Session 一致性

最新推荐文章于 2022-03-30 19:55:13 发布

我的架构师之路

最新推荐文章于 2022-03-30 19:55:13 发布

阅读量415

点赞数

分类专栏：分布式文章标签： session

本文链接：https://blog.csdn.net/qq_16681279/article/details/78184066

版权

分布式专栏收录该内容

12 篇文章 1 订阅

订阅专栏

个人备忘

Nginx –ip_hash

找到nginx 安装目录下的 nginx.conf文件

//修改如下配置
include  gzip.conf;    
       upstream localhost {    
           #ip_hash    
      ip_hash;    
      server localhost:8080;    
      server localhost:9080;    
     }

优点 ：
（1）配置简单，对应用无侵入性，不需要修改代码。
（2）只要hash属性是均匀的，多台web-server的负载是均衡的
（3）便于服务器水平扩展
（4）安全性较高

缺点：
（1）服务器重启造成部分session 丢失。
（2）水平扩展中也会造成部分session丢失
（3）存在单点负载高的风险
（4）某台服务器宕机了，会造成部分用户访问慢的问题。//说明 ： 因为他有心跳机制。

服务器的session 复制

tomcat的session复制是基于IP组播(multicast)来完成的, 详细的IP组播介绍可以参考这里.
简单的说就是需要进行集群的tomcat通过配置统一的组播IP和端口来确定一个集群组, 当一个node的session发生变更的时候, 它会向IP组播发送变更的数据, IP组播会将数据分发给所有组里的其他成员(node).

server.xml 配置如下(这里所有的tomcat都在不同的物理主机, 如果在同一台主机上需要改tomcat的tcpListenPort)

<Cluster className="org.apache.catalina.ha.tcp.SimpleTcpCluster"  
                 channelSendOptions="8">  

          <Manager className="org.apache.catalina.ha.session.DeltaManager"  
                   expireSessionsOnShutdown="false"  
                   notifyListenersOnReplication="true"/>  

          <Channel className="org.apache.catalina.tribes.group.GroupChannel">  
            <Membership className="org.apache.catalina.tribes.membership.McastService"  
                        address="228.0.0.4"  
                        port="45564"  
                        frequency="500"  
                        dropTime="3000"/>  
            <Receiver className="org.apache.catalina.tribes.transport.nio.NioReceiver"  
                      address="auto"  
                      port="4000"  
                      autoBind="100"  
                      selectorTimeout="5000"  
                      maxThreads="6"/>  

            <Sender className="org.apache.catalina.tribes.transport.ReplicationTransmitter">  
              <Transport className="org.apache.catalina.tribes.transport.nio.PooledParallelSender"/>  
            </Sender>  
            <Interceptor className="org.apache.catalina.tribes.group.interceptors.TcpFailureDetector"/>  
            <Interceptor className="org.apache.catalina.tribes.group.interceptors.MessageDispatch15Interceptor"/>  
          </Channel>  

          <Valve className="org.apache.catalina.ha.tcp.ReplicationValve"  
                 filter=""/>  
          <Valve className="org.apache.catalina.ha.session.JvmRouteBinderValve"/>  

          <Deployer className="org.apache.catalina.ha.deploy.FarmWarDeployer"  
                    tempDir="/tmp/war-temp/"  
                    deployDir="/tmp/war-deploy/"  
                    watchDir="/tmp/war-listen/"  
                    watchEnabled="false"/>  

          <ClusterListener className="org.apache.catalina.ha.session.JvmRouteSessionIDBinderListener"/>  
          <ClusterListener className="org.apache.catalina.ha.session.ClusterSessionListener"/>  
</Cluster>

//优点
（1）对应用无侵入性，不需要修改代码
（2）能适应各种负载均衡策略
（3）服务器重启或者宕机不会造成session丢失
（4）安全性较高

//缺点
（1）session同步会有一定的延迟
（2）占用内网带宽资源
（3）受限制于内存资源，水平扩展能力差
（4）服务器数量较多就GG
（5）序列化反序列化消耗cpu 性能

