1 <!-- AOP的配置 -->
 2     <aop:config>
 3         <!-- 配置所有切面通用的切入点表达式 -->
 4         <aop:pointcut expression="execution(* cn.itcast.service.impl.*.*(..))" id="pt1"/>
 5     
 6         <!-- 配置切面：切面就是关心的某一个方面 
 7             id：指定的是通知的唯一标识
 8             ref：指定的通知的bean的id
 9         -->
10         <aop:aspect id="loggerAdvice" ref="logger">
11             <!-- 抽取当前切面的通用切入点表达式 
12                 expression属性：指定的就是切入点表达式
13                 id属性：是把切入点表达式赋予唯一标识
14             
15             <aop:pointcut expression="execution(* cn.itcast.service.impl.*.*(..))" id="pt1"/>
16             -->
17             <!-- 配置通知的类型：指的就是在业务核心方法的什么时候执行 
18                 aop:before：指定的是前置通知
19             
20                 method属性：指的是通知里面的哪个方法执行
21                 pointcut属性：指定的是切入点表达式。表明从哪里切入业务主线。
22                             把哪些连接点变成切入点。
23                 切入点表达式：
24                     关键字：execution(表达式)
25                     表达式语法：
26                         访问修饰符  返回值  包名.类名.方法名(参数列表)
27                     全匹配方式：
28                         execution(public void cn.itcast.service.impl.UserServiceImpl.saveUser())
29                     访问修饰符可以不写：
30                         execution(void cn.itcast.service.impl.UserServiceImpl.saveUser())
31                     返回值可以使用通配符：通配符*
32                         execution(* cn.itcast.service.impl.UserServiceImpl.saveUser())
33                     包名可以使用通配符：当使用通配符时，有几级包，写几个*
34                         execution(* *.*.*.*.UserServiceImpl.saveUser())
35                     包名称可以使用..，表明的是当前包及其子包
36                         execution(* cn..UserServiceImpl.saveUser())
37                     类名可以使用通配符：
38                         execution(* cn..*.saveUser())
39                     方法名可以使用通配符：
40                         execution(* cn..*.*())
41                     参数列表可以指定类型：注意的是，如果是基本类型直接写类型名称，如果是引用类型，需要些包名.类名。lang也必须写。例如：java.lang.String
42                         execution(* *..*.*(int))
43                     参数列表可以使用通配符：注意:不能表示有无参数均可。只能表示参数的数据类型是任意的
44                         execution(* *..*.*(*))
45                     有无参数均可，可以使用..来表示：
46                         execution(* *..*.*(..))
47                     最简版：
48                         execution(* *..*.*(..))
49                     建议的写法：
50                         切到业务层具体实现类即可：
51                             execution(* cn.itcast.service.impl.*.*(..))
52                             
53                     pointcut-ref：指定的是通用切入点表达式的唯一标识
54                 -->
55             <aop:before method="printLog" pointcut-ref="pt1"/>        
56         </aop:aspect>
57     </aop:config>

1 <aop:pointcut expression="execution(* cn.itcast.service.impl.*.*(..))" id="pt1"/>
2 <aop:before method="printLog" pointcut-ref="pt1"/>

 1 <!-- 配置所有切面通用的切入点表达式 -->
 2         <aop:pointcut expression="execution(* cn.itcast.service.impl.*.*(..))" id="pt1"/>
 3         <aop:aspect id="loggerAdvice" ref="logger">
 4             <!-- 指定通知的类型-->
 5             <!-- 前置通知：永远在切入点方法执行之前执行
 6                  它可以获取切入点方法的参数
 7             
 8             <aop:before method="beforePrintLog" pointcut-ref="pt1"/>    -->
 9             
