【Shiro】4. Spring Boot整合Shiro

ricochet 创作等级LV.4

整合思路

ShiroFilter会拦截所有请求，Shrio会判断哪些请求需要做认证和授权，哪些不需要做。

如果请求中访问的是系统的公共资源，则不需要进行认证和授权的操作，ShiroFilter直接放行即可。

如果请求中访问的是系统的受限资源，若第一次访问需要做认证，认证成功后，后续的访问进行授权。ShiroFilter依赖SecurityManager来完成认证和授权的具体操作，同时SecurityManager也依赖Realm来获取认证和授权的相应数据。

公共资源不需要认证和授权，任何用户都能访问。似于登录页面，注册页面。

受限资源是需要认证成功并赋予权限才能访问的资源。类似于系统主页，用户主页。

如果Shiro整合Spring Cloud，则将相应操作整合进Spring Cloud Gateway或者zuul即可。

20210928170338.png

整合Shiro实现认证

  1. pom.xml 中引入依赖

    <dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-spring-boot-starter</artifactId>
    <version>1.5.3</version>
</dependency>
复制代码

  2. 创建工厂工具类

    @Component
public class ApplicationContextUtils implements ApplicationContextAware {

    private static ApplicationContext context;

    // 工厂就是该方法的参数，当Spring Boot启动时，该参数就会接收到工厂
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        context = applicationContext;
    }

    // 根据Bean的名字获取工厂中指定对象
    public static Object getBean(String beanName) {
        return applicationContext.getBean(beanName);
    }

}
复制代码

    Realm不由Spring托管，所以无法自动注入Service对象，所以在创建Realm之前，需要创建一个获取工厂的工具类。

  3. 构建shiro包，在shiro包下构建realms包

  4. realms包中构建自定义Realm

    public class UserRealm extends AuthorizingRealm {

    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        return null;
    }

    // 认证操作
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        // 获取前端传入身份信息
        String username = (String) token.getPrincipal();

        // 从工厂中获取userService
        UserSerivce userSerivce = (UserSerivce) ApplicationContextUtils.getBean("userService");
        // 根据身份信息从DB中获取User
        User user = userSerivce.getUserByUsername(username);

        // 获取加密后的密码和Salt，Shiro自动进行认证
        if (user != null) {
            return new SimpleAuthenticationInfo(username, user.getPassword(), ByteSource.Util.bytes(user.getSalt()), this.getName());
        }

        return null;
    }

}
复制代码

    默认被Spring工厂托管的Bean的名字都是其类名首字母小写，也可以指定，比方说@Service("userService")。

  5. 创建Shiro配置类

    @Configuration
public class ShiroConfig {

    // 创建ShiroFilter
    @Bean
    public ShiroFilterFactoryBean getShiroFilterFactoryBean(DefaultWebSecurityManager defaultWebSecurityManager) {
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();

        // 给ShiroFilter注入SecurityManager
        shiroFilterFactoryBean.setSecurityManager(defaultWebSecurityManager);

        // 设置默认认证路径，认证失败后会调用该接口，也算是公共资源
        shiroFilterFactoryBean.setLoginUrl("/user/login");

        // 配置公共资源和受限资源
        Map<String, String> map = new HashMap<>();
        // anon是过滤器的一种，表示该资源是公共资源，需要设置在authc上面
        map.put("/user/register", "anon");
        map.put("/user/login", "anon");
        // authc是过滤器的一种，表示除了设置公共资源和默认认证路径之外所有资源是受限资源
        map.put("/**", "authc");

        shiroFilterFactoryBean.setFilterChainDefinitionMap(map);

        return shiroFilterFactoryBean;
    }

    // 创建具有Web特性的SecurityManager
    @Bean
    public DefaultWebSecurityManager getDefaultWebSecurityManager(@Qualifier("getRealm") Realm realm) {
        DefaultWebSecurityManager defaultWebSecurityManager = new DefaultWebSecurityManager();

        // 给SecurityManager注入Realm
        defaultWebSecurityManager.setRealm(realm);

        return defaultWebSecurityManager;
    }

