某位大神万字长文，教你用go开发区块链应用，太强了

version: 2.1

volumes:
orderer.qq.com:
peer0.taobao.com:
peer1.taobao.com:
peer0.jd.com:
peer1.jd.com:

networks:
fabric_network:
name: fabric_network

services:
# 排序服务节点
orderer.qq.com:
container_name: orderer.qq.com
image: hyperledger/fabric-orderer:1.4.12
environment:
– GODEBUG=netdns=go
– ORDERER_GENERAL_LISTENADDRESS=0.0.0.0
– ORDERER_GENERAL_GENESISMETHOD=file
– ORDERER_GENERAL_GENESISFILE=/etc/hyperledger/config/genesis.block # 注入创世区块
– ORDERER_GENERAL_LOCALMSPID=QQMSP
– ORDERER_GENERAL_LOCALMSPDIR=/etc/hyperledger/orderer/msp # 证书相关
command: orderer
ports:
– “7050:7050”
volumes: # 挂载由cryptogen和configtxgen生成的证书文件以及创世区块
– ./config/genesis.block:/etc/hyperledger/config/genesis.block
– ./crypto-config/ordererOrganizations/qq.com/orderers/orderer.qq.com/:/etc/hyperledger/orderer
– orderer.qq.com:/var/hyperledger/production/orderer
networks:
– fabric_network

# Taobao 组织 peer0 节点
peer0.taobao.com:
extends:
file: docker-compose-base.yaml
service: peer-base
container_name: peer0.taobao.com
environment:
– CORE_PEER_ID=peer0.taobao.com
– CORE_PEER_LOCALMSPID=TaobaoMSP
– CORE_PEER_ADDRESS=peer0.taobao.com:7051
ports:
– “7051:7051” # grpc服务端口
– “7053:7053” # eventhub端口
volumes:
– ./crypto-config/peerOrganizations/taobao.com/peers/peer0.taobao.com:/etc/hyperledger/peer
– peer0.taobao.com:/var/hyperledger/production
depends_on:
– orderer.qq.com

# Taobao 组织 peer1 节点
peer1.taobao.com:
extends:
file: docker-compose-base.yaml
service: peer-base
container_name: peer1.taobao.com
environment:
– CORE_PEER_ID=peer1.taobao.com
– CORE_PEER_LOCALMSPID=TaobaoMSP
– CORE_PEER_ADDRESS=peer1.taobao.com:7051
ports:
– “17051:7051”
– “17053:7053”
volumes:
– ./crypto-config/peerOrganizations/taobao.com/peers/peer1.taobao.com:/etc/hyperledger/peer
– peer1.taobao.com:/var/hyperledger/production
depends_on:
– orderer.qq.com

# JD 组织 peer0 节点
peer0.jd.com:
extends:
file: docker-compose-base.yaml
service: peer-base
container_name: peer0.jd.com
environment:
– CORE_PEER_ID=peer0.jd.com
– CORE_PEER_LOCALMSPID=JDMSP
– CORE_PEER_ADDRESS=peer0.jd.com:7051
ports:
– “27051:7051”
– “27053:7053”
volumes:
– ./crypto-config/peerOrganizations/jd.com/peers/peer0.jd.com:/etc/hyperledger/peer
– peer0.jd.com:/var/hyperledger/production
depends_on:
– orderer.qq.com

# JD 组织 peer1 节点
peer1.jd.com:
extends:
file: docker-compose-base.yaml
service: peer-base
container_name: peer1.jd.com
environment:
– CORE_PEER_ID=peer1.jd.com
– CORE_PEER_LOCALMSPID=JDMSP
– CORE_PEER_ADDRESS=peer1.jd.com:7051
ports:
– “37051:7051”
– “37053:7053”
volumes:
– ./crypto-config/peerOrganizations/jd.com/peers/peer1.jd.com:/etc/hyperledger/peer
– peer1.jd.com:/var/hyperledger/production
depends_on:
– orderer.qq.com

# 客户端节点
cli:
container_name: cli
image: hyperledger/fabric-tools:1.4.12
tty: true
environment:
# go 环境设置
– GO111MODULE=auto
– GOPROXY=https://goproxy.cn
– CORE_PEER_ID=cli
command: /bin/bash
volumes:
– ./config:/etc/hyperledger/config
– ./crypto-config/peerOrganizations/taobao.com/:/etc/hyperledger/peer/taobao.com
– ./crypto-config/peerOrganizations/jd.com/:/etc/hyperledger/peer/jd.com
– ./../chaincode:/opt/gopath/src/chaincode # 链码路径注入
networks:
– fabric_network
depends_on:
– orderer.qq.com
– peer0.taobao.com
– peer1.taobao.com
– peer0.jd.com
– peer1.jd.com

