SpringMvc执行流程简配版demo

た入场券 2022-09-03 05:26 147阅读 0赞

### 文章目录 ###

*  简介
 *  一.用到的相关依赖
 *  二.相关代码信息
 *   *  1. annotation包
     *  2.bean包
     *  3.context包
     *  4.handler
     *  5. view包
     *  6. servlet包
     *  7.其它非核心类
 *  三.初始化流程
 *   *  1.配置需要被扫描包和模板路径
     *  2.web入口
     *  3.ioc控制反转和dl依赖注入
     *  4 初始化视图转换器
     *  5.初始化资源映射
 *  四. 处理请求流程
 *  五.测试效果
 *   *  1.测试返回视图
     *  2. 测试返回json数据
 *  六. 总结

# 简介 #

此文基于之前看【Spring5 核心原理】书籍然后综合自己的理解改造了一些功能,简单的概况了springMvc初始化和执行的流程,demo核心的模块如下图

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA_size_16_color_FFFFFF_t_70]

# 一.用到的相关依赖 #

*  **javax.servlet-api:** 这个就不需要我讲了吧,刚入行接触的就是servlet，处理请求用doPost，doGet相信大家都接触过
 *  **reflections:** 用于扫描接口的实现类使用的

<dependencies>
            <dependency>
                <groupId>javax.servlet</groupId>
                <artifactId>javax.servlet-api</artifactId>
                <version>3.0.1</version>
                <scope>provided</scope>
            </dependency>
            <dependency>
                <groupId>org.reflections</groupId>
                <artifactId>reflections</artifactId>
                <version>0.9.12</version>
            </dependency>
        </dependencies>

# 二.相关代码信息 #

## 1. annotation包 ##

<table> 
 <thead> 
  <tr> 
   <th>注解名称</th> 
   <th>功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>MyController</td> 
   <td>标识控制器返回html视图</td> 
  </tr> 
  <tr> 
   <td>MyRestController</td> 
   <td>标识控制器,所有方法返回json数据视图</td> 
  </tr> 
  <tr> 
   <td>MyRequestMapping</td> 
   <td>请求Url配置,有兴趣的小伙伴可以自行实现@doGet,@doPath等RESTful功能注解</td> 
  </tr> 
  <tr> 
   <td>MyRequestParam</td> 
   <td>请求参数映射</td> 
  </tr> 
  <tr> 
   <td>MyResponseBody</td> 
   <td>标识返回json数据(目前只做了返回字符串数据,感兴趣的小伙伴可以自行实现该功能)</td> 
  </tr> 
  <tr> 
   <td>MyAutowired</td> 
   <td>实现依赖注入</td> 
  </tr> 
  <tr> 
   <td>MyService</td> 
   <td>定义业务处理Bean</td> 
  </tr> 
 </tbody> 
</table>

