一、资源整合
我们需要修改hosts文件，并把相关的静态资源拷贝到nginx，然后动态模板文件拷贝到order项目的templates目录下，然后调整资源的路径。在网关中设置对应的路由即可。和之前创建一个服务步骤一致，这里就不重复写了。
二、整合SpringSession
结合官网，导入对应的依赖，然后添加对应的配置信息，redis配置信息，Cookie的配置一级域名和二级域名，也是之前的内容就不重复写了。
三、订单中心
订单中心涉及到的模块
订单的状态：
- 待付款:提交订单，订单预下单
- 已付款/待发货：完成支付，订单系统需要记录支付时间，支付流水号便于对账，订单下放到wms系统，仓库进行调拨，配货，分拣，出库等操作
- 待收款/已发货:仓库将商品出库，订单进入物流环节
- 已完成:用户确认收货，订单交易完成，后续支付侧进行结算，如果订单存在问题就进入售后状态
- 已取消:付款之前取消订单。
- 售后中：用户在付款后申请退款，或商家发货后用户申请退换货。
订单流程：
四、认证拦截
订单服务中的所有的请求都必须是在认证的状态下处理的，所有我们需要添加一个校验是否认证的拦截器
package com.sherrymall.mall.order.interceptor;
import com.sherrymall.common.constant.AuthConstant;
import com.sherrymall.common.vo.MemberVO;
import org.springframework.web.servlet.HandlerInterceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
public class AuthInterceptor implements HandlerInterceptor {
public static ThreadLocal threadLocal = new ThreadLocal();
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
// 通过HttpSession获取当前登录的用户信息
HttpSession session = request.getSession();
Object attribute = session.getAttribute(AuthConstant.AUTH_SESSION_REDIS);
if(attribute != null){
MemberVO memberVO = (MemberVO) attribute;
threadLocal.set(memberVO);
return true;
}
// 如果 attribute == null 说明没有登录，那么我们就需要重定向到登录页面
session.setAttribute(AuthConstant.AUTH_SESSION_MSG,"请先登录");
response.sendRedirect("http://auth.sherrymall.com/login.html");
return false;
}
}然后注册该拦截器即可
@Configuration
public class MyWebInterceptorConfig implements WebMvcConfigurer {
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(new AuthInterceptor()).addPathPatterns("/**");
}
}五、订单确认页
1.订单确认页VO抽取
public class OrderConfirmVo {
// 订单的收货人 及 收货地址信息
@Getter @Setter
List<MemberAddressVo> address;
// 购物车中选中的商品信息
@Getter @Setter
List<OrderItemVo> items;
// 支付方式
// 发票信息
// 优惠信息
//Integer countNum;
public Integer getCountNum(){
int count = 0;
if(items != null){
for (OrderItemVo item : items) {
count += item.getCount();
}
}
return count;
}
// BigDecimal total ;// 总的金额
public BigDecimal getTotal(){
BigDecimal sum = new BigDecimal(0);
if(items != null ){
for (OrderItemVo item : items) {
BigDecimal totalPrice = item.getPrice().multiply(new BigDecimal(item.getCount()));
sum = sum.add(totalPrice);
}
}
return sum;
}
// BigDecimal payTotal;// 需要支付的总金额
public BigDecimal getPayTotal(){
return getTotal();
}
}2.确认页数据获取
通过Fegin远程调用对应的服务，获取会员的数据和购物车中的商品信息。
@Override
public OrderConfirmVo confirmOrder() {
OrderConfirmVo vo = new OrderConfirmVo();
MemberVO memberVO = (MemberVO) AuthInterceptor.threadLocal.get();
// 获取到 RequestContextHolder 的相关信息
RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
CompletableFuture<Void> future1 = CompletableFuture.runAsync(() -> {
// 同步主线程中的 RequestContextHolder
RequestContextHolder.setRequestAttributes(requestAttributes);
// 1.查询当前登录用户对应的会员的地址信息
Long id = memberVO.getId();
List<MemberAddressVo> addresses = memberFeginService.getAddress(id);
vo.setAddress(addresses);
}, executor);
CompletableFuture<Void> future2 = CompletableFuture.runAsync(() -> {
RequestContextHolder.setRequestAttributes(requestAttributes);
// 2.查询购物车中选中的商品信息
List<OrderItemVo> userCartItems = cartFeginService.getUserCartItems();
vo.setItems(userCartItems);
}, executor);
try {
CompletableFuture.allOf(future1,future2).get();
} catch (Exception e) {
e.printStackTrace();
}
// 3.计算订单的总金额和需要支付的总金额 VO自动计算
return vo;
}在Fegin调用远程服务的时候会出现请求Header丢失的问题。
因为Cart服务有一个拦截器，需要获取到请求的登录状态，而Feign在远程调用的过程中，Header丢失后就获取不到登录的状态，所以接口就掉不通。
我们可以通过注入一个Request拦截器来解决该问题
@Configuration
public class MallFeignConfig {
@Bean
public RequestInterceptor requestInterceptor(){
return new RequestInterceptor() {
@Override
public void apply(RequestTemplate requestTemplate) {
ServletRequestAttributes requestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
HttpServletRequest request = requestAttributes.getRequest();
String cookie = request.getHeader("Cookie");
requestTemplate.header("Cookie",cookie);
}
};
}
}首先我们创建 RequestInterceptor的实现来绑定Header信息，同时在异步处理的时候我们需要从主线程中获取Request信息，然后绑定在子线程中。
然后在订单确认页中渲染数据的展示
最后的页面效果
六、接口幂等性处理
幂等性： 多次调用方法或者接口不会改变业务状态，可以保证重复调用的结果和单次调用的结果一致。
1.天然的幂等行为
以SQL语句为例：
select * from t_user where id = 1;
update t_user set age = 18 where id = 2;
delete from t_user where id = 1
insert into (userid,username)values(1,'') ; # userid 唯一主键不具备幂等行为的
update t_user set age = age + 1 where id = 1;
insert into (userid,username)values(1,''); # userid 不是主键 可以重复2.需要使用幂等的场景
需要使用幂等的场景 ：
- 前端重复提交
- 接口超时重试
- 消息队列重复消费
3.解决方案
- token机制 ：①客户端请求获取token，服务端生成一个唯一ID作为token存在redis中；②客户端第二次请求时携带token，服务端校验token成功则执行业务操作并删除token，服务端校验token失败则表示重复操作。值得注意的是 2 3 4 必须保证原子性，否则还是会出现问题。
- 基于mysql ：①新建去重表；②服务端将客户端请求时提交的部分信息放入表中，其中有唯一索引字段；③成功插入则没有重复请求，插入失败则重复请求。
- 基于redis ：①客户端请求服务端拿本次请求的标识字段；②服务端将标识字段以setnx方式存入redis并设置过期时间；③设置成功则说明非重复操作，设置失败则表示重复操作。
- 状态机、悲观锁、乐观锁等。
七、提交订单
1.防重提交
在订单提交的时候我们通过防重Token来保证请求的幂等性
2.生成Token
我们在获取订单结算页数据的service中我们需要生成对应的Token，并且保存到Redis中同时绑定到页面。
页面中的处理
3.提交订单
然后在提交订单的逻辑中我们先创建对应的VO
@Data
public class OrderSubmitVO {
// 收获地址的id
private Long addrId;
// 支付方式
private Integer payType;
// 防重Token
private String orderToken;
// 买家备注
private String note;
}然后在订单确认页中创建对应的form表单
然后把数据提交到后端服务中。
4.防重检查
订单数据提交到后端服务，我们在下订单前需要做防重提交的校验。
private Lock lock = new ReentrantLock();
@Override
public OrderResponseVo submitOrder(OrderSubmitVo vo) {
OrderResponseVo responseVo = new OrderResponseVo();
//获取当前登录的用户信息
MemberVo memberVo = AuthInterceptor.threadLocal.get();
//验证是否重复提交 保证Redis中的查询和删除是一个原子性操作
String key = OrderConstant.ORDER_TOKEN_PREFIX+":"+memberVo.getId();
try {
lock.lock();
String redisToken = redisTemplate.opsForValue().get(key);
if (redisToken != null && redisToken.equals(vo.getOrderToken())){
//表示是第一次提交
// 需要删除token
redisTemplate.delete(key);
}else {
}
}finally {
lock.unlock(); //释放锁
}
return responseVo;
}上面我们是通过Lock加锁的方式来实现Redis中的查询和删除操作的原子性，我们同时可以使用Redis中脚本来实现原子性处理。
// 获取当前登录的用户信息
MemberVO memberVO = (MemberVO) AuthInterceptor.threadLocal.get();
// 1.验证是否重复提交 保证Redis中的token 的查询和删除是一个原子性操作
String key = OrderConstant.ORDER_TOKEN_PREFIX+":"+memberVO.getId();
String script = "if redis.call('get',KEYS[1])==ARGV[1] then return redis.call('del',KEYS[1]) else return 0 ";
Long result = redisTemplate.execute(new DefaultRedisScript<Long>(script, Long.class)
, Arrays.asList(key)
, vo.getOrderToken());
if(result == 0){
// 表示验证失败 说明是重复提交
return responseVO;
}八、生成订单
一个是需要生成订单信息一个是需要生成订单项信息。具体的核心代码为
/**
* 创建订单的方法
* @param vo
* @return
*/
private OrderCreateTO createOrder(OrderSubmitVO vo) {
OrderCreateTO createTO = new OrderCreateTO();
// 创建订单
OrderEntity orderEntity = buildOrder(vo);
createTO.setOrderEntity(orderEntity);
// 创建OrderItemEntity 订单项
List<OrderItemEntity> orderItemEntitys = buildOrderItems(orderEntity.getOrderSn());
createTO.setOrderItemEntitys(orderItemEntitys);
return createTO;
}
/**
* 通过购物车中选中的商品来创建对应的购物项信息
* @return
*/
private List<OrderItemEntity> buildOrderItems(String orderSN) {
List<OrderItemEntity> orderItemEntitys = new ArrayList<>();
// 获取购物车中的商品信息 选中的
List<OrderItemVo> userCartItems = cartFeignService.getUserCartItems();
if(userCartItems != null && userCartItems.size() > 0){
// 统一根据SKUID查询出对应的SPU的信息
List<Long> spuIds = new ArrayList<>();
for (OrderItemVo orderItemVo : userCartItems) {
if(!spuIds.contains(orderItemVo.getSpuId())){
spuIds.add(orderItemVo.getSpuId());
}
}
Long[] spuIdsArray = new Long[spuIds.size()];
// 远程调用商品服务获取到对应的SPU信息
spuIdsArray = spuIds.toArray(spuIdsArray);
List<OrderItemSpuInfoVO> spuInfos = productService.getOrderItemSpuInfoBySpuId(spuIdsArray);
Map<Long, OrderItemSpuInfoVO> map = spuInfos.stream().collect(Collectors.toMap(OrderItemSpuInfoVO::getId, item -> item));
for (OrderItemVo userCartItem : userCartItems) {
// 获取到商品信息对应的 SPU信息
OrderItemSpuInfoVO spuInfo = map.get(userCartItem.getSpuId());
OrderItemEntity orderItemEntity = buildOrderItem(userCartItem,spuInfo);
// 绑定对应的订单编号
orderItemEntity.setOrderSn(orderSN);
orderItemEntitys.add(orderItemEntity);
}
}
return orderItemEntitys;
}
/**
* 根据一个购物车中的商品创建对应的 订单项
* @param userCartItem
* @return
*/
private OrderItemEntity buildOrderItem(OrderItemVo userCartItem,OrderItemSpuInfoVO spuInfo) {
OrderItemEntity entity = new OrderItemEntity();
// SKU信息
entity.setSkuId(userCartItem.getSkuId());
entity.setSkuName(userCartItem.getTitle());
entity.setSkuPic(userCartItem.getImage());
entity.setSkuQuantity(userCartItem.getCount());
List<String> skuAttr = userCartItem.getSkuAttr();
String skuAttrStr = StringUtils.collectionToDelimitedString(skuAttr, ";");
entity.setSkuAttrsVals(skuAttrStr);
// SPU信息
entity.setSpuId(spuInfo.getId());
entity.setSpuBrand(spuInfo.getBrandName());
entity.setCategoryId(spuInfo.getCatalogId());
entity.setSpuPic(spuInfo.getImg());
// 优惠信息 忽略
// 积分信息
entity.setGiftGrowth(userCartItem.getPrice().intValue());
entity.setGiftIntegration(userCartItem.getPrice().intValue());
return entity;
}
private OrderEntity buildOrder(OrderSubmitVO vo) {
// 创建OrderEntity
OrderEntity orderEntity = new OrderEntity();
// 创建订单编号
String orderSn = IdWorker.getTimeId();
orderEntity.setOrderSn(orderSn);
MemberVO memberVO = (MemberVO) AuthInterceptor.threadLocal.get();
// 设置会员相关的信息
orderEntity.setMemberId(memberVO.getId());
orderEntity.setMemberUsername(memberVO.getUsername());
// 根据收获地址ID获取收获地址的详细信息
MemberAddressVo memberAddressVo = memberFeginService.getAddressById(vo.getAddrId());
orderEntity.setReceiverCity(memberAddressVo.getCity());
orderEntity.setReceiverDetailAddress(memberAddressVo.getDetailAddress());
orderEntity.setReceiverName(memberAddressVo.getName());
orderEntity.setReceiverPhone(memberAddressVo.getPhone());
orderEntity.setReceiverPostCode(memberAddressVo.getPostCode());
orderEntity.setReceiverRegion(memberAddressVo.getRegion());
orderEntity.setReceiverProvince(memberAddressVo.getProvince());
// 设置订单的状态
orderEntity.setStatus(OrderConstant.OrderStateEnum.FOR_THE_PAYMENT.getCode());
return orderEntity;
}订单生成之后，要对订单进行保存
/**
* 生成订单数据方法
* @param orderCreateTO
*/
private void saveOrder(OrderCreateTO orderCreateTO) {
// 1.订单数据
OrderEntity orderEntity = orderCreateTO.getOrderEntity();
orderService.save(orderEntity);
// 2.订单项数据
List<OrderItemEntity> orderItemEntitys = orderCreateTO.getOrderItemEntitys();
orderItemService.saveBatch(orderItemEntitys);
}锁定库存的操作，需要操作ware仓储服务。
/**
* 锁定库存的操作
* @param vo
* @return
*/
@Transactional
@Override
public Boolean orderLockStock(WareSkuLockVO vo) {
List<OrderItemVo> items = vo.getItems();
// 首先找到具有库存的仓库
List<SkuWareHasStock> collect = items.stream().map(item -> {
SkuWareHasStock skuWareHasStock = new SkuWareHasStock();
skuWareHasStock.setSkuId(item.getSkuId());
List<WareSkuEntity> wareSkuEntities = this.baseMapper.listHashStock(item.getSkuId());
skuWareHasStock.setWareSkuEntities(wareSkuEntities);
skuWareHasStock.setNum(item.getCount());
return skuWareHasStock;
}).collect(Collectors.toList());
// 尝试锁定库存
for (SkuWareHasStock skuWareHasStock : collect) {
Long skuId = skuWareHasStock.getSkuId();
List<WareSkuEntity> wareSkuEntities = skuWareHasStock.wareSkuEntities;
if(wareSkuEntities == null && wareSkuEntities.size() == 0){
// 当前商品没有库存了
throw new NoStockExecption(skuId);
}
// 当前需要锁定的商品的梳理
Integer count = skuWareHasStock.getNum();
Boolean skuStocked = false; // 表示当前SkuId的库存没有锁定完成
for (WareSkuEntity wareSkuEntity : wareSkuEntities) {
// 循环获取到对应的 仓库，然后需要锁定库存
// 获取当前仓库能够锁定的库存数
Integer canStock = wareSkuEntity.getStock() - wareSkuEntity.getStockLocked();
if(count <= canStock){
// 表示当前的skuId的商品的数量小于等于需要锁定的数量
Integer i = this.baseMapper.lockSkuStock(skuId,wareSkuEntity.getWareId(),count);
count = 0;
skuStocked = true;
}else{
// 需要锁定的库存大于 可以锁定的库存 就按照已有的库存来锁定
Integer i = this.baseMapper.lockSkuStock(skuId,wareSkuEntity.getWareId(),canStock);
count = count - canStock;
}
if(count <= 0 ){
// 表示所有的商品都锁定了
break;
}
}
if(count > 0){
// 说明库存没有锁定完
throw new NoStockExecption(skuId);
}
if(skuStocked == false){
// 表示上一个商品的没有锁定库存成功
throw new NoStockExecption(skuId);
}
}
return true;
}
@Data
class SkuWareHasStock{
private Long skuId;
private Integer num;
private List<WareSkuEntity> wareSkuEntities;
}没有库存或者锁定库存失败我们通过自定义的异常抛出
/**
* 自定义异常：锁定库存失败的情况下产生的异常信
*/
public class NoStockExecption extends RuntimeException{
private Long skuId;
public NoStockExecption(Long skuId){
super("当前商品["+skuId+"]没有库存了");
this.skuId = skuId;
}
public Long getSkuId() {
return skuId;
}
public void setSkuId(Long skuId) {
this.skuId = skuId;
}
}如果下订单操作成功（订单数据和订单项数据）我们就会操作锁库存的行为
锁定库存失败通过抛异常来使订单操作回滚
@PostMapping("/orderSubmit")
public String orderSubmit(OrderSubmitVo vo, Model model, RedirectAttributes redirectAttributes){
Integer code = 0;
OrderResponseVo responseVo = null;
try {
responseVo = orderService.submitOrder(vo);
code = responseVo.getCode();
} catch (NoStockExecption noStockExecption) {
code = 2;
}
if (code == 0){
// 表示下单操作成功
model.addAttribute("orderResponseVO",responseVo);
return "pay";
}else {
// 表示下单操作失败
String msg = "订单失败";
if (code == 1){
msg = msg + ":重复提交";
}else if (code == 2){
msg = msg + ":锁定库存失败";
}
//redirectAttributes.addAttribute("msg",msg);
redirectAttributes.addFlashAttribute("msg",msg);
return "redirect:http://order.sherrymall.com/toTrade";
}
}@Override
public OrderResponseVo submitOrder(OrderSubmitVo vo) throws NoStockExecption{
OrderResponseVo responseVo = new OrderResponseVo();
//获取当前登录的用户信息
MemberVo memberVo = AuthInterceptor.threadLocal.get();
//1.验证是否重复提交 保证Redis中的查询和删除是一个原子性操作
String key = OrderConstant.ORDER_TOKEN_PREFIX+":"+memberVo.getId();
String script = "if redis.call('get',KEYS[1])==ARGV[1] then return redis.call('del',KEYS[1]) else return 0 end";
Long result = redisTemplate.execute(new DefaultRedisScript<Long>(script, Long.class)
, Arrays.asList(key)
, vo.getOrderToken());
if(result == 0){
// 表示验证失败 说明是重复提交
responseVo.setCode(1);
return responseVo;
}
// 2.创建订单和订单项信息
OrderCreateTO orderCreateTO = createOrder(vo);
responseVo.setOrderEntity(orderCreateTO.getOrderEntity());
// 3. 保存订单信息
saveOrder(orderCreateTO);
// 4. 锁定库存信息
// 订单号 sku_Id sku_name 商品数量
// 封装wareSkuLockVO 对象
WareSkuLockVO wareSkuLockVO = new WareSkuLockVO();
wareSkuLockVO.setOrderSN(orderCreateTO.getOrderEntity().getOrderSn());
List<OrderItemVo> orderItemVos = orderCreateTO.getOrderItemEntitys().stream().map(item -> {
OrderItemVo itemVo = new OrderItemVo();
itemVo.setSkuId(item.getSkuId());
itemVo.setTitle(item.getSkuName());
itemVo.setCount(item.getSkuQuantity());
return itemVo;
}).collect(Collectors.toList());
wareSkuLockVO.setItems(orderItemVos);
// 远程锁库存的操作
R r = wareFeignService.orderLockStock(wareSkuLockVO);
if (r.getCode() == 0){
// 表示锁定库存成功
responseVo.setCode(0); // 创建订单成功
}else {
// 表示锁定库存失败
responseVo.setCode(2); // 表示库存不足 锁定失败
throw new NoStockExecption(1000000L);
}
return responseVo;
}
