脚手架工程代码精简@20210225：Spring Session相关代码下沉至ipu-restful

ipu-rest-scaffold/src/main/java/com/ai/ipu/server/RestScaffoldStart.java

@@ -2,11 +2,9 @@ package com.ai.ipu.server;
import com.ai.ipu.basic.util.IpuBaseException;
import com.ai.ipu.basic.util.IpuUtility;
import com.ai.ipu.restful.InterceptorManager;
import com.ai.ipu.restful.boot.IpuRestApplication;
import com.ai.ipu.restful.interceptor.SessionInterceptor;
import com.ai.ipu.server.framework.DefineSessionInterceptor;
import com.ai.ipu.server.handler.AuthHandler;
import com.ai.ipu.server.handler.HandlerManager;
/**
@@ -51,7 +49,7 @@ public class RestScaffoldStart {
    
    private static void registerInterceptor(){
        // 注册Session校验拦截器
        InterceptorManager.registerHandlerInterceptor("/**", new DefineSessionInterceptor());
        InterceptorManager.registerHandlerInterceptor("/**", new SessionInterceptor());
        // 排除Session校验拦截器的拦截请求
        String[] excludePaths = new String[]{"/login"};
        InterceptorManager.registerExcludePath("/**", excludePaths);

ipu-rest-scaffold/src/main/java/com/ai/ipu/server/config/RedisSessionInterceptor.java

@@ -1,57 +0,0 @@
package com.ai.ipu.server.config;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import com.ai.ipu.basic.util.IpuException;
import com.ai.ipu.server.util.RedisUtil;
/**
 * 登录状态拦截器RedisSessionInterceptor
 */
public class RedisSessionInterceptor implements HandlerInterceptor {
	private static final Logger log = LoggerFactory.getLogger(RedisSessionInterceptor.class);
    @Autowired
    private RedisUtil redisUtil;
	public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {
		// 无论访问的地址是不是正确的，都进行登录验证，登录成功后的访问再进行分发，404的访问自然会进入到错误控制器中
		/*if (redisUtil.getSessionId(request) != null) {
			try {
				// 验证当前请求的session是否是已登录的session
				String loginSessionId = (String) redisUtil.getRedisSessionId(request);
				System.out.println("用户已登录，sessionId为： " + loginSessionId);
				if (redisUtil.isValidSession(request)) {
					return true;
				}
			} catch (Exception e) {
				log.error(e.getMessage(), e);
			}
		}
		throw new IpuException(HttpStatus.UNAUTHORIZED+"-用户未登录！");*/
	    return true;
	}
	
	public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
			ModelAndView modelAndView) throws Exception {
        
	}
	@Override
	public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
			throws Exception {
	}
	
}

ipu-rest-scaffold/src/main/java/com/ai/ipu/server/config/WebSecurityConfig.java

@@ -1,26 +0,0 @@
package com.ai.ipu.server.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
/**
 * Session配置拦截器
 */
@Configuration
public class WebSecurityConfig extends WebMvcConfigurerAdapter {
    @Bean
	public RedisSessionInterceptor getSessionInterceptor() {
		return new RedisSessionInterceptor();
	}
    
	public void addInterceptors(InterceptorRegistry registry) {
		// 所有访问都要进入RedisSessionInterceptor拦截器进行登录验证，并排除login接口(全路径)。必须写成链式，分别设置的话会创建多个拦截器。
		// 必须写成getSessionInterceptor()，否则SessionInterceptor中的@Autowired会无效
		registry.addInterceptor(getSessionInterceptor()).addPathPatterns("/**").excludePathPatterns("/login");
		super.addInterceptors(registry);
	}
}

ipu-rest-scaffold/src/main/java/com/ai/ipu/server/framework/DefineSessionInterceptor.java

