IT俱乐部 Java SpringBoot加载bean的八种方式总结

SpringBoot加载bean的八种方式总结

发布: 2023年 4月 4日 509阅读

第一种bean的加载方式-配置文件

先创建一个使用maven的spring工程

导入spring核心配置

1
org.springframeworkspring-context5.3.9

创建一个类

1
2
3
public  class Cat {
     
}
1
2
public class Dog {
}

创建一个名为applicationContext.xml的配置文件

1
 

创建一个启动类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package com.app;
  
import com.service.Dog;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
  
public class App1 {
    public static void main(String[] args) {
        ApplicationContext app=new ClassPathXmlApplicationContext("applicationContext.xml");
        Object cat = app.getBean("cat");//根据id获取
        System.out.println(cat);
        Object dog = app.getBean(Dog.class);//根据类获取，当不唯一时会报错
        System.out.println(dog);
  
    }
}

运行结果，这样就可以得到bean的对象了

或者使用可以使用一次性获取所有bean

1
2
3
4
5
6
7
8
9
10
public class App1 {
    public static void main(String[] args) {
        ApplicationContext app=new ClassPathXmlApplicationContext("applicationContext.xml");
  
        String[] names = app.getBeanDefinitionNames();
        for (String name : names) {
            System.out.println(name);
        }
    }
}

 运行结果

 第二种加载bean方式-注解和扫描

使用注解，注解的作用就是替代配置文件的配置，注解有@Component @Service @Repository等

替换配置文件中的

1
2
3
4
@Component("cat") //起的名
public class Cat {
  
}
1
2
3
@Component
public class Dog {
}

使用完注解还得让spring去扫描到这个注解，在配置文件中的写

1
 

运行结果 

创建第三方的bean对象

先导入对应的坐标

1
com.alibabadruid1.1.24

创建一个类，返回你需要导入的对象即可，加入注解 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package com.config;
  
import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;
  
@Component
public class DBconfig {
    @Bean
    public DruidDataSource dataSource(){
        DruidDataSource ds =new DruidDataSource();
        return ds;
    }
}

运行结果

 第三种加载bean方式-不使用配置文件

创建一个类代替配置文件

1
2
3
4
5
6
7
8
9
package com.config;
  
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
  
@Configuration//定义为配置类
@ComponentScan({"com.config","com.service"}) //注解扫描包
public class springConfig {
}

运行类也得修改

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package com.app;
  
import com.config.springConfig;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
  
public class App2 {
    public static void main(String[] args) {
ApplicationContext app=new AnnotationConfigApplicationContext(springConfig.class);
  
        String[] names = app.getBeanDefinitionNames();
        for (String name : names) {
            System.out.println(name);
        }
    }
}

运行结果 

扩展-bean的加载方式扩展FactoryBean

初始化实现FactoryBean接口的类，实现对bean加载到容器之前的批处理操作。

实现了FactoryBean接口创建出来的对象不是本身而是里面的泛型。

创建一个类实现接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package com.config;
  
import com.service.Dog;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.context.annotation.Bean;
  
public class DogFactoryBean implements FactoryBean {
    public Dog getObject() throws Exception {
        return new Dog();
    }
//返回对象的类型
    public Class> getObjectType() {
  
        //这里可以做一系列的初始化工作
        return Dog.class;
    }
  
    //是否是单例，单例则多次获取都是一个对象
    public boolean isSingleton() {
        return false;
    }
}
1
2
3
@Component
public class Dog {
}

启动的主类 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import com.config.springConfig;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
  
public class App2 {
    public static void main(String[] args) {
ApplicationContext app=new AnnotationConfigApplicationContext(springConfig.class);
  
        String[] names = app.getBeanDefinitionNames();
        for (String name : names) {
            System.out.println(name);
        }
        System.out.println(app.getBean("dog1"));
        System.out.println(app.getBean("dog1"));
    }
}

运行结果

 产生的是泛型的对象

扩展-@ImportResource导入配置文件

 看源码可知道，可以写入多个string类型的数组，使用{}

@ImportResource({“applicationContext2.xml”,”applicationContext.xml”})

