springBoot - springsession integrada para usar redis para lograr el intercambio de sesiones

Gire: https://www.cnblogs.com/mengmeng89012/p/5519698.html

Esta vez traigo el tutorial de spring boot + redis para lograr el intercambio de sesiones.

En la documentación de inicio de Spring, díganos que agreguemos @EnableRedisHttpSession para habilitar el soporte de sesión de Spring, la configuración es la siguiente:

Código Java

@Configuración
@EnableRedisHttpSession
clase pública RedisSessionConfig {
}

La anotación @EnableRedisHttpSession es proporcionada por spring-session-data-redis, así que agréguela al archivo pom.xml

Código Java

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

A continuación, debe configurar la ubicación del servidor redis en application.properties. Aquí, usamos la máquina:

Código Java

spring.redis.host = localhost
spring.redis.port = 6379

De esta manera, se completa el arranque de primavera + redis más simple para lograr el intercambio de sesiones, la siguiente prueba.

Primero, iniciamos dos servicios tomcat, los puertos son 8080 y 9090, establecidos en application.properties [dirección de descarga] :

Código Java

server.port = 8080

A continuación, defina un controlador:

Código Java

@RestController
@RequestMapping (value = "/ admin / v1")
público de clase {QuickRun
@RequestMapping (value = "/ first", method = RequestMethod.GET)
public Map <String, Object> firstResp (solicitud HttpServletRequest) {
Map <String, Object> map = new HashMap <> ();
request.getSession (). setAttribute ( "request Url", request.getRequestURL ());
map.put ( "URL de solicitud", request.getRequestURL ());
mapa de retorno;
}
@RequestMapping (value = "/ sessions", method = RequestMethod.GET)
Sesiones de objetos públicos (solicitud HttpServletRequest) {
Map <String, Object> map = new HashMap <> ();
map.put ( "sessionId", request.getSession (). getId ());
map.put ( "mensaje", request.getSession (). getAttribute ( "mapa"));
mapa de retorno;
}
}

Después del inicio de la prueba de acceso, primero visite el puerto tomcat 8080, regrese para obtener [dirección de descarga] :

Código Java

{ "URL de solicitud": "http: // localhost: 8080 / admin / v1 / first"}

A continuación, accedemos a las sesiones en el puerto 8080 y regresamos:

Código Java

{ "sessionId": "efcc85c0-9ad2-49a6-a38f-9004403776b5", "mensaje": "http: // localhost: 8080 / admin / v1 / first"}

Finalmente, visite las sesiones en el puerto 9090 y regrese:

Código Java

{ "sessionId": "efcc85c0-9ad2-49a6-a38f-9004403776b5", "mensaje": "http: // localhost: 8080 / admin / v1 / first"}

Se puede ver que los resultados devueltos por los dos servidores 8080 y 9090 son los mismos, compartiendo la sesión

Si accede al primer puerto 9090 en este momento, primero regrese:

Código Java

{ "URL de solicitud": "http: // localhost: 9090 / admin / v1 / first"}

Se devuelven las sesiones de ambos servidores:

Código Java

{ "sessionId": "efcc85c0-9ad2-49a6-a38f-9004403776b5", "mensaje": "http: // localhost: 9090 / admin / v1 / first"}

Es muy sencillo realizar sesiones compartidas a través de spring boot + redis, y también es muy útil. Con nginx para el equilibrio de carga, se pueden realizar aplicaciones distribuidas.

-------------------------------------------------- -----

Agregar caché

RedisCacheConfig

paquete com.lzw.core.configuration; 

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
importar org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
importar org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
importar org.springframework.context.annotation.Configuration;
importar org.springframework.data.redis.cache.RedisCacheManager;
importarorg.springframework.data.redis.connection.RedisConnectionFactory;
importar org.springframework.data.redis.core.RedisTemplate;
importar redis.clients.jedis.JedisPool;
importar redis.clients.jedis.JedisPoolConfig; 

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap; 

/ ** 
 * Creado por ZhenWeiLai el 2017/6/11. 
 * / 
