s2sh三大框架整合过程（仅供参考）

三大框架顾名思义就是非常有名的Struts2 ，Hibernate，Spring，

框架整合的方法很多，现在我写一个非常简单的整合过程，相信大家一看就会！

这里使用的struts-2.2.1.1、hibernate-3.2.0、spring2.5.6

第一步，搭建Struts2环境

　　1、导入struts2的jar包(直接把struts-blank项目下的依赖库coypy到自己项目中)

　　2、配置web.xml，增加struts2提供的过滤器(参考struts-blank项目)

 <?xml version="1.0" encoding="UTF-8"?>

 <web-app version="2.5"

     xmlns="http://java.sun.com/xml/ns/javaee"

     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

     xsi:schemaLocation="http://java.sun.com/xml/ns/javaee

     http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">

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

 </web-app>

　　3、建立包：com.qcf.struts.test，并增加普通java类，代码如下：

 package com.qcft.struts.test;

 public class FirstAction {

     private String msg;

     public String execute() throws Exception{

         System.out.println("FirstAction.test1()");

         setMsg("为了让生活美好！");

         return "success";

     }

     public String getMsg() {

         return msg;

     }

     public void setMsg(String msg) {

         this.msg = msg;

     }

 }

　　4、在src下增加struts.xml，并增加FirstAction类的配置内容：

 <?xml version="1.0" encoding="UTF-8" ?>

 <!DOCTYPE struts PUBLIC

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

     "http://struts.apache.org/dtds/struts-2.0.dtd">

 <struts>

     <package name="default" namespace="/" extends="struts-default">

         <action name="first" class="com。qcf.struts.test.FirstAction">

               <result name="success">ok.jsp</result>

         </action>

     </package>

     <!-- Add packages here -->

 </struts>

　　5、增加ok.jsp页面，用来显示FirstAction中的属性msg：

 <%@ page language="java" import="java.util.*" pageEncoding="gbk"%>

 <%@ taglib prefix="s" uri="/struts-tags" %>

 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">

 <html>

   <head>

     <title>测试struts2</title>

   </head>

   <body>

     <s:property value="msg" />

   </body>

 </html>

　　测试成功！

第二步：搭建Hibernate环境

　　1、导入hibernate所需要的基本的jar包

　　2、添加hibernate.cfg.xml配置文件

　　　　打开etc目录，将hibernate.cfg.xml拷贝到项目src下

　　　　修改配置文件hibernate.cfg.xml内容，结合etc/hibernate.properties（文件中搜索”mysql”），完成后配置内容如下：

 <!DOCTYPE hibernate-configuration PUBLIC

     "-//Hibernate/Hibernate Configuration DTD 3.0//EN"

     "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

 <hibernate-configuration>

     <session-factory>

         <property name="show_sql">true</property>

         <property name="hibernate.dialect">

             org.hibernate.dialect.MySQLDialect

         </property>

         <property name="connection.driver_class">

             com.mysql.jdbc.Driver

         </property>

         <property name="hibernate.connection.url">

             jdbc:mysql://localhost:3306/testhib

         </property>

         <property name="connection.username">

             root

         </property>

         <property name="connection.password">

             123456

         </property>

     </session-factory>

 </hibernate-configuration>

　　3、新建pojo类(Plain Old Java Objects 简单的java对象，实际上就是我们讲的普通javabean对象)：User

 package com.qcf.hib.bean;

 import java.util.Date;

 public class User {

     private int id;

     private String name;

     private Date birthday;

     public int getId() {

         return id;

     }

     public void setId(int id) {

         this.id = id;

     }

     public String getName() {

         return name;

     }

     public void setName(String name) {

         this.name = name;

     }

     public Date getBirthday() {

         return birthday;

     }

     public void setBirthday(Date birthday) {

         this.birthday = birthday;

     }

     public User(int id, String name, Date birthday) {

         super();

         this.id = id;

         this.name = name;

         this.birthday = birthday;

     }

     public User(String name, Date birthday) {

         super();

         this.name = name;

         this.birthday = birthday;

     }

     public User() {

     }

 }

　　4、增加映射文件User.hbm.xml（写法可以参考：eg/User.hbm.xml）

　　　　映射文件hbm.xml说明了pojo类和表的对应关系，以及pojo类中属性和表中字段的对应关系。

