0
点赞
收藏
分享

微信扫一扫

权限控制-auth工程当中添加用户验证

君之言之 2022-05-25 阅读 37
Projectjsonide用户名前端开发

Service

创建 IndexService

/**
 * @author BNTang
 * @version 1.0
 * @project video_parent
 * @description
 * @since Created in 2021/5/2 002 21:03
 **/
public interface IndexService {

    /**
     * 根据token获取用户信息
     *
     * @param name 用户名
     * @return 用户信息
     */
    Map<String, Object> getUserInfo(String name);

    /**
     * 获取当前登陆用户的菜单
     * @param name 用户名
     * @return 用户菜单信息
     */
    List<JSONObject> getMenu(String name);
}

修改 MenuService

/**
 * 根据用户ID查询用户权限
 *
 * @param id 用户ID
 * @return 用户权限
 */
List<String> selectPermissionValueByUserId(String id);

/**
 * 根据用户id返回前端的菜单
 *
 * @param id 用户id
 * @return 前端的菜单
 */
List<JSONObject> selectPermissionByUserId(String id);

修改 RoleService

/**
 * 根据用户id查询角色
 *
 * @param id 用户ID
 * @return 用户对应的角色
 */
List<Role> selectRoleByUserId(String id);

修改 UserService

/**
 * 根据用户名从数据库中取出用户信息
 *
 * @param username 用户名
 * @return 用户信息
 */
User selectByUserName(String username);

Impl

创建 IndexServiceImpl

/**
 * @author BNTang
 * @version 1.0
 * @project video_parent
 * @description
 * @since Created in 2021/5/2 002 21:09
 **/
@Service
public class IndexServiceImpl implements IndexService {
    @Resource
    private UserService userService;

    @Resource
    private RoleService roleService;

    @Resource
    private MenuService menuService;

    @Resource
    private RedisTemplate<String, List<String>> redisTemplate;

    /**
     * 根据用户名获取用户登录信息
     */
    @Override
    public Map<String, Object> getUserInfo(String username) {
        Map<String, Object> result = new HashMap<>(4);
        User user = userService.selectByUserName(username);

        if (ObjectUtils.isEmpty(user)) {
            throw new BnTangException(200001, "没有该用户");
        }

        // 根据用户id获取角色
        List<Role> roleList = roleService.selectRoleByUserId(user.getId());
        List<String> roleNameList = roleList.stream().map(Role::getRoleName).collect(Collectors.toList());
        if (roleNameList.size() == 0) {
            // 前端框架必须返回一个角色，否则报错，如果没有角色，返回一个空角色
            roleNameList.add("");
        }

        // 根据用户id获取操作权限值
        List<String> permissionValueList = menuService.selectPermissionValueByUserId(user.getId());

        // 把权限缓存到redis当中
        redisTemplate.opsForValue().set(username, permissionValueList);

        result.put("name", user.getUsername());
        result.put("avatar", user.getSalt());
        result.put("roles", roleNameList);
        result.put("permissionValueList", permissionValueList);
        return result;
    }

    /**
     * 根据用户名获取动态菜单
     */
    @Override
    public List<JSONObject> getMenu(String username) {
        // 根据用户id获取用户菜单权限
        return menuService.selectPermissionByUserId(userService.selectByUserName(username).getId());
    }
}

修改 MenuServiceImpl

@Resource
private UserService userService;
@Override
public List<String> selectPermissionValueByUserId(String id) {
    List<String> selectPermissionValueList;

    if (this.isSysAdmin(id)) {
        // 如果是系统管理员，获取所有权限
        selectPermissionValueList = baseMapper.selectAllMenuValue();
    } else {
        // 否则就不是系统管理员，根据用户查询菜单权限
        selectPermissionValueList = baseMapper.selectMenuValueByUserId(id);
    }
    return selectPermissionValueList;
}

@Override
public List<JSONObject> selectPermissionByUserId(String id) {
    List<Menu> selectMenuList;

    if (this.isSysAdmin(id)) {
        // 如果是超级管理员，获取所有菜单
        selectMenuList = baseMapper.selectList(null);
    } else {
        selectMenuList = baseMapper.selectMenuByUserId(id);
    }
    // 1.构建树形菜单
    List<Menu> menuList = buildTreeMenu(selectMenuList);

    // 2.返回给前端json数据
    return buildMenuWebList(menuList);
}

