Wie SpringBoot Spring Session integriert, um verteilte Sitzungen zu implementieren

Spring bietet eine Lösung für die Handhabung verteilter Sitzungen: Spring-Session. Spring-Session bietet Unterstützung für gängige Speicher wie Redis, MongoDB, MySQL usw. Spring-Session bietet eine transparente Integration mit HttpSession, was bedeutet, dass Entwickler die von Spring-Session unterstützte Implementierung verwenden können, um HttpSession auf Spring-Session umzustellen.

1. Konfiguration und Entwicklung

Schritt 1. Abhängigkeiten hinzufügen

Fügen Sie die Abhängigkeitspakete von Redis und Spring-Session in der pom.xml-Datei des Projekts hinzu.

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

Schritt 2. Konfigurieren Sie die Redis- und Spring-Session-Persistenzmethoden

Der Autor ist es gewohnt, application.properties als SpringBoot-Konfigurationsdatei zu verwenden, und Sie können sie auch mit application.yml konfigurieren. Fügen Sie die folgende Konfiguration in der Konfigurationsdatei application.properties hinzu.

# 配置 Redis 服务器地址（此处是一个虚假地址）
spring.redis.host=10.211.12.6
# 配置 Redis 端口
spring.redis.port=6379
# 配置 Redis 密码
spring.redis.password=123456
# 其他 Redis 的配置还有很多，例如 Redis 连接池的配置，此处暂时只配置上述几项关键点
# spring session 配置
spring.session.store-type=redis

Schritt 3. Verwenden Sie den JSON-Serialisierungsmechanismus

Spring-Session verwendet standardmäßig den JDK-Serialisierungsmechanismus, der Klassen zur Implementierung der serialisierbaren Schnittstelle erfordert. Nach der Serialisierung handelt es sich um ein binäres Byte-Array, das schwer zu verstehen ist. Mithilfe des JSON-Serialisierungsmechanismus ist die serialisierte Zeichenfolge leicht zu verstehen.

package com.test.conf;

import com.alibaba.fastjson.support.spring.GenericFastJsonRedisSerializer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.serializer.RedisSerializer;

// spring session 使用 json 序列化机制
@Configuration
public class SessionConfig {
    @Bean
    public RedisSerializer<Object> springSessionDefaultRedisSerializer() {
        return new GenericFastJsonRedisSerializer();
    }
}

Schritt 4. Fügen Sie die Annotation @EnableRedisHttpSession zur SpringBoot-Startklasse hinzu, um Spring-Session zu öffnen.

package com.test;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.session.data.redis.config.annotation.web.http.EnableRedisHttpSession;

@SpringBootApplication
// 开启 Spring-Session
@EnableRedisHttpSession
// @EnableRedisHttpSession(maxInactiveIntervalInSeconds = 1800, redisNamespace = "test:session")
public class TestSessionAppApplication {

    public static void main(String[] args) {
        SpringApplication.run(TestSessionAppApplication.class, args);
    }
}

Fügen Sie die Annotation @EnableRedisHttpSession hinzu, um Spring-Session zu öffnen. Die Annotation verfügt über mehrere Parameter, die individuell festgelegt werden können, darunter maxInactiveIntervalInSeconds für die Ablaufzeit der Sitzung. Der Standardwert beträgt 30 Minuten. redisNamespace stellt den Namespace dar, wenn die Sitzung in Redis gespeichert wird, dh das Schlüsselnamenpräfix der gespeicherten Sitzung In Redis ist der Standardwert „spring:session“. In tatsächlichen Projekten können verschiedene Systeme dasselbe Redis verwenden, um Ressourcen zu sparen. Um die Sitzungen verschiedener Systeme zu unterscheiden, kann für jedes System ein separater Namespace festgelegt werden. 2. Testen Öffnen Sie mit Google Chrome den Link http://localhost:9001/testSession. Der Server druckt das Protokoll wie unten gezeigt.

    @RequestMapping(value = "testSession")
    public String testSession(HttpServletRequest request) {
        HttpSession session = request.getSession();
        log.info("sessionId:[{}]", session.getId());
        session.setAttribute("name", "Lucy");
        session.setAttribute("age", "20");
        return session.getAttribute("name").toString();
    }

