第三次Java实训课总结

一、创建数据访问接口

对t_college、t_status、t_tudent与t_user表，创建四个数据访问接口CollegeDao、StatusDao、StudentDao与UserDao。

二、创建数据访问接口实现类

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

package net.zhj.student.dao.impl;

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

import java.sql.*;

public class CollegeDaoImpl implements CollegeDao {
    /**
     * 按编号查找学校记录
     *
     * @param id
     * @return 学校对象
     */
    @Override
    public College findById(int id) {
        // 声明学习对象
        College college = null;

        // 1. 获取数据库连接
        Connection conn = ConnectionManager.getConnection();
        // 2. 定义SQL字符串
        String student = "select * from t_college where id = ?";
        try {
            // 3.创建预备语句对象
            PreparedStatement pstmt = conn.prepareStatement(student);
            // 4.设置占位符的值
            pstmt.setInt(1,id);
            // 5.执行SQL查询，返回结果集
            ResultSet rs = pstmt.executeQuery();
            // 6.判断结果集是否为空
            if (rs.next()) {
                // 7.创建学校实体对象
                college = new College();
                // 8.用当前记录字段值设置实体属性
                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"));
            }
            //  关闭预备语句对象
            pstmt.close();
            //  关闭结果集对象
            rs.close();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            // 9.关闭数据库连接
            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 student = "update t_college set name = ?, president = ?, start_time = ?,"
                + " telephone = ?, email = ?, address = ?, profile = ? where id = ?";
        try {
            // 3. 创建预备语句对象
            PreparedStatement pstmt = conn.prepareStatement(student);
            // 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;
    }
}

1.1 创建测试类TestCollegeDaoImpl并编写测试方法testFindById()

package net.zhj.student.test;

import net.zhj.student.bean.College;
import net.zhj.student.dao.CollegeDao;
import net.zhj.student.dao.impl.CollegeDaoImpl;
import org.junit.Test;


public class TestCollegeDaolmpl {
    @Test
    public void testFindById() {
        // 创建学校数据访问接口对象
        CollegeDao dao = new CollegeDaoImpl();
        // 调用学校数据访问接口对象的查询方法
        College college = dao.findById(1);
        // 判断学校对象是否为空
        if (college != null) {
            // 输出学校信息
            System.out.println("校名:"+college.getName());
            System.out.println("校长:"+college.getPresident());
            System.out.println("地址:"+college.getAddress());
            System.out.println("邮箱:"+college.getEmail());
            System.out.println("电话:"+college.getTelephone());
        } else {
            System.out.println("没有查询到！");
        }
    }
}    

运行结果如下：

1.2 编写测试方法testUpdate()

    @Test
    public void testUpdate() {
        // 创建学校数据访问接口对象
        CollegeDao dao = new CollegeDaoImpl();
        // 调用学校数据访问接口对象的查询方法
        College college = dao.findById(1);
        // 修改学校信息(不能修改编号信息）
        college.setPresident("李萌萌");
        college.setTelephone("0830-3124567");
        // 调用学校数据访问对象的更新方法
        int count = dao.update(college);
        // 判断是否更新成功
        if (count > 0) {
            System.out.println("学校记录更新成功！");
            System.out.println("新校长："+dao.findById(1).getPresident());
            System.out.println("新电话："+dao.findById(1).getTelephone());
        } else {
            System.out.println("学校记录更新失败！");
        }
    }

运行结果如下：

2、创建状态数据访问接口实现类StatusDaoImpl

package net.zhj.student.dao.impl;

import net.zhj.student.bean.Status;
import net.zhj.student.dao.StatusDao;
import net.zhj.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 student = "SELECT * FROM t_status WHERE id = ?";
        try {
            // 3. 创建预备语句对象
            PreparedStatement pstmt = conn.prepareStatement(student);
            // 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;
    }
}

2.1 创建测试类TestStatusDaoImpl并编写测试方法testFindById()

package net.zhj.student.test;

import net.zhj.student.bean.Status;
import net.zhj.student.dao.StatusDao;
import net.zhj.student.dao.impl.StatusDaoImpl;
import org.junit.Test;

public class TestStatusDaoImpl {
    // 声明状态数据访问对象
    StatusDao dao = new StatusDaoImpl();

