//输入：orderNo订单号 userId从session中获取的用户id path二维码的上传路径文件夹
//输出：得到一个responseService，其中的data类型是Map<String ,String> resultMap 其中保存这订单号和ftp服务器中的二维码路径
public ServerResponse pay(Long orderNo,Integer userId,String path){
    //responseService中的data
    Map<String ,String> resultMap = Maps.newHashMap();
    //验证orderNo并放入resultMap中
    Order order = orderMapper.selectByUserIdAndOrderNo(userId,orderNo);
    if(order == null){
        return ServerResponse.createByErrorMessage("用户没有该订单");
    }
    resultMap.put("orderNo",String.valueOf(order.getOrderNo()));

    /*
        下面这段是从alipay的demo中摘抄的内容：
        我们做了以下工作：
        1.拼凑请求alipay服务器的各种参数
        2.创建扫码支付请求builder，设置请求参数
        3.对alipay进行访问，然后取得返回结果
    */

    // (必填) 商户网站订单系统中唯一订单号，64个字符以内，只能包含字母、数字、下划线，
    // 需保证商户系统端不能重复，建议通过数据库sequence生成，
    String outTradeNo = order.getOrderNo().toString();

    // (必填) 订单标题，粗略描述用户的支付目的。如“xxx品牌xxx门店当面付扫码消费”
    String subject = new StringBuilder().append("happymmall扫码支付,订单号:").append(outTradeNo).toString();

    // (必填) 订单总金额，单位为元，不能超过1亿元
    // 如果同时传入了【打折金额】,【不可打折金额】,【订单总金额】三者,则必须满足如下条件:【订单总金额】=【打折金额】+【不可打折金额】
    String totalAmount = order.getPayment().toString();

    // (可选) 订单不可打折金额，可以配合商家平台配置折扣活动，如果酒水不参与打折，则将对应金额填写至此字段
    // 如果该值未传入,但传入了【订单总金额】,【打折金额】,则该值默认为【订单总金额】-【打折金额】
    String undiscountableAmount = "0";

    // 卖家支付宝账号ID，用于支持一个签约账号下支持打款到不同的收款账号，(打款到sellerId对应的支付宝账号)
    // 如果该字段为空，则默认为与支付宝签约的商户的PID，也就是appid对应的PID
    String sellerId = "";

    // 订单描述，可以对交易或商品进行一个详细地描述，比如填写"购买商品2件共15.00元"
    String body = new StringBuilder().append("订单").append(outTradeNo).append("购买商品共").append(totalAmount).append("元").toString();

    // 商户操作员编号，添加此参数可以为商户操作员做销售统计
    String operatorId = "test_operator_id";

    // (必填) 商户门店编号，通过门店号和商家后台可以配置精准到门店的折扣信息，详询支付宝技术支持
    String storeId = "test_store_id";

    // 业务扩展参数，目前可添加由支付宝分配的系统商编号(通过setSysServiceProviderId方法)，详情请咨询支付宝技术支持
    ExtendParams extendParams = new ExtendParams();
    extendParams.setSysServiceProviderId("2088100200300400500");

    // 支付超时，定义为120分钟
    String timeoutExpress = "120m";

    // 商品明细列表，需填写购买商品详细信息，
    List<GoodsDetail> goodsDetailList = new ArrayList<GoodsDetail>();

    List<OrderItem> orderItemList = orderItemMapper.getByOrderNoUserId(orderNo,userId);
    for(OrderItem orderItem : orderItemList){
        GoodsDetail goods = GoodsDetail.newInstance(orderItem.getProductId().toString(), orderItem.getProductName(),
                BigDecimalUtil.mul(orderItem.getCurrentUnitPrice().doubleValue(),new Double(100).doubleValue()).longValue(),
                orderItem.getQuantity());
        goodsDetailList.add(goods);
    }

    // 创建扫码支付请求builder，设置请求参数
    AlipayTradePrecreateRequestBuilder builder = new AlipayTradePrecreateRequestBuilder()
            .setSubject(subject).setTotalAmount(totalAmount).setOutTradeNo(outTradeNo)
            .setUndiscountableAmount(undiscountableAmount).setSellerId(sellerId).setBody(body)
            .setOperatorId(operatorId).setStoreId(storeId).setExtendParams(extendParams)
            .setTimeoutExpress(timeoutExpress)
            .setNotifyUrl(PropertiesUtil.getProperty("alipay.callback.url"))//支付宝服务器主动通知商户服务器里指定的页面http路径,根据需要设置
            .setGoodsDetailList(goodsDetailList);

    //对alipay进行访问，然后取得返回结果
    AlipayF2FPrecreateResult result = tradeService.tradePrecreate(builder);
    switch (result.getTradeStatus()) {
        case SUCCESS:
            logger.info("支付宝预下单成功: )");

            AlipayTradePrecreateResponse response = result.getResponse();
            dumpResponse(response);

            File folder = new File(path);
            if(!folder.exists()){
                folder.setWritable(true);
                folder.mkdirs();
            }

            //需要修改为运行机器上的路径
            //细节细节细节
            String qrPath = String.format(path+"/qr-%s.png",response.getOutTradeNo());
            String qrFileName = String.format("qr-%s.png",response.getOutTradeNo());
            ZxingUtils.getQRCodeImge(response.getQrCode(), 256, qrPath);
	//上一句将二维码就已经将二维码保存到path位置了，名字也有了，那么现在我们用path+ qrFileName就可以将这个文件取出来保存，然后通过FTP工具类上传到FTP中去
            File targetFile = new File(path,qrFileName);
            try {
                FTPUtil.uploadFile(Lists.newArrayList(targetFile));
            } catch (IOException e) {
                logger.error("上传二维码异常",e);
            }
            logger.info("qrPath:" + qrPath);
            String qrUrl = PropertiesUtil.getProperty("ftp.server.http.prefix")+targetFile.getName();
            resultMap.put("qrUrl",qrUrl);
            return ServerResponse.createBySuccess(resultMap);
        case FAILED:
            logger.error("支付宝预下单失败!!!");
            return ServerResponse.createByErrorMessage("支付宝预下单失败!!!");

        case UNKNOWN:
            logger.error("系统异常，预下单状态未知!!!");
            return ServerResponse.createByErrorMessage("系统异常，预下单状态未知!!!");

        default:
            logger.error("不支持的交易状态，交易返回异常!!!");
            return ServerResponse.createByErrorMessage("不支持的交易状态，交易返回异常!!!");
    }
}