10             <!-- 后置通知：切入点方法正确执行之后执行。它和例外通知只会有一个执行 
11                 它可以获取切入点方法的返回值
12                 除了在通知的方法中提供一个参数之外，还需要在配置文件中提供一个属性
13                 returning属性：指定的是后置通知中方法参数的变量名称，严格区分大小写。
14             
15             <aop:after-returning method="afterReturningPrintLog" pointcut-ref="pt1" returning="rtValue"/>-->
16             
17             <!-- 例外通知：切入点方法执行时产生异常后执行。它和后置通知只会有一个执行 
18                 除了在通知的方法中提供一个Throwable类型的参数之外，还需要在配置文件中提供一个属性
19                 throwing属性：指定的是例外通知中方法参数的变量名称。严格区分大小写。
20             -->
21             <aop:after-throwing method="afterThrowingprintLog" pointcut-ref="pt1" throwing="th"/>
22             
23             <!-- 最终通知：无论切入点方法是否正确执行了，它都会在最后执行 
24             <aop:after method="printLog" pointcut-ref="pt1"/>-->
25             
26             <!-- 环绕通知：详情请见Logger类中的注释
27             <aop:around method="aroundPrintLog" pointcut-ref="pt1"/>-->
28         </aop:aspect>

 1     /**
 2      * 前置通知：它可以获取切入点方法的参数
 3      * Spring框架给我们提供了一个接口：JoinPoint
 4      * 在程序执行到前置通知方法时，spring框架会为我们注入该接口的实现类。
 5      * 该接口中有一个方法：
 6      *         Object[] args = jp.getArgs();
 7      */
 8     public static void beforePrintLog(JoinPoint jp){
 9         Object[] args = jp.getArgs();
10         System.out.println(Arrays.toString(args));
11         System.out.println("Logger的beforePrintLog方法开始记录日志。。。。。。。");
12     }
13     
14     /**
15      * 后置通知：它可以获取切入点方法的返回值
16      * 需要我们在后置通知的方法中提供一个参数，参数的类型是Object
17      * 参数的变量名称必须和配置文件中的returning属性保持一致
18      */
19     public static void afterReturningPrintLog(Object rtValue){
20         System.out.println(rtValue);
21         System.out.println("Logger的afterReturningPrintLog方法开始记录日志。。。。。。。");
22     }
23     
24     /**
25      * 例外通知：它可以获取切入点方法的异常对象
26      * 需要我们在例外通知的方法中提供一个参数，参数的类型是Throwable
27      * 参数的变量名称必须和配置文件中的throwing属性保持一致 
28      */
29     public static void afterThrowingprintLog(Throwable th){
30         System.out.println("异常信息是："+th);
31         System.out.println("Logger的afterThrowingprintLog方法开始记录日志。。。。。。。");
32     }
33     
34     /**
35      * 环绕通知详细说明：
36      *         它不是在配置切入点方法的前后执行，而是spring给我们提供的一种方式。让我们自己决定该通知是前置还是后者，例外还是最终。
37      * 问题：
38      *     当我们执行时，只会看见通知方法的语句输出，而看不到业务核心方法的输出语句。
39      * 分析原因：
40      *     在我们使用动态代理控制事务时，有明确的一句话调用业务核心方法：method.invoke(obj,args);
41      *     而此时我们没有明确的调用业务核心方法。
42      *     所以只能看到通知的语句输出，而无法看到业务核心方法的语句输出。
43      * 解决办法：
44      *     Spring给我们提供的一个接口：ProceedingJoinPoint
45      *     当Spring框架在执行通知时，会为我们提供该接口的实现类，我们在使用时，直接用即可。无须关心谁给我们提供。
46      *     ProceedingJoinPoint接口有一个方法：proceed()，它就相当于method的invoke方法。
47      *      pjp.proceed();    ======== method.invoke(obj,args);
48      *  
49      */
50     public static void aroundPrintLog(ProceedingJoinPoint pjp){
51         try {
52 //            System.out.println("Logger的aroundPringLog方法开始记录日志。。。。。。。");
53             pjp.proceed();
54 //            System.out.println("Logger的aroundPringLog方法开始记录日志。。。。。。。");
55         } catch (Throwable e) {
56 //            System.out.println("Logger的aroundPringLog方法开始记录日志。。。。。。。");
57             e.printStackTrace();
58         }finally{
59             System.out.println("Logger的aroundPringLog方法开始记录日志。。。。。。。");
60         }
61         
62     }