《Dubbo 实现原理与源码解析 —— 精品合集》 《Netty 实现原理与源码解析 —— 精品合集》
《Spring 实现原理与源码解析 —— 精品合集》 《MyBatis 实现原理与源码解析 —— 精品合集》
《Spring MVC 实现原理与源码解析 —— 精品合集》 《数据库实体设计合集》
《Spring Boot 实现原理与源码解析 —— 精品合集》 《Java 面试题 + Java 学习指南》

摘要: 原创出处 blog.csdn.net/llAl_lAll/article/details/121065156 「每日小新」欢迎转载,保留摘要,谢谢!


🙂🙂🙂关注**微信公众号:【芋道源码】**有福利:

  1. RocketMQ / MyCAT / Sharding-JDBC 所有源码分析文章列表
  2. RocketMQ / MyCAT / Sharding-JDBC 中文注释源码 GitHub 地址
  3. 您对于源码的疑问每条留言将得到认真回复。甚至不知道如何读源码也可以请教噢
  4. 新的源码解析文章实时收到通知。每周更新一篇左右
  5. 认真的源码交流微信群。

项目介绍:通过对依社区为单位进行人群的管理,以及疫苗的情况,包括小区状况,通过RBAC进行角色与用户之间的权限管理。

项目:环境IDEA、Mysql数据库,Tomcat服务器,SpringMVC,SpringBoot,AOP,拦截器,过滤器,全局异常,RBAC权限控制等。

1、登录模块(注册)


核心代码:service层

@Service
public class UserService extends BaseService<User,Integer> {
@Resource
//引入dao层
private UserMapper userMapper;

@Resource
private UserRoleMapper userRoleMapper;

@Resource
private CommunityMapper communityMapper;


//用户登录
public UserModel userLogin(String userName,String userPwd){
//对输入的账号密码进行判断,是否符合格式
checkUserLoginParam(userName,userPwd);

//通过对数据库的查询,查看用户是否存在
User temp = userMapper.queryUserByUserName(userName);
AssertUtil.isTrue(temp == null,"用户不存在");

//判断用户的密码是否正确,拿数据库查询到的用户密码和用户输入的用户密码进行equest比较
checkUserPwd(userPwd,temp.getUserPwd());

//返回目标对象 对密码进行加密
return builderUserInfo(temp);
}


/**
* //对输入的账号密码进行判断 是否符合格式
* @param userName 账号
* @param userPwd 密码
*/
//对输入的账号密码进行判断,是否符合格式
private void checkUserLoginParam(String userName, String userPwd) {
//用户非空
AssertUtil.isTrue(StringUtils.isBlank(userName),"用户名不能为空");

//密码非空
AssertUtil.isTrue(StringUtils.isBlank(userPwd),"密码不能为空");
}



/**
* //判断密码是否正确
* @param userPwd 用户输入的密码
* @param userPwd1 数据库查出来的密码
*/
//判断用户的密码是否正确,拿数据库查询到的用户密码和用户输入的用户密码进行equest比较
private void checkUserPwd(String userPwd, String userPwd1) {
//对用户输入的密码进行加密
userPwd = Md5Util.encode(userPwd);

AssertUtil.isTrue(!(userPwd.equals(userPwd1)),"密码不正确");



}

/**
*
* @param temp 当前登录对象
* @return
*/
//对密码进行加密 返回目标对象
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;

}


/**
*
* @param userId 当前Cookie存储的用户dId
* @param oldPassword 旧密码
* @param newPassword 新密码
* @param confirmPassword 确认密码
*/
//修改密码
@Transactional(propagation = Propagation.REQUIRED)
public void updateUserPassword(Integer userId, String oldPassword, String newPassword, String confirmPassword) {
//通过Id获取user对象
User user = userMapper.selectByPrimaryKey(userId);
//参数校验 (用户,旧密码,新密码,确认密码)
checkPasswordParams(user,oldPassword,newPassword,confirmPassword);

//默认参数设置,把用户输入的新密码 加密 添加进去
user.setUserPwd(Md5Util.encode(newPassword));

//执行更新操作
AssertUtil.isTrue(userMapper.updateByPrimaryKeySelective(user)<1,"修改密码失败");
}


