redis学习

Redis

1.安装

 vi /etc/sysconfig/network-scripts/ifcfg-ens33  #修改网络

安装gcc依赖

yum install -y gcc tcl

cd redis-6.2.11
make && make install

cp redis.conf.bck redis.conf
#修改redis.conf
bind 0.0.0.0
daemonize yes
requirepass 123456

cd /usr/local/src/redis-6.2.11/src
redis-server /usr/local/src/redis-6.2.11/redis.conf

redis-cli -h 192.168.0.138 -p 6379 -a 123456

下载客户端

https://github.com/lework/RedisDesktopManager-Windows/releases

String类型常见命令

keys *
del age
EXISTS name
expire age 30
ttl age
incr age
incrby age 2
set score 10.1
INCRBYFLOAT score 0.5
setnx name lisi
setex  name 10 jack

2.redis使用

2.1常用的操作redis的客户端工具

jedis
Jedis 是 Redis 官方推荐的 Java 连接开发工具，jedis非线程安全。

但是可以通过JedisPool连接池去管理实例，在多线程情况下让每个线程有自己独立的jedis实例，可变为线程安全。

Lettuce
Lettuce 是基于 Netty框架(NIO)的事件驱动的通信，支持同步和异步调用的，可扩展的 redis client，多个线程可以共享一个 RedisConnection，线程安全。

SpringBoot2.0之后默认都是使用的Lettuce这个客户端连接Redis服务器。Lettuce 是一种可扩展的、线程安全的 Redis 高级客户端。

Redisson
Redisson 是一个在 Redis 的功能基础上实现的 Java 驻内存数据网格客户端。实现了分布式和可扩展的 Java 数据结构，提供很多分布式相关操作服务，例如分布式锁，分布式集合，可通过 Redis 支持延迟队列。

小结
Jedis 和 Lettuce 两者相比，Jedis 的性能比较差，其他方面并没有太明显的区别，所以如果你不需要使用 Redis 的高级功能的话，优先推荐使用 Lettuce。

相比于 Jedis、Lettuce 等基于 redis 命令封装的客户端，Redisson 提供的功能更加高端和抽象，逼格简单使用

2.2Jedis测试

<dependency>
      <groupId>redis.clients</groupId>
      <artifactId>jedis</artifactId>
      <version>3.7.0</version>
</dependency>

private Jedis jedis;

@BeforeEach
void setUp() {
    jedis = new Jedis("192.168.0.138", 6379);
    jedis.auth("123456");
    jedis.select(0);
}

@Test
void testString() {
    String result = jedis.set("name", "胡歌");
    System.out.println("result = " + result);
    String name = jedis.get("name");
    System.out.println(name);
}

@Test
void testHash(){
    jedis.hset("user:1","name","jack");
    jedis.hset("user:1","age","21");

    //获取
    Map<String, String> map = jedis.hgetAll("user:1");
    System.out.println(map);
}

@AfterEach
void tearDown() {
    if (jedis != null) jedis.close();
}

Jedis连接池

Jedis本身是线程不安全的，并且频繁的创建和销毁连接会有性能损耗，因此我们推荐大家使用Jedis连接池代替Jedis的连接方式。

通过JedisPool连接池去管理实例，在多线程情况下让每个线程有自己独立的jedis实例，可变为线程安全。

public class JedisConctionFactory {
    private static final JedisPool jedisPool;
    static {
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        //设置最大连接数
        poolConfig.setMaxTotal(8);
        //设置最大空闲连接数
        poolConfig.setMaxIdle(6);
        // 设置最小空闲连接数 （就是隔段时间后，一直没有连接，会销毁剩于至1）
        poolConfig.setMinIdle(1);
        poolConfig.setMaxWaitMillis(1000);
        jedisPool = new JedisPool(poolConfig,"192.168.0.138",6379,1000,"123456");
    }
    
    public static Jedis getJedis(){
        return jedisPool.getResource();
    }
}

@SpringBootTest
public class RedisApplicationTests {
    private Jedis jedis;

