spring boot+redis实现token机制

      token的意思，即"令牌"，有这个令牌就可以进行访问，就具有一定的权限，在传统的应用中，一般是存储于session，但在当下很多分布式微服务的应用中，session就显得力不从心了。当用户第一次登陆之后，服务端生成一个token并返回给客户端，客户端每次以后带着这个token访问即可，无需用户名和密码。token可以防止表单重复提交和身份验证等用途

流程:

       1、用户登录之后，先校验用户名和密码

       2、用户名和密码通过之后生成token，以zset加分数存储redis，方便后期排行进行删除不活跃的用户

       3、将token返回前端，后面的每次请求携带token

       4、验证token，通过则返回相应的数据，删除token，再重新生成一个token返回给前端存储在本地。不通过，重新登录

也要进行限制token无限增加，比如登录之后生成token之后，无限登录，导致redis中的token无限增加以及相关用户信息修改之后要进行重新生成token

application.yml:看redis配置就好，这里是单机

server: 
  port: 8081
  # 下面是配置undertow作为服务器的参数
  undertow: 
    # 设置IO线程数, 它主要执行非阻塞的任务,它们会负责多个连接, 默认设置每个CPU核心一个线程
    io-threads: 4
    # 阻塞任务线程池, 当执行类似servlet请求阻塞操作, undertow会从这个线程池中取得线程,它的值设置取决于系统的负载
    worker-threads: 20
    # 以下的配置会影响buffer,这些buffer会用于服务器连接的IO操作,有点类似netty的池化内存管理
    # 每块buffer的空间大小,越小的空间被利用越充分
    buffer-size: 1024
    # 是否分配的直接内存
    direct-buffers: true
    
#启用shutdown
#endpoints: 
 # shutdown: 
   # enable: true
#禁用密码验证
#endpoints: 
  #shutdown: 
    #sensitive: false
#linux关闭的脚本
#curl -X POST host:port/shutdown

#开启shutdown的安全验证
#endpoints: 
  #shutdown: 
    #sensitive: true
    
#验证用户名和密码
#security: 
  #user: 
    #name: admin
    #password: admin
    
#角色
#management: 
  #address: 127.0.0.1
  #port: 8081
  #security: 
    #role: SUPERUSER


spring: 
  datasource: 
    type: com.alibaba.druid.pool.DruidDataSource
    driverClassName: com.mysql.cj.jdbc.Driver
    driver-class-name: com.mysql.cj.jdbc.Driver
    platform: mysql
    url: jdbc:mysql://xxx.xxx.xxx.xx:5306/miniprogram?useUnicode=true&characterEncoding=UTF-8&allowMultiQueries=true&useSSL=false
    username: root
    password: admin
# ELASTICSEARCH (ElasticsearchProperties)
# Elasticsearch cluster name.
#  data:
#    elasticsearch:
#      cluster-name: elasticsearch
#      cluster-nodes: 192.168.13.111:9300,192.168.13.222:9300
#      repositories:
#        enabled: true
  redis: 
#    database: 1
    host: 127.0.0.1
    port: 6379
    password: 
    timeout: 10000
    lettuce:
          pool:
            minIdle: 0
            maxIdle: 10
            maxWait: 10000
            max-active: 10
#    cluster:
#      nodes:
#        - 192.168.91.5:9001
#        - 192.168.91.5:9002
#        - 192.168.91.5:9003
#        - 192.168.91.5:9004
#        - 192.168.91.5:9005
#        - 192.168.91.5:9006
  activemq: 
    queueName: mvp.queue
    topicName: mvp.topic
    #账号密码
    user: user
    password: user
    #URL of the ActiveMQ broker.
    broker-url: tcp://localhost:61616
    in-memory: false
    #必须使用连接池
    pool: 
      #启用连接池
      enabled: true
      #连接池最大连接数
      max-connections: 5
      #空闲的连接过期时间，默认为30秒
      idle-timeout: 30s
    
mybatis: 
  typeAliasesPackage: com.pinyu.miniprogram.mysql.entity
  mapper-locations: classpath:mapper/**/*Mapper.xml
mapper:
  mappers: com.pinyu.miniprogram.mysql.mappers.BaseMapper
  identity: mysql
  
  
#logging.config: 
#  classpath: test/log4j2_test.xml

自定义token注解，只要在controller方法贴上此注解表示此请求是必须要进行身份验证

package com.pinyu.miniprogram.global.ann;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ ElementType.METHOD, ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RequireToken {

}

登录:

