Redis整合

一、JAVA连接Redis

1、工程中引入redis依赖==>jedis

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

2、获取连接对象

3、操作redis数据库

public class redisTest {
    public static void main(String[] args) {
        // 获取连接对象
        Jedis jedis=new Jedis("192.168.88.3",8081);

        // 操作redis数据库---String类型
        jedis.set("k1","vi");
        jedis.set("k2","v2");
        jedis.setnx("k1","v3");
        jedis.mset("k3","v4","k4","v5");
        List<String> mget = jedis.mget("k1", "k2");
        System.out.println(mget);

        jedis.flushAll();

        // 操作Hash类型

        Map<String,String> map=new HashMap<>();
        map.put("name","法外狂徒张三");
        map.put("age","68");
        map.put("sex","男");
        jedis.hset("k1",map);

        Map<String,String> k1=jedis.hgetAll("k1");
        System.out.println(k1);

        Set<String> keys=jedis.keys("*");
        System.out.println(keys);
    }
}


---------------运行结果--------------
[vi, v2]
{name=法外狂徒张三, age=68, sex=男}
[k1]

二、SpringBoot连接Redis

依赖-==》启动依赖==>自动装配==》自动读取配置

1、引入依赖

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

2、配置连接对象，代码测试

@SpringBootTest
class DemoApplicationTests {
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    @Test
    void contextLoads() {
        ValueOperations<String,String> ops= stringRedisTemplate.opsForValue();
        ops.set("k1","springboot-v1");
        System.out.println(ops.get("k1"));
        Boolean aboolean=ops.setIfAbsent("k1","你真厉害");//setnx
        System.out.println(aboolean);
        Map<String,String> map=new HashMap<>();
        map.put("name","花木兰");
        map.put("sex","女");
        map.put("name","程咬金");
        ops.multiSet(map);
        System.out.println(stringRedisTemplate.keys("*"));
    }

}

------运行结果--------

springboot-v1
false
[k2, name, sex, k1]

setIfAbsent 的用法类似于setnx;案例中k1已存在所以在给声明k1时就会返回false，而如果是不存在的k值，则会返回true。

StringRedisTemplate 为封装类，可以操作key,value操作的是Sting的字符串类型

那能不能引对象？经过测试，发现是不能的。这里需要将对象转化成json字符串的形式。引json的jar包，能不能在不用json就可以操作对象呢？

用RedisTemplate封装类，存放的key和value可以是Object类型。那么他的jkey和value默认采用的序列化方式为JDK序列化方式，需要我们指定key和value的序列化方式。

代码如下：

@SpringBootTest
class DemoApplicationTests2 {
    @Autowired
    private RedisTemplate redisTemplate;
    @Test
    void contextLoads() {
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(new StringRedisSerializer());
        HashOperations hash= redisTemplate.opsForHash();
        hash.put("u","n","张三");
        hash.put("u","a","李四");
        System.out.println(hash);
    }

    @Test
    void contextLoad(){
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        ValueOperations valueOperations= redisTemplate.opsForValue();
        valueOperations.set("k4",new Usr("王五",25,"郑州"));
        Object k4=valueOperations.get("k4");
        System.out.println(k4);
        Object k=valueOperations.get("k");
        System.out.println(k);
    }

}

---运行结果-------

Usr(name=王五, age=25, add=郑州)
null

----引Jar包----------
    <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
        </dependency>

        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
        </dependency>

        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-annotations</artifactId>
        </dependency>

三、SpringBoot连接哨兵模式

四、SpringBoot使用Redis作为缓存

缓存能够有效地加速应用的读写速度，同时也可以降低后端负载，对日常应用的开发至关重要。

4.1 缓存的优点和缺点

优点：
1、加速读写：因为缓存通常都是全内存的（例如Redis、Memcache），而存储层通常读写性能不够强悍（例如MySQL），通过缓存的使用可以有效地加速读写，优化用户体验。
2、降低后端负载：帮助后端减少访问量和复杂计算（例如很复杂的SQL语句），在很大程度降低了后端的负载。

缺点：

1、数据不一致性：缓存层和存储层的数据存在着一定时间窗口的不一致性，时间窗口跟更新策略有关。
2、代码维护成本：加入缓存后，需要同时处理缓存层和存储层的逻辑，增大了开发者维护代码的成本。
3、运维成本：以Redis Cluster为例，加入后无形中增加了运维成本。

4.2 什么时候用缓存？

查询频率高、修改频率底、数据安全性要求较低。

4.3 如何使用？

package com.dhy.springbootcache.service;

import com.dhy.springbootcache.entry.User;
import com.dhy.springbootcache.mapper.UserMapper;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

@Service
public class UserService {
    @Resource
    private UserMapper userMapper;

    @Resource
    private RedisTemplate redisTemplate;

    public User findById(Long empno){
        // 设置key和value的序列化，防止乱码
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());

        ValueOperations valueOperations= redisTemplate.opsForValue();
        // 1、先从Redis中获取数据
        Object obj=valueOperations.get("user::findById::"+empno);
        //  2、如果存在，则直接返回结果
        if (obj!=null){
            return (User) obj;
        }
        // 3、如果不存在，则查询数据，并把查询的结果放到redis中
        User user=userMapper.selectById(empno);
        if (user!=null){
            valueOperations.set("user::findById::"+empno,user);
        }
        return user;
    }
}