《HR黑話大全》：那些殘忍的潛臺詞！你知道哪些？面試必懂。

與這個面試者聊了一會兒，咦，發現他水平還可以，我內心有點兒喜出望外，終於遇到一個“合格”的“陪聊者”了，我要用 Spring 事務“好好套路”他一下。

我：你在開發中，一般都把事務加到哪一層？

 他：都加到 Service 層。 

我：現在基本都是基於註解的配置了，那和事務相關的註解是哪個？ 

他：我不太會讀那個單詞，就是以@T開頭的那個。 

我：我明白你的意思，就是@Transactional。 

 他：是的。 

我：與自己寫程式碼來開啟和提交事務相比，（先給他來個小的套路），這種通過註解來使用事務的方式叫什麼？ 

 他：（猶豫了兩、三秒），不知道。 

我：如果把寫程式碼那種叫程式設計式事務，那與之相對的應該是什麼式事務？ 

他：哦，宣告式事務。 

我：（先鋪墊），不加註解，沒有事務，加上註解，就有事務，可見事務和註解有莫大的關係。（開始套路），那加上註解後，到底發生了什麼變化呢，就有了事務？ 

他：（猶豫了幾秒鐘），不知道。 

我：（哈哈，意料之中），那我換一問法，Spring宣告式事務的底層是怎麼實現的？ 

他：是通過代理實現的。 

我：（鋪墊），代理這個詞不僅計算機裡有，現實生活中也經常見到代理，比如招華北地區總代理等等。（套路），那你能不能在生活中舉一個代理的例子？ 

他：（想了一會兒），我沒有想到什麼好例子。 

我：（開始聊會天），我看你老家離這還挺遠的，你一般都什麼時候回去啊？ 

他：一般都國慶節或春節會回去。其它時間假期短就不回去了。 

我：（引子），國慶節和春節，人都很多啊，票不好買吧？ 

他：是啊，都在網路上搶高鐵票，不停地刷。 

我：（引子），現在有了高鐵，出行確實方便了很多。那你知道以前沒有高鐵、沒有12306的時候，人們都是怎麼買票的嗎？ 

他：我雖然沒有經歷過，但是我知道。那時候春運，都在火車站售票大廳買票，人們排很長的隊，有時需要等半天，還不一定有票。 

我：（切入正題），除了火車站售票大廳外，你有沒有見過在城市裡分佈的一些火車票代售點？ 

 他：現在偶爾還能見到幾個，但都已經關門了。 

我：是啊，現在都網路上買票了，代售點算是被歷史拋棄了。（開始套路），那你覺得代售點算不算火車站售票大廳的代理呢？ 

他：火車站售票大廳可以買票，代售點也可以買票，應該算是代理吧。 

我：從廣義講算是代理。但有兩點需要注意： 

• 一是，代售點賣的也是售票大廳的票，它自己是沒有票的，它只是行使售票大廳的權利。 
• 二是，它可以有屬於自己的行為特徵，比如不需要排隊啊，每張硬座票收5元手續費啊等等。 我們平時聽到的中間商/代理商，其實都差不多是一回事兒。 

他：經你這麼一說，我明白了。 

我：那我們再說回到Spring中的代理，在Spring中生成代理的方式有幾種？ 

 他：兩種，JDK動態代理和CGLIB。 

我：那它們分別用於什麼情況下？  

他：JDK動態代理只能用於帶介面的，CGLIB則帶不帶介面都行。  

我：（鋪墊），假如有個介面，它包含兩個方法a和b，然後有一個類實現了該介面。在該實現類裡在a上標上事務註解、b上不標，此時事務是怎樣的？ 

他：a標註解了，肯定有事務，b沒有註解，所以沒有事務。 

我：嗯，是這樣的。（開始套路），現在來做個簡單的修改，在方法b裡呼叫方法a，其它保持不變，此時再呼叫方法b，會有事務嗎？ 

 他：應該有吧，雖然b沒有註解，但a有啊。 

