2019.6.29实训总结

最新推荐文章于 2020-07-08 15:36:03 发布

weixin_45095088

最新推荐文章于 2020-07-08 15:36:03 发布

阅读量102

点赞数

分类专栏：总结

本文链接：https://blog.csdn.net/weixin_45095088/article/details/94328656

版权

总结专栏收录该内容

12 篇文章 0 订阅

订阅专栏

学生数据访问接口实现类StudentDaoImpl,代码如下:

package net.lyq.student.dao.impl;

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

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

/**

功能：学生数据访问接口实现类
作者：刘燕琼
日期：2019年6月29日
*/

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;
}

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

}

在net.hw.student.test包里创建测试类TestStudentDaoImpl

在这里插入图片描述

运行该测试方法，结果如下：

用户数据访问接口实现类UserDaoImpl

package net.lyq.student.dao.impl;

import net.lyq.student.bean.User;
import net.lyq.student.dao.UserDao;
import net.lyq.student.dbutil.ConnectionManager;
import org.junit.Test;

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

/**

功能：用户数据访问接口实现类
作者：刘燕琼
日期：2019年6月29日
*/
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 (?, ?, ?, ?)";
  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 findAll() {
  // 声明用户列表
  List users = new ArrayList();
  
  // 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;
  }

}

在net.hw.student.test包里创建测试类TestUserDaoImpl：

在这里插入图片描述

运行该测试方法，结果如下：

weixin_45095088

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
2019.6.29实训总结

学生数据访问接口实现类StudentDaoImpl,代码如下:package net.lyq.student.dao.impl;import net.lyq.student.bean.Student;import net.lyq.student.dao.StudentDao;import net.lyq.student.dbutil.ConnectionManager;import ja...
复制链接

扫一扫