pom.xml

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>org.example</groupId>
  <artifactId>jdchainconsole</artifactId>
  <version>1.0-SNAPSHOT</version>

  <name>jdchainconsole</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
    <framework.version>1.5.0.RELEASE</framework.version>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>com.jd.blockchain</groupId>
      <artifactId>sdk-client</artifactId>
      <version>${framework.version}</version>
    </dependency>

    <dependency>
      <groupId>com.jd.blockchain</groupId>
      <artifactId>sdk-rpc</artifactId>
      <version>${framework.version}</version>
    </dependency>

    <dependency>
      <groupId>com.jd.blockchain</groupId>
      <artifactId>crypto-classic</artifactId>
      <version>${framework.version}</version>
    </dependency>

    <dependency>
      <groupId>com.jd.blockchain</groupId>
      <artifactId>crypto-sm</artifactId>
      <version>${framework.version}</version>
    </dependency>

    <dependency>
      <groupId>com.jd.blockchain</groupId>
      <artifactId>ledger-model</artifactId>
      <version>${framework.version}</version>
    </dependency>
  </dependencies>

  <build>
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>
        <!-- clean lifecycle, see https://maven.apache.org/ref/current/maven-core/lifecycles.html#clean_Lifecycle -->
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.1.0</version>
        </plugin>
        <!-- default lifecycle, jar packaging: see https://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_jar_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.8.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.22.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-jar-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
        <!-- site lifecycle, see https://maven.apache.org/ref/current/maven-core/lifecycles.html#site_Lifecycle -->
        <plugin>
          <artifactId>maven-site-plugin</artifactId>
          <version>3.7.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-project-info-reports-plugin</artifactId>
          <version>3.0.0</version>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>
</project>

ChainResponse.java

package org.example;

import com.jd.blockchain.ledger.TransactionResponse;

public class ChainResponse {
    private TransactionResponse _response;
    /*
    交易结果信息
     */
    public TransactionResponse getResponse(){
        return _response;
    }
    public void setResponse(TransactionResponse response){
        _response = response;
    }

    private String _address;
    /*
    新建的用户地址、数据帐户地址
     */
    public String getAddress(){
        return _address;
    }
    public void setAddress(String address){
        _address = address;
    }
    private boolean _state;
    /*
    执行情况
     */
    public boolean getState(){
        return _state;
    }
    public void setState(boolean state){
        _state = state;
    }

}

ChainHelper

package org.example;

import com.jd.blockchain.crypto.*;
import com.jd.blockchain.ledger.*;
import com.jd.blockchain.sdk.BlockchainService;
import com.jd.blockchain.sdk.client.GatewayServiceFactory;
import utils.Bytes;
import utils.codec.Base58Utils;

import java.sql.Timestamp;

