Java 实战项目之疫情防控管理系统详解-eolink官网

Java 实战项目之疫情防控管理系统详解

目录☣基于java疫情防控管理系统1、登录模块(注册）2、今日疫情模块3、防疫管理模块4、系统管理模块5、用户模块

☣基于java疫情防控管理系统

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

☣项目：环境-IDEA、mysql数据库，Tomcat服务器，SpringMVC，SpringBoot，AOP，拦截器，过滤器，全局异常，RBAC权限控制等。

1、登录模块(注册）

核心代码：service层

@Service

public class UserService extends BaseService {

@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 queryUserByParams (UserQuery query) {

Map map = new HashMap<>();

PageHelper.startPage(query.getPage(), query.getLimit());

PageInfo 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 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 {

@Resource

//引入ConfirmedMapper

private ConfirmedMapper confirmedMapper;

@Resource

//引入user表

private UserMapper userMapper;

@Resource

//引入user表

private CommunityMapper communityMapper;

//角色的条件查询以及分页

public Map findRoleByParam(ConfirmedQuery confirmedQuery){

//实例化对象

Map map = new HashMap<>();

//实例化分页单位

PageHelper.startPage(confirmedQuery.getPage(), confirmedQuery.getLimit());

//开始分页

PageInfo 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,"请选择正确的状态http://码");

}

//添加社区时的校验

private void relaionUserRole(Integer id, Integer comId) {

//准备集合存储对象

List 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> queryComs() {

return confirmedMapper.selectComs();

}

3、防疫管理模块

核心代码Service:

@Service

public class CommunityService extends BaseService {

@Resource

private CommunityMapper communityMapper;

/**

* 多条件分页查询

* @param query

* @return

public Map queryComByParams(CommunityQuery query){

Map map=new HashMap<>();

//初始化分页

PageHelper.startPage(query.getPage(), query.getLimit());

//开始分页

PageInfo 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> findRoles(Integer userId) {

return communityMapper.selectRoles(userId);

}

//============================================================

@Service

public class VaccinationService {

@Resource

VaccinationMapper vaccinationMapper;

/*多条件查询*/

public Map selectAll(VaccinationQuery vaccinationQuery) {

//创建map

Map map =new HashMap();

//查数据并分页

PageHelper.startPage(vaccinationQuery.getPage(),vaccinationQuery.getLimit());

PageInfo 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 {

@Autowired(required = false)

RoleMapper roleMapper;

@Autowired(required = false)

RoleQuery roleQuery;

@Resource

private ModuleMapper moduleMapper;

@Resource

private PermissionMapper permissionMapper;

/*多条件查询*/

public Map selectRole(RoleQuery roleQuery){

//创建map

Map map =new HashMap();

//查数据并分页

PageHelper.startPage(roleQuery.getPage(),roleQuery.getLimit());

PageInfo 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.setUphttp://dateDate(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> 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 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(), "vdgpok角色权限更新失败");

}

5、用户模块

核心代码Service:

@Service

public class RoleService extends BaseService {

@Autowired(required = false)

RoleMapper roleMapper;

@Autowired(required = false)

RoleQuery roleQuery;

@Resource

private ModuleMapper moduleMapper;

@Resource

private PermissionMapper permissionMapper;

/*多条件查询*/

public Map selectRole(RoleQuery roleQuery){

//创建map

Map map =new HashMap();

//查数据并分页

PageHelper.startPage(roleQuery.getPage(),roleQuery.getLimit());

PageInfo 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> 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 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(), "角色权限更新失败");

}

大概就是这样，管理系统，基本都差不多，比如图书管理，CRM等，详细源码见文件上传~

Python接口自动化之文件上传/下载接口怎么实现

332 2022-09-17

Java 实战项目之疫情防控管理系统详解

java中的接口是类吗

Spring中的aware接口详情

Python接口自动化之文件上传/下载接口怎么实现

推荐文章

接口调用是什么意思？几种常用接口调用方式

接口设计原则

8款在线 API 接口文档管理工具

api管理系统是什么？

什么是接口调试？接口调试的步骤有哪些？

api 接口管理系统有哪些？

接口测试有几种测试方法

API文档生成工具有哪些？

微服务和api网关区别

交换机配置步骤

最近发表

热评文章

在线接口文档管理工具推荐，支持在线测试，HTTP接口

开源的在线接口文档wiki工具Mindoc的介绍与使

如何优雅的进行接口设计？接口设计的六大原则是什么？

什么是API测试,api检测公司

遇到百度网址安全中心提醒您该页面可能存在钓鱼欺诈信息

软件接口设计怎么做？前后端分离软件接口设计思路