设计模式-代理模式（Proxy Pattern）

lei838016
1,824 阅读5分钟

Github 源码地址

23种设计模式总览

创建型模式

结构型模式

行为型模式

定义

为其他对象提供一种代理以控制对这个对象的访问

按照代理的创建时期，代理类可以分为两种： 

  • 静态代理：由程序员创建代理类或特定工具自动生成源代码再对其编译。在程序运行前代理类的.class文件就已经存在了。

  • 动态代理：在程序运行时运用反射机制动态创建而成。

优缺点

优点：  1、职责清晰。 2、高扩展性。 3、智能化。

缺点：  1、由于在客户端和真实主题之间增加了代理对象，因此有些类型的代理模式可能会造成请求的处理速度变慢。 2、实现代理模式需要额外的工作，有些代理模式的实现非常复杂。

使用场景

主要作用：控制对象访问

  • 扩展目标对象的功能：例如演员（目标对象），有演戏的功能，找一个经纪人（代理），会额外提供收费的功能，实际上是代理的功能，而不是演员的功能。
  • 限制目标对象的功能：例如经纪人对收费不满意，只让演员演一场戏，对演员的功能进行了部分限制。

类图

  • Subject：抽象主题角色，主要是声明代理类和被代理类共同的接口方法
  • RealSubject：具体主题角色（被代理角色），执行具体的业务逻辑
  • Proxy：代理类，持有一个被代理对象的引用，负责在被代理对象方法调用的前后做一些额外操作

静态代理

编译时期就已经存在，一般首先需要定义接口，而被代理的对象和代理对象一起实现相同的接口。

1、接口定义：

public interface Play {
  //唱歌
  void sing(int count);
  //演出
  void show();
}

2、演员（被代理对象）：

public class Actor implements Play {
  @Override
  public void sing(int count) {
    System.out.print("唱了" + count + "首歌");
  }

  @Override
  public void show() {
    System.out.print("进行演出");
  }
}

被代理对象提供了几个具体方法实现

3、经纪人（代理对象）：

public class Agent implements Play {
  //被代理对象
  private Play player;
  private long money;

  public void setMoney(long money){
    this.money = money;
  }

  /**
   * @param player
   * @param money 收费
   */
  public Agent(Play player, long money) {
    this.player = player;
    this.money = money;
  }

  @Override
  public void sing(int count) {
    player.sing(count);
  }
  //控制了被代理对象的访问
  @Override
  public void show() {
    if (money > 100) {
      player.show();
    } else {
      System.out.println("baibai...");
    }
  }
}

4、使用

public class PlayTest {
  public static void main(String[] args){
    Actor actor = new Actor();
    Agent agent = new Agent(actor, 50);
    agent.sing(2);
    agent.show();
    agent.setMoney(200);
    agent.show();
  }
}

代理对象通过自身的逻辑处理对目标对象的功能进行控制。

动态代理

动态一般指的是在运行时的状态，是相对编译时的静态来区分，就是在运行时生成一个代理对象帮我们做一些逻辑处理。主要使用反射技术获得类的加载器并且创建实例。
动态代理可以在运行时动态创建一个类，实现一个或多个接口，可以在不修改原有类的基础上动态为通过该类获取的对象添加方法、修改行为。

1、生成动态代理类：

InvocationHandler是动态代理接口，动态代理类需要实现该接口，并在invoke方法中对代理类的方法进行处理

public interface InvocationHandler {
  public Object invoke(Object proxy, Method method, Object[] args)
      throws Throwable;
}

参数说明：

  • Object proxy：被代理的对象
  • Object[] args：要调用的方法
  • Object[] args：方法调用所需要的参数

2、创建动态代理类

Proxy类可以通过newProxyInstance创建一个代理对象

public static Object newProxyInstance(ClassLoader loader,
    Class<?>[] interfaces,
    InvocationHandler h)
    throws IllegalArgumentException {
  if (h == null) {
    throw new NullPointerException();
  }  
  Class<?> cl = getProxyClass0(loader, interfaces);
  try {
    //通过反射完成了代理对象的创建
    final Constructor<?> cons = cl.getConstructor(constructorParams);
    return newInstance(cons, h);
  } catch (NoSuchMethodException e) {
    throw new InternalError(e.toString());
  }
}

参数说明：

  • ClassLoader loader：类加载器
  • Class<?>[] interfaces：所有的接口
  • InvocationHandler h：实现InvocationHandler接口的子类

3、动态代理demo：

（1）定义动态代理类

public class ActorProxy implements InvocationHandler {
    private Play player;

    public ActorProxy(Play player) {
        this.player = player;
    }

    /**
     * 获取动态代理对象
     */
    public Object getDynamicProxy() {
        return Proxy.newProxyInstance(player.getClass().getClassLoader(), player.getClass().getInterfaces(), this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //处理被代理对象的方法实现
        if ("show".equals(method.getName())) {
            System.out.println("代理处理show....");
            return method.invoke(player, null);
        } else if ("sing".equals(method.getName())) {
            System.out.println("代理处理sing....");
            return method.invoke(player, 2);
        }
        return null;
    }
}

代理类实现InvocationHandler接口，在invoke方法中对player（被代理对象）做相应的逻辑处理。

（2）使用

public class ProxyTest {

    public static void main(String[] args) {

        ActorProxy actorProxy = new ActorProxy(new Actor());
        //通过调用Proxy.newProxyInstance方法生成代理对象
        Play proxy = (Play) actorProxy.getDynamicProxy();
        //调用代理类相关方法
        proxy.show();
        proxy.sing(3);
    }
}

四、Android中的代理模式

Retrofit代理模式

（1）Retrofit使用： 定义接口

public interface MyService {
    @GET("users/{user}/list")
    Call<String> getMyList(@Path("user") String user);
}

新建retrofit对象，然后产生一个接口对象，然后调用具体方法去完成请求。

Retrofit retrofit = new Retrofit.Builder()
            .baseUrl("http://xxx.com")
            .build();
MyService myService = retrofit.create(MyService.class);
Call<String> myList = myService.getMyList("my");

retrofit.create方法就是通过动态代理的方式传入一个接口，返回了一个对象

（2）动态代理分析：

public <T> T create(final Class<T> service) {
  //判断是否为接口
  Utils.validateServiceInterface(service);
  if (validateEagerly) {
    eagerlyValidateMethods(service);
  }
  //创建请求接口的动态代理对象
  return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class<?>[] { service },
      new InvocationHandler() {
        private final Platform platform = Platform.get();
        private final Object[] emptyArgs = new Object[0];

        @Override public Object invoke(Object proxy, Method method, @Nullable Object[] args)
            throws Throwable {
          // If the method is a method from Object then defer to normal invocation.
          if (method.getDeclaringClass() == Object.class) {
            return method.invoke(this, args);
          }
          if (platform.isDefaultMethod(method)) {
            return platform.invokeDefaultMethod(method, service, proxy, args);
          }
          //将接口中方法传入返回了ServiceMethod
          return loadServiceMethod(method).invoke(args != null ? args : emptyArgs);
        }
      });
}

通过Proxy.newProxyInstance，该动态代理对象可以拿到请求接口实例上所有注解，然后通过代理对象进行网络请求。

avatar
文章
阅读
粉丝