從Spring3.0，@Configuration用於定義配置類，可替換xml配置文件，被註解的類內部包含有一個或多個被@Bean註解的方法，這些方法將會被AnnotationConfigApplicationContext或AnnotationConfigWebApplicationContext類進行掃描，並用於構建bean定義，初始化Spring容器。@Configuration的第二個作用是可以作爲配置類，和@Component的作用一樣，兩者的差別是@Configuration 中所有帶 @Bean 註解的方法都會被動態代理，因此調用該方法返回的都是同一個實例。
注意：@Configuration註解的配置類有如下要求：
- @Configuration不可以是final類型；
- @Configuration不可以是匿名類；
- 嵌套的configuration必須是靜態類。
本文的目錄如下（也可看左側的目錄列表）：
一、用@Configuration加載spring
1.1、@Configuration配置spring並啓動spring容器
1.2、@Configuration啓動容器+@Bean註冊Bean
1.3、@Configuration啓動容器+@Component註冊Bean
1.4、使用 AnnotationConfigApplicationContext 註冊 AppContext 類的兩種方法
1.5、配置Web應用程序(web.xml中配置AnnotationConfigApplicationContext)
二、組合多個配置類
2.1、在@configuration中引入spring的xml配置文件
2.2、在@configuration中引入其它註解配置
2.3、@configuration嵌套（嵌套的Configuration必須是靜態類）
三、@Component和@Configuration作爲配置類的差別
一、@Configuation加載Spring方法
1.1、@Configuration配置spring並啓動spring容器
@Configuration標註在類上，相當於把該類作爲spring的xml配置文件中的<beans>，作用爲：配置spring容器(應用上下文)
|
package com.dxz.demo.configuration;
import org.springframework.context.annotation.Configuration;
@Configuration
public class TestConfiguration {
public TestConfiguration() {
System.out.println("TestConfiguration容器啓動初始化。。。");
}
}
|
相當於：
主方法進行測試：
|
package com.dxz.demo.configuration;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class TestMain {
public static void main(String[] args) {
// @Configuration註解的spring容器加載方式，用AnnotationConfigApplicationContext替換ClassPathXmlApplicationContext
ApplicationContext context = new AnnotationConfigApplicationContext(TestConfiguration.class);
// 如果加載spring-context.xml文件：
// ApplicationContext context = new
// ClassPathXmlApplicationContext("spring-context.xml");
}
}
|
從運行主方法結果可以看出，spring容器已經啓動了：
![]()
1.2、@Configuration啓動容器+@Bean註冊Bean，@Bean下管理bean的生命週期
@Bean標註在方法上(返回某個實例的方法)，等價於spring的xml配置文件中的<bean>，作用爲：註冊bean對象
bean類：
|
package com.dxz.demo.configuration;
public class TestBean {
private String username;
private String url;
private String password;
public void sayHello() {
System.out.println("TestBean sayHello...");
}
public String toString() {
return "username:" + this.username + ",url:" + this.url + ",password:" + this.password;
}
public void start() {
System.out.println("TestBean 初始化。。。");
}
public void cleanUp() {
System.out.println("TestBean 銷燬。。。");
}
}
|
配置類：
|
package com.dxz.demo.configuration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;
@Configuration
public class TestConfiguration {
public TestConfiguration() {
System.out.println("TestConfiguration容器啓動初始化。。。");
}
// @Bean註解註冊bean,同時可以指定初始化和銷燬方法
// @Bean(name="testBean",initMethod="start",destroyMethod="cleanUp")
@Bean
@Scope("prototype")
public TestBean testBean() {
return new TestBean();
}
}
|
主方法測試類：
|
package com.dxz.demo.configuration;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class TestMain {
public static void main(String[] args) {
// @Configuration註解的spring容器加載方式，用AnnotationConfigApplicationContext替換ClassPathXmlApplicationContext
ApplicationContext context = new AnnotationConfigApplicationContext(TestConfiguration.class);
// 如果加載spring-context.xml文件：
// ApplicationContext context = new
// ClassPathXmlApplicationContext("spring-context.xml");
//獲取bean
TestBean tb = (TestBean) context.getBean("testBean");
tb.sayHello();
}
}
|
結果：
![]()
注：
(1)、@Bean註解在返回實例的方法上，如果未通過@Bean指定bean的名稱，則默認與標註的方法名相同；
(2)、@Bean註解默認作用域爲單例singleton作用域，可通過@Scope(“prototype”)設置爲原型作用域；
(3)、既然@Bean的作用是註冊bean對象，那麼完全可以使用@Component、@Controller、@Service、@Ripository等註解註冊bean，當然需要配置@ComponentScan註解進行自動掃描。
@Bean下管理bean的生命週期
可以使用基於 Java 的配置來管理 bean 的生命週期。@Bean 支持兩種屬性，即 initMethod 和destroyMethod，這些屬性可用於定義生命週期方法。在實例化 bean 或即將銷燬它時，容器便可調用生命週期方法。生命週期方法也稱爲回調方法，因爲它將由容器調用。使用 @Bean 註釋註冊的 bean 也支持 JSR-250 規定的標準 @PostConstruct 和 @PreDestroy 註釋。如果您正在使用 XML 方法來定義 bean，那麼就應該使用 bean 元素來定義生命週期回調方法。以下代碼顯示了在 XML 配置中通常使用 bean 元素定義回調的方法。
|
@Configuration
@ComponentScan(basePackages = "com.dxz.demo.configuration")
public class TestConfiguration {
public TestConfiguration() {
System.out.println("TestConfiguration容器啓動初始化。。。");
}
//@Bean註解註冊bean,同時可以指定初始化和銷燬方法
@Bean(name="testBean",initMethod="start",destroyMethod="cleanUp")
@Scope("prototype")
public TestBean testBean() {
return new TestBean();
}
}
|
啓動類：
|
public class TestMain {
public static void main(String[] args) {
ApplicationContext context = new AnnotationConfigApplicationContext(TestConfiguration.class);
TestBean tb = (TestBean) context.getBean("testBean");
tb.sayHello();
System.out.println(tb);
TestBean tb2 = (TestBean) context.getBean("testBean");
tb2.sayHello();
System.out.println(tb2);
}
}
|
結果：
![]()
分析：
結果中的1：表明initMethod生效
結果中的2：表明@Scope("prototype")生效
1.3、@Configuration啓動容器+@Component註冊Bean
bean類：
|
package com.dxz.demo.configuration;
import org.springframework.stereotype.Component;
//添加註冊bean的註解
@Component
public class TestBean {
private String username;
private String url;
private String password;
public void sayHello() {
System.out.println("TestBean sayHello...");
}
public String toString() {
return "username:" + this.username + ",url:" + this.url + ",password:" + this.password;
}
public void start() {
System.out.println("TestBean 初始化。。。");
}
public void cleanUp() {
System.out.println("TestBean 銷燬。。。");
}
}
|
配置類：
|
package com.dxz.demo.configuration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;
@Configuration
//添加自動掃描註解，basePackages爲TestBean包路徑
@ComponentScan(basePackages = "com.dxz.demo.configuration")
public class TestConfiguration {
public TestConfiguration() {
System.out.println("TestConfiguration容器啓動初始化。。。");
}
/*// @Bean註解註冊bean,同時可以指定初始化和銷燬方法
// @Bean(name="testNean",initMethod="start",destroyMethod="cleanUp")
@Bean
@Scope("prototype")
public TestBean testBean() {
return new TestBean();
}*/
}
|
主方法測試獲取bean對象：
|
package com.dxz.demo.configuration;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class TestMain {
public static void main(String[] args) {
// @Configuration註解的spring容器加載方式，用AnnotationConfigApplicationContext替換ClassPathXmlApplicationContext
ApplicationContext context = new AnnotationConfigApplicationContext(TestConfiguration.class);
// 如果加載spring-context.xml文件：
// ApplicationContext context = new
// ClassPathXmlApplicationContext("spring-context.xml");
//獲取bean
TestBean tb = (TestBean) context.getBean("testBean");
tb.sayHello();
}
}
|
sayHello()方法都被正常調用。
![]()
1.4、使用 AnnotationConfigApplicationContext 註冊 AppContext 類的兩種方法
1.4.1、 配置類的註冊方式是將其傳遞給 AnnotationConfigApplicationContext 構造函數
|
public static void main(String[] args) {
// @Configuration註解的spring容器加載方式，用AnnotationConfigApplicationContext替換ClassPathXmlApplicationContext
ApplicationContext context = new AnnotationConfigApplicationContext(TestConfiguration.class);
//獲取bean
TestBean tb = (TestBean) context.getBean("testBean");
tb.sayHello();
}
|
1.4.2、 AnnotationConfigApplicationContext 的register 方法傳入配置類來註冊配置類
|
public static void main(String[] args) {
ApplicationContext ctx = new AnnotationConfigApplicationContext();
ctx.register(AppContext.class)
}
|
1.5、配置Web應用程序(web.xml中配置AnnotationConfigApplicationContext)
過去，您通常要利用 XmlWebApplicationContext 上下文來配置 Spring Web 應用程序，即在 Web 部署描述符文件 web.xml 中指定外部 XML 上下文文件的路徑。XMLWebApplicationContext 是 Web 應用程序使用的默認上下文類。以下代碼描述了 web.xml 中指向將由 ContextLoaderListener 監聽器類載入的外部 XML 上下文文件的元素。
|
<web-app>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/applicationContext.xml</param-value>
</context-param>
<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>
<servlet>
<servlet-name>sampleServlet</servlet-name>
<servlet-class>
org.springframework.web.servlet.DispatcherServlet
</servlet-class>
</servlet>
...
</web-app>
|
現在，您要將 web.xml 中的上述代碼更改爲使用 AnnotationConfigApplicationContext 類。切記，XmlWebApplicationContext 是 Spring 爲 Web 應用程序使用的默認上下文實現，因此您永遠不必在您的web.xml 文件中顯式指定這個上下文類。現在，您將使用基於 Java 的配置，因此在配置 Web 應用程序時，需要在web.xml 文件中指定 AnnotationConfigApplicationContext 類。上述代碼將修改如下：
|
<web-app>
<context-param>
<param-name>contextClass</param-name>
<param-value>
org.springframework.web.context.
support.AnnotationConfigWebApplicationContext
</param-value>
</context-param>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>
demo.AppContext
</param-value>
</context-param>
<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>
<servlet>
<servlet-name>sampleServlet</servlet-name>
<servlet-class>
org.springframework.web.servlet.DispatcherServlet
</servlet-class>
<init-param>
<param-name>contextClass</param-name>
<param-value>
org.springframework.web.context.
support.AnnotationConfigWebApplicationContext
</param-value>
</init-param>
</servlet>
...
</web-app>
|
以上修改後的 web.xml 現在定義了 AnnotationConfigWebApplicationContext 上下文類，並將其作爲上下文參數和 servlet 元素的一部分。上下文配置位置現在指向 AppContext 配置類。這非常簡單。下一節將演示 bean 的生命週期回調和範圍的實現。
1.6、@Configuation總結
@Configuation等價於<Beans></Beans>
@Bean等價於<Bean></Bean>
@ComponentScan等價於<context:component-scan base-package="com.dxz.demo"/>
二、組合多個配置類
2.1、在@configuration中引入spring的xml配置文件
|
package com.dxz.demo.configuration2;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.ImportResource;
@Configuration
@ImportResource("classpath:applicationContext-configuration.xml")
public class WebConfig {
}
|
bean類：
|
package com.dxz.demo.configuration2;
public class TestBean2 {
private String username;
private String url;
private String password;
public void sayHello() {
System.out.println("TestBean2 sayHello...");
}
public String toString() {
return "TestBean2 username:" + this.username + ",url:" + this.url + ",password:" + this.password;
}
public void start() {
System.out.println("TestBean2 初始化。。。");
}
public void cleanUp() {
System.out.println("TestBean2 銷燬。。。");
}
}
|
測試類：
|
package com.dxz.demo.configuration2;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class TestMain2 {
public static void main(String[] args) {
// @Configuration註解的spring容器加載方式，用AnnotationConfigApplicationContext替換ClassPathXmlApplicationContext
ApplicationContext context = new AnnotationConfigApplicationContext(WebConfig.class);
// 如果加載spring-context.xml文件：
// ApplicationContext context = new
// ClassPathXmlApplicationContext("spring-context.xml");
// 獲取bean
TestBean2 tb = (TestBean2) context.getBean("testBean2");
tb.sayHello();
}
}
|
結果：
![]()
2.2、在@configuration中引入其它註解配置
|
package com.dxz.demo.configuration2;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.context.annotation.ImportResource;
import com.dxz.demo.configuration.TestConfiguration;
@Configuration
@ImportResource("classpath:applicationContext-configuration.xml")
@Import(TestConfiguration.class)
public class WebConfig {
}
|
測試類：
|
package com.dxz.demo.configuration2;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import com.dxz.demo.configuration.TestBean;
public class TestMain2 {
public static void main(String[] args) {
// @Configuration註解的spring容器加載方式，用AnnotationConfigApplicationContext替換ClassPathXmlApplicationContext
ApplicationContext context = new AnnotationConfigApplicationContext(WebConfig.class);
// 如果加載spring-context.xml文件：
// ApplicationContext context = new
// ClassPathXmlApplicationContext("spring-context.xml");
// 獲取bean
TestBean2 tb2 = (TestBean2) context.getBean("testBean2");
tb2.sayHello();
TestBean tb = (TestBean) context.getBean("testBean");
tb.sayHello();
}
}
|
結果：
![]()
2.3、@configuration嵌套（嵌套的Configuration必須是靜態類）
通過配置類嵌套的配置類，達到組合多個配置類的目的。但注意內部類必須是靜態類。
上代碼：
|
package com.dxz.demo.configuration3;
import org.springframework.stereotype.Component;
@Component
public class TestBean {
private String username;
private String url;
private String password;
public void sayHello() {
System.out.println("TestBean sayHello...");
}
public String toString() {
return "username:" + this.username + ",url:" + this.url + ",password:" + this.password;
}
public void start() {
System.out.println("TestBean start");
}
public void cleanUp() {
System.out.println("TestBean destory");
}
}
|
|
package com.dxz.demo.configuration3;
public class DataSource {
private String dbUser;
private String dbPass;
public String getDbUser() {
return dbUser;
}
public void setDbUser(String dbUser) {
this.dbUser = dbUser;
}
public String getDbPass() {
return dbPass;
}
public void setDbPass(String dbPass) {
this.dbPass = dbPass;
}
@Override
public String toString() {
return "DataSource [dbUser=" + dbUser + ", dbPass=" + dbPass + "]";
}
}
|
配置類：
|
package com.dxz.demo.configuration3;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
@Configuration
@ComponentScan(basePackages = "com.dxz.demo.configuration3")
public class TestConfiguration {
public TestConfiguration() {
System.out.println("TestConfiguration容器啓動初始化。。。");
}
@Configuration
static class DatabaseConfig {
@Bean
DataSource dataSource() {
return new DataSource();
}
}
}
|
啓動類：
|
package com.dxz.demo.configuration3;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class TestMain {
public static void main(String[] args) {
// @Configuration註解的spring容器加載方式，用AnnotationConfigApplicationContext替換ClassPathXmlApplicationContexts
ApplicationContext context = new AnnotationConfigApplicationContext(TestConfiguration.class);
//bean
TestBean tb = (TestBean) context.getBean("testBean");
tb.sayHello();
DataSource ds = (DataSource) context.getBean("dataSource");
System.out.println(ds);
}
}
|
結果：
TestConfiguration容器啓動初始化。。。
TestBean sayHello...
DataSource [dbUser=null, dbPass=null]
三、Spring @Configuration 和 @Component 區別
@Configuration的第二個作用是可以作爲配置類，和@Component的作用一樣，兩者的差別是@Configuration 中所有帶 @Bean 註解的方法都會被動態代理，因此調用該方法返回的都是同一個實例。
|
@Configuration
public class MyTestConfig {
@Bean
public Driver driver(){
Driver driver = new Driver();
driver.setId(1);
driver.setName("driver");
driver.setCar(car());
return driver;
}
@Bean
public Car car(){
Car car = new Car();
car.setId(1);
car.setName("car");
return car;
}
}
測試代碼如下
@RunWith(SpringRunner.class)
@SpringBootTest
public class TestApplicationTests {
@Autowired
private Car car;
@Autowired
private Driver driver;
@Test
public void contextLoads() {
boolean result = driver.getCar() == car;
System.out.println(result ? "同一個car" : "不同的car");
}
}
|
輸出
同一個car
替換爲Component後的打印結果：
不同的car
從上面的結果可以發現使用Configuration時在driver和spring容器之中的是同一個對象，而使用Component時是不同的對象。
造成不同結果的原因在ConfigurationClassPostProcessor類之中，通過調用enhanceConfigurationClasses方法，爲被註解@Configuration的類進行CGLIB代理。
