Quelle est la méthode d’intégration de Redis dans le projet Java SpringBoot ?

Redis est entièrement open source, est conforme au protocole BSD et est une base de données clé-valeur hautes performances

Redis présente les trois caractéristiques suivantes avec d'autres produits de cache clé-valeur :

• Redis prend en charge la persistance des données. , Les données en mémoire peuvent être enregistrées sur le disque et peuvent être chargées à nouveau pour être utilisées lors du redémarrage.

• Redis prend non seulement en charge les données simples de type clé-valeur, mais fournit également le stockage de structures de données telles que la liste, l'ensemble, le zset et le hachage.

• Redis prend en charge la sauvegarde des données, c'est-à-dire la sauvegarde des données en mode maître-esclave.

Avantages de Redis

• Extrêmement hautes performances : Redis peut lire à 110 000 fois/s et écrire à 81 000 fois/s

• Types de données riches : Redis prend en charge les cas binaires String, List, Hash, Set et Opérations de type de données zset.

• Atomique - Toutes les opérations de Redis sont atomiques, ce qui signifie qu'elles sont exécutées avec succès ou pas du tout. Les opérations individuelles sont atomiques. Les opérations multiples prennent également en charge les transactions, c'est-à-dire l'atomicité, encapsulées par les instructions MULTI et EXEC.

• Fonctionnalités riches - Redis prend également en charge la publication/l'abonnement, les notifications, l'expiration des clés et d'autres fonctionnalités

• Redis est monothread et la version 6.0 prend en charge l'activation du multithread.

Installation de Redis

Décompressez le fichier compressé téléchargé. La liste des fichiers après décompression est la suivante :

Utilisez la fenêtre cmd pour ouvrir Redis

redis-server.exe   redis.windows.conf   #加载配置文件启动

注：启动之后，不要关闭窗口，关闭窗口服务停止！

.

Installation Redis client de base de données

Instructions liées à la bibliothèque :

flushdb  清空当前库

flushall  清空所有库

select   1    切换库

instructions liées aux clés

commande	fonction	syntaxe
del	Supprimer une ou plusieurs clés	del keyname
exists	Détermine si une ou plusieurs clés existent. S'il y a plusieurs clés, s'il en existe une, il renverra 1	exists keyname
expire	Définissez le. survie de la clé Unité de temps : secondes	expiration du nom de clé secondes
cléss	Requête de toutes les clés correspondant au modèle ? Faire correspondre un caractère * Faire correspondre les caractères 0-n [] Rencontrer l'un des	key * key h?llo
move	Déplacer la clé vers la bibliothèque spécifiée	déplacer le nom de clé db
pexpire	Définissez l'unité de temps de survie de la clé : millisecondes. Renvoyez 1 si le réglage est réussi, sinon renvoyez 0	pexpire keyname milliseconds
ttl	Renvoyer le temps de survie restant de la clé en secondes, retournez - 1 pour le stockage permanent, -2 signifie que la clé n'existe pas	ttl keyname
randomkey	Renvoie aléatoirement une clé de la base de données actuelle	randomkey
rename	Renommer la clé et return ok avec succès, sinon un message d'erreur est renvoyé.	renommer la clé newkey
type	Renvoyer le type de valeur stockée dans la clé	type keyname

Type de données Redis

1.String (string)

• string est le type de redis le plus basique, vous pouvez le comprendre as Le même type que Memcached, une clé correspond à une valeur.

• Le type de chaîne est binaire sûr. Cela signifie que la chaîne de redis peut contenir n'importe quelle donnée. Par exemple, des images jpg ou des objets sérialisés.

• Le type de chaîne est le type de données le plus basique de Redis. La valeur du type de chaîne peut stocker jusqu'à 512 Mo.

Instructions de fonctionnement :

Définir la valeur de la clé spécifiée#🎜🎜 ## 🎜🎜#GETGETRANGEGETSETSETEXSETNXRenvoie la longueur de la valeur de chaîne stockée dans la clé. Définissez une ou plusieurs paires clé-valeur en même temps. Définir une ou plusieurs paires clé-valeur simultanément, si et seulement si toutes sont données Le la clé spécifiée n'existe pasAugmentez la valeur numérique stockée dans la clé d'une unité#🎜 🎜 #INCRBYAjouter la valeur stockée dans la clé par l'incrément donné #🎜🎜 #Ajouter la valeur stockée dans la clé à la valeur d'incrément à virgule flottante donnée (incrément)# 🎜🎜## 🎜🎜#Diminuez d'une unité la valeur numérique stockée dans la clé. key La valeur stockée moins le décrément donné# 🎜🎜#APPEND2.Hash (Hash) Redis hash est une table de mappage de champs et de valeurs de type chaîne. Hash est particulièrement adapté au stockage d'objets.

