struts+spring+hibernate整合

在已经做好了的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
文件添加该插件，如下所示：
"org.springframework.web.struts.ContextLoaderPlugIn">
"contextConfigLocation" value="/WEB-INF/beans.xml"/>

窍门 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。添加的代码会造成维护的麻烦并且将来会降低您的应用程序的灵活性。此外，还有过一些使用一系列命令来代­替
Struts RequestProcessor 的传闻。
这种改变将会对这种解决方法的使用寿命造成负面的影响
**/

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


清单 5. Spring 整合的委托方法



"-//Apache Software Foundation//DTD Struts Configuration
1.1//EN"


"">




type="org.apache.struts.validator.DynaValidatorForm">
















forward="/WEB-INF/pages/search.jsp"/>


type="org.springframework.web.struts.DelegatingActionProxy" |(1)
input="/searchEntry.do"
validate="true"
name="searchForm">












property="pathnames"
value="/WEB-INF/validator-rules.xml,/WEB-INF/validation.xml"/>



className="org.springframework.web.struts.ContextLoaderPlugIn">
value="/WEB-INF/beans.xml"/>






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


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


清单 6. 在 Spring 环境中注册一个 Struts 动作

"">



class="ca.nexcel.books.business.BookServiceImpl"/>


class="ca.nexcel.books.actions.SearchSubmit">









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


动作委托的优点不止如此。一旦让 Spring 控制您的
Struts 动作，您就可以使用 Spring
给动作补充更强的活力。例如，没有 Spring
的话，所有的 Struts
动作都必须是线程安全的。如果您设置 标记的
singleton
属性为"false"，那么不管用何种方法，您的应用程序都将在每一个请求上有一个新生成的动作对象。您可能不需要这种特性，但是把它放在您的工具箱中也很好。­您也可以利用
Spring 的生命周期方法。例如，当实例化 Struts
动作时， 标记的 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目录中

此文件可以到下载

 

文件内容如下：

 
  

   
    
   
   
    
   
  

 

 

编辑资源文件“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文件

在以下位置增加绿色字体部份

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

 

 

这里说明提交的数据必需经过验证，而验证则是通过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进行测试了

 这里说明一下，我的Tomcat已经装端口号改为80了，所以就不必使用这样的方法了。

 

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

 

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

 

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

 

单选框选第二个，这样的话所有的类库和标签等都将拷贝到项目中去，这样方便以后的布署

下一步后是创建配置文件，将文件放到“WebRoot/WEB-INF”目录下，文件名称为“applicationContext.xml”

 

 

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

 

   
 

 

 

修改LoginAction配置

 

原：

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

 

 

 

改为：

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

 

 

 

绿色字体部份为修改内容

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

 

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

 

现在来配置spring

 

">

 

 

 

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

 

属性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配置了

">

 

 
  
   com.mysql.jdbc.Driver
  
  
   jdbc:mysql://localhost/test
  
  
   root
  
  
   root
  
 

 

 
 
  
   
  
  
   
    com/test/Hibernate/User.hbm.xml
   
  
  
   
    org.hibernate.dialect.MySQLDialect
    true
   
  
 

 

 
  
   
  
 

 

 
  
   
  
 

 

 
  
   
  
  
   
  
  
   
    PROPAGATION_REQUIRED
    PROPAGATION_REQUIRED,readOnly
    PROPAGATION_REQUIRED,readOnly
   
  
 

 

 
  
   
  
 

 

现在可以进行测试了！

 

在编写代码有配置内容时一定要注意 hibernate 和 hibernate3 ，这两个包的名字就只差一个字，千万不要有错，否则找错误可是很难的。

2、

环境：Windows2003&jdk1.5.05&Eclipse3.1+MyEclipse4.03

 

做一登录练习。

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

struts-config.xml

">

 
 
 
   
     
     
   

  

 
 
     

 

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

 

 
 
   
 

login.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib uri="" prefix="bean"%>
<%@ taglib uri="" prefix="html"%>
 

 
  
 
 
  
   username :

   password :

   
  
 

index.jsp

 
   
 
 
 
 Login
 

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

 
  

   
    
   
   
    
   
  

 

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

********************************************************************

现在创建spring框架

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

   
 

修改LoginAction配置

原：

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

改为：

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

 

绿色字体部份为修改内容

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

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

现在来配置spring

">

 

绿色字体是关于转交控制权的配置内容属性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配置了

">

 
  
   com.mysql.jdbc.Driver
  
  
   jdbc:mysql://localhost:3306/test
  
  
   root
  
  
   
  
 

 
  
   
  
  
   
    com\test\Hibernate\User.hbm.xml
   
  
  
   
    net.sf.hibernate.dialect.MySQLDialect
    true
   
  
 

 
  
   
  
 

 
  
   
  
 

 
  
   
  
  
   
  
  
   
    PROPAGATION_REQUIRED
    PROPAGATION_REQUIRED,readOnly
    PROPAGATION_REQUIRED,readOnly
   
  
  

  
   
  
 

