定义必要的信息、获取数据库连接、释放资源时重复的代码，而我们最终的核心功能仅仅只是执行一条sql语句，所以我们可以抽取一个JDBC模板类，来封装一些方法（update，query），专门帮我们执行增删改查的sql语句。将之前那些重复的操作，都抽取到模板类的方法里，就能大大简化我们的使用步骤。
4.2 源信息DataBaseMetaData：数据库的源信息（了解）
java.DataBaseMeta封装了整个数据库的综合信息
例如：
String getDatabaseProductName()：获取数据库产品的名称
int getDatabaseProductVersion()：获取数据库产品的版本号
ParameterMetaData：参数的源信息
java.sql.ParameterMetaData封装的是预编译执行者对象中每个参数的类型和属性，这个对象可以通过预编译执行者对象中的getParameterMetaData()方法来获取
核心功能：int getParameterCount()用于获取sql语句中参数的个数
ResultSetMetaData：结果集的源信息
java.sql.ResultSetMetaData：封装的是结果集对象中列的类型和属性，这个对象可以通过结果集对象中的getMetaData()方法来获取
核心功能：int getColumnCount()用于获取列的综述，String getColumnName(int i)用于获取列名
① 定义所需要成员变量（数据源、数据库连接、执行者、结果集）
② 定义有参构造，为数据源对象赋值
③ 定义update()方法，参数：sql语句、sql语句所需参数
④ 定义int类型变量，用于接受sql语句执行后影响的行数
⑤ 通过数据源获取一个数据库连接
⑥ 通过数据库连接对象获取执行者对象并对sql语句预编译
⑦ 通过执行者对象获取sql语句中参数的源信息对象
⑧ 通过数据源信息对象获取sql语句中参数的个数
⑨ 判断参数个数是否一致
⑩ 为sql语句中?占位符赋值
11 执行sql语句并接受结果
12 释放资源
13 返回结果
package jdbc04;
import druid.DataSourceUtils;
import javax.sql.DataSource;
import java.sql.*;
public class JDBCTemplate {
//1 定义所需要成员变量（数据源、数据库连接、执行者、结果集）
private DataSource dataSource;
private Connection con;
private PreparedStatement pst;
private ResultSet rs;
//2 定义有参构造，为数据源对象赋值
public JDBCTemplate(DataSource dataSource){
this.dataSource = dataSource;
}
//3 定义update()方法，参数：sql语句、sql语句所需参数
public int update(String sql,Object...objs){
//4 定义int类型变量，用于接受sql语句执行后影响的行数
int result = 0;
try {
//5 通过数据源获取一个数据库连接
con = dataSource.getConnection();
//6 通过数据库连接对象获取执行者对象并对sql语句预编译
pst = con.prepareStatement(sql);
//7 通过执行者对象获取sql语句中参数的源信息对象
ParameterMetaData parameterMetaData = pst.getParameterMetaData();
//8 通过数据源信息对象获取sql语句中参数的个数
int count = parameterMetaData.getParameterCount();
//9 判断参数个数是否一致
if(count != objs.length){
throw new RuntimeException("参数个数不匹配");
}
//10 为sql语句中?占位符赋值
for (int i = 0;i < objs.length;i++) {
pst.setObject(i+1,objs[i]);
}
//11 执行sql语句并接受结果
result = pst.executeUpdate();
} catch (Exception e) {
e.printStackTrace();
}finally {
//12 释放资源
DataSourceUtils.close(con,pst);
}
//13 返回结果
return result;
}
}
测试：
package jdbc04;
import druid.DataSourceUtils;
import org.junit.Test;
public class JDBCTemplateTest1 {
private JDBCTemplate template = new JDBCTemplate(DataSourceUtils.getDataSource());
@Test
public void insert(){
//新增或数据测试
String sql = "insert into student values(?,?,?,?)";
Object[] params = {10,"周周",27,"1997-07-07"};
int result = template.update(sql,params);
if(result != 0){
System.out.println("添加成功");
}else{
System.out.println("添加失败");
}
}
@Test
public void update(){
//修改数据的测试
String sql = "update student set age=? where name=?";
Object[] params = {37,"周周"};
int result = template.update(sql,params);
System.out.println(result);
}
@Test
public void delete(){
//删除数据的测试
String sql="delete from student where name=?";
int result = template.update(sql,"周周");
System.out.println(result);
}
}
4.3.2 用于查询的方法
用于执行查询功能的方法介绍
- 查询一条记录并封装对象的方法：queryForObject()
- 查询多条记录并封装集合的方法：queryForList()
- 查询聚合函数并返回单条数据的方法：queryForScalar()
1）实体类的编写
定义一个类，提供一些成员变量
注意：成员变量的数据类型和名称要和表中的列保持一致。
package jdbc04.domain;
import java.util.Date;
public class Student {
private Integer sid;
private String name;
private Integer age;
private Date birthday;
public Student(){}
public Student(Integer sid, String name, Integer age, Date birthday) {
this.sid = sid;
this.name = name;
this.age = age;
this.birthday = birthday;
}
public Integer getSid() {
return sid;
}
public void setSid(Integer sid) {
this.sid = sid;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
@Override
public String toString() {
return "Student{" +
"sid=" + sid +
", name='" + name + ''' +
", age=" + age +
", birthday=" + birthday +
'}';
}
}
2）处理结果集的接口
① 定义泛型接口ResultSetHandler
② 定义用于处理结果集的泛型方法 T handler(ResultSet rs)
注意：此接口仅用于为不同处理结果集的方法提供规范，具体的实现类还需要自行编写
package jdbc04.handler; import java.sql.ResultSet; public interface ResultSetHandler{ T handler(ResultSet rs); }
3）处理结果集的接口实现类1
实现类1：用于将查询到的一条记录，封装为Student对象并返回
实现步骤：
1.定义一个类，实现ResultSetHandler接口
2.定义Class对象类型变量
3.通过有参构造为变量赋值
4.重写handler方法。用于将一条记录封装到自定义对象中
5.声明自定义对象类型
6.创建传递参数的对象，为自定义对象赋值
7.判断结果集中是否有数据
8.通过结果集对象获取结果集源信息的对象
9.通过结果集源信息对象获取列数
10.通过循环遍历列数
11.通过结果集源信息对象获取列名
12.通过列名获取该列的数据
13.创建属性描述器对象，将获取到的值通过该对象的set方法进行赋值
14.返回封装好的对象
package jdbc04.handler; import java.beans.PropertyDescriptor; import java.lang.reflect.Method; import java.sql.ResultSet; import java.sql.ResultSetMetaData; import java.util.Locale; // 1.定义一个类，实现ResultSetHandler接口 public class BeanHandlerimplements ResultSetHandler { // 2.定义Class对象类型变量 private Class beanClass; // 3.通过有参构造为变量赋值 public BeanHandler(Class beanClass){ this.beanClass = beanClass; } // 4.重写handler方法。用于将一条记录封装到自定义对象中 @Override public T handler(ResultSet rs) { // 5.声明自定义对象类型 T bean = null; try { // 6.创建传递参数的对象，为自定义对象赋值 bean = beanClass.newInstance(); // 7.判断结果集中是否有数据 if(rs.next()){ // 8.通过结果集对象获取结果集源信息的对象 ResultSetMetaData metaData = rs.getMetaData(); // 9.通过结果集源信息对象获取列数 int count = metaData.getColumnCount(); // 10.通过循环遍历列数 for(int i = 1;i <= count;i++){ // 11.通过结果集源信息对象获取列名 String columnName = metaData.getColumnName(i); // 12.通过列名获取该列的数据 Object value = rs.getObject(columnName); // 13.创建属性描述器对象，将获取到的值通过该对象的set方法进行赋值 PropertyDescriptor pd = new PropertyDescriptor(columnName.toLowerCase(), beanClass); // 获取set方法 Method writeMethod = pd.getWriteMethod(); // 执行set方法，给成员变量赋值 writeMethod.invoke(bean,value); } } } catch ( Exception e) { e.printStackTrace(); } // 14.返回封装好的对象 return bean; } }
4）用于查询一条记录并封装对象的方法queryForObject()
1.定义方法queryForObject()，参数：sql语句、处理结果集接口、sql语句中的参数
2.声明自定义对象
3.通过数据源获取数据库连对象
4.通过数据库对象获取执行者对象并对sql语句进行预编译
5.通过执行者对象获取参数源信息的对象
6.通过参数源信息对象获取参数的个数
7.判断参数量是否一致
8.为sql语句中?占位符赋值
9.执行sql语句并接受结果集
10.通过结果集接口对结果集进行处理
11.释放资源
12.返回结果
在JDBCTemplate中添加
public T queryForObject(String sql, ResultSetHandler rsh,Object...objs){
// 2.声明自定义对象
T obj = null;
try {
//3 通过数据源获取一个数据库连接
con = dataSource.getConnection();
//4 通过数据库连接对象获取执行者对象并对sql语句预编译
pst = con.prepareStatement(sql);
//5 通过执行者对象获取sql语句中参数的源信息对象
ParameterMetaData parameterMetaData = pst.getParameterMetaData();
//6 通过数据源信息对象获取sql语句中参数的个数
int count = parameterMetaData.getParameterCount();
//7 判断参数个数是否一致
if(count != objs.length){
throw new RuntimeException("参数个数不匹配");
}
//8 为sql语句中?占位符赋值
for (int i = 0;i < objs.length;i++) {
pst.setObject(i+1,objs[i]);
}
//9 执行sql语句并接受结果
rs = pst.executeQuery();
// 10 通过结果集接口对结果集进行处理
obj = rsh.handler(rs);
} catch (Exception e) {
e.printStackTrace();
}finally {
//11 释放资源
DataSourceUtils.close(con,pst);
}
//12.返回结果
return obj;
}
测试(JDBCTemplateTest1中)
@Test
public void queryForObject(){
String sql = "select * from student where sid=?";
Student stu = template.queryForObject(sql, new BeanHandler<>(Student.class), 1);
System.out.println(stu);
}
5）处理结果集的接口实现类2
1.定义BeanListHandler类事项ResultSetHandler接口
2.定义Class对象类型变量
3.通过有参构造为变量赋值
4.重写handler方法。用于将多条记录封装到自定义对象中并添加到集合中返回
5.创建List集合对象
6.遍历结果集对象
7.创建传递参数的对象
8.通过结果集对象获取结果集源信息的对象
9.通过结果集源信息对象获取列数
10.通过循环遍历列数
11.通过结果集源信息对象获取列名
12.通过列名获取该列的数据
13.创建属性描述器对象，将获取到的值通过该对象的set方法进行赋值
14.返回封装好的对象到集合中
15.返回集合对象
package jdbc04.handler; import java.beans.PropertyDescriptor; import java.lang.reflect.Method; import java.sql.ResultSet; import java.sql.ResultSetMetaData; import java.util.ArrayList; import java.util.List; //1.定义BeanListHandler类事项ResultSetHandler 接口 public class BeanListHandler implements ResultSetHandler { // 2.定义Class对象类型变量 private Class beanClass; // 3.通过有参构造为变量赋值 public BeanListHandler(Class beanClass){ this.beanClass = beanClass; } // 4.重写handler方法。用于将多条记录封装到自定义对象中并添加到集合中返回 @Override public List handler(ResultSet rs) { // 5.创建List集合对象 List list = new ArrayList<>(); try { // 6 遍历结果集对象 while(rs.next()){ // 7.创建传递参数的对象 T bean = beanClass.newInstance(); // 8.通过结果集对象获取结果集源信息的对象 ResultSetMetaData metaData = rs.getMetaData(); // 9.通过结果集源信息对象获取列数 int count = metaData.getColumnCount(); // 10.通过循环遍历列数 for(int i = 1;i <= count;i++){ // 11.通过结果集源信息对象获取列名 String columnName = metaData.getColumnName(i); // 12.通过列名获取该列的数据 Object value = rs.getObject(columnName); // 13.创建属性描述器对象，将获取到的值通过该对象的set方法进行赋值 PropertyDescriptor pd = new PropertyDescriptor(columnName.toLowerCase(), beanClass); // 获取set方法 Method writeMethod = pd.getWriteMethod(); // 执行set方法，给成员变量赋值 writeMethod.invoke(bean,value); // 14.返回封装好的对象到集合中 } list.add(bean); } } catch ( Exception e) { e.printStackTrace(); } // 15.返回封装好的对象 return list; } }
6）用于查询多条记录并封装集合的方法queryForList()
1.定义方法queryForList()，参数：sql语句、处理结果集接口、sql语句中的参数
2.创建集合对象
3.通过数据源获取数据库连对象
4.通过数据库对象获取执行者对象并对sql语句进行预编译
5.通过执行者对象获取参数源信息的对象
6.通过参数源信息对象获取参数的个数
7.判断参数量是否一致
8.为sql语句中?占位符赋值
9.执行sql语句并接受结果集
10.通过结果集接口对结果集进行处理
11.释放资源
12.返回结果
添加在JDBCTemplate中
public List queryForList(String sql, ResultSetHandler rsh, Object...objs){
// 2.创建集合对象
List list = new ArrayList<>();
try {
//3 通过数据源获取一个数据库连接
con = dataSource.getConnection();
//4 通过数据库连接对象获取执行者对象并对sql语句预编译
pst = con.prepareStatement(sql);
//5 通过执行者对象获取sql语句中参数的源信息对象
ParameterMetaData parameterMetaData = pst.getParameterMetaData();
//6 通过数据源信息对象获取sql语句中参数的个数
int count = parameterMetaData.getParameterCount();
//7 判断参数个数是否一致
if(count != objs.length){
throw new RuntimeException("参数个数不匹配");
}
//8 为sql语句中?占位符赋值
for (int i = 0;i < objs.length;i++) {
pst.setObject(i+1,objs[i]);
}
//9 执行sql语句并接受结果
rs = pst.executeQuery();
// 10 通过结果集接口对结果集进行处理
list = rsh.handler(rs);
} catch (Exception e) {
e.printStackTrace();
}finally {
//11 释放资源
DataSourceUtils.close(con,pst);
}
//12.返回结果
return list;
}
测试（JDBCTemplateTest1中）
@Test
public void queryForList(){
//查询所有学生信息的测试
String sql = "select * from student";
List list = template.queryForList(sql, new BeanListHandler<>(Student.class));
for (Student stu : list) {
System.out.println(stu);
}
}
7）处理结果集的接口实现类3
1.定义ScalarHandler类实现ResultSetHandler接口
2.重写handler()方法，用于返回一个聚合函数的查询结果
3.定义Long类型变量
4.判断结果集对象是否有数据
5.通过结果集对象获取结果集源信息的对象
6.通过结果集源信息对象获取第一列的列名
7.通过列名获取该列的数据
8.将结果返回
package jdbc04.handler; import java.sql.ResultSet; import java.sql.ResultSetMetaData; import java.sql.SQLException; //1.定义ScalarHandler类实现ResultSetHandler 接口 public class ScalarHandler implements ResultSetHandler { // 2.重写handler()方法，用于返回一个聚合函数的查询结果 @Override public Long handler(ResultSet rs) { // 3.定义Long类型变量 Long value = null; try { // 4.判断结果集对象是否有数据 if(rs.next()){ // 5.通过结果集对象获取结果集源信息的对象 ResultSetMetaData metaData = rs.getMetaData(); // 6.通过结果集源信息对象获取第一列的列名 String columnName = metaData.getColumnName(1); // 7.通过列名获取该列的数据 value = rs.getLong(columnName); } } catch (Exception e) { e.printStackTrace(); } // 8.将结果返回 return value; } }
8）用于执行聚合函数sql语句的方法queryForScalar()
1.定义方法queryForScalar()，参数：sql语句、处理结果集接口、sql语句中的参数
2.创建Long类型变量
3.通过数据源获取数据库连对象
4.通过数据库对象获取执行者对象并对sql语句进行预编译
5.通过执行者对象获取参数源信息的对象
6.通过参数源信息对象获取参数的个数
7.判断参数量是否一致
8.为sql语句中?占位符赋值
9.执行sql语句并接受结果集
10.通过ScalarHandler对结果集进行处理
11.释放资源
12.返回结果
在JDBCTemplate中添加
public Long queryForScalar(String sql, ResultSetHandler rsh, Object...objs){
// 2.创建集合对象
Long value = null;
try {
//3 通过数据源获取一个数据库连接
con = dataSource.getConnection();
//4 通过数据库连接对象获取执行者对象并对sql语句预编译
pst = con.prepareStatement(sql);
//5 通过执行者对象获取sql语句中参数的源信息对象
ParameterMetaData parameterMetaData = pst.getParameterMetaData();
//6 通过数据源信息对象获取sql语句中参数的个数
int count = parameterMetaData.getParameterCount();
//7 判断参数个数是否一致
if(count != objs.length){
throw new RuntimeException("参数个数不匹配");
}
//8 为sql语句中?占位符赋值
for (int i = 0;i < objs.length;i++) {
pst.setObject(i+1,objs[i]);
}
//9 执行sql语句并接受结果
rs = pst.executeQuery();
// 10 通过ScalarHandler对结果集进行处理
value = rsh.handler(rs);
} catch (Exception e) {
e.printStackTrace();
}finally {
//11 释放资源
DataSourceUtils.close(con,pst);
}
//12.返回结果
return value;
}
测试(JDBCTemplateTest1中)
@Test
public void queryForScalar(){
//查询聚合函数的测试
String sql = "select count(*) from student";
Long value = template.queryForScalar(sql, new ScalarHandler());
System.out.println(value);
}
