其他分享
首页 > 其他分享> > Shiro

Shiro

作者：互联网

Shiro

Maven依赖：

<!-- 项目依赖，根据情况二选一 -->
<!-- 普通项目 -->
<dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-core</artifactId>
</dependency>
<!-- SpringBoot整合 -->
<dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-spring-boot-starter</artifactId>
</dependency>
​
<!-- 缓存依赖，根据情况二选一，第二种是在springboot -->
<!-- shiro的默认缓存ehcache -->
<dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-ehcache</artifactId>
</dependency>
<!-- redis整合springboot -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
​

1.核心架构

核心为Security Manager，几乎所有功能均为其实现。

Cryptography：密码生成器，封装好了相应算法，用于对密码加密。SHA256、MD5等。一般采用MD5做哈希散列。

2.认证流程

主体（Subject）将身份信息（Principal）和凭证信息（Credential）传给shiro，shiro将其封装为token，token通过Security Manager进行验证（调用Authenticator，Authenticator调用Realm）。

2.1.基本Demo示例

核心代码：

// 1.创建安全管理器
DefaultSecurityManager securityManager = new DefaultSecurityManager();
​
// 2.给安全管理器设置Realm
securityManager.setRealm(new IniRealm("classpath:shiro.ini"));
​
// 3.SecurityUtils 给全局安全工具类设置安全管理器
SecurityUtils.setSecurityManager(securityManager);
​
// 4.关键对象 subject 主体
Subject subject = SecurityUtils.getSubject();
​
// 5.创建令牌
UsernamePasswordToken token = new UsernamePasswordToken("xiaochen", "123456");
​
// 6.用户认证
try {
    //System.out.println("用户认证前状态：" + subject.isAuthenticated());
    subject.login(token);
    //System.out.println("用户认证后状态：" + subject.isAuthenticated());
} catch (Exception e) {
    e.printStackTrace();
}

ps：login认证失败时，若为无当前账户会报UnknownAccountException，否则密码错误会报IncorrectCredentialsException。

3.2.主要源码解析

最终执行用户名比较是SimpleAccountRealm的doGetAuthenticationInfo方法，完成用户名校验。最终密码校验是在AuthenticatingRealm中的assertCredentialsMatch方法（SimpleCredentialsMatcher的doCredentialsMatch方法，拿到token和account的credentials后默认equal比较，后面需要修改为密码比较方法）。（重写Realm，需要我们实现doGetAuthenticationInfo方法，而密码不需要我们实现。）

AuthenticatingRealm中doGetAuthenticationInfo方法认证realm，AuthorizingRealm中doGetAuthorizationInfo方法授权realm。

3.3.自定义realm

实现AuthorizingRealm抽象类doGetAuthenticationInfo方法和doGetAuthorizationInfo方法。

  1. doGetAuthenticationInfo方法实现

可返回SimpleAuthenticationInfo或者SimpleAccount。

返回null，login时报UnknownAccountException；返回空参SimpleAuthenticationInfo，login时报AuthenticationException。

举例实现：

/**
 * 认证
 * @param authenticationToken
 * @return
 * @throws AuthenticationException
 */
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
​
    // 在token中获取用户名
    String principal = (String) authenticationToken.getPrincipal();
​
    // 根据身份信息使用jdbc mybatis查询相关数据库
    if ("xiaochen".equals(principal)) {
        // 参数1数据库中正确的用户名 参数2数据库中的正确密码 参数3当前realm的名字
        SimpleAuthenticationInfo simpleAuthenticationInfo = new SimpleAuthenticationInfo(principal, "123", this.getName());
        return simpleAuthenticationInfo;
    }
    
    return null;
}

  1. 密码加密

AuthenticatingRealm的credentialsMatcher属性为比较方法，默认equals，可以通过realm的setCredentialsMatcher方法进行设置，可设置以下凭证匹配器：

以下，实现对密码进行MD5+salt+hash散列存储（salt默认拼接在原字符串后面；hash散列默认1次，一般设置为1024或者2048次)：

// 新建hash凭证匹配器
HashedCredentialsMatcher hashedCredentialsMatcher = new HashedCredentialsMatcher();
// 设置算法
hashedCredentialsMatcher.setHashAlgorithmName("md5");
// 设置realm使用hash凭证匹配器
realm.setCredentialsMatcher(hashedCredentialsMatcher);

添加随机盐（随机盐保存至数据库，以下举例耦合死）需要在自定义realm当中，对返回的AuthenticationInfo设置credentialsSalt，即在第三个参数添加盐值，添加方法举例如下：

