对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);
}
}
静态代理存在明显的弊端：
- 一个代理类只能为一个类服务，不同的类需要各自的代理类
- 被代理类进行了功能的扩展，比如实现了另外一个接口，我们的代理类也需要实现对应的接口，并作实现
动态代理（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;
}
}
简单的分析一下上面这段代码：
- 首先我们必须明确，要通过JDKProxy方式动态获取到代理对象，必须实现InvocationHandler接口，再通过反射包下的Proxy类动态获取代理对象
-
invoke()方法的三个参数，分别是代理对象，被代理对象被调用的方法，和被调用方法的参数集合 -
Proxy.newProxyInstance(this.targetObject.getClass().getClassLoader(),this.targetObject.getClass().getInterfaces(), this);这就是我们通过目标对象生成代理对象的代码，三个类分别是被代理对象的类加载器，实现的接口，以及之后代理对象需要调用的方法，this表示被代理对象方法被调用时，调用当前类的invoke()方法 - 在
invoke()方法中判断用户不为空之后，method.invoke(targetObject,args)表示调用targetObject的save()方法这里的method是通过反射获取到的当前被代理对象被调用的方法 - 最后注意，虽然
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;
}
}
