JDBCtemplate的实际操作，解决案例

最新推荐文章于 2021-04-01 20:25:49 发布
最新推荐文章于 2021-04-01 20:25:49 发布
阅读量401 收藏
点赞数 1
文章标签： 数据库 java sql spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Jackbillzsc/article/details/107962806
版权

JDBCtemplate的实际操作，解决案例

2018/8/12
今天的学习是深入学习JDBCtemplate的许多方法，对昨天的入门进行巩固，写了一些案例和案例中的问题

JDBCTemplate入门：

  • update():执行DML语句。增、删、改语句

  • queryForMap():查询结果将结果集封装为map集合，将列名作为key，将值作为value 将这条记录封装为一个map集合
    *注意：这个方法查询的结果集长度只能是1

  • queryForList():查询结果将结果集封装为list集合
    *注意：将每一条记录封装为一个Map集合，再将Map集合装载到List集合中

  • query():查询结果，将结果封装为JavaBean对象
    * query的参数：RowMapper
    * 一般我们使用BeanPropertyRowMapper实现类。可以完成数据到JavaBean的自动封装
    * new BeanPropertyRowMapper<类型>(类型.class)

  • queryForObject：查询结果，将结果封装为对象
    *一般用于聚合函数的查询

案例及问题：

需求：

1.修改id为1 的密码possword为zsczsc
2.添加一条记录
3.删除刚才添加的记录
4.查询id为1的记录，将其封装为map集合
5.查询所有记录，将其封装为list集合
6.查询所有记录，就其封装为studentTable1对象的list集合
7.查询记录总数

前三个方法是使用jdbctemplate的upadte方法执行DML语句

1.修改id为1 的密码possword为zsczsc
代码如下：

//Junit单元测试，可以让方法独立去执行
    //前三个方法是使用jdbctemplate的upadte方法执行DML语句
    /***
     *   1.修改id为1 的密码possword为zsczsc
     */
    //获取jdbctemplate对象(将template放在成员变量中所以不需要在每个方法中重新获取jdbctemplate对象)
    private JdbcTemplate template=new JdbcTemplate(JDBCUtils.getdatasource());
    @Test
    public void test1(){
        //1.创建修改的sql命令
        String sql="update studentTable1 set possword=? where id=?";
        //2.执行sql命令（调用jdbctemplat的update方法参数就是sql命令）
        int i = template.update(sql,"zsc",1);
        //3.打印受影响的行数
        System.out.println(i);
    }

这里的类为测试类使用了@Test注解，这样的方式可以使得方法直接运不需要依赖主类，可以在百度搜索Junit单元测试来详细了解。
2.添加一条记录
代码如下

/***
     *  * 2.添加一条只有用户名密码为空的数据
     */
    @Test
    public void test2(){
        //1创建添加的sql命令(添加一行数据只有用户名没有密码)
        String sql="insert into studentTable1(name) values (?)";
        //2执行sql命令
        int i = template.update(sql, "1234");
        //3打印受影响的行数
        System.out.println(i);
    }

3.删除刚才添加的记录
代码如下

/***
     *  * 3.删除刚才添加的记录
     */
    @Test
    public void test3(){
        //1.创建删除的sql命令
        String sql="delete from studentTable1 where name=? ";
        //2.执行sql命令
        int i = template.update(sql, "1234");
        //3.打印受影响的行数
        System.out.println(i);
    }

后四个方法是使用jdbctemplate的query方法执行DQl语句

4.查询id为1的记录，将其封装为map集合
代码如下

/***
     *  * 4.查询id为1的记录，将其封装为map集合
     */
    @Test
    public void test4(){
        //1.创建查询id为1 的sql命令
        String sql="select * from studentTable1 where id=?";
        //2.执行sql命令，并且将结果封装成map集合，使用jdbctemplate的queryForMap方法
        Map<String, Object> map1 = template.queryForMap(sql, 1);
        //3.打印结果集
        System.out.println(map1);
        //结果为：{id=1, name=zsc1, possword=zsc}
        /*注意：如果当查询语句查询两条记录时是不能封装进一个map集合的，
        只能查询一条记录并且封装map集合 String sql="select * from studentTable1 where id=? or id=?";
        queryForMap方法查询的结果集长度只能为1*/
    }