　　　　注：本映射文件增加到跟pojo同一个包中

 <?xml version="1.0"?>

 <!DOCTYPE hibernate-mapping PUBLIC

     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"

     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

 <hibernate-mapping

     package="com.qcf.hib.bean">

     <class name="User" table="_user" lazy="true">

         <id name="id">

             <generator class="native"/>

         </id>

         <property name="name"  type="java.lang.String"

                 not-null="true"

                 length="15"

                 column="_name"/>

         <property name="birthday"  type="java.util.Date" column="birthday"/>

     </class>

 </hibernate-mapping>

　　5、在hibernate.cfg.xml中增加User.hbm.xml文件的配置，让hibernate知道本映射关系。在<session-factory>元素下增加：

　　6、修改hibernate.cfg.xml文件，在<session-factory>下增加hbm2ddl.auto的配置：

　　<property name="hibernate.hbm2ddl.auto">update</property>

create-drop: 运行时，先创建，运行完，在删除。

create:每次运行前都会删除已有的。在创建。 测试时，可以使用create.

update:映射文件和表。不会重新创建表及不会重新执行ddl语句，只会更新表中的记录。

validate:看映射文件和表是不是对应，如果不对应，他也不会更新，会报错。经常用它，保险一些。

　　7、增加Test.java测试类：

 package com.bjsxt.hib.test;

 import java.util.Date;

 import org.hibernate.Session;

 import org.hibernate.SessionFactory;

 import org.hibernate.cfg.Configuration;

 import com.bjsxt.hib.bean.User;

 public class Test {

     public static void main(String[] args) {

         Configuration conf = new Configuration().configure();

         SessionFactory factory = conf.buildSessionFactory();

         Session session = factory.openSession();

         User user = new User("高淇",new Date());

         session.save(user);

         session.close();

     }

 }

　　8、上一次执行，我们发现表创建成功但是数据记录并没有插入表中。jdbc是自动提交，autocommit。hibernate缺省是false. 因此，我们必须很明确的开启事务才行。我们将Test.java文件内容修改如下：

 package com.qcf.hib.test;

 import java.util.Date;

 import org.hibernate.Session;

 import org.hibernate.SessionFactory;

 import org.hibernate.Transaction;

 import org.hibernate.cfg.Configuration;

 import com.bjsxt.hib.bean.User;

 public class Test {

     public static void main(String[] args) {

         Configuration conf = new Configuration().configure();

         SessionFactory factory = conf.buildSessionFactory();

         Session session = factory.openSession();

         Transaction transaction = session.beginTransaction();

         User user = new User("高淇",new Date());

         session.save(user);

         transaction.commit();//保存之后，关闭session之前，显示提交事务.(必须调用，不然不会提交。即使session关闭，也不回自动提交)

         session.close();

     }

 }

　　测试成功，数据库中也有相应的数据添加成功！

第三步：搭建Spring环境

　　1、导入Spring所需要的jar包

　　　　spring.jar这一个即可！

　　2、写一个测试类

 package com.qcf.test;

 public class UserDao {

     public void add(String uname,String pwd){

         System.out.println("增加一个用户!");

     }

 }

　　3、增加配置文件beans.xml，内容如下：

 <?xml version="1.0" encoding="UTF-8"?>

 <beans

 xmlns="http://www.springframework.org/schema/beans"

 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

 xmlns:p="http://www.springframework.org/schema/p"

 xsi:schemaLocation="http://www.springframework.org/schema/beans

 http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">

     <bean id="userDao" class="com.sxt.test.UserDao"></bean>

 </beans>

通过上面的配置文件，spring框架知道了UserDao类的存在！可以通过反射机制自动将UserDao类的对象new出！ 所以注意托管给spring的类必须符合基本的javabean规范：

1.    如果有属性，则必须有相应的get/set方法。

2.    必须要无参的构造器

　　4、建立Test.java类

 package com.qcf.test;

 import org.springframework.context.ApplicationContext;

 import org.springframework.context.support.ClassPathXmlApplicationContext;

 public class Test {

     public static void main(String[] args){

 //        UserDao userDao = new UserDao();

 //        userDao.add("a", "123");

         ApplicationContext context = new ClassPathXmlApplicationContext(new String[]{"beans.xml"});

         UserDao userdao = (UserDao) context.getBean("userDao");

         userdao.add("d", "222");

     }

 }

