Redis面试：击穿、穿透、雪崩、分布式锁、API

public String get(key) {
      String value = redis.get(key);
      if (value == null) { //代表缓存值过期
          //设置3min的超时，防止del操作失败的时候，下次缓存过期一直不能load db
      if (redis.setnx(key_mutex, 1, 3 * 60) == 1) {  //代表设置成功
               value = db.get(key);
                      redis.set(key, value, expire_secs);
                      redis.del(key_mutex);
              } else {  //这个时候代表同时候的其他线程已经load db并回设到缓存了，这时候重试获取缓存值即可
                      sleep(50);
                      get(key);  //重试
              }
          } else {
              return value;      
          }
 }

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>3.5.2</version>
    <type>jar</type>
    <scope>compile</scope>
</dependency>

Jedis jedis = new Jedis("localhost");
jedis.set("foo", "bar");
String value = jedis.get("foo");

<dependency>
  <groupId>io.lettuce</groupId>
  <artifactId>lettuce-core</artifactId>
  <version>x.y.z</version>
</dependency>

StatefulRedisConnection<String, String> connection = client.connect();
RedisStringAsyncCommands<String, String> async = connection.async();  # 异步方式
RedisFuture<String> set = async.set("key", "value")
RedisFuture<String> get = async.get("key")

async.awaitAll(set, get) == true

set.get() == "OK"
get.get() == "value"

@Configuration
class AppConfig {

  @Bean
  public LettuceConnectionFactory redisConnectionFactory() {

    return new LettuceConnectionFactory(new RedisStandaloneConfiguration("server", 6379));
  }
}

@Bean
public RedisConnectionFactory lettuceConnectionFactory() {
  RedisSentinelConfiguration sentinelConfig = new RedisSentinelConfiguration()
  .master("mymaster")
  .sentinel("127.0.0.1", 26379)
  .sentinel("127.0.0.1", 26380);
  return new LettuceConnectionFactory(sentinelConfig);
}

@Configuration
class AppConfig {

  @Bean
  public JedisConnectionFactory redisConnectionFactory() {
    return new JedisConnectionFactory();
  }
}

@Configuration
class RedisConfiguration {

  @Bean
  public JedisConnectionFactory redisConnectionFactory() {

    RedisStandaloneConfiguration config = new RedisStandaloneConfiguration("server", 6379);
    return new JedisConnectionFactory(config);
  }
}

 /**
 * Jedis
 */
@Bean
public RedisConnectionFactory jedisConnectionFactory() {
  RedisSentinelConfiguration sentinelConfig = new RedisSentinelConfiguration()
  .master("mymaster")
  .sentinel("127.0.0.1", 26379)
  .sentinel("127.0.0.1", 26380);
  return new JedisConnectionFactory(sentinelConfig);
}

public class Example {

  // inject the actual template
  @Autowired
  private RedisTemplate<String, String> template;

  // inject the template as ListOperations
  @Resource(name="redisTemplate")
  private ListOperations<String, String> listOps;

  public void addLink(String userId, URL url) {
    listOps.leftPush(userId, url.toExternalForm());
  }
}

@Component
public class MyBean {

    private StringRedisTemplate template;

    @Autowired
    public MyBean(StringRedisTemplate template) {
        this.template = template;
    }

    // ...

}

package cn.shifpeng.architecturelearning;

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

@SpringBootApplication
public class ArchitectureLearningApplication {

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

public class ArchitectureLearningApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext ctx = SpringApplication.run(ArchitectureLearningApplication.class, args);
        TestRedis redis = ctx.getBean(TestRedis.class);  //下面通过@Component，这里就会找到这个类
    }
}

package cn.shifpeng.architecturelearning;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

@Component  //@Component注解会把这个类扔到容器中，然后在上面的代码中获取到
public class TestRedis {
  //这里写一个注入,这里面redis会有一个start，start会把Redis所有的连接和对象准备好，注入到RedisTemplate中，。然后下面就可以使用它了
    @Autowired 
    RedisTemplate redisTemplate; 
}

