简写SpringMVC初始化流程

痛定思痛。 2022-12-07 12:14 171阅读 0赞

1、SpringMVC和Spring是两个并列的项目。  
2、Spring是IOC和AOP的容器框架，SpringMVC是基于Spring功能之上添加的Web框架，想用SpringMVC必须先依赖Spring  
3、因此MVC可以获取Spring数据，反之则不可以

## SpringMVC 简单执行流程 ##

用户发起请求到前端控制器（DispatcherServlet）
    前端控制器会找到处理器映射器（HandlerMapping），通过HandlerMapping完成url到controller映射的组件
    执行处理器(Controller，也叫后端控制器)。
    处理器会返回一个ModelAndView对象给HandlerAdapter
    通过HandlerAdapter将ModelAndView对象返回给前端控制器(DispatcherServlet)
    DispatcherServlet将ModelAndView传给ViewReslover视图解析器
    ViewReslover解析后返回具体View
    DispatcherServlet对View进行渲染视图（即将模型数据填充至视图中）。

最近复习基础，看了别人写的类似的逻辑，理解之后自己又简单重写。

[git 项目地址][git]

## 项目结构 ##

自己创建了四个注解 ，供项目加载用 `Controller，RequestMapping，Service，Autowired`

import org.springframework.stereotype.Component;
    import java.lang.annotation.*;
    
    @Target({ ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Component
    public @interface Controller { 
        String value() default "";
    }
    
    import org.springframework.core.annotation.AliasFor;
    import org.springframework.web.bind.annotation.Mapping;
    
    import java.lang.annotation.*;
    
    /** * @desc ... */
    
    @Target({ ElementType.METHOD, ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Mapping
    public @interface RequestMapping { 
        String name() default "";
    
        @AliasFor("path")
        String[] value() default { };
    
        @AliasFor("value")
        String[] path() default { };
    }
    import org.springframework.stereotype.Component;
    
    import java.lang.annotation.*;
    
    /** * @desc ... */
    @Target({ ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Component
    public @interface Service { 
        String value() default "";
    }
    
    import java.lang.annotation.*;
    
    /** * @desc ... */
    @Target({ ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD, ElementType.ANNOTATION_TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface Autowired { 
        boolean required() default true;
    
    }

创建了一个见简单的`Controller`

import main.annotation.Autowired;
    import main.annotation.Controller;
    import main.annotation.RequestMapping;
    import main.service.TestService;
    
    /** * @desc ... */
    @Controller
    @RequestMapping("/v1")
    public class TestController { 
    
        @Autowired
        private TestService testService;
    
        @RequestMapping("/teMethod")
        public void teMethod(){ 
            testService.say();
        }
    
        @RequestMapping("")
        public void index(){ 
            System.out.println("TestController.index");
        }
    }

一个被注入的`service`

import main.annotation.Service;
    
    /** * @desc ... */
    
    @Service
    public class TestService { 
    
        public void say(){ 
            System.out.println("test.haha");
        }
    }

***项目的核心`DispatcherServlet`类***

import main.annotation.Autowired;
    import main.annotation.Controller;
    import main.annotation.RequestMapping;
    import main.annotation.Service;
    import org.springframework.util.CollectionUtils;
    
    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.reflect.Field;
    import java.lang.reflect.Method;
    import java.net.URL;
    import java.util.LinkedList;
    import java.util.List;
    import java.util.Map;
    import java.util.Set;
    import java.util.concurrent.ConcurrentHashMap;
    /** * @desc ... */
    
    public class DispatcherServlet extends HttpServlet { 
        //封装扫描到的类
        private List<String> names = new LinkedList<>();
        //key : BeanName value : Bean
        private Map<String,Object> beans = new ConcurrentHashMap<>();
        //key : requestURL value : Request.index + Method.index
        private Map<String,Method> methods = new ConcurrentHashMap<>();
    
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { 
            String requestURI = req.getRequestURI();
            String contextPath = req.getContextPath();
            String path = requestURI.replace(contextPath, "");
            Method method = methods.get(path);
            try { 
                Object invoke = method.invoke(beans.get("/"+path.split("/")[1]), null);
    
            } catch (Exception e) { 
                e.printStackTrace();
            }
        }
    
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { 
            this.doGet(req, resp);
        }
    
        @Override
        public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException { 
            super.service(req, res);
        }
    	//继承了HttpServlet项目启动会自动启动
        @Override
        public void init() throws ServletException { 
            super.init();
            try { 
                // 扫描路径下所有class
                scanPackage("main");
                //将扫描到的类进行初始化
                initializeBean();
                //将 类里面的自动注入设置属性值，requestURL装配请求method
                adapterRequestPath();
            } catch (Exception e) { 
                e.printStackTrace();
            }
        }
    
        void adapterRequestPath() throws IllegalAccessException { 
            if(CollectionUtils.isEmpty(beans)){ 
                return;
            }
            Set<Map.Entry<String, Object>> entries = beans.entrySet();
            for ( Map.Entry<String, Object> obj:entries) { 
                Field[] declaredFields = obj.getValue().getClass().getDeclaredFields();
                for (Field fie:declaredFields) { 
                    //将注入对象 反射设置到对应的 属性对象
                    if(fie.isAnnotationPresent(Autowired.class)){ 
                        fie.getName();
                        fie.setAccessible(true);
                        fie.set(obj.getValue(),beans.get(fie.getName()));
                    }
                }
                Method[] declaredMethods = obj.getValue().getClass().getDeclaredMethods();
                for (Method meth:declaredMethods) { 
                    //将 Request.index + Method.index 拼接
                    if(meth.isAnnotationPresent(RequestMapping.class)){ 
                        RequestMapping annotation = meth.getAnnotation(RequestMapping.class);
                        String space = annotation.value()[0];
                        methods.put(obj.getKey()+space,meth);
                    }
                }
            }
        }
    
        private void initializeBean() throws Exception { 
            if(CollectionUtils.isEmpty(names)){ 
                return;
            }
            for (String name:names) { 
                Class<?> aClass = Class.forName(name);
                if(aClass.isAnnotationPresent(Controller.class)){ 
                    Object obj = aClass.newInstance();
                    RequestMapping annotation = aClass.getAnnotation(RequestMapping.class);
                    String name1 = annotation.value()[0];
                    beans.put(name1,obj);
                }
                if(aClass.isAnnotationPresent(Service.class)){ 
                    Object obj = aClass.newInstance();
                    String substring = aClass.getName().substring(aClass.getName().lastIndexOf(".") + 1, aClass.getName().length());
                    beans.put(toLowerFirstWord(substring),obj);
                }
            }
        }
    
        private void scanPackage(String main) { 
            URL resource = this.getClass().getClassLoader().getResource(main.replaceAll("\\.", "/"));
            String path = resource.getFile();
            File file = new File(path);
            File[] files = file.listFiles();
            for (File fil:files) { 
                if(fil.isDirectory()){ 
                    scanPackage(main+"."+fil.getName());
                }else{ 
                    names.add(main+"."+fil.getName().replace(".class",""));
                }
            }
        }
    
        /** * 把字符串的首字母小写 * * @param name * @return */
        private String toLowerFirstWord(String name) { 
            char[] charArray = name.toCharArray();
            charArray[0] += 32;
            return String.valueOf(charArray);
        }
    
    }

自行在tomcat配置测试地址 eg:`127.0.0.1:8080/v1/teMethod`

[git]: https://github.com/JiPengL/TestMVC