　　5、上面的代码中，我们可以使用context.getBean("userDao")代替了new UserDao(这样的代码，也就是spring内部有个工厂类，替我们完成了new对象的操作！而这个工厂类是通过读取beans.xml文件知道了字符串”userDao”和com.sxt.test.UserDao类之间的关系！

　　直接运行Test.java类即可。

第四步：已经将三个框架各自搭建完毕。现在先整合Struts和spring

　　整合struts2和spring非常简单只需两步：

　　1、在web.xml下面添加一个spring的过滤器(添加到最上面，在struts2的配置文件上面)

     <listener>

       <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>

     </listener>

     <context-param>

       <param-name>contextConfigLocation</param-name>

       <param-value>classpath:application.xml</param-value>

     </context-param>

　　2、添加一个struts-spring.plus的插件，这个可以再struts官方提供的jar中即可找到

　　注：action中的class不用填写全名，直接写spring中注册的id即可，如：testAction

     <package name="default" namespace="/" extends="struts-default">

         <action name="testAction" class="testAction">

             <result name="success">index.jsp</result>

         </action>

     </package>

第五步：整合spring和hibernate

　　1、首先将web.xml添加头文件

 <?xml version="1.0" encoding="UTF-8"?>

 <beans xmlns="http://www.springframework.org/schema/beans"

     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

     xmlns:aop="http://www.springframework.org/schema/aop"

     xmlns:tx="http://www.springframework.org/schema/tx"

     xmlns:context="http://www.springframework.org/schema/context"

     xsi:schemaLocation="

 http://www.springframework.org/schema/beans

 http://www.springframework.org/schema/beans/spring-beans-2.5.xsd

 http://www.springframework.org/schema/tx

 http://www.springframework.org/schema/tx/spring-tx-2.5.xsd

 http://www.springframework.org/schema/aop

 http://www.springframework.org/schema/aop/spring-aop-2.5.xsd

   http://www.springframework.org/schema/context

    http://www.springframework.org/schema/context/spring-context-2.5.xsd

 ">

　　2、配置sessionFactory（配置了C3P0数据库连接池）

    <!-- 导入jdbc.properties -->

    <context:property-placeholder location="classpath:jdbc.properties"/>

    <!-- 配置sessionfactory -->

    <bean name="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">

        <!-- 配置application.xml路径 -->

        <property name="configLocation" value="classpath:hibernate.cfg.xml"></property>

        <!-- 配置c3p0连接池 -->

        <property name="dataSource">

            <bean class="com.mchange.v2.c3p0.ComboPooledDataSource">

                <!-- 数据库连接信息 -->

                <property name="driverClass" value="${driverClass}"></property>

                <property name="jdbcUrl" value="${jdbcUrl}"></property>

                <property name="user" value="${user}"></property>

                <property name="password" value="${password}"></property>

                <!-- 其它配置 -->

                <!-- 数据库初始化时获取三个链接，取值应该在min -->

                <property name="initialPoolSize" value="3"></property>

                <!-- 连接池中保留的最小连接数 -->

                <property name="minPoolSize" value="3"></property>

                <!-- 连接池中保留的最大连接数 -->

                <property name="maxPoolSize" value="10"></property>

                <!-- 当连接池中连接耗尽时c3p0一次获取的连接数 -->

                <property name="acquireIncrement" value="3"></property>

                <!-- 配置数据源内加载的preparestatement数量 -->

                <property name="maxStatements" value="3"></property>

                <!-- 单个连接所拥有的最大statments缓存数 -->

                <property name="maxStatementsPerConnection" value="3"></property>

                <!-- 设置最大空闲时间不使用自动丢弃，如果为0永远不丢弃 -->

                <property name="maxIdleTime" value="1800"></property>

            </bean>

        </property>

    </bean>

　　3、配置事务管理（XML）

 <!-- 配置声明事务管理 -->

     <bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">

         <property name="sessionFactory" ref="sessionFactory"></property>

     </bean>

     <!-- AOP核心配置 -->

     <aop:config>

         <!-- 定义aop切面 -->

         <aop:pointcut expression="execution(public * com.qcf.test.*.*(..))" id="testa"/>

         <aop:advisor advice-ref="txadvice" pointcut-ref="testa"/>

     </aop:config>

     <!-- 定义切割方法 -->

     <tx:advice id="txadvice" transaction-manager="txManager">

         <tx:attributes>

             <tx:method name="save*" propagation="REQUIRED"/>

         </tx:attributes>

     </tx:advice>

     <!--  -->

　　配置事务(annotation)

      <!-- 自动扫面

       -->

      <context:component-scan base-package="com.qcf"></context:component-scan>

     <!-- 配置事务 -->

     <bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">

         <property name="sessionFactory" ref="sessionFactory"></property>

     </bean>

     <!-- annotation配置事务     -->

     <tx:annotation-driven transaction-manager="txManager"/>

　　测试方法：

 package com.qcf.dao.impl;

 import javax.annotation.Resource;

 import org.hibernate.Session;

 import org.hibernate.SessionFactory;

 import org.springframework.stereotype.Controller;

 import org.springframework.stereotype.Service;

 import org.springframework.transaction.annotation.Transactional;

 import com.qcf.dao.UserDao;

 import com.qcf.po.User;

 @Service

 public class UserDaoImpl implements UserDao  {

     @Resource

     private SessionFactory sessionFactory;

     /**

      * 增加用户

      */

     @Transactional

     public void addUser() {

         // TODO Auto-generated method stub

         Session session=sessionFactory.getCurrentSession();

         session.save(new User(, "zhangsan", ));

         session.save(new User(, "zhan", ));

     }

     public SessionFactory getSessionFactory() {

         return sessionFactory;

     }

     public void setSessionFactory(SessionFactory sessionFactory) {

         this.sessionFactory = sessionFactory;

     }

 }

　　4、配置HibernateTemplate

　　　HibernateTemplate类可让我们将Hibernate的使用模板化，使我们对hibernate的调用更加简单！使用他，我们只需要在配置文件中增加：

     <!-- 配置hibernatetempter -->

     <bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">

         <property name="sessionFactory" ref="sessionFactory"></property>

     </bean>

　　hibernateTemplate常用方法：　　

　　　　◦ void delete(Object entity)：删除指定持久化实例

　　　　◦ deleteAll(Collection entities)：删除集合内全部持久化类实例

　　　　◦ find(String queryString)：根据HQL查询字符串来返回实例集合

　　　　◦ get(Class entityClass, Serializable id)：根据主键加载特定持久化类的实例

　　　　◦ save(Object entity)：保存新的实例

　　　　◦ saveOrUpdate(Object entity)：根据实例状态，选择保存或者更新

　　　　◦ update(Object entity)：更新实例的状态，要求entity是持久状态

　　　　◦ setMaxResults(int maxResults)：设置分页的大小(无setFirstResult方法)

　　HibernateTemplate的典型用法：

1. 　　需要直接获得session对象的处理方式(比如：分页处理)

         hibernateTemplate.execute(new HibernateCallback() {

             public Object doInHibernate(Session session) throws HibernateException,

                     SQLException {

                 // TODO Auto-generated method stub

                 session.save(new User(0, "lisi", 19));

                 return null;

             }

         });

　　　　　　2. 不需要直接获得session对象的情况

     public List<User> getAllUser(){

             List<User> list=hibernateTemplate.find("from User");

             for (int i = 0; i < list.size(); i++) {

                 System.out.println(list.get(i).getId());

             }

             List list2 = hibernateTemplate.find("from User where name=? and id=?", new Object[]{"zhangsan",1});

             for (int i = 0; i < list2.size(); i++) {

                 System.out.println(list2.get(i).toString());

             }

         return null;

     }

　　5、HibernateDaoSupport

　　　　封装了HibernateTemplate！常见用法如下：

public class UserDaoImpl3 extends HibernateDaoSupport  {

    public void add(User u) {

        this.getHibernateTemplate().save(u);

    }

}

public class UserDaoImpl3 extends HibernateDaoSupport  {

    public void add(User u) {

        Session s = this.getSession();

        s.save(u);

        releaseSession(s); //手动释放session资源

    }

}

　　6、JDBCTemplate的使用

　　　dbcTemplate类是spring为了让我们更加容易使用jdbc而提供的封装。JdbcTemplate对jdbc操作做了简单的封装。内部也使用了类似HibernateTemplate中使用的模板方法模式。JdbcTemplate在工作中用的不多。本节为自学内容，目的是让大家开阔眼界。

　　要使用JdbcTemplate，我们必须要在spring中增加配置：

 <!--配置一个JdbcTemplate实例-->

 <bean id="jdbcTemplate"  class="org.springframework.jdbc.core.JdbcTemplate">

      <property name="dataSource" ref="dataSource"/>

 </bean>

　　测试类如下：

 package com.qcf.dao.impl;

 import java.sql.ResultSet;

 import java.sql.SQLException;

 import java.util.List;

 import java.util.Map;

 import javax.annotation.Resource;

 import org.springframework.context.ApplicationContext;

 import org.springframework.context.support.ClassPathXmlApplicationContext;

 import org.springframework.jdbc.core.JdbcTemplate;

 import org.springframework.jdbc.core.RowMapper;

 import org.springframework.stereotype.Component;

 import com.sxt.po.User;

 /**

  * 用来测试jdbcTemplate的用法

  * @author Administrator

  *

  */

 @Component("userDao")

 public class UserDaoImpl {

     @Resource

     private JdbcTemplate jdbcTemplate;

     public void testInsertUser(User user){

         jdbcTemplate.update("insert into user (uname,pwd) values (?,?)",new Object[]{user.getUname(),user.getPwd()});

     }

     public void testUpdateUser(String pwd,int id){

         jdbcTemplate.update("update user set pwd=? where id=?",new Object[]{pwd,id});

     }

     public void deleteUser(int id){

         jdbcTemplate.update("delete from user where id=?",new Object[]{id});

     }

     public void testGetUserById(int id){

         User user = (User) jdbcTemplate.queryForObject("select id,uname,pwd from user where id=?", new Object[]{id}, new RowMapper(){

             @Override

             public Object mapRow(ResultSet rs, int no) throws SQLException {

                 User u = new User();

                 u.setId(rs.getInt("id"));

                 u.setUname(rs.getString("uname"));

                 u.setPwd(rs.getString("pwd"));

                 return u;

             }});

         System.out.println(user.getUname());

     }

     public void testGetUsers(){

         List<Map> list = jdbcTemplate.queryForList("select * from user where id>?",new Object[]{1});

         for (Map map : list) {

             System.out.println(map.get("uname"));

         }

     }

     public static void main(String[] args) {

         ApplicationContext context = new ClassPathXmlApplicationContext(new String[]{"applicationContext.xml"});

         UserDaoImpl ud = (UserDaoImpl) context.getBean("userDao");

         User u = new User();

         u.setUname("sss");

         u.setPwd("123");

 //        ud.testInsertUser(u);

 //        ud.testDeleteUser(2);

         ud.testGetUsers();

     }

 }

　　7、OpenSessionInView管理session

　　OpenSessionInViewFilter是Spring提供的一个针对Hibernate的一个支持类，其主要意思是在发起一个页面请求时打开 Hibernate的Session，一直保持这个Session，直到这个请求结束，具体是通过一个Filter来实现的。

由于Hibernate引入了Lazy Load特性，使得脱离Hibernate的Session周期的对象如果再想通过getter方法取到其关联对象的值，Hibernate会抛出一个 LazyLoad的Exception。所以为了解决这个问题，Spring引入了这个Filter，使得Hibernate的Session的生命周期变长。

OpenSessionInViewFilter：org.springframework.orm.hibernate3.support.OpenSessionInViewFilter]是 Spring提供的一个针对Hibernate的一个支持类，其主要意思是在发起一个页面请求时打开Hibernate的Session，一直保持这个 Session，直到这个请求结束，具体是通过一个Filter来实现的。