//修改密码的参数校验
private void checkPasswordParams(User user, String oldPassword, String newPassword, String confirmPwd) {
//用户不能为空 (不存在)
AssertUtil.isTrue(null == user,"用户不存在");
//原始密码 非空
System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
AssertUtil.isTrue(StringUtils.isBlank(oldPassword),"原始密码不能为空");
//原始密码是否和数据库查询到的密码一致
AssertUtil.isTrue(!(Md5Util.encode(oldPassword).equals(user.getUserPwd())),"原始密码不正确");
//新密码不能为空
AssertUtil.isTrue(StringUtils.isBlank(newPassword),"新密码不能为空");
//新密码和原始密码不能相同
AssertUtil.isTrue(oldPassword.equals(newPassword),"新密码不能和原始密码相同");
//确认密码非空
AssertUtil.isTrue(StringUtils.isBlank(confirmPwd),"确认密码不能为空");
//确认密码需要和新密码一致
AssertUtil.isTrue(!(newPassword.equals(confirmPwd)),"新密码和确认密码不一致");
}

/**
* 多条件分页查询用户数据
* @param query
* @return
*/
public Map<String, Object> queryUserByParams (UserQuery query) {
Map<String, Object> map = new HashMap<>();
PageHelper.startPage(query.getPage(), query.getLimit());
PageInfo<User> pageInfo = new PageInfo<>(userMapper.selectByParams(query));
map.put("code",0);
map.put("msg", "");
map.put("count", pageInfo.getTotal());
map.put("data", pageInfo.getList());
System.out.println("执行完毕");
return map;
}

/**
* 添加用户
* @param user
*/
@Transactional(propagation = Propagation.REQUIRED)
public void saveUser(User user){
//参数校验
checkParams(user.getUserName(),user.getComId(),user.getVc());
//设置默认参数
user.setCreateDate(new Date());
user.setUpdateDate(new Date());
user.setUserPwd(Md5Util.encode("123456"));
//执行添加,判断结果
AssertUtil.isTrue(userMapper.insertSelective(user)==null,"用户添加失败!");
relaionUserRole(user.getId(),user.getRoleIds());
AssertUtil.isTrue(communityMapper.addNumByComId(user.getComId())<1, "社区用户添加失败");
}

/**
* 用户更新,修改
* @param user
*/
@Transactional(propagation = Propagation.REQUIRED)
public void updateUser(User user){
//1.参数校验
//通过用户id获取用户对象
User temp=userMapper.selectByPrimaryKey(user.getId());
//判断对象是否存在
AssertUtil.isTrue(temp==null,"待更新记录不存在");
//验证参数
checkParams1(user.getUserName(),user.getComId(),user.getVc());
//2.设置默认参数
user.setUpdateDate(new Date());
//3.执行更新,返回结果
AssertUtil.isTrue(userMapper.updateByPrimaryKeySelective(user)<1,"用户更新失败!");
relaionUserRole(user.getId(),user.getRoleIds());
}

private void checkParams(String userName, Integer comId, Integer vc) {
AssertUtil.isTrue(StringUtils.isBlank(userName),"用户名不能为空");
//验证用户是否存在
User temp=userMapper.queryUserByUserName(userName);
AssertUtil.isTrue(temp!=null,"用户名已存在");
AssertUtil.isTrue(comId==null,"请输入所在社区");
AssertUtil.isTrue(vc==null,"请选择疫苗接种状况");
}

private void checkParams1(String userName, Integer comId, Integer vc) {
AssertUtil.isTrue(StringUtils.isBlank(userName),"用户名不能为空");
//验证用户是否存在
AssertUtil.isTrue(comId==null,"请输入所在社区");
AssertUtil.isTrue(vc==null,"请选择疫苗接种状况");
}

@Transactional(propagation = Propagation.REQUIRED)
public void deleteUser(Integer[] ids){
AssertUtil.isTrue(ids==null||ids.length==0,"请选择您要删除的记录");
for (int id:ids){
User user=userMapper.selectByPrimaryKey(id);
AssertUtil.isTrue(communityMapper.subNumByComId(user.getComId())!=ids.length, "社区用户删除失败");
}
AssertUtil.isTrue(deleteBatch(ids) != ids.length,"用户角色删除失败");
}


