boolean[] boolArray = new boolean[]{true,false,true};
JSONArray jsonArray1 = JSONArray.fromObject( boolArray );
System.out.println( jsonArray1 );
// prints [true,false,true]
List list = new ArrayList();
list.add( "first" );
list.add( "second" );
JSONArray jsonArray2 = JSONArray.fromObject( list );
System.out.println( jsonArray2 );
// prints ["first","second"]
JSONArray jsonArray3 = JSONArray.fromObject( "['json','is','easy']" );
System.out.println( jsonArray3 );
// prints ["json","is","easy"]

Map map = new HashMap();
map.put( "name", "json" );
map.put( "bool", Boolean.TRUE );
map.put( "int", new Integer(1) );
map.put( "arr", new String[]{"a","b"} );
map.put( "func", "function(i){ return this.arr[i]; }" );
JSONObject json = JSONObject.fromObject( map );
System.out.println( json );
//{"func":function(i){ return this.arr[i]; },"arr":["a","b"],"int":1,"name":"json","bool":true}

/**
* Bean.java
private String name = "json";
private int pojoId = 1;
private char[] options = new char[]{'a','f'};
private String func1 = "function(i){ return this.options[i]; }";
private JSONFunction func2 = new JSONFunction(new String[]{"i"},"return this.options[i];");
*/
JSONObject jsonObject = JSONObject.fromObject( new JsonBean() );
System.out.println( jsonObject );
//{"func1":function(i){ return this.options[i]; },"pojoId":1,"name":"json","options":["a","f"],"func2":function(i){ return this.options[i]; }}

/**
* private int row ;
private int col ;
private String value ;
*
*/
List list = new ArrayList();
JsonBean2 jb1 = new JsonBean2();
jb1.setCol(1);
jb1.setRow(1);
jb1.setValue("xx");
JsonBean2 jb2 = new JsonBean2();
jb2.setCol(2);
jb2.setRow(2);
jb2.setValue("");
list.add(jb1);
list.add(jb2);
JSONArray ja = JSONArray.fromObject(list);
System.out.println( ja.toString() );
//[{"value":"xx","row":1,"col":1},{"value":"","row":2,"col":2}]

String json = "{name=\"json\",bool:true,int:1,double:2.2,func:function(a){ return a; },array:[1,2]}";
JSONObject jsonObject = JSONObject.fromString(json);
Object bean = JSONObject.toBean( jsonObject );
assertEquals( jsonObject.get( "name" ), PropertyUtils.getProperty( bean, "name" ) );
assertEquals( jsonObject.get( "bool" ), PropertyUtils.getProperty( bean, "bool" ) );
assertEquals( jsonObject.get( "int" ), PropertyUtils.getProperty( bean, "int" ) );
assertEquals( jsonObject.get( "double" ), PropertyUtils.getProperty( bean, "double" ) );
assertEquals( jsonObject.get( "func" ), PropertyUtils.getProperty( bean, "func" ) );
List expected = JSONArray.toList( jsonObject.getJSONArray( "array" ) );
assertEquals( expected, (List) PropertyUtils.getProperty( bean, "array" ) );

String json = "{\"value\":\"xx\",\"row\":1,\"col\":1}";
JSONObject jsonObject = JSONObject.fromString(json);
JsonBean2 bean = (JsonBean2) JSONObject.toBean( jsonObject, JsonBean2.class );
assertEquals( jsonObject.get( "col" ),new Integer( bean.getCol())  );
assertEquals( jsonObject.get( "row" ), new Integer( bean.getRow() ) );
assertEquals( jsonObject.get( "value" ), bean.getValue() );

6 json to xml
1)
JSONObject json = new JSONObject( true );
String xml = XMLSerializer.write( json );

<o class="object" null="true">

2)
JSONObject json = JSONObject.fromObject("{\"name\":\"json\",\"bool\":true,\"int\":1}");
String xml = XMLSerializer.write( json );
<o class="object">
<name type="string">json</name>
<bool type="boolean">true</bool>
<int type="number">1</int>
</o>
<o class="object">
<name type="string">json</name>
<bool type="boolean">true</bool>
<int type="number">1</int>
</o>
3)
JSONArray json = JSONArray.fromObject("[1,2,3]");
String xml = XMLSerializer.write( json );
<a class="array">
<e type="number">1</e>
<e type="number">2</e>
<e type="number">3</e>
</a>

7 、xml to json
<a class="array">
<e type="function" params="i,j">
return matrix[i][j];
</e>
</a>
<a class="array">
<e type="function" params="i,j">
return matrix[i][j];
</e>
</a>

JSONArray json = (JSONArray) XMLSerializer.read( xml );
System.out.println( json );
// prints [function(i,j){ return matrix[i][j]; }]

自从微软推出16位的Windows操作系统起，此后每种版本的Windows操作系统都非常依赖于动态链接库(DLL)中的函数和数据，实际上Windows操作系统中几乎所有的内容都由DLL以一种或另外一种形式代表着，例如显示的字体和图标存储在GDI DLL中、显示Windows桌面和处理用户的输入所需要的代码被存储在一个User DLL中、Windows编程所需要的大量的API函数也被包含在Kernel DLL中。
DLL是建立在客户/服务器通信的概念上，包含若干函数、类或资源的库文件，函数和数据被存储在一个DLL（服务器）上并由一个或多个客户导出而使用，这些客户可以是应用程序或者是其它的DLL。

使用动态链接库的优点：
     最主要的一点是多个应用程序、甚至是不同语言编写的应用程序可以共享一个DLL文件，真正实现了资源"共享"，大大缩小了应用程序的执行代码，更加有效的利用了内存；
     使用DLL的另一个优点是DLL文件作为一个单独的程序模块，封装性、独立性好，在软件需要升级的时候开发人员只需要修改相应的DLL文件就可以了，而且，当DLL中的函数改变后，只要不是参数的改变,程序代码并不需要重新编译。这在编程时十分有用，大大提高了软件开发和维护的效率。

静态库：
函数和数据被编译进一个二进制文件（通常扩展名为LIB），在使用静态库的情况下，在编译链接可执行文件时，链接器从库中复制这些函数和数据并把他们和应用程序的其他模块组合起来创建最终的可执行文件（EXE文件）。这个过程称为"静态链接"，此时因为应用程序所需的全部内容都是从库中复制了出来，所以静态库本身并不需要与可执行文件一起发行。

动态库：
在使用动态库的时候，往往提供两个文件，一个引入库和一个DLL，引入库包含被DLL导出的函数和变量的符号名，DLL包含实际的函数和数据，在编译链接可执行文件时，只需要链接引入库，DLL中的函数代码和数据并不复制到可执行文件中，在运行的时候再去加载DLL，访问DLL中导出的函数

动态链接库加载的2种方式
1.隐式链接:隐式链接就是在程序开始执行时就将DLL文件加载到应用程序当中。实现隐式链接很容易，只要将导入函数关键字_declspec(dllimport)函数名等写到应用程序相应的头文件中就可以了。
注意：要先将Dll.dll和Dll.lib拷贝到当前工程所在的目录下面，

2.显式链接:显式链接是应用程序在执行过程中随时可以加载DLL文件，也可以随时卸载DLL文件，这是隐式链接所无法作到的，所以显式链接具有更好的灵活性，对于解释性语言更为合适。
首先要将DLL文件拷贝到工程所在的目录或Windows系统目录下。使用显式链接应用程序编译时不需要使用相应的Lib文件。
主要是三个函数的调用
LoadLibrary//加载动态链接库文件；
GetProcAddress//获取导入到应用程序中的函数指针
FreeLibrary(hDLL)//卸载动态链接库文件

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/sendy888/archive/2007/07/25/1707175.aspx

    通俗的说，在Windows操作系统中，许多应用程序并不是一个完整的可执行文件，它们的正确执行需要调用一些相对独立的动态链接库，即DLL文件。一个应用程序可以调用多个DLL文件，一个DLL文件也可能被几个应用程序所共用，这样的DLL文件被称为共享 DLL 文件。[2]DLL 文件一般被存在C:\Windows\System 目录下，也可能放在应用程序所在的目录或是子目录中。

   提到动态链接，先说明一下静态连接。什么是静态连接呢?在程序链接的过程中，需要将编译后的二进制代码链接成目标代码，链接器从静态链接库中获得所有被引用的函数，并将这些被引用的函数同代码一起放到可执行文件中。那么关于 DLL 的静态连接则是指链接器将被引用的库函数的代码复制到调用 DLL 的可执行模块(.dll 文件或 .exe 文件)中。

  什么是动态链接呢？动态链接是系统允许可执行模块(.dll 文件或 .exe 文件)在运行程中，只需要包含在定位 DLL 函数的可执行代码所需的信息。换句话说，可执行模块(.dll 文件或 .exe 文件)在运行时加载这些模块(亦即所需的模块映射到调用进程的地址空间)。[3]

   那么动态链接和静态连接 相比，优点有哪些呢？

    (1)节省内存，减少交换操作。使用动态链接，多个进程可以同时使用一个 DLL，在内存中共享该 DLL 的一个副本。使用静态链接，每个应用程序都包含被引用的库函数的代码，那么Windows 必须在内存中为每个应用程序加载引用的库函数的代码的一个副本。
    (2)节省磁盘空间。使用动态链接，在磁盘上仅需要 DLL 的一个副本。使用静态链接，每个应用程序都包含被引用的库函数的代码。
    (3)更易于升级。使用动态链接，DLL 中的函数发生变化时，只要函数的参数和返回值没有更改，就不需重新编译或重新链接使用它们的应用程序。使用静态链接，在函数发生变化时，需要重新链接来生成应用程序。
    (4)支持多语言程序，只要程序遵循函数的调用约定，用不同编程语言编写的程序就可以调用相同的DLL 函数。
    (5)提供扩展 MFC 库类的机制。可以从现有 MFC 类派生类，并将它们放到 MFC 扩展 DLL 中供 MFC应用程序使用。
    (6)支持多语言程序，并使国际版本的创建轻松完成。通过将资源放到 DLL 中，创建应用程序的国际版本变得容易得多。可将用于应用程序的每个语言版本的字符串放到单独的 DLL 资源文件中，并使不同的语言版本加载合适的资源。[4]

  DLL 中包含下面两类函数的定义：
  导出函数：这些函数由可执行模块(.dll 文件或 .exe 文件)调用。
  内部函数：这些函数仅从定义它们的 DLL 中调用。DLL 还导出数据。不过，这些数据由相应的函数使用。

   可以通过下列方式调用 DLL 中的函数： 
    加载时动态链接：可执行模块执行显式调用以导出 DLL 函数。为 DLL 创建导入库，然后将 DLL 链接到应用程序。在加载应用程序时，导入库提供加载 DLL 和查找导出的 DLL 函数所需的信息。
    运行时动态链接：在运行时加载 DLL 时，可执行模块使用 LoadLibrary 函数或 LoadLibraryEx 函数。可执行模块调用 GetProcAddress 函数以获取导出的 DLL 函数的地址。在链接时，Windows 搜索预安装的一组 DLL，例如性能库 (Kernel32.dll) 和安全库 (User32.dll)。然后，Windows 按以下顺序搜索DLL：
1.当前进程的可执行程序所在的目录。
2.当前目录。
3.Windows 系统目录。（GetSystemDirectory 函数获取 Windows 系统目录的路径。）
4.Windows 目录。（GetWindowsDirectory 函数获取 Windows 目录的路径。）
5.PATH 环境变量中列出的目录。注意：LIBPATH 环境变量不用于搜索。[3]

    DLL 有一个特殊的入口点（DllMain 函数），它在附加和分离进程和线程时运行。此行为允许根据需要创建和销毁数据结构。文件扩展名为 .ocx、.cpl 和 .drv 的文件类型也是 DLL，尽管文件扩展名已改变。
    您可以通过创建 DLL 实现以下目的：
    (1)将程序划分为可按需加载的单独模块。
    (2)存储特定于语言或特定于区域的资源。
    (3)使您自己的应用程序能够使用核心代码库。
    (4)生成进程内 COM 对象或 ActiveX 控件 (OCX)。
    (5)将 OLE 对象用作进程内 DLL。这一用法可改进 OLE 链接的性能。
    (6)使用控制面板扩展或使用某些类型的驱动程序。 [3]

