SpringMvc工作原理及源码分析

最新推荐文章于 2022-01-03 00:23:06 发布

随风去。

最新推荐文章于 2022-01-03 00:23:06 发布

阅读量933

点赞数

分类专栏： Spring

本文链接：https://blog.csdn.net/weixin_41358004/article/details/103676365

版权

Spring 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

　　使用过spring mvc的小伙伴都知道，mvc在使用的时候，我们只需要在controller上注解上@controller跟@requestMapping（“URL”）,当我们访问对应的路径的时候，框架便会帮我们去映射到指定的controller里面的指定方法，那么这一切都是怎么做到的呢？还有我们所传递过去的参数，为什么通过request.getParam就能轻易地拿到呢？大家都知道mvc的核心控制器DispacherServlet的基本运行流程，那么他的内部是怎么运行的呢，我们来做一下简单的实现，让我们能进一步的了解MVC。以助于我们今后的开发。

SpringMVC流程：

1、用户发送请求至前端控制器DispatcherServlet。

2、 DispatcherServlet收到请求调用HandlerMapping处理器映射器。

3、处理器映射器找到具体的处理器(可以根据xml配置、注解进行查找)，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet。

4、 DispatcherServlet调用HandlerAdapter处理器适配器。

5、 HandlerAdapter经过适配调用具体的处理器(Controller，也叫后端控制器)。

6、 Controller执行完成返回ModelAndView。

7、 HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet。

8、 DispatcherServlet将ModelAndView传给ViewReslover视图解析器。

9、 ViewReslover解析后返回具体View。

10、DispatcherServlet根据View进行渲染视图（即将模型数据填充至视图中）。

11、 DispatcherServlet响应用户。

　　此次实现基于Servlet 3.0，SpringBoot 2.0.1,采用注解的方式实现.这里我先把我的demo的工程包结构先贴出来：

　　pom文件：

<dependency>
　　<groupId>javax.servlet</groupId>
　　<artifactId>javax.servlet-api</artifactId>
　　<version>3.1.0</version>
</dependency>

　　首先，我们先从注解入手，为什么在类上面标注一下@controller以及@RequestMapping,他就能其效果呢？我们先来定义出这两个注解 @Controller :

@Target(ElementType.TYPE)//表示注解运行在哪里 这里表示只能注解再类上面
@Retention(RetentionPolicy.RUNTIME)//表示注解的(生命周期)哪来出现
public @interface WuzzController {
}

　　@RequestMapping :

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

　　@Service

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

　　@Autowired

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

　　定义完注解后，那么我们创建一个TestController 来测试一下我们自己定义的注解

@WuzzController
@WuzzRequestMapping("/wuzz")
public class TestController  extends BaseController{

    @WuzzAutowired
    private ServiceDemo serviceDemo;

