【包调试运行】基于ssm教师综合评价系统源码和文档

简介：
教师综合评价系统ssm

SSM  layui jsp

功能分析：

管理员
学生管理：（id，学号，姓名，班级，性别，电话，操作）
教师管理：（id，教师工号，姓名，密码，性别，电话，系别名称，操作）
班级管理：（id，班级，院系，操作）
系别管理：（id，系别名称，操作）
学期管理：
学期设置（id，学期名称，开启状态）
学期开启（评价学期设置，状态）
课程管理：（id，课程名称，院系，操作）
授课管理：（id，学期，教师，班级，课程，操作）
分数管理：
学生评教分数（id，学生名称，学生班级，教师名称，课程名称，评价分数，操作）
同行教师评教分数（id，院系，评价教师，被评价教师，课程名，分数，操作）
评价管理：
评价指标管理（id，指标内容，指标类别，操作）

学生
在线评教：（序号，课程名称，任课教师，操作）
查看结果：（序号，课程名称，任课教师，评教分数）
个人信息：
查看个人信息
修改密码

教师
在线评教：（序号，课程名称，任课教师，操作）
查看结果：（序号，课程名称，任课教师，评教分数）
个人信息：
查看个人信息
修改密码

教学质量是高等院校人才的培养和存活持续发展的根本保证，树立良好的教师教学质量保障机制是世界一流大学的主要标示，而推行客观课堂教学评乃是健全质量认证体系的基本前提。科学规范、切实可行的教学质量点评方式是恰当充分发挥教学质量点评指导作用、平稳提升教学质量的关键所在，文中明确提出设计一个根据互联网的数据库系统智能管理系统，以专注于完成合理的课堂教学品质的描述与意见反馈。

本系统研发的过程中，最先，应该是高等院校已有的文化教育课堂教学评价系统开展调研，然后进行需求分析报告，随后统一建模语言然后进行要求描述及其测试用例通信规约的描述。次之，针对性地开展系统详细设计，明确本课题研究所使用的技术方案。再度，开展系统的总体设计及其核心模块的健全，并且对概念模型设计及其数据分析表进行系统描述。最终，进行系统页面设计及其代码实现工作。完成核心模块的功效后，对系统开展上线测试，确保系统安全性、灵便、高效率的运作。

教师教学质量综合评价系统对提高教学质量起着关键的作用。该系统通过 Mysql数据库对系统涉及到的各类数据和数据关系进行设计，再利用IDEA程序设计工具通过JAVA的 SSM 技术框架对数据库的信息进行管理，从用户需求，系统结构设计，数据库设计，软件功能的实现等方面进行了详细的论述。该系统操作界面友好简单，系统能够完成各级用户的评教和个人信息的查询，同时也实现了管理员对各类信息的有效管理。

关键字: 教学质量综合评价；B/S模式;SSM;mysql

【765】基于ssm教师综合评价系统设计与实现

演示视频：

ssm教师综合评价系统java教师教学质量评价系统源码和论文

ABSTRACT

Teaching quality is the fundamental guarantee for the cultivation of talents and the survival and sustainable development of colleges and universities. Establishing a good guarantee mechanism for teachers' teaching quality is the main sign of world-class universities, and the implementation of objective classroom teaching evaluation is the basic premise for improving the quality certification system. The scientific, standardized and practical teaching quality evaluation method is the key to properly give full play to the guiding role of teaching quality evaluation and steadily improve the teaching quality. The article clearly proposes to design an intelligent management system based on the Internet database system to focus on completing reasonable classroom teaching quality description and feedback.

In the process of research and development of this system, the first step should be to conduct research on the existing cultural education classroom teaching evaluation system in colleges and universities, and then conduct demand analysis reports. Then, the unified modeling language will describe the requirements and test case communication protocols. Secondly, the detailed design of the system shall be carried out to clarify the technical scheme used in this research. Thirdly, carry out the overall design of the system and the improvement of its core modules, and systematically describe the conceptual model design and its data analysis table. Finally, the system page design and code implementation work. After the effectiveness of the core modules is completed, the system will be online tested to ensure the safe, convenient and efficient operation of the system.

