记一次springBoot 自动装载对象为Null的问题

最新推荐文章于 2024-01-15 15:18:07 发布
最新推荐文章于 2024-01-15 15:18:07 发布
阅读量1.5k 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xjk201/article/details/86628929
版权

使用@Autowired和@Resource注解是装载对象碰到了对象是Null的问题：如

userCashLogMapper这个对象为Null;

这是由于spring 的IOC必须层层都由其创建，而我写的其中有个类

public class StrategyPayPathInfo {
    private static final StrategyPayPathInfo obtainStrategyInfo = new StrategyPayPathInfo();

    public static StrategyPayPathInfo getInstance(){
        return obtainStrategyInfo;
    }

    public void getPayPath(int payPath, String orderNo, OrderPay orderPay, OrderInfo orderNew, String refundId, UserInfo userInfo, String loginUserId, OrderInfo orderInfo1, CorpInfo corpInfo1, UserCashLog cashLog){
        AbstractStrategyPayPath strategyInfo = new PayPathFactory().getStrategyInfoClass(String.valueOf(payPath));
         strategyInfo.payPath(payPath,orderNo,orderPay,orderNew,refundId,userInfo,loginUserId,orderInfo1,corpInfo1,cashLog);
    }
}

自己New了两次对象所以导致下面的这个类

public class AlipayPayPath extends AbstractStrategyPayPath

里面自动装载的对象为null

如下解决：

@Component
public class AlipayPayPath extends AbstractStrategyPayPath {

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


    private  static  PaymentClient paymentClient;


    private static RefundInfoMapper refundInfoMapper;


//    @Resource
//    public void setPaymentClient(PaymentClient paymentClient){
//        AlipayPayPath.paymentClient = paymentClient;
//    }
//
//    @Resource
//    public void setRefundInfoMapper(RefundInfoMapper refundInfoMapper){
//        AlipayPayPath.refundInfoMapper = refundInfoMapper;
//    }

    @Autowired
    public void setPaymentClient(PaymentClient paymentClient,RefundInfoMapper refundInfoMapper){
        AlipayPayPath.paymentClient = paymentClient;
        AlipayPayPath.refundInfoMapper = refundInfoMapper;
    }

 

https://blog.csdn.net/xjk201/article/details/86628585

 

private static PaymentClient paymentClient;


private static OrderInfoMapper orderInfoMapper;


private static RefundInfoMapper refundInfoMapper;


private static OrderOperationMapper orderOperationMapper;

private static String platFormSubAcctNo;

private static String platFormTranNetMemberCode;

@Autowired
public void setPaymentClient(PaymentClient paymentClient,RefundInfoMapper refundInfoMapper,OrderInfoMapper orderInfoMapper,OrderOperationMapper orderOperationMapper){
    AbstractStrategyPayPath.paymentClient = paymentClient;
    AbstractStrategyPayPath.refundInfoMapper = refundInfoMapper;
    AbstractStrategyPayPath.orderInfoMapper = orderInfoMapper;
    AbstractStrategyPayPath.orderOperationMapper = orderOperationMapper;
}

@Value("${payment.pingan.platFormSubAcctNo}")
public  void setPlatFormSubAcctNo(String platFormSubAcctNo) {
    AbstractStrategyPayPath.platFormSubAcctNo = platFormSubAcctNo;
}

@Value("${payment.pingan.platFormTranNetMemberCode}")
public  void setPlatFormTranNetMemberCode(String platFormTranNetMemberCode) {
    AbstractStrategyPayPath.platFormTranNetMemberCode = platFormTranNetMemberCode;
}

其中需要value属性的https://blog.csdn.net/xjk201/article/details/86628644

 

对了上面用@Autowired可以一个方法多个参数但是@Resource注解方法只能一个参数不然会报错

或者全部不new对象全部交给spring 管理ioc默认 单例创建如下：

@Component
public class StrategyPayPathInfo {

    @Resource
    private PayPathFactory payPathFactory;

    public void getPayPath(int payPath, String orderNo, OrderPay orderPay, OrderInfo orderNew, String refundId, UserInfo userInfo, String loginUserId, OrderInfo orderInfo1, CorpInfo corpInfo1, UserCashLog cashLog){
        AbstractStrategyPayPath strategyInfo = payPathFactory.getStrategyInfoClass(String.valueOf(payPath));
         strategyInfo.payPath(payPath,orderNo,orderPay,orderNew,refundId,userInfo,loginUserId,orderInfo1,corpInfo1,cashLog);
    }
}

 

@Component
public class PayPathFactory {

    @Resource
    private AlipayPayPath alipayPayPath;

    @Resource
    private WeChatPayPath weChatPayPath;

    private static Map<String, AbstractStrategyPayPath> strategyInfoMap = new HashMap<>();

