编写Student类
package come.example.jdbc.chapter01;
/**
* @Classname Student
* @Description
* @Author Jay lan
* @Date 2023/9/13 16:30
* @Version 1.0.0
*/
public class Student {
private int sid;
private String sname;
private String age;
private String course;
public Student()
{
//构造方法中隐式的调用super() 这里为了清晰性进行显示的调用
super();
}
public Student(int sid,String sname,String age,String course){
super();
this.sid=sid;
this.sname=sname;
this.age=age;
this.course=course;
}
public int getSid() {
return sid;
}
public void setSid(int sid) {
this.sid = sid;
}
public String getSname() {
return sname;
}
public void setSname(String sname) {
this.sname = sname;
}
public String getAge() {
return age;
}
public void setAge(String age) {
this.age = age;
}
public String getCourse() {
return course;
}
public void setCourse(String course) {
this.course = course;
}
/**
* @Description 重写toString方法
* @return Student对象信息
*/
public String toString()
{
return "Student [id="+sid+",sname="+sname+",age="+age+",course="+course+"]";
}
}
- 构造方法中会隐式的调用super() 为了清晰性和可读性 可以直接进行显式调用
- 数据的类时要成员变量以及其getter和setter方法，另外还可以重写toString方法
Q:为什么重写toString方法?
A:为了易于理解和表示，默认的情况下toString方法会返回对象类型+哈希码构成的字符串重写能使其更直观
JDBCUtils类
package come.example.jdbc.chapter01;
import java.sql.*;
/**
* @Classname JDBCUtils
* @Description JDBC工具类
* @Author Jay lan
* @Date 2023/9/13 16:41
* @Version 1.0.0
*/
public class JDBCUtils {
//使用final修饰可以防止被修改
private static final String url = "jdbc:mysql://localhost:3306/chapter01?useSSL=false";
private static final String username = "root";
private static final String password = "Xi233";
private static final Connection connection;
//
static {
try {
Class.forName("com.mysql.cj.jdbc.Driver");
connection = DriverManager.getConnection(url, username, password);
} catch (Exception exception) {
exception.printStackTrace();
// 数据库连接失败抛出运行时异常,程序停止
throw new RuntimeException("数据库连接失败");
}
}
/**
* @Description: 获取连接
* @param: null
* @Return: 获取到的连接对象
* @Date: 2023/9/13 16:58
* @Author: Jay lan
*/
public static Connection getConnection() {
return connection;
}
/**
* @Description: 释放资源
* @param: connection
* @param: preparedStatement
* @param: resultSet
* @Return: void
* @Date: 2023/9/13 16:58
* @Author: Jay lan
*/
public static void release(Connection connection, PreparedStatement preparedStatement, ResultSet resultSet) {
// 先判断对象是否为空
if (resultSet != null) {
// 尝试释放并捕捉错误
try {
if (resultSet != null) {
resultSet.close();
}
} catch (SQLException e) {
e.printStackTrace();
}
// 将对象引用设置为null 目的是什么?
resultSet = null;
}
release(connection, preparedStatement);
}
public static void release(Connection connection, PreparedStatement preparedStatement) {
if (preparedStatement != null) {
try {
preparedStatement.close();
} catch (SQLException e) {
e.printStackTrace();
}
preparedStatement = null;
}
if (connection != null) {
try {
connection.close();
} catch (SQLException e) {
e.printStackTrace();
}
connection = null;
}
}
}
在写JDBC工具类时主要完成以下几个需求
- 注册驱动
- 获取链接
- 资源释放
注册驱动和获取连接可以写成静态代码块，获取连接的方法可以使用static修饰方便调用
Q:为什么用final来修饰url，username，password变量
A:能避免这些变量被以外修改，提高代码的可读性(只要是final修饰就能确定这些是在整个程序中不变的)
Dto类
提供对数据库的增删查改功能
package come.example.jdbc.chapter01;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
/**
* @Classname StudentDao
* @Description StudentDao类
* @Author Jay lan
* @Date 2023/9/13 17:07
* @Version 1.0.0
*/
public class StudentDao {
/**
* @Description: 添加一条学生记录
* @param: student 学生对象
* @Return: boolean 判断是否添加成功
* @Date: 2023/9/13 17:08
* @Author: Jay lan
*/
public boolean insert(Student student) {
boolean flag = false;
// 创建预编译对象
PreparedStatement insertPreparedStatement = null;
// 使用JDBC工具类获取连接
Connection conn = JDBCUtils.getConnection();
// 预编译SQL语句
String insertSql = "INSERT INTO student(sid,sname,age,course) VALUES(?,?,?,?)";
// INSERT INTO student(sid,sname,age,course) VALUES(?,?,?,?)
try {
// 预编译SQL
insertPreparedStatement = conn.prepareStatement(insertSql);
// 给SQL语句设置参数
insertPreparedStatement.setInt(1, student.getSid());
insertPreparedStatement.setString(2, student.getSname());
insertPreparedStatement.setString(3, student.getAge());
insertPreparedStatement.setString(4, student.getCourse());
// 执行SQL语句并获取影响行数
int num = insertPreparedStatement.executeUpdate();
// 影响行数>0则说明插入成功
if (num > 0) {
flag = true;
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
// 释放资源
JDBCUtils.release(conn, insertPreparedStatement);
}
return flag;
}
/**
* @Description: 更新一条记录
* @param: student
* @Return: boolean
* @Date: 2023/9/13 20:22
* @Author: Jay lan
*/
public boolean update(Student student) {
boolean flag = false;
PreparedStatement preparedStatement = null;
Connection connection = JDBCUtils.getConnection();
String updateSql = "UPDATE student SET sname=?,age=?,course=? WHERE sid=?;";
try {
preparedStatement = connection.prepareStatement(updateSql);
preparedStatement.setString(1, student.getSname());
preparedStatement.setString(2, student.getAge());
preparedStatement.setString(3, student.getCourse());
int num = preparedStatement.executeUpdate(updateSql);
if (num > 0) {
flag = true;
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
// 释放资源
JDBCUtils.release(connection, preparedStatement);
}
return flag;
}
/**
* @Description: 根据id删除一条记录
* @param: null
* @Return: 删除是否成功
* @Date: 2023/9/13 20:22
* @Author: Jay lan
*/
public boolean deleteById(String sid) {
boolean flag = false;
PreparedStatement preparedStatement = null;
Connection connection = JDBCUtils.getConnection();
String deleteSql = "DELETE FROM student WHERE sid=?";
try {
preparedStatement = connection.prepareStatement(deleteSql);
preparedStatement.setString(1, sid);
int num = preparedStatement.executeUpdate();
if (num > 0) {
flag = true;
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
JDBCUtils.release(connection, preparedStatement);
}
return flag;
}
/**
* @Description: 根据id查询学生
* @param: sid 学生id
* @Return: come.example.jdbc.chapter01.Student
* @Date: 2023/9/13 20:12
* @Author: Jay lan
*/
public Student selectOneById(String sid) {
PreparedStatement preparedStatement = null;
Connection connection = JDBCUtils.getConnection();
// 因为是查询所以需要Result 对象用来保存结果
String selectSql = "SELECT * FROM student WHERE sid=?";
// 用来存储结果的Student对象
Student newStudent = new Student();
// 执行操作
try {
// 预编译SQL
preparedStatement = connection.prepareStatement(selectSql);
// 设置参数
preparedStatement.setString(1, sid);
// 执行查询并放入ResultSet中
ResultSet resultSet = preparedStatement.executeQuery();
// 将resultSet的结果赋值给各个成员变量
while (resultSet.next())
{
newStudent.setSid(resultSet.getInt("sid"));
newStudent.setAge(resultSet.getString("age"));
newStudent.setCourse(resultSet.getString("course"));
newStudent.setSname(resultSet.getString("sname"));
}
// ResultSet不用手动释放 使用PreparedStatement.executeQuery() 会自动管理ResultSet生命周期查询完成就释放
// 捕获错误
} catch (SQLException e) {
// 释放资源 不过没有释放Result
} finally {
JDBCUtils.release(connection, preparedStatement);
}
return newStudent;
}
public ArrayList<Student> selectAll()
{
PreparedStatement preparedStatement=null;
Connection connection=JDBCUtils.getConnection();
ArrayList<Student> studentArrayList=new ArrayList<>();
String selectAllSql="SELECT * FROM student";
try {
// 预编译SQL
preparedStatement=connection.prepareStatement(selectAllSql);
ResultSet resultSet=preparedStatement.executeQuery();
while (resultSet.next())
{
Student newStudent=new Student();
// 将resultSet的结果赋值给各个成员变量
newStudent.setSid(resultSet.getInt("sid"));
newStudent.setAge(resultSet.getString("age"));
newStudent.setCourse(resultSet.getString("course"));
newStudent.setSname(resultSet.getString("sname"));
// 将查询到的对象放入List中
studentArrayList.add(newStudent);
}
}catch (SQLException e)
{
e.printStackTrace();
}finally {
JDBCUtils.release(connection,preparedStatement);
}
return studentArrayList;
}
}
主要提供的功能是对数据库的增删查改，其中查询的部分可以写完查询单个的方法还可以写查询全部的方法
ResultSet不用手动进行释放 执行完了PreparedStatement.executeQuery()因为ResultSet会被数据库驱动自动管理 查询完成了就释放
对于修改和删除操作可以一般返回boolean值在进行操作时可以通过影响行数来判断操作是否成功
Dto类可以主要是完成增加、修改、删除、查询操作
测试类
测试查询单个
package come.example.jdbc.chapter01;
/**
* @Classname SelectOneTest
* @Description
* @Author Jay lan
* @Date 2023/9/13 21:38
* @Version 1.0.0
*/
public class SelectOneTest {
public static void main(String[] args) {
StudentDao studentDao=new StudentDao();
Student student=studentDao.selectOneById("2");
System.out.println(student);
}
}
对于查询单个可以通过记录的主键id或者其他主键
测试查询所有
package come.example.jdbc.chapter01;
import java.util.ArrayList;
/**
* @Classname SelectAllTest
* @Description
* @Author Jay lan
* @Date 2023/9/13 21:01
* @Version 1.0.0
*/
public class SelectAllTest {
public static void main(String[] args) {
StudentDao studentDao=new StudentDao();
ArrayList<Student> studentArrayList;
studentArrayList=studentDao.selectAll();
for (Student student: studentArrayList) {
System.out.println(student);
}
}
}
关于查询 除了通过主键查询单个之外还可以编写查询所有记录的方法
测试插入一条数据
package come.example.jdbc.chapter01;
/**
* @Classname InsertTest
* @Description 增加一个学生
* @Author Jay lan
* @Date 2023/9/13 21:51
* @Version 1.0.0
*/
public class InsertTest {
public static void main(String[] args) {
StudentDao studentDao=new StudentDao();
Student student=new Student();
student.setSid(233);
student.setSname("Jaylan");
student.setCourse("SofterEngineer");
student.setAge("21");
System.out.println(studentDao.insert(student));
}
}
测试删除一条记录
package come.example.jdbc.chapter01;
/**
* @Classname DeleteTest
* @Description 删除一条记录
* @Author Jay lan
* @Date 2023/9/13 22:04
* @Version 1.0.0
*/
public class DeleteTest {
public static void main(String[] args) {
StudentDao studentDao=new StudentDao();
System.out.println(studentDao.deleteById("233"));
}
}
测试更新一条记录
package come.example.jdbc.chapter01;
/**
* @Classname TestUpdate
* @Description
* @Author Jay lan
* @Date 2023/9/14 15:57
* @Version 1.0.0
*/
public class TestUpdate {
public static void main(String[] args) {
StudentDao studentDao = new StudentDao();
Student newstudent = new Student();
newstudent.setSid(1);
newstudent.setSname("huaji");
newstudent.setAge("1");
newstudent.setCourse("软件工程");
studentDao.update(newstudent);
}
}
小结
- 对数据库中的数据最基本的操作是增删查改
- 对于写好的增删查改方法需要进行测试
- 对于修改和删除方法可以通过获取 preparedStatement.executeUpdate()的返回值(影响行数)来判断释放成功
- ResultSet不用手动进行释放 在执行玩查询方法后会被驱动自动管理，有自己的生命周期
- 构造方法中会隐式是调用 super()方法 可以直接在构造方法中显式的写出使得代码更加清晰
-
- 默认的toString方法会返回对象类型+哈希码构成的字符串难以理解可以对重写获取更直观的信息
本文含有隐藏内容，请 开通VIP 后查看