编写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方法会返回对象类型+哈希码构成的字符串难以理解可以对重写获取更直观的信息