Spring Session + Redis 实现Session的分布式存储

最新推荐文章于 2024-07-20 10:08:36 发布

boy_cto_tony

最新推荐文章于 2024-07-20 10:08:36 发布

阅读量1.4k

点赞数

文章标签： session redis centos 分布式存储 spring

本文链接：https://blog.csdn.net/ITTechnologyHome/article/details/77897699

版权

1 Redis的安装及其基本使用

1.1 环境说明

CentOS7.3
Redis-3.2.10

1.2 Redis下载

使用wget http://download.redis.io/releases/redis-3.2.10.tar.gz 即可下载

[root@tony Downloads]# wget http://download.redis.io/releases/redis-3.2.10.tar.gz #下载Redis3.2
--2017-09-05 18:50:20-- http://download.redis.io/releases/redis-3.2.10.tar.gz
Resolving download.redis.io (download.redis.io)... 109.74.203.151
Connecting to download.redis.io (download.redis.io)|109.74.203.151|:80... connected.
HTTP request sent, awaiting response... 200 OK
Length: 1550261 (1.5M) [application/x-gzip]
Saving to: ‘redis-3.2.10.tar.gz’
100%[===============================================================================================================================>] 1,550,261 11.6KB/s in 1m 54s
2017-09-05 18:52:18 (13.3 KB/s) - ‘redis-3.2.10.tar.gz’ saved [1550261/1550261]

1.3 Redis安装

主要是将下载后的压缩包解压后复制到/usr/local/redis-3.2.10文件夹后使用make&make install安装

[root@tony Downloads]# tar -xvf redis-3.2.10.tar.gz  #解压
[root@tony Downloads]# mv redis-3.2.10 /usr/local/redis-3.2.10 #将redis-3.2.10移动到/usr/local/redis-3.2.10目录中
[root@tony Downloads]# cd /usr/local/redis-3.2.10/
[root@tony redis-3.2.10]# make #编译
make编译之后会在src目录下生成如下图所示的可执行文件

编译生成目录

[root@tony redis-3.2.10]# make install # 执行make install 将make编译生成的执行文件复制到/usr/local/bin目录下
cd src && make install
make[1]: Entering directory `/usr/local/redis-3.2.10/src'
Hint: It's a good idea to run 'make test' ;)
INSTALL install
INSTALL install
INSTALL install
INSTALL install
INSTALL install
make[1]: Leaving directory `/usr/local/redis-3.2.10/src'

1.4 Redis初始化配置

[root@tony src]# vim /usr/local/redis-3.2.10/redis.conf   #编辑配置文件
修改如下配置:
把bind 127.0.0.1 #修改为bind 0.0.0.0.0
requirepass guanglei #设置密码为guanglei

1.5 Redis的启动和关闭

启动Redis

[root@tony src]# redis-server ../redis.conf & #启动Redis

查看进程并关闭Redis

[root@tony src]#  ps -ef|grep redis
root 70264 59484 0 00:08 pts/4 00:00:00 redis-server 0.0.0.0:6379
root 70273 59484 0 00:08 pts/4 00:00:00 grep --color=auto redis
[root@tony src]# kill - 9 70264

1.6 使用Redis Desktop Manager连接Redis服务

连接Redis

2 SpringBoot-Session集成Redis

1 添加依赖

<dependency>
 <groupId>org.springframework.session</groupId>
 <artifactId>spring-session-data-redis</artifactId>
 <version>1.3.1.RELEASE</version>
</dependency>

2 在GUOYUN_P2P_CONFIG_URL_PREFIX 环境变量下添加redis.properties，内容如下:

# redis 连接配置
redis.host=192.168.137.128
redis.port=6379
redis.password=guanglei
#redis 数据配置
redis.database=0
# redis 连接池配置
# 连接池最大连接数（使用负值表示没有限制）
redis.pool.max-active=20
# 连接池最大阻塞等待时间（使用负值表示没有限制）
redis.pool.max-wait=-1
# 连接池中的最大空闲连接
redis.pool.max-idle=10
# 连接池中的最小空闲连接
redis.pool.min-idle=2
# 连接超时时间（毫秒）
redis.timeout=15000

3 创建redis.properteis文件解析对象

