基于Annotation的Struts2.0+Hibernate3.3+Spring2.5整合开发

合集下载

framework开发手册

Framework架构手册前言本框架基于Struts2.0+Spring2.5+Hibernate3.2架构所建，用于中小型企业网站或管理系统基础架构。

下面先简要介绍一下struts，spring，hibernate●Struts简介Struts是一个基于Sun J2EE平台的MVC框架，主要是采用Servlet和JSP技术来实现的。

Struts把Servlet、JSP、自定义标签和信息资源(message resources)整合到一个统一的框架中，开发人员利用其进行开发时不用再自己编码实现全套MVC模式，极大的节省了时间，所以说Struts是一个非常不错的应用框架。

●Spring简介Spring是一个解决了许多在J2EE开发中常见的问题的强大框架。

Spring提供了管理业务对象的一致方法并且鼓励了注入对接口编程而不是对类编程的良好习惯。

Spring的架构基础是基于使用JavaBean属性的Inversion of Control容器。

然而，这仅仅是完整图景中的一部分：Spring在使用IoC容器作为构建完关注所有架构层的完整解决方案方面是独一无二的。

Spring提供了唯一的数据访问抽象，包括简单和有效率的JDBC框架，极大的改进了效率并且减少了可能的错误。

Spring的数据访问架构还集成了Hibernate和其他O/R mapping解决方案。

Spring还提供了唯一的事务管理抽象，它能够在各种底层事务管理技术，例如JTA 或者JDBC事务提供一个一致的编程模型。

Spring提供了一个用标准Java语言编写的AOP 框架，它给POJOs提供了声明式的事务管理和其他企业事务--如果你需要--还能实现你自己的aspects。

这个框架足够强大，使得应用程序能够抛开EJB的复杂性，同时享受着和传统EJB相关的关键服务。

Spring还提供了可以和IoC容器集成的强大而灵活的MVC Web框架。

●Hibrenate简介Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。

基于STRUTS2.0+SPRING+IBATIS技术的WEB开发

基于ＳＴＲＵＴＳ２．０＋ＳＰＲＩＮＧ＋ＩＢＡＴＩＳ技术的ＷＥＢ开发摘要:随着b/s多层应用已成为web开发的主流,本文首先介绍了struts2.0、spring、ibatis这三种框架,随后介绍了如何使用这三种框架组合来实现web开发。

关键词:b/s struts2.0 spring ibatis随着中国软件的发展,不同于c/s软件,用户不需要在每台电脑上安装客户端软件,b/s软件只需要在联网电脑的浏览器中输入网址就可以访问远程的信息,因此b/s软件越来越受到用户的欢迎。

b/s 软件的开发有很多种方式,有不同的语言,本文主要介绍在struts2.0、spring、ibatis三种框架组合的基础上实现高校宿舍智能化、信息化管理的研究与实现。

1、struts2.0struts2的体系使用了webwork的设计核心,并大量使用拦截器来处理用户请求,从而允许用户的业务逻辑控制器与servlet api分离。

从数据流图上来看,struts2与webwork相差不大,struts2同样使用拦截器作为处理,以用户的业务逻辑控制器为目标,创建一个控制器代理。

控制器代理负责处理用户请求,处理用户请求时回调业务控制器的execute方法,该方法的返回值将决定了struts 2将怎样的视图资源呈现给用户。

2、springspring是目前java ee 领域中比较流行的一个开源框架,它的目的是为了解决企业应用程序开发的复杂性。

spring框架的分层架构允许在不同的层次上选择各种组件,所以spring可以和hibernate、struts以及jsf等框架结合起来。

spring框架是一个分层架构,由7个定义良好的模块组成。

spring 模块构建在核心容器之上,核心容器定义了创建、配置和管理 bean 的方式。

组成spring框架的每个模块(或组件)都可以单独存在,或者与其他一个或多个模块联合实现。

3、ibatisibatis是以sql为中心的持久化层框架。

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+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注解。

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中使用注解配置Action方法详解

