Quelles sont les méthodes d'implémentation de script Lua et les scénarios d'application dans Redis ?

1. Présentation du script Redis Lua

Redis permet aux utilisateurs d'écrire des scripts personnalisés à l'aide de scripts Lua et de les exécuter sur le serveur Redis. Lua est un langage de script léger présentant les avantages de simplicité, d'efficacité et d'évolutivité. Dans Redis, les scripts Lua peuvent être utilisés pour des traitements de données complexes, tels que le filtrage, l'agrégation, le tri des données, etc., et peuvent également améliorer les performances du serveur Redis.

2. Avantages des scripts Redis Lua

Par rapport à la méthode de commande Redis traditionnelle, les scripts Lua présentent les avantages suivants :

• (2) Réduisez la latence du réseau : fusionnez plusieurs commandes Redis en un seul script Lua, réduisant ainsi l'interaction réseau entre client et serveur. Dans le même temps, le serveur Redis fournit également la commande EVALSHA, qui peut mettre en cache la valeur SHA1 du script sur le serveur lors de l'exécution suivante du même script, il vous suffit de transmettre la valeur SHA1, ce qui réduit le temps de transmission réseau.

• (2) Opération atomique : le script Lua peut garantir l'atomicité de plusieurs commandes Redis et éviter les problèmes de concurrence.

• (3) Commandes personnalisées : grâce aux scripts Lua, vous pouvez étendre la collection de commandes Redis et implémenter des commandes personnalisées.

3. Scénarios d'application du script Redis Lua

• (1) Requête complexe : pour certaines exigences de requête complexes, le script Lua peut être utilisé pour l'implémenter rapidement, évitant ainsi les problèmes de traitement des données sur le client.

• (2) Logique de calcul : pour certains scénarios nécessitant une logique de calcul, même si aucune commande de calcul correspondante n'est fournie dans Redis, une logique de calcul personnalisée peut être implémentée via des scripts Lua.

• (3) Opération de transaction : le script Lua peut garantir l'atomicité d'un ensemble de commandes Redis, ce qui permet de mettre en œuvre des opérations de transaction sur Redis.

• (4) Statistiques en temps réel : le script Lua peut compter les données dans Redis en temps réel, telles que le calcul des UV, PV et autres données en temps réel.

4. Comment utiliser le script Redis Lua

Le script Redis Lua peut être exécuté via la commande EVAL ou la commande EVALSHA. La méthode d'utilisation spécifique est la suivante :

 EVAL script numkeys key [key ...] arg [arg ...] 
 EVALSHA sha1 numkeys key [key ...] arg [arg ...]

Où le script est le contenu du script Lua ; des opérations sont requises dans le script Lua Le nombre de paires clé-valeur ; key représente le nom de la valeur clé qui doit être utilisée ; arg représente le paramètre qui doit être utilisé dans le script Lua.

5. Script Lua utilisant Redis en Java

Enfin, intégrons-le en Java. Voici une démonstration de script Lua simple qui intègre Redis à Spring Boot et implémente les opérations CRUD de base,

5.1 Ajoutez des dépendances Redis et ajoutez les dépendances suivantes dans pom.xml :

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

5.2 Configurez les informations de connexion Redis dans l'application. configuration en .properties :

# Redis数据库地址 
spring.redis.host=127.0.0.1 
# Redis端口 
spring.redis.port=6379 
# Redis密码（如果没有密码不用填写） 
spring.redis.password=

5.3. Définir le script Redis Lua

L'utilisation de scripts Lua dans Redis nécessite d'abord de définir le script. Il existe deux façons de définir des scripts Lua dans Spring Boot :

• Utiliser des caractères dans la définition de chaîne de code.

• est défini dans RedisTemplate

Ici, nous utilisons la méthode de définition dans RedisTemplate et ajoutons le code suivant au bean de RedisTemplate :

 @Bean 
 public RedisScript<Long> redisScript() {
     RedisScript<Long> redisScript = new DefaultRedisScript<>(); 
     redisScript.setLocation(new ClassPathResource("lua/RedisCRUD.lua"));
     redisScript.setResultType(Long.class); 
     return redisScript; 
 }

Parmi eux, RedisCRUD.lua est le script Lua que nous voulons définir. script Utilisé pour implémenter les opérations CRUD de base.

5.4. Implémenter RedisService

