关于spring-boot-编程思想:Spring-Boot自定义配置与自动配置共存

Spring Boot 是一个疾速开发框架，能够简化 Spring 应用程序的开发，其中自定义配置是其中一个十分重要的个性。

在 Spring Boot 中，自定义配置容许开发者以本人的形式来配置应用程序。自定义配置能够用于笼罩默认配置，也能够用于增加新的配置项。本文将具体介绍 java 框架面试题 -Spring Boot 自定义配置与主动配置共存，并提供 Java 代码案例。

一.Spring Boot 自定义配置的过程
Spring Boot 是一种基于 Spring 框架的疾速开发应用程序的工具。它应用主动配置和约定大于配置的形式，简化了开发人员的工作量。在 Spring Boot 中，能够应用 application.properties 或 application.yml 文件来配置应用程序的属性。然而，有时候须要自定义配置，以满足特定的需要。上面给大家带来的是自定义配置的过程和代码案例的详细分析：

1. 创立一个配置类
首先，创立一个 Java 类，用于自定义配置。这个类须要应用 @Configuration 注解，以批示它是一个配置类。此外，如果须要在配置类中应用其余的 Spring 组件，比方 @Bean 注解，还须要应用 @ComponentScan 注解来扫描这些组件。

@Configuration
@ComponentScan
public class MyConfig {

// 定义配置项

}

2. 定义配置项
在配置类中，能够定义须要自定义的配置项。这些配置项能够是应用程序中的任何属性，例如数据库连贯参数、邮件服务器设置、缓存策略等等。配置项须要应用 @Bean 注解，以批示它是一个 Spring Bean。在 @Bean 注解中，须要应用 @ConfigurationProperties 注解来指定配置项的前缀和属性。

@Configuration
@ComponentScan
public class MyConfig {

@Bean
@ConfigurationProperties(prefix = “myapp.database”)
public DataSource dataSource() {

  // 定义数据源配置

}

@Bean
@ConfigurationProperties(prefix = “myapp.email”)
public EmailProperties emailProperties() {

  // 定义邮件服务器配置

}

}

在下面的例子中，咱们定义了两个配置项：dataSource 和 emailProperties。这些配置项的前缀别离为“myapp.database”和“myapp.email”。

3. 增加配置文件
接下来，须要增加一个 application.properties 或 application.yml 文件，以存储自定义配置。

在这个文件中，须要为每个配置项指定一个值。如果应用的是 application.properties 文件，须要依照“前缀. 属性 = 值”的格局来配置。如果应用的是 application.yml 文件，须要依照以下格局来配置：

myapp:
database:

driver-class-name: com.mysql.jdbc.Driver
url: jdbc:mysql://localhost:3306/mydb
username: myuser
password: mypass

email:

host: smtp.gmail.com
port: 587
username: myemail@gmail.com
password: myemailpassword

在下面的例子中，咱们为 dataSource 和 emailProperties 两个配置项指定了值。

4. 应用自定义配置
当初，能够在应用程序中应用自定义配置了。只须要在须要应用配置的类中，应用 @Autowired 注解来主动注入配置类中的 Bean 即可。

@RestController
public class MyController {

@Autowired
private DataSource dataSource;

@Autowired
private EmailProperties emailProperties;

// 应用 dataSource 和 emailProperties

}

在下面的例子中，咱们在 MyController 类中应用了 dataSource 和 emailProperties 两个配置项。通过以上步骤，就能够实现 Spring Boot 中的自定义配置了。

二. Spring Boot 自定义配置原理
Spring Boot 的自定义配置原理其实就是基于 Spring 框架的 IoC 容器和 Bean 生命周期的概念实现的。在 Spring Boot 中，咱们能够通过 @Configuration 注解定义一个配置类，而后在这个类中应用 @Bean 注解定义一些 Bean 对象，这些 Bean 对象能够被其余组件主动注入。

上面咱们来看一个简略的案例，详细分析 Spring Boot 自定义配置的原理：

假如咱们有一个服务类 HelloService，它须要一个名为 message 的属性值作为欢送信息。

public class HelloService {

private String message;
public HelloService(String message) {this.message = message;}
public void sayHello() {System.out.println(message);
}

}

当初咱们须要应用 Spring Boot 来配置 HelloService，并将 message 属性值设置为 ”Hello, World!”。咱们能够定义一个配置类 HelloConfig：

@Configuration
public class HelloConfig {

@Bean
public HelloService helloService() {return new HelloService("Hello, World!");
}

}

在下面的代码中，@Configuration 注解示意这是一个配置类，@Bean 注解示意定义了一个 Bean 对象 helloService。在 helloService 办法中，咱们创立了一个 HelloService 对象，并将 message 属性值设置为 ”Hello, World!”，而后将它返回。

当初咱们能够在其余组件中注入 HelloService 对象，并调用它的 sayHello 办法了。比方咱们能够在一个控制器类中注入 HelloService 对象，并在某个申请解决办法中调用它：

