dao配置

最新推荐文章于 2022-07-07 11:49:24 发布
最新推荐文章于 2022-07-07 11:49:24 发布
阅读量1.5k 收藏
点赞数
分类专栏： spring 文章标签： dao hibernate spring jdbc class java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ldongwei/article/details/5421037
版权

 事务的处理一般来说有两种方式:

  一个是依赖特定的资源的事务：如通过JDBC，JTA,Hibernate Transaction。

  还有一个就是依赖窗口的参数进行事务管理,像EJB容器事务

 

spring对于以上两种都有相应的实现，还提供了一些辅助类可供我们选择使用，如基于JDBC,JDO,HIBERNATE的扩展类.而对于依赖 容器的参数化事务管理来说，spring体现出一它的优势，它本身也是一个容器，但相对EJB容器它来它显得很轻巧（当然在后来插件越来越多的情况下，我 们需要摈弃一些我们不用的模块）。我们不用付出其他的代价，就可以通过spring实现容器的事务管理。

下面就来说说基于JDBC，HIBERNATE这两种方式的事务管理与非事务管理的配置：

 

 

取得source连接

首先对于一个DB操作，我们必须要取得DB连接，而在spring下取得这个连接的方式可以采用

1.JNDI

2.配置dataSource(spring方式)或者sessionFactory（hibernate)

且看下面代码:

对于JNDI可以参考如下实现:

Java代码
  1. <bean id= "dataSource"   class = "org.springframework.jndi.JndiObjectFactoryBean" >  
  2.         <property name="jndiName" >  
  3.         <value>jdbc_sdcf</value>  
  4.         </property>  
  5.         </bean>    
  6.         </beans>   
<bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean">
		<property name="jndiName">
		<value>jdbc_sdcf</value>
		</property>
		</bean>  
		</beans>

 

对于dataSource方式如下：

Java代码
  1. <bean id= "dataSource"   
  2.     class = "org.springframework.jdbc.datasource.DriverManagerDataSource" >  
  3.     <property name="driverClassName" >  
  4.         <value>oracle.jdbc.driver.OracleDriver</value>  
  5.     </property>  
  6.     <property name="url" >  
  7.         <value>jdbc:oracle:thin:@127 .0. 0.1 : 1521 :oracle</value>  
  8.     </property>  
  9.     <property name="username" >  
  10.         <value>test</value>  
  11.     </property>  
  12.     <property name="password" >  
  13.         <value>test</value>  
  14.     </property>  
  15.     <property name="connectionProperties" >  
  16.         <props />  
  17.     </property>  
  18. </bean>   
	<bean id="dataSource"
		class="org.springframework.jdbc.datasource.DriverManagerDataSource">
		<property name="driverClassName">
			<value>oracle.jdbc.driver.OracleDriver</value>
		</property>
		<property name="url">
			<value>jdbc:oracle:thin:@127.0.0.1:1521:oracle</value>
		</property>
		<property name="username">
			<value>test</value>
		</property>
		<property name="password">
			<value>test</value>
		</property>
		<property name="connectionProperties">
			<props />
		</property>
	</bean>

 

而对于sessionFactory的方式来说， 我们可以有两种方式来配置它：

一个是基于在spring的dataSource方式上进行配置:

Java代码
  1. <bean id= "sessionFactory"   class  = "org.springframework.orm.hibernate3.LocalSessionFactoryBean" >  
  2.         <property name="dataSource" >  
  3.             <ref local="dataSource" />  
  4.         </property>  
  5.         <property name="mappingResources" >  
  6.             <list>  
  7.                 <value>com/lgh/hibernate/UserTable.hbm.xml</value>  
  8.             </list>  
  9.         </property>  
  10.         <property name="hibernateProperties" >  
  11.             <props>  
  12.                 <prop key="hibernate.dialect" >org.hibernate.dialect.OracleDialect</prop>   
  13.                 <prop key="hibernate.show_sql" > true </prop>  
  14.             </props>  
  15.         </property>  
  16.     </bean>    
