-
"openSessionInViewInterceptor"
-
class="org.springframework.orm.hibernate3.support.OpenSessionInViewInterceptor">
-
"sessionFactory">
-
"sessionFactory"/>
-
-
"urlMapping"
-
class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
-
"interceptors">
-
"openSessionInViewInterceptor"/>
-
-
"mappings">
- ...
-
- ...
- ...
- hibernateFilter
- org.springframework.orm.hibernate3.support.OpenSessionInViewFilter
- singleSession
- true
- ...
- hibernateFilter
- *.do
- ...
- org.springframework.dao.InvalidDataAccessApiUsageException: Write operations
-
are not allowed in read-only mode
(FlushMode.NEVER)
- turn your Session into
-
FlushMode.AUTO or remove
'readOnly' marker from transaction definition
-
protected void
doFilterInternal(HttpServletRequest
request,
HttpServletResponse response,FilterChain filterChain)
throws ServletException, IOException
{
SessionFactory sessionFactory = lookupSessionFactory();
logger.debug("Opening Hibernate Session in OpenSessionInViewFilter");
Session session = getSession(sessionFactory);
TransactionSynchronizationManager.bindResource(
sessionFactory,
new SessionHolder(session));
try
{
filterChain.doFilter(request,
response);
}
finally
{
TransactionSynchronizationManager.unbindResource(sessionFactory);
logger.debug("Closing Hibernate Session in OpenSessionInViewFilter");
closeSession(session, sessionFactory);
}
}
-
protected Session
getSession(SessionFactory
sessionFactory)
throws DataAccessResourceFailureException
{
Session session = SessionFactoryUtils.getSession(sessionFactory,
true);
session.setFlushMode(FlushMode.NEVER);
return session;
}
-
protected void
closeSession(Session
session, SessionFactory sessionFactory)
throws CleanupFailureDataAccessException
{
SessionFactoryUtils.closeSessionIfNecessary(session,
sessionFactory);
}
-
throws CleanupFailureDataAccessException
{
-
if
(session ==
null ||
TransactionSynchronizationManager.hasResource(sessionFactory))
{
-
return;
-
}
-
logger.debug("Closing
Hibernate session");
-
try
{
-
session.close();
-
}
-
catch
(JDBCException ex)
{
-
// SQLException underneath
-
throw
new CleanupFailureDataAccessException("Could
not close Hibernate session", ex.getSQLException());
-
}
-
catch
(HibernateException ex)
{
-
throw
new CleanupFailureDataAccessException("Could
not close Hibernate session", ex);
-
}
-
}
-
可能的解決方式有:
1、 将singleSession设为false,这样只要改web.xml,缺点是Hibernate Session的Instance可能会大增,使用的JDBC Connection量也会大增,如果Connection Pool的maxPoolSize设得太小,很容易就出问题。
2、在控制器中自行管理Session的FlushMode,麻烦的是每个有Modify的Method都要多几行程式。
session.setFlushMode(FlushMode.AUTO);
session.update(user);
session.flush();
3、Extend OpenSessionInViewFilter,Override protected Session getSession(SessionFactory sessionFactory),将FlushMode直接改为Auto。
4、让方法受Spring的事务控制。这就是常使用的方法:
-
class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"
abstract="true">
PROPAGATION_REQUIRED,readOnly
PROPAGATION_REQUIRED,readOnly
PROPAGATION_REQUIRED,readOnly
PROPAGATION_REQUIRED
PROPAGATION_REQUIRED
PROPAGATION_REQUIRED
PROPAGATION_REQUIRED
-
-
session.setFlushMode(FlushMode.AUTO);
-
session.save(user);
-
session.flush();
在没有使用Spring提供的Open Session In View情况下,因需要在service(or
Dao)层里把session关闭,所以lazy loading
为true的话,要在应用层内把关系集合都初始化,如 company.getEmployees(),否则Hibernate抛session
already closed Exception; Open Session In View提供了一种简便的方法,较好地解决了lazy loading问题.
它有两种配置方式OpenSessionInViewInterceptor和OpenSessionInViewFilter(具体参看SpringSide),功能相同,只是一个在web.xml配置,另一个在application.xml配置而已。
Open Session In View在request把session绑定到当前thread期间一直保持hibernate
session在open状态,使session在request的整个期间都可以使用,如在View层里PO也可以lazy
loading数据,如 ${ company.employees }。当View
层逻辑完成后,才会通过Filter的doFilter方法或Interceptor的postHandle方法自动关闭session。
OpenSessionInViewInterceptor配置
OpenSessionInViewFilter配置
很多人在使用OpenSessionInView过程中提及一个错误:
看看OpenSessionInViewFilter里的几个方法
关 于绑定session的方式,通过看spring里TransactionSynchronizationManager的实现,发现:它维护一个 java.lang.ThreadLocal类型的resources,resources负责持有线程局部变量,这里resources持有的是一个 HashMap,通过TransactionSynchronizationManager.bindResource()方法在map里绑定和线程相关 的所有变量到他们的标识上,包括如上所述的绑定在sessionFactory上的线程局部session。sessionHolder只不过是存放可以
hold一个session并可以和transtaction同步的容器。可以看到 OpenSessionInViewFilter在getSession的时候,会把获取回来的session的flush mode 设为FlushMode.NEVER。然后把该sessionFactory绑定到 TransactionSynchronizationManager,使request的整个过程都使用同一个session,在请求过后再接除该 sessionFactory的绑定,最后closeSessionIfNecessary根据该session是否已和transaction绑定来决定是否关闭session。绑定以后,就可以防止每次不会新开一个Session呢?看看HibernateDaoSupport的情况:
1.
public final void setSessionFactory(SessionFactory sessionFactory) {
2. this.hibernateTemplate = new HibernateTemplate(sessionFactory);
3. }
4. protected final HibernateTemplate getHibernateTemplate() {
5. return hibernateTemplate;
6. }
我们的DAO将使用这个template进行操作.
public abstract class BaseHibernateObjectDao extends HibernateDaoSupport
implements BaseObjectDao {
protected BaseEntityObject getByClassId(final long id) {
BaseEntityObject obj =(BaseEntityObject) getHibernateTemplate().execute(new HibernateCallback() {
public Object doInHibernate(Session session) throws HibernateException {
return session.get(getPersistentClass(),new Long(id));
}
});
return obj;
}
public void save(BaseEntityObject entity) {
getHibernateTemplate().saveOrUpdate(entity);
}
public void remove(BaseEntityObject entity) {
try {
getHibernateTemplate().delete(entity);
} catch (Exception e) {
throw new FlexEnterpriseDataAccessException(e);
}
}
public void refresh(final BaseEntityObject entity) {
getHibernateTemplate().execute(new HibernateCallback() {
public Object doInHibernate(Session session) throws HibernateException {
session.refresh(entity);
return null;
}
});
}
public void replicate(final Object entity) {
getHibernateTemplate().execute(new HibernateCallback() {
public Object doInHibernate(Session session)throws HibernateException {
session.replicate(entity,ReplicationMode.OVERWRITE);
return null;
}
});
}
}
而HibernateTemplate试图每次在execute之前去获得Session,执行完就力争关闭Session
1. public Object execute(HibernateCallback action) throws DataAccessException {
2.
Session session = (!this.allowCreate ?
3.
SessionFactoryUtils.getSession(getSessionFactory(),
4.
false) :
5.
SessionFactoryUtils.getSession(getSessionFactory(),
6.
getEntityInterceptor(),
7.
getJdbcExceptionTranslator()));
8.
boolean existingTransaction =
9.
TransactionSynchronizationManager.hasResource(getSessionFactory());
10.if (!existingTransaction && getFlushMode() == FLUSH_NEVER) {
11.session.setFlushMode(FlushMode.NEVER);
12.}
13.try {
14.Object result = action.doInHibernate(session);
15.flushIfNecessary(session, existingTransaction);
16.return result;
17.}
18.catch (HibernateException ex) {
19.throw convertHibernateAccessException(ex);
20.}
21.finally {
22.SessionFactoryUtils.closeSessionIfNecessary(
23.
session, getSessionFactory());
24.}
25. }
而这个SessionFactoryUtils能否得到当前的session以及closeSessionIfNecessary是否真正关闭 session,端取决于这个session是否用sessionHolder和这个sessionFactory在我们最开始提到的
TransactionSynchronizationManager绑定。
public static void
closeSessionIfNecessary(Session session, SessionFactory sessionFactory)
在这个过程中,若HibernateTemplate 发现自当前session有不是readOnly的transaction,就会获取到FlushMode.AUTO
Session,使方法拥有写权限。也即是,如果有不是readOnly的transaction就可以由Flush.NEVER转为 Flush.AUTO,拥有insert,update,delete操作权限,如果没有transaction,并且没有另外人为地设flush
model的话,则doFilter的整个过程都是Flush.NEVER。所以受transaction保护的方法有写权限,没受保护的则没有。
采用spring的事务声明,使方法受transaction控制
对 于上例,则以save,add,update,remove开头的方法拥有可写的事务,如果当前有某个方法,如命名为importExcel(),则因没 有transaction而没有写权限,这时若方法内有insert,update,delete操作的话,则需要手动设置flush model为Flush.AUTO,如
尽 管Open Session In View看起来还不错,其实副作用不少。看回上面OpenSessionInViewFilter的doFilterInternal方法代码,这个方法 实际上是被父类的doFilter调用的,因此,我们可以大约了解的OpenSessionInViewFilter调用流程:
request(请求)->open session并开始transaction->controller->View(Jsp)->结束transaction并 close session.
一切看起来很正确,尤其是在本地开发测试的时候没出现问题,但试想下如果流程中的某一步被阻塞的话,那在这期间connection就一直被占用而不释 放。最有可能被阻塞的就是在写Jsp这步,一方面可能是页面内容大,response.write的时间长,另一方面可能是网速慢,服务器与用户间传输时 间久。当大量这样的情况出现时,就有连接池连接不足,造成页面假死现象。
Open Session In View是个双刃剑,放在公网上内容多流量大的网站请慎用。
另外:这样会产生一点危险性,毕竟把数据库访问的环境放到了表现层。(用VO)
相关推荐
韩顺平老师的"Spring雇员管理系统"教学资源,重点关注了使用Hibernate ORM框架与Spring集成来处理数据库操作。这个教程通过一个具体的雇员管理系统实例,深入浅出地讲解了Hibernate的核心概念和实践技巧。 ...
7. **事务处理机制**: - Hibernate依赖于JDBC或JTA来处理事务,它自身并不直接提供事务管理功能,而是将事务的控制权交给了底层的事务管理系统。 8. **SessionFactory为单例**: - SessionFactory是重量级对象,...
7. Hibernate的延迟加载机制允许在需要时才加载关联对象,以提高性能。`openSessionInView`模式在Web层设置过滤器,保持Session在一次HTTP请求的整个生命周期内都开启,确保延迟加载能在Session范围内完成。 8. ...
Java框架面试题主要涵盖了许多核心概念,特别是在Spring和Hibernate这两个流行的Java框架中。...以上是Java框架面试中常见的问题和解答,涉及到了Struts、Hibernate和Spring的核心机制,对于理解和准备面试至关重要。
- OpenSessionInView模式在Web请求处理过程中保持Hibernate Session打开,直到视图渲染完成,确保数据的一致性。但也可能导致长时间持有数据库连接,增加内存占用。合理控制Session的生命周期对性能至关重要。 10....
Struts2提供了一套强大的拦截器机制,可以进行输入验证、异常处理等操作。在本示例中,Struts2配置文件(struts.xml)定义了Action与视图之间的映射关系,以及Action的执行逻辑。 2. **Spring**:Spring框架是Java...
Spring的事务管理提供了强大且灵活的机制,主要包括编程式和声明式两种方式: 1. 编程式事务管理:通过TransactionDefinition、TransactionStatus和PlatformTransactionManager接口进行事务的控制。例如,可以使用...
Spring框架提供了事务管理机制,提供了几个关于事务处理的类: 1. TransactionDefinition:事务属性定义。 2. TranscationStatus:代表了当前的事务,可以提交,回滚。 3. PlatformTransactionManager:这是Spring...
【Spring框架1】知识点详解: 1. **Spring AOP(面向切面编程)**:Spring AOP 是一种用于实现横...以上是对Spring框架核心概念及关键知识点的详细解析,涵盖了AOP、IOC、事务管理、Struts对象和Hibernate操作等内容。
4. **Spring 与 Hibernate 整合** - **配置 DataSource**:在 Spring 配置文件中定义数据源。 - **创建 SessionFactory**:基于 DataSource 创建 SessionFactory。 - **DAO 继承 HibernateDaoSupport**:DAO 类...
Hibernate的开发步骤,主要接口(尤其是Session),普通属性和关联关系映射,Native SQL,inverse lazy cascade,继承关系映射,HQL,性能优化(一级缓存,二级缓存,查询缓存),事务和并发控制(悲观锁,乐观锁)...
掌握实体属性映射,关联关系映射,Native SQL,inverse,lazy,cascade,继承关系映射,HQL,性能优化,一级缓存,二级缓存,查询缓存,事务管理,悲观锁和乐观锁,以及OpenSessionInView和CurrentSession。...
Spring 提供了与 Hibernate 等 ORM 框架的集成,例如: - **配置 DataSource 和 SessionFactory**:在 Spring 配置文件中定义数据源和 Hibernate 的 SessionFactory,设置相应的参数。 - **DAO 层集成**:DAO 类...
性能优化,一级缓存,二级缓存,查询缓存,事务管理(悲观锁、乐观锁),以及OpenSessionInView和CurrentSession策略。 9. **Spring**:IoC(控制反转)和DI(依赖注入)的核心概念,Spring的架构,AOP(面向切面...