Struts-Spring-Hibernate集成
6．6．1環境搭建和基本配置
我們在Eclipse中可以增加對Struts2.0, Spring2.0, Hibernate3.1的支持，具體如下：
1. 搭建簡單的Struts2 Web工程
1) 下載和安裝Struts2框架
在此下載最新的struts-2.0.11-all完整包，裏面包括apps（示例）、docs（文檔）、j4（struts2支持jdk1.4的jar文件）、lib（核心類庫及struts2第三方插件類庫）、src（源代碼）。
2) 創建web工程，添加jar包
將下載資源包中lib下的struts2-core-2.0.11.jar、xwork-2.0.4.jar和ognl-2.6.11.jar（三個爲必須jar包）添加，就可以開發應用，但是會有錯誤消息。添加commons-logging-1.04.jar和freemarker-2.3.8.jar就不會報錯。
3) 編輯web.xml文件，配置struts2的核心Filter
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.4"
xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
<display-name>Struts 2.0 Hello World</display-name>
<filter>
<filter-name>struts2</filter-name>
<filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
<welcome-file>login.jsp</welcome-file>
</welcome-file-list>
</web-app>
4) 寫用戶請求jsp
<%@ page language="java" contentType="text/html; charset=utf-8"%>
<html>
<head>
<title>登陸頁面</title>
</head>
<body>
<form action="Login.action" method="post">
<table align="center">
<h3>用戶登陸</h3>
<tr align="center">
<td>用戶名：<input type="text" name="username"/></td>
</tr>
<tr align="center"><td>密 碼：<input type="text" name="password"/></td></tr>
<tr align="center">
<td colspan="2"><input type="submit" value="提交"/><input
type="reset" value="重置"/></td>
</tr>
</table>
</form>
</body>
</html>
5) 寫Action類
package com.ascent.struts2.action;
public class LoginAction {
private String username;
private String password;
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String execute(){
if(getUsername().equals("liang")&& getPassword().equals("liang")){
return "success";
}
return "error";
}
}
6) 在src下寫struts.xml
<?xml version="1.0" encoding="GBK"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<package name="struts2_helloworld" extends="struts-default">
<action name="Login" class="com.ascent.struts2.action.LoginAction">
<result name="error">/error.jsp</result>
<result name="success">/welcome.jsp</result>
</action>
</package>
</struts>
7) 添加error.jsp和welcome.jsp
8) 部署和啓動，進行測試。
注意：TOMCAT 5。5有警告，說的是
警告: Settings: Could not parse struts.locale setting, substituting default VM locale）
要解決也不難，創建struts.properties這個文件，放在src目錄下就可以了
struts.locale=en_GB
2. 添加Spring2.0支持，整合Spring2.0
1) 右鍵工程名，選擇MyEclipse->Add Spring Capabilities…打開添加spring支持配置頁面，如下圖：
圖3-26 MyEclipse配置spring頁面1圖
2) 打開如下配置頁面，進行配置：
圖3-27 MyEclipse配置spring頁面2圖
選擇spring2.0，勾取spring2.0支持包，要選擇Spring2.0 ORM/DAO/Hibernate3 Libraries ,選擇Copy checked Libraty contents to project folder(TLDs always copied) ,並將其拷貝到路徑爲/WebRoot/WEB-INF/lib,然後選擇Next，進行下一步設置。
3) 進入application生成頁面，如下圖：
圖3-28 MyEclipse配置spring頁面3圖
選擇New，Folder選擇工程下的WebRoot/WEB-INF, File爲applicationContext.xml,最後點擊Finish完成對Spring2.0的添加。
4) 上面3步添加了spring2.0支持，還需要將spring2.0和struts2.0整合在一起，需要添加struts2-spring-plugin-2.0.11.jar插件，需要在web.xml中配置spring初始化監聽，如下代碼：
<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>
插件添加很簡單，將下載的struts2的資源包中的lib下的struts2-spring-plugin-2.0.11.jar拷貝到工程的lib下即可。
完成上述工作，Spring的IoC容器會在Web應用啓動時完成初始化，且成爲Struts2框架的默認的objectFactory。
3. 添加Hibernate3.1支持，整合Hibernate3.1
1) 添加工程的包結構，分別爲DAO和PO的類包，如下：
圖3-29 MyEclipse配置hibernate頁面1圖
2) 添加Hibernate3.1支持，右鍵工程->MyEclipse->Add Hibernate Capabilities…,如下圖：
圖3-30 MyEclipse配置hibernate頁面2圖
3) 進入配置頁面，進行如下步驟配置：
圖3-31 MyEclipse配置hibernate頁面3圖
選擇Hibernate3.1，勾取支持Libraries，選擇Copy checked Library Jars to project folder and add to build-path,Library folder路徑爲WebRoot/WEB-INF/lib，選擇Next。
4) 選擇Spring configuration file (applicationContext.xml)，將hibernate連接庫的操作交給Spring來控制，然後Next，如下圖：
圖3-32 MyEclipse配置hibernate頁面4圖
5) 選擇Existing Spring configuration file，爲前配置好的Spring配置文件，SessionFaction ID寫爲sessionFactory，爲hibernate 產生連接的bean的id，如下圖，然後Next
圖3-33 MyEclipse配置hibernate頁面5圖
6) 設置數據源，填寫Bean Id 爲dataSource，選擇JDBC，DB Driver爲設置好的mysql driver，如下圖，然選擇Next
圖3-34 MyEclipse配置hibernate頁面6圖
7) 取消創建sessinFactory class，不勾取，因爲前面已經將sessionFactory交給了Spring來產生，如下圖配置，然後finishi完成hibernate支持的添加。
圖3-35 MyEclipse配置hibernate頁面7圖
8) 點擊finish出現如下窗口，選擇Keep Existing
圖3-36 MyEclipse配置hibernate頁面8圖
9) 完成後applicationContext.xml中已經添加了數據源和sessionFactory的配置，如下圖：
圖3-37 MyEclipse配置hibernate頁面9圖
10) 此時，已經完成了Hibernate3.1的添加，其他hibernate映射具體看struts2與hibernate整合的章節。
提示：完成了struts2.0、spring2.0和hibernate3.1的添加與整合，重新啓動工程，驗證連接程序時會出現如下錯誤：
啓動Tomcat，又有新的錯誤;
嚴重: Unable to initialize Struts ActionServlet due to an unexpected exception or error thrown, so marking the servlet as unavailable. Most likely, this is due to an incorrect or missing library dependency.
java.lang.NoClassDefFoundError: org/apache/commons/pool/impl/GenericObjectPool
at java.lang.Class.getDeclaredConstructors0(Native Method)
......
解決辦法:
到http://www.apache.org/dist/commons/pool/binaries/ 下載commons-pool-1.3.zip，把裏面的commons-pool-1.3.jar放到Tomcat目錄下的lib文件夾！
再次啓動，可能還會報下面的錯誤：
java.lang.NoSuchMethodError: org.objectweb.asm.ClassVisitor.visit
2007-08-08 15:36:17,406 ERROR [org.hibernate.proxy.BasicLazyInitializer] - CGLIB Enhancement failed: dao.User
java.lang.NoSuchMethodError: org.objectweb.asm.ClassVisitor.visit(IILjava/lang/String;Ljava/lang/String;[Ljava/lang/String;Ljava/lang/String;)V
at net.sf.cglib.core.ClassEmitter.begin_class(ClassEmitter.java:77)
Spring 和 Hibernate 共用的一些 jar 文件發生了版本衝突, 刪除 WEB-INF/lib/asm-2.2.3.jar 然後重啓 Tomcat.
至此我們完成了Eclipse對Struts2.0, Spring2.0, Hibernate3.1的支持。我們可以看出，Spring的配置主要在WEB-INF下的applicationContext.xml文件中。由於在Struts-Spring- Hibernate的開發中，Spring處於承上啓下的作用，所以這個文件是整個項目的核心文件，applicationContext.xml文件具體內容如下：
<?xml version="1.0" encoding="UTF-8"?>
<beans
xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
<bean id="dataSource"
class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName"
value="com.mysql.jdbc.Driver">
</property>
<property name="url"
value="jdbc:mysql://localhost:3306/acesys">
</property>
<property name="username" value="root"></property>
<property name="password" value="root"></property>
</bean>
<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="dataSource">
<ref bean="dataSource" />
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">
org.hibernate.dialect.MySQLDialect
</prop>
<prop key="show_sql">true</prop>
</props>
</property>
<property name="mappingResources">
<list>
<value>com/ascent/po/Productuser.hbm.xml</value>
<value>com/ascent/po/Product.hbm.xml</value>
<value>com/ascent/po/UserProduct.hbm.xml</value>
<value>com/ascent/po/Orders.hbm.xml</value>
<value>com/ascent/po/Orderitem.hbm.xml</value>
<value>com/ascent/po/Mailtb.hbm.xml</value></list>
</property></bean>
<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory"/>
</bean>
<bean id="transactionInterceptor" class="org.springframework.transaction.interceptor.TransactionInterceptor">
<!-- 事務攔截器bean需要依賴注入一個事務管理器 -->
<property name="transactionManager" ref="transactionManager"/>
<property name="transactionAttributes">
<!-- 下面定義事務傳播屬性-->
<props>
<prop key="find*,get*">PROPAGATION_REQUIRED,readOnly</prop>
<prop key="save*,update*,delete*">PROPAGATION_REQUIRED</prop>
</props>
</property>
</bean>
<!-- 定義BeanNameAutoProxyCreator-->
<bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
<!-- 指定對滿足哪些bean name的bean自動生成業務代理 -->
<property name="beanNames">
<!-- 下面是所有需要自動創建事務代理的bean-->
<list>
<value>productuserService</value>
<value>productService</value>
<value>userProductService</value>
<value>ordersService</value>
<value>orderitemService</value>
<value>mailService</value>
</list>
<!-- 此處可增加其他需要自動創建事務代理的bean-->
</property>
<!-- 下面定義BeanNameAutoProxyCreator所需的事務攔截器-->
<property name="interceptorNames">
<list>
<!-- 此處可增加其他新的Interceptor -->
<value>transactionInterceptor</value>
</list>
</property>
</bean>
<bean id="productuserDAO"
class="com.ascent.dao.impl.ProductuserDAOImpl" abstract="false"
lazy-init="default" autowire="default" dependency-check="default">
<property name="sessionFactory">
<ref local="sessionFactory" />
</property>
</bean>
<bean id="productuserService"
class="com.ascent.service.impl.ProductuserServiceImpl"
abstract="false" lazy-init="default" autowire="default"
dependency-check="default">
<property name="productuserDAO">
<ref local="productuserDAO" />
</property>
</bean>
<bean id="productDAO" class="com.ascent.dao.impl.ProductDAOImpl"
abstract="false" lazy-init="default" autowire="default"
dependency-check="default">
<property name="sessionFactory">
<ref local="sessionFactory" />
</property>
</bean>
<bean id="productService"
class="com.ascent.service.impl.ProductServiceImpl" abstract="false"
lazy-init="default" autowire="default" dependency-check="default">
<property name="productDAO">
<ref local="productDAO" />
</property>
</bean>
<bean id="userProductDAO"
class="com.ascent.dao.impl.UserProductDAOImpl" abstract="false"
lazy-init="default" autowire="default" dependency-check="default">
<property name="sessionFactory">
<ref local="sessionFactory" />
</property>
</bean>
<bean id="userProductService"
class="com.ascent.service.impl.UserProductServiceImpl"
abstract="false" lazy-init="default" autowire="default"
dependency-check="default">
<property name="userProductDAO">
<ref local="userProductDAO" />
</property>
</bean>
<bean id="ordersDAO" class="com.ascent.dao.impl.OrdersDAOImpl"
abstract="false" lazy-init="default" autowire="default"
dependency-check="default">
<property name="sessionFactory">
<ref local="sessionFactory" />
</property>
</bean>
<bean id="ordersService"
class="com.ascent.service.impl.OrdersServiceImpl" abstract="false"
lazy-init="default" autowire="default" dependency-check="default">
<property name="ordersDAO">
<ref local="ordersDAO" />
</property>
</bean>
<bean id="orderitemDAO" class="com.ascent.dao.impl.OrderitemDAOImpl"
abstract="false" lazy-init="default" autowire="default"
dependency-check="default">
<property name="sessionFactory">
<ref local="sessionFactory" />
</property>
</bean>
<bean id="orderitemService"
class="com.ascent.service.impl.OrderitemServiceImpl" abstract="false"
lazy-init="default" autowire="default" dependency-check="default">
<property name="orderitemDAO">
<ref local="orderitemDAO" />
</property>
</bean>
<bean id="mailDAO" class="com.ascent.dao.impl.MailDAOImpl"
abstract="false" lazy-init="default" autowire="default"
dependency-check="default">
<property name="sessionFactory">
<ref local="sessionFactory" />
</property>
</bean>
<bean id="mailService"
class="com.ascent.service.impl.MailServiceImpl" abstract="false"
lazy-init="default" autowire="default" dependency-check="default">
<property name="mailDAO">
<ref local="mailDAO" />
</property>
</bean>
</beans>
關於它的具體內容我們稍後詳細講解。
6.6．2 Spring和Hibernate集成
我們前面提到，Spring與hibernate的集成實際上是通過applicationContext.xml配置文件完成的。關於如何使用Hibernate來對數據庫表做映射我們在前面已經做了介紹，這裏我們關心的是如何配置Spring使它能管理Hibernate。其實只要在Spring的配置文件（我們這裏是applicationContext. xml）中配置一個叫作sessionFactory的bean，Spring就可以和Hibernate聯繫起來了。而sessionFactory會應用dataSource的bean, 它代表的是數據源信息。如下所示：
<bean id="dataSource"
class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName"
value="com.mysql.jdbc.Driver">
</property>
<property name="url"
value="jdbc:mysql://localhost:3306/acesys">
</property>
<property name="username" value="root"></property>
<property name="password" value="root"></property>
</bean>
<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="dataSource">
<ref bean="dataSource" />
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">
org.hibernate.dialect.MySQLDialect
</prop>
<prop key="show_sql">true</prop>
</props>
</property>
這樣Spring和Hibernate的第一步整合就完成了，現在到了關鍵的地方，也就是如何讓Spring和Hibernate雙劍合璧來實現業務邏輯呢？
還是在applicationContext.xml文件中我們做了一個配置：
<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory"/>
</bean>
在上面你大概可以感覺到Spring給我們帶來的好處了，Spring的IoC模式可以統一管理各層，而又使各層鬆散耦合在一起。使各層之間實現最大的解耦性，這也是Web架構一貫的追求。
但是，Spring帶來的好處還不止於此，除了IoC還有AOP，Spring可以運用AOP來實現很多功能，最常用的就是事務處理。這裏我們用了業務服務（business service）層和數據存取對象（Data Access Object）層，在business service層我們增加事務處理，DAO（Data Access Object）層負責數據讀寫
首先組裝配置好Service Beans，
<bean id="transactionInterceptor" class="org.springframework.transaction.interceptor.TransactionInterceptor">
<!-- 事務攔截器bean需要依賴注入一個事務管理器 -->
<property name="transactionManager" ref="transactionManager"/>
<property name="transactionAttributes">
<!-- 下面定義事務傳播屬性-->
<props>
<prop key="find*,get*">PROPAGATION_REQUIRED,readOnly</prop>
<prop key="save*,update*,delete*">PROPAGATION_REQUIRED</prop>
</props>
</property>
</bean>
<!-- 定義BeanNameAutoProxyCreator-->
<bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
<!-- 指定對滿足哪些bean name的bean自動生成業務代理 -->
<property name="beanNames">
<!-- 下面是所有需要自動創建事務代理的bean-->
<list>
<value>productuserService</value>
<value>productService</value>
<value>userProductService</value>
<value>ordersService</value>
<value>orderitemService</value>
<value>mailService</value>
</list>
<!-- 此處可增加其他需要自動創建事務代理的bean-->
</property>
<!-- 下面定義BeanNameAutoProxyCreator所需的事務攔截器-->
<property name="interceptorNames">
<list>
<!-- 此處可增加其他新的Interceptor -->
<value>transactionInterceptor</value>
</list>
</property>
</bean>
之後需要把Business Service Object和 DAO也組裝起來，並把這些對象配到一個事務管理器（transaction manager）裏。
在Spring中的配置信息還有以下內容：
<bean id="productuserService"
class="com.ascent.service.impl.ProductuserServiceImpl"
abstract="false" lazy-init="default" autowire="default"
dependency-check="default">
<property name="productuserDAO">
<ref local="productuserDAO" />
</property>
</bean>
<bean id="productuserDAO"
class="com.ascent.dao.impl.ProductuserDAOImpl" abstract="false"
lazy-init="default" autowire="default" dependency-check="default">
<property name="sessionFactory">
<ref local="sessionFactory" />
</property>
</bean>
理解了以上的配置，我們就建立了整體框架，下面我們來進行具體代碼實現。
首先開發我們的DAO類吧。先說明一點，由於Spring是提倡面向接口編程的，所以我們先爲每個DAO類都定義一個接口.：例如，com/ascent/dao目錄下的ProductuserDAO是業務接口，而com/ascent/dao/impl目錄下的ProductuserDAOImpl是業務接口的實現類。在DAO的實現中，我們使用了Spring對Hibernate的集成類：HibernateTemplate.
典型的應用經常會被重複的資源管理代碼搞亂。很多項目嘗試創造自己的方案解決這個問題，有時會爲了編程方便犧牲適當的故障處理。對於恰當的資源處理Spring提倡令人矚目的簡單的解決方案：使用templating的IoC，比如基礎的class和回調接口，或者提供AOP攔截器。基礎的類負責固定的資源處理，以及將特定的異常轉換爲unchecked異常體系。Spring引進了DAO異常體系，可適用於任何數據訪問策略。Spring提供了對Hibernate的支持：HibernateTemplate，HibernateInterceptor，以及一個Hibernate transaction manager。這樣做的主要目的是：能夠清晰地劃分應用層次而不管使用何種數據訪問和事務技術；使應用對象之間的耦合鬆散。業務對象（Business Object）不再依賴於數據訪問和事務策略；不再有硬編碼的資源查找（lookup）；不再有難於替換的單點模式（singletons）；不再有自定義的服務註冊。一個簡單且堅固的方案連接了應用對象，並且使它們可重用盡可能地不依賴容器。雖然所有的數據訪問技術都能獨立使用，但是與Spring application context結合更好一些，它提供了基於xml的配置和普通的與Spring無關的JavaBean實例。在典型的Spring應用中，很多重要的對象都是JavaBeans：數據訪問template，數據訪問對象（使用template），transaction managers, 業務對象（使用數據訪問對象和transaction managers），web view resolvers, web controller（使用業務對象）等等。 代碼如下：
/**
*
*/
package com.ascent.dao;
import java.util.ArrayList;
import java.util.List;
import com.ascent.po.Productuser;
public interface ProductuserDAO {
//註冊
public Productuser saveProductuser(Productuser productuser);
//按用戶名查用戶
public Productuser findByUserName(String username);
//用戶登陸驗證的方法
public Productuser checkProductuser(String username,String password);
// 查詢所有用戶
public List findAll();
//返回查詢所有行 分頁
public int getTotalRows();
//查詢分頁設置數量的數據
public ArrayList getData(String sql,int firstRow,int maxRow);
// 按主鍵查詢用戶
public Productuser findById(String uid);
//刪除用戶
public boolean deleteProductuser(String uid);
//修改用戶信息
public boolean updateProductuser(Productuser productuser);
}
/**
*
*/
package com.ascent.dao.impl;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import com.ascent.dao.ProductuserDAO;
import com.ascent.po.Productuser;
public class ProductuserDAOImpl extends HibernateDaoSupport implements
ProductuserDAO {
/**
* 註冊productuser方法實現
*/
public Productuser saveProductuser(Productuser productuser) {
try{
this.getHibernateTemplate().save(productuser);
return productuser;
}catch(Exception e){
e.printStackTrace();
return null;
}
}
/**
* 根據用戶名查詢productuser
* 返回類型是Productuser，以備查詢用戶有需要得到其他信息，所以返回該對象
* 當返回是null，說明該用戶名的用戶庫中不存在，可以用來註冊
*/
public Productuser findByUserName(String username) {
String sql = "from Productuser p where p.username=? ";
List list = this.getHibernateTemplate().find(sql, username);
if(list.size()>0){
return (Productuser) list.get(0);
}
return null;
}
/**
* 用戶登陸驗證的方法 delFlag爲0標誌正常可使用用戶
*/
public Productuser checkProductuser(String username, String password) {
String sql = "from Productuser p where p.username=? and p.password=? and p.delFlag=0 ";
List list = this.getHibernateTemplate().find(sql, new String []{username,password});
if(list.size()>0){
return (Productuser)list.get(0);
}
return null;
}
@SuppressWarnings("unchecked")
public List findAll() {
List list = new ArrayList();
List l = this.getHibernateTemplate().find("from Productuser p order by p.uid");
Iterator it = l.iterator();
while(it.hasNext()){
Productuser p = (Productuser)it.next();
p.setTemp4("<input type=\"checkbox\" name=\"infoid\" value=\""+p.getUid()+"\">");
list.add(p);
}
return list;
}
//查詢總行數 分頁 查詢所有用戶包括del_flag爲1的標誌刪除用戶
public int getTotalRows() {
String sql="from Productuser p order by p.uid ";
int totalRows = this.getHibernateTemplate().find(sql).size();
return totalRows;
}
/**
* @param sql
* @param firstRow
* @param maxRow
* @return list 對象，已包含一定數量的 User 在內
*/
public ArrayList getData(final String sql,final int firstRow, final int maxRow) {
return (ArrayList)this.getHibernateTemplate().executeFind( new HibernateCallback(){
public Object doInHibernate(Session session) throws SQLException,HibernateException {
Query q = session.createQuery(sql);
q.setFirstResult(firstRow);
q.setMaxResults(maxRow);
ArrayList data = (ArrayList) q.list();
return data;
}
});
}
//刪除用戶 需求中爲軟刪除 所以可能不用delete方法
public boolean deleteProductuser(String uid) {
Productuser p = (Productuser)this.getHibernateTemplate().load(Productuser.class, new Integer(uid));
this.getHibernateTemplate().delete(p);
return true;
}
//根據uid查詢用戶
public Productuser findById(String uid) {
Productuser p = (Productuser)(this.getHibernateTemplate().find("from Productuser p where p.uid=? ", new Integer(uid))).get(0);
return p;
}
//修改用戶信息
public boolean updateProductuser(Productuser productuser) {
this.getHibernateTemplate().saveOrUpdate(productuser);
System.out.println("修改成功====updateProductuser");
return true;
}
}
service的接口及實現如下：
/**
*
*/
package com.ascent.service;
import java.util.ArrayList;
import java.util.List;
import com.ascent.po.Productuser;
public interface ProductuserService {
//註冊方法
public Productuser saveProductuser(Productuser productuser);
//按照姓名查詢方法
public Productuser findByUserName(String username);
//用戶登陸驗證的方法
public Productuser checkProductuser(String username,String password);
// 查詢所有用戶
public List findAll();
// 返回查詢所有行 分頁
public int getTotalRows();
//查詢分頁設置數量的數據
public ArrayList getData( final String sql, final int firstRow, final int maxRow);
//按主鍵查詢用戶
public Productuser findById(String uid);
//刪除用戶
public boolean deleteProductuser(String uid);
//修改用戶信息
public boolean updateProductuser(Productuser productuser);
}
/**
*
*/
package com.ascent.service.impl;
import java.util.ArrayList;
import java.util.List;
import com.ascent.dao.ProductuserDAO;
import com.ascent.po.Productuser;
import com.ascent.service.ProductuserService;
public class ProductuserServiceImpl implements ProductuserService {
private ProductuserDAO productuserDAO;
public void setProductuserDAO(ProductuserDAO productuserDAO) {
this.productuserDAO = productuserDAO;
}
public Productuser saveProductuser(Productuser productuser) {
return productuserDAO.saveProductuser(productuser);
}
public Productuser findByUserName(String username) {
return productuserDAO.findByUserName(username);
}
public Productuser checkProductuser(String username, String password) {
return productuserDAO.checkProductuser(username, password);
}
public List findAll() {
return productuserDAO.findAll();
}
public ArrayList getData(String sql, int firstRow, int maxRow) {
return productuserDAO.getData(sql, firstRow, maxRow);
}
public int getTotalRows() {
return productuserDAO.getTotalRows();
}
public boolean deleteProductuser(String uid) {
return productuserDAO.deleteProductuser(uid);
}
public Productuser findById(String uid) {
return productuserDAO.findById(uid);
}
public boolean updateProductuser(Productuser productuser) {
return productuserDAO.updateProductuser(productuser);
}
}
6.6.3 Spring和Struts集成
Spring和Struts的整合有很多種方式，如下三種解決方案，可以做爲參考：
1．使用Spring的ActionSupport類整合Struts
2．使用Spring的DelegatingRequestProcessor覆蓋Struts的RequestProcessor
3．將Struts Action管理委託給Spring框架
我們這裏使用的是第三種方式，也就是通過IoC模式讓Spring對Struts的Action進行管理，並且我們這裏使用了Spring的自動裝配功能。
先建立一個BaseAction，它繼承了Action類，而其它自定義的Action都要繼承這個BaseAction
/**
*
*/
package com.ascent.action;
import com.ascent.service.MailService;
import com.ascent.service.OrderitemService;
import com.ascent.service.OrdersService;
import com.ascent.service.ProductService;
import com.ascent.service.ProductuserService;
import com.ascent.service.UserProductService;
import com.opensymphony.xwork2.ActionSupport;
@SuppressWarnings("serial")
public class BaseAction extends ActionSupport {
//BaseAction中定義service接口，所有Action繼承該父類 ，不用每個Action中都得引入了
protected ProductuserService productuserService;
public ProductuserService getProductuserService() {
return productuserService;
}
public void setProductuserService(ProductuserService productuserService) {
this.productuserService = productuserService;
}
protected ProductService productService;
public ProductService getProductService() {
return productService;
}
public void setProductService(ProductService productService) {
this.productService = productService;
}
protected UserProductService userProductService;
public UserProductService getUserProductService() {
return userProductService;
}
public void setUserProductService(UserProductService userProductService) {
this.userProductService = userProductService;
}
protected OrdersService ordersService;
public OrdersService getOrdersService() {
return ordersService;
}
public void setOrdersService(OrdersService ordersService) {
this.ordersService = ordersService;
}
protected OrderitemService orderitemService;
public OrderitemService getOrderitemService() {
return orderitemService;
}
public void setOrderitemService(OrderitemService orderitemService) {
this.orderitemService = orderitemService;
}
protected MailService mailService;
public MailService getMailService() {
return mailService;
}
public void setMailService(MailService mailService) {
this.mailService = mailService;
}
}
工具類AppContext的使用：
一般情況下，我們使用Spring的IoC功能將業務邏輯Service組件注入到Action對象中，這時需要在applicationContext.xml中進行配置，例如以下片段：
<bean id="productuserLoginAction"
class="com.ascent.action.ProductuserLoginAction"
scope="prototype">
<!- -依賴注入業務邏輯Service組件 - ->
<property name="productuserService"
ref local="productuserService" />
</property>
</bean>
<bean id="productuserService"
class="com.ascent.service.impl.ProductuserServiceImpl"
abstract="false" lazy-init="default" autowire="default"
dependency-check="default">
<property name="productuserDAO">
<ref local="productuserDAO" />
</property>
</bean>
這種方式有一個明顯的缺陷：所有的Action都需要在applicationContext.xml中進行配置，而struts.xml文件中還需要配置同樣的Action。對於有成百上千Action的一般應用，配置文件就會過於龐大臃腫和過多冗餘。
爲了簡化，我們在Spring對Struts的集成中使用了Spring的自動裝配功能。在這種策略下，Action還是由Spring插件創建，但Spring插件在創建Action實例時，會將對應業務邏輯組件自動注入Action實例。通過使用自動裝配，就不再需要在applicationContext.xml中對Action進行配置，也就是省去了上面那些關於Action的相關內容。
指定Spring插件的自動裝配策略通過struts.objectFactory.spring.auto Wire常量制定，該常量可以接受如下幾個值：
l name: 根據屬性名自動裝配。Spring插件會查找容器中全部Bean，找出其中id屬性與Action所需的業務邏輯組件同名的Bean，將該Bean實例注入到Action實例。
l type: 根據屬性類型自動裝配。Spring插件會查找容器中全部Bean，找出其類型恰好與Action所需的業務邏輯組件相同的Bean，將該Bean實例注入到Action實例。如果有多個這樣的Bean，就拋出一個致命異常；如果沒有匹配的Bean，則什麼都不會發生，屬性不會被設置。
l auto: Spring插件會自動檢測需要使用哪種自動裝配方式。
l constructor: 同type類似，區別是constructor使用構造器來構造注入的所需參數，而不是使用設值注入方式。
本應用使用按name來完成自動裝配。如果我們不指定自動裝配的方式，則系統默認使用按name自動裝配，因此我們無需設置任何的Struts 2常量。
<!--
指定使用按name的自動裝配策略
-->
<constant name="struts.objectFactory.spring.autoWire" value="name" />
因爲使用了自動裝配，Spring插件創建Action實例時，是根據配置Action的class屬性指定實現類來創建Action實例的。
例如在struts.xml中，我們有以下內容：
<action name="productuserLoginAction" class="com.ascent.action.ProductuserLoginAction">
<result>/index.html</result>
<result name="success_1">/product/products.jsp</result>
<result name="success_2">/product/products.jsp</result>
<result name="success_3">/product/products_showusers.jsp</result>
<result name="error">/product/products.jsp</result>
<result name="input">/product/products.jsp</result>
</action>
ProductuserLoginAction繼承了BaseAction類, 該Action所需的業務邏輯組件名爲productuserService。我們查看剛纔的BaseAction類代碼，發現瞭如下的內容：
//系統所用的業務邏輯組件
protected ProductuserService productuserService;
public ProductuserService getProductuserService() {
return productuserService;
}
public void setProductuserService(ProductuserService productuserService) {
this.productuserService = productuserService;
}
配置業務邏輯組件時，我們必須在applicationContext.xml文件中指定其id屬性爲productuserService，那麼Spring插件就可以在創建時自動地將該業務邏輯組件注入給Action實例。相關代碼如下：
<bean id="productuserService"
class="com.ascent.service.impl.ProductuserServiceImpl"
abstract="false" lazy-init="default" autowire="default"
dependency-check="default">
<property name="productuserDAO">
<ref local="productuserDAO" />
</property>
</bean>
至此，Struts-Spring-Hibernate已經可以一起來工作了。
Struts-Spring-Hibernate集成
發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章
idea 創建簡單的Spring boot項目
1、 2、 3、 4、 5、 6、 7、運行 HelloWorld 啓動後內置的Tomcat服務器也同時啓動起來了,然後在瀏覽器中輸入 localhost:8080/hello