自定义的springMvc框架简单实现

分手后的思念是犯贱 2022-04-22 02:12 155阅读 0赞

最近通过学习前辈们的自定义的mini版springMvc框架实现案例，自己也模仿着学习了一遍，以此记录下来：

SpringMVC运行流程

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2ODI3OTU3_size_16_color_FFFFFF_t_70][]

执行过程如图所示：   
⑴用户发送请求至前端控制器DispatcherServlet。   
⑵ DispatcherServlet收到请求调用HandlerMapping处理器映射器。   
⑶ 处理器映射器根据请求url找到具体的处理器，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet。   
⑷ DispatcherServlet通过HandlerAdapter处理器适配器调用处理器。   
⑸ 执行处理器(Controller，也叫后端控制器)。   
⑹ Controller执行完成返回ModelAndView。   
⑺ HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet。   
⑻ DispatcherServlet将ModelAndView传给ViewReslover视图解析器。   
⑼ ViewReslover解析后返回具体View。   
⑽ DispatcherServlet对View进行渲染视图（即将模型数据填充至视图中）。   
⑾ DispatcherServlet响应用户。   
从上面可以看出，DispatcherServlet有接收请求，响应结果，转发等作用。有了DispatcherServlet之后，可以减少组件之间的耦合度。  
 另外大家也可以看下我的另一个文章，[SpringMVC中的九大组件的理解和源码][SpringMVC]

不多说直接上代码：

整体工程架构如下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2ODI3OTU3_size_16_color_FFFFFF_t_70 1][]

这个项目是一个maven项目，下面是具体类的代码：

package com.lyh.annotation;
    
    import java.lang.annotation.*;
    
    /**
     * @author 633805 LYH
     * @version V1.0
     * @description 自动注入的注解
     * @create 2018-11-01 8:41
     * @since 1.7
     */
    @Documented
    @Target(ElementType.FIELD)//(字段)标志此注解可以修饰在哪些地方，类，成员变量，方法.
    @Retention(RetentionPolicy.RUNTIME)//Annotation的生命周期，一般情况下，我们自定义注解的话，显然需要在运行期获取注解的一些信息。
    public @interface MyAutowired {
        public String value() default "";
    }

package com.lyh.annotation;
    
    import java.lang.annotation.*;
    
    /**
     * @author 633805 LYH
     * @version V1.0
     * @description 控制层的注解
     * @create 2018-11-01 8:36
     * @since 1.7
     */
    @Documented
    @Target(ElementType.TYPE)//作用于类上
    @Retention(RetentionPolicy.RUNTIME)
    public @interface MyController {
        public String value() default "";
    }

package com.lyh.annotation;
    
    import java.lang.annotation.*;
    
    /**
     * @author 633805 LYH
     * @version V1.0
     * @description  @Qualifier提供依赖注入
     * @create 2018-11-01 8:52
     * @since 1.7
     */
    @Documented
    @Target(ElementType.FIELD)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface MyQualifier {
        public String value();
    }

package com.lyh.annotation;
    
    import java.lang.annotation.*;
    
    /**
     * @author 633805 LYH
     * @version V1.0
     * @description 对持久层的注解
     * @create 2018-11-01 8:50
     * @since 1.7
     */
    @Documented//JavaDoc文档
    @Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface MyRepository {
        public String value() default "";
    }

package com.lyh.annotation;
    
    import java.lang.annotation.*;
    
    /**
     * @author 633805 LYH
     * @version V1.0
     * @description 方法映射的注解
     * @create 2018-11-01 8:39
     * @since 1.7
     */
    @Documented
    @Target({ElementType.METHOD,ElementType.TYPE})//作用于类或者方法上
    @Retention(RetentionPolicy.RUNTIME)
    public @interface MyRequestMapping {
        public String value();
    }

package com.lyh.annotation;
    
    import java.lang.annotation.*;
    
    /**
     * @author 633805 LYH
     * @version V1.0
     * @description 对于映射参数的注解
     * @create 2018-11-01 8:55
     * @since 1.7
     */
    @Documented
    @Target(ElementType.PARAMETER)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface MyRequestParam {
        public String value();
    }

