Springboot 实现自动装配

最新推荐文章于 2024-05-09 06:30:00 发布
最新推荐文章于 2024-05-09 06:30:00 发布
阅读量374 收藏 2
点赞数
分类专栏： Java Springboot 文章标签： Springboot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Tangwp1214/article/details/103940374
版权

SpringBoot由Pivotal团队在2013年开始研发、2014年4月发布第一个版本的全新开源的轻量级框架。基于Spring4.0设计，它不仅继承了Spring框架原有的优秀特性，还通过简化配置来进一步简化了Spring应用的整个搭建和开发过程。另外SpringBoot通过集成大量的框架使得依赖包的版本冲突，以及引用的不稳定性等问题得到了很好的解决。

Springboot 给我们带来了新Spring应用的初始搭建以及开发过程。它使用了特定的方式来进行配置，可以使开发人员不再需要定义样板化的配置。通过这种方式，Spring Boot致力于在蓬勃发展的快速应用开发领域(rapid application development)成为领导者。

使用Springboot进行Java Web开发，只需引用Springboot提供的spring-boot-starter-parent及spring-boot-starter-web两个依赖，再加上一个SpringApplication#run等简单的配置即可搭建好一个Web开发环境，极大的简化了环境的搭建，提高开发效率。

1.自动装配实现原理

Springboot为我们自动引入了开发所需的对应依赖以及相关bean,其实现自动装配核心主要在@SpringBootApplication以及SpringApplication#run方法

@SpringBootApplication //Springboot核心注解
public class Application {

    public static void main(String[] args) {
        
        SpringApplication.run(Application.class, args);
    }

}

 @SpringBootApplication的核心是@EnableAutoConfiguration

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
		@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {

	
	@AliasFor(annotation = EnableAutoConfiguration.class)
	Class<?>[] exclude() default {};

	
	@AliasFor(annotation = EnableAutoConfiguration.class)
	String[] excludeName() default {};

	
	@AliasFor(annotation = ComponentScan.class, attribute = "basePackages")
	String[] scanBasePackages() default {};

	
	@AliasFor(annotation = ComponentScan.class, attribute = "basePackageClasses")
	Class<?>[] scanBasePackageClasses() default {};

}

 @EnableAutoConfiguration通过@Import引入了AutoConfigurationImportSelector类，它实现了对注解@EnableAutoConfiguration的主要处理逻辑

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {

	String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";

	
	Class<?>[] exclude() default {};

	
	String[] excludeName() default {};

}

 其中getCandidateConfigurations 实现了自动装配的核心文件spring.factories的加载，它会在类路径下加载文件META-INF/spring.factories，读取需要进行自动转配的类信息，提供给Springboot进行加载

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
		List<String> configurations = SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(),
				getBeanClassLoader());
		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.");
		return configurations;
	}

下面是spring-boot 2.1.8.RELEASE jar包中的spring.factories文件内容，文件中的类信息都会在应用启动时会被加载进Spring Context中，我们自定义实现的SpringApplicationRunListener、ApplicationContextInitializer也可通过在工程的classpath路径下新建META/spring.factories文件，按照下列方式添加，自定义的bean也会被加载到Springboot容器中

# PropertySource Loaders
org.springframework.boot.env.PropertySourceLoader=\
org.springframework.boot.env.PropertiesPropertySourceLoader,\
org.springframework.boot.env.YamlPropertySourceLoader

# Run Listeners
org.springframework.boot.SpringApplicationRunListener=\
org.springframework.boot.context.event.EventPublishingRunListener

# Error Reporters
org.springframework.boot.SpringBootExceptionReporter=\
org.springframework.boot.diagnostics.FailureAnalyzers

# Application Context Initializers
org.springframework.context.ApplicationContextInitializer=\
org.springframework.boot.context.ConfigurationWarningsApplicationContextInitializer,\
org.springframework.boot.context.ContextIdApplicationContextInitializer,\
org.springframework.boot.context.config.DelegatingApplicationContextInitializer,\
org.springframework.boot.web.context.ServerPortInfoApplicationContextInitializer

# Application Listeners
org.springframework.context.ApplicationListener=\
org.springframework.boot.ClearCachesApplicationListener,\
org.springframework.boot.builder.ParentContextCloserApplicationListener,\
org.springframework.boot.context.FileEncodingApplicationListener,\
org.springframework.boot.context.config.AnsiOutputApplicationListener,\
org.springframework.boot.context.config.ConfigFileApplicationListener,\
org.springframework.boot.context.config.DelegatingApplicationListener,\
org.springframework.boot.context.logging.ClasspathLoggingApplicationListener,\
org.springframework.boot.context.logging.LoggingApplicationListener,\
org.springframework.boot.liquibase.LiquibaseServiceLocatorApplicationListener