private List<JSONObject> buildMenuWebList(List<Menu> menuList) {
    List<JSONObject> menus = new ArrayList<>();

    if (menuList.size() == 1) {
        // 左侧一级菜单
        menuList.get(0).getChildren().forEach(oneMenu -> {
            JSONObject oneMenuObj = this.generateJsonObj(oneMenu, false);

            List<JSONObject> children = new ArrayList<>();
            oneMenu.getChildren().forEach(twoMenu -> {
                JSONObject twoMenuObj = this.generateJsonObj(twoMenu, false);
                children.add(twoMenuObj);

                twoMenu.getChildren().forEach(three -> {
                    if (StringUtils.isEmpty(three.getPath())) {
                        return;
                    }
                    JSONObject threeMenu = this.generateJsonObj(three, true);
                    children.add(threeMenu);
                });
            });
            oneMenuObj.put("children", children);
            menus.add(oneMenuObj);
        });
    }
    return menus;
}

/**
 * 生成菜单信息JSON对象
 */
private JSONObject generateJsonObj(Menu menu, Boolean whetherDisplay) {
    JSONObject jsonObj = new JSONObject();
    jsonObj.put("path", menu.getPath());
    jsonObj.put("component", menu.getComponent());
    jsonObj.put("hidden", whetherDisplay);

    JSONObject oneMeta = new JSONObject();
    oneMeta.put("title", menu.getName());

    if (!StringUtils.isEmpty(menu.getIcon())) {
        oneMeta.put("icon", menu.getIcon());
    }
    jsonObj.put("meta", oneMeta);

    return jsonObj;
}

/**
 * 判断用户是否是系统管理员
 */
private boolean isSysAdmin(String userId) {
    User user = userService.getById(userId);
    return !ObjectUtils.isEmpty(user) && "admin".equals(user.getUsername());
}

修改 RoleServiceImpl

@Override
public List<Role> selectRoleByUserId(String id) {
    // 根据用户id查询拥有的角色id
    List<UserRole> userRoleList = userRoleService.list(new QueryWrapper<UserRole>()
            .eq("user_id", id)
            .select("role_id"));

    //获取所有角色id
    List<String> roleIdList = userRoleList.stream().map(UserRole::getRoleId).collect(Collectors.toList());

    // 根据角色id查询所有的角色信息
    List<Role> roleList = new ArrayList<>();

    if (roleIdList.size() > 0) {
        roleList = baseMapper.selectBatchIds(roleIdList);
    }
    return roleList;
}

创建 UserDetailsServiceImpl

/**
 * @author BNTang
 * @version 1.0
 * @project video_parent
 * @description 用户验证业务
 * @since Created in 2021/5/2 002 16:42
 **/
@Service
public class UserDetailsServiceImpl implements UserDetailsService {

    @Resource
    private UserService userService;

    @Resource
    private MenuService menuService;

    /***
     * 根据账号获取用户信息
     */
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        // 从数据库中取出用户信息
        User user = userService.selectByUserName(username);

        // 判断用户是否存在
        if (ObjectUtils.isEmpty(user)) {
            throw new UsernameNotFoundException("用户不存在！");
        }

        // 返回UserDetails实现类
        top.it6666.common_security.entity.User curUser = new top.it6666.common_security.entity.User();
        BeanUtils.copyProperties(user, curUser);

        // 查询用户权限
        List<String> authorities = menuService.selectPermissionValueByUserId(user.getId());
        SecurityUser securityUser = new SecurityUser(curUser);
        securityUser.setPermissionValueList(authorities);
        return securityUser;
    }
}

修改 UserServiceImpl

@Override
public User selectByUserName(String username) {
    return baseMapper.selectOne(new QueryWrapper<User>().eq("username", username));
}

Controller

创建 IndexController

/**
 * @author BNTang
 * @version 1.0
 * @project video_parent
 * @description
 * @since Created in 2021/5/2 002 21:02
 **/
@Api(tags = "工作人员-用户组")
@RestController
@RequestMapping("/service_auth/admin/index")
public class IndexController {
    @Resource
    private IndexService indexService;

