springboot使用lua脚本操作redis

た入场券 2023-06-25 08:12 20阅读 0赞

### springboot使用lua脚本操作redis ###

*  项目背景
 *  开发步骤
 *   *   *  1、流程
         *  2、引入依赖
         *  3、配置RedisTemplate
         *  4、封装待执行的lua脚本对象
         *  5、执行脚本

# 项目背景 #

*  1、可以把多个redis操作放到一个lua脚本中，能避免频繁操作redis
 *  2、一个lua脚本中的所有操作都是原子性。在执行该脚本的过程中，不会插入其他线程的执行任务

# 开发步骤 #

### 1、流程 ###

![在这里插入图片描述][20210204112915571.png]

### 2、引入依赖 ###

> springboot用的是2.1.6.RELEASE版本

<parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.1.6.RELEASE</version>
            <relativePath/> 
        </parent>
    
    ...
    
    <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>

### 3、配置RedisTemplate ###

> 主要是配置序列化和反序列化的方式

package cc.xxx.configs;
    
    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;
    
    /** * redis配置类 * @author ZENG.XIAO.YAN * @date 2018年6月6日 * 参考：https://www.cnblogs.com/senlinyang/p/8830577.html */
    @Configuration
    public class RedisConfig { 
    
        @Bean
        public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) { 
            RedisTemplate<String, Object> template = new RedisTemplate<>();
            template.setConnectionFactory(factory);
            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);
            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;
        }
    }

### 4、封装待执行的lua脚本对象 ###

> 下面是一个示例。我封装了两个lua脚本对象，一个是setRedisScript 和casRedisScript。具体的脚本内容见下文。  
> 这里采用的是静态代码块的方式。它的好处是：1、项目启动时脚本就已经加载完毕了，不需要等待执行时才去磁盘上读取；2、使用时直接使用类名.脚本对象名即可，无须注入，拿来即用。

*  封装脚本对象：

package cc.xxx.script;
    
    import org.springframework.core.io.ClassPathResource;
    import org.springframework.data.redis.core.script.DefaultRedisScript;
    import org.springframework.scripting.support.ResourceScriptSource;
    
    public class TestScript { 
    
        public static final DefaultRedisScript<Boolean> setRedisScript = new DefaultRedisScript<>();
        static { 
            setRedisScript.setScriptSource(new ResourceScriptSource(new ClassPathResource("lua/set.lua")));
            setRedisScript.setResultType(Boolean.class);
        }
    
        public static final DefaultRedisScript<Boolean> casRedisScript = new DefaultRedisScript<>();
        static { 
            casRedisScript.setScriptSource(new ResourceScriptSource(new ClassPathResource("lua/cas.lua")));
            casRedisScript.setResultType(Boolean.class);
        }
    }

*  lua脚本内容：

（1）lua/set.lua脚本(去redis中写一个键-值)：

redis.call('set',KEYS[1],KEYS[2])

（2）lua/cas.lua脚本(通过key去redis中获取值，如果该值等于val1，则把key对应的值修改为val2：

local key = KEYS[1]
    
    local val1 = KEYS[2]
    local val2 = KEYS[3]
    
    redis.log(redis.LOG_WARNING,key)
    
    if redis.pcall("get", key) == val1 then
        if redis.pcall("set",key, val2) then
            return true
        else
            return false
        end
    end

### 5、执行脚本 ###

> 这里只展示service层，其他的层不展示

package cc.xxx.impl;
    
    import cc.xxx.script.TestScript;
    import cc.xxx.service.ReportService;
    import lombok.NonNull;
    import lombok.RequiredArgsConstructor;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.data.redis.core.StringRedisTemplate;
    import org.springframework.stereotype.Service;
    
    import javax.servlet.http.HttpServletResponse;
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.List;
    import java.util.Map;
    
    /** * @author wangll */
    @Service
    @Slf4j
    @RequiredArgsConstructor
    public class ReportServiceImpl implements ReportService { 
    
        @NonNull
        private StringRedisTemplate stringRedisTemplate;
    
        @Override
        public Boolean setStringByLua(String k, String v) { 
            List<String> keys = Arrays.asList(k,v);
            Boolean execute = stringRedisTemplate.execute(TestScript.setRedisScript, keys);
            return execute;
        }
    
        @Override
        public Boolean casByLua(String k, String v1, String v2) { 
            List<String> keys = Arrays.asList(k,v1,v2);
            Boolean execute = stringRedisTemplate.execute(TestScript.casRedisScript, keys);
            return execute;
        }
    }

[20210204112915571.png]: https://img-blog.csdnimg.cn/20210204112915571.png