java代理的原理及應用

什么是代理模式？

　　定義

　　　　為其他對象提供一種代理以控制對這個對象的訪問。在某些情況下，一個對象不適合或者不能直接引用另一個對象，而代理對象可以在客戶端和目標對象之間起到中介的作用。

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　——百度百科

　　代理模式的角色

　　抽象角色：代理對象和真實對象的共同接口

　　代理角色：代理對象角色內部含有對真實對象的引用，從而可以操作真實對象，同時代理對象提供與真實對象相同的接口以便在任何時刻都能夠代替真實對象。同時，代理對象可以在執行真實對象操作時，附加其他的操作，相當于對真實對象進行封裝。

　　真實角色：代理角色所代表的真實對象，是我們最終要引用的對象。

　　示意圖

　　　　

代理模式的分類及使用

• 靜態代理

package staticProxy;

// 抽象角色，真是對象與代理對象的共同接口
public interface Subject {
    public void request();
}

package staticProxy;

//代理對象，用來被客戶端直接調用的類，內部被注入真實對象，可以在調用真是對象的方法前后做預處理和后處理
public class ProxyClass implements Subject {
    
    Subject subject;
    
    ProxyClass (Subject subject) {
        this.subject = subject;
    }

    @Override
    public void request() {
        System.out.println("prefix-process!");
        subject.request();
        System.out.println("suffix-process!");
    }

}

package staticProxy;

//真實對象，委托類
public class RealClass implements Subject {

    @Override
    public void request() {
        System.out.println("I'm realClass!");
    }

}

package staticProxy;

//客戶端
public class StaticProxy {
    public static void main(String[] args) {
        Subject subject = new ProxyClass(new RealClass());
        
        subject.request();
    }
}

　　　　靜態代理的缺點很顯著，對每一個委托類都需要創建一個代理類，為了解決這個問題，java提供了動態代理。

• 動態代理

　　　　抽象角色與真實角色的定義和靜態代理完全一致，這里不再重復定義

　　　　動態代理類需要繼承自InvocationHandler接口，并實現其中的invoke方法。

package dynamicProxy;

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

public class ProxyClass implements InvocationHandler {

    Object subject;
    
    public ProxyClass(Object subject) {
        this.subject = subject;
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("prefix-process!");
        method.invoke(subject, args);
        System.out.println("suffix-process!");
        return null;
    }

}

package dynamicProxy;

import java.lang.reflect.Proxy;

public class DynamicProxy {
    public static void main(String[] args) {
        
        Subject subject = (Subject) Proxy.newProxyInstance(RealClass.class.getClassLoader(),
                new Class[] {Subject.class}, new ProxyClass(new RealClass()));
        
        subject.request();
    }
}

動態代理的實現原理

動態代理的實現主要依賴于java.lang.reflect.InvocationHandler接口與java.lang.reflect.Proxy類，其實現原理是基于java的反射技術。

InvocationHandler接口

　　　　動態代理類需要繼承自InvocationHandler接口，此接口中只包含一個方法invoke方法，接口原型如下：

package java.lang.reflect;

public interface InvocationHandler {

    /**
     * proxy：代表代理對象本身，用于調用本代理對象的其他方法
     * method：代表正在被調用的委托類的方法
     * args：代表調用方法的參數
     */
    public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable;
}

Proxy類

　　　　Proxy類中定義了很多的方法，但根據上面動態代理的應用我們看到，最重要的一個方法就是newProxyInstance方法，該方法的作用就是動態創建一個代理類對象：

    /**
     * loader代表了委托類的類加載器
     * interfaces代表了委托類的接口數組
     * h代表委托類的實例
     */
    @CallerSensitive
    public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
        // 判斷委托類實例是否為空，如果未空拋異常
        Objects.requireNonNull(h);

        final Class<?>[] intfs = interfaces.clone();
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
        }

        /*
         * 獲取獲取代理類的Class實例
         */
        Class<?> cl = getProxyClass0(loader, intfs);

        /*
         * Invoke its constructor with the designated invocation handler.
         */
        try {
            if (sm != null) {
                checkNewProxyPermission(Reflection.getCallerClass(), cl);
            }

            //獲取代理類的Constructor對象
            final Constructor<?> cons = cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            if (!Modifier.isPublic(cl.getModifiers())) {
                AccessController.doPrivileged(new PrivilegedAction<Void>() {
                    public Void run() {
                        cons.setAccessible(true);
                        return null;
                    }
                });
            }

            //利用反射原理中使用constructor動態創建動態代理類型
            return cons.newInstance(new Object[]{h});
        } catch (IllegalAccessException|InstantiationException e) {
            throw new InternalError(e.toString(), e);
        } catch (InvocationTargetException e) {
            Throwable t = e.getCause();
            if (t instanceof RuntimeException) {
                throw (RuntimeException) t;
            } else {
                throw new InternalError(t.toString(), t);
            }
        } catch (NoSuchMethodException e) {
            throw new InternalError(e.toString(), e);
        }
    }

動態代理的應用場景

　　動態代理最著名的應用場景就是spring中的aop