最新版本Struts2.3.12+Spring3.2.2+Hibernate4.2.0框架配置详细步骤

合集下载

Struct2、Hibernate3、Spring3框架搭建实战

Struct2、Hibernate3、Spring3框架搭建实战采⽤⽬前最新的struts-2.3.1.2、hibernate3.6.10.Final、spring-framework-3.1.1.RELEASE开发包，以及eclipse-jee-indigo-SR2-win32、apache-tomcat-7.0.27服务器、JDK6和mysql5做开发环境，参考了前辈的⼀篇相关⽂章，改正了其中的错误和疏漏，克服了公司分配的“新”机器每⼩时⾃动重启三次的困难，终于把环境给搭好了。

整个过程中遵循的⼀个原则是，避免引⼊⽤不到的jar包，以求搭建⼀个最⼩的SSH 运⾏环境。

⾸先创建⼀个Dynamic web project 输⼊任意名字如SSHBase。

第⼀步：加载Spring环境我们需要引⼊的包有：org.springframework.asm-3.1.1.RELEASE.jarorg.springframework.beans-3.1.1.RELEASE.jarorg.springframework.context-3.1.1.RELEASE.jarorg.springframework.core-3.1.1.RELEASE.jarorg.springframework.expression-3.1.1.RELEASE.jarorg.springframework.jdbc-3.1.1.RELEASE.jarorg.springframework.web-3.1.1.RELEASE.jarorg.springframework.orm-3.1.1.RELEASE.jar由于spring默认开启了⽇志，还需要加⼊commons-logging的jar包，否则会报错。

建议不要⼀次性加⼊应该先加最核⼼的运⾏代码看缺少什么加什么，这样就不会加多余的包进来了，spring3已经把包按功能分开，不像以前⼀个包，这样更灵活，只要运⾏我们需要的功能，⽽没⽤到的就不⽤在硬性的添加进来。

Struts、Spring、Hibernate三大框架的原理和优点

Struts的原理和优点.Struts工作原理MVC即Model—View—Controller的缩写，是一种常用的设计模式。

MVC 减弱了业务逻辑接口和数据接口之间的耦合，以及让视图层更富于变化。

