java第三，四次实训项目9-10 GUI学生信息管理系统
文章目录(项目9)
实现步骤
(五)创建数据库访问接口
1、创建学校数据访问接口
2、创建状态数据访问接口
3、创建学生数据访问接口
4、创建用户数据访问接口
- 在net.hw.student包里创建子包dao
1、创建学校数据访问接口
- 创建学校数据访问接口CollegeDao
package net.zm.student.dao;
import net.zm.student.bean.College;
public interface CollegeDao {
College findById(int id); //按编号查询学校记录
int update(College college); //更新学校记录
}
2、创建状态数据访问接口
- 创建状态数据访问接口StatusDao
package net.zm.student.dao;
import net.zm.student.bean.Status;
public interface StatusDao {
Status findById(int id); // 按编号查询状态记录
int update(Status status); // 更新状态记录
}
3、创建学生数据访问接口
- 创建学生数据访问接口StudentDao
package net.zm.student.dao;
import net.zm.student.bean.Student;
import java.util.List;
import java.util.Vector;
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<Student> findByName(String name); // 按姓名查询学生记录
List<Student> findByClass(String clazz); // 按班级查询学生记录
List<Student> findByDepartment(String department); // 按系部查询学生记录
List<Student> findAll(); // 查询全部学生记录
Vector findRowsBySex(); // 按性别统计人数
Vector findRowsByClass(); // 按班级统计人数
Vector findRowsByDepartment(); // 按系部统计人数
}
4、创建用户数据访问接口
- 创建用户数据访问接口UserDao
package net.zm.student.dao;
import net.zm.student.bean.User;
import java.util.List;
public interface UserDao {
int insert(User user); // 插入用户记录
int deleteById(int id); // 按编号删除用户记录
int update(User user); // 更新用户记录
User findById(int id); // 按编号查询用户记录
List<User> findAll(); // 查询全部用户记录
User login(String username, String password); // 用户登录
boolean isUsernameExisted(String username); // 判断用户名是否存在
}
文章目录(项目10)
实现步骤
（六）创建数据访问接口实现类
1、创建学校数据访问接口实现类
单元测试：对CollegeDaoImpl进行单元测试
(1)编写测试方法testFindById()
(2)编写测试方法testUpdate()
(3)同时运行多个测试方法
(4)完善测试代码
实现步骤
（六）创建数据访问接口实现类
- 在net.hw.student.dao包里创建impl子包，然后在里面创建四个数据访问接口的实现类。
1、创建学校数据访问接口实现类
- 创建学校数据访问接口实现类CollegeDaoImpl
package net.zm.student.dao.impl;
/**
*功能：学校数据访问接口实现类
*/
import net.zm.student.bean.College;
import net.zm.student.dao.CollegeDao;
import net.zm.student.dbutli.ConnectionManager;
import java.sql.*;
public class CollegeDaoImpl implements CollegeDao {
@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()){
//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"));
}
//9.关闭预备语句对象
pstmt.close();
//10.关闭结果集对象
rs.close();
} catch (SQLException e) {
e.printStackTrace();
} finally {
//11.关闭数据库连接
ConnectionManager.closeConnection(conn);
}
//返回学校对象
return college;
}
@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.setString(8,college.getId());
//5.执行sql，返回更新记录数
count = pstmt.executeUpdate();
//6.关闭预备语句对象
pstmt.close();
} catch (SQLException e) {
e.printStackTrace();
} finally {
//7.关闭数据库连接
ConnectionManager.closeConnection(conn);
}
//返回更新记录数
return 0;
}
}
单元测试：对CollegeDaoImpl进行单元测试
- 在根包net.hw.student里创建test子包，在里面创建测试类TestCollegeDaoImpl
package net.zm.student.test;
import net.zm.student.bean.College;
import net.zm.student.dao.CollegeDao;
import net.zm.student.dao.impl.CollegeDaoImpl;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
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);
//判断是否查询成功
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("没有查找到学校记录！");
}
}
@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("新校长："+college.getPresident());
}else {
System.out.println("学校记录更新失败！");
}
}
}
- 运行测试方法testFindById()，查看结果
- 运行测试方法testUpdate()，查看结果
2、创建状态数据访问接口实现类
- 创建状态数据访问接口实现类StatusDaoImpl
package net.zm.student.dao.impl;
import net.zm.student.bean.Status;
import net.zm.student.dao.StatusDao;
import net.zm.student.dbutli.ConnectionManager;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
/**
* 状态数据访问接口实现类
*/
public class StatusDaolmpl 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;
}
}
单元测试：对StatusDaoImpl进行单元测试
- 在net.zm.student.test包里创建测试类TestStatusDaoImpl
package net.zm.student.test;
import net.zm.student.bean.Status;
import net.zm.student.dao.StatusDao;
import net.zm.student.dao.impl.StatusDaolmpl;
import org.junit.Test;
/**
* 测试状态数据访问接口实现类
*/
public class TestStatusDaolmpl {
//声明状态数据访问对象
StatusDao dao = new StatusDaolmpl();
@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());
}
@Test
public void testUpdate(){
//调用状态数据访问对象的查询方法
Status status = dao.findById(1);
//修改状态对象的属性
status.setAuthor("曾梅");
status.setTelephone("18208303744");
status.setEmail("[email protected]");
//调用状态数据访问对象的更新方法
int count = dao.update(status);
//判断是否更新成功
if (count>0){
System.out.println("状态记录更新成功！");
System.out.println(dao.findById(1));
}else {
System.out.println("状态记录更新失败！");
}
}
}-
运行testFindById()方法，查看结果
-
运行testUpdate()方法，查看结果
3、学生数据访问接口实现类
- 学生数据访问接口实现类StudentDaoImpl
package net.zm.student.dao.impl;
import net.zm.student.bean.Student;
import net.zm.student.dao.StudentDao;
import net.zm.student.dbutli.ConnectionManager;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Vector;
/**
* 功能：学生数据访问接口实现类
*/
public class StudentDaolmpl 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;
}
}
单元测试：对TestStudentDaoImpl进行单元测试
- 在net.zm.student.test包里创建测试类TestStudentDaoImpl
package net.zm.student.test;
import net.zm.student.bean.Student;
import net.zm.student.dao.StudentDao;
import net.zm.student.dao.impl.StudentDaolmpl;
import org.junit.Test;
import java.util.Iterator;
import java.util.List;
import java.util.Vector;
public class TestStudentDaolmpl {
//定义学生数据访问对象
StudentDao dao = new StudentDaolmpl();
@Test
public void testInsert(){
//创建学生对象
Student student = new Student();
//设置学生对象属性
student.setId("19242094");
student.setName("张晓慧");
student.setSex("女");
student.setAge(19);
student.setDepartment("艺术传媒学院");
student.setClazz("2019数媒3班");
student.setTelephone("18208303744");
//调用学生数据访问对象的插入方法
int count = dao.insert(student);
//判断学生记录是否插入成功
if (count>0){
System.out.println("恭喜，学生记录插入成功！");
System.out.println(dao.findById(student.getId()));
}else {
System.out.println("遗憾，学生记录插入失败！");
}
}
@Test
public void testDeleteById(){
String id = "19242094";
//调用学生数据访问对象的按id删除方法
int count = dao.deleteById(id);
//判断学生记录是否删除成功
if (count>0){
System.out.println("恭喜，学生记录删除成功！");
}else {
System.out.println("遗憾，学生记录删除失败！");
}
}
@Test
public void testDeleteByClass(){
String clazz = "2019小教3班";
//调用学生书局访问对象的按班级删除方法
int count = dao.deleteByClass(clazz);
if (count>0){
System.out.println("恭喜，["+clazz+"]学生记录删除成功！");
}else {
System.out.println("遗憾，["+clazz+"]学生记录删除失败！");
}
}
@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("温馨提示：查无此人！");
}
}
@Test
public void testFindAll(){
//调用学生数据访问对象的查找全部方法
List<Student> students = dao.findAll();
//通过增强for循环遍历学生列表
for (Student student :students){
System.out.println(student);
}
}
@Test
public void testFindRowsBySex(){
//调用学生数据访问对象的按性别统计人数方法
Vector rows = dao.findRowsBySex();
//获取向量的迭代器
Iterator iterator = rows.iterator();
//遍历迭代器
while (iterator.hasNext()){
System.out.println(iterator.next());
}
}
@Test
public void testDeleteByDepartment(){
//调用学生访问对象按系部删除人数
String dep = "外语系";
//调用学生数据访问对象的按dep删除方法
int count = dao.deleteByDepartment(dep);
//判断学生记录是否删除成功
if (count>0){
System.out.println("恭喜，学生记录删除成功！");
}else {
System.out.println("遗憾，学生记录删除失败！");
}
}
@Test
public void testUpdate(){
//调用学生数据访问对象的查询方法
Student student=dao.findById("11012456");
//修改学生对象的属性
student.setName("李玉刚");
student.setSex("男");
student.setAge(20);
student.setDepartment("外语系");
student.setClazz("19小教一班");
student.setTelephone("18208303744");
//调用学生数据访问对象的更新方法
int count=dao.update(student);
//判断学生更新是否成功
if(count>0){
System.out.println("学生记录更新成功！");
System.out.println(dao.findById("11012456"));
}else {
System.out.println("学生记录更新失败！");
}
}
@Test
public void testFindById(){
//调用学生数据访问对象的查找方法
Student student=dao.findById("11012456");
//输出学生信息
System.out.println("id:"+student.getId());
System.out.println("姓名："+student.getName());
System.out.println("性别："+student.getSex());
System.out.println("年龄："+student.getAge());
System.out.println("系部："+student.getDepartment());
System.out.println("班级："+student.getClazz());
System.out.println("电话："+student.getTelephone());
}
@Test
public void testFindByClass(){
//调用学生数据访问对象的查找方法
List<Student> students=dao.findByClass("11建工1班");
//输出学生信息
for(Student student:students){
System.out.println("id:"+student.getId());
System.out.println("姓名："+student.getName());
System.out.println("性别："+student.getSex());
System.out.println("年龄："+student.getAge());
System.out.println("系部："+student.getDepartment());
System.out.println("班级："+student.getClazz());
System.out.println("电话："+student.getTelephone());
}
}
@Test
public void testFindByDepartment(){
//调用学生数据访问对象的查找方法
List<Student> students=dao.findByDepartment("信息工程系");
//判断列表里是否有元素
if(students.size()>0){
//通过增强for循环遍历学生列表
for(Student student:students){
System.out.println("id:"+student.getId());
System.out.println("姓名："+student.getName());
System.out.println("性别："+student.getSex());
System.out.println("年龄："+student.getAge());
System.out.println("系部："+student.getDepartment());
System.out.println("班级："+student.getClazz());
System.out.println("电话："+student.getTelephone());
}
}else {
System.out.println("温馨提示：没有这个系部！");
}
}
@Test
public void testFindRowsByClass(){
//调用学生数据访问对象的按班级统计人数方法
Vector rows=dao.findRowsByClass();
//获取向量的迭代器
Iterator iterator=rows.iterator();
//遍历迭代器
while (iterator.hasNext()){
System.out.println(iterator.next());
}
}
@Test
public void testFindRowsByDepartment(){
//调用学生数据访问对象的按系部统计人数方法
Vector rows=dao.findRowsByDepartment();
//获取向量的迭代器
Iterator iterator=rows.iterator();
//遍历迭代器
while (iterator.hasNext()){
System.out.println(iterator.next());
}
}
}
4、创建用户数据访问接口实现类
- 创建用户数据访问接口实现类UserDaoImpl
package net.zm.student.dao.impl;
import net.zm.student.bean.User;
import net.zm.student.dao.UserDao;
import net.zm.student.dbutli.ConnectionManager;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
/**
* 功能：用户数据访问接口实现类
*/
public class UserDaolmpl 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;
}
}
单元测试：对TestUserDaoImpl进行单元测试
- 在net.zm.student.test包里创建测试类TestUserDaoImpl
package net.zm.student.test;
import net.zm.student.bean.User;
import net.zm.student.dao.UserDao;
import net.zm.student.dao.impl.UserDaolmpl;
import org.junit.Test;
import java.util.Date;
import java.util.List;
public class TestUserDaolmpl {
//定义用户数据访问对象
UserDao dao = new UserDaolmpl();
@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());
}
@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("遗憾，用户名或密码错误，登陆失败！");
}
}
@Test
public void testlsUsernameExisted(){
//定义用户名
String username = "张三丰";
//调用用户数据访问对象的用户名存在与否方法
boolean result = dao.isUsernameExisted(username);
//判断用户是否存在
if (result){
System.out.println("温馨提示：["+username+"]已存在，不可用此名注册！");
}else {
System.out.println("温馨提示：["+username+"]不存在，可用此名注册！");
}
}
@Test
public void testInsert(){
//定义用户对象
User user = new User();
//设置用户属性
user.setUsername("吴彦祖");
user.setPassword("111");
user.setTelephone("18208303744");
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("遗憾,用户记录插入失败！");
}
}
@Test
public void testDeleteById(){
int id=8;
//调用用户数据访问对象的按id删除方法
int count=dao.deleteById(id);
//判断用户记录是否删除成功
if(count>0){
System.out.println("恭喜，用户记录删除成功！");
}else {
System.out.println("遗憾，用户记录删除失败！");
}
}
@Test
public void testUpdate(){
//调用状态数据访问对象的查询方法
User user=dao.findById(1);
//修改状态对象的属性
user.setUsername("adminn");
user.setPassword("adminn");
user.setTelephone("18922222222");
user.setRegisterTime(new Date());
//调用状态数据访问对象的更新方法
int count=dao.update(user);
//判断状态更新是否成功
if(count>0){
System.out.println("状态记录更新成功！");
System.out.println(dao.findById(1));
}else {
System.out.println("状态记录更新失败！");
}
}
@Test
public void testFindAll(){
//调用用户数据访问对象的查找全部方法
List<User> users=dao.findAll();
//通过增强for循环遍历学生列表
for(User user:users){
System.out.println(user);
}
}
}
第三，四实训小结，在敲代码的过程中总会导错包，导致报错。还有在创建学校数据访问接口类collegedaolmpl时定义字符串更新数据代码少大还有多打了逗号都会导致报错，所以在每次打代码的时候都要多注意。