這兒是一段使用建造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文件設置