This is a general step that happens when m2e/m2eclipse (Maven integration for Eclipse) is installed, whether projects are actively using it or not.
这是因为m2eclipse(maven插件)要在启动时需要进行的一个步骤。

This step can be disabled through the Eclipse preferences: Window / Preferences / Maven / "Download repository index updates on startup". This option is on the main "Maven" preference page (not a child page). Just uncheck the box to prevent this from happening.
我们可以停止这个动作。方法：Windows -> Preferences -> Maven 取消勾选 Download repository index updates on startup

1. Go to web project properties.
2. Deployment Assembly (Left).
3. Add > Select project > Select your lib project > Check "Assemble projects into the WEB-INF/lib folder of the web application" if not checked > Finish.

Retina 屏幕的概念最早由苹果公司执行长史蒂夫·乔布斯（Steve Jobs）于 WWDC2010 发布 iPhone 4 时提出的。

　　定义是：要求在正常观看距离下，足以使人肉眼无法分辨其中的单独像素。因此它并没有限定像素值多少。

4K 就是水平方向每一行的像素值达到或是接近 1024 的 4 倍，8K 就是达到或接近 8 倍。

　　以此为标准，4K 一般图像就是指 4096*2160 的分辨率。当然，这也不是硬性要求，像市场上很多 4K 屏幕其实是 3840*2160 或是 3656*2664，这些都是 4K 图像分辨率的范畴。

　　8K 就是分辨率在 7680*4320 左右。

顺便说一下，720p 则是指竖直方向的像素点达到 720 个，1080p 则是 1080 个，“P”是逐行扫描的意思

问：那到底 Retina 和 4K 或是 Retina 和 8K 哪个更清楚呢？

　　答：不一定，二者不能平行比较。

　　因为 4K 和 8K 是限定了像素点的多少，而 Retina 是要求正常距离看不到像素点。

　　举个例子：如果放到正常的 42 寸屏幕上，4K 和 8K 在正常距离观看下都看不到像素点，那么两者都可以被称作“Retina 屏幕”。

      可是如果给你一台 500 寸的巨大屏幕，那么即便是 8K 也会到处是马赛克，这时 Retina 观感依然是高清无像素点，必然比 8K 和 4K 清楚的多。

Where are the Database Files Stored?

When using database URLs like jdbc:h2:~/test, the database is stored in the user directory. For Windows, this is usually C:\Documents and Settings\<userName> or C:\Users\<userName>. If the base directory is not set (as in jdbc:h2:test), the database files are stored in the directory where the application is started (the current working directory). When using the H2 Console application from the start menu, this is<Installation Directory>/bin. The base directory can be set in the database URL. A fixed or relative path can be used. When using the URL jdbc:h2:file:data/sample, the database is stored in the directory data(relative to the current working directory). The directory is created automatically if it does not yet exist. It is also possible to use the fully qualified directory name (and for Windows, drive name). Example:jdbc:h2:file:C:/data/tes

window.location="download.action?para1=value1...."

Bug

    *  Element.forceAttribute uses the element's namespace to match the attribute.
    *  Element.attribute(String name, String value) adds elements that already exist
    *  Element#addClassName can create an additional new 'class' attribute
    *  Properties defined in an Interface are not exposed by PropertyAccess for abstract classes that do not directly implement the methods
    *  Some services require a notification that they have been reloaded, so they can clean up external dependencies
    *  Whitespaces in SymbolConstants.SUPPORTED_LOCALES cause that locales are not persised
    *  Validation macros do not work when used in @Validate annotation
    *  Client-side validation of @Pattern is broken
    *  Linking a Form to a Zone will no longer work unless the Form contains validated fields
    *  When using PropertyShadowBuilder to build a service, if the property is null, an immediate exception is needed (rather than a NullPointerException)
    *  When using a MultiZoneUpdate, Tapestry will clear the referenced zone

Improvement

    *  Add the facility to optionally disable on-focus-change triggered validation while retaining the on-form-submit validation
    *  Form component should be able to render a secure URL even on an insecure page
    *  New annotations @Decorate and @Advise to identify methods that decorate or annotate services
    *  Extend Link with new methods for producing absolute URLs (that include scheme, hostname, etc.)
    *  Simplify connecting a link or form to an (enclosing) Zone
    *  BeanBlockContribution should be split into two sub-classes: EditBlockContribution and DisplayBlockContribution
    *  Define a special CSS class to prevent a client-side form from submitting normally (for Ajax use cases)
    *  Additional method for Link: addParameterValue(String,Object) that uses ContextPathEncoder to encode object value to a string
    *  SeleniumTestCase should expose the underlying CommandProcessor, to allow execution of commands not defined by the Selenium interface
    *  Allow individual SeleniumTestCases to run w/o configuring SeleniumLauncher