    // 创建自定义Realm
    @Bean
    public Realm getRealm() {
        UserRealm userRealm = new UserRealm();

        // 设置Hash凭证校验匹配器，用来完成密码加密校验
        HashedCredentialsMatcher hashedCredentialsMatcher = new HashedCredentialsMatcher();
        // 设置加密算法MD5
        hashedCredentialsMatcher.setHashAlgorithmName("md5");
        // 设置散列次数1024
        hashedCredentialsMatcher.setHashIterations(1024);

        // 注入凭证校验匹配器
        userRealm.setCredentialsMatcher(hashedCredentialsMatcher);

        return userRealm;
    }

}
复制代码

    Spring在SecurityManager中注入自定义Realm时，因为工厂中已经有多个Realm，其中包括Shiro中的系统Realm和自定义Realm，所以不知道注入谁到SecurityManager中。我们需要指定下面getRealm方法创建的Realm，而getRealm方法创建的Bean的名字默认就是方法名getRealm，因此需要将getRealm放入@Qualifier中指定Bean的注入。

  6. 设计数据库

    user表中需要在基础上添加salt字段。

  7. 创建随机生成Salt的工具类

    public class SaltUtils {

    /**
     * 随机生成定长的Salt
     * @param n 长度
     * @return Salt
     */
    public static String getSalt(int n) {
        char[] chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789~!@#$%^&*()_+|{}:.,<>?/".toCharArray();
        
        StringBuilder stringBuilder = new StringBuilder();

        for (int i = 0; i < n; i++) {
            char c = chars[new Random().nextInt(chars.length)];
            stringBuilder.append(c);
        }

        return stringBuilder.toString();
    }
    
}
复制代码

  8. 创建Controller

    默认DB、MP和Service都已经配置并编写完毕。

    以下代码为了方便展示，将业务写在Controller中，实际开发时需要提取进Service。

    @RestController
@RequestMapping("/user")
public class UserContoller {

    @Autowired
    private UserService userService;

    @PostMapping("register")
    public Response register(@RequestBody UserRegisterDto userRegisterDto) {
        try {
            // 生成8位Salt
            String salt = SaltUtils.getSalt(8);
            // MD5 + Hash + Salt给密码加密
            Md5Hash md5Hash = new Md5Hash(userRegisterDto.getPassword(), salt, 1024);
            // 注册
            userService.register(userRegisterDto.getUsername(), md5Hash.toHex(), salt);
            // 注册成功
            return Response.ok().message("注册成功");
        } catch (Exception e) {
            return Response.error(ResponseEnum.UNIFIED_ERROR).message("注册失败");
        }
    }

    @PostMapping("login")
    public Response login(@RequestBody UserLoginDto userLoginDto) {
        Subject subject = SecurityUtils.getSubject();

        try {
            // 登录，Shiro自动认证
            subject.login(new UsernamePasswordToken(userLoginDto.getUsername(), userLoginDto.getPassword()));
            // 认证成功
            return Response.ok().message("登录成功");
        } catch (UnknownAccountException e) {
            return Response.error(ResponseEnum.UNKNOWN_ACCOUNT_ERROR);
        } catch (IncorrectCredentialsException e) {
            return Response.error(ResponseEnum.INCORRECT_CREDENTIALS_ERROR);
        }
    }

    @GetMapping("logout")
    public Response login() {
        Subject subject = SecurityUtils.getSubject();

        subject.logout();

        return Response.ok().message("退出成功");
    }

}
复制代码

    在Web环境中，只要Shiro配置类中配置了SecurityManager，那么Spring就会将其托管，无需在Controller中单独创建。

Shiro过滤器

Shiro提供多个默认的过滤器，我们可以用这些过滤器来配置控制指定URL的权限。

