`
kx29126390
  • 浏览: 40275 次
  • 性别: Icon_minigender_1
  • 来自: 天津
社区版块
存档分类
最新评论

spring几种Dao支持配置

    博客分类：
  • JAVA
DAOSpring配置管理HibernateBean 
阅读更多

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

  一个是依赖特定的资源的事务：如通过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来建立，及事务管理器的各种参数化配置方式等等，总之，只要明白的其中的原理就不难解决配置上的这块问题了。

 

转：http://www.iteye.com/topic/616032

分享到：
| JPA注解
评论
发表评论

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

相关推荐

    org.springframework.dao.InvalidDataAccessApiUsageException

    为了避免 `org.springframework.dao.InvalidDataAccessApiUsageException` 的发生，可以采取以下几种解决方案： 1. **显式配置事务管理**： 在Spring的配置文件（例如 `applicationContext.xml`）中显式地配置事务...

    Spring DAO

    Spring 的 JDBC 支持主要体现在以下几个方面： 1. **JdbcTemplate**：这是一个高度抽象的类，它将数据库操作的模板方法模式应用到了极致。开发者只需要实现具体的SQL语句即可，其他的诸如资源释放、异常处理等由...

    Spring配置的5种方式

    除了上述方式外，还有以下几种事务配置方法： 1. **基于AspectJ的事务配置**: - 使用AspectJ可以更加灵活地配置事务边界，适用于复杂的事务管理场景。 - 示例配置可能涉及`@Aspect`和`@Before`等注解。 2. **...

    spring声明式事务配置

    4. **TransactionProxyFactoryBean**：这是一种使用代理模式的声明式事务配置方法，为DAO层的方法提供事务支持。 ```xml &lt;bean id="userDao" class="org.springframework.transaction.interceptor....

    spring 对dao 的操作

    3. **配置Spring**：在Spring的配置文件中，定义DAO Bean，指定其实现类，并注入必要的依赖，如数据源、SessionFactory等。 4. **事务管理**：在Spring中，可以使用声明式事务管理，通过`@Transactional`注解来控制...

    SpringDao模式实例

    Spring DAO模式是Spring框架中的一种设计模式，它主要用于数据库访问层的实现，旨在提供一种统一的、可扩展的、易管理的方式来处理数据访问。在Spring框架中，DAO（Data Access Object）模式是将业务逻辑与数据操作...

    jsf+spring 的 配置文件

    在"jsf+spring"的配置文件中，主要涉及以下几个方面： 1. **集成配置**：首先，我们需要在Spring的配置文件（如`applicationContext.xml`）中声明JSF的Managed Bean作为Spring的Bean，这样可以利用Spring的依赖注入...

    Spring 加载多个配置文件

    ### Spring 加载多个配置文件详解 #### 一、引言 在现代软件开发中，Spring 框架因其强大的依赖注入（DI）和面向切面编程（AOP）能力而备受青睐。尤其在构建大型应用时，为了提高代码的可读性和可维护性，将系统...

    spring中事物配置

    Spring提供了几种事务通知类型，如`@Transactional`注解、`tx:advice`元素等。在XML配置中，我们可以使用`&lt;tx:advice&gt;`元素来定义一个事务通知： ```xml *" propagation="REQUIRED"/&gt; ``` 这里，`*`表示...

    基于注解和Spring的多数据源配置和使用

    在Spring中，多数据源配置通常涉及以下几个关键步骤： 1. **数据源配置**：创建多个DataSource对象，每个对象对应一个数据库连接。可以使用`org.springframework.jdbc.datasource.DriverManagerDataSource`或`...

    spring事务与配置

    在Spring配置文件中，事务配置主要包含以下几个核心组成部分： 1. **DataSource**：数据源，负责连接数据库。 2. **TransactionManager**：事务管理器，负责事务的开启、提交或回滚等操作。 3. **代理机制**：用于...

    springioc的搭建和配置

    Spring 也支持通过注解来配置 IoC 容器，这种方式更加简洁易用。下面是一些常用的注解： - `@Component`: 通用组件注解，适用于任何类型的类。 - `@Repository`: 用于 DAO 层的组件。 - `@Service`: 用于 Service ...

    ssh框架整合详细步骤（spring+struts2+hibernate）

    - 创建Spring的配置文件applicationContext.xml，配置Bean的定义，包括DAO层、Service层以及Action层的Bean。 **Step10：Struts2与Spring的集成** - 在`struts.xml`中，将Action的Class属性修改为Spring的Bean名称...

    spring 整合 mybatis 中数据源的几种配置方式(总结篇)

    Spring 整合 MyBatis 中数据源的几种配置方式总结 Spring 整合 MyBatis 是当前 Java 企业级应用程序中非常常见的一种技术架构。然而，在 Spring 整合 MyBatis 的过程中，有多种方式可以实现数据源的配置。今天，...

    spring事务与数据库操作

    要启用Spring的声明式事务管理，通常需要做以下几步配置： - **配置数据源**：首先需要配置数据源，以便Spring能够访问数据库。 - **配置事务管理器**：接下来，需要配置一个事务管理器（如`...

    Spring系列面试题129道（附答案解析）

    - 依赖注入（DI）支持：Spring通过控制反转（IoC）支持将对象之间的依赖关系通过配置文件或注解来管理。 - 面向切面编程（AOP）：Spring支持面向切面编程，可以将通用任务（如日志记录和事务管理）模块化。 - 事务...

    Spring 依赖注入的几种方式详解

    然后，在Spring的XML配置文件中，你可以创建`SpringAction`和`SpringDao`的bean，并使用`&lt;property&gt;`标签将`SpringDao`注入到`SpringAction`中： ```xml &lt;bean name="springAction" class=...

    Spring与Hibernate集成

    3. **配置HibernateTemplate**: Spring通过`HibernateTemplate`提供了一种简化数据访问的方法。它封装了常见的Hibernate操作，如保存、更新、删除和查询。在Spring配置文件中，我们可以定义一个`HibernateTemplate`...

    mybaits-spring(ibatis-spring)-1.0.2-bundle

    在实际应用中，配置MyBatis-Spring涉及以下几个步骤： 1. 引入依赖：在项目的pom.xml文件中添加MyBatis-Spring的依赖。 2. 配置SqlSessionFactory：在Spring的配置文件中，通过bean定义SqlSessionFactory，通常基于...

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