今天在网上转了转，发现Tapestry又有了新动作。
1、从5.2.0alpha版8月11日发布到现在，终于发布5.2.1Beta版了。这个版本主要是修改alpha版本中的bug.
5.2相对于5.1进行了许多重大的改进，详细内容可见：Tapestry5.2的新变化
2、据称在5.3版中将引入大量的新功能，具体内容不详。
3、以往最令人诟病的文档问题，目前开发小组也在努力解决。
     首先，建立了新的文档网页：http://people.apache.org/~uli/tapestry-site/，不过目前这个网站还没有完全完成，只能算是预览版，但是这毕竟是在正确的道路上前进。
     其次，Tapestry 5 in action一书正在写作中，已经完成20%，预计明年一季度能够出版。
我相信，随着功能的不断完善和补充，再加上文档的逐渐充实，Tapestry完全有理由能吸引更多的开发者来关注和使用。

这是mybatis从ibatis更名过来后，发布的第2个版本（第1个版本是3.0.1)。
在这个版本中只修复了4个bug(感觉数目有点少，难道是因为上一个版本的bug真的如此之少?)，增加了一个小功能.
作者的话：尽管只有5个修改，但我还是觉得值得为此发布一个新版本。
这5个修改是：
1、在org.apache.ibatis.Session中增加了一个新方法：void select(String statement, ResultHandler handler);
原来只有：
 void select(String statement, Object parameter, ResultHandler handler);
 void select(String statement, Object parameter, RowBounds rowBounds, ResultHandler handler);

2、修复了ManagedConnection中关闭连接的问题
3、修复了schema migration中，语句提交(statement commit)不正确的问题
4、修复了延迟加载已经预读取属性时的问题
5、修复了schema migration中，FileInputStream没有正确关闭的问题

jquery有一个很方便的插件UI Table Filter可以根据输入的内容隐藏显示表格中相应的数据行。
因为目前使用的tapestry捆绑的是prototype，所以就自己写了一个类似的插件。

<html>
<head>
<script src="prototype-1.6.0.2.js" type="text/javascript"></script>
<script language="javaScript">
 Event.observe(window, 'load', function() {
  Event.observe('filter', 'keyup', filterTable);
 });
 function filterTable() {
  var filterCaseElement = document.getElementById('filterCase');
  var caseSensitive = filterCaseElement.checked;
  
  $$('tr').each(function(trElement, ind) {
   var val = $('filter').value;
   
   if ( ! caseSensitive ) {
    val = val.toLowerCase();
   }
       
   trElement.childElements().each(function(tdElememt) {
     var tdText = tdElement.innerText;
    if ( ! caseSensitive ) {
     tdText = tdText.toLowerCase();
    }
    if (tdText.include(val)) {
     trElement.show();
    } else if ( ind > 0 ) {
     trElement.hide();
    }
   });
  });
 }
</script>

CardLayout布局管理器能够帮助用户处理两个以至更多的成员共享同一显示空间,它把容器分成许多层,每层的显示空间占据整个容器的大小,但是每层只允许放置一个组件,当然每层都可以利用Panel来实现复杂的用户界面.布局管理器（CardLayout）就象一副叠得整整齐齐的扑克牌一样,有54 张牌,但是你只能看见最上面的一张牌,每一张牌就相当于布局管理器中的每一层.

流式布局管理器把容器看成一个行集，好象平时在一张纸上写字一样，一行写满就换下一行。行高是用一行中的控件高度决定的。FlowLayout是所有 JApplet/JApplet的默认布局。在生成流式布局时能够指定显示的对齐方式，默认情况下是居中（FlowLayout.CENTER）

GridLayout 将成员按网格型排列，每个成员尽可能地占据网格的空间，每个网格也同样尽可能地占据空间，从而各个成员按一定的大小比例放置。如果你改变大小， GridLayout将相应地改变每个网格的大小，以使各个网格尽可能地大，占据Container容器全部的空间。
基本布局策略是把容器的空间划分成若干行乘若干列的网格区域，组件就位于这些划分出来的小区域中，所有的区域大小一样。组件按从左到右，从上到下的方法加入。

BoxLayout布局能够允许将控件按照X轴（从左到右）或者Y轴（从上到下）方向来摆放，而且沿着主轴能够设置不同尺寸。

HTTP Status Codes Explained

"java decompiler"是一个非常出色的java反编译工具，详见主页：http://java.decompiler.free.fr/

在myeclipse8.5中的安装也比较简单，下载：http://java.decompiler.free.fr/jd-eclipse/update/jdeclipse_update_site.zip
然后把这个压缩包解开放在myeclipse8.5的dropins目录下，比如：C:\Programs\Genuitec\MyEclipse-8.5\dropins\jdeclipse_update_site
重起myeclipse就行了，第一次打开class文件，可能会稍微有一点慢，要等待一小会才会反编译出来。

好像还有点问题

