Was ist die Methode zur Integration von Redis in ein Java-SpringBoot-Projekt?

Redis ist vollständig Open Source, entspricht dem BSD-Protokoll und ist eine leistungsstarke Schlüsselwertdatenbank.

Redis weist im Vergleich zu anderen Schlüsselwert-Cache-Produkten die folgenden drei Merkmale auf:

• Redis unterstützt die Datenpersistenz , Die Daten im Speicher können auf der Festplatte gespeichert und zur Verwendung bei einem Neustart erneut geladen werden.

• Redis unterstützt nicht nur einfache Daten vom Typ Schlüsselwert, sondern bietet auch die Speicherung von Datenstrukturen wie Liste, Menge, Zset und Hash.

• Redis unterstützt die Datensicherung, also die Datensicherung im Master-Slave-Modus.

Vorteile von Redis

• Extrem hohe Leistung – Redis kann mit 110.000 Mal/s lesen und mit 81.000 Mal/s schreiben zset-Datentypoperationen.

• Atomic – Alle Operationen von Redis sind atomar, was bedeutet, dass sie entweder erfolgreich oder überhaupt nicht ausgeführt werden. Einzelne Operationen sind atomar. Mehrere Operationen unterstützen auch Transaktionen, d. h. Atomizität, die durch die Anweisungen MULTI und EXEC umschlossen werden.

• Reichhaltige Funktionen – Redis unterstützt auch Veröffentlichung/Abonnement, Benachrichtigungen, Schlüsselablauf und andere Funktionen.

• Redis ist Single-Threaded und Version 6.0 unterstützt die Aktivierung von Multithreading.

• Redis-Installation

Entpacken Sie die heruntergeladene komprimierte Datei:

Verwenden Sie das cmd-Fenster, um Redis zu öffnen

Installation Redis Datenbank-Client

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

Bibliotheksbezogene Anweisungen:

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

schlüsselbezogene Anweisungen

Befehl

Funktion Syntax delLöschen Sie einen oder mehrere Schlüssel Bestimmt, ob ein oder mehrere Schlüssel vorhanden sind. Falls einer vorhanden ist, wird 1 zurückgegeben. Legen Sie fest Überleben des Schlüssels Zeiteinheit: SekundenSchlüsselname Sekunden ablaufen lassensAlle Schlüssel abfragen, die dem Muster entsprechen? Übereinstimmung mit einem Zeichen * Übereinstimmung mit 0-n Zeichen [] Treffen Sie einen der key * key halloVerschieben Sie den Schlüssel in die angegebene Bibliothekmove keyname dbLegen Sie die Überlebenszeiteinheit des Schlüssels fest: Millisekunden. Geben Sie 1 zurück, wenn die Einstellung erfolgreich ist. Andernfalls geben Sie 0 zurück. 1 für permanente Speicherung, -2 bedeutet, dass der Schlüssel nicht existiert return ok erfolgreich, andernfalls wird eine Fehlermeldung zurückgegeben. Schlüssel in neuen Schlüssel umbenennenDen im Schlüssel gespeicherten Werttyp zurückgebenSchlüsselname eingeben

Redis-Datentyp

1.String (String)

• String ist der grundlegendste Typ von Redis. Sie können ihn als genau den gleichen Typ verstehen wie Memcached. Ein Schlüssel entspricht einem Wert.

• String-Typ ist binärsicher. Dies bedeutet, dass die Zeichenfolge von Redis beliebige Daten enthalten kann. Zum Beispiel JPG-Bilder oder serialisierte Objekte.

• Der String-Typ ist der grundlegendste Datentyp von Redis. Der String-Typ-Wert kann bis zu 512 MB speichern.

Bedienungsanweisungen:

del keyname		exists
exists keyname	expire
	Schlüssel
	move
	pexpire
	Typ

Befehl	Beschreibung
SET	Legen Sie den Wert des angegebenen Schlüssels fest
GET	Den Wert des angegebenen Schlüssels abrufen .
GETRANGE	Gibt die Unterzeichen des Zeichenfolgenwerts im Schlüssel zurück.
GETSET	Setzt den Wert des angegebenen Schlüssels auf Wert und gibt den alten Wert des Schlüssels zurück.
SETEX	Ordnet den Wert dem Schlüssel zu und legt die Ablaufzeit des Schlüssels auf Sekunden (in Sekunden) fest.
SETNX	Legt den Wert des Schlüssels nur fest, wenn der Schlüssel nicht existiert.
STRLEN	Gibt die Länge des im Schlüssel gespeicherten Zeichenfolgenwerts zurück.
MSET	Legen Sie ein oder mehrere Schlüssel-Wert-Paare gleichzeitig fest.
MSETNX	Legen Sie ein oder mehrere Schlüssel-Wert-Paare gleichzeitig fest, genau dann, wenn nicht alle angegebenen Schlüssel vorhanden sind.
INCR	Erhöhen Sie den im Schlüssel gespeicherten numerischen Wert um one
INCRBY	Addieren Sie den im Schlüssel gespeicherten Wert um das angegebene Inkrement.
INCRBYFLOAT	Addieren Sie den im Schlüssel gespeicherten Wert um das angegebene Gleitkomma-Inkrement (Inkrement)
DECR	dekrementieren Sie den im Schlüssel gespeicherten numerischen Wert um eins.
DECRBY	Der im Schlüssel gespeicherte Wert abzüglich der angegebenen Dekrementierung.
APPEND	Wenn der Schlüssel bereits vorhanden ist und eine Zeichenfolge ist, gibt der Befehl APPEND den Wert an. Anhängen an das Ende des Originals Wert des Schlüssels

