package s2jsp.bysj.dao; //此类所在包的名称
import java.sql.Connection; //导入Connection类
import java.sql.PreparedStatement; //导入PreparedStatement类
import java.sql.ResultSet; //导入ResultSet类
import java.util.ArrayList; //导入ArrayList类
import java.util.List; //导入List类
import s2jsp.bysj.entity.Users; //导入Users实体类
public class UserDao extends BaseDao { //UserDao类继承了BaseDao类
private Connection conn; //声明私有变量：Connection对象
private PreparedStatement pstmt; //声明私有变量：PreparedStatement对象
private ResultSet rs; //声明私有变量：ResultSet数据集对象
/**
* 根据用户名和密码，查找相关用户信息
* @return Users类的对象：用户对象
*@userName 用户名
*@password 用户密码
*/
public Users findUsers(String userName, String password) {
Users user = null; //声明实体类Users对象
String sql = "select * from users where userName=? and password=? "; //定义sql变量，此变量用来代替执行的SQL语句
try { //将会发生异常的代码放在了try{}catch{}块中
conn = this.getConn(); //初始化了Connection对象：conn，getConn()方法是继承自BaseDao的方法
pstmt = conn.prepareStatement(sql); //初始化PreparedStatement对象：pstmt
pstmt.setString(1, userName); //为SQL语句中的参数1设置值
pstmt.setString(2, password); //为SQL语句中的参数2设置值
rs = pstmt.executeQuery(); //用PreparedStatement的对象的executeQuery()方法初始化ResultSet对象：rs
if (rs.next()) { //如果ResultSet的next()方法返回true，则说明目标数据库中的下一行有数据
user = new Users(); //初始化Users实体类，此类准备用来初始化其域
user.setUserID(rs.getInt("userID")); //用数据库中的值初始化Users实体类中的UserID字段
user.setUserName(userName); //用数据库中的值初始化Users实体类中的UserName字段
user.setPassword(password); //用数据库中的值初始化Users实体类中的Password字段
user.setStatus(rs.getInt("status")); //用数据库中的值初始化Users实体类中的Status字段
}
} catch (Exception e) { //catch内使用了Exception异常根类的printStackTrace()方法：表示将错误信息打印在堆栈上
e.printStackTrace();
} finally { //finally块中的语句表示始终要执行的语句，并且在try语句块后执行
this.closeAll(conn, pstmt, rs); //try语句块中执行完毕或发生异常则使用closeAll()关闭所有使用到的数据库连接对象，此处省略this也可以，conn是Connection对象，pstmt是PreparedStatement对象，rs是ResultSet对象
}
return user; //此方法最后返回Users实体类的对象，注：如果方法定义有返回值则一定要加此关键字
}
/**
* 判断数据库中当前用户名是否存在
* @param userName 用户名
* @return 存在返回true,否则返回false
*/
public boolean findUsers(String userName){ //此方法用来查找传入的用户是否存在，返回一个布尔类型的值，true表示存在，false表示不存在
String sql = "select * from users where userName=? "; //定义SQL语句并放入sql变量中，这样的好处是简化了代码的长度和复用的便利
try {
conn = this.getConn(); //用BaseDao类的getConn()方法初始化Connection对象：conn
pstmt = conn.prepareStatement(sql); //用Connection对象的prepareStatement()方法初始化PreparedStatement对象：pstmt
pstmt.setString(1, userName); //设置SQL语句参数1的值：userName
rs = pstmt.executeQuery(); //使用PreparedStatement对象的executeQuery()方法初始化ResultSet对象：rs
if (rs.next()) { //如果数据库中有记录则返回true，此时方法停止
return true;
}
} catch (Exception e) {
e.printStackTrace(); //将错误信息打印到控制台
} finally {
this.closeAll(conn, pstmt, rs); //关闭所有使用到的数据库连接对象，此处可省略this关键字
}
return false; //最后的返回值可以是任意布尔类型的值
}
/**
* 添加用户信息
* @param userName
* @param password
* @return 操作数据库影响行数
*/
public int insertUser(String userName, String password,int status) { //插入一个用户的方法，此方法类的参数跟数据库中强制不为空的列是一一对应的
String sql = "insert into users values(?,?,?) "; //定义SQL语句
String[] params = new String[] { userName, password ,status+""}; //定义字符串数组用来存放传入的参数，因为传入的参数可能不止一个所以定义一个字符串数组来存放，困了余下的代码都差不多所以我简单写了
return this.executeSQL(sql, params);
}
/**
* 查找所有的注册用户信息
* @return 用户列表
*/
public List selectAllUser(){
List list=new ArrayList(); //实例化一个ArrayList对象，因为ArrayList是List对象的子类
String sql = "select * from users ";
try {
conn = this.getConn();
pstmt = conn.prepareStatement(sql);
rs = pstmt.executeQuery();
while(rs.next()) {
Users user = new Users();
user.setUserID(rs.getInt("userID"));
user.setUserName(rs.getString("userName"));
user.setPassword(rs.getString("password"));
user.setStatus(rs.getInt("status"));
list.add(user);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
this.closeAll(conn, pstmt, rs);
}
return list; //此方法返回一个List对象
}
/**
* 根据用户ID,进行删除操作
* @param userID
* @return 执行SQL语句所影响的数据库行数
*/
public int deleteUserByID(String userID){
String sql="delete from users where userID = ? "; //?号表示占位符号此处要用一个变量表示
String[] param = new String[]{ userID };
return this.executeSQL(sql, param);
}
}
//PreaparedStatement和Statement比较而言，PreparedStatement更适合于做修改插入的操作，应为此类是预编译的类，他的执行效率要高于Statement类。而普通的查询则使用Statement就可以了。
//ResultSet是结果集的意思，他用来存放从数据库中读取到的所有数据，他用next()方法来确定下一行是否还有数据，用返回的布尔类型值类表示。使用ResultSet对象的getXX(index)方法获取程序从数据库中读取到的值，index为参数位置，从1开始，1对应数据中第一个字段。
//Connection是连接的意思，他的PreparedStatement和createStatement分别用来初始化PreaparedStatement对象和Statement对象。为SQL语句中的参数赋值用PreparedStatement对象的setXX(index,值)方法，参数位置从1开始递增。
//List是一个接口，ArrayList是实现了List接口的类，也可以其为List的子类，所以List lst=new ArrayList();是一种编译时多态的表现，是完全允许的。其返回的是ArrayList子类的对象。ArrayList一般用来对数据的遍历查询，而LinkedList则比较擅长于增删改，他们都是集合，在此处用来存放实体类的对象。
//try{}catch{}finally{}就不用我多说了吧！用来捕捉容易发生异常的代码段，一些抛出异常的类是要求强制捕捉的，如果不捕捉编辑器会报告一个错误。finally{}块中的代码是无论代码执行正确与否则都会执行，此处用来对数据库连接对象执行关闭操作。
//其实我也是一个初学者，说了这么多也许还有很多没说到的地方，当然这段代码如果要解释完全是要牵扯到很多Java知识，应为篇幅和个人精力和知识量有限，先说到这儿了，各位也请多多包涵，多多指正吧！
package s2jsp.bysj.dao; //这个。。。包名，不解释
import java.sql.Connection; //jdbc的connection，用于取得和数据库的连接
import java.sql.PreparedStatement; //jdbc的PreparedStatement，sql语句就往里面丢
import java.sql.ResultSet; //jdbc的结果集，用于存储结果
import java.util.ArrayList;
import java.util.List;
//上面两个不需要解释吧
import s2jsp.bysj.entity.Users;
//你的POJO
public class UserDao extends BaseDao {
private Connection conn;
private PreparedStatement pstmt;
private ResultSet rs;
/**
* 根据用户名和密码，查找相关用户信息
* @return 用户对象
*/
public Users findUsers(String userName, String password) {
Users user = null;
String sql = "select * from users where userName=? and password=? ";
try {
conn = this.getConn(); //这里是父类BaseDao的getConn（）方法，进去看，估计就是jdbc最最基本的取得数据库连接的代码，驱动啊，方言啊，地址啊，用户名，密码什么的，你懂的。
pstmt = conn.prepareStatement(sql); // 连上数据库后要做事情对吧，这里想做上面那个select * from users where userName=? and password=?
//将select * from users where userName=? and password=?的第一个问号替换成userName
pstmt.setString(1, userName);
//将select * from users where userName=? and password=?的第二个问号替换成password
pstmt.setString(2, password);
//ok，执行，结果就在这个rs里面了
rs = pstmt.executeQuery();
//对结果集rs的迭代，将所有选取出来的object打包成Users对象
if (rs.next()) {
user = new Users();
user.setUserID(rs.getInt("userID"));
user.setUserName(userName);
user.setPassword(password);
user.setStatus(rs.getInt("status"));
}
} catch (Exception e) {
e.printStackTrace();
} finally {
//这个也是父类BaseDAO的方法，要清理垃圾，要回收资源，要绿色的地球
this.closeAll(conn, pstmt, rs);
}
return user;
}
/**
* 判断数据库中当前用户名是否存在
* @param userName 用户名
* @return 存在返回true,否则返回false
*/
public boolean findUsers(String userName){
String sql = "select * from users where userName=? ";
try {
conn = this.getConn();
pstmt = conn.prepareStatement(sql);
//只有一个问号，所以。。。替换一个，为什么总要这样呢？因为可以提高sql语句的命中率，减少硬解析，还可以防止sql注入，这些估计你还不用知道。
pstmt.setString(1, userName);
//一样，运行，execute就是执行的意思，CEO的E就是executive
rs = pstmt.executeQuery();
//查的有数据就返回true，这个方法返回类型是boolean
if (rs.next()) {
return true;
}
} catch (Exception e) {
e.printStackTrace();
} finally {
this.closeAll(conn, pstmt, rs);
//一样，数据库连接是宝贵的资源，父类BaseDAO有自己实现连接池就更nice了
}
return false;
}
/**
* 添加用户信息
* @param userName
* @param password
* @return 操作数据库影响行数
*/
public int insertUser(String userName, String password,int status) {
String sql = "insert into users values(?,?,?) ";
//将参数整成String数组，status+""一处理 int型的status会变成String型
String[] params = new String[] { userName, password ,status+""};
//自己或父类的executeSql方法，应该就是对jdbc的轻度封装，要执行什么语句，按参数要求调这个方法就行了，这里执行一条插入语句
return this.executeSQL(sql, params);
}
/**
* 查找所有的注册用户信息
* @return 用户列表
*/
public List selectAllUser(){
//没什么好说的了吧，选出所有的用户，包装成List返回，没用泛型，你将会看到一堆raw type的黄线，可以不管，但是我们公司这样是不允许的。
List list=new ArrayList();
String sql = "select * from users ";
try {
conn = this.getConn();
pstmt = conn.prepareStatement(sql);
rs = pstmt.executeQuery();
while(rs.next()) {
Users user = new Users();
user.setUserID(rs.getInt("userID"));
user.setUserName(rs.getString("userName"));
user.setPassword(rs.getString("password"));
user.setStatus(rs.getInt("status"));
list.add(user);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
this.closeAll(conn, pstmt, rs);
}
return list;
}
/**
* 根据用户ID,进行删除操作
* @param userID
* @return 执行SQL语句所影响的数据库行数
*/
//一样，按照父类executeSQL的要求，丢参数进去执行删除任务，将userId为参数userID的记录删掉
public int deleteUserByID(String userID){
String sql="delete from users where userID = ? ";
String[] param = new String[]{ userID };
return this.executeSQL(sql, param);
}
}
就是通过数据库来根据用户ID,进行删除操作，查找所有的注册用户信息
添加用户信息
public class UserDao extends BaseDao //继承的父类{
private Connection conn;
private PreparedStatement pstmt;
private ResultSet rs;
/**
* 根据用户名和密码，查找相关用户信息
* @return 用户对象
*/
public Users findUsers(String userName, String password) {
Users user = null;
String sql = "select * from users where userName=? and password=? ";
try {
conn = this.getConn();//调用继承后所拥有的连接数据库的方法
pstmt = conn.prepareStatement(sql);//执行sql语句
pstmt.setString(1, userName);//给参数赋值
pstmt.setString(2, password);
rs = pstmt.executeQuery();//获取结果集
if (rs.next()) {
user = new Users();
user.setUserID(rs.getInt("userID"));
user.setUserName(userName);
user.setPassword(password);
user.setStatus(rs.getInt("status"));//把结果赋给一个Users类的对象
}
} catch (Exception e) {
e.printStackTrace();
} finally {
this.closeAll(conn, pstmt, rs);//关闭连接等
}
return user;
}
/**
* 判断数据库中当前用户名是否存在
* @param userName 用户名
* @return 存在返回true,否则返回false
*/
public boolean findUsers(String userName){
String sql = "select * from users where userName=? ";
try {
conn = this.getConn();
pstmt = conn.prepareStatement(sql);
pstmt.setString(1, userName);
rs = pstmt.executeQuery();
if (rs.next()) {
return true;
}
} catch (Exception e) {
e.printStackTrace();
} finally {
this.closeAll(conn, pstmt, rs);
}
return false;
}
/**
* 添加用户信息
* @param userName
* @param password
* @return 操作数据库影响行数
*/
public int insertUser(String userName, String password,int status) {
String sql = "insert into users values(?,?,?) ";
String[] params = new String[] { userName, password ,status+""};
return this.executeSQL(sql, params);
}
/**
* 查找所有的注册用户信息
* @return 用户列表
*/
public List selectAllUser(){
List list=new ArrayList();
String sql = "select * from users ";
try {
conn = this.getConn();
pstmt = conn.prepareStatement(sql);
rs = pstmt.executeQuery();
while(rs.next()) {
Users user = new Users();
user.setUserID(rs.getInt("userID"));
user.setUserName(rs.getString("userName"));
user.setPassword(rs.getString("password"));
user.setStatus(rs.getInt("status"));
list.add(user);//把赋值完的对象添加到list里
}
} catch (Exception e) {
e.printStackTrace();
} finally {
this.closeAll(conn, pstmt, rs);
}
return list;
}
/**
* 根据用户ID,进行删除操作
* @param userID
* @return 执行SQL语句所影响的数据库行数
*/
public int deleteUserByID(String userID){
String sql="delete from users where userID = ? ";
String[] param = new String[]{ userID };
return this.executeSQL(sql, param);
}
}
也不知道你要怎么注释。。
package s2jsp.bysj.dao;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
import s2jsp.bysj.entity.Users;
public class UserDao extends BaseDao {
private Connection conn; // 数据链接类
private PreparedStatement pstmt; // 与数据库交互的声明
private ResultSet rs; // 数据结果类
/**
* 根据用户名和密码，查找相关用户信息
*
* @return 用户对象
*/
public Users findUsers(String userName, String password) {
Users user = null; // 声明一个空的实体
// sql 语句 : 查询 所有 从 用户表 条件 用户名 = ? 和 密码 = ?
String sql = "select * from users where userName=? and password=? ";
try {
conn = this.getConn(); // 通过 BaseDAO 获取 链接
pstmt = conn.prepareStatement(sql); // 实例声明
pstmt.setString(1, userName); // 给第一个问号赋值
pstmt.setString(2, password); // 给第二个问号赋值
// PreparedStatement 很好的解决了 SQL 注入的问题
rs = pstmt.executeQuery(); // 查询 返回结果
if (rs.next()) { // 如果 有数据结果 就证明已找到匹配的用户
user = new Users(); // 实例 user
user.setUserID(rs.getInt("userID"));
user.setUserName(userName);
user.setPassword(password);
user.setStatus(rs.getInt("status"));
// *********************** 以上给实体设值 *********************** //
}
} catch (Exception e) {
e.printStackTrace(); // 异常处理
} finally { // 最终 一定的执行的 closeAll 方法
this.closeAll(conn, pstmt, rs);
}
return user; // 返回用户实体
}
/**
* 判断数据库中当前用户名是否存在
*
* @param userName
* 用户名
* @return 存在返回true,否则返回false
*/
public boolean findUsers(String userName) {
// sql 语句 : 查询 所有 从 用户表 条件 用户名 = ?
String sql = "select * from users where userName=? ";
try {
conn = this.getConn();
pstmt = conn.prepareStatement(sql);
pstmt.setString(1, userName);
rs = pstmt.executeQuery();
// 以上参考第一个方法注释
if (rs.next()) { // 如果有匹配记录
return true; // 返回 true
}
} catch (Exception e) {
e.printStackTrace();
} finally {
this.closeAll(conn, pstmt, rs);
}
// ****************** 以上太多相同之处参考第一个方法注释 ****************** //
return false;
}
/**
* 添加用户信息
*
* @param userName
* @param password
* @return 操作数据库影响行数
*/
public int insertUser(String userName, String password, int status) {
// sql 语句 : 插入 进 用户表 值( ? , ? , ? )
String sql = "insert into users values(?,?,?) ";
// 字串数组形式的参数
String[] params = new String[] { userName, password, status + "" };
// 自定义方法 , 执行 sql , 在方法内遍历参数赋值
return this.executeSQL(sql, params);
}
/**
* 查找所有的注册用户信息
*
* @return 用户列表
*/
public List selectAllUser() {
// 实例一个列表
List list = new ArrayList();
// SQL 语句：查询 所有 从 用户表
String sql = "select * from users ";
try {
conn = this.getConn();
pstmt = conn.prepareStatement(sql);
rs = pstmt.executeQuery();
// ****** 以上重复参考第一个方法 ******* //
while (rs.next()) { // 循环 数据结果, 将数据赋给新实例的 用户实体, 加进列表
Users user = new Users();
user.setUserID(rs.getInt("userID"));
user.setUserName(rs.getString("userName"));
user.setPassword(rs.getString("password"));
user.setStatus(rs.getInt("status"));
list.add(user);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
this.closeAll(conn, pstmt, rs);
}
// ****************** 以上太多相同之处参考第一个方法注释 ****************** //
return list;
}
/**
* 根据用户ID,进行删除操作
*
* @param userID
* @return 执行SQL语句所影响的数据库行数
*/
public int deleteUserByID(String userID) {
// SQL 语句：删除 从 用户表 条件 用户ID = ?
String sql = "delete from users where userID = ? ";
String[] param = new String[] { userID };
return this.executeSQL(sql, param);
// *************** 以上两句参考插入方法 *************** //
}
}
最后：
希望帮到你，有什么问题Hi我。
内容全部来源于网络收集，如有侵权，请联系网站删除：QQ：24596024