三. Spring Boot 当中的“容器功能” 和 “配置绑定” 的详细剖析(附+源代码流程)

---

1. Spring Boot 是继续支持了 Spring 当中的注解的

1.2 Spring 当中的 @Component，@Controller，@Service，@Repository

Spring 注入组件的注解：

• @Component
• @Controller
• @Service
• @Repository

这些在 Spring 中传统的注解仍然有效，通过这些注解可以给容器注入组件。

演示测试：

这里我们仅仅测试一下 ，@Repository 注解，另外三个就不测试了，都是可以的。

1. 首先，我们在 springboot 目录下，创建好一个bean 包，用于统一存放 Bean对象的类。

2. 同时在该 bean 创建一个 A 类，同时给予上 @Repository 注解。

package com.rainbowsea.springboot.bean;


import org.springframework.stereotype.Repository;

@Repository
public class A {
}

---

3. 在主程序中编写，测试获取该 A bean 类，看看是否被加入到了 ioc 容器管理起来了。

package com.rainbowsea.springboot;


import com.rainbowsea.springboot.bean.A;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;


// @SpringBootApplication  表示是一个 springboot 应用
// 直接在    SpringBootApplication 注解后指定,让 Spring Boot 要扫描到的包路径
 @SpringBootApplication(scanBasePackages = {"com.rainbowsea"})
public class MainApp {
    public static void main(String[] args) {
        // 启动 SpringBoot 应用程序
        ConfigurableApplicationContext ioc = SpringApplication.run(MainApp.class, args);

        // 演示Spring中传统的注解依然可以使用 @Controller,@Service, @Repository,@Component  start
        A aBean = ioc.getBean(A.class);
        System.out.println("aBean --" + aBean);

        // 演示Spring中传统的注解依然可以使用 @Controller,@Service, @Repository,@Component  end
    }
}

4. 运行测试：

1.3 Spring Boot 中的 @Configuration

在Spring Boot当中可以通过 @Configuration注解来创建定义配置类，从而注入 Bean /组件

我们先来回顾传统方式如何通过配置文件(xml)注入组件/ 注入 Bean 对象，进行一个对比。

1. 创建一个 名为 Monster的类 / Bean 对象

package com.rainbowsea.springboot.bean;


import org.springframework.stereotype.Repository;


public class Monster {

    private Integer id;
    private String name;
    private Integer age;
    private String skill;

    public Monster() {
    }

    public Monster(Integer id, String name, Integer age, String skill) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.skill = skill;
    }

    @Override
    public String toString() {
        return "Monster{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", skill='" + skill + '\'' +
                '}';
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getSkill() {
        return skill;
    }

    public void setSkill(String skill) {
        this.skill = skill;
    }
}

2. 在 resources 类路径下，创建一个名为 beans.xml 文件，为上述的 Monster 类/bean对象，进行一个 set 注入，纳入到 ioc 容器当中进行管理。
   

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

<!--    通过 xml 配置 Monster bean 注入到 ioc 容器当中去-->
    <bean id="monster03" class="com.rainbowsea.springboot.bean.Monster">
<!--       set 注入的方式-->
        <property name="name" value="牛魔王"></property>
        <property name="age" value="5000"></property>
        <property name="skill" value="封魔拳"></property>
        <property name="id" value="1000"></property>
    </bean>

</beans>

3. 在主程序当中，获取该 bean 对象，看看是否 set 注入成功了。

package com.rainbowsea.springboot;


import com.rainbowsea.springboot.bean.A;
import com.rainbowsea.springboot.bean.Monster;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;


// @SpringBootApplication  表示是一个 springboot 应用
// 直接在    SpringBootApplication 注解后指定,让 Spring Boot 要扫描到的包路径
 @SpringBootApplication(scanBasePackages = {"com.rainbowsea"})
public class MainApp {
    public static void main(String[] args) {
        // 启动 SpringBoot 应用程序
        ConfigurableApplicationContext ioc = SpringApplication.run(MainApp.class, args);

        // 演示在Spring Boot 项目中，依然可以使用Spring的配置bean/注入bean/获取bean方式 start
        ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");
        //ac.getBean("xml中配置的id",class)
        Monster monster03 = ac.getBean("monster03", Monster.class);
        System.out.println("monster03--" + monster03);
        // 演示在Spring Boot 项目，依然可以使用Spring的配置bean/注入bean/获取bean方式  end

        
    }
}

4. 运行测试：

使用 SpringBoot 的@Configuration 添加/注入组件

1. 创建一个 config 包，在该包下创建一个名为 Beanconfig 的类

2. 在该类上标注上： @Configuration 注解：

@Configuration 标识这是一个配置类: 等价 配置文件。

程序员可以通过 @Bean 注解注入 bean对象到 ioc 容器当中

当一个类被 @Configuration 标识，则该类-Bean ，也会注入到容器当中，以配置类的形式存在于其中