@Component
public class TestRedis {
    @Autowired
    RedisTemplate redisTemplate;

    public void testRedis() {
        redisTemplate.opsForValue().set("k1", "hello world");
        System.out.println(redisTemplate.opsForValue().get("k1"));
    }
}

package cn.shifpeng.architecturelearning;

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

@SpringBootApplication
public class ArchitectureLearningApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext ctx = SpringApplication.run(ArchitectureLearningApplication.class, args);
        TestRedis redis = ctx.getBean(TestRedis.class);
        redis.testRedis(); //调用方法
    }
}

@Component
public class TestRedis {
    @Autowired
    RedisTemplate redisTemplate;

    @Autowired
    StringRedisTemplate stringRedisTemplate;

    public void testRedis() {
        stringRedisTemplate.opsForValue().set("k1", "hello world");
        System.out.println(redisTemplate.opsForValue().get("k1"));
    }
}

@Component
public class TestRedis {
    @Autowired
    RedisTemplate redisTemplate;
//
//    @Autowired
//    StringRedisTemplate stringRedisTemplate;

    public void testRedis() {
//        stringRedisTemplate.opsForValue().set("k1", "hello world");
//        System.out.println(redisTemplate.opsForValue().get("k1"));
        RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
      // 所有直接在redis中使用的命令，都可以在这里使用
        connection.set("Hello".getBytes(StandardCharsets.UTF_8), "world".getBytes(StandardCharsets.UTF_8));
        System.out.println(new String(connection.get("Hello".getBytes(StandardCharsets.UTF_8))));
    }
}

@Configuration
public class MyTemplate {

    /**
     * 
     * @param factory
     * @return
     */
    @Bean
    public StringRedisTemplate getTemplate(RedisConnectionFactory factory) {
        StringRedisTemplate stringRedisTemplate = new StringRedisTemplate(factory);
        stringRedisTemplate.setHashValueSerializer(new Jackson2JsonRedisSerializer<Object>(Object.class));
        return stringRedisTemplate;
    }
}

package cn.shifpeng.architecturelearning;

import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.hash.Jackson2HashMapper;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.stereotype.Component;

import java.nio.charset.StandardCharsets;
import java.time.Period;
import java.util.Map;

@Component
public class TestRedis {
    @Autowired
    RedisTemplate redisTemplate;
    //
    @Autowired
    @Qualifier("getTemplate")
    StringRedisTemplate stringRedisTemplate;

    @Autowired
    ObjectMapper objectMapper;//需要引入spring-boot-starter-json的maven包

    public void testRedis() {

        Person p = new Person();
        p.setAge(22);
        p.setName("zhangsan");

      //因为value种存在整形，导致类型不匹配，所以需要序列化
       //stringRedisTemplate.setHashValueSerializer(new Jackson2JsonRedisSerializer<Object>(Object.class));
        Jackson2HashMapper jackson2HashMapper = new Jackson2HashMapper(objectMapper, true);//第二个参数可以控制里面的子对象页做map映射
        //value需要的是一个Map
        stringRedisTemplate.opsForHash().putAll("Steven01", jackson2HashMapper.toHash(p));
        Map map = stringRedisTemplate.opsForHash().entries("Steven01");
        Person person = objectMapper.convertValue(map, Person.class);
        System.out.println(person.getName());
    }
}

stringRedisTemplate.convertAndSend("channel01", "hello"); //发布

//订阅
RedisConnection connection = stringRedisTemplate.getConnectionFactory().getConnection();
connection.subscribe(new MessageListener() {
    @Override
    public void onMessage(Message message, byte[] bytes) {
        byte[] body = message.getBody();
        System.out.println(new String(body));
    }
}, "channel01".getBytes());


while (true) { //让进程一直存在着

}