Spring AOP

AOP是Aspect Oriented Programming的缩写，意思是面向方面编程，一种新兴的编程技术。
AOP实际是GoF设计模式的延续,设计模式孜孜不倦追求的是调用者和被调用者之间的解耦,
AOP可以说也是这种目标的一种实现。它可以解决OOP和过程化方法不能够很好解决的横切
（crosscut）问题,
如：事务、安全、日志等横切关注。当未来系统变得越来越复杂,
横切关注点就成为一个大问题的时候,AOP就可以很轻松的解决横切关注点这个问题。

比如有这样一个情景:

public class AccountManager {
    private static final sysLogger = SystemLogger.getInstance();
    private AuthorizationManager authMgr = new AuthorizationManager();

    public void transferFunds(String from, String to, int amount) {
        sysLogger.log("transfer funds from " + from + " to " + to);
        if(authMgr.accessAble(from) && authMgr.accessAble(to)) {
            sysLogger.log("access successfully");
            CustomerAccount from = findAccount(from);
            CustomerAccount to = findAccount(to);
            from.debit(amount);
            to.credit(amount);
        } else {
            sysLogger.log("access deny");
        }
        sysLogger.log("transfer funds from " + from + " to " + to + " $" + amount + " successfully!");
    }
}

 public class AccountManager {  
     private static final sysLogger = SystemLogger.getInstance();  
     private AuthorizationManager authMgr = new AuthorizationManager();  
       
     public void transferFunds(String from, String to, int amount) {  
         sysLogger.log("transfer funds from " + from + " to " + to);  
         if(authMgr.accessAble(from) && authMgr.accessAble(to)) {  
             sysLogger.log("access successfully");  
             CustomerAccount from = findAccount(from);  
             CustomerAccount to = findAccount(to);  
             from.debit(amount);  
             to.credit(amount);  
         } else {  
             sysLogger.log("access deny");  
         }  
         sysLogger.log("transfer funds from " + from + " to " + to + " $" + amount + " successfully!");  
     }  
 }

 这个例子虽然是很好的面向对象代码,但是在业务处理逻辑中夹杂这日志处理和权限判断,变得复杂混乱.
在 AOP 中，正交关注点（如安全和日志记录）被识别为系统中的常见横切关注点。说它们是横切,
是因为它们总是切入模块（如包、类和代码文件）的多个单位。也许横切关注点可能不是核心业务逻辑的一部分,但是它们是应用程序的基本部分。

AOP的实现主要是通过方法的拦截实现.在不使用AOP框架的情况下,我们可以通过JDK提供的动态代理来实现方法的拦截

注意:使用JDK提供的动态代理实现
要求我们的目标对象必须实现接口

IUserBean接口

package com.royzhou.aop;

public interface IUserBean {

    public void getUser();

    public void addUser();

    public void updateUser();

    public void deleteUser();
}

 package com.royzhou.aop;  
   
 public interface IUserBean {  
       
     public void getUser();  
       
     public void addUser();  
       
     public void updateUser();  
       
     public void deleteUser();  
 }

 IUserBean实现类 UserBean.java

package com.royzhou.aop;

public class UserBean implements IUserBean {

    private String user = null;

    public UserBean() {
    }

    public UserBean(String user) {
        this.user = user;
    }

    public void setUser(String user) {
        this.user = user;
    }

    public void addUser() {
        System.out.println("this is addUser() method!");
    }

    public void deleteUser() {
        System.out.println("this is deleteUser() method!");
    }

    public void getUser() {
        System.out.println("this is getUser() method!");
    }

    public void updateUser() {
        System.out.println("this is updateUser() method!");
    }
}

 package com.royzhou.aop;  
   
 public class UserBean implements IUserBean {  
       
     private String user = null;  
       
     public UserBean() {  
     }  
   
     public UserBean(String user) {  
         this.user = user;  
     }  
       
     public void setUser(String user) {  
         this.user = user;  
     }  
   
     public void addUser() {  
         System.out.println("this is addUser() method!");  
     }  
   
     public void deleteUser() {  
         System.out.println("this is deleteUser() method!");  
     }  
   
     public void getUser() {  
         System.out.println("this is getUser() method!");  
     }  
   
     public void updateUser() {  
         System.out.println("this is updateUser() method!");  
     }  
 }

 我们希望在UserBean执行方法之前先检查userName是不是为空,以此做为权限判断.
当然我们可以在没个方法里面去加这些判断,但是这需要为每个方法都添加同样的判断,维护不便.
使用JDK提供的动态代理技术可以很方便的实现上面的需求:
通过java.lang.reflect.Proxy;提供的
public static Object newProxyInstance(ClassLoader loader,
  Class<?>[] interfaces,
  InvocationHandler h)