struts2中使⽤注解配置Action⽅法详解使⽤注解来配置Action可以实现零配置，零配置将从基于纯XML的配置转化为基于注解的配置。

使⽤注解，可以在⼤多数情况下避免使⽤struts.xml⽂件来进⾏配置。

struts2框架提供了四个与Action相关的注解类型，分别为ParentPackage、Namespace、Result和Action。

ParentPackage:ParentPackage注解⽤于指定Action所在的包要继承的⽗包。

该注解只有⼀个value参数。

⽤于指定要继承的⽗包。

⽰例：使⽤ParentPackage注解，其value值为mypackage,表⽰所在的Action需要继承mypackage包，@ParentPackage(value="mypackage")public class UserAction extends ActionSupport{}如果注解中只有⼀个value参数值，或者其他参数值都使⽤默认值时，则可以对value参数设置进⾏简写，⽐如上述的代码：@ParentPackage("mypackage")public class UserAction extends ActionSupport{}把struts2-convention-pligin-2.x.x.jar包导⼊到web应⽤中，才能在Action类中使⽤注解。

Namespace：Namespace注解⽤于指定Action所在的包的命名空间。

该注解只有⼀个value参数，⽤于指定ACtion所属于的命名空间。

当使⽤Namespace注解时，在为命名空间取名需要使⽤斜杠（/）开头。

使⽤Namespace注解，指定其Action所在的包的命名空间为/user：@Namespace("/user")public class UserAction extends ActionSupport{}Result：Result注解⽤于定义⼀个Result映射，该注解包含四个参数，1）name:可选参数，⽤于指定Result的逻辑名，默认值为success2）location：必选参数，⽤于指定Result对应资源的URL3）type：可选参数，⽤于指定Result的类型，默认值为NullResult.class4）params:可选参数，⽤于为Result指定要传递的参数，格式为：{key1,value1,key2,value2,...}如果type参数的值为NullResult.class,那么struts2框架在解析Result配置时，会使⽤默认的结果类型（即ServletDispatcherResult）来替换NullResult。

Maven搭建MyEclipse10+Struts2.1+Spring3.3+Hibernate3.3全注解框架

