1,prerequisites

1,setup a fabric network follows 《endorsement transaction》

2,create a project using a IDE. this case using vscode

2,system initial codes

package com.cares.fabrictest.config;

import java.util.EnumSet;
import java.util.Properties;

import com.cares.fabrictest.model.LocalUser;

import org.hyperledger.fabric.sdk.ChaincodeID;
import org.hyperledger.fabric.sdk.Channel;
import org.hyperledger.fabric.sdk.Enrollment;
import org.hyperledger.fabric.sdk.HFClient;
import org.hyperledger.fabric.sdk.Orderer;
import org.hyperledger.fabric.sdk.Peer;
import org.hyperledger.fabric.sdk.QueryByChaincodeRequest;
import org.hyperledger.fabric.sdk.TransactionProposalRequest;
import org.hyperledger.fabric.sdk.TransactionRequest;
import org.hyperledger.fabric.sdk.Channel.PeerOptions;
import org.hyperledger.fabric.sdk.Peer.PeerRole;
import org.hyperledger.fabric.sdk.security.CryptoSuite;
import org.hyperledger.fabric.sdk.security.CryptoSuiteFactory;
import org.hyperledger.fabric_ca.sdk.HFCAClient;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class Init {

    @Value("${ca.address}")
    String ca_address;

    @Value("${peer.address}")
    String peer_address;

    @Value("${peer.name}")
    String peer_name;

    @Value("${orderer.address}")
    String orderer_address;

    @Value("orderer.name")
    String orderer_name;

    @Value("${channelname}")
    String channelname;

    @Value("${chaincodename}")
    String chaincodename;

    @Value("${mspId}")
    String mspId;

    @Value("${adminuser}")
    String adminuser;

    @Value("${adminpass}")
    String adminpass;

    @Bean
    public HFCAClient caClient() {

        Properties props = new Properties();
        HFCAClient caClient = null;
        CryptoSuite cryptoSuite = null;
        try {
            props.put("allowAllHostNames", "true");
            // https加密的 CA需要 放置此属性  ca证书  props.put("pemBytes", new byte[0]);
            caClient = HFCAClient.createNewInstance(ca_address, props);
            cryptoSuite = CryptoSuiteFactory.getDefault().getCryptoSuite();
            caClient.setCryptoSuite(cryptoSuite);
        } catch (Exception e) {
            e.printStackTrace();
        }

        return caClient;
    }

    @Bean
    public HFClient hfClient(HFCAClient hfcaClient) {

        /*
         * String keyFile = "../solo-network/msp/keystore/user-key.pem"; String certFile
         * = "../solo-network/msp/signcerts/user-cert.pem";
         */
        HFClient client = null;
        try {
            Enrollment enrollment = hfcaClient.enroll(adminuser, adminpass);
            LocalUser user = new LocalUser("Admin", mspId, enrollment);
            client = HFClient.createNewInstance();
            client.setCryptoSuite(CryptoSuite.Factory.getCryptoSuite());
            client.setUserContext(user);
        } catch (Exception e) {

        }

        return client;
    }

    @Bean
    public Channel channel(HFClient hfClient) throws Exception {
        Channel channel = hfClient.newChannel(channelname);
        Peer peer = hfClient.newPeer(peer_name, peer_address);
        PeerOptions peerOptions = PeerOptions.createPeerOptions();
        EnumSet<PeerRole> roles = EnumSet.of(PeerRole.SERVICE_DISCOVERY);
        peerOptions.setPeerRoles(roles);
        channel.addPeer(peer,peerOptions);
        Orderer orderer = hfClient.newOrderer(orderer_name, orderer_address);
        channel.addOrderer(orderer);
        channel.initialize();

        return channel;
    }

    @Bean
    public ChaincodeID chaincodeID() {
        ChaincodeID cid = ChaincodeID.newBuilder().setName(chaincodename).build();
        return cid;
    }

    @Bean
    public QueryByChaincodeRequest queryByChaincodeRequest(HFClient hfClient, ChaincodeID cid) {
        QueryByChaincodeRequest req = hfClient.newQueryProposalRequest();
        req.setChaincodeID(cid);
        return req;
    }

    @Bean
    public TransactionProposalRequest transactionProposalRequest(ChaincodeID cid,HFClient hfClient) {
        TransactionProposalRequest transactionProposalRequest = hfClient.newTransactionProposalRequest();
        transactionProposalRequest.setChaincodeID(cid);
        transactionProposalRequest.setChaincodeLanguage(TransactionRequest.Type.JAVA);
        return transactionProposalRequest;
    }

}