The comprehensive evaluation system of teachers' teaching quality plays a key role in improving teaching quality. The system designs all kinds of data and data relationships involved in the system through MySQL database, and then uses IDEA programming tools to manage the database information through JAVA's SSM technical framework. It discusses in detail from user requirements, system structure design, database design, software function realization, etc. The operation interface of the system is friendly and simple. The system can complete the evaluation of users at all levels and the query of personal information. At the same time, it also realizes the effective management of various information by administrators.

Keywords: comprehensive evaluation of teaching quality; B/S mode; SSM; mysql

package ssm.controller;

import java.util.HashMap;
import java.util.Iterator;
import java.util.List;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.ModelAndView;


import ssm.entity.ResultMsg;
import ssm.entity.St_score;
import ssm.entity.Standard;
import ssm.entity.Student;
import ssm.entity.Teacher;
import ssm.entity.Teacher_course;
import ssm.entity.Tt_score;
import ssm.service.EvaluateService;
import ssm.service.StandardService;
import ssm.service.TermService;

@Controller
public class EvaluateController {

	@Autowired
	private EvaluateService evaluateService;
	@Autowired
	private TermService termService;
	@Autowired
	private StandardService standardService;

	//1.访问学生评教列表页面
	@RequestMapping("/st_evaluate_list")
	public ModelAndView st_evaluate_list(HttpServletRequest request) {
		ModelAndView mView=new ModelAndView("evaluate/st_evaluate_list");
		
		HttpSession session = request.getSession(true); 
		Student student=(Student)session.getAttribute("user");
		
		//查询学期是否存在
		int termResult = termService.selectIsCurrAppraise();
		if(termResult==1) {//如果存在，查询学期的id
			int termResultId = termService.selectIsCurrAppraiseByIs_open();
			
			HashMap <String,Object> map = new HashMap<String,Object>();

			map.put("classes_no",student.getClasses().getClasses_no());

			map.put("term_id",termResultId);
				
			List<Teacher_course> st_list = evaluateService.selectCourseTeacherByNo(map);//查询该学生在开启学期的可评价记录
			
			List<St_score> st_scores = evaluateService.selectSt_scoreByStudent_id(student.getId());//查询该学期已评价的记录
			
			Iterator<Teacher_course> it = st_list.iterator();
			 while(it.hasNext()){
			  Teacher_course x = it.next();
			  System.out.println(x.getId());
			  Iterator<St_score> is = st_scores.iterator();
			  while(is.hasNext()){
				  St_score y = is.next();
				  System.out.println(y.getId());
				  if(y.getStudent_id() == student.getId() && y.getTeacher_id() == x.getTeacher_id() && y.getCourse_name() .equals(x.getCourse().getCourse_name()) ){
					    it.remove();
				  }
			  }  
			}
			 
			mView.addObject("st_list", st_list);
			
			return mView;
		}else {
			return mView.addObject("st_list", "");
		}

		
	}	
	
	//新
	//2.访问教师评教列表页面
	@RequestMapping("/tt_evaluate_list")
	public ModelAndView tt_evaluate_list(HttpServletRequest request) {
		ModelAndView mView=new ModelAndView("evaluate/tt_evaluate_list");
		
		HttpSession session = request.getSession(true); 
		Teacher teacher=(Teacher)session.getAttribute("user");
		
		//查询学期是否存在
				int termResult = termService.selectIsCurrAppraise();
				if(termResult==1) {//如果存在，查询学期的id
					int termResultId = termService.selectIsCurrAppraiseByIs_open();
					
					HashMap <String,Object> map = new HashMap<String,Object>();

					map.put("dep_id",teacher.getDep_id());

					map.put("term_id",termResultId);
						
					List<Teacher_course> tt_list = evaluateService.selectCourseTeacherByInfo(map);//查询该学生在开启学期的可评价记录
					
					List<Tt_score> tt_scores = evaluateService.selectSt_scoreByTeacher_id(teacher.getId());//查询该学期已评价的记录
					Iterator<Teacher_course> it = tt_list.iterator();
					 while(it.hasNext()){
					  Teacher_course x = it.next();
					  					  
					  if(x.getTeacher_id() == teacher.getId()) {
						  it.remove();
						  continue;
					  }
					  Iterator<Tt_score> is = tt_scores.iterator();
					  while(is.hasNext()){
						  Tt_score y = is.next();
						  if(y.getTeacher1_id() == teacher.getId() && y.getTeacher2_id() == x.getTeacher_id() && y.getCourse_name().equals(x.getCourse().getCourse_name())){
							    it.remove();
						  }
					  }  
					}
					 
					 
					mView.addObject("tt_list", tt_list);
					
					return mView;
				}else {
					return mView.addObject("tt_list", "");
				}
		
		
		/*List<Teacher_course> tt_list=evaluateService.selectCourseTeacherByDepid(teacher);
		
		mView.addObject("tt_list", tt_list);
		return mView;*/
	}
	