常用的有两种：anon和authc。

过滤器缩写过滤器功能
anonAnonymousFilter指定URL可以匿名访问，无需认证和授权
authcFormAuthenticationFilter指定URL需要form表单登录，默认会从请求中获取username，password , rememberMe等参数并尝试登录，如果登录不了就会跳转到setLoginUrl配置的认证路径。我们也可以用这个过滤器做默认的登录逻辑，但是一般都是我们自己在控制器写登录逻辑的，因为可以定制出错返回的信息。
authcBasicBasicHttpAuthenticationFilter指定URL需要basic登录
logoutLogoutFilter登出过滤器，配置指定URL就可以实现退出功能，非常方便
noSessionCreationNoSessionCreationFilter禁止创建会话
permsPermissionsAuthorizationFilter需要指定权限才能访问
portPortFilter需要指定端口才能访问
restHttpMethodPermissionFilter将http请求方法转化成相应的动词来构造一个权限字符串，这个感觉意义不大，有兴趣自己看源码的注释
rolesRolesAuthorizationFilter需要指定角色才能访问
sslSslFilter需要https请求才能访问
userUserFilter需要已登录或 "记住我" 的用户才能访问

整合Shiro实现授权

前文说了，Shiro提供了三种授权方式，在前后端分离的系统中，我们主要使用注解式实现授权。后端只负责写接口传递用户的权限信息，具体前台如何显示由前端负责。

1. @RequiresRoles注解

该注解标注在接口方法上，表示是指定的角色才可以访问该接口。

@GetMapping
@RequiresRoles("admin")
public Response findAll() {
    ...
}
复制代码

也可以设置多个角色，表示同时具有指定的所有角色才能访问该接口。

@GetMapping
@RequiresRoles("admin")
public Response findAll() {
    ...
}
复制代码

2. @RequiresPermissions注解

该注解标注在接口方法上，表示有指定访问权限才可以访问该接口。

@GetMapping
@RequiresPermissions("user:*:*")
public Response findAll() {
    ...
}
复制代码

也可以设置多个访问权限，表示同时具有指定的所有访问权限才能访问该接口。

@GetMapping
@RequiresPermissions(value = {"user:*:*", "product:*:*"})
public Response findAll() {
    ...
}
复制代码

3. 授权数据持久化

在实际项目中，权限数据需要在DB中获，因此我们要设计角色表和权限表。

通常情况下，一般是这样设计的：用户 <—（* *）—> 角色，角色 <—（* *）—> 权限，权限 <—（1 1）—> 资源

20210929162150.png

  1. 设计用户表

    20210929182304.png

  2. 设计角色表

    表结构：

    20210929175606.png

    数据案例：

    idrole
    1418430206598709249admin
    1418430206598709250user

  3. 设计权限表

    表结构：

    20210929175819.png

    permission为权限标识符，url为权限标识符对应的URL。

    数据案例：

    idpermissionurl
    1418430206598709251user:*:*
    1418430206598709252user:find:1418430206598709252

  4. 设计用户-角色表

    表结构：

    20210929180038.png

  5. 设计角色-权限表

    表结构：

    20210929180350.png

4. 授权流程

  1. 构建Role和Permission的Bean

    @Data
public class Role implements Serializable {
    
    private String id;
    
    private String role;
    
}
复制代码
    @Data
public class Permission implements Serializable {

    private String id;

    private String permission;

    private String url;

}
复制代码

    所有的Bean必须序列化，因为后文要将该Bean存入Redis。

  2. 在User类中添加角色集合

    @Data
public class User implements Serializable {

    private String id;

    private String username;

    private String password;

    private String salt;

    private List<String> roles;

}
复制代码

  3. 在Role类中添加权限集合

    @Data
public class Role implements Serializable {
    
    private String id;
    
    private String role;
    