@Bean
public PropertiesFactoryBean redisSettings(){

    PropertiesFactoryBean propertiesFactoryBean =new PropertiesFactoryBean();
    String path = System.getenv("GUOYUN_P2P_CONFIG_URL_PREFIX");
    Resource resource=new FileSystemResource(path+"/redis.properties");
    propertiesFactoryBean.setLocation(resource);
    return propertiesFactoryBean;
}

4 创建RedisConfiguation

package com.hengpeng.itfints.configuration;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.GenericToStringSerializer;
import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import redis.clients.jedis.JedisPoolConfig;

import java.io.Serializable;
import java.lang.reflect.Method;

/**
 * Redis Configuration
 *
 * @author guanglei liuguanglei@ekeyfund.com
 * @create 2017-09-05-10:08
 * @see
 * @since JDK1.8u141
 */
@Configuration
public class RedisConfiguration {
    /*从redis.properties读取*/

    @Value("#{redisSettings['redis.host']}")
    private String host;
    @Value("#{redisSettings['redis.port']}")
    private int port;
    @Value("#{redisSettings['redis.password']}")
    private String password;

    @Value("#{redisSettings['redis.database']}")
    private int database;

    @Value("#{redisSettings['redis.pool.max-active']}")
    private int maxActive;

    @Value("#{redisSettings['redis.pool.max-wait']}")
    private int maxWait;

    @Value("#{redisSettings['redis.pool.max-idle']}")
    private int maxIdle;

    @Value("#{redisSettings['redis.pool.min-idle']}")
    private int minIdle;

    @Value("#{redisSettings['redis.timeout']}")
    private int timeOut;


    /**
     * Redis连接配置
     * @return
     */
    @Bean
    public JedisPoolConfig jedisPoolConfig(){

        JedisPoolConfig jedisPoolConfig=new JedisPoolConfig();
        jedisPoolConfig.setMaxIdle(maxIdle);
        jedisPoolConfig.setMaxWaitMillis(maxWait);
        jedisPoolConfig.setMaxTotal(maxActive);
        jedisPoolConfig.setMinIdle(minIdle);
        jedisPoolConfig.setMaxIdle(maxIdle);
        return jedisPoolConfig;
    }


    /**
     * Redis连接池
     * @param jedisPoolConfig
     * @return
     */
    @Bean
    public JedisConnectionFactory jedisConnectionFactory(JedisPoolConfig jedisPoolConfig){

        JedisConnectionFactory jedisConnectionFactory =new JedisConnectionFactory();
        jedisConnectionFactory.setHostName(host);
        jedisConnectionFactory.setPort(port);
        jedisConnectionFactory.setPassword(password);
        jedisConnectionFactory.setDatabase(database);
        jedisConnectionFactory.setTimeout(timeOut);
        jedisConnectionFactory.setPoolConfig(jedisPoolConfig);
        return jedisConnectionFactory;
    }


    @Bean
    public RedisTemplate<Serializable,Serializable> redisTemplate(JedisConnectionFactory jedisConnectionFactory){

        RedisTemplate<Serializable,Serializable> redisTemplate =new RedisTemplate<>();
        redisTemplate.setConnectionFactory(jedisConnectionFactory);

        StringRedisSerializer stringRedisSerializer=new StringRedisSerializer();
        JdkSerializationRedisSerializer jdkSerializationRedisSerializer=new JdkSerializationRedisSerializer();

        redisTemplate.setKeySerializer(stringRedisSerializer);
        redisTemplate.setHashKeySerializer(stringRedisSerializer);

        redisTemplate.setValueSerializer(jdkSerializationRedisSerializer);
        redisTemplate.setHashValueSerializer(jdkSerializationRedisSerializer);

        return redisTemplate;
    }

}

5 封装Redis常用操作API

package com.hengpeng.itfints.core.redis;

import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.ListOperations;
import org.springframework.data.redis.core.SetOperations;
import org.springframework.data.redis.core.ZSetOperations;