@Configuration 
@EnableCaching 
clase pública  RedisCacheConfig   extiende CachingConfigurerSupport { 
    Logger logger = LoggerFactory.getLogger (RedisCacheConfig. Class ); 
    @Valor("$ {spring.redis.host}" )
     host de cadena privado ; 

    @Value ( "$ {spring.redis.port}" )
     puerto int privado  ; 
    @Value ( "$ {spring.redis.timeout}" )
     privado int timeout; 
    @Value ( "$ {spring.redis.pool.max-idle}" )
     private int maxIdle; 
    @Value ( "$ {spring.redis.pool.max-wait}" )
     privado largo maxWaitMillis; 
    @Value ( "$ {spring.redis.password}" )
     contraseña de cadena privada ;
 
 
 



    JedisPool redisPoolFactory () { 
        logger.info ( "JedisPool 注入 成功 ！！" ); 
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig (); 
        jedisPoolConfig.setMaxIdle (maxIdle); 
        jedisPoolConfig.setMaxWaitMillis (maxWaitMillis); 

        JedisPool jedisPool = nuevo JedisPool (jedisPoolConfig, host, puerto, tiempo de espera, contraseña); 

        volver jedisPool; 
    } 


    @Bean 
    public RedisTemplate <String, String> redisTemplate (RedisConnectionFactory cf) { 
        RedisTemplate <String, String> redisTemplate = new RedisTemplate <String, String>(); 
        RedisTemplate.setConnectionFactory (CF2); 
        retorno redisTemplate; 
    } 

    @Bean 
    pública la CacheManager CacheManager (RedisTemplate redisTemplate) { 
        RedisCacheManager CacheManager = nueva nueva RedisCacheManager (redisTemplate); 

        // tiempo predeterminado, en segundos 
        cacheManager.setDefaultExpiration (3000 );
         // Establezca el tiempo de espera de acuerdo con el nombre de la memoria caché, 0 significa que no hay tiempo de espera 
        Map <String, Long> expires = new ConcurrentHashMap <> (); 
        cacheManager.setExpires (expires); 

        return cacheManager; 
    } 
}

application.yml

spring: 
  datasource: 
# readSize: 1 
# name: writeDataSource 
    type: com.alibaba.druid.pool.DruidDataSource 
    write: 
      driver-class-name: com.mysql.jdbc.Driver 
      url: jdbc: mysql: // localhost: 3306 / cloud? useUnicode = true & characterEncoding = UTF-8 & zeroDateTimeBehavior = convertToNull &TransformatedBitIsBoolean = true & useSSL = 
      nombre de usuario verdadero : 
      contraseña de root : 123 
      initialSize: 10 
      maxActive: 100 
      maxWait: 60000 
      minIdle: 5 
      timeBetweenEvictionRunsMillis: 60000 
      minTillMillis: 60000 
      validationQuery: SELECT 'x'
      testWhileIdle: true 
      testOnBorrow: false 
      testOnReturn: false 
      poolPreparedStatements: true 
      maxPoolPreparedStatementPerConnectionSize: 20 

  #redis configuration 
  redis: 
    host: 192.168.1.11 
    port: 6379 
    # REDIS (RedisProperties) 
    # Índice de la base de datos de Redis (el valor predeterminado es 0) 
    base de datos del 
    servidor Redis : 0 # contraseña de conexión del servidor Redis (El valor predeterminado es vacío) 
    contraseña: 
    # número máximo de conexiones en el grupo de conexiones (use un valor negativo para indicar que no hay límite) 
    # tiempo de espera de conexión (milisegundos) 
    tiempo de espera: 0 
    grupo: 
      max-active: 8 
      # tiempo de espera de bloqueo máximo del grupo de conexiones (use un valor negativo para indicar Sin límite) 
      max-wait: -1 
      # La conexión inactiva más grande en el 
      max-idle: 8
      # La conexión inactiva mínima en el grupo de conexiones 
      min-idle: 0

blues_ygw

Publicado 7 artículos originales · 69 alabanzas · 200,000+ visitas

carta privada preocupaciones

springBoot - springsession integrada para usar redis para lograr el intercambio de sesiones

Supongo que te gusta