    List<Permission> permissions;
    
}
复制代码

  4. 在UserMapper和UserService中提供通过username查询单个用户的角色集合的接口

    具体使用逻辑实现使用MP或者Mybatis不同，自行选择即可。

    List<Role> getRolesByUsername(String username);
复制代码

  5. 在UserMapper和UserService中提供通过role_id查询单个角色的权限集合的接口

    List<Permission> getPermissionsByRoleId(String roleId);
复制代码

    具体使用逻辑实现使用MP或者Mybatis不同，自行选择即可。

  6. 整合Realm中授权的方法

    public class UserRealm extends AuthorizingRealm {

    // 授权操作
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        // 获取身份信息
        String username = (String) principals.getPrimaryPrincipal();

        // 从工厂中取出UserService
        UserService userService = (UserService) ApplicationContextUtils.getBean("userService");

        // 注入该角色的角色和权限
        List<Role> roles = userService.getRolesByUsername(username);
        if (roles != null) {
            SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
            roles.forEach(role -> {
                // 注入角色
                simpleAuthorizationInfo.addRole(role.getRole());

                // 获取权限集合
                List<Permission> permissions = userService.getPermissionsByRoleId(role.getId());
                // 也可以使用该方法判断集合是否不为空
                if (!CollectionUtils.isEmpty(permissions)) {
                    permissions.forEach(permission -> {
                        // 注入权限
                        simpleAuthorizationInfo.addStringPermission(permission.getPermission());
                    });
                }
            });
            return simpleAuthorizationInfo;
        }
        
        return null;
    }

    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        // 获取前端传入身份信息
        String username = (String) token.getPrincipal();

        // 获取userService
        UserSerivce userSerivce = (UserSerivce) ApplicationContextUtils.getBean("userService");
        // 根据身份信息从DB中获取User
        User user = userSerivce.getUserByUsername(username);

        // 获取加密的密码和Salt，Shiro自动进行认证
        if (user != null) {
            return new SimpleAuthenticationInfo(username, user.getPassword(), ByteSource.Util.bytes(user.getSalt()), this.getName());
        }

        return null;
    }

}
复制代码

  7. 给Controller接口添加角色

    @GetMapping("info")
@RequiresRoles(value = {"admin", "user"})
public Response info() {
    ...
}
复制代码

  8. 给Controller接口添加权限

    @GetMapping("info")
@RequiresPermissions(value = {"user:find:*", "admin:*:*"})
public Response info() {
    ...
}
复制代码

整合Redis实现缓存

在前后端实际开发中，我们会大量使用注解来控制权限。在每一次执行认证或授权的操作时，Shiro都会去DB中查询身份或者权限信息。已知，身份信息和权限信息是不会经常变动的，且十分繁杂。如果同时有很多用户对系统做操作，每一次操作Shiro都需要去DB中查询身份或权限，无疑增加了数据库的压力，耗费了大量的计算资源。

为了避免上述问题，我们在设计身份和权限时，都会添加缓存。

所谓缓存，就是如果系统对该用户已经认证或授权过一次，就把该用户的身份信息或权限信息给缓存起来，当改用户再次做认证或者授权时，Shiro直接去缓存中获取给用户的身份信息和权限信息。

1. 实现流程

Shiro中提供了CacheManager作为缓存管理器，具体实现流程如下

20210930101858.png

2. 具体实现

Shiro默认的缓存为EhCache，只能实现本地缓存，如果应用服务器宕机，则缓存数据丢失。在实际生产实践中，一般都配合Redis实现分布式缓存，缓存数据独立于应用服务器之外，提高数据的安全性。

本文就不再阐述Shiro与EhCache的整合了，直接整合Redis。

  1. pom.xml 中引入依赖

    <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
复制代码

  2. 在 application.yml 中配置Redis

    Spring:
  ...
  # Redis配置
  redis:
    port: 6379
    host: localhost
    database: 0