3. 在 BeanConfig 当中定义一个方法，同时在该方法上 加上 @Bean 注解。

@Bean ： 给容器添加组件，就是 Monster bean。

monster01() ： 默认：你的方法名monster01，作为 Bean 的名字/id

这里：我们

monster01() ： 默认：你的方法名monster01，作为 Bean 的名字/id

new Monster(2000,“牛魔王”,5000,“芭蕉扇”) 注入到容器中具体的 Bean 信息

package com.rainbowsea.springboot.config;


import com.rainbowsea.springboot.bean.Monster;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;


/*
1. @Configuration  标识这是一个配置类: 等价  配置文件
2. 程序员可以通过 @Bean 注解注入bean对象到容器中
3. 当一个类被 @Configuration 标识，则该类-Bean ，也会注入到容器当中，以配置类的形式存在于其中
*/

@Configuration
public class BeanConfig {


    /*
    * 解读:
    * 1. @Bean ： 给容器添加组件，就是 Monster bean
    * 2. monster01() ： 默认：你的方法名monster01，作为 Bean 的名字/id
    * 3. Monster: 注入类型，注入的bean的类型是Monster
    * 4. new Monster(2000,"牛魔王",5000,"芭蕉扇") 注入到容器中具体的Bean 信息
    * 5.     @Bean(name = {"monster_nmw"}) 在配置，注入Bean指定名字/id ，name是数组类型，可以定义多个
    * 6. 默认是单例注入的：（也就是说 getBean 获取到的都是同一个对象，共用）
    * 7. 通过    @Scope(value = "prototype") 可以每次返回一个新的对象，多例
    * */

    @Bean
    public Monster monster01(){
        return new Monster(2000,"牛魔王",5000,"芭蕉扇");
    }




}

3. 运行测试：
   

package com.rainbowsea.springboot;


import com.rainbowsea.springboot.bean.A;
import com.rainbowsea.springboot.bean.Monster;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;


// @SpringBootApplication  表示是一个 springboot 应用
// 直接在    SpringBootApplication 注解后指定,让 Spring Boot 要扫描到的包路径
 @SpringBootApplication(scanBasePackages = {"com.rainbowsea"})
public class MainApp {
    public static void main(String[] args) {
        // 启动 SpringBoot 应用程序
        ConfigurableApplicationContext ioc = SpringApplication.run(MainApp.class, args);

        // 演示 Spring Boot 项目中：     @Bean的方式 start
        Monster monster01 = ioc.getBean("monster01", Monster.class);
        System.out.println("monster01 --- " + monster01);

        // 演示 Spring Boot 项目中：     @Bean的方式 end


    }
}

1.3.1 @Bean 注解补充说明

1. @Bean ： 给容器添加组件，就是 Monster bean
2. monster01() ： 默认：你的方法名monster01，作为 Bean 的名字/id
3. Monster: 注入类型，注入的bean的类型是 Monster
4. new Monster(2000,“牛魔王”,5000,“芭蕉扇”) 注入到容器中具体的Bean 信息
5. @Bean(name = {“monster_nmw”}) 在配置，注入Bean指定名字/id ，name是数组类型，可以定义多个。如果 @Bean 没有指定 name/value的话，那么方法名 就是默认的 name/value属性的值 作为 id/名称 进行获取使用。

package com.rainbowsea.springboot.config;


import com.rainbowsea.springboot.bean.Monster;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;


/*
1. @Configuration  标识这是一个配置类: 等价  配置文件
2. 程序员可以通过 @Bean 注解注入bean对象到容器中
3. 当一个类被 @Configuration 标识，则该类-Bean ，也会注入到容器当中，以配置类的形式存在于其中
*/

@Configuration
public class BeanConfig {


    /*
    * 解读:
    * 1. @Bean ： 给容器添加组件，就是 Monster bean
    * 2. monster01() ： 默认：你的方法名monster01，作为 Bean 的名字/id
    * 3. Monster: 注入类型，注入的bean的类型是Monster
    * 4. new Monster(2000,"牛魔王",5000,"芭蕉扇") 注入到容器中具体的Bean 信息
    * 5.     @Bean(name = {"monster_nmw"}) 在配置，注入Bean指定名字/id ，name是数组类型，可以定义多个
    * 6. 默认是单例注入的：（也就是说 getBean 获取到的都是同一个对象，共用）
    * 7. 通过    @Scope(value = "prototype") 可以每次返回一个新的对象，多例
    * */

    @Bean(name = {"monster_nmw"})
    public Monster monster01(){
        return new Monster(2000,"牛魔王",5000,"芭蕉扇");
    }




}

package com.rainbowsea.springboot;


import com.rainbowsea.springboot.bean.A;
import com.rainbowsea.springboot.bean.Monster;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;


