JAVA_动态代理

来源：互联网发布：js 打开新页面编辑：程序博客网时间：2024/04/28 11:54

代理的概念与作用

1、引入:

为已存在的多个具有相同接口的目标类的各个方法增加一些系统功能，例如，异常处理、日志、计算方法的运行时间、事务管理、等等，你准备如何做？

编写一个与目标类具有相同接口的代理类，代理类的每个方法调用目标类的相同方法，并在调用方法时加上系统功能的代码。

2、代理类的优点：

如果采用工厂模式和配置文件的方式进行管理，则不需要修改客户端程序，在配置文件中配置是使用目标类、还是代理类，这样以后很容易切换，譬如，想要日志功能时就配置代理类，否则配置目标类，这样，增加系统功能很容易，以后运行一段时间后，又想去掉系统功能也很容易。

目标类：代理类：

class X{ Xproxy{

void sayHello(){ void sayHello(){

syso:Hello; startTime

} X. sayHello();

} endTime;}}

一般用接口来引用其子类，如：Collectioncoll = new ArrayList();

AOP

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

安全事务日志

StudentService ------|----------|------------|-------------

CourseService ------|----------|------------|-------------

MiscService ------|----------|------------|-------------

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

method1 method2 method3

{ { {

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

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

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

} } }

交叉业务的编程问题即为面向方面的编程（Aspect oriented program ,简称AOP），AOP的目标就是要使交叉业务模块化。可以采用将切面代码移动到原始方法的周围，这与直接在方法中编写切面代码的运行效果是一样的，如下所示：

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

func1 func2 func3

{ { {

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

} } }

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

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

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

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

动态代理技术

1、要为系统中的各种接口的类增加代理功能，那将需要太多的代理类，全部采用静态代理方式，将是一件非常麻烦的事情！写成百上千个代理类，是不是太累！

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

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

4、CGLIB库可以动态生成一个类的子类，一个类的子类也可以用作该类的代理，所以，如果要为一个没有实现接口的类生成动态代理类，那么可以使用CGLIB库。

5、代理类的各个方法中通常除了要调用目标的相应方法和对外返回目标返回的结果外，还可以在代理方法中的如下四个位置加上系统功能代码：

1）在调用目标方法之前

2）在调用目标方法之后

3）在调用目标方法前后

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

分析JVM动态生成的类

总结思考：让jvm创建动态类及其实例对象，需要给它提供哪些信息?

三个方面：

1、生成的类中有哪些方法，通过让其实现哪些接口的方式进行告知；

2、产生的类字节码必须有个一个关联的类加载器对象；

3、生成的类中的方法的代码是怎样的，也得由我们提供。把我们的代码写在一个约定好了接口对象的方法中，把对象传给它，它调用我的方法，即相当于插入了我的代码。提供执行代码的对象就是那个InvocationHandler对象，它是在创建动态类的实例对象的构造方法时传递进去的。在上面的InvocationHandler对象的invoke方法中加一点代码，就可以看到这些代码被调用运行了。

用newProxyInstance（）方法直接一步就创建出代理对象。

总结分析动态代理类的统计原理和结构：

1、怎样将目标传进去：

1）直接在InvocationHandler实现类中创建目标类的实例对象，可看运行效果和加入日志代码，但是毫无意义。

2）为InvocationHandler实现类注入目标的实例对象，不能采用匿名内部类的形式了。

3）让匿名内部类的InvocationHandler实现类访问外面的方法中的目标类实例对象的final类型的引用变量。

2、动态代理的工作原理：

1）Client(客户端)调用代理，代理的构造方法接受一个InvocationHandler，client调用代理的各个方法，代理的各个方法请求转发给刚才通过构造方法传入的handler对象，又把各请求分发给目标的相应的方法。就是将handler封装起来，其中this引用了当前的放(发来什么请求就接受哪个方法)。

猜想分析动态生成的类的内部代码：

1、动态生成的类实现了Collection接口（可以实现若干接口），生成的类有Collection接口中的所有方法和一个如下接受InvocationHandler参数的构造方法。

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

实现Collection接口的动态类中的各个方法的代码又是怎样的呢？InvocationHandler接口中定义的invoke方法接受的三个参数又是什么意思？图解说明如下：

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

为何动态类的实例对象的getClass()方法返回了正确结果，而没调用invoke方法：

因为代理类从Object上继承了许多方法，其中只对三个方法（hashCode、equals和toString）进行开发，委托给handler去自行处理，对于它身上其他方法不会交给代理类去实现，所以对于getClass()方法，还是由Object本身实现的。即proxy3.getClass()，该是什么结果还是什么结果，并不会交给invoke方法处理。

7、综合示例代码（用到三个.java文件，张老师的源码，自己加了注释，自己敲精简版的代理）：

package javaenhance.src.cn.itcast.day3;

