这儿是一段使用建造store数据库实例的方法，由于没有加new 构造实例，出现this.onMetaChange的错误
这个问题出现发生的代码如下：


这是用Struts2上传多个文件时候的一段代码，错误处理是遇到异常时return 一个ERROR，结果调用这个这个UploadAction报错 No result defined for action .....

应该修改成这样，捕获到异常时return ActionSupport.INPUT ，这样当页面第一次被载入时就不会报错了
 在java 企业应用领域，ejb的功能强大同ejb的配置复杂，难于学习一样出名。但在以前我们又有什么办法呢？只有硬着头皮来学ejb。真有点“明知山有虎，偏向虎山行”的精神。现在形式有了乐观的变化，java开源的持续走红，使得开发java企业级应用不再局限于ejb领域。这里我主要介绍一下怎样采用开源的 Spring,Hibernate以及Struts构建一个轻量级的架构。

一、整体架构介绍
    在软件工程领域，为了降低模块耦合度，提高模块的可重用性，分层一直是广为采纳的一个方法。其实分层还可以使开发人员专注于某一层进行开发，使得软件开发的分工变细，提高生产效率（这一点上堪比福特发明的流水线生产汽车的做法，各个工人负责特定部件的生产，最后组装）。
   
一个企业级的java应用，通常分为以下几层：UI层，业务逻辑层，数据持久层，域对象层。下面对这几层分别作简要介绍：
1．     UI层：负责与用户交互，包括：接受用户的请求，把处理结果返回给用户。这里我们采用struts来UI层，虽然比起Tapestry以及JSF这些事件驱动的表现层技术而言，Struts的设计显得有些老土，但它目前仍是表现层事实上的标准，所以我们还是选用它。
2．     业务逻辑层：主要负责具体的业务处理。通过Spring的IOC以及AOP实现各个功能的耦合相连
3．     数据持久层：主要负责与底层的数据库打交道。这里我们采用Spring封装的Hibernate操作来简化实际的编码。主要的操作为CRUD（create ,read,update,delete）
4．     域对象层：具体的实体类，如老师，学生等等这些具体的类（注意：需要与数据库中的某一标对应）。
以上只是简单介绍了各个层的划分以及各层所对应的开源框架，要详细了解各层的具层信息，需要访问 struts,hibernate,spring的官方网站。
二、实例分析
实例说明：一个网站登录的例子，比较简单，但能说明各层是如何协调工作的。
工具：jdk1.5,eclipse3.2,myeclipse5.0GA,mysql5.0,tomcat5.5，至于这几个工具到底该怎么装这里我就不多说了，大家不清楚的可以到网上搜搜。下面是具体操作步骤：
预备工作：用mysql创建一个test数据库，再创建一个user表，再创建两个字段username和password。脚本如下

DROP DATABASE IF EXISTS `test`;
CREATE DATABASE `test`
USE `test`;

