AHPU答疑网（在线学生答疑系统） - 图文
更新时间：2024-04-07 04:48:01 阅读量： 综合文库 文档下载
- ahpu推荐度：
- 相关推荐
****大学
企业级软件开发课程设计说明书
课题名称： 姓 名： 学 号： 专 业： 班 级： 指导教师：
2015年1月1日
目 录
第一章 概 述----------------------------------------------------------------------------
第二章 需求分析------------------------------------------------------------------------------ 2.1 系统基本功能需求-------------------------------------------------------------------------- 2.2 具体功能概述--------------------------------------------------------------
第三章 概要设计--------------------------------------------------------------------- 3.1 系统用例图------------------------------------------------------------------
3.2 系统功能结构图------------------------------------------------------------------------ 3.3 模块功能结构----------------------------------------------------------------------- 3.4 框架分析-----------------------------------------------------------------------
第四章 详细设计----------------------------------------------------------------------
第五章 调试分析------------------------------------------------------------------------------ 第六章 运行截图----------------------------------------------------------------------
第七章 设计总结-------------------------------------------------------------------------------- 第八章 参考文献---------------------------------------------------------------------------- 第九章 附录----------------------------------------------------------------------------
第一章 概 述
论坛最早是用来公布股市价格等类信息的，而且只能在苹果计算机上运行。直到个人计算机普及之后，有些人尝试将苹果计算机上的BBS转移到个人计算机上，BBS才开始渐渐普及开来。在Internet飞速发展的今天，校园论坛在Internet应用上的地位也越来越重要。通过学生发帖提问，老师回帖解答的方式，本次设计的答疑网系统，有效解决了大学学习过程中存在的师生接触时间过短问题，起到随时随地解决学生疑惑的作用。本课题主要的工作是对论坛网站的主要功能进行设计与实现，实现用户注册/登录、浏览帖子，发表及回复帖子的功能以及系统管理员对后台的管理功能，如维护版块/指定版主，版主对帖子置顶/设置回复可见，自动对帖子列表/回帖列表分页等。
BBS论坛系统具有访问吞吐量大，对性能要求高的特点，在Web应用开发中这样的系统具有一定的代表性。JavaEE是实现企业级分布式应用的平台，JavaEE以其高效率，高性能，高扩展而成为企业级应用的优秀解决方案。采用Struts、Hibernate、Spring等技术，通过MVC架构，将视图层和业务层分离，方便开发与维护。本系统功能主要有:用户帖子管理功能，用户可以发帖、回帖，浏览帖子；管理员对帖子的管理，如将帖子置顶、设置回复可见、自动分页；用户管理功能，管理员指定版主等；版块管理功能，管理员可以对版块进行维护等操作。通过本系统，用户可以轻松交流，管理员信息维护更加方便。
第二章 需求分析
2.1系统基本功能需求
此次设计的答疑网为师生提供一个相互交流、帮助的平台,用以更好的增强本校师生的团结互助精神。整个系统分为个人中心管理系统、后台管理系统。个人中心管理系统将实现以下功能：注册、登录、发表主题、回复等等；后台管理系统实现以下功能：查看、设置版主 、置顶帖子、设置帖子回复可见并对版块进行维护等。
2.2 具体功能概述
本答疑网是一个基于SHH框架的网上论坛，论坛采用B/S体系结构，人们通过浏览器访问网站的主页，该论坛功能较全，在这里用户可以自由地发表自己的观点和回复他人帖子。
该系统主要分为前台和后台两个模块，前台主要功能有：
(1)用户注册：只有注册了以后才可以发帖或者回帖，在菜单栏中创建一个链接，点击它，就跳转到用户注册的页面上去了。用户的注册就是对用户输入的信息进行添加。将信息添加带数据库中。其中包含用户会员名，密码等。
(2)用户登录：在进入主页面之后，用户要进行帖子发布那么就必须登录才可以。所以在菜单栏是上建一个用户登录的键。输入用会员名和密码，在数据库中查找是否有输入的ID，存在就进入系统，不存在，就跳转到失败的页面。
(3)修改信息：在主页面的菜单栏中包括个人信息项，点击个人信息即进入到用户管理页面。在该页面可以查看个人注册信息。输入需要更新的信息，点击“更新”按钮调用相应的action，执行该功能，用户可以随时更新自己的资料以及修改登录密码。
(4)发帖：用户可以发表自己的帖子和回复别人的帖子，点击进入发表帖子的界面，输入相应的信息（包括文章标题、文章内容），点击“发表帖子”按钮即可发表文章，在主页面上显示最新发表的帖子。
（5）回帖：点击帖子标题，查询文章内容，输入回复信息，点击“发表回复”按钮即可回复该帖子，在主页面上更新该文章的最新回复及数量。
（6）版主申请：点击主页面版块菜单，进入该版块，用户可以点击“我要申请版主”按钮进行申请版主操作，等待管理员审核，审核通过后即可对该版块的文章进行管理（包括置顶、删除操作）。
(7)删除帖子：用户只可以删除自己的帖子，版主可以删除别人的帖子，以及自己帖子里的楼层。
(8)封禁管理：版主可以封禁不当言论的用户，也可以解封。 后台主要功能有：
(1)帖子管理：管理员可以对帖子进行置顶、设置回复可见等。 (2)版块维护：设定合适的版面，增加或者删除版块。
(3)用户管理：启用、禁用、删除用户，当用户注册完成以后，系统会为每个用户保存信息资料。管理员可以对用户信息进行管理。
(4)版主申请处理：点击“版主申请处理”菜单，显示需要处理的清单，点击“通过申请”或“拒绝申请”链接对该清单进行处理。
第三章 概要设计
系统用例图
用 户 注册/登录 发表帖子 回复帖子 浏览帖子 版主 修改信息 帖子管理 用户管理 信息管理 管理员 帖子管理 用户管理 版块维护 指定版主 临时用户
3.1
3.2 系统功能结构图
AHPU答疑网 前台功能 后台管理 用 户 注册登陆 用户浏览信息 用户发帖回帖 用户修改信息 用户管理 帖子管理 版块维护 指定版主
3.3模块功能结构
AHPU答疑网 用户模块帖子模块后台管理 用户注册用户登录资料修改帖子发表帖子回复回复可见权限管理帖子管理版块管理
系统实现了如下的功能.
1.用户模块
此模块用来实现用户的注册登陆和用户资料的修改。 (1) 用户登陆模块
用户可以通过此模块进行登陆,登陆后便拥有用户的所有权限，比如发帖回帖，修改资料等等
(2) 用户注册模块
游客需要通过此模块进行用户的注册，注册成功后便可登陆答疑网,使用普通用户功能.
(3) 资料修改模块
注册成功的用户在登录以后可以通过此模块对自己的基本资料进行修改。 2.帖子模块
(1) 帖子发表模块 用户在登录成功以后，可以在论坛中发表自己的主题帖,发表成功后,其他用户就可以在相应的版块查看到发表的帖子，并可以对其进行回复等操作。
(2) 帖子回复模块
用户在发表完帖子后,其他用户便可在相应版块查看到帖子,并可以在帖子中对已发表的帖子进行回复。
(3) 回复可见模块
版主对帖子设置回复可见。 3.后台管理
(1) 权限管理模块
该模块用于管理员对用户的操作，比如封禁和解封用户、删除用户、指定版主等。
(2) 帖子管理模块
帖子管理模块是用于管理员对帖子进行管理的模块,如果管理员发现有不当言论或者违反规定的帖子，可以对帖子进行删除,相反如果看到优秀的帖子,则可以对帖子进行置顶,加精等操作。
帖子管理模块 帖子删除帖子置顶帖子加精 图3-3 帖子管理模块功能层次图
(3) 版块管理模块.
管理员通过该模块可以进行版块的添加、删除等操作。
3.4 框架分析：
1.Struts框架
Struts是Apache组织的一个开放源码项目。Struts是一个比较好的MVC框架，提供了对开发MVC系统的底层支持，它采用的主要技术是Servlet，JSP和Custom tag library。
Struts框架的优点如下：
(1)实现了MVC模式，层次结构清晰，使程序员只需关注业务逻辑的实现。 (2)丰富的标签库，大大提高了开发的效率。 (3)Struts提供丰富的拦截器实现。
(4)通过配置文件，就可以掌握整个系统各个部分之间的关系。
(5)异常处理机制，只需在配置文件中配置异常的映射，即可对异常做相应的处理。
2. Spring框架
Spring框架是由于软件开发的复杂性而创建的。Spring使用的是基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅仅限于服务器端的开发。从简单性、可测试性和松耦合性的角度而言，绝大部分Java应用都可以从Spring中受益。
目的：解决企业应用开发的复杂性
功能：使用基本的JavaBean代替EJB，并提供了更多的企业应用功能 范围：任何Java应用 Spring框架的优点如下： (1)无入侵性。
(2)各个组件之间的耦合极为松散。
(3)无需程序员自己实现singleton模式。 (4)通过AOP，可以实现事务管理和日志管理。
(5)整合其他的框架，如：struts框架和hibernate框架。
3.Hibernate框架
Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用中使用，最具革命意义的是，Hibernate可以在应用EJB的J2EE架构中取代CMP，完成数据持久化的重任。 Hibernate框架（ORM框架）的优点如下： (1)对象/关系数据库映射（ORM），使用时只需操纵对象，使开发更加面向对象化。
(2)无入侵性。
(3)简洁的HQL语句，减少了JDBC与SQL操作数据库的代码量； (4) 移植性好。
第四章 详细设计
4.1登录模块实现
public String login() throws Exception { if(user.getUsername() == null || user.getUsername().trim().equals(\ addActionError(\用户名不能为空！\ return \ } else if(user.getPassword() == null || user.getPassword().trim().equals(\ addActionError(\密码不能为空！\ return \ } else if(qaService.checkedUserLogin(user.getUsername(), user.getPassword())) { //判断是否已注册 if(qaService.isAdmin(user.getUsername()).equals(\判断是否为管理员登陆 ActionContext.getContext().getSession().put(\ } if(qaService.isMoterator(user.getUsername())) {//判断是否为版主登陆 ActionContext.getContext().getSession().put(\ } //若登录成功则将用户名存入session,这样才可以发帖和提问 ActionContext.getContext().getSession().put(\ return execute(); } else { addActionError(\用户名或密码不正确！\ return \ } }
4.2注册模块实现 public String regist() {
if(user.getUsername() == null || user.getUsername().trim().equals(\ addActionError(\用户名不能为空！\ return \}
}
else if(qaService.checkedUser(user)) { addActionError(\用户名已存在！\ return \}
else if(user.getPassword() == null || user.getPassword().trim().equals(\ addActionError(\密码不能为空！\ return \}
else if(user.getRole()== -1) {//-1 表示没有选择用户类型 addActionError(\请选择用户类型！\ return \}
else {//注册成功 qaService.regist(user); return \}
4.3发帖模块实现
public String postArticle() throws Exception {
if(categoryId == 0) { addActionError(\请选择正确的版块！\ return question();//一定要返回给方法，而不能简单的返回一个String那样list编译会出错 } else if(article.getTitle() == null || article.getTitle().trim().equals(\ addActionError(\标题不能为空！\ return question(); } else if(article.getContext() == null || article.getContext().trim().equals(\ addActionError(\内容不能为空！\ return question(); } else { //这里提问者是从已登录的用户session里获得，放入第一个参数 qaService.questionArticle((String)ActionContext.getContext().getSession().get(\article.getTitle(), article.getContext(), categoryId); return execute(); } }
4.4回帖模块实现
public String answerArticle() throws Exception {
String userName = (String)ActionContext.getContext().getSession().get(\ if(article.getContext() == null || article.getContext().trim().equals(\ addActionError(\内容不能为空！\ return showArticle(); } else if(userName == null || userName.equals(\ addActionError(\请先登录！\ return showArticle(); } else if(!qaService.isAdmin(userName).equals(\只有教师才可以回答 addActionError(\只有教师才可以回答，所以你不具有回答权限！\ return showArticle(); } else {//这里提问者是从已登录的用户session里获得，放入第一个参数 qaService.answerArticle((String)ActionContext.getContext().getSession().get(\article.getId(), article.getContext()); return showArticle(); } }
4.5版主设定模块
//设置版主前填充所有用户
public String addMoteratorPage() { List
//添加版主
public String addMoterator() throws Exception { qaService.addMoterator(user.getUsername()); return execute(); }
//取消版主
public String deleteMoterator() throws Exception { qaService.deleteMoterator(user.getUsername()); return execute(); }
4.6帖子置顶模块
public String toTop() throws Exception {
qaService.articleToTop(article.getId()); return execute(); }
/* getters And setters */
public QandAService getQaService() { return qaService; }
public void setQaService(QandAService qaService) { this.qaService = qaService; }
public User getUser() { return user; }
public void setUser(User user) { this.user = user; }
public int getCategoryId() { return categoryId; }
public void setCategoryId(int categoryId) { this.categoryId = categoryId; }
public String getCategoryName() { return categoryName; }
public void setCategoryName(String categoryName) { this.categoryName = categoryName; }
public Article getArticle() { return article; }
public void setArticle(Article article) { this.article = article; }
public int getPageNo() {
return pageNo; } public void setPageNo(int pageNo) { /* 页码判断 */ int totalArticles ; if(categoryId == 0) totalArticles = qaService.getTotalArticles(); else totalArticles = qaService.getTotalArticles(categoryId); if(pageNo <= 0) { pageNo =1; } int totalPages = totalArticles%pageSize == 0 ? totalArticles/pageSize + 1; if(pageNo > totalPages) pageNo = totalPages; this.pageNo = pageNo; } }
4.7设置回复可见模块
/** * 根据ID得到某个帖子的回答
* @param articleId 要显示的帖子的ID * @return 所有答案 */
public List getArticleAnswer(int articleId) { List articles = articleDAO.findBPid(articleId); return articles;
}
4.8帖子列表、分页显示模块
/** * 得到所有帖子 分页显示
* @param pageNo 当前页码,pageSize 每页显示帖子条数 * @return 所有帖子 */
public List getAllArticle(int pageNo, int pageSize) { int startPos = (pageNo - 1)* pageSize;//每页第一条帖子 List articles = articleDAO.findAll(); /* 以下代码实现分页与置顶 */
for(int i=0; i
totalArticles/pageSize : }
Article a = articles.get(i); if(a.getIsTop() != 0) {//取得置顶帖将其置顶 Article a2 = articles.get(0); articles.set(0, a); articles.set(i, a2); } }
int last = startPos + pageSize; if(last > articles.size()) { last = articles.size(); }
List as = articles.subList(startPos, last);//分页 return as;
4.9管理员维护版块模块 /**
* 删除版块
* @param 被删除版块的ID */
public void deleteCategory(int categoryId) { Transaction ts = categoryDAO.getSession().beginTransaction(); Category c = categoryDAO.findById(categoryId); categoryDAO.delete(c); ts.commit(); } /**
* 添加版块
* @param 新添加的版块名 */
public void addCategory(String categoryName) { Category c = new Category(categoryName); Transaction ts = categoryDAO.getSession().beginTransaction(); categoryDAO.save(c); ts.commit(); }
第五章 调试分析
整个系统设计完成后,需要对系统进行测试,确保系统能够正确完整的运行,并解决出现运行过程中出现的BUG。 5.1 测试概述
对软件测试,首先需要明确软件测试的目的,才能完成软件测试的任务,确保软件的质量。
5.1.1 软件测试的任务 1.寻找Bug
2.避免软件开发过程中的缺陷; 3.衡量软件的品质。 总的目标是：确保软件的质量 5.1.2 测试环境
MyEclipse自带MyEclipse Tomcat，使得用户可以在MyEclipse当中直接运行
程序，浏览网页。向MyEclipse Tomcat浏览器输入本地动态网页的URL，Web服务器在收到浏览器传送的URL之后找到网页文件,并在服务器端执行该文件后将此文件以HTML文件的形式返回该浏览器。 5.2 单元测试
单元测试主要分为黑盒测试和白盒测试,完成这两个测试后还需进行模块接口测试。 5.2.1 黑盒测试
在单元测试中分别对前台模块和后台模块进行分别测试。
首先对各个模块进行黑盒测试，在各种条件下运行模块是否能正常运行，比如在等录时，输入空白用户名等等。 5.2.2 白盒测试
白盒测试将系统看做一个透明的盒子,测试人员主要根据系统的逻辑结构,按照系统的结构进行测试,选取相应的测试用例,测试程序的所有逻辑路径。 5.3 系统测试综述
通过对程序进行黑盒测试,分别测试了前台模块和后台模块,使用白盒测试
测试了不同用例,在此基础上进行模块接口测试,整个系统可以正确无误的运行,测试结束。
第六章 运行截图
第七章 设计总结
本文设计是采用B/S架构，使用SSH框架，Myeclipse运行环境、基于JAVA和SQL Server2005数据库服务器而开发的答疑网系统。本网站具有帖子浏览、帖子回复、帖子发表、帖子管理、用户登陆和用户注册等功能。用户只要通过注册就可以进入本系统发帖，登陆后就可以在本网站上进行各种相应的操作。
答疑网系统在不断的设计更改过程中,逐渐的成熟。在编写的最后阶段中,参考了一些设计模式,在逻辑代码和数据库连接DAO中抽象出了若干接口,并对其进行了对象的依赖注入,大大的减少了模块之间的耦合,使系统具有很高的灵活性和可维护性,这是此系统最大的优点。
当然此系统也存在很多不足的地方, 有些方面没有考虑到，还有一些功能没有实现。比如说没有考虑版主的问题。不仅管理员可以登录后台对版块进行管理，其实版主也可以直接对版块进行相关的操作。另外界面的友好性可能还不够，也许有些地方只是按照自己的理解设计的，可能存在缺陷，以后慢慢拓宽和改善。
通过这次的设计, 加深了我对S.S.H框架,以及面向对象思想的一些理解.对于软件工程方面的设计思想也有了更深一步的理解, 但同时，由于个人经验及能力尚欠不足，系统在技术实现上还有很多不尽如人意的地方。比如，一开始就编码，没有很好的做好概要设计，加重了代码修改及维护的工作量等。总的来说，我在系统的开发整个过程中取得了一些收获，也得到了一些教训，在今后的学习和工作中避免同样的教训出现，同时多思考，多总结。
第八章 参考文献
[1]邹天思：《JavaScript程序设计》,人民邮电出版社，2009年第一版。
[2]许川佩,张民,李倩.基于Ajax的J2EE安全应用框架[J].计算机工程,2010 [3]张银鹤.点石成金：JSP+Ajax网站开发典型实例[M].电子工业出版社,2009 [4] 刘竹林:《软件工程与项目管理》，北京师范大学出版社，2008年第一版。 [5]王苗.BBS论坛管理系统[D].黑龙江:哈尔滨工业大学,2008
[6］许文宪．Java 程序设计教程与实训[M]．北京：北京大学出版社，2005． [7]曾海：《JavaScript程序设计基础》,人民邮电出版社，2009年第一版。
第九章 附 录
package ahpu.qanda.action; import java.util.Date; import java.util.List; import java.util.Set;
import ahpu.qanda.model.Article; import ahpu.qanda.model.Category; import ahpu.qanda.model.User;
import ahpu.qanda.service.QandAService;
import com.opensymphony.xwork2.ActionContext; import com.opensymphony.xwork2.ActionSupport; public class QandAAction extends ActionSupport{ private int categoryId;//根据该ID得到某个版块 private String categoryName;//添加的版块名 private int pageNo = 1;//默认是第一页 int pageSize = 3;//每页显示帖子数 private User user; private Article article; private QandAService qaService = new QandAService(); // 答疑网首页 public String execute() throws Exception { List
addActionError(\用户名或密码不正确！\ } return \ } //public String showArticle() { 显示帖子 Article oldArticle = qaService.getArticle(article.getId()); List answers = qaService.getArticleAnswer(article.getId()); ActionContext ctx = ActionContext.getContext(); article.setTitle(oldArticle.getTitle()); ctx.put(\ctx.put(\ ctx.put(\ ctx.put(\return \ } // public String question() throws Exception { 提问页面 List
return \article.getTitle(),
article.getId(),
// 添加版主
public String addMoterator() throws Exception { qaService.addMoterator(user.getUsername()); return execute(); }
// 取消版主
public String deleteMoterator() throws Exception { qaService.deleteMoterator(user.getUsername()); return execute(); }
//添加或删除版块前加载所有版块 public String categoryPage() { List
// 删除版块
public String deleteCategory() { qaService.deleteCategory(categoryId); return categoryPage(); }
//添加版块
public String addCategory() { if(qaService.checkedCategory(categoryName)) { addActionError(\版块名已存在！\ return categoryPage(); } if(categoryName == null || categoryName.trim().equals(\ addActionError(\版块名不能为空！\ return categoryPage(); } qaService.addCategory(categoryName); return categoryPage(); }
//帖子置顶
public String toTop() throws Exception { qaService.articleToTop(article.getId()); return execute(); }
/* getters And setters */
public QandAService getQaService() { return qaService; }
public void setQaService(QandAService qaService) { this.qaService = qaService; }
public User getUser() { return user; }
public void setUser(User user) { this.user = user; }
public int getCategoryId() { return categoryId; }
public void setCategoryId(int categoryId) { this.categoryId = categoryId; }
public String getCategoryName() { return categoryName; }
public void setCategoryName(String categoryName) { this.categoryName = categoryName; }
public Article getArticle() { return article; }
public void setArticle(Article article) { this.article = article; }
public int getPageNo() { return pageNo; }
public void setPageNo(int pageNo) { /* 页码判断 */ int totalArticles ; if(categoryId == 0) totalArticles = qaService.getTotalArticles(); else totalArticles = qaService.getTotalArticles(categoryId); if(pageNo <= 0) { pageNo =1; } int totalPages = totalArticles%pageSize == 0 ? totalArticles/pageSize : totalArticles/pageSize + 1; if(pageNo > totalPages)
pageNo = totalPages; this.pageNo = pageNo; } }
package ahpu.qanda.model; import java.util.Date;
import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import static javax.persistence.GenerationType.IDENTITY; import javax.persistence.Id;
import javax.persistence.JoinColumn; import javax.persistence.ManyToOne; import javax.persistence.Table; import javax.persistence.Temporal; import javax.persistence.TemporalType; /**
* Article entity. @author MyEclipse Persistence Tools */
@Entity
@Table(name = \
public class Article implements java.io.Serializable { // Fields private Integer id; private Category category; private User user; private String title; private String context; private Date articleDate; private Integer pid; private Integer isTop; // Constructors /** default constructor */ public Article() { } /** full constructor */ public Article(Category category, User user, String title, String context, Date articleDate, Integer pid, Integer isTop) { this.category = category; this.user = user; this.title = title; this.context = context; this.articleDate = articleDate; this.pid = pid; this.isTop = isTop; } // Property accessors @Id @GeneratedValue(strategy = IDENTITY) @Column(name = \ public Integer getId() { return this.id; } public void setId(Integer id) { this.id = id; } @ManyToOne(fetch = FetchType.LAZY) @JoinColumn(name = \ public Category getCategory() { return this.category; } public void setCategory(Category category) { this.category = category; } @ManyToOne(fetch = FetchType.LAZY) @JoinColumn(name = \ public User getUser() { return this.user; } public void setUser(User user) { this.user = user; } @Column(name = \ public String getTitle() { return this.title; } public void setTitle(String title) { this.title = title; } @Column(name = \ public String getContext() { return this.context; } public void setContext(String context) { this.context = context;
} @Temporal(TemporalType.TIMESTAMP) @Column(name = \ public Date getArticleDate() { return this.articleDate; } public void setArticleDate(Date articleDate) { this.articleDate = articleDate; } @Column(name = \ public Integer getPid() { return this.pid; } public void setPid(Integer pid) { this.pid = pid; } @Column(name = \ public Integer getIsTop() { return this.isTop; } public void setIsTop(Integer isTop) { this.isTop = isTop; } }
pckage ahpu.qanda.model; import java.util.HashSet; import java.util.Set;
import javax.persistence.CascadeType; import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import static javax.persistence.GenerationType.IDENTITY; import javax.persistence.Id;
import javax.persistence.OneToMany; import javax.persistence.Table; /**
* Category entity. @author MyEclipse Persistence Tools */
@Entity
@Table(name = \
public class Category implements java.io.Serializable { // Fields private Integer id; private String categoryName; private Set articles = new HashSet(0); // Constructors /** default constructor */ public Category() { } /** minimal constructor */ public Category(String categoryName) { this.categoryName = categoryName; } /** full constructor */ public Category(String categoryName, Set articles) { this.categoryName = categoryName; this.articles = articles; } // Property accessors @Id @GeneratedValue(strategy = IDENTITY) @Column(name = \ public Integer getId() { return this.id; } public void setId(Integer id) { this.id = id; } @Column(name = \ public String getCategoryName() { return this.categoryName; } public void setCategoryName(String categoryName) { this.categoryName = categoryName; } @OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY, mappedBy = \ public Set getArticles() { return this.articles; } public void setArticles(Set articles) { this.articles = articles; } }
package ahpu.qanda.model; import java.util.HashSet; import java.util.Set;
import javax.persistence.CascadeType; import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import static javax.persistence.GenerationType.IDENTITY; import javax.persistence.Id;
import javax.persistence.OneToMany; import javax.persistence.Table; /**
* User entity. @author MyEclipse Persistence Tools */
@Entity
@Table(name = \
public class User implements java.io.Serializable { // Fields private Integer id; private String username; private String password; private Integer role; private String moderator; private Set articles = new HashSet(0); // Constructors /** default constructor */ public User() { } /** minimal constructor */ public User(String username, String password, Integer role, String moderator) { this.username = username; this.password = password; this.role = role; this.moderator = moderator; } /** full constructor */ public User(String username, String password, Integer role, String moderator, Set articles) { this.username = username; this.password = password; this.role = role; this.moderator = moderator; this.articles = articles; } // Property accessors @Id @GeneratedValue(strategy = IDENTITY) @Column(name = \ public Integer getId() { return this.id; } public void setId(Integer id) { this.id = id; } @Column(name = \ public String getUsername() { return this.username; } public void setUsername(String username) { this.username = username; } @Column(name = \ public String getPassword() { return this.password; } public void setPassword(String password) { this.password = password; } @Column(name = \ public Integer getRole() { return this.role; } public void setRole(Integer role) { this.role = role; } @Column(name = \ public String getModerator() { return this.moderator; } public void setModerator(String moderator) { this.moderator = moderator; } @OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY, mappedBy = \ public Set getArticles() { return this.articles; } public void setArticles(Set articles) { this.articles = articles; }
}
package ahpu.qanda.service; import java.util.Date; import java.util.Iterator; import java.util.List; import java.util.Set;
import org.hibernate.Transaction; import sun.nio.cs.ext.TIS_620; import ahpu.qanda.model.Article; import ahpu.qanda.model.Category; import ahpu.qanda.model.User; import aphu.qanda.dao.ArticleDAO; import aphu.qanda.dao.CategoryDAO; import aphu.qanda.dao.UserDAO; public class QandAService { private UserDAO userDAO = new UserDAO(); private CategoryDAO categoryDAO = new CategoryDAO(); private ArticleDAO articleDAO = new ArticleDAO(); //检测用户名是否存在 public boolean checkedUser(User checkedUser) { List
/**
* 得到帖子总数，用于分页 * @return 帖子总数 */
public int getTotalArticles() { int totalArticles = articleDAO.findAll().size(); return totalArticles; } /**
* 得到某个版块帖子的个数，用于分页 * @param categoryId 当前版块的ID * @return 该版块的帖子总数 */
public int getTotalArticles(int categoryId) { Category c = categoryDAO.findById(categoryId); Set articles = c.getArticles(); Iterator it = articles.iterator(); while(it.hasNext()) {//取出得到的帖子 Article a = it.next(); if(a.getPid() != 0) {//如果是回帖则移出 it.remove();//这行代码很重要 articles.remove(a); } } int totalArticles = articles.size(); return totalArticles; } /**
* 得到所有帖子 分页显示
* @param pageNo 当前页码,pageSize 每页显示帖子条数 * @return 所有帖子 */
public List getAllArticle(int pageNo, int pageSize) { int startPos = (pageNo - 1)* pageSize;//每页第一条帖子 List articles = articleDAO.findAll(); /* 以下代码实现分页与置顶 */ for(int i=0; i articles.size()) { last = articles.size(); } List as = articles.subList(startPos, last);//分页 return as; } /**
* 得到某版块下的所有帖子 分页显示
* @param categoryId 当前版块的ID pageNo 当前页码,pageSize 每页显示帖子条数 */
public List getArticleFromCategory(int categoryId, int pageNo, int pageSize) { int startPos = (pageNo - 1)* pageSize;//每页第一条帖子 Category category = categoryDAO.findById(categoryId); List articles =null; if(categoryId != 0) {//得到某一模块下的所有帖子 articles = articleDAO.findByProperty(\ } Iterator it = articles.iterator(); while(it.hasNext()) {//取出得到的帖子 Article a = it.next(); if(a.getPid() != 0) {//如果是回帖则移出 it.remove();//这行代码很重要 articles.remove(a); } } /* 以下代码实现分页与置顶 */ for(int i=0; i articles.size()) { last = articles.size(); } List as = articles.subList(startPos, last);//分页 return as; } /**
* 根据ID得到某个帖子
* @param articleId 要显示的帖子的ID * @return 帖子 */
public Article getArticle(int articleId) { Article article = articleDAO.findById(articleId); return article; } /**
* 根据ID得到某个帖子的回答
* @param articleId 要显示的帖子的ID * @return 所有答案 */
public List getArticleAnswer(int articleId) { List articles = articleDAO.findBPid(articleId); return articles; } /**
* 提问
* @param userName提问者 articleTitle问题标题 articleContex问题内容 * @param categoryId 问题所在版块ID */
public void questionArticle(String userName, String articleTitle, String articleContex, int categoryId) { User user = userDAO.findByName(userName); Category category = categoryDAO.findById(categoryId); Article article = new Article();//初始化问题 Date now = new Date(); article.setArticleDate(now); article.setCategory(category); article.setContext(articleContex); article.setTitle(articleTitle); article.setUser(user); article.setPid(0); article.setIsTop(0); Transaction tx = articleDAO.getSession().beginTransaction(); articleDAO.save(article);//保存问题 user.getArticles().add(article);//添加到提问者的问题中 category.getArticles().add(article);//添加到该版块 tx.commit(); } /**
* 回答
* @param userName 回答者 articleId回答的问题的ID articleContext回答内容 */
public void answerArticle(String userName, int articleId, String articleContext) { User user = userDAO.findByName(userName); Article oldA = articleDAO.findById(articleId); Article newA = new Article(); Date now = new Date(); newA.setArticleDate(now);//传入发帖时间 newA.setContext(articleContext); newA.setUser(user); newA.setPid(articleId); newA.setTitle(oldA.getTitle()); newA.setCategory(oldA.getCategory()); newA.setIsTop(0); Transaction tx = articleDAO.getSession().beginTransaction(); articleDAO.save(newA); user.getArticles().add(newA); oldA.getCategory().getArticles().add(newA); tx.commit(); } /**
* 删除帖子
* @param 删除帖子的ID */
public void deleteArticle(int articleId) { List articles = articleDAO.findBPid(articleId); for(Iterator it = articles.iterator(); it.hasNext();) { Article a = it.next(); deleteArticle(a.getId()); } Transaction tx = articleDAO.getSession().beginTransaction(); articleDAO.delete(articleId); tx.commit(); } /**
* 得到所有用户以便管理员设置版主 * @return 所有用户 */
public List
* 添加版主
* @param 被设置的用户名
*/ public void addMoterator(String userName) { User user = userDAO.findByName(userName); user.setModerator(\ Transaction tx = userDAO.getSession().beginTransaction(); userDAO.save(user); tx.commit(); } /** * 取消版主 * @param 被设置的用户名 */ public void deleteMoterator(String userName) { User user = userDAO.findByName(userName); user.setModerator(\ Transaction tx = userDAO.getSession().beginTransaction(); userDAO.save(user); tx.commit(); } /** * 删除版块 * @param 被删除版块的ID */ public void deleteCategory(int categoryId) { Transaction ts = categoryDAO.getSession().beginTransaction(); Category c = categoryDAO.findById(categoryId); categoryDAO.delete(c); ts.commit(); } /** * 添加版块 * @param 新添加的版块名 */ public void addCategory(String categoryName) { Category c = new Category(categoryName); Transaction ts = categoryDAO.getSession().beginTransaction(); categoryDAO.save(c); ts.commit(); } /** * 帖子置顶 * @param 被置顶帖子的ID */ public void articleToTop(int articleId) { List articles = articleDAO.findAll(); Iterator it = articles.iterator(); Transaction ts = articleDAO.getSession().beginTransaction(); while(it.hasNext()) {//取出得到的帖子 Article oldTopA = it.next(); if(oldTopA.getIsTop() != 0) { oldTopA.setIsTop(0); articleDAO.save(oldTopA); } } Article topA = articleDAO.findById(articleId); topA.setIsTop(1); articleDAO.save(topA); ts.commit(); } /* getters And setters */ public ArticleDAO getArticleDAO() { return articleDAO; } public CategoryDAO getCategoryDAO() { return categoryDAO; } public UserDAO getUserDAO() { return userDAO; } public void setArticleDAO(ArticleDAO articleDAO) { this.articleDAO = articleDAO; } public void setCategoryDAO(CategoryDAO categoryDAO) { this.categoryDAO = categoryDAO; } public void setUserDAO(UserDAO userDAO) { this.userDAO = userDAO; } }
package aphu.qanda.dao; import java.sql.Timestamp; import java.util.List;
import org.hibernate.LockMode; import org.hibernate.Query;
import static org.hibernate.criterion.Example.create; import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import ahpu.qanda.model.Article;
public class ArticleDAO extends BaseHibernateDAO { private static final Logger log = LoggerFactory.getLogger(ArticleDAO.class); // property constants public static final String TITLE = \ public static final String CONTEXT = \ public void save(Article transientInstance) { log.debug(\ try { getSession().save(transientInstance); log.debug(\ } catch (RuntimeException re) { log.error(\ throw re; } } public void delete(int articleId) { log.debug(\ try { String queryString = \ Query queryObject = getSession().createQuery(queryString); queryObject.setParameter(0, articleId).executeUpdate(); log.debug(\ } catch (RuntimeException re) { log.error(\ throw re; } } public Article findById(java.lang.Integer id) { log.debug(\ try { Article instance = (Article) getSession().get( \ return instance; } catch (RuntimeException re) { log.error(\ throw re; } } public List findBPid(java.lang.Integer id) { log.debug(\ try { String queryString = \ Query queryObject = getSession().createQuery(queryString); queryObject.setParameter(0, id); return queryObject.list(); } catch (RuntimeException re) { log.error(\ throw re; } } public List findByExample(Article instance) { log.debug(\ try { List results = (List) getSession() .createCriteria(\ .add(create(instance)).list(); log.debug(\ + results.size()); return results; } catch (RuntimeException re) { log.error(\ throw re; } } public List findByProperty(String propertyName, Object value) { log.debug(\ + \ try { String queryString = \ + propertyName + \ Query queryObject = getSession().createQuery(queryString); queryObject.setParameter(0, value); return queryObject.list(); } catch (RuntimeException re) { log.error(\ throw re; } } public List findByTitle(Object title) { return findByProperty(TITLE, title); } public List findByContext(Object context) { return findByProperty(CONTEXT, context); } public List findAll() { log.debug(\
try {//此处得到的是所有的提问帖子 String queryString = https://www.bwwdw.com/plus/\ Query queryObject = getSession().createQuery(queryString); return queryObject.list(); } catch (RuntimeException re) { log.error(https://www.bwwdw.com/plus/\ throw re; } } public Article merge(Article detachedInstance) { log.debug(https://www.bwwdw.com/plus/\ try { Article result = (Article) getSession().merge(detachedInstance); log.debug(https://www.bwwdw.com/plus/\ return result; } catch (RuntimeException re) { log.error(https://www.bwwdw.com/plus/\ throw re; } } public void attachDirty(Article instance) { log.debug(https://www.bwwdw.com/plus/\ try { getSession().saveOrUpdate(instance); log.debug(https://www.bwwdw.com/plus/\ } catch (RuntimeException re) { log.error(https://www.bwwdw.com/plus/\ throw re; } } public void attachClean(Article instance) { log.debug(https://www.bwwdw.com/plus/\ try { getSession().lock(instance, LockMode.NONE); log.debug(https://www.bwwdw.com/plus/\ } catch (RuntimeException re) { log.error(https://www.bwwdw.com/plus/\ throw re; } } }
package aphu.qanda.dao; import java.util.List; import java.util.Set;
import org.hibernate.LockMode; import org.hibernate.Query;
import static org.hibernate.criterion.Example.create; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import ahpu.qanda.model.Category;
public class CategoryDAO extends BaseHibernateDAO { private static final Logger log = LoggerFactory .getLogger(CategoryDAO.class); // property constants public static final String CATEGORY_NAME = https://www.bwwdw.com/plus/\ public void save(Category transientInstance) { log.debug(https://www.bwwdw.com/plus/\ try { getSession().save(transientInstance); log.debug(https://www.bwwdw.com/plus/\ } catch (RuntimeException re) { log.error(https://www.bwwdw.com/plus/\ throw re; } } public void delete(Category persistentInstance) { log.debug(https://www.bwwdw.com/plus/\ try { getSession().delete(persistentInstance); log.debug(https://www.bwwdw.com/plus/\ } catch (RuntimeException re) { log.error(https://www.bwwdw.com/plus/\ throw re; } } public Category findById(java.lang.Integer id) { log.debug(https://www.bwwdw.com/plus/\ try { Category instance = (Category) getSession().get( https://www.bwwdw.com/plus/\ return instance; } catch (RuntimeException re) { log.error(https://www.bwwdw.com/plus/\ throw re; } } public List
log.debug(https://www.bwwdw.com/plus/\ try { List
package aphu.qanda.dao; import java.util.List; import java.util.Set;
import org.hibernate.LockMode; import org.hibernate.Query;
import static org.hibernate.criterion.Example.create; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import ahpu.qanda.model.User;
public class UserDAO extends BaseHibernateDAO { private static final Logger log = LoggerFactory.getLogger(UserDAO.class); // property constants public static final String USERNAME = https://www.bwwdw.com/plus/\ public static final String PASSWORD = https://www.bwwdw.com/plus/\
public static final String ROLE = https://www.bwwdw.com/plus/\
public static final String MODERATOR = https://www.bwwdw.com/plus/\public void save(User transientInstance) { log.debug(https://www.bwwdw.com/plus/\ try { getSession().save(transientInstance); log.debug(https://www.bwwdw.com/plus/\ } catch (RuntimeException re) { log.error(https://www.bwwdw.com/plus/\ throw re; } }
public void delete(User persistentInstance) { log.debug(https://www.bwwdw.com/plus/\ try { getSession().delete(persistentInstance); log.debug(https://www.bwwdw.com/plus/\ } catch (RuntimeException re) { log.error(https://www.bwwdw.com/plus/\ throw re; } }
public User findById(java.lang.Integer id) { log.debug(https://www.bwwdw.com/plus/\ try { User instance = (User) getSession().get(https://www.bwwdw.com/plus/\ return instance; } catch (RuntimeException re) { log.error(https://www.bwwdw.com/plus/\ throw re; } }
public User findByName(String username) {//提问时得到提问者 log.debug(https://www.bwwdw.com/plus/\ try { String queryString = https://www.bwwdw.com/plus/\ User user = (User)getSession() .createQuery(queryString) .setParameter(0, username) .uniqueResult(); return user; } catch (RuntimeException re) { log.error(https://www.bwwdw.com/plus/\ throw re; } }
public List
public List findByProperty(String propertyName, Object value) { log.debug(https://www.bwwdw.com/plus/\ + https://www.bwwdw.com/plus/\ try { String queryString = https://www.bwwdw.com/plus/\ + propertyName + https://www.bwwdw.com/plus/\ Query queryObject = getSession().createQuery(queryString); queryObject.setParameter(0, value); return queryObject.list(); } catch (RuntimeException re) { log.error(https://www.bwwdw.com/plus/\ throw re; } }
public List
public List
public List
public List
public List findAll() {
log.debug(https://www.bwwdw.com/plus/\ try { String queryString = https://www.bwwdw.com/plus/\ Query queryObject = getSession().createQuery(queryString); return queryObject.list(); } catch (RuntimeException re) { log.error(https://www.bwwdw.com/plus/\ throw re; } } public User merge(User detachedInstance) { log.debug(https://www.bwwdw.com/plus/\ try { User result = (User) getSession().merge(detachedInstance); log.debug(https://www.bwwdw.com/plus/\ return result; } catch (RuntimeException re) { log.error(https://www.bwwdw.com/plus/\ throw re; } } public void attachDirty(User instance) { log.debug(https://www.bwwdw.com/plus/\ try { getSession().saveOrUpdate(instance); log.debug(https://www.bwwdw.com/plus/\ } catch (RuntimeException re) { log.error(https://www.bwwdw.com/plus/\ throw re; } } public void attachClean(User instance) { log.debug(https://www.bwwdw.com/plus/\ try { getSession().lock(instance, LockMode.NONE); log.debug(https://www.bwwdw.com/plus/\ } catch (RuntimeException re) { log.error(https://www.bwwdw.com/plus/\ throw re; } } }
<%@ page language=https://www.bwwdw.com/plus/\ import=https://www.bwwdw.com/plus/\ pageEncoding=https://www.bwwdw.com/plus/\%> <%
String path = request.getContextPath();
String basePath = request.getScheme()+https://www.bwwdw.com/plus/\+request.getServerName()+https://www.bwwdw.com/plus/\+request.getServerPort()+path+https://www.bwwdw.com/plus/\; %>
<%@taglib uri=https://www.bwwdw.com/plus/\ prefix=https://www.bwwdw.com/plus/\ %>