Java 动态代理

更多 Java 高级知识方面的文章,请参见文集《Java 高级知识》


代理模式

  • 委托类:具体提供服务
  • 代理类:通过调用委托类对象的方法来提供服务。代理类的作用包括:
    • 调用具体方法前进行预处理,包括:
      • 数据的验证及过滤
      • 权限的验证
      • 开启事务
      • 查询缓存
      • 建立数据库连接
      • 记录日志等等。
    • 调用具体方法后进行后处理,包括:
      • 提交事务
      • 更新缓存
      • 关闭数据库连接
      • 记录日志等等。

代理模式分为两种形式:

  • 静态代理:程序运行前,代理类已经存在于 class 字节码文件中,程序运行中只是创建代理类的对象。
  • 动态代理:程序运行中动态创建出代理类及其对象(原理:通过反射来动态产生字节码)

静态代理

示例如下:

public class Proxy_Test {
    public static void main(String[] args) throws Exception {
        AddProxy proxy = new AddProxy(new AddImpl());
        proxy.add(1, 2);
    }
}

// 共同的接口
interface Add {
    int add(int a, int b);
}

// 委托类
class AddImpl implements Add {
    public int add(int a, int b) {
        return a + b;
    }
}

// 代理类
class AddProxy implements Add {
    // 代理类关联一个委托类对象
    private AddImpl impl;

    // 通过构造方法传入委托类的对象
    public AddProxy(AddImpl impl) {
        this.impl = impl;
    }

    public int add(int a, int b) {
        // 预处理,记录日志
        System.out.println("Add start");

        // 通过调用委托类对象的方法来提供服务
        return impl.add(a, b);
    }
}

可以看出:

  • 委托类和代理类需要实现同一个接口
  • 委托类具体提供服务
  • 代理类通过调用委托类对象的方法来提供服务,在调用前进行预处理操作,例如记录日志
  • 代理类关联一个委托类对象,并通过构造方法传入委托类的对象

静态代理的问题

代理类与委托类一一对应。
如果有多个委托类,例如在上述的例子中存在 AddImpl MinusImpl MultiplyImpl DivideImpl,则需要对应地构造多个代理类,产生重复的代码,因为每个代理类的功能其实都一样,例如记录日志。

动态代理

一个代理类完成全部的代理功能,代理一个或多个委托类。

Proxy 类

所在包:import java.lang.reflect.Proxy;
通过 Proxy 类的 newProxyInstance 方法可以为一个或多个接口动态地创建出代理类及其对象。

public static Object newProxyInstance(ClassLoader loader,
                                          Class[] interfaces,
                                          InvocationHandler h)

该方法返回一个代理类对象,该对象实现了指定的接口 Class[] interfaces

newProxyInstance 方法中,会调用如下代码:即在运行时动态生成代理类的字节码,并将字节码转换为代理类的对象。

/*
 * Generate the specified proxy class.
 */
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
    proxyName, interfaces, accessFlags);

InvocationHandler 接口

所在包:import java.lang.reflect.InvocationHandler;
实现如下的 invoke 方法:

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

Processes a method invocation on a proxy instance and returns the result. This method will be invoked on an invocation handler when a method is invoked on a proxy instance that it is associated with.
当调用代理类对象的方法时,会自动调用该 invoke 方法。
在该 invoke 方法中进行预处理,调用委托类方法 method,后处理,返回结果。

通过动态代理类实现如上的静态代理功能,完整的代码如下:

public class Proxy_Test {
    public static void main(String[] args) throws Exception {
        // 动态创建 AddImpl 的代理类对象
        Add addProxy = (Add) generateProxy(new AddImpl());
        addProxy.add(1, 2);

        // 动态创建 MinusImpl 的代理类对象
        Minus minusProxy = (Minus) generateProxy(new MinusImpl());
        minusProxy.minus(1, 2);
    }

    public static Object generateProxy(Object obj) {
        // 通过 Proxy 类的 newProxyInstance 方法可以为一个或多个接口动态地创建出代理类及其对象
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        // 预处理,记录日志
                        System.out.println(method.getName() + " start");

                        // 实际调用委托类的具体方法
                        return method.invoke(obj, args);
                    }
                });
    }
}

// 共同的接口
interface Add {
    int add(int a, int b);
}

interface Minus {
    int minus(int a, int b);
}

interface Multiply {
    int multiply(int a, int b);
}

interface Divide {
    int divide(int a, int b);
}

// 委托类
class AddImpl implements Add {
    public int add(int a, int b) {
        return a + b;
    }
}

class MinusImpl implements Minus {
    public int minus(int a, int b) {
        return a - b;
    }
}

class MultiplyImpl implements Multiply {
    public int multiply(int a, int b) {
        return a * b;
    }
}

class DivideImpl implements Divide {
    public int divide(int a, int b) {
        return a / b;
    }
}

动态代理的原理

调用代理类的方法时 addProxy.add(1, 2);,会自动触发 invoke 方法,invoke 方法中调用委托类的方法 method.invoke(obj, args);
实际上,invoke 方法不是显示调用的,它是一个回调函数。

动态代理的问题

委托类需要实现某一个接口,例如 AddImpl 需要实现 AddMinusImpl 需要实现 Minus

CGLib 可以弥补这个缺陷,不需要实现特定的接口。
CGLib 通过继承来实现,动态产生的代理类实际上为委托类的子类,代理类通过 Method Override 实现了代码增强。
例如:

Enhancer e = new Enhancer();
e.setSuperclass(AddImpl.class);
e.setCallback(new MethodInterceptor() {
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        // 预处理,记录日志
        System.out.println(method.getName() + " start");

        return method.invoke(o, objects);
    }
});

// 动态产生的代理类实际上为委托类的子类
AddImpl proxy = (AddImpl)e.create();
proxy.add(1, 2);

关于 CGLib 和 JDK Proxy 的比较,可以参见 Stack Overflow

你可能感兴趣的:(Java 动态代理)