Java资源网
首
页		 | JAVA基础 | 环境配置 | JDBC | 线程技术 | Socket编程 | JavaMail | JAVA与XML | 设计模式 | 技术新闻 | Java认证 | 程序人生 软件下载
| JSP&Servlet | Spring | Struts | Hibernate | JBuilder | Eclipse | WebService | EJB技术 | J2ME开发 | 应用服务器 | JXTA | Ajax
Articles search文章搜索
   关键字:
   类　别:
       
New download 最新下载
· [组件]HTML Parser 1.5
· [教程]WebSphere Studio应用教程
· [组件]JDom 1.0
· [工具]Junit3.8.1
· [教程]EJB编程及J2EE系统架构和设计
· [教程]EJB教程
· [教程]J2EE Tutorial中文版
· [教程]Java编程思想2(英文)
· [教程]java编程思想（完整版）
· [教程]Java网络编程
New articles 最新文章
· 设计移动 Web 服务
· 解析XML的时候完全忽略DTD
· 理解XML Schema XML Schema 初步
· 标签库的深入研究
· 提升JSP应用程序的七大绝招
· 如何使用JDOM对XML文件进行操作
· 处理XML字符串中特殊字符
· 利用Digester把XML转换成为Java对象
· 使用WebService 和RMI远程协作
· 使用Axis开发Web Service程序
Articles top 热门文章
· Eclipse基础－－plugin插件安装(6644)
· eclipse+tomcat+lomboz的安装配置说明(4774)
· Java程序员就业前景(4584)
· Windows下JAVA环境变量的设置祥解(3788)
· Tomcat下JSP、Servlet和JavaBean环境的配置(3716)
· 使用links方式安装Eclipse插件(3698)
· 一个老程序员的心理话(3533)
· linux下jdk的安装与配置(3459)
· 初学者入门：Structs中基本配置入门(3334)
· Eclipse 运行命令行参数大全(3084)
您的位置:首页>>设计模式>>Decoratenbsp;yournbsp;Javanbsp;codenbsp;(2)nbsp;--nbsp;Anbsp;looknbsp;atnbsp;thenbsp;Decoratornbsp;d
Decoratenbsp;yournbsp;Javanbsp;codenbsp;(2)nbsp;--nbsp;Anbsp;looknbsp;atnbsp;thenbsp;Decoratornbsp;d
2007-04-13   来源:www.javaresearch.org  作者:未知

Sort and filter decorators for Swing tables

The Decorator pattern excels at attaching functionality, such as sorting and filtering, to Swing tables. In fact, the Decorator pattern is flexible enough that we can attach functionality to any Swing table at runtime. Before we can discuss how decorators enhance Swing tables in detail, we must have a basic understanding of Swing tables; so, let's take a short detour. 

Swing tables

Swing components are implemented with the Model-View-Controller (MVC) design pattern. Each component consists of a model that maintains data, views that display the data, and controllers that react to events. For example, Swing tables, instances of JTable, are commonly created with an explicit model. Example 3 lists an application that does just that. (Try to picture the table in Example 3 before viewing it in Figure 5.) 

Example 3. Create a Swing table

 
  1. import javax.swing.*;
  2. import javax.swing.table.*;
  4. public class Test extends JFrame {
  5.    public static void main(String args[]) {
  6.       Test frame = new Test();
  7.       frame.setTitle("Tables and Models");
  8.       frame.setBounds(300, 300, 450, 300);
  9.       frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
  10.       frame.show();
  11.    }
  12.    public Test() {
  13.       TableModel model = new TestModel();   
  14.       getContentPane().add(new JScrollPane(new JTable(model)));
  15.    }
  16.    private static class TestModel extends AbstractTableModel {
  17.       final int rows = 100, cols = 10;
  18.       public int    getRowCount()    { return rows; }
  19.       public int    getColumnCount() { return cols; }
  20.       public Object getValueAt(int row, int col) {
  21.          return "(" + row + "," + col + ")";
  22.       }
  23.    }
  24. }

The application creates a table with a model. That table is placed in a scrollpane and added to the frame's content pane. Figure 5 shows the application listed in Example 3. 


