D丶Manson
D丶Manson

spring+springmvc+Interceptor+jwt+redis实现sso单点登录

一、前言

1.在大型互联网公司下，一个公司有多个平台系统项目，而且有可能每个项目开发语言都不同，同时每个平台也会分别有APP、PC（前后端分离）、小程序端等，而且服务部署在分布式环境下，要实现支持PC、APP（ios、android）、小程序等多端的会话共享，本文章采取的方案是spring+springmvc+Interceptor+jwt+redis实现sso单点登录。假如用传统方式session、cookie实现不太好，第一如果用session实现，会面临集群环境下session共享问题（可以用springsession来解决），但是session存过多数据会给服务器带来压力。第二如果用cookie实现，会面临域名跨域问题，而且不适合用在native app里面：native app不好管理cookie，毕竟它不是浏览器。
2.通俗来讲，JWT是一个含签名并携带用户相关信息的加密串，页面请求校验登录接口时，请求头中携带JWT串到后端服务，后端通过签名加密串匹配校验，保证信息未被篡改。校验通过则认为是可靠的请求，将正常返回数据，同时JSON解析成对象。
优点：在非跨域环境下使用JWT机制是一个非常不错的选择，实现方式简单，操作方便，能够快速实现。由于服务端不存储用户状态信息，因此大用户量，对后台服务也不会造成压力；
缺点：跨域实现相对比较麻烦，安全性也有待探讨。因为JWT令牌返回到页面中，可以使用js获取到，如果遇到XSS攻击令牌可能会被盗取，在JWT还没超时的情况下，就会被获取到敏感数据信息（敏感信息最好别放置JWT中）。
但是我们可以针对令牌盗取，做一些防范：比如前后端传输参数RSA验签防止篡改，采取https加密参数传输。没有一个互联网平台做到绝对安全的，只能说提高安全性，把风险降到最低。

二、实现代码

2.1.引入jwt的相关jar包，在项目pom.xml中引入：

		
		    com.auth0
		    java-jwt
		    2.2.0

2.2 JWT工具类

public class JWT {
	private static final String SECRET = "填写你的秘钥";

    private static final String EXP = "exp";

    private static final String PAYLOAD = "payload";

    //加密，传入一个对象和有效期
    public static  String sign(T object, long maxAge) {
        try {
            final JWTSigner signer = new JWTSigner(SECRET);
            final Map claims = new HashMap();
            ObjectMapper mapper = new ObjectMapper();
            String jsonString = mapper.writeValueAsString(object);
            claims.put(PAYLOAD, jsonString);
            claims.put(EXP, System.currentTimeMillis() + maxAge);
            return signer.sign(claims);
        } catch(Exception e) {
            return null;
        }
    }

    //解密，传入一个加密后的token字符串和解密后的类型
    public static T unsign(String jwt, Class classT) {
        final JWTVerifier verifier = new JWTVerifier(SECRET);
        try {
            final Map claims= verifier.verify(jwt);
            if (claims.containsKey(EXP) && claims.containsKey(PAYLOAD)) {
                //long exp = (Long)claims.get(EXP);
                //long currentTimeMillis = System.currentTimeMillis();
                //if (exp > currentTimeMillis) {
                    String json = (String)claims.get(PAYLOAD);
                    ObjectMapper objectMapper = new ObjectMapper();
                    return objectMapper.readValue(json, classT);
                //}
            }
            return null;
        } catch (Exception e) {
            return null;
        }
    }
    
    public static void main(String[] args) {
        System.out.println(System.currentTimeMillis());
    	//加密
    	String ss = sign("123444444444444444444444444444444444444444444444444444444444444444444;4a", 0);
		System.out.println(ss);
		//解密
		System.out.println(unsign("eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJleHAiOjE1NTg5NDY4NDUzODksInBheWxvYWQiOiJcIjExMTFcIiJ9.jJwpdHgpNLjU1vL0DZhxtAsNEBG0ysXrJEvMf_X5OXk", String.class));
	}
}

2.3编写用户登录LoginInterceptor.java拦截器

public class LoginInterceptor implements HandlerInterceptor{
	
	public static final String REDIS_TOKEN_FLAG = "redis_token";
	
	public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {
		//过滤不匹配的请求
		PrintWriter writer = null;
		if(handler instanceof DefaultServletHttpRequestHandler){
			writer = response.getWriter();
			Map resultMap = ResponseCode.buildReturnMap(ResponseCode.REQUEST_URL_NOT_SERVICE, false);
        	responseMessage(response, writer, resultMap);
        	return false;
		}
		
		response.setCharacterEncoding("utf-8");
        String token = request.getHeader("token");
        //拼接redis的key=平台标识+登录方式+(会员表id或用户授权表id)
        //token不存在
        if(StringUtils.isEmpty(token)) {
        	writer = response.getWriter();
        	Map resultMap = LoginResponseCode.buildReturnMap(LoginResponseCode.LOGIN_TOKEN_NOT_NULL, false);
        	responseMessage(response, writer, resultMap);
        	return false;
        }

		//tokenRedisKey是redis存token的key
		String tokenRedisKey = LoginInterceptor.REDIS_TOKEN_FLAG + JWT.unsign(token, String.class);
		if(StringUtils.isEmpty(tokenRedisKey)){
			writer = response.getWriter();
			Map resultMap = LoginResponseCode.buildReturnMap(LoginResponseCode.USERID_NOT_UNAUTHORIZED, false);
			responseMessage(response, writer, resultMap);
			return false;
		}

        //根据token截取用户id
        String redisToken = (String)RedisClusterUtils.get(tokenRedisKey);
        LoginResponseCode loginCode = null;
        if(StringUtils.isEmpty(redisToken)){
        	//未登录
        	loginCode = LoginResponseCode.LOGIN_TIME_EXP;
        }
        else if(!StringUtils.equals(redisToken, token)){
			//用户在同设备（APP、PC、小程序、公众号，比如APP设备不能登录两个一样的账号）上登录，你已经被踢下线
			loginCode= LoginResponseCode.RESPONSE_CODE_LOGIN_ERROR;
        }
        if(loginCode != null){
        	writer = response.getWriter();
        	Map resultMap = LoginResponseCode.buildReturnMap(loginCode, false);
        	responseMessage(response, writer, resultMap);
        	return false;
        }
        //重新设置会话时间,半小时
		RedisClusterUtils.expire(LoginInterceptor.REDIS_TOKEN_FLAG + token, 1800);
        request.setAttribute("tokenRedisKey", tokenRedisKey);
		return true;
	}

	public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
			ModelAndView modelAndView) throws Exception {
	}

	public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
			throws Exception {
		
	}
	
	private void responseMessage(HttpServletResponse response, PrintWriter out, Object responseVO) {
        response.setContentType("application/json; charset=utf-8");  
        out.print(JSONObject.fromObject(responseVO).toString());
        out.flush();
        out.close();
    }

}

2.4 定义LoginResponseCode

public enum LoginResponseCode {
	
	USERID_NOT_NULL(3001,"用户id不能为空."), 
	LOGIN_TOKEN_NOT_NULL(3002,"登录token不能为空."),
	USERID_NOT_UNAUTHORIZED(3003, "用户token无效"),
	RESPONSE_CODE_UNLOGIN_ERROR(421, "未登录异常"),
	RESPONSE_CODE_LOGIN_ERROR(422, "用户在另一台机器上登录，你已经被踢下线"),
	LOGIN_TIME_EXP(3004, "未登录或登录时间超时，请重新登录");
	