version: 2.1

services:
peer-base: # peer的公共服务
image: hyperledger/fabric-peer:1.4.12
environment:
– GODEBUG=netdns=go
– CORE_VM_ENDPOINT=unix:///host/var/run/docker.sock
– CORE_LOGGING_PEER=info
– CORE_CHAINCODE_LOGGING_LEVEL=INFO
– CORE_PEER_MSPCONFIGPATH=/etc/hyperledger/peer/msp # msp证书（节点证书）
– CORE_LEDGER_STATE_STATEDATABASE=goleveldb # 状态数据库的存储引擎（or CouchDB）
– CORE_VM_DOCKER_HOSTCONFIG_NETWORKMODE=fabric_network # docker 网络
volumes:
– /var/run/docker.sock:/host/var/run/docker.sock
working_dir: /opt/gopath/src/github.com/hyperledger/fabric
command: peer node start
networks:
– fabric_network

package main

import (
“fmt”

“github.com/hyperledger/fabric/core/chaincode/shim”
pb “github.com/hyperledger/fabric/protos/peer”
)

type MyChaincode struct {
}

// Init 初始化时会执行该方法
func (c *MyChaincode) Init(stub shim.ChaincodeStubInterface) pb.Response {
fmt.Println(“链码初始化”)
return shim.Success(nil)
}

// Invoke 智能合约的功能函数定义
func (c *MyChaincode) Invoke(stub shim.ChaincodeStubInterface) pb.Response {
funcName, args := stub.GetFunctionAndParameters()
switch funcName {

default:
return shim.Error(fmt.Sprintf(“没有该功能: %s”, funcName))
}
}

func main() {
err := shim.Start(new(MyChaincode))
if err != nil {
panic(err)
}
}

package main

import (
“encoding/json”
“errors”
“fmt”
“strconv”

“github.com/hyperledger/fabric/core/chaincode/shim”
pb “github.com/hyperledger/fabric/protos/peer”
)

type MyChaincode struct {
}

// Init 初始化时会执行该方法
func (c *MyChaincode) Init(stub shim.ChaincodeStubInterface) pb.Response {
fmt.Println(“链码初始化”)
// 假设A有1000元，以复合主键 userA 的形式写入账本
err := WriteLedger(stub, map[string]interface{}{“name”: “A”, “balance”: 1000}, “user”, []string{“A”})
if err != nil {
return shim.Error(err.Error())
}
// 假设B有1000元，以复合主键 userB 的形式写入账本
err = WriteLedger(stub, map[string]interface{}{“name”: “B”, “balance”: 1000}, “user”, []string{“B”})
if err != nil {
return shim.Error(err.Error())
}
return shim.Success(nil)
}

// Invoke 智能合约的功能函数定义
func (c *MyChaincode) Invoke(stub shim.ChaincodeStubInterface) pb.Response {
funcName, args := stub.GetFunctionAndParameters()
switch funcName {
case “query”:
return query(stub, args)
case “transfer”:
return transfer(stub, args)
default:
return shim.Error(fmt.Sprintf(“没有该功能: %s”, funcName))
}
}

func query(stub shim.ChaincodeStubInterface, args []string) pb.Response {
// 如果 args 为空，则表示查询所有 user
results, err := ReadLedger(stub, “user”, args)
if err != nil {
return shim.Error(err.Error())
}
var users []map[string]interface{}
for _, result := range results {
var user map[string]interface{}
if err = json.Unmarshal(result, &user); err != nil {
return shim.Error(err.Error())
}
users = append(users, user)
}
usersByte, err := json.Marshal(&users)
if err != nil {
return shim.Error(err.Error())
}
return shim.Success(usersByte)
}