CREATE TABLE `user` (
`id` int(11) NOT NULL auto_increment,
`username` varchar(30) NOT NULL default '',
`password` varchar(30) default '',
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=gb2312;
打开myeclipse的database explore透视图




右键单击左侧的空白区域 ，点击 new 按钮



单击“configure database driver”来配置数据库的驱动，你必须有mysql的jdbc驱动 ，没有的到mysql的官方网站上下载。



测试数据库配置是否成功。

1．     新建一个myeclipse的web工程




2．     引入Spring包
右键工程名







注意：这里为了省得以后再添加spring的相关包，所以一次性的选中了所有的包。选中
Copy选项，它会把这些包拷贝到/WebRoot/WEB-INF/lib目录下，方便以后的实际部署。

3．添加hibernate包



系统会检测到该工程已经添加了Spring包，选择使用Spring的配置文件



点击 next



点击 next



点击 next



最后点击Finish按钮即可。
4切换到database explore视图，右键 点击 user 表的“Hibrnate Reverse Engineering”



弹出如下窗口



点击 “next”



再单击finish
    在包视图中 可以看到 src下多了一个名为vo的package以及该包下的四个文件



为了更加直观地显示分层，我另建了一个名为dao的package,并把UserDAO.java移到dao中



同时注意在applicationContext.xml中把对UserDAO的引用部分也作相应修改。
5．     建立业务逻辑层代码
新建一个名为service的包，再在里面建立一个Service类，代码如下

package service;
import java.util.List;
import vo.User;
import dao.UserDAO;
public class Service {
private UserDAO userDao;
public UserDAO getUserDao() {
return userDao;
}
public void setUserDao(UserDAO userDao) {
this.userDao = userDao;
}
public boolean isValid(User user) {//判断用户是否合法
        List result = userDao.findByExample(user);
if (result.size() > 0)
return true;
else
return false;
}
}

同时在applicationContext.xml中添加如下配置
<bean id="service" class="service.Service" singleton="false">
        <property name="userDao">
              <ref bean="userDao" />
        </property>
    </bean>


6．配置UI层
  添加struts包，方法同添加spring一样



配置struts-config.xml文件，在空白区域右键单击 new 一个 action ,actionForm ,jsp










下一步
对forward作设置,增加succeed转到welcome.jsp,fail转到login.jsp

在WebRoot目录下建立一个welcome.jsp文件，显示用户登录成功后的欢迎信息。



6． 把struts和spring连接起来
6．1修改struts-config.xml注意红色字体部分

<action
attribute="loginForm"
input="/login.jsp"
name="loginForm"
path="/login"
scope="request"
type="org.springframework.web.struts.DelegatingActionProxy">
<forward name="fail" path="/login.jsp" />
<forward name="succeed" path="/welcome.jsp" />
</action>

    再在strut-config.xml中添加如下代码

<plug-in className="org.springframework.web.struts.ContextLoaderPlugIn">
<set-property property="contextConfigLocation" value="/WEB-INF/classes/applicationContext.xml" />
</plug-in>>
6.2修改applicationContext，增加以下内容
<bean name="/login" class="web.action.LoginAction"
singleton="false">
<property name="service">
<ref bean="service" />
</property>
</bean>

6.3修改LoginAction.java部分代码，增加一个service变量，以及其 get/set方法（主要用于Spring IOC）。代码如下：

/*
* Generated by MyEclipse Struts
* Template path: templates/java/JavaClass.vtl
*/
package web.action;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.struts.action.Action;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import web.form.LoginForm;
import service.Service;
import vo.User;
/**
* MyEclipse Struts Creation date: 09-27-2006
*
* XDoclet definition:
*
* @struts.action path="/login" name="loginForm" input="/login.jsp"
*           scope="request" validate="true"
* @struts.action-forward name="fail" path="/login.jsp"
* @struts.action-forward name="succeed" path="/welcome.jsp"
*/
public class LoginAction extends Action {
/*
* Generated Methods
*/
/**
* Method execute
*
* @param mapping
* @param form
* @param request
* @param response
* @return ActionForward
*/
private Service service;
public void setService(Service service) {
this.service = service;
}
public Service getService() {
return service;
}
public ActionForward execute(ActionMapping mapping, ActionForm form,
HttpServletRequest request, HttpServletResponse response) {
LoginForm loginForm = (LoginForm) form;// TODO Auto-generated method
                                                        // stub
        User user = new User();
user.setPassword(loginForm.getPassword());
user.setUsername(loginForm.getUserName());
if (service.isValid(user))
return mapping.findForward("succeed");
else
return mapping.findForward("fail");
}
}

  至此一个简单的登录已经做成。剩下的工作就是打包并发布你的应用了。 

  Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1549145

IDE工具：eclipse3.0(插件：hibernate synchronize2.3.1)
框架：hibernate2.1+spring1.2
jar包：cglib-full-2.0.2.jar、commons-collections-2.1.1.jar、commons-dbcp-

1.2.1.jar、commons-lang-1.0.1.jar、commons-logging-1.0.4.jar、commons-

pool-1.2.jar、dom4j-1.4.jar、ehcache-0.9.jar、hibernate2.jar、jta.jar、

odmg-3.0.jar、spring.jar、xalan-2.4.0.jar、xerces-2.4.0.jar、xml-apis.jar

、jconn2.jar（我用的sybase数据库，这个是sybase的驱动）
数据库建表sql（sybase数据库）：create table CUSTOMERS (ID int not null,

NAME nvarchar(15) not null, primary key (ID)) ;
create table ORDERS (
ID bigint not null,
ORDER_NUMBER varchar(15),
CUSTOMER_ID bigint,
primary key (ID)
);
alter table ORDERS add constraint FK_CUSTOMER foreign key ( CUSTOMER_ID)

references CUSTOMERS ;
（针对不同的数据有不同的sql语句，请自己修改）
用hibernate synchronize插件可以生成hiberante.cfg.xml、Customer.hbm(用这个

插件直接生成的是hbm文件，不是hbm.xml文件)、Order.hbm、Customer.java、

Order.java、以及DAO类（注意：生成的DAO类不适合用spring，所以这里就不提及了

）。
因为这里我们要使用spring，所以直接用spring的配置文件即可（把

hiberante.cfg.xml的内容集成到spring配置文件中）。
以下是所有文件的代码：
1.spring配置文件hibernate_context.xml：
[code:1]
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"

"http://www.springframework.org/dtd/spring-beans.dtd">

<beans>
<!-- <bean id="viewResolver"

class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property

name="viewClass"><value>org.springframework.web.servlet.view.JstlView</val

ue></property>
<property name="prefix"><value>/WEB-INF/jsp/</value></property>
<property name="suffix"><value>.jsp</value></property>
</bean> -->

<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">

<property name="driverClassName">
<value>com.sybase.jdbc2.jdbc.SybDriver</value>
</property>

<property name="url">
<value>jdbc:sybase:Tds:172.16.9.40:5000/quickstart</value>
</property>

<property name="username">
<value>sa</value>
</property>

<property name="password">
<value></value>
</property>
</bean>

<bean id="sessionFactory"

class="org.springframework.orm.hibernate.LocalSessionFactoryBean">

<property name="dataSource">
<ref local="dataSource" />
</property>

<property name="mappingResources">
<list>
<value>com/jacky/hibernate/domainmodel/Customer.hbm</value>
<value>com/jacky/hibernate/domainmodel/Order.hbm</value>
</list>
</property>

<property name="hibernateProperties">
<props>
<prop

key="hibernate.dialect">net.sf.hibernate.dialect.SybaseDialect</prop>
<prop key="hibernate.show_sql">true</prop>
</props>
</property>
</bean>

<bean id="transactionManager"

class="org.springframework.orm.hibernate.HibernateTransactionManager">
<property name="sessionFactory">
<ref local="sessionFactory" />
</property>
</bean>


<!-- Spring的数据访问异常转换器（Data Access Exception Translator）定义 -

->
<bean id="jdbcExceptionTranslator"

class="org.springframework.jdbc.support.SQLErrorCodeSQLExceptionTranslator

">
<property name="dataSource">
<ref bean="dataSource" />
</property>
</bean>

<!-- Hibernate Template定义 -->
<bean id="hibernateTemplate"

class="org.springframework.orm.hibernate.HibernateTemplate">
<property name="sessionFactory">
<ref bean="sessionFactory" />
</property>
<property name="jdbcExceptionTranslator">
<ref bean="jdbcExceptionTranslator" />
</property>
</bean>

<!--baseTransactionProxy -->
<bean abstract="true"

class="org.springframework.transaction.interceptor.TransactionProxyFactory

Bean" id="baseTransactionProxy">
<property name="transactionManager">
<ref bean="transactionManager" />
</property>
<property name="transactionAttributes">
<props>
<prop key="save*">PROPAGATION_REQUIRED</prop>
<prop key="update*">PROPAGATION_REQUIRED</prop>
<prop key="find*">PROPAGATION_REQUIRED</prop>
<prop key="*">PROPAGATION_REQUIRED,readOnly</prop>
</props>
</property>
</bean>


<bean id="customerDao"

class="com.jacky.hibernate.domainmodel.dao.CustomerHibernateDao">
<property name="sessionFactory">
<ref local="sessionFactory" />
</property>
</bean>

<bean id="customerManagerTarget"

class="com.jacky.hibernate.service.CustomerManagerImpl">
<property name="customerDao">
<ref local="customerDao" />
</property>
</bean>

<bean id="customerManager"

class="org.springframework.transaction.interceptor.TransactionProxyFactory

Bean">
<property name="transactionManager">
<ref bean="transactionManager" />
</property>

<property name="target">
<ref local="customerManagerTarget" />
</property>

<property name="proxyTargetClass">
<value>true</value>
</property>
<property name="transactionAttributes">
<props>
<prop key="save*">PROPAGATION_REQUIRED</prop>
<prop key="remove*">PROPAGATION_REQUIRED,readOnly</prop>
<prop key="*">PROPAGATION_REQUIRED,readOnly</prop>
</props>
</property>
</bean>

</beans>
[/code:1]

2.Customer.hbm:
[code:1]
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd" >

<hibernate-mapping package="com.jacky.hibernate.domainmodel">
<class name="Customer" table="CUSTOMERS" lazy="false">
<id column="ID"
name="Id"
type="integer"
>
<generator class="vm" />
</id>
<property
column="NAME"
length="15"
name="Name"
not-null="true"
type="string"
/>
<set inverse="true" name="ORDERSSet" lazy="false" batch-

size="4" outer-join="false">
<key column="CUSTOMER_ID" />
<one-to-many class="Order" />
</set>
</class>
</hibernate-mapping>
[/code:1]

3.Order.hbm:
[code:1]
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd" >

<hibernate-mapping package="com.jacky.hibernate.domainmodel">
<class name="Order" table="ORDERS" lazy="true">
<id
column="ID"
name="Id"
type="integer"
>
<generator class="vm" />
</id>
<property
column="ORDER_NUMBER"
length="15"
name="OrderNumber"
not-null="true"
type="string"
/>
<many-to-one
class="Customer"
name="Customer"
not-null="true"
outer-join="true"

>
<column name="CUSTOMER_ID" />
</many-to-one>
</class>
</hibernate-mapping>
[/code:1]

4.Customer.java:
[code:1]
package com.jacky.hibernate.domainmodel;

import com.jacky.hibernate.domainmodel.base.BaseCustomers;
//import java.util.Set;
//import java.util.HashSet;
/**
* This is the object class that relates to the CUSTOMERS table.
* Any customizations belong here.
*/
public class Customer extends BaseCustomers {

/*[CONSTRUCTOR MARKER BEGIN]*/
public Customer () {
super();
}

/**
* Constructor for primary key
*/
public Customer (java.lang.Integer _id) {
super(_id);
}

/**
* Constructor for required fields
*/
public Customer (
java.lang.Integer _id,
java.lang.String _name) {

super (
_id,
_name);
}

/*[CONSTRUCTOR MARKER END]*/

}
[/code:1]

5.BaseCustomer.java:
[code:1]
package com.jacky.hibernate.domainmodel.base;

import java.io.Serializable;


/**
* This class has been automatically generated by Hibernate Synchronizer.


* For more information or documentation, visit The Hibernate Synchronizer

page
* at http://www.binamics.com/hibernatesync or contact Joe Hudson at

joe@binamics.com.
*
* This is an object that contains data related to

the CUSTOMERS table.
* Do not modify this class because it will be overwritten if the

configuration file
* related to this class is modified.
*
* @hibernate.class
* table="CUSTOMERS"
*/
public abstract class BaseCustomer implements Serializable {

public static String PROP_NAME = "Name";
public static String PROP_ID = "Id";


private int hashCode = Integer.MIN_VALUE;

// primary key
private java.lang.Integer _id;

// fields
private java.lang.String _name;

// collections
private java.util.Set _oRDERSSet;


// constructors
public BaseCustomer () {
initialize();
}

/**
* Constructor for primary key
*/
public BaseCustomer (java.lang.Integer _id) {
this.setId(_id);
initialize();
}

/**
* Constructor for required fields
*/
public BaseCustomer (
java.lang.Integer _id,
java.lang.String _name) {

this.setId(_id);
this.setName(_name);
initialize();
}

protected void initialize () {}



/**
* Return the unique identifier of this class
* @hibernate.id
* generator-class="vm"
* column="ID"
*/
public java.lang.Integer getId () {
return _id;
}

/**
* Set the unique identifier of this class
* @param _id the new ID
*/
public void setId (java.lang.Integer _id) {
this._id = _id;
this.hashCode = Integer.MIN_VALUE;
}


/**
* Return the value associated with the column: NAME
*/
public java.lang.String getName () {
return _name;
}

/**
* Set the value related to the column: NAME
* @param _name the NAME value
*/
public void setName (java.lang.String _name) {
this._name = _name;
}


/**
* Return the value associated with the column: ORDERSSet


*/
public java.util.Set getORDERSSet () {
return this._oRDERSSet;
}

/**
* Set the value related to the column: ORDERSSet
* @param _oRDERSSet the ORDERSSet value
*/
public void setORDERSSet (java.util.Set _oRDERSSet) {
this._oRDERSSet = _oRDERSSet;
}

public void addToORDERSSet (Object obj) {
if (null == this._oRDERSSet) this._oRDERSSet = new

java.util.HashSet();
this._oRDERSSet.add(obj);
}



public boolean equals (Object obj) {
if (null == obj) return false;
if (!(obj instanceof

com.jacky.hibernate.domainmodel.base.BaseCustomer)) return false;
else {
com.jacky.hibernate.domainmodel.base.BaseCustomer

mObj = (com.jacky.hibernate.domainmodel.base.BaseCustomer) obj;
if (null == this.getId() || null == mObj.getId())

return false;
else return (this.getId().equals(mObj.getId()));
}
}


public int hashCode () {
if (Integer.MIN_VALUE == this.hashCode) {
if (null == this.getId()) return super.hashCode();
else {
String hashStr = this.getClass().getName()

+ ":" + this.getId().hashCode();
this.hashCode = hashStr.hashCode();
}
}
return this.hashCode;
}


public String toString () {
return super.toString();


}

}
[/code:1]

6.Order.java:
[code:1]
package com.jacky.hibernate.domainmodel;

import com.jacky.hibernate.domainmodel.base.BaseOrders;

/**
* This is the object class that relates to the ORDERS table.
* Any customizations belong here.
*/
public class Order extends BaseOrders {
private Customer customers;

/*[CONSTRUCTOR MARKER BEGIN]*/
public Order () {
super();
}

/**
* Constructor for primary key
*/
public Order (java.lang.Integer _id) {
super(_id);
}

/**
* Constructor for required fields
*/
public Order (
java.lang.Integer _id,
com.jacky.hibernate.domainmodel.Customer _customer,
java.lang.String _orderNumber) {

super (
_id,
_customer,
_orderNumber);
}

/*[CONSTRUCTOR MARKER END]*/

}
[/code:1]

7.BaseOrder.java:
[code:1]
package com.jacky.hibernate.domainmodel.base;

import java.io.Serializable;


/**
* This class has been automatically generated by Hibernate Synchronizer.


* For more information or documentation, visit The Hibernate Synchronizer

page
* at http://www.binamics.com/hibernatesync or contact Joe Hudson at

joe@binamics.com.
*
* This is an object that contains data related to

the ORDERS table.
* Do not modify this class because it will be overwritten if the

configuration file
* related to this class is modified.
*
* @hibernate.class
* table="ORDERS"
*/
public abstract class BaseOrder implements Serializable {

public static String PROP_ORDER_NUMBER = "OrderNumber";
public static String PROP_CUSTOMER = "Customer";
public static String PROP_ID = "Id";


private int hashCode = Integer.MIN_VALUE;

// primary key
private java.lang.Integer _id;

// fields
private java.lang.String _orderNumber;

// many to one
private com.jacky.hibernate.domainmodel.Customer _customer;


// constructors
public BaseOrder () {
initialize();
}

/**
* Constructor for primary key
*/
public BaseOrder (java.lang.Integer _id) {
this.setId(_id);
initialize();
}

/**
* Constructor for required fields
*/
public BaseOrder (
java.lang.Integer _id,
com.jacky.hibernate.domainmodel.Customer _customer,
java.lang.String _orderNumber) {

this.setId(_id);
this.setCustomer(_customer);
this.setOrderNumber(_orderNumber);
initialize();
}

protected void initialize () {}



/**
* Return the unique identifier of this class
* @hibernate.id
* generator-class="vm"
* column="ID"
*/
public java.lang.Integer getId () {
return _id;
}

/**
* Set the unique identifier of this class
* @param _id the new ID
*/
public void setId (java.lang.Integer _id) {
this._id = _id;
this.hashCode = Integer.MIN_VALUE;
}


/**
* Return the value associated with the column: ORDER_NUMBER
*/
public java.lang.String getOrderNumber () {
return _orderNumber;
}

/**
* Set the value related to the column: ORDER_NUMBER
* @param _orderNumber the ORDER_NUMBER value
*/
public void setOrderNumber (java.lang.String _orderNumber) {
this._orderNumber = _orderNumber;
}


/**
* @hibernate.property
* column=CUSTOMER_ID
* not-null=true
*/
public com.jacky.hibernate.domainmodel.Customer getCustomer () {
return this._customer;
}

/**
* Set the value related to the column: CUSTOMER_ID
* @param _customer the CUSTOMER_ID value
*/
public void setCustomer (com.jacky.hibernate.domainmodel.Customer

_customer) {
this._customer = _customer;
}


public boolean equals (Object obj) {
if (null == obj) return false;
if (!(obj instanceof

com.jacky.hibernate.domainmodel.base.BaseOrder)) return false;
else {
com.jacky.hibernate.domainmodel.base.BaseOrder

mObj = (com.jacky.hibernate.domainmodel.base.BaseOrder) obj;
if (null == this.getId() || null == mObj.getId())

return false;
else return (this.getId().equals(mObj.getId()));
}
}


public int hashCode () {
if (Integer.MIN_VALUE == this.hashCode) {
if (null == this.getId()) return super.hashCode();
else {
String hashStr = this.getClass().getName()

+ ":" + this.getId().hashCode();
this.hashCode = hashStr.hashCode();
}
}
return this.hashCode;
}


public String toString () {
return super.toString();


}

}
[/code:1]

8.IDAO.java:
[code:1]
/*
* 创建日期：2005-8-19
*
* 作者：<a href="mailto:jacky.jar@gmail.com">贾恺</a>
*/
package com.jacky.hibernate.domainmodel.dao;

/**
* @author 贾恺
*
* TODO 要更改此生成的类型注释的模板，请转至
* 窗口 － 首选项 － Java － 代码样式 － 代码模板
*/
public interface IDAO {

}
[/code:1]

9.ICustomerDao.java:
[code:1]
/*
* 创建日期：2005-8-19
*
* 作者：<a href="mailto:jacky.jar@gmail.com">贾恺</a>
*/
package com.jacky.hibernate.domainmodel.dao;

import java.util.List;

import com.jacky.hibernate.domainmodel.Customer;
/**
* @author 贾恺
*
* TODO 要更改此生成的类型注释的模板，请转至
* 窗口 － 首选项 － Java － 代码样式 － 代码模板
*/
public interface ICustomerDao extends IDAO {
public List getCustomer();
public Customer getCustomer(Integer id);
public List getCustomer(String name);
public void saveCustomer(Customer customer);
public void removeCustomer(String name);


}
[/code:1]

10.CustomerHibernateDao.java:
[code:1]
/*
* 创建日期：2005-8-19
*
* 作者：<a href="mailto:jacky.jar@gmail.com">贾恺</a>
*/
package com.jacky.hibernate.domainmodel.dao;

import java.util.List;

import org.springframework.orm.hibernate.support.HibernateDaoSupport;

import com.jacky.hibernate.domainmodel.Customer;

/**
* @author 贾恺
*
* TODO 要更改此生成的类型注释的模板，请转至
* 窗口 － 首选项 － Java － 代码样式 － 代码模板
*/

//import java.util.List;

import org.springframework.orm.ObjectRetrievalFailureException;
//import org.springframework.orm.hibernate.support.HibernateDaoSupport;

//import com.jacky.hibernate.domainmodel.Customer;
import com.jacky.hibernate.domainmodel.dao.ICustomerDao;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

public class CustomerHibernateDao extends HibernateDaoSupport implements
ICustomerDao {
private Log log = LogFactory.getLog(CustomerHibernateDao.class);

/* （非 Javadoc）
* @see

com.jacky.hibernate.domainmodel.dao.ICustomerDao#getCustomer()
*/
public List getCustomer() {
// TODO 自动生成方法存根
return getHibernateTemplate().find("from Customer");
}

/* （非 Javadoc）
* @see

com.jacky.hibernate.domainmodel.dao.ICustomerDao#getCustomer

(java.lang.String)
*/
public Customer getCustomer(Integer id) {
// TODO 自动生成方法存根
//log.info("***="+name);
Customer Customer = (Customer)getHibernateTemplate().load

(Customer.class,id);
System.out.println(Customer.getId());
if (Customer == null) {
throw new ObjectRetrievalFailureException(Customer.class,

id);
}
return Customer;
}

public List getCustomer(String name){
List list = getHibernateTemplate().find("from Customer

where NAME=?",name);
if (list == null) {
throw new ObjectRetrievalFailureException

(Customer.class, name);
}
return list;
}
/* （非 Javadoc）
* @see com.jacky.hibernate.domainmodel.dao.ICustomerDao#saveUser

(com.jacky.hibernate.domainmodel.Customer)
*/
public void saveCustomer(Customer Customer) {
// TODO 自动生成方法存根
log.info("saveCustomer(Customer Customer)");
getHibernateTemplate().saveOrUpdate(Customer);
if (log.isDebugEnabled()) {

log.debug("Customername set to " +

Customer.getName());

}
}

/* （非 Javadoc）
* @see

com.jacky.hibernate.domainmodel.dao.ICustomerDao#removeUser

(java.lang.String)
*/
public void removeCustomer(String name) {
// TODO 自动生成方法存根
Object Customer = getHibernateTemplate().load

(Customer.class, name);

getHibernateTemplate().delete(Customer);

if (log.isDebugEnabled()) {

log.debug("del Customer " + name);

}

}

}
[/code:1]

11.ICustomerManager.java:
[code:1]
/*
* 创建日期：2005-8-19
*
* 作者：<a href="mailto:jacky.jar@gmail.com">贾恺</a>
*/
package com.jacky.hibernate.service;

/**
* @author 贾恺
*
* TODO 要更改此生成的类型注释的模板，请转至
* 窗口 － 首选项 － Java － 代码样式 － 代码模板
*/

import java.util.List;

import com.jacky.hibernate.domainmodel.Customer;
import com.jacky.hibernate.domainmodel.dao.ICustomerDao;

public interface ICustomerManager {
public void setCustomerDAO(ICustomerDao dao);
public Customer getCustomer(Integer id);
public List getCustomer();
public List getCustomer(String name);
public Customer saveCustomer(Customer customer);
public void removeCustomer(String name);
}
[/code:1]

12.CustomerManagerImpl.java:
[code:1]
/*
* 创建日期：2005-8-19
*
* 作者：<a href="mailto:jacky.jar@gmail.com">贾恺</a>
*/
package com.jacky.hibernate.service;

import java.util.List;

import com.jacky.hibernate.domainmodel.Customer;
import com.jacky.hibernate.domainmodel.dao.ICustomerDao;
//import com.jacky.hibernate.domainmodel.dao.CustomersDAO;
/**
* @author 贾恺
*
* TODO 要更改此生成的类型注释的模板，请转至
* 窗口 － 首选项 － Java － 代码样式 － 代码模板
*/

//import java.util.List;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

public class CustomerManagerImpl implements ICustomerManager {
private static Log log = LogFactory.getLog

(CustomerManagerImpl.class);

public ICustomerDao customerDao;
/* （非 Javadoc）
* @see com.jacky.hibernate.service.ICustomersManager#setUserDAO

(com.jacky.hibernate.domainmodel.dao.ICustomersDao)
*/
public void setCustomerDAO(ICustomerDao dao) {
// TODO 自动生成方法存根
this.customerDao = dao;
}

public ICustomerDao getCustomersDao(){
return customerDao;
}

public void setCustomerDao(ICustomerDao customerDao){
this.customerDao = customerDao;
}
/* （非 Javadoc）
* @see

com.jacky.hibernate.service.ICustomersManager#getCustomers

(java.lang.String)
*/
public Customer getCustomer(Integer id) {
// TODO 自动生成方法存根
return customerDao.getCustomer(id);

}

/* （非 Javadoc）
* @see

com.jacky.hibernate.service.ICustomersManager#getCustomers()
*/
public List getCustomer() {
// TODO 自动生成方法存根
return customerDao.getCustomer();
}

public List getCustomer(String name){
return customerDao.getCustomer(name);
}
/* （非 Javadoc）
* @see com.jacky.hibernate.service.ICustomersManager#saveUser

(com.jacky.hibernate.domainmodel.Customers)
*/
public Customer saveCustomer(Customer customer) {
// TODO 自动生成方法存根
customerDao.saveCustomer(customer);
return customer;
}

/* （非 Javadoc）
* @see com.jacky.hibernate.service.ICustomersManager#removeUser

(java.lang.String)
*/
public void removeCustomer(String name) {
// TODO 自动生成方法存根
customerDao.removeCustomer(name);
}

}
[/code:1]

13.CustomersManagerImplTest.java:
[code:1]
/*
* 创建日期：2005-8-19
*
* 作者：<a href="mailto:jacky.jar@gmail.com">贾恺</a>
*/
package com.jacky.test;

/**
* @author 贾恺
*
* TODO 要更改此生成的类型注释的模板，请转至
* 窗口 － 首选项 － Java － 代码样式 － 代码模板
*/
import java.util.Iterator;
import java.util.Set;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.jacky.hibernate.domainmodel.Customer;
import com.jacky.hibernate.domainmodel.Order;
//import com.jacky.hibernate.service.CustomersManagerImpl;
import com.jacky.hibernate.service.ICustomerManager;

public class CustomersManagerImplTest {
private static final Log log = LogFactory.getLog

(CustomersManagerImplTest.class);
private ApplicationContext ac;
private static ICustomerManager cm;
public CustomersManagerImplTest(){
ac = new ClassPathXmlApplicationContext

("hibernate_context.xml");
cm = (ICustomerManager)ac.getBean

("customerManagerTarget");
log.info("welcome!");
}
public static void main(String[] args){
new CustomersManagerImplTest();
test(cm);
}

private static void test(ICustomerManager cm){
//getCustomer(cm);
getCustomer(new Integer(1));
//getCustomer("Tom");
}
private static void getCustomer(ICustomerManager cm){
Iterator it = cm.getCustomer().iterator();
while(it.hasNext()){
log.info("name="+((Customer)it.next()).getName());
}
}
private static void getCustomer(Integer id){
Customer customer = cm.getCustomer(id);
Set set = customer.getORDERSSet();
log.info("name="+customer.getName());
Iterator it = set.iterator();
while(it.hasNext()){
log.info(customer.getName()+":"+((Order)it.next

()).getOrderNumber());
}

}
private static void getCustomer(String name){
Iterator it = cm.getCustomer(name).iterator();
while(it.hasNext())log.info("id="+((Customer)it.next

()).getId());
}
}
[/code:1]

14.build.xml:
[code:1]
<?xml version="1.0"?>
<project name="Learning Hibernate" default="prepare" basedir=".">

<!-- Set up properties containing important project directories -->
<property name="source.root" value="src"/>
<property name="class.root" value="WEB-INF/classes"/>
<property name="lib.dir" value="WEB-INF/lib"/>

<!-- Set up the class path for compilation and execution -->
<path id="project.class.path">
<!-- Include our own classes, of course -->
<pathelement location="${class.root}" />
<!-- Include jars in the project library directory -->
<fileset dir="${lib.dir}">
<include name="*.jar"/>
</fileset>
</path>


<!-- Create our runtime subdirectories and copy resources into them -->
<target name="prepare" description="Sets up build structures">
<delete dir="${class.root}"/>
<mkdir dir="${class.root}"/>


<!-- Copy our property files and O/R mappings for use at runtime -->
<copy todir="${class.root}" >
<fileset dir="${source.root}" >
<include name="**/*.properties"/>
<include name="**/*.hbm.xml"/>
<include name="**/*.xml"/>
<include name="**/*.gif"/>
<include name="**/*.hbm"/>
</fileset>
</copy>

<delete dir="${lib.dir}"/>
<mkdir dir="${lib.dir}"/>
<!-- Copy our property files and O/R mappings for use at runtime

-->
<copy todir="${basedir}/WEB-INF" >
<fileset dir="${basedir}" >
<include name="lib/*.jar"/>
<include name="lib/*.tdt"/>
<include name="lib/*.xml"/>

</fileset>
</copy>
</target>

<!-- Compile the java source of the project -->
<target name="compile" depends="prepare"
description="Compiles all Java classes">
<javac srcdir="${source.root}"
destdir="${class.root}"
debug="on"
optimize="off"
deprecation="on">
<classpath refid="project.class.path"/>
</javac>
</target>

<target name="run" description="Run a Hibernate+spring sample"
depends="compile">
<java classname="com.jacky.test.CustomersManagerImplTest" fork="true">
<arg value="NativeTester" />
<classpath refid="project.class.path"/>
</java>
</target>

</project>
[/code:1] （1）下载Hibernate，并向项目中导入Hibernate。
     Project->Properies->Java Build Path->Libraries->Add External JARs...，选择Hibernate根目录下的hibernate3.jar，添加到项目中。
    接着，要将Hibernate下的lib文件夹下的所有文件都作为一个User Library添加到项目中，否则，如果仅仅添加hibernate3.jar，编译可以通过，运行却会抛出ClassNotDef的异常，因为hibernate3.jar依赖于Hibernate下的lib文件夹下的文件。

 2）我们的应用的后台数据库使用的是Oracle，所以首先要在例子项目中引入含有Oracle jdbc driver的包，classes12.jar。该jar文件位于oracle安装目录的jdbc\lib目录下。
    在Eclipse中，Project->Properies->Java Build Path->Libraries->Add External JARs...，选择classes12.jar，将其添加到项目中。
    
（3）生成hibernate.cfg.xml文件。
    通常Hibernate的配置文件和.hbm.xml文件都可以自动生成，这种自动生成的工具很多，我使用的是HibernateSynchronizer，它可以作为一个插件添加到Eclipse中。当HibernateSynchronizer插件正确加载后，我们可以向当前项目中添加Hibernate配置文件：File->New->Other->Hibernate->Hibernate Configuration File，出现如下界面：


  注意，Driver Class要选择针对Oracle的oracle.jdbc.driver.OracleDriver，而且Database URL的格式也要正确，如：

    最好将hibernate.cfg.xml文件存放于项目的根目录下。

 4）生成.hbm.xml文件。File->New->Other->Hibernate->Hibernate Mapping File，出现如下界面：

     
    在填写完Password后，点击Refresh按钮，就会在Tables中列出所有可以访问的数据库表，然后选中要为其生成.hbm.xml文件的表，点击Finish，即会生成对应的.hbm.xml文件，比如我上面选择的是Mobileuser表，就会生成Mobileuser.hbm.xml文件。

（5）从.hbm.xml文件自动生成实体类。
    在Package Explorer中选中Mobileuser.hbm.xml文件，右键->Hibernate Synchronizer->Synchronize Files ，即可生成对应的实体类和DAO类。如果你仅仅想要实体类，那么可以在Project->Properies->Hibernate Synchronizer->Data Access Objects ，将“I would like to have DAOs created for me”的钩选项去掉即可。

（6）在hibernate.cfg.xml文件中添加对应的mapping resource。
    在Package Explorer中选中Mobileuser.hbm.xml文件，右键->Hibernate Synchronizer->Add Mapping Reference，即会在
hibernate.cfg.xml中自动生成如下配置：

（7）修改自动生成的hibernate.cfg.xml文件。需要在hibernate.cfg.xml文件的首部添加：

    比较繁琐的是，每次自动修改hibernate.cfg.xml文件后，都要重新添加这个xml片断。

    万事具备，现在可以写个测试来检验一下了：

介绍如何利用Hibernate Synchronizer插件在Eclipse 3.0.1中快速的开发Hibernate应用程序，提高我们的工作效率。

　　Eclipse是目前非常流行的开发平台，开放扩展的架构让很多程序员找到了自己个性化的工作环境，Hibernate也是目前很流行的O/R Mapping框架，至少在EJB 3.0大行其道之前，它是我们在考虑O/R Mapping时非常好的选择。

　　关于Hibernate框架的细节，请参考《Hibernate in Action》一书。

　　首先需要安装这个插件，Eclipse 3.0.1为我们提供了更加方便的插件管理方式，选择菜单“帮助—软件更新—查找并安装”，选择“搜索要安装的新功能部件”，操作界面如下：

　　选择 New Remote Site ，填写名称 Hibernate PlugIn ，下面的URL中填入：http://www.binamics.com/hibernatesync

如下图：

　　然后在“安装”界面中选中我们刚添加的 Hibernate PlugIn ，打开它，选中下一级的Synchronizer，然后Next，以下的安装根据提示进行Next即可了。
　　Eclipse就可以自己下载完成安装，然后Eclipse自动重启动一次就完成了。

Spring PlugIn的地址为：
http://springframework.sourceforge.net/spring-ide/eclipse/updatesite/
安装配置类似于Hibernate PlugIn的安装。

Spring的地址为：
http://www.springframework.org/

　　下面演示一个最简单的单表操作，让我们熟悉开发过程。我们选择MySQL数据库来做这个应用，首先在MySQL里建立一个新的数据库为HibernateTest，再建立一个数据表，名为Person，包含ID, Name, Sex, Address四个字段，建表语句如下：

# Host: localhost
# Database: hibernatetest
# Table: 'person'
#
CREATE TABLE `person` (
`ID` int(11) NOT NULL auto_increment,
`Name` varchar(20) NOT NULL default '',
`Sex` char(1) default NULL,
`Address` varchar(200) default NULL,
PRIMARY KEY  (`ID`)
) TYPE=MyISAM;

　　然后新建一个普通的Java项目：“File -> Project -> New Project ->Java Project

　　输入项目名称：HibernateMySQL

　　注意加入Hibernate的所有lib文件，包括有Hibernate下面的hibernate2.jar和lib目录下面的所有.jar文件；
还有要加入MySQL的jdbc驱动文件，比如mysql-connector-java-3.0.14-production-bin.jar
驱动程序自己选择加载，版本不同，文件名也不同：）

　　下面我们需要在项目中加入一个Hibernate的配置文件，在src目录下选择 New -> Other -> Hibernate -> Hibernate Configuration File，如下图：

　　在弹出的界面中，你需要指定要使用的数据库，以及连接数据库所需要的信息，我们对应的选择了数据库为MySQL，并配置了数据库的URL和管理员帐号与密码，如下：

Database Type: QL
Driver Class:  org.git.mm.mysql.Driver
Database URL: jdbc:mysql://localhost:3306/HibernateTest
Username: root
Password:

　　点击Browse按钮，在弹出的框中输入Driver，在下面就会出现相应的驱动所在的包
我们选中org.git.mm.mysql.Driver所在的包的文件，确定即可。

　　在上图中，我们还可以指定从JNDI数据源中获得连接，可以点击 Datasource 标签进行配置。

　　点击 Finish 按钮之后系统会自己生成一个名为 hibernate.cfg.xml 的文件，里面包含了基本的配置信息，如果需要高级配置，可以手动配置，也可以通过其它插件来进行编辑，比如MyEclipse的XML Editor

　　下面要生成映射文件，首先新建一个包 New -> Package，输入net.echochina.hibernatetest

　　在这个包下选择 New -> Other -> Hibernate -> Hibernate Mapping File ，在弹出的界面中点击 Refresh 按钮，将会列出库中所有的数据表，选中我们要使用的 Person 表，点击 Browse 按钮，选择我们所要生成的POJO文件所在的包：net.echochina.hibernatetest

如下图：

　　在上述界面的 Properties 标签中可以配置hbm的其他选项，包括文件扩展名，聚合列名，ID生成规则等。完成后，系统会自动生成一个名为 Person.hbm 的文件，我们可以通过这个文件生成相关的存根类。

　　在Person.hbm文件上单击右键，选择 Hibernate Synchronizer -> Synchronize Files

　　该操作将生成三个包八个类文件，里面封装了Hibernate的操作细节，让我们可以专心面对业务逻辑的开发，仔细阅读这些文件可以提高你对Hibernate的认识，增长应用技巧。

　　然后我们需要在Hibernate的配置文件中添加对Person 的相关信息，在Person.hbm上单击右键，选择Synchronizer -> Add Mapping Reference

　　现在我们可以开始编写自己的程序逻辑了，代码可以写在
net.echochina.hibernatetest.dao.PersonDAO类中，这个类的代码不会被插件进行修改的。

　　首先在数据库里增加一条新的记录
　　在PersonDAO类中增加一个引入import net.echochina.hibernatetest.Person;
　　然后加入一个main方法，内容如下：

public static void main(String args[])
{
try
{
_RootDAO.initialize();
PersonDAO persondao = new PersonDAO();
Person person = new Person();
person.setName("YuLimin");
person.setSex("M");
person.setAddress("http://Java.EchoChina.net");
persondao.save(person);
}
catch(Exception e)
{
e.printStackTrace();
}
}

　　//测试MySQL的中文问题：更改内容如下，把setName的参数改为中文的内容：

person.setName("俞黎敏");

　　这里应当到hibernate.cfg.xml文件的<session-factory/>块中增加上如下两行设置

<property name="connection.useUnicode">true</property>
<property name="connection.characterEncoding">GBK</property>

　　这样插入数据与读取数据时才不会有中文的问题，如果仍有中文问题请Google吧：）

　　可以看出，插件已经把session操作和事务操作都封装起来了，我们的代码工作得到了极大的简化。而且我们可以利用插件自带的Hibernate Editor来编辑hbm文件，非常方便。
　　我们还需要把ID的生成方式改为 identity，右键Person.hbm，Open With -> Hibernate Editor

　

　　把ID的生成方式改为 identity

　　要让这个程序正常运行，还需要对配置文件hibernate.cfg.xml作一些修改。
　　使用Eclipse的 文本编辑器 打开该文件，其中有如下的内容：

<!--
<property name="hibernate.transaction.factory_class">
net.sf.hibernate.transaction.JTATransactionFactory
</property>
<property name="jta.UserTransaction">
java:comp/UserTransaction
</property>
-->

　　由于在我们的例子中，并没有使用JTA来控制事务，所以需要将上面的内容注释掉，程序才能正常运行。

　　现在可以开始运行了，点击Run

　　在出现的配置中选择Java Application，Name中输入PersonDAO

　　单击Search 按钮，在弹出地框中选择net.echochina.hibernatetest包中的PersonDAO类

　　OK之后，点击Run开始运行，如果以上各步操作正确的话，可以看到数据已经被保存到数据库。

　　如果在实际开发工作中，需要重新设计数据表结构，那么只需要在.hbm文件中做相应的修改，然后执行 Synchronize and Overwrite 的操作，插件会重新生成存根文件，我们只需要修改程序逻辑就可以了，非常方便。有了这样的功能插件，我们可以极大的从配置文件的编写、查错中解脱出来，从而提高我们的工作效率。

Hibernate 常用工具

Hibernate Synchronizer 很好的辅助开发工具，是一个Eclipse 的插件，可以生成80%的代码，首选。
MyEclipse 安装的 3.8.3 感觉非常的强大，主要是因为他是付费的，做得比较全面，喜欢他们的struts 组件，开发 Struts 必不可少。
Hibernator Hibernate查询的辅助工具，可以使用 HSQL进行查询，测试HSQL的好工具，是个Eclipse插件。
Hibern8IDE（现更名为：HibernateConsole） 一个单独运行的Hibernate工具，可以运行 Hibernate Query Language (HQL)语句。
MiddleGen 生成持久对象的工具，可以生成

Persistence layer with EJB (CMP 2.0)
Persistence layer with JDO
Persistence layer with Hibernate
Persistence layer with Torque
Database GUI with JSP/Struts

http://spindle.sourceforge.net 开发Tapestry的必备

http://springui.sourceforge.net 写Spring Application Context File的辅助好工具

下载并安装Hibernate Synchronizer插件

Hibernate Synchronizer是一个Eclipse插件，可以自动生成*.hbm文件、持久化类和DAO，大大降低开发Hibernate应用的难度。本节介绍如何下载和安装Hibernate Synchronizer插件。

JBoss Eclipse IDE插件中包括Hibernate Tools，按照6.1节介绍的步骤安装JBoss Eclipse IDE插件后就可以完成Hibernate Synchronizer插件的安装，打开如图8-1所示的“关于Eclipse SDK”窗口，其中包含了四个Hibernate插件，说明插件安装成功了。

图8-1关于Eclipse SDK插件窗口

TortoiseSVN是开源界非常流行的一款源代码控制和管理软件，在开源项目里，几乎都用到了SVN。但是安装了SVN后会有一个TSVNCache.exe的进程驻留内存，这个进程会定时地去扫描Subversion管理的文件夹/文件是否被修改了，一旦发现有更新，那本地的这些有更新的文件/文件夹就会被更新，这个动作不仅会占用10-50MB左右的内存，而且也会在执行的瞬间占用超过CPU 50%的负载。对于Minidxer这样使用N年前买的电脑来说，这个进程还是影响到了PC的使用性能，那么应该如何停掉它呢？打开系统的文件夹管理–>右键–>TortoiseSVN–>settings–>look and feel–>Icon Overlays–>Status cache 设为”none”就可以了。

我用的myeclipse 6.0版本，oracle是10g版本，在连接的时候出现了以下问题

 java.sql.SQLException: ORA-00604: error occurred at recursive SQL level 1
ORA-12705: Cannot access NLS data files or invalid environment specified

一开始以为是驱动程序的问题，其实不是，只需在eclipse目录下找到eclipse.ini文件，把

Duser.language=en  改成 Duser.language=zh就行了。

有可能大家出现的问题不一样，按我的方法有可能不好使，我写出来仅供大家参考，因为当时为解决这问题，花了不少时间，希望大家少走弯路。

在 C:\WINDOWS\system32\drivers\etc 目录下hosts文件设置