5.查询所有记录，将其封装为list集合
代码如下

/***
     *  * 5.查询所有记录，将其封装为list集合
     */
    @Test
    public void test5(){
        //1.创建sql命令查询所有的记录
        String sql="select * from studentTable1";
        //2.执行sql命令，调用jdbctemplate的queryForList方法，该方法先将没一条记录封装为map集合，然后将map集合封装为list集合
        List<Map<String, Object>> mapList = template.queryForList(sql);
        //3.遍历list集合
        for (Map<String, Object> stringObjectMap : mapList) {
            System.out.println(stringObjectMap);
        }
    }

6.1查询所有记录，就其封装为studentTable1对象的list集合
（自己实现RowMapper<数据库类>接口）

/***
     *  * 6.1查询所有记录，就其封装为studentTable1对象的list集合
     *  自己实现RowMapper<studentTable1>接口
     */
    @Test
    public void test6_1(){
        //1.创建sql命令，查询所有记录
        String sql="select * from studentTable1";
        //2.执行sql命令(自己实现RowMapper<studentTable1>接口)
        List<studentTable1> list = template.query(sql, new RowMapper<studentTable1>() {
            @Override
            public studentTable1 mapRow(ResultSet rs, int i) throws SQLException {
                //1从数据库获取数据
                int id = rs.getInt("id");
                String name = rs.getString("name");
                String possword = rs.getString("possword");
                //2创建studentTable1对象，并赋值
                studentTable1 studentTable1 = new studentTable1();
                studentTable1.setId(id);
                studentTable1.setName(name);
                studentTable1.setPossword(possword);
                //3返回装载进list集合
                return studentTable1;
            }
        });
        //3.遍历list集合
        for (studentTable1 studentTable1 : list) {
            System.out.println(studentTable1);
        }
    }

此时你会发现这样的方法并不方便，没有什么简单的地方，还是要靠自己实现RowMapper<数据库类> 接口，所以为了否报jdbctemplate提供了已经实现的接口BeanPropertyRowMapper<类型>(类型.class)

6.2查询所有记录，就其封装为studentTable1对象的list集合
（ 通过jdbctemplate提供的BeanPropertyRowMapper已经实现RowMapper接口 去完成操作）
代码如下

/***
     *  * 6.2查询所有记录，就其封装为studentTable1对象的list集合
     *  通过jdbctemplate提供的BeanPropertyRowMapper已经实现RowMapper<studentTable1>接口
     */
    @Test
    public void test6_2(){
        //1.创建sql命令，查询所有记录
        String sql="select * from studentTable1";
        /*2.执行sql命令(通过jdbctemplate提供的BeanPropertyRowMapper<类型>(类型.class)参数为studentTable1的字节码文件，
        去实现RowMapper<studentTable1>接口，)*/

        /*注意如果使用jdbctemplate提供的对象BeanPropertyRowMapper，在studentTable1类中中定义时不能使用基本数据类型如int，double等等，
        要使用引用数据类型如Integer，Double等等*/

        List<studentTable1> list = template.query(sql, new BeanPropertyRowMapper<studentTable1>(studentTable1.class));
        //3.遍历list集合
        for (studentTable1 studentTable1 : list) {
            System.out.println(studentTable1);
        }
    }

注意：1.通过jdbctemplate提供的BeanPropertyRowMapper<类型>(类型.class)参数为studentTable1的字节码文件，
去实现RowMapper<类型>接口
2.注意如果使用jdbctemplate提供的对象BeanPropertyRowMapper，在studentTable1类中中定义时不能使用基本数据类型如int，double等等，
要使用引用数据类型如Integer，Double等等