package com.lyh.annotation;
    
    import java.lang.annotation.*;
    
    /**
     * @author 633805 LYH
     * @version V1.0
     * @description Service层的注解
     * @create 2018-11-01 8:38
     * @since 1.7
     */
    @Documented
    @Target(ElementType.TYPE)//作用于类上
    @Retention(RetentionPolicy.RUNTIME)
    public @interface MyService {
        public String value() default "";
    }

package com.lyh.controller;
    
    import com.lyh.annotation.MyAutowired;
    import com.lyh.annotation.MyController;
    import com.lyh.annotation.MyRequestMapping;
    import com.lyh.annotation.MyRequestParam;
    import com.lyh.service.TestService;
    
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import java.io.IOException;
    
    /**
     * @author 633805 LYH
     * @version V1.0
     * @description 对类的描述
     * @create 2018-11-01 14:48
     * @since 1.7
     */
    @MyController
    @MyRequestMapping("test1")
    public class TestController1 {
    
        @MyAutowired
        private TestService testService;
    
        @MyRequestMapping("test")
        public void myTest(HttpServletRequest req, HttpServletResponse resp, @MyRequestParam("param") String param) {
            try {
                resp.getWriter().write("TestController1: the param you send is :" + param);
                testService.printParam(param);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

package com.lyh.dao;
    
    /**
     * @author 633805 LYH
     * @version V1.0
     * @description 对类的描述
     * @create 2018-10-31 15:56
     * @since 1.7
     */
    public interface UserDao {
        void insert();
    }
    
    
    package com.lyh.dao.impl;
    
    import com.lyh.annotation.MyRepository;
    import com.lyh.dao.UserDao;
    
    /**
     * @author 633805 LYH
     * @version V1.0
     * @description 对类的描述
     * @create 2018-10-31 15:57
     * @since 1.7
     */
    @MyRepository("userDaoImpl")
    public class UserDaoImpl implements UserDao{
    
        @Override
        public void insert() {
            System.out.println("execute UserDaoImpl insert()");
        }
    }

package com.lyh.service;
    
    /**
     * @author 633805 LYH
     * @version V1.0
     * @description 对类的描述
     * @create 2018-11-01 14:41
     * @since 1.7
     */
    public interface TestService {
    
        void printParam(String param);
    }
    
    
    
    package com.lyh.service.impl;
    
    import com.lyh.annotation.MyAutowired;
    import com.lyh.annotation.MyService;
    import com.lyh.dao.UserDao;
    import com.lyh.service.TestService;
    
    /**
     * @author 633805 LYH
     * @version V1.0
     * @description 对类的描述
     * @create 2018-11-01 14:43
     * @since 1.7
     */
    @MyService
    public class TestServiceImpl implements TestService {
    
        @MyAutowired
        UserDao userDao;
    
    
        @Override
        public void printParam(String param) {
            System.out.println("接收到的参数为：" + param);
            userDao.insert();
        }
    }

package com.lyh.servlet;
    
    import com.lyh.annotation.*;
    
    import javax.servlet.ServletConfig;
    import javax.servlet.ServletException;
    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.io.InputStream;
    import java.lang.reflect.Field;
    import java.lang.reflect.Method;
    import java.net.URL;
    import java.util.*;
    import java.util.logging.Logger;
    
    /**
     * @author 633805 LYH
     * @version V1.0
     * @description MVC框架的请求分转
     * @create 2018-11-01 8:58
     * @since 1.7
     * Remark：继承HttpServlet，重写init方法、doGet、doPost方法
     */
    public class MyDispatcherServlet extends HttpServlet {
    
        private Logger logger = Logger.getLogger("init");
    
        private Properties properties = new Properties();
    
        private List<String> classNames = new ArrayList<String>();
    
        private Map<String, Object> ioc = new HashMap<String, Object>();
    
        //handlerMapping的类型可以自定义为Handler
    
        private Map<String, Object> handlerMapping = new HashMap<String, Object>();
    
        private Map<String, Object> controllerMap = new HashMap<String, Object>();
    
        @Override
        public void init(ServletConfig config) throws ServletException {
            super.init();
            logger.info("初始化MyDispatcherServlet");
            //1.加载配置文件，填充properties字段
            doLoadConfig(config.getInitParameter("contextConfigLocation"));
    
            //2.根据properties，初始化所有相关联的类，扫描用户设定的包下面所有的类
            doScanner(properties.getProperty("scanPackage"));
    
            //3.拿到扫描到的类，通过反射的机制，实例化，并且放到ioc容器中（k-v  beanName  bean）
            doInstance();
    
            //4.自动化注入
            doAutowired();
    
            //5.初始化HandlerMapping（将url和method对应上）
            initHandlerMapping();
    
            doAutowired2();
        }
    
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) {
            //注释掉父类的实现，不然会报错：405 Http method  POST  is not supported by ...
            //super.doPost(req, resp);
            logger.info("执行MyDispatcherServlet的doPost()方法");
            try {
                //处理请求
                doDispatch(req, resp);
            } catch (Exception e) {
                try {
                    resp.getWriter().write("500!!! Server Exception");
                } catch (IOException e1) {
                    e1.printStackTrace();
                }
            }
    
        }
    
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) {
            //注释掉父类的实现，不然会报错：405 Http method  GET  is not supported by ...
            //super.doGet(req, resp);
            logger.info("在执行MyDispatcherServlet的doGet()方法");
            try {
                //处理请求
                doDispatch(req, resp);
            } catch (Exception e) {
                try {
                    resp.getWriter().write("500!!! Server Exception");
                } catch (IOException e1) {
                    e1.printStackTrace();
                }
            }
        }
    
        private void doDispatch(HttpServletRequest req, HttpServletResponse resp) {
            if (handlerMapping.isEmpty()){
                return;
            }
            String url = req.getRequestURI();
            String contextPath = req.getContextPath();
            url = url.replace(contextPath, "").replaceAll("/+", "/");
            //去掉url前面的斜杆“/”，所有的@Myrequestmapping可以不用写斜杆“/”
            if (url.lastIndexOf('/') != 0) {
                url = url.substring(1);
            }
            if (!this.handlerMapping.containsKey(url)) {
                try {
                    resp.getWriter().write("404 NOT FOUND");
                    logger.info("404 NOT FOUND!");
                    return;
                } catch (IOException e) {
                    e.printStackTrace();
                }
    
            }
            Method method = (Method) this.handlerMapping.get(url);
            //获取方法的参数列表
            Class<?>[] parameterTypes = method.getParameterTypes();
    
            //获取请求的参数
            Map<String, String[]> parameterMap = req.getParameterMap();
    
            //保存的参数值
            Object[] paramValues = new Object[parameterTypes.length];
            //方法的参数列表
            for (int i =0, len = parameterTypes.length; i < len; i ++) {
                //根据参数名称，做某些处理
                String requestParam = parameterTypes[i].getSimpleName();
                if ("HttpServletRequest".equals(requestParam)) {
                    //参数类型已经明确，这边强转类型
                    paramValues[i] = req;
                    continue;
                }
                if ("HttpServletResponse".equals(requestParam)) {
                    paramValues[i] = resp;
                    continue;
    
                }
                if ("String".equals(requestParam)) {
                    for (Map.Entry<String, String[]> param : parameterMap.entrySet()) {
                        String value = Arrays.toString(param.getValue()).replaceAll("\\[|\\]", "").replaceAll(",\\s", ",");
                        paramValues[i] = value;
    
                    }
                }
            }
            //利用反射机制来调用
            try {
                //第一个参数是method所对应的实例  在ioc容器中
                method.invoke(this.controllerMap.get(url),paramValues);
            } catch (Exception e) {
                e.printStackTrace();
            }
    
        }
    
        /**
         * 根据配置文件位置，读取配置文件中的配置信息，将其填充到properties字段
         * @param location  配置文件的位置
         */
        private void doLoadConfig(String location) {
    
            //将web.xml中的contextConfigLocation对应value值得文件加载到流里面
            InputStream resourceAsStream = this.getClass().getClassLoader().getResourceAsStream(location);
            try {
                //用Properties文件加载文件里的内容
                logger.info("读取"+location+"里面的文件");
                properties.load(resourceAsStream);
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                //关流
                if (null != resourceAsStream) {
                    try {
                        resourceAsStream.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    
        /**
         * 将指定包下扫描得到的类，添加到classNames字段中；
         * @param packageName 需要扫描的包名
         *
         */
        private void doScanner(String packageName) {
            URL url  =this.getClass().getClassLoader().getResource("/"+packageName.replaceAll("\\.", "/"));
            File dir = new File(url.getFile());
            for (File file : dir.listFiles()) {
                if (file.isDirectory()) {
                    //递归取包
                    doScanner(packageName+"."+file.getName());
                } else {
                    String className =packageName +"." +file.getName().replace(".class", "");
                    classNames.add(className);
                }
            }
        }
    
        /**
         * 将classNames中的类实例化，经key-value：类名（小写）-类对象放入ioc字段中
         * Params:
         */
        private void doInstance() {
    
            if (classNames.isEmpty()) {
                return;
            }
            for (String className : classNames) {
                try {
                    //把类搞出来，反射来实例化（只有加@Controller需要实例化）
                    Class<?> clazz = Class.forName(className);
                    if (clazz.isAnnotationPresent(MyController.class)) {
                        ioc.put(toLowerFirstWord(clazz.getSimpleName()),clazz.newInstance());
                    } else if (clazz.isAnnotationPresent(MyService.class)){
                        MyService myService=clazz.getAnnotation(MyService.class);
                        String beanName=myService.value();
                        if ("".equals(beanName.trim())) {
                            beanName = toLowerFirstWord(clazz.getSimpleName());
                        }
                        Object instance = clazz.newInstance();
                        ioc.put(beanName, instance);
                        Class[] interfaces = clazz.getInterfaces();
                        for (Class<?> i : interfaces) {
                            ioc.put(i.getName(), instance);
                        }
                    } else if(clazz.isAnnotationPresent(MyRepository.class)) {
    
                        MyRepository myRepository=clazz.getAnnotation(MyRepository.class);
                        String beanName=myRepository.value();
                        if ("".equals(beanName.trim())) {
                            beanName = toLowerFirstWord(clazz.getSimpleName());
                        }
                        Object instance = clazz.newInstance();
                        ioc.put(beanName, instance);
                        Class[] interfaces = clazz.getInterfaces();
                        for (Class<?> i : interfaces) {
                            ioc.put(i.getName(), instance);
                        }
                    } else {
                        continue;
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                    continue;
                }
            }
        }
    
        /**
         * 自动化的依赖注入
         */
        private void doAutowired() {
            if (ioc.isEmpty()) {
                return;
            }
            for (Map.Entry<String, Object> entry : ioc.entrySet()) {
                //包括私有的方法，在spring中没有隐私，@MyAutowired可以注入public、private字段
                Field[] fields=entry.getValue().getClass().getDeclaredFields();
                for (Field field:fields){
                    if (!field.isAnnotationPresent(MyAutowired.class)){
                        continue;
                    }
                    MyAutowired autowired= field.getAnnotation(MyAutowired.class);
                    String beanName=autowired.value().trim();
                    if ("".equals(beanName)) {
                        beanName = field.getType().getName();
                    }
                    field.setAccessible(true);
                    try {
                        field.set(entry.getValue(), ioc.get(beanName));
                    } catch (Exception e) {
                        e.printStackTrace();
                        continue;
                    }
                }
            }
        }
    
        private void doAutowired2() {
            if (controllerMap.isEmpty()) {
                return;
            }
            for (Map.Entry<String,Object> entry : controllerMap.entrySet()) {
                //包括私有的方法，在spring中没有隐私，@MyAutowired可以注入public、private字段
                Field[] fields=entry.getValue().getClass().getDeclaredFields();
                for (Field field:fields){
                    if (!field.isAnnotationPresent(MyAutowired.class)) {
                        continue;
                    }
                    MyAutowired autowired= field.getAnnotation(MyAutowired.class);
                    String beanName=autowired.value().trim();
                    if ("".equals(beanName)) {
                        beanName = field.getType().getName();
                    }
                    field.setAccessible(true);
                    try {
                        field.set(entry.getValue(), ioc.get(beanName));
                    } catch (Exception e) {
                        e.printStackTrace();
                        continue;
                    }
                }
            }
        }
    
        /**
         * \初始化HandlerMapping(将url和method对应上)
         */
        private void initHandlerMapping() {
            if (ioc.isEmpty()) {
                return;
            }
    
            try {
                for (Map.Entry<String, Object> entry : ioc.entrySet()) {
                    Class<? extends Object> clazz = entry.getValue().getClass();
                    if(!clazz.isAnnotationPresent(MyController.class)){
                        continue;
                    }
                    //拼接url时，是Controller头的url拼上方法的url
                    String baseUrl = "";
                    if (clazz.isAnnotationPresent(MyRequestMapping.class)) {
                        MyRequestMapping annotation = clazz.getAnnotation(MyRequestMapping.class);
                        baseUrl = annotation.value();
                    }
                    Method[] methods = clazz.getMethods();
                    for (Method method : methods) {
                        if (!method.isAnnotationPresent(MyRequestMapping.class)) {
                            continue;
                        }
                        MyRequestMapping annotation = method.getAnnotation(MyRequestMapping.class);
                        String url = annotation.value();
    
                        url = (baseUrl + "/" +url).replaceAll("/+", "/");
                        handlerMapping.put(url, method);
                        controllerMap.put(url, clazz.newInstance());
                        System.out.println(url + "," + method);
                    }
                }
            } catch (Exception e) {
    
                e.printStackTrace();
            }
        }
    
        /**
         * 将字符串中的首字母小写
         * @param name
         * @return
         */
        private String toLowerFirstWord(String name) {
            char[] charArray = name.toCharArray();
            charArray[0] += 32;
            return String.valueOf(charArray);
        }
    }

application.properties文件：

scanPackage=com.lyh

web.xml:

<?xml version="1.0" encoding="UTF-8"?>
    <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    	xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
    	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
    	version="3.0">
    	<servlet>
    		<servlet-name>MiniServlet</servlet-name>
    		<servlet-class>com.lyh.servlet.MyDispatcherServlet</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>MiniServlet</servlet-name>
    		<url-pattern>/*</url-pattern>
    	</servlet-mapping>
    
    </web-app>

pom.xml主要引入的jar包

<dependency>
                <groupId>javax.servlet</groupId>
                <artifactId>javax.servlet-api</artifactId>
                <version>3.0.1</version>
                <scope>provided</scope>
            </dependency>

主要是dispatcherServlet分发管理器类的实现，接下来是使用本地tomcat搭载项目测试：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2ODI3OTU3_size_16_color_FFFFFF_t_70 2][]

![20181101162428768.jpg][]

到此springmvc的简单功能就模拟实现了。。。。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2ODI3OTU3_size_16_color_FFFFFF_t_70]: /images/20220422/ac74dc4da9054afcb5a7b68ada059b14.png
[SpringMVC]: https://blog.csdn.net/qq_36827957/article/details/82964346
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2ODI3OTU3_size_16_color_FFFFFF_t_70 1]: /images/20220422/4193a4411764417da2a3dd2134a06853.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2ODI3OTU3_size_16_color_FFFFFF_t_70 2]: /images/20220422/2c8f489ee2ae4c3d868dff65719e7110.png
[20181101162428768.jpg]: /images/20220422/53cdb17ade48414f84e1656bee8d1508.png