Spring JDBC 的简单使用
Spring框架对JDBC的简单封装。提供了一个JDBCTemplate对象简化JDBC的开发。
使用步骤
-
导入架包：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 -
创建JdbcTemplate对象。
JdbcTemplate template = new JdbcTemplate(new DataSource); // 创建JdbcTemplate对象，需要传入数据库连接池对象。 -
调用JdbcTemplate的方法，对数据库进行操作：
update() // 执行insert into、delete、set语句（增、删、改）queryForMap() // 查询结果将结果集封装为map集合，将列名作为key，将值作 value 将这条记录封装为一个map集合 备注：这个方法查询的结果集长度只能是1queryForList() // 查询结果将结果集封装为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表格
需求
-
修改id = 1001数据的 salary 字段记录为 10000
-
添加一条记录
-
删除刚才添加的记录
-
查询id为1001的记录，将其封装为Map集合
-
查询所有记录，将其封装为List
-
查询所有记录，将其封装为Emp对象的List集合
-
查询总记录数
实现前，为了后续的实现方便：创建一个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);
}
}
本文来自博客园，作者：LeeHua，转载请注明原文链接：https://www.cnblogs.com/liyihua/p/14482474.html
