Java源码社

基于javaweb的SpringBoot社团管理系统(java+springboot+vue+maven+layui+elementui+mysql)

更新于

运行环境

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

开发工具

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

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

适用

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

功能说明

451424050701

461424050701

471424050701

481424050701

501424050701

511424050701

521424050701

531424050701

541424050701

基于javaweb的SpringBoot社团管理系统(java+springboot+vue+maven+layui+elementui+mysql)

角色：管理员、社长、社团成员

1.管理员可以完成几乎全部的操作，包括系统用户、社团信息、社团类型等管理工作

2.社长可以完成社团活动、社团通知等社团日常管理工作

3.社团成员可以申请社团，也可以进行活动报名、查看费用记录等操作

使用人群：
正在做毕设的学生，或者需要项目实战练习的Java学习者

由于本程序规模不大，可供课程设计，毕业设计学习演示之用

技术栈
后端： SpringBoot+Mybaits

前端：layui +Vue +ELementUI 

1
2
3
4
5
6
7
8
9
管理员用户名密码：admin/admin
社团团长用户名密码：123/123456
社团成员用户名密码：zs/123456



后端启动类：StartApplication
前端启动命令：npm run serve

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
public R getInfo(String id) {

    Log.info("查找指定成员信息，ID：{}", id);

    Members members = membersService.getOne(id);

    return R.successData(members);
}

@GetMapping("/page")
@ResponseBody
public R getPageInfos(Long pageIndex, Long pageSize,
                      String token, String teamName, String userName) {

    Users user = usersService.getOne(cacheHandle.getUserInfoCache(token));

    if (user.getType() == 0) {

        Log.info("分页查找成员信息，当前页码：{}，"
                        + "每页数据量：{}, 模糊查询，团队名称：{}，用户姓名：{}", pageIndex,
                pageSize, teamName, userName);

        PageData page = membersService.getPageAll(pageIndex, pageSize, teamName, userName);

        return R.successData(page);
    } else {

        Log.info("分页查找成员信息，当前页码：{}，"
                        + "每页数据量：{}, 模糊查询，团队名称：{}，用户姓名：{}", pageIndex,
                pageSize, teamName, userName);

        PageData page = membersService.getPageByManId(pageIndex, pageSize, user.getId(), teamName, userName);

        return R.successData(page);
    }
}


