spring整合acegi(hibernate)

合集下载

SpringMVC+Spring+Hibernate框架整合原理,作用及使用方法

SpringMVC+Spring+Hibernate框架整合原理,作⽤及使⽤⽅法SSM框架是spring MVC ，spring和mybatis框架的整合，是标准的MVC模式，将整个系统划分为表现层，controller层，service层，DAO层四层使⽤spring MVC负责请求的转发和视图管理spring实现业务对象管理，mybatis作为数据对象的持久化引擎原理：SpringMVC：1.客户端发送请求到DispacherServlet（分发器）2.由DispacherServlet控制器查询HanderMapping，找到处理请求的Controller3.Controller调⽤业务逻辑处理后，返回ModelAndView4.DispacherSerclet查询视图解析器，找到ModelAndView指定的视图5.视图负责将结果显⽰到客户端Spring：我们平时开发接触最多的估计就是IOC容器，它可以装载bean（也就是我们中的类，当然也包括service dao⾥⾯的），有了这个机制，我们就不⽤在每次使⽤这个类的时候为它初始化，很少看到关键字new。

另外spring的aop，事务管理等等都是我们经常⽤到的。

Mybatis：mybatis是对jdbc的封装，它让数据库底层操作变的透明。

mybatis的操作都是围绕⼀个sqlSessionFactory实例展开的。

mybatis通过配置⽂件关联到各实体类的Mapper⽂件，Mapper⽂件中配置了每个类对数据库所需进⾏的sql语句映射。

在每次与数据库交互时，通过sqlSessionFactory拿到⼀个sqlSession，再执⾏sql命令。

使⽤⽅法：要完成⼀个功能：1. 先写实体类entity，定义对象的属性，（可以参照数据库中表的字段来设置，数据库的设计应该在所有编码开始之前）。

2. 写Mapper.xml（Mybatis），其中定义你的功能，对应要对数据库进⾏的那些操作，⽐如 insert、selectAll、selectByKey、delete、update等。

Spring集成Acegi安全框架在J2EE中的应用

中图分类号：Ｐ９Ｔ３１
文献标识码：Ａ
文章编号：１７ — ２６２１）７０２ — ３６４６３（０２０ — ０９０
Ｓｒｎｅｉｎｅｒｔｄｓｃｒｔｒｍｅｒ２ｐｌａｉｎｐｉｇＡｃｇｔｇａｅｅｕｉｆａｗｏｋｉＪＥＥａｐｉｔｉｙｎｃｏ
ｓｃｒｙｆｍｅｒｏｎｙｓｖｓｈｏｋｃｄ，ｍｐｏｅｃｄｎｆｃｅｃａｄｉｒｖｅｑａｉｆｏｅｅｕｔａｗｏｋｎｔｌａｅｅｗｒｌ・ｉｒｖｏｉｇｅｉｉｎｙ，ｎｉｒｏｔａｍｐｏｅｔｕｌｙｏｄ．ｈｔｃ
张国平．马丽
（顶山学院软件学院，河南平项山４７０）平６００
摘要：ｐｎｒｍｗｒ一个开发ＪＥ应用的优秀框架。ｐｎ本身没有提供对系统安全方面的支持。而对于一ＳｒｇＦａｅｏｋ是ｉ２ＥＳｒｇｉ然
ＺＨＡＮＧｏｐｎ，ＭＡｉＧｕ — ｉｇＬ
（ｏｗｒ０Ｓａｅｃｔｆ
，ｉｇｉｓａｎｖｒｔ，ｉｇｉｓａ６００Ｃｉ）ＰｎｄｎｈｎＵｉｅｉＰｎｄｎｈｎ４７０，ｈｎｇｓｙｇａ
ＡｂｔａｔＴｅＳｒｇＦａｗｒｎｅｃ￣ｎａｗｒｏｅｅｏｉｇＪＥＥａｐｉａｉｎ，Ｓｒｇｉｅｆｄｅｏｒｖｄｓｒｃ：ｈｐｎｒｍｅｏｋｉａｘｅｅｔｒｍｅｏｋｆｒｄｖｌｐｎ２ｐｌｔｓｐｎｔｌｏｓｎｔｏｉｅｉｓｆｃｏｉｓｐ

Spring整合Hibernate

Spring3整合Hibernate3实现简单的增删改查(XML):以前我们的代码中是通过hibernate配置文件hibernate.cfg.xml中设置和数据库连接有关的信息:jdbc... .现在可以将这些配置全部放在spring中来进行管理. 在我们整合过程之前的hibernate.cfg.xml可以不存在了.1.Spring中配置数据源的方法:实例化一个类对象，后面有dao操作有关的代码，可以直接饮用这个dataSource,和连接池有关的参数.<bean id="dataSource"class="mons.dbcp.BasicDataSource"destroy-m ethod="close"><property name="driverClassName"value="com.mysql.jdbc.Driver"/><property name="url"value="jdbc:mysql://localhost:3306/spring"/><property name="username"value="root"/><property name="password"value="123456"/></bean>以上的写法，value的值都是固定的，硬编码在配置文件中,如果不想修改配置文件.创建一个独立的和数据源配置有关的属性文件.占位符的形式来配置数据源，好处如果数据库有关的配置信息发生改变不需要修改源文件: PropertyPlaceholderConfigurer<beanclass="org.springframework.beans.factory.config.PropertyPlaceholderConfig urer"><property name="locations"><value>classpath:jdbc.properties</value></property></bean><bean id="dataSource"destroy-method="close"class="mons.dbcp.BasicDataSource"><property name="driverClassName"value="${jdbc.driverClassName}"/><property name="url"value="${jdbc.url}"/><property name="username"value="${ername}"/><property name="password"value="${jdbc.password}"/></bean>2.将其注入到XXDao中: 可通过注解或者是xml形式:Dao中操作过程中用到数据源,去找谁? Srpingpublicclass UserDaoImpl implements UserDao {private DataSource dataSource;public DataSource getDataSource() {return dataSource;}@Resource(name="dataSource") 这里引用datasource是spring中配置好一个bean的信息.publicvoid setDataSource(DataSource dataSource) {this.dataSource = dataSource;}}以上是注解的写法,如果改成xml格式?<bean class=”erDaoImpl”><property name=”dataSource” ref=”dataSource”></bean>以上也只是得到一个和连接有关的DataSource而已,.实具体执行的sql代码还是要我们自己写?正长情况这些东西一定是hibernate帮我们做的.在srping中如何整合hibernate呢?以前的操作:1得到一个Configuration =>读取hibernate全局的配置文件2.得到一个sessionFactorySpring3整合hibernate3重点就是需要初始化SessionFactory这个bean,需要在Spring的配置文件中进行配置，同时让Spring来管理SessionFactroy,Session,Transaction等，实现实例:有了上面配置的datasource后就可以将其注入给SessionFactory了:<bean id="sessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"><property name="mappingResources"><list><value>com/etc/entity/Users.hbm.xml</value></list></property><！-③hibernateProperties 主要用来设置数据库方言是否显示sql语句以及ddl---><property name="hibernateProperties"><props><prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop><prop key="hibernate.show_sql">true</prop><prop key="hibernate.format_sql">true</prop><prop key="hibernate.hbm2ddl.auto">update</prop></props></property></bean>1.新建web Project，增加支持Spring的完整包;spring-tx-3.2.15.RELEASE.jarspring-orm-3.2.15.RELEASE.jarspring-jdbc-3.2.15.RELEASE.jarspring-expression-3.2.15.RELEASE.jarspring-core-3.2.15.RELEASE.jarspring-context-support-3.2.15.RELEASE.jarspring-context-3.2.15.RELEASE.jarspring-beans-3.2.15.RELEASE.jarspring-aop-3.2.15.RELEASE.jar2.增加Hibernate支持包(参考之前的笔记和项目):3.其他支持包:commons-dbcp-1.2.2.jarcommons-pool-1.4.jarlog4j-1.2.17.jarslf4j-log4j12-1.5.8.jarmysql-connector-java-5.1.5-bin.jar增加外部jar支持的原则是，宁可少，根据错误提示增加缺失的包进来;也不要一下子加太多.不能重复添加同名的jar。

