JSP+Servlet培训班作业管理系统[18] -完结篇之后端源代码

/**
* action包：包含所有动作类
* Action类是所有动作类抽象基类
* 具体动作类包含：AddAction AddWorkAction DeleteAction EditAction EditJobContentAction EditJobScoreAction
* LoginAction SaveAction SaveJobAction SaveLessonAction SaveWorkAction ViewAction ViewCourseAction
* ViewJobAction ViewWorkAction Action是业务核心，全部列出
*/
package action;
import inter.IAction;
/**
* 所有动作的抽象基类Action
* @author 猫哥
* @date 2017.2.19
* @modify 2017.2.19 to remove context
*/
public abstract class Action implements IAction{
//三个必备参数，采用protected便于子类使用
protected String entityType=null;
protected String operationType=null;
protected String actionUrl=null;
public Action(String entityType,String operationType){
this.entityType=entityType;
this.operationType=operationType;
}
public String getEntityType() {
return entityType;
}
public void setEntityType(String entityType) {
this.entityType = entityType;
}
public String getOperationType() {
return operationType;
}
public void setOperationType(String operationType) {
this.operationType = operationType;
}
public String getActionUrl() {
return actionUrl;
}
public void setActionUrl(String actionUrl) {
this.actionUrl = actionUrl;
}
}
package action;
import java.util.HashMap;
import java.util.Map;
import exception.MyException;
/***
* 动作：点击新增按钮后对应动作，直接跳转对应实体更新页面
* @author 猫哥
* @date 2017.2.9
* @modify  2017.2.19 to remove context
*/
public class AddAction extends Action{
public AddAction(String entityType,String operationType){
super(entityType,operationType);
}
@Override
public Map<String, Object> execute() throws MyException {
Map<String,Object> resultMap=
20000
new HashMap<String,Object>();
actionUrl=entityType.toLowerCase()+"Update.jsp";
return resultMap;
}
}
package action;
import java.util.Map;
import operation.CourseOperation;
import exception.MyException;
import factory.OperationFactory;
/***
* 动作：新增作业
* @author 猫哥
* @date 2017.2.17
* @modify 2017.2.19 to remove context
*/
public class AddWorkAction extends AddAction{
//AddWork不同与AddAction的参数
protected int loginUserId=-1;
public AddWorkAction(String entityType,String operationType,int loginUserId){
super(entityType,operationType);
this.loginUserId=loginUserId;
}
@Override
public Map<String, Object> execute() throws MyException {
//通过父类方法设置了actionUrl
Map<String,Object> resultMap=super.execute();
//注意新增作业时需要选择课程，所以返回信息里面含有教师所有课程信息
CourseOperation CourseOper=(CourseOperation)OperationFactory.createOperation("Course");
resultMap.put("courses",CourseOper.selectAllByUserId(loginUserId));
return resultMap;
}
}
package action;
import inter.IOperation;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import exception.MyException;
import factory.OperationFactory;
/***
* 动作：删除后对应动作
* @author 猫哥
* @date 2017.2.9
* @modify 2017.2.19 to remove context
*/
public class DeleteAction extends Action{
protected int deleteEntityId=-1;
public DeleteAction(String entityType,String operationType,int deleteEntityId){
super(entityType,operationType);
this.deleteEntityId=deleteEntityId;
}
@Override
public Map<String, Object> execute() throws MyException {
Map<String,Object> resultMap=new HashMap<String,Object>();
//按类型获取实体操作类
IOperation oper=OperationFactory.createOperation(entityType);
int affectedCount=oper.deleteById(deleteEntityId);
if(affectedCount<1){//删除失败咯
throw new MyException(new Date(),"DeleteAction执行失败,entityType:"+entityType,"删除失败");
}else{
resultMap.put("tipInfo", "删除成功");
actionUrl="tip.jsp";
return resultMap;
}
}
}
package action;
import java.util.HashMap;
import java.util.Map;
import inter.IOperation;
import exception.MyException;
import factory.OperationFactory;
/***
* 动作：点击修改按钮后对应动作
* @author 猫哥
* @date 2017.2.9
* @modify 2017.2.19 to remove context
*/
public class EditAction extends Action{
protected int editEntityId=-1;
public EditAction(String entityType,String operationType,int editEntityId){
super(entityType,operationType);
this.editEntityId=editEntityId;
}
@Override
public Map<String, Object> execute() throws MyException {
Map<String,Object> resultMap=new HashMap<String,Object>();
IOperation oper=OperationFactory.createOperation(entityType);
Object entity=oper.selectById(editEntityId);
resultMap.put(entityType.toLowerCase(), entity);
actionUrl=entityType.toLowerCase()+"Update.jsp";
return resultMap;
}
}

package action;
import java.util.HashMap;
import java.util.Map;
import inter.IOperation;
import exception.MyException;
import factory.OperationFactory;
/***
* 动作：学生做作业
* @author 猫哥
* @date 2017.2.20
*/
public class EditJobContentAction extends Action{
protected int editEntityId=-1;
public EditJobContentAction(String entityType,String operationType,int editEntityId){
super(entityType,operationType);
this.editEntityId=editEntityId;
}
@Override
public Map<String, Object> execute() throws MyException {
Map<String,Object> resultMap=new HashMap<String,Object>();
IOperation oper=OperationFactory.createOperation(entityType);
Object entity=oper.selectById(editEntityId);
resultMap.put(entityType.toLowerCase(), entity);
actionUrl="jobUpdateByStudent.jsp";
return resultMap;
}
}

package action;
import java.util.HashMap;
import java.util.Map;
import inter.IOperation;
import exception.MyException;
import factory.OperationFactory;
/***
* 动作：学生做作业
* @author 猫哥
* @date 2017.2.20
*/
public class EditJobScoreAction extends Action{
protected int editEntityId=-1;
public EditJobScoreAction(String entityType,String operationType,int editEntityId){
super(entityType,operationType);
this.editEntityId=editEntityId;
}
@Override
public Map<String, Object> execute() throws MyException {
Map<String,Object> resultMap=new HashMap<String,Object>();
IOperation oper=OperationFactory.createOperation(entityType);
Object entity=oper.selectById(editEntityId);
resultMap.put(entityType.toLowerCase(), entity);
actionUrl="jobUpdateByTeacher.jsp";
return resultMap;
}
}

package action;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import operation.UserOperation;
import util.Constant;
import entity.User;
import exception.MyException;
import factory.OperationFactory;
/**
* 登录动作
* @author Administrator
* @modify 2017.2.19 to remove context
*/
public class LoginAction extends Action{
protected String inputUserId=null;
protected String inputUserPassword=null;
public LoginAction(String entityType,String operationType,String inputUserId,String inputUserPassword){
super(entityType,operationType);
this.inputUserId=inputUserId;
this.inputUserPassword=inputUserPassword;
}
@Override
public Map<String, Object> execute() throws MyException {
UserOperation oper=(UserOperation)OperationFactory.createOperation(entityType);
int userId=-1;
try{
userId=Integer.parseInt(inputUserId);
}catch(Exception ex){
throw new MyException(new Date(),ex.toString(),"登录失败！");
}
User realUser=(User)oper.selectById(userId);
if(realUser.getUserId()!=0&&realUser.getUserPassword().equals(inputUserPassword)){
//设置返回参数
Map<String,Object> resultMap=new HashMap<String,Object>();
//如果需要Servlet将返回值放入session作用域，则此处命名时以session开头即可
resultMap.put("sessionUser", realUser);
//登录用户角色对应菜单
resultMap.put("sessionRoleMenu", Constant.RoleMenu.get(realUser.getUserRole().getRoleName()));
actionUrl="tip.jsp";
return resultMap;
}
else{
throw new MyException(new Date(),"LoginAction Error","登录失败！");
}
}
}
package action;
import inter.IOperation;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import entity.User;
import exception.MyException;
import factory.OperationFactory;
/***
* 动作：点击保存按钮后对应动作
* @author 猫哥
* @date 2017.2.9
* @modify 2017.2.19 to remove context
*/
public class SaveAction extends Action{
protected Boolean isAddOrEdit;
protected Object saveEntity=null;
protected User sessionUser=null;
public SaveAction(String entityType,String operationType,Boolean isAddOrEdit,Object saveEntity,User sessionUser){
super(entityType,operationType);
this.isAddOrEdit=isAddOrEdit;
this.saveEntity=saveEntity;
this.sessionUser=sessionUser;
}
@Override
public Map<String,Object> execute() throws MyException {
Map<String,Object> resultMap=new HashMap<String,Object>();
IOperation oper=OperationFactory.createOperation(entityType);
int affectedCount=-1;
if(isAddOrEdit){//添加
affectedCount=oper.add(saveEntity);
}else{//修改
affectedCount=oper.update(saveEntity);
}
if(affectedCount<1){//失败咯
throw new MyException(new Date(),"SaveAction执行失败,entityType:"+entityType,"更新失败");
}else{
resultMap.put("tipInfo", "更新成功");
actionUrl="tip.jsp";
return resultMap;
}
}
}