SimpleAuthenticationInfo simpleAuthenticationInfo = new SimpleAuthenticationInfo(principal,
                    "c15be9a15a0a238084e0c5a846f3a7b4",
                    ByteSource.Util.bytes("x0*7ps"), // 盐值
                    this.getName());

调用hash凭证匹配器的setHashIterations方法进行设置。

hashedCredentialsMatcher.setHashIterations(1024);

ps：shiro集成了获得md5加密后的值的算法，如下：

// 参数1加密明文，参数2盐，参数3散列次数
Md5Hash md5Hash = new Md5Hash("123", "x0*7ps", 1024);
// toHex 转为String
System.out.println(md5Hash.toHex());

3.授权流程

在完成shiro鉴权之后，就可进行授权了。

  1. 授权的关键对象：

  1. 授权方式：

if (subject.hasRole("admin")) {
    // 操作什么资源
}
if (subject.isPermission("user:update:01")) { // 资源实例
    // 对01用户进行修改
}
if (subject.isPermission("user:update:*")) { // 资源类型
    // 对所有用户进行修改
}

ps：权限字符串规则是资源标识符:操作:资源实例标识符，意思是对哪个资源的那个实例有什么操作。

  1. 实现方式

if (subject.hasRole("admin")) {
    // 有权限
} else {
    // 无权限
}
@RequiredRoles("admin")
public void hello() {
    // TODO 实现方法
}
<!- JSP/GSP标签：在JSP/GSP页面通过相应的标签完成 ->
<shiro:hasRole name="admin">
    <!- 有权限 ->
</shiro:hasRole>
<!- ps：Thymeleaf中使用shiro需要额外集成！->

3.1.Demo示例

  1. realm授权

在realm的doGetAuthorizationInfo方法中，返回AuthorizationInfo。

示例代码：

@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
    String primaryPrincipal = (String) principalCollection.getPrimaryPrincipal();
​
    // 根据身份信息获取当前的角色信息，以及权限信息
    SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
​
    // 将数据库中查询角色信息赋值给权限对象
    // 假设这里xiaochen有admin、user角色信息
    simpleAuthorizationInfo.addRole("admin");
    simpleAuthorizationInfo.addRole("user");
​
    simpleAuthorizationInfo.addStringPermission("user:*:01");
    simpleAuthorizationInfo.addStringPermission("product:create");
    
    return simpleAuthorizationInfo;
​
}

  1. 核心代码鉴权

// 认证用户进行授权
if (subject.isAuthenticated()) {
    // 1.基于角色权限控制
    // 单角色
    System.out.println(subject.hasRole("admin"));
    // 多角色所有
    System.out.println(subject.hasAllRoles(Arrays.asList("admin", "user")));
    // 多角色某个
    boolean[] booleans = subject.hasRoles(Arrays.asList("admin", "super", "user"));
    for (boolean aBoolean : booleans) {
        System.out.println(aBoolean);
    }
​
    // 2.基于权限字符串的访问控制 资源标识符:操作:资源类型
    // 单个
    System.out.println(subject.isPermitted("user:update:01"));
    System.out.println(subject.isPermitted("product:update"));
    // 同时
    System.out.println(subject.isPermittedAll("user:*:01", "order:*:10"));
    // 分别
    boolean[] permitted = subject.isPermitted("user:*:01", "order:*:10");
    for (boolean b : permitted) {
        System.out.println(b);
    }
}

4.SpringBoot整合

4.1.项目权限管理流程

SpringBoot项目关键加入拦截器ShiroFilter。请求发出，ShiroFilter进行拦截，依赖SecurityManager进行认证，对资源进行相应访问。

 

 

4.2.Demo示例

首选需要创建自定义Realm，在这里面做我们的认证（登录鉴权）授权规则。随后，设置Shiro配置，主要完成ShiroFilter、SecurityManager、Realm的创建并交给Spring工厂管理。以后的应用就可以设定相应规则来进行鉴权。

具体权限一般保存至数据库之中，一般按照用户<->角色<->权限<->资源进行设计（以下代码示例均通过数据库访问来赋权/鉴权/认证）。

4.2.1.自定义Realm

示例如下：

/**
 * 自定义realm
 */
