struts+hibernate+spring整合

在已经做好了的hibernate+struts 工程里加入spring（本人一般采用第三种技术)

将 Struts 动作整合到 Spring 框架中

1、使用 Spring 的 ActionSupport 类整合 Structs
2、使用 Spring 的 DelegatingRequestProcessor 覆盖 Struts 的
RequestProcessor
3、将 Struts Action 管理委托给 Spring 框架(其他两种技术请参考其他网站)

首先要建立"装载应用程序环境"
无论您使用哪种技术，都需要使用 Spring 的
ContextLoaderPlugin 为 Struts 的 ActionServlet 装载 Spring
应用程序环境。就像添加任何其他插件一样，简单地向您的struts-config.xml
文件添加该插件，如下所示：
<plug-in className=
"org.springframework.web.struts.ContextLoaderPlugIn">
<set-property property=
"contextConfigLocation" value="/WEB-INF/beans.xml"/>
</plug-in>

窍门 3. 将动作管理委托给 Spring
一个更好的解决方法是将 Strut 动作管理委托给
Spring。您可以通过在 struts-config
动作映射中注册一个代理来实现。代理负责在 Spring
环境中查找 Struts 动作。由于动作在 Spring
的控制之下，所以它可以填充动作的 JavaBean
属性，并为应用诸如 Spring 的 AOP
拦截器之类的特性带来了可能。

/**清单 4. 具有 JavaBean 属性的 Struts 动作
package ca.nexcel.books.actions;


import java.io.IOException;


import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;


import org.apache.struts.action.Action;
import org.apache.struts.action.ActionError;
import org.apache.struts.action.ActionErrors;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.action.DynaActionForm;


import ca.nexcel.books.beans.Book;
import ca.nexcel.books.business.BookService;


public class SearchSubmit extends Action {


private BookService bookService;
public BookService getBookService() {
return bookService;
}


public void setBookService(BookService bookService) { | (1)
this.bookService = bookService;
}


public ActionForward execute(
ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
HttpServletResponse response)
throws IOException, ServletException {


DynaActionForm searchForm = (DynaActionForm) form;
String isbn = (String) searchForm.get("isbn");


Book book = getBookService().read(isbn.trim()); |(2)


if (null == book) {
ActionErrors errors = new ActionErrors();
errors.add(ActionErrors.GLOBAL_ERROR,new
ActionError("message.notfound"));
saveErrors(request, errors);
return mapping.findForward("failure") ;
}


request.setAttribute("book", book);
return mapping.findForward("success");
}



}


在清单 4 中，您可以了解到如何创建 Struts 动作。在
(1) 处，我创建了一个 JavaBean
属性。DelegatingRequestProcessor自动地配置这种属性。这种设计使
Struts 动作并不知道它正被 Spring
管理，并且使您能够利用 Sping
的动作管理框架的所有优点。由于您的 Struts
动作注意不到 Spring 的存在，所以您不需要重写您的
Struts 代码就可以使用其他控制反转容器来替换掉
Spring。

DelegatingRequestProcessor
方法的确比第一种方法好，但是仍然存在一些问题。如果您使用一个不同的
RequestProcessor，则需要手动整合 Spring 的
DelegatingRequestProcessor。添加的代码会造成维护的麻烦并且将来会降低您的应用程序的灵活性。此外，还有过一些使用一系列命令来代&shy;替
Struts RequestProcessor 的传闻。
这种改变将会对这种解决方法的使用寿命造成负面的影响
**/

清单 5 中的 Action 类与清单 4 中的相同。但是
struts-config 有一些不同：


清单 5. Spring 整合的委托方法
<?xml version="1.0" encoding="ISO-8859-1" ?>


<!DOCTYPE struts-config PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration
1.1//EN"


"http://jakarta.apache.org/struts/dtds/struts-config_1_1.dtd">


<struts-config>
<form-beans>
<form-bean name="searchForm"
type="org.apache.struts.validator.DynaValidatorForm">
<form-property name="isbn" type="java.lang.String"/>
</form-bean>


</form-beans>


<global-forwards type="org.apache.struts.action.ActionForward">
<forward name="welcome" path="/welcome.do"/>
<forward name="searchEntry" path="/searchEntry.do"/>
<forward name="searchSubmit" path="/searchSubmit.do"/>
</global-forwards>


