redis的安装配置及使用

都说redis的很好用，一直没机会用到，今天上午正好闲来无事，学了下redis的用法，在这里简单的做个记录
第一步，巧妇难为无米之炊，你得先安装redis才能使用不是。我没有在服务器上安装，而是在Windows上安装的。这是Windows的安装包
链接：https://pan.baidu.com/s/191rEq6ZohLO0kxjk3G4hcQ
提取码：ci1a
下载好之后，直接解压
再解压目录输入cmd进入控制台，输入redis-server redis.windows.conf启动redis
如下图所示则证明启动成功

我还安装了一个redis远程连接工具RedisDesktopManager，这个连接工具有很多种，安不安也没什么，你也可以在控制台用redis的自带的那个redis-cli.exe来操作和查看redis。
若安装工具后，配置连接如下

连接成功
接下来学习如何使用redis.
首先你要在项目中导入依赖

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

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.47</version>
        </dependency>

配置redis

spring:
  redis:
    host: localhost
    password:
    timeout: 1000ms
    database: 0

然后再项目里建一个config文件夹，里面放一个配置类

package com.ldp.config;

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.*;
import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * Redis配置
 * @author ldp
 *
 */
@Configuration
public class RedisConfig {
    @Autowired
    private RedisConnectionFactory factory;

    @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 JdkSerializationRedisSerializer());
        redisTemplate.setConnectionFactory(factory);
        return redisTemplate;
    }

    @Bean
    public HashOperations<String, String, Object> hashOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForHash();
    }

    @Bean
    public ValueOperations<String, String> valueOperations(RedisTemplate<String, String> redisTemplate) {
        return redisTemplate.opsForValue();
    }

    @Bean
    public ListOperations<String, Object> listOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForList();
    }

    @Bean
    public SetOperations<String, Object> setOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForSet();
    }

    @Bean
    public ZSetOperations<String, Object> zSetOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForZSet();
    }
}

然后再建一个utils文件夹，把这个redis工具类放进去

package com.ldp.utils;

import com.alibaba.fastjson.JSON;

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

import javax.annotation.Resource;
import java.util.List;
import java.util.concurrent.TimeUnit;

/**
 *  Redis工具类
 * @author ldp
 *
 */
@Component
public class RedisUtils {
    @Autowired
    private RedisTemplate<String, ?> redisTemplate;
    @Resource(name="redisTemplate")
    private ValueOperations<String, String> valueOperations;
    @Resource(name="redisTemplate")
    private HashOperations<String, String, Object> hashOperations;
    @Resource(name="redisTemplate")
    private ListOperations<String, Object> listOperations;
    @Resource(name="redisTemplate")
    private SetOperations<String, Object> setOperations;
    @Resource(name="redisTemplate")
    private ZSetOperations<String, Object> zSetOperations;
    /**  默认过期时长，单位：秒 */
    public final static long DEFAULT_EXPIRE = 60 * 60 * 24;
    /**  不设置过期时长 */
    public final static long NOT_EXPIRE = -1;

    public void set(String key, Object value, long expire){
        valueOperations.set(key, toJson(value));
        if(expire != NOT_EXPIRE){
            redisTemplate.expire(key, expire, TimeUnit.SECONDS);
        }
    }

    public void set(String key, Object value){
        set(key, value, DEFAULT_EXPIRE);
    }
    /**
     * 存储List
     * @param key code
     * @param list 数据集
     * @param expire 过期时间
     */
    public void setList(String key, List<?> list,long expire){
    	listOperations.rightPush(key, list);
        if(expire != NOT_EXPIRE){
            redisTemplate.expire(key, expire, TimeUnit.SECONDS);
        }
    
    }
    /**
     * 存储List
     * @param key code
     * @param list 数据集
     * @param expire 过期时间
     */
    public void setList(String key, String list,long expire){
    	listOperations.rightPush(key, list);
        if(expire != NOT_EXPIRE){
            redisTemplate.expire(key, expire, TimeUnit.SECONDS);
        }
    
    }
    /**
     * 存储List
     * @param key code
     * @param list 数据集
     */
    public  void setList(String key, List<?> list){
    	setList(key, list,NOT_EXPIRE);
    }
    
    /**
     * 存储List
     * @param key code
     * @param list 数据集
     */
    public  void setList(String key, String list){
    	setList(key, list,NOT_EXPIRE);
    }
    
    

    public  List<Object> getList(String key) {
    	return   listOperations.range(key, 0, -1);
    }

    
    public Object getHash(String key,String hashKey){
    	return hashOperations.get(key, hashKey);
    }
    /**
     * 批量获取
     * @param key  key 
     * @param keys 集合key
     * @return
     */
    public List<Object> getList(String key,List<String> keys){
    	return hashOperations.multiGet(key, keys);
    }
    
    public  <T> T get(String key, Class<T> clazz, long expire) {
        String value = valueOperations.get(key);
        if(expire != NOT_EXPIRE){
            redisTemplate.expire(key, expire, TimeUnit.SECONDS);
        }
        return value == null ? null : fromJson(value, clazz);
    }

    public  <T> T get(String key, Class<T> clazz) {
        return get(key, clazz, NOT_EXPIRE);
    }

    public String get(String key, long expire) {
        String value = valueOperations.get(key);
        if(expire != NOT_EXPIRE){
            redisTemplate.expire(key, expire, TimeUnit.SECONDS);
        }
        return value;
    }

    public String get(String key) {
        return get(key, NOT_EXPIRE);
    }

    public void delete(String key) {
        redisTemplate.delete(key);
    }
    /**
     * 删除list数组
     * @param key
     */
    public void deleteList(String key) {
    	listOperations.rightPop(key);
    }

    /**
     * Object转成JSON数据
     */
    private String toJson(Object object){
        if(object instanceof Integer || object instanceof Long || object instanceof Float ||
                object instanceof Double || object instanceof Boolean || object instanceof String){
            return String.valueOf(object);
        }
        return JSON.toJSONString(object);
    }

    /**
     * JSON数据，转成Object
     */
    private <T> T fromJson(String json, Class<T> clazz){
        return JSON.parseObject(json, clazz);
    }
}

接下来就是使用了，由于这个工具类使用了@Component，说明他交给spring管理了，所以在使用的时候需要注入。

/**
 * Created By Ivan_ldp@163.com on 2020/3/5 18:50
 */
@RestController
public class HelloController {

    @Autowired
    RedisUtils redisUtils;
    @GetMapping("/provider/hello")
    public String sayHello(){
        redisUtils.set("sex","男");
        System.out.println(redisUtils.get("name"));
        System.out.println("服务提供者");
        return "全体起立";
    }
}

测试一下

看看redis中

redis的简单使用就是这样，希望大家都能学会啦。