Spring入門詳細教程（三）

前言

本篇緊接着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("后置通知，發生異常也會調用");
    }
}