java代理模式

1.概念

为其他对象提供一个代理以控制对这个对象的访问；即通过代理对象访问目标对象。

2.适用性

优点:可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能。
不要随意修改已写好的代码或者方法，而是通过代理的方式来扩展。

3.结构

4.分类

4.1静态代理

定义一个接口或者父类，被代理对象与代理对象一起实现相同的接口或者继承相同父类。

/**
 * 接口
 */
public interface IDrive {
       void drive();
}

/**
 * 目标对象
 */
public class Boss implements IDrive {
      @Override
      public void drive() {
            System.out.println("----老板开车!----");
      }
}

/**
 * 代理对象，静态代理
 */
public class DriverProxy implements IDrive {
      // 接收保存目标对象
      private IDrive iDrive；
      public DriverProxy(IDrive iDrive){
        this.iDrive = iDrive;
      }

      @Override
      public void drive() {
            System.out.println("----司机开车!----");
      }
}

/**
 * 测试类
 */
public class Test {
    public static void main(String[] args) {
        // 目标对象
        Boss target = new Boss();

        // 代理对象,把目标对象传给代理对象,建立代理关系
        DriverProxy proxy = new DriverProxy(target);

        // 司机来开车
        proxy.drive(); // 执行的是代理的方法
    }
}

优点：可以在不修改目标对象的情况下，对目标功能进行扩展
缺点：一旦接口增加方法，目标对象和代理对象都要修改,代理对象一旦多，会很麻烦

4.2动态代理

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

JDK中生成代理对象的API

代理类所在包:java.lang.reflect.Proxy
JDK实现代理只需要使用newProxyInstance方法,但是该方法需要接收三个参数,完整的写法是:

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

注意该方法是在Proxy类中是静态方法,且接收的三个参数依次为:

• ClassLoader loader : 指定当前目标对象使用类加载器,获取加载器的方法是固定的
• Class

/**
 * 创建动态代理对象
 * 动态代理不需要实现接口,但是需要指定接口类型
 */
public class ProxyFactory{

    // 维护一个目标对象
    private IDrive target;
    private ProxyFactory(IDrive target){
        this.target=target;
    }

    public static ProxyFactory createProxyInstance(IDrive target) {
        return new ProxyFactory(target);
    }

   // 给目标对象生成代理对象
    public IDrive create(){
        return (IDrive) Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        // 执行目标对象方法
                        Object returnValue = method.invoke(target, args);
                        return returnValue;
                    }
                }
        );
    }

}

/**
 * 测试类2
 */
public class Test2 {
    public static void main(String[] args) {
        // 目标对象
        IDriver target = new Boss();
        System.out.println(target.getClass());

        // 给目标对象，创建代理对象
        IDriver proxy = ProxyFactory.createProxyInstance(target).create();
        // class $Proxy0   内存中动态生成的代理对象
        System.out.println(proxy.getClass());

        // 执行方法   【代理对象】
        proxy.driver();
    }
}

代理对象不需要实现接口，比较灵活。
接口不能被创建出实例，通过动态代理的话可以创建出代理对象 （例：Retrofit）。