Command	Description# 🎜🎜#
SET
Obtient la valeur de la clé spécifiée.
Renvoie le sous-caractère de la valeur de chaîne dans la clé #🎜 🎜#
Définit la valeur de la clé donnée sur value et renvoie l'ancienne valeur de la clé.
Associer la valeur à la clé et définir le délai d'expiration de la clé en secondes (en secondes).
Définissez la valeur de la clé uniquement lorsque la clé n'existe pas #🎜 🎜 #	STRLEN
	MSET
	MSETNX
	INCR
INCRBYFLOAT
DECR
DECRBY	# 🎜🎜#
Si la clé existe déjà et est une chaîne, la commande APPEND ajoutera la valeur spécifiée à la fin de la valeur d'origine de la clé
#🎜 🎜#Redis hash est une collection de Paires clé-valeur (clé => valeur).

Instructions de fonctionnement :

• Command
• Description# 🎜🎜#

hset

Définir une paire clé/valeurhgetObtenir la valeur correspondant à la cléhgetallObtenir toutes les clés/valeurs paires hdelSupprimer une paire clé/valeurhexists# 🎜🎜#hkeyshvalsObtenir toutes les valeurshmsetDéfinir plusieurs clés/valeurs#🎜 🎜#Obtenir la valeur de plusieurs clésDéfinir la valeur d'une clé inexistantehincrbyAjouter la valeur de value#🎜🎜 ##🎜🎜 #hincrbyfloatAjouter une opération de valeur de type virgule flottante à la valeur

3.List (List)

• La liste Redis est une simple liste de chaînes, triées par ordre d'insertion. Vous pouvez ajouter un élément en tête (à gauche) ou en queue (à droite) de la liste.

Commande d'opération

Juge si une clé existe
Obtenir toutes les clés	# 🎜 🎜#
	hmget
	hsetnx# 🎜🎜#

Command	Description
LINDEX	Récupérer les éléments de la liste par index 0
LINSÉRER la clé AVANT| APRÈS	Insérer des éléments avant ou après les éléments de la liste
LLEN	Obtenir la longueur de la liste
LPOP	Supprimer et obtenir le premier élément de la liste
LPUSH	Insérer une ou plusieurs valeurs en tête de liste
LPUSHX	Insérer une valeur en tête d'une existinglist
LRANGE	Obtenez les éléments dans la plage spécifiée de la liste (0 -1)
LREM	Supprimer les éléments en double de la liste
LSET	Définissez la valeur de l'élément de liste via l'index, mais l'index doit exister, l'essence est de modifier la valeur en fonction de l'index
LTRIM	Découper une liste, c'est-à-dire laisser la liste ne conserver que les éléments dans la plage spécifiée et les éléments en dehors de la plage spécifiée sera supprimé
RPOP	Supprimer Le dernier élément de la liste, la valeur de retour est l'élément supprimé
RPOPLPUSH	Supprimer le dernier élément de la liste et ajouter l'élément à une autre liste et retournez
RPUSH	Ajouter une ou plusieurs valeurs à la liste
RPUSHX	Ajouter une valeur à une liste existante

4.Set (set)

• Redis' Set est une collection non ordonnée de type chaîne.

• Les ensembles sont implémentés via des tables de hachage, donc la complexité de l'ajout, de la suppression et de la recherche est O(1).

Instructions d'utilisation :

Commande	Description
sadd	Ajouter des éléments à la collection
smembers	Affichage tous les éléments de la collection (aucun) Préface)
scard	Renvoyer le nombre d'éléments dans l'ensemble
spop	Renvoyer un élément au hasard et supprimer cet élément
smove	Déplacer des éléments d'un ensemble à un autre
srem	Supprimer un élément de l'ensemble
sismember	Déterminer si l'ensemble contient cet élément
srandmember	Renvoyer un élément au hasard
sinter	Trouver l'intersection
sunion	Ensemble de somme

5.ZSet (ensemble trié : ensemble ordonné)

