学习struts过程，碰到中文乱码问题，不管3721，go出一大堆关于这方面的文章，看了几个，觉得好象讲的都差不多，但是具体细节有些遗漏，摸索了两天，仔细体会了一些原理性文章。终于得到解决。

我的解决办法是这样的:

首先要搞清楚以下几个概念：

1.首先是.properties,.jsp文件的编码格式(eclipse中来说吧，就是文件Properties的Info的Text file encoding )

2.jsp中的"charset"的设置值

首先建立建立一个ApplicationResources_cn.properties文件

内容如下:

errors.name=用户名错误

在里面写入一些信息。并以UTF-8格式保存（我使用的是eclipse,在eclipse中设置文件的Properties属性为UTF-8既可).然后在dos下，先进入ApplicationResources_cn.properties文件所在的目录。在输入以下命令:

native2ascii -encoding UTF-8  ApplicationResources_cn.properties ApplicationResources.properties

(这里要注意 -encoding 后面的参数 UTF-8,因为前面ApplicationResources_cn.properties 是以UTF-8格式保存的，所以这里一定要要用UTF-8，要不后面再怎么弄，永远也显示不出中文。我曾经就被网上一篇文章误导了，前面说用UTF-8，后面native2ascii参数既然用gb2312!!!!!*&*&&&^&^(*#&#$&#^@)*#))

ApplicationResources_cn.properties文件也可以以gbk格式保存（eclipse中只有gbk没有gb2312)

然后native2ascii -encoding gbk ApplicationResources_cn.properties ApplicationResources.properties

不管用gbk,还是UTF-8都可以（因为这2种都支持中文显示)，并且最后得到的 ApplicationResources.properties文件内容都会一样:

errors.name=u7528u6237u540du9519u8bef

然而ApplicationResources.properties文件保存的编码格式有什么限制呢？目前，个人感觉随便什么都可以，因为这个文件中没有任何中文。

.jsp文件中charset设置为gb2312,UTF-8都可以。

.jsp文件保存的编码格式和charset一一对应.

综上所述：

因为UTF-8支持所有的国际字符，所以个人建议使用 UTF-8（包括charset等 ）既碰到关于字符编码的都使用UTF-8.这样会省去很多麻烦的。

作者 Budi Kurniawan

JavaServer Face为Java应用程序的开发提速。

JavaServer Faces(JSF)是一项使用Java技术来快速构建Web应用程序的新技术。JSF通过提供以下特性来加速开发进程：标准和可扩展的用户界面组件；极易配置的页面导航；用于输入验证的组件；自动化的Bean管理；事件处理；轻松的错误处理，以及内置的对国际化的支持。

本文介绍如何使用JSF来构建在线比萨（pizza）订购系统。

项目描述

该应用程序被称之为PizzaRia，是一个在线商店，允许用户选择比萨饼并递交选定的比萨饼。PizzaRia与其他在线商店类似，用户可以浏览菜单，向购物车中添加所选产品并进行结账。

该应用程序的用户界面由5个JSP文件组成，它们是index.jsp, details.jsp, shoppingCart.jsp, checkOut.jsp以及order.jsp 。每个用户界面的页面包括3个其它页面：header.jsp, menu.jsp和 footer.jsp 。

数据库

该程序的数据存储在3张表中：products（产品）、orders（定单）和OrderDetails（订单详细项目）。Products表存储产品信息，具有4列：ProductId（产品标识）, Name（名称）, Description（说明）和 Price（价格）。

Orders表中的每一行存储一个单独的订单，其中的信息包括联系人姓名、送货地址以及信用卡细目。Orders表有6列：OrderId（定单标识）, ContactName（联系人姓名）, DeliveryAddress（送货地址）, CCName（信用卡所属人姓名）, CCNumber（信用卡号码）和 CCExpiryDate（信用卡有效期限）。

每个订单的详细项目被存储在OrderDetails表中。OrderDetails表有4列：OrderId（定单标识）, ProductId（产品标识）, Quantity（数量）和 Price（价格）。Orders与OrderDetails表通过OrderID列有一对多的对应关系。请注意，OrderDetails表在用户下订单的时候就保存相关的价格信息。该价格可能与当前产品价格不同，后者存储在Products表的Price列中。

用于在一个Oracle数据库中创建所需的表的脚本文件pizzaria-oracle.sql存放在 pizzaria.zip 文件中。

业务对象

以下是在该应用程序中使用的业务对象：

ProductBean 用于封装一个产品信息。它具有如下属性：id（标识）、name（名称）、description（说明）和price（价格）。每次details.asp页被访问的时候，JSF实现（implementation）就会自动创建一个ProductBean实例。该JSF实现调用ProductBean的无参数构造器，从数据库中获取相关的数据，并且将其填入相应的字列中。

ProductSummary。 ProductSummary（产品概要）用于表示产品的概要。该类包含2个属性：id（标识）和name（名称）。

ShoppingItemBean。 ShoppingItemBean用于表示购物项目。该类包含4个属性：productId（产品标识）, productName（产品名称）, price（价格）以及 quantity（数量）。

ShoppingCartBean。 ShoppingCartBean用于表示一个存储在对话（session）对象中的购物车。该类允许用户添加购物项目（使用addShopping方法），获取包含所有购物项目的列表（使用getShoppingItems方法），获得所购货物的总价值（使用getTotal方法）。

OrderBean。 OrderBean表示一个订单。该类具有如下5个属性：contactName, deliveryAddress, creditCardName, creditCardNumber以及 creditCardExpiryDate。

MenuBean。 MenuBean使用getMenu方法显示可供产品的目录。该方法返回一个包含到产品细节的链接的HTML表。

DatabaseUtil。 DatabaseUtil提供了以下3种方法以便访问和操作数据：

• GetProductSummaries：该方法返回一个包含了产品表中所有产品概要的列表。一个产品概要通过ProductSummary类来表示。

   

   

• GetProductDetails：该方法返回一个ProductBean对象，该对象封装具有特定标识符的产品细节。

   

   

• InsertOrder：该方法向Orders表和OrderDetails表插入客户订单。

应用程序上下文监听器

应用程序上下文监听器（AppContextListener类）从web.xml文件读出用于访问数据库的初始参数，然后将其写入ServletContext对象。用到的初始参数如下：jdbcDriver, dbUrl, dbUserName和 dbPassword。在你的web.xml文件中编辑这些值，以便反应你数据库的真实值。

JSF应用程序配置

JSF允许编程人员仅仅通过应用程序配置文件就可以轻松配置应用程序。该文件如果存在的话，则它应该被命名为faces-config.xml，并且应该位于你应用程序下的WEB-INF 目录。

可以在faces-config.xmlz文件中对该应用程序的多个方面进行配置，包括bean管理、页面导航、定制UI（用户界面）组件、定制验证程序和消息资源。在 PizzaRia 应用程序中，我将该faces-config.xml用于bean管理和页面导航的配置。

JavaBean管理。 对于JavaBean管理，可以使用应用程序配置文件faces-config.xml中的managed-bean元件。每个managed-bean元件都会注册一个JavaBean--JSF会将该JavaBean在特定的作用域内实例化和进行储存。managed-bean元件定义如下：

<!ELEMENT managed-bean (description*, display-name*, icon*, managed-bean
name, managed-bean-class, managed-bean-scope, (managed-property* | map-entries |
list-entries))>

每个managed-bean元件都必须包含一个managed-bean-name元件，一个managed-bean-class元件，以及一个managed-bean-scope元件，并且可选择性地包含一些描述、显示名、图标和managed-property/map-entries/list-entries元件。

