商城项目解决订单模块Feign异步处理远程调用丢失线程一致性导致ThreadLocal失效问题-----商城项目

已于 2024-10-03 23:52:15 修改
阅读量586 收藏 10
点赞数 6
分类专栏： 电商项目 # Spring-Boot框架 # Spring-Cloud框架 文章标签： mybatis spring boot 后端 微服务 分布式 spring cloud spring
于 2024-10-03 22:20:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2201_75960169/article/details/142696885
版权
#哪个编程工具让你的工作效率翻倍？# 
package com.alatus.mall.order.service.impl;

import com.alatus.common.vo.MemberRespVo;
import com.alatus.mall.order.feign.CartFeignService;
import com.alatus.mall.order.feign.MemberFeignService;
import com.alatus.mall.order.interceptor.LoginUserInterceptor;
import com.alatus.mall.order.to.MemberAddressTo;
import com.alatus.mall.order.vo.OrderConfirmVo;
import com.alatus.mall.order.vo.OrderItemVo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Map;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ThreadPoolExecutor;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.alatus.common.utils.PageUtils;
import com.alatus.common.utils.Query;

import com.alatus.mall.order.dao.OrderDao;
import com.alatus.mall.order.entity.OrderEntity;
import com.alatus.mall.order.service.OrderService;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;


@Service("orderService")
public class OrderServiceImpl extends ServiceImpl<OrderDao, OrderEntity> implements OrderService {
    @Autowired
    private MemberFeignService memberFeignService;
    @Autowired
    private CartFeignService cartFeignService;
    @Autowired
    private ThreadPoolExecutor threadPoolExecutor;
    @Override
    public PageUtils queryPage(Map<String, Object> params) {
        IPage<OrderEntity> page = this.page(
                new Query<OrderEntity>().getPage(params),
                new QueryWrapper<OrderEntity>()
        );

        return new PageUtils(page);
    }

    @Override
    public OrderConfirmVo confirmOrder() throws ExecutionException, InterruptedException {
        OrderConfirmVo confirmVo = new OrderConfirmVo();
//        获取原请求信息,避免异步导致丢失
        RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
        MemberRespVo memberRespVo = LoginUserInterceptor.loginUser.get();
//        远程查询购物车所有选中的购物项
        CompletableFuture<Void> itemVoList = CompletableFuture.runAsync(() -> {
            RequestContextHolder.setRequestAttributes(requestAttributes);
            confirmVo.setItemVoList(cartFeignService.getCurrentCartItem());
        }, threadPoolExecutor);
//        远程查询所有的用户地址列表
        CompletableFuture<Void> addressTask = CompletableFuture.runAsync(() -> {
            RequestContextHolder.setRequestAttributes(requestAttributes);
            confirmVo.setAddress(memberFeignService.getAddress(memberRespVo.getId()));
        }, threadPoolExecutor);
//        用户积分
        CompletableFuture<Void> integrationTask = CompletableFuture.runAsync(() -> {
            confirmVo.setIntegration(memberRespVo.getIntegration());
        }, threadPoolExecutor);
        CompletableFuture.allOf(addressTask,itemVoList,integrationTask).get();
//        TODO 订单令牌
        return confirmVo;
    }
}
package com.alatus.mall.order.service.impl;

import com.alatus.common.vo.MemberRespVo;
import com.alatus.mall.order.feign.CartFeignService;
import com.alatus.mall.order.feign.MemberFeignService;
import com.alatus.mall.order.interceptor.LoginUserInterceptor;
import com.alatus.mall.order.to.MemberAddressTo;
import com.alatus.mall.order.vo.OrderConfirmVo;
import com.alatus.mall.order.vo.OrderItemVo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Map;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ThreadPoolExecutor;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.alatus.common.utils.PageUtils;
import com.alatus.common.utils.Query;

import com.alatus.mall.order.dao.OrderDao;
import com.alatus.mall.order.entity.OrderEntity;
import com.alatus.mall.order.service.OrderService;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;


@Service("orderService")
public class OrderServiceImpl extends ServiceImpl<OrderDao, OrderEntity> implements OrderService {
    @Autowired
    private MemberFeignService memberFeignService;
    @Autowired
    private CartFeignService cartFeignService;
    @Autowired
    private ThreadPoolExecutor threadPoolExecutor;
    @Override
    public PageUtils queryPage(Map<String, Object> params) {
        IPage<OrderEntity> page = this.page(
                new Query<OrderEntity>().getPage(params),
                new QueryWrapper<OrderEntity>()
        );

        return new PageUtils(page);
    }

