Aujourd'hui, Soleil et Lune sont là pour vous apprendre à utiliser springBoot pour intégrer redis Pour être honnête, c'est relativement simple, et il existe de nombreux tutoriels sur Internet. Appliquons d’abord l’introduction sur Internet.
Définition
REmote DIctionary Server (Redis) est un système de stockage clé-valeur écrit par Salvatore Sanfilippo.
Redis est une base de données de valeurs-clés de type journal open source écrite en langage ANSI C, respecte le protocole BSD, prend en charge le réseau, peut être basée sur la mémoire et persistante et fournit des API dans plusieurs langues.
On l'appelle souvent serveur de structure de données car les valeurs peuvent être de types tels que String, Hash (Map), List, Sets et Sorted Sets .
Avantages de Redis
Voici quelques avantages de Redis.
Exceptionnellement rapide : Redis est très rapide et peut effectuer environ 110 000 opérations de définition (SET) par seconde et environ 81 000 opérations de lecture/obtention (GET) par seconde.
Prise en charge des types de données riches - Redis prend en charge la plupart des types de données couramment utilisés par les développeurs, tels que les listes, les ensembles, les ensembles triés, les hachages, etc. Cela permet à Redis d'être facilement utilisé pour résoudre divers problèmes, car nous savons quels problèmes peuvent être mieux résolus en utilisant quels types de données.
Les opérations sont atomiques - Toutes les opérations Redis sont atomiques, ce qui garantit que le serveur Redis peut recevoir des valeurs mises à jour si deux clients y accèdent simultanément.
Outil multi-utilitaire - Redis est un outil multi-utilitaire qui peut être utilisé pour plusieurs cas d'utilisation tels que : la mise en cache, les files d'attente de messages (Redis prend en charge la publication/l'abonnement de manière native), toutes les données à court terme dans une application, par ex. une application Web Sessions, nombre de pages consultées, etc.
Recommandé (gratuit) : redis
Installation de Redis
Installation sous Windows
Adresse de téléchargement : https://github.com/MSOpenTech/redis/releases.
Redis prend en charge 32 bits et 64 bits. Cela doit être sélectionné en fonction de la situation réelle de votre plate-forme système. Ici, nous téléchargeons le package compressé Redis-x64-xxx.zip sur le lecteur C. Après la décompression, renommez le dossier en redis.
Ouvrez une fenêtre cmd et utilisez la commande cd pour basculer les répertoires vers C:redis
Exécutez redis-server.exe redis.windows.conf
Si vous voulez être plus pratique, vous pouvez ajouter le chemin d'accès à redis au système variable d'environnement, vous n'avez donc pas à vous en soucier. Lorsque vous entrez à nouveau le chemin, le redis.windows.conf suivant peut être omis. S'il est omis, celui par défaut sera activé. Après saisie, l'interface suivante s'affichera : 
Nous continuons toujours à utiliser le projet du chapitre précédent : Springboot intègre springcloud-config pour implémenter dataSource déploiement à chaud
1. Ajouter des dépendances
<!--集成redis--> <dependency> <groupid>org.springframework.boot</groupid> <artifactid>spring-boot-starter-redis</artifactid> <version>1.4.1.RELEASE</version> </dependency> <dependency> <groupid>com.alibaba</groupid> <artifactid>fastjson</artifactid> <version>1.2.3</version> </dependency> <dependency> <groupid>com.fasterxml.jackson.core</groupid> <artifactid>jackson-databind</artifactid> </dependency>
2. Ajouter la configuration redis dans le centre de configuration
spring.redis.host=127.0.0.1 #Redis服务器连接端口 spring.redis.port=6379 #Redis服务器连接密码（默认为空） spring.redis.password= #连接池最大连接数（使用负值表示没有限制） spring.redis.pool.max-active=8 #连接池最大阻塞等待时间（使用负值表示没有限制） spring.redis.pool.max-wait=-1 #连接池中的最大空闲连接 spring.redis.pool.max-idle=8 #连接池中的最小空闲连接 spring.redis.pool.min-idle=0 #连接超时时间（毫秒） spring.redis.timeout=30000
3. Classe de configuration RedisConfig
import java.lang.reflect.Method;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.databind.ObjectMapper;
@Configuration
@EnableCaching
@RefreshScope
public class RedisConfig extends CachingConfigurerSupport{
@Value("${spring.redis.host}")
private String host;
@Value("${spring.redis.port}")
private int port;
@Value("${spring.redis.timeout}")
private int timeout;
@Value("${spring.redis.password}")
private String password;
@Value("${spring.redis.pool.max-active}")
private int maxActive;
@Value("${spring.redis.pool.max-wait}")
private int maxWait;
@Value("${spring.redis.pool.max-idle}")
private int maxIdle;
@Value("${spring.redis.pool.min-idle}")
private int minIdle;
@RefreshScope
@Bean
public KeyGenerator wiselyKeyGenerator(){
return new KeyGenerator() {
@Override
public Object generate(Object target, Method method, Object... params) {
StringBuilder sb = new StringBuilder();
sb.append(target.getClass().getName());
sb.append(method.getName());
for (Object obj : params) {
sb.append(obj.toString());
}
return sb.toString();
}
};
}
@RefreshScope
@Bean
public JedisConnectionFactory redisConnectionFactory() {
JedisConnectionFactory factory = new JedisConnectionFactory();
factory.setHostName(host);
factory.setPort(port);
factory.setTimeout(timeout); //设置连接超时时间
factory.setPassword(password);
factory.getPoolConfig().setMaxIdle(maxIdle);
factory.getPoolConfig().setMinIdle(minIdle);
factory.getPoolConfig().setMaxTotal(maxActive);
factory.getPoolConfig().setMaxWaitMillis(maxWait);
return factory;
}
@RefreshScope
@Bean
public CacheManager cacheManager(RedisTemplate redisTemplate) {
RedisCacheManager cacheManager = new RedisCacheManager(redisTemplate);
// Number of seconds before expiration. Defaults to unlimited (0)
cacheManager.setDefaultExpiration(10); //设置key-value超时时间
return cacheManager;
}
@RefreshScope
@Bean
public RedisTemplate<string> redisTemplate(RedisConnectionFactory factory) {
StringRedisTemplate template = new StringRedisTemplate(factory);
setSerializer(template); //设置序列化工具，这样ReportBean不需要实现Serializable接口
template.afterPropertiesSet();
return template;
}
@RefreshScope
private void setSerializer(StringRedisTemplate template) {
Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jackson2JsonRedisSerializer.setObjectMapper(om);
template.setValueSerializer(jackson2JsonRedisSerializer);
}
}</string>4. Classe RedisUtils
import java.io.Serializable;
import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.ListOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.SetOperations;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.stereotype.Service;
@Service
public class RedisUtils {
@Autowired
private RedisTemplate redisTemplate;
/**
* 写入缓存
* @param key
* @param value
* @return
*/
public boolean set(final String key, Object value) {
boolean result = false;
try {
ValueOperations<serializable> operations = redisTemplate.opsForValue();
operations.set(key, value);
result = true;
} catch (Exception e) {
e.printStackTrace();
}
return result;
}
/**
* 写入缓存设置时效时间
* @param key
* @param value
* @return
*/
public boolean set(final String key, Object value, Long expireTime ,TimeUnit timeUnit) {
boolean result = false;
try {
ValueOperations<serializable> operations = redisTemplate.opsForValue();
operations.set(key, value);
redisTemplate.expire(key, expireTime, timeUnit);
result = true;
} catch (Exception e) {
e.printStackTrace();
}
return result;
}
/**
* 批量删除对应的value
* @param keys
*/
public void remove(final String... keys) {
for (String key : keys) {
remove(key);
}
}
/**
* 批量删除key
* @param pattern
*/
public void removePattern(final String pattern) {
Set<serializable> keys = redisTemplate.keys(pattern);
if (keys.size() > 0){
redisTemplate.delete(keys);
}
}
/**
* 删除对应的value
* @param key
*/
public void remove(final String key) {
if (exists(key)) {
redisTemplate.delete(key);
}
}
/**
* 判断缓存中是否有对应的value
* @param key
* @return
*/
public boolean exists(final String key) {
return redisTemplate.hasKey(key);
}
/**
* 读取缓存
* @param key
* @return
*/
public Object get(final String key) {
Object result = null;
ValueOperations<serializable> operations = redisTemplate.opsForValue();
result = operations.get(key);
return result;
}
/**
* 哈希 添加
* @param key
* @param hashKey
* @param value
*/
public void hmSet(String key, Object hashKey, Object value){
HashOperations<string> hash = redisTemplate.opsForHash();
hash.put(key,hashKey,value);
}
/**
* 哈希获取数据
* @param key
* @param hashKey
* @return
*/
public Object hmGet(String key, Object hashKey){
HashOperations<string> hash = redisTemplate.opsForHash();
return hash.get(key,hashKey);
}
/**
* 列表添加
* @param k
* @param v
*/
public void lPush(String k,Object v){
ListOperations<string> list = redisTemplate.opsForList();
list.rightPush(k,v);
}
/**
* 列表获取
* @param k
* @param l
* @param l1
* @return
*/
public List<object> lRange(String k, long l, long l1){
ListOperations<string> list = redisTemplate.opsForList();
return list.range(k,l,l1);
}
/**
* 集合添加
* @param key
* @param value
*/
public void add(String key,Object value){
SetOperations<string> set = redisTemplate.opsForSet();
set.add(key,value);
}
/**
* 集合获取
* @param key
* @return
*/
public Set<object> setMembers(String key){
SetOperations<string> set = redisTemplate.opsForSet();
return set.members(key);
}
/**
* 有序集合添加
* @param key
* @param value
* @param scoure
*/
public void zAdd(String key,Object value,double scoure){
ZSetOperations<string> zset = redisTemplate.opsForZSet();
zset.add(key,value,scoure);
}
/**
* 有序集合获取
* @param key
* @param scoure
* @param scoure1
* @return
*/
public Set<object> rangeByScore(String key,double scoure,double scoure1){
ZSetOperations<string> zset = redisTemplate.opsForZSet();
return zset.rangeByScore(key, scoure, scoure1);
}</string></object></string></string></object></string></string></object></string></string></string></serializable></serializable></serializable></serializable>5. Tester, modifier le contrôleur
import java.util.concurrent.TimeUnit;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.chenqi.springboot.redis.RedisUtils;
import com.chenqi.springboot.service.TestService;
@RestController
public class SpringBootController {
public static final Logger log = LoggerFactory.getLogger(SpringBootController.class);
@Autowired
TestService testService;
@Autowired
private RedisUtils redisUtils;
@RequestMapping(value = "/hello/{id}")
public String hello(@PathVariable(value = "id") String id){
//查询缓存中是否存在
boolean hasKey = redisUtils.exists(id);
String str = "";
if(hasKey){
//获取缓存
Object object = redisUtils.get(id);
log.info("从缓存获取的数据"+ object);
str = object.toString();
}else{
//从数据库中获取信息
log.info("从数据库中获取数据");
str = testService.test();
//数据插入缓存（set中的参数含义：key值，user对象，缓存存在时间10（long类型），时间单位）
redisUtils.set(id,str,10L,TimeUnit.MINUTES);
log.info("数据插入缓存" + str);
}
return str;
}
}
Grâce à la sortie de la console, nous pouvons voir que les données sont obtenues à partir du base de données et stocké dans le cache Redis.
Vous pouvez voir que la deuxième fois qu'il est lu depuis le cache, essayons d'actualiser le navigateur en continu
Comme vous pouvez le voir, tout est ensuite obtenu du cache.
Si vous avez un besoin urgent de la démo, veuillez la télécharger vous-même. Si vous n'êtes pas pressé, vous pouvez laisser un message dans votre adresse e-mail et elle le sera. généralement être envoyé dans les 48 heures.
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
Étapes de création du projet SpringBoot
Quelle est la différence entre j2ee et springboot
Quels sont les moteurs de workflow Java ?
Solution à javascript :;
Comment déclencher un événement de pression de touche
Comment trier dans Excel
Comment résoudre le problème de ssleay32.dll manquant
Comment éliminer le code HTML
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