/*SZC*/
/**
* 用户注册
* @param userName
* @param password1
* @param password2
* @param icon
*/
public void registerUser(String userName, String password1, String password2, String icon) {
// 参数校验
checkRegister(userName, password1, password2, icon);
// 实例化user
User user = new User();
//设置默认参数
user.setUserName(userName);
user.setUserPwd(Md5Util.encode(password1));
user.setUserPhone(icon);
user.setCreateDate(new Date());
user.setUpdateDate(new Date());
// 执行方法
AssertUtil.isTrue(userMapper.insertSelective(user)<1, "用户添加失败");
}

/**
* 用户注册的参数校验
* @param userName
* @param password1
* @param password2
* @param icon
*/
private void checkRegister(String userName, String password1, String password2, String icon) {
// 用户名不为空
AssertUtil.isTrue(StringUtils.isBlank(userName), "请输入用户名");
// 判断用户名是否存在
User user1 = userMapper.selectByName(userName);
AssertUtil.isTrue(user1!=null, "该用户已存在");
// 判断手机号是否存在
User user2 = userMapper.selectByPhone(icon);
AssertUtil.isTrue(user2!=null, "该手机号已注册过账号");
// 密码不为空
AssertUtil.isTrue(StringUtils.isBlank(password1), "请输入密码");
// 确认密码不为空
AssertUtil.isTrue(StringUtils.isBlank(password2), "请输入确认密码");
// 密码长度校验
AssertUtil.isTrue(password1.length()<6 || password1.length()>12, "密码长度为6-12位");
// 密码和确认密码相等
AssertUtil.isTrue(!password1.equals(password2), "确认密码与密码不一致");
// 手机号合法
AssertUtil.isTrue(!PhoneUtil.isMobile(icon), "请输入正确的手机号");
}

/**
* 删除用户原先的角色,并重新赋予新的角色
* @param userId
* @param roleIds
*/
private void relaionUserRole(int userId, String roleIds) {
// 通过id获取用户的角色数量
int count = userRoleMapper.countUserRoleByUserId(userId);
// count>0 说明用户原先有角色 先删除所有的角色
if (count>0) {
AssertUtil.isTrue(userRoleMapper.deleteUserRoleByUserId(userId)!=count, "用户角色删除失败");
}
// 传入的角色信息不为空 添加新的角色
if (StringUtils.isNoneBlank(roleIds)) {
// 将传入的roleIds转成字符串数组
String[] roleStrIds = roleIds.split(",");
// 用来存放用户的角色信息
List<UserRole> roleList = new ArrayList<>();
// 遍历roleIds
for (String rid : roleStrIds) {
// 准备对象
UserRole userRole = new UserRole();
userRole.setUserId(userId);
userRole.setRoleId(Integer.parseInt(rid));
userRole.setCreateDate(new Date());
userRole.setUpdateDate(new Date());
roleList.add(userRole);
}
AssertUtil.isTrue(userRoleMapper.insertBatch(roleList) != roleList.size(), "用户角色分配失败");
}

}

}


2、今日疫情模块



核心代码Service

@Service
public class ConfirmedService extends BaseService<Confirmed,Integer> {

@Resource
//引入ConfirmedMapper
private ConfirmedMapper confirmedMapper;

@Resource
//引入user表
private UserMapper userMapper;

@Resource
//引入user表
private CommunityMapper communityMapper;

//角色的条件查询以及 分页
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());
//返回Map
return map;
}


