Fork me on GitHub

Apache Shiro --- 8 session

阅读数:0次
字数统计: 4.5k字   |   阅读时长≈ 19分

Shiro提供了完整的企业级会话管理功能，不必将应用程序耦合到Web或ejb技术，提供了会话管理，会话事件监听，会话存储/持久化，容器无关的集群，失效/过期支持，对Web的透明支持，SSO单点登录的支持等特性。即直接使用 Shiro 的会话管理可以直接替换如 Web 容器的会话管理。

前言

​ shiro 提供了 session 用于保存与用户相关的信息，需要注意到这和 HTTP 的 session 概念是不一样的，它可以运行在没有web环境下。本篇文章会先介绍 Web 环境下的原理，读者有兴趣的话，可以看看在非 Web 环境下的原理。

Session 接口

session是与单个subject（用户，守护进程等）相关联的有状态数据上下文，该subject在一段时间内与软件系统进行交互。session旨在由业务层进行管理，并且可以通过其他层进行访问，而不受任何给定的客户端技术的束缚。这对Java 系统来说是巨大的好处，因为到目前为止，唯一可行的会话机制是javax.servlet.http.HttpSession或有状态session EJB，然而如果使用本session则不必将应用程序耦合到Web或ejb技术

image-20210112143512162

image-20210112143539625

Session 定义了主要接口，支持设置时间有效期，存储等。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public interface Session {
    
    // 返回 sessionId
	Serializable getId();
    
    // 设置超时时间
    void setTimeout(long maxIdleTimeInMillis) throws InvalidSessionException;
    
    // 添加值
    void setAttribute(Object key, Object value) throws InvalidSessionException;
    
    Object getAttribute(Object key) throws InvalidSessionException;
    
	// ....
}

HttpServletSession 实现了 http 的 session，运行在web环境。完全由标准的servlet容器支持HttpSession，它不与Shiro与会话相关的任何组件 SessionManager，SecurityManager等进行交互，而是通过与提供的servlet容器HttpSession HttpSession实例进行交互来满足所有方法实现。

DelegatingSession支持本地管理 session，运行在非 web 环境。DelegatingSession是服务器端的客户端层表示。此实现基本上是服务器端NativeSessionManager NativeSessionManager的代理，该代理将为每个方法调用返回正确的结果。DelegatingSession 将在适当的时候缓存数据，以避免远程方法调用，仅在必要时与服务器通信。当然，如果将其与NativeSessionManager业务POJO一起在进程中使用，则在基于Web的应用程序中可能会出现这种情况，其中基于Web的类和服务器端业务Pojo存在于同一个JVM，将不会进行远程方法调用。

ProxiedSession只是Session的代理类。简单的session实现，可立即将所有相应的调用委派给基础代理会话实例*此类对于框架子类最有用，它可以拦截某些 Session调用并执行其他逻辑。

SimpleSession只是简单的Session实现类。

Session 管理

session manager分为两类，非 Web 环境和 Web 环境。它负责 session 的创建，查找，删除等管理操作，由SessionManager接口表示。

SessionManager 接口

SessionManager只有两个方法，创建和查找 session。通过这两个方法的声明，可以看到多个概念的联系。

1
2
3
4
5
6
7
8
9
public interface SessionManager {
    
    // 创建Session实例
    Session start(SessionContext context);
    
    // 获取Session实例
    // 注意SessionKey实际上并不是大多数Shiro最终用户使用通常该接是框架开发使用。更方便的方法是通过Subject.getSession()方法获取当前正在执行的session
    Session getSession(SessionKey key) throws SessionException;
}

上述方法涉及到了 Session，SessionContext，SessionKey和SessionManager四种概念，这里先简单介绍下它们，

  • Session存储了用户的相关信息
  • SessionContext用作初始化Session实例
  • SessionKey是Session实例的 id，用于查找
  • SessionManager管理着多个Session

SessionManager 类图

session manager根据使用环境分为 HTTP 和 非 HTTP 两类。下图中左边的部分是使用本地 session 管理，在 Web 环境和非Web环境下都可以试用。右边的是使用Servlet自带的 session 管理，只能在Web环境下使用。