7.查询记录总数
代码如下

/***
     *  * 7.查询记录总数
     */
    @Test
    public void test7(){
        //1.创建sql命令查询总记录数
        String sql="select count(id) from studentTable1";
        //2.执行sql命令
        Long count = template.queryForObject(sql, long.class);
        //打印记录数
        System.out.println(count);
    }

注意在使用queryForObject(sql,记录总数类型.class)方法时，参数为sql命令执行后返回的记录总数的类型的字节码文件。

测试类的完整代码

如下：

package cn.itcat.JDBCTemplate;

import cn.itcat.datasource.utils.JDBCUtils;
import cn.itcat.templateDO.studentTable1;
import org.junit.Test;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;

/***
 * 测试类（使用JDBCtemplate对数据库的操作）使用Junit单元测试
 * 需求：
 * 1.修改id为1 的密码possword为zsczsc
 * 2.添加一条记录
 * 3.删除刚才添加的记录
 * 4.查询id为1的记录，将其封装为map集合
 * 5.查询所有记录，将其封装为list集合
 * 6.查询所有记录，就其封装为studentTable1对象的list集合
 * 7.查询记录总数
 */
public class JDBCTemplateDemo2 {
    //Junit单元测试，可以让方法独立去执行
    //前三个方法是使用jdbctemplate的upadte方法执行DML语句
    /***
     *   1.修改id为1 的密码possword为zsczsc
     */
    //获取jdbctemplate对象(将template放在成员变量中所以不需要在每个方法中重新获取jdbctemplate对象)
    private JdbcTemplate template=new JdbcTemplate(JDBCUtils.getdatasource());
    @Test
    public void test1(){
        //1.创建修改的sql命令
        String sql="update studentTable1 set possword=? where id=?";
        //2.执行sql命令（调用jdbctemplat的update方法参数就是sql命令）
        int i = template.update(sql,"zsc",1);
        //3.打印受影响的行数
        System.out.println(i);
    }

    /***
     *  * 2.添加一条只有用户名密码为空的数据
     */
    @Test
    public void test2(){
        //1创建添加的sql命令(添加一行数据只有用户名没有密码)
        String sql="insert into studentTable1(name) values (?)";
        //2执行sql命令
        int i = template.update(sql, "1234");
        //3打印受影响的行数
        System.out.println(i);
    }

    /***
     *  * 3.删除刚才添加的记录
     */
    @Test
    public void test3(){
        //1.创建删除的sql命令
        String sql="delete from studentTable1 where name=? ";
        //2.执行sql命令
        int i = template.update(sql, "1234");
        //3.打印受影响的行数
        System.out.println(i);
    }
    //后四个方法是使用jdbctemplate的query方法执行DQl语句
    /***
     *  * 4.查询id为1的记录，将其封装为map集合
     */
    @Test
    public void test4(){
        //1.创建查询id为1 的sql命令
        String sql="select * from studentTable1 where id=?";
        //2.执行sql命令，并且将结果封装成map集合，使用jdbctemplate的queryForMap方法
        Map<String, Object> map1 = template.queryForMap(sql, 1);
        //3.打印结果集
        System.out.println(map1);
        //结果为：{id=1, name=zsc1, possword=zsc}
        /*注意：如果当查询语句查询两条记录时是不能封装进一个map集合的，
        只能查询一条记录并且封装map集合 String sql="select * from studentTable1 where id=? or id=?";
        queryForMap方法查询的结果集长度只能为1*/
    }

    /***
     *  * 5.查询所有记录，将其封装为list集合
     */
    @Test
    public void test5(){
        //1.创建sql命令查询所有的记录
        String sql="select * from studentTable1";
        //2.执行sql命令，调用jdbctemplate的queryForList方法，该方法先将没一条记录封装为map集合，然后将map集合封装为list集合
        List<Map<String, Object>> mapList = template.queryForList(sql);
        //3.遍历list集合
        for (Map<String, Object> stringObjectMap : mapList) {
            System.out.println(stringObjectMap);
        }
    }