坑
这里写图片描述

Session 统一缓存

基于redis , 利用redis 的 key 的过期时间来保证session 的失效时间（当session 有操作，过期时间ttl 会加长）。个人推荐使用这种，因为 redis 的hash存储跟 servlet session 存储很类似。

//优点
（1）能适应各种负载均衡策略
（2）服务器重启或者宕机不会造成session丢失
（3）安全性较高
（4）扩展能力强
（5）适合集群数量大时使用

//缺点
（1）对应用有入侵，需要增加相关配置。
（2）增加一次网络开销，用户体验降低
（3）序列化反序列化消耗cpu性能

配置如下：

增加redis client 和 spring session 依赖
修改web.xml, 增加filter ： springSessionRepom.xml,增加spring-session-data-redispositoryFilter ;
修改spring配置文件，在容器中注入spring session 和redis 相关的bean ；


//相关依赖

<!-- Spring 整合 Redis -->
<dependency><!--  session 跨域到 redis中 ，解决Nginx反向代理问题。  -->
    <groupId>org.springframework.session</groupId>
    <artifactId>spring-session</artifactId>
    <version>1.3.0.RELEASE</version>
      </dependency> 
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>2.8.0</version>
</dependency>

//web.xml 配置

<!-- 过滤器   session跨域 共享 -->
 <filter>
     <filter-name>springSessionRepositoryFilter</filter-name>
     <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
 </filter>
 <filter-mapping>
     <filter-name>springSessionRepositoryFilter</filter-name>
     <url-pattern>/*</url-pattern>
 </filter-mapping>

// 注入bean
spring-redis.xml


<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="  
            http://www.springframework.org/schema/beans  
            http://www.springframework.org/schema/beans/spring-beans.xsd  
            http://www.springframework.org/schema/context   
           http://www.springframework.org/schema/context/spring-context.xsd">


    <!-- redis 连接池   -->
    <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <property name="maxTotal" value="${redis.pool.maxTotal}" />
        <property name="maxIdle" value="${redis.pool.maxIdle}" />
        <property name="minIdle" value="${redis.pool.minIdle}" />
        <property name="testOnBorrow" value="${redis.pool.testOnBorrow}" />
    </bean>
    <bean id="jedisConnectionFactory"
        class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
        <property name="hostName"   value="${redis.host}" />
        <property name="port"       value="${redis.port}" />
        <!-- <property name="password"   value="${redis.password}" /> -->
        <property name="timeout"    value="${redis.timeout}" />  
        <property name="poolConfig" ref="jedisPoolConfig" />
    </bean>
    <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
        <property name="connectionFactory" ref="jedisConnectionFactory"></property>
        <property name="keySerializer">
            <bean
                class="org.springframework.data.redis.serializer.StringRedisSerializer" />
        </property>
        <property name="valueSerializer">
            <bean
                class="org.springframework.data.redis.serializer.StringRedisSerializer" />
        </property>
    </bean>


    <!-- Spring  session 用redis存储 -->
    <bean id="redisHttpSessionConfiguration"  
          class="org.springframework.session.data.redis.config.annotation.web.http.RedisHttpSessionConfiguration">  
        <property name="maxInactiveIntervalInSeconds" value="${session.maxInactiveIntervalInSeconds}"  /> 
    </bean> 

</beans>

jedis.properties

redis.pool.maxTotal=100
redis.pool.maxIdle=200
redis.pool.minIdle=10
redis.pool.maxActive=1024  
redis.pool.maxWait=1000  
redis.pool.testOnBorrow=true 

session.maxInactiveIntervalInSeconds=600

redis.host=localhost
redis.port=6379
#redis.password=four2BeltTwoKing
redis.timeout=100000

原理剖析

客户端发起请求–servlet 容器 – tomcat session 中获取session 对象。

这里写图片描述

应用：

这里写图片描述

最后一种重写代码：

重写httpServletRequest

重写getSession（）方法。

package com.dongnao.jack.servlet;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

public class MyHttpServletRequest extends HttpServletRequestWrapper {

    private HttpServletRequest req;

    private HttpServletResponse resp;

    public MyHttpServletRequest(HttpServletRequest request,
            HttpServletResponse resp) {
        super(request);
        this.req = request;
        this.resp = resp;
    }

    public HttpSession getSession() {
        return new MyHttpSession(req, resp);
    }
}

子类MyHttpSession

重写 setAttribute() ， getAttribute() 两个方法，将数据存储到缓存中（memcached,redis）, 然后去读取。

此方法跟spring-session 方法异曲同工。

package com.dongnao.jack.servlet;

import java.util.Enumeration;
import java.util.List;
import java.util.UUID;

import javax.servlet.ServletContext;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import javax.servlet.http.HttpSessionContext;

import com.alibaba.fastjson.JSONObject;
import com.dongnao.jack.redis.RedisApi;

public class MyHttpSession implements HttpSession {

    private HttpServletRequest req;

    private HttpServletResponse resp;

    private static String cacheKey = "sessionId";

    private ThreadLocal<String> local = new ThreadLocal<String>();

    public MyHttpSession(HttpServletRequest req, HttpServletResponse resp) {
        this.req = req;
        this.resp = resp;
    }

    public long getCreationTime() {
        // TODO Auto-generated method stub
        return 0;
    }

    public String getId() {
        // TODO Auto-generated method stub
        return null;
    }

    public long getLastAccessedTime() {
        // TODO Auto-generated method stub
        return 0;
    }

    public ServletContext getServletContext() {
        // TODO Auto-generated method stub
        return null;
    }

    public void setMaxInactiveInterval(int interval) {
        // TODO Auto-generated method stub

    }

    public int getMaxInactiveInterval() {
        // TODO Auto-generated method stub
        return 0;
    }

    public HttpSessionContext getSessionContext() {
        // TODO Auto-generated method stub
        return null;
    }

    public Object getAttribute(String name) {
        //1、从我们的cookie拿到对应的sessionID
        String sessionId = this.getSessionIdFromCookie();

        if (sessionId == null) {
            return null;
        }
        //2、从redis中拿出对应的数据
        List<String> list = RedisApi.lrange(sessionId);
        return getValueByKey(name, list);
    }

    private Object getValueByKey(String key, List<String> list) {

        for (String each : list) {
            JSONObject jo = JSONObject.parseObject(each);

            if (jo.containsKey(key)) {
                return jo.get(key);
            }
        }
        return null;
    }

    public Object getValue(String name) {
        // TODO Auto-generated method stub
        return null;
    }

    public Enumeration<String> getAttributeNames() {
        // TODO Auto-generated method stub
        return null;
    }

    public String[] getValueNames() {
        // TODO Auto-generated method stub
        return null;
    }

    /* 
     * 我们在这个方法里面，必须要把我们的信息存储到我们的redis缓存中
     */
    public void setAttribute(String name, Object value) {
        //1我们要把redis的key存储到哪里去？必须要满足每一次jack老师的请求必须要从redis中找到唯一对应的那个session信息
        //我们必须要把我们的key存储到我们的cookie
        String sessionId = getSessionIdFromCookie();

        if (sessionId == null) {
            sessionId = local.get();
            if (sessionId == null) {
                sessionId = "dnjack#" + UUID.randomUUID();
                local.set(sessionId);
            }
        }

        //2、把我们的信息存储到redis服务中
        JSONObject jo = new JSONObject();
        jo.put(name, value);
        RedisApi.lpush(sessionId, jo.toJSONString());

        //3、把sessoinId存储到我们的cookie
        writeCooke(sessionId);
    }

    private void writeCooke(String sessinId) {
        Cookie cookie = new Cookie(cacheKey, sessinId);
        cookie.setPath("/");
        resp.addCookie(cookie);
    }

    private String getSessionIdFromCookie() {
        Cookie[] cookies = req.getCookies();
        if (cookies != null) {
            for (Cookie cookie : cookies) {
                if (cacheKey.equals(cookie.getName())) {
                    return cookie.getValue();
                }
            }
        }
        return null;
    }

    public void putValue(String name, Object value) {
        // TODO Auto-generated method stub

    }

    public void removeAttribute(String name) {
        // TODO Auto-generated method stub

    }

    public void removeValue(String name) {
        // TODO Auto-generated method stub

    }

    public void invalidate() {
        // TODO Auto-generated method stub

    }

    public boolean isNew() {
        // TODO Auto-generated method stub
        return false;
    }

}