import java.io.Serializable;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * Redis操作常用API
 */
 public interface RedisService {




     void set(Serializable key, Serializable value);


     void set(Serializable key, Serializable value, long liveTime);


     void setNX(Serializable key, Serializable value);


     void setNX(Serializable key, Serializable value, long liveTime);


     void setList(Serializable key, List<Serializable> values, long liveTime);

     void setLeftList(Serializable key, Serializable value, long liveTime);

     void setRightList(Serializable key, Serializable value, long liveTime);

     void setMap(Serializable key, Map<Serializable, Serializable> parameterMap, long liveTime);

     long deleteByKeys(final Serializable... keys);

     long deleteByKeys(final Set<byte[]> keys);


     Map<Serializable, Serializable> getMap(Serializable key);


     Serializable getListFirstElement(Serializable key);


     Serializable getSetFirstElement(Serializable key);

     Set<Serializable> getSet(Serializable key);


     List<Serializable> getRangeList(Serializable key, int startIndex, int endIndex);


     Serializable get(Serializable key);

     Set<Serializable> keys(String pattern);

     boolean exists(Serializable key);

     String flushRedis();

     long sizeForRedis();

     String ping();

     Boolean expired(Serializable key, int second);

     Boolean lock(Serializable key, Serializable value);

     ListOperations<Serializable, Serializable> getOptionsForList();

     SetOperations<Serializable,Serializable> getOptionsForSet();

     ZSetOperations<Serializable, Serializable> getOptionsForZSet();

     HashOperations<Serializable, Serializable, Serializable> getOptionsForHash();

     Serializable leftPop(Serializable key);

     Serializable rightPop(Serializable key);
}

RedisServiceImpl.java

package com.hengpeng.itfints.core.redis;

import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.SerializationUtils;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.*;
import org.springframework.stereotype.Service;

import java.io.Serializable;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * Redis常用API封装实现
 *
 * @author guanglei liuguanglei@ekeyfund.com
 * @create 2017-09-05-16:24
 * @see
 * @since JDK1.8u141
 */
@Service
public class RedisServiceImpl implements RedisService{


    private static final Logger logger =Logger.getLogger(RedisServiceImpl.class);

    @Autowired
    private RedisTemplate<Serializable, Serializable> redisTemplate;



    @Override
    public long deleteByKeys(final Serializable... keys) {
        return redisTemplate.execute(new RedisCallback<Long>() {
            @Override
            public Long doInRedis(RedisConnection connection)
                    throws DataAccessException {
                Long result =0L;
                byte[] keyByteArray=null;
                for(int i=0;i<keys.length;i++){
                    keyByteArray= SerializationUtils.serialize(keys[i]);
                    result=connection.del(keyByteArray);
                }
                return result;
            }
        });
    }

    @Override
    public long deleteByKeys(final Set<byte[]> keys) {
        return redisTemplate.execute(new RedisCallback<Long>() {
            @Override
            public Long doInRedis(RedisConnection connection)
                    throws DataAccessException {
                Long result =0L;
                Iterator<byte[]> iter=keys.iterator();
                while(iter.hasNext()){
                    result=connection.del(iter.next());
                }
                return result;
            }
        });
    }

    @Override
    public void set(Serializable key, Serializable value) {
        this.set(key, value, 0L);
    }

    @Override
    public void set(final Serializable key, final Serializable value, final long liveTime) {
        this.redisTemplate.execute(new RedisCallback<Void>() {
            @Override
            public Void doInRedis(RedisConnection connection)
                    throws DataAccessException {
                byte[] keyByteArray =SerializationUtils.serialize(key);
                byte[] valueByteArray =SerializationUtils.serialize(value);
                connection.set(keyByteArray, valueByteArray);
                if(liveTime>0){
                    connection.expire(keyByteArray, liveTime);
                }
                return null;
            }
        });
    }

    @Override
    public void setNX(Serializable key, Serializable value) {
        this.setNX(key, value, 0L);
    }

    @Override
    public void setNX(final Serializable key, final Serializable value, final long liveTime) {
        this.redisTemplate.execute(new RedisCallback<Void>() {
            @Override
            public Void doInRedis(RedisConnection connection)
                    throws DataAccessException {
                byte[] keyByteArray =SerializationUtils.serialize(key);
                byte[] valueByteArray =SerializationUtils.serialize(value);
                connection.setNX(keyByteArray, valueByteArray);
                if(liveTime>0){
                    connection.expire(keyByteArray, liveTime);
                }
                return null;
            }
        });
    }

    @Override
    public void setList(Serializable key, List<Serializable> values,
                        long liveTime) {
        this.getOptionsForList().leftPushAll(key, values.toArray());
        if(liveTime>0){
            this.redisTemplate.expire(key, liveTime, TimeUnit.MILLISECONDS);
        }
    }

