`
riyunzhu
  • 浏览: 30027 次
  • 性别: Icon_minigender_1
  • 来自: 杭州
文章分类
社区版块
存档分类
最新评论

HibernateDaoSupport与JdbcDaoSupport

 
阅读更多

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>

二、编程式事务管理、声明式事务管理中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()方法。

本文转载自：http://www.cnblogs.com/liuzheng-java/articles/2100071.html

分享到：
| 浅谈oracle中的几个日期函数
评论
发表评论

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

相关推荐

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

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

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

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

    Jdbcsupport培训 详细讲解jdbcsupport

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

    Spring持久化模板总结

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

    spring和数据库层的结合

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

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

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

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

    在Java的Spring框架中，DAO（Data Access Object）数据访问对象是一种设计模式，用于封装数据库操作，使得业务逻辑层与数据存储层之间解耦。Spring框架提供了对DAO的支持，包括与JDBC、Hibernate、JDO和JPA等不同...

    spring3.x的读书笔记-5

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

    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