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）、internalConfigurationAnnotationProcessor2）、internalAutowiredAnnotationProcessor3）、internalRequiredAnnotationProcessor4）、internalCommonAnnotationProcessor5）、internalEventListenerProcessor6）、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、ApplicationContext5）、添加编译时的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）、获取所有的BeanFactoryPostProcessor2）、看先执行实现了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）、获取BeanFactory2）、看容器中是否有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）、获取BeanFactory2）、从BeanFactory中获取applicationEventMulticaster的ApplicationEventMulticaster；3）、如果有则赋值给指定属性，如果上一步没有配置；创建一个SimpleApplicationEventMulticaster4）、将创建的ApplicationEventMulticaster添加到BeanFactory中，以后其他组件直接自动注入
9、onRefresh();留给子容器（子类）1、子类重写这个方法，在容器刷新的时候可以自定义逻辑；
10、registerListeners();给容器中将所有项目里面的ApplicationListener注册进来；1、从容器中拿到所有的ApplicationListener，然后再通过类型获得所有的ApplicationListener【监听器】2、将每个监听器添加到事件派发器中；getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);3、派发之前步骤产生的事件；
11、finishBeanFactoryInitialization(beanFactory);初始化所有剩下的单实例bean；1、beanFactory.preInstantiateSingletons();初始化后剩下的单实例bean1）、获取容器中的所有Bean，依次进行初始化和创建对象2）、获取Bean的定义信息；RootBeanDefinition3）、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);创建Bean1）、【创建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\BeanFactoryAware2）、【执行后置处理器初始化之前】applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);BeanPostProcessor.postProcessBeforeInitialization（）;3）、【执行初始化方法】invokeInitMethods(beanName, wrappedBean, mbd);1）、是否是InitializingBean接口的实现；执行接口规定的初始化；2）、是否自定义初始化方法；4）、【执行后置处理器初始化之后】applyBeanPostProcessorsAfterInitializationBeanPostProcessor.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的实现类，可以在BeanFactoryvoid 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();}@Beanpublic 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区获得这个FactoryBean

import 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 {@Beanpublic  MyFactoryBean myFactoryBean(){return new MyFactoryBean();}
}import org.springframework.beans.factory.FactoryBean;public class MyFactoryBean implements FactoryBean {@Overridepublic Object getObject() throws Exception {return new Object();}@Overridepublic 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 {@Beanpublic TestInitAndDistory testBean(){return new TestInitAndDistory();}
}
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;public class TestInitAndDistory {@PostConstructpublic void init(){System.out.println("init");}@PreDestroypublic 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 {@Beanpublic 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");}@Overridepublic void destroy() throws Exception {System.out.println("destory");}@Overridepublic 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 {@Overridepublic 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 {@Overridepublic boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {//获得bean工厂 可以用用来获得所有的beanConfigurableListableBeanFactory 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 {@Beanpublic  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 {@Beanpublic Object idName(){return new Object();}
}import org.springframework.context.annotation.ImportSelector;
import org.springframework.core.type.AnnotationMetadata;public class MyImportSelector implements ImportSelector {@Overridepublic 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@Overridepublic void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {//判断spring容器中是否有这个beanboolean b = registry.containsBeanDefinition("111");//如果没有注册一个这个beanif(!b){RootBeanDefinition rootBeanDefinition = new RootBeanDefinition(WindowsBean.class);registry.registerBeanDefinition("111",rootBeanDefinition);}}
}public class WindowsBean {public WindowsBean() {System.out.println("windows");}
}

@Value

@Primary

@Autowired

@Qualifier

@Resources

@PropertySource

@PropertySources

@Profile

@EnableAspectJAutoProxy

@Before/@After/@AfterReturning/@AfterThrowing/@Around

@Pointcut

@EnableTransactionManagement

@Transactional

志宇-Spring源码分析相关推荐

志宇-dubbo源码分析
dubbo源码分析文档 dubbo加载配置文件 dubboSPI dubbo服务提供 1.校验配置信息 2.创建URL 3.本地注册 4.远程注册 4.1 开启netty服务端 4.2 连接注册中心 ...
Spring源码分析【1】-Tomcat的初始化
org.apache.catalina.startup.ContextConfig.configureStart() org.apache.catalina.startup.ContextConfig ...
spring源码分析之spring-core总结篇
1.spring-core概览 spring-core是spring框架的基石,它为spring框架提供了基础的支持. spring-core从源码上看,分为6个package,分别是asm,cgli ...
【Spring源码分析】Bean加载流程概览
代码入口之前写文章都会啰啰嗦嗦一大堆再开始,进入[Spring源码分析]这个板块就直接切入正题了. 很多朋友可能想看Spring源码,但是不知道应当如何入手去看,这个可以理解:Java开发者通常从事 ...
【spring源码分析】IOC容器初始化（二）
前言:在[spring源码分析]IOC容器初始化(一)文末中已经提出loadBeanDefinitions(DefaultListableBeanFactory)的重要性,本文将以此为切入点继续分析. ...
spring源码分析第六天------spring经典面试问题
spring源码分析第六天------spring经典面试问题 1.Spring5 新特性及应用举例 2.Spring 经典的面试问题 a.什么是 Spring 框架?Spring 框架有哪些主要模块 ...
spring源码分析第五天------springAOP核心原理及源码分析
spring源码分析第五天------springAOP核心原理及源码分析 1. 面向切面编程.可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术切面(A ...
spring源码分析第四天------springmvc核心原理及源码分析
spring源码分析第四天------springmvc核心原理及源码分析 1.基础知识普及 2. SpringMVC请求流程 3.SpringMVC代码流程 4.springMVC源码分析 4.1 ...
spring源码分析第一天------源码分析知识储备
spring源码分析第一天------源码分析知识储备 Spring源码分析怎么学? 1.环境准备: 2.思路看:是什么? 能干啥想:为什么? 实践:怎么做? ...

志宇-Spring源码分析