码迷，mamicode.com
首页 > 数据库 > 详细

Spring JDBC 的简单使用

时间：2021-03-05 13:09:26      阅读：0      评论：0      收藏：0      [点我收藏+]

标签：简单   jar   聚合函数   param   ring   工具类   创建   mapper   方法   

Spring框架对JDBC的简单封装。提供了一个JDBCTemplate对象简化JDBC的开发。

使用步骤

  1. 导入架包：commons-logging-1.2.jar、spring-beans-5.0.0.RELEASE.jar、spring-core-5.0.0.RELEASE.jar、
    spring-jdbc-5.0.0.RELEASE.jar、spring-tx-5.0.0.RELEASE.jar

  2. 创建JdbcTemplate对象。

    JdbcTemplate template = new JdbcTemplate(new DataSource);
// 创建JdbcTemplate对象，需要传入数据库连接池对象。

  3. 调用JdbcTemplate的方法，对数据库进行操作：

    update()
// 执行insert into、delete、set语句（增、删、改）

    queryForMap()
// 查询结果将结果集封装为map集合，将列名作为key，将值作 value 将这条记录封装为一个map集合

备注：这个方法查询的结果集长度只能是1

    queryForList()
// 查询结果将结果集封装为list集合

备注：将每一条记录封装为一个Map集合，再将Map集合装载到List集合中

    query()
// 查询结果，将结果封装为JavaBean对象

    queryForObject()
// 查询结果，将结果封装为对象

备注：一般用于聚合函数的查询

实例1

有如下一个数据库表格：

CREATE TABLE account (
    id INT PRIMARY KEY AUTO_INCREMENT,   -- id
    NAME VARCHAR(10),                    -- 名字
    balance DOUBLE                       -- 余额
);

INSERT INTO account (NAME, balance) VALUES (‘LeeHua‘, 1000), (‘Tom‘, 1000), (‘WanWu‘, 2000);

配置文件如下：druid-1.0.9.properties

driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://MySQL地址/数据库名称
username=登录mysql的用户名
password=密码
initialSize=初始化数据库连接池连接数量
maxActive=最大数据库连接池连接数量
maxWait=最大超时时间（/ms）

Java代码操作数据库表：把id=3的用户的账户余额修改为5000

package my.view.jdbctemplate;

import com.alibaba.druid.pool.DruidDataSourceFactory;
import org.springframework.jdbc.core.JdbcTemplate;

import javax.sql.DataSource;
import java.io.InputStream;
import java.util.Properties;

public class JdbcTemplateDemo01 {

    public static void main(String[] args) throws Exception {
        // 获取加载配置文件的对象
        Properties properties = new Properties();

        // 获取类的类加载器
        ClassLoader classLoader = JdbcTemplateDemo01.class.getClassLoader();

        // 获取druid-1.0.9.properties配置文件资源输入流
        InputStream resourceAsStream = classLoader.getResourceAsStream("druid-1.0.9.properties");

        // 加载配置文件
        properties.load(resourceAsStream);

        // 获取连接池对象
        DataSource dataSource = DruidDataSourceFactory.createDataSource(properties);

        // 创建JdbcTemplate对象
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

        // 定义预编译SQL语句
        String sql = "UPDATE account SET balance = 5000 WHERE id = ?";

        // 调用JdbcTemplate对象的update()方法，给SQL语句的?赋值，并执行SQL语句。该方法返回值是一个int类型的数。
        int update = jdbcTemplate.update(sql, 3);

        // 输出执行的SQL语句，影响表格中的行数。
        System.out.println(update);
    }

}

运行程序，控制台输出：

1

表中的数据如下：

技术图片

案例2

有如下一个表格：emp表格

技术图片

需求

  1. 修改id = 1001数据的 salary 字段记录为 10000

  2. 添加一条记录

  3. 删除刚才添加的记录

  4. 查询id为1001的记录，将其封装为Map集合

  5. 查询所有记录，将其封装为List

  6. 查询所有记录，将其封装为Emp对象的List集合

  7. 查询总记录数

