SpringBoot_缓存_Redis

雨点打透心脏的1/2处 2021-10-06 02:58 454阅读 0赞

### SpringBoot\_缓存\_Redis ###

*  方式一
 *   *  添加依赖
     *  添加配置文件
     *  代码中使用
 *  方式二
 *   *  引用依赖
     *  配置类
     *  工具类
     *  自定义注解缓存

# 方式一 #

## 添加依赖 ##

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

## 添加配置文件 ##

spring.redis.host=127.0.0.1
    spring.redis.port=6379
    spring.redis.pool.max-active=5   #最大连接池

## 代码中使用 ##

@Autowired
    private StringRedisTemplate redisTemplate;

# 方式二 #

## 引用依赖 ##

<dependency>
    		<groupId>org.springframework.boot</groupId>
    		<artifactId>spring-boot-starter-data-redis</artifactId>
    	</dependency>
    	
    	<dependency>
    		<groupId>org.apache.commons</groupId>
    		<artifactId>commons-pool2</artifactId>
    	</dependency>
    	<dependency>
    		<groupId>com.alibaba</groupId>
    		<artifactId>fastjson</artifactId>
    	</dependency>
    	<dependency>
    		<groupId>com.google.code.gson</groupId>
    		<artifactId>gson</artifactId>
    	</dependency>

## 配置类 ##

//# 自定义缓存喷子
    //pingruan:
    //	  base:
    //	    cache-redis-ttl: -1
    //
    //spring:
    //  application:
    //    name: vander-springboot-demo
    //  redis:
    //    timeout: 6000ms
    //    password: 
    //    port: 6379
    //    database: 0
    //    host: 192.168.164.100
    //    lettuce: 
    //      pool: 
    //        max-active: 1000  # 连接池最大连接数（使用负值表示没有限制）
    //        max-idle: 10 # 连接池中的最大空闲连接
    //        min-idle: 5 # 连接池中的最小空闲连接
    //        max-wait: -1 # 连接池最大阻塞等待时间（使用负值表示没有限制）
    
    //缓存业务数据步骤：
    //1、缓存
    //@Cacheable(value = "project_user",key = "'id_' + #id")
    //2、删除
    //@CacheEvict(value="project_user",key="'id_' + #id")
    //3、修改
    //@CachePut(value="project_user",key="'id_' + #id")
    //备注：
    //#user.id  获取方法user对象的id值
    
    //指定方法唯一数据缓存，方式一：
    //@Cacheable(value = "project_cache",keyGenerator="keyGenerator")
    
    //指定方法唯一数据缓存（可以指定过期时间s），方式二：
    //@VCacheable(expireTime=60)
    
    @Configuration
    @EnableCaching // 开启缓存支持
    @AutoConfigureAfter(RedisAutoConfiguration.class)
    @SuppressWarnings("all")
    public class RedisConfig extends CachingConfigurerSupport {
    	
    	@Autowired
    	private BProperties bProperties;
    	
    	@Bean
    	public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory factory) {
    		RedisTemplate<String, Object> template = new RedisTemplate<>();
    		RedisSerializer<String> redisSerializer = new StringRedisSerializer();
    		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.setConnectionFactory(factory);
    		// key序列化方式
    		template.setKeySerializer(redisSerializer);
    		// value序列化
    		template.setValueSerializer(jackson2JsonRedisSerializer);
    		// value hashmap序列化
    		template.setHashValueSerializer(jackson2JsonRedisSerializer);
    		return template;
    	}
    	
    	@Bean
    	public ValueOperations<String, Object> valueOperations(RedisTemplate<String, Object> redisTemplate){
    		ValueOperations<String, Object> opsForValue =redisTemplate.opsForValue();
    		return opsForValue;
    	}
    	
    	//缓存管理器
    	@Bean
    	public CacheManager cacheManager(LettuceConnectionFactory factory) {
    		RedisSerializer<String> redisSerializer = new StringRedisSerializer();
    		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);
    
    		// 配置序列化（解决乱码的问题）,过期时间30秒
    		RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig().entryTtl(Duration.ofSeconds(bProperties.getCacheRedisTtl()))
    				.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))
    				.serializeValuesWith(
    						RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer))
    				.disableCachingNullValues();
    		RedisCacheManager cacheManager = RedisCacheManager.builder(factory).cacheDefaults(config).build();
    		return cacheManager;
    	}
    
    	/**
    	 * 
    	 * 1、针对调用方法唯一缓存，使用该方式
    	 * 2、该方法只是声明了key的生成策略,还未被使用,需在@Cacheable注解中指定keyGenerator
    	 * 3、如: @Cacheable(value = "users", keyGenerator = "keyGenerator")
    	 */
    	@Bean
    	public KeyGenerator keyGenerator() {
    		return new KeyGenerator() {
    			@Override
    			public Object generate(Object target, Method method, Object... params) {
    				StringBuffer sb = new StringBuffer();
    				sb.append(target.getClass().getName());
    				sb.append(method.getName());
    				for (Object obj : params) {
    					sb.append(JSON.toJSONString(obj).hashCode());
    				}
    				return sb.toString();
    			}
    		};
    	}
    }

## 工具类 ##