复制代码

  3. 在shiro包中创建cache包

  4. 在cache包中创建Redis缓存管理器

    public class RedisCacheManager implements CacheManager {

    // 每次执行缓存时，都会调用该方法，自动注入s 
    // 参数s为在ShiroConfig中设置的认证缓存或授权缓存的名字
    @Override
    public <K, V> Cache<K, V> getCache(String s) throws CacheException {
        // 自动去RedisCahce中找具体实现
        return new RedisCache<K, V>(s);
    }
    
}
复制代码

    Shiro中提供了一个全局缓存管理器接口CacheManager，如果要实现自定义缓存管理器，必须要让自定义缓存管理器实现CacheManager接口。

  5. 在cache包中创建Reids缓存

    public class RedisCache<K, V> implements Cache<K, V> {

    // 认证缓存或者授权缓存名名字
    private String cacheName;

    public RedisCache() {

    }

    public RedisCache(String cacheName) {
        this.cacheName = cacheName;
    }

    // 获取RedisTemplate实例
    private RedisTemplate getRedisTemplate() {
        // 从工厂中取出RedisTemplate实例
        RedisTemplate redisTemplate = (RedisTemplate) ApplicationContextUtils.getBean("redisTemplate");
        // 将Key的序列化规则设置为字符串
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        // 将Hash中field的序列化规则设置为字符串
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());

        return redisTemplate;
    }

    // 获取缓存
    @Override
    public V get(K k) throws CacheException {
        return (V) getRedisTemplate().opsForHash().get(this.cacheName, k.toString())
    }

    // 存入缓存
    @Override
    public V put(K k, V v) throws CacheException {
        getRedisTemplate().opsForHash().put(this.cacheName, k.toString(), v);

        return null;
    }

    // 删除缓存
    @Override
    public V remove(K k) throws CacheException {
        return (V) getRedisTemplate().opsForHash().delete(this.cacheName, k.toString());;
    }

    // 清空所有缓存
    @Override
    public void clear() throws CacheException {
        getRedisTemplate().delete(this.cacheName);
    }

    // 缓存数量
    @Override
    public int size() {
        return getRedisTemplate().opsForHash().size(this.cacheName).intValue();
    }

    // 获取所有Key
    @Override
    public Set<K> keys() {
        return getRedisTemplate().opsForHash().keys(this.cacheName);
    }

    // 获取所有Value
    @Override
    public Collection<V> values() {
        return getRedisTemplate().opsForHash().values(this.cacheName);
    }

}
复制代码

    CacheManager底层真正实现缓存的是Cache<K，V>，因此还需要创建一个RedisCache才能真正实现自定义缓存，RedisCache同样要实现Cache接口。

    RedisCache中所有接口全部使用Redis来实现，从而实现Shiro与Redis的整合，至于什么时候调用RedisCache中的什么接口，由Shiro来决定，我们只需定义即可。

    Redis对于Shiro身份和权限的管理使用的数据结构是Hash，Key对应cacheName，field对应k，value对应v。

  6. 在ShiroConfig中配置缓存管理器

    @Configuration
public class ShiroConfig {

    // 创建ShiroFilter
    @Bean
    public ShiroFilterFactoryBean getShiroFilterFactoryBean(DefaultWebSecurityManager defaultWebSecurityManager) {
        ...
    }

    // 创建具有Web特性的SecurityManager
    @Bean
    public DefaultWebSecurityManager getDefaultWebSecurityManager(@Qualifier("getRealm") Realm realm) {
        ...
    }

    // 创建自定义Realm
    @Bean
    public Realm getRealm() {
       	...

        // 注入缓存管理器
        userRealm.setCacheManager(new RedisCacheManager());
        // 开启全局缓存
        userRealm.setCachingEnabled(true);
        // 开启认证缓存，并命名（真实的认证缓存名为cacheName）
        userRealm.setAuthenticationCachingEnabled(true);
        userRealm.setAuthenticationCacheName("authenticationCache");
        // 开启授权缓存，并命名（真实的授权缓存名为完整包名+cacheName）
        userRealm.setAuthorizationCachingEnabled(true);
        userRealm.setAuthorizationCacheName("authorizationCache");

        return userRealm;
    }

}
复制代码

  7. 序列化和反序列化Salt

    按照上文的配置方式，Salt是直接被ByteSource存储，没有被序列化的。

    // 获取加密的密码和Salt，Shiro自动进行认证
