Ein Beispiel dafür, wie Java das Proxy-Muster im Entwurfsmuster verwendet, um ein Projekt zu erstellen

Konzept

Proxy-Modus (Proxy): Der Proxy-Modus ist eigentlich eine zusätzliche Proxy-Klasse, die einige Vorgänge im Namen des Originalobjekts ausführt. Manchmal müssen wir beispielsweise einen Anwalt beauftragen, wenn wir vor Gericht gehen, weil Anwälte über Rechtskompetenz verfügen und unsere Ideen in unserem Namen zum Ausdruck bringen können. Der Proxy-Modus ist in zwei Kategorien unterteilt: 1. Statischer Proxy (verwendet nicht die Methoden in JDK); 2. Dynamischer Proxy (verwendet InvocationHandler und Proxy in JDK).
Statische Proxys werden von Programmierern oder Tools erstellt, die den Quellcode der Proxy-Klasse generieren und dann die Proxy-Klasse kompilieren. Die sogenannte Statik bedeutet, dass die Bytecode-Datei der Proxy-Klasse bereits vor der Ausführung des Programms vorhanden ist und die Beziehung zwischen der Proxy-Klasse und der Delegate-Klasse vor der Ausführung bestimmt wird.
Der Quellcode der dynamischen Proxy-Klasse wird von der JVM dynamisch generiert, basierend auf Mechanismen wie der Reflektion während der Programmausführung, sodass es keine Bytecode-Datei für die Proxy-Klasse gibt. Die Beziehung zwischen der Proxy-Klasse und der Delegate-Klasse wird bei der Ausführung des Programms bestimmt.

Beispiel
Hier geben wir ein Beispiel für einen statischen Proxy:
Klassendiagramm:

/**
 * 游戏者接口
 *
 */
public interface IGamePlayer {

  // 登录游戏
  public void login(String user, String password);

  // 杀怪，网络游戏的主要特色
  public void killBoss();

  // 升级
  public void upgrade();

}

/**
 * 游戏者
 *
 */
public class GamePlayer implements IGamePlayer {

  private String name = "";

  // 通过构造函数传递名称
  public GamePlayer(String _name) {
    this.name = _name;
  }

  // 打怪，最期望的就是杀老怪

  public void killBoss() {

    System.out.println(this.name + " 在打怪！");

  }

  // 进游戏之前你肯定要登录吧，这是一个必要条件
  public void login(String user, String password) {
    System.out.println("登录名为" + user + " 的角色 " + this.name + "登录成功！");
  }

  // 升级，升级有很多方法，花钱买是一种，做任务也是一种
  public void upgrade() {
    System.out.println(this.name + " 又升了一级！");
  }

}

/**
 * 客户端 对被代理对象不可见
 */
public class GamePlayerProxy implements IGamePlayer {

  private IGamePlayer gamePlayer = null;//被代理对象

  // 通过构造函数传递要对谁进行代练
  public GamePlayerProxy(String username) {
    this.gamePlayer = new GamePlayer(username);
  }

  // 代练杀怪
  public void killBoss() {
    this.gamePlayer.killBoss();
  }

  // 代练登录
  public void login(String user, String password) {
    this.gamePlayer.login(user, password);
  }

  // 代练升级
  public void upgrade() {
    this.gamePlayer.upgrade();
  }

}

/*
 * 客户端 对被代理对象不可见
 */
public class GamePlayerProxy2 implements IGamePlayer {

  private IGamePlayer gamePlayer = null;//被代理对象

  // 通过构造函数传递要对谁进行代练
  public GamePlayerProxy2(String username) {
    this.gamePlayer = new GamePlayer(username);
  }

  // 代练杀怪
  public void killBoss() {
    this.gamePlayer.killBoss();
  }

  // 代练登录
  public void login(String user, String password) {
    System.out.println("登录时间是：" + new Date().toLocaleString());
    this.gamePlayer.login(user, password);
  }

  // 代练升级
  public void upgrade() {
    this.gamePlayer.upgrade();
    System.out.println("升级时间是：" + new Date().toLocaleString());
  }

}

/*
 * 客户端 对被代理对象不可见
 */
public class GamePlayerProxy3 {