package action;
import java.util.Map;
import operation.JobOperation;
import util.Constant;
import entity.Job;
import entity.User;
import exception.MyException;
import factory.OperationFactory;
/***
* 动作：学生做作业/老师批阅作业
* @author 猫哥
* @date 2017.2.20
*/
public class SaveJobAction extends SaveAction{
public SaveJobAction(String entityType,String operationType,Boolean isAddOrEdit,Object saveEntity,User sessionUser){
super(entityType,operationType,isAddOrEdit,saveEntity,sessionUser);
}
@Override
public Map<String,Object> execute() throws MyException {
JobOperation jobOper=(JobOperation)OperationFactory.createOperation(entityType);
Job inputJob=(Job)saveEntity;
Job job=(Job)jobOper.selectById(inputJob.getJobId());
if(sessionUser.getUserRole().getRoleName().equals("学生"))//做作业
{
job.setJobScore("-1");//已做完，未阅
job.setJobContent(inputJob.getJobContent());
job.setJobTime(Constant.getDate());
}
else if(sessionUser.getUserRole().getRoleName().equals("教师"))//批阅
{
job.setJobScore(inputJob.getJobScore());//已做完，未阅
}
//新增完毕后跳转查看作业页面
saveEntity=job;
return super.execute();
}
}
package action;
import java.util.Map;
import entity.Lesson;
import entity.User;
import exception.MyException;
/***
* 动作：选课
* @author 猫哥
* @date 2017.2.20
*/
public class SaveLessonAction extends SaveAction{
public SaveLessonAction(String entityType,String operationType,Boolean isAddOrEdit,Object saveEntity,User sessionUser){
super(entityType,operationType,isAddOrEdit,saveEntity,sessionUser);
}
@Override
public Map<String,Object> execute() throws MyException {
Lesson lesson=(Lesson)saveEntity;
lesson.setLessonUser(sessionUser);
saveEntity=lesson;
return super.execute();
}
}
package action;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import database.MySQLHandler;
import operation.LessonOperation;
import operation.WorkOperation;
import entity.Lesson;
import entity.User;
import entity.Work;
import exception.MyException;
import factory.OperationFactory;
/***
* 动作：保存作业(注意新增作业时需要事务)
* @author 猫哥
* @date 2017.2.17
* @modify 2017.2.19 to remove context
*/
public class SaveWorkAction extends SaveAction{
public SaveWorkAction(String entityType,String operationType,Boolean isAddOrEdit,Object saveEntity,User sessionUser){
super(entityType,operationType,isAddOrEdit,saveEntity,sessionUser);
}
@Override
public Map<String,Object> execute() throws MyException {
Map<String,Object> resultMap=new HashMap<String,Object>();
//获取最大work_id，加一为新id
WorkOperation workOper=(WorkOperation)OperationFactory.createOperation("Work");
int maxId=workOper.selectMaxId();
//获取新增的work信息，maxId+1是没问题的，如果正好别人插入maxId+1，大不了就失败了
Work one=(Work)saveEntity;
one.setWorkId(maxId+1);
//待执行的sql列表
ArrayList<String> sqlList=new ArrayList<String>();
//第一条语句system_Work中新增作业
sqlList.add("insert into system_Work(work_id,Work_title,work_time,work_course)"
+" values('"+one.getWorkId()+"','"+one.getWorkTitle()+"','"+one.getWorkTime()+"','"+one.getWorkCourse().getCourseId()+"')");
//第二条语句student_job中添加多条
LessonOperation lessonOper=(LessonOperation)OperationFactory.createOperation("Lesson");
ArrayList<Lesson> lessonList=(ArrayList<Lesson>)lessonOper.selectByCourseId(one.getWorkCourse().getCourseId());
StringBuilder sqlLesson=new StringBuilder();
sqlLesson.append("insert into student_Job(Job_score,job_user,job_work) values");
for(Lesson lesson:lessonList){
String sql="('-2','"+lesson.getLessonUser().getUserId()+"','"+one.getWorkId()+"'),";
sqlLesson.append(sql);
}
sqlLesson.deleteCharAt(sqlLesson.length()-1);
if(lessonList.size()>0)
sqlList.add(sqlLesson.toString());
//执行事务
MySQLHandler hand=new MySQLHandler();
hand.doTransaction(sqlList);
//新增完毕后跳转查看作业页面
resultMap.put("tipInfo", "更新成功");
actionUrl="tip.jsp";
return resultMap;
}
}
package action;
import inter.IOperation;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import util.Constant;
import exception.MyException;
import factory.OperationFactory;
/***
* 动作：查看用户列表
* @author 猫哥
* @date 2017.2.9
* @modify 2017.2.x(忘记了哪天) add 分页 by 猫哥
* @modify 2017.2.19 to remove context
*/
public class ViewAction extends Action{
//分别代表要显示的页码，每页显示个数，偏移数，总个数，最大页数
protected int page,size,offset,total,maxPage;
public ViewAction(String entityType,String operationType,int page){
super(entityType,operationType);
this.page=page;
}
@Override
public Map<String,Object> execute() throws MyException {
//返回值对象
Map<String,Object> resultMap=new HashMap<String,Object>();
//获取数据库操作对象
IOperation oper=OperationFactory.createOperation(entityType);
//处理分页
total=oper.selectCount();
size=Constant.PageSize.get(entityType);
maxPage=total/size+((total%size)>0?1:0);
if(page>maxPage)//最后一页时点击下一页
page=maxPage;
if(page<1)//第一页时点击上一页
page=1;
offset=(page-1)*size;
//处理返回值
actionUrl=entityType.toLowerCase()+"Manage.jsp";
List result=oper.selectPage(offset, size);
resultMap.put(entityType.toLowerCase()+"s",result);
resultMap.put("currentPage", page);
resultMap.put("maxPage", maxPage);
return resultMap;
}
}
package action;
import java.util.HashMap;
import java.util.Map;
import operation.CourseOperation;
import util.Constant;
import entity.User;
import exception.MyException;
import factory.OperationFactory;
/***
* 动作：查看课程列表(根据登录用户角色不同)
* @author 猫哥
* @date 2017.2.15
* @modify 2017.2.19 to remove context
*/
public class ViewCourseAction extends ViewAction{
protected User sessionUser=null;
public ViewCourseAction(String entityType,String operationType,int page,User sessionUser){
super(entityType,operationType,page);
this.sessionUser=sessionUser;
}
@Override
public Map<String,Object> execute() throws MyException {
//返回值对象
Map<String,Object> resultMap=new HashMap<String,Object>();
//获取数据库操作对象
CourseOperation oper=(CourseOperation)OperationFactory.createOperation(entityType);
if(sessionUser.getUserRole().getRoleName().equals("校长")){//查看全部课程
return super.execute();
}else if(sessionUser.getUserRole().getRoleName().equals("教师")){
//教师特殊之处在于查看课程时，只能看自己创建的课程，注意分页也要重算
total=oper.selectCountByUserId(sessionUser.getUserId());
size=Constant.PageSize.get(entityType);
maxPage=total/size+((total%size)>0?1:0);
if(page>maxPage)//最后一页时点击下一页
page=maxPage;
if(page<1)//第一页时点击上一页
page=1;
offset=(page-1)*size;
resultMap.put(entityType.toLowerCase()+"s",oper.selectPageByUserId(offset, size, sessionUser.getUserId()));
resultMap.put("currentPage", page);
resultMap.put("maxPage", maxPage);
actionUrl="courseManageByTeacher.jsp";
}
else if(sessionUser.getUserRole().getRoleName().equals("学生")){//选课
//教师特殊之处在于查看课程时，只能看自己创建的课程，注意分页也要重算
total=oper.selectCountByStudentId(sessionUser.getUserId());
size=Constant.PageSize.get(entityType);
maxPage=total/size+((total%size)>0?1:0);
if(page>maxPage)//最后一页时点击下一页
page=maxPage;
if(page<1)//第一页时点击上一页
page=1;
offset=(page-1)*size;
resultMap.put(entityType.toLowerCase()+"s",oper.selectPageByStudentId(offset, size, sessionUser.getUserId()));
resultMap.put("currentPage", page);
resultMap.put("maxPage", maxPage);
actionUrl="courseManageByStudent.jsp";
}
return resultMap;
}
}

package action;
import java.util.HashMap;
import java.util.Map;
import operation.JobOperation;
import util.Constant;
import entity.User;
import exception.MyException;
import factory.OperationFactory;
/***
* 动作：查看作业列表(根据登录用户角色不同)
* @author 猫哥
* @date 2017.2.20
*/
public class ViewJobAction extends ViewAction{
protected User sessionUser=null;
public ViewJobAction(String entityType,String operationType,int page,User sessionUser){
super(entityType,operationType,page);
this.sessionUser=sessionUser;
}
@Override
public Map<String,Object> execute() throws MyException {
//返回值对象
Map<String,Object> resultMap=new HashMap<String,Object>();
//获取数据库操作对象
JobOperation oper=(JobOperation)OperationFactory.createOperation(entityType);
if(sessionUser.getUserRole().getRoleName().equals("校长")){//查看全部作业
return super.execute();
}else if(sessionUser.getUserRole().getRoleName().equals("教师")){
//教师负责查看自己课程已完成、未批阅的作业
total=oper.selectCountByTeacherId(sessionUser.getUserId(),"-1");
size=Constant.PageSize.get(entityType);
maxPage=total/size+((total%size)>0?1:0);
if(page>maxPage)//最后一页时点击下一页
page=maxPage;
if(page<1)//第一页时点击上一页
page=1;
offset=(page-1)*size;
resultMap.put(entityType.toLowerCase()+"s",oper.selectPageByTeacherId(offset, size, sessionUser.getUserId(),"-1"));
resultMap.put("currentPage", page);
resultMap.put("maxPage", maxPage);
actionUrl="jobManageByTeacher.jsp";
}
else if(sessionUser.getUserRole().getRoleName().equals("学生")){
//学生查看未做的作业
total=oper.selectCountByStudentId(sessionUser.getUserId(),"-2");
size=Constant.PageSize.get(entityType);
maxPage=total/size+((total%size)>0?1:0);
if(page>maxPage)//最后一页时点击下一页
page=maxPage;
if(page<1)//第一页时点击上一页
page=1;
offset=(page-1)*size;
resultMap.put(entityType.toLowerCase()+"s",oper.selectPageByStudentId(offset, size, sessionUser.getUserId(),"-2"));
resultMap.put("currentPage", page);
resultMap.put("maxPage", maxPage);
actionUrl="jobManageByStudent.jsp";
}
return resultMap;
}
}

package action;
import java.util.List;
import java.util.Map;
import operation.WorkOperation;
import util.Constant;
import exception.MyException;
import factory.OperationFactory;
/***
* 动作：查看作业列表(根据作业名称)
* @author 猫哥
* @date 2017.2.15
* @modify 2017.2.19 to remove context
*/
public class ViewWorkAction extends ViewAction{
protected int courseId;//所属course的id
public ViewWorkAction(String entityType,String operationType,int page,int courseId){
super(entityType,operationType,page);
this.courseId=courseId;
}
@Override
public Map<String,Object> execute() throws MyException {
//利用父类起码可以把actionUrl设置了
Map<String,Object> resultMap=super.execute();
//获取数据库操作对象
WorkOperation oper=(WorkOperation)OperationFactory.createOperation(entityType);
//处理分页
total=oper.selectCountByCourseId(courseId);
size=Constant.PageSize.get(entityType);
maxPage=total/size+((total%size)>0?1:0);
if(page>maxPage)//最后一页时点击下一页
page=maxPage;
if(page<1)//第一页时点击上一页
page=1;
offset=(page-1)*size;
List result=oper.selectPageByCourseId(offset, size,courseId);
resultMap.put(entityType.toLowerCase()+"s",result);
resultMap.put("currentPage", page);
resultMap.put("maxPage", maxPage);
resultMap.put("byCourseId", courseId);
return resultMap;
}
}