    private void strategyInfoMap(){
        strategyInfoMap.put(String.valueOf(PayPathEnum.WeChat.getId()), weChatPayPath);
        strategyInfoMap.put(String.valueOf(PayPathEnum.Alipay.getId()), alipayPayPath);
        strategyInfoMap.put(String.valueOf(PayPathEnum.UnionPay.getId()), weChatPayPath);
        strategyInfoMap.put(String.valueOf(PayPathEnum.OfficialAccount.getId()), weChatPayPath);
        strategyInfoMap.put(String.valueOf(PayPathEnum.MiniProgram.getId()), weChatPayPath);
    }
//    static {
//        strategyInfoMap.put(String.valueOf(PayPathEnum.WeChat.getId()), new weChatPayPath);
//        strategyInfoMap.put(String.valueOf(PayPathEnum.Alipay.getId()), new AlipayPayPath());
//        strategyInfoMap.put(String.valueOf(PayPathEnum.UnionPay.getId()), new WeChatPayPath());
//        strategyInfoMap.put(String.valueOf(PayPathEnum.OfficialAccount.getId()), new WeChatPayPath());
//        strategyInfoMap.put(String.valueOf(PayPathEnum.MiniProgram.getId()), new WeChatPayPath());
//    }

    public AbstractStrategyPayPath getStrategyInfoClass(String strategy){
        strategyInfoMap();
        AbstractStrategyPayPath abstractStrategyPayPath = null;
        for(String key : strategyInfoMap.keySet()){
            if(strategy.equals(key)) {
                abstractStrategyPayPath = strategyInfoMap.get(key);
            }
        }
        return abstractStrategyPayPath;
    }
}

 

 

package com.msh.strategy;

import com.alibaba.fastjson.JSONObject;
import com.common.core.base.client.PaymentClient;
import com.common.core.businessenum.RefundStatusEnum;
import com.common.core.constant.TokenConstant;
import com.common.core.frame.Consts;
import com.common.core.util.ErrorCode;
import com.common.core.util.JsonUtil;
import com.common.core.util.UUID;
import com.common.core.util.Utils;
import com.msh.dao.OrderInfoMapper;
import com.msh.dao.OrderOperationMapper;
import com.msh.dao.RefundInfoMapper;
import com.msh.model.*;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.Date;

@Component
public abstract class AbstractStrategyPayPath {

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

    @Resource
    private  PaymentClient paymentClient;

    @Resource
    private  OrderInfoMapper orderInfoMapper;

    @Resource
    private  RefundInfoMapper refundInfoMapper;

    @Resource
    private  OrderOperationMapper orderOperationMapper;

    @Value("${payment.pingan.platFormSubAcctNo}")
    private  String platFormSubAcctNo;

    @Value("${payment.pingan.platFormTranNetMemberCode}")
    private  String platFormTranNetMemberCode;

//    @Autowired
//    public void setPaymentClient(PaymentClient paymentClient,RefundInfoMapper refundInfoMapper,OrderInfoMapper orderInfoMapper,OrderOperationMapper orderOperationMapper){
//        AbstractStrategyPayPath.paymentClient = paymentClient;
//        AbstractStrategyPayPath.refundInfoMapper = refundInfoMapper;
//        AbstractStrategyPayPath.orderInfoMapper = orderInfoMapper;
//        AbstractStrategyPayPath.orderOperationMapper = orderOperationMapper;
//    }

//    @Value("${payment.pingan.platFormSubAcctNo}")
//    public  void setPlatFormSubAcctNo(String platFormSubAcctNo) {
//        AbstractStrategyPayPath.platFormSubAcctNo = platFormSubAcctNo;
//    }
//
//    @Value("${payment.pingan.platFormTranNetMemberCode}")
//    public  void setPlatFormTranNetMemberCode(String platFormTranNetMemberCode) {
//        AbstractStrategyPayPath.platFormTranNetMemberCode = platFormTranNetMemberCode;
//    }

    protected String getplatFormSubAcctNo(){
        return platFormSubAcctNo;
    }

    protected String getplatFormTranNetMemberCode(){
        return platFormTranNetMemberCode;
    }
    /**
     *支付方式
     * @param id
     */
    protected abstract void payPath(int id,String orderNo,OrderPay orderPay,OrderInfo orderNew,String refundId,UserInfo userInfo,String loginUserId,OrderInfo orderInfo1,CorpInfo corpInfo1,UserCashLog cashLog);

    /**
     * 分账
     */
    protected abstract  void subAccount(UserInfo userInfo, OrderPay orderPay, OrderInfo orderInfo1, CorpInfo corpInfo1, OrderInfo orderNew,String refundId,String orderNo,String loginUserId,UserCashLog cashLog);