// @SpringBootApplication  表示是一个 springboot 应用
// 直接在    SpringBootApplication 注解后指定,让 Spring Boot 要扫描到的包路径
 @SpringBootApplication(scanBasePackages = {"com.rainbowsea"})
public class MainApp {
    public static void main(String[] args) {
        // 启动 SpringBoot 应用程序
        ConfigurableApplicationContext ioc = SpringApplication.run(MainApp.class, args);

        // 演示 Spring Boot 项目中：     @Bean(name = {"monster_nmw"}) 自定义别名的方式 start
        Monster monster_nmw = ioc.getBean("monster_nmw", Monster.class);
        System.out.println("monster_nmw --- " + monster_nmw);
        // 演示 Spring Boot 项目中：     @Bean(name = {"monster_nmw"}) 自定义别名的方式 end



    }
}

---

6. 默认是单例注入的：（也就是说 getBean 获取到的都是同一个对象，共用）

// @SpringBootApplication  表示是一个 springboot 应用
// 直接在    SpringBootApplication 注解后指定,让 Spring Boot 要扫描到的包路径
 @SpringBootApplication(scanBasePackages = {"com.rainbowsea"})
public class MainApp {
    public static void main(String[] args) {
        // 启动 SpringBoot 应用程序
        ConfigurableApplicationContext ioc = SpringApplication.run(MainApp.class, args);

        // 演示 @Configuration start
        Monster monster01 = ioc.getBean("monster01", Monster.class);
        Monster monster02 = ioc.getBean("monster01", Monster.class);
        System.out.println("monster01 ---" + monster01 + " " + monster01.hashCode());
        System.out.println("monster02 ---" + monster02 + " " + monster02.hashCode());

        // 特别说明：默认Spring Boot 是单例获取的 Bean对象的，叶就是获取到的Bean是同一个对象
        // 在对应的 Config配置类中定义：  @Scope(value = "prototype") 就是多例的了。
        // 演示 @Configuration end




    }
}

7. 通过 @Scope(value = “prototype”) 可以每次返回一个新的对象，多例
   

8. 可以通过 @Bean配置多个 bean 对象。都是纳入到 ioc 容器当中进行管理起来的。

1.3.2 @Configuration 补充说明和注意事项，以及细节内容

1. @Configuration 标识这是一个配置类: 等价 配置文件
2. 程序员可以通过 @Bean 注解注入bean对象到容器中
3. 当一个类被 @Configuration 标识，则该类-Bean ，也会注入到容器当中，以配置类的形式存在于其中
4. @Configuration 修饰标识的配置类-bean,也会被注入到ioc容器当中。这也是正常，可以理解的，因为你需要读取配置类上的信息，你不加入到 ioc 容器当中，Spring Boot 又怎么读取呢？

5. 可以通过@Configuration ，定义多个配置类, 就和 Spring 可以有多个 ioc 配置文件是一个道理。同样的该多个配置类，也都会纳入到 ioc 容器当中进行管理起来。

6. @Configuration 注意事项和细节： 自定义配置类的

1. @Configuration 中有一个属性 proxyBeanMethods : 代理bean的方法。

2. Full(proxyBeanMethods = true) 单例：保证每个@Bean方法被调用多少次返回的组件都是单实例的，是代理方式，是共用的 // 默认就是
3. Lite(proxyBeanMethods = false) 多例： 每个@Bean方法被调用多少次，返回的组件都是新创建的，是非代理方式 ，非共用的，特别说明：proxyBeanMethods 是在调用 @Bean方法才生效，因此，需要先获取到对应 BeanConfig(配置类的组件)，再从配置类组件的方法中，调用方法，获取到的Bean，而不是直接通过 SpringBoot 主程序的 ioc,getBean()直接得到容器来获取 bean,
4. 注意观察直接通过ioc.getBean()获取 Bean, proxyBeanMethods 值并没有生效。
5. 需要注意的是：@Configuration 是定义在类上的，所以配置 proxyBeanMethods 是应用 到该@Configuration注解标注的类当中的所有的方法上的 。
6. 如何选择：组件依赖必须使用Full模式(默认就是 full模式)，如果不需要组件依赖使用 Lite模式
7. 当然，如果你仅仅只想要其中的一个对象，进行多例的话，就采用，@Scope("prototype") 在该返回对象的方法上，添加上该注解即可
8. Lite 模式也称之为：“轻量级模式”，因为不检测依赖关系，运行速度快。

Full(proxyBeanMethods = true) 单例：保证每个@Bean方法被调用多少次返回的组件都是单实例的，是代理方式，是共用的 。记得把上面测试的，@Scope(value = “prototype”) 多例给去了

package com.rainbowsea.springboot.config;


import com.rainbowsea.springboot.bean.Monster;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;


