- carga AutoConfig
- Escreva suas próprias cargas de código
- carga xml
Use esses três métodos são necessários:
1. Adicione dependência
2. informações de configuração Write
= 0 spring.redis.database
spring.redis.host = localhost
spring.redis.port = 6379
tempo # tempo limite de conexão ms (milissegundos)
spring.redis.timeout = 3000
# Piscina máxima conexão conexões ociosas, o valor padrão é 8.
. 8-IDLE = spring.redis.pool.max
# mínimo pool de conexão conexões ociosas, o valor padrão é 0.
IDLE = 0-spring.redis.pool.min
# Se a categoria é -1, indica não se limitando, por maxActive jedis exemplo, se um tiver sido atribuída uma piscina, o estado piscina neste momento está esgotado (esgotada).
= Ativos. 8-spring.redis.pool.max
# tempo máximo de espera por uma conexão disponível, em milissegundos, o valor padrão é -1, nunca expira. Se o tempo de espera for excedido, jogado diretamente JedisConnectionException
spring.redis.pool.max = a espera - 1
Método 1: Utilização de configuração automática carregada automaticamente.
Desde a introdução da mola-boot-start-data-Redis acima, pode ser usado para arquivo de propriedades de configuração de carga classe RedisAutoConfiguration.
**
* configuração Redis padrão.
* /
@Configuration
protegido RedisConfiguration classe estática {
@Bean
@ConditionalOnMissingBean (name = "redisTemplate")
RedisTemplate pública <Object, Object> redisTemplate (
RedisConnectionFactory redisConnectionFactory)
lança UnknownHostException {
RedisTemplate <Object, Object> template = new RedisTemplate <Object, Object> ();
template.setConnectionFactory (redisConnectionFactory);
voltar modelo;
}
@Bean
@ConditionalOnMissingBean (StringRedisTemplate.class)
público StringRedisTemplate stringRedisTemplate (
RedisConnectionFactory redisConnectionFactory)
lança UnknownHostException {
StringRedisTemplate template = new StringRedisTemplate ();
template.setConnectionFactory (redisConnectionFactory);
voltar modelo;
}
}
Redis desta forma será o padrão configuração carregada no applicaiton, fornece dois de feijão
RedisTemplate <Object, Object> todos podem operar sobre o objeto tipo de dados em Redis e valor de chave, o objeto irá utilizar uma serialização padrão JdkSerializationRedisSerializer
StringRedisTemplate Redis pode ser operado e os dados de valor-chave do tipo String.
A segunda maneira: escrever seu próprio código é carregado.
@Configuration
classe pública RedisConfig {
registador registador privada = LoggerFactory.getLogger (this.getClass ());
@Value ( "$ {spring.redis.host}")
String host privado;
@Value ( "$ {spring.redis.port}")
port int privado;
@Value ( "$ {spring.redis.timeout}")
tempo limite int privado;
@Value ( "$ {spring.redis.password}")
password private String;
@Value ( "$ {spring.redis.database}")
do banco de dados int privado;
@Value ( "$ {spring.redis.pool.max-idle}")
int privado maxIdle;
@Value ( "$ {spring.redis.pool.min-idle}")
int privado minIdle;
/ **
* Redis模板,存储关键字是字符串,值是Jdk序列化
* @description:
* fábrica @ param
* @ return
* /
@Bean
RedisTemplate pública <String, Object> redisTemplate (fábrica RedisConnectionFactory) {
RedisTemplate <string , Object> redisTemplate = new RedisTemplate <> ();
redisTemplate.setConnectionFactory (de fábrica);
RedisSerializer <String> redisSerializer = new StringRedisSerializer ();
redisTemplate.setKeySerializer (redisSerializer);
redisTemplate.setHashKeySerializer (redisSerializer);
// JdkSerializationRedisSerializer序列化方式;
JdkSerializationRedisSerializer jdkRedisSerializer = novo JdkSerializationRedisSerializer ();
redisTemplate.setValueSerializer (jdkRedisSerializer);
redisTemplate.setHashValueSerializer (jdkRedisSerializer);
redisTemplate.afterPropertiesSet ();
voltar redisTemplate;
}
}
Três maneiras: usando XML carregado.
Na entrada do programa é adicionado:
@ImportResource (locations = { "classpath: primavera-redis.xml"})
Na pasta de arquivo de recurso ao abrigo da nova primavera-redis.xml
<feijão xmlns =" http://www.springframework.org/schema/beans "
xmlns: xsi =" http://www.w3.org/2001/XMLSchema-instance "xmlns: cache =" http: // www .springframework.org / schema / cache "
xmlns: context =" http://www.springframework.org/schema/context "
xsi: schemaLocation =" http://www.springframework.org/schema/beans
http: // www.springframework.org/schema/beans/spring-beans-4.0.xsd
http://www.springframework.org/schema/cache
http://www.springframework.org/schema/cache/spring-cache.xsd
http : //www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.0.xsd ">
<bean id = "jedisPoolConfig" class = "redis.clients.jedis.JedisPoolConfig">
<property name = value "minIdle" = "$ {redis.pool.minIdle}" />
<property name = "maxIdle" value =" $ {redis.pool.maxIdle}"/>
<property name = "maxWaitMillis" value = "$ {redis.pool.maxWaitMillis}"/>
</ bean>
<bean id = "jedisConnectionFactory"
class = "org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
<property name = value "usePool" = "true"> </ property>
<property name = value "hostname" = "$ {redis.ip}" />
<property name = value "port" = "$ {redis.port}" />
<property name = value "password" = "$ {redis.password}" />
< property name = valor "timeout" = "{redis.timeout} $" />
<property name = value "banco de dados" = "$ {redis.default.db}"> </ property>
<constructor-arg ref = "jedisPoolConfig "/>
</ Bean>
<bean id = "redisTemplate" class = "org.springframework.data.redis.core.RedisTemplate">
<property name = "connectionFactory" ref = "jedisConnectionFactory" />
<property name = "KeySerializer">
<bean
class =" org.springframework.data.redis.serializer.StringRedisSerializer "> </ bean>
</ property>
<property name =" ValueSerializer ">
<bean
class =" org.springframework.data.redis.serializer.JdkSerializationRedisSerializer "> </ bean >
</ property>
<property name = "HashKeySerializer">
<feijão
class = "org.springframework.data.redis.serializer.StringRedisSerializer"> </ bean>
</ property>
<property name = "HashValueSerializer">
<bean
class = "org.springframework.data.redis.serializer.JdkSerializationRedisSerializer"> </ bean>
</ property>
</ bean>
</ beans>
use:
Modelo injetado com anotações diretamente chamar muito bem.
@Repository
RedisService classe pública {
@Autowired
StringRedisTemplate stringRedisTemplate;
add public void (String chave, usuário do usuário, tempo de Long) {
Gson Gson = new Gson ();
stringRedisTemplate.opsForValue () conjunto (chave, gson.toJson (utilizador), o tempo, TimeUnit.MINUTES).;
}
public void add (String chave, List <User> utilizadores, Long tempo) {
Gson Gson = new Gson ();
Corda src = gson.toJson (utilizadores);
stringRedisTemplate.opsForValue () Set (de chave, src, tempo, TimeUnit.MINUTES.);
}
get pública do usuário (chave String) {
fonte String = stringRedisTemplate.opsForValue () get (key).;
if (StringUtils.isEmpty (fonte)!) {
return new Gson () fromJson (fonte, User.class.);
}
Return null;
}
Lista pública <User> getUserList (String chave) {
fonte String = stringRedisTemplate.opsForValue () get (key).;
if (StringUtils.isEmpty (fonte)!) {
return new Gson () fromJson (fonte, novo TypeToken <List <User >> () {.
} .getType ());
}
Return null;
}
public void delete (String chave) {
.. stringRedisTemplate.opsForValue () getOperations () delete (chave);
}
}
Se o teste é então:
@RunWith (SpringJUnit4ClassRunner.class)
@SpringBootTest
classe pública RedisTest {
@Autowired
RedisService redisService;
@Before
setUp public void () {
}
@Test
get public void () {
user Usuário = new User ();
user.setName ( "wangjianfeng");
user.setAge (22);
redisService.add ( "userByName:" + user.getName (), utilizador, 10L);
List <User> list = new ArrayList <> ();
list.add (utilizador);
redisService.add ( "list", lista, 10L);
Usuário user1 = redisService.get ( "userByName: wangjianfeng");
Assert.notNull (user1, "utilizador é nula");
List <User> list2 = redisService.getUserList ( "list");
Assert.notNull (list2, "a lista é nulo");
}
}
SpringBoot usar o cache Redis:
ofertas Springboot muitos gerenciador de cache, tais como:
- SimpleCacheManager
- EhCacheManager
- CaffeineCacheManager
- GuavaCacheManager
- CompositeCacheManager
SpringData fornece o Gerenciador de cache: RedisCacheManager
Em SpringBoot, a entrada no programa, em conjunto com um gestor de configuração adequada anotação @EnableCaching automatizado.
Então nós usamos para escrever sua própria configuração do código, modificar RedisConfig @EnableCaching adicionar anotações, e CachingCongigurerSupport herdar
@Configuration
@EnableCaching
classe pública RedisConfig estende CachingConfigurerSupport {
...
}
