2. 程式人生 > >何為Spring中的配置類？

何為Spring中的配置類？

阿新 • • 發佈：2019-06-06

現在大部分的專案都採用了基於註解的配置，採用了@Configuration 替換 標籤的做法。但是最近在翻看Spring 官方文件時，發現@Configuration 宣告為基礎標籤之外，還和大量的其他註解產生化學反應。

@Configuration 基本說明

​ 定義：指示一個類宣告一個或者多個@Bean 宣告的方法並且由Spring容器統一管理，以便在執行時為這些bean生成bean的定義和服務請求的類。例如：

@Configuration
public class AppConfig {
  
  @Bean
  public MyBean myBean(){
    return new MyBean();
  }
}

上述AppConfig 加入@Configuration 註解，表明這就是一個配置類。有一個myBean()的方法，返回一個MyBean()的例項，並用@Bean 進行註釋，表明這個方法是需要被Spring進行管理的bean。@Bean 如果不指定名稱的話，預設使用myBean名稱，也就是小寫的名稱。

通過註解啟動：

通過啟動一個AnnotationConfigApplicationContext 來引導這個@Configuration 註解的類，比如：

AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
ctx.register(AppConfig.class);
ctx.refresh();

在web專案中，也可以使用AnnotationContextWebApplicationContext或者其他變體來啟動。

新建一個SpringBoot專案(別問我為什麼，因為這樣建立專案比較快)。

  • pom.xml 檔案如下：
<?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>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.5.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.spring.configuration</groupId>
    <artifactId>spring-configuration</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>spring-configuration</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.6.RELEASE</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>
  • 在config 包下新建一個MyConfiguration環境配置，和上面的示例程式碼相似，完整的程式碼如下：
@Configuration
public class MyConfiguration {

    @Bean
    public MyBean myBean(){
        System.out.println("myBean Initialized");
        return new MyBean();
    }
}

說明MyConfiguration 是一個配置類，能夠在此類下面宣告管理多個Bean，我們聲明瞭一個MyBean的bean，希望它被容器載入和管理。

  • 在pojo包下新建一個MyBean的類，具體程式碼如下
public class MyBean {

    public MyBean(){
        System.out.println("generate MyBean Instance");
    }

    public void init(){
        System.out.println("MyBean Resources Initialized");
    }
}
  • 新建一個SpringConfigurationApplication類，用來測試MyConfiguration類，具體程式碼如下：
public class SpringConfigurationApplication {

    public static void main(String[] args) {
        
//        AnnotationConfigApplicationContext context = = new AnnotationConfigApplicationContext(MyConfiguration.class)
        // 因為我們載入的@Configuration 是基於註解形式的，所以需要建立AnnotationConfigApplicationContext
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        // 註冊MyConfiguration 類並重新整理bean 容器。
        context.register(MyConfiguration.class);
        context.refresh();

    }

}

輸出：

myBean Initialized
generate MyBean Instance

從輸出的結果可以看到，預設名稱為myBean 的bean隨著容器的載入而載入，因為myBean方法返回一個myBean的構造方法，所以myBean被初始化了。

通過XML 的方式來啟動

  • 可以通過使用XML方式定義的<context:annotation-config />開啟基於註解的啟動，然後再定義一個MyConfiguration的bean，在/resources 目錄下新建 application-context.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:context="http://www.springframework.org/schema/context"
       xmlns:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="
      http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
      http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.2.xsd
      http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd"
>

    <!-- 相當於基於註解的啟動類 AnnotationConfigApplicationContext-->
    <context:annotation-config />

    <bean class="com.spring.configuration.config.MyConfiguration"/>

</beans>
  • 需要引入applicationContext.xml ，在SpringConfigurationApplication 需要進行引入，修改後的SpringConfigurationApplication如下：
public class SpringConfigurationApplication {

    public static void main(String[] args) {

        ApplicationContext context = 
          new ClassPathXmlApplicationContext("applicationContext.xml");
    }
}

輸出：

myBean Initialized
generate MyBean Instance

基於ComponentScan() 來獲取Bean的定義

@Configuration 使用@Component 進行原註解，因此@Configuration 類也可以被元件掃描到（特別是使用XML 元素）。

