Spring对JDBC的DAO支持

    Spring提供JdbcDaoSupport来实现对JDBC的DAO支持。在JdbcDaoSupport类中提供了两个方法，分别是：

        void setDataSource(DataSource dataSource) :采用setter依赖注入来设置数据源

        getJdbcTemplate():获得JdbcTemplate来执行CRUD操作。

    下面举例来详细说明：

    假设有一个名为dao的数据库，数据库中有一个student表，表中的字段为id,name,sex

    1、首先创建一个JavaBean来作为数据传输对象：

    StudentBean.java

1. package bean;
3. public class StudentBean {
4.     
5.     private int id;
6.     
7.     private String name;
8.     
9.     private String sex;
10.     
11.     public StudentBean() {
12.         
13.     }
15.     public StudentBean(int id, String name, String sex) {
16.         super();
17.         this.id = id;
18.         this.name = name;
19.         this.sex = sex;
20.     }
22.     public int getId() {
23.         return id;
24.     }
26.     public void setId(int id) {
27.         this.id = id;
28.     }
30.     public String getName() {
31.         return name;
32.     }
34.     public void setName(String name) {
35.         this.name = name;
36.     }
38.     public String getSex() {
39.         return sex;
40.     }
42.     public void setSex(String sex) {
43.         this.sex = sex;
44.     }
45. }

    2、编写DAO接口

    StudentDao.java

1. package dao;
3. import bean.StudentBean;
5. public interface StudentDao {
6.     
7.     /**
8.      * 根据传入的StudentBean实例插入记录
9.      * @param s 需要保存的StudentBean实例
10.      */
11.     void createStudent(StudentBean s) throws Exception;
12.     
13.     /**
14.      * 根据传入的id属性，查找匹配名字字符串的StudentBean实例
15.      * @param id 需要查找StudentBean的id
16.      * @return 匹配名字字符串的StudentBean实例
17.      */
18.     StudentBean getStudent(int id) throws Exception;
19.     
20.     /**
21.      * 根据传入的name属性，删除记录
22.      * @param name 需要删除的StudentBean的name
23.      */
24.     void deleteStudent(String name) throws Exception;
25.     
26.     /**
27.      * 根据传入的StudentBean实例更新对应的记录
28.      * @param s 需要更新的StudentBean实例
29.      */
30.     void updateStudent(StudentBean s) throws Exception;
31. }

    3、编写DAO接口的实现类，继承了JdbcDaoSupport

    StudentDaoJdbc.java

 

1. package dao;
3. import java.sql.ResultSet;
4. import java.sql.SQLException;
6. import org.springframework.jdbc.core.RowMapper;
7. import org.springframework.jdbc.core.support.JdbcDaoSupport;
9. import bean.StudentBean;
11. public class StudentDaoJdbc extends JdbcDaoSupport implements StudentDao {
13.     public void createStudent(StudentBean s) throws Exception {
14.         Object[] args = {new Integer(s.getId()),s.getName(),s.getSex()};
15.         String sql = "insert into student(id,name,sex) values(?,?,?)";
16.         //获得JdbcTemplate对象，并调用update方法对数据库进行操作
17.         this.getJdbcTemplate().update(sql,args);
18.     }
20.     public void deleteStudent(String name) throws Exception {
21.         Object[] args = {name};
22.         String sql = "delete from student where name = ?";
23.         this.getJdbcTemplate().update(sql, args);
24.     }
26.     public StudentBean getStudent(int id) throws Exception {
27.         Object[] args = {new Integer(id)};
28.         String sql = "select id,name,sex from student where id = ?";
29.         
30.         //将查询的ResultSet包装成对象后返回
31.         return (StudentBean)getJdbcTemplate().queryForObject(sql,args,new StudentRowMapper());
32.     }
34.     public void updateStudent(StudentBean s) throws Exception {
35.         Object[] args = {s.getName(),s.getSex(),new Integer(s.getId())};
36.         String sql = "update student set name = ?,sex = ? where id = ?";
37.         this.getJdbcTemplate().update(sql, args);
39.     }
40.     
41.     /**
42.      * @author Administrator
43.      * 私有内部类
44.      * 继承了RowMapper接口
45.      * 用于将ResultSet包装成相应的值对象后返回
46.      */
47.     private class StudentRowMapper implements RowMapper {
48.         public Object mapRow(ResultSet rs,int rowNumber) throws SQLException {
49.             StudentBean sb = new StudentBean(rs.getInt("id"),rs.getString("name"),rs.getString("sex"));
50.             return sb;
51.         }
52.     }
54. }

    4、最后描述配置文件（包括对数据源的配置，并将数据源对象注入到StudentDaoJdbc实例中）

    applicationContext.xml

 

1. <?xml version="1.0" encoding="GB2312"?>
3. <beans xmlns="http://www.springframework.org/schema/beans"
4.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
5.          xmlns:aop="http://www.springframework.org/schema/aop"
6.          xmlns:tx="http://www.springframework.org/schema/tx"
7.          xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
8.            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
9.            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd">
10.     <!-- 配置dbcp数据源 -->
11.     <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
12.         <property name="driverClassName">
13.             <value>com.mysql.jdbc.Driver</value>
14.         </property>
15.         <property name="url">
16.             <value>jdbc:mysql://localhost:3306/dao</value>
17.         </property>
18.         <property name="username">
19.             <value>root</value>
20.         </property>
21.         <property name="password">
22.             <value>4231992</value>
23.         </property>
24.     </bean>
25.     <!-- 配置用户的DAO bean -->
26.     <bean id="studentDao" class="dao.StudentDaoJdbc">
27.         <!-- 为DAO实例注入所需的DataSource实例，采用setter注入，setter方法位于StudentDaoJdbc的父类JdbcDaoSupport中 -->
28.         <property name="dataSource">
29.             <ref local="dataSource"/>
30.         </property>
31.     </bean>
32. </beans>

    通过测试，我们可以看到通过Spring实现的DAO，代码简洁，不需要频繁地进行数据库连接和捕获异常，也不需要创建DAO工厂，而是由Spring自动地管理DAO实例的创建。