Spring + JdbcTemplate + JdbcDaoSupport + HibernateDaoSupport examples

文章摘自以下出处：

http://www.mkyong.com/spring/spring-jdbctemplate-jdbcdaosupport-examples/

http://blog.csdn.net/linwei_1029/article/details/5485890

In Spring JDBC development, you can use JdbcTemplate ,JdbcDaoSupport and HibernateTemplate，HibernateDaoSupport classes to simplify the overall database operation processes.

In this tutorial, we will reuse the last Spring + JDBC example, to see the different between a before (No JdbcTemplate support) and after (With JdbcTemplate support) example.

1. Example Without JdbcTemplate

Witout JdbcTemplate, you have to create many redundant codes (create connection , close connection , handle exception) in all the DAO database operation methods – insert, update and delete. It just not efficient, ugly, error prone and tedious.

	private DataSource dataSource;
 
	public void setDataSource(DataSource dataSource) {
		this.dataSource = dataSource;
	}
 
	public void insert(Customer customer){
 
		String sql = "INSERT INTO CUSTOMER " +
				"(CUST_ID, NAME, AGE) VALUES (?, ?, ?)";
		Connection conn = null;
 
		try {
			conn = dataSource.getConnection();
			PreparedStatement ps = conn.prepareStatement(sql);
			ps.setInt(1, customer.getCustId());
			ps.setString(2, customer.getName());
			ps.setInt(3, customer.getAge());
			ps.executeUpdate();
			ps.close();
 
		} catch (SQLException e) {
			throw new RuntimeException(e);
 
		} finally {
			if (conn != null) {
				try {
					conn.close();
				} catch (SQLException e) {}
			}
		}
	}

2. Example With JdbcTemplate

With JdbcTemplate, you save a lot of typing on the redundant codes, becuase JdbcTemplate will handle it automatically.

	private DataSource dataSource;
	private JdbcTemplate jdbcTemplate;
 
	public void setDataSource(DataSource dataSource) {
		this.dataSource = dataSource;
	}
 
	public void insert(Customer customer){
 
		String sql = "INSERT INTO CUSTOMER " +
			"(CUST_ID, NAME, AGE) VALUES (?, ?, ?)";
 
		jdbcTemplate = new JdbcTemplate(dataSource);
 
		jdbcTemplate.update(sql, new Object[] { customer.getCustId(),
			customer.getName(),customer.getAge()  
		});
 
	}

See the different?

3. Example With JdbcDaoSupport

