@Repository("userDao")
public class UserDao {

    public void addUser() {
        System.out.println("?? 攔截的方法 addUser 開始執(zhí)行");
    }
}

@Aspect
@Component
public class AnnotationAspect {

    // 定義切入點表達式, 使用一個返回值為 void、方法體為空的方法來命名切入點
    @Pointcut("execution(* com.fairy.springmvc.aspectj.annotation.*.*(..))")
    private void customPointCut(){}

    // 前置通知
    @Before("customPointCut()")
    public void myBefore(JoinPoint joinPoint){
        System.out.print("前置通知：模擬執(zhí)行權(quán)限檢查..，");
        System.out.print("目標類是：" + joinPoint.getTarget());
        System.out.println("，被植入增強處理的目標方法為：" + joinPoint.getSignature().getName());
    }

    // 后置通知
    @AfterReturning(value="customPointCut()")
    public void myAfterReturning(JoinPoint joinPoint) {
        System.out.print("后置通知：模擬記錄日志..，");
        System.out.println("被植入增強處理的目標方法為：" + joinPoint.getSignature().getName());
    }

    /**
     * 環(huán)繞通知
     * ProceedingJoinPoint 是 JoinPoint的子接口，表示可執(zhí)行目標方法
     * 1.必須是 Object 類型的返回值
     * 2.必須接收一個參數(shù)，類型為 ProceedingJoinPoint
     * 3.必須 throws Throwable
     */
    @Around("customPointCut()")
    public Object myAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
        // 開始
        System.out.println("環(huán)繞開始：執(zhí)行目標方法之前，模擬開啟事務..，");
        // 執(zhí)行當前目標方法
        Object obj = proceedingJoinPoint.proceed();
        // 結(jié)束
        System.out.println("環(huán)繞結(jié)束：執(zhí)行目標方法之后，模擬關(guān)閉事務..，");
        return obj;
    }

    /**
     * 異常通知處理
     * @param joinPoint
     * @param e
     */
    @AfterThrowing(value="customPointCut()",throwing="e")
    public void myAfterThrowing(JoinPoint joinPoint, Throwable e){
        System.out.println("異常通知：出錯了" + e.getMessage());
    }

    // 最終通知
    @After("customPointCut()")
    public void myAfter(){
        System.out.println("最終通知：模擬方法結(jié)束后釋放資源..");
    }
}

<!-- 啟動基于注解的聲明式 AspectJ 支持 -->
<aop:aspectj-autoproxy />

@Configuration
@EnableAspectJAutoProxy
@ComponentScan("com.fairy.springmvc")
public class ApplicationConfig {
    ....
}

public class TestCase {
    @Test
    public void testAnnotation() throws Exception {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext(
                "spring-test.xml");

        // 從容器中獲得內(nèi)容
        UserDao userDao= (UserDao) applicationContext.getBean("userDao");
        // 執(zhí)行方法
        userDao.addUser();
    }
}

@Repository("companyDao")
public class CompanyDao {

    public void addCompany() {
        System.out.println("?? 真正的業(yè)務處理：add company ??");
    }

    public void exception() throws Exception {
        throw new Exception("業(yè)務異常了");
    }
}

@Component("xmlAspectConfig")
public class XmlAspect {

    public void printUnderscore() {
        System.out.println("------------------------------------------------");
    }

    /**
     * 在核心業(yè)務執(zhí)行前執(zhí)行，不能阻止核心業(yè)務的調(diào)用
     * @param joinPoint
     */
    public void beforeAdvice(JoinPoint joinPoint) {
        printUnderscore();
        System.out.println("1?? 通知：beforeAdvice 執(zhí)行開始");
        System.out.println("   執(zhí)行核心業(yè)務邏輯前，可以做一些前置的安全性的檢測等");
        System.out.println("   通知：beforeAdvice 執(zhí)行結(jié)束");
        printUnderscore();
    }

    /**
     * 核心業(yè)務退出后，不管是正常結(jié)束還是異常退出，均執(zhí)行此通知
     * @param joinPoint
     */
    public void afterAdvice(JoinPoint joinPoint) {
        printUnderscore();
        System.out.println("4?? 通知：afterAdvice 執(zhí)行開始");
        System.out.println("   此處可以對返回值做進一步的處理");
        System.out.println("   通知：afterAdvice 執(zhí)行結(jié)束");
    }

    /**
     * 核心業(yè)務調(diào)用正常退出后，不管是否有返回值，只要是正常退出，都會執(zhí)行此通知
     * @param joinPoint
     */
    public void afterReturningAdvice(JoinPoint joinPoint) {
        printUnderscore();
        System.out.println("2?? 通知：afterReturningAdvice 執(zhí)行開始");
        System.out.println("   此處可以對返回值做進一步處理");
        System.out.println("   通知：afterReturningAdvice 執(zhí)行結(jié)束");
    }

    /**
     * 核心業(yè)務邏輯調(diào)用異常退出后，執(zhí)行此通知，處理錯誤信息
     * @param e
     */
    public void afterThrowingAdvice(Exception e) {
        printUnderscore();
        System.out.println("3?? 通知：afterThrowingAdvice 執(zhí)行開始");
        System.out.println("   錯誤信息：" + e.getMessage());
        System.out.println("   此處意味著，在核心業(yè)務邏輯出錯時，捕獲異常，并可以做一些日志記錄相關(guān)的操作");
    }

    /**
     * 手動控制調(diào)用核心業(yè)務邏輯，以及調(diào)用前和調(diào)用后的處理
     * @param pjp
     */
    public Object aroundAdvice(ProceedingJoinPoint pjp) throws Throwable {
        // 開始
        System.out.println("5?? 環(huán)繞開始：執(zhí)行目標方法之前");
        System.out.println("   此處可以做類似于 Before Advice 的事情");
        // 調(diào)用核心邏輯，執(zhí)行當前目標方法
        Object obj = pjp.proceed();

        // 打印下劃線
        printUnderscore();
        // 結(jié)束
        System.out.println("   此處可以做類似于 After Advice 的事情");
        System.out.println("5?? 環(huán)繞結(jié)束：執(zhí)行目標方法之后");
        return obj;
    }
}

<!-- 基于 XML 文件的配置進行聲明，注意和 aop:aspectj-autoproxy 的區(qū)別 -->
<aop:config proxy-target-class="true">

    <!-- 基于 aspect 配置一個完整的切面 -->
    <aop:aspect id="aspectXmlConfigExample" ref="xmlAspectConfig">
        <!-- 切點配置，可以配置多個切點 -->
        <aop:pointcut id="xmlPointCut"
                      expression="execution(* com.fairy.springmvc.aspectj.xml.CompanyDao.*(..))"/>
        <aop:after-returning method="afterReturningAdvice" pointcut-ref="xmlPointCut" />
        <aop:after-throwing method="afterThrowingAdvice" pointcut-ref="xmlPointCut" throwing="e"/>
        <aop:after method="afterAdvice" pointcut-ref="xmlPointCut" />
        <aop:around method="aroundAdvice" pointcut-ref="xmlPointCut" />
        <aop:before method="beforeAdvice" pointcut-ref="xmlPointCut" />
    </aop:aspect>

</aop:config>

public class TestCase {
    @Test
    public void testAnnotation() throws Exception {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext(
                "spring-test.xml");

        CompanyDao companyDao = (CompanyDao) applicationContext.getBean("companyDao");
        companyDao.addCompany();
        // companyDao.exception();
    }

}