Ensuite, nous devons implémenter RedisService pour faire fonctionner Redis, injecter RedisTemplate et redisScript dans RedisService, puis implémenter les opérations CRUD de base :

@Service 
public class RedisServiceImpl implements RedisService { 
    @Autowired 
    private RedisTemplate<String, Object> redisTemplate; 
    @Autowired 
    private RedisScript<Long> redisScript;
    
    public void set(String key, Object value) { 
        redisTemplate.opsForValue().set(key, value); 
    } 
    public Object get(String key) { 
        return redisTemplate.opsForValue().get(key); 
    } 
    public void delete(String key) { 
        redisTemplate.delete(key); 
    } 
    public Boolean exists(String key) { 
        return redisTemplate.hasKey(key); 
    } 
    public Long hset(String key, String field, Object value) { 
        return redisTemplate.opsForHash().put(key, field, value); 
    } 
    public Object hget(String key, String field) { 
        return redisTemplate.opsForHash().get(key, field); 
    } 
    public void hdelete(String key, String... fields) { 
        redisTemplate.opsForHash().delete(key, fields); 
    } 
    public Boolean hexists(String key, String field) {
        return redisTemplate.opsForHash().hasKey(key, field); 
    } 
    public Long eval(String script, List<String> keys, List<Object> args) { 
        return redisTemplate.execute(RedisScript.of(script), keys, args.toArray()); 
    } 
    public Long eval(List<String> keys, List<Object> args) { 
        return redisTemplate.execute(redisScript, keys, args.toArray()); 
    } 
 }

Ici, nous utilisons RedisTemplate Certaines méthodes. implémentez les opérations CRUD de base, ainsi que la méthode eval pour exécuter des scripts Lua personnalisés.

5.5. Écrire le script Redis Lua

Enfin, nous devons écrire le script RedisCRUD.lua. Ce script est utilisé pour implémenter les opérations CRUD de base :

-- set 
if KEYS[1] and ARGV[1] then 
redis.call('SET', KEYS[1], ARGV[1]) 
return 1 
end 
-- get 
if KEYS[1] and not ARGV[1] then 
return redis.call('GET', KEYS[1]) 
end 
-- delete 
if KEYS[1] and not ARGV[1] then 
redis.call('DEL', KEYS[1]) 
return 1 
end 
-- exists 
if KEYS[1] and not ARGV[1] then 
    if redis.call('EXISTS', KEYS[1]) == 1 then 
    return true 
    else 
    return false 
    end 
end 
-- hset 
if KEYS[1] and ARGV[1] and ARGV[2] and ARGV[3] then 
redis.call('HSET', KEYS[1], ARGV[1], ARGV[2]) 
redis.call('EXPIRE', KEYS[1], ARGV[3]) 
return 1 
end 
-- hget 
if KEYS[1] and ARGV[1] and not ARGV[2] then 
return redis.call('HGET', KEYS[1], ARGV[1]) 
end 
-- hdelete 
if KEYS[1] and ARGV[1] and not ARGV[2] then 
redis.call('HDEL', KEYS[1], ARGV[1]) 
return 1 
end 
-- hexists 
if KEYS[1] and ARGV[1] and not ARGV[2] then 
    if redis.call('HEXISTS', KEYS[1], ARGV[1]) == 1 then 
    return true 
    else 
    return false 
    end 
end

Dans ce script, nous définissons 8 opérations. :

• set : définir la valeur-clé

• get : obtenir la valeur correspondant à la clé

• delete : supprimer la valeur-clé

• exists : déterminer si la clé existe

• hset : Définir la valeur de champ de hachage A

• hget : Obtenir la valeur correspondant à un champ dans le hachage

• hdelete : Supprimer une valeur de champ dans le hachage

• hexists : Déterminer si un champ existe dans le hachage

5.6 Test RedisService

Enfin, nous écrivons une classe de test pour tester si RedisService peut fonctionner normalement. Voici l'exemple de code :

@RunWith(SpringRunner.class) 
@SpringBootTest 
public class RedisServiceImplTest { 
    @Autowired 
    private RedisService redisService; 
    @Test 
    public void test() {
        //第一种方式：执行string的lua
        redisService.eval("redis.call('SET', KEYS[1], ARGV[1])",Collections.singletonList(hashKey), Collections.singletonList(hashValue));
        //第二种方式：执行lua脚本
        String key ="key";
        String value ="value";
        redisService.eval(Collections.singletonList(hashKey), Collections.singletonList(hashValue));
    }

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!