• 1. 要使用aop編程所需要的jar:
     aspectjrt.jar
     aspectjweaver.jar
     commons-logging-1.2.jar
     spring-aop-4.3.9.RELEASE.jar
     spring-aspects-4.3.9.RELEASE.jar
     spring-beans-4.3.9.RELEASE.jar
     spring-context-4.3.9.RELEASE.jar
     spring-core-4.3.9.RELEASE.jar
     spring-expression-4.3.9.RELEASE.jar

• 2.在配置文件加入aop命名空間

• 3 把切面加入ioc容器 使用@Component 注解加入spring容器 使用@Aspect標識為切面

• 4 在切面類中聲明通知如 @Before

• 5 訪問到方法細節(jié)在通知方法加入?yún)?shù)JoinPoint

注解方式：

模擬計算器 在加減乘除打印日志

定義一個計算器接口

package chen.spring.aop;
public interface calculate {
    int add(int i, int j);
    int sub(int i, int j);
    int mul(int i, int j);
    int div(int i, int j);
}

計算器實現(xiàn)類并注解方式配置為bean

package chen.spring.aop;

import org.springframework.stereotype.Component;

@Component
public class JiShuanQi implements calculate{
    @Override
    public int add(int i, int j) {
        int r=i+j;
        System.out.println( r);
        return r;
    }

    @Override
    public int sub(int i, int j) {
        int r=i-j;
        System.out.println( r);
        return r;
    }

    @Override
    public int mul(int i, int j) {
        int r=i*j;
        System.out.println( r);
        return r;
    }

    @Override
    public int div(int i, int j) {
        int r=i/j;
        System.out.println( r);
        return r;
    }
}

切面類：

package chen.spring.aop;

import java.util.Arrays;

import java.util.List;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;


//使用@Order注解指定切面右下角 越小優(yōu)先級越高
@Order(1)
@Aspect
@Component
public class LogAspect {
    //定義一個方法风皿，用于聲明切入點表達式舞痰，一般這個方法不需要其他代碼
    //使用@Pointcut來聲明切入點
    //后面的其他通知就可以直接使用方法名來引用當(dāng)前的切入點表達式
    @Pointcut("execution(public int chen.spring.aop.calculate.*(int, int))")
    public void pointcut() {}
    
    
    //聲明前置前置通知：在目標方法之前
//  @Before("execution(public int chen.spring.aop.calculate.*(int, int))")
    @Before("pointcut()")//使用了切入點聲明
    public void beforeLog(JoinPoint jPoint) {
        String name=jPoint.getSignature().getName();//獲取方法name
        List<Object> args=Arrays.asList(jPoint.getArgs());//獲取參數(shù)
        System.out.println("前置通知 方法"+name +"參數(shù)"+args);
        
    }
    
    //后置通知：在目標方法執(zhí)行后（無論發(fā)生錯誤）
    //在后置通知中還不能訪問目標方法的結(jié)果
    @After("execution(public int chen.spring.aop.calculate.*(int, int))")
    public void afterLog(JoinPoint jPoint) {
        String name=jPoint.getSignature().getName();//獲取方法name
        List<Object> args=Arrays.asList(jPoint.getArgs());//獲取參數(shù)
        System.out.println("后置通知 方法"+name +"參數(shù)"+args);
    }
    
    //返回通知：在方法正確執(zhí)行后執(zhí)行的代碼
    //可以訪問返回值
    @AfterReturning(value="execution(public int chen.spring.aop.calculate.*(int, int))",
            returning="result")
    public void afterReturningLog(JoinPoint jPoint,Object result) {
        String name=jPoint.getSignature().getName();//獲取方法name
        List<Object> args=Arrays.asList(jPoint.getArgs());//獲取參數(shù)
        System.out.println("返回通知 方法"+name +" 參數(shù)="+args+" 返回值="+result);
        
    }
    //異常通知：在方法異常后執(zhí)行的代碼
    //可以指定特定異常才執(zhí)行
    @AfterThrowing(value="execution(public int chen.spring.aop.calculate.*(int, int))",
            throwing="ex")
    public void afterThrowingLog(JoinPoint jPoint,Exception ex) {
        String name=jPoint.getSignature().getName();//獲取方法name
        System.out.println("返回通知 方法"+name +" 返回值="+ex);
    }
    