    //写入退款信息表审核
    protected void refunding(String refundId,String orderNo,String loginUserId ,Integer refundStatus){
        Date now = new Date();
        OrderInfo orderInfo = orderInfoMapper.selectByPrimaryKey(orderNo);
        RefundInfo refund = new RefundInfo();
        refund.setId(refundId);
        refund.setRefundReason(0);
        refund.setRefundMethod(0);
        refund.setOrderNo(orderNo);

        refund.setCreateTime(now);
        refund.setCost(orderInfo.getUserRefundCost());
        if (refundStatus==RefundStatusEnum.REFUNDING.getId()){
            refund.setRefundStatus(RefundStatusEnum.REFUNDING.getId());
        }else {
            refund.setRefundStatus(RefundStatusEnum.REFUNDED.getId());
        }
        refund.setCreateUserId(loginUserId);
        refundInfoMapper.insertSelective(refund);
    }

    protected void insertOrderOperation(int operationType,String operationContent,int operationContentId,String orderNo){
        Date now = new Date();
        OrderOperation completeOrderOperation = new OrderOperation();
        completeOrderOperation.setOperationType(operationType);
        completeOrderOperation.setOperationContent(operationContent);
        completeOrderOperation.setOperationContentId(operationContentId);
        completeOrderOperation.setOrderOperId(UUID.generate());
        completeOrderOperation.setOrderNo(orderNo);
        completeOrderOperation.setCreateTime(now);
        completeOrderOperation.setCreateUserId("admin");
        orderOperationMapper.insert(completeOrderOperation);
    }

    protected void updateRefoundInfo(RefundInfo refundInfo,int refundStatus){
        Date now = new Date();
        RefundInfo refundInfo1 = new RefundInfo();
        refundInfo1.setUpdateTime(now);
        refundInfo1.setUpdateUserId("admin");
        refundInfo1.setRefundStatus(refundStatus);
        refundInfo1.setId(refundInfo.getId());
        refundInfoMapper.updateByPrimaryKeySelective(refundInfo1);
    }

    /**
     * 微信冻洁
     * @param userInfo
     * @param orderNew
     * @param orderPay
     * @param orderNo
     * @param loginUserId
     * @param refundId
     */
    protected void insertMembershipTrancheFreeze(UserInfo userInfo, OrderInfo orderNew, OrderPay orderPay,String orderNo,String loginUserId,String refundId){
        JSONObject freezeParam = new JSONObject();
        freezeParam.put(TokenConstant.TOKEN, TokenConstant.ALLPOWER_TOKEN);
        freezeParam.put("functionFlag", "2");
        freezeParam.put("subAcctNo", userInfo.getCustAcctId());
        freezeParam.put("tranNetMemberCode", userInfo.getUserId());
        freezeParam.put("tranAmt", Utils.formatMoney(orderNew.getUserRefundCost()));
        freezeParam.put("tranCommission", Utils.formatMoney(BigDecimal.ZERO));
        freezeParam.put("orderNo", orderPay.getOutPayId());
        JSONObject result1 = paymentClient.insertMembershipTrancheFreeze(freezeParam);

        if (ErrorCode.SUCCESS != JsonUtil.getJInt(result1, Consts.RESULT, ErrorCode.FAILED)) {
            logger.error(">>>>>>>>>>>>>>解冻失败"+result1);
            //写入退款信息表退款中
            RefundInfo refundInfo = refundInfoMapper.selectByOrderNo(orderNo);
            if(refundInfo==null){
                refunding(refundId,orderNo,loginUserId, RefundStatusEnum.REFUNDING.getId());
            }
        }
    }
}

 

 

 

package com.msh.strategy;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.common.core.base.client.PaymentClient;
import com.common.core.businessenum.*;
import com.common.core.constant.TokenConstant;
import com.common.core.frame.Consts;
import com.common.core.util.*;
import com.msh.dao.RefundInfoMapper;
import com.msh.model.*;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.math.BigDecimal;

@Component
public class AlipayPayPath extends AbstractStrategyPayPath {

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

    @Resource
    private   PaymentClient paymentClient;

    @Resource
    private  RefundInfoMapper refundInfoMapper;


//    @Resource
//    public void setPaymentClient(PaymentClient paymentClient){
//        AlipayPayPath.paymentClient = paymentClient;
//    }
//
//    @Resource
//    public void setRefundInfoMapper(RefundInfoMapper refundInfoMapper){
//        AlipayPayPath.refundInfoMapper = refundInfoMapper;
//    }

//    @Autowired
//    public void setPaymentClient(PaymentClient paymentClient,RefundInfoMapper refundInfoMapper){
//        AlipayPayPath.paymentClient = paymentClient;
//        AlipayPayPath.refundInfoMapper = refundInfoMapper;
//    }


