2021-06-29

2023-12-30 22:49:28

学习目标：

1.java连接redis。
2.springboot整合redis。
3.springboot使用redis作为缓存。
4.redis常见的面试题。

1.java连接redis。

1.1 引入redis的依赖------>jedis

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

1.2 java代码操作redis

package com.test;

import redis.clients.jedis.Jedis;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class TestRedis {
public static void main(String[] args) {
//1.获取连接对象
Jedis jedis=new Jedis("192.168.223.128",6379); //默认连接的为localhost 端口号为6379
//2.操作redis数据库 -----String类型
jedis.set("k1","v1");
jedis.set("k2","2");
jedis.setnx("k1","v3");
jedis.mset("k3","v3","k4","v4");
List<String> mget = jedis.mget("k1", "k2");
System.out.println(mget);
jedis.flushAll();

//3.操作hash类型
Map<String,String> map=new HashMap<>();
map.put("name","闫克起");
map.put("age","17");
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);
}
}

2.springboot整合redis。

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

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

2.2 代码测试--------StringRedistemplate

@Autowired
private StringRedisTemplate stringRedisTemplate;//存放的数据格式为string类型
@Test
void contextLoads() {
// //使用ValueOperations -----操作的为字符串类型
// ValueOperations<String, String> ops = stringRedisTemplate.opsForValue();
// ops.set("k1","springboot-v1");
// System.out.println(ops.get("k1"));
// Boolean aBoolean = ops.setIfAbsent("k2", "王沛他很听话");//setnx
// System.out.println(aBoolean);
// Map<String,String> map=new HashMap<>();
// map.put("name","张三");
// map.put("age","18");
// map.put("name","李四");
// ops.multiSet(map);
// System.out.println(stringRedisTemplate.keys("*"));
// //操作hash类型 HashOperations<String, Object, Object>
HashOperations<String, Object, Object> hash = stringRedisTemplate.opsForHash();
hash.put("k1","name","赵露露");
hash.put("k1","age","18");
Object o = hash.get("k1", "name");
System.out.println(hash.keys("k1"));
System.out.println(hash.values("k1"));
System.out.println(o);
System.out.println(hash.entries("k1"));
}

2.3 代码测试----------RedisTemplate

它的key和value可以存放Object类型,那么它的key和value默认采用的序列化方式为JDK序列化方式。一般我们需要为key和value指定序列化方式。

redisTemplate.setKeySerializer(new StringRedisSerializer());
redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
redisTemplate.setHashKeySerializer(new StringRedisSerializer());
redisTemplate.setHashValueSerializer(new StringRedisSerializer());

@Autowired
private RedisTemplate redisTemplate;

@Test
void contextLoadsHash() {
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","25");
}

@Test
void contextLoads() {
//因为RedisTemplate默认会为key和value进行序列按照JDK的序列化方式进行的，
//再实际开发过程中不用默认的序列化方式。空间少而且不用为实体类实现序列化接口
redisTemplate.setKeySerializer(new StringRedisSerializer());
redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
ValueOperations valueOperations = redisTemplate.opsForValue();
//可以指定key的序列化方式
valueOperations.set("k4",new User("王五",25,"郑州"));
Object k4 = valueOperations.get("k4");
System.out.println(k4);
// Object k = valueOperations.get("k");
// System.out.println(k);

}

3. 连接集群

哨兵

集群：

4. springboot使用redis作为缓存。

作用：为了减少对数据库的访问频率。从而提高项目的性能。

什么样的数据适合放入缓存中。

1. 查询频率高
2. 修改频率低
3. 数据安全行要求低的

package com.yyh.redis1.sercice;

import com.yyh.redis1.entity.User;
import com.yyh.redis1.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;
import java.util.concurrent.TimeUnit;

@Service
public class UserService2 {
    @Resource
    private UserMapper userMapper;
    @Resource
    private RedisTemplate redisTemplate;

