Blockchain net.corda.serialization.internal.amqp.IllegalCustomSerializationRexception在流启动期间发生异常

我在执行一个corda流时出错。 启动ApplyLocafFlow受益人：，发卡银行：，advisingBank:，locID:null，applicationDate:null，金额：1000，locStatus:“创建”：异常：net.corda.serialization.internal.amqp.IllegalCustomSerializerException:异常（java.lang.Throwable）->自定义序列化程序net.corda.serialization.internal.amqp.Custom.ThrowableSerializer已注册为序列化非自定义可序列化类型类net.corda.core.flows.IllegalFlowLogicException 星期一9月30日10:40:03 IST 2019>>

周一至九月30日10:40:03 IST 2019>>>[错误]10:40:03+0530 [pool-8-thread-2]command.CRaSHSession.execute-执行时出错 评估申请“启动应用程序流量受益人：”，发卡行： “”，advisingBank:“”，locID:null，applicationDate:null，金额： 1000，locStatus:“创建”'开始应用程序流量受益人：“”， 发行银行：，通知银行：，locID:null，申请日期：null， 金额：1000，locStatus:“创建”：异常： net.corda.serialization.internal.amqp.IllegalCustomSerializationRexception： 异常（java.lang.Throwable）->自定义序列化程序 net.corda.serialization.internal.amqp.custom.ThrowableSerializer 已注册以序列化非自定义可序列化类型类 net.corda.core.flows.IllegalFlowLogicException[errorCode=g3v6fv， 更多信息=

LoCState:

package com.template.states;

import com.template.contracts.LoCContract;
import net.corda.core.contracts.*;
import net.corda.core.identity.AbstractParty;
import net.corda.core.identity.Party;
import net.corda.core.serialization.CordaSerializable;

import java.time.LocalDate;
import java.util.Arrays;
import java.util.Currency;
import java.util.Date;
import java.util.List;

// *********
// * State *
// *********
@BelongsToContract(LoCContract.class)
@CordaSerializable
public class LoCState implements LinearState {
    private Party applicant;
    private Party beneficiary;
    private Party issuingBank;
    private Party advisingBank;
    private UniqueIdentifier locID;
    private Date applicationDate;
    private int amount;
    private String locStatus;

    public LoCState(Party applicant, Party benificiery, Party issuingBank,
                    Party advisingBank, UniqueIdentifier locID, Date applicationDate,
                    int amount, String locStatus) {
        this.applicant = applicant;
        this.beneficiary = benificiery;
        this.issuingBank = issuingBank;
        this.advisingBank = advisingBank;
        this.locID = locID;
        this.applicationDate = applicationDate;
        this.amount = amount;
        this.locStatus = locStatus;
    }

    public List<AbstractParty> getParticipants() {
        return Arrays.asList(applicant, beneficiary, issuingBank, advisingBank);
    }

    public UniqueIdentifier getLinearId() {
        return this.locID;
    }

    public Party getApplicant() {
        return applicant;
    }

    public void setApplicant(Party applicant) {
        this.applicant = applicant;
    }

    public Party getBeneficiary() {
        return beneficiary;
    }

    public void setBeneficiary(Party beneficiary) {
        this.beneficiary = beneficiary;
    }

    public Party getIssuingBank() {
        return issuingBank;
    }

    public void setIssuingBank(Party issuingBank) {
        this.issuingBank = issuingBank;
    }

    public Party getAdvisingBank() {
        return advisingBank;
    }

    public void setAdvisingBank(Party advisingBank) {
        this.advisingBank = advisingBank;
    }

    public UniqueIdentifier getLocID() {
        return locID;
    }

    public void setLocID(UniqueIdentifier locID) {
        this.locID = locID;
    }

    public Date getApplicationDate() {
        return applicationDate;
    }

    public void setApplicationDate(Date applicationDate) {
        this.applicationDate = applicationDate;
    }

    public int getAmount() {
        return amount;
    }

    public void setAmount(int amount) {
        this.amount = amount;
    }

    public String getLocStatus() {
        return locStatus;
    }

    public void setLocStatus(String locStatus) {
        this.locStatus = locStatus;
    }
}

package com.template.contracts;

import net.corda.core.contracts.CommandData;
import net.corda.core.contracts.Contract;
import net.corda.core.transactions.LedgerTransaction;

public class LoCContract implements Contract {

            @Override
            public void verify(LedgerTransaction tx) {}

            public interface Commands extends CommandData {
                class CreateLoC implements Commands {}
            }
        }

ApplyLoCFlow：

