博客

shiro简介

什么是shiro

Shiro是一个强大且易用的Java安全框架，执行身份验证、授权、密码和会话管理。Shiro是Apache软件基金会的一个开源项目。Shiro可以轻松地保护任何应用程序，从命令行应用程序到最大的企业Web应用程序。

shiro三大主体

Shiro的三大主体分别是Subject、SecurityManager、Realm。

Subject

：主体，代表了当前“用户”，这个用户不一定是一个具体的人，与当前应用交互的任何东西都是Subject，如网络爬虫，机器人等；所有Subject都绑定到SecurityManager上，与Subject的所有交互都会委托给SecurityManager；可以把Subject认为是一个门面；

Subject中比较常用的方法为：

SecurityManager

：安全管理器；即所有与安全有关的操作都会与SecurityManager交互；且它管理着所有Subject；可以看出它是Shiro框架的核心，它负责与后边介绍的其他组件进行交互，如果学习过SpringMVC，你可以把它看成DispatcherServlet前端控制器。

SecurityManager提供了以下常用方法：

Realm

：域，Shiro从从Realm获取安全数据（如用户、角色、权限），就是说SecurityManager要验证用户身份，那么它需要从Realm获取相应的用户进行比较以确定用户身份是否合法；也需要从Realm得到用户相应的角色/权限进行验证用户是否能进行操作；可以把Realm看成DataSource，即安全数据源。

shiro的引入

<dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-all</artifactId>
    <version>1.10.0</version>
</dependency>

springboot整合shiro的基本配置

@Configuration
public class ShiroConfig {
@Bean
public ShiroFilterFactoryBean shiroFilterFactoryBean(SecurityManager securityManager) {
    ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
    shiroFilterFactoryBean.setSecurityManager(securityManager);//设置安全管理器
    shiroFilterFactoryBean.setLoginUrl("/login");//默认登录的页面
    shiroFilterFactoryBean.setSuccessUrl("/index");//登录成功返回的页面
    shiroFilterFactoryBean.setUnauthorizedUrl("/403");//没有权限访问的页面
    //设置
    Map<String, String> filterChainDefinitionMap = new LinkedHashMap<>();
    filterChainDefinitionMap.put("/static/**", "anon");
    filterChainDefinitionMap.put("/authc/**", "authc");
    filterChainDefinitionMap.put("/**", "user");
    shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);
    return shiroFilterFactoryBean;
}

@Bean
public SecurityManager getSecurityManager(Realm realm) {
    DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
    securityManager.setRealm(realm);
    return securityManager;
}

@Bean
public ShiroRealm getRealm() {
    return new ShiroRealm();
}

}

springboot在整合shiro中是固定的三个步骤,首先就是要先创建一个ShiroFilterFactoryBean来设置SecurityManager以及过滤器，再创建一个SecurityManager的bean来设置Realm，之后在把自己自定义的Realm设置成bean。其中有一点需要注意的就是在设置

ShiroFilterFactoryBean

中的

filterChainDefinitionMap

的过滤链的时候最好使用

LinkedHashMap

，要是使用

HashMap

的话可能会出现一些问题。

shiro中常用的Filter

shiro的常用的系统自定义的Filter根据不同的设置来调用不同的过滤器，如下所示：

shiro在DefaultFilter这个枚举类之中所定义的各种各样的过滤器，其中最常用的也就是authc，anon，在登出的时候或许也会设置logout这个过滤器，而这些过滤器也就是在设置

ShiroFilterFactoryBean

中的setFilterChainDefinitionMap方法过滤链所用到的。当然也可以自定义实现shiro中的过滤器，通常来说，在自定义实现过滤器都是继承的FormAuthenticationFilter或者AuthenticatingFilter这个类进行。但是自定义过滤器一般是加入一些其他的东西才会用到，比如用jwt所生成的token来代替shiro自带的。

自定义Realm

Shiro不是直接处理身份验证和权限控制的，而是通过与应用程序集成的Realm实现。Realm是Shiro身份验证和授权查询的后端数据源，它们通常与本地数据存储库（例如数据库）或远程数据存储库（例如LDAP）一起工作。Shiro具有一组默认的Realm，但您可以选择编写自定义Realm以处理自己的身份验证和授权数据源。

自定义Realm可以满足具体的业务需求，例如：

1. 集成不同类型的数据源：Shiro默认支持JDBC和LDAP等数据源，但是如果您的应用程序需要使用其他类型的数据源（例如NoSQL数据库或REST API），则需要编写自定义Realm。

