底层注解@Configuration、@Bean、@ComponentScan 、@Conditional、@Import、@ConfigurationProperties(prefix=“xxx“)

迷南。 2022-10-13 15:57 172阅读 0赞

###  ###

# **底层注解** #

# **@Configuration** #

把一个类变为配置类，回想下，之前spring中的 xxx.xml Bean配置文件，@Configuration代替了 之前的xml配置文件，那之前xml中的 <bean id="xxx" class="com.lxc.xxx.xxx" /> 在类中如何表示？ 在一个方法上用注解 @Bean 来表示 <Bean> 标签，默认方法名表示之前Bean标签上的id，也就是组件的名字默认是方法名称，class值（返回类型）就是方法的返回值，也就是组件的类型。

配置类

此时，两个组件（我的理解就是两个对象而已）Person和Cat会被加载到IOC的容器里边，在启动入口类中，通过 app.getBean() 的方式可以获取到任何一个组件！！！

@Configuration(proxyBeanMethods = true)
    public class ConfigBean {
        /**
         * @Bean 相当于 之前
         * <Bean id="person" class="com.lxc.xxx.person">
         * </Bean>
         * @return User
         */
        @Bean // 方法名就是之前xml中 id的值，也可以自定义 @Bean(name="alisName")
        public Person person() {
            return new Person(); // 返回值 相当于class 返回类型
        }
        @Bean
        public Cat cat () {
            return new Cat();
        }
    }

Cat

public class Cat {
        private String name;
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        @Override
        public String toString() {
            return "Cat{" +
                    "name='" + name + '\'' +
                    '}';
        }
    }

Person

public class Person {
        private String name;
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        @Override
        public String toString() {
            return "Person{" +
                    "name='" + name + '\'' +
                    '}';
        }
    }

测试

@SpringBootApplication
    public class BootAndVueProjectApplication {
        private static final Logger LOG = LoggerFactory.getLogger(BootAndVueProjectApplication.class);
        public static void main(String[] args) {
            // 返回IOC容器
            ConfigurableApplicationContext app = SpringApplication.run(BootAndVueProjectApplication.class, args);
            Person person = app.getBean("person", Person.class);
            Cat cat = app.getBean("cat", Cat.class);
            System.out.println(person);
            System.out.println(cat);
        }
    
    }

![20210707213723202.png][]

#  #

# **几个提示点** #

**（1）通过@Configuration配置一个类，里边的所有注册的组件默认是单例模式（调用多少次都会从缓存中获取除了第一次调用）。**

@SpringBootApplication
    public class BootAndVueProjectApplication {
        private static final Logger LOG = LoggerFactory.getLogger(BootAndVueProjectApplication.class);
        public static void main(String[] args) {SpringApplication(BootAndVueProjectApplication.class);
            ConfigurableApplicationContext app = SpringApplication.run(BootAndVueProjectApplication.class, args);
            Person person = app.getBean("person", Person.class);
            Person person1 = app.getBean("person", Person.class);
            System.out.println(person == person1);
        }
    }

![20210707214712715.png][]

**（2）配置类本身也是一个组件**

@SpringBootApplication
    public class BootAndVueProjectApplication {
    
        public static void main(String[] args) {
            ConfigurableApplicationContext app = SpringApplication.run(BootAndVueProjectApplication.class, args);
            ConfigBean configBean = app.getBean(ConfigBean.class);
            System.out.println(configBean);
    }

![20210707215214133.png][]

**（3）springboot 2.0  @Configuration多了一个 这样的属性 proxyBeanMethod :是否代理Bean的方法，默认为true，什么意思？**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNzc4MDAx_size_16_color_FFFFFF_t_70][]

很简单，在外部调用配置类中两个组件的注册方法（person和Cat）时，如果 **proxyBeanMethod** 属性取默认值true，那么不管调用方法多少次，都会取容器中的单实例对象。

@SpringBootApplication
    public class BootAndVueProjectApplication {
        public static void main(String[] args) {
            ConfigurableApplicationContext app = SpringApplication.run(BootAndVueProjectApplication.class, args);
            ConfigBean configBean = app.getBean(ConfigBean.class);
            System.out.println(configBean.person() == configBean.person());
        }
    }

![20210707220652590.png][]

如果 **proxyBeanMethod** 属性为false，每次调用，都会拿到一个新对象