    @Override
    public void setLeftList(Serializable key, Serializable value, long liveTime) {
        this.getOptionsForList().leftPush(key, value);
        if (liveTime > 0) {
            redisTemplate.expire(key, liveTime, TimeUnit.MILLISECONDS);
        }
    }

    @Override
    public void setRightList(Serializable key, Serializable value, long liveTime) {
        this.getOptionsForList().rightPush(key, value);
        if (liveTime > 0) {
            this.redisTemplate.expire(key, liveTime, TimeUnit.MILLISECONDS);
        }
    }

    @Override
    public void setMap(Serializable key,
                       Map<Serializable, Serializable> parameterMap, long liveTime) {
        this.getOptionsForHash().putAll(key, parameterMap);
        if (liveTime > 0) {
            this.redisTemplate.expire(key, liveTime, TimeUnit.MICROSECONDS);
        }
    }

    @Override
    public Map<Serializable, Serializable> getMap(Serializable key) {
        return this.getOptionsForHash().entries(key);
    }

    @Override
    public Serializable getListFirstElement(Serializable key) {
        List<Serializable> result=this.getRangeList(key, 0, -1);
        if(CollectionUtils.isNotEmpty(result)){
            return result.get(0);
        }
        return null;
    }

    @Override
    public Serializable getSetFirstElement(Serializable key) {
        Serializable result ="";
        Set<Serializable> resultSet =this.getOptionsForSet().members(key);
        if(CollectionUtils.isNotEmpty(resultSet)){
            Iterator<Serializable> iterator=resultSet.iterator();
            if(iterator.hasNext()){
                result=iterator.next();
            }
        }
        return result;
    }

    @Override
    public Set<Serializable> getSet(Serializable key) {
        return this.getOptionsForSet().members(key);
    }

    @Override
    public List<Serializable> getRangeList(Serializable key, int startIndex,
                                           int endIndex) {
        return this.getOptionsForList().range(key, startIndex, endIndex);
    }

    @Override
    public Serializable get(final Serializable key) {
        return this.redisTemplate.execute(new RedisCallback<Serializable>() {
            @Override
            public Serializable doInRedis(RedisConnection connection)
                    throws DataAccessException {
                byte[]byteArrayKey=SerializationUtils.serialize(key);
                byte[]resultByte=connection.get(byteArrayKey);
                if(resultByte!=null&&resultByte.length>0){
                    return (Serializable) SerializationUtils.deserialize(resultByte);
                }
                return null;
            }

        });
    }

    @Override
    public Set<Serializable> keys(String pattern) {
        return this.redisTemplate.keys(pattern);
    }

    @Override
    public boolean exists(final Serializable key) {
        Boolean sign=this.redisTemplate.execute(new RedisCallback<Boolean>() {

            @Override
            public Boolean doInRedis(RedisConnection connection)
                    throws DataAccessException {
                byte[] byteArrayByte=SerializationUtils.serialize(key);

                return connection.exists(byteArrayByte);
            }
        });
        return sign.booleanValue();
    }

    @Override
    public String flushRedis() {
        return this.redisTemplate.execute(new RedisCallback<String>() {
            @Override
            public String doInRedis(RedisConnection connection)
                    throws DataAccessException {
                connection.flushDb();
                return "ok";
            }
        });
    }

    @Override
    public long sizeForRedis() {
        return this.redisTemplate.execute(new RedisCallback<Long>() {

            @Override
            public Long doInRedis(RedisConnection connection)
                    throws DataAccessException {
                return connection.dbSize();
            }
        });
    }

    @Override
    public String ping() {
        return this.redisTemplate.execute(new RedisCallback<String>() {

            @Override
            public String doInRedis(RedisConnection connection)
                    throws DataAccessException {
                return connection.ping();
            }
        });
    }

    @Override
    public Boolean expired(final Serializable key,final int second) {
        return this.redisTemplate.execute(new RedisCallback<Boolean>() {

            @Override
            public Boolean doInRedis(RedisConnection connection)
                    throws DataAccessException {
                byte[]byteArrayKey=SerializationUtils.serialize(key);
                return connection.expire(byteArrayKey, second);
            }
        });
    }