@RequestMapping("/login")
	public String login(@RequestBody Map logMap) throws Exception {
		String memberName = logMap.get("memberName");
		String pwd = logMap.get("pwd");
		MemberEntity m = new MemberEntity();
		m.setMemberName(memberName);
		pwd = MD5Utils.convertMD5(MD5Utils.md5(pwd));
		m.setPwd(pwd);
		List list = service.select(m);
		if (list != null && list.size() > 0) {
			MemberEntity member = list.get(0);
			token.delToken(member);//清除之前redis有的token信息
			String memberToken = token.saveToken(member);//重新生成token
			return JsonMsg.OK(memberToken);
		} else {
			return JsonMsg.OK("用户名或密码错误");
		}
	}

Token:

package com.pinyu.miniprogram.utils;

import java.security.NoSuchAlgorithmException;
import java.security.spec.InvalidKeySpecException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.Random;

import org.apache.commons.codec.digest.DigestUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.pinyu.miniprogram.config.redis.RedisUtils;
import com.pinyu.miniprogram.mysql.entity.member.MemberEntity;
import com.pinyu.miniprogram.utils.date.DateUtils;
import com.pinyu.miniprogram.utils.result.Code;
import com.pinyu.miniprogram.utils.result.JsonMsg;
import com.pinyu.miniprogram.utils.rsa.RSAUtils;

@Component
public class Token {
	
	private final static String TOKEN_ERROR = "error";

	public final static Integer TOKEN_ERROR_CODE = -1;
	
	public static final String TOKEN_VALIDA_NULL="token为空";
    public static final String TOKEN_VALIDA_ERROR="token验证错误";
    public static final String TOKEN_VALIDA_FAIL="token验证失败";

	public static String Error(String msg) {
		Map map = new HashMap();
		map.put("code", TOKEN_ERROR_CODE);
		map.put("msg", msg);
		return JSONObject.toJSONStringWithDateFormat(map, DateUtils.YYYY_MM_DD_HH_MM_SS,
				SerializerFeature.WriteMapNullValue);
	}
	
	public static final String MEMBER_TOKEN = "MEMBER_TOKEN";

	@Autowired
	private RedisUtils redisUtils;

	// 生成token前的格式为token:id:时间:六位随机数
	public String generateToken(Long id) throws Exception{
        StringBuilder tokenBuilder = new StringBuilder();
        //生成未加密的token:
        tokenBuilder.append("token:")
        					.append(id).append(":")
        					.append(new SimpleDateFormat("yyyyMMddHHmmssSSS").format(new Date())+":")
        					.append(new Random().nextInt((999999 - 111111 + 1)) + 111111);
        String token=(RSAUtils.privateEncrypt(tokenBuilder.toString(), RSAUtils.getPrivateKey(RSAUtils.privateKey)));
        System.out.println("token=>" + token.toString());
        return token.toString();
    }

	public String saveToken(MemberEntity member) throws Exception {
		String token = generateToken(member.getId());
		redisUtils.zsetAdd(MEMBER_TOKEN, token, Double.valueOf(System.currentTimeMillis()));// 设置zset用于线程根据分数定时清理不活跃用户
		redisUtils.set(token, member, 60 * 60 * 24 * 30L);// 存储相关用户信息(权限等信息)
		redisUtils.set(String.valueOf(member.getId()), token);// 用于重新登录，但之前token还存在的情况,通过id获取相应的token来进行之前的token清理
		return token;
	}

	public void delToken(MemberEntity member) {
		Object object = redisUtils.get(String.valueOf(member.getId()));
		if (object != null) {
			String token = (String) object;
			redisUtils.del(token);// 移除token以及相对应的权限信息
			redisUtils.del(String.valueOf(member.getId()));// 移除token
			redisUtils.remove(MEMBER_TOKEN, token);// 移除zset排行的token，避免一个用户重复排行
		}
	}
}

RedisUtils:

package com.pinyu.miniprogram.config.redis;

import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

/**
 * @author ypp 创建时间：2018年11月19日 下午4:58:04
 * @Description: TODO(redis缓存工具类)
 */
@Component
public class RedisUtils {

	@Autowired
	@Qualifier("redisTemplate")
	private RedisTemplate redisTemplate;

	// =============================common============================
	/**
	 * 指定缓存失效时间
	 * @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));
			}
		}
	}

	// ============================String=============================
	/**
	 * 普通缓存获取
	 * @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 键
	 * @param by 要增加几(大于0)
	 * @return
	 */
	public 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 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 hmget(String key) {
		return redisTemplate.opsForHash().entries(key);
	}

	/**
	 * HashSet
	 * @param key 键
	 * @param map 对应多个键值
	 * @return true 成功 false 失败
	 */
	public 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 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 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