有两种方式可以配置实现OpenSessionInView，分别是 OpenSessionInViewInterceptor和OpenSessionInViewFilter，功能完全相同，只不过一个在 web.xml配置，另一个在application.xml配置而已。

　　我们可以在web.xml中配置opensessioninview，代码如下：

 <!-- 配置Spring自动管理Session. 要配置到struts过滤器之前！-->

  <filter>

      <filter-name>hibernateSessionFilter</filter-name>

      <filter-class>

  org.springframework.orm.hibernate3.support.OpenSessionInViewFilter

      </filter-class>

  </filter>

  <filter-mapping>

      <filter-name>hibernateSessionFilter</filter-name>

      <url-pattern>/*</url-pattern>

  </filter-mapping>

　　8、ThreadLocal模式管理session

我们知道Session是由SessionFactory负责创建的，而SessionFactory的实现是线程安全的，多个并发的线程可以同时访问一个SessionFactory并从中获取Session实例，那么Session是否是线程安全的呢？很遗憾，答案是否定的。

早在Java1.2推出之时，Java平台中就引入了一个新的支持：java.lang.ThreadLocal，给我们在编写多线程程序时提供了一种新的选择。ThreadLocal是什么呢？其实ThreadLocal并非是一个线程的本地实现版本，它并不是一个Thread，而是thread local variable(线程局部变量)。也许把它命名为ThreadLocalVar更加合适。线程局部变量(ThreadLocal)其实的功用非常简单，就是为每一个使用某变量的线程都提供一个该变量值的副本，是每一个线程都可以独立地改变自己的副本，而不会和其它线程的副本冲突。从线程的角度看，就好像每一个线程都完全拥有一个该变量。

ThreadLocal是如何做到为每一个线程维护变量的副本的呢？其实实现的思路很简单，在ThreadLocal类中有一个Map，用于存储每一个线程的变量的副本。

比如下面的示例实现(为了简单，没有考虑集合的泛型)：

 public  class  ThreadLocal  {

 　   private  Map  values  =  Collections.synchronizedMap(new  HashMap());

 　   public  Object  get()  {

 　　 Thread  currentThread  =  Thread.currentThread(); 

 　   Object  result  =  values.get(currentThread); 

 　　   if(result  ==  null&&!values.containsKey(currentThread))  {

 　　　    result  =  initialValue();

 　　　    values.put(currentThread,  result); 

 　　       }

 　　       return  result; 

 　       }

 　   public  void  set(Object  newValue)  {

 　　   values.put(Thread.currentThread(),  newValue);

 　      }

      public  Object  initialValue()  {

 　　   return  null; 

 　    }

    }

那麽具体如何利用ThreadLocal来管理Session呢？Hibernate官方文档手册的示例之中，提供了一个通过ThreadLocal维护Session的好榜样：

 public  class  HibernateUtil  {

   public  static  final  SessionFactory  sessionFactory;

     static  {

       try  {

         sessionFactory  =  new  Configuration().configure().buildSessionFactory();

         } catch (Throwable  ex) {

           throw  new  ExceptionInInitializerError(ex);

            }

          }

    public static final ThreadLocal<Session>session=new ThreadLocal<Session>();

    public  static  Session  currentSession()  throws  HibernateException  {

        Session  s  =  session.get();

        if(s  ==  null)  {

          s  =  sessionFactory.openSession();

          session.set(s);

           }

          return  s;

          }

    public  static  void  closeSession()  throws  HibernateException  {

          Session  s  =  session.get();

         if(s  !=  null)  {

            s.close();

           }

           session.set(null);

         }

      }

只要借助上面的工具类获取Session实例，我们就可以实现线程范围内的Session共享，从而避免了线程中频繁的创建和销毁Session实例。当然，不要忘记在用完后关闭Session。写到这里，想再多说一些，也许大多数时候我们的DAO并不会涉及到多线程的情形，比如我们不会将DAO的代码写在Servlet之中，那样不是良好的设计，我自己通常会在service层的代码里访问DAO的方法。但是我还是建议采用以上的工具类来管理 Session，毕竟我们不能仅仅考虑今天为自己做什么，还应该考虑明天为自己做什么！

s2sh三大框架整合过程（仅供参考）的更多相关文章

S2SH三大框架整合(配置及思想)
花了一下午,终于将struts2.18+hibernate3.5.6+spring2.5.5进行整合,完成功能:在Oracle数据库的TCourse表中插入一条数据. Ⅰ,整合流程:web启动———— ...
安装oracle 11g详细过程仅供参考
SSM三大框架整合详细教程（Spring+SpringMVC+MyBatis）(转)
使用 SSM ( Spring . SpringMVC 和 Mybatis )已经有三个多月了,项目在技术上已经没有什么难点了,基于现有的技术就可以实现想要的功能,当然肯定有很多可以改进的地方.之前没 ...
SSM三大框架整合详细教程（Spring+SpringMVC+MyBatis）
使用 SSM ( Spring . SpringMVC 和 Mybatis )已经有三个多月了,项目在技术上已经没有什么难点了,基于现有的技术就可以实现想要的功能,当然肯定有很多可以改进的地方.之前没 ...
SSM三大框架整合详细教程
使用SSM(Spring.SpringMVC和Mybatis)已经有三个多月了,项目在技术上已经没有什么难点了,基于现有的技术就可以实现想要的功能,当然肯定有很多可以改进的地方.之前没有记录SSM整合 ...
SSM三大框架整合详细教程（Spring+SpringMVC+MyBatis
原博主链接:( http://blog.csdn.net/zhshulin ) 使用 SSM ( Spring . SpringMVC 和 Mybatis )已经有三个多月了,项目在技术上已经没有什么 ...
SSM三大框架整合详细总结（Spring+SpringMVC+MyBatis）（山东数漫江湖）
使用 SSM ( Spring . SpringMVC 和 Mybatis )已经很久了,项目在技术上已经没有什么难点了,基于现有的技术就可以实现想要的功能,当然肯定有很多可以改进的地方.之前没有记录 ...
SSM三大框架整合详细教程（Spring+SpringMVC+MyBatis）（转载）
使用SSM(Spring.SpringMVC和Mybatis)已经有三个多月了,项目在技术上已经没有什么难点了,基于现有的技术就可以实现想要的功能,当然肯定有很多可以改进的地方.之前没有记录SSM整合 ...
SSM三大框架整合详细教程（Spring+SpringMVC+MyBatis）【转】
使用SSM(Spring.SpringMVC和Mybatis)已经有三个多月了,项目在技术上已经没有什么难点了,基于现有的技术就可以实现想要的功能,当然肯定有很多可以改进的地方.之前没有记录SSM整合 ...

随机推荐

Attribute(两)——定义自己的特色+Asp.net MVC中间filter详细解释
部分博客是预先定义的有关特性的一些基本特征,同时还Attribute这一概念的一个宏观上的认识,在上篇博客结尾介绍了有关为自己定义特性服务的AttributeUsage,这篇博客主要是通过filter ...
使用智能移动设备访问Ossim制
使用智能移动设备访问Ossim制下面我们用iPad,iPhone通路ossim效果系统. 高清视频:http://www.tudou.com/programs/view/TikMZ1z1ELw ip ...
onethink和phpwind共享
将onethink和phpwind数据库安装在一起.使用公用表前缀. 将onethink的member表点phpwind有user表这是onethink在根文件夹的安装,phpwind安装在bbs的 ...
Net 项目构建基于Jenkins + Github + Mono 的持续集成环境
Net 项目构建基于Jenkins + Github + Mono 的持续集成环境阅读目录 1 安装 2 配置 3 测试在Redhat enterprise 6.5 的服务器上,为在gutub 上 ...
js之第三方工具解析JSON
1.JSON 仅仅是一种文本字符串.它被存储在 responseText 属性中为了读取存储在 responseText 属性中的 JSON 数据,须要依据 JavaScript 的 eval 函数 ...
VB6基本数据库应用（五）：数据的查找与筛选
同系列的第五篇,上一篇在:http://blog.csdn.net/jiluoxingren/article/details/9633139 数据的查找与筛选第4篇发布到现在已经过了4天,很抱歉,学 ...
在InstallShield中发布单一的Setup.exe文件
原文:在InstallShield中发布单一的Setup.exe文件 InstallShield默认的Release模式下,生成了一个setup.exe文件,一个msi文件,以及一些其它的杂项文件. ...
Telephone Lines USACO 月赛
以前做过这套题目这个题又重新写了:http://www.cnblogs.com/jh818012/archive/2013/05/05/3182681.html 还是以前的思路一直错在一个地方:决 ...
Angular绑定数据时转义html标签
AngularJs在绑定数据时默认会以文本的形式出现在页面上,比如我现在有这样一段代码 <div ng-controller="testCtrl">{{data}}&l ...
Spring MVC异常处理详解(转)
下图中,我画出了Spring MVC中,跟异常处理相关的主要类和接口. 在Spring MVC中,所有用于处理在请求映射和请求处理过程中抛出的异常的类,都要实现HandlerExceptionReso ...

s2sh三大框架整合过程（仅供参考）

s2sh三大框架整合过程（仅供参考）的更多相关文章

随机推荐

热门专题