func transfer(stub shim.ChaincodeStubInterface, args []string) pb.Response {
// 验证参数
if len(args) != 3 {
return shim.Error(“参数个数不满足”)
}
from := args[0]
to := args[1]
money, err := strconv.ParseFloat(args[2], 64)
if err != nil {
return shim.Error(err.Error())
}
// 从账本查询 from 用户
fromResults, err := ReadLedger(stub, “user”, []string{from})
if err != nil {
return shim.Error(err.Error())
}
if len(fromResults) != 1 {
return shim.Error(“没有该用户 ” + from)
}
var fromUser map[string]interface{}
if err = json.Unmarshal(fromResults[0], &fromUser); err != nil {
return shim.Error(err.Error())
}
// 从账本查询 to 用户
toResults, err := ReadLedger(stub, “user”, []string{to})
if err != nil {
return shim.Error(err.Error())
}
if len(toResults) != 1 {
return shim.Error(“没有该用户 ” + to)
}
var toUser map[string]interface{}
if err = json.Unmarshal(toResults[0], &toUser); err != nil {
return shim.Error(err.Error())
}
// from 用户扣除余额
if money > fromUser[“balance”].(float64) {
return shim.Error(“余额不足”)
}
fromUser[“balance”] = fromUser[“balance”].(float64) – money
// to 用户增加余额
toUser[“balance”] = toUser[“balance”].(float64) + money
// 写回账本
err = WriteLedger(stub, fromUser, “user”, []string{from})
if err != nil {
return shim.Error(err.Error())
}
err = WriteLedger(stub, toUser, “user”, []string{to})
if err != nil {
return shim.Error(err.Error())
}
return shim.Success([]byte(“ok”))
}

func main() {
err := shim.Start(new(MyChaincode))
if err != nil {
panic(err)
}
}

// WriteLedger 写入账本
// obj 为要写入的数据
// objectType和keys 共同组成复合主键
func WriteLedger(stub shim.ChaincodeStubInterface, obj interface{}, objectType string, keys []string) error {
//创建复合主键
var key string
if val, err := stub.CreateCompositeKey(objectType, keys); err != nil {
return errors.New(fmt.Sprintf(“%s-创建复合主键出错 %s”, objectType, err.Error()))
} else {
key = val
}
bytes, err := json.Marshal(obj)
if err != nil {
return err
}
//写入区块链账本
if err := stub.PutState(key, bytes); err != nil {
return errors.New(fmt.Sprintf(“%s-写入区块链账本出错: %s”, objectType, err.Error()))
}
return nil
}

// ReadLedger 根据复合主键查询账本数据(适合获取全部或指定的数据)
// objectType和keys 共同组成复合主键
func ReadLedger(stub shim.ChaincodeStubInterface, objectType string, keys []string) (results [][]byte, err error) {
// 通过主键从区块链查找相关的数据，相当于对主键的模糊查询
resultIterator, err := stub.GetStateByPartialCompositeKey(objectType, keys)
if err != nil {
return nil, errors.New(fmt.Sprintf(“%s-获取全部数据出错: %s”, objectType, err))
}
defer resultIterator.Close()

//检查返回的数据是否为空，不为空则遍历数据，否则返回空数组
for resultIterator.HasNext() {
val, err := resultIterator.Next()
if err != nil {
return nil, errors.New(fmt.Sprintf(“%s-返回的数据出错: %s”, objectType, err))
}

results = append(results, val.GetValue())
}
return results, nil
}

version: 1.0.0

# GO SDK 客户端配置
client:
# 客户端所属的组织，必须是organizations定义的组织
organization: JD
# 日志级别
logging:
level: info
# MSP证书的根路径
cryptoconfig:
path: /network/crypto-config

# 通道定义
channels:
appchannel:
orderers:
– orderer.qq.com
peers:
peer0.jd.com:
endorsingPeer: true
chaincodeQuery: true
ledgerQuery: true
eventSource: true
peer1.jd.com:
endorsingPeer: true
chaincodeQuery: true
ledgerQuery: true
eventSource: true

# 组织配置
organizations:
JD:
mspid: “JDMSP”
cryptoPath: peerOrganizations/jd.com/users/{username}@jd.com/msp
peers:
– peer0.jd.com
– peer1.jd.com

# orderer节点列表
orderers:
orderer.qq.com:
url: orderer.qq.com:7050
# 传递给gRPC客户端构造函数
grpcOptions:
ssl-target-name-override: orderer.qq.com
keep-alive-time: 0s
keep-alive-timeout: 20s
keep-alive-permit: false
fail-fast: false
allow-insecure: true