public class CustomerRealm extends AuthorizingRealm {
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        // 获取身份信息
        String primaryPrincipal = (String) principalCollection.getPrimaryPrincipal();
​
        UserService userService = (UserService) ApplicationContextUtils.getBean("userService");
        List<Role> roles = userService.findRolesByUsername(primaryPrincipal);
​
        // 赋值授权角色
        if (!CollectionUtils.isEmpty(roles)) {
            SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
            roles.forEach(role -> {
                
                // 赋值角色信息
                simpleAuthorizationInfo.addRole(role.getName());
​
                // 赋值权限信息
                List<Perms> perms = userService.findPermsByRoleId(role.getId());
                if (!CollectionUtils.isEmpty(perms)) {
                    perms.forEach(perm -> {
                        simpleAuthorizationInfo.addStringPermission(perm.getName());
                    });
                }
​
            });
            return simpleAuthorizationInfo;
        }
        
        return null;
    }
​
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        String principal = (String) authenticationToken.getPrincipal();
​
        // 在工厂中获取service对象
        UserService userService = (UserService) ApplicationContextUtils.getBean("userService");
​
        User user = userService.findByUsername(principal);
​
        if (!ObjectUtils.isEmpty(user)) {
            return new SimpleAuthenticationInfo(user.getUsername(), user.getPassword(), new MySimpleByteSource(user.getSalt()), this.getName());
        }
​
        return null;
    }
}
​

示例与普通项目类似，但存在两点区别：1.自定义realm并未交给Spring工厂管理，获取bean时自己实现了ApplicationContextUtils.getBean()，详情参见其它。2.原本的shiro自带的用于加盐的ByteSource牵涉到使用Redis缓存时序列化问题，不可用，自己实现了MySimpleByteSource，详情参见其它。

4.2.2.ShiroConfig

示例代码：

/**
 * 用来整合shiro框架相关配置类
 */
@Configuration
public class ShiroConfig {
​
    // 1.创建ShiroFilter，负责拦截所有请求
    @Bean
    public ShiroFilterFactoryBean getShiroFilterFactoryBean(DefaultWebSecurityManager defaultWebSecurityManager) {
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
​
        // 给filter设置安全管理器
        shiroFilterFactoryBean.setSecurityManager(defaultWebSecurityManager);
​
        // 配置系统受限资源
        Map<String, String> map = new HashMap<>();
        map.put("/user/login", "anon");
        map.put("/user/register", "anon");
        map.put("/register.jsp", "anon");
        map.put("/**", "authc");
​
        // 默认认证界面路径
        shiroFilterFactoryBean.setLoginUrl("/login.jsp");
​
        shiroFilterFactoryBean.setFilterChainDefinitionMap(map);
​
        return shiroFilterFactoryBean;
    }
​
    // 2.创建安全管理器
    @Bean
    public DefaultWebSecurityManager getDefaultWebSecurityManager(Realm realm) {
        DefaultWebSecurityManager defaultWebSecurityManager = new DefaultWebSecurityManager();
​
        // 给安全管理器设置realm
        defaultWebSecurityManager.setRealm(realm);
​
        return defaultWebSecurityManager;
    }
​
    // 3.创建自定义realm
    @Bean
    public Realm getRealm() {
        CustomerRealm customerRealm = new CustomerRealm();
        
        // 修改凭证校验匹配器
        HashedCredentialsMatcher hashedCredentialsMatcher = new HashedCredentialsMatcher();
        hashedCredentialsMatcher.setHashAlgorithmName("Md5");
        hashedCredentialsMatcher.setHashIterations(1024);
        customerRealm.setCredentialsMatcher(hashedCredentialsMatcher);
​
        // 开启缓存管理 Redis
        customerRealm.setCacheManager(new RedisCacheManager());
​
        customerRealm.setCachingEnabled(true); // 开启全局缓存
        customerRealm.setAuthenticationCachingEnabled(true); // 开启认证缓存
        customerRealm.setAuthorizationCachingEnabled(true); // 开启授权缓存
        customerRealm.setAuthenticationCacheName("authenticationCache"); // 设置缓存在内存的名字，不设置默认为当前realm+.authentication
        customerRealm.setAuthorizationCacheName("authorizationCache");
​
        return customerRealm;
    }
​
​
}

spring-boot-shiro的ShiroFilter依赖SecurityManager，SecurityManager依赖Realm。

对于Realm，配置为自定义CustomerRealm，与凭证校验匹配器修改普通项目类似，不同的是使用了缓存管理。shiro默认的缓存管理为EhCache，为是本地缓存，即在应用内部缓存，当前应用停止/宕机等，依然会重查数据库，不符合现实需求。所以，这里我使用了Redis（如果依旧使用EhCache只需将customerRealm.setCacheManager(new RedisCacheManager())改为customerRealm.setCacheManager(new EhCacheManager())）。RedisCacheManager为自己实现，需要实现CacheManager接口，其中getCache方法，需要返回Cache，这里也是自己实现RedisCache。RedisCache需要实现Cache接口，其中get方法实现从redis中获取值；put方法实现填入值到redis；remove在用户logout时调用，清理缓存；clear为清理所有缓存……