现在可以进行测试

3、使用平台：Eclipse3.2、MyEclipse5.01GA
Struts、Spring、Hibernate三个框架在MyEclipse下添加顺序为：
首先新建一个Web Project，

添加Add Struts Capabilities…，设置好包路径后继续；

选择MyEclipse菜单下的Add Spring Capabilities…选择所有的标签库，JAR Library Installation位置选择“Copy”项，下一步，设置Spring Bean配置文件位置，一般就默认在SRC目录，点击完成，就添加了Spring，继续；

（做这步之前最好把在MYSQL中建了DB）切换到MyEclipse Database Explorer（数据库浏览器视图），添加一个数据连接，测试连接成功后继续，(关于这一步的图文说明请参考的loginstruts工程说明)这一步是为了给下面添加Hibernate框架准备的，因为它在建立过程中需要指定一个有效连接数据库的连接；

选择MyEclipse菜单下的Add Hibernate Capabilities…选择反有的标签库，包括Spring的，JAR Library Installation位置还是选择“Copy”项，下一步；因为之前添加了Spring框架，所以这里就会自动识别到，并询问你使用Hibernate的配置文件“hibernate.cfg.xml”还是使用Spring的配置文件“applicationContext.xml”，这里选择Spring来统一配置，下一步；此处是定义Spring配置文件是需要新建还是使用已存在的Spring配置文件，这里选择Existing Spring configuration file，即使用已存在的Spring配置文件“src/applicationContext.xml”,下方需要指定Hibernate的SessionFactory在Spring配置文件中的Bean ID，使用“sessionFactory”即可，下一步；在DB Profile的下拉列表中选择刚刚建立的连接，并在Bean ID处设置这个DataSource在Spring配置文件中的Bean ID名，这里使用“DataSource”，下一步；接下来的Define SessionFactory properties界面是配置Hibernate的SessionFactory工具类存放位置，设置好包路径后，下一步；点击Finish，就完成了对Struts、Spring、Hibernate三个框架的设置。

这里还需要配置Log4J（日志工具），只需将以下两个文件复制到SRC目录下即可
commons-loggingproperties.properties
log4j.properties
至于这两文件里的具体配置就不再多说。

接下来，先完成JSP页面、ActionForm、及Action的添加，添加过程就不再多说。再就是为数据表添加持久化类，过程是在MyEclipse DataBase Explorer中打开连接，找到所需的表后，鼠标右键点击表名，选择“Hibernate Reverse Engineering…”,设置了包路径后，依次钩选“Hibernate Mapping File”、“Java Data Object”（取消钩选“Create abstract class”）以及“Java Data Access Object(DAO)”，在“Java Data Access Object(DAO)”下会自动钩选“Generate precise findby methods”，以及选择“Spring DAO”选项，使用“Spring DAO”后，在DAO类里转而使用了HibernateTemplate对象来操作数据库，据说可以免去事务管理，具体情况，明天再继续研究。生成完持久化类后，需要在Struts-config.xml文件里添加以下字段：
  "org.springframework.web.struts.ContextLoaderPlugIn">
          "contextConfigLocation" value="/WEB-INF/classes/applicationContext.xml"/>

Value值就指定了Spring配置文件applicationContext.xml文件具体包位置。

接着在Action中需要做以下操作：
导入import org.springframework.web.struts.ActionSupport;包
原先Action是继承Action类的，例：
public class EmployeeListAction extends Action
这里将它改为继承ActionSupport类，例：
public class EmployeeListAction extends ActionSupport

生成一个数据表的DAO对象，格式如下：
EmployeeinfoDAO empDao=EmployeeinfoDAO.getFromApplicationContext(this.getWebApplicationContext());       
List empList=empDao.getHibernateTemplate().loadAll(Employeeinfo.class);   

如此就完成了读取一个数据表里所有字段的操作，是不是很简单呢？

 

4、

===============Spring+Hibernate+Struts配置===============
spring加载log4j
   web.xml

   < context - param >
     < param - name > log4jConfigLocation param - name >
     < param - value >/ WEB - INF / classes / log4j.properties param - value >
   context - param >
   < listener >
     < listener - class > org.springframework.web.util.Log4jConfigListener listener - class >
   listener >

一.spring+struts
1.加载springContext
      通过struts-config.xml中增加plug-in插件来加载springContext
  
    
  
   applicationContext.xml为spring的配置文件

