Configuring the conversation-timeout period can be accomplished through the following in your components.xml:

<core:manager conversation-timeout="900000" />

At first glance most developers relate conversation-timeout to session timeout, where any conversation will simply timeout after the configured conversation timeout period. As you will quickly notice during testing, this is not the case. To execute a quick experiment, try the following configuration in the components.xml of the seam-booking example:

<core:manager conversation-timeout="60000" />

Because the conversation-timeout is set in milliseconds, the above configuration sets the conversation-timeout to 1 minute. Now in the web.xml set the session timeout to 5 minutes:

<session-config>

<session-timeout>5</session-timeout>

</session-config>

Now in the destroy method of the HotelBookingAction add the following line:

...

@Destroy @Remove

public void destroy() {

log.info("Destroying HotelBookingAction...");

}

...

This will log our message when the conversation ends and the HotelBookingAction is destroyed. Now deploy the seam-booking example to your local JBoss instance and start up a conversation. This can be accomplished by logging in, navigating to the hotels listing, and selecting a hotel for booking. At this point, wait for the 1 minute period… nothing happens. Now wait for another 4 minutes, the message is displayed. The conversation timed out along with the session.

Foreground vs. Background Conversations

So why didn’t our conversation timeout as configured? This is because the conversation-timeout only affects background conversations. The foreground conversation will only timeout when the session times out. Foreground, background, what? The foreground conversation is the conversation that the user last interacted with. A background conversation is any other conversation in the user’s session. Thus, in our previous scenario the foreground conversation timed out with the session as expected.

Now lets try another approach. Perform the same steps as before to proceed to the booking screen. Now open a new window and perform the same steps. We now have a foreground conversation and a background conversation in progress. Again, wait 1 minute. Nothing happened. If you wait an additional 4 minutes, both conversations will timeout. So what is going on here, I thought we had a background conversation? We did, Seam simply checks the conversation timeout on each request. Thus, if I interact with the foreground conversation after 1 minute, the background conversation times out. Try it, perform the same steps, wait 1 minute and then click on the window of the foreground conversation and you will see the log message.

This is very desirable behavior. Essentially when a user leaves his or her desk for a period of time and comes back, if the session is still active it would be desirable to maintain the state the user was previously in. This is the foreground conversation state. All other background conversation state is left to timeout after the configured conversation-timeout period which reduces overall memory consumption. This enables a developer to think less about memory usage and cleaning up state and more about developing business logic. That’s why we’re here right?

Letting the user choose

So you may be asking at this point why the conversation-timeout doesn’t use polling. As we said, you must interact with the foreground conversation to cause the background conversations to timeout after the conversation-timeout period. Imagine that the user had many windows open and leaves his or her desk. Based on which window the user clicks on when they return, that becomes the foreground conversation timing out any other background conversations. This gives the user a chance to resume whichever conversation he or she chooses, not the one the developer chooses.

假如文本中包含了大量的 "<" 和 "&" 字符 - 就像编程代码中经常出现的情况一样 - 那么这个 XML 元素就可以被定义为一个 CDATA 部分。

CDATA 区段开始于 "<![CDATA["，结束于 "]]>"：

<script type="text/javascript">
<![CDATA[
function compare(a,b)
{
if (a < b)
   {alert("a小于b");}
else if (a>b)
   {alert("a大于b");}
else
   {alert("a等于b");}
}
]]>
</script>

在上面的例子中，在 CDATA 区段中的所有东西都会被解析器忽略。

关于 CDATA 区段的注释:

CDATA 区段不能包含字符串 "]]>"，所以，CDATA 区段的嵌套是不被允许的。

同时也需要确保在 "]]>" 字符串中没有空格或折行。

为什么要使用CDATA:

       XHTML的第二个改变是使用CDATA段。XML中的CDATA段用于声明不应被解析为标签的文本（XHTML也是如此），这样就可以使用特殊字符，如 小于（<）、大于（>）、和号（&）和双引号（"），而不必使用它们的字符实体。考虑下面的代码：

<script type="text/javascript">
function compare(a,b)
{
if (a < b)
   {alert("a小于b");}
else if (a>b)
   {alert("a大于b");}
else
   {alert("a等于b");}
}
</script>

这个函数相当简单，它比较数字a和b，然后显示消息说明它们的关系。但是，在XHTML中，这段代码是无效的，因为它使用了三个特殊符号，即小于、 大于和双引号。要修正这个问题，必须分别用这三个字符的XML实体&lt;、&gt;和&quot;替换它们：

<script type="text/javascript">
function compare(a,b)
{
if (a &lt;b)
   {alert(&quot;a小于b&quot;);}  
else if (a&gt;b)
   {alert(&quot;a大于b&quot;);}
else
   {alert(&quot;a等于b&quot;);}
}
</script>

这段代码存在两个问题。首先，开发者不习惯用XML实体编写代码。这使代码很难读懂。其次，在JavaScript中，这种代码实际上将视为有语法 错，因为解释程序不知道XML实体的意思。用CDATA段即可以以常规形式（即易读的语法）编写JavaScript代码。正式加入CDATA段的方法如 下：

<script type="text/javascript">
<![CDATA[
function compare(a,b)
{
if (a < b)
   {alert("a小于b");}
else if (a>b)
   {alert("a大于b");}
else
   {alert("a等于b");}
}
]]>
</script>