[i]Figure 5. A simple Swing table[/i] 

The application shown above creates a table model with 100 rows and 10 columns. When asked for a cell value, the model creates a string that represents the cell's row and column. The application uses that model to construct a Swing table (an instance of JTable). Table models produce a table's data, in addition to metadata such as the number of rows and columns. 

It's important to understand that Swing tables possess models that maintain a table's data. Table models, as evidenced in Example 3, do not have to actually store any data -- they must produce a value for a given row and column. 

A sort decorator

With a basic understanding of the Decorator pattern and Swing tables, we can now implement a table sort decorator. First, we'll see an application that uses the decorator, followed by a discussion of the decorator's implementation. 

The application shown in Figure 6 contains a table with two columns: one for items and another for price. You can sort columns by clicking on column headers. When the application starts, nothing is sorted, as evidenced by the status bar in the bottom of the left picture in Figure 6. I took the middle picture in Figure 6 after I clicked the Item column header. I took the the right picture after I clicked the Price/Lb. column header.
 

[i]Figure 6. A sorting decorator. Click on thumbnail to view full-size image[/i] 

The application shown in Figure 6 replaces the table's model with a sort decorator. That application is partially listed in Example 4. (You can download the full source code from the Resources section below.) 

Example 4. Sorting a Swing table 


  1. import java.awt.*;
  2. import java.awt.event.*;
  4. import java.util.Locale;
  5. import java.util.ResourceBundle;
  7. import javax.swing.*;
  8. import javax.swing.event.*;
  9. import javax.swing.table.*;
  11. public class Test extends JFrame {
  12.    public static void main(String args[]) {
  13.       SwingApp.launch(new Test(), "A Sort Decorator", 
  14.                                    300, 300, 200, 250);
  15.    }
  16.    public Test() {
  17.       // Create the decorator that will decorate the table's 
  18.       // original model. The reference must be final because it's
  19.       // accessed by an inner class below. 
  20.       final TableSortDecorator decorator = 
  21. new TableSortDecorator(table.getModel());
  23.       // Set the table's model to the decorator. Because the
  24.       // decorator implements TableModel, the table will never
  25.       // know the difference between the decorator and it's
  26.       // original model.
  27.       table.setModel(decorator);
  28.       ...
  30.       // Obtain a reference to the table's header
  31.       JTableHeader header = (JTableHeader)table.getTableHeader();
  33.       // React to mouse clicks in the table header by calling 
  34.       // the decorator's sort method.
  35.       header.addMouseListener(new MouseAdapter() {
  36.          public void mouseClicked(MouseEvent e) {
  37.             TableColumnModel tcm = table.getColumnModel();
  38.             int vc = tcm.getColumnIndexAtX(e.getX());
  39.             int mc = table.convertColumnIndexToModel(vc);
  41.             // Perform the sort
  42.             decorator.sort(mc);
  44.             // Update the status area
  45.             SwingApp.showStatus(headers[mc] + " sorted");
  46.          }
  47.       });
  48.    }
  49.    ...
  50. }


In the preceding code, a sort decorator decorates the table's original model. When you click on a column header, the application calls the decorator's sort() method. The interesting code in this example is not the application, but the sort decorator. Before looking at the source to TableSortDecorator, let's look at its class diagram, shown in Figure 7. 


[i]Figure 7. Sorting decorator class diagram[/i] 

Since instances of TableSortDecorator decorate table models, TableSortDecorator implements the TableModel interface. TableSortDecorator also maintains a reference to the real model that it decorates. That reference can point to any table model. Example 5 lists the TableSortDecorator class: 