• Redis ZSet Comme Set, c'est aussi une collection d'éléments de type String, et les membres en double ne sont pas autorisés.

• La différence est que chaque élément est associé à un score de type double. Redis utilise des scores pour trier les membres de l'ensemble du plus petit au plus grand. Les membres de

• ZSet sont uniques, mais les scores peuvent être répétés.

Commande d'opération :

Command	Description
zadd	Ajouter un élément d'ensemble ordonné
zcard	Renvoyer le numéro d'éléments dans l'ensemble
zrange Ascendant zrevrange décroissant	Renvoie des éléments dans une plage
zrangebyscore	Trouve des éléments dans une plage par score
zrank	Retour au classement
zrevrank	Flashback classement
zscore	Affichage le score d'un élément
zrem	Supprimer un élément
zincrby	Donner des points à un élément spécifique

SpringBoot 操作 Redis

  spring boot data redis中提供了RedisTemplate和StringRedisTemplate，其中StringRedisTemplate是Redistemplate的子类，两个方法基本一致，不同之处主要体现在操作的数据类型不同，RedisTemplate中的两个泛型都是Object，意味着存储的key和value都可以是一个对象，而StringRedisTemplate的两个泛型都是String，意味着StringRedisTemplate的key和value都只能是字符串。

引入依赖

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

SpringBoot 配置 Redis

spring:
  redis:
    # Redis数据库索引（默认为0）
    database: 0
    # Redis服务器地址
    host: 127.0.0.1
    # Redis服务器连接端口
    port: 6379
    # Redis服务器连接密码（默认为空）
    password:
    # 连接池最大连接数（使用负值表示没有限制）
    jedis.pool.max-active: 20
    # 连接池最大阻塞等待时间（使用负值表示没有限制）
    jedis.pool.max-wait: -1
    # 连接池中的最大空闲连接
    jedis.pool.max-idle: 10
    # 连接池中的最小空闲连接
    jedis.pool.min-idle: 0
    # 连接超时时间（毫秒）
    timeout: 1000

RedisTemplate 及其相关方法

1.RedisTemplate 介绍

  Spring封装了RedisTemplate对象来进行对Redis的各种操作，它支持所有的Redis原生的api。RedisTemplate位于spring-data-redis包下。RedisTemplate提供了redis各种操作、异常处理及序列化，支持发布订阅。

2.Redis 5种数据结构操作

• redisTemplate.opsForValue(); //操作字符串

• redisTemplate.opsForHash(); //操作hash

• redisTemplate.opsForList(); //操作list

• redisTemplate.opsForSet(); //操作set

• redisTemplate.opsForZSet(); //操作有序set

或者：

• redistempalate.boundValueOps

• redistempalate.boundSetOps

• redistempalate.boundListOps

• redistempalate.boundHashOps

• redistempalate.boundZSetOps

 opsForXXX和boundXXXOps的区别：XXX为value的类型，前者获取一个operator，但是没有指定操作的对象（key），可以在一个连接（事务）内操作多个key以及对应的value；后者获取了一个指定操作对象（key）的operator，在一个连接（事务）内只能操作这个key对应的value。

 SpringBootTest 实现Redis数据库增删改查

/**
 * 使用RedisTemplate 操作Redis数据的不同数据类型
 */
@SpringBootTest
public class Springbootday03ApplicationTests {
    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    /**
     * String 类型数据操作
     */
    @Test
    public void operateString() {

        //添加值
        redisTemplate.opsForValue().set("str", "strValue1");

        //添加值  判定是否存在 存在则不添加
        Boolean aBoolean = redisTemplate.opsForValue().setIfAbsent("str", "strAbsent");
        System.out.println("str设置成功:" + aBoolean);

        //获取值
        String str = redisTemplate.opsForValue().get("str");
        System.out.println("str = " + str);

        //更新值
        redisTemplate.opsForValue().set("str", "strValue2");
        str = redisTemplate.opsForValue().get("str");
        System.out.println("newStr = " + str);

        //删除值
        Boolean b = redisTemplate.delete("str");
        System.out.println("str删除成功：" + b);

    }

    /**
     * 操作string类型数据  设置过期时间
     */
    @Test
    public void operateString2() {
        redisTemplate.opsForValue().set("str", "strTimeout", 10, TimeUnit.SECONDS);
        //判定值是否存在 不存在则设置值 同时设置过期时间
        Boolean aBoolean = redisTemplate.opsForValue().setIfAbsent("str2", "strTimeoutAbsent", 20, TimeUnit.SECONDS);
        System.out.println("setIfAbsent:" + aBoolean);
    }