@@ -1,45 +0,0 @@
package com.ai.ipu.server.framework;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import org.springframework.http.HttpStatus;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import com.ai.ipu.basic.util.IpuUtility;
//@Slf4j
public class DefineSessionInterceptor implements HandlerInterceptor{
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws Exception {
        String ipuSessionId = SpringSessionManager.getIpuSessionId();
        if(ipuSessionId==null){
            // 404会进入错误控制器
            IpuUtility.error(HttpStatus.UNAUTHORIZED+"-用户未登录！");
        }
        
        HttpSession session = request.getSession();
        String _ipuSessionId = (String) session.getAttribute(SpringSessionManager.IPU_SESSION_ID);
        if(!ipuSessionId.equals(_ipuSessionId)){
            IpuUtility.error(HttpStatus.UNAUTHORIZED+"-用户登录失效！");
        }
        return true;
    }
    @Override
    public void postHandle(HttpServletRequest userRequest, HttpServletResponse userResponse, Object userHandler,
            ModelAndView userModelAndView) throws Exception {
        
    }
    @Override
    public void afterCompletion(HttpServletRequest userRequest, HttpServletResponse userResponse, Object userHandler,
            Exception userEx) throws Exception {
        
    }
}

ipu-rest-scaffold/src/main/java/com/ai/ipu/server/framework/ISessionManager.java

@@ -1,22 +0,0 @@
package com.ai.ipu.server.framework;
import java.util.Map;
import com.ai.ipu.server.framework.context.IContext;
/**
 * @author huangbo@asiainfo.com
 * @team IPU
 * @date 2021年2月23日下午3:40:32
 * @desc Session管理
 */
public interface ISessionManager {
    public String create(IContext context) throws Exception;
    public void verify(String sessionId, Map<String, Object> param) throws Exception;
    
    public String update(String sessionId, IContext context) throws Exception;
    public String destory(String sessionId) throws Exception;
}

ipu-rest-scaffold/src/main/java/com/ai/ipu/server/framework/SessionManager.java

@@ -1,117 +0,0 @@
package com.ai.ipu.server.framework;
import java.util.Map;
import javax.servlet.http.HttpSession;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.ai.ipu.restful.web.ServletManager;
import com.ai.ipu.server.framework.context.IContext;
import com.ai.ipu.server.framework.session.DefaultSession;
import com.ai.ipu.server.framework.session.ISession;
import com.ai.ipu.server.util.SpringUtil;
/**
 * @author huangbo@asiainfo.com
 * @team IPU
 * @date 2021年2月23日上午11:03:13
 * @desc Session管理
 */
public class SessionManager implements ISessionManager{
    private static final Logger log = LoggerFactory.getLogger(SessionManager.class);
    private static int sessionTimeout = 3000;
    private static String IPU_SESSION_ID = "IpuSessionId";
    
    private SpringRedisCache springRedisCache;
    
    private volatile static ISessionManager instance;
    
    private SessionManager() {
        springRedisCache = SpringUtil.getBean(SpringRedisCache.class);
    }
    
    public static ISessionManager getInstance() throws Exception {
        if (instance == null) {
            synchronized (SessionManager.class) {
                if (instance == null) {
                    instance = new SessionManager();
                }
            }
        }
        return instance;
    }
    @Override
    public String create(IContext context) throws Exception {
        String sessionId = createSessionId();
        ISession session = createSession(context);
        springRedisCache.put(sessionId, session, sessionTimeout);
        
        HttpSession httpSession = ServletManager.getSession();
        httpSession.setAttribute(IPU_SESSION_ID, sessionId);
        return sessionId;
    }
    @Override
    public void verify(String sessionId, Map<String, Object> param) throws Exception {
        
    }
    @Override
    public String update(String sessionId, IContext context) throws Exception {
        Object element = springRedisCache.get(sessionId);
        context.setDirty(false);
        if (element == null) {
            if(log.isDebugEnabled()){
                log.debug("No Cached Element[{}]!", sessionId);
            }
            springRedisCache.put(sessionId, createSession(context));
        }else{
            ISession session = (DefaultSession)element;
            session.setContext(context, System.currentTimeMillis()); //分布式环境下，时间戳统一获取
            springRedisCache.put(sessionId, session);
        }
        return sessionId;
    }
    @Override
    public String destory(String sessionId) throws Exception {
        Object session = springRedisCache.get(sessionId);
        if (session == null) {
            if(log.isDebugEnabled()){
                log.debug("No Cached Element[{}]!", sessionId);
            }
            return null;
        }
        springRedisCache.remove(sessionId);
        return sessionId;
    }
    private String createSessionId(){
        return getRandomNumber(4)+String.valueOf(System.currentTimeMillis());
    }
    
