FISCO BCOS Gin调用WeBASE-Front接口发请求

前提环境

需要提前搭建好一条FISCO-BCOS链和WeBASE-Front中间件

访问WeBase-Front

部署案例合约

pragma solidity>=0.4.24 <0.6.11;

contract HelloWorld {
    string name;

    constructor() public {
        name = "Hello, World!";
    }

    function get() public view returns (string memory) {
        return name;
    }

    function set(string memory n) public {
        name = n;
    }
}

获取合约地址、合约名称和合约ABI

使用GoLand创建一个工程

请求工具类

package util

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
)

type RequestData struct {
    GroupId         string        `json:"groupId"`
    User            string        `json:"user"`
    ContractName    string        `json:"contractName"`
    Version         string        `json:"version"`
    FuncName        string        `json:"funcName"`
    FuncParam       []interface{} `json:"funcParam"`
    ContractAddress string        `json:"contractAddress"`
    ContractAbi     []interface{} `json:"contractAbi"`
    UseAes          bool          `json:"useAes"`
    UseCns          bool          `json:"useCns"`
    CnsName         string        `json:"cnsName"`
}

var (
    contractAbi     = `[{"constant":false,"inputs":[{"name":"n","type":"string"}],"name":"set","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"get","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"inputs":[],"payable":false,"stateMutability":"nonpayable","type":"constructor"}]`
    contractName    = "HelloWorld"
	contractAddress = "0x3dd7ab770f48c8c828c3b7bd8b2e152764bb3a6c"
	transUrl        = "http://192.168.200.147:5002/WeBASE-Front/trans/handle"
	ownerAddress    = "0x7bccfc8f2eb60ade058b1427d2bfbb2bb8c37c2a"
)

func WriteContract(userAddress, funcName string, funcParam []interface{}) (map[string]interface{}, error) {
	// 调用 CommonReq 函数发送请求并获取响应
	result, err := CommonReq(userAddress, funcName, funcParam)
	if err != nil {
		return nil, err
	}

	// 解析返回的 JSON 数据
	var response map[string]interface{}
	err = json.Unmarshal([]byte(result), &response)
	if err != nil {
		return nil, err
	}

	// 判断交易是否成功
	if code, ok := response["code"].(float64); ok && code > 0 {
		// 失败时打印响应并返回错误
		fmt.Println(response)
		return nil, fmt.Errorf("transaction failed with code: %d", int(code))
	}

	// 检查状态是否为 "0x0"（表示成功）
	status, ok := response["status"].(string)
	if !ok || status != "0x0" {
		// 失败时打印响应并返回错误
		fmt.Println(response)
		return nil, fmt.Errorf("transaction failed with status: %s", status)
	}

	// 返回成功的响应数据
	return response, nil
}

func OwnerWriteContract(funcName string, funcParam []interface{}) (map[string]interface{}, error) {
	return WriteContract(ownerAddress, funcName, funcParam)
}

func CommonReq(userAddress, funcName string, funcParam []interface{}) (string, error) {
	// 解析合约的 ABI
	var abiJSON []interface{}
	err := json.Unmarshal([]byte(contractAbi), &abiJSON)
	if err != nil {
		return "", fmt.Errorf("error parsing ABI: %v", err)
	}

	// 构建请求数据
	data := RequestData{
		GroupId:         "1",
		User:            userAddress,
		ContractName:    contractName,
		Version:         "",
		FuncName:        funcName,
		FuncParam:       funcParam,
		ContractAddress: contractAddress,
		ContractAbi:     abiJSON,
		UseAes:          false,
		UseCns:          false,
		CnsName:         "",
	}

	// 将请求数据转为 JSON 字符串
	payloadBytes, err := json.Marshal(data)
	if err != nil {
		return "", fmt.Errorf("error marshalling data: %v", err)
	}

	// 发送 HTTP POST 请求
	resp, err := http.Post(transUrl, "application/json; charset=utf-8", bytes.NewBuffer(payloadBytes))
	if err != nil {
		return "", fmt.Errorf("error making POST request: %v", err)
	}
	defer resp.Body.Close()

	// 读取响应体
	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return "", fmt.Errorf("error reading response body: %v", err)
	}

	// 返回响应的字符串
	return string(body), nil
}

将contractAbi、contractName、contractAddress、ownerAddress改成在wefront-front部署abi、合约名称、合约地址、部署合约用户

transUrl的IP改成对应虚拟机IP

编写实体

package entity

type HelloWorld struct {
	Name string `json:"name"`
}

编写服务层

package service

import (
	"SDK/entity"
	"SDK/util"
	"log"
)

// Set 函数用于设置 HelloWorld 实体
func Set(helloworld *entity.HelloWorld) bool {
	funcParams := []interface{}{
		helloworld.Name,
	}

	res, err := util.OwnerWriteContract("set", funcParams)
	if err != nil || res == nil {
		log.Printf("set失败: %v", err)
		return false
	}

	return true
}

编写控制层

package controller

import (
	"SDK/entity"
	"SDK/service"
	"github.com/gin-gonic/gin"
	"net/http"
)

// Set 处理 POST 请求以设置 HelloWorld 实体
func Set(c *gin.Context) {
	var helloworld entity.HelloWorld

	// 将 JSON 数据绑定到 HelloWorld 结构体
	if err := c.ShouldBindJSON(&helloworld); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	// 调用服务层以设置 HelloWorld 实体
	if success := service.Set(&helloworld); !success {
		c.JSON(http.StatusInternalServerError, gin.H{"error": "fail"})
		return
	}

	// 返回成功响应
	c.JSON(http.StatusOK, gin.H{"message": "success"})
}

编写路由

package router

import (
	"SDK/controller"
	"github.com/gin-gonic/gin"
)

func SetupRouter() *gin.Engine {
	// 创建一个新的 Gin 引擎并手动添加中间件
	r := gin.New()
	r.Use(gin.Logger(), gin.Recovery()) // 手动添加 Logger 和 Recovery 中间件

	// 设置路由
	r.POST("/set", controller.Set)

	return r
}

编写main.go

package main

import (
	"SDK/router"
	"log"
)

func main() {
	r := router.SetupRouter() // 通过 SetupRouter 获取初始化好的路由

	// 启动服务器
	if err := r.Run("127.0.0.1:8080"); err != nil {
		log.Fatalf("Unable to start the server: %v", err)
	}
}

Postman测试

合约查看结果