fabric-sdk-go

区块链网络搭建

使用fabric-sample的网络结构用容器搭建起测试网络即可。

fabric-sdk代码

代码很简易，主要为了了解怎么使用fabric为编程人员提供的sdk从而提供HTTP接口的情况。

代码结构：

main.go:定义对外http接口的web路由，与程序的启动。
client.go:可以理解为./pkg/fabric/路径下的代码文件为chaincode，主要包含对链操作部分的代码----智能合约。
handler.go:http web接口的实现，在接口中通过调用智能合约实现对区块链的操作。
go.mod:golang环境相关文件。
go.sum:golang环境相关文件。

代码eg：

main.go

package main

import (
	"log"
	"my-fabric-sdk/pkg/fabric"
	customhttp "my-fabric-sdk/pkg/http"
	"net/http"
)

func main() {
	fabricClient, err := fabric.NewFabricClient("wallet", "connection-profile.yaml",
		"my_channel", "my_chaincode")

	if err != nil {
		log.Fatalf("Failed to create Fabric client: %v", err)
	}

	handler := customhttp.NewHandler(fabricClient)

	http.HandleFunc("/submit", handler.SubmitTransactionHandler)
	http.HandleFunc("/query", handler.QueryTransactionHandler)

	log.Println("Starting server on :8080")
	log.Fatal(http.ListenAndServe(":8080", nil))
}

client.go

package fabric

import (
	"fmt"
	"github.com/hyperledger/fabric-sdk-go/pkg/core/config"
	"github.com/hyperledger/fabric-sdk-go/pkg/gateway"
)

type FabricClient struct {
	Network  *gateway.Network
	Contract *gateway.Contract
}

func NewFabricClient(walletPath, connectionProfile, channelName, chaincodeID string) (*FabricClient, error) {
	// 加载钱包
	wallet, err := gateway.NewFileSystemWallet(walletPath)
	if err != nil {
		return nil, fmt.Errorf("failed to create wallet: %v", err)
	}

	// 设置 Fabric Gateway 的连接
	gateway, err := gateway.Connect(
		gateway.WithConfig(config.FromFile(connectionProfile)),
		gateway.WithIdentity(wallet, "User1"),
	)
	if err != nil {
		return nil, fmt.Errorf("failed to connect to gateway: %v", err)
	}

	// 获取网络通道
	network, err := gateway.GetNetwork(channelName)
	if err != nil {
		return nil, fmt.Errorf("failed to get network: %v", err)
	}

	// 获取智能合约
	contract := network.GetContract(chaincodeID)

	return &FabricClient{
		Network:  network,
		Contract: contract,
	}, nil
}

func (fc *FabricClient) SubmitTransaction(function string, args ...string) (string, error) {
	result, err := fc.Contract.SubmitTransaction(function, args...)
	if err != nil {
		return "", fmt.Errorf("failed to submit transaction: %v", err)
	}
	return string(result), nil
}

func (fc *FabricClient) QueryTransaction(function string, args ...string) (string, error) {
	result, err := fc.Contract.EvaluateTransaction(function, args...)
	if err != nil {
		return "", fmt.Errorf("failed to evaluate transaction: %v", err)
	}
	return string(result), nil
}

handler.go

package http

import (
	"encoding/json"
	"my-fabric-sdk/pkg/fabric"
	"net/http"
)

type Handler struct {
	FabricClient *fabric.FabricClient
}

func NewHandler(client *fabric.FabricClient) *Handler {
	return &Handler{
		FabricClient: client,
	}
}

func (h *Handler) SubmitTransactionHandler(w http.ResponseWriter, r *http.Request) {
	type request struct {
		Function string   `json:"function"`
		Args     []string `json:"args"`
	}

	var req request
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		http.Error(w, "Invalid request", http.StatusBadRequest)
		return
	}

	result, err := h.FabricClient.SubmitTransaction(req.Function, req.Args...)
	if err != nil {
		http.Error(w, "Transaction failed: "+err.Error(), http.StatusInternalServerError)
		return
	}

	w.WriteHeader(http.StatusOK)
	w.Write([]byte(result))
}

func (h *Handler) QueryTransactionHandler(w http.ResponseWriter, r *http.Request) {
	type request struct {
		Function string   `json:"function"`
		Args     []string `json:"args"`
	}

	var req request
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		http.Error(w, "Invalid request", http.StatusBadRequest)
		return
	}

	result, err := h.FabricClient.QueryTransaction(req.Function, req.Args...)
	if err != nil {
		http.Error(w, "Query failed: "+err.Error(), http.StatusInternalServerError)
		return
	}

	w.WriteHeader(http.StatusOK)
	w.Write([]byte(result))
}