122.【SpringBoot 源码刨析A】（四）-阿里云开发者社区

(4).@Conditional

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

1.当组件中存在某个组件的时候才执行注册

1.作用域: 类上或者方法上。
假如标注到方法上,当这个条件注解为真的时候,这个方法上的注册才生效。当标注到类上的时候,当条件为假的时候,这个类上的所有方法都不生效(也就不会注入到IOC)。
 @ConditionalOnBean(name = "tom") // 当整个IOC容器中存在tom这个容器，我们就注册user01这个组件否则不注册

我们这里对tom容器进行了注释,也就是说IOC容器中不存在tom容器了。

package com.jsxs.config;
import com.jsxs.bean.Pet;
import com.jsxs.bean.User;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Conditional;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
/**
 * @Author Jsxs
 * @Date 2023/7/1 12:30
 * @PackageName:com.config
 * @ClassName: MyConfig
 * @Description: TODO 1.配置类里面使用@Bean标注在方法上给容器注册组件,默认也是单实列的，
 * @Description: TODO 2.配置类(类名)本身也是一个组件,即在这个列子中有三个组件并不是俩个。
 * @Description: TODO 3.@Configuration(proxyBeanMethods=true)代理bean,也就是无论外部调用多少次实列都是一样的即单列。否则不是单实列
 *                          Full(proxyBeanMethods = true)、【保证每个@Bean方法被调用多少次返回的组件都是单实例的】
 *                          Lite(proxyBeanMethods = false)【每个@Bean方法被调用多少次返回的组件都是新创建的】
 *                          组件依赖必须使用Full模式默认。其他默认是否Lite模式
 *
 * @Version 1.0
 */
@Import({User.class})
@Configuration(proxyBeanMethods=true)  // 告诉SpringBoot这是一个配置类,相当于以前的配置文件 beans.xml
public class MyConfig {
    @ConditionalOnBean(name = "tom") // 当整个IOC容器中存在tom这个容器，我们就注册user01这个组件否则不注册
    @Bean // 1. 这里相当于我们配置文件中的<bena></bean>标签
    //  2. User对应的是我们配置文件的class非全限定名, user01对应我们配置文件的id
    public User user01() {
        // FULL模式人拥有宠物
        return new User("李明",12,this.cat());
    }
//    @Bean("tom")  // 相当于我们配置文件的bean标签
    public Pet cat(){  // Pet指的是calss的非全限定名, cat指定的是id
        return new Pet("哈吉米");
    }
}

package com.jsxs;
import com.jsxs.bean.Pet;
import com.jsxs.bean.User;
import com.jsxs.config.MyConfig;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
/**
 * @Author Jsxs
 * @Date 2023/7/1 9:53
 * @PackageName:com.jsxs
 * @ClassName: MainSpringApplication
 * @Description: TODO
 * @Version 1.0
 */
@SpringBootApplication
public class MainSpringApplication {
    public static void main(String[] args) {
        // 1.返回的是我们的IOC容器
        ConfigurableApplicationContext run = SpringApplication.run(MainSpringApplication.class, args);
        // 2.我们查看IOC容器里面都有哪些组件
        String[] benas = run.getBeanDefinitionNames();
        for (String bena : benas) {
            System.out.println(bena);
        }
        // 1.测试容器中是否有tom这个组件
        boolean flag = run.containsBean("tom");
        System.out.println("IOC容器是否有tom容器:"+flag);
        boolean b = run.containsBean("user01");
        System.out.println("IOC容器中是否有user01这个容器:"+b);
    }
}

当容器中没有指定的组件的时候才执行

package com.jsxs.config;
import com.jsxs.bean.Pet;
import com.jsxs.bean.User;
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.Conditional;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
/**
 * @Author Jsxs
 * @Date 2023/7/1 12:30
 * @PackageName:com.config
 * @ClassName: MyConfig
 * @Description: TODO 1.配置类里面使用@Bean标注在方法上给容器注册组件,默认也是单实列的，
 * @Description: TODO 2.配置类(类名)本身也是一个组件,即在这个列子中有三个组件并不是俩个。
 * @Description: TODO 3.@Configuration(proxyBeanMethods=true)代理bean,也就是无论外部调用多少次实列都是一样的即单列。否则不是单实列
 *                          Full(proxyBeanMethods = true)、【保证每个@Bean方法被调用多少次返回的组件都是单实例的】
 *                          Lite(proxyBeanMethods = false)【每个@Bean方法被调用多少次返回的组件都是新创建的】
 *                          组件依赖必须使用Full模式默认。其他默认是否Lite模式
 *
 * @Version 1.0
 */
@Import({User.class})
@Configuration(proxyBeanMethods=true)  // 告诉SpringBoot这是一个配置类,相当于以前的配置文件 beans.xml
@ConditionalOnMissingBean(name = "tom") // 当整个IOC容器中存在tom这个容器，我们就注册user01这个组件否则不注册
public class MyConfig {
    @Bean // 1. 这里相当于我们配置文件中的<bena></bean>标签
    //  2. User对应的是我们配置文件的class非全限定名, user01对应我们配置文件的id
    public User user01() {
        // FULL模式人拥有宠物
        return new User("李明",12,this.cat());
    }
//    @Bean("tom")  // 相当于我们配置文件的bean标签
    public Pet cat(){  // Pet指的是calss的非全限定名, cat指定的是id
        return new Pet("哈吉米");
    }
}

