int 接口 wing area web 構造器 async 所有 reg

給容器中註冊組件

1、包掃描+組件標註註解（@Controller/@service/@Repository/@compement）

2、@Bean[導入的第三方包裏面的組件 ]

3、@Scope設置組件作用域

4、@Lazy 懶加載

5、@Conditional 按照條件註冊bean

6、@Import[快速給窗口中導入一個組件]
1、@Import(要導入的容器組件)，容器中應付自動註冊這個組件，id默認為全類名
2、ImportSelector:返回需要導入的組件的儼名數組
3、ImportBeanDefinitionRegistrar：手動註冊bean

到容器中

7、使用Spring提供的FacoryBean（工廠Bean）
1、默認獲取到的是工廠的bean調用的getObject創建對象
2、要獲取工廠Bean本身，我們需要給id前面加一個&

Bean的生命周期

Bean的創建-----初始化----銷毀的過程

容器管理bean的生命周期

我們可以自定義初始化和銷毀方法；容器bean進行到當前生命周期的時候來調用我們自定義的初始化和銷毀的過程

構造（對象創建）

單實例：在容器啟動的時候創建對象

多實例：在每次獲取的時候創建對象

BeanPostProcessor. postProcessBefortInitiazation

初始化：

對象創建完成，並賦值好，調用初始化方法。。。

BeanPostProcessor. postProcessAfterInitialization

銷毀：

單實例：容器關閉的時候

多實例：容器不會管理這個bean；容器不會調用銷毀方法。

1、指定初始化和銷毀的方法

a) 通過@Bean指定init-method和destory-method

2、通過Bean實現InitializingBean（定義初始化邏輯）、DesposableBean（定義銷毀邏輯）

3、可以使用JSR250:

a) @PostConstruct

：在bean創建完成並且屬性賦值完成時來執行初始化方法。

b) @PreDestory：在容器銷毀bean之前通知我們進行清理工作

4、BeanPostProcessor【interface】：bean的後置處理器

在bean初始化前後進行一些處理工作：

postProcessBefortInitiazation:在初始化之前工作

postProcessAfterInitialization:在初始化之後工作

spirng底層對BeanPostProceseeor的使用

bean賦值，註入其他組件，@Autowired,生命周期註解功能，@Async ,

xxx BeanPostProcesstor

屬性賦值

1、使用@Value賦值

a) 基本數值

b) 可以寫SpEL：#{}

c) 可以寫${}:取出配置文件【properties】中的值（在運行環境變量裏面的值）

2、使用@propertySource讀取外部配置文件中的k/v保存到運行的環境變量中；加載完外部的配置文件以後使用${}取出配置文件的值

自動裝配

1、@Autowired：自動註入

A、默認優先按照類型去容器中找對應的組件：applicationContext.getBean(Book.class);

B、如果找到多個相同類型的組件，再將屬性的名稱作為組件的id去容器中查找

applicationContext.getBean(“bookDao”);

C、@Qualifier(“bookDao”)：使用@Qualifier指定需要裝配的組件的id，而不是使用屬性名

D、自動裝配默認一定要將屬性賦值好，沒有就會報錯；

可以使用@Autowired（reuqeired=false）

E、@Primary：讓Spring進行自動裝配的時候，默認使用首先的bean；

也可以繼續使用@Qualifier指定需要裝配的bean的名字

BookService{

@Autowired

BookDao bookDao;

}

2、Spring還支持使用A@Resource(JSR250)和@Inject（JSR330）【java規範的註解】

a) @Resource:

1. 可以和@Autowired一樣實現自動裝配功能，默認是按照組件名稱進行裝配的

2. 沒有能支持@Primary功能，沒有支持@Autowired（reqiured=false）

B、@Inject:

需要導入javax.inject的包，和Autowired的功能一樣。沒有requied=fasle的功能

@Autowired：Spring定義的；@Resource、@Inject都是java規範。

@AutowiredAnnotationBeanPostProcessor：解析完成自動裝配的功能

3、@Autowired：可以標註在構造器，參數，方法，屬性；都是在容器中獲取參數組件的值