image-20210112150105003

image-20210112213203646

SecurityManager 在单个应用程序中为subject执行所有安全性操作。 该接口本身主要是为了方便起见-它扩展了org.apache.shiro.authc.Authenticator，Authorizer和SessionManager接口。对于大多数Shiro用法，这简化了配置，并且相比单独引用Authenticator, Authorizer, SessionManager实例更方便;除了上述三个接口之外，此接口还提供了许多支持subject行为的方法。org.apache.shiro.subject.Subject对单个用户执行身份验证，授权和会话操作，因此只能由SecurityManager管理，它了解所有三个功能。另一方面，三个父接口不会“了解”subject，以确保清晰地分离关注点。实际上，绝大多数应用程序程序员根本不会经常与SecurityManager进行交互。大多数应用程序程序员仅关心当前正在执行的用户的安全操作，通常通过调用 org.apache.shiro.SecurityUtils.getSubject()来实现。

image-20210112152114795

WebSercurityManager 此接口表示可以在启用Web的应用程序中使用的SecurityManager

1
2
3
4
5
6
7
8
public DefaultWebSecurityManager() {
    super();
    ((DefaultSubjectDAO) this.subjectDAO).setSessionStorageEvaluator(new DefaultWebSessionStorageEvaluator());
    this.sessionMode = HTTP_SESSION_MODE;
    setSubjectFactory(new DefaultWebSubjectFactory());
    setRememberMeManager(new CookieRememberMeManager());// CookieRememberMeManager里面有设置cookie,所以可以直接开启subject.rememverMe(true),注意这里的cookie设置，建议自己重新设置相应的CookieRememberMeManager。
    setSessionManager(new ServletContainerSessionManager()); //默认使用ServletContainerSessionManager 管理session
}

ValidatingSessionManager 是可以主动验证可能已过期的会话的SessionManager。
NativeSessionManager定义了本地 session 管理的接口，也就是说它可以存在非 web 环境下。
AbstractSessionManager接口的基本抽象类，支持配置应用程序范围的getGlobalSessionTimeout()、 globalSessionTimeout()。默认的全局会话超时为30分钟。
WebSessionManager定义了web session 管理的接口，也就是说它可以存在 web 环境下。

DefaultSessionManager是用于非 Web 环境下， 默认的管理器。(里面设置了SessionFactory，SessionDAO，CacheManager)
DefaultWebSessionManager是 shrio 支持用于 Web 环境下，只不过使用了自己的 session 管理。(里面设置了自定义的Cookie)
ServletContainerSessionManager是基于 spring web 实现的，只能用于 Web 环境下，它只是简单的封装了Serlvet相关功能。(session,cookie完全交由shiro管理)

Web 环境

​ 因为 Web 的场景会非常普遍，而且实现也比较简单，所以会先讲解这部分。ServletContainerSessionManager类实现了SessionManager接口，下面是它的代码

image-20210112152820121

image-20210112152742909

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
public class ServletContainerSessionManager implements WebSessionManager {
    
    // 实现start接口，创建Session实例
    public Session start(SessionContext context) throws AuthorizationException {
        return createSession(context);
    }
    
    protected Session createSession(SessionContext sessionContext) throws AuthorizationException {
        //此类的某些方法是从Spring Framework复制而来的，因此我们不必重新发明轮子.
        // 这里sessionContext实际是DefaultWebSessionContext类型，从中提取HttpServletRequest
        HttpServletRequest request = WebUtils.getHttpRequest(sessionContext);
		// 从中提取HttpSession
        HttpSession httpSession = request.getSession();

        // 构建HttpServletSession实例
        String host = getHost(sessionContext);
        return createSession(httpSession, host);
    }
    
    protected Session createSession(HttpSession httpSession, String host) {
        return new HttpServletSession(httpSession, host);
    }
    