spring和Hibernate的工作原理

spring工作原理spring的最大作用ioc/di,将类与类的依赖关系写在配置文件中，程序在运行时根据配置文件动态加载依赖的类，降低的类与类之间的藕合度。

它的原理是在applicationContext.xml加入bean标签,在bean标签中通过class属性说明具体类名、通过property标签说明该类的属性名、通过constructor-args说明构造子的参数。

其一切都是返射，当通过applicationContext.getBean("id名称")得到一个类实例时，就是以bean标签的类名、属性名、构造子的参数为准，通过反射实例对象，唤起对象的set方法设置属性值、通过构造子的newInstance实例化得到对象。

正因为spring一切都是反射，反射比直接调用的处理速度慢，所以这也是spring 的一个问题。

spring第二大作用就是aop，其机理来自于代理模式，代理模式有三个角色分别是通用接口、代理、真实对象代理、真实对象实现的是同一接口，将真实对象作为代理的一个属性，向客户端公开的是代理，当客户端调用代理的方法时，代理找到真实对象，调用真实对象方法，在调用之前之后提供相关的服务，如事务、安全、日志。

其名称分别是代理、真实对象、装备、关切点、连接点。

spring也不是帮我们去new的，因为new这个东西实在是不好，spring是通过反射的机制帮助我们实现的，建议你去看看java的反射和动态代理，这个对你spring乃至以后的学习都是非常有用的！spring是一个非常优秀的框架，他的官方强烈推荐使用面向接口编程，非常好的思想！方便以后程序的扩展！有兴趣真的可以好好的研究下spring，你会知道大师级们写代码就是不一样！Hibernate工作原理学习过程是首先看看java反射的概念,然后学学AOP原理：1.读取并解析配置文件2.读取并解析映射信息，创建SessionFactory3.打开Sesssion4.创建事务Transation5.持久化操作6.提交事务7.关闭Session8.关闭SesstionFactory为什么要用：1. 对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码。

Spring+Hibernate整合配置

为什么要用Spring来管理Hibernate呢？我们可以参考以下步骤。

首先我们来看一下Hibernate进行操作的步骤。

比如添加用户的一个步骤。

在此为了解释提出的问题，只做一个截图，若想看完整代码示例，可以参考《八步详解Hibernate的搭建及使用》看截图，可以看出，Hibernate操作的步骤如下：1.获得Configuration对象2.创建SessionFactory3.创建Session4.打开事务5.进行持久化操作。

比如上面的添加用户操作6.提交事务7.发生异常，回滚事务8.关闭事务使用Hibernate进行访问持久层，每次都要进行这八个步骤。

但是若使用Spring对Hibernate进行管理，又是怎么样的呢?首先，Spring对Hibernate提供了HibernateTemple类。

这个模版类对session进行封装。

并且Spring会默认为自动提交事务。

所在在dao层直接写入this.save(Object)即可。

在实践中，遇到了一个问题，无法插入数据库，经过一番折腾，多次实验，验证，总结一下原因，结果如下：注意：所有的操作都必须在事务中进行。

若单纯的使用Hibernate,则事务需要手动开启提交关闭操作。

当然也可以在Hibernate配置文件中，自动提交。

若使用Spring管理Hibernate,则默认的是自动提交事务。

但是在此，需要注意的是：若使用Spring在配置文件中配置数据源而不使用hibernate.cfg.xml,则可以成功插入数据库，因为HibernateTemple默认提供自动提交事务。

在Spring的配置文件配置数据源如下：使用此数据源需要的jar如下：commons-dbcp.jar,commons-pool.jar,msbase.jar,mssqlserver.jar,msutil.jar,s qljdbc4.jar;org.hibernate.dialect.SQLServerDialectupdate!-- 如果采用传统的hbm.xml的方式，可以采用如下方式来简化注册hbm.xml的步骤，并且class为LocalSessionFactoryBean-->classpath:User.hbm.xml若Spring中不是直接配置数据源，而是使用hibernate.cfg.xml,则是无法若直接this.save(Object)，则无法插入数据库中，但是可以保存中缓存中。

spring+acegi+中文手册

本章内容：n Acegi安全系统介绍n 使用Servlet过滤器保护Web应用系统n 基于数据库或LDAP进行身份认证n 透明地对方法调用进行保护你是否曾注意到在电视连续剧中大多数人是不锁门的？这是司空见惯的。

在情景喜剧Seinfeld中，Krammer常常到Jerry的房间里自己仍冰箱里拿东西吃。

在Fri ends中，各种各样的剧中人经常不敲门就不假思索地进入别人的房间。

甚至有一次在伦敦，Ross突然进入Chandler的旅馆房间，差点儿撞见Chandler和Ross的妹妹的私情。

在20世纪50年代Leave It to Beaver热播的时代，并不值得为人们不锁门这一现象大惊小怪。

但在如今这个隐私和安全极受重视的时代，看到电视剧中的角色允许他人大摇大摆地进入自己的家中或房间中实在让人觉得难以置信。

类似地，在软件系统中，允许仸何人可以访问敏感或者私密的信息是不明智的。

应用系统必须通过质询来验证用户身份，据此决定是允许还是拒绝他访问受限制的信息。

无论你是通过用户名/密码来保护一个电子邮件账号，还是基于交易个人身份号码来保护一个佣金账户，安全性都是大多数应用系统的一个重要切面。

我们有意选择“切面”这个词来描述应用系统的安全性。

安全性是超越应用系统功能特性的一个关注点。

应用系统的绝大部分不应该亲自参与到与安全相关的处理中。

尽管你能够把与安全相关的处理直接编码到应用系统中（这种情况并不少见），但更好的做法还是将安全有关的关注点与应用系统的关注点分开。

