Comprehensive Java SpringBoot Project for Community Management and Epidemic Control with RBAC

Project introduction: This Java SpringBoot project implements community‑based user management and epidemic tracking, using RBAC for role‑user permission control, MySQL, Tomcat, SpringMVC, and various Spring features such as AOP, interceptors, and global exception handling.

1. Login Module (Registration)

Provides user login, registration, password update and related validation logic.

@Service
public class UserService extends BaseService<User,Integer> {
    @Resource
    private UserMapper userMapper;
    @Resource
    private UserRoleMapper userRoleMapper;
    @Resource
    private CommunityMapper communityMapper;

    // User login
    public UserModel userLogin(String userName, String userPwd) {
        checkUserLoginParam(userName, userPwd);
        User temp = userMapper.queryUserByUserName(userName);
        AssertUtil.isTrue(temp == null, "用户不存在");
        checkUserPwd(userPwd, temp.getUserPwd());
        return builderUserInfo(temp);
    }

    // Validate login parameters
    private void checkUserLoginParam(String userName, String userPwd) {
        AssertUtil.isTrue(StringUtils.isBlank(userName), "用户名不能为空");
        AssertUtil.isTrue(StringUtils.isBlank(userPwd), "密码不能为空");
    }

    // Validate password
    private void checkUserPwd(String userPwd, String userPwd1) {
        userPwd = Md5Util.encode(userPwd);
        AssertUtil.isTrue(!(userPwd.equals(userPwd1)), "密码不正确");
    }

    // Build user model
    private UserModel builderUserInfo(User temp) {
        UserModel userModel = new UserModel();
        userModel.setUserIdStr(UserIDBase64.encoderUserID(temp.getId()));
        userModel.setUserName(temp.getUserName());
        userModel.setTrueName(temp.getTrueName());
        return userModel;
    }

    // Additional methods for password update, registration, etc., are defined similarly.
}

2. Daily Epidemic Module

Handles confirmed case data, linking users to communities, and provides pagination and role‑based queries.

@Service
public class ConfirmedService extends BaseService<Confirmed,Integer> {
    @Resource
    private ConfirmedMapper confirmedMapper;
    @Resource
    private UserMapper userMapper;
    @Resource
    private CommunityMapper communityMapper;

    // Paginated role query
    public Map<String,Object> findRoleByParam(ConfirmedQuery confirmedQuery) {
        Map<String,Object> map = new HashMap<>();
        PageHelper.startPage(confirmedQuery.getPage(), confirmedQuery.getLimit());
        PageInfo<Confirmed> rlist = new PageInfo<>(selectByParams(confirmedQuery));
        map.put("code",0);
        map.put("msg","success");
        map.put("count",rlist.getTotal());
        map.put("data",rlist.getList());
        return map;
    }

    // Add confirmed case with transactional handling
    @Transactional(propagation = Propagation.REQUIRED)
    public void addUser(Confirmed user) {
        checkConfirmed(user.getTrueName(), user.getState());
        // Community mapping logic omitted for brevity
        User temp = userMapper.selectByPhone(user.getTcPhone());
        if (temp != null) {
            userMapper.updateUserHealthById(temp.getUserPhone());
            user.setUserId(temp.getId());
        } else {
            User u = new User();
            u.setTrueName(user.getTrueName());
            u.setUserName(user.getTrueName());
            u.setUserPwd(Md5Util.encode("123456"));
            u.setComId(user.getComId());
            u.setUserPhone(user.getTcPhone());
            u.setEcPhone(user.getTcPhone());
            u.setHealth("2");
            u.setCreateDate(new Date());
            u.setUpdateDate(new Date());
            AssertUtil.isTrue(userMapper.insertSelective(u) < 1, "插入用户失败");
            Integer userId = userMapper.selectById(user.getTcPhone());
            user.setUserId(userId);
        }
        user.setCreateDate(new Date());
        AssertUtil.isTrue(insertSelective(user) < 1, "添加失败");
    }

    // Other CRUD methods omitted for brevity.
}

3. Prevention Management Module

Manages community information and vaccination records, offering multi‑condition pagination and CRUD operations.

@Service
public class CommunityService extends BaseService<Community,Integer> {
    @Resource
    private CommunityMapper communityMapper;

    public Map<String,Object> queryComByParams(CommunityQuery query) {
        Map<String,Object> map = new HashMap<>();
        PageHelper.startPage(query.getPage(), query.getLimit());
        PageInfo<Community> pageInfo = new PageInfo<>(communityMapper.selectByParams(query));
        map.put("code",0);
        map.put("msg","");
        map.put("count",pageInfo.getTotal());
        map.put("data",pageInfo.getList());
        return map;
    }