@Target(ElementType.FIELD)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface MyAutowired { 
        String value() default "";
    }
    
    @Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface MyController { }
    
    @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 "";
        boolean required() default true;
    }
    
    @Target({ ElementType.TYPE, ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface MyResponseBody { }
    
    @Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface MyRestController { 
        String value() default "";
    }
    
    @Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface MyService { 
        String value() default "";
    }

## 2.bean包 ##

<table> 
 <thead> 
  <tr> 
   <th>类名</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>MyBeanDefinition</td> 
   <td>封装Bean名称和对应的className(用于反射生成构建实例)</td> 
  </tr> 
  <tr> 
   <td>MyDefaultListableBeanFactory</td> 
   <td>工程类,用于存储MyBeanDefinition 信息</td> 
  </tr> 
  <tr> 
   <td>MyBeanWrapper</td> 
   <td>用于包装Bean实例对象</td> 
  </tr> 
  <tr> 
   <td>MyBeanDefinitionReader</td> 
   <td>根据配置文件的路径扫描需要由spring代理的包</td> 
  </tr> 
  <tr> 
   <td>MyBeanFactory</td> 
   <td>工厂顶层设计接口</td> 
  </tr> 
 </tbody> 
</table>

public class MyBeanDefinition { 
        /** * Bean的全类名 */
        private String beanClassName;
    
        /** * Bean名称,在Ioc容器里存储的Key */
        private String beanName;
    	//省略 get set方法
     }

public class MyDefaultListableBeanFactory extends MyAbstractApplicationContext { 
        protected final Map<String, MyBeanDefinition> beanDefinitionMap=new ConcurrentHashMap<>();
    }

public class MyBeanWrapper { 
        private Object wrappedInstance;
        private Class<?> wrappedClass;
        public MyBeanWrapper(Object wrappedInstance) { 
            this.wrappedInstance = wrappedInstance;
            this.wrappedClass=wrappedInstance.getClass();
        }
    }

public class MyBeanDefinitionReader { 
        private String packageName;
        private List<String> registyBeanClasses = new ArrayList<>();
        private Properties config = new Properties();
    	//省略get set方法
        /** * 固定配置文件的key */
        private final String SCAN_PACKAGE = "scanPackage";
        public MyBeanDefinitionReader(String... localtions) { 
            //通过资源路径定位到其所应的文件
            try (InputStream is = this.getClass().getClassLoader().getResourceAsStream(localtions[0])) { 
                config.load(is);
                scanner(config.getProperty(SCAN_PACKAGE));
            } catch (Exception e) { 
                e.printStackTrace();
            }
        }
        /** * 扫描需要被sprig管理包 */
        private void scanner(String packageName) { 
            if(this.packageName==null){ 
                this.packageName=packageName;
            }
            URL url = this.getClass().getClassLoader().getResource("/" + packageName.replaceAll("\\.", "/"));
            File dir = new File(url.getFile());
            for (File file : dir.listFiles()) { 
                if (file.isDirectory()) { 
                    //递归读取包
                    scanner(packageName + "." + file.getName());
                } else { 
                    String className = packageName + "." + file.getName().replace(".class", "");
                    //把bean的class信息放入到List中
                    registyBeanClasses.add(className);
                }
            }
        }
    
        /** * 把配置文件扫描的所有配置信息转换未MyBeanDefinition对象 */
        public List<MyBeanDefinition> loadBeanDefinitions() { 
            List<MyBeanDefinition> result = new ArrayList<>();
            try { 
                for (String className : registyBeanClasses) { 
                    Class<?> beanClass = Class.forName(className);
                     //接口不需要处理
                    if (beanClass.isInterface()) { 
                        continue;
                    }
                     //只处理需要包含指定需要代理类的注解的类
                    if(beanClass.isAnnotationPresent(MyController.class) || beanClass.isAnnotationPresent(MyRestController.class) ||  beanClass.isAnnotationPresent(MyService.class)){ 
                        result.add(createBeanDefinition(StringUtils.toLowerFirstWord(beanClass.getSimpleName()), beanClass.getName()));
                    }
                }
            } catch (Exception e) { 
                e.printStackTrace();
            }
            return result;
        }
    
        private MyBeanDefinition createBeanDefinition(String beanName, String beanClassName) { 
            MyBeanDefinition myBeanDefinition = new MyBeanDefinition();
            myBeanDefinition.setBeanName(beanName);
            myBeanDefinition.setBeanClassName(beanClassName);
            return myBeanDefinition;
        }
    }

public interface MyBeanFactory { 
        /** *根据bean名称获取实例 */
        Object getBean(String beanName) throws Exception;
         /** *根据bean类名获取实例 */
        Object getBean(Class<?> beanClass) throws Exception;
    }

## 3.context包 ##

<table> 
 <thead> 
  <tr> 
   <th>类名</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>MyAbstractApplicationContext</td> 
   <td>定义Ioc容器的公共逻辑</td> 
  </tr> 
  <tr> 
   <td>MyApplicationContext</td> 
   <td>实现ioc容器初始化和依赖注入功能</td> 
  </tr> 
 </tbody> 
</table>

public  abstract  class MyAbstractApplicationContext { 
       public   void refresh() throws Exception{ }
    }
    public class MyApplicationContext extends MyDefaultListableBeanFactory implements MyBeanFactory { 
    
        private String[] configLocations;
        private MyBeanDefinitionReader reader;
        private Properties config;
    
        /** * ioc容器,存放需要由spring管理的Bean实例 */
        private Map<String, Object> factoryBeanObjectCache = new HashMap<>();
    
        /** * 存放Bean包装器信息 */
        private Map<String, MyBeanWrapper> factoryBeanInstanceCache = new HashMap<>();
    
        public Map<String, Object> getFactoryBeanObjectCache() { 
            return factoryBeanObjectCache;
        }
    
    
        public Properties getConfig() { 
            return config;
        }
    
        public MyApplicationContext(String... configLocations) { 
            this.configLocations = configLocations;
            try { 
                refresh();
            } catch (Exception e) { 
                e.printStackTrace();
            }
        }
    
        @Override
        public Object getBean(String beanName) throws Exception { 
            MyBeanDefinition beanDefinition = super.beanDefinitionMap.get(beanName);
            try { 
            	//重ioc容器中获取bean实例
                Object instance = instantiateBean(beanDefinition);
                if (null == instance) { 
                    return null;
                }
                //把bean实例放入包装器中
                MyBeanWrapper beanWrapper = new MyBeanWrapper(instance);
                this.factoryBeanInstanceCache.put(beanName, beanWrapper);
                 //依赖注入
                populateBean(instance);
                return this.factoryBeanInstanceCache.get(beanName).getWrappedInstance();
            } catch (Exception e) { 
                return null;
            }
        }
    
        /** * 注入依赖的Bean */
        private void populateBean(Object instance) { 
            Class clas = instance.getClass();
            Field[] fields = clas.getDeclaredFields();
            for (Field field : fields) { 
                if (!field.isAnnotationPresent(MyAutowired.class)) { 
                    continue;
                }
                MyAutowired autowired = field.getAnnotation(MyAutowired.class);
                String autowiredBeanName = autowired.value().trim();
                if ("".equals(autowiredBeanName)) { 
                    autowiredBeanName = StringUtils.toLowerFirstWord(field.getType().getSimpleName());
                }
                field.setAccessible(true);
                try { 
                    boolean insertBeanDefinition = false;
                    MyBeanDefinition myBeanDefinition;
                    if (super.beanDefinitionMap.containsKey(autowiredBeanName)) { 
                        // 当 @MyAutowired UserServiceImpl重ioc容器获取bean
                        myBeanDefinition = super.beanDefinitionMap.get(autowiredBeanName);
                    } else { 
                        //当 @MyAutowired UserService,则找到接口的实现类封装成bean修饰器然后再注入bean实例
                        String subClassName = ClassUtils.getInterfaceImpl(reader.getPackageName(), field.getType());
                        myBeanDefinition = super.beanDefinitionMap.get(subClassName);
                        insertBeanDefinition = true;
                    }
                    if (myBeanDefinition == null) { 
                        continue;
                    }
                    Object autowiredInstance = instantiateBean(myBeanDefinition);
                    if (null == instance) { 
                        continue;
                    }
                    if (insertBeanDefinition) { 
                        //把UserService和UserServiceImpl对应的修饰器类对应上,避免别的地方依赖注入的时候又重新调用一次获取接口子类的逻辑
                        super.beanDefinitionMap.put(autowiredBeanName, myBeanDefinition);
                    }
                    field.set(instance, autowiredInstance);
                } catch (Exception e) { 
                    e.printStackTrace();
                }
            }
        }
    
        /** * 传入一个BeanFefinition返回一个实例,如果实例存在,重ioc容器中获取 * 使用到了 【注册式单例模式】 */
        private Object instantiateBean(MyBeanDefinition beanDefinition) { 
            Object instance = null;
            String className = beanDefinition.getBeanClassName();
            try { 
                //根据className确定类是否有示例
                if (this.factoryBeanObjectCache.containsKey(className)) { 
                    instance = this.factoryBeanObjectCache.get(className);
                } else { 
                    Class<?> clas = Class.forName(className);
                    instance = clas.newInstance();
                    this.factoryBeanObjectCache.put(className, instance);
                }
                return instance;
            } catch (Exception e) { 
                e.printStackTrace();
            }
            return null;
        }
    
        @Override
        public Object getBean(Class<?> beanClass) throws Exception { 
            return this.getBean(beanClass.getName());
        }
    
        @Override
        public void refresh() throws Exception { 
            //1.定位配置文件
            reader = new MyBeanDefinitionReader(this.configLocations);
            this.config = reader.getConfig();
            //2.加载配置文件,扫描相关的类,把它们封装成BeanDefinition
            List<MyBeanDefinition> beanDefinitionList = reader.loadBeanDefinitions();
            //3.把bean信息放入到map中
            registerBeanFefinition(beanDefinitionList);
            //4.控制反转和依赖注入
            autowrited();
        }
    
        private void autowrited() { 
            for (Map.Entry<String, MyBeanDefinition> beanDefinitionEntry : super.beanDefinitionMap.entrySet()) { 
                String beanName = beanDefinitionEntry.getKey();
                try { 
                    getBean(beanName);
                } catch (Exception e) { 
                    e.printStackTrace();
                }
            }
        }
    
        private void registerBeanFefinition(List<MyBeanDefinition> beanDefinitionList) throws Exception { 
            for (MyBeanDefinition beanDefinition : beanDefinitionList) { 
                if (super.beanDefinitionMap.containsKey(beanDefinition.getBeanName())) { 
                    throw new Exception("The " + beanDefinition.getBeanName() + " is exists");
                }
                super.beanDefinitionMap.put(beanDefinition.getBeanName(), beanDefinition);
            }
        }
    }

## 4.handler ##

<table> 
 <thead> 
  <tr> 
   <th>类名</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>MyHandlerAdapter</td> 
   <td>处理请求并返回视图或者json数据（使用到了适配器模式）</td> 
  </tr> 
  <tr> 
   <td>MyHandlerMapping</td> 
   <td>用来存储路由和请求参数信息。</td> 
  </tr> 
 </tbody> 
</table>

public class MyHandlerAdapter { 
    
        public boolean supports(Object handler) { 
            return (handler instanceof MyHandlerMapping);
        }
    
        public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, MyHandlerMapping handler) throws Exception { 
            //获取方法的参数列表
            Class<?>[] parameterTypes = handler.getMethod().getParameterTypes();
    
            //保存参数值
            Object[] paramValues = new Object[parameterTypes.length];
    
            //获取请求的参数
            Map<String, String[]> parameterMap = request.getParameterMap();
    
            for (Map.Entry<String, String[]> entry : parameterMap.entrySet()) { 
                if (!handler.getParamIndexMapping().containsKey(entry.getKey())) { 
                    continue;
                }
                int index = handler.getParamIndexMapping().get(entry.getKey());
                paramValues[index] = DispatcherServletUtils.convert(parameterTypes[index], entry.getValue());
                if (handler.requiredList != null) { 
                    //重必选参数列表移除存在的key
                    handler.requiredList.remove(entry.getKey());
                }
            }
    
            if (handler.requiredList != null && handler.requiredList.size() > 0) { 
                throw new MissingParametersException(handler.requiredList.toString() + "是必选参数,不能为null");
            }
    
            if (handler.paramIndexMapping.containsKey(HttpServletRequest.class.getName())) { 
                int index = handler.paramIndexMapping.get(HttpServletRequest.class.getName());
                paramValues[index] = request;
            }
            if (handler.paramIndexMapping.containsKey(HttpServletResponse.class.getName())) { 
                int index = handler.paramIndexMapping.get(HttpServletResponse.class.getName());
                paramValues[index] = response;
            }
            if (handler.paramIndexMapping.containsKey(HttpSession.class.getName())) { 
                int index = handler.paramIndexMapping.get(HttpSession.class.getName());
                paramValues[index] = request.getSession();
            }
    
                //利用反射机制来调用 第一个参数是method所对应的实例 在ioc容器中
                Object returnValue = handler.getMethod().invoke(handler.controller, paramValues);
                if (returnValue == null) { 
                    return null;
                }
                boolean isModelAndView = handler.getMethod().getReturnType() == ModelAndView.class;
                if (isModelAndView) { 
                    return (ModelAndView) returnValue;
                } else { 
                    //判断当前控制器是否包含MyRestController注解或者当前调用的方法是否包含MyResponseBody注解
                    if(handler.getMethod().isAnnotationPresent(MyResponseBody.class) ||  handler.controller.getClass().isAnnotationPresent(MyRestController.class))
                    { 
                        response.setCharacterEncoding("UTF-8");
                        response.setHeader("Content-Type", "text/html; charset=UTF-8");
                        response.getWriter().write(returnValue.toString());
                        return  null;
                    }
                    //抛出视图未找到异常
                    throw  new ViewNotFindException(returnValue.toString());
                }
    
        }
    
    }

public class MyHandlerMapping { 
        //保存方法对应的实例
        protected Object controller;
        //保存映射的方法
        protected Method method;
        //参数顺序
        protected Map<String, Integer> paramIndexMapping;
        //必选参数列表吧
        protected List<String> requiredList;
    
        public Method getMethod() { 
            return method;
        }
    
        public Map<String, Integer> getParamIndexMapping() { 
            return paramIndexMapping;
        }
    
        /** * 构建一个Handler的基本参数 */
        public MyHandlerMapping(Object controller, Method method) { 
            this.controller = controller;
            this.method = method;
            initParamIndexMapping(method);
        }
    
        private void initParamIndexMapping(Method method) { 
            paramIndexMapping = new HashMap<>();
            requiredList = new ArrayList<>();
            //提取方法注解参数
            Annotation[][] param = method.getParameterAnnotations();
            MyRequestParam mrp;
            for (int i = 0; i < param.length; i++) { 
                for (Annotation a : param[i]) { 
                    if (a instanceof MyRequestParam) { 
                        mrp = ((MyRequestParam) a);
                        String paramName = mrp.value();
                        if (!"".equals(paramName.trim())) { 
                            paramIndexMapping.put(paramName, i);
                        }
                        if (mrp.required()) { 
                            requiredList.add(paramName);
                        }
                    }
                }
            }
            if (requiredList.size() == 0) { 
                requiredList = null;
            }
            //提取方法中的request,response,session参数
            Class<?> paramsTypes[] = method.getParameterTypes();
            for (int i = 0; i < paramsTypes.length; i++) { 
                Class<?> type = paramsTypes[i];
                if (type == HttpServletRequest.class || type == HttpServletResponse.class || type == HttpSession.class) { 
                    paramIndexMapping.put(type.getName(), i);
                }
            }
        }
    }

## 5. view包 ##

<table> 
 <thead> 
  <tr> 
   <th>类名</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>ModelAndView</td> 
   <td>返回视图名称和页面需要的model数据</td> 
  </tr> 
  <tr> 
   <td>View</td> 
   <td>封装页面文件信息和渲染页面流程</td> 
  </tr> 
  <tr> 
   <td>MyViewResolver</td> 
   <td>把静态文件转换为动态文件</td> 
  </tr> 
 </tbody> 
</table>

public class ModelAndView { 
        private String ViewName;
        private Map<String, ?> model;
        public ModelAndView(String viewName, Map<String, ?> model) { 
            ViewName = viewName;
            this.model = model;
        }
    }

public class View { 
        private static final String DEFAULT_CONTENT_TYPE = "text/html;charset=utf-8";
        private static final Pattern pattern = Pattern.compile("\\$\\{[^\\}]+\\}", Pattern.CASE_INSENSITIVE);
        private File viewFile;
        public View(File viewFile) { 
            this.viewFile = viewFile;
        }
        public String getContentType() { 
            return DEFAULT_CONTENT_TYPE;
        }
        private static String makeStringForRegExp(String str) { 
            return str.replace("\\", "\\\\").replace("*", "\\*")
                    .replace("+", "\\+").replace("|", "\\|")
                    .replace("{", "\\{").replace("}", "\\}")
                    .replace("(", "\$").replace(")", "\$")
                    .replace("^", "\\^").replace("$", "\\$")
                    .replace("[", "\\[").replace("]", "\\]")
                    .replace("?", "\\?").replace(",", "\\,")
                    .replace(".", "\\.").replace("&", "\\&");
        }
        public void render(Map<String, ?> model, HttpServletRequest request, HttpServletResponse response) throws Exception { 
            StringBuilder sb = new StringBuilder();
            RandomAccessFile ra = new RandomAccessFile(this.viewFile, "r");
            try { 
                String line = null;
                Matcher matcher;
                while (null != (line = ra.readLine())) { 
                    line = new String(line.getBytes("ISO-8859-1"), "utf-8");
                    matcher = pattern.matcher(line);
                    while (matcher.find()) { 
                        String paramName = matcher.group();
                        paramName = paramName.replaceAll("\\$\\{|}", "");
                        Object paramValue = model.get(paramName);
                        if (null == paramValue) { 
                            paramValue = "";
                        }
                        line = matcher.replaceFirst(makeStringForRegExp(paramValue.toString()));
                        matcher = pattern.matcher(line);
                    }
                    sb.append(line);
                }
            } finally { 
                ra.close();
            }
            response.setCharacterEncoding("utf-8");
            response.getWriter().write(sb.toString());
        }

public class MyViewResolver { 
        private final String DEFALUT_TEMPALTE_SUFIX = ".html";
        // 视图目录
        private File templateRootDir;
        public MyViewResolver(String templateRootPath) { 
            this.templateRootDir = new File(templateRootPath);
        }
        // 通过页面Name，返回相应View视图
        public View resolveViewName(String viewName, Locale locale) { 
            if (null == viewName || "".equals(viewName.trim())) { 
                return null;
            }
            // 给没有 .html的加上后缀（我们可以在ModelAndView中写500.html，也可以直接写 500）
            viewName = viewName.endsWith(DEFALUT_TEMPALTE_SUFIX) ? viewName : (viewName + DEFALUT_TEMPALTE_SUFIX);
            // 返回相应视图
            File templateFile = new File((templateRootDir.getPath() + "/" + viewName).replaceAll("/+", "/"));
            return new View(templateFile);
        }
    }

## 6. servlet包 ##

public class MyDispatcherServlet extends HttpServlet { 
    
        private Logger log = Logger.getLogger(this.getClass().getName());
    
        MyApplicationContext applicationContext;
    
        /** * 保存接口和方法路由映射关系 */
        private Map<String, MyHandlerMapping> handlerMapping = new HashMap();
    
        /** * 存放路由和处理器映射关系 */
        private Map<MyHandlerMapping, MyHandlerAdapter> handlerAdapterMap = new HashMap<>();
    
        /** * 保存视图解析器的容器 */
        private List<MyViewResolver> viewResolvers = new ArrayList<>();
    
        @Override
        public void init(ServletConfig config) throws ServletException { 
            super.init();
            log.info("初始化MyDispatcherServlet");
            //初始化应用程序上下文,处理ioc和dl核心功能流程
            applicationContext = new MyApplicationContext(config.getInitParameter("contextConfigLocation"));
            //初始化策略,加载必须要使用的组件
            initStrategies(applicationContext);
        }
    
        protected void initStrategies(MyApplicationContext applicationContext) { 
    
            // 1.初始化视图转换器，必须实现
            initViewResolvers(applicationContext);
    
            //2.加载接口和方法映射
            initHandlerMapping(applicationContext);
            //3.加载适配器
            initHandlerAdapter(applicationContext);
        }
    
        private void initHandlerAdapter(MyApplicationContext applicationContext) { 
            MyHandlerAdapter myHandlerAdapter;
            for (MyHandlerMapping myHandlerMapping : handlerMapping.values()) { 
                //此处实际用的是同一个适配器,实际可能根据HandlerMapping类型分配不同的适配器
                myHandlerAdapter=new MyHandlerAdapter();
                if(myHandlerAdapter.supports(myHandlerMapping)){ 
                    this.handlerAdapterMap.put(myHandlerMapping,myHandlerAdapter);
                }
            }
        }
    
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { 
            log.info("执行MyDispatcherServlet的doPost()");
            try { 
                //处理请求
                doDispatch(req, resp);
            } catch (Exception e) { 
                try { 
                    Map model = new HashMap();
                    model.put("msg", e.getMessage());
                    model.put("stackTrace", e.getStackTrace());
                    processDispatchResult(req, resp, new ModelAndView("500.html",model));
                } catch (Exception er) { 
                    er.printStackTrace();
                }
            }
        }
    
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { 
            log.info("执行MyDispatcherServlet的doGet()");
            doPost(req, resp);
        }
    
        private void doDispatch(HttpServletRequest req, HttpServletResponse resp) throws Exception { 
            if (handlerMapping.isEmpty()) { 
                return;
            }
            String url = req.getRequestURI();
            String contextPath = req.getContextPath();
            url = url.replace(contextPath, "").replaceAll("/+", "/");
            if (!this.handlerMapping.containsKey(url)) { 
                processDispatchResult(req, resp, new ModelAndView("404.html"));
                return;
            }
            MyHandlerMapping handler = this.handlerMapping.get(url);
            MyHandlerAdapter myHandlerAdapter = getHandlerAdapter(handler);
    
            ModelAndView myModelAndView = myHandlerAdapter.handle(req, resp, handler);
            //输出结果
            processDispatchResult(req, resp, myModelAndView);
        }
    
        private void processDispatchResult(HttpServletRequest req, HttpServletResponse resp, ModelAndView mv) throws Exception { 
            if (null == mv) { 
                return;
            }
            if (this.viewResolvers.isEmpty()) { 
                return;
            }
            for (MyViewResolver myViewResolver : this.viewResolvers) { 
                View view = myViewResolver.resolveViewName(mv.getViewName(), null);
                if (view != null) { 
                    view.render(mv.getModel(), req, resp);
                    return;
                }
            }
        }
    
    
        private MyHandlerAdapter getHandlerAdapter(MyHandlerMapping handlerMapping) { 
            if (this.handlerAdapterMap.isEmpty()) return null;
            MyHandlerAdapter myHandlerAdapter = this.handlerAdapterMap.get(handlerMapping);
            if (myHandlerAdapter.supports(handlerMapping)) { 
                return myHandlerAdapter;
            }
            return null;
        }
    
        /** * 初始化控制器 */
        private void initHandlerMapping(MyApplicationContext context) { 
    
            if (context.getFactoryBeanObjectCache().size() == 0) { 
                return;
            }
    
            try { 
                for (Map.Entry<String, Object> entry : context.getFactoryBeanObjectCache().entrySet()) { 
                    Class<? extends Object> clazz = entry.getValue().getClass();
                    if (!clazz.isAnnotationPresent(MyController.class) && !clazz.isAnnotationPresent(MyRestController.class)) { 
                        continue;
                    }
    
                    //拼url时,是controller头的url拼上方法上的url
                    String baseUrl = "";
                    if (clazz.isAnnotationPresent(MyRequestMapping.class)) { 
                        MyRequestMapping annotation = clazz.getAnnotation(MyRequestMapping.class);
                        baseUrl = annotation.value();
                    }
    
                    if (!baseUrl.startsWith("/")) { 
                        baseUrl = "/" + baseUrl;
                    }
    
                    Method[] methods = clazz.getMethods();
    
                    MyRequestMapping annotation;
                    for (Method method : methods) { 
                        if (!method.isAnnotationPresent(MyRequestMapping.class)) { 
                            continue;
                        }
                        annotation = method.getAnnotation(MyRequestMapping.class);
                        String url = annotation.value();
                        if(url.trim().length()>0){ 
                            url = (baseUrl + "/" + url).replaceAll("/+", "/");
                        }else{ 
                            url=baseUrl;
                        }
                        handlerMapping.put(url, new MyHandlerMapping(entry.getValue(), method));
                        System.out.println("mapping " + url + "," + method);
                    }
                }
    
            } catch (Exception e) { 
                e.printStackTrace();
            }
    
        }
    
        private void initViewResolvers(MyApplicationContext context) { 
            // 拿到在配置文件中配置的模板存放路径(layouts)
            String templateRoot = context.getConfig().getProperty("templateRoot");
    
            // 通过相对路径找到目标后，获取到绝对路径
            // 注：getResourse返回的是URL对象，getFile返回文件的绝对路径
            String templateRootPath = this.getClass().getClassLoader().getResource(templateRoot).getFile();
            // 视图解析器可以有多种，且不同的模板需要不同的Resolver去解析成不同的View（jsp，html，json。。）
            // 但这里其实就只有一种（解析成html）
                this.viewResolvers.add(new MyViewResolver(templateRootPath ));
        }
    
    
    }

## 7.其它非核心类 ##

<table> 
 <thead> 
  <tr> 
   <th>类名</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>ClassUtils</td> 
   <td>获取接口的实例</td> 
  </tr> 
  <tr> 
   <td>StringUtils</td> 
   <td>将字符串中的首字母小写</td> 
  </tr> 
  <tr> 
   <td>MissingParametersException</td> 
   <td>自定义参数缺失异常</td> 
  </tr> 
  <tr> 
   <td>ViewNotFindException</td> 
   <td>自定义视图没找到异常</td> 
  </tr> 
 </tbody> 
</table>

public class ClassUtils { 
    
        /** * 获取接口的实现类 */
        public static String getInterfaceImpl(String packageName, Class classz) { 
            Reflections reflections = new Reflections(packageName);
            Set<? extends Class> classes = reflections.getSubTypesOf(classz);
            String beanClassName = null;
            for (Class clazz : classes) { 
                beanClassName = clazz.getSimpleName();
                beanClassName=StringUtils.toLowerFirstWord(beanClassName);
                break;
            }
            return beanClassName;
        }
    
        public static void main(String[] args) { 
            String beanClassName=getInterfaceImpl("com.ljm.demo", UserService.class);
            //返回userServiceImpl
            System.out.println(beanClassName);
        }
    }

public class StringUtils { 
        public static String toLowerFirstWord(String name) { 
            char[] charArray = name.toCharArray();
            charArray[0] += 32;
            return String.valueOf(charArray);
        }
    }

public class MissingParametersException extends Exception { 
        public MissingParametersException() {  }
        public MissingParametersException(String message) { 
            super(message);
        }
    }
    public class ViewNotFindException extends Exception { 
        public ViewNotFindException() {  }
        public ViewNotFindException(String message) { 
            super(String.format("没有找到 [%s.html] 文件",message));
        }
    }

# 三.初始化流程 #

## 1.配置需要被扫描包和模板路径 ##

application.properties文件内容如下

scanPackage=com.ljm.demo
    templateRoot=/templates

## 2.web入口 ##

**首先需要重web.xml中配置MyDispatcherServlet类和路由绑定。**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA_size_16_color_FFFFFF_t_70 1]

**启动应用会访问MyDispatcherServlet的init()方法执行初始化流程，首先会去构建MyApplicationContext实例,通过有参构造函数把application.properties文件的路径传递进去了**\*\*  
![在这里插入图片描述][64e57ee141b34ac5bd5ac1dda3999403.png]

## 3.ioc控制反转和dl依赖注入 ##

在MyApplicationContext构造函数中会执行refresh()方法，refresh()方法中会进行ioc控制反转和依赖注入方法  
![在这里插入图片描述][123436be9f1448ddb46ec8db3f0e17f7.png]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA_size_16_color_FFFFFF_t_70 2]

