1. 使用Spring Security管理用户身份认证、登录退出

2. 用户密码加密及验证

3. 采用数据库的方式实现Spring Security的remember-me功能

4. 获取登录用户信息。

5.使用Spring Security管理url和权限

<bean id="jobDetail7"class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">

                   <propertyname="targetObject" ref="billingBillTask"></property>

                   <propertyname="targetMethod" value="executeInternal" />

                   <propertyname="concurrent" value="false" />

         </bean>

         <beanid="billingBillTask"class="com.dangdang.tms.job.schedule.bms.BillingBillTask"/>

         <beanid="cronTriggerBean7" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">

                   <propertyname="jobDetail" ref="jobDetail7"></property>

                   <propertyname="cronExpression" value="0/5 * * * * ?"></property>

         </bean>

参考 http://blog.csdn.net/lkforce/article/details/51841890

单数据{'singer':{'id':01,'name':'tom','gender':'男'}} 
多个数据{"singers":[ 
        {'id':02,'name':'tom','gender':'男'}, 
         {'id':03,'name':'jerry,'gender':'男'}, 
{'id':04,'name':'jim,'gender':'男'}, 
{'id':05,'name':'lily,'gender':'女'}]}          
// 普通Json数据解析 
    private void parseJson(String strResult) { 
        try { 
            JSONObject jsonObj = new JSONObject(strResult).getJSONObject("singer"); 
            int id = jsonObj.getInt("id"); 
            String name = jsonObj.getString("name"); 
            String gender = jsonObj.getString("gender"); 
            tvJson.setText("ID号"+id + ", 姓名：" + name + ",性别：" + gender); 
        } catch (JSONException e) { 
            System.out.println("Json parse error"); 
            e.printStackTrace(); 
        } 
    } 
    //解析多个数据的Json
   private void parseJsonMulti(String strResult) { 
       try { 
            JSONArray jsonObjs = new JSONObject(strResult).getJSONArray("singers"); 
            String s = ""; 
            for(int i = 0; i < jsonObjs.length() ; i++){ 
                JSONObject jsonObj = ((JSONObject)jsonObjs.opt(i)).getJSONObject("singer"); 
                int id = jsonObj.getInt("id"); 
                String name = jsonObj.getString("name"); 
                String gender = jsonObj.getString("gender"); 
                s +=  "ID号"+id + ", 姓名：" + name + ",性别：" + gender+ "\n" ; 
            } 
            tvJson.setText(s); 
        } catch (JSONException e) { 
            System.out.println("Jsons parse error !"); 
            e.printStackTrace(); 
        } 
    } 

1. //第一种方式    
2.         Button Btn1 = (Button)findViewById(R.id.button1);//获取按钮资源    
3.         Btn1.setOnClickListener(new Button.OnClickListener(){//创建监听    
4.             public void onClick(View v) {    
5.                 String strTmp = "点击Button01";    
6.                 Ev1.setText(strTmp);    
7.             }    
8.   
9.         });   

1.     //第二种方式(Android1.6版本及以后的版本中提供了，直接在layout中设置)    
2.     public void Btn3OnClick(View view){    
3.         String strTmp="点击Button03";  
4.         Ev1.setText(strTmp);  
5.   
6.     }  

1.  <Button  
2.         android:id="@+id/button3"  
3.         android:layout_width="wrap_content"  
4.         android:layout_height="wrap_content"  
5.         android:text="Button3"   
6.         android:onClick="Btn3OnClick"/>  

第三种方式 activity 实现 单击监听接口

昨天部署web应用到Tomcat之后,无法成功启动,并且控制台没有详细的错误信息,
顶多就两行提示信息,例如:
严重: Error listenerStart
严重: Context [/] startup failed due to previous errors

或者

严重: Error filterStart
org.apache.catalina.core.StandardContext start
严重: Context startup failed due to previous errors

查找logs目录下的信息,除了这两句话,也没别的辅助内容.
给查错带来了困难,在这种情况下,是因为Tomcat自身的默认日志没有将一些错误信息输出到控制台或文件,
这个时候则需要配置Tomcat自身的log,启用详细的调试日志.

3.log4j配置文件:
log4j.properties
配置内容为:

log4j.rootLogger=ERROR,R

log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=[%p]%t-%c-%m%n

log4j.appender.R=org.apache.log4j.RollingFileAppender
log4j.appender.R.File=${catalina.home}/logs/tomcat.log
log4j.appender.R.MaxFileSize=10MB
log4j.appender.R.MaxBackupIndex=10
log4j.appender.R.layout=org.apache.log4j.PatternLayout
log4j.appender.R.layout.ConversionPattern=[%p]%t-%c-%m%n

log4j.logger.org.apache.catalina=INFO,R,CONSOLE

#日志级别不能太低,如果配置为debug的话,输出的日志信息太多,导致tomcat启动非常的慢.

4.Tomcat 6.0所需的juli替换文件:
http://www.apache.org/dist/--escaped_anchor:079305423cce36d6691457475e081123--/tomcat-6/v6.0.18/bin/extras/tomcat-juli-adapters.jar
http://www.apache.org/dist/--escaped_anchor:079305423cce36d6691457475e081123--/tomcat-6/v6.0.18/bin/extras/tomcat-juli.jar
以上两个链接基本没用，大家可以搜索一下，csdn上面有人提供jar包下载，这里附件也不能加，没有办法。

在Tomcat6.0中,

将tomcat-juli-adapters.jar,log4j-1.2.15.jar,log4j.properties复制到D:\Java\ApacheTomcat6.0.14\lib下面.

将tomcat-juli.jar复制到D:\Java\apache-tomcat-6.0.14\bin\下面.

然后启动tomcat,就可以在D:\Java\apache-tomcat-6.0.14\logs下看到tomcat.log了.

在这个时候,再通过日志文件来分析,则会发现出现这种错误的情况可能有:
(以下是我遇到的出错情况,大多是些低级错误)
1.webapps要用到的classe文件根本没有复制到WEB-INF/classes目录下面
(java.lang.NoClassDefFoundError,而这个信息可能默认没输出到控制台,尤其是用了spring的,昨天就是这个粗心的低级错误)
2.要用到lib文件没有复制完,缺少lib
3.lib下的同一个库的jar文件存在多个不同版本,引起版本冲突.
4.lib下的jar与tomcat版本不相对应(我遇到的问题是web应用在Tomcat5.5上运行正常,换到Tomcat6.0上就出错,
例如一个用了struts的webapp在Tomcat 6上报下面的错误
“Parse Fatal Error at line 17 column 6: The processing instruction
target matching “[xX][mM][lL]” is not allowed” )

愿意看英文的可以参考官方网站说明:
http://tomcat.apache.org/tomcat-6.0-doc/logging.html


标记一下：） 

1、新建一个临时数据库，用于存放查询结果
CREATE TABLE DatabaseFileLog
(
 date DATETIME,
 dbname VARCHAR(20),
 FILENAME VARCHAR(100),
 fileSIZE FLOAT
 
)

2、通过游标遍历所有数据库
declare @dbName varchar(50)
declare @command varchar(1024)
declare dbName_cursor CURSOR FOR
    select [name]
    from master.dbo.sysdatabases
    where [name] not in ('master','tempdb','msdb','model')
open dbName_cursor
FETCH NEXT FROM dbName_cursor INTO @dbName
WHILE @@FETCH_STATUS = 0
begin
    set @command = '
        insert into DatabaseFileLog
        select
        getdate(),
        '''+
        @dbName
        +''',

        filename,
        convert(float,size) * (8192.0/1024.0)/1024.0 as ''MB''

        from '+@dbName +'.dbo.sysfiles ';
    exec ( @command );
    FETCH NEXT FROM dbName_cursor INTO @dbName ;
end
CLOSE dbName_cursor;
DEALLOCATE dbName_cursor;

3、查询结果
SELECT * FROM DatabaseFileLog

文件(Files)注释标签：

/**  
* @Title: ${file_name}
* @Package ${package_name}
* @Description: ${todo}(用一句话描述该文件做什么)
* @author A18ccms A18ccms_gmail_com  
* @date ${date} ${time}
* @version V1.0  
*/

/**
* @Description: ${todo}(这里用一句话描述这个类的作用)
* @author ${user}
* @date ${date} ${time}
*
* ${tags}
*/

 <bean id="datasourceTarget" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
  <!-- Connection Info -->

 </bean>

    <bean id="dataSource" class="com.p6spy.engine.spy.P6DataSource">
        <constructor-arg>
            <ref local="datasourceTarget"/>
        </constructor-arg>
    </bean>

1、 登录action：/spring_security_login

2、 登出action：j_spring_security_logout （这两个action是springSecurity自带的，直接用就可以了）

3、 Filter的配置，在项目中，跟struts2一起使用，filter的前后顺序有关系。Spring secutiry要放在struts2的前面，否则系统找不到security的action

4、 怎么获取用户信息：可以参考springside中的实现org.springside.modules.security.springsecurity.SpringSecurityUtils。具体信息都在Authentication这个类中。

        又经过了半天多的努力，总算页面基本操作都能实现了，下面就是完善操作及异常处理。
        在window&form的操作上有些小问题。
        还有就是grid的异步数据载入，暂时用array，下面考虑用json来异步实现。

继续看效果图

在此记录开过过程及问题处理，便于浏览查询。
ECApp是一个web版的进销存系统
模块有系统模块，基础模块，采购管理，销售管理，仓库管理，应收应付等。

在web版的基础上，计划再开发一个RCP版本的。web的主要用于查询分析。RCP用于数据操作。

这样B/S,C/S的特点都能发挥出来。

两种方式都是可以，但是看人家的代码，习惯将注解放于方法上，不知道有没有什么好的地方？

现在唯一发现的区别就是，@Transient非持久化域的不同。
放在方法上，只需要标记那个getter方法即可，可以没有对应属性。

如果放在属性上，需要生成getter 和setter方法

1，使用new ModelAndView来返回页面，变量需要跟在这个类中直接返回，使用modelMap.addAttribute("message", message);在页面上使用EL表达式无法获得变量。感觉使用new ModelAndView回到页面不能同ModelMap同时使用。

2，form 的映射，spring mvc中，使用默认映射就可以，如果需要映射到一个对象中，直接在方法中指定这个对象声明就可以，这样form提交时会将属性绑定到同名的属性中。比原版的配置映射要简单很多，而且不需要继承FormBean类，比struts也简单，好用很多。

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN"
              "http://www.springframework.org/dtd/spring-beans-2.0.dtd">

<beans>
    <!-- Hibernate SessionFactory -->
    <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
        <property name="configLocation">
            <value>classpath:hibernate.cfg.xml</value>
        </property>
    </bean>
    
    <!-- Transaction manager for a single Hibernate SessionFactory (alternative to JTA) -->
    <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory">
            <ref local="sessionFactory" />
        </property>
    </bean>

    
    <!-- jBPM configuration-->
    <!--bean id="hibernateConfiguration" factory-bean="sessionFactory" factory-method="getConfiguration"/-->
    <bean id="jbpmConfiguration" class="org.springmodules.workflow.jbpm31.LocalJbpmConfigurationFactoryBean">
        <property name="sessionFactory" ref="sessionFactory" />
        <property name="configuration">
            <value>classpath:jbpm.cfg.xml</value>
        </property>
    </bean>
    
    <!-- jBPM template -->
    <bean id="jbpmTemplate" class="org.springmodules.workflow.jbpm31.JbpmTemplate">
        <constructor-arg index="0" ref="jbpmConfiguration" />
    </bean>

    <bean id="testSetUp" class="com.ivo.jpbm.test.TestSetUp">
        <property name="jbpmTemplate" ref="jbpmTemplate" />
    </bean>
    
</beans>

这个是spring的配置，hibernate的配置可以直接使用原来的那个。

然后这里可能会出现一个错误，说找不到default.jbpm.context，需要修改jbpm.cfg.xml

这里最简单的方法就是完全复制org/jbpm/default.jbpm.cfg.xml 内容，然后把hibernate部分的东西注释掉就可以了。

然后编写一个test类，用于测试。

整合的步骤如上，下面就是在jbpmTemplate的基础上，将常用的方法重新封装一下。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-2.5.xsd">

    <context:component-scan base-package="com.ivo.web.action.spring" />
 
    <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="viewClass"><value>org.springframework.web.servlet.view.JstlView</value></property>
        <property name="prefix"><value>/pages/</value></property>
        <property name="suffix"><value>.jsp</value></property>
    </bean>
   
</beans>

@Controller
public class HelloController {

 @RequestMapping("/hello.do")
 public ModelAndView processImageUpload() throws IOException {
  System.out.println("hello");
  return new ModelAndView("org", "jsonString", "test");
 }

}

    3.2 在class上配置mapping路径，通过参数指定调用的方法

@Controller
@RequestMapping("/hello.do")
public class HelloController {

@RequestMapping(params = "action=save")
 public ModelAndView save() throws IOException {
  System.out.println("hello");
  return new ModelAndView("org", "jsonString", "test");
 }

}

方法的返回值可以是null，string 或者ModelAndView，都支持。

以上是系统暂时用到的，其他的以后再研究。

事件的自定义
 treeDept.on('click', function(node){
    if(node.leaf==true){
       addSelected(node.id, node.text);
    }
 });
如何自定义事件。上面针对tree的单击事件，设置的单击时所要做 的动作。

其他的事件设置可以参考这个。从API上查到相应的事件名称，然后就可以设定了。

<action name="Logon" class="tutorial.Logon">
  <result type="redirect-action">Menu</result>
  <result name="input">/tutorial/Logon.jsp</result>
</action>

http://www.planetstruts.org/struts2-mailreader/Welcome.do

在应用中，这个到action的链接一般是由struts tag来自动产生的。这个tag通过名字来指定action，并且这个framework会加上默认扩展名和其他一些必须 的东西。

<s:form action="Hello">
    <s:textfield label="Please enter your name" name="name"/>
    <s:submit/>
</s:form>

这种情况，你就可以通过通配符的方式来定义一次action mapping，远胜于定义每一个action mapping.

<action name="*Crud" class="example.Crud" method="{1}">

这里，一个"editCrud"的action会调用Crud Action类实例的edit方法。同样，一个"deleteCrud"的action会调用delete方法。
另一种常用的方法就是后缀方法名，通过设置"!", "_", 或者其他一些特殊字符。

• "action=Crud_input"
• "action=Crud_delete"

To use a postfix wildcard, just move the asterisk and add an underscore.

<action name="Crud_*" class="example.Crud" method="{1}">

当Action类方法完成，会返回一个字符串，这个字符串值用来选择result元素。一个action可以映射到一组不同描述的结果。标准的result是在ActionSupport 这个基类中定义的。

String SUCCESS = "success";
String NONE    = "none";
String ERROR   = "error";
String INPUT   = "input";
String LOGIN   = "login";

当然，ap可以自定义其他的result标记来match特定的情况。

Result Elements
result有默认值设定，如果不指定属性，则使用success和dispatch来执行这个result

<action name="Hello">
  <result>/hello/Result.jsp</result>
  <result name="error">/hello/Error.jsp</result>
  <result name="input">/hello/Input.jsp</result>
</action>

如上显示，默认情况下，如果返回值是success，则执行第一个result，其他的情况执行下面的匹配的result

Global Results

大部分时候，results都是嵌套在antion元素中。但是很多results会应用到不同的action。在一个安全的应用中，一个client试图访问一个没有认证的页面，那么很多action可能都需要去访问 logon result。
如果action需要共享result， 一组global result可以为每一个package定义。框架首先查询嵌套在action中的本地result，如果本地result没有符合的，则在global result中查询。

<global-results>
  <result name="error">/Error.jsp</result>
  <result name="invalid.token">/Error.jsp</result>
  <result name="login" type="redirect-action">Logon!input</result>
</global-results>

Dynamic Results
A result may not be known until execution time. Consider the implementation of a state-machine-based execution flow; the next state might depend on any combination of form input elements, session attributes, user roles, moon phase, etc. In other words, determining the next action, input page, etc. may not be known at configuration time.

Result values may be retrieved from its corresponding Action implementation by using EL expressions that access the Action's properties, just like the Struts 2 tag libraries. So given the following Action fragment:
一个action有时候不可能在执行前就知道它的action，这种情况就需要通过动态result来实现。

 首先定义一个属性，来存放这个值，然后在流程定义中通过EL表达式来取得这个属性值。这样就可以通过程序动态指定需要转发的值。

private String nextAction;

   public String getNextAction() {
       return nextAction;
   }

you might define a result like this:

<action name="fragment" class="FragmentAction">
        <result name="next" type="redirect-action">${nextAction}</result>
</action>

开发环境
radrails 0.71, radrails就是一个基于eclipse的IDE工具，不过没有提供代码助手功能，这个让我javaer有点不习惯，可能都是被IDE给宠坏了，不喜欢记那么多的名字吧。

下面来做我们的第一个hello world程序。

1、创建项目

输入项目名称

最后点击Finish
radrails会自动运行 rails Hello命令，创建所有需要的目录及文件。
目录机构如图


在servers窗口中会自动创建相应的server，用来启动服务（ruby script/server）

2、创建controller
在Generators窗口中，下拉框选择controller，后一个输入要创建的controller的名字，然后点击go，过几秒钟，系统就会创建controller所需要的文件，最后会在console窗口显示创建的文件，这个时候就说明controller已经创建完成。你可以在app/controller中发现多了一个say_controller.rb的文件

如果要删除都个已经创建好的controller，在第二个下拉框中选择要删除的名字，然后选择Destroy，点击go即可。



3、增加Action
say_controller.rb的默认代码：

class SayController < ApplicationController
end
简单来说action 就是controller中的方法。
添加一个hello的方法
def hello
end
启动服务器，可以测试了。不过因为没有建view页面，所以会出错，出现的错误类似
Missing template ./script/../config/..//app/view/hello.rhtml

4、view页面
在app/views/say/目录下增减hello.rhtml文件，然后输入
<html>

<body>
    <h1>
        Hello from rails!
    </h1>
</body>
</html>
测试页面代码，在刷新，即可出现你想要的页面。
只是到现在为止，所有的都是静态的数据。下面将对action，及view进行重写，添加动态数据。

4、action修改
看如何从action中传数据到view。

  def hello
    @time = Time.now
  end

页面
<p> It is now <%= @time %></p>
在action中定义了一个 @time, 在页面中就可以引用这个实例变量进行显示。

问题：这个没有对这个实例变量进行任何的访问控制，按照ruby的语法，实例变量在对象外面是不能访问的。

Ruby的注释

Ruby的注释是指从#开始到该行结束。

Ruby的表达式

Ruby的表达式包括下列内容（主要的）。

字符串

字符串是指被单引号(')或双引号(")括起来的部分。在用双引号括起来的字符串中，可以使用反斜杠(\)来指定转义字符，这同C语言是一样的。同时，以#{}括起来的表达式的结果也被置入其中。

数值

整数，浮点数。

数组／散列表

用[]括起来的一串表达式是数组，而以{}括起来的一串表达式是散列表。

散列表是一种可以把任意类型的对象都当成索引的数组。散列表有时也叫做哈希表或辞典。

变量／常数

Ruby中有常数和3种变量。变量和常数的区别在于第一个字符有所不同。

局部变量

变量名以小写英文字母开始。使用时，需要以赋值的方式进行初始化。

全局变量

以$开始。未初始化的值为nil。

实例变量

以@开始。未初始化的值为nil。

类变量

以@@开始。未初始化的值为nil。

类常数

以大写英文字母开始。未初始化的值为nil。

赋值

变量赋值方法如下。

变量=表达式

调用方法（函数）

执行对象固有操作（方法）的方法如下

表达式.方法名
表达式.方法名(表达式..)

在不引起混淆的情况下，可以省略参数的括号。

调用某方法执行主体self的方法时，可以省略最开始的表达式。

方法名
方法名(表达式..)

区分无参数的方法调用和局部变量的方法是看看有没有赋值过程。

操作符表达式

普通的算式可以用(基本上与C语言一样的)操作符来表示。但内部是把操作符当作方法调用(以操作符作为方法名)来处理的。

Ruby的语句

Ruby使用分号(;)或换行来分隔表达式，表达式串起来构成语句。语句的值取决于最后执行的表达式的值。

Ruby的流程控制结构

Ruby中可以使用下列流程控制结构。

• if表达式 then代码块 [elsif表达式 then代码块]..[else代码块]end
• case表达式when表达式..;代码块...[else代码块]end
• while表达式;代码块end
• for变量..in表达式;代码块end

if和while的意思与通常的语言基本相同。可以使用分号或换行来代替if代码块中的then。请注意Ruby使用elsif代替C语言中的else if。

case是把若干个比较归为一体的控制结构。

for可以使用循环把数组等的元素分别赋值给变量。

循环内可以使用下列语句。

break

中断循环（相当于C语言的break）。

next

开始下一次循环（相当于C语言的continue）。

redo

重新执行块的第一行。

常用的语句

介绍几个Ruby程序中常用的语句。这些语句是对象类的方法，可以在任何类中使用，就如同使用函数一样。

exit([status])

结束程序的运行。若为status指定了一个整数的话，该整数就成为结束status。默认的status值为0。

gets

从命令行参数指定的文件(群)中读取一行，然后把该行的内容作为字符串返回。若没有制定命令行参数的话，则从标准输入中读取。读取的字符串可以被赋值给变量$_。遇到文件结束返回nil(伪)。

while gets
...
end

上面就是典型的用法。

open(文件名[,mode])

打开文件。mode是字符串，就和C的fopen一样。省略时以读取模式打开。

print

输出函数。按顺序将参数输出到标准输出上。省略参数时则输出变量$_的值。

以上为几个使用参考

·            复制 ajax4jsf.jar and oscache-2.2.jar 到程序的 WEB-INF/lib 文件夹下.
修改web.xml，增加a4j的filter配置

<filter>
          <display-name>Ajax4jsf Filter</display-name>
          <filter-name>ajax4jsf</filter-name>
          <filter-class>org.ajax4jsf.Filter</filter-class>
          </filter>
          <filter-mapping>
          <filter-name>ajax4jsf</filter-name>
          <servlet-name>Faces Servlet</servlet-name>
          <dispatcher>REQUEST</dispatcher>
          <dispatcher>FORWARD</dispatcher>
          <dispatcher>INCLUDE</dispatcher>
          </filter-mapping>
</filter>

<%@ taglib uri="https://ajax4jsf.dev.java.net/ajax" prefix="a4j"%>
<%@ taglib uri="http://java.sun.com/jsf/html" prefix="h"%>
<%@ taglib uri="http://java.sun.com/jsf/core" prefix="f"%>
<html>
    <head>
        <title>repeater</title>
    </head>
    <body>
        <f:view>
            <h:form>
                <h:panelGrid columns="2">

                        <h:outputText value="Type the Text:" />
                        <h:inputText value="#{bean.text}">
                                <a4j:support event="onkeyup" reRender="repeater" />
                        </h:inputText>

                        <h:outputText value="Text in the AJAX Response:" />
                        <h:outputText id="repeater" value="#{bean.text}" />

                </h:panelGrid>
        </h:form>

        </f:view>
    </body>
</html>

在这里我们在父标签(<h:inputText>)中添加了一个AJAX 支持. 该支持绑定了JavaScript事件“onkeyup” .因此, 每一次该事件发布给父标签时,我们的程序将发送一个AJAX请求到Server.这意味着我们的受管理的bean将包含该“text” 域中我们输入的最新数据.

package com.ivo.a4j.bean;

public class Bean {

    private String text;

    public Bean() {
        //text = "11";
        //System.out.println("Create");
    }

    public String getText() {
        return text;
    }

    public void setText(String text) {
        this.text = text;
    }

}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE faces-config PUBLIC "-//Sun Microsystems, Inc.//DTD JavaServer Faces Config 1.1//EN" "http://java.sun.com/dtd/web-facesconfig_1_1.dtd">
<faces-config>

    <managed-bean>
        <managed-bean-name>bean</managed-bean-name>
        <managed-bean-class>com.ivo.a4j.bean.Bean</managed-bean-class>
        <managed-bean-scope>request</managed-bean-scope>
    </managed-bean>

</faces-config>

or
<from-view-id>*</from-view-id>

Using from-action
<navigation-case>
  <from-action>#{quiz.answerAction}</from-action>
  <from-outcome>again</from-outcome>
  <to-view-id>/again.jsp</to-view-id>
</navigation-case>
<navigation-case>
  <from-action>#{quiz.startOverAction}</from-action>
  <from-outcome>again</from-outcome>
  <to-view-id>/index.jsp</to-view-id>
</navigation-case>
根据不同的action使用不同的导航规则。

导航算法

The algorithm has three inputs（算法有三个输入）:

• The outcome, that is, the value of an action attribute or the string resulting from the invocation of a method reference. action属性的值或者引用方法的返回结果（字符串类型）

• The view ID of the current view。当前视图

• The action, that is, the literal value of the action attribute in the component that triggered the navigation.用以触发导航的组件属性。

The first of two phases is to find the matching navigation-rule, following these steps（第二阶段的第一步就是寻找符合的导航规则）.

• If the outcome is null, return immediately and redisplay the current page.（如果outcome是空，则立刻返回重新显示当前页面）
• Merge all navigation rules with the same from-view-id value.（合并相同from-view-id的导航规则）
• Try to find a navigation rule whose from-view-id value matches the view ID exactly. If such a rule exists, take it.
• Consider all navigation rules whose from-view-id values end with a wildcard suffix, such as secure. For each such rule, check whether the prefix (after removing the *) is identical to the corresponding prefix of the view ID. If there are matching rules, take the one with the longest matching prefix.
• If there is a rule without a from-view-id, take it.（如果有没有from-view-id的规则，使用）
• If there is no match at all, redisplay the current page.（如果都没有符合，重新显示当前页面）

The second of two phases is to consider all navigation-case elements in the matching navigation rule (which may consist of several merged navigation-rule elements with matching from-view-id.values).

Follow these steps to find the matching case.

• If a case has both matching from-outcome and from-action, take it.
• Otherwise, if a case has matching from-outcome and no from-action, take it.
• Otherwise, if a case has matching from-action and no from-outcome, take it.
• Otherwise, if there is a case with neither from-outcome or from-action, take it.
• If there is no match at all, redisplay the current page.
  Naturally, we recommend that you do not create tricky navigation rules in your own programs. As long as you stay away from wildcards and from-action elements, you won't need to know about the gory details of the navigation algorithm.

一、beans在 faces-config.xml中的定义
格式如下：

<managed-bean>
   <managed-bean-name>user</managed-bean-name>
   <managed-bean-class>com.corejsf.UserBean</managed-bean-class>
   <managed-bean-scope>session</managed-bean-scope>
</managed-bean>

<faces-config>
<application>
<locale-config>
<default-locale>en</default-locale>
<supported-locale>de</supported-locale>
</locale-config>
</application>
</faces-config>

Request

Session
Application

五、Configure Bean 
设置属性值
  <managed-bean>
   <managed-bean-name>user</managed-bean-name>
   <managed-bean-class>com.corejsf.UserBean</managed-bean-class>
   <managed-bean-scope>session</managed-bean-scope>
   <managed-property>
      <property-name>name</property-name>
      <value>me</value>
   </managed-property>
   <managed-property>
      <property-name>password</property-name>
      <value>secret</value>
   </managed-property>
</managed-bean>
设置null值
<managed-property>
   <property-name>password</property-name>
   <null-value/>
</managed-property>

一、JSF开发环境
   使用myeclipse的功能，添加相关lib到classpath。 或者从sun的官方网站下载相关lib。
http://java.sun.com/javaee/javaserverfaces/download.html
二、JSP页面
      index.jsp

<html>
    <%@ taglib uri="http://java.sun.com/jsf/core" prefix="f"%>
    <%@ taglib uri="http://java.sun.com/jsf/html" prefix="h"%>

    <f:view>
        <head>
            <title>A Simple JavaServer Faces Application</title>
        </head>
        <body>
            <h:form>
                <h3>Please enter your name and password.</h3>
                <table>
                    <tr>
                        <td>Name:</td>
                        <td><h:inputText value="#{user.name}" /></td>
                    </tr>
                    <tr>
                        <td>Password:</td>
                        <td><h:inputSecret value="#{user.password}" /></td>
                    </tr>
                </table>
                <p><h:commandButton value="Login" action="login" /></p>
            </h:form>
        </body>
    </f:view>
</html>

      welcome.jsp

<html>
    <%@ taglib uri="http://java.sun.com/jsf/core" prefix="f"%>
    <%@ taglib uri="http://java.sun.com/jsf/html" prefix="h"%>

    <f:view>
        <head>
            <title>A Simple JavaServer Faces Application</title>
        </head>
        <body>
            <h3> Welcome to JavaServer Faces,
                <h:outputText value="#{user.name}" /> !
            </h3>
        </body>
    </f:view>
</html>

三、Bean
      UserBean .java
   package com.test.jsf.bean;

public class UserBean {

 private String name;

 private String password;

 // PROPERTY: name
 public String getName() {
  return name;
 }

 public void setName(String newValue) {
  name = newValue;
 }

 // PROPERTY: password
 public String getPassword() {
  return password;
 }

 public void setPassword(String newValue) {
  password = newValue;
 }
 
 public String check() {
  name = "wxf";
  return "success";
  //return SUCCESS;
 }
}

四、faces-config
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE faces-config PUBLIC "-//Sun Microsystems, Inc.//DTD JavaServer Faces Config 1.1//EN" "http://java.sun.com/dtd/web-facesconfig_1_1.dtd">
<faces-config >
 <navigation-rule>
 
    <from-view-id>/login/index.jsp</from-view-id>
    <navigation-case>
       <from-outcome>login</from-outcome>
       <to-view-id>/login/welcome.jsp</to-view-id>
    </navigation-case>
 </navigation-rule>
 
 <managed-bean>
    <managed-bean-name>user</managed-bean-name>
    <managed-bean-class>
       com.test.jsf.bean.UserBean
    </managed-bean-class>
    <managed-bean-scope>session</managed-bean-scope>
 </managed-bean>

</faces-config>
五、web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/j2ee"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="2.4"
 xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee   http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
 <context-param>
  <param-name>javax.faces.CONFIG_FILES</param-name>
  <param-value>/WEB-INF/faces-config.xml</param-value>
 </context-param>

 <servlet>
  <servlet-name>Faces Servlet</servlet-name>
  <servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
  <load-on-startup>0</load-on-startup>
 </servlet>
 <servlet-mapping>
  <servlet-name>Faces Servlet</servlet-name>
  <url-pattern>*.faces</url-pattern>
 </servlet-mapping>
</web-app>

六、测试

   http://localhost:8080/jsf/login/index.faces
注意，调用jsp页面时一定要使用faces，结尾，否则jsf的标签将无法识别

A task node represents one or more tasks that are to be performed by humans. So when execution arrives in a task node, task instances will be created in the task lists of the workflow participants. After that, the node will behave as a wait state. So when the users perform their task, the task completion will trigger the resuming of the execution. In other words, that leads to a new signal being called on the token.
任务节点：一个或多个可以人为执行的任务。所以当执行到任务节点，任务实例将由工作流参与者的任务列表创建。之后，这个节点会表现为等待状态。当用户执行他们的任务，任务完成将会触发执行继续。还句话说，在token上会调用一个新的signal

Nodetype state

A state is a bare-bones wait state. The difference with a task node is that no task instances will be created in any task list. This can be usefull if the process should wait for an external system. E.g. upon entry of the node (via an action on the node-enter event), a message could be sent to the external system. After that, the process will go into a wait state. When the external system send a response message, this can lead to a token.signal(), which triggers resuming of the process execution.

Nodetype decision

Actually there are 2 ways to model a decision. The distinction between the two is based on *who* is making the decision. Should the decision made by the process (read: specified in the process definition). Or should an external entity provide the result of the decision.

When the decision is to be taken by the process, a decision node should be used. There are basically 2 ways to specify the decision criteria. Simplest is by adding condition elements on the transitions. Conditions are beanshell script expressions that return a boolean. At runtime the decision node will loop over its leaving transitions (in the order as specified in the xml), and evaluate each condition. The first transition for which the conditions resolves to 'true' will be taken. Alternatively, an implementation of the DecisionHandler can be specified. Then the decision is calculated in a java class and the selected leaving transition is returned by the decide-method of the DecisionHandler implementation.

When the decision is taken by an external party (meaning: not part of the process definition), you should use multiple transitions leaving a state or wait state node. Then the leaving transition can be provided in the external trigger that resumes execution after the wait state is finished. E.g. Token.signal(String transitionName) and TaskInstance.end(String transitionName).

Nodetype fork

A fork splits one path of execution into multiple concurrent paths of execution. The default fork behaviour is to create a child token for each transition that leaves the fork, creating a parent-child relation between the token that arrives in the fork.

Nodetype join

The default join assumes that all tokens that arrive in the join are children of the same parent. This situation is created when using the fork as mentioned above and when all tokens created by a fork arrive in the same join. A join will end every token that enters the join. Then the join will examine the parent-child relation of the token that enters the join. When all sibling tokens have arrived in the join, the parent token will be propagated over the (unique!) leaving transition. When there are still sibling tokens active, the join will behave as a wait state.

Nodetype node

The type node serves the situation where you want to write your own code in a node. The nodetype node expects one subelement action. The action is executed when the execution arrives in the node. The code you write in the actionhandler can do anything you want but it is also responsible for propagating the execution.

This node can be used if you want to use a JavaAPI to implement some functional logic that is important for the business analyst. By using a node, the node is visible in the graphical representation of the process. For comparison, actions --covered next-- will allow you to add code that is invisible in the graphical representation of the process, in case that logic is not important for the business analyst.