    @Test
    public void testFindById() {
        // 调用状态数据访问对象的查询方法
        Status status = dao.findById(1);
        // 输出状态信息
        System.out.println("作者:" + status.getAuthor());
        System.out.println("学校:" + status.getCollege());
        System.out.println("版本:" + status.getVersion());
        System.out.println("地址:" + status.getAddress());
        System.out.println("电话:" + status.getTelephone());
        System.out.println("邮箱:" + status.getEmail());
    }
}

运行结果如下：

2.2 编写测试方法testUpdate()

@Test
    public void testUpdate() {
        // 调用状态数据访问对象的查询方法
        Status status = dao.findById(1);
        // 修改状态对象的属性
        status.setAuthor("小朱");
        status.setTelephone("17748118364");
        status.setEmail("[e-mail]");
        // 调用状态数据访问对象的更新方法
        int count = dao.update(status);
        // 判断状态更新是否成功
        if (count > 0) {
            System.out.println("状态记录更新成功！");
            System.out.println(dao.findById(1));
        } else {
            System.out.println("状态记录更新失败！");
        }
    }

运行结果如下：

3、学生数据访问接口实现类StudentDaoImpl

package net.zhj.student.dao.impl;

import net.zhj.student.bean.Student;
import net.zhj.student.dao.StudentDao;
import net.zhj.student.dbutil.ConnectionManager;

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

public class StudentDaoImpl implements StudentDao {
    /**
     * 插入学生记录
     *
     * @param student
     * @return 插入记录数
     */
    @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;
    }

    @Override
    public int deleteById(int id) {
        return 0;
    }

