待办清单项目2：创建数据库增删改查对象DAO

创建用户表DAO接口类

DAO的全称是Data Access Object，即数据访问对象，我们需要利用该对象来对数据表格进行增删改查等基本操作。

1.首先，在src文件夹上单击鼠标右键，然后选择新建软件包，输入名字为

com.你的名字或公司名字.todolist.dao

2.选择dao，点击鼠标右键，选择新建Java类

3.在弹出的对话框中，设置名字为SysUserDao，然后点击接口将其设置为接口，然后按一下回车键

SysUserDao.java文件如下图所示

该文件了定了对用户进行增删改查等相关操作的接口，带注释的完整代码如下(注意要替换自己的包名字)：

package com.youngshu.todolist.dao;
import com.youngshu.todolist.pojo.SysUser;
import java.util.List;
/**
 * @author youngshu
 * @date 2024/4/10 10:50
 * @description 用于对SysUser表进行增删改查等操作的接口
 */
public interface SysUserDao {
    /**
     * 增加用户的方法
     * @param sysUser 需要增加的SysUser对象
     * @return 返回插入成功的记录数
     */
    int insert(SysUser sysUser);
    /**
     * 修改用户的方法
     * @param sysUser 需要修改的SysUser对象，必须包含id字段
     * @return 返回更新成功的记录数
     */
    int update(SysUser sysUser);
    /**
     * 删除用户的方法
     * @param id 需要删除的用户的id
     * @return 返回删除成功记录数
     */
    int delete(int id);
    /**
     * 根据用户名查询用户的方法
     * @param username 需要查询的用户名
     * @return 返回查询到的SysUser对象，如果未找到则返回null
     */
    SysUser findByUsername(String username);
    /**
     * 根据id查询用户的方法
     * @param id 需要查询的用户的id
     * @return 返回查询到的SysUser对象，如果未找到则返回null
     */
    SysUser findById(int id);
    /**
     * 查询所有用户的方法
     * @return 返回所有用户的SysUser对象列表
     */
    List<SysUser> findAll();
}

添加jdbc驱动和代码

1.接下来将mysql-connetor的jar包拷贝到lib目录中

2. 然后在com.youngshu.todolist包中创建一个软件包utils，并在该包中创建一个类JDBCUtils,如下图所示。

JDBCUtils.java文件中的代码如下（注意将数据库名，用户名和密码换成你自己的）：

package com.youngshu.todolist.utils;

import java.sql.*;

/**
 * JDBC工具类，用于管理数据库连接和资源关闭
 */
public class JDBCUtils {
    // 数据库连接信息
    // 注意：需要修改为自己的数据库连接信息
    private static final String URL = "jdbc:mysql://localhost:3306/todo_list";
    private static final String USERNAME = "root";
    private static final String PASSWORD = "123456789";

    // 静态代码块，用于加载MySQL驱动
    static {
        try {
            Class.forName("com.mysql.cj.jdbc.Driver");
        } catch (ClassNotFoundException e) {
            throw new RuntimeException("MySQL驱动加载失败", e);
        }
    }

