转载

真懂Spring的@Configuration配置类？你可能自我感觉太良好

当大潮退去，才知道谁在裸泳。关注公众号【 BAT的乌托邦 】开启专栏式学习，拒绝浅尝辄止。本文 https://www.yourbatman.cn 已收录，里面一并有Spring技术栈、MyBatis、中间件等小而美的专栏供以学习哦。

目录

真懂Spring的@Configuration配置类？你可能自我感觉太良好

前言

各位小伙伴大家好，我是A哥。这是一篇“插队”进来的文章，源于我公众号下面的这句评论：

真懂Spring的@Configuration配置类？你可能自我感觉太良好

官方管这两种模式分别叫： Full @Configuration 和 lite @Bean mode ，口语上我习惯把它称为Spring配置的Full模式和Lite模式更易沟通。

的确，我很简单的“调研”了一下，知晓Spring配置中 Lite模式 和 Full模式 的几乎没有（或者说真的很少吧）。按照我之前的理论，大多人都不知道的技术（知识点）那肯定是不流行的。但是： 不流行不代表不重要，不流行不代表不值钱，毕竟高薪往往只有少数人才能拥有。

什么OPP、OOP、AOP编程，其实我最喜欢的和推崇的是 面向工资编程 。当然前提是够硬（收回你邪恶的笑容），没有金刚钻，不揽瓷器活。

听我这么一忽悠，是不是对这块内容还饶有兴味了，这不它来了嘛。

版本约定

本文内容若没做特殊说明，均基于以下版本：

1.8
5.2.2.RELEASE

正文

最初的Spring只支持xml方式配置Bean，从 Spring 3.0 起支持了一种更优的方式：基于Java类的配置方式，这一下子让我们Javaer可以从标签语法里解放了出来。毕竟作为Java程序员，我们擅长的是写Java类，而非用标签语言去写xml文件。

我对Spring配置的Full/Lite模式的关注和记忆深刻，源自于一个小小故事：某一年我在看公司的项目时发现，数据源配置类里有如下一段配置代码：

@Configuration
public class DataSourceConfig {

	...
	@Bean
    public DataSource dataSource() {
    	...
        return dataSource;
    }
    @Bean(name = "transactionManager")
    public DataSourceTransactionManager transactionManager() {
        return new DataSourceTransactionManager(dataSource());
    }
	...
}

作为当时还是 Java萌新 的我，非常的费解。自然的对此段代码产生了较大的好奇（其实是质疑）：在准备 DataSourceTransactionManager 这个Bean时调用了 dataSource() 方法，根据我“非常扎实”的JavaSE基础知识，它肯定会重新走一遍 dataSource() 方法，从而产生一个新的数据源实例，那么你的事务管理器管理的不就是一个“全新数据源”麽？谈何事务呢？

为了验证我的猜想，我把断点打到 dataSource() 方法内部开始调试，但让我“失望”的是： 此方法并没有执行两次 。这在当时是震惊了我的，甚至一度怀疑自己引以为豪的Java基础了。所以我四处询问，希望得到一个“解释”，但奈何，问了好几圈，那会没有一人能给我一个合理的说法，只知道那么用是没有问题的。

很明显，现在再回头来看当时的这个质疑是显得有些“无知”的，这个“难题”困扰了我很久，直到我前2年开始深度研究Spring源码才让此难题迎刃而解，当时那种豁然开朗的感觉真好呀。

真懂Spring的@Configuration配置类？你可能自我感觉太良好

基本概念

关于配置类的核心概念，在这里先予以解释。

@Configuration和@Bean

Spring新的配置体系中最为重要的构件是： @Configuration 标注的类， @Bean 标注的方法。 

// @since 3.0
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Configuration {

	@AliasFor(annotation = Component.class)
	String value() default "";
	// @since 5.2
	boolean proxyBeanMethods() default true;
	
}

用 @Configuration 注解标注的类表明其主要目的是作为bean定义的 源 。此外， @Configuration 类允许通过调用同一类中的其他 @Bean method方法来定义bean之间的依赖关系（下有详解）。 

