利用反射生成JDK动态代理

提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

在Java的java.lang.reflect包下提供了一个Proxy类和一个InvocationHandler接口，通过使用这个类和接口可以生成JDK动态代理类和动态代理对象

1.使用Proxy和InvocationHandler创建动态代理

Proxy提供了用于创建动态代理类和代理对象的静态方法，也是所有动态代理类的父亲。如果在程序中为一个或多个接口动态的生成实现类，就可以用proxy来创建动态代理类；如果需要为一或多个接口动态的创建实例，也可以使用Proxy来创建动态代理实例

Proxy提供了如下两个方法用于创建动态代理类和代理对象。

static Class<?> getProxyClass(ClassLoader loader,Class<?>... interfaces):创建一个动态代理类的所对应的Class对象，该代理类将实现interface所制定的多个接口。loader参数指定生成动态代理类的类加载器。
static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)：直接创建一个动态代理对象。该对象的实现类实现了interfaces指定的系列接口，执行代理对象的每个方法时都会被替换执行InvocationHandler对象的invoke方法。

实际上，第一种方法生成动态代理之后，如果程序需要通过该代理类来创建对象，依然需要传入一个InvocationHandler对象。也就是说，系统生成的每个代理对象都有一个与之关联的InvocationHandler对象。

创建动态代理对象时需要实现一个或多个接口定义的方法，而InvocationHandler对象的作用是—当执行动态代理对象里的方法时，实际上会替换成调用InvocationHandler对象的invoke方法。

程序中可以采用先生成一个动态代理类，然后通过动态代理类来创建代理对象的方式生成一个动态代理对象，代码如下

package com.gdut.test0516;import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;class MyInvocationHandler implements InvocationHandler{ @Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
return null;
}
}
interface Foo{}public class ProxyTest1 { public static void main(String[] args) throws Exception{
InvocationHandler handler = new MyInvocationHandler();
Class proxyClass = Proxy.getProxyClass(Foo.class.getClassLoader(),new Class[]{Foo.class});
//获取ProxyClass中带一个InvocationHandler参数的实例
Constructor ctor = proxyClass.getConstructor(new Class[]{InvocationHandler.class});
//调用ctor的newInstance方法创建实例
Foo f = (Foo)ctor.newInstance(new Object[]{handler});
}
}

也可以简化成

package com.gdut.test0516;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;class MyInvocationHandler implements InvocationHandler{ @Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
return null;
}
}
interface Foo{}public class ProxyTest1 { public static void main(String[] args) throws Exception{
Foo f = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),new Class[]{Foo.class},new MyInvocationHandler());
}
}

下面程序示范了使用Proxy和InvocationHandler来生成动态代理对象

package com.gdut.test0516;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;interface Person{
void walk();
void sayHello(String name);
}class MyInvocationHandler2 implements InvocationHandler{
/**
* 执行动态代理对象的所有方法时，都会被替换成执行如下的invoke方法
* @param proxy 代表动态代理对象
* @param method 代表正在执行的方法
* @param args 代表调用目标方法时传入的实参
* @return
* @throws Throwable
*/
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("-----正在执行的方法："+method);
if(args != null){
System.out.println("下面执行该方法时传入的实参为：");
for (Object val:args) {
System.out.println(val);
}
}else{
System.out.println("调用该方法没有实参！");
}
return null;
}
}
public class ProxyTest2 {
public static void main(String[] args) throws Exception {
InvocationHandler handler = new MyInvocationHandler();
Person p = (Person)Proxy.newProxyInstance(Person.class.getClassLoader(),new Class[]{Person.class},new MyInvocationHandler2());
p.walk();
p.sayHello("孙悟空");
}
}

2. 动态代理和AOP

开发实际应用的软件系统时，通常会存在相同代码段重复出现的情况

我们大多数会将深色代码定义成一个方法，然后让另外三段代码段直接调用该方法即可。

但采用这种方式来实现代码复用仍存在一个重要问题，虽然代码段1，代码段2，代码段三和深色代码分开了，但是又和一个特定的方法耦合了！最理想的状态是代码块1，代码块2，代码块3能执行深色代码块部分，又无需以硬代码的方式直接调用深色代码的方法，这时可以通过动态代理达到这种效果。

由于JDK动态代理只能为接口创建代理，下面先提供一个Dog接口

interface Dog{
void info();
void run();
}

实际情况通常时，软件系统会为该接口提供一个或多个实现类，例如：GunDog

public class GunDog implements Dog{
@Override
public void info() {
System.out.println("我是一只猎狗");
} @Override
public void run() {
System.out.println("我迅速奔跑");
}
}

此处假设info()，run()两个方法分别代表代码段1，代码段2，那么要求：程序执行info()、run()方法时能调用某个通用方法，但又不想以硬代码方式调用该方法。下面提供一个DogUtil类，该类里包含两个通用方法。

public class DogUtil {
public void method1(){
System.out.println("=====模拟第一个通用方法=====");
}
public void method2(){
System.out.println("=====模拟第一个通用方法=====");
}
}

借助动态代理，将method1(),method2()两个通用方法分别插入info(),run()方法中执行

这个程序的关键在于下面的MyInvocationHandler3类，该类是InvocationHandler实现类，该实现类的invoke()方法将会作为代理对象的方法实现

package com.gdut.test0516;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;public class MyInvocationHandler3 implements InvocationHandler {
private Object target;
public void setTarget(Object target){
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Exception {
DogUtil du = new DogUtil();
du.method1();
Object result = method.invoke(target,args);
du.method2();
return result;
}
}

下面再提供MyProxyFactory类，该对象专为指定的target生成动态代理实例

public class MyProxyFactory {
public static Object getProxy(Object target)throws Exception{
MyInvocationHandler3 handler3 = new MyInvocationHandler3();
handler3.setTarget(target);
return Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),handler3);
}}

上面的动态代理工厂类提供了一个getProxy()方法，该方法为target对象生成一个动态代理对象，这个动态代理对象与target实现了相同接口，所以具有相同的public方法——从这个意义上看，动态代理对象可以当成target对象使用。当程序调用动态代理对象的指定方法时，实际上将变为执行MyInvocationHandler3对象的invoke方法。

下面是测试效果