徒手撸一个Spring MVC框架

Posted Java大联盟

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了徒手撸一个Spring MVC框架相关的知识,希望对你有一定的参考价值。

  Java大联盟

  致力于最高效的Java学习


徒手撸一个Spring MVC框架


今天我们来仿写一个 Spring MVC 框架,用到的技术比较简单,只需要 XML 解析+反射就可以完成,不需要 JDK 动态代理。


自己手写框架的前提是必须理解框架的底层原理和运行机制,所以我们还是先来回顾一下 Spring MVC 的实现原理。


核心组件


1、DispatcherServlet:前端控制器,负责调度其他组件的执行,可降低不同组件之间的耦合性,是整个 Spring MVC 的核心模。


2、Handler:处理器,完成具体业务逻辑,相当于 Servlet 或 Action。


3、HandlerMapping:DispatcherServlet 是通过 HandlerMapping 将请求映射到不同的 Handler。


4、HandlerInterceptor:处理器拦截器,是一个接口,如果我们需要做一些拦截处理,可以来实现这个接口。


5、HandlerExecutionChain:处理器执行链,包括两部分内容:Handler 和 HandlerInterceptor(系统会有一个默认的 HandlerInterceptor,如果需要额外拦截处理,可以添加拦截器设置)。


6、HandlerAdapter:处理器适配器,Handler 执行业务方法之前,需要进行一系列的操作包括表单数据的验证,数据类型的转换,将表单数据封装到 POJO 等等,这一系列的操作,都是由 HandlerAdapter 来完成,DispatcherServlet 通过 HandlerAdapter 执行不同的 Handler。


7、ModelAndView:装载了模型数据和视图信息,作为 Handler 的处理结果,返回给 DispatcherServlet。


8、ViewResolver:视图解析器,DispatcherServlet 通过它将逻辑视图解析成物理视图,最终将渲染结果响应给客户端。


以上就是 Spring MVC 的核心组件。那么这些组件之间是如何进行交互的呢?



工作流程


1、户端请求被 DispatcherServlet(前端控制器)接收。


2、根据 Handler Mapping映射到 Handler。


3、生成 Handler 和 HandlerInterceptor(如果有则生成)。


4、Handler 和 HandlerInterceptor 以 HandlerExecutionChain 的形式一并返回给 DispatcherServlet。


5、DispatcherServlet 通过 HandlerAdapter 调用 Handler 的方法做业务逻辑处理。


6、返回一个 ModelAndView 对象给 DispatcherServlet。


7、DispatcherServlet 将获取的 ModelAndView 对象传给 ViewResolver 视图解析器,将逻辑视图解析成物理视图 View。


8、ViewResolver 返回一个 View 给 DispatcherServlet。


9、DispatcherServlet 根据 View 进行视图渲染(将模型数据填充到视图中)。


10、DispatcherServlet 将渲染后的视图响应给客户端。


如下图所示。


徒手撸一个Spring MVC框架

通过以上的分析,大致可以将 Spring MVC 流程理解如下:


首先需要一个前置控制器 DispatcherServlet,作为整个流程的核心,由它去调用其他组件,共同完成业务。


主要组件有两个:


一是 Controller,调用其业务方法 Method,执行业务逻辑。


二是 ViewResolver 视图解析器,将业务方法的返回值解析为物理视图+模型数据,返回客户端。


我们自己写框架就按照这个思路来。



初始化工作


1、根据 Spring IoC 容器的特性,需要将参与业务的对象全部创建并保存到容器中,供流程调用。首先需要创建 Controller 对象,HTTP 请求是通过注解找到对应的 Controller 对象,所以我们需要将所有的 Controller 与其注解建立关联,很显然,使用 key-value 结构的 Map 集合来保存最合适不过了,这样就模拟了 IoC 容器。


2、Controller 的 Method 也是通过注解与 HTTP 请求映射的,同样的,我们需要将所有的 Method 与其注解建立关联, HTTP 直接通过注解的值找到对应的 Method,这里也用 Map 集合保存。


3、实例化视图解析器。


初始化工作完成,接下来处理 HTTP 请求,业务流程如下:


1、DispatcherServlet 接收请求,通过映射从 IoC 容器中获取对应的 Controller 对象。


2、根据映射获取 Controller 对象对应的 Method。


3、调用 Method,获取返回值。


4、将返回值传给视图解析器,返回物理视图。


5、完成页面跳转。



思路捋清楚了,接下来开始写代码,我们需要创建下面这四个类:


1、MyDispatcherServlet:模拟 DispatcherServlet。


2、MyController:模拟 Controller 注解。


3、MyRequestMapping:模拟 RequestMapping 注解。


4、MyViewResolver:模拟 ViewResolver 视图解析器。



首先创建 MyDispatcherServlet,init 方法完成初始化:


1、将 Controller 与注解进行关联,保存到 iocContainer 中,哪些 Controller 是需要添加到 iocContainer 中的?


必须同时满足两点:


