Spring Boot之容器功能

海绵hong

已于 2022-11-17 16:54:39 修改

阅读量1.1k

点赞数 4

分类专栏：微服务 Java框架文章标签： spring boot java spring 后端 mysql

于 2022-11-17 16:54:14 首次发布

本文链接：https://blog.csdn.net/weixin_54107527/article/details/127870247

版权

Java框架同时被 2 个专栏收录

24 篇文章 1 订阅

订阅专栏

微服务

7 篇文章 0 订阅

订阅专栏

一.Spring 注入组件的注解

二.@Configuration

1.代码演示

1.1JavaBean--》Monster.java

1.2配置类

1.3执行代码

2.@Configuration 注意事项和细节

2.@ImportResource 应用实例

一.Spring 注入组件的注解

@Component、@Controller、 @Service、@Repository

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

二.@Configuration

在 SpringBoot, 通过 @Configuration 创建配置类来注入组件

1.代码演示

1.1JavaBean--》Monster.java

ublic class Monster {

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

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

    public Monster() {
    }

    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;
    }

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

1.2配置类

/**
 * @author 海绵hong
 * @version 1.0
 * <p>
 * 解读
 * 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(200,"牛魔王",500,"疯魔拳") 注入到容器中具体的Bean信息
     * 5. @Bean(name = "monster_nmw") : 在配置、注入Bean指定名字/id monster_nmw
     * 6. 默认是单例注入
     * 7. 通过 @Scope("prototype")  可以每次返回新的对象，就多例.
     */
    //@Bean(name = "monster_nmw")
    @Bean
    //@Scope("prototype")
    public Monster monster01() {
        return new Monster(200, "牛魔王", 500, "疯魔拳");
    }

}

1.3执行代码

        //启动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());

        //===演示 @Configuration end ====

2.@Configuration 注意事项和细节

1. 配置类本身也是组件，因此也可以获取 , 测试修改 MainApp.java

    public static void main(String[] args) {
        ConfigurableApplicationContext ioc =
                SpringApplication.run(MainApp.class, args);
//解读
//1. ioc.getBean("monster01", Monster.class) 是从 BeanConfig 配置类/容器获取 bean 实例
//2. 默认是单列模式, 所以 monster01 == monster02
//获取 BeanConfig 配置类的组件/bean 实例
        Monster monster01 = ioc.getBean("monster01", Monster.class);
        System.out.println(monster01);
        Monster monster02 = ioc.getBean("monster01", Monster.class);
        System.out.println(monster01 == monster02);
//解读
//配置类本身也是组件， 因此也可以获取
        BeanConfig beanConfig = ioc.getBean(BeanConfig.class);
        System.out.println("beanConfig= " + beanConfig);
    }

2. SpringBoot2 新增特性： proxyBeanMethods 指定 Full 模式（全模式）和 Lite 模式（简化模式）

1. proxyBeanMethods：代理bean的方法
 (1) Full(proxyBeanMethods = true)、【保证每个@Bean方法被调用多少次返回的组件都是单实例的, 是代理方式】
 (2) Lite(proxyBeanMethods = false)【每个@Bean方法被调用多少次返回的组件都是新创建的, 是非代理方式】 
(3) 特别说明: proxyBeanMethods 是在 调用@Bean方法 才生效，因此，需要先获取BeanConfig 组件，再调用方法 而不是直接通过 SpringBoot 主程序得到的容器来获取bean, 注意观察直接通过ioc.getBean() 获取Bean, proxyBeanMethods 值并没有生效 
(4) 如何选择: 组件依赖必须使用Full模式默认。如果不需要组件依赖使用 Lite模 
(5) Lite模 也称为轻量级模式，因为不检测依赖关系，运行速度快

@Configuration(proxyBeanMethods = false)
public class BeanConfig {

        //===演示@Configuration(proxyBeanMethods = xxx) start

        //1. 先得到BeanConfig组件
        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());


        //特别说明: proxyBeanMethods 是在 调用@Bean方法 才生效，因此，需要先获取BeanConfig 组件，再调用方法
        //1. 而不是直接通过 SpringBoot 主程序得到的容器来获取bean, 注意观察直接通过ioc.getBean() 获取Bean, proxyBeanMethods 值并没有生效

        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());

        //===演示@Configuration(proxyBeanMethods = xxx) end

3. 配置类可以有多个 , 就和 Spring 可以有多个 ioc 配置文件是一个道理

三.@Import

在 SpringBoot, 通过 @Import 来注入组件（和@Configuration一样都是注入bean）

1.创建两个JavaBean类

Cat+Dog

2.注入类