一、新建项目1.新建maven项目New ->project选择Maven projectnext在filter输入webapp选择maven-archetype-webappGroup id输入inscribe，artifact id输入farsighted二、添加struts2框架1.添加struts2支持项目上点右键->myeclipse->add struts capabilities点选struts2.1和/*只勾选struts2 core lib启动tomcat，在地址栏输入localhost:8088/farsighted出现如下界面2.添加action类New ->source folder输入src/main/javaNew ->classPackage输入org.inscribe.farsighted.action，name输入LoginActionLoginAction.javapackage org.inscribe.farsighted.action;import org.apache.struts2.convention.annotation.Action;import org.apache.struts2.convention.annotation.ParentPackage; import org.apache.struts2.convention.annotation.Result;import com.opensymphony.xwork2.ActionSupport;/*** @author steve frank**/@ParentPackage("struts-default")public class LoginAction extends ActionSupport {private String name;private String password;public String getName() {return name;}public void setName(String name) { = name;}public String getPassword() {return password;}public void setPassword(String password) {this.password = password;}@Action(value = "login", results = {@Result(name = INPUT, location = "/WEB-INF/content/fail.jsp"),@Result(name = SUCCESS, location = "/WEB-INF/content/success.jsp") }) public String execute() {if (name.equals("steve") && password.equals("123"))return SUCCESS;elsereturn INPUT;}}Index.jsp<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%><%@ taglib prefix="s" uri="/struts-tags"%><!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"><html><head><title>My JSP 'index.jsp' starting page</title></head><body><s:form action="login"><s:textfield name="name" value="steve"></s:textfield><s:textfield name="password" value="123"></s:textfield><s:submit></s:submit></s:form></body></html>success.jsp<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%> <%@ taglib prefix="s" uri="/struts-tags"%><!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"><html><head><title>My JSP 'success.jsp' starting page</title></head><body><s:text name="password" /><hr /><s:property value="password" /></body></html>fail.jsp<body>登录失败,用户名或密码错误.</body>三、添加hibernate框架1.添加hibernate支持右键->myeclipse->add hibernate capabilities点选hibernate 3.3 勾选enable hibernate annotations support勾选hibernate 3.3 annotations&entity manager,hibernate 3.3 core lib,hibernate 3.3 advanced support lib点选copy checked library jars to folder and add to build-path点选newFolder :src/main/resources勾选open configuration file选择db driver:mysql去掉勾，不创建hibernatesessionfactory四、添加spring框架1.添加spring支持项目右键->myeclipse->add spring capabilities点选spring3.0勾选spring 3.0 core;spring 3.0 aop;spring3.0 persistence core; spring3.0 persistence jdbc; 勾选copy checked library contents to project folder采取默认，enable aop,new applicationcontext.xml不创建sessionfactory2.applicationContext.xml文件配置<?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.xsd/schema/context/schema/context/spring-context.xsd/schema/aop/schema/aop/spring-aop.xsd/schema/tx/schema/tx/spring-tx.xsd"> <bean id="sessionFactory"class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBea n"><property name="configLocation" value="classpath:hibernate.cfg.xml"></property><property name="packagesToScan" value="org.inscribe.farsighted.model" /> </bean><context:component-scan base-package="org.inscribe.farsighted" /><bean id="transactionManager"class="org.springframework.orm.hibernate3.HibernateTransactionManager"><property name="sessionFactory" ref="sessionFactory" /></bean><tx:annotation-driven transaction-manager="transactionManager"proxy-target-class="true" /></beans>3.hibernate.cfg.xml修改<?xml version='1.0' encoding='UTF-8'?><!DOCTYPE hibernate-configuration PUBLIC"-//Hibernate/Hibernate Configuration DTD 3.0//EN""/hibernate-configuration-3.0.dtd"><hibernate-configuration><session-factory><property name="dialect">org.hibernate.dialect.MySQLDialect</property><property name="connection.url">jdbc:mysql://localhost:3306/test</property><property name="ername">root</property><property name="connection.password">admin</property><property name="connection.driver_class">com.mysql.jdbc.Driver</property><property name="myeclipse.connection.profile">MYSQL</property><property name="initialSize">5</property><property name="maxActive">100</property><property name="maxIdle">30</property><property name="maxWait">500</property><property name="defaultAutoCommit">false</property></session-factory></hibernate-configuration>4.web.xml文件配置<?xml version="1.0" encoding="UTF-8"?><web-app version="3.0" xmlns="/xml/ns/javaee"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/xml/ns/javaee/xml/ns/javaee/web-app_3_0.xsd"><display-name></display-name><welcome-file-list><welcome-file>index.jsp</welcome-file></welcome-file-list><context-param><param-name>contextConfigLocation</param-name><param-value>classpath*:applicationContext*.xml</param-value></context-param><listener><listener-class>org.springframework.web.context.ContextLoaderListener</listener-class ></listener><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><filter><filter-name>Set Character Encoding</filter-name><filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class><init-param><param-name>encoding</param-name><param-value>UTF-8</param-value></init-param><init-param><param-name>forceEncoding</param-name><param-value>true</param-value></init-param></filter><filter-mapping><filter-name>Set Character Encoding</filter-name><url-pattern>/*</url-pattern></filter-mapping></web-app>五、类的添加1.hibernate反向生成students表右键->hibernate reverse engineering选择package : com.inscribe.farsighted.model勾选create pojo<>db->点选add hibernate mapping annotations to pojo;勾选update hibernate configuration with mapping resource location勾选java data access object(dao)->勾选generate precise findby methods;点选sping daoId generation :native2.添加service接口package org.inscribe.farsighted.service;import org.inscribe.farsighted.model.Student;public interface StudentService {public Student findById(Integer id);}3.添加service实现类package org.inscribe.farsighted.service.impl;import javax.annotation.Resource;import org.inscribe.farsighted.model.Student;import org.inscribe.farsighted.model.StudentDAO;import org.inscribe.farsighted.service.StudentService;import org.springframework.stereotype.Service;@Servicepublic class StudentServiceImpl implements StudentService {@Resourceprivate StudentDAO studentDAO;@Overridepublic Student findById(Integer id) {// TODO Auto-generated method stubreturn studentDAO.findById(id);}}4.添加测试类package org.inscribe.farsighted;import org.inscribe.farsighted.model.Student;import org.inscribe.farsighted.service.StudentService;import org.springframework.context.ApplicationContext;import org.springframework.context.support.ClassPathXmlApplicationContext;public class Test {public static void main(String[] args) {ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");StudentService service = (StudentService) context.getBean("studentServiceImpl");Student s=service.findById(1);System.out.println(s.getName());}}5.WEB-INF下新建Folder包结构如下6.修改输出目录Build path->configure build pathOut folder统一改default：Webapp/src/main/webapp/WEB-INF/classes更改如果无效,在pom.xml中<build>……</build>添加<sourceDirectory>src/main/java</sourceDirectory><resources><resource><directory>src/main/resources</directory></resource></resources><outputDirectory>src/main/webapp/WEB-INF/classes</outputDirectory>7.添加struts-spring支持(action注解配置支持)Build path->add librariesMyeclipse libraries勾选struts 2 spring libraries8.修改struts.xml<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration2.1//EN" "/dtds/struts-2.1.dtd"><struts><constant name="struts.devMode" value="true" /><constant name="struts.objectFactory" value="spring" /><constant name="struts.i18n.encoding" value="UTF-8" /><constant name="struts.i18n.reload" value="true" /><constant name="struts.configuration.xml.reload" value="false" /><constant name="struts.custom.i18n.resources" value="content/Language" /><constant name="struts.serve.static.browserCache" value="false" /><constant name="struts.action.extension" value="do,action,jhtml,," /><constant name="actionPackages" value="com.frank.action" /> </struts>9.在LoginAction.java中添加调用StudentService@Resourceprivate StudentService studentService;测试Student s = studentService.findById(1);System.out.println(s.getName());10.success.jsp中添加<hr /> ${password}11.启动tomcat,地址栏输入http://localhost:8088/farsighted/点击submit效果如下包结构如下12.测试完成.。

