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

已于 2024-08-29 22:58:33 修改
阅读量1.6k 收藏 14
点赞数 22
分类专栏： Spring Boot 文章标签： spring boot java 后端 web spring
于 2024-08-29 22:56:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_61635597/article/details/141690208
版权

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

文章目录

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

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

Spring 注入组件的注解：

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

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

演示测试：

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

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

在这里插入图片描述

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

在这里插入图片描述

package com.rainbowsea.springboot.bean;


import org.springframework.stereotype.Repository;

@Repository
public class A {
}
  1. 在主程序中编写，测试获取该 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
    }
}
  1. 运行测试：

在这里插入图片描述

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;
    }
}
  1. 在 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>
  1. 在主程序当中，获取该 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

        
    }
}
  1. 运行测试：

在这里插入图片描述

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

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

在这里插入图片描述

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

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

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

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

在这里插入图片描述

  1. 在 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,"芭蕉扇");
    }




}
  1. 运行测试：
    在这里插入图片描述
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



    }
}

在这里插入图片描述

在这里插入图片描述

  1. 默认是单例注入的：（也就是说 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




    }
}

在这里插入图片描述

在这里插入图片描述

  1. 通过 @Scope(value = “prototype”) 可以每次返回一个新的对象，多例
    在这里插入图片描述

在这里插入图片描述

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

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

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

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

在这里插入图片描述

在这里插入图片描述

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

在这里插入图片描述

  1. @Configuration 注意事项和细节： 自定义配置类的
  1. @Configuration 中有一个属性 proxyBeanMethods : 代理bean的方法。

在这里插入图片描述

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

在这里插入图片描述

  1. 在 Furn 类上添加：@ConfigurationProperties 注解：
  2. 在这里插入图片描述

格式

@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;
    }
}
  1. 装配上 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;
    }

}
  1. 启动运行测试：

​

在这里插入图片描述

其实配置绑定还有第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了。

在这里插入图片描述

运行测试：

在这里插入图片描述

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

在这里插入图片描述

测试：

在这里插入图片描述

  1. 使用 @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的方法。

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

在这里插入图片描述

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

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

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

4. 最后：

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

在这里插入图片描述