2.1.通过MyBeanDefinitionReader构造,把指定包下的所有类都加到了registyBeanClasses列表中  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA_size_16_color_FFFFFF_t_70 3]  
2.2 通过执行MyBeanDefinitionReader的**loadBeanDefinitions**方法,进行了类的过滤,然后执行**registerBeanFefinition**方法把信息放入map中  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA_size_16_color_FFFFFF_t_70 4]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA_size_16_color_FFFFFF_t_70 5]  
![在这里插入图片描述][9df5cc57c4d248e38a9b4186bba34324.png]  
2.3 通过执行**autowrited**方法然后迭代调用getBean方法进行ioc和dl操作  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA_size_16_color_FFFFFF_t_70 6]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA_size_16_color_FFFFFF_t_70 7]

通过执行super.**beanDefinitionMap**.get(beanName)方法去获取Bean的配置信息,然后通过调用**instantiateBean**方法重ioc容器中获取bean实例,如果不存在则通过反射生成实例并放入ioc容器中  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA_size_16_color_FFFFFF_t_70 8]  
然后把获取的实例放入包装器中,再放入到缓存中  
![在这里插入图片描述][c5ab0d761e534cea97c71d45f5c4bb5f.png]  
然后执行**populateBean**方法进行依赖注入，整体执行逻辑如下