1
2
3
4
5
6
7
8
9
@Configuration
@ComponentScan("com")
@ImportResource({"applicationContext2.xml","applicationContext.xml"})
public class SpringConfig2 {
    @Bean
    public Cat cat(){
        return new Cat();
    }
}

 两个配置文件中的bean，排在前面的首先加载，后面的之后加载，同的内容以之后的为主，不同的内容都加载。

扩展-proxyBeanMethods属性-产生代理对象

@Configuration注解中有一属性proxyBeanMethod属性，默认值是true

 值为false时

1
2
3
4
5
6
7
8
9
@Configuration(proxyBeanMethods = false)
@ComponentScan("com")
@ImportResource({"applicationContext2.xml","applicationContext.xml"})
public class SpringConfig2 {
    @Bean
    public Cat cat(){
        return new Cat();
    }
}

主方法中

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class app3 {
    public static void main(String[] args) {
        ApplicationContext app=new AnnotationConfigApplicationContext(SpringConfig2.class);
        String[] names = app.getBeanDefinitionNames();
        for (String name : names) {
            System.out.println(name);
        }
  
        System.out.println("--------");
        System.out.println(app.getBean("springConfig2"));
  
        SpringConfig2 springConfig2 = app.getBean("springConfig2", SpringConfig2.class);
        System.out.println(springConfig2.cat());
        System.out.println(springConfig2.cat());
        System.out.println(springConfig2.cat());
  
    }
}

运行结果 

 产生的是普通对象，每一次调用方法都会new一个新的对象前提是这个方法是被bean管理的对象。

  值为true时

不写或写true时

1
2
3
4
5
6
7
8
9
@Configuration(proxyBeanMethods = true)
@ComponentScan("com")
@ImportResource({"applicationContext2.xml","applicationContext.xml"})
public class SpringConfig2 {
    @Bean
    public Cat cat(){
        return new Cat();
    }
}

运行结果

 会产生一个代理对象，这个代理对象让我们每次调用方法是都是同一个，前提也是需要被bean容器管理

注：产生的bean对象没指定名称时，默认是方法名或类名首字母小写，如类名是SpringTest则产生的bean是springTest 

第四种加载bean方式-使用@Import

翻看@Import源码可知，需要一个类class字节码对象

 在类中

1
2
3
4
5
6
7
import com.service.TestBean1;
import com.service.TestBean2;
import org.springframework.context.annotation.Import;
  
@Import({TestBean1.class, TestBean2.class})
public class springConfig4 {
}

 创建测试的类

1
2
public class TestBean1 {
}
1
2
public class testBean2 {
}

主类上

1
2
3
4
5
6
7
8
9
10
public class app4 {
    public static void main(String[] args) {
        ApplicationContext app=new AnnotationConfigApplicationContext(springConfig4.class);
        String[] names = app.getBeanDefinitionNames();
        for (String name : names) {
            System.out.println(name);
        }
  
    }
}

运行结果

 全路径名，加入的类即使没有被spring管理也可以产生bean。

第五种加载bean方式-registerBean

使用上下文对象在容器初始化后注入bean

在创建完上下文对象的时候可以加载bean

只能使用 AnnotationConfigApplicationContext获取上下文对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class app5 {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext app=new AnnotationConfigApplicationContext(springConfig5.class);
    //加载完成后
        app.registerBean("CaiDog", Dog.class,1 );
        app.registerBean("CaiDog", Dog.class,2);
        app.registerBean("CaiDog", Dog.class,3 );
        String[] names = app.getBeanDefinitionNames();
        for (String name : names) {
            System.out.println(name);
        }
  
        System.out.println("------");
        System.out.println(app.getBean(Dog.class));
    }
}

 Dog类下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@Component
public class Dog {
  
    int age;
    public Dog(){}
  
    public Dog(int age){
        this.age=age;
    }
  
    @Override
    public String toString() {
        return "Dog{" +
                "age=" + age +
                '}';
    }
}

运行结果 ，当有多个的时候，且bean的名字一致时，以最后的为准。

或者直接使用

1
app.register(Cat.class);

也可以快速的加载一个bean

