redis的搭建及使用

  redis是一个高性能的key-value数据库，他的读取的速度是110000次/s，写的速度是81000次/s。

Redis的搭建

  docker是最近最为流行的容器化技术，使用docker搭建redis是最为方便快捷的。

1.拉取redis镜像。

如果对docker有一定了解的人都知道，docker构建容器是基于镜像的，镜像可以从各大镜像仓库拉取，也能够自己构建镜像，redis的镜像在dockerhub中有，直接拉取redis镜像即可。

docker pull redis:5.0.6

拉取镜像后，用命令docker images可以查看镜像

可以看到镜像名称为redis，版本为5.0.6

2.构建容器

docker run -p 6379:6379 -v /data/redis/data:/data -d redis:5.0.6 redis-server --appendonly yes

-p 6379:6379:端口映射

-v /data/redis/data:/data:容器重启后，容器中的数据会丢失，所以需要挂载外部数据卷，从而使数据能够长久存储。

3.查看redis容器

docker ps可以查看正在运行的容器

docker exec -it 49bc13590551(容器id) /bin/sh 可以进入容器内部

进入容器后，使用redis-cli可以使用redis的基本语法，如存放一条数据，并通过key值获得value

springboot集成redis

  springboot集成redis，只需导入redis依赖包即可。

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

properties配置：

spring.redis.host=localhost  //redis地址
spring.redis.port=6379    //redis端口号
spring.redis.jedis.pool.max-wait=30000   //连接池最大阻塞等待时间
spring.redis.jedis.pool.max-active=100   //连接池最大连接数
spring.redis.jedis.pool.max-idle=20    //连接池的最大空闲连接
spring.redis.jedis.pool.min-idle=0    //连接池的最小空闲连接
spring.redis.timeout=3000    //连接超时

redis配置类

@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {

    @Bean
    public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory factory){
        RedisTemplate<String,Object> template = new RedisTemplate<>();
        // 配置连接工厂
        template.setConnectionFactory(factory);
        //序列化和反序列化redis的value值
        Jackson2JsonRedisSerializer jsonRedisSerializer=new Jackson2JsonRedisSerializer(Object.class);

        ObjectMapper om=new ObjectMapper();
        // 指定要序列化的域，field,get和set,以及修饰符的范围,ANY是都有包括private和public
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        //指定序列化输入的类型，类必须是非final修饰的
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jsonRedisSerializer.setObjectMapper(om);

        //值采用json序列化
        template.setValueSerializer(jsonRedisSerializer);
        //使用StringRedisSerializer来序列化和反序列化redis的key值
        template.setKeySerializer(new StringRedisSerializer());

        //设置hash key和value序列化模式
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(jsonRedisSerializer);
        template.afterPropertiesSet();

        return template;

    }

    /**
     * 对hash类型的数据操作
     * @param redisTemplate
     * @return
     */
    @Bean
    public HashOperations<String,String,Object> hashOperations(RedisTemplate<String,Object> redisTemplate){
        return redisTemplate.opsForHash();
    }

    /**
     * 对redis字符串类型数据操作
     * @param redisTemplate
     * @return
     */
    @Bean
    public ValueOperations<String,Object> valueOperations(RedisTemplate<String,Object> redisTemplate){
        return redisTemplate.opsForValue();
    }

    /**
     * 对链表类型的数据操作
     * @param redisTemplate
     * @return
     */
    @Bean
    public ListOperations<String,Object> listOperations(RedisTemplate<String,Object> redisTemplate){
        return redisTemplate.opsForList();
    }

    /**
     * 对无须集合类型的数据操作
     * @param redisTemplate
     * @return
     */
    @Bean
    public SetOperations<String,Object> setOperations(RedisTemplate<String,Object> redisTemplate){
        return redisTemplate.opsForSet();
    }

    /**
     * 对有序集合类型的数据操作
     * @param redisTemplate
     * @return
     */
    public ZSetOperations<String,Object> zSetOperations(RedisTemplate<String,Object> redisTemplate){
        return redisTemplate.opsForZSet();
    }
}

 

redis工具类

@Component
public class RedisUtil {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    public RedisUtil(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }


    /**
     * 普通缓存获取
     *
     * @param key
     * @return
     */
    public Object get(String key) {
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }

    /**
     * 普通缓存放入
     *
     * @param key
     * @param value
     * @return
     */
    public boolean set(String key, Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

}

 

redisController

 

@RequestMapping(value = "/redis")
@RestController
public class RedisController {

//    @Value("${redis.expireTime:}")
    private static final int ExpireTime=60;

    @Autowired
    private RedisUtil redisUtil;

    /**
     * 存放数据
     * @param key
     * @param value
     * @return
     */
    @RequestMapping(value = "/set",method = RequestMethod.GET)
    public boolean redisset(@RequestParam(value = "key") String key,@RequestParam(value = "value")String value){
        return redisUtil.set(key,value);
    }

    /**
     * 根据key获取value
     * @param key
     * @return
     */
    @RequestMapping(value = "/get",method = RequestMethod.GET)
    public Object redisGet(@RequestParam(value = "key") String key){
        return  redisUtil.get(key);
    }

}

 

最后运行此项目，通过postman调用/redis/set接口即可。