*  1.获取实例的类信息,然后获取类的所有字段
 *  2.遍历字段,如果当前字段包含**MyAutowired注解**,则往下执行依赖注入的逻辑
 *  3.先重MyAutowired的value字段中获取bean名称,如果未配置默认使用去字段类名并首字母小写，并设置暴力访问该字段。
 *  4.通过要注入的bean名称去获取对应的Bean配置信息，由于**beanDefinitionMap**只管理了类信息没有管理类实现的接口信息,当**MyAutowired注解**注入的是一个接口类型的时候需要通过工具类获取接口的实现类信息
 *  5.然后通过**instantiateBean**方法重ioc容器中获取需要被注入的Bean实例
 *  6.最后通过 **field.set**(instance, autowiredInstance)把需要注入的对象赋值给字段  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA_size_16_color_FFFFFF_t_70 9]

最后返回Bean的包装器对象  
![在这里插入图片描述][750456554d2e4255849b29dea612a157.png]

## 4 初始化视图转换器 ##

通过执行**initViewResolvers**方法加载视图转换器  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA_size_16_color_FFFFFF_t_70 10]  
整体执行逻辑如下

*  1.获取配置文件配置好的模板存放目录。
 *  2.往视图解析器列表里放入html解析器

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA_size_16_color_FFFFFF_t_70 11]

