spring aop常用的有以下：

    • 通知类型：
      前置通知（Before advice）：在某连接点之前执行的通知，但这个通知不能阻止连接点之前的执行流程（除非它抛出一个异常）。
       后置通知（After returning advice）：在某连接点正常完成后执行的通知：例如，一个方法没有抛出任何异常，正常返回。
      异常通知（After throwing advice）：在方法抛出异常退出时执行的通知。
       最终通知（After (finally) advice）：当某连接点退出的时候执行的通知（不论是正常返回还是异常退出）。
      * 环绕通知（Around Advice）：包围一个连接点的通知，如方法调用。这是最强大的一种通知类型。环绕通知可以在方法调用前后完成自定义的行为。它也会选择是否继续执行连接点或直接返回它自己的返回值或抛出异常来结束执行。
    • 核心配置只要在AOP的实现方法上加上@Aspect与在spring 配置文件中加上 aop:aspectj-autoproxy/,spring 就可以配置aop方法，然后再根据方法的增强标签不同的效果，这里需要注意是它们的参数不同。
    • pom.xml
    1. <project xmlns="http://maven.apache.org/POM/4.0.0"
    2.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    3.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    4.     <parent>
    5.         <artifactId>mrwood_study</artifactId>
    6.         <groupId>xyz.mrwood.study</groupId>
    7.         <version>1.0-SNAPSHOT</version>
    8.     </parent>
    9.     <modelVersion>4.0.0</modelVersion>
    11.     <artifactId>study-spring-aop</artifactId>
    12.     <packaging>jar</packaging>
    14.     <name>study-spring-aop</name>
    15.     <url>http://maven.apache.org</url>
    17.     <properties>
    18.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    19.         <spring.version>4.2.5.RELEASE</spring.version>
    21.     </properties>
    23.     <dependencies>
    24.         <!-- spring开始 -->
    25.         <dependency>
    26.             <groupId>org.springframework</groupId>
    27.             <artifactId>spring-aop</artifactId>
    28.             <version>${spring.version}</version>
    29.         </dependency>
    30.         <dependency>
    31.             <groupId>org.springframework</groupId>
    32.             <artifactId>spring-tx</artifactId>
    33.             <version>${spring.version}</version>
    34.         </dependency>
    35.         <dependency>
    36.             <groupId>org.springframework</groupId>
    37.             <artifactId>spring-beans</artifactId>
    38.             <version>${spring.version}</version>
    39.         </dependency>
    40.         <dependency>
    41.             <groupId>org.springframework</groupId>
    42.             <artifactId>spring-context</artifactId>
    43.             <version>${spring.version}</version>
    44.         </dependency>
    45.         <dependency>
    46.             <groupId>org.springframework</groupId>
    47.             <artifactId>spring-test</artifactId>
    48.             <version>${spring.version}</version>
    49.         </dependency>
    50.         <dependency>
    51.             <groupId>org.springframework</groupId>
    52.             <artifactId>spring-context-support</artifactId>
    53.             <version>${spring.version}</version>
    54.         </dependency>
    55.         <!--spring 结束-->
    57.         <!-- AOP begin -->
    58.         <dependency>
    59.             <groupId>org.aspectj</groupId>
    60.             <artifactId>aspectjrt</artifactId>
    61.             <version>1.7.4</version>
    62.         </dependency>
    63.         <dependency>
    64.             <groupId>org.aspectj</groupId>
    65.             <artifactId>aspectjweaver</artifactId>
    66.             <version>1.7.4</version>
    67.         </dependency>
    68.         <dependency>
    69.             <groupId>cglib</groupId>
    70.             <artifactId>cglib</artifactId>
    71.             <version>3.1</version>
    72.         </dependency>
    73.         <dependency>
    74.             <groupId>junit</groupId>
    75.             <artifactId>junit</artifactId>
    76.             <version>4.12</version>
    77.             <scope>test</scope>
    78.         </dependency>
    79.         <!-- AOP end -->
    81.         <!-- 日志开始 -->
    82.         <dependency>
    83.             <groupId>ch.qos.logback</groupId>
    84.             <artifactId>logback-classic</artifactId>
    85.             <version>1.1.7</version>
    86.             <exclusions>
    87.                 <exclusion>
    88.                     <artifactId>slf4j-api</artifactId>
    89.                     <groupId>org.slf4j</groupId>
    90.                 </exclusion>
    91.             </exclusions>
    92.         </dependency>
    93.         <dependency>
    94.             <groupId>org.slf4j</groupId>
    95.             <artifactId>slf4j-api</artifactId>
    96.             <version>1.7.21</version>
    97.         </dependency>
    98.         <!-- 日志结束 -->
    100.     </dependencies>
    101. </project>
    • spring-context.xml
    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.        xmlns:context="http://www.springframework.org/schema/context"
    5.        xmlns:aop="http://www.springframework.org/schema/aop"
    6.        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.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
    8.     <!--自动注入-->
    9.     <context:component-scan base-package="xyz.mrwood.study"/>
    11.     <!--开启aop-->
    12.     <aop:aspectj-autoproxy/>
    13. </beans>
    • AopHandler.java
    1. /**
    2.  * Copyright (c) 2016, 791650277@qq.com(Mr.kiwi) All Rights Reserved.
    3.  */
    4. package xyz.mrwood.study.aop;
    6. import org.aspectj.lang.JoinPoint;
    7. import org.aspectj.lang.ProceedingJoinPoint;
    8. import org.aspectj.lang.annotation.*;
    9. import org.springframework.stereotype.Component;
    11. /**
    12.  * 项目：study
    13.  * 包名：xyz.mrwood.study.aop
    14.  * 功能：aop实现
    15.  * 时间：2016-05-28 10:33
    16.  * 作者：Mr.Kiwi
    17.  * 通知类型：
    18.  * 前置通知（Before advice）：在某连接点之前执行的通知，但这个通知不能阻止连接点之前的执行流程（除非它抛出一个异常）。
    19.  * 后置通知（After returning advice）：在某连接点正常完成后执行的通知：例如，一个方法没有抛出任何异常，正常返回。
    20.  * 异常通知（After throwing advice）：在方法抛出异常退出时执行的通知。
    21.  * 最终通知（After (finally) advice）：当某连接点退出的时候执行的通知（不论是正常返回还是异常退出）。
    22.  * 环绕通知（Around Advice）：包围一个连接点的通知，如方法调用。这是最强大的一种通知类型。环绕通知可以在方法调用前后完成自定义的行为。它也会选择是否继续执行连接点或直接返回它自己的返回值或抛出异常来结束执行。
    23.  */
    24. @Aspect
    25. @Component
    26. public class AopHandler {
    28.     /**
    29.      * 拦截工程下所有的切点
    30.      */
    31.     @Pointcut("execution(* xyz.mrwood.study..*.*(..))")
    32.     public void getAllPoint() {
    33.     }
    35.     /**
    36.      * 拦截所有service层下的切点
    37.      */
    38.     @Pointcut("execution(* xyz.mrwood.study.service..*.*(..))")
    39.     public void getServicePoint() {
    40.     }
    43.     /**
    44.      * 前置增强
    45.      * @param joinPoint
    46.      */
    47.     @Before("getServicePoint()")
    48.     public void beforeMethod(JoinPoint joinPoint){
    50.         System.out.println("[前置增强开始]：" + "方法开始了");
    51.     }
    53.     @AfterThrowing(value = "getServicePoint()", throwing = "ex")
    54.     public void exceptionMethod(JoinPoint joinPoint, Exception ex){
    56.         System.out.println("[异常增强]：" + "如果你看到这行，就说明你的程序报错了！" + "异常信息：" + ex.getMessage());
    57.     }
    59.     /**
    60.      * 后置增强，只有在方法正常结束才会调用
    61.      * @param returnVal
    62.      */
    63.     @AfterReturning(value = "getServicePoint()",returning = "returnVal")
    64.     public void afterReturningMethod(Object returnVal){
    66.         System.out.println("[后置增强]：" + "当你看到这个说明，你的方法没有正常结束了！" + "它的返回值为：" + returnVal);
    67.     }
    69.     /**
    70.      * 最终增强，类似于finally的功能
    71.      */
    72.     @After("getServicePoint()")
    73.     public void afterMethod(){
    75.         System.out.println("[最终增强]：" + "无论发论发生什么事，我都会运行！");
    76.     }
    78.     /**
    79.      * 环绕增强
    80.      * @param proceedingJoinPoint
    81.      */
    82.     @Around("getServicePoint()")
    83.     public Object aroundMethod(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
    85.         System.out.println("[环绕增强开始]：" + "方法开始了！");
    86.         Object returnVal = proceedingJoinPoint.proceed(proceedingJoinPoint.getArgs());
    87.         System.out.println("[环绕增强结束]：" + "方法已经结束了！");
    89.         return returnVal;
    90.     }
    91. }
    • TargetService.java
    1. /**
    2.  * Copyright (c) 2016, 791650277@qq.com(Mr.kiwi) All Rights Reserved.
    3.  */
    4. package xyz.mrwood.study.service;
    6. import org.springframework.stereotype.Component;
    8. /**
    9.  * 项目：study
    10.  * 包名：xyz.mrwood.study.service
    11.  * 功能：被拦截的目标类
    12.  * 时间：2016-05-28 10:32
    13.  * 作者：Mr.Kiwi
    14.  */
    15. @Component
    16. public class TargetService {
    18.     public String hello(String name){
    20.         return "hello " + name;
    21.     }
    23.     public String  test(){
    26.         return "test";
    27.     }
    28. }
    • 运行结果
    1. [环绕增强开始]：方法开始了！
    2. [前置增强开始]：方法开始了
    3. [环绕增强结束]：方法已经结束了！
    4. [最终增强]：无论发论发生什么事，我都会运行！
    5. [后置增强]：当你看到这个说明，你的方法没有正常结束了！它的返回值为：test