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

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

先说下"傻瓜式"的使用(不依赖于xml配置):

直接写个测试单元:

 1 package com.lcw.spring.jdbc;
 2
 3 import org.junit.Test;
 4 import org.springframework.jdbc.core.JdbcTemplate;
 5 import org.springframework.jdbc.datasource.DriverManagerDataSource;
 6
 7 public class JDBCTemplate {
 8
 9     @Test
10     public 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=new JdbcTemplate(dataSource);
18         jdbcTemplate.execute("create table temp(id int primary key,name varchar(32))");
19
20     }
21
22 }

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

首先DEMO目录结构:

appliactionContext.xml

 1 <?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"></property>
11         <property name="url" value="jdbc:mysql:///spring"></property>
12         <property name="username" value="root"></property>
13         <property name="password" value=""></property>
14     </bean>
15
16
17   
18     <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
19         <property name="dataSource" ref="dataSource"></property>
20     </bean>
21
22
23     <bean id="userDao" class="com.curd.spring.impl.UserDAOImpl">
24         <property name="jdbcTemplate" ref="jdbcTemplate"></property>
25     </bean>
26
27
28
29 </beans>

接口:IUserDAO.java

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

接口实现类:UserDAOImpl.java

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

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

1     <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
2         <property name="dataSource" ref="dataSource"></property>
3     </bean>
4
5
6     <bean id="userDao" class="com.curd.spring.impl.UserDAOImpl">
7         <property name="jdbcTemplate" ref="jdbcTemplate"></property>
8     </bean>

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

JdbcTemplate主要提供下列方法:

  1、execute方法:可以用于执行任何SQL语句,一般用于执行DDL语句;

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

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

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

 1 package com.curd.spring.impl;
 2
 3 import java.sql.ResultSet;
 4 import java.sql.SQLException;
 5 import java.util.List;
 6
 7 import org.springframework.jdbc.core.RowMapper;
 8 import org.springframework.jdbc.core.support.JdbcDaoSupport;
 9 import com.curd.spring.dao.IUserDAO;
