Spring核心——@Configuration与混合使用

ゞ 浴缸里的玫瑰 2021-11-29 16:24 307阅读 0赞

@Configuration

在介绍Spring核心容器的系列文章中已经多次出现这个注解，从使用的角度来说可以把他理解为XML配置中的标签，但是两者肯定是不等价的。

在标签中除了使用声名Bean以外，还有各种标签来扩展功能，比如、以及等，这些扩展的功能并不是@Configuration注解的参数，而是通过另外一个注解来实现——@ComponentScan、@Import。

@Configuration的基本使用方法已经在纯Java运行与@Bean的“@Bean注解”部分介绍了使用方法，本篇在此基础上进一步进行说明。

@Configuration添加依赖

除了在纯Java运行与@Bean文中介绍的使用方法，我们还可以直接通过使用Java代码来添加依赖关系：

  1. @Configuration
  2. public class MyConfig {
  4.     @Bean
  5.     public Alice alice() {
  6.         //直接使用方法注入数据。
  7.         //从表面上看这里调用bob()并没有经过容器处理。而是直接使用了。
  8.         return new Alice(bob());
  9.     }
  11.     @Bean
  12.     public Bob bob() {
  13.         return new Bob();
  14.     }
  15. }

看到这里，思维敏捷的码友通过以下逻辑肯定就发现问题了：

  1. 通过@Bean注解是向容器添加一个BeanDefinition，
  2. 在所有的BeanDefinition创建之后容器开始创建Bean之前会执行预设的后置处理器BeanFactoryPostProcessor。
  3. 最后容器根据BeanDefinition的内容创建Bean。
    • return new Alice(bob()); 这段代码中MyConfig::bob*方法的调用看起来完全和容器无关，这样就违反了依赖注入的原则！
  5. 所以是不是Alice类中被注入的Bob实例根本就不是IoC容器中的Bob？

首先可以很负责的告诉码友们Spring并没有限制这个方式去添加Bean，所以例子中Alice类中的Bob实例就是IoC容器中的实例。即使是这样去注入Bean同样实现了依赖注入的功能。至于怎么解决的看完本文自然就能得到答案了。

@Component添加依赖

之前在Stereotype组件与Bean扫描这篇文章已经提到过，除了在@Configuration中的方法使用@Bean，还可以在@Component及其派生类中的方法使用@Bean。例如下面的例子：

  1. package chkui.springcore.example.javabase.configuration.bean;
  3. @Component
  4. public class BeanManager {
  6.     @Bean
  7.     public Cytus cytus() {
  8.         return new Cytus();
  9.     }
  11.     @Bean
  12.     public Dva dva() {
  13.         return new Dva();
  14.     }
  16.     @Bean
  17.     public Game game(Dva dva) {
  18.         return new Game(cytus(), dva);
  19.     }
  20. }

BeanManager中的三个方法都会向容器添加Bean。注意第三个方法：public Game game(Dva dva)。这里即采用了通过方法参数注入依赖，也像前面的例子一样直接调用了方法。但是这里与前面介绍的使用@Configuration注解不同，Game中的Cytus实例不是IoC容器中的Cytus。

通过下面的例子来说明@Configuration和@Component中注入Bean的差异。

  1. //package chkui.springcore.example.javabase.configuration;
  2. //使用@Configuration注解
  3. @Configuration
  4. class Config {
  6.     @Bean
  7.     public Alice alice() {
  8.         return new Alice(bob());
  9.     }
  11.     @Bean
  12.     public Bob bob() {
  13.         return new Bob();
  14.     }
  15. }
  16. //package chkui.springcore.example.javabase.configuration.bean;
  17. //使用@Component注解
  18. @Component
  19. public class BeanManager {
  21.     @Bean
  22.     public Cytus cytus() {
  23.         return new Cytus();
  24.     }
  26.     @Bean
  27.     public Dva dva() {
  28.         return new Dva();
  29.     }
  31.     @Bean
  32.     public Game game(Dva dva) {
  33.         return new Game(cytus(), dva);
  34.     }
  35. }
  36. //运行
  37. public class ConfigurationApp {
  38.     public static void main(String[] args) {
  39.         ApplicationContext ctx = new AnnotationConfigApplicationContext(Config.class， BeanManager.class);
  40.         Bob bob = ctx.getBean(Bob.class);
  41.         Alice alice = ctx.getBean(Alice.class);
  42.         System.out.println("Bob instance of IoC hash: " + bob.hashCode());
  43.         System.out.println("Bob instance of Alice hash: " + alice.getBob().hashCode());
  44.         System.out.println("Compare：" + (bob == alice.getBob()));
  45.         System.out.println("Config instance：" + ctx.getBean(Config.class));
  47.         Game game = ctx.getBean(Game.class);
  48.         Cytus cytus = ctx.getBean(Cytus.class);
  49.         Dva dva = ctx.getBean(Dva.class);
  50.         System.out.println("IoC Cytus: " + cytus.hashCode());
  51.         System.out.println("Game Cytus: " + game.getCytus().hashCode());
  52.         System.out.println("IoC Dva: " + dva.hashCode());
  53.         System.out.println("Game Dva: " + game.getDva().hashCode());
  54.         System.out.println("Cytus：" + (cytus == game.getCytus()));
  55.         System.out.println("Dva：" + (dva == game.getDva()));
  56.         System.out.println("BeanManager Instance：" + ctx.getBean(BeanManager.class));
  57.     }
  58. }