实现前，为了后续的实现方便：创建一个Emp类，封装Emp表数据的JavaBean。创建一个工具类，用来获取数据库连接池对象。

Emp.java

package my.view.domain;

import java.util.Date;

public class Emp {

    /** 员工id */
    private int id;
    /** 员工姓名 */
    private String ename;
    /** 职务id */
    private int job_id;
    /** 上级领导 */
    private int mgr;
    /** 入职日期 */
    private Date joindate;
    /** 工资 */
    private double salary;
    /** 奖金 */
    private double bonus;
    /** 所在部门编号 */
    private int dept_id;

    public Emp() {
    }

    public Emp(int id, String ename, int job_id, int mgr, Date joindate, double salary, double bonus, int dept_id) {
        this.id = id;
        this.ename = ename;
        this.job_id = job_id;
        this.mgr = mgr;
        this.joindate = joindate;
        this.salary = salary;
        this.bonus = bonus;
        this.dept_id = dept_id;
    }

    public int getId() {
        return id;
    }

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

    public String getEname() {
        return ename;
    }

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

    public int getJob_id() {
        return job_id;
    }

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

    public int getMgr() {
        return mgr;
    }

    public void setMgr(int 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 int getDept_id() {
        return dept_id;
    }

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

    public double getBonus() {
        return bonus;
    }

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

    @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 +
                ‘}‘;
    }

}

package my.view.utils;

import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.sql.DataSource;
import java.io.InputStream;
import java.lang.reflect.Method;
import java.sql.Connection;
import java.util.Properties;

public class JdbcUtils {

    /**
     * 数据库连接对象
     */
    private static DataSource dataSource;

