大技术

线程池来实现异步任务（亮点1）

  /*** 去结算确认页时封装订单确认页返回需要用的数据* @return* @throws ExecutionException* @throws InterruptedException*/@Overridepublic OrderConfirmVo confirmOrder() throws ExecutionException, InterruptedException {//构建OrderConfirmVoOrderConfirmVo confirmVo = new OrderConfirmVo();//获取当前用户登录的信息(直接获取)MemberResponseVo memberResponseVo = LoginUserInterceptor.loginUser.get();//获取当前线程请求头信息(用于解决Feign异步调用丢失上下文的问题)RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();/**开启第一个异步任务来远程查询所有的收获地址列表**/CompletableFuture<Void> addressFuture = CompletableFuture.runAsync(() -> {//每一个线程都来共享之前的请求数据(用于解决Feign异步调用丢失上下文的问题)RequestContextHolder.setRequestAttributes(requestAttributes);//1、远程查询所有的收获地址列表List<MemberAddressVo> address = memberFeignService.getAddress(memberResponseVo.getId());confirmVo.setMemberAddressVos(address);}, threadPoolExecutor);/**开启第二个异步任务来远程查询购物车所有选中的购物项**/CompletableFuture<Void> cartInfoFuture = CompletableFuture.runAsync(() -> {//每一个线程都来共享之前的请求数据(用于解决Feign异步调用丢失上下文的问题)RequestContextHolder.setRequestAttributes(requestAttributes);//2、远程查询购物车所有选中的购物项List<OrderItemVo> currentCartItems = cartFeignService.getCurrentCartItems();confirmVo.setItems(currentCartItems);//feign在远程调用之前要构造请求，调用很多的拦截器}, threadPoolExecutor).thenRunAsync(() -> {/** 开启第三个异步任务来远程批量查询所有商品的库存是否有货**/List<OrderItemVo> items = confirmVo.getItems();//获取全部商品的idList<Long> skuIds = items.stream().map((itemVo -> itemVo.getSkuId())).collect(Collectors.toList());//远程查询商品库存信息R skuHasStock = wmsFeignService.getSkuHasStock(skuIds);//SkuStockVo就是下面的SkuHasStockVo类List<SkuStockVo> skuStockVos = skuHasStock.getData("data", new TypeReference<List<SkuStockVo>>() {});if (skuStockVos != null && skuStockVos.size() > 0) {//将skuStockVos集合转换为mapMap<Long, Boolean> skuHasStockMap = skuStockVos.stream().collect(Collectors.toMap(SkuStockVo::getSkuId, SkuStockVo::getHasStock));confirmVo.setStocks(skuHasStockMap);}},threadPoolExecutor);//3、查询用户积分Integer integration = memberResponseVo.getIntegration();confirmVo.setIntegration(integration);//4、价格数据由OrderConfirmVo的getTotal方法自动计算//TODO 5、防重令牌(防止表单重复提交)//为用户设置一个token，三十分钟过期时间（存在redis）String token = UUID.randomUUID().toString().replace("-", "");//防重令牌一个放到redis里  USER_ORDER_TOKEN_PREFIX = "order:token"redisTemplate.opsForValue().set(USER_ORDER_TOKEN_PREFIX+memberResponseVo.getId(),token,30, TimeUnit.MINUTES);//防重令牌一个放到前台页面（不过隐藏了）confirmVo.setOrderToken(token);//阻塞异步线程，只有两个异步都完成了才可以进行下一步CompletableFuture.allOf(addressFuture,cartInfoFuture).get();return confirmVo;}

@Autowired

private ThreadPoolExecutor executor; //线程池

CompletableFuture<Void> addressFuture = CompletableFuture.runAsync(() -> {

/**开启第一个异步任务来远程查询所有的收获地址列表**/

}, executor);

CompletableFuture<Void> cartInfoFuture = CompletableFuture.runAsync(() -> {

/**开启第二个异步任务来远程查询购物车所有选中的购物项**/

}, executor).thenRunAsync(() -> {

/** 开启第三个异步任务来远程批量查询所有商品的库存是否有货**/

},executor);

//阻塞异步线程，只有两个异步都完成了才可以进行下一步

CompletableFuture.allOf(addressFuture,cartInfoFuture).get();

注意：addressFuture和cartInfoFuture是两个同时执行的异步任务，而cartInfoFuture里面又开了一个thenRunAsync异步任务，这个异步任务是必须在cartInfoFuture执行完后才可以执行，有先后顺序

防重令牌存到Redis中并且通过lure脚本保证令牌的原子性（亮点2）

防重令牌的格式为key:order:token：+用户id，value:防重令牌的值

//防重令牌(防止表单重复提交)
//为用户设置一个token，三十分钟过期时间（存在redis）
String token = UUID.randomUUID().toString().replace("-", "");
//防重令牌一个放到redis里  USER_ORDER_TOKEN_PREFIX = "order:token"
redisTemplate.opsForValue().set(USER_ORDER_TOKEN_PREFIX+memberResponseVo.getId(),token,30, TimeUnit.MINUTES);

在点击去结算按钮后生成一个防重令牌，然后放到redis中和当到订单页面（隐藏起来，用户看不到），这个防重令牌是为了防止用户因为网络延迟等原因连续多次点击提交订单按钮，如果不做这个功能那就会生成多个一样的订单

/**1、验证令牌是否合法【令牌的对比和删除必须保证原子性】**/
String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
String orderToken = vo.getOrderToken();
//通过lure脚本原子验证令牌和删除令牌（执行脚本后返回long类型的0或1，0表示令牌验证失败，1表示成功）
//Arrays.asList(USER_ORDER_TOKEN_PREFIX + memberResponseVo.getId())表示存到redis里的值
//   orderToken是页面传过来的令牌（表示当前需要验证的值）
Long result = redisTemplate.execute(new DefaultRedisScript<Long>(script, Long.class),Arrays.asList(USER_ORDER_TOKEN_PREFIX + memberResponseVo.getId()),orderToken);if (result == 0L) {//令牌验证失败
} else {//令牌验证成功

这里的防重令牌删除的时候需要考虑下面的问题

先执行业务后删除令牌
先删除令牌后执行业务

如果是先执行业务的话那是不行的，因为在并发的情况下，会有多个请求同时来校验令牌，然后这个令牌还没有删除，那么多个请求就都执行了业务代码，这不合理

如果先删除令牌在执行业务更合理一些，但是也会有问题，加入有两个请求同时校验令牌，同时删除令牌，同时执行业务代码，那还是有问题，所以要保证令牌的校验和删除是原子性操作，也就是只能有一个线程来执行令牌的校验和删除，其他线程只能等待，这样就可以解决上面的问题，这也是为什么要用lure脚本来保证令牌的校验和删除是原子性的原因

String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";这句是lure脚本用来保证在redis中校验和删除令牌的原子性

含义：如果在redis中get的第一个key和argv值（也就是要和redis中比较的值）相同那就删除key，删除key成功返回1，如果不相同就返回0

使用RabbitMQ来解库存的分布式事务问题

问题就是提交订单submitOrder这个方法的所有代码实现的业务都要保持原子性，如果出现任何异常都要进行数据回滚，例如这个方法中是先保存订单和订单项的信息到数据库对应的表格中，然后再调用远程服务去锁库存，如果锁库存成功后再执行下面的代码出现异常或者电脑嗝屁了这类情况那前面保存好的订单和订单项就应该数据回滚（也就是删除刚才录入的数据），同时库存服务也应该解库存。一般情况下只需要在submitOrder方法上加一个@Transactional注解就可以了，但是这个注解只能回滚本地的服务，不能回滚库存服务中的锁库存（也就是这个注解可以实现出现异常后删除刚才录入数据库的订单和订单项的数据，但是没办法把锁库存的数量给改回原来的数量，因为锁库存是库存服务的，不是订单服务的，所以没法靠@Transactional注解来实现回滚）

解决办法

这里采用的是通过RabbitMQ的延时队列来实现保持数据的最终一致性，也就是保持数据库的数据最后的一致性，而不是像@Transactional注解一样立马就回滚，立马保持数据的一致性（这里可以理解成@Transactional 是出现异常后飞快的把数据恢复到原来的样子，而保持数据的最终一致性是过了一段时间后才恢复到原来的样子）

那RabbitMQ的延时队列是怎样来实现数据的最终一致性的呢？

简单说下，其实就是用户下订单后就给延时队列发送消息，如果这个订单的状态在指定的时间过后还是待付款就自动取消这个订单，取消了这个订单后就立马发消息给队列去解库存，可以看出这里就不在乎你到底是异常导致的没支付成功还是用户没付款导致的，再或者是电脑嗝屁了，无论是哪种情况都不管，我只管这个订单有没有在指定的时间内把订单的状态改成已支付状态，只要是过了指定的时间订单的状态还是待付款的话那我就给你回滚数据，不但之前已经存到数据库的订单和订单项数据我都给你删了，而且库存也给你解了，就是这么霸气!从而这样来保持数据库的最终一致性！

图解：用户点击提交订单按钮后会创建一个订单，把这个订单作为一个消息发给topic交换机order-event-exchange，交换机根据路由键order.create.order路由到延时队列order.delay.queue，然后消息在延时队列里等待指定的时间，当时间过期后把这个消息通过交换机order-event-exchange识别他的新的路由键order.release.order路由到新的队列order.release.order.queue（取消订单的队列），这个队列是用于处理用户提交订单但是没有支付订单的情况，然后订单就会被自动取消，但是这里要考虑一个情况（这个特殊情况是需要额外的处理的），那就是取消订单操作因为网络卡顿导致解库存操作先执行的话，这样就导致导致卡顿的订单永远都不能解锁库存，所以订单取消后立马发消息给order-event-exchange交换机，交换机把这个消息通过路由键order.release.other发到stock.release.stock.queue队列（解库存的队列），这个队列其中有个监听方法就是来监听这个消息的，只要监听到这个消息就会立马执行解库存，还有一种就是正常解库存的操作，当订单成功创建后就进行锁库存，锁库存成功后就会发消息给stock-event-exchange交换机，交换机根据路由键stock.locked把消息路由到stock.delay.queue延时队列，时间过期后就把消息根据路由键stock.release路由到stock.release.stock.queue队列（解库存的队列），然后这个消息队列的消息是被一个专门解库存的监听器来监听（注意这里有两种解库存的监听方法，一个是自动解库存的监听，一个是订单服务的订单取消后立马解库存的监听）

具体实现

1、在MyRabbitMQConfig配置类中创建队列、交换机、队列和交换机的绑定关系

订单服务和库存服务都是创建一个主题交换机，两个队列，一个队列是用来存放消息的，另外一个队列是用来存放死信的（也就是死了的消息，这里并没有直接处理掉，而是放到这个队列里）

整体思路

首先生产者发送一个消息给topic交换机order-event-exchange，交换机根据路由键order.create.order路由到延时队列order.delay.queue，然后消息在延时队列里等待指定的时间，当时间过期后还没有被消费就会被当成死信，然后把这个消息通过交换机order-event-exchange识别他的新的路由键order.release.order路由到新的队列order.release.order.queue

package com.saodai.saodaimall.order.config;import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.Exchange;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;import java.util.HashMap;/*** RabbitMQ配置类* 整体思路* 首先生产者发送一个消息给topic交换机order-event-exchange，交换机根据路由键order.create.order路由到延时队列order.delay.queue* 然后消息在延时队列里等待指定的时间，当时间过期后还没有被消费就会被当成死信，然后把这个消息通过交换机order-event-exchange识别他的新的* 路由键order.release.order路由到新的队列order.release.order.queue** 这里只有一个交换机，两个队列，一个队列是用来存放消息的，另外一个队列是用来存放死信的（也就是死了的消息，这里并没有直接处理掉，而是放到这个队列里）**/@Configuration
public class MyRabbitMQConfig {/****创建延时队列*延时队列是通过参数来设置的* arguments.put("x-dead-letter-exchange", "order-event-exchange");前面的固定的前缀，表示这个队列延时后的消息* @return*/ @Beanpublic Queue orderDelayQueue() {//用map构造参数HashMap<String, Object> arguments = new HashMap<>();//指定延时后的消息的交换机（x-dead-letter-exchange是固定的前缀，order-event-exchange是自定义的交换机）arguments.put("x-dead-letter-exchange", "order-event-exchange");//死信路由（也就是消息如果超时了就会被当作死信，然后通过路由键order.release.order路由到指定的消息队列）arguments.put("x-dead-letter-routing-key", "order.release.order");//设置消息过期时间arguments.put("x-message-ttl", 60000); // 消息过期时间 1分钟/*Queue(String name,  队列名字boolean durable,  是否持久化boolean exclusive,  是否排他boolean autoDelete, 是否自动删除Map<String, Object> arguments) 参数*/Queue queue = new Queue("order.delay.queue", true, false, false, arguments);return queue;}/*** 死信队列（也就是到了这个队列的都是要死的消息）** @return*/@Beanpublic Queue orderReleaseQueue() {Queue queue = new Queue("order.release.order.queue", true, false, false);return queue;}/*** TopicExchange*创建主题类型的交换机* @return*/@Beanpublic Exchange orderEventExchange() {/**   String name,*   boolean durable,*   boolean autoDelete,*   Map<String, Object> arguments* */return new TopicExchange("order-event-exchange", true, false);}/*** 创建交换机和队列的捆绑关系（延时队列捆绑）* @return*/@Beanpublic Binding orderCreateBinding() {/** String destination, 目的地（队列名或者交换机名字）* DestinationType destinationType, 目的地类型（Queue、Exhcange）* String exchange,* String routingKey,* Map<String, Object> arguments* */return new Binding("order.delay.queue",Binding.DestinationType.QUEUE,"order-event-exchange","order.create.order",null);}/*** 创建交换机和队列的捆绑关系（死信队列捆绑）* @return*/@Beanpublic Binding orderReleaseBinding() {return new Binding("order.release.order.queue",Binding.DestinationType.QUEUE,"order-event-exchange","order.release.order",null);}/*** 订单释放直接和库存释放进行绑定* @return*/@Beanpublic Binding orderReleaseOtherBinding() {return new Binding("stock.release.stock.queue",Binding.DestinationType.QUEUE,"order-event-exchange","order.release.other.#",null);}/*** 商品秒杀队列* @return*/@Beanpublic Queue orderSecKillOrrderQueue() {Queue queue = new Queue("order.seckill.order.queue", true, false, false);return queue;}@Beanpublic Binding orderSecKillOrrderQueueBinding() {//String destination, DestinationType destinationType, String exchange, String routingKey,//           Map<String, Object> argumentsBinding binding = new Binding("order.seckill.order.queue",Binding.DestinationType.QUEUE,"order-event-exchange","order.seckill.order",null);return binding;}}/****创建延时队列* @return*/ @Beanpublic Queue orderDelayQueue() {//用map构造参数HashMap<String, Object> arguments = new HashMap<>();//指定延时后的消息的交换机（x-dead-letter-exchange是固定的前缀，order-event-exchange是自定义的交换机）arguments.put("x-dead-letter-exchange", "order-event-exchange");//死信路由（也就是消息如果超时了就会被当作死信，然后通过路由键order.release.order路由到指定的消息队列）arguments.put("x-dead-letter-routing-key", "order.release.order");//设置消息过期时间arguments.put("x-message-ttl", 60000); // 消息过期时间 1分钟/*Queue(String name,  队列名字boolean durable,  是否持久化boolean exclusive,  是否排他boolean autoDelete, 是否自动删除Map<String, Object> arguments) 参数*/Queue queue = new Queue("order.delay.queue", true, false, false, arguments);return queue;}

创建特殊的延时队列只需要传入一个map类型的参数进去就可以让普通队列成为一个延时队列

 //指定延时后的消息的交换机（x-dead-letter-exchange是固定的前缀，order-event-exchange是自定义的交换机）
arguments.put("x-dead-letter-exchange", "order-event-exchange");
//死信路由（也就是消息如果超时了就会被当作死信，然后通过路由键order.release.order路由到指定的消息队列）
arguments.put("x-dead-letter-routing-key", "order.release.order");
//设置消息过期时间
arguments.put("x-message-ttl", 60000); // 消息过期时间 1分钟

x-dead-letter-exchange这个key是rabbitMQ封装好了的固定的前缀，表示这个队列延时后的消息指定使用order-event-exchange这个交换机，这个交换机来把延时的消息进行传输，x-dead-letter-routing-key也是rabbitMQ封装好了的固定的前缀，表示这个队列延时后的消息使用的新路由键是order.release.order，x-message-ttl也是rabbitMQ封装好了的固定的前缀，表示设置延时队列的延时时间是多少，也就是上面的三个key值都是封装好的固定前缀，后面的值才是自定义的

package com.saodai.saodaimall.ware.config;import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.Exchange;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
import org.springframework.amqp.support.converter.MessageConverter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;import java.util.HashMap;/*** RabbitMQ配置类（一个交换机，两个队列，两个绑定，跟订单服务的基本一样，详细介绍看订单服务的队列）**/
@Configuration
public class MyRabbitMQConfig {/*** 使用JSON序列化机制，进行消息转换* @return*/@Beanpublic MessageConverter messageConverter() {return new Jackson2JsonMessageConverter();}/*** RabbitMQ要第一次连接上发现没有队列或者交换机才会创建，所以如果没有下面的代码运行会发现官网中并没有创建交换机和队列* 下面代码就是模拟监听，这样就可以连接上RabbitMQ，然后可以创建交换机和队列* 但是后面要注释掉（自动解锁库存时这里也会监听队列导致多一个消费者，所以要注释掉）*/
//     @RabbitListener(queues = "stock.release.stock.queue")
//     public void handle(Message message) {
//
//     }/*** 库存服务默认的交换机* @return*/@Beanpublic Exchange stockEventExchange() {//String name, boolean durable, boolean autoDelete, Map<String, Object> argumentsTopicExchange topicExchange = new TopicExchange("stock-event-exchange", true, false);return topicExchange;}/*** 普通队列* @return*/@Beanpublic Queue stockReleaseStockQueue() {//String name, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> argumentsQueue queue = new Queue("stock.release.stock.queue", true, false, false);return queue;}/***  延迟队列* @return*/@Beanpublic Queue stockDelay() {HashMap<String, Object> arguments = new HashMap<>();arguments.put("x-dead-letter-exchange", "stock-event-exchange");arguments.put("x-dead-letter-routing-key", "stock.release");// 消息过期时间 2分钟arguments.put("x-message-ttl", 120000);Queue queue = new Queue("stock.delay.queue", true, false, false,arguments);return queue;}/*** 交换机与普通队列绑定* @return*/@Beanpublic Binding stockLocked() {//String destination, DestinationType destinationType, String exchange, String routingKey,//             Map<String, Object> argumentsBinding binding = new Binding("stock.release.stock.queue",Binding.DestinationType.QUEUE,"stock-event-exchange","stock.release.#",null);return binding;}/*** 交换机与延迟队列绑定* @return*/@Beanpublic Binding stockLockedBinding() {return new Binding("stock.delay.queue",Binding.DestinationType.QUEUE,"stock-event-exchange","stock.locked",null);}}

2、理解订单服务和库存服务的RabbitMQ队列的图

（1）订单服务使用RabbitMQ的整个过程：

1、订单创建成功后发送消息给topic主题交换机order-event-exchange，交换机根据order.create.order路由键把消息路由到order.delay.queue延时队列（订单创建成功是指OrderServiceImpl类中的submitOrder方法执行成功后给order.delay.queue队列发送消息）

rabbitTemplate.convertAndSend("order-event-exchange","order.create.order",order.getOrder());

2、消息在order.delay.queue延时队列里等待指定的时间，当时间过期后还没有被消费就会被当成死信，然后把这个消息通过order-event-exchange交换机的新的路由键order.release.order路由到order.release.order.queue队列（过期后的路由键和交换机设置是由订单服务的MyRabbitMQConfig配置的）

注意：这里order.delay.queue队列只是作为延时队列来使用的（正常情况是会有队列的监听器来监听这个队列的消息然后消费掉，但是在这个场景中是没有消费者来消费这个队列的消息的，因为这个队列只需要延时就可以了，并不需要消费者，这个队列的消息等待指定的时间后就会被送到order.release.order.queue队列里，从而达到延时队列的效果）

 //交换机（x-dead-letter-exchange是固定的，order-event-exchange是自定义的交换机）
arguments.put("x-dead-letter-exchange", "order-event-exchange");
//死信路由（也就是消息如果超时了就会被当作死信，然后通过路由键order.release.order路由到指定的消息队列）
arguments.put("x-dead-letter-routing-key", "order.release.order");
//设置消息过期时间
arguments.put("x-message-ttl", 60000); // 消息过期时间 1分钟

3、设置一个监听器用来消费order.release.order.queue队列的消息（这个队列的消息都是已经超时了的消息，也就是模拟用户生成订单后没有支付的订单，所以要写个监听器来取消之前生成的订单）

package com.saodai.saodaimall.order.listener;import com.rabbitmq.client.Channel;
import com.saodai.saodaimall.order.entity.OrderEntity;
import com.saodai.saodaimall.order.service.OrderService;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;import java.io.IOException;/*** 订单监听器，监听的是队列order.release.order.queue（定时关闭订单）* 但凡被这个监听器监听到的消息都是过期的死信**/
@RabbitListener(queues = "order.release.order.queue")
@Service
public class OrderCloseListener {@Autowiredprivate OrderService orderService;@RabbitHandlerpublic void listener(OrderEntity orderEntity, Channel channel, Message message) throws IOException {System.out.println("收到过期的订单信息，准备关闭订单" + orderEntity.getOrderSn());try {//关闭订单orderService.closeOrder(orderEntity);//消费者的手动ack确认这条消息被成功消费了channel.basicAck(message.getMessageProperties().getDeliveryTag(),false);} catch (Exception e) {channel.basicReject(message.getMessageProperties().getDeliveryTag(),true);}}}/*** 关闭订单（这个方法由OrderCloseListener监听器调用）* 这个方法被调用说明这个订单已经过了指定的时间还没有付款* 所谓的关闭订单其实就是修改订单的状态，修改成已取消就行了* @param orderEntity  前面生成订单时发送给RabbitMQ队列的消息orderEntity*/@Overridepublic void closeOrder(OrderEntity orderEntity) {//关闭订单之前先查询一下数据库，判断此订单状态是否已支付OrderEntity orderInfo = this.getOne(new QueryWrapper<OrderEntity>().eq("order_sn",orderEntity.getOrderSn()));//   CREATE_NEW(0,"待付款")（说明这个订单已经过了指定的时间还没有付款）if (orderInfo.getStatus().equals(OrderStatusEnum.CREATE_NEW.getCode())) {//如果是待付款状态就可以进行关单OrderEntity orderUpdate = new OrderEntity();orderUpdate.setId(orderInfo.getId());//把待付款修改成已取消的状态即可CANCLED(4,"已取消")orderUpdate.setStatus(OrderStatusEnum.CANCLED.getCode());this.updateById(orderUpdate);/**这里要考虑一个情况（这个特殊情况是需要下面的额外处理）* 防止订单服务卡顿，导致订单状态消息一直改不了，也就是上面的代码因为卡顿导致没有执行解库存服务先执行，查订单状态发现不是取消状态，然后什么都不处理* 导致卡顿的订单，永远都不能解锁库存* 所以订单释放直接和库存释放进行绑定*/// 发送消息给MQOrderTo orderTo = new OrderTo();BeanUtils.copyProperties(orderInfo, orderTo);try {//订单释放直接和库存释放进行绑定/*** 订单取消后立马发消息给交换机，交换机把这个消息通过路由键order.release.other发到队列stock.release.stock.queue* 这个路由设置是由MyRabbitMQConfig中的orderReleaseOtherBinding方法进行绑定的*/rabbitTemplate.convertAndSend("order-event-exchange", "order.release.other", orderTo);} catch (Exception e) {//TODO 定期扫描数据库，重新发送失败的消息}}}

关闭订单之前先查询一下数据库，判断此订单状态是否已支付
关闭订单其实就是修改订单的状态，修改成已取消
这里要考虑一个情况（这个特殊情况是需要额外的处理的）
- 按理来说是订单服务的取消订单操作是在解库存操作的前面的，也就是一般先会取消订单操作后再去解库存操作，但是如果取消订单操作因为网络卡顿导致解库存操作先执行的话就会出现下面的情况：
- 解库存的实现逻辑又是先来看看订单的状态是不是已取消，如果是已取消才会去解库存，否则就不会执行解库存操作了，上面的情况就会出现解库存操作来看订单状态的时候发现订单状态是待支付，不是已取消状态，所以就不执行解库存操作，由于解库存操作只会来查看一次，所以就会导致卡顿的订单，永远都不能解锁库存
- 解决办法：订单取消后立马发消息给order-event-exchange交换机，交换机把这个消息通过路由键order.release.other发到stock.release.stock.queue队列，这个队列其中有个监听方法就是来监听这个消息的，只要监听到这个消息就会立马执行解库存

rabbitTemplate.convertAndSend("order-event-exchange", "order.release.other", orderTo);

package com.saodai.common.to;import lombok.Data;import java.math.BigDecimal;
import java.util.Date;/**
*订单类
*/@Data
public class OrderTo {private Long id;/*** member_id*/private Long memberId;/*** 订单号*/private String orderSn;/*** 使用的优惠券*/private Long couponId;/*** create_time*/private Date createTime;/*** 用户名*/private String memberUsername;/*** 订单总额*/private BigDecimal totalAmount;/*** 应付总额*/private BigDecimal payAmount;/*** 运费金额*/private BigDecimal freightAmount;/*** 促销优化金额（促销价、满减、阶梯价）*/private BigDecimal promotionAmount;/*** 积分抵扣金额*/private BigDecimal integrationAmount;/*** 优惠券抵扣金额*/private BigDecimal couponAmount;/*** 后台调整订单使用的折扣金额*/private BigDecimal discountAmount;/*** 支付方式【1->支付宝；2->微信；3->银联； 4->货到付款；】*/private Integer payType;/*** 订单来源[0->PC订单；1->app订单]*/private Integer sourceType;/*** 订单状态【0->待付款；1->待发货；2->已发货；3->已完成；4->已关闭；5->无效订单】*/private Integer status;/*** 物流公司(配送方式)*/private String deliveryCompany;/*** 物流单号*/private String deliverySn;/*** 自动确认时间（天）*/private Integer autoConfirmDay;/*** 可以获得的积分*/private Integer integration;/*** 可以获得的成长值*/private Integer growth;/*** 发票类型[0->不开发票；1->电子发票；2->纸质发票]*/private Integer billType;/*** 发票抬头*/private String billHeader;/*** 发票内容*/private String billContent;/*** 收票人电话*/private String billReceiverPhone;/*** 收票人邮箱*/private String billReceiverEmail;/*** 收货人姓名*/private String receiverName;/*** 收货人电话*/private String receiverPhone;/*** 收货人邮编*/private String receiverPostCode;/*** 省份/直辖市*/private String receiverProvince;/*** 城市*/private String receiverCity;/*** 区*/private String receiverRegion;/*** 详细地址*/private String receiverDetailAddress;/*** 订单备注*/private String note;/*** 确认收货状态[0->未确认；1->已确认]*/private Integer confirmStatus;/*** 删除状态【0->未删除；1->已删除】*/private Integer deleteStatus;/*** 下单时使用的积分*/private Integer useIntegration;/*** 支付时间*/private Date paymentTime;/*** 发货时间*/private Date deliveryTime;/*** 确认收货时间*/private Date receiveTime;/*** 评价时间*/private Date commentTime;/*** 修改时间*/private Date modifyTime;}

（2）库存服务使用RabbitMQ的整个过程

锁库存成功后就会发消息给stock-event-exchange交换机，交换机根据路由键stock.locked把消息路由到stock.delay.queue延时队列（跟上面一样，这个延时队列的消息不会被消费掉），时间过期后就把消息根据路由键stock.release路由到stock.release.stock.queue队列，然后这个消息队列的消息是被一个专门解库存的监听器来监听（注意这里有两种解库存的监听方法，一个是自动解库存的监听，一个是订单服务的订单取消后立马解库存的监听）

rabbitTemplate.convertAndSend("stock-event-exchange","stock.locked",lockedTo);

package com.saodai.saodaimall.ware.listener;import com.rabbitmq.client.Channel;
import com.saodai.common.to.OrderTo;
import com.saodai.common.to.mq.StockLockedTo;
import com.saodai.saodaimall.ware.service.WareSkuService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;import java.io.IOException;/*** RabbitMQ的监听器* 这里有两个监听方法，这两个监听识别的依据是看传入的是StockLockedTo还是OrderTo* 一个是监听的库存自动解锁* 一个是监听订单取消后库存解锁*/@Slf4j
@RabbitListener(queues = "stock.release.stock.queue")
@Service
public class StockReleaseListener {@Autowiredprivate WareSkuService wareSkuService;/**** 监听库存自动解锁*/@RabbitHandlerpublic void handleStockLockedRelease(StockLockedTo to, Message message, Channel channel) throws IOException {log.info("******收到解锁库存的信息******");try {System.out.println("******收到解锁库存的信息******");//当前消息是否被第二次及以后（重新）派发过来了// Boolean redelivered = message.getMessageProperties().getRedelivered();//解锁库存wareSkuService.unlockStock(to);// 手动删除消息channel.basicAck(message.getMessageProperties().getDeliveryTag(),false);} catch (Exception e) {// 解锁失败 将消息重新放回队列，让别人消费channel.basicReject(message.getMessageProperties().getDeliveryTag(),true);}}/**** 防止订单服务卡顿，导致订单状态消息一直改不了，库存优先到期，查订单状态新建，什么都不处理*导致卡顿的订单，永远都不能解锁库存* 订单释放直接和库存释放进行绑定* @param orderTo* @param message* @param channel* @throws IOException*/@RabbitHandlerpublic void handleOrderCloseRelease(OrderTo orderTo, Message message, Channel channel) throws IOException {log.info("******收到订单关闭，准备解锁库存的信息******");try {wareSkuService.unlockStock(orderTo);// 手动删除消息channel.basicAck(message.getMessageProperties().getDeliveryTag(),false);} catch (Exception e) {// 解锁失败 将消息重新放回队列，让别人消费channel.basicReject(message.getMessageProperties().getDeliveryTag(),true);}}}

package com.saodai.common.to.mq;import lombok.Data;/*** 发送到mq消息队列的to**/@Data
public class StockLockedTo {/** 库存工作单的id **/private Long id;/** 工作单详情的所有信息  StockDetailTo对象内容就是上面的WareOrderTaskDetailEntity **/private StockDetailTo detailTo;
}

解锁库存的思路

首先查询数据库的库存详细工作单表看看有没有成功锁定库存（如果成功锁库存了会有对应的一条记录），如果没有那就说明库存没有锁成功，那自然就不需要解锁了

库存详细工作单表有这条记录那就证明库存锁定成功了

- 具体需不需要解库存还要先看订单状态

- - 先查询有没有这个订单，没有这个订单必须解锁库存（可能出现因为有异常造成的数据回滚导致订单不存在的情况，但是库存锁成功了）
  - 有这个订单，不一定解锁库存，要根据订单的状态来决定是否解库存

- - - 订单状态是已取消状态，说明是用户没有支付订单过期了，那就必须解锁库存
    - 订单状态是已支付状态，说明是用户支付成功了，那就不能解锁库存

- - 除了判断上面的情况，还有考虑当前库存详细工作单的状态，只有满足订单状态是已取消状态并且是已锁定的状态那才可以解库存

- - - 已锁定：解锁库存
    - 已解锁：不能再解锁

 /*** (这个方法是由StockReleaseListener监听器调用的)* 锁库存失败后的自动解锁（也就是回溯）* @param to*/@Overridepublic void unlockStock(StockLockedTo to) {//获取库存详细工作单类StockDetailTo detail = to.getDetailTo();//库存详细工作单的idLong detailId = detail.getId();//WareOrderTaskDetailEntity是库存详细工作单类WareOrderTaskDetailEntity taskDetailInfo = wareOrderTaskDetailService.getById(detailId);if (taskDetailInfo != null) {//查出wms_ware_order_task工作单的信息Long id = to.getId();//订单锁库存工作单(获取哪个订单要锁库存)WareOrderTaskEntity orderTaskInfo = wareOrderTaskService.getById(id);//获取订单号查询订单状态String orderSn = orderTaskInfo.getOrderSn();//远程查询订单信息R orderData = orderFeignService.getOrderStatus(orderSn);if (orderData.getCode() == 0) {//订单数据返回成功OrderVo orderInfo = orderData.getData("data", new TypeReference<OrderVo>() {});/***     CREATE_NEW(0,"待付款"),*     PAYED(1,"已付款"),*     SENDED(2,"已发货"),*     RECIEVED(3,"已完成"),*     CANCLED(4,"已取消"),*     SERVICING(5,"售后中"),*     SERVICED(6,"售后完成");*///订单不存在（因为有异常造成的数据回滚导致订单不存在）或者订单状态是取消状态（orderInfo.getStatus() == 4）才可解库存if (orderInfo == null || orderInfo.getStatus() == 4) {//当前库存工作单详情状态1，已锁定，只有当前库存工作单详情状态未解锁才可以解锁if (taskDetailInfo.getLockStatus() == 1) {//调用真正接库存的方法unLockStockunLockStock(detail.getSkuId(),detail.getWareId(),detail.getSkuNum(),detailId);}}} else {//消息拒绝以后重新放在队列里面，让别人继续消费解锁//远程调用服务失败throw new RuntimeException("远程调用服务失败");}} else {//无需解锁}}/*** 真正解锁库存的方法（自动解库存）* @param skuId 需要解锁库存的商品id* @param wareId  需要解锁库存的库存仓库id* @param num  需要解锁库存的商品数量* @param taskDetailId   库存工作单详情id*/public void unLockStock(Long skuId,Long wareId,Integer num,Long taskDetailId) {//库存解锁（其实就是修改wms_ware_sku表中的stock_locked的值，之前锁库存锁了多少个就减去多少个）wareSkuDao.unLockStock(skuId,wareId,num);//更新工作单的状态WareOrderTaskDetailEntity taskDetailEntity = new WareOrderTaskDetailEntity();taskDetailEntity.setId(taskDetailId);//setLockStatus(2)表示变为已解锁（1表示已锁定，2表示已解锁，3表示减扣）taskDetailEntity.setLockStatus(2);wareOrderTaskDetailService.updateById(taskDetailEntity);}/*** 订单取消了就立马解库存* 防止订单服务卡顿，导致订单状态消息一直改不了，库存优先到期，查订单状态新建，什么都不处理* 导致卡顿的订单，永远都不能解锁库存* @param orderTo*/@Transactional(rollbackFor = Exception.class)@Overridepublic void unlockStock(OrderTo orderTo) {String orderSn = orderTo.getOrderSn();//查一下最新的库存解锁状态，防止重复解锁库存WareOrderTaskEntity orderTaskEntity = wareOrderTaskService.getOrderTaskByOrderSn(orderSn);//按照工作单的id找到所有 没有解锁的库存，进行解锁（lock_status=1表示已锁定库存）Long id = orderTaskEntity.getId();List<WareOrderTaskDetailEntity> list = wareOrderTaskDetailService.list(new QueryWrapper<WareOrderTaskDetailEntity>().eq("task_id", id).eq("lock_status", 1));for (WareOrderTaskDetailEntity taskDetailEntity : list) {//解锁库存unLockStock(taskDetailEntity.getSkuId(),taskDetailEntity.getWareId(),taskDetailEntity.getSkuNum(),taskDetailEntity.getId());}}

自动解库存

/*** (这个方法是由StockReleaseListener监听器调用的)* 锁库存失败后的自动解锁（也就是回溯）* @param to*/@Overridepublic void unlockStock(StockLockedTo to) {//获取库存详细工作单类StockDetailTo detail = to.getDetailTo();//库存详细工作单的idLong detailId = detail.getId();//WareOrderTaskDetailEntity是库存详细工作单类WareOrderTaskDetailEntity taskDetailInfo = wareOrderTaskDetailService.getById(detailId);if (taskDetailInfo != null) {//查出wms_ware_order_task工作单的信息Long id = to.getId();//订单锁库存工作单(获取哪个订单要锁库存)WareOrderTaskEntity orderTaskInfo = wareOrderTaskService.getById(id);//获取订单号查询订单状态String orderSn = orderTaskInfo.getOrderSn();//远程查询订单信息R orderData = orderFeignService.getOrderStatus(orderSn);if (orderData.getCode() == 0) {//订单数据返回成功OrderVo orderInfo = orderData.getData("data", new TypeReference<OrderVo>() {});/***     CREATE_NEW(0,"待付款"),*     PAYED(1,"已付款"),*     SENDED(2,"已发货"),*     RECIEVED(3,"已完成"),*     CANCLED(4,"已取消"),*     SERVICING(5,"售后中"),*     SERVICED(6,"售后完成");*///订单不存在（因为有异常造成的数据回滚导致订单不存在）或者订单状态是取消状态（orderInfo.getStatus() == 4）才可解库存if (orderInfo == null || orderInfo.getStatus() == 4) {//当前库存工作单详情状态1，已锁定，只有当前库存工作单详情状态未解锁才可以解锁if (taskDetailInfo.getLockStatus() == 1) {//调用真正接库存的方法unLockStockunLockStock(detail.getSkuId(),detail.getWareId(),detail.getSkuNum(),detailId);}}} else {//消息拒绝以后重新放在队列里面，让别人继续消费解锁//远程调用服务失败throw new RuntimeException("远程调用服务失败");}} else {//无需解锁}}/*** 真正解锁库存的方法（自动解库存）* @param skuId 需要解锁库存的商品id* @param wareId  需要解锁库存的库存仓库id* @param num  需要解锁库存的商品数量* @param taskDetailId   库存工作单详情id*/public void unLockStock(Long skuId,Long wareId,Integer num,Long taskDetailId) {//库存解锁（其实就是修改wms_ware_sku表中的stock_locked的值，之前锁库存锁了多少个就减去多少个）wareSkuDao.unLockStock(skuId,wareId,num);//更新工作单的状态WareOrderTaskDetailEntity taskDetailEntity = new WareOrderTaskDetailEntity();taskDetailEntity.setId(taskDetailId);//setLockStatus(2)表示变为已解锁（1表示已锁定，2表示已解锁，3表示减扣）taskDetailEntity.setLockStatus(2);wareOrderTaskDetailService.updateById(taskDetailEntity);}

自动解库存的具体实现流程

- 获取库存详细工作单的id

package com.saodai.common.to.mq;import lombok.Data;/*** 发送到mq消息队列的to**/@Data
public class StockLockedTo {/** 库存工作单的id **/private Long id;/** 工作单详情的所有信息 **/private StockDetailTo detailTo;
}
package com.saodai.common.to.mq;import lombok.Data;/*** 其实就是库存工作单详情实体类（具体给订单的哪个商品锁库存）**/@Data
public class StockDetailTo {private Long id;/*** sku_id*/private Long skuId;/*** sku_name*/private String skuName;/*** 购买个数*/private Integer skuNum;/*** 工作单id*/private Long taskId;/*** 仓库id*/private Long wareId;/*** 锁定状态*/private Integer lockStatus;}

- 查询数据库有没有这个库存详细工作单类

package com.saodai.saodaimall.ware.entity;import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;import java.io.Serializable;/*** 库存工作单详情（具体给订单的哪个商品锁库存）*/@NoArgsConstructor
@AllArgsConstructor
@Builder
@Data
@TableName("wms_ware_order_task_detail")
public class WareOrderTaskDetailEntity implements Serializable {private static final long serialVersionUID = 1L;/*** id*/@TableIdprivate Long id;/*** sku_id*/private Long skuId;/*** sku_name*/private String skuName;/*** 购买个数*/private Integer skuNum;/*** 工作单id*/private Long taskId;/*** 仓库id*/private Long wareId;/*** 锁定状态*/private Integer lockStatus;}

- 查询订单锁库存工作单(获取哪个订单要锁库存)

package com.saodai.saodaimall.ware.entity;import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;import java.io.Serializable;
import java.util.Date;/*** 订单锁库存工作单(表示我准备要给哪个订单锁库存了)*/
@Data
@TableName("wms_ware_order_task")
public class WareOrderTaskEntity implements Serializable {private static final long serialVersionUID = 1L;/*** id*/@TableIdprivate Long id;/*** order_id*/private Long orderId;/*** order_sn*/private String orderSn;/*** 收货人*/private String consignee;/*** 收货人电话*/private String consigneeTel;/*** 配送地址*/private String deliveryAddress;/*** 订单备注*/private String orderComment;/*** 付款方式【 1:在线付款 2:货到付款】*/private Integer paymentWay;/*** 任务状态*/private Integer taskStatus;/*** 订单描述*/private String orderBody;/*** 物流单号*/private String trackingNo;/*** create_time*/private Date createTime;/*** 仓库id*/private Long wareId;/*** 工作单备注*/private String taskComment;}

- 根据订单号远程查询订单

package com.saodai.saodaimall.ware.vo;import lombok.Data;import java.math.BigDecimal;
import java.util.Date;@Data
public class OrderVo {private Long id;/*** member_id*/private Long memberId;/*** 订单号*/private String orderSn;/*** 使用的优惠券*/private Long couponId;/*** create_time*/private Date createTime;/*** 用户名*/private String memberUsername;/*** 订单总额*/private BigDecimal totalAmount;/*** 应付总额*/private BigDecimal payAmount;/*** 运费金额*/private BigDecimal freightAmount;/*** 促销优化金额（促销价、满减、阶梯价）*/private BigDecimal promotionAmount;/*** 积分抵扣金额*/private BigDecimal integrationAmount;/*** 优惠券抵扣金额*/private BigDecimal couponAmount;/*** 后台调整订单使用的折扣金额*/private BigDecimal discountAmount;/*** 支付方式【1->支付宝；2->微信；3->银联； 4->货到付款；】*/private Integer payType;/*** 订单来源[0->PC订单；1->app订单]*/private Integer sourceType;/*** 订单状态【0->待付款；1->待发货；2->已发货；3->已完成；4->已关闭；5->无效订单】*/private Integer status;/*** 物流公司(配送方式)*/private String deliveryCompany;/*** 物流单号*/private String deliverySn;/*** 自动确认时间（天）*/private Integer autoConfirmDay;/*** 可以获得的积分*/private Integer integration;/*** 可以获得的成长值*/private Integer growth;/*** 发票类型[0->不开发票；1->电子发票；2->纸质发票]*/private Integer billType;/*** 发票抬头*/private String billHeader;/*** 发票内容*/private String billContent;/*** 收票人电话*/private String billReceiverPhone;/*** 收票人邮箱*/private String billReceiverEmail;/*** 收货人姓名*/private String receiverName;/*** 收货人电话*/private String receiverPhone;/*** 收货人邮编*/private String receiverPostCode;/*** 省份/直辖市*/private String receiverProvince;/*** 城市*/private String receiverCity;/*** 区*/private String receiverRegion;/*** 详细地址*/private String receiverDetailAddress;/*** 订单备注*/private String note;/*** 确认收货状态[0->未确认；1->已确认]*/private Integer confirmStatus;/*** 删除状态【0->未删除；1->已删除】*/private Integer deleteStatus;/*** 下单时使用的积分*/private Integer useIntegration;/*** 支付时间*/private Date paymentTime;/*** 发货时间*/private Date deliveryTime;/*** 确认收货时间*/private Date receiveTime;/*** 评价时间*/private Date commentTime;/*** 修改时间*/private Date modifyTime;}

- 进行双重判断

- - 先判断订单不存在（因为有异常造成的数据回滚导致订单不存在）或者订单状态是取消状态
  - 在判断当前库存工作单详情状态是不是1，1表示已锁定，只有当前库存工作单详情状态未解锁才可以解锁

- 调用unLockStock方法实现真正的解库存（自动解库存）

- - 更新库存的数量（还原）
  - 更新工作单的状态为已解锁

 /*** 真正解锁库存的方法（自动解库存）* @param skuId 需要解锁库存的商品id* @param wareId  需要解锁库存的库存仓库id* @param num  需要解锁库存的商品数量* @param taskDetailId   库存工作单详情id*/public void unLockStock(Long skuId,Long wareId,Integer num,Long taskDetailId) {//库存解锁（其实就是修改wms_ware_sku表中的stock_locked的值，之前锁库存锁了多少个就减去多少个）wareSkuDao.unLockStock(skuId,wareId,num);//更新工作单的状态WareOrderTaskDetailEntity taskDetailEntity = new WareOrderTaskDetailEntity();taskDetailEntity.setId(taskDetailId);//setLockStatus(2)表示变为已解锁（1表示已锁定，2表示已解锁，3表示减扣）taskDetailEntity.setLockStatus(2);wareOrderTaskDetailService.updateById(taskDetailEntity);}

<!--    解锁库存-->
<update id="unLockStock">UPDATE wms_ware_skuSET stock_locked = stock_locked - #{num}WHEREsku_id = ${skuId}AND ware_id = #{wareId}
</update>

手动解库存

订单服务的订单取消后立马解库存的具体逻辑

- 首先通过订单号查询订单锁库存工作单
- 通过订单锁库存工作单的id去库存详细工作单去找对应的锁库存的记录，看有没有记录并且锁库存的状态是已锁定的状态，防止多次重复解库存（其中库存详细工作单中的工作id的值就是订单锁库存工作单的id的值）
- 最后调用真正的解库存方法来解库存

   /*** 真正解锁库存的方法（自动解库存）* @param skuId 需要解锁库存的商品id* @param wareId  需要解锁库存的库存仓库id* @param num  需要解锁库存的商品数量* @param taskDetailId   库存工作单详情id*/public void unLockStock(Long skuId,Long wareId,Integer num,Long taskDetailId) {//库存解锁（其实就是修改wms_ware_sku表中的stock_locked的值，之前锁库存锁了多少个就减去多少个）wareSkuDao.unLockStock(skuId,wareId,num);//更新工作单的状态WareOrderTaskDetailEntity taskDetailEntity = new WareOrderTaskDetailEntity();taskDetailEntity.setId(taskDetailId);//setLockStatus(2)表示变为已解锁（1表示已锁定，2表示已解锁，3表示减扣）taskDetailEntity.setLockStatus(2);wareOrderTaskDetailService.updateById(taskDetailEntity);}/*** 订单取消了就立马解库存* 防止订单服务卡顿，导致订单状态消息一直改不了，库存优先到期，查订单状态新建，什么都不处理* 导致卡顿的订单，永远都不能解锁库存* @param orderTo*/@Transactional(rollbackFor = Exception.class)@Overridepublic void unlockStock(OrderTo orderTo) {String orderSn = orderTo.getOrderSn();//查一下最新的库存解锁状态，防止重复解锁库存WareOrderTaskEntity orderTaskEntity = wareOrderTaskService.getOrderTaskByOrderSn(orderSn);//按照工作单的id找到所有 没有解锁的库存，进行解锁（lock_status=1表示已锁定库存）Long id = orderTaskEntity.getId();List<WareOrderTaskDetailEntity> list = wareOrderTaskDetailService.list(new QueryWrapper<WareOrderTaskDetailEntity>().eq("task_id", id).eq("lock_status", 1));for (WareOrderTaskDetailEntity taskDetailEntity : list) {//解锁库存unLockStock(taskDetailEntity.getSkuId(),taskDetailEntity.getWareId(),taskDetailEntity.getSkuNum(),taskDetailEntity.getId());}}

订单服务------技术点及亮点相关推荐

秒杀服务------技术点及亮点
大技术使用Redisson 使用Redisson在秒杀服务中有两个作用,一个是作为分布式锁来确保多个秒杀服务同时在线时同时上架秒杀商品,只允许有一个秒杀服务成功上架秒杀商品,其他的上架失败.第二个作 ...
中国式微服务技术栈2.0
本文转载自公众号: 波波微课 | 前言近年,Spring Cloud俨然已经成为微服务开发的主流技术栈,在国内开发者社区非常火爆. 我近年一直在一线互联网公司(携程,拍拍贷等)开展微服务架构实践,根 ...
springcloud全局过滤_微服务技术SpringCloud 互联网网站架构演变过程
网站架构演变过程传统架构传统的SSH架构,分为三层架构 web控制层.业务逻辑层.数据库访问层. 传统架构也就是单点应用,就是大家在刚开始初学JavaEE技术的时候SSH架构或者SSM架构,业务没 ...
微服务技术发展的现状与展望
微服务技术发展的现状与展望人工智能技术与咨询来源:计算机研究与发展,作者冯志勇等摘要随着云计算.物联网等技术迅速发展,用户对软件系统的需求趋于多样化,面向服务的体系架构(service or ...
netty 游戏服务器框图_基于Netty和WebSocket协议实现Web端自动打印订单服务方法与流程...
本发明涉及电子商务技术领域,尤其涉及一种基于netty和websocket协议实现web端自动打印订单服务方法. 背景技术: 电子商务是以信息网络技术为手段,以商品交换为中心的商务活动:也可理解为在互 ...
谷粒商城--订单服务--高级篇笔记十一
1.页面环境搭建 1.1 静态资源导入nginx 等待付款 --------->detail 订单页 --------->list 结算页 --------->confirm 收银页 ...
SpringCloud一、前提概述、相关微服务和微服务架构理论知识、微服务技术栈有哪些、
①前提概述.微服务架构springcloud的相关学习. 前提知识+相关说明 1.目前,我们学习到最后的微服务架构SpringCloud,基本上需要熟悉以前的学习内容和知识:springmvc.spr ...
SpringCloud微服务技术实践与总结（基础篇）
1.认识微服务 1.1.单体架构单体架构:将业务的所有功能集中在一个项目中开发,打成一个包部署. 单体架构的优缺点如下: 优点: 架构简单.部署成本低缺点: 耦合度高(维护困难.升级困难) 1.2 ...
【谷粒商城之订单服务-支付】
本笔记内容为尚硅谷谷粒商城订单服务支付部分目录一.支付宝沙箱沙箱环境二.公钥.私钥.加密.加签.验签 1.公钥私钥 2.加密和数字签名 3.对称加密和非对称加密三.内网穿透四.整合支付 1 ...

订单服务------技术点及亮点

大技术