Java设计模式(三) -- 代理模式

        代理是一种设计模式，即通过代理对象访问目标对象，这样可以在目标对象实现的基础上，增强额外的功能，即扩展目标类的功能。

        通常编程中存在一种思想,即不要随意修改别人的代码或者方法，所以代理就可以在不修改目标代码的基础上扩展该目标类。代理模式的关键点在于代理对象和目标对象。代理对象对目标对象进行扩展，并会调用目标对象。

        代理模式包含几个角色:

        Subject:    一个接口，是代理对象和目标对象公共的接口

        RealSubject:    目标对象。实现接口的类。

        Proxy：    代理对象，包含对目标对象的引用，进而操作目标对象。代理对象包含和目标对象对接口一样的操作，同时还会附加其他操作，相当于对目标对象的进一步封装。

        

 1.静态代理

        静态代理在使用时,需要定义接口或者父类,被代理对象与代理对象一起实现相同的接口或者是继承相同父类.

         代码示例:

         接口:             

public interface Image {
    void display();
}

       目标类：

public class RealImage implements Image{

    @Override
    public void display() {
        System.out.println("这是一张漂亮的图片");
    }
}

       代理类:

public class ProxyImage implements Image{

    //接收保存目标对象
    private Image img;

    public ProxyImage(Image img) {
        this.img = img;
    }

    @Override
    public void display() {
        System.out.println("打开图片");
        img.display();
        System.out.println("关闭图片");
    }
}

        测试：

    

public class Main {
    public static void main(String args[]){
        RealImage image = new RealImage();
        ProxyImage proxyImage = new ProxyImage(image);
        proxyImage.display();
    }
}

结果：

        静态代理可以做到不修改目标对象的前提下对目标对象扩展，但是静态代理有个缺点：代理对象需要和目标对象实现一样的接口，所以会有很多代理类，类太多。同时，一旦接口增加方法，目标对象与代理对象都要维护。

    2.动态代理

        动态代理有以下特点：

            1.代理对象,不需要实现接口
               2.代理对象的生成,是利用JDK的API,动态的在内存中构建代理对象(需要我们指定创建代理对象/目标对象实现的接口的类型)

               3.动态代理也叫做:JDK代理,接口代理

        动态代理的关键是反射

        JDK中生成代理对象的API

        代理类所在包:java.lang.reflect.Proxy

        JDK实现代理只需要使用newProxyInstance方法,但是该方法需要接收三个参数,完整的写法是:

static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler h )

        实例代码：

        接口类和目标对象类都不变，在此基础上增加一个代理工厂类，在Main类中建立目标对象和代理对象的联系,然后代用代理对象的中同名方法

        代理工厂类：

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

/**
 * 创建动态代理对象
 * 动态代理不需要实现接口，但是需要知道接口的类型
 */
public class ProxyFactory {

    private Object object;

    public ProxyFactory(Object object) {
        this.object = object;
    }

    //给目标对象生成代理对象
    public Object getProxyInstance() {
        return Proxy.newProxyInstance(object.getClass().getClassLoader(), object.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println(" --- start --- ");
                        Object value = method.invoke(object, args);
                        System.out.println(" --- end --- ");
                        return object;
                    }
                });
    }
}

        Main类:

public class Main {
    public static void main(String args[]){
        // 目标对象
        Image img = new RealImage();
        System.out.println(img.getClass());

        // 给目标对象，创建代理对象
        Image proxy = (Image) new ProxyFactory(img).getProxyInstance();
        System.out.println(proxy.getClass());
        proxy.display();
    }
}

结果：

    

代理对象不需要实现接口,但是目标对象一定要实现接口,否则不能用动态代理