    // 成员变量  
	private int code; //状态码  
    private String message; //返回消息

    // 构造方法  
    private LoginResponseCode(int code,String message) {  
        this.code = code;  
        this.message = message;  
    }  
	public int getCode() {
		return code;
	}
	public void setCode(int code) {
		this.code = code;
	}
	public String getMessage() {
		return message;
	}
	public void setMessage(String message) {
		this.message = message;
	}  

	public static ResponseVO buildEnumResponseVO(LoginResponseCode responseCode, Object data) {
		return new ResponseVO(responseCode.getCode(),responseCode.getMessage(),data);
	}
	
	public static Map buildReturnMap(LoginResponseCode responseCode, Object data) {
		Map map = new HashMap();
		map.put("code", responseCode.getCode());
		map.put("message", responseCode.getMessage());
		map.put("data", data);
		return map;
	}
}

2.5 定义ResponseCode 枚举类

public enum ResponseCode {
	RESPONSE_CODE_FAILURE(10000,"请求失败、结果处理失败"),
	RESPONSE_CODE_SUCCESS(200,"请求成功、结果处理成功"),
	RESPONSE_CODE_PARAM_FORMAT_ERROR(10002,"请求失败、参数格式错误"),
	RESPONSE_CODE_PARAM_ERROR(10003,"参数错误"),
	RESPONSE_CODE_REQ_CANNOT_EMPTY(10004,"必要的请求参数不能为空"),
	RESPONSE_CODE_USER_DOES_NOT_EXIST(10005,"用户不存在"),
	RESPONSE_CODE_QUERY_SUCCESS(10006,"数据查询成功"),
	RESPONSE_CODE_QUERY_NO_DATA(10007,"无数据或者结果"),
	USER_LOGIN_PWD_ERROR(10008,"用户名密码错误"),
	REQUEST_URL_NOT_SERVICE(10009,"访问了非服务路径"),
	RESPONSE_CODE_QUERY_REMARKS_50(10010,"退货原因不得超过50字"),
	RESPONSE_CODE_UNLOGIN_ERROR(421,"未登录异常"),
	RESPONSE_CODE_LOGIN_SUCCESS(200,"用户登录成功"),
	RESPONSE_CODE_NO_PERMISSION(403,"无权访问该系统"),
	RESPONSE_CODE_SYSTEM_ERROR(500,"系统内部异常"),
	RESPONSE_CODE_TIME_OUT(504,"上游服务端网关超时"),
	REGISTER_MOBILE_EXIST(2001,"手机号码已经注册"),
	REGISTER_VERIFICA_CODE_INVALID(2002,"验证码错误或者已经失效，请重新获取验证码"),
	VERIFICA_CODE_ERROR(2003,"验证码不正确或失效"),
	REFERRER_NOT_EXIST(2004, "推荐人不存在"),
	PROXY_ACTIVATE_CODE_ERROR(2005, "激活码错误"),
	USER_TRADE_PASSWORD_ERROR(2006,"用户交易密码错误"),
	APP_VERSION_MISMATCHING(2007,"app版本号不是最新版本"),
	USER_IDNO_NOT_MATCHING(2008, "用户身份证号码不匹配"),
	BANK_CARD_MUST_HAVE_TO_ONE(2010, "银行卡必须保留一张"),
	OLD_PASSWORD_ERROR(2011, "原密码不正确"),
	NEW_PASSWORD_INCONSISTENT(2012, "新密码不一致"),
	V_PASSWORD_REG(2013, "密码为数字或字母"),
	TWO_PASSWORD_INCONSISTENCIES(2014, "密码和确认密码不一致"),
	ACCEPT_PROTOCOL(2015, "请阅读和接受协议"),
	LOGOUT_SUCESS(2016, "退出成功"),
	TRANSCODE_FAILED(2017,"转码失败"),
	APPLY_SALE_AFTER_STATUS_ERROR(2018,"申请售后失败，该订单未付款"),
	NO_PAY_VALIDATE(2019,"支付未认证"),
	PAY_VALIDATE_PROCESSING(2020,"支付人工审核中"),
	PAY_VALIDATE_FAIL(2021,"支付人工审核失败，请重新填写"),
	PAY_VALIDATE_SUCESS(2022,"支付人工审核成功"),
	ACCOUNT_EXIST(2023,"账号已存在"),
	ROLE_NAME_EXIST(2024,"角色已存在"),
	PASSWORD_IS_BLENK(2025,"密码不能为空"),
	DECRYPT_FAIL(2026,"参数解密失败"),
	NOT_BINDING_MEMBER(2027,"未绑定会员"),
	GET_ACCESSTOKEN_FAIL(2028,"获取accessToken失败"),
	TWO_PASSWORD_CONSISTENCIES(2029, "新旧密码一致"),
    NOT_PLATFORM_AUTH(2030, "该平台账号未授权或者已停用"),
	AUTH_CODE_NOT_NULL(2031, "平台授权码不能为空");

	private int code; //状态码
	private String message; //返回消息
	private static String version = "v1.0"; //版本号

	// 构造方法
	private ResponseCode(int code,String message) {
		this.code = code;
		this.message = message;
	}
	public int getCode() {
		return code;
	}
	public void setCode(int code) {
		this.code = code;
	}
	public String getMessage() {
		return message;
	}
	public void setMessage(String message) {
		this.message = message;
	}

	public static ResponseVO buildEnumResponseVO(ResponseCode responseCode, Object data) {
		return new ResponseVO(responseCode.getCode(),responseCode.getMessage(),data);
	}

	public static Map buildReturnMap(ResponseCode responseCode, Object data) {
		Map map = new HashMap();
		map.put("code", responseCode.getCode());
		map.put("version", version);
		map.put("message", responseCode.getMessage());
		map.put("data", data);
		return map;
	}


	/**
	 * 自定义状态码返回结果Map
	 * @param code  状态码
	 * @param message 消息提示
	 * @param data 数据
	 * @return
	 */
	public static Map customBuildReturnMap(String code, String message, Object data) {
		if(StringUtils.isEmpty(code)){
			code = "9999"; // 自定义错误消息状态码
		}
		Map map = new HashMap();
		map.put("code", code);
		map.put("version", version);
		map.put("message", message);
		map.put("data", data);
		return map;
	}
}

2.6 RedisClusterUtils（redis集群工具类）

public class RedisClusterUtils {

	@SuppressWarnings("rawtypes")
	private static RedisTemplate redisTemplate;

	public void setRedisTemplate(RedisTemplate redisTemplate) {
		RedisClusterUtils.redisTemplate = redisTemplate;
	}

	static {
		if (null == redisTemplate) {
			RedisClusterUtils.redisTemplate = SpringContextHolder
					.getBean(RedisTemplate.class);
		}
	}

	/**
	 * 普通缓存获取
	 * 
	 * @param key
	 *            键
	 * @return 值
	 */
	public static Object get(String key) {
		return key == null ? null : redisTemplate.opsForValue().get(key);
	}

	/**
	 * 普通缓存放入
	 * 
	 * @param key
	 *            键
	 * @param value
	 *            值
	 * @return true成功 false失败
	 */
	public static boolean set(String key, Object value) {
		try {
			redisTemplate.opsForValue().set(key, value);
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}

	}

