Spring源码------手写体验MVC(升级版)

最新推荐文章于 2024-06-09 16:06:06 发布
最新推荐文章于 2024-06-09 16:06:06 发布
阅读量156 收藏
点赞数
分类专栏： springmvc spring 文章标签： java spring mvc bean
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qqq3117004957/article/details/106023189
版权

Spring------手写体验MVC(升级版)

目录

Spring------手写体验MVC(升级版)

1、前言

2、构建思想

2.1 Spring MVC的大致工作流程

2.2 Spring MVC的九大组件

2.3 Spring MVC的核心执行流程

3、核心代码

4、总结

1、前言

本篇博客并非是对Spring源码的深入研究。而是对上一篇博客《Spring源码------手写体验MVC》结构的优化：进行职责对的解耦。过程中主要是体验Spring IOC和DI的初始化过程。那么这篇博客涉及到的知识点大致有以下几点：

  • 如何自定义注解，如何通过反射机制去赋予注解强大的功能（说白了，就是体验在反射机制下，注解功能是多么的强大）
  • Spring Ioc容器的实现原理
  • Spring DI 注解注入
  • Java反射机制
  • Java I/O流（加载配置文件，读取配置文件信息） 
  • 正则表达式
     

2、构建思想

2.1 Spring MVC的大致工作流程

img

  • 用户发送请求至前端控制器DispatcherServlet；
  •  DispatcherServlet收到请求后，调用HandlerMapping处理器映射器，请求获取Handle；
  • 处理器映射器根据请求url找到具体的处理器，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet；
  • DispatcherServlet 调用 HandlerAdapter处理器适配器；
  • HandlerAdapter 经过适配调用 具体处理器(Handler，也叫后端控制器)；
  • Handler执行完成返回ModelAndView；
  • HandlerAdapter将Handler执行结果ModelAndView返回给DispatcherServlet；
  • DispatcherServlet将ModelAndView传给ViewResolver视图解析器进行解析；
  • ViewResolver解析后返回具体View；
  • DispatcherServlet对View进行渲染视图（即将模型数据填充至视图中）
  • DispatcherServlet响应用户。

2.2 Spring MVC的九大组件

SpringMVC九大组件
序号组件名解释
1MultipartResolver多文件上传组件
2LocaleResolver本地语言环境
3ThemeResolver主题模板处理器
4HandlerMapping保存Url映射关系
5HandlerAdapter动态参数适配器
6HandlerExceptiomResolver异常拦截器
7RequestToViewNameTransltor视图读取器，从request中获取viewname
8ViewResolvers视图转换器，模板引擎
9FlashMapManager参数缓存器

 

 

 

 

 

 

 

 

 

2.3 Spring MVC的核心执行流程

3、核心代码

3.1 核心类结构图

      

3.2 核心代码

/**
 * @description: 委派模式，职责：负责任务调度，请求分发
 * @author: zps
 * @create: 2020-05-09 8:25
 **/
public class ZPSDispatcherServlet extends HttpServlet {

    private ZPSApplicationContext applicationContext;

    private List<ZPSHandlerMapping> handlerMappings = new ArrayList<ZPSHandlerMapping>();

    private Map<ZPSHandlerMapping, ZPSHandlerAdapter> handlerAdapters = new HashMap<ZPSHandlerMapping, ZPSHandlerAdapter>();

    private List<ZPSViewResolver> viewResolvers = new ArrayList<ZPSViewResolver>();

    @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 {

        //委派,根据URL去找到一个对应的Method并通过response返回
        try {
            doDispatch(req,resp);
        } catch (Exception e) {
            try {
                processDispatchResult(req,resp,new ZPSModelAndView("500"));
            } catch (Exception e1) {
                e1.printStackTrace();
                resp.getWriter().write("500 Exception,Detail : " + Arrays.toString(e.getStackTrace()));
            }
        }

    }
    @Override
    public void init(ServletConfig config) throws ServletException {

        //初始化Spring核心IoC容器
        applicationContext = new ZPSApplicationContext(config.getInitParameter("contextConfigLocation"));

        //初始化SpringMVC的九大组件
        initStrategies(applicationContext);

        System.out.println("GP Spring framework is init.");
    }