By extended the JdbcDaoSupport, set the datasource and JdbcTemplate in your class is no longer required, you just need to inject the correct datasource into JdbcCustomerDAO. And you can get the JdbcTemplate by using a getJdbcTemplate() method.

	public class JdbcCustomerDAO extends JdbcDaoSupport implements CustomerDAO
	{
	   //no need to set datasource here
	   public void insert(Customer customer){
 
		String sql = "INSERT INTO CUSTOMER " +
			"(CUST_ID, NAME, AGE) VALUES (?, ?, ?)";
 
		getJdbcTemplate().update(sql, new Object[] { customer.getCustId(),
				customer.getName(),customer.getAge()  
		});
 
	}

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
	http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
 
	<bean id="dataSource" 
         class="org.springframework.jdbc.datasource.DriverManagerDataSource">
 
		<property name="driverClassName" value="com.mysql.jdbc.Driver" />
		<property name="url" value="jdbc:mysql://localhost:3306/mkyongjava" />
		<property name="username" value="root" />
		<property name="password" value="password" />
	</bean>
 
</beans>

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
	http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
 
	<bean id="customerDAO" class="com.mkyong.customer.dao.impl.JdbcCustomerDAO">
		<property name="dataSource" ref="dataSource" />
	</bean>
 
</beans>

Note
In Spring JDBC development, it’s always recommended to use  JdbcTemplate and JdbcDaoSupport, instead of coding JDBC code yourself.

4.HibernateDaoSupport的使用：

一、HibernateDaoSupport是Spring为Hibernate的DAO提供工具类。此类主要提供了两个方法：

1. public final HibernateTemplate getHibernateTemplate() 
2. public final void setSessionFactory(SessionFactory sessionFactory)

其中，setSessionFactory方法接收来自Spring的applicationContext的依赖注入，接收了配置在Spring中的 SessionFactory实例，getHibernateTemplate方法用来利用刚才的SessionFactory生成Session，再生成HibernateTemplate来完成数据库的访问。

 

二. 一个小例子：

 

[java]  view plain copy

1. package test;  
2.   
3. import java.util.List;  
4.   
5. import org.springframework.context.ApplicationContext;  
6. import org.springframework.context.support.ClassPathXmlApplicationContext;  
7. import org.springframework.orm.hibernate3.support.HibernateDaoSupport;  
8.   
9. import cn.ccb.clpm.common.model.bo.documentservice.ObjectDocRelationshipBO;  
10.   
11. public class HibernateDaoSupportTest extends HibernateDaoSupport {  
12.   
13.     public void test1() {  
14.         List list = getHibernateTemplate().find("from ObjectDocRelationshipBO o where o.relationId = 1000000068");  
15.         System.out.println(((ObjectDocRelationshipBO)list.get(0)).getCustomerNum());  
16.     }  
17.   
18.     public static void main(String[] args) {  
19.         ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext-daoSupport-test.xml");  
20.         HibernateDaoSupportTest t = (HibernateDaoSupportTest)ac.getBean("test");  
21.         t.test1();  
22. //      t.getHibernateTemplate().save((ObjectDocRelationshipBO)list.get(0));  
23.           
24.     }  
25.   
26. }  

 

配置文件：

[xhtml]  view plain copy

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">  
3. <beans>  
4.          
5.         <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">  
6.         <property name="dataSource">  
7.             <ref bean="jndiDataSource"/>  
8.         </property>  
9.         <property name="hibernateProperties">  
10.             <props>  
11.                 <prop key="hibernate.dialect">  
12.                     org.hibernate.dialect.Oracle9Dialect  
13.                 </prop>  
14.                 <prop key="hibernate.show_sql">  
15.                     true  
16.                 </prop>  
17.                 <prop key="hibernate.format_sql">  
18.                     true  
19.                 </prop>  
20.                 <prop key="hibernate.query.factory_class">  
21.                      org.hibernate.hql.classic.ClassicQueryTranslatorFactory  
22.                 </prop>  
23.             </props>  
24.         </property>  
25.         <property name="mappingResources">  
26.             <list>  
27.                <value>/cn/ccb/clpm/common/model/bo/documentservice/DocIndexBO.hbm.xml</value>  
28.                <value>/cn/ccb/clpm/common/model/bo/documentservice/ObjectDocRelationshipBO.hbm.xml</value>  
29.                <value>/cn/ccb/clpm/common/model/bo/documentservice/RawMaterialBO.hbm.xml</value>  
30.             </list>     
31.         </property>  
32.              
33.         </bean>  
34.           
35.         <bean id="test" class="test.HibernateDaoSupportTest">  
36.                 <property name="sessionFactory">  
37.                      <ref bean="sessionFactory"/>  
38.                 </property>  
39.         </bean>  
40.   
41.     <bean id="jndiDataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">  
42.         <property name="driverClassName">  
43.             <value>oracle.jdbc.driver.OracleDriver</value>  
44.         </property>  
45.         <property name="url">  
46.             <value>jdbc:oracle:thin:@128.64.96.28:1521:clpmkfdb</value>  
47.         </property>  
48.         <property name="username">  
49.             <value>clpmtest</value>  
50.         </property>  
51.         <property name="password">  
52.             <value>clpmtest</value>  
53.         </property>  
54.     </bean>     
55.   
56. </beans>  

 

这个过程中，其实DAO的实现依然借助了HibernateTemplate的模板访问方式。只是，HibernateDaoSupport将依赖注入 SessionFactory的工作已经完成，获取HibernateTemplate的工作也已经完成。注意，这种方法须在Spring的配置文件中配置SessionFactory。

在继承HibrnateDaoSupport的DAO实现里，Hibernate Session的管理完全不需要Hibernate代码打开，而由Spring来管理。Spring会根据实际的操作，采用“每次事务打开一次 session”的策略，自动提高数据库访问的性能。

5. 总结

Spring 通过JdbcDaoSupport 和 HibernateDaoSupport 工具类， 很好的封装了数据库访问需要的数据源， 事物管理， 例外管理等一切配置管理工作。 另外，通过JdbcTemplate , HibernateTemplate 封装了一切数据库操作， 简化了通过数据源， 获得连接， 取得session, 创建sql statement, 然后进行CRUD操作等一系列复杂过程。

总而言之， 通过以上工具类， Spring 很好的完成了JDBC数据库访问和Hibernate数据库访问的封装和集成。

另外：

1）借助JdbcDaoSupport这个类不需要HIbernate框架，也不需要有ORM的对象关联映射。但它和HibernateDaoSupport很类似，有JdbcTemplate来实现增、删、改、查操作.

2）其中还有点区别就是: HibernateDaoSupport是使用HQL语言来查询的，而JdbcDaoSupport则是使用SQL来查询，可以

更加简单方便的使用我们平常的SQL来操作数据库.