Spring集成ORM框架之Hibernate的使用

最新推荐文章于 2024-07-20 09:30:00 发布
最新推荐文章于 2024-07-20 09:30:00 发布
阅读量1.3k 收藏
点赞数
分类专栏： Spring学习笔记 文章标签： Spring之ORM
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/polo_longsan/article/details/46446809
版权

最近在学习Spring整合ORM框架。在使用Hibernate的时候遇到很多问题，花费了几天时间总算解决了。Hibernate的主要接口是org.hibernate.session，session提供了基本的数据操作功能如更新、插入、删除、加载数据对象的功能。session要通过SessionFactory来打开，关闭及管理。下面来看代码：

1、和之前一样首先通过新建一个maven项目SpringBean_01，它的pom.xml配置如下：

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.csii.spring</groupId>
  <artifactId>SpringBean_01</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>SpringBean_01</name>
  <url>http://maven.apache.org</url>

 <properties>
     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
     <springframework.version>3.2.3.RELEASE</springframework.version>  
  </properties>
  
 <repositories>  
    <repository>  
      <snapshots>  
        <enabled>false</enabled>  
      </snapshots>  
      <id>central</id>  
      <name>Maven Repository Switchboard</name>  
      <url>http://repo2.maven.org/maven2</url>  
    </repository>  
  </repositories>  

 <dependencies>  
  
     	<dependency>
		    <groupId>junit</groupId>
		    <artifactId>junit</artifactId>
		    <version>4.0</version>
		</dependency>
		 
        <dependency>  
            <groupId>org.springframework</groupId>  
            <artifactId>spring-context</artifactId>  
            <version>${springframework.version}</version>  
        </dependency>  
  
        <dependency>  
            <groupId>org.springframework</groupId>  
            <artifactId>spring-context-support</artifactId>  
            <version>${springframework.version}</version>  
        </dependency>  
  
        <dependency>  
            <groupId>org.springframework</groupId>  
            <artifactId>spring-tx</artifactId>  
            <version>${springframework.version}</version>  
        </dependency>  
  
        <dependency>  
            <groupId>org.springframework</groupId>  
            <artifactId>spring-web</artifactId>  
            <version>${springframework.version}</version>  
        </dependency>
        
          <dependency>  
            <groupId>org.springframework</groupId>  
            <artifactId>spring-aspects</artifactId>  
            <version>${springframework.version}</version>  
        </dependency>
        
         <dependency>  
            <groupId>org.springframework</groupId>  
            <artifactId>spring-aspects</artifactId>  
            <version>${springframework.version}</version>  
        </dependency>
        
          <dependency>  
            <groupId>org.springframework</groupId>  
            <artifactId>spring-orm</artifactId>  
            <version>${springframework.version}</version>  
        </dependency>
        
           <dependency>  
            <groupId>org.springframework</groupId>  
            <artifactId>spring-jdbc</artifactId>  
            <version>${springframework.version}</version>  
        </dependency>
        
          <dependency>  
            <groupId>org.aspectjweaver</groupId>  
            <artifactId>aspectjweaver</artifactId>  
            <version>1.7.2</version>  
        </dependency>
        
     	 <dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-log4j12</artifactId>
			<version>1.7.0</version>
		</dependency>
		
     	 <dependency>
			<groupId>commons-collections</groupId>
			<artifactId>commons-collections</artifactId>
			<version>3.1</version>
		</dependency>
  
        <dependency>  
            <groupId>org.quartz-scheduler</groupId>  
            <artifactId>quartz</artifactId>  
            <version>1.8.5</version>  
        </dependency>
        
        <dependency>
		    <groupId>commons-pool</groupId>
		    <artifactId>commons-pool</artifactId>
		    <version>1.5.4</version>
		</dependency>
		
        <dependency>
			<groupId>commons-dbcp</groupId>
			<artifactId>commons-dbcp</artifactId>
			<version>1.2.2</version>
		</dependency>
		
       <dependency>
		    <groupId>com.mysql</groupId>
		    <artifactId>mysql-connector-java</artifactId>
		    <version>5.1.20</version>
		</dependency>
		
       <dependency>
		<groupId>org.hibernate</groupId>
		<artifactId>hibernate-core</artifactId>
		<version>3.6.10.Final</version>
	</dependency>
	
     <dependency>
		<groupId>org.javassist</groupId>
		<artifactId>javassist</artifactId>
		<version>3.18.2-GA</version>
	</dependency>
       
		
    </dependencies>  
    <build>  
        <finalName>${project.artifactId}</finalName>  
        <plugins>  
            <plugin>  
                <groupId>org.mortbay.jetty</groupId>  
                <artifactId>jetty-maven-plugin</artifactId>  
                <version>7.5.4.v20111024</version>  
                <configuration>  
                    <scanIntervalSeconds>10</scanIntervalSeconds>  
                    <webApp>  
                        <contextPath>/${project.artifactId}</contextPath>  
                    </webApp>  
                </configuration>  
            </plugin>  
        </plugins>  
    </build>  
  <!--   <properties>  
        <springframework.version>3.2.3.RELEASE</springframework.version>  
    </properties>   -->
