Hystrix的服务容错之请求缓存

た入场券 2023-01-04 14:32 185阅读 0赞

## 这个没什么好详细讲的，就是使用redis来做缓存 ##

注意重写一下redis的序列化方式就行，不要用他自带的JDK的Serializer方式，用通用的jackson，为啥，因为自带的序列化存储空间太大  
增加依赖

<dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-redis</artifactId>
                <version>2.1.3.RELEASE</version>
            </dependency>
            
            <dependency>
                <groupId>org.apache.commons</groupId>
                <artifactId>commons-pool2</artifactId>
                <version>2.6.2</version>
            </dependency>

重写redis的序列化

package com.qiangqiang.config;
    
    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.GenericJackson2JsonRedisSerializer;
    import org.springframework.data.redis.serializer.RedisSerializationContext;
    import org.springframework.data.redis.serializer.StringRedisSerializer;
    
    import java.time.Duration;
    
    @Configuration
    public class RedisConfiguration {
        /**
         * 重写Redis序列化方式，使用Json方式:
         * 当我们的数据存储到Redis的时候，我们的键（key）和值（value）都是通过Spring提供的Serializer序列化到Redis的。
         * RedisTemplate默认使用的是JdkSerializationRedisSerializer，
         * StringRedisTemplate默认使用的是StringRedisSerializer。
         * <p>
         * Spring Data JPA为我们提供了下面的Serializer：
         * GenericToStringSerializer、Jackson2JsonRedisSerializer、
         * JacksonJsonRedisSerializer、JdkSerializationRedisSerializer、
         * OxmSerializer、StringRedisSerializer。
         * 在此我们将自己配置RedisTemplate并定义Serializer。
         */
        @Bean
        public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
    
            RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
            redisTemplate.setConnectionFactory(redisConnectionFactory);
            //创建一个json的序列化对象
            GenericJackson2JsonRedisSerializer jackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
            //设置value的序列化方式json
            redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
            //设置key序列化方式string
            redisTemplate.setKeySerializer(new StringRedisSerializer());
    
            //设置hash key序列化方式string
            redisTemplate.setHashKeySerializer(new StringRedisSerializer());
            //设置hash value的序列化方式json
            redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
    //        redisTemplate.afterPropertiesSet();
            return redisTemplate;
        }
    
        //重写Cache序列化
        @Bean
        public RedisCacheManager employeeRedisCacheManager(RedisConnectionFactory redisConnectionFactory) {
            RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
                            .entryTtl(Duration.ofDays(1))   // 设置缓存过期时间为一天
    //                        .disableCachingNullValues()     // 禁用缓存空值，不缓存null校验
                            .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
                            .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()));     // 设置CacheManager的值序列化方式为json序列化，可加入@Class属性
            return RedisCacheManager.builder(redisConnectionFactory).cacheDefaults(redisCacheConfiguration).build();     // 设置默认的cache组件
        }
    }

主启动类开启缓存，和以前redis使用一样

package com.qiangqiang;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.cache.annotation.EnableCaching;
    import org.springframework.cloud.openfeign.EnableFeignClients;
    
    @SpringBootApplication
    @EnableFeignClients
    @EnableCaching
    public class SpringCloudOrderServerApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(SpringCloudOrderServerApplication.class, args);
        }
    
    }

接口的实现类

package com.qiangqiang.service.impl;
    
    
    import com.qiangqiang.entity.Order;
    import com.qiangqiang.entity.Product;
    import com.qiangqiang.service.OrderService;
    import com.qiangqiang.service.ProductService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.cache.annotation.Cacheable;
    import org.springframework.cloud.client.ServiceInstance;
    import org.springframework.cloud.client.discovery.DiscoveryClient;
    import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
    import org.springframework.core.ParameterizedTypeReference;
    import org.springframework.http.HttpMethod;
    import org.springframework.http.ResponseEntity;
    import org.springframework.stereotype.Service;
    import org.springframework.web.client.RestTemplate;
    
    import java.util.List;
    
    @Service
    public class OrderServiceImpl implements OrderService {
    
        @Autowired
        private ProductService productService;
    
        @Cacheable(cacheNames = "getOrderById:list:id",key = "#id")
        @Override
        public Order getOrder(Integer id) {
            Order order = new Order(1, "用户订单", 2, productService.getProductById(id));
            return order;
        }
    
        @Cacheable(cacheNames = "getOrderById:list")
        @Override
        public Order getOrderById() {
    
            Order order = new Order(1, "用户订单", 2, productService.getProduct());
            return order;
        } 
    }

ymi配置，看其中的redis配置即可

server:
      port: 8001
      tomcat:
        max-threads: 10     #降低最大线程数方便模拟高并发
    eureka:
      client:
        service-url:
          defaultZone: http://root:root@eureka2:8762/eureka/,http://root:root@eureka1:8761/eureka/
        register-with-eureka: true     #不注册到注册中心
      instance:
        instance-id: ${spring.cloud.client.ip-address}:${server.port}   #显示ip：port
        prefer-ip-address: true
        lease-renewal-interval-in-seconds: 5    #心跳间隔
        lease-expiration-duration-in-seconds: 15
    spring:
      application:
        name: order-server
      redis:
        # redis数据库索引(默认为0)，我们使用索引为3的数据库，避免和其他数据库冲突
        database: 0
        # redis服务器地址（默认为loaclhost）
        host: 127.0.0.1
        # redis端口（默认为6379）
        port: 6379
        # redis访问密码（默认为空）
        password:
        # redis连接超时时间（单位毫秒）
        timeout: 10000ms
        # redis连接池配置
        lettuce:
          pool:
            # 最大可用连接数（默认为8，负数表示无限）
            max-active: 1024
            # 最大空闲连接数（默认为8，负数表示无限）
            max-idle: 200
            # 最小空闲连接数（默认为0，该值只有为正数才有用）
            min-idle: 5
            # 从连接池中获取连接最大等待时间（默认为-1，单位为毫秒，负数表示无限）
            max-wait: 10000ms
    product-server:
      ribbon:
        NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule
    ribbon:
      ConnecTimeout: 5000
      ReadTimeout: 5000