    /***
     *  * 6.1查询所有记录，就其封装为studentTable1对象的list集合
     *  自己实现RowMapper<studentTable1>接口
     */
    @Test
    public void test6_1(){
        //1.创建sql命令，查询所有记录
        String sql="select * from studentTable1";
        //2.执行sql命令(自己实现RowMapper<studentTable1>接口)
        List<studentTable1> list = template.query(sql, new RowMapper<studentTable1>() {
            @Override
            public studentTable1 mapRow(ResultSet rs, int i) throws SQLException {
                //1从数据库获取数据
                int id = rs.getInt("id");
                String name = rs.getString("name");
                String possword = rs.getString("possword");
                //2创建studentTable1对象，并赋值
                studentTable1 studentTable1 = new studentTable1();
                studentTable1.setId(id);
                studentTable1.setName(name);
                studentTable1.setPossword(possword);
                //3返回装载进list集合
                return studentTable1;
            }
        });
        //3.遍历list集合
        for (studentTable1 studentTable1 : list) {
            System.out.println(studentTable1);
        }
    }

    /***
     *  * 6.2查询所有记录，就其封装为studentTable1对象的list集合
     *  通过jdbctemplate提供的BeanPropertyRowMapper去实现RowMapper<studentTable1>接口
     */
    @Test
    public void test6_2(){
        //1.创建sql命令，查询所有记录
        String sql="select * from studentTable1";
        /*2.执行sql命令(通过jdbctemplate提供的BeanPropertyRowMapper<类型>(类型.class)参数为studentTable1的字节码文件，
        去实现RowMapper<studentTable1>接口，)*/

        /*注意如果使用jdbctemplate提供的对象BeanPropertyRowMapper，在studentTable1类中中定义时不能使用基本数据类型如int，double等等，
        要使用引用数据类型如Integer，Double等等*/

        List<studentTable1> list = template.query(sql, new BeanPropertyRowMapper<studentTable1>(studentTable1.class));
        //3.遍历list集合
        for (studentTable1 studentTable1 : list) {
            System.out.println(studentTable1);
        }
    }
    /***
     *  * 7.查询记录总数
     */
    @Test
    public void test7(){
        //1.创建sql命令查询总记录数
        String sql="select count(id) from studentTable1";
        //2.执行sql命令
        Long count = template.queryForObject(sql, long.class);
        //打印记录数
        System.out.println(count);
    }
}

JDBCUtils工具类
代码如下

package cn.itcat.datasource.utils;

import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.sql.DataSource;
import java.io.IOException;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;

/***
 * Druid连接池工具类
 */
