java实训之学生管理系统五

创建数据访问接口

在net.hw.student里面在创建一个子包dao,如图

在dao里面创建学校数据访问接口CollegeDao

package net.hw.student.dao;

import net.hw.student.bean.College;
//创建学校数据访问接口CollegeDao
public interface CollegeDao {
College findById(int id);
int update(College college);

}

StatusDao.java

package net.hw.student.dao;

import net.hw.student.bean.Status;

//创建状态数据访问接口StatusDao
public interface StatusDao {
Status findById(int id);
int update(Status status);

}

StudentDao.java

package net.hw.student.dao;

import net.hw.student.bean.Student;

import java.util.List;
import java.util.Vector;

//创建学生数据访问接口StudentDao
public interface StudentDao {
int insert(Student student);
int deleteById(String id);
int deleteByClass(String clazz);
int deleteByDepartment(String department);
int update(Student student);
Student findById(String id);
List findByName(String name);
List findByClass(String clazz);
List findByDepartment(String department);
List findAll();
Vector findRowsBySex();
Vector findRowsByClass();
Vector findRowsByDepartment();

}

UserDao.java

package net.hw.student.dao;

import net.hw.student.bean.User;

import java.util.List;

//创建用户数据访问接口StudentDao

public interface UserDao {
int insert(User user);
int deleteById(int id);
int update(User user);
User findById(int id);
List findAll();
User login(String username, String password);
boolean isUsernameExisted(String username);

}

创建数据访问接口实现类

1、创建学校数据访问接口实现类CollegeDaoImpl

package net.hw.student.dao.impl;

import net.hw.student.bean.College;
import net.hw.student.dao.CollegeDao;
import net.hw.student.dbutil.ConnectionManager;

import java.sql.*;

//创建学校数据访问接口实现类CollegeDaoImpl

public class CollegeDaoImpl implements CollegeDao{
/**
* 按id查找学校
*
* @param id
* @return 学校对象
*/
@Override
public College findById(int id) {
// 定义学校对象
College college = null;

    // 1. 获取数据库连接
    Connection conn = ConnectionManager.getConnection();
    // 2. 定义SQL字符串
    String strSQL = "select * from t_college where id = ?";
    try {
        // 3. 创建预备语句对象
        PreparedStatement pstmt = conn.prepareStatement(strSQL);
        // 4. 设置占位符的值
        pstmt.setInt(1, id);
        // 5. 执行SQL，返回结果集
        ResultSet rs = pstmt.executeQuery();
        // 6. 判断结果集是否有记录
        if (rs.next()) {
            // 实例化学校对象
            college = new College();
            // 利用当前记录各个字段值去设置学校对象的属性
            college.setId(rs.getInt("id"));
            college.setName(rs.getString("name"));
            college.setPresident(rs.getString("president"));
            college.setStartTime(rs.getTimestamp("start_time"));
            college.setTelephone(rs.getString("telephone"));
            college.setEmail(rs.getString("email"));
            college.setAddress(rs.getString("address"));
            college.setProfile(rs.getString("profile"));
        }
        // 7. 关闭预备语句对象
        pstmt.close();
        // 8. 关闭结果集对象
        rs.close();
    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        // 关闭数据库连接
        ConnectionManager.closeConnection(conn);
    }

    // 返回学校对象
    return college;
}

/**
 * 更新学校信息
 *
 * @param college
 * @return 更新记录数
 */
@Override
public int update(College college) {
    // 定义更新记录数
    int count = 0;

    // 1. 获取数据库连接
    Connection conn = ConnectionManager.getConnection();
    // 2. 定义SQL字符串
    String strSQL = "update t_college set name = ?, president = ?, start_time = ?,"
            + " telephone = ?, email = ?, address = ?, profile = ? where id = ?";
    try {
        // 3. 创建预备语句对象
        PreparedStatement pstmt = conn.prepareStatement(strSQL);
        // 4. 设置占位符的值
        pstmt.setString(1, college.getName());
        pstmt.setString(2, college.getPresident());
        pstmt.setTimestamp(3, new Timestamp(college.getStartTime().getTime()));
        pstmt.setString(4, college.getTelephone());
        pstmt.setString(5, college.getEmail());
        pstmt.setString(6, college.getAddress());
        pstmt.setString(7, college.getProfile());
        pstmt.setInt(8, college.getId());
        // 5. 执行SQL，返回更新记录数
        count = pstmt.executeUpdate();
        // 6. 关闭预备语句对象
        pstmt.close();
    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        // 关闭数据库连接
        ConnectionManager.closeConnection(conn);
    }

    // 返回更新记录数
    return count;
}

}