    @Override
    public OrderConfirmVo confirmOrder() throws ExecutionException, InterruptedException {
        OrderConfirmVo confirmVo = new OrderConfirmVo();
//        获取原请求信息,避免异步导致丢失
        RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
        MemberRespVo memberRespVo = LoginUserInterceptor.loginUser.get();
//        远程查询购物车所有选中的购物项
        CompletableFuture<Void> itemVoList = CompletableFuture.runAsync(() -> {
            RequestContextHolder.setRequestAttributes(requestAttributes);
            confirmVo.setItemVoList(cartFeignService.getCurrentCartItem());
        }, threadPoolExecutor);
//        远程查询所有的用户地址列表
        CompletableFuture<Void> addressTask = CompletableFuture.runAsync(() -> {
            RequestContextHolder.setRequestAttributes(requestAttributes);
            confirmVo.setAddress(memberFeignService.getAddress(memberRespVo.getId()));
        }, threadPoolExecutor);
//        用户积分
        CompletableFuture<Void> integrationTask = CompletableFuture.runAsync(() -> {
            confirmVo.setIntegration(memberRespVo.getIntegration());
        }, threadPoolExecutor);
        CompletableFuture.allOf(addressTask,itemVoList,integrationTask).get();
//        TODO 订单令牌
        return confirmVo;
    }
}
package com.alatus.mall.order.vo;

import com.alatus.mall.order.to.MemberAddressTo;
import lombok.Data;
import java.math.BigDecimal;
import java.util.List;

@Data
public class OrderConfirmVo {
//    用户的收货地址
    private List<MemberAddressTo> address;
//    所有选中的购物车商品项
    private List<OrderItemVo> itemVoList;
//    TODO 发票信息
//    优惠券信息,积分可以减免金额
    private Integer integration;
//    订单令牌
    private String orderToken;
//    总价格
    private BigDecimal total;
//    应付金额
    private BigDecimal payPrice;
    public BigDecimal getTotal() {
        BigDecimal total = new BigDecimal(0);
        if(itemVoList!=null){
            for (OrderItemVo orderItemVo : itemVoList) {
                total.add(orderItemVo.getTotalPrice());
            }
        }
        return total;
    }
    public BigDecimal getPayPrice() {
        if(integration!=null){
            BigDecimal integrationBD = new BigDecimal(String.valueOf(integration));
            return getTotal().subtract(integrationBD);
        }
        return getTotal();
    }
}

package com.alatus.mall.order.vo;

import com.alatus.mall.order.to.MemberAddressTo;
import lombok.Data;
import java.math.BigDecimal;
import java.util.List;

@Data
public class OrderConfirmVo {
//    用户的收货地址
    private List<MemberAddressTo> address;
//    所有选中的购物车商品项
    private List<OrderItemVo> itemVoList;
//    TODO 发票信息
//    优惠券信息,积分可以减免金额
    private Integer integration;
//    订单令牌
    private String orderToken;
//    总价格
    private BigDecimal total;
//    应付金额
    private BigDecimal payPrice;
    public BigDecimal getTotal() {
        BigDecimal total = new BigDecimal(0);
        if(itemVoList!=null){
            for (OrderItemVo orderItemVo : itemVoList) {
                total.add(orderItemVo.getTotalPrice());
            }
        }
        return total;
    }
    public BigDecimal getPayPrice() {
        if(integration!=null){
            BigDecimal integrationBD = new BigDecimal(String.valueOf(integration));
            return getTotal().subtract(integrationBD);
        }
        return getTotal();
    }
}

package com.alatus.mall.cart.web;

import com.alatus.mall.cart.service.CartService;
import com.alatus.mall.cart.vo.Cart;
import com.alatus.mall.cart.vo.CartItem;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.mvc.support.RedirectAttributes;

import java.util.List;
import java.util.concurrent.ExecutionException;

@Controller
public class CartController {
    @Autowired
    private CartService cartService;
    @GetMapping("/currentUserCartItem")
    @ResponseBody
    public List<CartItem> getCurrentCartItem(){
        return cartService.getUserCartItems();
    }
    @GetMapping("/cart.html")
    public String cartListPage(Model model) throws ExecutionException, InterruptedException {
        Cart cart = cartService.getCart();
        model.addAttribute("cart",cart);
        return "cartList";
    }
    @GetMapping("/deleteItem")
    public String deleteItem(@RequestParam("skuId")Long skuId){
        cartService.deleteItem(skuId);
        return "redirect:http://cart.alatusmall.com/cart.html";
    }
    @GetMapping("/countItem")
    public String countItem(@RequestParam("skuId") Long skuId, @RequestParam("num") Integer num){
        cartService.changeItemCount(skuId,num);
        return "redirect:http://cart.alatusmall.com/cart.html";
    }
    @GetMapping("/addToCart")
    public String addToCart(@RequestParam("skuId") Long skuId, @RequestParam("num") Integer num, RedirectAttributes model) throws ExecutionException, InterruptedException {
        if(num > 0){
            cartService.addToCart(skuId,num);
//            RedirectAttributes的addAttribute会自动拼串,自动以参数的形式携带数据
//            RedirectAttributes的addFlashAttribute()会保存在session里面,但是仅可以取一次值
            model.addAttribute("skuId",skuId);
            return "redirect:http://cart.alatusmall.com/addToCartSuccess.html";
        }
        return "redirect:http://cart.alatusmall.com/addToCartSuccess.html";
    }
    @GetMapping("/checkItem")
    public String checkItem(@RequestParam("skuId")Long skuId,@RequestParam("check")Integer check){
        cartService.checkItem(skuId,check);
        return "redirect:http://cart.alatusmall.com/cart.html";
    }
    @GetMapping("/addToCartSuccess.html")
    public String addToCartSuccessPage(@RequestParam("skuId")Long skuId,Model model){
        CartItem cartItem = cartService.getCartItem(skuId);
        model.addAttribute("item",cartItem);
        return "success";
    }
}


