`
紫_色
  • 浏览: 144180 次
  • 性别: Icon_minigender_1
  • 来自: 深圳
社区版块
存档分类
最新评论

关于用String+JPA+struts2使用编程式和声明式事务管理页面出现could not initialize proxy - no Session的问题

    博客分类：
  • J2EE
could not initialize proxy - no Session事务管理编程式和声明式 
阅读更多

Spring事务的管理分为声明式和编程式,声明式就是在Spring配置文件中统一声明,而编程式就是使用@Transactional对方法或类进行注解.在项目开发过各中为对事物进行更灵活的控制,我们理所当然的认为在Service声明开启事物,然后在Dao层对只读方法声明为只读和将事务挂起,这样即使在Service有的查询方法中插入更新或者删除操作时也可以进行很好的事务控制,但是我们发现在service层和dao层同时使用事务时会出现问题.下面分别对声明式事务管理和编程式事务管理分别进行说明.

 

首先贴出其基本的测试代码:

Model:

package gd.hz.shopping.model;

import java.util.HashSet;
import java.util.Set;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.OneToMany;

/**
 * 商品类别实体类
 * 实现Serializable为以后做分布提供扩展
 * @author Administrator
 *
 */
@Entity
public class ProductType {
	
	private static final long serialVersionUID = 1L;

	/**
	 * 类别ID
	 */
	private int id ;
	
	/**
	 * 用户名称
	 */
	private String name ;
	
	/**
	 * 备注,用于搜索引擎
	 */
	private String note ;
	
	/**
	 * 是否可见
	 */
	private boolean visible = true ;
	
	/**
	 * 父商品,可以没有
	 */
	private ProductType parent ;
	
	/**
	 * 子类商品,可以没有
	 */
	private Set<ProductType> childType = new HashSet<ProductType>() ;

	@Id
	@GeneratedValue
	@Column(name="productId")
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}

	@Column(nullable=false , length=32)
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}

	@Column(length=128)
	public String getNote() {
		return note;
	}
	public void setNote(String note) {
		this.note = note;
	}

	@Column(nullable=false)
	public boolean isVisible() {
		return visible;
	}
	public void setVisible(boolean visible) {
		this.visible = visible;
	}

	@ManyToOne(cascade={CascadeType.REFRESH} , fetch=FetchType.LAZY)
	@JoinColumn(name="parentId")
	public ProductType getParent() {
		return parent;
	}
	public void setParent(ProductType parent) {
		this.parent = parent;
	}
	
	@OneToMany(mappedBy="parent" , cascade={CascadeType.REFRESH , CascadeType.REMOVE})
	public Set<ProductType> getChildType() {
		return childType;
	}
	public void setChildType(Set<ProductType> childType) {
		this.childType = childType;
	}
}

这里我们要注意,我们的实体有一个外键(parent)是指向自己的,并且声明为懒加载.

 

Dao接口:

package gd.hz.shopping.dao;

public interface ProductTypeDao {
	public <T> T select(Class<T> entityClass, Object entityId) ;
	public void insert(Object entity) ;
	public <T>  void delete(Class<T> entityClass , Object entityId) ;
}

 

 

Dao接口实现:

package gd.hz.shopping.dao.impl;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

import org.springframework.stereotype.Repository;
import org.springframework.transaction.support.TransactionSynchronizationManager;

import gd.hz.shopping.dao.ProductTypeDao;

/**
 * 商品类别DAO层
 * @author Administrator
 *
 */
@Repository("productTypeDao")
public class ProductTypeDaoImpl implements ProductTypeDao {

	/**
	 * 使用EntityManager管理器
	 */
	protected EntityManager entityManager ;

	@PersistenceContext
	protected void setEntityManager(EntityManager entityManager) {
		this.entityManager = entityManager;
	}
	
	/**
	 * 查询实体
	 */
	@Override
	public <T> T select(Class<T> entityClass, Object entityId) {
		return entityManager.find(entityClass , entityId) ;
	}

	/**
	 * 插入实体
	 */
	@Override
	public void insert(Object entity) {
		entityManager.persist(entity) ;
	}

	/**
	 * 更新实体
	 */
	@Override
	public <T> void delete(Class<T> entityClass, Object entityId) {
		entityManager.remove(entityManager.getReference(entityClass, entityId)) ;
	}

}

 

 

Service接口:

package gd.hz.shopping.service;

public interface ProductTypeService {
	public <T> T find(Class<T> entityClass, Object entityId) ;
	public void save(Object entity) ;
	public <T>  void remove(Class<T> entityClass , Object entityId) ;
}

 

 

Service接口实现:

package gd.hz.shopping.service.impl;

import javax.annotation.Resource;

import org.springframework.stereotype.Service;
import org.springframework.transaction.support.TransactionSynchronizationManager;

import gd.hz.shopping.dao.ProductTypeDao;
import gd.hz.shopping.service.ProductTypeService;

/**
 * 产品类别Service层
 * @author Administrator
 *
 */
@Service("productTypeService")
public class ProductTypeServiceImpl implements ProductTypeService {

	private ProductTypeDao productTypeDao = null ;
	
	/**
	 * 注入产品类别Dao类
	 * @param productTypeDao
	 */
	@Resource(name="productTypeDao")
	public void setProductTypeDao(ProductTypeDao productTypeDao) {
		this.productTypeDao = productTypeDao;
	}

	@Override
	public <T> T find(Class<T> entityClass, Object entityId) {
		return productTypeDao.select(entityClass, entityId) ;
	}

	@Override
	public void save(Object entity) {
		productTypeDao.insert(entity);
	}

	@Override
	public <T> void remove(Class<T> entityClass, Object entityId) {
		productTypeDao.delete(entityClass, entityId) ;
	}
}

 

 

我的测试的环境是基于Spring+JPA+struts进行的,其基本配置可以看我之前写的文章<<java Spring-3.2.0+Struts-2.3.4+JPA2.0整合>>,首先看一下声明式事务管理:

 

 

 

我们在Spring配置文件中同时对service层和dao层声明事务.其部分配置如下:

<aop:config>
		<aop:pointcut id="bussinessService"
			expression="execution(public * gd.hz.shopping.service.*.*(..))" />
		<aop:advisor pointcut-ref="bussinessService"
			advice-ref="txAdvice" />
	</aop:config>
	<tx:advice id="txAdvice" transaction-manager="transactionManager">
		<tx:attributes>
			<tx:method name="find*" propagation="NOT_SUPPORTED" />
			<tx:method name="save*" propagation="REQUIRED"/>
			<tx:method name="modify*" propagation="REQUIRED"/>
			<tx:method name="remove*" propagation="REQUIRED"/>
		</tx:attributes>
	</tx:advice>
	
	<aop:config>
		<aop:pointcut id="bussinessDao"
			expression="execution(public * gd.hz.shopping.dao.*.*(..))" />
		<aop:advisor pointcut-ref="bussinessDao"
			advice-ref="txdao" />
	</aop:config>
	<tx:advice id="txdao" transaction-manager="transactionManager">
		<tx:attributes>
			<tx:method name="select*" read-only="true" propagation="NOT_SUPPORTED" />
			<tx:method name="insert*" propagation="REQUIRED"/>
			<tx:method name="delete*" propagation="REQUIRED"/>
		</tx:attributes>
	</tx:advice>

 这样我们就在Service层开启了事物,然后在Dao层对只读方法声明没有事务和只读.我们是这样认为的.

 

然后我们使用struts2写一个控制类,查询一个ID为52的实体,这个实体的父类ID为31(名称为篮球31):

package gd.hz.shopping.action;

import javax.annotation.Resource;

import gd.hz.shopping.model.ProductType;
import gd.hz.shopping.service.ProductTypeService;

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Controller;

import com.opensymphony.xwork2.ActionSupport;

/**
 * 产品类别控制器
 * @author Administrator
 *
 */
@Controller("productTypeAction")
@Scope("prototype")
public class ProductTypeAction extends ActionSupport {

	private static final long serialVersionUID = 1L;
	
	private ProductTypeService productTypeService = null ;
	private ProductType productType = null ;

	public ProductType getProductType() {
		return productType;
	}
	public void setProductType(ProductType productType) {
		this.productType = productType;
	}
	
	@Resource(name="productTypeService")
	public void setProductTypeService(ProductTypeService productTypeService) {
		this.productTypeService = productTypeService;
	}

	/**
	 * 返回产品类型列表
	 * @return
	 */
	public String productType()
	{
		productType = productTypeService.find(ProductType.class, 52);
		return "productType" ;
	}
}

 

新建一个JSP文件Test.jsp(查询其父类名称):

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
测试session关闭:${productType.parent.name }
</body>
</html>

 

配置我们的struts2文件:

<package name="center" namespace="/admin/center" extends="struts-default">
		<action name="productTypeAction" class="productTypeAction">
			<result name="productType">/Test.jsp</result>
		</action>
	</package>

输入URL后进行测试,没问题,可以正常显示.Spring提供的一个TransactionSynchronizationManager类,这个类有两个静态方法.getCurrentTransactionName()和isCurrentTransactionReadOnly(),它们的用处分别是判断当前上下文是否有事务,有就返回名称,没有返回空.而isCurrentTransactionReadOnly返回当前事务是否只读.

 

把这两个方法另到我们的查询中.

 

Dao层:

public <T> T select(Class<T> entityClass, Object entityId) {
		System.out.println("Dao--> 是否使用事务: " + TransactionSynchronizationManager.getCurrentTransactionName());
		System.out.println("Dao--> 是否只读: " + TransactionSynchronizationManager.isCurrentTransactionReadOnly());
		return entityManager.find(entityClass , entityId) ;
	}

 

Service层:

@Override
	public <T> T find(Class<T> entityClass, Object entityId) {
		System.out.println("Service--> 是否使用事务: " + TransactionSynchronizationManager.getCurrentTransactionName());
		System.out.println("Service--> 是否只读: " + TransactionSynchronizationManager.isCurrentTransactionReadOnly());
		return productTypeDao.select(entityClass, entityId) ;
	}
 
测试截图如下:


 
可以看出我们在Spring配置文件对Dao层的事务配置并不生效.所以配了也白配.
 
再看一下我们的编程式事务管理:
首先在Spring中注释掉声明式管理的配置:
<!-- <aop:config>
		<aop:pointcut id="bussinessService"
			expression="execution(public * gd.hz.shopping.service.*.*(..))" />
		<aop:advisor pointcut-ref="bussinessService"
			advice-ref="txAdvice" />
	</aop:config>
	<tx:advice id="txAdvice" transaction-manager="transactionManager">
		<tx:attributes>
			<tx:method name="find*" propagation="NOT_SUPPORTED" />
			<tx:method name="save*" propagation="REQUIRED"/>
			<tx:method name="modify*" propagation="REQUIRED"/>
			<tx:method name="remove*" propagation="REQUIRED"/>
		</tx:attributes>
	</tx:advice>
	
	<aop:config>
		<aop:pointcut id="bussinessDao"
			expression="execution(public * gd.hz.shopping.dao.*.*(..))" />
		<aop:advisor pointcut-ref="bussinessDao"
			advice-ref="txdao" />
	</aop:config>
	<tx:advice id="txdao" transaction-manager="transactionManager">
		<tx:attributes>
			<tx:method name="select*" read-only="true" propagation="NOT_SUPPORTED" />
			<tx:method name="insert*" propagation="REQUIRED"/>
			<tx:method name="delete*" propagation="REQUIRED"/>
		</tx:attributes>
	</tx:advice> -->
 
在配置文件上使用@Transactional:
<!-- 对@Transactional这个注解进行的驱动，
	这是基于注解的方式使用事务配置声明，这样在具体应用中可以指定对哪些方法使用事务。 -->
	<tx:annotation-driven transaction-manager="transactionManager" />
 
在ProductTypeServiceImpl类和ProductTypeDaoImpl上加上@Transactional注解,默认为Propagation.REQUIRED,它的意思是当前上下文有事务就使用当前事务,没有就创建一个.
@Transactional
public class ProductTypeDaoImpl implements ProductTypeDao
 
@Transactional
public class ProductTypeServiceImpl implements ProductTypeService
 
然后在Dao层对我们的方法加上不使用事务和只读.
@Override
	@Transactional(readOnly=true, propagation=Propagation.NOT_SUPPORTED)
	public <T> T select(Class<T> entityClass, Object entityId) {
		System.out.println("Dao--> 是否使用事务: " + TransactionSynchronizationManager.getCurrentTransactionName());
		System.out.println("Dao--> 是否只读: " + TransactionSynchronizationManager.isCurrentTransactionReadOnly());
		return entityManager.find(entityClass , entityId) ;
	}
 
引入Junit包进行单元测试:
@Test
	public void testFind() {
		ProductType productType = productTypeService.find(ProductType.class , 52) ;
		System.out.println("测试session关闭:" + productType.getParent().getName()) ;
	}
 看一下部分结果截图:
 

 这一次好像我们在Dao层的配置生效了,很遗憾,它抛出了一个org.hibernate.LazyInitializationException: could not initialize proxy - no Session异常.session关闭了,很正常我们建立实体的时候把父类设为懒加载了.
我们在jsp上进行测试也是同样抛出这个异常,那我们认为我们可以在web.xml文件配置声明session到web层才关闭.那看一下web.xmlr的配置:
  
<!-- 声明session在view层关闭 -->
	<filter>
		<filter-name>Spring OpenEntityManagerInViewFilter</filter-name>
		<filter-class>org.springframework.orm.jpa.support.OpenEntityManagerInViewFilter</filter-class>
		<init-param>
			<param-name>entityManagerFactoryBeanName</param-name>
			<param-value>entityManagerFactory</param-value>
		</init-param>
	</filter>
	<filter-mapping>
		<filter-name>Spring OpenEntityManagerInViewFilter</filter-name>
		<url-pattern>/*</url-pattern>
	</filter-mapping>
 要注意要配置在struts声明之前.
再次进行测试,还是会报could not initialize proxy - no Session异常.但是我们把Dao层的事务声明去掉在jsp进行测试发现可以了(Junit也会报错).
 
最后我认为这是Spring还没有完善的地方,所以我们现在只能在Service中声明事务.
 
 
  • 大小: 22.3 KB
  • 大小: 21.7 KB
分享到：
| 关于@ include和jsp:include的区别
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Spring+Struts2+JPA

    **Spring+Struts2+JPA 整合详解** 在Java Web开发中，Spring、Struts2和JPA是三个非常重要的框架。Spring作为一个全面的轻量级框架，提供了依赖注入（DI）和面向切面编程（AOP）等功能；Struts2是一个强大的MVC框架...

    Java Web EJB3+JPA+Struts2 分布式宠物商店源代码项目

    分布式宠物商店(EJB3+JPA+Struts2) 宠物商店(petstore)是个比较经典的demo案例， 以宠物商店充分演示EJB3与Java Web程序，Java图形界面程序的结合 主要模块：会员模块 宠物类别模块 宠物模块 购物模块

    spring+hibernate+jpa+struts1+struts2+springmvc+jquery+freemaker 学习笔记 案例.rar

    spring+hibernate+jpa+struts1+struts2+springmvc+jquery+freemaker 学习笔记 Compass将lucene、Spring、Hibernate三者结合

    基于_Struts_2+Spring+JPA_框架的WEB_应用

    Struts 2 提供了一种声明式和配置式的控制流程，使得开发者可以专注于业务逻辑而不是繁琐的请求处理。它通过Action类处理HTTP请求，使用Interceptor拦截器进行预处理和后处理，以及提供结果映射来决定请求的最终目的...

    Struts+spring+JPA例子

    它允许开发者通过声明式方式管理事务，增强了应用的可测试性。 JPA（Java Persistence API）是Java EE平台中的持久化标准，它为对象关系映射（ORM）提供了统一的API。JPA2.0版本带来了许多改进，包括更强大的查询...

    struts2+spring+jpa整合的完整例子（含分页）

    在学习jpa时候做的一个struts2+spring+jpa整合的完整例子 包含分页，一个简单的 资产入库系统 并实现了登陆等。

    Spring+Hibernate+Jpa+Struts2整合实例

    标题 "Spring+Hibernate+Jpa+Struts2整合实例" 描述的是一个综合性的Web开发教程，它将四个关键的Java技术框架集成在一起，用于构建高效的企业级应用程序。这个实例涵盖了Spring作为整体应用的管理框架，Hibernate...

    Struts2+Srping+jpa例子

    Struts2、Spring和JPA是Java开发中的三大框架，它们在企业级应用开发中扮演着重要的角色。这个"Struts2+Spring+jpa例子"是一个面向初学者的学习资源，旨在帮助他们理解如何将这三个框架集成到一个项目中，实现数据的...

    Spring+JPA+Struts2

    - **AOP（面向切面编程）**：通过实现声明式事务管理等功能增强模块化能力。 - **事务管理**：提供了一种机制来管理事务边界，使得开发者可以更专注于业务逻辑而非事务处理细节。 - **MVC支持**：提供了构建Web应用...

    Struts2+JPA+Spring整合(PPT)

    Struts2处理用户请求和视图跳转，Spring提供依赖管理和事务控制，而JPA则负责数据持久化。这种整合方式大大简化了开发流程，提高了代码的可维护性和可扩展性。在实际项目中，开发者应熟练掌握这些框架的使用和整合...

    struts2+jpa+spring2.5配置基础框架

    整合Spring 2.5与Struts2和JPA，我们可以在Spring的配置文件（如`applicationContext.xml`）中定义Bean，包括Action类、Service类和DAO类，然后使用Spring的依赖注入来管理这些组件。 在这个基础框架的配置中，我们...

    Struts2+Spring+JPA实例

    Struts2、Spring和JPA是Java开发中常用的三大框架，它们在企业级应用开发中发挥着关键作用。Struts2作为一个成熟的MVC框架，负责处理前端请求和控制业务流程；Spring作为轻量级的IOC（Inversion of Control）和AOP...

    Spring3+Struts2+JPA2.0

    - **事务管理**：Spring支持编程式和声明式事务管理，确保数据的一致性和完整性。 2. **Struts2框架**： - **MVC模式**：Struts2是基于MVC设计模式的，分离了业务逻辑、数据展示和用户交互。 - **拦截器...

    Struts+Spring+Jpa(hibernate)整合

    在整合中，Spring主要负责管理所有bean（包括Struts的Action和Hibernate的SessionFactory），并且可以通过声明式事务管理来处理数据库事务。 3. **JPA（Java Persistence API）与Hibernate**：JPA是Java官方提出的...

    基于JSF+EJB3+JPA的竞价拍卖系统

    同时，JPA的事务管理保证了数据的一致性和完整性。 **服务器环境：JBOSS** JBOSS是一个开源的应用服务器，支持Java EE规范，包括JSF、EJB和JPA。在拍卖系统中，JBOSS作为运行环境，为应用程序提供了运行时的服务，...

    Struts2 + Spring + Jpa

    Struts2 + Spring + JPA 是一...Struts2处理用户请求和视图展示，Spring管理对象和事务，JPA则负责数据持久化。这种集成方式简化了开发流程，提高了代码的可读性和可维护性，同时也为大型企业级应用提供了强大的支持。

    Struts 2 + Spring 2 + JPA + AJAX 示例

    Struts 2、Spring 2、JPA 和 AJAX 是企业级 Web 应用开发中的四大核心技术，它们在构建高效、可扩展的系统中扮演着重要角色。本示例结合这四种技术，提供了一个完整的应用实例，帮助开发者了解如何将它们整合在一起...

    集成spring的hibernate懒加载

    在Spring整合Hibernate的情况下，Session通常通过Transaction Management进行管理，比如使用`Open Session in View`（OSIV）模式或者基于注解的事务管理。 当你尝试在Controller层或者视图层访问懒加载的属性时，...

    struts2+spring2+jpa+ajax

    Struts2、Spring2、JPA（Java Persistence API）和Ajax是Java Web开发中的四大关键技术，它们共同构建了一个高效、灵活且功能强大的应用程序框架。在这个项目中，这四者的组合运用旨在实现一个前后端分离、数据持久...

Magicbox
Global site tag (gtag.js) - Google Analytics