# Environment Post Processors
org.springframework.boot.env.EnvironmentPostProcessor=\
org.springframework.boot.cloud.CloudFoundryVcapEnvironmentPostProcessor,\
org.springframework.boot.env.SpringApplicationJsonEnvironmentPostProcessor,\
org.springframework.boot.env.SystemEnvironmentPropertySourceEnvironmentPostProcessor

# Failure Analyzers
org.springframework.boot.diagnostics.FailureAnalyzer=\
org.springframework.boot.diagnostics.analyzer.BeanCurrentlyInCreationFailureAnalyzer,\
org.springframework.boot.diagnostics.analyzer.BeanDefinitionOverrideFailureAnalyzer,\
org.springframework.boot.diagnostics.analyzer.BeanNotOfRequiredTypeFailureAnalyzer,\
org.springframework.boot.diagnostics.analyzer.BindFailureAnalyzer,\
org.springframework.boot.diagnostics.analyzer.BindValidationFailureAnalyzer,\
org.springframework.boot.diagnostics.analyzer.UnboundConfigurationPropertyFailureAnalyzer,\
org.springframework.boot.diagnostics.analyzer.ConnectorStartFailureAnalyzer,\
org.springframework.boot.diagnostics.analyzer.NoSuchMethodFailureAnalyzer,\
org.springframework.boot.diagnostics.analyzer.NoUniqueBeanDefinitionFailureAnalyzer,\
org.springframework.boot.diagnostics.analyzer.PortInUseFailureAnalyzer,\
org.springframework.boot.diagnostics.analyzer.ValidationExceptionFailureAnalyzer,\
org.springframework.boot.diagnostics.analyzer.InvalidConfigurationPropertyNameFailureAnalyzer,\
org.springframework.boot.diagnostics.analyzer.InvalidConfigurationPropertyValueFailureAnalyzer

# FailureAnalysisReporters
org.springframework.boot.diagnostics.FailureAnalysisReporter=\
org.springframework.boot.diagnostics.LoggingFailureAnalysisReporter

在SpringApplication的run方法中也会去加载spring.factories文件中的相关类并进行实例化。执行run方法前会初始化SpringApplication对象，其中就会加载spring.factories中定义的ApplicationContextInitializer，SpringApplicationRunListener

public SpringApplication(ResourceLoader resourceLoader, Class... primarySources) {
        this.sources = new LinkedHashSet();
        this.bannerMode = Mode.CONSOLE;
        this.logStartupInfo = true;
        this.addCommandLineProperties = true;
        this.addConversionService = true;
        this.headless = true;
        this.registerShutdownHook = true;
        this.additionalProfiles = new HashSet();
        this.isCustomEnvironment = false;
        this.resourceLoader = resourceLoader;
        Assert.notNull(primarySources, "PrimarySources must not be null");
        this.primarySources = new LinkedHashSet(Arrays.asList(primarySources));
        this.webApplicationType = WebApplicationType.deduceFromClasspath();
        this.setInitializers(this.getSpringFactoriesInstances(ApplicationContextInitializer.class));//加载spring.factoies文件中的定义的ApplicationContextInitializer
        this.setListeners(this.getSpringFactoriesInstances(ApplicationListener.class));//加载spring.factoies定义的SpringApplicationRunListener
        this.mainApplicationClass = this.deduceMainApplicationClass();
    }

2.自定义自动装配实现

实现自定义自动装配需要创建两个工程，greeting-spring-boot-starter，springbooot-autoconfiguration，其中starter的命名可参考springboot官方规范。

greeting-spring-boot-starter: starter只是一个空的项目，用于提供对自动配置模块的依赖，以及一些其他的依赖

springbooot-autoconfiguration: 自动配置工程，需要引入自动配置依赖spring-boot-autoconfigure，spring-boot-configuration-processor

greeting-spring-boot-starter 工程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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.8.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.twp.spring</groupId>
    <artifactId>greeting-spring-boot-starter</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>customer-spring-boot-starter</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>12</java.version>
    </properties>

    <dependencies>

        <dependency>
            <groupId>com.twp.spring</groupId>
            <artifactId>springbooot-autoconfiguration</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>12</source>
                    <target>12</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

springbooot-autoconfiguration 中需要实例化的服务类

package com.twp.spring.server;

import com.twp.spring.properties.GreetingServerProperties;

public class GreetingServer {

    private GreetingServerProperties properties;

    public String greet(){

        return properties.getTarget() + ":" + properties.getMessage();
    }

    public GreetingServerProperties getProperties() {
        return properties;
    }