public class ChainHelper {
    protected static HashDigest ledger;
    protected static BlockchainService blockchainService;
    protected static BlockchainKeypair adminKey;
    // 7VeR8q2oLa5dBgcSKi8AZ8ojpyDcVPP3pnaa4BCC7Kom5xhC
    // 177gjvw6ePEW5GhThsQFUNXwu16MkaPEh8TPiEXjmNMj25UJUycaaZCYQ8rkucmYTqrJQ6H
    // 8EjkXVSTxMFjCvNNsTo8RBMDEVQmk7gYkW4SCDuvdsBG
    // j5tos1z5oFXagUdJUuYjjjYC3rXYWn2kiDs4F4qVGBLz4N
    // "192.168.10.8"
    // 10550
    public static void Init(String pubStr, String privStr, String pwd, String ledgerHash, String gateway, int port){
        // 初始配置交易签名用户信息
        PubKey pubKey = KeyGenUtils.decodePubKey(pubStr);
        PrivKey privKey = KeyGenUtils.decodePrivKey(privStr, pwd);
        adminKey = new BlockchainKeypair(pubKey, privKey);
        // 读取网关配置
        blockchainService = GatewayServiceFactory.connect(gateway, port, false, adminKey).getBlockchainService();
        ledger = Crypto.resolveAsHashDigest(Base58Utils.decode(ledgerHash));
    }
    public static void getTransactionByContentHash(HashDigest sampleHash) {
        LedgerTransaction tx = blockchainService.getTransactionByContentHash(ledger, sampleHash);

    }
    public static TypedKVEntry getDataEntries(String dataAccountString, String key) {
        TypedKVEntry[] kvs = blockchainService.getDataEntries(ledger, dataAccountString, key);
        return kvs[0];
    }
    // 数据上链
    public static ChainResponse setKV(String dataAccountString,String key, String value) {
        ChainResponse ret = new ChainResponse();
        ret.setState(false);
        // 新建交易
        TransactionTemplate txTemp = blockchainService.newTransaction(ledger);
        // 版本判断
        TypedKVEntry originalKV = getDataEntries(dataAccountString, key);
        System.out.println("上一版本：" + originalKV.getVersion());
        long version = -1;
        if(originalKV.getVersion()>-1){
            version = originalKV.getVersion();
        }
        // 请正确填写数据账户地址
        // expVersion是针对此key的插入更新操作次数严格递增，初始为-1，再次运行本测试用例请修改该值，否则服务端将报版本冲突异常。
        txTemp.dataAccount(Bytes.fromBase58(dataAccountString)).setText(key, value, version);
        // 交易准备
        PreparedTransaction ptx = txTemp.prepare();
        // 交易签名
        ptx.sign(adminKey);
        // 提交交易
        TransactionResponse response = ptx.commit();
        if (response.isSuccess()) {
            ret.setState(true);
            System.out.println(String.format("height=%d, ###OK#, contentHash=%s, executionState=%s",
                    response.getBlockHeight(),
                    response.getContentHash(), response.getExecutionState().toString()));
        } else {
            System.out.println(String.format("height=%d, ###exception#, contentHash=%s, executionState=%s",
                    response.getBlockHeight(),
                    response.getContentHash(), response.getExecutionState().toString()));
        }
        ret.setResponse(response);
        return ret;
    }
    /*
    数据上链
     */
    public static ChainResponse setKV(String dataAccountString,String key, Integer value) {
        ChainResponse ret = new ChainResponse();
        ret.setState(false);
        // 新建交易
        TransactionTemplate txTemp = blockchainService.newTransaction(ledger);
        // 版本判断
        TypedKVEntry originalKV = getDataEntries(dataAccountString, key);
        long version = -1;
        if(originalKV.getVersion()>-1){
            version = originalKV.getVersion();
        }
        // 请正确填写数据账户地址
        // expVersion是针对此key的插入更新操作次数严格递增，初始为-1，再次运行本测试用例请修改该值，否则服务端将报版本冲突异常。
        txTemp.dataAccount(Bytes.fromBase58(dataAccountString)).setInt64(key, value, version);
        // 交易准备
        PreparedTransaction ptx = txTemp.prepare();
        // 交易签名
        ptx.sign(adminKey);
        // 提交交易
        TransactionResponse response = ptx.commit();
        if (response.isSuccess()) {
            ret.setState(true);
            System.out.println(String.format("height=%d, ###OK#, contentHash=%s, executionState=%s",
                    response.getBlockHeight(),
                    response.getContentHash(), response.getExecutionState().toString()));
        } else {
            System.out.println(String.format("height=%d, ###exception#, contentHash=%s, executionState=%s",
                    response.getBlockHeight(),
                    response.getContentHash(), response.getExecutionState().toString()));
        }
        ret.setResponse(response);
        return ret;
    }
    /*
    数据上链
     */
    public static ChainResponse setKV(String dataAccountString,String key, Timestamp value) {
        ChainResponse ret = new ChainResponse();
        ret.setState(false);
        // 新建交易
        TransactionTemplate txTemp = blockchainService.newTransaction(ledger);
        // 版本判断
        TypedKVEntry originalKV = getDataEntries(dataAccountString, key);
        long version = -1;
        if(originalKV.getVersion()>-1){
            version = originalKV.getVersion();
        }
        // 请正确填写数据账户地址
        // expVersion是针对此key的插入更新操作次数严格递增，初始为-1，再次运行本测试用例请修改该值，否则服务端将报版本冲突异常。
        txTemp.dataAccount(Bytes.fromBase58(dataAccountString)).setTimestamp(key, value.getTime(), version);
        // 交易准备
        PreparedTransaction ptx = txTemp.prepare();
        // 交易签名
        ptx.sign(adminKey);
        // 提交交易
        TransactionResponse response = ptx.commit();
        if (response.isSuccess()) {
            ret.setState(true);
            System.out.println(String.format("height=%d, ###OK#, contentHash=%s, executionState=%s",
                    response.getBlockHeight(),
                    response.getContentHash(), response.getExecutionState().toString()));
        } else {
            System.out.println(String.format("height=%d, ###exception#, contentHash=%s, executionState=%s",
                    response.getBlockHeight(),
                    response.getContentHash(), response.getExecutionState().toString()));
        }
        ret.setResponse(response);
        return ret;
    }
    /*
    数据上链
     */
    public static ChainResponse setJSONKV(String dataAccountString,String key, String value) {
        ChainResponse ret = new ChainResponse();
        ret.setState(false);
        // 新建交易
        TransactionTemplate txTemp = blockchainService.newTransaction(ledger);
        // 版本判断
        TypedKVEntry originalKV = getDataEntries(dataAccountString, key);
        long version = -1;
        if(originalKV.getVersion()>-1){
            version = originalKV.getVersion();
        }
        // 请正确填写数据账户地址
        // expVersion是针对此key的插入更新操作次数严格递增，初始为-1，再次运行本测试用例请修改该值，否则服务端将报版本冲突异常。
        txTemp.dataAccount(Bytes.fromBase58(dataAccountString)).setJSON(key, value, version);
        // 交易准备
        PreparedTransaction ptx = txTemp.prepare();
        // 交易签名
        ptx.sign(adminKey);
        // 提交交易
        TransactionResponse response = ptx.commit();
        if (response.isSuccess()) {
            ret.setState(true);
            System.out.println(String.format("height=%d, ###OK#, contentHash=%s, executionState=%s",
                    response.getBlockHeight(),
                    response.getContentHash(), response.getExecutionState().toString()));
        } else {
            System.out.println(String.format("height=%d, ###exception#, contentHash=%s, executionState=%s",
                    response.getBlockHeight(),
                    response.getContentHash(), response.getExecutionState().toString()));
        }
        ret.setResponse(response);
        return ret;
    }
    /*
数据上链
 */
    public static ChainResponse setByteKV(String dataAccountString,String key, Integer value) {
        ChainResponse ret = new ChainResponse();
        ret.setState(false);
        // 新建交易
        TransactionTemplate txTemp = blockchainService.newTransaction(ledger);
        // 版本判断
        TypedKVEntry originalKV = getDataEntries(dataAccountString, key);
        long version = -1;
        if(originalKV.getVersion()>-1){
            version = originalKV.getVersion();
        }
        // 请正确填写数据账户地址
        // expVersion是针对此key的插入更新操作次数严格递增，初始为-1，再次运行本测试用例请修改该值，否则服务端将报版本冲突异常。
        txTemp.dataAccount(Bytes.fromBase58(dataAccountString)).setBytes(key, Bytes.fromInt(value), version);
        // 交易准备
        PreparedTransaction ptx = txTemp.prepare();
        // 交易签名
        ptx.sign(adminKey);
        // 提交交易
        TransactionResponse response = ptx.commit();
        if (response.isSuccess()) {
            ret.setState(true);
            System.out.println(String.format("height=%d, ###OK#, contentHash=%s, executionState=%s",
                    response.getBlockHeight(),
                    response.getContentHash(), response.getExecutionState().toString()));
        } else {
            System.out.println(String.format("height=%d, ###exception#, contentHash=%s, executionState=%s",
                    response.getBlockHeight(),
                    response.getContentHash(), response.getExecutionState().toString()));
        }
        ret.setResponse(response);
        return ret;
    }
    /*
    数据上链
    */
    public static ChainResponse setByteKV(String dataAccountString,String key, byte[] value) {
        ChainResponse ret = new ChainResponse();
        ret.setState(false);
        // 新建交易
        TransactionTemplate txTemp = blockchainService.newTransaction(ledger);
        // 版本判断
        TypedKVEntry originalKV = getDataEntries(dataAccountString, key);
        long version = -1;
        if(originalKV.getVersion()>-1){
            version = originalKV.getVersion();
        }
        // 请正确填写数据账户地址
        // expVersion是针对此key的插入更新操作次数严格递增，初始为-1，再次运行本测试用例请修改该值，否则服务端将报版本冲突异常。
        txTemp.dataAccount(Bytes.fromBase58(dataAccountString)).setBytes(key, value, version);
        // 交易准备
        PreparedTransaction ptx = txTemp.prepare();
        // 交易签名
        ptx.sign(adminKey);
        // 提交交易
        TransactionResponse response = ptx.commit();
        if (response.isSuccess()) {
            ret.setState(true);
            System.out.println(String.format("height=%d, ###OK#, contentHash=%s, executionState=%s",
                    response.getBlockHeight(),
                    response.getContentHash(), response.getExecutionState().toString()));
        } else {
            System.out.println(String.format("height=%d, ###exception#, contentHash=%s, executionState=%s",
                    response.getBlockHeight(),
                    response.getContentHash(), response.getExecutionState().toString()));
        }
        ret.setResponse(response);
        return ret;
    }
    /*
    注册数据帐户
     */
    public static ChainResponse registerDataAccount() {
        ChainResponse ret = new ChainResponse();
        ret.setState(false);
        // 新建交易
        TransactionTemplate txTemp = blockchainService.newTransaction(ledger);
        // 生成数据账户
        BlockchainKeypair dataAccount = BlockchainKeyGenerator.getInstance().generate();
        ret.setAddress(dataAccount.getAddress() + "");
        System.out.println("数据账户地址：" + dataAccount.getAddress());
        // 注册数据账户
        txTemp.dataAccounts().register(dataAccount.getIdentity());
        // 交易准备
        PreparedTransaction ptx = txTemp.prepare();
        // 交易签名
        ptx.sign(adminKey);
        // 提交交易
        TransactionResponse response = ptx.commit();
        if (response.isSuccess()) {
            ret.setState(true);
            System.out.println(String.format("height=%d, ###OK#, contentHash=%s, executionState=%s",
                    response.getBlockHeight(),
                    response.getContentHash(), response.getExecutionState().toString()));
        } else {
            System.out.println(String.format("height=%d, ###exception#, contentHash=%s, executionState=%s",
                    response.getBlockHeight(),
                    response.getContentHash(), response.getExecutionState().toString()));
        }
        ret.setResponse(response);
        return ret;
    }
    /*
    注册用户并授权
     */
    public static ChainResponse registerUserAndConfigRole() {
        ChainResponse ret = new ChainResponse();
        ret.setState(false);
        // 新建交易
        TransactionTemplate txTemp = blockchainService.newTransaction(ledger);
        // 生成用户
        BlockchainKeypair user = BlockchainKeyGenerator.getInstance().generate();
        ret.setAddress(user.getAddress().toString());
        System.out.println("用户地址：" + user.getAddress());
        // 注册用户
        txTemp.users().register(user.getIdentity());

        // 创建角色 MANAGER
        txTemp.security().roles().configure("MANAGER")
                .enable(LedgerPermission.WRITE_DATA_ACCOUNT)
                .enable(TransactionPermission.DIRECT_OPERATION);

        // 设置用户角色权限
        txTemp.security().authorziations().forUser(user.getAddress()).authorize("MANAGER");
        // 交易主恩贝
        PreparedTransaction ptx = txTemp.prepare();
        // 交易签名
        ptx.sign(adminKey);
        // 提交交易
        TransactionResponse response = ptx.commit();
        if (response.isSuccess()) {
            ret.setState(true);
            System.out.println(String.format("height=%d, ###OK#, contentHash=%s, executionState=%s",
                    response.getBlockHeight(),
                    response.getContentHash(), response.getExecutionState().toString()));
        } else {
            System.out.println(String.format("height=%d, ###exception#, contentHash=%s, executionState=%s",
                    response.getBlockHeight(),
                    response.getContentHash(), response.getExecutionState().toString()));
        }
        ret.setResponse(response);
        return ret;
    }
    public static boolean registerUser() {
        // 新建交易
        TransactionTemplate txTemp = blockchainService.newTransaction(ledger);
        // 生成用户
        BlockchainKeypair user = BlockchainKeyGenerator.getInstance().generate();
        System.out.println("用户地址：" + user.getAddress());
        // 注册用户
        txTemp.users().register(user.getIdentity());
        // 交易准备
        PreparedTransaction ptx = txTemp.prepare();
        // 交易签名
        ptx.sign(adminKey);
        // 提交交易
        TransactionResponse response = ptx.commit();
        return response.isSuccess();
    }
    public static void createRole() {
        // 新建交易
        TransactionTemplate txTemp = blockchainService.newTransaction(ledger);

        // 创建角色 MANAGER ，并设置可以写数据账户，能执行交易
        txTemp.security().roles().configure("MANAGER")
                .enable(LedgerPermission.WRITE_DATA_ACCOUNT)
                .enable(TransactionPermission.DIRECT_OPERATION);
        // 交易准备
        PreparedTransaction ptx = txTemp.prepare();
        // 交易签名
        ptx.sign(adminKey);
        // 提交交易
        TransactionResponse response = ptx.commit();
        System.out.println("完成");
    }
    public static void configUserRole() {
        // 新建交易
        TransactionTemplate txTemp = blockchainService.newTransaction(ledger);

        // 给用户设置 MANAGER 角色权限
        txTemp.security().authorziations().forUser(Bytes.fromBase58("LdeNv7JLbcQidY98y2QYXK1dGmi589zjFrf4v")).authorize("MANAGER");
        // 交易准备
        PreparedTransaction ptx = txTemp.prepare();
        // 交易签名
        ptx.sign(adminKey);
        // 提交交易
        TransactionResponse response = ptx.commit();
        System.out.println("完成2");
    }
}

