springboot整合redis

1.redis简单介绍

什么是redis

 Redis是用c语言开发的一个开源的高性能键值对（key-value数据库），它通过提供多种键值数据类型来适应不同的场景下的存储需求，目前Redis支持的键值对数据类型如下：

字符串数据类型
散列数据类型
列表数据类型
集合类型
有序集合类型

2.redis应用场景

缓存（数据查询、短链接、新闻内容、商品内容等等）（用的最多）
聊天室在线聊天列表
任务队列（秒杀、抢购）
应用排行榜
网站访问统计
数据过期处理
分布式集群架构中的session分离

3.安装redis,请自行查找资料进行安装，这边就不做介绍了

4.maven依赖

<!-- 整合redis -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

5.在application.yml中添加redis配置

  redis:
    host: ${REDIS_HOST:127.0.0.1}
    port: ${REDIS_PORT:6379}
    password: ${REDIS_PASSWORD:root}

6.封装RedisTemplate的RedisOperator 类

package com.yankuang.equipment.web.util;

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

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

/**
 * 使用redisTemplate的操作实现类
 */
@Component
public class RedisOperator {
	
//	@Autowired
//    private RedisTemplate<String, Object> redisTemplate;
	
	@Autowired
	private StringRedisTemplate redisTemplate;
	
	// Key（键），简单的key-value操作

	/**
	 * 实现命令：TTL key，以秒为单位，返回给定 key的剩余生存时间(TTL, time to live)。
	 * 
	 * @param key
	 * @return
	 */
	public long ttl(String key) {
		return redisTemplate.getExpire(key);
	}
	
	/**
	 * 实现命令：expire 设置过期时间，单位秒
	 * 
	 * @param key
	 * @return
	 */
	public void expire(String key, long timeout) {
		redisTemplate.expire(key, timeout, TimeUnit.SECONDS);
	}
	
	/**
	 * 实现命令：INCR key，增加key一次
	 * 
	 * @param key
	 * @return
	 */
	public long incr(String key, long delta) {
		return redisTemplate.opsForValue().increment(key, delta);
	}

	/**
	 * 实现命令：KEYS pattern，查找所有符合给定模式 pattern的 key
	 */
	public Set<String> keys(String pattern) {
		return redisTemplate.keys(pattern);
	}

	/**
	 * 实现命令：DEL key，删除一个key
	 * 
	 * @param key
	 */
	public void del(String key) {
		redisTemplate.delete(key);
	}

	// String（字符串）

	/**
	 * 实现命令：SET key value，设置一个key-value（将字符串值 value关联到 key）
	 * 
	 * @param key
	 * @param value
	 */
	public void set(String key, String value) {
		redisTemplate.opsForValue().set(key, value);
	}

	/**
	 * 实现命令：SET key value EX seconds，设置key-value和超时时间（秒）
	 * 
	 * @param key
	 * @param value
	 * @param timeout
	 *            （以秒为单位）
	 */
	public void set(String key, String value, long timeout) {
		redisTemplate.opsForValue().set(key, value, timeout, TimeUnit.SECONDS);
	}

	/**
	 * 实现命令：GET key，返回 key所关联的字符串值。
	 * 
	 * @param key
	 * @return value
	 */
	public String get(String key) {
		return (String)redisTemplate.opsForValue().get(key);
	}

	// Hash（哈希表）

	/**
	 * 实现命令：HSET key field value，将哈希表 key中的域 field的值设为 value
	 * 
	 * @param key
	 * @param field
	 * @param value
	 */
	public void hset(String key, String field, Object value) {
		redisTemplate.opsForHash().put(key, field, value);
	}

	/**
	 * 实现命令：HGET key field，返回哈希表 key中给定域 field的值
	 * 
	 * @param key
	 * @param field
	 * @return
	 */
	public String hget(String key, String field) {
		return (String) redisTemplate.opsForHash().get(key, field);
	}

	/**
	 * 实现命令：HDEL key field [field ...]，删除哈希表 key 中的一个或多个指定域，不存在的域将被忽略。
	 * 
	 * @param key
	 * @param fields
	 */
	public void hdel(String key, Object... fields) {
		redisTemplate.opsForHash().delete(key, fields);
	}

	/**
	 * 实现命令：HGETALL key，返回哈希表 key中，所有的域和值。
	 * 
	 * @param key
	 * @return
	 */
	public Map<Object, Object> hgetall(String key) {
		return redisTemplate.opsForHash().entries(key);
	}

	// List（列表）

	/**
	 * 实现命令：LPUSH key value，将一个值 value插入到列表 key的表头
	 * 
	 * @param key
	 * @param value
	 * @return 执行 LPUSH命令后，列表的长度。
	 */
	public long lpush(String key, String value) {
		return redisTemplate.opsForList().leftPush(key, value);
	}

