Wie verwende ich SpringBoot, um Redis zu integrieren?-Redis-php.cn

In diesem Artikel erfahren Sie, wie Sie mit springBoot Redis integrieren. Es hat einen gewissen Referenzwert. Freunde in Not können sich darauf beziehen. Ich hoffe, es wird für alle hilfreich sein.

Wie verwende ich SpringBoot, um Redis zu integrieren?

REmote Dictionary Server (Redis) ist ein Schlüsselwertspeichersystem, das von Salvatore Sanfilippo geschrieben wurde.

Redis ist eine Open-Source-Schlüsselwertdatenbank vom Protokolltyp, die in der Sprache ANSI C geschrieben ist, sich an das BSD-Protokoll hält, das Netzwerk unterstützt, speicherbasiert und persistent sein kann und APIs in mehreren Sprachen bereitstellt. [Verwandte Empfehlung: Redis-Video-Tutorial]

Es wird oft als Datenstrukturserver bezeichnet, da der Wert eine Zeichenfolge (String), ein Hash (Map), eine Liste (Liste), eine Sammlung (Sets) und sortiert sein kann Sets und andere Typen.

Vorteile von Reids

Hier sind einige Vorteile von Redis:

Außergewöhnlich schnell – Redis ist sehr schnell und kann ungefähr 110.000 Set-Operationen (SET) pro Sekunde und ungefähr 81.000 Lesevorgänge pro Sekunde ausführen Get/get (GET ) Betrieb.
Unterstützt umfangreiche Datentypen – Redis unterstützt die meisten von Entwicklern häufig verwendeten Datentypen, z. B. Listen, Mengen, sortierte Mengen, Hashes und mehr. Dies erleichtert den Einsatz von Redis zur Lösung verschiedener Probleme, da wir wissen, welche Probleme mit welchen Datentypen besser gelöst werden können.
Operationen sind atomar – Alle Redis-Operationen sind atomar, was sicherstellt, dass der Redis-Server aktualisierte Werte empfangen kann, wenn zwei Clients gleichzeitig darauf zugreifen.
Multi-Utility-Tool – Redis ist ein Multi-Utility-Tool, das für mehrere Anwendungsfälle verwendet werden kann, wie zum Beispiel: Caching, Nachrichtenwarteschlangen (Redis unterstützt nativ Publish/Subscribe), alle kurzfristigen Daten in Anwendungen , in Webanwendungssitzungen, Seitenzugriffszahlen usw.

Redis-Installation

Installation unter Windows

Download-Adresse: https://github.com/MSOpenTech/redis/releases.

Redis unterstützt 32-Bit und 64-Bit. Dies muss entsprechend der tatsächlichen Situation Ihrer Systemplattform ausgewählt werden. Hier laden wir das komprimierte Paket Redis-x64-xxx.zip auf das Laufwerk C herunter. Benennen Sie den Ordner nach der Dekomprimierung in Redis um.

Öffnen Sie ein cmd-Fenster und verwenden Sie den Befehl cd, um die Verzeichnisse auf C: redis zu wechseln Sie müssen den Pfad erneut eingeben. Die Datei redis.windows.conf kann weggelassen werden. Wenn sie weggelassen wird, wird die Standarddatei aktiviert. Nach der Eingabe wird die folgende Schnittstelle angezeigt:

redis-server.exe redis.windows.conf

Redis integrieren

Wie verwende ich SpringBoot, um Redis zu integrieren?

Wir verwenden immer noch das Projekt aus dem vorherigen Kapitel: Springboot integriert springcloud-config, um die DataSource-Hot-Bereitstellung zu implementieren

<!--集成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>

Nach dem Login kopieren

2. Redis-Konfiguration im Konfigurationscenter hinzufügen

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

Nach dem Login kopieren

3. Konfigurationsklasse RedisConfig4. RedisUtils-Klasse

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, 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);
    }
}

Nach dem Login kopieren

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, Object> 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, Object> 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, Object> 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, Object, Object> hash = redisTemplate.opsForHash();
        hash.put(key,hashKey,value);
    }
    /**
     * 哈希获取数据
     * @param key
     * @param hashKey
     * @return
     */
    public Object hmGet(String key, Object hashKey){
        HashOperations<String, Object, Object>  hash = redisTemplate.opsForHash();
        return hash.get(key,hashKey);
    }
    /**
     * 列表添加
     * @param k
     * @param v
     */
    public void lPush(String k,Object v){
        ListOperations<String, Object> 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, Object> list = redisTemplate.opsForList();
        return list.range(k,l,l1);
    }
    /**
     * 集合添加
     * @param key
     * @param value
     */
    public void add(String key,Object value){
        SetOperations<String, Object> set = redisTemplate.opsForSet();
        set.add(key,value);
    }
    /**
     * 集合获取
     * @param key
     * @return
     */
    public Set<Object> setMembers(String key){
        SetOperations<String, Object> set = redisTemplate.opsForSet();
        return set.members(key);
    }
    /**
     * 有序集合添加
     * @param key
     * @param value
     * @param scoure
     */
    public void zAdd(String key,Object value,double scoure){
        ZSetOperations<String, Object> 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, Object> zset = redisTemplate.opsForZSet();
        return zset.rangeByScore(key, scoure, scoure1);
    }

Nach dem Login kopieren

Start Das Projekt, erste Besuche: http://localhost:8002/hello/111

Durch die Konsolenausgabe können wir sehen, dass die Daten aus der Datenbank abgerufen und im Redis-Cache gespeichert werden.
Wie verwende ich SpringBoot, um Redis zu integrieren? Wir aktualisieren den Browser erneut

Sie können sehen, dass wir beim zweiten Lesen aus dem Cache versuchen, den Browser kontinuierlich zu aktualisieren

Sie können sehen, dass danach alles aus dem Cache abgerufen wird.

Wie verwende ich SpringBoot, um Redis zu integrieren? Jetzt ist unser Redis konfiguriert.

SpringBoot integrierter Redis-Demo-Download Wie verwende ich SpringBoot, um Redis zu integrieren?
https://download.csdn.net/download/weixin_40623736/12692763

Brüder, die die Demo dringend benötigen, können sie selbst herunterladen. Wenn Sie es nicht eilig haben, Sie Sie können eine Nachricht an Ihre E-Mail-Adresse hinterlassen. Diese wird normalerweise innerhalb von 48 Stunden gesendet.

Weitere Kenntnisse zum Thema Programmierung finden Sie unter:
Einführung in die Programmierung
! !

Das obige ist der detaillierte Inhalt vonWie verwende ich SpringBoot, um Redis zu integrieren?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!