    private ISession createSession(IContext context){
        return new DefaultSession(context, System.currentTimeMillis());
    }
    
    private static final String[] NUM = {"0","1","2","3","4","5","6","7","8","9"};
    private static final int NUMBER_TEN = 10;
    
    /**
     * 获取len长度的随机数
     * @param len 长度
     * @return String 随机数
     */
    public static String getRandomNumber(int len){
        String randomCode = "";
        for(int i = 0; i < len; i++){
            int number = (int) (Math.random() * NUMBER_TEN);
            randomCode += NUM[number];
        }
        return randomCode;
    }
    
}

ipu-rest-scaffold/src/main/java/com/ai/ipu/server/framework/SpringRedisCache.java

@@ -1,74 +0,0 @@
package com.ai.ipu.server.framework;
import java.util.concurrent.TimeUnit;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import com.ai.ipu.basic.util.IpuUtility;
import com.ai.ipu.cache.ICache;
/**
 * @author huangbo@asiainfo.com
 * @team IPU
 * @date 2021年2月24日下午5:52:32
 * @desc Spring体系下载Redis操作
 * 可以考虑使用StringRedisTemplate代替RedisTemplate
 */
@Component
public class SpringRedisCache implements ICache {
    @Autowired
    private RedisTemplate<Object, Object> redisTemplate;
    
    @Override
    public boolean put(Object key, Object value) throws Exception {
        redisTemplate.opsForValue().set(key, value);
        return true;
    }
    @Override
    public Object get(Object key) throws Exception {
        return redisTemplate.opsForValue().get(key);
    }
    @Override
    public boolean remove(Object key) throws Exception {
        redisTemplate.delete(key);
        return true;
    }
    @Override
    public void clear() throws Exception {
        IpuUtility.error("SpringRedisCache无clear方法的实现");
    }
    @Override
    public boolean keyExists(String cacheKey) {
        return redisTemplate.hasKey(cacheKey);
    }
    @Override
    public boolean put(Object key, Object value, int secondTimeout) throws Exception {
        redisTemplate.opsForValue().set(key, value, secondTimeout, TimeUnit.SECONDS);
        return true;
    }
    @Override
    public void close() throws Exception {
        IpuUtility.error("SpringRedisCache无close方法的实现");
    }
    public RedisTemplate<Object, Object> getRedisTemplate() {
        return redisTemplate;
    }
}
/**
 *  Redis常见的五大数据类型：
 *  stringRedisTemplate.opsForValue();[String(字符串)]
 *  stringRedisTemplate.opsForList();[List(列表)]
 *  stringRedisTemplate.opsForSet();[Set(集合)]
 *  stringRedisTemplate.opsForHash();[Hash(散列)]
 *  stringRedisTemplate.opsForZSet();[ZSet(有序集合)]
 */

ipu-rest-scaffold/src/main/java/com/ai/ipu/server/framework/SpringSessionManager.java

@@ -1,80 +0,0 @@
package com.ai.ipu.server.framework;
import javax.servlet.http.HttpSession;
import org.springframework.data.redis.core.RedisTemplate;
import com.ai.ipu.restful.web.ServletManager;
import com.ai.ipu.server.util.SpringUtil;
public class SpringSessionManager {
    private static final String IPU_ROOT_DIR = "ipu";
    public static final String IPU_SESSION_ID = "IpuSessionId";
    private static final String IPU_ACCOUNT = "IpuAccount";
    private static final String IPU_CONTEXT = "IpuContext";
    private static final SpringRedisCache springRedisCache;
    static {
        springRedisCache = SpringUtil.getBean(SpringRedisCache.class);
    }
    
