Spring注解学习总结---IOC部分
程序员文章站
2022-03-10 17:45:01
目录一、组件注册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执行原理简单分析
:
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:可标注在构造器,参数,方法,属性
;都是从容器中获取参数组件的值
- [标注在方法位置]:@Bean标注的方法创建对象的时候,方法参数的值从容器中获取;默认不写@Autowired效果是一样的;都能自动装配
- [标在构造器上]:如果组件只有一个有参构造器,这个有参构造器的@Autowired可以省略,参数位置的组件还是可以自动从容器中获取
- [放在参数位置]
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:指定组件在哪个环境的情况下才能被注册到容器中,如果不指定,任何环境下都能注册这个组件
- 加了环境标识的bean,只有这个环境被激活的时候才能注册到容器中。默认是default环境(@Profile(“default”)
- 写在配置类上,只有是指定的环境的时候,整个配置类里面的所有配置才能开始生效
- 没有标注环境标识的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