BlogJava-Mark's Java Blog-随笔分类-设计模式

（转）《分析模式：可重用对象模型》-- 责任模式(party)

Mark — Tue, 01 Apr 2008 06:35:00 GMT

1 责任模式

这一章关注的重点是关系，以及怎样为错综复杂的关系建立模型，另外，所有的插图都来自原书（《Analysis Patterns：Reusable Object Models》），并遵循UML标准。

1.1 Party模式

在这一章中，首先我们接触到是是Party模式，在进行系统分析和概念模型设计的时候，经常发现人和各种各样的组织有着同样的行为，例如，固定电话的计费可能是针对个人，也可能是一个单位；需要各种服务的时候，你可能求助于一个服务公司，或者服务公司一个特定的业务员。总之，因为人（Person）和组织（Organization）表现上的一致性，如下图所见，我们从中抽象出Party，作为Person和Organization的抽象父类。

1.2 组织（Organization）的内部结构

第二步，如果我们把注意力转移到组织（Organization）的内部结构，就会发现一些有趣的问题，通常最常见的一种结构是金字塔结构，因此建模时可能按照这样的结构建立线性的模型，例如：

这样的模型并没有错误，但是有缺陷，首先不能满足比较复杂的组织关系，更严重的是，一旦需要更多的层次关系，例如存在部门直接上下级关系以及区域附属管理方式，必将引起整个模型的更改，对系统的影响可想而知，在这种情况下，最通常的改进措施是引入层次关系，如下图所示：

通过增加新的关联关系，可以灵活实现组织（Organization）之间的各种关系以及可能的变化。在上图中，{hierarchy}是一个约束（constraint）来限定关系。

1.3 组织关系抽象

第三步，在一般的情况下，以上的模式已经足够解决问题，但当这样的层次和组织关系很多而且复杂时（超过两种），例如现在流行的矩阵管理，就可以将关系本身抽取出来独立处理，如下图所示，作者此时考虑到组织结构的有效时段，所以加入了一个时间段属性来记录组织结构的存在时间。

请注意，在这个模式中，Organization Structure才是模式的核心，在系统中，由两个Organization的实例（分别充当parent和subsidiary），以及一个Type实例来说明该结构的类型。在这样的结构中，可能存在许多的规则（Rule），这些规则可以根据情况分别处理：如果Type很多，而且规则主要跟Type有关，就分配给与Type相关联；如果Type并不多，但主要根据Organization的子类型变化，就可以分布到Organization的子类型中。

1.4 责任（Accountability）模式

第四步，从第一步看到，Party是Person和Organization的抽象父类，因此把Party代入上面的模式（有点象我们小时侯代数里常用的代入），正式形成责任（Accountability）模式。

1.5 知识层（Knowledge level）和操作层（Operational level）分离

出现这样一种想法是考虑到以下情况：当Accountablity Type的数量比Accountability的数量多很多的时候，处理Accountablity Type的规则也变得更为复杂，要解决这样的问题，就可以引入知识层和操作层的分离。

由下图可见，用虚线隔离开的，就是知识层（Knowledge level）和操作层（Operational level），在这个模型中，知识层（Knowledge level）由三个类协作完成，它们分别是Accountablity Type、Connection Rule、Party Type，在Connection Rule中定义合法的Party关系规则，并通过Accountablity Type对Accountablity进行创建时的合法性检验。它的另一个好处就是，可以将知识层的实例化独立出来，作为操作层（Operational level）运行时的配置；换句话说，当知识层的规则改变时，系统的行为将被改变，而不需要任何其他代码的改动，这当然是一种比较理想化的情况。

由此想到，构建专家系统的设计思路也可以从这个模式得到一些启发，这是笔者一时的感触。

在原书中，如何实现这样的模型提得比较模糊，但是笔者认为，可以将它们作为正常的模型来实现，两个层次的区分只是表明它们各自担负的任务和地位不同。知识层倾向于描述系统可能存在的各种形式，并设定判断系统是否有效的各种规则；操作层则描述在这样的配置下系统实际的行为。通过改变内在的配置来改变外在的行为，就是这个模式的目的。

由于这个模式的特点，改变系统行为时不必更改操作层的代码，但是，并不意味着改变系统行为连测试也不必要做。同样，也需要调试、配置管理。

作者也提到，这样的模式用起来并不轻松，甚至在一般的系统中也不必要，但当你发现有必要用它的时候，别犹豫（感觉象用降落伞一样）！

1.6 小结

从简单到复杂，前面分五步介绍了适用于解决Party及其关系的各种模式，每种推荐的模式都有其表现的机会，希望我这篇文章可以起到一些抛砖引玉的作用，并欢迎大家对其中的错误进行指正，欢迎发表意见，进行交流。