@Configuration(proxyBeanMethods = false)
    public class ConfigBean {// ··· ···}

@SpringBootApplication
    public class BootAndVueProjectApplication {
        public static void main(String[] args) {
    
            ConfigurableApplicationContext app = SpringApplication.run(BootAndVueProjectApplication.class, args);
            ConfigBean configBean = app.getBean(ConfigBean.class);
            System.out.println(configBean.person() == configBean.person());
        }
    }

![20210707221429547.png][]

**（3）有上边 proxyBeanMethod 属性为true，引出一个组件依赖的问题。**

假设Person类中有Cat cat属性，可以理解为这个人 A 想领养了一只猫 B，下边来测试下，在外部通过person来创建这个猫 B，和调用 cat方法来创建猫A，是不是同一只猫呢？

@Configuration(proxyBeanMethods = true)
    public class ConfigBean {
        @Bean
        public Person person() {
            Person person = new Person();
            person.setCat(cat());
            return person;
        }
        @Bean
        public Cat cat () {
            return new Cat();
        }
    }

public class Person {
        private Cat cat;
        public Cat getCat() {
            return cat;
        }
        public void setCat(Cat cat) {
            this.cat = cat;
        }
    }

public class Cat {
    }

测试：

很明显，是同一只猫，这个人领养的这只猫就是B

@SpringBootApplication
    public class BootAndVueProjectApplication {
        public static void main(String[] args) {
            ConfigurableApplicationContext app = SpringApplication.run(BootAndVueProjectApplication.class, args);
            Person person = app.getBean("person", Person.class);
            Cat cat = app.getBean("cat", Cat.class);
            System.out.println(person.getCat() == cat);
        }
    }

![20210707223246686.png][]

当 **proxyBeanMethod 属性为false时，如果组件间存在依赖关系（一个类中属性引用了别的类），每次外部在调用时，都会产生一个新的对象。**

**实际上平时开发，如果配置类中的只是单纯的注册组件的话，通常会把proxyBeanMethod 属性设置为false，如果 proxyBeanMethod = true ，在springboot启动时，每次都会去检查注册组件的方法 在容器中是否存在，启动很慢；如果设置为false，在启动时，会跳过检查容器，启动速度非常快。**

# **向容器注册组件，除了上边@Bean注解，还有以下注解：** #

**@Component、@Controller、@Service、@Repository**

**@Import**

@import注解与上边几个一样，都是把组件注册到IOC容器里边，注解属性默认是数组，里边元素必须为Class类型。  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNzc4MDAx_size_16_color_FFFFFF_t_70 1][]

@Import({Person.class, Cat.class})
    @Configuration(proxyBeanMethods = true)
    public class TestConfig {
    }

public class Cat {
    }

public class Person {
    }

# **@ComponentScan 包扫描** #

@ComponentScan(basePackages="包全路径")

# **@Conditional 条件装配** #

**条件装配：**满足 @Conditional 指定的条件时，则进行组件注入，基于@Conditional 注解衍生出非常多的条件判断注解，springboo源码中有很多基于这个注解的文件类，存在一个按需加载的概念，就是用@Conditional 注解和衍生注解来做的。  
下边以 @ConditionalOnBean 为例 记录下。

// 当容器中存在名字为 user 的组件时，下边所有注册的主键才能生效，否则不生效！
    @ConditionalOnBean(name = {"user"})
    @Import({Person.class, Cat.class})
    @Configuration(proxyBeanMethods = true)
    public class TestConfig {
        @Bean
        public Person person () {
            return new Person();
        }
        @Bean
        public Cat cat () {
            return new Cat();
        }
    }

# **@ImportResource("classpass:beans.xml") 导入spring的xml文件** #

一些老项目，都会使用xml的方式向容器中注册组件 ， 我们可以使用@ImportResource("classpass:beans.xml") 注解的方式去加载xml配置文件来注册组件。

# **配置绑定（获取配置文件中的内容）** #

**有两种方式：**

**方式一：**

如何使用java读取到properties文件中的内容，并把它封装到JavaBean 中，以供随时使用。在springboot中可以使用以下注解非常方便的拿到properties配置文件中的键值对：

### **@ConfigurationProperties(prefix="xxx")   prefix:在配置文件中的属性前缀** ###

Person.java

// 为了方便，不在使用 @Configuration+@Bean方式注册组件，可以直接在类上添加@Component注解
    // ，spring会把这个类直接注册到IOC容器里
    @Component
    @ConfigurationProperties(prefix = "person")
    public class Person {
        private String name;
        private String address;
        
        public String getName() {
            return name;
        }
    
        public String getAddress() {
            return address;
        }
    }

测试

@SpringBootApplication
    public class SprintBoot01Application {
        public static void main(String[] args) {
              ConfigurableApplicationContext ctx = SpringApplication.run(SprintBoot01Application.class, args);
              Person person = ctx.getBean("person", Person.class);
            System.out.println(person.getName());
            System.out.println(person.getAddress());
        }
    }

测试时，发现报了一个错误，仔细琢磨下边这个报错:  
在名为person的组件中 绑定属性失败，下边是配置文件中的键值对，最后一行Reason划重点，原因：address这个属性没有setter方法，原来如此，猜测：springboot底层为每个属性赋值时，使用的是每个属性的settter方法为其赋值，加上属性的settter方法，结果输出了。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNzc4MDAx_size_16_color_FFFFFF_t_70 2][]

@Component
    @ConfigurationProperties(prefix = "person")
    public class Person {
        private String name;
        private String address;
        public void setAddress(String address) {
            this.address = address;
        }
        public void setName(String name) {
            this.name = name;
        }
        public String getName() {
            return name;
        }
        public String getAddress() {
            return address;
        }
    }

