前言

本篇緊接著spring入門詳細教程（二），建議閱讀本篇前，先閱讀第一篇和第二篇。連結如下：

Spring入門詳細教程（一） https://www.cnblogs.com/jichi/p/10165538.html

Spring入門詳細教程（二） https://www.cnblogs.com/jichi/p/10176601.html

本篇主要講解spring的aop相關。

一、aop的概念

在軟體業，AOP為Aspect Oriented Programming的縮寫，意為：面向切面程式設計，通過預編譯方式和執行期動態代理實現程式功能的統一維護的一種技術。AOP是OOP的延續，是軟體開發中的一個熱點，也是Spring框架中的一個重要內容，是函數語言程式設計的一種衍生範型。利用AOP可以對業務邏輯的各個部分進行隔離，從而使得業務邏輯各部分之間的耦合度降低，提高程式的可重用性，同時提高了開發的效率。AOP是可以通過預編譯方式和執行期動態代理實現在不修改原始碼的情況下給程式動態統一新增功能的一種技術。

AOP主要實現功能日誌記錄，效能統計，安全控制，事務處理，異常處理等等。將日誌記錄，效能統計，安全控制，事務處理，異常處理等程式碼從業務邏輯程式碼中劃分出來，通過對這些行為的分離，我們希望可以將它們獨立到非指導業務邏輯的方法中，進而改變這些行為的時候不影響業務邏輯的程式碼。

AOP主要思想總結為橫向重複，縱向抽取。

二、spring實現aop的原理及底層實現

spring實現aop的底層使用了兩種代理機制。一種是jdk的動態代理，一種是cglib的動態代理。下面來分析一下兩種代理模式。

1、jdk的動態代理

被代理物件必須要實現接口才能產生代理物件，如果被代理物件不能實現介面，則這種方式的動態代理技術無效。

接下來做一個底層程式碼的編寫來進行理解。

（1）首先jdk的動態代理要求被代理物件必須實現介面。我們準備一個介面以及一個介面的實現類。

public interface UserDao {
    public void saveUser();
}

public class UserDaoImpl implements UserDao {
    public void saveUser(){
        System.out.println("儲存使用者");
    }
}

（2）建立一個UserDao的動態代理類，實現介面InvocationHandler。

public class UserProxy implements InvocationHandler{
    private UserDao userDao ;
    
    public UserProxy(UserDao userDao) {
        this.userDao = userDao;
    }

    public UserDao createProxy(){
        UserDao userDaoProxy = (UserDao) Proxy.newProxyInstance(userDao.getClass().getClassLoader(),userDao.getClass().getInterfaces(), this);
        return userDaoProxy;
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("動態代理");
        return method.invoke(userDao, args);
    }

}

（3）進行單元測試，發現第一個方法執行的時候沒有被動態代理，第二個執行的時候進行了動態代理。

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class TestJunit {
    @Test
    public void test3(){
        UserDaoImpl userDaoImpl = new UserDaoImpl();
        userDaoImpl.saveUser();
        UserProxy userProxy = new UserProxy(userDaoImpl);
        UserDao createProxy = userProxy.createProxy();
        createProxy.saveUser();
    }
}

2、cglib動態代理

針對一些不能實現介面的代理物件產生代理，可以對沒有被final修飾的任何物件進行繼承代理，其底層應用的是位元組碼增強的技術，生成代理物件的子類物件。如果被final修飾，類不可繼承，便不可使用cglib動態代理。

（1）建立一個cglib動態代理物件實現介面。

public class CglibProxy implements MethodInterceptor{

    private UserDaoImpl userDaoImpl;
    
    public CglibProxy(UserDaoImpl userDaoImpl) {
        this.userDaoImpl = userDaoImpl;
    }
    
    public UserDaoImpl createProxy(){
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(UserDaoImpl.class);
        enhancer.setCallback(this);
        UserDaoImpl udi = (UserDaoImpl) enhancer.create();
        return udi;
    }
    
    @Override
    public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        Object obj = methodProxy.invokeSuper(proxy, args);
        System.out.println("動態代理");
        return obj;
    }

}

（2）進行單元測試。

    public void test4(){
        UserDaoImpl userDaoImpl = new UserDaoImpl();
        userDaoImpl.saveUser();
        CglibProxy cglib = new CglibProxy(userDaoImpl);
        UserDaoImpl userDaoImpl2 = cglib.createProxy();
        userDaoImpl2.saveUser();
    }

可以發現第一個saveUser沒有執行動態代理，第二個執行了動態代理。

結論：兩種代理技術針對不同情況，互相彌補，從而使任何物件都可以實現動態代理。spring在進行aop的時候，預設使用jdk的動態代理技術，當發現jdk的動態代理技術不好使的情況下，使用cglib動態代理技術，保證被代理物件能夠被正常代理。如需使用cglib動態代理可以再spring的配置檔案中進行配置。

<aop:config proxy-target-class="true">

三、aop開發中的相關概念

1、Joinpoint（連線點）：目標物件中，所有可以增強的方法。

2、Pointcut（切入點）：目標物件中，已經增強的方法。

3、Advice（通知）：對於目標物件來說，需要給目標物件增強的方法。

4、Target（目標物件）：被代理物件。

5、Weaving（織入）：將通知應用到切入點的過程。

6、Proxy（代理）：將通知織入到目標物件後，形成的增強後的物件。

7、Aspect（切面）：切入點和通知的結合。