package com.alatus.mall.cart.web;

import com.alatus.mall.cart.service.CartService;
import com.alatus.mall.cart.vo.Cart;
import com.alatus.mall.cart.vo.CartItem;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.mvc.support.RedirectAttributes;

import java.util.List;
import java.util.concurrent.ExecutionException;

@Controller
public class CartController {
    @Autowired
    private CartService cartService;
    @GetMapping("/currentUserCartItem")
    @ResponseBody
    public List<CartItem> getCurrentCartItem(){
        return cartService.getUserCartItems();
    }
    @GetMapping("/cart.html")
    public String cartListPage(Model model) throws ExecutionException, InterruptedException {
        Cart cart = cartService.getCart();
        model.addAttribute("cart",cart);
        return "cartList";
    }
    @GetMapping("/deleteItem")
    public String deleteItem(@RequestParam("skuId")Long skuId){
        cartService.deleteItem(skuId);
        return "redirect:http://cart.alatusmall.com/cart.html";
    }
    @GetMapping("/countItem")
    public String countItem(@RequestParam("skuId") Long skuId, @RequestParam("num") Integer num){
        cartService.changeItemCount(skuId,num);
        return "redirect:http://cart.alatusmall.com/cart.html";
    }
    @GetMapping("/addToCart")
    public String addToCart(@RequestParam("skuId") Long skuId, @RequestParam("num") Integer num, RedirectAttributes model) throws ExecutionException, InterruptedException {
        if(num > 0){
            cartService.addToCart(skuId,num);
//            RedirectAttributes的addAttribute会自动拼串,自动以参数的形式携带数据
//            RedirectAttributes的addFlashAttribute()会保存在session里面,但是仅可以取一次值
            model.addAttribute("skuId",skuId);
            return "redirect:http://cart.alatusmall.com/addToCartSuccess.html";
        }
        return "redirect:http://cart.alatusmall.com/addToCartSuccess.html";
    }
    @GetMapping("/checkItem")
    public String checkItem(@RequestParam("skuId")Long skuId,@RequestParam("check")Integer check){
        cartService.checkItem(skuId,check);
        return "redirect:http://cart.alatusmall.com/cart.html";
    }
    @GetMapping("/addToCartSuccess.html")
    public String addToCartSuccessPage(@RequestParam("skuId")Long skuId,Model model){
        CartItem cartItem = cartService.getCartItem(skuId);
        model.addAttribute("item",cartItem);
        return "success";
    }
}

package com.alatus.mall.cart.service.impl;

import com.alatus.common.utils.R;
import com.alatus.mall.cart.feign.ProductFeignService;
import com.alatus.mall.cart.service.CartService;
import com.alatus.mall.cart.vo.Cart;
import com.alatus.mall.cart.vo.CartItem;
import com.alatus.mall.cart.vo.SkuInfoVo;
import com.alatus.mall.cart.vo.UserInfoTo;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.BoundHashOperations;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
import com.alatus.mall.cart.interceptor.CartInterceptor;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.stream.Collectors;

@Slf4j
@Service
public class CartServiceImpl implements CartService {
    @Autowired
    private StringRedisTemplate redisTemplate;
    @Autowired
    private ProductFeignService productFeignService;
    @Autowired
    private ThreadPoolExecutor threadPoolExecutor;
    private final String CART_PREFIX = "alatusmall:cart:";
    @Override
    public void addToCart(Long skuId, Integer num) throws ExecutionException, InterruptedException {
        BoundHashOperations<String, Object, Object> cartOps = getCartOps();
        String res = (String) cartOps.get(skuId.toString());
        if(StringUtils.isEmpty(res)){
            CartItem cartItem = new CartItem();
//            当购物车没有该商品
//        查询商品服务目前添加的商品信息
            CompletableFuture<Void> getSkuInfo = CompletableFuture.runAsync(() -> {
                R info = productFeignService.info(skuId);
                if (info.getCode() == 0) {
                    SkuInfoVo skuInfo = info.get("skuInfo", new TypeReference<SkuInfoVo>() {});
                    cartItem.setCheck(true);
                    cartItem.setCount(num);
                    cartItem.setImage(skuInfo.getSkuDefaultImg());
                    cartItem.setTitle(skuInfo.getSkuTitle());
                    cartItem.setSkuId(skuId);
                    cartItem.setPrice(skuInfo.getPrice());
                }
            }, threadPoolExecutor);
            CompletableFuture<Void> getSkuAttrValues = CompletableFuture.runAsync(() -> {
//            远程查询sku的组合信息
                List<String> skuSaleAttrValues = productFeignService.getSkuSaleAttrValues(skuId);
                cartItem.setSkuAttr(skuSaleAttrValues);
            }, threadPoolExecutor);
            CompletableFuture.allOf(getSkuInfo,getSkuAttrValues).get();
            String jsonString = JSON.toJSONString(cartItem);
            cartOps.put(skuId.toString(),jsonString);
        }
        else{
//            购物车有这个商品
            CartItem oldCartItem = JSON.parseObject(res, CartItem.class);
            oldCartItem.setCount(oldCartItem.getCount()+num);
            cartOps.put(skuId.toString(),JSON.toJSONString(oldCartItem));
        }
    }