    /*
     获取数据库连接池对象
     */
    static {

        try {
            // 获取加载配置文件的对象
            Properties properties = new Properties();
            // 获取类的类加载器
            ClassLoader classLoader = JdbcUtils.class.getClassLoader();
            // 获取druid-1.0.9.properties配置文件资源输入流
            InputStream resourceAsStream = classLoader.getResourceAsStream("druid-1.0.9.properties");
            // 加载配置文件
            properties.load(resourceAsStream);
            // 获取连接池对象
            dataSource = DruidDataSourceFactory.createDataSource(properties);
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    /**
     * 获取连接池对象
     */
    public static DataSource getDataSource() {
        return dataSource;
    }

    /**
     * 获取数据库连接对象
     */
    public static Connection getConnection() throws Exception {
        return dataSource.getConnection();
    }

    /**
     * 归还连接 或 释放资源
     * @param t 要被归还到熟即可连接池对象的数据库连接对象 或 要被释放的资源
     * @param <T> 数据库连接对象的类型 或 要被释放的资源对象的类型
     */
    public static <T> void releaseResources (T t){
        if(t != null){
            try {
                // 利用反射，获取class对象
                Class<?> aClass = t.getClass();
                // 获取class对象中的方法对象
                Method close = aClass.getMethod("close");
                // 执行方法
                close.invoke(t);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

}

需求1的实现

package my.view.jdbctemplate;

import my.view.utils.JdbcUtils;
import org.junit.Test;
import org.springframework.jdbc.core.JdbcTemplate;

import javax.sql.DataSource;

public class JdbcTemplateDemoTest {

    /**
     * 修改id = 1001数据的 salary 字段记录为 10000
     */
    @Test
    public void updateSetTest01() {
        // 调用自己定义的工具类JdbcUtils，获取数据库连接池对象
        DataSource dataSource = JdbcUtils.getDataSource();

        // 获取JDBCTemplate对象
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

        // 定义预编译的SQL语句
        String sql = "UPDATE emp SET salary = ? WHERE id = ?";

        // 执行SQL语句
        int update = jdbcTemplate.update(sql, 10000, 1001);

        // 输出执行SQL语句后的返回值
        System.out.println(update);
    }

}

需求2的实现

package my.view.jdbctemplate;

import my.view.utils.JdbcUtils;
import org.junit.Test;
import org.springframework.jdbc.core.JdbcTemplate;

import javax.sql.DataSource;

public class JdbcTemplateDemoTest {

    /**
     * 添加一条数据
     */
    @Test
    public void updateInsertTest01() {
        // 调用自己定义的工具类JdbcUtils，获取数据库连接池对象
        DataSource dataSource = JdbcUtils.getDataSource();

        // 获取JDBCTemplate对象
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

        // 定义预编译的SQL语句
        String sql = "INSERT INTO emp (id, ename, salary) VALUE (?, ?, ?)";

        // 执行SQL语句
        int insert = jdbcTemplate.update(sql, 1015, "LeeHua", 8000);

        // 输出执行SQL语句后的返回值
        System.out.println(insert);
    }

}

需求3的实现

package my.view.jdbctemplate;

import my.view.utils.JdbcUtils;
import org.junit.Test;
import org.springframework.jdbc.core.JdbcTemplate;

import javax.sql.DataSource;

public class JdbcTemplateDemoTest {

    /**
     * 删除刚才添加的记录
     */
    @Test
    public void updateDeleteTest03() {
        // 调用自己定义的工具类JdbcUtils，获取数据库连接池对象
        DataSource dataSource = JdbcUtils.getDataSource();

        // 获取JDBCTemplate对象
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

        // 定义预编译的SQL语句
        String sql = "DELETE FROM emp WHERE id = ?";

        // 执行SQL语句
        int delete = jdbcTemplate.update(sql, 1015);

        // 输出执行SQL语句后的返回值
        System.out.println(delete);
    }

}

需求4的实现

package my.view.jdbctemplate;

import my.view.utils.JdbcUtils;
import org.junit.Test;
import org.springframework.jdbc.core.JdbcTemplate;

import javax.sql.DataSource;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class JdbcTemplateDemoTest {

    /**
     * 查询id为1001的记录，将其封装为Map集合
     */
    @Test
    public void queryForMapTest01() {
        // 调用自己定义的工具类JdbcUtils，获取数据库连接池对象
        DataSource dataSource = JdbcUtils.getDataSource();

        // 获取JDBCTemplate对象
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

        // 定义预编译的SQL语句
        String sql = "SELECT * FROM emp WHERE id = ?;";

        // 执行SQL语句
        Map<String, Object> stringObjectMap = jdbcTemplate.queryForMap(sql, 1001);

        // 获取Key值，即列名称
        Set<String> stringKey = stringObjectMap.keySet();

        // 获取Set集合的迭代器对象，并遍历该迭代器对象
        Iterator<String> ite = stringKey.iterator();
        while (ite.hasNext()) {
            // 通过迭代器对象中的每一个值(Map集合中的键)，获取key-value
            String key = ite.next();
            System.out.println(
                    "Key：" + key +
                            "    Value：" + stringObjectMap.get(key)
            );
        }
    }
    
}

进行测试，控制台输出：

Key：id    Value：1001
Key：ename    Value：Sun Wukong
Key：job_id    Value：4
Key：mgr    Value：1004
Key：joindate    Value：2000-12-17
Key：salary    Value：10000.00
Key：bonus    Value：null
Key：dept_id    Value：20

需求5的实现

package my.view.jdbctemplate;

import my.view.utils.JdbcUtils;
import org.junit.Test;
import org.springframework.jdbc.core.JdbcTemplate;

import javax.sql.DataSource;
import java.util.List;
import java.util.Map;

public class JdbcTemplateDemoTest {

    /**
     * 查询所有记录，将其封装为List
     */
    @Test
    public void queryForListTest01() {
        // 调用自己定义的工具类JdbcUtils，获取数据库连接池对象
        DataSource dataSource = JdbcUtils.getDataSource();

        // 获取JDBCTemplate对象
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

        // 定义预编译的SQL语句
        String sql = "SELECT * FROM emp;";

        // 执行SQL语句
        List<Map<String, Object>> stringObjectList = jdbcTemplate.queryForList(sql);

        // 输出查询结果
        stringObjectList.forEach(System.out::println);
    }
}

进行测试，控制台输出：

{id=1001, ename=Sun Wukong, job_id=4, mgr=1004, joindate=2000-12-17, salary=10000.00, bonus=null, dept_id=20}
{id=1002, ename=Lu Junyi, job_id=3, mgr=1006, joindate=2001-02-20, salary=16000.00, bonus=3000.00, dept_id=30}
{id=1003, ename=Lin Chong, job_id=3, mgr=1006, joindate=2001-02-22, salary=12500.00, bonus=5000.00, dept_id=30}
{id=1004, ename=Tang Monk, job_id=2, mgr=1009, joindate=2001-04-02, salary=29750.00, bonus=null, dept_id=20}
{id=1005, ename=Li Yan, job_id=4, mgr=1006, joindate=2001-09-28, salary=12500.00, bonus=14000.00, dept_id=30}
{id=1006, ename=Song Jiang, job_id=2, mgr=1009, joindate=2001-05-01, salary=28500.00, bonus=null, dept_id=30}
{id=1007, ename=Liu Bei, job_id=2, mgr=1009, joindate=2001-09-01, salary=24500.00, bonus=null, dept_id=10}
{id=1008, ename=Zhu Bajie, job_id=4, mgr=1004, joindate=2007-04-19, salary=30000.00, bonus=null, dept_id=20}
{id=1009, ename=Luo Guanzhong, job_id=1, mgr=null, joindate=2001-11-17, salary=50000.00, bonus=null, dept_id=10}
{id=1010, ename=Wu Yong, job_id=3, mgr=1006, joindate=2001-09-08, salary=15000.00, bonus=0.00, dept_id=30}
{id=1011, ename=sand monk, job_id=4, mgr=1004, joindate=2007-05-23, salary=11000.00, bonus=null, dept_id=20}
{id=1012, ename=Li Yan, job_id=4, mgr=1006, joindate=2001-12-03, salary=9500.00, bonus=null, dept_id=30}
{id=1013, ename=Little White Dragon, job_id=4, mgr=1004, joindate=2001-12-03, salary=30000.00, bonus=null, dept_id=20}
{id=1014, ename=Guan Yu, job_id=4, mgr=1007, joindate=2002-01-23, salary=13000.00, bonus=null, dept_id=10}

需求6的实现

package my.view.jdbctemplate;

import my.view.domain.Emp;
import my.view.utils.JdbcUtils;
import org.junit.Test;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;

import javax.sql.DataSource;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class JdbcTemplateDemoTest {

    /**
     * 查询所有记录，将其封装为Emp对象的List集合
     */
    @Test
    public void queryTest06() {
        // 调用自己定义的工具类JdbcUtils，获取数据库连接池对象
        DataSource dataSource = JdbcUtils.getDataSource();

        // 获取JDBCTemplate对象
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

        // 定义预编译的SQL语句
        String sql = "SELECT * FROM emp;";

        // 执行SQL语句，将其封装为Emp对象的List集合
        List<Emp> empList = jdbcTemplate.query(sql, new RowMapper<Emp>() {
            @Override
            public Emp mapRow(ResultSet resultSet, int i) throws SQLException {
                return new Emp(
                        // 员工ID
                        resultSet.getInt("id"),
                        // 员工姓名
                        resultSet.getString("ename"),
                        // 职务ID
                        resultSet.getInt("job_id"),
                        // 上级领导
                        resultSet.getInt("mgr"),
                        // 入职日期
                        resultSet.getDate("joindate"),
                        // 工资
                        resultSet.getDouble("salary"),
                        // 奖金
                        resultSet.getDouble("bonus"),
                        // 所在部门编号
                        resultSet.getInt("dept_id")
                );
            }
        });
        empList.forEach(System.out::println);
    }
}

query()方法，参数说明：

query(String sql, RowMapper<T> rowMapper)

参数：
// String sql：SQL语句
// rowMapper：一般我们使用BeanPropertyRowMapper实现类。可以完成数据到
//            JavaBean的自动封装，也可以覆盖重写RowMapper<T>函数式接口
//            的方法。

运行测试，控制台输出：

Emp{id=1001, ename=‘Sun Wukong‘, job_id=4, mgr=1004, joindate=2000-12-17, salary=10000.0, bonus=0.0, dept_id=20}
Emp{id=1002, ename=‘Lu Junyi‘, job_id=3, mgr=1006, joindate=2001-02-20, salary=16000.0, bonus=3000.0, dept_id=30}
Emp{id=1003, ename=‘Lin Chong‘, job_id=3, mgr=1006, joindate=2001-02-22, salary=12500.0, bonus=5000.0, dept_id=30}
Emp{id=1004, ename=‘Tang Monk‘, job_id=2, mgr=1009, joindate=2001-04-02, salary=29750.0, bonus=0.0, dept_id=20}
Emp{id=1005, ename=‘Li Yan‘, job_id=4, mgr=1006, joindate=2001-09-28, salary=12500.0, bonus=14000.0, dept_id=30}
Emp{id=1006, ename=‘Song Jiang‘, job_id=2, mgr=1009, joindate=2001-05-01, salary=28500.0, bonus=0.0, dept_id=30}
Emp{id=1007, ename=‘Liu Bei‘, job_id=2, mgr=1009, joindate=2001-09-01, salary=24500.0, bonus=0.0, dept_id=10}
Emp{id=1008, ename=‘Zhu Bajie‘, job_id=4, mgr=1004, joindate=2007-04-19, salary=30000.0, bonus=0.0, dept_id=20}
Emp{id=1009, ename=‘Luo Guanzhong‘, job_id=1, mgr=0, joindate=2001-11-17, salary=50000.0, bonus=0.0, dept_id=10}
Emp{id=1010, ename=‘Wu Yong‘, job_id=3, mgr=1006, joindate=2001-09-08, salary=15000.0, bonus=0.0, dept_id=30}
Emp{id=1011, ename=‘sand monk‘, job_id=4, mgr=1004, joindate=2007-05-23, salary=11000.0, bonus=0.0, dept_id=20}
Emp{id=1012, ename=‘Li Yan‘, job_id=4, mgr=1006, joindate=2001-12-03, salary=9500.0, bonus=0.0, dept_id=30}
Emp{id=1013, ename=‘Little White Dragon‘, job_id=4, mgr=1004, joindate=2001-12-03, salary=30000.0, bonus=0.0, dept_id=20}
Emp{id=1014, ename=‘Guan Yu‘, job_id=4, mgr=1007, joindate=2002-01-23, salary=13000.0, bonus=0.0, dept_id=10}

需求7的实现

package my.view.jdbctemplate;

import my.view.domain.Emp;
import my.view.utils.JdbcUtils;
import org.junit.Test;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;

import javax.sql.DataSource;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class JdbcTemplateDemoTest {
    /**
     * 查询总记录数
     */
    @Test
    public void queryTest08() {
        // 调用自己定义的工具类JdbcUtils，获取数据库连接池对象
        DataSource dataSource = JdbcUtils.getDataSource();

        // 获取JDBCTemplate对象
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

        // 定义预编译的SQL语句
        String sql = "SELECT COUNT(*) FROM emp;";

        // 执行SQL语句，查询的结果是一个Long类型的数，该方法传入Long类作为参数
        Long aLong = jdbcTemplate.queryForObject(sql, Long.class);

        // 输出查询结果
        System.out.println(aLong);
    }
}

运行测试，控制台输出：

14

1-7需求所有代码如下：

package my.view.jdbctemplate;

import my.view.domain.Emp;
import my.view.utils.JdbcUtils;
import org.junit.Test;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;

import javax.sql.DataSource;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * @Author: YiHua Lee
 * @Version: 1.8.0_201       Java SE 8
 * @Application: IntelliJ IDEA
 * @CreateTime: 2020/2/19 20:42
 * @Description:
 */
public class JdbcTemplateDemoTest {

    /**
     * 修改id = 1001数据的 salary 字段记录为 10000
     */
    @Test
    public void updateSetTest01() {
        // 调用自己定义的工具类JdbcUtils，获取数据库连接池对象
        DataSource dataSource = JdbcUtils.getDataSource();

        // 获取JDBCTemplate对象
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

        // 定义预编译的SQL语句
        String sql = "UPDATE emp SET salary = ? WHERE id = ?";

        // 执行SQL语句
        int update = jdbcTemplate.update(sql, 10000, 1001);

        // 输出执行SQL语句后的返回值
        System.out.println(update);
    }

    /**
     * 添加一条数据
     */
    @Test
    public void updateInsertTest02() {
        // 调用自己定义的工具类JdbcUtils，获取数据库连接池对象
        DataSource dataSource = JdbcUtils.getDataSource();

        // 获取JDBCTemplate对象
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

        // 定义预编译的SQL语句
        String sql = "INSERT INTO emp (id, ename, salary) VALUE (?, ?, ?)";

        // 执行SQL语句
        int insert = jdbcTemplate.update(sql, 1015, "LeeHua", 8000);

        // 输出执行SQL语句后的返回值
        System.out.println(insert);
    }

    /**
     * 删除刚才添加的记录
     */
    @Test
    public void updateDeleteTest03() {
        // 调用自己定义的工具类JdbcUtils，获取数据库连接池对象
        DataSource dataSource = JdbcUtils.getDataSource();

        // 获取JDBCTemplate对象
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

        // 定义预编译的SQL语句
        String sql = "DELETE FROM emp WHERE id = ?";

        // 执行SQL语句
        int delete = jdbcTemplate.update(sql, 1015);

        // 输出执行SQL语句后的返回值
        System.out.println(delete);
    }

    /**
     * 查询id为1001的记录，将其封装为Map集合
     */
    @Test
    public void queryForMapTest04() {
        // 调用自己定义的工具类JdbcUtils，获取数据库连接池对象
        DataSource dataSource = JdbcUtils.getDataSource();

        // 获取JDBCTemplate对象
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

        // 定义预编译的SQL语句
        String sql = "SELECT * FROM emp WHERE id = ?;";

        // 执行SQL语句
        Map<String, Object> stringObjectMap = jdbcTemplate.queryForMap(sql, 1001);

        // 获取Key值，即列名称
        Set<String> stringKey = stringObjectMap.keySet();

        // 获取Set集合的迭代器对象，并遍历该迭代器对象
        Iterator<String> ite = stringKey.iterator();
        while (ite.hasNext()) {
            // 通过迭代器对象中的每一个值(Map集合中的键)，获取key-value
            String key = ite.next();
            System.out.println(
                    "Key：" + key +
                            "    Value：" + stringObjectMap.get(key)
            );
        }
    }

    /**
     * 查询所有记录，将其封装为List
     */
    @Test
    public void queryForListTest05() {
        // 调用自己定义的工具类JdbcUtils，获取数据库连接池对象
        DataSource dataSource = JdbcUtils.getDataSource();

        // 获取JDBCTemplate对象
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

        // 定义预编译的SQL语句
        String sql = "SELECT * FROM emp;";

        // 执行SQL语句
        List<Map<String, Object>> stringObjectList = jdbcTemplate.queryForList(sql);

        // 输出查询结果
        stringObjectList.forEach(System.out::println);
    }

    /**
     * 1、查询所有记录，将其封装为Emp对象的List集合
     */
    @Test
    public void queryTest06() {
        // 调用自己定义的工具类JdbcUtils，获取数据库连接池对象
        DataSource dataSource = JdbcUtils.getDataSource();

        // 获取JDBCTemplate对象
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

        // 定义预编译的SQL语句
        String sql = "SELECT * FROM emp;";

        // 执行SQL语句，将其封装为Emp对象的List集合
        List<Emp> empList = jdbcTemplate.query(sql, new RowMapper<Emp>() {
            @Override
            public Emp mapRow(ResultSet resultSet, int i) throws SQLException {
                return new Emp(
                        // 员工ID
                        resultSet.getInt("id"),
                        // 员工姓名
                        resultSet.getString("ename"),
                        // 职务ID
                        resultSet.getInt("job_id"),
                        // 上级领导
                        resultSet.getInt("mgr"),
                        // 入职日期
                        resultSet.getDate("joindate"),
                        // 工资
                        resultSet.getDouble("salary"),
                        // 奖金
                        resultSet.getDouble("bonus"),
                        // 所在部门编号
                        resultSet.getInt("dept_id")
                );
            }
        });

//        List<Emp> empList1 = jdbcTemplate.query(sql, (ResultSet resultSet, int i) -> new Emp(
//                // 员工ID
//                resultSet.getInt("id"),
//                // 员工姓名
//                resultSet.getString("ename"),
//                // 职务ID
//                resultSet.getInt("job_id"),
//                // 上级领导
//                resultSet.getInt("mgr"),
//                // 入职日期
//                resultSet.getDate("joindate"),
//                // 工资
//                resultSet.getDouble("salary"),
//                // 奖金
//                resultSet.getDouble("bonus"),
//                // 所在部门编号
//                resultSet.getInt("dept_id")
//        ));
        // 输出查询结果
        empList.forEach(System.out::println);
    }

    /**
     * 2、查询所有记录，将其封装为Emp对象的List集合
     * BeanPropertyRowMapper<>() 类，实现了RowMapper<>()接口
     *
     * 使用BeanPropertyRowMapper<>() 类，将每一行数据存储到BeanPropertyRowMapper对象中，
     * 传入的类，用来存储数据的数据类型，必须都是包装类数据，如String、Integer
     */
    @Test
    public void queryTest07() {
        // 调用自己定义的工具类JdbcUtils，获取数据库连接池对象
        DataSource dataSource = JdbcUtils.getDataSource();

        // 获取JDBCTemplate对象
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

        // 定义预编译的SQL语句
        String sql = "SELECT * FROM emp;";

        // 执行SQL语句，将其封装为Emp对象的List集合
        List<Emp> empList = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Emp>(Emp.class));

        // 输出查询结果
        empList.forEach(System.out::println);
    }

    /**
     * 查询总记录数
     */
    @Test
    public void queryTest08() {
        // 调用自己定义的工具类JdbcUtils，获取数据库连接池对象
        DataSource dataSource = JdbcUtils.getDataSource();

        // 获取JDBCTemplate对象
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

        // 定义预编译的SQL语句
        String sql = "SELECT COUNT(*) FROM emp;";

        // 执行SQL语句，查询的结果是一个Long类型的数，该方法传入Long类作为参数
        Long aLong = jdbcTemplate.queryForObject(sql, Long.class);

        // 输出查询结果
        System.out.println(aLong);
    }
}

Spring JDBC 的简单使用

标签：简单   jar   聚合函数   param   ring   工具类   创建   mapper   方法   

原文地址：https://www.cnblogs.com/liyihua/p/14482474.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！