MVC的工作原理，如下图1所示：Struts 是MVC的一种实现，它将Servlet和JSP 标记(属于J2EE 规范）用作实现的一部分。

Struts继承了MVC的各项特性,并根据J2EE的特点，做了相应的变化与扩展.Struts的工作原理，视图:主要由JSP生成页面完成视图，Struts提供丰富的JSP 标签库: Html，Bean，Logic，Template等，这有利于分开表现逻辑和程序逻辑。

控制：在Struts中,承担MVC中Controller角色的是一个Servlet，叫ActionServlet。

ActionServlet是一个通用的控制组件。

这个控制组件提供了处理所有发送到Struts的HTTP请求的入口点。

它截取和分发这些请求到相应的动作类(这些动作类都是Action类的子类）。

另外控制组件也负责用相应的请求参数填充Action From（通常称之为FromBean），并传给动作类（通常称之为ActionBean）。

动作类实现核心商业逻辑，它可以访问java bean 或调用EJB。

最后动作类把控制权传给后续的JSP 文件，后者生成视图。

所有这些控制逻辑利用Struts-config.xml文件来配置。

模型：模型以一个或多个java bean的形式存在。

这些bean分为三类：Action Form、Action、JavaBean or EJB.Action Form通常称之为FormBean，封装了来自于Client的用户请求信息,如表单信息。

Action通常称之为ActionBean，获取从ActionSevlet传来的FormBean,取出FormBean中的相关信息，并做出相关的处理，一般是调用Java Bean或EJB等。

Struts2+Spring框架简介+Hibernate查询语言

出自Gavin King的手笔，目前最流行的开源ORM框架，其灵巧的设计，优秀的性能，还有丰富的文档，都是其迅速风靡全球的重要因素。

Entity EJB

Entity EJB实质上也是一种ORM技术，这是一种备受争议的组件技术，很多人说它非常优秀，也有人说它一钱不值。事实上，EJB为J2EE的蓬勃发展赢得了极高的声誉，EJB作为一种重量级、高花费的ORM技术上，具有不可比拟的优势。但由于其必须运行在EJB容器内，而且学习曲线陡峭，开发周期、成本相对较高，因而限制EJB的广泛使用。

添加自动注解配置(自动扫描@Service,@Repository等注解)

<context:component-scan base-package="test,a"/>
<context:annotation-config/> 该配置将隐式地向Spring容器注册4个 BeanPostProcessor
<bean id="hello" class="test.HelloWorld" abstract="false“ lazy-init="default" autowire="default" dependencycheck="default"> <property name="helloWorld"> <value type="ng.String">Hello World From IOC</value> </property> </bean>

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、spring2、hibernate_的整合

一.struts 2 与spring2struts2 本身就采用了类似于spring的IOC容器机制，可以利用struts2官方提供的插件struts2-spring-plugin-2.0.11.1.jar，直接与spring进行整合，配置文件中只需要设置struts.objectFactory=spring这样，就将struts2的对象管理交给了spring2的IOC容器。

在struts.xml中配置的action<package name="maintaince" extends="struts-default"><action name="serverInfoList" class="serverInfoService" method="getAllServersInfo"><result name="list">/jsp/server_info/server_info_list.jsp</result></action>在spring的配置文件中配置的bean<bean id="serverInfoService" class="com.wod.service.impl.ServerInfoServiceImpl"><property name="serverInfoDao" ref="serverInfoDao"/><property name="sib" ref="serverInfoBean"/></bean>可以看出，struts2可以直接只用在spring2中配置的bean，引用过来作为action。

Struts-Hibernate-Spring的整合配置

Struts-Hibernate-Spring的整合1. Struts2的配置(struts2.1.6 其他版本不同)：A:加入包：B:在web.xml中加入Struts的监听：<filter><filter-name>struts2</filter-name><filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-clas s></filter><filter-mapping><filter-name>struts2</filter-name><url-pattern>/*</url-pattern></filter-mapping>C:在src目录下加入:struts.xml文件;2. Spring的配置;A:加入包：还要：struts2-spring-plugin.jar;具体aspectjrt.jar和aspectjweaver.jar可以到：B:在web.xml中加入Spring的监听：<listener><listener-class>org.springframework.web.context.ContextLoaderListener</listener-class></listener>更多具体配置：/2.x/docs/spring-plugin.htmlC:在WEB-INF/添加：applicationContext.xml文件:(介绍两个相关工具：1. Ant :下载地址A:下载完后，解压.B:配置环境变量：和配置java环境大体相同ANT_HOME:具体路径path=%ANT_HOME%/libC:测试是否成功！2. Xdoclet:xdoclet-plugins-1.0.3.rarA:下载完后解压;3. 应用这两个工具;A:在项目中建立一build.xml内容：<?xml version="1.0" encoding="GBK"?><project name="OA系统构建脚本" default="生成Hibernate配置文件" basedir="."><property name="src.dir" value="${basedir}/src" /><property name="xdoclet.home" value="E:/xdoclet[i1]-1.2.3" /><path id="xdoclet.task.classpath"><fileset dir="${xdoclet.home}/lib"><include name="**/*.jar" /></fileset></path><!—制定一个任务 ---><taskdef name="xdoclet" classname="org.xdoclet.ant.XDocletTask"classpathref="xdoclet.task.classpath" /><target name="生成Hibernate配置文件"><xdoclet><fileset dir="${src.dir}/com/oa/model"[i2]><include name="**/*.java" /></fileset><componentclassname="org.xdoclet.plugin.hibernate.HibernateConfigPlugin"destdir="${src.dir}" version="3.0" hbm2ddlauto="update"jdbcurl="jdbc:mysql://localhost:3306/oa" jdbcdriver="com.mysql.jdbc.Driver"jdbcusername="root" jdbcpassword="liaogaohua"dialect="org.hibernate.dialect.MySQLDialect" showsql="true" />[i3]</xdoclet></target><target name="生成Hibernate映射文件"><xdoclet><fileset dir="${src.dir}/com/oa/model"><include name="**/*.java" /></fileset><componentclassname="org.xdoclet.plugin.hibernate.HibernateMappingPlugin" version="3.0"destdir="${src.dir}" /></xdoclet></target>[i4]</project>B:在项目中使用ant工具,生成文件,刷新;4. 加入Hibernate支持;A:导入所需的包.B:配置web.xml在原有基础;1. <context-param><param-name>contextConfigLocation</param-name><param-value>classpath*:applicationContext-*.xml[i5]</param-value></context-param>2. <filter><filter-name>hibernateFilter</filter-name><filter-class>org.springframework.orm.hibernate3.support.OpenSessionInViewFilter </filter-class></filter><filter-mapping><filter-name>hibernateFilter</filter-name><url-pattern>/*</url-pattern></filter-mapping>3. <filter><filter-name>encodingFilter</filter-name><filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class><init-param><param-name>encoding</param-name><param-value>GBK</param-value></init-param></filter><filter-mapping><filter-name>encodingFilter</filter-name><url-pattern>/*</url-pattern></filter-mapping>C:在applicationContext-commons.xml中配置;<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:aop="/schema/aop"xmlns:tx="/schema/tx"xsi:schemaLocation="/schema/beans /schema/beans/spring-beans-2.5.xsd /schema/aop/schema/aop/spring-aop-2.5.xsd/schema/tx/schema/tx/spring-tx-2.5.xsd"><bean id="sessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <property name="configLocation"><value>classpath:hibernate.cfg.xml</value></property></bean>[i6]<bean id="transactionManager"class="org.springframework.orm.hibernate3.HibernateTransactionManager"> <property name="sessionFactory"><ref bean="sessionFactory"/></property></bean>[i7]<tx:advice id="txAdvice" transaction-manager="transactionManager"> <tx:attributes><tx:method name="add*" propagation="REQUIRED" /><tx:method name="delete*" propagation="REQUIRED" /><tx:method name="modify*" propagation="REQUIRED" /><tx:method name="*" read-only="true" /></tx:attributes></tx:advice>[i8] <aop:config><aop:pointcut id="allManagerMethod" expression="execution(*org.test.*.*(..))[i9]" /><aop:advisor pointcut-ref="allManagerMethod" advice-ref="txAdvice" /> </aop:config></beans>5. 测试，能够把表建立，则Hibernat---Spring成功！能够访问action，则Spring---Struts成功![i1]Xdoclet路径[i2]所要生产*.hbm.xml文件的java文件[i3]hibernate.nbm.xml文件的生成信息[i4]把生成的*.hbm.xml文件添加到hibernate.nhm.xml[i5]Spring的配置文件在src目录下.并且为多个时.若为一个且在WEB-INF下时则：/WEB-INF/applicationContext-*.xml;[i6]用于取得session对象;[i7]创建session对象实例化;用于管理session对象的开关，不用人为去控制;[i8]对象session的可执行的方法;[i9]Dao,DaoImpl类5:测试，经测试成功！。

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的内容如表，我们暂时不分析。

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.1+Spring3.0+JPA1.0(Hibernate3.3实现)例子

Struts2.1+Spring3.0+JPA1.0(Hibernate3.3实现)例子文章分类:Java编程本文代码是传智播客黎活明老师所讲的《Spring2.5视频教程》各种示例的综合，在此把所有框架升级到最新版本整合一下。

/blog/582117所用jar包：Struts：struts-2.1.8.1\lib下除了各种plugin(保留struts2-spring-plugin-2.1.8.1.jar)的所有文件Spring：spring-framework-3.0.0.RELEASE\dist下的所有文件Hibernate：hibernate-distribution-3.3.2.GA下的hibernate3.jar\lib\bytecode\cglib下的cglib-2.2.jar\lib\optional\ehcache下的ehcache-1.2.3.jar\lib\required下的所有文件hibernate-annotations-3.4.0.GA下的hibernate-annotations.jar\lib下的ejb3-persistence.jar，hibernate-commons-annotations.jar hibernate-entitymanager-3.4.0.GA下的hibernate-entitymanager.jar \lib\test下的log4j.jar，slf4j-log4j12.jarMySQL：mysql-connector-java-5.1.10-bin.jarJUnit：4JDK：jdk-6u14-windows-i586.exeTomcat：apache-tomcat-6.0.18.zip项目名：testPerson.javaJava代码package com.test.bean;import java.io.Serializable;import javax.persistence.Column;import javax.persistence.Entity;import javax.persistence.GeneratedValue;import javax.persistence.Id;@Entitypublic class Person implements Serializable {private Integer id;private String name;public Person(){}public Person(String name){ = name;}@Id @GeneratedValuepublic Integer getId() {return id;}public void setId(Integer id) {this.id = id;}@Column(length=10,nullable=false)public String getName() {return name;}public void setName(String name) { = name;}@Overridepublic int hashCode() {final int prime = 31;int result = 1;result = prime * result + ((id == null) ? 0 : id.hashCode());return result;}@Overridepublic boolean equals(Object obj) {if (this == obj)return true;if (obj == null)return false;if (getClass() != obj.getClass())return false;final Person other = (Person) obj;if (id == null) {if (other.id != null)return false;} else if (!id.equals(other.id))return false;return true;}}package com.test.bean;import java.io.Serializable;import javax.persistence.Column;import javax.persistence.Entity;import javax.persistence.GeneratedValue; import javax.persistence.Id;@Entitypublic class Person implements Serializable { private Integer id;private String name;public Person(){}public Person(String name){ = name;}@Id @GeneratedValuepublic Integer getId() {return id;}public void setId(Integer id) {this.id = id;}@Column(length=10,nullable=false)public String getName() {return name;}public void setName(String name) { = name;}@Overridepublic int hashCode() {final int prime = 31;int result = 1;result = prime * result + ((id == null) ? 0 : id.hashCode());return result;}@Overridepublic boolean equals(Object obj) {if (this == obj)return true;if (obj == null)return false;if (getClass() != obj.getClass())return false;final Person other = (Person) obj;if (id == null) {if (other.id != null)return false;} else if (!id.equals(other.id))return false;return true;}} PersonService.javaJava代码package com.test.service;import com.test.bean.Person;public interface PersonService {public void save(Person person);public void update(Person person);public void delete(Integer personid);public Person getPerson(Integer personid);@SuppressWarnings("unchecked")public List<Person> getPersons();}package com.test.service;import java.util.List;import com.test.bean.Person;public interface PersonService {public void save(Person person);public void update(Person person);public void delete(Integer personid);public Person getPerson(Integer personid);@SuppressWarnings("unchecked")public List<Person> getPersons();} PersonServiceBean.javaJava代码package com.test.service.impl;import javax.persistence.EntityManager;import javax.persistence.PersistenceContext;import org.hibernate.exception.SQLGrammarException;import org.springframework.transaction.annotation.Propagation; import org.springframework.transaction.annotation.Transactional; import com.test.bean.Person;import com.test.service.PersonService;@Transactionalpublic class PersonServiceBean implements PersonService { @PersistenceContext EntityManager em;public void delete(Integer personid) {em.remove(em.getReference(Person.class, personid));}@Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)public Person getPerson(Integer personid) {return em.find(Person.class, personid);}@Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)@SuppressWarnings("unchecked")public List<Person> getPersons() throws SQLGrammarException {return em.createQuery("select o from Person o").getResultList();}public void save(Person person) {em.persist(person);}public void update(Person person) {em.merge(person);}}package com.test.service.impl;import java.util.List;import javax.persistence.EntityManager;import javax.persistence.PersistenceContext;import org.hibernate.exception.SQLGrammarException;import org.springframework.transaction.annotation.Propagation; import org.springframework.transaction.annotation.Transactional; import com.test.bean.Person;import com.test.service.PersonService;@Transactionalpublic class PersonServiceBean implements PersonService { @PersistenceContext EntityManager em;public void delete(Integer personid) {em.remove(em.getReference(Person.class, personid));}@Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)public Person getPerson(Integer personid) {return em.find(Person.class, personid);}@Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)@SuppressWarnings("unchecked")public List<Person> getPersons() throws SQLGrammarException {return em.createQuery("select o from Persono").getResultList();}public void save(Person person) {em.persist(person);}public void update(Person person) {em.merge(person);}} PersonAction.javaJava代码package com.test.web.action;import java.util.List;import javax.annotation.Resource;import com.test.bean.Person;import com.test.service.PersonService;public class PersonAction {@Resource PersonService personService;private String message;private List<Person> persons;private Person person;public Person getPerson() {return person;}public void setPerson(Person person) { this.person = person;}/*** 人员列表显示*/public String list(){this.persons = personService.getPersons();return "list";}/*** 人员添加界面*/public String addUI(){return "add";}/*** 人员添加*/public String add(){this.personService.save(this.person);this.message="添加成功";return "message";}public List<Person> getPersons() {return persons;}public void setPersons(List<Person> persons) { this.persons = persons;}public String getMessage() {return message;}public void setMessage(String message) {this.message = message;}}package com.test.web.action;import java.util.List;import javax.annotation.Resource;import com.test.bean.Person;import com.test.service.PersonService;public class PersonAction {@Resource PersonService personService;private String message;private List<Person> persons;private Person person;public Person getPerson() {return person;}public void setPerson(Person person) {this.person = person;}/*** 人员列表显示*/public String list(){this.persons = personService.getPersons();return "list";}/*** 人员添加界面*/public String addUI(){return "add";}/*** 人员添加*/public String add(){this.personService.save(this.person);this.message="添加成功";return "message";}public List<Person> getPersons() {return persons;}public void setPersons(List<Person> persons) {this.persons = persons;}public String getMessage() {return message;}public void setMessage(String message) {this.message = message;}}PersonServiceTest.javaJava代码package junit.test;import java.util.List;import org.junit.BeforeClass;import org.junit.Test;import org.springframework.context.ApplicationContext;importorg.springframework.context.support.ClassPathXmlApplicationConte xt;import com.test.bean.Person;import com.test.service.PersonService;public class PersonServiceTest {private static PersonService personService;@BeforeClasspublic static void setUpBeforeClass() throws Exception { try {ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");personService = (PersonService) applicationContext.getBean("personService");} catch (RuntimeException e) {e.printStackTrace();}}@Testpublic void testSave() {personService.save(new Person("小张"));}@Testpublic void testUpdate() {Person person = personService.getPerson(1);person.setName("小丽");personService.update(person);}@Testpublic void testGetPerson() {Person person = personService.getPerson(2);System.out.println(person.getName());try {System.out.println("请关闭数据库");Thread.sleep(1000 * 15);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("第二次开始获取");person = personService.getPerson(2);System.out.println(person.getName());}@Testpublic void testDelete() {personService.delete(1);}@Testpublic void testGetPersons() {List<Person> persons = personService.getPersons();for (Person person : persons) {System.out.println(person.getName());}}}package junit.test;import java.util.List;import org.junit.BeforeClass;import org.junit.Test;import org.springframework.context.ApplicationContext;importorg.springframework.context.support.ClassPathXmlApplicationConte xt;import com.test.bean.Person;import com.test.service.PersonService;public class PersonServiceTest {private static PersonService personService;@BeforeClasspublic static void setUpBeforeClass() throws Exception { try {ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");personService = (PersonService) applicationContext.getBean("personService");} catch (RuntimeException e) {e.printStackTrace();}}@Testpublic void testSave() {personService.save(new Person("小张"));}@Testpublic void testUpdate() {Person person = personService.getPerson(1);person.setName("小丽");personService.update(person);@Testpublic void testGetPerson() {Person person = personService.getPerson(2);System.out.println(person.getName());try {System.out.println("请关闭数据库");Thread.sleep(1000 * 15);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("第二次开始获取");person = personService.getPerson(2);System.out.println(person.getName());}@Testpublic void testDelete() {personService.delete(1);}@Testpublic void testGetPersons() {List<Person> persons = personService.getPersons();for (Person person : persons) {System.out.println(person.getName());}}} META-INF\persistence.xmlXml代码<?xml version="1.0" encoding="UTF-8"?><persistence xmlns="/xml/ns/persistence" xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/xml/ns/persistence/xml/ns/persistence/persistence_1_0.xsd"version="1.0"><persistence-unit name="test" transaction-type="RESOURCE_LOCAL"><properties><property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5Dialect"/><property name="hibernate.connection.driver_class" value="org.gjt.mm.mysql.Driver"/><property name="ername" value="root"/><property name="hibernate.connection.password" value="1234"/><property name="hibernate.connection.url" value="jdbc:mysql://localhost:3306/test?useUnicode=true&char acterEncoding=UTF-8"/><property name="hibernate.max_fetch_depth" value="3"/><property name="hibernate.hbm2ddl.auto" value="update"/><property name="hibernate.show_sql" value="true"/><property name="hibernate.format_sql" value="true"/><property name="e_second_level_cache" value="true"/><property name="e_query_cache" value="false"/><property name="hibernate.cache.provider_class" value="org.hibernate.cache.EhCacheProvider"/></properties></persistence-unit></persistence><?xml version="1.0" encoding="UTF-8"?><persistence xmlns="/xml/ns/persistence" xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/xml/ns/persistence/xml/ns/persistence/persistence_1_0.xsd"version="1.0"><persistence-unit name="test" transaction-type="RESOURCE_LOCAL"><properties><property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5Dialect"/><property name="hibernate.connection.driver_class" value="org.gjt.mm.mysql.Driver"/><property name="ername" value="root"/><property name="hibernate.connection.password" value="1234"/><property name="hibernate.connection.url" value="jdbc:mysql://localhost:3306/test?useUnicode=true&char acterEncoding=UTF-8"/><property name="hibernate.max_fetch_depth" value="3"/><property name="hibernate.hbm2ddl.auto" value="update"/><property name="hibernate.show_sql" value="true"/><property name="hibernate.format_sql" value="true"/><property name="e_second_level_cache" value="true"/><property name="e_query_cache" value="false"/><property name="hibernate.cache.provider_class" value="org.hibernate.cache.EhCacheProvider"/></properties></persistence-unit></persistence> src\beans.xmlXml代码<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance" xmlns:context="/schema/context"xmlns:aop="/schema/aop"xmlns:tx="/schema/tx"xsi:schemaLocation="/schema/beans /schema/beans/spring-beans-3.0.xsd /schema/context/schema/context/spring-context-3.0.x sd/schema/aop/schema/aop/spring-aop-3.0.xsd /schema/tx/schema/tx/spring-tx-3.0.xsd"> <context:annotation-config/><bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalEntityManagerFactoryBea n"><property name="persistenceUnitName" value="test"/></bean><bean id="txManager" class="org.springframework.orm.jpa.JpaTransactionManager"> <property name="entityManagerFactory" ref="entityManagerFactory"/></bean><tx:annotation-driven transaction-manager="txManager"/><bean id="personService" class="com.test.service.impl.PersonServiceBean"/><bean id="personAction" scope="prototype" class="com.test.web.action.PersonAction" /></beans><?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance" xmlns:context="/schema/context"xmlns:aop="/schema/aop"xmlns:tx="/schema/tx"xsi:schemaLocation="/schema/beans /schema/beans/spring-beans-3.0.xsd /schema/context/schema/context/spring-context-3.0.x sd/schema/aop/schema/aop/spring-aop-3.0.xsd /schema/tx/schema/tx/spring-tx-3.0.xsd"> <context:annotation-config/><bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalEntityManagerFactoryBea n"><property name="persistenceUnitName" value="test"/></bean><bean id="txManager" class="org.springframework.orm.jpa.JpaTransactionManager"> <property name="entityManagerFactory" ref="entityManagerFactory"/></bean><tx:annotation-driven transaction-manager="txManager"/><bean id="personService" class="com.test.service.impl.PersonServiceBean"/><bean id="personAction" scope="prototype" class="com.test.web.action.PersonAction" /></beans> src\ehcache.xmlXml代码<?xml version="1.0" encoding="UTF-8"?><ehcache><diskStore path="C:\cache"/><defaultCache maxElementsInMemory="1000" eternal="false" overflowToDisk="true"timeToIdleSeconds="120"timeToLiveSeconds="180"diskPersistent="false"diskExpiryThreadIntervalSeconds="60"/><cache name="com.test.bean.Person" maxElementsInMemory="100" eternal="false"overflowToDisk="true" timeToIdleSeconds="300" timeToLiveSeconds="600" diskPersistent="false"/></ehcache><?xml version="1.0" encoding="UTF-8"?><ehcache><diskStore path="C:\cache"/><defaultCache maxElementsInMemory="1000" eternal="false" overflowToDisk="true"timeToIdleSeconds="120"timeToLiveSeconds="180"diskPersistent="false"diskExpiryThreadIntervalSeconds="60"/><cache name="com.test.bean.Person" maxElementsInMemory="100" eternal="false"overflowToDisk="true" timeToIdleSeconds="300" timeToLiveSeconds="600" diskPersistent="false"/></ehcache>src\struts.xmlXml代码<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE struts PUBLIC"-//Apache Software Foundation//DTD Struts Configuration 2.1//EN""/dtds/struts-2.1.dtd"><struts><constant name="struts.i18n.encoding" value="UTF-8"/><!-- 该属性指定需要Struts 2处理的请求后缀，该属性的默认值是action，即所有匹配*.action的请求都由Struts2处理。

Struts2,Spring,Hibernate整合步骤及一个简单实例

Struts2,Spring,Hibernate整合步骤（自己笔记）配步骤的例子一个：请参看：Struts2,Spring,Hibernate整合例子一个1.建立web项目2.在web.xml 配置 struts2，和 spring ，<filter><filter-name>struts2</filter-name><filter-class>org.apache.struts2.dispatcher.FilterDispatcher(struts的过滤器)</filter-class></filter><filter-mapping>（加载struts2）<filter-name>struts2</filter-name><url-pattern>/*</url-pattern></filter-mapping><listener><listener-class>org.springframework.web.context.ContextLoaderListener（spring监听器）</listener-class></listener><context-param>（程序从此处开始加载.xml 文件，并执行）<param-name>contextConfigLocation</param-name><param-value>classpath*:*.xml</param-value></context-param>3.在src根目录下创建struts.xml文件<include file="struts-default.xml"/>固定格式，用到此包4.在src根目录创建hibernate.cfg.xml文件<?xml version='1.0' encoding='UTF-8'?><!DOCTYPE hibernate-configuration PUBLIC"-//Hibernate/Hibernate Configuration DTD 3.0//EN" "/hibernate-configura tion-3.0.dtd"><hibernate-configuration><session-factory><property name="dialect">org.hibernate.dialect.Oracle9Dialect</property><property name="show_sql">false</property><property name="format_sql">true</property><propertyname="e_reflection_optimizer">true</property><property name="max_fetch_depth">2</property><property name="default_batch_fetch_size">8</property><property name="jdbc.batch_size">20</property></session-factory></hibernate-configuration>系统给的文件只需要拷贝，都是一些数据库库的基本配置5.在src根目录拷贝struts.properties文件struts.objectFactory = spring 该项是告诉系统用spring来控制hibernate和Actionstruts.action.extension=action 告诉系统访问时以什么结尾。

SpringBoot2.3.12.RELEASE优雅的全局异常处理（模板一）

SpringBoot2.3.12.RELEASE优雅的全局异常处理（模板⼀）1、⾸先，需要引⼊maven依赖包，如下所⽰：1 <?xml version="1.0" encoding="UTF-8"?>2 <project xmlns="/POM/4.0.0"3 xmlns:xsi="/2001/XMLSchema-instance"4 xsi:schemaLocation="/POM/4.0.0 https:///xsd/maven-4.0.0.xsd">5 <modelVersion>4.0.0</modelVersion>6 <parent>7 <groupId>org.springframework.boot</groupId>8 <artifactId>spring-boot-starter-parent</artifactId>9 <version>2.3.12.RELEASE</version>10 <relativePath /> 11 </parent>12 <groupId>com.bie</groupId>13 <artifactId>SpringbootException</artifactId>14 <version>0.0.1-SNAPSHOT</version>15 <name>SpringbootException</name>16 <description>Demo project for Spring Boot</description>1718 <properties>19 <java.version>1.8</java.version>20 </properties>2122 <dependencies>23 24 <dependency>25 <groupId>org.springframework.boot</groupId>26 <artifactId>spring-boot-starter-web</artifactId>27 </dependency>28 29 <dependency>30 <groupId>com.alibaba</groupId>31 <artifactId>fastjson</artifactId>32 <version>1.2.41</version>33 </dependency>3435 <dependency>36 <groupId>org.springframework.boot</groupId>37 <artifactId>spring-boot-starter-test</artifactId>38 <scope>test</scope>39 <exclusions>40 <exclusion>41 <groupId>org.junit.vintage</groupId>42 <artifactId>junit-vintage-engine</artifactId>43 </exclusion>44 </exclusions>45 </dependency>46 </dependencies>4748 <build>49 <plugins>50 <plugin>51 <groupId>org.springframework.boot</groupId>52 <artifactId>spring-boot-maven-plugin</artifactId>53 </plugin>54 </plugins>55 </build>5657 </project> SpringBoot中有⼀个ControllerAdvice的注解，使⽤该注解表⽰开启了全局异常的捕获，我们只需再⾃定义⼀个⽅法，然后使⽤ExceptionHandler注解，在该注解的value属性⾥⾯，定义捕获异常的类型，即可对这些捕获的异常进⾏统⼀的处理。

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>。

SSH三大框架（StrutsSpringHibernate）

SSH三大框架（StrutsSpringHibernate）struts0、Struts1工作流程：（1）检索和用户请求匹配的ActionMapping实例。

如果不存在此示例，就返回用户请求路径无效。

（2）如果ActionForm实例不存在，就创建一个ActionForm对象，把客户提交的表单数据保存到ActionForm对象中。

（3）根据配置信息决定是否需要表单验证，如果需要验证，就调用ActionForm的validate()方法。

（4）如果ActionForm的validate()方法返回null或返回的ActionErrors对象里不包含ActionMessage对象，就表示表单验证成功。

（5）ActionServlet根据ActionMapping实例包含的映射信息决定将请求转发给哪个Action。

如果相应的Action实例不存在，就先创建这个实例，然后调用Action的execute()方法。

（6）Action的execute()方法返回一个ActionForward对象，ActionServlet再把客户请求转发给ActionForward对象所指向的JSP 组件。

（7）通过ActionForward对象指向的JSP组件生成动态网页，返回给客户端。

1、Struts2工作流程：(包含拦截器处理部分，详细描述)1、客户端向Servlet容器（如Tomcat）提交一个请求2、请求经过一系列过滤器（如ActionContextCleanUp (已被JVM和WEB容器废弃的空对象) 过滤器等）3、核心控制器被调用，询问ActionMapper来决定请求是否需要调用某个Action ?4、如果ActionMapper决定需要调用某个Action，核心控制器把控制权委派给ActionProxy （备注：JSP请求无需调用Action）5、ActionProxy通过Configuration Manager询问框架的配置文件（struts.xml），找到需调用的Action类6、ActionProxy创建一个ActionInvocation的实例，(ActionInvocation的作用是如何执行Action，拦截器的功能就是在ActionInvocation中实现的)7、ActionInvocation负责调用Action，在此之前会依次调用所有配置的拦截器8、Action执行完毕，ActionInvocation负责根据结果码字符串在struts.xml的配置中找到对应的返回结果9、拦截器被再次执行10、过滤器被再次执行2、Struts1和Struts2区别：1、Action的实现方面：Struts1要求必须统一扩展自Action类，而Struts2中可以是一个普通的POJO2、线程模型方面：Struts1的Action工作在单例模式，一个Action的实例处理所有的请求。

Spring、SpringMVC、Struts2之间的区别

Spring、SpringMVC、Struts2之间的区别⼀、Spring与SpringMVC的区别：spring是⼀个开源框架，是为了解决企业应⽤程序开发，功能如下：功能：使⽤基本的JavaBean代替EJB，并提供了更多的企业应⽤功能范围：任何Java应⽤ Spring是⼀个轻量级的控制反转（IoC）和⾯向切⾯（AOP）的容器框架。

1、轻量——从⼤⼩与开销两⽅⾯⽽⾔Spring都是轻量的。

完整的Spring框架可以在⼀个⼤⼩只有1MB多的JAR⽂件⾥发布。

并且Spring所需的处理开销也是微不⾜道的。

此外， Spring是⾮侵⼊式的：典型地，Spring应⽤中的对象不依赖于Spring的特定类。

2、控制反转——Spring通过⼀种称作控制反转（IoC）的技术促进了松耦合。

当应⽤了IoC，⼀个对象依赖的其它对象会通过被动的⽅式传递进来，⽽不是这个对象⾃⼰创建或者查找依赖对象。

你可以认为IoC与JNDI相反——不是对象从容器中查找依赖，⽽是容器在对象初始化时不等对象请求就主动将依赖传递给它。

3、⾯向切⾯——Spring提供了⾯向切⾯编程的丰富⽀持，允许通过分离应⽤的业务逻辑与系统级服务（例如审计（auditing）和事务（transaction）管理）进⾏内聚性的开发。

应⽤对象只实现它们应该做的——完成业务逻辑—— 仅此⽽已。

它们并不负责（甚⾄是意识）其它的系统级关注点，例如⽇志或事务⽀持。

4、容器——Spring包含并管理应⽤对象的配置和⽣命周期，在这个意义上它是⼀种容器，你可以配置你的每个bean如何被创建——基于⼀个可配置原型（prototype），你的bean可以创建⼀个单独的实例或者每次需要时都⽣成⼀个新的实例——以及它们是如何相互关联的。

然⽽，Spring不应该被混同于传统的重量级的EJB容器，它们经常是庞⼤与笨重的，难以使⽤。

5、框架——Spring可以将简单的组件配置、组合成为复杂的应⽤。

Struts1、Struts2、Hibernate、Spring框架工作原理介绍

Struts1、Struts2、Hibernate、Spring框架工作原理介绍Struts1工作原理Struts1工作原理图1、初始化：struts框架的总控制器ActionServlet是一个Servlet，它在web.xml中配置成自动启动的Servlet，在启动时总控制器会读取配置文件(struts-config.xml)的配置信息，为struts中不同的模块初始化相应的对象。

(面向对象思想)2、发送请求：用户提交表单或通过URL向WEB服务器提交请求，请求的数据用HTTP协议传给web服务器。

3、form填充：struts的总控制器ActionServlet在用户提交请求时将数据放到对应的form对象中的成员变量中。

4、派发请求：控制器根据配置信息对象ActionConfig将请求派发到具体的Action，对应的formBean一并传给这个Action中的excute()方法。

5、处理业务：Action一般只包含一个excute()方法，它负责执行相应的业务逻辑(调用其它的业务模块)完毕后返回一个ActionForward对象。

服务器通过ActionForward对象进行转发工作。

6、返回响应：Action将业务处理的不同结果返回一个目标响应对象给总控制器。

7、查找响应：总控制器根据Action处理业务返回的目标响应对象，找到对应的资源对象，一般情况下为jsp页面。

8、响应用户：目标响应对象将结果传递给资源对象，将结果展现给用户。

Struts1优缺点（为什么要用strust1）1.优点：①开源的框架，结构清晰②是MVC的经典实现（MVC是一种思想，而不是一种技术）③处理异常机制，实现国际化④具有强大的标签库⑤解决了JSP页面存在大量的JAVA代码，维护起来方便⑥在formBean中会自动提交，不会去使用传统的get、set方法得到值、取值2.缺点：①配置复杂②测试不方便③依赖web容器④action是一个单例模式，必须设置为线程安全Struts2工作原理struts2工作原理图1 客户端初始化一个指向Servlet容器（例如Tomcat）的请求2 这个请求经过一系列的过滤器（Filter）（这些过滤器中有一个叫做ActionContextCleanUp的可选过滤器，这个过滤器对于Struts2和其他框架的集成很有帮助，例如：SiteMesh Plugin）3 接着FilterDispatcher被调用，FilterDispatcher询问ActionMapper来决定这个请是否需要调用某个Action4 如果ActionMapper决定需要调用某个Action，FilterDispatcher把请求的处理交给ActionProxy5 ActionProxy通过Configuration Manager询问框架的配置文件，找到需要调用的Action类6 ActionProxy创建一个ActionInvocation的实例。

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测试，必须。

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

SSH框架搭建Struts2.3.12+Spring3.2.2+Hibernate4.2.0编号：SSH-S2-S3-H4版本：V1.1级别：公开编写时间：2013-03-18目录1 导言 (1)1.1 目的 (1)1.2 范围 (1)1.3 说明 (1)2 搭建Struts2 (2)2.1 搭建所需jar包 (2)2.2 整合步骤 (2)2.2.1 创建项目 (2)2.2.2 导入jar包 (2)2.2.3 配置web.xml (4)2.2.4 创建web (4)2.2.5 创建jsp页面 (5)2.2.6 配置struts.xml (6)2.2.7 配置Tomcat (6)2.2.8 部署项目 (7)2.3 测试 (8)2.3.1 启动Tomcat (10)2.3.2 测试Tomcat (10)2.3.3 测试Struts (11)3 整合Spring3 (12)3.1 整合所需jar包 (12)3.2 整合步骤 (12)3.2.1 导入jar包 (12)3.2.2 配置web.xml (12)3.2.3 配置struts.xml (13)3.2.4 配置spring.xml (13)3.3 测试 (14)3.3.1 启动Tomcat (14)3.3.2 测试登录 (14)4 整合Hibernate4 (15)4.1 整合所需jar包 (15)4.2 整合步骤 (15)4.2.1 导入jar包 (15)4.2.2 创建数据库ccc (15)4.2.3 创建对象User (16)4.2.4 生成映射文件User.hbm.xml (17)4.2.5 创建dao (18)4.2.6 创建service (19)4.2.7 创建web (20)4.2.8 配置jdbc.properties (21)4.2.9 配置db.xml (22)4.2.10 配置spring.xml (24)4.2.11 配置struts.xml (24)4.3 测试 (25)4.3.1 启动Tomcat (25)4.3.2 测试登录 (25)1导言1.1 目的本文档是根据个人的工作经验搭建的轻量级SSH框架，也是实际应用中比较全面的基础框架，用于指导SSH框架初学者学习搭建SSH框架，希望能给各位使用者提供帮助，同时也希望朋友们尽量去帮助其他人。

1.2 范围本次框架搭建的版本是Struts2.3.12+Spring3.2.2+Hibernate4.2.0，截止2013年3月18日是最新的版本。

本次搭建的过程是先搭建Struts2.3.12,测试通过之后，整合Spring3.2.2，最后再整合Hibernate4.2.0，最后的整合内容有点多，因为这也是居于MVC思想搭建的环境，希望大家耐心学习。

1.3 说明本文档是个人总结的经验，仅供参考学习，同时欢迎朋友们一起沟通学习，文档中会对使用的jar做详细解说，对配置的过程使用图文说明，因为SSH博大精深，很多知识在搭建过程中没有使用到，只是一个基础框架的搭建，能测试通过就可以，所以对于高要求的开发，需要自己添加jar、增加方法和配置，同时文档中出现的纰漏希望朋友们等指正。

开发环境：MyEclipse7.0，Tomcat6.0，JDK1.6，其他环境可进行测试。

1.4 更新内容本次文档更新内容为Tomcat的配置使用虚拟路径，这样每次项目内容更新不需要重新部署项目，而且使用debug模式启动，在启动状态下修改项目内容，保存之后，可以直接测试，不需要重启Tomcat，非常简单。

本次更新是将为2013年5月15日，如果项目搭建学习遇到问题，可邮件给我，我可以发演示项目给大家进行参考学习。

同时声明，搭建的框架只是最简单的框架基础入门，大神就不用挑刺了，有时间多写点东西分享一下吧。

邮箱：xiazhangrui@。

2搭建S t r u t s22.1 搭建所需jar包2.2 整合步骤2.2.1 创建项目创建一个web项目，项目名称为SSH，如下所示：2.2.2 导入jar包项目中点击lib，复制需要的jar到lib中即完成导入，如下所示：如果没有导入完成，右键点击项目名（SSH），选择properties-Java Build Path，点击Add Extenrnal JARs，选择项目lib中的jar包进行导入，如下所示：2.2.3 配置web.xml主要配置Struts2容器控制器，如下所示：<?xml version="1.0"encoding="UTF-8"?><web-app version="2.4"xmlns="/xml/ns/j2ee"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/xml/ns/j2ee/xml/ns/j2ee/web-app_2_4.xsd"><filter><filter-name>struts2</filter-name><filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPr epareAndExecuteFilter</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-list></web-app>2.2.4 创建webLoginAction主要用于实现逻辑控制控制，通过Struts的调用，处理业务之后，返回给Struts，然后显示给页面，如下所示：LoginAction.javapackage com.ssh.web;public class LoginAction {private String name;private String password;public String login() {i f (null == name && null == password) {return"login";}else if ("ssh".equals(name) && "12345".equals(password)) { return"ok";}else {return"error";}}public String getName() {r eturn name;}public void setName(String name) {t = name;}public String getPassword() {r eturn password;}public void setPassword(String password) {t his.password = password;}}2.2.5 创建jsp页面login.jsp是登录页面,其他两个jsp分别写入Login Is Ok 和Login Is Error，用于登录成功和失败的页面显示，右键点击WebRoot，创建jsp，如下所示：login.jsp<html><body><center><form method="post"action="login">UserName<input type="text"name="name"id="name"/><br/>Password<input type="password"name="password"id="password"/><br/><input type="submit"value="login"/></form></center></body></html>loginOk.jsp<html><body><center><h1>Login Is Ok</h1></center></body></html>loginError.jsp<html><body><center><h1>Login Is Error</h1></center></body></html>2.2.6 配置struts.xml这里配置页面访问访问请求的跳转和返回结果的路径,右键点击src，创建一个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="default"extends="struts-default"><action name="login"class="com.ssh.web.LoginAction"method="login"><result name="login">login.jsp</result><result name="ok">loginOk.jsp</result><result name="error">loginError.jsp</result></action></package></struts>2.2.7 配置Tomcat(1) 点击Window-Preferences-MyEclipse…-Server-Tomcat-Tomcat 6.x配置tomcat路径，并启用，如下所示：(2) 点击Tomcat 6.x-jdk配置安装的jdk版本，如下所示：2.2.8 部署项目有两种部署项目的方式，第一种类似于物理配置，部署之后，项目的可执行程序复制到Tomcat的webapps里面，因为这样，每次改变项目内容需要重新部署和启动Tomcat，这是最原始的部署方法。