    @Override
    public CartItem getCartItem(Long skuId) {
        BoundHashOperations<String, Object, Object> cartOps = getCartOps();
        String res = (String)cartOps.get(skuId.toString());
        return JSON.parseObject(res, CartItem.class);
    }

    @Override
    public Cart getCart() throws ExecutionException, InterruptedException {
        UserInfoTo userInfoTo = CartInterceptor.threadLocal.get();
        Cart cart = new Cart();
        String userKey = CART_PREFIX + userInfoTo.getUserId();
        String templateKey = CART_PREFIX + userInfoTo.getUserKey();
        if (userInfoTo.getUserId()!=null) {
//            登录了
//            先获取临时购物车
            List<CartItem> tempCartItems = getCartItems(templateKey);
//            如果临时购物车还没有合并
            List<String> skuIds = new ArrayList<>();
            if(tempCartItems!=null&&tempCartItems.size()>0){
//                两个购物车要合并
                for (CartItem cartItem : tempCartItems) {
                    addToCart(cartItem.getSkuId(),cartItem.getCount());
                    skuIds.add(cartItem.getSkuId().toString());
                }
//                清除临时购物车的数据
                for (int i = 0; i < skuIds.size(); i++) {
                    redisTemplate.boundHashOps(templateKey).delete(skuIds.get(i));
                }
            }
//            登陆后的所有购物车数据(包含所有合并的购物车)
            List<CartItem> newCartItems = getCartItems(userKey);
            cart.setItems(newCartItems);
        }
        else{
//            没登陆
            List<CartItem> cartItems = getCartItems(templateKey);
            cart.setItems(cartItems);
        }
        return cart;
    }

    @Override
    public void checkItem(Long skuId, Integer check) {
        CartItem cartItem = getCartItem(skuId);
        cartItem.setCheck(check == 1);
        getCartOps().put(skuId.toString(),JSON.toJSONString(cartItem));
    }

    @Override
    public void changeItemCount(Long skuId, Integer num) {
        CartItem cartItem = getCartItem(skuId);
        cartItem.setCount(num);
        getCartOps().put(skuId.toString(),JSON.toJSONString(cartItem));
    }

    @Override
    public void deleteItem(Long skuId) {
        getCartOps().delete(skuId.toString());
    }

    @Override
    public List<CartItem> getUserCartItems() {
        UserInfoTo userInfoTo = CartInterceptor.threadLocal.get();
        if (userInfoTo.getUserId()!=null) {
            String cartKey = CART_PREFIX + userInfoTo.getUserId();
            List<CartItem> cartItems = getCartItems(cartKey);
            cartItems = cartItems.stream().filter(CartItem::getCheck).map(item->{
//                更新为最新价格,因为购物车价格是缓存,不一定准确
//                TODO 价格我们采用远程获取的方式
                R price = productFeignService.getPrice(item.getSkuId());
                if(price.getCode()==0){
                    item.setPrice(price.getData(new TypeReference<BigDecimal>(){}));
                }
                return item;
            }).collect(Collectors.toList());
            return cartItems;
        }
        else{
            return null;
        }
    }

    private List<CartItem> getCartItems(String cartKey){
        BoundHashOperations<String, Object, Object> operations = redisTemplate.boundHashOps(cartKey);
        List<Object> values = operations.values();
        if(values!=null&&values.size()>0){
            List<CartItem> collect = values.stream().map((obj) -> {
                return JSON.parseObject(obj.toString(), CartItem.class);
            }).collect(Collectors.toList());
            return collect;
        }
        else{
            return null;
        }
    }

    //    获取我们要操作的购物车
    private BoundHashOperations<String, Object, Object> getCartOps(){
        UserInfoTo userInfoTo = CartInterceptor.threadLocal.get();
//        用户已登录
        String cartKey = "";
        if(userInfoTo.getUserId()!=null){
            cartKey = CART_PREFIX + userInfoTo.getUserId();
        }
//        用户未登录
        else{
            cartKey = CART_PREFIX + userInfoTo.getUserKey();
        }
        BoundHashOperations<String, Object, Object> operations = redisTemplate.boundHashOps(cartKey);
        return operations;
    }
}

