想当将军的螺丝 / JAVA / 实战,通过复写shiro的SessionDAO来实现将...

分享

   

实战,通过复写shiro的SessionDAO来实现将session保存到redis集群中

2020-04-21  想当将军...

作者:zifangsky

https://www.zifangsky.cn/889.html

如题所示,在分布式系统架构中需要解决的一个很重要的问题就是——如何保证各个应用节点之间的Session共享。现在通用的做法就是使用redis、memcached等组件独立存储所有应用节点的Session,以达到各个应用节点之间的Session共享的目的

在Java Web项目中实现session共享的一个很好的解决方案是:Spring Session+Spring Data Redis。关于这方面的内容可以参考我之前写的这篇文章:https://www.zifangsky.cn/862.html

但是,如果在项目中使用到了shiro框架,并且不想使用Spring Session的话,那么我们可以通过复写shiro的SessionDAO同样达到将shiro管理的session保存到redis集群的目的,以此解决分布式系统架构中的session共享问题

下面,我将详细说明具体该如何来实现:

(1)配置Spring Data Redis环境:

关于Spring Data Redis环境的配置可以参考这篇文章:

https://www.zifangsky.cn/861.html

在这里,我测试使用的是redis集群模式,当然使用redis单节点也可以

(2)复写shiro的SessionDAO:

import java.io.Serializable;
import java.util.concurrent.TimeUnit;

import javax.annotation.Resource;

import org.apache.shiro.session.Session;
import org.apache.shiro.session.mgt.eis.EnterpriseCacheSessionDAO;
import org.springframework.data.redis.core.BoundValueOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Repository;

@Repository('customShiroSessionDao')
public class CustomShiroSessionDao extends EnterpriseCacheSessionDAO {

    @Resource(name='redisTemplate')
    private RedisTemplate<String, Object> redisTemplate;

    /**
     * 创建session,保存到redis集群中
     */
    @Override
    protected Serializable doCreate(Session session) {
        Serializable sessionId = super.doCreate(session);
        System.out.println('sessionId: ' + sessionId);

        BoundValueOperations<String, Object> sessionValueOperations = redisTemplate.boundValueOps('shiro_session_' + sessionId.toString());
        sessionValueOperations.set(session);
        sessionValueOperations.expire(30, TimeUnit.MINUTES);

        return sessionId;
    }

    /**
     * 获取session
     * @param sessionId
     * @return
     */
    @Override
    protected Session doReadSession(Serializable sessionId) {
        Session session = super.doReadSession(sessionId);

        if(session == null){
            BoundValueOperations<String, Object> sessionValueOperations = redisTemplate.boundValueOps('shiro_session_' + sessionId.toString());
            session = (Session) sessionValueOperations.get();
        }

        return session;
    }

    /**
     * 更新session
     * @param session
     */
    @Override
    protected void doUpdate(Session session) {
        super.doUpdate(session);

        BoundValueOperations<String, Object> sessionValueOperations = redisTemplate.boundValueOps('shiro_session_' + session.getId().toString());
        sessionValueOperations.set(session);
        sessionValueOperations.expire(30, TimeUnit.MINUTES);
    }

    /**
     * 删除失效session
     */
    @Override
    protected void doDelete(Session session) {
        redisTemplate.delete('shiro_session_' + session.getId().toString());
        super.doDelete(session);
    }

}

具体含义可以参考注释,这里就不多做解释了

(3)在shiro的配置文件中添加sessionManager:

    <!-- 使用redis存储管理session -->
    <bean id='sessionManager'  
        class='org.apache.shiro.web.session.mgt.DefaultWebSessionManager'> 
        <!-- 删除失效session -->
        <property name='sessionValidationSchedulerEnabled' value='true' />  
        <!-- session失效时间(毫秒) --> 
        <property name='globalSessionTimeout' value='1800000' />
        <property name='sessionDAO' ref='customShiroSessionDao' />  
    </bean>

然后在securityManager中使用该sessionManager:

    <!-- Shiro安全管理器 -->
    <bean id='securityManager' class='org.apache.shiro.web.mgt.DefaultWebSecurityManager'>
        <property name='realm' ref='customRealm' />
        <property name='sessionManager' ref='sessionManager' />
        <property name='cacheManager' ref='cacheManager' />
    </bean>

注:完整的shiro的配置文件如下:

<?xml version='1.0' encoding='UTF-8'?>
<beans xmlns='http://www.springframework.org/schema/beans'
    xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns:jee='http://www.springframework.org/schema/jee'
    xsi:schemaLocation='http://www.springframework.org/schema/beans 
            http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
            http://www.springframework.org/schema/jee 
            http://www.springframework.org/schema/jee/spring-jee-4.0.xsd
            http://www.springframework.org/schema/aop 
            http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
            http://www.springframework.org/schema/context 
            http://www.springframework.org/schema/context/spring-context-4.0.xsd
            http://www.springframework.org/schema/tx 
            http://www.springframework.org/schema/tx/spring-tx-4.0.xsd'
    xmlns:context='http://www.springframework.org/schema/context' xmlns:tx='http://www.springframework.org/schema/tx'
    xmlns:aop='http://www.springframework.org/schema/aop'>
    <description>Shiro 配置</description>

    <context:component-scan base-package='cn.zifangsky.manager.impl' />
    <context:component-scan base-package='cn.zifangsky.shiro' />

    <bean id='cacheManager' class='org.apache.shiro.cache.ehcache.EhCacheManager'>
        <property name='cacheManager' ref='cacheManagerFactory' />
        <property name='cacheManagerConfigFile' value='classpath:ehcache.xml' />
    </bean>

    <!-- 使用redis存储管理session -->
    <bean id='sessionManager'  
        class='org.apache.shiro.web.session.mgt.DefaultWebSessionManager'> 
        <!-- 删除失效session -->
        <property name='sessionValidationSchedulerEnabled' value='true' />  
        <!-- session失效时间(毫秒) --> 
        <property name='globalSessionTimeout' value='1800000' />
        <property name='sessionDAO' ref='customShiroSessionDao' />  
    </bean>

    <!-- Shiro安全管理器 -->
    <bean id='securityManager' class='org.apache.shiro.web.mgt.DefaultWebSecurityManager'>
        <property name='realm' ref='customRealm' />
        <property name='sessionManager' ref='sessionManager' />
        <property name='cacheManager' ref='cacheManager' />
    </bean>

    <!-- 自定义Realm -->
    <bean id='customRealm' class='cn.zifangsky.shiro.CustomRealm' />

    <bean id='shiroFilter' class='org.apache.shiro.spring.web.ShiroFilterFactoryBean'>
        <property name='securityManager' ref='securityManager' />
        <property name='loginUrl' value='/user/user/login.html' />
        <!-- <property name='successUrl' value='/login/loginSuccessFull' /> -->
        <property name='unauthorizedUrl' value='/error/403.jsp' />
        <!-- <property name='filters'>
            <map>
                <entry key='auth' value-ref='userFilter'/>
            </map>  
        </property> -->
        <property name='filterChainDefinitions'>
            <value>
                /error/* = anon
                /scripts/* = anon
                /user/user/check.html = anon
                /user/user/verify.html = anon
                /user/user/checkVerifyCode.html = anon
                /user/user/logout.html = logout
                /**/*.htm* = authc
        /**/*.json* = authc
            </value>
        </property>
    </bean>

    <!-- <bean id='cleanFilter' class='cn.zifangsky.shiro.CleanFilter'/> -->
    <bean id='lifecycleBeanPostProcessor' class='org.apache.shiro.spring.LifecycleBeanPostProcessor'/>

</beans>

(4)测试:

i)本地简单测试:

将同一项目部署到本地两个不同端口的Tomcat中,然后在其中一个Tomcat登录,接着直接在另一个Tomcat上访问登录后的URL,观察是否可以直接访问还是跳转到登录页面

ii)完整分布式环境测试:

首先将测试项目部署到两个服务器上的Tomcat中,我这里的访问路径分别是:

192.168.1.30:9080
192.168.1.31:9080

接着配置nginx访问(PS:nginx所在IP是:192.168.1.31):

server {
    server_name  localhost;
    listen 7888;

    location /WebSocketDemo
        {       
              proxy_redirect off;
              proxy_set_header        Host $host:7888;
              proxy_set_header        X-Real-IP $remote_addr;
              proxy_set_header        X-Forwarded-For $proxy_add_x_forwarded_for;
              proxy_pass http://demo/WebSocketDemo;
              proxy_set_header   Cookie $http_cookie;
        }

    #access_log  on;
    limit_conn perip 1000;  #同一ip并发数为50,超过会返回503
    access_log logs/access_test.log zifangsky_log;
 }

对应的upstream是:

upstream demo {
  server 192.168.1.30:9080;
  server 192.168.1.31:9080;
}

从上面可以看出,这里设置的nginx的负载均衡策略是默认策略——轮询

最后在浏览器中访问:http://192.168.1.31:7888/WebSocketDemo/user/user/login.html

登录之后,不断刷新页面并观察nginx的日志:

可以发现,经过nginx的反向代理之后,虽然每次访问的实际服务地址都不一样,但是我们的登录状态并没有丢失——并没有跳转到登录页面。这就证明了这个测试小集群的session的确实现了共享,也就是说session保存到了redis集群中,并不受具体的业务服务器的更改而发生改变

当然,我们也可以登录到redis集群,查询一下该sessionId对应的session值:

参考:

http://www.cnblogs.com/sunshine-2015/p/5686750.html

    本站是提供个人知识管理的网络存储空间,所有内容均由用户发布,不代表本站观点。请注意甄别内容中的联系方式、诱导购买等信息,谨防诈骗。如发现有害或侵权内容,请点击一键举报。

    0条评论

    发表

    请遵守用户 评论公约

    类似文章 更多
    喜欢该文的人也喜欢 更多

    ×
    ×

    ¥.00

    微信或支付宝扫码支付:

    开通即同意《个图VIP服务协议》

    全部>>