Spring容器导入Bean

末蓝、 2022-12-11 10:28 140阅读 0赞

> [https://blog.csdn.net/qq\_40794973/article/details/93471884][https_blog.csdn.net_qq_40794973_article_details_93471884]

@Data
    public class Person {
        private String name;
        private Integer age;
        public Person() {}
        public Person(String name, Integer age) {this.name = name;this.age = age;}
    }

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

--------------------

# 1 bean&@Bean #

## 1.1 XML ##

<bean id="person" class="cn.yuanyu.crud.bean.Person">
        <property name="name" value="蔡徐坤"/>
        <property name="age" value="18"/>
    </bean>

@Test
    public void test() {
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:beans.xml");
        // 通过类型获取，同一个类形在容器中只有一个才能这样获取
        Person p1 = applicationContext.getBean(Person.class);
        System.out.println(p1);
        // 通过名字获取
        Person p2 = (Person) applicationContext.getBean("person");
        System.out.println(p1 == p2);
    }

## 1.2 Annotation ##

// 使用配置类代替配置文件
    @Configuration  // 告诉Spring这是一个配置类
    public class AppConfig {
        // 给容器中注册一个Bean，类型为返回值的类型，id默认是用方法名作为id
        @Bean //@Bean("kun")
        public Person cxk() {
            return new Person("蔡徐坤", 58);
        }
    }

@Test
    public void test() {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);
        Person person = applicationContext.getBean(Person.class);
        System.out.println(person);
        // 通过类型获取容器中bean的名字
        String name = applicationContext.getBeanNamesForType(Person.class)[0];
        System.out.println(name);
    }

--------------------

# 2 context:component-scan&@ComponentScan #

## 2.1 XML ##

<context:component-scan base-package="cn.yuanyu.crud">
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

<context:component-scan base-package="cn.yuanyu.crud" use-default-filters="false">
        
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

## 2.2 Annotation ##

// Spring的配置文件
    @Configuration
    @ComponentScan(basePackages = "cn.yuanyu.crud"
            , excludeFilters = {@ComponentScan.Filter(type = FilterType.ANNOTATION, value = Controller.class)})
    public class ApplicationConfig {
        // 事务管理器、业务bean等...

// SpringMVC的配置文件
    @Configuration
    @EnableWebMvc
    @ComponentScan(basePackages = "cn.yuanyu.crud"
            , includeFilters = {@ComponentScan.Filter(type = FilterType.ANNOTATION, value = Controller.class)}
            , useDefaultFilters = false)
    public class WebConfig implements WebMvcConfigurer {
      //视图解析器等配置...

## 2.3 自定义TypeFilter指定过滤规则 ##

// 扫描 cn.yuanyu.crud 下的所有类
    @Configuration
    @ComponentScan(basePackages = "cn.yuanyu.crud"
            , includeFilters = @Filter(type = FilterType.CUSTOM, classes = {MyTypeFilter.class})
            , useDefaultFilters = false)
    public class AppConfig {

// 自定义过滤规则
    public class MyTypeFilter implements TypeFilter {
        /**
         * 返回true添加到容器中，返回false不添加到容器中
         *
         * @param metadataReader        读取到的当前正在扫描的类的信息
         * @param metadataReaderFactory 可以获取到其他任何类信息的
         */
        @Override
        public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
            // 获取当前类注解的信息
            AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();
            // 获取当前正在扫描的类的类信息，类型是什么、实现了什么接口等
            ClassMetadata classMetadata = metadataReader.getClassMetadata();
            // 获取当前类资源信息（类的路径等）
            Resource resource = metadataReader.getResource();
            
            // 根据业务决定是否加入容器中
            String className = annotationMetadata.getClassName();
            System.out.println("className => " + className);
            return false; // true加入容器，false不加入容器
        }
    }

--------------------

# 3 @Conditional 条件注册 #

按照一定的条件进行判断，满足条件给容器注册bean

/**
     * 判断操作系统是否是linux系统
     */
    public class LinuxCondition implements Condition {
        @Override
        public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
            Environment environment = context.getEnvironment();
            String property = environment.getProperty("os.name");
            if (property != null) {
                return property.contains("linux");
            }
            return false;
        }
    }

/**
     * 判断操作系统是否是Windows系统
     */
    public class WindowsCondition implements Condition {
        /**
         * @param context  判断条件能使用的上下文（环境）
         * @param metadata 注释信息
         */
        @Override
        public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
            // 获取ioc使用的beanFactory
            ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
            // 获取类加载器
            ClassLoader classLoader = context.getClassLoader();
            // 获取当前环境信息
            Environment environment = context.getEnvironment();
            // 获取到bean定义的注册类（注册一个bean的定义、移除一个bean的定义、查询一个bean的定义...）
            // 可以判断容器中的bean注册情况，也可以给容器中注册bean
            BeanDefinitionRegistry registry = context.getRegistry();
            
            String property = environment.getProperty("os.name");
    
            if (property != null) {
                return property.contains("Windows");
            }
            return false;
        }
    }

/**
     * 根据系统环境加载不同的bean
     */
    // @Conditional放在整类个上，用于类中组件统一设置，满足当前条件这个类中配置的所有bean才会注册生效
    @Configuration
    public class AppConfig {
        // 系统是windows才注册
        @Bean("bill")
        @Conditional(value = WindowsCondition.class)
        public Person bill() {
            return new Person("Bill Gates", 62);
        }
    
        // 系统是linux才注册
        @Conditional(value = LinuxCondition.class)
        @Bean("linus")
        public Person linus() {
            return new Person("linus", 48);
        }
    }