二、关于以.ocx为后缀名的ActiveX控件

    刚才提到过，文件扩展名为 .ocx、.cpl 和 .drv 的文件类型也是 DLL。

    现在的ActiveX 控件等价与以前的OLE控件或OCX，一个典型的控件包括设计时和运行时的用户界面，唯一的IDispatch接口定义了控件的属性和方法，唯一的 IConnectionPoint接口定义控件可引发的事件。一个控件可以在容器中运行，所以从运行的角度看它类似与一个DLL。[5]

    尽管 ActiveX 和 OLE 都基于组建对象模型(Component Object Model，COM)，它们为程序员提供的却是截然不同的服务。COM提供的是低级的对象捆绑机制，该机制支持对象之间的交互通讯。OLE使用COM来提供低级的应用服务，例如采用连接和嵌入机制，支持用户创建复合文档。与之不同，ActiveX提供更精细的结构，用以支持在网络站点上嵌入控件，以及对事件的交互反应。优化ActiveX，目的是为了提高时间和空间效率，而优化OLE，是为了便于终端用户的使用和集成台式系统的应用程序。ActiveX还为Internet技术带来了一些技术上的变革，例如，ActiveX大大减小了代码量(代码量减少了百分之五十到七十)，支持更多的提交和异步连接。 [6]

   ActiveX的基础是OLE和COM，但是通过MS的各种开发工具可以屏蔽掉COM模型中许多另人费解的技术细节。ActiveX组件技术包括以下一些方面：(1)自动化服务器 (2)自动化控制器 (3)控件 (4)COM对象 (5)文档 (6)容器 。

   以.ocx为后缀名的ActiveX控件主要应用在WEB上和Window Forms程序开发上。应用程序使用ActiveX/COM组件来扩展自身的业务逻辑、事务处理和应用服务的范围。

   顺便提一下以.ocx为后缀名的ActiveX控件的注册和卸载方法，在“开始”菜单的“运行”输入以下代码完成任务：
    regsvr32 path & "\xxx.ocx" '注册
    regsvr32 /u path & "\xxx.ocx" '卸载

    其中path代表该xxx.ocx所以在的目录的路径。

三、OCX和DLL的区别

   以.ocx为后缀名的ActiveX控件是一种比较特殊的DLL，它的基础是OLE和COM，是有交互界面的可视化控件,定义了控件的属性和方法,定义控件可引发的事件的响应。我们通常说的.DLL为后缀名的文件是一个包含函数和数据的模块集合，可以被其它应用程序共享的程序模块。

本文引用：
[1]http://zhouyi2.jblog.cn/120494.shtml
[2]http://www.symood.com/Article/ShowArticle.asp?ArticleID=197
[3]http://www.jr163.org/cup2/54/54294.htm
[4]MSDN：DLL
[5]http://www.blog.edu.cn/user2/eliming/archives/2006/1127399.shtml
[6]http://www.symood.com/Article/ShowArticle.asp?ArticleID=198

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/scucj/archive/2006/06/29/852181.aspx

　　4:JDOM

　　JDOM的目的是成为 Java 特定文档模型，它简化与 XML 的交互并且比使用 DOM 实现更快。由于是第一个 Java 特定模型，JDOM 一直得到大力推广和促进。正在考虑通过“Java 规范请求 JSR-102”将它最终用作“Java 标准扩展”。从 2000 年初就已经开始了 JDOM 开发。

　　JDOM 与 DOM 主要有两方面不同。首先，JDOM 仅使用具体类而不使用接口。这在某些方面简化了 API，但是也限制了灵活性。第二，API 大量使用了 Collections 类，简化了那些已经熟悉这些类的 Java 开发者的使用。

　　JDOM 文档声明其目的是“使用 20%（或更少）的精力解决 80%（或更多）Java/XML 问题”（根据学习曲线假定为 20%）。JDOM 对于大多数 Java/XML 应用程序来说当然是有用的，并且大多数开发者发现 API 比 DOM 容易理解得多。JDOM 还包括对程序行为的相当广泛检查以防止用户做任何在 XML 中无意义的事。然而，它仍需要您充分理解 XML 以便做一些超出基本的工作（或者甚至理解某些情况下的错误）。这也许是比学习 DOM 或 JDOM 接口都更有意义的工作。

　　JDOM 自身不包含解析器。它通常使用 SAX2 解析器来解析和验证输入 XML 文档（尽管它还可以将以前构造的 DOM 表示作为输入）。它包含一些转换器以将 JDOM 表示输出成 SAX2 事件流、DOM 模型或 XML 文本文档。JDOM 是在 Apache 许可证变体下发布的开放源码。

　　5: DOM4J

　　虽然 DOM4J 代表了完全独立的开发结果，但最初，它是 JDOM 的一种智能分支。它合并了许多超出基本 XML 文档表示的功能，包括集成的 XPath 支持、XML Schema 支持以及用于大文档或流化文档的基于事件的处理。它还提供了构建文档表示的选项，它通过 DOM4J API 和标准 DOM 接口具有并行访问功能。从 2000 下半年开始，它就一直处于开发之中。

　　为支持所有这些功能，DOM4J 使用接口和抽象基本类方法。DOM4J 大量使用了 API 中的 Collections 类，但是在许多情况下，它还提供一些替代方法以允许更好的性能或更直接的编码方法。直接好处是，虽然 DOM4J 付出了更复杂的 API 的代价，但是它提供了比 JDOM 大得多的灵活性。

　　在添加灵活性、XPath 集成和对大文档处理的目标时，DOM4J 的目标与 JDOM 是一样的：针对 Java 开发者的易用性和直观操作。它还致力于成为比 JDOM 更完整的解决方案，实现在本质上处理所有 Java/XML 问题的目标。在完成该目标时，它比 JDOM 更少强调防止不正确的应用程序行为。

　　DOM4J 是一个非常非常优秀的Java XML API，具有性能优异、功能强大和极端易用使用的特点，同时它也是一个开放源代码的软件。如今你可以看到越来越多的 Java 软件都在使用 DOM4J 来读写 XML，特别值得一提的是连 Sun 的 JAXM 也在用 DOM4J。

　　6:总述

　　JDOM 和 DOM 在性能测试时表现不佳，在测试 10M 文档时内存溢出。在小文档情况下还值得考虑使用 DOM 和 JDOM。虽然 JDOM 的开发者已经说明他们期望在正式发行版前专注性能问题，但是从性能观点来看，它确实没有值得推荐之处。另外，DOM 仍是一个非常好的选择。DOM 实现广泛应用于多种编程语言。它还是许多其它与 XML 相关的标准的基础，因为它正式获得 W3C 推荐（与基于非标准的 Java 模型相对），所以在某些类型的项目中可能也需要它（如在 javascript 中使用 DOM）。

　　SAX表现较好，这要依赖于它特定的解析方式。一个 SAX 检测即将到来的XML流，但并没有载入到内存（当然当XML流被读入时，会有部分文档暂时隐藏在内存中）。

　　无疑，DOM4J是最好的，目前许多开源项目中大量采用 DOM4J，例如大名鼎鼎的 Hibernate 也用 DOM4J 来读取 XML 配置文件。如果不考虑可移植性，那就采用DOM4J吧！

最后发现是这段代码没有规范的使用java.net.URLEncoder，虽然使用了java.net.URLEncoder.encode()对要传递的中文进行编码，可是接收页面接收时没有使用java.net.URLEncoder.decode()进行解码。导致在有的机器上运行正常，而有的就出错。

下面贴一下解决这个问题参考的文章：

使用java.net.URLEncoder.encode()可以对要传递的中文进行编码

a.在传参数之前先把参数进行转码:java.net.URLEncoder.encode(param);
取值时用语句java.net.URLDecoder.decode(param);再转回中文
b.在你的Tomcat目录-->conf目录-->server.xml里找出这段:
       <Connector
         port="8080"               maxThreads="150" minSpareThreads="25" maxSpareThreads="75"
               enableLookups="false" redirectPort="8443" acceptCount="100"
               debug="0" connectionTimeout="20000"
               disableUploadTimeout="true"
<!--在里边加上这个参数-->
URIEncoding="gb2312"
     />

 例如:
<%@ page contentType="text/html;charset=gb2312" %>

<a href="ds.jsp?url=<%=java.net.URLEncoder.encode("编码的是这里","GB2312")%>">点击这里</a>

<%
if(request.getParameter("url")!=null)
{

str=request.getParameter("url");
str=java.net.URLDecoder.decode(str,"GB2312");
str=new String(str.getBytes("ISO-8859-1"));
out.print(str);
}

%>

若,字符编码为utf-8也可以实现.或者在此段代码中,不写出字符编码也可以(只写一个参数)。

Java代码

1. public class BlobDAO {   
2.   
3.     private static final BlobDAO instance = new BlobDAO();   
4.   
5.     private Connection conn = null;   
6.   
7.     private BlobDAO() {   
8.   
9.     }   
10.   
11.     public static BlobDAO getInstance() {   
12.         return instance;   
13.     }   
14.   
15.     private void initConn() {   
16.         conn = DBAccess.getInstance().getConn();   
17.     }   
18.   
19.        
20.     public byte[] getImage(String imgname) {   
21.         BufferedInputStream ins;//取得BLOB的IO流   
22.         byte[] bt = null;   
23.   
24.         initConn();   
25.         Blob bo = null;   
26.         PreparedStatement ps = null;   
27.         ResultSet rs = null;   
28.         String sql = "select T_IMAGE from IMAGE_LOB where t_id=?";   
29.         try {   
30.               ps = conn.prepareStatement(sql);   
31.               ps.setString(1, imgname);   
32.               rs = ps.executeQuery();   
33.               if (rs.next()) {   
34.                   bo = rs.getBlob("T_IMAGE");   
35.   
36.                   try {   
37.                       ins = new BufferedInputStream(bo.getBinaryStream());   
38.                       int bufferSize = (int) bo.length();//取得BLOB的长度   
39.                       bt = new byte[bufferSize];   
40.                       try {   
41.                             ins.read(bt, 0, bufferSize);   
42.                       } catch (IOException e) {   
43.                             // TODO Auto-generated catch block   
44.                             e.printStackTrace();   
45.                       }   
46.                       //建立字节缓存   
47.                   } catch (SQLException e) {   
48.                       // TODO Auto-generated catch block   
49.                       e.printStackTrace();   
50.                   }   
51.   
52.               }   
53.         } catch (SQLException e) {   
54.               // TODO Auto-generated catch block   
55.               e.printStackTrace();   
56.         } finally {   
57.               try {   
58.                   rs.close();   
59.                   ps.close();   
60.                   conn.close();   
61.               } catch (SQLException e) {   
62.                   // TODO Auto-generated catch block   
63.                   e.printStackTrace();   
64.               }   
65.         }   
66.   
67.         return bt;   
68.     }   
69. }  