2.Hash (Hash)

• Redis-Hash ist eine Reihe von Schlüssel-Wert-Paaren (Schlüssel=>Wert).

• Redis-Hash ist eine Zuordnungstabelle für Felder und Werte vom Typ Zeichenfolge. Hash eignet sich besonders zum Speichern von Objekten.

Bedienungsanweisungen:

Befehl

Beschreibung

hset

Legen Sie ein Schlüssel/Wert-Paar fest

hget

Ge t der Wert, der dem Schlüssel

hgetall entspricht

Alle Schlüssel/Wert-Paare abrufen

hdel

Ein Schlüssel/Wert-Paar löschen

hexists

Bestimmen, ob ein Schlüssel vorhanden ist

hkeys

Alle Schlüssel abrufen

hvals

Alle Werte abrufen

hmset

Mehrere Schlüssel/Werte festlegen

hmget

Den Wert mehrerer Schlüssel abrufen

hsetnx

Den Wert eines nicht vorhandenen Schlüssels festlegen

hincrby

führt die Additionsoperation für den Wert von value durch.

hincrbyfloat

3.List (Liste)

• Die Redis-Liste ist eine einfache Liste von Zeichenfolgen, sortiert in Einfügungsreihenfolge. Sie können ein Element am Kopf (links) oder am Ende (rechts) der Liste hinzufügen.

Operationsbefehl

Holen die Elemente innerhalb des angegebenen Bereichs der Liste (0 -1)Entfernen Sie doppelte Elemente aus der ListeLegen Sie den Wert des Listenelements über den Index fest, aber Der Index muss vorhanden sein. Das Wesentliche besteht darin, den Wert entsprechend dem Index zu ändern wird gelöschtEntfernen Das letzte Element der Liste, der Rückgabewert ist das entfernte Element Entfernen Sie das letzte Element der Liste und fügen Sie das Element einer anderen Liste hinzu und zurück Füge einen oder mehrere Werte zur Liste hinzuFüge einen Wert zu einer vorhandenen Liste hinzuRedis' Set ist eine ungeordnete Sammlung vom Typ String. Bedienungsanweisungen: BefehlBeschreibung

Befehl	Beschreibung
LINDEX	Rufen Sie die Elemente in der Liste nach Indexlisten ab 0
LINSERT-Taste VORHER| NACH	Fügen Sie Elemente vor oder nach den Elementen der Liste ein
LLEN	Ermitteln Sie die Länge der Liste
LPOP	Entfernen Sie und erhalten Sie das erste Element der Liste
LPUSH	Fügen Sie einen oder mehrere Werte in den Kopf der Liste ein
	LREM
LSET
RPOP
RPOPLPUSH
RPUSH
RPUSHX
4.Set (set)
Sets werden durch Hash-Tabellen implementiert, sodass die Komplexität des Hinzufügens, Löschens und Suchens O(1) ist.

hinzufügen

• Elemente zur Sammlung hinzufügen

• Mitglieder

Alle anzeigen Elemente in der Sammlung (keine) Vorwort)

scard Gibt die Anzahl der Elemente im Satz zurückspopGibt ein Element zufällig zurück und löscht dieses ElementsmoveElemente von einem Satz in einen anderen verschiebensrem Entferne ein Element aus der Menge Summensatz 5.ZSet (sortierte Menge: geordnete Menge) Redis ZSet Wie SetStringdoppelteRedis verwendet Scores, um die Mitglieder der Menge von klein nach groß zu sortieren. Die Mitglieder von ZSet sind einzigartig, aber die Ergebnisse können wiederholt werden. BefehlBeschreibungzaddEin bestelltes Set-Element hinzufügen

handelt es sich auch um eine Sammlung von Elementen vom Typ	, und doppelte Mitglieder sind nicht zulässig.
Der Unterschied besteht darin, dass jedem Element eine	Typbewertung zugeordnet ist.
	Betriebsbefehl:

zcard

• Return the Anzahl der Elemente im Set zrange Aufsteigend zrevrange absteigend Elemente in einem Bereich zurückgeben

• zrangebyscore Elemente in einem Bereich nach Punktzahl suchen

zrank

• Rangliste zurückgeben

zrevrank

Flashback-Rangliste

zscoreAnzeige die Punktzahl eines ElementszremEin Element entfernenZinkbyGib einem bestimmten Element Punkte

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接口测试工具测试接口

Das obige ist der detaillierte Inhalt vonWas ist die Methode zur Integration von Redis in ein Java-SpringBoot-Projekt?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!