纯手写实现Spring MVC

代码实现

annotation

@CustomizeAutowired

package com.liubin.springmvc.annotation;

import java.lang.annotation.*;

/**
 * 〈功能详细描述〉自定义Controller注解
 *
 * @author 刘斌
 * @date 2020/3/8
 * @see [相关类/方法]（可选）
 * @since [产品/模块版本] （可选）
 */
@Target(ElementType.FIELD)//@Target代表当前注解在哪些地方可以使用，自定义的注解作用范围，只能作用在字段或者说成员变量上面
@Retention(RetentionPolicy.RUNTIME)//运行时通过反射来获取注解的相关信息
@Documented//当前自定义的注解可以包含在javadoc里
public @interface CustomizeAutowired {
    String value() default "";//自定义的@CustomizeController()注解，括号里面可能会传值进去，默认是"";
}

@CustomizeController

package com.liubin.springmvc.annotation;

import java.lang.annotation.*;

/**
 * 〈功能详细描述〉自定义Controller注解
 *
 * @author 刘斌
 * @date 2020/3/8
 * @see [相关类/方法]（可选）
 * @since [产品/模块版本] （可选）
 */
@Target(ElementType.TYPE)//@Target代表当前注解在哪些地方可以使用，自定义的注解作用范围，只能作用在类上面
@Retention(RetentionPolicy.RUNTIME)//运行时通过反射来获取注解的相关信息
@Documented//当前自定义的注解可以包含在javadoc里
public @interface CustomizeController {
    String value() default "";//自定义的@CustomizeController()注解，括号里面可能会传值进去，默认是"";
}

@CustomizeRequestMapping

package com.liubin.springmvc.annotation;

import java.lang.annotation.*;

/**
 * 〈功能详细描述〉自定义Controller注解
 *
 * @author 刘斌
 * @date 2020/3/8
 * @see [相关类/方法]（可选）
 * @since [产品/模块版本] （可选）
 */
@Target({ElementType.METHOD, ElementType.TYPE})//@Target代表当前注解在哪些地方可以使用，自定义的注解作用范围，只能作用在方法和类上面
@Retention(RetentionPolicy.RUNTIME)//运行时通过反射来获取注解的相关信息
@Documented//当前自定义的注解可以包含在javadoc里
public @interface CustomizeRequestMapping {
    String value() default "";//自定义的@CustomizeController()注解，括号里面可能会传值进去，默认是"";
}

@CustomizeRequestParam

package com.liubin.springmvc.annotation;

import java.lang.annotation.*;

/**
 * 〈功能详细描述〉自定义Controller注解
 *
 * @author 刘斌
 * @date 2020/3/8
 * @see [相关类/方法]（可选）
 * @since [产品/模块版本] （可选）
 */
@Target(ElementType.PARAMETER)//@Target代表当前注解在哪些地方可以使用，自定义的注解作用范围，只能作用在方法里的参数里面
@Retention(RetentionPolicy.RUNTIME)//运行时通过反射来获取注解的相关信息
@Documented//当前自定义的注解可以包含在javadoc里
public @interface CustomizeRequestParam {
    String value() default "";//自定义的@CustomizeController()注解，括号里面可能会传值进去，默认是"";
}

@CustomizeService

package com.liubin.springmvc.annotation;

import java.lang.annotation.*;

/**
 * 〈功能详细描述〉自定义Controller注解
 *
 * @author 刘斌
 * @date 2020/3/8
 * @see [相关类/方法]（可选）
 * @since [产品/模块版本] （可选）
 */
@Target(ElementType.TYPE)//@Target代表当前注解在哪些地方可以使用，自定义的注解作用范围，只能作用在类上面
@Retention(RetentionPolicy.RUNTIME)//运行时通过反射来获取注解的相关信息
@Documented//当前自定义的注解可以包含在javadoc里
public @interface CustomizeService {
    String value() default "";//自定义的@CustomizeController()注解，括号里面可能会传值进去，默认是"";
}

service

UserService.java

package com.liubin.springmvc.service;

import com.liubin.springmvc.entity.User;

/**
 * 〈功能详细描述〉
 *
 * @author 刘斌
 * @date 2020/3/8
 * @see [相关类/方法]（可选）
 * @since [产品/模块版本] （可选）
 */
public interface UserService {
    public User getUser(String id);
}

   impl

   UserServiceImpl.java

package com.liubin.springmvc.service.impl;

import com.liubin.springmvc.annotation.CustomizeService;
import com.liubin.springmvc.entity.User;
import com.liubin.springmvc.service.UserService;

/**
 * 〈功能详细描述〉
 *
 * @author 刘斌
 * @date 2020/3/8
 * @see [相关类/方法]（可选）
 * @since [产品/模块版本] （可选）
 */
@CustomizeService("userServiceImpl")
public class UserServiceImpl implements UserService {
    @Override
    public User getUser(String id) {
        User user = new User();
        user.setId(id);
        user.setName("liu bin");
        user.setAge(28);
        user.setGender("M");
        return user;
    }
}

controller

UserController.java

package com.liubin.springmvc.controller;

import com.liubin.springmvc.annotation.CustomizeAutowired;
import com.liubin.springmvc.annotation.CustomizeController;
import com.liubin.springmvc.annotation.CustomizeRequestMapping;
import com.liubin.springmvc.annotation.CustomizeRequestParam;
import com.liubin.springmvc.entity.User;
import com.liubin.springmvc.service.UserService;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;

/**
 * 〈功能详细描述〉
 *
 * @author 刘斌
 * @date 2020/3/8
 * @see [相关类/方法]（可选）
 * @since [产品/模块版本] （可选）
 */
@CustomizeController
@CustomizeRequestMapping("/userController")
public class UserController {
    @CustomizeAutowired("userServiceImpl")
    private UserService userService;