package com.template.flows;

import co.paralleluniverse.fibers.Suspendable;
import com.template.contracts.LoCContract;
import com.template.states.LoCState;
import net.corda.core.contracts.Amount;
import net.corda.core.contracts.Command;
import net.corda.core.contracts.UniqueIdentifier;
import net.corda.core.flows.*;
import net.corda.core.identity.CordaX500Name;
import net.corda.core.identity.Party;
import net.corda.core.transactions.SignedTransaction;
import net.corda.core.transactions.TransactionBuilder;
import net.corda.core.utilities.ProgressTracker;

import java.time.LocalDate;
import java.util.Arrays;
import java.util.Currency;
import java.util.Date;

import static com.template.flows.ProgressTrackerStates.*;

@InitiatingFlow
@StartableByRPC
public class ApplyLoCFlow extends FlowLogic<SignedTransaction> {

    public ApplyLoCFlow(String beneficiary, String issuingBank, String advisingBank,
                        UniqueIdentifier locID, LocalDate applicationDate,
                        int amount, String locStatus) {
        this.beneficiary = beneficiary;
        this.issuingBank = issuingBank;
        this.advisingBank = advisingBank;
    //    this.locID = locID;
    //    this.applicationDate = applicationDate;
        this.amount = amount;
        this.locStatus = locStatus;
    }

    private String beneficiary;
    private String issuingBank;
    private String advisingBank;
  //  private UniqueIdentifier locID;
  //  private LocalDate applicationDate;
    private int amount;
    private String locStatus;

    private final ProgressTracker progressTracker = new ProgressTracker(GETTING_NOTARY, GETTING_COUNTERPARTIES,GENERATING_TRANSACTION, VERIFYING_TRANSACTION, SIGNING_TRANSACTION, FINALISING_TRANSACTION);

    @Override
    public ProgressTracker getProgressTracker() {
        return progressTracker;
    }

    @Suspendable
    @Override
    public SignedTransaction call() throws FlowException {
        progressTracker.setCurrentStep(GETTING_NOTARY);
        final Party notary=getServiceHub().getNetworkMapCache().getNotaryIdentities().get(0);

        progressTracker.setCurrentStep(GETTING_COUNTERPARTIES);
        Party bName=null;
        Party iBank= null;
        Party aBank= null;
      //  if(getServiceHub().getIdentityService().partiesFromName(beneficiary, false).iterator().hasNext()){
            CordaX500Name counterPartyName = new CordaX500Name("PartyA", "Hyderabad", "IN");
            bName = getServiceHub().getIdentityService().wellKnownPartyFromX500Name(counterPartyName);
           // bName=getServiceHub().getIdentityService().partiesFromName(beneficiary, false).iterator().next();

      //  }
        /*if(getServiceHub().getIdentityService().partiesFromName(issuingBank, false).iterator().hasNext()){
             iBank=getServiceHub().getIdentityService().partiesFromName(issuingBank, false).iterator().next();
        }*/
        CordaX500Name issuingName = new CordaX500Name("BankA", "Chennai", "IN");
        iBank = getServiceHub().getIdentityService().wellKnownPartyFromX500Name(issuingName);
       /* if(getServiceHub().getIdentityService().partiesFromName(advisingBank, false).iterator().hasNext()){
             aBank=getServiceHub().getIdentityService().partiesFromName(advisingBank, false).iterator().next();
        }*/
        CordaX500Name advName = new CordaX500Name("BankB", "Mumbai", "IN");
        aBank = getServiceHub().getIdentityService().wellKnownPartyFromX500Name(advName);
        TransactionBuilder txBuilder= new TransactionBuilder(notary);
        Command command= new Command(new LoCContract.Commands.CreateLoC(), Arrays.asList(getServiceHub().getMyInfo().getLegalIdentities().get(0).getOwningKey()));
        LoCState state= new LoCState(getOurIdentity(), bName, iBank, aBank,  new UniqueIdentifier(), new Date(), amount, "Open");

        txBuilder.addOutputState(state, LoCContract.ID);
        txBuilder.addCommand(command);

        progressTracker.setCurrentStep(VERIFYING_TRANSACTION);
        txBuilder.verify(getServiceHub());

        progressTracker.setCurrentStep(SIGNING_TRANSACTION);
        SignedTransaction stx= getServiceHub().signInitialTransaction(txBuilder);

        progressTracker.setCurrentStep(FINALISING_TRANSACTION);
        return subFlow(new FinalityFlow(stx));
        // Initiator flow logic goes here.

    }
}

