redis在实际项目中的应用 -- 登录成功通过redisUtil.setData存取token

首先保证 redis服务处于启动状态，redis安装和启动步骤参考博客连接：
redis安装和启动步骤:

然后使用Redis Desktop Manager 工具连接服务器的redis：

上图中，数据库中的 key的数量 为 1

一、在各个服务的配置文件中配置redis

如果redis设置了密码，别忘记再加上password :

二、Redis工具类 和controller中接收登录请求的方法

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

import java.util.concurrent.TimeUnit;

@Component
public class RedisUtil {
    /**
     * REDIS_ACTIVE_TIME : redis数据存活时间 - 20分钟
     */
    private static final int REDIS_ACTIVE_TIME = 20 * 60;

    /**
     * Redis 操作器
     */

    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 设置数据
     *
     * @return true:添加成功;false:添加失败，该值已经存在或其他错误等
     */
    public synchronized boolean setData(String key, Object object) {
        if(getData(key) != null){
            return false;
        }

        redisTemplate.opsForValue().set(key, object, REDIS_ACTIVE_TIME, TimeUnit.SECONDS);
        return true;
    }

    /**
     * 返回指定数据
     * @param key 被查找的数据值
     * @return 返回的被查找的值
     */
    public synchronized Object getData(String key) {
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }

    /**
     * 更新缓存时间
     * @param key 被更新的键值
     * @return true:更新成功;false:更新失败 键值不存在或者已经过期
     */
    public boolean resetActiveTime(String key){
        if(getData(key) == null){
            return false;
        }

        redisTemplate.expire(key, REDIS_ACTIVE_TIME, TimeUnit.SECONDS);

        return true;
    }

    /**
     * 覆盖数据
     * @param key 被覆盖的数据key
     * @param object 新数据值
     * @return 是否成功
     */
    public boolean setOverride(String key, Object object){
        redisTemplate.opsForValue().set(key, object, REDIS_ACTIVE_TIME, TimeUnit.SECONDS);
        return true;
    }

    /**
     * 删除Key 的值
     * @param key 被删除的key
     * @return 是否成功
     */
    public boolean delKey(String key){
        if(getData(key) == null){
            return false;
        }

        redisTemplate.delete(key);

        return true;
    }
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * @author :
 * @ClassName: RedisConfig
 * @Description:
 * @date : 2019/4/25
 */
@Configuration
public class RedisConfig {

    @Autowired
    private RedisConnectionFactory redisConnectionFactory;

    @Bean
    public RedisTemplate<String, Object> redisTemplate(){
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new StringRedisSerializer());
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        return redisTemplate;
    }
}

/**
 * @author : 
 * @ClassName: LoginInterceptor 登陆拦截器
 * @Description:
 * @date : 2019/4/11 2019/4/26
 */
@Deprecated
public class LoginInterceptor{
    /**
     * 生成Token
     *
     * @param userId 用户ID
     * @return 生成的Token
     */
    public static String createUserToken(String userId) {
        Date date = new Date();

        return String.valueOf((userId + date.getTime()).hashCode());
    }
}

Controller接收登录请求:

@ResponseBody
    @PostMapping("userLogin")
    public AppResponse doLogin(@RequestBody(required = false) Map<String, String> params, HttpSession session) throws UnsupportedEncodingException {
        if(params == null || params.size() != 2){
            return AppResponse.bizError("无效请求参数");
        }

        String userAccount = "userAccount";
        String userPwd = "userPwd";

        if(params.containsKey(userAccount)){
            userAccount = params.get(userAccount);
        }else {
            return AppResponse.bizError("无效请求参数");
        }

        if(params.containsKey(userPwd)){
            userPwd = params.get(userPwd);
        }else {
            return AppResponse.bizError("无效请求参数");
        }

        System.out.println(userAccount + userPwd);

        UserInfo userInfo = userService.getUserByAccount(userAccount);

        System.out.println(userInfo);
        if(userInfo == null){
            return AppResponse.bizError("失败");
        }

        if(userInfo.getUserPwd().equals(CreateMD5.getMd5(userPwd))){
            String userId = userAccount;
            String userToken = LoginInterceptor.createUserToken(userId);

            redisUtil.setData(userToken, userId);

            userInfo.setToken(userToken);
            return AppResponse.success("成功", userInfo);
        }else {
            return AppResponse.bizError("失败");
        }
    }

三、存、取token演示：

1.postman发出请求：

2.Controller处理请求 ：

存token：

请求成功， 生成token:

3.再次查看Redis Desktop Manager，果然多了一个键值对：

获取token（键）对应的值，即为登录用户的userAccount --> admin

4.再对 取token进行测试：
随便访问后台的一个需要验证token的方法：

/**@Author:
     * @Description：获取所有分类
     * @Date: 2019/4/27
     * @Param：tokenBackend
     */
    @ApiOperation(value = "获取所有分类")
    @ResponseBody
    @GetMapping("/getCategory")
    public AppResponse listCategory(String tokenBackend) throws Exception {
        String userId=(String)redisUtil.getData(tokenBackend);
        if(userId !=null || !userId.equals("")){
            try {

                Tree tree = categoryService.listCategory();
                return AppResponse.success("查询成功", tree.getChildren());
            } catch (Exception e) {

                throw new Exception("获取分类失败，请联系管理员!");
            }
        }else{
            return AppResponse.noPermission("您无权限访问此方法,请登录!");
        }
    }

postman发出请求（注意，这里的参数tokenBackend一定要使用刚才登录生成的token，否则此方法不会被允许访问的）：

后台处理请求：

成功获取到之前存的那个token