public class RedisUtil {
private static final Logger logger = LoggerFactory.getLogger(RedisUtil.class);
private RedisTemplate<Object, Object> redisTemplate;
public RedisUtil(RedisTemplate<Object, Object> redisTemplate) {
this.redisTemplate = redisTemplate;
}
/**
* 设置有超时时间的KV
*/
public void set(String key, String value, long seconds) {
redisTemplate.opsForValue().set(key,value,seconds,TimeUnit.SECONDS);
}
/**
* 根据key删除缓存
*
public boolean delete(String key) {
if (org.springframework.util.StringUtils.isEmpty(key)) {
logger.warn("key must not be empty.");
return false;
}
boolean hasKey = redisTemplate.hasKey(key);
if (hasKey) {
redisTemplate.delete(key);
return true;
}
return false;
}
/**
* 以list形式存储数据
*
public boolean pushToList(String key, Object value) {
if (!keyIfPresent(key)) {
return false;
}
logger.debug(key.toString());
Long count = redisTemplate.opsForList().leftPush(key, value);
return count != null && count > 0;
}
/**
* 从list中获取最先插入的值
*
public Object popOneFromList(String key) {
if (!keyIfPresent(key)) {
return null;
}
logger.debug(key.toString());
return redisTemplate.opsForList().rightPop(key);
}
private boolean keyIfPresent(String key) {
if (key == null) {
logger.error("key must not be empty.");
return false;
}
return true;
}
/**
* 指定缓存失效时间
*
* @param key 键
* @param time 时间(秒)
* @return
*/
public 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 long getExpire(String key) {
return redisTemplate.getExpire(key, TimeUnit.SECONDS);
}
/**
* 判断key是否存在
*
* @param key 键
* @return true 存在 false不存在
*/
public boolean hasKey(String key) {
try {
return redisTemplate.hasKey(key);
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 删除缓存
*
* @param key 可以传一个值 或多个
*/
@SuppressWarnings("unchecked")
public void del(String... key) {
if (key != null && key.length > 0) {
if (key.length == 1) {
redisTemplate.delete(key[0]);
} else {
redisTemplate.delete(CollectionUtils.arrayToList(key));
}
}
}
/**
* 普通缓存获取
*
* @param key 键
* @return 值
*/
public Object get(String key) {
return key == null ? null : redisTemplate.opsForValue().get(key);
}
/**
* 普通缓存放入
*
* @param key 键
* @param value 值
* @return true成功 false失败
*/
public 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 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 键
* @return
*/
public long incr(String key, long delta) {
if (delta < 0) {
throw new RuntimeException("递增因子必须大于0");
}
return redisTemplate.opsForValue().increment(key, delta);
}
/**
* 递减
*
* @param key 键
* @param
* @return
*/
public long decr(String key, long delta) {
if (delta < 0) {
throw new RuntimeException("递减因子必须大于0");
}
return redisTemplate.opsForValue().increment(key, -delta);
}
//================================Map=================================
/**
* HashGet
*
* @param key 键 不能为null
* @param item 项 不能为null
* @return 值
*/
public Object hget(String key, String item) {
return redisTemplate.opsForHash().get(key, item);
}
/**
* 获取hashKey对应的所有键值
*
* @param key 键
* @return 对应的多个键值
*/
public Map<Object, Object> hmget(String key) {
return redisTemplate.opsForHash().entries(key);
}
/**
* HashSet
*
* @param key 键
* @param map 对应多个键值
* @return true 成功 false 失败
*/
public boolean hmset(String key, Map<String, Object> 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 boolean hmset(String key, Map<String, Object> 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 boolean hset(String key, String item, Object 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 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 void hdel(String key, Object... item) {
redisTemplate.opsForHash().delete(key, item);
}
/**
* 判断hash表中是否有该项的值
*
* @param key 键 不能为null
* @param item 项 不能为null
* @return true 存在 false不存在
*/
public boolean hHasKey(String key, String item) {
return redisTemplate.opsForHash().hasKey(key, item);
}
/**
* hash递增 如果不存在,就会创建一个 并把新增后的值返回
*
* @param key 键
* @param item 项
* @param by 要增加几(大于0)
* @return
*/
public 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 double hdecr(String key, String item, double by) {
return redisTemplate.opsForHash().increment(key, item, -by);
}
//============================set=============================
/**
* 根据key获取Set中的所有值
*
* @param key 键
* @return
*/
public Set<Object> 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 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 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 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 long sGetSetSize(String key) {
try {
return redisTemplate.opsForSet().size(key);
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 移除值为value的
*
* @param key 键
* @param values 值 可以是多个
* @return 移除的个数
*/
public long setRemove(String key, Object... values) {
try {
Long count = redisTemplate.opsForSet().remove(key, values);
return count;
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
//===============================list=================================
/**
* 获取list缓存的内容
*
* @param key 键
* @param start 开始
* @param end 结束 0 到 -1代表所有值
* @return
*/
public List<Object> 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 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 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 值
* @return
*/
public 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 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 值
* @return
*/
public boolean lSet(String key, List<Object> 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 boolean lSet(String key, List<Object> 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 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
*
public 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;
}
}
}
@Service
public class LoginServiceImpl implements LoginService {
@Autowired
private UserDao userDao;
@Autowired
AssociatesBaseMapper associatesBaseMapper;
private JedisUtil jedisUtil = JedisUtil.getInstance();
private IdGenerator idGenerator = new IdGenerator();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
R r;
/**
* 随时都可以登录,但是只允许在线一个(最新的) 10分钟 连续登录失败3次自动锁定账号1小时
*
* @param phone
* @param pass
* @return
*/
@Override
public R login(String phone, String pass) {
new IdGenerator().nextId();
//1、校验用户名是否存在
User user = userDao.selectByPhone(phone);
if (user != null) {
//2、校验密码是否正常
if (Objects.equals(user.getPassword(), EncryptionUtil.RSAEnc(ProjectConfig.PASSRSAPRI, pass))) {
/**
* 登录成功
*/
LoginToken loginToken = new LoginToken();
loginToken.setPhone(phone);
loginToken.setUid(user.getUid());
loginToken.setId(idGenerator.nextId() + "");
/**
* 3、生成Token
*/
String token = JwtUtil.createJWT(loginToken.getId(), JSON.toJSONString(loginToken));
/**
* 4、存储到服务器
*/
//1、String 类型 user:phone token
jedisUtil.setnx(ProjectConfig.TOKENPHONE + phone, token);
//2、String 类型 token phone 校验token是否有效
jedisUtil.setnx(ProjectConfig.TOKENJWT + token, JSON.toJSONString(user));
//3、Zset 记录每个手机号下的所有的Token score:phone value:令牌
//5、将Token(原本是没有token //为原本实现方式可以直接获取到用户id)
String s = simpleDateFormat.format(new Date());
jedisUtil.lpush(com.totyu.zoworld.login.common.ProjectConfig.LOGINLOG + user.getPhone(), user.getUid().toString(), "1", s, "登录成功,令牌生成");
r = R.setOK("OK", token);
} else {
String s1 = simpleDateFormat.format(new Date());
jedisUtil.lpush(com.totyu.zoworld.login.common.ProjectConfig.LOGINLOG + user.getPhone(), user.getUid().toString(), "2", s1, "登录失败,密码不正确");
r = R.setERROR("密码不正确");
}
} else {
String s3 = simpleDateFormat.format(new Date());
jedisUtil.lpush(com.totyu.zoworld.login.common.ProjectConfig.LOGINLOG + user.getPhone(), user.getUid().toString(), "3", s3, "登录失败,账号有误");
r = R.setERROR("账号有误,请核对");
}
return r;
}
/**
* 用户名密码登录
* @param uname
* @param pass
* @return
*/
@Override
public R usernamelogin(String uname, String pass) {
//1、校验用户名是否存在
User user=userDao.selectByUname(uname);
if(user!=null){
//2、校验密码是否正常
if(Objects.equals(user.getPassword(), EncryptionUtil.RSAEnc(ProjectConfig.PASSRSAPRI,pass))){
/**
* 登录成功
*/
LoginToken loginToken = new LoginToken();
loginToken.setPhone(uname);
loginToken.setUid(user.getUid());
loginToken.setId(idGenerator.nextId()+"");
/**
* 3、生成Token
*/
String token = JwtUtil.createJWT(loginToken.getId(), JSON.toJSONString(loginToken));
/**
* 4、存储到服务器
*/
//1、String 类型 user:phone token
jedisUtil.setnx(ProjectConfig.TOKENPHONE + uname, token);
//2、String 类型 token phone 校验token是否有效
jedisUtil.setnx(ProjectConfig.TOKENJWT + token, JSON.toJSONString(user));
//3、Zset 记录每个手机号下的所有的Token score:phone value:令牌
//5、将Token(原本是没有token //为原本实现方式可以直接获取到用户id)
String s = simpleDateFormat.format(new Date());
jedisUtil.lpush(com.totyu.zoworld.login.common.ProjectConfig.LOGINLOG+user.getPhone(),user.getUid().toString(),"1",s,"登录成功,令牌生成");
//logDao.save(user.getUid(),"登录成功,令牌生成");
r= R.setOK("OK",token);
}else {
String s1 = simpleDateFormat.format(new Date());
jedisUtil.lpush(com.totyu.zoworld.login.common.ProjectConfig.LOGINLOG+user.getPhone(),user.getUid().toString(),"2",s1,"登录失败,密码不正确");
//logDao.save(user.getUid(),"登录失败,密码有误");
r= R.setERROR("密码不正确");
}
}else {
String s3 = simpleDateFormat.format(new Date());
jedisUtil.lpush(com.totyu.zoworld.login.common.ProjectConfig.LOGINLOG+user.getPhone(),user.getUid().toString(),"3",s3,"登录失败,账号有误");
//logDao.save(user.getUid(),"登录失败,账号有误");
r= R.setERROR("账号有误,请核对");
}
return r;
}
/**
* 根据openID进行插入数据
* @param user
* @return
*/
@Override
public R addByWx(User user) {
//如果查询到数据库没有这个openid
User wxuser = userDao.findOpenId(user.getOpenid());
if (wxuser==null){
long uid = new IdGenerator().nextId();
user.setUid(uid);
//插入一条新的数据
userDao.addByWx(user);
}else {//查到了
user.setUid(wxuser.getUid());//能查到uid
}
/**
* 登录成功
*/
LoginToken loginToken = new LoginToken();
loginToken.setPhone(user.getOpenid());
loginToken.setUid(user.getUid());
loginToken.setId(idGenerator.nextId()+"");
/**
* 3、生成Token
*/
String token = JwtUtil.createJWT(loginToken.getId(), JSON.toJSONString(loginToken));
/**
* 4、存储到服务器
*/
//1、String 类型 user:phone token
jedisUtil.setnx(ProjectConfig.TOKENPHONE + user.getOpenid(),token);
//2、String 类型 token phone 校验token是否有效
jedisUtil.setnx(ProjectConfig.TOKENJWT + token,JSON.toJSONString(user));
//3、Zset 记录每个手机号下的所有的Token score:phone value:令牌
//5、将Token(原本是没有token //为原本实现方式可以直接获取到用户id)
String s = simpleDateFormat.format(new Date());
jedisUtil.lpush(com.totyu.zoworld.login.common.ProjectConfig.LOGINLOG+user.getPhone(),user.getUid().toString(),"1",s,"登录成功,令牌生成");
//logDao.save(user.getUid(),"登录成功,令牌生成");
r= R.setOK("插入token成功,登录成功",token);
return r;
}
/**
* 解析token获取用户id,校验token是否正确
* @param token
* @return
*/
@Override
public R checkLogin(String token) {
//1、校验Token有效性
if(JwtUtil.checkJWT(token)){
//反解析 令牌 获取当初登录的手机号、用户id
LoginToken loginToken=JSON.parseObject(JwtUtil.parseJWT(token), LoginToken.class);
//获取当前手机号的令牌
String t = jedisUtil.get(ProjectConfig.TOKENPHONE + loginToken.getPhone());
//获得当前登录账户的id
Long tokenUid = loginToken.getUid();
//比对令牌
if(Objects.equals(t,token)) {
TokenInfoUtil.setTokenId(tokenUid);
long userId = TokenInfoUtil.getTokenId();
return R.setOK("有效", userId);
}else {
return R.setERROR("已经在其他地方登录了");
}
}else {
return R.setERROR("Token校验失败");
}
}
/**
* 退出登录
* @param token
* @return
*/
@Override
public R exitLogin(String token) {
//1、校验Token有效性
if(JwtUtil.checkJWT(token)){
jedisUtil.del(ProjectConfig.TOKENJWT + token);
//反解析 令牌 获取当初登录的手机号
LoginToken loginToken = JSON.parseObject(JwtUtil.parseJWT(token), LoginToken.class);
System.out.println("第一个token:" + loginToken);
//获取当前手机号的令牌
jedisUtil.del(ProjectConfig.TOKENPHONE+loginToken.getPhone());
return R.setOK("退出成功",null);
}else {
return R.setERROR("Token校验失败");
}
}
/**
* 根据uid修改当前用户密码
* @param oldpassword
* @param password
* @param uid
* @return
*/
@Override
public Result updatePassByUid(String oldpassword, String password, Long uid) {
if (StringUtils.isBlank(password)){
return ResultUtil.returnData(-1,"修改密码失败,密码格式错误");
}else {
//判断旧密码是否正确
String old = EncryptionUtil.RSAEnc(ProjectConfig.PASSRSAPRI, oldpassword);
String password1 = associatesBaseMapper.show(uid).getPassword();
if (!password1.equals(old)){
return ResultUtil.returnData(9002,"旧密码输入不正确");
}
String s = EncryptionUtil.RSAEnc(ProjectConfig.PASSRSAPRI, password);
userDao.updatePassByUid(s, uid);
return ResultUtil.returnData(0,"修改密码成功");
}
}
public class JwtUtil {
public static String createJWT(String id,String content){
//获取指定签名加密算法的枚举对象
SignatureAlgorithm algorithm= SignatureAlgorithm.HS256;
JwtBuilder builder=Jwts.builder();
builder.setId(id);
builder.setSubject(content); //sub
builder.setIssuedAt(new Date());//开始时间
builder.setExpiration(TimeUtil.getMinutes(ProjectConfig.JWTTIME));//失效时间
builder.signWith(algorithm,createKey());
return builder.compact();
}
/**
* 生成秘钥
* @return
*/
private static SecretKey createKey(){
byte[] dataKey=ProjectConfig.JWTKEY.getBytes();
SecretKey key=new SecretKeySpec(dataKey,0,dataKey.length,"AES");
return key;
}
//校验令牌是否合法
public static boolean checkJWT(String token){
SecretKey key=createKey();
try{
Claims claims = Jwts.parser().setSigningKey(key).parseClaimsJws(token).getBody();
return true;
}catch (Exception e){
e.printStackTrace();
return false;
}
}
/**
* 解析Token
* @param token
* @return
*/
public static String parseJWT(String token){
SecretKey key = createKey();
try{
Claims claims = Jwts.parser().setSigningKey(key).parseClaimsJws(token).getBody();
return claims.getSubject();
}catch (Exception e){
return null;
}
}
/**
* 更新失效时间
* @param token
* @return
*/
public static String updateJWT(String token){
SecretKey key=createKey();
try{
SignatureAlgorithm algorithm=SignatureAlgorithm.HS256;
Claims claims=Jwts.parser().setSigningKey(key).parseClaimsJws(token).getBody();
claims.setIssuedAt(new Date());
claims.setExpiration(TimeUtil.getMinutes(ProjectConfig.JWTTIME));
JwtBuilder builder=Jwts.builder();
builder.addClaims(claims);
builder.signWith(algorithm,key);
return builder.compact();
}catch (Exception e){
return null;
}
}
}
04-16
2183
![](https://csdnimg.cn/release/blogv2/dist/pc/img/readCountWhite.png)
09-12
“相关推荐”对你有帮助么?
-
非常没帮助
-
没帮助
-
一般
-
有帮助
-
非常有帮助
提交