		//访问学生评价页面
		@RequestMapping("/st_score_evaluate")
		public ModelAndView st_score(int id){						
			ModelAndView mView= new ModelAndView("evaluate/st_score");
			Teacher_course teacher_course = evaluateService.selectCourseTeacherAllById(id);			
			mView.addObject("teacher_course", teacher_course);
			
			return mView;		
		}
		
		//访问教师评价页面
		@RequestMapping("/tt_score_evaluate")
		public ModelAndView tt_score(){
			ModelAndView mView= new ModelAndView("evaluate/tt_score");
			return mView;		
		}
			
		//学生评价提交
		@RequestMapping("/st_score_submit")
		@ResponseBody
		public ResultMsg st_score_submit(int student_id,int classes_id,int teacher_id,float st_score,String course_name) {
				
			St_score score = new St_score();
			score.setStudent_id(student_id);
			score.setClasses_id(classes_id);
			score.setTeacher_id(teacher_id);
			score.setSt_score(st_score);
			score.setCourse_name(course_name);
			int st_scoreResult = evaluateService.insertSt_scoreInfo(score);
			
			if(st_scoreResult>0) {
				return new ResultMsg(1, "评价成功！");
			}else {
				return new ResultMsg(0, "评价失败！");
			}
		}
		
		//教师评价提交
		@RequestMapping("/tt_score_submit")
		@ResponseBody
		public ResultMsg tt_score_submit(int teacher1_id,int dep_id,int teacher2_id,float tt_score,String course_name) {
			System.out.println("test1");
			Tt_score score = new Tt_score();
			score.setTeacher1_id(teacher1_id);
			score.setDep_id(dep_id);
			score.setTeacher2_id(teacher2_id);
			score.setTt_score(tt_score);
			score.setCourse_name(course_name);
			int tt_scoreResult = evaluateService.insertTt_scoreInfo(score);
			
			if(tt_scoreResult>0) {
				return new ResultMsg(1, "评价成功！");
			}else {
				return new ResultMsg(0, "评价失败！");
			}
		}
		
	//点击评教按钮，进入评教界面
	@RequestMapping("/st_comein")
	public ModelAndView st_comein(@RequestParam(value = "id")String id) {
		ModelAndView mView=new ModelAndView("evaluate/st_score");
		System.out.println(id);
		double tmp = Double.parseDouble(id);
		
		Teacher_course teacher_course=evaluateService.selectCourseTeacherByid((int)tmp);
		
		List<Standard> standards = standardService.selectStandardByType(0);
		
		System.out.println("列表id:"+teacher_course.getId());
		
		mView.addObject("standards",standards);
		mView.addObject("teacher_course",teacher_course);

		return mView;
	}
	
	//点击评教按钮，进入评教界面
	@RequestMapping("/tt_comein")
	public ModelAndView tt_comein(@RequestParam(value = "id")String id) {
		ModelAndView mView=new ModelAndView("evaluate/tt_score");
		System.out.println("id:"+id);
		double tmp = Double.parseDouble(id);
		
		Teacher_course teacher_course=evaluateService.selectCourseTeacherByTeacher_courseId((int)tmp);
		
		List<Standard> standards=standardService.selectStandardByType(1);
		
		mView.addObject("standards",standards);
		mView.addObject("teacher_course",teacher_course);
		return mView;
	}
	
}

package com.controller;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Map;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Date;
import java.util.List;
import javax.servlet.http.HttpServletRequest;