依次为

StatusDaoImpl.java

package net.hw.student.dao.impl;

import net.hw.student.bean.Status;
import net.hw.student.dao.StatusDao;
import net.hw.student.dbutil.ConnectionManager;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

//创建数据访问接口实现类
public class StatusDaoImpl implements StatusDao{
@Override
public Status findById(int id) {
// 声明状态对象
Status status = null;

    // 1. 获取数据库连接对象
    Connection conn = ConnectionManager.getConnection();
    // 2. 定义SQL字符串
    String strSQL = "SELECT * FROM t_status WHERE id = ?";
    try {
        // 3. 创建预备语句对象
        PreparedStatement pstmt = conn.prepareStatement(strSQL);
        // 4. 设置占位符的值
        pstmt.setInt(1, id);
        // 5. 执行SQL查询，返回结果集
        ResultSet rs = pstmt.executeQuery();
        // 6. 判断结果集是否有记录
        if (rs.next()) {
            // 实例化状态
            status = new Status();
            // 利用当前记录字段值去设置状态对象的属性
            status.setId(rs.getInt("id"));
            status.setCollege(rs.getString("college"));
            status.setVersion(rs.getString("version"));
            status.setAuthor(rs.getString("author"));
            status.setTelephone(rs.getString("telephone"));
            status.setAddress(rs.getString("address"));
            status.setEmail(rs.getString("email"));
        }
        // 7. 关闭预备语句对象
        pstmt.close();
        // 8. 关闭结果集对象
        rs.close();
    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        // 关闭数据库连接
        ConnectionManager.closeConnection(conn);
    }

    // 返回状态对象
    return status;
}

@Override
public int update(Status status) {
    // 定义更新记录数
    int count = 0;

    // 1. 获得数据库连接
    Connection conn = ConnectionManager.getConnection();
    // 2. 定义SQL字符串
    String strSQL = "update t_status set college = ?, version = ?, author = ?,"
            + " telephone = ?, address = ?, email = ? where id = ?";
    try {
        // 3. 创建预备语句对象
        PreparedStatement pstmt = conn.prepareStatement(strSQL);
        // 4. 设置占位符的值
        pstmt.setString(1, status.getCollege());
        pstmt.setString(2, status.getVersion());
        pstmt.setString(3, status.getAuthor());
        pstmt.setString(4, status.getTelephone());
        pstmt.setString(5, status.getAddress());
        pstmt.setString(6, status.getEmail());
        pstmt.setInt(7, status.getId());
        // 5. 执行更新操作，更新记录
        count = pstmt.executeUpdate();
        // 6. 关闭预备语句对象
        pstmt.close();
    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        // 关闭数据库连接
        ConnectionManager.closeConnection(conn);
    }

    // 返回更新记录数
    return count;
}

}

StudentDaoImpl.java

package net.hw.student.dao.impl;
import net.hw.student.bean.Student;
import net.hw.student.dao.StudentDao;
import net.hw.student.dbutil.ConnectionManager;

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

