一、概念
Spring JDBC使用时还是得用到上一篇博客的druip和它的JDBCUtils的配置的，只不过它那些获取pstmt对象和.close方法就可以不用写（JdbcTemplate对象自动帮你弄好和关闭啥的，你只要专注写sql就行），就更加方便一点。 （传送门：上一篇博客）
JdbcTemplate对象还是得用到druip和它的JDBCUtils，所以我们直接在上一篇博客下，添加驱动和创个JDBCTemplate_tset包：
二、演示上面所说的增删改，查询封装为对象
我们要对这个数据库进行操作：
需求：
1. 修改1号数据的 salary 为 10000
2. 添加一条记录
3. 删除刚才添加的记录
4. 查询id为1的记录，将其封装为Map集合
5. 查询所有记录，将其封装为List
6. 查询所有记录，将其封装为Emp对象的List集合 （就是把数据库表中的每一行封装为你对应实体类的一个对象，返回一个list，那么你遍历这个list，就是你表中有多少行数据就输出多少个对象）
6. 查询总记录数
首先我们先创建数据库对应的实体类对象Emp（实体表中的成员变量设为包装类，防止查到的数据表的数据为null存为基本类型有可能空指针异常）：（不清楚可以看）
（只有下下面代码中的template.query中的test6和test_02才要用Emp实体类）
package cn.qlbf.domain;
import java.util.Date;
/**
* @author QLBF
* @version 1.0
* @date 2020/11/19 20:20
*/
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 +
'}';
}
}
query封装为对象，就是把数据库表的每一行数据封装为你对应数据库表的实体类对象，数据库表的每一行就封装为一个对象，然后你就可以拿这对象来干嘛就干嘛了
queryForObject还可以查表中的一行返回实体类对象，其实query也可以查一个对象，只不过它返回的是list而不是实体类对象：
queryForObject与query的区别，queryForObject只能返回一个对象，而query可返回一个对象也可以返回一个封装多个对象的集合
public User login(User loginUser){
try {
//1.编写sql
String sql = "select * from user where username = ? and password = ?";
//2.调用query方法
User user = template.queryForObject(sql,
new BeanPropertyRowMapper<User>(User.class),
loginUser.getUsername(), loginUser.getPassword());
return user;
}
然后我们就可以写需求的代码了：
package cn.qlbf.JDBCTemplate_tset;
import cn.qlbf.domain.Emp;
import cn.qlbf.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 java.sql.Date;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;
public class demo01{
//Junit单元测试，可以让方法独立执行
//1. 获取JDBCTemplate对象,放在这里当成员变量，这样下面方法test就不用每次都加上了
private JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
/**
* 1. 修改id为1001号数据的 salary 为 10000
*/
@Test
public void test1(){
//2. 定义sql，emp为数据库表
String sql = "update emp set salary = ? where id = ？";
//3. 执行sql
int count = template.update(sql，10000,1001);
System.out.println(count);
}
/**
* 2. 添加一条记录
*/
@Test
public void test2(){
String sql = "insert into emp(id,ename,dept_id) values(?,?,?)";
int count = template.update(sql, 1015, "郭靖", 10);
System.out.println(count);
}
/**
* 3.删除刚才添加的记录
*/
@Test
public void test3(){
String sql = "delete from emp where id = ?";
int count = template.update(sql, 1015);
System.out.println(count);
}
/**
* 4.查询id为1001的记录，将其封装为Map集合
* 注意：这个方法查询的结果集长度只能是1
*/
@Test
public void test4(){
String sql = "select * from emp where id = ? ";
//String sql = "select * from emp where id = ? or id = ?";//查不了，expected 1, actual 2
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}
Set<String> set = map.keySet();
for (String key : set) {
Object value = map.get(key);
System.out.println(key+":"+value);
/* 输出 id:1001
ename:孙悟空
job_id:4
mgr:1004
joindate:2000-12-17
salary:19999.00
bonus:null
dept_id:20*/
}
}
/**
* 5. 查询所有记录，将其封装为List
*/
@Test
public void test5(){
String sql = "select * from emp";
List<Map<String, Object>> list = template.queryForList(sql);
for (Map<String, Object> stringObjectMap : list) {
System.out.println(stringObjectMap);
}
}
/**
* 6. 查询所有记录，将其封装为Emp对象的List集合
*/
@Test
public void test6(){
String sql = "select * from emp";
//自己实现RowMapper<Emp>接口比较麻烦(需自己实现抽象方法)，所以我们一般使用test6_2的方法
List<Emp> list = template.query(sql, new RowMapper<Emp>() {
@Override
public Emp mapRow(ResultSet rs, int i) throws SQLException {
Emp emp = new Emp();
//rs.getInt()括号里面是mysql的列名
int id = rs.getInt("id");
String ename = rs.getString("ename");
int job_id = rs.getInt("job_id");
int mgr = rs.getInt("mgr");
Date joindate = rs.getDate("joindate");
double salary = rs.getDouble("salary");
double bonus = rs.getDouble("bonus");
int dept_id = rs.getInt("dept_id");
//下面setId等方法，是你对应实体类的方法
emp.setId(id);
emp.setEname(ename);
emp.setJob_id(job_id);
emp.setMgr(mgr);
emp.setJoindate(joindate);
emp.setSalary(salary);
emp.setBonus(bonus);
emp.setDept_id(dept_id);
return emp;
}
});
for (Emp emp : list) {
System.out.println(emp);
}
}
/**
* 6. 查询所有记录，将其封装为Emp对象的List集合
*/
@Test
public void test6_2(){
String sql = "select * from emp";
//Emp.class是你对应的实体类的字节码文件
List<Emp> list = template.query(sql, new BeanPropertyRowMapper<Emp>(Emp.class));
for (Emp emp : list) {
//获取对象就可以做很多事情了，可以单单输出它们的姓名
System.out.println(emp);
}
}
/**
* 7. 查询总记录数
*/
@Test
public void test7(){
String sql = "select count(id) from emp";
//写对应查出来的包装类型.class，若查出来是int类型，则写Integer.class
Long total = template.queryForObject(sql, Long.class);
System.out.println(total);
}
}
扫一扫
2758
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