在這裡認識幾個註解: @Controller, @Service, @Repository, @Component

  • @Controller: 表明一個註解的類是一個"Controller"，也就是控制器，可以把它理解為MVC 模式的Controller 這個角色。這個註解是一個特殊的@Component，允許實現類通過類路徑的掃描掃描到。它通常與@RequestMapping 註解一起使用。
  • @Service: 表明這個帶註解的類是一個"Service"，也就是服務層，可以把它理解為MVC 模式中的Service層這個角色，這個註解也是一個特殊的@Component，允許實現類通過類路徑的掃描掃描到
  • @Repository: 表明這個註解的類是一個"Repository",團隊實現了JavaEE 模式中像是作為"Data Access Object" 可能作為DAO來使用，當與 PersistenceExceptionTranslationPostProcessor 結合使用時，這樣註釋的類有資格獲得Spring轉換的目的。這個註解也是@Component 的一個特殊實現，允許實現類能夠被自動掃描到
  • @Component: 表明這個註釋的類是一個元件，當使用基於註釋的配置和類路徑掃描時，這些類被視為自動檢測的候選者。

也就是說，上面四個註解標記的類都能夠通過@ComponentScan 掃描到，上面四個註解最大的區別就是使用的場景和語義不一樣，比如你定義一個Service類想要被Spring進行管理，你應該把它定義為@Service 而不是@Controller因為我們從語義上講，@Service更像是一個服務的類，而不是一個控制器的類，@Component通常被稱作元件，它可以標註任何你沒有嚴格予以說明的類，比如說是一個配置類，它不屬於MVC模式的任何一層，這個時候你更習慣於把它定義為 @Component。@Controller，@Service，@Repository 的註解上都有@Component，所以這三個註解都可以用@Component進行替換。

來看一下程式碼進行理解：

  • 定義五個類，類上分別用@Controller, @Service, @Repository, @Component, @Configuration 進行標註，分別如下
@Component
public class UserBean {}

@Configuration
public class UserConfiguration {}

@Controller
public class UserController {}

@Repository
public class UserDao {}

@Service
public class UserService {}
  • 在MyConfiguration上加上@ComponentScan 註解，掃描上面5個類所在的包位置。程式碼如下：
@Configuration
@ComponentScan(basePackages = "com.spring.configuration.pojo")
public class MyConfiguration {

    @Bean
    public MyBean myBean(){
        System.out.println("myBean Initialized");
        return new MyBean();
    }
}
  • 修改 SpringConfigurationApplication 中的程式碼，如下：
public class SpringConfigurationApplication {

    public static void main(String[] args) {

//        AnnotationConfigApplicationContext context = = new AnnotationConfigApplicationContext(MyConfiguration.class)
//        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        context.register(MyConfiguration.class);
        context.refresh();

        // 獲取啟動過程中的bean 定義的名稱
        for(String str : context.getBeanDefinitionNames()){
            System.out.println("str = " + str);
        }
        context.close();

    }
}

輸出：

myBean Initialized
generate MyBean Instance
str = org.springframework.context.annotation.internalConfigurationAnnotationProcessor
str = org.springframework.context.annotation.internalAutowiredAnnotationProcessor
str = org.springframework.context.annotation.internalRequiredAnnotationProcessor
str = org.springframework.context.annotation.internalCommonAnnotationProcessor
str = org.springframework.context.event.internalEventListenerProcessor
str = org.springframework.context.event.internalEventListenerFactory
str = myConfiguration
str = userBean
str = userConfiguration
str = userController
str = userDao
str = userService
str = myBean

由輸出可以清楚的看到，上述定義的五個類成功被@ComponentScan 掃描到，並在程式啟動的時候進行載入。

@Configuration 和 Environment

​ @Configuration 通常和Environment 一起使用，通過@Environment 解析的屬性駐留在一個或多個"屬性源"物件中，@Configuration類可以使用@PropertySource，像Environment 物件提供屬性源

  • 為了便於測試，我們引入junit4和spring-test 的依賴，完整的配置檔案如下
<?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>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.5.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.spring.configuration</groupId>
    <artifactId>spring-configuration</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>spring-configuration</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
        <spring.version>5.0.6.RELEASE</spring.version>
        <spring.test.version>4.3.13.RELEASE</spring.test.version>
        <junit.version>4.12</junit.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.test.version}</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>${junit.version}</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>
  • 在config 包下定義一個 EnvironmentConfig 類，注入Environment 屬性，完整程式碼如下：
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = EnvironmentConfig.class)
@Configuration
@PropertySource("classpath:beanName.properties")
public class EnvironmentConfig {

    @Autowired
    Environment env;

