java代理模式

可以对原有的类进行扩展，即可通过代理对象的模式来访问目标对象。

一.静态代理：

需要代理类和目标类实现相同的接口。

例：

public interface Phone {
    void call(String sb);
}

public interface Player {
    void play(String music);
}

public class Iphone implements Phone,Player{
    public void call(String sb){
        System.out.println("I'm calling "+sb);
    }
    public void play(String music){
        System.out.println("I'm playing "+music);
    }
}

public class iphoneProxy implements Phone,Player{
    Iphone iphone;
    public iphoneProxy(Iphone iphone){
        this.iphone=iphone;
    }
    public void call(String sb){
        System.out.println("I'm going to call sb");
        iphone.call(sb);
        System.out.println("I finished my call");
    }
    public void play(String music){
        System.out.println("I'm going to call sb");
        iphone.play(music);
        System.out.println("I closed the player");
    }

    public static void main(String[]args){
        Iphone iphone1=new Iphone();
        iphone1.call("ZhangSan");
        iphone1.play("双截棍");
        System.out.println("--------------------------");
        iphoneProxy proxy1=new iphoneProxy(iphone1);
        proxy1.call("ZhangSan");
        proxy1.play("双截棍");
    }
}

输出结果：

image.png

总结：可以在不修改目标对象功能的前提下对目标对象进行扩展。

缺点：应为代理对象需要与目标对象实现一样的接口，会有很多代理类，同时一旦接口修改，代理类和目标类都需修改。

二.动态代理：

相比与静态代理，每个代理类对应一个接口，若接口方法改变需要同时修改代理类。动态代理只需指定一组目标接口及目标类对象就能在运行时创建代理类对象。

生成代理对象的方法：
1.实现invocationHandler接口，重写invoke方法。在invoke方法中动过反射的方式调用目标类的方法。
2.通过proxy.getProxyClass生成代理类的Class对象，动态生成的Class字节码文件，保存在
3.通过反射动态的获得代理类的构造方法getConstructor(InvocationHandler.class)
4.通过构造函数获得代理类对象。
5.通过代理对象调用目标方法。
如下所示：

public class MyInvocationHandler implements InvocationHandler {
    private Object target;
    public MyInvocationHandler(Object target){
        this.target=target;
    }
    public Object invoke(Object proxy,Method method,Object...args)throws Throwable{
        System.out.println("I'm going to do this");
        Object result=method.invoke(target,args);
        System.out.println("I'm going to end this");
        return result;
    }
    public static void main(String ...args) throws Exception{
        Class<?>[] InterfaceArr={Phone.class,Player.class};
        Class<?> proxyClass=Proxy.getProxyClass(Phone.class.getClassLoader(),InterfaceArr);
        Constructor<?> constructor=proxyClass.getConstructor(InvocationHandler.class);
        Phone iphone1 = (Phone) constructor.newInstance(new MyInvocationHandler(new Iphone()));
        iphone1.call("李四");
    }
}

程序在运行过程中会自动在com.sun.proxy下生成名字为$proxy+数字(从零开始)的class字节码文件，如下：

package com.sun.proxy;

import designPattern.Phone;
import designPattern.Player;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class $Proxy0 extends Proxy implements Phone, Player {
    private static Method m1;
    private static Method m2;
    private static Method m4;
    private static Method m3;
    private static Method m0;

    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
            return ((Boolean)super.h.invoke(this, m1, new Object[]{var1})).booleanValue();
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final void play(String var1) throws  {
        try {
            super.h.invoke(this, m4, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final void call(String var1) throws  {
        try {
            super.h.invoke(this, m3, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final int hashCode() throws  {
        try {
            return ((Integer)super.h.invoke(this, m0, (Object[])null)).intValue();
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[]{Class.forName("java.lang.Object")});
            m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
            m4 = Class.forName("designPattern.Player").getMethod("play", new Class[]{Class.forName("java.lang.String")});
            m3 = Class.forName("designPattern.Phone").getMethod("call", new Class[]{Class.forName("java.lang.String")});
            m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

生成的代理类继承proxy，实现了类与目标类相同的接口，proxy.getProxyClass方法根据参数传入接口，读取接口中定义的方法，其中proxy0中的method0,method1,method2为object 的 hashcode equals和toString方法，其他的为接口中的方法$ proxy0 的父类Proxy定义了调用句柄：protected InvocationHandler h; 通过构造函数传入并初始化。通过super.h.invoke(this, m4, new Object[]{var1});即可通过InvocationHandler来调用目标类的函数。
InvocationHandler为核心，每个代理类的实例都有一个InvocationHandler属性，对代理实例调用方法时，将对方法调用进行编码并委派到他的调用处理程序InvocationHandler的invoke方法中，所有代理方法的调用都是通过invoke方法来实现的，invoke方法根据传入的method对象和参数列表决定调用代理的哪个方法。