SpringBoot-Redis

redis是一个key-value存储系统。和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash（哈希类型）。
这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。在此基础上，redis支持各种不同方式的排序。
与memcached一样，为了保证效率，数据都是缓存在内存中。区别的是redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave(主从)同步。
--摘自百度百科

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 3          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
 4   <modelVersion>4.0.0</modelVersion>
 5   <parent>
 6     <groupId>org.springframework.boot</groupId>
 7     <artifactId>spring-boot-starter-parent</artifactId>
 8     <version>2.0.6.RELEASE</version>
 9     <relativePath/> <!-- lookup parent from repository -->
10   </parent>
11 
12   <groupId>com.mike.study</groupId>
13   <artifactId>springboot-redis</artifactId>
14   <version>0.0.1-SNAPSHOT</version>
15   <name>springboot-redis</name>
16   <description>Demo project for Spring Boot</description>
17 
18   <properties>
19     <java.version>1.8</java.version>
20   </properties>
21   <dependencies>
22     <dependency>
23       <groupId>org.springframework.boot</groupId>
24       <artifactId>spring-boot-starter-data-redis</artifactId>
25     </dependency>
26     <dependency>
27       <groupId>org.springframework.boot</groupId>
28       <artifactId>spring-boot-starter-web</artifactId>
29     </dependency>
30 
31     <dependency>
32       <groupId>com.alibaba</groupId>
33       <artifactId>fastjson</artifactId>
34       <version>1.2.8</version>
35     </dependency>
36 
37     <dependency>
38       <groupId>org.springframework.boot</groupId>
39       <artifactId>spring-boot-starter-test</artifactId>
40       <scope>test</scope>
41     </dependency>
42     <dependency>
43       <groupId>io.projectreactor</groupId>
44       <artifactId>reactor-test</artifactId>
45       <scope>test</scope>
46     </dependency>
47   </dependencies>
48 
49   <build>
50     <plugins>
51       <plugin>
52         <groupId>org.springframework.boot</groupId>
53         <artifactId>spring-boot-maven-plugin</artifactId>
54       </plugin>
55     </plugins>
56   </build>
57 
58 </project>

1 spring:
2   data:
3     redis:
4       host: 127.0.0.1
5       port: 6379

 1 /**
 2  * @Classname OrderInfo
 3  * @Created by Michael
 4  * @Date 2023/5/25
 5  * @Description 订单信息类
 6  */
 7 public class OrderInfo {
 8   private long orderID;
 9   private String orderNo;
10 
11   public long getOrderID() {
12     return orderID;
13   }
14 
15   public void setOrderID(long orderID) {
16     this.orderID = orderID;
17   }
18 
19   public String getOrderNo() {
20     return orderNo;
21   }
22 
23   public void setOrderNo(String orderNo) {
24     this.orderNo = orderNo;
25   }
26 }

 1 import com.alibaba.fastjson.JSON;
 2 import com.alibaba.fastjson.serializer.SerializerFeature;
 3 import org.springframework.data.redis.serializer.RedisSerializer;
 4 import org.springframework.data.redis.serializer.SerializationException;
 5 
 6 import java.nio.charset.Charset;
 7 
 8 /**
 9  * @Classname FastJsonRedisSerializer
10  * @Created by Michael
11  * @Date 2023/5/25
12  * @Description 自定义FastJSON的serializer
13  */
14 public class FastJsonRedisSerializer<T> implements RedisSerializer<T> {
15 
16   public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");
17   private Class<T> clazz;
18 
19   public FastJsonRedisSerializer(Class<T> clazz) {
20     super();
21     this.clazz = clazz;
22   }
23 
24   @Override
25   public byte[] serialize(T t) throws SerializationException {
26     if (null == t) {
27       return new byte[0];
28     }
29     return JSON.toJSONString(t, SerializerFeature.WriteClassName).getBytes(DEFAULT_CHARSET);
30   }
31 
32   @Override
33   public T deserialize(byte[] bytes) throws SerializationException {
34     if (null == bytes || bytes.length <= 0) {
35       return null;
36     }
37     String str = new String(bytes, DEFAULT_CHARSET);
38     return (T) JSON.parseObject(str, clazz);
39   }
40 }

 1 import com.mike.study.springbootredis.serializer.FastJsonRedisSerializer;
 2 import org.springframework.context.annotation.Bean;
 3 import org.springframework.context.annotation.Configuration;
 4 import org.springframework.data.redis.connection.RedisConnectionFactory;
 5 import org.springframework.data.redis.core.RedisTemplate;
 6 import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
 7 import org.springframework.data.redis.serializer.RedisSerializer;
 8 import org.springframework.data.redis.serializer.StringRedisSerializer;
 9 
10 /**
11  * @Classname RedisConfiguration
12  * @Created by Michael
13  * @Date 2023/5/25
14  * @Description Redis配置序列化器
15  */
16 @Configuration
17 public class RedisConfiguration {
18   @Bean
19   public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
20     RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<Object, Object>();
21     redisTemplate.setConnectionFactory(connectionFactory);
22     // 使用jackson2的序列对象
23     RedisSerializer genericJackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
24     redisTemplate.setDefaultSerializer(genericJackson2JsonRedisSerializer);
25 
26     return redisTemplate;
27   }
28 
29   @Bean
30   public RedisTemplate<Object, Object> customRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
31       RedisTemplate<Object, Object> template = new RedisTemplate<>();
32       //使用fastjson序列化
33       FastJsonRedisSerializer fastJsonRedisSerializer = new FastJsonRedisSerializer(Object.class);
34       // value值的序列化采用fastJsonRedisSerializer
35       template.setValueSerializer(fastJsonRedisSerializer);
36       template.setHashValueSerializer(fastJsonRedisSerializer);
37       // key的序列化采用StringRedisSerializer
38       template.setKeySerializer(new StringRedisSerializer());
39       template.setHashKeySerializer(new StringRedisSerializer());
40       template.setConnectionFactory(redisConnectionFactory);
41       return template;
42   }
43 }

 1 import com.mike.study.springbootredis.domain.OrderInfo;
 2 import org.springframework.boot.SpringApplication;
 3 import org.springframework.boot.autoconfigure.SpringBootApplication;
 4 import org.springframework.context.ConfigurableApplicationContext;
 5 import org.springframework.data.redis.core.RedisTemplate;
 6 
 7 @SpringBootApplication
 8 public class SpringbootRedisApplication {
 9 
10   public static void main(String[] args) {
11     ConfigurableApplicationContext 
12             context = SpringApplication.run(SpringbootRedisApplication.class, args);
13     OrderInfo orderInfo = new OrderInfo();
14     // 使用默认的序列化器 redisTemplate
15     RedisTemplate redisTemplate
16             = context.getBean("redisTemplate", RedisTemplate.class);
17 
18 //    redisTemplate.opsForValue().set("test", "测试");//没有定义序列化器，会出现乱码
19 
20     orderInfo.setOrderID(123456L);
21     orderInfo.setOrderNo("订单号：20230525A112");
22     //使用默认序列化器
23     redisTemplate.opsForValue().set("order",orderInfo);
24 
25 
26     //使用自定义序列化器
27     RedisTemplate redisTemplate2
28             = context.getBean("customRedisTemplate", RedisTemplate.class);
29     orderInfo.setOrderID(98765L);
30     orderInfo.setOrderNo("订单号：20230525A996");
31     //使用默认序列化器
32     redisTemplate2.opsForValue().set("order2",orderInfo);
33     context.close();
34 
35 
36   }
37 
38 }