@Component
public class SidecarHealthIndicator extends AbstractHealthIndicator {

    @Autowired
    AiConfig aiConfig;

    @Override
    protected void doHealthCheck(Health.Builder builder) throws Exception {
        try {
            String result;
            if (aiConfig.aiFaceType.equals(FaceType.NT.name())) {
                result = HttpUtil.get(aiConfig.aiFaceUrl + "/version", aiConfig.aiFaceUrlTimeout);
                builder.withDetail("version", result);
            } else if (aiConfig.aiFaceType.equals(FaceType.KS.name())) {
                result = HttpUtil.get(aiConfig.aiFaceUrl + "/version", aiConfig.aiFaceUrlTimeout);
                JSONObject r = JSONUtil.parseObj(result);
                builder.withDetail("version", r.getStr("platform_version"));
            } else {
                result = HttpUtil.get(aiConfig.aiFaceUrl + "/version", aiConfig.aiFaceUrlTimeout);
                builder.withDetail("version", result);
            }
            builder.up();
        } catch (Exception e) {
            builder.down(e);
        }
    }
}

if ("true".equals(request.getHeader("sub"))) {
           log.info("sub request " + request.getRequestURI());
       } else {
           ThreadUtil.execAsync(() -> {
               String uri = request.getRequestURI();
               log.info("main request " + uri);
               List<String> urls = aiConfig.aiFaceStatefulUrls;
               if (urls.contains(uri)) {
                   BodyReaderHttpServletRequestWrapper requestWrapper = null;
                   try {
                       requestWrapper = new BodyReaderHttpServletRequestWrapper(request);
                   } catch (IOException e) {
                       log.error("read body error: {}", e.getMessage());
                   }
                   String body = IoUtil.read(requestWrapper.getInputStream(), requestWrapper.getCharacterEncoding());
                   log.debug("请求体：{}", body);
                   String ip = discoveryProperties.getIp();
                   List<ServiceInstance> instanceList = discoveryClient.getInstances("xkiot-ai");
                   for (ServiceInstance serviceInstance : instanceList) {
                       if (!ip.equals(serviceInstance.getHost())) {
                           String url = serviceInstance.getUri().toString() + uri;
                           HttpRequest.post(url).header("sub", "true").body(body).execute(true).body();
                       }
                   }
               }
           });
       }
       return true;

import org.springframework.util.StreamUtils;

import javax.servlet.ReadListener;
import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

public class BodyReaderHttpServletRequestWrapper extends HttpServletRequestWrapper {

    private byte[] requestBody = null;//用于将流保存下来

    public BodyReaderHttpServletRequestWrapper(HttpServletRequest request) throws IOException {
        super(request);
        requestBody = StreamUtils.copyToByteArray(request.getInputStream());
    }

    @Override
    public ServletInputStream getInputStream() {
        final ByteArrayInputStream bodyStream = new ByteArrayInputStream(requestBody);
        return new ServletInputStream() {
            @Override
            public int read() {
                return bodyStream.read();  // 读取 requestBody 中的数据
            }

            @Override
            public boolean isFinished() {
                return false;
            }

            @Override
            public boolean isReady() {
                return false;
            }

            @Override
            public void setReadListener(ReadListener readListener) {
            }
        };
    }

    @Override
    public BufferedReader getReader() {
        return new BufferedReader(new InputStreamReader(getInputStream()));
    }

}

import org.springframework.stereotype.Component;

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;

@Component
@WebFilter(urlPatterns = "/**", filterName = "BodyReadFilter")
public class BodyReadFilter implements Filter {
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        ServletRequest requestWrapper = null;
        if (servletRequest instanceof HttpServletRequest) {
            requestWrapper = new BodyReaderHttpServletRequestWrapper((HttpServletRequest) servletRequest);
        }
        if (requestWrapper == null) {
            filterChain.doFilter(servletRequest, servletResponse);
        } else {
            filterChain.doFilter(requestWrapper, servletResponse);
        }
    }
}

import cn.hutool.core.io.IoUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;


@Slf4j
public class StatefulFeignInterceptor implements HandlerInterceptor {

    @Autowired
    AiConfig aiConfig;

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

