基于javaweb+mysql的springboot课程评价系统(java+springboot+layui+html+maven+mysql)

于 2023-08-13 16:04:26 发布
阅读量51 收藏
点赞数
文章标签： java html mysql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_71414071/article/details/132260581
版权

基于javaweb+mysql的springboot课程评价系统(java+springboot+layui+html+maven+mysql)

运行环境

Java≥8、MySQL≥5.7

开发工具

eclipse/idea/myeclipse/sts等均可配置运行

适用

课程设计，大作业，毕业设计，项目练习，学习演示等

功能说明

基于javaweb+mysql的SpringBoot课程评价系统(java+springboot+layui+html+maven+mysql)

项目介绍

适合刚接触springboot的同学学习一下的，难度不大，前端使用layui框架，后台springboot+mybatis。代码量较少。 角色分为 学生、教师、管理员，学生可修改密码，先选择课程之后对对应课程的教师做出评价，最后计算出总分入库；

管理员角色包含以下功能：登录,管理员管理,教师管理增删改查,课程管理增删改查,教学指标增删改查,学生增删改查,查看评价等功能。 教师角色包含以下功能：登录,课程管理,教学指标管理,学生管理,收到的评价等功能。 学生角色包含以下功能：登录,修改个人信息,开始评分,选择课程进行评价,查看评分,打分等功能。

环境需要

1.运行环境：最好是java jdk 1.8，我们在这个平台上运行的。其他版本理论上也可以。

2.IDE环境：IDEA，Eclipse,Myeclipse都可以。推荐IDEA; 3.tomcat环境：Tomcat 7.x,8.x,9.x版本均可 4.硬件环境：windows 7/8/10 1G内存以上；或者 Mac OS； 5.是否Maven项目: 是；查看源码目录中是否包含pom.xml；若包含，则为maven项目，否则为非maven项目

6.数据库：MySql 5.7版本；

技术栈

  1. 后端：SpringBoot+MyBatis

  2. 前端：layui+html

使用说明

  1. 使用Navicat或者其它工具，在mysql中创建对应名称的数据库，并导入项目的sql文件； 2. 将项目中application.properties配置文件中的数据库配置改为自己的配置 3. 使用IDEA/Eclipse/MyEclipse导入项目，Eclipse/MyEclipse导入时，若为maven项目请选择maven;若为maven项目，导入成功后请执行maven clean;maven install命令，配置tomcat，然后运行； 4. 运行项目，输入localhost:8085 登录 5. 管理员账户：admin 密码：123456 教师账户：jiaoshi 密码：123456

