`
chyx72
  • 浏览: 35475 次
  • 性别: Icon_minigender_1
  • 来自: 成都
社区版块
存档分类
最新评论

声明式spring整合hibernate配置参考

    博客分类：
  • JAVA
spring整合hibernate 
阅读更多
applicationContext.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: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/context 
			http://www.springframework.org/schema/context/spring-context-2.5.xsd">
			
	<!-- 持久层配置 -->
 	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">  
		<property name="driverClass" value="com.mysql.jdbc.Driver"></property>   
		<property name="jdbcUrl" value="jdbc:mysql://127.0.0.1:3306/oa?useUnicode=true&amp;characterEncoding=utf8"></property>   
		<property name="user" value="root"></property>   
		<property name="password" value="root"></property>  
		<property name="maxPoolSize" value="40"></property>   
		<property name="minPoolSize" value="1"></property>   
		<property name="initialPoolSize" value="1"></property>   
		<property name="maxIdleTime" value="180"></property>   
	</bean>  

	<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
		<property name="dataSource">
			<ref bean="dataSource" />
		</property>
		<property name="hibernateProperties">
			<props>
				<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
				<prop key="hibernate.hbm2ddl.auto">update</prop>
				<prop key="hibernate.show_sql">true</prop>
				<prop key="hibernate.format_sql">true</prop>
<!--				<prop key="hibernate.current_session_context_class">thread</prop>-->
			</props>
		</property>
		
		<property name="mappingLocations">
			<list>
				<value>classpath:/com/gc/oa/entity/*.hbm.xml</value>
			</list>
		</property>
	</bean>
	<!-- end  -->
	
	<!-- 事物配置 -->
	<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager"> 
		<property name="sessionFactory"> 
			<ref local="sessionFactory" /> 
		</property> 
	</bean>
	
	<bean id="baseTransactionProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean" abstract="true" lazy-init="true"> 
		<property name="transactionManager"> 
			<ref bean="transactionManager" /> 
		</property>
		<property name="proxyTargetClass"> 
			<value>false</value> 
		</property> 
		
		<property name="transactionAttributes"> 
			<props> 
				<prop key="*">PROPAGATION_REQUIRED</prop> 
			</props> 
		</property> 
	</bean>
	<!-- end -->
	
	<!-- 使用spring annotation自动扫描配置 -->
	<context:component-scan base-package="com.gc.oa" />
	<!-- 使用spring annotation自动事务配置-->
	<tx:annotation-driven transaction-manager="transactionManager" />
	<!-- end -->
</beans>

部分代码: 
package com.gc.oa.dao.impl;

import java.sql.SQLException;
import java.util.List;

import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

import com.gc.oa.dao.BaseDao;
import com.gc.oa.utils.Pagination;

public class BaseDaoImpl<T> extends HibernateDaoSupport implements BaseDao<T>{
	
	private Class clazz;
	
	public BaseDaoImpl(Class clazz) {
		this.clazz=clazz;
	}
	
	@Autowired
	protected void setSessionFactoryS(SessionFactory sessionFactory) {
		this.setSessionFactory(sessionFactory);
	}

	public void add(T t) throws Exception {
		this.getHibernateTemplate().save(t);
	}

	public void delete(T t) throws Exception {
		this.getHibernateTemplate().delete(t);
	}

	public void update(T t) throws Exception {
		this.getHibernateTemplate().update(t);
	}

	public Pagination findByPage(final String query,final int pageNum,final int pageSize) {
		
		return (Pagination)getHibernateTemplate().execute(new HibernateCallback(){
			public Object doInHibernate(Session session)
					throws HibernateException, SQLException {
				
				String queryStr="From "+clazz.getName();
				if(query!=null&&!query.equals("")){
					queryStr+=" Where "+query;
				}
				int count=session.createQuery(queryStr).list().size();
				
				List list=session.createQuery(queryStr)
						.setFirstResult((pageNum-1)*pageSize)
						.setMaxResults(pageSize).list();
				
				Pagination pagination=new Pagination();
				pagination.setCountResult(count);
				pagination.setList(list);
				pagination.setCurPage(pageNum);
				pagination.setPageSize(pageSize);
				return pagination;
			}
			
		});
	
	}

	public T findById(int id) {
		return (T)getHibernateTemplate().get(this.clazz, id);
	}

	@SuppressWarnings("unchecked")
	public List<T> query(final String str) throws Exception {
		return getHibernateTemplate().executeFind(new HibernateCallback(){
			public Object doInHibernate(Session session)
					throws HibernateException, SQLException {
					return session.createQuery("From "+clazz.getName()+" where "+str).list();
			}
		});
	}

	public List<T> findAll() {
		return getHibernateTemplate().loadAll(clazz);
	}
	

}

package com.gc.oa.dao.impl;

import org.springframework.transaction.annotation.Transactional;

import com.gc.oa.entity.Diary;
@Repository
public class DiaryDaoImpl extends BaseDaoImpl<Diary>{
	public DiaryDaoImpl() {
		super(Diary.class);
	}

	@Transactional
	public void deleteById(int id) {
		Diary diary=super.findById(id);
		this.getHibernateTemplate().delete(diary);
	}

}

package com.gc.oa.service.impl;

import java.util.Date;

import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;

import com.gc.oa.dao.DiaryDao;
import com.gc.oa.entity.Diary;
import com.gc.oa.service.DiaryService;
import com.gc.oa.utils.Pagination;
@Service
public class DiaryServiceImpl implements DiaryService {
	public static final Logger logger = Logger.getLogger(DiaryServiceImpl.class);
	@Autowired
	private DiaryDao DiaryServiceImpl;

	@Transactional
	public void add(Diary diary) {
		try {
			diary.setCreateTime(new Date());
			DiaryServiceImpl.add(diary);
		} catch (Exception e) {
			logger.error("添加公告失败");
		}
	}

	public Diary findById(int id) {
		Diary diary = null;
		try {
			diary= DiaryServiceImpl.findById(id);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return diary;
	}

	public Pagination findByPage(String query, int pageNum, int pageSize) throws Exception {
		return DiaryServiceImpl.findByPage(query, pageNum, pageSize);
	}
	@Transactional
	public void update(Diary diary) {
		try {
			Diary diary1=findById(diary.getId());
			if(diary1!=null){
				diary1.setTitle(diary.getTitle());
				diary1.setUpdateTime(new Date());
				diary1.setContent(diary.getContent());
				diary1.setEmployer(diary.getEmployer());
				DiaryServiceImpl.update(diary1);
			}
		} catch (Exception e) {
			logger.error("修改公告失败");
		}
	}
	@Transactional
	public void deleteById(int id) {
		try {
			DiaryServiceImpl.deleteById(id);
		} catch (Exception e) {
			logger.error("删除公告失败");
		}
		
	}
}

package com.gc.oa.action;

import org.apache.struts2.ServletActionContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Service;

import com.gc.oa.entity.Diary;
import com.gc.oa.service.DiaryService;

@Controller("diaryAction")
@Scope("prototype")
public class DiaryAction {
	private Diary diary;
	@Autowired
	private DiaryService diaryServiceImpl;
	public String add(Diary diary){
		diaryServiceImpl.add(diary);
		return "addSuc";
	}
	
	public String delete(Diary diary){
		diaryServiceImpl.deleteById(Integer.valueOf(ServletActionContext.getRequest().getParameter("id")));
		return "delSuc";
	}
	
	public String update(Diary diary){
		diaryServiceImpl.update(diary);
		return "updSuc";
	}
	
	public Diary findById(int id){
		id = Integer.valueOf(ServletActionContext.getRequest().getParameter("id"));
		diary=diaryServiceImpl.findById(id);
		return diary;
		}
	
	public Diary getDiary() {
		return diary;
	}
	public void setDiary(Diary diary) {
		this.diary = diary;
	}
}

例子很简单,代码中记得放@Autowired,@Transactional,@Scope("prototype")...注解
entity配置和hibernate一样,一个javabean对应一个.hbm.xml
web.xml: 
<?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">
	
	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>
			classpath*:applicationContext.xml
		</param-value>
	</context-param>
	
	<context-param>
		<param-name>log4jRefreshInterval</param-name>
		<param-value>6000</param-value>
	</context-param>
	
	<!-- spring2 -->
	<listener>
		<listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>
	</listener>
	
	<listener>
		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	</listener>
	<listener>
		<listener-class>org.springframework.web.context.request.RequestContextListener</listener-class>
	</listener>
	
	<!-- 权限控制 -->
	<filter>
		<filter-name>privilegeController</filter-name>
		<filter-class>com.gc.oa.privilege.PrivilegeController</filter-class>
	</filter>
	<filter-mapping>
		<filter-name>privilegeController</filter-name>
		<url-pattern>/employer/*</url-pattern>
	</filter-mapping>
	
	<!-- open session in view配置 -->
	<filter>
		<filter-name>sessionFilter</filter-name>
		<filter-class>org.springframework.orm.hibernate3.support.OpenSessionInViewFilter</filter-class>

	</filter>
	<filter-mapping>
		<filter-name>sessionFilter</filter-name>
		<url-pattern>/*</url-pattern>
	</filter-mapping>
	<!-- 编码过滤器 -->
	<filter>
		<filter-name>CharacterEncodingFilter</filter-name>
		<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
		<init-param>
			<param-name>encoding</param-name>
			<param-value>UTF-8</param-value>
		</init-param>
	</filter>
	<filter-mapping>
		<filter-name>CharacterEncodingFilter</filter-name>
		<url-pattern>/*</url-pattern>
	</filter-mapping>
	
	<!-- struts2 -->
	<filter>
		<filter-name>struts2</filter-name>
		<filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class>
	</filter>

	<filter-mapping>
		<filter-name>struts2</filter-name>
		<url-pattern>*.do</url-pattern>
		<dispatcher>REQUEST</dispatcher>  
		<dispatcher>FORWARD</dispatcher>
	</filter-mapping>
	
	
  <welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>
  
  <!-- 
  	<error-page>
		<error-code>403</error-code>
		<location>/403.html</location>
	</error-page>
-->
</web-app>

基本上就这样吧
分享到：
| [转]spring事务原理
评论
发表评论

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

相关推荐

    Spring+hibernate整合源代码

    这个“Spring+hibernate整合源代码”应该包含了实现上述整合步骤的示例代码，可以作为学习和参考的资源。通过学习和实践这些代码，你可以更好地理解和掌握 Spring 和 Hibernate 整合的细节，提升你的 Java Web 开发...

    Spring整合Hibernate案例

    - Spring提供了声明式事务管理，通过`@Transactional`注解可以轻松地在方法级别声明事务边界，简化事务管理代码。 - 另外，还可以使用编程式事务管理，通过TransactionTemplate或PlatformTransactionManager接口...

    Spring + JPA + Hibernate配置

    标题“Spring + JPA + Hibernate配置”涉及到的是Java开发中常用的三个框架——Spring、Java Persistence API (JPA) 和Hibernate的集成与配置。这是一份关于如何将这些框架结合使用的教程或参考资料，可能包含了实现...

    spring+hibernate+webwork相关配置

    标题 "spring+hibernate+webwork相关配置" 指的是一个集成开发环境的配置，其中涵盖了三个关键的技术框架：Spring、Hibernate和WebWork。这些框架在Java Web开发中非常常见，主要用于实现依赖注入、持久化管理和MVC...

    Struts2、Spring、Hibernate整合ExtJS,

    ### Struts2、Spring、Hibernate整合ExtJS：深入解析与实践 #### 一、概述 在现代企业级应用开发中，通常会采用多种框架和技术进行整合以满足复杂业务需求。Struts2、Spring 和 Hibernate 是 Java Web 开发领域内...

    Spring+Hibernate

    6. **整合配置**：Spring 和 Hibernate 的整合需要在 Spring 的配置文件中配置 Hibernate 的 SessionFactory，并通过 DataSource 配置数据库连接。同时，还需要配置事务管理器，如 `PlatformTransactionManager`。 ...

    webwork spring hibernate整合实例源代码全部jar包

    3. Hibernate配置文件：设置数据库连接信息，实体类映射等。 4. 实体类：代表数据库中的表，使用Hibernate注解或XML映射文件进行ORM配置。 5. DAO（Data Access Object）层：实现对数据库的操作，通常会使用...

    整合Struts2,Spring2.5,Hibernate3.3操作参考

    整合Hibernate时，我们需要配置Hibernate的sessionFactory，然后通过Spring的HibernateTemplate或SessionFactoryBean来访问数据库。 **整合步骤** 1. **配置环境**：确保JDK、Tomcat、Struts2、Spring和Hibernate库...

    中文Struts+Spring+Hibernate整合开发迅雷

    《Struts+Spring+Hibernate 整合开发.pdf》这本书可能是详细讲解这个主题的资源，它可能涵盖了从基础概念到实战案例的全面内容，对于想要深入理解和掌握这三大框架整合的开发者来说是一份宝贵的参考资料。...

    Spring+Hibernate 自动映射

    2. **事务管理（Transaction Management）**：Spring提供了声明式事务管理，开发者只需在方法上添加@Transactional注解，Spring就会自动处理事务的开始、提交或回滚，提高了代码的可读性和可维护性。 3. **数据源...

    Struts+Spring+Hibernate(整合)

    Struts 与Spring整合时，可以通过Spring的Action代理，实现Action的依赖注入，进一步提高代码的可测试性和解耦。 2. **Spring框架**：Spring 提供了一个容器，用于管理应用对象的生命周期和依赖关系。它允许通过XML...

    spring-hibernate.zip

    接下来，我们将深入探讨Spring整合Hibernate的相关知识点。 1. **Spring框架**：Spring是一个开源的Java平台，它提供了全面的应用程序开发模型，包括事务管理、数据访问集成、Web应用开发等。核心特性包括依赖注入...

    CXF接口Spring+Hibernate的添加完整版

    5. **集成过程**：在整合CXF、Spring和Hibernate的过程中，通常需要配置Spring的XML上下文文件来声明服务接口、实现类、DAO和SessionFactory。此外，还需要设置CXF的服务器配置，指定服务的地址和实现类。在本示例中...

    cxf+spring+hibernate整合添加功能实现修改版

    2. **Spring事务管理**：Spring的事务管理支持声明式和编程式两种方式，可以在服务调用过程中确保数据的一致性。修改版可能优化了事务边界设定，提升了事务处理性能，或者增强了事务回滚策略。 3. **Hibernate整合*...

    整合Struts + Spring + Hibernate

    在IT行业中，构建大型企业级应用时，常常会采用MVC（Model-...而提供的文件"A111]整合Struts + Spring + Hibernate续.exe"可能是一个关于这个整合过程的教程或者示例应用，"src"目录则包含了源代码，供开发者参考学习。

    spring+hibernate+structs(pdf)

    Spring与Hibernate的整合，可以实现声明式事务管理，而Spring与Struts的整合则可以通过Spring的Action代理实现AOP切面，如日志记录、权限验证等。 这份PDF教程将详细讲解这三个框架的安装、配置、基本用法以及它们...

    ssh完整例子ssh完整例子

    整合过程中，可能涉及到的配置包括Struts2的Spring插件配置和Hibernate的SessionFactory注入。 5. **项目结构**：一个SSH项目通常会有如下的目录结构：`src/main/java`存放源代码，`src/main/resources`放置配置...

    struts+spring+hibernate 英文 API

    总的来说，"Struts+Spring+Hibernate 英文 API" 是一套完整的Java开发参考资料，对于熟悉和精通这些框架的开发者来说，是一份宝贵的资源。通过深入研究这些API，开发者不仅可以提升自己的技能，还能更好地适应和解决...

    Spring之Spring2.5集成Hibernate3.6

    1. **事务管理**：Spring提供了一种统一的事务管理方式，可以在不同数据源上进行声明式或编程式事务控制，使得事务管理更加简单且健壮。 2. **对象持久化**：通过Spring的Hibernate模板或者JPA抽象层，开发者可以...

    SpringMVC+Spring+Hibernate(SSH)框架搭建之一

    最后，我们将整合Hibernate作为ORM（对象关系映射）工具，它简化了与数据库的交互。 1. 引入Hibernate依赖：包括hibernate-core、hibernate-entitymanager等。 2. 配置Hibernate：在Spring配置文件中设置...

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