@RestController
public class HelloController {

@Autowired
private HelloService helloService;
@GetMapping("/hello")
public void hello() {helloService.sayHello();
}

}

在下面的代码中，@RestController 注解示意这是一个控制器类，@Autowired 注解示意要主动注入 HelloService 对象。在 hello 办法中，咱们调用 HelloService 的 sayHello 办法输入欢送信息。通过这个案例，咱们能够看到 Spring Boot 的自定义配置原理其实就是通过 IoC 容器和 Bean 生命周期来治理 Bean 对象，并提供了一种简略不便的形式来定义和配置这些对象。

咱们只须要在配置类中应用 @Configuration 和 @Bean 注解来定义 Bean 对象，而后在其余组件中应用 @Autowired 注解来主动注入它们即可。

三. Spring Boot 主动配置的过程
Spring Boot 的主动配置是 Spring Boot 框架的外围个性之一，它能够依据类门路中存在的依赖关系主动配置 Spring 应用程序，缩小了 Spring 应用程序的配置量，进步了开发效率。上面让咱们通过一个代码案例来详细分析 Spring Boot 的主动配置过程：

首先，咱们须要创立一个 Spring Boot 我的项目，并在 http://pom.xml 文件中增加以下依赖：

<dependencies>

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

</dependencies>

这里咱们增加了 spring-boot-starter-web 依赖，它蕴含了 Spring Boot Web 应用程序的所有必须依赖项。而后，咱们创立一个简略的 Java 类 HelloController，代码如下：

@RestController
public class HelloController {

@GetMapping("/hello")
public String hello() {return "Hello, World!";}

}

在这个 Java 类中，咱们应用了 Spring 框架中的 @RestController 注解，将该类申明为一个 Web 控制器，同时应用了 @GetMapping 注解来定义 HTTP GET 申请的映射门路。

接下来，咱们启动 Spring Boot 应用程序，能够发现在控制台输入了一系列的主动配置信息，其中蕴含了 Tomcat 服务器的主动配置信息，如下所示：

2023-04-10 17:06:50.581 INFO 19944 — [main] o.s.b.a.e.web.EndpointLinksResolver : Exposing 2 endpoint(s) beneath base path ‘/actuator’
2023-04-10 17:06:51.325 INFO 19944 — [main] o.s.b.web.embedded.tomcat.TomcatWebServer : Tomcat started on port(s): 8080 (http) with context path ”
2023-04-10 17:06:51.328 INFO 19944 — [main] com.example.demo.DemoApplication : Started DemoApplication in 2.233 seconds (JVM running for 2.844)

从输入后果能够看出，Spring Boot 曾经主动配置了 Tomcat 服务器，并且将应用程序部署在了端口号为 8080 的地位。

如果咱们心愿对 Tomcat 服务器进行更加粗疏的配置，能够在 application.properties 或 application.yml 中增加对应的属性配置项，例如：

server:
port: 8888

这样就能够将 Tomcat 服务器的端口号配置为 8888。

总的来说，Spring Boot 的主动配置过程就是在应用程序启动时，依据类门路中存在的依赖关系和配置文件中的属性配置，主动配置 Spring 应用程序的各种组件和性能。这种主动配置的形式极大地提高了开发效率，让开发人员可能更加专一于业务逻辑的实现。

四. Spring Boot 主动配置的原理
Spring Boot 的主动配置是 Spring Boot 的一大特色，它可能主动配置大量的框架和组件，使得开发者只需大量的代码就能疾速搭建一个 Spring Boot 利用。上面将通过代码案例详细分析 Spring Boot 主动配置的原理。

Spring Boot 的主动配置基于 Spring 的条件化配置（Conditional Configuration）机制实现。条件化配置是指在 Spring 容器中只有满足特定条件的 bean 才会被创立和注册到容器中，这样能够依据不同的场景抉择不同的配置。Spring Boot 利用了这一机制，通过配置类中的 @Conditional 注解来判断是否须要主动配置。

上面以 Spring Boot 主动配置 MyBatis 数据库拜访框架为例，演示主动配置的原理。首先在 Maven 或 Gradle 中引入 MyBatis 和 MyBatis-Spring 的依赖：

<dependency>

<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.6</version>

</dependency>
<dependency>

<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>2.2.0</version>

</dependency>

而后，在配置类中增加 @MapperScan 注解，指定须要扫描的 Mapper 接口所在的包：

@Configuration
@MapperScan(“com.example.mapper”)
public class MyBatisConfig {
}

在这个配置类中，@MapperScan 注解会触发主动配置，主动配置会扫描 com.example.mapper 包下的所有 Mapper 接口，并为这些接口创立代理对象并注册到 Spring 容器中。

主动配置的原理在 MyBatis-Spring 的源码中也能够看到。在 MybatisAutoConfiguration 类中，有一个 @ConditionalOnClass 注解，示意只有在类门路中存在 MybatisTemplate 类时才会启用主动配置：

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass({SqlSessionFactory.class, SqlSessionFactoryBean.class})
@AutoConfigureAfter(MybatisLanguageDriverAutoConfiguration.class)
@MapperScan(basePackages = MybatisAutoConfiguration.BASE_PACKAGE)
public class MybatisAutoConfiguration {

...

}

