package top.quhailong.pan.file.gateway.filter;
@Component//将这个类注册成Spring bean
@RefreshScope// 允许在允许的时候刷新这个bean,通常用于动态更新配置属性
public class TokenFilter implements GlobalFilter, Ordered {
    @Value("${filter-url}")
    private String filterUrl;// 从nacos读取
    //包含需要进行令牌验证的 URL 列表，从配置中注入
    
    
    
    
    
    
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        ServerHttpRequest request = exchange.getRequest();//从exchange中获得当前请求的request
        String uri = request.getURI().getPath();//从request中获得uri
        List<String> uriList = Arrays.asList(filterUrl.split(","));//分割这个filterUrl，获取全部需要拦截的url列表
        for (String filterUrl:uriList) {///如果当前这个url需要被拦截，就拦截下来，验证token，如果有token，且正确，就可以放行
            if(uri.contains(filterUrl)){
                return verifyToken(exchange, chain);
            }
        }
        return chain.filter(exchange);
    }
    
    
// 这里就是验证token方法
    private Mono<Void> verifyToken(ServerWebExchange exchange, GatewayFilterChain chain) {
        try {
            ServerHttpRequest request;//尝试从请求的 Cookies 中获取名为 token 的令牌。
            HttpCookie cookie = exchange.getRequest().getCookies().getFirst("token");//获得token，返回类型是cookie类型
            String token = cookie.getValue();
            
            //解析token（JWT）令牌，获得claim对象，这个对象是个啥。如果令牌失效就会返回错误的响应
            Claims claims = JWTUtils.parseJWT(token, "nimadetou".getBytes());
            //从 Claims 中提取 subject 并将其转换为 UserInfoDTO 对象。
            String subject = claims.getSubject();
            UserInfoDTO userinfo = JSONUtils.parseObject(subject, UserInfoDTO.class);
            
            
            
            //将编码后的用户信息添加到请求头中，继续处理请求。
            String operationInfo = URLEncoder.encode(JSONUtils.toJSONString(userinfo), StandardCharsets.UTF_8.toString());
            
            // 把这个请求头放到request里面，然后继续向后面传递
            request = exchange.getRequest().mutate().header("operationInfo", operationInfo).build();
            return chain.filter(exchange.mutate().request(request).build());
        } catch (Exception e) {
            ServerHttpResponse response = exchange.getResponse();
            response.getHeaders().add("Content-Type", "application/json;charset=UTF-8");
            DataBuffer dataBuffer = response.bufferFactory().wrap(JSON.toJSONString(RestAPIResultDTO.Error("token验证失败")).getBytes());
            return response.writeWith(Flux.just(dataBuffer));
        }
    }

    @Override
    public int getOrder() {
        return 0;//返回过滤器的顺序，数值越小优先级越高。这里返回 0 表示最高优先级。
    }
}

Header.Payload.Signature

@FeignClient(name = "some-service")// 这个指定了远程调用的服务名，一般是在服务注册中心中注册的服务吗
// 这个注释说明spring cloud feign要创建一个这个接口的代理实例，并将其用于名"some-service"发送远程服务的请求
public interface SomeServiceClient {
    @GetMapping("/some-endpoint")//定义了一个get请求，目标是远程服务some-service的/some-endpoint 端点
    ResponseEntity<String> getSomeData();
    // 这个是feign客户端接口的方法的定义，也就是说，如果这个方法被调用了，那么就会把相应的请求转发到这个远程服务的端点上，、
    // 此外还定义了这个方法的响应，也就是ResponseEntity<String>，接受响应的结果
}

@RestController
public class SomeOtherServiceController {

    @Autowired
    private SomeServiceClient someServiceClient;

    @GetMapping("/use-some-service")
    public ResponseEntity<String> useSomeService() {
        // 调用远程服务的端点
        //这里就调用了一里面的客户端
        return someServiceClient.getSomeData();
    }
}

@RestController
public class SomeServiceController {