Struts2+Spring3+Hibernate3 集成方法

Ｓｔｒｕｔｓ２＋Ｓｐｒｉｎｇ３＋Ｈｉｂｅｒｎａｔｅ３　集成　目　录　1.Struts2集成　．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．　１1.1. 把Struts提供的jar包拷贝到/WEB-INF/lib/目录下 (1)1.2. 在web.xml中配置Struts的过滤器 (2)2.Struts2开发　．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．　２2.1 编写Struts Action程序，需要继承ActionSupport (2)2.2 创建struts.xml的Action映射文件 (3)3.Struts2+Spring集成　．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．　３3.1 按第1步“Struts2集成”方法集成Struts2 (3)3.2 再把Struts的Spring插件把拷贝到/WEB-INF/lib/目录下 (3)3.3 把Spring提供的jar拷贝到/WEB-INF/lib/目录下 (3)3.4 web.xml配置Spring的过滤器 (3)3.5 创建applicationContext.xml配置文件 (4)4.Struts2+Spring+Hibernate集成　．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．　５4.1 先按照“Struts2+Spring集成”方法执行 (5)4.2 导入Apache Commons几个jar包 (5)4.3 导入Hibernate几个jar包 (5)4.4 数据库的JDBC驱动 (5)4.5 在applicationContext.xml中加入如下的配置 (5)4.6 创建hibernate.cfg.xml文件 (6)5.Struts2+Spring+Hibernate开发　．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．　６5.1 编写Model类 (6)5.2 编写Model类的HBM映射文件 (7)5.3 在applicationContext.xml中指定HBM映射文件路径 (8)5.4 编写DAO接口和实现类程序，并继承HibernateDaoSupport (8)5.5 在applicationContext.xml中配置DAO Bean (10)6.注意事项　．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．　１０1. Struts2集成1.1.把Struts提供的jar包拷贝到/WEB-INF/lib/目录下Struts需要如下几个包：解压：struts-2.2.3.1-lib.zip需要：struts2-core-2.2.3.1.jarxwork-core-2.2.3.1.jarognl-3.0.1.jarfreemarker-2.3.16.jarjavassist-3.11.0.GA.jar和所有以“commons-”开头的包。