    public static String createIpuSession(String account, Object context) throws Exception{
        // 清除ipuSessionId
        clearIpuSession(account);
        // 创建ipuSessionId
        String ipuSessionId = SessionManager.getRandomNumber(4) + String.valueOf(System.currentTimeMillis());
        // Spring Session中存储对应信息
        HttpSession httpSession = ServletManager.getSession();
        httpSession.setAttribute(IPU_SESSION_ID, ipuSessionId);
        httpSession.setAttribute(IPU_ACCOUNT, account);
        httpSession.setAttribute(IPU_CONTEXT, context);
        
        springRedisCachePut(account, ipuSessionId);
        springRedisCachePut(ipuSessionId, httpSession.getId()); //将sessionId存储为后续清除动作提供key
        
        return ipuSessionId;
    }
    
    public static void clearIpuSession(String account) throws Exception {
        // 清除Spring Redis Session中的冗余数据，重启客户端时
        String ipuSessionId = (String) springRedisCacheGet(account);
        if(ipuSessionId==null||"".equals(ipuSessionId)){
            return;
        }
        String sessionId = (String) springRedisCacheGet(ipuSessionId);
        /*
         * 补充清除逻辑：根据sessionId来清除Spring Redis Session
         */
        springRedisCacheRemove(ipuSessionId);
        springRedisCacheRemove(account);
    }
    public static String getIpuSessionId() throws Exception {
        HttpSession httpSession = ServletManager.getSession();
        String account = (String) httpSession.getAttribute(IPU_ACCOUNT);
        if(account==null){
            return null;
        }
        return (String) springRedisCacheGet(account);
    }
    
    public static String getSessionAttr(String attrKey) {
        HttpSession httpSession = ServletManager.getSession();
        String sessionKey ="spring:session:sessions:" + httpSession.getId();
        
        RedisTemplate<Object, Object> redisTemplate = springRedisCache.getRedisTemplate();
        String ipuSessionId = (String) redisTemplate.opsForHash().get(sessionKey, "sessionAttr:" + attrKey);
        return ipuSessionId;
    }
    
    private static void springRedisCachePut(String key, Object value){
        springRedisCache.getRedisTemplate().opsForHash().put(IPU_ROOT_DIR, key, value);
    }
    
    private static Object springRedisCacheGet(String key){
        return springRedisCache.getRedisTemplate().opsForHash().get(IPU_ROOT_DIR, key);
    }
    
    private static void springRedisCacheRemove(String key){
        springRedisCache.getRedisTemplate().opsForHash().delete(IPU_ROOT_DIR, key);
    }
}

ipu-rest-scaffold/src/main/java/com/ai/ipu/server/framework/context/DefaultContext.java

@@ -1,51 +0,0 @@
package com.ai.ipu.server.framework.context;
import java.util.HashMap;
import java.util.Map;
/**
 * @author huangbo@asiainfo.com
 * @team IPU
 * @date 2021年2月23日上午11:31:40
 * @desc 上下文默认实现类
 */
public class DefaultContext implements IContext {
    
    private boolean isDirty; //上下文变脏可能需要回存
    
    private Map<String, Object> data;
    
    public DefaultContext(Map<String, Object> data) {
        this.data = data;
        if(this.data==null){
            this.data = new HashMap<String, Object>();
        }
    }
    @Override
    public void put(String key, Object value) {
        data.put(key, value);
        setDirty(true);
    }
    @Override
    public Object get(String key) {
        return data.get(key);
    }
    @Override
    public boolean isDirty() {
        return isDirty;
    }
    @Override
    public void setDirty(boolean isDirty) {
        this.isDirty = isDirty;
    }
    @Override
    public Map<String, Object> getData() {
        return data;
    }
}

ipu-rest-scaffold/src/main/java/com/ai/ipu/server/framework/context/IContext.java

@@ -1,24 +0,0 @@
package com.ai.ipu.server.framework.context;
import java.util.Map;
/**
 * @author huangbo@asiainfo.com
 * @team IPU
 * @date 2021年2月23日上午11:15:09
 * @desc 上下文抽象接口，定义上下文的行文
 * 放弃对DTO的存储和映射
 */
public interface IContext {
    public void put(String key, Object value);
    
    public Object get(String key);
    
    public boolean isDirty();
    
    public void setDirty(boolean isDirty);
    
    public Map<String,Object> getData();
    
}

ipu-rest-scaffold/src/main/java/com/ai/ipu/server/framework/session/DefaultSession.java

