Go使用net.rpc

Go使用net.rpc

標籤(空格分隔): go

// 使用net.rpc包

服務端 [gob協議默認]

package main

import (
	"log"
	"net"
	"net/rpc"
)

type HelloService struct {
}

func (h *HelloService) Hello(request string, rely *string) error {
	*rely = "hello," + request
	return nil
}

func main() {
	listen, _ := net.Listen("tcp", ":9991")
	err := rpc.RegisterName("HelloService", &HelloService{})
	if err != nil {
		log.Fatalf("rpc register error %+v\n", err)
	}
	conn, err := listen.Accept()
	if err != nil {
		log.Fatalf("listen accept error %+v\n", err)
	}
	rpc.ServeConn(conn)
}

客戶端 [gob協議默認]

package main

import (
	"fmt"
	"net/rpc"
)

func main() {

	dial, err := rpc.Dial("tcp", "127.0.0.1:9991")
	if err != nil {
		panic(err)
	}
	//var re *string = new(string)
	var re string
	err = dial.Call("HelloService.Hello", "bill", &re)
	if err != nil {
		panic(err)
	}
	fmt.Println(re)
}

服務端 [jsonrpc協議]

package main

import (
	"net"
	"net/rpc"
	"net/rpc/jsonrpc"
)

type HelloService struct {
}

func (h *HelloService) Hello(request string, rely *string) error {
	*rely = "hello, " + request
	return nil
}

func main() {
	listen, err := net.Listen("tcp", ":9992")
	if err != nil {
		panic(err)
	}
	err = rpc.RegisterName("HelloService", &HelloService{})
	if err != nil {
		panic(err)
	}

	// 默認gob協議
	//rpc.ServeConn(accept)

	// json 協議
	for {
		accept, err := listen.Accept()
		if err != nil {
			panic(err)
		}
		go rpc.ServeCodec(jsonrpc.NewServerCodec(accept))
	}

}

go客戶端 [jsonrpc協議]

package main

import (
	"fmt"
	"net"
	"net/rpc"
	"net/rpc/jsonrpc"
)

func main() {

	conn, err := net.Dial("tcp", "127.0.0.1:9992")
	if err != nil {
		return
	}
	client := rpc.NewClientWithCodec(jsonrpc.NewClientCodec(conn))

	//var re *string = new(string)
	var re string
	err = client.Call("HelloService.Hello", "bill", &re)
	if err != nil {
		panic(err)
	}
	fmt.Println(re)
	// jsonrpc 協議格式
	//	{
	//	"method": "HelloService.Hello",
	//	"param": [
	//		"bill"
	//	],
	//	"id": 0
	//	}
}

php客戶端 [jsonrpc協議]

<?php
$resource = socket_create(AF_INET, SOCK_STREAM, SOL_TCP);
$bool = socket_connect($resource, "127.0.0.1", "9992");
if (!$bool) {
exit("socket connect error" . PHP_EOL);
}
$data = ["method" => "HelloService.Hello", "params" => ["php"], "id" => 0];
$jsonStr = json_encode($data, JSON_UNESCAPED_UNICODE);
socket_write($resource, $jsonStr);
$result = socket_read($resource, 1024);
var_dump($result);
// {"id":0,"result":"hello, php","error":null}

服務端 [http協議]

package main

import (
	"fmt"
	"io"
	"net/http"
	"net/rpc"
	"net/rpc/jsonrpc"
)

type HelloService struct {
}

func (h *HelloService) Hello(request string, rely *string) error {
	*rely = "hello, " + request
	return nil
}

func main() {

	err := rpc.RegisterName("HelloService", &HelloService{})
	fmt.Println("err:", err)
	http.HandleFunc("/jsonrpc", func(w http.ResponseWriter, r *http.Request) {
		var conn io.ReadWriteCloser = struct {
			io.Writer
			io.ReadCloser
		}{
			ReadCloser: r.Body,
			Writer:     w,
		}
		rpc.ServeRequest(jsonrpc.NewServerCodec(conn))
	})
	http.ListenAndServe(":9992", nil)
}

客戶端 [http協議]

package main

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

type JsonRpcRequestMessage struct {
	Method string   `json:"method"`
	Params []string `json:"params"`
	Id     int      `json:"id"`
}

type JsonRpcResponseMessage struct {
	Id     int    `json:"id"`
	Result string `json:"result"`
	Error  string `json:"error"`
}

func main() {

	url := "http://127.0.0.1:9992/jsonrpc"
	contentType := "application/json"

	r := JsonRpcRequestMessage{
		Method: "HelloService.Hello",
		Params: []string{
			"params_one",
			"params_two",
		},
		Id: 0,
	}
	bytesAll, err := json.Marshal(&r)
	if err != nil {
		panic(err)
	}
	fmt.Printf("request-body: %s\n", bytesAll)

	resp, err := http.Post(url, contentType, bytes.NewReader(bytesAll))
	if err != nil {
		panic(err)
	}
	all, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return
	}
	var p JsonRpcResponseMessage
	json.Unmarshal(all, &p)
	fmt.Printf("response-body: %+v\n", p)
}
發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章