// 简单打印应答
private void dumpResponse(AlipayResponse response) {
    if (response != null) {
        logger.info(String.format("code:%s, msg:%s", response.getCode(), response.getMsg()));
        if (StringUtils.isNotEmpty(response.getSubCode())) {
            logger.info(String.format("subCode:%s, subMsg:%s", response.getSubCode(),
                    response.getSubMsg()));
        }
        logger.info("body:" + response.getBody());
    }
}

//在这个函数中处理了：过虑重复通知 然后将payinfo数据表需要的数据保存在payinfo中，插入到数据库中
public ServerResponse aliCallback(Map<String,String> params){
    Long orderNo = Long.parseLong(params.get("out_trade_no"));
    String tradeNo = params.get("trade_no");
    String tradeStatus = params.get("trade_status");
    Order order = orderMapper.selectByOrderNo(orderNo);
    if(order == null){
        return ServerResponse.createByErrorMessage("非快乐慕商城的订单,回调忽略");
    }
    if(order.getStatus() >= Const.OrderStatusEnum.PAID.getCode()){
        return ServerResponse.createBySuccess("支付宝重复调用");
    }
    if(Const.AlipayCallback.TRADE_STATUS_TRADE_SUCCESS.equals(tradeStatus)){
        order.setPaymentTime(DateTimeUtil.strToDate(params.get("gmt_payment")));
        order.setStatus(Const.OrderStatusEnum.PAID.getCode());
        orderMapper.updateByPrimaryKeySelective(order);
    }

    PayInfo payInfo = new PayInfo();
    payInfo.setUserId(order.getUserId());
    payInfo.setOrderNo(order.getOrderNo());
    payInfo.setPayPlatform(Const.PayPlatformEnum.ALIPAY.getCode());
    payInfo.setPlatformNumber(tradeNo);
    payInfo.setPlatformStatus(tradeStatus);

    payInfoMapper.insert(payInfo);

    return ServerResponse.createBySuccess();
}


