Java模式设计之模板方法模式

freesky — Mon, 14 May 2007 02:40:00 GMT

这是一个很简单的模式，却被非常广泛的使用。之所以简单是因为在这个模式中仅仅使用到了继承关系。

继承关系由于自身的缺陷，被专家们扣上了“罪恶”的帽子。“使用委派关系代替继承关系”，“尽量使用接口实现而不是抽象类继承”等等专家警告，让我们这些菜鸟对继承“另眼相看”。

其实，继承还是有很多自身的优点所在。只是被大家滥用的似乎缺点更加明显了。合理的利用继承关系，还是能对你的系统设计起到很好的作用的。而模板方法模式就是其中的一个使用范例。

二、定义与结构

GOF给模板方法（Template Method）模式定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。这里的算法的结构，可以理解为你根据需求设计出来的业务流程。特定的步骤就是指那些可能在内容上存在变数的环节。

可以看出来，模板方法模式也是为了巧妙解决变化对系统带来的影响而设计的。使用模板方法使系统扩展性增强，最小化了变化对系统的影响。这一点，在下面的举例中可以很明显的看出来。

来看下这个简单模式的结构吧：

1) AbstractClass（抽象类）：定义了一到多个的抽象方法，以供具体的子类来实现它们；而且还要实现一个模板方法，来定义一个算法的骨架。该模板方法不仅调用前面的抽象方法，也可以调用其他的操作，只要能完成自身的使命。

2) ConcreteClass（具体类）：实现父类中的抽象方法以完成算法中与特定子类相关的步骤。

下面是模板方法模式的结构图。直接把《设计模式》上的图拿过来用下：

三、举例

还是在我刚刚分析完源码的JUnit中找个例子吧。JUnit中的TestCase以及它的子类就是一个模板方法模式的例子。在TestCase这个抽象类中将整个测试的流程设置好了，比如先执行Setup方法初始化测试前提，在运行测试方法，然后再TearDown来取消测试设置。但是你将在 Setup、TearDown里面作些什么呢？鬼才知道呢！！因此，而这些步骤的具体实现都延迟到子类中去，也就是你实现的测试类中。

来看下相关的源代码吧。

这是TestCase中，执行测试的模板方法。你可以看到，里面正像前面定义中所说的那样，它制定了“算法”的框架——先执行setUp方法来做下初始化，然后执行测试方法，最后执行tearDown释放你得到的资源。

public void runBare() throws Throwable {
setUp();

try {
runTest();
}

finally {
tearDown();
}
}

这就是上面使用的两个方法。与定义中不同的是，这两个方法并没有被实现为抽象方法，而是两个空的无为方法（被称为钩子方法）。这是因为在测试中，我们并不是必须要让测试程序使用这两个方法来初始化和释放资源的。如果是抽象方法，则子类们必须给它一个实现，不管用到用不到。这显然是不合理的。使用钩子方法，则你在需要的时候，可以在子类中重写这些方法。

protected void setUp() throws Exception {}
protected void tearDown() throws Exception {}

四、适用情况

根据上面对定义的分析，以及例子的说明，可以看出模板方法适用于以下情况：

1) 一次性实现一个算法的不变的部分，并将可变的行为留给子类来实现。

2) 各子类中公共的行为应被提取出来并集中到一个公共父类中以避免代码重复。其实这可以说是一种好的编码习惯了。

3) 控制子类扩展。模板方法只在特定点调用操作，这样就只允许在这些点进行扩展。比如上面runBare（）方法就只在runTest前面适用setUp方法。如果你不愿子类来修改你的模板方法定义的框架，你可以采用两种方式来做：一是在API中不体现出你的模板方法；二、将你的模板方法置为final就可以了。

可以看出，使用模板方法模式可以将代码的公共行为提取出来，达到复用的目的。而且，在模板方法模式中，是由父类的模板方法来控制子类中的具体实现。这样你在实现子类的时候，根本不需要对业务流程有太多的了解。

转载：http://fly-net-cn.javaeye.com/blog/78611

freesky 2007-05-14 10:40 发表评论

Java设计模式之策略模式

freesky — Mon, 14 May 2007 02:28:00 GMT

策略模式（Strategy Pattern）中体现了两个非常基本的面向对象设计的基本原则：封装变化的概念；编程中使用接口，而不是对接口实现。策略模式的定义如下：

定义一组算法，将每个算法都封装起来，并且使它们之间可以互换。策略模式使这些算法在客户端调用它们的时候能够互不影响地变化。

策略模式使开发人员能够开发出由许多可替换的部分组成的软件，并且各个部分之间是弱连接的关系。弱连接的特性使软件具有更强的可扩展性，易于维护；更重要的是，它大大提高了软件的可重用性。