    @Test
    public void testReadProperty(){
        // 獲取bean.name.controller 的屬性
        System.out.println(env.getProperty("bean.name.controller"));
        // 判斷是否包含bean.name.component
        System.out.println(env.containsProperty("bean.name.component"));
        // 返回與給定鍵關聯的屬性值
        System.out.println(env.getRequiredProperty("bean.name.service"));
    }
}
  • 在/resources 目錄下新建beanName.properties 檔案，如下：
bean.name.configuration=beanNameConfiguration
bean.name.controller=beanNameController
bean.name.service=beanNameService
bean.name.component=beanNameComponent
bean.name.repository=beanNameRepository

啟動並進行Junit測試，輸出如下：

…..…...

beanNameController

true

beanNameService

…..…...

@Autowired 、 @Inject、@Resource 的區別

@Inject: 這是jsr330 的規範，通過AutowiredAnnotationBeanPostProcessor 類實現的依賴注入。位於javax.inject包內，是Java自帶的註解。

@Inject
@Named("environment")
Environment env;

不加@Named註解，需要配置與變數名一致即可。

@Autowired: @Autowired 是Spring提供的註解，通過AutowiredAnnotationBeanPostProessor 類實現注入。位於org.springframework.beans.factory.annotation 包內，是Spring 中的註解

@Autowired
Environment env;

預設是通過byType 實現注入

@Resource: @Resource 是jsr250規範的實現，@Resource通過CommonAnnotationBeanPostProcessor 類實現注入。@Resource 一般會指定一個name屬性，如下：

@Resource(name = "environment")
Environment env;

預設是通過byName 實現注入

區別：

@Autowired和@Inject基本是一樣的，因為兩者都是使用AutowiredAnnotationBeanPostProcessor來處理依賴注入。但是@Resource是個例外，它使用的是CommonAnnotationBeanPostProcessor來處理依賴注入。當然，兩者都是BeanPostProcessor。

在介紹完上述三者的區別之後，可以對Environment的屬性以上述注入方式進行改造

@Value、@PropertySource 和 @Configuration

@Configuration 可以和@Value 和@PropertySource 一起使用讀取外部配置檔案，具體用法如下：

  • 在config 包下新建一個ReadValueFromPropertySource類，程式碼如下
@PropertySource("classpath:beanName.properties")
@Configuration
public class ReadValueFromPropertySource {

    @Value("bean.name.component")
    String beanName;

    @Bean("myTestBean")
    public MyBean myBean(){
        return new MyBean(beanName);
    }

}

通過@PropertySource引入的配置檔案，使@Value 能夠獲取到屬性值，在給myBean()方法指定了一個名稱叫做myTestBean。

  • 修改MyBean類，增加一個name屬性和一個構造器，再生成其toString() 方法
public class MyBean {

    String name;

    public MyBean(String name) {
        this.name = name;
    }

    public MyBean(){
        System.out.println("generate MyBean Instance");
    }

    public void init(){
        System.out.println("MyBean Resources Initialized");
    }

    @Override
    public String toString() {
        return "MyBean{" +
                "name='" + name + '\'' +
                '}';
    }
}
  • 在SpringConfigurationApplication中進行測試，如下
public class SpringConfigurationApplication {

    public static void main(String[] args) {

      // 為了展示配置檔案的完整性，之前的程式碼沒有刪除。
//        AnnotationConfigApplicationContext context = = new AnnotationConfigApplicationContext(MyConfiguration.class)
//        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

//        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
//        context.register(MyConfiguration.class);
//        context.refresh();
//
//        // 獲取啟動過程中的bean 定義的名稱
//        for(String str : context.getBeanDefinitionNames()){
//            System.out.println("str = " + str);
//        }
//        context.close();

        ApplicationContext context =
                new AnnotationConfigApplicationContext(ReadValueFromPropertySource.class);
        MyBean myBean = (MyBean) context.getBean("myTestBean");
        System.out.println("myBean = " + myBean);

    }
}

使用Applicatio@InConntext 就能夠獲取myTestBean 這個bean，再生成myBean的例項。

輸出：myBean = MyBean{name='bean.name.component'}

@Import 和 @Configuration

@Import的定義(來自於JavaDoc)：表明一個或者多個配置類需要匯入，提供與Spring XML中相等的功能，允許匯入@Configuration 、@ImportSelector、@ImportBeanDefinitionRegistar的實現，以及常規元件類似於AnnotationConfigApplicationContext。可能用於類級別或者是原註解。如果XML或者其他非@Configuration標記的Bean資源需要被匯入的話，使用@ImportResource。下面是一個示例程式碼：

  • 在pojo 包下新建兩個配置類，分別是CustomerBo, SchedualBo