    /**
     * 根据token获取用户信息
     */
    @ApiOperation(value = "根据token获取用户信息")
    @GetMapping("info")
    public ResponseResult info() {
        // 获取当前登录用户用户名
        return ResponseResult.ok().data(indexService.getUserInfo(SecurityContextHolder.getContext().getAuthentication().getName()));
    }

    /**
     * 获取当前登陆用户的菜单
     */
    @ApiOperation(value = "获取当前登陆用户的菜单")
    @GetMapping("menu")
    public ResponseResult getMenu() {
        // 获取当前登录用户用户名
        List<JSONObject> menuList = indexService.getMenu(SecurityContextHolder.getContext().getAuthentication().getName());
        return ResponseResult.ok().data("menuList", menuList);
    }
}

修改 application.yml 加入 Redis 的相关配置

redis:
  host: 127.0.0.1
  port: 6379
  database: 0
  timeout: 1800000
  lettuce:
    pool:
      max-active: 20
      max-wait: 1
      # 最大阻塞等待时间
      max-idle: 5
      min-idle: 0

修改 service_auth 的 pom.xml 加入 security 安全认证

<dependencies>
    <dependency>
        <groupId>top.it6666</groupId>
        <artifactId>common_security</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </dependency>
</dependencies>

Mapper

修改 MenuMapper

/**
 * <p>
 * 菜单权限 Mapper 接口
 * </p>
 *
 * @author BNTang
 * @since 2021-04-21
 */
public interface MenuMapper extends BaseMapper<Menu> {

    /**
     * 查询所有的菜单
     *
     * @return 菜单信息
     */
    List<String> selectAllMenuValue();

    /**
     * 根据用户ID查询用户菜单权限
     *
     * @param id 用户ID
     * @return 菜单权限
     */
    List<String> selectMenuValueByUserId(String id);

    /**
     * 根据用户id获取菜单权限
     *
     * @param id 用户id
     * @return 菜单权限信息数据
     */
    List<Menu> selectMenuByUserId(String id);
}

修改 MenuMapper.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="top.it6666.service_auth.mapper.MenuMapper">
    <select id="selectAllMenuValue" resultType="java.lang.String">
        SELECT permission_value
        FROM auth_menu
        WHERE type = 2
          AND is_deleted = 0
    </select>
    <select id="selectMenuValueByUserId" resultType="java.lang.String">
        SELECT p.permission_value
        FROM auth_user_role ur
                     INNER JOIN auth_role_menu rp ON rp.role_id = ur.role_id
                     INNER JOIN auth_menu p ON p.id = rp.permission_id
        WHERE ur.user_id = #{userId}
          AND p.type = 2
          AND ur.is_deleted = 0
          AND rp.is_deleted = 0
          AND p.is_deleted = 0
    </select>
    <select id="selectMenuByUserId" resultType="top.it6666.service_auth.entity.Menu">
        SELECT p.id,
               p.pid,
               p.name,
               p.type,
               p.permission_value,
               path,
               p.component,
               p.icon,
               p.status,
               p.is_deleted
        FROM auth_user_role ur
                     INNER JOIN auth_role_menu rp ON rp.role_id = ur.role_id
                     INNER JOIN auth_menu p ON p.id = rp.permission_id
        WHERE ur.user_id = #{userId}
          AND ur.is_deleted = 0
          AND rp.is_deleted = 0
          AND p.is_deleted = 0
    </select>
</mapper>

修改 Menu 实体类去除逻辑删除

权限控制-auth工程当中添加用户验证_Project




举报

相关推荐

linux系统添加审计用户并进行权限控制

运维审计用户LinuxPowered by 金山文档vimJavaScript前端开发

权限控制-用户管理

Project数据idejson编程语言

Django 用户验证与权限管理

django

Linux如何添加用户及用户权限管理

linux

fastadmin的权限管理auth

用户组初始化ITHtml/CSS前端开发

rancher中添加用户，赋予权限

dockerk8srancher多用户全栈工程师Python后端开发

DCL 管理用户与权限控制

用户名主机名数据库MySQLyyds干货盘点

RabbitMQ用户角色及权限控制

大数据人工智能运维正则表达式配置文件JavaScript前端开发

Auth用户认证组件

pythondjangohtml#ifPython编程语言

thinkphp5.0--auth权限

auth权限thinkphp5用户组PHP前端开发
0 条评论