    //核心处理
    private void doDispatch(HttpServletRequest req, HttpServletResponse resp) throws Exception {
        //完成了对HandlerMapping的封装
        //完成了对方法返回值的封装ModelAndView

        //通过URL获得一个HandlerMapping
        ZPSHandlerMapping handler = getHandler(req);
        if(handler == null){
            processDispatchResult(req,resp,new ZPSModelAndView("404"));
            return;
        }
        
        //根据一个HandlerMaping获得一个HandlerAdapter
        ZPSHandlerAdapter ha = getHandlerAdapter(handler);

        //解析某一个方法的形参和返回值之后，统一封装为ModelAndView对象
        ZPSModelAndView mv = ha.handler(req,resp,handler);

        //就把ModelAndView变成一个ViewResolver
        processDispatchResult(req,resp,mv);

    }

    private ZPSHandlerAdapter getHandlerAdapter(ZPSHandlerMapping handler) {
        if(this.handlerAdapters.isEmpty()){return null;}
        return this.handlerAdapters.get(handler);
    }

    private void processDispatchResult(HttpServletRequest req, HttpServletResponse resp, ZPSModelAndView mv) throws Exception {
        if(null == mv){return;}
        if(this.viewResolvers.isEmpty()){return;}

        for (ZPSViewResolver viewResolver : this.viewResolvers) {
            ZPSView view = viewResolver.resolveViewName(mv.getViewName());
            //直接往浏览器输出
            view.render(mv.getModel(),req,resp);
            return;
        }
    }

    private ZPSHandlerMapping getHandler(HttpServletRequest req) {
        if(this.handlerMappings.isEmpty()){return  null;}
        String url = req.getRequestURI();
        String contextPath = req.getContextPath();
        url = url.replaceAll(contextPath,"").replaceAll("/+","/");

        for (ZPSHandlerMapping mapping : handlerMappings) {
            Matcher matcher = mapping.getPattern().matcher(url);
            if(!matcher.matches()){continue;}
            return mapping;
        }
        return null;
    }


    //这里主要是进行九大主键的初始化
    private void initStrategies(ZPSApplicationContext context) {
//        //多文件上传的组件
//        initMultipartResolver(context);
//        //初始化本地语言环境
//        initLocaleResolver(context);
//        //初始化模板处理器
//        initThemeResolver(context);

        //c初始化处理器映射器
        initHandlerMappings(context);

        //初始化参数适配器
        initHandlerAdapters(context);

//        //初始化异常拦截器
//        initHandlerExceptionResolvers(context);
//        //初始化视图预处理器
//        initRequestToViewNameTranslator(context);

        //初始化视图转换器
        initViewResolvers(context);
//        //FlashMap管理器
//        initFlashMapManager(context);
    }

    //初始化视图转换器
    private void initViewResolvers(ZPSApplicationContext context) {
        String templateRoot = context.getConfig().getProperty("templateRoot");
        String templateRootPath = this.getClass().getClassLoader().getResource(templateRoot).getFile();

        File templateRootDir = new File(templateRootPath);
        for (File file : templateRootDir.listFiles()) {
            this.viewResolvers.add(new ZPSViewResolver(templateRoot));
        }
    }

    private void initHandlerAdapters(ZPSApplicationContext context) {
        for (ZPSHandlerMapping handlerMapping : handlerMappings) {
            this.handlerAdapters.put(handlerMapping,new ZPSHandlerAdapter());
        }
    }
    //初始化处理器映射器
    private void initHandlerMappings(ZPSApplicationContext context) {
        if(this.applicationContext.getBeanDefinitionCount() == 0){ return;}

        for (String beanName : this.applicationContext.getBeanDefinitionNames()) {
            Object instance = applicationContext.getBean(beanName);
            Class<?> clazz = instance.getClass();

            if(!clazz.isAnnotationPresent(ZPSController.class)){ continue; }

            //相当于提取 class上配置的url
            String baseUrl = "";
            if(clazz.isAnnotationPresent(ZPSRequestMapping.class)){
                ZPSRequestMapping requestMapping = clazz.getAnnotation(ZPSRequestMapping.class);
                baseUrl = requestMapping.value();
            }

            //只获取public的方法
            for (Method method : clazz.getMethods()) {
                if(!method.isAnnotationPresent(ZPSRequestMapping.class)){continue;}
                //提取每个方法上面配置的url
                ZPSRequestMapping requestMapping = method.getAnnotation(ZPSRequestMapping.class);

                // //demo//query
                String regex = ("/" + baseUrl + "/" + requestMapping.value().replaceAll("\\*",".*")).replaceAll("/+","/");
                Pattern pattern = Pattern.compile(regex);
                //handlerMapping.put(url,method);
                handlerMappings.add(new ZPSHandlerMapping(pattern,instance,method));
                System.out.println("Mapped : " + regex + "," + method);
            }

        }
    }

}
/**
 * @description: 处理器映射器，由相应的url找到相应的handler
 * @author: zps
 * @create: 2020-05-09 8:30
 **/
