欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

Spring注解学习总结---IOC部分

程序员文章站 2022-06-28 16:14:30
目录一、组件注册1.@Configration & @Bean2.@ComponentScan3.@Scope & @Lazy4.@Conditional4.@Import5.FactoryBean二、Bean的生命周期三、属性赋值四、自动装配1.@Autowired2.@Resource & @Inject3.Aware接口4.@Profile参考:https://www.bilibili.com/video/BV1gW411W7wy一、组件注册1.@Configration...

参考:https://www.bilibili.com/video/BV1gW411W7wy

一、组件注册

1.@Configration & @Bean

@Configuration
//告知Spring这是一个配置类,等价于配置文件
public class MainConfig {
	//@Bean,注册实例放入IOC容器,默认单实例
	//给容器中注册一个Bean实例,类型为返回值的类型,Bean实例名称默认是用方法名
	//可以在注解中添加参数,来设置Bean实例名称
	@Bean("person")
	public Person person01(){
		return new Person("dxs", 20);
	}
}

2.@ComponentScan

@ComponentScan((value = "包路径"))
//表示扫描路径下的所有类
//扫描标注了@Controller、@Service、@Repository,@Component注解的类,创建实例加入IOC容器
//excludeFilters = Filter[] :指定扫描的时候按照什么规则排除那些组件
//includeFilters = Filter[] :指定扫描的时候只需要包含哪些组件
//FilterType.ANNOTATION:按照注解
//FilterType.ASSIGNABLE_TYPE:按照给定的类型
//FilterType.ASPECTJ:使用ASPECTJ表达式
//FilterType.REGEX:使用正则指定
//FilterType.CUSTOM:使用自定义规则
//useDefaultFilters=true:禁用默认过滤规则,使includeFilters生效

//ComponentScan数组
@ComponentScans(
		value = {
	@ComponentScan(value="包路径",includeFilters = {
		//包含Controller注解标注的类
		@Filter(type=FilterType.ANNOTATION,classes={Controller.class}),
		//包含指定类型的类(包含子类、实现类)
		@Filter(type=FilterType.ASSIGNABLE_TYPE,classes={BookService.class}),
		//
		@Filter(type=FilterType.CUSTOM,classes={MyTypeFilter.class})
},useDefaultFilters = false)
	}
)
//源码解释
/** Filter candidates using a given custom
	 * {@link org.springframework.core.type.filter.TypeFilter} implementation.
	 */
//	CUSTOM
//自定义过滤器,需要是实现TypeFilter接口

public class MyTypeFilter implements TypeFilter {

	/**
	 * metadataReader:读取到的当前正在扫描的类的信息
	 * metadataReaderFactory:可以获取到其他任何类信息的
	 */
	@Override
	public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory)
			throws IOException {
		// TODO Auto-generated method stub
		//获取下面三个参数,代表当前扫描到的类的的三种信息
		//获取当前类注解的信息
		AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();
		//获取当前正在扫描的类的类信息
		ClassMetadata classMetadata = metadataReader.getClassMetadata();
		//获取当前类资源(类的路径)
		Resource resource = metadataReader.getResource();
		
		//实例
		//通过类信息,获取类名包含er字符的类
		String className = classMetadata.getClassName();
		System.out.println("--->"+className);
		if(className.contains("er")){
			return true;
		}
		return false;
	}

}

3.@Scope & @Lazy

//@Bean默认注册的是单实例
//@Scope:调整作用域
//通过@Scope修改
@Scope("prototype")

prototype:多实例的:ioc容器启动并不会去调用方法创建对象放在容器中。
		  每次获取的时候才会调用方法创建对象;
		  
singleton:单实例的(默认值):ioc容器在启动后,会自动调用方法创建对象放到ioc容器中。
		  以后每次获取就是直接从容器(map.get())中拿,

针对默认单实例情况下:
使用 @Lazy 懒加载:
	 单实例bean:默认在容器启动的时候创建对象;
	 懒加载:容器启动不创建对象。第一次使用(获取)Bean创建对象,并初始化;

4.@Conditional

@Conditional({Condition}) : 按照一定的条件进行判断,满足条件给容器中注册bean
@Conditional({XXXCondition.class})
//放在方法上,表示满足条件才注册bean
//放在类上,类中组件统一设置。满足当前条件,这个类中配置的所有bean注册才能生效
//自定义条件,实现Condition接口
public class XXXCondition implements Condition {

	/**
	 * ConditionContext:判断条件能使用的上下文(环境)
	 * AnnotatedTypeMetadata:注释信息
	 */
	@Override
	public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
		
		//1、能获取到ioc使用的beanfactory
		ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
		//2、获取类加载器
		ClassLoader classLoader = context.getClassLoader();
		//3、获取当前环境信息
		Environment environment = context.getEnvironment();
		//4、获取到bean定义的注册类
		BeanDefinitionRegistry registry = context.getRegistry();
		