Example 5. A table sort decorator 

  1. class TableSortDecorator implements TableModel,TableModelListener{
  2.    public TableSortDecorator(TableModel model) {
  3.       this.realModel = model;   
  4.       realModel.addTableModelListener(this);
  5.       allocate();
  6.    }
  8.    // The following nine methods are defined by the TableModel
  9.    // interface; all of those methods forward to the real model.
  10.    public void addTableModelListener(TableModelListener l) {
  11.       realModel.addTableModelListener(l);
  12.    }
  13.    public Class getColumnClass(int columnIndex) {
  14.       return realModel.getColumnClass(columnIndex);
  15.    }
  16.    public int getColumnCount() {
  17.       return realModel.getColumnCount();   
  18.    }
  19.    public String getColumnName(int columnIndex) {
  20.       return realModel.getColumnName(columnIndex);
  21.    }
  22.    public int getRowCount() {
  23.       return realModel.getRowCount();   
  24.    }
  25.    public boolean isCellEditable(int rowIndex, int columnIndex) {
  26.       return realModel.isCellEditable(rowIndex, columnIndex);
  27.    }
  28.    public void removeTableModelListener(TableModelListener l) {
  29.       realModel.removeTableModelListener(l);
  30.    }
  31.    public Object getValueAt(int row, int column) {
  32.       return getRealModel().getValueAt(indexes[row], column);
  33.    }
  34.    public void setValueAt(Object aValue, int row, int column) {
  35.       getRealModel().setValueAt(aValue, indexes[row], column);
  36.    }
  38.    // The getRealModel method is used by subclasses to
  39.    // access the real model.
  40.    protected TableModel getRealModel() {
  41.       return realModel;
  42.    }
  44.    // tableChanged is defined in TableModelListener, which
  45.    // is implemented by TableSortDecorator.
  46.    public void tableChanged(TableModelEvent e) {
  47.       allocate();   
  48.    }
  50.    // The following methods perform the bubble sort ...
  52.    public void sort(int column) {
  53.       int rowCount = getRowCount();
  55.       for(int i=0; i < rowCount; i++) {
  56.          for(int j = i+1; j < rowCount; j++) {
  57.             if(compare(indexes[i], indexes[j], column) < 0) {
  58.                swap(i,j);
  59.             }
  60.          }
  61.       }
  62.    }
  63.    private void swap(int i, int j) {
  64.       int tmp = indexes[i];
  65.       indexes[i] = indexes[j];
  66.       indexes[j] = tmp;
  67.    }
  68.    private int compare(int i, int j, int column) {
  69.       TableModel realModel = getRealModel();
  70.       Object io = realModel.getValueAt(i,column);
  71.       Object jo = realModel.getValueAt(j,column);
  73.       int c = jo.toString().compareTo(io.toString());
  74.       return (c < 0) ? -1 : ((c > 0) ? 1 : 0);
  75.    }
  76.    private void allocate() {
  77.       indexes = new int[getRowCount()];
  78.       for(int i=0; i < indexes.length; ++i) {
  79.          indexes[i] = i;         
  80.       }
  81.    }
  82.    private TableModel realModel; // We're decorating this model
  83.    private int indexes[];
  84. }


Table sort decorators do not change their real model when they sort; instead, decorators maintain an array of integers representing sorted row positions. When a sort decorator, masquerading as a table model, is asked for a value at a specific row and column, it uses the row value as an index into its array, and returns the corresponding value from the array. In that way, sort decorators overlay sorting onto Swing table models without modifying the original model in any way. 

TableSortDecorator also implements the TableModelListener interface and registers itself as a listener with the real model. When the real model fires a table changed event, the decorator reallocates its array of sorted index references. That allocation happens in TableSortDecorator.tableChanged. 

TableSortDecorator has 11 public methods. Nine of those methods forward to the real model. Of those nine methods, only two methods -- getValueAt() and setValueAt() -- provide any additional functionality. Such ratios are not unusual among decorators; most decorators add a small amount of behavior to a decorated object that already performs several functions. 

Refactoring the sort decorator

The sort decorator discussed above works as advertised by decorating arbitrary table models with sorting functionality at runtime. This gives you flexibility because the decorated models do not need to be modified, which means that any table model can be decorated with sorting capabilities. 

But the TableSortDecorator as implemented above is not designed for reuse because it implements two responsibilities for which it is not well suited. The first responsibility is forwarding to the real model. Because other table model decorators will need almost exactly the same code, that responsibility is too general, and should be moved up the class hierarchy. The second responsibility is sorting, which in this example is a bubble sort. That sorting algorithm is hardcoded into the sort decorator, which means sorting cannot be changed without rewriting the entire decorator. The sorting algorithm is too specific, so it should be moved down the hierarchy. 