managed-bean-name指定了被用来在整个应用程序中引用该JavaBean的名称。managed-bean-class元件包含该JavaBean的完全限度的类名。managed-bean-scope元件定义该JavaBean的作用域。该元件可能的值是：application、session、request或者none。如果managed-bean-scope元件是none以外的其他值，那么，所创建的该JavaBean元件将会被存储在相应的对象中。比如说，如果值是"session"，那么，该JavaBean就会被存储在一个给定用户的session对象中。

在PizzaRia应用程序中，我注册了如 代码清单1 所示的4个JavaBeans。

页面导航： 页面导航决定了Web应用程序的控制流。本节演示如何在JSF中创立一个页面导航。

JSF使用navigation-rule元件来为页面导航定义规则。其定义如下：

<!ELEMENT navigation-rule 
  (description*, display-name*, icon*, from-view-id?, navigation-case*)>

from-view-id元件是首页（起始页）的标识符。为了说明被称之为index.jsp的JSP页面的导航规则，下面给出子元件from-view-id的值：

<from-view-id>/index.jsp</from-view-id>

navigation-case元件表示一个可能的目标页面。navigation-rule一个元件可以有零个或者数个navigation-case子元件。

每个navigation-case元件都指定from-view-id的特定处理结果的目标页面。结果可以来自from-view-id元件中 UICommand组件的行动（action）属性。

navigation-case元件由如下所示的代码描述：

<!ELEMENT navigation-case 
(description*, display-name*, icon*, from-action?, from-outcome?, 
to-view-id, redirect?)>

to-view-id元件指定目标页面。from-outcome值是处理from-view-id的结果。该值来自于在from-view-id中触发了ActionEvent的 UICommand组件的行动属性。

from-action元件也表示处理from-view-id的结果。但其值来自于引发了ActionEvent的UICommand组件的行动属性的运算值。

代码清单2 展示了在PizzaRia应用程序中使用的navigation-rule元件。

在JSP页面中使用UI组件

JSF提供两个定制标记库来帮助用户快速编写Web应用程序：HTML和Core。HTML定制标记库定义了用来表示UI组件的标记。Core定制标记库使用具有组件的验证器（validators）定义了注册事件处理器的核心行动，以及其他一些行动。你可以在自己的JSF应用程序的JSP页面中使用这两个库的标记。

为了在JSP页面中使用HTML和Core定制标记库，必须在页面中包含如下所示的taglib指令：

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

Prefix的属性值可以是任意值。但是，根据惯例，最好是使用"h"和"f"。

在JSF应用程序中编写JSP页面是每一个页面制作者的责任。除了布置组件之外，他们的责任还包括把组件绑定到模型对象数据并且把Core标记（诸如事件监听器和验证器）添加到组件标记中。

在HTML定制标记库中有25个标记。每个组件都呈现为一个HTML元件，而多个标记被呈现为同一个HTML元件。表1列出了HTML定制标记库中的标记。

使用验证器

验证器使得输入确认简单化并且可以节省开发人员的大量编程时间。JSF提供一套验证器类用于确认输入到输入组件中的值。另外一种方法就是，如果现有的标准验证器不符合需要，那么开发人员还可以编写自己的验证器。

验证器是一个实现类（implementation class），它可以验证输入值，如果是非法输入，就会发出一个错误信息。可以通过将一个验证器嵌入一个其输入需要验证的输入组件中来使用它。如果该验证器判断出用户的输入是非法的，那么JSF servlet就会重新显示刚才提交了表单的那个JSP页面，而不会将本地值复制给绑定到该输入组件上的JavaBean实例。

JSF实现为通用的验证任务提供了3个标准验证器，包括检查必填的域内已填入内容、输入的内容符合长度和范围要求。 表2 列举了标准的验证器。

另外，HTML定制标记库中的input_text和input_textarea标记有必填的属性。如果将该属性标赋值为真，那么用户在继续进行操作之前，就必须对文本输入框元件或者文本输入区域进行填写。

在PizzaRia应用程序中，checkOut.jsp页面使用该必填的属性以便保证没有一个域是空的。

事件处理

JSP应用程序是事件驱动型的程序。在JSF中处理事件令人惊奇的简单。以下是处理步骤：

1. 编写事件监听器。
2. 在程序目录下的WEB-INF/classes or WEB-INF/lib目录中部署事件监听器。
3. 在表示组件（其事件被捕获）的标记中，使用Core定制标记库中定义的action_listener或者 valuechange_listener标记。

在JSF中的事件对象。 JSF中的所有事件对象必须提供javax.faces .event.FacesEvent类，以便这些事件被请求处理生命周期支持。FacesEvent类是java.util.EventObject的子类，并添加了getComponent方法，该方法返回引发该事件的UIComponent组件。

FacesEvent类有两个子类：ActionEvent和 ValueChangeEvent。ActionEvent类激活诸如UICommand组件之类的UI组件。

ValueChangeEvent类会发出一个通知，告知本地UIInput组件的值被修改了。然而，如果新值没有被成功地验证为合法的，则不会发出ValueChangeEvent通知。被加入到该类中的两个重要方法是getOldValue 和 getNewValue。getOldValue方法返回引发该事件的组件的旧值。getNewValue方法返回相应的新值。这两种方法的返回值类型都是java .lang.Object。
第三，JSF中的事件监听器。

为捕获一个JSF事件， 需要使用一个事件监听器。JSF程序中的所有监听器都必须实现javax.faces.event.FacesListener接口。该接口提供java.util.EventListener接口，后者是必须由所有Java事件监听器实现的接口。

Faces Listener接口有两个子接口：ActionListener 和 ValueChangeListener。ActionListener接口是为了捕获ActionEvent而必须被实现的接口。该接口添加了一个新的方法--processAction--该方法请求处理生命周期来调用。当为之注册了ActionListener 的ActionEvent发生事件时，就会调用processAction。processAction方法的代码如下：

public void processAction(ActionEvent 
  event) 
 throws AbortProcessingException

ValueChangeListener接口是为了捕获ValueChangeEvent而实现的接口。该接口添加了一个方法：processValueChange。当ValueChangeEvent动作被其监听者监听到时，就会调用processValueChange方法。processValueChange方法的代码如下：

public void processValueChange(ValueChangeEvent
  event) 
throws AbortProcessingException

AppActionListener类使用两个非常有用的方法：getValueBinding 和getDatabaseUtil。getValueBinding接受指定对象名的字符串，并返回一个可以向下转换类型为对象类型的ValueBinding对象。比如说，为获得用户的在应用程序配置文件中被注册成shoppingCartBean 的ShoppingCartBean实例，开发人员需要通过传递"shoppingCartBean"来调用getValueBinding。

ShoppingCartBean cart = (ShoppingCartBean) 
getValueBinding("#{shoppingCartBean}").getValue(facesContext);

getValueBinding方法如下：

private ValueBinding getValueBinding(String valueRef) {
  ApplicationFactory factory =
  (ApplicationFactory)FactoryFinder
.getFactory(FactoryFinder
.APPLICATION_FACTORY);
  Application application = factory.getApplication();
return
  application.createValueBinding
(valueRef);
  }

getDatabaseUtil方法返回一个对ServletContext中的DatabaseUtil实例的引用：

private DatabaseUtil getDatabaseUtil() {
FacesContext facesContext = FacesContext.getCurrentInstance();
ServletContext servletContext = (ServletContext)
facesContext.getExternalContext()
.getContext();
return (DatabaseUtil) servletContext
.getAttribute("DATABASE_UTIL");
  }

运行该应用程序

该PizzaRia JSF应用程序用JSF参考实现（JavaServer Faces [JSF] Beta 1.0）已做过测试。请参看该应用程序的zip文件( pizzaria.zip )中的readme.txt文件，以便获得有关部署PizzaRia应用程序的更详细信息。

• 每个产品必须具有唯一的ID
• 每个产品必须属于至少一个category
  
