Java源码社

基于javaweb的SpringBoot校友交流平台校园论坛(java+springboot+vue+maven+mysql+redis)

更新于

运行环境

Java≥8、MySQL≥5.7、Node.js≥14

开发工具

后端：eclipse/idea/myeclipse/sts等均可配置运行
前端：WebStorm/VSCode/HBuilderX等均可

❗没学过node.js的不要搞前后端分离项目

适用

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

功能说明

431324560701

441324560701

451324560701

461324560701

471324560701

481324560701

基于javaweb的SpringBoot校友交流平台校园论坛(java+springboot+vue+maven+mysql+redis)

1
2
3
4
5
6
后台管理员：
100000000@qq.com    123456

前台用户（注册）：
200000001@qq.com    123456
200000002@qq.com    123456

一、项目简述

用户角色：管理员、用户

功能介绍：

登录、公告管理、轮播图管理、地区管理、学院管理、组织管理、标签管理、用户管理、内推管理、帖子管理、添加帖子、帖子信息、问题管理、动态管理、关于作者

二、项目运行

环境配置： Jdk1.8 + mysql + Eclispe（IntelliJ IDEA,Eclispe,MyEclispe,Sts都支持）

项目技术： Springboot + VUE + ElementUI + maven等等。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
        BeanUtils.copyProperties(getQuestionByPageRequest, workPageQuery);
        Map<String, Object> map = questionService.getQuestionByPage(workPageQuery);
        return ResultUtils.success(map);
    }

    /**
     * 根据id查询问题
     */
    @GetMapping("/getQuestionInfoById/{id}")
    public BaseResponse<QuestionVO> getQuestionInfoById(@PathVariable Long id) {
        if (id == null || id < CommonConstant.MIN_ID) {
            log.error("参数校验失败,该参数为：{}", GsonUtil.toJson(id));
            throw new BusinessException(ErrorCode.PARAMS_ERROR);
        }
        QuestionVO questionInfoById = questionService.getQuestionInfoById(id);
        return ResultUtils.success(questionInfoById);
    }

}



/**
 * @Auther: gali
 * @Description:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
    QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
    userQueryWrapper.eq("id", user.getId());
    Long count = userMapper.selectCount(userQueryWrapper);
    if (count == OperationConstant.COUNT_NUM) {
        log.warn("该用户不存在，该参数为：{}", GsonUtil.toJson(user));
        throw new BusinessException(ErrorCode.NO_EXISTED_USER);
    }
    QueryWrapper<UserInfo> userInfoQueryWrapper = new QueryWrapper<>();
    userInfoQueryWrapper.eq("id", user.getId());
    Long userInfoCount = userInfoMapper.selectCount(userInfoQueryWrapper);
    if (userInfoCount == OperationConstant.COUNT_NUM) {
        log.warn("该用户不存在，该参数为：{}", GsonUtil.toJson(userInfo));
        throw new BusinessException(ErrorCode.NO_EXISTED_USER);
    }
    int operationNum = userMapper.updateById(user);
    if (operationNum == OperationConstant.OPERATION_NUM) {
        log.warn("更新用户基本信息失败,该用户参数为:{}", GsonUtil.toJson(user));
        throw new BusinessException(ErrorCode.UPDATE_ERROR);
    }
    int userInfoOperationNum = userInfoMapper.updateById(userInfo);
    if (userInfoOperationNum == OperationConstant.OPERATION_NUM) {
        log.warn("更新用户详细信息失败,该用户参数为:{}", GsonUtil.toJson(userInfo));
        throw new BusinessException(ErrorCode.UPDATE_ERROR);
    }
    return Boolean.TRUE;
}

@Override
public Map<String, Object> getUserByPage(GetUserByPageQuery getUserByPageQuery) {
    Page<UserVO> page = new Page<>(getUserByPageQuery.getPageNum(), getUserByPageQuery.getPageSize());
    IPage<UserVO> result = userMapper.selectUserByPage(page, getUserByPageQuery);
    List<UserVO> records = result.getRecords();
    if (StringUtils.isNotBlank(getUserByPageQuery.getUserName())) {
        records = records.stream().filter(item -> item.getUserName().contains(getUserByPageQuery.getUserName())).collect(Collectors.toList());
    }
    if (getUserByPageQuery.getCollegeId() != null) {
        records = records.stream().filter(item -> item.getCollegeId().equals(getUserByPageQuery.getCollegeId())).collect(Collectors.toList());
    }
    if (getUserByPageQuery.getRegionId() != null) {
        records = records.stream().filter(item -> item.getRegionId().equals(getUserByPageQuery.getRegionId())).collect(Collectors.toList());
    }
    records.forEach(item -> {
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
     */
    @GetMapping("/getQuestionInfoById/{id}")
    public BaseResponse<QuestionVO> getQuestionInfoById(@PathVariable Long id) {
        if (id == null || id < CommonConstant.MIN_ID) {
            log.error("参数校验失败,该参数为：{}", GsonUtil.toJson(id));
            throw new BusinessException(ErrorCode.PARAMS_ERROR);
        }
        QuestionVO questionInfoById = questionService.getQuestionInfoById(id);
        return ResultUtils.success(questionInfoById);
    }

}