@Configuration
public class CustomerBo {

    public void printMsg(String msg){
        System.out.println("CustomerBo : " + msg);
    }

    @Bean
    public CustomerBo testCustomerBo(){
        return new CustomerBo();
    }
}

@Configuration
public class SchedulerBo {

    public void printMsg(String msg){
        System.out.println("SchedulerBo : " + msg);
    }

    @Bean
    public SchedulerBo testSchedulerBo(){
        return new SchedulerBo();
    }
}
  • 在config 包下新建一個AppConfig，匯入CustomerBo 和 SchedulerBo 。
@Configuration
@Import(value = {CustomerBo.class,SchedulerBo.class})
public class AppConfig {}
  • 在config 包下新建一個ImportWithConfiguration ，用於測試@Import 和 @Configuration 的使用
public class ImportWithConfiguration {

    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        CustomerBo customerBo = (CustomerBo) context.getBean("testCustomerBo");
        customerBo.printMsg("System out println('get from customerBo')");

        SchedulerBo schedulerBo = (SchedulerBo) context.getBean("testSchedulerBo");
        schedulerBo.printMsg("System out println('get from schedulerBo')");
    }
}

輸出：

CustomerBo : System out println('get from customerBo')
SchedulerBo : System out println('get from schedulerBo')

@Profile

@Profile: 表示當一個或多個@Value 指定的配置檔案處於可用狀態時，元件符合註冊條件，可以進行註冊。

三種設定方式：

  • 可以通過ConfigurableEnvironment.setActiveProfiles()以程式設計的方式啟用

  • 可以通過AbstractEnvironment.ACTIVE_PROFILES_PROPERTY_NAME (spring.profiles.active )屬性設定為

    JVM屬性

  • 作為環境變數，或作為web.xml 應用程式的Servlet 上下文引數。也可以通過@ActiveProfiles 註解在整合測試中以宣告方式啟用配置檔案。

作用域

  • 作為類級別的註釋在任意類或者直接與@Component 進行關聯，包括@Configuration 類
  • 作為原註解，可以自定義註解
  • 作為方法的註解作用在任何方法

注意:

​ 如果一個配置類使用了Profile 標籤或者@Profile 作用在任何類中都必須進行啟用才會生效，如果@Profile({"p1","!p2"}) 標識兩個屬性，那麼p1 是啟用狀態 而p2 是非啟用狀態的。

@ImportResource 和 @Configuration

@ImportResource: 這個註解提供了與@Import 功能相似作用，通常與@Configuration 一起使用，通過AnnotationConfigApplicationContext 進行啟動，下面以一個示例來看一下具體用法：

  • 在config下新建TestService 類，宣告一個建構函式，類初始化時呼叫
public class TestService {

    public TestService(){
        System.out.println("test @importResource success");
    }
}
  • 在/resources 目錄下新建 importResources.xml ，為了匯入TestService
<?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:context="http://www.springframework.org/schema/context"
       xmlns:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="
      http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
      http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.2.xsd
      http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd"
>

    <bean id = "testService" class="com.spring.configuration.config.TestService" />

</beans>
  • 然後在config 下新建一個ImportResourceWithConfiguration， 用於讀取配置檔案
@Configuration
@ImportResource("classpath:importResources.xml")
public class ImportResourceWithConfiguration {

    @Autowired
    private TestService service;

    public void getImportResource(){
        new TestService();
    }

    public static void main(String[] args) {
        AnnotationConfigApplicationContext context =
                new AnnotationConfigApplicationContext(ImportResourceWithConfiguration.class);
        context.getBean("testService");

    }
}

輸出：test @importResource success

@Configuration 巢狀

@Configuration註解作用在類上，就和普通類一樣能夠進行相互巢狀，定義內部類。

// 來自JavaDoc
@Configuration
public class AppConfig{
  
  @Inject
  DataSource dataSource;
  
  @Bean
  public MyBean myBean(){
    return new MyBean(dataSource);
  }
  
  @Configuration
  static class DataConfig(){
    @Bean
    DataSource dataSource(){
      return new EmbeddedDatabaseBuilder().build()
    }
  }
}

