Dao 的支持类可以有好多，如： JdbcDaoSupport ， HibernateDaoSupport ，JdoDaoSupport等，下面对最常用的HibernateDaoSupport与JdbcDaoSupport做一小总结：
一、在Spring框架中实现连接数据库方式：
1、、借助类HibernateDaoSupport的简约化实现：
借助这个类必须需要HIbernate框架，用到HIbernate里提供的HibernateTemplate模板，从而进行增、删、改、查操作。
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，如下：
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:
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:
        <bean id="testa" class="com.sun.demo.TestA">
        <property name="dataSource">
        <ref bean="myDataSource"/>
        </property>
        </bean>

JdbcDaoSupport是JDBC数据访问对象的超类。它与特定的数据源相关联。Spring Inversion of Control （IOC）容器或BeanFactory负责获得相应数据源的配置详细信息，并将其与JdbcDaoSupport相关联。这个类最重要的功能就是使子类可以使用JdbcTemplate对象。  图2：Spring JDBC框架的主要组件

#p#

JdbcTemplate是Spring JDBC框架中最重要的类。引用文献中的话：“它简化了JDBC的使用，有助于避免常见的错误。它执行核心JDBC工作流，保留应用代码以提供SQL和提取结果。”这个类通过执行下面的样板任务来帮助分离JDBC DAO代码的静态部分：

◆从数据源检索连接。
◆准备合适的声明对象。
◆执行SQL CRUD操作。
◆遍历结果集，然后将结果填入标准的collection对象。
◆处理SQLException异常并将其转换成更加特定于错误的异常层次结构。

应用实例：

1.applicationContext.xml配置文件:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean id="myDataSource"
   class="org.apache.commons.dbcp.BasicDataSource"
   destroy-method="close">
   <property name="driverClassName" value="oracle.jdbc.driver.OracleDriver" />
   <property name="url" value="jdbc:oracle:thin:@127.0.0.1:1521:lrmora9" />
   <property name="username" value="dmis2006_sj" />
   <property name="password" value="omssj" />
   <property name="maxActive" value="5" />
   <property name="maxIdle" value="3" />
   <property name="minIdle" value="2" />
   <property name="maxWait" value="2" />
   <property name="initialSize" value="1" />
   <property name="removeAbandoned" value="true" />
   <property name="removeAbandonedTimeout" value="180" />
   <property name="logAbandoned" value="true" />
</bean>

<bean id="jdbcDao" class="com.lrm.study.jdbc.SpringJdbcDaoSupportApp">
   <property name="dataSource">
    <ref bean="myDataSource" />
   </property>
</bean>
</beans>

2.测试类：

package com.lrm.study.springJDBCDao;

import java.util.List;
import java.util.Map;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.core.support.JdbcDaoSupport;

public class SpringJdbcDaoSupportApp extends JdbcDaoSupport{
/**
on May 10, 2010 by lrm
*/
public static void main(String[] args) {
   //applicationContext.xml这个文件放到src下，如果报找不到这样的文件，直接拷贝到web-root下的classes下
   ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
   SpringJdbcDaoSupportApp jdbcDao = (SpringJdbcDaoSupportApp) ctx.getBean("jdbcDao");
   String sql = "select t.ftypename from dmis_eqptype t where t.fcategory = '保护'";
   List reList = jdbcDao.queryListBySql(sql);
   if(reList.size()>0){
    for (int i = 0; i < reList.size(); i++) {
     String typename = ((Map)reList.get(i))==null?"":((Map)reList.get(i)).get("ftypename").toString();
     System.out.println(typename);
    }
   }
}

public List queryListBySql(String sql){
   return this.getJdbcTemplate().queryForList(sql);
}

}

注意：这里需求相关的jar包支持，否则会报错.commons-dbcp-1.2.1.jar ;commons-pool-1.2.jar ;commons-collections-3.1.jar; spring-1.2.6.jar; spring-aop.jar;ojdbc14.jar

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

TestA.java:
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='liuzheng.666888@163.com' where userid='100000001'");
      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:
<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:
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，如下：
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类；
<bean id="myDataSource" class="org.apache.commons.dbcp.BasicDataSource">
         
         ... ....

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

需要在Spring配置文件中配置声明事务处理，用JdbcDaoSupport提供的DataSourceTransactionManager如下：
        <!-- 事务管理配置 -->
        <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>

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()方法
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://定义接口
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);
       }
}

测试：
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:
        <!-- 事务管理配置 -->
        <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的JdbcDaoSupport的批量操作

 

由于数据的批量处理（比如往RDBMS插入几万条数据）非常耗资源，因此建议在所有场合能够借助于JDBC完成，而不要去采用Hibernate API。本文主要围绕Spring内置的各类JDBC API抽象支持展开的。

1.1.  JdbcTemplate内置的batchUpdate(final String[] sql)

这一方法适合于小批量数据的CUD（增、更新、删除）操作，而且SQL类型不限。由于其内部使用了Statement语句，所以数据的操作效率一般。

1.2.  JdbcTemplate内置的batchUpdate(String sql, final BatchPreparedStatementSetter pss)

这一方法也仅仅适合于小批量数据的CUD（增、更新、删除）操作，但始终是同一SQL（参数具有多样性）。由于其内部使用了PreparedStatement语句，所以数据的操作效率还是不错的。下面给出了操作示例：

final int[] no = new int[]{7369,7499,7521,7566,7654,7698};

jt.batchUpdate("update emp set sal = ? where empno = ?",

new BatchPreparedStatementSetter(){

public void setValues(PreparedStatement ps, int i)

throws SQLException {

ps.setInt(1, no[i]);

ps.setFloat(2, no[i]);

}

public int getBatchSize() {

return no.length;

}

});

