Java面向对象——代理

分析代理类的作用与原理及AOP概念

代理的概念与作用

生活中的代理武汉人从武汉的代理商手中买联想电脑和直接跑到北京传智播客旁边来找联想总

部买电脑，你觉得最终的主体业务目标有什么区别吗？基本上一样吧，都解决了核心问题，但

是，一点区别都没有吗？从代理商那里买真的一点好处都没有吗？

程序中的代理

要为已存在的多个具有相同接口的目标类的各个方法增加一些系统功能，例如，异常处理、日

志、计算方法的运行时间、事务管理、等等，你准备如何做？

编写一个与目标类具有相同接口的代理类，代理类的每个方法调用目标类的相同方法，并在调用

方法时加上系统功能的代码。 如果采用工厂模式和配置文件的方式进行管理，则不需要修改客户

端程序，在配置文件中配置是使用目标类、还是代理类，这样以后很容易切换，例如，想要日志

功能时就配置代理类，否则配置目标类，这样，增加系统功能很容易，以后运行一段时间后，又想去掉系统功能也很容易。

代理结构图

AOP

系统中存在交叉业务，一个交叉业务就是要切入到系统中的一个方面，如下所示：

用具体的程序代码描述交叉业务：

method1         method2          method3

{                      {                       {

------------------------------------------------------切面

....                    ....                     ......

------------------------------------------------------切面

}                       }                       }

交叉业务的编程问题即为面向方面的编程（Aspect oriented program ,简称AOP），AOP的目标就是要使交叉业务模块化。可以采

用将切面代码移动到原始方法的周围，这与直接在方法中编写切面代码的运行效果是一样的，如下所示：

------------------------------------------------------切面

func1     func2    func3

{             {                {

....            ....              ......

}             }                }

------------------------------------------------------切面

使用代理技术正好可以解决这种问题，代理是实现AOP功能的核心和关键技术。

注意：

安全，事务，日志等功能要贯穿到好多个模块中，所以，它们就是交叉业务。

重要原则：不要把供货商暴露给你的客户。

动态代理技术

要为系统中的各种接口的类增加代理功能，那将需要太多的代理类，全部采用静态代理方

式，将是一件非常麻烦的事情！写成百上千个代理类，是不是太累！

JVM可以在运行期动态生成出类的字节码，这种动态生成的类往往被用作代理类，即动态代理类。

JVM生成的动态类必须实现一个或多个接口，所以，JVM生成的动态类只能用作具有相同接口的目标类的代理。

CGLIB库可以动态生成一个类的子类，一个类的子类也可以用作该类的代理，所以，如果要为一个没有实现

接口的类生成动态代理类，那么可以使用CGLIB库。

代理类的各个方法中通常除了要调用目标的相应方法和对外返回目标返回的结果外，还可以在代理方法中的如下四

个位置加上系统功能代码：

1、在调用目标方法之前

2、在调用目标方法之后

3、在调用目标方法前后

4、在处理目标方法异常的catch块中

例子：

class proxy{

void sayHello(){

……….

try{

target.sayHello();

}catch(Exception e){

………..

}

………….

}

}

创建动态类及查看其方法列表信息

创建实现了Collection接口的动态类和查看其名称，分析Proxy.getProxyClass方法的各个参数。

编码列出动态类中的所有构造方法和接收参数的类型。

编码列出动态类中的所有方法和接收参数的类型。

package com.tuozou.day03;

import java.lang.reflect.Constructor;

import java.lang.reflect.Method;

import java.lang.reflect.Proxy;

import java.util.Collection;

public class ProxyTest {

public static void main(String[] args) {

/*

 * 编码列出动态类中的所有构造方法和接收参数的类型。

 */

Class clazzProxy = Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class);

System.out.println(clazzProxy.getName());

System.out.println("--------begin constructors list-------");

Constructor[] constructors = clazzProxy.getConstructors();

for (Constructor constructor : constructors) {

String name = constructor.getName();

StringBuilder sb = new StringBuilder(name);

sb.append("(");

Class[] clazzParams = constructor.getParameterTypes();

for(Class clazzParam : clazzParams) {

sb.append(clazzParam.getName()).append(",");

}

if (clazzParams !=null && clazzParams.length != 0) {

sb.deleteCharAt(sb.length()-1);

}

sb.append(")");

System.out.println(sb.toString());

}

/*

 *  编码列出动态类中的所有方法和接收参数的类型。

 * */

System.out.println("--------begin method list-------");

Method [] methods = clazzProxy.getMethods();

for (Method method : methods) {

String name = method.getName();

StringBuilder sb =new StringBuilder(name);

sb.append("(");

Class[] clazzParams = method.getParameterTypes();

for (Class clazzParam : clazzParams) {

sb.append(clazzParam.getName()).append(",");

}

if(clazzParams !=null && clazzParams.length != 0) {

sb.deleteCharAt(sb.length()-1);

}

sb.append(")");

System.out.println(sb.toString());

}

}

}

