Chapter 1. 后记

开发者版

开发快照版

extremecomponents-1.0.1-M5-A8（下载） 是正式版发行前的最后开发快照版。这个build版所使用的代码将被下一个release版沿用。

1.0.1-M5-A8

我决定发布一个新的里程碑(milestone)版是因为我对视图(view)的代码做了一些调整，现在eXtremeTable将能够支持AJAX(而不是局部build)。 在确认release候选版前，这些增加的大的特性能够完美地工作。

下面列出的是eXtremeTable下一个里程碑（milestone）版特性和改进，我希望从上一个里程碑版升级到现在这版没有任何问 题（breakage）。 然而，在完成M4版视图实现后，我决定我必须做最后的更改...将静态builders变为具体的类。这将是唯一可能出现问题(breakage)并且 将只影响到定制视图(定制cells也一样，但是更多的是较平和的deprecated)。尽管那样，这些更改将很容易实现。

Html Builder类具体化

所有的视图builder类具体化，需要被实例化，这些只对开发者需要创建定制试图或cells有影响。 这是因为需要使得视图代码能够像他们需要的那样具有弹性。builder classes是静态的能够很好地工作，但是 将来没有机会来做一些有意义的事，并且创建定制试图更加麻烦。然而，现在这些方法和原来的一样，而仅仅是需要对它进行实例化。

为了使这种转变更容易CellBuilder仍然是静态的，但是现在为deprecated。新的(非静态)builder称为ColumnBuilder，通过这个名称我们能更确切地知道什么被构建了。

    public String getHtmlDisplay(TableModel model, Column column) {
        ColumnBuilder columnBuilder = new ColumnBuilder(column);
        columnBuilder.tdStart();
        columnBuilder.tdBody(getCellValue(model, column));
        columnBuilder.tdEnd();
        return columnBuilder.toString();
    }

另一个例子，使用ColumnBuilder定制cells如下：

 public String getHtmlDisplay(TableModel model, Column column) {
        InputBuilder inputBuilder = new InputBuilder(column);
        inputBuilder.tdStart();

        try {
            Object bean = model.getCurrentRowBean();
            Integer id = new Integer(BeanUtils.getProperty(bean, "id"));
            inputBuilder.tdBody(id);

        } catch (Exception e) {}

        inputBuilder.tdEnd();

        return inputBuilder.toString();
    }

    private static class InputBuilder extends ColumnBuilder {
        public InputBuilder(Column column) {
            super(column);
        }

        public void tdBody(Integer id) {
            getHtmlBuilder().input("radio").name("location.id").id("location.id").value(id.toString()).onclick("populateLocationFields(this.value)");
            getHtmlBuilder().xclose();
        }
    }
 } 

这样更简洁，只需要扩展你关心的builder，并构建你定制的实现。

另外toolbar被完全重构，但是这个实现被隐藏在ToolbarBuilder类的背后，所以不会有影响。

最后，我探索性地增加了toolbar特性，这样可以在preferences配置表关联到不同的toolbars。 这个特性能够用来动态构造toolbar。这将使开发者很简单地通过preferences来定义一个定制的toolbar。 例如，一个toolbar当使用Limit定制不包含最后一页按钮，或者另一个toolbar不包含rows displayed... 如果你要定制的就是这些东西而不需要别的新的特性，你最好等待一两个星期直到我实现完成。

新的表的showTitle属性

TableTag新的showTitle属性用来确认是否现实title，这是一个boolean值默认为true。

Limit现在能使用State特性

Limit特性为了使用State特性，你需要使用TableLimitFactory的带有state的构造函数，当使用state 特性时，你应该提供唯一的tableId（本例为presidents），带有state的构造函数同时也需要这个tableId。

    Context context = new HttpServletRequestContext(request);
    LimitFactory limitFactory = new TableLimitFactory(context, presidents, TableConstants.STATE_PERSIST, null);
    Limit limit = new TableLimit(limitFactory);

新的列的filterOptions属性/FilterOption接口

TableTag新的filterOptions属性，能够接受一个filter options的集合，这个集合中的每个bean都实现FilterOption的 接口。被用来和filterCell=droplist结合，当使用Limit时使用定制droplist时非常有用。

导出EXCLE文件时的本地语言的支持

默认的XlsView使用UTF-16编码，这样能够支持对于双字节语言导出。如果要使用unicode，你可以设置 ExportTag的新的encoding属性，这个属性接受的值为：UTF和UNICODE。

删除Compact视图的title的style

当使用compact视图是我硬编码了表的title，这是一个bug。只需要通过CSS的titleRow属性style（或移走）title。

TableModel现在变为接口

TableModel现在变为接口，这只对TableAssembler产生影响。然而，正如下面提到的，使用Java代码来组装一个表将更容易。

TableAssembler整合到TableModel