import com.utils.ValidatorUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.annotation.IgnoreAuth;

import com.entity.WeixiugongEntity;
import com.entity.view.WeixiugongView;

import com.service.WeixiugongService;
import com.service.TokenService;
import com.utils.PageUtils;
import com.utils.R;
import com.utils.MD5Util;
import com.utils.MPUtil;
import com.utils.CommonUtil;


/**
 * 维修工
 * 后端接口
 * @author 
 * @email 
 * @date 2023-02-25 16:01:10
 */
@RestController
@RequestMapping("/weixiugong")
public class WeixiugongController {
    @Autowired
    private WeixiugongService weixiugongService;
    
	@Autowired
	private TokenService tokenService;
	
	/**
	 * 登录
	 */
	@IgnoreAuth
	@RequestMapping(value = "/login")
	public R login(String username, String password, String captcha, HttpServletRequest request) {
		WeixiugongEntity user = weixiugongService.selectOne(new EntityWrapper<WeixiugongEntity>().eq("zhanghao", username));
		if(user==null || !user.getMima().equals(password)) {
			return R.error("账号或密码不正确");
		}
		
		String token = tokenService.generateToken(user.getId(), username,"weixiugong",  "维修工" );
		return R.ok().put("token", token);
	}
	
	/**
     * 注册
     */
	@IgnoreAuth
    @RequestMapping("/register")
    public R register(@RequestBody WeixiugongEntity weixiugong){
    	//ValidatorUtils.validateEntity(weixiugong);
    	WeixiugongEntity user = weixiugongService.selectOne(new EntityWrapper<WeixiugongEntity>().eq("zhanghao", weixiugong.getZhanghao()));
		if(user!=null) {
			return R.error("注册用户已存在");
		}
		Long uId = new Date().getTime();
		weixiugong.setId(uId);
        weixiugongService.insert(weixiugong);
        return R.ok();
    }
	
	/**
	 * 退出
	 */
	@RequestMapping("/logout")
	public R logout(HttpServletRequest request) {
		request.getSession().invalidate();
		return R.ok("退出成功");
	}
	
	/**
     * 获取用户的session用户信息
     */
    @RequestMapping("/session")
    public R getCurrUser(HttpServletRequest request){
    	Long id = (Long)request.getSession().getAttribute("userId");
        WeixiugongEntity user = weixiugongService.selectById(id);
        return R.ok().put("data", user);
    }
    
    /**
     * 密码重置
     */
    @IgnoreAuth
	@RequestMapping(value = "/resetPass")
    public R resetPass(String username, HttpServletRequest request){
    	WeixiugongEntity user = weixiugongService.selectOne(new EntityWrapper<WeixiugongEntity>().eq("zhanghao", username));
    	if(user==null) {
    		return R.error("账号不存在");
    	}
        user.setMima("123456");
        weixiugongService.updateById(user);
        return R.ok("密码已重置为：123456");
    }


