Spring的兩大核心之一就是AOP，AOP：面向切面程式設計。在說原理之前，得先知道一些AOP的專業術語。

AOP的專業術語

連線點（JoinPoint）：增強執行的位置（增加程式碼的位置），Spring只支援方法；

切點（PointCut）：具體的連線點；一般可能通過一個表示式來描述；

增強（Advice）：也稱為訊息，指的是增加的額外的程式碼，Spring中，增強除了包含程式碼外，還包含位置資訊；

Spring中一共有四種增強：

MethodBeforeAdvice:前置增強

MethodInterceptor：環繞增強

ThrowsAdvice：異常增強

AfterReturingAdvice

引介（Introduction）：特殊的增強，動態為類增加方法

織入（Weaving）：將增強加入到目標類的過程，織入分為三種時期

編譯器:AspectJ

類載入

執行期：jdk動態代理（實現介面），CGlib（子類，不能用final）

目標物件（Target）：原始物件

代理物件（Proxy）：加入了增強的物件，是生成的；

切面（Aspect）：切點+增強

接下來我要說的就是在執行期間織入的兩種實現方式

JDK動態代理（實現介面）

什麼是代理模式呢？

  代理模式有三個角色，分別是

抽象角色：介面

目標角色：實現類

代理角色：實現介面（InvocationHandler），並引用目標角色

代理模式與裝飾者模式的區別

類圖（結構）基本一樣，但目的不同，裝飾模式的前提是已經所有的類，並進行組裝；而

使用代理模式時，我們不能直接訪問目標角色或沒有許可權訪問時，可以使用代理模式

代理模式分為兩種

靜態代理：需要為每個目標角色，建立一個對應的代理角色；類的數量會急劇膨脹

動態代理：自動為每個目標角色生成對應的代理角色

接下來就是jdk動態代理的程式碼：

實現jdk動態代理的前提是所有的目標類都必須要基於一個統一的介面

建立統一的介面

package com.dao;


/**
 * 為目標類定義統一的介面SleepDao
 * @author XuXQ
 *
 */
public interface SleepDao {

public void sleep();


}
 

package com.daoImpl;

import com.dao.SleepDao;

/**
 * 目標類
 * @author XuXQ
 *
 */
public class SleepDaoImpl implements SleepDao {

	@Override
	public void sleep() {
		System.out.println("本大人要睡覺了");
	}

}

建立代理角色

package com.handler;


import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
/**
 * 建立的類得需要實現InvocationHandler,並重寫invoke()方法
 * InvocationHandler 是代理例項的呼叫處理程式 實現的介面
 * 即：MyInvocationHandler 是代理例項的呼叫處理程式
 * @author XuXQ
 *
 */
public class MyInvoctionHandler implements InvocationHandler {
	Object object=null;//目標物件
	


	public MyInvoctionHandler(Object object) {
		super();
		this.object = object;
	}




	/**
	 * proxy=代理物件
	 * method=被呼叫方法的方法名
	 * args=被呼叫方法的引數
	 */
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		System.out.println("睡覺前要脫衣服啊");
		Object obj=method.invoke(object, args);//obj為目標物件呼叫方法的返回值
		System.out.println("睡著了當然得做個美夢啊");
		return obj;
	}


}

編寫測試用例

package com.handler;

import static org.junit.Assert.*;

import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import com.dao.SleepDao;
import com.daoImpl.SleepDaoImpl;

public class Test1 {

	@Before
	public void setUp() throws Exception {
	}

	@After
	public void tearDown() throws Exception {
	}

	@Test
	public void test() {
		//目標類必須基於統一的介面
		SleepDao s=new SleepDaoImpl();
		ClassLoader classLoader=s.getClass().getClassLoader();
		MyInvoctionHandler myInvoctionHandler=new MyInvoctionHandler(s);
		
		//Proxy為InvocationHandler實現類動態建立一個符合某一介面的代理例項  
		SleepDao sd=(SleepDao) Proxy.newProxyInstance(classLoader, s.getClass().getInterfaces(), myInvoctionHandler);
		
		//相當於呼叫代理角色的Invoke()
		sd.sleep();
	}

}

由結果可以看到成功的將增強織入到了目標物件中了

CGlib代理

package com.cglibproxy;
/**
 * 和JDK動態代理不同，不需要建立統一的介面
 * @author XuXQ
 *
 */
public class Base {
	public void sleep(){
		System.out.println("本大少要睡覺啦");
	}
}

package com.cglibproxy;

import java.lang.reflect.Method;

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;


//用來生成代理物件
public class CglibProxy implements MethodInterceptor {
	
	public Object getProxy(Object object){
		Enhancer e=new Enhancer();//建立代理物件類
		e.setSuperclass(object.getClass());//宣告代理物件的父類是誰（是目標物件）
		e.setCallback(this);//設定回撥函式，即呼叫intercept()
		return e.create();//返回建立的代理物件
	}
	/**
 * proxy=代理物件，也是目標物件的子類
 * args=方法引數
 */
	@Override
	public Object intercept(Object proxy, Method method, Object[] args, MethodProxy arg3) throws Throwable {
		System.out.println("你個大懶豬，竟然睡覺前不脫衣服，嫌棄o");
		Object object=arg3.invokeSuper(proxy, args);
		System.out.println("起床啦，要不然得遲到了哦");
		return null;
	}

}

package com.cglibproxy;

import static org.junit.Assert.*;

import org.junit.After;
import org.junit.Before;

public class Test {

	@Before
	public void setUp() throws Exception {
	}

	@After
	public void tearDown() throws Exception {
	}

	@org.junit.Test
	public void test() {
		CglibProxy proxy=new CglibProxy();
		Base base=(Base) proxy.getProxy(new Base());
		base.sleep();
	}

}

由結果同樣可以看到成功的將增強織入到了目標物件中了

總結

當然我們以後寫程式碼都是基於Aspect，直接寫註解的，當然這並不代表這我們不需要知道AOP

底層的實現原理，至於註解用的是哪種實現方式，使用配置來解決的，這裡就不詳解了。