package com.template.flows；
import co.paralleluniverse.fibers.Suspendable；
导入com.template.contracts.LoCContract；
导入com.template.states.LoCState；
进口净额.corda.core.contracts.Amount；
导入net.corda.core.contracts.Command；
导入net.corda.core.contracts.UniqueIdentifier；
导入net.corda.core.flows.*；
导入net.corda.core.identity.CordaX500Name；
导入net.corda.core.identity.Party；
导入net.corda.core.transactions.SignedTransaction；
导入net.corda.core.transactions.TransactionBuilder；
导入net.corda.core.utilities.ProgressTracker；
导入java.time.LocalDate；
导入java.util.array；
导入java.util.Currency；
导入java.util.Date；
导入静态com.template.flows.ProgressTrackerStates.*；
@启动流
@星表
公共类ApplyLoCFlow扩展了FlowLogic{
公共应用程序流量（字符串受益人、字符串发行银行、字符串咨询银行、，
UniqueIdentifier locID、LocalDate applicationDate、，
整数金额，字符串状态）{
这个受益人=受益人；
this.issuingBank=发行银行；
this.advisingBank=advisingBank；
//this.locID=locID；
//this.applicationDate=applicationDate；
这个。金额=金额；
this.locStatus=locStatus；
}
私人受益人；
私人字符串发行银行；
私人字符串咨询银行；
//专用唯一标识符locID；
//私有localdateapplicationdate；
私人整数金额；
私有字符串状态；
private final ProgressTracker ProgressTracker=新的ProgressTracker（获取公证人、获取交易对手、生成交易、验证交易、签署交易、完成交易）；
@凌驾
公共ProgressTracker getProgressTracker（）{
返回进程跟踪器；
}
@暂停
@凌驾
public SignedTransaction调用（）引发流异常{
progressTracker.setCurrentStep（获取公证人）；
最终参与方公证人=getServiceHub（）.getNetworkMapCache（）.getNotaryIdentities（）.get（0）；
progressTracker.setCurrentStep（获取交易对手）；
Party bName=null；
第三方银行=空；
甲方银行=空；
//if（getServiceHub（）.getIdentityService（）.partiesFromName（受益人，false）.iterator（）.hasNext（））{
CordaX500Name counterPartyName=新的CordaX500Name（“PartyA”、“Hyderabad”、“IN”）；
bName=getServiceHub（）.getIdentityService（）.wellKnownPartyFromX500Name（对方名称）；
//bName=getServiceHub（）.getIdentityService（）.partiesFromName（受益人，false）.iterator（）.next（）；
//  }
/*if（getServiceHub（）.getIdentityService（）.partiesFromName（issuingBank，false）.iterator（）.hasNext（））{
iBank=getServiceHub（）.getIdentityService（）.partiesFromName（issuingBank，false）.iterator（）.next（）；
}*/
CordaX500Name issuingName=新的CordaX500Name（“BankA”、“Chennai”、“IN”）；
iBank=getServiceHub（）.getIdentityService（）.wellKnownPartyFromX500Name（issuingName）；
/*if（getServiceHub（）.getIdentityService（）.partiesFromName（advisingBank，false）.iterator（）.hasNext（））{
aBank=getServiceHub（）.getIdentityService（）.partiesFromName（advisingBank，false）.iterator（）.next（）；
}*/
CordaX500Name advName=新CordaX500Name（“银行”、“孟买”、“IN”）；
aBank=getServiceHub（）.getIdentityService（）.wellKnownPartyFromX500Name（advName）；
TransactionBuilder txBuilder=新TransactionBuilder（公证人）；
Command Command=new命令（new LoCContract.Commands.CreateLoC（），Arrays.asList（getServiceHub（）.getMyInfo（）.getLegalidenties（）.get（0.getOwningKey（）））；
LoCState state=新LoCState（getOurIdentity（），bName，iBank，aBank，new UniqueIdentifier（），new Date（），金额，“未结”）；
txBuilder.addOutputState（state，LoCContract.ID）；
txBuilder.addCommand（命令）；
progressTracker.setCurrentStep（验证_事务）；
验证（getServiceHub（））；
progressTracker.setCurrentStep（签名\u事务）；
SignedTransaction stx=getServiceHub（）。signInitialTransaction（txBuilder）；
progressTracker.setCurrentStep（完成_事务）；
返回子流（新最终流（stx））；
//启动器流逻辑在这里。
}
}

如果您使用的是Corda v4，则该州的所有参与者（不仅仅是签名者）都应该有响应流

为Corda状态保留空构造函数。

H