        if (aiConfig.aiFaceStatefulUrls.contains(request.getRequestURI())) {
            BodyReaderHttpServletRequestWrapper requestWrapper = new BodyReaderHttpServletRequestWrapper(request);
            String body = IoUtil.read(requestWrapper.getInputStream(), requestWrapper.getCharacterEncoding());
            log.debug("请求体：{}", body);
        }
        return true;
    }

}

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class StatefulConfig implements WebMvcConfigurer {

    /**
     * 解决StatefulFeignInterceptor里面的使用Autowired注入为null的问题
     *
     * @return
     */
    @Bean
    public StatefulFeignInterceptor statefulFeignInterceptor() {
        return new StatefulFeignInterceptor();
    }

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(statefulFeignInterceptor()).addPathPatterns("/**");
    }
}

@Component
public class RedisRouteDefinitionRepository implements RouteDefinitionRepository {
    private static final Logger log = LoggerFactory.getLogger(RedisRouteDefinitionRepository.class);
    public static final String GATEWAY_ROUTES = CacheConstants.GATEWAY_ROUTES;
    @Autowired
    private RedisService redisService;

    @Override
    public Flux<RouteDefinition> getRouteDefinitions() {
        log.debug("get route info by redis/db");
        List<RouteDefinition> routeDefinitions = new ArrayList<>();
        //定义路由信息，可以从redis/db等地方获取路由信息
        redisService.getAllCacheMapValues(GATEWAY_ROUTES).stream().forEach(routeDefinition -> {
            routeDefinitions.add(JSON.parseObject(routeDefinition.toString(), RouteDefinition.class));
        });
        return Flux.fromIterable(routeDefinitions);
    }

    @Override
    public Mono<Void> save(Mono<RouteDefinition> route) {
        log.debug("save route info to redis/db");
        return route.flatMap(routeDefinition -> {
            redisService.setCacheMapValue(GATEWAY_ROUTES, routeDefinition.getId(), JSON.toJSONString(routeDefinition));
            return Mono.empty();
        });
    }

    @Override
    public Mono<Void> delete(Mono<String> routeId) {
        log.debug("delete route info by redis/db");
        return routeId.flatMap(id -> {
            if (redisService.getCacheMapValue(GATEWAY_ROUTES, id)) {
                redisService.delCacheMapValue(GATEWAY_ROUTES, id);
                return Mono.empty();
            }
            return Mono.defer(() -> Mono.error(new BaseException("路由配置没有找到: " + routeId)));
        });
    }
}

@Service
public class GatewayServiceHandler implements ApplicationEventPublisherAware {
    private static final Logger log = LoggerFactory.getLogger(GatewayServiceHandler.class);

    @Autowired
    private RedisRouteDefinitionRepository routeDefinitionWriter;

    private ApplicationEventPublisher publisher;

    @Override
    public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
        this.publisher = applicationEventPublisher;
    }

    /**
     * 保存或更新多个路由配置
     * @param gatewayRouteList
     * @return
     */
    public String saveOrUpdateMultiRouteConfig(List<JSONObject> gatewayRouteList) {
        log.debug("begin add multi route config");
        gatewayRouteList.forEach(gatewayRoute -> {
            RouteDefinition definition = handleData(gatewayRoute);
            routeDefinitionWriter.save(Mono.just(definition)).subscribe();
        });
        this.publisher.publishEvent(new RefreshRoutesEvent(this));
        return "success";
    }

    /**
     * json数据转换为路由实体
     * @param gatewayRoute
     * @return
     */
    private RouteDefinition handleData(JSONObject gatewayRoute) {
        RouteDefinition definition;
        definition = JSONObject.toJavaObject(gatewayRoute, RouteDefinition.class);
        return definition;
    }
}

@RestController
@RequestMapping("/route")
public class RouteConfigController extends BaseController {
    @Autowired
    private GatewayServiceHandler gatewayServiceHandler;

    /**
     * 新增更新路由配置接口
     *
     * @param gatewayRouteList
     * @return
     */
    @PostMapping
    public AjaxResult add(@Validated @RequestBody List<JSONObject> gatewayRouteList) {
        String result = gatewayServiceHandler.saveOrUpdateMultiRouteConfig(gatewayRouteList);
        return AjaxResult.success(result);
    }
}