在上述程式碼中，只需要在應用程式的上下文中註冊 AppConfig 。由於是巢狀的@Configuration 類，DatabaseConfig 將自動註冊。當AppConfig 、DatabaseConfig 之間的關係已經隱含清楚時，這就避免了使用@Import 註解的需要。

@Lazy 延遲初始化

@Lazy : 表明一個bean 是否延遲載入，可以作用在方法上，表示這個方法被延遲載入；可以作用在@Component (或者由@Component 作為原註解) 註釋的類上，表明這個類中所有的bean 都被延遲載入。如果沒有@Lazy註釋，或者@Lazy 被設定為false，那麼該bean 就會急切渴望被載入；除了上面兩種作用域，@Lazy 還可以作用在@Autowired和@Inject註釋的屬性上，在這種情況下，它將為該欄位建立一個惰性代理，作為使用ObjectFactory或Provider的預設方法。下面來演示一下：

  • 修改MyConfiguration類，在該類上新增@Lazy 註解，新增一個IfLazyInit()方法，檢驗是否被初始化。
@Lazy
@Configuration
@ComponentScan(basePackages = "com.spring.configuration.pojo")
public class MyConfiguration {

    @Bean
    public MyBean myBean(){
        System.out.println("myBean Initialized");
        return new MyBean();
    }

    @Bean
    public MyBean IfLazyInit(){
        System.out.println("initialized");
        return new MyBean();
    }
}
  • 修改SpringConfigurationApplication 啟動類，放開之前MyConfiguration 的啟動類
public class SpringConfigurationApplication {

    public static void main(String[] args) {

        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfiguration.class);
//        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

//        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
//        context.register(MyConfiguration.class);
//        context.refresh();
//
//        // 獲取啟動過程中的bean 定義的名稱
        for(String str : context.getBeanDefinitionNames()){
            System.out.println("str = " + str);
        }
//        context.close();

//        ApplicationContext context =
//                new AnnotationConfigApplicationContext(ReadValueFromPropertySource.class);
//        MyBean myBean = (MyBean) context.getBean("myTestBean");
//        System.out.println("myBean = " + myBean);

    }
}

輸出你會發現沒有關於bean的定義資訊，但是當吧@Lazy 註釋拿掉，你會發現輸出了關於bean的初始化資訊：

myBean Initialized
generate MyBean Instance
initialized
generate MyBean Instance

@RunWith 和 @ContextConfiguration

Junit4 測試類，用於註解在類上表示通過Junit4 進行測試，可以省略編寫啟動類程式碼，是ApplicationContext 等啟動類的替換。一般用@RunWith 和 @Configuration 進行單元測試，這是軟體開發過程中非常必要而且具有專業性的一部分，上面EnvironmentConfig 類證實了這一點：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = EnvironmentConfig.class)
@Configuration
@PropertySource("classpath:beanName.properties")
public class EnvironmentConfig {

//    @Autowired
//    Environment env;

    @Inject
    Environment env;

    @Test
    public void testReadProperty(){
        // 獲取bean.name.controller 的屬性
        System.out.println(env.getProperty("bean.name.controller"));
        // 判斷是否包含bean.name.component
        System.out.println(env.containsProperty("bean.name.component"));
        // 返回與給定鍵關聯的屬性值
        System.out.println(env.getRequiredProperty("bean.name.service"));
    }
}

@Enable 啟動Spring內建功能

詳情查閱@EnableAsync,@EnableScheduling,@EnableTransactionManagement,@EnableAspectJAutoProxy,@EnableWebMvc官方文件

@Configuration 使用約束

  • 必須以類的方式提供(即不是從工廠方法返回的例項)
  • @Configuration 註解的類必須是非final的
  • 配置類必須是非本地的（即可能不在方法中宣告）,native 標註的方法
  • 任何巢狀的@Configuration 都必須是static 的。
  • @Bean 方法可能不會反過來建立更多配置類

文章來源：

https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/context/annotation/Configuration.html

https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/context/annotation/PropertySource.html

https://blog.csdn.net/u012734441/article/details/51706

相關推薦

何為Spring中的配置類？

現在大部分的專案都採用了基於註解的配置，採用了@Configuration 替換 標籤的做法。但是最近在翻看Spring 官方文件時，發現@Configuration 宣告為基礎標籤之外，還和大量的其他註解產生化學反應。 @Configuration 基本說明 ​ 定義：指示一個類宣告一個或者多個@Bean

Transaction之坑：Spring中配置Transaction與不配置有何區別