    @GetMapping("/some-endpoint")
    public ResponseEntity<String> getSomeData() {
        // 服务逻辑处理
        return ResponseEntity.ok("Some data from some-service");
    }
}

@Autowired
    private SomeServiceClient someServiceClient;

return someServiceClient.getSomeData();

@GetMapping("/some-endpoint")//定义了一个get请求，目标是远程服务some-service的/some-endpoint 端点
   ResponseEntity<String> getSomeData();

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

@SpringBootApplication
@EnableFeignClients
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

@FeignClient(name = "some-service")
public interface SomeServiceClient {

    @GetMapping("/some-endpoint")
    ResponseEntity<String> getSomeData();

    @GetMapping("/another-endpoint")
    ResponseEntity<String> getAnotherData(@RequestParam("param") String param);
}

@RestController
public class SomeOtherServiceController {

    @Autowired
    private SomeServiceClient someServiceClient;

    @GetMapping("/use-some-service")
    public ResponseEntity<String> useSomeService() {
        // 调用远程服务的端点
        return someServiceClient.getSomeData();
    }

    @GetMapping("/use-another-service")
    public ResponseEntity<String> useAnotherService(@RequestParam("param") String param) {
        // 调用另一个远程服务的端点
        return someServiceClient.getAnotherData(param);
    }
}

feign:
  client:
    config:
      default:
        connectTimeout: 5000
        readTimeout: 5000
        loggerLevel: full

Feign.Builder builder = Feign.builder()
                             .decoder(new JacksonDecoder())//将 HTTP 响应解码为响应对象
                             .encoder(new JacksonEncoder());//将请求对象编码为 HTTP 请求
SomeServiceClient client = builder.target(SomeServiceClient.class, "http://some-service");

Client client = new OkHttpClient();
Feign.Builder builder = Feign.builder().client(client);

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Import(FeignClientsRegistrar.class)
public @interface EnableFeignClients {
    String[] value() default {};
    String[] basePackages() default {};//指定要扫描的包。
    Class<?>[] basePackageClasses() default {};
    Class<?>[] defaultConfiguration() default {};//指定默认的配置类。
    Class<?>[] clients() default {};//指定具体的 Feign 客户端类。
}

@Configuration
@ConditionalOnClass(Feign.class)
@Import(FeignClientsConfiguration.class)
public class FeignAutoConfiguration {
    @Bean
    @ConditionalOnMissingBean
    public Feign.Builder feignBuilder() {
        return Feign.builder();
    }

    @Bean
    @ConditionalOnMissingBean
    public Decoder feignDecoder() {
        return new OptionalDecoder(new ResponseEntityDecoder(new SpringDecoder(this.messageConverters)));
    }

    @Bean
    @ConditionalOnMissingBean
    public Encoder feignEncoder() {
        return new SpringEncoder(this.messageConverters);
    }

    @Bean
    @ConditionalOnMissingBean
    public Contract feignContract() {
        return new SpringMvcContract();
    }

    @Bean
    @ConditionalOnMissingBean
    public Logger feignLogger() {
        return new Slf4jLogger();
    }
}

@Configuration
public class FeignClientsConfiguration {
    @Bean
    public Decoder feignDecoder() {
        return new ResponseEntityDecoder(new SpringDecoder(messageConverters));
    }

    @Bean
    public Encoder feignEncoder() {
        return new SpringEncoder(messageConverters);
    }

    @Bean
    public Contract feignContract() {
        return new SpringMvcContract();
    }

    @Bean
    public Logger feignLogger() {
        return new Slf4jLogger();
    }
}

public class FeignClientFactoryBean implements FactoryBean<Object>, InitializingBean {
    @Override
    public Object getObject() throws Exception {
        return feignContext.getInstance(this.name, Feign.Builder.class)
                           .target(this.targetType, this.url);
    }
    
    @Override
    public void afterPropertiesSet() throws Exception {
        // 初始化配置
    }
}