1.3.  BatchSqlUpdate

这一方法适合于各种批量数据的CUD（增、更新、删除）操作，但始终是同一SQL（参数具有多样性）。由于其内部使用了PreparedStatement语句，所以数据的操作效率还是不错的。下面给出了操作示例：

DataSource ds = gbfa.getBean("dataSource");

final int[] no = new int[]{7369,7499,7521,7566,7654,7698};

BatchSqlUpdate bsu = new BatchSqlUpdate(ds, "update emp set sal=? where empno = ?");

bsu.setBatchSize(4);

bsu.setTypes(new int[]{Types.FLOAT, Types.INTEGER});

for(int i = 0; i < no.length; ++i){

log.info(bsu.update(new Object[]{no[i],no[i]})) ;

}

bsu.flush();

同JdbcTemplate内置的batchUpdate(String sql, final BatchPreparedStatementSetter pss)相比，BatchSqlUpdate会自动分批待批量处理的数据。比如，如果需要批量操作10万条数据，则可以控制其batchSize，从而在时间（RDBMS可知性）和空间（内存）上达到平衡。

务必注意，在使用BatchSqlUpdate的最后，不要忘记手工调用其暴露的flush()方法。

HibernateDaoSupport与JdbcDaoSupport的更多相关文章

  1. 使用JDBC批量保存数据（JdbcDaoSupport，JdbcTemplete）

    最近做的一个项目中用到了Hibernate的,然后数据库批量插入数据的时候就使用到了hibernate的批处理,但是效率比较低,看网上说还有一些限制,要禁止二级缓存,还要多一个batch_size的配 ...

  2. HibernateDaoSupport类的使用

    HibernateDaoSupport类的使用 1.        继承了HibernateDaoSupport类的类获取session时,已不可用SessionFactory.OpenSessioo ...

  3. HibernateTemplate和HibernateDaoSupport(spring注入问题)

    HibernateTemplate HibernateTemplate是spring提供的一个就hibernate访问持久层技术而言.支持Dao组件的一个工具.HibernateTemplate提供持 ...

  4. HibernateDaoSupport 源码

    package org.springframework.orm.hibernate3.support; import org.hibernate.HibernateException; import  ...

  5. spring使用JdbcDaoSupport中封装的JdbcTemplate进行query

    1.Dept package cn.hxex.springcore.jdbc; public class Dept { private Integer deptNo; private String d ...

  6. Spring + JdbcTemplate + JdbcDaoSupport examples

    In Spring JDBC development, you can use JdbcTemplate and JdbcDaoSupport classes to simplify the over ...

  7. HibernateDaoSupport的使用

    1.HibernateDaoSupport是有spring提供的一个hibernate模版工具类,或不多说,直接上代码 接口 IGenericDao.java package org.hibernat ...

  8. SessionFactory、HibernateTemplate、HibernateDaoSupport之间的关系说明

    在接触HibernateTemplate之前,我们知道,在对数据库进行CRUD操作之前,需要开启session.transaction等等.在hibernate学习过程中,我们知道了,得到sessio ...

  9. HibernateDaoSupport和HibernateTemplate

    hibernateTemplate的常用方法: Ø  void delete(Object entity):删除指定持久化实例 Ø  deleteAll(Collection entities):删除 ...

随机推荐

  1. Git_工作区和暂存区

    Git和其他版本控制系统如SVN的一个不同之处就是有暂存区的概念. 先来看名词解释. 工作区(Working Directory):就是你在电脑里能看到的目录,比如我的learngit文件夹就是一个工 ...

  2. 工作记录（1）- js问题

    也是好久不写博客了,确实懒了:想想应该把node.js的东西写完整比较好,在抽时间吧: 这几天在做阿里巴巴的一个页面展示,里面设计到了一些js的问题,中途也遇到了一些幼稚的问题, 算是简单记录一下,以 ...

  3. C++源码里没有./configure文件的问题

    使用autoreconf软件来进行生成即可,在命令行输入autoreconf -vi,注意:前提要安装这个软件yum install autoconf.

  4. linux系统编程：线程原语

    线程原语 线程概念 线程(thread),有时被称为轻量级进程(Lightweight Process,LWP).是程序运行流的最小单元.一个标准的线程由线程ID.当前指令指针(PC),寄存器集合和堆 ...

  5. HTML中显示的文字自动换行

    在html中控制自动换行 http://www.cnblogs.com/zjxbetter/articles/1323449.html eg: <table> <tr> < ...

  6. java基础学习总结——多态(动态绑定)

    一.面向对象最核心的机制——动态绑定,也叫多态

  7. EXC_BAD_ACCESS(code=2,address=0xcc 异常解决 及 建议不要在子线程中刷新界面

    iOS 上不建议在非主线程进行UI操作,在非主线程进行UI操作有很大几率会导致程序崩溃,或者出现预期之外的效果. 我开始不知道这一点,在子线程中进行了弹窗操作,结果程序就出问题了! 报的错误是(EXC ...

  8. 【转】利用HTML5开发Android

    ● Android设备多分辨率的问题 Android浏览器默认预览模式浏览 会缩小页面 WebView中则会以原始大小显示 Android浏览器和WebView默认为mdpi.hdpi相当于mdpi的 ...

  9. [Git] An efficient GIT workflow for mid/long term projects

    reference : http://fle.github.io/an-efficient-git-workflow-for-midlong-term-projects.html Our full-w ...

  10. OpenCV学习(25) 直方图(2)

    在OpenCV中,也可以对三通道的图像,比如BGR,HSV等计算直方图.方法和计算单通道图像直方图相似,下面的代码描述了如何计算一个BGR三通道图像的直方图,需要注意的是,因为是三通道,每个通道取值都 ...