		if(...){
			...
			return true;
		}
		
		return false;
	}

}

5.@Import

//类上的注解
@Import[快速给容器中导入一个组件]

1@Import({XXX.class,MyImportSelector.class});容器中就会自动注册这个组件,组件id默认是全类名

2)ImportSelector:返回需要导入的组件的全类名数组;
//自定义逻辑返回需要导入的组件
public class MyImportSelector implements ImportSelector {

	//返回值,就是到导入到容器中的组件全类名
	//AnnotationMetadata:当前标注@Import注解的类的所有注解信息(@Bean、@Conditional等等这个类上有的注解)
	@Override
	public String[] selectImports(AnnotationMetadata importingClassMetadata) {
		// TODO Auto-generated method stub
		//importingClassMetadata
		//方法不要返回null值
		return new String[]{"全类名","com.dxs.bean.XXX"};
	}

}

3)ImportBeanDefinitionRegistrar:手动注册bean到容器中
public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {

	/**
	 * AnnotationMetadata:当前类的注解信息
	 * BeanDefinitionRegistry:BeanDefinition注册类;
	 * 		把所有需要添加到容器中的bean;调用
	 * 		BeanDefinitionRegistry.registerBeanDefinition手动注册进来
	 */
	@Override
	public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
		//判断是IOC容器中是否存在,根据id判断
		boolean definition = registry.containsBeanDefinition("com.dxs.bean.Red");
		boolean definition2 = registry.containsBeanDefinition("com.dxs.bean.Blue");
		if(definition && definition2){
			//指定Bean定义信息;(Bean的类型,Bean作用域等等)
			BeanDefinition beanDefinition = new RootBeanDefinition(RainBow.class);
			//注册一个Bean,指定bean名和BeanDefinition
			registry.registerBeanDefinition("rainBow", beanDefinition);
		}
	}

}

6.FactoryBean

使用Spring提供的 FactoryBean(工厂Bean),来创建实例对象
1)默认获取到的是工厂bean调用getObject创建的对象
2)要获取工厂Bean本身,我需要给id前面加一个&
	如:&xxxFactoryBean
//创建一个Spring定义的FactoryBean
public class XXXFactoryBean implements FactoryBean<Integer> {

	//返回一个Integer对象,这个对象会添加到容器中
	@Override
	//Integer,这个对象会添加到容器中
	@Override
	public Integer getObject() throws Exception {
		// TODO Auto-generated method stub
		System.out.println("XXXFactoryBean...getObject...");
		return new Integer(0);
	}

	@Override
	public Class<?> getObjectType() {
		// TODO Auto-generated method stub
		return Color.class;
	}

	//是单例?
	//true:这个bean是单实例,在容器中保存一份
	//false:多实例,每次获取都会创建一个新的bean;
	@Override
	public boolean isSingleton() {
		// TODO Auto-generated method stub
		return true;
	}
}
@Bean
public XXXFactoryBean xxxFactoryBean(){
	return new XXXFactoryBean();
}
注册后,IOC中会有名为xxxFactoryBean的组件,但它的类型实际上是getObject中返回的对象类型。
在多实例下,每次都是调用getObject获取的实例。

二、Bean的生命周期

bean的生命周期:bean创建—>初始化---->销毁

构造(对象创建)
	单实例:在容器启动的时候创建对象
	多实例:在每次获取的时候创建对象

初始化之前:
BeanPostProcessor.postProcessBeforeInitialization		
初始化:
	对象创建完成,并赋值好后,调用初始化方法
初始化之后:
BeanPostProcessor.postProcessAfterInitialization

销毁:
	单实例:容器关闭的时候销毁
	多实例:容器不会管理这个bean;容器不会调用销毁方法;可以手动调用销毁
	
@Bean(initMethod="类中定义的初始化方法名",destroyMethod="类中定义的销毁方法名")

指定初始化和销毁方法;
1)通过@Bean指定initMethod和destroyMethod;

2)通过让Bean实现InitializingBean(定义初始化逻辑),DisposableBean(定义销毁逻辑)接口

3)可以使用JSR250(Java注解
	//作用在方法上的注解(构造之后
 	@PostConstruct:在bean创建完成并且属性赋值完成;来执行初始化方法
 	//作用在方法上的注解(销毁之前
	@PreDestroy:在容器销毁bean之前通知我们进行清理工作
	
4)BeanPostProcessor【interface】:bean的后置处理器;在bean初始化前后进行一些处理工作;
	//接口的两个方法
	//参数一表示新的bean实例,参数二表示实例名称
	//返回值:要使用的bean实例(可以对bean参数包装或直接返回
	postProcessBeforeInitialization:在初始化之前工作
	postProcessAfterInitialization:在初始化之后工作