为了说明策略模式，我们将首先讨论一下在Swing中是如何利用策略模式来绘制组件边界的，然后讨论在Swing中使用策略模式带来的好处，最后讨论如何在软件中实现策略模式。

Swing边框

对所有的Swing组件，例如按钮、列表单等，都还可以绘制边框。在Swing中提供了各种边框类型，例如bevel、etched、line、titled等。Swing组件的边框是通过JComponent类来绘制的，该类是所有Swing 组件的基类，实现了所有Swing组件公共的功能。在JComponent中有一个paintBorder()方法，该方法为组件绘制边框。Swing的开发人员可以象下面的例子中所示那样来绘制边框：

// 一段实现paintBorder（）方法代码
protected void paintBorder(Graphics g) {
   switch(getBorderType()) {
      case LINE_BORDER:   paintLineBorder(g);
                          break;
      case ETCHED_BORDER: paintEtchedBorder(g);
                          break;
      case TITLED_BORDER: paintTitledBorder(g);
                          break;
      ...
   }
}

请注意上面的代码只是一种假设，事实上Swing的开发人员并没有这样实现 paintBorder（）方法。在上面的代码中，在JComponent中绘制边框的代码被直接写入了paintBorder（）方法中，这意味着 JComponent和绘制边框的功能被紧密地结合在了一起。很自然地大家会联想到如果需要实现一种新的边框类型，开发人员必须修改至少三处代码：首先增加一个常量，该常量代表新添加的边框的类型值；其次需要在Switch语句中增加一个case语句；最后开发人员需要实现paintXXXBorder （）方法，其中XXX代表新边框的名称。

很显然要扩展上面paintBorder()方法的功能是一件很困难的事情，不仅仅是因为开发人员需要增加一种新的边框类型，更麻烦的是开发人员很难修改JComponent类。JComponent类已经被编译到了Swing的开发工具中，如果开发人员想修改它的话，必须获得Swing的源代码，修改后重新编译Swing。同时在用户的计算机上与需要使用新编译的Swing API。另外所有的Swing组件都可以使用开发人员新添加的边框类型。有可能开发人员只希望新的边框被某些组件使用，但是现在开发人员无法对使用该边框的组件进行限制。

开发人员有更好的实现方法吗？答案就是策略模式。通过策略模式，可以将 JComponent和实现绘制边框的代码分离开来，这样开发人员在增加或修改绘制边框的代码使就不需要修改JComponent的代码。通过应用策略模式，开发人员将变化的概念（在这个例子中是绘制边框）封装起来，然后通过一个Border接口，使程序能够重用绘制边框的功能。下面让我们来看 JComponent是如何利用策略模式来实现绘制边框的功能的：

// Swing中paintBorder()方法的源代码
protected void paintBorder(Graphics g) {
   Border border = getBorder();
   if (border != null) {
      border.paintBorder(this, g, 0, 0, getWidth(), getHeight());
   }
}

上面的paintBorder()方法通过一个border对象绘制了组件的边框。这样border对象替代了前一个例子中的JComponent封装了边框绘制的功能。我们还应该注意到JComponent将一个对自己的引用传递给了 Border.paintBorder（）方法，这是因为Border的实例必须知道它对应的组件的信息，这种方式通常被称为委托。通过这种方式，一个对象可以将功能委托给另一个对象来实现。

在JComponent类中引用了一个Border对象，通过JComponent.getBorder（）方法可以获得该Border对象。下面的代码演示了如何设定和获得Border对象：

...
private Border border;
...
public void setBorder(Border border) {
   Border oldBorder = this.border;
   this.border = border;
   firePropertyChange("border", oldBorder, border);
   if (border != oldBorder) {
      if (border == null || oldBorder == null || !(border.getBorderInsets(this).
                                    equals(oldBorder.getBorderInsets(this)))) {
         revalidate();
      }       
      repaint();
   }
}
...
public Border getBorder() {
   return border;
}

当开发人员通过JComponent.setBorder（）方法设定了一个组件的边框后，JComponent类发出一个属性更新事件。如果新的边框和以前的边框不同的话，setBorder（）方法就重新绘制边框。 getBorder（）方法仅仅返回对Border对象的引用。图1显示了Border的类结构图：

图1 Border的类结构图

通过类结构图我们可以看到，JComponent类中保存了一个对Border对象的引用。由于Border是一个接口，Swing组件可以使用任何一个实现了Border接口的类。

现在我们已经知道了JComponent是如何利用策略模式来绘制组件的边框的。下面让我们通过实现一个新的边框类型来测试一下它的可扩展性。

实现一个新的边框类型

图2中是一个有三个JPanel对象的小程序，每个JPanel对象有各自不同的边框，每个边框对应一个HandleBorder实例。

图2 新的边框类型

