一、工具
STS,和MySQL数据库
二、系统分析：
需求概述
论坛即BBS，全称为Bulletin Board System。它是互联网上常见的一种交互性强、内容丰富的信息服务系统，每个用户都可以在上面浏览和发布信息。
早期的BBS与一般街头和校园内的公告板性质相同，只不过是用来传播或获得消息而已。普及之后，BBS的功能得到了很大的扩充。目前，通过BBS我们可以随时获取各种最新的信息，例如求职招聘、二手交易、交友娱乐等等，更可以召集亲朋好友一起高谈阔论。论坛拉近了我们的距离，使彼此素不相识的人可以在一起讨论问题、共享资源。
为了能更方便得帮助师生在课下讨论问题、共享资源，我们现在需要开发一个基于控制台的学校论坛系统。通过这个系统，学生可以很方便的提出自己在学习过程中遇到的问题，老师可以很方便的进行解答，大家还可以就学习方法进行分享和讨论
结合上面的用例图，在这个项目中我们需要实现的功能可以分为以下两大块：
- 管理员：登录、用户管理（查看和禁用）、版块管理（查看和增加）、主帖管理（查看和删除）、统计汇总（活跃用户和版块总贴数）。
- 普通用户：注册、登录、发帖、回帖。
下面我们把其中一些稍微复杂的功能做进一步的说明。
- 不管是普通用户还是管理员都需要进行登录，所以在实现登录功能时，需要注意判断对方是管理员还是普通用户，这里要求使用存储过程实现。
- 在实现删除主帖时需要注意的是：某个主帖可能有很多回帖，这时需要先删除这个主帖的所有回帖，然后才能删除主帖。同时考虑到数据的一致性，这个地方需要使用JDBC事务进行处理。
- 对于统计汇总功能，由于实现单独一个功能所需要的SQL语句不止一条，所以这里要求使用存储过程来实现。
- 由于本项目是控制台程序，所以用户在使用这个程序时需要很多菜单导航来一步一步进行操作，这时我们可以单独设计一个类来实现程序中所有的菜单导航。
- 数据库设计
根据上述需求描述和功能分析设计出以下四个表。
表11-1 用户表（user）
| 列名 | 数据类型 | 是否为空 | 说明 |
| uId | int | 否 | 用户ID，自动编号，主键 |
| uName | varchar(20) | 否 | 用户昵称 |
| uPass | varchar(20) | 否 | 用户密码 |
| state | int | 否 | 用户状态，0表示正常，1表示禁用 |
| flag | int | 否 | 用户标识，0表示管理员，1表示用户 |
表11-2 版块表（board）
| 列名 | 数据类型 | 是否为空 | 说明 |
| bId | int | 否 | 版块ID，自动编号，主键 |
| bName | varchar(50) | 否 | 版块名字 |
表11-3 主贴表（topic）
| 列名 | 数据类型 | 是否为空 | 说明 |
| tId | int | 否 | 主帖ID，自动编号，主键 |
| title | varchar(50) | 否 | 主帖标题 |
| context | varchar(1000) | 否 | 主帖内容 |
| pTime | datetime | 否 | 发帖时间 |
| uId | int | 否 | 发帖人，外键，引用user表主键 |
| bId | int | 否 | 所属版块，外键，引用board表主键 |
表11-4 回帖表（reply）
| 列名 | 数据类型 | 是否为空 | 说明 |
| rId | int | 否 | 回帖ID，自动编号，主键 |
| title | varchar(50) | 否 | 回帖标题 |
| context | varchar(1000) | 否 | 回帖内容 |
| pTime | datetime | 否 | 回帖时间 |
| uId | int | 否 | 回帖人，外键，引用user表主键 |
| tId | int | 否 | 所属主帖，外键，引用topic表主键 |
对于这个校园论坛系统（BBS）系统，有四个表，所以对应的就应该有四个实体类，我们先写实体类，分别是用户类User，主贴类Title，板块类Board,回帖类Reply，我们把这四个实体类放到同一个包entity（实体）中。这样分类放，方便管理
package com.xintouyun.bbs.entity;
//用户类User
public class User {
private int uid;
private String uname;
private String upass;
private int state;
private int flag;
//private UserState userState;
//public UserState getUserState() {
//return userState;
//}
//public void setUserState(UserState userState) {
//this.userState = userState;
//}
public int getUid() {
return uid;
}
public void setUid(int uid) {
this.uid = uid;
}
public String getUname() {
return uname;
}
public void setUname(String uname) {
this.uname = uname;
}
public String getUpass() {
return upass;
}
public void setUpass(String upass) {
this.upass = upass;
}
public int getState() {
return state;
}
public void setState(int state) {
this.state = state;
}
public int getFlag() {
return flag;
}
public void setFlag(int flag) {
this.flag = flag;
}
}
package com.xintouyun.bbs.entity;
//主贴类
public class Topic {
private int tid;
private String title;
private String context;
private String ptime;
private int uid;
private int bid;
private String bname;
private String uname;
public String getBname() {
return bname;
}
public void setBname(String bname) {
this.bname = bname;
}
public String getUname() {
return uname;
}
public void setUname(String uname) {
this.uname = uname;
}
public int getTid() {
return tid;
}
public void setTid(int tid) {
this.tid = tid;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getContext() {
return context;
}
public void setContext(String context) {
this.context = context;
}
public String getPtime() {
return ptime;
}
public void setPtime(String ptime) {
this.ptime = ptime;
}
public int getUid() {
return uid;
}
public void setUid(int uid) {
this.uid = uid;
}
public int getBid() {
return bid;
}
public void setBid(int bid) {
this.bid = bid;
}
}
package com.xintouyun.bbs.entity;
//回帖类
public class Reply {
private int rid;
private String title;
private String context;
private String ptime;
private int uid;
private int tid;
public int getRid() {
return rid;
}
public void setRid(int rid) {
this.rid = rid;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getContext() {
return context;
}
public void setContext(String context) {
this.context = context;
}
public String getPtime() {
return ptime;
}
public void setPtime(String ptime) {
this.ptime = ptime;
}
public int getUid() {
return uid;
}
public void setUid(int uid) {
this.uid = uid;
}
public int getTid() {
return tid;
}
public void setTid(int tid) {
this.tid = tid;
}
}
package com.xintouyun.bbs.entity;
//版块类
public class Board {
private int bid;
private String bname;
public int getBid() {
return bid;
}
public void setBid(int bid) {
this.bid = bid;
}
public String getBname() {
return bname;
}
public void setBname(String bname) {
this.bname = bname;
}
}
连接数据库的过程有过多重复代码，我们可以吧他封装成一个工具类JdbcUtil(我这里连接的是本地的mysql数据库，本文使用的数据库名字叫bbs，里面有四个表user，topic，board，reply)
package com.xintouyun.bbs.util;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public final class JdbcUtil {
private static String DRIVER_CLASS = "com.mysql.jdbc.Driver";
private static String URL="jdbc:mysql:///bbs";//连接本地mysql数据库，然后连接bbs数据库
private static String USER = "root";
private static String PASSWORD = "123456";
//封装加载驱动
static {
try {
Class.forName(DRIVER_CLASS);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
//封装连接数据库
public static Connection getConnection() {
try {
return DriverManager.getConnection(URL, USER, PASSWORD);
} catch (SQLException e) {
e.printStackTrace();
}
return null;
}
//封装关闭数据库连接
public static void closeAll(ResultSet rs, Statement st, Connection conn) {
try {
if (rs != null)
rs.close();
if (st != null)
st.close();
if (conn != null)
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
二、系统大致分层
1.Dao层:对数据库中内容进行存取操作
首先是Dao层的接口，我们可以先把要实现的功能给列出来，然后通过接口把这些方法声明出来。为什么要用接口而不直接写实现类呢，这就涉及到了面型接口编程，在实际开发中我们可能没有过多的时间去写实现方法，所以可以先通过接口把方法的名称，参数，返回值类型定义出来，这样其他人就可以通过写的接口帮你写实现类，这样写出来可以保证我们的代码是可以互相拿来用的。另外接口也可以使我们的程序具有良好的可扩展性，一个接口可以通过不同的实现方法来实现，这样利于我们后期的维护。
package com.xintouyun.bbs.dao;
import java.util.List;
import com.xintouyun.bbs.entity.User;
public interface UserDao {
/**
* 根据用户名和密码查询
* @param uname
* @param upass
* @return 数据表中有一条记录返回一个user对象，否则返回null
*/
User queryByUnameAndUpass(String uname,String upass);
/**
* 保存一个用户对象
* @param user
* @return 返回受影响行数
*/
int saveUser(User user);
/**
* 根据用户状态筛选
* @param state
* @return 返回符合条件的对象集合
*/
List <User> listByState(int state);
/**
* 修改用户状态，禁用用户
* @param uid
* @return 返回受影响行数
*/
int DisableUser(int uid);
}
package com.xintouyun.bbs.dao;
import java.util.List;
import com.xintouyun.bbs.entity.Reply;
import com.xintouyun.bbs.entity.Topic;
public interface TopicDao {
/**
* 查看所有主贴
* @return 对象集合
*/
List <Topic> listTopic();
/**
* 查看指定板块下所有主贴
* @param bid
* @return 对象集合
*/
List <Topic> listTopic(int bid);
/**
* 添加一个主贴
* @param topic
* @return 返回受影响行数
*/
int saveTopic(Topic topic);
/**
* 根据主贴id删除
* @param tid
* @return 返回受影响行数
*/
int deleteTopic(int tid);
/**
* 根据板块编号统计主贴条数
* @param bid 板块编号
* @return 主贴条数
*/
int countByBid(int bid);
/**
* 显示最近发帖活跃的用户
* @return
*/
List<String> listActiveUsers();
/**
* 根据回帖查看主贴是否存在
* @param reply
* @return
*/
boolean findTopicByTid(int tid);
}
package com.xintouyun.bbs.dao;
import java.util.List;
import com.xintouyun.bbs.entity.Reply;
public interface ReplyDao {
/**
* 添加回帖对象
* @param reply
* @return 返回受影响行数
*/
int saveReply(Reply reply);
/**
* 根据主贴号列出其所有回帖
* @param tid
* @return
*/
List <Reply> queryReplyByTid(int tid);
/**
* 根据主贴号删除回帖
* @param tid
* @return 返回受影响行数
*/
int deleteByTid(int tid);
}
package com.xintouyun.bbs.dao;
import java.util.List;
import com.xintouyun.bbs.entity.Board;
public interface BoardDao {
/**
* 列出所有版块
* @return 对象集合
*/
List <Board> listBoard();
/**
* 保存一个版块对象
* @param board
* @return 返回受影响行数
*/
int saveBoard(Board board);
}
然后我们写实现类来实现这些功能
package com.xintouyun.bbs.dao.impl;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
import com.xintouyun.bbs.dao.UserDao;
import com.xintouyun.bbs.entity.User;
import com.xintouyun.bbs.entity.UserState;
import com.xintouyun.bbs.util.JdbcUtil;
public class UserDaoImpl implements UserDao{
@Override
public User queryByUnameAndUpass(String uname, String upass) {
// TODO Auto-generated method stub
Connection conn = null;
PreparedStatement st = null;
ResultSet rs = null;
User user=null;
try {
conn = JdbcUtil.getConnection();
st = conn.prepareStatement("select * from user where uname=? and upass=? and state=0" );
st.setString(1, uname);
st.setString(2, upass);
rs=st.executeQuery();
while(rs.next()) {
user=new User();
user.setUid(rs.getInt("uid"));
user.setUname(rs.getString("uname"));
user.setUpass(rs.getString("upass"));
user.setState(rs.getInt("state"));
user.setFlag(rs.getInt("flag"));
}
} catch (Exception e) {
e.printStackTrace();
} finally {
JdbcUtil.closeAll(rs, st, conn);
}
return user;
}
@Override
public int saveUser(User user) {
// TODO Auto-generated method stub
Connection conn = null;
PreparedStatement st = null;
ResultSet rs = null;
int affectedRow = 0;
try {
conn = JdbcUtil.getConnection();
st = conn.prepareStatement("insert into user(uname,upass,state,flag) values(?,?,0,1)");
st.setString(1, user.getUname());
st.setString(2, user.getUpass());
/*st.setInt(3, user.getState());
st.setInt(4, user.getFlag());*/
affectedRow = st.executeUpdate();
} catch (Exception e) {
e.printStackTrace();
} finally {
JdbcUtil.closeAll(rs, st, conn);
}
return affectedRow;
}
@Override
public List<User> listByState(int state) {
// TODO Auto-generated method stub
Connection conn = null;
PreparedStatement st = null;
ResultSet rs = null;
List<User> list=new ArrayList<User>();
User user=null;
//UserState userstate=null;
try {
conn = JdbcUtil.getConnection();
st=conn.prepareStatement("select * from user u,userstate us where u.state=us.id and u.state=?");
//st = conn.prepareStatement("select * from user where state=?");
st.setInt(1, state);
rs=st.executeQuery();
while(rs.next()) {
user=new User();
user.setUid(rs.getInt("uid"));
user.setUname(rs.getString("uname"));
user.setUpass(rs.getString("upass"));
user.setState(rs.getInt("state"));
user.setFlag(rs.getInt("flag"));
//
UserState userState = new UserState();
userState.setName(rs.getString("name"));
userState.setId(rs.getInt("id"));
user.setUserState(userState);
list.add(user);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
JdbcUtil.closeAll(rs, st, conn);
}
return list;
}
@Override
public int DisableUser(int uid) {
// TODO Auto-generated method stub
Connection conn = null;
PreparedStatement st = null;
ResultSet rs = null;
int affectedRow = 0;
try {
conn = JdbcUtil.getConnection();
st = conn.prepareStatement("update user set state=1 where uid=?");
st.setInt(1, uid);
st.executeUpdate();
affectedRow = st.executeUpdate();
} catch (Exception e) {
e.printStackTrace();
} finally {
JdbcUtil.closeAll(rs, st, conn);
}
return affectedRow;
}
}
package com.xintouyun.bbs.dao.impl;
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.xintouyun.bbs.dao.TopicDao;
import com.xintouyun.bbs.entity.Reply;
import com.xintouyun.bbs.entity.Topic;
import com.xintouyun.bbs.util.JdbcUtil;
public class TopicDaoImpl implements TopicDao{
@Override
public List<Topic> listTopic() {
// TODO Auto-generated method stub
Connection conn = null;
PreparedStatement st = null;
ResultSet rs = null;
List <Topic> list=new ArrayList<Topic>();
Topic topic=null;
try {
conn = JdbcUtil.getConnection();
//st = conn.prepareStatement("select * from topic");
st=conn.prepareStatement("select b.bid,b.bname,t.tid,t.title,t.context,t.ptime,u.uid,u.uname from board b,topic t,user u where u.uid=t.uid and b.bid=t.bid");
rs=st.executeQuery();
while(rs.next()) {
topic=new Topic();
topic.setBid(rs.getInt("bid"));
topic.setTitle(rs.getString("title"));
topic.setContext(rs.getString("context"));
topic.setPtime(rs.getString("ptime"));
topic.setUid(rs.getInt("uid"));
topic.setTid(rs.getInt("tid"));
topic.setBname(rs.getString("bname"));
topic.setUname(rs.getString("uname"));
list.add(topic);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
JdbcUtil.closeAll(rs, st, conn);
}
return list;
}
@Override
public List<Topic> listTopic(int bid) {
// TODO Auto-generated method stub
Connection conn = null;
PreparedStatement st = null;
ResultSet rs = null;
List <Topic> list=new ArrayList<Topic>();
Topic topic=null;
try {
conn = JdbcUtil.getConnection();
st = conn.prepareStatement("select b.bid,b.bname,t.tid,t.title,t.context,t.ptime,u.uid,u.uname from board b,topic t,user u where u.uid=t.uid and b.bid=t.bid group by b.bid having b.bid=?" );
st.setInt(1, bid);
rs=st.executeQuery();
while(rs.next()) {
topic=new Topic();
topic.setBid(rs.getInt("bid"));
topic.setTitle(rs.getString("title"));
topic.setContext(rs.getString("context"));
topic.setPtime(rs.getString("ptime"));
topic.setUid(rs.getInt("uid"));
topic.setTid(rs.getInt("tid"));
topic.setBname(rs.getString("bname"));
topic.setUname(rs.getString("uname"));
list.add(topic);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
JdbcUtil.closeAll(rs, st, conn);
}
return list;
}
@Override
public int saveTopic(Topic topic) {
Connection conn = null;
PreparedStatement st = null;
ResultSet rs = null;
int affectedRow = 0;
try {
conn = JdbcUtil.getConnection();
st = conn.prepareStatement("insert into topic(title,context,ptime,uid,bid) values(?,?,now(),?,?)");
st.setString(1, topic.getTitle());
st.setString(2, topic.getContext());
st.setInt(3, topic.getUid());
st.setInt(4, topic.getBid());
affectedRow=st.executeUpdate();
} catch (Exception e) {
e.printStackTrace();
} finally {
JdbcUtil.closeAll(rs, st, conn);
}
return affectedRow;
}
@SuppressWarnings("resource")
public int deleteTopic(int tid) {
Connection conn = null;
PreparedStatement st = null;
ResultSet rs = null;
Reply reply=null;
List <Reply> list=new ArrayList<Reply>();
int affectedRow = 0;
try {
conn = JdbcUtil.getConnection();
conn.setAutoCommit(false);
st = conn.prepareStatement("select * from reply where tid=?");
st.setInt(1, tid);
rs=st.executeQuery();
while(rs.next()) {
reply=new Reply();
reply.setTitle(rs.getString("title"));
reply.setContext(rs.getString("context"));
reply.setPtime(rs.getString("ptime"));
reply.setUid(rs.getInt("uid"));
reply.setTid(rs.getInt("tid"));
list.add(reply);
}
st = conn.prepareStatement("delete from reply where tid=?");
st.setInt(1, tid);
st.executeUpdate();
//int i=5/0;*/
st = conn.prepareStatement("delete from topic where tid=?");
st.setInt(1, tid);
affectedRow=st.executeUpdate();
conn.commit();
} catch (Exception e) {
e.printStackTrace();
try {
conn.rollback();
} catch (SQLException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
} finally {
JdbcUtil.closeAll(rs, st, conn);
}
return affectedRow;
}
@Override
public int countByBid(int bid) {
Connection conn = null;
PreparedStatement st = null;
ResultSet rs = null;
int affectedRow = 0;
try {
conn = JdbcUtil.getConnection();
st = conn.prepareStatement("select count(*) from topic where bid=?");
st.setInt(1, bid);
rs=st.executeQuery();
while(rs.next()) {
affectedRow=rs.getInt("count(*)");
}
} catch (Exception e) {
e.printStackTrace();
} finally {
JdbcUtil.closeAll(rs, st, conn);
}
return affectedRow;
}
@Override
public List<String> listActiveUsers() {
Connection conn = null;
PreparedStatement st = null;
ResultSet rs = null;
List <String> list=new ArrayList<String>();
try {
conn = JdbcUtil.getConnection();
st = conn.prepareStatement("select uid from topic");
rs=st.executeQuery();
while(rs.next()) {
String uid=rs.getString("uid");
list.add(uid);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
JdbcUtil.closeAll(rs, st, conn);
}
return list;
}
@Override
public boolean findTopicByTid(int tid) {
Connection conn = null;
PreparedStatement st = null;
ResultSet rs = null;
boolean flag=false;
try {
conn = JdbcUtil.getConnection();
st = conn.prepareStatement("select * from topic where tid=?");
st.setInt(1, tid);
rs=st.executeQuery();
while(rs.next()) {
flag=true;
}
} catch (Exception e) {
e.printStackTrace();
} finally {
JdbcUtil.closeAll(rs, st, conn);
}
return flag;
}
}
package com.xintouyun.bbs.dao.impl;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
import com.xintouyun.bbs.dao.ReplyDao;
import com.xintouyun.bbs.entity.Reply;
import com.xintouyun.bbs.util.JdbcUtil;
public class ReplyDaoImpl implements ReplyDao {
@Override
public int saveReply(Reply reply) {
// TODO Auto-generated method stub
Connection conn = null;
PreparedStatement st = null;
ResultSet rs = null;
int affectedRow = 0;
try {
conn = JdbcUtil.getConnection();
st = conn.prepareStatement("insert into reply(title,context,ptime,uid,tid) values(?,?,now(),?,?) ");
st.setString(1, reply.getTitle());
st.setString(2, reply.getContext());
st.setInt(3, reply.getUid());
st.setInt(4, reply.getTid());
affectedRow=st.executeUpdate();
} catch (Exception e) {
e.printStackTrace();
} finally {
JdbcUtil.closeAll(rs, st, conn);
}
return affectedRow;
}
@Override
public List<Reply> queryReplyByTid(int tid) {
// TODO Auto-generated method stub
Connection conn = null;
PreparedStatement st = null;
ResultSet rs = null;
List <Reply> list=new ArrayList<Reply>();
Reply reply=null;
try {
conn = JdbcUtil.getConnection();
st = conn.prepareStatement("select * from reply where tid=?");
st.setInt(1, tid);
rs=st.executeQuery();
while(rs.next()) {
reply=new Reply();
reply.setTitle(rs.getString("title"));
reply.setContext(rs.getString("context"));
reply.setPtime(rs.getString("ptime"));
reply.setUid(rs.getInt("uid"));
reply.setTid(rs.getInt("tid"));
list.add(reply);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
JdbcUtil.closeAll(rs, st, conn);
}
return list;
}
@Override
public int deleteByTid(int tid) {
// TODO Auto-generated method stub
Connection conn = null;
PreparedStatement st = null;
ResultSet rs = null;
int affectedRow = 0;
try {
conn = JdbcUtil.getConnection();
st = conn.prepareStatement("delete from reply where tid=?");
st.setInt(1, tid);
affectedRow=st.executeUpdate();
} catch (Exception e) {
e.printStackTrace();
} finally {
JdbcUtil.closeAll(rs, st, conn);
}
return affectedRow;
}
}
package com.xintouyun.bbs.dao.impl;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
import com.xintouyun.bbs.dao.BoardDao;
import com.xintouyun.bbs.entity.Board;
import com.xintouyun.bbs.util.JdbcUtil;
public class BoardDaoImpl implements BoardDao{
@Override
public List<Board> listBoard() {
// TODO Auto-generated method stub
Connection conn = null;
PreparedStatement st = null;
ResultSet rs = null;
List <Board> list=new ArrayList<Board>();
Board board=null;
try {
conn = JdbcUtil.getConnection();
st = conn.prepareStatement("select * from board");
rs=st.executeQuery();
while(rs.next()) {
board=new Board();
board.setBid(rs.getInt("bid"));
board.setBname(rs.getString("bname"));
list.add(board);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
JdbcUtil.closeAll(rs, st, conn);
}
return list;
}
@Override
public int saveBoard(Board board) {
// TODO Auto-generated method stub
Connection conn = null;
PreparedStatement st = null;
ResultSet rs = null;
int affectedRow = 0;
try {
conn = JdbcUtil.getConnection();
st = conn.prepareStatement("insert into board(bname) values(?)");
st.setString(1, board.getBname());
affectedRow=st.executeUpdate();
} catch (Exception e) {
e.printStackTrace();
} finally {
JdbcUtil.closeAll(rs, st, conn);
}
return affectedRow;
}
}
2.业务层:制作相应的函数，实现相应的业务需求
同样业务层我们也是先写接口来定义这些业务的方法：
package com.xintouyun.bbs.service;
import java.util.List;
import com.xintouyun.bbs.entity.User;
public interface UserService {
/**
* 查询禁用用户
* @return 用户列表
*/
List<User> showDisabledUsers(int state);
/**
* 查询正常用户
* @return 用户列表
*/
List<User> showEnabledUsers(int state);
/**
* 禁用指定用户
* @param uid 用户编号
* @return true成功，false失败
*/
boolean disableUser(int uid);
}
package com.xintouyun.bbs.service;
import java.util.List;
import com.xintouyun.bbs.entity.Reply;
import com.xintouyun.bbs.entity.Topic;
public interface TopicService {
/**
* 查看所有主贴
* @return 主贴集合
*/
List<Topic> showAllTopic();
/**
* 查看指定板块下主贴
* @param bid
* @return 主贴集合
*/
List<Topic> showAllTopic(int bid);
/**
* 根据主贴号删除主贴
* @param tid
* @return 成功返回true,否则返回false
*/
boolean deleteTopic(int tid);
/**
* 查询主贴的所有回帖
* @param tid
* @return 主贴的所有回帖的集合
*/
List<Reply> queryReplyByTid(int tid);
/**
* 根据主贴删除所有回帖
* @param tid 主贴号
* @return 删除成功返回true，否则返回false
*/
boolean deleteReplyByTid(int tid);
/**
* 根据版块统计主贴数目
* @param bid
* @return
*/
int countByBid(int bid);
/**
* 获取所有主贴的uid
* @return
*/
List<String> countActiveUser();
}
package com.xintouyun.bbs.service;
public interface CountService {
/**
* 统计某个版块帖子总数
* @param bid 版块号
* @return 帖子总数
*/
int countAllTopicNum(int bid);
}
package com.xintouyun.bbs.service;
import java.util.List;
import com.xintouyun.bbs.entity.Board;
public interface Boardservice {
/**
* 查询版块
* @return 返回版块对象集合
*/
List<Board> showAllBoard();
/**
* 添加版块
* @param board
* @return 添加成功返回true，添加失败返回false
*/
boolean addBoard(Board board);
}
package com.xintouyun.bbs.service;
import com.xintouyun.bbs.entity.Reply;
import com.xintouyun.bbs.entity.Topic;
import com.xintouyun.bbs.entity.User;
public interface BaseService {
/**
* 登录
* @param uname 用户名
* @param upass 密码
* @return 成功返回User，失败返回null
*/
User checkLogin(String uname,String upass) ;
/**
* 注册用户
* @param user 用户对象
* @return 成功返回true，失败返回false
*/
boolean register(User user);
/**
* 发帖
* @param topic
* @return 成功返回true，失败返回false
*/
boolean post(Topic topic);
/**
* 回復帖子
* @param reply
* @return 成功返回true，失败返回false
*/
boolean rePost(Reply reply,int tid);
}
接口写完我们来写一下实现类：
package com.xintouyun.bbs.service.impl;
import java.util.List;
import com.xintouyun.bbs.dao.impl.UserDaoImpl;
import com.xintouyun.bbs.entity.User;
import com.xintouyun.bbs.service.UserService;
public class UserServiceImpl implements UserService{
UserDaoImpl udi=new UserDaoImpl();
@Override
public List<User> showDisabledUsers(int state) {
List<User> list=udi.listByState(1);
return list;
}
@Override
public List<User> showEnabledUsers(int state) {
List<User> list=udi.listByState(0);
return list;
}
@Override
public boolean disableUser(int uid) {
return udi.DisableUser(uid)>0;
}
}
package com.xintouyun.bbs.service.impl;
import java.util.List;
import com.xintouyun.bbs.dao.impl.ReplyDaoImpl;
import com.xintouyun.bbs.dao.impl.TopicDaoImpl;
import com.xintouyun.bbs.entity.Reply;
import com.xintouyun.bbs.entity.Topic;
import com.xintouyun.bbs.service.TopicService;
public class TopicServiceImpl implements TopicService {
TopicDaoImpl tdi=new TopicDaoImpl();
ReplyDaoImpl rdi=new ReplyDaoImpl();
@Override
public List<Topic> showAllTopic() {
List<Topic> list=tdi.listTopic();
return list;
}
@Override
public List<Topic> showAllTopic(int bid) {
List<Topic> list=tdi.listTopic(bid);
return list;
}
@Override
public boolean deleteTopic(int tid) {
return tdi.deleteTopic(tid)>0;
}
@Override
public boolean deleteReplyByTid(int tid) {
return rdi.deleteByTid(tid)>0;
}
@Override
public List<Reply> queryReplyByTid(int tid) {
List<Reply> list=rdi.queryReplyByTid(tid);
return list;
}
@Override
public int countByBid(int bid) {
int count=tdi.countByBid(bid);
return count;
}
@Override
public List<String> countActiveUser() {
List<String> list=tdi.listActiveUsers();
return list;
}
}
package com.xintouyun.bbs.service.impl;
import java.util.List;
import com.xintouyun.bbs.dao.impl.TopicDaoImpl;
import com.xintouyun.bbs.entity.User;
import com.xintouyun.bbs.service.CountService;
public class CountServiceImpl implements CountService {
TopicDaoImpl tdi=new TopicDaoImpl();
@Override
//查询某个版块中的主贴数
public int countAllTopicNum(int bid) {
int i=tdi.countByBid(bid);
return i;
}
//查询最近三个月最活跃用户前三名
public List<User> countActiveUser(){
return null;
}
}
package com.xintouyun.bbs.service.impl;
import java.util.List;
import com.xintouyun.bbs.dao.impl.BoardDaoImpl;
import com.xintouyun.bbs.entity.Board;
import com.xintouyun.bbs.service.Boardservice;
public class BoardServiceImpl implements Boardservice {
BoardDaoImpl bdi=new BoardDaoImpl();
@Override
public List<Board> showAllBoard() {
List<Board> list=bdi.listBoard();
return list;
}
@Override
public boolean addBoard(Board board) {
return bdi.saveBoard(board)>0;
}
}
package com.xintouyun.bbs.service.impl;
import com.xintouyun.bbs.dao.impl.ReplyDaoImpl;
import com.xintouyun.bbs.dao.impl.TopicDaoImpl;
import com.xintouyun.bbs.dao.impl.UserDaoImpl;
import com.xintouyun.bbs.entity.Reply;
import com.xintouyun.bbs.entity.Topic;
import com.xintouyun.bbs.entity.User;
import com.xintouyun.bbs.service.BaseService;
public class BaseServiceImpl implements BaseService {
TopicDaoImpl tdi=new TopicDaoImpl();
UserDaoImpl udi=new UserDaoImpl();
ReplyDaoImpl rdi=new ReplyDaoImpl();
@Override
public User checkLogin(String uname, String upass) {
User user=udi.queryByUnameAndUpass(uname, upass);
return user;
}
@Override
public boolean register(User user) {
return udi.saveUser(user) > 0;
}
@Override
public boolean post(Topic topic) {
return tdi.saveTopic(topic) > 0;
}
@Override
public boolean rePost(Reply reply,int tid) {
boolean i=false;
if(!tdi.findTopicByTid(tid)) {
i=false;
}else {
rdi.saveReply(reply);
i=true;
}
return i;
}
}
业务方法写好之后我们就可以通过客户端来调用这些方法。
3.客户端:有层次的调用业务层相应的方法，制作成一个客户端系统
因为层次较多所以我们可以把这些菜单写到一个类中：
package com.xintouyun.bbs.util;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Scanner;
import com.xintouyun.bbs.entity.Board;
import com.xintouyun.bbs.entity.Reply;
import com.xintouyun.bbs.entity.Topic;
import com.xintouyun.bbs.entity.User;
import com.xintouyun.bbs.service.BaseService;
import com.xintouyun.bbs.service.Boardservice;
import com.xintouyun.bbs.service.CountService;
import com.xintouyun.bbs.service.TopicService;
import com.xintouyun.bbs.service.UserService;
import com.xintouyun.bbs.service.impl.BaseServiceImpl;
import com.xintouyun.bbs.service.impl.BoardServiceImpl;
import com.xintouyun.bbs.service.impl.CountServiceImpl;
import com.xintouyun.bbs.service.impl.TopicServiceImpl;
import com.xintouyun.bbs.service.impl.UserServiceImpl;
public class MenuFactoryNew {
static Scanner sc = new Scanner(System.in);
static int cursor = 0;
static User user = null;
// 程序主菜单
public static void showBBSMenu() {
System.out.println("------------欢迎来到校园论坛-------------");
System.out.println("1.管理员登录2.普通用户登录3.注册");
while (true) {
try {
cursor = sc.nextInt();
break;
} catch (Exception e) {
System.out.println("请输入正确选择：1：管理员登录2：普通房用户登录3：注册");
sc = new Scanner(System.in);
}
}
switch (cursor) {
case 1:
user = showcheckLogMenu();
if (user.getFlag() == 0) { // 验证管理员登陆
showAdminMenu();// 验证通过进入管理员菜单
} else {
System.out.println("登录失败请重新输入");
showBBSMenu();// 验证失败返回主菜单
}
break;
case 2:
user = showcheckLogMenu();
if (user.getFlag() == 1) {// 验证普通用户登陆
showUserMenu();// 验证通过进入普通用户菜单
} else {
System.out.println("登录失败请重新输入");
showBBSMenu();// 验证失败返回主菜单
}
break;
case 3:
boolean i = RegMenu();
if (i) {
System.out.println("注册成功");
showBBSMenu();// 注册结束返回主菜单
} else {
System.out.println("注册失败");// 注册失败返回主菜单
showBBSMenu();
}
break;
default:
System.out.println("输入错误，请重新输入");
showBBSMenu();
break;
}
}
// 管理员主菜单
public static void showAdminMenu() {
System.out.println("1.用户管理2.版块管理3.主贴管理4.统计汇总5.退出登录");
while (true) {
try {
cursor = sc.nextInt();
break;
} catch (Exception e) {
System.out.println("请重新输入正确选项：1.用户管理2.版块管理3.主贴管理4.统计汇总5.退出登录");
sc = new Scanner(System.in);
}
}
switch (cursor) {
case 1:
showuserManager();// 用户管理
break;
case 2:
showBoardManager();// 版块管理
break;
case 3:
showTopicManager();// 主题管理
break;
case 4:
showCountManager();// 统计汇总
break;
case 5:
showBBSMenu();// 退出登录
break;
default:
System.out.println("输入无效，提示输入值为1-5之间的整数，请重新输入");
showAdminMenu();
break;
}
}
// 普通用户主菜单
public static void showUserMenu() {
TopicService tsi = new TopicServiceImpl();
System.out.println("1.发帖2.回帖3.查看主贴4.查看回帖5.退出登录");
while (true) {
try {
cursor = sc.nextInt();
break;
} catch (Exception e) {
System.out.println("请重新输入正确选项：1.发帖2.回帖3.查看主贴4.查看回帖5.退出登录");
sc = new Scanner(System.in);
}
}
switch (cursor) {
case 1:
boolean i = UserUtil.Post();
if (i) {
System.out.println("发帖成功");
showUserMenu();
} else {
System.out.println("发帖失败");
showUserMenu();
}
break;
case 2:
boolean j= UserUtil.RePost(); //用户回帖
if (j) {
System.out.println("回帖成功");
showUserMenu();
} else {
System.out.println("回帖失败");
showUserMenu();
}
break;
case 3:
List <Topic> lists= tsi.showAllTopic();
System.out.println("所在版块号\t"+"主贴号\t"+"主贴标题\t"+"主贴内容\t"+"创建时间\t"+"发帖人id");
for (Topic topic:lists) {
System.out.println(topic.getBid()+"\t"+topic.getTid()+"\t"+topic.getTitle()+"\t"+topic.getContext()+"\t"+topic.getPtime()+"\t"+topic.getUid());
}
showUserMenu();
case 4:
System.out.println("请输入要查看的主贴号");
int tid = sc.nextInt();
List <Reply> lists1=tsi.queryReplyByTid(tid);
System.out.println("回帖编号\t"+" 回帖标题\t"+" 回帖内容\t"+" 回帖时间 \t"+"回帖人编号\t"+" 主贴编号");
for(Reply reply:lists1) {
System.out.println(reply.getRid()+"\t"+reply.getTitle()+"\t"+reply.getContext()+"\t"+reply.getPtime()+"\t"+reply.getUid()+"\t"+reply.getTid());
}
showUserMenu();
case 5:
showBBSMenu();// 退出登录
break;
default:
System.out.println("输入无效，提示1-5，请重新输入");
showUserMenu();
break;
}
}
// 用户登录
public static User showcheckLogMenu() {
BaseService bsi = new BaseServiceImpl();
User user = null;
System.out.println("请输入账号名字");
String uname = sc.next();
System.out.println("请输入密码");
String upass = sc.next();
while (true) {
try {
user = bsi.checkLogin(uname, upass);
if (user == null) {
System.out.println("您输入的账号不存在");
showBBSMenu();
}
} catch (Exception e) {
e.printStackTrace();
}
return user;
}
}
// 用户注册
public static boolean RegMenu() {
BaseService bsi = new BaseServiceImpl();
System.out.println("请输入账号名字");
String uname = sc.next();
System.out.println("请输入密码");
String upass = sc.next();
User user = new User();
user.setUname(uname);
user.setUpass(upass);
boolean result = bsi.register(user);
return result;
}
// 用户管理菜单
public static void showuserManager() {
UserService usi = new UserServiceImpl();
System.out.println("1.查询禁用用戶2.查询正常用戶3.禁用用戶4.返回管理员菜单");
while (true) {
try {
cursor = sc.nextInt();
break;
} catch (Exception e) {
System.out.println("请重新输入正确选项：1.查询禁用用戶2.查询正常用戶3.禁用用戶4.返回管理员菜单");
sc = new Scanner(System.in);
}
}
switch (cursor) {
case 1:
List <User> list=usi.showDisabledUsers(1);
Iterator<User> it=list.iterator();
System.out.println("用户号\t"+"用户名字\t"+"用户状态");
while(it.hasNext()) {
User user=it.next();
//String state=UserUtil.userStateChange(user.getState());
System.out.println(user.getUid()+"\t"+user.getUname()+"\t"+user.getUserState().getName());
}
showuserManager();
break;
case 2:
List <User> list1=new ArrayList<User>();
list1.addAll(usi.showEnabledUsers(0));
list =usi.showEnabledUsers(0);
Iterator<User> it1=list.iterator();
System.out.println("用户号\t"+"用户名字\t"+"用户状态");
while(it1.hasNext()) {
User user=it1.next();
//String state=UserUtil.userStateChange(user.getState());
System.out.println(user.getUid()+"\t"+user.getUname()+"\t"+user.getUserState().getName());
}
showuserManager();
break;
case 3:
System.out.println("请输入要禁用的用户id");
int uid = sc.nextInt();
boolean j = usi.disableUser(uid);
if (j) {
System.out.println("禁用成功");
showuserManager();
} else {
System.out.println("禁用失败");
showuserManager();
}
break;
case 4:
showAdminMenu();
break;
default:
System.out.println("输入无效，提示1/2/3/4");
showuserManager();
break;
}
}
// 版块管理菜单
public static void showBoardManager() {
Boardservice bosi = new BoardServiceImpl();
System.out.println("1.查詢所有版块2.添加版块3.返回管理员菜单");
while (true) {
try {
cursor = sc.nextInt();
break;
} catch (Exception e) {
System.out.println("请重新输入正确选项：1.查詢所有版块2.添加版块3.返回管理员菜单");
sc = new Scanner(System.in);
}
}
switch (cursor) {
case 1:
List <Board> lists= bosi.showAllBoard();
System.out.println("版块号\t"+"板块名");
for (Board board:lists) {
System.out.println(board.getBid()+"\t"+board.getBname());
}
showBoardManager();
case 2:
Board board = new Board();
System.out.println("请输入要添加的版块名字");
board.setBname(sc.next());
boolean i=bosi.addBoard(board);
if (i) {
System.out.println("添加成功");
showBoardManager();
} else {
System.out.println("添加失败");
showBoardManager();
}
case 3:
showAdminMenu();
break;
default:
System.out.println("输入无效，提示1/2");
showBoardManager();
break;
}
}
// 主贴管理菜单
public static void showTopicManager() {
TopicService tsi = new TopicServiceImpl();
System.out.println("1.显示所有主贴2.显示指定版块主贴3.刪除主贴4.返回管理员菜单");
while (true) {
try {
cursor = sc.nextInt();
break;
} catch (Exception e) {
System.out.println("请重新输入正确选项：1.显示所有主贴2.显示指定版块主贴3.刪除主贴4.返回管理员菜单");
sc = new Scanner(System.in);
}
}
switch (cursor) {
case 1:
List <Topic> lists= tsi.showAllTopic();
System.out.println("所在版块号\t"+"所在版块\t"+"主贴号\t"+"主贴标题\t"+"主贴内容\t"+"创建时间\t"+"发帖人id\t"+"发帖人名字");
for (Topic topic:lists) {
System.out.println(topic.getBid()+"\t"+topic.getBname()+"\t"+topic.getTid()+"\t"+topic.getTitle()+"\t"+topic.getContext()+"\t"+topic.getPtime()+"\t"+topic.getUid()+"\t"+topic.getUname());
}
showTopicManager();
case 2:
System.out.println("请输入要显示版块的id");
int bid = sc.nextInt();
List <Topic> lists1= tsi.showAllTopic(bid);
System.out.println("所在版块号\t"+"所在版块\t"+"主贴号\t"+"主贴标题\t"+"主贴内容\t"+"创建时间\t"+"发帖人id\t"+"发帖人名字");
for (Topic topic:lists1) {
System.out.println(topic.getBid()+"\t"+topic.getBname()+"\t"+topic.getTid()+"\t"+topic.getTitle()+"\t"+topic.getContext()+"\t"+topic.getPtime()+"\t"+topic.getUid()+"\t"+topic.getUname());
}
showTopicManager();
case 3:
System.out.println("请输入要删除主贴的id");
int tid = sc.nextInt();
boolean i=tsi.deleteTopic(tid);
if (i) {
System.out.println("删除成功");
showTopicManager();
} else {
System.out.println("删除失败");
showTopicManager();
}
case 4:
showAdminMenu();
break;
default:
System.out.println("输入无效，提示1/2/3");
showTopicManager();
break;
}
}
// 统计汇总菜单
public static void showCountManager() {
CountService csi = new CountServiceImpl();
TopicService tsi = new TopicServiceImpl();
System.out.println("1.查询某个版块所有主贴数2.查询最近活跃用戶id 3.返回管理员菜单");
while (true) {
try {
cursor = sc.nextInt();
break;
} catch (Exception e) {
System.out.println("请重新输入正确选项：1.查询某个版块所有主贴数2.查询最近活跃用戶id 3.返回管理员菜单");
sc = new Scanner(System.in);
}
}
switch (cursor) {
case 1:
System.out.println("请输入你要查询的版块号");
int bid = sc.nextInt();
int count=csi.countAllTopicNum(bid);
System.out.println("板块中主贴数为:" + count);
showCountManager();
break;
case 2:
System.out.println("最近活跃用户为:");
List <String > list=tsi.countActiveUser();
System.out.println("发帖人id");
for(String uid:list) {
System.out.println(uid);
}
showCountManager();
break;
case 3:
showAdminMenu();
break;
default:
System.out.println("输入无效，提示1/2");
showCountManager();
break;
}
}
}
我当时写的时候把发帖回帖单独写出来了
package com.xintouyun.bbs.util;
import com.xintouyun.bbs.entity.Reply;
import com.xintouyun.bbs.entity.Topic;
import com.xintouyun.bbs.service.impl.BaseServiceImpl;
public class UserUtil extends MenuFactoryNew{
static BaseServiceImpl bsi=new BaseServiceImpl();
//发帖
public static boolean Post() {
System.out.println("请输入主贴标题");
String title=sc.next();
System.out.println("请输入內容");
String context=sc.next();
int uid=user.getUid();
System.out.println("请输入主贴所在的版块号");
int bid=sc.nextInt();
Topic topic=new Topic();
topic.setTitle(title);
topic.setContext(context);
topic.setUid(uid);
topic.setBid(bid);
boolean result=bsi.post(topic);
return result;
}
//回帖
public static boolean RePost() {
System.out.println("请输入标题");
String title=sc.next();
System.out.println("请输入內容");
String context=sc.next();
int uid=user.getUid();
System.out.println("請輸入所在主貼號");
int tid=sc.nextInt();
Reply reply=new Reply();
reply.setTitle(title);
reply.setContext(context);
reply.setUid(uid);
reply.setTid(tid);
boolean result=bsi.rePost(reply,tid);
return result;
}
}
最后写一个测试类：
package com.xintouyun.bbs.test;
import com.xintouyun.bbs.util.MenuFactoryNew;
public class ClientNew1 {
static MenuFactoryNew mfn=new MenuFactoryNew();
public static void main(String[] args) {
MenuFactoryNew.showBBSMenu();
}
}
好了，系统做好了，我们来看一下运行效果：
管理员登录
用户管理:查询被禁用用户，查询正常用户，禁用用户
版块管理：查询所有版块，添加版块
主贴管理：显示所有主贴，显示指定版块主贴，删除主贴
返回主菜单，切换到用户登录
扫一扫
6926
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