package com.alatus.mall.cart.service.impl;

import com.alatus.common.utils.R;
import com.alatus.mall.cart.feign.ProductFeignService;
import com.alatus.mall.cart.service.CartService;
import com.alatus.mall.cart.vo.Cart;
import com.alatus.mall.cart.vo.CartItem;
import com.alatus.mall.cart.vo.SkuInfoVo;
import com.alatus.mall.cart.vo.UserInfoTo;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.BoundHashOperations;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
import com.alatus.mall.cart.interceptor.CartInterceptor;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.stream.Collectors;

@Slf4j
@Service
public class CartServiceImpl implements CartService {
    @Autowired
    private StringRedisTemplate redisTemplate;
    @Autowired
    private ProductFeignService productFeignService;
    @Autowired
    private ThreadPoolExecutor threadPoolExecutor;
    private final String CART_PREFIX = "alatusmall:cart:";
    @Override
    public void addToCart(Long skuId, Integer num) throws ExecutionException, InterruptedException {
        BoundHashOperations<String, Object, Object> cartOps = getCartOps();
        String res = (String) cartOps.get(skuId.toString());
        if(StringUtils.isEmpty(res)){
            CartItem cartItem = new CartItem();
//            当购物车没有该商品
//        查询商品服务目前添加的商品信息
            CompletableFuture<Void> getSkuInfo = CompletableFuture.runAsync(() -> {
                R info = productFeignService.info(skuId);
                if (info.getCode() == 0) {
                    SkuInfoVo skuInfo = info.get("skuInfo", new TypeReference<SkuInfoVo>() {});
                    cartItem.setCheck(true);
                    cartItem.setCount(num);
                    cartItem.setImage(skuInfo.getSkuDefaultImg());
                    cartItem.setTitle(skuInfo.getSkuTitle());
                    cartItem.setSkuId(skuId);
                    cartItem.setPrice(skuInfo.getPrice());
                }
            }, threadPoolExecutor);
            CompletableFuture<Void> getSkuAttrValues = CompletableFuture.runAsync(() -> {
//            远程查询sku的组合信息
                List<String> skuSaleAttrValues = productFeignService.getSkuSaleAttrValues(skuId);
                cartItem.setSkuAttr(skuSaleAttrValues);
            }, threadPoolExecutor);
            CompletableFuture.allOf(getSkuInfo,getSkuAttrValues).get();
            String jsonString = JSON.toJSONString(cartItem);
            cartOps.put(skuId.toString(),jsonString);
        }
        else{
//            购物车有这个商品
            CartItem oldCartItem = JSON.parseObject(res, CartItem.class);
            oldCartItem.setCount(oldCartItem.getCount()+num);
            cartOps.put(skuId.toString(),JSON.toJSONString(oldCartItem));
        }
    }

    @Override
    public CartItem getCartItem(Long skuId) {
        BoundHashOperations<String, Object, Object> cartOps = getCartOps();
        String res = (String)cartOps.get(skuId.toString());
        return JSON.parseObject(res, CartItem.class);
    }

    @Override
    public Cart getCart() throws ExecutionException, InterruptedException {
        UserInfoTo userInfoTo = CartInterceptor.threadLocal.get();
        Cart cart = new Cart();
        String userKey = CART_PREFIX + userInfoTo.getUserId();
        String templateKey = CART_PREFIX + userInfoTo.getUserKey();
        if (userInfoTo.getUserId()!=null) {
//            登录了
//            先获取临时购物车
            List<CartItem> tempCartItems = getCartItems(templateKey);
//            如果临时购物车还没有合并
            List<String> skuIds = new ArrayList<>();
            if(tempCartItems!=null&&tempCartItems.size()>0){
//                两个购物车要合并
                for (CartItem cartItem : tempCartItems) {
                    addToCart(cartItem.getSkuId(),cartItem.getCount());
                    skuIds.add(cartItem.getSkuId().toString());
                }
//                清除临时购物车的数据
                for (int i = 0; i < skuIds.size(); i++) {
                    redisTemplate.boundHashOps(templateKey).delete(skuIds.get(i));
                }
            }
//            登陆后的所有购物车数据(包含所有合并的购物车)
            List<CartItem> newCartItems = getCartItems(userKey);
            cart.setItems(newCartItems);
        }
        else{
//            没登陆
            List<CartItem> cartItems = getCartItems(templateKey);
            cart.setItems(cartItems);
        }
        return cart;
    }

    @Override
    public void checkItem(Long skuId, Integer check) {
        CartItem cartItem = getCartItem(skuId);
        cartItem.setCheck(check == 1);
        getCartOps().put(skuId.toString(),JSON.toJSONString(cartItem));
    }

    @Override
    public void changeItemCount(Long skuId, Integer num) {
        CartItem cartItem = getCartItem(skuId);
        cartItem.setCount(num);
        getCartOps().put(skuId.toString(),JSON.toJSONString(cartItem));
    }