当使用Java代码来组装一个表将更容易：

    TableModel model = new TableModelImpl(context);

    Table table = new Table(model);
    table.setItems(presidents);
    table.setAction("assembler.run");
    table.setTitle("Presidents");
    table.setShowTooltips(Boolean.FALSE);
    model.addTable(table);

    Row row = new Row(model);
    row.setHighlightRow(Boolean.FALSE);
    model.addRow(row);

    Column columnName = new Column(model);
    columnName.setProperty("fullName");
    columnName.setIntercept((AssemblerIntercept.class).getName());
    model.addColumn(columnName);

    Column columnNickName = new Column(model);
    columnNickName.setProperty("nickName");
    model.addColumn(columnNickName);

    Object view = model.assemble();

重命名FilterSet.getValue()方法

FilterSet.getValue()方法被Deprecated，重命名为FilterSet.getFilterValue()。

删除TableTag的onsubmit

onsubmit被删除，因为javascript被表的所有actions使用。

总计导出

PDF和XLS现在包含总计导出，你只需要和平常一样设置Calc特性。

导出错误-Response头修改

过滤器的response头应该能更好地适应不同环境，在response头后添加：

 response.setHeader("Cache-Control", "must-revalidate, post-check=0, pre-check=0");

列标签autoGenerateColumns的Preferences

autoGenerateColumns属性现在可以在Preferences文件中配置，可以使用别名来避免全路径引用。

自动转换参数

Registry能够接受null、String、List或者Array作为参数，Registry将把这些转换成String[]。

表的bufferView属性

表的bufferView属性，默认为true将使用视图的默认buffer。如果不需要使用buffer可以设置为false。

eXtremeTable的AJAX特性

当使用eXtremeTable API来通过JAVA代码来创建表时，现在可以结合AJAX技术来生成视图。这意味着 当navigate（比如：翻页）时不需要刷新web页，这令人非常兴奋，关于这个特性的更多的文档将会出来。开发 者能够更好地测试并使用这个特性，这个特性的真正hook是表的onInvokeAction属性，它使得javascript方法 能够被invoked。AJAX整合一个最强大的地方是它不需要整合。下一步是使eXtremeTable有一个清晰并且易于使用的API， 这意味着你可以使用你感兴趣的AJAX技术因为eXtremeTable没有整合一个特定的技术。现在你可以通过CVS得到eXtremeSite代码， 它展示了一个使用AJAX的实例，它现在使用HSQL所以只需要下载并直接运行。请暂时不要向我询问更多的文档，我现在正在整理 并将尽可能快的发布出来。

表的items可以使用Map

表的Items可以使用Map(values)，因此可以使用不使用Collection而使用一些key来快速构造。 这个特性正是一个eXtremeComponents使用者需要的。我想这将是一个有趣的特性所以决定在下一个release中发布!

可以定义超过一个显示的行数（rows displayed））

现在可以定义超过一个显示的行数（rows displayed）。这使得在eXtremeTable顶部和底部定义相同的工具条成为可能。

Parameter参数的更多变化

Parameter特性能更好地支持Arrays、Lists、String和其他一些具有toString()的java对象，具有toString（）函数能够转换成一个String数组（array），例如：Number。

修正Export viewResolver属性没有被参照

修正Export viewResolver属性没有被真正使用的bug。这使得定制导出时不需要设置view和viewResolver为相同的命名，而可以给出ViewResolver的全路径或者在配置中配置它的别名。

修正在同一个form中使用两个eXtremeTables时导出的问题

修正在同一个form中使用两个eXtremeTables时导出的问题，现在他们能够互不干扰分别导出。我只是重新组织表实例 （instance）参数(现在命名ec_eti为导出表的id)，这个参数需要被同一个form中的不同表共享，每次request时候被重新设置 （reset）。

如果form还包含其他的按钮（buttons）被条用，导出完毕后你需要调用resetExportParameters(form, action)，它包含在extremecomponents.js文件中。第一个参数是当前的form，第二个参数是form的action。这个是因 为导出使用javaScript进行调用,没有别的办法重新自动reset它。 resetExportParameters做的就是将导出表的id置为空(null),并且将form action设置为原来的值。这很不幸，但是我想不出别的处理方法。

Note: 这个修正也关系到State特性。当使用State设置为persist时，导出也会出现问题。

table.imagePath配置(preference)添加上下文路径（contextPath ）

如果table.imagePath的上下文路径(context path)没有在配置文件(Preferences)中指定，那么将给它自动指定一个。然而，如果路径以表示绝对路径“/”开始，将只给它提供一个上下文 (context)而上下文(contextPath)并没有插入。

使用javascript设置form的method属性

当翻页、过滤、排序时将使用javascript来设置form的method属性。以前只是设置了form的action属性，为了完整性现在也设置了form的method属性。

Bullet Proof Limit feature

如果传入不正确的数据到LimitCallback时，Limit只记录（log）并显示一个警告（warning）。

Intercept被重命名为Interceptor

intercept特性被重命名为interceptor。因此我们现在的interceptors有：TableInterceptor、 RowInterceptor、ExportInterceptor和ColumnInterceptor。他们现在在interceptor包中。遍更 的原因是intercept不如interceptor能给大家提供一种表明他们作用更好的直觉。我不向提供一种我不喜欢的命名。然而，这些方法名都一样 所以能够将他们集中到一个正确的包中。