原文参照《Analysis Patterns：Reusable Object Models》，Chapter 2，Martin Fowler

原文：http://blog.csdn.net/nzh_csdn/archive/2004/12/19/221484.aspx

Mark 2008-04-01 14:35 发表评论

观察者模式（二）

Mark — Tue, 18 Mar 2008 07:04:00 GMT

使用java.util.Observable类和java.util.Observer接口实现观察者模式气象站（拉、推均实现，自己也可以按照它的实现方法扩展）

拉：也就是观察者来决定接到“可观察者”类通知时获取“可观察者”的哪些变化。调用方法notifyObservers（）；

推：“可观察者”类通知观察者时传递给观察者自身所有的变化。调用方法notifyObservers（Object arg）；

import java.util.Observable;
import java.util.Observer;
//此类实现的是“拉”的发式，继承java.util.Observable类
public class WeatherData extends Observable {
private float temperature;
private float humidity;
private float pressure;
//构造器不需要为了记住观察者们而建立数据结构了
public WeatherData() { }

public void measurementsChanged() {
  setChanged();//指示可观察者状态已改变（可以由状态是否改变决定是否通知观察者，很容易，自己实现就行）
  notifyObservers();//没有调用传送数据对象，表示采用“拉”的做法
}

public void setMeasurements(float temperature, float humidity, float pressure) {
  this.temperature = temperature;
  this.humidity = humidity;
  this.pressure = pressure;
  measurementsChanged();
}
//以下不是新方法，而是为了使用“拉”的做法
public float getTemperature() {
  return temperature;
}

public float getHumidity() {
  return humidity;
}

public float getPressure() {
  return pressure;
}
}

import java.util.Observable;
import java.util.Observer;
//实现java.util.Observer接口，成为观察者
public class CurrentConditionsDisplay implements Observer, DisplayElement {
Observable observable;
private float temperature;
private float humidity;
//构造器需要Observable 作为参数，并将本对象登记为观察者
public CurrentConditionsDisplay(Observable observable) {
  this.observable = observable;
  observable.addObserver(this);
}
//改变update()方法，增加Observable 和数据对象为参数
public void update(Observable obs, Object arg) {
  if (obs instanceof WeatherData) {
   WeatherData weatherData = (WeatherData)obs;
   this.temperature = weatherData.getTemperature();
   this.humidity = weatherData.getHumidity();
   display();
  }
}

public void display() {
  System.out.println("Current conditions: " + temperature
   + "F degrees and " + humidity + "% humidity");
}
}

注意：java.util.Observable是一个类而不是接口，而且还没有实现任何接口。它本身的实现有很多问题，限制了它的使用和复用。由于它是个类，所以我们只能继承，java不允许多继承，所以限制了其复用潜力。而且setChanged()方法被保护起来（被定义成protected），这就意味着除非继承，否则无法创建实例并组合到自己的对象中，这就违背了设计原则“多用组合，少用继承”。

Mark 2008-03-18 15:04 发表评论

观察者模式（一）

Mark — Tue, 18 Mar 2008 05:52:00 GMT

观察者模式：在对象之间定义一对多的依赖，当一个对象改变状态，依赖他的对象都会收到通知，并自动更新。（以松耦合方式在一系列对象之间沟通状态，代表人物--MVC）

注意事项：主题（可观察者）用一个共同的接口来更新观察者，主题不知道观察者的细节，只知道观察者实现了观察者接口。使用此模式时，你可从被观察者处推（push）或拉（pull）数据（推的方式被认为更正确）。有多个观察者时，不可以依赖特定的通知顺序。java有多种观察者模式的实现，包括java.util.Observable(有一些违背设计原则的问题，有必要的话可以实现自己的Observable)，JavaBeans,RMI等，Swing大量使用此模式，许多GUI框架也是如此。

用观察者模式实现一个气象站的实例：
要求当WeatherData对象（接受物理气象站数据的对象）更新数据时，随即会更新三个布告板的显示：目前状况（温度、湿度、气压）、气象统计和天气预报。并且公布API可以让其他人写出自己的布告板。

代码：
//主题接口，提供注册、删除、更新布告板的方法
public interface Subject {
public void registerObserver(Observer o);
public void removeObserver(Observer o);
public void notifyObservers();
}

//观察者接口，提供更新本布告板的方法
public interface Observer {
public void update(float temp, float humidity, float pressure);
}

//布告板显示接口，提供布告板显示的方法
public interface DisplayElement {
public void display();
}

