# grpc 的初次实践

## 一、前期准备

### 1. 安装 protoc

```shell
wget https://github.com/protocolbuffers/protobuf/releases/download/v21.5/protobuf-all-21.5.zip
unzip protobuf-all-21.5.zip && cd protobuf-21.5/
./configure
make
make install
```







安装完成后，可以通过 `protoc --version` 查看是否安装成功。

### 2. 安装 protoc-gen-go

```shell
go get -u github.com/golang/protobuf/protoc-gen-go
go install github.com/golang/protobuf/protoc-gen-go
mv $GOPATH/bin/protoc-gen-go /usr/local/bin/
```

### 3. 初始化一个项目

```shell
mkdir grpc-demo && cd grpc-demo
go mod init grpc-demo
mkdir client server proto
```

## 二、编写 proto 文件

### 1. 创建 proto 文件

```proto
syntax = "proto3";

package helloworld;

// The greeting service definition.
service Greeter {
  // Sends a greeting
  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;
}
```

### 2. 生成 pb.go 文件

```shell
protoc --go_out=plugins=grpc:. ./proto/*.proto
```

> 报错 1：
> go_out: protoc-gen-go: Plugin failed with status code 1.
> 由于没有指定.proto 文件路径，在 proto 文件第三行加上`option go_package ="./proto";`

> 报错 2：
> --go_out: protoc-gen-go: plugins are not supported; use 'protoc --go-grpc_out=...' to generate gRPC
> 由于 proto 版本过高，无法使用`plugins=grpc`，需要使用`--go-grpc_out=.`
> 将生成的 proto-gen-go-grpc 文件移动到/usr/local/bin/目录下
> 使用新的命令：
> protoc --go_out=. --go_opt=paths=source_relative \\
> --go-grpc_out=. --go-grpc_opt=paths=source_relative \\
> ./proto/\*.proto

## 三、编写 GRPC

### 1. 一元 RPC

> 一元 RPC 是指客户端发送一个请求到服务器，并获得一个响应，就像是一个简单的函数调用。


1. Proto

```proto
rpc SayHello (HelloRequest) returns (HelloReply) {};
```

2. server.go

```go
package main

import (
	"context"
	pb "grpc-demo/proto"
	"net"

	"google.golang.org/grpc"
)

type GreeterServer struct{
	pb.UnimplementedGreeterServer
}

func (s *GreeterServer) SayHello(ctx context.Context, req *pb.HelloRequest) (*pb.HelloReply, error) {
	return &pb.HelloReply{Message: "Hello " + req.Name}, nil
}

func main() {
	server := grpc.NewServer()
	pb.RegisterGreeterServer(server, &GreeterServer{})
	lis,_ := net.Listen("tcp", ":8080")
	server.Serve(lis)
}
```

3. client.go

```go
package main

import (
	"context"
	pb "grpc-demo/proto"
	"log"

	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"
)

func main() {
	conn, err := grpc.Dial("localhost:8080", grpc.WithTransportCredentials(insecure.NewCredentials()))
	if err != nil {
		log.Fatalf("did not connect: %v", err)
	}
	defer conn.Close()
	client := pb.NewGreeterClient(conn)
	SayHello(client)
}

func SayHello(client pb.GreeterClient) {
	resp, err := client.SayHello(context.Background(), &pb.HelloRequest{Name: "duty"})
	if err != nil {
		log.Fatalf("could not greet: %v", err)
	}
	log.Printf("Greeting: %s", resp.Message)
}
```

### 2. 服务端流 RPC

> 服务端流 RPC 是指客户端发送一个请求到服务器，服务器可以返回多个流，直到没有任何消息返回。

1. Protot

```proto
rpc SayHelloAgain (HelloRequest) returns (stream HelloReply) {};
```

2. server.go

