AnnotationConfigApplicationContext
Spring初始化流程
Spring循环依赖
SpringAOP
spring注解
@Configuration
一、组件添加
@ComponentScan
@Bean–InitializingBean（初始化设置值之后）DisposableBean（销毁）
@PostConstruct
@PreDestroy
@Configuration
@Component
@Service
@Controller
@Repository
@Conditional
@Primary
@Lazy
@Scope
@Import
FactoryBean 使用&beanName获取Factory本身
二、组件赋值
@Value
@Autowired
@Qualifier
@Resources
@PropertySource
@PropertySources
@Profile–Environment设置变量-Dspring.profiles.active=test
ApplicationContextAware
ApplicationContextAwareProcessor
xxxAware
三、Aop
@EnableAspectJAutoProxy
@Before/@After/@AfterReturning/@AfterThrowing/@Around
@Pointcut
四、声明式事务
@EnableTransactionManagement
@Transactional
基础知识
使用spring导包
Spring初始化流程
一、Spring的this()【创建三个重要对象】
在this()中创建了三个重要对象，DefaultListableBeanFactory是在父类GenericApplicationContext中创建的
1、AnnotatedBeanDefinitionReader(this);【将六个开天辟地的类放到beanDefintionMap中】
1）、internalConfigurationAnnotationProcessor
2）、internalAutowiredAnnotationProcessor
3）、internalRequiredAnnotationProcessor
4）、internalCommonAnnotationProcessor
5）、internalEventListenerProcessor
6）、internalEventListenerFactory
2、ClassPathBeanDefinitionScanner(this);
3、DefaultListableBeanFactory();
二、Sprinig的register(annotatedClasses)【注册配置类】
将创建来的annotatedClasses添加到beanDefintionMap中
三、Spring容器的refresh()【创建刷新】;
1、prepareRefresh()刷新前的预处理;
1）、initPropertySources()初始化一些属性设置;子类自定义的属性设置方法；空方法，可以重写增强
2）、getEnvironment().validateRequiredProperties();检验属性的合法等，将initPropertySources()中配置的属性进行校验
3）、earlyApplicationEvents= new LinkedHashSet<ApplicationEvent>();保存容器中的一些早期的事件；存储派发事件，当派发器要派发事件的时候要将事件派发到所有的ApplicationEvent中
2、obtainFreshBeanFactory();获取BeanFactory；
1）、refreshBeanFactory();刷新【创建】在GenericApplicationContext无参构造器中创建一个BeanFactory；
无参构造器中创建了一个this.beanFactory = new DefaultListableBeanFactory();
此处用到AtomicBoolean,进行cas操作尝试去刷新
设置序列化id；
2）、getBeanFactory();返回刚才GenericApplicationContext创建的BeanFactory对象；
3）、将创建的BeanFactory【DefaultListableBeanFactory】返回；
3、prepareBeanFactory(beanFactory);BeanFactory的预准备工作（BeanFactory进行一些设置）；
1）、设置BeanFactory的类加载器、支持表达式解析器【BeanExpressionResolver】...
2）、添加部分BeanPostProcessor【ApplicationContextAwareProcessor】
3）、设置忽略的自动装配的接口EnvironmentAware、EmbeddedValueResolverAware、xxx；
4）、注册可以解析的自动装配；我们能直接在任何组件中自动注入：
BeanFactory、ResourceLoader、ApplicationEventPublisher、ApplicationContext
5）、添加编译时的AspectJ用到的后置处理器【LoadTimeWeaverAwareProcessor】；
6）、给BeanFactory中注册一些能用的组件；
environment【ConfigurableEnvironment】、环境，其中有一些配置
systemProperties【Map<String, Object>】、系统属性
systemEnvironment【Map<String, Object>】、系统的环境变量信息
4、postProcessBeanFactory(beanFactory);BeanFactory准备工作完成后进行的后置处理工作；
1）、子类通过重写这个方法来在BeanFactory创建并预准备完成以后做进一步的设置、空方法
-----------------------------以上是BeanFactory的创建及预准备工作----------------
5、invokeBeanFactoryPostProcessors(beanFactory);执行BeanFactoryPostProcessor实现类的方法；
BeanFactoryPostProcessor：BeanFactory的后置处理器。在BeanFactory标准初始化之后执行的；
两个接口：BeanFactoryPostProcessor、BeanDefinitionRegistryPostProcessor
添加一个BeanPostProcessorChecker后置处理器在beanFactory中
1）、执行BeanFactoryPostProcessor的方法；
先执行BeanDefinitionRegistryPostProcessor
【BeanDefinitionRegistryPostProcessor是BeanFactoryPostProcessor的子接口，BeanDefinitionRegistryPostProcessor这个接口中多了一个方法，这个方法在spring源码中要先于BeanFactoryPostProcessor中的方法执行】
1）、获取所有的BeanDefinitionRegistryPostProcessor；立刻执行ApplicationContext中已经注册好的后置处理器
【这步主要为了执行ConfigurationClassPostProcessor类，也就是@Configuration类的作用部分实现， 在ConfigurationClassPostProcessor类的processConfigBeanDefinitions(registry)会将所有@Bean注解配置的类中的信息方法放到BeanDefinitionMap中】
2）、通过类型获得所有的BeanDefinitionRegistryPostProcessor，看先执行实现了PriorityOrdered优先级接口的BeanDefinitionRegistryPostProcessor、
postProcessor.postProcessBeanDefinitionRegistry(registry)
3）、通过类型获得所有的BeanDefinitionRegistryPostProcessor，在执行实现了Ordered顺序接口的BeanDefinitionRegistryPostProcessor；
postProcessor.postProcessBeanDefinitionRegistry(registry)
4）、通过类型获得所有的BeanDefinitionRegistryPostProcessor，最后执行没有实现任何优先级或者是顺序接口的BeanDefinitionRegistryPostProcessors；
postProcessor.postProcessBeanDefinitionRegistry(registry)
再执行BeanFactoryPostProcessor的方法
1）、获取所有的BeanFactoryPostProcessor
2）、看先执行实现了PriorityOrdered优先级接口的BeanFactoryPostProcessor、
postProcessor.postProcessBeanFactory()
3）、在执行实现了Ordered顺序接口的BeanFactoryPostProcessor；
postProcessor.postProcessBeanFactory()
4）、最后执行没有实现任何优先级或者是顺序接口的BeanFactoryPostProcessor；
postProcessor.postProcessBeanFactory()
6、registerBeanPostProcessors(beanFactory);注册BeanPostProcessor（Bean的后置处理器)，
【将后置处理器创建出来，然后根据顺序来进行注册到ApplictionContext的Beanfactory中，注意这里只是按顺序注册并不是执行】
不同接口类型的BeanPostProcessor；在Bean创建前后的执行时机是不一样的所以要按顺序排序
BeanPostProcessor下有很多的实现了比如、
DestructionAwareBeanPostProcessor、
InstantiationAwareBeanPostProcessor、
SmartInstantiationAwareBeanPostProcessor、
MergedBeanDefinitionPostProcessor【internalPostProcessors】、
1）、获取所有的 BeanPostProcessor;后置处理器都默认可以通过PriorityOrdered、Ordered接口来执行优先级
2）、先注册PriorityOrdered优先级接口的BeanPostProcessor；
把每一个BeanPostProcessor；添加到BeanFactory中
beanFactory.addBeanPostProcessor(postProcessor);
3）、再注册Ordered接口的
4）、最后注册没有实现任何优先级接口的
5）、最终注册MergedBeanDefinitionPostProcessor类型的后置处理器；
6）、注册一个ApplicationListenerDetector；
applicationContext.addApplicationListener((ApplicationListener<?>) bean);【这个后置处理器主要用于配合ApplicationListener的事件派发】
7、initMessageSource();初始化MessageSource组件（做国际化功能；消息绑定，消息解析）；
1）、获取BeanFactory
2）、看容器中是否有id为messageSource的，类型是MessageSource的组件
如果有赋值给messageSource，如果没有自己创建一个DelegatingMessageSource；
MessageSource：取出国际化配置文件中的某个key的值；能按照区域信息获取；
3）、把创建好的MessageSource注册在容器中，以后获取国际化配置文件的值的时候，可以自动注入MessageSource；
如果定义了MessageSource的实现类则不用注册了，因为容器中本来就有
beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
MessageSource.getMessage(String code, Object[] args, String defaultMessage, Locale locale);
8、initApplicationEventMulticaster();初始化事件派发器；
1）、获取BeanFactory
2）、从BeanFactory中获取applicationEventMulticaster的ApplicationEventMulticaster；
3）、如果有则赋值给指定属性，如果上一步没有配置；创建一个SimpleApplicationEventMulticaster
4）、将创建的ApplicationEventMulticaster添加到BeanFactory中，以后其他组件直接自动注入
9、onRefresh();留给子容器（子类）
1、子类重写这个方法，在容器刷新的时候可以自定义逻辑；
10、registerListeners();给容器中将所有项目里面的ApplicationListener注册进来；
1、从容器中拿到所有的ApplicationListener，然后再通过类型获得所有的ApplicationListener【监听器】
2、将每个监听器添加到事件派发器中；
getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
3、派发之前步骤产生的事件；
11、finishBeanFactoryInitialization(beanFactory);初始化所有剩下的单实例bean；
1、beanFactory.preInstantiateSingletons();初始化后剩下的单实例bean
1）、获取容器中的所有Bean，依次进行初始化和创建对象
2）、获取Bean的定义信息；RootBeanDefinition
3）、Bean不是抽象的，是单实例的，是懒加载；
1）、判断是否是FactoryBean；是否是实现FactoryBean接口的Bean；
2）、不是工厂Bean。利用getBean(beanName);创建对象
0、getBean(beanName)； ioc.getBean();
1、doGetBean(name, null, null, false);
2、先获取缓存中保存的单实例Bean。如果能获取到说明这个Bean之前被创建过（所有创建过的单实例Bean都会被缓存起来）
从private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(256);获取的
3、缓存中获取不到【getSingleton】，开始Bean的创建对象流程；如果是单例对象循环依赖这里会获得对象，解决循环依赖
4、标记当前bean已经被创建
5、获取Bean的定义信息；
6、获取当前Bean依赖的其他Bean;如果有按照getBean()把依赖的Bean先创建出来；【DependsOn】
7、启动单实例Bean的创建流程；
1）、createBean(beanName, mbd, args);
2）、Object bean = resolveBeforeInstantiation(beanName, mbdToUse);让BeanPostProcessor先拦截返回代理对象；
【InstantiationAwareBeanPostProcessor】：提前执行 用于aop包装对象；
先触发：postProcessBeforeInstantiation()；
如果有返回值：触发postProcessAfterInitialization()；
【 Give BeanPostProcessors a chance to return a proxy instead of the target bean instance】
3）、如果前面的InstantiationAwareBeanPostProcessor没有返回代理对象；
4）、Object beanInstance = doCreateBean(beanName, mbdToUse, args);创建Bean
1）、【创建Bean实例】；createBeanInstance(beanName, mbd, args);
调用构造方法，利用工厂方法或者对象的构造器创建出Bean实例；
2）、applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
调用MergedBeanDefinitionPostProcessor的postProcessMergedBeanDefinition(mbd, beanType, beanName);
3）、【Bean属性赋值】populateBean(beanName, mbd, instanceWrapper);
赋值之前：
1）、拿到InstantiationAwareBeanPostProcessor后置处理器；
postProcessAfterInstantiation()；
2）、拿到InstantiationAwareBeanPostProcessor后置处理器；
postProcessPropertyValues()；
=====赋值之前：===
3）、应用Bean属性的值；为属性利用setter方法等进行赋值；
applyPropertyValues(beanName, mbd, bw, pvs);
4）、【Bean初始化】initializeBean(beanName, exposedObject, mbd);
1）、【执行Aware接口方法】invokeAwareMethods(beanName, bean);执行xxxAware接口的方法
BeanNameAware\BeanClassLoaderAware\BeanFactoryAware
2）、【执行后置处理器初始化之前】applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
BeanPostProcessor.postProcessBeforeInitialization（）;
3）、【执行初始化方法】invokeInitMethods(beanName, wrappedBean, mbd);
1）、是否是InitializingBean接口的实现；执行接口规定的初始化；
2）、是否自定义初始化方法；
4）、【执行后置处理器初始化之后】applyBeanPostProcessorsAfterInitialization
BeanPostProcessor.postProcessAfterInitialization()；
5）、注册Bean的销毁方法；
5）、将创建的Bean添加到缓存中singletonObjects；
ioc容器就是这些Map；很多的Map里面保存了单实例Bean，环境信息。。。。；
所有Bean都利用getBean创建完成以后；
检查所有的Bean是否是SmartInitializingSingleton接口的；如果是；就执行afterSingletonsInstantiated()；
12、finishRefresh();完成BeanFactory的初始化创建工作；IOC容器就创建完成；
1）、initLifecycleProcessor();初始化和生命周期有关的后置处理器；LifecycleProcessor类型
默认从容器中找是否有lifecycleProcessor的组件【LifecycleProcessor】；如果没有new DefaultLifecycleProcessor();
加入到容器；
写一个LifecycleProcessor的实现类，可以在BeanFactory
void onRefresh();
void onClose();
2）、 getLifecycleProcessor().onRefresh();
拿到前面定义的生命周期处理器（BeanFactory）；回调onRefresh()；
3）、publishEvent(new ContextRefreshedEvent(this));发布容器刷新完成事件；
4）、liveBeansView.registerApplicationContext(this);
======总结===========
spring加载会创建一系列对象，Map，将开天辟地的对象放到beanDefintionMap中，
同时将传进来的Config类的class信息放到beanDefintionMap【这个类上的注解信息极为重要】
然后创建beanfactory，然后将一系列的BeanPostProcessor手动注册到beanfactory中
【这些都是spring自己定义的后置处理器】等对象创建放到beanfactory中，
执行ConfigurationClassPostProcessor【BeanDefinitionRegistryPostProcessor类型】
后置处理器的方法将@Bean注解下的信息放到BeanDefintion中，然后将
BeanDefintion放到beanDefintionMap中，
这时beanDefintionMap中已经有了所有自己手动配置的Bean的信息，然后按顺序注册并且执行BeanDefinitionRegistryPostProcessor类型的后置处理器，
然后按顺序注册并执行BeanFactoryPostProcessor的后置处理器，
其实BeanDefinitionRegistryPostProcessor是BeanFactoryPostProcessor的子接口，
BeanDefinitionRegistryPostProcessor中多出了一个实现方法会先执行；
接下来会按顺序创建并注册一些我们自己创建的BeanPostProcessor【注意这里不会执行后置处理器】；
然后初始化一个HierarchicalMessageSource类型的对象放到单例池中这个对象我们可以自己创建，
如果我们没有创建spring会采用一个默认的DelegatingMessageSource，这个类型的bean一般用来做国际化处理；
然后创建一个ApplicationEventMulticaster类型的单例Bean放到单例池中，
我们也可以自己定义如果没定义则spring会使用默认的SimpleApplicationEventMulticaster类，
这个类用来进行事件派发；然后获得所有ApplicationListener类型的对象，将这些对象名注册到SimpleApplicationEventMulticaster类型spring管理的的对象中
【这时并没有去创建ApplicationListener实现类】，这是用来接收事件派发的类；进行最重要的一步【finishBeanFactoryInitialization】获得所有的beanDefintionMap中的beanDefintion，
判断是否是factorybean如果是则进行处理；如果不是factoryBean，则首先通过
第一个getSingle方法来获得对象，如果没有则检测依赖的bean【DependsOn】，
将依赖的bean先创建，然后判断是否要aop代理的这个对象，如果有则使用aop进行创建对象结束；
如果没有aop进行代理则调用对象构造方法然后依次调用SmartInstantiationAwareBeanPostProcessor、
MergedBeanDefinitionPostProcessor的后置处理器，
然后调用InstantiationAwareBeanPostProcessor后置处理器，然后进行赋值，然后调用
BeanNameAware\BeanClassLoaderAware\BeanFactoryAware后置处理器，然后调用所有的
BeanPostProecssor的postProcessBeforeInitialization方法，然后执行bean的初始化方法，
然后调用所有后置处理器的postProcessAfterInitialization方法；调用Bean的销毁方法，
通过第二个getSingle方法将bean对象放到单例池中；最终创建生命周期相关的后置处理器
【LifecycleProcessor类型】调用后置处理器中的指定刷新方法，
然后发布【publishEvent】容器加载完成事件；
循环依赖
AOP
@ComponentScan
可以扫描包下的@Component(@Service，@Controller等)注解 意思是创建对象,和下面xml作用相同
排除里面存放的是@Filter数组
@Filter数组定义，Filter中有一个FilterType来写过滤类型，FilterType是一个枚举
可以根据注解啊，类型啊，和ASPECTJ表达式，正则啊，和定义规则，其中自定义规则要实现org.springframework.core.type.filter.TypeFilter接口
其中org.springframework.core.type.filter.TypeFilter接口实现
metadataReaderFactory可以获得注解信息，类路径等
ComponentScan排除的使用
@Configuration
@ComponentScan(
//value代表要扫描的包
value = "com",
//excludeFilters代表要排除那些要扫的
excludeFilters = {
//excludeFilters中存放的是@Filter数组
//type是要排除的类型,这里是使用注解进行排除,也可以使用自定方法排除
@ComponentScan.Filter(type = FilterType.ANNOTATION,classes = {
Controller.class, Service.class
})
}
)
public class Weee {}
ComponentScan包含的使用
要设置userDefaultFilters为false，作用为关闭默认包含规则，使用自己定义的包含规则
这个ComponentScan可以重复使用，因为这个注解有一个@Repeatable的重复注解
还有一个@ComponentScans里面存放多个@ComponentScan
@Component
用于导入类，和service，controller，repository作用相同@Service
@Controller
@Repository
# @Bean意思是创建对象,和下面xml作用相同
//如果不指定name则name为方法名,默认为单例懒加载,返回的对象为class
@Bean(name = "beanPropertyName")
public BeanAaa beanPropertyName(){
return new BeanAaa();
}
@Configuration
可以理解为，如果类上添加了这个注解则这个类代表spring的配置文件； 这个注解主要作用为，在另一段代码中调用了创建Bean的方法,返回的对象是由spring管理的对象//如果这个类是配置类也可以不使用@Configuration注解，也不会报错
//不使用则打印false,使用则会打印true
//说明添加了这个注解再次调用创建Bean的方法会返回同一个对象
@Configuration
public class Weee {
@Bean
@Lazy(value = false)
@Scope(value= ConfigurableBeanFactory.SCOPE_SINGLETON)
public BeanAaa beanPropertyName(){
return new BeanAaa();
}
@Bean
public BeanAaas beanAaas(){
//如果new则会创建一个新的对象,这个对象并不是spring中的对象
//BeanAaa beanAaa = new BeanAaa();
//如果调用这个方法则会返回相同的对象,这个对象是由spring进行管理的对象
BeanAaa beanAaa1 = beanPropertyName();
BeanAaa beanAaa2 = beanPropertyName();
System.out.println(beanAaa1.equals(beanAaa2));
return new BeanAaas();
}
}
FactoryBean
是一种特殊的bean，用这个bean去产生bean，可以通过&FactoryBean的name区获得这个FactoryBeanimport org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class Test
{
public static void main(String[] args) {
AnnotationConfigApplicationContext ac=new AnnotationConfigApplicationContext(Weee.class);
//获得myFactoryBean产生的对象
Object myBeanFactory = ac.getBean("myFactoryBean");
//获得MyFactoryBean对象
MyFactoryBean myFactoryBean= (MyFactoryBean) ac.getBean("&myFactoryBean");
}
}
import org.springframework.context.annotation.*;
@Configuration
public class Weee {
@Bean
public MyFactoryBean myFactoryBean(){
return new MyFactoryBean();
}
}
import org.springframework.beans.factory.FactoryBean;
public class MyFactoryBean implements FactoryBean {
@Override
public Object getObject() throws Exception {
return new Object();
}
@Override
public Class<?> getObjectType() {
return Object.class;
}
}
初始化前后调用方法,3种，构造方法调用之后
第一种 在声明类上添加@PostConstruct 和@PreDestroy
@PostConstruct
@PreDestroy
package com;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class Test
{
public static void main(String[] args) {
AnnotationConfigApplicationContext ac=new AnnotationConfigApplicationContext(Weee.class);
ac.close();
}
}
import org.springframework.context.annotation.*;
@Configuration
public class Weee {
@Bean
public TestInitAndDistory testBean(){
return new TestInitAndDistory();
}
}
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
public class TestInitAndDistory {
@PostConstruct
public void init(){
System.out.println("init");
}
@PreDestroy
public void destory(){
System.out.println("destory");
}
}
第二种在Bean注解上添加initMethod，destroyMethod
import org.springframework.context.annotation.*;
@Configuration
public class Weee {
@Bean(initMethod="init",destroyMethod="destory")
public TestInitAndDistory testBean(){
return new TestInitAndDistory();
}
}
public class TestInitAndDistory {
public void init(){
System.out.println("init");
}
public void destory(){
System.out.println("destory");
}
}
第三种声明类实现DisposableBean,InitializingBean接口
import org.springframework.context.annotation.*;
@Configuration
public class Weee {
@Bean
public TestInitAndDistory testBean(){
return new TestInitAndDistory();
}
}
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
public class TestInitAndDistory implements DisposableBean,InitializingBean {
public TestInitAndDistory(){
System.out.println("construct");
}
@Override
public void destroy() throws Exception {
System.out.println("destory");
}
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("init");
}
}
@Conditional
这个注解可以加载方法上，也可以加到类上，这个注解可以根据环境等信息让添加的方法或者类中交给spring管理的bean是否注册； 在@Conditional中的值，这个值要实现Conditional接口；下面根据环境进行注册bean
package com;
import org.springframework.context.annotation.*;
@Configuration
public class Weee {
@Bean
@Conditional(WindowsCondition.class)
public BeanByEnvironment windowsBean(){
return new BeanByEnvironment("bill");
}
@Bean
@Conditional(LinuxCondition.class)
public BeanByEnvironment linuxBean(){
return new BeanByEnvironment("linux");
}
}
package com;
//windows 环境
import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.env.Environment;
import org.springframework.core.type.AnnotatedTypeMetadata;
public class WindowsCondition implements Condition {
@Override
public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
Environment environment = context.getEnvironment();
String property = environment.getProperty("os.name");
if(property.toUpperCase().contains("WINDOW")){
return true;
}
return false;
}
}
package com;
public class BeanByEnvironment {
public BeanByEnvironment(String haha) {
System.out.println(haha);
}
}
package com;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.env.Environment;
import org.springframework.core.type.AnnotatedTypeMetadata;
//linux环境
public class LinuxCondition implements Condition {
@Override
public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
//获得bean工厂 可以用用来获得所有的bean
ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
//BeanDefinition beanName = beanFactory.getBeanDefinition("beanName");
//BeanDefinitionRegistry用来注册一个bean,在Condition中主要用来判断不用来注册bean
//BeanDefinitionRegistry registry = context.getRegistry();
//获得ioc环境
Environment environment = context.getEnvironment();
String property = environment.getProperty("os.name");
if(property.toUpperCase().contains("LINUX")){
return true;
}
return false;
}
}
package com;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class Test
{
public static void main(String[] args) {
AnnotationConfigApplicationContext ac=new AnnotationConfigApplicationContext(Weee.class);
}
}
可以设置参数进行运行
@Lazy
默认是懒加载true
@Scope
scope取值,单例，多例，request，session； spring获得对象时候会判断是否是单例懒加载等，根据类型进行合适的创建；
使用
@Import
导入的类可以是有@Configuration的Class，也可以是正常的class，也可以是ImportSelector的实现类，也可以是ImportBeanDefinitionRegistrar的实现类
import使用如下
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class Test
{
public static void main(String[] args) {
AnnotationConfigApplicationContext ac=new AnnotationConfigApplicationContext(Weee.class);
}
}
import org.springframework.context.annotation.*;
@Configuration
@Import({BeanAaa.class,Config.class,MyImportSelector.class,MyImportBeanDefinitionRegistrar.class})
public class Weee {
@Bean
public BeanByEnvironment windowsBean(){
return new BeanByEnvironment("bill");
}
}
public class BeanAaa {
public BeanAaa() {
System.out.println(
"--------------"
);
}
}
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class Config {
@Bean
public Object idName(){
return new Object();
}
}
import org.springframework.context.annotation.ImportSelector;
import org.springframework.core.type.AnnotationMetadata;
public class MyImportSelector implements ImportSelector {
@Override
public String[] selectImports(AnnotationMetadata importingClassMetadata) {
//返回要注册的类的包名+类名 返回null会报错，不注册对象可以返回空数字
return new String[0];
}
}
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.RootBeanDefinition;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import org.springframework.core.type.AnnotationMetadata;
public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
//AnnotationMetadata 当前类注解信息
//BeanDefinitionRegistry 可以用这个对象注册bean
@Override
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
//判断spring容器中是否有这个bean
boolean b = registry.containsBeanDefinition("111");
//如果没有注册一个这个bean
if(!b){
RootBeanDefinition rootBeanDefinition = new RootBeanDefinition(WindowsBean.class);
registry.registerBeanDefinition("111",rootBeanDefinition);
}
}
}
public class WindowsBean {
public WindowsBean() {
System.out.println("windows");
}
}
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