    @Override
    protected void payPath(int id, String orderNo, OrderPay orderPay, OrderInfo orderNew, String refundId, UserInfo userInfo, String loginUserId, OrderInfo orderInfo1, CorpInfo corpInfo1, UserCashLog cashLog) {
        //支付宝分账
        subAccount(userInfo,orderPay,orderInfo1,corpInfo1,orderNew,refundId,orderNo,loginUserId,cashLog);
        //用户退款金额小于0只分账不退款
        if (orderNew.getUserRefundCost().compareTo(BigDecimal.ZERO) <= 0){
            //写入订单操作记录表操作记录表退款成功
            insertOrderOperation(OrderOperationTypeEnum.SYSTEM.getValue(),OrderOperationEnum.REFUND_COMPLETE.getDescription(),OrderOperationEnum.REFUND_COMPLETE.getId(),orderNo);
            //退款信息表写入退款成功
            RefundInfo refundInfo = refundInfoMapper.selectByOrderNo(orderNo);
            if(refundInfo==null){
                refunding(refundId,orderNo,loginUserId,RefundStatusEnum.REFUNDED.getId());
            }else {
                //更新退款信息
                updateRefoundInfo(refundInfo,RefundStatusEnum.REFUNDED.getId());
            }
            return;
        }
        //支付宝退款
        JSONObject paramJson = new JSONObject();
        paramJson.put("orderId", orderPay.getOutPayId());
        paramJson.put("refundId", orderNo);
        paramJson.put("refundFee", Utils.formatMoney(orderNew.getUserRefundCost()));
        paramJson.put("token", TokenConstant.ALLPOWER_TOKEN);
        JSONObject result = paymentClient.refundAlipay(paramJson);
        if (YesOrNoEnum.NO.getValue() == JsonUtil.getJInt(result, Consts.RESULT, ErrorCode.FAILED)) {
            //写入订单操作记录表
            insertOrderOperation(OrderOperationTypeEnum.SYSTEM.getValue(),OrderOperationEnum.REFUND_COMPLETE.getDescription(),OrderOperationEnum.REFUND_COMPLETE.getId(),orderNo);
            //退款信息表写入退款成功
            RefundInfo refundInfo = refundInfoMapper.selectByOrderNo(orderNo);
            if(refundInfo==null){
                refunding(refundId,orderNo,loginUserId,RefundStatusEnum.REFUNDED.getId());
            }else {
                //更新退款信息
                updateRefoundInfo(refundInfo,RefundStatusEnum.REFUNDED.getId());
            }
        } else {
            //写入退款信息表退款中
            RefundInfo refundInfo = refundInfoMapper.selectByOrderNo(orderNo);
            if(refundInfo==null){
                refunding(refundId,orderNo,loginUserId,RefundStatusEnum.REFUNDING.getId());
            }
            logger.error(">>>>>>>>>>>>>>>>>>>>调用支付宝接口退款失败"+result);
        }
    }

    @Override
    protected void subAccount(UserInfo userInfo, OrderPay orderPay, OrderInfo orderInfo1, CorpInfo corpInfo1, OrderInfo orderNew, String refundId, String orderNo, String loginUserId, UserCashLog cashLog) {
        JSONObject payParam = new JSONObject();
        payParam.put(TokenConstant.TOKEN, TokenConstant.ALLPOWER_TOKEN);
        payParam.put("outCustAcctId", userInfo.getCustAcctId());
        payParam.put("outThirdCustId", userInfo.getUserId());
        payParam.put("handFee", "0");
        payParam.put("orderNo", orderPay.getOutPayId());
        JSONArray tranItemArray = new JSONArray();
        JSONObject jo = new JSONObject();
            //商家
            if (orderInfo1.getBusinessIncome().compareTo(new BigDecimal("0.00")) > 0) {
                JSONObject corpJo = new JSONObject();
                corpJo.put("inCustAcctId", corpInfo1.getCustAcctId());
                corpJo.put("inThirdCustId", corpInfo1.getThirdCustId());
                corpJo.put("tranAmount", StringUtil.toString(orderInfo1.getBusinessIncome()));
                tranItemArray.add(corpJo);
            }

        //平台
        if (orderNew.getTotalRefund().compareTo(new BigDecimal("0.00")) > 0){
            jo.put("inCustAcctId", getplatFormSubAcctNo());
            jo.put("inThirdCustId", getplatFormTranNetMemberCode());
            jo.put("tranAmount", Utils.formatMoney(orderNew.getTotalRefund().add(orderInfo1.getPlatformCommission())));
            tranItemArray.add(jo);
        }
        if (tranItemArray.size()>0){
            payParam.put("tranItemArray", tranItemArray);

            JSONObject result2 = paymentClient.insertMembershipTranchePay(payParam);
            if (ErrorCode.SUCCESS != JsonUtil.getJInt(result2, Consts.RESULT, ErrorCode.FAILED)) {
                logger.error(">>>>>>>>>>>>>>>>>>>>>>>>>>结算分账失败"+result2);
                cashLog.setTranStatus(UserTranStatusEnum.FAILED.getId());
            }else{
                cashLog.setTranStatus(UserTranStatusEnum.SUCCESS.getId());
            }
        }
        //写入退款信息表退款中
        RefundInfo refundInfo6 = refundInfoMapper.selectByOrderNo(orderNo);
        if(refundInfo6==null){
            refunding(refundId,orderNo,loginUserId, RefundStatusEnum.REFUNDING.getId());
        } else{
            //用户退款金额小于0只分账不退款
            if (orderNew.getUserRefundCost().compareTo(BigDecimal.ZERO) <= 0){
                updateRefoundInfo(refundInfo6,RefundStatusEnum.REFUNDED.getId());
            }
        }
    }
}

 

 

 

package com.msh.strategy;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.common.core.base.client.PaymentClient;
import com.common.core.businessenum.*;
import com.common.core.constant.TokenConstant;
import com.common.core.frame.Consts;
import com.common.core.util.*;
import com.msh.dao.RefundInfoMapper;
import com.msh.model.*;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.math.BigDecimal;

@Component
public class WeChatPayPath extends AbstractStrategyPayPath {

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