    @BeforeEach
    void setUp() {
//        jedis = new Jedis("192.168.0.138", 6379);
        jedis = JedisConctionFactory.getJedis();
        jedis.auth("123456");
        jedis.select(0);
    }

    @Test
    void testString() {
        String result = jedis.set("name", "胡歌");
        System.out.println("result = " + result);
        String name = jedis.get("name");
        System.out.println(name);
    }

    @Test
    void testHash(){
        jedis.hset("user:1","name","jack");
        jedis.hset("user:1","age","21");

        //获取
        Map<String, String> map = jedis.hgetAll("user:1");
        System.out.println(map);
    }

    @AfterEach
    void tearDown() {
        if (jedis != null) jedis.close();
    }
}

2.3SpringDataRedis

• 提供了对不同Redis客户端的整合(Lettuce和Jedis)
• RedisTemplate统一操作
• 支持发布订阅
• 支持哨兵和集群
• 支持基于Lettuce的响应式编程
• 支持基于JDK、JSON、字符串、Spring对象的数据序列化和反序列化（如原始的jedis客户端只是支持String)
• 支持基于Redis的JDKCollection实现

<!--        redis依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
<!--        连接池依赖-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>

spring:
  redis:
    host: 192.168.0.138
    port: 6379
    password: 123456
    jedis:
      pool:
        max-active: 8
        max-idle: 8
        min-idle: 0
        max-wait: 1000ms

String类型

不序列化 默认采用JDK序列化

@Resource
private RedisTemplate redisTemplate;

@Test
public void test1(){
    redisTemplate.opsForValue().set("name","虎哥");
    Object name = redisTemplate.opsForValue().get("name");
    System.out.println("name:" + name);
}

\xAC\xED\x00\x05t\x00\x06\xE8\x99\x8E\xE5\x93\xA5

序列化

@Configuration
public class redisConfig {

    @Bean
    public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory connectionFactory){

        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory);
        GenericJackson2JsonRedisSerializer jsonSerializer = new GenericJackson2JsonRedisSerializer();

        template.setKeySerializer(RedisSerializer.string());
        template.setHashKeySerializer(RedisSerializer.string());

        template.setValueSerializer(jsonSerializer);
        template.setHashValueSerializer(jsonSerializer);

        return template;
    }
}

@Resource
private RedisTemplate<String,Object> redisTemplate;
@Test
public void test2(){
    redisTemplate.opsForValue().set("user:100",new User("虎哥",21));
    User user = (User) redisTemplate.opsForValue().get("user:100");
    System.out.println("user:" + user);
}

查看redis数据库

{
  "@class": "com.cc.redis.pojo.User",
  "name": "虎哥",
  "age": 21
}

问题：多了 "@class": "com.cc.redis.pojo.User", 占用空间，优化方式：使用手动序列化

手动序列化不需要上面的序列化配置了

@Resource
private StringRedisTemplate stringRedisTemplate;

private static final ObjectMapper mapper = new ObjectMapper();

@Test
public void test2() throws Exception{
    User user = new User("虎哥", 21);
    String josn = mapper.writeValueAsString(user);
    stringRedisTemplate.opsForValue().set("user:200",josn);
    String jsonUser = stringRedisTemplate.opsForValue().get("user:200");
    User user1 = mapper.readValue(jsonUser, User.class);
    System.out.println("user:" + user);
}

@Test
public void test1(){
    stringRedisTemplate.opsForValue().set("name","虎哥");
    Object name = stringRedisTemplate.opsForValue().get("name");
    System.out.println("name:" + name);
}

查看数据库

{
  "name": "虎哥",
  "age": 21
}

Hash类型

@Test
public void test3(){
    stringRedisTemplate.opsForHash().put("user:400","name","虎哥");
    stringRedisTemplate.opsForHash().put("user:400","age","21");
    Map<Object, Object> entries = stringRedisTemplate.opsForHash().entries("user:400");
    System.out.println("entries:" + entries);
}