四、spring中aop的實現方式

分兩種方式介紹，一種是xml配置方式，一種是註解方式。

1、xml配置方式

（1）實現spring的aop需要匯入aop包，aspect包，aopalliance包，weaver包。在spring教程一中可以找到獲取這些包的方法。

（2）編寫需要增加的方法類。

public class UserDaoImpl{
    
    public void saveUser(){
        System.out.println("儲存使用者");
    }
    public void deleteUser(){
        System.out.println("刪除使用者");
    }
}

（3）編寫通知，也就是說想要增加的程式碼方法。

public class UserAdvice{
    
    public void before(){
        System.out.println("前置通知");
    }
    
    public void afterReturning(){
        System.out.println("後置通知（不發生異常的情況下呼叫）");
    }

    public Object around(ProceedingJoinPoint pjp) throws Throwable{
        System.out.println("執行前");
        Object proceed = pjp.proceed();
        System.out.println("執行後");
        return proceed;
    }
    
    public void afterThrowException(){
        System.out.println("發生異常呼叫");
    }
    
    public void after(){
        System.out.println("後置通知，發生異常也會呼叫");
    }
}

（4）在spring的配置檔案中進行配置

    <bean name = "userDaoImpl" class="com.jichi.aop.UserDaoImpl"></bean>
    <bean name="userAdvice" class="com.jichi.aop.UserAdvice"></bean>
    <aop:config>
        <aop:pointcut expression="execution(* com.jichi.aop..UserDaoImpl.*(..))" id="pc"/>
        <aop:aspect ref="userAdvice">
            <aop:before method="before" pointcut-ref="pc"/>
            <aop:after-returning method="afterReturning" pointcut-ref="pc"/>
            <aop:around method="around" pointcut-ref="pc"/>
            <aop:after-throwing method="afterThrowException" pointcut-ref="pc"/>
            <aop:after method="after" pointcut-ref="pc"/>
        </aop:aspect>
    </aop:config>

（5）進行單元測試

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class TestAop {

    @Resource
    private UserDaoImpl userDaoImpl;
    
    @Test
    public void test1(){
        userDaoImpl.saveUser();
    }
}

結果如下：織入成功。

2、註解配置方式

（1）同第一種方式需要匯入包

（2）編寫需要增加的方法類。

public class UserDaoImpl{
    
    public void saveUser(){
        System.out.println("儲存使用者");
    }
    public void deleteUser(){
        System.out.println("刪除使用者");
    }
}

（3）編寫通知，也就是說想要增加的程式碼方法。

public class UserAdvice{
    
    public void before(){
        System.out.println("前置通知");
    }
    
    public void afterReturning(){
        System.out.println("後置通知（不發生異常的情況下呼叫）");
    }

    public Object around(ProceedingJoinPoint pjp) throws Throwable{ System.out.println("執行前"); Object proceed = pjp.proceed(); System.out.println("執行後"); return proceed; } public void afterThrowException(){ System.out.println("發生異常呼叫"); } public void after(){ System.out.println("後置通知，發生異常也會呼叫"); } }

（4）在spring配置檔案中進行配置，並開啟註解aop

    <bean name = "userDaoImpl" class="com.jichi.aop.UserDaoImpl"></bean>
    <bean name="userAdvice" class="com.jichi.aop.UserAdvice"></bean>
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

（5）在通知類上打上aspect的註解。在方法上打上相應註解

@Aspect
public class UserAdvice{
    
    @Before("execution(* com.jichi.aop..UserDaoImpl.*(..))")
    public void before(){
        System.out.println("前置通知");
    }
    
    @AfterReturning("execution(* com.jichi.aop..UserDaoImpl.*(..))")
    public void afterReturning(){
        System.out.println("後置通知（不發生異常的情況下呼叫）");
    }

    @Around("execution(* com.jichi.aop..UserDaoImpl.*(..))")
    public Object around(ProceedingJoinPoint pjp) throws Throwable{
        System.out.println("執行前");
        Object proceed = pjp.proceed();
        System.out.println("執行後");
        return proceed;
    }
    
    @AfterThrowing("execution(* com.jichi.aop..UserDaoImpl.*(..))")
    public void afterThrowException(){
        System.out.println("發生異常呼叫");
    }
    
    @After("execution(* com.jichi.aop..UserDaoImpl.*(..))")
    public void after(){
        System.out.println("後置通知，發生異常也會呼叫");
    }
}

優化方式：每個方法都配置方法抽取，顯得比較臃腫，可以進行提取，方法如下

@Aspect
public class UserAdvice{
    
    @Pointcut("execution(* com.jichi.aop..UserDaoImpl.*(..))")
    public void adc(){}
    
    @Before("UserAdvice.adc()")
    public void before(){
        System.out.println("前置通知");
    }
    
    @AfterReturning("UserAdvice.adc()")
    public void afterReturning(){
        System.out.println("後置通知（不發生異常的情況下呼叫）");
    }

    @Around("UserAdvice.adc()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable{
        System.out.println("執行前");
        Object proceed = pjp.proceed();
        System.out.println("執行後");
        return proceed;
    }
    
    @AfterThrowing("UserAdvice.adc()")
    public void afterThrowException(){
        System.out.println("發生異常呼叫");
    }
    
    @After("UserAdvice.adc()")
    public void after(){
        System.out.println("後置通知，發生異常也會呼叫");
    }
}