MySQL | Spring JDBCTemplate

MySQL | Spring JDBCTemplate

99 次访问
· 数据库

Spring JDBC

Spring 框架对 JDBC 进行了简单封装，提供了一个 JDBCTemplate 对象简化 JDBC 的开发过程

使用方法

  1. 导入相关 jar 包（文章尾部有下载地址）
  2. 创建 JdbcTemplate 对象，依赖于数据源 DataSource 
    JdbcTemplate template = new JdbcTemplate(ds);
  3. 调用对应的方法来完成 CRUD 的操作
    • update()：执行 DML 即增、删、改语句
    • queryForMap()：执行 DQL 查询语句，并将结果集封装为 Map 集合，字段名为 key，值作为 value，注意：这个方法查询的结果集长度只能是 1，也就是一条记录
    • queryForList()：执行 DQL 查询语句，并将结果集封装为 List 集合，List 中存储的是 Map 对象，一个 Map 对象对应一条记录
    • query()：执行 DQL 查询语句，并将结果集封装为 JavaBean 对象，该方法的参数为 RowMapper，一般使用 BeanPropertyRowMapper 实现类，可以完成数据到 JavaBean 的自动封装
        new BeanPropertyRowMapper<类型>(类型.class)
    • queryForObject()：执行 DQL 查询语句，并将结果集封装为对象，一般用于聚合函数的查询

应用实例

需求：针对 emp 表的增删改查

  1. 修改 id 为 1001 的记录的 salary 为 10000
  2. 添加一条记录
  3. 删除刚才添加的记录
  4. 查询 id 为 1001 的记录，将其封装为 Map 集合
  5. 查询所有记录，将其封装为 List
  6. 查询所有记录，将其封装为 Emp 对象的 List 集合
  7. 查询总记录数

工程文件目录结构

Druid 连接池配置文件

driverClassName=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/db3?useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai
username=root
password=root
initialSize=10
maxActive=15
maxWait=3000

validationQuery:SELECT 1

实体类

package cool.yzt.domain;

import java.util.Date;

/**
 * @Author: yzt
 * @Description:实体类
 */
public class Emp {
    private Integer id;
    private String ename;
    private Integer job_id;
    private Integer mgr;
    private Date joindate;
    private Double salary;
    private Double bonus;
    private Integer dept_id;

    public Integer getId() {
        return id;
    }

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

    public String getEname() {
        return ename;
    }

    public void setEname(String ename) {
        this.ename = ename;
    }

    public Integer getJob_id() {
        return job_id;
    }

    public void setJob_id(Integer job_id) {
        this.job_id = job_id;
    }

    public Integer getMgr() {
        return mgr;
    }

    public void setMgr(Integer mgr) {
        this.mgr = mgr;
    }

    public Date getJoindate() {
        return joindate;
    }

    public void setJoindate(Date joindate) {
        this.joindate = joindate;
    }

    public Double getSalary() {
        return salary;
    }

    public void setSalary(Double salary) {
        this.salary = salary;
    }

    public Double getBonus() {
        return bonus;
    }

    public void setBonus(Double bonus) {
        this.bonus = bonus;
    }

    public Integer getDept_id() {
        return dept_id;
    }

    public void setDept_id(Integer dept_id) {
        this.dept_id = dept_id;
    }

    @Override
    public String toString() {
        return "Emp{" +
                "id=" + id +
                ", ename='" + ename + '\'' +
                ", job_id=" + job_id +
                ", mgr=" + mgr +
                ", joindate=" + joindate +
                ", salary=" + salary +
                ", bonus=" + bonus +
                ", dept_id=" + dept_id +
                '}';
    }
}

JDBC 工具类

package cool.yzt.utils;

import com.alibaba.druid.pool.DruidDataSourceFactory;
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;

/**
 * @Author: yzt
 * @Description: JDBC 工具类
 */
public class JDBCUtiles {
    private static DataSource ds;

    static {
        try {
            Properties pros = new Properties();
            pros.load(JDBCUtiles.class.getClassLoader().getResourceAsStream("druid.properties"));
            ds = DruidDataSourceFactory.createDataSource(pros);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static Connection getConnection() throws SQLException {
        return ds.getConnection();
    }

    public static void close(Statement statement,Connection connection) {
        close(null,statement,connection);
    }

    public static void close(ResultSet rs,Statement statement, Connection connection) {
        if(rs!=null) {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        if(statement!=null) {
            try {
                statement.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        if(connection!=null) {
            try {
                connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    public static DataSource getDataSource() {
        return ds;
    }
}

测试类，方便起见，使用 JUnit 进行单元测试

package cool.yzt.demo;

import cool.yzt.domain.Emp;
import cool.yzt.utils.JDBCUtiles;
import org.junit.Test;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import java.util.List;
import java.util.Map;

/**
 * @Author: yzt
 * @Description: 测试类
 */
public class JdbcTemplateDemo1 {
    // 获取一个JdbcTemplate对象，方便统一测试，入参为数据库连接池对象，从JDBC工具类获取
    private static JdbcTemplate template = new JdbcTemplate(JDBCUtiles.getDataSource());

    @Test
    public void test1() {
        // 将id为1001的记录的salary字段设置为10000，使用?作为参数的占位符，防止sql注入问题
        String sql = "update emp set salary = ? where id = ?";
        // 入参分别为sql语句，参数（按顺序）
        template.update(sql,10000,1001);
    }

    @Test
    public void test2() {
        // 添加一条记录
        String sql = "insert into emp (id,ename,dept_id) values (?,?,?)";
        template.update(sql,1015,"郭靖",10);
    }

    @Test
    public void test3() {
        // 删除一条记录
        String sql = "delete from emp where id = ?";
        template.update(sql,1015);
    }

    @Test
    public void test4() {
        String sql = "select * from emp where id = ?";
        // 结果集中只有一条记录，封装为Map对象，泛型为<String（key，字段名）,Object（value，记录值）>
        Map<String,Object> map = template.queryForMap(sql,1001);
        System.out.println(map);
        // 打印结果
        // {id=1001, ename=孙悟空, job_id=4, mgr=1004, joindate=2000-12-17, salary=10000.00, bonus=null, dept_id=20}
    }
    @Test
    public void test5() {
        String sql = "select * from emp";
        // 将结果集中的每一条记录封装为Map对象在装载进List中
        List<Map<String,Object>> list = template.queryForList(sql);
        for(Map<String,Object> map : list) {
            System.out.println(map);
        }
    }

    @Test
    public void test6() {
        String sql = "select * from emp";
        // 入参为sql、BeanPropertyRowMapper对象（泛型和入参要指明JavaBean的类型和class对象）、其他?参数
        List<Emp> list = template.query(sql,new BeanPropertyRowMapper<Emp>(Emp.class));
        for(Emp emp : list) {
            System.out.println(emp);
        }
    }

    @Test
    public void test7() {
        String sql = "select count(id) from emp";
        // 结果集封装为一个对象，入参要指明对象的class
        Integer num = template.queryForObject(sql,Integer.class);
        System.out.println(num);
    }
}

参考

使用的 jar 包

Copyright: 采用 知识共享署名4.0 国际许可协议进行许可

Links: https://yzt.cool/archives/mysqlspringjdbctemplate

# Java # 数据库 # MySQL # Spring

Tomcat 服务器介绍