A、標註在方法位置：@Bean+方法參數；參數從容器中獲取；默認不寫@Autowired效果都是一樣的；都能自動裝配。

//標註在方法，Spring容器創建當前對象，就會調用方法，完成賦值

//方法使用參數，自定義類型的值從Ioc容器中獲取

例如：

@Autowired

Public void setCar(Car car){

This.car=car;

}

B、標在構造器上：如果組件上只有一個有參構造器，這個有參構造器的@Autowired可以省略，參數位置的組件還是可以自動從容器中獲取

C、放在參數位置。

3、自定義想要使用Spring容器底層的一些組件（ApplicationContext,BeanFactory,XXX）;

a) 自定義組件實現xxxAware:在創建對象的時候，會調用接口規定的方法註入相關組件：Aware;

b) 把Spring底層一些組件註入到定義的Bean中；

c) XxxAware:功能使用xxxProcesser:

i. ApplicationContextAwareèApplicationContextAwareProcesser;

4、@Profile

Spring為我們提供的可以根據當前環境，動態的激活和切換一系列的功能。

比如說：開發環境用A數據庫，測試環境用B數據庫，生產環境用C數據庫

@Profile：指定組件在哪個環境的情況下才能被註冊到容器中，不指定，任何環境下都能註冊到這個組件

1）、加了環境標識的bean，只有這個環境被激活才能註冊到容器中。默認中default環境

2）、寫在配置類上，只有是指定的環境的時候，整個配置類裏面的所有配置才能開始生效。

3）、沒有標註環境標識的bean在任何環境下都是加載的。

設置環境的方法：

1、使用命令行動態參數：在虛擬機參數位置加載 -Dspirng.profiles.active=test

2、使用代碼的方式，如下

a) 創建一個applicationContext

AnnotationConfigApplicationContext applicationContext=new AnnotationConfigApplicationContext();

b) 設置需要激活的環境

applicationContext.getEnviroment().setActiveProfiles(“test”,”dev”);

c) 註冊主配置類

applicationContext.register(MainConifgOfProfile.class);

d) 啟動刷新容器

ApplicationContext.refresh();

AOP

Aop:【動態代理】

指在程序運行期間動態的將某段代碼切入到指定方法指定位置進行運行的編程方式；

1、導入aop模塊：Spring Aop:（spring-aspects）

2、定義一個業務邏輯類（MathCalculator）:在業務邏輯運行的時候將日誌進行打印（方法之前、方法運行結束、方法出現異常，XXX）

3、定義一個日誌切面類（LogAspects）：切面類裏面的方法需要動態感知MathCalculator.div運行到執行

a) 通知方法：

i. 前置通知(@Before)：logStart：在目標方法（div）運行之前執行

ii. 後置通知(@After)：logEnd：在目標方法（div）運行結束之後執行

iii. 返回通知(@AfterReturning)：logReturn:在目標方法（div）正常返回之後執行

iv. 異常通知：(@AfterThrowing)：logException：在目標方法（div）出現異常後返回

v. 環繞通知(@Aroud)：動態代理 ，手動推進目標方法運行（joinPoint.procced()）

4、給切面類的目標方法標註何時何地運行（通知註解）

5、將切面類和業務邏輯類（目標方法所在類）都加入到容器中；

6、必須告訴Spring哪個類是切面類（給切面類上加一個註解：@Aspect）

7、給配置類中加@EnableAspectJAutoProxy【開啟基於註解的aop模式】

a) 在sprig中有很多的@EnablXXX;

三步：

1、將業務邏輯組件和切面類都加入到容器中，告訴Spring哪個是切面類（@Aspect）

2、在切面類上的每一個通知方法上都標註通知註解，告訴Spring何時何地運行(切入點表達式)

3、開啟基於註解的aop模式；@EnableAspectJ AutoProxy

AOP原理

AOP原理：【看給容器中註冊了什麽組件，這個組件什麽時候工作，這個組件的功能是什麽？

@EnableAspectJAutoProxy；

1、@EnableAspectJAutoProxy是什麽？

@Import(AspectJAutoProxyRegistrar.class)：給容器中導入AspectJAutoProxyRegistrar

