Spring Boot Auto-Configuration

最新推荐文章于 2024-08-12 09:07:46 发布
最新推荐文章于 2024-08-12 09:07:46 发布
阅读量2k 收藏 6
点赞数 4
分类专栏： java 基础 文章标签： Auto-config Spring 自动装配
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013433591/article/details/128007364
版权

Spring 自定义Auto-Configuration

Spring Boot 可以根据classpath中依赖关系自动装配应用程序。通过自动装配机制，可以使开发更快、更简单。今天，学习下如何在Spring Boot 中创建自定义 auto-configuration。

代码运行环境

Maven 依赖

首先添加以下依赖

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-web</artifactId>
  <version>2.7.5</version>
</dependency>
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-data-jpa</artifactId>
  <version>2.7.5</version>
</dependency>
<dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
  <version>8.0.19</version>
</dependency>

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-test</artifactId>
  <version>2.7.5</version>
  <scope>test</scope>
</dependency>
<dependency>
  <groupId>junit</groupId>
  <artifactId>junit</artifactId>
  <version>4.13.1</version>
  <scope>test</scope>
</dependency>
<dependency>
  <groupId>javax.xml.bind</groupId>
  <artifactId>jaxb-api</artifactId>
  <version>2.3.1</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-test</artifactId>
  <version>5.3.23</version>
  <scope>test</scope>
</dependency>

创建自动装配

为了创建自动装配机制，首先创建一个类，并使用 @Configuration注解标记。以创建一个Mysql数据源为例

@Configuration
public class MySQLAutoconfiguration {
    //...
}

接下来，需要将类注册到Spring Boot 容器中。创建 resources/META-INF/spring.factories文件, 内容如下：

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.spring.boot.autoconfig.MySQLAutoconfiguration
  • 如果想要自定义的装配有更高的优先级，需要添加 @AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE) 注解即可。
  • 开发者可以使用 @Conditional 注解标记 auto-configuration的类，以便在条件满足时激活自动装配.
  • bean的默认作用于为单例，如果开发者自定义的bean 装配跟框架内定义的bean一致，则会覆盖默认的bean定义

Class Conditions

Conditions 系列注解允许开发者定义 当指定条件满足时才会加载 auto-configuration.

  • @ConditionalOnClass 当指定类存在时 条件满足
  • @ConditionalOnMissingClass 当指定类不存在时 条件满足
@Configuration
@ConditionalOnClass(DataSource.class)
public class MySQLAutoconfiguration {
    //...
}

上述代码指定当 DataSource.class 存在时，@Configuration 装配的逻辑才生效。

Bean Conditions

指定的bean是否存在，由此来确定是否加载 @Configuration

  • @ConditionalOnBean - bean存在时 条件满足
  • @ConditionalOnMissingBean - bean不存在时 条件满足

接下来，在 configuration class中增加 数据源定义. 开发者期望同时满足以下两个条件，才会创建bean

  1. 当容器中存在以 datasource 命名的bean
  2. 当容器中不存在entityManagerFactory类型的bean
@Bean
@ConditionalOnBean(name = "dataSource")
@ConditionalOnMissingBean
public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
    LocalContainerEntityManagerFactoryBean em
      = new LocalContainerEntityManagerFactoryBean();
    em.setDataSource(dataSource());
    em.setPackagesToScan("com.spring.boot");
    em.setJpaVendorAdapter(new HibernateJpaVendorAdapter());
    if (additionalProperties() != null) {
        em.setJpaProperties(additionalProperties());
    }
    return em;
}

以同样的方式创建事务管理的bean

@Bean
@ConditionalOnMissingBean(type = "JpaTransactionManager")
JpaTransactionManager transactionManager(EntityManagerFactory entityManagerFactory) {
    JpaTransactionManager transactionManager = new JpaTransactionManager();
    transactionManager.setEntityManagerFactory(entityManagerFactory);
    return transactionManager;
}

Property Conditions

开发者可以使用@ConditionalOnProperty注解通过判断Spring 环境中是否存在相关属性来确定是否进行自动装配。

首先，在 resource 目录下创建 mysql.perperties

usemysql=local

mysql-hibernate.dialect=org.hibernate.dialect.MySQL5Dialect
mysql-hibernate.show_sql=true
mysql-hibernate.hbm2ddl.auto=update

其次，使用@PropertySource注解以mysql.perperties是否存在为条件，决定是否加载配置