@Transactional(propagation = Propagation.REQUIRED) //涉及到事务 就需要此注解
//用户模块的添加
public void addUser(Confirmed user) {
//1、参数校验
checkConfirmed(user.getTrueName(),user.getState());

if (user.getComId().equals("浦东区")){
user.setComId(1);
}
if (user.getComId().equals("黄浦区")){
user.setComId(2);
}
if (user.getComId().equals("松江区")){
user.setComId(3);
}
if (user.getComId().equals("徐汇区")){
user.setComId(4);
}
if (user.getComId().equals("虹口区")){
user.setComId(5);
}

//查询user表中是否存在此人 不存在 添加上去 设置默认值
User temp = userMapper.selectByPhone(user.getTcPhone());
// 手机号查询用户
if (temp != null){
//健康状态改成2 如果user表里面已经有了的情况下
userMapper.updateUserHealthById(temp.getUserPhone());
//默认值 确诊表中的userId字段
user.setUserId(temp.getId());

}else { //表里没有这个人的时候 添加 这个用户 新建一个user对象
User u = new User();
//真实姓名
u.setTrueName(user.getTrueName());
//名字
u.setUserName(user.getTrueName());
//设置密码 默认值 :123456
u.setUserPwd(Md5Util.encode("123456"));

//设置社区ID
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,"插入用户失败");

//给确诊人员添加其 userId
Integer userId = userMapper.selectById(user.getTcPhone());
user.setUserId(userId);
}

//2、默认值设置
//确诊日期
user.setCreateDate(new Date());

//添加是否成功
AssertUtil.isTrue(insertSelective(user)<1,"添加失败");

//relaionUserRole(user.getId(),user.getComId());


}


@Transactional(propagation = Propagation.REQUIRED) //涉及到事务 就需要此注解
//用户模块的修改
public void changeUser(Confirmed user) {
//通过id获取用户信息
Confirmed temp = confirmedMapper.selectByPrimaryKey(user.getId());
//判断用户信息是否存在
AssertUtil.isTrue(temp == null,"当前用户不存在");

//校验参数
changeConfirmed(user.getTrueName(),user.getTcPhone(),user.getState());

//修改是否成功 完整版
//AssertUtil.isTrue(updateByPrimaryKeySelective(user)<1,"修改失败了");


//修改是否成功 完整版
AssertUtil.isTrue(confirmedMapper.uBPKS(user)<1,"修改失败了");

}

//修改的参数校验
private void changeConfirmed(String trueName, String tcPhone, Integer state) {
//1、用户名不能为空
AssertUtil.isTrue(StringUtils.isBlank(trueName),"姓名不能为空");
//2、当前状态不能为空
AssertUtil.isTrue(StringUtils.isBlank(tcPhone),"请输入手机号");
//3、当前状态不能为空
AssertUtil.isTrue(state<1 || state>4,"请选择正确的状态码");
}

//用户模块的添加的参数校验
private void checkConfirmed(String trueName, Integer state) {
//1、用户名不能为空
AssertUtil.isTrue(StringUtils.isBlank(trueName),"姓名不能为空");
//2、当前状态不能为空
AssertUtil.isTrue(state<1 || state>3,"请选择正确的状态码");
}

//添加社区时的校验
private void relaionUserRole(Integer id, Integer comId) {
//准备集合 存储对象
List<Community> urlist = new ArrayList<>();

//userId,roleId
//判断是否选择了角色信息

//只能选择一个社区
AssertUtil.isTrue(comId>1 || comId<1,"只能选择一个社区");

//通过社区表的 com_id 查询到社区表的对应社区名
communityMapper.selectaddresComId(comId);
//添加

}

@Transactional(propagation = Propagation.REQUIRED) //涉及到事务 就需要此注解
//确诊人员的批量删除
public void deleteUserByIds(Integer[] ids) {
//要删除记录不能为空
AssertUtil.isTrue(ids == null || ids.length==0,"请选择要删除的记录");

//修改user表的状态码
for(Integer id: ids){
Confirmed confirmed = confirmedMapper.selectId(id);
System.out.println(id+ " -----------------" );
System.out.println(confirmed.getTrueName());
AssertUtil.isTrue(userMapper.updateById(confirmed.getUserId())<1,"修改失败");
}

//删除确诊表的个人信息记录
AssertUtil.isTrue(deleteBatch(ids)!=ids.length,"删除失败");
}

//查询所有社区
public List<Map<String, Object>> queryComs() {
return confirmedMapper.selectComs();
}

}

3、防疫管理模块



核心代码Service:

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

