使用Spring JDBCTemplate简化JDBC的操作

发布时间：2021-07-06 06:03:45 所属栏目：大数据来源： https://www.jb51.cc

导读：接触过JAVA WEB开发的朋友肯定都知道Hibernate框架，虽然不否定它的强大之处，但个人对它一直无感，总感觉不够灵活，太过臃肿了。今天来说下Spring中关于JDBC的一个辅助类(JDBC Template)，它封装了JDBC的操作，使用起来非常方便。 ? 先说下"傻瓜式"的使用

接触过JAVA WEB开发的朋友肯定都知道Hibernate框架，虽然不否定它的强大之处，但个人对它一直无感，总感觉不够灵活，太过臃肿了。

今天来说下Spring中关于JDBC的一个辅助类(JDBC Template)，它封装了JDBC的操作，使用起来非常方便。

先说下"傻瓜式"的使用（不依赖于xml配置）：

直接写个测试单元：

 1 package com.lcw.spring.jdbc;
 2 
 3 import org.junit.Test;
 4  org.springframework.jdbc.core.JdbcTemplate;
 5  org.springframework.jdbc.datasource.DriverManagerDataSource;
 6 
 7 public class JDBCTemplate {
 8     
 9     @Test
10     void demo(){
11         DriverManagerDataSource dataSource=new DriverManagerDataSource();
12         dataSource.setDriverClassName("com.MysqL.jdbc.Driver");
13         dataSource.setUrl("jdbc:MysqL:///spring"14         dataSource.setUsername("root"15         dataSource.setPassword(""16         
17         JdbcTemplate jdbcTemplate= JdbcTemplate(dataSource);
18         jdbcTemplate.execute("create table temp(id int primary key,name varchar(32))"19     
20     }
21 
22 }

很简单吧，再来看下使用结合配置文件，完整的实现对一个类的增删改查

首先DEMO目录结构：

appliactionContext.xml

<?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3        xmlns:p="http://www.springframework.org/schema/p"
 4        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 5        xsi:schemaLocation="
 6 http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
 7     
 8     <!--数据源的配置 -->
 9     bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource"10         property name="driverClassName" value="com.MysqL.jdbc.Driver"></property11         ="url"="jdbc:MysqL:///spring"12         ="username"="root"13         ="password"=""14     </bean15     
16     
17 　　
18     ="jdbcTemplate"="org.springframework.jdbc.core.JdbcTemplate"19          ref="dataSource"20     21     
22     
23     ="userDao"="com.curd.spring.impl.UserDAOImpl"24         ="jdbcTemplate"25     26 
27 
28 
29 beans>

接口：IUserDAO.java

 com.curd.spring.dao;
 java.util.List;
 4 
 com.curd.spring.vo.User;
interface IUserDAO {
 8 
 addUser(User user);
10 
11     void deleteUser(int id);
12 
13      updateUser(User user);
14 
15     public String searchUserName(17     public User searchUser(18     
19     public List<User> findAll();
20 
21 }

接口实现类：UserDAOImpl.java

按照以往Spring的依赖注入，我们需要在接口实现类中利用构造器去获取JdbcTemplate

Spring早就帮我们想到了这点，它为我们提供了JdbcDaoSupport支持类，所有DAO继承这个类，就会自动获得JdbcTemplate（前提是注入DataSource）。

1     2         3     4     
5     
6     7         8     >

在我们的实现类中直接利用getJdbcTemplate就可以获取操作对象了。

JdbcTemplate主要提供下列方法：

　　1、execute方法：可以用于执行任何sql语句，一般用于执行DDL语句；

　　2、update方法及batchUpdate方法：update方法用于执行新增、修改、删除等语句；batchUpdate方法用于执行批处理相关语句；

　　3、query方法及queryForXXX方法：用于执行查询相关语句；

　　4、call方法：用于执行存储过程、函数相关语句。

 com.curd.spring.impl;
 java.sql.ResultSet;
 java.sql.sqlException;
 org.springframework.jdbc.core.RowMapper;
 8  org.springframework.jdbc.core.support.JdbcDaoSupport;
 com.curd.spring.dao.IUserDAO;
10 11 
12 class UserDAOImpl extends JdbcDaoSupport implements13 
 addUser(User user) {
15         String sql = "insert into user values(?,?,?)";
16         this.getJdbcTemplate().update(sql,user.getId(),user.getUsername(),17                 user.getPassword());
18 19 
 id) {
21         String sql = "delete from user where id=?"22         23 
24 25 
26      updateUser(User user) {
27         String sql = "update user set username=?,password=? where id=?"28                         user.getPassword(),user.getId());
30 31 
32     int id) {// 简单查询，按照ID查询，返回字符串
33         String sql = "select username from user where id=?"34          返回类型为String(String.class)
35         return this.getJdbcTemplate().queryForObject(sql,String.,1)">36 
37 38 
39     public List<User> findAll() { 复杂查询返回List集合
40         String sql = "select * from user"41         this.getJdbcTemplate().query(sql, UserRowMapper());
42 
43 44 
45     46         String sql="select * from user where id=?"47          UserRowMapper(),1)">48 49 
50     class UserRowMapper implements RowMapper<User> {
51 　　　　　//rs为返回结果集，以每行为单位封装着
52         public User mapRow(ResultSet rs,1)">int rowNum) throws sqlException {
53     
54             User user =  User();
55             user.setId(rs.getInt("id"));
56             user.setUsername(rs.getString("username"57             user.setPassword(rs.getString("password"58             return user;
59         }
60 
61 62 
63 }

测试类：UserTest.java

 com.curd.spring.test;
 org.springframework.context.ApplicationContext;
 org.springframework.context.support.ClassPathXmlApplicationContext;
 UserTest {
13     
14     @Test增
 demo1(){
16         User user=17         user.setId(318         user.setUsername("admin"19         user.setPassword("123456"20         
21         ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml"22         IUserDAO dao=(IUserDAO) applicationContext.getBean("userDao"23         dao.addUser(user);
24         
25 26     
27     @Test改
28      demo2(){
29         User user=30         user.setId(131         user.setUsername("admin"32         user.setPassword("admin"33         
34         ApplicationContext applicationContext=35         IUserDAO dao=(IUserDAO) applicationContext.getBean("userDao"36         dao.updateUser(user);
38     
39     @Test删
40      demo3(){
41         ApplicationContext applicationContext=42         IUserDAO dao=(IUserDAO) applicationContext.getBean("userDao"43         dao.deleteUser(344 45     
46     @Test查（简单查询，返回字符串）
47      demo4(){
48         ApplicationContext applicationContext=49         IUserDAO dao=(IUserDAO) applicationContext.getBean("userDao"50         String name=dao.searchUserName(151         System.out.println(name);
52 54     @Test查（简单查询，返回对象）
55      demo5(){
56         ApplicationContext applicationContext=57         IUserDAO dao=(IUserDAO) applicationContext.getBean("userDao"58         User user=dao.searchUser(1        System.out.println(user.getUsername());
60 61     
62     @Test查（复杂查询，返回对象集合）
63      demo6(){
64         ApplicationContext applicationContext=65         IUserDAO dao=(IUserDAO) applicationContext.getBean("userDao"66         List<User> users=dao.findAll();
67         System.out.println(users.size());
68 69     
70     
71 
72 }

怎么样，很简单吧，在不缺JDBC里sql的灵活操作又去除了繁杂操作~

附：

1、Spring 为每种持久化技术提供一个支持类，在DAO 中注入模板工具类
　　　　（1）JDBC ： org.springframework.jdbc.core.support.JdbcDaoSupport
　　　　（2）Hibernate 3.0 ：org.springframework.orm.hibernate3.support.HibernateDaoSupport
　　　　（3）iBatis ：org.springframework.orm.ibatis.support.sqlMapClientDaoSupport

用户自己编写DAO 只需要继承 JdbcDaoSupport，就可以注入 JdbcTemplate

2、通过jdbcTemplate 提供 int update(String sql,Object... args) 实现增加、修改、删除

3、简单查询，返回原始数据类型， String类型
String sql = "select count(*) from user"; // int queryForInt(String sql)
String sql = "select name from user where id = ? "; // <T> T queryForObject(String sql,Class<T> requiredType,Object... args)

4、复杂查询
JdbcTemplate 没有handler，手动完成对象封装

编写实体类 RowMapper
class UserRowMapper implements RowMapper<User> {
　　@Override
　　public User mapRow(ResultSet rs,int rowNum) throws sqlException {
　　　　// rs 已经指向每一条数据，不需要自己调用 next，将rs指向数据转换 User对象
　　　　User user = new User();
　　　　user.setId(rs.getInt("id"));
　　　　user.setName(rs.getString("name"));
　　　　return user;
　　}
}

查询单个对象 <T> T queryForObject(String sql,RowMapper<T> rowMapper,Object... args)
return this.getJdbcTemplate().queryForObject(sql,new UserRowMapper(),id);

查询所有对象List集合 <T> List<T> query(String sql,Object... args)
return this.getJdbcTemplate().query(sql,new UserRowMapper());

以上提供的方法基本可以满足我们的日常需要了。

（编辑：北几岛）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!