@PropertySource("classpath:mysql.properties")
public class MySQLAutoconfiguration {
    //...
}

接下来，我们使用两种方式创建建数据库连接

  • 硬编码方式
@Bean
@ConditionalOnProperty(name = "usemysql", havingValue = "local")
@ConditionalOnMissingBean
public DataSource dataSource() {
    DriverManagerDataSource dataSource = new DriverManagerDataSource();
 
    dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
    //此处需要根据实际情况进行修改
    dataSource.setUrl("jdbc:mysql://localhost:3306/myDb?createDatabaseIfNotExist=true");
    dataSource.setUsername("root");
    dataSource.setPassword("123456");

    return dataSource;
}
  • 配置文件的方式
@Bean(name = "dataSource")
@ConditionalOnProperty(
  name = "usemysql", 
  havingValue = "custom")
@ConditionalOnMissingBean
public DataSource dataSource2() {
    DriverManagerDataSource dataSource = new DriverManagerDataSource();
        
    dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
    dataSource.setUrl(env.getProperty("mysql.url"));
    dataSource.setUsername(env.getProperty("mysql.user") != null 
      ? env.getProperty("mysql.user") : "");
    dataSource.setPassword(env.getProperty("mysql.pass") != null 
      ? env.getProperty("mysql.pass") : "");
        
    return dataSource;
}

上述两个方法将条件装配的特性展现的淋漓尽致，并且对开发者十分友好。可以在配置文件中指定相关属性，实现按需加载。 开发环境加载dataSource,测试环境加载datasource2.

Resource Conditions

@ConditionalOnResource注解表示当指定资源存在时，才会进行自动装配。定义一个additionalProperties() 方法，该方法返回entityManagerFactory bean需要使用的 Hibernate 相关属性。

@ConditionalOnResource(
  resources = "classpath:mysql.properties")
@Conditional(HibernateCondition.class)
Properties additionalProperties() {
    Properties hibernateProperties = new Properties();

    hibernateProperties.setProperty("hibernate.hbm2ddl.auto", 
      env.getProperty("mysql-hibernate.hbm2ddl.auto"));
    hibernateProperties.setProperty("hibernate.dialect", 
      env.getProperty("mysql-hibernate.dialect"));
    hibernateProperties.setProperty("hibernate.show_sql", 
      env.getProperty("mysql-hibernate.show_sql") != null 
      ? env.getProperty("mysql-hibernate.show_sql") : "false");
    return hibernateProperties;
}

自定义 Conditions

之前介绍的各种 条件装配注解，基本能满足绝大多数业务需求。此外，Spring Boot 也预留了接口让开发者实现自定义的条件注解。我们来实现一个自定义装配的类，作用是判断 HibernateEntityManager 类是否在classpath中

static class HibernateCondition extends SpringBootCondition {

    private static String[] CLASS_NAMES
      = { "org.hibernate.ejb.HibernateEntityManager", 
          "org.hibernate.jpa.HibernateEntityManager" };

    @Override
    public ConditionOutcome getMatchOutcome(ConditionContext context, 
      AnnotatedTypeMetadata metadata) {
 
        ConditionMessage.Builder message
          = ConditionMessage.forCondition("Hibernate");
        return Arrays.stream(CLASS_NAMES)
          .filter(className -> ClassUtils.isPresent(className, context.getClassLoader()))
          .map(className -> ConditionOutcome
            .match(message.found("class")
            .items(Style.NORMAL, className)))
          .findAny()
          .orElseGet(() -> ConditionOutcome
            .noMatch(message.didNotFind("class", "classes")
            .items(Style.NORMAL, Arrays.asList(CLASS_NAMES))));
    }
}

然后在 additionalProperties() 方法上增加注解

@Conditional(HibernateCondition.class)
Properties additionalProperties() {
  //...
}

应用级别 Conditions

此外，开发者可以使用以下注解指定 web 上下文中满足指定条件

  • @ConditionalOnWebApplication - web应用才会满足条件
  • @ConditionalOnNotWebApplication - 非web应用才会满足条件

验证测试

创建实体文件

package com.spring.boot.entity;

import javax.persistence.Entity;
import javax.persistence.Id;

@Entity
public class User {
    @Id
    private Long id;
    private String email;
    public User() {
    }
    public User(String email,Long id) {
        super();
        this.email = email;
        this.id = id;
    }
    public String getEmail() {
        return email;
    }
    public void setEmail(String email) {
        this.email = email;
    }
    public Long getId() {
        return id;
    }
    public void setId(Long id) {
        this.id = id;
    }
}