<action-mappings>
<action path="/welcome" forward="/WEB-INF/pages/welcome.htm"/>
<action path="/searchEntry"
forward="/WEB-INF/pages/search.jsp"/>
<action path="/searchSubmit"


type="org.springframework.web.struts.DelegatingActionProxy" |(1)
input="/searchEntry.do"
validate="true"
name="searchForm">
<forward name="success" path="/WEB-INF/pages/detail.jsp"/>
<forward name="failure" path="/WEB-INF/pages/search.jsp"/>
</action>


</action-mappings>


<message-resources parameter="ApplicationResources"/>


<plug-in className="org.apache.struts.validator.ValidatorPlugIn">
<set-property
property="pathnames"
value="/WEB-INF/validator-rules.xml,/WEB-INF/validation.xml"/>
</plug-in>


<plug-in
className="org.springframework.web.struts.ContextLoaderPlugIn">
<set-property property="contextConfigLocation"
value="/WEB-INF/beans.xml"/>
</plug-in>


</struts-config>


清单 5 是一个典型的 struts-config.xml
文件，只有一个小小的差别。它注册 Spring
代理类的名称，而不是声明动作的类名，如（1）处所示。DelegatingActionProxy
类使用动作映射名称查找 Spring
环境中的动作。这就是我们使用 ContextLoaderPlugIn
声明的环境。


将一个 Struts 动作注册为一个 Spring bean
是非常直观的，如清单 6 所示。我利用动作映射使用
<bean> 标记的名称属性（在这个例子中是
"/searchSubmit"）简单地创建了一个 bean。这个动作的
JavaBean 属性像任何 Spring bean 一样被填充：


清单 6. 在 Spring 环境中注册一个 Struts 动作
<?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="bookService"
class="ca.nexcel.books.business.BookServiceImpl"/>


<bean name="/searchSubmit"
class="ca.nexcel.books.actions.SearchSubmit">
<property name="bookService">
<ref bean="bookService"/>
</property>
</bean>


</beans>


动作委托的优点
动作委托解决方法是这三种方法中最好的。Struts
动作不了解 Spring，不对代码作任何改变就可用于非
Spring 应用程序中。RequestProcessor
的改变不会影响它，并且它可以利用 Spring AOP
特性的优点。


动作委托的优点不止如此。一旦让 Spring 控制您的
Struts 动作，您就可以使用 Spring
给动作补充更强的活力。例如，没有 Spring
的话，所有的 Struts
动作都必须是线程安全的。如果您设置 <bean> 标记的
singleton
属性为"false"，那么不管用何种方法，您的应用程序都将在每一个请求上有一个新生成的动作对象。您可能不需要这种特性，但是把它放在您的工具箱中也很好。&shy;您也可以利用
Spring 的生命周期方法。例如，当实例化 Struts
动作时，<bean> 标记的 init-method
属性被用于运行一个方法。类似地，在从容器中删除
bean 之前，destroy-method
属性执行一个方法。这些方法是管理昂贵对象的好办法，它们以一种与
Servlet 生命周期相同的方式进行管理。


在本文中，您已经学习了将 Struts 动作整合到 Spring
框架中的三种窍门。使用 Spring 的 ActionSupport 来整合
Struts（第一种窍门中就是这样做的）简单而快捷，但是会将
Struts 动作与 Spring
框架耦合在一起。如果您需要将应用程序移植到一个不同的框架，则需要重写代码。第二种解决方法通过委托
RequestProcessor
巧妙地解开代码的耦合，但是它的可扩展性不强，并且当
Struts 的 RequestProcessor
变成一系列命令时，这种方法就持续不了很长时间。第三种方法是这三种方法中最好的：将
Struts 动作委托给 Spring
框架可以使代码解耦，从而使您可以在您的 Struts
应用程序中利用 Spring
的特性（比如日志记录拦截器）。








最近看看SSH，从网上看到这篇文章，转过来收藏：

Struts+Spring+Hibernate练习(完整)
工具：
    Eclipse3.1、MyEclipse4.03、Tomcat5.5.9、Properties Editor插件、MySql4.1.13

新建工程：名称为 login

创建Struts框架

创建 index.jsp，增加一链接指向 login.jsp

