JDBC---把查询的结果封装到相应的实体上(实体类entity) 把对每一张表的操作封装到相应的类上(操作类Dao)
目录
1.回顾
2.正文
3.把查询的结果封装到相应的实体上。
4. 把对每一张表的操作封装到相应的类上。
5. 使用try-catch-finally来处理异常
6.抽取一个dao的公共的父类。
6.1为什么要抽取父类
3.2 为添加 删除 修改抽取公共的方法
7.可变长度的参数
8. 总结
1.回顾
1. jdbc--查询功能。
2. sql注入的安全问题解决方案.
(1)加载驱动:Class.forName("mysql驱动名称");
(2)获取连接对象:Connection conn=DriverManager.getConnection(url,u,pass);
(3)获取执行sql语句的对象:
PreparedStatement ps=conn.prepareStatement(sql);//预编译sql
(4)为占位符赋值
ps.setXXX(index,value); //index:表示占位符的索引。value:表示占位符的值
(5)执行sql语句。
ps.executeUpdate();//执行增删改的sql
ResultSet rs=ps.executeQuery();//执行查询的sql
(6)遍历ResultSet中的内容.
while(rs.next()){ //判断指针是否可以移动，如果可以移动则移动到下一行记录
rs.getXXX("列名"); //获取当前行的指定列的值。
}
2.正文
1. 把查询的结果封装到相应的实体上。
2. 把对每一张表的操作封装到相应的类上。
3. 抽象操作类的公共父类。
3.把查询的结果封装到相应的实体上。 
注意: 我们这里把查询的结果直接输出到控制台了，而实际开发中，我们需要把查询的结果展示到浏览器网页上，效果如下
如何把查询的结果封装起来。
1. 把数据库中每张表封装成一个类---简称实体类。
2. 把表中的列封装成实体类中的属性。
3. 表中的每条记录封装成实体类的对象。
4. 表中多条记录封装成集合ArrayList。
//查询多条记录
@Test
public void testSelect() throws Exceotion{
Class.ForName("com.mysql.cj.jdbc.Driver");
String url = "jdbc:mysql://localhost3306/zy1?serverTimezone=Asia/Shanghai";
String user="root";
String password="root";
Connection connection = DriverManager.getConnection(url,user,password);
String sql="select * from t_stu";//因为这里没有占位符 所以可以不用为占位符赋值
PreparedStatement ps = connection.preparedstatement(sql);
ResulrSet rs = ps.executeQuery();
List list = new ArrayList<>(); //集合存放数据库表中所有记录
while(rs.next()){
int id= rs.getInt("id");
String name=rs.getString("name");
//创建一个实体类对象 存储表中的一条记录。
Student d = new Student();
d.setId(id);
d.setName(name);
list.add(d);
}
System.out.println(list);//正常再开发中应该把该对象list返回给前端。
}
} //查询一条记录
@Test
public void testSelectone() throws Exception{
Class.forName("com.mysql.cj.jdbc.Driver");
Connection connection = DriverManager.getConnection
("jdbc:mysql://localhost:3306/zy1?serverTimezone=Asia/Shanghai","root","root");
String sql = "select * from t_stu where id=?";
PreparedStatement ps = connection.prepareStatement(sql);
ps.setObject(1,2);
ResultSet rs = ps.executeQuery();
Student d = null;//声明部门类实体对象
while (rs.next()){
int id= rs.getInt("id");
String name= rs.getString("name");
d = new Student();//因为进入改语句表示从数据库中查询到相应的记录
d.setId(id);
d.setName(name);
}
System.out.println(d);
}如果查询的结果为多条记录使用ArrayList存储多条记录而每一条还是用实体类对象。
如果查询的结果确定为一条，直接使用实体类。
4. 把对每一张表的操作封装到相应的类上。
思考: 我们如果把所有表的操作都写在一个类中，那么该类的代码会变得越来越容重，对应后期维护也不方便，真正再企业开发时我们会对每张表得操作都封装一个对应得操作类。
后缀都是Dao -----Data access Object 数据访问对象层
tb_dept 对应一个操作类 DeptDao该操作类中包含所有对tb_dept表得增删改查得操作。
tb_student 对应一个操作 StudentDao
public class DeptDao {
private String driverName="com.mysql.cj.jdbc.Driver";
private String url="jdbc:mysql://localhost:3306/mydb?serverTimezone=Asia/Shanghai";
private String user="root";
private String password="root";
//根据id查询部门信息
public Dept findOne(int id) throws Exception{
Class.forName(driverName);
Connection connection = DriverManager.getConnection(url, user, password);
String sql = "select * from tb_dept where id=?"; //这里根据id查询的结果一定是一条记录。因为id是主键。
PreparedStatement ps= connection.prepareStatement(sql);
ps.setInt(1,id);
ResultSet rs = ps.executeQuery();
Dept d=null;//声明部门实体类对象。
while (rs.next()){
d = new Dept(); //因为进入该语句表示从数据库中查询到相应的记录了。
d.setId(rs.getInt("id"));
d.setName(rs.getString("name"));
}
return d;
}
//查询操作--查询所有
public List findAll() throws Exception{
List list=new ArrayList<>();
Class.forName(driverName);
Connection connection = DriverManager.getConnection(url,user,password);
String sql= "select * from tb_dept";
PreparedStatement ps=connection.prepareStatement(sql);
ResultSet rs = ps.executeQuery();
while (rs.next()){
//创建一个实体类对象 存储表中的一条记录。
Dept d = new Dept();
d.setId(rs.getInt("id"));
d.setName(rs.getString("name"));
list.add(d);
}
return list;
}
//增加操作--要不要传递参数
public void insertDept(Dept dept) throws Exception{ //把前端输入得部门信息封装到相应得实体类。
Class.forName(driverName);
Connection connection = DriverManager.getConnection(url,user,password);
String sql = "insert into tb_dept values(null,?)";
PreparedStatement ps = connection.prepareStatement(sql);
ps.setObject(1,dept.getName());
ps.executeUpdate();
}
//删除操作--根据id删除
public void delete(int id)throws Exception{
Class.forName(driverName);
Connection connection = DriverManager.getConnection(url,user,password);
String sql = "delete from tb_dept where id=?";
PreparedStatement ps = connection.prepareStatement(sql);
ps.setObject(1,id);
ps.executeUpdate();
}
} 5. 使用try-catch-finally来处理异常
package com.qy151.test3.com.ysh.dao;
import com.qy151.test3.com.ysh.entity.Student;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
/**
* @unthor : YSH
* @date : 20:51 2022/5/6
*/
public class StudentDao {
private String driverName = "com.mysql.cj.jdbc.Driver";
private String url = "jdbc:mysql://localhost:3306/zy1?serverTimezone=Asia/Shanghai";
private String user = "root";
private String password = "root";
PreparedStatement ps = null;
Connection connection = null;
ResultSet rs = null;
//增加操作
public void insert(Student student){
try {
Class.forName(driverName);
connection= DriverManager.getConnection(url,user,password);
String sql="insert into t_stu values(null,?)";
ps=connection.prepareStatement(sql);
ps.setObject(1,student.getName());
ps.executeUpdate();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException throwables) {
throwables.printStackTrace();
} finally {
try{
if(ps !=null){
ps.close();
}
if( connection !=null){
connection.close();
}
}catch (Exception e){
e.printStackTrace();
}
}
}
//删除操作
public void delete(int id){
try {
Class.forName(driverName);
connection = DriverManager.getConnection(url,user,password);
String sql="delete from t_stu where id=?";
ps=connection.prepareStatement(sql);
ps.setObject(1,id);
ps.executeUpdate();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException throwables) {
throwables.printStackTrace();
} finally {
try {
if (ps != null) {
ps.close();
}
if (connection != null) {
connection.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
//修改操作
public void update(int id){
try {
Class.forName(driverName);
connection=DriverManager.getConnection(url,user,password);
String sql="update t_stu set name='熊大' where id=?";
ps=connection.prepareStatement(sql);
ps.setObject(1,id);
ps.executeUpdate();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException throwables) {
throwables.printStackTrace();
} finally {
try {
if (ps != null) {
ps.close();
}
if (connection != null) {
connection.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
//根据id查询
public Student selectOne(int id) {
Student student = null;
try {
Class.forName(driverName);
connection = DriverManager.getConnection(url, user, password);
String sql = "select * from t_stu where id=?"; //这里根据id查询的结果一定是一条记录。因为id是主键。
ps = connection.prepareStatement(sql);
ps.setInt(1, id);
rs = ps.executeQuery();
while (rs.next()) {
student = new Student(); //因为进入该语句表示从数据库中查询到相应的记录了。
student.setId(rs.getInt("id"));
student.setName(rs.getString("name"));
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException throwables) {
throwables.printStackTrace();
} finally {
try {
if(rs!=null){
rs.close();
}
if(ps!=null){
ps.close();
}
if(connection!=null){
connection.close();
}
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
return student;
}
//查询全部
public List selectAll(){
List list = new ArrayList<>();
try {
Class.forName(driverName);
connection = DriverManager.getConnection(url, user, password);
String sql = "select * from t_stu";
ps = connection.prepareStatement(sql);
rs = ps.executeQuery();
while(rs.next()){
Student s = new Student();
s.setId(rs.getInt("id"));
s.setName(rs.getString("name"));
list.add(s);
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException throwables) {
throwables.printStackTrace();
} finally {
try {
if (rs != null) {
rs.close();
}
if (ps != null) {
ps.close();
}
if (connection != null) {
connection.close();
}
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
return list;
}
}
Test测试类：
package com.qy151.test3;
import com.qy151.test3.com.ysh.dao.StudentDao;
import com.qy151.test3.com.ysh.entity.Student;
import org.junit.Test;
import java.util.List;
/**
* @unthor : YSH
* @date : 20:50 2022/5/6
*/
public class TestStudentDao {
StudentDao studentDao = new StudentDao();
@Test
public void testInsert(){
Student student = new Student();
student.setName("光头强");
studentDao.insert(student);
}
@Test
public void testDelete(){
Student student = new Student();
student.setId(3);
studentDao.delete(3);
}
@Test
public void testUpdate(){
Student student = new Student();
student.setId(7);
studentDao.update(7);
}
@Test
public void testSelectone(){
Student one = studentDao.selectOne(2);
System.out.println(one.getId()+"\t"+one.getName());
}
//测试刚刚dao中写得查询所有方法
@Test
public void testSelectAll() {
List all = studentDao.selectAll();
for(Student s:all){
System.out.println(s.getId()+"\t"+s.getName());
}
}
}
6.抽取一个dao的公共的父类。
6.1为什么要抽取父类
因为我们对每一张表都封装了一个操作类，那么再数据库中有很多表，那么我们就会有很多操作类，这些操作类都有一些公共的代码，为了减少代码的冗余，我们就抽取了一个父类。
package com.qy151.test1.com.ysh.dao;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
/**
* @unthor : YSH
* @date : 12:29 2022/5/8
*该类就是一个父类。该类种包含子类中一些公共的属性和方法
*/
public class BaseDao {
//公共属性
private String driverName="com.mysql.cj.jdbc.Driver";
private String url="jdbc:mysql://localhost:3306/zy1?serverTimezone=Asia/Shanghai";
private String user="root";
private String password="root";
protected PreparedStatement ps = null;
protected Connection connection = null;
protected ResultSet rs = null;
//获取连接对象
public Connection getConnection() throws Exception{
Class.forName(driverName);
connection= DriverManager.getConnection(url,user,password);
return connection;
}
//关闭资源
public void coloseAll(){
try {
if (rs !=null){
rs.close();
}
if (connection !=null){
connection.close();
}
if (ps !=null){
ps.close();
}
}catch (Exception e){
e.printStackTrace();
}
}
}
3.2 为添加 删除 修改抽取公共的方法
父类的代码：
//抽取一个增删改 公共方法
public void edit(String sql,Object... params){
try {
connection = getConn();
//意外
ps = connection.prepareStatement(sql);
//为占位符赋值
for(int i=0;i子类的代码 :
package com.qy151.test1.com.ysh.dao;
import com.qy151.test1.com.ysh.entity.Emp;
import java.util.ArrayList;
import java.util.List;
/**
* @unthor : YSH
* @date : 12:29 2022/5/8
*/
public class EmpDao extends BaseDao{
//增加操作
public void insert(Emp emp){
String sql="insert into tb_emp values(null,?,?,?,?,?,?,?)";
edit(sql,emp.getEname(),emp.getAge(),emp.getJob(),emp.getSalary(),emp.getEntrydate(),emp.getManagerid(),emp.getDept_id());
}
//删除操作 根据ID 删除
public void dalete(int id){
String sql="delete from tb_emp where id=?";
edit(sql,id);
}
//修改操作 根据ID修改
public void update(int id){
String sql="update tb_emp set ename='殷素素' where id=?";
edit(sql,id);
}
//根据ID查询
public Emp selectone(int id){
Emp emp=null;
try{
connection = getConnection();
String sql = "select * from tb_emp where id=?";
ps=connection.prepareStatement(sql);
ps.setObject(1,2);
rs = ps.executeQuery();
while (rs.next()){
emp = new Emp();
emp.setId(rs.getInt("id"));
emp.setEname(rs.getString("ename"));
emp.setAge(rs.getInt("age"));
emp.setJob(rs.getString("job"));
emp.setSalary(rs.getInt("salary"));
emp.setEntrydate(rs.getDate("entrydate"));
emp.setManagerid(rs.getInt("managerid"));
emp.setDept_id(rs.getInt("dept_id"));
}
}catch (Exception e){
e.printStackTrace();
}finally {
coloseAll();
}
return emp;
}
//查询所有
public List selectAll(){
List list=new ArrayList<>();
try{
connection = getConnection();
String sql = "select * from tb_emp";
ps=connection.prepareStatement(sql);
rs = ps.executeQuery();
while(rs.next()){
Emp e = new Emp();
e.setId(rs.getInt("id"));
e.setEname(rs.getString("ename"));
e.setAge(rs.getInt("age"));
e.setJob(rs.getString("job"));
e.setSalary(rs.getInt("salary"));
e.setEntrydate(rs.getDate("entrydate"));
e.setManagerid(rs.getInt("managerid"));
e.setDept_id(rs.getInt("dept_id"));
list.add(e);
}
}catch(Exception e){
e.printStackTrace();
}finally {
coloseAll();
}
return list;
}
}
测试类：
package com.qy151.test1;
import com.qy151.test1.com.ysh.dao.EmpDao;
import com.qy151.test1.com.ysh.entity.Emp;
import org.junit.Test;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
/**
* @unthor : YSH
* @date : 12:28 2022/5/8
*/
public class TestEmpDao {
EmpDao empDao = new EmpDao();
@Test
public void testInsert(){
Emp emp = new Emp();
emp.setEname("张翠山");
emp.setAge(44);
emp.setJob("总经理");
emp.setSalary(14000);
SimpleDateFormat sdf = new SimpleDateFormat("yyy-MM-dd");
Date date =null;
try {
date = sdf.parse("2001-01-01");
} catch (ParseException e) {
e.printStackTrace();
}
emp.setEntrydate(date);
emp.setManagerid(1);
emp.setDept_id(1);
empDao.insert(emp);
}
@Test
public void testDelete(){
Emp emp = new Emp();
emp.setId(17);
empDao.dalete(17);
}
@Test
public void testUpdate(){
Emp emp = new Emp();
emp.setId(18);
empDao.update(18);
}
@Test
public void testSelectone(){
Emp one = empDao.selectone(2);
System.out.println(one.getId()+"\t"+one.getEname()+"\t"+one.getAge()+"\t"+one.getJob()+"\t"+one.getSalary()+"\t"+one.getEntrydate()+"\t"+
one.getManagerid()+"\t"+one.getDept_id());
}
@Test
public void testSelectAll(){
List all = empDao.selectAll();
for (Emp e:all){
System.out.println(e.getId()+"\t"+e.getEname()+"\t"+e.getAge()+"\t"+e.getJob()+"\t"+e.getSalary()+"\t"+e.getEntrydate()+"\t"+
e.getManagerid()+"\t"+e.getDept_id());
}
}
}
7.可变长度的参数
Object ... a : ...表示可变长度的参数
public class Test {
public static void main(String[] args) {
// fun("hello");
// fun(23);
// fun(15.6);
fun02(); //
fun02("hello");
fun02("hello",153);
fun02("hello",153,25.6);
}
//...可变参可以理解为把实参封装到数组中
public static void fun02(Object ... a){ //...表示可变长度的参数
for(int i=0;i8. 总结
1. 再数据库中每张表封装了一个实体类和一个操作类。
实体类---与表中列对应得类。
操作类---对该表进行相应操作得类。--对表得增删改查。2.异常处理try-catch-finally
3. 抽取操作类dao的父类