@@ -1,64 +0,0 @@
package com.ai.ipu.server.framework.session;
import com.ai.ipu.server.framework.context.DefaultContext;
import com.ai.ipu.server.framework.context.IContext;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.SerializerFeature;
public class DefaultSession implements ISession {
    private static final long serialVersionUID = 2077082727127850649L;
    private String contextData;
    
    private long latestTime;
    private long creatTime;
    private long timeoutInterval;
    
    public DefaultSession(IContext context, long latestTime) {
        contextData = JSON.toJSONString(context, SerializerFeature.IgnoreNonFieldGetter);
        this.latestTime = latestTime;
    }
    @Override
    public IContext getContext() {
        IContext context = JSON.toJavaObject(JSON.parseObject(contextData), DefaultContext.class);
        return context;
    }
    
    @Override
    public void setContext(IContext context, long latestTime) {
        contextData = JSON.toJSONString(context, SerializerFeature.IgnoreNonFieldGetter);
        this.latestTime = latestTime;
    }
    @Override
    public long getLatestTime() {
        return latestTime;
    }
    @Override
    public void setLatestTime(long latestTime) {
        this.latestTime = latestTime;
    }
    @Override
    public long getCreatTime() {
        return creatTime;
    }
    @Override
    public void setCreatTime(long creatTime) {
        this.creatTime = creatTime;
    }
    @Override
    public long getTimeoutInterval() {
        return timeoutInterval;
    }
    @Override
    public void setTimeoutInterval(long timeoutInterval) {
        this.timeoutInterval = timeoutInterval;
    }
}

ipu-rest-scaffold/src/main/java/com/ai/ipu/server/framework/session/ISession.java

@@ -1,40 +0,0 @@
package com.ai.ipu.server.framework.session;
import java.io.Serializable;
import com.ai.ipu.server.framework.context.IContext;
/**
 * @author huangbo@asiainfo.com
 * @team IPU
 * @date 2021年2月24日下午6:12:24
 * @desc Session对象为一级缓存，Context为二级缓存并存储在Session中。
 * 参考Spring Session，引入lastAccessedTime、creationTime、maxInactiveInterval属性
 */
public interface ISession extends Serializable{
    /**获取上下文数据*/
    public IContext getContext();
    
    /**设置上下文数据*/
    public void setContext(IContext context, long latestTime);
    
    /**获取最新访问时间*/
    public long getLatestTime();
    
    /**设置最新访问时间*/
    public void setLatestTime(long latestTime);
    
    /**获取创建时间*/
    public long getCreatTime();
    
    /**设置创建时间*/
    public void setCreatTime(long creatTime);
    
    /**获取超时间隔*/
    public long getTimeoutInterval();
    
    /**设置超时间隔*/
    public void setTimeoutInterval(long timeoutInterval);
    
}

ipu-rest-scaffold/src/main/java/com/ai/ipu/server/service/impl/AuthServiceImpl.java

@@ -5,7 +5,7 @@ import java.util.Map;
import org.springframework.stereotype.Service;
import com.ai.ipu.server.framework.SpringSessionManager;
import com.ai.ipu.restful.framework.SpringSessionManager;
import com.ai.ipu.server.handler.AuthHandler;
import com.ai.ipu.server.handler.HandlerManager;
import com.ai.ipu.server.service.AuthService;

ipu-rest-scaffold/src/main/java/com/ai/ipu/server/util/RedisOperUtil.java