虽然这是正式方式，但还要记住，大多数浏览器都不完全支持XHTML，这就带来主要问题，即这在JavaScript中是个语法错误，因为大多数浏览器还不认识CDATA段。

<script type="text/javascript">
//<![CDATA[                                            
function compare(a,b)
{
if (a < b)
   {alert("a小于b");}
else if (a>b)
   {alert("a大于b");}
else
   {alert("a等于b");}
}
//]]>                                      
</script>

当前使用的解决方案模仿了“对旧浏览器隐藏”代码的方法。使用单行的JavaScript注释"//"，可在不影响代码语法的情况下嵌入CDATA段：

现在，这段代码在不支持XHTML的浏览器中也可运行。

但是，为避免CDATA的问题，最好还是用外部文件引入JavaScript代码。

当一个操作成功时，Home对象可以自动地显示Faces信息，我们可以再一次通过配置来定制信息。

<factory name="person"

value="#{personHome.instance}"/>



<framework:entity-home name="personHome"

entity-class="eg.Person"

new-instance="#{newPerson}">

<framework:created-message>New person #{person.firstName} #{person.lastName} created</framework:created-message>

<framework:deleted-message>Person #{person.firstName} #{person.lastName} deleted</framework:deleted-message>

<framework:updated-message>Person #{person.firstName} #{person.lastName} updated</framework:updated-message>

</framework:entity-home>



<component name="newPerson"

class="eg.Person">

<property name="nationality">#{country}</property>

</component>

或者扩展：

@Name("personHome")

public class PersonHome extends EntityHome<Person> {



@In Country country;



@Factory("person")

public Person initPerson() { return getInstance(); }



protected Person createInstance() {

return new Person(country);

}



protected String getCreatedMessage() { return "New person #{person.firstName} #{person.lastName} created"; }

protected String getUpdatedMessage() { return "Person #{person.firstName} #{person.lastName} updated"; }

protected String getDeletedMessage() { return "Person #{person.firstName} #{person.lastName} deleted"; }



}

但是指定信息最好的方法是把信息置于Seam所知的resource bundle中（在默认情况下，这个bundle叫做 messages ）。

Person_created=New person #{person.firstName} #{person.lastName} created

Person_deleted=Person #{person.firstName} #{person.lastName} deleted

Person_updated=Person #{person.firstName} #{person.lastName} updated

这样方便进行国际化，从表现层的角度考虑也保持了代码和配置的整洁。

最后一步是使用 <s:validateAll> 和 <s:decorate> 向页面中添加验证功能，我会把这个留给你们自己去实现。

<f:view contentType="text/html" />



问题解决。

      一、修改数据库的连接方式

         1、采用数据源的形式
            在 tomcat 中配置数据源方式如下:
            在生成的项目同级目录中找此文件： context.xml 
                     Servers/Tomcat 。。。/context.xml  作如下配置：
            在标签 <Context> 中间加入:
            <Resource  
                  name="jdbc/demo" auth="Container" type="javax.sql.DataSource" 
                  maxActive="30" maxIdle="5" maxWait="10000" username="root" 
                  password="admin" driverClassName="com.mysql.jdbc.Driver" 
                  url="jdbc:mysql://localhost:3306/demo?useUnicode=true&amp;characterEncoding=UTF-8">

          </Resource>          

         2、使用非数据源的形式
            在文件：persistence.xml 中添加hibernate 的连接数据库的方式，如下：
              <property name="hibernate.connection.username" value="root"/>
            <property name="hibernate.connection.password" value="admin"/>
            <property name="hibernate.connection.driver_class" value="com.mysql.jdbc.Driver"/>
            <property name="hibernate.connection.url" 
                  value="jdbc:mysql://localhost:3306/demo?useUnicode=true&characterEncoding=UTF-8"/>

      二、修改 JPA 配置文件 persistence.xml

          1、如果数据的连接方式采用数据源的形式，则只需修改里面数据源的名称，如：
            <jta-data-source>java:comp/env/jdbc/demo</jta-data-source>

          2、如果采用hibernate 的连接方式，则把此行删了。        

          3、删除里面的此行配置：
             <property name="hibernate.transaction.manager_lookup_class" 
                  value="org.hibernate.transaction.JBossTransactionManagerLookup"/>

          4、修改事务的策略方式为 RESOURCE_LOCAL ： 

            <persistence-unit name="demo" transaction-type="RESOURCE_LOCAL">

      三、配置 Seam 的事务管理器
          在 component.xml 文件加入：
          <transaction:entity-transaction entity-manager="#{entityManager}"/>
         默认生成的此文件是不含有 transaction 的命名空间，需要手动在此文件加入它的命名空间：

          xmlns:transaction=http://jboss.com/products/seam/transaction
         http://jboss.com/products/seam/transaction 
         http://jboss.com/products/seam/transaction-2.1.xsd

      四、为此项目加入必要的依赖包 。。。。。。

Conversational components don't allow real concurrent access therefore Seam queues each request to process them serially. This allows each request to be executed in a deterministic fashion. However, a simple queue isn't that great — firstly, if a method is, for some reason, taking a very long time to complete, running it over and over again whenever the client generates a request is bad idea (potential for Denial of Service attacks), and, secondly, AJAX is often to used to provide a quick status update to the user, so continuing to run the action after a long time isn't useful.