```go
package main

import (
	"context"
	pb "grpc-demo/proto"
	"net"

	"google.golang.org/grpc"
)

type GreeterServer struct{
	pb.UnimplementedGreeterServer
}

// 服务端流式 RPC
func (s *GreeterServer) SayHelloAgain(req *pb.HelloRequest, stream pb.Greeter_SayHelloAgainServer) error {
	for i := 0; i < 10; i++ {
		if err := stream.Send(&pb.HelloReply{Message: "Hello " + req.Name}); err != nil {
			return err
		}
	}
	return nil
}

func main() {
	server := grpc.NewServer()
	pb.RegisterGreeterServer(server, &GreeterServer{})
	lis,_ := net.Listen("tcp", ":8080")
	server.Serve(lis)
}

```

3. client.go

```go
package main

import (
	"context"
	pb "grpc-demo/proto"
	"log"

	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"
)

func main() {
	conn, err := grpc.Dial("localhost:8080", grpc.WithTransportCredentials(insecure.NewCredentials()))
	if err != nil {
		log.Fatalf("did not connect: %v", err)
	}
	defer conn.Close()
	client := pb.NewGreeterClient(conn)
	SayHelloAgain(client)
}

// 服务端流式 RPC
func SayHelloAgain(client pb.GreeterClient) {
	stream, err := client.SayHelloAgain(context.Background(), &pb.HelloRequest{Name: "duty"})
	if err != nil {
		log.Fatalf("could not greet: %v", err)
	}
	for {
		resp, err := stream.Recv()
		if err != nil {
			break
		}
		log.Printf("Greeting: %s", resp.Message)
	}
}

```

### 3. 客户端流 RPC

> 客户端流 RPC 是指客户端发送多个请求到服务器，服务器返回一个响应。

1. Proto

```proto
rpc SayHelloStream (stream HelloRequest) returns (HelloReply) {};
```

2. server.go

```go
package main

import (
	pb "grpc-demo/proto"
	"io"
	"log"
	"net"

	"google.golang.org/grpc"
)

type GreeterServer struct {
	pb.UnimplementedGreeterServer
}

// 客户端流式 RPC
func (s *GreeterServer) SayHelloStream(stream pb.Greeter_SayHelloStreamServer) error {
	for {
		req, err := stream.Recv()
		if err == io.EOF {
			return stream.SendAndClose(&pb.HelloReply{Message: "Hello " + "duty"})
		}
		if err != nil {
			return err
		}
		log.Printf("resp: %s", req)
	}
}

func main() {
	server := grpc.NewServer()
	pb.RegisterGreeterServer(server, &GreeterServer{})
	lis, _ := net.Listen("tcp", ":8080")
	server.Serve(lis)
}

```

3. client.go

```go
package main

import (
	"context"
	pb "grpc-demo/proto"
	"log"

	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"
)

func main() {
	conn, err := grpc.Dial("localhost:8080", grpc.WithTransportCredentials(insecure.NewCredentials()))
	if err != nil {
		log.Fatalf("did not connect: %v", err)
	}
	defer conn.Close()
	client := pb.NewGreeterClient(conn)
	SayHelloStream(client)
}

// 客户端流式 RPC
func SayHelloStream(client pb.GreeterClient) {
	stream, err := client.SayHelloStream(context.Background())
	if err != nil {
		log.Fatalf("could not greet: %v", err)
	}
	for i := 0; i < 10; i++ {
		if err := stream.Send(&pb.HelloRequest{Name: "duty"}); err != nil {
			log.Fatalf("56 could not greet: %v", err)
		}
	}
	resp, err := stream.CloseAndRecv()
	if err != nil {
		log.Fatalf("could not greet: %v", err)
	}
	log.Printf("Greeting: %s", resp.Message)
}

```

### 4. 双向流 RPC

> 双向流 RPC 是指客户端和服务器都可以在双向流中发送多个消息。

1. Proto

```proto
rpc SayHelloStreamAll (stream HelloRequest) returns (stream HelloReply) {};
```

2. server.go