import java.lang.reflect.Constructor;

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 {

/**

* @param args

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

// TODO Auto-generated method stub

//接收两个参数，一个是后边参数的字节码的加载器，一个是所要实现代理的接口的字节码

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

System.out.println(clazzProxy1.getName());//打印代理的名字 $Proxy0

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

/*想打印出如下格式：

* $Proxy0()

$Proxy0(InvocationHandler,int)*/

Constructor[] constructors = clazzProxy1.getConstructors();//获取代理的构造函数

for(Constructor constructor : constructors){

String name = constructor.getName();//获取代理的构造函数的name

StringBuilder sBuilder = new StringBuilder(name);

sBuilder.append('(');

Class[] clazzParams = constructor.getParameterTypes();//获取代理的构造函数的参数

for(Class clazzParam : clazzParams){

sBuilder.append(clazzParam.getName()).append(',');

}

if(clazzParams!=null && clazzParams.length != 0)//稳妥的判断是否是一个参数，不是就删掉最后的，

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

sBuilder.append(')');

System.out.println(sBuilder.toString()); //$Proxy0(java.lang.reflect.InvocationHandler)

}

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

/*$Proxy0()

$Proxy0(InvocationHandler,int)*/

Method[] methods = clazzProxy1.getMethods();//获取代理身上的方法

for(Method method : methods){

String name = method.getName();

StringBuilder sBuilder = new StringBuilder(name);

sBuilder.append('(');

Class[] clazzParams = method.getParameterTypes();

for(Class clazzParam : clazzParams){

sBuilder.append(clazzParam.getName()).append(',');

}

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

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

sBuilder.append(')');

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

}

System.out.println("----------begin create instance object----------");

//Object obj = clazzProxy1.newInstance();

//方式一：通过接口的子类创建对象

Constructor constructor =

clazzProxy1.getConstructor(InvocationHandler.class);

//获取代理身上的构造函数

//创建内部类MyInvocationHandler1，目的是传递给代理的构造器

class MyInvocationHandler1 implements InvocationHandler{

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

throws Throwable {

// TODO Auto-generated method stub

return null;

}

//方式二：匿名内部类

Collection proxy1 = (Collection)constructor.newInstance(new MyInvocationHandler1());

System.out.println(proxy1);//没有错误

proxy1.clear();//没有错误

//proxy1.size();报错，因为，代理调用size方法，其实是调用了MyInvocationHandler1中的invoke，他的返回值是null

//System.out.println("111111111111111");//调试用的

//用了匿名内部类的方法实现

Collection proxy2 = (Collection)constructor.newInstance(new InvocationHandler(){

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

throws Throwable {

return null;

}

});

/*下边这部分代码非常重要和精辟*/

final ArrayList target = new ArrayList();

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

proxy3.add("zxx");

proxy3.add("lhm");

proxy3.add("bxd");

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

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

}

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

//方式三，newProxyInstance这个方法需要三个参数，可以直接创建target的代理对象

Object proxy3 = Proxy.newProxyInstance(

target.getClass().getClassLoader(),

/*new Class[]{Collection.class},*/

//获取target上的接口

target.getClass().getInterfaces(),

new InvocationHandler(){

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

throws Throwable {

/*long beginTime = System.currentTimeMillis();

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

long endTime = System.currentTimeMillis();

System.out.println(method.getName() + " running time of " + (endTime - beginTime));

return retVal;*/

//把上边的代码封装到一个类中，让后调用该类的方法，就实现了方法的封装

advice.beforeMethod(method);

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

advice.afterMethod(method);

return retVal;

}

);

return proxy3;

}

/*$Proxy0

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

$Proxy0(java.lang.reflect.InvocationHandler)

----------begin methods list----------

hashCode()

equals(java.lang.Object)

toString()

add(java.lang.Object)

contains(java.lang.Object)

isEmpty()

size()

toArray()

toArray([Ljava.lang.Object;)

addAll(java.util.Collection)

iterator()

remove(java.lang.Object)

clear()

containsAll(java.util.Collection)

removeAll(java.util.Collection)

retainAll(java.util.Collection)

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

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

isProxyClass(java.lang.Class)

getInvocationHandler(java.lang.Object)

getClass()

notify()

notifyAll()

wait(long)

wait(long,int)

wait()

----------begin create instance object----------

null

到传智播客来学习啦！

从传智播客毕业上班啦！

add running time of 0

到传智播客来学习啦！

从传智播客毕业上班啦！

add running time of 0

到传智播客来学习啦！

从传智播客毕业上班啦！

add running time of 0

到传智播客来学习啦！

从传智播客毕业上班啦！

size running time of 0

$Proxy1*/

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

import java.lang.reflect.Method;

public interface Advice {

void beforeMethod(Method method);

void afterMethod(Method method);

}

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

package javaenhance.src.cn.itcast.day3;

import java.lang.reflect.Method;

//创建实现Advice接口的子类

public class MyAdvice implements Advice {

long beginTime = 0;

public void afterMethod(Method method) {

// TODO Auto-generated method stub

System.out.println("从传智播客毕业上班啦！");

long endTime = System.currentTimeMillis();

System.out.println(method.getName() + " running time of " + (endTime - beginTime));

}

public void beforeMethod(Method method) {

// TODO Auto-generated method stub

System.out.println("到传智播客来学习啦！");

beginTime = System.currentTimeMillis();

}

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

一、工厂类BeanFactory：

1、工厂类BeanFactory负责创建目标类或代理类的实例对象，并通过配置文件实现切换。

2、getBean方法根据参数字符串返回一个相应的实例对象，如果参数字符串在配置文件中对应的类名不是ProxyFactoryBean，则直接返回该类的实例对象，否则返回该类示例对象的getProxy方法返回的对象。

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

#xxx=java.util.ArrayList

xxx=cn.itcast.test3.aopframework.ProxyFactoryBean

xxx.advice=cn.itcast.test3.MyAdvice

xxx.target=java.util. ArrayList

注意：其中的#代表注释当前行。

4、ProxyFactoryBean充当封装成动态的工厂，需为工厂提供的配置参数信息包括：

目标（target）

通告（advice）

5、BeanFactory和ProxyFactoryBean：

1）BeanFactory是一个纯粹的bean工程，就是创建bean即相应的对象的工厂。

2）ProxyfactoryBean是BeanFactory中的一个特殊的Bean，是创建代理的工厂。

二、实现类似spring的可配置的AOP框架的思路：

1、创建BeanFactory类：

1）构造方法：接受一个配置文件，通过Properties对象加载InputStream流对象获得。

2）创建getBean(String name)方法，接收Bean的名字，从上面加载后的对象获得。

3）通过其字节码对象创建实例对象bean。

4）判断bean是否是特殊的Bean即ProxyFactoryBean，如果是，就要创建代理类，并设置目标和通告，分别得到各自的实例对象，并返回代理类实例对象。如果不是在返回普通类的实例对象。

2、创建ProxyFactoryBean(接口)，此处用类做测试，其中有一个getProxy方法，用于获得代理类对象。

3、对配置文件进行配置，如上面配置一样。

4、作一个测试类：AopFrameworkTest进行测试。

//创建BeanFactory类

package cn.itcast.test3.aopframework;

import java.io.IOException;

import java.io.InputStream;

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

import java.lang.reflect.Proxy;

import java.util.Properties;

public class BeanFactory {

Properties prop = new Properties();

//创建对象时需要传入一个配置文件中的数据，所以需要在构造方法中接受一个参数

public BeanFactory(InputStream ips) {

try {

//将配置文件加载进来

prop.load(ips);

} catch (IOException e) {

e.printStackTrace();

}

//创建getBean方法，通过配置文件中的名字获取bean对象

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();

}

//判断bean是特殊的bean即ProxyFactoryBean还是普通的bean

if(bean instanceof ProxyFactoryBean){

Object proxy = null;

try {

//是ProxyFactoryBean的话，强转，并获取目标和通告

ProxyFactoryBean proxyFactoryBean = (ProxyFactoryBean)bean;

//获取advice和target

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);

//通过类ProxyFactoryBean（开发中是作为接口存在）中获得proxy对象

proxy = proxyFactoryBean.getProxy();

} catch (Exception e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

//是ProxyFactoryBean的话，返回proxy对象

return proxy;

}

//否则返回普通bean对象

return bean;

}

//创建ProxyFactoryBean类

package cn.itcast.test3.aopframework;

import java.lang.reflect.*;

import cn.itcast.test3.Advice;

public class ProxyFactoryBean {

private Object target;

private Advice advice;

public Object getTarget() {

return target;

}

public void setTarget(Object target) {

this.target = target;

}

public Advice getAdvice() {

return advice;

}

public void setAdvice(Advice advice) {

this.advice = advice;

}

public Object getProxy() {

Object proxy = Proxy.newProxyInstance(

target.getClass().getClassLoader(),

//这里的接口要和target实现相同的接口

target.getClass().getInterfaces(),

new InvocationHandler() {

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

throws Throwable {

//通过契约，使用其方法--before和after方法

advice.beforeMethod(method);

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

advice.afterMethod(method);

return value;

}

);

return proxy;

}

//创建测试类AopFrameworkTest

package cn.itcast.test3.aopframework;

import java.io.InputStream;

public class AopFramewrorkTest {

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

//读取配置文件的数据

InputStream ips =

AopFramewrorkTest.class.getResourceAsStream("config.property");

//获取bean对象

Object bean = new BeanFactory(ips).getBean("xxx");

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

}

0 0