Error message here!

Hide Error message here!

忘记密码?

Error message here!

请输入正确邮箱

Hide Error message here!

密码丢失?请输入您的电子邮件地址。您将收到一个重设密码链接。

Error message here!

返回登录

Close

自己写一个java的mvc框架吧(二)

何白白 2019-01-31 10:37:00 阅读数:176 评论数:0 点赞数:0 收藏数:0

自己写一个mvc框架吧(二)

自己写代码的习惯

写一个框架吧,如果这个框架会用到一些配置上的东西,我自己习惯是先不用考虑这个配置文件应该是怎样的,什么形式的,先用一个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的代码。

拜拜~~~

版权声明
本文为[何白白]所创,转载请带上原文链接,感谢
https://www.cnblogs.com/hebaibai/p/10340884.html

编程之旅,人生之路,不止于编程,还有诗和远方。
阅代码原理,看框架知识,学企业实践;
赏诗词,读日记,踏人生之路,观世界之行;

支付宝红包,每日可领