spring_03AOP编程

AOP 编程

AOP( Aspect Oricented Programming ) 面向切面编程

是对所有对象或者是一类对象进行编程 

核心是（不  还）

    在不增加代码的基础上，还增加新的功能

spring AOP实现原理

• 动态代理&CGLib代理

  spring能够为容器中管理的对象生成动态代理对象
  
  以前我们要使用动态代理，我们需要自己调用下面这个方法：
  
      Proxy.newProxyInstance(xx,xx,xx)
  
  生成代理对象
  
  
  spring能帮我们生成代理对象

• 动态代理和CGLib代理的区别：

  动态代理：被代理的对象必须实现接口，才能产生代理对象，
  
      如果没有接口将不能使用动态代理技术
  
  cglib代理：第三方代理技术，cglib代理，可以对任何类生成代理，代理的原理是
  
      对目标对象进行继承代理。如果目标对象被final修饰，那么该类无法被
  
      cglib代理

• 具体的顺序：有接口的话，优先使用 动态代理，没有的话使用cglib代理

AOP的一些术语：

1. Joinpoint（连接点）：

   目标对象中，所有可以增强的方法

2. Pointcut（切入点）：

   目标对象，已经增强的方法

3. Afvice（通知/增强）：

   增强的代码

4. Target（目标对象）：

   被代理的对象

5. Weaving（织入）：

   动词，将通知织入连接点形成切入点

6. Proxy（代理）：

   将通知织入目标对象后，形成代理对象

7. aspect（切面）：

   切入点+通知

使用spring中的AOP：

1. 导包

   （4+2+2+2）4个核心+2个日志
   
   +（2）spring的aop包：
   
       spring-aop.jar 与 spring-aspects.jar
   
   +（2）spring需要第三方aop包：
   
       com.springsource.org.aopalliance-1.0.0.jar
   
       com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar

2. 准备目标对象

   package org.spring.service;
   
   public class UserService {
   
       public void save(){
           System.out.println("保存用户");
       }
       public void delete(){
           System.out.println("删除用户");
       }
       public void find(){
           System.out.println("查询用户");
       }
       public void update(){
           System.out.println("更新用户");
       }
   }

3. 定义通知：

   前置通知
   
       目标方法运行之前调用
   
   后置通知（如果出现异常不会调用）
   
       在目标方法运行之后调用
   
   
   环绕通知
   
       在目标方法之前和之后都调用
   
   异常拦截通知
   
       如果出现异常，就会调用
   
   后置通知（无论是否出现异常都会调用）
   
       在目标运行之后调用
   
   
   
   特殊：环绕通知需要手动调用目标方法
   
   
   package org.spring.advice;
   
   import org.aspectj.lang.ProceedingJoinPoint;
   
   public class MyAdvice {
       //前置通知
       public void before(){
           System.out.println("前置通知");
       }
       //后置通知
       public void afterRunning(){
           System.out.println("后置通知（如果出现异常不会调用）");
       }
       //环绕通知
       public Object around(ProceedingJoinPoint  pjp) throws Throwable{
           System.out.println("环绕通知-前");
           Object procced = pjp.proceed();
           System.out.println("环绕通知-后");
           return procced;
       }
       //异常通知
       public void afterException(){
           System.out.println("异常通知");
       }
       //后置通知
       public void after(){
           System.out.println("后置通知（出现异常也会调用）");
       }
   }

4. 配置进行织入，将通知织入目标对象中

   <!-- 准备工作：导入aop（约束）命名空间 -->
   <!-- 1.配置目标对象 -->
       <bean name="userService" class="org.spring.service.UserService"></bean>
   <!-- 2.配置通知对象 -->
       <bean name="myAdvice" class="org.spring.advice.MyAdvice"></bean>
   <!-- 3.配置将通知织入目标对象 -->
       <aop:config>
           <!-- 配置切入点
               public void org.spring.service.UserService.save()
               void org.spring.service.UserService.save()
               * org.spring.service.UserService.save()
               * org.spring.service.UserService.*()
               * org.spring.service.UserService.*(..)
               * org.spring.service.*Service.*(..)
               * org.spring.service..*Service.*(..)
            -->
           <aop:pointcut expression="execution(* org.spring.service.*Service.*(..))" id="pc"/>
           <!-- 通知对象 -->
           <aop:aspect ref="myAdvice">
               <!-- 指定通知类型与通知方法名以及切入点 -->
               <aop:before method="before" pointcut-ref="pc"/>
               <aop:after-returning method="afterRunning" pointcut-ref="pc"/>
               <aop:around method="around" pointcut-ref="pc"/>
               <aop:after-throwing method="afterException" pointcut-ref="pc"/>
               <aop:after method="after" pointcut-ref="pc"/>
           </aop:aspect>
       </aop:config>