```go
package main

import (
	"context"
	pb "grpc-demo/proto"
	"io"
	"log"
	"net"

	"google.golang.org/grpc"
)

type GreeterServer struct {
	pb.UnimplementedGreeterServer
}

// 双向流式 RPC
func (s *GreeterServer) SayHelloStreamAll(stream pb.Greeter_SayHelloStreamAllServer) error {
	n := 0
	for {
		err := stream.Send(&pb.HelloReply{Message: "Hello " + "duty"})
		if err != nil {
			return err
		}
		req, err := stream.Recv()
		if err == io.EOF {
			return nil
		}
		if err != nil {
			return err
		}
		n++
		log.Printf("resp: %s,%d", req, n)
	}
}

func main() {
	server := grpc.NewServer()
	pb.RegisterGreeterServer(server, &GreeterServer{})
	lis, _ := net.Listen("tcp", ":8080")
	server.Serve(lis)
}
```

3. client.go

```go
package main

import (
	"context"
	pb "grpc-demo/proto"
	"io"
	"log"

	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"
)

func main() {
	conn, err := grpc.Dial("localhost:8080", grpc.WithTransportCredentials(insecure.NewCredentials()))
	if err != nil {
		log.Fatalf("did not connect: %v", err)
	}
	defer conn.Close()
	client := pb.NewGreeterClient(conn)
	SayHelloStreamAll(client)
}

// 双向流式 RPC
func SayHelloStreamAll(client pb.GreeterClient) error {
	stream, err := client.SayHelloStreamAll(context.Background())
	if err != nil {
		log.Fatalf("could not greet: %v", err)
		return err
	}
	for n := 0; n < 10; n++ {
		err := stream.Send(&pb.HelloRequest{Name: "duty"})
		if err != nil {
			log.Fatalf("could not greet: %v", err)
			return err
		}
		resp, err := stream.Recv()
		if err == io.EOF {
			break
		}
		if err != nil {
			log.Fatalf("could not greet: %v", err)
			return err
		}
		log.Printf("Greeting: %s", resp)
	}

	err = stream.CloseSend()
	if err != nil {
		log.Fatalf("could not greet: %v", err)
		return err
	}
	return nil
}

```

grpc的初次实践

错误如下