// @since 3.0
@Target({ElementType.METHOD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Bean {

	@AliasFor("name")
	String[] value() default {};
	@AliasFor("value")
	String[] name() default {};
	@Deprecated
	Autowire autowire() default Autowire.NO;
	// @since 5.1
	boolean autowireCandidate() default true;
	String initMethod() default "";
	String destroyMethod() default AbstractBeanDefinition.INFER_METHOD;
	
}

@Bean 注解标注在方法上，用于指示方法实例化、配置和初始化要由Spring IoC容器管理的新对象。对于熟悉Spring的 <beans/> XML配置的人来说， @Bean 注解的作用与 <bean/> 元素相同。您可以对任何Spring的@Component组件使用 @Bean 注释的方法代替（注意：这是理论上，实际上比如使用@Controller标注的组件就不能直接使用它代替）。

需要注意的是，通常来说，我们均会把 @Bean 标注的方法写在 @Configuration 标注的类里面来配合使用。

简单粗暴理解： @Configuration 标注的类等同于一个xml文件， @Bean 标注的方法等同于xml文件里的一个 <bean/> 标签

使用举例

@Configuration
public class AppConfig {

    @Bean
    public User user(){
        User user = new User();
        user.setName("A哥");
        user.setAge(18);
        return user;
    }

}
public class Application {

    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

        User user = context.getBean(User.class);
        System.out.println(user.getClass());
        System.out.println(user);
    }
}

输出：

class com.yourbatman.fullliteconfig.User
User{name='A哥', age=18}

Full模式和Lite模式

Full模式和Lite模式均是针对于Spring配置类而言的，和xml配置文件无关。值得注意的是：判断是Full模式 or Lite模式的前提是，首先你得是个容器组件。至于一个实例是如何“晋升”成为容器组件的，可以用注解也可以没有注解，本文就不展开讨论了，这属于Spring的基础知识。

Lite模式

当 @Bean 方法在没有使用 @Configuration 注释的类中声明时，它们被称为 在Lite模式下处理 。它包括：在 @Component 中声明的 @Bean 方法，甚至只是在一个非常普通的类中声明的Bean方法，都被认为是Lite版的配置类。 @Bean 方法是一种通用的工厂方法（ factory-method ）机制。

和Full模式的 @Configuration 不同，Lite模式的 @Bean 方法 不能声明Bean之间的依赖关系 。因此，这样的 @Bean 方法 不应该调用其他@Bean方法 。每个这样的方法实际上 只是一个特定Bean引用的工厂方法(factory-method) ，没有任何特殊的运行时语义。

何时为Lite模式

官方定义为：在没有标注 @Configuration 的类里面有 @Bean 方法就称为Lite模式的配置。透过源码再看这个定义是不完全正确的，而应该是有如下case均认为是Lite模式的配置类：

  1. 类上标注有 @Component 注解
  2. 类上标注有 @ComponentScan 注解
  3. 类上标注有 @Import 注解
  4. 类上标注有 @ImportResource 注解
  5. 若类上没有任何注解 ，但类内存在@Bean方法

以上case的前提均是类上没有被标注 @Configuration ，在 Spring 5.2之后 新增了一种case也算作Lite模式：

  1. 标注有 @Configuration(proxyBeanMethods = false) ，注意：此值默认是true哦，需要显示改为false才算是Lite模式

细心的你会发现，自Spring5.2（对应Spring Boot 2.2.0）开始，内置的几乎所有的 @Configuration 配置类都被修改为了 @Configuration(proxyBeanMethods = false) ，目的何为？答：以此来降低启动时间，为Cloud Native继续做准备。

优缺点

优点：

  • 运行时不再需要给对应类生成CGLIB子类，提高了运行性能，降低了启动时间
  • 可以该配置类当作一个普通类使用喽：也就是说@Bean方法 可以是private、可以是final

缺点：

  • 不能声明@Bean之间的依赖，也就是说不能通过方法调用来依赖其它Bean
  • （其实这个缺点还好，很容易用其它方式“弥补”，比如：把依赖Bean放进方法入参里即可）

代码示例

主配置类：

@ComponentScan("com.yourbatman.fullliteconfig.liteconfig")
@Configuration
public class AppConfig {
}

准备一个Lite模式的配置：

@Component
// @Configuration(proxyBeanMethods = false) // 这样也是Lite模式
public class LiteConfig {

    @Bean
    public User user() {
        User user = new User();
        user.setName("A哥-lite");
        user.setAge(18);
        return user;
    }


    @Bean
    private final User user2() {
        User user = new User();
        user.setName("A哥-lite2");
        user.setAge(18);

        // 模拟依赖于user实例  看看是否是同一实例
        System.out.println(System.identityHashCode(user()));
        System.out.println(System.identityHashCode(user()));

        return user;
    }

    public static class InnerConfig {

        @Bean
        // private final User userInner() { // 只在lite模式下才好使
        public User userInner() {
            User user = new User();
            user.setName("A哥-lite-inner");
            user.setAge(18);
            return user;
        }
    }
}

测试用例：

public class Application {

    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

        // 配置类情况
        System.out.println(context.getBean(LiteConfig.class).getClass());
        System.out.println(context.getBean(LiteConfig.InnerConfig.class).getClass());

        String[] beanNames = context.getBeanNamesForType(User.class);
        for (String beanName : beanNames) {
            User user = context.getBean(beanName, User.class);
            System.out.println("beanName:" + beanName);
            System.out.println(user.getClass());
            System.out.println(user);
            System.out.println("------------------------");
        }
    }
}