package com.jsxs;
import com.jsxs.bean.Pet;
import com.jsxs.bean.User;
import com.jsxs.config.MyConfig;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
/**
 * @Author Jsxs
 * @Date 2023/7/1 9:53
 * @PackageName:com.jsxs
 * @ClassName: MainSpringApplication
 * @Description: TODO
 * @Version 1.0
 */
@SpringBootApplication
public class MainSpringApplication {
    public static void main(String[] args) {
        // 1.返回的是我们的IOC容器
        ConfigurableApplicationContext run = SpringApplication.run(MainSpringApplication.class, args);
        // 2.我们查看IOC容器里面都有哪些组件
        String[] benas = run.getBeanDefinitionNames();
        for (String bena : benas) {
            System.out.println(bena);
        }
        // 1.测试容器中是否有tom这个组件
        boolean flag = run.containsBean("tom");
        System.out.println("IOC容器是否有tom容器:"+flag);
        boolean b = run.containsBean("user01");
        System.out.println("IOC容器中是否有user01这个容器:"+b);
    }
}

2.2、原生配置文件引入 (只能放在类级别的注解上)

1.作用:
  我们使用SpringBoot框架之后,SpringMvc支持的beans.xml配置文件不会被SpringBoot进行解析,这时候我们想要SpringBoot帮助我们解析beans.xml
2.用法:
文件的话,我们可以在任意一个IOC容器组件类上进行@ImportResource()即可
这个注解放在任意一个IOC容器类组件上即可。(放一个即可)
classpath: 指的是resource目录下
@ImportResource("classpath:beans.xml")

(1). 尚未使用 @ImportResource

/resource/benas.xml: 我们对id名进行修改(避嫌),进行查找是否存在这两个组件

<?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">
    <!-- 1.指定我们的人类实体类并赋值id   -->
    <bean id="haha" class="com.jsxs.bean.User">
        <!-- 2.给我们实体类进行默认赋值的操作       -->
        <property name="name" value="李明"></property>
        <property name="age" value="12"></property>
    </bean>
    <!-- 3.指定宠物实体类并赋值id   -->
    <bean id="hehe" class="com.jsxs.bean.Pet">
        <property name="name" value="哈吉米"></property>
    </bean>
</beans>

查询结果:是查询不到的。因为SpringBoot识别不了这个beans.xml文件

(2). 引用 @ImportResource

package com.jsxs.config;
import com.jsxs.bean.Pet;
import com.jsxs.bean.User;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.*;
/**
 * @Author Jsxs
 * @Date 2023/7/1 12:30
 * @PackageName:com.config
 * @ClassName: MyConfig
 * @Description: TODO 1.配置类里面使用@Bean标注在方法上给容器注册组件,默认也是单实列的，
 * @Description: TODO 2.配置类(类名)本身也是一个组件,即在这个列子中有三个组件并不是俩个。
 * @Description: TODO 3.@Configuration(proxyBeanMethods=true)代理bean,也就是无论外部调用多少次实列都是一样的即单列。否则不是单实列
 *                          Full(proxyBeanMethods = true)、【保证每个@Bean方法被调用多少次返回的组件都是单实例的】
 *                          Lite(proxyBeanMethods = false)【每个@Bean方法被调用多少次返回的组件都是新创建的】
 *                          组件依赖必须使用Full模式默认。其他默认是否Lite模式
 *
 * @Version 1.0
 */
@Import({User.class})
@Configuration(proxyBeanMethods=true)  // 告诉SpringBoot这是一个配置类,相当于以前的配置文件 beans.xml
//@ConditionalOnMissingBean(name = "tom") // 当整个IOC容器中存在tom这个容器，我们就注册user01这个组件否则不注册
@ImportResource("classpath:beans.xml")
public class MyConfig {
    @Bean // 1. 这里相当于我们配置文件中的<bena></bean>标签
    //  2. User对应的是我们配置文件的class非全限定名, user01对应我们配置文件的id
    public User user01() {
        // FULL模式人拥有宠物
        return new User("李明",12,this.cat());
    }
    @Bean("tom")  // 相当于我们配置文件的bean标签
    public Pet cat(){  // Pet指的是calss的非全限定名, cat指定的是id
        return new Pet("哈吉米");
    }
}

package com.jsxs;
import com.jsxs.bean.Pet;
import com.jsxs.bean.User;
import com.jsxs.config.MyConfig;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
/**
 * @Author Jsxs
 * @Date 2023/7/1 9:53
 * @PackageName:com.jsxs
 * @ClassName: MainSpringApplication
 * @Description: TODO
 * @Version 1.0
 */
@SpringBootApplication
public class MainSpringApplication {
    public static void main(String[] args) {
        // 1.返回的是我们的IOC容器
        ConfigurableApplicationContext run = SpringApplication.run(MainSpringApplication.class, args);
        // 2.我们查看IOC容器里面都有哪些组件
        String[] benas = run.getBeanDefinitionNames();
        for (String bena : benas) {
            System.out.println(bena);
        }
        // 9.@ImportResource ⭐
        boolean haha = run.containsBean("haha");
        boolean hehe = run.containsBean("hehe");
        System.out.println("haha "+haha+" " + "hehe " +hehe);
    }
}