现在打开iBatis的主页：ibatis.apache.org会发现作者发布了一个新闻或者说是声明。

大意是因为各种原因，已经把iBatis更名为MyBatis, 并且搬迁到Google Code中了。

新的主页地址是： http://www.mybatis.org

另外，MyBatis3.0.1的正式版已经在http://code.google.com/p/mybatis/可以下载了。

出自伏尔泰的名句。在许多优秀的程序员的编程习惯中，寻找解决方案就如同是寻找女友一般，总是力求完美，如果一个解决方案不够完美的话，那么宁可舍弃也不会降低标准而采用。但是这样的结果很有可能会是一叶障目，不见森林。
举个实际的例子来说，tapestry5的服务动态加载就是一个典型。
大家知道，在Tapestry中，页面模板的动态加载一直是其的一个宣传点。也就是说，页面模板如果修改了，不需要重新启动应用服务器，修改即时生效。但是，Tapestry却一直没有实现服务的动态加载，也就是说服务的类修改了，就必须重新启动服务器。为什么呢，因为追求完美。
其实很久以前在Tapestry的作者的头脑中，包括许多的用户都想在Tapestry中加入服务动态加载的功能，但是最后作者却放弃了。原因是因为，在Tapestry的架构中，服务比页面要复杂的多，服务不是单独存在的，他会被Inject到许多其他的服务，而这些服务又会被inject到其他的服务中，最后导致你很难界定哪些类需要被重新加载。
但是最近有一个人提出一个建议，为什么要实现完整的动态加载呢。其实只实现服务的实现类的动态加载就已经很好了。
确实，如果保持接口不变，只在接口具体实现修改的时候加载，确实大大简化了问题，因为这样变化范围就被限定在单个类之内了。虽然这样并不完美，因为如果改变了对外接口，比如，添加了一个新的方法，或者改变了方法的签名，还是需要重新启动服务器。可是这样也已经在很大程度上提升了用户的使用满意度。
正如有句古语所说：退一步海阔天空。也在此提醒自己在以后的开发过程中，尽量拓展自己的思维，不要一下子钻到牛角尖里。

在教程的第四部分（http://www.blogjava.net/usherlight/archive/2009/06/20/283396.html）我们已经粗略地介绍了Tapestry的前缀，其中提及最常用的两种literal和prop。这里顺便再介绍一下其他的几个前缀.
1、context，这个经常在引用图片的时候用到。比如：<img src="${context:images/icon.png}"/> 这样就能够在页面上显示在web-inf/images/icon.png
2、message，这个是需要I18N的应用必用的前缀。${message:some-key}
3、var，用于定义生成一个临时变量。比如：<li t:type="loop" source="1..10" value="var:index">${var:index}</li>。如果没有加这个前缀var:的话，就需要在页面类中添加一个property： index以及相应的getter和setter。
我们这次介绍自定义一个cycle前缀，这个可以用于在表格中显示不同背景的行（也就是斑马条）。
比如：
<t:grid ....  rowClass="cycle:line1,line2">
...
</t:grid>
或者
<t:loop ...>
<div class="${cycle:line1,line2}">aaaa</div>
</tloop>

自定义prefix一般来说是3个步骤，
1、定义一个BindingFactory，这个需要实现BindingFactory接口
2、定义一个Binding继承AbstractBinding
3、注册这个Binding

看一下具体的prefix的类：

 1import java.util.ArrayList;
 2import java.util.List;
 3
 4import org.apache.tapestry5.Binding;
 5import org.apache.tapestry5.BindingConstants;
 6import org.apache.tapestry5.ComponentResources;
 7import org.apache.tapestry5.ioc.Location;
 8import org.apache.tapestry5.services.BindingFactory;
 9import org.apache.tapestry5.services.BindingSource;