第六种加载bean方式-实现ImportSelector接口

这个接口有许多方法用来判定

导入实现了ImportSelector接口的类，实现对导入源的编程式处理

1
2
3
4
5
6
7
8
9
10
11
public class MyImportSelector implements ImportSelector {
    public String[] selectImports(AnnotationMetadata annotationMetadata) {//AnnotationMetadata 注解的源数据
     //  做判定条件，是否有这个注解
        boolean flag = annotationMetadata.hasAnnotation("org.springframework.context.annotation.Configuration");
        if (flag){
            return new String[]{"com.service.Dog"};
        }
  
        return new String[]{"com.service.Cat"};
    }
}
1
2
3
@Import({MyImportSelector.class})
public class SpringConfig6 {
}
1
2
3
4
5
6
7
8
9
10
11
public class app6 {
    public static void main(String[] args) {
        ApplicationContext app=new AnnotationConfigApplicationContext(SpringConfig6.class);
        String[] names = app.getBeanDefinitionNames();
        for (String name : names) {
            System.out.println(name);
        }
  
  
    }
}

运行结果 

 第七种加载bean方式-实现ImportBeanDefinitionRegistrar

导入实现ImportBeanDefinitionRegistrar接口的类，通过BeanDefinition的注册器注册实名bean，实现对容器中bean的决定，例如对现有的bean的覆盖，进而达到

1
2
3
4
5
6
7
8
9
10
11
12
import com.service.Dog;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import org.springframework.core.type.AnnotationMetadata;
public class MyRegistrar implements ImportBeanDefinitionRegistrar {
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        BeanDefinition beanDefinition= BeanDefinitionBuilder.rootBeanDefinition(Dog.class).getBeanDefinition();
        registry.registerBeanDefinition("woDog", beanDefinition);
    }
}
1
2
3
@Import({MyRegistrar.class})
public class SpringConfig7 {
}

 运行结果

第八种bean的加载方式-实现BeanDefinitionRegistryPostProcessor

导入实现了BeanDefinitionRegistryPostProcessor接口的类，通过BeanDefintion的注册器注册实名bean，实现对容器中bean的最终裁定.(以这个接口加载的bean为主)

1
2
3
4
5
6
7
8
@Component
public class DBconfig {
    @Bean
    public DruidDataSource dataSource(){
        DruidDataSource ds =new DruidDataSource();
        return ds;
    }
}
1
2
3
4
5
6
7
8
9
10
11
public class MyPostProcessor implements BeanDefinitionRegistryPostProcessor {
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
 BeanDefinition beanDefinition = BeanDefinitionBuilder.rootBeanDefinition(DBconfig.class).getBeanDefinition();
  
    registry.registerBeanDefinition("dataSource",beanDefinition);
    }
  
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
  
    }
}
1
2
3
@Import({MyPostProcessor.class})
public class SpringConfig8 {
}

运行结果

 实现bean的方式总结

1.xml+

2.xml:context+注解(@Component+4个@Bean

3.配置类+扫描+注解(@Component+4个@Bean)

@Bean定义FactoryBean接口@ImportResource@Configuration注解的proxyBeanMethods属性

4.@Import导入bean的类

@Import导入配置类

5.AnnotationConfigApplicationContext调用register方法

6.@Import导入ImportSelector接口

7.@Import导入ImportBeanDefinitionRegistrar接口

8.@Import导入BeanDefinitionRegistryPostProcessor接口

到此这篇关于SpringBoot加载bean的八种方式的文章就介绍到这了,更多相关SpringBoot加载bean内容请搜索IT俱乐部以前的文章或继续浏览下面的相关文章希望大家以后多多支持IT俱乐部！

本文收集自网络，不代表IT俱乐部立场，转载请注明出处。https://www.2it.club/code/java/6560.html
52赞
标签:
上一篇
下一篇

相关推荐

联系我们

联系我们

在线咨询: QQ交谈

邮箱: 1120393934@qq.com

工作时间：周一至周五，9:00-17:30，节假日休息

关注微信
微信扫一扫关注我们

微信扫一扫关注我们

返回顶部