springboot配置shiro多项目实现session共享的详细步骤

水深无声 2023-10-02 16:56 37阅读 0赞

## springboot配置shiro多项目实现session共享的详细步骤 ##

###### 公司需要这样的需求： ######

有两个项目`master` 主项目、`suiteone` 项目，两个项目各自由`shiro` 安全框架管理，当不能登录时，都无法访问，但当登录了其中一个，再访问另一个的时候不再需要登录即可访问。  
如果想看为什么需要共享`session` ,可以去看我这篇文章。\[shiro框架—关于多项目之间验证为什么需要共享session\]

###### 关于实现多项目共享session的逻辑介绍 ######

其实在上边的链接里我已经说明了，但是怕大家不去看，所以我就又复制到了这里：  
先来`说一下我的理解` ，如下：

![这里写图片描述][70]  
上图中`master` 项目为主项目，登录页即在这个项目中，`suiteone` 、`suitetwo` 为两个从项目，当两个从项目有请求时，如果没有登录的时候，都会打到`master` 项目的登录页上。共享`session` 采用的是`redis` 存储。

##### 上图的步骤如下： #####

1.  浏览器请求`master` 项目，第一次请求的时候，也是会带着浏览器中的`cookie` 去请求，当然第一次去`redis` 里肯定找不到对应的`session`，会通过⑤进入到登录页。
2.  当在登录页输入完正确的账号密码后，才能登录成功，否则仍会回到⑤。
3.  在这一步的时候，会将登录成功后的`session` ，根据它，将生成`sessionId串` ，并传到前端浏览器中，浏览器以`cookie` 存储。
4.  同时将第③步中生成的`session` 存储到`redis` 中。
5.  当前这里，不只是当登录失败的时候，会进入到登录页中，当浏览器长时间没有访问后台（每次浏览器访问后台，其实都会刷新`session` 的过期时间`expireTime`），导致`session` 超过时，也会进入到该步中。
6.  当浏览器请求`suiteone` 、`suteTwo` 这两个从项目时，肯定也是将当前浏览器中的所有的`cookie` 设置到`request headers` 请求头中。
7.  根据传入的`sessionId串` 到共享的`redis` 存储中匹配。
8.  如果匹配不到，则会跳转到`master` 项目的登录页，如果匹配成功，则会访问通过。

以上描述的并不难，大家也都会想到，那么如何将`扯了这么多的淡` 真正更简单的，落地实现才是大家关注的。

##### 多项目通过redis共享session的步骤 #####

###### 1、`shiro` 共享`session` 的切入点，下图是shiro的验证流程 ######

![这里写图片描述][70 1]

###### 2、配置过程 ######

说一下实现`shiro` 项目共享`session` 的配置步骤：

###### （1）项目多添加`redis` 依赖。 ######

<dependency>
        <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-redis</artifactId>
         <version>1.3.6.RELEASE</version>
     </dependency>

###### （2）配置`application.properties` 文件 ######

###主项目写成自己项目的登录页面路径，从项目必须写完整的主项目登录页面url
    shiro.loginUrl=/login
    ###主从项目的下边名字必须一致
    shiro.jessionid=sessionId
    ###redis连接配置
    spring.redis.host=192.168.1.160
    spring.redis.port=6379
    spring.redis.password=znxd

###### （3）重写`session` 增删改查，与redis接入 ######

package microservice.sc.shiro;
    
    import org.apache.shiro.session.Session;
    import org.apache.shiro.session.UnknownSessionException;
    import org.apache.shiro.session.mgt.eis.AbstractSessionDAO;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.stereotype.Service;
    import java.io.Serializable;
    import java.util.Collection;
    import java.util.concurrent.TimeUnit;
    
    
    @Service
    public class RedisSessionDao extends AbstractSessionDAO {
        
        // Session超时时间，单位为毫秒
        private long expireTime = 120000;
    
        @Autowired
        private RedisTemplate redisTemplate;// Redis操作类，对这个使用不熟悉的，可以参考前面的博客
    
        public RedisSessionDao() {
        
            super();
        }
    
        public RedisSessionDao(long expireTime, RedisTemplate redisTemplate) {
        
            super();
            this.expireTime = expireTime;
            this.redisTemplate = redisTemplate;
        }
    
        @Override // 更新session
        public void update(Session session) throws UnknownSessionException {
        
            System.out.println("===============update================");
            if (session == null || session.getId() == null) {
        
                return;
            }
            session.setTimeout(expireTime);
            redisTemplate.opsForValue().set(session.getId(), session, expireTime, TimeUnit.MILLISECONDS);
        }
    
        @Override // 删除session
        public void delete(Session session) {
        
            System.out.println("===============delete================");
            if (null == session) {
        
                return;
            }
            redisTemplate.opsForValue().getOperations().delete(session.getId());
        }
    
        @Override
    // 获取活跃的session，可以用来统计在线人数，如果要实现这个功能，可以在将session加入redis时指定一个session前缀，统计的时候则使用keys("session-prefix*")的方式来模糊查找redis中所有的session集合
        public Collection<Session> getActiveSessions() {
        
            System.out.println("==============getActiveSessions=================");
            return redisTemplate.keys("*");
        }
    
        @Override// 加入session
        protected Serializable doCreate(Session session) {
        
            System.out.println("===============doCreate================");
            Serializable sessionId = this.generateSessionId(session);
            this.assignSessionId(session, sessionId);
    
            redisTemplate.opsForValue().set(session.getId(), session, expireTime, TimeUnit.MILLISECONDS);
            return sessionId;
        }
    
        @Override// 读取session
        protected Session doReadSession(Serializable sessionId) {
        
            System.out.println("==============doReadSession=================");
            if (sessionId == null) {
        
                return null;
            }
            return (Session) redisTemplate.opsForValue().get(sessionId);
        }
    
        public long getExpireTime() {
        
            return expireTime;
        }
    
        public void setExpireTime(long expireTime) {
        
            this.expireTime = expireTime;
        }
    
        public RedisTemplate getRedisTemplate() {
        
            return redisTemplate;
        }
    
        public void setRedisTemplate(RedisTemplate redisTemplate) {
        
            this.redisTemplate = redisTemplate;
    
        }
    }