public class BlobDAO {
private static final BlobDAO instance = new BlobDAO();
private Connection conn = null;
private BlobDAO() {
}
public static BlobDAO getInstance() {
return instance;
}
private void initConn() {
conn = DBAccess.getInstance().getConn();
}
public byte[] getImage(String imgname) {
BufferedInputStream ins;//取得BLOB的IO流
byte[] bt = null;
initConn();
Blob bo = null;
PreparedStatement ps = null;
ResultSet rs = null;
String sql = "select T_IMAGE from IMAGE_LOB where t_id=?";
try {
ps = conn.prepareStatement(sql);
ps.setString(1, imgname);
rs = ps.executeQuery();
if (rs.next()) {
bo = rs.getBlob("T_IMAGE");
try {
ins = new BufferedInputStream(bo.getBinaryStream());
int bufferSize = (int) bo.length();//取得BLOB的长度
bt = new byte[bufferSize];
try {
ins.read(bt, 0, bufferSize);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
//建立字节缓存
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
try {
rs.close();
ps.close();
conn.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
return bt;
}
}

Java代码

1. public ActionForward execute(ActionMapping mapping, ActionForm form,   
2.               HttpServletRequest request, HttpServletResponse response) {   
3.         // TODO Auto-generated method stub   
4.            
5.         BlobDAO blobDAO = BlobDAO.getInstance();   
6.            
7.         byte[] bs = blobDAO.getImage("1");   
8.            
9.         try {   
10.                  
11.               response.getOutputStream().write(bs);   
12.                  
13.         } catch (IOException e) {   
14.               // TODO Auto-generated catch block   
15.               e.printStackTrace();   
16.         }   
17.            
18.         return null;   
19.     }  

public ActionForward execute(ActionMapping mapping, ActionForm form,
HttpServletRequest request, HttpServletResponse response) {
// TODO Auto-generated method stub
BlobDAO blobDAO = BlobDAO.getInstance();
byte[] bs = blobDAO.getImage("1");
try {
response.getOutputStream().write(bs);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}

Java代码

1. public void savaImg(String imgId) {   
2.            //传的是存入数据库图片的id   
3.            initConn();   
4.            Statement st = null;   
5.            BLOB blob = null; //图片类型   
6.            OutputStream outputStream = null; //输出流   
7.            File file = null; //文件   
8.            InputStream inputStream = null; //输入流   
9.            ResultSet rs = null;   
10.            try {   
11.                  conn.setAutoCommit(false); //事物由程序员操作   
12.                  st = conn.createStatement();   
13.                  st.executeQuery("insert into IMAGE_LOB values('"+ imgId +"',empty_blob())");   
14.                  rs = st.executeQuery("select T_IMAGE from IMAGE_LOB where t_id='"+ imgId +"' for update");   
15.                  if (rs.next()) {   
16.                        blob = (BLOB) rs.getBlob(1);   
17.                        outputStream = blob.getBinaryOutputStream();   
18.                        file = new File("c:\\4.gif");   
19.                        inputStream = new FileInputStream(file);   
20.                        byte[] b = new byte[blob.getBufferSize()];   
21.                        int len = 0;   
22.                        while ((len = inputStream.read(b)) != -1) {   
23.                              System.out.println(len);   
24.                              outputStream.write(b, 0, len);   
25.                        }   
26.                  }   
27.   
28.            } catch (SQLException e) {   
29.                  // TODO Auto-generated catch block   
30.                  e.printStackTrace();   
31.            } catch (FileNotFoundException e) {   
32.                  // TODO Auto-generated catch block   
33.                  e.printStackTrace();   
34.            } catch (IOException e) {   
35.                  // TODO Auto-generated catch block   
36.                  e.printStackTrace();   
37.            } finally {   
38.                  try {   
39.                        inputStream.close();   
40.                        outputStream.flush();   
41.                        outputStream.close();   
42.                        rs.close();   
43.                        st.close();   
44.                        conn.commit();   
45.                        conn.close();   
46.                  } catch (IOException e) {   
47.                        // TODO Auto-generated catch block   
48.                        e.printStackTrace();   
49.                  } catch (SQLException e) {   
50.                        // TODO Auto-generated catch block   
51.                        e.printStackTrace();   
52.                  }   
53.   
54.            }   
55.      }  

public void savaImg(String imgId) {
//传的是存入数据库图片的id
initConn();
Statement st = null;
BLOB blob = null; //图片类型
OutputStream outputStream = null; //输出流
File file = null; //文件
InputStream inputStream = null; //输入流
ResultSet rs = null;
try {
conn.setAutoCommit(false); //事物由程序员操作
st = conn.createStatement();
st.executeQuery("insert into IMAGE_LOB values('"+ imgId +"',empty_blob())");
rs = st.executeQuery("select T_IMAGE from IMAGE_LOB where t_id='"+ imgId +"' for update");
if (rs.next()) {
blob = (BLOB) rs.getBlob(1);
outputStream = blob.getBinaryOutputStream();
file = new File("c:\\4.gif");
inputStream = new FileInputStream(file);
byte[] b = new byte[blob.getBufferSize()];
int len = 0;
while ((len = inputStream.read(b)) != -1) {
System.out.println(len);
outputStream.write(b, 0, len);
}
}
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
try {
inputStream.close();
outputStream.flush();
outputStream.close();
rs.close();
st.close();
conn.commit();
conn.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

　　技术1：在HttpServlet init()方法中缓存数据

　　服务器会在创建servlet实例之后和servlet处理任何请求之前调用servlet的init()方法。该方法在servlet的生命周期中仅调用一次。为了提高性能，在init()中缓存静态数据或完成要在初始化期间完成的代价昂贵的操作。例如，一个最佳实践是使用实现了javax.sql.DataSource接口的JDBC连接池。DataSource从JNDI树中获得。每调用一次SQL就要使用JNDI查找DataSource是非常昂贵的工作，而且严重影响了应用的性能。Servlet的init()方法可以用于获取DataSource并缓存它以便之后的重用：

以下是引用片段： 　　public class ControllerServlet extends HttpServlet 　　{ 　　private javax.sql.DataSource testDS = null; 　　public void init(ServletConfig config) throws ServletException 　　{ 　　super.init(config); 　　Context ctx　= null; 　　try 　　{ 　　ctx = new InitialContext(); 　　testDS = (javax.sql.DataSource)ctx.lookup("jdbc/testDS"); 　　} 　　catch(NamingException ne) 　　{ 　　ne.printStackTrace(); 　　} 　　catch(Exception e) 　　{ 　　e.printStackTrace(); 　　} 　　} 　　public javax.sql.DataSource getTestDS() 　　{ 　　return testDS; 　　} 　　... 　　... 　　}

　　技术2：禁用servlet和Jsp的自动装载功能

　　当每次修改了Servlet/JSP之后，你将不得不重新启动服务器。由于自动装载功能减少开发时间，该功能被认为在开发阶段是非常有用的。但是，它在运行阶段是非常昂贵的;servlet/JSP由于不必要的装载，增加类装载器的负担而造成很差的性能。同样，这会使你的应用由于已被某种类装载器装载的类不能和当前类装载器装载的类不能相互协作而出现奇怪的冲突现象。因此，在运行环境中为了得到更好的性能，关闭servlet/JSP的自动装载功能。

　　技术3：控制HttpSession

　　许多应用需要一系列客户端的请求，因此他们能互相相关联。由于HTTP协议是无状态的，所以基于Web的应用需要负责维护这样一个叫做session的状态。为了支持必须维护状态的应用，Java servlet技术提供了管理session和允许多种机制实现session的API。HttpSession对象扮演了session，但是使用它需要成本。无论何时HttpSession被使用和重写，它都由servlet读取。你可以通过使用下面的技术来提高性能：

　　在JSP页面中不要创建默认的HttpSession:默认情况下，JSP页面创建HttpSession。如果你在JSP页面中不用HttpSession，为了节省性能开销，使用下边的页面指令可以避免自动创建HttpSession对象：

以下是引用片段： < %@ page session="false"%>

　　不要将大的对象图存储在HttpSession中：如果你将数据当作一个大的对象图存储在HttpSession中，应用服务器每次将不得不处理整个HttpSession对象。这将迫使Java序列化和增加计算开销。由于序列化的开销，随着存储在HttpSession对象中数据对象的增大，系统的吞吐量将会下降。

　　用完后释放HttpSession：当不在使用HttpSession时，使用HttpSession.invalidate()方法使sesion失效。

　　设置超时值：一个servlet引擎有一个默认的超时值。如果你不删除session或者一直把session用到它超时的时候，servlet引擎将把session从内存中删除。由于在内存和垃圾收集上的开销，session的超时值越大，它对系统弹性和性能的影响也越大。试着将session的超时值设置的尽可能低。

　　技术4：使用gzip压缩

　　压缩是删除冗余信息的作法，用尽可能小的空间描述你的信息。使用gzip(GNU zip)压缩文档能有效地减少下载HTML文件的时间。你的信息量越小，它们被送出的速度越快。因此，如果你压缩了由你web应用产生的内容，它到达用户并显示在用户屏幕上的速度就越快。不是任何浏览器都支持gzip压缩的，但检查一个浏览器是否支持它并发送gzip压缩内容到浏览器是很容易的事情。下边的代码段说明了如何发送压缩的内容。

以下是引用片段： 　　public void doGet(HttpServletRequest request, HttpServletResponse response) 　　throws IOException, ServletException 　　{ 　　OutputStream out = null 　　// Check the Accepting-Encoding header from the HTTP request. 　　// If the header includes gzip, choose GZIP. 　　// If the header includes compress, choose ZIP. 　　// Otherwise choose no compression. 　　String encoding = request.getHeader("Accept-Encoding"); 　　if (encoding != null && encoding.indexOf("gzip") != -1) 　　{ 　　response.setHeader("Content-Encoding" , "gzip"); 　　out = new GZIPOutputStream(response.getOutputStream()); 　　} 　　else if (encoding != null && encoding.indexOf("compress") != -1) 　　{ 　　response.setHeader("Content-Encoding" , "compress"); 　　out = new ZIPOutputStream(response.getOutputStream()); 　　} 　　else 　　{ 　　out = response.getOutputStream(); 　　} 　　... 　　... 　　}

　　技术5：不要使用SingleThreadModel

　　SingleThreadModel保证servlet一次仅处理一个请求。如果一个servlet实现了这个接口，servlet引擎将为每个新的请求创建一个单独的servlet实例，这将引起大量的系统开销。如果你需要解决线程安全问题，请使用其他的办法替代这个接口。SingleThreadModel在Servlet 2.4中是不再提倡使用。

　　技术6：使用线程池

　　servlet引擎为每个请求创建一个单独的线程，将该线程指派给service()方法，然后在service()方法执行完后删除该线程。默认情况下，servlet引擎可能为每个请求创建一个新的线程。由于创建和删除线程的开销是很昂贵的，于是这种默认行为降低了系统的性能。我们可以使用线程池来提高性能。根据预期的并发用户数量，配置一个线程池，设置好线程池里的线程数量的最小和最大值以及增长的最小和最大值。起初，servlet引擎创建一个线程数与配置中的最小线程数量相等的线程池。然后servlet引擎把池中的一个线程指派给一个请求而不是每次都创建新的线程，完成操作之后，servlet引擎把线程放回到线程池中。使用线程池，性能可以显著地提高。如果需要，根据线程的最大数和增长数，可以创建更多的线程。

　　技术7：选择正确的包括机制

　　在JSP页面中，有两中方式可以包括文件：包括指令(< %@ include file="test.jsp" %>)和包括动作(< jsp:include page="test.jsp" flush="true" />)。包括指令在编译阶段包括一个指定文件的内容;例如，当一个页面编译成一个servlet时。包括动作是指在请求阶段包括文件内容;例如，当一个用户请求一个页面时。包括指令要比包括动作快些。因此除非被包括的文件经常变动，否则使用包括指令将会获得更好的性能。

　　技术8：在useBean动作中使用合适的范围

　　使用JSP页面最强大方式之一是和JavaBean组件协同工作。JavaBean使用< jsp:useBean>标签可以嵌入到JSP页面中。语法如下：

以下是引用片段： 　　< jsp:useBean id="name" scope="page|request|session|application" class= 　　"package.className" type="typeName"> 　　< /jsp:useBean>

　　scope属性说明了bean的可见范围。scope属性的默认值是page。你应该根据你应用的需求选择正确的范围，否则它将影响应用的性能。

　　例如，如果你需要一个专用于某些请求的对象，但是你把范围设置成了session，那么那个对象将在请求结束之后还保留在内存中。它将一直保留在内存中除非你明确地把它从内存中删除、使session无效或session超时。如果你没有选择正确的范围属性，由于内存和垃圾收集的开销将会影响性能。因此为对象设置合适的范围并在用完它们之后立即删除。

    最近做的一个项目需要用Java程序读写Zip文件，迫于找不到好的工具类来处理，也只好用java.util.zip包提供的类来实现Zip文件的压缩和解压操作了，在这之前你需要了解以下几个基本概念：

• ZipEntry：This class is used to represent a ZIP file entry.

• ZipFile：This class is used to read entries from a zip file.

• ZipInputStream：This class implements an input stream filter for reading files in the ZIP file format.

• ZipOutputStream：This class implements an output stream filter for writing files in the ZIP file format.

现在我们了解一下读写Zip文件的基本流程。当解压时，从该Zip文件输入流中读取出ZipEntry，然后根据ZipEntry的信息，读取对应文件的相应字节。代码实现如下：

publicsynchronizedstatic Map<String, byte[]> unZip(InputStream is)

           throws IOException {

       Map<String, byte[]> result = new HashMap<String, byte[]>();

       byte[] buf;

       ZipInputStream zis = new ZipInputStream(is);

       ZipEntry zipEntry = zis.getNextEntry();

       while (zipEntry != null) {

           if (zipEntry.isDirectory()) {

              zipEntry = zis.getNextEntry();

              continue;

           } else {

              buf = newbyte[(int) zipEntry.getSize()];

              zis.read(buf, 0, (int) zipEntry.getSize());

               result.put(zipEntry.getName(), buf);

              zipEntry = zis.getNextEntry();

           }

       }

       return result;

}

压缩操作与解压操作差不多，先将文件字节流组装成ZipEntry，然后把ZipEntry加入到输出流中即可。代码实现如下：

publicsynchronizedstaticByteArrayOutputStream zip(Map<String, byte[]> map)

           throws IOException {

       ByteArrayOutputStream baos = new ByteArrayOutputStream();

       ZipOutputStream zos = new ZipOutputStream(baos);

       ZipEntry zipEntry;

       for (String key : map.keySet()) {

           zipEntry = new ZipEntry(key);

           zipEntry.setSize(map.get(key).length);

           zipEntry.setTime(System.currentTimeMillis());

           zos.putNextEntry(zipEntry);

           zos.write(map.get(key));

           zos.flush();

       }

       zos.close();

       return baos;

    }

    至此，使用上面的两个方法就能完成基本的Zip文件压缩和解压缩处理了；该方法只适合处理Zip格式的文件，对于GZip格式的文件，我相信你也能轻松搞定了：）。

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

public class ZipOutputStreamDemo {
  
  
    public static void main(String[] args) throws Exception {  
 
       byte[] buffer = new byte[1024];  
 
       //生成的ZIP文件名为Demo.zip  
 
       String strZipName = "C:\\temp\\Demo.zip";  
 
       ZipOutputStream out = new ZipOutputStream(new FileOutputStream(strZipName));  
 
       //需要同时下载的两个文件result.txt ，source.txt  
 
       File[] file1 = {new File("C:\\temp\\temp001.txt"),new File("C:\\temp\\temp002.txt")};  
 
       for(int i=0;i<file1.length;i++) {  
 
           FileInputStream fis = new FileInputStream(file1[i]);  
 
           out.putNextEntry(new ZipEntry(file1[i].getName()));  
 
           int len;  
 
           //读入需要下载的文件的内容，打包到zip文件  
 
          while((len = fis.read(buffer))>0) {  
 
           out.write(buffer,0,len);   
 
          }  
 
           out.closeEntry();  
 
           fis.close();  
 
       }  
 
        out.close();  
 
        System.out.println("生成Demo.zip成功");  
 
    }  

}

实例说明

BuildPath(路径,文件名) //这个方法会对给定的路径加上文件，并自动加上分界符
<SCRIPT LANGUAGE="JavaScript">
<!--
var fso = new ActiveXObject("Scripting.FileSystemObject");
var newpath = fso.BuildPath("c:\\tmp", "51js.txt"); //生成 c:\tmp\51js.txt的路径
alert(newpath);
-->
</SCRIPT>

CopyFile(源文件, 目标文件, 覆盖) //复制源文件到目标文件，当覆盖值为true时，如果目标文件存在会把文件覆盖
<SCRIPT LANGUAGE="JavaScript">
<!--
var fso = new ActiveXObject("Scripting.FileSystemObject");
var newpath = fso.CopyFile("c:\\autoexec.bat", "d:\\autoexec.bak");
-->
</SCRIPT>

CopyFolder(对象目录,目标目录 ,覆盖) //复制对象目录到目标目录，当覆盖为true时，如果目标目录存在会把文件覆盖
<SCRIPT LANGUAGE="JavaScript">
<!--
var fso = new ActiveXObject("Scripting.FileSystemObject");
fso.CopyFolder("c:\\WINDOWS\\Desktop", "d:\\"); //把C盘的Desktop目录复制到D盘的根目录
-->
</SCRIPT>

CreateFolder(目录名) //创建一个新的目录
<SCRIPT LANGUAGE="JavaScript">
<!--
var fso = new ActiveXObject("Scripting.FileSystemObject");
var newFolderName = fso.CreateFolder("c:\\51JS"); //在C盘上创建一个51JS的目录
-->
</SCRIPT>

CreateTextFile(文件名, 覆盖) //创建一个新的文件，如果此文件已经存在，你需要把覆盖值定为true
<SCRIPT LANGUAGE="JavaScript">
<!--
var fso = new ActiveXObject("Scripting.FileSystemObject");
var newFileObject = fso.CreateTextFile("c:\\autoexec51JS.bat", true); //脚本将在C盘创建一个叫 autoexec51JS.bat的文件
-->
</SCRIPT>

DeleteFile(文件名, 只读？) //删除一个文件，如果文件的属性是只读的话，你需要把只读值设为true
<SCRIPT LANGUAGE="JavaScript">
<!--
var fso = new ActiveXObject("Scripting.FileSystemObject"); //为了安全我先把要删除的autoexec.bat备份到你的D盘
var newpath = fso.CopyFile("c:\\autoexec.bat", "d:\\autoexec.bat"); //把C盘的autoexec.bat文件删除掉
fso.DeleteFile("c:\\autoexec.bat", true);
-->
</SCRIPT>

DeleteFolder(文件名, 只读？)//删除一个目录，如果目录的属性是只读的话，你需要把只读值设为true
<SCRIPT LANGUAGE="JavaScript">
<!--
var fso = new ActiveXObject("Scripting.FileSystemObject");
fso.CopyFolder("c:\\WINDOWS\\Desktop", "d:\\"); //为了安全我先把你C盘的Desktop目录复制到你D盘的根目录
fso.DeleteFolder("c:\\WINDOWS\\Desktop", true); //把你的Desktop目录删除，但因为desktop是系统的东西，所以不能全部删除，但.........
-->
</SCRIPT>

DriveExists(盘符) //检查一个盘是否存在，如果存在就返会真，不存在就返回.......
<SCRIPT LANGUAGE="JavaScript">
<!--
var fso = new ActiveXObject("Scripting.FileSystemObject");
hasDriveD = fso.DriveExists("d"); //检查系统是否有D盘存在
hasDriveZ = fso.DriveExists("z"); //检查系统是否有Z盘存在
if (hasDriveD) alert("你的系统内有一个D盘");
if (!hasDriveZ) alert("你的系统内没有Z盘");
-->
</SCRIPT>

FileExists(文件名) //检查一个文件是否存在，如果存在就返会真，不存在就返回.......
<SCRIPT LANGUAGE="JavaScript">
<!--
var fso = new ActiveXObject("Scripting.FileSystemObject");
fileName = fso.FileExists("c:\\autoexec.bat");
if (fileName) alert("你在C盘中有autoexec.bat文件，按下确定后这个文件将被删除！"); //开个玩笑:)
-->
</SCRIPT>

FolderExists(目录名) //检查一个目录是否存在，如果存在就返会真，不存在就返回.......
<SCRIPT LANGUAGE="JavaScript">
<!--
var fso = new ActiveXObject("Scripting.FileSystemObject");
folderName = fso.FolderExists("c:\\WINDOWS\\Fonts");
if (folderName) alert("按下确定后系统的字库将被删除！"); //开个玩笑:)
-->
</SCRIPT>

GetAbsolutePathName(文件对象) //返回文件对象在系统的绝对路径
<SCRIPT LANGUAGE="JavaScript">
<!--
var fso = new ActiveXObject("Scripting.FileSystemObject");
pathName = fso.GetAbsolutePathName("c:\\autoexec.bat");
alert(pathName);
-->
</SCRIPT>

GetBaseName(文件对象) //返回文件对象的文件名
<SCRIPT LANGUAGE="JavaScript">
<!--
var fso = new ActiveXObject("Scripting.FileSystemObject");
baseName = fso.GetBaseName("c:\\autoexec.bat"); //取得autoexec.bat的文件名autoexec
alert(baseName);
-->
</SCRIPT>

GetExtensionName(文件对象) //文件的后缀
<SCRIPT LANGUAGE="JavaScript">
<!--
var fso = new ActiveXObject("Scripting.FileSystemObject");
exName = fso.GetExtensionName("c:\\autoexec.bat"); //取得autoexec.bat后缀bat
alert(exName);
-->
</SCRIPT>

GetParentFolderName(文件对象) //取得父级的目录名
<SCRIPT LANGUAGE="JavaScript">
<!--
var fso = new ActiveXObject("Scripting.FileSystemObject");
parentName = fso.GetParentFolderName("c:\\autoexec.bat"); //取得autoexec.bat的父级目录C盘
alert(parentName);
-->
</SCRIPT>

GetSpecialFolder(目录代码) //取得系统中一些特别的目录的路径，目录代码有3个分别是 0:安装Window的目录 1:系统文件目录 2:临时文件目录
<SCRIPT LANGUAGE="JavaScript">
<!--
var fso = new ActiveXObject("Scripting.FileSystemObject");
tmpFolder = fso.GetSpecialFolder(2); //取得系统临时文件目录的路径 如我的是 C:\windows\temp
alert(tmpFolder);
-->
</SCRIPT>

GetTempName() //生成一个随机的临时文件对象，会以rad带头后面跟着些随机数，就好象一些软件在安装时会生成*.tmp
<SCRIPT LANGUAGE="JavaScript">
<!--
var fso = new ActiveXObject("Scripting.FileSystemObject");
tmpName = fso.GetTempName(); //我在测试时就生成了radDB70E.tmp
alert(tmpName);
-->
</SCRIPT>

MoveFile(源文件, 目标文件) //把源文件移到目标文件的位置
<SCRIPT LANGUAGE="JavaScript">
<!--
var fso = new ActiveXObject("Scripting.FileSystemObject");
var newpath = fso.MoveFile("c:\\autoexec.bat", "d:\\autoexec.bat"); //把C盘的autoexec.bat文件移移动到D盘
-->
</SCRIPT> 

继承
指的是一个类（称为子类、子接口）继承另外的一个类（称为父类、父接口）的功能，并可以增加它自己的新功能的能力，继承是类与类或者接口与接口之间最常见的关系；在Java中此类关系通过关键字extends明确标识，在设计时一般没有争议性；

实现
指的是一个class类实现interface接口（可以是多个）的功能；实现是类与接口之间最常见的关系；在Java中此类关系通过关键字implements明确标识，在设计时一般没有争议性；

依赖
可以简单的理解，就是一个类A使用到了另一个类B，而这种使用关系是具有偶然性的、、临时性的、非常弱的，但是B类的变化会影响到A；比如某人要过河，需要借用一条船，此时人与船之间的关系就是依赖；表现在代码层面，为类B作为参数被类A在某个method方法中使用；

关联
他体现的是两个类、或者类与接口之间语义级别的一种强依赖关系，比如我和我的朋友；这种关系比依赖更强、不存在依赖关系的偶然性、关系也不是临时性的，一般是长期性的，而且双方的关系一般是平等的、关联可以是单向、双向的；表现在代码层面，为被关联类B以类属性的形式出现在关联类A中，也可能是关联类A引用了一个类型为被关联类B的全局变量；

聚合
聚合是关联关系的一种特例，他体现的是整体与部分、拥有的关系，即has-a的关系，此时整体与部分之间是可分离的，他们可以具有各自的生命周期，部分可以属于多个整体对象，也可以为多个整体对象共享；比如计算机与CPU、公司与员工的关系等；表现在代码层面，和关联关系是一致的，只能从语义级别来区分；

组合
组合也是关联关系的一种特例，他体现的是一种contains-a的关系，这种关系比聚合更强，也称为强聚合；他同样体现整体与部分间的关系，但此时整体与部分是不可分的，整体的生命周期结束也就意味着部分的生命周期结束；比如你和你的大脑；表现在代码层面，和关联关系是一致的，只能从语义级别来区分；

对于继承、实现这两种关系没多少疑问，他们体现的是一种类与类、或者类与接口间的纵向关系；其他的四者关系则体现的是类与类、或者类与接口间的引用、横向关系，是比较难区分的，有很多事物间的关系要想准备定位是很难的，前面也提到，这几种关系都是语义级别的，所以从代码层面并不能完全区分各种关系；但总的来说，后几种关系所表现的强弱程度依次为：组合>聚合>关联>依赖；

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/sfdev/archive/2009/02/18/3906243.aspx

Enum是enumeration(列举)的简写形式,包含在java.lang包中.熟悉C, C++, C#, 或 Pascal人应该对列举有所了解,先看个例子:

public enum Season { winter, spring, summer, fall }

一个enum是定义一组值的对象,它可以包括零个或多个值成员.它是属于enum类型的,一个enum对象中不可有两个或多个相同的属性或值.在次之前的java程序员一般是 用接口的方法实现列举的,如 :

public interface Season {

   static winter = 0;

   static spring = 1; //etc..

}

引入了enum的java的列举的编写方便了许多,只须定义一个enum型的对象.enum对象的值都回自动获得一个数字值,从0开始,依次递增.看一个比较简单的enum实现的例子:

EnumDemo.java

package net.javagarage.enums;

/*

We can loop over the values we put into the enum

using the values() method.

Note that the enum Seasons is compiled into a

separate unit, called EnumDemo$Seasons.class

*/

public class EnumDemo {

      /*declare the enum and add values to it. note that, like in C#, we don't use a ; to

 end this statement and we use commas to separate the values */

      private enum Seasons { winter, spring,

       summer, fall }

      //list the values

      public static void main(String[] args) {

            for (Seasons s : Seasons.values()){

                  System.out.println(s);

            }

      }

}
运行上述代码你回得到 以下结果:

winter

spring

summer

fall

Enum的属性调用:

下面的代码展示了调用enum对象的方法,这也是它通常的用法:

package net.javagarage.enums;

/*

File: EnumSwitch.java

Purpose: show how to switch against the values in an enum.

*/

public class EnumSwitch {

      private enum Color { red, blue, green }

      //list the values

      public static void main(String[] args) {

            //refer to the qualified value

            doIt(Color.red);

      }

      /*note that you switch against the UNQUALIFIED name. that is, "case Color.red:" is a

 compiler error */

      private static void doIt(Color c){

      switch (c) {

      case red:

            System.out.println("value is " + Color.red);

            break;

      case green:

            System.out.println("value is " + Color.green);

            break;

      case blue:

            System.out.println("value is : " + Color.blue);

            break;

      default :

            System.out.println("default");

      }

      }
}

为enums添加属性和方法

enums也可以象一般的类一样添加方法和属性,你可以为它添加静态和非静态的属性或方法,这一切都象你在一般的类中做的那样.

package net.javagarage.enums;

/*

File: EnumDemo.java

Purpose: show how to use an enum that also defines its own fields and methods

*/

public class EnumWithMethods {

//declare the enum and add values to it.

public enum Season {

      winter, spring, summer, fall;

      private final static String location = "Phoenix";

      public static Season getBest(){

            if (location.equals("Phoenix"))

                  return winter;

            else

                  return summer;

      }

      public static void main(String[] args) {

      System.out.println(Season.getBest());

      }

}

就是这么的简单.但是有一点是需要注意的,那就是enums的值列表必须紧跟在enum声明,不然编译时将会出错.

Enums构造函数:

和类一样enums也可以有自己的构造函数,如下:

package net.javagarage.enums;

public class EnumConstructor {

      public static void main(String[] a) {

            //call our enum using the values method

            for (Temp t : Temp.values())

                  System.out.println(t + " is : " + t.getValue());

      }

      //make the enum

      public enum Temp {

            absoluteZero(-459), freezing(32),

            boiling(212), paperBurns(451);

      //constructor here

      Temp(int value) {

            this.value = value;

      }

      //regular field?but make it final,

      //since that is the point, to make constants

      private final int value;

      //regular get method

      public int getValue() {

      return value;

      }

      }

}
输出结果是:

absoluteZero is : -459

freezing is : 32

boiling is : 212

paperBurns is : 451

尽管enums有这么多的属性,但并不是用的越多越好,如果那样还不如直接用类来的直接.enums的优势在定义int最终变量仅当这些值有一定特殊含义时.但是如果你需要的是一个类,就定义一个类,而不是enum.

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import junit.framework.TestCase;
import ognl.Ognl;

import org.darkness.oa.model.Person;
import org.darkness.oa.model.User;

public class OgnlTest extends TestCase {
 
 // ***************** root对象的概念 ******************* //
 public void testOgnl_01() throws Exception{
  User user = new User();
  user.setUsername("暗之幻影");
  
  //相当于调用user.getUsername()方法
  String value = (String)Ognl.getValue("username", user);
  System.out.println(value);
 }
 
 public void testOgnl_02() throws Exception{
  User user = new User();
  Person p = new Person();
  p.setName("暗之幻影");
  user.setPerson(p);
  
  //相当于调用user.getPerson().getName()方法
  String value = (String)Ognl.getValue("person.name", user);
  System.out.println(value);
 }
 
 public void testOgnl_03() throws Exception{
  User user = new User();
  Person p = new Person();
  p.setName("暗之幻影");
  user.setPerson(p);
  
  //可以使用#root来引用根对象，相当于调用user.getPerson().getName()方法
  String value = (String)Ognl.getValue("#root.person.name", user);
  System.out.println(value);
 }
 
 // *********************** context的概念 **********************//
 public void testOgnl_04() throws Exception{
  Person p1 = new Person();
  Person p2 = new Person();
  p1.setName("风");
  p2.setName("云");

  Map<String,Person> context = new HashMap<String,Person>();
  context.put("p1", p1);
  context.put("p2", p2);
  
  // 需要加上#才表示到context中取数据，否则表示从根目录下取值
  String value = (String)Ognl.getValue("#p1.name + ',' + #p2.name", context, new Object());
  System.out.println(value);
 }
 
 public void testOgnl_05() throws Exception{
  Person p1 = new Person();
  Person p2 = new Person();
  p1.setName("风");
  p2.setName("云");
  
  Map<String,Person> context = new HashMap<String,Person>();
  context.put("p1", p1);
  context.put("p2", p2);
  
  User root = new User();
  root.setUsername("雨");
  
  String value = (String)Ognl.getValue("#p1.name + ',' + #p2.name + ',' + username", context, root);
  System.out.println(value);
 }
 
 // ******************* OGNL赋值操作 ************************//
 public void testOgnl_06() throws Exception{
  User user = new User();
  
  //给root对象的属性赋值，相当于调用user.setUsername()
  Ognl.setValue("username", user, "暗之幻影");
  
  System.out.println(user.getUsername());
 }
 
 public void testOgnl_07() throws Exception{
  User user = new User();

  Map<String, User> context = new HashMap<String, User>();
  context.put("u", user);
  
  //给context中的对象属性赋值，相当于调用user.setUsername()
  Ognl.setValue("#u.username", context, new Object(), "暗之幻影");
  
  System.out.println(user.getUsername());
 }
 
 public void testOgnl_08() throws Exception{
  User user = new User();
  
  Map<String, User> context = new HashMap<String, User>();
  context.put("u", user);
  
  //给context中的对象属性赋值，相当于调用user.setUsername()
  //在表达式中使用=赋值操作符来赋值
  Ognl.getValue("#u.username = '暗之幻影'",context, new Object());
  
  System.out.println(user.getUsername());
 }
 
 public void testOgnl_09() throws Exception{
  User user = new User();
  Person p = new Person();
  
  Map<String,Object> context = new HashMap<String,Object>();
  context.put("u", user);
  context.put("p", p);
  
  //给context中的对象属性赋值，相当于调用user.setUsername()
  //在表达式中使用=赋值操作符来赋值
  Ognl.getValue("#u.username = '风',#p.name = '云'",context, new Object());
  
  System.out.println(user.getUsername()+","+p.getName());
 }
 
 //****************** 使用OGNL调用对象的方法 **********************//
 public void testOgnl_10() throws Exception{
  User user = new User();
  user.setUsername("暗之幻影");
  
  String value = (String)Ognl.getValue("getUsername()", user);
  System.out.println(value);
 }
 
 public void testOgnl_11() throws Exception{
  User user = new User();
  
  Ognl.getValue("setUsername('暗之幻影')", user);
  System.out.println(user.getUsername());
 }
 
 // ******************* OGNL调用类变量、静态方法 *************************//
 public void testOgnl_12() throws Exception{
  User user = new User();
  
  Ognl.getValue("setUsername('暗之幻影')", user);
  Ognl.getValue("@System@out.println(username)", user);
 }
 
 public void testOgnl_13() throws Exception{
  User user = new User();
  
  Ognl.getValue("setUsername('暗之幻影')", user);
  Ognl.getValue("@System@out.println(@org.darkness.struts2.test.Utils@toLowerCase(username))", user);
 }
 
 // ********************* OGNL中的this表达式 **********************//
 public void testOgnl_14() throws Exception{
  Object root = new Object();
  Map context = new HashMap();
  
  List values = new ArrayList();
  for(int i=0; i<11; i++){
   values.add(i);
  }
  context.put("values", values);
  
  Ognl.getValue("@System@out.println(#values.size.(#this > 10 ? \"大于10\" : '不大于10'))", context, root);
  
 }
 
 public void testOgnl_15() throws Exception{
  User user = new User();
  
  Ognl.getValue("setUsername('暗之幻影')", user);
  Ognl.getValue("@System@out.println(#this.username)", user);
 }
 
 public void testOgnl_16() throws Exception{
  User user = new User();
  
  Ognl.getValue("setUsername('暗之幻影')", user);
  Ognl.getValue("@System@out.println(username.(#this.toLowerCase()))", user);
 }
 
 // ******************* 如何把表达式的解释结果作为另外一个表达式,OGNL中括号的使用 **********************//
 public void testOgnl_17() throws Exception{
  Object root = new Object();
  Map context = new HashMap();
  User u = new User();
  u.setUsername("暗之幻影");
  context.put("u", u);
  context.put("fact", "username");
  
  /**
   * 1、首先把#fact表达式进行解释，得到一个值：username
   * 2、解释括号中的表达式#u，其结果是user对象
   * 3、把括号中表达式的结果作为root对象，解释在第一步中得到的结果（即把第一步的结果看成另外一个表达式）
   */
  String value = (String)Ognl.getValue("#fact(#u)", context, root);
  System.out.println(value);
 }
 
 public void testOgnl_18() throws Exception{
  Person person = new Person();
  Map context = new HashMap();
  User u = new User();
  u.setUsername("暗之幻影");
  context.put("u", u);
  
  /**
   * 相当于调用person这个根对象的fact方法，并把#u的解释结果作为参数传入此方法
   */
  String value = (String)Ognl.getValue("fact(#u)", context, person);
  System.out.println(value); //输出是 "暗之幻影,"
 }
 
 public void testOgnl_19() throws Exception{
  Person person = new Person();
  Map context = new HashMap();
  User u = new User();
  u.setUsername("暗之幻影");
  context.put("u", u);
  
  /**
   * 1、先计算表达式fact，得到结果是：username
   * 2、解释括号中的表达式#u，其结果是user对象
   * 3、把括号中表达式的结果作为root对象，解释在第一步中得到的结果（即把第一步的结果看成另外一个表达式）
   */
  String value = (String)Ognl.getValue("(fact)(#u)", context, person);
  System.out.println(value); //输出"暗之幻影"
 }
 
 // ********************* OGNL访问集合元素 **************************//
 public void testOgnl_20() throws Exception{
  Object root = new Object();
  Map context = new HashMap();
  
  //用OGNL创建List对象
  List listvalue = (List)Ognl.getValue("{123,'暗之幻影','风之水影'}", context, root);
  context.put("listvalue", listvalue);
  
  //用OGNL创建数组
  int[] intarray= (int[])Ognl.getValue("new int[]{23,45,67}", context, root);
  context.put("intarray", intarray);
  
  //用OGNL创建Map对象
  Map mapvalue = (Map)Ognl.getValue("#{'listvalue':#listvalue,'intarray':#intarray}", context, root);
  context.put("mapvalue", mapvalue);
  
  Ognl.getValue("@System@out.println(#listvalue[0])", context, root);
  Ognl.getValue("@System@out.println(#intarray[1])", context, root);
  Ognl.getValue("@System@out.println(#mapvalue['intarray'][2])", context, root);
  Ognl.getValue("@System@out.println(#mapvalue.intarray[0])", context, root);
 }
}

一. 采用ContextLoaderListener创建ApplicationContext
使用ContextLoaderListener创建ApplicationContext必须服务器支持listener，下面这些服务器都是支持Listener的，如果使用这些服务器，则可以使用ContextLoaderListener创建ApplicationContext实例：
1.Apache Tomcat 4.x+ 。
2.etty 4.x+ 。
3.Resin 2.1.8+ 。
4.Orion 2.0.2+ 。
5.BEA WebLogic 8.1 SP3。
Spring提供ServletContextListener的一个实现类ContextLoaderListener，该类可以作为listener使用，它会在创建时候自动查找WEB-INF/下的applicationContext.xml文件，因此，如果只有一个配置文件，并且文件名为applicationContext.xml，只需在web.xml文件中增加如下一段即可：
<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
如果有多个配置文件需要载入，则考虑使用<context-param>元素来确定配置文件的文件名。ContextLoaderListener加载时，会查找名为contextConfigLocation的参数。因此，配置context-param时参数名字应该是contextConfigLocation。
带多个配置文件的web.xml文件如下：
<!--  XML文件的文件头-->
<?xml version="1.0" encoding="ISO-8859-1"?>
<!--  web.xml文件的DTD等信息-->
<!DOCTYPE web-app
    PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
    "http://java.sun.com/dtd/web-app_2_3.dtd">
<web-app>
 <!--  确定多个配置文件-->
在web.xml文件中加载Spring容器，这是最常见的做法。Spring自己的MVC框架就是采用这种策略。
关于让MVC框架负责创建ApplicationContext实例的情况比较多，因为每个MVC框架的启动机制有区别，因此加载ApplicationContext的方式也各有不同。
对于在web.xml配置文件中配置ApplicationContext的自动创建有两种策略：
1.利用ServletContextListener实现。
<context-param>
  <!--  参数名为contextConfigLocation -->
  <param-name>contextConfigLocation</param-name>
  <!--  多个配置文件之间以,隔开 -->
  <param-value>/WEB-INF/daoContext.xml,/WEB-INF/applicationContext.xml</param-value>
 </context-param>
 <!--  采用listener创建ApplicationContext实例-->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
</web-app>
如果没有contextConfigLocation制定配置文件，Spring自动查找applicationContext.xml配置文件。
如果有contextConfigLocation，则利用该参数确定的配置文件，该参数指定的一个字符串，Spring的ContextLoaderListener负责将该字符串分解成多个配置文件，逗号“,”、空格“ ”、分号“;”都可作为字符串的分割符。
如果既然没有applicationContext.xml文件，也没有使用contextConfigLocation参数确定配置文件，或者contextConfigLocation确定的配置文件不存在，都将导致：Spring无法加载配置文件，无法正常创建ApplicationContext实例。
Spring根据bean定义创建 WebApplicationContext对象，并将其保存在Web应用的ServletContext中。大部分情况下，应用中的bean无需感受到ApplicationContext的存在，只要利用ApplicationContext的IoC即可。
如果需要在应用中获取ApplicationContext实例，可以通过如下方法获取：
WebApplicationContext ctx =
WebApplicationContextUtils.getWebApplicationContext(servletContext);
下面是采用Servlet获取ApplicationContext的完整源代码：
public class SpringTestServlet extends HttpServlet
{
 //Servlet的响应方法。
 public void service(HttpServletRequest request, HttpServletResponse response)
  throws ServletException,java.io.IOException
 {z
  //获取Servlet的ServletContext对象
  ServletContext sc = getServletContext();
  //使用WebApplicationContextUtils类获得ApplicationContext
  WebApplicationContext ctx = WebApplicationContextUtils.getWebApplicationContext(sc);
  //获取Servlet的页面输出流
  PrintWriter out = response.getWriter();
  //将ApplicationContext对象输出
  out.println(ctx);
 }
}
程序里手动获取ApplicationContext对象，然后直接输出到Servlet的响应。结果看到，ApplicationContext加载了web.xml文件中指定的两个配置文件。

二. 采用load-on-startup Servlet创建ApplicationContext
如果容器不支持Listener，则只能使用load-on-startup Servlet创建ApplicationContext实例，下面的容器都不支持Listener：
1.BEA WebLogic up to 8.1 SP2。
2.IBM WebSphere 5.x 。
3.Oracle OC4J 9.0.3。
Spring提供了一个特殊的Servlet类：ContextLoaderServlet。该Servlet在启动时，会自动查找WEB-INF/下的applicationContext.xml文件。
当然，为了让ContextLoaderServlet随应用启动而启动，应将此Servlet配置成load-on-startup的Servlet，load-on-startup的值小一点比较合适，因为要保证ApplicationContext优先创建。如果只有一个配置文件，并且文件名为：applicationContext.xml。在web.xml文件中增加如下一段即可：
<servlet>
 <servlet-name>context</servlet-name>
 <servlet-class>org.springframework.web.context.ContextLoaderServlet</servlet-class>
 <load-on-startup>1</load-on-startup>
</servlet>
该Servlet用于提供“后台”服务，作为容器管理应用中的其他bean，不需要响应客户请求，因此无需配置servlet-mapping。
如果有多个配置文件，一样使用<context-param>元素来确定多个配置文件。事实上，不管是ContextLoaderServlet，还是ContextLoaderListener，都依赖于ContextLoader创建ApplicationContext实例。在ContextLoader代码的第240行，有如下代码：
String configLocation = servletContext.getInitParameter(CONFIG_LOCATION_PARAM);
if (configLocation != null) {
 wac.setConfigLocations(StringUtils.tokenizeToStringArray(configLocation,
 ConfigurableWebApplicationContext.CONFIG_LOCATION_DELIMITERS));
}
其中CONFIG_LOCATION_PARAM是该类的常量，其值为contextConfigLocation。可看出：ContextLoader首先检查servletContext中是否有contextConfigLocation的参数，如果有该参数，则加载该参数指定的配置文件。带多个配置文件的web.xml文件如下：
<!--  XML文件的文件头-->
<?xml version="1.0" encoding="ISO-8859-1"?>
<!--  web.xml文件的DTD等信息-->
<!DOCTYPE web-app
    PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
    "http://java.sun.com/dtd/web-app_2_3.dtd">
<web-app>
 <!--  确定多个配置文件-->
 <context-param>
  <!--  参数名为contextConfigLocation -->
  <param-name>contextConfigLocation</param-name>
  <!--  多个配置文件之间以,隔开 -->
  <param-value>/WEB-INF/daoContext.xml,/WEB-INF/applicationContext.xml</param-value>
 </context-param>
 <!--  采用load-on-startup Servlet创建ApplicationContext实例-->
<servlet>
  <servlet-name>context</servlet-name>
  <servlet-class>org.springframework.web.context.ContextLoaderServlet</servlet-class>
  <!--  下面值小一点比较合适，会优先加载-->
  <load-on-startup>1</load-on-startup>
</servlet>
</web-app>
测试所用的Servlet与前面所用的没有区别。ContextLoaderServlet与ContextLoaderListener底层都依赖于ContextLoader。因此，二者的效果几乎没有区别。之间区别不是它们本身引起的，而是由于Servlet2.3的规范：listener比servlet优先加载。因此，采用ContextLoaderListener创建ApplicationContext的时机更早。
当然，也可以通过ServletContext的getAttribute方法获取ApplicationContext，使用WebApplicationContextUtils类更便捷，因为无需记住ServletContext属性名。即使ServletContext的WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE属性没有对应对象，WebApplicationContextUtils的getWebApplicationContext()方法将会返回空，而不会引起异常。
获得了WebApplicationContext实例的引用后，可以通过bean的名字访问容器中的bean实例。大部分时候，无需通过这种方式访问容器中的bean。将表现层的控制器bean置入容器的管理中，客户端请求直接转发给容器中的bean，然后由容器管理bean之间的依赖，因此，无需手动获取ApplicationContext引用。当然，每个框架都会有自己特定的整合策略。

部署到tomcat后，src目录下的配置文件会和class文件一样，自动copy到应用的 classes目录下

spring的 配置文件在启动时，加载的是web-info目录下的applicationContext.xml,
运行时使用的是web-info/classes目录下的applicationContext.xml。

配置web.xml使这2个路径一致：

<context-param>
  <param-name>contextConfigLocation</param-name>
  <param-value>/WEB-INF/classes/applicationContext.xml</param-value>
 </context-param>

多个配置文件的加载
<context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>
            classpath*:conf/spring/applicationContext_core*.xml,
            classpath*:conf/spring/applicationContext_dict*.xml,
            classpath*:conf/spring/applicationContext_hibernate.xml,
            classpath*:conf/spring/applicationContext_staff*.xml,
            classpath*:conf/spring/applicationContext_security.xml
            classpath*:conf/spring/applicationContext_modules*.xml
            classpath*:conf/spring/applicationContext_cti*.xml
            classpath*:conf/spring/applicationContext_apm*.xml
        </param-value>
    </context-param>

contextConfigLocation 参数定义了要装入的 Spring 配置文件。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/happyinggirl/archive/2008/03/13/2176285.aspx

struts.properties

applicationContext.xml

一. ActionSupport是个工具类，他实现了Action, Validatable等接口, Validatable提供validate()方法进行数据验证．Action只要继承ActionSupport类，重写validate()方法就可以进行数据验证

二. 校验的流程
     首先,Struts框架对输入数据进行类型转换,然后再进行数据校验,如果类型转换与数据校验都没有错误发生, 就进入execute(),否则请求将被转发到input视图

三. 注册实例
    首先新建RegistAcion.java

Java代码

1. package com;   
2. import java.util.Date;   
3. import com.opensymphony.xwork2.ActionSupport;   
4. public class RegistAction extends ActionSupport {   
5.     private String userName;   
6.            
7.     private Integer age;   
8.        
9.     private Date birthday;   
10.        
11.     public String getUserName() {   
12.         return userName;   
13.     }   
14.     public void setUserName(String userName) {   
15.         this.userName = userName;   
16.     }   
17.     public Integer getAge() {   
18.         return age;   
19.     }   
20.     public void setAge(Integer age) {   
21.         this.age = age;   
22.     }   
23.     public Date getBirthday() {   
24.         return birthday;   
25.     }   
26.     public void setBirthday(Date birthday) {   
27.         this.birthday = birthday;   
28.     }   
29.     @Override  
30.     public String execute() throws Exception {   
31.         System.out.println("注册成功");   
32.         return SUCCESS;   
33.     }   
34.     @Override  
35.     public void validate() {   
36.         if("".equals(userName)){   
37.             addFieldError("userName", "username is empty");   
38.         }   
39.         if(null != age){   
40.             if(1 > age || 150 < age){   
41.                 addFieldError("age", "age invalid");   
42.             }   
43.         }   
44.     }   
45. }  

package com;
import java.util.Date;
import com.opensymphony.xwork2.ActionSupport;
public class RegistAction extends ActionSupport {
private String userName;
private Integer age;
private Date birthday;
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
@Override
public String execute() throws Exception {
System.out.println("注册成功");
return SUCCESS;
}
@Override
public void validate() {
if("".equals(userName)){
addFieldError("userName", "username is empty");
}
if(null != age){
if(1 > age || 150 < age){
addFieldError("age", "age invalid");
}
}
}
}

 配置Action

Xml代码

1. <action name="regist" class="com.RegistAction">  
2.       <result name="success">/welcome.jsp</result>  
3.       <result name="input">/regist.jsp</result>  
4.  </action>  

<action name="regist" class="com.RegistAction">
<result name="success">/welcome.jsp</result>
<result name="input">/regist.jsp</result>
</action>

 接着是注册页面和注册成功页面

regist.jsp

Html代码

1. <body>  
2.     <form action="regist.action" method="post">  
3.         <s:fielderror></s:fielderror>  
4.         <table><tr>  
5.                 <td>userName:</td>  
6.                 <td>  
7.                     <input type="text" name="userName">  
8.                 </td>  
9.             </tr>  
10.             <tr>  
11.                 <td>age:</td>  
12.                 <td>  
13.                     <input type="text" name="age">  
14.                 </td>  
15.             </tr>  
16.             <tr>  
17.                 <td>birthday:</td>  
18.                 <td>  
19.                     <input type="text" name="birthday">  
20.                 </td>  
21.             </tr>  
22.             <tr>  
23.                 <td colspan="2">  
24.                     <s:submit value="注册"></s:submit>  
25.                 </td>  
26.             </tr>  
27.     </form>  
28.   </body>  

<body>
<form action="regist.action" method="post">
<s:fielderror></s:fielderror>
<table><tr>
<td>userName:</td>
<td>
<input type="text" name="userName">
</td>
</tr>
<tr>
<td>age:</td>
<td>
<input type="text" name="age">
</td>
</tr>
<tr>
<td>birthday:</td>
<td>
<input type="text" name="birthday">
</td>
</tr>
<tr>
<td colspan="2">
<s:submit value="注册"></s:submit>
</td>
</tr>
</form>
</body>

 如果不输入userName, age输入为abc,会提示
 Invalid field value for field "age".
 username is empty

1. 其中Invalid field value for field "age" 信息是struts2通过内置的类型转换器进行类型转换时,如果不能成功转换, struts2框架自动生成一条错误信息，并将该错误信息放到addFieldError里面,这种默认的输出信息格式是在  xwork-2.0.4.jar中定义的.  com/opensymphony/xwork2/xwork-messages.properties文件中有一条xwork.default.invalid.fieldvalue=Invalid field value for field "{0}".

2. 这是一种全局的错误提示方式,整个系统中只要是字段类型转换错误都会这样提示,我们也可以改变这种输出格式,只要在全局的国际资源文件中重写xwork.default.invalid.fieldvalue就可以了.

实现方式:
在struts.xml中加入<constant name="struts.custom.i18n.resources" value="messageResource"></constant> (此处i18n,不是l，是1)
或者也可以在struts.properties中加入struts.custom.i18n.resources=messageResource
指定国际化资源文件名为messageResource. Properties

新建messageResource. Properties资源文件并添加数据xwork.default.invalid.fieldvalue={0} failure
修改之后字段类型转换错误提示为 : {0} failure

3 所有的类型转换失败后,struts2会将基本类型设置为0,对象类型设置为null,这里的age的类型为Integer,当类型转换失败age值为null,如果age的类型为int,那么转换失败后值为0

4.这种提示信息不够友好,也可以定义局布的提示信息,为每一个Action新建一个properties文件,文件名为XXX.properties(Action名.properties)

实现方式:新建RegistAction.properties并添加
invalid.fieldvalue.age=age error
invalid.fieldvalue.birthday=birthday error
其中age和birthday分别为字段的名称

四.
Struts2也提供类似BaseDispatchAction的功能

Java代码

1. package com;   
2. import com.opensymphony.xwork2.ActionSupport;   
3. public class Regist2Action extends ActionSupport {   
4.     private String userName;   
5.            
6.     public String getUserName() {   
7.         return userName;   
8.     }   
9.     public void setUserName(String userName) {   
10.         this.userName = userName;   
11.     }   
12.     public String regist() throws Exception {   
13.         System.out.println("注册成功-regist");   
14.         return SUCCESS;   
15.     }   
16.        
17.     public void validateRegist() {   
18.         if(userName.equals("")){   
19.             addFieldError("userName", "请输入用户名-registValidate");   
20.         }   
21.     }   
22. }  

package com;
import com.opensymphony.xwork2.ActionSupport;
public class Regist2Action extends ActionSupport {
private String userName;
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String regist() throws Exception {
System.out.println("注册成功-regist");
return SUCCESS;
}
public void validateRegist() {
if(userName.equals("")){
addFieldError("userName", "请输入用户名-registValidate");
}
}
}

  <action name="regist2" class="com.Regist2Action" method="regist">
     <result name="success">/welcome.jsp</result>
     <result name="input">/regist2.jsp</result>
   </action>

指定了method为regist,当请求时会执行regist(),不会再去执行默认的execute()方法了,
validateRegist()方法是专门针对regist校验的.(格式为validate+方法名)

解决办法：原因缺少了dojo的JAR包，引入即可:struts2-dojo-plugin-2.1.2.jar

(

The "head" tag renders required JavaScript code to configure Dojo and is required in order to use any of the tags included in the Dojo plugin.

--------------------

If you are planning to nest tags from the Dojo plugin, make sure you set parseContent="false", otherwise each request made by the inner tags will be performed twice. 

)

2---:Unable to load configuration. - bean - jar:file:/F:/Struts2/Struts2/WebRoot/WEB-INF/lib/struts2-core-       2.1.2.jar!/struts-default.xml:46:178

       Caused by: Unable to load bean: type:org.apache.struts2.dispatcher.multipart.MultiPartRequest class:org.apache.struts2.dispatcher.multipart.JakartaMultiPartRequest -       bean - jar:file:/F:/Struts2/Struts2/WebRoot/WEB-INF/lib/struts2-core-2.1.2.jar!/struts-default.xml:46:178

       Caused by: java.lang.NoClassDefFoundError: org/apache/commons/fileupload/RequestContext 
       解决办法：缺少JAR包，引入commons-fileupload-1.2.1.jar，commons-io-1.3.2.jar即可

3---:No tag "datetimepicker" defined in tag library imported with prefix "s"

       原因版本问题：缺少struts-dojo-plugin JAR包，以及HTML的,<HEAD></HEAD>中没有使用<s:head/>标签

         If you're using Struts 2.1.x you're probably missing the> struts-dojo-plugin.  Michaël's reference below applies to Struts 2.1.xonly. In the lasts versions (since 2.0.9 I guess), all AJAX are in dojo> plugin.
> > So you need to include <%@ taglib uri="/struts-dojo-tags" prefix="sx"%>
> > and <sx:head/>
> >( Temp1:
   <sx:datetimepicker name="picker" />
   Temp2:
   <sx:datetimepicker type="time" name="picker" /><br/>
   Temp3:
   <sx:datetimepicker value="%{'2008-06-08'}" name="picker" />
   Temp4:
   <sx:datetimepicker value="date" name="picker" />)
> > and call  :<sx:datetimepicker .../>

4---:使用TILES框架     

    If you use the Tiles 2 plugin, check your tiles.xml file(s) to ensure they contain a DOCTYPE.

    <!DOCTYPE tiles-definitions PUBLIC "-//Apache Software Foundation//DTD Tiles Configuration 2.0//EN"
     "http://tiles.apache.org/dtds/tiles-config_2_0.dtd">
    <tiles-definitions>

5---:struts2中不支持EL表达式 Convert EL expressions to OGNL  

    Struts2.1 tags do not allow evaluation of JSP EL within their attributes.
    Instead, Struts2 tags evaluate attribute values as OGNL. Allowing both
    expression languages within the same attribute opens major security
    vulnerabilities. 

6---文件上传过程中取不到文件名和文件类型，即都取到NULL

    原因：如果页面中file的name=“a”则我们ACTION中设置String aContentType,String aFileName;(此两个其实无所谓，关键是SET方法)

    setA(File file)(){}; setAContentType(String s){};setAFileName(String name){} 即格式如下：setXContentType() setXFileName().X代表你给FILE取的NAME名字

    必须和它相同，固定格式

7---严重: Unable to parse request

    org.apache.commons.fileupload.FileUploadBase$SizeLimitExceededException: the request was rejected because its size (8523356) exceeds the configured maximum (2097152)

     at org.apache.commons.fileupload.FileUploadBase$FileItemIteratorImpl.<init>(FileUploadBase.java:914)2008-5-27 17:46:51 com.opensymphony.xwork2.util.logging.commons.CommonsLogger warn

    警告: Could not find property [struts.valueStack]

    2008-5-27 17:46:51 com.opensymphony.xwork2.util.logging.commons.CommonsLogger error

    严重: the request was rejected because its size (8523356) exceeds the configured maximum (2097152)

    2008-5-27 17:46:51 com.opensymphony.xwork2.util.logging.commons.CommonsLogger warn

    警告: Could not find property [org.apache.catalina.jsp_file]

 原因：上传文件大小超过预定大小，可以在struts.properties配置文件中设置struts.multipart.maxSize=XXX（XXX为文件大小）

 8---配置了文件类型限制后，当传错误类型可以拦截不让用户上传该文件，可是跳转的页面却没有跳转到input配置的错误页面，而是返回

    到了success正确页面。

    严重: Content-Type not allowed: filedata "upload__5b01657_11a329d4dcf__8000_00000000.tmp" text/plain

    《我的打印输出DEBUG语句内容:File:null  FlieName:null      type:null》即拦截类型成功了

    java.lang.NullPointerException

     at java.io.FileInputStream.<init>(FileInputStream.java:103)

     at com.study.web.util.FileUploadUtil.uploadFile(FileUploadUtil.java:36)

     at com.study.web.action.UploadFileAction.execute(UploadFileAction.java:58)

     at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)。。。

    2008-5-29 10:59:07 com.opensymphony.xwork2.util.logging.commons.CommonsLogger warn

    警告: Could not find property [org.apache.catalina.jsp_file]

    2008-5-29 10:59:07 com.opensymphony.xwork2.util.logging.commons.CommonsLogger warn

    警告: Could not find property [struts]

    2008-5-29 10:59:07 com.opensymphony.xwork2.util.logging.commons.CommonsLogger info

    信息: Removing file filedata \tmp\upload__5b01657_11a329d4dcf__8000_00000000.tmp

    原因及解决办法：在该文件上传Action中只配置了FileUploadInterceptor后缺少配置了defaultStack拦截器.

    在ACTION中配置玩defaultStack拦截器后改错误消失。

9---struts.properties中全局配置文件大小，再使用默认FileUploadInterceptor拦截器时候能实现拦截的功能但是后台出现异常。

    严重: Unable to parse request

    org.apache.commons.fileupload.FileUploadBase$SizeLimitExceededException: the request was rejected because its size (380) exceeds the configured maximum (10)

     at org.apache.commons.fileupload.FileUploadBase$FileItemIteratorImpl.<init>(FileUploadBase.java:914)

原因：未知。将全局配置中的限制大小去掉，再重新在ACTION中覆盖配置FileUploadInterceptor拦截器设置大小和文件类型限制，可消除异常。

10---多文件上传中，其中一个传被限制的文件如限制aplication/msword(即.doc)文件，允许传文本文件。然而当夹杂在一起传的时候，后台能截获类型错误不可传信息，但是

    实际却还是上传成功。

严重: Content-Type not allowed: filedata "upload_4d958287_11a33e76ab9__8000_00000007.tmp" application/msword

file is :\tmp\upload_4d958287_11a33e76ab9__8000_00000006.tmp  fileName:project.txt  fileType:text/plain

file is :\tmp\upload_4d958287_11a33e76ab9__8000_00000007.tmp  fileName:application base.doc  fileType:application/msword

file is :\tmp\upload_4d958287_11a33e76ab9__8000_00000008.tmp  fileName:zhongqi-bug.txt  fileType:text/plain

原因：忘记了继承ActionSupport类。继承后异常消失。

11--文件上传异常，不能创建File文件

    Cannot create type class java.io.File from value C:\Documents and Settings\admin\桌面\OrderReporterServiceImp.java - [unknown location]

    原因：忘记了在form表单里将enctype设置成文件上传格式：enctype="multipart/form-data"

12--当使用限制文件类型和大小的时候抛出空指针异常

    java.lang.NullPointerException
demo.struts2.action.ValidatFileUploadAction.execute(ValidatFileUploadAction.java:71)
sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    原因：在ACTION中配置了fileUpload拦截器后忘记了配置默认拦截器：defautlStack。注意当ACTION中配置自己的拦截器后需要显示配置默认

        拦截器defaultStack

13--在国际化时候抛空指针异常：
     16:31:12,812 ERROR [jsp]:253 - Servlet.service() for servlet jsp threw exception

    java.lang.NullPointerException  at java.text.MessageFormat.applyPattern(MessageFormat.java:414)
     at java.text.MessageFormat.<init>(MessageFormat.java:350)

     at com.opensymphony.xwork2.DefaultTextProvider.getText(DefaultTextProvider.java:70)
     
     原因：忘记了在struts.xml中配置国际化常量，或者在struts.properties中配置全局国际化常量 struts.custom.i18n.resources=globeMessage
 
14-- struts action的配置文件加载失败：
    Unable to load configuration. - result - file:/D:/Java/apache-tomcat-5.5.20/webapps/mysts/WEB-INF/classes/test.xml:10:26
     Caused by: No result type specified for result named 'error', perhaps the parent package does not specify the result type? - result - file:/D:/Java/apache-tomcat-5.5.20/webapps/mysts/WEB-INF/classes/test.xml:10:26

     at com.opensymphony.xwork2.config.providers.XmlConfigurationProvider.buildResults(XmlConfigurationProvider.java:609)
  
     原因：忘记了继承包struts-default
15-- struts action 配置文件注意事项：
     1. 别忘记了继承struts-default默认配置包
     2.如果配置命名空间，一定要以"/"开始，例如：namespace="/test"
     3.每个模块struts action配置文件中都可以配置全局result，global-result 经测试不会冲突，STRTUS会智能寻找该Action请求的
       模块STRUTS ACTION配置包

1.1．往action里传值的使用方式：

<input name="userName" type="text" class="input6" size="15">

a. userName属性需要在访问的action中提供相应的属性，并有SET/GET方法。

b. 可以不在访问的action中提供相应的属性，用request.getParameter(“userName”);1.2．显示标签 property 用于输出指定值：

<s:property value=" userName "/> 当action返回到指定页面是，可以通过该标签显示action中的属性信息。（注 userName必须在action中存在，并有GET方法）。

1.3．往对象中传值<s:textfield> 用于从页面往action中的对象内传值：

<s:text name="user. userName " id="username"/>

该标签可以在页面中向action中的实体对象内直接传值。（注：在action中要存在user对象，并有SET/GET方法。）

1.4．判断<s:if> </s:if> 用于在页面中判断指定数据

<s:if test="userName == admin">…. </s:if>

<s:else>…. </s:else>

该标签用于对指定的数据进行判断，但指定的数据必须在action中存在。

1.5．迭代<s:iterator>用于将List、Map、ArrayList等集合进行循环遍历

<s:iterator value="userList" id="user" status="u">

<s:property value="userName"/></a>

</s:iterator>

该标签用于将userList集合中的元素进行循环，用过property进行显示集合中的指定元素值。

1.6．URL地址标签，<s:url>用于生成一个URL地址，可以通过URL标签指定的<s:param>子元素向URL地址发送请求参数

<s:url action=" ">

           <s:param name=" " value=""></s:param>

       </s:url>

其中action为请求地址，param子元素为地址后面所带的参数。

1.7．超链接 <a href >一般和<s:url>标签一起使用，用于带多个参数。

<a href="

<s:url action=" ">

      <s:param name=" " value=""></s:param>

      <s:param name=" " value=""></s:param>

      <s:param name=" " value=""></s:param>

      </s:url>">

超链接</a>

1.8．set标签，用于将某个值放入指定的范围内。例如application,session等。

<s:set name="user" value="userName" scope=”request”/>

将user值放入request范围内。

2． Struts2页面开发中常用标签使用规范：

1.1．通过<input name="userName" type="text" class=" " size="15">

往action中传值，action中要有相应的属性，并提供SET/GET方法。

（在数量少时可以使用request.getParameter(“userName”);）

1.2．在页面显示action传来的数据，使用property标签。需要显示的数据从action中获得。

1.3．往action中的实体对象内传值，使用textfield标签。

1.4．在页面中判断指定值使用<s:if>标签。判断数据从action中获得。

1.5．在页面中需要循环列表显示的数据使用<s:iterator>标签，列表数据从action中获得。

1.6．URL地址和超链接可以使用<a href>和<s:url>，在传多值时建议<a href>和<s:url>一起使用

<%@ taglib  prefix="s" uri="/struts-tags" %>就能使用。

下面介绍各个标签的用法（若有错请指正）：

A：<s:a href=""></s:a>-----超链接，类似于html里的<a></a>

<s:action name=""></s:action>-----执行一个view里面的一个action

<s:actionerror/>-----如果action的errors有值那么显示出来

<s:actionmessage/>-----如果action的message有值那么显示出来

<s:append></s:append>-----添加一个值到list，类似于list.add();

<s:autocompleter></s:autocompleter>-----自动完成<s:combobox>标签的内容，这个是ajax

B：

<s:bean name=""></s:bean>-----类似于struts1.x中的，JavaBean的值

C：

<s:checkbox></s:checkbox>-----复选框

<s:checkboxlist list=""></s:checkboxlist>-----多选框

<s:combobox list=""></s:combobox>-----下拉框

<s:component></s:component>-----图像符号

D：

<s:date/>-----获取日期格式

<s:datetimepicker></s:datetimepicker>-----日期输入框

<s:debug></s:debug>-----显示错误信息

<s:div></s:div>-----表示一个块，类似于html的<div></div>

<s:doubleselect list="" doubleName="" doubleList=""></s:doubleselect>-----双下拉框

E：

<s:if test=""></s:if>

<s:elseif test=""></s:elseif>

<s:else></s:else>-----这3个标签一起使用，表示条件判断

F：

<s:fielderror></s:fielderror>-----显示文件错误信息

<s:file></s:file>-----文件上传

<s:form action=""></s:form>-----获取相应form的值

G：

<s:generator separator="" val=""></s:generator>----和<s:iterator>标签一起使用

H：

<s:head/>-----在<head></head>里使用，表示头文件结束

<s:hidden></s:hidden>-----隐藏值

I：

<s:i18n name=""></s:i18n>-----加载资源包到值堆栈

<s:include value=""></s:include>-----包含一个输出，servlet或jsp页面

<s:inputtransferselect list=""></s:inputtransferselect>-----获取form的一个输入

<s:iterator></s:iterator>-----用于遍历集合

L：

<s:label></s:label>-----只读的标签

M：

<s:merge></s:merge>-----合并遍历集合出来的值

O：

<s:optgroup></s:optgroup>-----获取标签组

<s:optiontransferselect doubleList="" list="" doubleName=""></s:optiontransferselect>-----左右选择框

P：

<s:param></s:param>-----为其他标签提供参数

<s:password></s:password>-----密码输入框

<s:property/>-----得到'value'的属性

<s:push value=""></s:push>-----value的值push到栈中,从而使property标签的能够获取value的属性

R：

<s:radio list=""></s:radio>-----单选按钮

<s:reset></s:reset>-----重置按钮

S：

<s:select list=""></s:select>-----单选框

<s:set name=""></s:set>-----赋予变量一个特定范围内的值

<s:sort comparator=""></s:sort>-----通过属性给list分类

<s:submit></s:submit>-----提交按钮

<s:subset></s:subset>-----为遍历集合输出子集

T：

<s:tabbedPanel id=""></s:tabbedPanel>-----表格框

<s:table></s:table>-----表格

<s:text name=""></s:text>-----I18n文本信息

<s:textarea></s:textarea>-----文本域输入框

<s:textfield></s:textfield>-----文本输入框

<s:token></s:token>-----拦截器

<s:tree></s:tree>-----树

<s:treenode label=""></s:treenode>-----树的结构

U：

<s:updownselect list=""></s:updownselect>-----多选择框

<s:url></s:url>-----创建url

• struts2-core-2.1.6.jar
• freemarker-2.3.13.jar
• commons-logging-1.0.4.jar
• ognl-2.6.11.jar
• xwork-2.1.2.jar
• commons-fileupload-1.2.1.jar
  
  要注意的是，Struts 2.1.6的最小jar包配置比Struts2.0.14多了一个commons-fileupload-1.2.1.jar。
  如果要使用Struts2的注释功能，在Struts2.0.14中只要引用了struts2-core-2.1.6.jar文件即可，而在 struts2.1.6中还需要引用struts2-convention-plugin-2.1.6.jar文件，而且注释类的包也变了（又增加了一些新的注释类），Struts2.0.14中的注释类在org.apache.struts2.config包中，而struts2.1.6的注释类在 org.apache.struts2.convention.annotation包中。除此之外，有些注释的属性名也变了，如Result注释在 struts2.0.14中有一个value属性，表示一个要转入的URL，而在Struts2.1.6的Result注释中使用location属性代替了value属性（不再有value属性了），但它们的使用方法相同。
  因此，读者在使用Struts2.1.x时要注意，这一版本与Struts2.0.x并不完全兼容（但大部分还是兼容的）。据我的经验，Struts2.1.x版本将是比较稳定的一个Struts2版本，因此，Struts1.x就是在Struts1.1版本才开始流行起来的。
  以前也测试过Struts2的其他版本，经部分测试，目前Struts 2分为三个版本阶段：Struts 2.0.9及以前版本、Struts2.0.10至Struts2.0.14、Struts 2.1.x，这三类版本都不太兼容，如果确定使用struts2来开发程序，建议直接使用struts2.1.6及以后的版本，这是一个比较稳定的Struts2版本。
  

先看看SessionFactory.getCurrentSession与openSession的区别
1. 如果使用的是getCurrentSession来创建session的话，在commit后，session就自动被关闭了，
    也就是不用再session.close()了。但是如果使用的是openSession方法创建的session的话，
    那么必须显示的关闭session，也就是调用session.close()方法。这样commit后，session并没有关闭
/*2. getCurrentSession的使用可以参见hibernate\hibernate-3.2\doc\tutorial\src项目
3. 使用SessionFactory.getCurrentSession()需要在hibernate.cfg.xml中如下配置：
   * 如果采用jdbc独立引用程序配置如下：
    <property name="hibernate.current_session_context_class">thread</property>
   * 如果采用了JTA事务配置如下
    <property name="hibernate.current_session_context_class">jta</property>*/

开始用的:

Session session = this.getHibernateTemplate().getSessionFactory().getCurrentSession();
Transaction tran=session.beginTransaction();

好多文章里都说只需在Spring配置<bean id="sessionFactory"...---><property name="hibernateProperties">   中加入 <prop key="hibernate.current_session_context_class">thread</prop>就可以解决,试了没用.

修改后的:

Session session = this.getHibernateTemplate().getSessionFactory().openSession();

Transaction tran=session.beginTransaction();

......

finally
   {  
    session.close();  
   }

问题解决

1．             Session 级别的缓存，它同session邦定。它的生命周期和session相同。Session消毁，它也同时消毁；管理一级缓存，一级缓存无法取消，用两个方法管理，clear(),evict()

2．             两个session 不能共享一级缓存，因它会伴随session的生命周期的创建和消毁；

3．             Session缓存是实体级别的缓存，就是只有在查询对象级别的时候才使用，如果

使用HQL和SQL是查询属性级别的，是不使用一级缓存的！切记！！！！

4 .  iterate 查询使用缓存，会发出查询Id的SQL和HQL语句，但不会发出查实体的，

它查询完会把相应的实体放到缓存里边，一些实体查询如果缓存里边有，就从缓存中查询，但还是会发出查询id的SQL和HQL语句。如果缓存中没有它会数据库中查询，然后将查询到的实体一个一个放到缓存中去，所以会有N+1问题出现。

5 . List()和iterate 查询区别：

使用iterate,list查询实体对象*N+1问题，在默认情况下，使用query.iterate查询，有可以能出现N+1问题

所谓的N+1是在查询的时候发出了N+1条sql语句1:首先发出一条查询对象id列表的sqlN:

根据id列表到缓存中查询，如果缓存中不存在与之匹配的数据，那么会根据id发出相应的sql语句list和iterate的区别？

list每次都会发出sql语句，list会向缓存中放入数据，而不利用缓存中的数据

iterate：在默认情况下iterate利用缓存数据，但如果缓存中不存在数据有可以能出现N+1问题

6．Get()和load(),iterate方法都会使用一级缓存，

7.hiberate3 session 存储过程如下：

       例如 object 对象

       Session.save(object);

       这时候不会把数据放到数据库，会先放到session缓存中去，数据库中没有相应记录，session.flush();才发SQL和HQL语句，数据库中有了相应记录，

       但是数据库用select查不到，这是跟数据库事物级别有关系，（这里在说下数据库的事务隔离级别一共四种如下：）
    数据库隔离级别：
        隔离级别                       是否存在脏读  是否存在不可重复读     是否存在幻读；
    Read UnCommited(未提交读)               Y            Y                     Y
    Read Commited (提交读 oraclel默认)      N            Y                     Y
    Repeatable Read(不可重复读（Msql默认）)  N            N                     Y 
    Serializable(使用很少)                  N            N                     N
    

       Session.beginTrransaction().commit();

       事物提交后可以查询到了。

Session.flush()语句但是为什么不写呢，因为commit()会默认调用flush();

Hiberante3 二级缓存总结

1．Hibernate3的（sessionFactory）二级缓存和session级别的缓存一样都只对实体对象做缓存，不对属性级别的查询做缓存；二级缓存的生命周期和sessionFactory的生命周期是一样的，sessionFactory可以管理二级缓存；

2．sessionFactory级别的缓存，需要手动配置；所有的session可以共享sessionFactory 级别的缓存；（一般把一些不经常变化的实体对象放到sessionFactory级别的缓存中，适合放不经常变化的实体对象。）

3．Hiberante3二级缓存的配置和使用方法如下：

1． 必须把ehcache.jar包导入，然后到Hibernate3.2的etc文件下把ehcache.xml复制到工程src目录下（ehcache.xml里边的参数里边有详细英文说明）；

（说明：ehcache.jar是第三方法的缓存产品，hiberante只是把它做了集成，还有好多第三方hibernate集成的缓存产品，相关说明请查阅hiberante3开发手册；ehcache支持分布应用的（这个和Hibernate3.2开发手册有出入，经过官网查证确实支持了），如果有分布式需求，请换成支持分布式的二级缓存产品，hiberate3开发手册都有相头说明。配置方法都类似）；

4．Hibernate3的二级缓存默认是开起的，也可以指定开起。在hibernate.cfg.xml 文件下配置如下：

*修改hibernate.cfg.xml文件，开户二级缓存；

                     <property name=”hibernate.cache.use_second_level_cache”>true</property>

                     *指定二级缓存产品的提供商；

<property name=”hibernate.cache.provider_class”>de> org.hibernate.cache.EhCacheProviderde>

</property>

要让那些实体使用二级缓存，在hibernate.cfg.xml配置文件中加入：

<!—

让这个实体用二级缓存 也可以在实体中映射文件去配置即：

<cache usage="read-only"/>

-->

<class-cache class=”com.zzz.hibernate.ClassT” usage=”read-only”/>

Read-only一般使用这个策略，其它的hibernate3开发手册中也有详细介绍；

CacheMode去hibernate3开发手册中搜索这个关键字，可以找到一级缓存和二级缓存交互使用的问题；

String sql = "select a.* from tb_doc_catalog a where a.cat_code like '"+catCode+"%'";
Session session = this.getSession();
try {
List catNameList = session.createSQLQuery(sql).list();
return catNameList ;
} finally {
releaseSession(session); //释放session
}

String sql = "select a from DocCatalogInfo a where a.catCode like '"+catCode+"%'";
List catNameList =getHibernateTemplate().find(sql);
return catNameList ;

String sql = "select a.* from tb_doc_catalog a where a.cat_code like '"+catCode+"%'";
Session session = this.getSession();
try {
List catNameList = session.createSQLQuery(sql).addEntity(DocCatalogInfo.class).list();
return catNameList ;
} finally {
releaseSession(session); //释放session
}

学生
<hibernate-mapping>
 
 <class name="bjca.testHibernate.entity.impl.StudentInfo" table="t_student">
   <id name="stuId" type="java.lang.Integer">
            <column name="id" />          
             <generator class="native" />
        </id>
  <property name="stuName" type="java.lang.String">
            <column name="stuName" length="50" not-null="true" />
        </property>
       
        <many-to-one name="classes" column="classId"

class="bjca.testHibernate.entity.impl.ClassInfo" cascade="all"/>
 </class>
</hibernate-mapping>

插入一个班级：
log4j:WARN No appenders could be found for logger (org.hibernate.cfg.Environment).
log4j:WARN Please initialize the log4j system properly.
Hibernate: select hibernate_sequence.nextval from dual
Hibernate: insert into t_class (claName, claId) values (?, ?)
11111

插入一个学生：
log4j:WARN No appenders could be found for logger (org.hibernate.cfg.Environment).
log4j:WARN Please initialize the log4j system properly.
Hibernate: select hibernate_sequence.nextval from dual
Hibernate: insert into t_student (stuName, classId, id) values (?, ?, ?)
11111

修改一条学生信息：
11111
log4j:WARN No appenders could be found for logger (org.hibernate.cfg.Environment).
log4j:WARN Please initialize the log4j system properly.
Hibernate: select studentinf0_.id as id0_, studentinf0_.stuName as stuName0_,

studentinf0_.classId as classId0_ from t_student studentinf0_ where studentinf0_.id=10
Hibernate: select classinfo0_.claId as claId1_, classinfo0_.claName as claName1_ from t_class

classinfo0_ where classinfo0_.claId=11
Hibernate: select studentinf0_.id as id0_0_, studentinf0_.stuName as stuName0_0_,

studentinf0_.classId as classId0_0_ from t_student studentinf0_ where studentinf0_.id=?
Hibernate: update t_student set stuName=?, classId=? where id=?
Hibernate: update t_class set claName=? where claId=?

修改一条班级信息：
11111
log4j:WARN No appenders could be found for logger (org.hibernate.cfg.Environment).
log4j:WARN Please initialize the log4j system properly.
Hibernate: select classinfo0_.claId as claId1_, classinfo0_.claName as claName1_ from t_class

classinfo0_ where classinfo0_.claId=11
Hibernate: update t_class set claName='大象二班' where claId=11

班级信息级联 all
11111
log4j:WARN No appenders could be found for logger (org.hibernate.cfg.Environment).
log4j:WARN Please initialize the log4j system properly.
Hibernate: select studentinf0_.id as id0_, studentinf0_.stuName as stuName0_,

studentinf0_.classId as classId0_ from t_student studentinf0_ where studentinf0_.id=12
Hibernate: select classinfo0_.claId as claId1_, classinfo0_.claName as claName1_ from t_class

classinfo0_ where classinfo0_.claId=11
Hibernate: select studentinf0_.id as id0_0_, studentinf0_.stuName as stuName0_0_,

studentinf0_.classId as classId0_0_ from t_student studentinf0_ where studentinf0_.id=?
Hibernate: update t_class set claName=? where claId=?

结论：
1对多，多的那方 cascade="all"

**********************************
1方， 班级：       
**********************************
实体类包含set对象，放置多方对象 名自取

配置文件中配置<set>标记,标记name取本方实体中的对方set对象的名字，即set的名字 ,
<set> 下的 <key> 指向多方主键
<set> 下的 <one-to-many> 指向多方对象

***********************************
多方  学生：       
***********************************
实体类包含1方对象，名自取

配置文件中配置<many-to-one> 指向1方对象 name 属性取本方实体方法中的对方对象的名字。