//开启缓存功能
@EnableCaching
//缓存没有数据查执行方法里面的内容，然后将执行的结果缓存起来，缓存里面有直接读缓存，不会执行方法里面的内容，参数会作为key
@Cacheable("user_info")
public User findById(String id)
//参数unless对结果进行判断，condition对参数进行判断  
//缓存不管是否存在都会执行方法里面的内容并更新缓存   
@CachePut(value="user_info")   
//删除缓存   
@CacheEvict(value="user_info")
//多个缓存分组   
@Caching
//注解到类上面，类里面的方法只需要添加注解@Cacheable，不用在指定cacheName了
@CacheConfig(cacheNames={"user_info"})
   

@CacheConfig(cacheNames = {"mongo"})
public interface BaseDao<T, ID> {
  	//#root.target.table为SpEL表达式，当前被调用的目标对象实例的table的值
    @Cacheable(key = "#root.target.table+#p0",condition ="#root.target.isCache")
    T findById(ID id);
    @CachePut(key = "#root.target.table+#p0.id",condition ="#root.target.isCache")
    <S extends T> S save(S entity);
    @CacheEvict(key = "#root.target.table+#p0",condition ="#root.target.isCache")
    void deleteById(ID id);
  	//删除所有是删除mongo所有的表，粒度不能到key
    @CacheEvict(key="#root.target.table",allEntries=true,condition="#root.target.isCache")
    void deleteAll();
  	//用来设置是否开启缓存
    void enableCache(boolean isCache);
}

public class BaseDaoImpl<T, ID> implements BaseDao<T, ID> {
    private SimpleMongoRepository<T, ID> mongoRepository;
    private Class<T> entityType;
    private Class<ID> identifierType;
    protected MongoTemplate mongoTemplate;
		//这里用来存储表的名字
    public String table;
  	//这里用来判断是否开启redis缓存
    public Boolean isCache = false;
		//构造方法初始化
    public BaseDaoImpl() {
        ResolvableType resolvableType = ResolvableType.forClass(getClass());
        entityType=(Class<T>)resolvableType.as(BaseDao.class).getGeneric(0).resolve();
        identifierType=(Class<ID>)resolvableType.as(BaseDao.class).getGeneric(1).resolve();
      	//初始化表的名字，用“:”是因为可以在redis里面进行分类
        table=entityType.getSimpleName()+":";
    }
  
    @Autowired
    public void setMongoTemplate(MongoTemplate mongoTemplate) {
        this.mongoTemplate = mongoTemplate;
        MappingMongoEntityInformation<T, ID> entityInformation = new MappingMongoEntityInformation<T, ID>(
                new BasicMongoPersistentEntity<>(ClassTypeInformation.from(entityType)), identifierType);
        mongoRepository = new SimpleMongoRepository<T, ID>(entityInformation, mongoTemplate);
    }

    @Override
    public T findById(ID id) {
        return mongoTemplate.findOne(Query.query(Criteria.where("Id").is(id.toString())), entityType);
    }
  
      @Override
    public void enableCache(boolean isCache) {
        this.isCache = isCache;
    }
}

public interface UserDao extends BaseDao<User, String> {
    void updateAddNumById(String id); //自定义的接口
}

@Repository
public class UserDaoImpl extends BaseDaoImpl<User, String> implements UserDao {
		
    public UserDaoImpl() {
        super.enableCache(true); //这里进开启缓存设置，默认是不开启的
    }

    @Override
    public void updateAddNumById(String id) {
    }
}

public class CustomizedRedisCacheManager extends RedisCacheManager {
    private final RedisCacheWriter cacheWriter;
    private final RedisCacheConfiguration defaultCacheConfig;


    public CustomizedRedisCacheManager(RedisCacheWriter cacheWriter, RedisCacheConfiguration defaultCacheConfiguration) {
        super(cacheWriter, defaultCacheConfiguration);
        this.cacheWriter = cacheWriter;
        this.defaultCacheConfig = defaultCacheConfiguration;
    }

    public CustomizedRedisCacheManager(RedisCacheWriter cacheWriter, RedisCacheConfiguration defaultCacheConfiguration, String... initialCacheNames) {
        super(cacheWriter, defaultCacheConfiguration, initialCacheNames);
        this.cacheWriter = cacheWriter;
        this.defaultCacheConfig = defaultCacheConfiguration;
    }