创建Repository

public interface MyUserRepository 
  extends JpaRepository<MyUser, String> { }

开启自动装配

为了开启自动装配启动类上，增加*@SpringBootApplication* 或 @EnableAutoConfiguration注解。

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

测试类

import com.spring.boot.AutoConfigurationApplication;
import com.spring.boot.entity.User;
import com.spring.boot.repository.UserRepository;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;


@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = AutoConfigurationApplication.class)
@EnableJpaRepositories(basePackages = { "com.spring.boot" })
public class AutoconfigurationTest {

    @Autowired
    private UserRepository userRepository;

    @Test
    public void whenSaveUser_thenOk() {
        User user = new User("user@email.com",1000L);
        userRepository.save(user);
    }
}

运行测试方法，并在mysql数据库中相关记录

在这里插入图片描述

禁止自动装配

开发者可以通过以下两种方式禁止指定的自动装配

  • 代码方式

    @Configuration
@EnableAutoConfiguration(
  exclude={MySQLAutoconfiguration.class})
public class AutoconfigurationApplication {
    //...
}

  • 配置方式

    spring.autoconfigure.exclude=com.baeldung.autoconfiguration.MySQLAutoconfiguration
u013433591
关注
专栏目录
009 maven插件spring-boot-maven-plugin
06-17
该 POM 包含了许多有用的依赖项和配置，例如 Spring Boot auto-configuration、 logging 等。 使用 Spring Boot without the Parent POM 如果不想继承 Starter 父 POM，可以使用以下方式来使用 Spring Boot： ```...
Spring Boot四大神器之Auto Configuration
王浩的技术博客
02-22 1万+
Spring Boot非常简单容易上手，它隐藏了很多内容而不需要你去关心。但对于一个好的开发人员也许希望知道Spring Boot自动配置背后到底发生了什么？ Spring Boot并不属于一种新的技术，只不过Spring Boot的启动器帮我们配置了若干个被Spring管理的bean，当我们的项目依赖这些jar并启动Spring应用时，Spring的Container容器已经把jar包下的对象加...
Spring Boot 中的自动配置（autoconfigure）
????
01-25 2346
详细的讲解了Spring Boot 自动配置的原理以及其中使用到的主要注解和类
Spring Boot:四大神器之Auto Configuration
最新发布
Admans的专栏
08-12 676
Spring Boot非常简单容易上手，它隐藏了很多内容而不需要你去关心。但对于一个好的开发人员也许希望知道Spring Boot自动配置背后到底发生了什么？Spring Boot并不属于一种新的技术，只不过Spring Boot的启动器帮我们配置了若干个被Spring管理的bean，当我们的项目依赖这些jar并启动Spring应用时，Spring的Container容器已经把jar包下的对象加以创建及管理了。
@AutoConfiguration注解详解
热门推荐
怪咖@的博客
10-31 2万+
@AutoConfiguration属于springboot当中autoconfigure包下的注解。springboot给我们提供了好多AutoConfiguration，例如关于缓存cache的有CacheAutoConfiguration，关于定时任务quartz的有QuartzAutoConfiguration，这些AutoConfiguration你会发现基本上都会拿@AutoConfiguration来修饰。本篇来彻底了解@AutoConfiguration到底有什么作用，以及到底如何应用他。
Spring_boot之自动加载自己的AutoConfiguration
Harry的博客
06-27 4990
如果项目中要开发一个比较通用的组件，这个组件可以被其它springboot项目应用并且其它springboot项目在应用它时不要加入新的标注和代码，只要在pom.xml里加入它的依赖就可以了。怎么办呢假如：我们组件名字时spring_autoconfiguration,在我们的组件里加入META-INF/spring.factories文件 创建这个组件的MyEnableAutoConfiguration MyService pom.xml 2. 项目spring_boot_test这个是sp
SpringBoot的AutoConfigure自动配置原理
HD243608836的博客
01-04 4718
外化配置和自动配置 将配置从代码中分离到XML或者properties中，这种spring配置外部化的方式成为外部配置。 spring 自动配置，spring-boot-autoconfigure依赖默认配置项，根据添加的依赖自动加载相关的配置属性并启动依赖。应用者只需要引入对应的start jar包，spring boot 就可以自动扫描和加载依赖信息。 自动配置原理 自动配置的前提 @Configuration ：他是JavaConfig形式的Spring IOC容器配置，其本身是一个IOC
spring-boot-starter-hbase:Spring Boot Starter HBase的
05-09
自定义的spring-boot的hbase starter，为hbase的query和更新等操作提供简易的api并集成spring-boot的auto configuration 版本 本项目版本 hbase版本 1.0.0 hbase1.1.2 打包 修改相关的maven私服地址 gradle clean ...
spring-boot-reference2018最新版
07-12
一个典型的Spring Boot应用通常包含一个`@SpringBootApplication`注解的主类，这个注解结合了`@Configuration`、`@EnableAutoConfiguration`和`@ComponentScan`三个注解的功能。 6. **Spring Boot与Maven/Gradle...
spring-boot-master-auto-configuration:在“ Master Spring Boot自动配置”讨论期间使用的示例应用程序
05-14
Master Spring Boot自动配置 这是在Master Spring Boot自动配置讨论期间使用的示例应用程序。 此存储库每步包含一个提交，以实现完整的自动配置。 有关每个步骤的详细信息，请参阅提交消息。 笔记 请参阅。 会议的...
自定义spring-boot-starter封装
07-12
1. **自动配置类（Auto Configuration）**：这是`spring-boot-starter`的核心，通过`@Configuration`和`@Conditional`注解，Spring Boot能根据类路径中的存在与否自动配置相应的bean。 2. ** starter-pom.xml**：这...
【SpringBoot】AutoConfigurtion（自动配置）
一个天蝎座的程序猿
05-21 1147
揭秘Spring Boot自动配置（Auto Configuration）运行机制，谈到auto-configuration，肯定离不开@EnableAutoConfiguration注解。 package org.springframework.boot.autoconfigure; @Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) @Documented @Inherited @AutoConfigurationPackage
Spring auto configuration简介
FantasyBaby的博客
11-29 1319
什么是自动配置 Spring Boot的自动配置试图通过自动的方式基于我们添加的jar依赖来配置Spring应用. 比如 HSQLDB在classpath里面,并且我们没有手动配置任何数据库连接的bean,Spring boot会自动的配置一个内存级别数据库. 我们可以选择添加 @EnableAutoConfiguration或者@SpringBootApplication 在配置类上 Spring boot支持的所有的自动配置 替换自动配置 自动配置是无侵入的...
Spring Boot之auto configuration自动配置
sunny潘先生的博客
01-03 2545
概念 springboot auto configuration的本质就是自动配置spring的各种bean。然后使应用可以通过@Autowired等注入方式来直接使用bean。 比如自动配置redisTemplate，jdbcTemplate等bean。 原理 1. 开启@EnableAutoConfiguration注解 如果写了@SpringBootApplication注解，不必...
7.spring-boot依赖详解
yiguang_820的博客
09-13 515
【代码】7.spring-boot依赖详解。
SpringBoot——自动化配置（Auto-configuration）原理和使用
程序员阿皓的博客
05-03 725
自动化配置是Spring Boot框架的一个重要特性，它通过条件化配置和约定优于配置的原则，根据应用程序的类路径和其他条件自动配置应用程序所需的Bean。
SpringBoot特性
weixin_43923436的博客
01-11 312
依赖管理 几乎声明了所有开发中常用的依赖的版本号。自动版本仲裁机制。 SpringBoot利用maven的父项目特性，只需要导入父项目的依赖，子项目会继承父项目的依赖，就不需要再手动管理各种jar包及其版本，全部都已经通过父项目定义好了。 1、引入依赖默认都可以不写版本 2、引入非版本仲裁的jar，要写版本号。 依赖管理 <parent> <groupId>org.springframework.boot</groupId> &lt
[Java] Spring Boot Auto Configure（Spring Boot自动装配）的原理
ToraNe的博客
11-21 3521
Spring Boot能帮助我们Java开发者快速开发基于Spring框架的应用，除了其作为依赖管理好帮手的一众Spring-Boot-Starter之外，其自动装配（Auto Configure）特性也起到了非常重要的作用。那么Spring Boot是如何实现自动装配的呢？本文将结合源码去讲解其原理。
Spring Boot起步依赖
wantLight的博客
02-26 413
Spring Boot起步依赖 spring-boot-autoconfigure:包含大量第三方自动配置，还有一个文件名叫spring.factories的配置文件。 这里我们先看一下 mybatis.mapper.autoconfigure。引入mybatis基础得bean @Configuration //在SqlSessionFactory和SqlSessionF...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值