    @Resource
    private  PaymentClient paymentClient;

    @Resource
    private  RefundInfoMapper refundInfoMapper;

//    @Autowired
//    public void setPaymentClient(PaymentClient paymentClient,RefundInfoMapper refundInfoMapper){
//        WeChatPayPath.paymentClient = paymentClient;
//        WeChatPayPath.refundInfoMapper = refundInfoMapper;
//    }

    @Override
    public void payPath(int id,String orderNo,OrderPay orderPay,OrderInfo orderNew,String refundId,UserInfo userInfo,String loginUserId,OrderInfo orderInfo1,CorpInfo corpInfo1,UserCashLog cashLog) {

        if (orderNew.getUserRefundCost().compareTo(BigDecimal.ZERO) > 0){
            insertMembershipTrancheFreeze(userInfo,orderNew,orderPay,orderNo,loginUserId,refundId);
        }

        //分账
        subAccount(userInfo,orderPay,orderInfo1,corpInfo1,orderNew,refundId,orderNo,loginUserId,cashLog);
        //用户退款金额小于0只分账不退款
        if (orderNew.getUserRefundCost().compareTo(BigDecimal.ZERO) <= 0){
            //写入订单操作记录表操作记录表退款成功
            insertOrderOperation(OrderOperationTypeEnum.SYSTEM.getValue(),OrderOperationEnum.REFUND_COMPLETE.getDescription(),OrderOperationEnum.REFUND_COMPLETE.getId(),orderNo);
            //退款信息表写入退款成功
            RefundInfo refundInfo = refundInfoMapper.selectByOrderNo(orderNo);
            if(refundInfo==null){
                refunding(refundId,orderNo,loginUserId,RefundStatusEnum.REFUNDED.getId());
            }else {
                //更新退款信息
                updateRefoundInfo(refundInfo,RefundStatusEnum.REFUNDED.getId());
            }
            return;
        }

        //银联与微信及公众号逻辑差不多故写一起,银联退款相关逻辑
        if (orderPay.getPayPath()==PayPathEnum.UnionPay.getId()){
            unionRefund(orderPay,orderNew,orderNo,refundId,loginUserId);
        }

        JSONObject jsonObject = new JSONObject();
        jsonObject.put("outNo", orderPay.getOutPayId());
        jsonObject.put("orderNo",orderPay.getOutPayId());
        jsonObject.put("refundAmount", orderNew.getUserRefundCost().multiply(new BigDecimal(100)).intValue());
        jsonObject.put("refundOutNo",refundId);
        jsonObject.put("custAcctId",userInfo.getCustAcctId());
        jsonObject.put("token", TokenConstant.ALLPOWER_TOKEN);
        JSONObject result = paymentClient.insertPayRefund(jsonObject);
        if (YesOrNoEnum.NO.getValue() == JsonUtil.getJInt(result, Consts.RESULT, ErrorCode.FAILED)){
            //写入操作记录表
            insertOrderOperation(OrderOperationTypeEnum.SYSTEM.getValue(),OrderOperationEnum.REFUND_COMPLETE.getDescription(),OrderOperationEnum.REFUND_COMPLETE.getId(),orderNo);
            //退款信息表写入退款成功
            RefundInfo refundInfo = refundInfoMapper.selectByOrderNo(orderNo);
            if(refundInfo==null){
                refunding(refundId,orderNo,loginUserId,RefundStatusEnum.REFUNDED.getId());
            }else {
                //更新退款信息
                updateRefoundInfo(refundInfo,RefundStatusEnum.REFUNDED.getId());
            }
        }else{
            //写入退款信息表退款中
            RefundInfo refundInfo = refundInfoMapper.selectByOrderNo(orderNo);
            if(refundInfo==null){
                refunding(refundId,orderNo,loginUserId,RefundStatusEnum.REFUNDING.getId());
            }
            logger.error(">>>>>>>>>>>>>>>>>>>>>>>>>>微信或公众号退款失败"+result);
        }
    }