    @Override
    public void deleteItem(Long skuId) {
        getCartOps().delete(skuId.toString());
    }

    @Override
    public List<CartItem> getUserCartItems() {
        UserInfoTo userInfoTo = CartInterceptor.threadLocal.get();
        if (userInfoTo.getUserId()!=null) {
            String cartKey = CART_PREFIX + userInfoTo.getUserId();
            List<CartItem> cartItems = getCartItems(cartKey);
            cartItems = cartItems.stream().filter(CartItem::getCheck).map(item->{
//                更新为最新价格,因为购物车价格是缓存,不一定准确
//                TODO 价格我们采用远程获取的方式
                R price = productFeignService.getPrice(item.getSkuId());
                if(price.getCode()==0){
                    item.setPrice(price.getData(new TypeReference<BigDecimal>(){}));
                }
                return item;
            }).collect(Collectors.toList());
            return cartItems;
        }
        else{
            return null;
        }
    }

    private List<CartItem> getCartItems(String cartKey){
        BoundHashOperations<String, Object, Object> operations = redisTemplate.boundHashOps(cartKey);
        List<Object> values = operations.values();
        if(values!=null&&values.size()>0){
            List<CartItem> collect = values.stream().map((obj) -> {
                return JSON.parseObject(obj.toString(), CartItem.class);
            }).collect(Collectors.toList());
            return collect;
        }
        else{
            return null;
        }
    }

    //    获取我们要操作的购物车
    private BoundHashOperations<String, Object, Object> getCartOps(){
        UserInfoTo userInfoTo = CartInterceptor.threadLocal.get();
//        用户已登录
        String cartKey = "";
        if(userInfoTo.getUserId()!=null){
            cartKey = CART_PREFIX + userInfoTo.getUserId();
        }
//        用户未登录
        else{
            cartKey = CART_PREFIX + userInfoTo.getUserKey();
        }
        BoundHashOperations<String, Object, Object> operations = redisTemplate.boundHashOps(cartKey);
        return operations;
    }
}

package com.alatus.mall.order.config;

import feign.RequestInterceptor;
import feign.RequestTemplate;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;

@Configuration
public class OrderFeignConfig {
    @Bean("requestInterceptor")
    public RequestInterceptor requestInterceptor(){
        return new RequestInterceptor() {
            @Override
            public void apply(RequestTemplate requestTemplate) {
//                使用RequestContextHolder拿到当前请求所用的请求信息
                ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
//                同步请求头的Cookie信息,放到Feign的新请求中
                requestTemplate.header("Cookie",attributes.getRequest().getHeader("Cookie"));
            }
        };
    }
}

package com.alatus.mall.order.config;

import feign.RequestInterceptor;
import feign.RequestTemplate;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;

@Configuration
public class OrderFeignConfig {
    @Bean("requestInterceptor")
    public RequestInterceptor requestInterceptor(){
        return new RequestInterceptor() {
            @Override
            public void apply(RequestTemplate requestTemplate) {
//                使用RequestContextHolder拿到当前请求所用的请求信息
                ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
//                同步请求头的Cookie信息,放到Feign的新请求中
                requestTemplate.header("Cookie",attributes.getRequest().getHeader("Cookie"));
            }
        };
    }
}

package com.alatus.mall.cart.feign;

import com.alatus.common.utils.R;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import java.util.List;

@FeignClient("Mall-product")
public interface ProductFeignService {
    @RequestMapping("/product/skuinfo/info/{skuId}")
    R info(@PathVariable("skuId") Long skuId);
    @GetMapping("/product/skusaleattrvalue/stringlist/{skuId}")
    List<String> getSkuSaleAttrValues(@PathVariable("skuId") Long skuId);
    @GetMapping("/product/skuinfo/{skuId}/price")
    R getPrice(@PathVariable("skuId") Long skuId);
}

package com.alatus.mall.cart.feign;

import com.alatus.common.utils.R;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import java.util.List;

