本身写一个mvc框架吧（二）

上一篇

本身写一个mvc框架吧（一）

本身写一个mvc框架吧（二）

项目地址在：github.com/hjx60149632… 。

测试代码在：github.com/hjx60149632… 。

本身写代码的习惯

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

如今开始写～

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

装模作样的分析一下

由于一个mvc的框架我的感受主要作的事情就是经过http请求调用java中的方法。首先要作的就是怎样把一个请求地址和一个java中的方法绑定起来，使其造成一个对应关系。另外请求也是分请求类型的，好比get，post等等，因此还须要请求类型。

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

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

最终咱们须要的是：

1. 一个URL地址
2. 对应的请求类型
3. 一个Method对象
4. Method所属Class的实例对象
5. Method的入参参数名称
6. 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中的数据就所有填充好了。

下一篇咱们开始写转换参数，并经过反射执行Method的代码。

拜拜～～～

完

下一篇

本身写一个mvc框架吧（三）