结果：

com.sun.proxy.$Proxy0

--------begin constructors list-------

com.sun.proxy.$Proxy0(java.lang.reflect.InvocationHandler)

--------begin method list-------

add(java.lang.Object)

remove(java.lang.Object)

equals(java.lang.Object)

toString()

hashCode()

clear()

contains(java.lang.Object)

isEmpty()

size()

toArray()

toArray([Ljava.lang.Object;)

addAll(java.util.Collection)

iterator()

containsAll(java.util.Collection)

removeAll(java.util.Collection)

retainAll(java.util.Collection)

isProxyClass(java.lang.Class)

getInvocationHandler(java.lang.Object)

getProxyClass(java.lang.ClassLoader,[Ljava.lang.Class;)

newProxyInstance(java.lang.ClassLoader,[Ljava.lang.Class;,java.lang.reflect.InvocationHandler)

wait(long,int)

wait(long)

wait()

getClass()

notify()

notifyAll()

注意：

StringBuilder与StringBuffer的区别？

答：StringBuffer是线程安全的，StringBuilder是线程不安全的。

StringBuilder在单线程的时候使用，StringBuffer则是在多线程的时候使用。

因此StringBuilder比StringBuffer效率高一些。

创建动态类的实例对象及调用其方法

步骤：

1、创建动态类的实例对象。通过反射获得构造方法。

2、编写一个最简单的InvocationHandler类。

3、调用构造方法创建动态类的实例对象，并将编写的InvocationHandler类的实例对象传进去。

4、将创建动态类的实例对象的代理改成匿名内部类的形式编写，锻炼大家习惯匿名内部类。

package com.tuozou.day03;

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

import java.lang.reflect.Proxy;

import java.util.Collection;

public class ProxyTest {

public static void main(String[] args)throws Exception {

Class<?> clazzProxy =Proxy.getProxyClass(

Collection.class.getClassLoader(), 

Collection.class);

Collection<?> proxy =

 (Collection<?>)clazzProxy.getConstructor(InvocationHandler.class).newInstance(

new InvocationHandler(){

@Override

public Object invoke(Object proxy,Method method,Object[] args) 

throws Throwable{

return null;

}

});

System.out.println(proxy);

//结果：null

proxy.clear();

//执行没有返回值的方法，不会报告异常

proxy.size();

//执行有返回值的方法，会报告异常

}

}

完成InvocationHandler对象的内部功能

用 Proxy.newInstance方法可以直接一步就创建出代理对象。

一个简单的例子：

Foo f = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),

new Class[] { Foo.class },

handler);

代码示例：

package com.tuozou.day03;

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

import java.lang.reflect.Proxy;

import java.util.ArrayList;

import java.util.Collection;

public class ProxyTest {

@SuppressWarnings("unchecked")

public static void main(String[] args) throws Exception {

@SuppressWarnings("rawtypes")

Collection proxy = (Collection)Proxy.newProxyInstance(

Collection.class.getClassLoader(),

new Class[] {Collection.class }, 

new InvocationHandler() {

ArrayList<String> target =new ArrayList<String>();

@Override

public Object invoke(Object proxy,Method method,Object[] args) throws Throwable {

long startTime = System.currentTimeMillis();

Object retVal = method.invoke(target, args);

long endTime =System.currentTimeMillis();

System.out.println(method.getName() +" 运行时间 "

+ (endTime - startTime) + "秒");

return retVal;

}

});

proxy.add("黑马程序员");

proxy.add("黑马论坛");

proxy.add("CSDN社区");

System.out.println(proxy.size());

//结果：3

}

}

注意：

如果作为target的ArrayList对象放置在invoke方法内部定义，那么每次调用代理的某个方法，都会调用invoke

方法，这样作为target的ArrayList对象每次都会被创建，这样就导致最后调用proxy.size()的时候，结果为0。

分析InvocationHandler对象的运行原理

动态生成的类实现了Collection接口（可以实现若干接口），生成的类有Collection接口中的所有方法和一个

InvocationHandler参数的构造方法。

构造方法接受一个InvocationHandler对象，接受对象了要干什么用呢？该方法内部的代码会是怎样的呢？

答：接受的对象会通过构造函数赋值给某个成员变量。

$Proxy0 implements Collection{

InvocationHandler handler;

public $Proxy0(InvocationHandler handler){

this.handler = handler;

}

}

实现Collection接口的动态类中的各个方法的代码又是怎样的呢？InvocationHandler接口中定义的invoke方法接受的

三个参数又是什么意思？图解说明如下：

示例：

$Proxy0 implements Collection{

InvocationHandler handler;

public $Proxy0(InvocationHandler handler){

this.handler = handler;

}

//生成的Collection接口中的方法的运行原理

int size(){

return handler.invoke(this,this.getClass().getMethod("size"),null);

}

void clear(){

handler.invoke(this,this.getClass().getMethod("clear"),null);

}

boolean add(Object obj){

return handler.invoke(this,this.getClass().getMethod("add"),obj);

}

}

代码示例：

package com.tuozou.day03;

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

import java.lang.reflect.Proxy;

import java.util.ArrayList;

import java.util.Collection;

public classProxyTest {

@SuppressWarnings("unchecked")

public static void main(String[] args)throws Exception {

@SuppressWarnings("rawtypes")

Collection proxy = (Collection)Proxy.newProxyInstance(

Collection.class.getClassLoader(),

new Class[] {Collection.class },

new InvocationHandler() {

@Override

public Object invoke(Object proxy,Method method,

Object[] args)throws Throwable{

return null;

}

});

System.out.println(proxy.getClass());

// class com.sun.proxy.$Proxy0

System.out.println(proxy);

// 结果：null

proxy.clear();

// 执行没有返回值的方法，不会报告异常

proxy.size();

//执行有返回值的方法，会报告异常

}

}

①分析上面打印动态类的实例对象时，结果为什么会是null呢？

答：打印动态类的示例对象实际上就是打印proxy的toString方法，也就是执行代理对象中的如下代码：

String toString(){

return handler.invoke(this,this.getClass().getMethod("toString"),null);

}

由于invoke方法返回的是null，打印出来的结果肯定是null。

②调用有基本类型返回值的方法时为什么会出现NullPointerException异常？

答：执行proxy.size()方法，就是执行下面的代码：

int size(){

return handler.invoke(this,this.getClass().getMethod("size"),null);

}

由于invoke方法返回的是null，要将null转换为int类型，肯定会报告空指针异常。

③分析为什么动态类的实例对象的getClass()方法返回了正确结果呢？

答：调用代理对象的从Object类继承的hashCode, equals, 或toString这几个方法时，代理对象将调用请求转发给

InvocationHandler对象，对于其他方法，则不转发调用请求，比如getClass方法，所以它会返回正确的结果。

详见如下JDK文档中的描述：

总结分析动态代理类的设计原理与结构

动态代理的工作原理图

注意：源对象的类必须自己定义时就实现接口，从该类的祖辈类上继承的接口是无效的。

将创建代理的过程改为一种更优雅的方式，MyEclipse重构出一个getProxy方法绑定接收目标同时返回代理对象，让

调用者更懒惰，更方便，调用者甚至不用接触任何代理的API。

将系统功能代码模块化，即将切面代码也改为通过参数形式提供，怎样把要执行的系统功能代码以参数形式提供？

把要执行的代码装到一个对象的某个方法里，然后把这个对象作为参数传递，接收者只要调用这个对象的方法，即

等于执行了外界提供的代码！为方法增加一个Advice参数。

代码示例：

package com.tuozou.day03;

import java.lang.reflect.Method;

public interface Advice {

void startTime();

void endTime(Object target ,Method method);

}

package com.tuozou.day03;

import java.lang.reflect.Method;

public class MyAdvice implements Advice{

private long startTime;

@Override

public void startTime() {

startTime = System.currentTimeMillis();

}

@Override

public void endTime(Object target ,Method method) {

long endTime =System.currentTimeMillis();

String objName = target.getClass().getName();

System.out.println("调用"+objName.substring((objName.lastIndexOf(".")+1),objName.length())+ 

"对象的"+method.getName()+"方法 耗时"+(endTime-startTime)+"秒");

}

}

package com.tuozou.day03;

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

import java.lang.reflect.Proxy;

import java.util.ArrayList;

import java.util.Collection;

public class ProxyTest {

@SuppressWarnings({ "rawtypes", "unchecked" })

public static void main(String[] args) throws Exception {

final ArrayListtarget =newArrayList();

Collection collection = (Collection) getProxy(target,new MyAdvice());

collection.add("黑马程序员");

}

private static Object getProxy(final Object target,final Advice advice) {

Object objProxy = Proxy.newProxyInstance(

target.getClass().getClassLoader(),

target.getClass().getInterfaces(),

new InvocationHandler() {

@Override

public Object invoke(Object proxy,Method method,Object[] args) throws Throwabl{

advice.startTime();

Object retVal = method.invoke(target, args);

advice.endTime(target,method);

return retVal;

}

});

return objProxy;

}

}

实现类似spring的可配置的AOP框架

工厂类BeanFactory负责创建目标类或代理类的实例对象，并通过配置文件实现切换。其getBean方法根据参数字符

串返回一个相应的实例对象，如果参数字符串在配置文件中对应的类名不是ProxyFactoryBean，则直接返回该类的

实例对象，否则，返回该类实例对象的getProxy方法返回的对象。

BeanFactory的构造方法接收代表配置文件的输入流对象，配置文件格式如下：

#proxy=java.util.ArrayList

proxy=com.tuozou.day03.ProxyFactoryBean

proxy.target=java.util.ArrayList

proxy.advice=com.tuozou.day03.MyAdvice

ProxyFacotryBean充当封装生成动态代理的工厂，需要为工厂类提供哪些配置参数信息？

目标

通知

编写客户端应用：

编写实现Advice接口的类和在配置文件中进行配置

调用BeanFactory获取对象。

代码示例：

package com.tuozou.day03;

import java.lang.reflect.Method;

public interface Advice {

void beforeAdvice();

void afterAdvice(Object target ,Method method);

}

package com.tuozou.day03;

import java.lang.reflect.Method;

public class MyAdvice implements Advice{

private long startTime;

@Override

public void beforeAdvice() {

startTime = System.currentTimeMillis();

}

@Override

public void afterAdvice(Object target ,Method method) {

long endTime =System.currentTimeMillis();

String objName = target.getClass().getName();

System.out.println("调用"+objName.substring((objName.lastIndexOf(".")+1),objName.length())+ 

"对象的"+method.getName()+"方法 耗时"+(endTime-startTime)+"秒");

}

}

package com.tuozou.day03;

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

import java.lang.reflect.Proxy;

public class ProxyFactoryBean {

private Advice advice;

private Object target;

public ProxyFactoryBean(){}

public Advice getAdvice() {

return advice;

}

public Object getTarget() {

return target;

}

public void setAdvice(Advice advice) {

this.advice = advice;

}

public void setTarget(Object target) {

this.target = target;

}

public Object getProxy(){

Object objProxy =Proxy.newProxyInstance(

target.getClass().getClassLoader(), 

target.getClass().getInterfaces(), 

new InvocationHandler() {

@Override

public Object invoke(Object proxy,Method method,Object[] args) throws Throwable {

advice.beforeAdvice(target,method);

Object retVal = method.invoke(target, args); 

advice.afterAdvice(target ,method);

return retVal;

}

});

return objProxy;

}

}

package com.tuozou.day03;

import java.io.InputStream;

import java.util.Properties;

public class BeanFactory {

private Properties prop = new Properties();

public BeanFactory(InputStream ips) {

try {

prop.load(ips);

} catch (Exception e) {

e.printStackTrace();

}

}

public Object getBean(String name) {

String className = prop.getProperty(name);

Object bean =null;

try {

Class<?> clazz =Class.forName(className);

bean = clazz.newInstance();

} catch (Exception e) {

e.printStackTrace();

}

if(bean instanceof ProxyFactoryBean) {

ProxyFactoryBean proxyFactoryBean = (ProxyFactoryBean) bean;

Object proxy = null;

try {

Advice advice = (Advice)Class.forName(

prop.getProperty(name + ".advice")).newInstance();

Object target =Class.forName(

prop.getProperty(name + ".target")).newInstance();

proxyFactoryBean.setAdvice(advice);

proxyFactoryBean.setTarget(target);

proxy = proxyFactoryBean.getProxy();

} catch (Exception e) {

e.printStackTrace();

}

return proxy;

}

return bean;

}

}

package com.tuozou.day03;

import java.io.InputStream;

public class AopFrameworkTest {

public static void main(String[] args)throws Exception {

InputStream ips = AopFrameworkTest.class.getResourceAsStream("config.properties");

Object objProxy = new BeanFactory(ips).getBean("proxy");

System.out.println(objProxy.getClass().getName());

}

}

config配置文件：

结果：

config配置文件：

结果：

----------------------