乐趣区

关于spring:Spring框架系列2-Spring简单例子引入Spring要点

jiezi

上文中咱们简略介绍了 Spring 和 Spring Framework 的组件，那么这些 Spring Framework 组件是如何配合工作的呢？本文次要承接上文，向你展现 Spring Framework 组件的典型利用场景和基于这个场景设计出的简略案例，并以此引出 Spring 的外围要点，比方 IOC 和 AOP 等；在此基础上还引入了不同的配置形式，如 XML，Java 配置和注解形式的差别。@pdai

  • Spring 框架系列(2) – Spring 简略例子引入 Spring 要点

    • Spring 框架如何利用
    • 设计一个 Spring 的 Hello World

    • 这个例子体现了 Spring 的哪些外围要点

      • 管制反转 – IOC
      • 面向切面 – AOP

    • Spring 框架设计如何逐渐简化开发的

      • Java 配置形式革新
      • 注解配置形式革新
      • SpringBoot 托管配置
      • 联合 Spring 历史版本和 SpringBoot 看倒退
    • 更多文章

Spring 框架如何利用

上文中，咱们展现了 Spring 和 Spring Framework 的组件, 这里对于开发者来说有几个问题：

  1. 首先，对于 Spring 进阶，间接去看 IOC 和 AOP，存在一个断层，所以须要整体上构建对 Spring 框架认知上进一步深刻，这样能力构建常识体系。
  2. 其次，很多开发者入门都是从 Spring Boot 开始的，他对 Spring 整体框架底层，以及倒退历史不是很理解；特地是对于一些老旧我的项目保护和底层 bug 剖析没有全局观。
  3. 再者，Spring 代表的是一种框架设计理念，须要全局上了解 Spring Framework 组件是如何配合工作的，须要了解它设计的初衷和将来趋势。

如下是官网在解释 Spring 框架的罕用场景的图

我加上一些正文后，是比拟好了解的；引入这个图，重要的起因是为前面设计一个案例帮忙你构建认知。

设计一个 Spring 的 Hello World

联合下面的应用场景，设计一个查问用户的案例的两个需要，来看 Spring 框架帮咱们简化了什么开发工作:

  1. 查问用户数据 – 来看 DAO+POJO-> Service 的初始化和装载。
  2. 给所有 Service 的查询方法记录日志
  • 创立一个 Maven 的 Java 我的项目

  • 引入 Spring 框架的 POM 依赖，以及查看这些依赖之间的关系
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>tech.pdai</groupId>
    <artifactId>001-spring-framework-demo-helloworld-xml</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <spring.version>5.3.9</spring.version>
        <aspectjweaver.version>1.9.6</aspectjweaver.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>${aspectjweaver.version}</version>
        </dependency>
    </dependencies>

</project>

  • POJO – User
package tech.pdai.springframework.entity;

/**
 * @author pdai
 */
public class User {

    /**
     * user's name.
     */
    private String name;

    /**
     * user's age.
     */
    private int age;

    /**
     * init.
     *
     * @param name name
     * @param age  age
     */
    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {return name;}

    public void setName(String name) {this.name = name;}

    public int getAge() {return age;}

    public void setAge(int age) {this.age = age;}
}
  • DAO 获取 POJO，UserDaoServiceImpl (mock 数据)
package tech.pdai.springframework.dao;

import java.util.Collections;
import java.util.List;

import tech.pdai.springframework.entity.User;

/**
 * @author pdai
 */
public class UserDaoImpl {

    /**
     * init.
     */
    public UserDaoImpl() {}

    /**
     * mocked to find user list.
     *
     * @return user list
     */
    public List<User> findUserList() {return Collections.singletonList(new User("pdai", 18));
    }
}

并减少 daos.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
 http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="userDao" class="tech.pdai.springframework.dao.UserDaoImpl">
        <!-- additional collaborators and configuration for this bean go here -->
    </bean>
    <!-- more bean definitions for data access objects go here -->
</beans>
  • 业务层 UserServiceImpl（调用 DAO 层）
package tech.pdai.springframework.service;

import java.util.List;

import tech.pdai.springframework.dao.UserDaoImpl;
import tech.pdai.springframework.entity.User;

/**
 * @author pdai
 */
public class UserServiceImpl {

    /**
     * user dao impl.
     */
    private UserDaoImpl userDao;

    /**
     * init.
     */
    public UserServiceImpl() {}

    /**
     * find user list.
     *
     * @return user list
     */
    public List<User> findUserList() {return this.userDao.findUserList();
    }