</project>
2、新建应用上下文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: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/tx 
            http://www.springframework.org/schema/tx/spring-tx-3.2.xsd 
    	  	http://www.springframework.org/schema/aop 
           http://www.springframework.org/schema/aop/spring-aop-3.2.xsd">
    
    <import resource="datasource.xml"/>
    
    <import resource="hibernate/hibernate.xml"/>
    
</beans>
其中datasource.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:aop="http://www.springframework.org/schema/aop"
    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-3.2.xsd">
           
	<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
	    <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
	    <property name="url" value="jdbc:mysql://127.0.0.1:3306/dbtest?useUnicode=true&characterEncoding=utf8"></property>
	     <property name="username" value="root"></property>
	     <property name="password" value="root"></property>
	     <!--  maxActive: 最大连接数量    --> 
        <property name="maxActive" value="20"/>  
      <!-- minIdle: 最小空闲连接   -->  
        <property name="minIdle" value="0"/>  
       <!-- maxIdle: 最大空闲连接  -->   
        <property name="maxIdle" value="2"/>  
       <!-- initialSize: 初始化连接    --> 
        <property name="initialSize" value="10"/>  
    	<!-- 连接被泄露时是否打印  --> 
	</bean>

</beans>
hibernate.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: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-3.2.xsd 
    		 http://www.springframework.org/schema/aop 
           	http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
    		 http://www.springframework.org/schema/tx 
            http://www.springframework.org/schema/tx/spring-tx-3.2.xsd 
           	http://www.springframework.org/schema/context 
           	http://www.springframework.org/schema/context/spring-context-3.2.xsd">
           
    
           
	<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
	    <property name="dataSource" ref="dataSource"></property>
	    <property name="mappingResources">
	        <list>
	            <value>hibernate/user.hbm.xml</value>
	        </list>
	    </property>
	    <property name="hibernateProperties">
	        <props>
	            <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
	           <!--  <prop key="hibernate.current_session_context_class">org.springframework.orm.hibernate3.SpringSessionContext</prop> -->
	        </props>
	    </property>
	    
	</bean>
	
	<bean id="hUserDao" class="com.csii.dao.impl.HUserDAOImpl">
	    <property name="sessionFactory" ref="sessionFactory"></property>
	</bean>
	
	<!-- 配置事务容器 -->
	 <bean id="transactionManager"
		  class="org.springframework.orm.hibernate3.HibernateTransactionManager">
		  <property name="sessionFactory" ref="sessionFactory" />
	 </bean>
	 <!-- 定义事务规则 -->
	 <tx:advice id="txAdvice" transaction-manager="transactionManager">
		  <tx:attributes>
			   <tx:method name="add*" propagation="REQUIRED" />
			   <tx:method name="modify*" propagation="REQUIRED" />
			   <tx:method name="del*" propagation="REQUIRED" />
			   <tx:method name="*" propagation="REQUIRED" read-only="true" />
		  </tx:attributes>
	 </tx:advice>
	 
	 <!-- 定义事务入口 -->
	 <aop:config>
		  <aop:pointcut id="allDaoMethod" expression="execution(* com.csii.dao.*.*(..))" />
		  <aop:advisor advice-ref="txAdvice" pointcut-ref="allDaoMethod" />
	 </aop:config>
	