    public CustomizedRedisCacheManager(RedisCacheWriter cacheWriter, RedisCacheConfiguration defaultCacheConfiguration, boolean allowInFlightCacheCreation, String... initialCacheNames) {
        super(cacheWriter, defaultCacheConfiguration, allowInFlightCacheCreation, initialCacheNames);
        this.cacheWriter = cacheWriter;
        this.defaultCacheConfig = defaultCacheConfiguration;
    }

    public CustomizedRedisCacheManager(RedisCacheWriter cacheWriter, RedisCacheConfiguration defaultCacheConfiguration, Map<String, RedisCacheConfiguration> initialCacheConfigurations) {
        super(cacheWriter, defaultCacheConfiguration, initialCacheConfigurations);
        this.cacheWriter = cacheWriter;
        this.defaultCacheConfig = defaultCacheConfiguration;
    }

    public CustomizedRedisCacheManager(RedisCacheWriter cacheWriter, RedisCacheConfiguration defaultCacheConfiguration, Map<String, RedisCacheConfiguration> initialCacheConfigurations, boolean allowInFlightCacheCreation) {
        super(cacheWriter, defaultCacheConfiguration, initialCacheConfigurations, allowInFlightCacheCreation);
        this.cacheWriter = cacheWriter;
        this.defaultCacheConfig = defaultCacheConfiguration;
    }

    /**
     * 这个构造方法最重要
     **/
    public CustomizedRedisCacheManager(RedisConnectionFactory redisConnectionFactory, RedisCacheConfiguration cacheConfiguration) {
        this(RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory), cacheConfiguration);
    }

    @Override
    public Map<String, RedisCacheConfiguration> getCacheConfigurations() {
        Map<String, RedisCacheConfiguration> configurationMap = new HashMap<>(getCacheNames().size());
        getCacheNames().forEach(it -> {
            RedisCache cache = CustomizedRedisCache.class.cast(lookupCache(it));
            configurationMap.put(it, cache != null ? cache.getCacheConfiguration() : null);
        });
        return Collections.unmodifiableMap(configurationMap);
    }

    @Override
    protected RedisCache createRedisCache(String name, RedisCacheConfiguration cacheConfig) {
        return new CustomizedRedisCache(name, cacheWriter, cacheConfig != null ? cacheConfig : defaultCacheConfig);
    }
}

public class CustomizedRedisCache extends RedisCache {
    private final String name;
    private final RedisCacheWriter cacheWriter;
    private final ConversionService conversionService;

    /**
     * Create new {@link RedisCache}.
     *
     * @param name        must not be {@literal null}.
     * @param cacheWriter must not be {@literal null}.
     * @param cacheConfig must not be {@literal null}.
     */
    protected CustomizedRedisCache(String name, RedisCacheWriter cacheWriter, RedisCacheConfiguration cacheConfig) {
        super(name, cacheWriter, cacheConfig);
        this.name = name;
        this.cacheWriter = cacheWriter;
        this.conversionService = cacheConfig.getConversionService();
    }

    @Override
    public void evict(Object key) {
        if (key instanceof String) {
            String keyString = key.toString();
            // 后缀删除
            if (keyString.endsWith("*")) {
                byte[] pattern = this.conversionService.convert(this.createCacheKey(key), byte[].class);
                this.cacheWriter.clean(this.name, pattern);
                return;
            }
        }
        // 删除指定的key
        super.evict(key);
    }
}

@Configuration
public class CachingConfig {
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
       //两个转换器二选一，也可以自定义
      	//fastJson转换器
        FastJson2JsonRedisSerializer serializer = new FastJson2JsonRedisSerializer(Object.class);
        //jackson转换器
//        Jackson2JsonRedisSerializer<Object> serializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
//        ObjectMapper objectMapper = new ObjectMapper();
//        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
//        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
//        serializer.setObjectMapper(objectMapper);      
        RedisCacheConfiguration cacheConfiguration = RedisCacheConfiguration
                .defaultCacheConfig()
                //添加下面这句存到redis里面的数据就是以json格式，不添加就是二进制格式缓存。
          			//为了解决二进制格式下list数据丢失，改成以json存储
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(serializer));
        return new CustomizedRedisCacheManager(redisConnectionFactory, cacheConfiguration);
    }
}

//删除table开头的所有key
@CacheEvict(key = "#root.target.table+'*'",condition ="#root.target.isCache")