在最后的main方法中我们对容器中以及Alice、Game中包含的实例进行了hash以及实例对比，在我的电脑上输出结果如下：

  1. 1.Bob instance of IoC hash: 1242027525
  2. 2.Bob instance of Alice hash: 1242027525
  3. 3.Compare：true
  4. 4.Config instance：5.chkui.springcore.example.javabase.configuration.Config$$EnhancerBySpringCGLIB$$acdbeb32@74287ea3
  5. 6.IoC Cytus: 2104973502
  6. 7.Game Cytus: 735937428
  7. 8.IoC Dva: 1604247316
  8. 9.Game Dva: 1604247316
  9. 10.Cytus：false
  10. 11.Dva：true
  11. 12.BeanManager Instance：chkui.springcore.example.javabase.configuration.bean.BeanManager@68746f22

例子中分别在@Configuration和@Component标记的类中使用@Bean来向容器添加Bean。最后通过输出实例的hash以及地址匹配（使用“==”比对）来确定是否都是同一个单例。

很明显IoC容器中的Cytus以Game中的Cytus并不是一个实例，其他都是同一个单例。仔细看看第4行和第12行的Config instance和BeanManager instance的输出内容就会得到答案。

BeanManager是一个常规的类，而在JVM中运行的Config是一个通过CGLIB实现的字节码级别的代理类（如果不知道CGLIB是什么就自己网上找找吧，这玩意在Java界已经红得发紫了）。Spring实际上是使用CGLIB为Config类添加了一个“代理壳”，当我们在任何地方直接调用@Configuration标注的类中的的方法时，代理壳都会将其整理为一个BeanDefinition的转换过程。

知道两者的差异后我们选择何种方式来添加Bean就很清晰了：

使用@Configuration能保证不会出现例子中Cytus这样的例外。也能清晰的明确@Configuration等价于一个统一管理。

而在@Component或其他组建中使用@Bean好处是不会启动CGLIB这种重量级工具（不过在Spring中即使这里不使用，其他很多地方也在使用）。并且@Component及其相关的Stereotype组件自身就有摸框级别的功能，在这里使用@Bean注解能很好的表明一个Bean的从属和结构关系，但是需要注意直接调用方法的“副作用”。

个人建议如果没什么特别的要求就使用@Configuration，引入CGLIB并不会影响多少性能，然而坑会少很多。在spring官网将用@Configuration创建的@Bean称呼为”Full”模式、将@Component创建的@Bean称呼为”‘lite”模式，从字面上也能略知他们的差异。

多种方式混合使用

从XML配置到纯Java配置，Spring变得越来越简便好用，对应的功能也越来越多样化。如果对他的脉络没有清晰的认识，往往会陷入迷惑中。无论功能再复杂我们都要记住本系列文章开篇提到的IoC容器的初衷：

处理容器与Bean、Bean与Bean的关系。Bean是最小的工作单元，一切功能都是在Bean基础上扩展而来的。

所以无论是XML配置还是纯Java配置基本目标就是解决三个问题：向容器添加Bean，确定Bean的功能，确定Bean与Bean之间的依赖关系。

既然XML和纯Java配置都是解决同样的问题，那么混合使用当然没问题。比如在XML中配置了，那么指定路径下的@Component以及派生注解（@Service、@Comfiguration等）都会被扫描并添加到容器中成为一个Bean。然后IoC容器会根据注解的类型来确定这个Bean是什么功能。

下面是一个使用AnnotationConfigApplicationContext启动容器混合使用Java配置与XML配置的例子