按下Ctrl + N，创建 login.jsp、LoginAction，使用MyEclipse的向导就可以了，记得选对正确的版本

在ActionForm配置页中选择类型为动态Form，并继承于DynaValidatorForm，新增两个属性：username、password，在创建jsp文件打上钩，将路径改为/login.jsp，然后下一步，改LoginAction的Input source改为/login.jsp，点击完成

按下Ctrl + N 创建一个forwards，记得选对正确的版本
name 输入 indexGo
路径选择 /index.jsp

配置validator
先添加Struts插件，使用向导
Plugin class : org.apache.struts.validator.ValidatorPlugIn
Property : pathnames
Value : /WEB-INF/validator-rules.xml,/WEB-INF/validation.xml
这里需要两个xml文件
现在创建“validation.xml” 文件

在这里说明一点，我使用MyEclipse创建的Struts框架中缺少了validator-rules.xml文件，需要动拷贝到WEB-INF目录中
此文件可以到http://struts.apache.org/下载

文件内容如下：
<form-validation>
<formset>
  <form name="loginForm">
   <field property="username" depends="required">
    <arg0 key="prompt.username" />
   </field>
   <field property="password" depends="required">
    <arg0 key="prompt.password" />
   </field>
  </form>
</formset>
</form-validation>

编辑资源文件“ApplicationResources.properties”
增加以下内容

prompt.username=User Name
prompt.password=User Password
errors.required={0} is required.

再创建中文件资源文件“ApplicationResources_zh_CN.properties”
增加以下内容
prompt.username=用户名称
prompt.password=登录密码
errors.required={0} 必需填写！

修改struts-config.xml文件
在以下位置增加绿色字体部份
<action-mappings >
    <action
      attribute="loginForm"
      input="/login.jsp"
      name="loginForm"
      path="/login"
      scope="request"
      validate="true"
      type="com.test.struts.action.LoginAction" />
  </action-mappings>

这里说明提交的数据必需经过验证，而验证则是通过validator框架进行的。

修改LoginAction.java文件的execute方法，内容如下
public ActionForward execute(
  ActionMapping mapping,
  ActionForm form,
  HttpServletRequest request,
  HttpServletResponse response) {
  DynaValidatorForm loginForm = (DynaValidatorForm) form;
  String username=loginForm.getString("username");
  String password=loginForm.getString("password");
  if(username.equals("test")||password.equals("test")){
   return mapping.findForward("indexGo");
  }else{
   return mapping.getInputForward();
  }
}

现在再修改一下login.jsp
增加以下绿色字体部份
<%@ page language="java" contentType="text/html; charset=UTF-8" %>

其中charset=UTF-8 是使用UTF-8的字符编码，这也是为了支持国际化而使用的。

好了，现在可以启动Tomcat进行测试了
http://localhost/login/ 这里说明一下，我的Tomcat已经装端口号改为80了，所以就不必使用http://localhost:8080/login/这样的方法了。

如果不输入任何数据而直接提交表单的话就可以看到效果了。

好了，如果没有什么问题的话就继续往下看吧，如果有问题的话就得往上看了^_^

现在创建Spring框架了，在这里我将Spring所有的包全部加载进去，因为我还不知道具体用到哪些类，全部加进去方便点

单选框选第二个，这样的话所有的类库和标签等都将拷贝到项目中去，这样方便以后的布署
下一步后是创建配置文件，将文件放到“WebRoot/WEB-INF”目录下，文件名称为“applicationContext.xml”


配置struts-config.xml文件，添加（spring）的插件

<plug-in className="org.springframework.web.struts.ContextLoaderPlugIn">
    <set-property property="contextConfigLocation" value="/WEB-INF/applicationContext.xml" />
  </plug-in>

 
修改LoginAction配置

原：
<action
      attribute="loginForm"
      input="/login.jsp"
      name="loginForm"
      path="/login"
      scope="request"
      validate="true"
      type="com.test.struts.action.LoginAction" />

  </action-mappings>

改为：
<action
      attribute="loginForm"
      input="/login.jsp"
      name="loginForm"
      path="/login"
      scope="request"
      validate="true"
      type="org.springframework.web.struts.DelegatingActionProxy" />
  </action-mappings>

 
绿色字体部份为修改内容
这里将使用spring的代理器来对Action进行控制

