Redis(持续更新）

1、安装

安装太麻烦了直接使用宝塔的一键部署

密码是bt_redis

2、jedis

1、引入依赖

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

 2、建立连接

private Jedis jedis;
    @BeforeEach
    void setUp(){
        //1建立连接
        jedis=new Jedis("IP",37690);
        //2设置密码
        jedis.auth("bt_redis");
        //3选择库
        jedis.select(0);
    }

3、测试String

@Test
    void testString() {
        //存入结果
        String result = jedis.set("name", "高晗");
        System.out.println(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> stringStringMap = jedis.hgetAll("user:1");
        System.out.println(stringStringMap);
    }

4、释放资源

//释放连接
    void tearDown(){
        if (jedis!=null)
            jedis.close();
    }

多线程时使用连接池

1、创建连接池工具

public class jedisConnectionFactory {
    private static  JedisPool jedispool;

    static {
        //配置连接池
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        jedisPoolConfig.setMaxTotal(8);//最大连接数
        jedisPoolConfig.setMaxIdle(8);//最大空闲连接
        jedisPoolConfig.setMinIdle(0);//最小空闲连接
        jedisPoolConfig.setMaxWaitMillis(100);//等待时间
        //创建连接池对象
        JedisPool jedisPool = new JedisPool(
                jedisPoolConfig,
                "IP",
                37690,
                1000,
                "bt_redis");


    }
    public static Jedis getJedis(){
        return jedispool.getResource();
    }

}

 修改建立连接代码

@BeforeEach
    void setUp(){
        //1建立连接
        jedis= jedisConnectionFactory.getJedis();//从池子中获取连接
        //2设置密码
        jedis.auth("bt_redis");
        //3选择库
        jedis.select(0);
    }

释放资源时底层会自动判断是否使用连接池，如果使用则归还连接池 

3、SpringDataRedis

RedisTemplate入门

依赖与springboot整合

 <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>
<!--        底层都通过commons完成底层线程池-->
        
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

配置

spring:
  data:
    redis:
      host: IP
      port: 37690
      password: bt_redis
      lettuce:
        pool:
          max-active: 8
          max-idle: 8
          min-idle: 0
          max-wait: 100

3注入RedisTemplate并使用

@Autowired
    private RedisTemplate redisTemplate;

    @Test
    void testString() {
        //底层自动序列化 所以object类型
        //写入一条数据
        redisTemplate.opsForValue().set("name","姜赫");
        Object name = redisTemplate.opsForValue().get("name");
        System.out.println(name);
    }

使用上述创建时，传入的是object而不是string所以会进行序列化所以当去底层使用原本object的文本时，会得到不同与String内容，可读性差(key,value)都序列化 序列化后增加了长度增加了内存容量的所以要改变序列化方式。 

两者序列化方案

RedisSerializer

自定义序列号方式：

@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory connectionFactory){
        //创建redisTemplate对象
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        //设置连接工厂
        template.setConnectionFactory(connectionFactory);
        //创建JSON序列化工具，来实现对值的序列化
        GenericJackson2JsonRedisSerializer jsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
        //设置Key的序列化
        template.setKeySerializer(RedisSerializer.string());//spring专门处理字符的序列化
        template.setHashKeySerializer(RedisSerializer.string());
        //设置Value序列化
        template.setValueSerializer(jsonRedisSerializer);
        template.setHashValueSerializer(jsonRedisSerializer);
        //返回
        return template;
    }

}

测试

//一般情况
@Test
    void testString() {
        //底层自动序列化 所以object类型
        //写入一条数据
        redisTemplate.opsForValue().set("name","姜赫");
        Object name = redisTemplate.opsForValue().get("name");
        System.out.println(name);
    }
//如果是对象的话

    @Test
    void testSaveUser() {
        //写入数据
        redisTemplate.opsForValue().set("user:100",new User("姜赫",19));
        //获取数据
        User o = (User) redisTemplate.opsForValue().get("user:100");
        System.out.println(o);
    }

 ok

StringRedisTemplate

要实现自动序列化和反序列化必须要这样如果不知道class就没办法自动反转

所以如果想节省就不能实现自动的序列化和反序列化

所以我们不会使用JSON的序列化器

用KEY的序列化器来使用

如果必需存对象，我们就必须手动序列化

 StringRedisTemplate默认key value都是sting

    @Test
    void testString() {
        //底层自动序列化 所以object类型
        //写入一条数据
        stringRedisTemplate.opsForValue().set("name","米浴");
        Object name = stringRedisTemplate.opsForValue().get("name");
        System.out.println(name);
    }

    private static  final ObjectMapper mapper=new ObjectMapper();
    @Test
    void testSaveUser() throws JsonProcessingException {
        //创建对象
        User user = new User("米浴", 6);
        //手动序列化
        String json = mapper.writeValueAsString(user);
        //写入数据
        stringRedisTemplate.opsForValue().set("user:200",json);
        //获取数据
        String jsonUser=  stringRedisTemplate.opsForValue().get("user:200");
        //手动反序列化
        User user1=mapper.readValue(jsonUser,User.class);
        System.out.println("user1="+user1);
    }

 Hash(Api更接近java编程习惯）

@Test
    void testHash(){
        stringRedisTemplate.opsForHash().put("user:400","name","东海帝皇");
        stringRedisTemplate.opsForHash().put("user:400","age","3");

        Map<Object, Object> entries = stringRedisTemplate.opsForHash().entries("user:400");
        System.out.println(entries);
    }