3, service code

package com.cares.fabrictest.service.impl;

import java.util.Collection;
import java.util.concurrent.ExecutionException;

import com.cares.fabrictest.service.SecurityCheckService;

import org.hyperledger.fabric.sdk.BlockEvent;
import org.hyperledger.fabric.sdk.Channel;
import org.hyperledger.fabric.sdk.Channel.DiscoveryOptions;
import org.hyperledger.fabric.sdk.ProposalResponse;
import org.hyperledger.fabric.sdk.QueryByChaincodeRequest;
import org.hyperledger.fabric.sdk.TransactionProposalRequest;
import org.hyperledger.fabric.sdk.exception.InvalidArgumentException;
import org.hyperledger.fabric.sdk.exception.ProposalException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

@Service
public class SecurityCheckServiceImpl implements SecurityCheckService {

@Value("${airportCode}")
String airportCode;

@Autowired
Channel channel;

@Autowired
QueryByChaincodeRequest queryByChaincodeRequest;

@Autowired
TransactionProposalRequest transactionProposalRequest;


@Override
public String getHis(String id) {

    queryByChaincodeRequest.setFcn("queryCheckHis");
    queryByChaincodeRequest.setArgs(id);
    ProposalResponse[] rsp = new ProposalResponse[0];
    try {
        rsp = channel.queryByChaincode(queryByChaincodeRequest).toArray(new ProposalResponse[0]);
    } catch (InvalidArgumentException e) {
        e.printStackTrace();
    } catch (ProposalException e) {
        e.printStackTrace();
    }
    String ret = rsp[0].getProposalResponse().getResponse().getPayload().toStringUtf8();
    System.out.format("rsp message => %s\n",ret);
    return ret;
}

@Override
public void setCheckRecord(String id, String desc) {
    transactionProposalRequest.setFcn("saveCheck");
    transactionProposalRequest.setArgs(id,airportCode,desc);
    Collection<ProposalResponse> rsp2 = null;
    try {
        rsp2 = channel.sendTransactionProposal(transactionProposalRequest);
    } catch (ProposalException e) {
        e.printStackTrace();
    } catch (InvalidArgumentException e) {
        e.printStackTrace();
    }
    BlockEvent.TransactionEvent event = null;
    try {
        event = channel.sendTransaction(rsp2).get();
    } catch (InterruptedException e) {
        e.printStackTrace();
    } catch (ExecutionException e) {
        e.printStackTrace();
    }
    System.out.format("txid: %s\n", event.getTransactionID());
    System.out.format("valid: %b\n", event.isValid());
}

@Override
public String queryValueA() {


    queryByChaincodeRequest.setFcn("query");
    queryByChaincodeRequest.setArgs("a");
    ProposalResponse[] rsp = new ProposalResponse[0];
    try {
        rsp = channel.queryByChaincode(queryByChaincodeRequest).toArray(new ProposalResponse[0]);
    } catch (InvalidArgumentException e) {
        e.printStackTrace();
    } catch (ProposalException e) {
        e.printStackTrace();
    }
    String ret = rsp[0].getProposalResponse().getResponse().getPayload().toStringUtf8();
    return ret;
}

@Override
public void transfer(Long val) {
    transactionProposalRequest.setFcn("invoke");
    transactionProposalRequest.setArgs("a","b",val.toString());
    Collection<ProposalResponse> rsp2 = null;
    try {
        DiscoveryOptions discoveryOptions = DiscoveryOptions.createDiscoveryOptions();
        discoveryOptions.setForceDiscovery(true);
        rsp2 = channel.sendTransactionProposalToEndorsers(transactionProposalRequest,discoveryOptions);
    } catch (Exception e) {
        e.printStackTrace();
    } 

    BlockEvent.TransactionEvent event = null;
    try {
        event = channel.sendTransaction(rsp2).get();
    } catch (InterruptedException e) {
        e.printStackTrace();
    } catch (ExecutionException e) {
        e.printStackTrace();
    }
    System.out.format("txid: %s\n", event.getTransactionID());
    System.out.format("valid: %b\n", event.isValid());

}

}