![image.png](https://gcore.jsdelivr.net/gh/blue-duty/gitnote-images/img/562b3e34dcfb1d6591882addcceec5bc.image.png)


尝试使用换源解决失败，最后使用激活一个新的环境成功安装

    conda create --name myenv
    conda activate myenv






----------


上面的方法治标不治本


![image.png](https://gcore.jsdelivr.net/gh/blue-duty/gitnote-images/img/5c9bf6c791d4c2f6c549fcaee931f72b.image.png)

这个方法实测可用

ubuntu22.04安装Anaconda3后conda下载失败问题

# 一、安装搜狗输入法

1、更新源

    sudo apt update

2、安装fcitx框架

    sudo apt install fcitx
    
    



3、设置fcitx框架开机自启

    sudo cp /usr/share/applications/fcitx.desktop /etc/xdg/autostart/

4、卸载系统框架ibus

    sudo apt purge ibus

5、安装搜狗输入法linux

    sudo dpkg -i sogoupinyin_4.0.1.2800_x86_64.deb

6、安装依赖

    sudo apt install libqt5qml5 libqt5quick5 libqt5quickwidgets5 qml-module-qtquick2
    sudo apt install libgsettings-qt1

7、重启，完成


----------
# 二、卸载安装的deb的软件

1、使用dpkg --lis查询是否存在你要卸载的软件包。
2、通过remove卸载，--purge清除缓存

    sudo apt-get --purge remove 软件名

3、删除ded包，通过grep过滤，更加精确。

    dpkg -l | grep 软件名


----------
# 三、如何使普通用户也可以使用docker

```shell
sudo groupadd docker
```
Next add your user to the docker group:
```shell
sudo usermod -aG docker $USER
```
After adding the userto the dockergroup, logout and log back in to take effect the changes.
Alternatively run the following command to apply the changes to groups:
```shell
newgrp docker
```
From now on, the normal (non-root) user can be able to use Docker without sudo permissions.
Let me run the following commands as normal user:
```shell
docker version
docker run hello-world
```


----------
# 四、为Goland设置快捷启动

1、使用ToolBox安装可以生成goland的启动脚本，位置如图

![image.png](https://gcore.jsdelivr.net/gh/blue-duty/gitnote-images/img/4e3c614e97797fd6e0e699b9ee258ea0.image.png)


2、使用这个启动脚本

    alias goland='echo "123456" | sudo -S nohup /root/.local/share/JetBrains/Toolbox/scripts/goland & >/dev/null'

  在.bashrc中写入上述内容，

  ‘echo "123456" | sudo -S commod’命令用于获取sudo权限并执行commmod，

  nohup用于运行脚本并将输出重定向入/dev/null中，默认情况下会重定向入nohup.out中，

  加上‘&’将程序后台运行，

  allias 'commod'='***',将等号后的''中的命令用'commod'代替。

3、更新配置文件，自此，就可以愉快的通过命令行输入goland回车来打开goland了。
```
source ~/.bashrc
  ```

ubuntu22.04使用记录

### 1. 对于一对一的关系的尝试
初始化一张cxk表和一张chicken表，关联关系是一对一的关系，关联关系的类型是has_one，关联关系的方向是has_one的方向。
``` go
type Cxk struct {
	Id      uint   `gorm:"primary_key"`
	Name    string `gorm:"column:name"`
	Chicken Chicken
}

func (Cxk) TableName() string {
	return "cxk"
}

type Chicken struct {
	Id    uint   `gorm:"primary_key"`
	Name  string `gorm:"column:name"`
	CxkId uint
}

func (Chicken) TableName() string {
	return "chicken"
}
```
跳过连接数据库的过程，我们初始化完成cxk表以及chicken表后，添加一只cxk的信息，并且添加一只chicken的信息
我们可以在添加cxk的时候直接为其绑定一只chicken。







``` go
    err = db.AutoMigrate(&Cxk{}, &Chicken{})
    if err != nil {
        return
    }

    db.Model(&Cxk{}).Create(&Cxk{
        Id:   1,
        Name: "cxk",
        Chicken: Chicken{
            Id:   1,
            Name: "chicken",
        },
    })
```
这样我们就可以在查询cxk的时候直接查询出其绑定的chicken的信息。
``` go
var cxk Cxk
db.First(&cxk)
fmt.Printf("%#v", cxk)
```
使用上面的方法我们只能得到这样的结果
``` go
main.Cxk{Id:0x1, Name:"cxk", Chicken:main.Chicken{Id:0x0, Name:"", CxkId:0x0}}
```
我们只查询出cxk所对应的信息，却没有查出他拥有的chicken的信息，我们可以通过gorm的Preload方法来解决这个问题。
``` go
var cxk Cxk
db.Preload("Chicken").First(&cxk)
fmt.Printf("%#v", cxk)
// 结果：main.Cxk{Id:0x1, Name:"cxk", Chicken:
main.Chicken{Id:0x1, Name:"chicken", CxkId:0x1}}
```
### 2. 对于一对多的关系的尝试
一只cxk肯定不止拥有一只chicken，我们可以通过has_many的方式来实现一对多的关系。
``` go
type Cxk struct {
    Id      uint   `gorm:"primary_key"`
    Name    string `gorm:"column:name"`
    Chickens []Chicken
}
func (Cxk) TableName() string {
    return "cxk"
}
type Chicken struct {
    Id    uint   `gorm:"primary_key"`
    Name  string `gorm:"column:name"`
    CxkId uint
}
func (Chicken) TableName() string {
    return "chicken"
}
```
如法炮制，我们初始化了一张cxk表和一张chicken表，关联关系是一对多的关系，关联关系的类型是has_many，关联关系
的方向是has_many的方向。并为表初始化了一组数据。
``` go
    err = db.AutoMigrate(&Cxk{}, &Chicken{})
    if err != nil {
        return
    }
    db.Model(&Cxk{}).Create(&Cxk{
        Id:   1,
        Name: "cxk",
        Chickens: []Chicken{
            {
                Id:   1,
                Name: "chicken1",
            },
            {
                Id:   2,
                Name: "chicken2",
            },
        },
    })
```
这次我们不在添加cxk的时候直接为其绑定一只chicken，而是在添加chicken的时候直接为其绑定一个cxk。
``` go
    db.Model(&Chicken{}).Create(&Chicken{
        Id:   3,
        Name: "chicken3",
        CxkId: 1,
    })
```
这样我们就可以在查询cxk的时候直接查询出其绑定的chicken的信息。
``` go
var cxk Cxk
db.Preload("Chickens").First(&cxk)
fmt.Printf("%#v", cxk)
// 结果：main.Cxk{Id:0x1, Name:"cxk", Chickens:[]main.Chicken{
main.Chicken{Id:0x1, Name:"chicken1", CxkId:0x1}, 
main.Chicken{Id:0x2, Name:"chicken2", CxkId:0x1}, 
main.Chicken{Id:0x3, Name:"chicken3", CxkId:0x1}}}
```
### 3. 对于多对多的关系的尝试
一只cxk肯定不止拥有一只chicken，一只chicken肯定不止属于一个cxk，我们可以通过many_to_many的方式来
实现多对多的关系。
``` go
type Cxk struct {
	Id       uint      `gorm:"primary_key"`
	Name     string    `gorm:"column:name"`
	Chickens []Chicken `gorm:"many2many:cxk_chicken;"`
}

func (Cxk) TableName() string {
	return "cxk"
}

type Chicken struct {
	Id   uint   `gorm:"primary_key"`
	Name string `gorm:"column:name"`
}

func (Chicken) TableName() string {
	return "chicken"
}
```
此时将会生成一张cxk_chicken表，保存了cxk和chicken的关系，我们为其添加值。
``` go
    err = db.AutoMigrate(&Cxk{}, &Chicken{})
    if err != nil {
        return
    }
    db.Model(&Cxk{}).Create(&Cxk{
        Id:   1,
        Name: "cxk1",
        Chickens: []Chicken{
            {
                Id:   1,
                Name: "chicken1",
            },
            {
                Id:   2,
                Name: "chicken2",
            },
        },
    })
    db.Model(&Cxk{}).Create(&Cxk{
        Id:   2,
        Name: "cxk2",
        Chickens: []Chicken{
            {
                Id:   1,
                Name: "chicken1",
            },
            {
                Id:   4,
                Name: "chicken4",
            },
        },
    })
```
此时cxk1拥有chicken1和chicken2，cxk2拥有chicken1和chicken4。
查询cxk1以及chicken1的信息
``` go
// 查询cxk1的信息
var cxk Cxk
db.Preload("Chickens").Where("id = ?", 1).First(&cxk)
fmt.Printf("%#v", cxk)
// 结果：main.Cxk{Id:0x1, Name:"cxk", Chickens:[]main.Chicken{
// main.Chicken{Id:0x1, Name:"chicken1"}, 
// main.Chicken{Id:0x2, Name:"chicken2"}}}

// 查询chicken1的所有cxk的信息
var cxks []Cxk
db.Preload("Chickens", "id in (1)").Find(&cxks) //预加载的条件是id in (1)
fmt.Printf("%#v", cxks)
// 结果：[]main.Cxk{main.Cxk{Id:0x1, Name:"cxk", Chickens:[]main.Chicken{
// main.Chicken{Id:0x1, Name:"chicken1"}}}, 
// main.Cxk{Id:0x2, Name:"cxk2", Chickens:[]main.Chicken{
// main.Chicken{Id:0x1, Name:"chicken1"}}}}
```

Gorm的edge的尝试

总有人分享成功的经验，殊不知，每个人的成功都是在多种条件的发酵下形成的最有利的结果。然后出现了一大批的追随者，以为像他一样做就可以成功，然而匆匆尝试过后，才发现，别人的成功永远无法为自己复制一份。

成功是不可复制的

日常生活随录 feedId:60978413862965248+userId:41774543735911424