    /**
     * set dao.
     *
     * @param userDao user dao
     */
    public void setUserDao(UserDaoImpl userDao) {this.userDao = userDao;}
}

并减少 services.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
 http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!-- services -->
    <bean id="userService" class="tech.pdai.springframework.service.UserServiceImpl">
        <property name="userDao" ref="userDao"/>
        <!-- additional collaborators and configuration for this bean go here -->
    </bean>
    <!-- more bean definitions for services go here -->
</beans>
  • 拦挡所有 service 中的办法，并输入记录
package tech.pdai.springframework.aspect;

import java.lang.reflect.Method;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

/**
 * @author pdai
 */
@Aspect
public class LogAspect {

    /**
     * aspect for every methods under service package.
     */
    @Around("execution(* tech.pdai.springframework.service.*.*(..))")
    public Object businessService(ProceedingJoinPoint pjp) throws Throwable {
        // get attribute through annotation
        Method method = ((MethodSignature) pjp.getSignature()).getMethod();
        System.out.println("execute method:" + method.getName());

        // continue to process
        return pjp.proceed();}

}

并减少 aspects.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
 http://www.springframework.org/schema/beans/spring-beans.xsd
 http://www.springframework.org/schema/aop
 http://www.springframework.org/schema/aop/spring-aop.xsd
 http://www.springframework.org/schema/context
 http://www.springframework.org/schema/context/spring-context.xsd
">

    <context:component-scan base-package="tech.pdai.springframework" />

    <aop:aspectj-autoproxy/>

    <bean id="logAspect" class="tech.pdai.springframework.aspect.LogAspect">
        <!-- configure properties of aspect here as normal -->
    </bean>
    <!-- more bean definitions for data access objects go here -->
</beans>
  • 组装 App
package tech.pdai.springframework;

import java.util.List;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import tech.pdai.springframework.entity.User;
import tech.pdai.springframework.service.UserServiceImpl;

/**
 * @author pdai
 */
public class App {

    /**
     * main interfaces.
     *
     * @param args args
     */
    public static void main(String[] args) {
        // create and configure beans
        ApplicationContext context =
                new ClassPathXmlApplicationContext("aspects.xml", "daos.xml", "services.xml");

        // retrieve configured instance
        UserServiceImpl service = context.getBean("userService", UserServiceImpl.class);

        // use configured instance
        List<User> userList = service.findUserList();

        // print info from beans
        userList.forEach(a -> System.out.println(a.getName() + "," + a.getAge()));
    }
}
  • 整体构造和运行 app

这个例子体现了 Spring 的哪些外围要点

那么 Spring 框架帮忙咱们做什么，它体现了什么哪些要点呢?

管制反转 – IOC

来看第一个需要：查问用户（service 通过调用 dao 查问 pojo)，实质上如何创立 User/Dao/Service 等；

  • 如果没有 Spring 框架，咱们须要本人创立 User/Dao/Service 等，比方：
UserDaoImpl userDao = new UserDaoImpl();
UserSericeImpl userService = new UserServiceImpl();
userService.setUserDao(userDao);
List<User> userList = userService.findUserList();
  • 有了 Spring 框架，能够将原有 Bean 的创立工作转给框架, 须要用时从 Bean 的容器中获取即可，这样便简化了开发工作

Bean 的创立和应用拆散了。

// create and configure beans
ApplicationContext context =
        new ClassPathXmlApplicationContext("aspects.xml", "daos.xml", "services.xml");

// retrieve configured instance
UserServiceImpl service = context.getBean("userService", UserServiceImpl.class);

// use configured instance
List<User> userList = service.findUserList();

更进一步，你便能了解为何会有如下的知识点了：

  1. Spring 框架治理这些 Bean 的创立工作，即由用户治理 Bean 转变为框架治理 Bean，这个就叫 管制反转 – Inversion of Control (IoC)
  2. Spring 框架托管创立的 Bean 放在哪里呢？这便是IoC Container;
  3. Spring 框架为了更好让用户配置 Bean，必然会引入 不同形式来配置 Bean？这便是 xml 配置，Java 配置，注解配置 等反对
  4. Spring 框架既然接管了 Bean 的生成，必然须要 治理整个 Bean 的生命周期 等；
  5. 利用程序代码从 Ioc Container 中获取依赖的 Bean，注入到应用程序中，这个过程叫 依赖注入(Dependency Injection，DI)；所以说管制反转是通过依赖注入实现的，其实它们是同一个概念的不同角度形容。艰深来说就是IoC 是设计思维，DI 是实现形式
  6. 在依赖注入时，有哪些形式呢？这就是结构器形式，@Autowired, @Resource, @Qualifier… 同时 Bean 之间存在依赖（可能存在先后顺序问题，以及 循环依赖问题 等）

