自己写一个mvc框架吧

自己写一个mvc框架吧 733 阅读 0 评论 0 点赞

自己写一个mvc框架吧

自己写代码的习惯

写一个框架吧，如果这个框架会用到一些配置上的东西，我自己习惯是先不用考虑这个配置文件应该是怎样的，什么形式的，先用一个java对象（比如叫 Config.java）都给放进去。等到功能写的差不多了，需要考虑到使用配置文件了，就可以写一个工厂类，根据不同的配置（可能是xml，可能是json，甚至是注解）把刚才说的 Config.java 对象生成出来。

现在开始写～

我们先写URL与Method的映射关系

装模做样的分析一下

因为一个mvc的框架个人感觉主要做的事情就是通过http请求调用java中的方法。首先要做的就是怎样把一个请求地址和一个java中的方法绑定起来，使其形成一个对应关系。另外请求也是分请求类型的，比如get，post等等，所以还需要请求类型。

其次，要通过java的反射执行这个方法的话，还需要这个Method的所属Class的实例对象。

最后，因为这个方法是要通过http调用的，我们需要知道这个Method中的入参有哪些，每个参数是什么类型的，之后才能从每一次的请求中找到相应的参数，并转换成为对应的java类型。所以我们还需要每个参数的参数名称。

最终我们需要的是：

一个URL地址
对应的请求类型
一个Method对象
Method所属Class的实例对象
Method的入参参数名称
Method的入参参数类型，以Class形式存在

创建一个描述映射的类 UrlMethodMapping

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
import java.lang.reflect.Method;
/**
 * 一个请求Url到Method的映射
 *
 * @author hjx
 */
@ToString
@Setter
@Getter
public class UrlMethodMapping {
 /**
 * 请求地址
 */
 private String url;
 /**
 * 请求类型
 */
 private RequestType[] requestTypes;
 /**
 * 请求方法所属class实例
 */
 private Object object;
 /**
 * method的所属class
 */
 private Class objectClass;
 /**
 * url 对应的method
 */
 private Method method;
 /**
 * method 的入参名称
 * 顺序要保持一致
 */
 private String[] paramNames;
 /**
 * method 的入参类型
 * 顺序要保持一致
 */
 private Class[] paramClasses;
}

这里我没有写 getter和setter，是因为我用了一个叫做lombok的工具，很好用大家搜一下就知道怎么用了。

在上面的代码中有一个属性 RequestType[] requestTypes 这是一个枚举，主要是用来说明这个映射支持那些请求方式的。

现在将UrlMethodMapping数据填充起来

我在这里写了一个工厂类，提供了一个方法来组装UrlMethodMapping 这个对象：

/**
 * @param url 请求地址
 * @param requestTypes http请求方式
 * @param objectClass 实例对象的Class
 * @param method url对应的方法
 * @param paramClasses 请求参数类型
 * @return
 */
public UrlMethodMapping getUrlMethodMapping(
 String url, RequestType[] requestTypes, Class objectClass, Method method, Class[] paramClasses
) {
 Assert.notNull(url, URL + NOT_FIND);
 Assert.notNull(requestTypes, REQUEST_TYPE + NOT_FIND);
 Assert.isTrue(requestTypes.length > 0, REQUEST_TYPE + NOT_FIND);
 Assert.notNull(objectClass, CLASS + NOT_FIND);
 Assert.notNull(method, METHOD + NOT_FIND);
 Assert.notNull(paramClasses, PARAM_TYPES + NOT_FIND);
 //class实例化对象
 Object object = objectFactory.getObject(objectClass);
 Assert.notNull(object, "objectFactory.getObject() 获取失败！objectClass：" + objectClass.getName());
 //获取参数名称
 String[] paramNames = paramNameGetter.getParamNames(method);
 Assert.notNull(paramNames, "paramNameGetter.getParamNames() 执行失败！method：" + method.getName());
 Assert.isTrue(paramNames.length == paramClasses.length, "方法名称取出异常 method：" + method.getName());
 //组装参数
 UrlMethodMapping mapping = new UrlMethodMapping();
 mapping.setMethod(method);
 mapping.setUrl(url);
 mapping.setRequestTypes(requestTypes);
 mapping.setObject(object);
 mapping.setParamClasses(paramClasses);
 mapping.setObjectClass(objectClass);
 mapping.setParamNames(paramNames);
 return mapping;
}

在这个方法里，我用自己写的一个断言的工具类 Assert 来校验参数是否是正确的，如果参数不正确的话就会抛出异常信息。这段代码基本上是这个样子：

public static void notNull(Object obj, String msg) {
 if (obj == null) {
 throw new RuntimeException(msg);
 }
}

