Jedis

概念

Jedis 是 Redis 官方推薦的 java連接開發工具！ 使用Java 操作Redis 中間件！如果你要使用java操作redis，那么一定要對Jedis 十分的熟悉！

使用

• 1、導入對應的依賴

 <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>4.0.1</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.38</version>
 </dependency>

• 2、編碼測試：

連接數據庫
操作命令
斷開連接！
代碼

/**
 * 測試Jedis連接
 */
public class TestPing {
    public static void main(String[] args) {
        //1.new Jedis對象即可
        Jedis jedis = new Jedis("127.0.0.1",6379);
         //測試連接
        System.out.println(jedis.ping());
    }
}

常用的API，所有的api命令與Redis沒有區別。這里重點講一下事務的相關API，其他的API使用可以參考這里：

public class TestMulti {
    public static void main(String[] args) {
        //創建客戶端連接服務端，redis服務端需要被開啟
        Jedis jedis = new Jedis("127.0.0.1", 6379);
        jedis.flushDB();

        JSONObject jsonObject = new JSONObject();
        jsonObject.put("hello", "world");
        jsonObject.put("name", "java");
        //開啟事務
        Transaction multi = jedis.multi();
        String result = jsonObject.toJSONString();
        try {
            //向redis存入一條數據
            multi.set("json", result);
            //再存入一條數據
            multi.set("json2", result);
            //這里引發了異常，用0作為被除數
            int i = 100/0;
            //如果沒有引發異常，執行進入隊列的命令
            multi.exec();
        } catch (Exception e) {
            e.printStackTrace();
            //如果出現異常，回滾
            multi.discard();
        } finally {
            System.out.println(jedis.get("json"));
            System.out.println(jedis.get("json2"));
            //最終關閉客戶端
            jedis.close();
        }
    }
}

SpringBoot

SpringBoot 操作數據：spring-data jpa jdbc mongodb redis！
SpringData 也是和 SpringBoot 齊名的項目！
說明： 在 SpringBoot2.x 之后，原來使用的jedis 被替換為了 lettuce?

• jedis : 采用的直連，多個線程操作的話，是不安全的，如果想要避免不安全的，使用 jedis pool 連接 池！ 更像 BIO 模式
• lettuce : 采用netty，實例可以再多個線程中進行共享，不存在線程不安全的情況！可以減少線程數據 了，更像 NIO 模式

配置文件源碼分析：

 @Bean
    @ConditionalOnMissingBean(
        name = {"redisTemplate"}
    )
    //ConditionalOnSingleCandidate 如果沒有這個類，則使用這個類
    //我們可以自己定義一個redisTemplate來替換這個默認的！
 @ConditionalOnSingleCandidate(RedisConnectionFactory.class)
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
    //默認的 RedisTemplate 沒有過多地設置，redis對象都是需要序列化的！
    //兩個泛型都是 Object類型，我們之后使用需要強制類型轉換 <String Object>
        RedisTemplate<Object, Object> template = new RedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }

    @Bean
    @ConditionalOnMissingBean
    //由于string 是redis中最常使用的類型，所以說單獨提出來了一個bean！@ConditionalOnSingleCandidate(RedisConnectionFactory.class)
    public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
        return new StringRedisTemplate(redisConnectionFactory);
    }

整合測試

1、導入依賴

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

2、配置連接

# 配置redis 
spring.redis.host=127.0.0.1 
spring.redis.port=6379

3、測試！

@SpringBootTest
class RedisSpringbootApplicationTests {

    @Autowired
    private RedisTemplate<String,String> redisTemplate;

    @Test
    void contextLoads() {
        // redisTemplate 操作不同的數據類型，api和我們的指令是一樣的
        // opsForValue 操作字符串 類似String
        // opsForList 操作List 類似List
        // opsForSet
        // opsForHash
        // opsForZSet
        // opsForGeo
        // opsForHyperLogLog
        // 除了進本的操作，我們常用的方法都可以直接通過redisTemplate操作，比如事務，和基本的 CRUD
        // 獲取redis的連接對象
//        RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
//        connection.flushDb();
//        connection.flushAll();
        redisTemplate.opsForValue().set("key","myValue");
        System.out.println(redisTemplate.opsForValue().get("key"));
    }

}

自己的 RedisTemplete

因為默認的序列化方式是JDK序列化，我們可能會用到Json來序列化，我們來編寫一個自己的 RedisTemplete，方便使用

@Configuration
public class RedisConfig {

  @Bean
  @SuppressWarnings("all")
  public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
      RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
      template.setConnectionFactory(factory);
      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);
      StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();

      // key采用String的序列化方式
      template.setKeySerializer(stringRedisSerializer);
      // hash的key也采用String的序列化方式
      template.setHashKeySerializer(stringRedisSerializer);
      // value序列化方式采用jackson
      template.setValueSerializer(jackson2JsonRedisSerializer);
      // hash的value序列化方式采用jackson
      template.setHashValueSerializer(jackson2JsonRedisSerializer);
      template.afterPropertiesSet();

      return template;
  }
  
}