/**
* 多条件分页查询
* @param query
* @return
*/
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
Map<String,Object> map =new HashMap<String,Object>();
//查数据并分页
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;
}
/*通过ID获取对象*/
public Vaccination selectId(Integer id) {
return vaccinationMapper.selectById(id);
}

/*添加*/
@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 vaccinatio){
AssertUtil.isTrue(vaccinatio==null,"请输入添加的角色");
AssertUtil.isTrue(StringUtils.isBlank(vaccinatio.getTrueName()),"用户名不能为空");
AssertUtil.isTrue(StringUtils.isBlank(vaccinatio.getFirst()),"请填写(是/否)");
AssertUtil.isTrue(StringUtils.isBlank(vaccinatio.getSecond()),"请填写(是/否)");
}

/*删除*/
public void delete(Integer[] ids) {
AssertUtil.isTrue(ids==null||ids.length==0,"请选择要删除的用户");
AssertUtil.isTrue(vaccinationMapper.deleteVa(ids)!=ids.length,"删除失败~~~");
}

/*编辑*/
public void updateVa(Vaccination vaccination) {
checkOK(vaccination);
if(vaccination.getFirst()==null||"否".equals(vaccination.getFirst())){
vaccination.setFirstDate(null);
}
if(vaccination.getSecond()==null||"否".equals(vaccination.getSecond())){
vaccination.setSecondDate(null);
}
if("是".equals(vaccination.getFirst())){
vaccination.setFirstDate(new Date());
}
if("是".equals(vaccination.getSecond())){
vaccination.setSecondDate(new Date());
}
AssertUtil.isTrue(vaccinationMapper.updateByPrimaryKeySelective(vaccination)<1,"修改失败~");

}
}

4、系统管理模块



核心代码:Service:

@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
Map<String,Object> map =new HashMap<String,Object>();
//查数据并分页
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());
System.out.println("就差一点!!!!");
AssertUtil.isTrue(insertSelective(role)<1,"添加失败了呢~");
}
private void checkRole(Role role) {
//是否为空
AssertUtil.isTrue(role==null,"请输入角色信息~");
//判断是否已经重复
System.out.println("判断");
Role role1= roleMapper.selectByName(role.getRoleName());
System.out.println("判断结束");
System.out.println(role1!=null);
AssertUtil.isTrue(role1!=null,"已添加过啦~");
System.out.println("退出@");
}
/*编辑角色*/
@Transactional(propagation = Propagation.REQUIRED)
public void updateRole(Role role) {
role.setUpdateDate(new Date());
AssertUtil.isTrue(updateByPrimaryKeySelective(role)<1,"编辑失败啦~");
}

/**
* 删除角色信息
* @param role
*/
@Transactional(propagation = Propagation.REQUIRED)
public void deleteRole(Role role) {
// 验证
AssertUtil.isTrue(role.getId()==null || selectByPrimaryKey(role.getId())==null, "待删除角色不存在");
// 设定默认值
role.setUpdateDate(new Date());
// 删除角色绑定的权限资源
int count = roleMapper.countPermissionByRoleId(role.getId());
if (count>0) {
int i = roleMapper.deletePermissionsByRoleId(role.getId());
AssertUtil.isTrue(i!=count, "角色绑定的权限资源删除失败");
}
// 判断是否成功
AssertUtil.isTrue(roleMapper.updateRoleById(role.getId())<1, "角色删除失败");
}

/**
* 查询所有角色
* @return
*/
public List<Map<String, Object>> seleceAllRole(Integer userId) {
return roleMapper.seleceAllRole(userId);
}

