目录
1软件系统设计
1.1系统分析
对学校全体师生的需求进行分析，可以将系统分为四大模块：用户管理模块、课程管理模块、课程表管理模块、成绩管理模块。
（1）用户管理模块
本模块主要实现对用户信息的管理，包括：新增用户信息、删除用户信息、修改用户信息；按条件查询用户信息。
（2）课程管理模块
本模块主要实现对课程信息的管理，包括：创建课程信息、修改课程信息、删除课程信息；按条件查询课程信息。
（3）课程表模块
本模块主要实现对课程表信息的管理，包括：课程表的录入和修改。
（4）成绩管理模块
本模块主要实现对学生成绩信息的管理，包括：学生成绩的录入、修改以及学生成绩的统计。如下图3-1系统功能图所示
图3-1系统功能图
1.2 类设计
本人在次这个系统这个系统中主要是设计课程管理模块、教师课程管理模块和课程表管理模块的类，比如serlevt类里的控制层controller这一部分是涉及到前端接口方法还有用于实现业务逻辑的service服务层的impl类，用于修改数据库操作的Dao层。
1.2.1 课程管理模块的类设计
客户端向servlet类CourseController发出请求，调用Courseservice中的各个业务方法，将请求传到Dao层的CourseMapper，最后通过是实现对数据库的读写操作完成添加课程，删除课程，更新课程，获取课程列表，通过条件查询课程等功能。如下图3-2 课程管理模块功能图所示
图3-2 课程管理模块功能图
1.2.2 教师课程管理模块的类设计
客户端向servlet类TeacherCourseController发出请求，调用TeacherCourseservice中的各个业务方法，将请求传到Dao层的TeacherCourseMapper去执行相应的数据库操作，最后通过是实现对数据库的读写操作完成添加教师课程信息，删除教师课程，更新教师课程，根据教师ID获取课程、专业，通过条件查询课程等功能。如图3-3教师课程管理模块功能图所示
图3-3 教师课程管理模块功能图
1.2.3 课程表管理模块的类设计
客户端向servlet类TimetableController发出请求，调用Timetableservice中的各个业务方法，将请求传到Dao层的TimetableMapper与TimetableServiceImpl，最后通过是实现对数据库的读写操作完成添加更新课程表，获取学生的列表，根据条件获取学生的课程表，获得教师的课程表、更新课程等功能。用户端提出请求Controller向调用service中的业务逻辑，这是Dao层就执行数据库操作，并将结果返回service，service将业务逻辑的结果返回给客户端controller。如图3-4 课程表管理模块功能图所示
图3-4 课程表管理模块功能图
1.3课程管理模块的设计
1.3.1 CourseController类的设计
CourseController主要负责处理与课程相关的操作请求以下是再系统中的作用
（1）添加课程:通过 addCourse 方法，调用服务层中的courseservice来添加新的课程
（2）删除课程:delete 方法根据传入的课程ID数组删除对应的课程。
（3）更新课程:update方法负责处理HTTP PUT请求接收更新后的课程信息并保存。
（4）获取课程列表:getCourseList 方法支持分页获取课程列表。管理员或教师可以根据需要获取特定范围内的课程数据，方便查看和管理大量课程信息。
（5）通过条件查询课程:getCourseByMap 方法通过接收查询条件，从数据库中筛选并返回符合条件的课程列表。关键代码如下
controller类的代码设计
service层的代码设计
/**
* Description 课程信息业务层
* Author: rabbiter
* Date: 2020/3/11 14:49
**/
@Service
public class CourseServiceImpl implements CourseService {
@Resource
private CourseMapper courseMapper; // 注入CourseMapper，用于操作课程数据
@Resource
private CourseInfoMapper courseInfoMapper; // 注入CourseInfoMapper，用于操作课程信息数据
@Resource
private ProfessionMapper professionMapper; // 注入ProfessionMapper，用于操作专业数据
@Override
public void addCourse(Course course) {
Profession profession = professionMapper.getProfessionIdByName(course.getProfession()); // 通过专业名称获取专业ID
String id = ""; // 初始化课程ID
String str = course.getYear().toString() + "0" + profession.getId() + course.getTerm(); // 生成课程ID的前缀部分
Map<String, Object> condition = new HashMap<>(); // 创建条件Map
condition.put("profession", course.getProfession()); // 将专业名称放入条件Map
condition.put("year", course.getYear()); // 将年份放入条件Map
String value = courseMapper.checkCodeCount(condition); // 查询已有课程数量
String strValue = ""; // 初始化课程ID的后缀部分
if (value != null) { // 如果查询结果不为空
int num = Integer.parseInt(value.substring(value.length() - 3)) + 1; // 获取已有课程的数量并加1
if (num < 10) {
strValue = "00" + Integer.toString(num); // 格式化编号为三位数字
} else if (num < 100) {
strValue = "0" + Integer.toString(num); // 格式化编号为三位数字
} else {
strValue = Integer.toString(num); // 格式化编号为三位数字
}
} else {
strValue = "001"; // 如果查询结果为空，设置初始编号为001
}
id = str + strValue; // 组合前缀和后缀生成完整的课程ID
course.setId(id); // 设置课程的ID
courseMapper.addCourse(course); // 将课程信息添加到数据库中
courseInfoMapper.deleteInfo(id); // 删除已有的课程信息
CourseInfo courseInfo = new CourseInfo(); // 创建新的课程信息对象
courseInfo.setStart(1); // 设置课程开始周
courseInfo.setEnd(25); // 设置课程结束周
courseInfo.setCourseId(id); // 设置课程ID
courseInfo.setProfession(course.getProfession()); // 设置专业名称
courseInfoMapper.addCourseInfo(courseInfo); // 将课程信息添加到数据库中
}
@Override
public void delete(List<Long> ids) {
courseMapper.delete(ids); // 删除课程
for (Long id : ids) {
courseInfoMapper.deleteInfo(Long.toString(id)); // 删除对应的课程信息
}
}
@Override
public void update(Course course) {
courseMapper.update(course); // 更新课程信息
CourseInfo courseInfo = new CourseInfo(); // 创建新的课程信息对象
courseInfo.setProfession(course.getProfession()); // 设置专业名称
courseInfo.setCourseId(course.getId()); // 设置课程ID
courseInfoMapper.updateCourseInfo(courseInfo); // 更新课程信息
}
@Override
public PagingResult<Course> getCourseList(RowBounds rowBounds, Map<String, Object> condition) {
PageRowBounds pageRowBounds = new PageRowBounds(rowBounds.getOffset(), rowBounds.getLimit()); // 创建分页对象
List<Course> CourseList = courseMapper.getCourseList(pageRowBounds, condition); // 获取课程列表
return new PagingResult<>(CourseList, pageRowBounds.getTotal()); // 返回分页结果
}
@Override
public List<Course> getCourseByMap(Map<String, Object> condition) {
return courseMapper.getCourseByMap(condition); // 根据条件获取课程列表
}
}
1.4教师课程管理模块
专门负责管理教师与课程的关系及信息。作用如下
(1)添加教师课程信息:add 方法接收教师课程信息并添加到系统中。
(2)删除教师课程信息:delete 方法根据传入的ID数组删除对应教师课程信息。
（3）更新教师课程信息:update 接收更新后的 TeacherCourse 对象并保存。通过该功能，教师或管理员可以及时更新课程信息，例如课程调整或教师更换等
（4）获取教师课程列表:getCourseListById 根据教师ID获取其课程列表。此功能允许教师查看自己所授课程的详细信息，便于课程管理和教学安排。
（5）获取教师专业信息:getProfessionInfo 方法和 getProfessionInfoByAdmin 方法分别处理根据教师ID获取专业信息和获取所有教师的专业信息。
（6）获取课程信息:getCourseInfo 根据条件查询并返回课程信息。管理员或教师可以通过该功能获取特定课程的详细信息，支持多样化的查询需求。
service层的代码设计
/**
* Description 课程控制层
* Author: rabbiter
* Date: 2020/3/11 14:40
**/
@RestController // 标注这是一个RESTful的控制器
@RequestMapping("/api/sms/course") // 定义控制器的根URL
public class CourseController {
@Autowired // 自动注入CourseService服务
private CourseService courseService;
@PostMapping // 处理HTTP POST请求
public void addCourse(@RequestBody Course course) { // 从请求体中获取Course对象
courseService.addCourse(course); // 调用服务层添加课程
}
@DeleteMapping("/{ids}") // 处理HTTP DELETE请求
public void delete(@PathVariable("ids") String[] ids) { // 从URL路径中获取ID参数
List<Long> idsList = Stream.of(ids).map(Long::parseLong).collect(Collectors.toList()); // 将字符串数组转换为Long列表
courseService.delete(idsList); // 调用服务层删除课程
}
@PutMapping // 处理HTTP PUT请求
public void update(@RequestBody Course course) { // 从请求体中获取Course对象
courseService.update(course); // 调用服务层更新课程
}
@GetMapping("/getCourseList") // 处理HTTP GET请求
private PagingResult<Course> getCourseList(@RequestParam Map<String, Object> condition, // 获取所有请求参数作为Map
@RequestParam(required = false, name = "$limit", defaultValue = "10") Integer limit, // 获取分页大小，默认为10
@RequestParam(required = false, name = "$offset", defaultValue = "0") Integer offset) { // 获取分页偏移量，默认为0
RowBounds rowBounds = new RowBounds(offset, limit); // 创建分页对象
return courseService.getCourseList(rowBounds, condition); // 调用服务层获取分页课程列表，并返回结果
}
@GetMapping("/getCourseByMap") // 处理HTTP GET请求
private List<Course> getCourseByMap(@RequestParam Map<String, Object> condition) { // 获取所有请求参数作为Map
return courseService.getCourseByMap(condition); // 调用服务层根据条件获取课程列表，并返回结果
}
}
package com.rabbiter.sms.service.TeacherCourse.impl;
import com.rabbiter.sms.dao.Course.CourseMapper;
import com.rabbiter.sms.dao.Profession.ProfessionMapper;
import com.rabbiter.sms.dao.TeacherCourse.TeacherCourseMapper;
import com.rabbiter.sms.dao.User.StudentMapper;
import com.rabbiter.sms.domain.Profession;
import com.rabbiter.sms.domain.TeacherCourse;
import com.rabbiter.sms.dto.Course;
import com.rabbiter.sms.service.TeacherCourse.TeacherCourseService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.*;
/**
* Description
* Author: rabbiter
* Date: 2020/3/29 15:09
**/
@Service // 标注这是一个服务类
public class TeacherCourseServiceImpl implements TeacherCourseService {
@Autowired
private TeacherCourseMapper teacherCourseMapper; // 自动注入教师课程Mapper
@Autowired
private ProfessionMapper professionMapper; // 自动注入专业Mapper
@Autowired
private StudentMapper studentMapper; // 自动注入学生Mapper
@Autowired
private CourseMapper courseMapper; // 自动注入课程Mapper
@Override
public void add(List<TeacherCourse> list) {
List<Integer> ids = new ArrayList<>();
for (TeacherCourse teacherCourse : list) {
if (teacherCourse.getId() != -1) {
ids.add(teacherCourse.getId());
}
}
if (ids.size() > 0) {
teacherCourseMapper.delete(ids); // 删除已有的教师课程记录
}
for (TeacherCourse teacherCourse : list) {
Course course = courseMapper.getCourseById(teacherCourse.getCourseId());
teacherCourse.setName(course.getName()); // 设置课程名称
teacherCourseMapper.add(teacherCourse); // 新增教师课程记录
}
}
@Override
public void delete(List<Integer> ids) {
teacherCourseMapper.delete(ids); // 根据ID列表删除教师课程记录
}
@Override
public void update(TeacherCourse teacherCourse) {
teacherCourseMapper.update(teacherCourse); // 更新教师课程记录
}
@Override
public List<TeacherCourse> getCourseListById(String id) {
List<TeacherCourse> teacherCourseList = teacherCourseMapper.getCourseListById(id); // 根据教师ID获取课程列表
return teacherCourseList;
}
@Override
public List<Map<String, Object>> getProfessionInfo(String teacherId) {
List<TeacherCourse> list = teacherCourseMapper.getCourseListById(teacherId); // 根据教师ID获取课程列表
List<Map<String, Object>> arr = new ArrayList<>();
Set<String> professionSet = new HashSet<>();
for (TeacherCourse teacherCourse : list) {
professionSet.add(teacherCourse.getProfession()); // 获取教师教授的所有专业
}
for (String s : professionSet) {
Map<String, Object> condition = new HashMap<>();
condition.put("teacherId", teacherId);
condition.put("profession", s);
List<TeacherCourse> listObj = teacherCourseMapper.getGradeInfoByMap(condition); // 根据教师ID和专业获取班级和课程信息
Set<String> gradeSet = new HashSet<>();
Set<String> courseSet = new HashSet<>();
for (TeacherCourse teacherCourse : listObj) {
gradeSet.add(teacherCourse.getGrade()); // 获取班级信息
courseSet.add(teacherCourse.getName()); // 获取课程信息
}
condition.put("grade", gradeSet);
condition.put("course", courseSet);
arr.add(condition); // 将信息添加到结果列表中
}
return arr;
}
@Override
public List<Map<String, Object>> getProfessionInfoByAdmin() {
List<Map<String, Object>> arr = new ArrayList<>();
List<Profession> professionList = professionMapper.getProfessionList(); // 获取所有专业列表
for (Profession profession : professionList) {
Map<String, Object> condition = new HashMap<>();
condition.put("profession", profession.getName());
List<String> gradeList = studentMapper.getGradeByProfession(profession.getName()); // 根据专业获取班级列表
List<Course> courseList = courseMapper.getCourseByMap(condition); // 根据条件获取课程列表
List<String> courseNameList = new ArrayList<>();
for (Course course : courseList) {
courseNameList.add(course.getName()); // 获取课程名称列表
}
// 转成int，然后再排序
List<Integer> list = new ArrayList<>();
for (String str : new HashSet<>(gradeList)) {
int number = Integer.parseInt(str);
list.add(number);
}
Collections.sort(list); // 对班级进行排序
condition.put("grade", list);
condition.put("course", new HashSet<>(courseNameList));
arr.add(condition); // 将信息添加到结果列表中
}
return arr;
}
@Override
public Course getCourseInfo(Map<String, Object> condition) {
return teacherCourseMapper.getCourseInfo(condition); // 根据条件获取课程详细信息
}
}
1.5 课程表管理模块的详细设计
1.5.1 TimetableController类的设计
TimetableController 专门负责管理课程表的相关信息。作用如下
（1）新增和更新课程表:add 方法接收课程表信息并将其新增或更新到系统中。该功能允许管理员批量处理课程表信息
（2）获取课程表:getStudentList 此功能提供了灵活的课程表查询机制，满足不同用户的需求，例如根据日期、课程名称等条件查询课程表信息。
（3）根据学生条件获取课程表:getTimetableByStudent 方法接收学生相关的查询条件并返回相应的课程表。
（4）根据教师条件获取课程表:getTimetableByTeacher根据查询条件获取课程表。
（5）更新课程信息:updateCourseInfo 方法接收并更新课程信息。通过该功能，管理员或教师可以修改课程的详细信息。
1.5.2 TimetableService的设计
TimetableServiceImpl实现了对TimetableService里声明的方法。
- 在实现添加课程表方法add：先用getTimetable方法去获取原先的课程表信息，在对其修改并排序，删除旧的课程表之后再新增新的课程表。
- 处理每周的课程，如果某天没有课程那么将其设置为一。
- 处理课程信息：根据课程信息表来判断某课程是否在当前周，如果不在则返回"一"，否则返回课程名称。
- 通过学生ID获取学生信息，并根据学生的专业和年级获取对应的课程表。
@Service // 声明该类为Spring的服务组件
public class TimetableServiceImpl implements TimetableService {
@Resource // 注入Mapper依赖
private TimetableMapper timetableMapper;
@Resource
private StudentMapper studentMapper;
@Resource
private WeekCourseMapper weekCourseMapper;
@Resource
private TeacherCourseMapper teacherCourseMapper;
@Resource
private CourseInfoMapper courseInfoMapper;
@Override
@Transactional // 将此方法标记为事务性操作
public void add(List<WeekCourse> list) {
Map<String, Object> condition = new HashMap<>(); // 创建一个条件Map用于查询
condition.put("profession", list.get(0).getProfession());
condition.put("grade", list.get(0).getGrade());
condition.put("year", list.get(0).getYear());
condition.put("term", list.get(0).getTerm());
condition.put("week", list.get(0).getWeek());
// 获取原本课程表信息
List<Timetable> timeTableList = timetableMapper.getTimetable(condition);
Set<Integer> ids = new HashSet<>();
Set<Integer> weekIds = new HashSet<>();
for (Timetable timetable : timeTableList) { // 从现有课程表中收集ids和weekIds
ids.add(timetable.getId());
weekIds.add(timetable.getWeekId());
}
if (ids.size() > 0) { // 如果存在id，更新课程表
for (int i = 0; i < list.size(); i++) {
List<Integer> weekList = new ArrayList<>(weekIds);
// 排序weekList
Collections.sort(weekList);
WeekCourse weekCourse = list.get(i);
weekCourse.setId(weekList.get(i)); // 设置每个周课程的id
dealWeek(list.get(i)); // 处理周课程的详细信息
weekCourseMapper.update(list.get(i)); // 更新数据库中的周课程
}
} else { // 如果不存在id，创建新的课程表
timetableMapper.deleteTimeTable(condition); // 删除旧的课程表
for (WeekCourse weekCourse : list) {
dealWeek(weekCourse); // 处理周课程的详细信息
weekCourseMapper.add(weekCourse); // 添加周课程到数据库
Timetable timetable = new Timetable(); // 创建一个新的课程表条目
timetable.setWeekId(weekCourse.getId());
timetable.setProfession(weekCourse.getProfession());
timetable.setGrade(weekCourse.getGrade());
timetable.setYear(weekCourse.getYear());
timetable.setTerm(weekCourse.getTerm());
timetable.setWeekNum(weekCourse.getWeek());
timetableMapper.add(timetable); // 添加课程表条目到数据库
}
}
}
private void dealWeek(WeekCourse weekCourse) { // 处理周课程天的默认值
if (weekCourse.getMonday() == null || weekCourse.getMonday().equals("")) {
weekCourse.setMonday("一");
}
if (weekCourse.getTuesday() == null || weekCourse.getTuesday().equals("")) {
weekCourse.setTuesday("一");
}
if (weekCourse.getWednesday() == null || weekCourse.getWednesday().equals("")) {
weekCourse.setWednesday("一");
}
if (weekCourse.getThursday() == null || weekCourse.getThursday().equals("")) {
weekCourse.setThursday("一");
}
if (weekCourse.getFriday() == null || weekCourse.getFriday().equals("")) {
weekCourse.setFriday("一");
}
if (weekCourse.getSaturday() == null || weekCourse.getSaturday().equals("")) {
weekCourse.setSaturday("一");
}
if (weekCourse.getSunday() == null || weekCourse.getSunday().equals("")) {
weekCourse.setSunday("一");
}
}
@Override
public List<WeekCourse> getTimetable(Map<String, Object> condition) {
int num = timetableMapper.checkCount(condition); // 检查课程表条目的数量
List<WeekCourse> list = new ArrayList<>();
if (num == 0) { // 如果没有条目，创建一个空的课程表
for (int i = 1; i < 11; i++) {
WeekCourse week = new WeekCourse();
list.add(week);
}
} else {
list = weekCourseMapper.getWeekCourse(condition); // 获取给定条件的周课程
dealMethod(list, condition); // 处理周课程
}
return list;
}
// 根据当前周过滤课程表中不属于当前周的课程
private void dealMethod (List<WeekCourse> list, Map<String, Object> condition) {
for (WeekCourse weekCourse : list) {
Map<String, Object> map = new HashMap<>();
map.put("profession", condition.get("profession").toString());
map.put("week", condition.get("week").toString());
map.put("name", weekCourse.getMonday().toString());
weekCourse.setMonday(dealCourseInfo(map)); // 处理周一的课程信息
map.put("name", weekCourse.getTuesday().toString());
weekCourse.setTuesday(dealCourseInfo(map)); // 处理周二的课程信息
map.put("name", weekCourse.getWednesday().toString());
weekCourse.setWednesday(dealCourseInfo(map)); // 处理周三的课程信息
map.put("name", weekCourse.getThursday().toString());
weekCourse.setThursday(dealCourseInfo(map)); // 处理周四的课程信息
map.put("name", weekCourse.getFriday().toString());
weekCourse.setFriday(dealCourseInfo(map)); // 处理周五的课程信息
map.put("name", weekCourse.getSaturday().toString());
weekCourse.setSaturday(dealCourseInfo(map)); // 处理周六的课程信息
map.put("name", weekCourse.getSunday().toString());
weekCourse.setSunday(dealCourseInfo(map)); // 处理周日的课程信息
}
}
private String dealCourseInfo (Map<String, Object> map) {
CourseInfo courseInfo = courseInfoMapper.getInfo(map); // 根据map获取课程信息
if (courseInfo != null) {
int start = courseInfo.getStart();
int end = courseInfo.getEnd();
int content = Integer.parseInt(map.get("week").toString());
if (content < start || content > end) {
return "一"; // 如果周数不在课程持续时间内，返回默认值
}
}
return map.get("name").toString(); // 返回课程名称
}
@Override
public List<WeekCourse> getTimetableByStudent(Map<String, Object> condition) {
User user = studentMapper.getStudentById(condition.get("studentName").toString()); // 根据姓名获取学生信息
Map<String, Object> oldMap = new HashMap<>();
oldMap.put("profession", user.getProfession());
oldMap.put("grade", user.getGrade());
oldMap.put("year", condition.get("year"));
oldMap.put("term", condition.get("term"));
oldMap.put("week", condition.get("week"));
List<WeekCourse> list = weekCourseMapper.getWeekCourse(oldMap); // 获取学生条件下的周课程
dealMethod(list, oldMap); // 处理周课程
return list;
}
@Override
public List<WeekCourse> getTimetableByTeacher(Map<String, Object> condition) {
// 已废弃的功能
int num = timetableMapper.checkCount(condition); // 检查课程表条目的数量
List<WeekCourse> weekCourseList = new ArrayList<>();
if (num == 0) { // 如果没有条目，创建一个空的课程表
for (int i = 1; i < 11; i++) {
WeekCourse week = new WeekCourse();
weekCourseList.add(week);
}
} else {
weekCourseList = weekCourseMapper.getWeekCourse(condition); // 获取给定条件的周课程
dealMethod(weekCourseList, condition); // 处理周课程
}
// 获取教师负责的专业、班级、课程
List<TeacherCourse> teacherCourseList = teacherCourseMapper.getCourseListById(condition.get("teacherId").toString());
List<WeekCourse> newList = new ArrayList<>();
// 将新课程的
// 每一项设为"一"
for (int i = 1; i < 11; i++) {
WeekCourse week = new WeekCourse();
dealWeek(week); // 处理每周默认值
newList.add(week);
}
if (num == 0) {
return newList; // 如果没有课程条目，返回新课程列表
}
for (TeacherCourse teacherCourse : teacherCourseList) {
for (int i = 0; i < weekCourseList.size(); i++) {
WeekCourse weekCourse = dealWeekCourse(newList.get(i), weekCourseList.get(i), teacherCourse.getName());
newList.set(i, weekCourse); // 将处理后的周课程设为新课程列表
}
}
return newList; // 返回新课程列表
}
@Override
public void updateCourseInfo(CourseInfo courseInfo) {
courseInfoMapper.updateCourseInfo(courseInfo); // 更新课程信息
}
private WeekCourse dealWeekCourse(WeekCourse newWeek, WeekCourse oldWeek, String name) {
// 当课程表的课程等于教师负责的课程时，存入新的课程表newWeek
if (oldWeek.getMonday().equals(name)) {
newWeek.setMonday(oldWeek.getMonday());
}
if (oldWeek.getTuesday().equals(name)) {
newWeek.setTuesday(oldWeek.getTuesday());
}
if (oldWeek.getWednesday().equals(name)) {
newWeek.setWednesday(oldWeek.getWednesday());
}
if (oldWeek.getThursday().equals(name)) {
newWeek.setThursday(oldWeek.getThursday());
}
if (oldWeek.getFriday().equals(name)) {
newWeek.setFriday(oldWeek.getFriday());
}
if (oldWeek.getSaturday().equals(name)) {
newWeek.setSaturday(oldWeek.getSaturday());
}
if (oldWeek.getSunday().equals(name)) {
newWeek.setSunday(oldWeek.getSunday());
}
return newWeek; // 返回新的周课程
}
}
11万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