# peers节点列表
peers:
# peer节点定义，可以定义多个
peer0.jd.com:
# URL用于发送背书和查询请求
url: peer0.jd.com:7051
# 传递给gRPC客户端构造函数
grpcOptions:
ssl-target-name-override: peer0.jd.com
keep-alive-time: 0s
keep-alive-timeout: 20s
keep-alive-permit: false
fail-fast: false
allow-insecure: true
peer1.jd.com:
url: peer1.jd.com:7051
grpcOptions:
ssl-target-name-override: peer1.jd.com
keep-alive-time: 0s
keep-alive-timeout: 20s
keep-alive-permit: false
fail-fast: false
allow-insecure: true
peer0.taobao.com:
url: peer0.taobao.com:7051
grpcOptions:
ssl-target-name-override: peer0.taobao.com
keep-alive-time: 0s
keep-alive-timeout: 20s
keep-alive-permit: false
fail-fast: false
allow-insecure: true
peer1.taobao.com:
url: peer1.taobao.com:7051
grpcOptions:
ssl-target-name-override: peer1.taobao.com
keep-alive-time: 0s
keep-alive-timeout: 20s
keep-alive-permit: false
fail-fast: false
allow-insecure: true

package main

import (
“github.com/hyperledger/fabric-sdk-go/pkg/client/channel”
“github.com/hyperledger/fabric-sdk-go/pkg/core/config”
“github.com/hyperledger/fabric-sdk-go/pkg/fabsdk”
)

// 配置信息
var (
sdk *fabsdk.FabricSDK // Fabric SDK
channelName = “appchannel” // 通道名称
username = “Admin” // 用户
chainCodeName = “fabric-realty” // 链码名称
endpoints = []string{“peer0.jd.com”, “peer0.taobao.com”} // 要发送交易的节点
)

// init 初始化
func init() {
var err error
// 通过配置文件初始化SDK
sdk, err = fabsdk.New(config.FromFile(“config.yaml”))
if err != nil {
panic(err)
}
}

// ChannelExecute 区块链交互
func ChannelExecute(fcn string, args [][]byte) (channel.Response, error) {
// 创建客户端，表明在通道的身份
ctx := sdk.ChannelContext(channelName, fabsdk.WithUser(username))
cli, err := channel.New(ctx)
if err != nil {
return channel.Response{}, err
}
// 对区块链账本的写操作（调用了链码的invoke）
resp, err := cli.Execute(channel.Request{
ChaincodeID: chainCodeName,
Fcn: fcn,
Args: args,
}, channel.WithTargetEndpoints(endpoints…))
if err != nil {
return channel.Response{}, err
}
//返回链码执行后的结果
return resp, nil
}

// ChannelQuery 区块链查询
func ChannelQuery(fcn string, args [][]byte) (channel.Response, error) {
// 创建客户端，表明在通道的身份
ctx := sdk.ChannelContext(channelName, fabsdk.WithUser(username))
cli, err := channel.New(ctx)
if err != nil {
return channel.Response{}, err
}
// 对区块链账本查询的操作（调用了链码的invoke），只返回结果
resp, err := cli.Query(channel.Request{
ChaincodeID: chainCodeName,
Fcn: fcn,
Args: args,
}, channel.WithTargetEndpoints(endpoints…))
if err != nil {
return channel.Response{}, err
}
//返回链码执行后的结果
return resp, nil
}

package main

import (
“bytes”
“encoding/json”

“github.com/gin-gonic/gin”
)

func main() {
g := gin.Default()
g.GET(“/query”, func(c *gin.Context) {
args := make([][]byte, 0)
user := c.Query(“user”)
if user != “” {
args = append(args, []byte(user))
}
// 调用链码的query函数
resp, err := ChannelQuery(“query”, args)
if err != nil {
c.AbortWithStatusJSON(500, gin.H{“err”: err.Error()})
return
}
var data []map[string]interface{}
if err = json.Unmarshal(bytes.NewBuffer(resp.Payload).Bytes(), &data); err != nil {
c.AbortWithStatusJSON(500, gin.H{“err”: err.Error()})
return
}
c.JSON(200, data)
})
g.POST(“/transfer”, func(c *gin.Context) {
from := c.Query(“from”)
to := c.Query(“to”)
money := c.Query(“money”)
if from == “” || to == “” || money == “” {
c.AbortWithStatusJSON(400, gin.H{“err”: “参数不能为空”})
return
}
args := make([][]byte, 0)
args = append(args, []byte(from), []byte(to), []byte(money))
// 调用链码的transfer函数
resp, err := ChannelExecute(“transfer”, args)
if err != nil {
c.AbortWithStatusJSON(500, gin.H{“err”: err.Error()})
return
}
c.JSON(200, gin.H{“msg”: string(resp.Payload)})
})
g.Run(“0.0.0.0:8000”)
}

version: 2.1

networks:
fabric_network:
external:
name: fabric_network

services:
app:
build: .
image: app:latest
ports:
– “8000:8000”
volumes:
– ./../network/crypto-config:/network/crypto-config # 挂载搭建区块链网络时生成的crypto-config文件夹
networks:
– fabric_network