    @Override
    public void subAccount(UserInfo userInfo, OrderPay orderPay, OrderInfo orderInfo1, CorpInfo corpInfo1,OrderInfo orderNew,String refundId,String orderNo,String loginUserId,UserCashLog cashLog) {
        //分账
        JSONObject payParam = new JSONObject();
        payParam.put(TokenConstant.TOKEN, TokenConstant.ALLPOWER_TOKEN);
        payParam.put("outCustAcctId", userInfo.getCustAcctId());
        payParam.put("outThirdCustId", userInfo.getUserId());
        payParam.put("handFee", "0");
        payParam.put("orderNo", orderPay.getOutPayId());
        JSONArray tranItemArray = new JSONArray();
        JSONObject jo = new JSONObject();
            if(orderInfo1.getBusinessIncome().compareTo(new BigDecimal("0.00")) > 0){
                JSONObject corpJo = new JSONObject();
                corpJo.put("inCustAcctId",corpInfo1.getCustAcctId());
                corpJo.put("inThirdCustId",corpInfo1.getThirdCustId());
                corpJo.put("tranAmount", StringUtil.toString(orderInfo1.getBusinessIncome()));
                tranItemArray.add(corpJo);
            }
        //平台使用优惠券
        if(orderNew.getTotalRefund().subtract(orderNew.getUserRefundCost()).compareTo(new BigDecimal("0.00")) > 0){
            jo.put("inCustAcctId", getplatFormSubAcctNo());
            jo.put("inThirdCustId", getplatFormTranNetMemberCode());
            jo.put("tranAmount", Utils.formatMoney(orderNew.getTotalRefund().subtract(orderNew.getUserRefundCost()).add(orderNew.getPlatformCommission())));
            tranItemArray.add(jo);
        }else{
            if (orderNew.getPlatformCommission().compareTo(new BigDecimal("0.00")) >  0){
                jo.put("inCustAcctId", getplatFormSubAcctNo());
                jo.put("inThirdCustId", getplatFormTranNetMemberCode());
                jo.put("tranAmount", Utils.formatMoney(orderNew.getPlatformCommission()));
                tranItemArray.add(jo);
            }
        }
        if(tranItemArray.size()>0){
            payParam.put("tranItemArray", tranItemArray);
            JSONObject result2 = paymentClient.insertMembershipTranchePay(payParam);
            if (ErrorCode.SUCCESS != JsonUtil.getJInt(result2, Consts.RESULT, ErrorCode.FAILED).intValue()) {
                logger.error(">>>>>>>>>>>>>>>>>>>>>>>>>>结算分账失败"+result2);
                cashLog.setTranStatus(UserTranStatusEnum.FAILED.getId());
            }else {
                cashLog.setTranStatus(UserTranStatusEnum.SUCCESS.getId());
            }
        }
        //写入退款信息表退款中
        RefundInfo refundInfo5 = refundInfoMapper.selectByOrderNo(orderNo);
        if(refundInfo5==null){
            refunding(refundId,orderNo,loginUserId, RefundStatusEnum.REFUNDING.getId());
        }else{
            //用户退款金额小于0只分账不退款
            if (orderNew.getUserRefundCost().compareTo(BigDecimal.ZERO) <= 0){
                updateRefoundInfo(refundInfo5,RefundStatusEnum.REFUNDED.getId());
            }
        }
    }

