• Spring 基础知识、执行流程、源码分析和设计思想

    目录

    Spring 基础

    Spring 体系结构

    Core (IoC & DI)

    Bean

    AOP

    Spring Boot  原理解析和 SpringApplication 执行流程

    spring-boot-starter 原理

    手写一个 starter

    手写 Spring 核心代码

    Spring的部分总结与思考

    官方文档：https://docs.spring.io/spring-framework/docs/current/reference/html/

    Spring 基础

    Spring 体系结构

    Core Container核心容器包括

    1. （1）Core核心模块（IoC和DI功能）
    2. （2）Beans模块（提供BeanFactory，Spring把管理对象称为Bean）
    3. （3）Context上下文模块（访问定义和配置的任务对象的媒介ApplicationContext）
    4. （4）SpEL模块（运行时查询和操作对象的强大的表达式语言）

    AOP：运行定义方法拦截器和切入点。

    AspectJ 是一个功能强大且成熟的面向切面编程（AOP）框架。

    ORM：对象关系映射（Object Relational Mapping，简称ORM）。

    Core (IoC & DI)

    从获取对象的方式来进行比较：

    传统的方式： 

    通过new 关键字主动创建一个对象

    IOC方式

    对象的生命周期由Spring来管理，直接从Spring那里去获取一个对象。 IOC是控制反转 (Inversion Of Control)的缩写，控制反转是把控制权交出去，交给Spring，通过IOC方式松耦合。

    传统方式导致了硬编码耦合。

    入门实例：

    1.新建一个Java project，新建一个com.cxf.pojo包，Category 类

    1. package com.cxf.pojo;
    2.  
    3. public class Category {
    4.     private int id;
    5.     private String name;
    6.  
    7.     public int getId() {
    8.         return id;
    9.     }
    10.  
    11.     public void setId(int id) {
    12.         this.id = id;
    13.  
    14.     }
    15.  
    16.     public String getName() {
    17.         return name;
    18.     }
    19.  
    20.     public void setName(String name) {
    21.         this.name = name;
    22.     }
    23. }

    2.新建一个配置文件applicationContext.xml

    1. ​<?xml version="1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.     xmlns:aop="http://www.springframework.org/schema/aop"
    5.     xmlns:tx="http://www.springframework.org/schema/tx"
    6.     xmlns:context="http://www.springframework.org/schema/context"
    7.     xsi:schemaLocation="
    8.    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    9.    http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
    10.    http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
    11.    http://www.springframework.org/schema/context/spring-context-3.0.xsd">
    12.  
    13.   <bean name="c" class="com.cxf.pojo.Category">
    14.       <property name="name" value="category 1"/>
    15.   </bean>    
    16.  
    17. </beans>

    对Category的name属性注入了"category 1"字符串。

    3.新建一个测试类TestSpring

    1. package com.cxf.test;
    2.  
    3. import org.springframework.context.ApplicationContext;
    4. import org.springframework.context.support.ClassPathXmlApplicationContext;
    5.  
    6. import com.cxf.pojo.Category;
    7.  
    8. public class TestSpring {
    9.  
    10.     public static void main(String[] args) {
    11.         ApplicationContext context = new ClassPathXmlApplicationContext(new String[]{"applicationContext.xml"});
    12.         Category c = (Category)context.getBean("c");
    13.         System.out.println(c.getName());
    14.     }
    15.  
    16. }

    DI (Dependency Injection)

    IoC是一种设计思想，主要是为了解耦，DI是这种思想的一种实现方式。依赖注入是指在启动Spring容器加载 bean 配置的时候，完成对变量的赋值行为。

    依赖注入通常有两种方式：

    • 设值注入：property相当于bean的成员变量，ref自动调用 setter(set方法）对属性进行赋值。
    • 构造器注入

    eg:

    （1）XML方式：

    （2）Java方式：

    Bean

    Bean的作用域

    (这个模块后续再整理)

    AOP

    aspect-oriented programming

    (这个模块后续再整理)

    Spring Boot  原理解析和 SpringApplication 执行流程

    将普通类交给 Spring 容器管理通常有2种方法：

    （1）使用 @Configuration，@Bean，@Controller，@Service，@Repository，@Component注解，然后启用 @ComponentScan 自动扫描。

    （2）使用 @Import 。

    Spring Boot 入口类 @SpringBootApplication 和 main 方法中 SpringApplication.run方法的解析：

    1. @Target({ElementType.TYPE})
    2. @Retention(RetentionPolicy.RUNTIME)
    3. @Documented
    4. @Inherited
    5. @SpringBootConfiguration
    6. @EnableAutoConfiguration
    7. @ComponentScan(
    8.     excludeFilters = {@Filter(
    9.     type = FilterType.CUSTOM,
    10.     classes = {TypeExcludeFilter.class}
    11. ), @Filter(
    12.     type = FilterType.CUSTOM,
    13.     classes = {AutoConfigurationExcludeFilter.class}
    14. )}
    15. )
    16. public @interface SpringBootApplication {
    17.     // 省略代码
    18. }

    @SpringBootConfiguration 是对 @Configuration 的简单“包装”，它就是Java Config形式的Spring IoC 容器的配置类：

    1. @Target(ElementType.TYPE)
    2. @Retention(RetentionPolicy.RUNTIME)
    3. @Documented
    4. @Configuration
    5. public @interface SpringBootConfiguration {
    6.  
    7. }

    @EnableAutoConfiguration:

    1. @Target({ElementType.TYPE})
    2. @Retention(RetentionPolicy.RUNTIME)
    3. @Documented
    4. @Inherited
    5. @AutoConfigurationPackage
    6. @Import({AutoConfigurationImportSelector.class})
    7. public @interface EnableAutoConfiguration {
    8.  
    9. }

    @AutoConfigurationPackage：

    1. @Target({ElementType.TYPE})
    2. @Retention(RetentionPolicy.RUNTIME)
    3. @Documented
    4. @Inherited
    5. @Import({Registrar.class})
    6. public @interface AutoConfigurationPackage {
    7.     String[] basePackages() default {};
    8.  
    9.     Class<?>[] basePackageClasses() default {};
    10. }

    Registrar:

    1. @Order(Ordered.HIGHEST_PRECEDENCE)
    2. static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {
    3.  
    4.     @Override
    5.     public void registerBeanDefinitions(AnnotationMetadata metadata,
    6.             BeanDefinitionRegistry registry) {
    7.         register(registry, new PackageImport(metadata).getPackageName());
    8.     }
    9.  
    10.     @Override
    11.     public Set<Object> determineImports(AnnotationMetadata metadata) {
    12.         return Collections.<Object>singleton(new PackageImport(metadata));
    13.     }
    14.  
    15. }

     @Import：

    1. @Target({ElementType.TYPE})
    2. @Retention(RetentionPolicy.RUNTIME)
    3. @Documented
    4. public @interface Import {
    5.     Class<?>[] value();
    6. }

    AutoConfigurationImportSelector:

    1.     protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
    2.         List<String> configurations = SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.getBeanClassLoader());
    3.         Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you are using a custom packaging, make sure that file is correct.");
    4.         return configurations;
    5.     }

    从 spring.factories 中可以看到： 

    @Import 注解的主要作用就是借助 AutoConfigurationImportSelector 将 Spring Boot 应用所有符合条件的 @Configuration 配置都加载到当前 Spring Boot 创建并使用的 IoC 容器中，IoC 容器就是Spring 应用程序上下文 ApplicationContext。

    Spring 框架提供了很多 @Enable 开头的注解定义，比如 @EnableScheduling，@EnableCaching，@EnableAsync 等，这些注解的共同点是借助 @Import 收集和注册特定场景相关的 bean定义。

    @ComponentScan：启动组件扫描，组件或bean定义能被自动发现并注入Spring应用程序上下文，@Controller，@Service，@Component，@Repository等都可以被扫描到。

    SpringApplication.run 的run底层代码是new SpringApplication后再调用run：

    1. 	public ConfigurableApplicationContext run(String... args) {
    2. 		long startTime = System.nanoTime();
    3. 		DefaultBootstrapContext bootstrapContext = createBootstrapContext();
    4.         // 注意是ConfigurableApplicationContext
    5. 		ConfigurableApplicationContext context = null;
    6. 		configureHeadlessProperty();
    7.         // 开启SpringApplicationRunListeners监听器
    8. 		SpringApplicationRunListeners listeners = getRunListeners(args);
    9. 		listeners.starting(bootstrapContext, this.mainApplicationClass);
    10. 		try {
    11. 			ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
    12. 			ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);
    13. 			configureIgnoreBeanInfo(environment);
    14. 			Banner printedBanner = printBanner(environment);
    15.             // 创建应用上下文
    16. 			context = createApplicationContext();
    17. 			context.setApplicationStartup(this.applicationStartup);
    18.             // 准备上下文
    19. 			prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
    20.             // 刷新上下文
    21. 			refreshContext(context);
    22.             // 刷新后操作
    23. 			afterRefresh(context, applicationArguments);
    24. 			Duration timeTakenToStartup = Duration.ofNanos(System.nanoTime() - startTime);
    25. 			if (this.logStartupInfo) {
    26. 				new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), timeTakenToStartup);
    27. 			}
    28. 			listeners.started(context, timeTakenToStartup);
    29. 			callRunners(context, applicationArguments);
    30. 		}
    31. 		catch (Throwable ex) {
    32. 			handleRunFailure(context, ex, listeners);
    33. 			throw new IllegalStateException(ex);
    34. 		}
    35. 		try {
    36. 			Duration timeTakenToReady = Duration.ofNanos(System.nanoTime() - startTime);
    37. 			listeners.ready(context, timeTakenToReady);
    38. 		}
    39. 		catch (Throwable ex) {
    40. 			handleRunFailure(context, ex, null);
    41. 			throw new IllegalStateException(ex);
    42. 		}
    43. 		return context;
    44. 	}

    创建、准备、刷新 ConfigurableApplicationContext，通过上下文加载应用所需的类和各种环境配置等，最后启动应用实例。

    查询和加载所有的 SpringApplicationRunListener 监听器（通过 SpringFactoriesLoader 加载 META-INF/spring.factories 文件）。

    SpringApplicationRunListener 规定了 Spring Boot 的生命周期，在各个生命周期广播响应的事件（ApplicationEvent），实际调用的是 ApplicationListener 类：

     

    ApplicationListener 是 Spring 框架的监听器模式的一种实现。

    1. @FunctionalInterface
    2. public interface ApplicationListener<E extends ApplicationEvent> extends EventListener {
    3.     void onApplicationEvent(E event);
    4.  
    5.     static <T> ApplicationListener<PayloadApplicationEvent<T>> forPayload(Consumer<T> consumer) {
    6.         return (event) -> {
    7.             consumer.accept(event.getPayload());
    8.         };
    9.     }
    10. }

    prepareContext时：

    创建和准备应用要使用的 Environment，包括配置要使用的 PropertySource 和 Profile。

    ApplicationContextInitializer 类的 initialize方法对应用程序上下文进行设置和处理。

    1. @FunctionalInterface
    2. public interface ApplicationContextInitializer<C extends ConfigurableApplicationContext> {
    3.     void initialize(C applicationContext);
    4. }

    在调用 ApplicationContext 的 refresh 方法使 IoC容器达到可用状态后，查找当前上下文是否注册有 ApplicationRunner 与 CommandLineRunner，从 SpringApplicationRunListener 类的 started 方法的注释中可以看出： 

    void run(ApplicationArguments args) throws Exception; // ApplicationRunner