在这个类中，还有许多其余的条件判断，例如只有在存在 DataSource 类时才会配置数据源。这些条件的组合，最终决定了是否启用 MyBatis 的主动配置。综上所述，Spring Boot 主动配置的原理是基于 Spring 的条件化配置机制实现的，通过在配置类中增加 @Conditional 注解来判断是否须要主动配置。在 MyBatis-Spring 中的实现，也是通过这种机制来判断是否须要启用主动配置。

五. Spring Boot 自定义配置与主动配置共存
在 Spring Boot 中，咱们通常能够应用主动配置（Auto-Configuration）来疾速地配置应用程序。然而，在某些状况下，咱们须要对 Spring Boot 的默认配置进行自定义，这就须要应用自定义配置（Custom Configuration）。自定义配置和主动配置是能够共存的，本篇答复将通过一个 代码示例来详细分析如何实现这一点。

首先，咱们须要在 Spring Boot 应用程序中定义一个自定义配置类。在这个类中，咱们能够笼罩 Spring Boot 默认的配置，并指定一些自定义配置。例如，咱们能够定义一个名为 MyConfig 的自定义配置类，如下所示：

@Configuration
public class MyConfig {

@Bean
public MyService myService() {return new MyServiceImpl();
}

}

在下面的代码中，咱们定义了一个名为 myService() 的 Bean，返回一个 MyServiceImpl 实例。

接下来，咱们须要创立一个主动配置类，以便让 Spring Boot 可能主动配置咱们的应用程序。咱们能够应用 @Configuration 和 @ConditionalOnMissingBean 注解来定义一个主动配置类，如下所示：

@Configuration
@ConditionalOnMissingBean(MyService.class)
public class MyAutoConfiguration {

@Bean
public MyService myService() {return new MyServiceImpl();
}

}

在下面的代码中，咱们应用 @ConditionalOnMissingBean 注解来判断是否须要主动配置 Bean。如果 MyService 这个 Bean 曾经被定义了，那么这个主动配置类就不会失效。如果 MyService 这个 Bean 没有被定义，那么 Spring Boot 就会主动配置这个 Bean。最初，咱们须要在 Spring Boot 应用程序的启动类中引入主动配置类和自定义配置类。能够应用 @Import 注解来引入这两个类，如下所示：

@SpringBootApplication
@Import({MyAutoConfiguration.class, MyConfig.class})
public class MyApplication {

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

}

在下面的代码中，咱们应用 @Import 注解来引入主动配置类和自定义配置类。这样，咱们就能够实现自定义配置和主动配置的共存。

总结一下，咱们须要实现以下几个步骤来实现自定义配置和主动配置的共存：

●创立一个自定义配置类，笼罩 Spring Boot 默认的配置，并指定一些自定义配置。

●创立一个主动配置类，以便让 Spring Boot 可能主动配置咱们的应用程序。应用 >@ConditionalOnMissingBean 注解来判断是否须要主动配置 Bean。

●在 Spring Boot 应用程序的启动类中引入主动配置类和自定义配置类，应用 @Import 注解来引入这两个类。

六. 总结
明天次要跟大家介绍 Spring Boot 自定义配置的过程及原理、Spring Boot 主动配置的过程及原理、以及自定义配置和主动配置共存，这一是一道十分广泛的场景面试题，最初再做下总结，加深印象

Spring Boot 是一种疾速开发应用程序的框架，它通过主动配置（Auto-configuration）缩小了利用程序开发的工作量。主动配置是 Spring Boot 的一个重要个性，它会依据应用程序的类门路、jar 包和其余条件来主动配置应用程序的组件和性能。但有时候，咱们须要对主动配置进行一些自定义，以满足应用程序的需要。

在这种状况下，Spring Boot 提供了自定义配置（Custom Configuration）的性能。自定义配置容许咱们批改或笼罩主动配置，并提供本人的配置来满足应用程序的需要。自定义配置和主动配置共存的长处包含：

●自定义配置和主动配置共存能够让开发者依据理论须要灵便地抉择应用主动配置或者自定义配置。当主动配置不满足需要时，能够通过自定义配置来扩大或者批改 Spring Boot 应用程序的行为。

●自定义配置能够进步代码的可读性和可维护性。当须要批改应用程序的行为时，能够通过批改自定义配置文件来实现，而不须要批改底层代码。这样能够缩小代码保护的难度，进步代码的可维护性。

●自定义配置和主动配置共存能够进步应用程序的可扩展性。自定义配置能够通过自定义配置类、属性文件、XML 文件等模式实现，能够满足各种应用程序的需要。同时，主动配置也能够被继承和扩大，开发者能够在主动配置的根底上进行二次开发，以满足应用程序的需要。

综上所述，自定义配置和主动配置共存能够进步应用程序的灵活性、可维护性和可扩展性，是 Spring Boot 框架的重要个性之一哦，当初大家都记住了吗？