Spring为IOC容器注入Bean的五种方式

Posted 2020-11-16 天宇轩-王

一 @Import导入组件，id默认是组件的全类名

 1 //类中组件统一设置。满足当前条件，这个类中配置的所有bean注册才能生效；
 2 @Conditional({WindowsCondition.class})
 3 @Configuration
 4 @Import({Color.class,Red.class,MyImportSelector.class,MyImportBeanDefinitionRegistrar.class})
 5 //@Import导入组件，id默认是组件的全类名
 6 public class MainConfig2 {
 7     
 8     //默认是单实例的
 9     /**
10      * ConfigurableBeanFactory#SCOPE_PROTOTYPE    
11      * @see ConfigurableBeanFactory#SCOPE_SINGLETON  
12      * @see org.springframework.web.context.WebApplicationContext#SCOPE_REQUEST  request
13      * @see org.springframework.web.context.WebApplicationContext#SCOPE_SESSION  sesssion
14      * @return15      * @Scope:调整作用域
16      * prototype：多实例的：ioc容器启动并不会去调用方法创建对象放在容器中。
17      *                  每次获取的时候才会调用方法创建对象；
18      * singleton：单实例的（默认值）：ioc容器启动会调用方法创建对象放到ioc容器中。
19      *          以后每次获取就是直接从容器（map.get()）中拿，
20      * request：同一次请求创建一个实例
21      * session：同一个session创建一个实例
22      * 
23      * 懒加载：
24      *      单实例bean：默认在容器启动的时候创建对象；
25      *      懒加载：容器启动不创建对象。第一次使用(获取)Bean创建对象，并初始化；
26      * 
27      */
28 //  @Scope("prototype")
29     @Lazy
30     @Bean("person")
31     public Person person(){
32         System.out.println("给容器中添加Person....");
33         return new Person("张三", 25);
34     }
35     
36     /**
37      * @Conditional({Condition}) ： 按照一定的条件进行判断，满足条件给容器中注册bean
38      * 
39      * 如果系统是windows，给容器中注册("bill")
40      * 如果是linux系统，给容器中注册("linus")
41      */
42     
43     @Bean("bill")
44     public Person person01(){
45         return new Person("Bill Gates",62);
46     }
47     
48     @Conditional(LinuxCondition.class)
49     @Bean("linus")
50     public Person person02(){
51         return new Person("linus", 48);
52     }
53     
54     /**
55      * 给容器中注册组件；
56      * 1）、包扫描+组件标注注解（@Controller/@Service/@Repository/@Component）[自己写的类]
57      * 2）、@Bean[导入的第三方包里面的组件]
58      * 3）、@Import[快速给容器中导入一个组件]
59      *      1）、@Import(要导入到容器中的组件)；容器中就会自动注册这个组件，id默认是全类名
60      *      2）、ImportSelector:返回需要导入的组件的全类名数组；
61      *      3）、ImportBeanDefinitionRegistrar:手动注册bean到容器中
62      * 4）、使用Spring提供的 FactoryBean（工厂Bean）;
63      *      1）、默认获取到的是工厂bean调用getObject创建的对象
64      *      2）、要获取工厂Bean本身，我们需要给id前面加一个&
65      *          &colorFactoryBean
66      */
67     @Bean
68     public ColorFactoryBean colorFactoryBean(){
69         return new ColorFactoryBean();
70     }

 

二 实现Condition进行注入

 1 Springboot有大量的@ConditionXXXX注解
 2 
 3 public class LinuxCondition implements Condition {
 4 ?
 5     /**
 6      * ConditionContext：判断条件能使用的上下文（环境）
 7      * AnnotatedTypeMetadata：注释信息
 8      */
 9     public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
10         // TODO是否linux系统
11         //1、能获取到ioc使用的beanfactory
12         ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
13         //2、获取类加载器
14         ClassLoader classLoader = context.getClassLoader();
15         //3、获取当前环境信息
16         Environment environment = context.getEnvironment();
17         //4、获取到bean定义的注册类
18         BeanDefinitionRegistry registry = context.getRegistry();
19 ?
20         String property = environment.getProperty("os.name");
21 ?
22         //可以判断容器中的bean注册情况，也可以给容器中注册bean
23         boolean definition = registry.containsBeanDefinition("person");
24         if(property.contains("linux")){
25             return true;
26         }
27 ?
28         return false;
29     }
30 ?
31 }

 

三 实现ImportSelector

 1 public class MyImportSelector implements ImportSelector {
 2 ?
 3     //返回值，就是到导入到容器中的组件全类名
 4     //AnnotationMetadata:当前标注@Import注解的类的所有注解信息
 5     public String[] selectImports(AnnotationMetadata importingClassMetadata) {
 6         // TODO Auto-generated method stub
 7         //importingClassMetadata
 8         //方法不要返回null值
 9         return new String[]{"com.atguigu.bean.Blue","com.atguigu.bean.Yellow"};
10     }
11 ?
12 }

 

四 实现ImportBeanDefinitionRegistrar

 1 public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
 2 ?
 3     /**
 4      * AnnotationMetadata：当前类的注解信息
 5      * BeanDefinitionRegistry:BeanDefinition注册类；
 6      *      把所有需要添加到容器中的bean；调用
 7      *      BeanDefinitionRegistry.registerBeanDefinition手工注册进来
 8      */
 9     @Override
10     public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
11         
12         boolean definition = registry.containsBeanDefinition("com.atguigu.bean.Red");
13         boolean definition2 = registry.containsBeanDefinition("com.atguigu.bean.Blue");
14         if(definition && definition2){
15             //指定Bean定义信息；（Bean的类型，Bean。。。）
16             RootBeanDefinition beanDefinition = new RootBeanDefinition(RainBow.class);
17             //注册一个Bean，指定bean名
18             registry.registerBeanDefinition("rainBow", beanDefinition);
19         }
20     }
21 ?
22 }

 

五 实现 FactoryBean

 1 / /创建一个Spring定义的FactoryBean
 2 public class ColorFactoryBean implements FactoryBean<Color> {
 3 ?
 4     //返回一个Color对象，这个对象会添加到容器中
 5     @Override
 6     public Color getObject() throws Exception {
 7         // TODO Auto-generated method stub
 8         System.out.println("ColorFactoryBean...getObject...");
 9         return new Color();
10     }
11 ?
12     @Override
13     public Class<?> getObjectType() {
14         // TODO Auto-generated method stub
15         return Color.class;
16     }
17 ?
18     //是单例？
19     //true：这个bean是单实例，在容器中保存一份
20     //false：多实例，每次获取都会创建一个新的bean；
21     @Override
22     public boolean isSingleton() {
23         // TODO Auto-generated method stub
24         return false;
25     }
26 ?
27 }
28 ?