</beans>
user.hbm.xml的配置如下： 

<?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>
      
	<class name="com.csii.entity.User" table="user">  
	    <id name="id" column="id">  
	        <generator class="increment"/>  
	    </id>  
	    <property name="username" column="username" />
	    <property name="password" column="password" />   
	</class> 
	 
</hibernate-mapping>
2、然后我们新建dao类HUserDAO，HUserDAoImpl（备注：因为之前UserDAO，UserDAOImpl已经使用了，为了区分，虽然这不是一个很好地命名方式）。 

package com.csii.dao;

import com.csii.entity.User;

public interface HUserDAO {
	
	void addUser(User user);

}


package com.csii.dao.impl;


import org.hibernate.Session;
import org.hibernate.SessionFactory;

import com.csii.dao.HUserDAO;
import com.csii.entity.User;

public class HUserDAOImpl implements HUserDAO{
	
	private SessionFactory sessionFactory;

	public void addUser(User user) {
		
		getInstanceSession().save(user);
		
	}
	
	public Session getInstanceSession(){
		
		return sessionFactory.getCurrentSession();
	}

	public SessionFactory getSessionFactory() {
		return sessionFactory;
	}

	public void setSessionFactory(SessionFactory sessionFactory) {
		this.sessionFactory = sessionFactory;
	}
	
	

}
3、新建实体类User 

package com.csii.entity;

public class User {
	
	private int id;
	
	private String username;
	
	private String password;

	public int getId() {
		return id;
	}

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

	public String getUsername() {
		return username;
	}

	public void setUsername(String username) {
		this.username = username;
	}

	public String getPassword() {
		return password;
	}

	public void setPassword(String password) {
		this.password = password;
	}
	
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return "user{id="+getId()+",username="+getUsername()+",password="+getPassword()+"}";
	}
	
	

}
4、然后写一个测试类Test.java就可以测试了 

package com.csii.spring;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.csii.aop.SoccerGame;
import com.csii.aopwithparam.MindReader;
import com.csii.aopwithparam.Thinker;
import com.csii.aopwithparam.Volunteer;
import com.csii.dao.HUserDAO;
import com.csii.dao.UserDAO;
import com.csii.entity.User;

public class Test {
	
	public static void main(String[] args) throws Exception {
		ApplicationContext ctx=
	      		   new ClassPathXmlApplicationContext("applicationContext.xml");
		User user=new User();
		user.setUsername("李四");
		user.setPassword("123456");
		userDao.addUser(user);*/
		
		HUserDAO hUserDao=(HUserDAO)ctx.getBean("hUserDao");
		User user=new User();
		user.setUsername("后街男孩");
		user.setPassword("123456");
		hUserDao.addUser(user);
	    
	    
	}

}
在数据库中新建一个数据库和表，运行之后可看到数据库新增了一条记录。具体新建过程同上一篇博客。






