在聊 SpringBoot整合redis之前，我们先看看 Redis推荐的java连接开发工具：jedis知其然并知其所以然，授人以渔！ 学习不能急躁，慢慢来会很快！

Jedis

什么是Jedis 是 Redis 官方推荐的 java连接开发工具！ 使用Java 操作Redis 中间件！如果你要使用 java操作redis，那么一定要对Jedis 十分的熟悉！

测试：

1、导入对应的依赖

<!--导入jedis的包-->
<dependencies>
          <!-- https://mvnrepository.com/artifact/redis.clients/jedis -->
          <dependency>
                <groupId>redis.clients</groupId>
                <artifactId>jedis</artifactId>
                <version>3.2.0</version>
          </dependency>
          <!--fastjson-->
          <dependency>
                    <groupId>com.alibaba</groupId>
                    <artifactId>fastjson</artifactId>
                    <version>1.2.62</version>
          </dependency>
</dependencies>

2、编码测试：

• 连接数据库
• 操作命令
• 断开连接！

import redis.clients.jedis.Jedis;

public class TestPing {
public static void main(String[] args) {
            // 1、 new Jedis 对象即可
            Jedis jedis = new Jedis("127.0.0.1",6379);
            // jedis 所有的命令就是我们之前学习的所有指令！所以之前的指令学习很重要！
            System.out.println(jedis.ping());
    }
}

常用的API

• String
• List
• Set
• Hash
• Zset

所有的api命令，就是我们对应的上面学习的指令，一个都没有变化！

事务

public class TestTX {
public static void main(String[] args) {
            Jedis jedis = new Jedis("127.0.0.1", 6379);
            jedis.flushDB();
            JSONObject jsonObject = new JSONObject();
            jsonObject.put("hello","world");
            jsonObject.put("name","xiaohan");
            // 开启事务
            Transaction multi = jedis.multi();
            String result = jsonObject.toJSONString();
              // jedis.watch(result)
            try {
                      multi.set("user1",result);
                      multi.set("user2",result);
                      int i = 1/0 ; // 代码抛出异常事务，执行失败！
                      multi.exec(); // 执行事务！
                  } catch (Exception e) {
                        multi.discard(); // 放弃事务
                        e.printStackTrace();
                  } finally {
                        System.out.println(jedis.get("user1"));
                        System.out.println(jedis.get("user2"));
                        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") 
// 我们可以自己定义一个redisTemplate来替换这个默认的！
          public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory
          redisConnectionFactory)
          throws UnknownHostException {
          // 默认的 RedisTemplate 没有过多的设置，redis 对象都是需要序列化！
          // 两个泛型都是 Object, Object 的类型，我们后使用需要强制转换 <String, Object>
          RedisTemplate<Object, Object> template = new RedisTemplate<>();
          template.setConnectionFactory(redisConnectionFactory);
          return template;
}
@Bean
@ConditionalOnMissingBean {
// 由于 String 是redis中最常使用的类型，所以说单独提出来了一个bean！
        public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory
        redisConnectionFactory)
        throws UnknownHostException {
        StringRedisTemplate template = new StringRedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
}

整合测试一下

1、导入依赖

<!-- 操作redis -->
<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 Redis02SpringbootApplicationTests {
  
@Autowired
private RedisTemplate redisTemplate;
  
  
@Test
void contextLoads() {
              // redisTemplate            操作不同的数据类型，api和我们的指令是一样的
              // opsForValue             操作字符串 类似String
              // opsForList              操作List 类似List
              // opsForSet
              // opsForHash
        			 // opsForZS
              // opsForGeo
              // opsForHyperLogLog
   // 除了进本的操作，我们常用的方法都可以直接通过redisTemplate操作，比如事务，和基本的CRUD
              // 获取redis的连接对象
              // RedisConnection connection =
             // redisTemplate.getConnectionFactory().getConnection();
              // connection.flushDb();
              // connection.flushAll();
  
  
              redisTemplate.opsForValue().set("mykey","我是小涵");
              System.out.println(redisTemplate.opsForValue().get("mykey"));
      }
}

关于对象的保存：

我们来编写一个自己的 RedisTemplete

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
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.StringRedisSerializer;
@Configuration
public class RedisConfig {
  
  // 这是我给大家写好的一个固定模板，大家在企业中，拿去就可以直接使用！
// 自己定义了一个 RedisTemplate
  
@Bean
@SuppressWarnings("all")
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory
factory) {
            // 我们为了自己开发方便，一般直接使用 <String, Object>
            RedisTemplate<String, Object> template = new RedisTemplate<String,
            Object>();
            template.setConnectionFactory(factory);
            // Json序列化配置
            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);
            // String 的序列化
            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;
				}
}

所有的redis操作，其实对于java开发人员来说，十分的简单，更重要是要去理解redis的思想和每一种数 据结构的用处和作用场景！

其实redis的整合是很简单的有没有，很多都是复制粘贴的，然而授人予鱼不如授人予渔，如果这篇文章对你有益，别忘了关注点赞转发哦！