    //環(huán)繞通知:需要ProceedingJoinPoint類型的參數(shù)
    //環(huán)繞通知類似于動態(tài)代理的全程：ProceedingJoinPoint類型的參數(shù)可以決定是否執(zhí)行目標方法
    //且環(huán)繞通知必須有返回值包蓝，返回值即為目標方法的返回值
    @Around("execution(public int chen.spring.aop.calculate.*(int, int))")
    public Object aroundLog(ProceedingJoinPoint point) {
        String name=point.getSignature().getName();
        System.out.println("環(huán)繞通知 方法"+name);
        Object r=null;
        try {
            //前置通知
            r=point.proceed();//執(zhí)行目標方法
            //返回通知
        } catch (Throwable e) {
            //異常通知
            e.printStackTrace();
        }
            //后置通知
        return r;
    }
}


    //1 需要的jar

    /**
    aspectjrt.jar
    aspectjweaver.jar
    commons-logging-1.2.jar
    spring-aop-4.3.9.RELEASE.jar
    spring-aspects-4.3.9.RELEASE.jar
    spring-beans-4.3.9.RELEASE.jar
    spring-context-4.3.9.RELEASE.jar
    spring-core-4.3.9.RELEASE.jar
    spring-expression-4.3.9.RELEASE.jar
     * */
    
    //2 在配置文件加入aop命名空間
    
    //3 把切面加入ioc容器 使用@Component  標識為切面使用@Aspect
    
    //4 在切面類中聲明通知如 @Before
    
    //5 訪問到方法細節(jié)在通知方法加入?yún)?shù)JoinPoint

配置文件 ：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">
<!--配置自動掃描 -->
<context:component-scan base-package="chen.spring.aop"></context:component-scan>
<!-- 使 aspectj 注解起作用 -->
<aop:aspectj-autoproxy proxy-target-class="true"></aop:aspectj-autoproxy>
</beans>

• 必須<aop:aspectj-autoproxy/>啟動注解配置

通知：

• 前置通知：在目標方法之前 使用 @Before（execution（方法的全簽名））可以使用通配符

    //聲明前置前置通知：在目標方法之前
    @Before("execution(public int chen.spring.aop.calculate.*(int, int))")
    public void beforeLog(JoinPoint jPoint) {
        String name=jPoint.getSignature().getName();//獲取方法name
        List<Object> args=Arrays.asList(jPoint.getArgs());//獲取參數(shù)
        System.out.println("前置通知 方法"+name +"參數(shù)"+args);
        
    }

• 后置通知：在目標方法執(zhí)行后（無論發(fā)生錯誤）并且 后置通知中還不能訪問目標方法的結(jié)果

//后置通知：在目標方法執(zhí)行后（無論發(fā)生錯誤）
    //在后置通知中還不能訪問目標方法的結(jié)果
    @After("execution(public int chen.spring.aop.calculate.*(int, int))")
    public void afterLog(JoinPoint jPoint) {
        String name=jPoint.getSignature().getName();//獲取方法name
        List<Object> args=Arrays.asList(jPoint.getArgs());//獲取參數(shù)
        System.out.println("后置通知 方法"+name +"參數(shù)"+args);
    }

• 返回通知：在方法正確執(zhí)行后執(zhí)行的代碼 并且可以訪問返回值

//返回通知：在方法正確執(zhí)行后執(zhí)行的代碼
    //可以訪問返回值
    @AfterReturning(value="execution(public int chen.spring.aop.calculate.*(int, int))",
            returning="result")
    public void afterReturningLog(JoinPoint jPoint,Object result) {
        String name=jPoint.getSignature().getName();//獲取方法name
        List<Object> args=Arrays.asList(jPoint.getArgs());//獲取參數(shù)
        System.out.println("返回通知 方法"+name +" 參數(shù)="+args+" 返回值="+result);
        
    }