/**
 * 后置处理器:初始化前后进行处理工作
 * 将后置处理器加入到容器中
 * @author lfy
 */
@Component
public class MyBeanPostProcessor implements BeanPostProcessor {

	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		// TODO Auto-generated method stub
		System.out.println("postProcessBeforeInitialization..."+beanName+"=>"+bean);
		return bean;
	}

	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		// TODO Auto-generated method stub
		System.out.println("postProcessAfterInitialization..."+beanName+"=>"+bean);
		return bean;
	}

}

BeanPostProcessor执行原理简单分析

Spring注解学习总结---IOC部分

AbstractAutowireCapableBeanFactory.java中的initializeBean方法
Spring注解学习总结---IOC部分

//整体过程:
populateBean(beanName, mbd, instanceWrapper);给bean进行属性赋值
initializeBean
{
	applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);//初始化之前执行
	invokeInitMethods(beanName, wrappedBean, mbd);执行自定义初始化
	applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);//初始化之后执行
}
//查看详细代码
//分析:
//遍历得到容器中所有的BeanPostProcessor;挨个执行beforeInitialization,一但返回null,跳出for循环,不会执行后面BeanPostProcessor.postProcessorsBeforeInitialization
 @Override
	public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
			throws BeansException {

		Object result = existingBean;
		for (BeanPostProcessor processor : getBeanPostProcessors()) {
			Object current = processor.postProcessBeforeInitialization(result, beanName);
			if (current == null) {
				return result;
			}
			result = current;
		}
		return result;
	}

三、属性赋值

//使用@Value赋值;
	//1、基本数值
	//2、可以写SpEL; #{}
	//3、可以写${};取出配置文件【properties】中的值(在运行环境变量里面的值)
	
	@Value("张三")
	private String name;
	@Value("#{20-2}")
	private Integer age;
	
	@Value("${person.nickName}")
	private String nickName;
//想要使用配置文件,需要在配置类上添加注解引入配置文件
//使用@PropertySource读取外部配置文件中的k/v保存到运行的环境变量中;加载完外部的配置文件以后使用${}取出配置文件的值
@PropertySource(value={"classpath:/person.properties"})
@Configuration
public class MainConfigOfPropertyValues {
	
	@Bean
	public Person person(){
		return new Person();
	}

}

四、自动装配

自动装配,Spring利用依赖注入(DI),完成对IOC容器中中各个组件的依赖关系赋值。

1.@Autowired

@Autowired:自动注入属性:

  • 默认优先按照类型去容器中找对应的组件,找到就赋值
    类似于:applicationContext.getBean(XXX.class)
  • 如果找到多个相同类型的组件,再将属性的名称作为组件的id去容器中查找,即根据id查找
  • @Qualifier(“XXX”):使用@Qualifier指定需要装配的组件的id,而不是使用属性名
  • 自动装配默认一定要将属性赋值好,容器中没有就会报错;可以使用@Autowired(required=false),如果容器中没有,会设置为null
  • @Primary:让Spring进行自动装配的时候,首选有@Primary注解的bean

@Autowired:可标注在构造器,参数,方法,属性都是从容器中获取参数组件的值

  1. [标注在方法位置]:@Bean标注的方法创建对象的时候,方法参数的值从容器中获取;默认不写@Autowired效果是一样的;都能自动装配
  2. [标在构造器上]:如果组件只有一个有参构造器,这个有参构造器的@Autowired可以省略,参数位置的组件还是可以自动从容器中获取
  3. [放在参数位置]

2.@Resource & @Inject

Spring还支持使用@Resource(JSR250)和@Inject(JSR330)[java规范的注解]
@Resource:

  • 可以和@Autowired一样实现自动装配功能;默认是按照组件名称进行装配的;可以修改参数name指定装配的组件
  • 没有能支持@Primary功能,没有支持@Autowired(reqiured=false)

@Inject:

  • 需要导入javax.inject的包,和Autowired的功能一样。没有required=false的功能;

@Autowired:Spring定义的; @Resource、@Inject都是java规范

AutowiredAnnotationBeanPostProcessor:解析完成自动装配功能

3.Aware接口

//通过实现xxxAware接口,在创建对象额时候,会调用重写的接口方法,实现把Spring底层一些组件注入到自定义的Bean中

//xxxAware:通过使用xxxProcessor实现功能
@Component
public class awareTest implements ApplicationContextAware,BeanNameAware,EmbeddedValueResolverAware {
	
	private ApplicationContext applicationContext;

