`
bolan392
  • 浏览: 277017 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

HibernateDaoSupport和JdbcDaoSupport

 
阅读更多

HibernateDaoSupport与JdbcDaoSupport

Java配置管理Spring编程Hibernate
Dao 的支持类可以有好多，如： JdbcDaoSupport ， HibernateDaoSupport ，JdoDaoSupport等，下面对最常用的HibernateDaoSupport与JdbcDaoSupport做一小总结：
一、在Spring框架中实现连接数据库方式：
1、、借助类HibernateDaoSupport的简约化实现：
借助这个类必须需要HIbernate框架，用到HIbernate里提供的HibernateTemplate模板，从而进行增、删、改、查操作。
Java代码 复制代码 收藏代码
  1. TestA.java:   
  2. public class TestA extends HibernateDaoSupport{   
  3. public void test(){   
  4.      HibernateTemplate template = this.getHibernateTemplate();   
  5.      List list = template.find("from User");   
  6.      for(int i=0;i<list.size();i++){   
  7.       User u = (User)list.get(i);   
  8.       System.out.println(u.getUserid()+" "+u.getEmail());   
  9.      }   
  10. }   
  11.   
  12. public static void main(String[] args) {   
  13.            ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");   
  14.            TestA t = (TestA)ctx.getBean("testa");   
  15.            t.test();   
  16. }   
  17. }  
TestA.java:
public class TestA extends HibernateDaoSupport{
public void test(){
     HibernateTemplate template = this.getHibernateTemplate();
     List list = template.find("from User");
     for(int i=0;i<list.size();i++){
      User u = (User)list.get(i);
      System.out.println(u.getUserid()+" "+u.getEmail());
     }
}

public static void main(String[] args) {
           ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
           TestA t = (TestA)ctx.getBean("testa");
           t.test();
}
}

需要在Spring的配置文件applicationContext.xml中控制反转用到连接数据库中的类是注入SessionsFactory，如下：
Java代码 复制代码 收藏代码
  1. applicationContext.xml:   
  2.         <bean id="testa" class="com.sun.demo.TestA">   
  3.         <property name="sessionFactory">   
  4.         <ref bean="mySessionFactory"/>   
  5.         </property>   
  6.         </bean>  
applicationContext.xml:
        <bean id="testa" class="com.sun.demo.TestA">
        <property name="sessionFactory">
        <ref bean="mySessionFactory"/>
        </property>
        </bean>

2、、借助类JdbcDaoSupport的简约化实现：
借助这个类不需要HIbernate框架，也不需要有ORM的对象关联映射。但它和HibernateDaoSupport很类似，有JdbcTemplate来实现增、删、改、查操作。
TestA.java:
Java代码 复制代码 收藏代码
  1. public class TestA extends JdbcDaoSupport{   
  2.     public void test(){   
  3.         int n = this.getJdbcTemplate().queryForInt("select max(userid) from User");   
  4.         System.out.println(n);   
  5.     }   
  6. public static void main(String[] args) {   
  7. ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");   
  8. TestA ta = (TestA)ctx.getBean("testa");   
  9.         ta.test();    
  10. }   
  11. }   
public class TestA extends JdbcDaoSupport{
    public void test(){
        int n = this.getJdbcTemplate().queryForInt("select max(userid) from User");
        System.out.println(n);
    }
public static void main(String[] args) {
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
TestA ta = (TestA)ctx.getBean("testa");
        ta.test(); 
}
}
需要在Spring的配置文件applicationContext.xml中控制反转用到连接数据库中的类是注入DataSource，如下：
applicationContext.xml:
Java代码 复制代码 收藏代码
  1. <bean id="testa" class="com.sun.demo.TestA">   
  2. <property name="dataSource">   
  3. <ref bean="myDataSource"/>   
  4. </property>   
  5. </bean>  
        <bean id="testa" class="com.sun.demo.TestA">
        <property name="dataSource">
        <ref bean="myDataSource"/>
        </property>
        </bean>

       
二、编程式事务管理、声明式事务管理中HibernateDaoSupport与JdbcDaoSupport的应用：
1、编程式事务管理：
1>、JdbcDaoSupport编程式事物管理，必须继承JdbcDaoSupport类，得到JdbcTemplate从而实现事务管理；

TestA.java:
Java代码 复制代码 收藏代码
  1. public class TestA extends JdbcDaoSupport{   
  2. public void test(){   
  3.      PlatformTransactionManager ptm = new DataSourceTransactionManager(this.getDataSource());   
  4.      TransactionTemplate tst = new TransactionTemplate(ptm);   
  5.      tst.execute(new TransactionCallback(){   
  6.    public Object doInTransaction(TransactionStatus status) {   
  7.       getJdbcTemplate().update("update User set password='1230' where userid='1001'");    
  8.       getJdbcTemplate().update("update User set email='4444444444444444444444444444444444' where userid='1002'");   
  9.       getJdbcTemplate().update("update User set phone='phone'");   
  10.       return null;   
  11.    }   
  12.      });   
  13. }   
  14.   
  15.   
  16. public static void main(String[] args) {   
  17.     ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");   
  18.     TestA t = (TestA)ctx.getBean("testa");   
  19.     t.test();   
  20. }   
  21. }  
public class TestA extends JdbcDaoSupport{
public void test(){
     PlatformTransactionManager ptm = new DataSourceTransactionManager(this.getDataSource());
     TransactionTemplate tst = new TransactionTemplate(ptm);
     tst.execute(new TransactionCallback(){
   public Object doInTransaction(TransactionStatus status) {
      getJdbcTemplate().update("update User set password='1230' where userid='1001'"); 
      getJdbcTemplate().update("update User set email='4444444444444444444444444444444444' where userid='1002'");
      getJdbcTemplate().update("update User set phone='phone'");
      return null;
   }
     });
}


public static void main(String[] args) {
    ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
    TestA t = (TestA)ctx.getBean("testa");
    t.test();
}
}
需要在Spring的配置文件applicationContext.xml中控制反转用到连接数据库中的类是注入DataSource，如下：
applicationContext.xml:
Java代码 复制代码 收藏代码
  1. <bean id="myDataSource" class="org.apache.commons.dbcp.BasicDataSource">   
  2.        
  3.     ... ...   
  4.        
  5.     <property name="defaultAutoCommit">   
  6.     <value>false</value>   
  7.     </property>   
  8. </bean>   
  9.        
  10.         <bean id="testa" class="com.sun.demo.TestA">   
  11.         <property name="dataSource">   
  12.         <ref bean="myDataSource"/>   
  13.         </property>   
  14.         </bean>  
<bean id="myDataSource" class="org.apache.commons.dbcp.BasicDataSource">
    
    ... ...
    
    <property name="defaultAutoCommit">
    <value>false</value>
    </property>
</bean>
    
        <bean id="testa" class="com.sun.demo.TestA">
        <property name="dataSource">
        <ref bean="myDataSource"/>
        </property>
        </bean>

2>、HibernateDaoSupport编程式事物管理，必须继承HibernateDaoSupport类，得到HibernateTemplate从而实现事务管理；
TestB.java:
Java代码 复制代码 收藏代码
  1. public class TestB extends HibernateDaoSupport{   
  2. public void test(){   
  3.      HibernateTransactionManager hm = new HibernateTransactionManager(this.getSessionFactory());   
  4.      TransactionTemplate ttm = new TransactionTemplate(hm);   
  5.      ttm.execute(new TransactionCallback(){   
  6.    public Object doInTransaction(TransactionStatus status) {   
  7.     User u1 = new User();   
  8.     u1.setUserid("3001");   
  9.     u1.setPassword("3001");   
  10.     getHibernateTemplate().save(u1);   
  11.        
  12.     User u2 = new User();   
  13.     u2.setUserid("3001");   
  14.     u2.setPassword("3002");   
  15.     getHibernateTemplate().save(u2);   
  16.     return null;   
  17.    }   
  18.      });   
  19. }   
  20.   
  21. public static void main(String[] args) {   
  22.            ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");   
  23.            TestB t = (TestB)ctx.getBean("testb");   
  24.         t.test();   
  25. }   
  26. }  
public class TestB extends HibernateDaoSupport{
public void test(){
     HibernateTransactionManager hm = new HibernateTransactionManager(this.getSessionFactory());
     TransactionTemplate ttm = new TransactionTemplate(hm);
     ttm.execute(new TransactionCallback(){
   public Object doInTransaction(TransactionStatus status) {
    User u1 = new User();
    u1.setUserid("3001");
    u1.setPassword("3001");
    getHibernateTemplate().save(u1);
    
    User u2 = new User();
    u2.setUserid("3001");
    u2.setPassword("3002");
    getHibernateTemplate().save(u2);
    return null;
   }
     });
}

public static void main(String[] args) {
           ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
           TestB t = (TestB)ctx.getBean("testb");
        t.test();
}
}
需要在Spring的配置文件applicationContext.xml中控制反转用到连接数据库中的类是注入SessionsFactory，如下：
Java代码 复制代码 收藏代码
  1. applicationContext.xml:   
  2. <bean id="myDataSource" class="org.apache.commons.dbcp.BasicDataSource">   
  3.        
  4.     ... ...   
  5.        
  6.     <property name="defaultAutoCommit">   
  7.     <value>false</value>   
  8.     </property>   
  9. </bean>   
  10.        
  11.      <bean id="testb" class="com.sun.demo.TestB">   
  12.      <property name="sessionFactory">   
  13.      <ref bean="mySessionFactory"/>   
  14.      </property>   
  15.      </bean>  
applicationContext.xml:
<bean id="myDataSource" class="org.apache.commons.dbcp.BasicDataSource">
    
    ... ...
    
    <property name="defaultAutoCommit">
    <value>false</value>
    </property>
</bean>
    
     <bean id="testb" class="com.sun.demo.TestB">
     <property name="sessionFactory">
     <ref bean="mySessionFactory"/>
     </property>
     </bean>

2、声明式事务管理：   
1>、JdbcDaoSupport声明式样事物管理,必须继承JdbcDaoSupport类；
Java代码 复制代码 收藏代码
  1. <bean id="myDataSource" class="org.apache.commons.dbcp.BasicDataSource">   
  2.             
  3.          ... ....   
  4.   
  5. <property name="defaultAutoCommit">   
  6. <value>false</value>   
  7. </property>   
  8. </bean>  
<bean id="myDataSource" class="org.apache.commons.dbcp.BasicDataSource">
         
         ... ....

<property name="defaultAutoCommit">
<value>false</value>
</property>
</bean>


   需要在Spring配置文件中配置声明事务处理，用JdbcDaoSupport提供的DataSourceTransactionManager如下：
Java代码 复制代码 收藏代码
  1. <!-- 事务管理配置 -->   
  2. <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">   
  3. <property name="dataSource">   
  4. <ref bean="myDataSource"/>   
  5. </property>   
  6. </bean>   
  7.   
  8. <bean id="baseTransactionProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">   
  9. <property name="transactionManager" ref="transactionManager"/>   
  10. <!-- 事务管理属性 -->   
  11. <property name="transactionAttributes">   
  12.    <props>   
  13.    <prop key="updateUser">PROPAGATION_REQUIRED</prop>   
  14.    </props>   
  15. <!-- 事务管理目标bean -->   
  16. </property>   
  17. <property name="target" ref="userdao"></property>   
  18. </bean>   
  19.   
  20. <bean id="userdao" class="com.sun.demo.UserDao">   
  21. <property name="dataSource">   
  22. <ref bean="myDataSource"/>   
  23. </property>   
  24. </bean>  
        <!-- 事务管理配置 -->
        <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource">
        <ref bean="myDataSource"/>
        </property>
        </bean>
       
        <bean id="baseTransactionProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
        <property name="transactionManager" ref="transactionManager"/>
        <!-- 事务管理属性 -->
        <property name="transactionAttributes">
           <props>
           <prop key="updateUser">PROPAGATION_REQUIRED</prop>
           </props>
        <!-- 事务管理目标bean -->
        </property>
        <property name="target" ref="userdao"></property>
        </bean>
        
        <bean id="userdao" class="com.sun.demo.UserDao">
        <property name="dataSource">
        <ref bean="myDataSource"/>
        </property>
        </bean>


Java代码 复制代码 收藏代码
  1. IUserDao.java://定义接口   
  2. public interface IUserDao {   
  3. public void updateUser();   
  4. }   
  5.   
  6. UserDao.java:   
  7. public class UserDao extends JdbcDaoSupport implements IUserDao{   
  8.        public void updateUser(){   
  9.         this.getJdbcTemplate().update("update User set password='password1' where userid='1001'");   
  10.            this.getJdbcTemplate().update("update User set password='password9999999999999999999999999999999' where userid='1002'");   
  11.        }   
  12. }  
IUserDao.java://定义接口
public interface IUserDao {
public void updateUser();
}

UserDao.java:
public class UserDao extends JdbcDaoSupport implements IUserDao{
       public void updateUser(){
        this.getJdbcTemplate().update("update User set password='password1' where userid='1001'");
           this.getJdbcTemplate().update("update User set password='password9999999999999999999999999999999' where userid='1002'");
       }
}

TestA.java://调用updateUser()方法
Java代码 复制代码 收藏代码
  1. public class{   
  2.        
  3.     public void test(){   
  4.           ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");   
  5.        IUserDao u = (IUserDao)ctx.getBean("baseTransactionProxy");   
  6.           u.updateUser();   
  7.     }   
  8.   
  9.   
  10. public static void main(String[] args) {   
  11.            TestA t = new TestA();   
  12.            t.test();   
  13. }   
  14. }  
public class{
    
    public void test(){
          ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
       IUserDao u = (IUserDao)ctx.getBean("baseTransactionProxy");
          u.updateUser();
    }


public static void main(String[] args) {
           TestA t = new TestA();
           t.test();
}
}

2>、HibernateDaoSupport声明式事物管理，必须继承HibernateDaoSupport类；
IUserDao.java://定义接口
Java代码 复制代码 收藏代码
  1. public interface IUserDao {   
  2. public void updateUser();   
  3. }   
  4. UserDao.java:   
  5. public class UserDao extends HibernateDaoSupport implements IUserDao{   
  6.        public void updateUser(){   
  7.               User u1 = new User();   
  8.               u1.setUserid("1001");   
  9.               u1.setPassword("5001");   
  10.               this.getHibernateTemplate().update(u1);   
  11.                  
  12.                  
  13.               User u2 = new User();   
  14.               u2.setUserid("1003");   
  15.               u2.setPassword("20015555555555555555555555555555555555555555555");   
  16.               this.getHibernateTemplate().update(u2);   
  17.        }   
  18. }  
public interface IUserDao {
public void updateUser();
}
UserDao.java:
public class UserDao extends HibernateDaoSupport implements IUserDao{
       public void updateUser(){
              User u1 = new User();
              u1.setUserid("1001");
              u1.setPassword("5001");
              this.getHibernateTemplate().update(u1);
              
              
              User u2 = new User();
              u2.setUserid("1003");
              u2.setPassword("20015555555555555555555555555555555555555555555");
              this.getHibernateTemplate().update(u2);
       }
}

测试：
Java代码 复制代码 收藏代码
  1. public class TestA{   
  2.        
  3.     public void test(){   
  4.           ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");   
  5.        IUserDao userdao= (IUserDao)ctx.getBean("userproxy");   
  6.           userdao.updateUser();   
  7.     }   
  8.   
  9.   
  10. public static void main(String[] args) {   
  11.            TestA t = new TestA();   
  12.            t.test();   
  13. }   
  14. }   
public class TestA{
    
    public void test(){
          ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
       IUserDao userdao= (IUserDao)ctx.getBean("userproxy");
          userdao.updateUser();
    }


public static void main(String[] args) {
           TestA t = new TestA();
           t.test();
}
}

需要在Spring配置文件中配置声明事务处理，用JdbcDaoSupport提供的HibernateTransactionManager如下：
applicationContext.xml:
  
Java代码 复制代码 收藏代码
  1. <!-- 事务管理配置 -->   
  2.    <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">   
  3.    <property name="sessionFactory">   
  4.    <ref bean="mySessionFactory"/>   
  5.    </property>   
  6.    </bean>   
  7.       
  8.    <bean id="baseTransactionProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean" abstract="true">   
  9.    <property name="transactionManager" ref="transactionManager"/>   
  10.    <!-- 事务管理属性 -->   
  11.    <property name="transactionAttributes">   
  12.       <props>   
  13.       <prop key="update*">PROPAGATION_REQUIRED</prop>   
  14.       <prop key="save*">PROPAGATION_REQUIRED</prop>   
  15.       <prop key="delete*">PROPAGATION_REQUIRED</prop>   
  16.       </props>   
  17.    <!-- 事务管理目标bean -->          
  18.    </property>   
  19.    </bean>   
  20.       
  21.    <bean id="userdao" class="com.sun.demo.UserDao">   
  22.    <property name="sessionFactory">   
  23.    <ref bean="mySessionFactory"/>   
  24.    </property>   
  25.    </bean>   
  26.       
  27.    <bean id="userproxy" parent="baseTransactionProxy">   
  28.    <property name="target" ref="userdao"></property>   
  29.    </bean>  
     <!-- 事务管理配置 -->
        <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory">
        <ref bean="mySessionFactory"/>
        </property>
        </bean>
        
        <bean id="baseTransactionProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean" abstract="true">
        <property name="transactionManager" ref="transactionManager"/>
        <!-- 事务管理属性 -->
        <property name="transactionAttributes">
           <props>
           <prop key="update*">PROPAGATION_REQUIRED</prop>
           <prop key="save*">PROPAGATION_REQUIRED</prop>
           <prop key="delete*">PROPAGATION_REQUIRED</prop>
           </props>
        <!-- 事务管理目标bean -->       
        </property>
        </bean>
        
        <bean id="userdao" class="com.sun.demo.UserDao">
        <property name="sessionFactory">
        <ref bean="mySessionFactory"/>
        </property>
        </bean>
        
        <bean id="userproxy" parent="baseTransactionProxy">
        <property name="target" ref="userdao"></property>
        </bean>

以上这种声明事务的方式配置较多，需要为每个类配置代理对象，还有一种配置事务的方式使用了Spring的aop方式，自动生成代理对象，可以减少配置：

 

<!-- 事务管理配置 -->   
	<bean id="transactionManager"
		class="org.springframework.orm.hibernate3.HibernateTransactionManager">
	</bean>
	<!-- 配置事务的传播特性 --> 
	 <tx:advice id="txAdvice" transaction-manager="transactionManager"> 
       <tx:attributes> 
           <tx:method name="add*" propagation="REQUIRED"/> 
           <tx:method name="del*" propagation="REQUIRED"/> 
           <tx:method name="modify*" propagation="REQUIRED"/> 
           <tx:method name="*" read-only="true"/> 
       </tx:attributes> 
    </tx:advice> 
	<!-- 哪类的哪些方法参与事务 --> 
    <aop:config> 
       <aop:pointcut id="allServiceMethod" expression="execution(* com.spring.tran.service.*.*(..))"/> 
       <aop:advisor pointcut-ref="allServiceMethod" advice-ref="txAdvice"/> 
    </aop:config>

 

分享到：
| Spring中使用HibernateCallback
评论
发表评论

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

相关推荐

    HibernateDaoSupport与JdbcDaoSupport

    其中，`HibernateDaoSupport`和`JdbcDaoSupport`是两种非常常用的支持类。 **HibernateDaoSupport**主要用于整合Hibernate框架，提供了一种更加简洁的方式来使用Hibernate进行数据库操作。而**JdbcDaoSupport**则...

    Jdbcsupport培训 详细讲解jdbcsupport

    Spring对DAO的支持体现在提供了一系列的基类，如HibernateDaoSupport、JdbcDaoSupport、SqlMapClientDAOSupport和JpaDaoSupport等。这些基类为不同ORM框架的使用提供了便利。其中，JdbcDaoSupport是针对JDBC操作进行...

    hibernate和spring技术难点及其要点总结

    1. **HibernateDaoSupport与JdbcDaoSupport**：Spring提供了这些支持类来简化DAO（数据访问对象）的实现，两者分别用于Hibernate和JDBC操作。它们提供了事务管理和数据源的便捷接入。 **三、Hibernate的查询方式** ...

    Spring持久化模板总结

    本文将深入探讨Spring对JDBCTemplate和HibernateTemplate的整合使用方法，以及JdbcDaoSupport和HibernateDaoSupport的支持。 **JdbcTemplate** JdbcTemplate是Spring提供的一个简单、灵活且强大的JDBC抽象层。它...

    java之hibernate和spring技术难点及其要点总结

    1. **HibernateDaoSupport与JdbcDaoSupport**：`HibernateDaoSupport`是Spring提供的用于简化Hibernate使用的抽象支持类，它提供了`SessionFactory`等资源的注入，简化了Hibernate的使用过程。而`JdbcDaoSupport`则...

    pring对JDBC和orm的支持共10页.pdf.zip

    8. **DAO（数据访问对象）支持**：Spring提供了一套通用的DAO接口和抽象类，如JdbcDaoSupport和HibernateDaoSupport，帮助开发者创建符合约定的DAO层，便于测试和扩展。 综上所述，Spring对JDBC和ORM的支持极大地...

    spring3.x的读书笔记-5

    此外，Spring还为其他持久化技术如Hibernate提供了类似的模板类`HibernateTemplate`，以及对应的DAO支持类，如`JdbcDaoSupport`和`HibernateDaoSupport`，这些支持类负责初始化模板对象并提供数据资源。 在数据源...

    Java的Spring框架中DAO数据访问对象的使用示例

    Spring框架提供了对DAO的支持，包括与JDBC、Hibernate、JDO和JPA等不同数据访问技术的集成。在本示例中，我们将探讨Spring如何与JDBC和Hibernate一起使用DAO。 首先，Spring的`JdbcDaoSupport`是为JDBC数据访问对象...

    spring和数据库层的结合

    3. **自动注入与便利获取**：Spring同样提供了`HibernateDaoSupport`等支持类，这些类可以自动注入数据源和SessionFactory，并且提供了一个便捷的方法来获取`HibernateTemplate`对象。这使得开发过程更加高效。 ###...

    spring 对dao 的操作

    对于Hibernate，Spring提供`HibernateTemplate`和`HibernateDaoSupport`，它们封装了Hibernate的操作，使得开发者可以专注于业务逻辑，而不是底层的SessionFactory和Session管理。例如，我们可以在DAO中注入`...

    spring学习的第三天

    - 继承`HibernateDaoSupport`类：该类内部已经实现了`HibernateTemplate`的注入，可以通过`getHibernateTemplate()`方法直接获取。 ##### 3. SessionFactory `SessionFactory`是Hibernate的核心接口之一，用于...

    SPRING API 2.0.CHM

    JdbcDaoSupport JdbcOperations JdbcTemplate JdbcTransactionObjectSupport JdbcUpdateAffectedIncorrectNumberOfRowsException JdbcUtils JdkDynamicAopProxy JdkRegexpMethodPointcut JdkVersion ...

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