    /**
     * 获取数据库连接
     * @return 返回数据库连接对象
     * @throws SQLException 如果连接失败则抛出SQL异常
     */
    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection(URL, USERNAME, PASSWORD);
    }

    /**
     * 关闭数据库资源
     * @param conn 数据库连接对象
     * @param stmt Statement状态对象
     * @param rs ResultSet结果集对象
     */
    public static void closeResource(Connection conn, Statement stmt, ResultSet rs) {
        try {
            if (rs != null) rs.close();
            if (stmt != null) stmt.close();
            if (conn != null) conn.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

创建用户表DAO接口的实现类

1.接下来在dao包上单击鼠标右键，选择新建java类

2.在弹出的对话中取名为impl.SysUserDaoImpl,用于实现上面的SysUserDao接口

3.在生成的SysUserDaoImpl.java文件中把代码改成下面这样子（注意包要换成你自己的）：

package com.youngshu.todolist.dao.impl;

import com.youngshu.todolist.dao.SysUserDao;
import com.youngshu.todolist.pojo.SysUser;
import com.youngshu.todolist.utils.JDBCUtils;

import java.sql.*;
import java.util.ArrayList;
import java.util.List;

//SysUserDaoImpl类 实现 SysUserDao 接口
public class SysUserDaoImpl implements SysUserDao {

    /**
     * 插入用户信息
     * @param sysUser 用户对象
     * @return 插入成功返回1，失败返回0
     */
    @Override
    public int insert(SysUser sysUser) {
        Connection conn = null;
        PreparedStatement ps = null;
        try {
            conn = JDBCUtils.getConnection();
            String sql = "INSERT INTO sys_user (username, user_pwd) VALUES (?, ?)";
            ps = conn.prepareStatement(sql);
            ps.setString(1, sysUser.getUsername());
            ps.setString(2, sysUser.getUser_pwd());
            return ps.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
            return 0;
        } finally {
            JDBCUtils.closeResource(conn, ps, null);
        }
    }

    /**
     * 更新用户信息
     * @param sysUser 用户对象，包含要更新的信息
     * @return 更新成功返回影响的行数，失败返回0
     */
    @Override
    public int update(SysUser sysUser) {
        Connection conn = null;
        PreparedStatement ps = null;
        try {
            conn = JDBCUtils.getConnection();
            String sql = "UPDATE sys_user SET username = ?, user_pwd = ? WHERE uid = ?";
            ps = conn.prepareStatement(sql);
            ps.setString(1, sysUser.getUsername());
            ps.setString(2, sysUser.getUser_pwd());
            ps.setInt(3, sysUser.getUid());
            return ps.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
            return 0;
        } finally {
            JDBCUtils.closeResource(conn, ps, null);
        }
    }

    /**
     * 根据用户ID删除用户
     * @param id 用户ID
     * @return 删除成功返回影响的行数，失败返回0
     */
    @Override
    public int delete(int id) {
        Connection conn = null;
        PreparedStatement ps = null;
        try {
            conn = JDBCUtils.getConnection();
            String sql = "DELETE FROM sys_user WHERE uid = ?";
            ps = conn.prepareStatement(sql);
            ps.setInt(1, id);
            return ps.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
            return 0;
        } finally {
            JDBCUtils.closeResource(conn, ps, null);
        }
    }

    /**
     * 根据用户名查找用户
     * @param username 用户名
     * @return 找到返回用户对象，未找到返回null
     */
    @Override
    public SysUser findByUsername(String username) {
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            conn = JDBCUtils.getConnection();
            String sql = "SELECT * FROM sys_user WHERE username = ?";
            ps = conn.prepareStatement(sql);
            ps.setString(1, username);
            rs = ps.executeQuery();
            if (rs.next()) {
                return new SysUser(
                    rs.getInt("uid"),
                    rs.getString("username"),
                    rs.getString("user_pwd")
                );
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeResource(conn, ps, rs);
        }
        return null;
    }

    /**
     * 根据用户ID查找用户
     * @param id 用户ID
     * @return 找到返回用户对象，未找到返回null
     */
    @Override
    public SysUser findById(int id) {
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            conn = JDBCUtils.getConnection();
            String sql = "SELECT * FROM sys_user WHERE uid = ?";
            ps = conn.prepareStatement(sql);
            ps.setInt(1, id);
            rs = ps.executeQuery();
            if (rs.next()) {
                return new SysUser(
                    rs.getInt("uid"),
                    rs.getString("username"),
                    rs.getString("user_pwd")
                );
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeResource(conn, ps, rs);
        }
        return null;
    }

    /**
     * 查找所有用户
     * @return 返回所有用户对象的列表
     */
    @Override
    public List<SysUser> findAll() {
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        List<SysUser> userList = new ArrayList<>();
        try {
            conn = JDBCUtils.getConnection();
            String sql = "SELECT * FROM sys_user";
            ps = conn.prepareStatement(sql);
            rs = ps.executeQuery();
            while (rs.next()) {
                userList.add(new SysUser(
                    rs.getInt("uid"),
                    rs.getString("username"),
                    rs.getString("user_pwd")
                ));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeResource(conn, ps, rs);
        }
        return userList;
    }
}

测试用户表的增删改查操作

接下来测试一下是否可以实现对数据库中的用户表进行增删改查等操作

1. 在com开头的包上单击鼠标右键，选择新建Java类

2. 在弹出的对话框中设置名字为test.SysUserDaoTest，然后回车

3. 在SysUserDaoTest.java文件中粘贴下面的代码（注意替换包的名字）

package com.youngshu.todolist.test;

import com.youngshu.todolist.dao.SysUserDao;
import com.youngshu.todolist.dao.impl.SysUserDaoImpl;
import com.youngshu.todolist.pojo.SysUser;

public class SysUserDaoTest {
    public static void main(String[] args) {
        // 创建DAO实例
        SysUserDao userDao = new SysUserDaoImpl();

        // 测试插入用户
        SysUser newUser = new SysUser();
        newUser.setUsername("testuser");
        newUser.setUser_pwd("123456");
        int insertResult = userDao.insert(newUser);
        System.out.println("插入用户结果: " + (insertResult > 0 ? "成功" : "失败"));

        // 测试查询用户
        SysUser foundUser = userDao.findByUsername("testuser");
        if (foundUser != null) {
            System.out.println("查询到用户: " + foundUser.getUsername());
            
            // 测试更新用户
            foundUser.setUser_pwd("newpassword");
            int updateResult = userDao.update(foundUser);
            System.out.println("更新用户结果: " + (updateResult > 0 ? "成功" : "失败"));

            // 测试删除用户
            int deleteResult = userDao.delete(foundUser.getUid());
            System.out.println("删除用户结果: " + (deleteResult > 0 ? "成功" : "失败"));
        }

        // 测试查询所有用户
        System.out.println("\n所有用户列表:");
        userDao.findAll().forEach(user -> 
            System.out.println("用户ID: " + user.getUid() + 
                             ", 用户名: " + user.getUsername()));
    }
}

4. 打一个断点，然后对当前文件进行调试，一步一步执行

5. 观察控制台输出，如显示如下图所示信息，说明我们编写的对用户表进行增删改成操作的DAO测试成功

创建待办任务表的DAO接口类

1. 在dao包上单击右键，新建Java类

2. 在弹出的对话框中取名为SysTodoDao，然后选中【接口】，点击回车键

3. 在SysTodoDao中添加如下的代码，这些代码定义了对待办事项表格的增删改查等操作的接口。

package com.youngshu.todolist.dao;

import com.youngshu.todolist.pojo.SysTodo;
import java.util.List;

/**
 * 待办事项数据访问接口
 * 该接口定义了对待办事项（sys_todo表）的基本CRUD操作
 *
 * @author youngshu
 * @version 1.0
 * @since 2024-04-10
 */
public interface SysTodoDao {
    /**
     * 添加新的待办事项
     *
     * @param sysTodo 待添加的待办事项对象，不能为null
     * @return 影响的行数，插入成功返回1，失败返回0
     */
    int insert(SysTodo sysTodo);
    
    /**
     * 更新待办事项信息
     *
     * @param sysTodo 待更新的待办事项对象，必须包含sid，不能为null
     * @return 影响的行数，更新成功返回1，失败返回0
     */
    int update(SysTodo sysTodo);
    
    /**
     * 根据ID删除待办事项
     *
     * @param sid 待办事项ID
     * @return 影响的行数，删除成功返回1，失败返回0
     */
    int delete(int sid);
    
    /**
     * 根据ID查找待办事项
     *
     * @param sid 待办事项ID
     * @return 查找到的待办事项对象，如果不存在返回null
     */
    SysTodo findById(int sid);
    
    /**
     * 查找指定用户的所有待办事项
     *
     * @param uid 用户ID
     * @return 该用户的所有待办事项列表，如果没有则返回空列表
     */
    List<SysTodo> findByUserId(int uid);
    
    /**
     * 查找所有待办事项
     *
     * @return 所有待办事项的列表，如果没有则返回空列表
     */
    List<SysTodo> findAll();
    
    /**
     * 更新待办事项的完成状态
     *
     * @param sid 待办事项ID
     * @param completed 完成状态：0-未完成，1-已完成
     * @return 影响的行数，更新成功返回1，失败返回0
     */
    int updateCompleted(int sid, int completed);
}

创建待办任务表DAO接口的实现类

1. 接下来编写上述接口的实现类，在impl包上单击鼠标右键，选择新建Java类，取名为SysTodoDaoImpl

2. 在SysTodoDaoImpl文件中粘贴下面的代码（注意替换包的名字）

package com.youngshu.todolist.dao.impl;

import com.youngshu.todolist.dao.SysTodoDao;
import com.youngshu.todolist.pojo.SysTodo;
import com.youngshu.todolist.utils.JDBCUtils;

import java.sql.*;
import java.util.ArrayList;
import java.util.List;

/**
 * 实现SysTodoDao接口的类，用于对sys_todo表进行数据库操作
 */
public class SysTodoDaoImpl implements SysTodoDao {

    /**
     * 插入新的待办事项到数据库
     * @param sysTodo 待办事项对象
     * @return 插入成功返回1，失败返回0
     */
    @Override
    public int insert(SysTodo sysTodo) {
        Connection conn = null;
        PreparedStatement ps = null;
        try {
            conn = JDBCUtils.getConnection();
            String sql = "INSERT INTO sys_todo (uid, title, completed) VALUES (?, ?, ?)";
            ps = conn.prepareStatement(sql);
            ps.setInt(1, sysTodo.getUid());
            ps.setString(2, sysTodo.getTitle());
            ps.setInt(3, sysTodo.getCompleted());
            return ps.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
            return 0;
        } finally {
            JDBCUtils.closeResource(conn, ps, null);
        }
    }

    /**
     * 更新指定待办事项的信息
     * @param sysTodo 待办事项对象，包含更新后的信息
     * @return 更新成功返回1，失败返回0
     */
    @Override
    public int update(SysTodo sysTodo) {
        Connection conn = null;
        PreparedStatement ps = null;
        try {
            conn = JDBCUtils.getConnection();
            String sql = "UPDATE sys_todo SET title = ?, completed = ? WHERE sid = ?";
            ps = conn.prepareStatement(sql);
            ps.setString(1, sysTodo.getTitle());
            ps.setInt(2, sysTodo.getCompleted());
            ps.setInt(3, sysTodo.getSid());
            return ps.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
            return 0;
        } finally {
            JDBCUtils.closeResource(conn, ps, null);
        }
    }

    /**
     * 根据待办事项ID删除待办事项
     * @param sid 待办事项ID
     * @return 删除成功返回1，失败返回0
     */
    @Override
    public int delete(int sid) {
        Connection conn = null;
        PreparedStatement ps = null;
        try {
            conn = JDBCUtils.getConnection();
            String sql = "DELETE FROM sys_todo WHERE sid = ?";
            ps = conn.prepareStatement(sql);
            ps.setInt(1, sid);
            return ps.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
            return 0;
        } finally {
            JDBCUtils.closeResource(conn, ps, null);
        }
    }

    /**
     * 根据待办事项ID查找待办事项
     * @param sid 待办事项ID
     * @return 找到的待办事项对象，未找到返回null
     */
    @Override
    public SysTodo findById(int sid) {
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            conn = JDBCUtils.getConnection();
            String sql = "SELECT * FROM sys_todo WHERE sid = ?";
            ps = conn.prepareStatement(sql);
            ps.setInt(1, sid);
            rs = ps.executeQuery();
            if (rs.next()) {
                return new SysTodo(
                    rs.getInt("sid"),
                    rs.getInt("uid"),
                    rs.getString("title"),
                    rs.getInt("completed")
                );
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeResource(conn, ps, rs);
        }
        return null;
    }

    /**
     * 根据用户ID查找该用户的所有待办事项
     * @param uid 用户ID
     * @return 该用户的所有待办事项列表
     */
    @Override
    public List<SysTodo> findByUserId(int uid) {
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        List<SysTodo> todoList = new ArrayList<>();
        try {
            conn = JDBCUtils.getConnection();
            String sql = "SELECT * FROM sys_todo WHERE uid = ?";
            ps = conn.prepareStatement(sql);
            ps.setInt(1, uid);
            rs = ps.executeQuery();
            while (rs.next()) {
                todoList.add(new SysTodo(
                    rs.getInt("sid"),
                    rs.getInt("uid"),
                    rs.getString("title"),
                    rs.getInt("completed")
                ));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeResource(conn, ps, rs);
        }
        return todoList;
    }

    /**
     * 查找数据库中所有的待办事项
     * @return 所有待办事项列表
     */
    @Override
    public List<SysTodo> findAll() {
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        List<SysTodo> todoList = new ArrayList<>();
        try {
            conn = JDBCUtils.getConnection();
            String sql = "SELECT * FROM sys_todo";
            ps = conn.prepareStatement(sql);
            rs = ps.executeQuery();
            while (rs.next()) {
                todoList.add(new SysTodo(
                    rs.getInt("sid"),
                    rs.getInt("uid"),
                    rs.getString("title"),
                    rs.getInt("completed")
                ));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeResource(conn, ps, rs);
        }
        return todoList;
    }

    /**
     * 更新指定待办事项的完成状态
     * @param sid 待办事项ID
     * @param completed 完成状态，1表示已完成，0表示未完成
     * @return 更新成功返回1，失败返回0
     */
    @Override
    public int updateCompleted(int sid, int completed) {
        Connection conn = null;
        PreparedStatement ps = null;
        try {
            conn = JDBCUtils.getConnection();
            String sql = "UPDATE sys_todo SET completed = ? WHERE sid = ?";
            ps = conn.prepareStatement(sql);
            ps.setInt(1, completed);
            ps.setInt(2, sid);
            return ps.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
            return 0;
        } finally {
            JDBCUtils.closeResource(conn, ps, null);
        }
    }
}

测试待办任务表的增删改查操作

1. 在test包上单击鼠标右键，选择新建Java类，取名为SysTodoDaoTest

2. 在SysTodoDaoTest文件中粘贴下面的代码（注意替换包的名字）：

package com.youngshu.todolist.test;

import com.youngshu.todolist.dao.SysTodoDao;
import com.youngshu.todolist.dao.impl.SysTodoDaoImpl;
import com.youngshu.todolist.pojo.SysTodo;

import java.util.List;

/**
 * SysTodoDao接口的测试类
 * 用于测试待办事项相关的数据库操作
 *
 * @author youngshu
 * @version 1.0
 * @since 2024-04-10
 */
public class SysTodoDaoTest {

    /**
     * 测试入口方法
     * 按顺序测试待办事项的增删改查功能
     *
     * @param args 命令行参数（未使用）
     */
    public static void main(String[] args) {
        // 创建DAO实例
        SysTodoDao todoDao = new SysTodoDaoImpl();

        // 测试添加待办事项
        testInsert(todoDao);

        // 测试查询所有待办事项
        testFindAll(todoDao);

        // 测试根据用户ID查询待办事项
        testFindByUserId(todoDao, 1);

        // 测试更新待办事项
        testUpdate(todoDao);

        // 测试更新完成状态
        testUpdateCompleted(todoDao);

        // 测试删除待办事项
        testDelete(todoDao);
    }

    /**
     * 测试添加待办事项
     *
     * @param todoDao DAO实例
     */
    private static void testInsert(SysTodoDao todoDao) {
        System.out.println("=== 测试添加待办事项 ===");
        SysTodo todo = new SysTodo();
        todo.setUid(1);
        todo.setTitle("测试待办事项");
        todo.setCompleted(0);
        int result = todoDao.insert(todo);
        System.out.println("插入结果: " + (result > 0 ? "成功" : "失败"));
    }

    /**
     * 测试查询所有待办事项
     *
     * @param todoDao DAO实例
     */
    private static void testFindAll(SysTodoDao todoDao) {
        System.out.println("\n=== 测试查询所有待办事项 ===");
        List<SysTodo> todos = todoDao.findAll();
        todos.forEach(todo -> System.out.println(
            "ID: " + todo.getSid() +
            ", 用户ID: " + todo.getUid() +
            ", 标题: " + todo.getTitle() +
            ", 状态: " + (todo.getCompleted() == 1 ? "已完成" : "未完成")
        ));
    }

    /**
     * 测试根据用户ID查询待办事项
     *
     * @param todoDao DAO实例
     * @param uid 用户ID
     */
    private static void testFindByUserId(SysTodoDao todoDao, int uid) {
        System.out.println("\n=== 测试根据用户ID查询待办事项 ===");
        List<SysTodo> todos = todoDao.findByUserId(uid);
        System.out.println("用户" + uid + "的待办事项：");
        todos.forEach(todo -> System.out.println(
            "ID: " + todo.getSid() +
            ", 标题: " + todo.getTitle() +
            ", 状态: " + (todo.getCompleted() == 1 ? "已完成" : "未完成")
        ));
    }

    /**
     * 测试更新待办事项
     *
     * @param todoDao DAO实例
     */
    private static void testUpdate(SysTodoDao todoDao) {
        System.out.println("\n=== 测试更新待办事项 ===");
        // 假设ID为1的待办事项存在
        SysTodo todo = todoDao.findById(1);
        if (todo != null) {
            todo.setTitle("已更新的待办事项");
            int result = todoDao.update(todo);
            System.out.println("更新结果: " + (result > 0 ? "成功" : "失败"));
        } else {
            System.out.println("待更新的待办事项不存在");
        }
    }

    /**
     * 测试更新待办事项完成状态
     *
     * @param todoDao DAO实例
     */
    private static void testUpdateCompleted(SysTodoDao todoDao) {
        System.out.println("\n=== 测试更新待办事项完成状态 ===");
        // 假设ID为1的待办事项存在
        int result = todoDao.updateCompleted(1, 1);
        System.out.println("更新完成状态结果: " + (result > 0 ? "成功" : "失败"));
    }

    /**
     * 测试删除待办事项
     *
     * @param todoDao DAO实例
     */
    private static void testDelete(SysTodoDao todoDao) {
        System.out.println("\n=== 测试删除待办事项 ===");
        // 假设ID为1的待办事项存在
        int result = todoDao.delete(1);
        System.out.println("删除结果: " + (result > 0 ? "成功" : "失败"));
    }
}

3. 运行当前文件(SysTodoDaoTest)，观察底部测试结果是否正常。

小结

至此，我们已经成功封装了对两个数据表格进行增删改成等操作的代码