<bean id="sessionFactory" class ="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
	 	<property name="dataSource">
	 		<ref local="dataSource"/>
	 	</property>
	 	<property name="mappingResources">
	 		<list>
	 			<value>com/lgh/hibernate/UserTable.hbm.xml</value>
	 		</list>
	 	</property>
	 	<property name="hibernateProperties">
	 		<props>
	 		    <prop key="hibernate.dialect">org.hibernate.dialect.OracleDialect</prop> 
	 			<prop key="hibernate.show_sql">true</prop>
	 		</props>
	 	</property>
	</bean>

 

而另一个方式就是在hibernate.hbm.xml方式上进行配置：

Java代码
  1. <bean id= "sessionFactory"   class = "org.springframework.orm.hibernate3.LocalSessionFactoryBean" >    
  2.         <property name="configLocation"  value= "classpath:hibernate.cfg.xml"  />    
  3.         <property name="configurationClass"  value= "org.hibernate.cfg.AnnotationConfiguration"  />  
  4.     </bean>    
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">  
        <property name="configLocation" value="classpath:hibernate.cfg.xml" />  
        <property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration" />
    </bean>

 

这个hibernate.cfg.xml方式可以利用myeclipseIDE导入hibernate功能时自动创建，如下例子：

Java代码
  1. <?xml version= '1.0'  encoding= 'UTF-8' ?>  
  2. <!DOCTYPE hibernate-configuration PUBLIC  
  3.           "-//Hibernate/Hibernate Configuration DTD 3.0//EN"   
  4.           "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd" >  
  5.   
  6. <!-- Generated by MyEclipse Hibernate Tools.                   -->  
  7. <hibernate-configuration>  
  8.   
  9.     <session-factory>  
  10.         <property name="dialect" >  
  11.             org.hibernate.dialect.OracleDialect  
  12.         </property>  
  13.         <property name="connection.url" >  
  14.             jdbc:oracle:thin:@localhost : 1521 :oracle  
  15.         </property>  
  16.         <property name="connection.username" >test</property>  
  17.         <property name="connection.password" >test</property>  
  18.         <property name="connection.driver_class" >  
  19.             oracle.jdbc.driver.OracleDriver  
  20.         </property>  
  21.         <property name="myeclipse.connection.profile" >  
  22.             local_oracle  
  23.         </property>  
  24.         <!-- 事务管理类型，这里我们使用JDBC Transaction  
  25.   
  26.         <property name="hibernate.transaction.factory_class" >net.sf.hibernate.transaction.JDBCTransactionFactory  
  27.         </property> -->  
  28.         <mapping resource="com/lgh/hibernate/UserTable.hbm.xml"  />  
  29.   
  30.     </session-factory>  
  31.   
  32. </hibernate-configuration>   
<?xml version='1.0' encoding='UTF-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
          "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
          "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<!-- Generated by MyEclipse Hibernate Tools.                   -->
<hibernate-configuration>

	<session-factory>
		<property name="dialect">
			org.hibernate.dialect.OracleDialect
		</property>
		<property name="connection.url">
			jdbc:oracle:thin:@localhost:1521:oracle
		</property>
		<property name="connection.username">test</property>
		<property name="connection.password">test</property>
		<property name="connection.driver_class">
			oracle.jdbc.driver.OracleDriver
		</property>
		<property name="myeclipse.connection.profile">
			local_oracle
		</property>
		<!-- 事务管理类型，这里我们使用JDBC Transaction

		<property name="hibernate.transaction.factory_class">net.sf.hibernate.transaction.JDBCTransactionFactory
		</property> -->
		<mapping resource="com/lgh/hibernate/UserTable.hbm.xml" />

	</session-factory>

</hibernate-configuration>

 

 

 

事务管理（transactionManager)的两种初始化方式：

