package main

import (
	"context"
	"net"

	"google.golang.org/grpc"

	"awesomeProject/grpc_test/proto"
)

type Server struct{}

func (s *Server) SayHello(ctx context.Context, request *proto.HelloRequest) (*proto.HelloReply,error){
	var results []*proto.HelloReply_Result
	for i:=0;i<10;i++{
		result := proto.HelloReply_Result{
			Name: "name",
			Age:  string(i),
		}
		results = append(results,&result)
	}
	return &proto.HelloReply{
		Message: "Hello" + request.Name,
		Persons: results,
	},nil
}

func main(){
	server := grpc.NewServer()
 	proto.RegisterGreeterServer(server,&Server{})
	listen,err := net.Listen("tcp","127.0.0.1:50000")
	if err != nil{
		panic("fail to listen:" + err.Error())
	}
	err = server.Serve(listen)
	if err != nil{
		panic("fail to start:" + err.Error())
	}
}

package main

import (
	"awesomeProject/grpc_test/proto"
	"context"
	"fmt"
	"google.golang.org/grpc"
)

func main(){
	conn, err := grpc.Dial("127.0.0.1:50000", grpc.WithInsecure())
	if err != nil{
		panic(err)
	}
	defer conn.Close()

	c := proto.NewGreeterClient(conn)
	resp, err := c.SayHello(context.Background(), &proto.HelloRequest{Name:"Lily"})
	if err != nil{
		panic(err)
	}
	fmt.Println(resp.Persons)
}

type HelloReply_Gender int32

const (
	HelloReply_MALE   HelloReply_Gender = 0
	HelloReply_FEMALE HelloReply_Gender = 1
)

// 客户端用法
return &proto.HelloReply{
		Message: "Hello" + request.Name,
		Persons: results,
		G: proto.HelloReply_FEMALE,
		Mp: map[string]string{"hhh":"2333","QAQ":"QWQ"},
	},nil

syntax = "proto3";

package proto;//不能不一样
option go_package="./;proto";

// 服务名称
service Greeter {
    // 依次为：rpc关键字，函数名，函数参数，return关键字，返回值，函数内容体
    rpc SayHello (HelloRequest) returns (HelloReply) {}
}

// The request message containing the user's name.
message HelloRequest {
    string name = 1;
}

// The response message containing the greetings
message HelloReply {
    string message = 1;
}

//服务端
package main

import (
	"context"
	"net"

	"google.golang.org/grpc"

	"awesomeProject/grpc_test/proto"
)

type Server struct{}

//简单的通信需要一个上下文对象
func (s *Server) SayHello(ctx context.Context, request *proto.HelloRequest) (*proto.HelloReply,error){
	return &proto.HelloReply{
		Message: "Hello" + request.Name,
	},nil
}

func main(){
	server := grpc.NewServer()
 	proto.RegisterGreeterServer(server,&Server{})
    //指定端口
	listen,err := net.Listen("tcp","127.0.0.1:50000")
	if err != nil{
		panic("fail to listen:" + err.Error())
	}
    //开始监听
	err = server.Serve(listen)
	if err != nil{
		panic("fail to start:" + err.Error())
	}
}

//客户端
package main

import (
	"awesomeProject/grpc_test/proto"
	"context"
	"fmt"
	"google.golang.org/grpc"
)

func main(){
	conn, err := grpc.Dial("127.0.0.1:50000", grpc.WithInsecure())
	if err != nil{	
		panic(err)
	}
	defer conn.Close()

	c := proto.NewGreeterClient(conn)
	resp, err := c.SayHello(context.Background(), &proto.HelloRequest{Name:"Lily"})
	if err != nil{
		panic(err)
	}
	fmt.Println(resp.Message)
}

// server
package main

import (
   "awesomeProject/stream_grpc_test/proto"
   "errors"
   "fmt"
   "google.golang.org/grpc"
   "log"
   "net"
   "sync"
   "time"
)