这边引入咱们后续的相干文章：Spring 根底 – Spring 之管制反转(IOC)

面向切面 – AOP

来看第二个需要：给 Service 所有办法调用增加日志（调用办法时)，实质上是解耦问题；

  • 如果没有 Spring 框架，咱们须要在每个 service 的办法中都增加记录日志的办法，比方：
/**
* find user list.
*
* @return user list
*/
public List<User> findUserList() {System.out.println("execute method findUserList");
    return this.userDao.findUserList();}
  • 有了 Spring 框架，通过 @Aspect 注解 定义了切面，这个切面中定义了拦挡所有 service 中的办法，并记录日志；能够显著看到，框架将日志记录和业务需要的代码解耦了，不再是侵入式的了
/**
* aspect for every methods under service package.
*/
@Around("execution(* tech.pdai.springframework.service.*.*(..))")
public Object businessService(ProceedingJoinPoint pjp) throws Throwable {
    // get attribute through annotation
    Method method = ((MethodSignature) pjp.getSignature()).getMethod();
    System.out.println("execute method:" + method.getName());

    // continue to process
    return pjp.proceed();}

更进一步，你便能了解为何会有如下的知识点了：

  1. Spring 框架通过定义切面, 通过拦挡切点实现了不同业务模块的解耦，这个就叫 面向切面编程 – Aspect Oriented Programming (AOP)
  2. 为什么 @Aspect 注解应用的是 aspectj 的 jar 包呢？这就引出了Aspect4J 和 Spring AOP 的历史渊源，只有了解了 Aspect4J 和 Spring 的渊源能力了解有些注解上的兼容设计
  3. 如何反对 更多拦挡形式 来实现解耦，以满足更多场景需要呢？这就是 @Around, @Pointcut… 等的设计
  4. 那么 Spring 框架又是如何实现 AOP 的呢？这就引入 代理技术，分动态代理和动静代理，动静代理又蕴含 JDK 代理和 CGLIB 代理等

这边引入咱们后续的相干文章：Spring 根底 – Spring 之面向切面编程(AOP)

Spring 框架设计如何逐渐简化开发的

通过上述的框架介绍和例子，曾经初步晓得了 Spring 设计的两个大的要点：IOC 和 AOP；从框架的设计角度而言，更为重要的是简化开发，比方提供更为便捷的配置 Bean 的形式，直至 0 配置（即约定大于配置）。这里我将通过 Spring 历史版本的倒退，和 SpringBoot 的推出等，来帮你了解 Spring 框架是如何逐渐简化开发的。

Java 配置形式革新

在前文的例子中，通过 xml 配置形式实现的，这种形式实际上比拟麻烦；我通过 Java 配置进行革新：

  • User，UserDaoImpl, UserServiceImpl，LogAspect 不必改
  • 将原通过.xml 配置转换为 Java 配置
package tech.pdai.springframework.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import tech.pdai.springframework.aspect.LogAspect;
import tech.pdai.springframework.dao.UserDaoImpl;
import tech.pdai.springframework.service.UserServiceImpl;

/**
 * @author pdai
 */
@EnableAspectJAutoProxy
@Configuration
public class BeansConfig {

    /**
     * @return user dao
     */
    @Bean("userDao")
    public UserDaoImpl userDao() {return new UserDaoImpl();
    }

    /**
     * @return user service
     */
    @Bean("userService")
    public UserServiceImpl userService() {UserServiceImpl userService = new UserServiceImpl();
        userService.setUserDao(userDao());
        return userService;
    }

    /**
     * @return log aspect
     */
    @Bean("logAspect")
    public LogAspect logAspect() {return new LogAspect();
    }
}
  • 在 App 中加载 BeansConfig 的配置
package tech.pdai.springframework;

import java.util.List;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import tech.pdai.springframework.config.BeansConfig;
import tech.pdai.springframework.entity.User;
import tech.pdai.springframework.service.UserServiceImpl;

/**
 * @author pdai
 */
public class App {

