浅析AOP

对AOP的简单理解

AOP就是面向切面编程，这种方式让我们有更多精力放在核心业务逻辑上，下面这个图可以方便我们理解

APO1.png

左图的 验证用户功能就是每个操作中的 横切点，整个系统中所有该功能的点连起来就成为了一个 横切面，我们可以将这个功能做成一个 切面类，当其他地方要使用的时候，直接将其置入里面就好了
这篇博客址讲述AOP的实现方式，并不直接讲述SpringAOP的使用方式，当然SpringAOP的实现也用到了后面的动态生成代理类原理，如果只想看SpringAOP的简单使用请看这篇 SpringAOPdemo

实现AOP的两种方式（静态、动态代理）

静态代理

我们首先看一下代理模式的结构类图。Proxy就是我们的代理类，持有一个被代理对象的引用，和被代理对象共同实现了我们定义的业务接口，静态代理就是通过代理模式来实现的

代理模式.png

只简单的说一下实现

public interface IBankOperation（){  //银行业务操作接口
    public void drawMoney (int account); //取款
    public int transferMoney(int account); //转账
}


public class BankOperationImp implement IBankOperation(){//具体实现
   public void drawMoney(int account){    
        ...                        //实现查找核心的业务逻辑
        xxxDao.drawmoney(account);    //从持久层查找数据
        ...
   }
  public int transferMoney(int account){
        ...                       //实现转帐的核心业务逻辑
        xxxDao.transferMoney(account);   //持久层数据改变
  }
}

下面我们需要在IBankOperation接口的所有方法操作前进行验证操作，变使用代理对象来完成验证功能，并持有一个操作实现类的引用，调用实现类的方法来代替执行
public class BankOperationProxy implement IBankOperation(){ //银行操作代理类
   BankOperationImp operation;      //持有一个被代理对象的引用
   public void validate(){    //验证方法
   }
   public void drawMoney(int account){    
       validate();
       operation.drawMoney(account);
   }
   public int transferMoney(int account){
      validate();
      operation.drawMoney(account);
  }
}

静态代理存在明显的弊端：

1. 一个代理类只能为一个类服务，不同的类需要各自的代理类
2. 被代理类进行了功能的扩展，比如实现了另外一个接口，我们的代理类也需要实现对应的接口，并作实现

动态代理（JDKProxy&&CGLibProxy）

package cn.cherish.service;

public interface PersonService {         //业务类接口
    public void save(String name);
    public void update(String name, Integer personid);
    public String getPersonName(Integer personid);
}

package cn.cherish.service.impl;

import cn.cherish.service.PersonService;

public class PersonServiceBean implements PersonService{ //业务实现类
    private String user = null;
    
    public String getUser() {
        return user;
    }

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

    public String getPersonName(Integer personid) {
        System.out.println("调用了etPersonName()方法");
        return "xxx";
    }

    public void save(String name) {
        System.out.println("调用了save()方法");
    }

    public void update(String name, Integer personid) {
        System.out.println("调用了update()方法");
    }

}

JDKProxy

package cn.cherish.aop;

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

import cn.cherish.service.impl.PersonServiceBean;

public class JDKProxyFactory implements InvocationHandler{
    private Object targetObject;
    
    public Object createProxyIntance(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 {          //环绕通知
        PersonServiceBean bean = (PersonServiceBean) this.targetObject;
        Object result = null; 
        if(bean.getUser()!=null){
            //..... advice()-->前置通知
            try {
                result = method.invoke(targetObject, args);
                // afteradvice() -->后置通知
            } catch (RuntimeException e) {
                //exceptionadvice()--> 异常通知
            }finally{
                //finallyadvice(); -->最终通知
            }
        }
        return result;
    }
}

简单的分析一下上面这段代码：

1. 首先我们必须明确，要通过JDKProxy方式动态获取到代理对象，必须实现InvocationHandler接口，再通过反射包下的Proxy类动态获取代理对象
2. invoke()方法的三个参数，分别是代理对象，被代理对象被调用的方法，和被调用方法的参数集合
3. Proxy.newProxyInstance(this.targetObject.getClass().getClassLoader(),this.targetObject.getClass().getInterfaces(), this);这就是我们通过目标对象生成代理对象的代码，三个类分别是被代理对象的类加载器，实现的接口，以及之后代理对象需要调用的方法，this表示被代理对象方法被调用时，调用当前类的invoke()方法
4. 在invoke()方法中判断用户不为空之后，method.invoke(targetObject,args)表示调用targetObject的save()方法这里的method是通过反射获取到的当前被代理对象被调用的方法
5. 最后注意，虽然method.invoke(targetObject,args)返回值为空，但是我们还是需要返回一下的

测试结果：

package junit.test;
import org.junit.BeforeClass;
import org.junit.Test;
import cn.cherish.aop.CGlibProxyFactory;
import cn.cherish.aop.JDKProxyFactory;
import cn.cherish.service.PersonService;
import cn.cherish.service.impl.PersonServiceBean;

public class AOPTest {

    @BeforeClass
    public static void setUpBeforeClass() throws Exception {
    }

    @Test public void proxyTest(){
        JDKProxyFactory factory = new JDKProxyFactory();
        PersonService service = (PersonService) factory.createProxyIntance(new PersonServiceBean("xxx"));
        service.save("888");
    }
}
结果：当我们给定参数xxx的时候，才会输出“调用了save()方法”，因为我们在代理对象中加入了user字段非空判断

CGLibProxy

JDK的动态代理机制只能代理实现了接口的类，而不能实现接口的类就不能实现JDK的动态代理，cglib是针对类来实现代理的，他的原理是对指定的目标类生成一个子类，并覆盖其中方法实现增强，但因为采用的是继承，所以不能对final修饰的类进行代理。

package cn.cherish.aop;
import java.lang.reflect.Method;
import cn.cherish.service.impl.PersonServiceBean;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

public class CGlibProxyFactory implements MethodInterceptor{
    private Object targetObject;
    
    public Object createProxyIntance(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 {
        PersonServiceBean bean = (PersonServiceBean) this.targetObject;
        Object result = null;
        if(bean.getUser()!=null){
            result = methodProxy.invoke(targetObject, args);
        }
        return result;
    }
}