package top.quhailong.pan.framework.redis.core.idempotent.aop;
@Order(1)// 设置切面的执行顺序，值越小优先级越高
@Aspect//表明这个类是一个切面类
@Slf4j//引入日志记录功能
class IdempotentAopHandler {
    @Autowired
    private RedisUtil redisUtil;
    /**
     * 设置操作日志切入点 记录操作日志 在注解的位置切入代码
     @annotation(top.quhailong.pan.framework.redis.core.idempotent.annotation.Idempotent) 标识将匹配，即，将会在所有标注了这个注释的方法拦截，并调用aop
     */ 			
    @Pointcut("@annotation(top.quhailong.pan.framework.redis.core.idempotent.annotation.Idempotent)")
    public void IdempotentPointCut() {
    }
    // 通过定义切入点，环绕通知（@Around 注解标注的方法）可以使用该切入点来指定在哪些方法执行前后进行额外的处理。
    /**
     * 环绕通知，接口幂等
     * @author: quhailong
     * @date: 2020/7/26
     * round定义了一个环绕通知,围绕切点定义的方法的前后
     */
    
    
    
    
    
    
    
    
    
    // 这里需要处理幂等性控制逻辑
    // 通过这个注释，知道要在哪里拦截，那么就通过反射得到被拦截的方法和它的注释信息，
     //MethodSignature signature = (MethodSignature) proceedingJoinPoint.getSignature();
       
    //Method method = signature.getMethod();
    // 通过这个方式获得方法（被拦截的方法）
    @Around("IdempotentPointCut()")
    public Object addIdempotent(ProceedingJoinPoint proceedingJoinPoint) {
        Object result = null;
        
        
        //获取方法签名。
//        MethodSignature 和 Method：通过反射获取被拦截的方法和其注解信息。
        MethodSignature signature = (MethodSignature) proceedingJoinPoint.getSignature();
        // 获取切入点所在的方法，获得方法对象，签名里包含了
        Method method = signature.getMethod();
        
        
        // 获取操作 dempotent 注解：获取注解实例，并读取 uniqueIdentification 属性，用于生成唯一的幂等性锁标识。
        // 注解实例是 Java 中表示注解的对象。通过反射机制，可以在运行时获取这些注解实例，并读取注解中的属性值。以下是如何定义和使用自定义注解的示例：
        Idempotent idempotent = method.getAnnotation(Idempotent.class);
        String uniqueIdentification = idempotent.uniqueIdentification();
        //uniqueIdentification 是 @Idempotent 注解中的一个属性，通过注解实例可以访问该属性的值。
        
        
        
//        idempotentLock：构建 Redis 锁的键，使用唯一标识符和当前用户的 Token。
        String idempotentLock = String.format(RedisConstants.IDEMPOTENT_LOCK, uniqueIdentification, TokenUtil.getToken());

//        redisUtil.setIfAbsentEx( 尝试在redis中设置一个带有过期时间的键,如果设置成功,表示获得了锁
        if (redisUtil.setIfAbsentEx(idempotentLock, UUID.randomUUID().toString(), 120, TimeUnit.SECONDS)) {
            try {
                result = proceedingJoinPoint.proceed();
//                proceedingJoinPoint.proceed()：执行目标方法。
//                这里就是分布式的关键,需要得到锁,不然就不给执行
            } catch (Throwable e) {
                log.error("业务处理出现异常", e);
                throw new CustomException(ResultCodeEnum.SERVICE_EXCEPTION.getCode(), ResultCodeEnum.SERVICE_EXCEPTION.getDesc());
            } finally {
                redisUtil.delete(idempotentLock);
//                删除redis的锁
            }
        } else {
            throw new CustomException(ResultCodeEnum.IDEMPOTENT_LOCK_ERROR.getCode(), ResultCodeEnum.IDEMPOTENT_LOCK_ERROR.getMessage());
        }
        return result;
    }
}