/**
     * Redis工具类
     * 
     * 
     * @author vander
     * @date 2018年11月28日
     */
    @Component
    public class RedisService {
    	
        @Autowired(required=false)
        private RedisTemplate<String, Object> redisTemplate;
    
        @Autowired(required=false)
        private ValueOperations<String, Object> valueOperations;
        
        
        /**  默认过期时长，单位：秒 */
        public final static long DEFAULT_EXPIRE = 60 * 60 * 24;//1天
        /**  不设置过期时长 */
        public final static long NOT_EXPIRE = -1;
        private final static Gson gson = new Gson();
        
        public void set(String key, Object value, long expire){
            try{
            	valueOperations.set(key, toJson(value));
                if(expire != NOT_EXPIRE){
                    redisTemplate.expire(key, expire, TimeUnit.SECONDS);
                }
            }catch (Exception e){
                throw new BException("Redis服务异常",500);
            }
        }
    
        public void set(String key, Object value){
            try{
                set(key, value, DEFAULT_EXPIRE);
            }catch (Exception e){
                throw new BException("Redis服务异常",500);
            }
    
        }
        public <T> T get(String key, Class<T> clazz, long expire) {
            String value = null;
            try{
                value = valueOperations.get(key).toString();
                if(expire != NOT_EXPIRE){
                    redisTemplate.expire(key, expire, TimeUnit.SECONDS);
                }
            }catch (Exception e){
                throw new BException("Redis服务异常",500);
            }
            return value == null ? null : fromJson(value, clazz);
        }
        
        public <T> T get(String key, Type clazz, long expire) {
            String value = null;
            try{
                value = valueOperations.get(key).toString();
                if(expire != NOT_EXPIRE){
                    redisTemplate.expire(key, expire, TimeUnit.SECONDS);
                }
            }catch (Exception e){
                throw new BException("Redis服务异常",500);
            }
            return value == null ? null : fromJson(value, clazz);
        }
    
        public <T> T get(String key, Class<T> clazz) {
            T t;
            try{
                t = get(key, clazz, NOT_EXPIRE);
            }catch (Exception e){
                throw new BException("Redis服务异常",500);
            }
            return t;
        }
        
        public <T> T get(String key, Type clazz) {
            T t;
            try{
                t = get(key, clazz, NOT_EXPIRE);
            }catch (Exception e){
                throw new BException("Redis服务异常",500);
            }
            return t;
        }
    
        public String get(String key, long expire) {
            String value = null;
            try{
                value = valueOperations.get(key).toString();
                if(expire != NOT_EXPIRE){
                    redisTemplate.expire(key, expire, TimeUnit.SECONDS);
                }
            }catch (Exception e){
                throw new BException("Redis服务异常",500);
            }
            return value;
        }
    
        public String get(String key) {
            String str = null;
            try{
                str = get(key, NOT_EXPIRE);
            }catch (Exception e){
                throw new BException("Redis服务异常",500);
            }
            return str;
        }
    
        public void delete(String key) {
            try{
                redisTemplate.delete(key);
            }catch (Exception e){
                throw new BException("Redis服务异常",500);
            }
        }
    
        /**
         * Object转成JSON数据
         */
        private String toJson(Object object){
            if(object instanceof Integer || object instanceof Long || object instanceof Float ||
                    object instanceof Double || object instanceof Boolean || object instanceof String){
                return String.valueOf(object);
            }
            return gson.toJson(object);
        }
    
        /**
         * JSON数据，转成Object
         */
        private <T> T fromJson(String json, Class<T> clazz){
            return gson.fromJson(json, clazz);
        }
        
        /**
         * JSON数据，转成Object
         */
        private <T> T fromJson(String json,Type clazz){
            return gson.fromJson(json, clazz);
        }
    
    	public boolean hasKey(String key) {
    		return redisTemplate.hasKey(key);
    	}
    }

## 自定义注解缓存 ##

/**
     * 自定义缓存aop
     * 
     * @author vander
     *
     */
    @Component
    @Aspect
    public class CacheableAspect {
    
    	@Autowired
    	RedisService redisService;
    
    	@Pointcut("@annotation(org.pingruan.framework.component.starter.data.redis.custom.VCacheable)")
    	public void annotationPointcut() {
    	}
    
    	@Around("annotationPointcut()")
    	public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
    		// 获得当前访问的class
    		Class<?> className = joinPoint.getTarget().getClass();
    		// 获得访问的方法名
    		String methodName = joinPoint.getSignature().getName();
    		// 得到方法的参数的类型
    		Class<?>[] argClass = ((MethodSignature) joinPoint.getSignature()).getParameterTypes();
    		Object[] args = joinPoint.getArgs();
    		String key = "";
    		long expireTime = 1800; //30分钟
    		// 得到访问的方法对象
    		Method method = className.getMethod(methodName, argClass);
    		Type type = method.getAnnotatedReturnType().getType();
    		method.setAccessible(true);
    		// 判断是否存在@VCacheable注解
    		if (method.isAnnotationPresent(VCacheable.class)) {
    			VCacheable annotation = method.getAnnotation(VCacheable.class);
    			String keys = annotation.key();
    			if (StringUtils.isNotBlank(keys)) {
    				key = keys;
    			} else {
    				key = getKey(className.getName(), methodName, args);
    			}
    			expireTime = annotation.expireTime();
    		}
    		// 获取缓存是否存在
    		boolean hasKey = redisService.hasKey(key);
    		if (hasKey) {
    			return redisService.get(key,type);
    		} else {
    			Object res = joinPoint.proceed();
    			redisService.set(key, res, expireTime);
    			return res;
    		}
    	}
    
    	/**
    	 * 获取唯一key
    	 * 
    	 * @param name
    	 * @param methodName
    	 * @param args
    	 * @return
    	 */
    	private String getKey(String name, String methodName, Object[] args) {
    		StringBuffer sb = new StringBuffer();
    		sb.append(name).append(".").append(methodName);
    		for (Object object : args) {
    			sb.append(JSON.toJSONString(object).hashCode());
    		}
    		return sb.toString();
    	}
    
    }
    
    @Target({ ElementType.METHOD })
    @Retention(RetentionPolicy.RUNTIME)
    public @interface VCacheable {
    	String key() default ""; 
    	long expireTime() default 1800;// 30分钟
    }