    @Override
    public Boolean lock(Serializable key, Serializable value) {
        Boolean ret = Boolean.FALSE;
        try {
            this.setNX(key, value);
            ret = Boolean.TRUE;
        }
        catch (Exception ex) {
            logger.error("get error.", ex);
        }
        finally {

        }
        return ret;
    }

    @Override
    public ListOperations<Serializable, Serializable> getOptionsForList() {
        return this.redisTemplate.opsForList();
    }

    @Override
    public SetOperations<Serializable, Serializable> getOptionsForSet() {
        return this.redisTemplate.opsForSet();
    }

    @Override
    public ZSetOperations<Serializable, Serializable> getOptionsForZSet() {
        return this.redisTemplate.opsForZSet();
    }

    @Override
    public HashOperations<Serializable, Serializable, Serializable> getOptionsForHash() {
        return this.redisTemplate.opsForHash();
    }

    @Override
    public Serializable leftPop(Serializable key) {
        return this.getOptionsForList().leftPop(key);
    }

    @Override
    public Serializable rightPop(Serializable key) {
        return this.getOptionsForList().rightPop(key);
    }
}

6 编写基于SpringBoot的RedisAPI测试用例

package com.hengpeng.itfints.core.redis;

import com.hengpeng.itfints.PCApplication;
import com.hengpeng.itfints.vo.MemberSession;
import javassist.compiler.ast.Member;
import org.apache.log4j.LogManager;
import org.apache.log4j.Logger;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.boot.autoconfigure.web.WebMvcAutoConfiguration;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.test.context.junit4.SpringRunner;

import java.io.Serializable;
import java.util.Set;

/**
 * Redis Template Test Case
 *
 * @author guanglei liuguanglei@ekeyfund.com
 * @create 2017-09-07-15:25
 * @see
 * @since JDK1.8u141
 */
@RunWith(SpringRunner.class)
@SpringBootTest(classes = PCApplication.class)
@EnableAutoConfiguration(exclude = {DataSourceAutoConfiguration.class, WebMvcAutoConfiguration.class})
public class RedisTemplateTestCase {

    private static final Logger logger = LogManager.getLogger(RedisTemplateTestCase.class);

    @Autowired
    private RedisService redisService;



    @Test
    public void testRedisTemplateHashOperator(){

        HashOperations<Serializable, Serializable, Serializable> hashOperations= redisService.getOptionsForHash();
        Set<Serializable> keySet = hashOperations.keys( "spring:session:itfints:sessions:5bab029d-4cc4-4866-950c-b5d56505ee65");
        logger.info("RedisTemplateTestCase testRedisTemplateHashOperator ===》 "+keySet);
        MemberSession memberSession =(MemberSession)hashOperations.get("spring:session:itfints:sessions:5bab029d-4cc4-4866-950c-b5d56505ee65","sessionAttr:CLIENT_SESSION_MEMBER");
        logger.info("value="+memberSession);
    }
}

7 启用Spring Session
只需要在配置类中添加@EnableRedisHttpSession注解即可

package com.hengpeng.itfints.configuration;

import org.springframework.session.data.redis.config.annotation.web.http.EnableRedisHttpSession;

/**
 * Http Session Configuration
 *
 * @author guanglei liuguanglei@ekeyfund.com
 * @create 2017-09-05-16:36
 * @see
 * @since JDK1.8u141
 */
@EnableRedisHttpSession(maxInactiveIntervalInSeconds = 1800,redisNamespace = "itfints")
public class HttpSessionConfiguration {

}

8 编写 SpringSession测试用例

该测试用例用来演示当采用SpringSession后,调用request.getSession().setAttribute(key,value)的session值都会存放到Redis中,
通过HttpSessionManager可以获取Redis中Session的Key，再调用RedisService中封装的API即可获取对应的Session值

package com.hengpeng.itfints.spring.session;

import com.hengpeng.itfints.core.redis.RedisTemplateTestCase;
import org.apache.log4j.LogManager;
import org.apache.log4j.Logger;
import org.springframework.session.web.http.HttpSessionManager;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.util.Map;

/**
 * SessionController
 *
 * @author guanglei liuguanglei@ekeyfund.com
 * @create 2017-09-06-17:37
 * @see
 * @since JDK1.8u141
 */

@RestController
public class SessionController {