方法可以生成一个动态代理对象
其中
loader是类装载器
interfaces是目标对象实现的一系列接口
h是一个实现InvocationHandler接口的类,我们对代理对象的所有操作都经过它处理
这样我们就可以拦截到UserBean的方法,在方法执行前先判断是否有权限,如果有则执行方法,
没有权限的话就不执行方法.

编写我们的代理类:
JDKProxy.java

package com.royzhou.aop;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class JDKProxy implements InvocationHandler {

    private Object targetObject;

    public Object createProxyObject(Object targetObject) {
        this.targetObject = targetObject;
        //生成代理对象
        return Proxy.newProxyInstance(this.targetObject.getClass().getClassLoader(),this.targetObject.getClass().getInterfaces(),this);
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        UserBean userBean = (UserBean) targetObject;
        String userName = userBean.getUserName();
        Object result = null;
        //权限判断
        if(userName!=null && !"".equals(userName)) {
            //调用目标对象的方法
            result = method.invoke(targetObject, args);
        }
        return result;
    }
}

 package com.royzhou.aop;  
   
 import java.lang.reflect.InvocationHandler;  
 import java.lang.reflect.Method;  
 import java.lang.reflect.Proxy;  
   
 public class JDKProxy implements InvocationHandler {  
       
     private Object targetObject;  
       
     public Object createProxyObject(Object targetObject) {  
         this.targetObject = targetObject;  
         //生成代理对象  
         return Proxy.newProxyInstance(this.targetObject.getClass().getClassLoader(),this.targetObject.getClass().getInterfaces(),this);  
     }  
   
     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  
         UserBean userBean = (UserBean) targetObject;  
         String userName = userBean.getUserName();  
         Object result = null;  
         //权限判断  
         if(userName!=null && !"".equals(userName)) {  
             //调用目标对象的方法  
             result = method.invoke(targetObject, args);  
         }   
         return result;  
     }  
 }

 通过调用createProxyObject可以生成代理对象,
编写测试类如下:

package com.royzhou.aop;

public class TestProxy {

    public static void main(String[] args) {
        JDKProxy jProxy = new JDKProxy();
        IUserBean userBean = (IUserBean) jProxy.createProxyObject(new UserBean("royzhou"));
        userBean.addUser();
    }
}

 package com.royzhou.aop;  
   
 public class TestProxy {  
       
     public static void main(String[] args) {  
         JDKProxy jProxy = new JDKProxy();  
         IUserBean userBean = (IUserBean) jProxy.createProxyObject(new UserBean("royzhou"));  
         userBean.addUser();  
     }  
 }

 执行成功后输出:
this is addUser() method!

再次修改测试类:

package com.royzhou.aop;

public class TestProxy {

    public static void main(String[] args) {
        JDKProxy jProxy = new JDKProxy();
        IUserBean userBean = (IUserBean) jProxy.createProxyObject(new UserBean());
        userBean.addUser();
    }
}

 package com.royzhou.aop;  
   
 public class TestProxy {  
       
     public static void main(String[] args) {  
         JDKProxy jProxy = new JDKProxy();  
         IUserBean userBean = (IUserBean) jProxy.createProxyObject(new UserBean());  
         userBean.addUser();  
     }  
 }

 即当用户没有权限时,控制台不输出东西,说明我们拦截方法对其做的权限判断生效了.

从上面这个例子可以成功拦截了调用的方法并对其做了相应的处理

如果不使用JDK提供的Proxy类
通过cglib创建代理类,好处是不要求我们的目标对象实现接口
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(this.targetObject.getClass());
enhancer.setCallback(this); //回调,参数是一个实现MethodInterceptor接口的类,我们对代理对象的所有操作都经过它处理
return enhancer.create(); //创建代理对象


修改UserBean 去掉IUserBean接口

package com.royzhou.aop;

public class UserBean {

    private String userName = null;

    public UserBean() {
    }

    public UserBean(String userName) {
        this.userName = userName;
    }

    public void addUser() {
        System.out.println("this is addUser() method!");
    }

    public void deleteUser() {
        System.out.println("this is deleteUser() method!");
    }

    public void getUser() {
        System.out.println("this is getUser() method!");
    }

