用来记录一些原创性的总结
除了传统的使用XML来配置底层的bean容器定义，Spring还支持使用大家熟悉的Java类的形式来进行配置。使用Java类的形式来进行配置时我们将使用一个Java类来作为配置的主体，并在类上使用@Configuration进行标注，表示其是一个配置类。然后将对应的bean定义都定义为Java配置类中的一个公用方法，并在方法上使用@Bean进行标注，表示其是一个bean定义。使用@Bean进行标注的方法对应的返回类型就是生成的bean定义对应的Class类型，对应的方法体实现就是我们用来产生对应bean定义的实例的过程，对应的方法名就是bean定义的默认beanName。下面我们先来简单的看一个对应的实现。
@Configuration
public class SpringConfig {
@Bean
public Hello hello() {
return new Hello();
}
}
在上面代码中我们就通过@Configuration标注了我们的类SpringConfig是一个Spring的配置类，然后在其中定义了一个使用@Bean进行标注的方法，Spring会将其作为一个bean定义添加到bean容器中，对应beanName为“hello”，然后直接new一个对应的实例作为bean定义的实例。之后我们就可以从该配置类产生的bean容器中获取对应的bean定义了，对应测试代码可以是如下这样。
@ContextConfiguration(classes={SpringConfig.class})
@RunWith(SpringJUnit4ClassRunner.class)
public class ConfigurationTest {
@Autowired
private ApplicationContext context;
@Test
public void test() {
System.out.println(context.getBean("hello", Hello.class));
}
}
在使用基于Java类进行配置时，我们可以使用@Bean来标注配置类中需要定义为bean容器中一个bean定义的方法。标注后，默认会以该方法的名称作为对应bean定义的beanName，以方法的返回类型作为对应bean定义的Class类型。
@Configuration
public class SpringConfig {
@Bean
public Hello hello() {
return new Hello();
}
}
如上示例，我们就在基于Java类的配置中使用@Bean注解定义了一个bean定义，其相当于我们在XML配置文件中的如下定义。
<bean id="hello" class="com.app.Hello"/>
默认情况Spring会以方法名称作为对应bean定义的beanName。如果用户希望指定对应bean定义的beanName，则可以通过@Bean的name属性进行指定。
@Bean(name="hello1")
public Hello hello() {
return new Hello();
}
我们也可以通过@Bean的name属性给bean定义指定多个名称，这个时候就可以将name属性以一个数组的形式进行指定。如下示例中我们就表示同时指定beanName为“hello”和“hello1”。
@Bean(name={"hello", "hello1"})
public Hello hello() {
return new Hello();
}
根据之前文章的介绍我们知道bean的生命周期回调方法可以通过三种方式进行指定，使用JSR-250标准的@PostConstruct和@PreDestroy进行标注、实现InitializationBean和DisposableBean接口和通过bean定义的init-method和destroy-method进行指定。对于前两种方式而言，使用@Bean进行配置的bean也可以像其它基于注解或基于XML配置的bean一样进行回调。对于第三种方式，我们就需要通过@Bean的initMethod和destroyMethod属性进行指定，对应属性值即表示对应的回调方法名称。
@Bean(initMethod="init", destroyMethod="destroy")
public Hello hello() {
return new Hello();
}
上述示例中我们就通过initMethod属性指定了bean hello的初始化回调方法为init()，通过destroyMethod属性指定了对应的销毁前回调方法为destroy()。其就相当于我们基于XML配置的如下形式。
<bean id="hello" class="com.app.Hello" init-method="init" destroy-method="destroy"/>
在使用XML进行配置的时候，我们可以通过其autowire指定是否需要进行自动注入。对应的我们可以在@Bean上使用autowire属性来指定是否进行自动注入。可选值有Autowire.NO、Autowire.BY_NAME和Autowire.BY_TYPE。默认是Autowire.NO，即不进行自动注入。Autowire.BY_NAME表示按名称进行自动注入，Autowire.BY_TYPE表示按类型进行自动注入。
@Bean(autowire=Autowire.BY_TYPE)
public Hello hello() {
return new Hello();
}
上述示例表示按照类型对依赖的bean进行自动注入。其等同于如下XML定义。
<bean id="hello" class="com.app.Hello" autowire="byType"/>
通过@Bean进行定义的bean对应的Scope默认也是singleton的，用户如果希望更改这种默认策略，则需要在@Bean对应的方法上使用@Scope标注进行定义，具体用法与我们之前介绍的在基于注解配置bean定义时是一样的。如下表示我们定义对应的Scope为prototype。
@Bean
@Scope("prototype")
public Hello hello() {
return new Hello();
}
如果需要被代理，可以指定proxyMode。
@Bean
@Scope(value="prototype", proxyMode=ScopedProxyMode.TARGET_CLASS)
public Hello hello() {
return new Hello();
}
对于处于同一个使用@Configuration进行标注的配置类中的bean注入，我们可以直接通过方法调用的形式来获取对应的bean实例以进行注入。如下示例中我们就通过调用world()方法获取了一个World实例，然后注入给了Hello的实例。
@Bean
public Hello hello() {
Hello hello = new Hello();
hello.setWorld(this.world());
return hello;
}
@Bean
public World world() {
return new World();
}
也可以像之前介绍的使用@Autowired或@Inject标注进行自动注入，即在对应的bean对应的Class类中进行定义。如下示例中我们就通过@Autowired定义了world需要进行自动注入。对于使用Java类进行配置的情况，Spring会自动扫描对应的注解以完成对应的bean定义。
public class Hello {
@Autowired
private World world;
}
再来看一个示例，在下面的示例中，我们调用了两次world()方法，分别获取对应的bean实例注入hello和beanA。因为Spring默认生成的bean实例是singleton类型的，为了实现这种机制，则在第一次调用world()产生了第一个实例后，Spring会将对应的对象缓存起来，待下次再调用world()方法获取实例时则直接获取缓存起来的那个实例。所以对于如下这种情况，实际上Spring也只会产生一个World实例。Spring的这种基于Java类配置的单例bean机制是通过CGLIB动态生成类来实现的，在系统启动时，Spring将通过CGLIB构建所有使用@Configuration进行标注的Class的子类，在子类调用父类对应方法产生对应的bean实例之前，会先从子类的缓存中获取，只有在取不到的情况下才会调用父类产生新的实例，产生了对应的实例后就将其缓存到对应的缓存中。另外，鉴于Spring的这种机制就要求我们对应的Java配置Class不是final型的，且存在一个无参构造方法。
@Configuration
public class SpringConfig {
@Bean
public Hello hello() {
Hello hello = new Hello();
hello.setWorld(world());
return hello;
}
@Bean
public World world() {
return new World();
}
@Bean
public BeanA beanA() {
BeanA beanA = new BeanA();
beanA.setWorld(world());
return beanA;
}
}
在之前介绍XML配置时，我们曾使用lookup-method的方式以解决单例bean引用多例bean的问题。在使用基于Java进行配置时如果我们也希望以这样的方式来解决单例bean引用多例bean的情况，则我们可以通过如下方式进行解决。打个比方我们有一个单例bean，对应类Hello，其需要引用一个多例的bean World，那么我们就可以在Hello中定义一个公用的方法以获取World实例，然后每次需要使用World实例时都通过该方法获取，如下的getWorld()方法就是这个功能。
public class Hello {
public void doSomething() {
World world = this.getWorld();
System.out.println(world);
//...
}
public World getWorld() {
return null;
}
}
然后我们在定义Hello对应的单例bean时，可以new一个匿名的Hello类的子类，然后在其中重写getWorld()方法，对应方法体则是通过@Configuration标注的配置类的对应方法获取一个多例的World实例。这样我们在单例的hello中每次调用getWorld()方法时都会从bean容器中获取到一个全新的World实例。
@Configuration
public class SpringConfig {
@Bean
public Hello hello() {
Hello hello = new Hello() {
public World getWorld() {
return world();
}
};
return hello;
}
@Bean
@Scope("prototype")
public World world() {
return new World();
}
}
@Configuration是标注在Class上的，当我们需要基于Java类的形式对Spring进行配置时，我们就需要在对应的配置类上使用@Configuration进行标注，这样Spring才会把对应的Class当做是一个配置用的Class。使用@Configuration进行标注的配置类默认也会被Spring作为一个bean进行注册。所以当我们的拥有多个@Configuration进行标注的配置类时，如果需要进行依赖注入时对应的依赖项处于不同的@Configuration配置类时也可以通过注入@Configuration配置类，然后通过注入的@Configuration配置类实例的对应方法产生目标依赖bean的实例进行注入。如下示例中我们拥有两个Java配置类，其中ServiceConfig中的UserService需要注入一个在DaoConfig中定义的UserDao，然后我们就在ServiceConfig中注入了一个DaoConfig，再通过调用DaoConfig的userDao()方法获取对应的UserDao实例注入给UserService的实例。
@Configuration
public class ServiceConfig {
@Autowired
private DaoConfig daoConfig;
@Bean
public UserService userService() {
UserService userService = new UserServiceImpl(daoConfig.userDao());
return userService;
}
}
@Configuration
public class DaoConfig {
@Bean
public UserDao userDao() {
UserDao userDao = new UserDaoImpl();
return userDao;
}
}
基于Java类的Spring配置也可以像基于XML配置一样让Spring扫描类路径以将标注了@Component等注解的Class注册为bean容器中的bean定义。这是通过在配置上使用@ComponentScan进行标注来进行定义的。
@Configuration
@ComponentScan(basePackages="com.app")
public class SpringConfig {
}
在上述代码中我们就通过@ComponentScan定义了将扫描类路径下com.app包及其子孙包下所有标注了@Component等注解的Class，并将它们作为一个bean定义注册到当前的bean容器中。其就相当于如下XML定义。
<context:component-scan base-package="com.app"/>
通过@ComponentScan的includeFilters和excludeFilters属性可以指定在扫描时需要使用的过滤器，对应的过滤器是通过@Filter进行指定的，可以通过其type属性指定过滤器的类型，默认为ANNOTATION。如下示例表示将排除@Service注解。
@Configuration
@ComponentScan(basePackages = "com.app", excludeFilters={@Filter(Service.class)})
public class ControllerConfig {
}
基本上使用<context:component-scan/>能定义的内容，@ComponentScan都有与之相对应的属性进行定义，更多信息请参考Spring API文档中ComponentScan的相关信息。
对于非Web环境的bean容器实例化，Spring为我们提供了一个对应的ApplicationContext实现类——AnnotationConfigApplicationContext。实例化AnnotationConfigApplicationContext时我们可以直接将Java配置类作为构造参数传入。
public static void main(String args[]) {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
context.close();
}
当有多个Java配置类时，我们可以给AnnotationConfigApplicationContext传递多个Java配置类。
public static void main(String args[]) {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(
SpringConfig.class, ServiceConfig.class, DaoConfig.class);
context.close();
}
我们还可以先构造一个空的AnnotationConfigApplicationContext，然后通过对应的register()方法来注册用于配置的Java类。
public static void main(String args[]) {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
context.register(SpringConfig.class);//注册单个配置类
context.register(ServiceConfig.class, DaoConfig.class);//注册多个配置类
context.refresh();//注册完后一定要refresh()一次
context.close();
}
此外，需要注意的是AnnotationConfigApplicationContext不仅仅接收使用@Configuration进行标注的类作为配置类，其还可以接收使用@Component等用于标注为bean的注解进行标注的类作为配置类。所以，当我们直接使用AnnotationConfigApplicationContext时，我们可以选择在对应的配置类上使用@Configuration进行标注，也可以选择使用@Component等定义bean的注解进行标注。
关于AnnotationConfigApplicationContext的更多信息请参考Spring API文档。
对于Web环境而言，Spring针对基于Java类配置提供了一个对应WebApplicationContext的实现类—AnnotationConfigWebApplicationContext。如果需要使用该WebApplicationContext，我们需要通过在web.xml文件中通过<context-param/>或<init-param/>进行指定。
我们知道通常在Web环境下使用Spring时我们都需要在web.xml文件中定义如下Listener，Spring将通过该Listener来实例化WebApplicationContext，默认会实例化一个基于XML配置的XmlWebApplicationContext。
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
如果我们希望ContextLoaderListener实例化的WebApplicationContext是一个AnnotationConfigWebApplicationContext，那么我们可以通过在web.xml中定义如下参数，该参数将会被ContextLoaderListener用来实例化对应的WebApplicationContext实现类。
<context-param>
<param-name>contextClass</param-name>
<param-value>org.springframework.web.context.support.AnnotationConfigWebApplicationContext</param-value>
</context-param>
我们知道基于XML配置的ContextLoaderListener默认取WEB-INF目录下的applicationContext.xml文件作为对应的配置文件，且对应的配置我们可以通过参数contextConfigLocation进行配置。那么当我们使用的WebApplicationContext是AnnotationConfigWebApplicationContext时对应的contextConfigLocation也需要变更为我们的Java配置类，且必须是全名的，即包含对应的包名称，多个配置类之间以逗号或分号或空格隔开。所以对于使用Spring的Web应用，我们应该如下定义对应的ContextLoaderListener。在如下示例中我们就通过contextClass参数指定了对应的contextClass为AnnotationConfigWebApplicationContext，然后通过contextConfigLocation参数指定了三个Java配置类。
<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>com.app.SpringConfig,com. app.ServiceConfig,com.app.DaoConfig</param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
而对于使用SpringMVC而言，如果我们是使用基于Java类的配置来配置对应的SpringMVC定义，则需要在定义DispatcherServlet时通过
<servlet>
<servlet-name>spring</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>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>com.app.ControllerConfig</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>spring</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>
对于使用Spring Test进行单元测试而言，我们可以直接通过@ContextConfiguration的classes属性来指定需要使用的Java配置类。如下示例中我们就指定了将使用SpringConfig、ServiceConfig和DaoConfig三个Java配置类来构建对应的ApplicationContext。
@ContextConfiguration(classes={SpringConfig.class, ServiceConfig.class, DaoConfig.class})
@RunWith(SpringJUnit4ClassRunner.class)
public class ConfigurationTest {
@Autowired
private ApplicationContext context;
@Test
public void test() {
context.getBean("hello", Hello.class);
}
}
通常在使用基于Java类的配置时我们可能不是单独使用一个Java类进行配置，有的时候可能会建立多个Java类进行配置，也可能是基于Java类的配置和基于XML的配置一起使用，这就需要我们将多个配置整合在一起了。
对于多个Java配置类的情况，我们可以通过将@Import标注在对应的配置类上以引入另外一个配置类，这样我们在使用的时候就可以只以其中的某个或某几个配置类来直接作为配置类。如下示例我们在配置类SpringConfig上使用@Import引入了另外两个配置类ServiceConfig和DaoConfig。
@Configuration
@Import({ServiceConfig.class, DaoConfig.class})
public class SpringConfig {
}
那么对应在使用的时候我们可以只显示的使用SpringConfig作为配置类，但实际上是使用了SpringConfig、ServiceConfig和DaoConfig三个配置类，即如下示例中的context将包含这三个配置类中定义的所有的bean。
@ContextConfiguration(classes={SpringConfig.class})
@RunWith(SpringJUnit4ClassRunner.class)
public class ConfigurationTest {
@Autowired
private ApplicationContext context;
}
当以Java配置类为主组合XML配置时我们只需要在Java配置类上使用@ImportResource进行标注以引入对应的XML配置即可。如下示例中我们即通过@ImportResource引入了类路径下的applicationContext.xml，这样我们可以继续使用SpringConfig作为配置类，但其中会包含applicationContext.xml中定义的bean。
@Configuration
@ImportResource({"classpath:applicationContext.xml"})
public class SpringConfig {
@Bean
public Hello hello() {
return new Hello();
}
}
由于@Configuration是标注了@Component的，所以以XML配置为主时，如果我们的XML配置定义了<context:component-scan/>，且其能扫描到我们使用了@Configuration进行标注的配置类，那么对应的配置类将作为一个bean定义到对应的bean容器中。与此同时，Spring能检测到其中使用@Bean进行标注的方法，并把它们作为一个bean进行定义。其实如果我们的配置类不是使用的@Configuration进行标注的，而是使用的其它Spring会把它当做一个bean进行定义的注解进行标注也是可以的，如@Component、@Service等。
但是当我们在XML配置中没有使用<context:component-scan/>或者对应的<context:component-scan/>扫描不到我们基于Java的配置类，这个时候就需要我们自己在XML配置中定义对应的bean了，这样Spring就能自动组合基于Java类配置的bean定义了。
<bean class="com.app.SpringConfig"/>
自己单独在XML配置中定义Java配置类对应的bean时，如果我们的配置类中有使用@Autowired进行自动注入，那就需要启用<context:annotation-config/>。当然如果使用了<context:component-scan/>就可以不再单独指定<context:annotation-config/>了，因为<context:component-scan/>默认会启用<context:annotation-config/>。
（注：本文是基于Spring4.1.0所写）