	/**
	 * 实现命令：LPOP key，移除并返回列表 key的头元素。
	 * 
	 * @param key
	 * @return 列表key的头元素。
	 */
	public String lpop(String key) {
		return (String)redisTemplate.opsForList().leftPop(key);
	}

	/**
	 * 实现命令：RPUSH key value，将一个值 value插入到列表 key的表尾(最右边)。
	 * 
	 * @param key
	 * @param value
	 * @return 执行 LPUSH命令后，列表的长度。
	 */
	public long rpush(String key, String value) {
		return redisTemplate.opsForList().rightPush(key, value);
	}

}

7.将数据存入redis

package com.kcx.ability.web.controller;

import com.kcx.ability.api.model.User;
import com.kcx.ability.web.config.YmlConfig;
import com.kcx.ability.web.consumer.LoginConsumer;
import com.kcx.ability.web.utils.CodeUtil;
import com.kcx.ability.web.utils.JsonUtil;
import com.kcx.ability.web.utils.RedisUtil;
import com.kcx.ability.web.vo.CommonResponse;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import java.io.UnsupportedEncodingException;
import java.util.Base64;

/**
 * @author 14011
 */
@CrossOrigin(maxAge = 3600)
@RestController
@RequestMapping("v1/login/")
public class LoginController {

    public static final Logger log = Logger.getLogger(UserController.class);

    @Autowired
    RedisUtil redis;

    @Autowired
    YmlConfig ymlConfig;

    @Autowired
    LoginConsumer loginConsumer;

    /**
     * 用户退出登录.
     */
    @PostMapping(value = "out/")
    public CommonResponse loginOut(HttpServletRequest request) {
        String token = request.getHeader("token");
        redis.del(token);
        return CommonResponse.build(200, "您已经成功退出登录", null);
    }

    /**
     * 用户登录.
     *
     * @param user
     * @return
     */
    @PostMapping(value = "in/")
    public CommonResponse login(@RequestBody User user) {
        if (StringUtils.isEmpty(user)) {
            return CommonResponse.errorMsg("参数不能为空");
        }
        String account = user.getAccount();
        if (StringUtils.isEmpty(account)) {
            return CommonResponse.errorMsg("account不能为空");
        }
        String pwd = user.getPwd();
        if (StringUtils.isEmpty(pwd)) {
            return CommonResponse.errorMsg("密码不能为空");
        }
        // todo 测完删掉
        log.info("--------- 用户登录信息:" + account + ":" + pwd);
        // 查询数据库用户信息密码
        User loginUser = loginConsumer.selectByAccount(account);
        if (StringUtils.isEmpty(loginUser)) {
            return CommonResponse.errorTokenMsg("账号不存在");
        }
        int status = loginUser.getStatus();
        if (2 == status) {
            return CommonResponse.errorTokenMsg("账号已经被停用");
        }
        if (!pwd.equals(loginUser.getPwd())) {
            return CommonResponse.errorTokenMsg("密码错误");
        }
        // todo 测完删掉
        log.info("根据用户名查询的用户信息" + loginUser.toString());

//        final Base64.Decoder decoder = Base64.getDecoder();
        // redis中存放的key和登录验证的accessToken
        String accessToken = "";
        accessToken = CodeUtil.getCode();
        loginUser.setAccessToken(accessToken);
        // 获取用户详细信息
        User userVo = loginConsumer.getUserVo(loginUser,user.getProjectCode());

        // 存放redis,暂时2小时
        String timeOut = ymlConfig.getTimeOut();
        redis.set(accessToken, JsonUtil.objectToJson(userVo), Long.valueOf(timeOut));

        // 用户信息base64处理
        final Base64.Encoder encoder = Base64.getEncoder();
        String encodedResult = "";
        try {
            // 转字节
            final byte[] textByte = JsonUtil.objectToJson(userVo).getBytes("UTF-8");
            // 加密
            encodedResult = encoder.encodeToString(textByte);
            log.info(encodedResult);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }

        // 返回加密用户信息包含token
        return CommonResponse.ok(encodedResult);
    }

}

8.获取redis中的数据

package com.yankuang.equipment.web.util;

import com.yankuang.equipment.common.util.JsonUtils;
import com.yankuang.equipment.web.dto.UserDTO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;

@Component
public class UserFromRedis {

    @Autowired
    RedisOperator redis;

    public UserDTO findByToken() {
        HttpServletRequest request =
                ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        String token = request.getHeader("token");
        if (StringUtils.isEmpty(token)) {
            return null;
        }
        String userRedis = (String) redis.get(token);
        if (StringUtils.isEmpty(userRedis)) {
            return null;
        }

        UserDTO userFromRedis = JsonUtils.jsonToPojo(userRedis, UserDTO.class);

        return userFromRedis;
    }

}