听风的歌

今天在服务里启动OracleOraHome92TNSListener服务时出现“

本地计算机上的OracleOraHome92TNSListener服务启动后又停止了，一些服务自动停止，如果它们没有什么可做的，例如"性能日志和警报服务"。

因为前两天更改了计算机名，于是打Net Manager重新设定之后，就OK啦。

1、从http://www.oracle.com/technology/software/tech/oci/instantclient/htdocs/winsoft.html下载下列几个压宿文件
instantclient-basic-win32-10.1.0.2.zip 　　 这是最核心的包
instantclient-jdbc-win32-10.1.0.2.zip 　　   包含JDBC Driver的包
instantclient-sqlplus-win32-10.1.0.2.zip 　　最简单的SQLPLUS包
下载之后，解压到一个单独的目录里，如：D:\dev\oraclient

2、配置tnsnames.ora，如果本机上没有安装oracle，可以从安装了oracle的机上拷贝一个(tnsnames.ora文件在%ORACLE_HOME%\network\admin下)放在上面的目录D:\dev\oraclient下。
oracledata =
  (DESCRIPTION =
    (ADDRESS_LIST =
      (ADDRESS = (PROTOCOL = TCP)(HOST = 192.168.0.58)(PORT = 1521))
    )
    (CONNECT_DATA =
      (SERVICE_NAME = oracledata)
    )
  )

3、添加一个环境变量，名为TNS_ADMIN，值为tnsnames.ora文件所在路径（如：D:\dev\oraclient)，这是为了能够找到上面说的tnsnames.ora。如果本机上安装了ORACLE，并且设置了ORACLE_HOME环境变量，那么会自动在%ORACLE_HOME%/network/admin/位置查找tnsnames.ora文件。

4、设置ORACLE的语言，添加注册表项：“NLS_LANG=SIMPLIFIED CHINESE_CHINA.ZHS16GBK”，位于 HKEY_LOCAL_MACHINE\SOFTWARE\ORACLE。如果本机没有安装ORACLE，在H_L_M\SOFTWARE\下是没有"ORACLE"这一项的，需要手动创建，然后再在ORACLE项下创建键NLS_LANG，键值为:SIMPLIFIED CHINESE_CHINA.ZHS16GBK

5、下载并安装PL.SQL.Developer配置应用
  配置tools->preferences->connection
  Oracle Home=D:\dev\oracleclient
  OCI library=D:\dev\oracleclient\oci.dll

6、再次打开plsql则会在database中有oracledata 选项输入用户名密码就可以登陆。

XFire开发Web服务的基本步骤
1) 检验JAVA类的方法和构造函数是否是公共的,一定要是公开的。
2) 将XFire Servlet相关的入口添加到web.xml中。

3) 创建services.xml并把它放到WEB-INF/classes/META-INF/xfire目录下，这是默认的做法;也可以将services.xml的路径配置到web.xml文件中。

4) 将XFire和其它第三方库添加到Web应用的WEB-INF/lib目录下。

FAQ
1) Weblogic8.1中应用XFire，启动wls时，出现java.lang.NoSuchMethodError的解决办法。
   首先，将XFire提供的QName JAR（qname.jar)放进WEB-INF/lib目录下。然后，将weblogic.xml文件放到WEB-INF下。
weblogic.xml的内容为：

具体的详细解说，请看XFire的User's Guide.

技巧
1. 如果Web Services的方法的参数是Collections，那就需要建一个Mapping文件，而且Mapping文件的命名为className.aegis.xml，并且与class放在同一个package下。
如：
public interface IConstraceSerice {
   boolean editConstraceInfo(List aList);
}
Mapping文件如下：IConstraceService.aegis.xml
<?xml version="1.0" encoding="utf-8"?>
<mappings>
   <mapping>
      <method name="editConstraceInfo">
          <parameter index="0" componentType="java.lang.String"/>
      </method>
   </mapping>
</mappings>

<parameter index="0" componentType="java.lang.String"/>表示第一个参数，里面实际值的类型,这里实际值的类型是java.lang.String.
如果是一个JavaBean,如com.test.TestBean,那以就要写成<parameter index="0" compentType="com.test.TestBean"/>

