Spring和Struts的整合

合集下载

Struts2+Spring3+Hibernate4+Maven整合

Struts2+Spring3+Hibernate4+Maven整合目录1.建立Maven工程2.搭建Spring33.搭建Struts2并整合Spring34.搭建Hibernate4并整合Spring3内容1.建立Maven工程第一步：第二步：第三步：第四步：注意：这里的JDK要选择默认的，这样别人在使用的时候，如何JDk不一致的话也不会出错，如下图所示：第五步：Maven标准目录src/main/javasrc/main/resourcessrc/test/javasrc/test/resources第六步：发布项目：Maven install清除编译过的项目：Maven cleanOK,Mean 工程创建成功！2. 搭建 Spring3(1)下载Spring3需要的jar包1.spring-core2.spring-context3.spring-jdbc4.spring-beans5.spring-web6.spring-expression7.spring-orm在pom.xml中编写Spring3需要的包，maven会自动下载这些包。

<dependency><groupId>org.springframework</groupId><artifactId>spring-core</artifactId><version>3.1.2.RELEASE</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>3.1.2.RELEASE</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-jdbc</artifactId><version>3.1.2.RELEASE</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-beans</artifactId><version>3.1.2.RELEASE</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-web</artifactId><version>3.1.2.RELEASE</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-expression</artifactId><version>3.1.2.RELEASE</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-orm</artifactId><version>3.1.2.RELEASE</version></dependency>(2)编写Spring配置文件<?xml version="1.0"encoding="UTF-8"?><beans xmlns="/schema/beans" xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-3.0.xsd /schema/context/schema/context/spring-context-3.0.xsd "><context:property-placeholderlocation="classpath:config.properties"/><context:component-scan base-package="com.zc.dao,com.zc.service" /></beans>(3)编写测试首先，在src/main/java中创建com.zc.service包，在包中编写一个UserService 接口，代码如下：package com.zc.service;/*** 测试* @author ZC* */public interface UserService {public void test();}然后，在src/main/java中创建com.zc.service.imple包，在包中编写UserServiceImple 实现类，代码如下：package com.zc.service.impl;import org.springframework.stereotype.Service;import erService;@Service("userService")public class UserServiceImpl implements UserService {@Overridepublic void test() {System.out.println("Hello World!");}}注意：@Service("userService")使用junit注解完成service 注入，所以还要在pom.xml中配置junit注解。

三大框架整合及其原理