Therefore, when you are working inside a long running conversation, Seam queues the action event for a period of time (the concurrent request timeout); if it can't process the event in time, it creates a temporary conversation and prints out a message to the user to let them know what's going on. It's therefore very important not to flood the server with AJAX events!

We can set a sensible default for the concurrent request timeout (in ms) in components.xml:

<core:manager concurrent-request-timeout="500" />

We can also fine tune the concurrent request timeout on a page-by-page basis:

<page view-id="/book.xhtml" 



         conversation-required="true" 



         login-required="true"



         concurrent-request-timeout="2000" />

So far we've discussed AJAX requests which appear serial to the user - the client tells the server that an event has occur, and then rerenders part of the page based on the result. This approach is great when the AJAX request is lightweight (the methods called are simple e.g. calculating the sum of a column of numbers). But what if we need to do a complex computation thats going to take a minute?

For heavy computation we should use a poll based approach — the client sends an AJAX request to the server, which causes action to be executed asynchronously on the server (the response to the client is immediate) and the client then polls the server for updates. This is good approach when you have a long-running action for which it is important that every action executes (you don't want some to timeout).

}

   <exception class="org.jboss.seam.ConcurrentRequestTimeoutException" logLevel="trace">



      <http-error error-code="503" />



   </exception>

<exception class="org.jboss.seam.ConcurrentRequestTimeoutException" logLevel="trace">



   <end-conversation/>



   <redirect view-id="/error.xhtml">



      <message>The server is too busy to process your request, please try again later</message>



   </redirect>



</exception>

<script type="text/javascript">

A4J.AJAX.onError = function(req,status,message) { 

alert("message");    

};

</script>

How do I set the Transaction Timeout?

Transaction timeout (unit is always seconds) can be configured in various ways:

This argument is the same no matter if you are using JBossTM(<=4.0.5) or JBossJTA-Arjuna(>=4.2).

• Globally: You can change this behavior globally by modifying the TransactionManagerService in /conf/jboss-service.xml (or /deploy/jta-service.xml for 4.0.3)

Version <= 4.0.5

This part is the same for either JBossTM or JBossJTA and is the same for ejb2 and ejb3

• Per-method basis: Modifying the <transaction-timeout> element inside the <method> element of a session or entity bean. This is located in the META-INF/jboss.xml deployment descriptor of a session bean. When the transaction timeout is specified at the method level, it overrides the default timeout. Further information about this element can be found in jboss-x.x.x/docs/dtd/jboss_4_0.dtd. Example taken from the testsuite:

• Using BMT: Calling javax.transaction.UserTransaction.setTransactionTimeout(int seconds). Please, be aware that this only applies to transactions started after this invocation on the same thread. Example:

@TransactionTimeout(1500)

在component.xml里添加：

<event type="org.jboss.seam.security.notLoggedIn">
<action execute="#{redirect.captureCurrentView}"/>
</event>
<event type="org.jboss.seam.security.postAuthenticate">
<action execute="#{redirect.returnToCapturedView}"/>
</event>

Intro to JBoss Seam Security, Part 1 - Authentication

Posted by WhoAmI? at 11:59 AM  

Configuring a Seam transaction manager

<transaction:ejb-transaction />

<transaction:entity-transaction entity-manager="#{em}"/>

<transaction:hibernate-transaction session="#{hibernateSession}"/>

<transaction:no-transaction />

JSF框架提供Validator机制，对用户输入值的合法性进行验证。若用户输入值无效，还提供了错误消息显示功能，以帮助用户能正确输入。

在开始本文之前，建议阅读下面的文章：
深入了解JSF
深入了解JSF（二）：从JSF的Lifecycle看JSF对页面的处理机制和流程
以了解JSF的概念等。

JSF Validator图：

JSF Validator特点：

输入数据的验证放在服务器端进行。
需要验证输入值的组件（输入组件）在JSP里通过JSF标签加以设置，方法简单直观。
每个输入组件可以同时绑定多个Validator。
验证发生错误时，可以向FacesContext登录错误信息，并且可以通过JSP直接显示。显示风格与位置可以自由设定。
验证错误时，JSF的生命周期控制机制自动中止处理流程，跳转到画面描画阶段（Render Response Phase）。
JSF标准提供对数值（long, double）的最大最小值验证，文字列的最大最小长度验证，以及必须(required)验证等Validator。
支持用户自定义Validator。用户自定义Validator的方法有2种，一种是Method Validator，一种是实现javax.faces.validator.Validator接口。本文的后面将对其作详细介绍。

JSF标准Validator

validateDoubleRange

Validator标签名：f:validateDoubleRange标签。
  属性名：
      maximum="最大值"
      minimum="最小值"
Validator ID：javax.faces.DoubleRange
Validator 类：javax.faces.validator.DoubleRangeValidator
输入值的范围验证。
输入值必须为Number（数值）类型或者可以转换为Double类型的值

validateLongRange

Validator标签名：f:validateLongRange
  属性名：
      maximum="最大值"
      minimum="最小值"
Validator ID：javax.faces.LongRange
Validator 类：javax.faces.validator.LongRangeValidator
输入值的范围验证。
输入值必须为Number（数值）类型或者可以转换为Long类型的值