2. 如果返回类型是List或Map，并且里面存放的是自定义类的话，则需要增加一个对于服务接口的配置文件。该文件的命名规则是　接口文件名.aegis.xml。例如接口是UserService.java的话，则此配置文件命名为UserService.aegis.xml。注意此配置文件须与接口放在同一目录下面。
<?xml version="1.0" encoding="UTF-8"?> 
 <mappings> 
   <mapping > 
     <method name="getUsers"> 
       <return-type componentType="com.test.domain.User"/> 
     </method> 
   </mapping> 
 </mappings>
getUsers方法返回类型是List，里面装的User对象。对于这种类型的方法，在配置文件中描述了它的返回值类型。

如果返回的类型是Map的话，做法和List一样。但定义的类型，是Map中的Value部分，并且这样的话，Map中Value所存放的对象就必须全部是同一种类啦。

下面给出一个详细的例子：
1）服务接口:
public interface MyService2
{
    boolean getInfo();
    Collection getCollection(); //method 1
    Collection getCollection(int id); //method 2
    Collection getCollection(String id); //method 3
    Collection getCollectionForValues(String id, Collection c); //method 4
    Collection getCollectionForValues(int value, Collection c); //method 5
}
2) Mapping文件内容:
<mappings>
    <mapping>
        <!-- mapping 1 -->
        <method name="getCollection">
            <return-type componentType="java.lang.Double"/>
        </method>
        <!-- mapping 2 -->
        <method name="getCollection">
            <return-type componentType="java.lang.Float"/>
            <parameter index="0" class="int"/>
        </method>
        <!-- mapping 3 -->
        <method name="getCollectionForValues">
            <return-type componentType="java.math.BigDecimal"/>
        </method>
        <!-- mapping 4 -->
        <method name="getCollectionForValues">
            <parameter index="0" class="java.lang.String"/>
            <parameter index="1" componentType="java.util.Date"/>
        </method>
        <!-- mapping 5 -->
        <method name="getCollectionForValues">
            <return-type componentType="java.util.Calendar"/>
            <parameter index="0" class="int"/>
            <parameter index="1" componentType="java.lang.Bit"/>
        </method>
    </mapping>
</mappings>

3. 如果一个方法的返回类型是一个JavaBean,而这个JavaBean当中又存在Collections,那么就需要定义一个与JavaBean相关的Mapping文件,文件名要与JavaBean名相同,如:User.aegis.xmll,并且与JavaBean放在同一个目录.

例子:
1) 服务接口
public interface IYMServiceFacade {
   User getUser();
}

2) JavaBean
public class User {
   private Strirng userName;
   // 这里是一个Collection
   private Set rooms;

   .....
   .....
}

3) Mapping文件(User.aegis.xml)
<?xml version="1.0" encoding="utf-8"?>
<mappings>
    <mapping>
        <property name="rooms" componentType="com.powerunion.ymservice.dto.Room"/>
    </mapping>
</mappings>

介绍:<property name="rooms" componentType="com.powerunion.ymservice.dto.Room"/>
其中的name属性就是JavaBean里面定义的rooms,componentType上面的相同,表示Collections里真正存储的类型.

注：如果服务接口的参数或者返因类型是基本类型（int, float, double等)就不需要创建Mapping文件。
详细的信息见XFire的User's Guide.

4.如果Web Services和客户端运行在同一个JVM上，可以选择使用本地传输，可以大幅提升性能。如：以下指定服务端URL的这行。
String serviceUrl = "http://localhost:8080/YM/services/ContractService";
替换为
String serviceUrl = "xfire.local://ContractService";

5. 用ant task 生成xfire 客户端代码
  
用xfire不管是配置web service，还是生成客户代码都很方便．
生成客户代码只要在用ant生成就可以了！

build.xml

代码
<?xml version="1.0"?> 
 