package database;
import java.sql.*;//导入数据库相关类库
import java.util.ArrayList;
import java.util.Date;
import exception.MyException;
/**
* MysqlHandler MySQL数据库管理类，使用数据库连接池
* @author 猫哥
* @date 2016.1.9
* @modify 2016.2.6 MysqlHandler-MySQLHandler,use MyException
*/
public class MySQLHandler{
//依然是那熟悉的三个必备参数
private Connection conn = null;
private Statement stmt = null;
private ResultSet rs = null;
//建立数据库连接，此处仅用于提供原始连接，供放入池中使用
public Connection buildConnection() {
String driver = "com.mysql.jdbc.Driver";
String url = "jdbc:mysql://localhost:3306/homework?useUnicode=true&characterEncoding=utf-8";//数据库连接字符串
String user = "root";
String password = "Pass1234";
try{
Class.forName(driver);//加载驱动程序
conn=DriverManager.getConnection(url,user,password);
}
catch(Exception ex){
//暂时不处理（未throw），加上日志模块后记在日志里
new MyException(new Date(),ex.getMessage(),"数据库连接建立异常");
}
return conn;
}
//操作1，“增删改查”中，增、删、改都是执行sql语句，无需返回ResultSet结果集，所以设置为一个方法
public int execute(String sql) throws MyException{
try {
if(conn==null)//未分配
conn=MySQLPool.getConnecton();//用时从池中取，很爽快
stmt=conn.createStatement();
int affectedCount = stmt.executeUpdate(sql);//此处真正执行stmt定义的操作
return affectedCount;//这个是收到影响的行数
}
catch (Exception ex) {
throw new MyException(new Date(),ex.getMessage(),"数据库连接错误");
}
}
//操作2，如果是查询，需返回结果集
public ResultSet query(String sql)throws Exception{
try{
if(conn==null)//未分配
conn=MySQLPool.getConnecton();//用时从池中取，很爽快
stmt=conn.createStatement();
rs = stmt.executeQuery(sql);//执行pstmt中定义的查询
return rs;//将结果集返回
}
catch (Exception ex) {
throw new MyException(new Date(),ex.getMessage(),"数据库连接错误");
}
}
//操作3，释放资源
public void sayGoodbye(){
if(rs!=null){//关闭结果集，这个不关闭也浪费
try {
rs.close();
} catch (Exception ex) {
ex.printStackTrace();
}
}
if(stmt!=null){//关闭Statement，不要浪费
try {
stmt.close();
} catch (Exception ex) {
ex.printStackTrace();
}
}
//此处注意，conn在池中管理，不用关闭，用完回归连接池继续使用
MySQLPool.release(conn);
}

public Boolean doTransaction(ArrayList<String> sqlList) throws MyException{
try{
if(conn==null)//未分配
conn=MySQLPool.getConnecton();//用时从池中取，很爽快
//开始事务(不让mysql自动提交了，程序员做主何时一起提交或者还是回退)
conn.setAutoCommit(false);
for(String sql:sqlList){
stmt=conn.createStatement();
stmt.executeUpdate(sql);
}
//此处提交事务，如果中间所有执行语句没错，则全部一起执行，如果有错跳到catch
conn.commit();
return true;
}
catch (Exception ex) {
try {
//如果有错误，则回归到所有sql未执行状态
conn.rollback();
} catch (SQLException sqlEx) {
new MyException(new Date(),sqlEx.getMessage(),"事务回滚错误");
}
throw new MyException(new Date(),ex.getMessage(),"数据库执行错误");
}finally{
MySQLPool.release(conn);//用完归还
}
}
}
/**
* database包：保存数据库操作基类的包，包含MySQLPool和MySQLHandler类
* MySQLPool：数据库连接池类
* MySQLHandler:使用数据库连接池的mysql数据库操作类
*/
package database;
import java.sql.*;
import java.util.Date;
import java.util.LinkedList;
import exception.MyException;
/**
* MySQL数据库自定义连接池
* @author 猫哥
* @date 2017.2.6修改
*/
public class MySQLPool {
private static LinkedList<Connection> pool = new LinkedList<Connection>();
private static int maxCount=1;//最大连接数
static{//初始化
for(int i=0;i<maxCount;i++){
MySQLHandler handler=new MySQLHandler();
Connection connection = handler.buildConnection();
pool.add(connection);
}
}
public static Connection getConnecton() throws MyException{
if(pool.size()==0)//分配完了
{
throw new MyException(new Date(),"数据库连接池资源短缺，无连接可分配","数据库连接错误");
}
else{
return pool.remove(0);//删除第一个对象并返回
}
}
public static void release(Connection connection){//使用完的归还给池子
pool.add(connection);
}
}

