Redis基础篇学习笔记五：springBoot整合redis

由于springboot在业内的使用占比非常大，所以我们不仅仅要学redis的命令，更多使用的是redis与springboot的整合。那接下来，就一起学习关于springboot整合redis的内容吧。

学习redis,需要类比MySql。使用java连接MySql时，我们使用了JDBC,，同理，连接redis时，我们也需要这样的一个连接代理，因此，出现了Jedis。
但由于Jedis对线程并不安全，于是出现了Lettuce(翻译：生菜)，后来，spring为了整合redis，推出了RedisTemplate,当然，这是对lettuce的封装和加强。本次介绍就依次介绍这三个以及它们的使用（重点是RedisTemplate,因为以后大多使用这个作为连接redis的连接器）。

在进行操作之前，大家要确保redis服务是开启的。

 redis-cli -a 123321 -p 6379 --raw

-a: redis密码 -p: 端口 --raw: 表示支持中文显示（当redis存入中文不显示乱码）

1：Jedis

jedis client是Redis官网推荐的一个面向java客户端，库文件实现了对各类API进行封装调用。
五步法建项目：

（1）建module
这里我们可以选择直接建立springboot项目，然后勾选一个web的start，版本使用2.6.10。
或者建立一个maven项目，后续在pom添加对应的依赖。
如果对建项目不熟，可以先学springboot的教材（推荐黑马程序员的教学）
（2）改pom
因为这是对Jedis的使用，所以需要添加Jedis的依赖，后续为了方便，我们还添加了lombok的依赖以及junit的依赖。

	<parent>
        <!--        父项目依赖-->
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.10</version>
        <relativePath/>
    </parent>

    <!--    版本控制-->
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <junit.version>4.12</junit.version>
        <log4j.version>1.2.17</log4j.version>
        <lombok.version>1.16.18</lombok.version>
    </properties>


    <dependencies>
        <!--        springboot通用模块-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--        jedis依赖-->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>4.3.1</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>${junit.version}</version>
            <scope>test</scope>
        </dependency>
        
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>${log4j.version}</version>
        </dependency>
        
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>${lombok.version}</version>
        </dependency>
    </dependencies>

这里建议直接复制，不容易出错。

（3）写YML
因为使用的Jedis，所以简单配置一下port和application.name。

server:
  port: 8080

spring:
  application:
    name: redis7

（4）主启动类
如果建立项目是使用springboot的话，主启动类会自动生产，如果建立maven的话，建一个自己的包以及主启动类，包结构如下：

config,service,controller,domo包里面没有类，整个结构只有主启动类。

package com.itludehu.redis;

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

@SpringBootApplication
public class RedisApplication {

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

（5）业务类
最后，我们就可以进行jedis的业务测试了，为了方便，不再新建一个测试类，而是再demo包里面新建一个类RedisDemo：

public class RedisDemo {

    //使用原生的jedis来进行连接redis
    public static void main(String[] args) {

        //1，指定端口，ip获得连接redis的连接
        Jedis jedis = new Jedis("192.168.190.128", 6379);

        //2，指定访问器的密码
        jedis.auth("123321");

        //3.获得jedis客户端 和jdbc一样，访问redis
        System.out.println(jedis.ping());

        //keys的操作
        Set<String> keys = jedis.keys("*");
        System.out.println(keys);

        //string的操作
        jedis.set("k3","hello-Jedis7");

        //list
        jedis.lpush("list","11","22","33");
        List<String> list = jedis.lrange("list", 0, -1);
        for(String element : list){
            System.out.println(element);
        }

    }
}

可以将主方法运行起来并得到结果。
通过上面，可以得到，使用Jedis步骤：1，new 一个Jedis并连接好ip和端口（这里放入你们自己的ip）,并使用方法auth()指定密码。2，使用jedis对redis的命令进行操作，这里的操作值redis的命令，上面仅仅写了几个命令的接口，各位可以参照其他命令的接口并运行起来。

2：Lettuce

上面的jedis以及可以对redis数据库进行操作了，但是有一个很大的问题，每当业务需要连接redis时候，都需要new一个Jedis，造成线程不安全，，当很多客户端需要连接redis的时候，这样会产生很多对象，浪费内存并且会是服务器宕机。
对比于MySql，解决这样的问题就是使用一个数据源DataSource来解决，所以redis中出现了Lettuce(生菜)。

lettuce是一个redis的Java驱动包。
优势：lettuce底层使用的Netty,当有很多个线程都需要连接redis服务器的时候，可以保证只创建一个lettuce连接，使所有的线程都共享这一个连接，这样减少了很大的开销；并且线程之间是安全的。
因为要使用到Lettuce，那需要在pow中添加对应的依赖

<!--        lettcue的依赖-->
        <dependency>
            <groupId>io.lettuce</groupId>
            <artifactId>lettuce-core</artifactId>
            <version>6.2.1.RELEASE</version>
        </dependency>

在代码中的demo包中新建一个类LettuceDemo：

public class LettuceDemo {