public ServerResponse queryOrderPayStatus(Integer userId,Long orderNo){
    Order order = orderMapper.selectByUserIdAndOrderNo(userId,orderNo);
    if(order == null){
        return ServerResponse.createByErrorMessage("用户没有该订单");
    }
    if(order.getStatus() >= Const.OrderStatusEnum.PAID.getCode()){
        return ServerResponse.createBySuccess();
    }
    return ServerResponse.createByError();
}

package com.mmall.service.impl;

import com.google.common.collect.Lists;
import com.mmall.service.IFileService;
import com.mmall.util.FTPUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.io.IOException;
import java.util.UUID;

/**
 * Created by geely
 */
@Service("iFileService")
public class FileServiceImpl implements IFileService {
    private Logger logger = LoggerFactory.getLogger(FileServiceImpl.class);

    public String upload(MultipartFile file,String path){
        String fileName = file.getOriginalFilename();
        //扩展名
        //abc.jpg
        String fileExtensionName = fileName.substring(fileName.lastIndexOf(".")+1);
        String uploadFileName = UUID.randomUUID().toString()+"."+fileExtensionName;
        logger.info("开始上传文件,上传文件的文件名:{},上传的路径:{},新文件名:{}",fileName,path,uploadFileName);

        File fileDir = new File(path);
        if(!fileDir.exists()){
            fileDir.setWritable(true);
            fileDir.mkdirs();
        }
        File targetFile = new File(path,uploadFileName);

        try {
            file.transferTo(targetFile);
            //文件已经上传成功了
            FTPUtil.uploadFile(Lists.newArrayList(targetFile));
            //已经上传到ftp服务器上

            targetFile.delete();
        } catch (IOException e) {
            logger.error("上传文件异常",e);
            return null;
        }
        //A:abc.jpg
        //B:abc.jpg
        return targetFile.getName();
    }
}

package com.mmall.util;

import org.apache.commons.net.ftp.FTPClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.List;

/**
 * Created by geely
 */
public class FTPUtil {

    private static  final Logger logger = LoggerFactory.getLogger(FTPUtil.class);

    private static String ftpIp = PropertiesUtil.getProperty("ftp.server.ip");
    private static String ftpUser = PropertiesUtil.getProperty("ftp.user");
    private static String ftpPass = PropertiesUtil.getProperty("ftp.pass");

    public FTPUtil(String ip,int port,String user,String pwd){
        this.ip = ip;
        this.port = port;
        this.user = user;
        this.pwd = pwd;
    }
    public static boolean uploadFile(List<File> fileList) throws IOException {
        FTPUtil ftpUtil = new FTPUtil(ftpIp,21,ftpUser,ftpPass);
        logger.info("开始连接ftp服务器");
        boolean result = ftpUtil.uploadFile("img",fileList);
        logger.info("开始连接ftp服务器,结束上传,上传结果:{}");
        return result;
    }


    private boolean uploadFile(String remotePath,List<File> fileList) throws IOException {
        boolean uploaded = true;
        FileInputStream fis = null;
        //连接FTP服务器
        if(connectServer(this.ip,this.port,this.user,this.pwd)){
            try {
                ftpClient.changeWorkingDirectory(remotePath);
                ftpClient.setBufferSize(1024);
                ftpClient.setControlEncoding("UTF-8");
                ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);
                ftpClient.enterLocalPassiveMode();
                for(File fileItem : fileList){
                    fis = new FileInputStream(fileItem);
                    ftpClient.storeFile(fileItem.getName(),fis);
                }

            } catch (IOException e) {
                logger.error("上传文件异常",e);
                uploaded = false;
                e.printStackTrace();
            } finally {
                fis.close();
                ftpClient.disconnect();
            }
        }
        return uploaded;
    }



    private boolean connectServer(String ip,int port,String user,String pwd){

        boolean isSuccess = false;
        ftpClient = new FTPClient();
        try {
            ftpClient.connect(ip);
            isSuccess = ftpClient.login(user,pwd);
        } catch (IOException e) {
            logger.error("连接FTP服务器异常",e);
        }
        return isSuccess;
    }


    

    private String ip;
    private int port;
    private String user;
    private String pwd;
    private FTPClient ftpClient;

    public String getIp() {
        return ip;
    }

    public void setIp(String ip) {
        this.ip = ip;
    }

    public int getPort() {
        return port;
    }

    public void setPort(int port) {
        this.port = port;
    }

    public String getUser() {
        return user;
    }

    public void setUser(String user) {
        this.user = user;
    }

    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }

    public FTPClient getFtpClient() {
        return ftpClient;
    }

    public void setFtpClient(FTPClient ftpClient) {
        this.ftpClient = ftpClient;
    }
}

