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:config
   
   <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>

springAOP的注解配置

1. applicationContext.xml中的配置

   <context:component-scan base-package="org.spring"></context:component-scan>
   
   aop:aspectj-autoproxy</aop:aspectj-autoproxy>

2. 通知中的注解：

   package org.spring.advice;

   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.stereotype.Component;
   @Component("myAdvice")
   //表示该类是一个通知类
   @Aspect
   public class MyAdvice {
   //表示切入点的方法
   @Pointcut("execution(* org.spring.service.Service.(..))")
   public void pc(){}

   //前置通知
   @Before("MyAdvice.pc()")
   public void before(){
   System.out.println("前置通知");
   }
   //后置通知
   @AfterReturning("MyAdvice.pc()")
   public void afterRunning(){
   System.out.println("后置通知（如果出现异常不会调用）");
   }
   //环绕通知
   @Around("MyAdvice.pc()")
   public Object around(ProceedingJoinPoint pjp) throws Throwable{
   System.out.println("环绕通知-前");
   Object procced = pjp.proceed();
   System.out.println("环绕通知-后");
   return procced;
   }
   //异常通知
   @AfterThrowing("MyAdvice.pc()")
   public void afterException(){
   System.out.println("异常通知");
   }
   //后置通知
   @After("MyAdvice.pc()")
   public void after(){
   System.out.println("后置通知（出现异常也会调用）");
   }
   }