一搭建三大框架步骤1 搭建s2sh步骤分析:1.1在MyEclipse 里面新建一个 java web project1.2新建三个 Source Folder :src : 源文件config : 存放配置文件 : hibernate , spring , struts2test: 测试类1.3 导入环境需要的jar 包 : WebRoot/WEB-INF/lib (一共64个)2 搭建Hibernate 和Spring 整合(*根据搭建需求谁能先测试就先搭建谁)2.1 在 src 源文件里面建立一个 cola.s2sh.domain[并且在该包下创建一个持久类和该类的映射文件] .2.2 配置核心文件在 config 里面建立一个hibernate 文件夹里面创建hibernate.cfg.xml配置文件(里面的内容拷贝就可以)2.3 在spring 文件夹里面创建并且把sessionFactory 交给spring 来管理: [applicationContext-db.xml中引入][<bean id="sessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <property name="configLocation"><value>classpath:hibernate/hibernate.cfg.xml</value> </property></bean>]在 applicationContext.xml 中 : 导入<import resource="applicationContext-db.xml"/>2.4 测试sessionFactory[编写SpringUtils 然后继承这个][public class SpringUtils {public static ApplicationContext context;static {context = newClassPathXmlApplicationContext("spring/applicationContext.xml" );}}]2.5 编写 dao .service 的包类和接口;PersonDaoImpl 要继承HibernateDaoSupport[public class PersonDaoImpl extends HibernateDaoSupport implements PersonDao {public void savePerson(Person person) {this.getHibernateTemplate().save(person);}}]2.6 把 dao ,service 放在spring 容器中:[<bean id="personDao"class="cola.s2sh.daoImpl.PersonDaoImpl"> <property name="sessionFactory"><ref bean="sessionFactory"/></property></bean><bean id="personService"class="cola.s2sh.service.impl.PersonServiceImpl"><property name="personDao"><ref bean="personDao"/></property></bean>]2.7 完成 spring 声明式处理 :[<bean id="transactionManager"class="org.springframework.orm.hibernate3.HibernateTransactionManager"><property name="sessionFactory"><ref bean="sessionFactory"/></property></bean><tx:advice id="tx"transaction-manager="transactionManager"><tx:attributes><tx:method name="save*"read-only="false"/><tx:method name="update*"read-only="false"/><tx:method name="delete*"read-only="false"/><tx:method name="*"read-only="true"/></tx:attributes></tx:advice><aop:config><aop:pointcutexpression="execution(* cola.s2sh.service.impl.*.*(..))"id="perform"/><aop:advisor advice-ref="tx"pointcut-ref="perform"/> </aop:config>]2.8 整合struts 创建 action 类包 ;2.9 把action 放在spring 容器中* 注意在personAction的spring的配置中一定要写一个属性scope="prototype"[<bean id="personAction"class="cola.s2sh.action.PersonAction" scope="prototype"><property name="personService"><ref bean="personService"/></property></bean>]在这个中引入下面3.0 编写struts2中配置文件Struts –person.xml中Struts.xml3.1 编写web .xml文件[<?xml version="1.0"encoding="UTF-8"?><web-app xmlns:xsi="/2001/XMLSchema-instance"xmlns="/xml/ns/javaee"xmlns:web="/xml/ns/javaee/web-app_2_5.xsd"xsi:schemaLocation="/xml/ns/javaee/xml/ns/javaee/web-app_3_0.xsd"id="WebApp_ID"version="3.0"><display-name>cola.s2sh</display-name><listener><listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> </listener><!—将srping放在SrvletContext中进行加载当servlet加载时 spring 也完成加载 --> <context-param><param-name>contextConfigLocation</param-name><param-value>classpath:spring/applicationContext.xml</param-value> </context-param><filter><filter-name>OpenSessionInViewFilter</filter-name><filter-class>org.springframework.orm.hibernate3.support.OpenSessionInViewFilter</filter-class></filter><filter-mapping><filter-name>OpenSessionInViewFilter</filter-name><url-pattern>*.action</url-pattern></filter-mapping><filter><filter-name>struts2</filter-name><filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter -class></filter><filter-mapping><filter-name>struts2</filter-name><url-pattern>/*</url-pattern></filter-mapping>]二原理分析:一、 Struts 2框架整合Spring步骤1、复制文件。

struts2+spring3+hibernate整合教程

Struts2+Spring3+hibernate3整合（2011年7月末，最新）上次下载了一个教程，上面写着：“献给我亲爱的老婆！”（羡慕不已）。

想了想，我没老婆，难道没什么好写了！不难…献给我暗恋过的每一个女人!（嘿嘿…）如果在你遇到的女生中有一个幽默豁达的女生，不要犹豫，追上去，就娶她了！一，需要的框架包二，建立project，添加相应的.jar文件（重点）1，eclipse中建立dynamic web project，这里是ssh_integrate_0100。

2，src中创建需要的类，这里以一个域模型为user的例子说明。

(现在建立这些类，可以方便我们在搭建时候随时测试!)User.javaIUserDao.javaUserDaoImpl.javaIUserService.javaUserServiceImpl.java3，拷贝spring-framework-3.1.0\dist目录下的所有jar包，注意有一个不是jar的文件，当然拷过去也没事。

4，拷贝spring运行中需要的其他jar文件，主要是mons-logging，可以从spring-framework-3.0.2.RELEASE-dependencies中找到。

ii.Aspectjrt.jar和aspect-waver.jar，可以从spring-framework-2.5.6-with-dependencies/lib/aspectj下面找到（不知道为什么，spring-framework-3.0.2.RELEASE-dependencies中没有aspectjrt的jar包）iii.aopalliance.Jar，apache-dbcp.jar，apache-pool.jar，可以从spring-framework-3.0.2.RELEASE-dependencies中找到。

5，建立beans.xml，这里使用的是annotation和component-scan，这样配置可以大大简化配置，所以是best-practice，其他配置请参考spring文档。

struts2+spring3+mybatis整合

--src|-com.ssm|-action|-LoginAction.java|-entity|-User.java|-iface|-IUserDao.java|-impl|-UserDao.java|-seriface|-IUserServices.java|-impl|-UserServices.java|-sqlmap|-User.xmlapplicationContext.xmldatabase.Propertieslog4j.PropertiesmyBatis-config.xmlstruts.Propertiesstruts.xmlok直接上代码了:Action类: LoginAction.javapackage com.ssm.action;import java.util.ArrayList;import java.util.List;import com.opensymphony.xwork2.Action;import er;import com.ssm.seriface.IUserService;public class LoginAction implements Action{private User user;private IUserService userServices;public void setUserServices(IUserService userServices) {erServices = userServices;}public User getUser(){return user;}public void setUser(User user){er = user;}public String execute() throws Exception{String aaa= getUser().getId()+"";List userList= new ArrayList();userList= userServices.selectUserById(getUser().getId()); if(userList.size()>0){return Action.SUCCESS;}else{return Action.ERROR;}}}实体类User.javapackage com.ssm.entity;import java.io.Serializable;import java.util.Date;public class User implements Serializable{private int id;private String name;private String password;private Date birthday;public User(){}public User(String name, String password, Date birthday) {= name;this.password= password;this.birthday= birthday;}public int getId(){return id;}public void setId(int id){this.id = id;}public String getName(){return name;}public void setName(String name){ = name;}public String getPassword(){return password;}public void setPassword(String password){this.password = password;}public Date getBirthday(){return birthday;}public void setBirthday(Date birthday){this.birthday = birthday;}}IUserDao接口类IUserDao.javapackage com.ssm.iface;import java.util.List;public interface IUserDao{public boolean userVaild(String name, String password);public List selectUserById(int id);}UserDaoImpl实现接口类:UserDaoImpl.javapackage com.ssm.iface.impl;import java.util.List;import org.springframework.orm.ibatis.support.SqlMapClientDaoSupport; import com.ssm.iface.IUserDao;//import com.ssb.baseutil.SqlMapClientDaoSupport;//import com.ssb.iface.IUserDao;//import org.springframework.orm.ibatis.support.SqlMapClientDaoSupport; public class UserDaoImpl extends SqlMapClientDaoSupport implements IUserDao {public List selectUserById(int id){// TODO Auto-generated method stubreturn getSqlMapClientTemplate().queryForList("selectUserById", id);}public boolean userVaild(String name, String password){// TODO Auto-generated method stubreturn false;}/*public boolean userVaild(String name, String password){return false;}public List selectUserById(String id){return getSqlMapClientTemplate().queryForList("getUserById", id);}*/}业务类IUserServices.javapackage com.ssm.seriface;import java.util.List;public interface IUserService{public boolean userVaild(String name, String password); public List selectUserById(int id);}UserServicesImpl.javapackage com.ssm.seriface.impl;import java.util.List;import com.ssm.iface.IUserDao;import com.ssm.seriface.IUserService;public class UserServiceImpl implements IUserService{private IUserDao serviceUserDao= null;public IUserDao getServiceUserDao(){return serviceUserDao;}public void setServiceUserDao(IUserDao serviceUserDao) {this.serviceUserDao = serviceUserDao;}public List selectUserById(int id){// TODO Auto-generated method stubreturn serviceUserDao.selectUserById(id);}public boolean userVaild(String name, String password){// TODO Auto-generated method stubreturn erVaild(name, password);}}mybatis实体配置文件User.xml<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE mapper PUBLIC"-////DTD Mapper 3.0//EN""/dtd/mybatis-3-mapper.dtd"><mapper namespace="user"><resultMap type="User" id="userResultMap"><id property="id" column="ID"/><result property="name" column="NAME"/><result property="password" column="PASSWORD"/><result property="birthday" column="BIRTHDAY"/></resultMap><select id="selectUserById" parameterType="ng.String" resultType="User"><![CDATA[SELECT * FROM USER SUWHERE SU.ID = #{id}]]></select></mapper>sprng配置文件applicationContext.xml<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans" xmlns:xsi="/2001/XMLSchema-instance"xmlns:p="/schema/p" xmlns:context="/schema/context"xmlns:jee="/schema/jee" xmlns:tx="/schema/tx"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-2.5.xsd/schema/context/schema/context/spring-context-2.5.xsd/schema/jee/schema/jee/spring-jee-2.5.xsd/schema/tx/schema/tx/spring-tx-2.5.xsd"><context:property-placeholder location="classpath:database.properties"/><bean id="dataSource" class="boPooledDataSource"><property name="driverClass" value="${jdbc.driverClassName}" /><property name="jdbcUrl" value="${jdbc.url}" /><property name="user" value="${ername}" /><property name="password" value="${jdbc.password}" /><property name="autoCommitOnClose" value="true"/><property name="checkoutTimeout" value="${cpool.checkoutTimeout}"/><property name="initialPoolSize" value="${cpool.minPoolSize}"/><property name="minPoolSize" value="${cpool.minPoolSize}"/><property name="maxPoolSize" value="${cpool.maxPoolSize}"/><property name="maxIdleTime" value="${cpool.maxIdleTime}"/><property name="acquireIncrement" value="${cpool.acquireIncrement}"/><property name="maxIdleTimeExcessConnections" value="${cpool.maxIdleTimeExcessConnections}"/> </bean><bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"><property name="dataSource" ref="dataSource"/></bean><bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"><property name="configLocation" value="classpath:myBatis-config.xml"/><property name="dataSource" ref="dataSource"/></bean><bean id="mapDao" class="org.mybatis.spring.MapperFactoryBean"><property name="mapperInterface" value="com.ssm.iface.IUserDao"/><property name="sqlSessionFactory" ref="sqlSessionFactory"/></bean><bean id="userServices" class="erServiceImpl"><property name="serviceUserDao" ref="mapDao"/></bean><bean id="LoginAction" class="com.ssm.action.LoginAction"><property name="userServices" ref="userServices"/></bean></beans>数据库连接属性配置文件(其实可以不用这么复杂)database.Propertiesjdbc.driverClassName=com.mysql.jdbc.Driverjdbc.url=jdbc:mysql://127.0.0.1:3306/ddtest?characterEncoding=utf8 ername=rootjdbc.password=123cpool.checkoutTimeout=5000cpool.minPoolSize=20cpool.maxPoolSize=50cpool.maxIdleTime=7200cpool.maxIdleTimeExcessConnections=1800cpool.acquireIncrement=10log4j 随便到log4j里copy一个吧mybatis-config.xml<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE configuration PUBLIC"-////DTD Config 3.0//EN""/dtd/mybatis-3-config.dtd"><configuration><typeAliases><typeAlias alias="User" type="er"/></typeAliases><mappers><mapper resource="com/ssm/sqlmap/User.xml" /></mappers></configuration>struts配置文件struts.Properties##整合spring的struts.objectFactory=springeClassCache = truestruts.locale=zh_CNstruts.i18n.encoding=GBKstruts的Action配置文件struts.xml<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE struts PUBLIC"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN""/dtds/struts-2.0.dtd"><struts><package name="style" extends="struts-default"><action name="loginAction" class="com.ssm.action.LoginAction"><result name="success">success.jsp</result><result name="error">error.jsp</result></action></package></struts>。

基于Struts+Hibernate+Spring的整合架构及其在Web开发中的应用

可扩展的Ｗｅ用。Ｈｂｒａｂ应ｉｅｔ目前在ＪＶｎｅ是ＡＡ界使用非常广泛的ＯＭａｐｎＲｐｉｇ的一种实现，以实现关系型数据库和对可
象之间的映射。Ｓｒｇｐｎ是为了解决企业应用开发的复杂性而创建的轻量级的框架。本文介绍了三种技术的框架结构和ｉ
ＴＡＮＸｉ — ａＬｈｎＬｈ．ｉ，ＮＧＬ．ｉｎＩｕｙｎ，ＩＺｏｇ，ＵＯＳｉｍｅＤＥｉｑａｇ
（．ｔｅａｃｎｆｒｔｎＣｌｇ，ＮｒｗｓＮｒａＵｉｅｉ，ａｚｏ３００Ｃｎ；１ＭａｍｔｓｄＩｏｉｏｌｅｏｔｅｔｏｌｎｖｒｔＬｎｈｕ７０７，￣ａｈｉａｎｍａｏｅｈｍｓｙ２ＣｉａＴｌｏａｓｎｅＣｍｐｎ，ａｚｏ３００Ｃｉａ．ｈｎｅｃｍＧｎｕＷａｗｉｏａｙＬｎｈｕ７０３，ｈｎ）ｅ
２００８年第１期１
计算机与现代化ＪＵＮＩＹＩＮＡＨＵＩＡＪＵＸＡＤＩＡＳ
总第１９期５
文章编号：０．４５２０）１０５０１６２７（０８１－９－４００
基于Ｓ构及其在ｒｅｅｎＷｅｂ开发中的应用
ＡｐｌａｉｎｉｅｖｌｐｅｔＵｓｓｄｏｔｕｓ＋ＨｉｅｎｔｐｉｔｎＷｂＤｅｅｏｍｎｅＢａｅｎＳｒｔｃｏｂｒａｅ＋Ｓｒｎｐｉｇ
ＩｅｒｔｄＦｒｍｅｒｎｔｇａｅａｗｏｋ

整合struts1+spring+hibernate框架完成简单的登录

*编写环境：*开发工具：Myeclipse6.01*SPRING ：spring2.0*STRUTS ：struts1.2*HIBERNATE：hibernate3.0*JDK: 1.6*TOMCAT: 6.0*WINDOW641.新建web项目。

2.选中新建项目，右键--》选择“myeclipse”--》添加Struts支持。

3.在弹出的信息框，有必要修改一下图中的地方。

4.上面的操作完成之后，打开我们的项目我们可以看到我们的项目结构发生了变化，引入了一些struts标签和生成了struts-config.xml配置文件。

5.开始添加spring支持，同样选中新建项目，右键--》选择“myeclipse”--》“添加spring 支持”，在弹出的信息框，做如下内容修改：6.点击“next”，直接选择默认，当然也可根据自己的规则做修改。

7.在添加“Hibernate”支持的时候，首先做的工作是创建一个数据源。

这个创建方法有很多中（找百度可得）这里只介绍一种：打开你的myeclipse的右上角的小三角，选择“myeclipsedatabase explorer”在弹出的界面中，在如图位置右键“new”在弹出的界面中做如下修改：修改完成后点击“test driver”成功则继续。

8.暂时回到myeclipse开发界面。

正式开始添加“Hibernate”支持。

在弹出的界面中做如图修改：点击“next”这里如图，选择spring的配置文件。

下一步操作后，做如下图修改操作：下一步之后，界面修改操作，如下图：去掉复选框中的选项，然后点击“finish”完成整个操作。

之后将会直接打开spring的配置文件，然后你核对一下您的数据库连接是否正确。

至此三大支持操作完成，启动没有问题说明框架雏形已经完成。

9.在项目中的WEB-INF下找到web.xml,做如下修改：格式头部分省略，下面是需要新增的代码<context-param><param-name>contextConfigLocation</param-name><param-value>classpath:applicationContext.xml</param-value></context-param><listener><listener-class>org.springframework.web.context.ContextLoaderListener</list ener-class></listener><filter>Ps ：这个时候我们再次启动服务的时候，发现可能会报错：因为我们在刚才已经把spring 的配置文件做了初始化，而在spring 的配置文件中有数据源的连接，而我们的项目中可能还缺少一个包：commons-pool-1.4.jar(/detail/u013806366/7897665 )当我们把这个包放在lib 下，我们再次启动项目的时候，错误信息应该会消失。

ssh框架原理及流程

ssh框架原理及流程SSH框架原理及流程。

SSH框架是指Struts、Spring、Hibernate三大开源框架的整合，它们分别解决了Web层、业务逻辑层和数据访问层的开发问题。

SSH框架的整合，旨在充分发挥各自框架的优势，实现高效、灵活、可维护的Web应用程序开发。

在本文中，我们将深入探讨SSH框架的原理及流程。

首先，我们来了解一下SSH框架各个组成部分的原理。

Struts作为Web层框架，它采用MVC（Model-View-Controller）设计模式，将应用程序分为模型、视图和控制器三层，实现了数据、展示和控制的分离，提高了代码的复用性和可维护性。

Spring作为业务逻辑层框架，它提供了IoC（控制反转）和AOP（面向切面编程）等功能，通过IoC容器管理对象之间的依赖关系，实现了松耦合，降低了组件之间的耦合度。

Hibernate作为数据访问层框架，它提供了ORM（对象关系映射）功能，将Java对象和数据库表之间建立映射关系，实现了面向对象的数据访问，简化了数据库操作。

接下来，我们来了解SSH框架的整合流程。

首先，我们需要在项目中引入Struts、Spring、Hibernate的相关jar包，并配置它们的配置文件。

在web.xml中配置DispatcherServlet，用于拦截所有的请求，然后将请求分发给对应的Controller处理。

在Spring的配置文件中配置业务逻辑层和数据访问层的Bean，以及事务管理器等。

在Hibernate的配置文件中配置数据源、SessionFactory等。

然后，我们需要编写业务逻辑层和数据访问层的代码，并在Controller中调用业务逻辑层的方法，最终将数据返回给视图层进行展示。

在SSH框架中，我们可以充分利用Struts的表单验证、Spring的事务管理、Hibernate的持久化操作等功能，实现了Web应用程序的快速开发。

同时，SSH框架也提供了良好的扩展性，我们可以根据项目的需要，灵活地替换其中的某个框架，而不影响整体架构。

Struts+Spring+Hibernate整合入门详解

3、运行eclipse，选择一个空目录作为工作区（工程结构如下：其中我们要写的Java代码在Java Resource: src（以后直接称src）下，网站根目录内容在WebContent下，类所在根目录是WEB-INF/classes，Eclipse 会自动将build/classes里面已经编译的类同步过去。

向WEB-INF下的lib目录添加如下所列的jar包。

（1）这些包在下载解压后Spring，Struts，Hibernate的lib目录或者dist/module目录下面（如果不在，可以到网上google一把。

列表中mysql-*.jar包是MySQL数据库的JDBC Driver）。

也可以把所有lib和dist 下的jar包拷贝过来（可以在系统复制这些jar包，然后到Eclipse里面选中WEB-INF里面的lib包，然后粘帖就可以了）。

但要注意全拷贝可能会存在冲突，如struts*plugin.jar等包不能引入，否则不能运行。

（2）这些Jar包是：antlr-2.7.2.jarcglib-nodep-2.1_3.jarcommons-beanutils-1.6.jarcommons-chain-1.1.jarcommons-collections-2.1.1.jarcommons-dbcp.jarcommons-digester.jarcommons-logging-1.0.4.jarcommons-logging-api-1.1.jarcommons-pool.jarcommons-validator-1.3.0.jardom4j-1.6.1.jarel-api.jarel-ri.jarfreemarker-2.3.8.jarhibernate3.jarjsf-api.jarjta.jarmysql-connector-java-3.0.14-production-bin.jarognl-2.6.11.jaroro-2.0.8.jarspring-hibernate3.jarspring.jarstruts-config.xmlstruts-core-1.3.5.jarstruts2-codebehind-plugin-2.0.9.jarstruts2-config-browser-plugin-2.0.9.jarstruts2-core-2.0.9.jarstruts2-jasperreports-plugin-2.0.9.jarstruts2-jfreechart-plugin-2.0.9.jarstruts2-jsf-plugin-2.0.9.jarstruts2-pell-multipart-plugin-2.0.9.jarstruts2-plexus-plugin-2.0.9.jarstruts2-sitegraph-plugin-2.0.9.jarstruts2-sitemesh-plugin-2.0.9.jarstruts2-spring-plugin-2.0.9.jarstruts2-struts1-plugin-2.0.9.jarstruts2-tiles-plugin-2.0.9.jartiles-api-2.0.4.jartiles-core-2.0.4.jartiles-jsp-2.0.4.jarindex.jsp的内容如表，我们暂时不分析。

Struts,Spring,Hibernate框架的整合与研究

Ｓｒｔｐｉｇｉｅｎｔ框架的整合与研究ｔｕｓＳｒ，Ｈｂｒａｅｎ
刘东旭马亚琦河南质量工程职业学院信息工程系河南平顶山４００６７０
【要】摘本文介绍了以Ｓｒｇ为基础，ｐｉｎ结合Ｓｒｔ和Ｈｂｒａｅｔｓｕｉｎｔ形成一个表示层、业务层、持久层的Ｗｂ决方案，ｔｕｓ＋ｉｒａｅＳｒｇｅｅ解ＳｔＨｂｎｔ＋ｐｉｒｅｎ
中图分类号：ＴＰ９文献标识码：Ｂ文章编号：１０ —０７２ｌ）５１ — ２３３０９４６（０１０ —２５０
１引言
Ｊｖａａ作为建立企业级应用平台的标准，ａａＥ得到了迅速的发展。ＪｖＥＪｖＥ规范包含了多项框架技术，统开发人员可以通过使用框架很容易地ａａＥ系构建起成熟而又稳定的基础架构，从而将更多的精力放到业务逻辑设计上。在诸多框架中，目前，Ｓｒｔ、Ｓｒｎ以ｔｕｓｐｉｇ和Ｈｉｅｎｔ最为流行。为了降低ｂｒａｅ代码的耦合性，高系统的开发效率，文提出了一种基于Ｓｒｔ、ｐｉｇ提本ｔｕｓＳｒｎ
Ｓｒｇ是一个以依赖注入（Ｃ原则和面向方面编程思想（Ｐ为基础ｐｉｎＩ）ｏＡＯ）的轻量级框架。ｏＩＣ是一个用于 “ 基于组件的体系结构 ”的设计模式，它将
３２添加Ｓｒｇ框架．ｐｉｎ

struts2+spring+hibernate整合步骤

引用struts2、hibernate、spring所需jar包struts-core-2.x.x.jar ----struts核心包xwork-core-2.x.x.jar -----身体ruts在其撒很难过构建ognl-2.6.x.jar ----对象导航语言freemarker-2.3.x.jar ------struts2的ui标签的模板使用commons-fileupload-1.2.x.jar ----文件上传组件 2.1.6版本后需加入此文件struts-spring-plugin-2.x.x.jar ---用于struts2继承spring的插件hibernate核心安装包下的（下载路径：/ ，点击Hibernate Core 右边的download）hibernate2.jarlib\bytecode\hibernate-cglib-repack-2.1_3.jarlib\required\*.jarhibernate安装包下的（下载路径：/;点击Hibernate Annotations 右边的下载）hibernate-annotations.jarlib\ejb3-persistence.jar、hibernate-commons-annotations.jar hibernate针对JPA的实现包（下载路径：/ ，点击Hibernate Entitymanager右边下载）hibernate-entitymanager.jarlib\test\log4j.jar、 slf4j-log4j12.jarspring安装包下的dist\spring.jarlib\c3p0\c3p0-0.9.1.2.jarlib\aspecti\aspectjweaver.jaraspectjrt.jarlib\colib\cglib-nodep-2.1_3.jarlib\j2ee\common-annotations.jarvlib\log4j\log4j-1.2.15.jarlib\jakarta-commons\commons_loggin.jar数据库驱动包引用创建mysql数据库ssh 设置编码为utf-8 语句：create database ssh character set 'utf8' collate 'utf8_general_ci'引用1.先整合spring和hibernate*将spring和hibernate的jar包放入lib下；*创建spring的beans.xml配置文件Java代码1.<?xml version="1.0" encoding="UTF-8"?>2.<beans xmlns="/schema/beans"3. xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"4. xmlns:aop="/schema/aop"xmlns:tx="/schema/tx"5. xsi:schemaLocation="/schema/beans6./schema/beans/spring-beans-2.5.xsd7. /schema/context8./schema/context/spring-context-2.5.xsd 9. /schema/aop/schema/aop/spring-aop-2.5.xsd10. /schema/tx/schema/tx/spring-tx-2.5.xsd">11.12. 13. 16. <context:component-scanbase-package="com.yss"></context:component-scan>17.18.19. 20. 21. <bean id="dataSource"class="boPooledDataSource"22. destroy-method="close">23. <property name="driverClass"value="org.gjt.mm.mysql.Driver" />24. <property name="jdbcUrl"25.value="jdbc:mysql://localhost:3306/ssh?useUnicode=true&characterE ncoding=UTF-8" />26. <property name="user" value="root" />27. <property name="password" value="root" />28. <!--初始化时获取的连接数，取值应在minPoolSize与maxPoolSize 之间。

struts2+hibernate+spring经典整合实例教程

Struts2与Spring、Hibernate三者整合的过程示例：示例工具：MyEclipse 7.0、Tomcat 6.0、MySql步骤：1.创建一个WEB工程，命名为BookShop（名字自己取，此处为示例工程名）；2.导入struts2的核心jar包，也就是在WEB-INF下的lib文件夹中放入jar包文件，如下图（图中jar包为示例版本）：3.加载spring，选中工程名，右击并选择【MyEclipse】选项下的【Add Spring Capabilities...】（或者在工具栏中选择【MyEclipse】下的【Add Spring Capabilities...】），在弹出的对话框中进行如下图所示操作：点击【Next】，点击Folder文本框后的【Browse】，在弹出对话框中选择spring配置文件存储位置为WEB-INF 文件夹，如下图所示：点击【OK】后，再点击【Finish】完成。

至此，已经完成加载spring，在WEB-INF文件夹下已经生成了配置文件applicationContext.xml。

4.加载Hibernate，选择【MyEclipse】下的【Add Hibernate Capabilities...】，在弹出对话框中进行如下图所示操作：点击【Next】后，选择Existing Spring configuration file单选框，在SessionFactory Id文本框中填入"sessionFactory"，如下图所示：点击【Next】，进行如下图所示操作：该操作中，只需在Bean Id文本框中输入一个Id名，作为数据库源的代用名，意义不大。

然后在DB Driver 下拉列表中，选择MyEclipse中创建好的数据库源xiaoqi，其他信息将自动填写。

点击【Next】，在弹出对话框中去掉Create SessionFactory class?复选框，不创建该类，点击【Finish】完成（创建过程中，加载的jar包文件可能有重复，所以这个时候如果提示有某些jar包重复，问全部保存【Keep Exiting】，还是替换掉【Replace】，可以选择替换掉【Replace】）。

基于MVC模式的struts和spring框架的分析及整合

基于M V C模式能J St r ut s和Spr i ng框架的分析及整合任仁(同济大学软件学院上海200092)【攘要】简单介鲠[J2E E，详述州C模式中N odel，V i ew以及C ont r o l l er之间的关系。

对目前-eb应用开发中的两个流行框架st r u t s和spr i ng进行了分析。

针对这两个框架的优点和不足，提出一个将两种框架分层应用、整合形成的新框架。

新的框架充分利用St r u t s、Spr i ng框柴技术的各层的优点，弥补之前两个框架中的不足。

【关键词】J2E E i f fC模式St r u t s框架Spri ng框架整合中图分类号：TP3文献标识码：A文章编号；1671--7597(2008)I”0051--01一、J2E E胃介J2EE(J ava2E nt er pr i s e E di t i on)是建立在J ava2qz台上的企业级应用的解决方案。

J2E E技术的基础便是Jav a2平台，不但有J2SE平台的所有功能，同时还提供r对EJB，Ser v l et，JSp，xM L等技术的全面支持，其最终目标是成为一个支持企业级应用开发的体系结构，简化企业解决方案的开发，部署和管理等复杂问题。

事实上，J2EE已经成为企业级开发的工业标准和首选平台。

J2E E并非一个产品，而是～系列的标准。

=、M vC设计文式M V C英文即(M ode l一V i ew-C ont r ol l e r)，即把一个应用的输入、处理、输出流程按照M o del、V i ew、C ont r ol l e r的方式进行分离，这样一个应用被分成三个层模型层、视图层、控制层。

视图(vi m代表用户交互界面，对于W eb应用来说，可以概括为H TM L界面。

但有可能为X H T M L、X M L和A ppl e t。

模型(M ode l)就是业务流程／状态的处理以及业务规则的制定。

基于MVC模式的Struts和Spring整合框架的研究与应用

ｏｔｕｔｎｄＳｉｇｂｓｄｏＶＣｆＳｒｓａｐｒｎａｅｎＭ
ＬＵＸ一ｓ。Ｉ吨ＬＯＸ —ｊＵｉ
（ｏｅＥｕａｏｅｈｏｇｅｔ．ｅｔｌｏｔＵｉｒｔ．ｈｎｓａ１０５ｈｎＩＭｄｍｄｃｔｎＴｃｎｌｙＣｎｅＣｎｒｕｈｎｖｓｙＣｓｇｈ０７。ＣｉａｉｏｒａＳｅｉ４
个将两种框架分层应用并且无缝整合形成的新框架，分利用框架技术的各层的优点．现有系统作了针对性的改进，充对验证了整合的新框架在Ｗｅ发应用中的可行性．ｂ开
关键词：ｔｔ；ＳｒｇＭＣ；构；ｂ应用Ｓｒｓｐｉ；Ｖ架ｕｎＷｅ
【ｂｔａｔＴｏｐｐｌｒｈｅｔｅｏＳｕｎｐｎｕｒｎＷｅｐｌａｏｄｅｐｉｔｎａｅａａｙｄＡｓｃ】ｗｏｕｒｃｉｃｒｓｆｔｔａｄＳｒｇｉｃｒｔｂａｐｃｔｎａｘｌｔｉｒｎｌｅ．ｒａａｔｕｒｓｉｎｅｉｉｎｏａｏｚ
成本、强程序的可维护性和可扩展性．文主要研究了ｗｅ增本ｂ开发中基于ＭＶＣ模式的Ｓｕｔｔｒｓ框架和
Ｓｒｇ架，ｐｎ框ｉ针对其特点和不足提出了按Ｗｅｂ应用分层选择框架并进行整合的方法，可能的让框架技尽术的优点最大限度发挥在每一层中．对一个既有系统进行改进，Ｓｒｔ架构表示层，Ｓｒｇ架构业针用ｔｓｕ用ｐｎｉ务层，并将这两个框架无缝地连接，到了明显的改进，得也进一步验证了Ｗｅ应用整合框架的可行性．ｂ

SSH_三大框架介绍

SSH_三大框架介绍SSH是指Struts、Spring和Hibernate三个开源框架的整合，其中每个框架都有自己的设计思想和特点，通过整合，可以充分发挥它们的优势，提高开发效率和系统性能。

下面将分别介绍这三个框架。

1. Struts：Struts是一个基于MVC设计模式的Web应用程序框架，它将应用程序分为三个层：模型（Model）、视图（View）和控制器（Controller）。

模型负责处理业务逻辑，视图负责展示数据，控制器负责接收用户输入和导航请求。

Struts通过配置文件定义请求的映射和处理逻辑，通过统一的控制器Servlet接收请求，根据配置文件将请求转发给相应的Action。

在Action中进行请求处理和业务逻辑的实现。

2. Spring：Spring是一个轻量级的IoC（Inverse of Control）容器和应用程序框架，它主要解决企业应用中的复杂性问题。

Spring的核心思想是面向接口编程和依赖注入。

通过Spring的IoC容器管理对象的生命周期和依赖关系，将对象的创建和销毁过程交给容器处理。

通过依赖注入，可以将对象之间的依赖关系解耦，提高代码的可维护性和可测试性。

Spring还提供了丰富的功能模块，如AOP（Aspect-Oriented Programming）框架、事务管理、远程调用等，可以在应用程序中灵活地配置和使用。

Spring的优点是具有良好的灵活性和扩展性，可以与其他框架进行无缝集成，支持多种数据库和应用服务器。

同时，Spring还提供了很强的层次化管理和面向切面编程的能力，使得开发人员可以更加精细地控制应用程序的流程和行为。

3. Hibernate：Hibernate是一个开源的对象关系映射框架，用于将Java对象映射到关系数据库中的表结构上。

Hibernate通过配置文件和注解，提供了一种方便的方式来实现数据的持久化和检索。

Hibernate根据对象的映射关系，自动生成相应的SQL语句，实现了对象与数据库之间的映射和转换。

第4章 Spring+Struts+Hibernate+事务(理论)

用“,”分隔
/WEB-INF/classes/applicationContext_biz_user.xml,
/WEB-INF/classes/applicationContext_biz_emp.xml,
/WEB-INF/classes/applicationContext_biz_card.xml
</property>
连接Oracle 的URL
<property name="dialect"> org.hibernate.dialect.Oracle9Dialect
Oracle的数据库方言
</property>
<property name="myeclipse.connection.profile">myOracle_DB</property>
</param-value>
</context-param> <listener>
<listener-class>
所有以applicationContext
开头的配置文件
org.springframework.web.context.ContextLoaderListener
</listener-class>
</servlet-mapping>
2.2 Spring整合Hibernate
连接Oracle数据库的方式
<property name="ername">lang</property>
<property name="connection.url"> jdbc:oracle:thin:@localhost:1521:myOracle

Struts2.3.1.2+Spring3.3.1+Hibernate4.1.1 配置步骤

一．搭建struts-2.3.1.21.Jar包：2.配置struts2.3的过滤器，web.xml位置3.web.xml<?xml version="1.0"encoding="UTF-8"?><web-app id="WebApp_ID"version="3.0"xmlns="/xml/ns/javaee"xmlns:xsi="/2001/XMLSchema-instance" xmlns:web="/xml/ns/javaee/web-app_2_5.xsd "xsi:schemaLocation="/xml/ns/javaee/xml/ns/javaee/web-app_3_0.xsd"><filter><filter-name>struts2</filter-name><filter-class>org.apache.struts2.dispatcher.ng.filter.Struts PrepareAndExecuteFilter</filter-class></filter><filter-mapping><filter-name>struts2</filter-name><url-pattern>/*</url-pattern></filter-mapping></web-app>4.配置struts.xml<?xml version="1.0"encoding="UTF-8"?><!DOCTYPE struts PUBLIC"-//Apache Software Foundation//DTD Struts Configuration 2.3//EN""/dtds/struts-2.3.dtd"><struts><package name="ssh"extends="struts-default,json-default,jfreechart-default,s pring-default"><action name="login"class="loginAction"><result name="ok">/loginOk.jsp</result><result name="error">/loginError.jsp</result></action></package></struts>5.测试struts二．整合Spring 3.1.1和Struts-2.3.1.21.jar包在配置好的strutsjar的基础上，添加额外Struts jar包：struts2-spring-plugin-2.3.1.2.jarcommons-logging-1.1.1.jarSpring的jar包：org.springframework.core-3.1.1.RELEASE.jarorg.springframework.context-3.1.1.RELEASE.jarorg.springframework.beans-3.1.1.RELEASE.jarorg.springframework.asm-3.1.1.RELEASE.jarorg.springframework.expression-3.1.1.RELEASE.jarorg.springframework.web-3.1.1.RELEASE.jar2.web.xml<?xml version="1.0"encoding="UTF-8"?>web-app id="WebApp_ID"version="3.0"xmlns="/xml/ns/javaee"xmlns:xsi=/2001/XMLSchema-instancexmlns:web="/xml/ns/javaee/web-app_2 _5.xsd"xsi:schemaLocation="/xml/ns/javaee /xml/ns/javaee/web-app_3_0.xsd"><filter><filter-name>struts2</filter-name><filter-class>org.apache.struts2.dispatcher.ng.filter.Str utsPrepareAndExecuteFilter</filter-class></filter><filter-mapping><filter-name>struts2</filter-name><url-pattern>/*</url-pattern></filter-mapping><listener><listener-class>org.springframework.web.context.ContextLoaderListener</listener-class></listener><context-param><param-name>contextConfigLocation</param-name><param-value>/WEB-INF/classes/applicationContext.xml</par am-value></context-param></web-app>3.配置springapplicationContext.xml<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:p="/schema/p"xmlns:tx="/schema/tx"xmlns:context="/schema/context"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-3.0.xsd/schema/tx/schema/tx/spring-tx-3.0.xsd/schema/aop/schema/aop/spring-aop-3.0.xsd/schema/context/schema/context/spring-context-3.0.xsd"> <context:annotation-config /><context:component-scan base-package="com.excel" /></beans>三．整合Hibernate4.1.11.jar包添加Hibernate jar文件Hibernate压缩包中的lib/required/antlr-2.7.7.jardom4j-1.6.1.jarhibernate-commons-annotations-4.0.1.Final.jarhibernate-core-4.1.1.Final.jarhibernate-jpa-2.0-api-1.0.1.Final.jarjavassist-3.15.0-GA.jarjboss-logging-3.1.0.GA.jarjboss-transaction-api_1.1_spec-1.0.0.Final.jar lib/jpa/hibernate-entitymanager-4.1.1.Final.jarlib/optional/c3p0/hibernate-c3p0-4.1.1.Final.jarc3p0-0.9.1.jarSpring中的jar文件org.springframework.aop-3.1.1.RELEASE.jarorg.springframework.jdbc-3.1.1.RELEASE.jarorg.springframework.orm-3.1.1.RELEASE.jarorg.springframework.transaction-3.1.1.RELEASE.jar 其他的Spring支持文件aopalliance.jar -- AOP要用到的jar包以及连接db2的jarDb2jcc.Jar以及支持el表达式的standard.jar2.配置文件<?xml version="1.0"encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:jee="/schema/jee"xmlns:tx="/schema/tx"xmlns:aop="/schema/aop"xmlns:p="/schema/p"xmlns:util="/schema/util"xmlns:tool="/schema/tool" xmlns:context="/schema/context"xsi:schemaLocation="/schema/beans /schema/beans/spring-beans.xsd/schema/tx/schema/tx/spring-tx.xsd/schema/aop/schema/aop/spring-aop.xsd/schema/jee/schema/jee/spring-jee.xsd/schema/context/schema/context/spring-context.xsd /schema/util/schema/util/spring-util.xsd/schema/tool/schema/tool/spring-tool.xsd"default-lazy-init="true"default-autowire="byName"> <bean id="dataSource"class="boPooledDataSource"destroy-method="close"><property name="driverClass"value="com.ibm.db2.jcc.DB2Driver" /><property name="jdbcUrl"value="jdbc:db2://192.168.1.35:50000/ZL_DEMO"/><property name="user"value="db2admin"/><property name="password"value="Forwor888"/></bean><bean id="sessionFactory"class="org.springframework.orm.hibernate4.LocalSessionFactoryBean"><property name="dataSource"><ref local="dataSource"/></property><property name="hibernateProperties"><props><prop key="hibernate.show_sql">true</prop><prop key="hibernate.format_sql">true</prop><propkey="hibernate.dialect">org.hibernate.dialect.DB2Dialect</prop> </props></property><property name="mappingResources"><list><value>com/forwor/ssh/entity/xml/User.hbm.xml</value></list></property></bean><bean id="userDAO"class="erDAOImpl"> <property name="sessionFactory"><ref local="sessionFactory"/></property></bean><bean id="userBiz"class="erBizImpl"> <property name="userDAO"><ref local="userDAO"/></property></bean><bean id="transactionManager"class="org.springframework.orm.hibernate4.HibernateTransactionManager "><property name="sessionFactory"><ref local="sessionFactory"/></property></bean><bean id="transactionInterceptor"class="org.springframework.transaction.interceptor.TransactionInterce ptor"><property name="transactionManager"><ref local="transactionManager"/></property><property name="transactionAttributes"><props><prop key="register">PROPAGATION_REQUIRED</prop><prop key="get*">PROPAGATION_REQUIRED,readOnly</prop><prop key="find*">PROPAGATION_REQUIRED,readOnly</prop><prop key="select*">PROPAGATION_REQUIRED,readOnly</prop><prop key="query*">PROPAGATION_REQUIRED,readOnly</prop><prop key="sync*">PROPAGATION_REQUIRED</prop><prop key="finish*">PROPAGATION_REQUIRED</prop><prop key="add*">PROPAGATION_REQUIRED</prop><prop key="insert*">PROPAGATION_REQUIRED</prop><prop key="edit*">PROPAGATION_REQUIRED</prop><prop key="update*">PROPAGATION_REQUIRED</prop><prop key="save*">PROPAGATION_REQUIRED</prop><prop key="remove*">PROPAGATION_REQUIRED</prop><prop key="delete*">PROPAGATION_REQUIRED</prop><propkey="*">PROPAGATION_REQUIRED,ng.Exception</prop></props></property></bean><bean id="ProxyCreator"class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyC reator"><property name="beanNames"><list><value>*Biz</value></list></property><property name="interceptorNames"><list><value>transactionInterceptor</value></list></property></bean><bean id="loginAction"class="com.forwor.ssh.web.LoginAction" scope="prototype"><property name="userBiz"><ref local="userBiz"/></property></bean></beans>。

Eclipse下SSH2框架搭建详细

一、Struts2和Spring整合,创建一个OA工程1、整合struts21)导入strut2的jar 包:commons-logging-1.0.4.jar,freemarker-2.3.8.jar,ognl-2.6.11.jar,struts2-core-2.0.12.jar,xwork-2.06.jar。

暂时导入这些jar包，到时候需要再倒入。

2)将struts.xml文件放置在OA工程的src目录下。

3)在web.xml里面配置struts2用到的核心过滤器。

Xml代码<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>2、整合spring1)导入spring的jar包:spring.jar2)将applicationContext.xml文件放置在OA工程的WEB-INF目录下。

3)在web.xml里面配置spring用到的监听器。

Xml代码<listener><listener-class>org.springframework.web.context.ContextLoaderListener</listener-class></listener>4)添加struts2-spring整合的插件:struts2-spring-plugin-2.0.12.jar,如果不使用这个插件，则需要在struts.xml里面配置:Xml代码<constant name="struts.objectFactory" value="org.apache.struts2.spring.StrutsSpringObjectFactory" />3、测试struts2和spring整合对不对?写一个jsp页面login.jsp来测试:Html代码<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%><%@ taglib prefix="s" uri="/struts-tags" %><!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "/TR/html4/loose.dtd"><html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>Insert title here</title></head><body><s:form action="Login" method="post"><s:textfield name="userName" label="userName"></s:textfield><s:password name="password" label="password"></s:password><s:submit label="submit"></s:submit></s:form></body></html>写一个LoginActionJava代码package com.struts2.action;import com.opensymphony.xwork2.ActionSupport;import com.struts2.service.LoginService;public class LoginAction extends ActionSupport {private LoginService loginService;private String userName;private String password;public void setLoginService(LoginService loginService) {this.loginService = loginService;}public String getUserName() {return userName;}public void setUserName(String userName) {erName = userName;}public String getPassword() {return password;}public void setPassword(String password) {this.password = password;}@Overridepublic String execute() throws Exception {if(loginService.isLogin(userName, password))return SUCCESS;elsereturn INPUT;}}写一个ServiceJava代码package com.struts2.service;public interface LoginService {boolean isLogin(String userName,String password);}写一个Service的实现Java代码package com.struts2.service.impl;import com.struts2.service.LoginService;public class LoginServiceImpl implements LoginService {public boolean isLogin(String userName, String password) { if("hello".equals(userName) && "world".equals(password)) return true;elsereturn false;}}在struts.xml里面配置:Xml代码<package name="struts2" extends="struts-default"><action name="Login" class="loginAction"><result name="success">/result.jsp</result><result name="input">/login.jsp</result></action></package>在applicationContext.xml里面配置:Xml代码<bean id="loginService" class="com.struts2.service.impl.LoginServiceImpl"></bean><bean id="loginAction" class="com.struts2.action.LoginAction" scope="prototype"> <property name="loginService" ref="loginService"></property></bean>启动tomcat，分别输入hello和world，提交,结果为hello和world。

Struts2_spring整合

Struts_spring整合第一步：建立WEB工程Spring_Struts2第二步：①导入struts2支持的JAR包：将struts-2.1.8.1-all\struts-2.1.8.1\apps\struts2-blank-2.1.8.1\WEB-INF\lib下的所有JAR包（6个jar 包，是struts必要的包）拷入到工程目录下的WEB-INF/lib目录下，如果没有看到你拷入的JAR包需要强制加载（这一步指的是如果包导入到lib下后仍然存在WEB-INF/lib下而没有在工程下出现Referenced Liberaries这一项则需要选中lib文件夹，单击右键，Build Path,Configure Build Path，在弹出的对话框中选择Order and Export,Select All,确定）。

②此外还需要struts2-spring-plugin-2.1.8.1.jar支持包，整合spring与struts2所必需的JAR 包，它位于struts-2.1.8.1-all\struts-2.1.8.1\lib目录下第三步：拷贝配置文件web.xml,struts.xml,它们分别位于路径：①struts-2.1.8.1-all\struts-2.1.8.1\apps\struts2-blank-2.1.8.1\WEB-INF（web.xml所在位置）拷贝Web.xml文件到工程的Web-INF路径下。

Web-INF路径下是受保护的，不会被访问到，保证数据的安全。

②struts-2.1.8.1-all\struts-2.1.8.1\apps\struts2-blank-2.1.8.1\WEB-INF\classes（struts.xml所在位置）拷贝struts.xml文件到工程的src文件下并删除<Struts>标签内的内容，它用于配置action。

内部有一个包含文件<include file="com/ibm/struts/conf/struts_user.xml"/>，这段代码表示，struts.xml中的包含文件是com/ibm/struts/conf包下的struts_user.xml。

struts2+spring+hibernate整合时所需的jar包

struts2+spring+hibernate整合时所需的jar包[java]view plaincopy1.1. //struts2核心包2.2. struts2-core-2.0.11.2.jar3.3.4.4. //struts2必须 (strust2 webwork的升级，webwork核心包)5.5. xwork-2.0.5.jar6.6.7.7. //struts2必须8.8. freemarker-2.3.8.jar9.9.10.10. //struts2必须11.11. ognl-2.6.11.jar12.12.13.13. //struts2整合Spring插件14.14. struts2-spring-plugin-2.0.11.2.jar15.15.16.16. //Spring整体包17.17. spring.jar18.18.19.19. //Hibernate必须使用，注意此包是包含全部的。

20.20. hibernate3.jar21.21.22.22. //如果使用C3P0数据源实现数据库连接23.23. c3p0-0.9.0.4.jar24.24.25.25. //Mysql JDBC驱动26.26. mysql-connector.jar27.27.28.28. //如果不用，启动时不会出错，但使用Dwr时，会抛出异常：ng.NoClassDefFoundError: antlr/ANTLRException29.29. antlr-2.7.2.jar30.30.31.31. //如果不用此包，在启动时会抛出： nested exception is ng.NoClassDefFoundError: org/o bjectweb/asm/Type32.32. asm.jar33.33.34.34.35.35. //如果不用此包，在启动时抛出：nested exception is ng.NoClassDefFoundError: net/sf/cgli b/proxy/CallbackFilter36.36. cglib-2.1.3.jar37.37.38.38. //如果不用此包，在启动时抛出：nested exception is ng.NoClassDefFoundError: org/apach e/commons/collections/SequencedHashMap39.39. commons-collections-3.1.jar40.40.41.41. //这个似乎可以不用的（用于上传下载）42.42. commons-fileupload-1.2.1.jar43.43.44.44. //这个就不用说啦，几乎所有框架都要使用的45.45. commons-logging-1.0.4.jar46.46.47.47. //如果不用此包会抛出：ng.NoClassDefFoundError:org/dom4j/DocumentException48.48. dom4j-1.6.1.jar49.49.50.50. //dwr必须51.51. dwr.jar52.52.53.53.54.54. //不用此包，在启动时抛出：ng.NoClassDefFoundError:javax/transaction/TransactionM anager55.55. jta.jar56.56.57.57. //如果想用junit测试，必须。

第9章 Spring与Struts2、Hibernate框架的整合

第9章Spring与Struts2、Hibernate框架的整合基础一、搭建Struts框架注：导入的jar包与前面课程介绍的不同二、搭建Spring框架1.添加的类库包括AOP、Core、Persistent Core、JDBC、Web库2.修改applicationContext.xml的存储目录为WebRoot/WEB-INF三、搭建hibernate框架1.建立数据库连接2.搭建框架，注意选择的配置文件为applicationContext.xml而不是hibernate.cfg.xml。

1）设置SessionFactory的Bean id为sessionFactory。

2）设置DataSource的Bean Id为dataSource3）取消“Create SessionFactory class”选项4）导入包commons-pool-1.3到lib文件夹。

四、修改web.xml加入Spring监听器配置，至此所有框架搭建完毕。

<listener><listener-class>org.springframework.web.context.ContextLoaderListener</listener-class></listener>五、数据库建表六、在工程下创建domain、dao包，反向工程自动生成实体类、配置文件、dao类。

1）反向工程将生成的dao文件2）移动dao类到dao包，修改由于移动dao类后applicationContext.xml出现的错误，并将id名首字母改成小写。

3）为dao类提取出接口。

在工作区右键dao文件-》refactor-》extract interface七、编写service、service接口并配置1）创建service包2）创建service类，定义方法findScoreBySnumber()。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

Spring和Struts整合的三种方式
要使用Spring 代替Spring的MVC,则一定要用到Struts的ActionServlet.
问题是Struts的ActionServlet如何装配Spring的应用环境.方法是使用Spring提供的org.springframework.web.struts.ContextLoaderPlugIn
在Struts的配置文件struts-config.xml中,注册contextConfigLocation即可
Spring和Struts整合主要有3种方式:
1.通过Spring的ActionSuppor类
2.通过Spring的DelegatingRequestProcessor类
3.通过Spring的DelegatingActionProxy类
通过Spring的ActionSupport类
让Actiobn不再继承Struts的Action类,而是继承Spring提供的ActionSupport类,在Action中获得Spring的ApplicationContext.
1.把Spring.jar放入WEB-INF/lib下
3.编写Spring的配置文件config.xml,放在WEB-INF目录下.
4.
5.
6.
小结:
在struts-config.xml中注册Spring的ContextLoaderPlugIn插件,使Action继承Spring的ActionSupport类来实现Spring和Struts的整合
优点:方便
缺点:Action和Spring偶合在了一起.
通过Spring的DelegatingRequestProcessor类
在struts中,担任控制器角色是是ActionSrvlet,当有请求发送至ActionServlet时,ActionServlet的doGet或者doPost 方法会执行RequestProcesssor的process()方法.
Spring提供了DelegatingRequestProcessor类用来代替struts的RequestProcessor类,从而把strus和Action与Spring 分离开,并把struts的动作置于Spring框架控制之下.
1.修改struts-config.xml,注册ContextLoaderPlugIn插件,并使用Spring的DelegatingRequestProcessor代替struts
的RequestProcessor类:
2.修改WEB-INF下的Spring配置文件,新建bean,和struts配置文件中的动作对应
3.HelloWorldService.java和前面的一样
4.Impl也一样
5.
6.
7.使用原来的show.jsp
使用DelegatingRequestProcessor代替struts的RequestProcessor这种方法
优点:Action中没有spring代码,偶合降低
缺点:开发人员可以自己定义DelegatingRequestProcessor类,如果没有struts默认的RequestProcesor类,则需要手工来整合spring和struts了
通过Spring的DelegatingActionProxy类
Spring通过了DelegatingActionProxy类用来代替struts中的动作,负责在Spring配置文件中查找对应的动作映射,从而把struts的action和spring分离,并把struts的动作置于spring框架的控制之下.
1.修改strtus-config.xml,注册ContextLoaderPlugIn插件,在注册动作时,动作的type属性不再注册为类的实名,而
是注册为spring提供的代理类DelegatingActionProxy
4.使用原来的impl
5.使用原来的action
6.使用原来的页面
比较3种方式:
1.第一种偶合度高,换ioc容器,使用aop,多个动作的action不能实现
2.第二种,依赖struts的requestProcessor类
3.第三种,最灵活。