这段程序中还有两个对象：

1：objectFactory

是一个接口，主要用于通过Class 来获取到实例化的对象，这里需要使用者自己实现。目的是为了和其他的 IOC框架进行集成。比如在这个接口里可以通过从Spring容器中获取实例化的对象。

2：paramNameGetter

还是一个接口，主要用于从Method中获取入参的名称，我在这里提供了一个实现类，是通过 asm 来获取的。也可以再写一个通过注解获取参数名称的实现类。我在这里用的是asm。

怎样使用asm获取参数名称呢？

首先我们要添加asm的依赖

<dependency>
 <groupId>org.ow2.asm</groupId>
 <artifactId>asm</artifactId>
 <version>7.0</version>
</dependency>

这里我们主要用到asm中的

1：ClassReader 的

public void accept(
 final ClassVisitor classVisitor, //一个ClassVisitor对象
 final int parsingOptions //在访问类时必须解析的属性原型
){
 ... 
}

这个类要求我们在构造函数中传入class的全限定名称，就是class.getName();

2：ClassVisitor.java 的

public MethodVisitor visitMethod(
 final int access,//方法的访问标志
 final String name,//方法的名称
 final String descriptor,//方法的描述符
 final String signature,//方法的签名
 final String[] exceptions//方法的异常类的内部名称
){
 ...
}

这个方法会在执行classReader.accept()的时候被执行。返回值是一个MethodVisitor

3：MethodVisitor.java的

public void visitLocalVariable(
 final String name,//局部变量的名称
 final String descriptor,//局部变量的类型描述符
 final String signature,//此局部变量的类型签名
 final Label start,//对应于此局部变量范围的第一条指令
 final Label end,//对应于此局部变量范围的最后一条指令
 final int index//局部变量的索引
){
 ...
}

这个方法会在methodVisitor.visitMethod()中被执行，没有返回值。我们需要的Method的入参名称就是在这里获取的。

因为这两个类是将整个Class的方法都扫描一遍，所以我们需要自己写两个类来继承它，在里面添加我们需要的逻辑。代码如下：

MethodParamNameClassVisitor.java

import org.objectweb.asm.*;
import java.util.List;
/**
 * asm class访问器
 * 用于提取方法的实际参数名称
 *
 * @author hjx
 */
public class MethodParamNameClassVisitor extends ClassVisitor {
 /**
 * 方法的参数名称
 */
 private List<String> paramNames;
 /**
 * 方法的名称
 */
 private String methodName;
 /**
 * 方法的参数类型
 */
 private Class[] patamTypes;
 @Override
 public MethodVisitor visitMethod(
 int access, String name, String descriptor, String signature, String[] exceptions
 ) {
 MethodVisitor visitMethod = super.visitMethod(access, name, descriptor, signature, exceptions);
 boolean sameMethod = sameMethod(name, methodName, descriptor, patamTypes);
 //如果是相同的方法, 执行取参数名称的操作
 if (sameMethod) {
 MethodParamNameMethodVisitor paramNameMethodVisitor = new MethodParamNameMethodVisitor(
 Opcodes.ASM4, visitMethod
 );
 paramNameMethodVisitor.paramNames = this.paramNames;
 paramNameMethodVisitor.paramLength = this.patamTypes.length;
 return paramNameMethodVisitor;
 }
 return visitMethod;
 }
 /**
 * 是否是相同的方法
 *
 * @param methodName
 * @param methodName2
 * @param descriptor
 * @param paramTypes
 * @return
 */
 private boolean sameMethod(String methodName, String methodName2, String descriptor, Class[] paramTypes) {
 //方法名相同
 Assert.notNull(methodName);
 Assert.notNull(methodName2);
 if (methodName.equals(methodName2)) {
 Type[] argumentTypes = Type.getArgumentTypes(descriptor);
 //参数长度相同
 if (argumentTypes.length == paramTypes.length) {
 //参数类型相同
 for (int i = 0; i < argumentTypes.length; i++) {
 if (!Type.getType(paramTypes[i]).equals(argumentTypes[i])) {
 return false;
 }
 }
 return true;
 }
 }
 return false;
 }
 /**
 * @param paramNames 取出的参数名称，传入一个空的集合
 * @param methodName 目标方法名称
 * @param patamTypes 目标方法的参数类型
 */
 public MethodParamNameClassVisitor(List<String> paramNames, String methodName, Class[] patamTypes) {
 super(Opcodes.ASM4);
 this.paramNames = paramNames;
 this.methodName = methodName;
 this.patamTypes = patamTypes;
 }
 /**
 * 禁止的操作
 * 无法正确使用,抛出异常
 *
 * @param api
 */
 public MethodParamNameClassVisitor(int api) {
 super(api);
 throw new RuntimeException("不支持的操作, 请使用构造函数:MethodParamNameClassVisitor(List<String> paramNames, int patamLength) !");
 }
}
/**
 * 用于取出方法的参数实际名称
 */