整合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 下，我们再次启动项目的时候，错误信息应该会消失。

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+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】）。

Struts2.5+Hibernate3.1+Spring应用开发实例(图)

Struts2.5+Hibernate3.1+Spring应用开发实例.（Hibernate和Spring是新的知识点，先单独强化，然后再整合训练）任务一：Hibernate（10课时）该任务包括两个部分内容一是Hibernate的基础知识，二是实际完成一个Hibernate应用。

要求：掌握Hibernate的基础知识，掌握开发Hibernate应用的方法。

任务二：Sping（10课时）该任务包括两个部分内容一是介绍Spring的基础知识，二是完成一个Spirng 应用。

要求：掌握Spring的基础知识，掌握开发Spirng应用的方法。

任务三：Hibernate和Spring的联合开发（8课时）使用Hibernate和Spring框架完成Java应用开发要求：掌握使用Hibernate和Spring框架开发Java应用程序的过程。

任务四：基于Struts+Hibernate+Spring的网上购物系统开发（28课时）结合Hibernate和Spring改写《Java Web 应用开发项目教程》的前台要求：掌握使用Struts+Hibernate+Spring框架开发网上购物系统的方法实训要求：1.每位同学独立完成2.每部分内容按时提交代码和学习报告（总成绩由每次的节点成绩统计获得）软件环境需求：1.操作系统：WindowsXP2.数据库及驱动程序：Microsoft SQLServer 2005 JDBC3.JDK: JDK64.IDE：MyEclipse7.05.服务器：Tomcat6.0任务一Hibernate1.1Hibernate基础知识1.Hibernate简介Hibernate是一种Java语言下的对象-关系映射解决方案，它是一种自由、开源的轻量级框架，用于将面向对象的对象模型映射到传统的关系数据库中。

Hibernate对JDBC进行了轻量级的对象封装，不仅提供从Java数据类型到SQL数据类型的ORM映射，还提供数据查询和数据缓存功能，大幅度减少开发时人工使用SQL 和JDBC 处理数据的时间，使得Java程序员可以完全使用面向对象的编程思维通过Hibernata API操作关系数据库。

struts2+spring+hibernate分页显示完整代码

分页显示一直是web开发中一大烦琐的难题，传统的网页设计只在一个JSP或者ASP页面中书写所有关于数据库操作的代码，那样做分页可能简单一点，但当把网站分层开发后，分页就比较困难了，下面是我做Spring+Hibernate+Struts2项目时设计的分页代码，与大家分享交流。

