实现一个简易版的SpringMvc框架

先来看我们的程序入口DispatcherServlet

主要核心处理流程如下：

1 扫描基础包下的带有controller 以及 service注解的class，并保存到list中

2 对第一步扫描到的class进行实例化操作

3 对第一步扫描到的class中带有AutoWired注解的属性值进入自动注入

4 建立url和方法，方法对应的controller的映射关系（使用map）

 

 

当以上准备工作完成以后，

 

用户提交请求，服务器获取url 并在第4步建立的映射关系中查找

 

找到了，就执行相关方法，找不到 就报404错误

 

以下是核心代码

 

几个自定义注解

 

 

@Target({ElementType.FIELD})  

 

@Retention(RetentionPolicy.RUNTIME)  

 

@Documented  

 

public @interface Autowired {  

 

    String value() default "";  

 

}  

 

 

 

@Target({ElementType.TYPE})  

 

@Retention(RetentionPolicy.RUNTIME)  

 

@Documented  

 

public @interface Controller {  

 

  

 

    String value() default "";  

 

}

 

 

 

@Target({ElementType.TYPE, ElementType.METHOD})  

 

@Retention(RetentionPolicy.RUNTIME)  

 

@Documented  

 

public @interface RequestMapping {  

 

    String value() default "";  

 

}  

 

 

@Target({ElementType.PARAMETER})  

 

@Retention(RetentionPolicy.RUNTIME)  

 

@Documented  

 

public @interface RequestParam {  

 

    String value() default "";  

 

  

 

    boolean required() default true;  

 

}  

 

 

@Target({ElementType.TYPE})  

 

@Retention(RetentionPolicy.RUNTIME)  

 

@Documented  

 

public @interface Service {  

 

    String value() default "";  

 

}  

================================================================================

 

 

帮助类

 

需要自行引入

 

Pom位置

 

<dependency>
<groupId>org.objectweb.asm</groupId>
<artifactId>org.objectweb.asm</artifactId>
<version>3.3</version>
</dependency>

　　

 

 

public class AsmUtil {
/**
* 获取指定类指定方法的参数名
*
* @param clazz
*
要获取参数名的class
* @param method
*
要获取参数名的方法
* @return 按参数顺序排列的参数名列表，如果没有参数，则返回null
*/
public static String[] getMethodParameterNamesByAsm4(final Class clazz, final Method method) {
final String methodName = method.getName();
final Class<?>[] methodParameterTypes = method.getParameterTypes();
final int methodParameterCount = methodParameterTypes.length;
String className = method.getDeclaringClass().getName();
final boolean isStatic = Modifier.isStatic(method.getModifiers());
final String[] methodParametersNames = new String[methodParameterCount];
int lastDotIndex = className.lastIndexOf(".");
className = className.substring(lastDotIndex + 1) + ".class";
InputStream is = clazz.getResourceAsStream(className);
try {
ClassReader cr = new ClassReader(is);
ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
cr.accept(new ClassAdapter(cw) {
public MethodVisitor visitMethod(int access, String name, String desc, String signature,
String[] exceptions) {
MethodVisitor mv = super.visitMethod(access, name, desc, signature, exceptions);
final Type[] argTypes = Type.getArgumentTypes(desc);
// 参数类型不一致
if (!methodName.equals(name) || !matchTypes(argTypes, methodParameterTypes)) {
return mv;
}
return new MethodAdapter(mv) {
public void visitLocalVariable(String name, String desc, String signature, Label start,
Label end, int index) {
// 如果是静态方法，第一个参数就是方法参数，非静态方法，则第一个参数是 this ,然后才是方法的参数
int methodParameterIndex = isStatic ? index : index - 1;
if (0 <= methodParameterIndex && methodParameterIndex < methodParameterCount) {
methodParametersNames[methodParameterIndex] = name;
}
super.visitLocalVariable(name, desc, signature, start, end, index);
}
};
}
}, 0);
} catch (Exception e) {
e.printStackTrace();
}
return methodParametersNames;
}
/**
* 比较参数是否一致
*/
private static boolean matchTypes(Type[] types, Class<?>[] parameterTypes) {
if (types.length != parameterTypes.length) {
return false;
}
for (int i = 0; i < types.length; i++) {
if (!Type.getType(parameterTypes[i]).equals(types[i])) {
return false;
}
}
return true;
}
}

　　

核心控制器

