13518219792
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 org.dao;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.Date;
import org.dbc.DBManageer;
import org.dbc.DBUtil;
import org.vo.CardInfo;
public class CardInfoDao {
public void testResultSetMetaData() {
String sql = "select * from cardinfo";
Connection con = new DBUtil().getConnection();
PreparedStatement ps = null;
ResultSetMetaData rsmd = null;
ResultSet rs = null;
try {
ps = con.prepareStatement(sql);
rs = ps.executeQuery();
rsmd = rs.getMetaData();
for (int i = 1; i rsmd.getColumnCount(); i++) {
System.out.print(" 数据类型名:" + rsmd.getColumnClassName(i));
System.out.print(" 别名:" + rsmd.getColumnLabel(i));
System.out.print(" 列名:" + rsmd.getColumnName(i));
System.out.print(" 数据类型:" + rsmd.getColumnTypeName(i));
System.out.println(" 数据类型:" + rsmd.getColumnType(i));
}
while (rs.next()) {
// 通过反射可以对VO对象(CardInfo)自动赋值
// for(...)
// CardInfo ci=new CardInfo();
// ci.setId(rs.getInt(columnIndex))
/*
* CardInfo ca = new CardInfo(); Class cc = ca.getClass();
*/
/*Class? c = Class.forName("org.vo.CardInfo");
CardInfo ca = (CardInfo) c.newInstance();
ca.setCardId(rs.getString("cardId"));
ca.setCustomerName(rs.getString("customerName"));
ca.setCurrentMoney(rs.getFloat("currentMoney"));
ca.setOpenDate(rs.getDate("openDate"));
System.out.println(ca);//ok */
//加载一个CardInfo类
Class c = Class.forName("org.vo.CardInfo");
Object o = c.newInstance(); //获得它的一个实例
//定义String类的对象数组
Class[] params = new Class[] { String.class};
//定义float类的对象数组
Class[] floatparams = new Class[] { float.class};
//定义Date(util)类的对象数组
Class[] dateparams = new Class[] { Date.class};
//获得setCardId方法
Method me = c.getMethod("setCardId", params);
//实例方法的参数
Object []ostr = new Object[]{rs.getString("cardId")};
//如果底层方法是静态的，那么可以忽略指定的 obj 参数。该参数可以为 null。
//如果底层方法所需的形参数为 0，则所提供的 args 数组长度可以为 0 或 null。
//o 调用方法的对象 ostr 方法调用的参数
me.invoke(o, ostr);
//获得setCustomerName方法
Method name = c.getMethod("setCustomerName", params);
Object []cusname = new Object[]{rs.getString("customerName")};
name.invoke(o,cusname);
//获得setCurrentMoney方法
Method money = c.getMethod("setCurrentMoney", floatparams);
Object []cusmoney = new Object[]{rs.getFloat("currentMoney")};
money.invoke(o,cusmoney);
//获得setOpenDate方法
Method date = c.getMethod("setOpenDate",dateparams);
Object []openDate = new Object[]{rs.getDate("openDate")};
date.invoke(o, openDate);
//打印
System.out.println(o);
}
} catch (SQLException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (SecurityException e) {
e.printStackTrace();
}catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
}
public void showResultSet() {
String sql = "select * from cardinfo";
Connection con = new DBManageer().getConnection();
PreparedStatement ps = null;
try {
ps = con.prepareStatement(sql, ResultSet.TYPE_SCROLL_SENSITIVE,
ResultSet.CONCUR_UPDATABLE);
ResultSet rs = ps.executeQuery();
System.out.println("---依次读取------");
while (rs.next()) {
CardInfo ca = new CardInfo();
ca.setCardId(rs.getString("cardId"));
ca.setCustomerName(rs.getString("customerName"));
ca.setCurrentMoney(rs.getFloat("currentMoney"));
ca.setOpenDate(rs.getDate("openDate"));
System.out.println(ca);
}
System.out.println("---倒读------");
while (rs.previous()) {
CardInfo ca = new CardInfo();
ca.setCardId(rs.getString("cardId"));
ca.setCustomerName(rs.getString("customerName"));
ca.setCurrentMoney(rs.getFloat("currentMoney"));
ca.setOpenDate(rs.getDate("openDate"));
System.out.println(ca);
}
rs.absolute(3);// 定位倒第几行
rs.updateString("customerName", "star");
// rs.updateRow();
rs.beforeFirst();
while (rs.next()) {
CardInfo ca = new CardInfo();
ca.setCardId(rs.getString("cardId"));
ca.setCustomerName(rs.getString("customerName"));
ca.setCurrentMoney(rs.getFloat("currentMoney"));
ca.setOpenDate(rs.getDate("openDate"));
System.out.println(ca);
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}
①dao到底是一个类还是一个接口？我看有的程序写成类有的写成接口，到底哪个好？
答：dao通常是设计模式里面的一个名词，在MVC模式里充当的是数据持久层，也称为模型层(M)。所用持术很多，具体可以找一些设计模式的资料查看，目前市场上最流行的M层的两个技术是ibatis、hibernate框架。要区分类和接口很简，直接看类名前面的关键字“class”是一个类，“interface”是一个接口。到底哪个好就要看项目的设计了，一般大型的项目都用接口，接口方便括展。
②这是书上的一段代码，我想知道怎么只有setter没有getter？
答：如果使用spring管理been，set方法是spring依赖注入所必需的方法，setter用于设置值，getter用于取值。
③return的返回值如果是注释的方法会怎样？二者有什么区别？
答：无意义代码。无需纠结。如果非要说会怎么样，按照代码逻辑，会返回“0”。区别在于，注释那句返回“0”，下面那句执行查询sql返回查询结果。
④还是return返回值：new Object[]{userName,password}里的大括号是什么？以前没见过这么写代码，请大神解释！
答：Object[]是一个Object类型的一维数组，大括号里面是给数组赋的两个初始值，object[0]=userName,object[1]=password。如果不清楚可以看看数组的语法结构。
希望可以帮到你。
你好，dao层统一写，具体的业务写在service层中。因为你还可能有判断登录，注册，他们的实现是不一样的。下面给出一个dao的例子：
package org.fit.dao;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.fit.ex.SysException;
public class Dao {
private static final String DRIVER=
"com.mysql.jdbc.Driver";
private static final String URL=
"jdbc:mysql://localhost:3306/cateweb";
private static final String USER="root";
private static final String PASSWORD="0";
public Dao() throws SysException{
try {
Class.forName(DRIVER);
} catch (ClassNotFoundException e) {
e.printStackTrace();
throw new SysException("驱动没有找到！") ;
}
}
private Connection conn;
private PreparedStatement pt;
private ResultSet rs;
public ResultSet query(String sql,Object... paramValues)
throws SQLException{
try {
conn=DriverManager.getConnection(URL,USER,PASSWORD);
pt=conn.prepareStatement(sql);
if(paramValues!=null){
for(int i=0;iparamValues.length;i++){
pt.setObject(i+1, paramValues[i]);
}
}
rs=pt.executeQuery();
return rs;
} catch (SQLException e) {
e.printStackTrace();
this.close();
throw e;
}
}
public int update(String sql,Object... paramValues)
throws SQLException{
try{
conn=DriverManager.getConnection(URL,USER,PASSWORD);
pt=conn.prepareStatement(sql);
if(paramValues!=null){
for(int i=0;iparamValues.length;i++){
pt.setObject(i+1, paramValues[i]);
}
}
return pt.executeUpdate();
}finally{
this.close();
}
}
public void close(){
try {
if(rs!=null){
rs.close();
}
} catch (Exception e) {}
rs=null;
try {
if(pt!=null){
pt.close();
}
} catch (Exception e) {}
pt=null;
try {
if(conn!=null){
if(!conn.isClosed())conn.close();
}
} catch (Exception e) {}
conn=null;
}
}
DAO类都是进行数据操作的类，
是对于数据库中的数据做增删改查等操作的代码。
DAO(DataAccessObject)数据访问对象是一个面向对象的数据库接口，它显露了MicrosoftJet数据库引擎（由MicrosoftAccess所使用），并允许VisualBasic开发者通过ODBC像直接连接到其他数据库一样，直接连接到Access表。DAO最适用于单系统应用程序或小范围本地分布使用。
DAO层一般有接口和该接口的实现类，接口用于规范实现类，实现类一般用于用于操作数据库！一般操作修改，添加，删除数据库操作的步骤很相似，就写了一个公共类DAO类，修改，添加，删除数据库操作时直接调用公共类DAO类。
扩展资料:
DAO(DataAccessObject)是一个数据访问接口，数据访问：顾名思义就是与数据库打交道。夹在业务逻辑与数据库资源中间。
在核心J2EE模式中是这样介绍DAO模式的：为了建立一个健壮的J2EE应用，应该将所有对数据源的访问操作抽象封装在一个公共API中。用程序设计的语言来说，就是建立一个接口，接口中定义了此应用程序中将会用到的所有事务方法。在这个应用程序中，当需要和数据源进行交互的时候则使用这个接口，并且编写一个单独的类来实现这个接口在逻辑上对应这个特定的数据存储。
访问对象
DAO（数据访问对象）是一种应用程序编程接口（API），存在于微软的VisualBasic中，它允许程序员请求对微软的Access数据库的访问。DAO是微软的第一个面向对象的数据库接口。DAO对象封闭了Access的Jet函数。通过Jet函数，它还可以访问其他的结构化查询语言（SQL）数据库。
参考资料:百度百科-dao