/**
 * 解读
 * 1. @Import 代码 可以看到，可以指定 class的数组, 可以注入指定类型的Bean
 * public @interface Import {
 *
 * 	 	Class<?>[] value()}
 *
 * 2. 通过@Import 方式注入了组件, 默认组件名字/id就是对应类型的全类名
 */

@Import({Dog.class, Cat.class})

3.测试注解的使用

  //启动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("dogBean--" + dogBean);
        System.out.println("catBean--" + catBean);

        //===测试@Import 使用 end

四.@Conditional

1.@Conditional 介绍

1. 条件装配：满足 Conditional 指定的条件，则进行组件注入

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

2.应用实例

1. 要求 : 演示在 SpringBoot, 如何通过 @ConditionalOnBean 来注入组件

2. 只有在容器中有 name = monster_nmw 组件时，才注入 dog01, 代码如图

    @Bean
    /**
     * 解读
     * 1. @ConditionalOnBean(name = "monster_nmw") 表示
     * 2. 当容器中有一个Bean , 名字是monster_nmw (类型不做约束), 就注入dog01这个Dog bean
     * 3. 如果没有 名字是monster_nmw Bean 就不注入dog01这个Dog bean
     * 4. 还有很多其它的条件约束注解，小伙伴可以自己测试
     *
     * 5. @ConditionalOnMissingBean(name = "monster_nmw") 表示在容器中,
     * 没有 名字/id 为 monster_nmw 才注入dog01这个Bean
     *
     * 6. @ConditionalOnBean(name = "monster_nmw") 也可以放在配置类
     * 表示对该配置类的所有要注入的组件，都进行条件约束.
     *
     */
    @ConditionalOnBean(name = "monster_nmw")
    //@ConditionalOnMissingBean(name = "monster_nmw")
    public Dog dog01() {
        return new Dog();
    }

五.@ImportResource

1.作用：

原生配置文件引入 , 也就是可以直接导入 Spring 传统的 beans.xml ，可以认为是 SpringBoot 对 Spring 容器文件的兼容 .（原来依靠借口或者类来导入，现在可以使用该注解进行判断）

2.@ImportResource 应用实例

@Configuration
//导入beans.xml - 就可以获取到beans.xml 中配置bean
@ImportResource(locations = {"classpath:beans.xml","classpath:beans02.xml"})//配置两个bean文件
public class BeanConfig3 {
}

        //===测试@Import 使用 start

        Dog dogBean = ioc.getBean(Dog.class);
        Cat catBean = ioc.getBean(Cat.class);
        System.out.println("dogBean--" + dogBean);
        System.out.println("catBean--" + catBean);

        //===测试@Import 使用 end

六.配置绑定

一句话：使用 Java 读取到 SpringBoot 核心配置文件 application.properties 的内容，

并且把它封装到 JavaBean 中

1.代码演示

#设置Furn的属性k-v
#前面的 furn01 是用于指定/区别不同的绑定对象, 这样可以再绑定Furn bean属性值时
#通过furn01 前缀进行区分
#furn01.id 中的id 就是你要绑定的 Furn bean的属性名
furn01.id=100
furn01.name=TV
furn01.price=1000.9

@Component
@ConfigurationProperties(prefix = "furn01")
public class Furn {
    private Integer id;
    private String name;
    private Double price;


}

会读取核心配置文件的信息，然后放入容器

2.配置绑定还有第 2 种方式

注意 : 注销

@Component 需要在 BeanConfig.java( 说明 : 也可以是其它配置类 ) 配置

@EnableConfigurationProperties ( Furn . class ), 否则会提示错误

//@EnableConfigurationProperties(Furn.class)解读
//1、开启 Furn 配置绑定功能
//2、把 Furn 组件自动注册到容器中
@EnableConfigurationProperties(Furn.class)
public class BeanConfig {
}

海绵的思路（可能错误）：

将@Component注解标识掉之后，就不会去读取到容器中，但是在控制器中@EnableConfigurationProperties(Furn.class)被添加，那么底层应该就是这样一个思路：将这个启用配置属性明确配置那个类的信息，然后在那个对应的JavaBean类中有@ConfigurationProperties(prefix = "furn01")这个配置就可以读取到，并且直接将这个信息发送到了控制器中，所有在之后添加了那个注解之后便没有报错

3.注意事项和细节

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

#设置属性 k-v
furn01.id=100
furn01.name=soft_chair\u6c99\u53d1!!
furn01.price=45678.9

2. 使用 @ConfigurationProperties (prefix = "furn01" ) 会提示如下信息 , 但是不会影响使用

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

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