Using AJAX with the eXtremeTable is a very simple and natural extension to the existing functionality. Probably the best thing about the AJAX integration is there is no integration at all. You are free to use whatever AJAX toolkit you want. All you need to do is tell the eXtremeTable what javascript to use when a table action is invoked. The table actions meaning the filtering, sorting, paging, rows displayed and exporting.

For my example I will be using the ultra cool DWR toolkit. As will be demonstrated, the glue code required by DWR is very minimal, which leaves us to just worry about constructing the table. You can see the working example in action on the site!

Assembler Example

For this example you will need to setup the DWR toolkit, create the POJO to build the table, and make up the JSP that contains the eXtremeTable.

Setup DWR

The first thing to do is download the DWR toolkit. You should read the instructions on the site, but the following is what I needed to do to get things working:

• Place the dwr-1.1.jar into the WEB-INF/lib directory
• Create a dwr.xml file and place it in the WEB-INF directory

<!DOCTYPE dwr PUBLIC
    "-//GetAhead Limited//DTD Direct Web Remoting 1.0//EN"
    "http://www.getahead.ltd.uk/dwr/dwr10.dtd">

<dwr>
  <allow>
    <create creator="new" javascript="Assembler">
      <param name="class" value="org.extremesite.controller.Assembler"/>
      <include method="getTable"/>
    </create>
  </allow>
  <signatures>
    <![CDATA[
       import java.util.Map;
       import java.util.List;
       import org.extremesite.controller.Assembler;
       import javax.servlet.http.HttpServletRequest;
       Assembler.getTable(Map<String, List> parameterMap, HttpServletRequest request);
       ]]>
  </signatures>
</dwr>

In a nutshell the create tag allows you to reference the POJO that builds the table, along with the method to invoke. The signature tag declares what the actual types are for the method that is invoked. In this example the Assembler class getTable method will be called by passing in a Map, with the form parameters, along with the HttpServletRequest.

