目录
第六种加载bean方式-实现ImportSelector接口
第七种加载bean方式-实现ImportBeanDefinitionRegistrar
第八种bean的加载方式-实现BeanDefinitionRegistryPostProcessor
第一种bean的加载方式-配置文件
先创建一个使用maven的spring工程
导入spring核心配置
-
<dependency>
-
<groupId>org.springframework
</groupId>
-
<artifactId>spring-context
</artifactId>
-
<version>5.3.9
</version>
-
</dependency>
创建一个类
-
public
class
Cat {
-
-
}
-
public
class
Dog {
-
}
创建一个名为applicationContext.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">
-
-
<bean id="cat" class="com.service.Cat"/>
-
<bean id="dog" class="com.service.Dog"/>
-
-
</beans>
创建一个启动类
-
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
-
-
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等
替换配置文件中的<bean id= class=..>
-
@Component("cat")
//起的名
-
public
class
Cat {
-
-
}
-
@Component
-
public
class
Dog {
-
}
使用完注解还得让spring去扫描到这个注解，在配置文件中的写
-
<?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
-
-
">
-
-
<!--告诉spring扫描哪个包component导入context命名空间-->
-
<context:component-scan base-package="com"/>
-
-
-
</beans>
运行结果
创建第三方的bean对象
先导入对应的坐标
-
<dependency>
-
<groupId>com.alibaba
</groupId>
-
<artifactId>druid
</artifactId>
-
<version>1.1.24
</version>
-
</dependency>
创建一个类，返回你需要导入的对象即可，加入注解
-
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方式-不使用配置文件
创建一个类代替配置文件
-
package com.config;
-
-
import org.springframework.context.annotation.ComponentScan;
-
import org.springframework.context.annotation.Configuration;
-
-
@Configuration
//定义为配置类
-
@ComponentScan({"com.config","com.service"})
//注解扫描包
-
public
class
springConfig {
-
}
运行类也得修改
-
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接口创建出来的对象不是本身而是里面的泛型。
创建一个类实现接口
-
package com.config;
-
-
import com.service.Dog;
-
import org.springframework.beans.factory.FactoryBean;
-
import org.springframework.context.annotation.Bean;
-
-
public
class
DogFactoryBean
implements
FactoryBean<Dog> {
-
public Dog
getObject
()
throws Exception {
-
return
new
Dog();
-
}
-
//返回对象的类型
-
public Class<?> getObjectType() {
-
-
//这里可以做一系列的初始化工作
-
return Dog.class;
-
}
-
-
//是否是单例，单例则多次获取都是一个对象
-
public
boolean
isSingleton
() {
-
return
false;
-
}
-
}
-
@Component
-
public
class
Dog {
-
}
启动的主类
-
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"})
-
@Configuration
-
@ComponentScan("com")
-
@ImportResource({"applicationContext2.xml","applicationContext.xml"})
-
public
class
SpringConfig2 {
-
@Bean
-
public Cat
cat
(){
-
return
new
Cat();
-
}
-
}
两个配置文件中的bean，排在前面的首先加载，后面的之后加载，同的内容以之后的为主，不同的内容都加载。
扩展-proxyBeanMethods属性-产生代理对象
@Configuration注解中有一属性proxyBeanMethod属性，默认值是true
值为false时
-
@Configuration(proxyBeanMethods = false)
-
@ComponentScan("com")
-
@ImportResource({"applicationContext2.xml","applicationContext.xml"})
-
public
class
SpringConfig2 {
-
@Bean
-
public Cat
cat
(){
-
return
new
Cat();
-
}
-
}
主方法中
-
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时
-
@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字节码对象
在类中
-
import com.service.TestBean1;
-
import com.service.TestBean2;
-
import org.springframework.context.annotation.Import;
-
-
@Import({TestBean1.class, TestBean2.class})
-
public
class
springConfig4 {
-
}
创建测试的类
-
public
class
TestBean1 {
-
}
-
public
class
testBean2 {
-
}
主类上
-
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获取上下文对象
-
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类下
-
@Component
-
public
class
Dog {
-
-
int age;
-
public
Dog
(){}
-
-
public
Dog
(int age){
-
this.age=age;
-
}
-
-
@Override
-
public String
toString
() {
-
return
"Dog{" +
-
"age=" + age +
-
'}';
-
}
-
}
运行结果 ，当有多个的时候，且bean的名字一致时，以最后的为准。
或者直接使用
app.register(Cat.class);也可以快速的加载一个bean
第六种加载bean方式-实现ImportSelector接口
这个接口有许多方法用来判定
导入实现了ImportSelector接口的类，实现对导入源的编程式处理
-
-
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"};
-
}
-
}
-
@Import({MyImportSelector.class})
-
public
class
SpringConfig6 {
-
}
-
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的覆盖，进而达到
-
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);
-
}
-
}
-
@Import({MyRegistrar.class})
-
public
class
SpringConfig7 {
-
}
运行结果
第八种bean的加载方式-实现BeanDefinitionRegistryPostProcessor
导入实现了BeanDefinitionRegistryPostProcessor接口的类，通过BeanDefintion的注册器注册实名bean，实现对容器中bean的最终裁定.(以这个接口加载的bean为主)
-
@Component
-
public
class
DBconfig {
-
@Bean
-
public DruidDataSource
dataSource
(){
-
DruidDataSource
ds
=
new
DruidDataSource();
-
return ds;
-
}
-
}
-
-
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 {
-
-
}
-
}
-
@Import({MyPostProcessor.class})
-
public
class
SpringConfig8 {
-
}
运行结果
实现bean的方式总结
1.xml+<bean/>
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接口
转载：https://blog.csdn.net/weixin_60719453/article/details/127496208
查看评论