    public void setProperties(GreetingServerProperties properties) {
        this.properties = properties;
    }
}

GreetingServerProperties属性类

package com.twp.spring.properties;

import org.springframework.boot.context.properties.ConfigurationProperties;

import java.io.Serializable;

@ConfigurationProperties(prefix = "greeting")
public class GreetingServerProperties implements Serializable {

    private static final long serialVersionUID = -225936785539739342L;

    private String target;

    private String message;

    public String getTarget() {
        return target;
    }

    public void setTarget(String target) {
        this.target = target;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
}

自动配置类

package com.twp.spring.configuration;

import com.twp.spring.properties.GreetingServerProperties;
import com.twp.spring.server.GreetingServer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableConfigurationProperties(GreetingServerProperties.class)
@ConditionalOnClass(GreetingServer.class)
@ConditionalOnProperty(prefix = "greeting",value = "enabled",matchIfMissing = true)
public class GreetingServerAutoConfiguration {

    @Autowired
    private GreetingServerProperties properties;

    @Bean("greeting")
    public GreetingServer greeting(){
        GreetingServer greetingServer = new GreetingServer();
        greetingServer.setProperties(properties);
        return greetingServer;
    }
}

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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.8.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.twp.spring</groupId>
    <artifactId>springbooot-autoconfiguration</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>
    <name>springbooot-autoconfiguration</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>12</java.version>
    </properties>

    <dependencies>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-autoconfigure</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>12</source>
                    <target>12</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

在spring.factories文件中配置自动配置类

# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.twp.spring.configuration.GreetingServerAutoConfiguration

执行mvn clean install，先将自动配置工程进行打包，再打包starter工程

在其他工程中引入starter工程，进行测试

<dependency>
    <groupId>com.twp.spring</groupId>
    <artifactId>greeting-spring-boot-starter</artifactId>
    <version>0.0.1-SNAPSHOT</version>
</dependency>
greeting:
  message: "Hello AutoConfiguration"
  target: "张飞"

测试接口

@Slf4j
@RestController
public class GreetingController {

    @Autowired
    private GreetingServer greetingServer;