// -Dos.name=linux
    public class AnnotationTest {
        @Test
        public void test() {
            AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);
            //
            String[] beanNamesForType = applicationContext.getBeanNamesForType(Person.class);
            System.out.println(Arrays.toString(beanNamesForType));
            //
            Map<String, Person> personMap = applicationContext.getBeansOfType(Person.class);
            System.out.println(personMap);
            // 获取环境变量的值
            ConfigurableEnvironment environment = applicationContext.getEnvironment();
            String property = environment.getProperty("os.name");
            System.out.println(property);
        }
    }

--------------------

# 4 @Import 导入组件 #

// 1）、@Import(要导入到容器中的组件)             : 容器中就会自动注册这个组件，id默认是组件的全类名
    // 2）、ImportSelector                        : 返回需要导入的组件的全类名数组
    // 3）、ImportBeanDefinitionRegistrar         : 手动注册bean到容器中
    @Configuration
    @Import({Red.class, MyImportSelector.class, MyImportBeanDefinitionRegistrar.class})
    public class AppConfig {

## 4.1 无逻辑导入 ##

public class Red {}

@Configuration
    @Import({Red.class})
    public class AppConfig {

## 4.2 ImportSelector 返回全类名导入 ##

@Configuration
    @Import({MyImportSelector.class})
    public class AppConfig {

public class Blue {}
    public class Yellow {}

// 自定义逻辑返回需要导入的组件
    public class MyImportSelector implements ImportSelector {
        /**
         * @param importingClassMetadata 当前标注@Import注解的类的所有注解信息
         * @return 导入到容器中的组件全类名
         */
        @Override
        public String[] selectImports(AnnotationMetadata importingClassMetadata) {
            // importingClassMetadata
            // 逻辑判断...
            // 方法不要返回null值
            return new String[]{"cn.yuanyu.ssm.bean.Blue", "cn.yuanyu.ssm.bean.Yellow"};
        }
    }

## 4.3 ImportBeanDefinitionRegistrar  指定bean的名字 ##

@Configuration
    @Import({MyImportBeanDefinitionRegistrar.class})
    public class AppConfig {

public class Pink {}

public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
        /**
         * BeanDefinitionRegistry.registerBeanDefinition手工注册进来
         *
         * @param importingClassMetadata 当前类的注解信息
         * @param registry               BeanDefinition注册类
         */
        @Override
        public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
            boolean hasYellow = registry.containsBeanDefinition("cn.yuanyu.ssm.bean.Yellow");
            if (hasYellow) {
                // 指定bean的定义信息（bean的类型等等）
                RootBeanDefinition beanDefinition = new RootBeanDefinition(Pink.class);
                // 注册一个bean，指定bean名
                registry.registerBeanDefinition("pink", beanDefinition);
            }
        }
    }

@Test
    public void test() {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);
        printBeans(applicationContext);
    }
    void printBeans(AnnotationConfigApplicationContext context) {
        String[] definitionNames = context.getBeanDefinitionNames();
        for (String definitionName : definitionNames) {
            System.out.println(definitionName);
        }
    }

--------------------

# 5 FactoryBean #

public class Color {}

// 创建一个Spring定义的FactoryBean
    public class ColorFactoryBean implements FactoryBean<Color> {
        // 返回一个Color对象，这个对象会添加到容器中
        @Override
        public Color getObject() throws Exception {
            System.out.println("ColorFactoryBean.getObject...");
            return new Color();
        }
        @Override
        public Class<?> getObjectType() {
            return Color.class;
        }
        //是否是单例？
        //true 		: 这个bean是单实例，在容器中保存一份
        //false 	: 多实例，每次获取都会创建一个新的bean
        @Override
        public boolean isSingleton() {
            return false;
        }
    }

@Configuration
    public class AppConfig {
        @Bean
        public ColorFactoryBean colorFactoryBean(){
            return new ColorFactoryBean();
        }
    }

@Test
    public void test() {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);
        printBeans(applicationContext);
        // 工厂Bean获取的是调用getObject创建的对象
        Object color = applicationContext.getBean("colorFactoryBean");
        System.out.println("bean的类型 : " + color.getClass());
        Object color2 = applicationContext.getBean("colorFactoryBean");
        System.out.println(color == color2); // false
        // org.springframework.beans.factory.BeanFactory.FACTORY_BEAN_PREFIX
        Object colorFactoryBean = applicationContext.getBean("&colorFactoryBean");
        System.out.println(colorFactoryBean.getClass());
    
    }
    void printBeans(AnnotationConfigApplicationContext context) {
        String[] definitionNames = context.getBeanDefinitionNames();
        for (String definitionName : definitionNames) {
            System.out.println(definitionName);
        }
    }

--------------------

# 6 总结 #

/**
     * 给容器中注册组件；
     * 1）、包扫描+组件标注注解（@Controller/@Service/@Repository/@Component），没有这些注解就无法导入了
     * 2）、@Bean可以导入的第三方包里面的组件
     * 3）、@Import快速给容器中导入一个组件（仅仅是用无参构造器导入一个注解使用@Bean有点太麻烦了）
     * 		1）、@Import(要导入到容器中的组件) : 容器中就会自动注册这个组件，id默认是全类名
     * 		2）、ImportSelector : 返回需要导入的组件的全类名数组
     * 		3）、ImportBeanDefinitionRegistrar : 手动注册bean到容器中
     * 4）、使用Spring提供的 FactoryBean（工厂Bean）
     * 		1）、默认获取到的是工厂bean调用getObject创建的对象
     * 		2）、要获取工厂Bean本身，我们需要给id前面加一个&
     */

[https_blog.csdn.net_qq_40794973_article_details_93471884]: https://blog.csdn.net/qq_40794973/article/details/93471884