springBoot - sessão de molas integrada para usar redis para obter compartilhamento de sessão

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

Desta vez, trago o tutorial de boot de primavera + redis para obter o compartilhamento de sessões.

Na documentação de inicialização do Spring, diga-nos para adicionar @EnableRedisHttpSession para ativar o suporte à sessão do Spring, a configuração é a seguinte:

Código Java

@Configuração
@EnableRedisHttpSession
classe pública RedisSessionConfig {
}

A anotação @EnableRedisHttpSession é fornecida por spring-session-data-redis, portanto, adicione o arquivo pom.xml:

Código Java

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

Em seguida, você precisa configurar o local do servidor redis em application.properties.Aqui, usamos a máquina:

Código Java

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

Dessa maneira, a inicialização mais simples da primavera + o redis para obter o compartilhamento de sessões é concluída, o teste a seguir.

Primeiro, iniciamos dois serviços tomcat, as portas são 8080 e 9090, definidas em application.properties [endereço de download] :

Código Java

server.port = 8080

Em seguida, defina um controlador:

Código Java

@RestController
@RequestMapping (valor = "/ admin / v1")
classe pública QuickRun {
@RequestMapping (valor = "/ primeiro", método = RequestMethod.GET)
public Map <String, Object> firstResp (solicitação HttpServletRequest) {
Mapear <String, Objeto> map = new HashMap <> ();
request.getSession (). setAttribute ( "request Url", request.getRequestURL ());
map.put ( "URL de solicitação", request.getRequestURL ());
mapa de retorno;
}
@RequestMapping (valor = "/ sessões", método = RequestMethod.GET)
sessões de objeto público (solicitação HttpServletRequest) {
Mapear <String, Objeto> map = new HashMap <> ();
map.put ( " sessionId ", request.getSession (). getId ());
map.put ( "mensagem", request.getSession (). getAttribute ( "map"));
mapa de retorno;
}
}

Após o início do teste de acesso, visite primeiro a porta 8080 do tomcat, retorne para obter o [endereço de download] :

Código Java

{ "URL de solicitação": "http: // localhost: 8080 / admin / v1 / first"}

Em seguida, acessamos as sessões na porta 8080 e retornamos:

Código Java

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

Por fim, visite as sessões na porta 9090 e retorne:

Código Java

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

Pode-se observar que os resultados retornados pelos dois servidores 8080 e 9090 são os mesmos, compartilhando a sessão

Se você acessar a primeira porta 9090 neste momento, primeiro retorne:

Código Java

{ "URL de solicitação": "http: // localhost: 9090 / admin / v1 / first"}

As sessões dos dois servidores são retornadas:

Código Java

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

É muito simples realizar o compartilhamento de sessões através do boot inicial + redis, e também é muito útil.Com o nginx para balanceamento de carga, aplicativos distribuídos podem ser realizados.

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

Adicionar cache

RedisCacheConfig

pacote com.lzw.core.configuration; 

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
importar org.springframework.beans.factory.annotation.Value;
importar org.springframework.cache.CacheManager;
importar org.springframework.cache.annotation.CachingConfigurerSupport;
importar org.springframework.cache.annotation.EnableCaching;
importar 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;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig; 

importar java.util.Map;
importar java.util.concurrent.ConcurrentHashMap; 

/ ** 
 * Criado por ZhenWeiLai em 11/6/2017. 
 * / 
@Configuration 
@EnableCaching 
classe pública  RedisCacheConfig   estende CachingConfigurerSupport { 
    Logger do logger = LoggerFactory.getLogger (RedisCacheConfig. Class ); 
    @Valor("$ {spring.redis.host}" )
     private String host; 

    @Value ( "$ {spring.redis.port}" )
     private  int port; 

    @Value ( "$ {spring.redis.timeout}" )
     private  int timeout; 

    @Value ( "$ {spring.redis.pool.max-idle}" )
     private  int maxIdle; 

    @Value ( "$ {spring.redis.pool.max-wait}" )
     private  long maxWaitMillis; 

    @Value ( "$ {spring.redis.password}" )
     private String senha;


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

        JedisPool jedisPool = novo JedisPool (jedisPoolConfig, host, porta, tempo limite, senha); 

        return 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 a CacheManager CacheManager (RedisTemplate redisTemplate) { 
        RedisCacheManager CacheManager = new new RedisCacheManager (redisTemplate); 

        // tempo padrão, em segundos 
        cacheManager.setDefaultExpiration (3000 );
         // Defina o tempo limite de acordo com o nome do cache, 0 significa que nenhum tempo limite 
        Map <String, Long> expira = new ConcurrentHashMap <> (); 
        cacheManager.setExpires (expira); 

        retorne cacheManager; 
    } 
}

application.yml

Primavera: 
  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 & transformBitIsBoolean = true & useSSL = 
      nome de usuário verdadeiro : 
      senha raiz : 123 
      initialSize: 10 
      maxActive: 100 
      maxWait: 60000 
      minIdle: 5 
      timeBetweenEvictionRunsMillis: 60000  
      minEvictableIdleTimeMillis: 300000
      validation '
      testWhileIdle: true 
      testOnBorrow: false 
      testOnReturn: false 
      poolPreparedStatements: true 
      maxPoolPreparedStatementPerConnectionSize: 20 

  #redis configuração 
  redis: 
    host: 192.168.1.11 
    porta: 6379 
    # REDIS (RedisProperties) 
    # índice de banco de dados Redis (o padrão é 0) 
    senha de conexão do servidor Redis 
    : 0 # senha de conexão do servidor Redis (O padrão está vazio) 
    senha: 
    # número máximo de conexões no conjunto de conexões (use um valor negativo para indicar nenhum limite) 
    # tempo limite de conexão (milissegundos) 
    tempo limite: 0 
    pool: 
      max-ativo: 8 
      # tempo de espera máximo de bloqueio do conjunto de conexões (use um valor negativo para indicar Sem limite) 
      max-wait: -1 
      # A maior conexão inativa no 
      max-idle: 8
      # A conexão inativa mínima no pool de conexões 
      min-idle: 0

blues_ygw

Publicado 7 artigos originais · 69 elogios · mais de 200.000 visualizações

carta particular preocupações

springBoot - sessão de molas integrada para usar redis para obter compartilhamento de sessão

Acho que você gosta