設計模式—結構型模式之代理模式

代理模式(Proxy Pattern) ,給某一個對象提供一個代理，並由代理對象控制對原對象的引用,對象結構型模式。

靜態代理

比如我們有一個直播平臺，提供了直播功能，但是如果不進行美顏，可能就比較冷清。所以美顏功能就是我們的增強，可以用靜態代理來實現。

直播介面：

/**
 * 直播介面
 */
public interface LiveBroadCastInterface {
    void liveBroadcast();
}

直播類：

/**
 * 實現直播介面
 */
public class SjdwzLiveBroadCast implements LiveBroadCastInterface{
    @Override
    public void liveBroadcast() {
        System.out.println("我來直播了......");
    }
}

如果沒有美顏，可能就會比較冷清；所以我們可以提供一個靜態代理，來為我們的直播進行增強。

要代理的功能類要和原類型實現相同的介面。

public class SjdwzStaticProxy implements  LiveBroadCastInterface{
    
    private LiveBroadCastInterface liveBroadCastInterface;

    public SjdwzStaticProxy(LiveBroadCastInterface liveBroadCastInterface) {
        this.liveBroadCastInterface = liveBroadCastInterface;
    }

    @Override
    public void liveBroadcast() {
        System.out.println("這是代理的功能");
        System.out.println("美顏--------");
        System.out.println("=========原功能如下=========");
        this.liveBroadCastInterface.liveBroadcast();
    }
}

測試類如下：

public class StaticSjdwzProxyTest {
    public static void main(String[] args) {
        SjdwzStaticProxy sjdwzStaticProxy = new SjdwzStaticProxy(new SjdwzLiveBroadCast());
        sjdwzStaticProxy.liveBroadcast();
    }
}

運行如下：

jdk動態代理

還是上面的例子，可以使用JDK的動態代理來實現：

/**
 * 實現InvocationHandler的作用是為了在本類實現增強方法，
 * @param <T> 要代理對象實現的介面
 */
public class JdkLiveBroadCastProxy<T> implements InvocationHandler {

    //被代理對象
    private T target;

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

    public static<T> T getProxy(T t){
        /**
         * ClassLoader loader, 當前被代理對象的類載入器
         * Class<?>[] interfaces, 當前被代理對象所實現的所有介面
         * InvocationHandler h,
         *  當前被代理對象執行目標方法的時候我們使用h可以定義攔截增強方法
         */
        Object o = Proxy.newProxyInstance(
                t.getClass().getClassLoader(),
                t.getClass().getInterfaces(), //必須介面
                new JdkLiveBroadCastProxy(t));
        return (T)o;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("這是代理的一些功能======");
        System.out.println("原本的功能===========");
        //反射執行
        Object invoke = method.invoke(this.target, args);
        System.out.println("返回值："+invoke);
        return invoke;
    }
}

測試類如下：

public class JdkLiveBroadCastProxyTest {
    public static void main(String[] args) {
        LiveBroadCastInterface proxy = JdkLiveBroadCastProxy.getProxy(new SjdwzLiveBroadCast());
        proxy.liveBroadcast();
    }
}

運行結果如下：

要求

JDK要求被代理對象必須有介面，因為必須有介面才能告訴代理有哪些方法。

cglib動態代理

我們發現，如果使用JDK的動態代理，必須實現介面。cglib動態代理是不需要實現介面的。

首先我們在項目的pom文件中引入依賴：

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.3.0</version>
</dependency>

cglib動態代理類如下：

public class CglibProxy {

    //為任意對象創建代理
    public static<T> T createProxy(T t){
        //1、創建一個增強器
        Enhancer enhancer = new Enhancer();

        //2、設置要增強哪個個類的功能。增強器為這個類動態創建一個子類
        enhancer.setSuperclass(t.getClass());

        //3、設置回調
        enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object obj,
                                    Method method,  //為了能獲取到原方法的一些元數據信息
                                    Object[] args,
                                    MethodProxy proxy) throws Throwable {
                //編寫增強的邏輯
                System.out.println("cglib的動態代理增強的功能===========");
                System.out.println("原功能===========");
                //目標方法進行執行
                Object invoke = proxy.invokeSuper(obj,args);
                return invoke;
            }
        });

        Object o = enhancer.create();
        return (T) o;
    }

}

測試類如下：

public class MyCglibProxyTest {
    public static void main(String[] args) {
        SjdwzLiveBroadCast proxy = CglibProxy.createProxy(new SjdwzLiveBroadCast());
        proxy.liveBroadcast();
    }
}

運行截圖如下：