    /**
     * 操作hash类型数据
     */
    @Test
    public void operateHash() {
        //添加hash类型数据  key - value
        redisTemplate.opsForHash().put("hash", "username", "admin");
        //修改hash类型数据
        redisTemplate.opsForHash().put("hash", "username", "tom");
        redisTemplate.opsForHash().put("hash", "password", "123456");

        //添加hash类型数据  key - map
        HashMap<String, String> map = new HashMap<>();
        map.put("driverName", "com.mysql.jdbc.Driver");
        map.put("url", "jdbc:mysql://localhost:3306/mybatis?serverTimezone=UTC");
        redisTemplate.opsForHash().putAll("hash", map);

        //获取hash类型数据  entries
        Map<Object, Object> hash = redisTemplate.opsForHash().entries("hash");
        hash.forEach((key, value) -> {
            System.out.println(key + "::" + value);
        });

        //获取所有的key
        Set<Object> keys = redisTemplate.opsForHash().keys("hash");
        for (Object key : keys) {
            System.out.println("key:" + key);
        }
        //获取所有value
        List<Object> values = redisTemplate.opsForHash().values("hash");
        values.forEach(value -> System.out.println("value:" + value));

        //删除hash类型数据  删除一个  返回删除的个数
        Long delete = redisTemplate.opsForHash().delete("hash", "username");
        System.out.println("delete = " + delete);

        //删除hash类型数据  删除多个  返回删除的个数
        delete = redisTemplate.opsForHash().delete("hash", "username", "password", "driverName");
        System.out.println("delete = " + delete);

        //删除hash类型数据  删除所有
        Boolean delHash = redisTemplate.delete("hash");
        System.out.println("delHah:" + delHash);

    }

    /**
     * 操作List类型  有序 可重复
     */
    @Test
    public void operateList() {

        //左压栈
        // redisTemplate.opsForList().leftPush("list", "listValue1");
        // redisTemplate.opsForList().leftPush("list", "listValue1");
        // redisTemplate.opsForList().leftPush("list", "listValue2");
        // redisTemplate.opsForList().leftPush("list", "listValue3");

        //右压栈
        redisTemplate.opsForList().rightPush("list", "listValue0");
        redisTemplate.opsForList().rightPush("list", "listValue2");
        redisTemplate.opsForList().rightPush("list", "listValue0");

        //左出栈
        String list1 = redisTemplate.opsForList().leftPop("list");
        System.out.println("leftPop list1 = " + list1);
        //右出栈
        String list2 = redisTemplate.opsForList().rightPop("list");
        System.out.println("rightPop list2 = " + list2);

        //获取所有数据
        List<String> lists = redisTemplate.opsForList().range("list", 0, 		        redisTemplate.opsForList().size("list") - 1);
        lists.forEach(list -> System.out.println(list));


        //设置指定位置的数据
        redisTemplate.opsForList().set("list", 0, "listValue0");
        /**
         * 从存储在键中的列表中删除等于值的元素的第一个计数事件。
         * count> 0：删除等于从左到右移动的值的第一个元素；
         * count< 0：删除等于从右到左移动的值的第一个元素；
         * count = 0：删除等于value的所有元素。
         */
        Long remove = redisTemplate.opsForList().remove("list", -1, "listValue0");
        System.out.println("remove:" + remove);

        //删除指定key的list数据
        Boolean list = redisTemplate.delete("list");
        System.out.println("list集合删除成功:" + list);
    }

    /**
     * 操作Set类型  无序 不可重复
     */
    @Test
    public void operateSet() {

        //设置set值
        redisTemplate.opsForSet().add("set", "setValue0");
        redisTemplate.opsForSet().add("set", "setValue0");
        redisTemplate.opsForSet().add("set", "setValue1");

        //判定是否包含
        Boolean member = redisTemplate.opsForSet().isMember("set", "setValue0");
        System.out.println("isMember:" + member);

        //删除set中的值
        Long remove = redisTemplate.opsForSet().remove("set", "setValue0");
        System.out.println("remove = " + remove);

        //获取set类型值
        Set<String> set = redisTemplate.opsForSet().members("set");
        set.forEach(str -> {
            System.out.println("str = " + str);
        });
    }