• 異常通知：在方法異常后執(zhí)行的代碼 可以指定特定異常才執(zhí)行

    //異常通知：在方法異常后執(zhí)行的代碼
    //可以指定特定異常才執(zhí)行
    @AfterThrowing(value="execution(public int chen.spring.aop.calculate.*(int, int))",
            throwing="ex")
    public void afterThrowingLog(JoinPoint jPoint,Exception ex) {
        String name=jPoint.getSignature().getName();//獲取方法name
        System.out.println("返回通知 方法"+name +" 返回值="+ex);
    }

• 環(huán)繞通知 環(huán)繞通知:需要ProceedingJoinPoint類型的參數(shù) 環(huán)繞通知類似于動態(tài)代理的全程：ProceedingJoinPoint類型的參數(shù)可以決定是否執(zhí)行目標方法 且環(huán)繞通知必須有返回值蒜哀，返回值即為目標方法的返回值

//環(huán)繞通知:需要ProceedingJoinPoint類型的參數(shù)
    //環(huán)繞通知類似于動態(tài)代理的全程：ProceedingJoinPoint類型的參數(shù)可以決定是否執(zhí)行目標方法
    //且環(huán)繞通知必須有返回值，返回值即為目標方法的返回值
    @Around("execution(public int chen.spring.aop.calculate.*(int, int))")
    public Object aroundLog(ProceedingJoinPoint point) {
        String name=point.getSignature().getName();
        System.out.println("環(huán)繞通知 方法"+name);
        Object r=null;
        try {
            //前置通知
            r=point.proceed();//執(zhí)行目標方法
            //返回通知
        } catch (Throwable e) {
            //異常通知
            e.printStackTrace();
        }
            //后置通知
        return r;
    }

• 定義一個方法，用于聲明切入點表達式，一般這個方法不需要其他代碼 使用@Pointcut來聲明切入點 后面的其他通知就可以直接使用方法名來引用當(dāng)前的切入點表達式

//定義一個方法苫耸，用于聲明切入點表達式，一般這個方法不需要其他代碼
    //使用@Pointcut來聲明切入點
    //后面的其他通知就可以直接使用方法名來引用當(dāng)前的切入點表達式
    @Pointcut("execution(public int chen.spring.aop.calculate.*(int, int))")
    public void pointcut() {}

    //聲明前置前置通知：在目標方法之前
    @Before("pointcut()")//使用了切入點聲明
    public void beforeLog(JoinPoint jPoint) {
        String name=jPoint.getSignature().getName();//獲取方法name
        List<Object> args=Arrays.asList(jPoint.getArgs());//獲取參數(shù)
        System.out.println("前置通知 方法"+name +"參數(shù)"+args);
        
    }

配置文件方式：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd">
    <!-- 配置bean -->
    <bean id="jsq" class="chen.spring.aop.JiShuanQi"></bean>
    <!-- 配置切面bean -->
    <bean id="aspect" class="chen.spring.aop.LogAspect"></bean>
    <!-- 配置AOP -->
    <aop:config>
        <!-- 配置切點表達式 -->
        <aop:pointcut
            expression="execution(public int chen.spring.aop.calculate.*(int, int))"
            id="pointcut" />
        <!-- 配置切面 -->
        <aop:aspect ref="aspect" order="1">
            <!-- 配置切面通知 -->
            <aop:before method="afterLog" pointcut-ref="pointcut" />
            <aop:after method="afterLog" pointcut-ref="pointcut" />
        </aop:aspect>
    </aop:config>

</beans>

• 1.配置bean
• 2.配置切面bean
• 3.配置AOP
  1）配置切點表達式 切點
  2）配置切面 關(guān)聯(lián)切面bean
  3）在切面配置中 配置切面通知 以及通知對應(yīng)的方法

總結(jié)：

• 切面類要加入spring容器 并使用@Aspect標識 spring就可以自動識別裝配

• 當(dāng)目標類方法擁有多個切面時可以在 切面類使用@Order（數(shù)值）注解 數(shù)值越小優(yōu)先級越高 （切面優(yōu)先級）

• 切面原理 動態(tài)代理

• 各個通知可以有相應(yīng)的參數(shù) 也可以獲取相應(yīng)的數(shù)據(jù)

• 切點：需要介入的目標方法 切面：處理對應(yīng)的類 通知：介入目標方法 的介入方法