JDBCTemplate---方法介绍和简单示例

当sql等查询方式不能满足性能或灵活性的要求，必须使用SQL时，大家有三种选择：

第一、使用Hibernate 的sql 查询函数，将查询结果对象转为Entity对象。

第二、使用Hibernate Session的getConnection 获得JDBC Connection，然后进行纯JDBC API操作；

第三、选择把Spring的JDBCTemplate作为一种很不错的JDBC Utils来使用。

 /*使用jdbcTemplate查询数据的时候可以使用queryForXXX等方法。下面我们就一一解析一下：*/
 1、jdbcTemplate.queryForInt()和jdbcTemplate.queryForLong()
 //使用queryForInt返回user表中的记录数量，queryForInt搭配这样的sql可以在分页的时候计算总记录数
 jdbcTemplate.queryForInt("select count(*) from user");

 2、jdbcTemplate.queryForObject()
 //本质上和queryForInt相同，只是可以返回不同的对象,例如返回一个String对象
 String name = (String) jdbcTemplate.queryForObject(  --3个参数: 1、sql 2、要传递的参数数组 3、返回来的对象class
 "SELECT name FROM USER WHERE id = ?",
 new Object[] {id},
 java.lang.String.class);

 3、jdbcTemplate.queryForList(???)
 //返回一个装有map的list,每一个map是一条记录,map里面的key是字段名
 List rows = jdbcTemplate.queryForList("SELECT * FROM user");  //得到装有map的list
 for(int i=0;i<rows.size();i++){                   //遍历
 Map userMap=rows.get(i);
 System.out.println(userMap.get("id"));
 System.out.println(userMap.get("name"));
 System.out.println(userMap.get("age"));
 }


 4、jdbcTemplate.queryForMap(SQL)
 //这个查询只能是查询一条记录的查询,返回一个map,key的值是column的值
 Map map = jdbcTemplate.queryForMap("select count(*) as keyval from user");
 map.get("keyval")


 5、jdbcTemplate.queryForRowSet(???)
 //返回一个RowSet   然后调用.getString或者getInt等去取值




 6、jdbc1.query(sql, new RowCallbackHandler()
 //返回一个ResultSet对象， processRow有自动循环的机制，它会自动执行processRow中的语句直到
 //rs的size执行完了为止。我们可以在这其中用list完成对象的转移，只不过list要用final来修饰
 jdbc1.query(sql, new RowCallbackHandler() { //editing
             public void processRow(ResultSet rs) throws SQLException {
         VideoSearch vs = new VideoSearch();
         vs.setRECORDINGFILENAME(rs.getString("RECORDINGFILENAME"));
         vs.setCALLID(rs.getString("CALLID"));
         list.add(vs);

     }
     }
 7.更新操作
 //执行sql语句，无返回执，可用于插入等操作
 jdbcTemplate.execute(sql);

 //更新操作，返回受影响的行数
 jdbcTemplate.update(strSql.toString());
 //执行批量更新，参数为string数组
 jdbcTemplate.batchUpdate(sql);
 //更新，args为对象数组
 jdbcTemplate.update(strSql, args);

 /*
 说明：
 JDBCTemplate的使用方法:
 在ApplicationContext.xml中定义一个jdbcTemplate的节点，使用POJO注入,获得注入后可以执行操作
 不需要继承什么基类
 */
 <bean id="jdbcTemplate"
 class="org.springframework.jdbc.core.JdbcTemplate">
       <property name="dataSource" ref="dataSource"/>
 </bean>

 SqlRowSet rs = jdbcTemplate.queryForRowSet(sql, params);
 /*
 jdbcTemplate有很多的ORM化回调操作将返回结果转为对象列表，
 但很多时候还是需要返回ResultSet，Spring有提供一个类似ResultSet的，实现JDBC3.0 RowSet接口的Spring SqlRowSet
 注意
 jdbcTemplate尽量只执行查询操作，莫要进行更新，否则会破坏Hibernate的二级缓存体系
 */

以下转载。

1. Spring的基本概念

       Spring框架核心的思想就是建立一个Java对象的大工厂，用户只要给工厂一个指令，工厂就能将用户需要的对象根据配置文件组装好返还给用户。用户需要做的许多工作则可以写成简单的配置文件。

2. 丑陋的JDBC代码

01 Connection con = null;
02 PreparedStatement pStmt = null;
03 ResultSet rs = null;
04 try {
05      con = ods.getConnection();
06      String sql = "select * from admin";
07      pStmt = con.prepareStatement(sql);
08      rs = pStmt.executeQuery();
09      while (rs.next()) {
10      }
11 } catch (Exception ex) {
12      try {
13           con.rollback();
14      } catch (SQLException sqlex) {
15           sqlex.printStackTrace(System.out);
16      }
17      ex.printStackTrace();
18
19 } finally {
20      try {
21           rs.close();
22           pStmt.close();
23           con.close();
24      } catch (Exception e) {
25           e.printStackTrace();
26      }
27 }

 

以上是常见的JDBC代码，简单的select语句也需要冗长的出错处理，并且每个函数都不断地重复同样的代码。

 

3. JdbcTemplate的作用

       JdbcTemplate正是为了减少上述繁琐的代码而设计出来的。它是对JDBC的一种封装，抽象我们常用的一些方法。Simple and Stupid就是它的目标。下面是完成了刚才JDBC代码同样功能的JdbcTemplate的代码：

1 String sql = "select * from admin";
2
3 jdbcTemplate.query(sql,new RowCallbackHandler() {
4
5          public void processRow(ResultSet rs) throws SQLException {
6
7                 }
8
9             } );

 

 

环境搭建：

1. 数据库的配置

      本文使用Mysql数据库，新建表admin：

1 CREATE TABLE `admin` (
2   `ID` bigint(20) unsigned NOT NULL auto_increment,
3   `NAME` varchar(100) NOT NULL,
4   `PASSWORD` varchar(200) NOT NULL,
5   PRIMARY KEY  (`ID`)
6 ) ENGINE=InnoDB DEFAULT CHARSET=utf8

 

  2. Spring配置

       JdbcTemplate的使用需要有DataSource的支持，所以在配置文件中，我们首先要配置一个OracleDataSource，然后在将这个DataSource配置到JdbcTemplate里。接着将JdbcTemplate配置进DAO层，最后将DAO配置进Model层。简要的关系如下：

 

 

01 <?xml version="1.0" encoding="UTF-8"?>
02 <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
03     "http://www.springframework.org/dtd/spring-beans.dtd">
04 <beans>
05     <bean id="dataSource"
06         class="org.springframework.jdbc.datasource.DriverManagerDataSource">
07         <property name="driverClassName" value="com.mysql.jdbc.Driver" />
08         <property name="url" value="jdbc:mysql://localhost:3306/zuidaima_admin?useUnicode=true&amp;characterEncoding=utf-8" />
09         <property name="username" value="root" />
10         <property name="password" value="111111" />
11     </bean>
12
13     <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
14         <property name="dataSource">
15             <ref bean="dataSource" />
16         </property>
17     </bean>
18
19     <bean id="userDao" class="com.zuidaima.dao.impl.UserDaoImpl">
20         <property name="jdbcTemplate">
21             <ref bean="jdbcTemplate" />
22         </property>
23     </bean>
24
25     <bean id="user" class="com.zuidaima.model.User">
26         <property name="dao">
27             <ref bean="userDao" />
28         </property>
29     </bean>
30
31 </beans>

 

 

3. 项目截图：

      

 

使用方法：

1.查找

多行查询：

01 class UserRowMapper implements RowMapper {
02
03         public Object mapRow(ResultSet rs,int index) throws SQLException
04
05         {
06
07             User u = new User();
08
09             u.setId(rs.getString("ID"));
10
11             u.setName(rs.getString("Name"));
12
13             u.setPassword(rs.getString("Password"));
14
15             return u;
16
17         }
18
19     }
20
21 public List select(String where)
22
23     {
24
25         List list;
26
27         String sql = "select * from admin "+where;
28
29         list = jdbcTemplate.query(sql,new RowMapperResultReader(new UserRowMapper()));
30
31         return list;
32
33     }

 

 

List最终返回的是满足条件的User队列。

 

单行查询：

01 public User selectById(String id){
02
03     String sql = "select * from admin where id=?";
04
05     final User u = new User();
06
07     final Object[] params = new Object[] {id};
08
09     jdbcTemplate.query(sql, params, new RowCallbackHandler(){
10
11                         public void processRow(ResultSet rs) throws SQLException {
12
13                                  u.setId(rs.getString("ID"));
14
15                                  u.setName(rs.getString("NAME"));
16
17                                  u.setPassword(rs.getString("PASSWORD"));
18
19                         }
20
21     });
22
23     return u;
24
25 }

 

 

2.      插入

01 public void insert(User u)
02
03 {
04
05      String sql = "insert into admin (ID,NAME,PASSWORD) values (admin_id_seq.nextval,?,?)";
06
07      Object[] params = new Object[] {
08
09                                                 u.getName(),
10
11                                                 u.getPassword() };
12
13      jdbcTemplate.update(sql,params);
14
15 }

 

admin_id_seq.nextval为Oracle设置好的序列，问号“?”被params里的数据依次替代，最终执行sql。

 

3.       修改

非常简单：

1 public void update(String how)
2
3 {
4
5         jdbcTemplate.update(how);
6
7     }

 

 

运行截图

数据库截图