## 5.初始化资源映射 ##

![在这里插入图片描述][a376c0fc316947c592881bfe1e0670ef.png]

执行**initHandlerMapping**进行映射，处理逻辑如下

*  1.遍历由ioc容器管理的Bean
 *  2.获取当前类包含**MyController注解**或者**MyRestController注解**则进行下面的处理
 *  3.获取类的路由地址
 *  4.便利该类的所有方法,处理包含**MyRequestMapping注解**方法，把方法路由地址然后和类的拼接上，然后封装成**MyHandlerMapping**对象放入资源路径容器中
 *  5.在MyHandlerMapping构造函数中对**MyRequestParam注解**进行绑定,并把必选参数名称加入到**requiredList**中  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA_size_16_color_FFFFFF_t_70 12]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA_size_16_color_FFFFFF_t_70 13]  
初始化HandlerMapping使用的适配器。  
![在这里插入图片描述][fda06d6b55264d8f892cd2df896ee7a1.png]

# 四. 处理请求流程 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA_size_16_color_FFFFFF_t_70 14]

发送post请求后会被**MyDispatcherServlet**的**doPost**方法处理,然后**doPost**委托给**doDispatch**方法处理  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA_size_16_color_FFFFFF_t_70 15]  
执行逻辑如下

*  1.判断**handlerMapping**容器是否有元素，没有则返回null。
 *  2.获取请求路径，如果路径包含连续的/符号,替换成一个。
 *  3.如果**handlerMapping**不包含当前请求的url，返回404页面。
 *  4.获取路由对应的适配器**myHandlerAdapter**，并执行**handle**方法
 *  5.然后把request请求中的参数和**MyRequestParam注解**对应的参数进行命名绑定。
 *  6.通过JDK动态代理的调用路由对应的方法,并获取返回值 Object returnValue = handler.getMethod().**invoke**(handler.controller, paramValues);
 *  7.判断返回值类型,如果不是**ModelAndView**类型,则判断当前方法是否包含**MyResponseBody注解**或者类是否包含**MyRestController注解**,如果包含则通过response.getWriter().write()响应数据给浏览器，不包含则返回**ViewNotFindException**异常
 *  8.如果返回值类型是**ModelAndView**则把返回值转换成**ModelAndView**并返回
 *  9.最后在doDispatch方法中调用**processDispatchResult**解析模板视图和数据给浏览器。
 *  10.通过视图名称找到模板文件,并把数据渲染渲染到模板的表达式上。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA_size_16_color_FFFFFF_t_70 16]  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA_size_16_color_FFFFFF_t_70 17]  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA_size_16_color_FFFFFF_t_70 18]

