项目引入redis并且简单应用

 

【前言】在金融圈流传金钱为王，而在互联网圈则流传缓存为王，redis就是其中不可或缺的一种缓存方式。

【pom文件引入redis】

<!-- redis -->
<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

 

【yml文件中链接redis】

redis:
    open: true  # 是否开启redis缓存  true开启   false关闭
    database: 0
    host: ***.***.**.**//服务器地址
    port: ****//端口号
    password:    # 密码（默认为空）
    timeout: 6000ms  # 连接超时时长（毫秒）
    jedis:
      pool:
        max-active: 1000  # 连接池最大连接数（使用负值表示没有限制）
        max-wait: -1ms      # 连接池最大阻塞等待时间（使用负值表示没有限制）
        max-idle: 10      # 连接池中的最大空闲连接
        min-idle: 5       # 连接池中的最小空闲连接

 

【添加redisconfig文件】

import com.alibaba.fastjson.support.spring.GenericFastJsonRedisSerializer;
import com.dmsdbj.itoo.tool.redis.TedisCacheManager;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * 实例:
 * 1.注解使用:
 *
 * @Cacheable(value = "configDetail", key = "#p0", sync = true)
 * @CacheExpire(expire = 120)
 * ConfigDetailEntity findByAction(String action);
 * <p>
 * 2.直接使用
 * redisTemplate.opsForValue();//操作字符串
 * redisTemplate.opsForHash();//操作hash
 * redisTemplate.opsForList();//操作list
 * redisTemplate.opsForSet();//操作set
 * redisTemplate.opsForZSet();//操作有序set
 */
@Configuration
@Slf4j
public class RedisConfig extends CachingConfigurerSupport {

private final RedisConnectionFactory redisConnectionFactory;
    private RedisSerializer keySerializer = new StringRedisSerializer();
    private final RedisSerializationContext.SerializationPair<String> keyPair = RedisSerializationContext
            .SerializationPair.fromSerializer(keySerializer);

private RedisSerializer valueSerializer = new GenericFastJsonRedisSerializer();
    private final RedisSerializationContext.SerializationPair<Object> valuePair = RedisSerializationContext
            .SerializationPair.fromSerializer(valueSerializer);

RedisConfig(RedisConnectionFactory redisConnectionFactory) {
        this.redisConnectionFactory = redisConnectionFactory;
    }

@Bean
    public RedisTemplate<String, Object> redisTemplate() {
        RedisTemplate<String, Object> template = new RedisTemplate<>();

// 设置key序列化类，否则key前面会多了一些乱码
        template.setKeySerializer(keySerializer);
        template.setHashKeySerializer(keySerializer);
        // fastjson serializer
        template.setValueSerializer(valueSerializer);
        template.setHashValueSerializer(valueSerializer);
        // 如果 KeySerializer 或者 ValueSerializer 没有配置，则对应的 KeySerializer、ValueSerializer 才使用这个 Serializer
        template.setDefaultSerializer(valueSerializer);

log.info("redis: {}", redisConnectionFactory);
        LettuceConnectionFactory factory = (LettuceConnectionFactory) redisConnectionFactory;
        log.info("spring.redis.database: {}", factory.getDatabase());
        log.info("spring.redis.host: {}", factory.getHostName());
        log.info("spring.redis.port: {}", factory.getPort());
        log.info("spring.redis.timeout: {}", factory.getTimeout());
        log.info("spring.redis.password: {}", factory.getPassword());

// factory
        template.setConnectionFactory(redisConnectionFactory);
        template.afterPropertiesSet();
        return template;
    }

@Bean
    @Override
    public KeyGenerator keyGenerator() {
        return (o, method, objects) -> {
            StringBuilder sb = new StringBuilder(32);
            sb.append(o.getClass().getSimpleName());
            sb.append(".");
            sb.append(method.getName());
            if (objects.length > 0) {
                sb.append("#");
            }
            String sp = "";
            for (Object object : objects) {
                sb.append(sp);
                if (object == null) {
                    sb.append("NULL");
                } else {
                    sb.append(object.toString());
                }
                sp = ".";
            }
            return sb.toString();
        };
    }

/**
     * 配置 RedisCacheManager，使用 cache 注解管理 redis 缓存
     */
    @Bean
    @Override
    public CacheManager cacheManager() {
        TedisCacheManager tedisCacheManager = TedisCacheManager.create(redisConnectionFactory);
        tedisCacheManager.setKeySerializer(keySerializer);
        tedisCacheManager.setValueSerializer(valueSerializer);
        return tedisCacheManager;
    }
}

【service简单应用，塞了个string值】

//实例化
@Resource
public RedisTemplate redisTemplate;



        String i = (String)redisTemplate.opsForValue().get(keyText);//取值
        if (INTERNNAME.equals(i)) {
            return true;
        }
        else {
            redisTemplate.opsForValue().set(keyText,internResume);//塞值
            redisTemplate.expire(keyText, 60, TimeUnit.SECONDS);//设置塞值的过期时间
            return false;
        }