redis入门教程

redis

启动redis：

cd /usr/local/bin

redis-server /etc/redis.conf

检查是否启动：

redis-cli

启动mysql命令

service mysql start

下载redis：

下载: wget http://download.redis.io/releases/redis-5.0.5.tar.gz

解压：tar -zxvf redis-5.0.5.tar.gz -C /opt/install

1、安装redis

1.1、安装gcc

yum install gcc 

1.2、编译并安装

cd redis-5.0.5
make MALLOC=libc 

1.3、安装

将redis-5.0.5/src目录下的二进制文件安装到指定的目录中
cd src
make install PREFIX=/usr/local/redis 

1.4、配置环境变量

vi /etc/profile
export REDIS_HOME=/usr/local/redis
  export PATH=$PATH:$REDIS_HOME/bin
 
 
 刷新配置文件
 source /etc/profile 

1.5、修改配置文件

默认的配置文件是/opt/install/redis-5.0.5/redis.conf 
1 设置后台启动 将 daemonize no 改成 daemonize yes 
2 下面一行必须改成 bind 0.0.0.0 或注释，否则只能在本机访问 bind 127.0.0.1 
3 把protected yes 该为：protected no 
4 并拷贝到/usr/local/redis/bin目录中一份 

1.6、配置后台启动

将redis.conf配置文件中的daemonize属性修改为yes：（默认为 daemonize no）
daemonize yes 

2、Redis启动

2.2、启动客户端

> 指定配置文件启动Redis

> redis-server /usr/local/redis/bin/redis.conf

> 提示：redis启动之后可以通过ps -ef | grep redis查看服务是否启动

> 如果没有netstat命令：需要通过yum install net-tools 安装网络工具包,然后使用该命令就有了

启动客户端：redis-cli -h IP地址 -p 端口号

启动客户端： redis-cli -h IP地址 -p 端口号

提示：1.不指定 -h -p的情况下,默认连接客户端所在机子的redis服务器

2.参数作用：

-h：

指定访问的redis服务器的ip地址

-p：

指定访问的redis服务器的port端口

-a:

指定登录密码

--raw:

解决中文乱码问题

3.redis默认使用的端口号为: 6379

关闭客户端：

quit|exit:都是退出客户端

shutdown: 在客户端关闭服务器端.

2、数据类型

官方给出的性能：

50个并发环境下

GET: 110000/s:读的速度每秒11万次

SET: 81000/s: 写的速度每秒8万次

2.1、key的操作

Redis 在实际使用过程中更多的用作缓存，然而缓存的数据一般都是要设置生存时间的，即到期后数据销毁。

EXPIRE key seconds        //设置key的生存时间（单位：秒）key在多少秒之后会自动删除
TTL key                   //查看key剩余的生存时间
                            //返回正数为key剩余生存时间
                            //返回-1,表示永久不过期
                            //返回-2,表示不存在的key
PERSIST key               //清除生存时间
PEXPIRE key milliseconds  //生存时间设置单位：毫秒 
  

其他key的操作

keys *   查看当前库所有key
exists key 判断某个key是否存在
type key  查看你的key是什么类型
del key  删除指定的key数据 

库的切换与操作

select 命令切换数据库
dbsize 查看当前数据库的key的数量
flushdb 清空当前库
flushall 清空所有库
move somekey 1 将某个key的值移到1号库，库下标从0开始 

2.2、String

set key value  赋值
get key        取值 

设置/获取多个键值
mset k1 v1 k2 v2 k3 v3   同时赋多个键值
mget k1 k2 k3            同时获取多个值 

取值并赋值
getset key value 

删除
del key 

数值增减
incr key   让当前键值递增 （如果value的值不能转换为整形，该操作会执行失败，并返回相应错误信息）
incrby key incrment  给某个key对应的值增加指定的幅度，其中incrment为增量
 
decr key   使该key对应的值减一
decrby key decrement  使该key对应的值减指定的值，其中decrement为减量

拼凑字符串
append key value   如果该key存在，则在原有的value后追加该value，字符串拼接，如果该key不存在，
则重新创建一个key/value

3、Hash类型

赋值操作
hset key  filed1 value1 一个key对应多个filed/value

同时赋值多个字段
hmset key  filed1 value1 filed2 value2   一次可以设置多个字段

hsetnx key field value  当字段不存在时才能赋值，否则不执行任何操作

取值
hget key field  一次只能获取一个字段值

hmget key field1 field2  一次能获取多个字段值

hgetall key   获取所有字段和值 

hkeys key  获取所有字段

hvals key  获取所有value

删除
hdel key field1 field2   删除一个或多个字段，返回值是被删除字段的个数 

增加数字
hincrby key field increment   给某个key的某个field对应的值增加指定的数值
hash类型没有减的语法，但是可以通过将增量设置为负数来进行减操作 

判断指定key中的filed是否存在，存在返回1，否则返回0
hexists key field 

获取key所包含的field的数量
hlen key  

4、List类型

List类似java中的列表类型，里面的数据：有序，可重复，而且list是双向链表

向列表两端增加元素

lpush key value [value...]    向列表左边（头部）增加元素