validateLength

Validator标签名：f:validateLength
  属性名：
      maximum="最大值"
      minimum="最小值"
Validator ID：javax.faces.Length
Validator 类：javax.faces.validator.LengthValidator
输入值的长度验证。
输入值必须为String（字符串）或者可以转换为String类型的值


JSF required（必须输入） Validator
JSF的几个输入组件还可以使用required属性简单地验证表单元素是否得到输入。
<h:inputHidden required="true/false"></h:inputHidden>
<h:inputSecret required=“true/false”></h:inputSecret>
<h:inputText required=“true/false”></h:inputText>
<h:inputTextarea required=“true/false”></h:inputTextarea>

<h:selectBooleanCheckbox required=“true/false”></h:selectBooleanCheckbox>
<h:selectManyCheckbox required=“true/false”></h:selectManyCheckbox>
<h:selectManyListbox required=“true/false”></h:selectManyListbox>
<h:selectManyMenu required=“true/false”></h:selectManyMenu>
<h:selectOneListbox required=“true/false”></h:selectOneListbox>
<h:selectOneMenu required=“true/false”></h:selectOneMenu>
<h:selectOneRadio required=“true/false”></h:selectOneRadio>

JSF Validator的使用

各输入组件使用required validator的方法上面已经作了介绍，这里不再重复。

使用Method Validator

JSF支持Method级别的Validator，这种Validator实现起来比较简单，可以在任何JSF的managed-bean里实现一个类似以下的方法：

view plainprint?

1. public void validateXxxx(FacesContext context,   
2.         UIComponent component, Object value){  
3.   
4.     String text = value.toString();  
5.     if(!text.equals("xxxx")){  
6.         throw new ValidatorException(new FacesMessage("some message"));  
7.     }  
8. }  

public void validateXxxx(FacesContext context,
        UIComponent component, Object value){
    String text = value.toString();
    if(!text.equals("xxxx")){
        throw new ValidatorException(new FacesMessage("some message"));
    }
}

其中，context变量为JSF容器上下文环境，component为 绑定的组件，value为组件的输入值。validateXxxx可以为任意你喜欢的方法名。与预期的输入值不符合的话，可以通过throw一个 ValidatorException。"some message"便是想要显示的错误消息。

然后在JSP中：

view plainprint?

1. <h:inputText value="#{mybean.someValue}" validator="#{mybean.validateXxxx}"/>  

便可。
错误消息的显示稍后再作介绍。

Validator标签的使用

Validator标签可以接收参数，所以功能上比较强大，也比较灵活。同时，除了使用JSF标准的Validator标签之外，你还可以自定义Validator标签。关于自定义Validator标签我们将在另外的文章中加以介绍。
Validator标签的使用例：

view plainprint?

1. <h:inputText id="xxxxValue" value="#{mybean.xxxxValue}" required="true">  
2.  <f:validateDoubleRange maximum="5"></f:validateDoubleRange>  
3. </h:inputText>  
4. <h:message for="xxxxValue"></h:message>  

<h:inputText id="xxxxValue" value="#{mybean.xxxxValue}" required="true">
<f:validateDoubleRange maximum="5"></f:validateDoubleRange>
</h:inputText>
<h:message for="xxxxValue"></h:message>

上 例对id为xxxxValue的输入框组件的输入值做double范围验证，指定范围最大值为5。超过5的情况则显示错误消息，错误消息可以使 用<h:message />或者<h:messages />标签显示。有关消息处理的详细介绍请参考：
JSF全面理解之消息处理
一文

f:validator标签的使用与Validator ID

除了以上2种验证方法之外，还可以使用f:validator标签对输入值加以验证。f:validator标签需要指定validatorId属性，Validator Id需要在faces-config.xml配置文件中加以配置。


f:validator标签的使用例：

view plainprint?

1. <h:inputText id="xxxxValue" value="#{mybean.xxxxValue}" required="true">  
2.   <f:validator validatorId="Some Validator ID"></f:validator>  
3. </h:inputText>  

<h:inputText id="xxxxValue" value="#{mybean.xxxxValue}" required="true">
  <f:validator validatorId="Some Validator ID"></f:validator>
</h:inputText>

"Some Validator ID"为具体的Validator ID，我们将在自定义Validator标签一文中对Validator ID做详细介绍。

JSF框架将调用指定Validator ID所对应的Validator的
public void validate(FacesContext context, UIComponent component, Object value)
方法。

跟Method Validator一样，不能f:validator标签传入参数。

本文介绍了JSF Validator的机制，特点，种类，以及使用方法等。我们将在近期其它文章中介绍怎么自定义Validator。

JSF Validator进阶篇 - 自定义JSF Validator

JSF框架提供Validator机制，对用户输入值的合法性进行验证。若用户输入值无效，还提供了错误消息显示功能，以帮助用户能正确输入。

在 JSF Validator入门基础篇 - JSF Validator的介绍与使用  一文中我们介绍了JSF Validator的机制，特点，种类，以及使用方法等。

本文将介绍怎么自定义Validator和Validator标签。

自定义Validator有2种方法：一种是Method Validator，我们在JSF Validator入门基础篇 - JSF Validator的介绍与使用  一文中已作了介绍，这里不再详述；另一种是通过实现Validator接口，也就是使用自定义的Validator类。

