springcloud开Product服务

1.主类

SpringBootApplication
@EnableDiscoveryClient
public class ProductServerApplication {

    public static void main(String[] args) {
        SpringApplication.run(ProductServerApplication.class, args);
    }

}

 /**
     * 1.查询所有在架的商品
     * 2.获取类目type列表
     * 3.查询类目
     * 4.构造数据
     */

2.前端多需格式

{
    "code": 10000,
    "msg": "成功",
    "data": [
        {
            "productInfoList": [
                {
                    "id": 1,
                    "name": "皮蛋粥",
                    "price": 34.5,
                    "Stock": 40,
                    "description": "好吃哦",
                    "icon": "http://111.jpa",
                    "status": 0,
                    "type": 11
                }
            ],
            "name": "热榜",
            "type": 11
        },
        {
            "productInfoList": [
                {
                    "id": 2,
                    "name": "豆腐",
                    "price": 4.3,
                    "Stock": 30,
                    "description": "很软",
                    "icon": "http",
                    "status": 0,
                    "type": 22
                }
            ],
            "name": "好吃的",
            "type": 22
        }
    ]
}

3.自己依据情况构建几个用于返回的对象

package com.zhu.product.utill;

import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.Data;

import java.util.List;

/**
 *封装外层对象
 */
@Data
public class ProductVo {


    /**
     * 返回前端加此注解 为前端需要字段
     */
    @JsonProperty("name")
    private String cacategoryName;
    @JsonProperty("type")
    private Integer categoryType;
    /**
     * List里面再封装一个对象
     */
    private List<ProductInfoVo> ProductInfoList;

}

package com.zhu.product.utill;

import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.Data;

import java.math.BigDecimal;

@Data
public class ProductInfoVo {
    @JsonProperty("id")
    private Integer productId;
    @JsonProperty("name")
    private String productName;
    @JsonProperty("price")
    private BigDecimal productPrice;
    /**
     * 库存
     */
    @JsonProperty("Stock")
    private Integer productStock;
    @JsonProperty("description")
    private String productDescription;
    /**
     * 小图
     */
    @JsonProperty("icon")
    private String productIcon;
    /**
     * 商品状态 0正常 1 下架
     */
    @JsonProperty("status")
    private Integer productStatus;
    /**
     * 类目编号
     */
    @JsonProperty("type")
    private Integer categoryType;

}

4.实体类：商品表，类目表

package com.zhu.product.entity;

import com.baomidou.mybatisplus.annotations.TableId;
import com.baomidou.mybatisplus.enums.IdType;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;

import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Date;

/**
 * <p>
 * 
 * </p>
 *
 * @author pacey
 * @since 2019-01-15
 */
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
public class ProductInfo implements Serializable {

    private static final long serialVersionUID = 1L;

    @TableId(value = "product_id", type = IdType.AUTO)
    private Integer productId;
    private String productName;
    private BigDecimal productPrice;
    /**
     * 库存
     */
    private Integer productStock;
    private String productDescription;
    /**
     * 小图
     */
    private String productIcon;
    /**
     * 商品状态 0正常 1 下架
     */
    private Integer productStatus;
    /**
     * 类目编号
     */
    private Integer categoryType;
    /**
     * 创建时间
     */
    private Date createTime;


}

    package com.zhu.product.entity;

import com.baomidou.mybatisplus.annotations.TableId;
import com.baomidou.mybatisplus.enums.IdType;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;

import java.io.Serializable;
import java.util.Date;

/**
 * <p>
 * 
 * </p>
 *
 * @author pacey
 * @since 2019-01-15
 */
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
public class ProductCategory implements Serializable {

    private static final long serialVersionUID = 1L;

    @TableId(value = "category_id", type = IdType.AUTO)
    private Integer categoryId;
    /**
     * 类目名字
     */
    private String categoryName;
    /**
     * 类目编号
     */
    private Integer categoryType;
    /**
     * 创建时间
     */
    private Date createTime;


}