/**
 * @Auther: gali
 * @Description:
 */
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

/**
 * 更新问题及审核
 */
@PostMapping("/updateQuestion")
public BaseResponse<Boolean> updateQuestion(@RequestBody QuestionUpdateRequest questionUpdateRequest) {
    if (questionUpdateRequest.getId() < CommonConstant.MIN_ID ||
            questionUpdateRequest.getTid() < CommonConstant.MIN_ID) {
        log.error("参数校验失败，该参数为：{}", GsonUtil.toJson(questionUpdateRequest));
        throw new BusinessException(ErrorCode.PARAMS_ERROR);
    }
    if (questionUpdateRequest.getIsAudit() < AuditEnum.AUDITING.getType() ||
            questionUpdateRequest.getIsAudit() > AuditEnum.AUDIT_REFUSE.getType()) {
        log.error("参数校验失败,该参数为：{}", GsonUtil.toJson(questionUpdateRequest));
        throw new BusinessException(ErrorCode.PARAMS_ERROR);
    }
    Question question = new Question();
    BeanUtils.copyProperties(questionUpdateRequest, question);
    Boolean isSuccess = questionService.updateQuestion(question);
    return ResultUtils.success(isSuccess);
}

/**
 * 删除问题
 */
@DeleteMapping("/deleteQuestion")
public BaseResponse<Boolean> deleteQuestion(@RequestBody QuestionDeleteRequest questionDeleteRequest) {
    questionDeleteRequest.getIds().forEach(item -> {
        if (item < CommonConstant.MIN_ID) {
            log.error("参数校验失败，该参数为：{}", GsonUtil.toJson(item));
            throw new BusinessException(ErrorCode.PARAMS_ERROR);
        }
    });
    Boolean isSuccess = questionService.deleteQuestion(questionDeleteRequest.getIds());
    return ResultUtils.success(isSuccess);
}

/**
 * 分页查询问题
 */
@PostMapping("/getQuestionByPage")
public BaseResponse<Map<String, Object>> getQuestionByPage(@RequestBody GetQuestionByPageRequest getQuestionByPageRequest) {
    if (getQuestionByPageRequest.getPageNum() < CommonConstant.MIN_PAGE_NUM ||
            getQuestionByPageRequest.getPageSize() < CommonConstant.MIN_PAGE_SIZE) {
        log.error("参数校验失败，该参数为：{}", GsonUtil.toJson(getQuestionByPageRequest));
        throw new BusinessException(ErrorCode.PARAMS_ERROR);
    }
    GetQuestionByPageQuery workPageQuery = new GetQuestionByPageQuery();
    BeanUtils.copyProperties(getQuestionByPageRequest, workPageQuery);
    Map<String, Object> map = questionService.getQuestionByPage(workPageQuery);
    return ResultUtils.success(map);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
    BeanUtils.copyProperties(discussUpdateRequest, discuss);
    boolean isSuccess = discussService.updateDiscuss(discuss);
    return ResultUtils.success(isSuccess);
}

/**
 * 删除讨论
 */
