区块链应用软件开发怎么做（如何开发区块链应用程序）

欢迎您是全球710万活跃的Java开发人员之一，也可能是1200万在一生中学习过Java语言的开发人员之一。

在本文中，我将指导您使用Corda构建第一个区块链应用程序，Corda是一个在JVM中运行的区块链平台，仅使用Java。准备好在Java同行中脱颖而出！

你需要什么…

在本文中，我不会详细介绍区块链是什么以及人们为什么需要区块链。我将直接进入编码，并在进行过程中解释去中心化的逻辑。因此，以下是您需要遵循的内容：

1. 您可以选择IDE或代码编辑器。

2. 具有最小2GB RAM的JVM环境。（大多数台式机/笔记本电脑/虚拟机都能够运行Corda。我建议您在Pi上运行应用程序！）。

3. 最后，但并非最不重要的是，您的Java知识！

我们应该建造什么…

当然，我们将从“Hello World”应用程序开始！我们将构建一个应用程序，从区块链上的一方向另一方发送“Hello World”消息。

在Corda世界中，您编写的区块链应用程序称为CorDapp。它仅由三个部分组成：

• 状态：创建、更新、存储和使用的真实资产/对象。例如，一本借书、一辆标记化自行车或一个游戏板。

• 合同：规范/验证国家交易、更新和消费的规则。

• 流程：指示如何执行每个事务的指令。

不用多说，让我们开始编码吧。

步骤1：Corda 状态

在此处克隆Cordapp代码（
https://github.com/corda/cordapp-template-java ）。

使用您选择的代码编辑器打开它，然后导航到：

/contracts/src/main/java/com/template/states/TemplateState.java

@BelongsToContract(TemplateContract.class)
public class TemplateState implements ContractState {/* Constructor of your Corda state */public TemplateState() {
    }/* This method will indicate who are the participants and required signers when 
     * this state is used in a transaction. */@Overridepublic List<AbstractParty> getParticipants() {return Arrays.asList();
    }
}

在Corda世界中，大多数数据都是在一个名为State的对象中处理的。每个状态都有一个 @BelongsToContract（） 注释，指示将使用哪个合同文件在事务中验证此状态。State和合同是1比1挂钩的。继续我们的Hello world CorDapp，我们只需添加几行代码，使上面的TemplateState包含一条消息。我们的州将有3个属性。

• 字符串消息

• 发信人

• 信息接收者

@BelongsToContract(TemplateContract.class)public class TemplateState implements ContractState {    //private variables
    private String msg;    private Party sender;    private Party receiver;    /* Constructor of your Corda state */
    public TemplateState(String msg, Party sender, Party receiver) {        this.msg = msg;        this.sender = sender;        this.receiver = receiver;
    }    //getters
    public String getMsg() { return msg; }    public Party getSender() { return sender; }    public Party getReceiver() { return receiver; }    /* This method will indicate who are the participants and required signers when
     * this state is used in a transaction. */
    @Override
    public List<AbstractParty> getParticipants() {        return Arrays.asList(sender,receiver);
    }
}

创建三个变量，实例化变量，创建 getter ，填写参与者的列表，然后就是Corda状态。创建区块链应用程序的第一步已经完成。

步骤2：Corda合同

导航到
/contracts/src/main/java/com/template/contracts/TemplateContract.java

public class TemplateContract implements Contract {    // This is used to identify our contract when building a transaction.
    public static final String ID = "com.template.contracts.TemplateContract";    // A transaction is valid if the verify() function of the contract of all the transaction's input and output states
    // does not throw an exception.
    @Override
    public void verify(LedgerTransaction tx) {}    // Used to indicate the transaction's intent.
    public interface Commands extends CommandData {        class Action implements Commands {}
    }
}

在Corda世界中，涉及一个国家的每一笔交易都必须通过合同进行验证。每份合同由三个必要部分组成：

• 用于以后参考的合同Id

• 检查事务的verify（）方法

• 一个命令界面，用于指示事务关于状态的意图。请注意，所有标准契约（不包括令牌契约，因为它们是预先编写的）都必须使用命令，为了方便起见，我们通常在接口中定义它们。