@FeignClient("Mall-product")
public interface ProductFeignService {
    @RequestMapping("/product/skuinfo/info/{skuId}")
    R info(@PathVariable("skuId") Long skuId);
    @GetMapping("/product/skusaleattrvalue/stringlist/{skuId}")
    List<String> getSkuSaleAttrValues(@PathVariable("skuId") Long skuId);
    @GetMapping("/product/skuinfo/{skuId}/price")
    R getPrice(@PathVariable("skuId") Long skuId);
}
旧约Alatus
关注
专栏目录
谷粒商城二十一订单服务分布式事务----RabbitMQ最终一致性
梦想是很难很难的，所以先勇敢一点
04-06 1078
假设我们订单服务是成功的，在调用库存服务的时候，出现了假失败的情况，例如服务器故障、超时等原因，库存锁成功并且库存服务事务提交了之后，一直没有给订单服务返回，远程调用有一个超时机制，远程调用会抛一个类似readTimeout的异常，就会出现一个问题，如果是远程调用的库存服务出异常，首先库存服务自己会回滚，订单服务会在库存服务调用完成之后获取返回的锁库存的结果，得知发生了异常，订单服务也会抛异常，那么订单服务也会回滚。举个例子，订单服务的执行流程是，订单服务的逻辑、远程调用库存服务、远程调用优惠券服务。
谷粒商城项目篇13_分布式高级篇_订单业务模块(提交订单幂等性、分布式事务、延时MQ实现定时任务)
xiaosi的博客
08-24 3665
目录 订单业务模块 一、订单业务模块 概述 电商系统涉及到 3 流，分别时信息流，资金流，物流，而订单系统作为中枢将三者有机的集 合起来。 订单模块是电商系统的枢纽，在订单这个环节上需求获取多个模块的数据和信息，同时对这 些信息进行加工处理后流向下个环节，这一系列就构成了订单的信息流通 1.订单流程 不管类型如何订单都包括正向流程和逆向流程，对应的场景就是购买商品和退换货流程，正 向流程就是一个正常的网购步骤：订单生成–>支付订单–>卖家发货–>确认收货–>交易成功。 而每
Java后端真实面试题大全(有详细答案)--高频/真题
热门推荐
IT利刃出鞘的博客
11-24 14万+
本文分享Java后端真实高频面试题，有详细答案，保你稳过面试。题目包括：Java基础、多线程、JVM、数据库、Redis、Shiro、Spring、SpringBoot、MyBatis、MQ、ELK、SpringCloud、设计模式等。 本博客包含从简单到困难、从高频到低频的题目，适合所有Java求职者，包括：刚入门的、三年以内经验、三到五年经验、五到十年经验等。
分布式项目-谷粒商城。
weixin_53417222的博客
10-16 8592
分布式
谷粒商城--订单服务--高级篇笔记十一
qq_31745863的博客
03-18 5713
1.页面环境搭建 1.1 静态资源导入nginx 等待付款 --------->detail 订单页 --------->list 结算页 --------->confirm 收银页 ---------> pay 1.2 配置host # gulimall 192.168.157.128 gulimall.com # search 192.168.157.128 search.gulimall.com # item 商品详情 192.168.157.128 item.guli
粒商城项目总结(二)-高级篇
qq_40811542的博客
04-10 1081
P102-P127ES使用 九.业务代码：商品上架 P128.sku在es中存储模型分析 商品信息上架到Es中进行检索。 P129.nested嵌入式数据模型处理 130.构建基本数据 传递商品上架Id到后端，后端查询数据上传到es中。 P131.构建sku检索属性 sku的销售规格属性的集合 P132.远程查询库存，泛型结果进行封装 库存量等于总库存量减去锁定库存量； P133远程上架接口 调用远程接口实现添加sku数据 P134上架接口调试，feign源码 十、前端thymeleaf、n
经验整理-1-dubbo-zookeeper-RPC-100-@
qq_15458763的博客
09-02 1253
-------------------RPC------------ ？RPC接口与HTTP接口相比，有什么优势？ HTTP协议，需要带HTTP请求头，导致传输起来效率或者说安全性不如RPC，特别是微服务里业务请求十分频繁的情况下不适合； 首先就是长链接减少3次握手，不必每次通信都要像http 一样去3次握手什么的，减少了网络开销 其次就是RPC框架一般都有注册中心，具有SOA服务治理，，有丰...
某个订单项目记录，涉及MQ消息处理、分布式问题、幂等性等问题解决设计
探索技术与实践的旅程，分享编程经验与工具使用心得，助力开发者提升技能。
11-16 1526
在电商订单中心等场景中，使用消息队列可以解决登录拦截、接口幂等性、分布式事务等问题。同时，需要注意消息队列可能会出现的消息积压、丢失、重复等问题，并采取相应的解决方案。此外，还有分布式事务问题解决，最大消息通知事务等等相关架构设计。
谷粒商城-高级篇-aiueo
qq_40780198的博客
02-19 2663
105 初步检索 105.1 _cat GET /_cat/nodes : 查看所有节点 GET /_cat/health : 查看es健康状况 GET /_cat/master : 查看主节点 GET /_cat/indices: 查看所有索引 107 乐观锁字段 _seq_no :并发控制字段 , 每次更新就会 + 1 , 用来做乐观锁 _primary_term : 同上,主分片重新分配 , 如重启 , 就会变化. 107.1 并发修改 发送两次修改同时对同一文档进行修改 , 为了控
商城-文档
weixin_46925850的博客
07-28 7930
谷粒商城学习笔记
谷粒商城关键技术总结-复习必备
qq_42762496的博客
05-20 3418
配置、注册中心nacos 网关 抽取各服务的鉴权、限流】日志输出 跨域 跨域 指的是浏览器不能执行其他网站的脚本。它是由浏览器的同源策略造成的，是浏览器对javascript施加的安全限制。 同源策略：是指协议，域名，端口都要相同，其中有一个不同都会产生跨域； 跨域流程 非简单请求(PUT,DELETE)等，需要先发送预检请求 预检请求，OPTIONS 响应允许跨域 发送真实请求 响应数据 解决跨域 使用nginx部署为同一域 配置当次请求允许跨域 在网关服务的配置类添加跨域配置 添加响应头
Mall4j商城实战 - 功能分析
yueerba126的博客
11-21 318
spring-aop。
谷粒商城-高级篇
xiang_yu_pai的博客
08-28 2072
谷粒商城上架商品新的改变 上架商品 上架商品：为了让前台可以看到商品，购买商品。 查询商品：前台查询商品主要是从es查询到的。 后台上架商品主要是传入一个spuId,通过这个spuId去查询sku相关信息，再将所有的商品上架 1、查出当前spuId对应的所有sku信息,品牌的名字 2、封装每个sku的信息 （1、发送远程调用，库存系统查询是否有库存 2、热度评分。0 3、查询品牌和分类的名字信息 4、查出当前sku的所有可以被用来检索的规格属性） 3、将数据发给es进行保存：gulimall-search
谷粒商城项目搭建思路
super_song的博客
06-21 2042
文章目录1. 基础篇核心技术点1.1 搭建环境2.高级篇核心技术点3. 集群篇 1. 基础篇 核心技术点 微服务基础开发： 逆向工程、微服务基础开发 SpringBoot、Mybatis、MybatisPlus、JCR303、Restful Maven、Git、Vagrant、Linux、Docker Aliyun-Oss、MySQL、Redis ES6、Vue、element-ui 目标：从0开始做一个合格的小全栈程序员 1.1 搭建环境 使用VirtualBox搭建虚拟机环境，需要设置cpu 2.高
MybatisPlus的LambdaQueryWrapper用法
2301_79693537的博客
08-21 5365
【代码】MybatisPlus的LambdaQueryWrapper用法。
Java项目实战II基于Java+Spring Boot+MySQL的智能物流管理系统（文档+源码+数据库）
2401_86524610的博客
09-29 625
随着电子商务的蓬勃发展，物流行业迎来了前所未有的挑战与机遇。传统物流管理方式在应对海量订单、复杂配送网络及实时追踪需求时显得力不从心。因此，开发一套基于Java+Spring Boot+MySQL的智能物流管理系统成为提升物流效率、优化客户体验的关键。本系统通过集成先进的信息技术，实现物流信息的自动化采集、智能分析、实时追踪与高效调度，旨在打造一个透明化、智能化的物流管理体系。
Java项目实战II基于Java+Spring Boot+MySQL的免税商品优选购物商城(源码+数据库+文档)
2401_86524610的博客
09-30 1530
随着全球贸易的日益繁荣和消费者需求的多样化，免税商品购物已成为众多旅行者和消费者的热门选择。为了提供一个更加便捷、高效且优质的免税商品购物体验，我们精心打造了一款基于Java、Spring Boot和MySQL的免税商品优选购物商城系统。本系统充分利用Java语言的稳定性和Spring Boot框架的灵活性，结合MySQL数据库的高效存储能力，旨在为用户打造一个功能全面、操作简便的在线购物平台。通过系统的智能化推荐和详尽的商品信息展示，用户能够轻松浏览并选购心仪的免税商品，享受前所未有的购物乐趣。
Spring Boot项目中使用MyBatis
最新发布
weixin_73060959的博客
10-02 655
在Spring Boot项目中使用MyBatis可以极大地简化配置过程，并且Spring Boot提供了很好的集成支持。你只需要添加必要的依赖，配置数据源，然后创建Mapper接口、XML映射文件和实体类，就可以轻松地进行数据库操作了。
在Spring Cloud项目中，我创建了feign-api模块，其他的模块如何通过添加maven依赖的方式调用feign-api
07-14
在Spring Cloud项目中，通过添加Maven依赖的方式调用feign-api模块需要进行以下步骤： 1. 在其他模块的pom.xml文件中添加feign-api模块的依赖。在dependencies标签中添加以下内容： ```xml <dependency> <groupId>com.example</groupId> <!-- 替换为feign-api模块的groupId --> <artifactId>feign-api</artifactId> <!-- 替换为feign-api模块的artifactId --> <version>1.0.0</version> <!-- 替换为feign-api模块的版本号 --> </dependency> ``` 2. 确保其他模块的pom.xml文件中已经添加了Spring Cloud相关依赖，以支持Feign。 3. 在其他模块中的Java类中使用@Autowired注解注入feign-api模块中的接口。例如： ```java @Autowired private FeignApiService feignApiService; ``` 4. 然后就可以在其他模块的代码中使用feignApiService调用feign-api模块中定义的接口方法了。 请注意，以上步骤假设你已经在feign-api模块中定义了Feign接口并提供了具体的实现。如果还没有定义Feign接口，请先创建并定义相关接口。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值