随着SpringBoot的兴起，Spring所鼓励的配置方式也逐渐由传统的xml的方式在向Java Config的方式来倾斜。
我们今天就来讲讲Java Config配置的一些内容。
文章的内容参考了Defining Bean Dependencies With Java Config in Spring Framework。
1. 内部Bean引用
这种方式也是Spring reference doc中所介绍的方式。
我们定义如下几个类：
public class MyRepository {
public String findString() {
return "some-string";
}
}
public class MyService {
private final MyRepository myRepository;
public MyService(MyRepository myRepository) {
this.myRepository = myRepository;
}
public String generateSomeString() {
return myRepository.findString() + "-from-MyService";
}
}
此时我们如果想将MyRepository注入到MyService中的话，只需要按照如下的内部引用即可：
@Configuration
class MyConfiguration {
@Bean
public MyService myService() {
return new MyService(myRepository());
}
@Bean
public MyRepository myRepository() {
return new MyRepository();
}
}
是不是很简单？除了这种方式，我们还可以引用.property文件中的属性。比如如果我们希望在MyRepository中加入前缀和后缀的话，则需要如下的MyRepository类：
public class MyRepository {
private final String prefix;
private final String suffix;
public MyRepository (String prefix, String suffix) {
this.prefix = prefix;
this.suffix = suffix;
}
public String findString() {
return prefix + "-some-string-" + suffix;
}
}
此时我们的Java Config文件可以按照如下方式进行配置：
@Configuration
class MyConfiguration {
@Bean
public MyService myService() {
return new MyService(myRepository(null, null));
}
@Bean
public MyRepository myRepository(@Value("${repo.prefix}") String prefix,
@Value("${repo.suffix}") String suffix) {
return new MyRepository(prefix, suffix);
}
}
等等？是不是感觉对这样的用法感觉有些奇怪呢。我们明明在构建myService Bean的时候通过构造器注入(constructor injection)传入的参数都是null，那这个配置到底是如何工作的呢？
实际上，被@Configuration注解的类都会被CGLIB代理，从而使得我们被@Bean注解的方法能够实现：
- 该方法返回的对象会被注入到Spring的容器中。
- 调用该方法返回的对象是个单例，每次都返回同样的Bean。
因此，每次我们调用该方法（比如上面例子中参数均为null），无论参数为如何，均能够返回正确的Bean。
当然，需要注意的是，由于使用了CGLIB代理，所以config类和Bean方法不能够是private或者final方法。
还有一点需要说明，@Bean方法不光能用于被@Configuration注解的类中，还能够用于被类似@Component注解的类中。但是当被@Componet注解的时候，该配置类并不会被CGLIB代理，因此@Bean方法每次返回的都是新的实例（不再是单例）。这种模式也被称为轻量模式（Lite mode）。
以下的例子证明了这点：
当我们使用@Configuration时：
@Configuration
public class MyConfiguration {
@Bean
public MyService myService() {
return new MyService(myRepository());
}
@Bean
public MyRepository myRepository() {
return new MyRepository();
}
public static void main(String[] args) {
AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(MyConfiguration.class);
MyConfiguration myConfiguration = ac.getBean("myConfiguration", MyConfiguration.class);
MyRepository myRepository1 = myConfiguration.myRepository();
MyRepository myRepository2 = myConfiguration.myRepository();
System.out.println("is singleton : " + (myRepository1 == myRepository2));
System.out.println(ac.getBean("myConfiguration").getClass());
}
}
输出：
is singleton : true
class com.spring.javaconf.MyConfiguration$$EnhancerBySpringCGLIB$$eb2da6d3
可见，通过@Configuration注解的类司机都是通过CGLIB进行了增强，使得我们从容器中获得的bean都是单例的形式。
当我们使用@Component的时候：
@Component
public class MyConfiguration {
@Bean
public MyService myService() {
return new MyService(myRepository());
}
@Bean
public MyRepository myRepository() {
return new MyRepository();
}
public static void main(String[] args) {
AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(MyConfiguration.class);
MyConfiguration myConfiguration = ac.getBean("myConfiguration", MyConfiguration.class);
MyRepository myRepository1 = myConfiguration.myRepository();
MyRepository myRepository2 = myConfiguration.myRepository();
System.out.println("is singleton : " + (myRepository1 == myRepository2));
System.out.println(ac.getBean("myConfiguration").getClass());
}
}
输出
is singleton : false
class com.spring.javaconf.MyConfiguration
可见，此时的实例并没有被代理。而配置类返回的Bean方法也每次返回的不同对象。
这种通过内部Bean（inter-bean reference）的配置方式对于所有bean的配置均处于一个@Configuration中时是非常有效的。但是如果我们希望跨类来进行配置呢？
2. 多个类之间的bean引用
2.1 通过Autowired
在Spring官方文档Referencing beans across @Configuration classes就介绍了这种方式。
比如我们修改我们的测试类如下：
MyConfiguration.class
@Configuration
public class MyConfiguration {
@Autowired
private MyRepository myRepository;
@Bean
public MyService myService() {
return new MyService(myRepository);
}
}
MyConfiguration2.class
@Configuration
public class MyConfiguration2 {
@Bean
public MyRepository myRepository() {
return new MyRepository();
}
}
这种方式也是可以的。
甚至我们可以通过全限定(full-qualified bean reference)的方式来进行引用。
比如：
@Configuration
public class MyConfiguration {
@Autowired
private MyConfiguration2 myConfiguration2;
@Bean
public MyService myService() {
return new MyService(myConfiguration2.myRepository());
}
}
2.2 通过Bean方法参数
如果我们不喜欢将方法调用作为参数，或者我们需要注入的bean是在另一个配置文件中定义的。那这个时候采用内部bean引用可能就不再适用了，此时我们就需要采用方法参数引用。
@Configuration
class MyConfiguration {
@Bean
public MyService myService(MyRepository myRepository) {
return new MyService(myRepository);
}
}
等等，如果我们的容器中包含多个MyRepository的bean呢，那么注入的规则是如何的呢。实际这时候注入的规则和@Autowired是一样的，也就是先按照类型进行注入，在按照名称（也就是此时参数的名称必须与bean的名称相符合）。
@Configuration
class MyConfiguration {
@Bean
public MyRepository myFirstRepository() {
return new MyRepository("first", "repository");
}
//a bean that will be injected by name into myService
@Bean
public MyRepository mySecondRepository() {
return new MyRepository("second", "repository");
}
@Bean
public MyService myService(MyRepository mySecondRepository) {
return new MyService(myRepository);
}
}
如果不希望通过方法参数名称这种形式来进行匹配，那么可以采用@Qualifier注解的方式进行匹配，这种方式将会优先于参数名称匹配。
@Configuration
class MyConfiguration {
//a bean that will be injected by name into myService
@Bean
public MyRepository myFirstRepository() {
return new MyRepository("first", "repository");
}
@Bean
public MyRepository mySecondRepository() {
return new MyRepository("second", "repository");
}
@Bean
public MyService myService(@Qualifier("myFirstRepository") MyRepository someRepository) {
return new MyService(someRepository);
}
}
3. 组合Configuration
如果由多个Configuration文件，我们通过@Import命令可以很容易的将几个配置文件组合在一起。
比如：
@Configuration
@Import({MyConfiguration2.class})
public class MyConfiguration {
@Bean
public MyService myService(MyRepository mySecondRepository) {
return new MyService(mySecondRepository);
}
public static void main(String[] args) {
AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(MyConfiguration.class);
MyService myService = ac.getBean("myService", MyService.class);
System.out.println("result : " + myService.generateSomeString());
}
}
public class MyConfiguration2 {
@Bean
public MyRepository myFirstRepository() {
return new MyRepository("first", "repository");
}
//a bean that will be injected by name into myService
@Bean
public MyRepository mySecondRepository() {
return new MyRepository("second", "repository");
}
}
可以看到，第二个配置文件即使我们没有使用@Configuration注解，也能够通过@Import注解将其配置注入。
4. 总结
在上面，我们介绍了各种通过Java配置的方式，那么我们在实际的应用中应该如何使用呢，通常来讲，啊这个需要依赖与情景与个人或团队的喜好。
比较常用的选择有：
- 当我们在一个配置文件中互相引用的时候，适用于使用内部bean的引用。否则我们采用传递方法参数的方式。
- 当我们有两个配置类在一个上下文中的时候，我们可以采用方法参数或者autowire的形式。
- 当我们有两个或更多的配置类在不同的上下文的时候，我们可以使用Import将其加入到同一个上下文中，并通过方法参数或者autowired的形式。