利用AspectJAutoProxyRegistrar自定義給容器中註冊bean；BeanDefinetion

internalAutoProxyCreator=AnnotationAwareAspectJAutoProxyCreator

給容器中註冊一個AnnotationAwareAspectJAutoProxyCreator；

2、 AnnotationAwareAspectJAutoProxyCreator：

AnnotationAwareAspectJAutoProxyCreator

->AspectJAwareAdvisorAutoProxyCreator

->AbstractAdvisorAutoProxyCreator

->AbstractAutoProxyCreator

implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware

關註後置處理器（在bean初始化完成前後做事情）、自動裝配BeanFactory

AbstractAutoProxyCreator.setBeanFactory()

AbstractAutoProxyCreator.有後置處理器的邏輯；

AbstractAdvisorAutoProxyCreator.setBeanFactory()-》initBeanFactory()

AnnotationAwareAspectJAutoProxyCreator.initBeanFactory()

流程：

1）、傳入配置類，創建ioc容器

2）、註冊配置類，調用refresh（）刷新容器；

3）、registerBeanPostProcessors(beanFactory);註冊bean的後置處理器來方便攔截bean的創建；

1）、先獲取ioc容器已經定義了的需要創建對象的所有BeanPostProcessor

2）、給容器中加別的BeanPostProcessor

3）、優先註冊實現了PriorityOrdered接口的BeanPostProcessor；

4）、再給容器中註冊實現了Ordered接口的BeanPostProcessor；

5）、註冊沒實現優先級接口的BeanPostProcessor；

6）、註冊BeanPostProcessor，實際上就是創建BeanPostProcessor對象，保存在容器中；

創建internalAutoProxyCreator的BeanPostProcessor【AnnotationAwareAspectJAutoProxyCreator】

1）、創建Bean的實例

2）、populateBean；給bean的各種屬性賦值

3）、initializeBean：初始化bean；

1）、invokeAwareMethods()：處理Aware接口的方法回調

2）、applyBeanPostProcessorsBeforeInitialization()：應用後置處理器的postProcessBeforeInitialization（）

3）、invokeInitMethods()；執行自定義的初始化方法

4）、applyBeanPostProcessorsAfterInitialization()；執行後置處理器的postProcessAfterInitialization（）；

4）、BeanPostProcessor(AnnotationAwareAspectJAutoProxyCreator)創建成功；--》aspectJAdvisorsBuilder

7）、把BeanPostProcessor註冊到BeanFactory中；

beanFactory.addBeanPostProcessor(postProcessor);

=======以上是創建和註冊AnnotationAwareAspectJAutoProxyCreator的過程========

AnnotationAwareAspectJAutoProxyCreator => InstantiationAwareBeanPostProcessor

4）、finishBeanFactoryInitialization(beanFactory);完成BeanFactory初始化工作；創建剩下的單實例bean

1）、遍歷獲取容器中所有的Bean，依次創建對象getBean(beanName);

getBean->doGetBean()->getSingleton()->

2）、創建bean

【AnnotationAwareAspectJAutoProxyCreator在所有bean創建之前會有一個攔截，InstantiationAwareBeanPostProcessor，會調用postProcessBeforeInstantiation()】

1）、先從緩存中獲取當前bean，如果能獲取到，說明bean是之前被創建過的，直接使用，否則再創建；

只要創建好的Bean都會被緩存起來

2）、createBean（）;創建bean；

AnnotationAwareAspectJAutoProxyCreator 會在任何bean創建之前先嘗試返回bean的實例

【BeanPostProcessor是在Bean對象創建完成初始化前後調用的】

【InstantiationAwareBeanPostProcessor是在創建Bean實例之前先嘗試用後置處理器返回對象的】

1）、resolveBeforeInstantiation(beanName, mbdToUse);解析BeforeInstantiation

希望後置處理器在此能返回一個代理對象；如果能返回代理對象就使用，如果不能就繼續

1）、後置處理器先嘗試返回對象；

bean = applyBeanPostProcessorsBeforeInstantiation（）：

拿到所有後置處理器，如果是InstantiationAwareBeanPostProcessor;

