第一个实训项目（2）

创建一个dao包

再在dao包里建立一个接口

package net.hj.student.dao;

import net.hj.student.bean.College;

/*
功能：学校数据访问接口
作者：何杰
日期：2019年6月27日
*/
public interface CollegeDao {
College findById(int id);
int update(College college);
}
第二个接口

package net.hj.student.dao;

import net.hj.student.bean.Status;

/*
功能：状态数据访问接口
作者：何杰
日期：2019年6月27日
*/
public interface StatusDao {
Status findById(int id);
int update(Status status);

}
插入第三个接口

package net.hj.student.dao;

import net.hj.student.bean.Student;

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

/*
功能：学生数据访问接口
作者：何杰
日期：2019年6月27日
*/
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 findRowsclass();
Vector findRowsDepartment();
}
插入第四个接口

package net.hj.student.dao;

import net.hj.student.bean.User;

import java.util.List;

/*
功能：用户数据访问接口
作者：何杰
日期：2019年6月27日
*/
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);
}
在dao包里创建一个子包impl
在impl包里创建一个类

CollegeDaoImpl的代码
package net.hj.student.dao.impl;

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

import java.sql.*;

/*
功能：学校数据访问实现类
作者：何杰
日期：2019年6月27日
/
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.getNString("name"));
            college.setPresident(rs.getNString("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;
}

}
在student包下新建一个test包，在test创建一个测试类TestCollegeDaoImpl
package net.hj.student.test;

import net.hj.student.bean.College;
import net.hj.student.dao.CollegeDao;
import net.hj.student.dao.impl.CollegeDaoImpl;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

/**

• 功能：测试学校数据访问接口实现类

• 作者:何杰

• 日期：2019年6月27日
  */
  public class TestCollegeDaoImpl {
  //创建学校数据访问对象
  CollegeDao dao = new CollegeDaoImpl();

  @Before
  public void beforeTest(){
  //每个单元测试之前都要执行的代码
  System.out.println(“温馨提示：单元测试开始了！”);
  }

  @After
  public void afterTest(){
  //每个单元测试之后都要执行的代码
  System.out.println(“温馨提示单元测试结束了！”);
  }
  @Test
  public void testFindById(){

   //调用学校数据访问对象的查询方法
   College college = dao.findById(1);
   //输出学校对象
   System.out.println(college);
  

  }

  @Test
  public void testUpdate(){
  //调用学校数据访问对象的查询方法
  College college = dao.findById(1);
  //修改学校信息
  college.setPresident(“郑志强”);
  //调用学校数据访问对象的更新方法
  int count = dao .update(college);
  //判断是否成功
  if (count > 0){
  System.out.println(“学校记录更新成功！”);
  System.out.println(“新校长：” + dao.findById(1).getPresident());
  }else {
  System.out.println(“学校记录更新失败！”);
  }
  }
  }
  再在impl下新建一个状态数据访问接口实现类
  package net.hj.student.dao.impl;

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

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

/**

• 功能：状态数据访问接口实现类

• 作者:何杰

• 日期：2019年6月18日
  */
  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) {
  //定义更新记录数
  //1.获取数据库连接对象
  Connection conn = ConnectionManager.getConnection();
  int count = 0;
  //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;
  

  }
  }
  再在test下面做个测试
  
  
  执行结束
  
  
  执行结束
  
  同意的方法建立个学生数据访问接口实现类
  
  package net.hj.student.dao.impl;

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

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

/*
功能：学生数据访问接口实现类
作者：何杰
日期：2019年6月27日
/
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 = ?";
    //3.创建预备语句对象
    try {
        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<>();

    //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 findRowsClass() {
    //定义行集向量
    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 findRowsDepartment() {
    //定义行集向量
    Vector rows = new Vector();

    //1获取数据库连接对象
    Connection conn = ConnectionManager.getConnection();
    try {
        //2.定义SQL字符串
        String strSQL = "select department as '系部', count(*) as '人数'"
                + "from t_student group by department order by department desc";
        //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;
}

}
在test里写个测试

插入记录

运行结果

按学号删除记录

运行结果

按班级删除记录

运行结果

按系部删除记录

运行结果

按姓名查找记录

运行结果

按学号查询记录

运行结果

按ID更新记录

运行结果

按姓名查找记录

运行结果

按班级查询学生记录

运行结果

按系部查询学生记录

运行结果

查询全部学生机记录

运行结果

按性别查询记录

运行结果

按班级统计学生人数

运行结果

按系部统计学生人数

运行结果


同样的方法在impl里新建一个类UserDaoImpl

package net.hj.student.dao.impl;

import net.hj.student.bean.User;
import net.hj.student.dao.UserDao;
import net.hj.student.dbutil.ConnectionManager;

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

/*
功能：用户数据访问接口实现类
作者：何杰
日期：2019年6月28日
/
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;
}

/**
 * 按di删除用户记录
 * @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 = ?";
    //3.创建预备语句对象
    try {
        PreparedStatement pstmt = conn.prepareStatement(strSQL);
        //4.设置占位符的值
        pstmt.setInt(1, id);
        //5.执行SQL，返回删除记录数
        count = pstmt.executeUpdate();
        //6.关闭预备语句对象
        pstmt.close();
    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        //关闭数据库连接
    }

    //返回删除记录数
    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;
}

}
再在test里建个实现类

插入用户数据，做到这儿的时候，我发现我找不到方法插入日期类型，于是去把定义的日期类型修改成了数据库里的类型，将Date修改成了Timestamp，其他相应的地方也修改





运行结果

按ID删除用户记录

执行结果


按ID更新记录

运行结果

显示信息

运行结果

查询所有用户

运行结果

用户登录

运行结果

判断用户名重复

运行结果

根据用户名获得密码

运行结果