@@ -1,111 +0,0 @@
package com.ai.ipu.server.util;
import java.util.concurrent.TimeUnit;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
import com.ai.ipu.basic.string.StringUtil;
import com.ai.ipu.basic.util.IpuUtility;
import com.ai.ipu.cache.ICache;
@Component
public class RedisOperUtil implements ICache{
    @Autowired
    private StringRedisTemplate strRedisTemplate;
    @Autowired
    private RedisTemplate redisTemplate;
   /**
     *  Redis常见的五大数据类型：
     *  stringRedisTemplate.opsForValue();[String(字符串)]
     *  stringRedisTemplate.opsForList();[List(列表)]
     *  stringRedisTemplate.opsForSet();[Set(集合)]
     *  stringRedisTemplate.opsForHash();[Hash(散列)]
     *  stringRedisTemplate.opsForZSet();[ZSet(有序集合)]
     */
       
    
    /**
     * 存
     */
    public boolean put(Object key, Object value) throws Exception {
        boolean result = true;
        try{
            if (key instanceof String)
            	strRedisTemplate.opsForValue().set(key.toString(), String.valueOf(value));
            else
            	IpuUtility.error("key只支持String，保存数据到缓存操作失败"); 
        }catch (NullPointerException e)
		{
			if (StringUtil.isEmpty((String)key))
				IpuUtility.error("由于key值为空，导致保存数据到缓存操作失败", e);
			IpuUtility.error("由于value值为空，导致保存数据到缓存操作失败", e);
			result = false;
		}
        return result;
    }
    /**
     * 取
     */
    public Object get(Object key) throws Exception {
        return strRedisTemplate.opsForValue().get(key);
    }
    /**
     * 移除
     */
    public boolean remove(Object key) throws Exception {
    	redisTemplate.delete(key);
    	return true;
    }
    /**
     * 清除
     */
    public void clear() throws Exception {
    	;
    }
    /**
     * key是否存在
     */
    public boolean keyExists(String key) {
        return strRedisTemplate.hasKey(key);
    }
    /**
     * 设置数据
     * @param key
     * @param value
     * @param timeoutSeconds
     * @return
     * @throws Exception
     */
    public boolean put(Object key, Object value, int timeoutSeconds) throws Exception {
        boolean result = true;
        try {
            if (key instanceof String)
            	strRedisTemplate.opsForValue().set(key.toString(), String.valueOf(value), timeoutSeconds, TimeUnit.SECONDS);
            else
            	IpuUtility.error("key只支持String，保存数据到缓存操作失败"); 
        }catch (NullPointerException e)
		{
			if (StringUtil.isEmpty((String)key))
				IpuUtility.error("由于key值为空，导致保存数据到缓存操作失败", e);
			IpuUtility.error("由于value值为空，导致保存数据到缓存操作失败", e);
			result = false;
		}
        return result;
    }
    public void close() throws Exception {
    	;
    }
}

ipu-rest-scaffold/src/main/java/com/ai/ipu/server/util/RedisUtil.java

@@ -1,129 +0,0 @@
package com.ai.ipu.server.util;
import java.util.List;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import org.jsoup.helper.StringUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import com.ai.ipu.basic.util.IpuException;
import com.ai.ipu.cache.CacheFactory;
import com.ai.ipu.cache.config.IpuCacheConfig;
import com.ai.ipu.cache.util.IpuCacheConstant;
@Component
public class RedisUtil{    
    private static final String DEFAULT_CACHE_NAME = "ssn";
    @Autowired
    private RedisOperUtil redis;
    