    public User selectId(Long id){
        //1.序列化
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        //2.存放key value
        ValueOperations valueOperations = redisTemplate.opsForValue();
        //3.先获取redis缓存里数据
        Object o=valueOperations.get("user::selectid::"+id);
        //4.如果存在，把缓存里的数据返回
        if(o!=null){
            return (User) o;
        }
        //5.否则查询数据库 并把查询结果放入redis缓存里 然后把查询结果返回
        User user= userMapper.selectById(id);
        if(user!=null){
            valueOperations.set("user::selectid::"+id,user,30, TimeUnit.MINUTES);

        }
        return user;
    }
    public void delete(Long id){
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        ValueOperations valueOperations = redisTemplate.opsForValue();
        //1.先删除redis里的数据
        redisTemplate.delete("user::findById::"+id);
        //2.再删除数据库里的数据
        userMapper.deleteById(id);
    }
    public void update(User user){
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        ValueOperations valueOperations = redisTemplate.opsForValue();
        //1.先修改数据库里的数据
        userMapper.updateById(user);
        //2.再修改缓存里的数据
        valueOperations.set("user::findById::"+user.getId(),user);
    }
    public void insert(User user){
        userMapper.insert(user);
    }
}

缓存注解：我只需要再相应方法上加入相应的缓存注解则可以完成缓存的功能

1.加入缓存的配置类

package com.yyh.redis1.config;

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.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.time.Duration;

@Configuration
public class MyConfig {
    //比如验证码
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        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);
        template.setConnectionFactory(factory);
        //key序列化方式
        template.setKeySerializer(redisSerializer);
        //value序列化
        template.setValueSerializer(jackson2JsonRedisSerializer);
        //value hashmap序列化
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        return template;
    }

    @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)) //缓存过期10分钟 ---- 业务需求。
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))//设置key的序列化方式
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer)) //设置value的序列化
                .disableCachingNullValues();
                 RedisCacheManager cacheManager = RedisCacheManager.builder(factory)
                .cacheDefaults(config)
                .build();
        return cacheManager;
    }

}

2.再相应的方法上加入缓存注解

package com.yyh.redis1.sercice;

import com.yyh.redis1.entity.User;
import com.yyh.redis1.mapper.UserMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
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 org.springframework.web.bind.annotation.GetMapping;

import javax.annotation.Resource;
import java.util.concurrent.TimeUnit;
@Service
public class UserService {
    @Resource
    private UserMapper userMapper;
    @Resource
    private RedisTemplate redisTemplate;

    @Cacheable(cacheNames = "user::selectById",key="#id")
    public User selectById(Long id){
        User user= userMapper.selectById(id);
        return user;
    }
    @CacheEvict(cacheNames = "user::delete",key = "#id")
    public void delete(Long id){

        userMapper.deleteById(id);
    }
    @CachePut(cacheNames = "user::update",key = "#user.id")
    public User update(User user){

        userMapper.updateById(user);
        return user;
        //2.再修改缓存里的数据

    }
    public void insert(User user){
        userMapper.insert(user);
    }
}

3.启动缓存注解

5. redis缓存穿透

1. 缓存没有该数据并且数据库中也没有该数据，这是如果有大量的恶意请求来访问这种数据时，这些请求穿过缓存，到达数据库。

1. 如果数据库中不存在该数据时，往缓存中存放一个空对象。该对象什么也不做。（缓存中会存在大量的冗余数据。设置很短的过期时间）。

2. 使用布隆过滤器。理解为一个容器
把数据库中的所有数据id放入到布隆过滤器中

6. 分布式锁

synchronized: 可以加载方法上，方法体内，类上。自动获取锁，自动是否释放锁。不会造成死锁。

lock: 方法体内。手动获取锁手动是否锁如果出现异常而没有手动释放锁则造成死锁。

使用redis中的setNx判断是否获取锁资源使用del释放锁资源

码农公寓