<project default="genfiles" basedir="."> 
    <property name="lib" value="WebRoot/WEB-INF/lib" /> 
    <path id="myclasspath"> 
        <fileset dir="${lib}"> 
            <include name="*.jar" /> 
        </fileset> 
        <pathelement location="${genfiles}" /> 
    </path> 
    <property name="code_path" value="src" /> 
    <property name="wsdl_path" value="Echo1Service.xml" /> 
    <property name="code_package" value="com.client" /> 
    <target name="genfiles"  description="Generate the files"> 
        <taskdef name="wsgen" classname="org.codehaus.xfire.gen.WsGenTask" classpathref="myclasspath" /> 
        <wsgen outputDirectory="${code_path}" wsdl="${wsdl_path}" package="${code_package}" binding="xmlbeans" /> 
    </target> 
</project> 
 

1、在WAS5.1上创建一个共享库
2、将jaxen.jar、jdom-1.0.jar、qname.jar、stax-api-1.0.1.jar、wsdl5j-1.6.1.jar放置于共享库里。
3、在应用程序里引用这个共享库，并将应用程序的class loader policy 设置为parent_last.

来自javayeye的帖子，http://www.javaeye.com/topic/18648?page=1，运用设计模式很重要一点：模式应该带来清晰并且易于理解的结构，而非大堆大堆的麻烦。如果是你发现变麻烦了，那是你的方法错了。设计模式的异同不是通过结构，而是通过意图和场景来理解，当然，如果真能达到应用中重神而非形的境界，就玄而又玄了。

工厂模式是最重要的模式，因为大多数模式都需要用到工厂模式。如果不能正确的运用工厂模式，那么可以说无法成为合格的架构师。
多数设计模式的内容讲解的都是如何设计接口。
接口如何产生呢？如果在客户代码（类库的使用者称之为客户）中直接使用具体类，那么就失去了接口的意义。因为接口的使用目的，就是要降低客户对具体类的依赖程度。如果在客户代码中直接使用接口，那么就造成了客户对具体类名称的依赖。（客户最终需要以某种方式指明所需要的具体类，如配置文件或代码，但是只需要指出一次，所以说降低对具体类的依赖程度）。要使客户代码不依赖具体类，唯一的方法，就是让客户代码不依赖具体类的部分不知道具体类的名称。知道具体类名称的部分，仅仅是配置部分。（配置文件或者配置代码）。
依赖不可能完全消除，除非二者毫无联系。但是可以将这种依赖的程度降到最低。
既然不能直接创建具体类，那么就需要通过一个创建者类来创建接口的实现类。这样就产生了工厂类。
那么现在已经知道工厂类存在的理由，抽象创建接口的过程。
这样，就可以使用简单工厂。
简单工厂，一般是两级结构。工厂类创建接口。
随着接口创建复杂性的增强，可能在接口创建的过程中，一个创建者类，无法承担创建所有的接口类的职责。
可能会有这样的情况，我们定义了一个接口，有6个实现类分别是123456号。但是，这六个实现类不可能用一个工厂创建出来，因为123号是 windows下的实现，而456号是linux上的实现。（假设我们使用的语言不是广大人民群众热爱的java语言），那么这个时候，我还需要客户方用相同的方式来创建这个借口，而不是在代码中到处写

那样就太麻烦了。设计模式就是为了减少麻烦，而不是什么别的废话，比如什么太极八卦、天人合一、面向xx之类的。因为怕麻烦，所以搞出设计模式这个咚咚减少麻烦。如果你发现用了设计模式更麻烦了，那么肯定是你用错了。
这个时候为了省事，我就把工厂也抽象成一个接口（因为我有两个相似的工厂，如果只有一个，我还废话什么呢），这样就成了工厂方法。
当然，既然工厂方法成了一个接口，那么当然也需要用一个工厂来创建它。这个时候，创建是三级结构，简单工厂（此时是工厂的工厂）创建工厂接口（本来是个类，现在因为进一步的抽象，成为接口了），工厂接口创建产品。
过了一段时间，随着我们的工厂业务不断发展，我们有了很多产品。
比如，我们有锤子和钉子两种产品。这两种产品都有windows品牌和linux品牌的。我们给锤子和钉子各自定义了一个创建的接口。