10
11/** *//**
12 * Implementation of the cycle: binding prefix -- we parse list of bindings
13 * and generate delegate bindings for each element<br>
14 * default binding is literal, other bindings can be used by specifying prefix.<br>
15 * example: "cycle:prop:name,prop:lastName,sth,sth else"
16 */
17public class CycleBindingFactory implements BindingFactory {
18    private final BindingSource _bindingSource;
19
20    public CycleBindingFactory(BindingSource source){
21        this._bindingSource = source;
22    }
23    
24    public Binding newBinding(String description, ComponentResources container, ComponentResources component,
25            String expression, Location location)
26    {
27        List<Binding> delegates = new ArrayList<Binding>();
28        String[] bindingNames = expression.split(",");
29
30        for (String bindingName : bindingNames){
31            String defaultBinding = BindingConstants.LITERAL;
32
33            Binding binding = _bindingSource.newBinding(description, container, component, defaultBinding, bindingName, location);
34            delegates.add(binding);
35        }
36        
37        CycleBinding cycleBinding = new CycleBinding(delegates);
38        container.addPageLifecycleListener(cycleBinding);
39            
40        return cycleBinding;
41    }
42}

 1import java.util.List;
 2
 3import org.apache.tapestry5.Binding;
 4import org.apache.tapestry5.internal.bindings.AbstractBinding;
 5import org.apache.tapestry5.runtime.PageLifecycleListener;
 6
 7
 8public class CycleBinding extends AbstractBinding implements PageLifecycleListener{
 9    private final List<Binding> delegates;
10    private int index = 0;
11
12    public CycleBinding(List<Binding> delegates) {
13        this.delegates = delegates;
14    }
15
16    public Object get() {
17        Object ret = delegates.get(index).get();
18        index ++; 
19        if(index>=delegates.size()) index = 0;
20        return ret;
21    }
22    
23    @Override
24    public boolean isInvariant() {
25        return false;
26    }
27    
28    @Override
29    public Class<Object> getBindingType() {
30        return Object.class;
31    }
32
33
34    public void containingPageDidDetach() {
35        index=0;
36    }
37
38    public void containingPageDidAttach() {/**//*not interested*/}
39    
40    public void containingPageDidLoad() {/**//*not interested*/}
41}

1    public static void contributeBindingSource(
2            MappedConfiguration<String, BindingFactory> configuration,
3            BindingSource bindingSource
4            )
5    {
6        configuration.add("cycle",new CycleBindingFactory(bindingSource));
7    } 

1. 先开始看SpringSide吧。
主要看寒冬日志版3.2.1开始有的JMS演示和WebService演示

一直觉得EJB好像已经日薄西山了，但是实际上生命力还挺顽强的。
另外，还有Web Service， SOA这个概念还是有人相信的。

所以，延伸项目有：JMS, MQ

在tapestry5中，在页面之间传递基本有3种方法
1、存放在Session中
2、使用@Persist进行持久化
3、使用页面context来传递参数。
其中1和2都需要将数据存放在Session中，相对来说系统的开销比较大。尤其是多用户高并发情况下，对于性能可能会有一定的影响。
使用页面Context来传递则需要在开发时写一些代码，增加了一些开发量，显得没有前两种方法方便。
第3种方法的实现是需要在页面中添加onActivate和onPassivate方法来完成页面参数的传递。
我们先来看一下其背后的故事。
举个例子，比如说我们有两个页面，第一个是查询条件输入页面input，另一个是查询结果输出页面output。input页面中有两个查询条件，起始时间dateFrom和终止时间dateTo
在Input.java中，我们可以很直观地这样写：
@InjectPage
private Output output;

@Property
private String dateFrom;

@Property
private String dateTo;

Object onFormSubmit() {
        output.setDateFrom(dateFrom);
        output.setDateTo(dateTo);
        return output;
}
首先使用注解注入output页面，然后在表单的提交事件中，返回output，这样就在程序中定义了返回页面，而不是使用配置文件的方式。
但是这样的实现却不能正确运行，原因是因为Tapestry5的使用了页面池技术，页面在每次渲染前都是从页面池中随机获取一个页面，而从页面池中取得的页面，所有的属性都是被清空了的。
也就是说在上例中，虽然我们注入了output页面，但是此页面马上就被放入了页面池，而且其中的属性值马上就被清空了。这就是引入onActivate和onPassivate这丙个方法的原因。tapestry5在清空属性前会首先查看是否包含onPassivate方法，如果有，就把其返回值保存起来，然后从页面池中取得页面后，再把刚才保存的值作为参数传递给onActivate方法。
这就是方法3的基本原理，但是无论是在官方的文档或是示例或者网上其他的应用中，可以发现大部分都是使用单个参数的，比如说id。这也很容易理解，因为onPassivate的方法的返回值只能有一个。
在Tapestry5的官方文档中，只有一句非常简要的话介绍了如果传递多个文档的方法： The activation context may consist of a series of values, in which case the return value of the method should be an array or a List. （参见：http://tapestry.apache.org/tapestry5.1/guide/pagenav.html）。
但是这并不是说只要在onPassivate中把参数的值加入到List中，返回一个List，而在onActivate中接受一个List参数，然后就可以得到其中的参数了，因为Tapestry5把参数传给onActivate的方法其实是通过将参数作为HttpRequest中的参数的。如果试图使用上述方法就是得到一个“无法将List转换成String的错误”
所以方法应该是这样的，在Output中：

private List<String> paramList;
public void setParamList(List<String> paramList) {
        this.paramList = paramList;
}
public List<String> getParamList() {
        return paramList;
}
List<String> onPassivate() {
        return paramList;
}
void onActivate(String dateFrom, String dateTo) {
        this.dateFrom = dateFrom;
        this.dateTo = dateTo;
}
private String dateFrom;
private String dateTo;