public class DispatcherServlet extends HttpServlet {
/**
*
*/
private static final long serialVersionUID = -8630585768835454263L;
// 保存含有controller或者service注解的class名字
private List<String> classNames = new ArrayList<>();
// 保存含有实例化对象
private Map<String, Object> instancesMap = new HashMap<>();
// 保存url和url对应的方法以及controller的映射关系
private Map<String, UrlMethodMappingModel> handlerMapping = new HashMap<>();
public void init(ServletConfig config) throws ServletException {
// 1 扫描基础包下的所有controller 以及 service
scanBasePackage(config.getInitParameter("basePackage"));
try {
// 2 实例化list中的对象 并且保存到map中
instanceClass();
// 3 注入使用了autowired的注解的属性
doAutoWired();
// 4建立 url和方法的映射
urlAndMethodMapping();
} catch (Exception e) {
e.printStackTrace();
}
}
private void urlAndMethodMapping() {
for (Map.Entry<String, Object> entry : instancesMap.entrySet()) {
Class<?> clazz = entry.getValue().getClass();
// 只处理Controller的，只有Controller有RequestMapping
if (!clazz.isAnnotationPresent(Controller.class)) {
continue;
}
// 定义url
StringBuffer urlBuffer = new StringBuffer();
urlBuffer.append("/");
if (clazz.isAnnotationPresent(RequestMapping.class)) {
RequestMapping requestMapping = clazz.getAnnotation(RequestMapping.class);
urlBuffer.append(requestMapping.value());
}
// 获取方法上的RequestMapping
Method[] methods = clazz.getMethods();
// 只处理带RequestMapping的方法
for (Method method : methods) {
if (!method.isAnnotationPresent(RequestMapping.class)) {
break;
}
RequestMapping methodMapping = method.getAnnotation(RequestMapping.class);
// requestMapping.value()即是在requestMapping上注解的请求地址，不管用户写不写"/"，我们都给他补上
String realUrl = urlBuffer.append("/" + methodMapping.value()).toString();
// 替换掉多余的"/",因为有的用户在RequestMapping上写"/xxx/xx",有的不写，所以我们处理掉多余的"/"
realUrl = realUrl.replaceAll("/+", "/");
// -------获取访问url完整路径end
// ---获取方法的请求参数开始
// 获取所有的参数的注解，有几个参数就有几个annotation[]，空的话也会有一个数组
// 是数组的原因是，一个参数可以有多个注解……
Annotation[][] annotations = method.getParameterAnnotations();
// 由于后面的Method的invoke时，需要传入所有参数的值的数组，所以需要保存各参数的位置
Map<String/* 参数名 如 name */, Integer/* 参数下标位置 */> paramMap = new HashMap<>();
// 获取方法里的所有参数的参数名（注意：此处使用了ASM.jar
// 如TestController 的test(String name, HttpServletResponse
// reponse)，将得到如下数组["name","reponse"]
String[] paramNames = AsmUtil.getMethodParameterNamesByAsm4(clazz, method);
// 获取所有参数的类型
Class<?>[] paramTypes = method.getParameterTypes();
for (int i = 0; i < annotations.length; i++) {
Annotation[] annotationArray = annotations[i];
if (annotationArray.length == 0) // 就是当前参数没有使用注解 （String
// name ）
{
Class<?> type = paramTypes[i];
if (type == HttpServletRequest.class || type == HttpServletResponse.class) {
paramMap.put(type.getName(), i);
} else { // 普通属性
paramMap.put(paramNames[i], i);
}
}
// 有注解，就遍历每个参数上的所有注解
for (Annotation annotation : annotationArray) {
if (annotation.annotationType() == RequestParam.class) {
String paramValue = ((RequestParam) annotation).value();
if (!"".equals(paramValue)) {
paramMap.put(paramValue, i);
break;
}
}
}
}
UrlMethodMappingModel model = new UrlMethodMappingModel(method, entry.getValue(), paramMap);
handlerMapping.put(realUrl, model);
}
}
}
private void doAutoWired() {
// 遍历instancesMap中被托管的对象
for (Map.Entry<String, Object> entry : instancesMap.entrySet()) {
// 查找所有被Autowired注解的属性
Field[] fieldArray = entry.getValue().getClass().getDeclaredFields();
for (Field field : fieldArray) {
// 没有使用Autowired注解
if (!field.isAnnotationPresent(Autowired.class)) {
continue;
}
Autowired autowired = field.getAnnotation(Autowired.class);
if ("".equals(autowired.value())) {
field.setAccessible(true);
String beanName = lowerFirstChar(field.getType().getSimpleName());
if (instancesMap.get(beanName) != null) {
try {
field.set(entry.getValue(), instancesMap.get(beanName));
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
}
}
}
}
private void instanceClass() throws Exception {
if (classNames.size() == 0) {
return;
}
for (String className : classNames) {
try {
Class<?> clazz = Class.forName(className);
// 如果是controller 或者 service 直接使用类名
if (clazz.isAnnotationPresent(Controller.class)) {
instancesMap.put(lowerFirstChar(clazz.getSimpleName()), clazz.newInstance());
} else if (clazz.isAnnotationPresent(Service.class)) {
// 获取注解上的名字 如果有的话
// 获取注解上的值
Service service = clazz.getAnnotation(Service.class);
String servicename = service.value();
if (!"".equals(servicename)) {
instancesMap.put(lowerFirstChar(clazz.getSimpleName()), clazz.newInstance());
} else {
Class<?>[] interfaces = clazz.getInterfaces();
// 这里简单处理 假定ServiceImpl只实现了一个接口
for (Class<?> class1 : interfaces) {
instancesMap.put(lowerFirstChar(class1.getSimpleName()), clazz.newInstance());
break;
}
}
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
private void scanBasePackage(String basePackage) {
URL baseUrl = this.getClass().getClassLoader().getResource("/" + basePackage.replaceAll("\.", "/"));
File baseFile = new File(baseUrl.getFile());
File[] files = baseFile.listFiles();
for (File file : files) {
if (file.isDirectory()) { // 是目录
scanBasePackage(basePackage + "." + file.getName());
} else { // 是文件
if (!file.getName().endsWith(".class")) {
continue;
}
String className = basePackage + "." + file.getName().replace(".class", "");
// 获取该名字对应的的字节码对象 判断是不是含有Controller注解以及Service注解
try {
Class<?> clazz = Class.forName(className);
if (clazz.isAnnotationPresent(Controller.class) || clazz.isAnnotationPresent(Service.class)) {
classNames.add(className);
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
}
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
try {
// 匹配用户请求
boolean isPattern = patternUrlRequest(request, response);
if (!isPattern) {
out(response, "404 not found");
}
} catch (Exception e) {
e.printStackTrace();
}
}
private boolean patternUrlRequest(HttpServletRequest request, HttpServletResponse response) {
String url = request.getRequestURI();
String projectUrl = request.getContextPath();
url = url.replace(projectUrl, "").replaceAll("/+", "/");
UrlMethodMappingModel mappingModel = handlerMapping.get(url);
if (mappingModel != null) // 匹配成功
{
Map<String, Integer> paramsIndex = mappingModel.getParamMap();
Object[] values = new Object[paramsIndex.size()];
// 获取该方法的参数类型
Class<?>[] methodTypes = mappingModel.getMethod().getParameterTypes();
for (Map.Entry<String, Integer> params : paramsIndex.entrySet()) {
String key = params.getKey(); // 变量名
if (key.equals(HttpServletRequest.class.getName())) {
values[params.getValue()] = request;
} else if (key.equals(HttpServletResponse.class.getName())) {
values[params.getValue()] = response;
} else {
String userPostValue = request.getParameter(key);
Class<?> type = methodTypes[params.getValue()];
// 转换用户提交上来的数据
Object convertValue = convertValue(userPostValue, type);
values[params.getValue()] = convertValue;
}
}
// 激活该方法
try {
mappingModel.getMethod().invoke(mappingModel.getController(), values);
} catch (Exception e) {
e.printStackTrace();
}
return true;
} else {
return false;
}
}
private Object convertValue(String userPostValue, Class<?> type) {
if (type == String.class) {
return userPostValue;
} else if (type == Integer.class || type == int.class) {
return Integer.parseInt(userPostValue);
} else if (type == Long.class || type == long.class) {
return Long.valueOf(userPostValue);
} else {
try {
throw new Exception("不支持的数据类型");
} catch (Exception e) {
e.printStackTrace();
}
}
return null;
}
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
// 首字母小写
private String lowerFirstChar(String className) {
char[] chars = className.toCharArray();
chars[0] += 32;
return String.valueOf(chars);
}
private void out(HttpServletResponse response, String str) {
try {
response.setContentType("application/json;charset=utf-8");
response.getWriter().print(str);
} catch (IOException e) {
e.printStackTrace();
}
}
private class UrlMethodMappingModel {
private Method method;
private Object controller;
private Map<String/* 参数名 */, Integer/* 下标位置 */> paramMap;
public Method getMethod() {
return method;
}
public Object getController() {
return controller;
}
public Map<String, Integer> getParamMap() {
return paramMap;
}
public UrlMethodMappingModel(Method method, Object controller, Map<String, Integer> paramMap) {
this.method = method;
this.controller = controller;
this.paramMap = paramMap;
}
}
}

　　

测试Controller 

@Controller
public class TestController {
@Autowired
ITestService testServ;
@RequestMapping(value = "/testAdd")
public void testAdd(@RequestParam("name") String name, HttpServletResponse reponse) {
String result = testServ.add(name);
out(reponse, result);
}
@RequestMapping(value = "/test")
public void test(String name, HttpServletResponse reponse) {
String result = testServ.add(name+" *** ");
out(reponse, result);
}
private void out(HttpServletResponse response, String str) {
try {
response.setContentType("application/json;charset=utf-8");
response.getWriter().print(str);
} catch (IOException e) {
e.printStackTrace();
}
}
}

　　

服务接口定义

public interface ITestService {
String add(String name);
}

服务接口实现

@Service
public class TestServImp implements ITestService {
@Override
public String add(String name) {
return "add " + name + " ";
}
}

　　运行结果如下

 

 总结：大体功能基本已经完成，如果想写出更多功能，建议阅读