if (user != null) {
    return new SimpleAuthenticationInfo(username, user.getPassword(), ByteSource.Util.bytes(user.getSalt()), this.getName());
}
复制代码

    在Shiro认证过程中，Salt也要随着Username和Password一起被存入缓存。Username和Password被String序列化和反序列化，而Salt（ByteSource）也需要进行序列化和反序列化。

    在shiro包中创建salt包，在salt包中创建能够被Redis序列化和反序列化ByteSource

    public class MyByteSource implements ByteSource, Serializable {

    private byte[] bytes;
    private String cachedHex;
    private String cachedBase64;

    public MyByteSource() {

 }

 public MyByteSource(byte[] bytes) {
        this.bytes = bytes;
    }

    public MyByteSource(char[] chars) {
        this.bytes = CodecSupport.toBytes(chars);
    }

    public MyByteSource(String string) {
        this.bytes = CodecSupport.toBytes(string);
    }

    public MyByteSource(ByteSource source) {
        this.bytes = source.getBytes();
    }

    public MyByteSource(File file) {
        this.bytes = (new MyByteSource.BytesHelper()).getBytes(file);
    }

    public MyByteSource(InputStream stream) {
        this.bytes = (new MyByteSource.BytesHelper()).getBytes(stream);
    }

    public static boolean isCompatible(Object o) {
        return o instanceof byte[] || o instanceof char[] || o instanceof String || o instanceof ByteSource || o instanceof File || o instanceof InputStream;
    }

    @Override
    public byte[] getBytes() {
        return this.bytes;
    }

    @Override
    public boolean isEmpty() {
        return this.bytes == null || this.bytes.length == 0;
    }

    @Override
    public String toHex() {
        if (this.cachedHex == null) {
            this.cachedHex = Hex.encodeToString(this.getBytes());
        }

        return this.cachedHex;
    }

    @Override
    public String toBase64() {
        if (this.cachedBase64 == null) {
            this.cachedBase64 = Base64.encodeToString(this.getBytes());
        }

        return this.cachedBase64;
    }

    @Override
    public String toString() {
        return this.toBase64();
    }

    @Override
    public int hashCode() {
        return this.bytes != null && this.bytes.length != 0 ? Arrays.hashCode(this.bytes) : 0;
    }

    @Override
    public boolean equals(Object o) {
        if (o == this) {
            return true;
        } else if (o instanceof ByteSource) {
            ByteSource bs = (ByteSource)o;
            return Arrays.equals(this.getBytes(), bs.getBytes());
        } else {
            return false;
        }
    }

    private static final class BytesHelper extends CodecSupport {
        private BytesHelper() {
        }

        public byte[] getBytes(File file) {
            return this.toBytes(file);
        }

        public byte[] getBytes(InputStream stream) {
            return this.toBytes(stream);
        }
    }

}
复制代码

    注意，不能将MyByteSource继承SimpleByteSource，因为SimpleByteSource没有无参构造，因此只能实现序列化而不能实现反序列化，因为Salt被Redis反序列化时，需要调用MyByteSource的无参构造，因此MyByteSource只能实现ByteSource。

    修改认证时使用的ByteSource

    // 获取加密的密码和Salt，Shiro自动进行认证
if (user != null) {
    return new SimpleAuthenticationInfo(username, user.getPassword(), new MyByteSource(user.getSalt()), this.getName());
}
复制代码
分类：
后端
标签：
Shiro后端

友情链接：

ricochet 创作等级LV.4
Java后端开发工程师 @ 汉得信息
私信
获得点赞
文章被阅读