自定义Validator类与Validator标签有以下几个步骤：
自定义Validator类的实现
faces-config.xml登录
自定义Validator标签类
设置TLD文件

自定义Validator类的实现

定义一个类，该类实现javax.faces.validator.Validaotr接口：

MyValidator.java

view plainprint?

1. package com.mypackages;  
2.   
3. import javax.faces.validator.Validaotr;  
4.   
5. public class MyValidator implements Validator {  
6.     public void validate(FacesContext context, UIComponent component, Object value)  
7.             throws ValidatorException {  
8.   
9.         String text = value.toString();  
10.         if(!text.equals("xxxx")){  
11.             throw new ValidatorException(new FacesMessage("some message"));  
12.         }  
13.     }  
14.   
15.     ... //其它参数设置，方法等（略）  
16. }  

package com.mypackages;
import javax.faces.validator.Validaotr;
public class MyValidator implements Validator {
    public void validate(FacesContext context, UIComponent component, Object value)
            throws ValidatorException {
        String text = value.toString();
        if(!text.equals("xxxx")){
            throw new ValidatorException(new FacesMessage("some message"));
        }
    }
    ... //其它参数设置，方法等（略）
}

faces-config.xml登录

自定义Validator类之后，还得向faces-config.xml登录之后才能使用。
faces-config.xml

view plainprint?

1. <?xml version="1.0"?>  
2. <!DOCTYPE faces-config PUBLIC  
3.   "-//Sun Microsystems, Inc.//DTD JavaServer Faces Config 1.0//EN"  
4.   "http://java.sun.com/dtd/web-facesconfig_1_0.dtd">  
5.   
6.   
7. <faces-config xmlns="http://java.sun.com/JSF/Configuration">  
8.     <validator>  
9.         <validator-id>MyValidator</validator-id>  
10.         <validator-class>com.mypackages.MyValidator</validator-class>  
11.     </validator>  
12. </faces-config>  

<?xml version="1.0"?>
<!DOCTYPE faces-config PUBLIC
  "-//Sun Microsystems, Inc.//DTD JavaServer Faces Config 1.0//EN"
  "http://java.sun.com/dtd/web-facesconfig_1_0.dtd">
<faces-config xmlns="http://java.sun.com/JSF/Configuration">
    <validator>
        <validator-id>MyValidator</validator-id>
        <validator-class>com.mypackages.MyValidator</validator-class>
    </validator>
</faces-config>

经过上面2个步骤，就可以使用MyValidator了。
例：
<h:inputText id="xxxxValue" value="#{mybean.xxxxValue}">
  <f:validator validatorId="MyValidator"></f:validator>
</h:inputText>

自定义Validator标签类

上面的MyValidator虽然可以通过f:validator标签加以利用， 但不能向其传入参数，若要向其传入参数，则需要定义自定义Validator标签类。
MyValidatorTag.java

view plainprint?

1. package com.mypackages;  
2.   
3. import javax.faces.webapp.ValidatorTag;  
4.   
5. public class MyValidatorTag extends ValidatorTag{  
6.   
7.     private String xxxParam;  
8.       
9.     public MyValidatorTag(){  
10.         setValidatorId("MyValidator");  
11.     }  
12.       
13.     protected Validator createValidator() throws JspException {  
14.         MyValidator validator =  (MyValidator)super.createValidator();  
15.         validator.setXxxParam(xxxParam);  
16.         return validator;  
17.     }  
18.   
19.     public String getXxxParam() {  
20.         return xxxParam;  
21.     }  
22.   
23.     public void setXxxParam(String xxxParam) {  
24.         this.xxxParam = xxxParam;  
25.     }  
26. }  

package com.mypackages;
import javax.faces.webapp.ValidatorTag;
public class MyValidatorTag extends ValidatorTag{
    private String xxxParam;
    
    public MyValidatorTag(){
        setValidatorId("MyValidator");
    }
    
    protected Validator createValidator() throws JspException {
        MyValidator validator =  (MyValidator)super.createValidator();
        validator.setXxxParam(xxxParam);
        return validator;
    }
    public String getXxxParam() {
        return xxxParam;
    }
    public void setXxxParam(String xxxParam) {
        this.xxxParam = xxxParam;
    }
}

另外，为MyValidator.java加入相应参数及方法实现。

TLD文件

定义好Validator标签类之后，还需要在TLD文件设置，有关TLD这里就不介绍了。请大家参考相关资料。

MyValidator.tld

view plainprint?

1. <?xml version="1.0" encoding="ISO-8859-1" ?>  
2. <!DOCTYPE taglib  
3.   PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN"  
4.   "http://java.sun.com/dtd/web-jsptaglibrary_1_2.dtd">  
5. <taglib xmlns="http://java.sun.com/JSP/TagLibraryDescriptor">  
6.     <tlib-version>1.0</tlib-version>  
7.     <jsp-version>1.2</jsp-version>  
8.     <short-name>myv</short-name>  
9.     <uri>my validator tag</uri>  
10.     <display-name>my validator tag</display-name>  
11.   
12.     <tag>  
13.         <name>validateMyData</name>  
14.         <tag-class>com.mypackages.MyValidatorTag</tag-class>  
15.         <attribute>  
16.             <name>xxxParam</name>  
17.             <required>false</required>  
18.         </attribute>  
19.     </tag>  
20. </taglib>  

