Redis事务和jedis与springboot整合

最新推荐文章于 2023-05-15 10:00:00 发布

程序小旭

最新推荐文章于 2023-05-15 10:00:00 发布

阅读量169

点赞数

分类专栏： java 文章标签： redis 数据库 java

本文链接：https://blog.csdn.net/weixin_46167190/article/details/120684498

版权

java 专栏收录该内容

51 篇文章 0 订阅

订阅专栏

Redis事务和jedis与springboot整合

Redis的单条命令是保证原子性的，但是redis事务不能保证原子性

Redis事务本质：一组命令的集合。
----------------- 队列 set set set 执行 -------------------
事务中每条命令都会被序列化，执行过程中按顺序执行，不允许其他命令进行干扰。
一次性
顺序性
排他性
Redis事务没有隔离级别的概念
Redis单条命令是保证原子性的，但是事务不保证原子性！

Redis事务操作过程

开启事务（multi）
命令入队
执行事务（exec）

所以事务中的命令在加入时都没有被执行，直到提交时才会开始执行(Exec)一次性完成。

multi:开启事务

127.0.0.1:6379> multi
OK

127.0.0.1:6379> set k1 v1
QUEUED

执行命令入队

127.0.0.1:6379> set k1 v1
QUEUED
127.0.0.1:6379> set k2 v2
QUEUED
127.0.0.1:6379> set k3 v3
QUEUED
127.0.0.1:6379> get k1
QUEUED
127.0.0.1:6379> get k3
QUEUED

执行事务进行输出

127.0.0.1:6379> exec
1) OK
2) OK
3) OK
4) "v1"
5) "v3"
127.0.0.1:6379>

取消事务(discurd)

使用此命令放弃事务即之前执行的事务都不会去执行。

事务错误

代码语法错误（编译时异常）所有的命令都不执行

127.0.0.1:6379> multi
OK
127.0.0.1:6379> set k1 v1
QUEUED
127.0.0.1:6379> set k2 v2
QUEUED
127.0.0.1:6379> error k1 # 这是一条语法错误命令
(error) ERR unknown command `error`, with args beginning with: `k1`, # 会报错但是不影响后续命令入队 
127.0.0.1:6379> get k2
QUEUED
127.0.0.1:6379> EXEC
(error) EXECABORT Transaction discarded because of previous errors. # 执行报错
127.0.0.1:6379> get k1 
(nil) # 其他命令并没有被执行

代码逻辑错误 (运行时异常) **其他命令可以正常执行 ** >>> 所以不保证事务原子性

127.0.0.1:6379> multi
OK
127.0.0.1:6379> set k1 v1
QUEUED
127.0.0.1:6379> set k2 v2
QUEUED
127.0.0.1:6379> INCR k1 # 这条命令逻辑错误（对字符串进行增量）
QUEUED
127.0.0.1:6379> get k2
QUEUED
127.0.0.1:6379> exec
1) OK
2) OK
3) (error) ERR value is not an integer or out of range # 运行时报错
4) "v2" # 其他命令正常执行
虽然中间有一条命令报错了，但是后面的指令依旧正常执行成功了。
所以说Redis单条指令保证原子性，但是Redis事务不能保证原子性。

通过jedis来操作redis数据库

使用Java来操作Redis，Jedis是Redis官方推荐使用的Java连接redis的客户端。

1.导入依赖

<!--导入jredis的包-->
<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.70</version>
</dependency>

2.打开本地的redis进行连接测试

package com.dzu.cn;


import redis.clients.jedis.Jedis;

public class TestJedis {
    public static void main(String[] args) {
        Jedis jedis =new Jedis("127.0.0.1",6379);
        System.out.println(jedis.ping());
    }
}

//输出结果为pong连接成功

通过jedis操作事务对事务再次理解

常用的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","kuangshen");
        // 开启事务
        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整合redis

SpringBoot 操作数据：spring-data jpa jdbc mongodb redis！

SpringData 也是和 SpringBoot 齐名的项目！

说明：在 SpringBoot2.x 之后，原来使用的jedis 被替换为了 lettuce?

jedis : 采用的直连，多个线程操作的话，是不安全的，如果想要避免不安全的，使用 jedis pool 连接池！更像 BIO 模式

lettuce : 采用netty，实例可以再多个线程中进行共享，不存在线程不安全的情况！可以减少线程数据了，更像 NIO 模式