public class ZPSHandlerMapping {
    private Pattern pattern;     //URL
    private Method method;  //对应的Method
    private Object controller;//Method对应的实例对象

    public ZPSHandlerMapping(Pattern pattern, Object controller, Method method) {
        this.pattern = pattern;
        this.method = method;
        this.controller = controller;
    }

    public Pattern getPattern() {
        return pattern;
    }

    public void setPattern(Pattern pattern) {
        this.pattern = pattern;
    }

    public Method getMethod() {
        return method;
    }

    public void setMethod(Method method) {
        this.method = method;
    }

    public Object getController() {
        return controller;
    }

    public void setController(Object controller) {
        this.controller = controller;
    }
}
/**
 * @description: 处理器适配器，这里主要是完成请求方法与处理方法的参数转换
 * @author: zps
 * @create: 2020-05-09 9:30
 **/
public class ZPSHandlerAdapter {

    public ZPSModelAndView handler(HttpServletRequest req, HttpServletResponse resp, ZPSHandlerMapping handler) throws Exception{

        //保存形参列表
        //将参数名称和参数的位置，这种关系保存起来
        Map<String,Integer> paramIndexMapping = new HashMap<String, Integer>();

        //通过运行时的状态
        Annotation[] [] pa = handler.getMethod().getParameterAnnotations();
        for (int i = 0; i < pa.length ; i ++) {
            for(Annotation a : pa[i]){
                if(a instanceof ZPSRequestParam){
                    String paramName = ((ZPSRequestParam) a).value();
                    if(!"".equals(paramName.trim())){
//                        String value = Arrays.toString(params.get(paramName))
//                                .replaceAll("\\[|\\]","")
//                                .replaceAll("\\s+",",");
//                        paramValues[i] = value;
                        paramIndexMapping.put(paramName,i);
                    }
                }
            }
        }

        //初始化一下
        Class<?> [] paramTypes = handler.getMethod().getParameterTypes();
        for (int i = 0; i < paramTypes.length; i++) {
            Class<?> paramterType = paramTypes[i];
            if(paramterType == HttpServletRequest.class || paramterType == HttpServletResponse.class){
                paramIndexMapping.put(paramterType.getName(),i);
            }
        }


        //去拼接实参列表
        Map<String,String[]> params = req.getParameterMap();

        Object [] paramValues = new Object[paramTypes.length];

        for (Map.Entry<String,String[]> param : params.entrySet()) {
            String value = Arrays.toString(params.get(param.getKey()))
                    .replaceAll("\\[|\\]","")
                    .replaceAll("\\s+",",");

            if(!paramIndexMapping.containsKey(param.getKey())){continue;}

            int index = paramIndexMapping.get(param.getKey());

            //允许自定义的类型转换器Converter，这里硬编码
            paramValues[index] = castStringValue(value,paramTypes[index]);
        }

        if(paramIndexMapping.containsKey(HttpServletRequest.class.getName())){
            int index = paramIndexMapping.get(HttpServletRequest.class.getName());
            paramValues[index] = req;
        }

        if(paramIndexMapping.containsKey(HttpServletResponse.class.getName())){
            int index = paramIndexMapping.get(HttpServletResponse.class.getName());
            paramValues[index] = resp;
        }

        Object result = handler.getMethod().invoke(handler.getController(),paramValues);
        if(result == null || result instanceof Void){return null;}

        boolean isModelAndView = handler.getMethod().getReturnType() == ZPSModelAndView.class;
        if(isModelAndView){
            return (ZPSModelAndView)result;
        }
        return null;
    }

    private Object castStringValue(String value, Class<?> paramType) {
        if(String.class == paramType){
            return value;
        }else if(Integer.class == paramType){
            return Integer.valueOf(value);
        }else if(Double.class == paramType){
            return Double.valueOf(value);
        }else {
            if(value != null){
                return value;
            }
            return null;
        }

    }
}
/**
 * @description: 返回结果封装
 * @author: zps
 * @create: 2020-05-09 11:30
 **/
public class ZPSModelAndView {
    private String viewName;   //视图名
    private Map<String,?> model;  //返回结果

    public ZPSModelAndView(String viewName, Map<String, ?> model) {
        this.viewName = viewName;
        this.model = model;
    }

    public ZPSModelAndView(String viewName) {
        this.viewName = viewName;
    }

    public String getViewName() {
        return viewName;
    }

    public Map<String, ?> getModel() {
        return model;
    }
}
/**
 * @description: 视图解析器
 * @author: zps
 * @create: 2020-05-09 11:40
 **/