Der Client meldet sich beim Redis-Server an und zeigt den Sitzungsinhalt in Redis an.

sessionId:[5c417104-4f6d-430d-b569-cbc1e19cdf02]

Redis speichert drei Schlüsselwertpaare (im Folgenden als Schlüsselwert bezeichnet) für jede RedisSession:

Der erste Schlüsselwert speichert die ID dieser Sitzung, bei der es sich um eine Redis-Datenstruktur vom Typ Set handelt. Der letzte Wert 1658127780000 in diesem Schlüssel ist ein Zeitstempel, der auf der Grundlage des Sitzungsablaufzeitpunkts berechnet wird, der auf die nächste Minute übertragen wird.

Der zweite Schlüsselwert wird zum Speichern der detaillierten Informationen der Sitzung verwendet. Es handelt sich um eine Redis-Datenstruktur vom Hash-Typ, einschließlich der letzten Zugriffszeit der Sitzung (lastAccessedTime) und des Ablaufzeitintervalls (maxInactiveInterval, die Standardeinstellung). beträgt 30 Minuten, der hier gespeicherte Sekundenwert), die Erstellungszeit (creationTime), sessionAttr usw.

• Der dritte Schlüsselwert wird verwendet, um die Ablaufzeit der Sitzung in Redis darzustellen, und ist eine Redis-Datenstruktur vom Typ String. Dieser Schlüsselwert speichert keine nützlichen Daten, er dient lediglich zur Anzeige des Sitzungsablaufs. Die Ablaufzeit dieses Schlüssels in Redis ist das Ablaufzeitintervall der Sitzung. Mit dem Befehl ttl können Sie die Ablaufzeit des Schlüssels anzeigen, also die Ablaufzeit der Sitzung.

• Während dieses Tests sind die Datendetails in Redis wie folgt.

  [testuser@vm ~]$ redis-cli -h 10.211.12.6 -p 6379
  10.211.12.6:6379> auth 123456
  OK
  10.211.12.6:6379> keys *
  1) "spring:session:expirations:1658127780000"
  2) "spring:session:sessions:5c417104-4f6d-430d-b569-cbc1e19cdf02"
  3) "spring:session:sessions:expires:5c417104-4f6d-430d-b569-cbc1e19cdf02"

  Überprüfen Sie das Browser-Cookie. Zu diesem Zeitpunkt verwendet der Browser bereits ein Cookie, wie im Bild unten gezeigt.
Aktualisieren Sie den Browser, die im Backend gedruckte SessionId bleibt unverändert, der Sitzungsinhalt in Redis wird nicht hinzugefügt und der Browser gibt den Inhalt normal zurück. Dies bedeutet, dass der Sitzungsbetrieb dieses Knotens normal ist.
Öffnen Sie mit demselben Browser einen weiteren Testport-Link http://localhost:9002/testSession. Der Backend-Druckinhalt ist derselbe (die Ablaufzeit wurde aktualisiert). , was darauf hinweist, dass es sich bei den Clusterknoten um eine gemeinsame Sitzung handelt.
3. Nachteile von Spring-Session

Obwohl Spring-Session eine benutzerfreundliche, nahezu transparente Integrationsmethode bietet, die die Unterstützung von Cluster-Sitzungen trivial macht, weist Spring-Session tatsächlich einige Mängel auf.

Es ist unmöglich, Sitzungsablauf- und Zerstörungsereignisse in Echtzeit zu veröffentlichen.

Die Serialisierungsmethode unterstützt möglicherweise nicht sehr gut.

• Redis erfordert 3 Schlüssel zum Speichern eines Sitzungswerts. nimmt etwas mehr Platz ein;

• Da es sich bei der Sitzung nicht um eine CAS-Operation (Compare And Set) handelt, kann es zu Parallelitätsproblemen (geringfügige Probleme) kommen.

• Obwohl Spring-Session einige Mängel aufweist, ist es insgesamt immer noch sehr brauchbar. Darüber hinaus können Sie selbst eine Reihe von Filtern schreiben, um die Mängel der Spring-Session zu optimieren und verteilte Sitzungen zu implementieren.

Das obige ist der detaillierte Inhalt vonWie SpringBoot Spring Session integriert, um verteilte Sitzungen zu implementieren. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!