    private static final Logger logger = LogManager.getLogger(RedisTemplateTestCase.class);


    @GetMapping("/session")
    public String index(Model model, HttpServletRequest request,String action,String msg){

        HttpSession session=request.getSession();

        if("set".equalsIgnoreCase(action)){

            session.setAttribute("msg",msg);
            return "success";
        }

        if("get".equalsIgnoreCase(action)){
            String value =(String)session.getAttribute("msg");
            model.addAttribute("msgForRedis",value);
            return value;

        }

        return "unknow operator";
    }


    @GetMapping("/get")
    public String get(HttpServletRequest request, HttpServletResponse httpServletResponse){

        //在请求中,根据名为org.springframework.session.web.http.HttpSessionManager获取Spring Session session管理器的引用
        HttpSessionManager sessionManager= (HttpSessionManager) request.getAttribute("org.springframework.session.web.http.HttpSessionManager");
        /**
         *         使用session管理器找出所请求session的别名
         *         默认情况下 session别名会包含在url中,并且请求参数的名称为"_s"
         *         例如http://127.0.0.1:8080/get?_s=0
         *         将会使如下的代码打出 requestSessionAlias====>0
         */
        String requestSessionAlias=sessionManager.getCurrentSessionAlias(request);

        logger.info("requestSessionAlias====>"+requestSessionAlias);

        /**
         * 返回唯一的session别名id,这个别名并没有被浏览器用来发送请求
         * 这个方法并不会创建新的session
         * 我们需要调用reuqest.getSession()来创建新的session
         *
         */
        String newSessionAlias=sessionManager.getNewSessionAlias(request);
        logger.info("newSessionAlias====>"+newSessionAlias);

        /**
         * 使用新创建的session别名来建立URL,这个URL将包含"_s"参数
         * 如果newSessionAlias的值为1的话,那么如下方法返回 /inbox?_s=1
         */
        String encodeURL=sessionManager.encodeURL("/inbox",newSessionAlias);
        logger.info("encodeURL====>"+encodeURL);

        /**
         * 返回session别名和session id所组成的map
         * 它们是由浏览器发送请求所形成的
         */
        Map<String,String> sessionIds=sessionManager.getSessionIds(request);
        logger.info("sessionIds====>" +sessionIds);


        return "success";
    }
}

9 项目Spring Session改造

SessionConstants主要包含了PC端Session前缀的Key和存储MemberSession的属性 CLIENT_SESSION_MEMBER，用来获取MemberSession对象的数据

package com.hengpeng.common.constant;

/**
 * Session Constants
 *
 * @author guanglei liuguanglei@ekeyfund.com
 * @create 2017-09-07-18:27
 * @see
 * @since JDK1.8u141
 */
public class SessionConstants {

    public static final String PC_SESSION_KEY_PREFIX="spring:session:itfints:sessions:";

    public static final String SESSION_ATTRIBUTE="sessionAttr:CLIENT_SESSION_MEMBER";
}

/**
 * <pre>
 * 获取登陆用户session信息
 * </pre>
 * 
 * @param request
 * @return
 */
public static  MemberSession getSessionMember(HttpServletRequest request) {

    MemberSession memberSession=new MemberSession();

    //在请求中,根据名为org.springframework.session.web.http.HttpSessionManager获取Spring Session session管理器的引用
    HttpSessionManager sessionManager= (HttpSessionManager) request.getAttribute("org.springframework.session.web.http.HttpSessionManager");

    //返回session别名和session id所组成的map，它们是由浏览器发送请求所形成的
    Map<String,String> sessionIdMap =sessionManager.getSessionIds(request);

    LOGGER.info("getSessionMember=====================>sessionIdMap=================>"+sessionIdMap);
    String sessionKeySuffix=sessionIdMap.get("0");
    String sessionKey= SessionConstants.PC_SESSION_KEY_PREFIX+sessionKeySuffix;
    RedisService redisService = RedisUtil.getRedisService();
    HashOperations<Serializable, Serializable, Serializable>  hashOperations= redisService.getOptionsForHash();
    memberSession=(MemberSession) hashOperations.get(sessionKey,SessionConstants.SESSION_ATTRIBUTE);
    return memberSession;

    //return (MemberSession) request.getSession().getAttribute(TSConstants.CLIENT_SESSION_MEMBER);

}