搭建开发环境：
Spring2.5需要的JAR文件：
spring-framework-2.5.6\dist\spring.jar
spring-framework-2.5.6\lib\jakarta-commons\commons-logging.jar
spring-framework-2.5.6\lib\aspectj\aspectjweaver.jar
Hibernate3.6需要的JAR文件
hibernate-distribution-3.6.0.Final\hibernate3.jar
hibernate-distribution-3.6.0.Final\lib\required\*
hibernate-distribution-3.6.0.Final\lib\jpa\hibernate-jpa-2.0-api-1.0.0.Final.jar
数据库驱动包
mysql-connector-java-5.1.7-bin.jar
方式一：
1.实体类与映射文件
package org.monday.hibernate1;
import java.util.Date;
public class Emp {
private int id; // 编号
private String name; // 姓名
private int age; // 年龄
private double salary; // 薪水
private Date birthday; // 生日
public Emp() {
}
public Emp(int id, String name, int age, double salary, Date birthday) {
this.id = id;
this.name = name;
this.age = age;
this.salary = salary;
this.birthday = birthday;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
@Override
public String toString() {
return "Emp [id=" + id + ", name=" + name + ", age=" + age
+ ", salary=" + salary + ", birthday=" + birthday + "]";
}
}
Emp.hbm.xml
<?xml version="1.0"?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> <hibernate-mapping package="org.monday.hibernate1"> <class name="Emp" table="EMP"> <id name="id"> <generator class="assigned" /> </id> <property name="name" /> <property name="age" /> <property name="salary" /> <property name="birthday" /> </class> </hibernate-mapping>
2.开发Dao
package org.monday.hibernate1;
import java.util.List;
public interface EmpDao {
/** 插入 */
public void insert(Emp emp);
/** 更新*/
public void update(Emp emp);
/** 删除*/
public void delete(Emp emp);
/** 根据id删除 */
public void delete(int id);
/** 根据id查询雇员的详细信息 */
public Emp findById(int id);
/** 查询全部雇员信息 */
public List<Emp> findAll();
/** 根据雇员姓名查询其薪水 */
public double findSalary(String name);
/** 查询部总记录数 */
public int totalCount();
/** 批量插入 */
public void insertBatch(List<Emp> emps);
/** 批量删除 */
public void deleteBatch(int... ids);
}
3.开发Dao实现类
package org.monday.hibernate1;
import java.util.List;
import javax.annotation.Resource;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;
@Repository("empDao")
public class EmpDaoImpl implements EmpDao {
@Resource
private SessionFactory sessionFactory;
/*
public void setSessionFactory(SessionFactory sessionFactory) {
this.sessionFactory = sessionFactory;
}
*/
/** 取得当前可用的Session */
private Session getSession(){
return sessionFactory.getCurrentSession();
}
/** 插入 */
@Transactional
public void insert(Emp emp) {
getSession().save(emp);
}
/** 更新 */
@Transactional
public void update(Emp emp) {
getSession().update(emp);
}
/** 删除 */
@Transactional
public void delete(Emp emp) {
getSession().delete(emp);
}
/** 根据id删除 */
@Transactional
public void delete(int id) {
/** 方法一 */
/*
Emp emp=(Emp) getSession().get(Emp.class,id);
getSession().delete(emp);
*/
/** 方法二*/
getSession().createQuery("delete from Emp where id=?").setParameter(0, id).executeUpdate();
}
/** 根据id查询雇员的详细信息 */
@Transactional(readOnly=true)
public Emp findById(int id) {
return (Emp) getSession().get(Emp.class,id);
}
/** 查询全部雇员信息 */
@Transactional(readOnly=true)
public List<Emp> findAll() {
return getSession().createQuery("from Emp").list();
}
/** 根据雇员姓名查询其薪水 */
@Transactional(readOnly=true)
public double findSalary(String name) {
return (Double) getSession().createQuery("select e.salary from Emp e where e.name=?").setParameter(0, name).uniqueResult();
}
/** 查询部总记录数 */
@Transactional(readOnly=true)
public int totalCount() {
return Integer.parseInt( getSession().createQuery("select count(id) from Emp").uniqueResult()+"");
//return (Integer) getSession().createQuery("select count(id) from Emp").uniqueResult();
//会抛出java.lang.ClassCastException: java.lang.Long cannot be cast to java.lang.Integer
}
/** 批量插入 */
@Transactional
public void insertBatch(List<Emp> emps) {
for (int i = 0; emps != null && i < emps.size(); i++) {
getSession().save(emps.get(i));
if(i%20==0){
getSession().flush();
getSession().clear();
}
}
}
/** 批量删除 */
@Transactional
public void deleteBatch(int... ids) {
/** 方法一 */
for (int i = 0; ids != null && i < ids.length; i++) {
Emp emp=(Emp) getSession().get(Emp.class,ids[i]);
getSession().delete(emp);
if(i%20==0){
getSession().flush();
getSession().clear();
}
}
/** 方法二*/
/*
StringBuffer hql=new StringBuffer();
hql.append("delete from Emp where id in");
hql.append("(");
for (int i = 0; ids != null && i < ids.length; i++) {
if(i==ids.length-1){
hql.append("?");
}else{
hql.append("?,");
}
}
hql.append(")");
Query query=getSession().createQuery(hql.toString());
for (int j=0; ids != null && j < ids.length; j++) {
query.setParameter(j, ids[j]);
}
query.executeUpdate();
*/
/** 方法三*/
/*
StringBuffer hql=new StringBuffer();
hql.append("delete from Emp where id in");
hql.append("(");
for (int i = 0; ids != null && i < ids.length; i++) {
if(i==ids.length-1){
hql.append(ids[i]);
}else{
hql.append(ids[i]+",");
}
}
hql.append(")");
getSession().createQuery(hql.toString()).executeUpdate();
*/
}
}
这里的操作需要通过Spring容器来注入SessionFactory，从而获取Session进行一系列Hibernate操作，而不依赖于Spring的API，只不过SessionFactory要依赖Spring容器来注入。而事务使用注解配置。
4.Spring的配置文件beans.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.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"> <!-- 配置注解扫描器 --> <context:annotation-config/> <!-- 指定要扫描的包 --> <context:component-scan base-package="org.monday.hibernate1"/> <!-- 将Hibernate的异常转变成Spring的DataAccessException异常 --> <bean class="org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor"/> <!-- 配置sessionFactory --> <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <property name="configLocation" value="classpath:hibernate.cfg.xml"/> <property name="mappingLocations" value="org/monday/hibernate1/*.hbm.xml"/> </bean> <!-- 配置事务 --> <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager"> <property name="sessionFactory" ref="sessionFactory"/> </bean> <tx:annotation-driven transaction-manager="transactionManager"/> </beans>
5.测试
package org.monday.hibernate1;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Main {
private ApplicationContext ctx = new ClassPathXmlApplicationContext("org/monday/hibernate1/beans1.xml");
private EmpDao empDao = (EmpDao) ctx.getBean("empDao");
@Test
public void testInsert() {
Emp emp = new Emp(101, "zy_test1", 21, 3000, randomDate("1980-01-01","1999-12-31"));
empDao.insert(emp);
}
@Test
public void testUpdate() {
Emp emp = new Emp(1, "zy_test", 19, 1000, randomDate("1980-01-01","1999-12-31"));
empDao.update(emp);
}
@Test
public void testDeleteEmp() {
Emp emp = new Emp();
emp.setId(100);
empDao.delete(emp);
}
@Test
public void testDeleteInt() {
empDao.delete(99);
}
@Test
public void testFindById() {
Emp emp = empDao.findById(1);
System.out.println(emp);
}
@Test
public void testFindAll() {
List<Emp> list = empDao.findAll();
for (Emp e : list) {
System.out.println(e);
}
}
@Test
public void testFindSalary() {
double salary = empDao.findSalary("zy_test");
System.out.println(salary);
}
@Test
public void testTotalCount() {
int count = empDao.totalCount();
System.out.println("共" + count + "条记录");
}
@Test
public void testInsertBatch() {
List<Emp> emps = new ArrayList<Emp>();
for (int i = 1; i <= 100; i++) {
int age = (int) (Math.random() * 100) + 1;
double salary = (int) (Math.random() * 3000) + 1;
Emp emp = new Emp(i, "zy_test" + i, age, salary, randomDate("1980-01-01", "1999-12-31"));
emps.add(emp);
}
empDao.insertBatch(emps);
}
@Test
public void testDeleteBatch() {
int[] ids = {96,95};
empDao.deleteBatch(ids);
}
/** 在给定的日期范围内生成随即日期 */
private static Date randomDate(String beginDate, String endDate) {
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
try {
long start = format.parse(beginDate).getTime();
long end = format.parse(endDate).getTime();
long time = Math.abs(start + (long) (Math.random() * (end - start)));
return new Date(time);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
方式二：
直接看Dao实现类吧
package org.monday.hibernate2;
import java.util.List;
import org.springframework.orm.hibernate3.HibernateTemplate;
public class EmpDaoImpl implements EmpDao {
private HibernateTemplate hibernateTemplate;
public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
this.hibernateTemplate = hibernateTemplate;
}
/** 插入 */
public void insert(Emp emp) {
hibernateTemplate.save(emp);
}
/** 更新 */
public void update(Emp emp) {
hibernateTemplate.update(emp);
}
/** 删除 */
public void delete(Emp emp) {
hibernateTemplate.delete(emp);
}
/** 根据id删除 */
public void delete(int id) {
Emp emp = (Emp) hibernateTemplate.get(Emp.class, id);
hibernateTemplate.delete(emp);
}
/** 根据id查询雇员的详细信息 */
public Emp findById(int id) {
return (Emp) hibernateTemplate.get(Emp.class, id);
}
/** 查询全部雇员信息 */
public List<Emp> findAll() {
return hibernateTemplate.find("from Emp");
}
/** 根据雇员姓名查询其薪水 */
public double findSalary(String name) {
List<Double> list = hibernateTemplate.find("select e.salary from Emp e where e.name=?", name);
return list.size() > 0 ? list.get(0) : 0;
}
/** 查询部总记录数 */
public int totalCount() {
List<Long> list = hibernateTemplate.find("select count(*) from Emp");
return list.size() > 0 ? Integer.parseInt(list.get(0)+"") : 0;
}
/** 批量插入 */
public void insertBatch(List<Emp> emps) {
for (int i = 0; emps != null && i < emps.size(); i++) {
hibernateTemplate.save(emps.get(i));
if (i % 20 == 0) {
hibernateTemplate.flush();
hibernateTemplate.clear();
}
}
}
/** 批量删除 */
public void deleteBatch(int... ids) {
/** 方法一 */
for (int i = 0; ids != null && i < ids.length; i++) {
Emp emp = (Emp) hibernateTemplate.get(Emp.class, ids[i]);
hibernateTemplate.delete(emp);
if (i % 20 == 0) {
hibernateTemplate.flush();
hibernateTemplate.clear();
}
}
}
}
这里注入的不在是SessionFactory而是HibernateTemplate，这是Spring为辅助Hibernate开发提供的模版类。
而事务不用注解了（之前写过了），用XML配置注解
此时Spring的配置文件编写如下：
<?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: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.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd"> <!-- 配置数据库连接信息 --> <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource"> <property name="driverClassName" value="com.mysql.jdbc.Driver"/> <property name="url" value="jdbc:mysql://localhost:3306/spring"/> <property name="username" value="root"/> <property name="password" value="root"/> </bean> <!-- 配置sessionFactory --> <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <property name="dataSource" ref="dataSource"/> <property name="hibernateProperties"> <props> <prop key="hibernate.dialect">org.hibernate.dialect.MySQLInnoDBDialect</prop> <prop key="hibernate.show_sql">true</prop> <prop key="hibernate.hbm2ddl.auto">update</prop> </props> </property> <!-- 个人觉得这么配置方便，不用将所有的映射文件都列出来，因为有时会忘记配置映射文件 --> <property name="mappingLocations" value="org/monday/hibernate2/*.hbm.xml"/> <!-- 或者 <property name="mappingResources"> <list> <value>org/monday/hibernate2/Emp.hbm.xml</value> </list> </property> --> </bean> <!-- 配置DAO --> <bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate"> <property name="sessionFactory" ref="sessionFactory"/> </bean> <bean id="empDao" class="org.monday.hibernate2.EmpDaoImpl"> <property name="hibernateTemplate" ref="hibernateTemplate"/> </bean> <!-- 配置事务 --> <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager"> <property name="sessionFactory" ref="sessionFactory"/> </bean> <tx:advice id="tx" transaction-manager="transactionManager"> <tx:attributes> <tx:method name="*"/> <tx:method name="find*" read-only="true"/> </tx:attributes> </tx:advice> <aop:config> <aop:pointcut id="perform" expression="execution( * org.monday.hibernate2.*.*(..))" /> <aop:advisor advice-ref="tx" pointcut-ref="perform"/> </aop:config> </beans>
方式三：
直接看Dao实现类吧。
package org.monday.hibernate3;
import java.util.List;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
public class EmpDaoImpl extends HibernateDaoSupport implements EmpDao {
/** 插入 */
public void insert(Emp emp) {
getHibernateTemplate().save(emp);
}
/** 更新 */
public void update(Emp emp) {
getHibernateTemplate().update(emp);
}
/** 删除 */
public void delete(Emp emp) {
getHibernateTemplate().delete(emp);
}
/** 根据id删除 */
public void delete(int id) {
Emp emp = (Emp) getHibernateTemplate().get(Emp.class, id);
getHibernateTemplate().delete(emp);
}
/** 根据id查询雇员的详细信息 */
public Emp findById(int id) {
return (Emp) getHibernateTemplate().get(Emp.class, id);
}
/** 查询全部雇员信息 */
public List<Emp> findAll() {
return getHibernateTemplate().find("from Emp");
}
/** 根据雇员姓名查询其薪水 */
public double findSalary(String name) {
List<Double> list = getHibernateTemplate().find("select e.salary from Emp e where e.name=?", name);
return list.size() > 0 ? list.get(0) : 0;
}
/** 查询部总记录数 */
public int totalCount() {
List<Long> list = getHibernateTemplate().find("select count(*) from Emp");
return list.size() > 0 ? Integer.parseInt(list.get(0)+"") : 0;
}
/** 批量插入 */
public void insertBatch(List<Emp> emps) {
for (int i = 0; emps != null && i < emps.size(); i++) {
getHibernateTemplate().save(emps.get(i));
if (i % 20 == 0) {
getHibernateTemplate().flush();
getHibernateTemplate().clear();
}
}
}
/** 批量删除 */
public void deleteBatch(int... ids) {
/** 方法一 */
for (int i = 0; ids != null && i < ids.length; i++) {
Emp emp = (Emp) getHibernateTemplate().get(Emp.class, ids[i]);
getHibernateTemplate().delete(emp);
if (i % 20 == 0) {
getHibernateTemplate().flush();
getHibernateTemplate().clear();
}
}
}
}
继承了HibernateDaoSupport，这也是Spring提供的一个辅助类
而Spring的配置文件变动如下：
<!-- 配置DAO --> <!-- <bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate"> <property name="sessionFactory" ref="sessionFactory"/> </bean> <bean id="empDao" class="org.monday.hibernate2.EmpDaoImpl"> <property name="hibernateTemplate" ref="hibernateTemplate"/> </bean> --> <bean id="empDao" class="org.monday.hibernate3.EmpDaoImpl"> <property name="sessionFactory" ref="sessionFactory"/> </bean>
三种方式，我个人喜欢第一种。
因为不用依赖Spring的API，不过反过来一想，既然开发都依赖Spring框架了，那这点依赖又算什么。
哈，确实不算什么，只是觉得使用Hibernate的原生API比Spring的好用。（一家之言，欢迎拍转，呵呵~）
而关于配置文件，我认为还是不要写在一起的好，Hibernate的配置就用hibernate.cfg.xml，而Spring就用beans.xml将组件组装起来。类似于Struts2的“分离关注”思想吧。（谁该做的，就让谁做，不要大杂烩。）
最好JDBC的数据库连接配置也单独写在一个配置文件中。
关于实体类的映射文件建议还是配置在beans.xml中吧。不用每次开发完实体类都要在hibernate.cfg.xml中配置，有时太忙了就忘记了。（自己犯过这样的错误...
）
在Sping中写成类似
<property name="mappingLocations" value="org/monday/hibernate3/*.hbm.xml"/>
通配符的形式，就不怕忘记啦。
相关推荐
在实际开发中，开发者可以结合 Spring 框架，利用 Spring 的 Transaction Management 和 DAO 支持，进一步简化 Hibernate 的使用。 总结起来，Hibernate 3.6 作为一款成熟的 ORM 框架，通过对象化的数据库操作方式...
这个实例是基于Spring 2.5、Struts2.3和Hibernate 3.6进行集成，用于实现一个基本的用户登录功能，下面将详细介绍这三个框架的核心功能以及它们如何协同工作。 **Spring 2.5** 是一个全面的Java应用框架，提供依赖...
标题中的"EXt2.1+sturts2.0+spring2.5+hibernate"是一个典型的Java Web开发技术栈，它包含了四个关键组件：EXT JS 2.1、Struts 2.0、Spring 2.5和Hibernate。这些技术在2000年代末至2010年代初是非常流行的，它们...
### Java SSH框架整合搭建Web系统（Struts1.2+Spring2.5+Hibernate3.2） #### 一、准备工作 在开始构建基于Struts1.2+Spring2.5+Hibernate3.2的Web应用之前，需要进行一系列的基础设置工作。 **1.1 创建工程** ...
这个集成项目是基于特定版本的这些技术，包括jbpm4.4（业务流程管理），spring2.5.6（依赖注入和事务管理），hibernate 3.6（对象关系映射），以及struts2.2.1（MVC框架）。下面将详细介绍这些组件以及它们如何协同...
Struts2、Spring3和Hibernate3.6是Java开发中非常经典的三大框架组合，它们各自在Web应用开发中承担着不同的职责，共同构建了一个高效、灵活的企业级应用开发环境。 Struts2作为MVC（Model-View-Controller）架构的...
本篇将详细讲解如何将Spring 3.0.5与JPA 2.0（基于Hibernate 3.6）进行集成，以构建高效、灵活的应用程序。 首先，让我们了解Spring 3.0.5的核心特性。Spring 3.0引入了若干改进和新特性，包括对JSR-303（Bean ...
这个"Spring3.2+Structs2.16+Hibernate3.6整合"的主题意味着我们将探讨如何将这三个组件集成到一个项目中，以实现模型-视图-控制器（MVC）架构的完美融合。 首先，Struts2是Apache软件基金会的一个开源项目，它基于...
下面将详细介绍如何整合Struts2.2.1、Hibernate3.6和Spring3.0.5。 首先，确保准备好所有必要的库文件，包括： 1. Struts2的struts2-2.2.1-all.zip 2. Hibernate的hibernate-distribution-3.6.0.Final-dist.zip 3. ...
整合Spring3.2和Hibernate3.6的关键在于如何将Hibernate的SessionFactory和TransactionManager集成到Spring的IoC容器中。这通常通过以下步骤实现： 1. 引入相关库：在项目中添加Spring和Hibernate的jar包，包括...
在整合Struts2.2与Hibernate3.6时，Spring3.1作为粘合剂，帮助管理这两个框架之间的交互。以下是一些关键的知识点： 1. **Struts2**：Struts2是一个基于MVC设计模式的Web框架，它提供了强大的动作调度、结果映射和...
整合Spring4和Hibernate3.6能够提供一个强大、灵活且易于维护的Java企业级应用开发基础，通过它们的协同工作，开发者可以更高效地构建数据驱动的应用程序。在实际项目中，你需要根据具体需求来调整配置，优化性能，...
完整的SSH集成，STRUTS2.0+SPRING 2.5+ HIBERNATE 3.6完美集成
标题中的"spring3,struts2,hibernate3.6"指的是三个著名的Java Web开发框架：Spring、Struts2和Hibernate。这些框架在Java企业级应用程序中被广泛使用，它们各自处理不同的职责，以实现高效的MVC（Model-View-...
标题中的"spring3.0API.chm、hibernate3.6API、struts2API"涉及的是三个关键的Java企业级开发框架：Spring、Hibernate和Struts2，它们是SSH（Spring、Struts、Hibernate）框架组合的一部分，广泛应用于构建复杂的Web...
Struts2、Spring3.02、Spring Security3和Hibernate3.6是Java Web开发中的四大框架，它们各自承担着不同的职责，共同构建了一个高效、稳定的后端架构。以下将详细解析这四个组件及其整合应用。 **Struts2** 是一个...
Struts2.2、Hibernate3.6和Spring3.0是Java Web开发中非常重要的三个框架，它们分别在MVC模式、持久层管理和依赖注入方面发挥着关键作用。本整合教程将详细介绍如何将这三个框架有效地集成在一起，以构建高效、灵活...
Struts2.3.16.1+Hibernate3.6.10+Spring3.2.8整合 能够运行，没有任何问题 另外附带applicationContext.xml、struts.xml、hibernate.cfg.xml
在这个项目中，使用的是Struts2.2.3、Hibernate3.6和Spring3.0.5的版本，这是一套相对稳定的配置，已经在实际项目中得到了验证，不存在兼容性问题，对于初学者来说是学习和实践的良好平台。 **Struts2** 是一个基于...