SpringBoot自学（三）整合redis

た入场券 2022-02-04 09:21 291阅读 0赞

引入依赖：

<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    <dependency>
    			<groupId>org.apache.commons</groupId>
    			<artifactId>commons-pool2</artifactId>
    			<version>${commons-pool2.version}</version>
    		</dependency>

增加配置 (根据自己的情况配置)

spring:
    	#单个redis配置  
      redis:
        #Redis服务器地址
        host: 127.0.0.1
        #Redis服务器连接端口
        port: 6379
        #Redis服务器连接密码（默认为空）
        password:
        # Redis数据库索引（默认为0）
        database: 0
        lettuce:
          pool:
            # 连接池最大连接数（使用负值表示没有限制） 默认 8
            max-active: 32
            # 连接池最大阻塞等待时间（使用负值表示没有限制） 默认 -1
            max-wait: -1
            # 连接池中的最大空闲连接 默认 8
            max-idle: 8
            # 连接池中的最小空闲连接 默认 0
            min-idle: 0
            # 连接超时时间（毫秒）
            timeout: 0

如果你的redis有密码，配置下即可。经过上述两步的操作，你可以访问redis数据了。

但是，还需要一些简单的配置。 比如序列化redisTemplete保存的数据呀，还有就是redis缓存的配置

package com.springboot.main.core.config.redis;
    
    import com.fasterxml.jackson.annotation.JsonAutoDetect;
    import com.fasterxml.jackson.annotation.PropertyAccessor;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import org.springframework.boot.autoconfigure.AutoConfigureAfter;
    import org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration;
    import org.springframework.cache.CacheManager;
    import org.springframework.cache.annotation.EnableCaching;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.data.redis.cache.RedisCacheConfiguration;
    import org.springframework.data.redis.cache.RedisCacheManager;
    import org.springframework.data.redis.connection.RedisConnectionFactory;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
    import org.springframework.data.redis.serializer.RedisSerializationContext;
    import org.springframework.data.redis.serializer.RedisSerializer;
    import org.springframework.data.redis.serializer.StringRedisSerializer;
    
    import java.time.Duration;
    import java.util.HashMap;
    import java.util.HashSet;
    import java.util.Map;
    import java.util.Set;
    
    /**
     * @method redis配置： RedisConfig文件名不能修改 ; 配置序列化方式以及缓存管理器 @EnableCaching 开启缓存
     * @author Mr yi
     * @time 2019年5月6日
     */
    @Configuration
    @EnableCaching
    @AutoConfigureAfter(RedisAutoConfiguration.class)
    public class RedisConfig {
    
    	/**
    	 * @method 配置自定义redisTemplate;
    	 *         因为使用的连接客户端为：Lettuce,所以RedisConnectionFactory实际传入数据为
    	 *         LettuceConnectionFactory
    	 * @author Mr yi
    	 * @time 2019年5月6日
    	 * @param connectionFactory
    	 * @return
    	 */
    	@Bean
    	public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
    		RedisTemplate<String, Object> template = new RedisTemplate<>();
    		template.setConnectionFactory(connectionFactory);
    		template.setValueSerializer(jackson2JsonRedisSerializer());
    		// 使用StringRedisSerializer来序列化和反序列化redis的key值
    		template.setKeySerializer(new StringRedisSerializer());
    		template.setHashKeySerializer(new StringRedisSerializer());
    		template.setHashValueSerializer(jackson2JsonRedisSerializer());
    		template.afterPropertiesSet();
    		return template;
    	}
    
    	/**
    	 * @method json序列化
    	 * @author Mr yi
    	 * @time 2019年5月6日
    	 * @return
    	 */
    	@SuppressWarnings({ "rawtypes", "unchecked" })
    	@Bean
    	public RedisSerializer<Object> jackson2JsonRedisSerializer() {
    		// 使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值
    		Jackson2JsonRedisSerializer serializer = new Jackson2JsonRedisSerializer(Object.class);
    		ObjectMapper mapper = new ObjectMapper();
    		mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
    		mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
    		serializer.setObjectMapper(mapper);
    		return serializer;
    	}
    
    	/**
    	 * @method 配置缓存管理器 ; 需要注意的是 你在RedisTemplate<String,
    	 *         Object>中的配置的key，value序列化方法并不会生效; 需要在RedisCacheConfiguration中单独配置。
    	 * @author Mr yi
    	 * @time 2019年5月6日
    	 * @param redisConnectionFactory
    	 * @return
    	 */
    	@Bean
    	public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
    		// 生成一个默认配置，通过config对象即可对缓存进行自定义配置
    		RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig();
    		// 设置缓存的默认过期时间，也是使用Duration设置 （此处为缓存1分钟）
    		config = config.entryTtl(Duration.ofMinutes(1))
    				// 设置 key为string序列化
    				.serializeKeysWith(
    						RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
    				// 设置value为json序列化
    				.serializeValuesWith(
    						RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer()))
    				// 不缓存空值
    				.disableCachingNullValues();
    
    		// 设置一个初始化的缓存空间set集合
    		Set<String> cacheNames = new HashSet<>();
    		cacheNames.add("timeGroup");
    		cacheNames.add("user");
    		cacheNames.add("UUser");
    
    		// 对每个缓存空间应用不同的配置
    		Map<String, RedisCacheConfiguration> configMap = new HashMap<>();
    		configMap.put("timeGroup", config);
    		// 该缓存空间，缓存时间120秒
    		configMap.put("user", config.entryTtl(Duration.ofSeconds(120)));
    		configMap.put("UUser", config.entryTtl(Duration.ofDays(3)));
    
    		// 使用自定义的缓存配置初始化一个cacheManager
    		RedisCacheManager cacheManager = RedisCacheManager.builder(redisConnectionFactory)
    				// 一定要先调用该方法设置初始化的缓存名，再初始化相关的配置
    				.initialCacheNames(cacheNames).withInitialCacheConfigurations(configMap).build();
    		return cacheManager;
    	}
    
    }