class MethodParamNameMethodVisitor extends MethodVisitor {
 /**
 * 方法的参数名称
 */
 List<String> paramNames;
 /**
 * 方法的参数长度
 */
 int paramLength;
 @Override
 public void visitLocalVariable(
 String name, String descriptor, String signature, Label start, Label end, int index
 ) {
 super.visitLocalVariable(name, descriptor, signature, start, end, index);
 //index 为0 时, name是this
 //根据方法实际参数长度截取参数名称
 if (index != 0 && paramNames.size() < paramLength) {
 paramNames.add(name);
 }
 }
 public MethodParamNameMethodVisitor(int api, MethodVisitor methodVisitor) {
 super(api, methodVisitor);
 }
}

这个类里，因为继承父类之后必须要实现一个带参数的构造方法：

public MethodParamNameClassVisitor(int api){
 super(api);
}

但是这个方法我不想用它，就在方法结束后抛了一个异常出来。并新写了一个构造方法：

/**
 * @param paramNames 取出的参数名称，传入一个空的集合
 * @param methodName 目标方法名称
 * @param patamTypes 目标方法的参数类型
 */
public MethodParamNameClassVisitor(
 List<String> paramNames,
 String methodName,
 Class[] patamTypes
) {
 super(Opcodes.ASM4);
 this.paramNames = paramNames;
 this.methodName = methodName;
 this.patamTypes = patamTypes;
}

其中paramNames传入一个空集合（不是null），在方法执行完毕后会在里面添加方法的入参名称。

这个类是这么用的（下面的代码就是上面说道的paramNameGetter的一个实现）：

/**
 * 通过asm获取method的入参名称
 *
 * @param method
 * @return
 */
@Override
public String[] getParamNames(Method method) {
 Assert.notNull(method);
 Class aClass = method.getDeclaringClass();
 Parameter[] parameters = method.getParameters();
 String methodName = method.getName();
 String className = aClass.getName();
 ClassReader classReader = null;
 try {
 classReader = new ClassReader(className);
 } catch (IOException e) {
 e.printStackTrace();
 }
 Class[] paramClasses = new Class[parameters.length];
 for (int i = 0; i < paramClasses.length; i++) {
 paramClasses[i] = parameters[i].getType();
 }
 //暂存参数名称
 List<String> paramNameList = new ArrayList<>();
 MethodParamNameClassVisitor myClassVisitor = new MethodParamNameClassVisitor(
 paramNameList, methodName, paramClasses
 );
 classReader.accept(myClassVisitor, 0);
 return paramNameList.toArray(new String[]{});
}

现在。映射关系UrlMethodMapping中的数据就全部填充好了。

点赞(0) 打赏

本文分类：菜鸟教程
本文标签：无
浏览次数：733 次浏览
发布日期：2021-08-16 09:25:05
本文链接：https://www.eruiyi.cn/cms/cainiaojiaocheng/28494.html

上一篇 > 一篇文章让你彻底了解 MVC、MVP 、MVVM
下一篇 > 设计模式中的三好学生:MVC模式

评论列表共有 0 条评论

暂无评论

发表评论取消回复

热门产品
查看更多

历史上的今天：04月20日

ThinkPHP5快速入门

ThinkPHP5快速入门目录零、序言一、基础二、URL和路由三、请求和响应四、数据库五、查询语言六、模型和关联 (1)模型定义 (2)基础操作 (3)读取器和修改器 (4)类型转换和自动完成 (5)查询范围 (6)输入和验证 (7)关联 (8)模型输出七、视图和模板八、调试和日志九、API开发十、命令行工具十一、扩展十二、杂项SessionCookie验证

菜鸟教程 2023年04月20日 0 点赞 0 评论 207 浏览

ThinkPHP5快速入门基础

ThinkPHP5快速入门基础一、基础快速入门 ( 一 ) ：基础本章介绍了 ThinkPHP5 .0 的安装及基本使用，并给出了一个最简单的示例带你了解如何开始开发，主要包含：简介官网下载 omposer安装和更新CGit下载和更新目录结构运行环境入口文件调试模式控制器视图读取数据总结在学习 ThinkPHP5.0 之前，如果你还不理解面向对象和命名空间的概念，建议首先去PHP手册恶

菜鸟教程 2023年04月20日 0 点赞 0 评论 123 浏览