如果你想到这听上去好像安全性是通过“面向切面”技术实现的，那你猜对了。

在本章中，我们将向你介绍Acegi安全系统，并探讨使用Spring AOP和Servlet 过滤器来保护应用系统的各种手段。

11.1 Acegi安全系统介绍Acegi是一个能够为基于Spring的应用系统提供描述性安全保护的安全框架。

它提供了一组可以在Spring应用上下文中配置的Bean，充分利用了Spring对依赖注入和面向切面编程的支持。

spring入门(11)-spring与hibernate整合完成增删改查的操作(封装HibernateTemplate模版类对象)

今天是spring的最后一节课，这节课老师讲了spring与hibernate整合完成增删改查的操作，这是很重要的一节课，这也是第一次真正的实现spring结合Hibernate和数据库连接上，下面是这次课的过程实现：首先是数据库建表：采用Oracle数据库，在Scott用户里新建USERS表，所用jar包:实现源码如下：Users.java[java]01. package www.csdn.spring.hibernate.domain;03. import java.io.Serializable;04. import java.util.Date;05.06. public class Users implements Serializable {07.08. /**09. *10. */11. private static final long serialVersionUID = 1L;12.13. private Integer id;14. private String name;15. private Date regTime;16.17. public Users() {18. super();19. // TODO Auto-generated constructor stub20. }21.22. public Users(Integer id, String name, Date regTime) {23. super();24. this.id = id;25. = name;26. this.regTime = regTime;27. }28.29. public Integer getId() {30. return id;31. }32.33. public void setId(Integer id) {34. this.id = id;35. }36.37. public String getName() {38. return name;39. }40.41. public void setName(String name) {42. = name;43. }44.45. public Date getRegTime() {46. return regTime;47. }48.49. public void setRegTime(Date regTime) {50. this.regTime = regTime;51. }52.53. @Override54. public String toString() {55. return"Users [id=" + id + ", name=" + name + ", regTime=" + regTime56. + "]";57. }58.Users.hbm.xml[html]01. <!DOCTYPE hibernate-mapping PUBLIC02. "-//Hibernate/Hibernate Mapping DTD 3.0//EN"03. "/dtd/hibernate-mapping-3.0.dtd">04. <hibernate-mapping package="www.csdn.spring.hibernate.domain">05. <class name="Users"table="USERS"schema="SCOTT">06. <id name="id"column="ID">07. <generator class="sequence">08. <param name="sequence">USERS_SEQ</param>09. </generator>10. </id>11.12. <property name="name"type="string"column="NAME"/>13. <property name="regTime"type="timestamp"column="REGTIME"/>14.15. </class>16.17. </hibernate-mapping>UsersDao.java[java]01. package www.csdn.spring.hibernate.dao;02.03. import java.util.List;04.05. import ers;06.07. public interface UsersDao{08. public void save(Users entity);09. public void deleteById(Class clazz,Integer id);10. public List<Users> getObjects(Class clazz);11. public void update(Users entity);12. }UsersDaoImpl.java[java]01. package www.csdn.spring.hibernate.dao;02.03. import java.util.List;04.05. import org.springframework.orm.hibernate3.HibernateTemplate;06.07. import ers;09. public class UsersDaoImpl implements UsersDao{10. // 封装模版类对象11. private HibernateTemplate hibernateTemplate;12.13. // 注入14. public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {15. this.hibernateTemplate = hibernateTemplate;16. }17.18. @Override19. public void save(Users entity) {20. hibernateTemplate.save(entity);21.22. }23. @Override24. public List<Users> getObjects(Class clazz) {25.26. return hibernateTemplate.find("from "+clazz.getName());27. }28.29. @Override30. public void deleteById(Class clazz,Integer id) {31. //hibernateTemplate.delete(hibernateTemplate.get(clazz.getName(), id));32. hibernateTemplate.bulkUpdate("delete from "+clazz.getName()+" where id="+id);33. }34.35. @Override36. public void update(Users entity) {37. hibernateTemplate.update(entity);38.39. }40.41. }UserTest.java[java]01. package www.csdn.spring.hibernate.dao;02.03.04.05. import java.util.Date;06. import java.util.List;07.08. import org.junit.Test;09. import org.springframework.context.ApplicationContext;10. import org.springframework.context.support.ClassPathXmlApplicationContext;11.12. import ers;13.14. public class UserTest {15. //保存16. @Test17. public void save(){18. ApplicationContext ac=new ClassPathXmlApplicationContext("app*.xml");19. UsersDao usersdao=ac.getBean("usersDaoImpl",UsersDao.class);20. usersdao.save(new Users(null,"chrp999999999",new Date()));21.22. System.out.println(usersdao.getClass());23.24. }25. //获取所有26. @Test27. public void getObjects(){28. ApplicationContext ac=new ClassPathXmlApplicationContext("app*.xml");29. UsersDao usersdao=ac.getBean("usersDaoImpl",UsersDao.class);30.31. List<Users> user=usersdao.getObjects(Users.class);32. for(Users u:user){33. System.out.println(u.toString());34. }35. }36. //根据id删除37. @Test38. public void delete(){39. ApplicationContext ac=new ClassPathXmlApplicationContext("app*.xml");40. UsersDao usersdao=ac.getBean("usersDaoImpl",UsersDao.class);41. usersdao.deleteById(Users.class,5);42.43.44. System.out.println(usersdao.getClass());45.46. }47. //更新48. @Test49. public void update(){50. ApplicationContext ac=new ClassPathXmlApplicationContext("app*.xml");51. UsersDao usersdao=ac.getBean("usersDaoImpl",UsersDao.class);52. usersdao.update(new Users(2,"deep",new Date()));53.54.55. System.out.println(usersdao.getClass());56.57. }58.59. }jdbc.properties[plain]01. jdbc.driverClassName=oracle.jdbc.driver.OracleDriver02. ername=scott03. jdbc.password=tiger04. jdbc.url=jdbc\:oracle\:thin\:@127.0.0.1\:1521\:orclapplicationContext.xml[html]01. <?xml version="1.0"encoding="UTF-8"?>02. <beans xmlns="/schema/beans"03. xmlns:context="/schema/context"04. xmlns:xsi="/2001/XMLSchema-instance"05. xsi:schemaLocation="/schema/beans06. /schema/beans/spring-beans.xsd07. /schema/context08. /schema/context/spring-context.xsd">09.10. 11. <import resource="spring.xml"/>12. <import resource="spring-dao.xml"/>13.14.15. 16. <context:property-placeholder location="jdbc.properties"/>17.18. </beans>spring.xml[html]01. <?xml version="1.0"encoding="UTF-8"?>02. <beans xmlns="/schema/beans"03. xmlns:context="/schema/context"04. xmlns:aop="/schema/aop"05. xmlns:tx="/schema/tx"06. xmlns:xsi="/2001/XMLSchema-instance"07. xsi:schemaLocation="/schema/beans08. /schema/beans/spring-beans.xsd09. /schema/context10. /schema/context/spring-context.xsd11. /schema/aop12. /schema/aop/spring-aop.xsd13. /schema/tx14. /schema/tx/spring-tx.xsd">15. 16. <bean id="dataSource"class="mons.dbcp.BasicDataSource">17. 18. <property name="driverClassName"value="${jdbc.driverClassName}"/>19. 20. <property name="username"value="${ername}"/>21. 22. <property name="password"value="${jdbc.password}"/>23. 24. <property name="url"value="${jdbc.url}"/>25. 26. 27. </bean>28. 29. 30. <bean id="localSessionFactoryBean"spring-dao.xml[html]01. <?xml version="1.0"encoding="UTF-8"?>02. <beans xmlns="/schema/beans"03. xmlns:xsi="/2001/XMLSchema-instance"04. xsi:schemaLocation="/schema/beans05. /schema/beans/spring-beans.xsd">06.07.08. <bean id="usersDaoImpl"class="ersDaoImpl">09. <property name="hibernateTemplate"ref="hibernateTemplate">10. </property>11. </bean>12.13. </beans>到此为止简单的spring+Hibernate完成增删改查就实现了，运行测试类UserTest.java后结果如下。

springmvc+spring+hibernate整合详解注解形式事物管理

Springmvc4+spring4+hibernate4整合步骤前言：(声明式事务管理采用配置文件来配置事物)准备工作：1/安装并配置java运行环境2/数据库的安装配置（Mysql）3/安装并配置服务器(Tomcat)4/Maven5/ IntelliJIDEA的安装配置（本人使用的主要软件是IntelliJIDEA,没用eclipse什么的）6/ 使用IntelliJIDEA创建一个web app项目。

一、在pom.xml文件中引入相关框架整合的依赖二、SpringMvc配置：我们先配置下SpringMVC的配置：resources/META-INF/spring-mvc.xml（也可以把OK，SpringMVC配置完成，现在我们进行一下测试吧在controller层新建一个TestController，内容如下test.jsp网页如下：重启Tomcat服务器，然后浏览器访问localhost:8080/test如下图所示：三、springmvc+Spring整合这个就十分简单了，配置applicationContext.xml这个Spring的配置文件如下：完善web.xml配置文件如下：（applicationContext.xml在META-INF文件夹下配置如下）,如果直接在resources下配置：classpath*:/applicationContext.xmlweb.xml配置文件中更改了三处：引入Spring配置文件Spring的监听器以及字符集过滤，以及加载Spring上下文配置OK，Spring+SpringMVC配置完成，下面我们开始测试：在service写一个TestServiceImpl实现TestService接口并实现其test()方法，代码如下：TestServiceTestServiceImplTestController更改如下：控制器这里我们运用了Spring的依赖注入自动装配。

springMVC与hibernate整合实例

SpringMVC的搭建一直以来接触到的都是SSH的框架，形成了MVC模式，本来并没有想着去弄另一个MVC模式，但现在springMVC模式很热，所以我也学习一下，首先我声明一下，这个框架我也是在网上找了一些资料才完成的，源文件等也是利用的网上的现成的，但是有对其进行修改。

下面来详细的说一说这个模式的搭建。

首先在spring中是以controller来作为控制器（相当于SSH中的action），其他的和SSH框架没有区别。

因为Spring是基于注解的，所以在整个的模式中都是采用注解的方式来处理，这个项目是用springMVC+hibernate一起来搭建的。

这个项目的搭建我花了很久的时间，也弄了蛮久才成功，希望日后能更加完善！理解更加的深入。

一：整体框架的结构图以及所需的jar包。

这里spring是3.0.1，hibernate是用的3.6，数据库是用的mysql 5.6 ，前提工作是要建立好一个数据库，我这里是名为springmvc的数据库来进行操作，这里是采用的hibernate自动更新的方式，所以可以不需要建表只需要建立起数据库就好。

项目框架的代码结构：二：开始搭建环境。

1，首先把上面所需的包添加进来后，我们要在/WEB-INF目录下的web.xml里面添加spring的监听器，以及相关的配置。

源码如下：<?xml version="1.0"encoding="UTF-8"?><web-app version="2.5"xmlns="/xml/ns/javaee"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/xml/ns/javaee/xml/ns/javaee/web-app_2_5.xsd"><display-name>s3h3</display-name><context-param><param-name>contextConfigLocation</param-name><param-value>classpath:applicationContext*.xml</param-value> </context-param><listener><listener-class>org.springframework.web.context.ContextLoaderList ener</listener-class></listener><servlet><servlet-name>spring</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet</se rvlet-class><init-param><param-name>contextConfigLocation</param-name><param-value>/WEB-INF/spring-servlet.xml</param-value> </init-param><load-on-startup>1</load-on-startup></servlet><servlet-mapping><servlet-name>spring</servlet-name> <url-pattern>*.do</url-pattern></servlet-mapping><welcome-file-list><welcome-file>index.html</welcome-file><welcome-file>index.htm</welcome-file><welcome-file>index.jsp</welcome-file><welcome-file>default.html</welcome-file><welcome-file>default.htm</welcome-file><welcome-file>default.jsp</welcome-file></welcome-file-list></web-app>2，接下来可以编写spring的配置文件，来整合hibernate，主要的配置写在一个专门存放配置文件的源码目录下config文件夹下，这里的applicationContext.xml是spring的主要配置文件，包括数据源等的配置。

SpringMVC+Spring+Hibernate集成详解

Spring+SpringMVC+Hibernate框架集成详解注：此文档只说明简单的框架集成，各个框架的高级特性未涉及，此文档适合有框架使用基础的开发人员查看，新手可能需要参考其他资料。

1.准备工作开发环境：JDK 7u80、Eclipse 4.4 、Tomcat 7.0.63、MySQL 5.6、Tomcat JDBC POOL框架：Spring 3.2.14、Hibernate 3.6.10、common-logging 1.2、aopalliance.jar、aspectjweaver.jar、mysql-connector-java-5.1.35-bin.jar在Eclipse下创建动态web项目Test，创建过程中注意勾选web.xml的选项，如果不勾选，项目创建之后需要手动创建web.xml，创建完成后将其部署到Tomcat中，项目结构应该如下(Package Explorer下，看个人习惯)：2.配置Spring1)将以下JAR包复制到lib文件夹下，不要问为什么是这些，想知道为什么可以把其他任意一个删掉看看启动项目报什么错。

2)在web.xml中添加如下代码：3)创建applicationContext.xml，当前版本的Spring默认其位于WEB-INF下，不过大多数开发人员习惯还是将其放到src下，这里我们将其放在src下。