在Input页面中，需要把onFormSubmit改一下：
Object onFormSubmit() {
        List<String> list = new ArrayList<String>();
        output.setParamList(list);
        return output;
}

其中，需要注意的是output中的onActivate方法，基参数的顺序必须和List中放入的参数顺序一致。

在上一篇中我们研究了如何实现SpringSecurity中Jsp Tag的<security:authorize ifAllGranted="ROLE_SUPERVISOR">的功能。这一次我们一起研究一下如何实现在Tapestry5.1中添加一个Filter来对所有的操作进行权限的过滤控制。
在SpringSecurity中，我们一般是在application-context.xml中，添加一个SpringSecurity的Filter，然后在另外一个xml中详细配置如何根据Url的规则进行权限的控制。而Tapestry的哲学是尽量减少Xml中的配置（其IOC容器也基本上是借鉴Guice而不Spring的），所以我们也是在代码中实现权限规则的控制。
总体上来看，可以用两种方式来实现url规则，一种是Request级别的Filter，一种是页面组件级别的Filter，如果是Request级别的话，可以从Request对象中获取Url路径，这样就与SpringSecurity基本一样了。本文主要介绍页面组件级别的Filter，从中我们也可以体会到Tapestry5.1中的IOC容器的强大和便利。

这就是Filter的代码，这个Filter必须实现ComponentRequestFilter接口。值得注意的是其构造函数所需要用到的4个参数，这4个参数都是Tapestry5本身自有的服务，所以我们什么也不用做，Tapestry5自动会将服务的实例注入进来，这就是Tapestry-IOC的威力。
ComponentRequestFilter接口一共有4个方法需要实现，具体代码如下：

在ComponentRequestFilter中，我们无法使用@SessionState注解来直接注入Session中的变量，但是我们可以通过ApplicationStateManager来取得。

现在我们需要把刚定义的Filter注册到系统中，很简单，只要在AppModule中添加以下函数就行了：

public class AuthenticationService {
    private List<String> privilegeList;
    // privilegeList 的getter and setter

    public boolean checkPermission(String ifNotGranted, String ifAllGranted,
            String ifAnyGranted) {
        if (((null == ifAllGranted) || "".equals(ifAllGranted))
                && ((null == ifAnyGranted) || "".equals(ifAnyGranted))
                && ((null == ifNotGranted) || "".equals(ifNotGranted))) {
            return false;
        }

        if ((null != ifNotGranted) && !"".equals(ifNotGranted)) {
            StringTokenizer st = new StringTokenizer(ifNotGranted, ",");
            while (st.hasMoreTokens()) {
                String value = st.nextToken();
                if (privilegeList.contains(value)) {
                    return false;
                }
            }
        }

        if ((null != ifAllGranted) && !"".equals(ifAllGranted)) {
            StringTokenizer st = new StringTokenizer(ifAllGranted, ",");
            while (st.hasMoreTokens()) {
                String value = st.nextToken();
                if (!privilegeList.contains(value)) {
                    return false;
                }
            }
        }

        if ((null != ifAnyGranted) && !"".equals(ifAnyGranted)) {
            StringTokenizer st = new StringTokenizer(ifAnyGranted, ",");
            while (st.hasMoreTokens()) {
                String value = st.nextToken();
                if (privilegeList.contains(value)) {
                    return true;
                }
            }
            return false;
        }

        return true;
    }
}

public class IfRole {
    /** *//**
     * A comma-separated list of roles is supplied to one or more of the
     * following parameters. If none are supplied, the default behavior is to
     * forbid access. Behavior should be self-explanatory.
     */
    @Parameter(required = false, defaultPrefix = "literal")
    private String ifAllGranted;

    @Parameter(required = false, defaultPrefix = "literal")
    private String ifAnyGranted;

    @Parameter(required = false, defaultPrefix = "literal")
    private String ifNotGranted;

    /** *//**
     * An alternate {@link Block} to render if the test parameter is false. The default, null, means
     * render nothing in that situation.
     */
    @Parameter(name = "else")
    private Block elseBlock;

    private boolean test;
   
    @SessionState
    private AuthenticationService auth;

    private boolean checkPermission() {
        return auth.checkPermission(ifNotGranted, ifAllGranted, ifAnyGranted);
    }
   
    void setupRender() {
        test = checkPermission();
    }

    /** *//**
     * Returns null if the test method returns true, which allows normal
     * rendering (of the body). If the test parameter is false, returns the else
     * parameter (this may also be null).
     */
    Object beginRender() {
        return test ? null : elseBlock;
    }

    /** *//**
     * If the test method returns true, then the body is rendered, otherwise not. The component does
     * not have a template or do any other rendering besides its body.
     */
    boolean beforeRenderBody() {
        return test;
    }
   
}

示例：
1. 在登录页面：
@SessionState
private Authentication auth;

......

// if user name and password is valid:
auth.setPrivliegeList(.....);