<?xml version="1.0" encoding="ISO-8859-1" ?>
<!DOCTYPE taglib
  PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN"
  "http://java.sun.com/dtd/web-jsptaglibrary_1_2.dtd">
<taglib xmlns="http://java.sun.com/JSP/TagLibraryDescriptor">
    <tlib-version>1.0</tlib-version>
    <jsp-version>1.2</jsp-version>
    <short-name>myv</short-name>
    <uri>my validator tag</uri>
    <display-name>my validator tag</display-name>
    <tag>
        <name>validateMyData</name>
        <tag-class>com.mypackages.MyValidatorTag</tag-class>
        <attribute>
            <name>xxxParam</name>
            <required>false</required>
        </attribute>
    </tag>
</taglib>

自定义Validator标签的使用

web.xml

view plainprint?

1.  <taglib>  
2.   <taglib-uri>/WEB-INF/MyValidator.tld</taglib-uri>  
3.   <taglib-location>/WEB-INF/MyValidator.tld</taglib-location>  
4.  </taglib>  

 <taglib>
  <taglib-uri>/WEB-INF/MyValidator.tld</taglib-uri>
  <taglib-location>/WEB-INF/MyValidator.tld</taglib-location>
</taglib>

JSP

view plainprint?

1. <%@ taglib uri="WEB-INF/MyValidator.tld" prefix="myv" %>  
2.   
3. ...  
4.   
5. <h:inputText value="#{mybean.xxxxValue}">  
6.     <myv:validateMyData xxxParam="Some Parameter"/>  
7. </h:inputText>  

<%@ taglib uri="WEB-INF/MyValidator.tld" prefix="myv" %>
...
<h:inputText value="#{mybean.xxxxValue}">
    <myv:validateMyData xxxParam="Some Parameter"/>
</h:inputText>

增

查

删

改

EntityManager 提供了这些功能。首先，如何把EntityManager 引入我的代码？很简单：

@PersistenceContext
private EntityManager em;    

    好了，我们看看一个Entity 进程如何产生：

Entity entity = new Entity();    

    这很简单。现在，这entity 的状态是NEW/TRANSIENT 。这意味着一个entity已经存在于你的应用程序中，但并不具有id，也不存在于你的数据库中。

    由于我们要使它持久化（即它应被写入数据库），我们应把它的状态转换为MANAGED 。

em.persist(entity);    

    现在，此entity由EntityManager管理了。EntityManager控制entity写入数据库。这动作无须立刻发生，可能把你的entity放在cache，稍后写入数据库。你可以放心，写动作肯定会发生。

Ok, what about reading an existing entity from the database? Therefore we use:

好，如何从数据库中读出已存在的entity呢？这样：

Entity entity = em.find(Entity.class, Id);    

    每个entity 有一个id（我已经说过，多数情况下是Long数据类型），通过id你可存取entity。这是这里的第二个参数。第一个参数代表你要存取的Entity class的进程。find操作之后，entity的状态也是MANAGED 。

一旦entity数据有所改变，将反映到数据库中。不能确认EntityManager何时会向数据库写入更新的数据。但是这一事件肯定会发生，一般是马上，但不会晚于EntityManager消失;)。你可以控制触发更新数据库：

em.flush();    

entity （因为别人可能已经修改其数据），这么写：

em.refresh(entity);    

    怎样删除一个entity呢？很简单：

em.remove(entity);    

finish()方法中增加以下行：

em.merge(entity);    