4)向applicationContext.xml中添加bean相关声明，具体如下：5)在web.xml中添加如下内容，用于自定义Spring配置文件的位置：3.测试Spring注：以下均为测试代码，测试完成后可以删除，User类建议保留，之后用于测试框架的集成情况1)新建测试实体类User，路径暂定为com.test.entity，添加如下代码(因为篇幅限制，所以图中无get和set方法，请自行添加)2)applicationContext.xml中添加如下定义：3)新建Test类，暂定路径com.test.test，添加如下代码：4)运行Test类查看结果，如果输出test则表示spring框架运行正常。

Spring整合Hibernate

Spring整合Hibernate（1）2009年07月19日星期日 10:246.5 Spring整合Hibernate时至今日，可能极少有J2EE应用会直接以JDBC方式进行持久层访问。

毕竟，用面向对象的程序设计语言来访问关系型数据库，是一件让人沮丧的事情。

大部分时候，J2EE应用都会以ORM框架来进行持久层访问，在所有的ORM框架中，Hibernate 以其灵巧、轻便的封装赢得了众多开发者的青睐。

Spring具有良好的开放性，能与大部分ORM框架良好整合。

下面将详细介绍Spring与Hibernate的整合。

6.5.1 Spring提供的DAO支持DAO模式是一种标准的J2EE设计模式，DAO模式的核心思想是，所有的数据库访问，都通过DAO组件完成，DAO组件封装了数据库的增、删、改等原子操作。