    // 获取 session
    public Session getSession(SessionKey key) throws SessionException {
        HttpServletRequest request = WebUtils.getHttpRequest(key);
        Session session = null;
        // 从HttpServletRequest获取session
        HttpSession httpSession = request.getSession(false);
        if (httpSession != null) {
            session = createSession(httpSession, request.getRemoteHost());
        }

        return session;
    }
    
}

可以看到，它只是简单的调用了HttpServletRequest相关的方法，创建了HttpServletSession实例。HttpServletSession也只是简单的包装了一下HTTPSession。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class HttpServletSession implements Session {
    
    private HttpSession httpSession = null;
    
    // 返回 session id
    public Serializable getId() {
        return httpSession.getId();
    }
    
    // 获取session里的值
    public Object getAttribute(Object key) throws InvalidSessionException {
        return httpSession.getAttribute(assertString(key));
    }
    
    // 设置session里的值
    public void setAttribute(Object key, Object value) throws InvalidSessionException {
        httpSession.setAttribute(assertString(key), value);
    }
}

非 Web 环境

DefaultSessionManager是非 Web 环境下默认的 session 管理器。我们来看看它的实现原理，因为它继承了AbstractNativeSessionManager类，所以真正的创建 session 实例由doCreateSession方法负责。从下面的代码可以看到，session的创建是有工厂类SessionFactory负责，并且创建后还会将其持久化。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class DefaultSessionManager extends AbstractValidatingSessionManager {
    
    // 负责实例化 session
    private SessionFactory sessionFactory;
    
    // session 持久化
    protected SessionDAO sessionDAO;
    
 	protected Session doCreateSession(SessionContext context) {
        // 使用SessionFactory创建实例
        Session s = newSessionInstance(context);
        // 使用SessionDAO持久化
        create(s);
        return s;
    }
    
    protected Session newSessionInstance(SessionContext context) {
        return getSessionFactory().createSession(context);
    }
    
     protected void create(Session session) {
        sessionDAO.create(session);
    }
}

同样根据 sessionId 查找 session 的方法，最终由retrieveSession实现。可以看到session的查找最终是由SessionDAO负责。

1
2
3
4
5
6
7
8
9
10
11
12
13
public class DefaultSessionManager extends AbstractValidatingSessionManager {
    
    protected Session retrieveSession(SessionKey sessionKey) throws UnknownSessionException {
        Serializable sessionId = getSessionId(sessionKey);
        // 调用SessionDAO来寻找session
        Session s = retrieveSessionFromDataSource(sessionId);
        return s;
    }
    
    protected Session retrieveSessionFromDataSource(Serializable sessionId) throws UnknownSessionException {
        return sessionDAO.readSession(sessionId);
    }
}

Session 实例化

上面涉及到了SessionFactory工厂类，用作创建 session。接下来就讲讲它的原理。

SessionFactory 工厂类

​ 一个简单的工厂类，用于实例化具体的Session实例。这主要是一种机制，允许实例在需要与默认值不同时在运行时创建实例。框架的最终用户不使用它，而是配置Shiro以在应用程序中工作的用户，通常将其注入org.apache.shiro.mgt.SecurityManager 或SessionManager。

SessionFactory接口定义了创建 Session 的方法createSession，其中参数SessionContext是用作初始化的。

1
2
3
public interface SessionFactory {
    Session createSession(SessionContext initData);
}

目前只有SimpleSessionFactory类实现了该接口，它的实现非常简单

1
2
3
4
5
6
7
8
9
10
11
12
13
public class SimpleSessionFactory implements SessionFactory {

    // 这里只是存储了客户端的host
    public Session createSession(SessionContext initData) {
        if (initData != null) {
            String host = initData.getHost();
            if (host != null) {
                return new SimpleSession(host);
            }
        }
        return new SimpleSession();
    }
}

初始化参数SessionContext

SessionContext的相关类图如下所示，虽然比较多，但是原理很简单。

image-20210112152947970

image-20210112153716985

​ 其中RequestPairSource 是提供当前执行请求关联的ServletRequest，ServletResponse 对。 用于框架开发支持，最终用户很少使用。

image-20210112163047631