@DeleteMapping("/deleteDiscuss")
public BaseResponse<Boolean> deleteDiscuss(@RequestBody DiscussDeleteRequest discussDeleteRequest) {
    discussDeleteRequest.getIds().forEach(item -> {
        if (item < CommonConstant.MIN_ID) {
            log.error("参数校验失败,该参数为：{}", GsonUtil.toJson(item));
            throw new BusinessException(ErrorCode.PARAMS_ERROR);
        }
    });
    boolean isSuccess = discussService.deleteDiscuss(discussDeleteRequest.getIds());
    return ResultUtils.success(isSuccess);
}

/**
 * 点赞相关
 */
@PostMapping("/upOrDownAction")
public BaseResponse<Boolean> upOrDownAction(@RequestBody DiscussUpOrDownRequest discussUpOrDownRequest) {
    if (discussUpOrDownRequest.getId() < CommonConstant.MIN_ID) {
        log.error("参数校验失败,该参数为：{}", GsonUtil.toJson(discussUpOrDownRequest));
        throw new BusinessException(ErrorCode.PARAMS_ERROR);
    }
    if (StringUtils.isBlank(discussUpOrDownRequest.getFlag())) {
        log.error("参数校验失败,该参数为：{}", GsonUtil.toJson(discussUpOrDownRequest));
        throw new BusinessException(ErrorCode.PARAMS_ERROR);
    }
    if ((discussUpOrDownRequest.getUid() == null)) {
        log.error("参数校验失败,该参数为：{}", GsonUtil.toJson(discussUpOrDownRequest));
        throw new BusinessException(ErrorCode.PARAMS_ERROR);
    }
    Discuss discuss = new Discuss();
    BeanUtils.copyProperties(discussUpOrDownRequest, discuss);
    boolean isSuccess = discussService.upOrDownAction(discuss, discussUpOrDownRequest.getFlag());
    return ResultUtils.success(isSuccess);
}

/**
 * 分页获取文章信息
 */
@PostMapping("/getDiscussByPageOrParam")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46


/**
 * @Auther: gali
 * @Description:
 */
@RestController
@RequestMapping("/discuss")
@Slf4j
public class DiscussController {

    @Resource
    private DiscussService discussService;

    /**
     * 增加讨论
     */
    @PostMapping("/addDiscuss")
    public BaseResponse<Boolean> addDiscuss(@RequestBody DiscussAddRequest discussAddRequest) {
        if (discussAddRequest.getUid() < CommonConstant.MIN_ID ||
                discussAddRequest.getTid() < CommonConstant.MIN_ID) {
            log.error("参数校验失败,该参数为：{}", GsonUtil.toJson(discussAddRequest));
            throw new BusinessException(ErrorCode.PARAMS_ERROR);
        }
        if (StringUtils.isBlank(discussAddRequest.getTitle()) ||
                StringUtils.isBlank(discussAddRequest.getCover()) ||
                StringUtils.isBlank(discussAddRequest.getMessage())) {
            log.error("参数校验失败,该参数为：{}", GsonUtil.toJson(discussAddRequest));
            throw new BusinessException(ErrorCode.PARAMS_ERROR);
        }
        if (discussAddRequest.getTitle().length() > CommonConstant.TITLE_MAX_LENGTH ||
                discussAddRequest.getMessage().length() < CommonConstant.CONTENT_MIN_LENGTH) {
            log.error("参数校验失败，该参数为：{}", GsonUtil.toJson(discussAddRequest));
            throw new BusinessException(ErrorCode.PARAMS_ERROR);
        }
        Discuss discuss = new Discuss();
        BeanUtils.copyProperties(discussAddRequest, discuss);
        boolean isSuccess = discussService.addDiscuss(discuss);
        return ResultUtils.success(isSuccess);
    }

    /**
     * 更新讨论
     */
    @PostMapping("/updateDiscuss")
    public BaseResponse<Boolean> updateDiscuss(@RequestBody DiscussUpdateRequest discussUpdateRequest) {

项目链接：
https://javayms.github.io?id=441524180701201ix
https://javayms.pages.dev?id=441524180701201ix