//主题实现类
public class WeatherData implements Subject {
private ArrayList observers;
private float temperature;
private float humidity;
private float pressure;
//构造方法中初始化观察者记录
public WeatherData() {
  observers = new ArrayList();
}
//注册观察者
public void registerObserver(Observer o) {
  observers.add(o);
}
//删除观察者
public void removeObserver(Observer o) {
  int i = observers.indexOf(o);
  if (i >= 0) {
   observers.remove(i);
  }
}
//当主题状态改变时调用，以通知所有观察者
public void notifyObservers() {
  for (int i = 0; i < observers.size(); i++) {
   Observer observer = (Observer)observers.get(i);
   observer.update(temperature, humidity, pressure);
  }
}
//通知观察者方法
public void measurementsChanged() {
  notifyObservers();
}
//更新数据方法
public void setMeasurements(float temperature, float humidity, float pressure) {
  this.temperature = temperature;
  this.humidity = humidity;
  this.pressure = pressure;
  measurementsChanged();
}

// other WeatherData methods here

public float getTemperature() {
  return temperature;
}

public float getHumidity() {
  return humidity;
}

public float getPressure() {
  return pressure;
}
}

//观察者实现类
public class CurrentConditionsDisplay implements Observer, DisplayElement {
private float temperature;
private float humidity;
private Subject weatherData;
//构造方法中把此观察者注册到主题
public CurrentConditionsDisplay(Subject weatherData) {
  this.weatherData = weatherData;
  weatherData.registerObserver(this);
}
//修改观察者状态
public void update(float temperature, float humidity, float pressure) {
  this.temperature = temperature;
  this.humidity = humidity;
  display();
}
//显示布告板更新内容
public void display() {
  System.out.println("Current conditions: " + temperature
   + "F degrees and " + humidity + "% humidity");
}
}

public class ForecastDisplay implements Observer, DisplayElement {
private float currentPressure = 29.92f;
private float lastPressure;
private WeatherData weatherData;

public ForecastDisplay(WeatherData weatherData) {
this.weatherData = weatherData;
weatherData.registerObserver(this);
}

public void update(float temp, float humidity, float pressure) {
lastPressure = currentPressure;
currentPressure = pressure;

display();
}

public void display() {
  System.out.print("Forecast: ");
  if (currentPressure > lastPressure) {
   System.out.println("Improving weather on the way!");
  } else if (currentPressure == lastPressure) {
   System.out.println("More of the same");
  } else if (currentPressure < lastPressure) {
   System.out.println("Watch out for cooler, rainy weather");
  }
}
}

public class StatisticsDisplay implements Observer, DisplayElement {
private float maxTemp = 0.0f;
private float minTemp = 200;
private float tempSum= 0.0f;
private int numReadings;
private WeatherData weatherData;

public StatisticsDisplay(WeatherData weatherData) {
this.weatherData = weatherData;
weatherData.registerObserver(this);
}

public void update(float temp, float humidity, float pressure) {
tempSum += temp;
numReadings++;

  if (temp > maxTemp) {
   maxTemp = temp;
  }

  if (temp < minTemp) {
   minTemp = temp;
  }

display();
}

public void display() {
System.out.println("Avg/Max/Min temperature = " + (tempSum / numReadings)
+ "/" + maxTemp + "/" + minTemp);
}
}

//测试类

public class WeatherStation {

public static void main(String[] args) {
  WeatherData weatherData = new WeatherData();

  CurrentConditionsDisplay currentDisplay =
   new CurrentConditionsDisplay(weatherData);
  StatisticsDisplay statisticsDisplay = new StatisticsDisplay(weatherData);
  ForecastDisplay forecastDisplay = new ForecastDisplay(weatherData);

  weatherData.setMeasurements(80, 65, 30.4f);
  weatherData.setMeasurements(82, 70, 29.2f);
  weatherData.setMeasurements(78, 90, 29.2f);
}
}

当我们想添加一个布告板的时候只要实现观察者借口就可以加入主题通知的记录中，实际代码如下：
//我们要添加一个酷热指数的布告板，利用一套公式来计算酷热指数。

public class HeatIndexDisplay implements Observer, DisplayElement {
float heatIndex = 0.0f;
private WeatherData weatherData;

public HeatIndexDisplay(WeatherData weatherData) {
this.weatherData = weatherData;
weatherData.registerObserver(this);
}

public void update(float t, float rh, float pressure) {
  heatIndex = computeHeatIndex(t, rh);
  display();
}
//酷热指数计算
private float computeHeatIndex(float t, float rh) {
  float index = (float)((16.923 + (0.185212 * t) + (5.37941 * rh) - (0.100254 * t * rh)
   + (0.00941695 * (t * t)) + (0.00728898 * (rh * rh))
   + (0.000345372 * (t * t * rh)) - (0.000814971 * (t * rh * rh)) +
   (0.0000102102 * (t * t * rh * rh)) - (0.000038646 * (t * t * t)) + (0.0000291583 *
   (rh * rh * rh)) + (0.00000142721 * (t * t * t * rh)) +
   (0.000000197483 * (t * rh * rh * rh)) - (0.0000000218429 * (t * t * t * rh * rh)) +
   0.000000000843296 * (t * t * rh * rh * rh)) -
   (0.0000000000481975 * (t * t * t * rh * rh * rh)));
  return index;
}

public void display() {
System.out.println("Heat index is " + heatIndex);
}
}