而业务逻辑组件则依赖于DAO组件提供的数据库原子操作，完成系统业务逻辑的实现。

对于J2EE应用的架构，有非常多的选择，但不管细节如何变换，J2EE应用都大致可分为如下3层：● 表现层。

Jsp struts● 业务逻辑层。

Manager service spring● 数据持久层。

DAO模式 --------------jdbc或者 hibernate● DB轻量级J2EE架构以Spring IoC容器为核心，承上启下。

其向上管理来自表现层的Action，向下管理业务逻辑层组件，同时负责管理业务逻辑层所需的DAO对象。

各层之间负责传值的是值对象，也就是JavaBean实例。

图6.5精确地描绘了轻量级J2EE架构的大致情形。

DAO组件是整个J2EE应用的持久层访问的重要组件，每个J2EE应用的底层实现都难以离开DAO组件的支持。

Spring对实现DAO组件提供了许多工具类，系统的DAO组件可通过继承这些工具类完成，从而可以更加简便地实现DAO组件。

Spring的DAO支持，允许使用相同的方式、不同的数据访问技术，如JDBC、Hibernate或JDO。

Spring Framework-5-在Spring中整合Hibernate

– 总的说来,该类的方法和Session接口中定义的方法是
一致的.
HibernateDaoSupport

HibernateDaoSupport
– org.springframework.orm.hibernate3.suppo
rt.HibernateDaoSupport – 该类用于对DAO提供支持 – 编写通用接口的实现类时必须继承该类. – 重要方法
配置LocalSessionFactoryBean
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <property name="dataSource"> <ref bean="dataSource"/> </property> <property name="mappingDirectoryLocations"> <list> <value>classpath:/com/aptech/pojo</value> </list> </property> <property name="hibernateProperties"> <props> <prop key="hibernate.dialect"> org.hibernate.dialect.MySQLDialect </prop> <prop key="hibernate.show_sql">true</prop> </props> </property> </bean>

跟我学Hibernate框架技术——Spring 与Hibernate3X的整合技术及应用实例

目录1.1Spring 与Hibernate3X的整合技术及应用实例 (2)1.1.1Hibernate O/R Mapping结合IOC容器技术 (2)1.1.2为了实现整合在Spring中提供了相应的组件类 (4)1.1.3实现相互整合的两种方式 (7)1.1.4Spring完整地包装Hibernate的实现过程及实例 (10)1.1.5采用Hibernate的hibernate.cfg.xml文件的实现方案及实例 (23)1.1.6基于Hibernate3的原生API实现DAO的功能实现实例 (27)1.1 Spring 与Hibernate3X的整合技术及应用实例1.1.1Hibernate O/R Mapping结合IOC容器技术1、Hibernate 和Spring共同的关键特征：建立对象关系（1）Spring中建立“对象依赖”关系在返回对象给客户之前，Spring建立对象之间的依赖关系，这样减少了在使用这些对象的客户中的大量代码。

（2）Hibernate中建立“O/R Mapping”关系Hibernate专门在返回一个完整的对象模型给客户之前构造出数据模型和对象模型之间的依赖关系。

当直接使用JDBC来映射数据模型到对象模型的时候，我们通常需要写大量的代码来建立对象模型。

Hibernate减少了这部分这样的编码工作。

2、Spring可以与Hibernate结合使用由于我们在实际的应用系统中经常需要使用O/R mapping技术和工具，而不是直接使用如JDBC等对关系数据库访问的技术。

因此，我们也希望所使用的应用程序框架也最号能够支持它，而Spring的设计者已经为我们考虑了这些应用的需求。

在Spring中提供了对Hibernate和JDO等的集成支持。

它的数据访问架构使得它能和任何底层的数据访问技术集成。

Spring和Hibernate集成得尤其好。

3、Spring与Hibernate相互结合时所应该注意的问题要把Spring和Hibernate相互结合从实现的角度来看并不难，无非是配置几个Bean。

Spring+Hibernate整合

至于配置文件为什么这样写，这里不做解释。本文重点描述怎样将 Spring 和 Hibernate
2
两个框架集成起来。在完成了上面的 Log4j 导入工作后，再将数据库连接 Jar 包导入，这里用的是 MySQL 数
据库，所以使用 mysql-connector-java-commercial-5.1.25-bin.jar，这个也是直接将 Jar 包拷到工程的 WebRoot/WEB-INF/lib 目录下即可。所有基础工作做完后工程的结构应该是图 3 的样子：
</bean> </beans>
我们发现，配置文件中自动添加了 id 为 sessionFactory 的 bean，这个是由于我们添加了 Hibernate 支持后 MyEclipse 为我们自动生成的配置，当然了这个还不能直接使用，我们还需要进行详细的配置。
五、在配置文件中添加 Hibernate 配置
 <bean id="dataSource" class="mons.dbcp.BasicDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"></property> <property name="url" value="jdbc:mysql://localhost:3306/test_db" /> <property name="username" value="root" /> <property name="password" value="" /> </bean>

spring和hibernate整合操作步骤

整合spring和hibernate步骤如下：1、打开已有的spring项目。

把hibernate的基本jar包拷贝到项目的lib文件夹中。

添加后jar 包如图所示:2、拷贝hibernate.cfg.xml文件到自己的项目中的src下。

配置如图所示:Hinerbate.cfg.xml中的基本配置不在这里赘述。

3、给自己项目中的实体类（entity/pojo）添加对应的映射文件如图：注：此映射文件只是针对项目blog中的实体类，至于映射文件的详细映射内容不在这里赘述，全部以上课内容为主。

4、在hibernate.cfg.xml中添加对应的映射文件，通知hibernate映射文件的存在。

如图：Hibernate的基本支持添加完成，可以简单测试。

下面开始spring和hibernate的整合。

1、为了方便测试我首先使用java项目模式,将spring的配置文件applicationContext.xml文档拷贝到src下边。