  private IGamePlayer gamePlayer;
  // 通过构造函数传递 被代练(代理)对象
  public GamePlayerProxy3(IGamePlayer gamePlayer) {
     this.gamePlayer = gamePlayer;
     System.out.println("我是一名代练,我玩的角色是别人的，可以动态传递进来");
  }

  public IGamePlayer getProxy() {
    return (IGamePlayer) Proxy.newProxyInstance(this.getClass().getClassLoader(),
        new Class[]{IGamePlayer.class}, new MyInvocationHandler());
  }

  private class MyInvocationHandler implements InvocationHandler {

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
      if (method.getName().equals("login")) {
        System.out.println("登录时间是：" + new Date().toLocaleString());
      } if (method.getName().equals("upgrade")) {
        System.out.println("升级时间是：" + new Date().toLocaleString());
      }
      method.invoke(gamePlayer, args);
      return null;
    }

  }
}

public class Test {
  public static void main(String[] args) {
    /*
     * 普通的静态代理: 客户端不知道被代理对象，由代理对象完成其功能的调用
     */
    IGamePlayer proxy = new GamePlayerProxy("X");
    System.out.println("开始时间是：" + new Date().toLocaleString());
    proxy.login("zhangSan", "abcd");
    proxy.killBoss();
    proxy.upgrade();
    System.out.println("结束时间是：" + new Date().toLocaleString());

    System.out.println();

    /*
     * 代理对象 增强了 被代理对象的功能
     */
    IGamePlayer proxy2 = new GamePlayerProxy2("M");
    proxy2.login("lisi", "efg");
    proxy2.killBoss();
    proxy2.upgrade();

    System.out.println();

    /*
     * 动态代理：使用jdk提供的InvocationHandler，反射调用被代理对象的方法
     * 结合java.reflect.Proxy 产生代理对象
     * 动态传入被代理对象构造InvocationHandler,在handler中的invoke时可以增强被代理对象的方法的功能
     * 或者说：(面向切面:)在什么地方（连接点）, 执行什么行为（通知）
     * GamePlayerProxy3中是方法名为login时通知开始时间，upgrade时通知结束时间
     */
    GamePlayerProxy3 dynamic = new GamePlayerProxy3(new GamePlayer("Y"));
    IGamePlayer dynamicPlayer = dynamic.getProxy();
    dynamicPlayer.login("wangwu", "1234");
    dynamicPlayer.killBoss();
    dynamicPlayer.upgrade();
    /*
     * 面向切面： 一些相似的业务逻辑需要加在众多的地方，那们就可以把它提取到切面中， 切面也就是事务切面:如日志切面、权限切面、业务切面
     */
  }
}

Drucken:

开始时间是：2014-10-8 17:19:05
登录名为zhangSan 的角色 X登录成功！
X 在打怪！
X 又升了一级！
结束时间是：2014-10-8 17:19:05

登录时间是：2014-10-8 17:19:05
登录名为lisi 的角色 M登录成功！
M 在打怪！
M 又升了一级！
升级时间是：2014-10-8 17:19:05

我是一名代练,我玩的角色是别人的，可以动态传递进来
登录时间是：2014-10-8 17:19:05
登录名为wangwu 的角色 Y登录成功！
Y 在打怪！
升级时间是：2014-10-8 17:19:05
Y 又升了一级！

Vorteile
(1) Klare Verantwortlichkeiten
Die eigentliche Aufgabe besteht darin, die eigentliche Geschäftslogik zu implementieren, und das ist nicht nötig Sorgen Sie sich um andere Angelegenheiten, die nicht in Ihren Verantwortungsbereich fallen. Eine abgeschlossene Transaktion wird durch den späteren Agenten abgeschlossen, und das damit verbundene Ergebnis ist eine einfache und klare Programmierung.
(2) Das Proxy-Objekt kann eine Vermittlerrolle zwischen dem Client und dem Zielobjekt spielen, was eine Rolle beim Schutz des Zielobjekts spielt.
(3) Hohe Skalierbarkeit

Weitere Beispiele dafür, wie Java das Proxy-Muster in Entwurfsmustern zum Erstellen von Projekten verwendet, finden Sie auf der chinesischen PHP-Website für verwandte Artikel!