    /**
     * main interfaces.
     *
     * @param args args
     */
    public static void main(String[] args) {
        // create and configure beans
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(BeansConfig.class);

        // retrieve configured instance
        UserServiceImpl service = context.getBean("userService", UserServiceImpl.class);

        // use configured instance
        List<User> userList = service.findUserList();

        // print info from beans
        userList.forEach(a -> System.out.println(a.getName() + "," + a.getAge()));
    }
}
  • 整体构造和运行 app

注解配置形式革新

更进一步，Java 5 开始提供注解反对，Spring 2.5 开始齐全反对基于注解的配置并且也反对 JSR250 注解。在 Spring 后续的版本倒退偏向于通过注解和 Java 配置联合应用.

  • BeanConfig 不再须要 Java 配置
package tech.pdai.springframework.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ComponentScans;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

/**
 * @author pdai
 */
@Configuration
@EnableAspectJAutoProxy
public class BeansConfig {}
  • UserDaoImpl 减少了 @Repository 注解
/**
 * @author pdai
 */
@Repository
public class UserDaoImpl {

    /**
     * mocked to find user list.
     *
     * @return user list
     */
    public List<User> findUserList() {return Collections.singletonList(new User("pdai", 18));
    }
}
  • UserServiceImpl 减少了 @Service 注解，并通过 @Autowired 注入 userDao.
/**
 * @author pdai
 */
@Service
public class UserServiceImpl {

    /**
     * user dao impl.
     */
    @Autowired
    private UserDaoImpl userDao;

    /**
     * find user list.
     *
     * @return user list
     */
    public List<User> findUserList() {return userDao.findUserList();
    }

}
  • 在 App 中扫描 tech.pdai.springframework 包
package tech.pdai.springframework;

import java.util.List;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import tech.pdai.springframework.entity.User;
import tech.pdai.springframework.service.UserServiceImpl;

/**
 * @author pdai
 */
public class App {

    /**
     * main interfaces.
     *
     * @param args args
     */
    public static void main(String[] args) {
        // create and configure beans
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext("tech.pdai.springframework");

        // retrieve configured instance
        UserServiceImpl service = context.getBean(UserServiceImpl.class);

        // use configured instance
        List<User> userList = service.findUserList();

        // print info from beans
        userList.forEach(a -> System.out.println(a.getName() + "," + a.getAge()));
    }
}
  • 整体构造和运行 app

SpringBoot 托管配置

Springboot 实际上通过约定大于配置的形式，应用 xx-starter 对立的对 Bean 进行默认初始化，用户只须要很少的配置就能够进行开发了。

这个因为很多开发者都是从 SpringBoot 开始着手开发的，所以这个比拟好了解。咱们须要的是将知识点都串联起来，构筑认知体系。

联合 Spring 历史版本和 SpringBoot 看倒退

最初联合 Spring 历史版本总结下它的倒退：

（这样是不是可能帮忙你在整体上构建了常识体系的认知了呢？）

PS：相干代码，能够通过这里间接查看

更多文章

首先，从 Spring 框架的整体架构和组成对整体框架有个认知。

  • Spring 根底 – Spring 和 Spring 框架组成

    • Spring 是什么？它是怎么诞生的？有哪些次要的组件和外围性能呢? 本文通过这几个问题帮忙你构筑 Spring 和 Spring Framework 的整体认知。

其次，通过案例引出 Spring 的外围（IoC 和 AOP），同时对 IoC 和 AOP 进行案例应用剖析。

  • Spring 根底 – Spring 简略例子引入 Spring 的外围

    • 上文中咱们简略介绍了 Spring 和 Spring Framework 的组件，那么这些 Spring Framework 组件是如何配合工作的呢？本文次要承接上文，向你展现 Spring Framework 组件的典型利用场景和基于这个场景设计出的简略案例，并以此引出 Spring 的外围要点，比方 IOC 和 AOP 等；在此基础上还引入了不同的配置形式，如 XML，Java 配置和注解形式的差别。

  • Spring 根底 – Spring 外围之管制反转(IOC)

    • 在 Spring 根底 – Spring 简略例子引入 Spring 的外围中向你展现了 IoC 的根底含意，同时以此发散了一些 IoC 相干知识点; 本节将在此基础上进一步解读 IOC 的含意以及 IOC 的应用形式

  • Spring 根底 – Spring 外围之面向切面编程(AOP)

    • 在 Spring 根底 – Spring 简略例子引入 Spring 的外围中向你展现了 AOP 的根底含意，同时以此发散了一些 AOP 相干知识点; 本节将在此基础上进一步解读 AOP 的含意以及 AOP 的应用形式。

