动态代理：如何像007一样化身影子

后端

2023-08-19 09:26:20

动态代理：程序员的秘密武器

在瞬息万变的软件开发世界中，你是否曾面临过这样的困境：

需要为现有对象添加新功能，却不想修改既有代码？
希望改变对象的某些行为，但又不想破坏其原有的设计？

这时，动态代理便横空出世，犹如编程界的007特工，轻而易举地为你解决这些难题。

动态代理是什么？

动态代理是一种设计模式，它允许你在运行时动态地创建代理对象。这个代理对象可以拦截目标对象的调用，在不改变原始代码的情况下，实现新功能或改变其行为。

想想看，就像007在执行任务时，可以根据不同的任务要求，伪装成不同的身份，完成不同的任务。动态代理也拥有类似的变形能力，它可以根据你的特定需要，伪装成目标对象，并执行不同的操作。

动态代理的优势：

灵活性： 你可以根据需要创建不同的代理，而不必修改原有代码。
可扩展性： 你可以随时添加新的代理，而不需要修改原有代码。
松散耦合： 代理对象与目标对象之间是松散耦合的，因此你可以轻松地更换代理对象，而不需要修改目标对象。
安全性： 代理对象可以保护目标对象免受非法访问。

动态代理的劣势：

性能开销： 创建代理对象和方法调用都会产生额外的性能开销。
复杂性： 动态代理的实现可能很复杂，特别是如果你需要处理多个代理对象和方法调用。
调试困难： 由于代理对象和目标对象之间是松散耦合的，因此调试动态代理代码可能会很困难。

动态代理的应用场景：

日志记录： 你可以使用动态代理来记录方法调用信息。
安全： 你可以使用动态代理来控制对对象的访问。
事务管理： 你可以使用动态代理来管理事务。
缓存： 你可以使用动态代理来缓存方法调用结果。
性能优化： 你可以使用动态代理来优化方法调用的性能。

在 Java 中实现动态代理：

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

public class DynamicProxyExample {
    public static void main(String[] args) {
        // 目标对象
        MyTargetObject targetObject = new MyTargetObject();

        // 创建一个 InvocationHandler 实现，用于拦截方法调用
        InvocationHandler handler = new MyInvocationHandler(targetObject);

        // 创建一个代理对象，将 InvocationHandler 作为参数传递给 Proxy.newProxyInstance() 方法
        MyTargetObject proxyObject = (MyTargetObject) Proxy.newProxyInstance(
                MyTargetObject.class.getClassLoader(),
                new Class[] { MyTargetObject.class },
                handler
        );

        // 使用代理对象调用方法
        proxyObject.doSomething();
    }

    // InvocationHandler 实现，用于拦截方法调用
    private static class MyInvocationHandler implements InvocationHandler {
        private final MyTargetObject targetObject;

        public MyInvocationHandler(MyTargetObject targetObject) {
            this.targetObject = targetObject;
        }

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            // 在方法调用之前和之后执行额外的操作
            System.out.println("Before method call: " + method.getName());
            Object result = method.invoke(targetObject, args);
            System.out.println("After method call: " + method.getName());

            return result;
        }
    }

    // 目标对象接口
    public interface MyTargetObject {
        void doSomething();
    }

    // 目标对象实现
    public static class MyTargetObjectImpl implements MyTargetObject {
        @Override
        public void doSomething() {
            System.out.println("MyTargetObjectImpl.doSomething() called");
        }
    }
}

使用这种动态代理实现，你可以在不修改原有 MyTargetObject 实现的情况下，轻松添加新的行为，例如方法调用前后的日志记录。

在 Python 中实现动态代理：

import types

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

    def __getattr__(self, name):
        method = getattr(self.target, name)
        return types.MethodType(method, self)

def my_handler(instance, method, args):
    print("Before method call: " + method.__name__)
    result = method(instance, *args)
    print("After method call: " + method.__name__)
    return result

def create_proxy(target):
    proxy = DynamicProxy(target)
    proxy.__handler__ = my_handler
    return proxy

def main():
    target = MyTargetObject()
    proxy = create_proxy(target)

    # 使用代理对象调用方法
    proxy.do_something()

class MyTargetObject:
    def do_something(self):
        print("MyTargetObject.do_something() called")

if __name__ == "__main__":
    main()