    private void unionRefund(OrderPay orderPay,OrderInfo orderNew,String orderNo,String refundId,String loginUserId){
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("orderId", orderPay.getOutPayId());
        jsonObject.put("refundAmt",orderNew.getUserRefundCost());
        jsonObject.put("token",TokenConstant.ALLPOWER_TOKEN);
        JSONObject result = paymentClient.insertUnionRefund(jsonObject);
        if (YesOrNoEnum.NO.getValue() == JsonUtil.getJInt(result, Consts.RESULT, ErrorCode.FAILED)){
            //写入订单操作记录表
            insertOrderOperation(OrderOperationTypeEnum.SYSTEM.getValue(),OrderOperationEnum.REFUND_COMPLETE.getDescription(),OrderOperationEnum.REFUND_COMPLETE.getId(),orderNo);
            //退款信息表写入退款成功
            RefundInfo refundInfo = refundInfoMapper.selectByOrderNo(orderNo);
            if(refundInfo==null){
                refunding(refundId,orderNo,loginUserId,RefundStatusEnum.REFUNDED.getId());
            }else {
                //更新退款信息
                updateRefoundInfo(refundInfo,RefundStatusEnum.REFUNDED.getId());
            }
        }else{
            //写入退款信息表退款中
            RefundInfo refundInfo = refundInfoMapper.selectByOrderNo(orderNo);
            if(refundInfo==null){
                refunding(refundId,orderNo,loginUserId,RefundStatusEnum.REFUNDING.getId());
            }
            logger.error(">>>>>>>>>>>>>>>>>>>>>>>>>>银联退款失败"+result);
        }
    }


}

 

 

 

 

 

 

 

 

 

xjk201
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
SpringBoot【问题 01】借助@PostConstruct解决使用@Component注解的类用@Resource注入Mapper接口为null的问题（原因解析+解决方法）
Java与大数据相关实践内容分享！
11-04 2942
Java【付诸实践 02】借助@PostConstruct解决使用@Component注解的类用@Resource注入Mapper接口为null的问题（原因解析+解决方法）
@Autowired和@Resource注入报空指针--NullPointerException（亲测有效）
菜狗博客
08-24 4888
问题：ssm项目中，spring采用@Autowired或@Resource引入mapper，报空指针。 问题原因：在使用Spring进行自动注入的过程中，只会对通过读取Spring的配置文件或者配置类后产生的实例进行自动注入。 手动new出来的实例是无法获得在Spring中注册过得实例，这是 因为手动new 的实例并不是Spring 在初始化过程中注册的实例。 解决：读取Spring的配置文件，...
spring boot获取datasource为null_spring-boot-starter-jdbc与数据访问
weixin_39957265的博客
11-26 2341
大部分 Java 应用都需要访问数据库，尤其是服务层，所以，SpringBoot 会为我们自动配置相应的数据访问设施。若想 SpringBoot 为我们自动配置数据访问的基础设施，那么，我们需要直接或者间接地依赖 spring-jdbc，一旦 spring-jdbc 位于我们 SpringBoot 应用的 classpath，即会触发数据访问相关的自动配置行为，最简单的做法就是把 spring-b...
@Resource和@Autowired注解导入类中的bean为null
maziaotong的博客
10-12 897
因为在启动spring后，spirng会将所有bean，也就是被@RestController、@Service等注解所注解的类加载到容器内，并返回给ApplicationContextAware，其他类需要时将bean注入进去，但new出来的类不会被容器注入。因为在启动spring后，spring会将所有注解过的类加载容器内，并返回给ApplicationContextAware，在其他注解后的类需要对象时，容器会自动注入，当遇到new出来的类时就会与其发生冲突。检查后发现导入的依赖没问题。
Spring在多线程下@Resource注入为null
Healist的博客
01-30 3135
前情叙述记录以下这个坑，我的情况大致是这样的，我在用webmagic写爬虫，在类中通过@Resoource（@Autowired也一样）注入dao接口实例。然后我在process方法中引用这个实例发现这个实例在这里一直为null，然后我在测试类或者当前类的main函数中引用dao实例就没问题，一切正常（当时 黑人问号脸？？？）几经波折，发现原因是spring和多线程安全的问题，不让注入。因为我也没研
数据库建表规则，找不到bean,@Resurce注入为null
FirstMrRight的博客
07-28 248
1.数据库建表规则 建表规约 表达是与否概念的字段，必须使用 is_xxx 的方式命名，数据类型是 unsigned tinyint 表名、字段名必须是小写字母或数字，禁止数字开头和两个下划线之间出现数字。 表名不能出现复数名词。（单数形式） 禁用保留字 主键索引名为 pk_字段名 小数使用decimal，禁止使用 float 和 double 如果存储的字符串长度几乎相等，使用 char 定长字符串类型 varchar是长度可变字符串，长度超过5000使用text (超过长度会报：MysqlDataTr
php类自动装载、链式操作、魔术方法实现代码
10-19
**链式操作**是一种常见的设计模式，它允许开发者连续调用同一个对象的方法，而不必每次调用方法后返回到对象本身。这有助于提高代码的可读性和简洁性。 1. **链式操作示例**: ```php namespace Baobab; class ...
贪心算法-背包装载问题
05-23
背包装载问题是指：给定一个背包，容量为c，它可以装载的最大重量为c。有n个物品，每个物品的重量为w[i]，价值为p[i]。目标是挑选一些物品，使得背包中的总价值最大，但是总重量不能超过c。 在这个问题中，我们可以...
无人化自动装载机的开发与研究
06-29
为了能够在无人现场操纵情况下完成各项复杂的作业任务,设计和研究了具有双目立体视觉技术的无人化自动装载机。该自动装载机不仅能够完全自动完成作业任务,还可自行装载,倾倒时无需掉头,来回行走路径简单,大大提高了...
行业资料-交通装置-一种具有自动装载功能的翻斗车.exe
08-14
行业资料-交通装置-一种具有自动装载功能的翻斗车.exe
springboot.drawio
10-05
个人springboot自动装载原理的思维导图，需要配合原码进行理解
spring boot获取datasource为null_Spring项目中Bean为null，这篇帮你解决
weixin_39961369的博客
12-05 1752
场景：当使用到工厂模式的时候，并在工厂实例中使用外部的service层对象，会这个对象是一个空对象，因此有必要通过spring ApplicationContext 去获取bean1、代码案例如下，拿着可以直接用import org.slf4j.Logger;import org.slf4j.LoggerFactory;import org.springframework.beans.BeansE...
Spring boot JdbcTemplet “this.dataSource“ is null解决办法
qq_69684924的博客
03-26 1471
在测试文件夹里面出现 "this.dataSource" is null的话。看看有没有写@RunWith（SpringRunner.class)注解。如果没有加上这个注解，下面这些自动装配的注解，是不会自动装配的，也就是空引用。，即使加了自动注入，也是不会自动加载配置的。然后在控制器类同样也声明数据源和JDBC对象。如果是运行类出现空引用的话，我遇到的问题是。解决方法是加入一个构造函数，如下图所示。然后进行构造函数的引用。确保配置文件是正常的。
@Resource或@Autowired导入对象时为null
最新发布
Everybody up
01-15 1080
当使用@Resource或@Autowired注解时，不能再手动new被该注解导入的类，否则会默认使用手动new的对象，框架所创建的对象则为null。
@Resource注入bean为null
qq_64726760的博客
01-09 1133
1.首先判断注入的类和被注入的类是否添加@Component @Controller 等注解。解决：使用applicationContext的getBean方法获取。2.加载顺序问题 注入的类比被注入的类加载要早，导致注入为null。
spring关于@Resource注入为null解决办法收藏
m0_71685541的博客
10-25 1924
正确的包是import jakarta.annotation.Resource这个包，如果没有就去Meven把坐标导进来，就好啦。里面是有booktype的，但是就是没有注入到mybook类中,这就很奇怪。开始导的是import javax.annotation.Resource。后面测试运行的时候，终端发现这个找不到这个类 为什么找不到呢。总结:出现这个问题就是导入的包错误了。后面debug的时候，发现单例池里面。
@Resource注入Bean为Null
云之彼端
05-05 1222
在程序运行后, 对该接口进行调试,发现图片所指的Bean注入为空,然后发现接口方法写成了private类型,改成public后恢复正常,特此记录
spring boot获取datasource为null_SpringBoot运行源码分析：Spring应用上下文创建
weixin_39900676的博客
12-08 499
忽略信息配置经过以上步骤，ConfigurableEnvironment 的初 始化和准备工作已经完成。之后，程序又对环境中的忽略信息配置项“spring.beaninfo.ignore”的值进行获取判断，进而设置为系统参数中的忽略项。private void configureIgnoreBeanInfo(ConfigurableEnvironment environment) {//如果系统参...
spring@Aspect类@Autowired注入的bean为null 【转发】
lonsn_lee的专栏
04-05 100
今天工作的时候需要做一个定时任务，在定时任务的job类中，需要调用之前的写好逻辑的service的代码。假设我的job类是MyJob，调用的service名称是MyService。而MyService中需要用到注入另一个service，名称是FlowService。 首先，这几个类都要纳入spring的管理，需要加上@Controller,@Service注解。我第一次就忘了在MyJob上面加注...
springboot自动装配原理
04-30
SpringBoot的自动装配原理可以解释为，它为了方便开发人员，通过预先配置好的默认规则，自动将符合条件的类或组件，自动装配到Spring容器中，从而实现快速、简单的构建应用程序的目的。 SpringBoot自动装配主要从以下几方面实现： 1、@EnableAutoConfiguration注解：在SpringBoot项目的入口类（一般为应用程序主类）上添加该注解，SpringBoot将通过classpath中META-INF/spring.factories的文件中的配置，自动装载Spring和第三方库中的Bean组件。 2、@Conditional注解：SpringBoot通过该注解根据一定的条件（如环境变量、类路径、JVM等）来控制自动装配哪些组件或类。 3、基于Spring的自动装配机制：SpringBoot基于Spring的IoC容器，实现自动装配机制。其核心原理是通过@Autowire、@Resource、@Inject等注解，在Spring容器中自动寻找匹配的Bean进行依赖注入。 总之，SpringBoot利用注解和条件判断机制，实现了自动配置，使得应用程序的开发变得更加快捷和易于维护。但是，需要注意的是当意料之外的自动配置出现问题时，需要进行适当的排查和配置，以避免对整个应用程序的影响。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值