Figure 8 shows the result of refactoring the sort decorator as recommended in the preceding paragraph. 


[i]Figure 8. Refactored sorting decorator class diagram. Click on thumbnail to view full-size image[/i]

The refactoring split the original TableSortDecorator into three different classes: 
  • TableModelDecorator: Implements TableModel by forwarding to the real model 

  • TableSortDecorator: Extends TableModelDecorator and adds an abstract sort method that subclasses must implement 

  • TableBubbleSortDecorator: Extends TableSortDecorator and implements the bubble sort 

By refactoring the sort decorator, we can reuse the code that forwards to the real table model. Encapsulating that code in TableModelDecorator lets us easily develop other table model decorator types, such as the filter decorators -- which are not discussed in this article -- shown in Figure 8. 

The abstract TableSortDecorator class defers the implementation of its sort() method to subclasses, making it trivial to implement sort decorators with a different sorting algorithm. 

Example 6 lists the TableModelDecorator class. 

Example 6. TableModelDecorator 

  1. import javax.swing.table.TableModel;
  2. import javax.swing.event.TableModelListener;
  4. // TableModelDecorator implements TableModelListener. That
  5. // listener interface defines one method: tableChanged(), which
  6. // is called when the table model is changed. That method is
  7. // not implemented in this abstract class; it's left for
  8. // subclasses to implement.
  9. public abstract class TableModelDecorator 
  10.                         implements TableModel, TableModelListener {
  11.    public TableModelDecorator(TableModel model) {
  12.       this.realModel = model;   
  13.       realModel.addTableModelListener(this);
  14.    }
  16.    // The following 9 methods are defined by the TableModel
  17.    // interface; all of those methods forward to the real model.
  18.    public void addTableModelListener(TableModelListener l) {
  19.       realModel.addTableModelListener(l);
  20.    }
  21.    public Class getColumnClass(int columnIndex) {
  22.       return realModel.getColumnClass(columnIndex);
  23.    }
  24.    public int getColumnCount() {
  25.       return realModel.getColumnCount();   
  26.    }
  27.    public String getColumnName(int columnIndex) {
  28.       return realModel.getColumnName(columnIndex);
  29.    }
  30.    public int getRowCount() {
  31.       return realModel.getRowCount();   
  32.    }
  33.    public Object getValueAt(int rowIndex, int columnIndex) {
  34.       return realModel.getValueAt(rowIndex, columnIndex);
  35.    }
  36.    public boolean isCellEditable(int rowIndex, int columnIndex) {
  37.       return realModel.isCellEditable(rowIndex, columnIndex);
  38.    }
  39.    public void removeTableModelListener(TableModelListener l) {
  40.       realModel.removeTableModelListener(l);
  41.    }
  42.    public void setValueAt(Object aValue, 
  43.                         int rowIndex, int columnIndex) {
  44.       realModel.setValueAt(aValue, rowIndex, columnIndex);
  45.    }
  47.    // The getRealModel method is used by subclasses to
  48.    // access the real model.
  49.    protected TableModel getRealModel() {
  50.       return realModel;
  51.    }
  53.    private TableModel realModel; // We're decorating this model
  54. }


Notice that public TableModelDecorator methods do nothing but forward to the real model. That makes them good defaults for other classes to inherit when they extend TableModelDecorator. Example 7 lists TableSortDecorator. 

Example 7. TableSortDecorator 

  1. import javax.swing.table.TableModel;
  3. public abstract class TableSortDecorator extends 
  4.                                          TableModelDecorator {
  5.    // Extensions of TableSortDecorator must implement the
  6.    // abstract sort method, in addition to tableChanged. The
  7.    // latter is required because TableModelDecorator
  8.    // implements the TableModelListener interface.
  9.    abstract public void sort(int column);
  11.    public TableSortDecorator(TableModel realModel) {
  12.       super(realModel);
  13.    }
  14. }


The abstract TableSortDecorator class defines one abstract method -- sort() -- that must be implemented by concrete subclasses. The TableBubbleSortDecorator, listed in Example 8, is one such class. 