@PostMapping("/add")
@ResponseBody
public R addInfo(Members members) {

    members.setId(IDUtils.makeIDByCurrent());

    Log.info("添加成员信息，传入参数：{}", members);

    membersService.add(members);

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
/**
 * 系统请求响应控制器
 * 社团信息
 */
@Controller
@RequestMapping("/teams")
public class TeamsController extends BaseController {

    protected static final Logger Log = LoggerFactory.getLogger(TeamsController.class);

    @Autowired
    private CacheHandle cacheHandle;

    @Autowired
    private UsersService usersService;

    @Autowired
    private TeamsService teamsService;

    @RequestMapping("")
    public String index() {

        return "pages/Teams";
    }

    @GetMapping("/info")
    @ResponseBody
    public R getInfo(String id) {

        Log.info("查找指定社团信息，ID：{}", id);

        Teams teams = teamsService.getOne(id);

        return R.successData(teams);
    }

    @GetMapping("/all")
    @ResponseBody
    public R getAll(){

        Log.info("获取全部的社团");

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
    Log.info("获取指定社团管理员相关的社团列表");

    List<Teams> list = teamsService.getListByManId(manId);

    return R.successData(list);
}

@GetMapping("/page")
@ResponseBody
public R getPageInfos(Long pageIndex, Long pageSize,
                     String token, Teams teams) {

    Users user = usersService.getOne(cacheHandle.getUserInfoCache(token));

    if(user.getType() == 1){

        teams.setManager(user.getId());
    }

    Log.info("分页查找社团信息，当前页码：{}，"
                    + "每页数据量：{}, 模糊查询，附加参数：{}", pageIndex,
            pageSize, teams);

    PageData page = teamsService.getPageInfo(pageIndex, pageSize, teams);

    return R.successData(page);
}

@PostMapping("/add")
@ResponseBody
public R addInfo(Teams teams) {

    teams.setId(IDUtils.makeIDByCurrent());
    teams.setCreateTime(DateUtils.getNowDate("yyyy-MM-dd"));

    Log.info("添加社团信息，传入参数：{}", teams);

    teamsService.add(teams);

    return R.success();
}

@PostMapping("/upd")
@ResponseBody
public R updInfo(Teams teams) {
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
52
53

            List<Notices> list = noticesService.getMemNotices(user.getId());

            return R.successData(list);
        }
    }

    // 生成验证码
    @GetMapping("/getVerifyCodeImage")
    @ResponseBody
    public String getImageCode(HttpServletRequest request) throws IOException {
// 1. 使用工具类生成验证码

       String code = VerifyCodeUtils.generateVerifyCode(4);
        validate_code = code; // 存放生成的验证码
// 2. 将验证码放入ServletContext作用域
        request.getServletContext().setAttribute("code", code);
// 3. 将图片转换成base64格式
// 字节数组输出流在内存中创建一个字节数组缓冲区，所有发送到输出流的数据保存在该字节数组缓冲区中
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
//将得到的验证码，使用工具类生成验证码图片，并放入到字节数组缓存区
        VerifyCodeUtils.outputImage(220, 60, byteArrayOutputStream, code);
//使用spring提供的工具类，将字节缓存数组中的验证码图片流转换成Base64的形式
//并返回给浏览器
        return "data:image/png;base64," + Base64Utils.encodeToString(byteArrayOutputStream.toByteArray());
    }
    @PostMapping("/login")
    @ResponseBody
    public R login(String userName, String passWord,String verifyCode ,HttpSession session){

        Log.info("用户登录，用户名：{}， 用户密码：{}", userName, passWord);
        if(!verifyCode.equalsIgnoreCase(validate_code)){
            return R.error("验证码错误");
        }

        Users user = usersService.getUserByUserName(userName);



        if(user == null) {

            return R.error("输入的用户名不存在");
        }else {

            if(passWord.equals(user.getPassWord().trim())) {


                String token = IDUtils.makeIDByUUID();
                cacheHandle.addUserCache(token, user.getId());

                return R.success("登录成功", token);
            }else {

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
    return R.success();
}

@GetMapping("/info")
@ResponseBody
public R info(String token){

    Users user = usersService.getOne(cacheHandle.getUserInfoCache(token));

    return R.successData(user);
}

@PostMapping("/info")
@ResponseBody
public R info(Users user){

    Log.info("修改用户信息，{}", user);

    usersService.update(user);

    return R.success();
}

@RequestMapping("/checkPwd")
@ResponseBody
public R checkPwd(String oldPwd, String token) {

    Users user = usersService.getOne(cacheHandle.getUserInfoCache(token));

    if(oldPwd.equals(user.getPassWord())) {

        return R.success();
    }else {

        return R.warn("原始密码和输入密码不一致");
    }
}

@PostMapping("/pwd")
@ResponseBody
public R pwd(String token, String password) {
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
    Users user = usersService.getOne(cacheHandle.getUserInfoCache(token));

    if (user.getType() == 0) {

        Log.info("分页查看全部申请记录，当前页码：{}，"
                        + "每页数据量：{}, 模糊查询，团队名称：{}，用户姓名：{}", pageIndex,
                pageSize, teamName, userName);

        PageData page = applyLogsService.getPageInfo(pageIndex, pageSize, null, teamName, userName);

        return R.successData(page);

    } else if (user.getType() == 1) {

        Log.info("团队管理员查看申请记录，当前页码：{}，"
                        + "每页数据量：{}, 模糊查询，团队名称：{}，用户姓名：{}", pageIndex,
                pageSize, teamName, userName);

        PageData page = applyLogsService.getManPageInfo(pageIndex, pageSize, user.getId(), teamName, userName);

        return R.successData(page);

    } else {

        Log.info("分页用户相关申请记录，当前页码：{}，"
                        + "每页数据量：{}, 模糊查询，团队名称：{}，用户姓名：{}", pageIndex,
                pageSize, teamName, userName);

        PageData page = applyLogsService.getPageInfo(pageIndex, pageSize, user.getId(), teamName, null);

        return R.successData(page);
    }
}

@PostMapping("/add")
@ResponseBody
public R addInfo(String token, ApplyLogs applyLogs) {

    Users user = usersService.getOne(cacheHandle.getUserInfoCache(token));

    if(applyLogsService.isApply(user.getId(), applyLogs.getTeamId())){

        applyLogs.setId(IDUtils.makeIDByCurrent());
        applyLogs.setUserId(user.getId());
        applyLogs.setCreateTime(DateUtils.getNowDate());

        Log.info("添加申请记录，传入参数：{}", applyLogs);

        applyLogsService.add(applyLogs);

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