结果输出：

1100767002
313540687
class com.yourbatman.fullliteconfig.liteconfig.LiteConfig
class com.yourbatman.fullliteconfig.liteconfig.LiteConfig$InnerConfig
beanName:userInner
class com.yourbatman.fullliteconfig.User
User{name='A哥-lite-inner', age=18}
------------------------
beanName:user
class com.yourbatman.fullliteconfig.User
User{name='A哥-lite', age=18}
------------------------
beanName:user2
class com.yourbatman.fullliteconfig.User
User{name='A哥-lite2', age=18}
------------------------

小总结

  • 该模式下，配置类本身不会被CGLIB增强，放进IoC容器内的就是本尊
  • 该模式下，对于内部类是没有限制的：可以是Full模式或者Lite模式
  • 该模式下，配置类内部 不能通过方法调用 来处理依赖，否则每次生成的都是一个新实例而并非IoC容器内的单例
  • 该模式下，配置类就是一普通类嘛，所以@Bean方法可以使用 private/final 等进行修饰（static自然也是阔仪的）

Full模式

在常见的场景中， @Bean 方法都会在标注有 @Configuration 的类中声明，以确保总是使用“Full模式”，这么一来，交叉方法引用会被重定向到容器的生命周期管理，所以就可以更方便的管理Bean依赖。

何时为Full模式

标注有 @Configuration 注解的类被称为full模式的配置类。自Spring5.2后这句话改为下面这样我觉得更为精确些：

  • 标注有 @Configuration 或者 @Configuration(proxyBeanMethods = true) 的类被称为Full模式的配置类
  • （当然喽，proxyBeanMethods属性的默认值是true，所以一般需要Full模式我们只需要标个注解即可）

优缺点

优点：

  • 可以支持通过常规Java调用相同类的@Bean方法而保证是容器内的Bean，这有效规避了在“Lite模式”下操作时难以跟踪的细微错误。特别对于萌新程序员，这个特点很有意义

缺点：

  • 运行时会给该类生成一个CGLIB子类放进容器，有一定的性能、时间开销（这个开销在Spring Boot这种拥有大量配置类的情况下是不容忽视的，这也是为何Spring 5.2新增了 proxyBeanMethods 属性的最直接原因）
  • 正因为被代理了，所以@Bean方法 不可以是private、不可以是final

