• Gin+getway+Fabric2.4.4演示

    今天演示一下Gin+Gateway+Fabric2.4.4结合，从区块账本抓取数据显示到前端。

    前提环境：Gin，Gateway，Fabric2.4.4环境。

    如何部署Fabric2.4.4环境看我这篇博客：指路：fabric2.4.4版本搭建过程（完整过程）_keep_top的博客-CSDN博客_fabric 搭建

    首先，我摸看一下gin的模板：

    1. package main
    2.  
    3. import (
    4. 	"fmt"
    5. 	"github.com/gin-gonic/gin"
    6. )
    7.  
    8. type Stu struct {
    9. 	Name string `form:"name"`
    10. 	Id   string `form:"id"`
    11. 	Age  string `form:"age"`
    12. }
    13.  
    14. func main() {
    15. 	r := gin.Default()
    16. 	var stu Stu
    17. 	r1 := r.Group("/fabric2.4")
    18. 	r1.POST("/setstu", func(c *gin.Context) {
    19. 		//var stu Stu
    20. 		c.ShouldBind(&stu)
    21. 		c.JSON(200, stu)
    22. 		fmt.Println("stu:", stu)
    23. 	})
    24. 	r1.POST("/ok1", func(c *gin.Context) {
    25. 		c.JSON(200, "ok1")
    26. 	})
    27. 	r.Run(":8080") // 监听并在 0.0.0.0:8080 上启动服务
    28.  
    29. }

    解释一下：

    这里定义的结构体Stu，可以表示在前端输入结构体的信息，在后端拿到这个结构体的值，后续我们会定义链码中的结构体，用来获取账本中的数据和前端输入数据存入账本，进行演示。

    以下是链码的只要功能部分：

    1. package chaincode
    2.  
    3. import (
    4. 	"encoding/json"
    5. 	"fmt"
    6.  
    7. 	"github.com/hyperledger/fabric-contract-api-go/contractapi"
    8. )
    9.  
    10. // SmartContract provides functions for managing an Asset
    11. type SmartContract struct {
    12. 	contractapi.Contract
    13. }
    14.  
    15. // Asset describes basic details of what makes up a simple asset
    16. //Insert struct field in alphabetic order => to achieve determinism across languages
    17. // golang keeps the order when marshal to json but doesn't order automatically
    18. type Asset struct {
    19. 	AppraisedValue int    `json:"AppraisedValue"`
    20. 	Color          string `json:"Color"`
    21. 	ID             string `json:"ID"`
    22. 	Owner          string `json:"Owner"`
    23. 	Size           int    `json:"Size"`
    24. }
    25.  
    26. // InitLedger adds a base set of assets to the ledger
    27. func (s *SmartContract) InitLedger(ctx contractapi.TransactionContextInterface) error {
    28. 	assets := []Asset{
    29. 		{ID: "asset1", Color: "blue", Size: 5, Owner: "Tomoko", AppraisedValue: 300},
    30. 		{ID: "asset2", Color: "red", Size: 5, Owner: "Brad", AppraisedValue: 400},
    31. 		{ID: "asset3", Color: "green", Size: 10, Owner: "Jin Soo", AppraisedValue: 500},
    32. 		{ID: "asset4", Color: "yellow", Size: 10, Owner: "Max", AppraisedValue: 600},
    33. 		{ID: "asset5", Color: "black", Size: 15, Owner: "Adriana", AppraisedValue: 700},
    34. 		{ID: "asset6", Color: "white", Size: 15, Owner: "Michel", AppraisedValue: 800},
    35. 	}
    36.  
    37. 	for _, asset := range assets {
    38. 		assetJSON, err := json.Marshal(asset)
    39. 		if err != nil {
    40. 			return err
    41. 		}
    42.  
    43. 		err = ctx.GetStub().PutState(asset.ID, assetJSON)
    44. 		if err != nil {
    45. 			return fmt.Errorf("failed to put to world state. %v", err)
    46. 		}
    47. 	}
    48.  
    49. 	return nil
    50. }
    51.  
    52. // CreateAsset issues a new asset to the world state with given details.
    53. func (s *SmartContract) CreateAsset(ctx contractapi.TransactionContextInterface, id string, color string, size int, owner string, appraisedValue int) error {
    54. 	exists, err := s.AssetExists(ctx, id)
    55. 	if err != nil {
    56. 		return err
    57. 	}
    58. 	if exists {
    59. 		return fmt.Errorf("the asset %s already exists", id)
    60. 	}
    61.  
    62. 	asset := Asset{
    63. 		ID:             id,
    64. 		Color:          color,
    65. 		Size:           size,
    66. 		Owner:          owner,
    67. 		AppraisedValue: appraisedValue,
    68. 	}
    69. 	assetJSON, err := json.Marshal(asset)
    70. 	if err != nil {
    71. 		return err
    72. 	}
    73.  
    74. 	return ctx.GetStub().PutState(id, assetJSON)
    75. }
    76.  
    77. // ReadAsset returns the asset stored in the world state with given id.
    78. func (s *SmartContract) ReadAsset(ctx contractapi.TransactionContextInterface, id string) (*Asset, error) {
    79. 	assetJSON, err := ctx.GetStub().GetState(id)
    80. 	if err != nil {
    81. 		return nil, fmt.Errorf("failed to read from world state: %v", err)
    82. 	}
    83. 	if assetJSON == nil {
    84. 		return nil, fmt.Errorf("the asset %s does not exist", id)
    85. 	}
    86.  
    87. 	var asset Asset
    88. 	err = json.Unmarshal(assetJSON, &asset)
    89. 	if err != nil {
    90. 		return nil, err
    91. 	}
    92.  
    93. 	return &asset, nil
    94. }
    95.  
    96. // UpdateAsset updates an existing asset in the world state with provided parameters.
    97. func (s *SmartContract) UpdateAsset(ctx contractapi.TransactionContextInterface, id string, color string, size int, owner string, appraisedValue int) error {
    98. 	exists, err := s.AssetExists(ctx, id)
    99. 	if err != nil {
    100. 		return err
    101. 	}
    102. 	if !exists {
    103. 		return fmt.Errorf("the asset %s does not exist", id)
    104. 	}
    105.  
    106. 	// overwriting original asset with new asset
    107. 	asset := Asset{
    108. 		ID:             id,
    109. 		Color:          color,
    110. 		Size:           size,
    111. 		Owner:          owner,
    112. 		AppraisedValue: appraisedValue,
    113. 	}
    114. 	assetJSON, err := json.Marshal(asset)
    115. 	if err != nil {
    116. 		return err
    117. 	}
    118.  
    119. 	return ctx.GetStub().PutState(id, assetJSON)
    120. }
    121.  
    122. // DeleteAsset deletes an given asset from the world state.
    123. func (s *SmartContract) DeleteAsset(ctx contractapi.TransactionContextInterface, id string) error {
    124. 	exists, err := s.AssetExists(ctx, id)
    125. 	if err != nil {
    126. 		return err
    127. 	}
    128. 	if !exists {
    129. 		return fmt.Errorf("the asset %s does not exist", id)
    130. 	}
    131.  
    132. 	return ctx.GetStub().DelState(id)
    133. }
    134.  
    135. // AssetExists returns true when asset with given ID exists in world state
    136. func (s *SmartContract) AssetExists(ctx contractapi.TransactionContextInterface, id string) (bool, error) {
    137. 	assetJSON, err := ctx.GetStub().GetState(id)
    138. 	if err != nil {
    139. 		return false, fmt.Errorf("failed to read from world state: %v", err)
    140. 	}
    141.  
    142. 	return assetJSON != nil, nil
    143. }
    144.  
    145. // TransferAsset updates the owner field of asset with given id in world state, and returns the old owner.
    146. func (s *SmartContract) TransferAsset(ctx contractapi.TransactionContextInterface, id string, newOwner string) (string, error) {
    147. 	asset, err := s.ReadAsset(ctx, id)
    148. 	if err != nil {
    149. 		return "", err
    150. 	}
    151.  
    152. 	oldOwner := asset.Owner
    153. 	asset.Owner = newOwner
    154.  
    155. 	assetJSON, err := json.Marshal(asset)
    156. 	if err != nil {
    157. 		return "", err
    158. 	}
    159.  
    160. 	err = ctx.GetStub().PutState(id, assetJSON)
    161. 	if err != nil {
    162. 		return "", err
    163. 	}
    164.  
    165. 	return oldOwner, nil
    166. }
    167.  
    168. // GetAllAssets returns all assets found in world state
    169. func (s *SmartContract) GetAllAssets(ctx contractapi.TransactionContextInterface) ([]*Asset, error) {
    170. 	// range query with empty string for startKey and endKey does an
    171. 	// open-ended query of all assets in the chaincode namespace.
    172. 	resultsIterator, err := ctx.GetStub().GetStateByRange("", "")
    173. 	if err != nil {
    174. 		return nil, err
    175. 	}
    176. 	defer resultsIterator.Close()
    177.  
    178. 	var assets []*Asset
    179. 	for resultsIterator.HasNext() {
    180. 		queryResponse, err := resultsIterator.Next()
    181. 		if err != nil {
    182. 			return nil, err
    183. 		}
    184.  
    185. 		var asset Asset
    186. 		err = json.Unmarshal(queryResponse.Value, &asset)
    187. 		if err != nil {
    188. 			return nil, err
    189. 		}
    190. 		assets = append(assets, &asset)
    191. 	}
    192.  
    193. 	return assets, nil
    194. }

    这是官方的链码，大家可以在fabric中自己找到。

    这里需要把证书文件拉到goland中，注意，因为goland是在宿主机（windows）中的，所以需要在虚拟机中把证书文件拉到window上面：

     

     我们更改路径：

    查看虚拟机的ip地址：

     这是需要更改的路径：

     运行这个go文件：

    显示：

     连接虚拟机成功了，也就是连接fabric底层成功了！

    接下来我们结合一下gin的部分：

    首先我们需要导入证书文件：

    如果报错了，基本上就是证书文件对不上的原因！注意，fabric网络每次重启后证书文件都会重新生成，所以每次重启了fabric网络，证书文件都需要更换！ 

    贴代码：

    1. package main
    2.  
    3. import (
    4. 	"bytes"
    5. 	"crypto/x509"
    6. 	"encoding/json"
    7. 	"fmt"
    8. 	"github.com/gin-gonic/gin"
    9. 	"github.com/hyperledger/fabric-gateway/pkg/client"
    10. 	"github.com/hyperledger/fabric-gateway/pkg/identity"
    11. 	"google.golang.org/grpc"
    12. 	"google.golang.org/grpc/credentials"
    13. 	"io/ioutil"
    14. 	"path"
    15. 	"time"
    16. )
    17.  
    18. const (
    19. 	mspID         = "Org1MSP"
    20. 	cryptoPath    = "./peerOrganizations/org1.example.com"
    21. 	certPath      = cryptoPath + "/users/User1@org1.example.com/msp/signcerts/cert.pem"
    22. 	keyPath       = cryptoPath + "/users/User1@org1.example.com/msp/keystore/"
    23. 	tlsCertPath   = cryptoPath + "/peers/peer0.org1.example.com/tls/ca.crt"
    24. 	peerEndpoint  = "192.168.136.130:7051"
    25. 	gatewayPeer   = "peer0.org1.example.com"
    26. 	channelName   = "mychannel"
    27. 	chaincodeName = "basic"
    28. )
    29.  
    30. type Asset struct {
    31. 	AppraisedValue int    `form:"appraisedValue" json:"appraisedValue" `
    32. 	Color          string `form:"color" json:"color"`
    33. 	ID             string `form:"id" json:"id"`
    34. 	Owner          string `form:"owner" json:"owner"`
    35. 	Size           int    `form:"size" json:"size"`
    36. }
    37.  
    38. func main() {
    39. 	// The gRPC client connection should be shared by all Gateway connections to this endpoint
    40. 	clientConnection := newGrpcConnection()
    41. 	defer clientConnection.Close()
    42.  
    43. 	id := newIdentity()
    44. 	sign := newSign()
    45.  
    46. 	// Create a Gateway connection for a specific client identity
    47. 	gateway, err := client.Connect(
    48. 		id,
    49. 		client.WithSign(sign),
    50. 		client.WithClientConnection(clientConnection),
    51. 		// Default timeouts for different gRPC calls
    52. 		client.WithEvaluateTimeout(5*time.Second),
    53. 		client.WithEndorseTimeout(15*time.Second),
    54. 		client.WithSubmitTimeout(5*time.Second),
    55. 		client.WithCommitStatusTimeout(1*time.Minute),
    56. 	)
    57. 	if err != nil {
    58. 		panic(err)
    59. 	}
    60. 	defer gateway.Close()
    61. 	network := gateway.GetNetwork(channelName)
    62. 	contract := network.GetContract(chaincodeName)
    63.  
    64. 	r := gin.Default()
    65. 	r1 := r.Group("/fabric2.4")
    66. 	r1.POST("/CreateAsset", func(c *gin.Context) {
    67. 		var asset Asset
    68. 		c.ShouldBind(&asset)
    69. 		c.JSON(200, asset)
    70. 		marshal, _ := json.Marshal(asset)
    71. 		fmt.Println(string(marshal))
    72. 		fmt.Println("asset:", asset)
    73. 	})
    74. 	r1.POST("/GetAllAssets", func(c *gin.Context) {
    75. 		result := getAllAssets(contract)
    76. 		c.JSON(200, result)
    77. 	})
    78. 	r.Run(":8080") // 监听并在 0.0.0.0:8080 上启动服务
    79.  
    80. }
    81.  
    82. // Evaluate a transaction to query ledger state.
    83. func getAllAssets(contract *client.Contract) string {
    84. 	fmt.Println("Evaluate Transaction: GetAllAssets, function returns all the current assets on the ledger")
    85.  
    86. 	evaluateResult, err := contract.EvaluateTransaction("GetAllAssets")
    87. 	if err != nil {
    88. 		panic(fmt.Errorf("failed to evaluate transaction: %w", err))
    89. 	}
    90. 	result := formatJSON(evaluateResult)
    91.  
    92. 	fmt.Printf("*** Result:%s\n", result)
    93.  
    94. 	return string(evaluateResult)
    95. }
    96.  
    97. // newGrpcConnection creates a gRPC connection to the Gateway server.
    98. func newGrpcConnection() *grpc.ClientConn {
    99. 	certificate, err := loadCertificate(tlsCertPath)
    100. 	if err != nil {
    101. 		panic(err)
    102. 	}
    103.  
    104. 	certPool := x509.NewCertPool()
    105. 	certPool.AddCert(certificate)
    106. 	transportCredentials := credentials.NewClientTLSFromCert(certPool, gatewayPeer)
    107.  
    108. 	connection, err := grpc.Dial(peerEndpoint, grpc.WithTransportCredentials(transportCredentials))
    109. 	if err != nil {
    110. 		panic(fmt.Errorf("failed to create gRPC connection: %w", err))
    111. 	}
    112.  
    113. 	return connection
    114. }
    115.  
    116. // newIdentity creates a client identity for this Gateway connection using an X.509 certificate.
    117. func newIdentity() *identity.X509Identity {
    118. 	certificate, err := loadCertificate(certPath)
    119. 	if err != nil {
    120. 		panic(err)
    121. 	}
    122.  
    123. 	id, err := identity.NewX509Identity(mspID, certificate)
    124. 	if err != nil {
    125. 		panic(err)
    126. 	}
    127.  
    128. 	return id
    129. }
    130.  
    131. func loadCertificate(filename string) (*x509.Certificate, error) {
    132. 	certificatePEM, err := ioutil.ReadFile(filename)
    133. 	if err != nil {
    134. 		return nil, fmt.Errorf("failed to read certificate file: %w", err)
    135. 	}
    136. 	return identity.CertificateFromPEM(certificatePEM)
    137. }
    138.  
    139. // newSign creates a function that generates a digital signature from a message digest using a private key.
    140. func newSign() identity.Sign {
    141. 	files, err := ioutil.ReadDir(keyPath)
    142. 	if err != nil {
    143. 		panic(fmt.Errorf("failed to read private key directory: %w", err))
    144. 	}
    145. 	privateKeyPEM, err := ioutil.ReadFile(path.Join(keyPath, files[0].Name()))
    146.  
    147. 	if err != nil {
    148. 		panic(fmt.Errorf("failed to read private key file: %w", err))
    149. 	}
    150.  
    151. 	privateKey, err := identity.PrivateKeyFromPEM(privateKeyPEM)
    152. 	if err != nil {
    153. 		panic(err)
    154. 	}
    155.  
    156. 	sign, err := identity.NewPrivateKeySign(privateKey)
    157. 	if err != nil {
    158. 		panic(err)
    159. 	}
    160.  
    161. 	return sign
    162. }
    163.  
    164. // Format JSON data
    165. func formatJSON(data []byte) string {
    166. 	var prettyJSON bytes.Buffer
    167. 	if err := json.Indent(&prettyJSON, data, " ", ""); err != nil {
    168. 		panic(fmt.Errorf("failed to parse JSON: %w", err))
    169. 	}
    170. 	return prettyJSON.String()
    171. }

    为了方便演示。这里仅仅结合了查询所有信息的功能，如需要结合其他功能可以自己结合：

    我们来分析结构：

    首先添加Gateway的功能函数：

    1. // newGrpcConnection creates a gRPC connection to the Gateway server.
    2. func newGrpcConnection() *grpc.ClientConn {
    3. 	certificate, err := loadCertificate(tlsCertPath)
    4. 	if err != nil {
    5. 		panic(err)
    6. 	}
    7.  
    8. 	certPool := x509.NewCertPool()
    9. 	certPool.AddCert(certificate)
    10. 	transportCredentials := credentials.NewClientTLSFromCert(certPool, gatewayPeer)
    11.  
    12. 	connection, err := grpc.Dial(peerEndpoint, grpc.WithTransportCredentials(transportCredentials))
    13. 	if err != nil {
    14. 		panic(fmt.Errorf("failed to create gRPC connection: %w", err))
    15. 	}
    16.  
    17. 	return connection
    18. }
    19.  
    20. // newIdentity creates a client identity for this Gateway connection using an X.509 certificate.
    21. func newIdentity() *identity.X509Identity {
    22. 	certificate, err := loadCertificate(certPath)
    23. 	if err != nil {
    24. 		panic(err)
    25. 	}
    26.  
    27. 	id, err := identity.NewX509Identity(mspID, certificate)
    28. 	if err != nil {
    29. 		panic(err)
    30. 	}
    31.  
    32. 	return id
    33. }
    34.  
    35. func loadCertificate(filename string) (*x509.Certificate, error) {
    36. 	certificatePEM, err := ioutil.ReadFile(filename)
    37. 	if err != nil {
    38. 		return nil, fmt.Errorf("failed to read certificate file: %w", err)
    39. 	}
    40. 	return identity.CertificateFromPEM(certificatePEM)
    41. }
    42.  
    43. // newSign creates a function that generates a digital signature from a message digest using a private key.
    44. func newSign() identity.Sign {
    45. 	files, err := ioutil.ReadDir(keyPath)
    46. 	if err != nil {
    47. 		panic(fmt.Errorf("failed to read private key directory: %w", err))
    48. 	}
    49. 	privateKeyPEM, err := ioutil.ReadFile(path.Join(keyPath, files[0].Name()))
    50.  
    51. 	if err != nil {
    52. 		panic(fmt.Errorf("failed to read private key file: %w", err))
    53. 	}
    54.  
    55. 	privateKey, err := identity.PrivateKeyFromPEM(privateKeyPEM)
    56. 	if err != nil {
    57. 		panic(err)
    58. 	}
    59.  
    60. 	sign, err := identity.NewPrivateKeySign(privateKey)
    61. 	if err != nil {
    62. 		panic(err)
    63. 	}
    64.  
    65. 	return sign
    66. }
    67.  
    68. // Format JSON data
    69. func formatJSON(data []byte) string {
    70. 	var prettyJSON bytes.Buffer
    71. 	if err := json.Indent(&prettyJSON, data, " ", ""); err != nil {
    72. 		panic(fmt.Errorf("failed to parse JSON: %w", err))
    73. 	}
    74. 	return prettyJSON.String()
    75. }

    然后在最开始添加常量信息，里面含有fabric的一些基本信息，还有定义asset结构体：

    1. const (
    2. 	mspID         = "Org1MSP"
    3. 	cryptoPath    = "./peerOrganizations/org1.example.com"
    4. 	certPath      = cryptoPath + "/users/User1@org1.example.com/msp/signcerts/cert.pem"
    5. 	keyPath       = cryptoPath + "/users/User1@org1.example.com/msp/keystore/"
    6. 	tlsCertPath   = cryptoPath + "/peers/peer0.org1.example.com/tls/ca.crt"
    7. 	peerEndpoint  = "192.168.136.130:7051"
    8. 	gatewayPeer   = "peer0.org1.example.com"
    9. 	channelName   = "mychannel"
    10. 	chaincodeName = "basic"
    11. )
    12.  
    13. type Asset struct {
    14. 	AppraisedValue int    `form:"appraisedValue" json:"appraisedValue" `
    15. 	Color          string `form:"color" json:"color"`
    16. 	ID             string `form:"id" json:"id"`
    17. 	Owner          string `form:"owner" json:"owner"`
    18. 	Size           int    `form:"size" json:"size"`
    19. }

    在mian函数里首先添加连接Gateway的代码：

    （这里注意，如果我们先写的是连接Gateway的代码，表示我们后续都会使用这个用户的身份去连接固定的fabric peer节点进行操作！如果我们想要每次连接使用不同用户身份连接不用的peer节点那么只要按照逻辑改变代码即可）

    1. // The gRPC client connection should be shared by all Gateway connections to this endpoint
    2. 	clientConnection := newGrpcConnection()
    3. 	defer clientConnection.Close()
    4.  
    5. 	id := newIdentity()
    6. 	sign := newSign()
    7.  
    8. 	// Create a Gateway connection for a specific client identity
    9. 	gateway, err := client.Connect(
    10. 		id,
    11. 		client.WithSign(sign),
    12. 		client.WithClientConnection(clientConnection),
    13. 		// Default timeouts for different gRPC calls
    14. 		client.WithEvaluateTimeout(5*time.Second),
    15. 		client.WithEndorseTimeout(15*time.Second),
    16. 		client.WithSubmitTimeout(5*time.Second),
    17. 		client.WithCommitStatusTimeout(1*time.Minute),
    18. 	)
    19. 	if err != nil {
    20. 		panic(err)
    21. 	}
    22. 	defer gateway.Close()
    23. 	network := gateway.GetNetwork(channelName)
    24. 	contract := network.GetContract(chaincodeName)

    我们再写gin的代码：

    1. r := gin.Default()
    2. 	r1 := r.Group("/fabric2.4")
    3. 	r1.POST("/CreateAsset", func(c *gin.Context) {
    4. 		var asset Asset
    5. 		c.ShouldBind(&asset)
    6. 		c.JSON(200, asset)
    7. 		marshal, _ := json.Marshal(asset)
    8. 		fmt.Println(string(marshal))
    9. 		fmt.Println("asset:", asset)
    10. 	})
    11. 	r1.POST("/GetAllAssets", func(c *gin.Context) {
    12. 		result := getAllAssets(contract)
    13. 		c.JSON(200, result)
    14. 	})
    15. 	r.Run(":8080") // 监听并在 0.0.0.0:8080 上启动服务

    这里在GetAllAssets中，我们执行result := getAllAssets(contract)函数：

    如下：

    1. // Evaluate a transaction to query ledger state.
    2. func getAllAssets(contract *client.Contract) string {
    3. 	fmt.Println("Evaluate Transaction: GetAllAssets, function returns all the current assets on the ledger")
    4.  
    5. 	evaluateResult, err := contract.EvaluateTransaction("GetAllAssets")
    6. 	if err != nil {
    7. 		panic(fmt.Errorf("failed to evaluate transaction: %w", err))
    8. 	}
    9. 	result := formatJSON(evaluateResult)
    10.  
    11. 	fmt.Printf("*** Result:%s\n", result)
    12.  
    13. 	return string(evaluateResult)
    14. }

    这个方法是官方的demo，我进行了小改动，返回一个string是为了方便大家在前端看到拿到的数据，原本的方法是没有返回值的，这里注意。

    最后，我们执行main函数：

    打开postman进行测试：

     

     我们看到账本的数据已经查出来到前端了！

  • 相关阅读:
    RMAN-06217: not connected to auxiliary database with a net service name
    房屋差价能否作为非违约方的损失
    如何建立用户关注与青睐的产品设计？
    Micro-OLED（硅基OLED）的工艺简介
    过五关，斩六将！「网易/美团/菜鸟」已拿offer【Java岗】
    基础复习——数据库SQLite——SQL的基本语法——数据库管理器SQLiteDatabase——数据库帮助器SQLiteOpenHelper...
    vue打包优化
    近视是怎样形成的？
    Selenium实现自动登录163邮箱和Locating Elements介绍
    中国财政科学研究院党委书记、院长刘尚希一行莅临麒麟信安调研
  • 原文地址：https://blog.csdn.net/lakersssss24/article/details/126434147