# 五.测试效果 #

## 1.测试返回视图 ##

![在这里插入图片描述][de5420f830c446e9bd4fcd3666f38d38.png]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA_size_16_color_FFFFFF_t_70 19]  
**MyRequestParam注解**的**required**默认值是true,如果不传参数页面会返回某个参数是必填的错误提示。  
输入:http://localhost:8080/index,  
输出如下  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA_size_16_color_FFFFFF_t_70 20]  
输入： http://localhost:8080/index?test  
输出如下  
![在这里插入图片描述][00c95643a2374432acc980a9168f39ec.png]

## 2. 测试返回json数据 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA_size_16_color_FFFFFF_t_70 21]![在这里插入图片描述][2151784c481241259f31059987ec38de.png]

输入: http://localhost:8080/user/get?id=1  
输出如下:  
![在这里插入图片描述][23e8a02318ff4002bfca6c443ef3a8fb.png]

# 六. 总结 #

目前这个简配版用到的设计模式有**注册式单例模式**,**工厂模式**，**包装器模式**,**代理模式**，代码和源码比起来太粗糙了,但是把一些比较核心实现功能都列出来了,相对于读源码去理解springmvc执行流程要简单不少，由于篇幅有限,一些测试代码就没贴出来，配套代码放到gitlab上，感兴趣的可以自行下载。