我：（我需要帶帶他），假設現在你和我都不知道有沒有事務，那我們來分析分析，看能不能找出答案。你有分析思路嗎？ 

 他：沒有。 

我：行吧，那我們開始。這是一個帶介面的，那就假定使用JDK動態代理吧。從巨集觀上看，就是Spring使用JDK動態代理為這個類生成了一個代理，併為標有註解的方法新增了和事務相關的程式碼，所以就具有了事務。那你知道這個代理大概會是什麼樣子的嗎？ 

 他：這個不知道。 

我：通過代售點的例子我們應該知道，所有的代理都具有以下特點： 

• 1.代理是一個空殼，它背後才是真正的老闆。 
• 2.代理可以行使老闆的權力，所以它看起來“很像”老闆，除非仔細檢視，否則不易區分。  
• 3.代理自己可以按需加進去一些行為特徵，除非仔細檢視，否則老闆都不一定知道這些。  

那我們回到程式世界，使用介面和類再套一下上面的特點： 

• 1.代理類是一個空殼（或外觀），它背後才是真正的類，通常稱為目標類。由此得出代理類要包含目標類。 
• 2.對目標類和代理類的使用方式是一樣的，甚至你都不知道它是代理類。由此得出代理類和目標類的型別要相容，對外介面一致。所以目標類實現的介面，代理類也要實現。 
• 3.代理類在把執行流程代理給目標類的過程中，可以新增一些行為程式碼，如開啟事務、提交事務等。

他：所以這個問題的答案就是沒有事務。 

我：這是我們分析推理的結果，究竟對不對呢，還需要驗證一下。

驗證過程如下： 找一個正常可用的Spring專案，把一個@Service的介面注入到一個@Controller類裡面，進行檢測，請仔細看下程式碼：

//是否是JDK動態代理
System.out.println("isJdkDynamicProxy => " + AopUtils.isJdkDynamicProxy(exampleService));
//是否是CGLIB代理
System.out.println("isCglibProxy => " + AopUtils.isCglibProxy(exampleService));
//代理類的型別
System.out.println("proxyClass => " + exampleService.getClass());
//代理類的父類的型別
System.out.println("parentClass => " + exampleService.getClass().getSuperclass());
//代理類的父類實現的介面
System.out.println("parentClass's interfaces => " + Arrays.asList(exampleService.getClass().getSuperclass().getInterfaces()));
//代理類實現的介面
System.out.println("proxyClass's interfaces => " + Arrays.asList(exampleService.getClass().getInterfaces()));
//代理物件
System.out.println("proxy => " + exampleService);
//目標物件
System.out.println("target => " + AopProxyUtils.getSingletonTarget(exampleService));
//代理物件和目標物件是不是同一個
System.out.println("proxy == target => " + (exampleService == AopProxyUtils.getSingletonTarget(exampleService)));
//目標類的型別
System.out.println("targetClass => " + AopProxyUtils.getSingletonTarget(exampleService).getClass());
//目標類實現的介面
System.out.println("targetClass's interfaces => " + Arrays.asList(AopProxyUtils.getSingletonTarget(exampleService).getClass().getInterfaces()));
System.out.println("----------------------------------------------------");
//自己模擬的動態代理的測試
Service target = new ServiceImpl();
ProxyByJdkDynamic proxy = new ProxyByJdkDynamic(target);
proxy.doNeedTx();
System.out.println("-------");
proxy.doNotneedTx();
System.out.println("-------");複製程式碼