首先我们使用AnnotationConfigApplicationContext启动IoC容器：

  1. package chkui.springcore.example.javabase.multiconfiguration;
  3. @Configuration
  4. @ComponentScans({ @ComponentScan("chkui.springcore.example.javabase.multiconfiguration.config"),
  5.         @ComponentScan("chkui.springcore.example.javabase.multiconfiguration.service") })
  6. public class MultiConfigurationApp {
  7.     public static void main(String[] args) {
  8.         ApplicationContext ctx = new AnnotationConfigApplicationContext(MultiConfigurationApp.class);
  9.     }
  10. }

在Main方法中直接指定了当前的类，所以MultiConfigurationApp类会成为一个Bean。由于是一个Stereotype模式的@Configuration标记类（@Configuration继承自@Component，提供了配置相关的分层功能，关于Stereotype模式的内容相见Stereotype组件与Bean扫描），所以容器会用CGLIB来代理它实现配置相关的功能。@ComponentScans是一个辅助注解，他的作用就是整合多个@ComponentScan一起使用。

在config包中有2个@Configuration类：

  1. package chkui.springcore.example.javabase.multiconfiguration.config;
  3. @Configuration
  4. @Import({ClubConfiguration.class})
  5. @ImportResource("javabase/multiconfiguration/config.xml")
  6. public class MainConfiguration {}
  8. package chkui.springcore.example.javabase.multiconfiguration.config;
  10. public class ClubConfiguration {
  11.     @Bean
  12.     public Mil mil() {return new Mil();}
  13.     @Bean
  14.     public Mau mau() {return new Mau();}
  15. }

MainConfiguration类被标记了@Configuration注解，所以他会被扫描并添加到容器中。

@Import注解的作用是引入其他类成为一个Bean，我们可以看到ClubConfiguration类并没有任何注解，但是他通过@Import注解在其他类添加到容器中。

而@ImportResource等价于XML配置中的标签，作用就是引入一个XML配置文件。对应的XML文件如下：

  1. <beans ...>
  2.     <bean class="chkui.springcore.example.javabase.multiconfiguration.bean.Cfc" />
  3.     <bean class="chkui.springcore.example.javabase.multiconfiguration.bean.Jav" />
  4. </beans>

这样XML配置中的2个类也会被添加到容器中。案例中对应的实体类如下：

  1. package chkui.springcore.example.javabase.multiconfiguration.bean;
  2. class Mau {
  3.     public String toString() {
  4.         return "Manchester United[MAU]";
  5.     }
  6. }
  7. class Cfc {
  8.     public String toString() {
  9.         return "Chelsea Football Club[CFC]";
  10.     }
  11. }
  12. class Mil {
  13.     public String toString() {
  14.         return "A.C Milan [MIL]";
  15.     }
  16. }
  17. class Jav {
  18.     public String toString() {
  19.         return "Juventus [JAV]";
  20.     }
  21. }

Conditionally

最后在使用@Configuration时可以使用Conditionally特性来确定是否添加Bean。大致用法就是实现Condition接口，然后通过@Conditional注解和@Bean绑定在一起进行条件判断。

实现Condition：

  1. package chkui.springcore.example.javabase.multiconfiguration.config;
  2. public class SoySauceCondition implements Condition {
  3.     @Override
  4.     public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
  5.         return false; //返回false则不会对应的Bean。
  6.     }
  7. }

然后使用@Conditional注解绑定到一个@Bean上：

  1. package chkui.springcore.example.javabase.multiconfiguration.config;
  2. public class ClubConfiguration {
  3.     @Bean
  4.     @Conditional(SoySauceCondition.class)
  5.     public SoySauce soySauce() {
  6.         return new SoySauce();
  7.     }
  8. }

这样，如果SoySauceCondition中的matches方法返回ture则添加SoySauce到IoC容器中，否则不会存在这个Bean。

欢迎工作一到五年的Java工程师朋友们加入Java技术交流群：659270626
群内提供免费的Java架构学习资料（里面有高可用、高并发、高性能及分布式、Jvm性能调优、Spring源码，MyBatis，Netty,Redis,Kafka,Mysql,Zookeeper,Tomcat,Docker,Dubbo,Nginx等多个知识点的架构资料）合理利用自己每一分每一秒的时间来学习提升自己，不要再用”没有时间“来掩饰自己思想上的懒惰！趁年轻，使劲拼，给未来的自己一个交代！

发表评论

表情：
评论列表 （有 0 条评论，307人围观）

还没有评论，来说两句吧...

相关阅读