/**
* 给角色添加权限
* @param mids
* @param roleId
*/
@Transactional(propagation = Propagation.REQUIRED)
public void addGrant(Integer[] mids, Integer roleId) {
// 判断roleId是否存在
AssertUtil.isTrue(roleId==null || roleMapper.selectByPrimaryKey(roleId)==null, "待授权的角色不存在");
// 统计当前角色的权限资源数量
int count = roleMapper.countPermissionByRoleId(roleId);
if (count>0) {
// 如果角色存在权限资源,就全部删除
int num = roleMapper.deletePermissionsByRoleId(roleId);
AssertUtil.isTrue(count!=num, "资源删除失败");
}
List<Permission> plist = new ArrayList<>();
if (mids!=null && mids.length!=0) {
// 遍历mids
for (Integer mid : mids) {
// 实例化对象
Permission permission = new Permission();
// 设置数据
permission.setRoleId(roleId);
permission.setModuleId(mid);
// 权限码
permission.setAclValue(moduleMapper.selectByPrimaryKey(mid).getOptValue());
permission.setCreateDate(new Date());
permission.setUpdateDate(new Date());
// 添加到list
plist.add(permission);
}
}
AssertUtil.isTrue(permissionMapper.insertBatch(plist)!=plist.size(), "角色权限更新失败");
}
}

5、用户模块



核心代码Service:

@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
Map<String,Object> map =new HashMap<String,Object>();
//查数据并分页
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());
System.out.println("就差一点!!!!");
AssertUtil.isTrue(insertSelective(role)<1,"添加失败了呢~");
}
private void checkRole(Role role) {
//是否为空
AssertUtil.isTrue(role==null,"请输入角色信息~");
//判断是否已经重复
System.out.println("判断");
Role role1= roleMapper.selectByName(role.getRoleName());
System.out.println("判断结束");
System.out.println(role1!=null);
AssertUtil.isTrue(role1!=null,"已添加过啦~");
System.out.println("退出@");
}
/*编辑角色*/
@Transactional(propagation = Propagation.REQUIRED)
public void updateRole(Role role) {
role.setUpdateDate(new Date());
AssertUtil.isTrue(updateByPrimaryKeySelective(role)<1,"编辑失败啦~");
}

/**
* 删除角色信息
* @param role
*/
@Transactional(propagation = Propagation.REQUIRED)
public void deleteRole(Role role) {
// 验证
AssertUtil.isTrue(role.getId()==null || selectByPrimaryKey(role.getId())==null, "待删除角色不存在");
// 设定默认值
role.setUpdateDate(new Date());
// 删除角色绑定的权限资源
int count = roleMapper.countPermissionByRoleId(role.getId());
if (count>0) {
int i = roleMapper.deletePermissionsByRoleId(role.getId());
AssertUtil.isTrue(i!=count, "角色绑定的权限资源删除失败");
}
// 判断是否成功
AssertUtil.isTrue(roleMapper.updateRoleById(role.getId())<1, "角色删除失败");
}

/**
* 查询所有角色
* @return
*/
public List<Map<String, Object>> seleceAllRole(Integer userId) {
return roleMapper.seleceAllRole(userId);
}

/**
* 给角色添加权限
* @param mids
* @param roleId
*/
@Transactional(propagation = Propagation.REQUIRED)
public void addGrant(Integer[] mids, Integer roleId) {
// 判断roleId是否存在
AssertUtil.isTrue(roleId==null || roleMapper.selectByPrimaryKey(roleId)==null, "待授权的角色不存在");
// 统计当前角色的权限资源数量
int count = roleMapper.countPermissionByRoleId(roleId);
if (count>0) {
// 如果角色存在权限资源,就全部删除
int num = roleMapper.deletePermissionsByRoleId(roleId);
AssertUtil.isTrue(count!=num, "资源删除失败");
}
List<Permission> plist = new ArrayList<>();
if (mids!=null && mids.length!=0) {
// 遍历mids
for (Integer mid : mids) {
// 实例化对象
Permission permission = new Permission();
// 设置数据
permission.setRoleId(roleId);
permission.setModuleId(mid);
// 权限码
permission.setAclValue(moduleMapper.selectByPrimaryKey(mid).getOptValue());
permission.setCreateDate(new Date());
permission.setUpdateDate(new Date());
// 添加到list
plist.add(permission);
}
}
AssertUtil.isTrue(permissionMapper.insertBatch(plist)!=plist.size(), "角色权限更新失败");
}
}

文章目录
  1. 1. 1、登录模块(注册)
  2. 2. 2、今日疫情模块
  3. 3. 3、防疫管理模块
  4. 4. 4、系统管理模块
  5. 5. 5、用户模块