@PersistenceContext(type=PersistenceContextType.EXTENDED
private EntityManager em;   

   
    当谈及列表：为取得不止一个实体，而是一个实体集合，使用：

List<Entity> entities = em.createQuery("from Entity").getResultList();    

EJBQL。你可以用它执行某些条件查询，排序等，如

..."from Entity where lastName=".nameToSearchFor." order by firstName"    

Posted by Roger Keays, 7 June 2007, 12:28 PM

This is probably one of the most frequently asked questions on the Facelets mailing list. Why doesn't my c:forEach tag work correctly? Unfortunately, there are may ways to misuse the jstl tags available in Facelets, so the answer isn't always simple. Here is an explanation of the differences between c:forEach and ui:repeat, along with some examples which will hopefully save you some headaches.

TagHandlers vs Components

The most important thing to understand about the jstl tags in Facelets is that they do not represent components and never become a part of the component tree once the view has been built. Rather, they are tags which are actually responsible for building the tree in the first place. Once they have done their job they expire, are no more, cease to be, etc etc.

Here is a table of the semantics of several common tags. I just discovered, reading the Facelets code, that validators and converters are classified separately. I had always thought they were just tag handlers, but I imagine they behave in much the same way.

One of the problems here is that there is no naming convention to indicate which tags correspond to which constructs. You've just got to know, or find out.

When is the view built?

Now that you understand that tag handlers are only effective when the tree is built, the next logical question should be well, when is tree built?

The short answer is that a new view is built for every request which is not a postback. During a postback, the view is reconstructed from saved state. Quite confusing, and not very obvious I know, but there you have it.

Common laments

The most common pitfalls are either with the JSF lifecycle, EL evaluation or combining tag handlers with components.

My c:if always evaluates to false

<h:dataTable values="${numbers}" var="number">

<h:column>

<c:if test="${number > 5}">

<h:outputText value="${number}"/>

</c:if>

</h:column>

</h:datatable>

Yes, the c:if is always evaluating to false! But it is only ever evaluated once - when the tree is built. The h:outputText component never makes it into the tree. Solution: replace the c:if with:

<ui:fragment rendered="${number > 5}"> ... </ui:fragment>

You could also use the rendered attribute on the h:outputText component in this example.

My ui:include fails inside ui:repeat

<ui:repeat value="#{bean.items}" var="item">

   <ui:include src="#{item.src}"/>

</ui:repeat>

The EL for the ui:include is evaluated when the view is built and is invalid since it relies on a variable only made available by the ui:repeat during rendering. Use c:forEach in this case.

My recursive tag never stops

myTag.xhtml:

<ul>

<ui:repeat value="${item.children} var="child">

<li><eg:myTag item="${child}"/></li>

</ui:repeat>

</ul>

The stop condition in this recursion is supposed to be when you run out of children. The problem is that the custom eg:myTag is just a tag handler, like a special version of ui:include. When the view is built, the ui:repeat has no influence on the building process and can't stop the recursion. Use c:forEach here instead of ui:repeat. Or better still, convert your tag file to a real UIComponent.

You might also recognise that the ${child} EL expression is meaningless during build time in this example, unless you use c:foreach.

My list doesn't change size after deleting or adding an item

<h:form>

<c:forEach items="${list}" var="item">

<h:outputText value="${item.name}"/><br/>

</c:forEach>

<h:commandButton value="Create new item" action="..."/>

<h:commandButton value="Delete an item" action="..."/>

</h:form>

When your view was built you only had, say, 5 items. If you post back to this view and add or delete an item, your view still has 5 h:outputText components in it since it was restored from saved state. In this simple case, you should use ui:repeat and your tree will always contain one h:ouputText component which is iterated over with differing values of ${item}.

If you rely on using c:forEach to dynamically include different form components you could run into difficulty. Always try to think about what the resulting tree looks like and remember it doesn't change on a postback.

Suggestions for the future

Probably the best relief to this problem would be to come up with a better syntax or naming convention to distinguish between tag handlers and components. I imagine you could also improve compilation performance if you did this.

Secondly, we need better terminology. I've used the terms tag handler and component in this blog which isn't too bad. The Facelets' FAQ [1] uses the terms build-time tags and render-time tags which is a bit misleading because render-time tags (components) are involved in all phases of the JSF lifecycle, not just the Render View phase.

Whatever happens, tag handlers are very useful (would you use facelets without ui:decorate?) so let's not get rid of them.

References

[1] http://wiki.java.net/.../FaceletsFAQ#Why_doesn_t_my_c_if_ui_repeat_ui

See http://docs.jboss.org/seam/latest/reference/en/html/controls.html

• Use <s:selectItems> to produce a list of labeled select items from a list of entities.
• Use <s:convertEntity> to map back and forth between the select items and the actual entity values. This is what allows you to map the value of the <h:selectOneMenu> directly to the property of the referencing entity (e.g. a property that is a many-to-one).

<h:selectOneMenu value="#{person.continent}" required="true">                        (1)

<s:selectItems value="#{continents.resultList}" var="continent"                  (2)

label="#{continent.name}" noSelectionLabel="Please Select..."/>

<s:convertEntity />                                                              (3)

</h:selectOneMenu>

1. person is an entity that has been outjected into the conversation. It has a 'continent' property which is many-to-one association with another entity.
2. continents is a Seam application framework 'query' object. This 'query' object should probably use a Seam-managed EntityManager because we want have the Hibernate session-in-view behavior so we don't get lazy initialization exceptions when rendering the labels, etc.
3. s:convertEntity will convert the Continent entities into values for the HTML select, and vice versa.

Tips

1. To avoid LazyInitializationExceptions and/or writing extra code in your EJB/Controller bean to initialize objects, use session in view.
2. For required fields, put required="true" on the selectOneMenu and override javax.faces.component.UIInput.REQUIRED in messages.properties (see Standard Faces Error Messages).

Select from an enum

This works just like selecting an entity, but <s:convertEnum/> is used instead.

XHTML:

<h:selectOneMenu id="marketStatus" value="#{person.status}"         (1)

required="true">

<s:selectItems value="#{enumLists.statusArray}" var="status"    (2)

label="#{status}"

noSelectionLabel="Select a status..."/>

<s:convertEnum/>

</h:selectOneMenu>

EnumLists.java:

@Name("enumLists")

@Scope(ScopeType.STATELESS)

public class EnumLists

{

public Status[] getStatusArray()

{

return Status.values();

}

}

1. person is an entity that has been outjected into the conversation. It has a 'status' property which is an enum.
2. We need to expose the values of the enum as a list or an array, so we make a stateless POJO component with getters that returns arrays for various enums called enumLists.

Multi-select from an enum

Here we use a selectManyCheckbox.

<h:selectManyCheckbox id="roles" 

layout="pageDirection" value="#{person.roles}"

required="true">

<s:selectItems value="#{enumLists.roleArray}" var="role"

label="#{role}"/>

<s:convertEnum/>

</h:selectManyCheckbox>

Unfortunately, Seam's convertEnum can't handle multi selects yet. This example will yeild a strange exception:

java.lang.IllegalArgumentException: java.util.List is not an enum type

Luckily, it's very easy to create custom converter tags with Facelets. Here is the converter class that handles both ordinary enums and multi-selects:

package eg;



import javax.faces.component.*;

import javax.faces.context.*;

import javax.faces.convert.*;

import javax.faces.el.ValueBinding;

import java.util.List;

import java.util.Collection;



/**

* Converter for enum multi-selects.

* <br>User: Joshua Davis

* Date: May 16, 2007

* Time: 7:25:58 AM

*/

public class EnumListConverter implements Converter

{

@SuppressWarnings({"unchecked"})

public Object getAsObject(FacesContext context,

UIComponent comp,

String value)

throws ConverterException

{

ValueBinding binding = comp.getValueBinding("value");

Class enumType = binding.getType(context);

if (enumType.isEnum())  // Single enum?

return Enum.valueOf(enumType, value);

else    // List of enums.

{

// Find the s:selectItems so we can get the enum.

List children = comp.getChildren();

for (Object child : children)

{

if (child instanceof UIComponent)

{

UIComponent c = (UIComponent) child;

ValueBinding b = c.getValueBinding("value");

Class t = b.getType(context);

// Array of enums: use the component type.

if (t.isArray() && t.getComponentType().isEnum())

{

t = t.getComponentType();

return Enum.valueOf(t,value);

}

else

{

Object v = b.getValue(context);

// Collection of enum values, get the type of the first element.

if (v instanceof Collection)

{

t = ((Collection) v).iterator().next().getClass();

return Enum.valueOf(t,value);

}

}

}

}

throw new ConverterException("Unable to find selectItems with enum values!");

}

}



public String getAsString(FacesContext context,

UIComponent component,

Object object)

throws ConverterException

{

if (object == null) {

return null;

}



return ((Enum) object).name();

}



}

I spent quite some time trying to find a solution for the following JSF issue: it is not possible to iterate over a java.util.Set.
- ui:repeat (facelets) doesn’t work
- a4j:repeat (richfaces) doesn’t work
- c:forEach works..only in case it does not rely on a variable defined by a parent component (rich:dataTable for instance)

All above are pretty logical phenomena, as UIData relies on ordered data, and generally a Set is not ordered.

In my case I had to use a Set defined in the Hibernate (JPA) object (PersistentSet).
An important note: you should use a set in case the view order is of no matter to you.

The solution..is pretty simple. And I’ll suggest it to be a part of facelets/richfaces for the next version, unless of course there is some valid specific

reason for it not to be.

1. Define your own UI component extending an existing repeater component. I used a4j:repeat (HtmlAjaxRepeat)
2. Override the metohd getDataModel
3. Define your component in your faces-config
4. create a custom facelets tag definition
5. Define a context-variable in web.xml pointing to the facelet tag definition.

Note: for use with JSP instead of Facelets, you should define a .tld and a Tag handler, which is not an ojbect of this post.

Now let’s see the steps in detail:

1,2. Here some code:

package com.myproject.components;
import java.util.ArrayList;
import java.util.Set;
import javax.faces.model.DataModel;
import javax.faces.model.ListDataModel;
import org.ajax4jsf.component.html.HtmlAjaxRepeat;
import org.ajax4jsf.model.SequenceDataModel;
public class UIIterator extends HtmlAjaxRepeat {
@SuppressWarnings("unchecked")
@Override
protected DataModel getDataModel() {
Object current = getValue();
if(current instanceof Set){
return new SequenceDataModel(new ListDataModel(
new ArrayList((Set) current)));
}
return super.getDataModel();
}
}

So, as we don’t care about the order of the elements, we just create a new ArrayList out of the Set. And we can now easily return the appropirate DataModel.

3. Add this to your faces-config. (I copied it from the a4j definition)

<component>
<description />
<display-name>Iterator</display-name>
<component-type>com.myproject.Iterator</component-type>
<component-class>com.myproject.components.UIIterator</component-class>
<component-extension>
<component-family>javax.faces.Data</component-family>
<renderer-type>org.ajax4jsf.components.RepeatRenderera</renderer-type>
</component-extension>
</component>

4. Here is the tag definition for facelets

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE facelet-taglib PUBLIC
"-//Sun Microsystems, Inc.//DTD Facelet Taglib 1.0//EN"
"http://java.sun.com/dtd/facelet-taglib_1_0.dtd">
<facelet-taglib xmlns="http://java.sun.com/JSF/Facelet">
<namespace>http://myproject.com/cust</namespace>
<tag>
<tag-name>repeat</tag-name>
<component>
<component-type>com.myproject.Iterator</component-type>
<renderer-type>org.ajax4jsf.components.RepeatRenderer</renderer-type>
</component>
</tag>
</facelet-taglib>

Save this file as /WEB-INF/facelets/custom.taglib.xml

5. Add to your web.xml

<context-param>
<param-name>facelets.LIBRARIES</param-name>
<param-value>/WEB-INF/facelets/custom.taglib.xml</param-value>
</context-param>

6. It is now ready to use
…
xmlns:cust=”http://myproject.com/cust”
…

<cust:repeat var=”myVar” value=”${aSet}”>
…
</cust:repeat>
I think it is way neater than other workarounds, like defining a custom EL Resolver.