手写简易版SpringMVC

爱被打了一巴掌 2023-07-20 12:19 75阅读 0赞

为了更好了Spring以及SpringMVC的核心原理，本文参考其他书籍实现了一个简易版的SpringMVC框架，框架的构建过程如下：

1.  创建个Maven工程，并在pom.xml文件中引入Servlet；
    
        <dependency>
          <groupId>javax.servlet</groupId>
          <artifactId>javax.servlet-api</artifactId>
          <version>4.0.1</version>
        </dependency>
2.  工程结构如下：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTg2MDE1_size_16_color_FFFFFF_t_70]
3.  在web.xml里配置前端控制器DispatcherServlet，用于拦截所有的请求，并在初始化参数里配置application.properties文件的路径

<servlet>
        <servlet-name>DispatcherServlet</servlet-name>
        <servlet-class>com.framework.servlet.DispatcherServlet</servlet-class>
        <init-param>
          <param-name>contextConfigLocation</param-name>
          <param-value>application.properties</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
      </servlet>
    
      <servlet-mapping>
        <servlet-name>DispatcherServlet</servlet-name>
        <url-pattern>/*</url-pattern> </servlet-mapping>

1.  application.properties文件中只填写包扫描路径即可

scanPackage=com.demo

1.  创建各种注解

@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 "";
    }

@Target({ ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface Service { 
    
        String value() default "";
    }

1.  创建一组业务处理逻辑，用DemoController接收请求并返回DemoService的处理结果给浏览器

@Controller
    @RequestMapping("/demo")
    public class DemoController { 
    
        @Autowired
        DemoService demoService;
    
        @RequestMapping("/query")
        public void query(HttpServletRequest request, HttpServletResponse response, @RequestParam("name") String name) throws IOException { 
            String result= demoService.get(name);
            response.getWriter().write(result);
        }
    
    }

public interface DemoService { 
    
        String get(String name);
    }

@Service
    public class DemoServiceImpl implements DemoService { 
        @Override
        public String get(String name)  { 
            return "My name is " + name;
        }
    }

1.  接下来是**重中之重**：**构造DispatcherServlet类**
    
    我们将在DispatcherServlet的init方法中进行：
    
    1.  加载配置文件
    2.  扫描所有的类
    3.  实例化所有单例Bean并放到IOC容器中
    4.  完成依赖注入
    5.  初始化HandlerMapping容器
    
    然后，因为本框架只对Get请求进行处理，所以只重写doGet方法。

具体过程如下：

1.  创建DispatcherServlet成员变量：

//加载application.properties配置文件中的内容
       private Properties contextConfig = new Properties();
    
       //保存扫描到的所有类名称
       private List<String> classNames = new ArrayList<>();
    
       //IOC容器，保存所有Bean实例
       private Map<String, Object> ioc = new HashMap<>();
    
       //handlerMapping容器，保存URL和Method的映射关系
       private Map<String, Method> handlerMapping = new HashMap<>();

1.  在DispatcherServlet中重写init方法并实现以下方法：

@Override
       public void init(ServletConfig config) { 
    
           //加载配置文件
           loadConfig(config.getInitParameter("contextConfigLocation"));
    
           //包扫描
           initScanner(contextConfig.getProperty("scanPackage"));
    
           //实例化扫描到的类，并放入到IOC容器中
           initBeans();
    
           //完成依赖注入
           initAutowired();
    
           //建立所有URL和Controller中方法的对应关系，并保存到HandlerMapping容器中
           initHandlerMapping();
       }

1.  实现loadConfig方法

private void loadConfig(String contextConfigLocation) { 
            //找到application.properties文件路径
            InputStream is = this.getClass().getClassLoader().getResourceAsStream(contextConfigLocation);
            //加载application.properties
            try { 
                contextConfig.load(is);
            } catch (IOException e) { 
                e.printStackTrace();
            } finally { 
                //关闭资源
                try { 
                    is.close();
                } catch (IOException e) { 
                    e.printStackTrace();
                }
            }
        }

1.  实现initScanner方法，扫描com.demo包以及子包的类，并将类的全限定名称保存起来，为initBean实例化这些类做准备；

private void initScanner(String scanPackage) { 
            //扫描com.demo包以及子包的类
            URL url = getClass().getClassLoader().getResource("/" + scanPackage.replaceAll("\\.", "/"));
            File classPath = new File(url.getFile());
            for (File file: classPath.listFiles()) { 
                if (file.isDirectory()) { 
                    initScanner(scanPackage + "." +file.getName());
                } else { 
                    if (!file.getName().endsWith(".class")) continue;
                    String className = scanPackage + "." + file.getName().replace(".class", "");
                    classNames.add(className);
                }
            }
        }

1.  通过遍历classNames中的路径名称，并以反射的方法实例化带有@Controller和@Service注解的类，最后把实例加入到IOC容器中；

private void initBeans() throws Exception { 
            if (classNames.isEmpty()) return;
            for (String className: classNames) { 
                Class<?> clazz = Class.forName(className);
                //加了注解的类才能初始化
                if (clazz.isAnnotationPresent(Controller.class)) { 
                    Object instance = clazz.newInstance();
                    ioc.put(clazz.getSimpleName(), instance);
                } else if (clazz.isAnnotationPresent(Service.class)) { 
                    Object instance = clazz.newInstance();
                    for (Class<?> i : clazz.getInterfaces()) { 
                        if (ioc.containsKey(i.getName())) { 
                            throw new RuntimeException(i.getName() + "已存在");
                        }
                        ioc.put(i.getName(), instance);
                    }
                } else { 
                    continue;
                }
            }
        }

1.  实现initAutowired方法，遍历IOC容器中所有的实例，找到实例中带有@Autowire注解的成员变量，这些成员变量都是对象的引用，还没用进行赋值，所以用反射的方法将这些变量进行引用赋值。

private void initAutowired() throws IllegalAccessException { 
            if (ioc.isEmpty()) return;
            for (Map.Entry<String, Object> entry: ioc.entrySet()) { 
                //获取被@Autowire注解的字段
                Field[] declaredFields = entry.getValue().getClass().getDeclaredFields();
                for (Field field: declaredFields) { 
                    if (!field.isAnnotationPresent(Autowired.class)) continue;
    
                    //根据变量类型获取类路径
                    String beanName = field.getType().getName();
                    //设置暴力访问
                    field.setAccessible(true);
                    //将变量所注入的类和根据类路径查找到的实例设置给这个变量
                    field.set(entry.getValue(), ioc.get(beanName));
                }
            }
        }

1.  初始化HandlerMapping，它是SpringMVC中完成URL到Controller映射的组件，实质上是一个Map，容器初始化会建立所有URL和Controller中方法的对应关系，保存到HandlerMapping<URL, Method>中，用户请求时根据请求的URL快读定位到Controller中的某个方法。确定了方法后，就把请求参数绑定到方法的形参上。

private void initHandlerMapping() { 
            if (ioc.isEmpty()) return;
            for (Map.Entry<String, Object> entry: ioc.entrySet()) { 
                Class<?> clazz = entry.getValue().getClass();
                if (!clazz.isAnnotationPresent(Controller.class)) continue;
                //保存类上面的@RequestMapping("/demo")
                String baseUrl = "";
                if (clazz.isAnnotationPresent(RequestMapping.class)) { 
                    RequestMapping requestMapping = clazz.getAnnotation(RequestMapping.class);
                    baseUrl = requestMapping.value();
                }
                //获取方法上的Url
                for (Method method: clazz.getMethods()) { 
                    if (!method.isAnnotationPresent(RequestMapping.class)) continue;
                    RequestMapping requestMapping = method.getAnnotation(RequestMapping.class);
                    String fullUrl = ("/" + baseUrl + "/" + requestMapping.value()).replaceAll("/+", "/");
                    //把URL和对应的方法放到HandlerMapping容器中
                    handlerMapping.put(fullUrl, method);
                }
            }
        }

1.  重写doGet方法，将请求转发给doDispatch方法进行处理

private void doDispatch(HttpServletRequest req, HttpServletResponse resp) throws Exception { 
            String url = req.getRequestURI();
            String contextPath = req.getContextPath();
            url = url.replaceAll(contextPath, "").replaceAll("/+", "/");
            //handlerMapping中查到请求的URL，没有就返回404
            if (!handlerMapping.containsKey(url)) { 
                resp.getWriter().write("404 Not Found");
                return;
            }
            //通过url找到对应的方法，用反射的方式知道方法对应的实例对象，并执行这个方法
            Method method = handlerMapping.get(url);
            Map<String, String[]> parameterMap = req.getParameterMap();
            String beanName = method.getDeclaringClass().getSimpleName();
            method.invoke(ioc.get(beanName), req, resp, parameterMap.get("name")[0]);
    
        }

通过以上步骤，我们完成了简易版SpringMVC框架的构建，下面看看运行结果：

1.  访问路径为http://localhost:8080/mvc\_write\_war/时，返回404  
    ![在这里插入图片描述][2020040117235448.png]
2.  访问路径为http://localhost:8080/mvc\_write\_war/demo/query?name=peter  
    ![在这里插入图片描述][20200401172338976.png]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTg2MDE1_size_16_color_FFFFFF_t_70]: /images/20230528/d55706e607fd4b24ae5824f58208d1af.png
[2020040117235448.png]: /images/20230528/b1a5920530944ddc9a449c2694e8ab1c.png
[20200401172338976.png]: /images/20230528/a278ad6658c344b4a11db38fce2e44ac.png