Dao层Impl
1、Dao层Impl
1.1 UserDaoImpl
1.1.1 login
@Override
public User login(String name, String password) {
Connection connection = null;
PreparedStatement preparedStatement = null;
ResultSet resultSet = null;
User user = null;
try {
connection = JDBCUtil.getConnection();
String sql = "SELECT * FROM user where username=? and password=?";
preparedStatement = connection.prepareStatement(sql);
preparedStatement.setString(1, name);
preparedStatement.setString(2, password);
//System.out.println(preparedStatement);
resultSet = preparedStatement.executeQuery();
while (resultSet.next()) {//判断下一个有没有，如果返回true而且指向下一个，没有返回false
int id = resultSet.getInt("id");
String nickName = resultSet.getString("nickname");
Integer status=resultSet.getInt("status");
user = new User(id, name, password, nickName,status);
}
} catch (SQLException throwables) {
throwables.printStackTrace();
} finally {
JDBCUtil.close(connection, preparedStatement, resultSet);
}
return user;
}
这段代码是一个实现了IUserDao接口的UserDaoImpl类的具体实现，其中的login方法用于验证用户登录。下面是对代码的详细解释：
-
该类实现了
IUserDao接口，这意味着它应该提供login方法的实现来处理用户的登录操作。 -
在
login方法中，首先创建了用于存储数据库连接、预编译语句和结果集的对象，以及一个用于存储用户信息的User对象。 -
通过
JDBCUtil.getConnection()方法获取数据库连接connection，这里假设JDBCUtil是一个自定义的工具类，负责数据库连接的创建和关闭。 -
构造 SQL 查询语句，该语句通过用户名和密码来查询匹配的用户信息。
-
通过预编译语句
preparedStatement设置参数，将用户名和密码作为查询条件传递给 SQL 查询语句。 -
使用
executeQuery方法执行 SQL 查询语句，并将结果存储在结果集resultSet中。 -
使用
while循环遍历结果集，如果有匹配的用户信息，那么将相应的字段值提取出来，并使用这些值构造一个User对象。 -
在循环外部，通过
JDBCUtil.close方法关闭数据库连接、预编译语句和结果集，以避免资源泄露。 -
最后，返回构造的
User对象，如果没有找到匹配的用户信息，则User对象为空。
1.1.2 register
@Override
public int register(String name, String password, String nickname) {
Connection connection=null;
PreparedStatement preparedStatement=null;
int count=0;
try {
connection = JDBCUtil.getConnection();
String sql = "select count(*) as num from user where username = ?";
preparedStatement = connection.prepareStatement(sql);
preparedStatement.setString(1,name);
ResultSet resultSet = preparedStatement.executeQuery();
int n=0;
while (resultSet.next()){
if(resultSet.getInt("num")<1){
break;
}
n++;
}
if(n>0){
return 0;
}
sql = "insert into user(username,password,nickname) values(?,?,?)";
preparedStatement = connection.prepareStatement(sql);
preparedStatement.setString(1,name);
preparedStatement.setString(2,password);
preparedStatement.setString(3,nickname);
count = preparedStatement.executeUpdate();
} catch (SQLException throwables) {
throwables.printStackTrace();
} finally {
JDBCUtil.close(connection, preparedStatement, null);
}
return count;
}
这段代码是一个实现了IUserDao接口的UserDaoImpl类，主要实现了用户注册的功能。下面是对代码的详细解释：
-
register方法是实现用户注册功能的方法。它接受三个参数：name（用户名）、password（密码）和nickname（昵称）。 -
首先，通过
JDBCUtil.getConnection()方法获取数据库连接对象connection。 -
接着，根据给定的用户名
name查询数据库中是否存在相同的用户名。SQL 查询语句select count(*) as num from user where username = ?用于统计具有相同用户名的记录数量。通过设置参数，预编译 SQL 语句并执行查询，然后使用resultSet获取查询结果。 -
在循环中，检查结果集中的“num”字段值，如果小于 1（即不存在相同用户名），则跳出循环。否则，递增变量
n。 -
如果
n大于 0，表示已经存在相同的用户名，因此返回值为 0，代表注册失败。 -
如果没有相同的用户名，则将注册信息插入到数据库中。使用预编译的 SQL 语句
insert into user(username, password, nickname) values(?,?,?)，设置参数，并执行更新操作。 -
最后，在
catch块中处理可能出现的SQLException异常，打印异常堆栈信息。 -
不论是否发生异常，最终都会通过
JDBCUtil.close()方法关闭数据库连接，预编译语句对象等资源。 -
返回注册操作影响的行数
count，如果注册成功，则count为 1，否则为 0。
总的来说，该 register 方法用于在数据库中插入新的用户记录，但在插入之前会检查是否存在相同的用户名，以确保用户名的唯一性。
1.1.3 selectByPage
@Override
public List<User> selectByPage(UserQuery userQuery) {
int offset = (userQuery.getPage() - 1) * userQuery.getLimit();
Connection connection = null;
PreparedStatement preparedStatement = null;
ResultSet resultSet = null;
List<User> list = new ArrayList<>();
try {
connection = JDBCUtil.getConnection();
String sql = "SELECT * FROM user where 1=1 ";
//这里面放所有搜索条件
List<Object> queryList = new ArrayList<>();
String queryName = userQuery.getUsername();
if (queryName != null && !"".equals(queryName)) {
sql += " and username like ? ";
queryList.add("%"+queryName+"%");
}
sql += " limit ?,?";
preparedStatement = connection.prepareStatement(sql);
for (int i = 0; i < queryList.size(); i++) {
preparedStatement.setObject(i + 1, queryList.get(i));
}
preparedStatement.setInt(queryList.size() + 1, offset);
preparedStatement.setInt(queryList.size() + 2, userQuery.getLimit());
resultSet = preparedStatement.executeQuery();
while (resultSet.next()) {//判断下一个有没有，如果返回true而且指向下一个，没有返回false
int id = resultSet.getInt("id");
String username = resultSet.getString("username");
String password = resultSet.getString("password");
String nickname = resultSet.getString("nickname");
Integer status=resultSet.getInt("status");
User user = new User(id, username, password, nickname,status);
list.add(user);
}
} catch (SQLException throwables) {
throwables.printStackTrace();
} finally {
JDBCUtil.close(connection, preparedStatement, resultSet);
}
return list;
}
这段代码是一个 Java 类，实现了 IUserDao 接口，并提供了对用户信息进行分页查询的功能。下面是对代码功能的详细解释：
-
selectByPage方法是根据给定的UserQuery对象执行分页查询的方法。它接受一个UserQuery对象作为参数，该对象包含了查询的条件，如用户名、分页信息等。 -
首先，根据传入的
userQuery中的分页信息计算出偏移量offset，用于指定查询结果的起始位置。 -
代码尝试建立数据库连接，并通过 JDBCUtil 工具类获取一个数据库连接对象
connection。 -
构建 SQL 查询语句，初始语句是
"SELECT * FROM user where 1=1 "。1=1 这个条件是为了方便后续拼接其他条件，使得 SQL 语句拼接更加灵活。 -
然后，根据传入的
userQuery对象中的用户名查询条件拼接 SQL 语句。如果用户名不为空，将会在 SQL 语句中加入username like ?条件，并将查询参数加入到queryList中。 -
接着，将 SQL 语句中的分页限制添加到 SQL 语句末尾，使用
limit ?,?的形式来限制查询结果的范围。 -
通过预编译的 SQL 语句
preparedStatement对象执行 SQL 查询。在这里，将所有的查询参数都设置到了preparedStatement中，包括用户名查询条件、偏移量和限制数量。 -
然后通过执行
resultSet = preparedStatement.executeQuery()语句来执行 SQL 查询并获取查询结果集。 -
通过遍历
resultSet，将每一行的查询结果映射为一个User对象，并将其添加到list中。 -
最后，在
finally块中关闭数据库连接，以释放数据库资源，避免造成资源泄漏。 -
最终，返回包含查询结果的
list列表，其中包含了根据查询条件和分页信息查询出的User对象列表。
1.1.4 selectTotalCount
@Override
public Integer selectTotalCount(UserQuery userQuery) {
Connection connection = null;
PreparedStatement preparedStatement = null;
ResultSet resultSet = null;
int totalCount = 0;
try {
connection = JDBCUtil.getConnection();
String sql = "select count(*) from user where 1=1 ";
List<Object> queryList = new ArrayList<>();
String queryName = userQuery.getUsername();
if (queryName != null && !"".equals(queryName)) {
sql += " and username like ? ";
queryList.add("%"+queryName+"%");
}
preparedStatement = connection.prepareStatement(sql);
for (int i = 0; i < queryList.size(); i++) {
preparedStatement.setObject(i + 1, queryList.get(i));
}
//System.out.println(preparedStatement);
resultSet = preparedStatement.executeQuery();
while (resultSet.next()) {
totalCount = resultSet.getInt(1);
}
} catch (SQLException throwables) {
throwables.printStackTrace();
}finally {
JDBCUtil.close(connection, preparedStatement, resultSet);
}
return totalCount;
}
这段代码是一个实现了接口 IUserDao 的类 UserDaoImpl，用于执行针对用户信息的数据库操作。下面是对代码的详细解释：
-
UserDaoImpl类实现了IUserDao接口，其中selectTotalCount方法用于查询符合条件的用户记录总数。该方法接受一个UserQuery对象作为参数，用于指定查询条件。 -
在方法中，首先初始化了
Connection、PreparedStatement和ResultSet对象，并初始化了一个整型变量totalCount用于存储查询结果的总数。 -
通过
JDBCUtil.getConnection()方法获取数据库连接，该方法返回一个数据库连接对象Connection。 -
构建 SQL 查询语句，初始语句为
"select count(*) from user where 1=1 "，然后根据UserQuery对象中的条件构造动态 SQL 语句，例如根据用户名进行模糊查询。 -
将动态生成的 SQL 语句中的查询条件使用
PreparedStatement对象的setObject方法设置，防止 SQL 注入。 -
执行 SQL 查询语句并将结果存储在
ResultSet对象中，然后通过循环从结果集中获取查询到的总记录数。 -
最后，在
SQLException异常处理块中，打印异常堆栈信息。然后使用JDBCUtil.close方法关闭数据库连接、PreparedStatement和ResultSet对象，释放数据库资源。 -
最后返回查询到的总记录数
totalCount。
总的来说，这段代码用于执行数据库查询操作，根据给定的条件查询符合条件的用户记录总数，并且使用了 PreparedStatement 对象来防止 SQL 注入攻击。同时在异常处理中关闭了数据库连接，确保资源得到正确释放。
1.1.5 deleteById
@Override
public int deleteById(int id) {
Connection connection = null;
PreparedStatement preparedStatement = null;
int count = 0;
try {
connection = JDBCUtil.getConnection();
String sql = "delete from user where id=?";
preparedStatement = connection.prepareStatement(sql);
preparedStatement.setInt(1, id);
//System.out.println(preparedStatement);
count = preparedStatement.executeUpdate();
} catch (SQLException throwables) {
throwables.printStackTrace();
}finally {
JDBCUtil.close(connection, preparedStatement, null);
}
return count;
}
这段代码是一个名为 UserDaoImpl 的类，实现了 IUserDao 接口。该类包含了一个名为 deleteById 的方法，用于从数据库中根据给定的 id 删除相应的用户记录。下面是对代码的详细解释：
-
public class UserDaoImpl implements IUserDao：这是一个类的声明，它实现了IUserDao接口。 -
@Override：这个注解表示该方法是对接口中方法的重写。 -
public int deleteById(int id)：这是一个公共方法，它接收一个整型参数 id，并返回一个整数值。 -
Connection connection = null;：在方法开始处声明了一个用于数据库连接的Connection对象，并将其初始化为null。 -
PreparedStatement preparedStatement = null;：声明了一个用于执行预编译 SQL 语句的PreparedStatement对象，并将其初始化为null。 -
int count = 0;：声明一个整数变量count，用于存储执行 SQL 语句后受影响的行数。 -
在
try块中，通过JDBCUtil.getConnection()方法获取数据库连接对象，并使用 SQL 语句delete from user where id=?创建一个预编译的 SQL 语句。 -
通过
preparedStatement.setInt(1, id)方法将传入的id参数绑定到 SQL 语句中的占位符。 -
count = preparedStatement.executeUpdate();：执行 SQL 语句并将受影响的行数赋值给count变量。 -
在
catch块中，打印 SQL 异常的堆栈信息。 -
在
finally块中，使用JDBCUtil.close()方法关闭数据库连接、预编译语句和结果集对象，以释放资源并避免内存泄漏。 -
最后，方法返回受影响的行数
count。
总的来说，这段代码实现了根据用户 id 从数据库中删除相应用户记录的功能，并通过预编译 SQL 语句和 JDBC 工具类来实现数据库操作，同时确保数据库资源的正确关闭和释放。
1.1.6 updateStatus
@Override
public int updateStatus(int id, int status) {
Connection connection = null;
PreparedStatement preparedStatement = null;
int count = 0;
try {
connection = JDBCUtil.getConnection();
String sql = "update user set status=? where id=?";
preparedStatement = connection.prepareStatement(sql);
preparedStatement.setInt(1, status);
preparedStatement.setInt(2, id);
//System.out.println(preparedStatement);
count = preparedStatement.executeUpdate();
} catch (SQLException throwables) {
throwables.printStackTrace();
}finally {
JDBCUtil.close(connection, preparedStatement, null);
}
return count;
}
这段代码是一个 Java 类 UserDaoImpl，实现了接口 IUserDao 中的 updateStatus 方法。该方法用于更新数据库中的用户状态。
下面是代码的详细解释：
-
UserDaoImpl类实现了IUserDao接口，该接口可能定义了一系列对用户数据进行操作的方法，其中之一是updateStatus方法。 -
updateStatus方法的作用是更新数据库中用户的状态。它接受两个参数id和status，分别代表用户的ID和新的状态值。 -
在方法内部，首先声明了一个
Connection类型的变量connection和一个PreparedStatement类型的变量preparedStatement，用于执行 SQL 查询。 -
通过
JDBCUtil.getConnection()方法获取数据库连接。 -
构造 SQL 更新语句，将用户的状态更新为指定的
status，使用id作为更新的条件。 -
将 SQL 语句预编译并设置参数。
-
调用
executeUpdate()方法执行更新操作，并将更新影响的行数存储在count变量中。 -
在
try-catch块中捕获可能抛出的SQLException异常，并通过throwables.printStackTrace()打印异常信息。 -
使用
JDBCUtil.close()方法关闭数据库连接，以避免资源泄露。 -
最后，返回更新的行数
count，表示更新操作的结果。
总的来说，这段代码的功能是通过 JDBC 技术与数据库进行交互，实现了根据给定的用户ID更新用户状态的功能。同时，在方法内部处理了可能出现的 SQL 异常，并在方法执行完成后关闭了数据库连接，保证了数据库资源的正确释放。
1.1.7 changePassword
@Override
public int changePassword(int userId, String oldPassword, String newPassword) {
Connection connection = null;
PreparedStatement preparedStatement = null;
int count = 0;
try {
connection = JDBCUtil.getConnection();
String sql = "update user set password=? where id=? and password=?";
preparedStatement = connection.prepareStatement(sql);
preparedStatement.setString(1, newPassword);
preparedStatement.setInt(2, userId);
preparedStatement.setString(3, oldPassword);
//System.out.println(preparedStatement);
count = preparedStatement.executeUpdate();
} catch (SQLException throwables) {
throwables.printStackTrace();
}finally {
JDBCUtil.close(connection, preparedStatement, null);
}
return count;
}
这段代码是一个用于修改用户密码的方法实现，实现了 IUserDao 接口中的 changePassword 方法。下面是对代码的详细解释：
-
public class UserDaoImpl implements IUserDao：这表示这是一个实现了IUserDao接口的类，它包含了接口中定义的方法changePassword的具体实现。 -
changePassword方法用于修改用户的密码。它接受三个参数：userId表示要修改密码的用户的ID，oldPassword表示旧密码，newPassword表示新密码。 -
在方法中首先创建了数据库连接
Connection，并初始化了一个PreparedStatement对象用于执行 SQL 查询。 -
SQL 查询语句为
update user set password=? where id=? and password=?，表示更新用户表中的密码，条件是用户ID必须匹配给定的userId，并且旧密码必须匹配给定的oldPassword。 -
通过调用
preparedStatement.setString和preparedStatement.setInt方法，将newPassword和userId分别设置到 SQL 查询语句中。 -
然后调用
preparedStatement.executeUpdate执行更新操作，该操作会返回一个表示更新行数的整数值，将这个值赋给count变量。 -
如果在执行 SQL 查询的过程中发生了异常，异常信息将会被打印出来。
-
最后，在
finally块中调用了JDBCUtil类的close方法，用于关闭数据库连接和相关资源，确保数据库连接被正确关闭，从而避免资源泄漏。 -
最后，方法返回更新的行数
count，表示成功更新的记录数。
总的来说，这段代码是一个简单的用于修改用户密码的数据库操作实现。它使用了 JDBC 技术来与数据库进行交互，保证了数据库连接的正确关闭，并且处理了可能发生的异常情况。
1.2 StuDorDaoImpl
1.2.1 add
@Override
public int add(StuDor stuDor) {
Connection connection = null;
PreparedStatement preparedStatement = null;
int count=0;
try {
connection = JDBCUtil.getConnection();
String sql = "insert into stu_dor(stuid,dorid) values (?,?)";
preparedStatement = connection.prepareStatement(sql);
preparedStatement.setInt(1, stuDor.getStuId());
preparedStatement.setInt(2, stuDor.getDorId());
//System.out.println(preparedStatement);
count = preparedStatement.executeUpdate();
} catch (SQLException throwables) {
throwables.printStackTrace();
} finally {
JDBCUtil.close(connection, preparedStatement, null);
}
return count;
}
这段代码看起来是一个名为 StuDorDaoImpl 的类，实现了 IStuDorDao 接口，并提供了对数据库操作的具体实现。下面是对代码的详细解释：
-
StuDorDaoImpl类实现了IStuDorDao接口，该接口可能定义了一些数据库操作的抽象方法，比如add方法，用于向数据库中添加学生宿舍信息。 -
add方法首先创建了一个数据库连接对象connection，并将其初始化为null。 -
然后创建了一个预编译语句对象
preparedStatement，也初始化为null。 -
在
try块中，代码获取了一个数据库连接对象，并根据传入的stuDor对象的信息，构建了一个 SQL 插入语句，插入到名为stu_dor的表中。 -
使用
preparedStatement.setInt方法设置了 SQL 语句中的占位符的值，这里是将stuDor对象中的stuId和dorId分别作为两个参数传入。 -
调用
preparedStatement.executeUpdate()方法执行 SQL 语句，并将执行的结果赋值给count变量。 -
在
catch块中，代码打印了可能出现的异常堆栈信息。 -
finally块中调用了JDBCUtil类中的close方法，用于关闭数据库连接、预编译语句对象和结果集对象，以确保数据库资源被正确释放。 -
add方法最终返回插入操作影响的行数count，这样调用该方法的代码就能知道插入操作是否成功以及影响的行数。
总体来说，这段代码用于将传入的 StuDor 对象表示的学生宿舍信息插入到数据库表中，并通过异常处理和资源释放操作确保了数据库连接的安全关闭。
1.2.2 delete
@Override
public int delete(StuDor stuDor) {
Connection connection = null;
PreparedStatement preparedStatement = null;
int count=0;
try {
connection = JDBCUtil.getConnection();
String sql = "DELETE FROM stu_dor WHERE stuid=?;";
preparedStatement = connection.prepareStatement(sql);
preparedStatement.setInt(1, stuDor.getStuId());
//System.out.println(preparedStatement);
count = preparedStatement.executeUpdate();
} catch (SQLException throwables) {
throwables.printStackTrace();
} finally {
JDBCUtil.close(connection, preparedStatement, null);
}
return count;
}
这段代码是一个名为 StuDorDaoImpl 的 Java 类，实现了 IStuDorDao 接口。它包含了一个名为 delete 的方法，用于从数据库中删除与给定 StuDor 对象相关联的记录。
下面是对代码功能的详细解释：
-
delete方法声明了一个StuDor类型的参数stuDor，用于指定要删除的记录。 -
在方法内部，首先创建了一个
Connection对象connection和一个PreparedStatement对象preparedStatement，用于执行 SQL 语句。 -
通过调用
JDBCUtil.getConnection()方法获取数据库连接，建立与数据库的连接。 -
使用预编译的 SQL 语句 “DELETE FROM stu_dor WHERE stuid=?”，其中
stuid是数据库表stu_dor中的一个列。 -
通过调用
preparedStatement.setInt(1, stuDor.getStuId())方法将stuDor对象中的学生 ID 设置为 SQL 语句中的参数。 -
执行 SQL 语句并将返回的受影响行数存储在
count变量中。 -
在发生异常的情况下，将打印堆栈跟踪并继续执行。
-
最后，通过调用
JDBCUtil.close(connection, preparedStatement, null)方法关闭数据库连接，释放资源。 -
返回删除的记录数，即删除操作影响的行数。
总体而言，这段代码的作用是删除数据库中 stu_dor 表中与给定 StuDor 对象关联的记录，并通过返回受影响的行数来指示删除操作的结果。同时，代码还考虑了异常情况并在完成操作后关闭了数据库连接，以确保资源得到释放。
1.2.3 change
@Override
public int change(StuDor stuDor) {
Connection connection = null;
PreparedStatement preparedStatement = null;
int count=0;
try {
connection = JDBCUtil.getConnection();
String sql = "UPDATE stu_dor SET dorid = ? WHERE stuid=?;";
preparedStatement = connection.prepareStatement(sql);
preparedStatement.setInt(1, stuDor.getDorId());
preparedStatement.setInt(2, stuDor.getStuId());
//System.out.println(preparedStatement);
count = preparedStatement.executeUpdate();
} catch (SQLException throwables) {
throwables.printStackTrace();
} finally {
JDBCUtil.close(connection, preparedStatement, null);
}
return count;
}
这段代码是一个实现了 IStuDorDao 接口的 StuDorDaoImpl 类，用于执行对数据库中 stu_dor 表的更新操作。下面是对代码的详细解释：
-
StuDorDaoImpl类实现了IStuDorDao接口，因此必须实现接口中定义的所有方法，其中这里实现了change方法。 -
change方法接受一个StuDor类型的参数stuDor，该对象包含了要更新的学生宿舍信息。 -
在方法中首先声明了一个
Connection类型的变量connection和一个PreparedStatement类型的变量preparedStatement，以及一个int类型的变量count用于存储更新的行数。 -
在
try块中，代码通过JDBCUtil.getConnection()方法获取数据库连接对象connection，然后准备 SQL 语句，使用connection.prepareStatement(sql)方法创建一个PreparedStatement对象。 -
SQL 语句是一个更新语句，用于将
stu_dor表中与给定stuId对应的学生的宿舍 ID 更新为dorId。具体的 SQL 语句是"UPDATE stu_dor SET dorid = ? WHERE stuid=?;"。 -
使用
preparedStatement.setInt(1, stuDor.getDorId())和preparedStatement.setInt(2, stuDor.getStuId())将 SQL 语句中的参数赋值，保证 SQL 语句的安全性和准确性。 -
执行更新操作，并将受影响的行数存储在
count变量中，使用count = preparedStatement.executeUpdate()实现更新操作并获取更新的行数。 -
如果在执行过程中发生了
SQLException，则会打印异常信息。 -
最后，在
finally块中，使用JDBCUtil.close(connection, preparedStatement, null)关闭连接和释放资源，以确保数据库资源的正确释放。 -
方法返回更新的行数
count，以便调用者了解更新操作的结果。
1.3 StudentDaoImpl
1.3.1 queryGender
@Override
public int[] queryGender() {
Connection connection = null;
PreparedStatement preparedStatement = null;
ResultSet resultSet = null;
int[] num = new int [2];
try {
connection = JDBCUtil.getConnection();
String sql = "select sum(case when gender = '男' then 1 else 0 end) man ," +
"sum(case when gender = '女' then 1 else 0 end) woman " +
"from student";
preparedStatement = connection.prepareStatement(sql);
resultSet = preparedStatement.executeQuery();
while (resultSet.next()) {//判断下一个有没有，如果返回true而且指向下一个，没有返回false
int man = resultSet.getInt("man");
num[0]=man;
int woman= resultSet.getInt("woman");
num[1]=woman;
}
} catch (SQLException throwables) {
throwables.printStackTrace();
} finally {
JDBCUtil.close(connection, preparedStatement, resultSet);
}
return num;
}
这段代码是一个实现了 IStudentDao 接口的 StudentDaoImpl 类，它的主要作用是从数据库中查询学生表中不同性别学生的人数，并以整数数组的形式返回男性和女性学生的数量。以下是对代码的详细解释：
-
queryGender方法是一个公共方法，它重写了IStudentDao接口中定义的queryGender方法。 -
在方法内部，首先创建了一个
Connection对象connection，一个PreparedStatement对象preparedStatement和一个ResultSet对象resultSet，它们用于执行 SQL 查询并获取查询结果。 -
代码中创建了一个大小为 2 的整数数组
num，用于存储查询结果。数组的第一个元素存储男性学生的数量，第二个元素存储女性学生的数量。 -
使用
JDBCUtil工具类获取数据库连接connection。 -
构建了一个 SQL 查询语句，该查询语句使用了 SQL 中的
case when语句来统计学生表中男性和女性学生的数量。 -
通过
connection.prepareStatement(sql)创建一个预编译的 SQL 语句对象preparedStatement，并使用preparedStatement.executeQuery()方法执行查询，将结果存储在resultSet中。 -
在
resultSet中使用while循环遍历查询结果。对于每一行结果，从结果集中获取男性学生的数量和女性学生的数量，并分别存储到num数组的对应位置。 -
在发生 SQL 异常时，使用
throwables.printStackTrace()打印异常堆栈信息。 -
无论是否发生异常，最终都会调用
JDBCUtil工具类的close方法关闭数据库连接、预编译语句和结果集，以释放资源和避免内存泄漏。 -
最后，将存储了学生数量信息的整数数组
num返回。
总体来说，这段代码实现了一个查询数据库中学生表中男女学生数量的方法，并通过数组返回结果。其中使用了 JDBC 进行数据库连接和操作，并且使用了 SQL 的聚合函数和条件判断来实现统计功能。
1.3.2 selectByPage
@Override
public List<Student> selectByPage(StudentQuery studentQuery) {
int offset = (studentQuery.getPage() - 1) * studentQuery.getLimit();
Connection connection = null;
PreparedStatement preparedStatement = null;
ResultSet resultSet = null;
List<Student> list = new ArrayList<>();
try {
connection = JDBCUtil.getConnection();
String sql = "SELECT * FROM student where 1=1 ";
//这里面放所有搜索条件
List<Object> queryList = new ArrayList<>();
String queryName = studentQuery.getName();
if (queryName != null && !"".equals(queryName)) {
sql += " and name like ? ";
queryList.add("%"+queryName+"%");
}
String queryGender = studentQuery.getGender();
if (queryGender != null && !"".equals(queryGender)) {
sql += " and gender like ? ";
queryList.add("%"+queryGender+"%");
}
String queryMajor = studentQuery.getMajor();
if (queryMajor != null && !"".equals(queryMajor)) {
sql += " and major like ? ";
queryList.add("%"+queryMajor+"%");
}
String queryClass_ = studentQuery.getClass_();
if (queryClass_ != null && !"".equals(queryClass_)) {
sql += " and class like ? ";
queryList.add("%"+queryClass_+"%");
}
sql += " limit ?,?";
preparedStatement = connection.prepareStatement(sql);
for (int i = 0; i < queryList.size(); i++) {
preparedStatement.setObject(i + 1, queryList.get(i));
}
preparedStatement.setInt(queryList.size() + 1, offset);
preparedStatement.setInt(queryList.size() + 2, studentQuery.getLimit());
System.out.println("Prepared statement: " + preparedStatement.toString());
//System.out.println(preparedStatement);
resultSet = preparedStatement.executeQuery();
while (resultSet.next()) {//判断下一个有没有，如果返回true而且指向下一个，没有返回false
int id = resultSet.getInt("id");
String name = resultSet.getString("name");
Integer age = resultSet.getInt("age");
String major = resultSet.getString("major");
String class_ = resultSet.getString("class");
String phone = resultSet.getString("phone");
String gender = resultSet.getString("gender");
Student student = new Student(id, name, age,major,class_,phone,gender);
list.add(student);
}
} catch (SQLException throwables) {
throwables.printStackTrace();
} finally {
JDBCUtil.close(connection, preparedStatement, resultSet);
}
System.out.println("SQL："+preparedStatement);
return list;
}
这段代码是一个实现了IStudentDao接口的具体类StudentDaoImpl，主要用于根据分页查询条件从数据库中获取学生信息列表。以下是对代码的详细解释：
-
selectByPage方法用于按照分页条件从数据库中查询学生信息。在方法中首先计算偏移量offset，通过page和limit属性计算。 -
代码首先获取数据库连接对象
connection，并创建PreparedStatement和ResultSet对象。同时创建了一个空的学生信息列表list用于存储查询到的学生信息。 -
动态生成 SQL 查询语句，通过判断传入的
StudentQuery对象中的搜索条件，如果条件不为空，就将对应的条件拼接到 SQL 语句中，同时将条件值添加到queryList中，这是为了后续设置PreparedStatement参数时使用。 -
将分页查询条件加入到 SQL 语句中，并通过
prepareStatement对象的setObject方法设置动态生成 SQL 语句中的占位符的值。 -
执行 SQL 查询，通过
executeQuery方法执行查询操作，将结果存储在resultSet对象中。 -
通过遍历
resultSet对象，将每一条查询结果封装为Student对象，并将其添加到list列表中。 -
最后，无论是否出现异常，都会执行关闭数据库连接的操作，释放资源，并返回查询到的学生信息列表。
-
在代码末尾，打印出完整的 SQL 语句，以便调试和检查生成的 SQL 是否正确。这可以帮助调试可能出现的 SQL 查询问题。
1.3.3 selectTotalCount
@Override
public Integer selectTotalCount(StudentQuery studentQuery) {
Connection connection = null;
PreparedStatement preparedStatement = null;
ResultSet resultSet = null;
int totalCount = 0;
try {
connection = JDBCUtil.getConnection();
String sql = "select count(*) from student where 1=1 ";
List<Object> queryList = new ArrayList<>();
String queryName = studentQuery.getName();
if (queryName != null && !"".equals(queryName)) {
sql += " and name like ? ";
queryList.add("%"+queryName+"%");
}
String queryGender = studentQuery.getGender();
if (queryGender != null && !"".equals(queryGender)) {
sql += " and gender like? ";
queryList.add("%"+queryGender+"%");
}
String queryMajor = studentQuery.getMajor();
if (queryMajor != null && !"".equals(queryMajor)) {
sql += " and major like ? ";
queryList.add("%"+queryMajor+"%");
}
String queryClass_ = studentQuery.getClass_();
if (queryClass_ != null && !"".equals(queryClass_)) {
sql += " and class like ? ";
queryList.add("%"+queryClass_+"%");
}
preparedStatement = connection.prepareStatement(sql);
for (int i = 0; i < queryList.size(); i++) {
preparedStatement.setObject(i + 1, queryList.get(i));
}
//System.out.println(preparedStatement);
resultSet = preparedStatement.executeQuery();
while (resultSet.next()) {
totalCount = resultSet.getInt(1);
}
} catch (SQLException throwables) {
throwables.printStackTrace();
}finally {
JDBCUtil.close(connection, preparedStatement, resultSet);
}
return totalCount;
}
这段代码是一个实现了接口 IStudentDao 的类 StudentDaoImpl，用于执行针对学生信息表的查询操作，其中包括根据给定的查询条件获取学生总数。下面是对代码的详细解释：
-
selectTotalCount方法用于查询符合特定条件的学生总数。它接受一个StudentQuery对象作为参数，该对象包含了用于筛选学生的查询条件。 -
在方法中，首先创建了数据库连接对象
connection，预编译语句对象preparedStatement以及结果集对象resultSet。然后初始化了变量totalCount用于存储查询到的学生总数。 -
通过
JDBCUtil.getConnection()方法获取数据库连接。 -
构建 SQL 查询语句，基础语句为 "select count(*) from student where 1=1 "，然后根据传入的查询条件逐步添加对应的查询约束。每个非空的查询条件都会添加相应的 SQL 语句片段，并将查询参数添加到列表
queryList中。 -
创建预编译语句对象
preparedStatement，并通过循环将查询参数设置到对应的占位符上。 -
执行查询操作，将结果存储在结果集对象
resultSet中。在此例中，通过resultSet.getInt(1)获取了查询到的总数并赋值给totalCount。 -
在异常处理块中打印堆栈跟踪信息。
-
最后，在
finally块中使用JDBCUtil.close()方法关闭数据库连接，释放相关资源。 -
返回查询得到的学生总数。
总体而言，这段代码实现了一个根据指定查询条件统计学生总数的方法。它使用了 JDBC 进行数据库操作，通过预编译语句防止 SQL 注入，最后确保在方法执行结束后关闭了数据库连接以释放资源。
1.3.4 deleteById
@Override
public int deleteById(int id) {
Connection connection = null;
PreparedStatement preparedStatement = null;
int count = 0;
try {
connection = JDBCUtil.getConnection();
String sql = "delete from student where id=?";
preparedStatement = connection.prepareStatement(sql);
preparedStatement.setInt(1, id);
//System.out.println(preparedStatement);
count = preparedStatement.executeUpdate();
} catch (SQLException throwables) {
throwables.printStackTrace();
}finally {
JDBCUtil.close(connection, preparedStatement, null);
}
return count;
}
这段代码是一个 Java 类 StudentDaoImpl，实现了接口 IStudentDao 中的 deleteById 方法。下面是对代码的详细解释：
-
public class StudentDaoImpl implements IStudentDao：这表示StudentDaoImpl类实现了接口IStudentDao，并且需要实现接口中的方法。 -
deleteById方法是一个公共方法，用于根据给定的学生 id 从数据库中删除相应的学生记录。 -
首先，定义了一个
Connection类型的变量connection和一个PreparedStatement类型的变量preparedStatement，以及一个整型变量count，用于存储删除操作影响的行数。 -
在
try块中，首先通过JDBCUtil.getConnection()方法获取数据库连接。然后，使用 SQL 语句delete from student where id=?创建一个PreparedStatement对象，并将要删除的学生的 id 设置到 SQL 语句中的占位符位置。 -
执行
preparedStatement.executeUpdate()方法来执行 SQL 删除操作，并将受影响的行数存储在count变量中。 -
如果在执行过程中出现了
SQLException异常，throwables.printStackTrace()将打印异常堆栈信息。 -
不论是否出现异常，最终都会执行
JDBCUtil.close(connection, preparedStatement, null)方法来关闭数据库连接以释放资源。 -
最后，
deleteById方法返回删除操作影响的行数count。
总的来说，这段代码实现了通过给定的学生 id 从数据库中删除学生记录的功能。在执行数据库操作的过程中，通过 JDBCUtil 类来获取数据库连接，并确保在操作完成后关闭连接以释放资源。
1.3.5 add
@Override
public int add(Student student) {
Connection connection = null;
PreparedStatement preparedStatement = null;
int count = 0;
try {
connection = JDBCUtil.getConnection();
String sql = "insert into student(name,age,major,class,phone,gender) values(?,?,?,?,?,?)";
preparedStatement = connection.prepareStatement(sql);
preparedStatement.setString(1, student.getName());
preparedStatement.setInt(2, student.getAge());
preparedStatement.setString(3, student.getMajor());
preparedStatement.setString(4, student.getClass_());
preparedStatement.setString(5, student.getPhone());
preparedStatement.setString(6, student.getGender());
//System.out.println(preparedStatement);
count = preparedStatement.executeUpdate();
} catch (SQLException throwables) {
throwables.printStackTrace();
}finally {
JDBCUtil.close(connection, preparedStatement, null);
}
return count;
}
这段代码是一个实现了 IStudentDao 接口的 StudentDaoImpl 类，用于向数据库中的 student 表中添加学生信息。下面是对代码的详细解释：
-
add方法是IStudentDao接口中定义的方法的具体实现。它的作用是向数据库中的student表中插入新的学生信息，并返回插入的记录数。 -
首先，该方法通过
JDBCUtil.getConnection()获取数据库连接对象connection，并将其赋值为null。然后创建了一个PreparedStatement对象preparedStatement，并同样将其赋值为null。声明了一个count变量来保存插入记录的数量。 -
在
try块中，使用预定义的 SQL 语句向数据库中插入学生信息。SQL 语句为insert into student(name,age,major,class,phone,gender) values(?,?,?,?,?,?)，其中?是占位符。 -
通过
preparedStatement.setXXX()方法为每个占位符设置具体的值，其中setString和setInt方法用于设置字符串和整型参数的值，参数依次对应于student对象的各个属性。 -
preparedStatement.executeUpdate()方法用于执行更新操作，并将执行结果保存在count变量中。 -
在
catch块中，如果出现SQLException异常，则会打印异常堆栈信息。 -
最后，在
finally块中调用JDBCUtil.close()方法关闭数据库连接和相关资源，以释放数据库资源并避免内存泄漏。 -
count变量最终作为方法的返回值，表示向数据库中插入记录的数量。
这段代码是一个简单的使用 JDBC 向数据库中插入数据的示例。它执行了插入操作，并确保在操作完成后关闭了数据库连接和相关资源。
1.3.6 selectById
@Override
public Student selectById(int id) {
Connection connection = null;
PreparedStatement preparedStatement = null;
ResultSet resultSet = null;
Student student = null;
try {
connection = JDBCUtil.getConnection();
String sql = "SELECT * FROM student where id=?";
preparedStatement = connection.prepareStatement(sql);
preparedStatement.setInt(1, id);
//System.out.println(preparedStatement);
resultSet = preparedStatement.executeQuery();
while (resultSet.next()) {//判断下一个有没有，如果返回true而且指向下一个，没有返回false
String name = resultSet.getString("name");
Integer age = resultSet.getInt("age");
String major = resultSet.getString("major");
String class_ = resultSet.getString("class");
String phone = resultSet.getString("phone");
String gender = resultSet.getString("gender");
student = new Student(id, name, age,major,class_,phone,gender);
}
} catch (SQLException throwables) {
throwables.printStackTrace();
} finally {
JDBCUtil.close(connection, preparedStatement, resultSet);
}
return student;
}
这段代码是一个实现了接口 IStudentDao 的 StudentDaoImpl 类，用于从数据库中根据学生的 id 查询学生信息。下面是对代码的详细解释：
-
首先，代码中使用了 JDBC（Java 数据库连接）来与数据库交互，执行查询操作。
-
selectById方法是根据学生的id查询学生信息的方法，它接受一个整数参数id作为输入。 -
代码中首先初始化了一些必要的变量，包括
Connection对象connection、PreparedStatement对象preparedStatement、ResultSet对象resultSet和Student对象student。初始化为null是为了确保在后续的代码中能够正确地处理异常情况。 -
通过
JDBCUtil.getConnection()方法获取数据库连接connection。 -
构建 SQL 查询语句
sql，该语句根据传入的id查询数据库中student表中对应的记录。 -
使用预处理语句
preparedStatement来预编译 SQL 查询语句，将id参数设置到 SQL 查询语句中。 -
执行 SQL 查询语句，并通过
executeQuery方法获取查询结果集resultSet。 -
使用
while循环遍历结果集resultSet，从中提取学生信息的各个字段，包括name、age、major、class_、phone和gender。 -
根据提取的信息创建一个新的
Student对象，并将其赋值给student变量。 -
在异常处理块中，打印出现的异常堆栈信息。
-
最后，通过
JDBCUtil.close方法关闭数据库连接、预处理语句和结果集，释放相关资源。 -
最终，方法返回获取的学生信息
student。
请注意，该代码片段中可能存在一些潜在的问题，比如异常处理方式可能不够严谨，没有使用日志记录来记录异常等。同时，该代码也没有考虑到 SQL 注入等安全性问题。
1.3.7 update
@Override
public int update(Student student) {
Connection connection = null;
PreparedStatement preparedStatement = null;
int count = 0;
try {
connection = JDBCUtil.getConnection();
String sql = "update student set name=?,age=?,major=?,class=?,phone=?,gender=? where id=?";
preparedStatement = connection.prepareStatement(sql);
preparedStatement.setString(1, student.getName());
preparedStatement.setInt(2, student.getAge());
preparedStatement.setString(3, student.getMajor());
preparedStatement.setString(4, student.getClass_());
preparedStatement.setString(5, student.getPhone());
preparedStatement.setString(6, student.getGender());
preparedStatement.setInt(7, student.getId());
//System.out.println(preparedStatement);
count = preparedStatement.executeUpdate();
} catch (SQLException throwables) {
throwables.printStackTrace();
}finally {
JDBCUtil.close(connection, preparedStatement, null);
}
return count;
}
这段代码是一个 Java 类 StudentDaoImpl，实现了接口 IStudentDao 中的 update 方法。这个方法的作用是用给定的 Student 对象更新数据库中对应的记录。下面是代码的详细解释：
-
首先，代码创建了一个
connection对象和一个preparedStatement对象，并初始化了一个整型变量count用于记录更新的行数。 -
在
try块中，通过JDBCUtil.getConnection()方法获取数据库连接对象，并使用prepareStatement方法创建一个 SQL 查询语句的预编译对象。 -
SQL 语句是一个更新语句，用于将给定的
student对象的属性更新到数据库中的对应记录。在 SQL 语句中，?是占位符，表示将在之后通过set方法设置具体的值。 -
通过
preparedStatement.set方法为 SQL 语句中的占位符设置具体的值，这些值来自于给定的student对象的属性。 -
执行 SQL 更新语句并将更新的行数赋值给
count变量。 -
在
catch块中，打印throwables异常的堆栈信息。 -
在
finally块中，调用JDBCUtil.close方法关闭数据库连接、预编译语句等资源，以确保资源得到正确释放，避免资源泄露。 -
最后，方法返回更新的行数
count。
综上所述，这段代码实现了一个更新数据库中 student 表记录的方法，用于将给定 Student 对象的属性更新到数据库中对应的记录中。
1.3.8 selectHasCheckIn
@Override
public List<Student> selectHasCheckIn(StudentQuery studentQuery) {
int offset = (studentQuery.getPage() - 1) * studentQuery.getLimit();
Connection connection = null;
PreparedStatement preparedStatement = null;
ResultSet resultSet = null;
List<Student> list=new ArrayList<>();
try {
connection = JDBCUtil.getConnection();
String sql = "SELECT * FROM view_stu_dor_building where 1=1 ";
List<Object> queryList = new ArrayList<>();
String queryName = studentQuery.getName();
if (queryName != null && !"".equals(queryName)) {
sql += " and name like ? ";
queryList.add("%"+queryName+"%");
}
String queryGender = studentQuery.getGender();
if (queryGender != null && !"".equals(queryGender)) {
sql += " and gender like ? ";
queryList.add("%"+queryGender+"%");
}
String queryMajor = studentQuery.getMajor();
if (queryMajor != null && !"".equals(queryMajor)) {
sql += " and major like ? ";
queryList.add("%"+queryMajor+"%");
}
String queryClass_ = studentQuery.getClass_();
if (queryClass_ != null && !"".equals(queryClass_)) {
sql += " and class like ? ";
queryList.add("%"+queryClass_+"%");
}
Integer dormitoryId = studentQuery.getDormitoryId();
if (dormitoryId != null && !dormitoryId.equals(0)) {
sql += " and dor_id = ? ";
queryList.add(dormitoryId);
}
sql += "and dor_id is not null limit ?,?";
preparedStatement = connection.prepareStatement(sql);
for (int i = 0; i < queryList.size(); i++) {
preparedStatement.setObject(i + 1, queryList.get(i));
}
preparedStatement.setInt(queryList.size() + 1, offset);
preparedStatement.setInt(queryList.size() + 2, studentQuery.getLimit());
//System.out.println(preparedStatement);
resultSet = preparedStatement.executeQuery();
while (resultSet.next()) {
Integer id=resultSet.getInt("id");
String name = resultSet.getString("name");
Integer age = resultSet.getInt("age");
String major = resultSet.getString("major");
String class_ = resultSet.getString("class");
String phone = resultSet.getString("phone");
Integer dorId = resultSet.getInt("dor_id");
String dorTag = resultSet.getString("dor_tag");
Integer buildingId = resultSet.getInt("building_id");
String buildingTag = resultSet.getString("building_tag");
String gender = resultSet.getString("gender");
Student student = new Student(id, name, age,major,class_,phone,gender,dorId,dorTag,buildingId,buildingTag);
list.add(student);
}
} catch (SQLException throwables) {
throwables.printStackTrace();
} finally {
JDBCUtil.close(connection, preparedStatement, resultSet);
}
return list;
}
这段代码是一个Java类，名为StudentDaoImpl，实现了IStudentDao接口，其中selectHasCheckIn方法用于从数据库中查询已入住学生的信息列表。下面是代码的详细解释：
-
方法
selectHasCheckIn中首先计算偏移量(offset)。它是根据传入的StudentQuery对象中的页数和限制数计算得出，用于实现分页功能。 -
接着创建了数据库连接(
Connection)，预编译语句(PreparedStatement)以及结果集(ResultSet)对象，并初始化了一个空的List用于存储查询到的学生信息。 -
代码通过使用
JDBCUtil.getConnection()方法获取数据库连接，然后构建 SQL 查询语句，并根据StudentQuery对象中的不同属性构建不同的查询条件。 -
通过添加
queryList列表来动态构建 SQL 查询语句中的条件部分，利用预编译语句的参数设置对应的值，从而避免 SQL 注入问题。 -
为 SQL 语句设置了分页参数，以便实现分页查询功能。
-
执行 SQL 查询并将结果存储在结果集中，随后通过循环遍历结果集，并从每一行中提取出学生对象的各个属性，并使用这些属性构建
Student对象。 -
将构建的
Student对象添加到之前创建的List中。 -
最后，在
finally块中关闭数据库连接以释放资源，防止数据库连接泄漏。 -
最终，返回包含查询到的学生信息的
List列表。
总的来说，这段代码实现了一个根据传入的 StudentQuery 对象中的条件进行动态查询，并将查询结果封装到 Student 对象中的功能。同时，它通过使用预编译语句和合理的资源释放策略来确保数据库操作的安全性和高效性。
1.3.9 selectNotCheckIn
@Override
public List<Student> selectNotCheckIn(StudentQuery studentQuery) {
int offset = (studentQuery.getPage() - 1) * studentQuery.getLimit();
Connection connection = null;
PreparedStatement preparedStatement = null;
ResultSet resultSet = null;
List<Student> list=new ArrayList<>();
try {
connection = JDBCUtil.getConnection();
String sql = "SELECT * FROM view_stu_dor_building where 1=1 ";
List<Object> queryList = new ArrayList<>();
String queryName = studentQuery.getName();
if (queryName != null && !"".equals(queryName)) {
sql += " and name like ? ";
queryList.add("%"+queryName+"%");
}
String queryGender = studentQuery.getGender();
if (queryGender != null && !"".equals(queryGender)) {
sql += " and gender like ? ";
queryList.add("%"+queryGender+"%");
}
String queryMajor = studentQuery.getMajor();
if (queryMajor != null && !"".equals(queryMajor)) {
sql += " and major like ? ";
queryList.add("%"+queryMajor+"%");
}
String queryClass_ = studentQuery.getClass_();
if (queryClass_ != null && !"".equals(queryClass_)) {
sql += " and class like ? ";
queryList.add("%"+queryClass_+"%");
}
sql += "and dor_id is null limit ?,?";
preparedStatement = connection.prepareStatement(sql);
for (int i = 0; i < queryList.size(); i++) {
preparedStatement.setObject(i + 1, queryList.get(i));
}
preparedStatement.setInt(queryList.size() + 1, offset);
preparedStatement.setInt(queryList.size() + 2, studentQuery.getLimit());
//System.out.println(preparedStatement);
resultSet = preparedStatement.executeQuery();
while (resultSet.next()) {
Integer id=resultSet.getInt("id");
String name = resultSet.getString("name");
Integer age = resultSet.getInt("age");
String major = resultSet.getString("major");
String class_ = resultSet.getString("class");
String phone = resultSet.getString("phone");
String gender = resultSet.getString("gender");
Student student = new Student(id, name, age,major,class_,phone,gender);
list.add(student);
}
} catch (SQLException throwables) {
throwables.printStackTrace();
} finally {
JDBCUtil.close(connection, preparedStatement, resultSet);
}
return list;
}
这段代码是一个 StudentDaoImpl 类的实现，实现了 IStudentDao 接口。以下是对代码的详细解释：
-
selectNotCheckIn方法是用于查询未办理入住手续的学生列表。该方法接受一个StudentQuery对象作为参数，该对象包含了一些查询条件。 -
首先，根据传入的
studentQuery对象中的页面页数和页面显示的数据条数，计算偏移量offset，用于分页查询时使用。 -
代码创建了
Connection、PreparedStatement和ResultSet对象，用于执行数据库查询操作。同时创建了一个空的List<Student>对象，用于存储查询结果。 -
在
try块中，首先通过JDBCUtil.getConnection()方法获取数据库连接对象connection。 -
根据传入的查询条件拼接 SQL 语句，根据
queryName、queryGender、queryMajor和queryClass_的不同情况拼接不同的查询条件，并将参数添加到queryList中。 -
添加额外的条件
and dor_id is null，用于查询未办理入住手续的学生。将查询条件拼接到 SQL 语句中。 -
使用预编译的 SQL 语句创建
PreparedStatement对象，并设置相应的参数值。 -
执行查询操作，并将结果集中的数据逐条取出，创建
Student对象并将其添加到list中。 -
在
catch块中打印异常堆栈信息。 -
在
finally块中，通过JDBCUtil.close()方法关闭数据库连接、PreparedStatement和ResultSet对象，释放数据库资源。 -
最后返回包含查询结果的
list列表。
1.3.10 countHasCheckIn
@Override
public int countHasCheckIn(StudentQuery studentQuery) {
Connection connection = null;
PreparedStatement preparedStatement = null;
ResultSet resultSet = null;
int totalCount = 0;
try {
connection = JDBCUtil.getConnection();
String sql = "SELECT count(*) FROM view_stu_dor_building where 1=1 ";
List<Object> queryList = new ArrayList<>();
String queryName = studentQuery.getName();
if (queryName != null && !"".equals(queryName)) {
sql += " and name like ? ";
queryList.add("%"+queryName+"%");
}
String queryGender = studentQuery.getGender();
if (queryGender != null && !"".equals(queryGender)) {
sql += " and gender like ? ";
queryList.add("%"+queryGender+"%");
}
String queryMajor = studentQuery.getMajor();
if (queryMajor != null && !"".equals(queryMajor)) {
sql += " and major like ? ";
queryList.add("%"+queryMajor+"%");
}
String queryClass_ = studentQuery.getClass_();
if (queryClass_ != null && !"".equals(queryClass_)) {
sql += " and class like ? ";
queryList.add("%"+queryClass_+"%");
}
Integer dormitoryId = studentQuery.getDormitoryId();
if (dormitoryId != null && !dormitoryId.equals(0)) {
sql += " and dor_id = ? ";
queryList.add(dormitoryId);
}
sql += "and dor_id is not null ";
preparedStatement = connection.prepareStatement(sql);
System.out.println(preparedStatement);
for (int i = 0; i < queryList.size(); i++) {
preparedStatement.setObject(i + 1, queryList.get(i));
}
resultSet = preparedStatement.executeQuery();
while (resultSet.next()) {
totalCount = resultSet.getInt(1);
}
} catch (SQLException throwables) {
throwables.printStackTrace();
}finally {
JDBCUtil.close(connection, preparedStatement, resultSet);
}
return totalCount;
}
这段代码是一个Java类，实现了接口IStudentDao中的countHasCheckIn方法。下面是对代码的详细解释：
-
在方法中首先初始化了
Connection、PreparedStatement和ResultSet对象，并初始化了一个整型变量totalCount用于存储统计结果。 -
通过
JDBCUtil.getConnection()获取数据库连接对象Connection。 -
构建SQL查询语句
sql，初始语句为"SELECT count(*) FROM view_stu_dor_building where 1=1 "。其中，view_stu_dor_building是一个视图，可能是一个用于展示学生宿舍信息的视图。 -
通过一个
List集合queryList来存储查询条件的值。 -
针对传入的
studentQuery对象，依次判断其中的各个属性是否存在，若存在则根据属性的值拼接SQL语句，并将对应的查询条件值加入queryList中。 -
执行完所有的查询条件拼接后，通过预编译的方式创建
PreparedStatement对象。 -
使用
preparedStatement.setObject()方法将queryList中的参数值按顺序绑定到SQL语句中的占位符上。 -
通过执行
preparedStatement.executeQuery()方法执行查询，并通过resultSet对象获取结果集。 -
使用
while循环遍历结果集，将查询到的结果赋值给totalCount变量。 -
最后，无论是否发生异常，都会执行
JDBCUtil.close()方法关闭数据库连接，释放资源。 -
返回
totalCount作为该方法的查询结果，即符合查询条件的记录总数。
整体而言，该方法是用于根据传入的查询条件统计符合条件的记录总数，并且利用了预编译的方式防止SQL注入等安全问题，并在最后关闭了数据库连接，防止资源泄漏。
1.3.11 countNotCheckIn
@Override
public int countNotCheckIn(StudentQuery studentQuery) {
Connection connection = null;
PreparedStatement preparedStatement = null;
ResultSet resultSet = null;
int totalCount = 0;
try {
connection = JDBCUtil.getConnection();
String sql = "SELECT count(*) FROM view_stu_dor_building where 1=1 ";
List<Object> queryList = new ArrayList<>();
String queryName = studentQuery.getName();
if (queryName != null && !"".equals(queryName)) {
sql += " and name like ? ";
queryList.add("%"+queryName+"%");
}
String queryGender = studentQuery.getGender();
if (queryGender != null && !"".equals(queryGender)) {
sql += " and gender like ? ";
queryList.add("%"+queryGender+"%");
}
String queryMajor = studentQuery.getMajor();
if (queryMajor != null && !"".equals(queryMajor)) {
sql += " and major like ? ";
queryList.add("%"+queryMajor+"%");
}
String queryClass_ = studentQuery.getClass_();
if (queryClass_ != null && !"".equals(queryClass_)) {
sql += " and class like ? ";
queryList.add("%"+queryClass_+"%");
}
sql += "and dor_id is null ";
preparedStatement = connection.prepareStatement(sql);
System.out.println(preparedStatement);
for (int i = 0; i < queryList.size(); i++) {
preparedStatement.setObject(i + 1, queryList.get(i));
}
resultSet = preparedStatement.executeQuery();
while (resultSet.next()) {
totalCount = resultSet.getInt(1);
}
} catch (SQLException throwables) {
throwables.printStackTrace();
}finally {
JDBCUtil.close(connection, preparedStatement, resultSet);
}
return totalCount;
}
这段代码是一个名为 StudentDaoImpl 的类，实现了接口 IStudentDao 中的 countNotCheckIn 方法。以下是对代码的详细解释：
-
首先创建了数据库连接对象
connection、预编译语句对象preparedStatement和结果集对象resultSet。同时，初始化了变量totalCount用于存储查询到的结果总数。 -
在
try块中，首先获取数据库连接connection，这里使用了名为JDBCUtil的工具类来获取数据库连接。 -
构建 SQL 查询语句
sql，初始语句为 "SELECT count(*) FROM view_stu_dor_building where 1=1 "，通过拼接字符串的方式根据传入的参数构建动态查询语句。 -
根据传入的
studentQuery对象中的不为空的属性值，依次添加查询条件，如果属性值不为空，则在 SQL 语句中添加相应的like条件，并将对应的属性值添加到queryList中。 -
在 SQL 语句的末尾添加了 "and dor_id is null " 条件，用于查询未入住的学生。
-
使用预编译语句对象
preparedStatement执行 SQL 查询语句，并将queryList中的参数设置到相应的占位符上。 -
通过执行查询操作，得到结果集
resultSet，遍历结果集并获取查询到的总数，并将其存储到totalCount变量中。 -
在
catch块中处理可能发生的SQLException异常，打印异常的堆栈信息。 -
最后，在
finally块中关闭数据库连接、预编译语句对象和结果集对象，以确保数据库资源得到释放，避免资源泄露和内存泄露。 -
最后，将查询到的总数
totalCount返回给调用者。
1.4 ManagerDaoImpl
1.4.1 queryGender
@Override
public int[] queryGender() {
Connection connection = null;
PreparedStatement preparedStatement = null;
ResultSet resultSet = null;
int[] num = new int [2];
try {
connection = JDBCUtil.getConnection();
String sql = "select sum(case when gender = '男' then 1 else 0 end) man ," +
"sum(case when gender = '女' then 1 else 0 end) woman " +
"from manager";
preparedStatement = connection.prepareStatement(sql);
resultSet = preparedStatement.executeQuery();
while (resultSet.next()) {//判断下一个有没有，如果返回true而且指向下一个，没有返回false
int man = resultSet.getInt("man");
num[0]=man;
int woman= resultSet.getInt("woman");
num[1]=woman;
}
} catch (SQLException throwables) {
throwables.printStackTrace();
} finally {
JDBCUtil.close(connection, preparedStatement, resultSet);
}
return num;
}
以上代码是一个 Java 类，名为 ManagerDaoImpl，实现了接口 IManagerDao 中的方法 queryGender。下面是对代码的详细解释：
-
queryGender方法用于从数据库中查询管理人员表中的男性和女性的数量，并以整数数组的形式返回这两个数量。 -
首先，代码创建了一个长度为 2 的整型数组
num用于存储男性和女性数量，数组的第一个元素表示男性数量，第二个元素表示女性数量。 -
代码使用 JDBC 连接数据库，并执行 SQL 查询语句。查询语句使用了 SQL 的
case when语句来统计满足条件的男性和女性的数量，并将结果命名为man和woman。 -
执行查询后，代码通过
resultSet.next()方法遍历查询结果集。在循环中，代码获取了man和woman的值，并将其分别赋值给num数组的第一个和第二个元素。 -
最后，无论是否发生异常，代码都会调用
JDBCUtil类中的close方法来关闭数据库连接、预编译语句和结果集，以释放资源。 -
如果发生异常，代码会打印异常堆栈信息，以便进行调试和错误处理。
-
最后，代码返回整型数组
num，其中包含了查询得到的男性和女性数量。
总的来说，该代码通过 JDBC 连接数据库并执行 SQL 查询语句，从数据库中获取了男性和女性的数量，并以整数数组的形式返回这些数量。
1.4.2 selectByPage
@Override
public List<Manager> selectByPage(ManagerQuery managerQuery) {
int offset = (managerQuery.getPage() - 1) * managerQuery.getLimit();
Connection connection = null;
PreparedStatement preparedStatement = null;
ResultSet resultSet = null;
List<Manager> list = new ArrayList<>();
try {
connection = JDBCUtil.getConnection();
String sql = "SELECT * FROM manager where 1=1 ";
//这里面放所有搜索条件
List<Object> queryList = new ArrayList<>();
String queryName = managerQuery.getName();
if (queryName != null && !"".equals(queryName)) {
sql += " and name like ? ";
queryList.add("%"+queryName+"%");
}
String queryGender = managerQuery.getGender();
if (queryGender != null && !"".equals(queryGender)) {
sql += " and gender like ? ";
queryList.add("%"+queryGender+"%");
}
sql += " limit ?,?";
preparedStatement = connection.prepareStatement(sql);
for (int i = 0; i < queryList.size(); i++) {
preparedStatement.setObject(i + 1, queryList.get(i));
}
preparedStatement.setInt(queryList.size() + 1, offset);
preparedStatement.setInt(queryList.size() + 2, managerQuery.getLimit());
//System.out.println(preparedStatement);
resultSet = preparedStatement.executeQuery();
while (resultSet.next()) {//判断下一个有没有，如果返回true而且指向下一个，没有返回false
int id = resultSet.getInt("id");
String name = resultSet.getString("name");
String gender = resultSet.getString("gender");
String image=resultSet.getString("image");
Manager manager = new Manager(id, name,gender,image);
list.add(manager);
}
} catch (SQLException throwables) {
throwables.printStackTrace();
} finally {
JDBCUtil.close(connection, preparedStatement, resultSet);
}
return list;
}
这段代码是一个实现了 IManagerDao 接口的 ManagerDaoImpl 类，用于执行分页查询操作并返回符合条件的 Manager 对象列表。
-
selectByPage方法根据传入的ManagerQuery对象执行查询操作，并返回满足条件的Manager对象列表。 -
offset变量用于计算分页查询的偏移量，确保每次查询返回正确的数据页。 -
通过
JDBCUtil工具类获取数据库连接对象connection，并根据查询条件拼接 SQL 语句，其中queryList用于存储查询条件的值。 -
queryName和queryGender分别表示要查询的名称和性别，并将它们加入到queryList中。 -
在 SQL 语句中使用
like关键字进行模糊查询，并通过queryList中的参数替换占位符。 -
通过
connection.prepareStatement(sql)创建preparedStatement对象，并将queryList中的参数设置到preparedStatement对象中。 -
通过
preparedStatement.setInt方法将偏移量和每页显示数量设置到preparedStatement对象中。 -
使用
preparedStatement.executeQuery()执行 SQL 查询语句，并将返回的结果集存储在resultSet对象中。 -
通过
resultSet.next()方法遍历结果集，提取每一行的数据，创建对应的Manager对象，并将其添加到list集合中。 -
最后，在
finally块中调用JDBCUtil.close()方法关闭数据库连接、预编译语句和结果集，以确保资源被正确释放。
总体来说，这段代码的作用是根据传入的 ManagerQuery 对象中的查询条件，在数据库中执行分页查询，并将查询结果封装为 Manager 对象的列表返回。同时，代码中确保了数据库连接、预编译语句和结果集的正确关闭，以避免资源泄漏问题。
1.4.3 selectTotalCount
@Override
public Integer selectTotalCount(ManagerQuery managerQuery) {
Connection connection = null;
PreparedStatement preparedStatement = null;
ResultSet resultSet = null;
int totalCount = 0;
try {
connection = JDBCUtil.getConnection();
String sql = "select count(*) from manager where 1=1 ";
List<Object> queryList = new ArrayList<>();
String queryName = managerQuery.getName();
if (queryName != null && !"".equals(queryName)) {
sql += " and name like ? ";
queryList.add("%"+queryName+"%");
}
String queryGender = managerQuery.getGender();
if (queryGender != null && !"".equals(queryGender)) {
sql += " and gender like? ";
queryList.add("%"+queryGender+"%");
}
preparedStatement = connection.prepareStatement(sql);
for (int i = 0; i < queryList.size(); i++) {
preparedStatement.setObject(i + 1, queryList.get(i));
}
//System.out.println(preparedStatement);
resultSet = preparedStatement.executeQuery();
while (resultSet.next()) {
totalCount = resultSet.getInt(1);
}
} catch (SQLException throwables) {
throwables.printStackTrace();
}finally {
JDBCUtil.close(connection, preparedStatement, resultSet);
}
return totalCount;
}
这段代码是一个Java类 ManagerDaoImpl 的实现，实现了接口 IManagerDao 中的方法 selectTotalCount。下面是代码的详细解释：
-
ManagerDaoImpl类实现了接口IManagerDao，该接口可能包含了一系列与管理人员相关的数据库操作方法。 -
selectTotalCount方法用于从数据库中查询符合条件的管理人员总数，并返回一个整数值作为结果。 -
方法中首先初始化了数据库连接
connection，PreparedStatement对象preparedStatement以及结果集resultSet。 -
通过调用
JDBCUtil.getConnection()方法获取数据库连接。 -
构建 SQL 查询语句，初始的查询语句为 "select count(*) from manager where 1=1 "，其中 “1=1” 是一个占位符，方便后续动态拼接查询条件。
-
根据传入的
ManagerQuery对象中的条件，动态拼接 SQL 语句中的查询条件。在这段代码中，根据name和gender来动态生成查询条件，并将查询所需的参数添加到queryList列表中。 -
通过
connection.prepareStatement(sql)创建PreparedStatement对象，并将动态生成的 SQL 语句作为参数传入。 -
针对
queryList中的参数列表，通过循环使用preparedStatement.setObject(i + 1, queryList.get(i))方法设置对应的参数。 -
执行查询操作，并通过
resultSet.getInt(1)获取查询结果中的总记录数，并将其赋值给totalCount变量。 -
在异常处理块中，捕获可能的
SQLException异常，并打印其堆栈信息。 -
最后通过
JDBCUtil.close(connection, preparedStatement, resultSet)方法关闭数据库连接、释放资源。 -
方法返回获取的总记录数
totalCount。
这段代码的功能是根据传入的查询条件动态生成 SQL 语句，查询数据库中满足条件的管理人员的总数。
1.4.4 deleteById
@Override
public int deleteById(int id) {
Connection connection = null;
PreparedStatement preparedStatement = null;
int count = 0;
try {
connection = JDBCUtil.getConnection();
String sql = "delete from manager where id=?";
preparedStatement = connection.prepareStatement(sql);
preparedStatement.setInt(1, id);
//System.out.println(preparedStatement);
count = preparedStatement.executeUpdate();
} catch (SQLException throwables) {
throwables.printStackTrace();
}finally {
JDBCUtil.close(connection, preparedStatement, null);
}
return count;
}
这段代码是一个 Java 类 ManagerDaoImpl 的实现，实现了 IManagerDao 接口。下面是对代码的详细解释：
-
ManagerDaoImpl类实现了IManagerDao接口，其中覆盖了deleteById方法，该方法用于从数据库中根据给定的 ID 删除manager表中的记录。 -
在方法中首先初始化了连接对象
connection和预编译语句对象preparedStatement，并初始化变量count为 0，用于记录执行 SQL 语句后受影响的行数。 -
通过调用
JDBCUtil.getConnection()方法获取数据库连接对象connection。 -
构建 SQL 语句
delete from manager where id=?，并将其预编译到preparedStatement对象中。 -
通过调用
preparedStatement.setInt(1, id)方法设置 SQL 语句中的参数，即要删除的记录的 ID。 -
调用
preparedStatement.executeUpdate()方法执行 SQL 删除语句，并将执行影响的行数赋值给count变量。 -
在
try块外，使用finally块确保无论是否发生异常，都会关闭数据库连接、预编译语句对象以及结果集对象，以避免数据库资源泄露。 -
如果发生
SQLException异常，会将异常信息打印到标准错误流。 -
最后，方法返回执行 SQL 语句后受影响的行数
count。
总体来说，这段代码实现了通过给定的 ID 从数据库中删除 manager 表中记录的功能。它利用 JDBC 连接和预编译语句执行 SQL 删除操作，并在最后关闭数据库连接以释放资源。
1.4.5 add
@Override
public int add(Manager manager) {
Connection connection = null;
PreparedStatement preparedStatement = null;
int count = 0;
try {
connection = JDBCUtil.getConnection();
String sql = "insert into manager(name,gender,image) values(?,?,?)";
preparedStatement = connection.prepareStatement(sql);
preparedStatement.setString(1, manager.getName());
preparedStatement.setString(2, manager.getGender());
preparedStatement.setString(3, manager.getImage());
//System.out.println(preparedStatement);
count = preparedStatement.executeUpdate();
} catch (SQLException throwables) {
throwables.printStackTrace();
}finally {
JDBCUtil.close(connection, preparedStatement, null);
}
return count;
}
以上代码是一个 Java 类 ManagerDaoImpl，实现了接口 IManagerDao 中声明的方法 add。下面是对代码的详细解释：
-
ManagerDaoImpl类实现了IManagerDao接口，该接口可能声明了一些用于管理操作的方法，其中之一是add方法。 -
add方法用于向数据库中的manager表中添加一条记录。它接受一个Manager对象作为参数，其中包含了待插入记录的相关信息。 -
在方法中首先初始化了一个数据库连接对象
connection和一个预编译语句对象preparedStatement，并将执行插入操作后的受影响行数存储在count变量中。 -
通过
JDBCUtil.getConnection()方法获取数据库连接。 -
构建 SQL 语句，预编译 SQL 语句，并通过
preparedStatement对象设置相应的参数。 -
执行 SQL 插入语句，将数据插入到数据库表中，并将受影响的行数存储在
count变量中。 -
在出现异常时，使用
throwables.printStackTrace()打印异常堆栈信息。 -
无论是否出现异常，最终都会执行
JDBCUtil.close方法关闭数据库连接和预编译语句对象，确保资源被正确释放。 -
最后，方法返回插入的记录数。
总的来说，以上代码实现了将一个 Manager 对象的信息插入到数据库的 manager 表中的操作。在这个过程中，通过使用预编译语句对象可以有效地防止 SQL 注入攻击，并且在数据库操作完成后，使用了适当的资源释放机制，避免了数据库连接的泄漏。
1.4.6 selectById
@Override
public Manager selectById(int id) {
Connection connection = null;
PreparedStatement preparedStatement = null;
ResultSet resultSet = null;
Manager manager = null;
try {
connection = JDBCUtil.getConnection();
String sql = "SELECT * FROM manager where id=?";
preparedStatement = connection.prepareStatement(sql);
preparedStatement.setInt(1, id);
//System.out.println(preparedStatement);
resultSet = preparedStatement.executeQuery();
while (resultSet.next()) {//判断下一个有没有，如果返回true而且指向下一个，没有返回false
String name = resultSet.getString("name");
String gender = resultSet.getString("gender");
String image=resultSet.getString("image");
manager = new Manager(id, name,gender,image);
}
} catch (SQLException throwables) {
throwables.printStackTrace();
} finally {
JDBCUtil.close(connection, preparedStatement, resultSet);
}
return manager;
}
这段代码是一个 Java 类，实现了 IManagerDao 接口中的 selectById 方法。该方法的作用是通过给定的 ID 从数据库中查询并返回对应的 Manager 对象。下面是对代码的详细解释：
-
在方法中首先声明了一些必要的变量，包括
Connection、PreparedStatement、ResultSet和Manager对象，用于执行数据库查询并存储结果。 -
通过调用
JDBCUtil.getConnection()方法获取数据库连接对象connection，用于后续的数据库操作。 -
使用预编译的 SQL 查询语句，通过
PreparedStatement对象执行 SQL 查询操作。在这个例子中，使用了带有占位符的 SQL 语句 “SELECT * FROM manager where id=?”，并通过preparedStatement.setInt(1, id)设置占位符的值为给定的 ID。 -
通过执行
preparedStatement.executeQuery()方法执行查询操作，并将查询结果存储在ResultSet对象resultSet中。 -
在
while (resultSet.next())循环中，遍历查询结果集，提取每一行中的数据。通过调用resultSet.getString("columnName")方法获取对应列的值，并将这些值用于构造一个Manager对象。在这个例子中，Manager对象的属性包括 ID、姓名 (name)、性别 (gender) 和图片 (image)。 -
在
SQLException异常捕获块中处理可能出现的数据库操作异常，并打印异常堆栈信息。 -
最后，在
finally块中调用JDBCUtil.close()方法，释放数据库资源，包括关闭数据库连接 (connection)、关闭预编译语句 (preparedStatement) 和关闭结果集 (resultSet)。 -
返回查询到的
Manager对象，或者如果查询未能成功执行，则返回null值。
总的来说，这段代码是一个简单的数据库操作，用于根据给定的 ID 查询数据库中的管理员信息，并将查询结果封装成 Manager 对象返回。同时，代码也确保了数据库资源得到适当的释放和关闭，以防止资源泄露和不必要的开销。
1.4.7 update
@Override
public int update(Manager manager) {
Connection connection = null;
PreparedStatement preparedStatement = null;
int count = 0;
try {
connection = JDBCUtil.getConnection();
String sql = "update manager set name=?,gender=?,image=? where id=?";
preparedStatement = connection.prepareStatement(sql);
preparedStatement.setString(1, manager.getName());
preparedStatement.setString(2, manager.getGender());
preparedStatement.setString(3, manager.getImage());
preparedStatement.setInt(4, manager.getId());
//System.out.println(preparedStatement);
count = preparedStatement.executeUpdate();
} catch (SQLException throwables) {
throwables.printStackTrace();
}finally {
JDBCUtil.close(connection, preparedStatement, null);
}
return count;
}
这段代码是一个Java类 ManagerDaoImpl，它实现了接口 IManagerDao，并提供了对数据库中manager表的更新操作。下面是对代码的详细解释：
-
public class ManagerDaoImpl implements IManagerDao：这行代码定义了一个类ManagerDaoImpl，该类实现了接口IManagerDao，表明它包含了实现接口中声明的方法。 -
@Override：这个注解表示这个方法是重写自父类或接口的方法。 -
public int update(Manager manager)：这是一个公共方法，它接收一个Manager类型的参数manager，用于更新数据库中的manager表的记录。 -
在方法体中：
- 首先声明了
Connection和PreparedStatement对象，用于与数据库建立连接并执行 SQL 语句。 - 通过
JDBCUtil.getConnection()方法获取数据库连接。 - 然后构建了 SQL 更新语句，其中使用了占位符
?，以便动态地设置 SQL 语句中的参数。 - 通过
preparedStatement对象的setString和setInt方法，将Manager对象的属性设置到 SQL 语句中对应的位置。 - 执行 SQL 更新操作，并将结果存储在
count变量中。 - 在捕获到
SQLException异常时，通过throwables.printStackTrace()输出异常信息。
-
finally块中使用了JDBCUtil.close方法关闭数据库连接、释放资源，以避免数据库连接的泄漏。 -
最后，方法返回更新操作所影响的行数
count。
总的来说，这段代码实现了对数据库中 manager 表的更新操作，通过传入一个 Manager 对象来更新表中的记录。
1.4.8 selectAll
@Override
public List<Manager> selectAll() {
Connection connection = null;
PreparedStatement preparedStatement = null;
ResultSet resultSet = null;
List<Manager> list = new ArrayList<>();
try {
connection = JDBCUtil.getConnection();
String sql = "SELECT * FROM manager where 1=1 ";
preparedStatement = connection.prepareStatement(sql);
// System.out.println(preparedStatement);
resultSet = preparedStatement.executeQuery();
while (resultSet.next()) {//判断下一个有没有，如果返回true而且指向下一个，没有返回false
int id = resultSet.getInt("id");
String name = resultSet.getString("name");
String gender = resultSet.getString("gender");
Manager manager = new Manager(id, name,gender);
list.add(manager);
}
} catch (SQLException throwables) {
throwables.printStackTrace();
} finally {
JDBCUtil.close(connection, preparedStatement, resultSet);
}
return list;
}
这段代码是一个 Java 类 ManagerDaoImpl，实现了接口 IManagerDao 中的 selectAll 方法。下面是对代码的详细解释：
-
在
selectAll方法中，首先初始化了一个Connection对象connection，一个PreparedStatement对象preparedStatement，一个ResultSet对象resultSet，以及一个空的List<Manager>对象list用于存储查询结果。 -
然后通过
JDBCUtil.getConnection()方法获取数据库连接对象connection，该方法应该是一个自定义的方法用于建立数据库连接。 -
定义 SQL 查询语句
"SELECT * FROM manager where 1=1 "，其中1=1是一个占位条件，可能是为了方便后续根据实际需要动态拼接 SQL 语句。 -
通过
connection.prepareStatement(sql)方法创建一个预编译的 Statement 对象preparedStatement，并将 SQL 查询语句传入。 -
执行 SQL 查询，并通过
resultSet = preparedStatement.executeQuery()执行查询操作，将查询结果保存在resultSet对象中。 -
使用
while (resultSet.next())循环遍历resultSet中的每一行数据，通过resultSet.getInt("id")、resultSet.getString("name")和resultSet.getString("gender")方法分别获取 “id”、“name” 和 “gender” 字段的值，然后创建一个Manager对象，并将其添加到list中。 -
在捕获到 SQL 异常时，通过
throwables.printStackTrace()方法打印异常的堆栈信息。 -
最后，通过
JDBCUtil.close(connection, preparedStatement, resultSet)方法关闭数据库连接、Statement 对象和结果集对象，以释放资源。 -
最终，将存储了查询结果的
list返回。
总的来说，这段代码实现了一个从数据库中查询所有 manager 数据的方法，并将查询结果封装成 Manager 对象的列表返回。同时，在合适的时候关闭了数据库连接和相关资源，以避免资源泄漏。
1.5 INoticeDaoImpl
1.5.1 add
@Override
public int add(Notice notice) {
Connection connection = null;
PreparedStatement preparedStatement = null;
int count = 0;
try {
connection = JDBCUtil.getConnection();
String sql = "insert into notice(n_notice,n_time,n_issuer,n_state) values(?,?,?,?)";
preparedStatement = connection.prepareStatement(sql);
preparedStatement.setString(1, notice.getN_notice());
preparedStatement.setString(2, notice.getN_time());
preparedStatement.setString(3, notice.getN_issuer());
preparedStatement.setString(4, notice.getN_state());
//System.out.println(preparedStatement);
count = preparedStatement.executeUpdate();
} catch (SQLException throwables) {
throwables.printStackTrace();
}finally {
JDBCUtil.close(connection, preparedStatement, null);
}
return count;
}
上面的代码是一个 Java 类 INoticeDaoImpl，实现了 INoticeDao 接口。它包含一个 add 方法，用于向数据库中的 notice 表中添加公告信息。
下面是对代码的详细解释：
-
INoticeDaoImpl类实现了INoticeDao接口，该接口可能定义了一些操作数据库的通用方法。 -
add方法用于向数据库的notice表中插入新的公告信息。该方法接受一个Notice对象作为参数。 -
在方法内部，首先创建了一个数据库连接
connection和一个预编译语句preparedStatement。 -
使用
JDBCUtil.getConnection()方法获取数据库连接对象。 -
创建 SQL 插入语句，插入公告的内容、时间、发布者和状态等信息到
notice表中。使用预编译语句对象preparedStatement将参数绑定到 SQL 语句中。 -
执行 SQL 语句并获取执行结果，
executeUpdate()方法返回一个表示受影响行数的整数。 -
在
catch块中捕获可能抛出的SQLException异常，并打印异常的堆栈跟踪。 -
最后，在
finally块中，通过JDBCUtil.close()方法关闭数据库连接，释放资源。 -
count是executeUpdate()方法的返回值，表示插入操作影响的行数。
总体来说，这段代码是一个简单的数据库操作代码，用于将传入的公告信息对象插入到数据库中的 notice 表中。在操作数据库时，它使用了预编译语句以及连接对象，并且在适当的时候关闭了数据库连接，以确保资源得到正确释放。
1.5.2 deleteById
@Override
public int deleteById(int n_id) {
Connection connection = null;
PreparedStatement preparedStatement = null;
int count = 0;
try {
connection = JDBCUtil.getConnection();
String sql = "delete from notice where n_id=?";
preparedStatement = connection.prepareStatement(sql);
preparedStatement.setInt(1, n_id);
//System.out.println(preparedStatement);
count = preparedStatement.executeUpdate();
} catch (SQLException throwables) {
throwables.printStackTrace();
}finally {
JDBCUtil.close(connection, preparedStatement, null);
}
return count;
}
这段代码是一个名为 INoticeDaoImpl 的类，实现了接口 INoticeDao。以下是对代码的详细解释：
-
INoticeDaoImpl类是一个数据访问对象（DAO）的实现类，用于对数据库中的notice表进行操作。 -
deleteById方法是在INoticeDao接口中声明的方法，用于根据给定的n_id（公告ID）从数据库中删除对应的记录。 -
方法中首先声明了一个
Connection对象和一个PreparedStatement对象，用于执行 SQL 查询。然后声明了一个整型变量count用于记录删除操作所影响的行数。 -
在
try块中，代码首先通过JDBCUtil.getConnection()方法获取数据库连接。 -
然后构造 SQL 删除语句，使用占位符
?来表示待填充的参数。 -
通过
preparedStatement.setInt(1, n_id)将n_id的值赋给 SQL 语句中的第一个占位符。 -
执行 SQL 删除语句，并将返回的受影响行数赋值给
count。 -
在
catch块中，捕获可能出现的SQLException异常，并打印异常信息。 -
最后在
finally块中调用JDBCUtil.close()方法关闭数据库连接、释放相关资源，确保数据库资源被正确释放。 -
最后返回
count，即删除操作影响的行数。
该代码主要实现了根据公告ID删除数据库中相应记录的功能，并使用了 JDBC 工具类中提供的方法来获取数据库连接以及关闭资源，以确保数据库连接的正确管理和释放。
1.5.3 loginNotice
@Override
public List<Notice> loginNotice(String n_state) {
Connection connection = null;
PreparedStatement preparedStatement = null;
ResultSet resultSet = null;
List<Notice> notice=new ArrayList<>();
try {
connection = JDBCUtil.getConnection();
String sql = "SELECT * FROM notice where n_state=?";
preparedStatement = connection.prepareStatement(sql);
preparedStatement.setString(1, n_state);
System.out.println("==========>SQL语句："+preparedStatement);
resultSet = preparedStatement.executeQuery();
while (resultSet.next()) {//判断下一个有没有，如果返回true而且指向下一个，没有返回false
Notice item = new Notice();
item.setN_id(resultSet.getInt("n_id"));
item.setN_notice(resultSet.getString("n_notice"));
item.setN_time(resultSet.getString("n_time"));
item.setN_issuer(resultSet.getString("n_issuer"));
item.setN_state(resultSet.getString("n_state"));
notice.add(item);
}
} catch (SQLException throwables) {
throwables.printStackTrace();
} finally {
JDBCUtil.close(connection, preparedStatement, resultSet);
}
System.out.println("===========>返回结果："+notice);
return notice;
}
这段代码是一个 Java 类，实现了 INoticeDao 接口，并重写了其中的 loginNotice 方法。以下是对代码功能的详细解释：
-
INoticeDaoImpl类是一个 DAO（数据访问对象）实现类，用于操作数据库中的notice表。 -
loginNotice方法接受一个n_state参数，并根据该参数从数据库中获取符合条件的通知（Notice）列表。 -
在方法中首先初始化了数据库连接对象
connection，预编译语句对象preparedStatement和结果集对象resultSet。然后创建了一个空的notice列表，用于存储查询结果。 -
通过 JDBCUtil 类获取数据库连接对象
connection。 -
生成 SQL 查询语句，使用占位符
?来代替参数，预防 SQL 注入攻击。SQL 查询语句为 “SELECT * FROM notice where n_state=?”。 -
通过调用
preparedStatement.setString(1, n_state)方法将n_state参数的值设置到 SQL 查询语句中。 -
执行 SQL 查询语句并将结果保存在
resultSet中。 -
使用
resultSet.next()判断结果集中是否还有下一条记录，如果有，将记录的各个字段取出并设置到一个Notice对象中，然后将该对象添加到notice列表中。 -
在
catch块中打印 SQL 异常的堆栈信息。 -
最后通过
JDBCUtil.close方法关闭数据库连接、预编译语句和结果集，释放数据库资源。 -
最后打印了获取的
notice列表，并将其作为方法的返回值返回。
总的来说，这段代码通过 JDBC 技术连接数据库，根据传入的 n_state 参数执行 SQL 查询语句，并将查询结果封装成 Notice 对象的列表返回。同时，通过合理的资源释放确保了数据库资源的正常释放，防止了数据库连接的泄露。
1.5.4 selectById
@Override
public Notice selectById(int n_id) {
Connection connection = null;
PreparedStatement preparedStatement = null;
ResultSet resultSet = null;
Notice notice = null;
try {
connection = JDBCUtil.getConnection();
String sql = "SELECT * FROM notice where n_id=?";
preparedStatement = connection.prepareStatement(sql);
preparedStatement.setInt(1, n_id);
//System.out.println(preparedStatement);
resultSet = preparedStatement.executeQuery();
while (resultSet.next()) {//判断下一个有没有，如果返回true而且指向下一个，没有返回false
String n_notice = resultSet.getString("n_notice");
String n_time = resultSet.getString("n_time");
String n_issuer = resultSet.getString("n_issuer");
String n_state = resultSet.getString("n_state");
notice = new Notice(n_notice,n_time,n_issuer,n_state);
}
} catch (SQLException throwables) {
throwables.printStackTrace();
} finally {
JDBCUtil.close(connection, preparedStatement, resultSet);
}
return notice;
}
这段代码是一个 Java 类的实现，它实现了一个接口 INoticeDao 的方法 selectById(int n_id)，该方法用于从数据库中查询公告（Notice）的信息，并根据提供的公告 ID（n_id）返回一个 Notice 对象。
以下是对代码的详细解释：
-
INoticeDaoImpl类实现了INoticeDao接口，这意味着它必须提供接口中定义的所有方法，包括selectById(int n_id)。 -
在方法中，首先声明了一些变量，用于处理数据库连接和结果集：
Connection connection用于建立与数据库的连接。PreparedStatement preparedStatement用于执行 SQL 查询语句。ResultSet resultSet用于存储查询结果。Notice notice用于存储查询得到的公告对象。
-
在
try块中，代码首先获取数据库连接，这是通过调用JDBCUtil.getConnection()来完成的。 -
接下来，构建 SQL 查询语句，使用预处理语句
PreparedStatement来防止 SQL 注入攻击。SQL 查询语句中使用了一个占位符?，并通过preparedStatement.setInt(1, n_id)设置了该占位符的值为提供的n_id参数值。 -
执行 SQL 查询语句，将查询结果存储在
resultSet中。在这里，使用executeQuery()方法执行查询。 -
使用
while (resultSet.next())循环来遍历查询结果集。这个循环用于处理可能的多个结果行，尽管在这个例子中，通常只会有一个结果。每次迭代，代码从结果集中提取公告的相关信息，如标题n_notice、时间n_time、发布者n_issuer和状态n_state。 -
使用提取的信息创建一个
Notice对象，并将其赋值给notice变量。在循环结束后，notice变量将包含最后一个查询结果行的公告信息。 -
在
catch块中，如果在执行数据库操作时发生了异常（如 SQL 异常），则通过throwables.printStackTrace()打印异常信息。 -
最后，在
finally块中，使用JDBCUtil.close(connection, preparedStatement, resultSet)来确保关闭数据库连接、预处理语句和结果集，以释放资源并防止资源泄漏。 -
最后，方法返回
notice对象，该对象包含了从数据库中检索到的公告信息。
总的来说，这段代码的主要功能是查询数据库中指定 ID 的公告信息，并将其封装为一个 Notice 对象返回给调用者。
1.5.5 updateStatus
@Override
public int updateStatus(int n_id, String n_state) {
Connection connection = null;
PreparedStatement preparedStatement = null;
int count = 0;
try {
connection = JDBCUtil.getConnection();
String sql = "update notice set n_state=? where n_id=?";
preparedStatement = connection.prepareStatement(sql);
preparedStatement.setString(1, n_state);
preparedStatement.setInt(2, n_id);
//System.out.println(preparedStatement);
count = preparedStatement.executeUpdate();
} catch (SQLException throwables) {
throwables.printStackTrace();
}finally {
JDBCUtil.close(connection, preparedStatement, null);
}
return count;
}
这段代码是一个 Java 类，它实现了 INoticeDao 接口，并提供了针对通知（notice）表的更新状态功能。下面是对代码的详细解释：
-
public class INoticeDaoImpl implements INoticeDao：这表明这是一个实现了INoticeDao接口的类，该类提供了通知数据访问对象的实现。 -
@Override：这个注解表示该方法重写了父类或接口的方法，这里重写了INoticeDao接口中的updateStatus方法。 -
public int updateStatus(int n_id, String n_state)：这是一个公共方法，它接受通知 ID（n_id）和通知状态（n_state）作为参数，返回一个整型值作为操作影响的行数。 -
在方法体内部，首先创建了一个
Connection对象connection和一个PreparedStatement对象preparedStatement，并初始化一个整型变量count用于计数更新的行数。 -
然后，代码尝试通过
JDBCUtil.getConnection()获取数据库连接。 -
接着，通过 SQL 语句
"update notice set n_state=? where n_id=?"创建一个PreparedStatement对象，并将n_state和n_id分别设置到 SQL 语句中对应的占位符位置。 -
执行 SQL 更新操作并将更新的行数保存在
count变量中。 -
在
try块的末尾，通过JDBCUtil.close(connection, preparedStatement, null)关闭数据库连接、释放资源。 -
如果在执行 SQL 更新操作的过程中出现了异常，将打印异常堆栈信息。这样可以确保及时发现并处理数据库操作可能出现的异常情况。
-
最后，返回更新的行数
count。
总的来说，这段代码实现了一个更新通知表中通知状态的功能，通过 SQL 更新语句将指定 n_id 的通知的状态更新为指定的 n_state 值，并返回更新的行数。同时，代码通过 JDBCUtil 工具类获取数据库连接并在操作完成后关闭连接，确保数据库资源的正确释放。
1.5.6 update
@Override
public int update(Notice notice) {
Connection connection = null;
PreparedStatement preparedStatement = null;
int count = 0;
try {
connection = JDBCUtil.getConnection();
String sql = "update notice set n_notice=?,n_time=?,n_issuer=?,n_state=? where n_id=?";
preparedStatement = connection.prepareStatement(sql);
preparedStatement.setString(1, notice.getN_notice());
preparedStatement.setString(2, notice.getN_time());
preparedStatement.setString(3, notice.getN_issuer());
preparedStatement.setString(4, notice.getN_state());
preparedStatement.setInt(5, notice.getN_id());
//System.out.println(preparedStatement);
count = preparedStatement.executeUpdate();
} catch (SQLException throwables) {
throwables.printStackTrace();
}finally {
JDBCUtil.close(connection, preparedStatement, null);
}
return count;
}
以上代码是一个实现了INoticeDao接口的INoticeDaoImpl类，用于更新数据库中的通知信息。下面是对代码的详细解释：
-
INoticeDaoImpl类实现了INoticeDao接口，这意味着它必须提供接口中声明的所有方法的具体实现。 -
update方法用于更新数据库中的通知信息。它接受一个Notice对象作为参数，该对象包含了要更新的通知的相关信息。 -
在方法内部，首先创建了一个
Connection对象和一个PreparedStatement对象，并初始化count为 0，用于计算更新的行数。 -
JDBCUtil.getConnection()方法用于获取数据库连接，该方法可能是一个工具类的静态方法，用于管理数据库连接。 -
接下来，使用预编译的 SQL 语句来更新通知信息，SQL 语句为：
"update notice set n_notice=?,n_time=?,n_issuer=?,n_state=? where n_id=?"。通过preparedStatement对象的setString和setInt方法设置 SQL 语句中的参数，以便将Notice对象的属性值传递给 SQL 语句。 -
count = preparedStatement.executeUpdate()用于执行 SQL 更新操作，并将更新的行数赋值给count变量。 -
如果在执行过程中出现了
SQLException异常，异常将被打印出来。 -
最后，在
finally块中调用JDBCUtil.close方法关闭数据库连接、释放资源，以避免数据库连接泄露。 -
count最终作为方法的返回值，表示更新的行数。
综上所述，该类的作用是实现了更新通知信息的功能，将传入的 Notice 对象的属性值更新到数据库中对应的记录中。
1.5.7 selectByPage
@Override
public List<Notice> selectByPage(NoticeQuery noticeQuery) {
int offset = (noticeQuery.getPage() - 1) * noticeQuery.getLimit();
Connection connection = null;
PreparedStatement preparedStatement = null;
ResultSet resultSet = null;
List<Notice> list = new ArrayList<>();
try {
connection = JDBCUtil.getConnection();
String sql = "SELECT * FROM notice where 1=1 ";
//这里面放所有搜索条件
List<Object> queryList = new ArrayList<>();
String queryName = noticeQuery.getN_notice();
if (queryName != null && !"".equals(queryName)) {
sql += " and n_notice like ? ";
queryList.add("%"+queryName+"%");
}
sql += " limit ?,?";
preparedStatement = connection.prepareStatement(sql);
for (int i = 0; i < queryList.size(); i++) {
preparedStatement.setObject(i + 1, queryList.get(i));
}
preparedStatement.setInt(queryList.size() + 1, offset);
preparedStatement.setInt(queryList.size() + 2, noticeQuery.getLimit());
System.out.println("Prepared statement: " + preparedStatement.toString());
//System.out.println(preparedStatement);
resultSet = preparedStatement.executeQuery();
while (resultSet.next()) {//判断下一个有没有，如果返回true而且指向下一个，没有返回false
Notice item = new Notice();
item.setN_id(resultSet.getInt("n_id"));
item.setN_notice(resultSet.getString("n_notice"));
item.setN_time(resultSet.getString("n_time"));
item.setN_issuer(resultSet.getString("n_issuer"));
item.setN_state(resultSet.getString("n_state"));
list.add(item);
}
} catch (SQLException throwables) {
throwables.printStackTrace();
} finally {
JDBCUtil.close(connection, preparedStatement, resultSet);
}
System.out.println("SQL："+preparedStatement);
return list;
}
这段代码是一个Java类 INoticeDaoImpl，它实现了接口 INoticeDao 中的 selectByPage 方法。以下是对代码的详细解释：
-
该方法的主要功能是根据传入的
NoticeQuery对象进行分页查询，查询结果以List<Notice>的形式返回。 -
首先，根据传入的
noticeQuery对象中的页数和每页的条目限制计算偏移量offset，以确定查询的起始位置。 -
代码通过 JDBCUtil 获取数据库连接对象
connection，并初始化预编译语句对象preparedStatement和结果集对象resultSet。 -
构建 SQL 查询语句，初始语句为 "SELECT * FROM notice where 1=1 "，后续根据传入的查询条件动态拼接不同的查询语句。
-
如果
noticeQuery中的n_notice不为空，则将 “n_notice” 字段添加为查询条件，使用 LIKE 运算符进行模糊查询。此处使用了预编译语句并通过设置占位符的方式避免了 SQL 注入问题。 -
将查询的结果限制在指定的范围内，使用 “limit” 子句来限制查询结果的数量，其中起始位置为
offset，数量为noticeQuery.getLimit()。 -
通过执行预编译语句
preparedStatement执行查询操作，将结果存储在resultSet中。 -
遍历结果集，将每行的数据封装成
Notice对象，并将其添加到list集合中。 -
在方法末尾，通过调用
JDBCUtil.close方法关闭连接、预编译语句和结果集，以确保资源得到释放，避免资源泄漏。 -
最后，该方法返回包含查询结果的
List<Notice>对象。
总的来说，这段代码实现了基于传入条件的分页查询功能，并通过 JDBC 与数据库交互，最终将查询结果封装在一个 List<Notice> 中并返回。同时，通过合理的资源释放，避免了潜在的资源泄漏问题。
1.5.8 selectTotalCount
@Override
public Integer selectTotalCount(NoticeQuery noticeQuery) {
Connection connection = null;
PreparedStatement preparedStatement = null;
ResultSet resultSet = null;
int totalCount = 0;
try {
connection = JDBCUtil.getConnection();
String sql = "select count(*) from notice where 1=1 ";
List<Object> queryList = new ArrayList<>();
String queryName = noticeQuery.getN_notice();
if (queryName != null && !"".equals(queryName)) {
sql += " and n_notice like ? ";
queryList.add("%"+queryName+"%");
}
preparedStatement = connection.prepareStatement(sql);
for (int i = 0; i < queryList.size(); i++) {
preparedStatement.setObject(i + 1, queryList.get(i));
}
//System.out.println(preparedStatement);
resultSet = preparedStatement.executeQuery();
while (resultSet.next()) {
totalCount = resultSet.getInt(1);
}
} catch (SQLException throwables) {
throwables.printStackTrace();
}finally {
JDBCUtil.close(connection, preparedStatement, resultSet);
}
return totalCount;
}
这段代码是一个 Java 类，实现了 INoticeDao 接口，并且重写了接口中的 selectTotalCount 方法。下面是对代码的详细解释：
-
INoticeDaoImpl类实现了INoticeDao接口，这意味着该类需要提供接口中声明的所有方法的具体实现。 -
selectTotalCount方法用于查询数据库中满足特定条件的记录总数，并返回结果。方法接受一个NoticeQuery对象作为参数，以便根据特定的查询条件执行查询操作。 -
在方法内部，首先初始化了
connection、preparedStatement和resultSet对象，并设置了totalCount初始值为 0。 -
通过
JDBCUtil.getConnection()方法获取数据库连接对象connection，并构建 SQL 查询语句。初始 SQL 查询语句为 “select count(*) from notice where 1=1”，表示从名为 notice 的表中查询所有记录的总数。 -
根据传入的查询条件，如果
noticeQuery对象中的n_notice字段不为空且不是空字符串，则在 SQL 语句中添加条件 “and n_notice like ?”，并将模糊查询的参数添加到queryList列表中。 -
使用预编译 SQL 语句的方式创建
PreparedStatement对象preparedStatement，并使用循环将queryList列表中的参数设置到 SQL 语句中。 -
执行 SQL 查询语句，并通过
resultSet对象获取查询结果。在这个例子中，查询结果只有一行一列，因此可以通过resultSet.getInt(1)获取查询到的总记录数。 -
在方法的最后，通过
JDBCUtil.close方法关闭数据库连接，释放资源，避免数据库连接的泄漏。 -
最后，方法返回查询到的总记录数
totalCount。
总的来说，这段代码实现了根据给定的查询条件统计数据库表 notice 中满足条件的记录总数，并且使用了 JDBC 工具类来获取数据库连接、执行 SQL 查询语句，并最终关闭数据库连接和释放资源，保证了代码的健壮性和安全性。
1.6 DormitoryDaoImpl
1.6.1 selectByPage
@Override
public List<Dormitory> selectByPage(DormitoryQuery dormitoryQuery) {
int offset = (dormitoryQuery.getPage() - 1) * dormitoryQuery.getLimit();
Connection connection = null;
PreparedStatement preparedStatement = null;
ResultSet resultSet = null;
List<Dormitory> list = new ArrayList<>();
try {
connection = JDBCUtil.getConnection();
String sql = "SELECT * FROM view_dor_building where 1=1 ";
//这里面放所有搜索条件
List<Object> queryList = new ArrayList<>();
String queryName = dormitoryQuery.getTag();
if (queryName != null && !"".equals(queryName)) {
sql += " and tag like ? ";
queryList.add("%"+queryName+"%");
}
String queryBuildingTag = dormitoryQuery.getBuildingTag();
if (queryBuildingTag != null && !"".equals(queryBuildingTag)) {
sql += " and building_tag = ? ";
queryList.add(queryBuildingTag);
}
sql += " limit ?,?";
preparedStatement = connection.prepareStatement(sql);
for (int i = 0; i < queryList.size(); i++) {
preparedStatement.setObject(i + 1, queryList.get(i));
}
preparedStatement.setInt(queryList.size() + 1, offset);
preparedStatement.setInt(queryList.size() + 2, dormitoryQuery.getLimit());
//System.out.println(preparedStatement);
resultSet = preparedStatement.executeQuery();
while (resultSet.next()) {//判断下一个有没有，如果返回true而且指向下一个，没有返回false
int id = resultSet.getInt("id");
String tag = resultSet.getString("tag");
Integer contain = resultSet.getInt("contain");
String note = resultSet.getString("note");
Integer buildingId = resultSet.getInt("buildingid");
String buildingTag = resultSet.getString("building_tag");
String buildingNote = resultSet.getString("building_note");
String buildingGender = resultSet.getString("building_gender");
Dormitory dormitory = new Dormitory(id, tag,contain,note,buildingId,buildingTag,buildingGender,buildingNote);
list.add(dormitory);
}
} catch (SQLException throwables) {
throwables.printStackTrace();
} finally {
JDBCUtil.close(connection, preparedStatement, resultSet);
}
return list;
}
这段代码是一个 Java 类，它实现了接口 IDormitoryDao 中的 selectByPage 方法。下面是代码的详细解释：
-
DormitoryDaoImpl类实现了IDormitoryDao接口，并重写了selectByPage方法，该方法用于按页查询宿舍信息。 -
在方法中，首先根据传入的页码和每页条目数计算偏移量
offset，用于分页查询。 -
声明了用于数据库连接、预编译语句和结果集的变量
connection、preparedStatement和resultSet。 -
创建了一个空的
ArrayList对象list，用于存储查询结果。 -
使用
JDBCUtil.getConnection()方法获取数据库连接对象connection。 -
构建 SQL 查询语句，初始 SQL 语句为
"SELECT * FROM view_dor_building where 1=1 "。 -
根据传入的查询条件，拼接 SQL 语句，将条件值添加到
queryList列表中，并在 SQL 语句中使用占位符。 -
通过
preparedStatement对象执行 SQL 查询，将查询结果存储在resultSet对象中。 -
使用
resultSet.next()方法遍历结果集，将查询结果映射为Dormitory对象，并将其添加到list列表中。 -
在捕获到
SQLException异常时打印堆栈信息，最后使用JDBCUtil.close()方法关闭数据库连接、预编译语句和结果集，确保资源的正确释放。 -
最后，方法返回存储了查询结果的
list列表。
这段代码的主要功能是从数据库中按页查询符合特定条件的宿舍信息，并将查询结果封装到 Dormitory 对象中，并返回一个包含查询结果的列表。
1.6.2 selectTotalCount
@Override
public Integer selectTotalCount(DormitoryQuery dormitoryQuery) {
Connection connection = null;
PreparedStatement preparedStatement = null;
ResultSet resultSet = null;
int totalCount = 0;
try {
connection = JDBCUtil.getConnection();
String sql = "select count(*) from view_dor_building where 1=1 ";
List<Object> queryList = new ArrayList<>();
String queryName = dormitoryQuery.getTag();
if (queryName != null && !"".equals(queryName)) {
sql += " and tag like ? ";
queryList.add("%"+queryName+"%");
}
String queryBuildingTag = dormitoryQuery.getBuildingTag();
if (queryBuildingTag != null && !"".equals(queryBuildingTag)) {
sql += " and building_tag like ? ";
queryList.add("%"+queryBuildingTag+"%");
}
preparedStatement = connection.prepareStatement(sql);
for (int i = 0; i < queryList.size(); i++) {
preparedStatement.setObject(i + 1, queryList.get(i));
}
//System.out.println(preparedStatement);
resultSet = preparedStatement.executeQuery();
while (resultSet.next()) {
totalCount = resultSet.getInt(1);
}
} catch (SQLException throwables) {
throwables.printStackTrace();
}finally {
JDBCUtil.close(connection, preparedStatement, resultSet);
}
return totalCount;
}
这段代码是一个实现了 IDormitoryDao 接口的具体类 DormitoryDaoImpl。以下是对代码的详细解释：
-
selectTotalCount方法是用来查询宿舍信息总数的方法。它接受一个DormitoryQuery对象作为参数，该对象包含了查询条件。 -
首先创建了数据库连接
connection，以及用于执行 SQL 语句的preparedStatement和用于存储结果集的resultSet。还初始化了一个totalCount变量用于存储查询结果的总数。 -
在
try块中，通过JDBCUtil.getConnection()方法获取数据库连接。然后构建 SQL 查询语句sql，基本结构为 "select count(*) from view_dor_building where 1=1 "。这里使用了一个占位符 “1=1”，方便后续根据条件动态添加查询条件。 -
根据传入的
DormitoryQuery对象中的查询条件，根据不同的情况动态拼接 SQL 语句，并将查询参数添加到queryList中。其中涉及的查询条件包括tag和buildingTag。 -
通过
connection.prepareStatement(sql)方法创建preparedStatement对象，并根据queryList中的参数设置占位符的值。 -
执行查询操作并将结果存储在
resultSet中。通过resultSet.getInt(1)获取查询结果的总数，并将其存储在totalCount变量中。 -
在
catch块中处理可能出现的SQLException异常，打印异常堆栈信息。 -
在
finally块中关闭数据库连接，释放资源，防止数据库连接泄漏。 -
最后，将查询到的总数
totalCount返回。
总的来说，这段代码实现了根据不同条件动态查询宿舍信息的总数，并确保在使用完数据库资源后正确释放资源，避免出现数据库连接泄露的情况。
1.6.3 deleteById
@Override
public int deleteById(int id) {
Connection connection = null;
PreparedStatement preparedStatement = null;
int count = 0;
try {
connection = JDBCUtil.getConnection();
String sql = "delete from dormitory where id=?";
preparedStatement = connection.prepareStatement(sql);
preparedStatement.setInt(1, id);
//System.out.println(preparedStatement);
count = preparedStatement.executeUpdate();
} catch (SQLException throwables) {
//throwables.printStackTrace();
}finally {
JDBCUtil.close(connection, preparedStatement, null);
}
return count;
}
这段代码是一个 Java 类的实现，它实现了 IDormitoryDao 接口中的 deleteById 方法。下面是对代码的详细解释：
-
DormitoryDaoImpl类实现了IDormitoryDao接口，这意味着它需要提供接口中定义的方法的具体实现。 -
deleteById方法用于根据给定的id删除数据库中的记录。 -
在方法内部，首先初始化了一个
Connection对象和一个PreparedStatement对象，并且初始化了一个整型变量count用于记录删除的记录数。 -
使用
JDBCUtil.getConnection()方法获取数据库连接对象connection。 -
构建 SQL 查询语句
"delete from dormitory where id=?"，并将其预编译为一个PreparedStatement对象。 -
将传入的
id设置到 SQL 查询语句中，以便删除相应的记录。 -
使用
preparedStatement.executeUpdate()执行 SQL 查询，并将执行的结果赋值给count变量，以便记录删除的记录数。 -
在
try块中捕获了SQLException异常，并在catch块中注释了throwables.printStackTrace()，这意味着在出现异常时不会打印异常的堆栈信息。 -
最后，在
finally块中调用了JDBCUtil.close()方法，关闭了数据库连接和相关资源，确保资源得到正确释放。 -
方法返回
count变量，它表示成功删除的记录数。
总体来说，这段代码是一个简单的数据库操作实现，用于删除数据库中指定 ID 的记录。代码通过 JDBC 连接到数据库，并执行了 SQL 删除操作，最后关闭了数据库连接以释放资源。
1.6.4 add
@Override
public int add(Dormitory dormitory) {
Connection connection = null;
PreparedStatement preparedStatement = null;
int count = 0;
try {
connection = JDBCUtil.getConnection();
String sql = "insert into dormitory(tag,contain,note,buildingid) values(?,?,?,?)";
preparedStatement = connection.prepareStatement(sql);
preparedStatement.setString(1, dormitory.getTag());
preparedStatement.setInt(2, dormitory.getContain());
preparedStatement.setString(3, dormitory.getNote());
preparedStatement.setInt(4, dormitory.getBuildingId());
//System.out.println(preparedStatement);
count = preparedStatement.executeUpdate();
} catch (SQLException throwables) {
throwables.printStackTrace();
}finally {
JDBCUtil.close(connection, preparedStatement, null);
}
return count;
}
这段代码是一个实现了IDormitoryDao接口的DormitoryDaoImpl类的部分方法。以下是代码的详细解释：
-
DormitoryDaoImpl类实现了IDormitoryDao接口，该接口可能定义了对宿舍（Dormitory）对象进行数据库操作的一些方法。 -
add方法用于向数据库中添加宿舍信息。该方法接受一个Dormitory对象作为参数，并返回一个整数值表示数据库中受影响的行数（即成功插入的行数）。 -
在方法内部，首先创建了数据库连接对象
Connection，以及用于执行 SQL 语句的PreparedStatement对象。 -
在
try块中，使用JDBCUtil.getConnection()方法获取数据库连接。然后，构造 SQL 插入语句并将其预编译到PreparedStatement对象中。 -
通过
preparedStatement对象的setString和setInt方法，将Dormitory对象的属性设置到 SQL 语句中对应的占位符位置。 -
调用
executeUpdate方法执行 SQL 插入语句，返回受影响的行数，即成功插入的行数，并将其赋值给count变量。 -
在
catch块中，捕获可能出现的SQLException异常，并打印异常堆栈信息。 -
最后，在
finally块中调用JDBCUtil.close方法关闭数据库连接，释放资源，确保数据库连接的正常关闭，以防止资源泄漏。
总的来说，这段代码实现了向数据库中插入宿舍信息的功能，通过预编译 SQL 语句并使用 PreparedStatement 对象设置参数，最终执行 SQL 插入操作，并在操作完成后关闭相关的数据库连接和资源。
1.6.5 selectById
@Override
public Dormitory selectById(int id) {
Connection connection = null;
PreparedStatement preparedStatement = null;
ResultSet resultSet = null;
Dormitory dormitory = null;
try {
connection = JDBCUtil.getConnection();
String sql = "SELECT * FROM view_dor_building where id=?";
preparedStatement = connection.prepareStatement(sql);
preparedStatement.setInt(1, id);
//System.out.println(preparedStatement);
resultSet = preparedStatement.executeQuery();
while (resultSet.next()) {//判断下一个有没有，如果返回true而且指向下一个，没有返回false
String tag = resultSet.getString("tag");
Integer contain = resultSet.getInt("contain");
String note = resultSet.getString("note");
Integer buildingId = resultSet.getInt("buildingid");
String buildingTag = resultSet.getString("building_tag");
String buildingGender = resultSet.getString("building_gender");
String buildingNote = resultSet.getString("building_note");
dormitory = new Dormitory(id,tag,contain,note,buildingId,buildingTag,buildingGender,buildingNote);
}
} catch (SQLException throwables) {
throwables.printStackTrace();
} finally {
JDBCUtil.close(connection, preparedStatement, resultSet);
}
return dormitory;
}
这段代码是一个Java类 DormitoryDaoImpl，实现了接口 IDormitoryDao 中的方法 selectById。下面是对代码的详细解释：
-
在
selectById方法中，首先初始化了一些变量，包括connection用于建立数据库连接，preparedStatement用于执行带参数的 SQL 语句，resultSet用于存储查询结果集，dormitory用于存储从数据库中查询到的宿舍信息。 -
通过
JDBCUtil.getConnection()方法获取数据库连接。 -
构建 SQL 查询语句，通过
preparedStatement对象执行 SQL 语句，其中使用了占位符?表示需要传入参数。 -
调用
preparedStatement.setInt(1, id)将方法传入的id参数赋值给 SQL 语句中的第一个占位符，从而实现根据特定 id 查询宿舍信息的功能。 -
调用
preparedStatement.executeQuery()方法执行 SQL 查询，并将返回的结果存储在resultSet中。 -
通过
resultSet.next()判断结果集中是否有下一条记录，如果有，则使用resultSet获取该记录中的字段值，包括tag、contain、note、buildingId、buildingTag、buildingGender和buildingNote。 -
最后，使用获取的字段值构造一个
Dormitory对象，然后将其返回。 -
在异常处理中，使用
throwables.printStackTrace()打印异常堆栈信息，以便调试和定位错误。最后通过JDBCUtil.close()方法关闭数据库连接，释放资源，避免资源泄漏。
总的来说，这段代码实现了根据传入的 id 从数据库中查询宿舍信息的功能，并将查询到的结果封装到 Dormitory 对象中返回。同时，代码也处理了数据库连接的获取和释放，以及异常情况的处理。
1.6.6 update
@Override
public int update(Dormitory dormitory) {
Connection connection = null;
PreparedStatement preparedStatement = null;
int count = 0;
try {
connection = JDBCUtil.getConnection();
String sql = "update dormitory set tag=?,contain=?,note=?,buildingid=? where id=?";
preparedStatement = connection.prepareStatement(sql);
preparedStatement.setString(1, dormitory.getTag());
preparedStatement.setInt(2, dormitory.getContain());
preparedStatement.setString(3, dormitory.getNote());
preparedStatement.setInt(4, dormitory.getBuildingId());
preparedStatement.setInt(5, dormitory.getId());
//System.out.println(preparedStatement);
count = preparedStatement.executeUpdate();
} catch (SQLException throwables) {
throwables.printStackTrace();
}finally {
JDBCUtil.close(connection, preparedStatement, null);
}
return count;
}
这段代码是一个 Java 类 DormitoryDaoImpl，实现了 IDormitoryDao 接口。下面是对代码的详细解释：
-
DormitoryDaoImpl类实现了IDormitoryDao接口，该接口可能定义了一些与宿舍管理相关的数据库操作的方法，其中之一是update方法。 -
update方法用于更新数据库中的dormitory表中的数据。它接受一个Dormitory对象作为参数，其中包含了需要更新的宿舍信息。 -
代码中使用了 JDBC 技术来操作数据库。首先，它获取一个数据库连接
connection，然后使用预处理语句preparedStatement来执行 SQL 更新操作。 -
SQL 语句是一个
update语句，用于更新dormitory表中的特定记录。其中，?是占位符，通过调用preparedStatement对象的setXXX方法将具体的值赋给这些占位符。 -
在
try-catch块中，执行 SQL 更新操作并将结果存储在count变量中。如果更新成功，count变量将包含受影响的行数。 -
finally块中调用了JDBCUtil.close方法来关闭数据库连接、预处理语句等资源，以防止资源泄露。
总的来说，这段代码通过 JDBC 技术实现了更新数据库中宿舍信息的操作。代码首先建立数据库连接，然后执行 SQL 更新语句，最后关闭相关资源。若在更新过程中出现异常，异常信息将会被打印出来。
1.6.7 selectByBuilding
@Override
public List<Dormitory> selectByBuilding(int buildingId) {
Connection connection = null;
PreparedStatement preparedStatement = null;
ResultSet resultSet = null;
List<Dormitory> list=new ArrayList<>();
try {
connection = JDBCUtil.getConnection();
String sql = "SELECT * FROM dormitory where buildingid=?";
preparedStatement = connection.prepareStatement(sql);
preparedStatement.setInt(1, buildingId);
//System.out.println(preparedStatement);
resultSet = preparedStatement.executeQuery();
while (resultSet.next()) {
Integer id=resultSet.getInt("id");
String tag = resultSet.getString("tag");
Integer contain = resultSet.getInt("contain");
String note = resultSet.getString("note");
Dormitory dormitory = new Dormitory(id,tag,contain,note);
list.add(dormitory);
}
} catch (SQLException throwables) {
throwables.printStackTrace();
} finally {
JDBCUtil.close(connection, preparedStatement, resultSet);
}
return list;
}
这段代码是一个实现了接口 IDormitoryDao 的类 DormitoryDaoImpl，用于从数据库中根据指定的 buildingId 查询相应的宿舍信息列表。下面是对代码的详细解释：
-
DormitoryDaoImpl类实现了IDormitoryDao接口，该接口可能定义了查询宿舍信息的抽象方法。 -
selectByBuilding方法用于根据给定的buildingId查询对应的宿舍列表，并返回一个包含宿舍对象的列表。 -
首先，代码初始化了一个空的
List<Dormitory>用于存储查询结果，并声明了数据库连接connection、预编译语句preparedStatement以及结果集resultSet。 -
在
try块中，代码首先通过JDBCUtil.getConnection()获取数据库连接。 -
然后构建 SQL 查询语句，使用预编译语句创建并设置参数，将
buildingId作为查询条件。 -
执行查询并将结果存储在
resultSet中。 -
使用
while循环遍历结果集中的每一行数据，将每行数据提取出来构建一个Dormitory对象，并将其添加到list中。 -
最后，无论是否发生异常，都会执行
JDBCUtil.close()方法来关闭连接、预编译语句和结果集，确保资源被正确释放。 -
最后，返回包含查询结果的
list。
总的来说，这段代码实现了一个根据给定 buildingId 查询相应宿舍信息的方法，并将查询结果封装在一个 List 中返回。同时，它还对数据库连接和资源进行了正确的管理，包括异常处理和资源释放，以确保代码的健壮性和可靠性。
1.7 BuildingManagerDaoImpl
1.7.1 add
@Override
public int add(BuildingManager buildingManager) {
Connection connection = null;
PreparedStatement preparedStatement = null;
int count=0;
try {
connection = JDBCUtil.getConnection();
String sql = "insert into building_manager(buildingid,managerid) values (?,?)";
preparedStatement = connection.prepareStatement(sql);
preparedStatement.setInt(1, buildingManager.getBuildingId());
preparedStatement.setInt(2, buildingManager.getManagerId());
//System.out.println(preparedStatement);
count = preparedStatement.executeUpdate();
} catch (SQLException throwables) {
throwables.printStackTrace();
} finally {
JDBCUtil.close(connection, preparedStatement, null);
}
return count;
}
这段代码是一个 DormitoryDaoImpl 类的实现，该类实现了 IDormitoryDao 接口。以下是代码的详细解释：
-
DormitoryDaoImpl类实现了IDormitoryDao接口，因此必须实现接口中声明的所有方法，包括add方法。 -
add方法用于向数据库中的building_manager表中插入数据。这个方法接受一个BuildingManager对象作为参数，该对象包含要插入的建筑物 ID 和管理员 ID。 -
首先，代码尝试获取数据库连接。如果连接成功，则执行 SQL 插入语句。SQL 语句使用了预处理语句，其中
?是占位符，用来动态设置参数值，以防止 SQL 注入攻击。 -
在预处理语句中，第一个
setInt方法将buildingManager对象中的建筑物 ID 设置到 SQL 语句中的第一个占位符位置，第二个setInt方法将管理员 ID 设置到 SQL 语句中的第二个占位符位置。 -
然后，使用
executeUpdate方法执行 SQL 语句并将执行影响的行数存储在count变量中。如果插入成功，则count的值将大于 0。 -
如果在执行过程中发生了 SQL 异常，将会捕获该异常并打印出堆栈信息。
-
无论插入是否成功，最终代码都会关闭数据库连接，以确保资源被正确释放，避免数据库连接泄漏。
总的来说，这段代码实现了向数据库中的 building_manager 表中插入一条记录的操作。这种方法可以防止 SQL 注入攻击，并确保数据库资源被正确释放。
1.7.2 delete
@Override
public int delete(BuildingManager buildingManager) {
Connection connection = null;
PreparedStatement preparedStatement = null;
int count=0;
try {
connection = JDBCUtil.getConnection();
String sql = "DELETE FROM building_manager WHERE buildingId=?;";
preparedStatement = connection.prepareStatement(sql);
preparedStatement.setInt(1, buildingManager.getBuildingId());
//System.out.println(preparedStatement);
count = preparedStatement.executeUpdate();
} catch (SQLException throwables) {
throwables.printStackTrace();
} finally {
JDBCUtil.close(connection, preparedStatement, null);
}
return count;
}
这段代码是一个 Java 类，实现了 IDormitoryDao 接口。下面是对代码的详细解释：
-
DormitoryDaoImpl类实现了IDormitoryDao接口，表明该类包含了实现该接口的具体功能。 -
delete方法是该类中的一个实例方法，用于从数据库中删除与给定BuildingManager对象关联的记录。 -
方法内部首先初始化了
connection和preparedStatement两个变量，用于执行 SQL 操作。 -
通过
JDBCUtil.getConnection()方法获取数据库连接。 -
构建 SQL 删除语句，其中
DELETE FROM building_manager WHERE buildingId=?;表示从名为building_manager的表中根据buildingId条件删除记录。 -
通过
connection.prepareStatement(sql)方法创建一个预编译的语句对象，并将 SQL 语句作为参数传入。 -
使用
preparedStatement.setInt(1, buildingManager.getBuildingId())方法设置 SQL 语句中的参数，即buildingManager对象中的buildingId。 -
调用
preparedStatement.executeUpdate()方法执行 SQL 语句，并将返回的更新记录数存储在count变量中。 -
如果在执行 SQL 语句的过程中发生异常，会将异常信息打印出来。
-
最后通过
JDBCUtil.close(connection, preparedStatement, null)方法关闭数据库连接和相关资源，确保数据库资源的及时释放。 -
方法返回
count，即受影响的记录数，表示删除成功的记录条数。
总的来说，该代码块实现了根据给定的 BuildingManager 对象中的 buildingId 删除数据库中相关记录的功能，并且在操作完成后关闭了数据库连接。
1.7.3 change
@Override
public int change(BuildingManager buildingManager) {
Connection connection = null;
PreparedStatement preparedStatement = null;
int count=0;
try {
connection = JDBCUtil.getConnection();
String sql = "UPDATE building_manager SET managerId = ? WHERE buildingId=?;";
preparedStatement = connection.prepareStatement(sql);
preparedStatement.setInt(1, buildingManager.getManagerId());
preparedStatement.setInt(2, buildingManager.getBuildingId());
//System.out.println(preparedStatement);
count = preparedStatement.executeUpdate();
} catch (SQLException throwables) {
throwables.printStackTrace();
} finally {
JDBCUtil.close(connection, preparedStatement, null);
}
return count;
}
这段代码是一个 Java 类 DormitoryDaoImpl，它实现了接口 IDormitoryDao，并提供了方法 change。下面是对代码的详细解释：
-
DormitoryDaoImpl类实现了接口IDormitoryDao，因此需要实现接口中声明的所有抽象方法，其中之一就是change方法。 -
change方法用于修改数据库中的building_manager表，将指定的buildingId对应的记录的managerId更新为给定的buildingManager对象中的managerId值。 -
在方法中首先创建了数据库连接
connection，并初始化了一个用于执行 SQL 语句的preparedStatement对象。 -
然后构建了 SQL 更新语句，使用
?占位符表示动态参数的位置。 -
通过
preparedStatement.setInt方法设置 SQL 语句中的两个参数的值，第一个参数对应managerId，第二个参数对应buildingId。 -
使用
preparedStatement.executeUpdate()方法执行 SQL 更新语句，并将受影响的行数存储在count变量中。 -
如果在执行 SQL 语句的过程中发生了异常，将会打印异常堆栈信息。
-
最后通过
JDBCUtil.close方法关闭数据库连接、预编译语句对象等资源，以确保资源被正确释放。 -
最后，
change方法返回执行 SQL 更新操作所影响的行数，即更新的记录数量。
总的来说，这段代码用于执行一个更新操作，将指定 buildingId 对应的记录的 managerId 更新为给定的 buildingManager 对象中的 managerId 值，并返回更新的记录数量。同时，代码在出现异常时也保证了数据库资源的正确释放。
1.8 BuildingDaoImpl
1.8.1 queryAllocation
@Override
public List<BuildingAllocation> queryAllocation() {
Connection connection = null;
PreparedStatement preparedStatement = null;
ResultSet resultSet = null;
List<BuildingAllocation> list=new ArrayList<>();
try {
connection = JDBCUtil.getConnection();
String sql = "select * from view_building_allocation order by tag desc";
preparedStatement = connection.prepareStatement(sql);
resultSet = preparedStatement.executeQuery();
while (resultSet.next()) {//判断下一个有没有，如果返回true而且指向下一个，没有返回false
int id = resultSet.getInt("id");
String tag=resultSet.getString("tag");
int roomsMax=resultSet.getInt("rooms_max");
int allocation=resultSet.getInt("has_allocation");
BuildingAllocation buildingAllocation=new BuildingAllocation(id,tag,roomsMax,allocation);
list.add(buildingAllocation);
}
} catch (SQLException throwables) {
throwables.printStackTrace();
} finally {
JDBCUtil.close(connection, preparedStatement, resultSet);
}
return list;
}
这段代码是一个 BuildingDaoImpl 类，实现了 IBuildingDao 接口，其中 queryAllocation 方法用于从数据库中查询建筑分配情况，并将查询结果封装为 BuildingAllocation 对象的列表。下面是对代码的详细解释：
-
首先创建了一个空的
List<BuildingAllocation>对象list用于存储查询结果。 -
通过 JDBCUtil 类的
getConnection方法获取数据库连接对象connection。 -
定义 SQL 查询语句
sql，用于从数据库中获取建筑分配情况。 -
通过
connection创建preparedStatement对象，并使用 SQL 语句创建查询预编译语句。 -
通过
preparedStatement对象执行查询语句，并将查询结果保存在resultSet对象中。 -
通过循环遍历
resultSet对象，使用resultSet.getInt和resultSet.getString方法获取每一行查询结果中的相关字段值，并将这些值封装为BuildingAllocation对象。 -
将封装好的
BuildingAllocation对象添加到list列表中。 -
在发生 SQL 异常时，通过
throwables.printStackTrace()打印异常堆栈信息。 -
最后，通过 JDBCUtil 类的
close方法关闭数据库连接、预编译语句和结果集，确保释放数据库资源。 -
返回存储查询结果的
list列表，完成数据库查询操作。
总的来说，这段代码的作用是从数据库中查询建筑分配情况，并将查询结果封装为 BuildingAllocation 对象的列表，以便在应用程序中进一步处理或显示。
1.8.2 queryStudentNum
@Override
public List<BuildingAllocation> queryStudentNum() {
Connection connection = null;
PreparedStatement preparedStatement = null;
ResultSet resultSet = null;
List<BuildingAllocation> list=new ArrayList<>();
try {
connection = JDBCUtil.getConnection();
String sql = "SELECT *,(select count(*) from view_stu_dor_building as b where b.building_id=a.id) as building_num FROM dormitory_system.building as a order by tag asc";
preparedStatement = connection.prepareStatement(sql);
resultSet = preparedStatement.executeQuery();
while (resultSet.next()) {//判断下一个有没有，如果返回true而且指向下一个，没有返回false
int id = resultSet.getInt("id");
String tag=resultSet.getString("tag");
int buildingNum=resultSet.getInt("building_num");
BuildingAllocation buildingAllocation=new BuildingAllocation(id,tag,buildingNum);
list.add(buildingAllocation);
}
} catch (SQLException throwables) {
throwables.printStackTrace();
} finally {
JDBCUtil.close(connection, preparedStatement, resultSet);
}
return list;
}
这段代码看起来是一个实现了 IBuildingDao 接口的类 BuildingDaoImpl，它包含了查询学生数量的方法 queryStudentNum。以下是代码的详细解释：
-
首先，建立了
BuildingDaoImpl类，该类实现了IBuildingDao接口。 -
在
queryStudentNum方法中，首先初始化了数据库连接connection、预编译语句对象preparedStatement和结果集对象resultSet。 -
创建了一个空的
ArrayList集合list，用于存储查询结果。 -
通过
JDBCUtil.getConnection()方法获取数据库连接。 -
构建了 SQL 查询语句，从数据库的
building表中选择所有字段，并通过子查询统计每栋楼的学生数量，并按照tag字段的升序进行排序。 -
使用
connection.prepareStatement(sql)方法将 SQL 查询语句预编译到preparedStatement对象中。 -
执行 SQL 查询并将结果存储在
resultSet中。 -
通过
resultSet.next()循环遍历每一行数据，提取出每行中的id、tag和building_num字段的值，然后利用这些值构造BuildingAllocation对象，并将其添加到list中。 -
最后，在
finally块中，调用JDBCUtil.close(connection, preparedStatement, resultSet)方法关闭数据库连接，以确保资源得到正确释放。 -
返回存储了所有查询结果的
list。
总的来说，这段代码实现了从数据库中查询每栋楼的学生数量，并将结果封装在 BuildingAllocation 对象中，最后将这些对象存储在一个列表中并返回。同时，代码中还包含了必要的异常处理和数据库资源的正确释放。
1.8.3 selectByPage
@Override
public List<Building> selectByPage(BuildingQuery buildingQuery) {
int offset = (buildingQuery.getPage() - 1) * buildingQuery.getLimit();
Connection connection = null;
PreparedStatement preparedStatement = null;
ResultSet resultSet = null;
List<Building> list = new ArrayList<>();
try {
connection = JDBCUtil.getConnection();
String sql = "SELECT * FROM view_building_manager where 1=1 ";
//这里面放所有搜索条件
List<Object> queryList = new ArrayList<>();
String queryName = buildingQuery.getTag();
if (queryName != null && !"".equals(queryName)) {
sql += " and tag like ? ";
queryList.add("%"+queryName+"%");
}
String queryGender = buildingQuery.getGender();
if (queryGender != null && !"".equals(queryGender)) {
sql += " and gender like ? ";
queryList.add("%"+queryGender+"%");
}
sql += " limit ?,?";
preparedStatement = connection.prepareStatement(sql);
for (int i = 0; i < queryList.size(); i++) {
preparedStatement.setObject(i + 1, queryList.get(i));
}
preparedStatement.setInt(queryList.size() + 1, offset);
preparedStatement.setInt(queryList.size() + 2, buildingQuery.getLimit());
//System.out.println(preparedStatement);
resultSet = preparedStatement.executeQuery();
while (resultSet.next()) {//判断下一个有没有，如果返回true而且指向下一个，没有返回false
int id = resultSet.getInt("id");
String tag = resultSet.getString("tag");
Integer roomsMax = resultSet.getInt("rooms_max");
String note = resultSet.getString("note");
String gender = resultSet.getString("gender");
String managerName=resultSet.getString("manager_name");
String managerGender=resultSet.getString("manager_gender");
Building building = new Building(id, tag,roomsMax,note,gender,managerName,managerGender);
list.add(building);
}
} catch (SQLException throwables) {
throwables.printStackTrace();
} finally {
JDBCUtil.close(connection, preparedStatement, resultSet);
}
return list;
}
这段代码是一个Java类，名为BuildingDaoImpl，实现了IBuildingDao接口。下面是对代码的详细解释：
-
selectByPage方法是该类的一个重要方法，用于根据传入的BuildingQuery对象进行分页查询。它根据传入的查询条件从数据库中检索建筑信息，并返回建筑信息的列表。 -
首先，根据传入的
buildingQuery对象计算出偏移量offset，用于分页查询时确定起始位置。 -
在方法的开头，代码初始化了一个数据库连接对象
connection、一个预编译语句对象preparedStatement和一个结果集对象resultSet，同时创建了一个空的建筑信息列表list。 -
代码通过
JDBCUtil.getConnection()获取数据库连接，确保数据库连接能够正确建立。 -
构建 SQL 查询语句，初始语句为 "SELECT * FROM view_building_manager where 1=1 "，然后根据传入的查询条件逐步拼接 SQL 语句。
-
代码使用
PreparedStatement预编译 SQL 语句，并通过循环将查询参数逐个设置进去。 -
使用
resultSet执行 SQL 查询语句，然后通过resultSet.next()方法逐行获取查询结果，将每行结果封装成Building对象，并添加到建筑信息列表list中。 -
最后，无论是否发生异常，代码都会确保关闭数据库连接、预编译语句和结果集，以释放资源和防止数据库连接泄露。
-
最终，方法返回建筑信息列表
list，其中包含了符合查询条件的建筑信息对象。
总体来说，该方法通过 JDBC 进行数据库查询，根据传入的查询条件进行动态拼接 SQL 语句，并将查询结果封装成建筑信息对象，最终返回一个建筑信息列表。
1.8.4 selectTotalCount
@Override
public Integer selectTotalCount(BuildingQuery buildingQuery) {
Connection connection = null;
PreparedStatement preparedStatement = null;
ResultSet resultSet = null;
int totalCount = 0;
try {
connection = JDBCUtil.getConnection();
String sql = "select count(*) from building where 1=1 ";
List<Object> queryList = new ArrayList<>();
String queryName = buildingQuery.getTag();
if (queryName != null && !"".equals(queryName)) {
sql += " and tag like ? ";
queryList.add("%"+queryName+"%");
}
String queryGender = buildingQuery.getGender();
if (queryGender != null && !"".equals(queryGender)) {
sql += " and gender like? ";
queryList.add("%"+queryGender+"%");
}
preparedStatement = connection.prepareStatement(sql);
for (int i = 0; i < queryList.size(); i++) {
preparedStatement.setObject(i + 1, queryList.get(i));
}
//System.out.println(preparedStatement);
resultSet = preparedStatement.executeQuery();
while (resultSet.next()) {
totalCount = resultSet.getInt(1);
}
} catch (SQLException throwables) {
throwables.printStackTrace();
}finally {
JDBCUtil.close(connection, preparedStatement, resultSet);
}
return totalCount;
}
这段代码是一个名为 BuildingDaoImpl 的类实现了接口 IBuildingDao 中的 selectTotalCount 方法。这个方法的作用是根据传入的 BuildingQuery 对象，查询符合条件的记录总数。
下面是对代码的详细解释：
-
首先在方法内部声明了一些变量，包括
Connection、PreparedStatement、ResultSet和int totalCount，用于存储查询结果的总数。 -
通过
JDBCUtil.getConnection()方法获取数据库连接。 -
构建 SQL 查询语句
sql，初始化为 "select count(*) from building where 1=1 "，其中1=1只是为了方便后续拼接查询条件而存在的一个占位条件。 -
创建一个
List<Object>类型的queryList，用于存储查询条件对应的值。 -
检查
BuildingQuery对象中的tag和gender属性是否存在并且不为空。如果存在，就根据对应的条件拼接 SQL 查询语句，并将对应的值加入queryList。 -
通过
connection.prepareStatement(sql)方法创建PreparedStatement对象，并将拼接好的 SQL 语句赋值给preparedStatement。 -
通过
preparedStatement.setObject(i + 1, queryList.get(i))将查询条件的值设置到preparedStatement中。 -
执行查询操作，获取查询结果集
resultSet。 -
通过
resultSet.getInt(1)获取查询结果的总数，并将其赋值给totalCount。 -
在
catch块中捕获可能出现的SQLException异常，并打印异常堆栈信息。 -
最后在
finally块中调用JDBCUtil.close()方法关闭数据库连接，释放资源。 -
返回查询结果的总数
totalCount。
总的来说，这段代码实现了根据传入的 BuildingQuery 对象中的条件，在数据库中查询符合条件的记录总数，并将结果作为一个整数返回。同时，通过合理的异常处理和资源释放，保证了代码的健壮性和稳定性。
1.8.5 deleteById
@Override
public int deleteById(int id) {
Connection connection = null;
PreparedStatement preparedStatement = null;
int count = 0;
try {
connection = JDBCUtil.getConnection();
String sql = "delete from building where id=?";
preparedStatement = connection.prepareStatement(sql);
preparedStatement.setInt(1, id);
//System.out.println(preparedStatement);
count = preparedStatement.executeUpdate();
} catch (SQLException throwables) {
//throwables.printStackTrace();
}
return count;
}
这段代码是一个名为 BuildingDaoImpl 的类，实现了 IBuildingDao 接口。下面是对代码的详细解释：
-
public class BuildingDaoImpl implements IBuildingDao：这行代码声明了一个类BuildingDaoImpl，该类实现了IBuildingDao接口，表明它包含了IBuildingDao接口中定义的方法。 -
deleteById方法用于根据提供的id值从数据库中删除一条记录。 -
在
deleteById方法中：- 通过调用
JDBCUtil.getConnection()方法获取数据库连接对象connection。 - 构建 SQL 语句
"delete from building where id=?"。 - 通过使用预编译语句
preparedStatement，将 SQL 语句和连接对象关联起来。 - 设置 SQL 语句中的占位符参数值为提供的
id值。 - 通过调用
executeUpdate()方法执行 SQL 语句，将受影响的行数存储在count变量中。
- 通过调用
-
catch块捕获了可能抛出的SQLException异常，但是在catch块中对异常并没有进行任何处理，只是注释掉了throwables.printStackTrace()语句。 -
return count;语句将受影响的行数作为结果返回，表示删除操作的执行结果。
需要确保在实际应用中，在 catch 块中应该记录或处理异常，以便更好地跟踪错误并进行适当的处理。此外，还应该在适当的时候关闭数据库连接和释放资源，以确保代码的健壮性和可靠性。
1.8.6 add
@Override
public int add(Building building) {
Connection connection = null;
PreparedStatement preparedStatement = null;
int count = 0;
try {
connection = JDBCUtil.getConnection();
String sql = "insert into building(tag,rooms_max,note,gender) values(?,?,?,?)";
preparedStatement = connection.prepareStatement(sql);
preparedStatement.setString(1, building.getTag());
preparedStatement.setInt(2, building.getRoomsMax());
preparedStatement.setString(3, building.getNote());
preparedStatement.setString(4, building.getGender());
//System.out.println(preparedStatement);
count = preparedStatement.executeUpdate();
} catch (SQLException throwables) {
throwables.printStackTrace();
}finally {
JDBCUtil.close(connection, preparedStatement, null);
}
return count;
}
这段代码是一个 BuildingDaoImpl 类的实现，该类实现了 IBuildingDao 接口。下面是对代码的详细解释：
-
BuildingDaoImpl类实现了IBuildingDao接口，其中包含了一个名为add的方法，用于向数据库中的building表添加新的记录。 -
在
add方法中，首先声明了connection和preparedStatement对象，并初始化count为 0，用于记录插入记录的数量。 -
在
try块中，通过JDBCUtil.getConnection()方法获取数据库连接对象connection。然后构造了 SQL 插入语句，并使用preparedStatement对象执行该 SQL 语句。 -
SQL 语句的模板是 “insert into building(tag,rooms_max,note,gender) values(?,?,?,?)”，它将
building对象的属性值作为参数插入到数据库表中。 -
使用
preparedStatement.setString和preparedStatement.setInt方法分别设置 SQL 语句中的占位符的值，保证了 SQL 语句的安全性和正确性。 -
count变量记录了数据库执行更新操作后所影响的记录数，通过preparedStatement.executeUpdate()方法执行 SQL 插入语句并返回执行结果。 -
在
catch块中，捕获可能抛出的SQLException异常，并调用printStackTrace方法打印异常堆栈信息。 -
无论是否发生异常，
finally块中调用JDBCUtil.close方法关闭数据库连接、释放相关资源，确保数据库连接的正确关闭，避免资源泄露。 -
最后，
count变量作为方法的返回值，用于表示插入记录的数量。
1.8.7 selectById
@Override
public Building selectById(int id) {
Connection connection = null;
PreparedStatement preparedStatement = null;
ResultSet resultSet = null;
Building building = null;
try {
connection = JDBCUtil.getConnection();
String sql = "SELECT * FROM building where id=?";
preparedStatement = connection.prepareStatement(sql);
preparedStatement.setInt(1, id);
//System.out.println(preparedStatement);
resultSet = preparedStatement.executeQuery();
while (resultSet.next()) {//判断下一个有没有，如果返回true而且指向下一个，没有返回false
String tag = resultSet.getString("tag");
Integer roomsMax = resultSet.getInt("rooms_max");
String note = resultSet.getString("note");
String gender = resultSet.getString("gender");
building = new Building(id, tag,roomsMax,note,gender);
}
} catch (SQLException throwables) {
throwables.printStackTrace();
} finally {
JDBCUtil.close(connection, preparedStatement, resultSet);
}
return building;
}
这段代码是一个实现了 IBuildingDao 接口的 BuildingDaoImpl 类。该类的 selectById 方法根据传入的 id 参数从数据库中查询对应的楼宇信息，并返回一个 Building 对象。以下是对代码的详细解释：
-
selectById方法用于根据传入的id参数从数据库中检索楼宇信息。 -
在方法内部，首先创建了与数据库的连接
Connection，预处理语句PreparedStatement，以及结果集ResultSet。同时创建了一个Building对象用于存储查询到的楼宇信息。 -
通过
JDBCUtil.getConnection()方法获取数据库连接。 -
使用 SQL 语句
"SELECT * FROM building where id=?"创建了一个PreparedStatement对象，并设置了参数值为传入的id。 -
通过
preparedStatement.executeQuery()执行查询操作，并将结果存储在ResultSet对象中。 -
使用
resultSet.next()判断结果集中是否有下一条记录，如果有，则从结果集中提取 “tag”、“rooms_max”、“note”、“gender” 字段的值。 -
使用提取的字段值构造了一个
Building对象，并将其赋值给之前声明的building对象。 -
在
try块中，通过JDBCUtil.close(connection, preparedStatement, resultSet)方法关闭了数据库连接、预处理语句和结果集，以释放资源并避免内存泄漏。 -
最后返回查询得到的
building对象。
总的来说，该方法通过 JDBC 技术连接数据库，并执行 SQL 查询语句，将结果封装为一个 Building 对象并返回。如果在执行过程中出现异常，会将异常打印出来，同时确保在最终关闭数据库资源。
1.8.8 update
@Override
public int update(Building building) {
Connection connection = null;
PreparedStatement preparedStatement = null;
int count = 0;
try {
connection = JDBCUtil.getConnection();
String sql = "update building set tag=?,rooms_max=?,note=?,gender=? where id=?";
preparedStatement = connection.prepareStatement(sql);
preparedStatement.setString(1, building.getTag());
preparedStatement.setInt(2, building.getRoomsMax());
preparedStatement.setString(3, building.getNote());
preparedStatement.setString(4, building.getGender());
preparedStatement.setInt(5, building.getId());
//System.out.println(preparedStatement);
count = preparedStatement.executeUpdate();
} catch (SQLException throwables) {
throwables.printStackTrace();
}finally {
JDBCUtil.close(connection, preparedStatement, null);
}
return count;
}
这段代码是一个Java类 BuildingDaoImpl，它实现了接口 IBuildingDao，并且重写了接口中声明的 update 方法。下面是对代码的详细解释：
-
BuildingDaoImpl类负责实现与数据库中的building表相关的操作。 -
update方法用于更新building表中的记录。它接受一个Building对象作为参数，该对象包含了需要更新的字段信息。 -
在方法中首先获取数据库连接
connection，并初始化一个PreparedStatement对象preparedStatement。 -
使用 SQL 语句
"update building set tag=?,rooms_max=?,note=?,gender=? where id=?"来构建一个预处理语句，其中?是占位符，用于后续设置具体的参数值。 -
通过调用
preparedStatement.setString和preparedStatement.setInt等方法，将Building对象中的字段值设置到预处理语句中的相应位置。 -
通过调用
preparedStatement.executeUpdate()方法执行 SQL 更新操作，并将执行更新操作所影响的行数存储在count变量中。 -
在可能发生异常的地方（例如 SQL 执行错误）使用
try-catch块来处理异常，打印异常堆栈信息。 -
最后，在
finally块中调用JDBCUtil.close方法关闭数据库连接，以释放相关资源。 -
方法返回更新的行数
count，用于进一步判断更新操作是否成功。
总的来说，这段代码用于更新数据库中 building 表的记录，根据传入的 Building 对象更新相应的字段内容，并确保在方法执行结束后关闭相关的数据库连接。
1.8.9 selectAll
@Override
public List<Building> selectAll(String gender) {
Connection connection = null;
PreparedStatement preparedStatement = null;
ResultSet resultSet = null;
List<Building> list = new ArrayList<>();
try {
connection = JDBCUtil.getConnection();
String sql = "SELECT * FROM building WHERE gender=?";
preparedStatement = connection.prepareStatement(sql);
preparedStatement.setString(1, gender);
resultSet = preparedStatement.executeQuery();
while (resultSet.next()) {
Integer id = resultSet.getInt("id");
String tag = resultSet.getString("tag");
Integer roomsMax = resultSet.getInt("rooms_max");
String note = resultSet.getString("note");
Building building = new Building(id, tag, roomsMax, note, gender);
list.add(building);
}
} catch (SQLException throwables) {
throwables.printStackTrace();
} finally {
JDBCUtil.close(connection, preparedStatement, resultSet);
}
return list;
}
这段代码是一个 Java 类 BuildingDaoImpl，实现了接口 IBuildingDao 中的方法 selectAll。下面是对代码的详细解释：
-
selectAll方法签名中的参数gender是用于筛选建筑物的性别条件。 -
在方法内部首先创建了一个数据库连接
connection，一个预编译语句对象preparedStatement以及一个结果集resultSet。 -
然后构造一个空的
List，用于存储从数据库中查询到的建筑物数据。 -
在
try块中，通过调用JDBCUtil.getConnection()获取数据库连接。 -
构建 SQL 查询语句，使用预编译语句对象
preparedStatement设置查询语句中的参数，并执行查询操作。 -
遍历结果集
resultSet，对每一行数据进行处理。从结果集中获取建筑物的属性值，包括id、tag、roomsMax和note。 -
使用获取的属性值构建
Building对象，并将其添加到之前创建的list中。 -
在
catch块中，打印出可能出现的异常信息。 -
最后，在
finally块中，调用JDBCUtil.close()方法关闭数据库连接，预编译语句对象和结果集，确保资源被正确释放。 -
最终，返回存储了所有查询到的建筑物对象的
list。
总的来说，这段代码是一个用于通过数据库查询获取指定性别建筑物信息的方法实现。它使用 JDBC 技术与数据库进行交互，并通过建立连接、执行查询操作和关闭资源等步骤来实现对数据库的访问。
3114
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
