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集合 备注：这个方法查询的结果集长度只能是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);
}
}
运行程序，控制台输出：
表中的数据如下：
案例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);
}
}
运行测试，控制台输出：
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);
}
}
本篇文章由一文多发平台 ArtiPub 自动发布
正文到此结束
- 本文标签： 需求 key lib Job 类加载器 spring map 代码 实例 Connection 文章 id mysql db sql 领导 Select dataSource ACE IO druid tab apr 大数据 DOM 工资 Word mapper stream 测试 cat IDE 遍历 开发 删除 ORM junit 编译 数据库 数据 App 参数 http bean ResultSet ssl description UI CTO list core Property JDBC update https 时间 value src Logging 连接池 java ip 配置
- 版权声明： 本文为互联网转载文章，出处已在文章中说明(部分除外)。如果侵权，请联系本站长删除，谢谢。
- 本文海报： 生成海报一 生成海报二
热门推荐
相关文章
近期评论
-
666
-
文章和留言都翻到11页了 没有OOM
-
-
朋友，翻页到11页，及以后，会出现OOM，无法访问
-
-
-
-
版本号是多少，你可以下载哪个代码仓库，jdk选1.8 直接跑就行
-
-
Loading...
![[HBLOG]公众号](https://www.liuhaihua.cn/img/qrcode_gzh.jpg)
