在任何地方获取多数据源hibernate session 的方法

原理：基于threadLocal：

使用hibernate,我们最终要获得的是一个hibernate session对象，

在第一次使用到一个hibernate Session的时候，创建创建一个session,并将其存储到threadLocal map集合中。

在同一个请求中，如果我们还需要用到这个session.我们就可以从threadLocal map集合中获取到这个session.接着使用。

在请求结束时（可以使用filter），关闭并清除ThreadLocal Map 中的所有session对象。

优点：可以配置多个数据源；可以在一个请求中在任何地方获取到hibernate session 对象；无需手工关闭hibernate session对象。

缺点：hibernate session 存活时间较长；我没详细测试过，只是理论上可行。

下面是代码：

1 HSessionHolder.java:用于获取到对应的session.

package com.hf.hibernate.util;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import org.apache.log4j.Logger;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;

/**
*
* @author Administrator
*
*/
public class HSessionHolder {
private static Logger logger = Logger.getLogger(HSessionHolder.class);
/**
* threadLocal集合，对应了不同的配置文件
*/
private static Map <String ,ThreadLocal<Session>> threadLocalMap =new HashMap <String ,ThreadLocal<Session>>();
/**
* 配置文件名称-路径集合
*/
private static Map <String ,String> configFileLocationMap =new HashMap <String ,String>();

/**
* Hibernate SessionFactory 名称-对象集合
*/
private static Map <String ,SessionFactory> sessionFactoryMap =new HashMap <String ,SessionFactory>();
/**
* hibernate配置文件读取器
*/
private static final Configuration cfg = new Configuration();
/**
*
*/
private static final String DEFAULT_FLAG = "configOne";
/**
* 初始化配置文件集合
*/
static {
/**
* 初始化配置文件集合
*/
String configOneFlag="configOne";
String configOnePath="/com/hf/hibernate/config/hibernate.cfg.xml";
configFileLocationMap.put(configOneFlag,configOnePath);
/**
* 初始化threadLocalMap集合
*/
ThreadLocal<Session> configOneT = new ThreadLocal<Session>();
threadLocalMap.put(configOneFlag,configOneT);

/**
* 初始化各个sessionFactory对象
*/
Iterator configIterator =configFileLocationMap.keySet().iterator();
while(configIterator.hasNext()){
String configFlag = (String) configIterator.next();
String configPath = configFileLocationMap.get(configOneFlag);


cfg.configure(configPath);
SessionFactory sessionFactory = cfg.buildSessionFactory();
sessionFactoryMap.put(configFlag, sessionFactory);
}


}//static

/**
* 获取默认数据库的会话对象
* @param flag
* @return
*/
public static Session getSession() {
String flag= DEFAULT_FLAG;
return getSession(flag);

}

/**
* 关闭所有可能已经打开的hibernate会话
* @return
*/
public static void closeSessions() {
/**
* 遍历所有的threadLocalMap的成员,如果存在Session，则关掉。
*/
Iterator<String> threadLocalIterator =threadLocalMap.keySet().iterator();
while(threadLocalIterator.hasNext()){
ThreadLocal<Session> t =threadLocalMap.get(threadLocalIterator.next());
Session session = t.get();
if(session!=null){
session.close();
t.set(null);
logger.info("成功的关闭了一个hibernate Session,并清空ThreadLocal");
}

}
}

/**
* 获取制定数据库的会话对象
* @param flag
* @return
*/
public static Session getSession(String flag) {
/**
* 取到threadLocal
*/
ThreadLocal<Session> t = threadLocalMap.get(flag);
if(t==null){
try {
throw new Exception("无效的threadlocal 标志");
} catch (Exception e) {
// TODO 自动生成 catch 块
e.printStackTrace();
}
return null;
}
/**
* 看看里面是不是已经有session了
*/
Session session = (Session) threadLocalMap.get(flag).get();
/**
* 没有的话创建一个新的
*/
if (session == null || !session.isOpen()) {
SessionFactory sessionFactory = sessionFactoryMap.get(flag);
if (sessionFactory != null) {

session = sessionFactory.openSession();

}
/**
* 将session存入threadLocal
*/
t.set(session);
}
return session;
}


}

2 filter:HSessionFilter :在结束时关闭所有打开的hibernate session

package com.hf.hibernate.filter;

import java.io.IOException;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import com.hf.hibernate.util.HSessionHolder;

public class HSessionFilter implements Filter {

private static final Log log = LogFactory .getLog(HSessionFilter.class);

public void init(FilterConfig config) throws ServletException {

}

/**
* 此过滤器只在最终关闭掉所有打开的session就可以了。
*/
public void doFilter(ServletRequest request, ServletResponse response,
FilterChain chain) throws IOException, ServletException {

try {
chain.doFilter(request, response);
} finally {
HSessionHolder.closeSessions();
}
}

public void destroy() {}
}

使用方法：

例如在一个DAO的保存方法中：

/**
* 保存信息分类对象到数据库中，已经设置好了id了
* @return
*/
public static boolean save(Info category) {
log.info("开始进行保存分类信息操作");
/*获取到hibernate session，这里调用的是默认的数据库配置*/
Session session = HSessionHolder.getSession();
/*开启事务*/
Transaction tran = session.beginTransaction();
try {
session.save(category);
tran.commit();

} catch (Exception e) {

//这里应该增加回退功能
e.printStackTrace();
return false;
}
return true;
}