//1.定义一个工具类JDBCUtils
public class JDBCUtils {
    //2.创建连接池连接配置文件静态代码块
    public static DataSource ds;
    static {
        try {
            Properties pro = new Properties();
            pro.load(JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties"));
            ds= DruidDataSourceFactory.createDataSource(pro);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    //3.提供方法
    /***
     * 获取连接的方法
     */
    public static Connection getconnection() throws SQLException {
        return ds.getConnection();
    }
    /***
     * 释放资源的方法
     */
    public static  void close(ResultSet rs,Statement st,Connection con){
        if (rs!=null){
            try {
                rs.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        if (st!=null){
            try {
                st.close();
                /*Statement 对象将由 Java 垃圾收集程序自动关闭。
            而作为一种好的编程风格，应在不需要 Statement对象时显式地关闭它们。
            这将立即释放 DBMS 资源，有助于避免潜在的内存问题。*/
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        if (con!=null){
            try {
                con.close();     //归还连接回连接池
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
    }
    /***
     * 获取连接池的方法
     */
    public static DataSource getdatasource(){
        return ds;
    }

}

studentTable1数据库对象类
代码如下

package cn.itcat.templateDO;

public class studentTable1 {
    private Integer id;
    private String name;
    private String possword;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPossword() {
        return possword;
    }

    public void setPossword(String possword) {
        this.possword = possword;
    }

    @Override
    public String toString() {
        return "studentTable1{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", possword='" + possword + '\'' +
                '}';
    }
}

好处：

简化代码量
使用方便
不需要手动归还连接和创建连接

A-Superman
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
jdbc mysql 返回游标_使用JdbcTemplate流式（游标）读取数据库
weixin_42363510的博客
01-27 2114
前言生产环境中经常使用数据库分页的方式来控制一次获取的数据量，而数据处理中经常会有另外一种场景：从一个数据库表中读取所有数据进行处理并将结果保存在其他数据库或文件或NoSql数据库中。这时候也可以使用分页的方式进行批处理，不过这种方法不但逻辑复杂，效率也十分低下，那么有没有类似于文件流的读取方式来读取数据库呢？答案是有的，JDBC提出的标准里不仅有流式读取，甚至还支持读取过程中感知与更新数据，不过...
mybatis01_入门案例
12-21
以上内容概括了MyBatis入门案例的基本步骤，包括理解框架概念、三层架构、MyBatis的用途，以及如何在实际项目中设置和使用MyBatis。通过这个案例，开发者可以开始学习如何在自己的项目中利用MyBatis进行数据库操作。
使用JdbcTemplate调用输出参数为结果集(REF游标)的集合
iteye_14360的博客
03-19 477
//例子一：只有输出参数 [code="xml"] [/code] [code="java"] @Test public void testRegisterCustomer() { List locationInfo = (List) jdbcTempla...
JDBCTemplate
weixin_40055163的博客
10-17 240
JDBCTemplate 1 Spring JDBC Spring框架对JDBC的简单封装。提供了一个JDBCTemplate对象简化JDBC的开发。 1.使用步骤如下 1.导入jar包。 2.创建JdbcTemplate对象。依赖于数据源DataSource。 JdbcTemplate template = new JdbcTemplate(ds); 3.调用JdbcTemplate的方法来完成CRUD的操作。 update():执行DML语句。增、删、改语句。 queryForMap():查询结果将结果
java jdbcTemplate执行sql
盗梦的博客
12-18 1499
1.getJdbcTemplate   ?代替参数 insert,delete getJdbcTemplate().update(sql,new Object[]{id,name});  get getJdbcTemplate().query(sql,new ColumnMapRowMapper(),new Object[]{id,name}); 2.getNamed
JdbcTemplate 调用 oracle Function 返回游标
q1i2_ao的专栏
03-13 495
String sql = "{?=call funcName(?,?,?)}"; return jdbcTemplate.execute(sql,new CallableStatementCallback<List<Map<String,Object>>>(){ public List<Map<String,Object>> doI...
JdbcTemplate,自己封装的jdbc小框架
02-26
为了解决这个问题，开发者常常会使用一些框架来简化这些操作，比如Spring的JdbcTemplate。本项目则基于这一思想，创建了一个自定义的JdbcTemplate小框架，旨在提供更简洁、高效的数据库操作方式。 自封装的...
java多数据源案例使用项目
最新发布
05-30
这个"java多数据源案例使用项目"旨在解决的就是这种需求，允许一套业务代码无缝对接不同数据库，提高代码复用性，降低维护成本。以下将详细介绍这一技术的原理、实现方式以及可能遇到的问题。 首先，我们要理解什么...
spring入门到精通综合案例详解
10-28
在学习这个综合案例的过程中，您会遇到如何创建 Spring 项目、配置 Bean、实现 MVC 结构、处理 Web 请求、实现事务管理、使用 Spring Boot 快速搭建应用、以及集成 Spring Security 等实际操作。每个案例都会加深对 ...
Spring,SpringMVC案例及SSM框架整合.zip
04-25
1. Spring与JDBC整合：Spring通过`JdbcTemplate`和`SqlSessionTemplate`等工具类简化了JDBC操作，提供了一套模板方法，使得代码更加简洁且易于测试。 2. Spring与Mybatis整合：Mybatis是轻量级的持久层框架，Spring...
jdbcTemplate分页彻底解决，使用游标滚动
05-29
jdbcTemplate分页彻底解决，使用游标滚动，看了Spring源码才解决了问题
JDBC使用游标实现分页查询的方法
09-01
主要介绍了JDBC使用游标实现分页查询的方法,实例分析了jdbc查询过程中游标的使用及查询分页相关实现技巧,需要的朋友可以参考下
JdbcTemplate中执行结果包含内嵌式实体
qq_24114893的博客
08-14 320
JdbcTemplate中执行结果包含内嵌式实体方式一方式二方式三 当使用JDBCTemplate时会遇到实体中内嵌其他实体的情况，这样实体中字段不会被赋值，提供了三种方式解决这个问题，每种方式各有优缺点 实体 public class User { private String name; private String password; private Father f...
Spring5总述（七）—— 基于JdbcTemplate实现数据库操作（代码演示）
mydesss的博客
04-01 1667
Spring5总述（七）—— 基于JdbcTemplate实现数据库操作（代码演示） 基于JdbcTemPlate实现数据库的添加、删除、修改、查询、批量添加操作
JdbcTemplate
linyouru的博客
06-13 198
JdbcTemplate简介 Spring对数据库的操作在jdbc上面做了深层次的封装，使用spring的注入功能，可以把DataSource注册到JdbcTemplate之中。 JdbcTemplate主要提供以下五类方法： execute方法：可以用于执行任何SQL语句，一般用于执行DDL语句； update方法及batchUpdate方法：update方法用于执行新增、修改、删除等语句；batchUpdate方法用于执行批处理相关语句； query方法及queryForXXX方法：用于执.
jdbcTemplate
Dzq_Boyka的博客
11-09 440
原文：https://www.cnblogs.com/wnlja/p/3909999.html 提供了JdbcTemplate 来封装数据库jdbc操作细节：  包括： 数据库连接[打开/关闭] ，异常转义 ，SQL执行 ，查询结果的转换  使用模板方式封装 jdbc数据库操作-固定流程的动作，提供丰富callback回调接口功能，方便用户自定义加工细节，更好模块化jdb
day06_JDBC连接池&JDBCTemplate
weixin_42651836的博客
08-19 226
今日内容 数据库连接池 数据库连接池 好处: 用户使用高效 节省资源 实现 标准接口：DataSource javax.sql包下的 获取连接：getConnection() 归还连接：Connection.close()。 2.一般我们不去实现它，有数据库厂商来实现 C3P0：数据库连接池技术 Druid：数据库连接池实现技术，由阿里巴巴提供的 C3P0：数据库连接...
Spring Boot多数据源配置之JdbcTemplate
热门推荐
江南一点雨的专栏
03-17 1万+
多数据源配置也算是一个常见的开发需求，Spring和SpringBoot中，对此都有相应的解决方案，不过一般来说，如果有多数据源的需求，我还是建议首选分布式数据库中间件MyCat去解决相关问题，之前有小伙伴在我的知识星球上提问，他的数据根据条件的不同，可能保存在四十多个不同的数据库中，怎么办？这种场景下使用多数据源其实就有些费事了，我给的建议是使用MyCat，然后分表策略使用sharding-by...
Spring框架中的JdbcTemplate数据库操作指南
"这篇文档介绍了如何使用Spring框架中的JdbcTemplate模块来简化数据库操作。通过引入Druid数据源、配置Spring的bean以及在Service和DAO层注入JdbcTemplate，实现了数据库操作的便捷性。" 在Java开发中，Spring框架...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值