• 产品ID一旦创立不得修改

• 英语讲是缺省语言，且不需事先国际化
• 在Catalog不讲不会超过500个产品
• catalog将不会被频繁的修改

• JDBC：这是最为灵活的方法，然而，低级的JDBC难以使用，而且质量差的JDBC代码很难运转良好
• Entity beans：CMP的Entity bean是一种分离数据访问代码和处理ORM的昂贵的方法，它是以应用服务器为中心的方法，即entity bean不是将应用与某种数据库类型而是EJB容器约束在一起。
• O/R mapping framework：一个ORM框架采用以对象为中心的方法实现数据持续化，一个以对象为中心的应用易于开发并具有高度的可移植性。在该领域中存在几个框架可用—JDO、Hibernate、TopLink以及CocoBase等。在我们的范例中将选用Hibernate。

• 类Swing的面向对象的Web应用开发：服务器端有状态的UI组件模型，配合event listeners和handlers，促进了面向对象的Web应用开发。
• backing-bean管理： backing bean是与页面中使用的UI组件相关联的javabean组件，backing-bean管理将UI组件对象的定义同执行应用相关处理和拥有数据的对象分离开来。JSF在合适的范围内保存和管理这些backing-bean实例。
• 可扩展的UI模型：JSF的UI模型是可配置的、可重用的，用以构建JSF应用的用户界面。你可以通过扩展标准的UI组件来开发出更为复杂的组件，例如菜单条、树组件等。
• 灵活的rendering模型：renderer分离了UI组件的功能和显示，多个renderers可创建和用来为同一客户端或不同的客户端定义不同的显示。
• 可扩展的转换和验证模型：基于标准的converter和validator，你可以开发出自己的可提供更好的模型保护的converter和validator。

• 利用一个backing bean：这一个方法非常简单，然而它却将backing bean与特殊的继承关系结合起来了
• 利用JSF的ViewHandler decorator：这一方法中，安全逻辑紧密地与一特定Web层技术联系在了一起
• 利用servlet filter：一个JSF应用与其他的Web应用没有什么两样，filter仍是处理认证检查的最好地方，这种方法中，认证逻辑与Web应用分离开来

• Bean management with application contexts：Spring可以有效地组织我们的中间层对象，它能够消除singleton的proliferation，并易于实现良好的面向对象编程方法，即“编程到接口”。
• Declarative Transaction management: Spring利用AOP实现事务管理，而无需借助于EJB容器，利用这种方法，事务管理可以用于任何POJO中。Spring的事务管理不局限于JTA，而是可以采用不同的事务策略，在范例应用中，我们将使用declarative transaction management with Hibernate transaction。
• Data-access exception hierarchy：Spring提供了非常好的异常来代替SQLException，为利用Spring的异常，必须在Spring的配置文件中定义以下异常转换：

• Hibernate integration：Spring与Hibernate这样的ORM框架整合的非常好，Spring提供了对Hibernate session的高效和安全的处理，它可通过application context配置Hibernate的SessionFactories和JDBC数据源，并使得应用易于测试。

• JSP page：createProduct.jsp是用来创建新产品的页面，它包含UI组件并将组件打包成ProductBean，ValidateItemsRange标签用来验证用户选择的种类数量，对每一个产品至少要有一个种类被选中。

• 页面导航：应用中的导航被定义在应用的配置文件faces-navigation.xml中，CreateProduct的导航准则如下：

   */FONT>
  
      createProduct/FONT>
      /createProduct.jsp/FONT>
   /FONT>
/FONT>

   /createProduct.jsp/FONT>
  
      success/FONT>
      /uploadImage.jsp/FONT>
   /FONT>
  
      retry/FONT>
      /createProduct.jsp/FONT>
   /FONT>
  
      cancel/FONT>
      /productList.jsp/FONT>
   /FONT>
/FONT>

• Backing bean：ProductBean不仅包含有将数据映射到页面上的UI组件的属性，还包括三个action：createAction、editAction和deleteAction，下面是createAction方法的代码：

public String createAction() {
   try {
      Product product = ProductBeanBuilder.createProduct(this);

      //Save the product.
      this.serviceLocator.getCatalogService().saveProduct(product);

      //Store the current product id inside the session bean.
      //For the use of image uploader.
      FacesUtils.getSessionBean().setCurrentProductId(this.id);

      //Remove the productList inside the cache.
      this.logger.debug("remove ProductListBean from cache");
      FacesUtils.resetManagedBean(BeanNames.PRODUCT_LIST_BEAN);
   } catch (DuplicateProductIdException de) {
      String msg = "Product id already exists";
      this.logger.info(msg);
      FacesUtils.addErrorMessage(msg);

      return NavigationResults.RETRY;
   } catch (Exception e) {
      String msg = "Could not save product";
      this.logger.error(msg, e);
      FacesUtils.addErrorMessage(msg + ": Internal Error");

      return NavigationResults.FAILURE;
   }
   String msg = "Product with id of " + this.id + " was created successfully.";
   this.logger.debug(msg);
   FacesUtils.addInfoMessage(msg);

   return NavigationResults.SUCCESS;
}

• Managed-bean声明：ProductBean必须在JSF配置文件faces-managed-bean.xml中配置：

  
      Backing bean that contains product information.
   /FONT>
   productBean/FONT>
   catalog.view.bean.ProductBean/FONT>
   requestnbsp;  
  
      id
      #{param.productId}/FONT>
   /FONT>
  
      serviceLocator
      #{serviceLocatorBean}/FONT>
   /FONT>
/FONT>

•  表示层和业务逻辑层之间的整合： ServiceLocator抽象了查找服务的逻辑，在范例应用中，ServiceLocator被定义为一个接口，该接口实现为一个JSF的 managed bean，即ServiceLocatorBean，它将在Spring的application context中寻找服务：

ServletContext context = FacesUtils.getServletContext();
this.appContext = WebApplicationContextUtils.getRequiredWebApplicationContext(context);
this.catalogService = (CatalogService)this.lookupService(CATALOG_SERVICE_BEAN_NAME);
this.userService = (UserService)this.lookupService(USER_SERVICE_BEAN_NAME);

• 业务对象：由于采用Hibernate提供持久化，因此Product和Category两个业务对象需要为它们的所有field提供getter和setter。

• 业务服务：CatalogService接口中定义了所有的与Catalog management相关的服务：

public interface CatalogService {
   public Product saveProduct(Product product) throws CatalogException;
   public void updateProduct(Product product) throws CatalogException;
   public void deleteProduct(Product product) throws CatalogException;
   public Product getProduct(String productId) throws CatalogException;
   public Category getCategory(String categoryId) throws CatalogException;
   public List getAllProducts() throws CatalogException;
   public List getAllCategories() throws CatalogException;
}

• Spring Configuration：这里是CatalogService的Spring配置：

  
/FONT>



  
/FONT>



  
  
  
     
         PROPAGATION_REQUIRED,readOnly/FONT>
       PROPAGATION_REQUIRED/FONT>
       PROPAGATION_REQUIRED/FONT>
       PROPAGATION_REQUIRED/FONT>
      /FONT>
  
/FONT>

• Spring和Hibernate的整合：下面是HibernateSessionFactory的配置：

<!-- Hibernate SessionFactory Definition -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate.LocalSessionFactoryBean">
   <property name="mappingResources">
      <list>
         <value>catalog/model/businessobject/Product.hbm.xml</value>
         <value>catalog/model/businessobject/Category.hbm.xml</value>
         <value>catalog/model/businessobject/User.hbm.xml</value>
      </list>
   </property>
   <property name="hibernateProperties">
      <props>
         <prop key="hibernate.dialect">net.sf.hibernate.dialect.MySQLDialect</prop>
       <prop key="hibernate.show_sql">true</prop>
       <prop key="hibernate.cglib.use_reflection_optimizer">true</prop>
       <prop key="hibernate.cache.provider_class">net.sf.hibernate.cache.HashtableCacheProvider</prop>
      </props>
   </property>
   <property name="dataSource">
      <ref bean="dataSource"/>
   </property>