	@Override
	public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
		// TODO Auto-generated method stub
		System.out.println("传入的ioc:"+applicationContext);
		this.applicationContext = applicationContext;
	}

	@Override
	public void setBeanName(String name) {
		// TODO Auto-generated method stub
		System.out.println("当前bean的名字:"+name);
	}

	@Override
	public void setEmbeddedValueResolver(StringValueResolver resolver) {
		// TODO Auto-generated method stub
		String resolveStringValue = resolver.resolveStringValue("你好 ${os.name} 我是 #{20*18}");
		System.out.println("解析的字符串:"+resolveStringValue);
	}
}
//基本原理
//在bean初始化时,后置处理器会判断是不是aware接口,并回调实现的接口方法。

//例如:ApplicationContextAware源码
@Override
	@Nullable
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		//判断是不是Aware
		if (!(bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
				bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
				bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware ||
				bean instanceof ApplicationStartupAware)) {
			return bean;
		}

		AccessControlContext acc = null;

		if (System.getSecurityManager() != null) {
			acc = this.applicationContext.getBeanFactory().getAccessControlContext();
		}

		if (acc != null) {
			AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
				invokeAwareInterfaces(bean);
				return null;
			}, acc);
		}
		else {
		//是的话会调用这个方法
			invokeAwareInterfaces(bean);
		}

		return bean;
	}

private void invokeAwareInterfaces(Object bean) {
//if里的setxxx都是我们实现的接口方法,即回调这些该方法
		if (bean instanceof EnvironmentAware) {
			((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
		}
		if (bean instanceof EmbeddedValueResolverAware) {
			((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
		}
		if (bean instanceof ResourceLoaderAware) {
			((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
		}
		if (bean instanceof ApplicationEventPublisherAware) {
			((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
		}
		if (bean instanceof MessageSourceAware) {
			((MessageSourceAware) bean).setMessageSource(this.applicationContext);
		}
		if (bean instanceof ApplicationStartupAware) {
			((ApplicationStartupAware) bean).setApplicationStartup(this.applicationContext.getApplicationStartup());
		}
		if (bean instanceof ApplicationContextAware) {
			((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
		}
	}

4.@Profile

@Profile:可以根据当前环境,动态的激活和切换一系列组件的功能。

@Profile:指定组件在哪个环境的情况下才能被注册到容器中,如果不指定,任何环境下都能注册这个组件

  1. 加了环境标识的bean,只有这个环境被激活的时候才能注册到容器中。默认是default环境(@Profile(“default”)
  2. 写在配置类上,只有是指定的环境的时候,整个配置类里面的所有配置才能开始生效
  3. 没有标注环境标识的bean在,任何环境下都是加载的
//例如:数据源
@PropertySource("classpath:/dbconfig.properties")
@Configuration
public class MainConfigOfProfile implements EmbeddedValueResolverAware{
	
	@Value("${db.user}")
	private String user;
	
	private StringValueResolver valueResolver;
	
	private String  driverClass;
	
	
	@Bean
	public Yellow yellow(){
		return new Yellow();
	}
	
	@Profile("test")
	@Bean("testDataSource")
	public DataSource dataSourceTest(@Value("${db.password}")String pwd) throws Exception{
		ComboPooledDataSource dataSource = new ComboPooledDataSource();
		dataSource.setUser(user);
		dataSource.setPassword(pwd);
		dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/test");
		dataSource.setDriverClass(driverClass);
		return dataSource;
	}
	
	
	@Profile("dev")
	@Bean("devDataSource")
	public DataSource dataSourceDev(@Value("${db.password}")String pwd) throws Exception{
		ComboPooledDataSource dataSource = new ComboPooledDataSource();
		dataSource.setUser(user);
		dataSource.setPassword(pwd);
		dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/ssm_crud");
		dataSource.setDriverClass(driverClass);
		return dataSource;
	}
	
	@Profile("prod")
	@Bean("prodDataSource")
	public DataSource dataSourceProd(@Value("${db.password}")String pwd) throws Exception{
		ComboPooledDataSource dataSource = new ComboPooledDataSource();
		dataSource.setUser(user);
		dataSource.setPassword(pwd);
		dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/scw_0515");
		
		dataSource.setDriverClass(driverClass);
		return dataSource;
	}

	@Override
	public void setEmbeddedValueResolver(StringValueResolver resolver) {
		// TODO Auto-generated method stub
		this.valueResolver = resolver;
		driverClass = valueResolver.resolveStringValue("${db.driverClass}");
	}

}
//1、使用命令行动态参数: 在虚拟机参数位置加载 -Dspring.profiles.active=xxx

//2、代码的方式激活某种环境;
	AnnotationConfigApplicationContext applicationContext = 
				new AnnotationConfigApplicationContext();
	//1、创建一个applicationContext
	//2、设置需要激活的环境
	applicationContext.getEnvironment().setActiveProfiles("dev");
	//3、注册主配置类
	applicationContext.register(MainConfigOfProfile.class);
	//4、启动刷新容器
	applicationContext.refresh();

本文地址:https://blog.csdn.net/weixin_44759105/article/details/113953609