![20210708100049144.png][]

**方式二：**

在配置文件中 添加 @EnableConfigurationProperties 注解，开启配置文件与 类的绑定。

// (1)开启配置绑定：把配置文件中的属性与Person类绑定，使用这个注解
    @EnableConfigurationProperties(Person.class)
    @Configuration(proxyBeanMethods = true)
    public class TestConfig {
        @Bean
        public Person person () {
            return new Person();
        }
    }

Person.java

@ConfigurationProperties(prefix = "person")
    public class Person {
        private String name;
        private String address;
    
        public void setAddress(String address) {
            this.address = address;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getName() {
            return name;
        }
    
        public String getAddress() {
            return address;
        }
    }

![20210708101729803.png][]

[20210707213723202.png]: /images/20221005/9b100e20af5c4b8ba6f546d5f23bf667.png
[20210707214712715.png]: /images/20221005/8e6a04f7a7514fad97119295edfeac71.png
[20210707215214133.png]: /images/20221005/2ced84afdd0c4dabb8e0d213bcf041fd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNzc4MDAx_size_16_color_FFFFFF_t_70]: /images/20221005/6bef57a8227a49e1ae3b2ff737247bd0.png
[20210707220652590.png]: /images/20221005/42f75d1343eb4c3faa2dcb2f81e15b1d.png
[20210707221429547.png]: /images/20221005/37d166205dc74a58b328d9cfd687b888.png
[20210707223246686.png]: /images/20221005/a8bbd8b47d784e13b3c66fda06d333dd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNzc4MDAx_size_16_color_FFFFFF_t_70 1]: /images/20221005/30c8d228b6264faf9fbb2ca1359a39a1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNzc4MDAx_size_16_color_FFFFFF_t_70 2]: /images/20221005/88c2a09fd5944489bad97ad350bc06b2.png
[20210708100049144.png]: /images/20221005/10504506bbb34aabab3997f6a78546eb.png
[20210708101729803.png]: /images/20221005/0425af471dd648b0a9b8cd4c06514a81.png

发表评论取消回复

表情：

评论列表（有 0 条评论，172人围观）

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

相关阅读

相关 SpringBoot-底层注解-@configuration

底层注解：@configuration 先前说明用在Config类中，用于添加组件，类似于传统的配置xml文件，Config下还有一个@Bean注解用来注册组件

傷城~/ 2023年10月04日 13:27/ 0 赞/ 44 阅读

相关 Servlet注解底层模拟

我们知道在web开发中配置Servlet有2种方式，一种是xml，另外一种是注解开发，前面我们已经使用java读取过xml文件，xml配置方式的原理比较清晰了，但是注解一直比

小鱼儿/ 2023年10月01日 20:19/ 0 赞/ 2 阅读

相关 SpringBoot底层注解详解

一、 @Configuration 我们先来看看，以前我们用spring是怎么配置bean的属性值： ![format_png][] 虽然不算多，但是如果每一个bea

冷不防/ 2023年09月27日 22:12/ 0 赞/ 151 阅读

相关底层注解

文章目录 @Component & @Service & @Controller & @Repository @AutoWired & @Qua

柔光的暖阳◎/ 2022年11月05日 00:53/ 0 赞/ 199 阅读

相关 @EventListener注解 -【Spring底层原理】

目录一、注解用法二、实例分析三、源码分析四、总结 -------------------- > 上篇我们讲到实现事件监听可以使用实现Applic

以你之姓@/ 2021年09月21日 21:38/ 0 赞/ 464 阅读

相关 @Profile注解 -【Spring底层原理】

目录 @Profile注解 -【Spring底层原理】一、注解用法二、实例分析三、源码追踪四、总结 -------------------- 一、注解用

╰+哭是因爲堅強的太久メ/ 2021年09月21日 21:01/ 0 赞/ 450 阅读

相关 @Import注解 -【Spring底层原理】

目录一、注解用法二、实例分析三、源码追踪 -------------------- 一、注解用法 > @Import注解也是用来给容器注册组件的，使

小灰灰/ 2021年09月21日 17:52/ 0 赞/ 387 阅读

相关 @Conditional注解 -【Spring底层原理】

> 案例已上传GitHub，欢迎star以鼓励：[https://github.com/oneStarLR/spring-annotation][https_github.co

r囧r小猫/ 2021年09月21日 17:36/ 0 赞/ 417 阅读

相关 @Scope注解、@Lazy注解 -【Spring底层原理】

目录一、注解用法二、实例分析三、源码追踪四、总结 -------------------- 一、注解用法【1】@Scope注解 @Scope注解是

向右看齐/ 2021年09月21日 17:32/ 0 赞/ 625 阅读

相关 @Configuration注解 -【Spring底层原理】

一、注解用法 1. 知识背景 > `lite @Bean mode` ：当`@Bean`方法在没有使用`@Configuration`注解的类中声明时称之为`

亦凉/ 2021年09月21日 15:30/ 1 赞/ 937 阅读