Exemples de modèle de proxy et de modèle de décoration en Java

Cet article présente principalement le mode proxy et le mode décoration des modèles de conception Java. Il analyse les concepts, les fonctions, les méthodes d'implémentation Java et les précautions d'utilisation associées du mode proxy et du mode décoration avec des exemples spécifiques. suivant

Les exemples de cet article décrivent le mode proxy et le mode de décoration des modèles de conception Java. Partagez-le avec tout le monde pour votre référence, les détails sont les suivants :

La raison pour laquelle je parle de ces deux modes ensemble est parce que j'ai trouvé que ces deux modes sont presque identiques !

J'ai également recherché des informations sur Internet et découvert qu'il existe des différences entre les deux. Nous avons également clarifié cette confusion en étudiant.

Définition :

Le modèle de proxy fournit un proxy pour d'autres objets afin de contrôler l'accès à cet objet.

Le mode Décorateur ajoute dynamiquement des responsabilités supplémentaires à un objet.

Le mode proxy est facile à comprendre. Il s'agit d'encapsuler à nouveau un objet, puis d'accéder à l'objet encapsulé.

Parce que l'objet proxy a remplacé l'objet proxy.

Le mode Décoration ajoute des fonctions à un objet. L'image, c'est comme se tenir à l'écart en tant que serveur pour fournir des services.

La différence fondamentale est donc que l'objet en mode décoration est toujours là, ne remplaçant pas l'objet d'origine, mais fournissant des services à côté.

Les opinions exprimées dans cet article sont des interprétations personnelles et j'en suis seul responsable.

Ce qui suit est un exemple :

package test.design.proxydecorator;
/**
 * 接口定义行为：吃饭
 * @author lushuaiyin
 *
 */
public interface Eatable {
  void eatFood();
}

package test.design.proxydecorator;
/**
 * 实现类
 * @author lushuaiyin
 *
 */
public class Man implements Eatable{
  @Override
  public void eatFood() {
    System.out.println("I am eating food! Happy!");
  }
}

Ce qui précède est l'interface et la mise en œuvre communes , ci-dessous est une instance de modèle

Modèle de proxy

package test.design.proxydecorator;
/**
 * 代理模式
 * 代理对象把被代理对象封装，像一个包装盒把被代理对象包裹起来。
 * 它不改变被代理对象的原有逻辑，只是增加来了一些自己的服务，像一个代理一样。
 * 代理从使用上给调用者的感觉就是你已经取代了原来的对象。
 * 就像皇太后取代小皇帝实行垂帘听政。
 * @author Administrator
 *
 */
public class ProxyMan implements Eatable{
  private Eatable eatable;
  public ProxyMan(){
    System.out.println("proxy: I am proxy object. I will help you create a object of Man that wnt to be proxyed");
    this.eatable=new Man();
    //注意代理对象把被代理对象封装，在内部有实际的被代理对象，这个调用者是不知道的。
  }
  @Override
  public void eatFood() {
    //代理对象把被代理对象的功能封装，蛋不改变其内部逻辑，只是增加一些服务。
    System.out.println("proxy: I know you are hungry,so I cook for you some food.");
    this.eatable.eatFood();
    System.out.println("proxy: Now you eat up food. Let me help you clean the dishes.");
  }
}

Modèle de décoration

package test.design.proxydecorator;
/**
 * 装饰的抽象.
 * 也可以不用抽象类，简单的父类也可以，只要实现装饰功能.
 * 抽象只是为了增加一层封装，规定装饰者必有的装饰功能而已。
 * @author lushuaiyin
 *
 */
public abstract class DecoratorMan {
  protected Eatable eatable;
  //使用构造函数或者set方法（或其他方法）把接口对象传入。
  //注意，必须保证这个对象的传入，最好还是用构造函数。
  public DecoratorMan(Eatable eatable){
    this.eatable=eatable;
  }
  public void eatFood(){
    this.eatable.eatFood();
  };
}

package test.design.proxydecorator;
/**
 * 装饰模式
 * 装饰对象时独立于原来的对象的。它和被装饰的对象有关系，但是是独立的对象。
 * 装饰对象更像一个酒店服务生，为别人提供服务，所以他还是他自己，他有自己的实际存在。
 * @author lushuaiyin
 *
 */
public class Decorator extends DecoratorMan{
  public Decorator(Eatable eatable) {
    super(eatable);
  }
  //重写父类方法
  public void eatFood(){
    decoratorServiceCookFood();//装饰的具体行为
    super.eatable.eatFood();
    decoratorServiceCleanDishes();//装饰的具体行为
  };
  public void decoratorServiceCookFood(){
    System.out.println("Decorator: I know you are hungry,so I cook for you some food.");
  }
  public void decoratorServiceCleanDishes(){
    System.out.println("Decorator: Now you eat up food. Let me help you clean the dishes.");
  }
}

Le plus important c'est l'appel, qui est aussi la principale différence entre ces deux modes !

package test.design.proxydecorator;
public class TestMain {
  /**
   * @param args
   */
  public static void main(String[] args) {
    //代理模式
    System.out.println("代理模式:");
    Man m1=new Man();//通常情况下
    m1.eatFood();
    System.out.println("---------------------------");
    //代理模式者直接取代某对象，你连你想要见的人的面都见不到。
    //它说你要见的人已经把所有事委托于我，他会的我会；他不会的，我也会。我就是他的替代增强版。
    Eatable e1=new ProxyMan();
    e1.eatFood();
    System.out.println("------------分割---------------");
    System.out.println("装饰模式:");
    Man m2=new Man();//通常情况下
    m2.eatFood();
    System.out.println("---------------------------");
    //装饰模式者站在一边提供各种服务.
    //装饰者和被装饰者都在场，装饰者提供服务，赚取小费。
    Decorator d1=new Decorator(m2);
    d1.eatFood();
  }
}

Impression :

代理模式:
I am eating food! Happy!
---------------------------
proxy: I am proxy object. I will help you create a object of Man that wnt to be proxyed
proxy: I know you are hungry,so I cook for you some food.
I am eating food! Happy!
proxy: Now you eat up food. Let me help you clean the dishes.
------------分割---------------
装饰模式:
I am eating food! Happy!
---------------------------
Decorator: I know you are hungry,so I cook for you some food.
I am eating food! Happy!
Decorator: Now you eat up food. Let me help you clean the dishes.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!