/**
* entity包：包含所有实体类的包
* 实体类计有：Course Job Lesson Role User Work
*/
package entity;
public class Course{//对应system_course
private int courseId;
private String courseName;
private User courseUser;
public int getCourseId() {
return courseId;
}
public void setCourseId(int courseId) {
this.courseId = courseId;
}
public String getCourseName() {
return courseName;
}
public void setCourseName(String courseName) {
this.courseName = courseName;
}
public User getCourseUser() {
return courseUser;
}
public void setCourseUser(User courseUser) {
this.courseUser = courseUser;
}
}
package entity;
public class Job{//对应work_job
private int jobId;
private String jobTime;
private String jobContent;
private String jobScore;
private Work jobWork;
private User jobUser;
public int getJobId() {
return jobId;
}
public void setJobId(int jobId) {
this.jobId = jobId;
}
public String getJobTime() {
return jobTime;
}
public void setJobTime(String jobTime) {
this.jobTime = jobTime;
}
public String getJobContent() {
return jobContent;
}
public void setJobContent(String jobContent) {
this.jobContent = jobContent;
}
public String getJobScore() {
return jobScore;
}
public void setJobScore(String jobScore) {
this.jobScore = jobScore;
}
public Work getJobWork() {
return jobWork;
}
public void setJobWork(Work jobWork) {
this.jobWork = jobWork;
}
public User getJobUser() {
return jobUser;
}
public void setJobUser(User jobUser) {
this.jobUser = jobUser;
}
}
package entity;
//学生选课
public class Lesson {
private int lessonId;
private User lessonUser;
private Course lessonCourse;
public int getLessonId() {
return lessonId;
}
public void setLessonId(int lessonId) {
this.lessonId = lessonId;
}
public User getLessonUser() {
return lessonUser;
}
public void setLessonUser(User lessonUser) {
this.lessonUser = lessonUser;
}
public Course getLessonCourse() {
return lessonCourse;
}
public void setLessonCourse(Course lessonCourse) {
this.lessonCourse = lessonCourse;
}
}
package entity;
public class Role{//对应system_role
private int roleId;
private String roleName;
public int getRoleId() {
return roleId;
}
public void setRoleId(int roleId) {
this.roleId = roleId;
}
public String getRoleName() {
return roleName;
}
public void setRoleName(String roleName) {
this.roleName = roleName;
}
}
package entity;
public class User{//对应system_user
private int userId;
private String userName;
private String userPassword;
private Role userRole;
public int getUserId() {
return userId;
}
public void setUserId(int userId) {
this.userId = userId;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String getUserPassword() {
return userPassword;
}
public void setUserPassword(String userPassword) {
this.userPassword = userPassword;
}
public Role getUserRole() {
return userRole;
}
public void setUserRole(Role userRole) {
this.userRole = userRole;
}
}
package entity;
public class Work {//对应system_work
private int workId;
private String workTitle;
private String workTime;
private Course workCourse;
public int getWorkId() {
return workId;
}
public void setWorkId(int workId) {
this.workId = workId;
}
public String getWorkTitle() {
return workTitle;
}
public void setWorkTitle(String workTitle) {
this.workTitle = workTitle;
}
public String getWorkTime() {
return workTime;
}
public void setWorkTime(String workTime) {
this.workTime = workTime;
}
public Course getWorkCourse() {
return workCourse;
}
public void setWorkCourse(Course workCourse) {
this.workCourse = workCourse;
}
}

/**
* exception包：包含自定义异常类的包
*/
package exception;
import java.util.Date;
import util.ExceptionLogger;
public class MyException extends Exception{
private Date time;//记录异常发生时间
private String message;//原始异常信息，给程序员看，记录日志
private String info;//自定义信息，给用户看
public MyException(){
super();
}
public MyException(Date time,String msg,String info){
super();
this.time=time;
this.message=msg;
this.info=info;
//日志
ExceptionLogger.logInfo(msg+"##"+info);
}
public Date getTime() {
return time;
}
public void setTime(Date time) {
this.time = time;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
public String getInfo() {
return info;
}
public void setInfo(String info) {
this.info = info;
}
}

/**
* factory包，工厂类包
* EntityFactory：用于从HttpServletRequest生成实体类对象的工厂
* OperationFactory:用于生成Operation类的工厂
*/
package factory;
import javax.servlet.http.HttpServletRequest;
import util.Constant;
import entity.*;
public class EntityFactory {
//组装的工艺类型entityType+组装的材料来源request
public static Object createEntityFromRequest(String entityType,HttpServletRequest request){
String id=request.getParameter("entityId");
if(entityType.equals("User")){
User user=new User();
if(id==null||"".equals(id)){//属于add
user.setUserId(-1);
}else{//属于edit
user.setUserId(Integer.parseInt(id));
}
user.setUserPassword(request.getParameter("userPassword"));
user.setUserName(request.getParameter("userName"));
Role role=new Role();
role.setRoleId(Integer.parseInt(request.getParameter("userRole")));
user.setUserRole(role);
return user;
}
else if(entityType.equals("Course")){
Course course=new Course();
if(id==null||"".equals(id)){//属于add
course.setCourseId(-1);
}else{//属于edit
course.setCourseId(Integer.parseInt(id));
}
course.setCourseName(request.getParameter("courseName"));
course.setCourseUser((User)request.getSession().getAttribute("sessionUser"));
return course;
}
else if(entityType.equals("Work")){
Work work=new Work();
if(id==null||"".equals(id)){//属于add
work.setWorkId(-1);
}else{//属于edit
work.setWorkId(Integer.parseInt(id));
}
Course course=new Course();
String temp=request.getParameter("workCourse");
course.setCourseId(Integer.parseInt(temp));
work.setWorkCourse(course);
work.setWorkTitle(request.getParameter("workTitle"));
work.setWorkTime(Constant.getDate());
return work;
}
else if(entityType.equals("Job")){
//不管是老师批阅，还是学生做作业，均为修改
Job job=new Job();
job.setJobId(Integer.parseInt(id));
//只会用到jobContent、jobScore
job.setJobContent(request.getParameter("jobContent"));
job.setJobScore(request.getParameter("jobScore"));
return job;
}
else if(entityType.equals("Lesson")){//选课，都是新增
Lesson lesson=new Lesson();
lesson.setLessonId(-1);
Course course=new Course();
course.setCourseId(Integer.parseInt(request.getParameter("courseId")));
lesson.setLessonCourse(course);
return lesson;
}
return null;
}
}
package factory;
import inter.IOperation;
import operation.*;
public class OperationFactory {
public static IOperation createOperation(String entityType){
if(entityType.equals("User")){
return new UserOperation();
}else if(entityType.equals("Role")){
return new RoleOperation();
}else if(entityType.equals("Work")){
return new WorkOperation();
}else if(entityType.equals("Job")){
return new JobOperation();
}else if(entityType.equals("Course")){
return new CourseOperation();
}else if(entityType.equals("Lesson")){
return new LessonOperation();
}
return null;
}
}

/**
* inter包：接口包，用于保存所有接口interface
* IAction接口：定义Aciton动作类的规范
* IOperation接口：定义Operation数据库实体操作类的规范
*/
package inter;
import java.util.Map;
import exception.MyException;
public interface IAction {
//执行动作，并返回一些结果
public Map<String, Object> execute()throws MyException;
}
package inter;
import java.util.List;
//规范了用于执行对象对应数据库表基本操作的类
public interface IOperation {
public int selectCount();//获取个数
public List selectAll();//选取表中所有数据
public List selectPage(int offset,int size);//分页显示，第一个参数为起始位置（按id排序），第二个参数为每页显示个数
public Object selectById(int id);//按id获取一条记录
public int add(Object obj);//添加一条数据
public int deleteById(int id);//按id删除一条记录
public int update(Object obj);//按obj对象的信息修改一条记录(以obj的id标记需要修改的记录)
}

/**
* operation包：保存数据库实体对象操作类的包
* 计有CourseOperation JobOperation LessonOperation RoleOperation UserOperation WorkOperation
* 因代码量太大且逻辑相近，此处只展示了CourseOperation
*/
package operation;
import inter.IOperation;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import database.MySQLHandler;
import entity.*;
import exception.MyException;
public class CourseOperation implements IOperation{
//学生选课使用begin
public int selectCountByStudentId(int studentId) {
MySQLHandler hand=new MySQLHandler();
ResultSet rs=null;
int re=0;
try {
//此处不要写select *，因为数据库将*转换为该表所有列名肯定需要浪费时间
rs=hand.query("select count(course_id) as count from system_course where course_id"
+" not in(select lesson_course from student_lesson l where l.lesson_user='"+studentId+"')");
while(rs.next()){
re=rs.getInt("count");
}
return re;
} catch (Exception ex) {
//对于数据库操作层面的异常，此时不予以向外抛出，记录在日志中分析即可
//在设计的时候就要明确，什么类型异常要外抛，什么异常不抛出只记录
new MyException(new Date(),ex.getMessage(),"CourseOperation.selectCountByStudentId异常");
return 0;//注意null和new Course()并不同！
}finally{
hand.sayGoodbye();
}
}
public List selectPageByStudentId(int offset, int size,int studentId) {
MySQLHandler hand=new MySQLHandler();
ResultSet rs=null;
ArrayList<Course> list=new ArrayList<Course>();//返回值
try {
rs=hand.query("select Course_id,Course_name,user_id,user_name from "
+" system_Course c,system_user u where c.Course_user=u.user_id "
+" and c.course_id not in (select lesson_course from student_lesson l where l.lesson_user='"+studentId+"')"
+" order by c.Course_id limit "+offset+","+size);
while(rs.next()){
Course one=new Course();//返回值中的一个
one.setCourseId(rs.getInt("Course_id"));
one.setCourseName(rs.getString("Course_name"));
User user=new User();
user.setUserId(rs.getInt("user_id"));
user.setUserName(rs.getString("user_name"));
one.setCourseUser(user);
list.add(one);//添加到列表
}
return list;
} catch (Exception ex) {
new MyException(new Date(),ex.getMessage(),"CourseOperation.selectPageByStudentId异常");
return null;
}finally{
hand.sayGoodbye();
}
}
//学生选课使用end
@Override
public int selectCount() {
MySQLHandler hand=new MySQLHandler();
ResultSet rs=null;
int re=0;
try {
//此处不要写select *，因为数据库将*转换为该表所有列名肯定需要浪费时间
rs=hand.query("select count(course_id) as count from system_course");
while(rs.next()){
re=rs.getInt("count");
}
return re;
} catch (Exception ex) {
//对于数据库操作层面的异常，此时不予以向外抛出，记录在日志中分析即可
//在设计的时候就要明确，什么类型异常要外抛，什么异常不抛出只记录
new MyException(new Date(),ex.getMessage(),"CourseOperation.selectCount异常");
return 0;//注意null和new Course()并不同！
}finally{
hand.sayGoodbye();
}
}
public int selectCountByUserId(int userId) {
MySQLHandler hand=new MySQLHandler();
ResultSet rs=null;
int re=0;
try {
//此处不要写select *，因为数据库将*转换为该表所有列名肯定需要浪费时间
rs=hand.query("select count(course_id) as count from system_course where course_user='"+userId+"'");
while(rs.next()){
re=rs.getInt("count");
}
return re;
} catch (Exception ex) {
//对于数据库操作层面的异常，此时不予以向外抛出，记录在日志中分析即可
//在设计的时候就要明确，什么类型异常要外抛，什么异常不抛出只记录
new MyException(new Date(),ex.getMessage(),"CourseOperation.selectCount异常");
return 0;//注意null和new Course()并不同！
}finally{
hand.sayGoodbye();
}
}
@Override
public Object selectById(int id) {
MySQLHandler hand=new MySQLHandler();
ResultSet rs=null;
Course one=new Course();//如果查询内容为空，则通过one.getCourseId()==0来判断即可
try {
//此处不要写select *，因为数据库将*转换为该表所有列名肯定需要浪费时间
rs=hand.query("select Course_id,Course_name,user_id,user_name from "
+"system_Course c,system_user u where c.Course_id='"+id+"' and c.Course_user=u.user_id");
while(rs.next()){
one.setCourseId(rs.getInt("Course_id"));
one.setCourseName(rs.getString("Course_name"));
User user=new User();
user.setUserId(rs.getInt("user_id"));
user.setUserName(rs.getString("user_name"));
one.setCourseUser(user);
}
return one;
} catch (Exception ex) {
//对于数据库操作层面的异常，此时不予以向外抛出，记录在日志中分析即可
//在设计的时候就要明确，什么类型异常要外抛，什么异常不抛出只记录
new MyException(new Date(),ex.getMessage(),"CourseOperation.selectById异常");
return null;//注意null和new Course()并不同！
}finally{
hand.sayGoodbye();
}
}
@Override
public List selectAll() {//注意返回值null和list.size()==0的区别
MySQLHandler hand=new MySQLHandler();
ResultSet rs=null;
ArrayList<Course> list=new ArrayList<Course>();//返回值
try {
rs=hand.query("select Course_id,Course_name,user_id,user_name from "
+"system_Course c,system_user u where c.Course_user=u.user_id");
while(rs.next()){
Course one=new Course();//返回值中的一个
one.setCourseId(rs.getInt("Course_id"));
one.setCourseName(rs.getString("Course_name"));
User user=new User();
user.setUserId(rs.getInt("user_id"));
user.setUserName(rs.getString("user_name"));
one.setCourseUser(user);
list.add(one);//添加到列表
}
return list;
} catch (Exception ex) {
new MyException(new Date(),ex.getMessage(),"CourseOperation.selectAll异常");
return null;
}finally{
hand.sayGoodbye();
}
}
public List selectAllByUserId(int userId) {//注意返回值null和list.size()==0的区别
MySQLHandler hand=new MySQLHandler();
ResultSet rs=null;
ArrayList<Course> list=new ArrayList<Course>();//返回值
try {
rs=hand.query("select Course_id,Course_name,user_id,user_name from "
+"system_Course c,system_user u where c.Course_user=u.user_id"
+" and u.user_id='"+userId+"'");
while(rs.next()){
Course one=new Course();//返回值中的一个
one.setCourseId(rs.getInt("Course_id"));
one.setCourseName(rs.getString("Course_name"));
User user=new User();
user.setUserId(rs.getInt("user_id"));
user.setUserName(rs.getString("user_name"));
one.setCourseUser(user);
list.add(one);//添加到列表
}
return list;
} catch (Exception ex) {
new MyException(new Date(),ex.getMessage(),"CourseOperation.selectAll异常");
return null;
}finally{
hand.sayGoodbye();
}
}
@Override
public List selectPage(int offset, int size) {
MySQLHandler hand=new MySQLHandler();
ResultSet rs=null;
ArrayList<Course> list=new ArrayList<Course>();//返回值
try {
rs=hand.query("select Course_id,Course_name,user_id,user_name from "
+" system_Course c,system_user u where c.Course_user=u.user_id "
+" order by c.Course_id limit "+offset+","+size);
while(rs.next()){
Course one=new Course();//返回值中的一个
one.setCourseId(rs.getInt("Course_id"));
one.setCourseName(rs.getString("Course_name"));
User user=new User();
user.setUserId(rs.getInt("user_id"));
user.setUserName(rs.getString("user_name"));
one.setCourseUser(user);
list.add(one);//添加到列表
}
return list;
} catch (Exception ex) {
new MyException(new Date(),ex.getMessage(),"CourseOperation.selectPage异常");
return null;
}finally{
hand.sayGoodbye();
}
}
public List selectPageByUserId(int offset, int size,int userId) {
MySQLHandler hand=new MySQLHandler();
ResultSet rs=null;
ArrayList<Course> list=new ArrayList<Course>();//返回值
try {
rs=hand.query("select Course_id,Course_name,user_id,user_name from "
+" system_Course c,system_user u where c.Course_user=u.user_id and user_id='"+userId+"'"
+" order by c.Course_id limit "+offset+","+size);
while(rs.next()){
Course one=new Course();//返回值中的一个
one.setCourseId(rs.getInt("Course_id"));
one.setCourseName(rs.getString("Course_name"));
User user=new User();
user.setUserId(rs.getInt("user_id"));
user.setUserName(rs.getString("user_name"));
one.setCourseUser(user);
list.add(one);//添加到列表
}
return list;
} catch (Exception ex) {
new MyException(new Date(),ex.getMessage(),"CourseOperation.selectPage异常");
return null;
}finally{
hand.sayGoodbye();
}
}
@Override
public int add(Object obj) {
Course one=(Course)obj;
MySQLHandler hand=new MySQLHandler();
try {
int re=hand.execute("insert into system_Course(Course_name,Course_user)"
+" values('"+one.getCourseName()+"','"+one.getCourseUser().getUserId()+"')");
return re;
} catch (Exception ex) {
new MyException(new Date(),ex.getMessage(),"CourseOperation.add异常");
return 0;
}finally{
hand.sayGoodbye();
}
}
@Override
public int deleteById(int id) {
MySQLHandler hand=new MySQLHandler();
try {
int re=hand.execute("delete from system_Course where Course_id='"+id+"'");
return re;
} catch (Exception ex) {
new MyException(new Date(),ex.getMessage(),"CourseOperation.deleteById异常");
return 0;
}finally{
hand.sayGoodbye();
}
}
@Override
public int update(Object obj) {
Course one=(Course)obj;
MySQLHandler hand=new MySQLHandler();
try {
int re=hand.execute("update system_Course set Course_name='"+one.getCourseName()
+"',Course_user='"+one.getCourseUser().getUserId()
+"' where Course_id='"+one.getCourseId()+"'");
return re;
} catch (Exception ex) {
new MyException(new Date(),ex.getMessage(),"CourseOperation.update异常");
return 0;
}finally{
hand.sayGoodbye();
}
}
}
package operation;
import inter.IOperation;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import database.MySQLHandler;
import entity.*;
import exception.MyException;
public class JobOperation implements IOperation{
//教师查看未批阅作业使用的两个方法begin
public int selectCountByTeacherId(int teacherId,String jobScore){
MySQLHandler hand=new MySQLHandler();
ResultSet rs=null;
int re=0;
try {
//此处不要写select *，因为数据库将*转换为该表所有列名肯定需要浪费时间
rs=hand.query("select count(job_id) as count from student_job j,system_work w,system_course c"
+" where c.course_user='"+teacherId+"' and c.course_id=w.work_course"
+" and w.work_id=j.job_work "
+" and job_score='"+jobScore+"'");
while(rs.next()){
re=rs.getInt("count");
}
return re;
} catch (Exception ex) {
//对于数据库操作层面的异常，此时不予以向外抛出，记录在日志中分析即可
//在设计的时候就要明确，什么类型异常要外抛，什么异常不抛出只记录
new MyException(new Date(),ex.getMessage(),"JobOperation.selectCount异常");
return 0;//注意null和new Course()并不同！
}finally{
hand.sayGoodbye();
}
}
public List selectPageByTeacherId(int offset,int size,int teacherId,String jobScore){
MySQLHandler hand=new MySQLHandler();
ResultSet rs=null;
ArrayList<Job> list=new ArrayList<Job>();//返回值
try {
rs=hand.query("select Job_id,job_content,job_score,job_time,user_id,user_name,work_id,work_title from "
+" student_Job j,system_user u,system_work w,system_course c"
+" where j.Job_user=u.user_id and j.job_work=w.work_id "
+" and w.work_course=c.course_id and c.course_user='"+teacherId+"'"
+" and j.job_score='"+jobScore+"'"
+" order by j.job_id limit "+offset+","+size);
while(rs.next()){
Job one=new Job();//返回值中的一个
one.setJobId(rs.getInt("Job_id"));
one.setJobContent(rs.getString("job_content"));
one.setJobScore(rs.getString("job_score"));
one.setJobTime(rs.getString("job_time"));
User user=new User();
user.setUserId(rs.getInt("user_id"));
user.setUserName(rs.getString("user_name"));
one.setJobUser(user);
Work work=new Work();
work.setWorkId(rs.getInt("work_id"));
work.setWorkTitle(rs.getString("work_title"));
one.setJobWork(work);
list.add(one);//添加到列表
}
return list;
} catch (Exception ex) {
new MyException(new Date(),ex.getMessage(),"JobOperation.selectPage异常");
return null;
}finally{
hand.sayGoodbye();
}
}
//教师查看未批阅作业使用的两个方法end
//学生查看未做作业使用的两个方法begin
public int selectCountByStudentId(int studentId,String jobScore){
MySQLHandler hand=new MySQLHandler();
ResultSet rs=null;
int re=0;
try {
//此处不要写select *，因为数据库将*转换为该表所有列名肯定需要浪费时间
rs=hand.query("select count(job_id) as count from student_job where job_user='"+studentId+"'"
+" and job_score='"+jobScore+"'");
while(rs.next()){
re=rs.getInt("count");
}
return re;
} catch (Exception ex) {
//对于数据库操作层面的异常，此时不予以向外抛出，记录在日志中分析即可
//在设计的时候就要明确，什么类型异常要外抛，什么异常不抛出只记录
new MyException(new Date(),ex.getMessage(),"JobOperation.selectCount异常");
return 0;//注意null和new Course()并不同！
}finally{
hand.sayGoodbye();
}
}
public List selectPageByStudentId(int offset,int size,int studentId,String jobScore){
MySQLHandler hand=new MySQLHandler();
ResultSet rs=null;
ArrayList<Job> list=new ArrayList<Job>();//返回值
try {
rs=hand.query("select Job_id,job_content,job_score,job_time,user_id,user_name,work_id,work_title from "
+" student_Job j,system_user u,system_work w where j.Job_user=u.user_id and j.job_work=w.work_id "
+" and u.user_id='"+studentId+"' and j.job_score='"+jobScore+"'"
+" order by j.job_id limit "+offset+","+size);
while(rs.next()){
Job one=new Job();//返回值中的一个
one.setJobId(rs.getInt("Job_id"));
one.setJobContent(rs.getString("job_content"));
one.setJobScore(rs.getString("job_score"));
one.setJobTime(rs.getString("job_time"));
User user=new User();
user.setUserId(rs.getInt("user_id"));
user.setUserName(rs.getString("user_name"));
one.setJobUser(user);
Work work=new Work();
work.setWorkId(rs.getInt("work_id"));
work.setWorkTitle(rs.getString("work_title"));
one.setJobWork(work);
list.add(one);//添加到列表
}
return list;
} catch (Exception ex) {
new MyException(new Date(),ex.getMessage(),"JobOperation.selectPage异常");
return null;
}finally{
hand.sayGoodbye();
}
}
//学生查看未做作业使用的两个方法end
@Override
public int selectCount() {
MySQLHandler hand=new MySQLHandler();
ResultSet rs=null;
int re=0;
try {
//此处不要写select *，因为数据库将*转换为该表所有列名肯定需要浪费时间
rs=hand.query("select count(job_id) as count  from student_job");
while(rs.next()){
re=rs.getInt("count");
}
return re;
} catch (Exception ex) {
//对于数据库操作层面的异常，此时不予以向外抛出，记录在日志中分析即可
//在设计的时候就要明确，什么类型异常要外抛，什么异常不抛出只记录
new MyException(new Date(),ex.getMessage(),"JobOperation.selectCount异常");
return 0;//注意null和new Course()并不同！
}finally{
hand.sayGoodbye();
}
}
@Override
public Object selectById(int id) {
MySQLHandler hand=new MySQLHandler();
ResultSet rs=null;
Job one=new Job();//如果查询内容为空，则通过one.getJobId()==0来判断即可
try {
//此处不要写select *，因为数据库将*转换为该表所有列名肯定需要浪费时间
rs=hand.query("select Job_id,job_content,job_score,job_time,user_id,user_name,work_id,work_title from "
+"student_Job j,system_user u,system_work w where j.Job_id='"+id+"' and j.Job_user=u.user_id and j.job_work=w.work_id");
while(rs.next()){
one.setJobId(rs.getInt("Job_id"));
one.setJobContent(rs.getString("job_content"));
one.setJobScore(rs.getString("job_score"));
one.setJobTime(rs.getString("job_time"));
User user=new User();
user.setUserId(rs.getInt("user_id"));
user.setUserName(rs.getString("user_name"));
one.setJobUser(user);
Work work=new Work();
work.setWorkId(rs.getInt("work_id"));
work.setWorkTitle(rs.getString("work_title"));
one.setJobWork(work);
}
return one;
} catch (Exception ex) {
//对于数据库操作层面的异常，此时不予以向外抛出，记录在日志中分析即可
//在设计的时候就要明确，什么类型异常要外抛，什么异常不抛出只记录
new MyException(new Date(),ex.getMessage(),"JobOperation.selectById异常");
return null;//注意null和new Job()并不同！
}finally{
hand.sayGoodbye();
}
}
@Override
public List selectAll() {//注意返回值null和list.size()==0的区别
MySQLHandler hand=new MySQLHandler();
ResultSet rs=null;
ArrayList<Job> list=new ArrayList<Job>();//返回值
try {
rs=hand.query("select Job_id,job_content,job_score,job_time,user_id,user_name,work_id,work_title from "
+"student_Job j,system_user u,system_work w where j.Job_user=u.user_id and j.job_work=w.work_id");
while(rs.next()){
Job one=new Job();//返回值中的一个
one.setJobId(rs.getInt("Job_id"));
one.setJobContent(rs.getString("job_content"));
one.setJobScore(rs.getString("job_score"));
one.setJobTime(rs.getString("job_time"));
User user=new User();
user.setUserId(rs.getInt("user_id"));
user.setUserName(rs.getString("user_name"));
one.setJobUser(user);
Work work=new Work();
work.setWorkId(rs.getInt("work_id"));
work.setWorkTitle(rs.getString("work_title"));
one.setJobWork(work);
list.add(one);//添加到列表
}
return list;
} catch (Exception ex) {
new MyException(new Date(),ex.getMessage(),"JobOperation.selectAll异常");
return null;
}finally{
hand.sayGoodbye();
}
}
@Override
public List selectPage(int offset,int size) {//注意返回值null和list.size()==0的区别
MySQLHandler hand=new MySQLHandler();
ResultSet rs=null;
ArrayList<Job> list=new ArrayList<Job>();//返回值
try {
rs=hand.query("select Job_id,job_content,job_score,job_time,user_id,user_name,work_id,work_title from "
+" student_Job j,system_user u,system_work w where j.Job_user=u.user_id and j.job_work=w.work_id "
+" order by j.job_id limit "+offset+","+size);
while(rs.next()){
Job one=new Job();//返回值中的一个
one.setJobId(rs.getInt("Job_id"));
one.setJobContent(rs.getString("job_content"));
one.setJobScore(rs.getString("job_score"));
one.setJobTime(rs.getString("job_time"));
User user=new User();
user.setUserId(rs.getInt("user_id"));
user.setUserName(rs.getString("user_name"));
one.setJobUser(user);
Work work=new Work();
work.setWorkId(rs.getInt("work_id"));
work.setWorkTitle(rs.getString("work_title"));
one.setJobWork(work);
list.add(one);//添加到列表
}
return list;
} catch (Exception ex) {
new MyException(new Date(),ex.getMessage(),"JobOperation.selectPage异常");
return null;
}finally{
hand.sayGoodbye();
}
}
@Override
public int add(Object obj) {
Job one=(Job)obj;
MySQLHandler hand=new MySQLHandler();
try {
int re=hand.execute("insert into student_Job(Job_content,Job_score,job_time,job_user,job_work)"
+" values('"+one.getJobContent()+"','"+one.getJobScore()+"','"+
one.getJobTime()+"','"+one.getJobUser().getUserId()+"','"+one.getJobWork().getWorkId()+"')");
return re;
} catch (Exception ex) {
new MyException(new Date(),ex.getMessage(),"JobOperation.add异常");
return 0;
}finally{
hand.sayGoodbye();
}
}
@Override
public int deleteById(int id) {
MySQLHandler hand=new MySQLHandler();
try {
int re=hand.execute("delete from student_Job where Job_id='"+id+"'");
return re;
}
21134
catch (Exception ex) {
new MyException(new Date(),ex.getMessage(),"JobOperation.deleteById异常");
return 0;
}finally{
hand.sayGoodbye();
}
}
@Override
public int update(Object obj) {
Job one=(Job)obj;
MySQLHandler hand=new MySQLHandler();
try {
int re=hand.execute("update student_Job set Job_content='"+one.getJobContent()
+"',Job_score='"+one.getJobScore()
+"',Job_time='"+one.getJobTime()
+"',Job_user='"+one.getJobUser().getUserId()
+"',Job_work='"+one.getJobWork().getWorkId()
+"' where Job_id='"+one.getJobId()+"'");
return re;
} catch (Exception ex) {
new MyException(new Date(),ex.getMessage(),"JobOperation.update异常");
return 0;
}finally{
hand.sayGoodbye();
}
}

}
package operation;
import inter.IOperation;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import database.MySQLHandler;
import entity.*;
import exception.MyException;
public class LessonOperation implements IOperation{
@Override
public int selectCount() {
MySQLHandler hand=new MySQLHandler();
ResultSet rs=null;
int re=0;
try {
//此处不要写select *，因为数据库将*转换为该表所有列名肯定需要浪费时间
rs=hand.query("select count(lesson_id) as count  from student_lesson");
while(rs.next()){
re=rs.getInt("count");
}
return re;
} catch (Exception ex) {
//对于数据库操作层面的异常，此时不予以向外抛出，记录在日志中分析即可
//在设计的时候就要明确，什么类型异常要外抛，什么异常不抛出只记录
new MyException(new Date(),ex.getMessage(),"LessonOperation.selectCount异常");
return 0;//注意null和new Course()并不同！
}finally{
hand.sayGoodbye();
}
}
@Override
public Object selectById(int id) {
MySQLHandler hand=new MySQLHandler();
ResultSet rs=null;
Lesson one=new Lesson();//如果查询内容为空，则通过one.getLessonId()==0来判断即可
try {
//此处不要写select *，因为数据库将*转换为该表所有列名肯定需要浪费时间
rs=hand.query("select Lesson_id,user_id,user_name,course_id,course_name from "
+" student_Lesson l,system_user u,system_course c"
+" where l.Lesson_id='"+id+"' and l.Lesson_user=u.user_id and l.Lesson_course=c.course_id");
while(rs.next()){
one.setLessonId(rs.getInt("Lesson_id"));
User user=new User();
user.setUserId(rs.getInt("user_id"));
user.setUserName(rs.getString("user_name"));
one.setLessonUser(user);
Course course=new Course();
course.setCourseId(rs.getInt("course_id"));
course.setCourseName(rs.getString("course_name"));
one.setLessonCourse(course);
}
return one;
} catch (Exception ex) {
//对于数据库操作层面的异常，此时不予以向外抛出，记录在日志中分析即可
//在设计的时候就要明确，什么类型异常要外抛，什么异常不抛出只记录
new MyException(new Date(),ex.getMessage(),"LessonOperation.selectById异常");
return null;//注意null和new Lesson()并不同！
}finally{
hand.sayGoodbye();
}
}
@Override
public List selectAll() {//注意返回值null和list.size()==0的区别
MySQLHandler hand=new MySQLHandler();
ResultSet rs=null;
ArrayList<Lesson> list=new ArrayList<Lesson>();//返回值
try {
rs=hand.query("select Lesson_id,user_id,user_name,course_id,course_name from "
+" student_Lesson l,system_user u,system_course c"
+" where l.Lesson_user=u.user_id and l.Lesson_course=c.course_id");
while(rs.next()){
Lesson one=new Lesson();//返回值中的一个
one.setLessonId(rs.getInt("Lesson_id"));
User user=new User();
user.setUserId(rs.getInt("user_id"));
user.setUserName(rs.getString("user_name"));
one.setLessonUser(user);
Course course=new Course();
course.setCourseId(rs.getInt("course_id"));
course.setCourseName(rs.getString("course_name"));
one.setLessonCourse(course);
list.add(one);//添加到列表
}
return list;
} catch (Exception ex) {
new MyException(new Date(),ex.getMessage(),"LessonOperation.selectAll异常");
return null;
}finally{
hand.sayGoodbye();
}
}
public List selectByCourseId(int courseId) {//注意返回值null和list.size()==0的区别
MySQLHandler hand=new MySQLHandler();
ResultSet rs=null;
ArrayList<Lesson> list=new ArrayList<Lesson>();//返回值
try {
rs=hand.query("select Lesson_id,user_id,user_name,course_id,course_name from "
+" student_Lesson l,system_user u,system_course c"
+" where l.Lesson_user=u.user_id and l.Lesson_course=c.course_id"
+" and c.course_id='"+courseId+"'");
while(rs.next()){
Lesson one=new Lesson();//返回值中的一个
one.setLessonId(rs.getInt("Lesson_id"));
User user=new User();
user.setUserId(rs.getInt("user_id"));
user.setUserName(rs.getString("user_name"));
one.setLessonUser(user);
Course course=new Course();
course.setCourseId(rs.getInt("course_id"));
course.setCourseName(rs.getString("course_name"));
one.setLessonCourse(course);
list.add(one);//添加到列表
}
return list;
} catch (Exception ex) {
new MyException(new Date(),ex.getMessage(),"LessonOperation.selectAll异常");
return null;
}finally{
hand.sayGoodbye();
}
}
@Override
public List selectPage(int offset,int size) {//注意返回值null和list.size()==0的区别
MySQLHandler hand=new MySQLHandler();
ResultSet rs=null;
ArrayList<Lesson> list=new ArrayList<Lesson>();//返回值
try {
rs=hand.query("select Lesson_id,user_id,user_name,course_id,course_name from "
+" student_Lesson l,system_user u,system_course c"
+" where l.Lesson_user=u.user_id and l.Lesson_course=c.course_id"
+" order by l.lesson_id limit "+offset+","+size);
while(rs.next()){
Lesson one=new Lesson();//返回值中的一个
one.setLessonId(rs.getInt("Lesson_id"));
User user=new User();
user.setUserId(rs.getInt("user_id"));
user.setUserName(rs.getString("user_name"));
one.setLessonUser(user);
Course course=new Course();
course.setCourseId(rs.getInt("course_id"));
course.setCourseName(rs.getString("course_name"));
one.setLessonCourse(course);
list.add(one);//添加到列表
}
return list;
} catch (Exception ex) {
new MyException(new Date(),ex.getMessage(),"LessonOperation.selectPage异常");
return null;
}finally{
hand.sayGoodbye();
}
}
@Override
public int add(Object obj) {
Lesson one=(Lesson)obj;
MySQLHandler hand=new MySQLHandler();
try {
int re=hand.execute("insert into student_Lesson(Lesson_user,Lesson_course)"
+" values('"+one.getLessonUser().getUserId()+"','"+one.getLessonCourse().getCourseId()+"')");
return re;
} catch (Exception ex) {
new MyException(new Date(),ex.getMessage(),"LessonOperation.add异常");
return 0;
}finally{
hand.sayGoodbye();
}
}
@Override
public int deleteById(int id) {
MySQLHandler hand=new MySQLHandler();
try {
int re=hand.execute("delete from system_Lesson where Lesson_id='"+id+"'");
return re;
} catch (Exception ex) {
new MyException(new Date(),ex.getMessage(),"LessonOperation.deleteById异常");
return 0;
}finally{
hand.sayGoodbye();
}
}
@Override
public int update(Object obj) {
Lesson one=(Lesson)obj;
MySQLHandler hand=new MySQLHandler();
try {
int re=hand.execute("update student_Lesson set "
+"'Lesson_user='"+one.getLessonUser().getUserId()
+"',Lesson_course='"+one.getLessonCourse().getCourseId()
+"' where Lesson_id='"+one.getLessonId()+"'");
return re;
} catch (Exception ex) {
new MyException(new Date(),ex.getMessage(),"LessonOperation.update异常");
return 0;
}finally{
hand.sayGoodbye();
}
}
}
package operation;
import inter.IOperation;
import java.sql.ResultSet;
import java.util.*;
import database.MySQLHandler;
import entity.*;
import exception.MyException;
public class RoleOperation implements IOperation{
@Override
public int selectCount() {
MySQLHandler hand=new MySQLHandler();
ResultSet rs=null;
int re=0;
try {
//此处不要写select *，因为数据库将*转换为该表所有列名肯定需要浪费时间
rs=hand.query("select count(role_id) as count  from system_role");
while(rs.next()){
re=rs.getInt("count");
}
return re;
} catch (Exception ex) {
//对于数据库操作层面的异常，此时不予以向外抛出，记录在日志中分析即可
//在设计的时候就要明确，什么类型异常要外抛，什么异常不抛出只记录
new MyException(new Date(),ex.getMessage(),"RoleOperation.selectCount异常");
return 0;//注意null和new Course()并不同！
}finally{
hand.sayGoodbye();
}
}
@Override
public Object selectById(int id) {
MySQLHandler hand=new MySQLHandler();
ResultSet rs=null;
Role one=new Role();//如果查询内容为空，则通过one.getRoleId()==0来判断即可
try {
//此处不要写select *，因为数据库将*转换为该表所有列名肯定需要浪费时间
rs=hand.query("select role_id,role_name from system_role r where r.role_id='"+id+"'");
while(rs.next()){
one.setRoleId(rs.getInt("role_id"));
one.setRoleName(rs.getString("role_name"));
}
return one;
} catch (Exception ex) {
//对于数据库操作层面的异常，此时不予以向外抛出，记录在日志中分析即可
//在设计的时候就要明确，什么类型异常要外抛，什么异常不抛出只记录
new MyException(new Date(),ex.getMessage(),"RoleOperation.selectById异常");
return null;//注意null和new Role()并不同！
}finally{
hand.sayGoodbye();
}
}
@Override
public List selectAll() {//注意返回值null和list.size()==0的区别
MySQLHandler hand=new MySQLHandler();
ResultSet rs=null;
ArrayList<Role> list=new ArrayList<Role>();//返回值
try {
rs=hand.query("select role_id,role_name from system_role r");
while(rs.next()){
Role one=new Role();//返回值中的一个
one.setRoleId(rs.getInt("role_id"));
one.setRoleName(rs.getString("role_name"));
list.add(one);//添加到列表
}
return list;
} catch (Exception ex) {
new MyException(new Date(),ex.getMessage(),"RoleOperation.selectAll异常");
return null;
}finally{
hand.sayGoodbye();
}
}
@Override
public List selectPage(int offset,int size) {//注意返回值null和list.size()==0的区别
MySQLHandler hand=new MySQLHandler();
ResultSet rs=null;
ArrayList<Role> list=new ArrayList<Role>();//返回值
try {
rs=hand.query("select role_id,role_name from system_role r "
+" order by r.role_id limit "+offset+","+size);
while(rs.next()){
Role one=new Role();//返回值中的一个
one.setRoleId(rs.getInt("role_id"));
one.setRoleName(rs.getString("role_name"));
list.add(one);//添加到列表
}
return list;
} catch (Exception ex) {
new MyException(new Date(),ex.getMessage(),"RoleOperation.selectPage异常");
return null;
}finally{
hand.sayGoodbye();
}
}
@Override
public int add(Object obj) {
Role one=(Role)obj;
MySQLHandler hand=new MySQLHandler();
try {
int re=hand.execute("insert into system_role(role_name) values('"+one.getRoleName()+"')");
return re;
} catch (Exception ex) {
new MyException(new Date(),ex.getMessage(),"RoleOperation.add异常");
return 0;
}finally{
hand.sayGoodbye();
}
}
@Override
public int deleteById(int id) {
MySQLHandler hand=new MySQLHandler();
try {
int re=hand.execute("delete from system_role where role_id='"+id+"'");
return re;
} catch (Exception ex) {
new MyException(new Date(),ex.getMessage(),"RoleOperation.deleteById异常");
return 0;
}finally{
hand.sayGoodbye();
}
}
@Override
public int update(Object obj) {
Role one=(Role)obj;
MySQLHandler hand=new MySQLHandler();
try {
int re=hand.execute("update system_role set role_name='"+one.getRoleName()
+"' where role_id='"+one.getRoleId()+"'");
return re;
} catch (Exception ex) {
new MyException(new Date(),ex.getMessage(),"RoleOperation.update异常");
return 0;
}finally{
hand.sayGoodbye();
}
}
}
package operation;
import inter.IOperation;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import database.MySQLHandler;
import entity.*;
import exception.MyException;
public class UserOperation implements IOperation{
@Override
public int selectCount() {
MySQLHandler hand=new MySQLHandler();
ResultSet rs=null;
int re=0;
try {
//此处不要写select *，因为数据库将*转换为该表所有列名肯定需要浪费时间
rs=hand.query("select count(user_id) as count  from system_user");
while(rs.next()){
re=rs.getInt("count");
}
return re;
} catch (Exception ex) {
//对于数据库操作层面的异常，此时不予以向外抛出，记录在日志中分析即可
//在设计的时候就要明确，什么类型异常要外抛，什么异常不抛出只记录
new MyException(new Date(),ex.getMessage(),"UserOperation.selectCount异常");
return 0;//注意null和new Course()并不同！
}finally{
hand.sayGoodbye();
}
}
@Override
public Object selectById(int i) {
MySQLHandler hand=new MySQLHandler();
ResultSet rs=null;
User one=new User();//如果查询内容为空，则通过one.getUserId()==0来判断即可
try {
//此处不要写select *，因为数据库将*转换为该表所有列名肯定需要浪费时间
rs=hand.query("select user_id,user_name,user_password,role_id,role_name from "
+"system_user u,system_role r where u.user_id='"+i+"' and u.user_role=r.role_id");
while(rs.next()){
one.setUserId(rs.getInt("User_id"));
one.setUserName(rs.getString("User_name"));
one.setUserPassword(rs.getString("user_password"));
Role role=new Role();
role.setRoleId(rs.getInt("role_id"));
role.setRoleName(rs.getString("role_name"));
one.setUserRole(role);
}
return one;
} catch (Exception ex) {
//对于数据库操作层面的异常，此时不予以向外抛出，记录在日志中分析即可
//在设计的时候就要明确，什么类型异常要外抛，什么异常不抛出只记录
new MyException(new Date(),ex.getMessage(),"UserOperation.selectById异常");
return null;//注意null和new User()并不同！
}finally{
hand.sayGoodbye();
}
}
@Override
public List selectAll() {//注意返回值null和list.size()==0的区别
MySQLHandler hand=new MySQLHandler();
ResultSet rs=null;
ArrayList<User> list=new ArrayList<User>();//返回值
try {
rs=hand.query("select user_id,user_name,user_password,role_id,role_name from "
+"system_user u,system_role r where u.user_role=r.role_id");
while(rs.next()){
User one=new User();//返回值中的一个
one.setUserId(rs.getInt("User_id"));
one.setUserName(rs.getString("User_name"));
one.setUserPassword(rs.getString("user_password"));
Role role=new Role();
role.setRoleId(rs.getInt("role_id"));
role.setRoleName(rs.getString("role_name"));
one.setUserRole(role);
list.add(one);//添加到列表
}
return list;
} catch (Exception ex) {
new MyException(new Date(),ex.getMessage(),"UserOperation.selectAll异常");
return null;
}finally{
hand.sayGoodbye();
}
}
@Override
public List selectPage(int offset,int size) {//注意返回值null和list.size()==0的区别
MySQLHandler hand=new MySQLHandler();
ResultSet rs=null;
ArrayList<User> list=new ArrayList<User>();//返回值
try {
rs=hand.query("select user_id,user_name,user_password,role_id,role_name from "
+"system_user u,system_role r where u.user_role=r.role_id "
+" order by u.user_id limit "+offset+","+size);
while(rs.next()){
User one=new User();//返回值中的一个
one.setUserId(rs.getInt("User_id"));
one.setUserName(rs.getString("User_name"));
one.setUserPassword(rs.getString("user_password"));
Role role=new Role();
role.setRoleId(rs.getInt("role_id"));
role.setRoleName(rs.getString("role_name"));
one.setUserRole(role);
list.add(one);//添加到列表
}
return list;
} catch (Exception ex) {
new MyException(new Date(),ex.getMessage(),"UserOperation.selectPage异常");
return null;
}finally{
hand.sayGoodbye();
}
}
/*需要注意添加用户时，我们只用到了关联表的id*/
@Override
public int add(Object obj) {
User one=(User)obj;
MySQLHandler hand=new MySQLHandler();
try {
int re=hand.execute("insert into system_User(User_name,user_password,user_role)"
+" values('"+one.getUserName()+"','"+one.getUserPassword()+"','"+one.getUserRole().getRoleId()+"')");
return re;
} catch (Exception ex) {
new MyException(new Date(),ex.getMessage(),"UserOperation.add异常");
return 0;
}finally{
hand.sayGoodbye();
}
}
/*这个方法我是从RoleOperation中拷贝过来的，然后使用User替换了Role，此时定睛一看，竟无需改变*/
@Override
public int deleteById(int id) {
MySQLHandler hand=new MySQLHandler();
try {
int re=hand.execute("delete from system_User where User_id='"+id+"'");
return re;
} catch (Exception ex) {
new MyException(new Date(),ex.getMessage(),"UserOperation.deleteById异常");
return 0;
}finally{
hand.sayGoodbye();
}
}
/*此处需要注意修改user_role的逻辑，如果设计的是修改用户信息时同步修改角色，可以就如下写代码
而如果修改用户信息不修改角色，修改角色的功能是单独的菜单，那么可单独增加updateUserRole方法
猫哥建议直接在update里都写好，如果有区分的功能菜单，直接在在command命令层写不同的代码即可*/
@Override
public int update(Object obj) {
User one=(User)obj;
MySQLHandler hand=new MySQLHandler();
try {
int re=hand.execute("update system_User set User_name='"+one.getUserName()
+"',user_password='"+one.getUserPassword()+"',user_role='"+one.getUserRole().getRoleId()
+"' where User_id='"+one.getUserId()+"'");
return re;
} catch (Exception ex) {
new MyException(new Date(),ex.getMessage(),"UserOperation.update异常");
return 0;
}finally{
hand.sayGoodbye();
}
}

}
package operation;
import inter.IOperation;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import database.MySQLHandler;
import entity.*;
import exception.MyException;
public class WorkOperation implements IOperation{
public int selectMaxId() {
MySQLHandler hand=new MySQLHandler();
ResultSet rs=null;
int re=0;
try {
//此处不要写select *，因为数据库将*转换为该表所有列名肯定需要浪费时间
rs=hand.query("select max(work_id) as maxId  from system_work");
while(rs.next()){
re=rs.getInt("maxId");
}
hand.sayGoodbye();
return re;
} catch (Exception ex) {
//对于数据库操作层面的异常，此时不予以向外抛出，记录在日志中分析即可
//在设计的时候就要明确，什么类型异常要外抛，什么异常不抛出只记录
new MyException(new Date(),ex.getMessage(),"WorkOperation.selectMaxId异常");
return 0;//注意null和new Course()并不同！
}
}
@Override
public int selectCount() {
MySQLHandler hand=new MySQLHandler();
ResultSet rs=null;
int re=0;
try {
//此处不要写select *，因为数据库将*转换为该表所有列名肯定需要浪费时间
rs=hand.query("select count(work_id) as count  from system_work");
while(rs.next()){
re=rs.getInt("count");
}
hand.sayGoodbye();
return re;
} catch (Exception ex) {
//对于数据库操作层面的异常，此时不予以向外抛出，记录在日志中分析即可
//在设计的时候就要明确，什么类型异常要外抛，什么异常不抛出只记录
new MyException(new Date(),ex.getMessage(),"WorkOperation.selectCount异常");
return 0;//注意null和new Course()并不同！
}
}
public int selectCountByCourseId(int courseId) {
MySQLHandler hand=new MySQLHandler();
ResultSet rs=null;
int re=0;
try {
//此处不要写select *，因为数据库将*转换为该表所有列名肯定需要浪费时间
rs=hand.query("select count(work_id) as count from system_work where work_course='"+courseId+"'");
while(rs.next()){
re=rs.getInt("count");
}
hand.sayGoodbye();
return re;
} catch (Exception ex) {
//对于数据库操作层面的异常，此时不予以向外抛出，记录在日志中分析即可
//在设计的时候就要明确，什么类型异常要外抛，什么异常不抛出只记录
new MyException(new Date(),ex.getMessage(),"WorkOperation.selectCount异常");
return 0;//注意null和new Course()并不同！
}
}
@Override
public Object selectById(int id) {
MySQLHandler hand=new MySQLHandler();
ResultSet rs=null;
Work one=new Work();//如果查询内容为空，则通过one.getWorkId()==0来判断即可
try {
//此处不要写select *，因为数据库将*转换为该表所有列名肯定需要浪费时间
rs=hand.query("select Work_id,Work_title,work_time,course_id,course_name from "
+"system_Work w,system_course c where w.Work_id='"+id+"' and w.Work_course=c.course_id");
while(rs.next()){
one.setWorkId(rs.getInt("Work_id"));
one.setWorkTitle(rs.getString("Work_title"));
one.setWorkTime(rs.getString("Work_time"));
Course course=new Course();
course.setCourseId(rs.getInt("course_id"));
course.setCourseName(rs.getString("course_name"));
one.setWorkCourse(course);
}
hand.sayGoodbye();
return one;
} catch (Exception ex) {
//对于数据库操作层面的异常，此时不予以向外抛出，记录在日志中分析即可
//在设计的时候就要明确，什么类型异常要外抛，什么异常不抛出只记录
new MyException(new Date(),ex.getMessage(),"WorkOperation.selectById异常");
return null;//注意null和new Work()并不同！
}
}
@Override
public List selectAll() {//注意返回值null和list.size()==0的区别
MySQLHandler hand=new MySQLHandler();
ResultSet rs=null;
ArrayList<Work> list=new ArrayList<Work>();//返回值
try {
rs=hand.query("select Work_id,Work_title,work_time,course_id,course_name from "
+"system_Work w,system_course c where w.Work_course=c.course_id");
while(rs.next()){
Work one=new Work();//返回值中的一个
one.setWorkId(rs.getInt("Work_id"));
one.setWorkTitle(rs.getString("Work_title"));
one.setWorkTime(rs.getString("Work_time"));
Course course=new Course();
course.setCourseId(rs.getInt("course_id"));
course.setCourseName(rs.getString("course_name"));
one.setWorkCourse(course);
list.add(one);//添加到列表
}
hand.sayGoodbye();//释放资源
return list;
} catch (Exception ex) {
new MyException(new Date(),ex.getMessage(),"WorkOperation.selectAll异常");
return null;
}
}
@Override
public List selectPage(int offset,int size) {//注意返回值null和list.size()==0的区别
MySQLHandler hand=new MySQLHandler();
ResultSet rs=null;
ArrayList<Work> list=new ArrayList<Work>();//返回值
try {
rs=hand.query("select Work_id,Work_title,work_time,course_id,course_name from "
+"system_Work w,system_course c where w.Work_course=c.course_id "
+" order by w.work_id limit "+offset+","+size);
while(rs.next()){
Work one=new Work();//返回值中的一个
one.setWorkId(rs.getInt("Work_id"));
one.setWorkTitle(rs.getString("Work_title"));
one.setWorkTime(rs.getString("Work_time"));
Course course=new Course();
course.setCourseId(rs.getInt("course_id"));
course.setCourseName(rs.getString("course_name"));
one.setWorkCourse(course);
list.add(one);//添加到列表
}
hand.sayGoodbye();//释放资源
return list;
} catch (Exception ex) {
new MyException(new Date(),ex.getMessage(),"WorkOperation.selectPage异常");
return null;
}
}
public List selectPageByCourseId(int offset,int size,int courseId) {//注意返回值null和list.size()==0的区别
MySQLHandler hand=new MySQLHandler();
ResultSet rs=null;
ArrayList<Work> list=new ArrayList<Work>();//返回值
try {
rs=hand.query("select Work_id,Work_title,work_time,course_id,course_name from "
+"system_Work w,system_course c where w.Work_course=c.course_id and c.course_id='"+courseId+"'"
+" order by w.work_id limit "+offset+","+size);
while(rs.next()){
Work one=new Work();//返回值中的一个
one.setWorkId(rs.getInt("Work_id"));
one.setWorkTitle(rs.getString("Work_title"));
one.setWorkTime(rs.getString("Work_time"));
Course course=new Course();
course.setCourseId(rs.getInt("course_id"));
course.setCourseName(rs.getString("course_name"));
one.setWorkCourse(course);
list.add(one);//添加到列表
}
return list;
} catch (Exception ex) {
new MyException(new Date(),ex.getMessage(),"WorkOperation.selectPage异常");
return null;
}finally{
hand.sayGoodbye();
}
}
@Override
public int add(Object obj) {
Work one=(Work)obj;
MySQLHandler hand=new MySQLHandler();
try {
int re=hand.execute("insert into system_Work(Work_title,work_time,work_course)"
+" values('"+one.getWorkTitle()+"','"+one.getWorkTime()+"','"+one.getWorkCourse().getCourseId()+"')");
return re;
} catch (Exception ex) {
new MyException(new Date(),ex.getMessage(),"WorkOperation.add异常");
return 0;
}finally{
hand.sayGoodbye();
}
}
@Override
public int deleteById(int id) {
MySQLHandler hand=new MySQLHandler();
try {
int re=hand.execute("delete from system_Work where Work_id='"+id+"'");
return re;
} catch (Exception ex) {
new MyException(new Date(),ex.getMessage(),"WorkOperation.deleteById异常");
return 0;
}finally{
hand.sayGoodbye();
}
}
@Override
public int update(Object obj) {
Work one=(Work)obj;
MySQLHandler hand=new MySQLHandler();
try {
int re=hand.execute("update system_Work set Work_title='"+one.getWorkTitle()
+"',Work_time='"+one.getWorkTime()
+"',Work_course='"+one.getWorkCourse().getCourseId()
+"' where Work_id='"+one.getWorkId()+"'");
return re;
} catch (Exception ex) {
new MyException(new Date(),ex.getMessage(),"WorkOperation.update异常");
return 0;
}finally{
hand.sayGoodbye();
}
}
}

package servlet;
import javax.servlet.http.HttpServletRequest;
import entity.User;
import factory.EntityFactory;
import action.*;
/**
* 实质的控制器
* @author 猫哥
* @date 2017.2.11
* @modify 2017.2.19 去除context改由Action自行决定需要参数列表
* ActionController此时只需负责根据Action需求提供参数即可
*/
public class ActionController {
//直接装配出Action
public static Action assemblyAction(HttpServletRequest request){
//两个必备参数
String operationType=request.getParameter("method");
String entityType=request.getParameter("entityType");
//根据Action需要装配
if(operationType.equals("delete")){
String entityId=request.getParameter("entityId");
//第三个参数null表示交给Action去设置
return new DeleteAction(entityType,operationType,Integer.parseInt(entityId));
}
else if(operationType.equals("view")){
//所有view都分页
String inputPage=request.getParameter("page");
int page=-1;
if(inputPage==null||"".equals(inputPage)){
page=1;
}else{
page=Integer.parseInt(inputPage);
}
//特殊查看逻辑
if(entityType.equals("Work")){//查看作业，需要课程编号
return new ViewWorkAction(entityType,operationType,page,Integer.parseInt(request.getParameter("byCourseId")));
}else if(entityType.equals("Course")){//查看课程，需要登录人员信息
return new ViewCourseAction(entityType,operationType,page,(User)request.getSession().getAttribute("sessionUser"));
}else if(entityType.equals("Job")){//查看作业，学生查看未做的，教师查看已做了未批阅的
return new ViewJobAction(entityType,operationType,page,(User)request.getSession().getAttribute("sessionUser"));
}
//正常查看
return new ViewAction(entityType,operationType,page);
}
else if(operationType.equals("add")){
if(entityType.equals("Work")){//添加作业时，需要携带教师创建的课程列表，此处只是需要登录用户身份即可
User user=(User)request.getSession().getAttribute("sessionUser");
return new AddWorkAction(entityType,operationType,user.getUserId());
}
return new AddAction(entityType,operationType);
}
else if(operationType.equals("edit")){
//点击编辑后，需要显示被编辑人的信息，所以edit要携带id
String entityId=request.getParameter("entityId");
return new EditAction(entityType,operationType,Integer.parseInt(entityId));
}
else if(operationType.equals("editJobContent")){//做作业
String entityId=request.getParameter("entityId");
return new EditJobContentAction(entityType,operationType,Integer.parseInt(entityId));
}
else if(operationType.equals("editJobScore")){//批阅作业
String entityId=request.getParameter("entityId");
return new EditJobScoreAction(entityType,operationType,Integer.parseInt(entityId));
}
else if(operationType.equals("save")){
//注意，点击保存后，不同的实体需要携带不同的参数列表，所以采用createEntityFromRequest来创建实体
Object saveEntity=EntityFactory.createEntityFromRequest(entityType, request);
Boolean isAddOrEdit=null;
//需要根据entityId判断是新增还是修改
String id=request.getParameter("entityId");
if(id==null||"".equals(id)){
isAddOrEdit=true;
}else{
isAddOrEdit=false;
}
//因为Save之后要跳到列表，有些列表需要根据登录用户身份显示，所以
User sessionUser=(User)request.getSession().getAttribute("sessionUser");
//注意因为work是跟课程相关的，修改work后要跳转到当前课程所有作业列表，所以添加该输入项
if(entityType.equals("Work")){
return new SaveWorkAction(entityType,operationType,isAddOrEdit,saveEntity,sessionUser);
}else if (entityType.equals("Job")){
return new SaveJobAction(entityType,operationType,isAddOrEdit,saveEntity,sessionUser);
}else if (entityType.equals("Lesson")){
return new SaveLessonAction(entityType,operationType,isAddOrEdit,saveEntity,sessionUser);
}
return new SaveAction(entityType,operationType,isAddOrEdit,saveEntity,sessionUser);
}
else if(operationType.equals("login")){
return new LoginAction(entityType,operationType,request.getParameter("userId"),request.getParameter("userPassword"));
}
return null;
}
}
/**
* servlet包包含ActionServlet：项目唯一控制器
* ActionController:控制逻辑类
*/
package servlet;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import action.Action;
import exception.MyException;
import java.util.Iterator;
import java.util.Map;
//ActionServlet作为整个项目唯一的Servlet
public class ActionServlet extends HttpServlet {

public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
this.doPost(request, response);//doGet与doPost一样处理
}
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
//输入输出格式设置

response.setContentType("text/html");
request.setCharacterEncoding("utf-8");
response.setCharacterEncoding("utf-8");
//根据不同的ActionContext创建不懂的action动作
Action action=ActionController.assemblyAction(request);
Map<String,Object> map=null;
try {
map=action.execute();//执行动作并返回结果
} catch (MyException ex) {//如果有异常，跳转异常提示页面
request.setAttribute("tipInfo", ex.getInfo());
request.getRequestDispatcher("/tip.jsp").forward(request,response);
return;
}
//设置返回页面
request.setAttribute("actionUrl",action.getActionUrl());
//取上下文中的返回值
if(map!=null){
Iterator iter = map.entrySet().iterator();
while (iter.hasNext()) {
Map.Entry entry = (Map.Entry) iter.next();
Object key = entry.getKey();
Object val = entry.getValue();
if(key.toString().startsWith("session")){
request.getSession().setAttribute(key.toString(), val);
}else{
request.setAttribute(key.toString(), val);
}
}
}
//跳转到index.jsp主页面，注意 actionUrl指向页面显示在index.jsp右边内容区域
request.getRequestDispatcher("/index.jsp").forward(request,response);
}
}
package servlet;
import java.io.IOException;

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
public class SessionFilter implements Filter{
@Override
public void destroy() {
}
/**
* 核心过滤方法
*/
@Override
public void doFilter(ServletRequest request, ServletResponse response,
FilterChain chain) throws IOException, ServletException {
//获取代表用户请求、响应、会话的对象
HttpServletRequest servletRequest = (HttpServletRequest) request;
HttpServletResponse servletResponse = (HttpServletResponse) response;
HttpSession servletSession = servletRequest.getSession();
// 获得用户请求的URI
String path = servletRequest.getRequestURI();
//允许访问login.jsp和tip.jsp以及ActionServlet
if((path.indexOf("/login.jsp")>-1)||(path.indexOf("/tip.jsp")>-1)||(path.indexOf("/ActionServlet")>-1)){
chain.doFilter(request, response);
return;
//允许访问css文件和图片文件(如果不允许，那就看不到样式和图片了)
}else if(path.contains(".css") || path.contains(".jpg")|| path.contains(".gif")|| path.contains(".png")){
chain.doFilter(request, response);
return;
//允许访问js文件，注意不允许访问jsp文件！
}else if(path.contains(".js")&&(!path.contains("jsp"))){
chain.doFilter(request, response);
return;
}
//除上述允许访问的之外，如果未登录报无权限错误
if(((HttpServletRequest) request).getSession().getAttribute("session_user")==null){
servletRequest.setAttribute("tipInfo", "无权限！");
request.getRequestDispatcher("/tip.jsp").forward(request,response);
return;
}else{//如果已登录，则允许访问
chain.doFilter(request, response);
return;
}

}
@Override
public void init(FilterConfig filterConfig) throws ServletException {
}
}