const PORT = ":50000"
type Server struct {}

// 服务端 单向流
func (s *Server)GetStream(req *proto.StreamReqData,serveStream proto.Greeter_GetStreamServer) error{
   for i:=0;i<10;i++ {
      err := serveStream.Send(&proto.StreamResData{
         Data: time.Now().String(),
      })
      if err != nil{
         panic(err.Error())
      }
      time.Sleep(time.Second)
   }
   return nil
}

// 客户端 单向流
func (s *Server)PutStream(clientStream proto.Greeter_PutStreamServer) error{
   for {
      a,err := clientStream.Recv()
      if err != nil{
         return errors.New("fail to receive data:"+err.Error())
      }
      log.Println(a.Data)
   }
}

// 双向流
func (s *Server)AllStream(allStream proto.Greeter_AllStreamServer) error{
   wg := sync.WaitGroup{}
   wg.Add(2)
   go func(){
      defer wg.Done()
      for i:=0;i<10;i++{
         err := allStream.Send(&proto.StreamResData{Data: time.Now().String()})
         if err != nil{
            fmt.Println("allStream sending goes wrong:"+err.Error())
         }
         time.Sleep(time.Second)
      }
   }()

   go func(){
      defer wg.Done()
      for i:=0;i<10;i++{
         data,err := allStream.Recv()
         if err != nil{
            fmt.Println("allStream sending goes wrong:"+err.Error())
            break
         }
         fmt.Println(data)
      }
   }()
   wg.Wait()
   return nil
}

func main(){
   server := grpc.NewServer()
   proto.RegisterGreeterServer(server,&Server{})
   listen,err := net.Listen("tcp",PORT)
   if err != nil{
      panic(err.Error())
   }

   err = server.Serve(listen)
   if err != nil{
      panic(err.Error())
   }


}

//client
package main

import (
	"awesomeProject/stream_grpc_test/proto"
	"context"
	"fmt"
	"google.golang.org/grpc"
	"log"
	"sync"
	"time"
)

const ADDR = "127.0.0.1:50000"

func main(){
	conn, err := grpc.Dial(ADDR,grpc.WithInsecure())
	if err != nil{
		panic(err.Error())
	}
	defer conn.Close()

	c := proto.NewGreeterClient(conn)
	// 服务端 流模式
	res,err := c.GetStream(context.Background(),&proto.StreamReqData{Data: "Hello,Lily!"})
	if err != nil{
		log.Fatalln("fail to send message:"+err.Error())
	}

	for {
		a,err := res.Recv()
		if err != nil{
			log.Println("fail to receive data:"+err.Error())
			break
		}
		log.Println(a)
	}

	// 客户端 流模式
	putStream,err := c.PutStream(context.Background())
	for i:=0;i<10;i++{
		err = putStream.Send(&proto.StreamReqData{Data: time.Now().String()})
		if err != nil{
			log.Println("fail to send stream:"+err.Error())
		}
		time.Sleep(time.Second)
	}

	// 双向流模式
	allStream,err := c.AllStream(context.Background())
	wg := sync.WaitGroup{}
	wg.Add(2)
	go func(){
		defer wg.Done()
		for i:=0;i<10;i++{
			err := allStream.Send(&proto.StreamReqData{Data: time.Now().String()})
			if err != nil{
				fmt.Println("allStream sending goes wrong:"+err.Error())
			}
			time.Sleep(time.Second)
		}
	}()

	go func(){
		defer wg.Done()
		for i:=0;i<10;i++{
			data,err := allStream.Recv()
			if err != nil{
				fmt.Println("allStream sending goes wrong:"+err.Error())
				break
			}
			fmt.Println(data)
		}
	}()
	wg.Wait()

}

package main	

import {
	"fmt"
}

func main() {
	fmt.Println("Hello, World!")
}

package main

import "fmt"