/*
1. @Configuration  标识这是一个配置类: 等价  配置文件
2. 程序员可以通过 @Bean 注解注入bean对象到容器中
3. 当一个类被 @Configuration 标识，则该类-Bean ，也会注入到容器当中，以配置类的形式存在于其中
*/

@Configuration(proxyBeanMethods = true)  // 默认就是 true
public class BeanConfig {


    /*
    * 解读:
    * 1. @Bean ： 给容器添加组件，就是 Monster bean
    * 2. monster01() ： 默认：你的方法名monster01，作为 Bean 的名字/id
    * 3. Monster: 注入类型，注入的bean的类型是Monster
    * 4. new Monster(2000,"牛魔王",5000,"芭蕉扇") 注入到容器中具体的Bean 信息
    * 5.     @Bean(name = {"monster_nmw"}) 在配置，注入Bean指定名字/id ，name是数组类型，可以定义多个
    * 6. 默认是单例注入的：（也就是说 getBean 获取到的都是同一个对象，共用）
    * 7. 通过    @Scope(value = "prototype") 可以每次返回一个新的对象，多例
    * */

    @Bean(name = {"monster01"})
    public Monster monster01(){
        return new Monster(2000,"牛魔王",5000,"芭蕉扇");
    }




}

package com.rainbowsea.springboot;


import com.rainbowsea.springboot.bean.A;
import com.rainbowsea.springboot.bean.Monster;
import com.rainbowsea.springboot.config.BeanConfig;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;


// @SpringBootApplication  表示是一个 springboot 应用
// 直接在    SpringBootApplication 注解后指定,让 Spring Boot 要扫描到的包路径
 @SpringBootApplication(scanBasePackages = {"com.rainbowsea"})
public class MainApp {
    public static void main(String[] args) {
        // 启动 SpringBoot 应用程序
        ConfigurableApplicationContext ioc = SpringApplication.run(MainApp.class, args);

        // 演示@Configuration(ProxyBeanMethods = xxx) 单例/ 多例的设置  start

        // 先得到 BeanConfig 组件，再从 BeanConfig 组件中调用方法获得其它的Bean
        BeanConfig beanConfig = ioc.getBean(BeanConfig.class);

        Monster monster_01 = beanConfig.monster01();
        Monster monster_02 = beanConfig.monster01();

        System.out.println("monster_01 " + monster_01 + " " + monster_01.hashCode());
        System.out.println("monster_02 " + monster_02 + " " + monster_02.hashCode());
        // 演示@Configuration(ProxyBeanMethods = xxx) 单例/ 多例的设置  end
    }
}

---

Lite(proxyBeanMethods = false) 多例： 每个@Bean方法被调用多少次，返回的组件都是新创建的，是非代理方式 ，非共用的，特别说明：proxyBeanMethods 是在调用 @Bean方法才生效，因此，需要先获取到对应 BeanConfig(配置类的组件)，再从配置类组件的方法中，调用方法，获取到的Bean，而不是直接通过 SpringBoot 主程序的 ioc,getBean()直接得到容器来获取 bean,

注意观察直接通过ioc.getBean()获取 Bean, proxyBeanMethods 值并没有生效。

注意观察直接通过ioc.getBean()获取 Bean, proxyBeanMethods 值并没有生效。

package com.rainbowsea.springboot;


import com.rainbowsea.springboot.bean.A;
import com.rainbowsea.springboot.bean.Monster;
import com.rainbowsea.springboot.config.BeanConfig;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;


// @SpringBootApplication  表示是一个 springboot 应用
// 直接在    SpringBootApplication 注解后指定,让 Spring Boot 要扫描到的包路径
 @SpringBootApplication(scanBasePackages = {"com.rainbowsea"})
public class MainApp {
    public static void main(String[] args) {
        // 启动 SpringBoot 应用程序
        ConfigurableApplicationContext ioc = SpringApplication.run(MainApp.class, args);

        // 演示@Configuration(ProxyBeanMethods = xxx) 单例/ 多例的设置  start

        // 特别说明: proxyBeanMethods 是在调用@Bean方法才生效，因此，需要先获取BeanConfig 组件，再调用其中BeanConfig配置类组件中的方法获取
        // 1. 而不是直接通过 SpringBoot 主程序得到的容器来获取Bean(ioc.getBean())，注意观察直接通过ioc.getBean()获取是@Configuration
        // (ProxyBeanMethods = xxx) 属性配置是失效的（还是默认的单例）
        Monster monster01 = ioc.getBean("monster01", Monster.class);
        Monster monster02 = ioc.getBean("monster01", Monster.class);

        System.out.println("monster01 " + monster01 + " " + monster01.hashCode());
        System.out.println("monster02 " + monster02 + " " + monster02.hashCode());

    }
}

1.4 Spring Boot 中的@Import

@Import 也是可以注入组件/就是实现 Bean 对象纳入到 ioc 容器当中进行管理。