public class ZPSViewResolver {
    private final String DEFAULT_TEMPLATE_SUFFIX = ".html";
    private File tempateRootDir;
    public ZPSViewResolver(String templateRoot) {
        String templateRootPath = this.getClass().getClassLoader().getResource(templateRoot).getFile();
        tempateRootDir = new File(templateRootPath);
    }

    public ZPSView resolveViewName(String viewName){
        if(null == viewName || "".equals(viewName.trim())){return null;}
        viewName = viewName.endsWith(DEFAULT_TEMPLATE_SUFFIX)? viewName : (viewName + DEFAULT_TEMPLATE_SUFFIX);
        File templateFile = new File((tempateRootDir.getPath() + "/" + viewName).replaceAll("/+","/"));
        return new ZPSView(templateFile);
    }

}
/**
 * @description: 视图渲染
 * @author: zps
 * @create: 2020-05-09 12:40
 **/
public class ZPSView {

    private File viewFile;
    public ZPSView(File templateFile) {
        this.viewFile = templateFile;
    }

    //渲染
    public void render(Map<String, ?> model, HttpServletRequest req, HttpServletResponse resp) throws Exception {
        StringBuffer sb = new StringBuffer();
        RandomAccessFile ra = new RandomAccessFile(this.viewFile,"r");

        String line = null;
        while (null != (line = ra.readLine())){
            line = new String(line.getBytes("ISO-8859-1"),"utf-8");
            Pattern pattern = Pattern.compile("￥\\{[^\\}]+\\}",Pattern.CASE_INSENSITIVE);
            Matcher matcher = pattern.matcher(line);
            while (matcher.find()){
                String paramName = matcher.group();
                paramName = paramName.replaceAll("￥\\{|\\}","");
                Object paramValue = model.get(paramName);
                line = matcher.replaceFirst(makeStringForRegExp(paramValue.toString()));
                matcher = pattern.matcher(line);
            }
            sb.append(line);
        }
        resp.setCharacterEncoding("utf-8");
        resp.getWriter().write(sb.toString());
    }

    //处理特殊字符
    public static String makeStringForRegExp(String str) {
        return str.replace("\\", "\\\\").replace("*", "\\*")
                .replace("+", "\\+").replace("|", "\\|")
                .replace("{", "\\{").replace("}", "\\}")
                .replace("(", "\\(").replace(")", "\\)")
                .replace("^", "\\^").replace("$", "\\$")
                .replace("[", "\\[").replace("]", "\\]")
                .replace("?", "\\?").replace(",", "\\,")
                .replace(".", "\\.").replace("&", "\\&");
    }
}

4、总结

结合前面三篇博客，大致可以得出Spring框架的初始化过程和原理：

  • 首先就是初始化Spring IoC 容器  (Ioc和DI)

       1. 根据配置文件的信息，扫描相关的包，然后将类信息封装成BeanDefinition对象

       2.  把BeanDefinition进行缓存，如果是延迟加载，则在进行getBean()时获取相关的BeanDefinition进行实例化

       3.当调用getBean()方法时，创建Bean实例，并对创建的实例进行一层包装，封装成BeanWrapper对象进行缓存

       4.进行bean的一个属性依赖注入 

  • Spring MVC启动时调用init()方法，进行九大组件的初始化（这里只介绍三个）

       1.初始化处理器映射器，即把处理器的url与handler（也就是我们常用的RequestMapping注解方法）进行绑定

       2.初始化处理器适配器，主要是进行handler请求与用户请求中参数的适配

       3.初始化视图解析器，主要是对相应视图模板进行初始化

  • 初始化后，便可以进行请求的处理了

 

个人一点小结，若有误，希望指出！！！！