public class TemplateContract implements Contract {    // This is used to identify our contract when building a transaction.
    public static final String ID = "com.template.contracts.TemplateContract";    // A transaction is valid if the verify() function of the contract of all the transaction's input and output states
    // does not throw an exception.
    @Override
    public void verify(LedgerTransaction tx) {        /* We can use the requireSingleCommand function to extract command data from transaction.
         * However, it is possible to have multiple commands in a signle transaction.*/
        final CommandWithParties<Commands> command = requireSingleCommand(tx.getCommands(), Commands.class);        final Commands commandData = command.getValue();        if (commandData.equals(new Commands.Send())) {            //Retrieve the output state of the transaction
            TemplateState output = tx.outputsOfType(TemplateState.class).get(0);            //Using Corda DSL function requireThat to replicate conditions-checks
            requireThat(require -> {
                require.using("The message must be Hello-World", output.getMsg().equals("Hello-World"));                return null;
            });
        }
    }    // Used to indicate the transaction's intent.
    public interface Commands extends CommandData {        //In our hello-world app, We will only have one command.
        class Send implements Commands {}
    }
}

在Commands界面中，我们创建了一个名为send的命令，稍后我们将使用该命令指示事务的意图。

在verify（）方法中，我们询问：

事务内部状态中携带的消息字符串必须是“Hello World”。

到这一步结束时，您将已经编写了合同。

步骤3：Corda流程

拥有可操作区块链应用程序之前的最后一步！导航到
/workflows/src/main/java/com/template/flows/Initiator.java

@InitiatingFlow@StartableByRPCpublic class Initiator extends FlowLogic<Void> {    private final ProgressTracker progressTracker = new ProgressTracker();    @Override
    public ProgressTracker getProgressTracker() {        return progressTracker;
    }    @Suspendable
    @Override
    public Void call() throws FlowException {        // Initiator flow logic goes here.

        return null;
    }
}

在Corda世界中，启动器流触发应用程序中的业务操作。无论是发送事务还是传递消息，都必须有一个启动器来发出操作信号。除了私有变量和构造函数之外，发起程序流还包括一个名为call（）的签名方法。

每当调用启动器时，此方法将自动运行。这是将有效负载添加到事务、签名和签名集合的地方。现在，让我们根据Hello World的情况填写一下。

@InitiatingFlow@StartableByRPCpublic class Initiator extends FlowLogic<SignedTransaction> {    // We will not use these ProgressTracker for this Hello-World sample
    private final ProgressTracker progressTracker = new ProgressTracker();    @Override
    public ProgressTracker getProgressTracker() {        return progressTracker;
    }    //private variables
    private Party sender ;    private Party receiver;    //public constructor
    public Initiator(Party sendTo){        this.receiver = sendTo;
    }    @Suspendable
    @Override
    public SignedTransaction call() throws FlowException {        //Hello World message
        String msg = "Hello-World";        this.sender = getOurIdentity();        // Step 1. Get a reference to the notary service on our network and our key pair.
        // Note: ongoing work to support multiple notary identities is still in progress.
        final Party notary = getServiceHub().getNetworkMapCache().getNotaryIdentities().get(0);        //Compose the State that carries the Hello World message
        final TemplateState output = new TemplateState(msg,sender,receiver);        // Step 3. Create a new TransactionBuilder object, and add the iou as an output state, 
        //as well as a command to the transaction builder.
        final TransactionBuilder builder = new TransactionBuilder(notary);
        builder.addOutputState(output);
        builder.addCommand(new TemplateContract.Commands.Send(), Arrays.asList(this.sender.getOwningKey(),this.receiver.getOwningKey()) );        // Step 4. Verify and sign it with our KeyPair.
        builder.verify(getServiceHub());        final SignedTransaction ptx = getServiceHub().signInitialTransaction(builder);        // Step 5. Collect the other party's signature using the SignTransactionFlow.
        List<Party> otherParties = output.getParticipants().stream().map(el -> (Party)el).collect(Collectors.toList());
        otherParties.remove(getOurIdentity());
        List<FlowSession> sessions = otherParties.stream().map(el -> initiateFlow(el)).collect(Collectors.toList());

        SignedTransaction stx = subFlow(new CollectSignaturesFlow(ptx, sessions));        // Step 6. Assuming no exceptions, we can now finalise the transaction
        return subFlow(new FinalityFlow(stx, sessions));
    }
}

在这个Hello World启动器流中，我们必须：

1. 获得公证处的证明。[防止双重开支]

2. 撰写包含Hello World消息的状态。[产生输出]