	public static String[] initRedis(String[] args) throws Exception {
		//将ipu-cache配置作为springboot配置
		String[] argv = new String[args.length+9];
        String cacheName = DEFAULT_CACHE_NAME;
		int i=0;		
		for (String arg : args) {
			if (arg.contains("--redis.cache.name")&&arg.contains("=")) {
				cacheName = arg.substring(arg.indexOf("=")+1);
				argv[i++] = " ";
			}
			else
				argv[i++] = arg;
		}
		String cacheType = IpuCacheConfig.getCacheType(cacheName);
		if (!CacheFactory.DEFAULT_CACHE_TYPE.endsWith(cacheType))
			throw new IpuException("只支持redis保存spring session信息！请检查ipu-cache.xml里的type");
		
		String jedisType = IpuCacheConfig.getCacheDefaultAttr(cacheName,
                IpuCacheConstant.Redis.CLIENT_TYPE, IpuCacheConstant.ClientType.JEDIS_CLIENT);
		
		argv[i++] = "--spring.session.store-type="+CacheFactory.DEFAULT_CACHE_TYPE;
		List<Map<String,String>> clusterList = IpuCacheConfig.getCacheServers(cacheName);
        if (null == clusterList || clusterList.isEmpty())
            throw new IllegalArgumentException("请确认ipu-cache.xml里server是否配置正确");
        
		if (IpuCacheConstant.ClientType.JEDIS_CLIENT.equalsIgnoreCase(jedisType))
        {
        	//只取第一个redis地址
            Map<String, String> server = clusterList.get(0);
        	argv[i++] = "--spring.redis.database=0";
        	argv[i++] = "--spring.redis.host=" + server.get(IpuCacheConstant.Redis.IP);
        	argv[i++] = "--spring.redis.port=" + server.get(IpuCacheConstant.Redis.PORT);
        }
        else
        {
        	//拼集群节点
        	StringBuffer nodes = new StringBuffer();
        	Map<String, String> server;
        	int j=0;
            for (; j < clusterList.size(); j++) {
                server = clusterList.get(j);
                if (j == clusterList.size()-1)
                    nodes.append(server.get(IpuCacheConstant.Redis.IP)).append(":").append(server.get(IpuCacheConstant.Redis.PORT));
                else
                	nodes.append(server.get(IpuCacheConstant.Redis.IP)).append(":").append(server.get(IpuCacheConstant.Redis.PORT)).append(",");
            }
    		argv[i++] = "--spring.redis.cluster.nodes=" + nodes.toString();
    		argv[i++] = "--spring.redis.cluster.timeout=5";
    		argv[i++] = "--spring.redis.cluster.max-redirects=3";
        }
		//设置访问密码
		String auth = IpuCacheConfig.getCacheAttr(cacheName, IpuCacheConstant.Redis.AUTH);
        if (StringUtil.isBlank(auth))
        	argv[i++] = "--spring.redis.password= ";
        else
        	argv[i++] = "--spring.redis.password=" + auth;
        
        //设置连接池参数
        int poolSize = IpuCacheConstant.RedisConstant.DEFAULT_POOL_SIZE;
        int maxIdle  = IpuCacheConstant.RedisConstant.DEFAULT_MAX_IDLE;
        int minIdle  = IpuCacheConstant.RedisConstant.DEFAULT_MIN_IDLE;
        
        String strPoolSize = IpuCacheConfig.getCacheAttr(cacheName, IpuCacheConstant.Redis.POOL_SIZE);
        String strMaxIdle = IpuCacheConfig.getCacheAttr(cacheName, IpuCacheConstant.Redis.MAX_IDLE);
        String strMinIdle = IpuCacheConfig.getCacheAttr(cacheName, IpuCacheConstant.Redis.MIN_IDLE);        
        if(!StringUtil.isBlank(strPoolSize)){
            poolSize = Integer.parseInt(strPoolSize);
        }
        if (!StringUtil.isBlank(strMaxIdle)){
            maxIdle = Integer.parseInt(strMaxIdle);
        }
        if (!StringUtil.isBlank(strMinIdle)){
            minIdle = Integer.parseInt(strMinIdle);
        }
		argv[i++] = "--spring.redis.pool.max-active=" + poolSize;
		argv[i++] = "--spring.redis.pool.max-idle=" + maxIdle;
		argv[i++] = "--spring.redis.pool.max-wait=-1";
		argv[i++] = "--spring.redis.pool.min-idle=" + minIdle;
        return argv;        
	}
	
	public Object getSessionId(HttpServletRequest request) {
		HttpSession session = request.getSession();
		return session.getAttribute("loginSessionId");
	}	
	
	public void saveSessionId(HttpServletRequest request, Object sessionId) throws Exception {
		HttpSession session = request.getSession();
		session.setAttribute("loginSessionId", sessionId);
		redis.put("loginUser:"+sessionId, session.getId());
	}	
	
	public Object getRedisSessionId(HttpServletRequest request) throws Exception {
		String sessionId = (String)getSessionId(request);
		return redis.get("loginUser:"+sessionId);
	}	
	
	public boolean isValidSession(HttpServletRequest request) throws Exception {
		HttpSession session = request.getSession();
		String sessionId = (String)getSessionId(request);
		String redisSessionId = (String)redis.get("loginUser:"+sessionId);
		return session.getId().equals(redisSessionId)?true:false;
	}
}