    /**
     * 按学号删除学生记录
     *
     * @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;
    }

    @Override
    public Student findById(int id) {
        return null;
    }

    /**
     * 按学号查询学生记录
     *
     * @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;
    }
}

3.1 创建测试类TestStudentDaoImpl并编写测试方法testInsert()

package net.zhj.student.test;

import net.zhj.student.bean.Student;
import net.zhj.student.dao.StudentDao;
import net.zhj.student.dao.impl.StudentDaoImpl;
import org.junit.Test;

import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Vector;

public class TestStudentDaoImpl {
    StudentDao dao = new StudentDaoImpl();

    @Test
    public void testInsert() {
        // 创建学生对象
        Student student = new Student();
        // 设置学生对象属性
        student.setId("19207194");
        student.setName("张晓慧");
        student.setSex("女");
        student.setAge(19);
        student.setDepartment("艺术传媒学院");
        student.setClazz("19数媒3班");
        student.setTelephone("15890674568");
        // 调用学生数据访问对象的插入方法
        int count = dao.insert(student);
        // 判断学生记录是否插入成功
        if (count > 0) {
            System.out.println("恭喜，学生记录插入成功！");
            System.out.println(dao.findById(student.getId()));
        } else {
            System.out.println("遗憾，学生记录插入失败！");
        }
    }
}

运行结果如下：

在navicat中查看：

3.2 编写测试方法testDeleteById()

 @Test
    public void testDeleteById() {
        String id = "19207194";
        // 调用学生数据访问对象的按id删除方法
        int count = dao.deleteById(id);
        // 判断学生记录是否删除成功
        if (count > 0) {
            System.out.println("恭喜，学生记录删除成功！");
        } else {
            System.out.println("遗憾，学生记录删除失败！");
        }
    }

运行结果如下：

3.3 编写测试方法testDeleteByClass()

@Test
    public void testDeleteByClass() {
        String clazz = "19会计2班";
        // 调用学生数据访问对象的按班级删除方法
        int count = dao.deleteByClass(clazz);
        if (count > 0) {
            System.out.println("恭喜,[" + clazz + "]学生记录删除成功!");
        } else {
            System.out.println("遗憾,[" + clazz + "]学生记录删除失败!");
        }
    }

运行结果如下：

3.4 编写测试方法testFindByName()

@Test
    public void testFindByName() {
        String name = "张三丰";
        // 调用学生数据访问对象的按姓名查找方法
        List<Student> students = dao.findByName(name);
        // 判断列表里是否有元素
        if (students.size() > 0) {
            // 通过增强for循环遍历学生列表
            for (Student student : students) {
                System.out.println(student);
            }
        } else {
            System.out.println("温馨提示：查无此人！");
        }
    }

运行结果如下：

3.5 编写测试方法testFindAll()

@Test
    public void testFindAll() {
        // 调用学生数据访问对象的查找全部方法
        List<Student> students = dao.findAll();
        // 通过增强for循环遍历学生列表
        for (Student student : students) {
            System.out.println(student);
        }
    }

运行结果如下：

3.6 编写测试方法testFindRowsBySex()

@Test
    public void testFindRowsBySex() {
        // 调用学生数据访问对象的按性别统计人数方法
        Vector rows = dao.findRowsBySex();
        // 获取向量的迭代器
        Iterator iterator = rows.iterator();
        // 遍历迭代器
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }

运行结果如下：

3.7 编写测试方法testDeleteByDepartment()

@Test
    public void testDeleteByDepartment() {
        String department = "国际学院";
        // 调用学生数据访问对象的按系部删除方法
        int count = dao.deleteByDepartment(department);
        if (count > 0) {
            System.out.println("恭喜,学生记录删除成功！");
        } else {
            System.out.println("遗憾,学生记录删除失败！");
        }
    }

运行结果如下：

3.8 编写测试方法testUpdate()

 @Test
    public void testUpdate() {
        // 调用状态数据访问对象的查询方法
        Student student = dao.findById("19202133");
        // 修改状态对象的属性
        student.setId("19202133");
        student.setName("刘芳");
        student.setTelephone("17748118364");
        // 调用状态数据访问对象的更新方法
        int count = dao.update(student);
        // 判断状态更新是否成功
        if (count > 0) {
            System.out.println("状态记录更新成功！");
        } else {
            System.out.println("状态记录更新失败！");
        }
    }

运行结果如下：

打开navicat查看：

3.9 编写测试方法testFindById()

@Test
    public void testFindById() {
        String id = "19202136";
        // 调用学生数据访问对象的按id查找方法
        List<Student> students = Collections.singletonList(dao.findById(id));
        // 判断列表里是否有元素
        if (students.size() > 0) {
            // 通过增强for循环遍历学生列表
            for (Student student : students) {
                System.out.println(student);
            }
        } else {
            System.out.println("温馨提示：查无此人！");
        }
    }

运行结果如下：

3.10 编写测试方法testFindByClass()

 @Test
    public void testFindByClass() {
        String clazz = "19计应2班";
        List<Student> students = dao.findByClass(clazz);
        // 判断列表里是否有元素
        if (students.size() > 0) {
            // 通过增强for循环遍历学生列表
            for (Student student : students) {
                System.out.println(student);
            }
        } else {
            System.out.println("温馨提示：查无此人！");
        }
    }

运行结果如下：

3.11 编写测试方法testFindByDepartment()

 @Test
    public void testFindByDepartment() {
        String department = "人文学院";
        List<Student> students = dao.findByClass(department);
        // 判断列表里是否有元素
        if (students.size() > 0) {
            // 通过增强for循环遍历学生列表
            for (Student student : students) {
                System.out.println(student);
            }
        } else {
            System.out.println("温馨提示：查无此人！");
        }
    }

运行结果如下：

问题：在Navicat中查看，表中有记录，但是查询不到？？？

3.12 编写测试方法testFindRowsByClass()

@Test
    public void testFindRowsByClass() {
        Vector rows = dao.findRowsByClass();
        // 获取向量的迭代器
        Iterator iterator = rows.iterator();
        // 遍历迭代器
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }

运行结果如下：

3.13 编写测试方法testFindRowsByDepartment()

@Test
    public void testFindRowsByDepartment() {
        Vector rows = dao.findRowsByDepartment();
        // 获取向量的迭代器
        Iterator iterator = rows.iterator();
        // 遍历迭代器
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }

运行结果如下：

4、创建用户数据访问接口实现类UserDaoImpl

4.1 创建测试类TestUserDaoImpl并编写测试方法testFindById()

package net.zhj.student.test;

import net.zhj.student.bean.User;
import net.zhj.student.dao.UserDao;
import net.zhj.student.dao.impl.UserDaoImpl;
import org.junit.Test;

import java.util.Date;
import java.util.List;

public class TestUserDaoImpl {
    UserDao dao = new UserDaoImpl();

    @Test
    public void testFindById() {
        User user = dao.findById(1);
        System.out.println("用户名："+user.getUsername());
        System.out.println("密码："+user.getPassword());
        System.out.println("电话："+user.getTelephone());
        System.out.println("注册时间:"+user.getRegisterTime());
    }
}

运行结果如下：

4.2 编写测试方法testLogin()

@Test
    public void testLogin() {
        String username, password;
        username = "admin";
        password = "admin";
        User user = dao.login(username, password);
        if (user != null) {
            System.out.println("恭喜，用户名与密码正确，登陆成功！");
        } else {
            System.out.println("遗憾，用户名与密码错误，登陆失败！");
        }
    }

运行结果如下：

4.3 编写测试方法testIsUsernameExisted()

@Test
    public void testIsUsernameExisted() {
        String username = "张三丰";
        boolean result = dao.isUsernameExisted(username);
        if (result) {
            System.out.println("温馨提示：[" + username + "]已存在，不可用此名注册！");
        } else {
            System.out.println("温馨提示：[" + username + "]不存在，可用此名注册！");
        }
    }

运行结果如下：

4.4 编写测试方法testInsert()

@Test
    public void testInsert() {
        User user = new User();
        user.setUsername("吴彦文");
        user.setPassword("345679");
        user.setTelephone("15823234590");
        user.setRegisterTime(new Date());

        int count = dao.insert(user);
        if (count > 0) {
            System.out.println("恭喜，用户记录插入成功！");
            System.out.println(dao.findById(dao.findAll().size()));
        } else {
            System.out.println("遗憾，用户记录插入失败！");
        }
    }

运行结果如下：

打开navicat查看：

4.5 编写测试方法testDeleteById()

@Test
    public void testDeleteById() {
        String id = "19208107";
        // 调用学生数据访问对象的按id删除方法
        int count = dao.deleteById(id);
        // 判断学生记录是否删除成功
        if (count > 0) {
            System.out.println("恭喜，学生记录删除成功！");
        } else {
            System.out.println("遗憾，学生记录删除失败！");
        }
    }

运行结果如下：

问题：删除失败

4.6 编写测试方法testUpdate()

@Test
    public void testUpdate() {
        // 调用状态数据访问对象的查询方法
        User user = dao.findById(1);
        // 修改状态对象的属性
        user.setUsername("刘芳");
        user.setTelephone("17748118364");
        // 调用状态数据访问对象的更新方法
        int count = dao.update(user);
        // 判断状态更新是否成功
        if (count > 0) {
            System.out.println("状态记录更新成功！");
            System.out.println(dao.findById(1));
        } else {
            System.out.println("状态记录更新失败！");
        }
    }

运行结果如下：

4.7 编写测试方法testFindAll()

 @Test
    public void testFindAll() {
        // 调用学生数据访问对象的查找全部方法
        List<User> users = dao.findAll();
        // 通过增强for循环遍历学生列表
        for (User user : users) {
            System.out.println(user);
        }
    }

运行结果如下：

总结

在创建数据访问接口类的时候，测试方法反复用了很多次，前面有老师的代码，跟着老师的写了几遍，后面写的时候就比较简单了，不会的再翻回去看。老师也提倡我们要先按着老师的写，然后自己默写，这样更能加深对知识的印象，更能帮助我们理解，实训的过程，也是查漏补缺的过程。

本文地址：https://blog.csdn.net/qq_45893453/article/details/107162051