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服务
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);
}