1、DAO层接口的设计，在MemberDao接口中定义了如下两个方法：publicinterface MemberDao {@SuppressWarnings("unchecked")/*** 分页查询* @param hql查询的条件* @param offset 开始记录* @param length 一次查询几条记录* @return*/public List queryForPage(final Stringhql,finalint offset,finalint length);/*** 查询所有记录数* @param hql查询的条件* @param offset 开始记录* @return总记录数*/publicint getAllRowCount(String hql);}2、DAO层实现类MemberDaoImpl对上面两个方法的实现如下：publicclass MemberDaoImpl extends HibernateDaoSupport implements Me mberDao {/*** 查询所有记录数* @return总记录数*/publicint getAllRowCount(String hql) {return getHibernateTemplate().find(hql).size();}/*** 分页查询* @param hql查询的条件* @param offset 开始记录* @param length 一次查询几条记录* @return*/@SuppressWarnings("unchecked")public List queryForPage(final String hql, finalint offset, finalint length) {List list =getHibernateTemplate().executeFind(new HibernateCallback(){ public Object doInHibernate(Session session)throws HibernateException, SQLException {Query query = session.createQuery(hql);query.setFirstResult(offset);query.setMaxResults(length);List list = query.list();return list;}});return list;}}细心的读者会发现，这个类继承了HibernateDaoSupport类，HibernateDaoSupport是Spring 提供的对Hibernate支持的类，getHibernateTemplate().executeFind(new HibernateCallback(){....})方法中的参数，我们使用了接口回调，在其参数内，我们能像原生的Hibernate一样调用query.setFirstResult(offset)和query.setMaxResults(length)来实现分页查询功能。

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

Struts2+spring注解配置简介

INF/fail.jsp") }) String
是
无
指定result对应的
public class HelloWorld extends ActionSuppoUrRt L{
pSutrbinligc Strin否g executed(is){praettcuhrenr "failure指";}定result的类型
public String method1() {...} @Action("url")
public String method2() { ...} @Action("/different/url")
public String method3() {... } } 通过 /other/hello-world!method1.action 访问method1 方法。通过 /other/url!method2.action 访问method2 方法通过 /different /url!method3.action 访问method3 方法与@Action 注释不同的是，该注释覆盖了默认的namespace(这里是’/’)，此时再用hello!method1.action 已经不能访问method1 了.
类，
InterceptorRef s注解中
@InterceptorRefs 一组拦截器集合
类，action注解中
Struts2中使用注解配置Action
@ParentPackage
ParentPackage注解的参数，如下：
参数 value
类型 String
是否必需是
默认值无
描述指要继承的父包
Struts2中使用注解配置Action

hibernate持久化对象的三种状态及描述

hibernate持久化对象的三种状态及描述摘要：I.引言A.介绍Hibernate 持久化对象B.介绍Hibernate 持久化对象的状态II.Hibernate 持久化对象的三种状态A.临时状态(Transient)1.定义2.特点3.示例B.持久状态(Persistent)1.定义2.特点3.示例C.游离状态(Detached)1.定义2.特点3.示例III.状态转换A.临时状态转换为持久状态1.对象实例化2.添加到Session 缓存3.提交事务B.持久状态转换为游离状态1.从Session 缓存中移除2.数据库更新3.对象失去联系C.游离状态转换为持久状态1.重新关联对象和数据库记录2.添加到Session 缓存3.提交事务IV.结论A.总结Hibernate 持久化对象的状态B.强调状态转换的重要性C.展望未来Hibernate 的发展正文：Hibernate 是一种流行的Java 持久化框架，它可以将Java 对象映射到关系型数据库中。

在Hibernate 中，持久化对象有三种状态：临时状态(Transient)、持久状态(Persistent) 和游离状态(Detached)。

理解这些状态对于掌握Hibernate 的运行机制至关重要。

临时状态(Transient) 是指对象刚刚被创建，还没有与数据库建立关联。

这种状态下的对象不包含任何数据库记录，也不在Session 缓存中。

当一个对象实例化后，它处于临时状态。

持久状态(Persistent) 是指对象已经与数据库建立了关联，并且存在于Session 缓存中。

当对象被添加到Session 缓存后，它就变成了持久状态。

此时，对象的变化会被同步到数据库中。

游离状态(Detached) 是指对象与数据库的关联已经断开，但是仍然存在于内存中。

这种状态下的对象不再受Session 缓存的管理，但是它仍然保持着与数据库记录的映射关系。

当对象从Session 缓存中移除，但是还没有被提交事务时，它处于游离状态。

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