github下载地址： [https://github.com/Dominick-Li/springmvc/][https_github.com_Dominick-Li_springmvc]  
要是觉得我写的对你有点帮助的话,麻烦在github上帮我点下 **Star**

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA_size_16_color_FFFFFF_t_70]: /images/20220829/32f8f488c0f04c94804a6a74e15af0fc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA_size_16_color_FFFFFF_t_70 1]: /images/20220829/8e10a73f885b42ffa3de9d74d993b636.png
[64e57ee141b34ac5bd5ac1dda3999403.png]: /images/20220829/b9e26dfbc80f44d7a094dbe5e979be0c.png
[123436be9f1448ddb46ec8db3f0e17f7.png]: /images/20220829/8288765a2a7b44968dc6d03098a49e23.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA_size_16_color_FFFFFF_t_70 2]: /images/20220829/e80a992674a046139e90dcb3e7c8283f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA_size_16_color_FFFFFF_t_70 3]: /images/20220829/b35c5eb0ae844f2693797ea7f08ceef4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA_size_16_color_FFFFFF_t_70 4]: /images/20220829/7751dba44297405bb5a2a0cabe60b3f6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA_size_16_color_FFFFFF_t_70 5]: /images/20220829/73776d8f51b7464d9a05acfcbcdec93d.png
[9df5cc57c4d248e38a9b4186bba34324.png]: /images/20220829/f79a0c84590a4968b0cdee81412f60f9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA_size_16_color_FFFFFF_t_70 6]: /images/20220829/d0337739fd3b4020a0e2f889808e1eb8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA_size_16_color_FFFFFF_t_70 7]: /images/20220829/3b0ef56da01b493397d2ff5ba891b8bc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA_size_16_color_FFFFFF_t_70 8]: /images/20220829/22bf4de59779423da505fa9ec976c745.png
[c5ab0d761e534cea97c71d45f5c4bb5f.png]: /images/20220829/396bc16ab13045ac809f55a33df1f457.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA_size_16_color_FFFFFF_t_70 9]: /images/20220829/8a6cd5ec61854af49be5156a86be1622.png
[750456554d2e4255849b29dea612a157.png]: /images/20220829/deef86d9c5cc4cedb7961156a2054db3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA_size_16_color_FFFFFF_t_70 10]: /images/20220829/928654a3f4f9477aa3b27c899fa71419.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA_size_16_color_FFFFFF_t_70 11]: /images/20220829/0bcbf5f9ced04cac909354e22f5ca10f.png
[a376c0fc316947c592881bfe1e0670ef.png]: /images/20220829/676d7ec9e68c43608dbbde1f445a9b58.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA_size_16_color_FFFFFF_t_70 12]: /images/20220829/55d09b73f575425789eef0d308fc03d2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA_size_16_color_FFFFFF_t_70 13]: /images/20220829/45b17ed8c6d64a5180458f73c8b91fa0.png
[fda06d6b55264d8f892cd2df896ee7a1.png]: /images/20220829/f0cea01235f04f7d876604e10c0ce3e7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA_size_16_color_FFFFFF_t_70 14]: /images/20220829/f4f4677e07ff497db5e696c76931a101.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA_size_16_color_FFFFFF_t_70 15]: /images/20220829/23096601d2c348fd86899f0d2d1e6550.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA_size_16_color_FFFFFF_t_70 16]: /images/20220829/fe81c1a43e214dbf8487b20b346db927.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA_size_16_color_FFFFFF_t_70 17]: /images/20220829/cd24161ee6814e1684bd018fc517634e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA_size_16_color_FFFFFF_t_70 18]: /images/20220829/56a8e67850b74b55b6b87d3a0185e270.png
[de5420f830c446e9bd4fcd3666f38d38.png]: /images/20220829/40fb3a94140b4b6bb8f02096560a8f5a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA_size_16_color_FFFFFF_t_70 19]: /images/20220829/0118b89995e544a29c25a408580f1a18.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA_size_16_color_FFFFFF_t_70 20]: /images/20220829/e428f4753d4b4f53a7df5589e01b589c.png
[00c95643a2374432acc980a9168f39ec.png]: /images/20220829/c24e6331565e48949f49188599edf0fb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA_size_16_color_FFFFFF_t_70 21]: https://img-blog.csdnimg.cn/cac50c50487b43c48c62370a6e5c25df.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA==,size_16,color_FFFFFF,t_70
[2151784c481241259f31059987ec38de.png]: /images/20220829/ad6a5532be634c24a59d6fad4c9c25af.png
[23e8a02318ff4002bfca6c443ef3a8fb.png]: /images/20220829/368c15f389b04eda87ca36e5423fed8f.png
[https_github.com_Dominick-Li_springmvc]: https://github.com/Dominick-Li/springmvc/