###### （4）将重写的`RedisSessionDao` 接入到`shiro` 中的`sessionManager` ######

@Bean
    	public RedisSessionDao getRedisSessionDao(){
        
    		return new RedisSessionDao();
    	}
    	/**
    	 * @see DefaultWebSessionManager
    	 * @return
    	 */
    	@Bean(name="sessionManager")
    	public DefaultWebSessionManager defaultWebSessionManager() {
        
    		DefaultWebSessionManager sessionManager = new DefaultWebSessionManager();
    		//sessionManager.setCacheManager(cacheManager());
    		sessionManager.setGlobalSessionTimeout(43200000); //12小时
    		sessionManager.setDeleteInvalidSessions(true);
    		//关键在这里
    		sessionManager.setSessionDAO(getRedisSessionDao());
    		sessionManager.setSessionValidationSchedulerEnabled(true);
    		sessionManager.setDeleteInvalidSessions(true);
    		sessionManager.setSessionIdCookie(getSessionIdCookie());
    		return sessionManager;
    	}

###### （5）将`sessionManager` 注入到`securityManager` ######

/**
    	 * @see org.apache.shiro.mgt.SecurityManager
    	 * @return
    	 */
    	@Bean(name="securityManager")
    	public DefaultWebSecurityManager securityManager() {
        
    		DefaultWebSecurityManager manager = new DefaultWebSecurityManager();
    		manager.setRealm(userRealm());
    		//manager.setCacheManager(cacheManager());
    		manager.setSessionManager(defaultWebSessionManager());
    		return manager;
    	}

###### （6）设置`登录页的地址` 和`cookie名字` ######

首先引入我们刚才`application.properties`文件中的内容：

@Value("${shiro.loginUrl}")
    private String masterLoginUrl;
    
    @Value("${shiro.jessionid}")
    private String jessionId;

然后注入到配置中：

@Bean(name = "shiroFilter")
    	public ShiroFilterFactoryBean shiroFilter(){
        
    		ShiroFilterFactoryBean bean = new MShiroFilterFactoryBean(); //指向自定义过滤器，自定义过滤器对js/css等忽略
    		bean.setSecurityManager(securityManager());
    		//在这里设置登录页
    		bean.setLoginUrl(masterLoginUrl);
    		Map<String, Filter>filters = new LinkedHashMap<>();
    		filters.put("anon", new AnonymousFilter());
    		bean.setFilters(filters);
    		//shiro配置过滤规则少量的话可以用hashMap,数量多了要用LinkedHashMap,保证有序，原因未知
    		Map<String, String> chains =  new LinkedHashMap<>();
    		chains.put("/login","anon");
    		chains.put("/loginForm","anon");
    		chains.put("/**", "authc");
    		bean.setFilterChainDefinitionMap(chains);
    		return bean;
    	}

/**
    	 * 给shiro的sessionId默认的JSSESSIONID名字改掉
    	 * @return
    	 */
    	@Bean(name="sessionIdCookie")
    	public SimpleCookie getSessionIdCookie(){
        
    		SimpleCookie simpleCookie = new SimpleCookie(jessionId);
    		return simpleCookie;
    	}

注意，如果值注入不进来，则看一下当前的`shiro` 配置文件里的`LifecycleBeanPostProcessor` 的注入是否为`static` 方法,如下：

/**
    	 * 该类如果不设置为static，@Value注解就无效，原因未知
    	 * @return
    	 */
    	@Bean
    	public static LifecycleBeanPostProcessor lifecycleBeanPostProcessor() {
        
    		return new LifecycleBeanPostProcessor();
    	}

###### （7）测试 ######

我的项目如下：  
如下图所示，我们是`springboot+dubbo+zookeeper` 的项目：  
![这里写图片描述][70 2]  
分别启动`30000端口` 的主项目`master` 项目、`300001端口的`从项目`suiteone` 项目，启动后，

*  首先访问主项目`http://localhost:30000`肯定进入登录页。
 *  当再访问`http://localhost:30001/test` ，因为没有登录直接被重定向到`http://localhost:30000` 的登录页上，即主项目的登录页。
 *  当在当前登录页上登录成功后，再次访问`http://localhost:30001/test` ，该接口即返回了数值。
 *  当我在主项目的`http://localhost:30000`中退出登录，再次访问`http://localhost:30001/test` ，同样重定向了登录页。
 *  应该能确定实现了`session` 共享。

具体如下图：  
登录页面，在这时访问`30001` 也会进入下边这个页面：  
![这里写图片描述][70 3]  
登录成功后：  
![这里写图片描述][70 4]  
登录成功后访问`30001`的接口，即可以访问成功  
![这里写图片描述][70 5]

#### 配置完成，如有问题请及时留言。 ####

[70]: https://img-blog.csdn.net/20180804114658656?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dvaGFxaXlp/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70
[70 1]: https://img-blog.csdn.net/2018080416381458?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dvaGFxaXlp/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70
[70 2]: https://img-blog.csdn.net/20180804160903308?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dvaGFxaXlp/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70
[70 3]: https://img-blog.csdn.net/20180804170912956?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dvaGFxaXlp/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70
[70 4]: https://img-blog.csdn.net/20180804170928666?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dvaGFxaXlp/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70
[70 5]: https://img-blog.csdn.net/20180804171035526?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dvaGFxaXlp/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70