polo_longsan
关注
专栏目录
Spring的ORM模块(结合Hibernate)
KevinLee的博客
04-16 2980
概述Spring的ORM模块对Hibernate、iBatis、JDO等ORM框架提供支持。 ORM模块依赖于dom4j-1.6.jar和antlr.jar，需要自己添加两个类库。 本篇文章以结合Hibernate为例。在Spring中Hibernate只是一个Bean 在Spring中，Hibernate的资源要交给Spring来管理。Hibernate和SessionFactory等只是
hibernate_集成spring
子龙修仙的博客
06-30 202
有三种方式在项目中使用hibernate，在这里使用注解的方式：Spring集成hibernate后不再需要Hibernate.cfg.xml配置文件了。1. 导包引入hibernate的包： 以及： 2. 配置 在spring的配置文件中配置数据源，及sessionFactory。&lt;!-- 数据源 --&gt;&lt;bean id="dataSource" class="org.spri...
Spring ORM+Hibernate？Out！换 Spring Data JPA 吧！
热门推荐
anxpp的博客
05-15 4万+
Spring Data JPA 的目标是通过让一些必须的工作变得更简单，来极大的提高数据访问层的实现效率。通常我们只需要姐访问方法，而 Spring 给你提供自动实现。！ 在一切开始之前，先举个简单的例子，以提高大家的兴致！ 如果一张表user有三个字段，id、name和age，要查找指定姓氏在某年龄以上的user，在传统的Spring+Hibernate中，dao层我们是这样写的...
一文解释Spring中对象关系映射（ORM）
最新发布
java永无止境！
07-20 448
Spring中的ORM主要是通过Spring Data Access/Integration层提供的支持实现的，这个层次为不同的ORM技术提供了一系列的整合与支持。ORM使得开发人员可以以面向对象的方式来处理数据库交互，而不必担心底层的SQL细节，从而提高了开发效率并减少了代码复杂性。通过如JPA这样的ORM规范，以及Spring Data JPA这样的库，Spring进一步简化了数据访问，并允许无缝地进行扩展和交换底层数据存储。
Spring ORM模块(Hibernate)
芸灵fly的博客
02-12 691
ORM模块对hibernate，JDO，TopLink，iBatis等ORM框架提供支持。在Spring里，hibernate的资源要交给Spring来管理。hibernate及其SessionFactory等只是Spring一个特殊的Bean，由Spring负责实例化与销毁。因此，DAO层只需要继承hibernateDaoSupport，而不需要与hibernate的API打交道，不需要开启、关...
Spring 使用ORM系列-集成Hibernate
qq_38693803的博客
06-18 243
声明Hibernate的Session工厂Bean setDatabaSource设置数据源 setMappingResources设置Hibernate映射文件(.hbm.xml) setPackagesToScan设置自动扫描的位置 setHibernateProperties设置属性-方言(dialet) 实体类加@Entity 借助Hibernate Session实现不依赖于Spri...
Spring ORM数据访问——Hibernate
EthanPark的博客
05-16 5917
Hibernate我们将首先介绍Spring环境中的Hibernate 5，然后介绍使用Hibernate 5来演示Spring集成O-R映射器的方法。本节将详细介绍许多问题，并显示DAO实现和事务划分的不同变体。这些模式中大多数可以直接转换为所有其他支持的ORM工具。本章中的以下部分将通过简单的例子来介绍其他ORM技术。 从Spring 5.0开始，Spring需要Hibernate ORM
Spring整合其他ORM框架
11-08
Spring 提供了对多种 ORM 框架的集成支持，如 Hibernate、MyBatis、JPA 等，使得开发者可以充分利用 Spring 的优势进行数据操作。 1. **Spring 整合 Hibernate**：Hibernate 是一款流行的 ORM 框架，它允许开发者用...
编程语言+JAVAspring+ORM框架+数据持久化
03-04
它介绍了JAVAspring的ORM框架的概念、原理和作用，以及如何使用JAVAspring的ORM框架来实现数据持久化，包括JDBC、Hibernate、MyBatis等常用的ORM框架的集成和使用，以及一些配置文件和注解的用法。
Spring与Hibernate集成
03-26
而Hibernate则是一个优秀的对象关系映射（ORM）框架，能够方便地将数据库操作与业务逻辑解耦。当这两个框架结合使用时，可以构建出高效、灵活且易于维护的Java应用。 首先，我们需要理解Spring如何管理和控制...
Spring之Spring2.5集成Hibernate3.6
03-29
3. **数据访问抽象**：Spring的Data Access/Integration模块提供了一种抽象层，可以透明地切换不同的ORM框架，如Hibernate、MyBatis等，增强了系统的可扩展性。 4. **懒加载和缓存**：Spring结合Hibernate的二级...
spring学习：hibernate orm集成
点缀星辰
04-17 211
简介     使用spring访问数据的框架就少不了使用到hibernate。 最近尝试手动去构建一些这样的示例时碰到了不少问题。本文结合hibernate 3, hibernate 4两个版本实现一个示例的过程，顺便也对它们的配置与使用做一个总结。   示例     我们从一个简单的对一个实体类进行增删查改的操作来看怎么使用hibernate。因为针对不同版本的hibernate，后...
Spring与Hibernate结合使用
chenfengdejuanlian的专栏
08-04 674
1、使用Spring的IOC容器，将对象之间的依赖关系交给Spring，可以降低组件之间的耦合性，可以更专注于应用逻辑。同时可以提供众多服务，数据库事务管理，WS等。 2、Hibernate是对JDBC的轻量级的对象封装，是一个独立的对象持久化对象。 1）对象/关系数据库映射(ORM) 它使用时只需要操纵对象，使开发更对象化，抛弃了数据库中心的思想，完全的面向对象思想。 2） 事务Tran
Spring Hibernate集成示例教程
YunWisdom
03-17 224
Spring Hibernate集成示例教程（Spring 4 + Hibernate 3和Hibernate 4） Spring是最常用的Java EE Framework之一，而Hibernate是最流行的ORM框架。这就是Spring Hibernate组合在企业应用程序中大量使用的原因。最近我为Spring Tutorial和Hibernate Tutorial撰写了很多文章...
Spring ORM与Hibernate的集成开发详解
成长的足迹
04-19 573
在Java应用中，存在多种数据访问API，如JDBC、JPA、JDO和Hibernate等。为了便于使用这些数据访问API进行应用开发，Spring框架提供了Spring DAO，其带来的优势如下：统一的应用接口统一的异常层次结构DataAccessException统一的资源标注@Repository统一的事务管理@Transactional下面以Hibernate为例，介绍Spring DAO...
Spring对ORM的支持之集成Hibernate3
chuji3953的博客
05-17 109
1 集成Hibernate3 Hibernate是全自动的ORM框架，能自动为对象生成相应SQL并透明的持久化对象到数据库。 Spring2.5+版本支持Hibernate 3.1+版本，不支持低版本，Spring3.0.5版本提供对Hibernate 3.6.0 Fina...
hibernate3.2在spring中的配置
gbtyy的专栏
03-22 455
 SessionFactory -->    bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">        property name="dataSource" ref="dataSource"/>        property
spring逐步整合orm实例--第四例：整合hibernate。
automannn
10-16 336
     之前的三个例子，分别使用spring整合或者使用别人整合的产品进行了演示。  这篇继续，整合，或者说使用整合的hibernate来进行数据库操作。    与spring-jdbc类似，hibernate作为一个出名的orm映射框架，spring官方早将它列为了其它逻辑产品之一的spring-orm中。  因此我们直接使用spring-orm就行了，但是要自己整合估计也是可以的，只不过...
Hibernate+Spring-orm的基本方法总结
weixin_34357436的博客
12-23 90
Hibernate的本质是对纯java JDBC的封装，Spring-orm是对Hibernate的封装。Hibernate是面向对象OO和关系型数据库RMDB的中介，通过Hibernate，java程序员看到的都是面向对象的，java的对象，而不是数据表和字段。Hibernate基本接口： Configuration接口 -- 配置hibernateS...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值