// HandleBorder.java
import java.awt.*;
import javax.swing.*;
import javax.swing.border.*;
public class HandleBorder extends AbstractBorder {
   protected Color lineColor;
   protected int thick;
   public HandleBorder() {
      this(Color.black, 6);
   }
   public HandleBorder(Color lineColor, int thick) {
      this.lineColor = lineColor;
      this.thick = thick;
   }
   public void paintBorder(Component component, 
                                  Graphics g, int x, int y, int w, int h) {
      Graphics copy = g.create();
      if(copy != null) {
         try {
            copy.translate(x,y);
            paintRectangle(component,copy,w,h);
            paintHandles(component,copy,w,h);
         }
         finally {
            copy.dispose();
         }
      }
   }
   public Insets getBorderInsets() {
      return new Insets(thick,thick,thick,thick);
   }
   protected void paintRectangle(Component c, Graphics g,
                           int w, int h) {
      g.setColor(lineColor);
      g.drawRect(thick/2,thick/2,w-thick-1,h-thick-1);
   }
   protected void paintHandles(Component c, Graphics g,
                           int w, int h) {
      g.setColor(lineColor);
      g.fillRect(0,0,thick,thick); 
      g.fillRect(w-thick,0,thick,thick); 
      g.fillRect(0,h-thick,thick,thick); 
      g.fillRect(w-thick,h-thick,thick,thick); 
      g.fillRect(w/2-thick/2,0,thick,thick); 
      g.fillRect(0,h/2-thick/2,thick,thick); 
      g.fillRect(w/2-thick/2,h-thick,thick,thick); 
      g.fillRect(w-thick,h/2-thick/2,thick,thick); 
   }   
}

HandleBorder类继承了 javax.swing.border.AbstractBorder类并重写了paintBorder（）和getBorderInsets（）。 HandleBorder是如何实现的其实并不重要，重要的是由于Swing使用了策略模型，开发人员能够很方便地增加新的边框类型。下面的代码显示了如何使用HandleBorder类。在这个例子中创建了三个JPanel对象，并对每个JPanel对象设定一个HandleBorder实例作为边框。

// Test.java
import javax.swing.*;
import javax.swing.border.*;
import java.awt.*;
import java.awt.event.*;
public class Test extends JFrame {
   public static void main(String[] args) {
      JFrame frame = new Test();
      frame.setBounds(100, 100, 500, 200);
      frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
      frame.show();
   }
   public Test() {
      super("实现一个新的边框类型");
      Container contentPane = getContentPane();
      JPanel[] panels = { new JPanel(), 
                     new JPanel(), new JPanel() };
      Border[] borders = { new HandleBorder(),
                     new HandleBorder(Color.red, 8),
                     new HandleBorder(Color.blue, 10) };
      contentPane.setLayout(
               new FlowLayout(FlowLayout.CENTER,20,20));
      for(int i=0; i < panels.length; ++i) {
         panels[i].setPreferredSize(new Dimension(100,100));
         panels[i].setBorder(borders[i]);
         contentPane.add(panels[i]);
      }
   }
}

还记得在上面的例子中曾提到在有些情况下，对组件的引用会作为参数传递给 Border.paintBorder（）方法。虽然上面的HandleBorder类没有保存对组件的引用，但是有些情况下Border接口的实现类会使用到对组件的引用并从中获得关于组件的信息。例如在EtchedBorder中，paintBorder（）方法通过对组件的引用获得它对应的组件的阴影和高光色：

// 下面的代码截取自javax.swing.border.EtchedBorder
public void paintBorder(Component component, Graphics g, int x, int y, 
                         int width, int height) {
   int w = width;
   int h = height;
   g.translate(x, y);
   g.setColor(etchType == LOWERED? getShadowColor(component) : 
getHighlightColor(component));
   g.drawRect(0, 0, w-2, h-2);
   g.setColor(etchType == LOWERED? getHighlightColor(component) : 
getShadowColor(component));
   g.drawLine(1, h-3, 1, 1);
   g.drawLine(1, 1, w-3, 1);
   g.drawLine(0, h-1, w-1, h-1);
   g.drawLine(w-1, h-1, w-1, 0);
   g.translate(-x, -y);
}

如何实现策略模型

通过以下步骤，开发人员可以很容易地在软件中实现策略模型：

1．对策略对象定义一个公共接口。

2．编写策略类，该类实现了上面的公共接口。

3．在使用策略对象的类中保存一个对策略对象的引用。

4．在使用策略对象的类中，实现对策略对象的set和get方法。

在Swing边框的例子中，公共接口是javax.swing.Border。策略类是LineBorder、EtchedBorder、HandleBorder等。而使用策略对象的类是JComponent。

转载：http://fly-net-cn.javaeye.com/blog/78615

freesky 2007-05-14 10:28 发表评论

BlogJava-freesky-随笔分类-设计模式

Java模式设计之模板方法模式

Java设计模式之策略模式