</bean>

CatalogDao uses HibernateTemplate to integrate between Hibernate and Spring. Here's the configuration for HibernateTemplate:

<!-- Hibernate Template Defintion -->
<bean id="hibernateTemplate" class="org.springframework.orm.hibernate.HibernateTemplate">
   <property name="sessionFactory"><ref bean="sessionFactory"/></property>
   <property name="jdbcExceptionTranslator"><ref bean="jdbcExceptionTranslator"/></property>
</bean>

BR>

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
      "-//Hibernate/Hibernate Mapping DTD 2.0//EN"
      "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">
<hibernate-mapping package="catalog.model.businessobject">
   <class name="Product" table="product">
      <id name="id" column="ID" unsaved-value="null">
         <generator class="assigned"/>
      </id>
      <property name="name" column="NAME" unique="true" not-null="true"/>
      <property name="price" column="PRICE"/>    
      <property name="width" column="WIDTH"/>      
      <property name="height" column="height"/>      
      <property name="description" column="description"/>   
      <set name="categoryIds" table="product_category" cascade="all">
         <key column="PRODUCT_ID"/>
         <element column="CATEGORY_ID" type="string"/>
      </set>
   </class>
</hibernate-mapping>

CatalogDao is wired with HibernateTemplate by Spring:

<!-- Catalog DAO Definition: Hibernate implementation -->
<bean id="catalogDao" class="catalog.model.dao.hibernate.CatalogDaoHibernateImpl">
   <property name="hibernateTemplate"><ref bean="hibernateTemplate"/></property>
</bean>

 

package mysqlpro;

import java.util.Properties;

public class SqlHelper {
 private static final String maps = "db.properties";
 
 private static SqlHelper helper = new SqlHelper();
 
 private SqlHelper(){}
 
 public static SqlHelper CreateHelper(){
  if(helper==null)
    helper = new SqlHelper();
  return helper;
 }
 
 public String getValue(String key){
  
  String value="";
  Properties pro = new Properties();
  try{
   pro.load(getClass().getResourceAsStream(maps));/**getClass取得一个正在运行的类，getResourceAsStream读取文件为一个流**/
   if(pro.containsKey(key)){/**看是否有这个KEY值**/
    value = pro.getProperty(key);/**取对应KEY的值**/
   }
  }
  catch(Exception ex){
   ex.printStackTrace();
  }
  
  
  
  return value;
 }
}

package mysqlpro;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;

public class MainApps {
 private Connection con = null;
 private ResultSet res = null;
 public MainApps(){
  try{
  Class.forName(SqlHelper.CreateHelper().getValue("driver"));
  con = DriverManager.getConnection(
   SqlHelper.CreateHelper().getValue("url"),
   SqlHelper.CreateHelper().getValue("user"),
   SqlHelper.CreateHelper().getValue("password")
  );
  
   res = con.createStatement().executeQuery("select * from stu");
  
   while(res.next()){
    System.out.println(res.getString(1)+""+res.getString(2));
   }
  
  
  }
  catch(ClassNotFoundException ex){
   ex.printStackTrace();
  }
  catch(SQLException ex){
   ex.printStackTrace();
  }
  
  
  
 }
 
 public static void main(String[] args){
  new MainApps();
 }
}

 

1.  

   我们不只一次抱怨信息系统中数据项变化不定，无法设计和实现Java Beans。我们也不只一次作过这样的事情：数据项增加或减少了，我需要修改信息系统以求适应。我们对付这种变化莫定的需求还有一招：天天催企业领导或业务人员决定数据项，而不开始下面的设计和开发，还美名其为一个需求的"需求里程碑"没到，至少这个需求相关的设计和开发绝对不能开始。本文为这种情况提供了一种解决办法，并美名其为"以动制动"。

    