拦截器

加入我们重写后的MyHttpServletRequest 。

package com.dongnao.jack.servlet;

import java.io.IOException;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

//@WebFilter(urlPatterns = "/*")
public class MyFilter implements Filter {

    public void init(FilterConfig filterConfig) throws ServletException {
        // TODO Auto-generated method stub

    }

    //实例化MyHttpServletRequest
    public void doFilter(ServletRequest request, ServletResponse response,
            FilterChain chain) throws IOException, ServletException {
        chain.doFilter(new MyHttpServletRequest((HttpServletRequest)request,
                (HttpServletResponse)response), response);
    }

    public void destroy() {

    }

}

redis连接池

package com.dongnao.jack.redis;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;
import java.util.Map;
import java.util.Properties;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

public class RedisApi {

    private static JedisPool pool;

    private static Properties prop = null;

    static {
        InputStream in = RedisApi.class.getClassLoader()
                .getResourceAsStream("com/agui/redis/redis.properties");



        prop = new Properties();
        try {
            prop.load(in);
        }
        catch (IOException e) {
            e.printStackTrace();
        }

        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxTotal(Integer.valueOf(prop.getProperty("MAX_TOTAL")));
        config.setMaxIdle(Integer.valueOf(prop.getProperty("MAX_IDLE")));

        config.setMaxWaitMillis(Integer.valueOf(prop.getProperty("MAX_WAIT_MILLIS")));

        config.setTestOnBorrow(Boolean.valueOf(prop.getProperty("TEST_ON_BORROW")));
        config.setTestOnReturn(Boolean.valueOf(prop.getProperty("TEST_ON_RETURN")));
        config.setTestWhileIdle(Boolean.valueOf(prop.getProperty("TEST_WHILE_IDLE")));
        pool = new JedisPool(config, prop.getProperty("REDIS_IP"),
                Integer.valueOf(prop.getProperty("REDIS_PORT")), 100000);
    }