10 import com.curd.spring.vo.User;
11
12 public class UserDAOImpl extends JdbcDaoSupport implements IUserDAO {
13
14     public void addUser(User user) {
15         String sql = "insert into user values(?,?,?)";
16         this.getJdbcTemplate().update(sql, user.getId(), user.getUsername(),
17                 user.getPassword());
18     }
19
20     public void deleteUser(int id) {
21         String sql = "delete from user where id=?";
22         this.getJdbcTemplate().update(sql, id);
23
24     }
25
26     public void updateUser(User user) {
27         String sql = "update user set username=?,password=? where id=?";
28         this.getJdbcTemplate().update(sql, user.getUsername(),
29                 user.getPassword(), user.getId());
30     }
31
32     public String searchUserName(int id) {// 简单查询,按照ID查询,返回字符串
33         String sql = "select username from user where id=?";
34         // 返回类型为String(String.class)
35         return this.getJdbcTemplate().queryForObject(sql, String.class, id);
36
37     }
38
39     public List<User> findAll() {// 复杂查询返回List集合
40         String sql = "select * from user";
41         return this.getJdbcTemplate().query(sql, new UserRowMapper());
42
43     }
44
45     public User searchUser(int id) {
46         String sql="select * from user where id=?";
47         return this.getJdbcTemplate().queryForObject(sql, new UserRowMapper(), id);
48     }
49
50     class UserRowMapper implements RowMapper<User> {
51      //rs为返回结果集,以每行为单位封装着
52         public User mapRow(ResultSet rs, int rowNum) throws SQLException {
53
54             User user = new 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

 1 package com.curd.spring.test;
 2
 3 import java.util.List;
 4
 5 import org.junit.Test;
 6 import org.springframework.context.ApplicationContext;
 7 import org.springframework.context.support.ClassPathXmlApplicationContext;
 8
 9 import com.curd.spring.dao.IUserDAO;
10 import com.curd.spring.vo.User;
11
12 public class UserTest {
13
14     @Test//增
15     public void demo1(){
16         User user=new User();
17         user.setId(3);
18         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     public void demo2(){
29         User user=new User();
30         user.setId(1);
31         user.setUsername("admin");
32         user.setPassword("admin");
33
34         ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
35         IUserDAO dao=(IUserDAO) applicationContext.getBean("userDao");
36         dao.updateUser(user);
37     }
38
39     @Test//删
40     public void demo3(){
41         ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
42         IUserDAO dao=(IUserDAO) applicationContext.getBean("userDao");
43         dao.deleteUser(3);
44     }
45
46     @Test//查(简单查询,返回字符串)
47     public void demo4(){
48         ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
49         IUserDAO dao=(IUserDAO) applicationContext.getBean("userDao");
50         String name=dao.searchUserName(1);
51         System.out.println(name);
52     }
53
54     @Test//查(简单查询,返回对象)
55     public void demo5(){
56         ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
57         IUserDAO dao=(IUserDAO) applicationContext.getBean("userDao");
58         User user=dao.searchUser(1);
59         System.out.println(user.getUsername());
60     }
61
62     @Test//查(复杂查询,返回对象集合)
63     public void demo6(){
64         ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
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, RowMapper<T> rowMapper, Object... args)
return this.getJdbcTemplate().query(sql, new UserRowMapper());

JDBCTemplate简化JDBC的操作(一)的更多相关文章

  1. 使用Spring JDBCTemplate简化JDBC的操作

    使用Spring JDBCTemplate简化JDBC的操作 接触过JAVA WEB开发的朋友肯定都知道Hibernate框架,虽然不否定它的强大之处,但个人对它一直无感,总感觉不够灵活,太过臃肿了. ...

  2. JDBCTemplate简化JDBC的操作(二)

    一.Spring对不同的持久化支持: Spring为各种支持的持久化技术,都提供了简单操作的模板和回调 ORM持久化技术 模板类 JDBC org.springframework.jdbc.core. ...

  3. JDBCTemplate简化JDBC的操作(三)需要注意的地方

    一,代码 List<String> cols = orgJdbcTemplate .queryForList( "SELECT COLUMN_NAME FROM informat ...

  4. 使用JdbcTemplate简化JDBC操作 实现数据库操作

    使用Spring JDBC框架方遍简单的完成JDBC操作,满足性能的需求且灵活性高. Spring JDBC框架由4个部分组成,即core.datasource.object.support. org ...

  5. [原创]java WEB学习笔记109:Spring学习---spring对JDBC的支持:使用 JdbcTemplate 查询数据库,简化 JDBC 模板查询,在 JDBC 模板中使用具名参数两种实现

    本博客的目的:①总结自己的学习过程,相当于学习笔记 ②将自己的经验分享给大家,相互学习,互相交流,不可商用 内容难免出现问题,欢迎指正,交流,探讨,可以留言,也可以通过以下方式联系. 本人互联网技术爱 ...

  6. 使用元数据简化jdbc代码---查询操作(用到反射)

    使用元数据简化jdbc代码---查询操作(用到反射) 一  思路分析 简化就是把共同的地方提取出来并放到一个方法里,在用到时只要调用就ok了,上一篇介绍了更新的操作,而查询的操作相对来说比较复杂,因为 ...

  7. springboot之整合基本的jdbc并操作Mysql数据库

    对于数据访问层,无论是SQL还是NOSQL,springboot默认采用整合spring data方式进行统一处理,添加大量自动配置,屏蔽了许多设置,引入各种xxxTemplate,xxxReposi ...

  8. DbUtils是Apache出品一款简化JDBC开发的工具类

    DbUtils     - DbUtils是Apache出品一款简化JDBC开发的工具类     - 使用DbUtils可以让我们JDBC的开发更加简单     - DbUtils的使用:       ...

  9. 深入浅出学习Hibernate框架(二):JDBC基础操作

    上篇博客<深入浅出学习Hibernate框架(一):从实例入手初识Hibernate框架>简单介绍了一下Hibernate框架,并且举了一个实例来了解Hibernate.这篇博客将介绍JD ...

随机推荐

  1. BZOJ 2467: [中山市选2010]生成树 [组合计数]

    2467: [中山市选2010]生成树 Time Limit: 5 Sec  Memory Limit: 128 MBSubmit: 638  Solved: 453[Submit][Status][ ...

  2. python 闯关之路一(语法基础)

    1,什么是编程?为什么要编程? 答:编程是个动词,编程就等于写代码,那么写代码是为了什么呢?也就是为什么要编程呢,肯定是为了让计算机帮我们搞事情,代码就是计算机能理解的语言. 2,编程语言进化史是什么 ...

  3. SDN第五次上机作业

    作业链接 1.建立拓扑,并连接上ODL控制器. 2.利用ODL下发组表.流表,实现建议负载均衡 查看s2接收的数据包都被drop掉了 在s1中下发组表 在s1中下发流表使组表生效 下发流表覆盖S2中d ...

  4. 插上腾飞的翅膀:为asp.net core添加protobuf支持

    没时间解释了,快上车. 通过NuGet获取Zaabee.AspNetCoreProtobuf Install-Package Zaabee.AspNetCoreProtobuf 在Startup.cs ...

  5. .NET Core UI框架Avalonia

    .NET Core UI框架Avalonia,Avalonia是一个基于WPF XAML的跨平台UI框架,并支持多种操作系统:Windows(.NET Framework,.NET Core),Lin ...

  6. zabbix 3.4.1 解决中文乱码

    docker zabbix中文乱码 基础镜像为:zabbix/zabbix-web-nginx-mysql 1.首先下载msyh.ttf 2.docker cp msyh.ttf 容器:/usr/sh ...

  7. 注册表命令 regedit32

    转自 https://zhidao.baidu.com/question/1958216489744783460.html Regedt32.exe 不支持注册表项文件 (.reg) 的导入和导出. ...

  8. SpringMvc解决Restful中文乱码问题

    中文乱码问题解决方式: <!-- 解决中文乱码问题 --> <filter> <filter-name>CharacterEncodingFilter</fi ...

  9. Js常用的函数

    1.用于对正则表达式的函数: var pattern=/\d{3}-\d{2}-\d{4}/;//这里产生的是一个object类型 alert(pattern.test("cscscscs& ...

  10. PHP函数register_shutdown_function的用法

    register_shutdown_function这个函数是在PHP程序运行结束之前调用的,用这个函数可以做很多,比如调用运行发生致命错误中止的原因,或者调试程序的执行时间等. PHP终止的情况有哪 ...