2.  

   Java Beans 作为一种组件技术，其结构体系主要由属性、方法和事件构成。象在其它面向对象技术中一样，在Beans 中,属性同样起决定其当前状态的作用。一个Bean的属性的访问和设置都必须通过访问方法和设置方法来进行。

   下面我们先举一个的示例，然后对Beans 组件技术中的属性支持进行解释。

   public class Author{ protected string name; protected boolean married; protected string[] books; public string[] getBooks(){} public void setBooks(integer[] x){} public void setName(string n){} public string getName(){} public boolean isMarried(){} public void setMarried(boolean bl){} ...... }

   这是一个非常简单的Bean，其中类的修饰符必须是public还有就是setXXX()/getXXX()方法必须遵循Beans内部的命名规则，因为Beans是根据这两个方法来确定属性的。其实，setXXX()/getXXX()方法是Beans的属性机制的核心技术。

   2.1 setXXX()/getXXX()方法

   一个Bean属性的定义完全取决于有无访问者方法：设置器（setXXX()）和获取器（getXXX()），而与在类定义中有无显示说明字段毫无关系，即上例中删去那些protected修饰的字段与Bean毫无影响，因为Beans内部是根据有无访问方法来确定属性的存在与否的。为了使Beans能确认一个属性，其设置器（setXXX()）和获取器（getXXX()）必须遵循下列命名规则：

    

   • 一个属性名在访问方法中必须以大写字母开头；
   • 在其它地方以小写字母开头。

    

   当然我们并不要求每个属性都必须同时拥有这两种访问者，因为我们并不排除某个属性只可读或可写。每种类型的属性的设计必须遵循的规则叫这种属性的设计模板，下面介绍各种类型属性的设计模板。

   2.1.1 简单属性

   一个属性为简单属性，当这个属性不与外界有连带关系时。简单属性中由于类型的复杂程度又有简单类型属性和数组属性之分。

    

   1. 简单类型属性的设计模板

      布尔型：

      设置器：public boolean is<属性名>(){}
      获取器：public void set<属性名> (boolean bl ){}
      

      其它类型的属性的设计模板如下：

      设置器：public void set<属性名>( <属性类型> x ){}
      获取器：public <属性类型> get<属性名>( ){}
      
   2. 数组属性的设计模板

      单个元素的设计模板

      设置器：public void set<属性名>( int i ,<属性元素类型> x ){}
      获取器：public <属性元素类型> get<属性名>( int i ){}
      

      整个数组的设计模板：

      设置器：public void set<属性名>( <属性元素类型> [] x){}
      获取器：public <属性元素类型>[] get<属性名>( ){}
      

      对于简单属性，不需要另外的附加类或接口。

    

   2.1.2 相关属性

   相关属性是这样的一种属性，它的改变能以事件的形式通知给对它感兴趣的部分，即事件收听者或目标。很明显，这种属性的作用在于它能使收听者接到其改变事件后根据其中的信息产生一些行为，从而达到两者之间的默契。相关属性的访问者方法遵循与简单属性相同的形式，就是说单从访问者方法是看不出其与简单属性的区别，但它要另外的附加类或接口以及事件的传播机制的支持（后面，我们会看到这同样适用于约束属性）。

   实现一个关联属性涉及到三方，源Bean，目标Bean和协调代码：

    

   • 源Bean

     源Bean必须提供属性变化事件监听器的注册和解册入口：

     public void addpropertyChangeListener (propertyChangeListener pcListener){} public void removepropertyChangeListener (propertyChangeListener pcListener){}

     如只想通知目标Bean某个特定属性的变化，可用下面特定属性的注册和解册方法：

     public void add<属性名>Listener (propertyChangeListener pcListener){} public void remove<属性名>Listener (propertyChangeListener pcListener){}

     这样，目标Bean只会接到源Bean此属性的变化的事件通知，减少了不必要的信息通信。另外，为了实现关联属性的方便，系统提供了一个帮助者类propertyChangeSupport，源Bean可实例化这个帮助者类，让它来为我们管理和维护收听者列表以及属性变化事件的通知的触发等工作。

   • 目标Bean

     目标Bean除了要实现propertyChangeListener接口外，还要用源Bean提供的注册方法注册自己。这样，目标Bean的实现大体框架如下：

     public class targetBean implements propertyChangeListener{ protected SourceBean source; …… source=new SourceBean(); source.addpropertyChangeListener(this); public void propertyChange(propertyChangeEvent e){ …… } }

   • 协调代码

     协调代码的工作职责分为以下几步：

      

     1. 负责创建源Bean和目标Bean；
     2. 利用源Bean的属性变化事件监听器的注册入口注册目标Bean；
     3. 改变源Bean的属性的属性
     4. 利用源Bean的属性变化事件监听器的解册入口解册目标Bean；

      

    

   2.1.3 约束属性

   约束属性是Beans所支持的最复杂最高级的属性，它允许收听者对属性的改变提出否定意见。

   与相关属性类似，其设计与实现也要涉及到源Bean、目标Bean和协调代码。只要把相关属性设计中的property改成Vetoable（除了propertyChangeEvent外）,不同的是为了能使目标Bean"反对"源Bean属性的变化。Beans提供了一种异常propertyVetoException,只要目标Bean收到属性改变的事件通知后，查看属性的新值，如果不满意，可抛出一个异常，让源Bean放弃改变属性到这个新值的念头，这就是约束属性中给目标Bean增加的"反对权利"。下面的简单源Bean和目标Bean的伪代码表述了约束属性的实现视图。

   • 源Bean

     public class SourceBean { public void addVetoChangeListener (VetoChangeListener vpListener){} public void removeVetoChangeListener (VetoChangeListener vpListener){}

     /*由于属性设置器本身不想处理异常，所以我们抛出异常，当然你也可以在属性设置器处理异常，属性变化监听者对属性的变化作出同意还是反对就是通过抛出异常的实现的。*/

     public void setName(String n) throws propertyVetoException{ /*从下面目标的代码可能抛出一个异常从而终止代码的执行 */ 实例化一个propertyChangeEvent对象 执行属性变化监听者的vetoChange方法 /*如果上面的代码抛出异常，下面这行代码不会被执行， 也就是说监听者阻止了属性的变化 */ name=n //修改属性的值 } }

   • 目标Bean

     public class TargetBean implements VetoChangeListener{ public void vetoChange(propertyChangeEvent e) throws propertyVetoException{ if e中的新值不满意　then 生成 并抛出一个propertyVetoException实例 else …… endif } }

   • 协调代码

     协调代码的工作职责分为以下几步：

     1. 负责创建源Bean和目标Bean；
     2. 利用源Bean的属性变化事件监听器的注册入口注册目标Bean；
     3. 改变源Bean的属性的属性，并捕获异常
     4. 利用源Bean的属性变化事件监听器的解册入口解册目标Bean；

   2.2 标准Java Bean属性总结

   

   图一 Java Bean属性综合图解

   如图一所示，Java语言为Java Bean组件的属性机制提供了良好的基础，这些语言元素包括Java的面向对象技术，接口技术和异常技术等。Java Bean属性命名规则和Java Bean属性设计模板是Java Bean组件的属性机制的规范。遵行这些规范，Java Bean组件的属性可以分为三种：最基本的为简单属性，这种属性只涉及属性所在的Java Bean组件本身；相关属性涉及到三方，包括源Bean、目标bean和协调代码，源Bean为属性的拥有者，目标bean为属性变化事件的监听者，协调代码负责组织双方，另外源Bean还可能实例化一个propertyChangeSupport对象来管理所有目标Bean，propertyChangeSupport对象的工作主要是保存所有目标Bean实例，并激发这些目标Bean的事件变化监听方法；约束属性在原理上和相关属性一样，只是增加了目标Bean对源Bean属性变化的"反对权利"。

   Java Bean组件技术是建立在Java基础上的组件技术，它继承了其的所有特点（如跨平台和面向对象），又引进了其它组件技术的思想，这两个方面恰好是其能成为后起之秀的主要原因。它所能支持的属性如相关属性和约束属性是其它组件技术所不能及的。

    

3.  

   无论是设计模式中值对象、视图助手，MVC框架中的模型（Model），还是Enterprise Bean中的会话Bean，实体Bean，都和javaBean属性息息相关。JavaBean组件属性的优点我们前面已经总结过，随着J2EE平台在企业应用中的广泛使用，JavaBean组件属性的缺陷也就显露了出来：无法满足企业应用动态变化的需要，原因在于javaBean属性是编译时的语言特性，它必须遵行一套命名规则和设计魔板。比如我按照某个企业的要求设计出了2000个实体Bean来满足该企业对信息系统中业务数据模型的需要，过了一定时间后，他们的业务发生了一定的变化，要对数据模型扩充一部分数据项，可想而知我会有多辛苦。扩展javaBean属性机制定义了五种属性访问策略，使得属性的访问代码像脚本一样在运行时决定，另外一个进步就是它支持List和Map属性的元素属性，也就是扩展javaBean属性机制它不把一个Bean的某个List和Map成员看成一个整体属性，而是动态地把这个List和Map成员的元素看成属性，这样无疑提供了一种无限扩展Bean属性的能力，为解决由于数据项变化带来的设计和实现的变更提供了技术基础。

   3.1 五种属性访问格式

   Common-beanutils 1.6中的propertyUtils实用类使用Java语言的内省反射功能实现扩展属性的设置器和获取器。propertyUtils定义了引用一个特定Java bean属性的五种格式：

   1. 简单属性，格式beanName.propName。propName标识了JavaBean beanName的一个属性,这个属性的获取器和设置器的方法是通过JavaBean的标准内省功能决定的。如果要改变简单属性的值，必须要有设置器操作，可以想象成类似调用beanName.[getpropName()|setpropName(value)]；
   2. 嵌套属性，格式beanName.propName1.propName2.propName3。像简单属性一样，第一个propName1元素被用来选择一个属性获取器方法，在这个方法返回的对象上使用propName2的获取器方法返回下一个对象，最后这个对象的属性propName3被访问或设置，可以想象成类似调用beanName.getpropName1().getpropName2().[getpropName3()|setpropName3(value)]；
   3. 索引属性，格式beanName.propName[index]。属性propName1可以是一个数组, java.util.List或者JavaBean beanName有索引属性获取器和设置器操作。bean只需propName的获取器方法，可以想象成类似调用beanName. [getpropName (index)|setpropName(index,value)]；
   4. 映射属性,格式beanName. propName(key)。propName是一个java.util.Map实现。bean只需propName的获取器方法，可以想象成类似调用beanName. getpropName ().[get("key")|set("key",value)；
   5. 组合属性，格式beanName. propName1.propName2[index].propName3(key)。

   3.2 代码解释

   为了更有效和直观的解释扩展属性的使用，在这里列出了两段代码，一段代码是Java Bean 代码，一段为propertyUtils以五中格式访问扩展属性的代码。

   3.2.1 扩展属性Java Bean

   下面是支持这些扩展属性的Java Bean代码：

   //TestBean.java import java.util.*; import java.io.*; public class TestBean { private String dupproperty[] = { "Dup 0", "Dup 1", "Dup 2", "Dup 3", "Dup 4" }; //propertyUtils只需要该索引属性的一个获取器操作就能 //使用get/setIndexedproperty方法访问和设置索引和元素值 public String[] getDupproperty() { System.out.println("getDupproperty"); return (this.dupproperty); } //下面的方法对propertyUtils的get/setIndexedproperty方法不关键,有则会调用这些方法 public String getDupproperty(int index) { System.out.println("getDupproperty index"); return (this.dupproperty[index]); } public void setDupproperty(int index, String value) { System.out.println("setDupproperty index value"); this.dupproperty[index] = value; } public void setDupproperty(String dupproperty[]) { System.out.println("setDupproperty du[]"); this.dupproperty = dupproperty; } //这是一个索引属性,除了支持"[]"型的数组属性外，还支持申明为List类型的属性 /** * A List property accessed as an indexed property. */ private static List listIndexed = new ArrayList(); static { listIndexed.add("String 0"); listIndexed.add("String 1"); listIndexed.add("String 2"); listIndexed.add("String 3"); listIndexed.add("String 4"); } public List getListIndexed() { return (listIndexed); } //嵌套属性 private TestBean nested = null; public TestBean getNested() { System.out.println("getNested"); if (nested == null) nested = new TestBean(); return (nested); } //这是一个映射属性,必须申明为Map类型，propertyUtils只需要该属性的一个获取器操作就能 //使用get/setMappedproperty方法访问和设置键和值 private Map hash = null; public Map getHash(){ System.out.println("getHash"); if (hash == null) { hash = new HashMap(); hash.put("First Key", "First Value"); hash.put("Second Key", "Second Value"); } return (hash); } //下面的方法对在common-beanutils 1.6.1中propertyUtils的getMappedproperty方法不起作用,中不调用这些方法， //而且不支持嵌套的映射属性 //propertyUtils.setMappedproperty(bean, "nested.hash(Fifth Key)", "Fifth Value"); don't work!! public Object getHash(String Key){ System.out.println("getHash Key"); return hash.get(Key); } public void setHash(String Key,Object value){ System.out.println("setHash Key value "); hash.put(Key,value); } //这是一个简单属性，想在propertyUtils中修改必须有设置器操作 private String sample = null; public String getSample() { return sample; } public void setSample(String sample){ this.sample = sample; } }

   3.2.2 使用propertyUtils实用类访问扩展属性

   下面propertyUtils以五中格式访问扩展属性的代码：

   //testpropertyUtils.java import org.apache..commons.beanutils.*; import junit.framework.TestCase; import junit.framework.Test; import junit.framework.TestSuite; public class testpropertyUtils extends TestCase { public propertyUtilsTestCase(String name) { super(name); } /** * 实例化TestBean */ public void setUp() { bean = new TestBean(); } /** * 测试索引属性 */ public void testSetIndexedValues() { Object value = null; //测试数组索引属性 try { propertyUtils.setproperty(bean, "dupproperty(0)", "New 0"); value = propertyUtils.getproperty(bean, "dupproperty(0) "); assertNotNull("Returned new value 0", value); assertTrue("Returned String new value 0", value instanceof String); assertEquals("Returned correct new value 0", "New 0", (String) value); } catch (Throwable t) { fail("Threw " + t); } //测试List索引属性 try { propertyUtils.setproperty(bean, "listIndexed(0) " , "New value"); value = propertyUtils.getproperty(bean, " listIndexed(0)"); assertNotNull("Returned new value 0", value); assertTrue("Returned String new value 0", value instanceof String); assertEquals("Returned correct new value 0", " New value ", (String) value); } catch (Throwable t) { fail("Threw " + t); } } /** * 测试映射属性 */ public void testSetMappedValues() { Object value = null; try { propertyUtils.setproperty(bean, "hash(key1)", "New 0"); value = propertyUtils.getproperty(bean, "hash(key1)"); assertNotNull("Returned new value 0", value); assertTrue("Returned String new value 0", value instanceof String); assertEquals("Returned correct new value 0", "New 0", (String) value); } catch (Throwable t) { fail("Threw " + t); } } /** * 测试嵌套属性 */ public void testNestedValues() { …. } }

    

4.  

   相对标准Java Bean的编译时静态决定一个Bean的属性，利用扩展javaBean属性机制，能在运行时决定属性的bean为动态bean。动态bean既有标准Java Bean的类型检查机制又有扩展javaBean属性机制的动态特点。下面我们从创建动态Bean和在配置文件中定义动态Bean的属性两方面介绍common-beanutils中动态bean机制。

   4.1 运行时创建动态bean

   动态bean具有动态属性，也就是说可以由程序运行时构造bean的属性，而不是像标准的javaBean在编译时决定一个bean的属性。

   定义和访问一个动态bean的步骤如下：

   1. 定义一个动态属性Dynaproperty数组，动态属性Dynaproperty定义了一个属性的名字和对象类型；
   2. 用定义好的动态属性数组实例化一个动态类；
   3. 由动态类返回一个动态bean；
   4. 可以用propertyUtils访问和设置动态bean的属性。

   下面是定义和访问动态bean的代码

   // TestDynaBean.java import org.apache.commons.beanutils.*; import java.util.*; public class TestDynaBean { public static void main(String[] args) { TestBean bean = new TestBean(); Object value = null; try{ Dynaproperty[] px = { new Dynaproperty("subordinate", bean.getClass()), new Dynaproperty("firstName", Class.forName("java.lang.String")), new Dynaproperty("lastName", Class.forName("java.lang.String")) }; DynaClass dynaClass = new BasicDynaClass("employee",null, px ); DynaBean employee = dynaClass.newInstance(); propertyUtils.setproperty(employee,"subordinate", bean); propertyUtils.setproperty(employee,"subordinate.listIndexed[0]","dy bean set"); propertyUtils.setproperty(employee,"firstName", "Fred"); propertyUtils.setproperty(employee,"lastName", "Flintstone"); System.out.println("subordinate.listIndexed[0]:"); System.out.println(propertyUtils.getproperty(employee,"subordinate.listIndexed[0]")); System.out.println("firstName:" + propertyUtils.getproperty(employee, "firstName")); System.out.println("lastName:" + propertyUtils.getproperty(employee, "lastName")); }catch (Exception e ){ System.out.println(e.toString()); } } }

   4.2 由文件配置动态bean的动态属性

   从配置文件配置动态bean的动态属性好处在于既能固定又能更改动态Bean的属性，这些属性是这个动态Bean对外界的宣布的"访问协议"。

   从上面的代码可以看出动态属性Dynaproperty的主要构造函数接受两个参数：第一个为属性名称，为字符串性，第二个为属性的类型，为Class类型。从配置文件读取的资料普通为字符串型，我们可以用ClassLoader把配置文件中字符串型的属性类型转化成Class类型的属性类型。

   下面struts 1.1 中struts-example.war的 formbeans.xml中的片断体现了如何在配置文件中定一个动态bean的动态属性：

   <form-bean name="logonForm" type="org.apache.struts.validator.DynaValidatorForm"> <form-property name="username" type="java.lang.String"/> <form-property name="password" type="java.lang.String"/> </form-bean>

   下面RequestUtils的代码片断体现了如何从字符串表示的属性类型转化成Class型的属性类型：

   public static Class applicationClass(String className) throws ClassNotFoundException { // Look up the class loader to be used ClassLoader classLoader = Thread.currentThread().getContextClassLoader(); if (classLoader == null) { classLoader = RequestUtils.class.getClassLoader(); } // Attempt to load the specified class return (classLoader.loadClass(className)); }

   这就是关于动态bean的所有奥秘，RequestUtils类代码片断public static ActionForm createActionForm就是这样创建动态bean的。

    

5.  

   我们说Java Bean所能支持的属性如相关属性和约束属性是其它组件技术所不能及的，这是非常先进的设计观念和模式。但是标准Java Bean属性是静态的，是在编译时决定的，不能满足变化不定的企业数据项的需求。扩展Java Bean属性机制提供了很好的思想，它不以Bean的List或Map成员看成一个整体属性，而把其中的动态元素看成属性，而且提供了脚本式的属性访问方法，从而为运行时动态管理（增，删和改）属性铺平了道路。动态属性继续发扬了扩展Java Bean属性机制的思路，考虑到增加程序的健壮性，保留了静态属性的类型检查机制，另外动态属性和属性配置文件结合可以提供良好的"静态和动态"平衡点，保证了动态Bean的动态属性不会漫无边际的扩张，这种动态性是有"章"可循的。

   

   图二 三种属性机制的关系图

   这三种属性机制的关系图表明了它们之间的这种依赖和发展关系；扩展Java Bean属性机制和动态属性机制都可以很好地解决数据项变化的需求。

Hibernate一共包括了23个jar包，令人眼花缭乱。本文将详细讲解Hibernate每个jar包的作用，便于你在应用中根据自己的需要进行取舍。

下载Hibernate，例如2.0.3稳定版本，解压缩，可以看到一个hibernate2.jar和lib目录下有22个jar包：

hibernate2.jar:

Hibernate的库，没有什么可说的，必须使用的jar包

cglib-asm.jar:

CGLIB库，Hibernate用它来实现PO字节码的动态生成，非常核心的库，必须使用的jar包

dom4j.jar:

dom4j是一个Java的XML API，类似于jdom，用来读写XML文件的。dom4j是一个非常非常优秀的Java XML API，具有性能优异、功能强大和极端易用使用的特点，同时它也是一个开放源代码的软件，可以在SourceForge上找到它。在IBM developerWorks上面可以找到一篇文章，对主流的Java XML API进行的性能、功能和易用性的评测，dom4j无论在那个方面都是非常出色的。我早在将近两年之前就开始使用dom4j，直到现在。如今你可以看到越来越多的Java软件都在使用dom4j来读写XML，特别值得一提的是连Sun的JAXM也在用dom4j。这是必须使用的jar包，Hibernate用它来读写配置文件。

odmg.jar:

ODMG是一个ORM的规范，Hibernate实现了ODMG规范，这是一个核心的库，必须使用的jar包。

commons-collections.jar：

Apache Commons包中的一个，包含了一些Apache开发的集合类，功能比java.util.*强大。必须使用的jar包。

commons-beanutils.jar：

Apache Commons包中的一个，包含了一些Bean工具类类。必须使用的jar包。

commons-lang.jar:

Apache Commons包中的一个，包含了一些数据类型工具类，是java.lang.*的扩展。必须使用的jar包。

commons-logging.jar:

Apache Commons包中的一个，包含了日志功能，必须使用的jar包。这个包本身包含了一个Simple Logger，但是功能很弱。在运行的时候它会先在CLASSPATH找log4j，如果有，就使用log4j，如果没有，就找JDK1.4带的java.util.logging，如果也找不到就用Simple Logger。commons-logging.jar的出现是一个历史的的遗留的遗憾，当初Apache极力游说Sun把log4j加入JDK1.4，然而JDK1.4项目小组已经接近发布JDK1.4产品的时间了，因此拒绝了Apache的要求，使用自己的java.util.logging，这个包的功能比log4j差的很远，性能也一般。后来Apache就开发出来了commons-logging.jar用来兼容两个logger。因此用commons-logging.jar写的log程序，底层的Logger是可以切换的，你可以选择log4j，java.util.logging或者它自带的Simple Logger。不过我仍然强烈建议使用log4j，因为log4j性能很高，log输出信息时间几乎等于System.out，而处理一条log平均只需要5us。你可以在Hibernate的src目录下找到Hibernate已经为你准备好了的log4j的配置文件，你只需要到Apache 网站去下载log4j就可以了。commons-logging.jar也是必须的jar包。

使用Hibernate必须的jar包就是以上的这几个，剩下的都是可选的。



ant.jar:

Ant编译工具的jar包，用来编译Hibernate源代码的。如果你不准备修改和编译Hibernate源代码，那么就没有什么用，可选的jar包

optional.jar：

Ant的一个辅助包。



c3p0.jar：

C3PO是一个数据库连接池，Hibernate可以配置为使用C3PO连接池。如果你准备用这个连接池，就需要这个jar包。

proxool.jar：

也是一个连接池，同上。

commons-pool.jar, commons-dbcp.jar:

DBCP数据库连接池，Apache的Jakarta组织开发的，Tomcat4的连接池也是DBCP。

实际上Hibernate自己也实现了一个非常非常简单的数据库连接池，加上上面3个，你实际上可以在Hibernate上选择4种不同的数据库连接池，选择哪一个看个人的偏好，不过DBCP可能更通用一些。另外强调一点，如果在EJB中使用Hibernate，一定要用App Server的连接池，不要用以上4种连接池，否则容器管理事务不起作用。


connector.jar:

JCA 规范，如果你在App Server上把Hibernate配置为Connector的话，就需要这个jar。不过实际上一般App Server肯定会带上这个包，所以实际上是多余的包。

jaas.jar:

JAAS是用来进行权限验证的，已经包含在JDK1.4里面了。所以实际上是多余的包。

jcs.jar：

如果你准备在Hibernate中使用JCS的话，那么必须包括它，否则就不用。

jdbc2_0-stdext.jar:

JDBC2.0的扩展包，一般来说数据库连接池会用上它。不过App Server都会带上，所以也是多余的。

jta.jar：

JTA规范，当Hibernate使用JTA的时候需要，不过App Server都会带上，所以也是多余的。

junit.jar:

Junit包，当你运行Hibernate自带的测试代码的时候需要，否则就不用。

xalan.jar, xerces.jar, xml-apis.jar:

Xerces是XML解析器，Xalan是格式化器，xml-apis实际上是JAXP。一般App Server都会带上，JDK1.4也包含了解析器，不过不是Xerces，是Crimson，效率比较差，不过Hibernate用XML只不过是读取配置文件，性能没什么紧要的，所以也是多余的。

Hibernate作为ORM，有一个ORM固有的问题，就是由于为了持久对象的同步，不能够使用批量删除和批量更新的sql，只能按照主键一条条来操作。因此效率相对JDBC来说是比较低的。然而事情也并不总是那么绝望，只要你对Hibernate进行优化，也可以得到相当满意的速度。

Hibernate 能支持数据库特有的函数，如 Oracle 的 connect by，Substr吗？能支持自己写的函数吗？答案是完全可以的！
最近有个项目在使用 Struts + Hibernate　开发，也碰到使用 Oracle connect by、自定义写的函数的困扰问题，后来查了很多相关的资料，
终于找到一个解决办法（不知是不是最好的？呵，希望你们指点一下）：

1、首先把 hibernate.properties 文件的下面这行代码前面的 '#' 符号去掉,加入相应的函数转换另命名，
如下面的sf_getchannelstaff=sf_getchannelstaff,substr=substr[说明：sf_getchannelstaff这个函数是自己写]
hibernate.query.substitutions true 1, false 0, yes 'Y', no 'N',sf_getchannelstaff=sf_getchannelstaff,substr=substr

2、使用 Hibernate 的 createSQLQuery() 函数，关于 createSQLQuery() 函数如何使用，请参考相关文档。下面我使用 createSQLQuery()
函数的一段代码：
                String[] ret = new String[] { "", "", "", "" };
  try {
   this.initSession();
   StringBuffer sql = new StringBuffer();
   sql.append("select {c}.CHANNEL_ID AS {c.channelId},");
   sql.append("{c}.NAME AS {c.name},");
   sql.append("substr(sf_getchannelstaff({c}.CHANNEL_ID,'A'),1,254) AS {c.channelTypeId},");
   sql.append("{c}.UPPER_CHANNEL_ID AS {c.upperChannelId},");
   sql.append("{c}.IS_PRE_DEFINE AS {c.isPreDefine},");
   sql.append("substr(sf_getchannelstaff({c}.CHANNEL_ID,'B'),1,254) AS {c.effDate},");
   sql.append("substr(sf_getchannelstaff({c}.CHANNEL_ID,'C'),1,254) AS {c.expDate},");
   sql.append("{c}.AREA_ID AS {c.areaId},");
   sql.append("{c}.IS_VIRTUAL AS {c.isVirtual}");
   sql.append(" from k_channel {c} where {c}.CHANNEL_ID=:channelId");
   Query query = this.session.createSQLQuery(sql.toString(), "c", ynt43.dao.KChannel.class);
   query.setLong("channelId", channelId);
   List result = query.list();
   if (!result.isEmpty()) {
    ynt43.dao.KChannel t = (ynt43.dao.KChannel) result.get(0);
    ret[0] = UtilBean.GBToUnicode(t.getName());
    ret[1] = UtilBean.GBToUnicode(t.getChannelTypeId());
    ret[2] = UtilBean.GBToUnicode(t.getEffDate());
    ret[3] = UtilBean.GBToUnicode(t.getExpDate());
   }
  }
  finally {
   this.closeSession();
  }
  return ret;
特别说明一下：使用 createSQLQuery() 函数后写 hql 语句时，from 子句后面是跟着数据库表名，而不是对象类名。

Hibernate 可以实现分页查询，例如：
从第2万条开始取出100条记录

JSF与Struts的异同

板桥里人 http://www.jdon.com 2005/09/05

　　Struts和JSF/Tapestry都属于表现层框架，这两种分属不同性质的框架，后者是一种事件驱动型的组件模型，而Struts只是单纯的MVC模式框架，老外总是急吼吼说事件驱动型就比MVC模式框架好，何以见得，我们下面进行详细分析比较一下到底是怎么回事？

　　首先事件是指从客户端页面（浏览器）由用户操作触发的事件，Struts使用Action来接受浏览器表单提交的事件，这里使用了Command模式，每个继承Action的子类都必须实现一个方法execute。

　　在struts中，实际是一个表单Form对应一个Action类(或DispatchAction)，换一句话说：在Struts中实际是一个表单只能对应一个事件，struts这种事件方式称为application event，application event和component event相比是一种粗粒度的事件。

　　struts重要的表单对象ActionForm是一种对象，它代表了一种应用，这个对象中至少包含几个字段，这些字段是Jsp页面表单中的input字段，因为一个表单对应一个事件，所以，当我们需要将事件粒度细化到表单中这些字段时，也就是说，一个字段对应一个事件时，单纯使用Struts就不太可能，当然通过结合JavaScript也是可以转弯实现的。

　　而这种情况使用JSF就可以方便实现，

　　#{login.userId}表示从名为login的JavaBean的getUserId获得的结果，这个功能使用struts也可以实现，name="login" property="userId"

　　关键是第二行，这里表示如果userId的值改变并且确定提交后，将触发调用类UserLoginChanged的processValueChanged(...)方法。

　　JSF可以为组件提供两种事件：Value Changed和 Action. 前者我们已经在上节见识过用处，后者就相当于struts中表单提交Action机制，它的JSF写法如下：

　　从代码可以看出，这两种事件是通过Listerner这样观察者模式贴在具体组件字段上的，而Struts此类事件是原始的一种表单提交Submit触发机制。如果说前者比较语言化（编程语言习惯做法类似Swing编程）；后者是属于WEB化，因为它是来自Html表单，如果你起步是从Perl/PHP开始，反而容易接受Struts这种风格。

基本配置

　　Struts和JSF都是一种框架，JSF必须需要两种包JSF核心包、JSTL包（标签库），此外，JSF还将使用到Apache项目的一些commons包，这些Apache包只要部署在你的服务器中既可。

　　JSF包下载地址：http://java.sun.com/j2ee/javaserverfaces/download.html选择其中Reference Implementation。

　　JSTL包下载在http://jakarta.apache.org/site/downloads/downloads_taglibs-standard.cgi

　　所以，从JSF的驱动包组成看，其开源基因也占据很大的比重，JSF是一个SUN伙伴们工业标准和开源之间的一个混血儿。

　　上述两个地址下载的jar合并在一起就是JSF所需要的全部驱动包了。与Struts的驱动包一样，这些驱动包必须位于Web项目的WEB-INF/lib，和Struts一样的是也必须在web.xml中有如下配置：

　　这里和Struts的web.xml配置何其相似，简直一模一样。

　　正如Struts的struts-config.xml一样，JSF也有类似的faces-config.xml配置文件：

　　在Struts-config.xml中有ActionForm Action以及Jsp之间的流程关系，在faces-config.xml中，也有这样的流程，我们具体解释一下Navigation：

　　在index.jsp中有一个事件：

　　action的值必须匹配form-outcome值，上述Navigation配置表示：如果在index.jsp中有一个login事件，那么事件触发后下一个页面将是welcome.jsp

　　JSF有一个独立的事件发生和页面导航的流程安排，这个思路比struts要非常清晰。

　　managed-bean类似Struts的ActionForm，正如可以在struts-config.xml中定义ActionForm的scope一样，这里也定义了managed-bean的scope为session。

　　但是如果你只以为JSF的managed-bean就这点功能就错了，JSF融入了新的Ioc模式/依赖性注射等技术。

Ioc模式

　　对于Userbean这样一个managed-bean，其代码如下：

public class UserBean {
　　private String name;
　　private String password;

　　// PROPERTY: name
　　public String getName() { return name; }
　　public void setName(String newValue) { name = newValue; }

　　// PROPERTY: password
　　public String getPassword() { return password; }
　　public void setPassword(String newValue) { password = newValue; }
}

　　faces-config.xml这段配置其实是将"me"赋值给name，将secret赋值给password，这是采取Ioc模式中的Setter注射方式。

Backing Beans

　　对于一个web form，我们可以使用一个bean包含其涉及的所有组件，这个bean就称为Backing Bean， Backing Bean的优点是：一个单个类可以封装相关一系列功能的数据和逻辑。

　　说白了，就是一个Javabean里包含其他Javabean，互相调用，属于Facade模式或Adapter模式。

　　对于一个Backing Beans来说，其中包含了几个managed-bean，managed-bean一定是有scope的，那么这其中的几个managed-beans如何配置它们的scope呢？

　　这里配置了一个Backing Beans中有一个setVisit方法，将这个visit赋值为session中的visit，这样以后在程序中我们只管访问visit对象，从中获取我们希望的数据（如用户登陆注册信息），而visit是保存在session还是application或request只需要配置既可。

UI界面

　　JSF和Struts一样，除了JavaBeans类之外，还有页面表现元素，都是是使用标签完成的，Struts也提供了struts-faces.tld标签库向JSF过渡。

　　使用Struts标签库编程复杂页面时，一个最大问题是会大量使用logic标签，这个logic如同if语句，一旦写起来，搞的JSP页面象俄罗斯方块一样，但是使用JSF标签就简洁优美：

　　如果authenticationBean中inboxAuthorized返回是假，那么这一行标签就不用显示，多干净利索！

　　先写到这里，我会继续对JSF深入比较下去，如果研究过Jdon框架的人，可能会发现，Jdon框架的jdonframework.xml中service配置和managed-bean一样都使用了依赖注射，看来对Javabean的依赖注射已经迅速地成为一种新技术象征，如果你还不了解Ioc模式，赶紧补课。

附Jsf核心教程一个JSF案例:login.rar