ChinaRainbowSea
关注
专栏目录
Spring Boot内置容器
qq_40874035的博客
09-02 1631
在Spring Boot项目开发过程中，除使用默认的tomcat内置容器以外，像jetty、undertow、netty、webflux等内置容器，也是一种不错的选择。
SpringBoot之容器
qq_44901346的博客
08-14 933
文章目录容器功能1.1 组件添加1.2 原生配置文件引入1.3 配置绑定 容器功能 1.1 组件添加 法一： @Configuration /** * 1、配置类里面使用@Bean标注在方法上给容器注册组件，默认也是单实例的 * 2、配置类本身也是组件 * 3、proxyBeanMethods：代理bean的方法 （这是SpringBoot2对SpringBoot很大的不同） * Full(proxyBeanMethods = true)、【保证每个@Bean方法被调用
SpringBoot中的容器
spade_Kwo的博客
12-07 3125
容器一、容器功能1、组件添加（1）主要注解（2） 基本使用（3）补充@Import@Conditional2、原生配置文件引入（xml文件引入）3.配置绑定(1)@Component + @ConfigurationProperties(2)@EnableConfigurationProperties + @ConfigurationProperties 一、容器功能 1、组件添加 （1）主要注解 @Configuration 告诉SpringBoot这是一个配置类 == 配置文件 注意：spring5.2
SpringBoot 容器化实践
Ivan Xiang
03-21 2166
Spring Boot 容器化 Spring Boot 脚手架的开箱即用特性，非常利于产品的快速开发，在微服务项目或单一功能的小程序开发项目中经常被使用。 Docker 是一种虚拟化的容器技术，它能在宿主机上虚拟化一台满足最少功能的虚拟主机，这些主机就是容器，多个容器之间，可以共享文件、网络、cpu、内存等资源，当然也可以相互隔离，比起VMWare等虚拟机，它更轻量化，启动速度快，容器支持量多，运维相对容易，虽然在资源隔离上比VMWare等虚拟化容器稍弱，但在满足业务需求的基础上，docker容器仍然有巨大
SpringBoot-容器功能
爱笑的boy的博客
07-30 964
SpringBoot-容器功能
基于Spring Boot + Mybatis+Vue开发实习生招聘网站源代码+数据库毕业设计
09-12
在压缩包“IndexRecruit-master”中，你可以找到项目的源代码文件，包括Spring Boot的后端服务、Mybatis的映射文件、Vue.js的前端组件以及其他必要的配置和资源文件。通过研究这个项目，你可以深入了解如何整合这些...
Spring Boot源码（spring-boot-2.6.2.zip）
01-07
Spring Boot 2.6.2是该框架的一个稳定版本，提供了一系列增强的功能和改进。在这个版本中，我们将深入探讨Spring Boot的核心特性、工作原理以及如何通过源码来理解其内部机制。 首先，Spring Boot的核心理念是...
基于springboot+vue+MySQL实现的在线考试系统+源代码+文档
最新发布
06-17
Spring Boot的核心特性包括自动配置、起步依赖和运行时监测。在本项目中，Spring Boot用于搭建后端服务，处理HTTP请求，提供RESTful API，以及与数据库的交互。 **2. Vue.js** Vue.js是一个轻量级的前端JavaScript...
基于spring boot+nadia-config的配置中心源码.zip
02-02
这个压缩包“基于spring boot+nadia-config的配置中心源码.zip”提供了使用Spring Boot和Nadia Config实现配置中心的源代码，对于理解和学习如何搭建和使用配置中心非常有帮助。 首先，Spring Boot的核心特性之一是...
springboot容器
fantasyleaves的博客
12-06 1094
嵌入式 springboot默认使用嵌入式的tomcat，依赖spring-boot-starter-web默认引入的是tomcat的jar包。 修改servlet相关配置：server.port=8888; server.xxx=...; 修改tomcat位置：server.tomcat.xx=xxx 嵌入式容器三大组件注册 嵌入式tomcatspringboot项目没有web.xml，无法在配置文件web.xml中配置三大组件，使用配置类来代替web.xml的配置作用。 1. 创建自己的
SpringBoot（六）之内嵌容器
aoxiaojun的博客
05-17 779
Springboot内嵌容器
Spring Boot之容器功能
weixin_54107527的博客
11-17 1173
笔记型博客-->Spring Boot之容器功能
SpringBoot2----容器功能
m0_53157173的博客
08-01 450
容器功能2.1、组件添加1、@Configuration基本使用Full模式与Lite模式这里有无依赖多指是否在一个类中使用到另一个类，例如在People类里面，Cat类是People里的一个属性，这样People和cat类之间就产生了依赖关系Full模式与Lite模式注意点如下关于SpringBoot的Full模式与Lite模式上面案例的总结2、@Bean、@Component、@Controller、@Service、@Repository这些注解都可以用来注册组件到容器中，当然注册组件到容器中的方法不
SpringBoot容器功能
weixin_47267628的博客
06-18 352
组件添加，就是在容器创建对象注解表示是一个配置类，可以添加相关的组件基本使用：模式和模式配置类组件之间无依赖关系用模式加速容器启动过程，减少判断，加载快，启动快 配置类组件之间有依赖关系，方法会调用得到之前单实例组件，用模式 作用是：如果需要使用到单例模式也就是组件依赖也是默认模式，就设置成模式，其他就使用模式示例：类 类 类【配置类】 测试 B. 注解创建对象【添加组件】 C. 注解创建对象【添加组件】 注意是：注解可以使用在任何例如： 测试： 注解源码 D.注解【非常重要在底层】
SpringBoot 基本介绍--依赖管理和自动配置--容器功能
业精于勤，荒于嬉
05-14 1870
1. spring-boot-starter-parent 还有父项目, 声明了开发中常用的依赖的版本号2. 并且进行自动版本仲裁, 即如果程序员没有指定某个依赖jar 的版本，则以父项目指定的版本为准1. 开发中我们引入了相关场景的starter，这个场景中所有的相关依赖都引入进来了，比如我们做web 开发引入了，该starter 将导入与web 开发相关的所有包2.依赖树。
SpringBoot 内嵌容器
myli92的博客
10-01 3479
jetty和undertow都是基于NIO实现的高并发轻量级的服务器，支持servlet3.1和websocket。NIO(非阻塞式输入输出，四个步骤Channel，Selector，Buffer。Acceptor）。Client和Server只向Buffer读写数据不关注数据的流向，数据通过Channel通道进行流转。而Selector是存在与服务端的，用于Channel的注册以此实现数据I/O操作。Acceptor负责接受所以的连接通道并且注册到Channel中。
spring boot 内置容器
lxlneversettle的博客
04-21 566
spring boot web容器 spring boot 可以通过java -jar的形式来启动web容器并且启动应用，其背后也使用到了自动配置 TomcatServletWebServerFactory用来产生TomcatServletWebServer TomcatServletWebServer则用来管来tomcat容器的启停 ServletWebServerFactoryAutoConfiguration ServletWebServerFactoryAutoConfiguration就是用来进行
Vue.js与Spring Boot打造员工之家管理系统源码发布
- src/main/java/：存放Spring Boot的主要Java源代码，包括控制器、服务、数据访问对象（DAO）等。 - src/main/resources/：存放资源文件，如配置文件application.properties或application.yml，以及静态资源。 -...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值