//概述：将cartList加工到cartProductVoList。从cartProductVoList.add(cartProductVo);这话就可以看出来
      if(CollectionUtils.isNotEmpty(cartList)){
          for(Cart cartItem : cartList){
              CartProductVo cartProductVo = new CartProductVo();
              cartProductVo.setId(cartItem.getId());
              cartProductVo.setUserId(userId);
              cartProductVo.setProductId(cartItem.getProductId());

              Product product = productMapper.selectByPrimaryKey(cartItem.getProductId());
              if(product != null){
                  cartProductVo.setProductMainImage(product.getMainImage());
                  cartProductVo.setProductName(product.getName());
                  cartProductVo.setProductSubtitle(product.getSubtitle());
                  cartProductVo.setProductStatus(product.getStatus());
                  cartProductVo.setProductPrice(product.getPrice());
                  cartProductVo.setProductStock(product.getStock());
                  //判断库存
                  int buyLimitCount = 0;
                  if(product.getStock() >= cartItem.getQuantity()){
                      //库存充足的时候
                      buyLimitCount = cartItem.getQuantity();
                      cartProductVo.setLimitQuantity(Const.Cart.LIMIT_NUM_SUCCESS);
                  }else{
                      buyLimitCount = product.getStock();
                      cartProductVo.setLimitQuantity(Const.Cart.LIMIT_NUM_FAIL);
                      //购物车中更新有效库存
                      Cart cartForQuantity = new Cart();
                      cartForQuantity.setId(cartItem.getId());
                      cartForQuantity.setQuantity(buyLimitCount);
                      cartMapper.updateByPrimaryKeySelective(cartForQuantity);
                  }
                  cartProductVo.setQuantity(buyLimitCount);
                  //计算总价
                  cartProductVo.setProductTotalPrice(BigDecimalUtil.mul(product.getPrice().doubleValue(),cartProductVo.getQuantity()));
                  cartProductVo.setProductChecked(cartItem.getChecked());
              }
              if(cartItem.getChecked() == Const.Cart.CHECKED){
                  //如果已经勾选,增加到整个的购物车总价中
                  cartTotalPrice = BigDecimalUtil.add(cartTotalPrice.doubleValue(),cartProductVo.getProductTotalPrice().doubleValue());
              }
              //这句话说明了这个段代码的最终目的
              cartProductVoList.add(cartProductVo);
          }
      }
      //我们上面生成的cartTotalPrice对象是cartVo对象其中的一个变量。并且我们还要在carVo设置一些特有的属性eg总价，是否全选，imagehost的文件名
      cartVo.setCartTotalPrice(cartTotalPrice);
      cartVo.setCartProductVoList(cartProductVoList);
      cartVo.setAllChecked(this.getAllCheckedStatus(userId));
      cartVo.setImageHost(PropertiesUtil.getProperty("ftp.server.http.prefix"));

      return cartVo;
  }

  private boolean getAllCheckedStatus(Integer userId){
      if(userId == null){
          return false;
      }
      return cartMapper.selectCartProductCheckedStatusByUserId(userId) == 0;

  }

package com.mmall.util;

import java.math.BigDecimal;

/**
 * Created by geely
 */
public class BigDecimalUtil {

    private BigDecimalUtil(){

    }


    public static BigDecimal add(double v1,double v2){
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.add(b2);
    }

    public static BigDecimal sub(double v1,double v2){
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.subtract(b2);
    }


    public static BigDecimal mul(double v1,double v2){
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.multiply(b2);
    }

    public static BigDecimal div(double v1,double v2){
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.divide(b2,2,BigDecimal.ROUND_HALF_UP);//四舍五入,保留2位小数

        //除不尽的情况
    }
}