注意 @Import方式注入的组件/ 纳入 ioc 容器，获取默认组件/Bean对象时，用的名字就是该对应类的全类名。

注意需要在 @Configuration 定义的配置类上的基础上，配置 @Import 才行

package com.rainbowsea.springboot.config;


import com.rainbowsea.springboot.bean.Cat;
import com.rainbowsea.springboot.bean.Dog;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;

@Import(value = {Cat.class, Dog.class})  // 这样就拿到 ioc 容器到中去了。就可以被获取到了
@Configuration // 标识这是一个配置类
public class BeanConfig03 {
}

package com.rainbowsea.springboot;


import com.rainbowsea.springboot.bean.A;
import com.rainbowsea.springboot.bean.Cat;
import com.rainbowsea.springboot.bean.Dog;
import com.rainbowsea.springboot.bean.Monster;
import com.rainbowsea.springboot.config.BeanConfig;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;


// @SpringBootApplication  表示是一个 springboot 应用
// 直接在    SpringBootApplication 注解后指定,让 Spring Boot 要扫描到的包路径
 @SpringBootApplication(scanBasePackages = {"com.rainbowsea"})
public class MainApp {
    public static void main(String[] args) {
        // 启动 SpringBoot 应用程序
        ConfigurableApplicationContext ioc = SpringApplication.run(MainApp.class, args);


        //  测试 @Import 使用 start
        Dog dogBean = ioc.getBean(Dog.class);
        Cat catBean = ioc.getBean(Cat.class);
        System.out.println("doBean -- " + dogBean);
        System.out.println("catBean--" + catBean);
        //  测试 @Import 使用 end

    }
}

运行测试：

1.5 Spring Boot 中的 @Conditional

@Conditional 是一个 条件装配：满足 Conditional 指定的条件，则进行组件注入(注入到 ioc 容器中，被 ioc 容器进行管理起来)。

@Conditional 是一个根注解，下面有很多扩展注解

演示在 SpringBoot, 如何通过 @ConditionalOnBean 来注入组件

**只有在容器中有 name = monster_nmw 组件时，才注入 dog01，使用 @ConditionalOnBean 注解中的 name 属性进行处理 **

package com.rainbowsea.springboot.config;


import com.rainbowsea.springboot.bean.Cat;
import com.rainbowsea.springboot.bean.Dog;
import com.rainbowsea.springboot.bean.Monster;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;


/*
1. @Configuration  标识这是一个配置类: 等价  配置文件
2. 程序员可以通过 @Bean 注解注入bean对象到容器中
3. 当一个类被 @Configuration 标识，则该类-Bean ，也会注入到容器当中，以配置类的形式存在于其中
*/

@Configuration(proxyBeanMethods = false)  // 默认就是 true
public class BeanConfig {


    /*
    * 解读:
    * 1. @Bean ： 给容器添加组件，就是 Monster bean
    * 2. monster01() ： 默认：你的方法名monster01，作为 Bean 的名字/id
    * 3. Monster: 注入类型，注入的bean的类型是Monster
    * 4. new Monster(2000,"牛魔王",5000,"芭蕉扇") 注入到容器中具体的Bean 信息
    * 5.     @Bean(name = {"monster_nmw"}) 在配置，注入Bean指定名字/id ，name是数组类型，可以定义多个
    * 6. 默认是单例注入的：（也就是说 getBean 获取到的都是同一个对象，共用）
    * 7. 通过    @Scope(value = "prototype") 可以每次返回一个新的对象，多例
    * */

    @Bean(name = {"monster_nmw"})
    //@Scope(value = "prototype")
    public Monster monster01(){
        return new Monster(2000,"牛魔王",5000,"芭蕉扇");
    }


    /**
     * 1.@ConditionalOnBean(name="monster_nmw") 表示
     * 2.当容器中有一个Bean，名字是monster_nmw(类型不做约束，仅仅是 id /名字做约束)，就注入dog01这个Dog bean
     * 3.如果ioc容器中，并没有一个叫 "monster_nmw" 的对象，该 Dog就不会注入 dog01的这个 Dog bean 对象到 ioc 容器当中
     * 4. 还有很多其它的条件约束注解，小伙伴可以自己测试
     * 5.注意：使用 @ConditionalOnBean 的同时，要将 @import 注解去了，因为 @import可以实现 ioc注入
     * 6. 注意：满足条件的，要放到判断的前面，简单的说就是，作为条件的bean要放到判断的bean的前面，不然是无法判断的
     * 7.     @ConditionalOnMissingBean(name = {"monster_nmw"})  没有名字/id 为 monster_nmw 才注入 dog01这个 Bean
     * 8. @ConditionalOnBean(name = {"monster_nmw"}) 也可以放在配置类，类的上面
     * 表示对该配置类的所有要注入的组件，都进行条件约束。
     * @return
     */
    @Bean  // 没有指明 name/value 则，默认方法名就是，获取对应 bean的名称/id
    @ConditionalOnBean(name = {"monster_nmw"})  // name 属性是个数组，可以写多个条件
    public Dog dog01() {
        return new Dog();
    }

}

