在这个世界上，有数以百万计的人对软件开发充满热情，他们有很多名字，例如软件工程师、程序员、编码员、开发人员。一段时间后，这些人可能会成为一名优秀的编码员，并且他们将非常熟悉如何使用计算机语言完成工作。但是，如果你想成为一名优秀的程序员，你还需要注意几点，如果你能让以下十项成为你的习惯，那么你就真的可以算是一名优秀的程序员了。

>本文原创内容来自phil的博客在线，可惜原链接已打不开。以下内容来自我在实践过程中的经验，并用我自己的话重新描述了这10篇文章。





## 1、学无止境。学习没有止境。
即使你有10多年的程序员经验，你仍然要努力学习，因为你在计算机领域，充满了创造力，每天都有很多很多新事物出现. 你需要跟上时代的步伐。您需要了解新的编程语言，以及了解正在开发的编程语言和一些编程框架。您还需要阅读行业新闻并参与热门社区的在线讨论，以便您了解和欣赏软件开发的整体趋势。在国内有CSDN、ITPUB、CHINAUINX等一些著名的社区。在国外，建议大家经常去digg.com看看各种BLOG的汇总。

## 2.掌握多种语言。
编程语言总是有它们最适合的领域。当您面临需要解决的问题时，您需要找到最适合解决这些问题的语言。比如，如果你需要性能，C/C++可能是首选，如果你需要跨平台，Java可能是首选，如果你想在Web上写开发程序，PHP、ASP、Ajax、JSP可能是您的选择，如果您想处理一些文本并与其他应用程序交互，Perl、Python可能是最好的。所以花一些时间探索你熟悉的其他编程语言来拓宽你的视野，你武装得更好，思考更全面，这对你和你的项目都有好处。

## 3. 对不同的操作系统或技术保持理性。
程序员心中总有自己无与伦比的技术和操作系统，有的喜欢 Ubuntu，有的喜欢 Debian，有的喜欢 Windows，还有 FreeBSD、MacOSX 或 Solaris 等。只有最优秀的程序员才能理解不同操作系统的优缺点。系统，以便他们在选择系统时能够做到真正客观和公平，而不会让他们的情绪变得更好。语言也是如此。太多的程序员总是喜欢纠缠于语言的比较，比如 Java 和 Perl。哪个新晋程序员没有为类似的话题争论过？比如VC++和Delphi等。争论这些事，只能说明一个人的肤浅和脆弱。一个好的程序不拘泥于这些。

## 4. 不要将自己局限在单一的开发环境中。
同样，如上所述，每个程序员都有自己喜欢的工具和技术，有些喜欢旧的（我喜欢用 Vi 来编辑程序），有些喜欢新的，比如 gedit 或 Emacs。有些人喜欢使用 VC++ 之类的 GUI 调试器，而我更喜欢 GDB 命令行调制器。等等等等。关于程序员使用什么工具有很多争论吗？到处都是。你使用什么工具并不重要，只要你能更好更快地实现你的目标。但是优秀的程序员应该知道一件事——那就是他们应该尝试其他工作环境。没有比较，你永远不知道谁好谁不好，你永远不知道你不知道什么。

## 5. 别告诉我你不知道源代码版本控制。
如果您的团队正在开发没有版本控制系统的源代码，那么我告诉您，您的软件开发仍处于石器时代。CVS 是一个看起来平淡无奇的版本控制工具，但它是使用最广泛的版本控制系统，Subversion 是开始占领 CVS 领域的 CVS 的更新版本，而 Git 是另一种版本控制工具。还有 Visual SourceSafe 等。根据您团队的规模和地理位置，您可能会使用效率最高或最低的工具来管理您的源代码。但是一个好的程序员总是会使用源代码版本控制工具来管理他或她的代码。如果你想让我推荐一个，我推荐开源的 git。

## 6. 成为一名优秀的团队合作者。
除非你喜欢独奏，除非你是独狼。但我想让你知道，如今，你可以单独完成的软件可能没有经过验证，你可能是团队中最优秀得开发者，但这并不意味着你是一个优秀的团队合作者。你的能力只有融入团队才能发挥作用。你与团队成员的沟通有礼貌吗？您是否定期与他们沟通？每个人都喜欢和您一起讨论问题吗？想想一支足球队，你是那支球队的好成员吗？当其他人看到你在场上奔跑时，当其他人看到你的传球、接球和扣篮时，你的团队成员会被你的行为所鼓舞吗？