    @GetMapping("/greet")
    public String greeting(){
        log.info("Greeting:{}",greetingServer.greet());
        return greetingServer.greet();
    }
}

请求接口结果:

这样就简单实现了自动配置，更加规范的starter编写，可以参考Springboot官方提供的各个组件的starter，如redis,mongoDB等。

孤舟沧海
关注
专栏目录
面试官：Spring Boot 自动装配是如何实现的？
小识的博客
03-27 1566
Enable注解是如何实现的？ 当我们使用Spring Boot的时候，只需要在启动类上加@SpringBootApplication注解即可，非常方便。@SpringBootApplication是一个复合注解 @SpringBootConfiguration @EnableAutoConfiguration @ComponentScan 其中自动装配的功能就是由@EnableAutoConfiguration注解实现的，那么@EnableAutoConfiguration是如何实现这个神奇的功能的？.
Springboot自动装配实现过程代码实例
08-19
Springboot自动装配实现过程代码实例是指在Spring Boot项目中实现自动装配的过程，包括创建自定义注解、配置类和自动装配Bean的过程。 知识点一：自定义注解 在Spring Boot项目中，可以使用自定义注解来标记组件、...
Spring Boot如何实现自动装配
weixin_45701550的博客
05-14 3388
Spring Boot的自动装配是Spring框架的一项重要特性，它使得开发人员可以更加便捷地集成第三方组件和库，并在应用程序中使用它们。Spring Boot的自动装配通过条件注解和类路径扫描实现。自动配置类使用@Configuration和@EnableConfigurationProperties注解标记，告诉Spring Boot这是一个自动配置类，并且需要配置哪些属性和类。
Springboot自动装配
纯洁的小魔鬼
05-31 4547
自动装配是springboot的核心，一般提到自动装配就会和springboot联系在一起。实际上 Spring Framework 早就实现了这个功能。Spring Boot 只是在其基础上，通过 SPI 的方式，做了进一步优化。
springboot的自动装配是如何实现的
weixin_42604188的博客
01-17 285
Spring Boot 的自动装配是通过 Spring 框架中的 @Autowired 注解实现的。@Autowired 注解用来标记需要自动装配的属性或者方法。当 Spring 容器初始化时，会自动查找标记了 @Autowired 注解的属性或者方法，并为其装配相应的对象。 Spring Boot 会在启动时扫描所有的 Bean，并自动为 @Autowired 注解的属性或者方法注入依赖的 Be...
Spring Boot是怎么实现自动装配的？
冥胖胖9的博客
10-09 118
自动装配是Spring Boot中最重要的高级特性之一，它不但可以减少重复代码的编写，而且还可以大大提高我们的开发效率。所谓的自动装配就是，Spring Boot会根据类路径中的jar包、类，为jar包中的类自动配置，这样可以极大的减少需要的配置。其实也就是，它会根据classpath下的类，自动给我们生成对应的Bean，然后加载Spring容器中。
springboot自定义自动装配.rar
04-25
在Spring Boot框架中，自定义自动装配是开发者为了满足特定需求，对框架默认配置进行扩展或替换的关键技术。Spring Boot的自动配置理念是基于“约定优于配置”，它能根据项目中的依赖自动配置Bean，极大地简化了Java...
SpringBoot启动及自动装配原理过程详解
08-19
SpringBoot启动及自动装配原理过程详解 SpringBoot启动及自动装配原理过程详解是 SpringBoot 框架中一个非常重要的机制，它控制着整个应用程序的启动和自动装配过程。下面将详细介绍 SpringBoot 启动及自动装配...
springboot自动装配笔记
01-16
下面我们将深入探讨 SpringBoot 的自动装配过程。 首先，SpringBoot 的自动装配始于其独特的依赖管理机制。在 `pom.xml` 文件中，引入的 `spring-boot-dependencies` 父工程包含了所有 SpringBoot 组件的默认版本，...
手动实现SpringBoot自动装配类
04-21
手动实现自动装配类，我们可以遵循以下步骤： 1. 创建配置类：使用`@Configuration`注解标识一个类为配置类，这个类将包含我们自定义的bean定义。例如，我们可以创建一个名为`MyAutoConfiguration`的类，并在其中...
java.lang.NoClassDefFoundError: javax/validation/ValidationException
wuhahaq的博客
03-21 1720
java.lang.NoClassDefFoundError: javax/validation/ValidationException
SpringBoot的自动装配是如何实现的？
chaochao2113的博客
10-15 1920
Spring注入的三种方式，SpringBoot自动装配源码解析
Springboot 启动java.lang.NoClassDefFoundError: javax/validation/ValidationException异常大坑
shmilyhq的博客
01-23 3440
在Springboot启动[restartedMain] DEBUG org.springframework.boot.diagnostics.FailureAnalyzers - FailureAnalyzer org.springframework.boot.diagnostics.analyzer.ValidationExceptionFailureAnalyzer@2bcd1a failed异常 其实主要的错误出现在application.yml文件中 坑！ ...
SpringBoot自动装配的方式
suming97的博客
09-27 1198
spring中实现自动装配的方式有两种，一种是通过xml文件、另一种是通过注解。
springboot如何实现自动装配
最新发布
m0_63102097的博客
05-09 331
例如，Spring Boot中的JPA自动配置类org.springframework.boot.autoconfigure.orm.jpa.JpaBaseConfiguration，使用了@ConditionalOnClass和@ConditionalOnBean等条件化注解，来根据Class路径是否包含JPA相关的类以及是否存在JPA相关的Bean来决定是否启用JPA自动配置。：Spring Boot Starter是一种依赖包，其中包含了一组预定义的依赖和自动配置，可以简化应用程序的配置和构建过程。
详细剖析SpringBoot自动装配的实现过程
tigerhhzz的博客
03-07 966
详细剖析SpringBoot自动装配的实现过程
SpringBoot的自动装配
99Savage
10-25 5470
SpringBoot自动装配原理
springBoot自动装配
热门推荐
qq_62898618的博客
11-16 1万+
为了简化配置，使spring的使用更加方便，例如：可以回忆一下springboot中是如何继承redis的。使用springboot后集成常用的第三方框架变得非常简单了。springboot starter带来的问题starter使SpringBoot集成第三方框架变得简单，但对刚刚上手SpringBoot的人来说，可能只知道配置属性是在application.xml或application.yml中添加，但他们各自的属性都有哪些，具体怎么配置，却无从下手。
SpringBoot自动装配详解
goat的博客
03-06 2617
Spring Boot 的自动装配（Auto-Configuration）原理是基于Spring Framework的条件化配置和注解实现的。这种机制允许开发者在项目中引入相关的依赖，Spring Boot 将根据这些依赖自动配置应用程序的上下文和功能。SpringBoot 定义了一套接口规范，这套规范规定：SpringBoot 在启动时会扫描外部引用 jar 包中的。
springboot实现自动装配
09-09
Spring Boot的自动装配是通过条件注解和Spring Boot的自动配置机制实现的。 条件注解是一种特殊的注解，它可以根据条件来决定是否加载某个类或者某个Bean。Spring Boot中的条件注解有很多，比如@ConditionalOnClass...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值