    public static void main(String[] args) {

        //1.使用构建器链式编程构建Builder出lettuce
        RedisURI url = RedisURI.builder()
                .redis("192.168.190.128")
                .withPort(6379)
                .withAuthentication("default", "123321")
                .build();

        //2,创建连接客户端
        RedisClient redisClient = RedisClient.create(url);
        StatefulRedisConnection conn = redisClient.connect();

        //3.创建操作的command，使用conn
        RedisCommands commands = conn.sync();

        //-----------业务逻辑---------------
        //key
        List keys = commands.keys("*");
        System.out.println("***************"+keys);

        //String
        commands.set("k5","hello-lettuce");
        Object k5 = commands.get("k5");
        System.out.println("***************"+k5);

        //list

        //4.各种关闭释放资源
        conn.close();;
        redisClient.shutdown();

    }
}

在进行业务逻辑后，记得关闭相应的资源：conn.close(); redisClient.shutdown();
运行代码也可以得到相应的结果，同样，这里仅仅写了几个命令接口，其他需要自己动手操作。

3:RedisTemplate

RedisTemplate是spring整合redis的常用的连接器。

spring优点就是整合其他技术，然后将这些技术放入Ioc的容器中，让spring进行管理，这样大大简化了我们的开发。
使用RedisTemplate，我们要先添加相应的依赖坐标，包括：spring和redis的整合启动坐标，commons-pool2的坐标。

<!--        springboot整合redis依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>

添加好依赖后，就可以修改yml文件中的配置。

server:
  port: 8080

spring:
  application:
    name: redis7
  redis:
    database: 0
    password: 123321
    host: 192.168.190.128
    port: 6379
    lettuce:   #连接器
      pool:
        max-active: 8
        max-wait: -1ms
        max-idle: 8
        min-idle: 0

！！！配置中的连接参数记得修改成你们自己的。
因为redisTemplate是对lettuce的封装加强，所有连接器使用的还是lettoce。
database: 0 表示连接的是redis的第一个库（redis一共有16个库）
password: 密码
host: 主机ip
port: 端口

接下来就是业务类的编写了。
之前添加了web的依赖，就在service和controller包下新建对应的OrderService和OrderController:

代码如下：
Service层

@Service
public class OrderService {


    public static final String ORDER_KEY = "order:";

    @Resource
    private RedisTemplate redisTemplate;


    public void addOrder(){
        int keyID = ThreadLocalRandom.current().nextInt(1000)+1;
        String serialNo = UUID.randomUUID().toString();

        String key = ORDER_KEY + keyID;
        String value = "京东订单" + serialNo;
        //存入redis
        redisTemplate.opsForValue().set(key,value);
        System.out.println("***Key: "+ key);
        System.out.println("***value: {}"+value);
    }

    public String getOrderById(Integer keyID){
        return (String) redisTemplate.opsForValue().get(ORDER_KEY + keyID);

    }

}

里面注入了RedisTemplate，并创建了两个方法：addOrder和getOrderByID。
在里面，直接调用redisTemplate.opsForValue.set(key,value)就是对redis进行set key value的命令。
redisTemplate有几种opsFor.*:
opsForValue: 表示对String类型进行操作。
opsForList: 表示对List类型进行操作。
opsForHash:表示对hash类型进行操作。
opsForSet：表示对set进行操作。
opsForZSet:表示对zSet操作。

controller层：

@RestController
public class OrderController {


    @Resource
    private OrderService orderService;
    
    @GetMapping(value = "/order/add")
    public void addOrder(){
        orderService.addOrder();
    }
    
    @RequestMapping(value = "/order/{keyID}",method = RequestMethod.GET)
    public String getOrderByID(@PathVariable  Integer keyID){
        return orderService.getOrderById(keyID);
    }
}

上面定义了两个请求，一个是添加Order，一个是根据ID获取Oder。

启动主程序后，我们打开第一个请求，存入一个Order。
但奇怪的是，获取请求并没有获取到，于是我们去redis数据库进行查询。
输入指令： keys *
可以看到一个很奇怪的东西：

数据库出现了乱码，使用的redisTemplate存入的数据有一个不知道的前缀，根据源码，发现是spring对存入的数据进行了序列化的默认序列化，导致前面出现了乱码，但我们本身不希望有乱码的出现，于是需要我们手动配置一个序列化的工具给redisTemplate。
在config包中新建一个RedisConfig类，并注解配置类@Configuration:

@Configuration
public class RedisConfig {


    //解决redis的序列化问题：
    @Bean
    public RedisTemplate<String,Object> redisTemplate(LettuceConnectionFactory lettuceConnectionFactory){
        RedisTemplate<String,Object> redisTemplate = new RedisTemplate<>();
        //注入lettuce工厂
        redisTemplate.setConnectionFactory(lettuceConnectionFactory);
        //设置key的序列化方式String
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        //设置value的序列化方式json,使用GenericJackson2JsonRedisSerializer
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());


        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
        return redisTemplate;
    }
}

这样序列化的方式就解决了。
运行发现后，redis数据没有了前缀。
当然，可以使用另外一种方法，也是就使用RedisTemplate的子类StringRedisTemplate来进行redis的连接，它本身就已经初始化了序列化类，所有在存入数据时并不会产生乱码前缀。
@Resource
private StringRedisTemplate stringRedisTemplate;
至此，springboot整合redis的基础就结束了。
后续会发布关于当使用redisTemplate来对对象（引用类型）进行存储到redis的一些步骤和会出现的问题！