2. 更好的性能：默认Realm需要处理大量权限控制逻辑，如果您想要更好的性能表现，则自定义Realm可以优化访问控制逻辑。

3. 更好的安全性：默认Realm中的身份验证和授权逻辑是通用的，可能存在一些风险，自定义Realm可以根据具体的业务情况定制相应的安全策略。

需要注意的是，自定义Realm需要自己编写相应的身份验证和授权逻辑，并与应用程序进行整合。

public class ShiroRealm implements AuthorizingRealm {
    @Override
public String getName() {
    return "ShiroRealm";
}
//判断当前Realm是否支持某种类型的Token
@Override
public boolean supports(AuthenticationToken token) {
    return token instanceof UsernamePasswordToken;
}
//认证
@Override
public AuthenticationInfo getAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
    String username = (String) token.getPrincipal();
    String password = new String((char[]) token.getCredentials());
    // 根据用户名和密码查询用户信息
    User user = userService.getUserByUsernameAndPassword(username, password);
    if (user == null) {
        throw new UnknownAccountException("用户名或密码错误");
    }
    SimpleAuthenticationInfo authenticationInfo = new SimpleAuthenticationInfo(user.getUsername(), user.getPassword(), getName());
    return authenticationInfo;
}
//授权
@Override
public AuthorizationInfo getAuthorizationInfo(PrincipalCollection principals) {
    String username = (String) principals.getPrimaryPrincipal();
    // 根据用户名查询用户角色和权限信息
    Set<String> roles = userService.getRolesByUsername(username);
    Set<String> permissions = userService.getPermissionsByUsername(username);
    SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
    authorizationInfo.setRoles(roles);
    authorizationInfo.setStringPermissions(permissions);
    return authorizationInfo;
}
}

AuthorizingRealm是Shiro所提供的一个基于权限控制的Realm实现，它也是Shiro推荐的默认实现方式。与其他的Realm不同的是，AuthorizingRealm不仅仅具有验证身份的功能，还能通过实现doGetAuthorizationInfo()方法来完成授权操作，即根据用户的角色、权限等信息来决定用户是否拥有访问某个资源的权限。因此，如果开发者需要在自定义Realm中实现授权功能，那么继承AuthorizingRealm是一个非常合适的选择。同时，Shiro也为开发者提供了其他的Realm实现，例如：JdbcRealm、IniRealm等等，可以根据具体业务需求来选择使用。

shiro使用redis做缓存

在pom.xml文件中添加以下依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

在引入redis的依赖之后则需要配置这三项：

spring.data.redis.host=localhost
spring.data.redis.port=6379
spring.data.redis.database=0

如果redis有密码的话，则需要通过

spring.data.redis.password

来配置密码进行连接。之后则是要来自定义自己的Cache和CacheManager进行操作。

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 {
        System.out.println("get = " + k);
        return (v) getRedisTemplate().opsForHash().get(this.CacheName,k.toString());
    }

    @Override
    public v put(k k, v v) throws CacheException {
        System.out.println("k = " + k+",v="+v);
        getRedisTemplate().opsForHash().put(this.CacheName,k.toString(),v);
        return null;
    }

    @Override
    public v remove(k k) throws CacheException {
         getRedisTemplate().opsForHash().delete(this.CacheName,k);
        return null;
    }

    @Override
    public void clear() throws CacheException {
        getRedisTemplate().opsForHash().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);
    }
    public RedisTemplate getRedisTemplate(){
        RedisTemplate redisTemplate =(RedisTemplate) ApplicationContextUtils.getApplicationContext().getBean("redisTemplate");
        redisTemplate.setKeySerializer(new StringRedisSerializer());
      redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        return redisTemplate;
    }
}

public class RedisCacheManager implements CacheManager {


    @Override
    public <K, V> Cache<K, V> getCache(String cacheName) throws CacheException {
        System.out.println(cacheName);
        return new RedisCache<K,V>(cacheName);
    }
}

在通过在配置类里面注册的Realm的bean，来将自定义Cache和CacheManager设置到所需要的Realm中。

@Bean
   public ShiroRealm shiroRealm(){
    ShiroRealm shiroRealm = new ShiroRealm();
    shiroRealm.setCacheManager(new RedisCacheManager());//设置缓存管理器
    shiroRealm.setAuthenticationCacheName("shiroRealmCache");
    shiroRealm.setAuthorizationCacheName("shiroRealmCache");
    shiroRealm.setAuthenticationCachingEnabled(true);
    shiroRealm.setCachingEnabled(true);
    return shiroRealm;
   }