Redis pode armazenar o mapeamento entre chaves e 5 diferentes tipos de estruturas de dados, estes cinco tipos de estruturas de dados são String (String), List (lista), o conjunto (set), o Hash (haxixe) e zset (ordenada coleção)
Cadeia pode ser uma cadeia de caracteres, inteiros ou de ponto flutuante para toda a cadeia ou cadeias em que a parte de realizar a operação, e um incremento alvo execução de ponto flutuante (incremento) ou diminuir (decremento)
Lista de uma lista ligada, cada nó na lista contém um empurrão ou um elemento pop-up nas extremidades da corda da lista; lista de acordo com a guarnição offset (TRIM); Ler um único ou uma pluralidade de elementos; O valor Localizar ou remover elementos
Definido que compreende um coletor de sequência aleatória (unorderedcollection), e cada cadeia de caracteres está contido é original, diferente Adicione, Obter, remover os elementos individuais; verificar se existe um elemento de um conjunto; cálculo intersecção, união, diferença; começa a mostrar a partir da coleção de elementos aleatórios
tabela hash de hash contém pares chave-valor não ordenadas para adicionar, obter, remover um único pares chave-valor; obter todos os pares chave-valor
mapeamento Zset entre membro ordenada cadeia (membro) e contagem de ponto flutuante (Score), os elementos são adicionados pela ordem determinada pelo tamanho pontuação, aquisição, excluir um único elemento, de acordo com o intervalo de valores (gama) ou membros Obtém o elemento
Nota: feijão Java para serializar
1. A dependência das importações
// Gradle
grupo de compilação: 'org.springframework.boot', name: 'primavera-Boot-arranque-data-Redis', versão: '2.1.3.RELEASE'
// pom
<Dependency>
<GroupId> org.springframework.boot </ groupId>
<ArtifactId> Primavera-Boot-autor-data-Redis </ artifactId>
<Version> 2.1.3.RELEASE </ version>
</ Dependency>
1
2
3
4
5
6
7
8
9
2. Configure Redis
redis.config
@Configuração
classe pública RedisConfig {
// usado para resolver o problema, em seguida, os redis operacionais seqüência de anotação
@Bean (nome = "myCacheManager")
pública CacheManager CacheManager (RedisConnectionFactory redisConnectionFactory) {
RedisCacheWriter redisCacheWriter = RedisCacheWriter.nonLockingRedisCacheWriter (redisConnectionFactory);
RedisSerializer <Object> jsonSerializer = new GenericJackson2JsonRedisSerializer ();
RedisSerializationContext.SerializationPair <Object> par = RedisSerializationContext.SerializationPair
.fromSerializer (jsonSerializer);
RedisCacheConfiguration defaultCacheConfig = RedisCacheConfiguration.defaultCacheConfig ()
.serializeValuesWith (par);
defaultCacheConfig.entryTtl (Duration.ofMinutes (30));
retornar nova RedisCacheManager (redisCacheWriter, defaultCacheConfig);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/ **
* Resolver o problema com a sequência de operações redisTemplate
*
* RedisConnectionFactory fábrica @param
* @Return redisTemplate
* /
@Feijão
@ConditionalOnMissingBean (nome = "redisTemplate")
pública RedisTemplate <String, Object> redisTemplate (fábrica RedisConnectionFactory) {
// Configure redisTemplate
RedisTemplate <String, Object> redisTemplate = new RedisTemplate <> ();
redisTemplate.setConnectionFactory (de fábrica);
// serialização chave
redisTemplate.setKeySerializer (STRING_SERIALIZER);
// serialização valor
redisTemplate.setValueSerializer (JACKSON__SERIALIZER);
// serialização chave Hash
redisTemplate.setHashKeySerializer (STRING_SERIALIZER);
// serialização valor Hash
redisTemplate.setHashValueSerializer (JACKSON__SERIALIZER);
redisTemplate.afterPropertiesSet ();
voltar redisTemplate;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
configuração de classe de inicialização
@EnableCaching // operação de cachê permite anotação
@SpringBootApplication
ShoppingMallApplication classe pública {
public static void main (String [] args) {
SpringApplication.run (ShoppingMallApplication.class, args);
}
}
1
2
3
4
5
6
7
arranjo application.yml
#redis cache de configuração
repetir:
banco de dados: 0
host: @ip
porta: 6379
timeout: 8000
# Se não houver tempo para escrever
senha:
Jedis:
piscina:
# Número máximo do conjunto de conexões de conexões
max-activa: 10
# Piscina tempo máximo de bloqueio Connection
max-espera: -1
# As conexões ociosas mínimo pool de conexão
min-inactivo: 0
# conexões ociosas piscina máxima de conexão
max-idle: 8
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
3. introdução comentário Cache
O resultado da operação do cache de método, mais tarde, para os mesmos dados, cacheNames de acesso e chave diretamente do cache deve preencher, se você não preencher a chave, chave padrão é o nome do método atual, porque diferentes métodos foram atualizados ao atualizar o cache falha
valor: Especifica o nome do cache pode especificar uma pluralidade (matriz)
chave: cache de dados-chave utilizados para os parâmetros do método padrão apoiar SPEL
KeyGenerator: gerador de chaves
CacheManager: Especifica o Gerenciador de cache, ou para obter um analisador, tanto segunda eleição
condição: o cache condição especificada
a menos que: Negativo menos cache quando a condição for verdadeira, o valor de retorno não será armazenada em cache, os resultados de julgamento podem ser adquiridos.
sync: se assíncrona não são suportadas a menos
@Cacheable (cacheNames = "xxx", key = "xxx")
1
Ambos os métodos são invocados para atualizar um conjunto de dados Caché modificar o banco de dados ao atualizar o cache, primeiro chamar o método de destino terá como alvo métodos em cache, à atenção de atualizações, ea chave para consultar ao mesmo tempo, caso contrário, o cache não é atualizado, a propriedade e @Cacheable mesmo
@CachePut (cacheNames = "xxx", key = "xxx")
1
cache de exclusão
allEntries: apagar todos os campos em cache
beforeInvocation: se antes do método
@CacheEvict (cacheNames = "xxx",-chave = "xxx")
1
@CacheConfig
Você pode especificar a estratégia de geração de chave pública
cacheNames Pública (valor) pode ser escrito em uma classe unificada acima não cobrem todos os cache em um nome ainda
CacheManager pública
@CacheConfig (cacheNames = "produto")
ProductInfoController classe pública {
@Caching (cacheável = {} @Cacheable, put = {@CachePut})
pública Response <Map <String, Object >> buyProduct () {
// Para fazer sthing
}
}
1
2
3
4
5
6
7
8
Chave pode ser definida como um método parâmetro dinâmico (suporte EL)
@Cacheable (cacheNames = "xxx", key = "#openid")
pública ResultVO <OrderDTO> detalhe (@RequestParam ( "OpenID") Cordas OpenID) {
// fazer sthing
}
1
2
3
4
comentário Composite
Ir para atualizar dados no cache quando os dados de consulta //
Zhengzhou hospitalar infertilidade: http: //www.zzchyy110.com/
@Caching (cacheável = {} @Cacheable, put = {@CachePut})
@Caching (cacheável = {} @Cacheable, put = {} @CachePut, despejar = {@CacheEvict})
1
2
4. Teste
Notes versão:
@CacheConfig (cacheNames = "-productInfo shopping") // nome personalizado
ProductInfoController classe pública {
// uso simples
@Caching (cacheável = {} @Cacheable, put = {@CachePut})
pública Response <Map <String, Object >> getAllInfoById (@ApiParam ( "商品 id") @RequestParam Integer id) {
// fazer sthing
}
}
1
2
3
4
5
6
7
8
Redistemplate 版:
@Autowired
RedisTemplate redisTemplate privado;
@Teste
demonstração public void () {
// Redis tipo comum de dados manipulação conjunto zset não listados
// tipo de dados de cadeia
redisTemplate.opsForValue () conjunto ( "teste", "123").;
redisTemplate.opsForValue (). get ( "test") // saída é 123
// lista de tipos de dados
. RedisTemplate.opsForList () rightPushAll ( "lista", nova String [] { "1", "2", "3"}); // inserir elementos da direita
. RedisTemplate.opsForList () range ( "list", 0, -1); // obter todos os elementos
. RedisTemplate.opsForList () índice ( "listRight", 1); // Obter elemento subscrito 2
. RedisTemplate.opsForList () rightPush ( "listRiht", "1"); // também ser inserida a partir do lado direito e esquerdo interpolado
redisTemplate.opsForList () leftPop ( "list") ;. // elementos pop dos elementos pop esquerda não existirão
//cerquilha
redisTemplate.opsForHash () Haskey ( "redisHash", "111") ;. // determina se existe a chave de hash
redisTemplate.opsForHash () put ( "redisHash", "nome", "111") ;. // armazena dados de hash
. RedisTemplate.opsForHash () chaves ( "redisHash"); // Obter o valor de hash da chave correspondente a
redisTemplate.opsForHash () get ( "redisHash", "idade") ;. // obter o valor de hash para uma determinada chave