[ Shiro ] SpringBoot 集成 Shiro 与 Redis 实现权限控制,统一会话管理

SpringBoot 集成 Shiro 实现权限管理

完整项目地址:https://gitee.com/aoxiaobao/Shiro-study

上一篇:[ JWT ] SpringBoot 集成 JWT 实现 token 鉴权


pom依赖

<dependency>
	<groupId>org.apache.shiro</groupId>
	<artifactId>shiro-core</artifactId>
	<version>1.3.2</version>
</dependency>
<dependency>
	<groupId>org.apache.shiro</groupId>
	<artifactId>shiro-spring</artifactId>
	<version>1.3.2</version>
</dependency>

修改登录方法


  • 密码采用shiro提供的 Md5Hash 方法加密
  • 参数一:加密的内容
  • 参数二:盐(加密的混淆字符串)(用户登录的用户名)
  • 参数三:加密次数
    public String login(String username,String password){
        // 构造登录令牌
        try{
            /**
             * 密码加密:
             *  shiro提供的md5加密
             *  Md5Hash:
             *      参数一:加密的内容
             *      参数二:盐(加密的混淆字符串)(用户登录的用户名)
             *      参数三:加密次数
             */
            // 密码加密
//            password = new Md5Hash(password,username,3).toString();

            UsernamePasswordToken upToken = new UsernamePasswordToken(username,password);
            System.out.println(upToken);
            // 获取subject
            Subject subject = SecurityUtils.getSubject();

            // 获取session
            String sid = (String) subject.getSession().getId();
            System.out.println(sid);
            // 调用subject进行登录
            subject.login(upToken);

            return "登录成功:"+sid;
        } catch (Exception e){
            return "用户名或密码错误";
        }
    }

添加自定义 realm


  • 该类继承 AuthorizingRealm
  • 重写认证方法:AuthenticationInfo
  • 重写授权方法:AuthorizationInfo
/**
 * 自定义reallm
 */
public class CustomerRealm extends AuthorizingRealm {
    @Override
    public void setName(String name){
        super.setName("customRealm");
    }
    @Autowired
    private UserService userService;
    @Autowired
    private RoleService roleService;
    @Autowired
    private PermService permService;
    /**
     * 授权方法
     *  操作的时候,判断用户是否具有响应的权限
     *      先认证 -- 安全数据
     *      再授权 -- 根据安全数据获取用户具有的所有操作权限
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        // 获取已认证的用户数据
        User user = (User) principalCollection.getPrimaryPrincipal(); // 得到唯一安全数据
        // 根据用户数据获取去用户的权限信息(所有角色,所有权限)
        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
        Set<String> roles = new HashSet<>(); // 所有角色
        Set<String> perms = new HashSet<>(); // 所有权限
//        for(Role role : user.getRoles()){
//            roles.add(role.getName());
//            for(Permission perm : role.getPermissions()){
//                perms.add(perm.getCode());
//            }
//        }
        Role role = roleService.findByName(user.getUsername());
        Permission permission = permService.findByName(user.getUsername());
        System.out.println(role.getRoleName());
        System.out.println(permission.getPermName());
        roles.add(role.getRoleName());
        perms.add(permission.getPermName());
        info.setStringPermissions(perms);
        info.setRoles(roles);
        return info;
    }

    /**
     * 认证方法
     * 参数:传递的用户名密码
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        // 获取登录的用户名密码(token)
        UsernamePasswordToken upToken  = (UsernamePasswordToken) authenticationToken;
        String username = upToken.getUsername();
        String password = new String(upToken.getPassword());

        // 根据用户名查询数据库
        User user = userService.findByName(username);

        // 判断用户名是否存在或密码是否一致
        if(user != null && user.getPassword().equals(password)){
            // 如果一致,返回安全数据
            // 构造方法:安全数据,密码,realm域名
            SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(user,user.getPassword(),this.getName());
            return info;
        }

        // 不一致,返回null(抛出异常)
        return null;
    }
}

配置 SecurityManager


详细的说明都写在注释里了

/**
 * @author aowei
 */
@Configuration
public class ShiroConfiguration {
    // 创建realm
    @Bean
    public CustomerRealm getRealm(){
        return new CustomerRealm();
    }
    // 创建安全管理器
    @Bean
    public SecurityManager getSecurityManager(CustomerRealm realm){
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        // 将自定义的realm交给安全管理器统一调度管理
        securityManager.setRealm(realm);

        // 将自定义的会话管理器注册到安全管理器中
        securityManager.setSessionManager(sessionManager());

        // 将自定义的redis缓存管理器注册到安全管理器
        securityManager.setCacheManager(redisCacheManager());
        return securityManager;
    }
    /**
     * 在web程序中,shiro进行权限控制全部是通过一组过滤器集合进行控制
     * 配置shiro的过滤器工厂,设置对应的过滤条件和跳转条件
     */
    @Bean
    public ShiroFilterFactoryBean shiroFilter(SecurityManager securityManager){
        // 创建过滤器工厂
        ShiroFilterFactoryBean filterFactory = new ShiroFilterFactoryBean();
        // 设置安全管理器
        filterFactory.setSecurityManager(securityManager);
        // 通用配置(跳转登录页面,未授权页面)
        filterFactory.setLoginUrl("/loginUrl"); // 跳转url地址
        filterFactory.setUnauthorizedUrl("/unAuth");// 未授权的url
        // 设置管理器集合

        /**
         * 设置所有的过滤器:有顺序map
         *  key = 拦截的url地址
         *  value = 过滤器类型
         */
        Map<String,String> filterMap = new LinkedHashMap<>();
        filterMap.put("/home","anon"); // 当前请求url地址可匿名访问

        // 具有某种权限才能访问
//        filterMap.put("/user/client","perms[user-client]");

        // 具有某种角色才能访问
//        filterMap.put("/user/admin","roles[admin]");
        filterMap.put("/user/**","authc"); // 当前请求地址必须认证之后可访问
        // 设置过滤器
        filterFactory.setFilterChainDefinitionMap(filterMap);
        return filterFactory;
    }

