[体系结构]设计模式(三）-CSDN博客

十、中介者模式

类图：

参与者：
Mediator(中介者)：中介者定义一个接口用于与各同事对象通信。
ConcreteMediator(具体中介者)：具体中介者通过协调各同事对象实现协作行为。了解并维护它的各个同事。
Colleague Class(参与者类)：每一个同事者类都知道他的中介者对象，每一个同事对象在需要与其他的同事者通信的时候，与他的中介者通信。

实例：生产者、消费者、代理商

public abstract class PersonColleague {     protected Mediator mediator;      public Mediator getMediator()     {         return mediator;     }      public void setMediator(final Mediator mediator)     {         this.mediator = mediator;     }      protected abstract void message(String context);  }  public class Mediator {     private PersonColleague consumer = null;     private ProducerColleague producer = null;      public ProducerColleague getProducer()     {         return producer;     }      public void setProducer(final ProducerColleague producer)     {         this.producer = producer;     }      public PersonColleague getConsumer()     {         return consumer;     }      public void setConsumer(final PersonColleague consumer)     {         this.consumer = consumer;     }      public Mediator()     {     }      public synchronized void message(final String context)     {         if (consumer != null)         {             System.out.println(context);         }         else if (producer != null)         {             System.out.println(context);         }     } }  public class ConsumerColleague extends PersonColleague {     public ConsumerColleague(final Mediator mediator)     {         this.mediator = mediator;     }      @Override     protected void message(final String context)     {         this.mediator.setConsumer(this);         this.mediator.message("hello! i am a consumer");     } }  public class ProducerColleague extends PersonColleague {     public ProducerColleague(final Mediator mediator)     {         this.mediator = mediator;     }      @Override     protected void message(final String context)     {         this.mediator.setProducer(this);         this.mediator.message(context);     } }  public class Client {     public static void main(final String[] args)     {         final Mediator mediator = new Mediator();         final PersonColleague person = new ConsumerColleague(mediator);         final PersonColleague person1 = new ProducerColleague(mediator);          person.message("I am a consumer");         person1.message("I am a producer");     } }  结果： hello! i am a consumer I am a producer

十一、观察者模式

类图：

顺序：

1.构造subject 2.给observer subject的引用,调用subject register方法3.在subject中添加observer 4. 触发subject 即调用subject的notify方法 5.subject被触发后调用自己的方法，for循环调用observer的update方法

观察者模式的应用场景：

1、对一个对象状态的更新，需要其他对象同步更新，而且其他对象的数量动态可变。

2、对象仅需要将自己的更新通知给其他对象而不需要知道其他对象的细节。

观察者模式的优点：

1、 Subject和Observer之间是松偶合的，分别可以各自独立改变。

2、 Subject在发送广播通知的时候，无须指定具体的Observer，Observer可以自己决定是否要订阅Subject的通知。

3、遵守大部分GRASP原则和常用设计原则，高内聚、低偶合。

观察者模式的缺陷：

1、松偶合导致代码关系不明显，有时可能难以理解。(废话)

2、如果一个Subject被大量Observer订阅的话，在广播通知的时候可能会有效率问题。（毕竟只是简单的遍历）

十二、命令模式

命令模式将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤销的操作。

类图：

模式结构：
Command: 定义命令的接口，声明执行的方法。
ConcreteCommand: 命令接口实现对象，通常会持有接受者，并调用接受者的功能来完成命令要执行的操作。
Receiver: 接收者，真正执行命令的对象。任何类都可能成为一个接收者,只要它能够实现命令要求的相应功能。
Invoker: 要求命令对象执行请求，通常会持有命令对象，可以持有很多的命令对象。这个是客户端真正触发命令并要求命令执行相应操作的地方，也就是说相当于使用命令对象的入口。
Client: 创建具体的命令对象，并且设置命令对象的接收者。注意这个不是我们常规意义上的客户端，而是在组装命令对象和接收者，也可以称为装配者，真正使用命令的客户端是从Invoker来触发执行。

　　接收者角色类

public class Receiver {     /**      * 真正执行命令相应的操作      */     public void action(){         System.out.println("执行操作");     } }

　　抽象命令角色类

public interface Command {     /**      * 执行方法      */     void execute(); }

　　具体命令角色类

public class ConcreteCommand implements Command {     //持有相应的接收者对象     private Receiver receiver = null;     /**      * 构造方法      */     public ConcreteCommand(Receiver receiver){         this.receiver = receiver;     }     @Override     public void execute() {         //通常会转调接收者对象的相应方法，让接收者来真正执行功能         receiver.action();     }  }

　　请求者角色类

public class Invoker {     /**      * 持有命令对象      */     private Command command = null;     /**      * 构造方法      */     public Invoker(Command command){         this.command = command;     }     /**      * 行动方法      */     public void action(){                  command.execute();     } }

　　客户端角色类

public class Client {      public static void main(String[] args) {         //创建接收者         Receiver receiver = new Receiver();         //创建命令对象，设定它的接收者         Command command = new ConcreteCommand(receiver);         //创建请求者，把命令对象设置进去         Invoker invoker = new Invoker(command);         //执行方法         invoker.action();     }  }

AudioPlayer系统

　　小女孩茱丽(Julia)有一个盒式录音机，此录音机有播音(Play)、倒带(Rewind)和停止(Stop)功能，录音机的键盘便是请求者(Invoker)角色；茱丽(Julia)是客户端角色，而录音机便是接收者角色。Command类扮演抽象命令角色，而PlayCommand、StopCommand和RewindCommand便是具体命令类。茱丽(Julia)不需要知道播音(play)、倒带(rewind)和停止(stop)功能是怎么具体执行的，这些命令执行的细节全都由键盘(Keypad)具体实施。茱丽(Julia)只需要在键盘上按下相应的键便可以了。

　　录音机是典型的命令模式。录音机按键把客户端与录音机的操作细节分割开来。

　　源代码

　　接收者角色，由录音机类扮演

public class AudioPlayer {          public void play(){         System.out.println("播放...");     }          public void rewind(){         System.out.println("倒带...");     }          public void stop(){         System.out.println("停止...");     } }

　　抽象命令角色类

public interface Command {     /**      * 执行方法      */     public void execute(); }

　　具体命令角色类

public class PlayCommand implements Command {      private AudioPlayer myAudio;          public PlayCommand(AudioPlayer audioPlayer){         myAudio = audioPlayer;     }     /**      * 执行方法      */     @Override     public void execute() {         myAudio.play();     }  }

public class RewindCommand implements Command {      private AudioPlayer myAudio;          public RewindCommand(AudioPlayer audioPlayer){         myAudio = audioPlayer;     }     @Override     public void execute() {         myAudio.rewind();     }  }

public class StopCommand implements Command {     private AudioPlayer myAudio;          public StopCommand(AudioPlayer audioPlayer){         myAudio = audioPlayer;     }     @Override     public void execute() {         myAudio.stop();     }  }

　　请求者角色，由键盘类扮演

public class Keypad {     private Command playCommand;     private Command rewindCommand;     private Command stopCommand;          public void setPlayCommand(Command playCommand) {         this.playCommand = playCommand;     }     public void setRewindCommand(Command rewindCommand) {         this.rewindCommand = rewindCommand;     }     public void setStopCommand(Command stopCommand) {         this.stopCommand = stopCommand;     }     /**      * 执行播放方法      */     public void play(){         playCommand.execute();     }     /**      * 执行倒带方法      */     public void rewind(){         rewindCommand.execute();     }     /**      * 执行播放方法      */     public void stop(){         stopCommand.execute();     } }

　　客户端角色，由茱丽小女孩扮演

public class Julia {     public static void main(String[]args){         //创建接收者对象         AudioPlayer audioPlayer = new AudioPlayer();         //创建命令对象         Command playCommand = new PlayCommand(audioPlayer);         Command rewindCommand = new RewindCommand(audioPlayer);         Command stopCommand = new StopCommand(audioPlayer);         //创建请求者对象         Keypad keypad = new Keypad();         keypad.setPlayCommand(playCommand);         keypad.setRewindCommand(rewindCommand);         keypad.setStopCommand(stopCommand);         //测试         keypad.play();         keypad.rewind();         keypad.stop();         keypad.play();         keypad.stop();     } }

宏命令

　　所谓宏命令简单点说就是包含多个命令的命令，是一个命令的组合。

　　设想茱丽的录音机有一个记录功能，可以把一个一个的命令记录下来，再在任何需要的时候重新把这些记录下来的命令一次性执行，这就是所谓的宏命令集功能。因此，茱丽的录音机系统现在有四个键，分别为播音、倒带、停止和宏命令功能。此时系统的设计与前面的设计相比有所增强，主要体现在Julia类现在有了一个新方法，用以操作宏命令键。

　　源代码

　　系统需要一个代表宏命令的接口，以定义出具体宏命令所需要的接口。

public interface MacroCommand extends Command {     /**      * 宏命令聚集的管理方法      * 可以添加一个成员命令      */     public void add(Command cmd);     /**      * 宏命令聚集的管理方法      * 可以删除一个成员命令      */     public void remove(Command cmd); }

　　具体的宏命令MacroAudioCommand类负责把个别的命令合成宏命令。

public class MacroAudioCommand implements MacroCommand {          private List<Command> commandList = new ArrayList<Command>();     /**      * 宏命令聚集管理方法      */     @Override     public void add(Command cmd) {         commandList.add(cmd);     }     /**      * 宏命令聚集管理方法      */     @Override     public void remove(Command cmd) {         commandList.remove(cmd);     }     /**      * 执行方法      */     @Override     public void execute() {         for(Command cmd : commandList){             cmd.execute();         }     }  }

　　客户端类Julia

public class Julia {          public static void main(String[]args){         //创建接收者对象         AudioPlayer audioPlayer = new AudioPlayer();         //创建命令对象         Command playCommand = new PlayCommand(audioPlayer);         Command rewindCommand = new RewindCommand(audioPlayer);         Command stopCommand = new StopCommand(audioPlayer);                  MacroCommand marco = new MacroAudioCommand();                  marco.add(playCommand);         marco.add(rewindCommand);         marco.add(stopCommand);         marco.execute();     } }