    @WuzzRequestMapping("/index.do")
    public void index() {
        try {
            response.getWriter().write("index"+serviceDemo.get("wuzz"));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @WuzzRequestMapping("/index1.do")
    public void index1() {
        try {
            response.getWriter().write("index1");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @WuzzRequestMapping("/index2.do")
    public void index2() {
        try {
            response.getWriter().write("index2");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @WuzzRequestMapping("/index3.do")
    public void index3() {
        try {
            response.getWriter().write("index3");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

　　Service：

public interface ServiceDemo {

    String get(String name);
}

@WuzzService
public class ServiceDemoImpl implements ServiceDemo {
    @Override
    public String get(String name) {
        return "service demo" + name;
    }
}

　　很显然，现在我们虽然能在类，方法上注解上我们自己定义的注解，但是他们现在是起不到我们MVC框架中的效果的，在框架的内部肯定是需要有一系列操作，才能使得这些注解起效果，我们注意到，要使用MVC的时候我们通常需要配置一个注解扫描包。然后肯定是将有这些特定注解的类扫描出来，并创建出映射的路径，才能达到我们预期的效果。

　　现在我们可以做一个小小的测试：所以我这里建了一个Test类来做简单的获取指定类（TestController）里面有没有我们的注解：

public class Test {
    private static final Logger LOGGER = LogManager.getLogger(Test.class);
    public static void main(String[] args) {
        //  Class
        Class clazz = TestController.class;
        //判断这个类是否存在 @WuzzController
        if (clazz.isAnnotationPresent(WuzzController.class)) {
            LOGGER.info(clazz.getName() + "被标记为controller");
            String path = "";
            //判断clazz是否存在注解@WuzzRequestMapping
            if (clazz.isAnnotationPresent(WuzzRequestMapping.class)) {
                //取出注解的值 放入path
                WuzzRequestMapping reqAnno = 
　　　　　　　　　　　　(WuzzRequestMapping)clazz.getAnnotation(WuzzRequestMapping.class);
                path = reqAnno.value().toString();
            }

            Method[] ms = clazz.getMethods();//拿到控制类所有公开方法遍历
            for (Method method : ms) {
                //如果不存在该注解  就进入下一轮
                if (!method.isAnnotationPresent(WuzzRequestMapping.class)) {
                    continue;
                }
                LOGGER.info("方法"+method.getName()+",映射的对外路径：" + path 
　　　　　　　　　　　　+ method.getAnnotation(WuzzRequestMapping.class).value().toString());
            }
        }
    }
}

　　这里我们运行后的结果为：

　　这样我们就可以拿到指定的类里面的指定的一些注解的值，还可以做一系列的操作。好，那么现在我们需要想到的就是核心控制器DispacherServlet了。既然是servlet,我们先来看一下servlet的生命周期。Servlet 生命周期可被定义为从创建直到毁灭的整个过程。以下是 Servlet 遵循的过程：

Servlet 通过调用 init () 方法进行初始化。
Servlet 调用 service() 方法来处理客户端的请求。
Servlet 通过调用 destroy() 方法终止（结束）。
最后，Servlet 是由 JVM 的垃圾回收器进行垃圾回收的。

　　既然知道了servlet的生命周期，那就好办了，我们可以通过servlet的初始化，将指定包下的类都扫描起来，然后再重写service()方法去处理这些请求，不久可以了么？接下去我们试一试。

　　创建自己的DispacherServlet：我是再spring boot环境下去操作的。我们要配置好拦截路径，基准包并重写init(),service()方法

@WebServlet(urlPatterns = {"*.do"},loadOnStartup = 1,initParams = {@WebInitParam(name = "basePackage", value = "com.wuzz.demo")})
public class WuzzDispacherServlet extends HttpServlet {

    private static final long serialVersionUID = 1L;
    //保存url和Method的对应关系
    private Map<String, Method> handlerMapping = new HashMap<String, Method>();

    //保存扫描的所有的类名
    private List<String> classNames = new ArrayList<String>();

    //存放所扫描出来的类及其实例
    private Map<String, Object> ioc = new HashMap<String, Object>();

    public WuzzDispacherServlet() {
        super();
    }

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        super.doGet(req, resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        super.doPost(req, resp);
    }

    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //访问地址http://localhost:8081/wuzz/index.do
        //这里拿到uri : /wuzz/index.do
        String uri = req.getRequestURI();
        //从方法map里获取到映射到的方法实例 : public void com.example.demo.annotation.TestController.index()
        //处理成相对路径
        if (!this.handlerMapping.containsKey(uri)) {
            resp.getWriter().write("404 Not Found!!!");
            return;
        }
        Method method = this.handlerMapping.get(uri);
        //通过反射拿到method所在class，拿到class之后还是拿到class的名称
        //再调用toLowerFirstCase获得beanName
        String beanName = toLowerFirstCase(method.getDeclaringClass().getSimpleName());
        BaseController controller;
        try {
            //获取实例
            controller = (BaseController) ioc.get(beanName);
            //初始化该controller的请求与响应
            //也就是我们的请求中参数怎么通过requset.getParam方法拿到的原因
            System.out.println(req.getRequestURI());
            controller.init(req, resp);
            //然后调用该方法
            method.invoke(controller);
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    @Override
    public void init(ServletConfig config) throws ServletException {
        //获取基础扫描包： 这里设定为com.wuzz.demo
        String basePackage = config.getInitParameter("basePackage");
        //1 扫描包得到所有的class 并且注入ioc
        doScanner(basePackage);
        //2、初始化扫描到的类，并且将它们放入到ICO容器之中
        doInstance();
        //3.实际上这里中间可以扫描@Service @Autowired 注解实现自动的依赖注入
        //可参考DispacherServlet 的初始化流程
        //可参考DispacherServlet#initStrategies(ApplicationContext context)
        doAutowired();
        //4、初始化HandlerMapping
        initHandlerMapping();
    }

    //扫描出相关的类
    private void doScanner(String scanPackage) {
        //scanPackage = com.gupaoedu.demo ，存储的是包路径
        //转换为文件路径，实际上就是把.替换为/就OK了
        //classpath
        URL url = this.getClass().getClassLoader().getResource("" + scanPackage.replaceAll("\\.", "/"));
        File classPath = new File(url.getFile());
        for (File file : classPath.listFiles()) {
            if (file.isDirectory()) {
                doScanner(scanPackage + "." + file.getName());
            } else {
                if (!file.getName().endsWith(".class")) {
                    continue;
                }
                String className = (scanPackage + "." + file.getName().replace(".class", ""));
                classNames.add(className);
            }
        }
    }

    private void doInstance() {
        //初始化，为DI做准备
        if (classNames.isEmpty()) {
            return;
        }
        try {
            for (String className : classNames) {
                Class<?> clazz = Class.forName(className);
                //什么样的类才需要初始化呢？
                //加了注解的类，才初始化，怎么判断？
                //为了简化代码逻辑，主要体会设计思想，只举例 @Controller和@Service,
                // @Componment...就一一举例了
                if (clazz.isAnnotationPresent(WuzzController.class)) {
                    Object instance = clazz.newInstance();
                    //Spring默认类名首字母小写
                    String beanName = toLowerFirstCase(clazz.getSimpleName());
                    ioc.put(beanName, instance);
                } else if (clazz.isAnnotationPresent(WuzzService.class)) {
                    //1、自定义的beanName
                    WuzzService service = clazz.getAnnotation(WuzzService.class);
                    String beanName = service.value();
                    //2、默认类名首字母小写
                    if ("".equals(beanName.trim())) {
                        beanName = toLowerFirstCase(clazz.getSimpleName());
                    }
                    Object instance = clazz.newInstance();
                    ioc.put(beanName, instance);
                    //3、根据类型自动赋值,投机取巧的方式
                    for (Class<?> i : clazz.getInterfaces()) {
                        if (ioc.containsKey(i.getName())) {//接口若有多个实现
                            throw new Exception("The “" + i.getName() + "” is exists!!");
                        }
                        //把接口的类型直接当成key了
                        ioc.put(i.getName(), instance);
                    }
                } else {
                    continue;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    //如果类名本身是小写字母，确实会出问题
    //但是我要说明的是：这个方法是我自己用，private的
    //传值也是自己传，类也都遵循了驼峰命名法
    //默认传入的值，存在首字母小写的情况，也不可能出现非字母的情况
    //为了简化程序逻辑，就不做其他判断了，大家了解就OK
    //其实用写注释的时间都能够把逻辑写完了
    private String toLowerFirstCase(String simpleName) {
        char[] chars = simpleName.toCharArray();
        //之所以加，是因为大小写字母的ASCII码相差32，
        // 而且大写字母的ASCII码要小于小写字母的ASCII码
        //在Java中，对char做算学运算，实际上就是对ASCII码做算学运算
        chars[0] += 32;
        return String.valueOf(chars);
    }
    //自动依赖注入
    private void doAutowired() {
        if (ioc.isEmpty()) {
            return;
        }
        for (Map.Entry<String, Object> entry : ioc.entrySet()) {
            //Declared 所有的，特定的 字段，包括private/protected/default
            //正常来说，普通的OOP编程只能拿到public的属性
            Field[] fields = entry.getValue().getClass().getDeclaredFields();
            for (Field field : fields) {
                if (!field.isAnnotationPresent(WuzzAutowired.class)) {
                    continue;
                }
                WuzzAutowired autowired = field.getAnnotation(WuzzAutowired.class);
                //如果用户没有自定义beanName，默认就根据类型注入
                //这个地方省去了对类名首字母小写的情况的判断，这个作为课后作业
                //小伙伴们自己去完善
                String beanName = autowired.value().trim();
                if ("".equals(beanName)) {
                    //获得接口的类型，作为key待会拿这个key到ioc容器中去取值
                    beanName = field.getType().getName();
                }
                //如果是public以外的修饰符，只要加了@Autowired注解，都要强制赋值
                //反射中叫做暴力访问， 强吻
                field.setAccessible(true);
                try {
                    //用反射机制，动态给字段赋值
                    field.set(entry.getValue(), ioc.get(beanName));
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    //初始化url和Method的一对一对应关系
    private void initHandlerMapping() {
        if (ioc.isEmpty()) {
            return;
        }
        for (Map.Entry<String, Object> entry : ioc.entrySet()) {
            Class<?> clazz = entry.getValue().getClass();
            if (!clazz.isAnnotationPresent(WuzzController.class)) {
                continue;
            }
            //保存写在类上面的@GPRequestMapping("/demo")
            String baseUrl = "";
            if (clazz.isAnnotationPresent(WuzzRequestMapping.class)) {
                WuzzRequestMapping requestMapping = clazz.getAnnotation(WuzzRequestMapping.class);
                baseUrl = requestMapping.value();
            }
            //默认获取所有的public方法
            for (Method method : clazz.getMethods()) {
                if (!method.isAnnotationPresent(WuzzRequestMapping.class)) {
                    continue;
                }
                WuzzRequestMapping requestMapping = method.getAnnotation(WuzzRequestMapping.class);
                //优化
                // //demo///query
                String url = ("/" + baseUrl + "/" + requestMapping.value())
                        .replaceAll("/+", "/");
                handlerMapping.put(url, method);
                System.out.println("Mapped :" + url + "," + method);
            }
        }
    }
}

　　最后要使这个@WebServlet 起效果，需要配置启动类：

@SpringBootApplication
@ServletComponentScan
public class App {
    private final static Logger log = LoggerFactory.getLogger(App.class);

    public static void main(String[] args) {
        SpringApplication.run(App.class, args);
        log.info("服务启动成功");
    }
}

　　经过以上的这些操作，我们自己定义的注解就能生效了，那么现在我们需要考虑的是，这个controller里面，我需要获取请求参数和响应要怎么做呢，其实，我们只要在初始化controller的时候将requset跟response给他塞进去不久好了嘛？我们可以创建一个controller的基类

public class BaseController {

    protected HttpServletRequest request;
    protected HttpServletResponse response;

    public void init(HttpServletRequest request, HttpServletResponse response) {
        this.request = request;
        this.response = response;
    }

    public HttpServletRequest getRequest() {
        return request;
    }

    public void setRequest(HttpServletRequest request) {
        this.request = request;
    }

    public HttpServletResponse getResponse() {
        return response;
    }

    public void setResponse(HttpServletResponse response) {
        this.response = response;
    }
}

　　这样子，我们在service()方法内去获取该controller实例的时候controller.init(req, resp); 给他插进去这两个东西，就完事了。最后启动主类，你会发现它真的就调用了controller下的方法。

　　如果启用XML的形式去做的话，大致大逻辑还是一样的，只不过需要如下修改：

　　1.添加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/j2ee" xmlns:javaee="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/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"
    version="2.4">
    <display-name>Gupao Web Application</display-name>
    <servlet>
        <servlet-name>gpmvc</servlet-name>
        <servlet-class>com.gupaoedu.mvcframework.v2.servlet.GPDispatcherServlet</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>gpmvc</servlet-name>
        <url-pattern>/*</url-pattern>
    </servlet-mapping>
</web-app>

　　2.去掉 @WebServlet 注解，添加 application.properties 内容如下：

basePackage  = com.wuzz.demo

　　3.既然添加了配置文件，那么我们需要扫描配置文件获取配置信息

 //保存application.properties配置文件中的内容
private Properties contextConfig = new Properties();
//加载配置文件
private void doLoadConfig(String contextConfigLocation) {
　　//直接从类路径下找到Spring主配置文件所在的路径
　　//并且将其读取出来放到Properties对象中
　　//相对于scanPackage=com.gupaoedu.demo 从文件中保存到了内存中
　　InputStream fis = this.getClass().getClassLoader().getResourceAsStream(contextConfigLocation);
　　try {
　　　　contextConfig.load(fis);
　　} catch (IOException e) {
　　　　e.printStackTrace();
　　}finally {
　　　　if(null != fis){
　　　　　　try {
　　　　　　　　fis.close();
　　　　　　} catch (IOException e) {
　　　　　　　　e.printStackTrace();
　　　　　　}
　　　　}
　　}
}

加载配置文件
doLoadConfig(config.getInitParameter("contextConfigLocation"));

扫描相关的类
doScanner(contextConfig.getProperty("scanPackage"));

　　4.修改pom文件为war包形式

　　contextConfigLocation 是我们在web.xml中配置的。然后用Tomcat启动即可。

随风去。

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
SpringMvc工作原理及源码分析

　　使用过spring mvc的小伙伴都知道，mvc在使用的时候，我们只需要在controller上注解上@controller跟@requestMapping（“URL”）,当我们访问对应的路径的时候，框架便会帮我们去映射到指定的controller里面的指定方法，那么这一切都是怎么做到的呢？还有我们所传递过去的参数，为什么通过request.getParam就能轻易地拿到呢？大家都...
复制链接

扫一扫

专栏目录