2. 在需要权限控制的页面模板中：
<t:ifRole ifAllGranted="admin">
        administrator can see this block
</t:ifRole>

* Spring expression language (SpEL): a core expression parser for use in bean definitions, allowing for references to nested bean structures (e.g. properties of other beans) as well as to environmental data structures (e.g. system property values) through a common #{…} syntax in property values.

* Extended support for annotation-based components: now with the notion of configuration classes and annotated factory methods (as known from Spring JavaConfig). Spring also allows for injecting configuration values through @Value expressions now, referring to configuration settings via dynamic #{…} expressions or static ${…} placeholders.

* Powerful stereotype model: allows for creating 'shortcut' annotations through the use of meta-annotations, e.g. for default scopes and default transactional characteristics on custom stereotypes. Imagine a custom @MyService annotation indicating @Service, @Scope("request") and @Transactional(readOnly=true) through a single annotation.

* Standardized dependency injection annotations: Spring 3.0 comes with full support for the JSR-330 specification for Dependency Injection in Java – annotation-driven injection via @Inject and its associated qualifier and provider model, as an alternative to Spring's own @Autowired and co.

* Declarative model validation based on constraint annotations: Spring-style setup of a JSR-303 Bean Validation provider (such as Hibernate Validator 4.0). Comes with an annotation-driven validation option in Spring MVC, exposing a unified view on constraint violations through Spring’s binding result facility.

* Enhanced binding and annotation-driven formatting: Converter and Formatter SPIs as an alternative to standard PropertyEditors. Formatting may be driven by annotations in a style similar to JSR-303 constraints, e.g. using @DateTimeFormat. Also, check out the new mvc namespace for convenient setup of formatting and validation in Spring MVC.

* Comprehensive REST support: native REST capabilities in Spring MVC, such as REST-style request mappings, URI variable extraction through @PathVariable parameters, and view resolution driven by content negotiation. Client-side REST support is available in the form of a RestTemplate class.

* Rich native Portlet 2.0 support: Spring MVC fully supports Portlet 2.0 environments and Portlet 2.0’s new event and resource request model. Includes specialized mapping facilities for typical portlet request characteristics: @ActionMapping, @RenderMapping, @ResourceMapping, @EventMapping.

* Object/XML Mapping (OXM): as known from Spring Web Services, now in Spring Framework core. Marshalling and Unmarshaller abstractions with out-of-the-box support for JAXB 2, Castor, etc. Comes with integration options for XML payloads in Spring MVC and Spring JMS.

* Next-generation scheduling capabilities: new TaskScheduler and Trigger mechanisms with first-class cron support. Spring 3.0 comes with a convenient task namespace and also supports @Async and @Scheduled annotations now. This can be executed on top of native thread pools or server-managed thread pools.

Beyond those big themes, there are hundreds of refinements in the details which you will particularly appreciate when upgrading from Spring 2.5. Check the changelog and the javadocs…

In terms of system requirements, Spring 3.0 covers a broad range of environments. For two key characteristics, Spring 3.0 supports Java SE 5 and above and Servlet 2.4 and above, e.g. Tomcat 5.x and 6.x, also retaining compatibility with common enterprise servers such as WebSphere 6.1 and WebLogic 9.2 (which are formally still based on J2EE 1.4). At the same time, we support GlassFish v3 already – adapting to Java EE 6 API level in Spring as well.

As a consequence, Spring 3 brings brand-new component model features, and also standards like JSR-330 injection and JSR-303 validation, to established production environments – without having to upgrade your server installation! All you have to do is to upgrade the application libraries of your Spring-powered application to Spring 3.0…

目前从实际应用来看，ORM的老大自然是Hibernate，可是iBatis因为相对比较直观、学习曲线相对较低，因而也赢得了不少用户的青睐。
本文主要介绍作为iBatis辅助工具的iBator的使用方法。
iBator是一个iBatis相关代码的自动生成工具。
1、安装iBator的插件
在Eclipse中，使用添加站点的方法，输入网址http://ibatis.apache.org/tools/ibator，进行iBator的安装。
2、建议不要直接在使用iBatis的项目里直接使用iBator，推荐另外单独建立一个项目来生成。比如，建立一个项目叫：IbatorPrj
3、右键点击IbatorPrj这个项目，如果刚才的插件安装正确的话，就会看到一个“Add iBATOR to the build path”的选项，点击一下。
4、创建iBator的配置文件。下面是我的例子，大家在实际使用的过程中，需要根据自己的情况进行相应的修改。
主要就是数据库JDBC库的路径、数据库驱动的类名、项目的名称、包名等。
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE ibatorConfiguration
  PUBLIC "-//Apache Software Foundation//DTD Apache iBATIS Ibator Configuration 1.0//EN"
  "http://ibatis.apache.org/dtd/ibator-config_1_0.dtd">