    /**
     * 后端列表
     */
    @RequestMapping("/page")
    public R page(@RequestParam Map<String, Object> params,WeixiugongEntity weixiugong, HttpServletRequest request){
        EntityWrapper<WeixiugongEntity> ew = new EntityWrapper<WeixiugongEntity>();
		PageUtils page = weixiugongService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, weixiugong), params), params));

        return R.ok().put("data", page);
    }
    
    /**
     * 前端列表
     */
    @RequestMapping("/list")
    public R list(@RequestParam Map<String, Object> params,WeixiugongEntity weixiugong, HttpServletRequest request){
        EntityWrapper<WeixiugongEntity> ew = new EntityWrapper<WeixiugongEntity>();
		PageUtils page = weixiugongService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, weixiugong), params), params));
        return R.ok().put("data", page);
    }

	/**
     * 列表
     */
    @RequestMapping("/lists")
    public R list( WeixiugongEntity weixiugong){
       	EntityWrapper<WeixiugongEntity> ew = new EntityWrapper<WeixiugongEntity>();
      	ew.allEq(MPUtil.allEQMapPre( weixiugong, "weixiugong")); 
        return R.ok().put("data", weixiugongService.selectListView(ew));
    }

	 /**
     * 查询
     */
    @RequestMapping("/query")
    public R query(WeixiugongEntity weixiugong){
        EntityWrapper< WeixiugongEntity> ew = new EntityWrapper< WeixiugongEntity>();
 		ew.allEq(MPUtil.allEQMapPre( weixiugong, "weixiugong")); 
		WeixiugongView weixiugongView =  weixiugongService.selectView(ew);
		return R.ok("查询维修工成功").put("data", weixiugongView);
    }
	
    /**
     * 后端详情
     */
    @RequestMapping("/info/{id}")
    public R info(@PathVariable("id") Long id){
        WeixiugongEntity weixiugong = weixiugongService.selectById(id);
        return R.ok().put("data", weixiugong);
    }

    /**
     * 前端详情
     */
    @RequestMapping("/detail/{id}")
    public R detail(@PathVariable("id") Long id){
        WeixiugongEntity weixiugong = weixiugongService.selectById(id);
        return R.ok().put("data", weixiugong);
    }
    



    /**
     * 后端保存
     */
    @RequestMapping("/save")
    public R save(@RequestBody WeixiugongEntity weixiugong, HttpServletRequest request){
    	weixiugong.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
    	//ValidatorUtils.validateEntity(weixiugong);
    	WeixiugongEntity user = weixiugongService.selectOne(new EntityWrapper<WeixiugongEntity>().eq("zhanghao", weixiugong.getZhanghao()));
		if(user!=null) {
			return R.error("用户已存在");
		}
		weixiugong.setId(new Date().getTime());
        weixiugongService.insert(weixiugong);
        return R.ok();
    }
    
    /**
     * 前端保存
     */
    @RequestMapping("/add")
    public R add(@RequestBody WeixiugongEntity weixiugong, HttpServletRequest request){
    	weixiugong.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
    	//ValidatorUtils.validateEntity(weixiugong);
    	WeixiugongEntity user = weixiugongService.selectOne(new EntityWrapper<WeixiugongEntity>().eq("zhanghao", weixiugong.getZhanghao()));
		if(user!=null) {
			return R.error("用户已存在");
		}
		weixiugong.setId(new Date().getTime());
        weixiugongService.insert(weixiugong);
        return R.ok();
    }

    /**
     * 修改
     */
    @RequestMapping("/update")
    public R update(@RequestBody WeixiugongEntity weixiugong, HttpServletRequest request){
        //ValidatorUtils.validateEntity(weixiugong);
        weixiugongService.updateById(weixiugong);//全部更新
        return R.ok();
    }
    

    /**
     * 删除
     */
    @RequestMapping("/delete")
    public R delete(@RequestBody Long[] ids){
        weixiugongService.deleteBatchIds(Arrays.asList(ids));
        return R.ok();
    }
    
    /**
     * 提醒接口
     */
	@RequestMapping("/remind/{columnName}/{type}")
	public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request, 
						 @PathVariable("type") String type,@RequestParam Map<String, Object> map) {
		map.put("column", columnName);
		map.put("type", type);
		
		if(type.equals("2")) {
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
			Calendar c = Calendar.getInstance();
			Date remindStartDate = null;
			Date remindEndDate = null;
			if(map.get("remindstart")!=null) {
				Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
				c.setTime(new Date()); 
				c.add(Calendar.DAY_OF_MONTH,remindStart);
				remindStartDate = c.getTime();
				map.put("remindstart", sdf.format(remindStartDate));
			}
			if(map.get("remindend")!=null) {
				Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
				c.setTime(new Date());
				c.add(Calendar.DAY_OF_MONTH,remindEnd);
				remindEndDate = c.getTime();
				map.put("remindend", sdf.format(remindEndDate));
			}
		}
		
		Wrapper<WeixiugongEntity> wrapper = new EntityWrapper<WeixiugongEntity>();
		if(map.get("remindstart")!=null) {
			wrapper.ge(columnName, map.get("remindstart"));
		}
		if(map.get("remindend")!=null) {
			wrapper.le(columnName, map.get("remindend"));
		}


		int count = weixiugongService.selectCount(wrapper);
		return R.ok().put("count", count);
	}
	


}