Spring2.5教程：6、AOP

AOP可以对方法进行拦截，进行权限的判断。

传统的AOP拦截流程：

用户（调用代理对象）--------》代理对象（实现了目标对象的所有接口）-------》invoke方法---------》目标对象（业务bean）

这样就不需要在目标对象（业务bean）进行权限判断了。

1、拦截所有的业务方法

2、判断用户是否有权限，有权限就允许他执行业务方法，没有权限不允许他执行业务方法。

有两种代理：动态代理和静态代理（很少用）

代理类：Proxy，使用的前提是业务bean必须实现接口，否则不能使用。

JDK动态代理

public class JDKProxyimplementsInvocationHandler {

  privateObjecttargetObject;//代理的目标对象

  publicObjectcreateProxyInstance(ObjecttargetObject){

  this.targetObject =targetObject;

/*

* 第一个参数设置代码使用的类装载器,一般采用跟目标类相同的类装载器

* 第二个参数设置代理类实现的接口

* 第三个参数设置回调对象,当代理对象的方法被调用时,会委派给该参数指定对象的invoke方法

*/

  returnProxy.newProxyInstance(this.targetObject.getClass().getClassLoader(),

  this.targetObject.getClass().getInterfaces(),this);

  }

  publicObject invoke(Object proxy,Methodmethod,Object[]args)

  throws Throwable {

  returnmethod.invoke(this.targetObject,args);//把方法调用委派给目标对象

  }

}

当目标类实现了接口，我们可以使用jdk的Proxy来生成代理对象。

 

使用CGLIB生成代理(当业务bean没有实现接口，可以通过地方框架CGLIB，spring帮我们提供了)

public class CGLIBProxyimplementsMethodInterceptor {

  privateObjecttargetObject;//代理的目标对象 

  publicObjectcreateProxyInstance(ObjecttargetObject){

  this.targetObject =targetObject;

  Enhancer enhancer =new Enhancer();//该类用于生成代理对象

  enhancer.setSuperclass(this.targetObject.getClass());//设置父类

  enhancer.setCallback(this);//设置回调用对象为本身

  returnenhancer.create();

  }

  publicObject intercept(Object proxy,Methodmethod,Object[]args,

  MethodProxymethodProxy) throwsThrowable {

  returnmethodProxy.invoke(this.targetObject,args);

  }

}

CGLIB可以生成目标类的子类，并重写父类非final修饰符的方法。

 

AOP中的概念

Aspect(切面):指横切性关注点的抽象即为切面,它与类相似,只是两者的关注点不一样,类是对物体特征的抽象,而切面横切性关注点的抽象.

joinpoint(连接点):所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法,因为spring只支持方法类型的连接点,实际上joinpoint还可以是field或类构造器)

Pointcut(切入点):所谓切入点是指我们要对那些joinpoint进行拦截的定义.

Advice(通知):所谓通知是指拦截到joinpoint之后所要做的事情就是通知.通知分为前置通知,后置通知,异常通知,最终通知,环绕通知

Target(目标对象):代理的目标对象

Weave(织入):指将aspects应用到target对象并导致proxy对象创建的过程称为织入.

Introduction(引入):在不修改类代码的前提下, Introduction可以在运行期为类动态地添加一些方法或Field.

 

使用Spring进行面向切面（AOP）编程（实际上spring的AOP编程就是使用上面的两种方法，只是进行了封装）

要进行AOP编程，首先我们要在spring的配置文件中引入aop命名空间：

<beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xmlns:aop="http://www.springframework.org/schema/aop"

       xsi:schemaLocation="http://www.springframework.org/schema/beans

           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd

           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">

</beans>

Spring提供了两种切面声明方式，实际工作中我们可以选用其中一种：

l 基于 XML 配置方式声明切面。

l 基于注解方式声明切面。

 
基于注解方式声明切面

首先启动对@AspectJ注解的支持(蓝色部分)：

<beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xmlns:aop="http://www.springframework.org/schema/aop"

       xsi:schemaLocation="http://www.springframework.org/schema/beans

           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd

           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">

   <aop:aspectj-autoproxy/>

  <bean id="orderservice" class="cn.itcast.service.OrderServiceBean"/>

  <bean id="log" class="cn.itcast.service.LogPrint"/>

</beans>

 

创建一个类

@Aspect

public class LogPrint {

  @Pointcut("execution(* cn.itcast.service..*.*(..))")

  private void anyMethod() {}//声明一个切入点 

  @Before("anyMethod() && args(userName)")//定义前置通知

  public void doAccessCheck(String userName) {} 

  @AfterReturning(pointcut="anyMethod()",returning="revalue")//定义后置通知

  public void doReturnCheck(String revalue) {}

  @AfterThrowing(pointcut="anyMethod()", throwing="ex")//定义例外通知

    public void doExceptionAction(Exception ex) {}

  @After("anyMethod()")//定义最终通知

  public void doReleaseAction() {}

  @Around("anyMethod()")//环绕通知(ProceedingJoinPoing是固定的，方法签名不能变)

  public Object doBasicProfiling(ProceedingJoinPointpjp) throws Throwable {

  return pjp.proceed();

  }

    @Before("allMethod() && args(name)") //得到拦截方法的参数

     public void checkPerson(String name) {

  System.out.println("前置方法!" + name);

  }

    @AfterReturning(pointcut="allMethod()", returning="result") //得到拦截方法的返回值

  public void aferRuning(String result) {

  System.out.println("后置方法" + result);

  }

 

  @AfterThrowing(pointcut="allMethod()", throwing="e")//得到拦截方法抛出的异常

  public void exceptionMethod(Exception e) {

  System.out.println("异常方法" + e);

  }

}

举例说明：

环绕通知。。。。（比如struts2提供的拦截器就是）

if（）{

前置通知。。。

       try{

           后置通知。。。

       }catch(){

           例外通知。。。

       }finally{

           最终通知。。。

        }

}

 

基于基于XML配置方式声明切面

public class LogPrint {

  public void doAccessCheck() {}定义前置通知

  public void doReturnCheck() {}定义后置通知

      public void doExceptionAction() {}定义例外通知

  public void doReleaseAction() {}定义最终通知

  public Object doBasicProfiling(ProceedingJoinPointpjp) throws Throwable {

  return pjp.proceed();环绕通知

  }

}

 

<bean id="orderservice" class="cn.itcast.service.OrderServiceBean"/>

<bean id="log" class="cn.itcast.service.LogPrint"/>//切面类

<aop:config>

  <aop:aspect id="myaop" ref="log">

    <aop:pointcut id="mycut" expression="execution(* cn.itcast.service..*.*(..))"/>

    <aop:beforepointcut-ref="mycut" method="doAccessCheck"/>

    <aop:after-returningpointcut-ref="mycut" method="doReturnCheck "/>

    <aop:after-throwingpointcut-ref="mycut" method="doExceptionAction"/>

    <aop:afterpointcut-ref="mycut" method=“doReleaseAction"/>

    <aop:aroundpointcut-ref="mycut" method="doBasicProfiling"/>

  </aop:aspect>

</aop:config>