代码示例

主配置：

@ComponentScan("com.yourbatman.fullliteconfig.fullconfig")
@Configuration
public class AppConfig {
}

准备一个Full模式的配置：

@Configuration
public class FullConfig {

    @Bean
    public User user() {
        User user = new User();
        user.setName("A哥-lite");
        user.setAge(18);
        return user;
    }


    @Bean
    protected User user2() {
        User user = new User();
        user.setName("A哥-lite2");
        user.setAge(18);

        // 模拟依赖于user实例  看看是否是同一实例
        System.out.println(System.identityHashCode(user()));
        System.out.println(System.identityHashCode(user()));

        return user;
    }

    public static class InnerConfig {

        @Bean
        // private final User userInner() { // 只在lite模式下才好使
        public User userInner() {
            User user = new User();
            user.setName("A哥-lite-inner");
            user.setAge(18);
            return user;
        }
    }
}

测试用例：

public class Application {

    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

        // 配置类情况
        System.out.println(context.getBean(FullConfig.class).getClass());
        System.out.println(context.getBean(FullConfig.InnerConfig.class).getClass());

        String[] beanNames = context.getBeanNamesForType(User.class);
        for (String beanName : beanNames) {
            User user = context.getBean(beanName, User.class);
            System.out.println("beanName:" + beanName);
            System.out.println(user.getClass());
            System.out.println(user);
            System.out.println("------------------------");
        }
    }
}

结果输出：

550668305
550668305
class com.yourbatman.fullliteconfig.fullconfig.FullConfig$$EnhancerBySpringCGLIB$$70a94a63
class com.yourbatman.fullliteconfig.fullconfig.FullConfig$InnerConfig
beanName:userInner
class com.yourbatman.fullliteconfig.User
User{name='A哥-lite-inner', age=18}
------------------------
beanName:user
class com.yourbatman.fullliteconfig.User
User{name='A哥-lite', age=18}
------------------------
beanName:user2
class com.yourbatman.fullliteconfig.User
User{name='A哥-lite2', age=18}
------------------------

小总结

  • 该模式下，配置类会被CGLIB增强(生成代理对象)，放进IoC容器内的是代理
  • 该模式下，对于内部类是没有限制的：可以是Full模式或者Lite模式
  • 该模式下，配置类内部 可以通过方法调用 来处理依赖，并且能够保证是同一个实例，都指向IoC内的那个单例
  • 该模式下，@Bean方法不能被 private/final 等进行修饰（很简单，因为方法需要被复写嘛，所以不能私有和final。defualt/protected/public都可以哦），否则启动报错（其实IDEA编译器在编译器就提示可以提示你了）：

真懂Spring的@Configuration配置类？你可能自我感觉太良好 

Exception in thread "main" org.springframework.beans.factory.parsing.BeanDefinitionParsingException: Configuration problem: @Bean method 'user2' must not be private or final; change the method's modifiers to continue
Offending resource: class path resource [com/yourbatman/fullliteconfig/fullconfig/FullConfig.class]
	at org.springframework.beans.factory.parsing.FailFastProblemReporter.error(FailFastProblemReporter.java:72)
	at org.springframework.context.annotation.BeanMethod.validate(BeanMethod.java:50)
	at org.springframework.context.annotation.ConfigurationClass.validate(ConfigurationClass.java:220)
	at org.springframework.context.annotation.ConfigurationClassParser.validate(ConfigurationClassParser.java:211)
	at org.springframework.context.annotation.ConfigurationClassPostProcessor.processConfigBeanDefinitions(ConfigurationClassPostProcessor.java:326)
	at org.springframework.context.annotation.ConfigurationClassPostProcessor.postProcessBeanDefinitionRegistry(ConfigurationClassPostProcessor.java:242)
	at org.springframework.context.support.PostProcessorRegistrationDelegate.invokeBeanDefinitionRegistryPostProcessors(PostProcessorRegistrationDelegate.java:275)
	at org.springframework.context.support.PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(PostProcessorRegistrationDelegate.java:95)
	at org.springframework.context.support.AbstractApplicationContext.invokeBeanFactoryPostProcessors(AbstractApplicationContext.java:706)
	at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:532)
	at org.springframework.context.annotation.AnnotationConfigApplicationContext.<init>(AnnotationConfigApplicationContext.java:89)
	at com.yourbatman.fullliteconfig.Application.main(Application.java:11)