就執行postProcessBeforeInstantiation

if (bean != null) {

bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);

}

2）、doCreateBean(beanName, mbdToUse, args);真正的去創建一個bean實例；和3.6流程一樣；

3）、

AnnotationAwareAspectJAutoProxyCreator【InstantiationAwareBeanPostProcessor】 的作用：

1）、每一個bean創建之前，調用postProcessBeforeInstantiation()；

關心MathCalculator和LogAspect的創建

1）、判斷當前bean是否在advisedBeans中（保存了所有需要增強bean）

2）、判斷當前bean是否是基礎類型的Advice、Pointcut、Advisor、AopInfrastructureBean，

或者是否是切面（@Aspect）

3）、是否需要跳過

1）、獲取候選的增強器（切面裏面的通知方法）【List<Advisor> candidateAdvisors】

每一個封裝的通知方法的增強器是 InstantiationModelAwarePointcutAdvisor；

判斷每一個增強器是否是 AspectJPointcutAdvisor 類型的；返回true

2）、永遠返回false

2）、創建對象

postProcessAfterInitialization；

return wrapIfNecessary(bean, beanName, cacheKey);//包裝如果需要的情況下

1）、獲取當前bean的所有增強器（通知方法） Object[] specificInterceptors

1、找到候選的所有的增強器（找哪些通知方法是需要切入當前bean方法的）

2、獲取到能在bean使用的增強器。

3、給增強器排序

2）、保存當前bean在advisedBeans中；

3）、如果當前bean需要增強，創建當前bean的代理對象；

1）、獲取所有增強器（通知方法）

2）、保存到proxyFactory

3）、創建代理對象：Spring自動決定

JdkDynamicAopProxy(config);jdk動態代理；

ObjenesisCglibAopProxy(config);cglib的動態代理；

4）、給容器中返回當前組件使用cglib增強了的代理對象；

5）、以後容器中獲取到的就是這個組件的代理對象，執行目標方法的時候，代理對象就會執行通知方法的流程；

3）、目標方法執行 ；

容器中保存了組件的代理對象（cglib增強後的對象），這個對象裏面保存了詳細信息（比如增強器，目標對象，xxx）；

1）、CglibAopProxy.intercept();攔截目標方法的執行

2）、根據ProxyFactory對象獲取將要執行的目標方法攔截器鏈；

List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

1）、List<Object> interceptorList保存所有攔截器 5

一個默認的ExposeInvocationInterceptor 和 4個增強器；

2）、遍歷所有的增強器，將其轉為Interceptor；

registry.getInterceptors(advisor);

3）、將增強器轉為List<MethodInterceptor>；

如果是MethodInterceptor，直接加入到集合中

如果不是，使用AdvisorAdapter將增強器轉為MethodInterceptor；

轉換完成返回MethodInterceptor數組；

3）、如果沒有攔截器鏈，直接執行目標方法;

攔截器鏈（每一個通知方法又被包裝為方法攔截器，利用MethodInterceptor機制）

4）、如果有攔截器鏈，把需要執行的目標對象，目標方法，

攔截器鏈等信息傳入創建一個 CglibMethodInvocation 對象，

並調用 Object retVal = mi.proceed();

5）、攔截器鏈的觸發過程;

1)、如果沒有攔截器執行執行目標方法，或者攔截器的索引和攔截器數組-1大小一樣（指定到了最後一個攔截器）執行目標方法；

2)、鏈式獲取每一個攔截器，攔截器執行invoke方法，每一個攔截器等待下一個攔截器執行完成返回以後再來執行；

攔截器鏈的機制，保證通知方法與目標方法的執行順序；

總結：

1）、 @EnableAspectJAutoProxy 開啟AOP功能

2）、 @EnableAspectJAutoProxy 會給容器中註冊一個組件 AnnotationAwareAspectJAutoProxyCreator

3）、AnnotationAwareAspectJAutoProxyCreator是一個後置處理器；

4）、容器的創建流程：

1）、registerBeanPostProcessors（）註冊後置處理器；創建AnnotationAwareAspectJAutoProxyCreator對象