5.coutroller

   List<Integer> typeList= new ArrayList<>();
    @GetMapping
    public Result getProductIndoByStatus()
    {

        //1.查询所有在架的商品
        List<ProductInfo> productInfoList=iProductInfoService.selectList(new EntityWrapper<ProductInfo>().eq("product_status", StatusEnum.UP));

        Integer type;

        for (ProductInfo list :productInfoList)
        {

            type=list.getCategoryType();
            //2.获取类目type列表
            typeList.add(type);
            System.out.println("11"+type);
        }
        for (Integer i:typeList)
        {
            System.out.println("x:"+i);
        }
         // 3.查询类目
        List<ProductCategory> productCategoryList =iProductCategoryService.selectList(new EntityWrapper<ProductCategory>().in("category_type",typeList));
                   //4.构造数据
        List<ProductVo> categoryinfo= new ArrayList<>();

        //遍历类目
         for (ProductCategory list:productCategoryList){
             ProductVo productVo =new ProductVo();
             productVo.setCacategoryName(list.getCategoryName());
             productVo.setCategoryType(list.getCategoryType());
             //便利商品表 获取商品信息
             List<ProductInfoVo> productInfo =new ArrayList<>();
             for(ProductInfo list1:productInfoList){
                 if(list1.getCategoryType().equals(list.getCategoryType())) {
                     ProductInfoVo productInfoVo = new ProductInfoVo();
                     //使用BeanUtils.copyProperties(,)把原对象的内容拷贝到新对象中去
                     BeanUtils.copyProperties(list1, productInfoVo);
                     productInfo.add(productInfoVo);
                 }
             }
             productVo.setProductInfoList(productInfo);
             categoryinfo.add(productVo);
         }

                    return ResultUtil.success(categoryinfo);
    }

6.下单服务：

/**
          1.参数校验
         * 2.查询商品信息（调用商品服务）
         * 3.计算总价
         * 4.扣库存（调用商品服务）
         * 5.订单入库
         */

1）商品信息（Product服务）

/**
     * 根据proudctid 多个查询商品信息 共订单服务调用
     */
    @PostMapping("/ListForOrder")
    public List<ProductInfos> ListForOrder(@RequestBody List<Integer> productIdList){
        log.info("参数："+productIdList);
        List<ProductInfos> list=new ArrayList<>();
      log.info("productIdList:"+productIdList);
        List<ProductInfo> productInfo =iProductInfoService.selectList(new EntityWrapper<ProductInfo>().in("product_id",productIdList));
          for (ProductInfo productInfo1 :productInfo)
          {
              log.info("PRODUCT-------------"+productInfo1.getProductName());
              ProductInfos productInfos =new ProductInfos();
              //左复制到右
              BeanUtils.copyProperties(productInfo1,productInfos);
              list.add(productInfos);
          }

          for (ProductInfos productInfos:list)
          {
              System.out.println("----"+productInfos.getProductName());
          }


        return list;

    }

2）：扣库存（商品服务）

/**
     * 扣库存 给订单服务调用
     */
    @PostMapping("/koukucun")
    @Transactional(rollbackFor=Exception.class)
    public void kouKuCun(@RequestBody List<CartDto> cartDtoList)
    {
       //检查库存够不够
        for (CartDto cartDto1:cartDtoList)
        {
            ProductInfo productInfo=iProductInfoService.selectById(cartDto1.getProductId());
            //判断商品是否存在
            if(null==productInfo)
            {
                //商品不存在
                throw new ProductException(ResultEnum.PRODUCT_NOT_EXIST);
            }
             Integer result= productInfo.getProductStock()-cartDto1.getProductShuliang();
            //判断库存是否足够
            if (result<0)
            {
                //库存不足
                throw new ProductException(ResultEnum.KUCUN_NOT_EHIGHT);
            }
            //把扣完的数量 修改到数据库
            productInfo.setProductId(cartDto1.getProductId());
            productInfo.setProductStock(result);
               //修改数据库 完成扣库存
            Boolean is= iProductInfoService.updateById(productInfo);
            if(is)
            {
                log.info("扣库存成功");
            }
            else
            {
                log.info("扣库存失败");
            }

        }
    }

3）：写异常类

package com.zhu.product.exception;

import com.zhu.product.enums.ResultEnum;

public class ProductException extends RuntimeException {

    private Integer code;

    public ProductException(Integer code,String message)
    {
        super(message);
        this.code=code;
    }
    public ProductException(ResultEnum resultEnum)
    {
        super(resultEnum.getMsg());
        this.code=resultEnum.getCode();
    }
}

4）:定义异常里的枚举

package com.zhu.product.enums;

import lombok.Getter;

/**
 *2. 然后构建一个常用的枚举类，内容可以根据项目自定义
 */
@Getter
public enum ResultEnum {
    //这里是可以自己定义的，方便与前端交互即可
    PRODUCT_NOT_EXIST(1,"商品不存在"),
    KUCUN_NOT_EHIGHT(2,"库存不足"),
    ;
    private Integer code;
    private String msg;

