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

目录

• 一、组件注册
• 二、Bean的生命周期
• 三、属性赋值
• 四、自动装配

参考：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执行原理简单分析：

AbstractAutowireCapableBeanFactory.java中的initializeBean方法

//整体过程：
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