void run(String... args) throws Exception; // CommandLineRunner
ApplicationRunner 和 CommandLineRunner 都是run方法，区别就是入参不一样。

    如果想在 Spring Boot 启动时运行一些特定代码，可以实现 implements ApplicationRunner 或 CommandLineRunner 接口。

    以上描述的完整流程如下：

    另外可借用网上的其他图辅助理解： 

    spring-boot-starter 原理

    起步依赖本质上是一个Maven项目对象模型，定义了对其他库的传递依赖。

    举个例子，mybatis-spring-boot-starter的pom.xml是:

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <!--
    4.        Copyright 2015-2017 the original author or authors.
    6.        Licensed under the Apache License, Version 2.0 (the "License");
    7.        you may not use this file except in compliance with the License.
    8.        You may obtain a copy of the License at
    10.           http://www.apache.org/licenses/LICENSE-2.0
    12.        Unless required by applicable law or agreed to in writing, software
    13.        distributed under the License is distributed on an "AS IS" BASIS,
    14.        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    15.        See the License for the specific language governing permissions and
    16.        limitations under the License.
    18. -->
    19. <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">
    20.   <modelVersion>4.0.0</modelVersion>
    21.   <parent>
    22.     <groupId>org.mybatis.spring.boot</groupId>
    23.     <artifactId>mybatis-spring-boot</artifactId>
    24.     <version>1.3.1</version>
    25.   </parent>
    26.   <artifactId>mybatis-spring-boot-starter</artifactId>
    27.   <name>mybatis-spring-boot-starter</name>
    28.   <dependencies>
    29.     <dependency>
    30.       <groupId>org.springframework.boot</groupId>
    31.       <artifactId>spring-boot-starter</artifactId>
    32.     </dependency>
    33.     <dependency>
    34.       <groupId>org.springframework.boot</groupId>
    35.       <artifactId>spring-boot-starter-jdbc</artifactId>
    36.     </dependency>
    37.     <dependency>
    38.       <groupId>org.mybatis.spring.boot</groupId>
    39.       <artifactId>mybatis-spring-boot-autoconfigure</artifactId>
    40.     </dependency>
    41.     <dependency>
    42.       <groupId>org.mybatis</groupId>
    43.       <artifactId>mybatis</artifactId>
    44.     </dependency>
    45.     <dependency>
    46.       <groupId>org.mybatis</groupId>
    47.       <artifactId>mybatis-spring</artifactId>
    48.     </dependency>
    49.   </dependencies>
    50. </project>

    MybatisAutoConfiguration的源代码：

    1. @Configuration
    2. @ConditionalOnClass({SqlSessionFactory.class, SqlSessionFactoryBean.class})
    3. @ConditionalOnBean({DataSource.class})
    4. @EnableConfigurationProperties({MybatisProperties.class})
    5. @AutoConfigureAfter({DataSourceAutoConfiguration.class})
    6. public class MybatisAutoConfiguration {
    7.     private static final Logger logger = LoggerFactory.getLogger(MybatisAutoConfiguration.class);
    8.     private final MybatisProperties properties;
    9.     private final Interceptor[] interceptors;
    10.     private final ResourceLoader resourceLoader;
    11.     private final DatabaseIdProvider databaseIdProvider;
    12.     private final List<ConfigurationCustomizer> configurationCustomizers;
    13.  
    14.     public MybatisAutoConfiguration(MybatisProperties properties, ObjectProvider<Interceptor[]> interceptorsProvider, ResourceLoader resourceLoader, ObjectProvider<DatabaseIdProvider> databaseIdProvider, ObjectProvider<List<ConfigurationCustomizer>> configurationCustomizersProvider) {
    15.         this.properties = properties;
    16.         this.interceptors = (Interceptor[])interceptorsProvider.getIfAvailable();
    17.         this.resourceLoader = resourceLoader;
    18.         this.databaseIdProvider = (DatabaseIdProvider)databaseIdProvider.getIfAvailable();
    19.         this.configurationCustomizers = (List)configurationCustomizersProvider.getIfAvailable();
    20.     }
    21.  
    22.     @PostConstruct
    23.     public void checkConfigFileExists() {
    24.         if (this.properties.isCheckConfigLocation() && StringUtils.hasText(this.properties.getConfigLocation())) {
    25.             Resource resource = this.resourceLoader.getResource(this.properties.getConfigLocation());
    26.             Assert.state(resource.exists(), "Cannot find config location: " + resource + " (please add config file or check your Mybatis configuration)");
    27.         }
    28.  
    29.     }
    30.  
    31.     @Bean
    32.     @ConditionalOnMissingBean
    33.     public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {
    34.         // 省略其他代码
    35.     }
    36.     
    37.     // 省略其他代码
    38. }

     DataSourceProperties 定义了数据源的各个属性，且使用 @ConfigurationProperties 指定了配置文件的前缀：

     @ConfigurationProperties 的作用是把yml或properties文件转化为Bean。

    手写一个 starter

    Spring Boot 提供的 starter 都是以 spring-boot-starter-xxx 的方式命名的，自定义的 starter 官方建议以 xxx-spring-boot-starter 命名。

    New Project => Maven => Create from archetype (maven-archetype-quickstart) =>

     pom.xml添加：

    1.    <dependency>
    2.       <groupId>org.springframework.boot</groupId>
    3.       <artifactId>spring-boot-autoconfigure</artifactId>
    4.     </dependency>
    1.   <dependencyManagement>
    2.     <dependencies>
    3.       <dependency>
    4.         <groupId>org.springframework.boot</groupId>
    5.         <artifactId>spring-boot-dependencies</artifactId>
    6.         <version>2.1.6.RELEASE</version>
    7.         <type>pom</type>
    8.         <scope>import</scope>
    9.       </dependency>
    10.     </dependencies>
    11.   </dependencyManagement>

    创建 main/resources/META-INF/spring.factories: 

    1. # Auto Configure
    2. org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
    3.   com.cxf.config.CxfStarterEnableAutoConfiguration

    com.cxf.config.CxfStarterEnableAutoConfiguration：

    1. package com.cxf.config;
    2.  
    3. import org.springframework.beans.factory.annotation.Autowired;
    4. import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
    5. import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
    6. import org.springframework.boot.context.properties.EnableConfigurationProperties;
    7. import org.springframework.context.annotation.Bean;
    8. import org.springframework.context.annotation.Configuration;
    9.  
    10. @Configuration
    11. @ConditionalOnClass(HelloService.class)
    12. @EnableConfigurationProperties(HelloServiceProperties.class)
    13. public class CxfStarterEnableAutoConfiguration {
    14.     private final HelloServiceProperties helloServiceProperties;
    15.  
    16.     @Autowired
    17.     public CxfStarterEnableAutoConfiguration(HelloServiceProperties helloServiceProperties) {
    18.         this.helloServiceProperties = helloServiceProperties;
    19.     }
    20.  
    21.     @Bean
    22.     @ConditionalOnProperty(prefix = "hello.service", name = "enable", havingValue = "true")
    23.     HelloService helloService() {
    24.         return new HelloService(helloServiceProperties.getPrefix(), helloServiceProperties.getSuffix());
    25.     }
    26.  
    27. }

    HelloServiceProperties:

    1. package com.cxf.config;
    2.  
    3. import org.springframework.boot.context.properties.ConfigurationProperties;
    4.  
    5. @ConfigurationProperties("hello.service")
    6. public class HelloServiceProperties {
    7.     private String prefix;
    8.     private String suffix;
    9.  
    10.     public String getPrefix() {
    11.         return prefix;
    12.     }
    13.  
    14.     public void setPrefix(String prefix) {
    15.         this.prefix = prefix;
    16.     }
    17.  
    18.     public String getSuffix() {
    19.         return suffix;
    20.     }
    21.  
    22.     public void setSuffix(String suffix) {
    23.         this.suffix = suffix;
    24.     }
    25. }

    HelloService:

    1. package com.cxf.config;
    2.  
    3. public class HelloService {
    4.     private String prefix;
    5.     private String suffix;
    6.  
    7.     public HelloService(String prefix, String suffix) {
    8.         this.prefix = prefix;
    9.         this.suffix = suffix;
    10.     }
    11.  
    12.     public String say(String text) {
    13.         return String.format("%s, hi, %s, %s", prefix, text, suffix);
    14.     }
    15. }

    当项目依赖该 starter 且配置文件中包含 hello.service前缀且hello.service.enable为true时，自动生成HelloService的Bean。

    在别的 Spring Boot 项目中的pom.xml引入：

    1. <dependency>
    2.   <groupId>org.springframework.boot</groupId>
    3.   <artifactId>cxf-spring-boot-starter</artifactId>
    4.   <version>1.0-SNAPSHOT</version>
    5. </dependency>

    在application.properties(或对应的application.yml)中配置：

    1. hello.service.enable=true
    2. hello.service.prefix=pre
    3. hello.service.suffix=suf


    手写 Spring 核心代码

    Spring 核心代码可参考阅读《SPRING技术内幕：深入解析SPRING架构与设计原理 第2版》（计文柯著）、《Spring源码深度解析 第2版》（郝佳著）、《Spring 5核心原理与30个类手写实战》（谭勇德著）、《Spring Boot编程思想》（小马哥著）等书籍和B站的Spring源码分析视频。

    用300行代码手写提炼Spring核心原理和设计思想，并保证功能可用的例子：GitHub - gupaoedu-tom/spring5-samples: 《Spring5核心原理与30个类手写实战》随书代码示例工程

    Spring的部分总结与思考

    • Spring提供哪些配置方法？

    Java配置通过@Configuration和@Bean注解实现：

    1. @Configuration
    2. public class AppConfig {
    3.     @Bean
    4.     public MyService myService() {
    5.         return my MyServiceImpl();
    6.     }
    7. }

    与上面相同的XML配置如下：

    1. <beans>
    2.     <bean id="myService" class="com.cxf.services.MyServiceImpl" />
    3. </beans>

    (这部分后续再整理)

  • 相关阅读:
    WebMvcConfigurer
    【序列比对】Needleman-Wunsch（全局）和Smith-Waterman（局部）算法py实现（多条回溯路径，三叉树思路，超详细注释）
    Spring IOC源码：＜context:component-scan＞源码详解
    Windows下IntelliJ IDEA工具连接TDEngine集群环境
    k8s集群pod和node状态监控
    Docker Swarm 创建加密覆盖网络
    初创公司用“豆包”大模型，日均tokens两个月内增长357倍
    实现天气彩色图像识别
    智能DNS云解析的宕机切换是如何实现的？-中科三方
    减少 try catch ，可以这样干
  • 原文地址：https://blog.csdn.net/Beth_Chan/article/details/125112461