Bean的加载方式

Bean的加载方式

bean的xml方式声明

<?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方式声明自己开发的bean-->
    <bean id="cat" class="com.itheima.bean.Cat"/>
    <bean class="com.itheima.bean.Dog"/>
<!--    xml声明第三方开发的Bean-->
    <bean  id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"/>
    <bean  class="com.alibaba.druid.pool.DruidDataSource"/>
    <bean  class="com.alibaba.druid.pool.DruidDataSource"/>
</beans>

bean的加载方式二：XML+注解当时声明bean

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       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
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
        ">


<!--    指定加载Bean的位置，Component-->
    <context:component-scan base-package="com.itheima.bean,com.itheima.config"/>

</beans>

//@Component
@Configuration
public class DbConfig {
    @Bean
    public DruidDataSource dataSource(){
        DruidDataSource ds = new DruidDataSource();
        return ds;
    }
}

bean的加载方式三：注解方式声明配置类

@ComponentScan({"com.itheima.bean","com.itheima.config"})
public class SpringConfig3 {
}

要使用AnnotationConfigApplicationContext加载bean了

public class App3 {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig3.class);
        String[] names = ctx.getBeanDefinitionNames();
        for (String name : names) {
            System.out.println(name);
        }
    }
}

bean加载方式扩展——FactoryBean

public class DogFactoryBean implements FactoryBean<Dog> {
    @Override
    public Dog getObject() throws Exception {
        return new Dog();
    }

    @Override
    public Class<?> getObjectType() {
        return Dog.class;
    }

    @Override
    public boolean isSingleton() {
        return FactoryBean.super.isSingleton();
    }
}

bean的加载方式扩展2——加载配置类并加载配置文件（系统迁移）

bean的加载方式扩展3——proxyBeanMethods

设置为true，就是从容器中拿同一个单例对象。

@Configuration(proxyBeanMethods = true)
public class SpringConfig33 {
    @Bean
    public Cat cat(){
        return  new Cat();
    }
}

bean的加载方式四：使用@Import注解注入

导进来的bean是全路径类名


使用import也可以加载配置类（其实就是里面又加载了其他的Bean）
而且配置类可以不加注解

bean的加载方式五：使用上下文对象在容器初始化完毕后注入Bean

只能用AnnotationConfigApplicationContext
所以声明ctx的时候，换了前面的类型。

public class App5 {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig4.class);
        // 上下文对象已经初始化完成以后，手工加载bean
        ctx.registerBean("tom", Cat.class);
        ctx.register(Mouse.class);  // 不给名，默认类名首字母小写
        String[] names = ctx.getBeanDefinitionNames();
        for (String name : names) {
            System.out.println(name);
        }
        System.out.println(ctx.getBean(Dog.class));
    }
}

bean的加载方式六：导入实现了ImportSelector接口的类，实现对导入源的编程式处理

public class MyImportSelector implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
//        System.out.println("==============");
//        System.out.println("提示：" + annotationMetadata.getClassName());
//        System.out.println(annotationMetadata.hasAnnotation("org.springframework.context.annotation.Configuration"));
//        Map attributes = annotationMetadata.getAnnotationAttributes("org.springframework.context.annotation.Configuration");
//        System.out.println(attributes);
//        System.out.println("==============");
        // 可以进行各种判定，判定完毕后，决定是否加载指定的Bean
        boolean flag = annotationMetadata.hasAnnotation("org.springframework.context.annotation.Configuration");
        if(flag){
            return new String[]{"com.itheima.bean.Dog"};
        }
        return new String[]{"com.itheima.bean.Cat"};
    }
}

bean的加载方式七：导入实现了BeanDefinitionRegistry接口的类。

public class MyRegister implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        // 1. 使用元数据去做判定

        BeanDefinition beanDefinition = BeanDefinitionBuilder
                                        .rootBeanDefinition(Dog.class)
                                        .getBeanDefinition();

        registry.registerBeanDefinition("yellow",beanDefinition);
    }
}

bean的加载方式八：导入实现了BeanDefinitionRegistryPostProcessor 接口的类

public class MyPostProcessor implements BeanDefinitionRegistryPostProcessor {
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanDefinitionRegistry) throws BeansException {
        BeanDefinition beanDefinition = BeanDefinitionBuilder
                                        .rootBeanDefinition(BookServiceImpl4.class)
                                        .getBeanDefinition();
        beanDefinitionRegistry.registerBeanDefinition("bookService",beanDefinition);
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {

    }
}