整合测试一下

对springboot中redis的自动配置类进行查看操作。

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

源码分析：

@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;
}

创建一个springboot的项目进行整合的测试

在配置文件中对springboot进行配置操作

spring.redis.host=127.0.0.1
spring.redis.port=6379

在springboot的测试类中进行测试操作

@Test
void contextLoads() {

    // redisTemplate 操作不同的数据类型，api和我们的指令是一样的
    // opsForValue 操作字符串 类似String
    // opsForList 操作List 类似List
    // opsForSet
    // opsForHash
    // opsForZSet
    // opsForGeo
    // opsForHyperLog

    // 除了基本的操作，我们常用的方法都可以直接通过redisTemplate操作，比如事务和基本的CRUD

    // 获取连接对象
    //RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
    //connection.flushDb();
    //connection.flushAll();

    redisTemplate.opsForValue().set(&quot;mykey&quot;,&quot;kuangshen&quot;);
    System.out.println(redisTemplate.opsForValue().get(&quot;mykey&quot;));
}

当在redis中查看默认的配置时会发现redis中的值可能会出现一定的乱码，需要我们对整个的对象进行序列化操作。

自定义redistemple

创建一个pojo的user类在没有进行序列化之前进行测试的操作。

package com.example.demo.config;

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);
        return template;
    }
}

package com.example.demo.pojo;

public class User {
    private String name;
    private int age;

    public User() {
    }

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

在实际的向redis中传递对象时，通常可以使用json的数据格式来完成对应的操作。

下面通过测试类来进行测试。

@Test
    public void test() throws JsonProcessingException {
        //在真实的开发中一般都会使用json来传递对象
        User user = new User("chenruxu",21);
        String jsonUser = new ObjectMapper().writeValueAsString(user);
        redisTemplate.opsForValue().set("user",jsonUser); //使用json格式向数据库中传入			对象
        System.out.println(redisTemplate.opsForValue().get("user"));
    }

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PIjIzSjb-1633837671714)(C:\Users\Lenovo\AppData\Roaming\Typora\typora-user-images\image-20211010111938003.png)]$

如果我们不使用json做为value 的值向redis里面存入数据，而是直接的使用对象来传递数据会出现报错对象没有进行序列化的操作。报错的信息如下

org.springframework.data.redis.serializer.SerializationException: Cannot serialize; nested exception is org.springframework.core.serializer.support.SerializationFailedException: Failed to serialize object using DefaultSerializer; nested exception is java.lang.IllegalArgumentException: DefaultSerializer requires a Serializable payload but received an object of type [com.example.demo.pojo.User]

at org.springframework.data.redis.serializer

对对象进行完序列化之后就可以实现对象的传入caoz

public class User implements Serializable

 @Test
    public void test() throws JsonProcessingException {
        //在真实的开发中一般都会使用json来传递对象
        User user = new User("chenruxu",21);
        String jsonUser = new ObjectMapper().writeValueAsString(user);
        redisTemplate.opsForValue().set("user",user); //使用json格式向数据库中传入对象
        System.out.println(redisTemplate.opsForValue().get("user"));

    }

默认的序列化时jdk的序列化在解析然后存储到redis数据库中的过程中显示的操作并不相同

`127.0.0.1:6379> keys *
1) "\xac\xed\x00\x05t\x00\x04user"
127.0.0.1:6379>127.0.0.1:6379> keys *
1) "\xac\xed\x00\x05t\x00\x04user"
127.0.0.1:6379>`

采用下面的模板在redis的自动配置类中配置好json方式的序列化的操作

package com.example.demo.config;

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

}

@Autowired
@Qualifier("redisTemplate")
private RedisTemplate redisTemplate;

使用json的序列化之后此时redis存入的key中的格式变成了字符串的格式

127.0.0.1:6379> keys *
1) "user"
127.0.0.1:6379>

程序小旭

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Redis事务和jedis与springboot整合

Redis事务和jedis与springboot整合Redis的单条命令是保证原子性的，但是redis事务不能保证原子性Redis事务本质：一组命令的集合。----------------- 队列 set set set 执行 -------------------事务中每条命令都会被序列化，执行过程中按顺序执行，不允许其他命令进行干扰。一次性顺序性排他性Redis事务没有隔离级别的概念Redis单条命令是保证原子性的，但是事务不保证原子性！Redis事务操作过程开启事务（mult
复制链接

扫一扫