	/**
	 * 普通缓存放入并设置时间
	 * 
	 * @param key
	 *            键
	 * @param value
	 *            值
	 * @param time
	 *            时间(秒) time要大于0 如果time小于等于0 将设置无限期
	 * @return true成功 false 失败
	 */
	public static boolean set(String key, Object value, long time) {
		try {
			if (time > 0) {
				redisTemplate.opsForValue().set(key, value, time,
						TimeUnit.SECONDS);
			} else {
				set(key, value);
			}
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 递增
	 * 
	 * @param key
	 *            键
	 * @param by
	 *            要增加几(大于0)
	 * @return
	 */
	public static long incr(String key, long delta) {
		if (delta < 0) {
			throw new RuntimeException("递增因子必须大于0");
		}
		return redisTemplate.opsForValue().increment(key, delta);
	}

	/**
	 * 递减
	 * 
	 * @param key
	 *            键
	 * @param by
	 *            要减少几(小于0)
	 * @return
	 */
	public static long decr(String key, long delta) {
		if (delta < 0) {
			throw new RuntimeException("递减因子必须大于0");
		}
		return redisTemplate.opsForValue().increment(key, -delta);
	}

	/**
	 * HashGet
	 * 
	 * @param key
	 *            键 不能为null
	 * @param item
	 *            项 不能为null
	 * @return 值
	 */
	public static Object hget(String key, String item) {
		return redisTemplate.opsForHash().get(key, item);
	}

	public static Object hget(byte[] key, byte[] item) {
		RedisSerializer stringSerializer = new StringRedisSerializer();
		redisTemplate.setHashValueSerializer(stringSerializer);
		return redisTemplate.opsForHash().get(key, item);
	}

	/**
	 * 获取hashKey对应的所有键值
	 * 
	 * @param key
	 *            键
	 * @return 对应的多个键值
	 */
	public static Map hmget(String key) {
		RedisSerializer stringSerializer = new StringRedisSerializer();
		redisTemplate.setHashValueSerializer(stringSerializer);
		return redisTemplate.opsForHash().entries(key);
	}

	/**
	 * 
	 * @Title: hkeys
	 * @Description: 获取hash所有字段
	 * @param @param key
	 * @param @return 设定文件
	 * @return Set 返回类型
	 * @throws
	 */
	public static Set hkeys(String key) {
		return redisTemplate.opsForHash().keys(key);
	}

	/**
	 * HashSet
	 * 
	 * @param key
	 *            键
	 * @param map
	 *            对应多个键值
	 * @return true 成功 false 失败
	 */
	public static boolean hmset(String key, Map map) {
		try {
			redisTemplate.opsForHash().putAll(key, map);
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * HashSet 并设置时间
	 * 
	 * @param key
	 *            键
	 * @param map
	 *            对应多个键值
	 * @param time
	 *            时间(秒)
	 * @return true成功 false失败
	 */
	public static boolean hmset(String key, Map map, long time) {
		try {
			redisTemplate.opsForHash().putAll(key, map);
			if (time > 0) {
				expire(key, time);
			}
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 向一张hash表中放入数据,如果不存在将创建
	 * 
	 * @param key
	 *            键
	 * @param item
	 *            项
	 * @param value
	 *            值
	 * @return true 成功 false失败
	 */
	public static boolean hset(String key, String item, Object value) {
		try {
			redisTemplate.opsForHash().put(key, item, value);
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	public static boolean hset(byte[] key, byte[] item, byte[] value) {
		try {
			redisTemplate.opsForHash().put(key, item, value);
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 向一张hash表中放入数据,如果不存在将创建
	 * 
	 * @param key
	 *            键
	 * @param item
	 *            项
	 * @param value
	 *            值
	 * @param time
	 *            时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
	 * @return true 成功 false失败
	 */
	public static boolean hset(String key, String item, Object value, long time) {
		try {
			redisTemplate.opsForHash().put(key, item, value);
			if (time > 0) {
				expire(key, time);
			}
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 删除hash表中的值
	 * 
	 * @param key
	 *            键 不能为null
	 * @param item
	 *            项 可以使多个 不能为null
	 */
	public static void hdel(String key, Object... item) {
		redisTemplate.opsForHash().delete(key, item);
	}

	public static void hdel(byte[] key, Object... item) {
		redisTemplate.opsForHash().delete(key, item);
	}

	/**
	 * 判断hash表中是否有该项的值
	 * 
	 * @param key
	 *            键 不能为null
	 * @param item
	 *            项 不能为null
	 * @return true 存在 false不存在
	 */
	public static boolean hHasKey(String key, String item) {
		return redisTemplate.opsForHash().hasKey(key, item);
	}

	/**
	 * hash递增 如果不存在,就会创建一个 并把新增后的值返回
	 * 
	 * @param key
	 *            键
	 * @param item
	 *            项
	 * @param by
	 *            要增加几(大于0)
	 * @return
	 */
	public static double hincr(String key, String item, double by) {
		return redisTemplate.opsForHash().increment(key, item, by);
	}

	/**
	 * hash递减
	 * 
	 * @param key
	 *            键
	 * @param item
	 *            项
	 * @param by
	 *            要减少记(小于0)
	 * @return
	 */
	public static double hdecr(String key, String item, double by) {
		return redisTemplate.opsForHash().increment(key, item, -by);
	}

	/**
	 * 根据key获取Set中的所有值
	 * 
	 * @param key
	 *            键
	 * @return
	 */
	public static Set sGet(String key) {
		try {
			return redisTemplate.opsForSet().members(key);
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 根据value从一个set中查询,是否存在
	 * 
	 * @param key
	 *            键
	 * @param value
	 *            值
	 * @return true 存在 false不存在
	 */
	public static boolean sHasKey(String key, Object value) {
		try {
			return redisTemplate.opsForSet().isMember(key, value);
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 将数据放入set缓存
	 * 
	 * @param key
	 *            键
	 * @param values
	 *            值 可以是多个
	 * @return 成功个数
	 */
	public static long sSet(String key, Object... values) {
		try {
			return redisTemplate.opsForSet().add(key, values);
		} catch (Exception e) {
			e.printStackTrace();
			return 0;
		}
	}

	/**
	 * 将set数据放入缓存
	 * 
	 * @param key
	 *            键
	 * @param time
	 *            时间(秒)
	 * @param values
	 *            值 可以是多个
	 * @return 成功个数
	 */
	public static long sSetAndTime(String key, long time, Object... values) {
		try {
			Long count = redisTemplate.opsForSet().add(key, values);
			if (time > 0)
				expire(key, time);
			return count;
		} catch (Exception e) {
			e.printStackTrace();
			return 0;
		}
	}

	/**
	 * 获取set缓存的长度
	 * 
	 * @param key
	 *            键
	 * @return
	 */
	public static long sGetSetSize(String key) {
		try {
			return redisTemplate.opsForSet().size(key);
		} catch (Exception e) {
			e.printStackTrace();
			return 0;
		}
	}

	/**
	 * 移除值为value的
	 * 
	 * @param key
	 *            键
	 * @param values
	 *            值 可以是多个
	 * @return 移除的个数
	 */
	public static long setRemove(String key, Object... values) {
		try {
			Long count = redisTemplate.opsForSet().remove(key, values);
			return count;
		} catch (Exception e) {
			e.printStackTrace();
			return 0;
		}
	}

	/**
	 * 获取list缓存的内容
	 * 
	 * @param key
	 *            键
	 * @param start
	 *            开始
	 * @param end
	 *            结束 0 到 -1代表所有值
	 * @return
	 */
	public static List lGet(String key, long start, long end) {
		try {
			return redisTemplate.opsForList().range(key, start, end);
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 获取list缓存的长度
	 * 
	 * @param key
	 *            键
	 * @return
	 */
	public static long lGetListSize(String key) {
		try {
			return redisTemplate.opsForList().size(key);
		} catch (Exception e) {
			e.printStackTrace();
			return 0;
		}
	}

	/**
	 * 通过索引 获取list中的值
	 * 
	 * @param key
	 *            键
	 * @param index
	 *            索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
	 * @return
	 */
	public static Object lGetIndex(String key, long index) {
		try {
			return redisTemplate.opsForList().index(key, index);
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 将list放入缓存
	 * 
	 * @param key
	 *            键
	 * @param value
	 *            值
	 * @param time
	 *            时间(秒)
	 * @return
	 */
	public static boolean lSet(String key, Object value) {
		try {
			redisTemplate.opsForList().rightPush(key, value);
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 将list放入缓存
	 * 
	 * @param key
	 *            键
	 * @param value
	 *            值
	 * @param time
	 *            时间(秒)
	 * @return
	 */
	public static boolean lSet(String key, Object value, long time) {
		try {
			redisTemplate.opsForList().rightPush(key, value);
			if (time > 0)
				expire(key, time);
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 将list放入缓存
	 * 
	 * @param key
	 *            键
	 * @param value
	 *            值
	 * @param time
	 *            时间(秒)
	 * @return
	 */
	public static boolean lSet(String key, List value) {
		try {
			redisTemplate.opsForList().rightPushAll(key, value);
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 将list放入缓存
	 * 
	 * @param key
	 *            键
	 * @param value
	 *            值
	 * @param time
	 *            时间(秒)
	 * @return
	 */
	public static boolean lSet(String key, List value, long time) {
		try {
			redisTemplate.opsForList().rightPushAll(key, value);
			if (time > 0)
				expire(key, time);
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 根据索引修改list中的某条数据
	 * 
	 * @param key
	 *            键
	 * @param index
	 *            索引
	 * @param value
	 *            值
	 * @return
	 */
	public static boolean lUpdateIndex(String key, long index, Object value) {
		try {
			redisTemplate.opsForList().set(key, index, value);
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 移除N个值为value
	 * 
	 * @param key
	 *            键
	 * @param count
	 *            移除多少个
	 * @param value
	 *            值
	 * @return 移除的个数
	 */
	public static long lRemove(String key, long count, Object value) {
		try {
			Long remove = redisTemplate.opsForList().remove(key, count, value);
			return remove;
		} catch (Exception e) {
			e.printStackTrace();
			return 0;
		}
	}

	/**
	 * 获取byte[]类型Key
	 * 
	 * @param key
	 * @return
	 */
	public static byte[] getBytesKey(Object object) {
		if (object instanceof String) {
			return StringUtils.getBytes((String) object);
		} else {
			return ObjectUtils.serialize(object);
		}
	}

	/**
	 * Object转换byte[]类型
	 * 
	 * @param key
	 * @return
	 */
	public static byte[] toBytes(Object object) {
		return ObjectUtils.serialize(object);
	}

	/**
	 * byte[]型转换Object
	 * 
	 * @param key
	 * @return
	 */
	public static Object toObject(byte[] bytes) {
		return ObjectUtils.unserialize(bytes);
	}

	/**
	 * 指定缓存失效时间
	 * 
	 * @param key
	 *            键
	 * @param time
	 *            时间(秒)
	 * @return
	 */
	public static boolean expire(String key, long time) {
		try {
			if (time > 0) {
				redisTemplate.expire(key, time, TimeUnit.SECONDS);
			}
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 根据key 获取过期时间
	 * 
	 * @param key
	 *            键 不能为null
	 * @return 时间(秒) 返回0代表为永久有效
	 */
	public static long getExpire(String key) {
		return redisTemplate.getExpire(key, TimeUnit.SECONDS);
	}

	/**
	 * 判断key是否存在
	 * 
	 * @param key
	 *            键
	 * @return true 存在 false不存在
	 */
	public static boolean hasKey(String key) {
		try {
			return redisTemplate.hasKey(key);
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 删除缓存
	 * 
	 * @param key
	 *            可以传一个值 或多个
	 */
	public static void del(String... key) {
		if (key != null && key.length > 0) {
			if (key.length == 1) {
				redisTemplate.delete(key[0]);
			} else {
				redisTemplate.delete(CollectionUtils.arrayToList(key));
			}
		}
	}

	/**
	 * 判断key是否存在
	 * 
	 * @param key
	 *            键
	 * @return true 存在 false不存在
	 */
	public static Collection values(String key) {
		return redisTemplate.opsForHash().values(key);
	}

}


2.7 redis集群配置spring-cluster-jedis.xml文件





	Jedis Configuration
	
	
	
		
	
		
		
		
		
	

	
	
		
		
			
				
					
					
				
				
					
					
				
				
					
					
				
				
					
					
				
				
					
					
				
				
					
					
				
			
		
	

	
	
		
		
		
	

	
	

	
	
		
		
		
            
        
		
	




2.8 redis集群配置属性文件


#--------------redis settings--------------
redis.keyPrefix=
redis.host1=${redis.host1}
redis.port1=${redis.port1}
redis.host2=${redis.host2}
redis.port2=${redis.port2}
redis.host3=${redis.host3}
redis.port3=${redis.port3}
redis.host4=${redis.host4}
redis.port4=${redis.port4}
redis.host5=${redis.host5}
redis.port5=${redis.port5}
redis.host6=${redis.host6}
redis.port6=${redis.port6}

redis.maxTotal=1000
redis.maxIdle=100
redis.maxWaitMillis=1000
redis.timeout=30000
redis.testOnBorrow=true
redis.password=



2.9 登录Controller


	@RequestMapping(value = "/login", method = RequestMethod.POST)
	public ResponseVO login(@RequestBody Member member, HttpServletRequest request, HttpServletResponse response) {
        //获取平台标识
        String strPlatformFlag = (String)request.getAttribute("platformFlag");
        System.out.println("==============strPlatformFlag:=============" + strPlatformFlag);
        member.setPlatformFlag(strPlatformFlag);

		//判断必要参数是否为空
		if (!StringUtils.isNotBlank(member.getLoginName()) || !StringUtils.isNotBlank(member.getPassword()) ||
                !StringUtils.isNotBlank(member.getPlatformFlag()) ||!StringUtils.isNotBlank(member.getLoginType()) ||
                !StringUtils.isNotBlank(member.getSource())) {
			return ResponseCode.buildEnumResponseVO(ResponseCode.RESPONSE_CODE_REQ_CANNOT_EMPTY, null);
		}

        //请求参数，登录日志记录
        String strParam = member.toString();
		
		//判断用户是否存在
		Member user = memberService.getByLoginName(member.getLoginName());
		if(user == null ){
			return ResponseCode.buildEnumResponseVO(ResponseCode.RESPONSE_CODE_USER_DOES_NOT_EXIST, null);
		}
        String strPassword = "";
        String password = "";
        try {
            //RSA解密密码
            strPassword = RSAUtils.decrypt(member.getPassword(), RSAUtils.getPrivateKey());
            member.setPassword(strPassword);

            password = MD5EncryptUtil.encryptMD5Code(member.getPassword());
        }catch (Exception e){
            return ResponseCode.buildEnumResponseVO(ResponseCode.DECRYPT_FAIL, null);
        }
        try {
            //判断密码是否正确并添加token
            if (StringUtils.equals(password, user.getPassword())) {
                String token = JWT.sign(member.getSource() + user.getId(), 0);
                //token在redis中的key等于redis_token+ 来源(0.公众号,1.PC,2.APP3.小程序) + 用户id
                //token在redis中的value等于key加密
                RedisClusterUtils.set(LoginInterceptor.REDIS_TOKEN_FLAG + member.getSource() + user.getId(), token, 1800);
                Map dataMap = new HashMap();
                dataMap.put("token", token);
                dataMap.put("mid", user.getId());
                return ResponseCode.buildEnumResponseVO(ResponseCode.RESPONSE_CODE_LOGIN_SUCCESS, JSONObject.fromObject(dataMap));
            }
        }catch (Exception e){
            return ResponseCode.buildEnumResponseVO(ResponseCode.RESPONSE_CODE_FAILURE, null);
        }
		return ResponseCode.buildEnumResponseVO(ResponseCode.USER_LOGIN_PWD_ERROR, false);
	}



























你可能感兴趣的:(spring+springmvc+Interceptor+jwt+redis实现sso单点登录)






    

  • element实现动态路由+面包屑
软件技术NINI
vue案例vue.js前端

    el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
    

    • 

  • 微服务下功能权限与数据权限的设计与实现
nbsaas-boot
微服务java架构

    在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
    

    • 

  • 2021年12月19日，春蕾教育集团团建活动感受——黄晓丹
黄错错加油

    感受:1.从陌生到熟悉的过程。游戏环节让我们在轻松的氛围中得到了锻炼，也增长了不少知识。2.游戏过程中，我们贡献的是个人力量，展现的是团队的力量。它磨合的往往不止是工作的熟悉，更是观念上契合度的贴近。3.这和工作是一样的道理。在各自的岗位上，每个人摆正自己的位置、各司其职充分发挥才能，并团结一致劲往一处使，才能实现最大的成功。新知:1.团队精神需要不断地创新。过去，人们把创新看作是冒风险，现在人们
    

    • 

  • 店群合一模式下的社区团购新发展——结合链动 2+1 模式、AI 智能名片与 S2B2C 商城小程序源码
说私域
人工智能小程序

    摘要：本文探讨了店群合一的社区团购平台在当今商业环境中的重要性和优势。通过分析店群合一模式如何将互联网社群与线下终端紧密结合，阐述了链动2+1模式、AI智能名片和S2B2C商城小程序源码在这一模式中的应用价值。这些创新元素的结合为社区团购带来了新的机遇，提升了用户信任感、拓展了营销渠道，并实现了线上线下的完美融合。一、引言随着互联网技术的不断发展，社区团购作为一种新兴的商业模式，在满足消费者日常需
    

    • 

  • 消息中间件有哪些常见类型
xmh-sxh-1314
java

    消息中间件根据其设计理念和用途，可以大致分为以下几种常见类型：点对点消息队列（Point-to-PointMessagingQueues）：在这种模型中，消息被发送到特定的队列中，消费者从队列中取出并处理消息。队列中的消息只能被一个消费者消费，消费后即被删除。常见的实现包括IBM的MQSeries、RabbitMQ的部分使用场景等。适用于任务分发、负载均衡等场景。发布/订阅消息模型（Pub/Sub
    

    • 

  • 腾讯云技术深度探索：构建高效云原生微服务架构
我的运维人生
云原生架构腾讯云运维开发技术共享

    腾讯云技术深度探索：构建高效云原生微服务架构在当今快速发展的技术环境中，云原生技术已成为企业数字化转型的关键驱动力。腾讯云作为行业领先的云服务提供商，不断推出创新的产品和技术，助力企业构建高效、可扩展的云原生微服务架构。本文将深入探讨腾讯云在微服务领域的最新进展，并通过一个实际案例展示如何在腾讯云平台上构建云原生应用。腾讯云微服务架构概览腾讯云微服务架构基于云原生理念，旨在帮助企业快速实现应用的容
    

    • 

  • 拥有断舍离的心态，过精简生活--《断舍离》读书笔记
爱吃丸子的小樱桃

    不知不觉间房间里的东西越来越多，虽然摆放整齐，但也时常会觉得空间逼仄，令人心生烦闷。抱着断舍离的态度，我开始阅读《断舍离》这本书，希望从书中能找到一些有效的方法，帮助我实现空间、物品上的断舍离。《断舍离》是日本作家山下英子通过自己的经历、思考和实践总结而成的，整体内涵也从刚开始的私人生活哲学的“断舍离”升华成了“人生实践哲学”，接着又成为每个人都能实行的“改变人生的断舍离”，从“哲学”逐渐升华成“
    

    • 

  • 从0到500+，我是如何利用自媒体赚钱？
一列脚印

    运营公众号半个多月，从零基础的小白到现在慢慢懂了一些运营的知识。做好公众号是很不容易的，要做很多事情；排版、码字、引流…通通需要自己解决，业余时间全都花费在这上面涨这么多粉丝是真的不容易，对比知乎大佬来说，我们这种没资源，没人脉，还没钱的小透明来说，想要一个月涨粉上万，怕是今天没睡醒（不过你有的方法，算我piapia打脸）至少我是清醒的，自己慢慢努力，实现我的万粉目标！大家快来围观、支持我吧！孩子
    

    • 

  • 使用LLaVa和Ollama实现多模态RAG示例
llzwxh888
python人工智能开发语言

    本文将详细介绍如何使用LLaVa和Ollama实现多模态RAG（检索增强生成），通过提取图像中的结构化数据、生成图像字幕等功能来展示这一技术的强大之处。安装环境首先，您需要安装以下依赖包：!pipinstallllama-index-multi-modal-llms-ollama!pipinstallllama-index-readers-file!pipinstallunstructured!p
    

    • 

  • 利用LangChain的StackExchange组件实现智能问答系统
nseejrukjhad
langchainmicrosoft数据库python

    利用LangChain的StackExchange组件实现智能问答系统引言在当今的软件开发世界中，StackOverflow已经成为程序员解决问题的首选平台之一。而LangChain作为一个强大的AI应用开发框架，提供了StackExchange组件，使我们能够轻松地将StackOverflow的海量知识库集成到我们的应用中。本文将详细介绍如何使用LangChain的StackExchange组件
    

    • 

  • MongoDB Oplog 窗口
喝醉酒的小白
MongoDB运维

    在MongoDB中，oplog（操作日志）是一个特殊的日志系统，用于记录对数据库的所有写操作。oplog允许副本集成员（通常是从节点）应用主节点上已经执行的操作，从而保持数据的一致性。它是MongoDB副本集实现数据复制的基础。MongoDBOplog窗口oplog窗口是指在MongoDB副本集中，从节点可以用来同步数据的时间范围。这个窗口通常由以下因素决定：Oplog大小：oplog的大小是有限
    

    • 

  • Faiss Tips：高效向量搜索与聚类的利器
焦习娜Samantha

    FaissTips：高效向量搜索与聚类的利器faiss_tipsSomeusefultipsforfaiss项目地址:https://gitcode.com/gh_mirrors/fa/faiss_tips项目介绍Faiss是由FacebookAIResearch开发的一个用于高效相似性搜索和密集向量聚类的库。它支持多种硬件平台，包括CPU和GPU，能够在海量数据集上实现快速的近似最近邻搜索（AN
    

    • 

  • Python 实现图片裁剪（附代码） | Python工具
剑客阿良_ALiang

    前言本文提供将图片按照自定义尺寸进行裁剪的工具方法，一如既往的实用主义。环境依赖ffmpeg环境安装，可以参考我的另一篇文章：windowsffmpeg安装部署_阿良的博客-CSDN博客本文主要使用到的不是ffmpeg，而是ffprobe也在上面这篇文章中的zip包中。ffmpy安装：pipinstallffmpy-ihttps://pypi.douban.com/simple代码不废话了，上代码
    

    • 

  • 数据仓库——维度表一致性
墨染丶eye
背诵数据仓库

    数据仓库基础笔记思维导图已经整理完毕，完整连接为：数据仓库基础知识笔记思维导图维度一致性问题从逻辑层面来看，当一系列星型模型共享一组公共维度时，所涉及的维度称为一致性维度。当维度表存在不一致时，短期的成功难以弥补长期的错误。维度时确保不同过程中信息集成起来实现横向钻取货活动的关键。造成横向钻取失败的原因维度结构的差别，因为维度的差别，分析工作涉及的领域从简单到复杂，但是都是通过复杂的报表来弥补设计
    

    • 

  • ARM驱动学习之5 LEDS驱动
JT灬新一
嵌入式C底层arm开发学习单片机

    ARM驱动学习之5LEDS驱动知识点：•linuxGPIO申请函数和赋值函数–gpio_request–gpio_set_value•三星平台配置GPIO函数–s3c_gpio_cfgpin•GPIO配置输出模式的宏变量–S3C_GPIO_OUTPUT注意点：DRIVER_NAME和DEVICE_NAME匹配。实现步骤：1.加入需要的头文件：//Linux平台的gpio头文件#include//三
    

    • 

  • Low Power概念介绍-Voltage Area
飞奔的大虎

    随着智能手机，以及物联网的普及，芯片功耗的问题最近几年得到了越来越多的重视。为了实现集成电路的低功耗设计目标，我们需要在系统设计阶段就采用低功耗设计的方案。而且，随着设计流程的逐步推进，到了芯片后端设计阶段，降低芯片功耗的方法已经很少了，节省的功耗百分比也不断下降。芯片的功耗主要由静态功耗（staticleakagepower）和动态功耗(dynamicpower)构成。静态功耗主要是指电路处于等
    

    • 

  • 道阻且长，行则将至
sweet橘子

    本文参与书香澜梦主题征文“行”文章原创首发，文责自负。我们每一个人都应该有属于自己的愿望或者是理想，人一但有了理想也就算是有了方向，它就会像灯塔一样指引我们前进的方向，哪怕是再远大的理想，如果坚持，那么我相信它就一定有收获。屈原是我最喜欢的一个浪漫主义的诗人，他曾今说过：“路漫漫其修远兮，吾将上下而求索。”人生的道路很长，但是为了实现自己的理想抱负我愿意付出我毕生的精力，只专注这一件事，因为“道阻
    

    • 

  • insert into select 主键自增_mybatis拦截器实现主键自动生成
weixin_39521651
insertintoselect主键自增mybatisdelete返回值mybatisinsert返回主键mybatisinsert返回对象mybatisplusinsert返回主键mybatisplus插入生成id

    前言前阵子和朋友聊天，他说他们项目有个需求，要实现主键自动生成，不想每次新增的时候，都手动设置主键。于是我就问他，那你们数据库表设置主键自动递增不就得了。他的回答是他们项目目前的id都是采用雪花算法来生成，因此为了项目稳定性，不会切换id的生成方式。朋友问我有没有什么实现思路，他们公司的orm框架是mybatis，我就建议他说，不然让你老大把mybatis切换成mybatis-plus。mybat
    

    • 

  • 和自己结婚，是一种怎样的体验
只如初见_2020

    一个17岁谈恋爱，19岁结婚，然后离了三次婚的女人，站在台上说：“现在我结婚了，和那个一直以来，真正想在一起的人结婚了，那个人就是我自己。”她说，在我9岁前，我已经在二十几个寄养家庭中待过。我从童年到成年，就只有一个目标，不要被落下。而我实现这一目标的方式就是，我要结婚。我第一次的结婚对象，是我17岁时遇到的人。我们两年之后结了婚，当时我19岁。他是个非常好的人，来自于非常棒的家庭，他是工商管理硕
    

    • 

  • Java 重写(Override)与重载(Overload)
叨唧唧的

    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
    

    • 

  • 网络编程基础
记得开心一点啊
网络

    目录♫什么是网络编程♫Socket套接字♪什么是Socket套接字♪数据报套接字♪流套接字♫数据报套接字通信模型♪数据报套接字通讯模型♪DatagramSocket♪DatagramPacket♪实现UDP的服务端代码♪实现UDP的客户端代码♫流套接字通信模型♪流套接字通讯模型♪ServerSocket♪Socket♪实现TCP的服务端代码♪实现TCP的客户端代码♫什么是网络编程网络编程，指网络上
    

    • 

  • xilinx vivado PULLMODE 设置思路
坚持每天写程序
fpga开发

    1.xilinx引脚分类XilinxIO的分类：以XC7A100TFGG484为例，其引脚分类如下：1.UserIO(用户IO)：用户使用的普通IO1.1专用(Dedicated)IO：命名为IO_LXXY_#、IO_XX_#的引脚，有固定的特定用途，多为底层特定功能的直接实现，如差分对信号、关键控制信号等，不能随意变更。1.2多功能(Multi-Function)IO：命名为IO_LXXY_ZZ
    

    • 

  • Python实现简单的机器学习算法
master_chenchengg
pythonpython办公效率python开发IT

    Python实现简单的机器学习算法开篇：初探机器学习的奇妙之旅搭建环境：一切从安装开始必备工具箱第一步：安装Anaconda和JupyterNotebook小贴士：如何配置Python环境变量算法初体验：从零开始的Python机器学习线性回归：让数据说话数据准备：从哪里找数据编码实战：Python实现线性回归模型评估：如何判断模型好坏逻辑回归：从分类开始理论入门：什么是逻辑回归代码实现：使用skl
    

    • 

  • C语言 判断回文数
Y雨何时停T
c语言学习

    一，回文数概念“回文”是指正读反读都能读通的句子，它是古今中外都有的一种修辞方式和文字游戏，如“我为人人，人人为我”等。在数学中也有这样一类数字有这样的特征，成为回文数。设n是一任意自然数。若将n的各位数字反向排列所得自然数n1与n相等，则称n为一回文数。例如，若n=1234321，则称n为一回文数；但若n=1234567，则n不是回文数。二，判断回文数实现思路一：数组与字符串将数字每一位按顺序放
    

    • 

  • 九月班级管理工作反思
追梦蜂

    这个月应该算是最难的一个月，我已N年没当班主任，然后我又开始当了。职称是一方面，想到我如果退休了，不能再接触学生了，那该是多么遗憾的事！我的学生梁*铭是我的榜样，她那么努力，那么拼，那么上进，为什么我不行？虽然我面临的工作很难，但是高考数学也不容易。她拿下来了！满分150分她考了146分！我目睹她的艰辛，她的拼搏！还有，我要为我的孩子做榜样，如何竭尽全力，实现梦想。还有，服务，为社会做事，也是会有
    

    • 

  • 2021-01-24
9ce517ee104c

    【打卡素材】《香帅金融学讲义》【标题】公司治理：怎样同床异梦地过下去【日期】2021.1.24【字数】公司本质上是一连串的合约关系。降低合同执行中的各种摩擦是公司正常有效运行的基础。协同各方的利益、制衡各方的权力是关键。为解决利益冲突问题、协同各方利益，进行权力制衡的机制设计就是公司治理机制。001什么是公司治理治理是管理的基础，治理机制越好，权、责、利就越清晰，管理的目标也就会更容易实现。002
    

    • 

  • 读书笔记|《遇见孩子，遇见更好的自己》5
抹茶社长

    为人父母意味着放弃自己的过去，不要对以往没有实现的心愿耿耿于怀，只有这样，孩子们才能做回自己。985909803.jpg孩子在与父母保持亲密的同时更需要独立，唯有这样，孩子才会成为孩子，父母才会成其为父母。有耐心的人生往往更幸福，给孩子留点余地。认识到养儿育女是对耐心的考验。为失败做好心理准备，教会孩子控制情绪。了解自己的底线，说到底线，有一点很重要，父母之所以发脾气，真正的原因往往在于他们自己，
    

    • 

  • 推荐算法_隐语义-梯度下降
_feivirus_
算法机器学习和数学推荐算法机器学习隐语义

    importnumpyasnp1.模型实现"""inputrate_matrix:M行N列的评分矩阵，值为P*Q.P:初始化用户特征矩阵M*K.Q:初始化物品特征矩阵K*N.latent_feature_cnt:隐特征的向量个数max_iteration:最大迭代次数alpha:步长lamda:正则化系数output分解之后的P和Q"""defLFM_grad_desc(rate_matrix,l
    

    • 

  • Java面试题精选：消息队列(二)
芒果不是芒
Java面试题精选javakafka

    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
    

    • 

  • 用Python实现简单的猜数字游戏
程序媛了了
python游戏java

    猜数字游戏代码：importrandomdefpythonit():a=random.randint(1,100)n=int(input("输入你猜想的数字："))whilen!=a:ifn>a:print("很遗憾，猜大了")n=int(input("请再次输入你猜想的数字："))elifna::如果玩家猜的数字n大于随机数字a，则输出"很遗憾，猜大了"，并提示玩家再次输入。elifn

    • 

  • java短路运算符和逻辑运算符的区别
3213213333332132
java基础

    
/*
* 逻辑运算符——不论是什么条件都要执行左右两边代码
* 短路运算符——我认为在底层就是利用物理电路的“并联”和“串联”实现的
* 原理很简单，并联电路代表短路或（||），串联电路代表短路与（&&）。
*
* 并联电路两个开关只要有一个开关闭合，电路就会通。
* 类似于短路或（||），只要有其中一个为true（开关闭合）是
    

    • 

  • Java异常那些不得不说的事
白糖_
javaexception

    一、在finally块中做数据回收操作
比如数据库连接都是很宝贵的，所以最好在finally中关闭连接。
JDBCAgent jdbc = new JDBCAgent();
try{
jdbc.excute("select * from ctp_log");
}catch(SQLException e){
...
}finally{
jdbc.close(); 
    

    • 

  • utf-8与utf-8(无BOM)的区别
dcj3sjt126com
PHP

    BOM——Byte Order Mark，就是字节序标记   在UCS 编码中有一个叫做"ZERO WIDTH NO-BREAK SPACE"的字符，它的编码是FEFF。而FFFE在UCS中是不存在的字符，所以不应该出现在实际传输中。UCS规范建议我们在传输字节流前，先传输 字符"ZERO WIDTH NO-BREAK SPACE"。这样如
    

    • 

  • JAVA Annotation之定义篇
周凡杨
java注解annotation入门注释

        Annotation: 译为注释或注解
An annotation, in the Java computer programming language, is a form of syntactic metadata that can be added to Java source code. Classes, methods, variables, pa
    

    • 

  • tomcat的多域名、虚拟主机配置
g21121
tomcat

    众所周知apache可以配置多域名和虚拟主机，而且配置起来比较简单，但是项目用到的是tomcat，配来配去总是不成功。查了些资料才总算可以，下面就跟大家分享下经验。
很多朋友搜索的内容基本是告诉我们这么配置：
在Engine标签下增面积Host标签，如下：
<Host name="www.site1.com" appBase="webapps"
    

    • 

  • Linux SSH 错误解析（Capistrano 的cap 访问错误 Permission ）
510888780
linuxcapistrano

    
1.ssh -v [email protected] 出现
Permission denied (publickey,gssapi-keyex,gssapi-with-mic,password).
错误
运行状况如下：
OpenSSH_5.3p1, OpenSSL 1.0.1e-fips 11 Feb 2013
debug1: Reading configuratio
    

    • 

  • log4j的用法
Harry642
javalog4j

    一、前言：     log4j 是一个开放源码项目，是广泛使用的以Java编写的日志记录包。由于log4j出色的表现，     当时在log4j完成时，log4j开发组织曾建议sun在jdk1.4中用log4j取代jdk1.4 的日志工具类，但当时jdk1.4已接近完成，所以sun拒绝使用log4j，当在java开发中
    

    • 

  • mysql、sqlserver、oracle分页，java分页统一接口实现
aijuans
oraclejave

    
定义：pageStart 起始页，pageEnd 终止页,pageSize页面容量
oracle分页：
　　　　select * from ( select mytable.*,rownum num from (实际传的SQL) where rownum<=pageEnd) where num>=pageStart
sqlServer分页：
 
    

    • 

  • Hessian 简单例子
antlove
javaWebservicehessian

    hello.hessian.MyCar.java
package hessian.pojo;
import java.io.Serializable;
public class MyCar implements Serializable {
private static final long serialVersionUID = 473690540190845543
    

    • 

  • 数据库对象的同义词和序列
百合不是茶
sql序列同义词ORACLE权限

    回顾简单的数据库权限等命令;
解锁用户和锁定用户
alter user scott account lock/unlock;
//system下查看系统中的用户
select * dba_users;
//创建用户名和密码
create user wj identified by wj;
identified by
//授予连接权和建表权
grant connect to 
    

    • 

  • 使用Powermock和mockito测试静态方法
bijian1013
持续集成单元测试mockitoPowermock

            实例：
package com.bijian.study;
import static org.junit.Assert.assertEquals;
import java.io.IOException;
import org.junit.Before;
import org.junit.Test;
import or
    

    • 

  • 精通Oracle10编程SQL(6)访问ORACLE
bijian1013
oracle数据库plsql

    /*
*访问ORACLE
*/
--检索单行数据
--使用标量变量接收数据
DECLARE
v_ename emp.ename%TYPE;
v_sal emp.sal%TYPE;
BEGIN
select ename,sal into v_ename,v_sal
from emp where empno=&no;
dbms_output.pu
    

    • 

  • 【Nginx四】Nginx作为HTTP负载均衡服务器
bit1129
nginx

     Nginx的另一个常用的功能是作为负载均衡服务器。一个典型的web应用系统，通过负载均衡服务器，可以使得应用有多台后端服务器来响应客户端的请求。一个应用配置多台后端服务器，可以带来很多好处：
  负载均衡的好处
增加可用资源
增加吞吐量
加快响应速度，降低延时
出错的重试验机制
Nginx主要支持三种均衡算法：
round-robin
l
    

    • 

  • jquery-validation备忘
白糖_
jquerycssF#Firebug

    留点学习jquery validation总结的代码：
 
function checkForm(){
validator = $("#commentForm").validate({// #formId为需要进行验证的表单ID
errorElement :"span",// 使用"div"标签标记错误， 默认:&
    

    • 

  • solr限制admin界面访问（端口限制和http授权限制）
ronin47
限定Ip访问

    solr的管理界面可以帮助我们做很多事情，但是把solr程序放到公网之后就要限制对admin的访问了。
可以通过tomcat的http基本授权来做限制，也可以通过iptables防火墙来限制。
我们先看如何通过tomcat配置http授权限制。
第一步： 在tomcat的conf/tomcat-users.xml文件中添加管理用户，比如：
<userusername="ad
    

    • 

  • 多线程-用JAVA写一个多线程程序，写四个线程，其中二个对一个变量加1，另外二个对一个变量减1
bylijinnan
java多线程

    
public class IncDecThread {
private int j=10;
/*
* 题目:用JAVA写一个多线程程序，写四个线程，其中二个对一个变量加1，另外二个对一个变量减1
* 两个问题：
* 1、线程同步--synchronized
* 2、线程之间如何共享同一个j变量--内部类
*/
public static 
    

    • 

  • 买房历程
cfyme

     
 
2015-06-21: 万科未来城，看房子
 
2015-06-26: 办理贷款手续，贷款73万，贷款利率5.65=5.3675
 
2015-06-27: 房子首付,签完合同
 
2015-06-28，央行宣布降息 0.25，就2天的时间差啊，没赶上。
 
首付，老婆找他的小姐妹接了5万，另外几个朋友借了1-
    

    • 

  • [军事与科技]制造大型太空战舰的前奏
comsci
制造

    
       天气热了........空调和电扇要准备好..........
       最近,世界形势日趋复杂化,战争的阴影开始覆盖全世界..........
       所以,我们不得不关
    

    • 

  • dateformat
dai_lm
DateFormat

    
"Symbol Meaning Presentation Ex."
"------ ------- ------------ ----"
"G era designator (Text) AD"
"y year
    

    • 

  • Hadoop如何实现关联计算
datamachine
mapreducehadoop关联计算

        选择Hadoop，低成本和高扩展性是主要原因，但但它的开发效率实在无法让人满意。
    以关联计算为例。
    假设：HDFS上有2个文件，分别是客户信息和订单信息，customerID是它们之间的关联字段。如何进行关联计算，以便将客户名称添加到订单列表中？
  &nbs
    

    • 

  • 用户模型中修改用户信息时，密码是如何处理的
dcj3sjt126com
yii

    当我添加或修改用户记录的时候对于处理确认密码我遇到了一些麻烦，所有我想分享一下我是怎么处理的。
场景是使用的基本的那些(系统自带)，你需要有一个数据表(user)并且表中有一个密码字段(password),它使用 sha1、md5或其他加密方式加密用户密码。
面是它的工作流程: 当创建用户的时候密码需要加密并且保存，但当修改用户记录时如果使用同样的场景我们最终就会把用户加密过的密码再次加密，这
    

    • 

  • 中文 iOS/Mac 开发博客列表
dcj3sjt126com
Blog

     
本博客列表会不断更新维护，如果有推荐的博客，请到此处提交博客信息。
本博客列表涉及的文章内容支持 定制化Google搜索，特别感谢 JeOam 提供并帮助更新。
本博客列表也提供同步更新的OPML文件（下载OPML文件），可供导入到例如feedly等第三方定阅工具中，特别感谢 lcepy 提供自动转换脚本。这里有导入教程。 
    

    • 

  • js去除空格，去除左右两端的空格
蕃薯耀
去除左右两端的空格js去掉所有空格js去除空格

    js去除空格，去除左右两端的空格
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>&g
    

    • 

  • SpringMVC4零配置--web.xml
hanqunfeng
springmvc4

    servlet3.0+规范后，允许servlet，filter，listener不必声明在web.xml中，而是以硬编码的方式存在，实现容器的零配置。
ServletContainerInitializer：启动容器时负责加载相关配置
package javax.servlet;
import java.util.Set;
public interface ServletContainer
    

    • 

  • 《开源框架那些事儿21》：巧借力与借巧力
j2eetop
框架UI

    同样做前端UI，为什么有人花了一点力气，就可以做好？而有的人费尽全力，仍然错误百出？我们可以先看看几个故事。
故事1：巧借力，乌鸦也可以吃核桃
有一个盛产核桃的村子，每年秋末冬初，成群的乌鸦总会来到这里，到果园里捡拾那些被果农们遗落的核桃。
核桃仁虽然美味，但是外壳那么坚硬，乌鸦怎么才能吃到呢？原来乌鸦先把核桃叼起，然后飞到高高的树枝上，再将核桃摔下去，核桃落到坚硬的地面上，被撞破了，于是，
    

    • 

  • JQuery EasyUI 验证扩展
可怜的猫
jqueryeasyui验证

      最近项目中用到了前端框架-- EasyUI，在做校验的时候会涉及到很多需要自定义的内容，现把常用的验证方式总结出来，留待后用。
  以下内容只需要在公用js中添加即可。
  使用类似于如下：
<input class="easyui-textbox" name="mobile" id="mobile&
    

    • 

  • 架构师之httpurlconnection----------读取和发送(流读取效率通用类)
nannan408

    1.前言.
   如题.
2.代码.
/*
* Copyright (c) 2015, S.F. Express Inc. All rights reserved.
*/
package com.test.test.test.send;
import java.io.IOException;
import java.io.InputStream
    

    • 

  • Jquery性能优化
r361251
JavaScriptjquery

    一、注意定义jQuery变量的时候添加var关键字
这个不仅仅是jQuery，所有javascript开发过程中，都需要注意，请一定不要定义成如下：
$loading = $('#loading'); //这个是全局定义，不知道哪里位置倒霉引用了相同的变量名，就会郁闷至死的
二、请使用一个var来定义变量
如果你使用多个变量的话，请如下方式定义：
. 代码如下:
var page 
    

    • 

  • 在eclipse项目中使用maven管理依赖
tjj006
eclipsemaven

    概览:
如何导入maven项目至eclipse中
建立自有Maven  Java类库服务器
建立符合maven代码库标准的自定义类库
Maven在管理Java类库方面有巨大的优势，像白衣所说就是非常“环保”。
我们平时用IDE开发都是把所需要的类库一股脑的全丢到项目目录下，然后全部添加到ide的构建路径中，如果用了SVN/CVS，这样会很容易就 把
    

    • 

  • 中国天气网省市级联页面
x125858805
级联

    1、页面及级联js
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
&l
    

    •