可是，我们发现某些用户，用windows的锤子去敲linux的钉子，从而把程序敲出了bug。这当然是我们的错误，因为我们违反了一条金科玉律：
要想使你的程序稳定运行，你假设用户是猪。
所以，我们把锤子和钉子的工厂合并，让一个工厂只能造出配套的锤子和钉子，这样猪就没有犯错误的机会了。
于是我们搞出一个抽象工厂：

当然，这个铁匠铺是个接口，所以同样需要用一个工厂来创建它。所以，这个时候，工厂还是三级结构。
我们的工厂，业务很多，而且产品一般都是配套使用的（这样可以多骗点钱），所以，我们大多数情况下，都是使用抽象工厂和简单工厂。简单工厂用来创建工厂，抽象工厂创建产品。
工厂的作用，就是创建接口。
其实我们不知道什么是设计模式，我们只是怕麻烦。什么是麻烦呢？
我们觉得把同样的代码写两遍就非常麻烦。所以，我们宁可多写几句，也要解决麻烦。猪不怕麻烦，可以日复一日的重复相同的事情，可是我们不是猪。

我们平日走在步人街上都能看到很多专卖店，服装、珠宝等等；
拿服装专卖店来说，一个专卖店里面肯定有好几个品牌的服装，比如Giordano、Baleno，这些品牌都是不同公司生产的。
没人见个专卖店自己生产服装的吧，专卖店需要某个品牌的服装时，就去联系相应的厂家供货即可，具体的生产是由厂家去完成。
抽象工厂模式也是如此，抽象工厂提供多个抽象方法，由具体的子工厂去实现。
现在我想开一家服装店，经营上衣和短裤，至于具体什么品牌的等选门面在装修之时再定。

好了，现在门面选好且已装修完毕，具体经营什么品牌也早想好，就佐丹奴和班尼路吧。
开始联系厂家，厂家要能生产Shirt和Pants，而且要有生产Giordano、Baleno这两个品牌。

我们都知道服装都有一些共同的特征，每件衣服都有所属的品牌、每条短裤都有一个尺码。

佐丹奴的衣服自然会印上Giordano字样的标志

班尼路的也不例外，加上自己的品牌标志

运气不错，很快就找到了厂家。

// 生产Giordano上衣和短裤的工厂

// 生产Baleno上衣和短裤的工厂

厂家开始供货，开业大吉，哈哈。

以后想多经营几个品牌，只需直接去找了厂家供货即可。

最后，为了充分理解抽象工厂模式，画出它的UML图是很有必要的。

建立一个基本的程序通常有几个常用的任务，像是设置通用属性、创建或删除目录、编译程序、打包、拷贝文件等等。
这些任务，我们都可以在build.xml中编写相应的任务目标[target]

■ 属性设定：<property>

如果一个固定的值（如：目录D:\dev\lib)，在多个target中被应用到，这时我们就通过<property>对它设定，应用到它的地方都使用设定的<property>代替，如果日后有发生变化，也只需要改动<property>的设定即可

每个property都有一个name(名称)和一个value(值)，要引用某个property可以使用${property-name}，像上面的${app.home}。
这些属性的值也可以在执行的时候指定，如：ant -Dapp.home="d:\dev\book"，如果执行时没有指定，那么就会使用value上定义的值。

■ 创建目录：<mkdir>
如果父目录不存在，也会被同时创建；如test不存在，会先创建test目录，然后在其下创建classes目录。可以看到我们这里使用了一个属性DIST.DIR代替一个具体的目录。

■ 创建目录和文件：<delete>

■ 拷贝文件和目录：<copy>

■ 移动或重命名文件、目录：<move>

前面简单的介绍了Ant
http://www.blogjava.net/x-29/archive/2007/04/09/109426.html

现在来看一下，如何编写Ant的buildfile.

buildfile是一个xml文档，默认命名为build.xml，在Ant的buildfile中，我们可以设定属性[property]、任务[task]，每个buildfile中可以设定多个任务[task]，这些任务可以是编译源码、生成Doc文档、程序测试等；通常会将这些任务组织为一个目标[target]。

看一个简单的build.xml，大概了解一下


可以看到build.xml中，project作为根元素(每个buildfile中都会有一个project)，然后是定义了两个属性以及一个target。

project元素和target元素的属性，可以看下面的表。

