Java设计模式 - 静态代理和动态代理

代理模式（proxy pattern）

定义

被代理类对象的方法调用交给了代理类来调用。

特点

1.静态代理类把接口写死，只能代理实现了代理类接口的被代理类。
2.动态代理利用了反射方法实现拥有不同接口的被代理类的代理。

一般写法

用代理2个类来体会下静态代理和动态代理的优缺点。

public interface MyInterface1 {
    String print1();
}

public interface MyInterface2 {
    String print2();
}

/**
 * 被代理类1
 */
public class MyClass1 implements MyInterface1 {
    @Override
    public String print1() {
        return "1";
    }
}

/**
 * 被代理类2
 */
public class MyClass2 implements MyInterface2 {
    @Override
    public String print2() {
        return "2";
    }
}

静态代理工厂

/**
 * 静态代理工厂
 * 相较于动态代理工厂 {@link ProxyFactory}，接口写死了，
 * 只能代理实现了{@link MyInterface1}的类
 */
public class Class1ProxyFactory implements MyInterface1 {
    private MyInterface1 myInterface1;

    // 把被代理类传进来
    public Class1ProxyFactory(MyInterface1 myInterface1) {
        this.myInterface1 = myInterface1;
    }

    @Override
    public String print1() {
        return myInterface1.print1();
    }
}

动态代理工厂，利用了反射

import java.lang.reflect.Proxy;

/**
 * 动态代理工厂类
 */
public class ProxyFactory {
    /**
     * 获取代理类对象
     *
     * @param object 被代理对象
     * @return 代理类对象
     */
    public static Object getProxyInstance(Object object) {
        MyInvocationHandler myInvocationHandler = new MyInvocationHandler();

        // 把被代理对象进行绑定
        myInvocationHandler.bind(object);

        // 此处利用了反射的方法
        return Proxy.newProxyInstance(object.getClass().getClassLoader(), object.getClass().getInterfaces(), myInvocationHandler);
    }
}

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

public class MyInvocationHandler implements InvocationHandler {
    private Object object;

    /**
     * 用于绑定被代理类对象
     *
     * @param object 被代理类对象
     */
    public void bind(Object object) {
        this.object = object;
    }

    @Override
    public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
        return method.invoke(object, objects);
    }
}

测试结果

/**
 * 测试
 */
public class Main {
    public static void main(String[] args) {
        MyClass1 myClass1 = new MyClass1();
        MyClass2 myClass2 = new MyClass2();

        // 动态代理，可代理实现不同接口的类
        // 通过被代理对象获取代理对象，进而代理对象可以调用到被代理对象的方法
        MyInterface1 proxyInstance1 = (MyInterface1) ProxyFactory.getProxyInstance(myClass1);
        System.out.println(proxyInstance1.print1());

        MyInterface2 proxyInstance2 = (MyInterface2) ProxyFactory.getProxyInstance(myClass2);
        System.out.println(proxyInstance2.print2());

        // 静态代理
        Class1ProxyFactory class1ProxyFactory = new Class1ProxyFactory(myClass1);
        System.out.println(class1ProxyFactory.print1());
    }
}

1
2
1