转载

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

Java的动态代理常用来包装原始方法调用，用于增强或改写现有方法的逻辑，它在Java技术领域被广为使用，在阿里的Sofa RPC框架序列化中你能看到它的身影，Hibernate的实体类功能增强也是以动态代理的方式解决的，还有Spring吹牛逼的AOP功能也是它搞定的。接下来我们看一个例子，该例子用于对原有的方法调用前后各打印一句话，这也算是对原有类方法的一种增强。

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更加简单呢？欢迎大家一起来评论区吵架。