标签	属性	描述	必需的
project	name	项目名称	No
	default	没有指定target时，缺省使用的target	Yes
	basedir	作为计算其它路径的基路径。该属性可以被basedir property覆盖，当覆盖时，该属性被忽略。如果属性和basedir property都没有设定，就使用buildfile文件的父目录	No
target	name	target的名字	Yes
	depends	用逗号隔开的target名字列表，设定些属性，就意味着本target将依赖于depends设定的target	No
	if	执行target所需设定的属性名	No
	unless	执行target所需要清除设定的属性名	No
	description	关于target的描述	No

在使用
执行时，会先进入到"complie"目标(上面的Ant没有指定target，所以会使用project的default值)，编译源码(javac task)

提示：我们可以在ant后面指定想要执行的target，缺省情况下会使用默认的(即:project元素default属性设定的target)。 

通常，要运行一个程序，首先得要编译它的源码，生成可执行文件，然后才运行这个可执行文件。 可以看到这是由两个任务组成，而且运行可执行文件任务依赖编译源码任务。Ant的buildfile中可以定义多个target，同时一个target的执行可以依赖于另一个target，表描这种依赖关系可以通过target元素的depends属性，depends可以设定多个target(以逗号间隔)，如：
"run"目标依赖"mkdir"和"complie"目标，也就是运行程序之前，要先建立相关文档目录，编译源码生成可执行文件。
depends属性设定的依赖是按左到右的顺序执行，执行命令Ant run，会先执行"mkdir"目标，执行完后，再到"complie"，最后才执行"run"目标。

<property>元素，主要是设置一些常用的属性，每个属性都会有一个名称(name)，以后再做详解。

有关Ant的buildfile，就说到这，下篇说说Ant的常用任务[task]标签

Ant是什么？ Ant的全名是"Another Neat Tool"，它是一个基于java的生成工具。

在使用Ant之前，我们要先到Ant官方网站将其下载下来，进行相关的设置。

下面说一下怎么设置Ant，下载Ant之后，解压到相关的目录，如：D:\dev\apache-ant-1.6.1

• 新增环境变量：JAVA_HOME，内容为JAVA的安装路径；如：D:\dev\j2sdk1.4.2
• 新增环境变量：ANT_HOME，内容为Ant的安装目录，如上：D:\dev\apache-ant-1.6.1
• 在PATH环境变量中加入Ant的bin目录：%\ANT_HOME%\bin

 

正确的安装Ant和设置好环境变量后，就可以开始运行ant了。
运行Ant很简单，只要输入ant就可以了
没有指定任何参数时，Ant会在当前目录下寻找build.xml文件。如果找到了就用该文件作为buildfile。

如果，使用Ant的-find选择，就会在当前目录的上级目录查找build.xml文件，一直到达文件系统的根。

上面说得的都是默认的buildfile，要想使用指定的buildfile，可以使用-buildfile file参数，这里file就是指定的要查找的buildfile。

也可以在Ant命令之后指定执行一个或者多个target，缺省情况下，Ant使用<project>标签中default属性所指定的target。
"complie"就是一个target


下面来看一些具体的例子
D:\>Ant
使用当前目录下的build.xml运行ant，执行缺省的target（也就是<project>标答中default属性所设写的target)

D:\>Ant -buildfile hibernate-build.xml
使用当前目录下的hibernate-build.xml运行ant，执行缺省的target。

D:\>And -buildfile hibernate-build.xml compile
使用当前目录下的hibernate-build.xml运行ant，并执行名为"complie"的target。

方法一：
使用java.sql.Date实现在yyyy-mm-dd格式的日期。

java.sql.Date不支持时间格式。切不要使用new java.sql.Date(int year, int month, int date)，因为这样还需要处理时间差问题。


方法二：
使用java.sql.Timestamp，同上不要使用new java.sql.Timestamp(...)


方法三：
使用ORACLE的内置函数to_date

理解类的实现机制

在JavaScript中可以使用function关键字来定义一个“类”，如何为类添加成员。在函数内通过this指针引用的变量或者方法都会成为类的成员，例如：

