go快速体验RPC

快速体验

Server

package main
import (
	"net"
	"net/rpc"
)

type HelloService struct{}

func (s *HelloService) Hello(request string, reply *string) error {
	// 真正的返回值是修改后的reply
	*reply = "hello, " + request
	return nil
}

func main() {
	// 实例化一个server
	listen, _ := net.Listen("tcp", ":8081")
	// 注册处理逻辑handler
	_ = rpc.RegisterName("HelloService", &HelloService{})
	// 启动服务
	conn, _ := listen.Accept()
	rpc.ServeConn(conn)
}

Client

package main

import (
	"fmt"
	"net/rpc"
)

func main() {
	// 建立连接
	client, _ := rpc.Dial("tcp", "localhost:8081")
	var reply string
	_ = client.Call("HelloService.Hello", "RPC", &reply)
	fmt.Println(reply)
}

替换RPC的序列化协议为json

go语言相互调用

Server

package main

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

type HelloService struct{}

func (s *HelloService) Hello(request string, reply *string) error {
	// 真正的返回值是修改后的reply
	*reply = "hello, " + request
	return nil
}

func main() {
	// 实例化一个server
	listen, _ := net.Listen("tcp", ":8081")
	// 注册处理逻辑handler
	_ = rpc.RegisterName("HelloService", &HelloService{})
	// 启动服务
	// 死循环避免处理一次请求就关闭server
	for {
		conn, _ := listen.Accept()
		// 使用协程提高并发
		go rpc.ServeCodec(jsonrpc.NewServerCodec(conn))
	}
}

client

package main

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

func main() {
	// 建立连接
	conn, _ := net.Dial("tcp", "localhost:8081")
	var reply string
	client := rpc.NewClientWithCodec(jsonrpc.NewClientCodec(conn))
	_ = client.Call("HelloService.Hello", "grpc", &reply)
	fmt.Println(reply)
}

使用java调用go的Server

Server

package main

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

type HelloService struct{}

func (s *HelloService) Hello(request string, reply *string) error {
	// 真正的返回值是修改后的reply
	*reply = "hello, " + request
	return nil
}

func main() {
	// 实例化一个server
	listen, _ := net.Listen("tcp", ":8081")
	// 注册处理逻辑handler
	_ = rpc.RegisterName("HelloService", &HelloService{})
	// 启动服务
	// 死循环避免处理一次请求就关闭server
	for {
		conn, _ := listen.Accept()
		// 使用协程提高并发
		 rpc.ServeCodec(jsonrpc.NewServerCodec(conn))
	}
}

Client

import com.alibaba.fastjson.JSON;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.util.HashMap;
import java.util.Map;

public class Demo {

    public static void main(String[] args) throws IOException {
        Map<String,Object> map = new HashMap<>();
        map.put("id",0);
        map.put("method","HelloService.Hello");
        map.put("params",new String[]{"grpc"});
        Socket socket = new Socket("127.0.0.1",8081);
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write(JSON.toJSONString(map).getBytes());
        InputStream inputStream = socket.getInputStream();
        byte[] bytes = new byte[1024];
        int len = inputStream.read(bytes);
        String string = new String(bytes,0,len);
        Map resMap = JSON.parseObject(string, Map.class);
        System.out.println(resMap.get("result"));
    }
}

进一步改造

handler

package handler

const HelloServiceName = "handler/HelloService"

type NewHelloService struct{}

func (s *NewHelloService) Hello(request string, reply *string) error {
	*reply = "hello, " + request
	return nil
}

server_proxy

package server_proxy

import (
	"ShopBefore/rpc/new_helloworld/handler"
	"net/rpc"
)

type HelloService interface {
	Hello(request string, reply *string) error
}

func RegisterHelloService(srv HelloService) error {
	return rpc.RegisterName(handler.HelloServiceName, srv)
}

Server

package main

import (
	"ShopBefore/rpc/new_helloworld/handler"
	"ShopBefore/rpc/new_helloworld/server_proxy"
	"net"
	"net/rpc"
)

func main() {
	listen, _ := net.Listen("tcp", ":8081")
	_ = server_proxy.RegisterHelloService(&handler.NewHelloService{})
	for {
		conn, _ := listen.Accept()
		go rpc.ServeConn(conn)
	}
}

client_proxy

package client_proxy

import (
	"ShopBefore/rpc/new_helloworld/handler"
	"net/rpc"
)

type HelloServiceStub struct {
	*rpc.Client
}

func NewHelloServiceClient(protocol, address string) HelloServiceStub {
	conn, _ := rpc.Dial(protocol, address)
	return HelloServiceStub{conn}
}

func (c *HelloServiceStub) Hello(request string, reply *string) error {
	return c.Call(handler.HelloServiceName+".Hello", request, reply)
}

client

package main

import (
	"ShopBefore/rpc/new_helloworld/client_proxy"
	"fmt"
)

func main() {
	client := client_proxy.NewHelloServiceClient("tcp", "localhost:8081")
	var reply string
	_ = client.Hello("RPC", &reply)
	fmt.Println(reply)
}