1 Spring高級部分
1.1 spring的aop順序
- 你肯定知道spring，那說說aop的全部通知順序 springboot或springboot2對aop的執行順序影響？
- 說說你使用aop中碰到的坑
1.1.1 Aop常用注解
@Before 前置通知: 目標方法之前執行
@After 后置通知: 目標方法之后執行（始終執行）
@AfterReturning 返回后通知: 執行方法結束前執行(異常不執行)
@AfterThrowing 異常通知: 出現異常時候執行
@Around 環繞通知: 環繞目標方法執行
1.1.2 業務類
//接口CalcService
public interface CalcService {
public int div(int x,int y);
}
//接口實現類CalcServicelmpl
import org.springframework.stereotype.Service;
@Service
public class CalcServiceImpl implements CalcService {
@Override
public int div(int x, int y) {
int result = x / y;
System.out.println("=========>CalcServiceImpl被調用了,我們的計算結果："+result);
return result;
}
}
//想在除法方法前后各種通知，引入切面編程
新建一個切面類MyAspect并為切面類新增兩個注解
- @Aspect 指定一個類為切面類
- @Component 納入spring容器管理
@Aspect
@Component
public class MyAspect {
@Before("execution(public int com.xubh.study.service.impl.CalcServiceImpl.*(..))")
public void beforeNotify() {
System.out.println("******** @Before我是前置通知MyAspect");
}
@After("execution(public int com.xubh.study.service.impl.CalcServiceImpl.*(..))")
public void afterNotify() {
System.out.println("******** @After我是后置通知");
}
@AfterReturning("execution(public int com.xubh.study.service.impl.CalcServiceImpl.*(..))")
public void afterReturningNotify() {
System.out.println("********@AfterReturning我是返回后通知");
}
@AfterThrowing("execution(public int com.xubh.study.service.impl.CalcServiceImpl.*(..))")
public void afterThrowingNotify() {
System.out.println("********@AfterThrowing我是異常通知");
}
@Around("execution(public int com.xubh.study.service.impl.CalcServiceImpl.*(..))")
public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
Object retValue = null;
System.out.println("我是環繞通知之前AAA");
retValue = proceedingJoinPoint.proceed();
System.out.println("我是環繞通知之后BBB");
return retValue;
}
}
1.1.3 Spring4+springboot1.5.x
@SpringBootTest
@RunWith(SpringRunner.class)
public class T1{
@Autowired
private CalcService service;
System.out.println("spring版本："+ SpringVersion.getVersion()+"\t"+"SpringBoot版本："+ SpringBootVersion.getVersion());
System.out.println();
calcService.div(10,2);
}
aop正常順序+異常順序
@Before
method.invode(obj, args);
@AfterReturning
{catch(
@AfterThrowing
)}
@After
正常
image-20210122143701670.png
異常
image-20210122143719917.png
spring4默認用的是JDK的動態代理
1.1.4 Spring5+springboot2.3.x
aop正常順序+異常順序
spring5--aop正常流程
image-20210122143840875.png
spring5--aop異常流程
image-20210122143915081.png
spring5默認動態代理用的是cglib,不再是JDK的動態代理，因為JDK必須要實現接口，但有些類它并沒有實現接口，所以更加通用的話就是cglib
1.1.5 總結
image-20210122144014724.png
1.2 spring的循環依賴
- 你解釋下spring中的三級緩存?
- 三級緩存分別是什么?三個Map有什么異同?
- 什么是循環依賴?請你談談?看過spring源碼嗎?一般我們說的spring容器是什么
- 如何檢測是否存在循環依賴?實際開發中見過循環依賴的異常嗎?
- 多例的情況下，循環依賴問題為什么無法解決?
1.2.1 什么是循環依賴
多個bean之間相互依賴，形成了一個閉環。 比如:A依賴于B、B依賴于c、c依賴于A
public class T1 {
class A {
B b;
}
class B {
C c;
}
class C {
A a;
}
}
比如：A依賴于B、B依賴于C、C依賴于A
通常來說，如果問spring容器內部如何解決循環依賴， 一定是指默認的單例Bean中，屬性互相引用的場景
image-20210122144611965.png
也就是說，Spring的循環依賴，是Spring容器注入時候出現的問題
1.2.2 兩種注入方式對循環依賴的影響
循環依賴官網說明
https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/core.html#beans
image-20210122144707814.png
我們AB循環依賴問題只要A的注入方式是setter且singleton, 就不會有循環依賴問題
1.2.3 spring容器循環依賴報錯BeanCurrentlylnCreationException
image-20210122145608897.png
循環依賴現象在Spring容器中 注入依賴的對象，有2種情況
構造器方式注入依賴
@Component
public class ServiceA {
private ServiceB serviceB;
public ServiceA(ServiceB serviceB) {
this.serviceB = serviceB;
}
}
@Component
public class ServiceB {
private ServiceA serviceA;
public ServiceB(ServiceA serviceA) {
this.serviceA = serviceA;
}
}
/**
* 通過構造器的方式注入依賴，構造器的方式注入依賴的bean，下面兩個bean循環依賴
*
* 測試后發現，構造器循環依賴是無法解決的
*/
public class ClientConstructor {
public static void main(String[] args) {
new ServiceA(new ServiceB(new ServiceA(new ServiceB()))); ....
}
}
構造器注入沒有辦法解決循環依賴， 你想讓構造器注入支持循環依賴，是不存在的
以set方式注入依賴
@Component
public class ServiceA {
private ServiceB serviceB;
public void setServiceB(ServiceB serviceB) {
this.serviceB = serviceB;
System.out.println("A 里面設置了B");
}
}
@Component
public class ServiceB {
private ServiceA serviceA;
public void setServiceA(ServiceA serviceA) {
this.serviceA = serviceA;
System.out.println("B 里面設置了A");
}
}
public class ClientSet {
public static void main(String[] args) {
//創建serviceA
ServiceA serviceA = new ServiceA();
//創建serviceB
ServiceB serviceB = new ServiceB();
//將serviceA注入到serviceB中
serviceB.setServiceA(serviceA);
//將serviceB注入到serviceA中
serviceA.setServiceB(serviceB);
}
}
code-java基礎編碼
public class A {
private B b;
public B getB(){
return b;
}
public void setB(B b){
this.b = b;
}
public A(){
System.out.println("---A created success");
}
}
public class B {
private A a;
public A getA(){
return a;
}
public void setA(A a){
this.a = a;
}
public B(){
System.out.println("---B created success");
}
}
public class ClientCode {
public static void main(String[] args) {
A a = new A();
B b = new B();
a.setB(b);
b.setA(a);
}
}
默認的單例(singleton)的場景是支持循環依賴的，不報錯
原型(Prototype)的場景是不支持循環依賴的，報錯
spring內部通過3級緩存來解決循環依賴
DefaultSingletonBeanRegistry
只有單例的Bean會通過三級緩存提前暴露來解決循環依賴的問題，而非單例的bean，每次從容器中獲取都是一個新的對象，都會重新創建，所有非單例的bean是沒有緩存的，不會將其放到三級緩存中。
第一級緩存〈也叫單例池）singletonObjects:存放已經經歷了完整生命周期的Bean對象
第二級緩存: earlySingletonObjects，存放早期暴露出來的Bean對象，Bean的生命周期未結束（屬性還未填充完整）
第三級緩存: Map<String, ObiectFactory<?>> singletonFactories，存放可以生成Bean的工廠
image-20210122145721952.png
所謂的三級緩存其實就是spring容器內部用來解決循環依賴問題的三個map
1.2.4 循環依賴Debug
- 實例化 堆內存中申請一塊內存空間
- 初始化 屬性填充 完成屬性的各種賦值
3大Map和四大方法，總體相關對象
image-20210122145958153.png
三級緩存+四大方法
1.getSingleton：希望從容器里面獲得單例的bean，沒有的話
2.doCreateBean: 沒有就創建bean
3.populateBean: 創建完了以后，要填充屬性
4.addSingleton: 填充完了以后，再添加到容器進行使用
第一層singletonObjects存放的是已經初始化好了的Bean,
第二層earlySingletonObjects存放的是實例化了，但是未初始化的Bean,
第三層singletonFactories存放的是FactoryBean。假如A類實現了FactoryBean,那么依賴注入的時候不是A類，而是A類產生的Bean
image-20210122150056564.png
A/B兩對象在三級緩存中的遷移說明
1 A創建過程中需要B，于是A將自己放到三級緩存里面，去實例化B
2 B實例化的時候發現需要A，于是B先查一級緩存，沒有，再查二級緩存，還是沒有，再查三級緩存，找到了A
然后把三級緩存里面的這個A放到二級緩存里面，并刪除三級緩存里面的A
3 B順利初始化完畢，將自己放到一級緩存里面（此時B里面的A依然是創建中狀態）
然后回來接著創建A，此時B已經創建結束，直接從一級緩存里面拿到B，然后完成創建，并將A自己放到一級緩存里面。
@FunctionalInterface
public interface ObjectFactory<T> {
/**
* Return an instance (possibly shared or independent)
* of the object managed by this factory.
* @return the resulting instance
* @throws BeansException in case of creation errors
*/
T getObject() throws BeansException;
}
1.2.5 總結
Spring創建bean主要分為兩個步驟，創建原始bean對象，接著去填充對象屬性和初始化
每次創建bean之前，我們都會從緩存中查下有沒有該bean，因為是單例，只能有一個
當我們創建 beanA的原始對象后，并把它放到三級緩存中，接下來就該填充對象屬性了，這時候發現依賴了beanB，接著就又去創建beanB，同樣的流程，創建完 beanB填充屬性時又發現它依賴了beanA又是同樣的流程，
不同的是：
這時候可以在三級緩存中查到剛放進去的原始對象beanA，所以不需要繼續創建，用它注入beanB，完成beanB的創建
既然 beanB創建好了，所以beanA就可以完成填充屬性的步驟了，接著執行剩下的邏輯，閉環完成
image-20210122150710112.png
Spring解決循環依賴依靠的是Bean的“中間態"這個概念，而這個中間態指的是已經實例化但還沒初始化的狀態……>半成品。
實例化的過程又是通過構造器創建的，如果A還沒創建好出來怎么可能提前曝光，所以構造器的循環依賴無法解決。
Spring為了解決單例的循環依賴問題，使用了三級緩存
其中一級緩存為單例池〈 singletonObjects)
二級緩存為提前曝光對象( earlySingletonObjects)
三級緩存為提前曝光對象工廠( singletonFactories）。
假設A、B循環引用，實例化A的時候就將其放入三級緩存中，接著填充屬性的時候，發現依賴了B，同樣的流程也是實例化后放入三級緩存，接著去填充屬性時又發現自己依賴A，這時候從緩存中查找到早期暴露的A，沒有AOP代理的話，直接將A的原始對象注入B，完成B的初始化后，進行屬性填充和初始化，這時候B完成后，就去完成剩下的A的步驟，如果有AOP代理，就進行AOP處理獲取代理后的對象A，注入B，走剩下的流程。
spring解決循環依賴的整個流程圖
Debug的步驟---->Spring解決循環依賴過程
1 調用doGetBean()方法，想要獲取beanA，于是調用getSingleton()方法從緩存中查找beanA
2 在getSingleton()方法中，從一級緩存中查找，沒有，返回null
3 doGetBean()方法中獲取到的beanA為null，于是走對應的處理邏輯，調用getSingleton()的重載方法（參數為ObjectFactory的)
4 在getSingleton()方法中，先將beanA_name添加到一個集合中，用于標記該bean正在創建中。然后回調匿名內部類的creatBean方法
5 進入AbstractAutowireCapableBeanFactory#doCreateBean，先反射調用構造器創建出beanA的實例，然后判斷。是否為單例、是否允許提前暴露引用(對于單例一般為true)、是否正在創建中〈即是否在第四步的集合中)。判斷為true則將beanA添加到【三級緩存】中
6 對beanA進行屬性填充，此時檢測到beanA依賴于beanB，于是開始查找beanB
7 調用doGetBean()方法，和上面beanA的過程一樣，到緩存中查找beanB，沒有則創建，然后給beanB填充屬性
8 此時beanB依賴于beanA，調用getsingleton()獲取beanA，依次從一級、二級、三級緩存中找，此時從三級緩存中獲取到beanA的創建工廠，通過創建工廠獲取到singletonObject，此時這個singletonObject指向的就是上面在doCreateBean()方法中實例化的beanA
9 這樣beanB就獲取到了beanA的依賴，于是beanB順利完成實例化，并將beanA從三級緩存移動到二級緩存中
10 隨后beanA繼續他的屬性填充工作，此時也獲取到了beanB，beanA也隨之完成了創建，回到getsingleton()方法中繼續向下執行，將beanA從二級緩存移動到一級緩存中
