Dao类的设计。
在前面的介绍中，我们在各种action中，好几次提到各种dao类，我们的dao类主要负责数据库的增删查改，我们看看这些dao类是怎么实现的把。
我们先看ArticleDao。
package com.MyBlog.dao;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import com.MyBlog.common.DB;
import com.MyBlog.entity.ArticleBean;
public class ArticleDao {
DB connection =new DB();
ArticleBean articleBean;
/*
* @功能 查询指定类别的文章
* @参数 typeID表示文章类别ID值，type为all时显示所有的记录，为sub时只显示前面的5条记录
* @返回值 List集合
*/
public List queryArticle(int typeID, String type) {
System.out.println("typeID:"+typeID);
System.out.println("type:"+type);
List articleList = new ArrayList();
String sql = "";
// 如果typeID <= 0，不按照类别查询
if(typeID <= 0 ){
if (type == null || type.equals("") || !type.equals("all")) {
// 不按照类别查询，根据发表时间，查询出前面的3条记录
sql = "select * from tb_article order by article_sdTime DESC limit 3";
}
else{
// 不按照类别查询，查询出所有记录
sql = "select * from tb_article order by article_sdTime DESC";
}
}else{
//typeID >0,按照类别进行查询
if (!type.equals("all")) {
// System.out.println("显示该类的前面3条记录");
// 按照类别查询,显示该类的前面3条记录
sql = "select * from tb_article where article_typeID=" + typeID
+ " order by article_sdTime DESC limit 3";
} else {
// 显示该类别所对应的ID 下的所有记录
sql = "select * from tb_article where article_typeID=" + typeID
+ " order by article_sdTime DESC";
}
}
System.out.println(sql);
ResultSet rs = connection.executeQuery(sql);
if (rs != null) {
try {
while (rs.next()) {
// 获取文章信息
articleBean = new ArticleBean();
articleBean.setId(rs.getInt(1));
articleBean.setArticleTypeID(rs.getInt(2));
articleBean.setArticleTitle(rs.getString(3));
articleBean.setArticleContent(rs.getString(4));
articleBean.setArticleSdTime(rs.getString(5));
articleBean.setArticleFrom(rs.getInt(6));
articleBean.setArticleInfo(rs.getString(7));
articleBean.setArticleCount(rs.getInt(8));
articleBean.setMasterID(rs.getInt(9));
// // 查询tb_review数据表统计当前文章的评论数
// sql = "select count(id) from tb_review where review_articleID=" + articleBean.getId();
// ResultSet rsr = connection.executeQuery(sql);
// if (rsr != null) {
// rsr.next();
// articleBean.setReview(rsr.getInt(1));
// rsr.close();
// }
articleList.add(articleBean);
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
try {
rs.close();
} catch (SQLException e) {
e.printStackTrace();
}
connection.closed();
}
}
return articleList;
}
/*
* @功能 实现对文章进行增删改的操作
* @参数 oper为一个String类型变量，用来表示要进行的操作，articleBean为ArticleBean类对象
* 用来存储某个文章信息
* @返回值 Boolean值
*/
public boolean operationArticle(String oper, ArticleBean articleBean) {
//生成sql语句
String sql=null;
//发表文章
if(oper.equals("add")){
sql="insert into tb_article(article_typeID,article_title,article_content,"
+"article_sdTime,article_from,article_info,article_count,article_masterID) values("
+ articleBean.getArticleTypeID()+",'"+articleBean.getArticleTitle()+"','"
+ articleBean.getArticleContent()+"','"+articleBean.getArticleSdTime()+"',"
+ articleBean.getArticleFrom()+",'"+articleBean.getArticleInfo()+"',"
+ articleBean.getArticleCount()+","+articleBean.getMasterID()+")";
System.out.println("add article:"+sql);
}
//修改文章
if(oper.equals("modify")){
sql="update tb_article set article_typeID="+articleBean.getArticleTypeID()
+",article_title='"+articleBean.getArticleTitle()
+"',article_content='"+articleBean.getArticleContent()
+"',article_from='"+articleBean.getArticleFrom()
+"',article_info='"+articleBean.getArticleInfo()
+"' where id="+articleBean.getId();
}
//删除文章
if(oper.equals("delete")){
sql="delete from tb_article where id="+articleBean.getId();
}
//累加阅读次数
if(oper.equals("readTimes")){
int article_count=articleBean.getArticleCount()+1;
sql="update tb_article set article_count="+article_count+" where id="+articleBean.getId();
}
//执行sql语句
boolean flag=connection.executeUpdate(sql);
return flag;
}
/*
* @功能 查询指定文章的详细内容
* @参数 id为文章ID值
* @返回值 ArticleBean类对象，封装了文章信息
*/
public ArticleBean queryArticleByID(int id) {
String sql="select * from tb_article where id="+id;
ResultSet rs=connection.executeQuery(sql);
try {
while(rs.next()){
articleBean=new ArticleBean();
articleBean.setId(rs.getInt(1));
articleBean.setArticleTypeID(rs.getInt(2));
articleBean.setArticleTitle(rs.getString(3));
articleBean.setArticleContent(rs.getString(4));
articleBean.setArticleSdTime(rs.getString(5));
articleBean.setArticleFrom(rs.getInt(6));
articleBean.setArticleInfo(rs.getString(7));
articleBean.setArticleCount(rs.getInt(8));
articleBean.setMasterID(rs.getInt(9));
// //查询tb_review数据表统计当前文章的评论数
// sql="select count(id) from tb_review where review_articleID="+articleBean.getId();
// ResultSet rsr=connection.executeQuery(sql);
// if(rsr!=null){
// rsr.next();
// articleBean.setReview(rsr.getInt(1));
// rsr.close();
// }
}
} catch (SQLException e) {
e.printStackTrace();
}
return articleBean;
}
}
这个ArticleDao有两个成员，一个是DB，一个是articleBean，articleBean就不用说了，是一个文章的类，和数据库的文章表相对应。DB是也给连接数据库的类。
我们来看DB类：
package com.MyBlog.common;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
/*
* 定义DB类，用于数据库的链接
*/
public class DB {
private final String url="jdbc:mysql://localhost:3306/MyBlogDB";
private final String userName="root";
private final String password="";
private Connection con=null;
private Statement stm=null;
/*通过构造方法加载数据库驱动*/
public DB(){
try {
Class.forName("com.mysql.jdbc.Driver");
} catch (ClassNotFoundException e) {
System.out.println("加载数据库驱动驱动失败！！！");
e.printStackTrace();
}
}
/*创建数据库连接*/
public void createCon(){
try {
con=DriverManager.getConnection(url,userName,password);
} catch (SQLException e) {
System.out.println("创建数据库连接失败！！");
e.printStackTrace();
}
}
/*获取数据库连接*/
public Connection getCon(){
try {
con=DriverManager.getConnection(url,userName,password);
} catch (SQLException e) {
System.out.println("获取数据库连接失败！！！");
e.printStackTrace();
}
return con;
}
/*获取Statement对象*/
public void getStm(){
createCon();
try {
stm=con.createStatement();
} catch (SQLException e) {
System.out.println("创建Statement对象失败！！！");
e.printStackTrace();
}
}
/*
* 对数据库进行增加、修改、删除操作
* 参数SQL为要执行的sql语句
* 返回boolean的值
*/
public boolean executeUpdate(String sql){
System.out.println("数据库中正在执行的SQL语句:"+sql);
boolean mark=false;
try {
getStm();
int iCount=stm.executeUpdate(sql);
if(iCount>0){
mark=true;
}else{
mark=false;
}
} catch (SQLException e) {
e.printStackTrace();
mark=false;
}
return mark;
}
/*
*查询数据库
*/
public ResultSet executeQuery(String sql){
ResultSet rs=null;
try {
getStm();
rs=stm.executeQuery(sql);
} catch (SQLException e) {
System.out.println("查询数据库数据失败！！！");
e.printStackTrace();
}
return rs;
}
/*
*关闭数据库的操作
*/
public void closed(){
if(stm!=null){
try {
stm.close();
} catch (SQLException e) {
System.out.println("关闭stm对象失败！！！");
e.printStackTrace();
}
}
if(con!=null){
try {
con.close();
} catch (SQLException e) {
System.out.println("关闭con对象失败");
e.printStackTrace();
}
}
}
}
我们这个DB类的成员有数据库的url，数据库的用户名，数据库的秘密，还有Connection对象和Statement对象。首先，这个DB通过构造函数加载数据库驱动。createCon函数用于进行数据库连接，我们的数据库连接通过DriverManager完成，并返回一个Connection对象，并赋值给DB的Connection对象成员：con.
con=DriverManager.getConnection(url,userName,password);
或者getCon直接返回一个Connection对象，同时也复制给DB的Connection成员，它和createCon的区别是它会返回这个Connection对象。getStm是获取Statement对象的方法，这个对象的获得是先进行数据库的连接，然后由con的createStatement方法获得。
这几个函数就是对数据库的增删查改用的：
1）DB的成员函数excuteUpdate，执行数据库语句，没有返回值的，我们执行数据库语句是由Statement对象来执行的，Statement对象的excuteUpdate方法就是对数据库进行操作，比如增加，删除，修改等等，若是excuteUpdate函数返回-1，则是操作失败，我们返回false，若是操作成功，我们返回true。
2）DB的成员函数excuteQuery，执行数据库的查询，我们的查询也是由Statement对象来查询的，通过执行Statement对象的excuteQuery函数查询，查询返回ResultSet类型的结果，然后我们这个DB的成员函数excuteQuery函数返回ResultSet类型的结果。
3）最后一个是断开数据库连接的函数，我们通过Statement对象执行close方法来关闭Statement对象，con的close方法端口数据库的连接。
在我们的dao类里面，是要调用DB的方法来和数据库操作的。
我们在dao类里面，范式执行什么操作，我们先要设定好sql语句，我们通过以下判断设置这些操作语句。
我们就拿ArticleDao类来说，比如说我们的查询文章，我们在ArticleDao类里面，queryArticle方法是查询文章的，我们有两个参数，一个是typeID，一个是type，如果typeID是-1的话，不按类别查询，那就没有where的判断，然后type是空的话，那么只查询最近的几篇文章，这得加上limit来限制，或type是非空，则查询所有的记录，不加limit。若typeID>0，则按照类别查询，那么就必须用where判断这个类别是否符合要求，typeID就是指定的那个类别的id，然后type如果是空，那么只查询该类别最近的几条记录，用limit来限制，或type非空，查询该类别的所有记录，不用limit。
通过以上的设定，我们总能得出我们想要的那一条sql语句，然后我们通过DB对象connection的excuteQuery(sql)函数来查询，这个sql就是我们在前面通过各种条件判断设置的sql语句。然后这个函数返回的是ResultSet类型的数据。所以我们还要把这个类型的数据取出来，设置到articleBean里面，我们的rs里面的语句可能有很多条，所以我们用while(rs.next())的循环，不断一条一条地读出来。同时我们在这个while循环里面new一个ArticleBean对象，我们在rs里面读出每一条数据，都设置到ArticleBean对象，然后把这个对象添加的articleList容器里面（List articleList = new ArrayList();argicleList是个List容器），最后我们的articleList就存到了很多个ArticleBean对象，都是从rs里面都出来的，这个articleList就是我们这个函数要返回的结果。就这样我们的查询结果出来了。
然后这个ArticleDao类的queryArticle方法就在我们的ArticleAction里面调用，获得我们想要的结果。
除了查询，我们还有一个函数，就是执行sql增删改的函数，operationArticle，这个函数有两个参数，oper和articleBean对象。Oper指定我们是增是删还是改，还有一个对于文章所独有的就是增加阅读次数。和查询那边一样，我们要执行相应的操作前，先设定好sql语句。
下面是操作的几个类型：
1）如果oper是add，那么是增加，我们就执行insert into 语句，因为我们的数据库的article的表是和articlebean对象是对应的，我们就把这个articlebean内容都添加到这个article表中。
2）然后是oper是modify，那么是修改，修改我们执行的是update语句，我们先通过where限定这个的id必须是和articleBean的id是一样的，然后我们再把这个表里面的数据改成和articleBean一样的数据。
3）Oper是delete的话，这个就比较简单了，我们用where来限定这个id就是articleBean的id，我们就删除这个表里面的这一条数据。
4）还有一个oper是readTimes，这个和修改改是是差不多了，只不过我们是吧这个articleBean里面的文章阅读次数加1，然后通过update语句，只修改article_count即文章阅读次数的值。
就这样，我们的sql语句设定好之后，就由DB类的对象connection的excuteUpdate(sql)函数来执行，执行的结果返回一个boolean值，这个值再由operationArticle返回，然后我们的ArticleAction就可以知道这个操作是否成功了。
5）除了以上的几个，我们还有个快速的查询方法，就是queryArticleById，这个直接通过一个id，查询出这个id的文章所有信息。我们的sql语句就直接设定成："select * from tb_article where id="+id;，然后同样有connection对象执行excuteQuery(sql)函数，结果是返回ResultSet类型。
然后我们在通过while(rs.next())循环把这个数据取出来，设置到articleBean里面，由于这里我们查询的结果只有一条数据，所以我们也就不用articleList了，这个循环也只是执行一次就退出了循环。然后我们的整个queryArticleById也只返回这个articleBean就可以了，最后我们的ArticleAcion会得到这个结果。
文章的dao类也就这些查询,至于其它的dao类的查询也是按照这一种方式，设定了可对相应的数据库的增删查改的函数，我们的相应的action类，可根据需要调用不同的函数，传递不同的参数，得到自己想要的结果。