一种是根据dataSource来初始化我们的事务管理器，另一种则是根据sessionFactory(hibernate方式）来初始化我们的事务管理器:

 

Java代码
  1. <!-- 事务方式方式一-->   
  2.     <bean id="transactionManager"   class = "org.springframework.jdbc.datasource.DataSourceTransactionManager" >  
  3.         <property name="dataSource" >  
  4.             <ref local = "dataSource" />  
  5.         </property>  
  6.     </bean>   
  7.     <!-- 事务配置方式二 -->  
  8.     <bean id="transactionManager"   
  9.         class = "org.springframework.orm.hibernate3.HibernateTransactionManager" >  
  10.         <property name="sessionFactory"  ref= "sessionFactory"  />  
  11.     </bean>    
<!-- 事务方式方式一--> 
	<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource">
			<ref local = "dataSource"/>
		</property>
	</bean> 
	<!-- 事务配置方式二 -->
	<bean id="transactionManager"
        class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>

 

 

 

 

 

JDBC在spring下的事务与非事务方式

 

1.非事务处理方式

     jdbc在spring下的非事务方式很简单，它其实就是于JDBC的简单封装:

 

Java代码
  1. public   interface  JdbcDao {  
  2.  public   void  insert(String[] sql);  
  3. }  
  4.   
  5. public   class  JdbcDaoImpl  extends  JdbcDaoSupport  implements  JdbcDao {  
  6.   
  7.     public   void  insert(String[] sql) {  
  8.         for  (String s : sql)  
  9.             getJdbcTemplate().execute(s);  
  10.     }  
  11. }   
public interface JdbcDao {
 public void insert(String[] sql);
}

public class JdbcDaoImpl extends JdbcDaoSupport implements JdbcDao {

	public void insert(String[] sql) {
		for (String s : sql)
			getJdbcTemplate().execute(s);
	}
}

 

 

这是简单的SQL语句插入，对于配置文件，我们只需要配置一个dataSource跟如下的bean：

Java代码
  1. <bean id= "jdbcDao"   class = "com.lgh.spring.jdbc.JdbcDaoImpl" >  
  2.     <property name="dataSource" >  
  3.         <ref local="dataSource" />  
  4.     </property>  
  5. </bean>   
	<bean id="jdbcDao" class="com.lgh.spring.jdbc.JdbcDaoImpl">
		<property name="dataSource">
			<ref local="dataSource"/>
		</property>
	</bean>

 

这种方式的缺点就是它是非事务处理方，即如果后面的数据处理错误时，而这时候如果前面已经进入数据操作了，它将无法回滚。

 

2.事务处理方式

   顾名思义，这种方式是可以回滚前面所做的事情的。它的参数化配置如下:

Java代码
  1. <bean id= "jdbcDaoProxy"   class = "org.springframework.transaction.interceptor.TransactionProxyFactoryBean" >  
  2.     <property name="proxyTargetClass" >  
  3.           <value>true </value>  
  4.        </property>   
  5.     <property name="transactionManager" >  
  6.         <ref local="transactionManager" />  
  7.     </property>  
  8.     <property name="target" >  
  9.         <ref local="jdbcDao" />  
  10.     </property>  
  11.     <property name="transactionAttributes" >  
  12.         <props>  
  13.             <prop key="insert*" >PROPAGATION_REQUIRED</prop>  
  14.             <prop key="*" >PROPAGATION_REQUIRED,readOnly</prop>  
  15.         </props>  
  16.     </property>  
  17. </bean>   
	<bean id="jdbcDaoProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
	 	<property name="proxyTargetClass">
        	  <value>true</value>
        </property> 
	 	<property name="transactionManager">
			<ref local="transactionManager"/>
		</property>
		<property name="target">
			<ref local="jdbcDao"/>
		</property>
		<property name="transactionAttributes">
			<props>
				<prop key="insert*">PROPAGATION_REQUIRED</prop>
				<prop key="*">PROPAGATION_REQUIRED,readOnly</prop>
			</props>
		</property>
	</bean>

 

如果我们想默认对所有的事件进行事务处理我们可以不用配置transactionAttributes

 

 

Hibernate在spring下的事务与非事务处理方式:

 

  非事务处理方式很简单:

 

Java代码
  1.  <bean id =  "hiberDao"   class  =  "com.lgh.spring.hibernate.HiberDaoImpl" >  
  2.     <property name="sessionFactory" >  
  3.         <ref local = "sessionFactory" />  
  4.     </property>  
  5. </bean>    
	 <bean id = "hiberDao" class = "com.lgh.spring.hibernate.HiberDaoImpl">
		<property name="sessionFactory">
			<ref local = "sessionFactory"/>
		</property>
	</bean>

 

而对于事务处理方式的参数化配置：

Java代码
  1. <bean id =  "hiberDaoProxy"   class  =  "com.lgh.spring.hibernate.HiberDaoImpl" >  
  2.         <property name="sessionFactory" >  
  3.             <ref local = "sessionFactory" />  
  4.         </property>  
  5.     </bean>   
  6.     <bean id="hiberDao"   class = "org.springframework.transaction.interceptor.TransactionProxyFactoryBean" >    
  7.         <property name="transactionManager"  ref= "transactionManager"  />       
  8.         <property name="target"  ref= "hiberDaoProxy"  />    
  9.          <property name="proxyInterfaces"  value= "com.lgh.spring.hibernate.HiberDao"  />  
  10.         <property name="transactionAttributes" >    
  11.             <props>    
  12.                 <prop key="*" >PROPAGATION_REQUIRED</prop>  
  13.             </props>    
  14.         </property>    
  15.     </bean>     
<bean id = "hiberDaoProxy" class = "com.lgh.spring.hibernate.HiberDaoImpl">
		<property name="sessionFactory">
			<ref local = "sessionFactory"/>
		</property>
	</bean> 
    <bean id="hiberDao" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">  
        <property name="transactionManager" ref="transactionManager" />     
        <property name="target" ref="hiberDaoProxy" />  
         <property name="proxyInterfaces" value="com.lgh.spring.hibernate.HiberDao" />
        <property name="transactionAttributes">  
            <props>  
                <prop key="*">PROPAGATION_REQUIRED</prop>
            </props>  
        </property>  
    </bean>

 

 

 

总：

   对于项目开发中，实际上经常会碰到spring与hibernate一起结合来进行参数化配置，但很多时候我们总是会分不清到底是哪个跟哪个。但其实我们 只要掌握了，事务参数化配置的原理。如如何取得sessionFactory，它有几种方式。是否要引用datasource来建立，及事务管理器的各种 参数化配置方式等等，总之，只要明白的其中的原理就不难解决配置上的这块问题了。

ldongwei
关注
专栏目录
spring-dao配置模板详细分析（全）
码农研究僧的博客
11-29 713
目录前言1. 模板2. 配置解析实战演练 前言 主要配置spring中的dao数据交互 1. 模板 <?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.sprin
IDEA连接数据库（Database）自动生成类、mapper.xml、Dao配置详解
cyy18702236763的博客
06-17 5911
-----------------------------------------------------------------------数据库连接----------------------------------------------------------------------------- ---------------------------------------...
DAO Tools-开源
05-14
DAO工具提供了一组有用的工具，可将SQL语句从旧系统转换为Hibernate DAO方法。 当前，它仅将SQL转换为HQL。
spring-dao配置
无知的博客
02-01 4041
spring-dao.xml,spring整合mybatis和redis <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.o
spring-dao配置模板
xzl的博客
07-23 154
<?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" xsi:schemaLo
Spring中dao层的配置
Amor__SAMA的博客
07-11 376
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="ht
idea 14 ssm 全注解框架+log4j+事物控制+mybatis基础Dao配置
07-27
下面将详细阐述SSM框架、Log4j日志管理、事务控制以及MyBatis的基础Dao配置。 首先，Spring框架作为核心，负责依赖注入（Dependency Injection，DI）和面向切面编程（Aspect-Oriented Programming，AOP）。通过注解...
mybatis_01 入门配置 Dao的两种开发方法
11-15
### MyBatis 入门配置与 DAO 的两种开发方法 #### 一、JDBC 开发问题及 MyBatis 概览 ##### JDBC 开发常见问题 - **频繁创建与释放数据库连接**: 这可能导致资源浪费并影响系统性能。在企业级项目中，通常采用连接...
spring几种Dao支持配置
04-02
Spring提供了多种方式来支持DAO的配置，使得开发人员可以灵活地选择最适合项目需求的数据访问策略。以下将详细阐述Spring对DAO支持的几种配置方式： 1. **JDBC DAO支持：** Spring通过`JdbcTemplate`和`...
DAO在MFC中的应用实例
MannHello的专栏
04-05 1086
本文介绍使用MFC DAO访问数据库的一个实例，其中实例来源于网络。  实例同样实现了对数据库的基本操作：添加、修改、删除和遍历。与ODBC实例中不同的是，ODBC使用过程中添加了一个从CRecordset派生而来的CBook类，负责成员数据与数据表字段的关联，而本实例则是直接使用CDaoRecordset类。无论是使用ODBC还是DAO访问数据库都可以使用这两种方法，本实例采用后者来实现
DAO设置模式
weixin_30505485的博客
03-31 70
区分： J2EE的组件层次： 　　客户端---表示层---业务层---数据层---数据库---数据库 DAO属于数据层的操作，即：在DAO中封装了一个表在项目中的多有的操作 举例： person表 id name password age 定义各种操作: 在java中只有通过接口可以定义标准----DAO规定的就是一个接口 在插入---针对对象插入 对象叫做---v...
Maven部署dao工程到私服上——（十三）
weixin_34204722的博客
08-04 103
1.修改settings.xml 需要在客户端即(部署dao工程)的电脑上配置 maven环境，并修改 settings.xml 文件，配置连接私服的用户和密码 。 此用户名和密码用于私服校验，因为私服需要知道上传都 的账号和密码 是否和私服中的账号和密码 一致。   修改如下代码: &lt;server&gt; &lt;id&gt;releases&lt;...
mybatis一个简单的程序开发纪念
weixin_45855227的博客
04-11 128
```java ## spring-dao <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" x...
简单工作流系统——部署DAO组件
实践求真知
10-01 292
一daoContext.xml <?xml version="1.0" encoding="GBK"?> <!-- 指定Spring配置文件的Schema信息 --> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/...
Spring的dao层配置(dbcp数据库连接池)
？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？
03-12 1593
<?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:/...
MyBatis基础操作与配置（传统DAO模式开发）
weixin_45565886的博客
07-07 809
MyBatis基于DAO模式开发详细过程
Dao模式连接oracle数据库
qq_35588249的博客
05-27 274
1.创建数据库表person，字段一次为id,name,address,birthday 2.创建项目连接数据库 3.创建oracle数据库中要操作表的实体类Person.java package com.dy.person; import java.util.Date; public class Person { private Integer id; private String name; private String address; public Integer getId() { r
Spring与AOP之AspectJ对DAO的实现
huangyuanzhi
11-02 391
对于 AOP 这种编程思想，很多框架都进行了实现。 Spring 就是其中之一， 可以完成面向切面编程。 然而， AspectJ 也实现了 AOP 的功能，且其实现方式更为简捷，使用更为方便，而且还支持注解式开发（在 Spring 中使用 AOP 开发时，一般使用 AspectJ 的实现方式）。 AspectJ 简介 AspectJ 是一个面向切面的框架，它扩展了 Java 语言。 AspectJ 定义了 AOP 语法，它有一个专门的编译器用来生成遵守 Java 字节编码规范的 Class 文件。——百度
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值