## 7. 把你的工作变成文档。
这个条目当然包括在你的代码中写注释，但这还不够，你还需要做更多。注释良好的代码是文档的基础，可让您和您的团队轻松理解您的意图和想法。写下文档不仅仅是一种团队离线交流的方式，以免忘记我们的想法，也是一种传递知识的方式。把你知道的一切都写下来是个好习惯。因为，我相信你不希望人们总是在你最忙的时候打断你问问题，或者在你度假时接到公司的电话问你问题。而如果你自己老是守口如瓶，那么结果很可能就是你会在很长一段时间内让自己深陷其中，而你更不能做更多的事情，包括向上提升。你可能会认为“教会徒弟饿死师父”，但我告诉你，你的保守会让你失去更多更好的东西，请相信我，我在这里不是耸人听闻。

## 8.注意备份和安全。
也许您认为这是“废话”，并且您已经了解备份的重要性。但我在这里要指出的是，失去东西是我们生活的一部分，你总是会失去东西，你永远无法避免它。比如：你的笔记本电脑被偷了，你的硬盘坏了，你的电脑中了病毒，你的系统被黑了，甚至整栋楼都被烧毁了等等。所以，备份是一件非常重要的事情。硬盘不可信，定期刻录CD或磁带可能是个好办法，而互联网也不可信，所以要提防病毒和黑客，不仅在软件方面使用安全策略，你需要一个完善的管理系统。此外，尽量将数据保存在尽可能多的不同位置，并制定定期（每天、每周、每月）备份策略。

## 9、设计要足够灵活。
也许你的需求只会要求你实现一个死的东西，但是，作为一个好的程序，你应该一直在想这个死的东西是否可以有灵活的一面，比如让一些参数可配置，将一些通用的东西形成你的函数库为了以后重用，是否提供插件方面的功能？您的模块必须像积木一样组装吗？如果有修改，您的设计可以立即应对吗？当然，灵活的设计可能并不意味着重新发明轮子，而是尽可能使用标准化的东西。所谓灵活设计，就是让我们去考虑更多需求之外的东西，把这个范畴的所有问题都考虑到需求中，而不是只处理需求中说的那个特定的东西。例如，如果要求的屏幕分辨率为 800×600，您的设计能否灵活适应其他分辨率？编程总是需要我们应对不同的环境，以及未来的趋势。我们需要以动态的视角思考事物，而不是开辟一条道路。也许有一天，你今天写的程序会被移植到另一个环境中，然后你才能真正理解什么是柔性设计。

稍微展望一下未来，说不定哪天你正在读这篇文章的你会自己设计一个系统，如果你能从系统的角度来看事情，那么灵活性就更重要了。

## 10. 不要捡起石头砸断自己的脚。
程序员总是有一个试图快速完成工作的坏习惯。但情况往往与你想要的相反。越想做快越容易出错，越想做快越容易漏题，最终程序改过来改过去，照葫芦画瓢，最终花费更多的时间和精力。对速度的渴望没有实现。一个好的程序员的习惯是在前面花更多的时间做更多的研究，尝试不同的解决方案，如果时间允许，一个好的习惯是每 4 个小时的编程，你需要一个小时的休息，然后再编码4个小时。当然，这因人而异，但它的目的是让你时不时回首，让你思考这样三个问题：
1) 这样做对吗？
2) 考虑到所有情况，这样做是否正确？
3) 有更好的方法吗？

这样想一想，时不时回头看看自己走了多远，时不时总结一下过去的事情，会对你有很大帮助。

-------

这是优秀程序员的十个习惯或行为规范，希望对你有所帮助。

一个优秀的程序员的十个好习惯

# rust的第一天
## 2022-10-16 02：11