运行测试：

@ConditionalOnBean(name="monster_nmw") 表示
当容器中有一个Bean，名字是monster_nmw(类型不做约束，仅仅是 id /名字做约束)，就注入dog01这个Dog bean

运行测试：

还有一个名为 @ConditionalOnMissingBean的注解，与 .@ConditionalOnBean 相反。 ，表示@ConditionalOnMissingBean “表示非，就是没有该 name 上的属性的值的时候，该 Bean 就会被 ioc 容器管理起来”。

运行测试：

---

@Conditional小总结：

1. @ConditionalOnBean(name=“monster_nmw”) 表示
2. 当容器中有一个Bean，名字是monster_nmw(类型不做约束，仅仅是 id /名字做约束)，就注入dog01这个Dog bean；如果ioc容器中，并没有一个叫 “monster_nmw” 的对象，该 Dog就不会注入 dog01的这个 Dog bean 对象到 ioc 容器当中
3. 注意：使用 @ConditionalOnBean 的同时，要将 @import 注解去了，因为 @import可以实现 ioc注入
4. 注意：满足条件的，要放到判断的前面，简单的说就是，作为条件的bean要放到判断的bean的前面，不然是无法判断的
5. @ConditionalOnMissingBean(name = {“monster_nmw”}) 没有名字/id 为 monster_nmw 才注入 dog01这个 Bean；
6. @ConditionalOnBean(name = {“monster_nmw”}) 也可以放在配置类，类的上面示对该配置类的所有要注入的组件，都进行条件约束。
7. 还有很多其它的条件约束注解，小伙伴可以自己测试。

1.6 Spring Boot 中的 @ImportResource

@ImportResource 作用：原生配置文件引入，也就是可以直接导入 **Spring ** 传统的 beans.xml ，可以认为是 Spring Boot 对 Spring 容器文件的兼容。

演示： 将 beans.xml 导入到 BeanConfig.java 配置类，获取到 beanx.xml 注入/配置的组件。

这里我们创建新的 BeanConfig3.java(建议创建新的配置类) 来测试, 使用@ImportResource 导入 beans.xml

package com.rainbowsea.springboot.config;


import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.ImportResource;

@Configuration  // 标注配置类
// 导入 beans.xml 就可以获取到 beans.xml 中配置 bean
// 就是导入在 beans.xml 文件中配置的的 bean对象里面是 monster03 对象bena
// 注意：不要忘记了 Spring ，通过 xml 文件也是可以导入到 ioc 容器当中的
// locations 是数组类型，可以配置多个
// 流程是：在配置类当中——> 添加上@ImportResource(指明bean 的xml 路径，一般是类路径下，通过xml实现的bean 加入到ioc)
@ImportResource(locations = {"classpath:beans.xml","classpath:beans02.xml"})
public class BeanConfig3 {
}

package com.rainbowsea.springboot;


import com.rainbowsea.springboot.bean.A;
import com.rainbowsea.springboot.bean.Cat;
import com.rainbowsea.springboot.bean.Dog;
import com.rainbowsea.springboot.bean.Monster;
import com.rainbowsea.springboot.config.BeanConfig;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;


// @SpringBootApplication  表示是一个 springboot 应用
// 直接在    SpringBootApplication 注解后指定,让 Spring Boot 要扫描到的包路径
 @SpringBootApplication(scanBasePackages = {"com.rainbowsea"})
public class MainApp {
    public static void main(String[] args) {
        // 启动 SpringBoot 应用程序
        ConfigurableApplicationContext ioc = SpringApplication.run(MainApp.class, args);

        // 演示 @ImportResource 使用 start
        Monster monster03 = ioc.getBean("monster03", Monster.class);
        System.out.println("monster03-" + monster03);
        System.out.println("monster03 bean 是否存在到 ioc 容器中" + ioc.containsBean("monster03"));

        // 演示 @ImportResource 使用 end

    }
}

@ImportResource 简单的说就是：可以通过@ImportResource 注解，到配置类上，在配置类上指定 配置好的 Bean 对象的 xml 文件，就可以将该 Bean 对象放入到 ioc 容器当中，同时又可以被获取到。

2. Spring Boot 中的 配置绑定

2.1 使用 Java 读取到 Spring Boot 核心配置文件 application.propert

简单的说：就是一句话：使用Java读取到 Spring Boot 核心配置文件application.properties 的内容，并且把它封装到对应的 JavaBean 当中去。

演示： 将 application.properties 指定 k-v 和 JavaBean 绑定。

1. 在 bean目录下，创建一个 Furn 类。