    // 开启对shiro 注解的支持
    @Bean
    public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager){
        AuthorizationAttributeSourceAdvisor advisor = new AuthorizationAttributeSourceAdvisor();
        advisor.setSecurityManager(securityManager);
        return advisor;
    }
    // 开启对shiro 注解的支持
    @Bean
    @ConditionalOnMissingBean
    public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator(){
        DefaultAdvisorAutoProxyCreator app=new DefaultAdvisorAutoProxyCreator();
        app.setProxyTargetClass(true);
        return app;
    }

shiro 鉴权


1、基于注解

    @RequiresPermissions("user-home")  -- 访问此方法必须具有的权限
    @RequiresRoles("admin")  --  访问此方法必须具有的角色

2、基于拦截器

Map<String,String> filterMap = new LinkedHashMap<>();
	filterMap.put("/home","anon"); // 当前请求url地址可匿名访问
	// 具有某种权限才能访问
	filterMap.put("/user/client","perms[user-client]");
	// 具有某种角色才能访问
	filterMap.put("/user/admin","roles[admin]");
	filterMap.put("/user/**","authc"); // 当前请求地址必须认证之后可访问
	// 设置过滤器
filterFactory.setFilterChainDefinitionMap(filterMap);

shiro 两种鉴权方式的区别

  • 过滤器:如果权限信息不匹配 跳转到setUnauthorizedUrl地址
  • 注解;如果权限信息不匹配,抛出异常

Shiro结合redis的统一会话管理


  • (1)shiroredis 整合
<dependency>
   <groupId>org.crazycake</groupId>
    <artifactId>shiro-redis</artifactId>
    <version>3.0.0</version>
</dependency>
  • (2)修改 springboot 配置文件,添加 redis 的设置
spring.redis.host=192.168.43.121
spring.redis.port=6379
  • (3)自定义 shiro 的会话管理器
/**
 * 自定义sessionManager
 * @author aowei
 */
public class CustomSessionManager extends DefaultWebSessionManager {
    /**
     * 头信息中具有sessionId
     *  请求头:Authorization:sessionId
     *
     *  指定sessionId的获取方式
     */
    @Override
    protected Serializable getSessionId(ServletRequest request, ServletResponse response) {
        // 获取请求头Authorization中的数据
        String id = WebUtils.toHttp(request).getHeader("Authorization");
        if(StringUtils.isEmpty(id)){
            // 如果没有携带,生成新的sessionId
            return super.getSessionId(request,response);
        }else {
            // 返回sessionId
            request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID_SOURCE,"header");
            request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID,id);
            request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID_IS_VALID,Boolean.TRUE);
            return id;
        }
    }
}
  • (4)配置shiro 基于redis 的会话管理
    @Value("${spring.redis.host}")
    private String host;
    @Value("${spring.redis.port}")
    private int port;
    /**
     * redis 的控制器,操作redis
     */
    public RedisManager redisManager(){
        RedisManager redisManager = new RedisManager();
        redisManager.setHost(host);
        redisManager.setPort(port);
        return redisManager;
    }

    /**
     * sessionDao
     */
    public RedisSessionDAO redisSessionDAO(){
        RedisSessionDAO sessionDAO = new RedisSessionDAO();
        sessionDAO.setRedisManager(redisManager());
        return sessionDAO;
    }

    /**
     * 会话管理器
     */
    public DefaultWebSessionManager sessionManager(){
        CustomSessionManager sessionManager = new CustomSessionManager();
        sessionManager.setSessionDAO(redisSessionDAO());
        // 禁用cookie
//        sessionManager.setSessionIdCookieEnabled(false);
        // 禁用url重写
//        sessionManager.setSessionIdUrlRewritingEnabled(false);
        return sessionManager;
    }
    /**
     * 缓存管理器
     */
    public RedisCacheManager redisCacheManager(){
        RedisCacheManager redisCacheManager = new RedisCacheManager();
        redisCacheManager.setRedisManager(redisManager());
        return redisCacheManager;
    }

统一异常处理


  • 自定义的公共异常处理器
  • 声明异常处理器
  • 对异常统一处理
/**
 * @author aowei
 */
@ControllerAdvice
public class BaseExceptionHandler {
    @ExceptionHandler(value = AuthorizationException.class)
    @ResponseBody
    public String error(HttpServletRequest request, HttpServletResponse response,AuthorizationException exception){
        return "未授权";
    }
}

在这里插入图片描述

已标记关键词 清除标记
©️2020 CSDN 皮肤主题: 技术黑板 设计师:CSDN官方博客 返回首页