/**
 * 自定义shiro缓存管理器
 */
public class RedisCacheManager implements CacheManager {
​
    /**
     *
     * @param cacheName 认证或者授权缓存的统一名称
     * @return
     * @param <K>
     * @param <V>
     * @throws CacheException
     */
    @Override
    public <K, V> Cache<K, V> getCache(String cacheName) throws CacheException {
        return new RedisCache<>(cacheName);
    }
}
​
/**
 * 自定义redis缓存的实现
 */
public class RedisCache<K, V> implements Cache<K, V> {
​
    private String cacheName;
​
    public RedisCache() {
    }
​
    public RedisCache(String cacheName) {
        this.cacheName = cacheName;
    }
​
    @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();
    }
​
    @Override
    public Set<K> keys() {
        return getRedisTemplate().opsForHash().keys(this.cacheName);
    }
​
    @Override
    public Collection<V> values() {
        return getRedisTemplate().opsForHash().values(this.cacheName);
    }
​
    private RedisTemplate getRedisTemplate() {
        RedisTemplate redisTemplate = (RedisTemplate) ApplicationContextUtils.getBean("redisTemplate");
        // 修改key的序列化方式为String方式
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        return redisTemplate;
    }
​
}

ps：Ehcache为应用缓存，导入依赖即可使用，Redis需要开启服务并做相应配置才可使用。

对于安全管理器SecurityManager，这里是Web项目，实现的是DefaultWebSecurityManager。

对于ShiroFilter，设置安全管理器、配置系统受限资源。

其它

  1. shiro配置文件以.ini结尾（.ini文件一般作为Windows操作系统中的配置文件）,.ini结尾文件类似.txt结尾文件。.ini文件可以写一些复杂数据格式。shiro配置文件放在resources下及其子目录下都行。在学习shiro中，这里.ini文件用来写权限信息等，真实场景在数据库中，这里是减少学习成本才使用.ini文件的。

  2. 常用shiro默认过滤器简写

    • anon(AnonymousFilter)：过滤器允许立即访问路径而不执行任何类型的安全检查，用于公共资源。

    • authc(FormAuthenticationFilter)：需要对请求用户进行身份验证才能继续请求，如果不是，则重定向到配置的URL强制用户登录。

    • perms(PermissionsAuthorizationFilter)：如果当前用户具有映射值指定的权限，则过滤器允许访问，如果用户没有指定的所有权限，则拒绝访问。

    • roles(RolesAuthorizationFilter)：如果当前用户具有映射值指定的角色，则允许访问；如果用户没有指定的所有角色，则拒绝访问。

  3. shiro项目重启，shiro缓存依然会重新加载，上次未退出的用户依然未退出。

  4. 默认认证界面URL为/login.jsp，可通过ShiroFilterFactoryBean的setLoginUrl方法进行设置。

  5. 设置/**为authc时，需要在其前面设置认证请求的url为anon，如/user/login（除认证页面，其他页面访问不到），否则永远无权。

  6. 可以在方法上添加@RequiresRoles("admin") 或@RequiresPermissions("user:update:01")来限制主体对方法的调用，值可设为value = {“admin”, "user"}多个值，都具有才能调用。@RequiresRoles与@RequiresPermissions同时标注时需要同时具有权限。（上述无权会报AuthorizationException）

  7. shiro在每次鉴权时都要调用doGetAuthorizationInfo，可设置缓存防止多次从数据库查询权限影响效率。

  8. Redis缓存相关问题

    1. 在对密码加盐时使用了ByteSource，其使用了SimpleByteSource，无法序列化，需要我们自己实现。实现方法，照搬SimpleByteSource并实现接口Serializable，并添加无参构造（反序列化需要使用）。

    2. 在对Redis缓存时，SimpleAuthenticationInfo和AuthorizationInfo都会缓存，认证时先缓存SimpleAuthenticationInfo，授权时缓存AuthorizationInfo，需要使用hash存而不是string，否则后者覆盖前者，会报类型无法转换错误。

    3. （待解决）AuthorizingRealm.setAuthorizationCacheName()使用无效。

标签：缓存,return,Shiro,new,public,shiro,user
来源： https://www.cnblogs.com/meyok/p/16526213.html