<ibatorConfiguration>
        <classPathEntry location="c:\javaLibs\MySql\mysql-connector-java-5.0.6-bin.jar" />

        <ibatorContext id="SampleiBator" targetRuntime="Ibatis2Java5">
                <jdbcConnection driverClass="com.mysql.jdbc.Driver"
                        connectionURL="jdbc:mysql://localhost/sample" userId="root" password="admin">
                </jdbcConnection>

                <javaTypeResolver>
                        <property name="forceBigDecimals" value="false" />
                </javaTypeResolver>

                <javaModelGenerator targetPackage="com.sample"
                        targetProject="IbatorPrj\src">
                        <property name="enableSubPackages" value="true" />
                        <property name="trimStrings" value="true" />
                </javaModelGenerator>

                <sqlMapGenerator targetPackage="com.sample.xml"
                        targetProject="IbatorPrj\src">
                        <property name="enableSubPackages" value="true" />
                </sqlMapGenerator>

                <daoGenerator type="GENERIC-CI" targetPackage="com.sample.dao"
                        targetProject="IbatorPrj\src">
                        <property name="enableSubPackages" value="true" />
                </daoGenerator>

                <table schema="sample" tableName="tab1" domainObjectName="JavaBean1">
                        <property name="useActualColumnNames" value="false" />
                        <generatedKey column="ID" sqlStatement="MySql" identity="true" />
                </table>

        </ibatorContext>
</ibatorConfiguration>
5、配置文件生成完毕后，右键点击这个文件，选择“Generate iBatis Artifact”，然后你就在配置的文件夹下找到自动生成的文件了。

根据前面的4部分内容，我们已经了解了Tapestry的基本概念，掌握了配置、组件等内容。现在我们通过剖析Tapestry的入门示例来对Tapestry进行一个总体上认识。
1、web.xml
<web-app>
    <display-name>app Tapestry 5 Application</display-name>
    <context-param>
        <!-- The only significant configuration for Tapestry 5, this informs Tapestry
of where to look for pages, components and mixins. -->
        <param-name>tapestry.app-package</param-name>
        <param-value>t5demo</param-value>
    </context-param>
    <filter>
        <filter-name>app</filter-name>
        <filter-class>org.apache.tapestry.TapestryFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>app</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
</web-app>

这就是一个最简单的Tapestry应用所需要配置的内容了。
a.context-param中的tapestry.app-package配置，这在第一部分说过：这是Tapestry要求配置的java package的名称，Tapestry相关内容都需要在这个package下面的pages, services, componets子package下。这里的配置是t5demo
b.TapestryFileter的配置。这个非常容易理解，几乎所有现在流行的web框架都需要一个类似的定义。

2、start.tml以及相应的java class，例子中就是t5demo.pages.Start.java
Start.java非常简单，只定义了一个get方法：
public class Start
{
        public Date getCurrentTime()
        {
                return new Date();
        }
}
相应的页面start.tml
<html xmlns:t="http://tapestry.apache.org/schema/tapestry_5_1_0.xsd">
    <head>
        <title>app Start Page</title>
    </head>
    <body>
        <h1>app Start Page</h1>

        <p> This is the start page for this application, a good place to start your modifications.
            Just to prove this is live: </p>

        <p> The current time is: ${currentTime}. </p>

        <p>
            [<t:pagelink t:page="Start">refresh</t:pagelink>]
        </p>
    </body>
</html>

首先要注意在html的tag中加入了Tapestry的命名空间。
第二、${currentTime}就是Tapestry的Tag了，这里就会调用对应class的getCurrentTime方法在页面上显示对应的值。
第三、<t:pagelink>定义一个到自己本身页面的链接，来完成刷新的任务。t:pagelink在本系列的第4部分介绍过。

3、需要的library：
commons-codec.jar
javassist.jar
log4j.jar
slf4j-api.jar
slf4j-log4j.jar
tapestry5-annotations-5.1.0.5.jar
tapestry-core-5.1.0.5.jar
tapestry-ioc-5.1.0.5.jar

4、再加上一个log4j.properties，这就是一个最简单的tapestry应用所需要的全部东西了。
怎么样，感觉还是挺简单的吧。

1，上网本所占份额很小

Google计划推出Chrome OS是基于对上网本需求强劲的预期，不过，虽然上网本很重要，但在PC销售中所占比重仍很小。

另外，Google可能还有个想法：对微软来说，他们需要靠出售操作系统获利，而对Google来说，可以免费贡献Chrome。然而，诸如Linux这样的免费操作系统已经存在多年，但Linux在操作系统市场仅占很小份额，约为1%。

Chrome OS主要还是依靠那些上网本用户，他们不需要特别的应用，因此能接受低价但又能提供相当功能的操作系统。

2，微软或许会拼命回击