2.将strutsAction交给Spring容器进行管理
      修改struts-config.xml中的action属性,action的type值不指定具体的实现类,统一修改成代理类
             name="loginActionForm"
         path="/loginAction" 
         scope="request"   
         type="org.springframework.web.struts.DelegatingActionProxy"
         validate="false">
     
     
   

3.在applicationContext.xml中的bean name值设定与struts-config.xml中action path值相对应,以使代理类DelegatingActionProxy能够根据传入的path在springContext中找到相应的bean,并将实例返回给struts.
name="/loginAction" class="com.derek.action.LoginAction" singleton="false">
 
   
 


二.spring+hibernate
   1.dateSource
      在springContext中设置dateSource Bean
    
       
       
        
       
    
     2.sessionFactory
       在springContext中设置sessionFactory Bean
 
    
    
        
          hbm\OvertimeRecord.hbm.xml>
          hbm\OvertimePermit.hbm.xml
        
    
    
        
           org.hibernate.dialect.SQLServerDialect
           true
           50
           20
       
    
  
 
  3.transactionManager
   在springContext中设置transactionManager Bean
  
    
      
    
  

   4.DAO bean
     
          
             
         
     
      public class Login extends HibernateDaoSupport implements LoginInterface
      DAO 继承HibernateDaoSupport
      HibernateSupport实现了HibernateTemplate和SessionFactory实例的关联, HibernateTemplate对Hibernate Session操作进行了封装，HibernateTemplate.execute方法则是一封装机制的核心. 借助HibernateTemplate我们可以脱离每次数据操作必须首先获得Session实例、启动事务、提交/回滚事务以及烦杂的try/catch/finally的繁琐操作.
        Spring中的事务管理实际上是基于动态AOP机制实现，为了实现动态AOP，Spring在默认情况下会使用Java DynamicProxy，但是，Dynamic Proxy要求其代理的对象必须实现一个接口，该接口定义了准备进行代理的方法。而对于没有实现任何接口的Java Class，需要采用其他方式，Spring通过CGLib实现这一功能。

   5.DAOProxy 代理bean
        通过代理,将上面的DAO bean 纳入到spring容器的事务管理中,并在其中设置对哪些方法进行事务管理
     
           
               
           
           
                
           
           
               
                     PROPAGATION_REQUIRED
                     PROPAGATION_REQUIRED,readOnly
                
           
      
    
    6.action bean
     
         
           
        
     

示例代码:
  struts-conifg.xml

xml version = " 1.0 "  encoding = " UTF-8 " ?>
DOCTYPE struts - config PUBLIC  " -//Apache Software Foundation//DTD Struts Configuration 1.1//EN "   " " >
< struts - config >

   < form - beans >
     < form - bean name = " loginActionForm "  type = " com.derek.form.LoginActionForm "   />
   form - beans >
   < action - mappings >
     < action input = " /login.jsp "  name = " loginActionForm "  path = " /loginAction "  scope = " request "  type = " org.springframework.web.struts.DelegatingActionProxy "  validate = " false " >
       < forward name = " success "  path = " /success.jsp "   />
       < forward name = " failure "  path = " /failure.jsp "   />
     action >
   action - mappings >
   < plug - in className = " org.springframework.web.struts.ContextLoaderPlugIn " >
     < set - property property = " contextConfigLocation "  value = " /WEB-INF/applicationContext.xml "   />
   plug - in >
struts - config >

  applicationContext.xml

class="org.springframework.jdbc.datasource.DriverManagerDataSource">
 
 
 
 


class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
 
 
  
    hbm\OvertimeRecord.hbm.xml
    hbm\OvertimePermit.hbm.xml
  
 
 
  
     org.hibernate.dialect.SQLServerDialect
     true
     50
     20
  
 


class="org.springframework.orm.hibernate3.HibernateTransactionManager">
   
       
   






class="com.derek.business.RecordDao">
  
    
  


class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
  
    
  
  
    
  
  
    
      PROPAGATION_REQUIRED
      PROPAGATION_REQUIRED,readOnly
    
  


Ilogin" class="com.derek.business.Login">
  
    
  


loginBOProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
  
    
  
  
    
  
  
    
      PROPAGATION_REQUIRED
      PROPAGATION_REQUIRED,readOnly
    
  


loginAction" class="com.derek.action.LoginAction" singleton="false">
  
    loginBOProxy" />
  

LoginInterface

package com.derek.myinterface;

public interface LoginInterface {
    public boolean check(String name,String pwd);
}

Login

package com.derek.business;

import com.derek.myinterface.LoginInterface;
import org.hibernate.SessionFactory;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import java.util.List;

