springboot2.x 使用redis (入门)

在使用之前先简单介绍一下，redis和mongoDB这两个nosql的区别以及使用场景。

1. redis

redis是一个分布式缓存、高性能的key-value数据库。支持存储的value类型包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash（哈希类型）。这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。数据操作在内存中，因此效率非常高。可以持久化到磁盘，所以在对不同数据集进行高速读写时需要权衡内存，因为数据量不能大于硬件内存。

2. mongoDB

mongoDB 是一种文档性的数据库。先解释一下文档的数据库，即可以存放xml、json、bson类型系那个的数据。这些数据具备自述性（self-describing），呈现分层的树状数据结构。支持丰富的查询语句。

使用场景总结

  • mongodb 更偏向保存数据，而 redis 更偏向保持状态。

  • 业务数据量小且对效率有要求用redis.

  • mongoDB用于对海量数据的操作性能提升。

最简单的就这几点，最最重要的是你要知道一个叫缓存，一个是数据库。想清楚了就理解了。
这些都是个人理解，关于事务方面的，虽然redis支持，但很弱，真正涉及到事务的场景基本不会用它的。

接下来，进入正题，首先你的机器上要先安装redis，建议用docker.

docker使用redis

  1. 获取redis镜像
    执行命令docker pull redis

  2. 运行redis 并进行端口映射和持久化存储

docker run -d --name myredis -p6379:6379 -v /d/dockerdata/redis/data:/data redis --appendonly yes

参数说明：

  • -d ——后台运行

  • -name —— 运行后容器的名字

  • -p 6379:6379 —— 端口映射，默认端口

  • -v /d/dockerdata/redis/data:/data —— 保存数据的位置。

  • redis –appendonly yes —— 在容器执行redis启动命令，并打开redis持久化配置。

有可能会提示输入Windows密码，或者提示找不到文件存储目录，正常输入密码，指定位置创建文件夹就好。

  1. 测试运行是否成功
PS C:\Users\Gyyyang> docker exec -it myredis redis-cli
127.0.0.1:6379> info
# Server
redis_version:5.0.6
redis_git_sha1:00000000
......

spring boot项目中使用redis

1.添加 Redis 依赖

Spring Boot 官方已经为我们提供好了集成 Redis 的 Starter，我们只需要简单地在 pom.xml 文件中添加如下代码即可。

<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>

2.配置 Redis

spring:
    redis:
        host: 192.168.2.28
        port: 6379
        database: 0 # 数据库索引，默认是0
        password:   # Redis 服务器连接密码（默认为空）
        # 在2.0后 redis 底层已经默认修改为使用的是 Lettuce 而不是 Jedis 作为 Redis 驱动程序,但是仍然支持 Jedis,配置用法一致
        lettuce:  
          pool:
            max-active: 8  #连接池最大连接数（使用负值表示没有限制）
            max-wait: -1   # 连接池最大阻塞等待时间（使用负值表示没有限制）
            max-idle: 8    # 连接池中的最大空闲连接
            min-idle: 0    # 连接池中的最小空闲连接
        timeout: 0       # 连接超时时间（毫秒）

Spring Boot 的 spring-boot-starter-data-redis 为 Redis 的相关操作提供了一个高度封装的 RedisTemplate 类，而且对每种类型的数据结构都进行了归类，将同一类型操作封装为 operation 接口。RedisTemplate 对五种数据结构分别定义了操作，如下所示：

  • 操作字符串：redisTemplate.opsForValue()

  • 操作 Hash：redisTemplate.opsForHash()

  • 操作 List：redisTemplate.opsForList()

  • 操作 Set：redisTemplate.opsForSet()

  • 操作 ZSet：redisTemplate.opsForZSet()

但是对于 string 类型的数据，Spring Boot 还专门提供了 StringRedisTemplate 类，而且官方也建议使用该类来操作 String 类型的数据。那么它和 RedisTemplate 又有啥区别呢？

  1. RedisTemplate 是一个泛型类，而 StringRedisTemplate 不是，后者只能对键和值都为 String 类型的数据进行操作，而前者则可以操作任何类型。

  2. 两者的数据是不共通的，StringRedisTemplate 只能管理 StringRedisTemplate 里面的数据，RedisTemplate 只能管理 RedisTemplate 中 的数据。

RedisTemplate 的配置

一个 Spring Boot 项目中，我们只需要维护一个 RedisTemplate 对象和一个 StringRedisTemplate 对象就可以了。所以我们需要通过一个 Configuration 类来初始化这两个对象并且交由的 BeanFactory 管理。在 config 包下面新建了一个 RedisConfig 类，其内容如下所示：

@Configuration
@AutoConfigureAfter(RedisAutoConfiguration.class)
public class RedisConfig {
 
    @Bean
    @ConditionalOnMissingBean(name = "redisTemplate")
    public RedisTemplate<String, Object> redisTemplate(
            RedisConnectionFactory redisConnectionFactory) {
 
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
 
        RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
        template.setConnectionFactory(redisConnectionFactory);
        template.setKeySerializer(jackson2JsonRedisSerializer);
        template.setValueSerializer(jackson2JsonRedisSerializer);
        template.setHashKeySerializer(jackson2JsonRedisSerializer);
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }
 
    @Bean
    @ConditionalOnMissingBean(StringRedisTemplate.class)
    public StringRedisTemplate stringRedisTemplate(
            RedisConnectionFactory redisConnectionFactory) {
        StringRedisTemplate template = new StringRedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }
}

其中@Configuration 代表这个类是一个配置类，然后@AutoConfigureAfter(RedisAutoConfiguration.class) 是让我们这个配置类在内置的配置类之后在配置，这样就保证我们的配置类生效，并且不会被覆盖配置。其中需要注意的就是方法名一定要叫redisTemplate 因为@Bean注解是根据方法名配置这个bean的name的。

测试

新建一个实体类：

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User implements Serializable {
    private static final Long  serialVersionUID = 111111111L;
    private String username;
    private String password;
    private Integer age;
​
    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", age=" + age +
                '}';
    }
}

测试代码：

@SpringBootTest
class BootApplicationTests {
​
@Autowired
private RedisTemplate redisTemplate;
​
@Autowired
private StringRedisTemplate stringRedisTemplate;
    @Test
    void contextLoads() {
        String key = "name";
        stringRedisTemplate.opsForValue().set(key, "hai");
        String value = stringRedisTemplate.opsForValue().get(key);
​
        System.out.println(key + "----" + value);
​
        User user =new User();
        user.setUsername("yang");
        user.setPassword("ssss");
        user.setAge(12);
        String userKey = "yang";
        redisTemplate.opsForValue().set(userKey,user);
        User newUser = (User) redisTemplate.opsForValue().get(userKey);
        System.out.println("获取缓存中key为" + userKey + "的值为：" + newUser);
    }
}

测试结果：

name----hai
获取缓存中key为yang的值为：User{username='yang', password='ssss', age=12}

其他数据类型操作类似，就不一一列举了，也可以下载一个可视化工具查看一下缓存。

文章内容纯属个人理解，可能存在错误，望及时指出，希望对你有用。

posted @ 2019-12-10 22:14  Gyyyang  阅读(681)  评论(2)  编辑  收藏  举报