代理和AOP一.起源

有时,我们在写一些功能方法的时候,需要加上特定的功能.比如说在方法调用的前后加上日志的操作,或者是事务的开启与关闭.对于一个方法来说,很简单,只要在需要的地方增加一些代码就OK.但是如果有很多方法都需要增加这种特定的操作呢?

没错,将这些特定的代码抽象出来,并且提供一个接口供调用者使用:

Java代码 复制代码 收藏代码

public class RecordLog   {       public static void recordLog()       {           //  记录日志的操作           System.out.println("记录日志...");       }   }

那么在其他的方法中,就可以使用RecordLog.recordLog()方法了.但你会发现,这仍不是个好的设计,因为在我们的代码里到处充塞着

RecordLog.recordLog()这样的语句: Java代码 复制代码 收藏代码public class A {

public void a()   {       //  1.记录日志       RecordLog.recordLog();       //  2.类A的方法a的操作   }

}

public class B {

public void b()   {       //  1.记录日志       RecordLog.recordLog();       //  2.类B的方法b的操作   }

}

......

这样虽然会在一定程度减轻代码量,但你会发现,仍有大量的地方有重复的代码出现!这绝对不是优雅的写法!

为了避免这种吃力不讨好的现象发生,“代理”粉墨登场了.

二.传统的代理.静态的代理.面向接口编程

同样为了实现以上的功能,我们在设计的时候做了个小小的改动.

2.1 抽象出来的记录日志的类:

Java代码 复制代码 收藏代码public class RecordLog {

public static void recordLog()   {       //  记录日志的操作       System.out.println("记录日志...");   }

}

2.2 设计了一个接口:

Java代码 复制代码 收藏代码public interface PeopleInfo {

public void getInfo();

}

该接口只提供了待实现的方法.

2.3 实现该接口的类:

Java代码 复制代码 收藏代码public class PeopleInfoImpl implements PeopleInfo {

private String name;   private int age;   //  构造函数   public PeopleInfoImpl(String name, int age)   {       this.name = name;       this.age  = age;   }   public void getInfo()   {       //  方法的具体实现       System.out.println("我是" + name + ",今年" + age + "岁了.");   }

}

这个类仅仅是实现了PeopleInfo接口而已.平平实实.好了.关键的地方来了.就在下面!

2.4 创建一个代理类:

Java代码 复制代码 收藏代码public class PeopleInfoProxy implements PeopleInfo {

//  接口的引用   private PeopleInfo peopleInfo;   //  构造函数    .针对接口编程,而非针对具体类   public RecordLogProxy(PeopleInfo peopleInfo)   {       this.peopleInfo = peopleInfo;   }   //  实现接口中的方法   public void record()   {       //  1.记录日志       RecordLog.recordLog();       //  2.方法的具体实现       peopleInfo.getInfo();   }

}

这个是类是一个代理类,它同样实现了PeopleInfo接口.比较特殊的地方在于这个类中有一个接口的引用private PeopleInfo peopleInfo;通过

这个引用,可以调用实现了该接口的类的实例的方法! 而不管是谁,只要实现了PeopleInfo这个接口,都可以被这个引用所引用.也就是说,这个代理类可以代理任何实现了接口的PeopleInfo的类.具体 如何实现,请看下面:

2.5 Main

Java代码 复制代码 收藏代码public class Main {

public static void main(String[] args)   {       //  new了一个对象       PeopleInfoImpl peopleInfoImpl = new PeopleInfoImpl("Rock",24);       //  代理该对象       PeopleInfoProxy peopleInfoProxy = new PeopleInfoProxy(PeopleInfoImpl);       //  调用代理类的方法.输入的是目标类(即被代理类的方法的实现)       peopleInfoProxy.getInfo();   }

}

这样,输出的结果将是:

记录日志... 我是Rock,今年24岁了.

由这个例子可见,这么做了之后不但省略了很多代码,而且不必要知道具体是由哪个类来执行方法.只需实现了特定的接口,代理类就可以打点一切

了.这就是面向接口的威力!HOHO...

三.动态代理.Java的动态机制.

面向接口的编程确实让我们省了不少心,只要实现一个特定的接口,就可以处理很多的相关的类了. 不过,这总是要实现一个“特定”的接口,如果有很多很多这样的接口需要被实现...也是件比较麻烦的事情.

好在,JDK1.3起,就有了动态代理机制,主要有以下两个类和一个接口:

Java代码 复制代码 收藏代码java.lang.reflect.Proxy java.lang.reflect.Method java.lang.reflect.InvocationHandler

所谓动态代理,就是JVM在内存中动态的构造代理类.说的真是玄,还是看看代码吧.

3.1 抽象出来的记录日志的类:

Java代码 复制代码 收藏代码public class RecordLog {

public static void recordLog()   {       //  记录日志的操作       System.out.println("记录日志...");   }

}

3.2 设计了一个接口:

Java代码 复制代码 收藏代码public interface PeopleInfo {

public void getInfo();

}

该接口只提供了待实现的方法.

3.3 实现该接口的类:

Java代码 复制代码 收藏代码public class PeopleInfoImpl implements PeopleInfo {

private String name;   private int age;   //  构造函数   public PeopleInfoImpl(String name, int age)   {       this.name = name;       this.age  = age;   }   public void getInfo()   {       //  方法的具体实现       System.out.println("我是" + name + ",今年" + age + "岁了.");   }

}

一直到这里,都和第二节没区别,好嘛,下面就是关键哟.

3.4 创建一个代理类,实现了接口InvocationHandler:

Java代码 复制代码 收藏代码public class PeopleInfoProxy implements InvocationHandler {

//  定义需要被代理的目标对象   private Object target;   //  将目标对象与代理对象绑定   public Object bind(Object targer)   {       this.target = target;       //  调用Proxy的newProxyInstance方法产生代理类实例       return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);   }   //  实现接口InvocationHandler的invoke方法   //  该方法将在目标类的被代理方法被调用之前,自动触发   public Object invoke(Object proxy, Method method, Object[] args) throws Throwable   {       Object result = null;              //  1.目标类的被代理方法被调用之前,可以做的操作       RecordLog.recordLog();       //  2.方法的具体实现       result = method.invoke(target, args);       //  3.还可以在方法调用之后加上的操作       //  自己补充       return result;   }

}

关于Proxy, Method, InvocationHandler的具体说明,请参见JDK_API.

只对代码中关键部分做些解释说明:

3.4.1

Java代码 复制代码 收藏代码Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);

表示生成目标类的代理类,传入的参数有目标类的ClassLoader, 目标类的接口列表, 和实现了接口InvocationHandler的代理类.

这样,bind方法就得到了目标类的代理类.

3.4.2

Java代码 复制代码 收藏代码method.invoke(target, args);

目标类的被代理方法在被代用前,会自动调用InvocationHandler接口的invoke方法.

在该方法中,我们可以对目标类的被代理方法进行加强,比如说在其前后加上事务的开启和关闭等等. 这段代码才是真正调用目标类的被代理方法.

就这样,我们不用实现其他任何的接口,理论上就能代理所有类了.调用的方式如下:

3.5 Main:

Java代码 复制代码 收藏代码public class Main {

public static void main(String[] args)   {       PeopleInfo peopleInfo = null;       PeopleInfoProxy peopleInfoProxy = new PeopleInfoProxy();       //  传入的参数是目标类实例,生成代理类实例,类型为Object       Object obj = peopleInfoProxy.bind(new PeopleInfoImpl("Rock", 24));       if(obj instanceof PeopleInfo)       {           peopleInfo = (PeopleInfo)obj;       }       peopleInfo.getInfo();   }

}

执行结果和上一节一样.

这就是使用Java动态代理机制的基本概述.而下一节,将要把Dynamic Proxy(动态代理)和AOP联系起来.

四.AOP概述.Spring的AOP.

AOP(Aspect Oriented Programming)面向切面编程.是一种比较新颖的设计思想.是对OOP(Object Orientd Programming)面向对象编程的一种有益的补充.

4.1 OOP和AOP

OOP对业务处理过程中的实体及其属性和行为进行了抽象封装,以获得更加清晰高效果的逻辑划分.研究的是一种“静态的”领域. AOP则是针对业务处理过程中的切面进行提取,它所面对的是处理过程中的某个步骤或阶段.研究的是一种“动态的”领域.

举例说,某个网站(5016?)用户User类又可分为好几种,区长,管理员,斑竹和普通水友.我们把这些会员的特性进行提取进行封装,这是OOP.

而某一天,区长开会了,召集斑竹等级以上的会员参与,这样,普通水友就不能访问相关资源.

我们怎么做到让普通水友访问不了资源,而斑竹等级以上会员可以访问呢.

权限控制.对,权限.当水友们进行操作的时候,我们给他的身份进行权限的判断. 请注意,当且仅需水友门执行了操作的时候,我们才需要进行权限判断,也就是说,这是发生在一个业务处理的过程中的一个片面. 我们对这一个片面进行编程,就是AOP!

我这样,你应该能理解吧.

4.2 AOP的基本术语

4.2.1 切面Aspect

业务处理过程中的一个截面.就像权限检查. 通过切面,可以将不同层面的问题隔离开:浏览帖子和权限检查两者互不相干. 这样一来,也就降低了耦合性,我们可以把注意力集中到各自的领域中. 上两节的例子中,getInfo()和recordLog()就是两个领域的方法,应该处于切面的不同端.哎呀,不知不觉间,我们就用了AOP.呵呵...

4.2.2 连接点JoinPoint

程序运行中的某个阶段点.如某个方法的调用,或者异常的抛出等. 在前面,我们总是在getInfo()的前后加了recordLog()等操作,这个调用getInfo()就是连接点.

4.2.3 处理逻辑Advice

在某个连接点采取的逻辑. 这里的逻辑有三种: I. Around 在连接点前后插入预处理和后处理过程. II. Before 在连接点前插入预处理过程. III.Throw 在连接点抛出异常的时候进行异常处理.

4.2.4 切点PointCut

一系列连接点的集合,它指明处理逻辑Advice将在何在被触发.

4.3 Spring中的AOP

Spring提供内置AOP支持.是基于动态AOP机制的实现. 所谓动态AOP,其实就是动态Proxy模式,在目标对象的方法前后插入相应的代码.(比如说在getInfo()前后插入的recordLog()) Spring AOP中的动态Proxy模式,是基于Java Dynamic Proxy(面向Interface)和CGLib(面向Class)的实现.

为什么要分面向接口和面向类呢.

还记得我们在生成代理类的代码吗: Java代码 复制代码 收藏代码Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), this);

这里面的参数不许为空,也就是说:obj.getClass().getInterfaces()必有值,即目标类一定要实现某个接口.

有了这些,JVM在内存中就动态的构造出代理出来.

而没有实现任何接口的类,就必须使用CGLib来动态构造代理类.值得一提的是,CGLib构造的代理类是目标类的一个子类.

4.4 相关工程简解

Spring的相关知识不应该在这里讲,难度系数过大.这里只给个简单例子.供参考.

4.4.1 准备工作

打开Eclipse.新建Java工程,取名为AOP_Proxy.完成. 复制spring-2.0.jar.粘贴到AOP_Proxy下. 右击AOP_Proxy-->属性-->Java构建路径-->库-->添加JAR-->找spring-2.0.jar-->添加确定. 复制commons-logging.jar.粘贴到AOP_Proxy下. 右击AOP_Proxy-->属性-->Java构建路径-->库-->添加JAR-->找commons-logging.jar-->添加确定.

4.4.2 写代码

代码略.配置文件略.

4.4.3 导入工程的步骤

新建工程AOP_Pro/Files/qileilove/AOP_Proxy.rarxy-->完成-->右击AOP_Proxy-->导入-->常规-->文件系统-->找到项目文件,导入完成.

两个jar包和项目文件(项目文件需要先解压).

本文出自seven的测试人生公众号最新内容请见作者的GitHub页：