package com.rainbowsea.springboot.bean;

public class Furn {
    private Integer id;
    private String name;
    private Double price;


    public Furn() {
    }

    public Furn(Integer id, String name, Double price) {
        this.id = id;
        this.name = name;
        this.price = price;
    }


    @Override
    public String toString() {
        return "Furn{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", price=" + price +
                '}';
    }


    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Double getPrice() {
        return price;
    }

    public void setPrice(Double price) {
        this.price = price;
    }
}

2. 在application.properties 文件当中配置 注入到 Furn 类属性当中值。

# 设置Furn的属性k-v
# 前面的furn01 是用于指定/区别不同绑定对象，这样可以再绑定Furn bean 属性值时
# 通过 furn01 前缀进行区分
# 不要有空格
# furn01.id 中的id，就是你要绑定的Furn bean 的属性名，不可以随便写，如果写错了，对应不上，那么对应的bean对象中的属性就为 null了
furn01.id=100
furn01.name=TV
furn01.price=100.99

3. 在 Furn 类上添加：@ConfigurationProperties 注解：
4. 

格式

@ConfigurationProperties（prefix = "在application.properties文件当中配置的前缀"）

package com.rainbowsea.springboot.bean;


import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Component // 注入到 ioc 容器当中
@ConfigurationProperties(prefix = "furn01")  // prefix = "前缀"
public class Furn {
    private Integer id;
    private String name;
    private Double price;


    public Furn() {
    }

    public Furn(Integer id, String name, Double price) {
        this.id = id;
        this.name = name;
        this.price = price;
    }


    @Override
    public String toString() {
        return "Furn{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", price=" + price +
                '}';
    }


    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Double getPrice() {
        return price;
    }

    public void setPrice(Double price) {
        this.price = price;
    }
}

5. 装配上 Furn 类。我们将其显示到浏览器上（以 JSON的方式显示）

package com.rainbowsea;


import com.rainbowsea.springboot.bean.Furn;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.annotation.Resource;

@Controller // 注入到 ioc 容器当中
public class HiController {


    //将 Furn  装配到 HiController 类当中
    // 装配完了，则furn 类的属性值，就是你在 application.properties当中配置的值
    @Resource
    private Furn furn;




    @RequestMapping("/furn")  // 映射路径
    @ResponseBody  // 表示返回的是一个json/字符串，不是一个页面
    public Furn furn(){
        return furn;
    }

}

6. 启动运行测试：

​

其实配置绑定还有第2种方式，只是这种方式不常用，这里我们也学习一下，效果是一样的。

注意：使用该方式，需要注销掉 Furn 也就是(对应Bean类)上的 @Compoent 注解，否则会报错。

然后我们需要在一个 **配置类**上加上一个 @EnableConfigurationProperties(对应的Bean.class)注解

package com.rainbowsea.springboot.config;


import com.rainbowsea.springboot.bean.Furn;
import com.rainbowsea.springboot.bean.Monster;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration  // 标注是配置类
@EnableConfigurationProperties({Furn.class})
public class BeanConfig02 {

}

运行测试：

2.2 配置绑定的“注意事项和细节”

1. 如果 application.properties 有中文, 需要转成 unicode 编码写入, 否则出现乱码

解决方法：

我们只需要去网上随便找一个，可以将 中文转换为 unicode编码 的网站，将转换为的 unicode 复制替换一下就OK了。

运行测试：

2. furn01.id 中的id，就是你要绑定的Furn bean 的属性名，不可以随便写，如果写错了，对应不上，那么对应的bean对象中的属性就为 null了

测试：

3. 使用 @ConfigurationProperties(prefix = “furn01”) 会提示如下信息 但是不会影响使用
   

解决方法：

解决 @ConfigurationProperties(prefix = “furn01”) 提示信息, 在 pom.xml 增加依赖, 即可

依赖如下：

  <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId> <optional>true</optional>
        </dependency>

3. 总结：

1. Spring Boot 是继续支持了 Spring 当中的注解的：例如：@Component，@Controller，@Service，@Repository。
2. @Configuraion注解：在Spring Boot当中可以通过 @Configuration注解来创建定义配置类，从而注入 Bean / 组件

1. @Configuration 标识这是一个配置类: 等价 配置文件
2. 程序员可以通过 @Bean 注解注入bean对象到容器中
3. 当一个类被 @Configuration 标识，则该类-Bean ，也会注入到容器当中，以配置类的形式存在于其中
4. @Configuration 修饰标识的配置类-bean,也会被注入到ioc容器当中。这也是正常，可以理解的，因为你需要读取配置类上的信息，你不加入到 ioc 容器当中，Spring Boot 又怎么读取呢？
5. 可以通过@Configuration ，定义多个配置类, 就和 Spring 可以有多个 ioc 配置文件是一个道理。同样的该多个配置类，也都会纳入到 ioc 容器当中进行管理起来。
6. @Configuration 注意事项和细节： 自定义配置类的