SessionContext继承 Map`接口，并且定义了 host 和 sessionId 两个属性的操作方法。

1
2
3
4
5
6
7
8
9
10
public interface SessionContext extends Map<String, Object> {
    
    void setHost(String host);
    
    String getHost();
    
    Serializable getSessionId();
    
    void setSessionId(Serializable sessionId);
}

DefaultSessionContext实现了默认的SessionContext接口。

DefaultWebSessionContext在它基础之上，添加了获取ServletRequest和ServletResponse实例的方法。

Session 持久化

Easy Custom Session Storage - 因为Shiro 的Session 对象是基于 POJO 的，会话数据可以很容易地存储在任意数量的数据源。这允许你自定义你的应用程序会话数据的确切位置——例如，文件系统，联网的分布式缓存，关系数据库，或专有的数据存储。

每当一个会话被创建或更新时，它的数据需要持久化到一个存储位置以便它能够被稍后的应用程序访问。同样地，当一个会话失效且不再被使用时，它需要从存储中删除以便会话数据存储空间不会被耗尽。SessionManager 实现委托这些 Create/Read/Update/Delete(CRUD) 操作为内部组件，同时，SessionDAO，反映了数据访问对象（DAO）设计模式。

SessionDAO 的权力是你能够实现该接口来与你想要的任何数据存储进行通信。这意味着你的会话数据可以驻留在内存中，文件系统，关系数据库或NoSQL 的数据存储，或其他任何你需要的位置。你得控制持久性行为。

SessionDAO定义了 session 增删改查接口，如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
public interface SessionDAO {
    
    Serializable create(Session session);

    Session readSession(Serializable sessionId) throws UnknownSessionException;

    void update(Session session) throws UnknownSessionException;

    void delete(Session session);

    Collection<Session> getActiveSessions();
}

它的子类图如下所示：

image-20210112154637793

AbstractSessionDAO实现了SessionDAO接口，并且定义了doCreate接口，子类需要实现它并且返回 SessionId。
MemorySessionDAO使用了 ConcurrentMap来保存 session。
CachingSessionDAO实现了session缓存，用户可以集成CacheManager实现自定义的缓存。
当持久化化 session 的时候，SessionDAO会使用SessionIdGenerator接口生成唯一的 SessionId。

image-20210112154747929

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
@Bean
   public RedisManager redisManager() {
       RedisManager redisManager = new RedisManager();
       redisManager.setHost(host);
       redisManager.setPort(port);
       redisManager.setTimeout(timeout);
       redisManager.setPassword(password);
       return redisManager;
   }

   /**
    * 配置Cache管理器
    * 用于往Redis存储权限和角色标识
    * @Attention 使用的是shiro-redis开源插件
    * @Author Sans
    * @CreateTime 2019/6/12 12:37
    */
   @Bean
   public RedisCacheManager cacheManager() {
       RedisCacheManager redisCacheManager = new RedisCacheManager();
       redisCacheManager.setRedisManager(redisManager());
       redisCacheManager.setKeyPrefix(CACHE_KEY);
       // 配置缓存的话要求放在session里面的实体类必须有个id标识
       redisCacheManager.setPrincipalIdFieldName("userId");
       return redisCacheManager;
   }

   /**
    * SessionID生成器
    * @Author Sans
    * @CreateTime 2019/6/12 13:12
    */
   @Bean
   public ShiroSessionIdGenerator sessionIdGenerator(){
       return new ShiroSessionIdGenerator();
   }

   /**
    * 配置RedisSessionDAO
    * @Attention 使用的是shiro-redis开源插件
    * @Author Sans
    * @CreateTime 2019/6/12 13:44
    */
   @Bean
   public RedisSessionDAO redisSessionDAO() {
       RedisSessionDAO redisSessionDAO = new RedisSessionDAO();
       redisSessionDAO.setRedisManager(redisManager());
       redisSessionDAO.setSessionIdGenerator(sessionIdGenerator());
       redisSessionDAO.setKeyPrefix(SESSION_KEY);
       redisSessionDAO.setExpire(expire);
       return redisSessionDAO;
   }

Session 集成

我们再回到DefaultSecurityManager类，看看它是如何集成Session的。SessionsSecurityManager是它的父类，它默认使用DefaultSessionManager实现，实现了 session 管理。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public abstract class SessionsSecurityManager extends AuthorizingSecurityManager {
    
    private SessionManager sessionManager;
    
    // 使用DefaultSessionManager作为默认的实现
    public SessionsSecurityManager() {
        super();
        this.sessionManager = new DefaultSessionManager();
    }
    
    // 转发给sessionManager处理
    public Session start(SessionContext context) throws AuthorizationException {
        return this.sessionManager.start(context);
    }

    // 转发给sessionManager处理
    public Session getSession(SessionKey key) throws SessionException {
        return this.sessionManager.getSession(key);
    }
}

Spring Session 集成

session在不同场景下有两种方式在分布式环境下Session一般会被持久化到应用可访问的外部存储上，供其它程序访问；在单应用程序上一般存储在服务器端。

单应用程序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
@Configuration
public class ShiroConfig {

    /**
     * cookie 保活时间
     */
    private static final Integer COOKIE_TIME = 60 * 60 * 24;
    /**
     * 30分钟验证一次会话
     */
    private static final Integer SESSION_VALIDATION_INTERVAL = 60 * 30 * 1000;
    /**
     * 服务器端会话过期时间
     */
    private static final Integer GLOBAL_SESSION_TIMEOUT = COOKIE_TIME * 1000;

    /**
     * 开启Shiro-aop注解支持 , 使用代理方式所以需要开启代码支持
     *
     * @param securityManager 安全管理器
     * @return AuthorizationAttributeSourceAdvisor
     */
    @Bean
    public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(
            SecurityManager securityManager) {
        AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
        authorizationAttributeSourceAdvisor.setSecurityManager(securityManager);
        return authorizationAttributeSourceAdvisor;
    }

    /**
     * Shiro基础配置
     */
    @Bean
    public ShiroFilterFactoryBean shiroFilterFactory(SecurityManager securityManager) {
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        shiroFilterFactoryBean.setSecurityManager(securityManager);
        Map<String, String> filterChainDefinitionMap = new LinkedHashMap<>();
        // 注意过滤器配置顺序不能颠倒
        // 配置过滤:不会被拦截的链接
        filterChainDefinitionMap.put("/api/user/login/**", "anon");
        filterChainDefinitionMap.put("/api/user/logout/**", "anon");
        // 需要拦截的
        filterChainDefinitionMap.put("/**", "authc");
        // 配置shiro默认登录界面地址，前后端分离中登录界面跳转应由前端路由控制，后台仅返回json数据
        LinkedHashMap<String, Filter> filterMap = new LinkedHashMap<>();
        filterMap.put("authc", new ShiroFormAuthenticationFilter());
        shiroFilterFactoryBean.setFilters(filterMap);
        shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);
        return shiroFilterFactoryBean;
    }

    /**
     * 安全管理器
     */
    @Bean
    public SecurityManager securityManager(SessionManager sessionManager) {
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        securityManager.setSessionManager(sessionManager);
        // 无需记住我，因为这里使用了自己的sessionManager
        securityManager.setRememberMeManager(null);
        securityManager.setRealm(shiroRealm());
        return securityManager;
    }

    private SimpleCookie simpleCookie() {
        SimpleCookie simpleCookie = new SimpleCookie();
        simpleCookie.setHttpOnly(true);
        simpleCookie.setPath("/");
        simpleCookie.setName("rememberMeAfter");
        simpleCookie.setMaxAge(COOKIE_TIME);
        return simpleCookie;
    }

    /**
     * 配置Session管理器,这里使用cookie管理sessionId (如果设置跨域的话可以使用自定义的ShiroSessionManager,使用redis存储sessionId,在前端request中添加访问)
     */
    @Bean
    public SessionManager sessionManager() {
        DefaultWebSessionManager sessionManager = new DefaultWebSessionManager();
        sessionManager.setSessionValidationInterval(SESSION_VALIDATION_INTERVAL);
        sessionManager.setGlobalSessionTimeout(GLOBAL_SESSION_TIMEOUT);
        sessionManager.setDeleteInvalidSessions(true);
        sessionManager.setSessionValidationSchedulerEnabled(true);
        sessionManager.setSessionIdCookie(simpleCookie());
        return sessionManager;
    }

    /**
     * 身份验证器 这个自定义realm,可以使用mysql管理用户角色和权限
     */
    private AccessRealm shiroRealm() {
        AccessRealm accessRealm = new AccessRealm();
        accessRealm.setCredentialsMatcher(hashedCredentialsMatcher());
        return accessRealm;
    }

    /**
     * 凭证匹配器 将密码校验交给Shiro的SimpleAuthenticationInfo进行处理,在这里做匹配配置
     */
    @Bean
    public HashedCredentialsMatcher hashedCredentialsMatcher() {
        HashedCredentialsMatcher shaCredentialsMatcher = new HashedCredentialsMatcher();
        // 散列算法:这里使用SHA256算法;
        shaCredentialsMatcher.setHashAlgorithmName(SHA256Util.HASH_ALGORITHM_NAME);
        // 散列的次数，比如散列两次，相当于 md5(md5(""));
        shaCredentialsMatcher.setHashIterations(SHA256Util.HASH_ITERATIONS);
        return shaCredentialsMatcher;
    }
}

分布式环境

可以session持久化，例如保存在redis中

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
@Configuration
public class ShiroConfig {

    private final static String CACHE_KEY = "shiro:cache:";
    private final static String SESSION_KEY = "shiro:session:";
    private final static Integer EXPIRE = 1800;

    @Value("${spring.redis.host}")
    private String host;
    @Value("${spring.redis.password}")
    private String password;

    /**
     * 开启Shiro-aop注解支持 , 使用代理方式所以需要开启代码支持
     *
     * @param securityManager 安全管理器
     * @return AuthorizationAttributeSourceAdvisor
     */
    @Bean
    public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(
            @Autowired SecurityManager securityManager) {
        AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
        authorizationAttributeSourceAdvisor.setSecurityManager(securityManager);
        return authorizationAttributeSourceAdvisor;
    }

    /**
     * Shiro基础配置
     */
    @Bean
    public ShiroFilterFactoryBean shiroFilterFactory(@Autowired SecurityManager securityManager,
            @Autowired ShiroFormAuthenticationFilter shiroFormAuthenticationFilter) {
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        shiroFilterFactoryBean.setSecurityManager(securityManager);
        Map<String, String> filterChainDefinitionMap = new LinkedHashMap<>();
        // 注意过滤器配置顺序不能颠倒
        // 配置过滤:不会被拦截的链接
        filterChainDefinitionMap.put("/api/user/login/**", "anon");
        // 需要拦截的
        filterChainDefinitionMap.put("/**", "authc");
        // 配置shiro默认登录界面地址，前后端分离中登录界面跳转应由前端路由控制，后台仅返回json数据
        //shiroFilterFactoryBean.setLoginUrl("/api/user/login");
        LinkedHashMap<String, Filter> filterMap = new LinkedHashMap<>();
        filterMap.put("authc", new ShiroFormAuthenticationFilter());
        shiroFilterFactoryBean.setFilters(filterMap);
        shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);
        return shiroFilterFactoryBean;
    }

    /**
     * 安全管理器
     */
    @Bean
    public SecurityManager securityManager(@Autowired SessionManager sessionManager,
            @Autowired IniRealm iniRealm) {
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        // 自定义Ssession管理
        securityManager.setSessionManager(sessionManager);
        // 自定义Cache实现
        securityManager.setCacheManager(cacheManager());
        // 自定义Realm验证
        securityManager.setRealm(iniRealm);
        return securityManager;
    }

    /**
     * 身份验证器
     * 这个自定义realm,可以使用mysql管理用户角色和权限
     */
    public AccessRealm shiroRealm() {
        AccessRealm accessRealm = new AccessRealm();
        accessRealm.setCredentialsMatcher(hashedCredentialsMatcher());
        return accessRealm;
    }

    /**
     * 配置文件身份认证器
     *
     * @return 身份认证器
     */
    @Bean
    public IniRealm iniRealm() {
        return new IniRealm("classpath:shiro.ini");
    }

    /**
     * 凭证匹配器 将密码校验交给Shiro的SimpleAuthenticationInfo进行处理,在这里做匹配配置
     */
    @Bean
    public HashedCredentialsMatcher hashedCredentialsMatcher() {
        HashedCredentialsMatcher shaCredentialsMatcher = new HashedCredentialsMatcher();
        // 散列算法:这里使用SHA256算法;
        shaCredentialsMatcher.setHashAlgorithmName(SHA256Util.HASH_ALGORITHM_NAME);
        // 散列的次数，比如散列两次，相当于 md5(md5(""));
        shaCredentialsMatcher.setHashIterations(SHA256Util.HASH_ITERATIONS);
        return shaCredentialsMatcher;
    }

    /**
     * 配置Redis管理器,使用的是shiro-redis开源插件
     *
     * @return RedisManager
     */
    private RedisManager redisManager() {
        RedisManager redisManager = new RedisManager();
        redisManager.setHost(host);
        redisManager.setPassword(password);
        return redisManager;
    }

    /**
     * 配置Cache管理器 用于往Redis存储权限和角色标识 使用的是shiro-redis开源插件
     */
    private RedisCacheManager cacheManager() {
        RedisCacheManager redisCacheManager = new RedisCacheManager();
        redisCacheManager.setRedisManager(redisManager());
        redisCacheManager.setKeyPrefix(CACHE_KEY);
        // 配置缓存的话要求放在session里面的实体类必须有个id标识
        redisCacheManager.setPrincipalIdFieldName("userId");
        return redisCacheManager;
    }

    /**
     * SessionID生成器
     */
    @Bean
    public ShiroSessionIdGenerator sessionIdGenerator() {
        return new ShiroSessionIdGenerator();
    }


    /**
     * 配置RedisSessionDAO
     */
    @Bean
    public RedisSessionDAO redisSessionDAO() {
        RedisSessionDAO redisSessionDAO = new RedisSessionDAO();
        redisSessionDAO.setRedisManager(redisManager());
        redisSessionDAO.setSessionIdGenerator(sessionIdGenerator());
        redisSessionDAO.setKeyPrefix(SESSION_KEY);
        redisSessionDAO.setExpire(EXPIRE);
        return redisSessionDAO;
    }

    /**
     * 配置Session管理器,这里使用cookie管理sessionId
     * (如果设置跨域的话可以使用自定义的ShiroSessionManager,使用redis存储sessionId,在前端request中添加访问)
     */
    @Bean
    public SessionManager sessionManager() {
        ShiroSessionManager shiroSessionManager = new ShiroSessionManager();
        shiroSessionManager.setSessionDAO(redisSessionDAO());
        return shiroSessionManager;
    }
}

注意:

rememberMe功能其实本身使用了session、cookie。所以如果使用了rememberMe就无需设置securityManager.setSessionManager(sessionManager),DefaultWebSecurityManager默认使用了ServletContainerSessionManager

RememberMeManager负责在主题与应用程序的会话中记住subject的身份

image-20210112165300673

1
2
3
4
5
6
public CookieRememberMeManager() {
    Cookie cookie = new SimpleCookie(DEFAULT_REMEMBER_ME_COOKIE_NAME);
    cookie.setHttpOnly(true);
    cookie.setMaxAge(Cookie.ONE_YEAR);
    this.cookie = cookie;
}

参考

1
2
3
https://blog.csdn.net/qq_34021712/article/details/80418112
https://zhmin.github.io/2020/04/14/shiro-session/
https://www.ctolib.com/docs/sfile/apache-shiro-reference/II.%20Core%20%E6%A0%B8%E5%BF%83/8.%20Session%20Management.html
赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

主要涉及技术：
Java后端开发、聚合支付、
公众号开发、开源爱好者、Linux

联系QQ:2013881276

很惭愧

只做了一点微小的工作
谢谢大家