想想，如果微软宣布2010年Windows 7上网本版将免费提供，那还有多少人会用Chrome OS。至少从理论上来说，任何目前Google能做的事情，微软都能做得更好。

如果微软变得疯狂，任何事情都可能发生。多年来，微软的敌人一直是它自己。像Chrome OS这样的外部刺激或许会帮助微软获得活力，就如免疫系统一样消灭入侵的外来威胁。

3，Google在云计算应用上缺少建树

目前，Google Docs算是Google推出的最好的云计算应用，其它的乏善可陈。而且，就Google Docs来说，仍有很多事情无法做到。如果偶尔使用，倒也不错，但作为完全替代的解决方案，无法满足要求。

4，Chrome并不是一个真正的操作系统

Google希望推出的Chrome OS对用户来说隐藏操作系统的影子，而直接提供方便易用的应用。但究竟有多少操作系统的功能会被牺牲掉？

而另外，如果Chrome越接近真正的操作系统，那它就更像Linux。而这又不是Google希望看到的。

5，兼容性问题

对硬件和软件兼容性问题的解决是微软能一直统治操作系统市场的原因之一。微软在通过推行标准解决兼容性问题的同时也成为垄断者。不过，消费者还是投了微软的票，因为他们不必再担心兼容性问题。

因此，Chrome OS对于那些可以说是一次性使用的上网本来说，或许有点用处，但对整个操作系统市场来说将是微不足道的一份子。

一段时间没有用笔记本上的Eclipse，今天给安装了一个新的3.5版（Galileo）的Eclipse，结果发现启动的时候，跳出一个对话框说是
JVM terminated. Exit Code=-1.
在网上找了一下，最后有效而且最简单的方法是：
删除eclipse目录下的eclipse.ini，然后Eclipse又能启动工作了。
原因应该是Eclipse.ini文件里的启动参数和我的笔记本不配合（个人猜测），删除后，使用默认配置，启动成功。

Ben Gidley进行了一个关于Tapestry5.1.0.5的性能测试。原文见：http://blog.gidley.co.uk/2009/05/tapestry-load-testing-round-up.html
最后，他得出的结论是：
１、Tapestry的速度是比较快的。即使在一定的压力下Tapestry的反应时间也相当短。Tapestry并不总是最快的解决方案，但它对于我（译注：Gidley）已经足够快了。
２、Tapestry没有内存泄漏。我以前曾经听说过Tapestry会占用大量的内存，实际上，正好相反。它使用的内存比struts/jsp还要少。内存使用曲线相当的平坦。
３、Tapestry在表单应用中比struts要快。Tapestry在应用变得非常复杂的时候有一定的优势。这可能利益于其模块池技术。
４、Tapestry不轻易崩溃，即使崩溃，也会恢复。Tapestry在极大压力的情况下确实会相应变慢，但是它会暂停或者遇到瓶颈（译注：我怀疑是作者这里有笔误，从语气和上下文来看，感觉应该不是暂停和没有瓶颈），这的确是一个好事情。另外在压力减轻之后，Tapestry能够自动恢复。
５、更多的CPU并一定会提升性能。在一系列的测试中，性能与CPU的数量并不是线性增长。２个CPU确实比一个CPU的性能翻倍了，但是４个CPU并不比２个CPU的性能翻倍。因此，建议在多个双核CPU的虚拟机上运行，而不是少数的４核CPU上运行。
６、６４位比３２位要快。这一点很让我惊奇。不管在Solaris还是Linux上，运行在６４位JVM中要比在３２位JVM要快。
７、Linux要比Open Solaris X86要快。这一点同样让我惊奇。我本来以为性能应该是相似的。
最终的结论是：Tapestry即使是对于一个大并发量的Web应用来说也已经足够快了。如果你的应用有性能问题的话，那么问题应该出在你自己本身的代码上。

上述是原文的翻译。下面是一些评论：
Howard（应该是Tapestry的作者）：Taptestry５和Struts相比，我认为差别应该是在反射的使用上（包括在java.bean.Introspector中大量的synchronization）。因此在Struts将查询参数的名称映射成JavaBean属性的时候，会比较耗时。而Tapestry５是不使用反射的，Tapestry在查询参数和JavaBean的属性之间使用一种“预编程”向量组件，也许这就是两者（Tapestry和Struts）的差别。当然，这只是猜想，如果要证实的话，是需要花费很多时间的。我认为OGNL的教训不是说反射很慢，而是在于一个关键代码上的序列存取对于性能的影响是相当大的。
最后一个小提示：我觉得在Tapestry5应用中如果把BeanModel从BeanModelSource中只提取一次，然后给Grid，BeanEditForm等等提供一个可以存取的方法，将会获得相当的性能提升。这样就不是需要每次都重建BeanModel，将减少操作的消耗。
jeverest：我也进行了Tapestry的性能测试，并且同意Tapestry５的性能比较以前版本的要快。