    ResultEnum(Integer code, String msg) {
        this.code = code;
        this.msg = msg;
    }


}

5：）下单（计算总价+订单主表/订单详情入库）

package com.zhu.order.service.impl;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.google.common.reflect.TypeToken;
import com.google.gson.Gson;
import com.zhu.order.dao.OrderDetailMapper;
import com.zhu.order.dto.OrderDto;
import com.zhu.order.entity.*;
import com.zhu.order.dao.OrderMasterMapper;
import com.zhu.order.enums.OrderPayStatusEnum;
import com.zhu.order.enums.OrderStatusEnum;
import com.zhu.order.service.IOrderMasterService;
import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import com.zhu.order.utills.OrderId;
import lombok.extern.log4j.Log4j;
import org.json.JSONArray;
import org.json.JSONObject;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

import javax.xml.ws.soap.Addressing;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/**
 * <p>
 *  服务实现类
 * </p>
 *
 * @author zhu
 * @since 2019-01-16
 */
@Log4j
@Service
public class OrderMasterServiceImpl extends ServiceImpl<OrderMasterMapper, OrderMaster> implements IOrderMasterService {

    @Autowired
    private OrderMasterMapper orderMasterMapper;
    @Autowired
    private OrderDetailMapper orderDetailMapper;
    @Autowired
    private RestTemplate restTemplate;

    @Override
    public OrderDto create(OrderDto orderDto) {
        //订单id
        String orderid =OrderId.getOrderId();

        /**
         * 2.查询商品信息（调用商品服务）
         * 3.计算总价
         * 4.扣库存（调用商品服务）
         * 5.订单入库
         */

        //2.查询商品信息（调用商品服务）
        //获取所有productid 使用了lomda表达式
        List<Integer> productIdList= orderDto.getOrderDetailList().stream().map(OrderDetail::getProductId).collect(Collectors.toList());
         log.info("所有productid:"+productIdList);
        List<ProductInfos> response= restTemplate.postForObject("http://PRODUCT/productInfo/ListForOrder", productIdList,List.class);
        log.info("response:"+response );
        //用到了谷歌的Gson 用于反序列化 不然List转对象报错
        Gson gson =new Gson();
        String json=gson.toJson(response);
        List<ProductInfos> response1=gson.fromJson(json,new TypeToken<List<ProductInfos>>(){}.getType());

        //3.计算总价
        //定义总价
        BigDecimal zongjia =new BigDecimal(BigInteger.ZERO);
        //遍历订单详情表
        for(OrderDetail orderDetail:orderDto.getOrderDetailList()){
            for (ProductInfos productInfo:response1)
            {
                log.info("价格0:"+productInfo.getProductPrice());
                //相等才计算
              if(productInfo.getProductId().equals(orderDetail.getProductId()))
              {
                  //单价*数量  ++
                  zongjia=  productInfo.getProductPrice().multiply(new BigDecimal(orderDetail.getProductShuliang())).add(zongjia);
                  orderDetail.setProductPrise(productInfo.getProductPrice());
                  orderDetail.setProductName(productInfo.getProductName());
                  orderDetail.setProductShuliang(orderDetail.getProductShuliang());
                  orderDetail.setOrderId(orderid);
                  orderDetail.setDetailId(OrderId.getOrderId());
                   log.info("价格:"+orderDetail.getProductPrise());
                  //订单详情入库
                  orderDetailMapper.insert(orderDetail);

              }
            }

        }

        //4.扣库存（调用商品服务）
          //要获取到productid 和数量的 集合 List
         List<CartDto> cartDto= orderDto.getOrderDetailList().stream().map(e -> new CartDto(e.getProductId(),e.getProductShuliang())).collect(Collectors.toList());

       log.info("cartDto:"+cartDto);
        restTemplate.postForObject("http://PRODUCT/productInfo/koukucun",cartDto,List.class);

        //5.订单入库
        OrderMaster orderMaster =new OrderMaster();
        //订单
        orderMaster.setOrderId(orderid);
         //用拷贝的方法 把传进来的参数拷贝到orderMaster
        BeanUtils.copyProperties(orderDto,orderMaster);
        //总价
        orderMaster.setOrderAmount(new BigDecimal(6));
        //订单状态
        orderMaster.setOrderStatus(OrderStatusEnum.NEW.getCode());
        //支付状态
        orderMaster.setPayStaus(OrderPayStatusEnum.WAIT.getCode());

        //订单主库入库
        orderMasterMapper.insert(orderMaster);
        log.info("下单完成");
        return orderDto;
    }
}