ConsoleApp

package org.example;

import com.jd.blockchain.contract.ContractEventContext;
import com.jd.blockchain.contract.EventProcessingAware;
import com.jd.blockchain.contract.LedgerContext;
import com.jd.blockchain.crypto.*;
import com.jd.blockchain.ledger.*;
import com.jd.blockchain.sdk.BlockchainService;
import com.jd.blockchain.sdk.client.GatewayServiceFactory;
import utils.Bytes;
import utils.codec.Base58Utils;

/**
 * Hello world!
 *
 */
public class App 
{
    // 账本Hash
    protected static HashDigest ledger;
    protected static BlockchainService blockchainService;
    protected static BlockchainKeypair adminKey;
    public static void main( String[] args )
    {
        String pubStr = "7VeR8q2oLa5dBgcSKi8AZ8ojpyDcVPP3pnaa4BCC7Kom5xhC";
        String privStr = "177gjvw6ePEW5GhThsQFUNXwu16MkaPEh8TPiEXjmNMj25UJUycaaZCYQ8rkucmYTqrJQ6H";
        String pwd = "8EjkXVSTxMFjCvNNsTo8RBMDEVQmk7gYkW4SCDuvdsBG";
        String ledgerAddr = "j5tos1z5oFXagUdJUuYjjjYC3rXYWn2kiDs4F4qVGBLz4N";
        String gateway = "192.168.10.8";
        Integer port =  10550;
        ChainHelper.Init(pubStr,privStr,pwd,ledgerAddr,gateway,port);

        String dataAccount = "LdeNve1fHLWCfRCm9J77pbWGDnR56xskKT3Mz";
        //ChainHelper.getDataEntries("LdeNve1fHLWCfRCm9J77pbWGDnR56xskKT3Mz","key4");
        ChainResponse ret = ChainHelper.setKV(dataAccount, "CorpName","xx有限公司");
        System.out.println(String.format("height=%d, ###exception#, contentHash=%s, executionState=%s",
                ret.getResponse().getBlockHeight(),
                ret.getResponse().getContentHash(), ret.getResponse().getExecutionState().toString()));
    }
}