4,测试代码

4.1 查询链码

    @Test
    void testCA() throws MalformedURLException {
        System.out.println(checkService.queryValueA());
    }

4.2 做背书交易

    @Test
    void testTransfer(){
        Integer before = Integer.valueOf(checkService.queryValueA());
        System.out.format("before transaction a=%s\n", before);
        checkService.transfer(1L);
        Integer after = Integer.valueOf(checkService.queryValueA());
        System.out.format("after transaction a=%s\n", after);
        assertThat(after, is(before-1));
    }

5,测试

6，GRPCS加密

加密方式与上述配置区别

6.1

peer 地址，orderer地址 要以grpcs 开头，fabric 组件都开启了 tls加密

channelname=securitycheck
chaincodename=securitycheck
orderer.address=grpcs://orderer.cares.com:7050
orderer.name=orderer.cares.com
spring.profiles.active=nkg
ca.address=https://192.168.53.50:6056
peer.address=grpcs://peer0.nkg.com:7051
peer.name=peer0.nkg.com
mspId=nkgMSP
airportCode=NKG
adminuser=Admin@nkg.com
adminpass=1

6.2 java bean

    @Bean
    public HFCAClient caClient() {

        Properties props = new Properties();
        HFCAClient caClient = null;
        CryptoSuite cryptoSuite = null;
        try {
            props.put("allowAllHostNames", "true");
            // https加密的 CA需要 放置此属性  ca证书  props.put("pemBytes", new byte[0]);
            ClassPathResource classPathResource = new ClassPathResource("nkg/ca-nkg-com-6056.pem");
            byte[] pems = FileUtils.readFileToByteArray(classPathResource.getFile());
            props.put("pemBytes", pems);
            caClient = HFCAClient.createNewInstance(ca_address, props);
            cryptoSuite = CryptoSuiteFactory.getDefault().getCryptoSuite();
            caClient.setCryptoSuite(cryptoSuite);
        } catch (Exception e) {
            e.printStackTrace();
        }

        return caClient;
    }

@Bean
    public Channel channel(HFClient hfClient) throws Exception {

        ClassPathResource classPathResource = new ClassPathResource("nkg/tls-tls-cares-com-6052.pem");
        byte[] pems = FileUtils.readFileToByteArray(classPathResource.getFile());


        Channel channel = hfClient.newChannel(channelname);
        Properties peerProps = new Properties();
        peerProps.put("pemBytes", pems);
        peerProps.put("sslProvider", "openSSL");
        peerProps.put("negotiationType", "TLS");
        Peer peer = hfClient.newPeer(peer_name, peer_address,peerProps);
        PeerOptions peerOptions = PeerOptions.createPeerOptions();
        EnumSet<PeerRole> roles = EnumSet.of(PeerRole.SERVICE_DISCOVERY);
        peerOptions.setPeerRoles(roles);
        channel.addPeer(peer,peerOptions);
        Properties orderProps = new Properties();
        orderProps.put("pemBytes", pems);
        orderProps.put("sslProvider", "openSSL");
        orderProps.put("negotiationType", "TLS");
        Orderer orderer = hfClient.newOrderer(orderer_name, orderer_address,orderProps);
        channel.addOrderer(orderer);
        channel.initialize();

        return channel;
    }

6.3 测试

---