萌之兰
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springmvc简单实现版本
12-05
springmvc注解版本和非注解版本的简单实现！！！！！！！
handwritten-mvc:手写Spring框架
05-10
handwritten-mvc-framwork 为自己实现的Spring框架 handwritten-mvc-example 为该框架的实例 数据库表 user.sql 在 handwritten-mvc-exampl 的 resources 目录中. 数据库名可以在 handwritten.properties 中修改. ...
SpringMVC学习笔记
weixin_46684099的博客
03-26 503
前言: 学习B站UP主狂神说[SpringMVC]视频笔记整理 B站链接 简介 什么是MVC 1.MVC是模型(Model)、视图(View)、控制器(Controller)的简写，是一种软件设计规范。 2.是将业务逻辑、数据、显示分离的方法来组织代码。 3.MVC主要作用是降低了视图与业务逻辑间的双向偶合。 4.MVC不是一种设计模式，MVC是一种架构模式。 5.当然不同的MVC存在差异。 Model（模型）：数据模型，提供要展示的数据，因此包含数据和行为，可以认为是领域模型或JavaBean组件（包
SpringMVC
2301_78834737的博客
07-29 556
SpringMVC 是一种基于 Java 的实现 MVC 设计模型的请求驱动类型的轻量级 Web 框架，属于SpringFrameWork的后续产品，已经融合在 Spring Web Flow 中。SpringMVC已经成为目前最主流的MVC框架之一。SpringMVC的作用：作为前端控制器，控制请求的共有行为，在传统的JavaEE技术中，只使用Servlet作为控制器，当每个功能都需要一个servlet程序相似功能也无法分开封装，另外，传统的开发模式也存在其它使用不便利的做法。
spring mvc 各版本包下载
RenDuData的博客
12-21 2698
http://repo.spring.io/release/org/springframework/spring/
手写Spring源码+MVC架构
11-30
手写Spring源码+MVC架构
springmvc-master.zip
09-19
第一篇 - 手写SpringMvc框架 博客地址：https://blog.csdn.net/m0_37499059/article/details/100940663
仿 Spring 手写 MVC 框架_源码.rar
11-02
《仿 Spring 手写 MVC 框架》博客附件。 博客地址：https://blog.csdn.net/Supreme_Sir/article/details/109445930
00-myspring.war
09-03
本文通过手写Spring，实现Spring MVC基本功能，为学习Spring源码做准备。分三个阶段： 配置阶段：设置application.properties和定义Annotation。 初始化阶段：重写Servlet的init方法，实现加载配置文件，读取配置...
springmvc的idea版本的开发
03-04
本版本使用springmvc的注解开发，里面包括了spring和mybatis的注解整合，使用了idea的版本，适合小白使用，关于数据库的表，我截了图放在里面，解压导入使用即可
SpringMvc 最新版官网下载spring 开发jar包以及文档 各种版本下载
03-12
SpringMvc 各种版本jar包下载，里面是文本，带下载地址
springMVC相应的相同版本的jar包。
09-22
相同版本的jar包才能够运行，否则就就回报错java.lang.NoClassDefFoundError
springMVC翻译版本已更新
Technology_liu的博客
08-18 327
springMVC翻译版本已经更新，诚挚邀请技术大神光临，QQ群:756502375 码云:https://gitee.com/k2252904046/spring_mvctranslation_module github:https://github.com/liumingjunhevttc/springmvc–translation ...
Restful API SpringMVC多版本实现
lvdou_lvdou的博客
10-31 2677
项目要做多版本控制，于是百度了一下，发现有3种常用的实现方式。1.直接在url中添加版本信息，但是不符合restful要求url : http://localhost:8080/multiversion/v1/print2.在content type中添加url: http://localhost:8080/multiversion/print Content-Type:application/js
2023官方发布最新SpringMVC
qq_58360406的博客
03-20 1561
整合2023官方发布最新的springmvc内容，更多功能合特性
Spring Mvc：初识SpringMvc
siaok的博客
07-07 1028
②SpringMVC是。
Spring MVC注解版本--初识--12
m0_53157173的博客
08-11 698
在基于注解的Controller中，当前实现类将用于哪个Web请求的处理是由相应的注解标注的。比如，＠RequestMapping（“/hello”）标注的HelloController将 用于URL为"helloController"的Web请求处理。这些注解中的信息，我们需要通过Java 的反射机制（Java Reflection）来读取。无论是现有的BeanNameUrlHandlerMapping还是SimpleUrlHandlerMapping，显然都没有提供通过反射读取注解中映射信息的功能。..
简单的项目部署脚本（转载）
最新发布
u010230019的博客
06-09 680
有些项目团队喜欢使用docker启动java服务,那么我们同样可以将上述脚本稍做改造,来实现基于shell+docker的简单项目部署能力。可以将核心节点的错误或者失败内容通过webhook发送到对应的告警平台,比如钉钉、飞书机器人等。把~/.ssh/id_rsa.pub内容添加到远程仓库的ssh秘钥中。执行start.sh脚本打包部署。start.sh脚本内容。
feign-spring-mvc-starter
06-06
`feign-spring-mvc-starter` 是一个 Feign 的扩展，它支持使用 Spring MVC 注解来定义和调用 REST 服务。使用 `feign-spring-mvc-starter`，你可以像使用 Spring MVC 控制器一样定义 Feign 客户端，从而更方便地进行...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值