• Reference the DWR servlet in the WEB-INF/web.xml file

  <servlet>
    <servlet-name>dwr-invoker</servlet-name>
    <display-name>DWR Servlet</display-name>
    <servlet-class>uk.ltd.getahead.dwr.DWRServlet</servlet-class>
    <init-param>
       <param-name>debug</param-name>
       <param-value>true</param-value>
    </init-param>
  </servlet>
  <servlet-mapping>
    <servlet-name>dwr-invoker</servlet-name>
      <url-pattern>/dwr/*</url-pattern>
  </servlet-mapping>

This is setting up the DWR servlet that is used to call your POJO. There is nothing more you should have to know about the servlet other than how to set it up here.

Create POJO

DWR works with POJOs. This works great for our needs because the eXtremeTable has a full API that feels very much like building a table with the JSP tags. In fact the JSP tags are merely a front end for the eXtremeTable Java API. First I will show the method that builds the table.

public class Assembler {
  private Object build(TableModel model, Collection presidents) throws Exception {
    Table table = model.getTableInstance();
    table.setTableId("assembler");
    table.setItems(presidents);
    table.setAction(model.getContext().getContextPath() + "/assembler.run");
    table.setTitle("Presidents");
    table.setOnInvokeAction("buildTable('assembler')");
    model.addTable(table);

    Export export = model.getExportInstance();
    export.setView(TableConstants.VIEW_XLS);
    export.setViewResolver(TableConstants.VIEW_XLS);
    export.setImageName(TableConstants.VIEW_XLS);
    export.setText(TableConstants.VIEW_XLS);
    export.setFileName("output.xls");
    model.addExport(export);

    Row row = model.getRowInstance();
    row.setHighlightRow(Boolean.FALSE);
    model.addRow(row);

    Column columnName = model.getColumnInstance();
    columnName.setProperty("fullName");
    columnName.setIntercept((AssemblerIntercept.class).getName());
    model.addColumn(columnName);

    Column columnNickName = model.getColumnInstance();
    columnNickName.setProperty("nickName");
    model.addColumn(columnNickName);

    Column columnTerm = model.getColumnInstance();
    columnTerm.setProperty("term");
    model.addColumn(columnTerm);

    Column columnBorn = model.getColumnInstance();
    columnBorn.setProperty("born");
    columnBorn.setCell(TableConstants.DATE);
    model.addColumn(columnBorn);

    Column columnDied = model.getColumnInstance();
    columnDied.setProperty("died");
    columnDied.setCell(TableConstants.DATE);
    model.addColumn(columnDied);

    Column columnCareer = model.getColumnInstance();
    columnCareer.setProperty("career");
    model.addColumn(columnCareer);

    return model.assemble();
  }
}

Most of this code should be very self explanatory. You will see how to build a TableModel in a second, but first you will notice that it is the only object you will have to interact with to build the table. The first step to building a table is use the TableModel to create the Table, Row, Column and Export. Once you create one of the model objects it needs to be added to the model. Until you actually add it the TableModel, the model will not use it. Once you have everything constructed then call model.assemble(); to build the table.

Probably the most interesting call is table.setOnInvokeAction("buildTable('assembler')");. This is the javascript method that will be called when you invoke any of the table actions (paging, filtering, sorting, etc..). If the table onInvokeAction is left blank the default javascript method is to submit the form that wraps the eXtremeTable, just like you would expect.

The other method of the Assembler class is getTable().

public class Assembler {
  public String getTable(Map parameterMap, HttpServletRequest request) {
    WebApplicationContext webApplicationContext = WebApplicationContextUtils.getWebApplicationContext(request.getSession().getServletContext());

    PresidentsDao presidentsDao = (PresidentsDao) webApplicationContext.getBean("presidentsDao");
    Collection presidents = presidentsDao.getPresidents();

    Context context = null;
    if (parameterMap == null) {
      context = new HttpServletRequestContext(request);
    } else {
      context = new HttpServletRequestContext(request, parameterMap);
    }

    TableModel model = new TableModelImpl(context);
    try {
      return build(model, presidents).toString();
    } catch (Exception e) {
      e.printStackTrace();
    }

    return "";
  }
}

This method is a little busy, but it is doing double duty. It needs to be called the first time by the Controller (if using Spring). If you use Struts this is the equivalent of the Action class. Then, when using AJAX, this method also needs to be called, but this time passing in a custom parameterMap. The parameterMap will contain all the parameters for the eXtremeTable using AJAX. This should become more clear once you see the Controller and the JSP.

Controller

public class AssemblerController extends AbstractController {
  public String successView;

  public void setSuccessView(String successView) {
    this.successView = successView;
  }

  protected ModelAndView handleRequestInternal(HttpServletRequest request, HttpServletResponse response) throws Exception {
    ModelAndView mv = new ModelAndView(successView);
    Assembler assembler = new Assembler();
    Object viewData = assembler.getTable(null, request);
    request.setAttribute("assembler", viewData);
    return mv;
  }
}

The controller is called the first time to initially build the table. It calls the POJO and then passes the table to the request. Notice how null is sent in for the parameterMap. This is because the first time the table is built there are no table actions the table needs to be aware of.

JSP

Start constructing the JSP by importing the proper javascript files. The only javascript file you need to include in your project is the extremecomponents.js. The other declarations are used by DWR.

  <script type="text/javascript" src="<c:url value="/dwr/interface/Assembler.js"/>"></script>
  <script type="text/javascript" src="<c:url value="/dwr/engine.js"/>"></script>
  <script type="text/javascript" src="<c:url value="/dwr/util.js"/>"></script>
  <script type="text/javascript" src="<c:url value="/js/extremecomponents.js"/>"></script>

Then put in the hook to display the table. The div is used to call the innerHtml and stream the new markup.

  <div id="tableDiv">
    <c:out value="${assembler}" escapeXml="false"/> 
  </div>

Lastly, declare the javascript to call the DWR hooks.

<script type="text/javascript">
  function buildTable(form) {
    var parameterMap = getParameterMap(form);   
    Assembler.getTable(parameterMap, showTable);
  }

  function showTable(table) {
    document.getElementById('tableDiv').innerHTML=table;
  }
</script>

The getParameterMap() method is included in the extremecomponents.js file and will grab all the form parameters. You need to pass in a reference to the form id that wraps the eXtremeTable. Remember that the eXtremeTable is essentially a form component and the tableid is used as the form id. By default the tableId is ec, but you usually want to set a tableId so that code is easier to follow for people reading your code. With the parameterMap you will then call the POJO getTable method. The showTable is a callback that tells DWR what to call when it returns from the getTable() method.

Conclusion

This tutorial described the steps needed to get the eXtremeTable working with AJAX. One of the main things to keep in mind is there is no actual integration with AJAX. You simply tell the eXtremeTable what javascript to call when one of the table actions is invoked. The other thing to get from this example is that the DWR toolkit works with POJOs and can be easily used with any framework.

进行中...

在eXtremeTable中使用AJAX非常简单，对现有功能的扩展也非常方便。 AJAX整合一个最强大的地方是它不需要整合。你可以自由地使用任何你想要使用的AJAX工具包。所有你要做的就是：当表的action被调用时，告诉 eXtremeTable使用什么javascript。表的actions包括：过滤、排序、分页、显示的行数和导出。

在我自己的示例中我将使用非常酷的DWR工具包。DWR 需要的粘合代码非常少，这样我们只需要关注如何构建表。你可以通过本站示例看到效果!

Assembler Example

本示例中将需要安装DWR工具包，创建POJO来构造表并创建包含eXtremeTable的JSP页面。

安装DWR

首先要做的就是下载DWR工具包。你应该浏览网站的使用说明，不过下面是我让它符合我的需要来工作所进行的操作:

• 将dwr-1.1.jar拷贝到WEB-INF/lib目录
• 在WEB-INF目录下创建一个dwr.xml文件

<!DOCTYPE dwr PUBLIC
    "-//GetAhead Limited//DTD Direct Web Remoting 1.0//EN"
    "http://www.getahead.ltd.uk/dwr/dwr10.dtd">

<dwr>
  <allow>
    <create creator="new" javascript="Assembler">
      <param name="class" value="org.extremesite.controller.Assembler"/>
      <include method="getTable"/>
    </create>
  </allow>
  <signatures>
    <![CDATA[
       import java.util.Map;
       import java.util.List;
       import org.extremesite.controller.Assembler;
       import javax.servlet.http.HttpServletRequest;
       Assembler.getTable(Map<String, List> parameterMap, HttpServletRequest request);
       ]]>
  </signatures>
</dwr>

简而言之（In a nutshell）创建（create）标签允许当方法被调用时，参照构建表需要的POJO。签名（signature）标签声明了被调用方法使用的实际 类型。 本示例的Assembler类的getTable方法将通过传入一个Map（包含form参数）和HttpServletRequest。

• 在WEB-INF/web.xml中对DWR servlet进行声明

  <servlet>
    <servlet-name>dwr-invoker</servlet-name>
    <display-name>DWR Servlet</display-name>
    <servlet-class>uk.ltd.getahead.dwr.DWRServlet</servlet-class>
    <init-param>
       <param-name>debug</param-name>
       <param-value>true</param-value>
    </init-param>
  </servlet>
  <servlet-mapping>
    <servlet-name>dwr-invoker</servlet-name>
      <url-pattern>/dwr/*</url-pattern>
  </servlet-mapping>

以上就完成了DWR servlet的设置，它被用来调用你的POJO。除了设置它，你不需要对这个servlet有更多的了解。

创建POJO

DWR使用（works with）POJOs。这个非常符合我们的需要，因为eXtremeTable有足够的API使用Jsp标签来构造表。实际上，JSP标签只不过是eXtremeTable Java API的前端。首先，我将展示构造表的方法：

public class Assembler {
  private Object build(TableModel model, Collection presidents) throws Exception {
    Table table = model.getTableInstance();
    table.setTableId("assembler");
    table.setItems(presidents);
    table.setAction(model.getContext().getContextPath() + "/assembler.run");
    table.setTitle("Presidents");
    table.setOnInvokeAction("buildTable('assembler')");
    model.addTable(table);

    Export export = model.getExportInstance();
    export.setView(TableConstants.VIEW_XLS);
    export.setViewResolver(TableConstants.VIEW_XLS);
    export.setImageName(TableConstants.VIEW_XLS);
    export.setText(TableConstants.VIEW_XLS);
    export.setFileName("output.xls");
    model.addExport(export);

    Row row = model.getRowInstance();
    row.setHighlightRow(Boolean.FALSE);
    model.addRow(row);

    Column columnName = model.getColumnInstance();
    columnName.setProperty("fullName");
    columnName.setIntercept((AssemblerIntercept.class).getName());
    model.addColumn(columnName);

    Column columnNickName = model.getColumnInstance();
    columnNickName.setProperty("nickName");
    model.addColumn(columnNickName);

    Column columnTerm = model.getColumnInstance();
    columnTerm.setProperty("term");
    model.addColumn(columnTerm);

    Column columnBorn = model.getColumnInstance();
    columnBorn.setProperty("born");
    columnBorn.setCell(TableConstants.DATE);
    model.addColumn(columnBorn);

    Column columnDied = model.getColumnInstance();
    columnDied.setProperty("died");
    columnDied.setCell(TableConstants.DATE);
    model.addColumn(columnDied);

    Column columnCareer = model.getColumnInstance();
    columnCareer.setProperty("career");
    model.addColumn(columnCareer);

    return model.assemble();
  }
}

上面的大部分代码是自解释性的，你将在下面看到如何构造一个TableModel，但是首先你应该注意到TableModel是构造表时需要交互的 唯一对象。构造表的第一步就是使用TableModel来创建Table、Row、Column和Export。 一旦你创建了一个model对象，你只需要将它添加到model中。除非你将它添加到TableModel，否则的话model将不会是用它。所有东西已 经构建好后，你只需要调用model.assemble()方法来构造表了。

可能table.setOnInvokeAction("buildTable('assembler')");是最有趣的调用。当你使用表的actions(翻页、过滤、排序......)，这个javascript方法将被调用。如果表的onInvokeAction空白，则默认的javascript方法将被提交（submit） ，正如你所期望的那样。

Assembler类的另一个方法---getTable()：

public class Assembler {
  public String getTable(Map parameterMap, HttpServletRequest request) {
    WebApplicationContext webApplicationContext = WebApplicationContextUtils.getWebApplicationContext(request.getSession().getServletContext());

    PresidentsDao presidentsDao = (PresidentsDao) webApplicationContext.getBean("presidentsDao");
    Collection presidents = presidentsDao.getPresidents();

    Context context = null;
    if (parameterMap == null) {
      context = new HttpServletRequestContext(request);
    } else {
      context = new HttpServletRequestContext(request, parameterMap);
    }

    TableModel model = new TableModelImpl(context);
    try {
      return build(model, presidents).toString();
    } catch (Exception e) {
      e.printStackTrace();
    }

    return "";
  }
}

这个方法调用比较频繁，它执行双重职责。它需要被Controller（如果使用Spring的话）在第一次调用，如果使用Struts就等同于Action类。 随后， 当使用AJAX时，这个方法也需要被调用，但是这次将传入一个定制的parameterMap。parameterMap将包含eXtremeTable使用AJAX需要的所有参数。当你看了 Controller和JSP后，这点将更加清晰。

Controller

public class AssemblerController extends AbstractController {
  public String successView;

  public void setSuccessView(String successView) {
    this.successView = successView;
  }

  protected ModelAndView handleRequestInternal(HttpServletRequest request, HttpServletResponse response) throws Exception {
    ModelAndView mv = new ModelAndView(successView);
    Assembler assembler = new Assembler();
    Object viewData = assembler.getTable(null, request);
    request.setAttribute("assembler", viewData);
    return mv;
  }
}

controller在被第一次调用时来构建表。它调用POJO并将表传给request。注意空值（null）如何使用parameterMap传输。这是因为第一次表被构造时，没有对应表需要知道的actions。

JSP

通过引入(importing)合适的javascript文件来开始构建JSP页面。唯一需要包含进工程的javascript文件是extremecomponents.js，其它的javascript文件申明都是DWR使用的。

  <script type="text/javascript" src="<c:url value="/dwr/interface/Assembler.js"/>"></script>
  <script type="text/javascript" src="<c:url value="/dwr/engine.js"/>"></script>
  <script type="text/javascript" src="<c:url value="/dwr/util.js"/>"></script>
  <script type="text/javascript" src="<c:url value="/js/extremecomponents.js"/>"></script>

接着，插入钩子（hook)来显示表，div被用来调用innerHtml并构建新的标签。

  <div id="tableDiv">
    <c:out value="${assembler}" escapeXml="false"/> 
  </div>

最后，添加javascript来调用DWR的钩子（hooks）。

<script type="text/javascript">
  function buildTable(form) {
    var parameterMap = getParameterMap(form);   
    Assembler.getTable(parameterMap, showTable);
  }

  function showTable(table) {
    document.getElementById('tableDiv').innerHTML=table;
  }
</script>

getParameterMap()方法包含在extremecomponents.js文件中，将的到所有的form参数。你需要传入一个 form id的参照。记住，eXtremeTable本质上是一个form组建，tableid作为form id使用。默认的tableId为ec，但是你通常想要设置tableId，以示大家能更容易阅读你的代码。你将使用parameterMap调用 POJO的getTable方法。showTable是一个callback告诉DWR当从getTable()方法返回时将调用什么操作。

结论

本指南描述了在eXtremeTable中使用AJAX所需要的步骤。需要留心的一个主要事情是没有和AJAX发生实际整合。当表的actions 被使用是，你只需要简单地告诉eXtremeTable什么javascript将被调yong。另一个事情是，通过本示例我们可以知道DWR工具包使用 POJOs并能够简单地被任何框架使用。

1）导出EXCLE文件时的本地语言的支持

        默认的XlsView使用UTF-16编码，这样能够支持对于双字节语言导出。如果要使用unicode，你可以设置 ExportTag的新的encoding属性，这个属性接受的值为：UTF和UNICODE。

2) 导出PDF文件时的本地语言的支持
       eXtremeComponents使用FOP来导出PDF文件，现在eXtremeComponents能够根据支持FOP对于导出双字节语言PDF的应用，具体操作请参照最新eXtremeComponents包：支持 PDF中文导出

3）AJAX特性

        eXtremeComponents现在能够支持AJAX，这使得用户可以在不刷新页面的情况下进行相关操作。

          最新的eXtremeSite实例代码（eXtremeComponents的全站代码，包括大多数展示M5升级说明特性：Ajax、通过Java生成表......），我将在整理后放到Sina邮箱中。用户名： extremetable 密码：extremetable.

          eXtremeSite使用Hsql，所以运行时不需要另外配置数据库。

             P.S. 刚才登录Sina邮箱，提示我这个邮箱存在技术问题（晕）。 大家可以通过eXtremeComponents网站下载最新eXtremeSite.zip或从CVS中获取代码。

From ExtremeComponents

Development Snapshot Release

This is the latest Development Snapshot Release (download). This build represents the code for the next release.

1.0.1-M5-A4

I decided to do another milestone release because I made some adjustments to the view code, and the eXtremeTable is now going to be AJAX enabled (not part of build yet). These are big enough features that I would really like to work perfectly before the release candidate.

The following features and enhancements represent the next milestone build of the eXtremeTable. I was hoping to not have any breakage going from the last milestone to this milestone. However, after working through the implementation of the M4 view code I decided I had to make one final change...going from static builders to concrete classes. This will be the only breakage and only effects those with custom views (custom cells too, but more gracefully deprecated). Even then the changes can be easily implemented.

Html Builder classes are concrete now.

All the view builder classes are concrete and need to be instantiated. This only effects developers that have created custom views or custom cells. This was a much needed change to make the view code as flexible as it needs to be. Having the builder classes be static worked Ok, but there would be no opportunities to do anything interesting in the future, and made creating custom views more difficult. However, the methods are all the same yet and just requires a builder class to be instantiated with an HtmlBuilder.

To make the transition easier the CellBuilder is still static, but is now deprecated. The new (non-static) builder is called the ColumnBuilder, which actually makes more sense as that is what is being built.

   public String getHtmlDisplay(TableModel model, Column column) {
       ColumnBuilder columnBuilder = new ColumnBuilder(column);
       columnBuilder.tdStart();
       columnBuilder.tdBody(getCellValue(model, column));
       columnBuilder.tdEnd();
       return columnBuilder.toString();
   }

As another example, now that the ColumnBuilder is not static I would write custom cells more like this:

 public String getHtmlDisplay(TableModel model, Column column) {
        InputBuilder inputBuilder = new InputBuilder(column);
        inputBuilder.tdStart();

        try {
            Object bean = model.getCurrentRowBean();
            Integer id = new Integer(BeanUtils.getProperty(bean, "id"));
            inputBuilder.tdBody(id);

        } catch (Exception e) {}

        inputBuilder.tdEnd();

        return inputBuilder.toString();
    }

    private static class InputBuilder extends ColumnBuilder {
        public InputBuilder(Column column) {
            super(column);
        }

        public void tdBody(Integer id) {
            getHtmlBuilder().input("radio").name("location.id").id("location.id").value(id.toString()).onclick("populateLocationFields(this.value)");
            getHtmlBuilder().xclose();
        }
    }
 } 

It is much cleaner to just extend the builder you care about and then build your custom implmentation.

In addition the toolbar code has been completely refactored, but the implemenation was hidden behind the ToolbarBuilder class and so no one should be effected by the changes.

Lastly, I am exploring creating a named toolbar feature that would enable different toolbars to be referenced in the preferences and on the table. The feature would use reflection to dynamically build the toolbar. This would enable a developer to easily define a custom toolbar through the preferences. For example a toolbar could be defined to not include the last page for the Limit, or another toolbar that does not include the rows displayed...things like that. If this is the only reason you have a custom view you are better off waiting a week or two until I get this done, unless you need one of the new features.

New Table showTitle attribute.

New TableTag showTitle attribute is used to specify whether or not to show the title. This is a boolean value with the default being true.

Limit can now use the State feature.

To use the State feature with the Limit feature you need to use the TableLimitFactory constructor that accepts the state. When using the state feature you should always give a unique tableId (in this example called presidents) so the constructor with the state will require the tableId also.

   Context context = new HttpServletRequestContext(request);
   LimitFactory limitFactory = new TableLimitFactory(context, presidents, TableConstants.STATE_PERSIST, null);
   Limit limit = new TableLimit(limitFactory);

New Column filterOptions attribute / FilterOption interface.

New ColumnTag filterOptions attribute. Accepts a Collection of filter options where each bean in the Collection implements the FilterOption interface. Is used in conjunction with the filterCell=droplist. Very useful when using the Limit to use a custom droplist.

New Export encoding attribute / XlsView has Locale support.

By default the XlsView uses UTF-16 character encoding. If you need to use unicode then use the new ExportTag encoding attribute. The acceptable values are UTF and UNICODE.

Removed the style attribute from the Compact View title.

This was kind of bug in the view code as I hard coded the title of the table when using the compact view. Just style (or move) the title through the CSS titleRow attribute.

TableModel is an Interface now.

The TableModel is now an interface. This does not impact any code except the TableAssembler. However, as mentioned below, assembling a table with just Java code is even easier now.

TableAssembler is integrated into the TableModel.

When building an eXtremeTable in Java code in the last release you would use the TableAssembler class. That code was refactored and completely integrated into the TableModel. This makes the feature even easier to use than before.

    TableModel model = new TableModelImpl(context);

    Table table = new Table(model);
    table.setItems(presidents);
    table.setAction("assembler.run");
    table.setTitle("Presidents");
    table.setShowTooltips(Boolean.FALSE);
    model.addTable(table);

    Row row = new Row(model);
    row.setHighlightRow(Boolean.FALSE);
    model.addRow(row);

    Column columnName = new Column(model);
    columnName.setProperty("fullName");
    columnName.setIntercept((AssemblerIntercept.class).getName());
    model.addColumn(columnName);

    Column columnNickName = new Column(model);
    columnNickName.setProperty("nickName");
    model.addColumn(columnNickName);

    Object view = model.assemble();

Renamed FilterSet.getValue() method.

Deprecated the poorly named FilterSet.getValue() method and renamed it to FilterSet.getFilterValue().

Remove TableTag onsubmit.

The onsubmit was removed as it was never being called because javascript is used for all the table actions.

Export Totaling

The PDF and XLS exports now include totaling capability. There is nothing you need to do except use the Calc feature as normal.

Export Errors - Response Headers Change

The filter response headers should handle exporting in different environments better. Add the following to the response headers:

response.setHeader("Cache-Control", "must-revalidate, post-check=0, pre-check=0");

ColumnsTag autoGenerateColumns Preferences

The tag attributes that are backed by an interface have the ability to alias out the attribute to avoid having to give the fully qualified package name. The ColumnsTag autoGenerateColumns attribute now includes this feature.

Automatically Convert Parameters

Greatly improved the Registry to accept either a null, String, List or Array as a parameter. The Registry will convert it to a String[] for you.

TableTag bufferView attribute

TableTag bufferView attribute. The default is true to buffer the view by default. This will improve the performance of the tag rendering in that the html view is streamed right out to the response writer if the bufferView is set to false. This does in theory improve the performance but I only included the feature because I thought it would be a nice feature. In general the eXtremeTable is very streamlined and this is just an additional performance kick.

AJAX enable the eXtremeTable

When creating a table with Java code using the eXtremeTable API it is now possible to combine AJAX technology to render the view. For those new to AJAX this means that the web page does not have to refresh to navigate the eXtremeTable! This is very exciting and more documentation will be coming out soon so that developers can start testing and using this feature. The only real hook to use this feature is to use the new Table onInvokeAction attribute to give the javascript method that should be invoked. One of the most powerful aspects of the AJAX integration is there is no integration. The eXtremeTable has a very clear and easy API to use and so this was the logical next step. This also means you can use your favorite AJAX technology as the eXtremeTable does not actually integrate with any specific one. There is an example in the site code that is only checked into CVS right now. However, my site runs on HSQL now so anyone can check out the source code and run the example. Please do not ask for more documentation at this time as I will be working to pull some together and will have it available soon!

如何在程序中嵌入FOP

在 Web 应用程序中动态生成国际化的 PDF

TableTag的collection属性被删除，现在变为三个新属性：tableId、items和var。 因为我按照标准的JSTL命名，你应该能够根据这些名称知道他们的作用。tableId属性 被用来作为表的唯一标识，items属性用来表示从各种servlet的scopes里取得的集合， var属性表示你将使用EL编写脚本的名称。

依赖你的需要来决定如何使用新的属性，tableId用来唯一标识表。如果你的页面上只使用了 一个eXtremeTable并且不使用Limit特性，那么你根本不需要定义它。默认的表示名为'ec'；如果使用 Limit特性你也可以使用'ec'这个名称。然而，如果的一个JSP页面上同时使用两个eXtremeTables你就 需要使用tableId来唯一标识他们。var属性被用来你将使用EL编写脚本的名称。items属性用来表示从 各种servlet的scopes里取得的集合，而且现在非常健壮。你现在能nest集合到另外的对象，或者nest你想的 深度。

取得集合的语法如下：

<ec:table items="command.myObject.myCol" />

本示例将从命令对象（command object）取得myCol集合。

<ec:table items="myCol" />

本示例中将根据名称自动取得集合，就像以前版本的collection属性一样。

table.imagePath=/extremesite/images/*.gif
table.rowsDisplayed=12
column.parse.date=yyyy-MM-dd
column.format.date=MM/dd/yyyy
column.format.currency=$###,###,##0.00

statusbar.resultsFound={0} results found, displaying {1} to {2}
statusbar.noResultsFound=There were no results found.

toolbar.firstPageTooltip=First Page
toolbar.lastPageTooltip=Last Page
toolbar.prevPageTooltip=Previous Page
toolbar.nextPageTooltip=Next Page
toolbar.filterTooltip=Filter
toolbar.clearTooltip=Clear

toolbar.clearText=Clear
toolbar.firstPageText=First
toolbar.lastPageText=Last
toolbar.nextPageText=Next
toolbar.prevPageText=Prev
toolbar.filterText=Filter

column.headercell.sortTooltip=Sort By

column.calc.total=Total
column.calc.average=Average

Context context = new HttpServletRequestContext(request);
LimitFactory limitFactory = new TableLimitFactory(context, tableId);
Limit limit = new TableLimit(limitFactory);

limit.setRowAttributes(totalRows, DEFAULT_ROWS_DISPLAYED);

Context context = new HttpServletRequestContext(request);
LimitFactory limitFactory = new TableLimitFactory(context);

public interface State {
    public void saveParameters(TableModel model, Map parameters);
    public Map getParameters(TableModel model);
}

<ec:column property="data" calc="total" calcTitle="Total:" />

public interface Calc {
    public Number getCalcResult(TableModel model, Column column);
}

Context context = new HttpServletRequestContext(request);
LimitFactory limitFactory = new TableLimitFactory(context, tableId);
Limit limit = new TableLimit(limitFactory);

Context context = new HttpServletRequestContext(request);
LimitFactory limitFactory = new TableLimitFactory(context);
Limit limit = new TableLimit(limitFactory);

private FilterSet filterSet;
private Sort sort;

private final String action;
private final Filter[] filters;

private Sort sort;

limit.setRowAttributes(totalRows, DEFAULT_ROWS_DISPLAYED);

private int rowStart;
private int rowEnd;
private int currentRowsDisplayed;
private int page;
private int totalRows;

<ec:table
  items="presidents"
  retrieveRowsCallback="limit"
  filterRowsCallback="limit"
  sortRowsCallback="limit"
  action="${pageContext.request.contextPath}/limit.run"
  title="Presidents"
  >
  <ec:row>
    <ec:column property="fullName" title="Name"/>
    <ec:column property="nickName" />
    <ec:column property="term" />
    <ec:column property="born" cell="date"/>
    <ec:column property="died" cell="date"/>
    <ec:column property="career" />
  </ec:row>
 </ec:table>

request.setAttribute("pres", presidents);
request.setAttribute("pres_totalRows", new Integer(""+totalRows));

译者注:关于limit使用的更详细信息，请参考《Limit指南》。