Java Spring Bean 的几种加载方式

写这篇文章的主要目的还是为了记录自己的笔记,如果有哪些不足的地方,还望指出

8 种bean的加载方式

1. xml + bean 形式

第一种方式是最基础的,也是我们最熟悉的,使用xml直接配置bean,方法如下!

<?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">
    <!--注入 user bean 对象-->
    <bean id="user" class="com.small.bean.User" ></bean>
</beans>

// main 方法
public class Application {
    public static void main(String[] args) {
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        Object userBean = app.getBean(User.class);
        System.out.println(userBean);
    }
}

2. xml + context + 注解

使用@component 注解方式,或者其他的例如 @controller ,@service ,@Resposity , @Bean 定义bean对象.

@Component // 加入该注解,并在配置文件声明包扫描
public class User {
}

<?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
            ">

    <!--    配置组件/包扫描-->
    <context:component-scan base-package="com.small.bean"></context:component-scan>

</beans>

// main 方法
public class Application {
    public static void main(String[] args) {
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        Object userBean = app.getBean(User.class);
        System.out.println(userBean);
    }
}

3. 配置类 + 扫描 + 注解

// 配置类 + 扫描
@Configuration
@ComponentScan(basePackages = "com.small")
public class MyConfig {

}

// 注解
@Component
public class User {
}

// main 方法
public class Application {
    public static void main(String[] args) {
        ApplicationContext app = new AnnotationConfigApplicationContext(MyConfig.class);
        Object userBean = app.getBean(User.class);
        System.out.println(userBean);
    }
}

4. @Import 导入加载的bean

// 配置类
@Import(User.class)
public class MyConfig {
}

// bean 类 此时无须声明该类为bean类
public class User {
}

// main 方法
public class Application {
    public static void main(String[] args) {
        ApplicationContext app = new AnnotationConfigApplicationContext(MyConfig.class);
        Object userBean = app.getBean(User.class);
        System.out.println(userBean);
    }
}

此形式可以有效降低源代码与Spring的耦合度,在Spring底层及诸多框架中大量使用

5. AnnotationConfigApplicationContext 调用 register 方法

// 配置类
public class MyConfig {
}

// bean 类
public class User {
}

// main 方法
public class Application {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext app = new AnnotationConfigApplicationContext(MyConfig.class);
        app.register(User.class);

        Object userBean = app.getBean(User.class);
        System.out.println(userBean);
    }
}

6. @Import 导入ImportSelector接口

实现对导入源的编程式处理

// MyImportSelector 类
public class MyImportSelector implements ImportSelector {
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        boolean flag = annotationMetadata.hasAnnotation("org.springframework.context.annotation.Import");
        if (flag) {
            return new String[]{"com.small.bean.People"};
        }
        return new String[]{"com.small.bean.User"};
    }
}

// 配置类
@Import(MyImportSelector.class)
public class MyConfig {
}

// bean 类
public class People {
}
public class User{
}

// main 方法
public class Application {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext app = new AnnotationConfigApplicationContext(MyConfig.class);
        Object userBean = app.getBean(People.class);
        System.out.println(userBean);
    }
}

7. @Import 导入ImportBeanDefinitionRegistrar接口

导入实现了ImportBeanDefinitionRegistrar接口的类,通过BeanDefinition的注册器注册实名bean,实现对容器中bean的裁定，例如对现有bean的覆盖，进而达成不修改源代码的情况下更换实现的效果

// 配置类
@Import(MyImportBeanDefinitionRegistrar.class)
public class MyConfig {
}

// MyImportBeanDefinitionRegistrar 类
public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata,
                                        BeanDefinitionRegistry registry) {
        BeanDefinition beanDefinition = BeanDefinitionBuilder.rootBeanDefinition(User.class).getBeanDefinition();
        registry.registerBeanDefinition("user", beanDefinition);
    }
}

// bean 类
public class User {
}

// main 方法
public class Application {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext app = new AnnotationConfigApplicationContext(MyConfig.class);
        Object userBean = app.getBean(User.class);
        System.out.println(userBean);
    }
}

8. @Import 导入BeanDefinitionRegistryPostProcessor接口

导入实现了BeanDefinitionRegistryPostProcessor接口的类，通过BeanDefinition的注册器注册实名bean,实现对容器中bean的最终裁定

// 配置类
@Import(MyPostProcessor.class)
public class MyConfig {
}

// MyPostProcessor 类
public class MyPostProcessor implements BeanDefinitionRegistryPostProcessor {
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
        BeanDefinition beanDefinition = BeanDefinitionBuilder.rootBeanDefinition(User.class).getBeanDefinition();
        registry.registerBeanDefinition("user", beanDefinition);
    }

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

    }


}

// bean 类
public class User {
}

// 主函数
public class Application {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext app = new AnnotationConfigApplicationContext(MyConfig.class);
        Object userBean = app.getBean(User.class);
        System.out.println(userBean);
    }
}