## 1. rust的安装
关于rust的安装，可以参考[官方文档](https://www.rust-lang.org/tools/install)。
因为我的系统为manjaro，所以我选择了使用yay来安装rust。
```bash
yay -S rust
```
安装完成后，可以使用`rustc --version`来查看rust的版本。





## 2. rust的hello world
使用cargo来创建一个新的项目。
```bash
cargo new rust1
```
在rust中，使用`println!`来输出字符串。
```rust
fn main() {
    println!("Hello, world!");
}
```
使用`cargo run`来运行程序。
```bash
cargo run
```
输出结果：
```bash
 Compiling rust1 v0.1.0 (/home/duty/rust/rust1)
    Finished dev [unoptimized + debuginfo] target(s) in 0.40s
     Running `target/debug/rust1`
Hello, world!
```

## 3. rust的数据类型
rust的数据类型分为两类：标量和复合。
### 3.1 标量
标量类型包括整型、浮点型、布尔型和字符型。
#### 3.1.1 整型
| 大小 | 有符号 | 无符号 |
| --- | --- | --- |
| 8-bit | i8 | u8 |
| 16-bit | i16 | u16 |
| 32-bit | i32 | u32 |
| 64-bit | i64 | u64 |
| arch | isize | usize |
> 值得注意的是，rust数据类型和go一样是自动推断的，所以在声明变量的时候，可以不用指定类型。
> 但是，如果想要指定类型，可以使用`let x: i32 = 5;`来指定类型。
1. 如果你确定了类型，但类型不匹配，rust会报错。
```rust
 Compiling rust1 v0.1.0 (/home/duty/rust/rust1)
error[E0600]: cannot apply unary operator `-` to type `u32`
  --> src/main.rs:11:19
   |
11 |     let x : u32 = -67;
   |                   ^^^ cannot apply unary operator `-`
   |
   = note: unsigned values cannot be negated

For more information about this error, try `rustc --explain E0600`.
error: could not compile `rust1` due to previous error
```
2. 如果i8的数据类型，我们给他赋值为129，rust会报错。
```rust
  Compiling rust1 v0.1.0 (/home/duty/rust/rust1)
error: literal out of range for `i8`
  --> src/main.rs:11:16
   |
11 |     let x:i8 = 129;
   |                ^^^
   |
   = note: `#[deny(overflowing_literals)]` on by default
   = note: the literal `129` does not fit into the type `i8` whose range is `-128..=127`
   = help: consider using the type `u8` instead

error: could not compile `rust1` due to previous error
```
3. 不同大小的整形的长度
```rust
   Compiling rust1 v0.1.0 (/home/duty/rust/rust1)
    Finished dev [unoptimized + debuginfo] target(s) in 0.30s
     Running `target/debug/rust1`
i8的最大值: 127
i8的最小值: -128
i16的最大值: 32767
i16的最小值: -32768
i32的最大值: 2147483647
i32的最小值: -2147483648
i64的最大值: 9223372036854775807
i64的最小值: -9223372036854775808
i128的最大值: 170141183460469231731687303715884105727
i128的最小值: -170141183460469231731687303715884105728
```

#### 3.1.2 浮点型
rust的浮点型包括f32和f64。
```rust
let x:f32 = 889_990_3.0;
println!("x = {}",x);
println!("f32的最大值: {}",std::f32::MAX);
println!("f32的最小值: {}",std::f32::MIN);
println!("f64的最大值: {}",std::f64::MAX);
println!("f64的最小值: {}",std::f64::MIN);
```
如上，我们可以使用`_`来分隔数字，使得数字更加易读。
输出结果：
```bash
  Compiling rust1 v0.1.0 (/home/duty/rust/rust1)
    Finished dev [unoptimized + debuginfo] target(s) in 0.30s
     Running `target/debug/rust1`
x = 8899903
f32的最大值: 340282350000000000000000000000000000000
f32的最小值: -340282350000000000000000000000000000000
f64的最大值: 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
f64的最小值: -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
```
#### 3.1.3 布尔型
rust的布尔型只有true和false。
```rust
let x = true;
let y:bool = false;
println!("x = {},y = {}",x,y);
```
输出结果：
```bash
  Compiling rust1 v0.1.0 (/home/duty/rust/rust1)
    Finished dev [unoptimized + debuginfo] target(s) in 0.30s
     Running `target/debug/rust1`
x = true,y = false
```
#### 3.1.4 字符型
rust的字符型是`char`，它的长度是4个字节。也就是单个字符或者汉字的长度。
使用utf-8编码。
```rust
let x = 'a';
let y:char = 'b';
println!("x = {},y = {}",x,y);
```
输出结果：
```bash
  Compiling rust1 v0.1.0 (/home/duty/rust/rust1)
    Finished dev [unoptimized + debuginfo] target(s) in 0.30s
     Running `target/debug/rust1`
x = a,y = b
```

### 3.2 复合类型
#### 3.2.1 元组
元组是一个有序的列表，可以存储不同类型的数据。
```rust
let x = (1,2,3);
let y = (1,"hello",true);
println!("x = {:?}",x);
println!("y = {:?}",y);
```
输出结果：
```bash
  Compiling rust1 v0.1.0 (/home/duty/rust/rust1)
    Finished dev [unoptimized + debuginfo] target(s) in 0.30s
     Running `target/debug/rust1`
x = (1, 2, 3)
y = (1, "hello", true)
```
#### 3.2.2 数组
数组是一个有序的列表，可以存储相同类型的数据。
```rust 
let x = [1,2,3];
let y = [1,2,3,4,5];
println!("x = {:?}",x);
println!("y = {:?}",y);
```
输出结果：
```bash
  Compiling rust1 v0.1.0 (/home/duty/rust/rust1)
    Finished dev [unoptimized + debuginfo] target(s) in 0.30s
     Running `target/debug/rust1`
x = [1, 2, 3]
y = [1, 2, 3, 4, 5]
```
#### 3.2.3 字符串
rust的字符串是`String`类型，它是一个可变的字符串。
```rust
let mut x = String::from("hello");
x.push_str(" world");
println!("x = {}",x);
```
输出结果：
```bash
  Compiling rust1 v0.1.0 (/home/duty/rust/rust1)
    Finished dev [unoptimized + debuginfo] target(s) in 0.30s
     Running `target/debug/rust1`
x = hello world
```

## 3. 变量
### 3.1 变量的声明
rust的变量声明使用`let`关键字。
```rust
let x = 1;
let y:i32 = 2;
println!("x = {},y = {}",x,y);
```
输出结果：
```bash
  Compiling rust1 v0.1.0 (/home/duty/rust/rust1)
    Finished dev [unoptimized + debuginfo] target(s) in 0.30s
     Running `target/debug/rust1`
x = 1,y = 2
```
### 3.2 变量的修改
rust的变量默认是不可变的，如果想要修改变量的值，需要使用`mut`关键字。
```rust
let mut x = 1;
x = 2;
println!("x = {}",x);
```
输出结果：
```bash
  Compiling rust1 v0.1.0 (/home/duty/rust/rust1)
    Finished dev [unoptimized + debuginfo] target(s) in 0.30s
     Running `target/debug/rust1`
x = 2
```
### 3.3 变量的隐藏
rust的变量可以隐藏，隐藏的变量会覆盖之前的变量。
```rust
let x = 1;
let x = 2;
println!("x = {}",x);
```
输出结果：
```bash
  Compiling rust1 v0.1.0 (/home/duty/rust/rust1)
    Finished dev [unoptimized + debuginfo] target(s) in 0.30s
     Running `target/debug/rust1`
x = 2
```
### 3.4 常量
rust的常量使用`const`关键字声明。
```rust
const X:i32 = 1;
const Y:i32 = 2;
println!("x = {},y = {}",X,Y);
```
输出结果：
```bash
  Compiling rust1 v0.1.0 (/home/duty/rust/rust1)
    Finished dev [unoptimized + debuginfo] target(s) in 0.30s
     Running `target/debug/rust1`
x = 1,y = 2
```

## 4. 函数
### 4.1 函数的声明
rust的函数使用`fn`关键字声明。
```rust
fn add(x:i32,y:i32) -> i32{
    x + y
}
fn main() {
    let x = 1;
    let y = 2;
    let z = add(x,y);
    println!("z = {}",z);
}
```
输出结果：
```bash
  Compiling rust1 v0.1.0 (/home/duty/rust/rust1)
    Finished dev [unoptimized + debuginfo] target(s) in 0.30s
     Running `target/debug/rust1`
z = 3
```
### 4.2 函数的参数
rust的函数参数可以有默认值。
```rust
fn add(x:i32,y:i32 = 2) -> i32{
    x + y
}
fn main() {
    let x = 1;
    let y = 2;
    let z = add(x);
    println!("z = {}",z);
}
```
输出结果：
```bash
  Compiling rust1 v0.1.0 (/home/duty/rust/rust1)
    Finished dev [unoptimized + debuginfo] target(s) in 0.30s
     Running `target/debug/rust1`
z = 3
```
### 4.3 函数的返回值
rust的函数可以有返回值，如果没有返回值，可以使用`()`表示。
```rust
fn add(x:i32,y:i32) -> i32{
    x + y
}
fn main() {
    let x = 1;
    let y = 2;
    let z = add(x,y);
    println!("z = {}",z);
}
```
输出结果：
```bash
  Compiling rust1 v0.1.0 (/home/duty/rust/rust1)
    Finished dev [unoptimized + debuginfo] target(s) in 0.30s
     Running `target/debug/rust1`
z = 3
```


## 5. 注释
rust的注释有两种，一种是单行注释，一种是多行注释。
单行注释使用`//`，多行注释使用`/* */`。
```rust
//单行注释
/*
多行注释
*/
```
## 6. 运算符
### 6.1 算术运算符
|运算符|描述|
|:---|:---|
|+|加|
|-|减|
|*|乘|
|/|除|
|%|取余|
### 6.2 比较运算符
|运算符|描述|
|:---|:---|
|==|等于|
|!=|不等于|
|>|大于|
|<|小于|
|>=|大于等于|
|<=|小于等于|
### 6.3 逻辑运算符
|运算符|描述|
|:---|:---|
|&&|逻辑与|
|\|\||逻辑或|
|!|逻辑非|
### 6.4 赋值运算符
|运算符|描述|
|:---|:---|
|=|赋值|
|+=|加赋值|
|-=|减赋值|
|*=|乘赋值|
|/=|除赋值|
|%=|取余赋值|
### 6.5 位运算符
|运算符|描述|
|:---|:---|
|&|按位与|
|\||按位或|
|^|按位异或|
|~|按位取反|
|<<|左移|
|>>|右移|
### 6.6 其他运算符
|运算符|描述|
|:---|:---|
|.|成员访问|
|->|成员访问|
|::|作用域|
|:|类型标注|
|@|模式匹配|
|..|范围|
|..=|范围|
|...|范围|
|,|分隔符|
|;|分隔符|
|=>|键值对|
|->|返回类型|
|=>|闭包|
|->|闭包|

rust-1

## next-terminal中的context

```go
package repository

import (
	"context"

	"next-terminal/server/constant"
	"next-terminal/server/env"

	"gorm.io/gorm"
)

type baseRepository struct {
}

func (b *baseRepository) GetDB(c context.Context) *gorm.DB {
	db, ok := c.Value(constant.DB).(*gorm.DB)
	if !ok {
		return env.GetDB()
	}
	return db
}
```

其中定义了一个基础的baseRepository,所有的rep全部组合baseRepository,然后通过GetDB方法获取其中的gorm.DB.目前来看,这种方式可以减少大量的repo的初始化过程,新创建的repo只需要组合baseRepository即可正常的使用gorm.DB.
这里使用它来存储一个gorm.DB,数据,以便每次需要使用时直接在context中取出来.





## Gorm Docs中的context描述

1. 单一会话模式
`db.WithContext(ctx).Find(&users)`
这种情况下,我不太理解这样用的目的,但可以将其中的ctx初始化为一个超时返回context`ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)`,这样的话,可以在sql语句超时后及时返回.

2. 连续会话模式
这个是我觉得最有用的一种context的使用,使用context将多条语句的操作联系起来.
```go
tx := db.WithContext(ctx)
tx.First(&user, 1)
tx.Model(&user).Update("role", "admin")
```

3. 携带值的context
通过context的方式将gorm.DB放在context中,在编写api需要gorm.DB时直接取出,这样看来,和上文next-terminal中的context的使用方式类似.

```go
func SetDBMiddleware(next http.Handler) http.Handler {
  return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    timeoutContext, _ := context.WithTimeout(context.Background(), time.Second)
    ctx := context.WithValue(r.Context(), "DB", db.WithContext(timeoutContext))
    next.ServeHTTP(w, r.WithContext(ctx))
  })
}

r := chi.NewRouter()
r.Use(SetDBMiddleware)

r.Get("/", func(w http.ResponseWriter, r *http.Request) {
  db, ok := ctx.Value("DB").(*gorm.DB)

  var users []User
  db.Find(&users)

  // lots of db operations
})
```

Gorm中Context

# 从头配置一个GitNote环境

## 一、安装gitnote
不过多赘述，自己在官网下载即可，不过提一点，我用的github，仓库无法拉取下来，只能自己下载下来后绑定仓库。

> 后续：由于GitHub新建仓库默认只有main分支，而gitnote默认拉取master分支，所以无法拉取成功，解决方法：新建一个master分支，或者直接将默认的main分支改为master。






## 二、配置插件
由于未知因素可能导致插件无法下载成功，我们可以选择通过作者的[插件仓库]()将插件下载到本地，然后解压`{user}/.gitnote/plugins`中。

### 配置图床
由于自带的github图床永远无法成功，可以使PicGo+GitHub+jsdelivr配置图床，具体操作如下：
 1. 在Github创建一个用于存放图片的仓库。

 2. 创建一个访问令牌，具体权限如下：![](https://gcore.jsdelivr.net/gh/blue-duty/gitnote-images/img/20220915005550.png)

 3. 配置PicGo，如图，仓库名和分支名按实际情况填写，Token即为上步设置的访问令牌，存储路径按自己想法填写，**自定义域名为: `https://gcore.jsdelivr.net/gh/{git用户名}/{仓库名}`**![](https://gcore.jsdelivr.net/gh/blue-duty/gitnote-images/img/20220915005700.png)

 4. 设置完成后，就通过PicGo上传图片。

## 三、Git更新仓库
目前来看，GitNote只能将变更提交到本地而无法推送到远端，所以，我们只能自己进行`git pull`之后，才能更新远端仓库中的内容。

从头配置一个GitNote环境

# 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
}

```