首先 Spring中 Transaction管理 配置有兩種方式： Annotation式：@Transactional Xml式：<tx:method /> Not

Spring中ClassPathXmlApplicationContext類的簡單使用

roo sys 盤符 protected 測試的 pac stat 相對路徑 ace 一、簡單的用ApplicationContext做測試的話,獲得Spring中定義的Bean實例(對象).可以用: ApplicationContext ac = new ClassPa

spring中配置監聽隊列的MQ

msl tin listen ann lazy ati app ssa clas 一、spring中配置監聽隊列的MQ相關信息註：${}是讀取propertites文件的常量，這裏忽略。綠色部分配置在接收和發送端都要配置。 <bean id="axx" class=

springboot在yml配置文件中配置類的屬性筆記

myba spring XML onf 簡單的 註解 pri one pid 首先建立一個簡單的實體類，我這裏以學生為例，並加上@Component和@ConfigurationProperties(prefix ="student")註解，其中prefix ="stude

Spring中配置檔案application xml中各配置的含義

分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！        

Spring中ClassPathXmlApplicationContext類的簡單使用和spring的簡單小案例

一、簡單的用ApplicationContext做測試的話,獲得Spring中定義的Bean例項(物件).可以用: ApplicationContext ac = new ClassPathXmlApplicationContext(“applicationContext.xml”);

如何解決spring中同一個類裡面方法之間呼叫的時候註解失效的問題

參考部落格：https://blog.csdn.net/z55887/article/details/81073450 @RestController public class Test { @Autowired ApplicationContext context;

Spring中配置Quartz的過程；Spring與Quartz的相容問題

1. 根據spring和Quratz的版本不同，觸發器的方法可能不同，有org.springframework.scheduling.quartz.SimpleTriggerFactoryBean和org.springframework.scheduling.quar

spring中配置profile

1、新建一個maven專案，匯入如下依賴 <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <sprin

Java中如何獲取Spring中配置的bean

Spring中的ApplicationContexts可以被限制在不同的作用域。在web框架中，每個DispatcherServlet有它自己的WebApplicationContext，它包含了DispatcherServlet配置所需要的bean。DispatcherServlet 使用的預設BeanF

Spring中配置和讀取多個Properties檔案--轉

    http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">       &

Spring中配置資料來源的幾種方式

無論使用什麼形式的Spring DAO支援類，都需要配置資料來源的引用。Spring提供了多個選項，用於在Spring程式裡配置資料庫，其中包括： 1，由JDBC驅動程式定義的資料來源。 2，由JNDI查詢的資料來源。 3，連線池的資料來源。 在Spring裡，我們可以像使用其他

Java中如何獲取spring中配置的properties屬性檔案內容

1、通過spring配置properties檔案 <bean id="propertyConfigurer"class="com.tjsoft.base.util.CustomizedPropertyPlaceholderConfigurer"><pro

Spring Boot配置類編寫

編寫Spring Boot配置類 解釋 多個配置類的編寫（一主多從） 啟動類為：Application 主配置類為：SpringConfiguration 從配置類為：SpringWebMvcConfigurer 1.啟動類匯入主配置類 @S

如何在spring中配置集合供多個Bean使用

一：Utility   Scheme 1.使用基本的集合標籤定義集合時，不能將集合作為獨立的Bean定義，導致其他Bean無法引用該集合，所以無法在不同Bean之間 共享集合。 2.可以使用Utility  Scheme裡的集合標籤定義獨立的集合Bean，需要的是在B

EhCache 介紹和在spring中配置

<?xml version="1.0" encoding="UTF-8"?> <ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="ehca

Spring中配置使用slf4j + log4j

https code control api 產生 eap ces jsp prop 本人也是查看別人博客獲得的方法，詳細講解請參照 https://www.cnblogs.com/yuxiaole/p/9297266.html 下面進入正題： 1.在pom.xml中註入相

Hibernate 事務處理和spring中配置事務

原文連結：http://blog.csdn.net/sd0902/article/details/8393700 1.非整合spring事務管理 事務是指由一個或者多個SQL語句組成的工作單元，這個單元中SQL語句只要有一個SQL語句執行失敗，就會撤銷整個工作單元

在Spring中配置aspectj模式

在事務，快取中，Spring通常提供了兩種模式：proxy和aspectj。 要成功的配置aspectj模式，前提是成功配置aspectj。 aspectJ有兩種植入方式：CTW（Compile Time Weaving）和LTW（Load Time Weaving），兩種