2）、finishBeanFactoryInitialization（）初始化剩下的單實例bean

1）、創建業務邏輯組件和切面組件

2）、AnnotationAwareAspectJAutoProxyCreator攔截組件的創建過程

3）、組件創建完之後，判斷組件是否需要增強

是：切面的通知方法，包裝成增強器（Advisor）;給業務邏輯組件創建一個代理對象（cglib）；

5）、執行目標方法：

1）、代理對象執行目標方法

2）、CglibAopProxy.intercept()；

1）、得到目標方法的攔截器鏈（增強器包裝成攔截器MethodInterceptor）

2）、利用攔截器的鏈式機制，依次進入每一個攔截器進行執行；

3）、效果：

正常執行：前置通知-》目標方法-》後置通知-》返回通知

出現異常：前置通知-》目標方法-》後置通知-》異常通知

聲明式事務

環境搭建：

1、導入相關依賴

a) 數據源，數據庫驅動，spring-jdbc模塊

2、配置數據源、JdbcTemplate (String 提供的簡化數據庫操作的工具) 操作數據

3、給方法上標註@Transactional 表示當前方法是一個事務方法

4、@EnableTransactionManagement 開啟 基於註解的事務管理功能。

5、配置事務管理器來控制事務

原理：

1）、@EnableTransactionManagement

利用TransactionManagementConfigurationSelector給容器中會導入組件

導入兩個組件

AutoProxyRegistrar

ProxyTransactionManagementConfiguration

2）、AutoProxyRegistrar：

給容器中註冊一個 InfrastructureAdvisorAutoProxyCreator 組件；

InfrastructureAdvisorAutoProxyCreator：？

利用後置處理器機制在對象創建以後，包裝對象，返回一個代理對象（增強器），代理對象執行方法利用攔截器鏈進行調用；

3）、ProxyTransactionManagementConfiguration 做了什麽？

1、給容器中註冊事務增強器；

1）、事務增強器要用事務註解的信息，AnnotationTransactionAttributeSource解析事務註解

2）、事務攔截器：

TransactionInterceptor；保存了事務屬性信息，事務管理器；

他是一個 MethodInterceptor；

在目標方法執行的時候；

執行攔截器鏈；

事務攔截器：

1）、先獲取事務相關的屬性

2）、再獲取PlatformTransactionManager，如果事先沒有添加指定任何transactionmanger

最終會從容器中按照類型獲取一個PlatformTransactionManager；

3）、執行目標方法

如果異常，獲取到事務管理器，利用事務管理回滾操作；

如果正常，利用事務管理器，提交事務

整合springmvc

1、web容器在啟動的時候，會掃描每個jar包下的META-INF/services/javax.servlet.ServletContainerInitializer

2、加載這個文件指定的類SpringServletContainerInitializer

3、spring的應用一啟動會加載感興趣的WebApplicationInitializer接口的下的所有組件；

4、並且為WebApplicationInitializer組件創建對象（組件不是接口，不是抽象類）

1）、AbstractContextLoaderInitializer：創建根容器；createRootApplicationContext()；

2）、AbstractDispatcherServletInitializer：

創建一個web的ioc容器；createServletApplicationContext();

創建了DispatcherServlet；createDispatcherServlet()；

將創建的DispatcherServlet添加到ServletContext中；

getServletMappings();

3）、AbstractAnnotationConfigDispatcherServletInitializer：註解方式配置的DispatcherServlet初始化器

創建根容器：createRootApplicationContext()

getRootConfigClasses();傳入一個配置類

創建web的ioc容器： createServletApplicationContext();

獲取配置類；getServletConfigClasses();

總結：

以註解方式來啟動SpringMVC；繼承AbstractAnnotationConfigDispatcherServletInitializer；

實現抽象方法指定DispatcherServlet的配置信息

===========================

定制SpringMVC；

1）、@EnableWebMvc:開啟SpringMVC定制配置功能；

<mvc:annotation-driven/>；

2）、配置組件（視圖解析器、視圖映射、靜態資源映射、攔截器。。。）

extends WebMvcConfigurerAdapter

Spring註解驅動開發