    @CustomizeRequestMapping("/getUser")
    public void queryUser(HttpServletRequest request, HttpServletResponse response, @CustomizeRequestParam("id") String id) {
        PrintWriter printWriter;
        try {
            printWriter = response.getWriter();
            User user = userService.getUser(id);
            printWriter.write(user.toString());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

servlet

CustomizeDispatcherServlet.java

package com.liubin.springmvc.servlet;

import com.liubin.springmvc.annotation.*;
import com.liubin.springmvc.controller.UserController;

import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.File;
import java.io.IOException;
import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 〈功能详细描述〉
 *
 * @author 刘斌
 * @date 2020/3/8
 * @see [相关类/方法]（可选）
 * @since [产品/模块版本] （可选）
 */
public class CustomizeDispatcherServlet extends HttpServlet {
    List<String> classNames = new ArrayList<>();
    Map<String, Object> beans = new HashMap<>();
    Map<String, Object> handlerMap = new HashMap<>();

    @Override
    public void init(ServletConfig config) throws ServletException {
        doScan("com.liubin");
        doInstance();
        doAutowired();
        doUrlHandleMapping();
    }

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doPost(req, resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String requestURI = req.getRequestURI();
        String contextPath = req.getContextPath();
        String path = requestURI.replace(contextPath, "");
        UserController instance = (UserController) beans.get("/" + path.split("/")[1]);
        Method method = (Method) handlerMap.get(path);
        Object[] args = handle(req, resp, method);
        try {
            method.invoke(instance, args);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }

    public void doScan(String basePackage) {
        URL url = this.getClass().getClassLoader().getResource("/" + basePackage.replaceAll("\\.", "/"));
        String fileStr = url.getFile();
        File file = new File(fileStr);
        String[] filesStr = file.list();
        for (String path : filesStr) {
            File filePath = new File(fileStr + path);
            if (filePath.isDirectory()) {
                doScan(basePackage + "." + path);
            } else {
                classNames.add(basePackage + "." + filePath.getName());
            }
        }
    }

    public void doInstance() {
        for (String className : classNames) {
            String classPath = className.replace(".class", "");
            try {
                Class<?> clazz = Class.forName(classPath);
                if (clazz.isAnnotationPresent(CustomizeController.class)) {
                    Object value = clazz.newInstance();
                    CustomizeRequestMapping customizeRequestMapping = clazz.getAnnotation(CustomizeRequestMapping.class);
                    String key = customizeRequestMapping.value();
                    beans.put(key, value);
                } else if (clazz.isAnnotationPresent(CustomizeService.class)) {
                    Object value = clazz.newInstance();
                    CustomizeService customizeService = clazz.getAnnotation(CustomizeService.class);
                    String key = customizeService.value();
                    beans.put(key, value);
                } else {
                    continue;
                }
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }
    }

    public void doAutowired() {
        for (Map.Entry<String, Object> entry : beans.entrySet()) {
            Object instance = entry.getValue();
            Class<?> clazz = instance.getClass();
            if (clazz.isAnnotationPresent(CustomizeController.class)) {
                Field[] declaredFields = clazz.getDeclaredFields();
                for (Field field : declaredFields) {
                    if (field.isAnnotationPresent(CustomizeAutowired.class)) {
                        CustomizeAutowired customizeAutowired = field.getAnnotation(CustomizeAutowired.class);
                        String key = customizeAutowired.value();
                        Object value = beans.get(key);
                        //把值塞进private声明的字段里
                        field.setAccessible(true);
                        try {
                            field.set(instance, value);
                        } catch (IllegalAccessException e) {
                            e.printStackTrace();
                        }
                    } else {
                        continue;
                    }
                }
            }
        }
    }

    public void doUrlHandleMapping() {
        for (Map.Entry<String, Object> entry : beans.entrySet()) {
            Object instance = entry.getValue();
            Class<?> clazz = instance.getClass();
            if (clazz.isAnnotationPresent(CustomizeController.class)) {
                CustomizeRequestMapping requestMapping = clazz.getAnnotation(CustomizeRequestMapping.class);
                String classPath = requestMapping.value();
                Method[] methods = clazz.getMethods();
                for (Method method : methods) {
                    if (method.isAnnotationPresent(CustomizeRequestMapping.class)) {
                        CustomizeRequestMapping requestMapping2 = method.getAnnotation(CustomizeRequestMapping.class);
                        String methodPath = requestMapping2.value();
                        handlerMap.put(classPath + methodPath, method);
                    } else {
                        continue;
                    }
                }
            } else {
                continue;
            }
        }
    }

    private Object[] handle(HttpServletRequest req, HttpServletResponse resp, Method method) {
        //拿到当前待执行的方法有哪些参数
        Class<?>[] parameterTypes = method.getParameterTypes();
        //根据参数的个数，实例化一个参数数组，将方法里的所有参数赋值到args
        Object[] args = new Object[parameterTypes.length];
        int args_i = 0;
        int index = 0;
        for (Class<?> paramClazz : parameterTypes) {
            if (ServletRequest.class.isAssignableFrom(paramClazz)) {
                args[args_i++] = req;
            }
            if (ServletResponse.class.isAssignableFrom(paramClazz)) {
                args[args_i++] = resp;
            }
            Annotation[] paramAns = method.getParameterAnnotations()[index];
            if (paramAns.length > 0) {
                for (Annotation paramAn : paramAns) {
                    if (CustomizeRequestParam.class.isAssignableFrom(paramAn.getClass())) {
                        CustomizeRequestParam rp = (CustomizeRequestParam) paramAn;
                        args[args_i++] = req.getParameter(rp.value());
                    }
                }
            }
            index++;
        }
        return args;
    }
}