public class Login extends HibernateDaoSupport implements LoginInterface{
    private SessionFactory sessionFactory;
    private String hsql = "from OvertimePermit where account=? and password=?";
    public Login() {}
    public boolean check(String name,String pwd){
        String condition[] = {name, pwd};//查询条件
        /**
         * 借助HibernateTemplate我们可以脱离每次数据操作必须首先
         * 获得Session实例 、启动事务、提交/回滚事务以及烦杂的try/catch/finally的繁琐操作
         */       
        List l = this.getHibernateTemplate().find(hsql, condition);
        
        if (l.size() > 0) return true;
          else return false;
    }
}

RecordDaoInterface

package com.derek.myinterface;

import java.util.List;
import hbm.OvertimeRecord;

public interface IRecordDao {
    public List findAll(String hsql);
    public void insert(OvertimeRecord or);
}

RecordDao

package com.derek.business;

import com.derek.myinterface.IRecordDao;
import java.util.List;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import org.hibernate.SessionFactory;
import hbm.OvertimeRecord;

public class RecordDao extends HibernateDaoSupport implements IRecordDao{
    private SessionFactory sessionFactory;
    public RecordDao() {
    }

    public List findAll(String hsql) {
       return this.getHibernateTemplate().find(hsql);
    }

    public void insert(OvertimeRecord or) {
        this.getHibernateTemplate().saveOrUpdate(or);
    }
}

LoginAction通过容器注入的Login实例完成业务操作(必须由接口强制类型转化)

package com.derek.action;

import javax.servlet.http.*;
import com.derek.form.*;
import org.apache.struts.action.*;
import org.apache.log4j.Logger;
import com.derek.myinterface.LoginInterface;

public class LoginAction extends Action {
    private LoginInterface login;
    public ActionForward execute(ActionMapping actionMapping,
                                 ActionForm actionForm,
                                 HttpServletRequest servletRequest,
                                 HttpServletResponse servletResponse) {
        Logger log = Logger.getLogger(this.getClass().getName());
        LoginActionForm loginActionForm = (LoginActionForm) actionForm;
        String name = loginActionForm.getName();
        String pwd = loginActionForm.getPwd();
        boolean TF = login.check(name,pwd);
        if(TF){ log.warn("LoginSuccess------------");;return actionMapping.findForward("success");}
          else{ log.warn("LoginFailure------------");;return actionMapping.findForward("failure");}
    }
    public void setLogin(LoginInterface Ilogin) {this.login = Ilogin;}
    public LoginInterface getLogin() {return login;}
}

类中直接通过Context获得bean实例(必须通过代理类获得实例且由其接口强制类型转化)

package com.derek.pub;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;
import com.derek.myinterface.IRecordDao;
import java.util.List;
import hbm.OvertimeRecord;

public class Untitled1 {
    public Untitled1() {
    ApplicationContext ctx = new FileSystemXmlApplicationContext("applicationContext.xml");
    IRecordDao recordDao = (IRecordDao)ctx.getBean("RecordDaoProxy");
    OvertimeRecord newor = new OvertimeRecord("004104","dada","100120","it","2006/04/02","2006/04/02","001145","david","001145","david","00","00","1","1","1","1");
    newor.setMark("0");
    recordDao.insert(newor);
    List l = recordDao.findAll("from OvertimeRecord");
    for(int i=0;i    OvertimeRecord or = (OvertimeRecord)l.get(i);
    System.out.println(or.getId());
    }
    }
    public static void main(String[] a){
    Untitled1 u = new Untitled1();
    }
}

      一个Spring application context的定义能够被很多种不同的上下文实现所读取， 比如FileSystemXmlApplicationContext 和 ClassPathXmlApplicationContext以及XmlWebApplicationContext。 默认的情况下，一个web应用程序会从”WEB-INF/applicationContext.xml”中得到root context。 在所有的Spring应用中，XML文件中定义的application context会把所有相关的application beans连接起来，包括Hibernate session factory以及数据访问和业务对象（就像上面定义的那些bean）。 它们中的大部分都不会意识到被Spring容器所管理，甚至在同其他bean合作的时候， 因为它们仅仅遵循JavaBeans的规范。一个bean属性及可以表示值参数，也可以是其他的合作bean。 下面的bean定义能够作为Spring web MVC context的一部分，在最基础的 application context中访问business beans。

ApplicationContext context = WebApplicationContextUtils.getWebApplicationContext(servletContext);
ProductService productService = (ProductService) context.getBean("myProductService");
ApplicationContext context =
    new FileSystemXmlApplicationContext("C:/myContext.xml");
ProductService productService =
    (ProductService) context.getBean("myProductService");
ApplicationContext context =
    new ClassPathXmlApplicationContext("myContext.xml");
ProductService productService =
    (ProductService) context.getBean("myProductService");