学生账户：student 密码：123456

    public Layui select(@RequestParam(required = false) String courseName, @RequestParam(value = "page",defaultValue = "1") Integer page,
                        @RequestParam(value = "limit",defaultValue = "100") Integer limit) {
        CourseEntityExample example = new CourseEntityExample();
        if (!StringUtils.isEmpty(courseName)) {
            example.or().andCourseNameLike("%"+courseName+"%");
        }
        Long cou = courseEntityMapper.countByExample(example);
        return Layui.data(cou.intValue(), courseEntityMapper.selectByExamplePaging(example, page - 1, limit));
    }

    @RequestMapping("/getCourse")
    public CourseEntity getAdmin(@RequestParam(value = "id") Integer id) {
        return courseEntityMapper.selectByPrimaryKey(id);
    }

    @RequestMapping("/queryTeacherByCourseId")
    public Layui queryTeacherByCourseId(@RequestParam(value = "id") Integer id) {
        CourseTeaEntityExample example = new CourseTeaEntityExample();
        example.or().andCourseIdEqualTo(id);
        List<CourseTeaEntity> courseTeaEntities = courseTeaEntityMapper.selectByExample(example);
        if (courseTeaEntities.size() == 0) {
            return null;
        }
        TeacherEntityExample teacherEntityExample = new TeacherEntityExample();
        teacherEntityExample.or().andTeaIdIn(courseTeaEntities.stream().map(CourseTeaEntity::getTeacherId).collect(Collectors.toList()));
        List<TeacherEntity> teacherEntities = teacherEntityMapper.selectByExample(teacherEntityExample);
        return Layui.data(teacherEntities.size(), teacherEntities);
    }

    @RequestMapping("/updateLoginUser")
    public Integer updateLoginUser(@RequestBody LoginUserDTO loginUserDTO) {
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        HttpSession session = request.getSession();
        String loginType = session.getAttribute("loginUserType").toString();
        UserTypeEnum userTypeEnum = UserTypeEnum.getEventByCode(loginType);
        int userDTO = 0;
        switch (userTypeEnum) {
            case ADMIN:
                AdminEntity adminEntity = new AdminEntity();
                adminEntity.setUserid(loginUserDTO.getId());
                adminEntity.setUsername(loginUserDTO.getUsername());
                adminEntity.setUserpw(loginUserDTO.getPassword());
                userDTO = adminEntityMapper.updateByPrimaryKeySelective(adminEntity);
                break;
            case TEACHER:

            PingjiaxinxiEntityExample entityExample = new PingjiaxinxiEntityExample();
            entityExample.or().andTeaIdEqualTo(teacherId).andStuIdEqualTo(Integer.parseInt(userId));
            Long result = pingjiaxinxiEntityMapper.countByExample(entityExample);
            System.out.println("评价用户身份："+loginUserType);
            if (result > 0) {
                return Result.ofSuccess(loginUserType);
            }
            pingjiaxinxiEntityMapper.insertSelective(entity);
            return Result.ofSuccess(loginUserType);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return Result.ofError(5001,"评价失败");
    }

    @RequestMapping("/listLayui")
    public Layui listLayui(@RequestParam(value = "page") Integer page,
                           @RequestParam(value = "limit") Integer limit) {
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        HttpSession session = request.getSession();
        PingjiaxinxiEntityExample entityExample = new PingjiaxinxiEntityExample();
        String loginUserId = session.getAttribute("loginUserId").toString();
        String loginUserType = session.getAttribute("loginUserType").toString();
        //如果登录用户为a教师  只能看到他自己的评价信息
        if (loginUserType.equals(UserTypeEnum.TEACHER.getCode())) {
            entityExample.or().andTeaIdEqualTo(Integer.parseInt(loginUserId));
        }
        Long count = pingjiaxinxiEntityMapper.countByExample(entityExample);
        List<PingjiaxinxiEntity> entities = pingjiaxinxiEntityMapper.selectByExamplePaging(entityExample, page, limit);
        List<PJDTO> pjdtoList = new ArrayList<>();
        entities.forEach(o -> {
            PJDTO pjdto = new PJDTO();
            pjdto.setId(o.getId());
            TeacherEntity teacherEntity = teacherEntityMapper.selectByPrimaryKey(o.getTeaId());
            StudentEntity studentEntity = studentEntityMapper.selectByPrimaryKey(o.getStuId());
            pjdto.setStudentName(studentEntity == null ? "" : studentEntity.getStuRealname());
            pjdto.setTeacherName(teacherEntity == null ? "" : teacherEntity.getTeaRealname());
            pjdto.setShijian(o.getShijian());
            pjdto.setZongfen(o.getZongfen());
            pjdtoList.add(pjdto);
        });
        return Layui.data(count.intValue(), pjdtoList);
    }

                    result = 2;
                    session.setAttribute("loginUserType", UserTypeEnum.TEACHER.getCode());
                    session.setAttribute("loginUserId", entity2.getTeaId());
                }
                break;
            case STUDENT:
                StudentEntityExample exampleStu = new StudentEntityExample();
                exampleStu.or().andLoginNameEqualTo(username).andLoginPwEqualTo(password);
                StudentEntity studentEntity = studentEntityMapper.selectOneByExample(exampleStu);
                if (null != studentEntity) {
                    result = 3;
                    session.setAttribute("loginUserType", UserTypeEnum.STUDENT.getCode());
                    session.setAttribute("loginUserId", studentEntity.getStuId());
                }
                break;
            default:
                return 0;
        }
        return result;
    }

    @GetMapping("/getLogin")
    public String getCurrentLoginUser() {
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        HttpSession session = request.getSession();
        String loginUser = session.getAttribute("loginUserType").toString();
        return loginUser;
    }

    @RequestMapping("/logout")
    public Boolean logout() {
        try {
            HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
            HttpSession session = request.getSession();
            session.removeAttribute("loginUserType");
            session.removeAttribute("loginUserId");
            return true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }
}


        HttpSession session = request.getSession();
        String loginType = session.getAttribute("loginUserType").toString();
        UserTypeEnum userTypeEnum = UserTypeEnum.getEventByCode(loginType);
        int userDTO = 0;
        switch (userTypeEnum) {
            case ADMIN:
                AdminEntity adminEntity = new AdminEntity();
                adminEntity.setUserid(loginUserDTO.getId());
                adminEntity.setUsername(loginUserDTO.getUsername());
                adminEntity.setUserpw(loginUserDTO.getPassword());
                userDTO = adminEntityMapper.updateByPrimaryKeySelective(adminEntity);
                break;
            case TEACHER:
                TeacherEntity teacherEntity = new TeacherEntity();
                teacherEntity.setTeaId(loginUserDTO.getId());
                teacherEntity.setLoginName(loginUserDTO.getUsername());
                teacherEntity.setLoginPw(loginUserDTO.getPassword());
                userDTO = teacherEntityMapper.updateByPrimaryKey(teacherEntity);
                break;
            case STUDENT:
                StudentEntity studentEntity = new StudentEntity();
                studentEntity.setStuId(loginUserDTO.getId());
                studentEntity.setLoginName(loginUserDTO.getUsername());
                studentEntity.setLoginPw(loginUserDTO.getPassword());
                userDTO = studentEntityMapper.updateByPrimaryKey(studentEntity);
                break;
            default:
                break;
        }
        return userDTO;
    }

    @RequestMapping("/getLoginUser")
    public LoginUserDTO getLoginUser() {
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        HttpSession session = request.getSession();
        String loginType = session.getAttribute("loginUserType").toString();
        String loginUserId = session.getAttribute("loginUserId").toString();
        UserTypeEnum userTypeEnum = UserTypeEnum.getEventByCode(loginType);
        LoginUserDTO userDTO = new LoginUserDTO();
        switch (userTypeEnum) {
            case ADMIN:
                AdminEntity adminEntity = adminEntityMapper.selectByPrimaryKey(Integer.parseInt(loginUserId));
                userDTO.setId(adminEntity.getUserid());
                userDTO.setUsername(adminEntity.getUsername());
                userDTO.setPassword(adminEntity.getUserpw());
                break;
            case TEACHER:
                TeacherEntity teacherEntity = teacherEntityMapper.selectByPrimaryKey(Integer.parseInt(loginUserId));
                userDTO.setId(teacherEntity.getTeaId());
                userDTO.setUsername(teacherEntity.getLoginName());
                userDTO.setPassword(teacherEntity.getLoginPw());


/**
 * @Description:
 */
@RestController
@RequestMapping("/login")
public class LoginController {

    @Autowired
    private StudentEntityMapper studentEntityMapper;
    @Autowired
    private AdminEntityMapper adminEntityMapper;
    @Autowired
    private TeacherEntityMapper teacherEntityMapper;

    @PostMapping("/login")
    public Integer login(@RequestParam(value = "username") String username, @RequestParam(value = "password") String password,
                         @RequestParam(value = "userType") String userType) {

        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        HttpSession session = request.getSession();
        UserTypeEnum userTypeEnum = UserTypeEnum.getEventByCode(userType);
        Integer result = 0;
        switch (userTypeEnum) {
            case ADMIN:
                AdminEntityExample example = new AdminEntityExample();
                example.or().andUsernameEqualTo(username).andUserpwEqualTo(password);
                AdminEntity entity = adminEntityMapper.selectOneByExample(example);
                if (null != entity) {
                    result = 1;
                    session.setAttribute("loginUserType", UserTypeEnum.ADMIN.getCode());
                    session.setAttribute("loginUserId", entity.getUserid());
                }
                break;
            case TEACHER:
                TeacherEntityExample exampleTea = new TeacherEntityExample();
                exampleTea.or().andLoginNameEqualTo(username).andLoginPwEqualTo(password);
                TeacherEntity entity2 = teacherEntityMapper.selectOneByExample(exampleTea);
                if (null != entity2) {
                    result = 2;
                    session.setAttribute("loginUserType", UserTypeEnum.TEACHER.getCode());

        }
        if (teaEntities.size() > 0) {
            courseTeaEntityMapper.insertBatch(teaEntities);
        }
        return teacherEntityMapper.insert(entity);
    }

    @PostMapping("/delete")
    public Integer delete(@RequestBody TeacherEntity entity) {
        return teacherEntityMapper.deleteByPrimaryKey(entity.getTeaId());
    }

    @PostMapping("/update")
    public Integer update(@RequestBody TeacherDTO entity) {
        CourseTeaEntityExample example = new CourseTeaEntityExample();
        example.or().andTeacherIdEqualTo(entity.getTeaId());
        //先清空后插入
        courseTeaEntityMapper.deleteByExample(example);
        List<CourseTeaEntity> teaEntities = new ArrayList<>();
        for (int i = 0; i < entity.getCourseIds().length; i++) {
            CourseTeaEntity courseTeaEntity = new CourseTeaEntity();
            courseTeaEntity.setCourseId(entity.getCourseIds()[i]);
            courseTeaEntity.setTeacherId(entity.getTeaId());
            teaEntities.add(courseTeaEntity);
        }
        if (teaEntities.size() > 0) {
            courseTeaEntityMapper.insertBatch(teaEntities);
        }
        return teacherEntityMapper.updateByPrimaryKey(entity);
    }

    @RequestMapping("/select")
    public Layui select(@RequestParam(required = false) String teaRealname, @RequestParam(value = "page") Integer page,
                        @RequestParam(value = "limit") Integer limit) {
        TeacherEntityExample example = new TeacherEntityExample();
        if (!StringUtils.isEmpty(teaRealname)) {
            example.or().andTeaRealnameLike("%"+teaRealname+"%");
        }
        Long cou = teacherEntityMapper.countByExample(example);
        return Layui.data(cou.intValue(), teacherEntityMapper.selectByExamplePaging(example, page - 1, limit));
    }

    @RequestMapping("/getTeacher")
    public TeacherDTO getAdmin(@RequestParam(value = "teaId") Integer teaId) {
        TeacherEntity entity = teacherEntityMapper.selectByPrimaryKey(teaId);
        CourseTeaEntityExample example = new CourseTeaEntityExample();
        example.or().andTeacherIdEqualTo(entity.getTeaId());

@RestController
@RequestMapping("/admin")
public class AdminController {
    @Autowired
    private AdminEntityMapper adminEntityMapper;

    @PostMapping("/add")
    public Integer add(@RequestBody AdminEntity entity) {
        return adminEntityMapper.insert(entity);
    }

    @PostMapping(value = "/delete", consumes = "application/json")
    public Integer delete(@RequestBody AdminEntity entity) {
        return adminEntityMapper.deleteByPrimaryKey(entity.getUserid());
    }

    @PostMapping("/update")
    public Integer update(@RequestBody AdminEntity entity) {
        return adminEntityMapper.updateByPrimaryKey(entity);
    }

    @RequestMapping("/select")
    public Layui select(@RequestParam(required = false) String username,@RequestParam(value = "page")Integer page,
                        @RequestParam(value = "limit")Integer limit) {
        AdminEntityExample example = new AdminEntityExample();
        if (!StringUtils.isEmpty(username)){
            example.or().andUsernameLike("%"+username+"%");
        }
        example.getOrderByClause();
        Long cou = adminEntityMapper.countByExample(example);
        return Layui.data(cou.intValue(), adminEntityMapper.selectByExamplePaging(example, page-1, limit));
    }

    @RequestMapping("/getAdmin")
    public AdminEntity getAdmin(@RequestParam(value="userid")Integer userid) {
        return adminEntityMapper.selectByPrimaryKey(userid);
    }

}

/**

    @PostMapping(value = "/delete", consumes = "application/json")
    public Integer delete(@RequestBody IndexTableEntity entity) {
        return indexTableEntityMapper.deleteByPrimaryKey(entity.getId());
    }

    @PostMapping("/update")
    public Integer update(@RequestBody IndexTableEntity entity) {
        return indexTableEntityMapper.updateByPrimaryKey(entity);
    }

    @RequestMapping("/select")
    public Layui select(@RequestParam(required = false) String indexname, @RequestParam(value = "page") Integer page,
                        @RequestParam(value = "limit") Integer limit) {
        IndexTableEntityExample example = new IndexTableEntityExample();
        IndexTableEntityExample.Criteria criteria = example.createCriteria();
        if (!StringUtils.isEmpty(indexname)) {
            criteria.andIndexnameLike("%"+indexname+"%");
        }
        criteria.andParentIdIsNotNull();
        Long cou = indexTableEntityMapper.countByExample(example);
        return Layui.data(cou.intValue(), indexTableEntityMapper.selectByExamplePaging(example, page - 1, limit));
    }

    @RequestMapping("/selectFir")
    public List<IndexTableEntity> selectFir() {
        IndexTableEntityExample example = new IndexTableEntityExample();
        example.or().andParentIdIsNull();
        return indexTableEntityMapper.selectByExample(example);
    }

    @RequestMapping("/selectList")
    public List<IndexTableEntity> selectList() {
        IndexTableEntityExample example = new IndexTableEntityExample();
        example.or().andParentIdIsNotNull();
        return indexTableEntityMapper.selectByExample(example);
    }

    @RequestMapping("/getFirst")
    public IndexTableEntity getAdmin(@RequestParam(value = "id") Integer userid) {
        return indexTableEntityMapper.selectByPrimaryKey(userid);
    }
}

            entityExample.or().andTeaIdEqualTo(teacherId).andStuIdEqualTo(Integer.parseInt(userId));
            Long result = pingjiaxinxiEntityMapper.countByExample(entityExample);
            System.out.println("评价用户身份："+loginUserType);
            if (result > 0) {
                return Result.ofSuccess(loginUserType);
            }
            pingjiaxinxiEntityMapper.insertSelective(entity);
            return Result.ofSuccess(loginUserType);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return Result.ofError(5001,"评价失败");
    }

    @RequestMapping("/listLayui")
    public Layui listLayui(@RequestParam(value = "page") Integer page,
                           @RequestParam(value = "limit") Integer limit) {
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        HttpSession session = request.getSession();
        PingjiaxinxiEntityExample entityExample = new PingjiaxinxiEntityExample();
        String loginUserId = session.getAttribute("loginUserId").toString();
        String loginUserType = session.getAttribute("loginUserType").toString();
        //如果登录用户为a教师  只能看到他自己的评价信息
        if (loginUserType.equals(UserTypeEnum.TEACHER.getCode())) {
            entityExample.or().andTeaIdEqualTo(Integer.parseInt(loginUserId));
        }
        Long count = pingjiaxinxiEntityMapper.countByExample(entityExample);
        List<PingjiaxinxiEntity> entities = pingjiaxinxiEntityMapper.selectByExamplePaging(entityExample, page, limit);
        List<PJDTO> pjdtoList = new ArrayList<>();
        entities.forEach(o -> {
            PJDTO pjdto = new PJDTO();
            pjdto.setId(o.getId());
            TeacherEntity teacherEntity = teacherEntityMapper.selectByPrimaryKey(o.getTeaId());
            StudentEntity studentEntity = studentEntityMapper.selectByPrimaryKey(o.getStuId());
            pjdto.setStudentName(studentEntity == null ? "" : studentEntity.getStuRealname());
            pjdto.setTeacherName(teacherEntity == null ? "" : teacherEntity.getTeaRealname());
            pjdto.setShijian(o.getShijian());
            pjdto.setZongfen(o.getZongfen());
            pjdtoList.add(pjdto);
        });
        return Layui.data(count.intValue(), pjdtoList);
    }
}


                StudentEntity studentEntity = studentEntityMapper.selectByPrimaryKey(Integer.parseInt(loginUserId));
                userDTO.setId(studentEntity.getStuId());
                userDTO.setUsername(studentEntity.getLoginName());
                userDTO.setPassword(studentEntity.getLoginPw());
                break;
            default:
                break;
        }
        System.out.println(JSONObject.toJSONString(userDTO));
        return userDTO;
    }
}

/**
 * @Description:
 */
@RestController
@RequestMapping("/teacher")
public class TeacherController {

    @Autowired
    TeacherEntityMapper teacherEntityMapper;
    @Autowired
    PingjiaxinxiEntityMapper pingjiaxinxiEntityMapper;
    @Autowired
    CourseTeaEntityMapper courseTeaEntityMapper;

    @PostMapping("/add")
    public Integer add(@RequestBody TeacherDTO entity) {
        List<CourseTeaEntity> teaEntities = new ArrayList<>();
        for (int i = 0; i < entity.getCourseIds().length; i++) {
            CourseTeaEntity courseTeaEntity = new CourseTeaEntity();

    @RequestMapping("/selectFir")
    public List<IndexTableEntity> selectFir() {
        IndexTableEntityExample example = new IndexTableEntityExample();
        example.or().andParentIdIsNull();
        return indexTableEntityMapper.selectByExample(example);
    }

    @RequestMapping("/selectList")
    public List<IndexTableEntity> selectList() {
        IndexTableEntityExample example = new IndexTableEntityExample();
        example.or().andParentIdIsNotNull();
        return indexTableEntityMapper.selectByExample(example);
    }

    @RequestMapping("/getFirst")
    public IndexTableEntity getAdmin(@RequestParam(value = "id") Integer userid) {
        return indexTableEntityMapper.selectByPrimaryKey(userid);
    }
}

/**
 * @Description:
 */
@RestController
@RequestMapping("/student")
public class StudentController {
    @Autowired
    private StudentEntityMapper studentEntityMapper;

    @PostMapping("/add")
    public Integer add(@RequestBody StudentEntity entity) {
        return studentEntityMapper.insert(entity);
    }

    @PostMapping("/delete")
    public Integer delete(@RequestBody StudentEntity entity) {
        return studentEntityMapper.deleteByPrimaryKey(entity.getStuId());
    }

    @PostMapping("/update")
    public Integer update(@RequestBody StudentEntity entity) {
        return studentEntityMapper.updateByPrimaryKey(entity);


    @RequestMapping("/getLoginUser")
    public LoginUserDTO getLoginUser() {
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        HttpSession session = request.getSession();
        String loginType = session.getAttribute("loginUserType").toString();
        String loginUserId = session.getAttribute("loginUserId").toString();
        UserTypeEnum userTypeEnum = UserTypeEnum.getEventByCode(loginType);
        LoginUserDTO userDTO = new LoginUserDTO();
        switch (userTypeEnum) {
            case ADMIN:
                AdminEntity adminEntity = adminEntityMapper.selectByPrimaryKey(Integer.parseInt(loginUserId));
                userDTO.setId(adminEntity.getUserid());
                userDTO.setUsername(adminEntity.getUsername());
                userDTO.setPassword(adminEntity.getUserpw());
                break;
            case TEACHER:
                TeacherEntity teacherEntity = teacherEntityMapper.selectByPrimaryKey(Integer.parseInt(loginUserId));
                userDTO.setId(teacherEntity.getTeaId());
                userDTO.setUsername(teacherEntity.getLoginName());
                userDTO.setPassword(teacherEntity.getLoginPw());
                break;
            case STUDENT:
                StudentEntity studentEntity = studentEntityMapper.selectByPrimaryKey(Integer.parseInt(loginUserId));
                userDTO.setId(studentEntity.getStuId());
                userDTO.setUsername(studentEntity.getLoginName());
                userDTO.setPassword(studentEntity.getLoginPw());
                break;
            default:
                break;
        }
        System.out.println(JSONObject.toJSONString(userDTO));
        return userDTO;
    }
}



    @PostMapping("/update")
    public Integer update(@RequestBody CourseEntity entity) {
        int i = courseEntityMapper.updateByPrimaryKey(entity);
        if(i != 1){
            i = courseEntityMapper.deleteByPrimaryKey(entity.getId());
        }
        return i;
    }

    @RequestMapping("/select")
    public Layui select(@RequestParam(required = false) String courseName, @RequestParam(value = "page",defaultValue = "1") Integer page,
                        @RequestParam(value = "limit",defaultValue = "100") Integer limit) {
        CourseEntityExample example = new CourseEntityExample();
        if (!StringUtils.isEmpty(courseName)) {
            example.or().andCourseNameLike("%"+courseName+"%");
        }
        Long cou = courseEntityMapper.countByExample(example);
        return Layui.data(cou.intValue(), courseEntityMapper.selectByExamplePaging(example, page - 1, limit));
    }

    @RequestMapping("/getCourse")
    public CourseEntity getAdmin(@RequestParam(value = "id") Integer id) {
        return courseEntityMapper.selectByPrimaryKey(id);
    }

    @RequestMapping("/queryTeacherByCourseId")
    public Layui queryTeacherByCourseId(@RequestParam(value = "id") Integer id) {
        CourseTeaEntityExample example = new CourseTeaEntityExample();
        example.or().andCourseIdEqualTo(id);
        List<CourseTeaEntity> courseTeaEntities = courseTeaEntityMapper.selectByExample(example);
        if (courseTeaEntities.size() == 0) {
            return null;
        }
        TeacherEntityExample teacherEntityExample = new TeacherEntityExample();
        teacherEntityExample.or().andTeaIdIn(courseTeaEntities.stream().map(CourseTeaEntity::getTeacherId).collect(Collectors.toList()));
        List<TeacherEntity> teacherEntities = teacherEntityMapper.selectByExample(teacherEntityExample);
        return Layui.data(teacherEntities.size(), teacherEntities);
    }

    @RequestMapping("/updateLoginUser")
    public Integer updateLoginUser(@RequestBody LoginUserDTO loginUserDTO) {
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        HttpSession session = request.getSession();
        String loginType = session.getAttribute("loginUserType").toString();
        UserTypeEnum userTypeEnum = UserTypeEnum.getEventByCode(loginType);
        int userDTO = 0;
        switch (userTypeEnum) {
            case ADMIN:
                AdminEntity adminEntity = new AdminEntity();
                adminEntity.setUserid(loginUserDTO.getId());
                adminEntity.setUsername(loginUserDTO.getUsername());
                adminEntity.setUserpw(loginUserDTO.getPassword());
                userDTO = adminEntityMapper.updateByPrimaryKeySelective(adminEntity);


    @RequestMapping("/listLayui")
    public Layui listLayui(@RequestParam(value = "page") Integer page,
                           @RequestParam(value = "limit") Integer limit) {
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        HttpSession session = request.getSession();
        PingjiaxinxiEntityExample entityExample = new PingjiaxinxiEntityExample();
        String loginUserId = session.getAttribute("loginUserId").toString();
        String loginUserType = session.getAttribute("loginUserType").toString();
        //如果登录用户为a教师  只能看到他自己的评价信息
        if (loginUserType.equals(UserTypeEnum.TEACHER.getCode())) {
            entityExample.or().andTeaIdEqualTo(Integer.parseInt(loginUserId));
        }
        Long count = pingjiaxinxiEntityMapper.countByExample(entityExample);
        List<PingjiaxinxiEntity> entities = pingjiaxinxiEntityMapper.selectByExamplePaging(entityExample, page, limit);
        List<PJDTO> pjdtoList = new ArrayList<>();
        entities.forEach(o -> {
            PJDTO pjdto = new PJDTO();
            pjdto.setId(o.getId());
            TeacherEntity teacherEntity = teacherEntityMapper.selectByPrimaryKey(o.getTeaId());
            StudentEntity studentEntity = studentEntityMapper.selectByPrimaryKey(o.getStuId());
            pjdto.setStudentName(studentEntity == null ? "" : studentEntity.getStuRealname());
            pjdto.setTeacherName(teacherEntity == null ? "" : teacherEntity.getTeaRealname());
            pjdto.setShijian(o.getShijian());
            pjdto.setZongfen(o.getZongfen());
            pjdtoList.add(pjdto);
        });
        return Layui.data(count.intValue(), pjdtoList);
    }
}

/**

        IndexTableEntityExample example = new IndexTableEntityExample();
        example.or().andParentIdIsNotNull();
        return indexTableEntityMapper.selectByExample(example);
    }

    @RequestMapping("/getFirst")
    public IndexTableEntity getAdmin(@RequestParam(value = "id") Integer userid) {
        return indexTableEntityMapper.selectByPrimaryKey(userid);
    }
}

/**
 * @Description:
 */
@RestController
@RequestMapping("/student")
public class StudentController {
    @Autowired
    private StudentEntityMapper studentEntityMapper;

    @PostMapping("/add")
    public Integer add(@RequestBody StudentEntity entity) {
        return studentEntityMapper.insert(entity);
    }

    @PostMapping("/delete")
    public Integer delete(@RequestBody StudentEntity entity) {
        return studentEntityMapper.deleteByPrimaryKey(entity.getStuId());
    }

    @PostMapping("/update")
    public Integer update(@RequestBody StudentEntity entity) {
        return studentEntityMapper.updateByPrimaryKey(entity);
    }

    @RequestMapping("/select")
    public Layui select(@RequestParam(required = false) String stuRealname, @RequestParam(value = "page") Integer page,
                        @RequestParam(value = "limit") Integer limit) {
        StudentEntityExample example = new StudentEntityExample();
        if (!StringUtils.isEmpty(stuRealname)){
            example.or().andStuRealnameLike("%"+stuRealname+"%");

        //如果登录用户为a教师  只能看到他自己的评价信息
        if (loginUserType.equals(UserTypeEnum.TEACHER.getCode())) {
            entityExample.or().andTeaIdEqualTo(Integer.parseInt(loginUserId));
        }
        Long count = pingjiaxinxiEntityMapper.countByExample(entityExample);
        List<PingjiaxinxiEntity> entities = pingjiaxinxiEntityMapper.selectByExamplePaging(entityExample, page, limit);
        List<PJDTO> pjdtoList = new ArrayList<>();
        entities.forEach(o -> {
            PJDTO pjdto = new PJDTO();
            pjdto.setId(o.getId());
            TeacherEntity teacherEntity = teacherEntityMapper.selectByPrimaryKey(o.getTeaId());
            StudentEntity studentEntity = studentEntityMapper.selectByPrimaryKey(o.getStuId());
            pjdto.setStudentName(studentEntity == null ? "" : studentEntity.getStuRealname());
            pjdto.setTeacherName(teacherEntity == null ? "" : teacherEntity.getTeaRealname());
            pjdto.setShijian(o.getShijian());
            pjdto.setZongfen(o.getZongfen());
            pjdtoList.add(pjdto);
        });
        return Layui.data(count.intValue(), pjdtoList);
    }
}

/**
 * @Description:
 */
@RestController
@RequestMapping("/login")
public class LoginController {

    @Autowired
    private StudentEntityMapper studentEntityMapper;
    @Autowired
    private AdminEntityMapper adminEntityMapper;

        return studentEntityMapper.updateByPrimaryKey(entity);
    }

    @RequestMapping("/select")
    public Layui select(@RequestParam(required = false) String stuRealname, @RequestParam(value = "page") Integer page,
                        @RequestParam(value = "limit") Integer limit) {
        StudentEntityExample example = new StudentEntityExample();
        if (!StringUtils.isEmpty(stuRealname)){
            example.or().andStuRealnameLike("%"+stuRealname+"%");
        }
        Long cou = studentEntityMapper.countByExample(example);
        return Layui.data(cou.intValue(), studentEntityMapper.selectByExamplePaging(example, page - 1, limit));
    }

    @RequestMapping("/getStudent")
    public StudentEntity getAdmin(@RequestParam(value="stuId")Integer stuId) {
        return studentEntityMapper.selectByPrimaryKey(stuId);
    }
}

/**
 * @Description:
 */
@RestController
@RequestMapping("/admin")
public class AdminController {
    @Autowired
    private AdminEntityMapper adminEntityMapper;

    @PostMapping("/add")
    public Integer add(@RequestBody AdminEntity entity) {
        return adminEntityMapper.insert(entity);
    }

    @PostMapping(value = "/delete", consumes = "application/json")
    public Integer delete(@RequestBody AdminEntity entity) {
        return adminEntityMapper.deleteByPrimaryKey(entity.getUserid());
    }

    @PostMapping("/update")
    public Integer update(@RequestBody AdminEntity entity) {

请添加图片描述
请添加图片描述
请添加图片描述
请添加图片描述
请添加图片描述
请添加图片描述
请添加图片描述

m0_71414071
关注
【附源码】Java计算机毕业设计教师教学评价系统（程序+LW+部署）
wek106的博客
03-12 316
项目运行环境配置：Jdk1.8 + Tomcat7.0 + Mysql + HBuilderX（Webstorm也行）+ Eclispe（IntelliJ IDEA,Eclispe,MyEclispe,Sts都支持）。项目技术：java+ mybatis + Maven等等组成，B/S模式 + Maven管理等等。环境需要1.运行环境：最好是java jdk 1.8，我们在这个平台上运行的。其他版本理论上也可以。2.IDE环境：IDEA，Eclipse,Myeclipse都可以。推荐IDEA。
基于javaweb的课程评价系统(java+springboot+layui+html+mysql)
m0_69590785的博客
10-27 426
基于javaweb的课程评价系统(java+springboot+layui+html+mysql) 运行环境 Java≥8、MySQL≥5.7 开发工具 eclipse/idea/myeclipse/sts等均可配置运行 适用 课程设计，大作业，毕业设计，项目练习，学习演示等 功能说明
C语言课设--教师评价系统源代码
09-14
本程序六个自定义函数和一个主函数组成，其中主函数循环调用菜单，菜单函数调用其他函数来实现要求的所有功能。在这些函数当中，插入函数，修改函数，删除函数，浏览函数，评价函数是程序的核心部分。
使用django+python开发的学生档案信息管理系统Vue源码
QQ188083800的博客
07-27 1616
学生档案管理系统采用python技术，基django开发，实现了首页、个人中心、学生管理、年级管理、班级管理、课程信息管理、奖惩信息管理、成绩信息管理等内容进行管理，本系统具有良好的兼容性和适应性，为用户提供更多的学生档案信息，也提供了良好的平台，从而提高系统的核心竞争力。对项目进行黑盒测试和白盒测试,搭建开发环境、编写相关文档、搭建对象、数据库设计、编写功能代码、设计网页、用例测试，代码的整合打包，完成服务器的相关配置，最后得到项目成品。4.uniapp微信小程序Androidwebapp。...
（附源码）springboot课程评价系统 毕业设计 211004
VXbishe的博客
11-27 442
1.信息获取方便，用户可在网页上快速浏览到新的信息 2.查看在线详情，单独查看某一个在线的详细信息。 3.注册登录，课程评价系统需要吸引用户，即通过注册来提高用户的存留率。 4.历史记录，用户可以查看自己购买过的订单信息以及其他操作。 5.修改用户信息，可以修改用户密码或者用户名等一些个性化操作。 6.管理员功能，管理员可以对用户或者在线进行管理。 7.系统安全，操作简便，不过于复杂。 8.系统可以稳定运行，不存在卡顿等问题造成用户反感。
课堂教学质量评价系统
07-11
课堂教学质量评价系统
Java 基于 spring boot课程评价系统 springboot+mybatis+layui
myqq80213251的博客
03-24 2025
角色分为 学生、教师、管理员，学生可修改密码，先选择课程之后对对应课程的教师做出评价 运行环境 jdk8+tomcat8+mysql+IntelliJ IDEA/eclipse+maven 项目技术 springboot+mybatis+layui jar包文件 使用maven 运行访问地址： http://localhost:8080/ 管理员账号admin admin 学生...
Java项目:学生管理系统(java+Springboot+Maven+mybatis+Vue+Mysql)
03-19
一、项目简述 本系统功能包括： 学生管理，教师管理，课程管理，成绩管理，系统管理等等。 二、项目运行 环境配置： ...Springboot + Maven + mybatis+ Vue 等等组成，B/S模式 + Maven管理等等。
Java项目:轻语音乐网平台(java+Springboot+ssm+mysql+maven+jsp)
02-11
一、项目简述 ...进行收藏 我的音乐模块：收藏的歌曲会被添加到我的音乐列表中， 在我的音乐列表中也可以对...项目技术： JSP +SpringBoot + MyBatis + html+ css + JavaScript + JQuery + Ajax + Bootstrap+ maven 等等。
Java项目:博客论坛管理系统(java+SpringBoot+JSP+LayUI+maven+mysql)
06-02
本系统分为管理员、游客两种角色； 管理员角色包含以下功能： 登录,用户增删改查,文章增删改查,链接增删改查,日志查看,查看近期数据,类别管理等功能。 游客角色包含以下功能： 首页,查看文章,注册账号,登录,管理...
Course-Evaluation:海大优选-公共课课程评分系统
03-11
JavaWeb项目-海大优选 海大优选-校园课程评价系统。 技术栈： 前端部分 HTML CSS Java脚本 jQuery查询 采取的框架： Vue.js ...待续 初步部分 Java JDK： IDE： 数据库： 数据库名称：课程评估 用户名：root 密码：123456 建表文件：doc / course_evaluation.sql 可视化工具：Navicat 整体框架：MVC架构
教师评价系统
02-26
校无忧教师评价系统是一套为提高教师的教学质量，反馈学生的心声，提高学校教务管理能力的系统。针对各专业所授课程及教师的评价结果，直观的统计出每位教师的综合能力...... 系统功能： 1、完善的系统设置，可以动态的设置院系，专业，课程，教师等信息，使本系统功能丰富，使用灵活，适用于各种学校。 2、增强的辅助功能，登录日志，数据维护，评价计算辅助工具，成绩报表，数据导出EXCEL，使系统更完善，提高使用效果。 3、评价系统的保密性，系统采用不记名投票的模式，不学生可以对所有课程进行评价，不记名评价让大家放心。 5、系统高级功能设置，可以设置软件的名称，后台界面等显示的内容，使软件真正变成您的系统。
教学评价管理系统
02-17
这是做的一个教学评价管理系统，分为管理员，考评管理员，教师和学生四个角色。学生可以通过问卷方式对老师进行教学质量评价，考评管理员负责对评价结果进行统计和计算等级排名等。管理员可以对其他角色进行增删改查。简单实现了密码加密和防止SQL注入功能。用的工具是myeclipse+mysql+tomcat，可以直接运行。
Java 选修课程系统源代码,Eclipse+Mysql开发
11-07
Java 选修课程管理系统，广东石油化工学院计算机07-1班 Logic 陈罗志原创程序，使用Eclipse+Mysql开发，代码中预设的Mysql数据库用户名为root，密码为admin，运行程序，测试用户用户名chenluozhi 密码chenluozhi 　　lib文件夹为Mysql 数据库驱动，util 是所用的工具包。 　　本程序提供几大模块： 　　用户管理模块（权限控制） 　　修改密码模块 　　操作日志管理模块 　　数据库初始化模块 　　学生、教师、课程的添加、修改、删除、查询等模块 　　学生信息录入模块 　　课程信息浏览（查询）模块 　　 　　Course1.1版本[2010-12-25] 　　 　　1、解决“恢复数据”中进度条虚假欺骗用户的问题 　　2、在“学生管理”模块中，添加了 多行删除 的功能 　　3、添加了mid格式的登陆背景音乐 　　4、在 “课程添加”模块中 添加了 “开课日期” 数据表并且加入日期选择模块 　　5、加入系统托盘图标显示 　　6、新增“日志管理”模块中添加 “保存日志”功能 　　8、开启及JTable表格自动排序功能 　　9、数据库升级为MySql 　　10、去掉绝大部分无关要痛的图片 　　11、加入初始化数据库功能
Java项目:在线考试平台(java+Springboot+ssm+mysql+maven)
12-02
一、项目简述 功能列表 考试前台 /系统登录：学生、教师、管理员登录 /门户首页：无需认证访问 /在线...项目技术： JSP +SpringBoot + MyBatis + Redis+ Thymeleaf+ Druid+ JQuery + SLF4J+ Fileupload + maven等等
基于JavaWeb+SpringBoot+MySQL+Maven构建房屋租赁系统 租房平台，适合本科毕业设计
06-14
基于SpringBoot实现的租房系统，包括三种角色：管理员、房东、租客。项目经过严格测试，确保可以运行！ #### 管理员功能： - 房屋管理 - 租房类型管理(合租/整租) - 房屋管理 - 订单管理 - 新闻公告管理 - 收支...
java基于springboot教学评价管理系统附源码
豆包程序员
07-26 1554
教学评价管理系统是基于java编程语言，mysql数据库，springboot框架的设计，本系统主要分为学生，管理员，教师，督导四个角色，学生可以注册登陆后，对教师进行评教和打分；8.学生评教管理对学生的评价信息查看，修改，删除，统计。9.督导评教管理对督导的评价信息查看，修改，删除，统计。5.评价管理学生查看评价信息，对评价信息修改，删除。5.学生管理对学生信息进行添加，修改，删除，查询。6.教师管理对教师信息进行添加，修改，查询，删除。7.督导管理对督导信息进行添加，修改，查询，删除。...
计算机毕业设计springboot基于微信小程序的高校评教系统的设计与实现9n6kr9【附源码+数据库+部署+LW】
最新发布
芹心计算机程序设计
08-08 359
选题背景： 高校评教是一项重要的工作，旨在了解学生对教师授课质量和教学效果的评价，为学校改进教学提供参考依据。然而，传统的高校评教方式存在一些问题，如评价结果容易受到个别学生主观因素的影响，评价过程繁琐且耗时，评价结果反馈不及时等。为了解决这些问题，基于微信小程序的高校评教系统应运而生。该系统利用微信小程序平台的便捷性和智能化特点，为学生提供方便、快捷的评教方式，并通过数据分析和反馈机制，为学校提供准确、及时的评教结果，从而促进教学质量的提升。 意义： 基于微信小程序的高校评教系统的设计与实现对于高校教学
Linux+Tomcat+Mysql+JDK环境在JavaWeb搭建教程
本文档主要介绍了如何在Linux系统中进行Java Web环境的搭建，包括Tomcat、MySQL以及JDK的配置。首先，我们将关注Maven的配置，一个常用的项目管理和构建工具，链接提供了一个详细的安装和配置指南...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值