    /**
     * 获取连接池
     */
    public static JedisPool getPool() {

        if (pool == null) {

            JedisPoolConfig config = new JedisPoolConfig();
            config.setMaxTotal(Integer.valueOf(prop.getProperty("MAX_TOTAL")));
            config.setMaxIdle(Integer.valueOf(prop.getProperty("MAX_IDLE")));

            config.setMaxWaitMillis(Integer.valueOf(prop.getProperty("MAX_WAIT_MILLIS")));

            config.setTestOnBorrow(Boolean.valueOf(prop.getProperty("TEST_ON_BORROW")));
            config.setTestOnReturn(Boolean.valueOf(prop.getProperty("TEST_ON_RETURN")));
            config.setTestWhileIdle(Boolean.valueOf(prop.getProperty("TEST_WHILE_IDLE")));
            pool = new JedisPool(config, prop.getProperty("REDIS_IP"),
                    Integer.valueOf(prop.getProperty("REDIS_PORT")));
        }

        return pool;
    }

    public static void returnResource(JedisPool pool, Jedis redis) {
        if (redis != null) {
            pool.returnResource(redis);
        }
    }

    public static Long hdel(String key, String key1) {
        Jedis jedis = null;
        try {
            jedis = pool.getResource();
            return jedis.hdel(key, key1);
        }
        catch (Exception e) {

        }
        finally {
            returnResource(pool, jedis);
        }
        return null;
    }