    /**
     * 操作 ZSet  有序 不可重复
     */
    @Test
    public void operateZSet() {
        //存储值
        Boolean add = redisTemplate.opsForZSet().add("zset", "zsetValue0", 10);
        System.out.println("add = " + add);
        System.out.println("add = " + add);
        add = redisTemplate.opsForZSet().add("zset", "zsetValue2", 2);
        System.out.println("add = " + add);
        //获取值
        // Boolean zset = redisTemplate.delete("zset");
        // System.out.println("delete zset = " + zset);
    }
}

Redis工具类的封装

/**
 * Redis 工具类
 * @author mosin
 * date 2021/11/30
 * @version 1.0
 */
@Component
public final class RedisUtil {

    private RedisUtil(){};
    @Autowired
    private RedisTemplate<String,String> redisTemplate;

    //设置值
    public void  setValue(String key,String value){
        redisTemplate.opsForValue().set(key, value);
    }
    // 设置值 同时设置有效时间
    public void setValue(String key, String value, Long timeOut, TimeUnit timeUnit){
        redisTemplate.opsForValue().setIfAbsent(key, value, timeOut, timeUnit);
    }

    //设置值 没有则设置 有则不设置
    public void  setNx(String key,String value){
        redisTemplate.opsForValue().setIfAbsent(key, value);
    }

    //设置值 没有则设置 同时设置有效时间 有则不设置
    public void  setNx(String key,String value,long timeOut,TimeUnit timeUnit){
        redisTemplate.opsForValue().setIfAbsent(key, value,timeOut,timeUnit);
    }

    //删除值
    public boolean del(String key){
        return redisTemplate.delete(key);
    }
    
     //获取值
    public String getValue(String key){
        return  redisTemplate.opsForValue().get(key);
    }
}

Redis 业务实践

redis 存储 token，实现非法请求拦截

1.编写拦截器

@Component
public class AdminInterceptor implements HandlerInterceptor {
    @Autowired
    private RedisUtil redisUtil;
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("拦截器以拦截请求");
        //从请求头中获取token  验证用户是否登录
        String token = request.getHeader("token");
        System.out.println(token);
        String tokenValue = redisUtil.getValue(token);
        System.out.println("tokenValue = " + tokenValue);
        if(tokenValue!=null){ //用户已登录 放行请求
            return  true;
        }else{//重定向到登录页面
            response.sendRedirect(request.getContextPath()+"/login.jsp");
            return false;
        }
    }
}

2.配置拦截器

@Configuration
public class LoginConfig implements WebMvcConfigurer {
    @Autowired
    private AdminInterceptor adminInterceptor;
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        InterceptorRegistration registration = registry.addInterceptor(adminInterceptor);
        registration.addPathPatterns("/**");
        registration.excludePathPatterns("/user/login","/user/register","/login.jsp");
    }
}

3.编写统一返回数据格式类

@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
public class JsonResult<T> {
    private Integer code;
    private String msg;
    private Long count;
    private T data;
}

4.编写控制器

@Controller
@RequestMapping("/user")
public class UserController {
    @Autowired
    private UserService userService;
    @Autowired
    private RedisUtil redisUtil;
    @ResponseBody
    @RequestMapping("/login")
    public Object login(User user) throws JsonProcessingException {
        User usr = User.builder().id(1).name("admin").password("123456").build();
        //获取token  放入redis
        String token = UUID.randomUUID().toString().replace("-", "");
        //将user 转为json格式放入 redis
        ObjectMapper objectMapper = new ObjectMapper();
        String s1 = objectMapper.writeValueAsString(usr);
        //将 token 和用户信息存入 redis
        redisUtil.setValue(token, s1, 2L, TimeUnit.MINUTES);
        //将token 存入map集合返回
        HashMap<String, String> map = new HashMap<>();
        map.put("token", token);
        return map;
    }

    @ResponseBody
    @RequestMapping("/register")
    public Object register(User user){
        HashMap<String, String> map = new HashMap<>();
        map.put("msg", "ok");
        return map;
    }

    @ResponseBody
    @RequestMapping("/add")
    public Object add(User user){
        HashMap<String, String> map = new HashMap<>();
        map.put("msg", "ok");
        return map;
    }
}

5.编写业务类和Mapper接口

6.使用postman接口测试工具测试接口

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!