使用建议

了解了Spring配置类的Full模式和Lite模式，那么在工作中我该如何使用呢？这里A哥给出使用建议，仅供参考：

  • 如果是在公司的业务功能/服务上做开发，使用Full模式
  • 如果你是个容器开发者，或者你在开发中间件、通用组件等，那么使用Lite模式是一种更被推荐的方式，它对Cloud Native更为友好

思考题？

通过 new AnnotationConfigApplicationContext(AppConfig.class) 直接放进去的类，它会成为一个IoC的组件吗？若会，那么它是Full模式 or Lite模式呢？是个固定的结果还是也和其标注的注解有关呢？

本思考题不难，自己试验一把便知，建议多动手~

总结

本文结合代码示例阐述了Spring配置中Full模式和Lite模式，以及各自的定义和优缺点。对于一般的小伙伴，掌握本文就够用了，并且足够你面试中吹x。但A哥系列文章一般不止于“表面”嘛， 下篇文章 将从原理层面告诉你Spring是如何来巧妙的处理这两种模式的，特别是会结合 Spring 5.2.0 新特性，以及对比 Spring 5.2.0 的实现和 之前版本 有何不同，你课订阅我的公众号保持关注。

原文  http://www.cnblogs.com/yourbatman/p/13266371.html
正文到此结束
所属分类： Java 编程技术

热门推荐

相关文章

阿里云首购8折
说给你听

本文目录
随机标签
书籍教程
springboot-demo Java入门教程 bootstrap3 CSS Apache基础教程 php ionic 教程 Python mysql教程 eclipse Ubuntu VPS系统配置 AngularJS 教程 MongoDB教程 Struts2教程 Redis教程 Spring教程 Git教程 Jenkins进阶系列 openfire参考指南 Java设计模式 HBase教程 java-demo Maven教程 springcloud-demo hibernate教程 Docker 教程 memcached教程 Quartz指南 Hive教程 ANTLR教程 SpringCloud Ant教程 java实例教程 Hazelcast教程 XStream教程 Elastic-Job-Lite 深入浅出MyBatis ibaties教程 SVN教程 rabittmq教程 Hadoop教程 solr教程 WebService CXF学习 JPA教程 ActiveMQ中文指南 Java内存模型 dubbo教程 python3-demo Linux入门视频教程
近期评论
  1. 1 使用 Docker 打包和运行 Vue 应用
  2. 2 Dependency Check命令行方式扫描jar包的安全漏洞
  3. 3 maven使用Dependency-Check来扫描安全漏洞
  4. 4 使用sonarqube分析代码质量
  5. 5 使用screw来对比数据库表和字段差异
  6. 6 Spring Boot 实现防盗链功能
  7. 7 在Spring Boot中的实现国际化（i18n）
  8. 8 一个用于 SMB/CIFS 网络的 Java 库-JCIFS
  9. 9 Spring Boot 3.x嵌入MongoDB 进行测试
  10. 10 java如何解析和生成yaml文件？
网站信息
  • 文章总数：82,737 篇
  • 文件总数：284,312 个
  • 标签总数：2,416 个
  • 分类总数：85 个
  • 留言数量：2,559 条
  • 在线人数：649 人
  • 运行天数：4,439天
  • 最后更新：2024年12月22日13点
Loading...

其他链接

关于本站

本站定位：个人技术类博客

本站作用：写博客、记日志、闲聊扯淡鼓捣技术。

问题交流

[HBLOG]公众号 HBLOG HBLOG