    /** 
     * get
     *  
     * @param key 
     * @return 
     */
    public static String get(String key) {
        Jedis jedis = null;
        String value = null;
        try {
            jedis = pool.getResource();
            value = jedis.get(key);
        }
        catch (Exception e) {

        }
        finally {
            returnResource(pool, jedis);
        }
        return value;
    }

    /**
     * set
     */
    public static String set(String key, String value) {
        Jedis jedis = null;
        try {
            jedis = pool.getResource();
            return jedis.set(key, value);
        }
        catch (Exception e) {

            return "0";
        }
        finally {
            returnResource(pool, jedis);
        }
    }

    public static String set(String key, String value, int expire) {
        Jedis jedis = null;
        try {
            jedis = pool.getResource();
            jedis.expire(key, expire);
            return jedis.set(key, value);
        }
        catch (Exception e) {

            return "0";
        }
        finally {
            returnResource(pool, jedis);
        }
    }

    public static Long del(String key) {
        Jedis jedis = null;
        try {
            jedis = pool.getResource();
            return jedis.del(key);
        }
        catch (Exception e) {
            return null;
        }
        finally {
            returnResource(pool, jedis);
        }
    }

    public static Long lpush(String key, String... strings) {
        Jedis jedis = null;
        try {
            jedis = pool.getResource();
            return jedis.lpush(key, strings);
        }
        catch (Exception e) {

            return 0L;
        }
        finally {
            returnResource(pool, jedis);
        }
    }

    public static List<String> lrange(String key) {
        Jedis jedis = null;
        String value = null;
        try {
            jedis = pool.getResource();
            return jedis.lrange(key, 0, -1);
        }
        catch (Exception e) {
            return null;
        }
        finally {
            returnResource(pool, jedis);
        }
    }

    public static String hmset(String key, Map map) {
        Jedis jedis = null;
        try {
            jedis = pool.getResource();
            return jedis.hmset(key, map);
        }
        catch (Exception e) {

            return "0";
        }
        finally {
            returnResource(pool, jedis);
        }
    }

    public static List<String> hmget(String key, String... strings) {
        Jedis jedis = null;
        String value = null;
        try {
            jedis = pool.getResource();
            return jedis.hmget(key, strings);
        }
        catch (Exception e) {

        }
        finally {
            returnResource(pool, jedis);
        }
        return null;
    }
}

redis.property文件

MAX_TOTAL = 10000
#控制一个pool最多有多少个状态为idle(空闲的)的jedis实例
MAX_IDLE = 10
#表示当borrow(引入)一个jedis实例时，最大的等待时间，如果超过等待时间，则直接抛出JedisConnectionException；
MAX_WAIT = 100000
#在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的
TEST_ON_BORROW = true
#在进行returnObject对返回的connection进行validateObject校验
TEST_ON_RETURN = true
#表示当borrow(引入)一个jedis实例时，最大的等待时间，如果超过等待时间，则直接抛出JedisConnectionException；  
MAX_WAIT_MILLIS = 100000
#从Redis host redis服务器IP 101.200.129.112
REDIS_IP = 39.108.193.58
#从Redis redis服务器port
REDIS_PORT = 6379
#定时对线程池中空闲的链接进行validateObject校验
TEST_WHILE_IDLE =true


#定时对线程池中空闲的链接进行validateObject校验1
#定时对线程池中空闲的链接进行validateObject校验2
#定时对线程池中空闲的链接进行validateObject校验3
#定时对线程池中空闲的链接进行validateObject校验4

我的架构师之路

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Session 一致性

个人备忘Nginx –ip_hash找到nginx 安装目录下的 nginx.conf文件//修改如下配置include gzip.conf; upstream localhost { #ip_hash ip_hash; server localhost:8080; server lo
复制链接

扫一扫