• //是JDK動態代理
  isJdkDynamicProxy => true
  //不是CGLIB代理
  isCglibProxy => false
  //代理類的型別，帶$的
  proxyClass => class com.sun.proxy.$Proxy82
  //代理類的父類
  parentClass => class java.lang.reflect.Proxy
  代理類的父類實現的介面
  parentClass's interfaces => [interface java.io.Serializable]
  //代理類實現的介面，包含了目標類的介面IExampleService，還有其它的
  proxyClass's interfaces => [interface org.eop.sb.example.service.IExampleService,
  interface org.springframework.aop.SpringProxy,
  interface org.springframework.aop.framework.Advised,
  interface org.springframework.core.DecoratingProxy]
  //代理物件
  proxy => org.eop.sb.example.service.impl.ExampleServiceImpl@54561bc9
  //目標物件
  target => org.eop.sb.example.service.impl.ExampleServiceImpl@54561bc9
  //代理物件和目標物件輸出的都是@54561bc9，還真有點懵逼
  //進行測試後發現，其實不是同一個，只是toString()的問題
  proxy == target => false
  //目標類，我們自己寫的
  targetClass => class org.eop.sb.example.service.impl.ExampleServiceImpl
  //目標類實現的介面，我們自己寫的
  targetClass's interfaces => [interface org.eop.sb.example.service.IExampleService]
  ----------------------------------------------------
  //帶註解的方法呼叫，有事務的開啟和提交
  -> create Tx here in Proxy
  execute doNeedTx in ServiceImpl
  <- commit Tx here in Proxy
  -------
  //沒有註解的方法呼叫，是沒有事務的
  execute doNeedTx in ServiceImpl
  -------複製程式碼

經過測試後，發現和我們推斷的一模一樣。 

他：你真是打破砂鍋問到底，把這個事情徹底弄明白了。 

我：對於沒有實現介面的類，只能使用CGLIB來生成代理。（開始套路），假設有這樣一個類，它裡面包含public方法，protected方法，private方法，package方法，final方法，static方法，我都給它們加上事務註解，哪些方法會有事務呢？ 

他：那我就現學現賣，事務是由代理加進去的，所以關鍵就是代理如何生成。按照上面所說的代理應該具備的特點來看，只能通過繼承的方式生成一個子類來充當代理，看起來就是這樣的：

class Target {
	@Transactional
	    public void doNeedTx() {
		System.out.println("execute doNeedTx in Target");
	}
	//no annotation here
	public void doNotneedTx() {
		this.doNeedTx();
	}
}
class ProxyByCGLIB extends Target {
	private Target target;
	public ProxyByCGLIB(Target target) {
		this.target = target;
	}
	@Override
	    public void doNeedTx() {
		System.out.println("-> create Tx in Proxy");
		target.doNeedTx();
		System.out.println("<- commit Tx in Proxy");
	}
	@Override
	    public void doNotneedTx() {
		target.doNotneedTx();
	}
}複製程式碼

//不是JDK動態代理
isJdkDynamicProxy => false
//是CGLIB代理
isCglibProxy => true
//生成的代理類的型別，帶$$的
proxyClass => class org.eop.sb.example.service.impl.ExampleServiceImpl$$EnhancerBySpringCGLIB$$5320b86e
//代理類的父類，就是目標類
parentClass => class org.eop.sb.example.service.impl.ExampleServiceImpl
//父類實現的介面，就是我們自己寫的介面
parentClass's interfaces => [interface org.eop.sb.example.service.IExampleService]
/**代理類實現的介面，並不包含目標類的介面*/
proxyClass's interfaces => [interface org.springframework.aop.SpringProxy,
interface org.springframework.aop.framework.Advised,
interface org.springframework.cglib.proxy.Factory]
//代理物件
proxy => org.eop.sb.example.service.impl.ExampleServiceImpl@1b2702b1
//目標物件
target => org.eop.sb.example.service.impl.ExampleServiceImpl@1b2702b1
//代理物件和目標物件不是同一個
proxy == target => false
//目標類，我們自己寫的類
targetClass => class org.eop.sb.example.service.impl.ExampleServiceImpl
//目標類實現的介面
targetClass's interfaces => [interface org.eop.sb.example.service.IExampleService]複製程式碼