    public List<Map<String,Object>> findRoles(Integer userId) {
        return communityMapper.selectRoles(userId);
    }
}

@Service
public class VaccinationService {
    @Resource
    VaccinationMapper vaccinationMapper;

    public Map<String,Object> selectAll(VaccinationQuery vaccinationQuery) {
        Map<String,Object> map = new HashMap<>();
        PageHelper.startPage(vaccinationQuery.getPage(), vaccinationQuery.getLimit());
        PageInfo<Vaccination> pageInfo = new PageInfo<>(vaccinationMapper.selectByParams(vaccinationQuery));
        map.put("code",0);
        map.put("msg","success");
        map.put("data",pageInfo.getList());
        map.put("count",pageInfo.getTotal());
        return map;
    }

    @Transactional(propagation = Propagation.REQUIRED)
    public void insertVaccination(Vaccination vaccination) {
        checkOK(vaccination);
        vaccination.setFirstDate(new Date());
        vaccination.setSecondDate(new Date());
        AssertUtil.isTrue(vaccinationMapper.insertSelective(vaccination) < 1, "插入失败");
    }

    private void checkOK(Vaccination v) {
        AssertUtil.isTrue(v == null, "请输入添加的角色");
        AssertUtil.isTrue(StringUtils.isBlank(v.getTrueName()), "用户名不能为空");
        AssertUtil.isTrue(StringUtils.isBlank(v.getFirst()), "请填写(是/否)");
        AssertUtil.isTrue(StringUtils.isBlank(v.getSecond()), "请填写(是/否)");
    }

    // Delete and update methods omitted for brevity.
}

4. System Management Module

Provides role management, permission granting, and role‑based resource handling.

@Service
public class RoleService extends BaseService<Role,Integer> {
    @Autowired(required = false)
    RoleMapper roleMapper;
    @Autowired(required = false)
    RoleQuery roleQuery;
    @Resource
    private ModuleMapper moduleMapper;
    @Resource
    private PermissionMapper permissionMapper;

    public Map<String,Object> selectRole(RoleQuery roleQuery) {
        Map<String,Object> map = new HashMap<>();
        PageHelper.startPage(roleQuery.getPage(), roleQuery.getLimit());
        PageInfo<Role> pageInfo = new PageInfo<>(roleMapper.selectByParams(roleQuery));
        map.put("code",0);
        map.put("msg","success");
        map.put("data",pageInfo.getList());
        map.put("count",pageInfo.getTotal());
        return map;
    }

    @Transactional(propagation = Propagation.REQUIRED)
    public void insertRole(Role role) {
        checkRole(role);
        role.setCreateDate(new Date());
        role.setUpdateDate(new Date());
        AssertUtil.isTrue(insertSelective(role) < 1, "添加失败了呢~");
    }

    private void checkRole(Role role) {
        AssertUtil.isTrue(role == null, "请输入角色信息~");
        Role existing = roleMapper.selectByName(role.getRoleName());
        AssertUtil.isTrue(existing != null, "已添加过啦~");
    }

    @Transactional(propagation = Propagation.REQUIRED)
    public void addGrant(Integer[] mids, Integer roleId) {
        AssertUtil.isTrue(roleId == null || roleMapper.selectByPrimaryKey(roleId) == null, "待授权的角色不存在");
        int count = roleMapper.countPermissionByRoleId(roleId);
        if (count > 0) {
            int deleted = roleMapper.deletePermissionsByRoleId(roleId);
            AssertUtil.isTrue(count != deleted, "资源删除失败");
        }
        List<Permission> plist = new ArrayList<>();
        if (mids != null && mids.length != 0) {
            for (Integer mid : mids) {
                Permission p = new Permission();
                p.setRoleId(roleId);
                p.setModuleId(mid);
                p.setAclValue(moduleMapper.selectByPrimaryKey(mid).getOptValue());
                p.setCreateDate(new Date());
                p.setUpdateDate(new Date());
                plist.add(p);
            }
        }
        AssertUtil.isTrue(permissionMapper.insertBatch(plist) != plist.size(), "角色权限更新失败");
    }

    // Update, delete, and other helper methods omitted for brevity.
}

5. User Module

Repeats role service logic for user‑related role management; the code is analogous to the system management module and demonstrates consistent service‑layer design.

Overall, the project showcases a layered architecture with service, mapper, and controller layers, comprehensive RBAC handling, and typical CRUD operations for community, vaccination, and user data.