redis的保存数据调用的例子:

@Controller
    @Slf4j
    @RequestMapping("/test")
    public class TestController {
    
    	@Autowired
        private RedisTemplate redisTemplate;
    	
        /**
         * redis 的测试方法（添加、获取、删除）
         * @return
         * @throws InterruptedException
         */
    	@SuppressWarnings("unchecked")
    	@RequestMapping("/getReids")
        public String getReids() throws InterruptedException {
    		Test user=new Test( );
        	 user.setId(1).setName("Mr yi").setAge(10);
             redisTemplate.opsForValue().set("uUserTest", user);
             Object uu = redisTemplate.opsForValue().get("uUserTest");
             redisTemplate.delete("uUserTest");
             log.info("redis中获取数据：[{}]", uu);
             return uu.toString();
        }
        }

使用redis缓存的例子：

package com.toad.swan.service.impl;
     
    import com.baomidou.mybatisplus.core.metadata.IPage;
    import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
    import com.toad.swan.entity.UUser;
    import com.toad.swan.mapper.UUserMapper;
    import com.toad.swan.service.UUserService;
    import com.toad.swan.web.param.UUserParam;
    import com.toad.swan.web.vo.UUserVo;
    import com.toad.common.baseclass.*;
    import com.toad.common.base.BaseServiceImpl;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.cache.annotation.CacheEvict;
    import org.springframework.cache.annotation.CachePut;
    import org.springframework.cache.annotation.Cacheable;
    import org.springframework.stereotype.Service;
    import org.springframework.transaction.annotation.Transactional;
     
    import java.io.Serializable;
     
    /**
     * <p>
     * 服务实现类
     * </p>
     *
     * @author wangqinmin
     * @since 2019-03-21
     */
    @Service
    @Transactional(rollbackFor = Exception.class)
    @Slf4j
    public class UUserServiceImpl extends BaseServiceImpl<UUserMapper, UUser> implements UUserService {
     
        @Autowired
        private UUserMapper uUserMapper;
     
        /**
         * 修改缓存
         * <p>
         * redis缓存--更新（修改）数据
         *
         * @param uUser
         * @return
         * @CachePut 应用到写数据的方法上，如新增/修改方法，调用方法时会自动把相应的数据放入缓存
         */
        @CachePut(value = {"user"}, key = "#root.args[0]", unless = "#user eq null ")
        @Override
        public boolean redisCacheUpdateById(UUser uUser) {
            int i = uUserMapper.updateById(uUser);
            if (i == 1) {
                return true;
            }
            return false;
        }
     
        /**
         * 删除缓存
         *
         * @param id
         * @return
         * @CacheEvict 应用到删除数据的方法上，调用方法时会从缓存中删除对应key的数据condition 与unless相反，只有表达式为真才会执行。
         * redis缓存--移除数据
         */
        @CacheEvict(value = {"user"}, key = "#root.args[0]", condition = "#result eq true")
        @Override
        public boolean redisCacheRemoveById(String id) {
            int i = uUserMapper.deleteById(id);
            if (i == 1) {
                return true;
            }
            return false;
        }
     
        /**
         * redis缓存--获取一条数据
         *
         * @param id
         * @return
         * @Cacheable 应用到读取数据的方法上，先从缓存中读取，如果没有再从DB获取数据，然后把数据添加到缓存中key 缓存在redis中的keyunless 表示条件表达式成立的话不放入缓存
         */
        @Cacheable(value = "user", key = "args[0]", unless = "#result eq null ")
        @Override
        public UUserVo redisCacheGetUUserById(String id) {
            return uUserMapper.getUUserById(id);
        }
     
    }

--------------------

如果你觉得本篇文章对你有所帮助的话，麻烦请点击头像右边的关注按钮，谢谢！

技术在交流中进步，知识在分享中传播