基于 Spring 框架和 IOC，AOP 的根底，为构建下层 web 利用，须要进一步学习 SpringMVC。

  • Spring 根底 – SpringMVC 申请流程和案例

    • 前文咱们介绍了 Spring 框架和 Spring 框架中最为重要的两个技术点（IOC 和 AOP），那咱们如何更好的构建下层的利用呢（比方 web 利用），这便是 SpringMVC；Spring MVC 是 Spring 在 Spring Container Core 和 AOP 等技术根底上，遵循上述 Web MVC 的标准推出的 web 开发框架，目标是为了简化 Java 栈的 web 开发。本文次要介绍 SpringMVC 的申请流程和根底案例的编写和运行。

Spring 进阶 – IoC，AOP 以及 SpringMVC 的源码剖析

  • Spring 进阶 – Spring IOC 实现原理详解之 IOC 体系结构设计

    • 在对 IoC 有了初步的认知后，咱们开始对 IOC 的实现原理进行深刻了解。本文将帮忙你站在设计者的角度去看 IOC 最顶层的结构设计

  • Spring 进阶 – Spring IOC 实现原理详解之 IOC 初始化流程

    • 上文，咱们看了 IOC 设计要点和设计构造；紧接着这篇，咱们能够看下源码的实现了：Spring 如何实现将资源配置（以 xml 配置为例）通过加载，解析，生成 BeanDefination 并注册到 IoC 容器中的

  • Spring 进阶 – Spring IOC 实现原理详解之 Bean 实例化(生命周期, 循环依赖等)

    • 上文，咱们看了 IOC 设计要点和设计构造；以及 Spring 如何实现将资源配置（以 xml 配置为例）通过加载，解析，生成 BeanDefination 并注册到 IoC 容器中的；容器中寄存的是 Bean 的定义即 BeanDefinition 放到 beanDefinitionMap 中，实质上是一个ConcurrentHashMap<String, Object>；并且 BeanDefinition 接口中蕴含了这个类的 Class 信息以及是否是单例等。那么如何从 BeanDefinition 中实例化 Bean 对象呢，这是本文次要钻研的内容？

  • Spring 进阶 – Spring AOP 实现原理详解之切面实现

    • 前文，咱们剖析了 Spring IOC 的初始化过程和 Bean 的生命周期等，而 Spring AOP 也是基于 IOC 的 Bean 加载来实现的。本文次要介绍 Spring AOP 原理解析的切面实现过程(将切面类的所有切面办法依据应用的注解生成对应 Advice，并将 Advice 连同切入点匹配器和切面类等信息一并封装到 Advisor，为后续交给代理加强实现做筹备的过程)。

  • Spring 进阶 – Spring AOP 实现原理详解之 AOP 代理

    • 上文咱们介绍了 Spring AOP 原理解析的切面实现过程(将切面类的所有切面办法依据应用的注解生成对应 Advice，并将 Advice 连同切入点匹配器和切面类等信息一并封装到 Advisor)。本文在此基础上持续介绍，代理（cglib 代理和 JDK 代理）的实现过程。

  • Spring 进阶 – Spring AOP 实现原理详解之 Cglib 代理实现

    • 咱们在前文中曾经介绍了 SpringAOP 的切面实现和创立动静代理的过程，那么动静代理是如何工作的呢？本文次要介绍 Cglib 动静代理的案例和 SpringAOP 实现的原理。

  • Spring 进阶 – Spring AOP 实现原理详解之 JDK 代理实现

    • 上文咱们学习了 SpringAOP Cglib 动静代理的实现，本文次要是 SpringAOP JDK 动静代理的案例和实现局部。

  • Spring 进阶 – SpringMVC 实现原理之 DispatcherServlet 初始化的过程

    • 前文咱们有了 IOC 的源码根底以及 SpringMVC 的根底，咱们便能够进一步深刻了解 SpringMVC 次要实现原理，蕴含 DispatcherServlet 的初始化过程和 DispatcherServlet 解决申请的过程的源码解析。本文是第一篇：DispatcherServlet 的初始化过程的源码解析。

  • Spring 进阶 – SpringMVC 实现原理之 DispatcherServlet 解决申请的过程

    • 前文咱们有了 IOC 的源码根底以及 SpringMVC 的根底，咱们便能够进一步深刻了解 SpringMVC 次要实现原理，蕴含 DispatcherServlet 的初始化过程和 DispatcherServlet 解决申请的过程的源码解析。本文是第二篇：DispatcherServlet 解决申请的过程的源码解析。
退出移动版