大家好✌！我是CZ淡陌。一名专注以理论为基础实战为主的技术博主，将再这里为大家分享优质的实战项目，本人在Java毕业设计领域有多年的经验，陆续会更新更多优质的Java实战项目，希望你能有所收获，少走一些弯路，向着优秀程序员前行！
🍅更多优质项目👇🏻👇🏻可点击下方获取🍅文章底部或评论区获取🍅
Java项目精品实战案例《100套》
文章目录
- 项目介绍
- 一、选题背景意义
- 1.项目背景
- 2.推荐理由
- 3.技术栈
- 二、运行效果
- 1.登录
- 2.首页
- 3.考勤系统
- 4.用户管理
- 5.角色管理
- 6.权限菜单
- 7.部门管理
- 8.岗位管理
- 9.公告管理
- 10.系统评价
- 11.教学计划
- 12.教学资源管理
- 13.实验管理
- 14.实验预约
- 15.课程发布
- 16.学生成绩
- 17.实验室分配
- 18.设备采购
- 19.仪器管理
- 20.维修管理
- 21.耗材管理
- 三、部分代码实现
- 1.用户模块
- 2.权限校验模块
- 总结
📣 有源码 查看源码
项目介绍
本文从用户的功能要求出发，建立了实验室管理系统，系统中的功能模块主要有完善的权限系统、图形页面展示模块、考勤模块、实验教学模块、实验室仪器管理模块等。
一、选题背景意义
示例：内容。。。。。。。。
1.项目背景
说起实验室信息管理系统（LIMS），各行业实验室并不陌生，尤其是近年来实验室信息管理系统（LIMS）在第三方检测实验室中的应用更为广泛，它给第三方检测行业实验室管理带来的促进作用和许多潜在的价值也已经得到了认可。
1．提高样品测试效率：测试人员可以随时在LIMS上查询自己所需的信息；分析结果输入LIMS后，自动汇总生成分析报告。
2．提高分析结果可靠性：分析人员可以及时了解与样品相关的全面信息；系统自检报错功能可以降低出错的概率。另外，LIMS提供的数据自动上传功能、特定的计算和自检功能，消除了人为因素，也可保证分析结果的可靠性。
3．提高对复杂分析问题的处理能力：LIMS将整个实验室的各类资源有机地整合在一起，工作人员可以方便地对实验室曾经做过的全部分析样品和结果进行查询。因此，通过对LIMS存储的历史数据的检错，有可能得到一些对实际问题处理有价值的信息。
实验室信息管理系统LIMS是帮助检测机构在管理上建立一个规范化、科学化、信息化的可持续发展的业务管理模式，能够帮助实验室提高工作效率。
2.推荐理由
3.技术栈
开发系统：Windows
JDK版本：Java JDK1.8（推荐）
开发工具：IDEA
数据库版本： mysql8.0（推荐）
数据库可视化工具： navicat
服务器：SpringBoot自带 apache tomcat
主要技术：Java,Springboot,mybatis,mysql,jquery,html
二、运行效果
1.登录
2.首页
可视图化查询学生签到情况、成绩分布情况、实验器材损耗情况等
3.考勤系统
4.用户管理
5.角色管理
可动态修改角色并设置权限
6.权限菜单
7.部门管理
8.岗位管理
9.公告管理
10.系统评价
11.教学计划
12.教学资源管理
13.实验管理
14.实验预约
15.课程发布
16.学生成绩
17.实验室分配
18.设备采购
19.仪器管理
20.维修管理
21.耗材管理
三、部分代码实现
1.用户模块
public class UserServiceImpl implements IUserService
{
private static final Logger log = LoggerFactory.getLogger(UserServiceImpl.class);
@Autowired
private UserMapper userMapper;
@Autowired
private RoleMapper roleMapper;
@Autowired
private PostMapper postMapper;
@Autowired
private UserPostMapper userPostMapper;
@Autowired
private UserRoleMapper userRoleMapper;
@Autowired
private IConfigService configService;
@Autowired
private PasswordService passwordService;
private static final String REQUEST_URL = "https://api.weixin.qq.com/sns/jscode2session";
private static final String GRANT_TYPE = "authorization_code";
@Override
public JSONObject getUserInfoMap(WechatLoginRequest loginRequest) throws Exception {
Map<String, Object> userInfoMap = new HashMap<>();
JSONObject sessionKeyOpenId = getSessionKeyOrOpenId(loginRequest.getCode());
// 获取openId && sessionKey
String openId = sessionKeyOpenId.getString("openid");
String sessionKey = sessionKeyOpenId.getString("session_key");
// 根据code保存openId和sessionKey
JSONObject sessionObj = new JSONObject();
sessionObj.put("openId", openId);
sessionObj.put("sessionKey", sessionKey);
// 根据openid查询用户，这里的查询service自己写，就不贴出来了
return sessionObj;
}
// 这里的JSONObject是阿里的fastjson，自行maven导入
private JSONObject getSessionKeyOrOpenId(String code) throws Exception {
Map<String, String> requestUrlParam = new HashMap<>();
// 小程序appId，自己补充
requestUrlParam.put("appid", "wxc4ff79a2ad4fc7bb");
// 小程序secret，自己补充
requestUrlParam.put("secret", "3f82cb947365f1ebd54d3e2857f47a67");
// 小程序端返回的code
requestUrlParam.put("js_code", code);
// 默认参数
requestUrlParam.put("grant_type", GRANT_TYPE);
// 发送post请求读取调用微信接口获取openid用户唯一标识
String result = HttpClientUtils.doPost(REQUEST_URL, requestUrlParam);
return JSON.parseObject(result);
}
/**
* 根据条件分页查询用户列表
*
* @param user 用户信息
* @return 用户信息集合信息
*/
@Override
@DataScope(deptAlias = "d", userAlias = "u")
public List<User> selectUserList(User user)
{
// 生成数据权限过滤条件
return userMapper.selectUserList(user);
}
@Override
public List<User> studentList(){
return userMapper.studentList();
}
/**
* 根据条件分页查询已分配用户角色列表
*
* @param user 用户信息
* @return 用户信息集合信息
*/
@Override
@DataScope(deptAlias = "d", userAlias = "u")
public List<User> selectAllocatedList(User user)
{
return userMapper.selectAllocatedList(user);
}
/**
* 根据条件分页查询未分配用户角色列表
*
* @param user 用户信息
* @return 用户信息集合信息
*/
@Override
@DataScope(deptAlias = "d", userAlias = "u")
public List<User> selectUnallocatedList(User user)
{
return userMapper.selectUnallocatedList(user);
}
/**
* 通过用户名查询用户
*
* @param userName 用户名
* @return 用户对象信息
*/
@Override
public User selectUserByLoginName(String userName)
{
return userMapper.selectUserByLoginName(userName);
}
/**
* 通过手机号码查询用户
*
* @param phoneNumber 手机号码
* @return 用户对象信息
*/
@Override
public User selectUserByPhoneNumber(String phoneNumber)
{
return userMapper.selectUserByPhoneNumber(phoneNumber);
}
/**
* 通过邮箱查询用户
*
* @param email 邮箱
* @return 用户对象信息
*/
@Override
public User selectUserByEmail(String email)
{
return userMapper.selectUserByEmail(email);
}
/**
* 通过用户ID查询用户
*
* @param userId 用户ID
* @return 用户对象信息
*/
@Override
public User selectUserById(Long userId)
{
return userMapper.selectUserById(userId);
}
/**
* 通过用户ID查询用户和角色关联
*
* @param userId 用户ID
* @return 用户和角色关联列表
*/
@Override
public List<UserRole> selectUserRoleByUserId(Long userId)
{
return userRoleMapper.selectUserRoleByUserId(userId);
}
/**
* 通过用户ID删除用户
*
* @param userId 用户ID
* @return 结果
*/
@Override
@Transactional
public int deleteUserById(Long userId)
{
// 删除用户与角色关联
userRoleMapper.deleteUserRoleByUserId(userId);
// 删除用户与岗位表
userPostMapper.deleteUserPostByUserId(userId);
return userMapper.deleteUserById(userId);
}
/**
* 批量删除用户信息
*
* @param ids 需要删除的数据ID
* @return 结果
*/
@Override
@Transactional
public int deleteUserByIds(String ids)
{
Long[] userIds = Convert.toLongArray(ids);
for (Long userId : userIds)
{
checkUserAllowed(new User(userId));
}
// 删除用户与角色关联
userRoleMapper.deleteUserRole(userIds);
// 删除用户与岗位关联
userPostMapper.deleteUserPost(userIds);
return userMapper.deleteUserByIds(userIds);
}
/**
* 新增保存用户信息
*
* @param user 用户信息
* @return 结果
*/
@Override
@Transactional
public int insertUser(User user)
{
user.randomSalt();
user.setPassword(passwordService.encryptPassword(user.getLoginName(), user.getPassword(), user.getSalt()));
//user.setCreateBy(ShiroUtils.getLoginName());
// 新增用户信息
int rows = userMapper.insertUser(user);
// 新增用户岗位关联
insertUserPost(user);
// 新增用户与角色管理
insertUserRole(user.getUserId(), user.getRoleIds());
return rows;
}
/**
* 注册用户信息
*
* @param user 用户信息
* @return 结果
*/
@Override
public boolean registerUser(User user)
{
user.setUserType(UserConstants.REGISTER_USER_TYPE);
user.randomSalt();
user.setPassword(passwordService.encryptPassword(user.getLoginName(), user.getPassword(), user.getSalt()));
return userMapper.insertUser(user) > 0;
}
/**
* 修改保存用户信息
*
* @param user 用户信息
* @return 结果
*/
@Override
@Transactional
public int updateUser(User user)
{
Long userId = user.getUserId();
user.setUpdateBy(ShiroUtils.getLoginName());
// 删除用户与角色关联
userRoleMapper.deleteUserRoleByUserId(userId);
// 新增用户与角色管理
insertUserRole(user.getUserId(), user.getRoleIds());
// 删除用户与岗位关联
userPostMapper.deleteUserPostByUserId(userId);
// 新增用户与岗位管理
insertUserPost(user);
return userMapper.updateUser(user);
}
/**
* 修改用户个人详细信息
*
* @param user 用户信息
* @return 结果
*/
@Override
public int updateUserInfo(User user)
{
return userMapper.updateUser(user);
}
/**
* 用户授权角色
*
* @param userId 用户ID
* @param roleIds 角色组
*/
@Override
public void insertUserAuth(Long userId, Long[] roleIds)
{
userRoleMapper.deleteUserRoleByUserId(userId);
insertUserRole(userId, roleIds);
}
/**
* 修改用户密码
*
* @param user 用户信息
* @return 结果
*/
@Override
public int resetUserPwd(User user)
{
user.randomSalt();
user.setPassword(passwordService.encryptPassword(user.getLoginName(), user.getPassword(), user.getSalt()));
return updateUserInfo(user);
}
/**
* 新增用户角色信息
*
* @param user 用户对象
*/
public void insertUserRole(Long userId, Long[] roleIds)
{
if (StringUtils.isNotNull(roleIds))
{
// 新增用户与角色管理
List<UserRole> list = new ArrayList<UserRole>();
for (Long roleId : roleIds)
{
UserRole ur = new UserRole();
ur.setUserId(userId);
ur.setRoleId(roleId);
list.add(ur);
}
if (list.size() > 0)
{
userRoleMapper.batchUserRole(list);
}
}
}
/**
* 新增用户岗位信息
*
* @param user 用户对象
*/
public void insertUserPost(User user)
{
Long[] posts = user.getPostIds();
if (StringUtils.isNotNull(posts))
{
// 新增用户与岗位管理
List<UserPost> list = new ArrayList<UserPost>();
for (Long postId : user.getPostIds())
{
UserPost up = new UserPost();
up.setUserId(user.getUserId());
up.setPostId(postId);
list.add(up);
}
if (list.size() > 0)
{
userPostMapper.batchUserPost(list);
}
}
}
/**
* 校验登录名称是否唯一
*
* @param loginName 用户名
* @return
*/
@Override
public String checkLoginNameUnique(String loginName)
{
int count = userMapper.checkLoginNameUnique(loginName);
if (count > 0)
{
return UserConstants.USER_NAME_NOT_UNIQUE;
}
return UserConstants.USER_NAME_UNIQUE;
}
/**
* 校验手机号码是否唯一
*
* @param user 用户信息
* @return
*/
@Override
public String checkPhoneUnique(User user)
{
Long userId = StringUtils.isNull(user.getUserId()) ? -1L : user.getUserId();
User info = userMapper.checkPhoneUnique(user.getPhonenumber());
if (StringUtils.isNotNull(info) && info.getUserId().longValue() != userId.longValue())
{
return UserConstants.USER_PHONE_NOT_UNIQUE;
}
return UserConstants.USER_PHONE_UNIQUE;
}
/**
* 校验email是否唯一
*
* @param user 用户信息
* @return
*/
@Override
public String checkEmailUnique(User user)
{
Long userId = StringUtils.isNull(user.getUserId()) ? -1L : user.getUserId();
User info = userMapper.checkEmailUnique(user.getEmail());
if (StringUtils.isNotNull(info) && info.getUserId().longValue() != userId.longValue())
{
return UserConstants.USER_EMAIL_NOT_UNIQUE;
}
return UserConstants.USER_EMAIL_UNIQUE;
}
/**
* 校验用户是否允许操作
*
* @param user 用户信息
*/
@Override
public void checkUserAllowed(User user)
{
if (StringUtils.isNotNull(user.getUserId()) && user.isAdmin())
{
throw new BusinessException("不允许操作超级管理员用户");
}
}
/**
* 查询用户所属角色组
*
* @param userId 用户ID
* @return 结果
*/
@Override
public String selectUserRoleGroup(Long userId)
{
List<Role> list = roleMapper.selectRolesByUserId(userId);
StringBuffer idsStr = new StringBuffer();
for (Role role : list)
{
idsStr.append(role.getRoleName()).append(",");
}
if (StringUtils.isNotEmpty(idsStr.toString()))
{
return idsStr.substring(0, idsStr.length() - 1);
}
return idsStr.toString();
}
/**
* 查询用户所属岗位组
*
* @param userId 用户ID
* @return 结果
*/
@Override
public String selectUserPostGroup(Long userId)
{
List<Post> list = postMapper.selectPostsByUserId(userId);
StringBuffer idsStr = new StringBuffer();
for (Post post : list)
{
idsStr.append(post.getPostName()).append(",");
}
if (StringUtils.isNotEmpty(idsStr.toString()))
{
return idsStr.substring(0, idsStr.length() - 1);
}
return idsStr.toString();
}
/**
* 导入用户数据
*
* @param userList 用户数据列表
* @param isUpdateSupport 是否更新支持，如果已存在，则进行更新数据
* @return 结果
*/
@Override
public String importUser(List<User> userList, Boolean isUpdateSupport)
{
if (StringUtils.isNull(userList) || userList.size() == 0)
{
throw new BusinessException("导入用户数据不能为空！");
}
int successNum = 0;
int failureNum = 0;
StringBuilder successMsg = new StringBuilder();
StringBuilder failureMsg = new StringBuilder();
String operName = ShiroUtils.getLoginName();
String password = configService.selectConfigByKey("sys.user.initPassword");
for (User user : userList)
{
try
{
// 验证是否存在这个用户
User u = userMapper.selectUserByLoginName(user.getLoginName());
if (StringUtils.isNull(u))
{
user.setPassword(password);
user.setCreateBy(operName);
this.insertUser(user);
successNum++;
successMsg.append("<br/>" + successNum + "、账号 " + user.getLoginName() + " 导入成功");
}
else if (isUpdateSupport)
{
user.setUpdateBy(operName);
this.updateUser(user);
successNum++;
successMsg.append("<br/>" + successNum + "、账号 " + user.getLoginName() + " 更新成功");
}
else
{
failureNum++;
failureMsg.append("<br/>" + failureNum + "、账号 " + user.getLoginName() + " 已存在");
}
}
catch (Exception e)
{
failureNum++;
String msg = "<br/>" + failureNum + "、账号 " + user.getLoginName() + " 导入失败：";
failureMsg.append(msg + e.getMessage());
log.error(msg, e);
}
}
if (failureNum > 0)
{
failureMsg.insert(0, "很抱歉，导入失败！共 " + failureNum + " 条数据格式不正确，错误如下：");
throw new BusinessException(failureMsg.toString());
}
else
{
successMsg.insert(0, "恭喜您，数据已全部导入成功！共 " + successNum + " 条，数据如下：");
}
return successMsg.toString();
}
/**
* 用户状态修改
*
* @param user 用户信息
* @return 结果
*/
@Override
public int changeStatus(User user)
{
return userMapper.updateUser(user);
}
}
2.权限校验模块
package com.ruoyi.project.system.role.service;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.ruoyi.common.constant.UserConstants;
import com.ruoyi.common.exception.BusinessException;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.security.ShiroUtils;
import com.ruoyi.common.utils.spring.SpringUtils;
import com.ruoyi.common.utils.text.Convert;
import com.ruoyi.framework.aspectj.lang.annotation.DataScope;
import com.ruoyi.project.system.role.domain.Role;
import com.ruoyi.project.system.role.domain.RoleDept;
import com.ruoyi.project.system.role.domain.RoleMenu;
import com.ruoyi.project.system.role.mapper.RoleDeptMapper;
import com.ruoyi.project.system.role.mapper.RoleMapper;
import com.ruoyi.project.system.role.mapper.RoleMenuMapper;
import com.ruoyi.project.system.user.domain.UserRole;
import com.ruoyi.project.system.user.mapper.UserRoleMapper;
/**
* 角色 业务层处理
*
* @author experiment
*/
@Service
public class RoleServiceImpl implements IRoleService
{
@Autowired
private RoleMapper roleMapper;
@Autowired
private RoleMenuMapper roleMenuMapper;
@Autowired
private UserRoleMapper userRoleMapper;
@Autowired
private RoleDeptMapper roleDeptMapper;
/**
* 根据条件分页查询角色数据
*
* @param role 角色信息
* @return 角色数据集合信息
*/
@Override
@DataScope(deptAlias = "d")
public List<Role> selectRoleList(Role role)
{
return roleMapper.selectRoleList(role);
}
/**
* 根据用户ID查询权限
*
* @param userId 用户ID
* @return 权限列表
*/
@Override
public Set<String> selectRoleKeys(Long userId)
{
List<Role> perms = roleMapper.selectRolesByUserId(userId);
Set<String> permsSet = new HashSet<>();
for (Role perm : perms)
{
if (StringUtils.isNotNull(perm))
{
permsSet.addAll(Arrays.asList(perm.getRoleKey().trim().split(",")));
}
}
return permsSet;
}
/**
* 根据用户ID查询角色
*
* @param userId 用户ID
* @return 角色列表
*/
@Override
public List<Role> selectRolesByUserId(Long userId)
{
List<Role> userRoles = roleMapper.selectRolesByUserId(userId);
List<Role> roles = selectRoleAll();
for (Role role : roles)
{
for (Role userRole : userRoles)
{
if (role.getRoleId().longValue() == userRole.getRoleId().longValue())
{
role.setFlag(true);
break;
}
}
}
return roles;
}
/**
* 查询所有角色
*
* @return 角色列表
*/
@Override
public List<Role> selectRoleAll()
{
return SpringUtils.getAopProxy(this).selectRoleList(new Role());
}
/**
* 通过角色ID查询角色
*
* @param roleId 角色ID
* @return 角色对象信息
*/
@Override
public Role selectRoleById(Long roleId)
{
return roleMapper.selectRoleById(roleId);
}
/**
* 通过角色ID删除角色
*
* @param roleId 角色ID
* @return 结果
*/
@Override
@Transactional
public boolean deleteRoleById(Long roleId)
{
// 删除角色与菜单关联
roleMenuMapper.deleteRoleMenuByRoleId(roleId);
// 删除角色与部门关联
roleDeptMapper.deleteRoleDeptByRoleId(roleId);
return roleMapper.deleteRoleById(roleId) > 0 ? true : false;
}
/**
* 批量删除角色信息
*
* @param ids 需要删除的数据ID
* @throws Exception
*/
@Override
@Transactional
public int deleteRoleByIds(String ids)
{
Long[] roleIds = Convert.toLongArray(ids);
for (Long roleId : roleIds)
{
checkRoleAllowed(new Role(roleId));
Role role = selectRoleById(roleId);
if (countUserRoleByRoleId(roleId) > 0)
{
throw new BusinessException(String.format("%1$s已分配,不能删除", role.getRoleName()));
}
}
// 删除角色与菜单关联
roleMenuMapper.deleteRoleMenu(roleIds);
// 删除角色与部门关联
roleDeptMapper.deleteRoleDept(roleIds);
return roleMapper.deleteRoleByIds(roleIds);
}
/**
* 新增保存角色信息
*
* @param role 角色信息
* @return 结果
*/
@Override
@Transactional
public int insertRole(Role role)
{
role.setCreateBy(ShiroUtils.getLoginName());
// 新增角色信息
roleMapper.insertRole(role);
return insertRoleMenu(role);
}
/**
* 修改保存角色信息
*
* @param role 角色信息
* @return 结果
*/
@Override
@Transactional
public int updateRole(Role role)
{
role.setUpdateBy(ShiroUtils.getLoginName());
// 修改角色信息
roleMapper.updateRole(role);
// 删除角色与菜单关联
roleMenuMapper.deleteRoleMenuByRoleId(role.getRoleId());
return insertRoleMenu(role);
}
/**
* 修改数据权限信息
*
* @param role 角色信息
* @return 结果
*/
@Override
@Transactional
public int authDataScope(Role role)
{
role.setUpdateBy(ShiroUtils.getLoginName());
// 修改角色信息
roleMapper.updateRole(role);
// 删除角色与部门关联
roleDeptMapper.deleteRoleDeptByRoleId(role.getRoleId());
// 新增角色和部门信息（数据权限）
return insertRoleDept(role);
}
/**
* 新增角色菜单信息
*
* @param role 角色对象
*/
public int insertRoleMenu(Role role)
{
int rows = 1;
// 新增用户与角色管理
List<RoleMenu> list = new ArrayList<RoleMenu>();
for (Long menuId : role.getMenuIds())
{
RoleMenu rm = new RoleMenu();
rm.setRoleId(role.getRoleId());
rm.setMenuId(menuId);
list.add(rm);
}
if (list.size() > 0)
{
rows = roleMenuMapper.batchRoleMenu(list);
}
return rows;
}
/**
* 新增角色部门信息(数据权限)
*
* @param role 角色对象
*/
public int insertRoleDept(Role role)
{
int rows = 1;
// 新增角色与部门（数据权限）管理
List<RoleDept> list = new ArrayList<RoleDept>();
for (Long deptId : role.getDeptIds())
{
RoleDept rd = new RoleDept();
rd.setRoleId(role.getRoleId());
rd.setDeptId(deptId);
list.add(rd);
}
if (list.size() > 0)
{
rows = roleDeptMapper.batchRoleDept(list);
}
return rows;
}
/**
* 校验角色名称是否唯一
*
* @param role 角色信息
* @return 结果
*/
@Override
public String checkRoleNameUnique(Role role)
{
Long roleId = StringUtils.isNull(role.getRoleId()) ? -1L : role.getRoleId();
Role info = roleMapper.checkRoleNameUnique(role.getRoleName());
if (StringUtils.isNotNull(info) && info.getRoleId().longValue() != roleId.longValue())
{
return UserConstants.ROLE_NAME_NOT_UNIQUE;
}
return UserConstants.ROLE_NAME_UNIQUE;
}
/**
* 校验角色权限是否唯一
*
* @param role 角色信息
* @return 结果
*/
@Override
public String checkRoleKeyUnique(Role role)
{
Long roleId = StringUtils.isNull(role.getRoleId()) ? -1L : role.getRoleId();
Role info = roleMapper.checkRoleKeyUnique(role.getRoleKey());
if (StringUtils.isNotNull(info) && info.getRoleId().longValue() != roleId.longValue())
{
return UserConstants.ROLE_KEY_NOT_UNIQUE;
}
return UserConstants.ROLE_KEY_UNIQUE;
}
/**
* 校验角色是否允许操作
*
* @param role 角色信息
*/
@Override
public void checkRoleAllowed(Role role)
{
if (StringUtils.isNotNull(role.getRoleId()) && role.isAdmin())
{
throw new BusinessException("不允许操作超级管理员角色");
}
}
/**
* 通过角色ID查询角色使用数量
*
* @param roleId 角色ID
* @return 结果
*/
@Override
public int countUserRoleByRoleId(Long roleId)
{
return userRoleMapper.countUserRoleByRoleId(roleId);
}
/**
* 角色状态修改
*
* @param role 角色信息
* @return 结果
*/
@Override
public int changeStatus(Role role)
{
return roleMapper.updateRole(role);
}
/**
* 取消授权用户角色
*
* @param userRole 用户和角色关联信息
* @return 结果
*/
@Override
public int deleteAuthUser(UserRole userRole)
{
return userRoleMapper.deleteUserRoleInfo(userRole);
}
/**
* 批量取消授权用户角色
*
* @param roleId 角色ID
* @param userIds 需要删除的用户数据ID
* @return 结果
*/
@Override
public int deleteAuthUsers(Long roleId, String userIds)
{
return userRoleMapper.deleteUserRoleInfos(roleId, Convert.toLongArray(userIds));
}
/**
* 批量选择授权用户角色
*
* @param roleId 角色ID
* @param userIds 需要删除的用户数据ID
* @return 结果
*/
@Override
public int insertAuthUsers(Long roleId, String userIds)
{
Long[] users = Convert.toLongArray(userIds);
// 新增用户与角色管理
List<UserRole> list = new ArrayList<UserRole>();
for (Long userId : users)
{
UserRole ur = new UserRole();
ur.setUserId(userId);
ur.setRoleId(roleId);
list.add(ur);
}
return userRoleMapper.batchUserRole(list);
}
}
📝分享的所有Java项目源码均包含（前端+后台+数据库），可做毕业设计或课程设计，欢迎留言分享问题，交流经验
🍅更多优质项目👇🏻👇🏻可点击下方获取🍅文章底部或评论区获取🍅
Java项目精品实战案例《100套》
总结
📣 有源码 查看源码
![[极客大挑战 2019]Secret File(BUUCTF)](https://img-blog.csdnimg.cn/c0ac03c8b7894819bbbfc9eac18820a5.png)