(1)springmvc.xml 中配置扫描的类。


(2)类定义处添加了注解。


注意这两点必须同时满足。


代码思路


(1)解析 springmvc.xml。


(2)获取 component-scan 标签配置的包下的所有类。


(3)判断若这些类添加了 @MyController 注解,则创建实例对象,并且保存到 iocContainer。


@MyRequestMapping 的值为键,Controller 对象为值。



2、将 Controller 中的 Method 与注解进行关联,保存到 handlerMapping 中。


代码思路


(1)遍历 iocContainer 中的 Controller 实例对象。


(2)遍历每一个 Controlle r对象的 Method。


(3)判断 Method 是否添加了 @MyRequestMapping 注解,若添加,则进行映射并保存。


(4)保存到 handlerMapping 中,@MyRequestMapping 的值为键,Method 为值。



3、实例化 ViewResolver。


代码思路


(1)解析 springmvc.xml。


(2)根据 bean 标签的 class 属性获取需要实例化的 MyViewResolver。


(3)通过反射创建实例化对象,同时获取 prefix 和 suffix 属性,以及 setter 方法。


(通过反射调用 setter 方法给属性赋值,完成 MyViewResolver 的实例化。



doPost 方法处理 HTTP 请求的流程:


(1)解析 HTTP,分别得到 Controller 和 Method 对应的 uri。


(2)通过 uri 分别在 iocContainer 和 handlerMapping 中获取对应的 Controller 以及 Method。


(3)通过反射调用 Method,执行业务方法,获取结果。


(4)将结果传给 MyViewResolver 进行解析,返回真正的物理视图(JSP 页面)。


(5)完成 JSP 页面跳转。


徒手撸一个Spring MVC框架



代码实现


1、创建 MyController 注解,作用目标为类。


/**
 * 自定义Controller注解
 * @author southwind
 *
 */

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


2、创建 MyRequestMapping 注解,作用目标为类和方法。


/**
 * 自定义RequestMapping注解
 * @author southwind
 *
 */

@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyRequestMapping {
    String value() default "";
}


3、创建 MyDispatcherServlet,核心控制器,init 完成初始化工作,doPost 处理 HTTP 请求。


/**
 * DispatcherServlet
 * @author southwind
 *
 */

public class MyDispatcherServlet extends HttpServlet{

    //模拟IOC容器,保存Controller实例对象
    private Map<String,Object> iocContainer = new HashMap<String,Object>();
    //保存handler映射
    private Map<String,Method> handlerMapping = new HashMap<String,Method>();
    //自定视图解析器
    private MyViewResolver myViewResolver;

    @Override
    public void init(ServletConfig config) throws ServletException {
        // TODO Auto-generated method stub
        //扫描Controller,创建实例对象,并存入iocContainer
        scanController(config);
        //初始化handler映射
        initHandlerMapping();
        //加载视图解析器
        loadViewResolver(config);
    }

    /**
     * 扫描Controller
     * @param config
     */

    public void scanController(ServletConfig config){
        SAXReader reader = new SAXReader();
        try {
            //解析springmvc.xml
            String path = config.getServletContext().getRealPath("")+"\\WEB-INF\\classes\\"+config.getInitParameter("contextConfigLocation");   
            Document document = reader.read(path);
            Element root = document.getRootElement();
            Iterator iter = root.elementIterator();
            while(iter.hasNext()){
                Element ele = (Element) iter.next();
                if(ele.getName().equals("component-scan")){
                    String packageName = ele.attributeValue("base-package");
                    //获取base-package包下的所有类名
                    List<String> list = getClassNames(packageName);
                    for(String str:list){
                        Class clazz = Class.forName(str);
                        //判断是否有MyController注解
                        if(clazz.isAnnotationPresent(MyController.class)){
                            //获取Controller中MyRequestMapping注解的value
                            MyRequestMapping annotation = (MyRequestMapping) clazz.getAnnotation(MyRequestMapping.class);
                            String value = annotation.value().substring(1);
                            //Controller实例对象存入iocContainer
                            iocContainer.put(value, clazz.newInstance());
                        }
                    }
                }
            }
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    /**
     * 获取包下的所有类名
     * @param packageName
     * @return
     */

    public List<String> getClassNames(String packageName){
        List<String> classNameList = new ArrayList<String>();
        String packagePath = packageName.replace(".""/");  
        ClassLoader loader = Thread.currentThread().getContextClassLoader();  
        URL url = loader.getResource(packagePath);  
        if(url != null){
            File file = new File(url.getPath());  
            File[] childFiles = file.listFiles();
            for(File childFile : childFiles){
                String className = packageName+"."+childFile.getName().replace(".class""");
                classNameList.add(className);
            }
        }
        return classNameList;
    }

    /**
     * 初始化handler映射
     */

    public void initHandlerMapping(){
        for(String str:iocContainer.keySet()){
            Class clazz = iocContainer.get(str).getClass();
            Method[] methods = clazz.getMethods();
               for (Method method : methods) {
                 //判断方式是否添加MyRequestMapping注解
                 if(method.isAnnotationPresent(MyRequestMapping.class)){
                     //获取Method中MyRequestMapping注解的value
                     MyRequestMapping annotation = method.getAnnotation(MyRequestMapping.class);
                     String value = annotation.value().substring(1);
                     //method存入methodMapping
                     handlerMapping.put(value, method);
                 }
             }
        }
    }

    /**
     * 加载自定义视图解析器
     * @param config
     */

    public void loadViewResolver(ServletConfig config){
        SAXReader reader = new SAXReader();
        try {
            //解析springmvc.xml
            String path = config.getServletContext().getRealPath("")+"\\WEB-INF\\classes\\"+config.getInitParameter("contextConfigLocation");   
            Document document = reader.read(path);
            Element root = document.getRootElement();
            Iterator iter = root.elementIterator();
            while(iter.hasNext()){
                Element ele = (Element) iter.next();
                if(ele.getName().equals("bean")){
                    String className = ele.attributeValue("class");
                    Class clazz = Class.forName(className);
                    Object obj = clazz.newInstance();
                    //获取setter方法
                    Method prefixMethod = clazz.getMethod("setPrefix", String.class);
                    Method suffixMethod = clazz.getMethod("setSuffix", String.class);
                    Iterator beanIter = ele.elementIterator();
                    //获取property值
                    Map<String,String> propertyMap = new HashMap<String,String>();
                    while(beanIter.hasNext()){
                        Element beanEle = (Element) beanIter.next();
                        String name = beanEle.attributeValue("name");
                        String value = beanEle.attributeValue("value");
                        propertyMap.put(name, value);
                    }
                    for(String str:propertyMap.keySet()){
                        //反射机制调用setter方法,完成赋值。
                        if(str.equals("prefix")){
                            prefixMethod.invoke(obj, propertyMap.get(str));
                        }
                        if(str.equals("suffix")){
                            suffixMethod.invoke(obj, propertyMap.get(str));
                        }
                    }
                    myViewResolver = (MyViewResolver) obj;
                }
            }
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException 
{
        // TODO Auto-generated method stub
        this.doPost(req, resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException 
{
        // TODO Auto-generated method stub
        //获取请求
        String handlerUri = req.getRequestURI().split("/")[2];
        //获取Controller实例
        Object obj = iocContainer.get(handlerUri);
        String methodUri = req.getRequestURI().split("/")[3];
        //获取业务方法
        Method method = handlerMapping.get(methodUri);
        try {
            //反射机制调用业务方法
            String value = (String) method.invoke(obj);
            //视图解析器将逻辑视图转换为物理视图
            String result = myViewResolver.jspMapping(value);
            //页面跳转
            req.getRequestDispatcher(result).forward(req, resp);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } 
    }
}


4、创建视图解析器 MyViewResolver。


/**
 * 自定义视图解析器
 * @author southwind
 *
 */

public class MyViewResolver {
    private String prefix;
    private String suffix;
    public String getPrefix() {
        return prefix;
    }
    public void setPrefix(String prefix) {
        this.prefix = prefix;
    }
    public String getSuffix() {
        return suffix;
    }
    public void setSuffix(String suffix) {
        this.suffix = suffix;
    }

    public String jspMapping(String value){
        return this.prefix+value+this.suffix;
    }
}


5、创建 TestController,处理业务请求。


@MyController
@MyRequestMapping(value = "/testController")
public class TestController {
    @MyRequestMapping(value = "/test")
    public String test(){
        System.out.println("执行test相关业务");
        return "index";
    }
}


6、测试。


徒手撸一个Spring MVC框架


跳转 index.jsp,同时控制台打印业务日志,访问成功。



总结


本文讲解了 Spring MVC 的底层原理,同时仿照 Spring MVC 手写了一个简单的框架,目的不是让大家自己去写框架,在实际开发中我们也不需要自己写框架,直接使用成熟的第三方框架即可。手写框架的目的在于让大家更透彻地理解 Spring MVC 的底层流程,学习优秀框架的编程思想,理解了原理,才能更熟练地应用。



以上内容来自楠哥的达人课「案例上手 Spring 全家桶」,今天给大家申请到一波福利,原价 99 元的课程,限时优惠仅售 49 元,并且只开放 50 个名额,截止当前仅剩 13 个名额,需要的老铁抓紧时间抢购了。


徒手撸一个Spring MVC框架





 

推荐阅读


以上是关于徒手撸一个Spring MVC框架的主要内容,如果未能解决你的问题,请参考以下文章

徒手撸了一个RPC框架,理解更透彻了,代码已上传github,自取~

徒手撸出一个类Flask微框架根据业务进行路由分组

徒手生撸一个验证框架,API 参数校验不再怕!

徒手撸一个简单的RPC框架(附源码)

从零开始,徒手撸一个简单的 RPC 框架,轻松搞定!

徒手撸出一个类Flask微框架路由及路由注册的演变