@EnableDiscoveryClient //开启服务发现
@SpringBootApplication
public class ProductMainApplication {
    public static void main(String[] args) {
        SpringApplication.run(ProductMainApplication.class, args);

    }
}

@Autowired
LoadBalancerClient loadBalancerClient;
//负载均衡发送请求
private Product getProductFromRemoteWithLoadBalance(Long productId) {
    ServiceInstance instance = loadBalancerClient.choose("service-product");
    //远程URL
    String address = "http://" + instance.getHost() + ":" + instance.getPort() + "/product/" + productId;

    RestTemplate restTemplate = new RestTemplate();
    log.info("远程请求：{}", address);
    return restTemplate.getForObject(address, Product.class);
}

@Configuration
public class OrderConfig {

    @LoadBalanced //注解式负载均衡
    @Bean
    RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

    //基于注解的负载均衡
    private Product getProductFromRemoteWithLoadBalanceAnnotation(Long productId) {

        //"service-product"会被动态替换
        String address = "http://service-product/product/" + productId;

        log.info("远程请求：{}", address);
        return restTemplate.getForObject(address, Product.class);
    }

@RefreshScope //激活配置中心的自动刷新
@RestController()
public class OrderController {
    @Value("${order.timeout}")
    String orderTimeout;
    @Value("${order.auto-confirm}")
    String orderAutoConfirm;
}

@FeignClient(value = "service-product", fallback = ProductFeignClientFallback.class) //Feign客户端
public interface ProductFeignClient {

    //mvc注解的两套使用逻辑
    //1、标注在controller上，是接收这样的请求
    //2、标注在FeignClient上，是发送这样的请求
    @GetMapping("/product/{id}")
    Product getProductById(@PathVariable("id") Long id);
}

//兜底回调：如果远程调用失败则调用该类的相关方法
@Component
public class ProductFeignClientFallback implements ProductFeignClient {

    @Override
    public Product getProductById(Long id) {
        Product product = new Product();
        product.setId(id);
        product.setPrice(new BigDecimal("100.00"));
        product.setProductName("兜底数据 - " + product.getId());
        product.setNum(10);
        return product;
    }
}

@SentinelResource(value = "createOrder", blockHandler = "createOrderFallback") //定义资源
@Override
public Order createOrder(Long productId, Long userId) {
    Order order = new Order();
    //Product product = getProductFromRemoteWithLoadBalanceAnnotation(productId);
    Product product = productFeignClient.getProductById(productId);
    order.setUserId(userId);
    // 总金额
    order.setTotalAmount(product.getPrice().multiply(new BigDecimal(product.getNum())));
    order.setId(1L);
    order.setAddress("127.0.0.1");

    // 远程查询商品列表
    order.setProductList(Arrays.asList(product));
    return order;
}

@Component
public class MyBlockExceptionHandler implements BlockExceptionHandler {

    private ObjectMapper objectMapper = new ObjectMapper();

    @Override
    public void handle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, String s, BlockException e) throws Exception {

        httpServletResponse.setStatus(429);
        httpServletResponse.setContentType("application/json;charset=utf-8");
        PrintWriter writer = httpServletResponse.getWriter();
        R error = R.error(500, s + "被Sentinel限制了，原因：" + e.getClass());
        String json = objectMapper.writeValueAsString(error);
        writer.write(json);
        writer.flush();
        writer.close();
    }
}

@SentinelResource(value = "createOrder", blockHandler = "createOrderFallback") //定义资源
@Override
public Order createOrder(Long productId, Long userId) {
    Order order = new Order();
    //Product product = getProductFromRemoteWithLoadBalanceAnnotation(productId);
    Product product = productFeignClient.getProductById(productId);
    order.setUserId(userId);
    // 总金额
    order.setTotalAmount(product.getPrice().multiply(new BigDecimal(product.getNum())));
    order.setId(1L);
    order.setAddress("127.0.0.1");

    // 远程查询商品列表
    order.setProductList(Arrays.asList(product));
    return order;
}

//若"createOrder"违反规则，则调用createOrderFallback
public Order createOrderFallback(Long productId, Long userId, BlockException e) {
    Order order = new Order();
    order.setId(0L);
    order.setUserId(userId);
    order.setTotalAmount(BigDecimal.ZERO);
    order.setNickName("未知用户");
    order.setAddress("异常信息:" + e.getClass());
    return order;
}

@Component //自定义断言
public class VipRoutePredicateFactory extends AbstractRoutePredicateFactory<VipRoutePredicateFactory.Config> {