（当然web项目必须把applicationContext.xml放在WEB-INF下）。

2、在项目添加spring的jar包aspectjrt.jar和aspectjweaver.jar，这是为了支持和hibernate的整合。

这两个jar包的目录如图所示:--------------------------------------------------------------------------------------------------第一种整合方式（hibernate完全托管于spring管理）1、在applicationContext.xml文件中添加dataSource的配置，效果如图所示：2、在applicationContext.xml中添加sessionfactory的配置，效果如图所示：3、在applicationContext.xml中添加事务管理切面的配置，效果如图所示：4、编写dao.impl下的实现类，这里以UserDaoImpl为例，效果如图所示：5、在applicationContext.xml中添加HUserDaoImpl.java的配置，效果如图所示:注：这里的配置只是纯粹的对HUserDaoImpl的配置，并未织入事务。

Spring整合Hibernate详细步骤

Spring整合Hibernate详细步骤⼀、概述 Spring整合Hibernate有什么好处？ 1、由IOC容器来管理Hibernate的SessionFactory 2、让Hibernate使⽤上Spring的声明式事务⼆、整合步骤整合前准备：持久化类：@Entitypublic class Book{private Integer id;private String bookName;private String isbn;private int price;private int stock;public Integer getId(){return id;}public void setId(Integer id){this.id = id;}public String getBookName(){return bookName;}public void setBookName(String bookName){this.bookName = bookName;}public String getIsbn(){return isbn;}public void setIsbn(String isbn){this.isbn = isbn;}public int getPrice(){return price;}public void setPrice(int price){this.price = price;}public int getStock(){return stock;}public void setStock(int stock){this.stock = stock;}public Book(Integer id, String bookName, String isbn, int price, int stock){super();this.id = id;this.bookName = bookName;this.isbn = isbn;this.price = price;this.stock = stock;}} Dao层：public interface BookDao{public String findBookById(int id);public void saveBook(Book book);} DaoImpl:@Repositorypublic class BookDaoImpl implements BookDao{@Autowiredprivate SessionFactory sessionFactory;//获取和当前线程绑定的Seesionprivate Session getSession(){return sessionFactory.getCurrentSession();}public String findBookById(int id){String hql="SELECT bookName from Book where id=?";Query query=getSession().createQuery(hql).setInteger(0, id);String str= query.uniqueResult().toString();return str;}public void saveBook(Book book){getSession().save(book);}} Service层：public interface BookService{public String findBookById(int id);public void saveBook(Book book);} ServiceImpl：@Servicepublic class BookServiceImpl implements BookService{@Autowiredprivate BookDao bookDao;public String findBookById(int id){return bookDao.findBookById(id);}public void saveBook(Book book){bookDao.saveBook(book);}} 1、加⼊Hibernate加⼊hibernate jar包添加Hibernate的配置⽂件：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="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property><property name="hibernate.show_sql">true</property><property name="hbm2ddl.auto">update</property></session-factory></hibernate-configuration>编写持久化类对应的.hbm.xml⽂件<?xml version="1.0"?><!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN""/hibernate-mapping-3.0.dtd"><hibernate-mapping><class name="com.demo.ssm.po.Book" table="BOOK"><id name="id" type="ng.Integer"><column name="ID"/><generator class="native"/></id><property name="bookName" type="ng.String"><column name="BOOK_NAME"/></property><property name="isbn" type="ng.String"><column name="ISBN"/></property><property name="price" type="int"><column name="PRICE"/></property><property name="stock" type="int"><column name="STOCK"/></property></class></hibernate-mapping> 2、加⼊Spring加⼊spring jar包加⼊Spring配置⽂件<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:tx="/schema/tx"xmlns:aop="/schema/aop"xmlns:context="/schema/context"xsi:schemaLocation="/schema/beans /schema/beans/spring-beans.xsd /schema/context /schema/context/spring-context-4.1.xsd/schema/aop /schema/aop/spring-aop-4.1.xsd/schema/tx /schema/tx/spring-tx-4.1.xsd"><context:component-scan base-package="com.demo.ssm"></context:component-scan><bean id="dataSource" class="mons.dbcp.BasicDataSource" destroy-method="close"><property name="driverClassName" value="com.mysql.jdbc.Driver"/><property name="url" value="jdbc:mysql://localhost/test"/><property name="username" value="root"></property><property name="password" value="281889"></property></bean><bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean" lazy-init="false"><property name="dataSource" ref="dataSource"/><property name="configLocation" value="classpath:hibernate.cfg.xml"></property><property name="mappingLocations" value="classpath:com/demo/ssm/po/*.hbm.xml"></property></bean><bean id="transactionManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager"><property name="sessionFactory" ref="sessionFactory"></property></bean><tx:advice id="txAdvice" transaction-manager="transactionManager"><tx:attributes><tx:method name="get*" read-only="true"/><tx:method name="*"/></tx:attributes></tx:advice><aop:config><aop:pointcut expression="execution(* com.demo.ssm.daoImpl.*.*(..))" id="txPointcut"/><aop:advisor advice-ref="txAdvice" pointcut-ref="txPointcut"/></aop:config></beans> 3、编写测试类public class BookDaoImplTest{private ApplicationContext context=null;private BookService bookService=null;{context= new ClassPathXmlApplicationContext("applicationContext.xml");bookService=context.getBean(BookService.class);}@Testpublic void test(){DataSource dataSource=(DataSource) context.getBean(DataSource.class); System.out.println(dataSource);}@Testpublic void test2(){String bookName=bookService.findBookById(1);System.out.println(bookName);}@Testpublic void test3(){bookService.saveBook(new Book(2, "android源码分析", "1002", 45, 10)); }}。

ch12 Spring、Struts2、Hibernate整合

如果系统采用Spring框架。Spring负责业务逻辑组件的创建和生成，并可管理业务逻辑组件的生命周期。可以如此理解： Spring是个性能非常优秀的工厂，可以生产出所有的实例，从业务逻辑组件，到持久层组件，甚至控制器。控制器如何访问到Spring容器中的业务逻辑组件？为了让Action 访问Spring的业务逻辑组件，有两种策略： 1、Spring管理控制器，并利用依赖注入为控制器注入业务逻辑组件。 2、控制器定位Spring工厂，也就是Spring的容器，从Spring容器中取得所需的业务逻辑组件。对于这两种策略，Spring与Struts2都提供了对应的整合实现。 Struts 2框架整合Spring很简单，整合的步骤参见课本。

Spring有3个作用：
◦ 允许Spring创建Action、Interceptor和Result ◦ 由Struts创建的对象能够被Spring装配 ◦ 如果没有使用Spring ObjectFactory，提供了两个拦截器来自动装配action
SS2H三者整合代码比较多，初学者做起来很繁，其实如果理解为什么要整合、整合所需要的包以及根据书中的配置文件模板也不是很难。以后项目中就使用该配置文件模板。整合基本步骤描述如下： 1、先向项目中加入Hibernate3.2+Spring2.支持，删除 hibernate.cfg.xml文件,修改applicationContext.xml文件的内容，增加SessionFactory和dataSource的设置。 2、通过MyEclipse的向导方式，生成POJO类和对应的映射文件。 3、修改applicationContext.xml文件中<property name="mappingResources">元素的内容。 4、编写DAO接口和实现类。 5、修改applicationContext.xml文件，增加对Dao实现类的配置。

springmvc+spring+hibernate整合

SpringMVC+Spring+Hibernate整合一、Spring + SpringMVC +Hibernate集成步骤。

1、集成Spring框架：编写spring的配置文件在web.xml中通过监听器加载spring的配置文件2、集成Hibernate框架：在spring的配置文件中，配置sessionFactory对象。

为sessionFactory对象注入Hibernate相关属性配置transactionManager事务管理器3、集成spring mvc框架：编写spring mvc的配置文件在web.xml中注册DispatcherServlet，加载spring mvc配置文件4、在web.xml中注册常用的过滤器：字符集过滤器和OpenSessionInView过滤器等。

1.导入相应的JAR包项目结构编写jdbc.properties 文件#mysql configjdbc.url=jdbc:mysql:///testjdbc.driver=com.mysql.jdbc.Driverername=rootjdbc.password=root编写日志properties 文件og4j.rootLogger=INFO,stdout,logfilelog4j.appender.stdout=org.apache.log4j.ConsoleAppenderyout=org.apache.log4j.PatternLayoutyout.ConversionPattern=%d%p[%c]-%m%nlog4j.appender.logfile=org.apache.log4j.RollingFileAppenderlog4j.appender.logfile.File=project-log.loglog4j.appender.logfile.MaxFileSize=512KB# Keep three backup files.log4j.appender.logfile.MaxBackupIndex=3# Pattern to output: date priority [category] - messageyout=org.apache.log4j.PatternLayoutyout.ConversionPattern=%d%p[%c]-%m%n6.编写Spring 配置文件,开启组件自动扫描，加载属性文件，配置持久层（数据源，SessionFactory），事物管理，及JSR303验证beans.xml<?xml version="1.0"encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:context="/schema/context"xmlns:tx="/schema/tx"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/schema/bean s/schema/beans/spring-beans-3.0.xsd /schema/context/schema/context/spring-context-3.0. xsd/schema/tx/schema/tx/spring-tx-3.0.xsd"><context:component-scan base-package="com"/><context:property-placeholderlocation="classpath*:jdbc.properties"/><bean id="dataSource" class="mons.dbcp.BasicDataSource"destroy-method="close"><property name="driverClassName"value="${jdbc.driver}"/><property name="url"value="${jdbc.url}"/><property name="username"value="${ername}"/><property name="password"value="${jdbc.password}"/> </bean><bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean "><property name="dataSource"ref="dataSource"/><property name="mappingDirectoryLocations"><list><value>classpath*:com/nyf/entity/</value></list></property><property name="hibernateProperties"><value>hibernate.dialet=org.hibernate.dialect.MySQL5Dialecthibernate.show_sql=truehibernate.hbm2ddl.auto=update</value></property></bean><beanclass="org.springframework.orm.hibernate3.HibernateTemplate"> <property name="sessionFactory"ref="sessionFactory"/> </bean><bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionMan ager"><property name="sessionFactory"ref="sessionFactory"/> </bean><tx:annotation-driven transaction-manager="txManager"/><bean id="validator" class="org.springframework.validation.beanvalidation.LocalValidat orFactoryBean"/></beans>2.编写相应的实体类erpackage com.nyf.entity;import java.util.*;public class User {private Integer id;/**姓名*/private String name;/**年龄*/private int age;/**生日*/private Date birthday = new Date();/**电话*/private String phone;/**Email*/private String mail;/**性别*/private int gender;//0女1男/**身份证*/private String idcard;/**地址*/private String address;/**职位*/private String position;/**密码*/private String password;public Integer getId() {return id;}public void setId(Integer id) {this.id = id;}public String getName() {return name;}public void setName(String name) { = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public Date getBirthday() {return birthday;}public void setBirthday(Date birthday) { this.birthday = birthday;}public String getPhone() {return phone;}public void setPhone(String phone) { this.phone = phone;}public String getMail() {return mail;}public void setMail(String mail) {this.mail = mail;}public int getGender() {return gender;}public void setGender(int gender) {this.gender = gender;}public String getIdcard() {return idcard;}public void setIdcard(String idcard) {this.idcard = idcard;}public String getAddress() {return address;}public void setAddress(String address) {this.address = address;}public String getPosition() {return position;}public void setPosition(String position) {this.position = position;}public String getPassword() {return password;}public void setPassword(String password) {this.password = password;}@Overridepublic String toString() {return name+", "+age+", "+birthday+", "+phone+", "+mail+", "+gender+", "+idcard+", "+address+", "+position+", "+password;}}er.hbm.xml配置<?xml version="1.0"encoding="UTF-8"?><!DOCTYPE hibernate-mapping PUBLIC"-//Hibernate/Hibernate Mapping DTD 3.0//EN""/hibernate-mapping-3.0.dtd"><hibernate-mapping package="com.nyf.entity"><class name="User"table="t_user"><id name="id"><generator class="native"/></id><property name="name"length="30"/><property name="age"/><property name="birthday"/><property name="phone"length="30"/><property name="mail"length="30"/><property name="gender"/><property name="idcard"length="30"/><property name="address"length="30"/><property name="position"length="100"/><property name="password"length="30"/></class></hibernate-mapping>4.编写Dao层com.nyf.Daopackage com.nyf.dao;import java.util.*;import com.nyf.entity.*;public interface IUserDao {/**增加一个用户*/public void add(User user);/**删除一个用户*/public void del(User user);/**修改一个用户*/public void modify(User user);/**根据Id查询一个用户*/public User findById(int id);/**验证用户是否存在*/public User validate(String name,String password);/**查询所有的用户*/public List<User> findAll();/**分页查询用户*/public List<User> findPage(int pageNo,int counts);}5.编写dao层实现类Com.nyf.dao.implpackage com.nyf.dao.impl;import java.util.List;import org.springframework.beans.factory.annotation.Autowired; import org.springframework.orm.hibernate3.HibernateTemplate;import org.springframework.stereotype.Repository;import com.nyf.dao.IUserDao;import er;//把 userDaoImpl交给Spring IOC容器管理@Repository("userDao")public class UserDaoImpl implements IUserDao {//由Spring依赖注入@Autowiredprivate HibernateTemplate hibernateTemplate;@Overridepublic void add(User user) {hibernateTemplate.save(user);}@Overridepublic void del(User user) {hibernateTemplate.delete(user);}@Overridepublic void modify(User user) {hibernateTemplate.update(user);}@Overridepublic User findById(int id) {List<User> users = hibernateTemplate.find("from User u where u.id=?", id);if(users.size()>0){return users.get(0);}else{return null;}}@Overridepublic List<User> findAll() {List<User> users = hibernateTemplate.find("from User");return users;}@Overridepublic List<User> findPage(int pageNo, int counts) {List<User> users = hibernateTemplate.getSessionFactory().openSession().createCriteria(User.class) .setFirstResult(pageNo*counts).setMaxResults(counts).list();return users;}@Overridepublic User validate(String name,String password) {String hql = "from User u where =? and u.password=?";String []values = {name,password};List<User> users = hibernateTemplate.find(hql,values);if(users.size()>0){return users.get(0);}else{return null;}}}7.编写ServiceCom.nyf.servicepackage com.nyf.service;import java.util.*;import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service;import org.springframework.transaction.annotation.Transactional; import com.nyf.dao.IUserDao;import er;//Service层最好用@Service注解//@Transactional该业务开启事物管理@Service@Transactionalpublic class UserService {//Spring 自动注入@Autowiredprivate IUserDao userDao;public void save(User user){userDao.add(user);}public void delete(User user){userDao.del(user);}public void modify(User user){userDao.modify(user);}//对于查询的业务，最好事物设置为只读@Transactional(readOnly=true)public User findById(int id){return userDao.findById(id);}@Transactional(readOnly=true)public User validate(String name,String password){return userDao.validate(name,password);}@Transactional(readOnly=true)public List<User> findAll(){return userDao.findAll();}@Transactional(readOnly=true)public List<User> findPage(int pageNo,int counts){return userDao.findPage(pageNo, counts);}}编写SpringMVC配置文件，组件自动扫描控制器层，文件上传解析器等<?xml version="1.0"encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:context="/schema/context"xmlns:mvc="/schema/mvc"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/schema/bean s/schema/beans/spring-beans-3.0.xsd /schema/context/schema/context/spring-context-3.0. xsd/schema/mvc/schema/mvc/spring-mvc-3.0.xsd"><context:component-scan base-package="com" use-default-filters="false"><context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/> </context:component-scan><!--<mvc:annotation-driven /> 是一种简写形式，完全可以手动配置替代这种简写形式简写形式可以让初学都快速应用默认配置方案。

浅谈Spring+Hibernate整合(doc 16页)

浅谈Spring+Hibernate整合(doc 16页)Spring+Hibernate整合Spring是一个轻量级的bean容器，它为业务对象（business objects）、DAO对象和资源对象（如：JDBC数据源或者Hibernate SessionFactorie等）提供了IoC类型的装配能力。

Spring通过使用一个xml格式的配置文件，为开发者提供了一种通过定制属性文件来手动管理单例对象或工厂对象的可选择性。

由于Spring 将非侵入性做为一个重要的目标，因此由Spring 配置管理的bean均不需要依赖Spring自身的接口和类，就可以通过它们的bean属性完成配置。

从而可以被应用到任何环境中，无论你开发的是Hibernate访问方法就完全解决了这些麻烦! 无论是在多个DAO接口还是在多方事务的情况下，Spring使得多种DAO对象无缝地协同工作。

例如：某些DAO对象可能是基于plain JDBC 的实现，更适合于经由Spring的JdbcTemplate 来避免手动的异常处理。

你可以单独地使用许多Spring特性，因为Spring的所有对象都是设计成可复用的JavaBean的集合。

使用其他的Spring特性时，应用配置概念是一个附加的特性，并不是一个必须的特性。

无论如何，当你要决定去构建一个象Spring这样的内在的基础架构的时候并没有什么范围上的限制。

1. 介绍: 资源管理典型的业务应用系统常常由于重复的资源管理代码而导致混乱。

许多项目试着用自己的方法来解决这个问题，有时为此要付出失败的代价，Spring针对适当的资源管理提倡了一种引人注目的简单方法：即经由模板来倒置控制（Inversion of control），例如：基础类使用回调接口，或者应用AOP拦截器。

其基础核心是适当的资源处理和将特殊的API异常转换为一个unchecked的基础异常。

Spring引入了一个DAO异常层用于任何数据访问策略。

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

<beans
xmlns="/schema/beans"
xmlns:xsi="/2001/XMLSchema-instance"
xmlns:p="/schema/p"

<bean id="authenticationManager"
class="org.acegisecurity.providers.ProviderManager">
<property name="decisionVoters">
<list>
<bean class="org.acegisecurity.vote.RoleVoter"></bean>
</list>
</property>
</bean>

<property name="authenticationManager" ref="authenticationManager"></property>
<property name="rememberMeServices" ref="rememberMeServices"></property>

<property name="filterProcessesUrl" value="/j_login.do"></property>
<property name="rememberMeServices" ref="rememberMeServices"></property>

<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
xsi:schemaLocation="/schema/beans /schema/beans/spring-beans-2.5.xsd">

<property name="providers">
<list>
<ref local="daoAuthenticationProvider" />
<ref local="rememberMeAuthenticationProvider"/>
</list>
</property>
-->
<property name="userDetailsService" ref="userDetailsService" />
</bean>
<bean id="rememberMeAuthenticationProvider"
class="org.acegisecurity.providers.rememberme.RememberMeAuthenticationProvider">
ConsensusBased：所有投票者通过才允许
UnanimouseBased：如果没有投票者拒绝，就允许
-->
<bean id="accessDecisionManager"
class="org.acegisecurity.vote.AffirmativeBased">
</bean>

<bean id="rememberMeFilter"
class="org.acegisecurity.ui.rememberme.RememberMeProcessingFilter">
</பைடு நூலகம்ean>

<bean id="daoAuthenticationProvider"
class="org.acegisecurity.providers.dao.DaoAuthenticationProvider" >
<bean id="filterChainProxy" class="org.acegisecurity.util.FilterChainProxy">
<property name="filterInvocationDefinitionSource">
<value>
CONVERT_URL_TO_LOWERCASE_BEFORE_COMPARISON
<constructor-arg>
<list>
<ref local="rememberMeServices"></ref>
<bean class="org.acegisecurity.ui.logout.SecurityContextLogoutHandler"></bean>
整合的步骤：
1.导入acegi-security.jar包
2.添加spring支持
3，配置web.xml

<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/security.xml</param-value>
<init-param>
<param-name>targetClass</param-name>
<param-value>org.acegisecurity.util.FilterChainProxy</param-value>
</init-param>
</filter>
PATTERN_TYPE_APACHE_ANT
/**=httpSessionContextIntegrationFilter,logoutFilter,authenticationProcessingFilter,rememberMeFilter,exceptionFilter,securityInterceptor

<filter-mapping>
<filter-name>acegiFilter</filter-name>
<url-pattern>*.jsp</url-pattern>
</filter-mapping>
<filter-mapping>
</value>
</property>
</bean>

<bean id="httpSessionContextIntegrationFilter"
class="org.acegisecurity.context.HttpSessionContextIntegrationFilter">
</bean>

<bean id="logoutFilter"