看完 Java 的动态代理技术——Pythoner 笑了

Java 的动态代理常用来包装原始方法调用，用于增强或改写现有方法的逻辑。我们看一个例子，该例子用于对原有的方法调用前后各打印一句话。

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

interface IHello {

	void say(String s);

}

// 待加强的目标类
class RealHello implements IHello {

	@Override
	public void say(String s) {
		System.out.println("hello " + s);
	}

}

// 增强器
class HelloProxy implements InvocationHandler {

	private IHello target;  // 原始对象

	public HelloProxy(IHello target) {
		this.target = target;
	}

	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		System.out.println("before print");
		method.invoke(target, args);  // 调用原始对象的方法
		System.out.println("after print");
		return null;
	}

}

public class DynamicProxy {

	public static void main(String[] args) {
		IHello hello = enhanceHello(new RealHello());  # 增强原始方法
		hello.say("world");
	}

	public static IHello enhanceHello(IHello target) {
		return (IHello) Proxy.newProxyInstance(DynamicProxy.class.getClassLoader(), new Class<?>[] { IHello.class },
				new HelloProxy(target));
	}

}

输出

before print
hello world
after print

为了便于理解，我们用图来表示上面的对象的关系。我们调用Proxy.newProxyInstance产生了一个匿名类实例，该实例同样实现了 IHello 接口，它的作用就是用来替代原生的RealHello实例。这个匿名实例持有 HelloDelegate 实例的引用，当你对这个匿名实例进行方法调用时，它会将调用逻辑委托给 HelloDelegate 实例的 invoke 方法。HelloDelegate 实例内部又持有原生 RealHello 对象的引用，所以用户就可以在 invoke 方法里实现任意附加逻辑，以及对原生 RealHello 对象的调用。

上面是 jdk 自带的动态代理技术，它的缺点是必须定义接口才能实现目标对象的方法增强，甚至想使用 abstract class 来替代也不行。所以开源市场上冒出了好几个动态代理的库，用于替代原生的 jdk 动态代理技术，它们不仅仅功能更强大，而且内部使用了字节码增强实现，在性能上还也要比原生 jdk 高出很多。

javaassist

javaassist 是使用最广泛的动态代理开源库。下面我们使用 javaassist 实现一个无需定义接口就能增强原始方法的例子。

import java.lang.reflect.Method;

import javassist.util.proxy.MethodHandler;
import javassist.util.proxy.ProxyFactory;

class RealHello {

	public void say(String s) {
		System.out.println("hello " + s);
	}

}

class HelloDelegate<T> implements MethodHandler {

	private T target;

	public HelloDelegate(T target) {
		this.target = target;
	}

	@Override
	public Object invoke(Object self, Method method, Method proceed, Object[] args) throws Throwable {
		System.out.println("before print");
		method.invoke(target, args);
		System.out.println("after print");
		return null;
	}

}

public class DynamicProxy {

	public static void main(String[] args) {
		RealHello hello = enhanceHello(new RealHello());
		hello.say("world");
	}

	@SuppressWarnings("unchecked")
	public static <T> T enhanceHello(T target) {
		ProxyFactory proxy = new ProxyFactory();
		proxy.setSuperclass(RealHello.class);
		try {
			HelloDelegate<T> delegate = new HelloDelegate<T>(target);
			// create 方法传递了两个空数组
			// 分别代表构造器的参数类型数组和构造器的参数实例数组
			return (T) proxy.create(new Class<?>[0], new Object[0], delegate);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}

}

输出

before print
hello world
after print

看起来和原生 jdk 提供的动态代理区别并不大，达到的效果是一样的。只不过这里要简单了很多，省去了接口类的定义。javaassist 的 ProxyFactory 还提供了方法过滤器，它可以选择性地对特定方法进行增强。

Python

Python 是动态语言，对于上面复杂的动态代理技术，它一笑而过。

下面我们来看看 Python 如果实现所谓的动态代理功能

class Proxy(object):

    def __init__(self, target):
        self.target = target

    def __getattribute__(self, name):
        target = object.__getattribute__(self, "target")
        attr = object.__getattribute__(target, name)

        def newAttr(*args, **kwargs):  # 包装
            print "before print"
            res = attr(*args, **kwargs)
            print "after print"
            return res
        return newAttr


class RealHello(object):

    def prints(self, s):
        print 'hello', s


if __name__ == '__main__':
    t = RealHello()
    p = Proxy(t)
    p.prints("world")

输出

before print
hello world
after print

我们使用了神奇的__getattribute__方法。在 Python 里面类的属性(方法)都是一个对象，我们先拿到这个类方法对象attr，然后对这个类方法对象进行包装，再返回包装后的新方法对象newAttr。 注意在获取 target 对象时，不能直接使用self.target，因为 self.target 会再次调用__getattribute__方法，这样就会导致死循环致堆栈过深曝出异常。取而代之应该使用object.__getattribute__方法来获取对象的属性值。

以上就是 Python 实现动态代理的方案，读者们，你们是否觉得 Python 更加简单呢？欢迎大家一起来评论区吵架。

阅读更多精彩文章，关注公众号「码洞」