到 Google 资讯主页   
EasyJF首页   资料   源码   软件    论坛   网站    
   使用帮助    
    该信息为本站MyRSS系统缓存内容,部分图片及附件有可能无法正常使用.easyjf.com与www.javaresearch.org无关,不对该信息负责.通过http://www.javaresearch.org/article//showarticle.jsp?column=31&thread=917访问该信息的原始内容.
页面功能  【加入收藏】 【推荐给朋友】 【字体：大 中 小】 【关闭】   
Decorate your Java code (2) -- A look at the Decorator design pattern
作者：bruce　来源：www.javaresearch.org 　发布时间：2006-02-28 12:36:57.603


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. 
 
相关文章
 
页面功能  【加入收藏】 【推荐给朋友】 【字体：大 中 小】 【关闭】   


EasyJF.com 2006 隐私政策 使用EasyJF前必读