当提交到/login.do是将控制权交给了spring，然后由spring来决定是否转回到struts的Action

现在来配置spring

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>
<bean name="/login" class="com.test.struts.action.LoginAction" singleton="false"></bean>
</beans>

绿色字体是关于转交控制权的配置内容

属性singleton="false"，指明了Action 的实例获取方式为每次重新创建。解决了Struts中令人诟病的线程安全问题（Struts中，由一个Action实例处理所有的请求，这就导致了类公用资源在并发请求中的线程同步问题。）（摘自spring开发指南）

这时如果你要进行测试也是可以的，不过为了省点时间就不进行测试了。
 
建立数据库在 这里我使用的是mysql4.1.13

CREATE TABLE `user` (
  `ID` int(11) NOT NULL auto_increment,
  `USERNAME` varchar(50) NOT NULL default '',
  `PASSWORD` varchar(50) NOT NULL default '',
  PRIMARY KEY  (`ID`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1;

添加记录 insert into user (USERNAME,PASSWORD) values ('test','test')

创建Hibernate框架
在配置界面中配置数据库的连接部份，重要的是点击链接将jdbc拷贝到lib目录中
使用MyEclipse的数据Database Explorer工具创建User.hmb.xml、AbstractUser.java、User.java映射文件
创建完成后可以将自动生成的hibernate.cfg.xml删除

创建UserDAO.java、UserDAOImp.java
UserDAO.java
public interface UserDAO {
   public abstract boolean isValidUser(String username, String password);
}

UserDAOImp.java
import java.util.List;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import com.test.Hibernate.SessionFactory;
public class UserDAOImp extends HibernateDaoSupport implements UserDAO {
    private SessionFactory sessionFactory;
    private static String hql = "from User u where u.username=? ";
    public boolean isValidUser(String username, String password) {
       List userList = this.getHibernateTemplate().find(hql, username);
       if (userList.size() > 0) {
           return true;
       }
       return false;
    }
}

修改LoginAction.java文件，使用userDao的方法来进行用户验证
package com.test.struts.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 org.apache.struts.validator.DynaValidatorForm;

import com.test.UserDAO;

public class LoginAction extends Action {

private UserDAO userDAO;

public UserDAO getUserDAO() {
  return userDAO;
}

public void setUserDAO(UserDAO userDAO) {
  this.userDAO = userDAO;
}

public ActionForward execute(ActionMapping mapping, ActionForm form,
   HttpServletRequest request, HttpServletResponse response) {
  DynaValidatorForm loginForm = (DynaValidatorForm) form;
  // TODO Auto-generated method stub
  String username = (String) loginForm.get("username");
  String password = (String) loginForm.get("password");
  loginForm.set("password", null);
  if (userDAO.isValidUser(username,password)) {
   return mapping.findForward("indexGo");
  } else {
   return mapping.getInputForward();
  }
}
}
绿色字体为修改部份

现在剩下最后的spring配置了
<?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="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
  <property name="driverClassName">
   <value>com.mysql.jdbc.Driver</value>
  </property>
  <property name="url">
   <value>jdbc:mysql://localhost/test</value>
  </property>
  <property name="username">
   <value>root</value>
  </property>
  <property name="password">
   <value>root</value>
  </property>
</bean>

<!-- 配置sessionFactory, 注意这里引入的包的不同  -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
  <property name="dataSource">
   <ref local="dataSource" />
  </property>
  <property name="mappingResources">
   <list>
    <value>com/test/Hibernate/User.hbm.xml</value>
   </list>
  </property>
  <property name="hibernateProperties">
   <props>
    <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
    <prop key="hibernate.show_sql">true</prop>
   </props>
  </property>
</bean>

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

<bean id="userDAO" class="com.test.UserDAOImp">
  <property name="sessionFactory">
   <ref local="sessionFactory" />
  </property>
</bean>

<bean id="userDAOProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
  <property name="transactionManager">
   <ref bean="transactionManager" />
  </property>
  <property name="target">
   <ref local="userDAO" />
  </property>
  <property name="transactionAttributes">
   <props>
    <prop key="insert*">PROPAGATION_REQUIRED</prop>
    <prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
    <prop key="is*">PROPAGATION_REQUIRED,readOnly</prop>
   </props>
  </property>
</bean>

<bean name="/login" class="com.test.struts.action.LoginAction" singleton="false">
  <property name="userDAO">
   <ref bean="userDAOProxy" />
  </property>
</bean>
</beans>

现在可以进行测试了！

在编写代码有配置内容时一定要注意 hibernate 和 hibernate3 ，这两个包的名字就只差一个字，千万不要有错，否则找错误可是很难的。
2、
环境：Windows2003&jdk1.5.05&Eclipse3.1+MyEclipse4.03

做一登录练习。

现已经完成了login的struts部份，实现了动态ActionForm和动态validator验证，详细全部文件内容如下：


struts-config.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts-config PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 1.1//EN" "http://jakarta.apache.org/struts/dtds/struts-config_1_1.dtd">

<struts-config>
  <data-sources />
  <form-beans >
    <form-bean name="loginForm" type="org.apache.struts.validator.DynaValidatorForm">
      <form-property name="password" type="java.lang.String" />
      <form-property name="username" type="java.lang.String" />
    </form-bean>

   </form-beans>

  <global-exceptions />
  <global-forwards >
    <forward name="indexGo" path="/index.jsp" />
</global-forwards>

  <action-mappings >
    <action
      attribute="loginForm"
      input="/login.jsp"
      name="loginForm"
      path="/login"
      scope="request"
      validate="true"
      type="com.test.struts.action.LoginAction" />
</action-mappings>

  <message-resources parameter="com.test.struts.ApplicationResources" />
  <plug-in className="org.apache.struts.validator.ValidatorPlugIn">
    <set-property property="pathnames" value="/WEB-INF/validator-rules.xml,/WEB-INF/validation.xml" />
  </plug-in>
</struts-config>

login.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib uri="http://jakarta.apache.org/struts/tags-bean" prefix="bean"%>
<%@ taglib uri="http://jakarta.apache.org/struts/tags-html" prefix="html"%>

<html>
<head>
  <title>JSP for loginForm form</title>
</head>
<body>
  <html:form action="/login">
   username : <html:text property="username"/><html:errors property="username"/><br/>
   password : <html:password property="password"/><html:errors property="password"/><br/>
   <html:submit/><html:cancel/>
  </html:form>
</body>
</html>

index.jsp

<html>
  <head>
    <title>My JSP 'index.jsp' starting page</title>
  </head>
 
  <body>
<a href="login.jsp">Login</a>
  </body>
</html>

LoginAction.java

//Created by MyEclipse Struts
// XSL source (default): platform:/plugin/com.genuitec.eclipse.cross.easystruts.eclipse_4.0.1/xslt/JavaClass.xsl

package com.test.struts.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 org.apache.struts.validator.DynaValidatorForm;

/**
* MyEclipse Struts
* Creation date: 10-27-2005
*
* XDoclet definition:
* @struts.action path="/login" name="loginForm" input="login.jsp" scope="request" validate="true"
*/
public class LoginAction extends Action {

// --------------------------------------------------------- Instance Variables

// --------------------------------------------------------- Methods

/**
  * Method execute
  * @param mapping
  * @param form
  * @param request
  * @param response
  * @return ActionForward
  */
public ActionForward execute(
  ActionMapping mapping,
  ActionForm form,
  HttpServletRequest request,
  HttpServletResponse response) {
  DynaValidatorForm loginForm = (DynaValidatorForm) form;
  // TODO Auto-generated method stub
  String username=(String)loginForm.get("username");
  String password=(String)loginForm.get("password");
  loginForm.set("password",null);
  if(username.equals("sonic")||password.equals("sonic")){
   System.out.println("AAA");
   return mapping.findForward("indexGo");
  }
  else {
   System.out.println("BBB");
   return mapping.getInputForward();
  }
}

}

ApplicationResources.properties

prompt.username=User Name
prompt.password=User Password

errors.required={0} is required.

ApplicationResources_zh_CN.properties

prompt.username=用户名称
prompt.password=登录密码

errors.required={0} 是必须的.

validation.xml

<form-validation>
<formset>
  <form name="loginForm">
   <field property="username" depends="required">
    <arg0 key="prompt.username" />
   </field>
   <field property="password" depends="required">
    <arg0 key="prompt.password" />
   </field>
  </form>
</formset>
</form-validation>

到此已经完成了全部代码！

********************************************************************
现在创建spring框架

配置struts-config.xml文件，添加（spring）的插件

<plug-in className="org.springframework.web.struts.ContextLoaderPlugIn">
    <set-property property="contextConfigLocation" value="/WEB-INF/applicationContext.xml" />
  </plug-in>

修改LoginAction配置

原：

<action
      attribute="loginForm"
      input="/login.jsp"
      name="loginForm"
      path="/login"
      scope="request"
      validate="true"
      type="com.test.struts.action.LoginAction" />
</action-mappings>

改为：

<action
      attribute="loginForm"
      input="/login.jsp"
      name="loginForm"
      path="/login"
      scope="request"
      validate="true"
      type="org.springframework.web.struts.DelegatingActionProxy" />

  </action-mappings>

绿色字体部份为修改内容

这里将使用spring的代理器来对Action进行控制

当提交到/login.do是将控制权交给了spring，然后由spring来决定是否转回到struts的Action

现在来配置spring

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>
<bean name="/login" class="net.xiaxin.action.LoginAction" singleton="false"></bean>
</beans>

绿色字体是关于转交控制权的配置内容属性singleton="false"，指明了Action 的实例获取方式为每次重新创建。解决了Struts中令人诟病的线程安全问题（Struts中，由一个Action实例处理所有的请求，这就导致了类公用资源在并发请求中的线程同步问题。）（摘自spring开发指南）

建立数据库在 这里我使用的是mysql4.1.1x

CREATE TABLE `user` (
  `ID` int(11) NOT NULL auto_increment,
  `USERNAME` varchar(50) NOT NULL default '',
  `PASSWORD` varchar(50) NOT NULL default '',
  PRIMARY KEY  (`ID`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1;

创建Hibernate框架

使用MyEclipse的数据Database Explorer工具创建User.hmb.xml、AbstractUser.java、User.java映射文件

创建完成后可以将自动生成的hibernate.cfg.xml删除

创建UserDAO.java、UserDAOImp.java

修改LoginAction.java文件，使用userDao的方法来进行用户验证

package com.test.struts.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 org.apache.struts.validator.DynaValidatorForm;

import com.test.UserDAO;

public class LoginAction extends Action {
public UserDAO getUserDAO() {
  return userDAO;
}

public void setUserDAO(UserDAO userDAO) {
  this.userDAO = userDAO;
}

public ActionForward execute(ActionMapping mapping, ActionForm form,
   HttpServletRequest request, HttpServletResponse response) {
  DynaValidatorForm loginForm = (DynaValidatorForm) form;
  // TODO Auto-generated method stub
  String username = (String) loginForm.get("username");
  String password = (String) loginForm.get("password");
  loginForm.set("password", null);
  if (userDAO.isValidUser(username,password)) {
   return mapping.findForward("indexGo");
  } else {
   return mapping.getInputForward();
  }
}

}
绿色字体为修改部份

现在剩下最后的spring配置了

<?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="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
  <property name="driverClassName">
   <value>com.mysql.jdbc.Driver</value>
  </property>
  <property name="url">
   <value>jdbc:mysql://localhost:3306/test</value>
  </property>
  <property name="username">
   <value>root</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\test\Hibernate\User.hbm.xml</value>
   </list>
  </property>
  <property name="hibernateProperties">
   <props>
    <prop key="hibernate.dialect">net.sf.hibernate.dialect.MySQLDialect</prop>
    <prop key="hibernate.show_sql">true</prop>
   </props>
  </property>
</bean>

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

<bean id="userDAO" class="com.test.UserDAOImp">
  <property name="sessionFactory">
   <ref local="sessionFactory" />
  </property>
</bean>

<bean id="userDAOProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
  <property name="transactionManager">
   <ref bean="transactionManager" />
  </property>
  <property name="target">
   <ref local="userDAO" />
  </property>
  <property name="transactionAttributes">
   <props>
    <prop key="insert*">PROPAGATION_REQUIRED</prop>
    <prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
    <prop key="is*">PROPAGATION_REQUIRED,readOnly</prop>
   </props>
  </property>
</bean>
<bean name="/login" class="com.test.struts.action.LoginAction" singleton="false">
  <property name="userDAO">
   <ref bean="userDAOProxy" />
  </property>
</bean>
</beans>

现在可以进行测试