>  기사  >  데이터 베이스  >  SpringBoot 통합 Redis에 대한 자세한 설명

SpringBoot 통합 Redis에 대한 자세한 설명

coldplay.xixi
coldplay.xixi앞으로
2021-04-16 17:06:282324검색

SpringBoot 통합 Redis에 대한 자세한 설명

오늘 Riyue는 springBoot를 사용하여 redis를 통합하는 방법을 가르치기 위해 왔습니다. 솔직히 말하면 비교적 간단하고 인터넷에 많은 튜토리얼이 있습니다. 먼저 인터넷에 소개된 내용을 적용해 보겠습니다.
정의

REmote DIctionary Server(Redis)는 Salvatore Sanfilippo가 작성한 키-값 저장 시스템입니다.
Redis는 ANSI C 언어로 작성된 오픈소스 로그형 Key-Value 데이터베이스로, BSD 프로토콜을 준수하고, 네트워크를 지원하며, 메모리 기반 및 영속성이 가능하며, 다국어 API를 제공합니다.
값은 문자열, 해시(맵), 목록, 집합 및 정렬된 집합과 같은 유형이 될 수 있기 때문에 종종 데이터 구조 서버라고 합니다.
redis의 장점

Redis의 장점은 다음과 같습니다.

매우 빠른 속도 - Redis는 매우 빠르며 초당 약 110,000개의 설정(SET) 작업과 초당 약 81,000개의 읽기/가져오기(GET) 작업을 수행할 수 있습니다.
풍부한 데이터 유형 지원 - Redis는 목록, 세트, ​​정렬된 세트, 해시 등과 같이 개발자가 일반적으로 사용하는 대부분의 데이터 유형을 지원합니다. 이를 통해 Redis를 사용하여 다양한 문제를 쉽게 해결할 수 있습니다. 어떤 데이터 유형을 사용하면 어떤 문제를 더 잘 해결할 수 있는지 알 수 있기 때문입니다.
작업은 원자적입니다 - 모든 Redis 작업은 원자적이므로 두 클라이언트가 동시에 액세스하는 경우 Redis 서버가 업데이트된 값을 받을 수 있습니다.
다중 유틸리티 도구 - Redis는 캐싱, 메시지 대기열(Redis는 기본적으로 게시/구독 지원), 애플리케이션의 단기 데이터(예: 세션)와 같은 여러 사용 사례에 사용할 수 있는 다중 유틸리티 도구입니다. 웹 애플리케이션, 웹 페이지 조회수 등

권장(무료): redis

Redis 설치

Window 아래 설치
다운로드 주소: https://github.com/MSOpenTech/redis/releases.
Redis는 32비트와 64비트를 지원합니다. 이는 시스템 플랫폼의 실제 상황에 따라 선택해야 합니다. 여기서는 Redis-x64-xxx.zip 압축 패키지를 C 드라이브에 다운로드합니다. 압축을 푼 후 폴더 이름을 redis로 바꿉니다.

cmd 창을 열고 cd 명령을 사용하여 디렉터리를 C:redis
Runredis-server.exe redis.windows.conf
로 전환합니다. 더 쉽게 하려면 시스템 환경 변수에 redis 경로를 추가하면 입력할 필요가 없습니다. 경로를 다시 지정하면 이후의 redis.windows.conf를 생략할 수 있으며, 생략하면 기본 경로가 활성화됩니다. 입력 후 다음 인터페이스가 표시됩니다.
SpringBoot 통합 Redis에 대한 자세한 설명

Integrate redis

우리는 여전히 이전 장의 프로젝트를 사용합니다. Springboot는 springcloud-config를 통합하여 dataSource 핫 배포를 구현합니다

1. 종속성 추가

<!--集成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. 구성 센터에 redis 구성을 추가합니다

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. 구성 클래스 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. 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. 테스트, 컨트롤러 수정

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

을 방문하세요. 처음: http: //localhost:8002/hello/111
SpringBoot 통합 Redis에 대한 자세한 설명
SpringBoot 통합 Redis에 대한 자세한 설명
콘솔 출력을 통해 데이터베이스에서 데이터를 가져와 Redis 캐시에 저장하는 것을 볼 수 있습니다.

브라우저를 다시 새로고침합니다
SpringBoot 통합 Redis에 대한 자세한 설명
두 번째로 캐시에서 읽을 때 브라우저를 계속 새로고침해 보도록 하겠습니다.
SpringBoot 통합 Redis에 대한 자세한 설명
그 이후에는 모든 것이 캐시에서 얻어지는 것을 볼 수 있습니다.

이제 Redis가 구성되었습니다.

SpringBoot 통합 Redis-데모 다운로드
데모가 긴급하게 필요한 경우 직접 다운로드하시기 바랍니다. 급하지 않은 경우 이메일 주소로 메시지를 남겨주시면 일반적으로 48시간 이내에 전송됩니다.

위 내용은 SpringBoot 통합 Redis에 대한 자세한 설명의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!

성명:
이 기사는 csdn.net에서 복제됩니다. 침해가 있는 경우 admin@php.cn으로 문의하시기 바랍니다. 삭제