码迷,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
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!