一个类手写Spring核心原理

水深无声 2023-01-13 04:20 194阅读 0赞

Spring实现的基本思路

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x1Y2lmZXJsb25neHU_size_16_color_FFFFFF_t_70][]

通过DispatcherServlet一个类演示Spring核心原理

public class DispatcherServlet extends HttpServlet {
        // 保存用户配置的配置文件
        private Properties contextConfiguration = new Properties();
        // 保存扫描包下的所有类的全名
        private List<String> classNames = new ArrayList<String>();
        // ioc容器保存所有扫描到的类的实例对象
        private Map<String, Object> ioc = new HashMap<String, Object>();
        // 保存URL和method的对应关系
        private Map<String, Method> handlerMapping = new HashMap<String, Method>();
    
        @Override
        public void init(ServletConfig config) throws ServletException {
            // 1、加载配置文件
            doLoadConfig(config.getInitParameter("contextConfigLocation"));
            // 2、扫描相关的类
            doScanner(contextConfiguration.getProperty("scanPackage"));
            // 3、初始化IoC容器，将扫描到的类实例化，缓存到IoC容器
            doInstance();
            // 4、完成依赖注入
            doAutowired();
            // 5、初始化HandlerMapping
            initHandlerMapping();
            System.out.println("Spring framework is init.");
        }
    
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            this.doPost(req, resp);
        }
    
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            // 6、根据URL委派给具体的调用方法
            try {
                doDispatch(req, resp);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        private void doDispatch(HttpServletRequest req, HttpServletResponse resp) throws Exception {
            String url = req.getRequestURI();
            String contextPath = req.getContextPath();
            url = url.replaceAll(contextPath, ""); //获取相对路径
            if (!this.handlerMapping.containsKey(url)) {
                resp.getWriter().write("404 Not Found");
                return;
            }
            Method method = this.handlerMapping.get(url);
    
            //1、先把参数的位置参数名字建立映射关系，并且缓存下来
            Map<String, Integer> paramIndexMapping = new HashMap<String, Integer>();
            Annotation[][] parameterAnnotations = method.getParameterAnnotations();
            for (int i = 0; i < parameterAnnotations.length; i ++) {
                for (Annotation anno : parameterAnnotations[i]) {
                    if (anno instanceof MyRequestParam) {
                        String paraName = ((MyRequestParam) anno).value();
                        if (!"".equals(paraName.trim())) {
                            paramIndexMapping.put(paraName, i);
                        }
                    }
                }
            }
            Class<?>[] parameterTypes = method.getParameterTypes();
            for (int i = 0; i < parameterTypes.length; i ++) {
                Class<?> parameterType = parameterTypes[i];
                if (parameterType == HttpServletRequest.class || parameterType == HttpServletResponse.class) {
                    paramIndexMapping.put(parameterType.getName(), i);
                }
            }
            //2、根据参数位置匹配参数名字，从url中获取到参数名字对应的值
            Object[] paramValues = new Object[parameterTypes.length];
            Map<String, String[]> parameterMap = req.getParameterMap();
            for (Map.Entry<String, String[]> entry : parameterMap.entrySet()) {
                String key = entry.getKey();
                String[] values = entry.getValue();
                String value = Arrays.toString(values).replaceAll("\\[|\\]", "").replaceAll("\\s", "");
                if (!parameterMap.containsKey(key)) { continue; }
                int index = paramIndexMapping.get(key);
                // TODO 涉及到类型转换
                paramValues[index] = value;
            }
            if (paramIndexMapping.containsKey(HttpServletRequest.class.getName())) {
                paramValues[paramIndexMapping.get(HttpServletRequest.class.getName())] = req;
            }
            if (paramIndexMapping.containsKey(HttpServletResponse.class.getName())) {
                paramValues[paramIndexMapping.get(HttpServletResponse.class.getName())] = resp;
            }
            //3、组成动态参数列表，传给方法反射调用
            String beanName = toLowerCaseFirstChar(method.getDeclaringClass().getSimpleName());
            method.invoke(ioc.get(beanName), paramValues);
        }
    
        private void initHandlerMapping() {
            if (ioc.isEmpty()) { return; }
            for (Map.Entry<String, Object> entry : ioc.entrySet()) {
                Class<?> clazz = entry.getValue().getClass();
                if (!clazz.isAnnotationPresent(MyController.class)) { continue; }
                String controllerUrl = "";
                if (clazz.isAnnotationPresent(MyRequestMapping.class)) {
                    controllerUrl = clazz.getAnnotation(MyRequestMapping.class).value();
                }
                // 只迭代controller中的public方法
                for (Method method : clazz.getMethods()) {
                    if (!method.isAnnotationPresent(MyRequestMapping.class)) { continue; }
                    MyRequestMapping myRequestMapping = method.getAnnotation(MyRequestMapping.class);
                    String url = "/" + controllerUrl + "/" + myRequestMapping.value();
                    // 不确定用户声明的url路径前是否添加了/，所以暂时当做没有加/，最后通过正则将多个连续/替换成一个/
                    url = url.replaceAll("/+", "/");
                    handlerMapping.put(url, method);
                    System.out.println("Mapped" + url + " --> " + method);
                }
            }
        }
    
        // 自动注入
        private void doAutowired() {
            if (ioc.isEmpty()) { return; }
            for (Map.Entry<String, Object> entry : ioc.entrySet()) {
                Field[] declaredFields = entry.getValue().getClass().getDeclaredFields();
                for (Field field : declaredFields) {
                    if (!field.isAnnotationPresent(MyAutowired.class)) { continue; }
                    MyAutowired myAutowired = field.getAnnotation(MyAutowired.class);
                    String beanName = myAutowired.value().trim();//获取注解的别名
                    if ("".equals(beanName)) {//如果注解上没有起别名，那么就获取对象名
                        beanName = field.getType().getName();
                    }
                    // 强制访问赋值
                    field.setAccessible(true);
                    try {
                        // 相当于userController.userService=ioc.get("com.lucifer.project.service.UserService");
                        field.set(entry.getValue(), ioc.get(beanName));
                    } catch (IllegalAccessException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    
        // 实例化对象，并缓存到IoC容器中
        private void doInstance() {
            if (classNames.isEmpty()){ return; }
            try {
                for (String className : classNames) {
                    Class<?> clazz = Class.forName(className);
                    Object instance = clazz.newInstance();
                    if (clazz.isAnnotationPresent(MyController.class)) {
                        String beanName = toLowerCaseFirstChar(clazz.getSimpleName());
                        ioc.put(beanName, instance);
                    } else if (clazz.isAnnotationPresent(MyService.class)) {
                        // 1、默认类名首字母小写，取默认名
                        String beanName = toLowerCaseFirstChar(clazz.getSimpleName());
                        // 2、如果多个包下出现相同的类名，优先使用别名
                        MyService serviceAnno = clazz.getAnnotation(MyService.class);
                        if (!"".equals(serviceAnno.value())) {
                            beanName = serviceAnno.value();
                        }
                        // 3、如果是接口，只能吃实话它的实现类
                        for (Class<?> inte : clazz.getInterfaces()) {
                            if (ioc.containsKey(inte.getName())) {
                                throw new Exception("The" + inte.getName() + " is exists, please use alias.");
                            }
                            beanName = inte.getName();
                        }
                        ioc.put(beanName, instance);
                    } else {
                        continue;
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        // 将类名首字母转小写
        private String toLowerCaseFirstChar(String simpleName) {
            char[] chars = simpleName.toCharArray();
            chars[0] += 32; //利用ASCII码，大写字母和小写字母相差32
            return String.valueOf(chars);
        }
    
        // 扫描指定包下所有的Class文件
        private void doScanner(String scanPackage) {
            URL url = this.getClass().getClassLoader().getResource("/" + scanPackage.replaceAll("\\.", "/"));
            File classpath = new File(url.getFile());
            for (File file : classpath.listFiles()) {
                if (file.isDirectory()) {
                    doScanner(scanPackage + "." + file.getName() + ".");
                } else {
                    if (!file.getName().endsWith(".class")) { continue; }
                    // 包名.类名 比如com.lucifer.project.UserController
                    String className = scanPackage + file.getName().replace(".class", "");
                    // 实例化时需要通过Class.forName(className);
                    classNames.add(className);
                }
            }
        }
    
        // 根据contextConfigLocation路径去Classpath下找到对应配置文件
        private void doLoadConfig(String contextConfigLocation) {
            InputStream in = this.getClass().getClassLoader().getResourceAsStream(contextConfigLocation);
            try {
                contextConfiguration.load(in);
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (null != in) {
                    try {
                        in.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

自定义Spring注解类

@Target({ElementType.FIELD})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface MyAutowired {
        String value() default "";
    }
    
    @Target({ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface MyController {
        String value() default "";
    }
    
    @Target({ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface MyService {
        String value() default "";
    }
    
    @Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface MyRespository {
        String value() default "";
    }
    
    @Target({ElementType.TYPE, ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface MyRequestMapping {
        String value() default "";
    }
    
    @Target({ElementType.PARAMETER})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface MyRequestParam {
        String value() default "";
    }

测试用户请求访问类

@MyController
    @MyRequestMapping("/user")
    public class UserController {
        @MyAutowired
        UserService userService;
    
        @MyRequestMapping("/query")
        public void query(HttpServletRequest req, HttpServletResponse resp, @MyRequestParam("name") String name) {
            String result = "Hello, I am " + name;
            try {
                resp.getWriter().write(result);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

![20210418231124544.png][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x1Y2lmZXJsb25neHU_size_16_color_FFFFFF_t_70]: /images/20221022/65c1699d4e7e44a0852f0c4130e318b1.png
[20210418231124544.png]: /images/20221022/6882d5d8e261456f8be169fc7c5b6e2a.png