    public void updateUser() {
        System.out.println("this is updateUser() method!");
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }
}

 package com.royzhou.aop;  
   
 public class UserBean {  
       
     private String userName = null;  
       
     public UserBean() {  
     }  
   
     public UserBean(String userName) {  
         this.userName = userName;  
     }  
   
     public void addUser() {  
         System.out.println("this is addUser() method!");  
     }  
   
     public void deleteUser() {  
         System.out.println("this is deleteUser() method!");  
     }  
   
     public void getUser() {  
         System.out.println("this is getUser() method!");  
     }  
   
     public void updateUser() {  
         System.out.println("this is updateUser() method!");  
     }  
   
     public String getUserName() {  
         return userName;  
     }  
   
     public void setUserName(String userName) {  
         this.userName = userName;  
     }  
 }

 通过cglib创建代理类

CGLibProxy.java

package com.royzhou.aop;

import java.lang.reflect.Method;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

public class CGLibProxy implements MethodInterceptor {

    private Object targetObject;

    public Object createProxyObject(Object targetObject) {
        this.targetObject = targetObject;
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(this.targetObject.getClass()); //非final 进行覆盖
        enhancer.setCallback(this); //回调,通过
        return enhancer.create(); //创建代理对象
    }

    public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        UserBean userBean = (UserBean) targetObject;
        String userName = userBean.getUserName();
        Object result = null;
        if(userName!=null && !"".equals(userName)) {
            //调用目标对象的方法
            result = methodProxy.invoke(targetObject, args);
        }
        return result;
    }
}

 package com.royzhou.aop;  
   
 import java.lang.reflect.Method;  
   
 import net.sf.cglib.proxy.Enhancer;  
 import net.sf.cglib.proxy.MethodInterceptor;  
 import net.sf.cglib.proxy.MethodProxy;  
   
 public class CGLibProxy implements MethodInterceptor {  
        
     private Object targetObject;  
       
     public Object createProxyObject(Object targetObject) {  
         this.targetObject = targetObject;  
         Enhancer enhancer = new Enhancer();  
         enhancer.setSuperclass(this.targetObject.getClass()); //非final 进行覆盖  
         enhancer.setCallback(this); //回调,通过  
         return enhancer.create(); //创建代理对象  
     }  
   
     public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {  
         UserBean userBean = (UserBean) targetObject;  
         String userName = userBean.getUserName();  
         Object result = null;  
         if(userName!=null && !"".equals(userName)) {  
             //调用目标对象的方法  
             result = methodProxy.invoke(targetObject, args);  
         }   
         return result;  
     }  
 }

 编写测试类:

package com.royzhou.aop;

public class TestProxy {

    public static void main(String[] args) {
        CGLibProxy cProxy = new CGLibProxy();
        UserBean userBean = (UserBean) cProxy.createProxyObject(new UserBean("royzhou"));
        userBean.addUser();
    }
}

 package com.royzhou.aop;  
   
 public class TestProxy {  
       
     public static void main(String[] args) {  
         CGLibProxy cProxy = new CGLibProxy();  
         UserBean userBean = (UserBean) cProxy.createProxyObject(new UserBean("royzhou"));  
         userBean.addUser();  
     }  
 }

 输出:
this is addUser() method!

当取消用户权限时,控制台不输出任何东西.

说明通过CGLib成功生成代理对象,拦截了目标对象的方法.


Spring主要通过代理来实现AOP

下面是AOP的一些基本概念:

切面(Aspect): 对横切关注点的抽象(类似类对对象的抽象)

连接点(JoinPoint): 被拦截到的点,泛指方法

切入点(CutPoint): 对哪些连接点进行拦截的定义

通知(Advice): 在特定的连接点，AOP框架执行的动作.前置/后置/例外/最终/环绕通知(调用方法之前执行,全部执行完毕之后)

引入（Introduction）: 添加方法或字段到被通知的类。 Spring允许引入新的接口到任何被通知的对象。例如，你可以使用一个引入使任何对象实现 IsModified接口，来简化缓存。

目标对象（Target Object）: 包含连接点的对象。也被称作 被通知或被代理对象。

AOP代理（AOP Proxy）: AOP框架创建的对象，包含通知。 在Spring中，AOP代理可以是JDK动态代理或者CGLIB代理。

织入（Weaving）: 组装方面来创建一个被通知对象。这可以在编译时 完成（例如使用AspectJ编译器），也可以在运行时完成。Spring和其他纯Java AOP框架一样， 在运行时完成织入。

