`
在水伊方
  • 浏览: 110588 次
  • 性别: Icon_minigender_1
  • 来自: 福州
社区版块
存档分类
最新评论

Spring与Hibernate的整合

阅读更多

下面为例子中将要操作的对象

package org.spring.bean;

public class Person {
	private Integer id;
	private String name;

	public Person() {
	}

	public Person(String name) {
		this.name = name;
	}

	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
}

 

与Person对象对应的映射文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="org.spring.bean">
	<class name="Person" table="person">
		<cache usage="read-write" region="org.spring.bean.Person" />
		<id name="id">
			<generator class="native" />
		</id>
		<property name="name" length="10" not-null="true" />
	</class>
</hibernate-mapping>

 

对Person对象操作的接口

package org.spring.service;

import java.util.List;

import org.spring.bean.Person;

public interface PersonService {

	public void save(Person person);

	public void update(Person person);

	public Person getPerson(Integer personid);

	public void delete(Integer personid);

	public List<Person> getPersons();

}

 

业务bean的实现类

package org.spring.service.impl;

import java.util.List;

import javax.annotation.Resource;

import org.hibernate.SessionFactory;
import org.spring.bean.Person;
import org.spring.service.PersonService;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

@Transactional
public class PersonServiceBean implements PersonService {
	@Resource
	private SessionFactory sessionFactory;

	public void save(Person person) {
		sessionFactory.getCurrentSession().persist(person);
	}

	public void update(Person person) {
		sessionFactory.getCurrentSession().merge(person);
	}

	@Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)
	public Person getPerson(Integer personid) {
		return (Person) sessionFactory.getCurrentSession().get(Person.class,
				personid);
	}

	public void delete(Integer personid) {
		sessionFactory.getCurrentSession()
				.delete(sessionFactory.getCurrentSession().load(Person.class,
						personid));
	}

	@Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)
	@SuppressWarnings("unchecked")
	public List<Person> getPersons() {
		return sessionFactory.getCurrentSession().createQuery("from Person")
				.list();
	}

}

 

在获取数据的时候,一般不开启事务,因为事务对性能影响较大

 

spring.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:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-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/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
           
	<context:annotation-config />
	
	<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
		destroy-method="close">
		<property name="driverClassName" value="org.gjt.mm.mysql.Driver" />
		<property name="url"
			value="jdbc:mysql://localhost:3306/springAndHibernate?useUnicode=true&amp;characterEncoding=UTF-8" />
		<property name="username" value="root" />
		<property name="password" value="mysql" />
		<!-- 连接池启动时的初始值 -->
		<property name="initialSize" value="1" />
		<!-- 连接池的最大值 -->
		<property name="maxActive" value="500" />
		<!-- 最大空闲值.当经过一个高峰时间后,连接池可以慢慢将已经用不到的连接慢慢释放一部分,一直减少到maxIdle为止 -->
		<property name="maxIdle" value="2" />
		<!-- 最小空闲值.当空闲的连接数少于阀值时,连接池就会预申请去一些连接,以免洪峰来时来不及申请 -->
		<property name="minIdle" value="1" />
	</bean>

	<bean id="sessionFactory"
		class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
		<property name="dataSource" ref="dataSource" />
		<property name="mappingResources">
			<list>
				<value>org/spring/bean/Person.hbm.xml</value>
			</list>
		</property>
		<property name="hibernateProperties">
			<value>
				hibernate.dialect=org.hibernate.dialect.MySQL5Dialect
				hibernate.hbm2ddl.auto=update
				hibernate.show_sql=false
				hibernate.format_sql=false
				hibernate.cache.use_second_level_cache=true
				hibernate.cache.use_query_cache=false
				hibernate.cache.provider_class=org.hibernate.cache.EhCacheProvider
			</value>
		</property>
	</bean>

	<bean id="txManager"
		class="org.springframework.orm.hibernate3.HibernateTransactionManager">
		<property name="sessionFactory" ref="sessionFactory" />
	</bean>

	<tx:annotation-driven transaction-manager="txManager" />
	<bean id="personService" class="org.spring.service.impl.PersonServiceBean" />
</beans>

 

测试类

package org.spring.junit;

import java.util.List;

import org.junit.BeforeClass;
import org.junit.Test;
import org.spring.bean.Person;
import org.spring.service.PersonService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class PersonServiceTest {
	private static PersonService personService;

	@BeforeClass
	public static void setUpBeforeClass() throws Exception {
		try {
			ApplicationContext applicationContext = new ClassPathXmlApplicationContext(
					"spring.xml");
			personService = (PersonService) applicationContext
					.getBean("personService");
		} catch (RuntimeException e) {
			e.printStackTrace();
		}
	}

	@Test
	public void testSave() {
		personService.save(new Person("xxx"));
	}

	@Test
	public void testUpdate() {
		Person person = personService.getPerson(1);
		person.setName("zzz");
		personService.update(person);
	}

	@Test
	public void testGetPerson() {
		Person person = personService.getPerson(1);
		System.out.println(person.getName());
	}

	@Test
	public void testDelete() {
		personService.delete(1);
	}

	@Test
	public void testGetPersons() {
		List<Person> persons = personService.getPersons();
		for (Person person : persons) {
			System.out.println(person.getName());
		}
	}

}

 

分享到:
评论

相关推荐

    Spring与Hibernate整合

    在"25_黑马程序员_黎活明_Spring2.5视频教程_搭建和配置Spring与Hibernate整合的环境.avi"这个文件中,可能详细演示了如何配置这些库到项目的类路径中。 接着,需要配置Spring的IoC容器。这可以通过XML配置文件完成...

    Spring与Hibernate整合实例(博客用户登录增删改查)

    在这个“Spring与Hibernate整合实例(博客用户登录增删改查)”中,我们将探讨如何将这两个强大的框架——Spring和Hibernate——结合起来,以实现一个博客系统的用户管理功能,包括用户登录、注册、信息修改以及数据...

    MyClipse6.0\Struts2,Spring与Hibernate整合应用,学生成绩管理系统

    《Struts2、Spring与Hibernate整合应用:学生成绩管理系统》 在IT行业中,构建一个高效、稳定的Web应用程序常常需要整合不同的框架。本项目“学生成绩管理系统”就是基于Struts2、Spring和Hibernate三大主流Java ...

    Struts2,Spring与Hibernate整合应用,学生成绩管理系统

    ### Struts2、Spring与Hibernate整合应用:学生成绩管理系统 #### 一、知识点概览 本项目聚焦于Struts2、Spring与Hibernate三大框架的整合应用,旨在构建一个高效、稳定、易于维护的学生成绩管理系统。通过整合这...

    Spring与Hibernate整合小例子

    "Spring与Hibernate整合"是为了实现业务逻辑层和数据访问层的高效协作。整合过程通常包括以下几个步骤: 1. **引入依赖**:首先,需要在项目中添加Spring和Hibernate的相关库。这通常通过Maven或Gradle的依赖管理来...

    SSH整合学习笔记之spring与hibernate整合(二)之c3p0

    在Spring与Hibernate整合的过程中,c3p0是一个重要的第三方组件,它是一个开源的JDBC连接池,能够有效地管理和重用数据库连接,从而减少创建和关闭连接的开销,提高系统性能。c3p0提供了许多配置选项,如最小连接数...

    spring和hibernate整合

    《Spring与Hibernate整合详解》 在现代Java Web开发中,Spring和Hibernate是两个非常重要的开源框架,它们分别在依赖注入和对象关系映射(ORM)领域有着广泛的应用。Spring作为一个全面的轻量级应用框架,提供了...

    第25,26讲 --搭建和配置Spring与Hibernate整合的环境

    通过以上步骤,我们就成功地搭建了一个Spring与Hibernate整合的开发环境。在实际开发中,我们还需要考虑性能优化、异常处理、事务策略等因素,以确保应用的稳定性和效率。此外,随着技术的发展,Spring Boot和Spring...

    Spring与hibernate 整合 简单示例

    这个简单的示例展示了Spring和Hibernate整合的基本流程,实际项目中可能还需要考虑更多的细节,如异常处理、事务策略等。 总结来说,Spring与Hibernate的整合使得Java开发人员能够更方便地管理数据库操作,并利用...

    Spring与Hibernate整合.zip

    本压缩包"Spring与Hibernate整合.zip"显然包含了一个关于如何将这两个框架集成到同一Java EE项目的教程或示例代码。下面将详细讲解Spring和Hibernate整合的关键步骤和概念。 1. **Spring的Bean管理**:首先,Spring...

    Spring与Hibernate整合,Spring与Struts2整合源代码

    接下来是Spring与Hibernate整合,其目标是利用Spring的IoC容器管理和事务控制来协调Hibernate的数据访问。具体步骤如下: 1. 引入Hibernate的库文件,包括hibernate-core、hibernate-entitymanager、jta等。 2. ...

    spring与hibernate整合

    解压后,我们可以看到Spring和Hibernate整合的具体实现,包括实体类、DAO、Service、配置文件等。 总的来说,Spring与Hibernate的整合使得开发者可以更专注于业务逻辑,而不用过多地关心数据库交互的细节。这种集成...

    spring 与 hibernate整合

    综上所述,Spring 与 Hibernate 的整合涉及多个层面,从配置管理到事务处理,再到业务逻辑的实现,都需要精心设计和合理配置。理解这些知识点对于提升 Java 开发技能至关重要,尤其是在企业级应用开发中。通过示例...

    浅谈Spring+Hibernate整合(共16页).doc

    总之,Spring 和 Hibernate 的整合是 Java Web 开发中的常见实践,它利用 Spring 的强大管理能力和事务处理,结合 Hibernate 的 ORM 功能,简化了数据库操作和事务管理,提高了软件的可扩展性和可维护性。...

    Struts2,Spring与Hibernate整合应用,学生成绩管理系统.doc

    ### Struts2、Spring与Hibernate整合应用:学生成绩管理系统 #### 实验要求与目标概述 本实验的主要目的是实现一个学生成绩管理系统,利用Struts2、Spring与Hibernate这三个流行的Java Web开发框架进行整合,以...

    struts2+spring+hibernate 整合的jar包

    此外,Spring还提供了与Hibernate的整合模块,使得ORM操作更加便捷。 3. **Hibernate**:Hibernate是一个优秀的对象关系映射(ORM)框架,它允许开发者使用Java对象来操作数据库,而无需直接编写SQL语句。Hibernate...

    spring+hibernate整合demo

    在"标签"中,"spring 整合 hibernate helloworld"进一步强调了这是关于Spring与Hibernate整合的基础教学,可能包含了一个简单的入门级示例。"helloworld"通常表示最基础的程序,用于展示框架的基本用法。 在"压缩...

    Spring+hibernate整合源代码

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

    基于SSH框架的学生成绩管理系统源码+数据库,Struts2、Spring与Hibernate整合应用,实验报告

    1) 整合Struts2、Spring和Hibernate框架 (2) 实现“登录”功能 (3) 实现“学生信息管理”功能 (4) 实现“学生成绩...基于SSH框架的学生成绩管理系统源码+数据库,Struts2、Spring与Hibernate整合应用,实验报告

Global site tag (gtag.js) - Google Analytics