//学生数据访问接口实现类StudentDaoImpl
public class StudentDaoImpl implements StudentDao{
@Override
public int insert(Student student) {
// 定义插入记录数
int count = 0;

    // 1. 获得数据库连接
    Connection conn = ConnectionManager.getConnection();
    // 2. 定义SQL字符串
    String strSQL = "insert into t_student (id, name, sex, age, department, class, telephone)"
            + " values (?, ?, ?, ?, ?, ?, ?)";
    try {
        // 3. 创建预备语句对象
        PreparedStatement pstmt = conn.prepareStatement(strSQL);
        // 4. 设置占位符的值
        pstmt.setString(1, student.getId());
        pstmt.setString(2, student.getName());
        pstmt.setString(3, student.getSex());
        pstmt.setInt(4, student.getAge());
        pstmt.setString(5, student.getDepartment());
        pstmt.setString(6, student.getClazz());
        pstmt.setString(7, student.getTelephone());
        // 5. 执行SQL，返回插入记录数
        count = pstmt.executeUpdate();
        // 6. 关闭预备语句对象
        pstmt.close();
    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        // 关闭数据库连接
        ConnectionManager.closeConnection(conn);
    }

    // 返回插入记录数
    return count;
}

/**
 * 按学号删除学生记录
 *
 * @param id
 * @return 删除记录数
 */
@Override
public int deleteById(String id) {
    // 定义删除记录数
    int count = 0;

    // 1. 获取数据库连接
    Connection conn = ConnectionManager.getConnection();
    // 2. 定义SQL字符串
    String strSQL = "delete from t_student where id = ?";
    try {
        // 3. 创建预备语句对象
        PreparedStatement pstmt = conn.prepareStatement(strSQL);
        // 4. 设置占位符的值
        pstmt.setString(1, id);
        // 5. 执行SQL，返回删除记录数
        count = pstmt.executeUpdate();
        // 6. 关闭预备语句对象
        pstmt.close();
    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        // 关闭数据库连接
        ConnectionManager.closeConnection(conn);
    }

    // 返回删除记录数
    return count;
}

/**
 * 按班级删除学生记录
 *
 * @param clazz
 * @return 删除记录数
 */
@Override
public int deleteByClass(String clazz) {
    // 定义删除记录数
    int count = 0;

    // 1. 获取数据库连接
    Connection conn = ConnectionManager.getConnection();
    // 2. 定义SQL字符串
    String strSQL = "delete from t_student where class = ?";
    try {
        // 3. 创建预备语句对象
        PreparedStatement pstmt = conn.prepareStatement(strSQL);
        // 4. 设置占位符的值
        pstmt.setString(1, clazz);
        // 5. 执行SQL，返回删除记录数
        count = pstmt.executeUpdate();
        // 6. 关闭预备语句对象
        pstmt.close();
    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        // 关闭数据库连接
        ConnectionManager.closeConnection(conn);
    }

    // 返回删除记录数
    return count;
}

/**
 * 按系部删除学生记录
 *
 * @param department
 * @return 删除记录数
 */
@Override
public int deleteByDepartment(String department) {
    // 定义删除记录数
    int count = 0;

    // 1. 获得数据库连接
    Connection conn = ConnectionManager.getConnection();
    // 2. 定义SQL字符串
    String strSQL = "delete from t_student where department = ?";
    try {
        // 3. 创建预备语句对象
        PreparedStatement pstmt = conn.prepareStatement(strSQL);
        // 4. 设置占位符的值
        pstmt.setString(1, department);
        // 5. 执行SQL，返回删除记录数
        count = pstmt.executeUpdate();
        // 6. 关闭预备语句对象
        pstmt.close();
    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        // 关闭数据库连接
        ConnectionManager.closeConnection(conn);
    }

    // 返回删除记录数
    return count;
}

/**
 * 更新学生记录
 *
 * @param student
 * @return 更新记录数
 */
@Override
public int update(Student student) {
    // 定义更新记录数
    int count = 0;

    // 1. 获得数据库连接
    Connection conn = ConnectionManager.getConnection();
    // 2. 定义SQL字符串
    String strSQL = "update t_student set name = ?, sex = ?, age = ?,"
            + " department = ?, class = ?, telephone = ? where id = ?";
    try {
        // 3. 创建预备语句对象
        PreparedStatement pstmt = conn.prepareStatement(strSQL);
        // 4. 设置占位符的值
        pstmt.setString(1, student.getName());
        pstmt.setString(2, student.getSex());
        pstmt.setInt(3, student.getAge());
        pstmt.setString(4, student.getDepartment());
        pstmt.setString(5, student.getClazz());
        pstmt.setString(6, student.getTelephone());
        pstmt.setString(7, student.getId());
        // 5. 执行SQL，返回更新记录数
        count = pstmt.executeUpdate();
        // 6. 关闭预备语句对象
        pstmt.close();
    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        // 关闭数据库连接
        ConnectionManager.closeConnection(conn);
    }

    // 返回更新记录数
    return count;
}

/**
 * 按学号查询学生记录
 *
 * @param id
 * @return 学生实体
 */
@Override
public Student findById(String id) {
    // 声明学生对象
    Student student = null;

    // 1. 获取数据库连接对象
    Connection conn = ConnectionManager.getConnection();
    // 2. 定义SQL字符串
    String strSQL = "select * from t_student where id = ?";
    try {
        // 3. 创建预备语句对象
        PreparedStatement pstmt = conn.prepareStatement(strSQL);
        // 4. 设置占位符的值
        pstmt.setString(1, id);
        // 5. 执行SQL，返回结果集
        ResultSet rs = pstmt.executeQuery();
        // 6. 判断结果集是否有记录
        if (rs.next()) {
            // 创建学生实体
            student = new Student();
            // 利用当前记录各字段值设置学生实体属性
            student.setId(rs.getString("id"));
            student.setName(rs.getString("name"));
            student.setSex(rs.getString("sex"));
            student.setAge(rs.getInt("age"));
            student.setDepartment(rs.getString("department"));
            student.setClazz(rs.getString("class"));
            student.setTelephone(rs.getString("telephone"));
        }
    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        // 关闭数据库连接
        ConnectionManager.closeConnection(conn);
    }

    // 返回学生对象
    return student;
}

/**
 * 按姓名查询学生记录
 *
 * @param name
 * @return 学生列表
 */
@Override
public List<Student> findByName(String name) {
    // 声明学生列表
    List<Student> students = new ArrayList<Student>();

    // 1. 获取数据库连接对象
    Connection conn = ConnectionManager.getConnection();
    // 2. 定义SQL字符串
    String strSQL = "select * from t_student where name like ?";
    try {
        // 3. 创建预备语句对象
        PreparedStatement pstmt = conn.prepareStatement(strSQL);
        // 4. 设置占位符的值
        pstmt.setString(1, name + "%");
        // 5. 执行SQL，返回结果集
        ResultSet rs = pstmt.executeQuery();
        // 6. 遍历结果集
        while (rs.next()) {
            // 创建学生实体
            Student student = new Student();
            // 利用当前记录各字段值设置学生实体属性
            student.setId(rs.getString("id"));
            student.setName(rs.getString("name"));
            student.setSex(rs.getString("sex"));
            student.setAge(rs.getInt("age"));
            student.setDepartment(rs.getString("department"));
            student.setClazz(rs.getString("class"));
            student.setTelephone(rs.getString("telephone"));
            // 将实体添加到学生列表
            students.add(student);
        }
        // 7. 关闭结果集
        rs.close();
        // 8. 关闭预备语句对象
        pstmt.close();
    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        // 关闭数据库连接
        ConnectionManager.closeConnection(conn);
    }

    // 返回学生列表
    return students;
}

/**
 * 按班级查询学生记录
 *
 * @param clazz
 * @return 学生列表
 */
@Override
public List<Student> findByClass(String clazz) {
    // 声明学生列表
    List<Student> students = new ArrayList<Student>();

    // 1. 获取数据库连接对象
    Connection conn = ConnectionManager.getConnection();
    // 2. 定义SQL字符串
    String strSQL = "select * from t_student where class like ?";
    try {
        // 3. 创建预备语句对象
        PreparedStatement pstmt = conn.prepareStatement(strSQL);
        // 4. 设置占位符的值
        pstmt.setString(1, clazz + "%");
        // 5. 执行SQL，返回结果集
        ResultSet rs = pstmt.executeQuery();
        // 6. 遍历结果集
        while (rs.next()) {
            // 创建学生实体
            Student student = new Student();
            // 利用当前记录各字段值设置学生实体属性
            student.setId(rs.getString("id"));
            student.setName(rs.getString("name"));
            student.setSex(rs.getString("sex"));
            student.setAge(rs.getInt("age"));
            student.setDepartment(rs.getString("department"));
            student.setClazz(rs.getString("class"));
            student.setTelephone(rs.getString("telephone"));
            // 将实体添加到学生列表
            students.add(student);
        }
        // 7. 关闭结果集
        rs.close();
        // 8. 关闭预备语句对象
        pstmt.close();
    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        // 关闭数据库连接
        ConnectionManager.closeConnection(conn);
    }

    // 返回学生列表
    return students;
}

/**
 * 按系部查询学生记录
 *
 * @param department
 * @return 学生列表
 */
@Override
public List<Student> findByDepartment(String department) {
    // 声明学生列表
    List<Student> students = new ArrayList<Student>();

    // 1. 获取数据库连接对象
    Connection conn = ConnectionManager.getConnection();
    // 2. 定义SQL字符串
    String strSQL = "select * from t_student where department like ?";
    try {
        // 3. 创建预备语句对象
        PreparedStatement pstmt = conn.prepareStatement(strSQL);
        // 4. 设置占位符的值
        pstmt.setString(1, department + "%");
        // 5. 执行SQL，返回结果集
        ResultSet rs = pstmt.executeQuery();
        // 6. 遍历结果集
        while (rs.next()) {
            // 创建学生实体
            Student student = new Student();
            // 利用当前记录各字段值设置学生实体属性
            student.setId(rs.getString("id"));
            student.setName(rs.getString("name"));
            student.setSex(rs.getString("sex"));
            student.setAge(rs.getInt("age"));
            student.setDepartment(rs.getString("department"));
            student.setClazz(rs.getString("class"));
            student.setTelephone(rs.getString("telephone"));
            // 将实体添加到学生列表
            students.add(student);
        }
        // 7. 关闭结果集
        rs.close();
        // 8. 关闭预备语句对象
        pstmt.close();
    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        // 关闭数据库连接
        ConnectionManager.closeConnection(conn);
    }

    // 返回学生列表
    return students;
}

/**
 * 查询全部学生记录
 *
 * @return 学生列表
 */
@Override
public List<Student> findAll() {
    // 声明学生列表
    List<Student> students = new ArrayList<Student>();

    // 1. 获取数据库连接对象
    Connection conn = ConnectionManager.getConnection();
    // 2. 定义SQL字符串
    String strSQL = "select * from t_student";
    try {
        // 3. 创建语句对象
        Statement stmt = conn.createStatement();
        // 4. 执行SQL，返回结果集
        ResultSet rs = stmt.executeQuery(strSQL);
        // 5. 遍历结果集
        while (rs.next()) {
            // 创建学生实体
            Student student = new Student();
            // 利用当前记录各字段值设置学生实体属性
            student.setId(rs.getString("id"));
            student.setName(rs.getString("name"));
            student.setSex(rs.getString("sex"));
            student.setAge(rs.getInt("age"));
            student.setDepartment(rs.getString("department"));
            student.setClazz(rs.getString("class"));
            student.setTelephone(rs.getString("telephone"));
            // 将实体添加到学生列表
            students.add(student);
        }
        // 6. 关闭结果集
        rs.close();
        // 7. 关闭语句对象
        stmt.close();
    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        // 关闭数据库连接
        ConnectionManager.closeConnection(conn);
    }

    // 返回学生列表
    return students;
}

/**
 * 按性别统计学生人数
 *
 * @return 统计结果向量
 */
@Override
public Vector findRowsBySex() {
    // 定义行集向量
    Vector rows = new Vector();

    // 1. 获取数据库连接对象
    Connection conn = ConnectionManager.getConnection();
    // 2. 定义SQL字符串
    String strSQL = "select sex as '性别', count(*) as '人数'"
            + " from t_student group by sex order by sex desc";
    try {
        // 3. 创建语句对象
        Statement stmt = conn.createStatement();
        // 4. 执行SQL，返回结果集
        ResultSet rs = stmt.executeQuery(strSQL);
        // 5. 遍历结果集
        while (rs.next()) {
            // 定义当前行向量
            Vector<String> currentRow = new Vector();
            // 利用当前记录字段值设置当前行向量的元素值
            currentRow.addElement(rs.getString("性别"));
            currentRow.addElement(rs.getInt("人数") + "");
            // 将当前行向量添加到行集向量
            rows.addElement(currentRow);
        }
    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        // 关闭数据库连接
        ConnectionManager.closeConnection(conn);
    }

    // 返回行集向量
    return rows;
}

/**
 * 按班级统计学生人数
 *
 * @return 统计结果向量
 */
@Override
public Vector findRowsByClass() {
    // 定义行集向量
    Vector rows = new Vector();

    // 1. 获取数据库连接对象
    Connection conn = ConnectionManager.getConnection();
    // 2. 定义SQL字符串
    String strSQL = "select class as '班级', count(*) as '人数'"
            + " from t_student group by class order by class desc";
    try {
        // 3. 创建语句对象
        Statement stmt = conn.createStatement();
        // 4. 执行SQL，返回结果集
        ResultSet rs = stmt.executeQuery(strSQL);
        // 5. 遍历结果集
        while (rs.next()) {
            // 定义当前行向量
            Vector<String> currentRow = new Vector();
            // 利用当前记录字段值设置当前行向量的元素值
            currentRow.addElement(rs.getString("班级"));
            currentRow.addElement(rs.getInt("人数") + "");
            // 将当前行向量添加到行集向量
            rows.addElement(currentRow);
        }
    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        // 关闭数据库连接
        ConnectionManager.closeConnection(conn);
    }

    // 返回行集向量
    return rows;
}

/**
 * 按系部统计学生人数
 *
 * @return 统计结果向量
 */
@Override
public Vector findRowsByDepartment() {
    // 定义行集向量
    Vector rows = new Vector();

    // 1. 获取数据库连接对象
    Connection conn = ConnectionManager.getConnection();
    // 2. 定义SQL字符串
    String strSQL = "select department as '系部', count(*) as '人数'"
            + " from t_student group by department order by department desc";
    try {
        // 3. 创建语句对象
        Statement stmt = conn.createStatement();
        // 4. 执行SQL，返回结果集
        ResultSet rs = stmt.executeQuery(strSQL);
        // 5. 遍历结果集
        while (rs.next()) {
            // 定义当前行向量
            Vector<String> currentRow = new Vector();
            // 利用当前记录字段值设置当前行向量的元素值
            currentRow.addElement(rs.getString("系部"));
            currentRow.addElement(rs.getInt("人数") + "");
            // 将当前行向量添加到行集向量
            rows.addElement(currentRow);
        }
    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        // 关闭数据库连接
        ConnectionManager.closeConnection(conn);
    }

    // 返回行集向量
    return rows;
}

}