/**
* util包：工具包
* Constant类：保存常量信息的类
*/
package util;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
public class Constant {
//roleMenu用于保存角色及对应的菜单信息
public static HashMap<String,String[][]> RoleMenu=new HashMap<String,String[][]>();
//pageSize用于保存不同实体列表页面显示实体个数信息（每页多少个）
public static HashMap<String,Integer> PageSize=new HashMap<String,Integer>();
//JobScore用于保存不同的job_score状态
public static HashMap<String,String> JobScore=new HashMap<String,String>();
//使用static代码块对roleMenu进行初始化
static{
//注意，二位数组中的每一组表示一个菜单的信息，又通过map建立了角色名和菜单直接的对应关系
RoleMenu.put("校长", new String[][]{
{"人员管理","view","User"},//由具体的地址，变为抽象的参数
{"课程查看","view","Course"}
});
RoleMenu.put("教师", new String[][]{
{"课程管理","view","Course"},
{"批阅作业","view","Job"}
});
RoleMenu.put("学生", new String[][]{
{"做作业","view","Job"},
{"选课","view","Course"}
});
//初始化页面列表个数
PageSize.put("Course", 5);
PageSize.put("Job", 5);
PageSize.put("Lesson", 5);
PageSize.put("Role", 5);
PageSize.put("User", 5);
PageSize.put("Work", 5);
//-2作业未提交 -1已提交未阅 0优秀 1良好 2合格 3不合格
JobScore.put("-2", "作业未提交");
JobScore.put("-1", "已提交未阅");
JobScore.put("0", "优秀");
JobScore.put("1", "良好");
JobScore.put("2", "合格");
JobScore.put("3", "不合格");
}
public static String getDate(){
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date now = new Date();
String dateValue = sdf.format(now);
return dateValue;
}
}
package util;
import java.io.IOException;
import java.util.logging.FileHandler;
import java.util.logging.Level;
import java.util.logging.LogRecord;
import java.util.logging.Logger;
import java.util.logging.SimpleFormatter;
/**
* 异常日志类ExceptionLogger
* @author 猫哥
* @date 2017.2.24
*/
public class ExceptionLogger {
//日志记录器
public static Logger logger;
static{//初始化
try{
//给日志记录器起名
logger=Logger.getLogger("HomeworkSystem");
//日志相关的文件处理器
FileHandler fileHandler;
fileHandler = new FileHandler("d:\\log.txt");
//文件处理器相关的格式
SimpleFormatter formatter = new SimpleFormatter();
fileHandler.setFormatter(formatter);
//日志记录器使用fileHandler管理文件
logger.addHandler(fileHandler);
} catch (SecurityException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
//记录一条日志
public static void logInfo(String info){
//设置日志级别，内容
LogRecord logRecord = new LogRecord(Level.INFO, info);
//记录一条日志
logger.log(logRecord);
}
}