Example 8. TableBubbleSortDecorator 

  1. import javax.swing.table.TableModel;
  2. import javax.swing.event.TableModelEvent;
  4. public class TableBubbleSortDecorator extends TableSortDecorator {
  5.    // The lone constructor must be passed a reference to a
  6.    // TableModel. This class decorates that model with additional
  7.    // sorting functionality.
  8.    public TableBubbleSortDecorator(TableModel model) {
  9.       super(model);
  10.       allocate();
  11.    }
  13.    // tableChanged is defined in TableModelListener, which
  14.    // is implemented by TableSortDecorator.
  15.    public void tableChanged(TableModelEvent e) {
  16.       allocate();   
  17.    }
  19.    // Two TableModel methods are overridden from
  20.    // TableModelDecorator ...
  21.    public Object getValueAt(int row, int column) {
  22.       return getRealModel().getValueAt(indexes[row], column);
  23.    }
  24.    public void setValueAt(Object aValue, int row, int column) {
  25.       getRealModel().setValueAt(aValue, indexes[row], column);
  26.    }
  28.    // The following methods perform the bubble sort ...
  30.    public void sort(int column) {
  31.       int rowCount = getRowCount();
  33.       for(int i=0; i < rowCount; i++) {
  34.          for(int j = i+1; j < rowCount; j++) {
  35.             if(compare(indexes[i], indexes[j], column) < 0) {
  36.                swap(i,j);
  37.             }
  38.          }
  39.       }
  40.    }
  41.    private void swap(int i, int j) {
  42.       int tmp = indexes[i];
  43.       indexes[i] = indexes[j];
  44.       indexes[j] = tmp;
  45.    }
  46.    private int compare(int i, int j, int column) {
  47.       TableModel realModel = getRealModel();
  48.       Object io = realModel.getValueAt(i,column);
  49.       Object jo = realModel.getValueAt(j,column);
  51.       int c = jo.toString().compareTo(io.toString());
  52.       return (c < 0) ? -1 : ((c > 0) ? 1 : 0);
  53.    }
  54.    private void allocate() {
  55.       indexes = new int[getRowCount()];
  56.       for(int i=0; i < indexes.length; ++i) {
  57.          indexes[i] = i;         
  58.       }
  59.    }
  60.    private int indexes[];
  61. }


With the refactoring of the original table sort decorator, we now have a hierarchy of table decorators that we can extend at will. 

Decorator applicability

In Java, developers typically use inheritance to add functionality to objects. Base classes implement shared behavior, and extensions add functionality. For example, instead of the sort and filter decorators discussed above, you could implement SortModel, FilterModel, and, perhaps, SortFilterModel classes. 

Decorators prove more flexible than inheritance because the relationship between decorators and the objects they decorate can change at runtime, but relationships between base classes and their extensions are fixed at compile time. 

Of course, both inheritance and the Decorator pattern have their places; in fact, inheritance is used to implement the Decorator pattern. So when should you use the Decorator pattern? It's useful when: 
  • You have many simple behaviors you would like to combine in numerous ways at runtime. Implementing the functionality with inheritance would result in a subclass explosion for every possible combination of behaviors. 

  • You need to transparently add functionality to individual objects at runtime. Transparently means that existing classes need not have been modified to support the extra functionality; indeed, those classes are not aware that they are being decorated. 

  • You want to restrict the use of an object's public methods. Instead of forwarding calls to a restricted method, a decorator can veto a method by throwing an exception from the wrapper method. 
　　--相关文章--
· 面向对象编程,我的思想 (2007-04-13)
· 面向对象的思维方式 (2007-04-13)
· 通过Javanbsp;Swing看透MVC设计模式 (2007-04-13)
· 适配器模式（Adapternbsp;Pattern） (2007-04-13)
· 追MM与Java的23种设计模式 (2007-04-13)
· 责任链模式（Chainnbsp;ofnbsp;Responsibility） (2007-04-13)

版权所有©2005-2006 JAVA资源网 渝ICP备05007591号 虚拟主机 | 关于我们 | 联系方式 | 广告业务 | 网站地图 | 友情链接