var obj1=new class1();
通过new class1()获得对象obj1，对象obj1便自动获得了属性p1和方法method1。
在JavaScript中，function本身的定义就是类的构造函数，结合前面介绍过的对象的性质

以及new操作符的用法，下面介绍使用new创建对象的过程。
(1) 当解释器遇到new操作符时便创建一个空对象；
(2) 开始运行class1这个函数，并将其中的this指针都指向这个新建的对象；
(3) 因为当给对象不存在的属性赋值时，解释器就会为对象创建该属性，例如在class1中，当执行到this.p1=s这条语句时，就会添加一个属性p1，并把变量s的值赋给它，这样函数执行就是初始化这个对象的过程，即实现构造函数的作用；
(4) 当函数执行完后，new操作符就返回初始化后的对象。

通过这整个过程，JavaScript中就实现了面向对象的基本机制。由此可见，在JavaScript中，function的定义实际上就是实现一个对象的构造器，是通过函数来完成的。这种方式的缺点是：
□将所有的初始化语句、成员定义都放到一起，代码逻辑不够清晰，不易实现复杂的功能。
□每创建一个类的实例，都要执行一次构造函数。构造函数中定义的属性和方法总被重复的创建，例如：

这里的method1每创建一个class1的实例，都会被创建一次，造成了内存的浪费。下一节介绍另一种类定义的机制：prototype对象，可以解决构造函数中定义类成员带来的缺点。

使用prototype对象定义类成员

上一节介绍了类的实现机制以及构造函数的实现，现在介绍另一种为类添加成员的机制：prototype对象。当new一个function时，该对象的成员将自动赋给所创建的对象，例如：

prototype是一个JavaScript对象，可以为prototype对象添加、修改、删除方法和属性。从而为一个类添加成员定义。
了解了函数的prototype对象，现在再来看new的执行过程。
(1) 创建一个新的对象，并让this指针指向它；
(2) 将函数的prototype对象的所有成员都赋给这个新对象；
(3) 执行函数体，对这个对象进行初始化操作；
(4) 返回（1）中创建的对象。

和上一节介绍的new的执行过程相比，多了用prototype来初始化对象的过程，这也和prototype的字面意思相符，它是所对应类的实例的原型。这个初始化过程发生在函数体（构造器）执行之前，所以可以在函数体内部调用prototype中定义的属性和方法，例如：

和上一段代码相比，这里在class1的内部调用了prototype中定义的方法showProp，从而在对象的构造过程中就弹出了对话框，显示prop属性的值为1。
需要注意，原型对象的定义必须在创建类实例的语句之前，否则它将不会起作用，例如：

这段代码将会产生运行时错误，显示对象没有showProp方法，就是因为该方法的定义是在实例化一个类的语句之后。
由此可见，prototype对象专用于设计类的成员，它是和一个类紧密相关的，除此之外，prototype还有一个重要的属性：constructor，表示对该构造函数的引用，例如：

class1.prototype.constructor(); //调用类的构造函数

这段代码运行后将会出现对话框，在上面显示文字“1”，从而可以看出一个prototype是和一个类的定义紧密相关的。实际上：class1.prototype.constructor===class1。

一种JavaScript类的设计模式

前面已经介绍了如何定义一个类，如何初始化一个类的实例，且类可以在function定义的函数体中添加成员，又可以用prototype定义类的成员，编程的代码显得混乱。如何以一种清晰的方式来定义类呢？下面给出了一种类的实现模式。
在JavaScript中，由于对象灵活的性质，在构造函数中也可以为类添加成员，在增加灵活性的同时，也增加了代码的复杂度。为了提高代码的可读性和开发效率，可以采用这种定义成员的方式，而使用prototype对象来替代，这样function的定义就是类的构造函数，符合传统意义类的实现：类名和构造函数名是相同的。例如：

虽然上面的代码对于类的定义已经清晰了很多，但每定义一个属性或方法，都需要使用一次class1.prototype，不仅代码体积变大，而且易读性还不够。为了进一步改进，可以使用无类型对象的构造方法来指定prototype对象，从而实现类的成员定义：