rpush key value [value...]    向列表右边（尾部）增加元素

查看列表
lrange key start stop     获取列表中的某一个片段，将返回start,stop 之间的所有元素（包含两端的元素）
 索引从0开始，索引可以是负数，如：“-1“ 代表最后边的一个元素，”-2”代表倒数第二个
 
从列表两端淡出元素
lpop key   将列表元素从左边弹出一个元素
rpop key   将列表元素从右边弹出一个元素

获取列表中的元素个数
llen key 
 

5、Set类型

set集合中不允许出现重复的元素

添加/删除元素
sadd key member [member ...]  向指定的集合中添加数据

srem key member [member ...]  删除集合set中的元素
 
获取集合中的所有元素
smembers key  

判断元素是否在集合中
sismember key member   存在返回1，否则返回0  

集合差集运算
sdiff key1 key2    返回key1与key2不同的元素

集合求交集运算
sinter key1 key2   返回key1与key2相同的元素

集合求并集运算
sunion key1 key2   返回key1与key2所有的元素，但是重复的不显示

获取set成员数量
scard key 

随机返回set中的一个成员
srandmember key
 

6、Zset类型

zset和set的区别在于zset中的每一个成员都会有一个分数（score）与之关联，Redis正是通过分数来为集合中的成员进行从小到大的排序，成员是唯一的，但是分数可以重复

增加元素
zadd key score member [score member ...]

获取元素的数值
zscore key member 

删除元素
zrem key member [member ...] 

获取集合中元素的个数
zset key 

按顺序排列获取元素列表
 zrange key start stop [withscores]
  
按照元素数值从大到小的顺序返回索引从start到stop之间的所有元素
zrevrange key start stop [withscores] 

获取集合中分数数值在一定范围之间的元素
zrangebyscore key  start stop 

给集合中的某个元素增加分值
zincrby key 分值 value  为value值增加分值，例如：zincrby zset 19 tfxing
 

3、springboot整合redis

3.1、pom依赖

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.tfxing</groupId>
  <artifactId>springboot_redis</artifactId>
  <version>1.0-SNAPSHOT</version>

  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.0.1.RELEASE</version>
  </parent>

  <dependencies>
    <!-- 配置使用redis启动器 -->
     <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency> 
      
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-test</artifactId>
      <scope>test</scope>
    </dependency>
  </dependencies>
</project>

3.2、yaml配置

spring:
  datasource:
    username: root
    password: 123456
    url: jdbc:mysql://127.0.0.1:3306/springboot?useUnicode=true&characterEncoding=utf8
    driver: com.mysql.jdbc.Driver
  redis:
    port: 6379
    host: 192.168.43.128
mybatis:
  type-aliases-package: com.tfxing.mapper
  mapper-locations: classpath:com/tfxing/mapper/*.xml
server:
  port: 18081

3.3、编写主启动类

package com.tfxing;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class,args);
    }
}

3.4、编写配置类

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.lang.reflect.Method;
import java.time.Duration;

@EnableCaching
@Configuration
public class RedisConfig {

    @Bean
    public KeyGenerator wiselyKeyGenerator() {
        return new KeyGenerator() {
            @Override
            public Object generate(Object target, Method method, Object... params) {
                StringBuilder sb = new StringBuilder();
                sb.append(target.getClass().getName());
                sb.append(method.getName());
                for (Object obj : params) {
                    sb.append(obj.toString());
                }
                return sb.toString();
            }
        };
    }

    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);

        //序列号key value
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);

        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }

    @Bean
    public CacheManager cacheManager(RedisConnectionFactory factory) {
        RedisSerializer<String> redisSerializer = new StringRedisSerializer();
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);

        //解决查询缓存转换异常的问题
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);

        // 配置序列化（解决乱码的问题）,过期时间600秒
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofSeconds(600))
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer))
                .disableCachingNullValues();

        RedisCacheManager cacheManager = RedisCacheManager.builder(factory)
                .cacheDefaults(config)
                .build();
        return cacheManager;
    }
}

3.5、使用redis实现效果

package com.tfxing.service.impl;

import com.tfxing.bean.User;
import com.tfxing.mapper.UserMapper;
import com.tfxing.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UserServiceImpl implements UserService {
    @Autowired
    private UserMapper userMapper;
    @Autowired
    private RedisTemplate redisTemplate;
    @Override
    public List<User> list() {
        String allKey = "allUser";
        List<User> lists = (List<User>) redisTemplate.boundValueOps(allKey).get();
        if(lists != null){
            System.out.println("inner redis success!!");
            return lists;
        }
        lists = userMapper.list();
        redisTemplate.boundValueOps(allKey).set(lists);
        return lists;
    }
}

缓存穿透/缓存击穿/缓存雪崩

缓存击穿：是指某一个热点数据由于某些原因失效，导致mysql数据库在短时间内请求爆发

缓存穿透：通过请求一个redis中不存在的key，从而使请求到达mysql

缓存雪崩：缓存中的大量key因为某种原因失效，（大量key的过期时间一致，大量key同时失效）导致无法提供服务，服务器崩溃