func main() {
	//声明常量
	const ( days = 365
           name = "days"
          )
	//声明变量
	var (
		dream = "I have a dream"
		new_dream = "I had a dream"
	)
	//格式化输出
	fmt.Println("One year has",days,name)
	fmt.Print("One year has ")
	fmt.Print(days)
	fmt.Print(" days\n")
	fmt.Printf("One year has %d days\n",days)
	fmt.Println(dream,"\n",new_dream)
}

func demo(){
	if 判断语句{
		//do sth.
	}
	else if 判断语句{
		//do sth.
	}
	else 判断语句{
		//do sth.
	}

package main

import "fmt"

func main() {
	const days = 365

	switch days {
	case 100:
		fmt.Println(100,"days")
	case 200,365://使用逗号分隔多个可选值
		fmt.Println("hhhh")
		fallthrough
	default:
		fmt.Println("23333333")
	}
}

//假设array_cut是一个数组或切片
//index和value分别对应了下标和值
for index,value := range array_cut{
//do sth.
}

//两方法等价
var name = 'ubuntu'
name := 'ubuntu'

for count := 10; count > 0;count--{
	//do sth.
}

if count := rand.Intn(3); count == 0{
	//do sth.
}

switch num := rand(10); num{
//do sth.
}

//双精度浮点数
age := 19.2
var age =19.2
var age float64 = 19.2

//单精度浮点数
var age float32 = 19.2

//默认零值
var age

year := 2021
var year = 2021
var year int 2021

//e12表示10的12次方
var distance int64  = 2.33e12

//创建int64类型
hhhhh := big.NewInt(2333333)

//创建很大很大的数
hhhhhhh := new(big.Int)
hhhhhhh.SetString("23333333333333333",10)

//Go语言不会为常量推断类型，而是默认无类型（untyped）
//由big包提供底层支持
const distance = 23333333333333333333333333

//go语言推断双引号内字面值为string类型
peace := "peace"
var peace = "peace"
var peace string = "peace"

//声明零值
var peace string

//反引号包围的文本不考虑转义字符`
var peace 'hhhhhhh\n'//不会输出换行符，而是输出/n

//反引号可跨越多行，打印时将包含这些行
var peace 'hhhhh
hhhhhhhh
hhhhh'

//可以独立访问字符串中的单个字符，但无法单独修改
hhhh = 'laugh'
h = laugh[4]

//非法操作：
laugh[4] = 'd'

//字符串拼接
hhhh = 'laugh ' + 'is the power of birth.'

//非法：
hhh ='laugh ' + 'is the power of birth.' + 10

//合法
hhh = 'laugh ' + 'is the power of birth.' + '10'

//根据代码点转换
fmt.Println(string(960),string(940),string(969),string(33))
//输出π ά ω !

//转换为字符串方法：
//使用strconv包的Itoa函数
hhh ='laugh ' + 'is the power of birth.' + strconv.Itoa(10)

//字符串转换为整数
//使用strconv包的Atoi函数
const hhh string = '23333'
number := strconv.Atoi(hhh)

func Add(number1 int,number2 int)(sum int){
	sum = number1 + number2
	return sum
}

func Add(number1 int,number2 int)(sum int){
	sum = number1 + number2
	return //省略了返回值的名字
}

func Calculate(number1 ,number2 int)(sum,multitude int){//减少了int的使用次数
	sum = number1 + number2
	multitude = number2*number1
	return sum,multitude
}

func Calculate(number1 ,number2 int)(sum,multitude int){
	sum = number1 + number2
	multitude = number2*number1
	return 

type 新类型名称 底层类型

type type1 float64
type type2 float64

var number1 type1 := 10
var number2 type2 := 15
var number3 float64 = 20

//以下操作非法.尽管底层相同，他们仍为不同的类型
numebr1 = number2
number2 = number3

func (接受者) 方法名(形参列表) （返回值列表）{
//do sth.
}