UserDaoImpl.java

package net.hw.student.dao.impl;
import net.hw.student.bean.User;
import net.hw.student.dao.UserDao;
import net.hw.student.dbutil.ConnectionManager;

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

public class UserDaoImpl implements UserDao{
/**
* 插入用户记录
*
* @param user
* @return 插入记录数
*/
@Override
public int insert(User user) {
// 定义插入记录数
int count = 0;

    // 1. 获得数据库连接
    Connection conn = ConnectionManager.getConnection();
    // 2. 定义SQL字符串
    String strSQL = "insert into t_user (username, password, telephone, register_time)"
            + " values (?, ?, ?, ?)";

    // 不允许用户表里插入两条用户名相同的记录
    if (!isUsernameExisted(user.getUsername())) {
        try {
            // 3. 创建预备语句对象
            PreparedStatement pstmt = conn.prepareStatement(strSQL);
            // 4. 设置占位符的值
            pstmt.setString(1, user.getUsername());
            pstmt.setString(2, user.getPassword());
            pstmt.setString(3, user.getTelephone());
            pstmt.setTimestamp(4, new Timestamp(user.getRegisterTime().getTime()));
            // 5. 执行SQL，返回插入记录数
            count = pstmt.executeUpdate();
            // 6. 关闭预备语句对象
            pstmt.close();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            // 关闭数据库连接
            ConnectionManager.closeConnection(conn);
        }
    }

    // 返回插入记录数
    return count;
}

/**
 * 按id删除用户记录
 *
 * @param id
 * @return 删除记录数
 */
@Override
public int deleteById(int id) {
    // 定义删除记录数
    int count = 0;

    // 1. 获取数据库连接
    Connection conn = ConnectionManager.getConnection();
    // 2. 定义SQL字符串
    String strSQL = "delete from t_user where id = ?";
    try {
        // 3. 创建预备语句对象
        PreparedStatement pstmt = conn.prepareStatement(strSQL);
        // 4. 设置占位符的值
        pstmt.setInt(1, id);
        // 5. 执行SQL，返回删除记录数
        count = pstmt.executeUpdate();
        // 6. 关闭预备语句对象
        pstmt.close();
    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        // 关闭数据库连接
        ConnectionManager.closeConnection(conn);
    }

    // 返回删除记录数
    return count;
}

/**
 * 更新用户记录
 *
 * @param user
 * @return 更新记录数
 */
@Override
public int update(User user) {
    // 定义更新记录数
    int count = 0;

    // 1. 获得数据库连接
    Connection conn = ConnectionManager.getConnection();
    // 2. 定义SQL字符串
    String strSQL = "update t_user set username = ?, password = ?, telephone = ?,"
            + " register_time = ? where id = ?";
    try {
        // 3. 创建预备语句对象
        PreparedStatement pstmt = conn.prepareStatement(strSQL);
        // 4. 设置占位符的值
        pstmt.setString(1, user.getUsername());
        pstmt.setString(2, user.getPassword());
        pstmt.setString(3, user.getTelephone());
        pstmt.setTimestamp(4, new Timestamp(user.getRegisterTime().getTime()));
        pstmt.setInt(5, user.getId());
        // 5. 执行SQL，返回更新记录数
        count = pstmt.executeUpdate();
        // 6. 关闭预备语句对象
        pstmt.close();
    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        // 关闭数据库连接
        ConnectionManager.closeConnection(conn);
    }

    // 返回更新记录数
    return count;
}

/**
 * 按id查询用户
 *
 * @param id
 * @return 用户实体
 */
@Override
public User findById(int id) {
    // 声明用户对象
    User user = null;

    // 1. 获取数据库连接对象
    Connection conn = ConnectionManager.getConnection();
    // 2. 定义SQL字符串
    String strSQL = "select * from t_user where id = ?";
    try {
        // 3. 创建预备语句对象
        PreparedStatement pstmt = conn.prepareStatement(strSQL);
        // 4. 设置占位符的值
        pstmt.setInt(1, id);
        // 5. 执行SQL，返回结果集
        ResultSet rs = pstmt.executeQuery();
        // 6. 判断结果集是否有记录
        if (rs.next()) {
            // 创建用户实体
            user = new User();
            // 利用当前记录各字段值设置用户实体属性
            user.setId(rs.getInt("id"));
            user.setUsername(rs.getString("username"));
            user.setPassword(rs.getString("password"));
            user.setTelephone(rs.getString("telephone"));
            user.setRegisterTime(rs.getTimestamp("register_time"));
        }
    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        // 关闭数据库连接
        ConnectionManager.closeConnection(conn);
    }

    // 返回用户对象
    return user;
}

/**
 * 查询所有用户
 *
 * @return 用户列表
 */
@Override
public List<User> findAll() {
    // 声明用户列表
    List<User> users = new ArrayList<User>();

    // 1. 获取数据库连接对象
    Connection conn = ConnectionManager.getConnection();
    // 2. 定义SQL字符串
    String strSQL = "select * from t_user";
    try {
        // 3. 创建语句对象
        Statement stmt = conn.createStatement();
        // 4. 执行SQL，返回结果集
        ResultSet rs = stmt.executeQuery(strSQL);
        // 5. 遍历结果集
        while (rs.next()) {
            // 创建用户实体
            User user = new User();
            // 利用当前记录各字段值设置用户实体属性
            user.setId(rs.getInt("id"));
            user.setUsername(rs.getString("username"));
            user.setPassword(rs.getString("password"));
            user.setTelephone(rs.getString("telephone"));
            user.setRegisterTime(rs.getTimestamp("register_time"));
            // 将实体添加到用户列表
            users.add(user);
        }
        // 6. 关闭结果集
        rs.close();
        // 7. 关闭语句对象
        stmt.close();
    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        // 关闭数据库连接
        ConnectionManager.closeConnection(conn);
    }

    // 返回用户列表
    return users;
}

/**
 * 用户登录
 *
 * @param username
 * @param password
 * @return 登录用户实体
 */
@Override
public User login(String username, String password) {
    // 声明用户对象
    User user = null;

    // 1. 获取数据库连接
    Connection conn = ConnectionManager.getConnection();
    // 2. 定义SQL字符串
    String strSQL = "select * from t_user where username = ? and password = ?";
    try {
        // 3. 创建预备语句对象
        PreparedStatement pstmt = conn.prepareStatement(strSQL);
        // 4. 设置占位符的值
        pstmt.setString(1, username);
        pstmt.setString(2, password);
        // 5. 执行SQL，返回结果集
        ResultSet rs = pstmt.executeQuery();
        // 6. 判断结果集是否有记录
        if (rs.next()) {
            // 实例化用户
            user = new User();
            // 利用当前记录各字段值设置用户实体属性
            user.setId(rs.getInt("id"));
            user.setUsername(rs.getString("username"));
            user.setPassword(rs.getString("password"));
            user.setTelephone(rs.getString("telephone"));
            user.setRegisterTime(rs.getTimestamp("register_time"));
        }
    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        // 关闭数据库连接
        ConnectionManager.closeConnection(conn);
    }

    // 返回用户对象
    return user;
}

@Override
public boolean isUsernameExisted(String username) {
    // 定义存在与否变量
    boolean existed = false;

    // 1. 获取数据库连接
    Connection conn = ConnectionManager.getConnection();
    // 2. 定义SQL字符串
    String strSQL = "select * from t_user where username = ?";
    try {
        // 3. 创建预备语句对象
        PreparedStatement pstmt = conn.prepareStatement(strSQL);
        // 4. 设置占位符的值
        pstmt.setString(1, username);
        // 5. 执行SQL，返回结果集
        ResultSet rs = pstmt.executeQuery();
        // 6. 判断结果集是否有记录
        if (rs.next()) {
            existed = true;
        }
        // 7. 关闭预备语句对象
        pstmt.close();
        // 8. 关闭结果集对象
        rs.close();
    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        // 关闭数据库连接
        ConnectionManager.closeConnection(conn);
    }

    // 返回存在与否变量
    return existed;
}

}

本文地址：https://blog.csdn.net/qq_47831078/article/details/107407109