//加入酷热指数布告板后的测试类

public class WeatherStationHeatIndex {

public static void main(String[] args) {
  WeatherData weatherData = new WeatherData();
  CurrentConditionsDisplay currentDisplay = new CurrentConditionsDisplay(weatherData);
  StatisticsDisplay statisticsDisplay = new StatisticsDisplay(weatherData);
  ForecastDisplay forecastDisplay = new ForecastDisplay(weatherData);
  HeatIndexDisplay heatIndexDisplay = new HeatIndexDisplay(weatherData);

  weatherData.setMeasurements(80, 65, 30.4f);
  weatherData.setMeasurements(82, 70, 29.2f);
  weatherData.setMeasurements(78, 90, 29.2f);
}
}

Mark 2008-03-18 13:52 发表评论

OO设计原则

Mark — Tue, 18 Mar 2008 05:48:00 GMT

1、找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起（封装变化）。
2、针对借口编程，而不是针对实现编程。
3、多用组合，少用继承。
4、为交互对象之间的松耦合设计而努力（松耦合设计更有弹性，更能应对变化）
5、类应该对扩展开放，对修改关闭。
6、依赖抽象，不要依赖具体类。

Mark 2008-03-18 13:48 发表评论

策略模式

Mark — Mon, 17 Mar 2008 01:55:00 GMT

   策略模式定义了算法族，分别封装起来，让它们之间可以互相替换，此模式让算法的变化独立于使用算法的客户。

    个人理解：策略模式就是把父类中需要根据不同情况而变化的行为想成“一族算法”，并把它抽象出来变成两个接口，在父类中包含这个接口类型的属性，这样就可以利用不同的接口实现类来改变这个行为。并且添加了getter,setter方法后可以在运行时随意改变行为的实现，这样就可以使我们的设计更加富有弹性，可以使我们的设计更加易于维护和扩展。

实例代码：

要求：所有的各类鸭子继承一个超类，并且可以拥有自己的特性，可以因为需求变化而改变某个鸭子或某一类鸭子的某种特性（如可以改变叫声和飞行状态）。

//鸭子超类
public abstract class Duck {
//飞行状态算法族
FlyBehavior flyBehavior;
//鸣叫状态算法族
QuackBehavior quackBehavior;

public Duck() {
}
//改变算法组状态的方法，可是在运行时改变特性的方法
public void setFlyBehavior (FlyBehavior fb) {
  flyBehavior = fb;
}

public void setQuackBehavior(QuackBehavior qb) {
  quackBehavior = qb;
}
//由子类继承并实现的鸭子特性（不会改变）
abstract void display();
//由子类继承的飞行和鸣叫方法
public void performFly() {
  flyBehavior.fly();
}

public void performQuack() {
  quackBehavior.quack();
}

public void swim() {
  System.out.println("All ducks float, even decoys!");
}
}

//飞行接口
public interface FlyBehavior {
public void fly();
}

//飞行状态实现类（不能飞）
public class FlyNoWay implements FlyBehavior {
public void fly() {
  System.out.println("I can't fly");
}
}

//火箭助推器
public class FlyRocketPowered implements FlyBehavior {
public void fly() {
  System.out.println("I'm flying with a rocket");
}
}
//鸣叫接口
public interface QuackBehavior {
public void quack();
}

//鸣叫状态实现类（不能叫）
public class MuteQuack implements QuackBehavior {
public void quack() {
  System.out.println("<< Silence >>");
}
}

//一个模型鸭的子类，在创建时指定特性
public class DecoyDuck extends Duck {
//在构造器中指定飞行特性和鸣叫特性（不能飞，不能叫）
public DecoyDuck() {
  setFlyBehavior(new FlyNoWay());
  setQuackBehavior(new MuteQuack());
}

public void display() {
  System.out.println("I'm a duck Decoy");
}
}

//测试程序

public class MiniDuckSimulator {

public static void main(String[] args) {

DecoyDuck decoy = new DecoyDuck();

  decoy.performQuack();

  decoy .performFly();
//运行时把飞行状态改为火箭助推器飞行
  decoy .setFlyBehavior(new FlyRocketPowered());
  decoy .performFly();
}
}

Mark 2008-03-17 09:55 发表评论