Adive通知可理解如下:

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        UserBean userBean = (UserBean) targetObject;
        String userName = userBean.getUserName();
        Object result = null;
        if(userName!=null && !"".equals(userName)) {
            //调用目标对象的方法
            try {
                //前置通知
                result = method.invoke(targetObject, args);
                //后置通知
            } catch(Exception e) {
                //例外通知
            } finally {
                //最终通知
            }
        }
        //环绕通知(前置通知之后,目标对象方法调用之前执行,全部执行完毕(最终通知)之后)
        return result;
    }

 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  
         UserBean userBean = (UserBean) targetObject;  
         String userName = userBean.getUserName();  
         Object result = null;  
         if(userName!=null && !"".equals(userName)) {  
             //调用目标对象的方法  
             try {  
                 //前置通知  
                 result = method.invoke(targetObject, args);  
                 //后置通知  
             } catch(Exception e) {  
                 //例外通知  
             } finally {  
                 //最终通知  
             }  
         }   
         //环绕通知(前置通知之后,目标对象方法调用之前执行,全部执行完毕(最终通知)之后)  
         return result;  
     }

 Spring提供两种方式实现AOP
一种是XML配置的方式
一种是annotation注解的方式

不管采用哪种方式,都必须在spring的配置文件中配置AOP支持:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       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/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
        <aop:aspectj-autoproxy/>
</beans>

 <?xml version="1.0" encoding="UTF-8"?>  
 <beans xmlns="http://www.springframework.org/schema/beans"  
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
        xmlns:context="http://www.springframework.org/schema/context"   
        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/context http://www.springframework.org/schema/context/spring-context-2.5.xsd  
            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">  
         <aop:aspectj-autoproxy/>   
 </beans>

 其中<aop:aspectj-autoproxy/> 表示打开aspect注解处理器
(aspect的内容具体可查看http://www.ibm.com/developerworks/cn/java/j-aspectj/ )

使用注解方式实现AOP必须引入三个jar包:
aspectjweaver.jar
aspectjrt.jar
cglib.jar

首先建立好测试用的业务bean
然后我们需要定义一个切面/定义切入点/通知等

接口IUserBean.java

package com.royzhou.aop;

public interface IUserBean {

    public void getUser();

    public void addUser();

    public void updateUser();

    public void deleteUser();
}

 package com.royzhou.aop;  
   
 public interface IUserBean {  
       
     public void getUser();  
       
     public void addUser();  
       
     public void updateUser();  
       
     public void deleteUser();  
 }

 实现类UserBean.java

package com.royzhou.aop;

public class UserBean {

    public void addUser(String userName) {
        System.out.println("this is addUser() method!");
    }

    public void deleteUser(int userId) {
        System.out.println("this is deleteUser() method!");
    }

    public String getUser(String userId) {
        System.out.println("this is getUser() method!");
        return "haha";
    }

    public void updateUser(int userId, String userName) {
        System.out.println("this is updateUser() method!");
    }
}

 package com.royzhou.aop;  
   
 public class UserBean {  
       
     public void addUser(String userName) {  
         System.out.println("this is addUser() method!");  
     }  
   
     public void deleteUser(int userId) {  
         System.out.println("this is deleteUser() method!");  
     }  
   
     public String getUser(String userId) {  
         System.out.println("this is getUser() method!");  
         return "haha";  
     }  
   
     public void updateUser(int userId, String userName) {  
         System.out.println("this is updateUser() method!");  
     }  
 }

 紧接着我们建立我们的切面类:使用@Aspect注解
MyInterceptor.java

package com.royzhou.aop;

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;

@Aspect
public class MyInterceptor {
    /**
     * 定义切入点
     * 第一个*表示方法的返回值,这里使用通配符,只有返回值符合条件的才拦截,(!void表示有返回值)
     * 第一个..表示com.royzhou.aop包及其子包
     * 倒数第二个*表示包下的所有Java类都被拦截
     * 最后一个*表示类的所有方法都被拦截
     * (..)表示方法的参数可以任意多个如[(java.lang.String,java.lang.Integer)表示第一个参数是String,第二个参数是int的方法才会被拦截]
     */
    @Pointcut("execution(* com.royzhou.aop..*.*(..))") //定义一个切入点,名称为pointCutMethod(),拦截类的所有方法
    private void pointCutMethod() {
    }

    @Before("pointCutMethod()") //定义前置通知
    public void doBefore() {
        System.out.println("前置通知");
    }

    @AfterReturning("pointCutMethod()") //定义后置通知
    public void doAfterReturning() {
        System.out.println("后置通知");
    }

    @AfterThrowing("pointCutMethod()") //定义例外通知
    public void doAfterException() {
        System.out.println("异常通知");
    }

    @After("pointCutMethod()") //定义最终通知
    public void doAfter() {
        System.out.println("最终通知");
    }

    @Around("pointCutMethod()") //定义环绕通知
    public Object doAround(ProceedingJoinPoint pjp) keyword

  


  
    
    分享到：
      
      
    
  

  
    
      设计模式笔记
      |
      Spring AOP配置选项 
    
  
  
    
      2011-03-11 10:32
      浏览 861
      评论(0)
      
      
      分类:企业架构      
      查看更多