3. 创建一个新的TransactionBuilder对象，将带有Hello World消息的状态添加为输出状态，并将命令添加到事务生成器中。[组成交易]

4. 验证并用我们的密钥对签名。[自行核实并签字]

5. 使用SignTransactionFlow收集另一方的签名。[在交易对手之间达成共识]

6. 完成交易并向所有相关方广播。[将交易存储到分类账]

这将是向交易对手发送Hello World的发起方流程。但是，我们还没有结束。我们必须注意该启动器的响应部分。现在，导航到
/workflows/src/main/java/com/template/flows/Responder.java

@InitiatedBy(Initiator.class)public class Responder extends FlowLogic<Void> {    //private variable
    private FlowSession counterpartySession;    
    //Constructor
    public Responder(FlowSession counterpartySession) {        this.counterpartySession = counterpartySession;
    }    @Suspendable
    @Override
    public Void call() throws FlowException {        // Responder flow logic goes here.

        return null;
    }
}

响应程序流，如其名称所示，将从对方方响应相应的发起程序流。这个annotation @InitiatedBy 显示它与哪个启动器关联。

同样，响应者也有一个自动运行调用（），该方法将在本地重新检查并保存事务（在对方节点端，因为响应者是在对方端触发的）。

@InitiatedBy(Initiator.class)public class Responder extends FlowLogic<Void> {    //private variable
    private FlowSession counterpartySession;    //Constructor
    public Responder(FlowSession counterpartySession) {        this.counterpartySession = counterpartySession;
    }    @Suspendable
    @Override
    public Void call() throws FlowException {
        SignedTransaction signedTransaction = subFlow(new SignTransactionFlow(counterpartySession) {            @Suspendable
            @Override
            protected void checkTransaction(SignedTransaction stx) throws FlowException {                /*
                * SignTransactionFlow will automatically verify the transaction and its signatures before signing it.
                * However, just because a transaction is contractually valid doesn’t mean we necessarily want to sign.
                * What if we don’t want to deal with the counterparty in question, or the value is too high,
                * or we’re not happy with the transaction’s structure? checkTransaction
                * allows us to define these additional checks. If any of these conditions are not met,
                * we will not sign the transaction - even if the transaction and its signatures are contractually valid.
                * ----------
                * For this hello-world cordapp, we will not implement any aditional checks.
                * */
            }
        });        //Stored the transaction into data base.
        subFlow(new ReceiveFinalityFlow(counterpartySession, signedTransaction.getId()));        return null;
    }
}

到目前为止，您已经完成了第一个区块链应用程序的编写。我们要试着运行它们吗？

正在运行Hello World区块链应用程序…

转到终端，导航到项目文件夹/cordapp template java/并运行以下代码来部署应用程序。

./gradlew clean deployNodes（适用于Unix）和gradlew.bat clean deployNodes（适用于Windows）

成功引导将产生以下信息：

现在，运行以下代码以运行引导环境：

/build/nodes/runnodes（适用于Unix）和.buildnodesrunnodes.bat（适用于Windows）。

我们应该期待三个节点在不同的选项卡中启动并启动它们的shell。

现在让我们从PartyA向PartyB发送“Hello world”。

转到PartyA的shell并运行：

流启动启动器发送到：PartyB

我们应该期待以下信息：

到目前为止，我们已经通过分布式系统从一方向另一方发送了“Hello World”消息！但是是吗？让我们检查一下！

导航到PartyB的节点外壳并运行：

运行Vault Query
contractStateType:com.template.states.TemplateState

就在那里！携带“Hello World”并从PartyA发送到PartyB的模板状态。

这个应用程序的“区块链”是什么？

你可能会想，等一下，我只看到一个在各方之间发送消息的应用程序，块在哪里？链条在哪里？通过部署和运行该应用程序，您已经成功启动了一个通常称为“区块链”的本地分布式账本系统。

携带消息字符串的状态是块。您将通过事务连接与先前生成的状态相关的后续状态，我们可以将其视为“链”。

这种状态交易链仅在参与方之间需要了解的基础上共享。（回忆步骤1中的参与者列表）。因此，在Corda世界中，数据是分布式共享的。不会有一个记录各方交易的集中数据库。

回到Hello World示例，事务（
txHash:736AA884909645171B56AD965D3B…94E4F457C）带有genesis块（状态），可以用作另一个事务的输入，该链将继续运行。与区块链的概念类似：Corda状态（块）由Corda事务（链）链接