@Configuration 中有一个属性 proxyBeanMethods : 代理bean的方法。

2. Full(proxyBeanMethods = true) 单例：保证每个@Bean方法被调用多少次返回的组件都是单实例的，是代理方式，是共用的 // 默认就是
3. Lite(proxyBeanMethods = false) 多例： 每个@Bean方法被调用多少次，返回的组件都是新创建的，是非代理方式 ，非共用的，特别说明：proxyBeanMethods 是在调用 @Bean方法才生效，因此，需要先获取到对应 BeanConfig(配置类的组件)，再从配置类组件的方法中，调用方法，获取到的Bean，而不是直接通过 SpringBoot 主程序的 ioc,getBean()直接得到容器来获取 bean,
4. 注意观察直接通过ioc.getBean()获取 Bean, proxyBeanMethods 值并没有生效。
5. 需要注意的是：@Configuration 是定义在类上的，所以配置 proxyBeanMethods 是应用 到该@Configuration注解标注的类当中的所有的方法上的 。
6. 如何选择：组件依赖必须使用Full模式(默认就是 full模式)，如果不需要组件依赖使用 Lite模式
7. 当然，如果你仅仅只想要其中的一个对象，进行多例的话，就采用，@Scope("prototype") 在该返回对象的方法上，添加上该注解即可
8. Lite 模式也称之为：“轻量级模式”，因为不检测依赖关系，运行速度快。

3. @Bean ： 给容器添加组件，就是 Monster bean。@Configuration 注解是配合 @Bean 使用的

1. @Bean ： 给容器添加组件，就是 Monster bean
2. monster01() ： 默认：你的方法名monster01，作为 Bean 的名字/id
3. Monster: 注入类型，注入的bean的类型是 Monster
4. new Monster(2000,“牛魔王”,5000,“芭蕉扇”) 注入到容器中具体的Bean 信息
5. @Bean(name = {“monster_nmw”}) 在配置，注入Bean指定名字/id ，name是数组类型，可以定义多个。如果 @Bean 没有指定 name/value的话，那么方法名 就是默认的 name/value属性的值 作为 id/名称 进行获取使用。
6. 默认是单例注入的：（也就是说 getBean 获取到的都是同一个对象，共用）
7. 通过 @Scope(value = “prototype”) 可以每次返回一个新的对象，多例
8. 可以通过 @Bean配置多个 bean 对象。都是纳入到 ioc 容器当中进行管理起来的。

4. @Import注解： 也是可以注入组件/就是实现 Bean 对象纳入到 ioc 容器当中进行管理。注意 @Import方式注入的组件/ 纳入 ioc 容器，获取默认组件/Bean对象时，用的名字就是该对应类的全类名。
5. @Conditional 是一个 条件装配：满足 Conditional 指定的条件，则进行组件注入(注入到 ioc 容器中，被 ioc 容器进行管理起来)。

1. @ConditionalOnBean(name=“monster_nmw”) 表示
2. 当容器中有一个Bean，名字是monster_nmw(类型不做约束，仅仅是 id /名字做约束)，就注入dog01这个Dog bean；如果ioc容器中，并没有一个叫 “monster_nmw” 的对象，该 Dog就不会注入 dog01的这个 Dog bean 对象到 ioc 容器当中
3. 注意：使用 @ConditionalOnBean 的同时，要将 @import 注解去了，因为 @import可以实现 ioc注入
4. 注意：满足条件的，要放到判断的前面，简单的说就是，作为条件的bean要放到判断的bean的前面，不然是无法判断的
5. @ConditionalOnMissingBean(name = {“monster_nmw”}) 没有名字/id 为 monster_nmw 才注入 dog01这个 Bean；
6. @ConditionalOnBean(name = {“monster_nmw”}) 也可以放在配置类，类的上面示对该配置类的所有要注入的组件，都进行条件约束。
7. 还有很多其它的条件约束注解，小伙伴可以自己测试。

6. @ImportResource注解： 作用：原生配置文件引入，也就是可以直接导入 **Spring ** 传统的 beans.xml ，可以认为是 Spring Boot 对 Spring 容器文件的兼容。

7. Spring Boot 中的配置绑定：简单的说：就是一句话：使用Java读取到 Spring Boot 核心配置文件application.properties 的内容，并且把它封装到对应的 JavaBean 当中去。

注意Spring Boot中配置绑定，文章中所提到的 3 个注意事项，以及解决方式。

4. 最后：

“在这个最后的篇章中，我要表达我对每一位读者的感激之情。你们的关注和回复是我创作的动力源泉，我从你们身上吸取了无尽的灵感与勇气。我会将你们的鼓励留在心底，继续在其他的领域奋斗。感谢你们，我们总会在某个时刻再次相遇。”