    public VipRoutePredicateFactory() {
        super(Config.class);
    }

    @Override
    public List<String> shortcutFieldOrder() {
        return Arrays.asList("param", "value");
    }

    @Override
    public Predicate<ServerWebExchange> apply(Config config) {
        return new GatewayPredicate() {
            @Override
            public boolean test(ServerWebExchange serverWebExchange) {
                ServerHttpRequest request = serverWebExchange.getRequest();
                HttpCookie first = request.getCookies().getFirst(config.param);
                if (first != null && first.equals(config.value)) {
                    return true;
                }
                return false;
            }
        };
    }

    @Validated
    public static class Config {

        @NotEmpty
        private String param;
        @NotEmpty
        private String value;

        public String getParam() {
            return param;
        }

        public void setParam(String param) {
            this.param = param;
        }

        public String getValue() {
            return value;
        }

        public void setValue(String value) {
            this.value = value;
        }
    }
}

@Slf4j
@Component
public class RtGlobalFilter implements GlobalFilter, Ordered {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        ServerHttpRequest request = exchange.getRequest();
        String uri = request.getURI().toString();
        long start = System.currentTimeMillis();
        log.info("请求{}开始，时间：{}", uri, start);
        //=========================以上为前置逻辑=========================
        Mono<Void> filter = chain.filter(exchange) //异步编程
                .doFinally(signal -> {
                    //=========================以下为后置逻辑=========================
                    long end = System.currentTimeMillis();
                    log.info("请求{}结束，时间：{}，总耗时：{}", uri, end, end - start);
                });

        return filter;
    }

    //优先级
    @Override
    public int getOrder() {
        return -1;
    }
}

@Component
public class OnceTokenGatewayFilterFactory extends AbstractNameValueGatewayFilterFactory {


    @Override
    public GatewayFilter apply(NameValueConfig config) {

        return new GatewayFilter() {
            @Override
            public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {

                return chain.filter(exchange).then(Mono.fromRunnable(() -> {
                    ServerHttpResponse response = exchange.getResponse();
                    HttpHeaders headers = response.getHeaders();
                    String name = config.getName();
                    String value = config.getValue();
                    if ("uuid".equalsIgnoreCase(value)) {
                        value = UUID.randomUUID().toString();
                    }

                    if ("jwt".equalsIgnoreCase(value)) {
                        value = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VyIjoiZ3Vlc3QiLCJyb2xlIjoidmlzaXRvciJ9.AwQV8c2xJw2V1f7l8p7x9v9m6n7k5y7u7i7w6f7a7d7e7s7t7";
                    }
                    headers.add(name, value);
                }));
            }
        };
    }
}

@Service
public class BusinessServiceImpl implements BusinessService {


    @Autowired
    StorageFeignClient storageFeignClient;
    @Autowired
    OrderFeignClient orderFeignClient;

    @GlobalTransactional
    @Override
    public void purchase(String userId, String commodityCode, int orderCount) {
        //1. 扣减库存
        storageFeignClient.deduct(commodityCode, orderCount);
        //2. 创建订单
        orderFeignClient.create(userId, commodityCode, orderCount);
    }
}

@Service
public class OrderServiceImpl implements OrderService {

    @Autowired
    OrderTblMapper orderTblMapper;
    @Autowired
    AccountFeignClient accountFeignClient;

    @Transactional
    @Override
    public OrderTbl create(String userId, String commodityCode, int orderCount) {
        //1、计算订单价格
        int orderMoney = calculate(commodityCode, orderCount);

        // 2、扣减账户余额
        accountFeignClient.debit(userId, orderMoney);
        //3、保存订单
        OrderTbl orderTbl = new OrderTbl();
        orderTbl.setUserId(userId);
        orderTbl.setCommodityCode(commodityCode);
        orderTbl.setCount(orderCount);
        orderTbl.setMoney(orderMoney);

        orderTblMapper.insert(orderTbl);

        return orderTbl;
    }

    // 计算价格
    private int calculate(String commodityCode, int orderCount) {
        return 9*orderCount;
    }
}

@Service
public class StorageServiceImpl implements StorageService {

    @Autowired
    StorageTblMapper storageTblMapper;

    @Transactional
    @Override
    public void deduct(String commodityCode, int count) {
        storageTblMapper.deduct(commodityCode, count);
        if (count == 5) {
            throw new RuntimeException("库存不足");
        }
    }
}

@Transactional //本地事务
@Override
public void debit(String userId, int money) {
    // 扣减账户余额
    accountTblMapper.debit(userId,money);
}