上面的代码用一种很清晰的方式定义了class1，构造函数直接用类名来实现，而成员使用无类型对象来定义，以列表的方式实现了所有属性和方法，并且可以在定义的同时初始化属性的值。这也更象传统意义面向对象语言中类的实现。只是构造函数和类的成员定义被分为了两个部分，这可看成JavaScript中定义类的一种固定模式，这样在使用时会更加容易理解。

注意：在一个类的成员之间互相引用，必须通过this指针来进行，例如在上面例子中的someMethod方法中，如果要使用属性someProperty，必须通过this.someProperty的形式，因为在JavaScript中每个属性和方法都是独立的，它们通过this指针联系在一个对象上。

 

以前做过一个网上申报的功能，客户可以在网站上申报办件，这个申报过程需要完成4个步骤，内容比较多，设计人员将4个步骤设计成四个单独的页面，每个页面上都有一个表单需要申报人员填写相关信息。

为了一个申报数据是合法、有效的，程序在第四个步骤完成时才会将数据记录到数据库当中。

大家可能会想到，通过隐藏字段(hidden)记录前一个步骤的表单值，到最后一个步骤时再一起提交出去，这也是一个方法。

现在有另一种方法，通过Struts来实现。
具体实现步骤如下：
1、建立一个FormBean，它包含4个步骤的Form信息，并助将scope设置为session.
2、每个页面共用这个FormBean.
3、为每个页面的表单加一个hidden字段，它的值分别为1,2,3,4(即第一个页面的值为1，以此类推；这样做的目的为了在FormBean里面的reset方法中，将相关的值设为null)

这里给出FormBean中reset方法的实现

JS中字符串的连接，我们常用"+"，大量的字符串连接操作中使用"+"代价是很高的，在JAVA里面，都知道使用StringBuffer类的append方法，那么在JS里面，我们可以使Array对象的join方法。

我们使用AJAX发送请求，有时候需要传递参数，其多个参数之间都是以"&"隔开。

在要求传的参数比较多的情况下，可以将参数-值先一个一个的存在Array里面，然后使用join方法转换为字符串。

首先看下面的代码


如果将val2的值改写成0.8，执行结果又如何呢？会是0.2吗？


为什么会这样呢？问题就是出在"IEEE 754 floating-point arithmetic"，在JAVA语言里需要遵守这项规则。


要解决上面的问题，得到正确的结果，需要使用BigDecimal类；float和double一般用来做科学计算或者是工程计算，在商业计算中我们要用 java.math.BigDecimal。

code:

double val1 = 1.0;
double val2 = 0.2;

BigDecimal b1 = new BigDecimal(String.valueOf(val1));
BigDecimal b2 = new BigDecimal(String.valueOf(val2));
b1 = b1.subtract(b2);
System.out.println(b1.doubleValue());

这里有一点需要说明一下，BigDecimal类提供了BigDecimal(double val)构造函数，为什么上面还用String.valueOf(double v)转换而使用BigDecimal类的BigDecimal(String val)构造函数呢？

在API Doc 中这样说明：

将 double 转换为 BigDecimal，后者是 double 的二进制浮点值准确的十进制表示形式。返回的 BigDecimal 的标度是使 (10^scale × val) 为整数的最小值。

注：

1. 此构造方法的结果有一定的不可预知性。有人可能认为在 Java 中写入 new BigDecimal(0.1) 所创建的 BigDecimal 正好等于 0.1（非标度值 1，其标度为 1），但是它实际上等于 0.1000000000000000055511151231257827021181583404541015625。这是因为 0.1 无法准确地表示为 double（或者说对于该情况，不能表示为任何有限长度的二进制小数）。这样，传入 到构造方法的值不会正好等于 0.1（虽然表面上等于该值）。
2. 另一方面，String 构造方法是完全可预知的：写入 new BigDecimal("0.1") 将创建一个 BigDecimal，它正好 等于预期的 0.1。因此，比较而言，通常建议优先使用 String 构造方法。
3. 当 double 必须用作 BigDecimal 的源时，请注意，此构造方法提供了一个准确转换；它不提供与以下操作相同的结果：先使用 Double.toString(double) 方法，然后使用 BigDecimal(String) 构造方法，将 double 转换为 String。要获取该结果，请使用 staticvalueOf(double) 方法。