分享数据过程
read 从磁盘读取文件数据 write 通过网络协议发送给客户端，但在操作系统中过程就不像图中表现的这么简单。
Linux传统文件传输过程
在linux系统文件传输的过程中，发生了4次用户态与内核态的上下文切换，和4次数据拷贝。
]]>操作系统为了隔离系统程序和应用程序把系统分为了用户空间和内核空间，而用户空间和内核空间的权限也不同。
read 从磁盘读取文件数据 write 通过网络协议发送给客户端，但在操作系统中过程就不像图中表现的这么简单。
在linux系统文件传输的过程中，发生了4次用户态与内核态的上下文切换，和4次数据拷贝。
]]>操作系统为了隔离系统程序和应用程序把系统分为了用户空间和内核空间，而用户空间和内核空间的权限也不同。
sql 语句的静态模版和动态数据没有严格的区分，如果在数据项中加入某些sql关键字,这些关键字就很可能在写入或读取数据时得到执行。
代码中遇到需要调用某个命令才能完成的功能时，会涉及到命令拼接，如果命令拼接没有做好安全过滤，那么将会导致命令输入风险。
资源访问或操作的时候主体权限没有进行校验就会造成越权问题，细分为：未授权，水平越权和垂直越权
服务器请求伪造攻击，指攻击者利用后端服务器为跳板，让后端服务向非预期网络地址（例如：内网地址）发出恶意请求，获取敏感信息或执行恶意操作。
恶意上传文件或脚本，用于攻击或分享。
本质上http服务端的漏洞在websocket上也会存在。
go install golang.org/x/vuln/cmd/govulncheck@latestgovulncheck ./..// 可通过 -db 指定一个外部的Go漏洞某些需要重定向到其他站点的功能，参数中经常携带需要重定向的URL,但是实际程序中没有控制重定向的范围，导致攻击者可以构造恶意的链接，诱导用户到恶意网站。
跨站脚本攻击，攻击者往目标WEB页面插入恶意的代码，当用户访问时，嵌入代码会被执行，达到恶意攻击用户的目的
跨站请求伪造：允许攻击者诱导用户访问恶意链接，执行用户非预期执行的操作
在网页中将恶意代码等隐藏值看似无害的内容或按钮中，并引导用户点击，用户点击后往往会执行一些非预期操作。
cors本身不存在漏洞，但由于开发时的错误配置，导致非预期的网站可以进行跨域访问。
发生场景
以需要跨域访问 example.com 所有子域名为例：
防护方案
将元素不断地插入已经排序好的 array 中
// 插入排序func InsertionSort(arr []int) []int { for i := 1; i < len(arr); i++ { k := arr[i] j := i - 1 for j >= 0 && arr[j] > k { arr[j+1] = arr[j] j = j - 1 } arr[j+1] = k } return arr}//i = 1 k = 5 j = 0 arr[j] = 6 arr = 6 6 2 1 3 4 j = -1 arr = 5 6 2 1 3 4//i = 2 k = 2 j = 1 arr[j] = 6 arr = 5 6 6 1 3 4 j = 0 arr = 5 5 6 1 3 4 j = -1 arr = 2 5 6 1 3 4......func TestInsertionSort(t *testing.T) { a := []int{6, 5, 2, 1, 3, 4} fmt.Println(InsertionSort(a))}
分治思想，不断分割序列直到序列整体有序
func QuickSort(arr []int, left, right int) []int { if left >= right { return arr } // 左指针大于右指针递归结束 l, r, cur := left, right, arr[left] for l < r { // l == r 所有值被变量 for l < r && arr[r] >= cur { //轴点取最左边值 需要先移动右指针 r-- } for l < r && arr[l] <= cur { l++ } arr[l], arr[r] = arr[r], arr[l] } arr[left], arr[r] = arr[r], arr[left] QuickSort(arr, left, l-1) QuickSort(arr, l+1, right) return arr}// cur = 6 l = 0 l = 1 l = 2 l = 3 l = 4 l = 5 r = 5 arr[r] = 4 arr[l] = 6->5->2->1->3->4 a[5],a[5] = a[5],a[5] [6,5,2,1,3,4] [4,5,2,1,3,6]// cur = 4 l = 0 l = 1 r = 4 arr[r] = 3 arr[l] = 4->5 a[1],a[4] = a[4],a[1] [4,3,2,1,5,6] l < r l = 1 r = 3 a[1] = 3 l = 2 a[2] = 2 l = 3 a[3] = 1 [4,3,2,1,5,6] [1,3,2,4,5,6]......
利用堆的性质形成的排序算法
为了使得多种设备能通过网络相互通信，和为了解决各种不同设备在网络互联中的兼容性问题，国际标准化组织制定了开放式系统互联通信参考模型（Open System Interconnection Reference Model），也就是 OSI 网络模型
OSI 模型把网络通信的工作分为 7 层，从下到上分别是物理层、数据链路层、网络层、传输层、会话层、表示层和应用层。OSI 只是存在于概念和理论上的一种模型，它的缺点是分层太多，增加了网络工作的复杂性，所以没有大规模应用。后来人们对 OSI 进行了简化，合并了一些层，最终只保留了 4 层，从下到上分别是接口层、网络层、传输层和应用层，形成常用的 TCP/IP 模型。
对于同一台设备上的进程间通信，有很多种方式，比如有管道、消息队列、共享内存、信号等方式，而对于不同设备上的进程间通信，就需要网络通信，而设备是多样性的，所以要兼容多种多样的设备，就需要有一套通用的网络协议。
最上层，我们能直接接触的就是应用层（Application Layer）,像电脑或手机软件都是在应用层上实现的，所有应用层只需要专注为用户提供应用功能，如： HTTP,FTP,DNS 等，应用层是不关注数据是如何去运输的，而且应用层是工作在操作系统的用户态，运输层及以下则工作在内核态。
第二层，应用层的数据包会传给运输层，运输层（Transport Layer）是为应用层提供网络支持的，当两个不同设备的应用需要通信的时候，应用就把应用数据传给下一层，也就是运输层，运输层有两个协议TCP和UDP，当设备作为接收方时，传输层则要负责把数据包传给应用，但是一台设备上可能会有很多应用在接收或者传输数据，因此需要用一个编号将应用区分开来，这个编号就是端口
TCP的全程叫运输控制协议，大部分的应用都是使用的TCP运输协议如：HTTP，TCP相对于UDP多了很多特性，如流量控制,超时重传,拥塞控制等，这些特性都是为了能保证数据包能可靠的运输给对方，当应用中需要传输的数据非常大，如果直接传输就不好控制，因此传输层的数据包大小超过MSS（TCP最大报文长度），就会将数据包分块，这样就算其中一个分块传输丢失或损坏只需重新发送这一个，而不是整个数据包，在TCP协议中，把每一个分块称为TCP段（TCP Segment）。
UDP相对TCP要简单很多，只负责发送数据包，不保证数据包能否抵达对方，这样运输会提高运输效率，如果把TCP的特性在应用层实现也可以让UDP实现可靠运输。
第三层，传输层只负责服务好应用，作为应用间数据传输的媒介，帮助实现应用到应用的通信，而实际的传输功能就交给下一层，也就是网络层（Internet Layer），网络层最常使用的是 IP 协议（Internet Protocol），IP 协议会将传输层的报文作为数据部分，再加上 IP 包头组装成 IP 报文，如果 IP 报文大小超过 MTU（以太网中一般为 1500 字节）就会再次进行分片，得到一个即将发送到网络的 IP 报文。
生成了 IP 头部之后，接下来要交给网络接口层（Link Layer）在 IP 头部的前面加上 MAC 头部，并封装成数据帧（Data frame）发送到网络上，MAC 头部是以太网使用的头部，它包含了接收方和发送方的 MAC 地址等信息，我们可以通过 ARP 协议获取对方的 MAC 地址，所以说，网络接口层主要为网络层提供「链路级别」传输的服务，负责在以太网、WiFi 这样的底层网络上发送原始数据包，工作在网卡这个层次，使用 MAC 地址来标识网络上的设备。
由于 OSI 模型实在太复杂，提出的也只是概念理论上的分层，并没有提供具体的实现方案。比较常见，也比较实用的是四层模型，即 TCP/IP 网络模型
Go语言中提供了一种类型叫做接口类型。接口是一种抽象类型，它并没有暴露所含数据的布局或内部结构，当然也没有哪些数据的基本操作，它所提供的仅仅是一些方法而已。如果你拿到一个接口类型的值，你无从知道它是什么，你能知道的仅仅是它能做什么，也就是说，仅仅能知道它提供了哪些方法。
一个接口类型定义了一套方法，如果一个具体的类型要实现该接口，那么必须实现该接口类型定义中的所有方法。
//声明 A 接口 包含 B 和 C 两个方法type A interface { B() float64 C() float64}//也可以组合已有的接口得到新的接口type AA interface { A D(int) float64 }一个接口可以被多个类型实现，一个类型也可以实现多个接口
type Shape interface { GetArea() float64 GetPerimeter() float64}type Circle struct { R float64}// Circle实现Shape接口的GetArea方法func (c Circle)GetArea() float64 { return 3.14 * c.R * c.R}// Circle实现Shape接口的GetPerimeter方法func (c Circle)GetPerimeter() float64 { return 3.14 * 2 * c.R}Go语言支持：函数、匿名函数和闭包 定义函数使用func关键字
//函数名：由字母、数字、下划线组成。但函数名的第一个字母不能是数字。在同一个包内，函数名也不能重名func 函数名(参数)(返回值) { 函数体}Go语言中调用函数，传递过来的变量就是函数的实参，函数可以通过两种方式来传递参数：值传递 和 引用传递
值传递: 调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数
引用传递: 调用函数时将实际参数的地址传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数
func swap(x, y *int){ var temp int temp = *x /* 保存 x 的值 */ *x = *y /* 将 y 值赋给 x */ *y = temp /* 将 temp 值赋给 y*/}//其中args是一个slice，我们可以通过arg[index]依次访问所有参数,通过len(arg)来判断传递参数的个数func myfunc(args ...int){ //0个或多个参数}//任意类型的不定参数func myfunc(args ...interface{}){}]]>wire 是由 google 开源的一个供 Go 语言使用的依赖注入代码生成工具。它能够根据你的代码，生成相应的依赖注入 go 代码。
与其他依赖注入工具不同，比如 Uber 的 Dig 和 Facebook 的 Inject，这 2 个工具都是使用反射实现的依赖注入，而且是运行时注入（runtime dependency injection）。
wire 是编译代码时生成代码的依赖注入，是编译期间注入依赖代码（compile-time dependency injection）。而且代码生成期间，如果依赖注入有问题，生成依赖代码时就会出错，就可以报出问题来，而不必等到代码运行时才暴露出问题。
go tool compile -N -l -S test.goslice表示切片(分片)，例如对一个数组进行切片，取出数组中的一部分值slice依赖于数组
slice自身维护了一个指针属性，指向它底层数组的某些元素的集合
slice代表变长的序列，它的底层是数组。一个切片由3部分组成：指针、长度和容量。指针指向底层数组，长度代表slice当前的长度，容量代表底层数组的长度。
可以在runtime中的slice中查看slice的实现原理 type slice struct { array unsafe.Pointer len int cap int }slice := make([]T, 5) 第二个参数定义长度 若是不传长度则与cap相同slice := []int{1, 2, 3, 4} 创建长度与容量都为4的切片slice[i:j:k] i 起始位置 j 切片长度 k 切片容量 简写 slice[i:] slice[:j] slice[:]函数的参数都是按值传递的，因此在调用函数时，会将参数的副本传递给函数。
在传递slice时 虽然传递的是副本 但是副本同样指向了源slice的底层数组
所以在函数内部修改slice，有可能会影响到底层数组，进而影响到其他slice 但是如果传参后切片长度发生变化，切片会自动扩容为新的地址，就无法影响到其他slice 如果想实现影响其他slice 可通过函数返回 或 指针实现
//测试Slice/* 传参前内容 地址 [1 2], addr is 0x1400011e018, ptr is 0x1400012c010 传参的内容 地址 [3 2], addr is 0x1400011e060, ptr is 0x1400012c010 传参后内容 地址 [3 2], addr is 0x1400011e018, ptr is 0x1400012c010*/func TestSlice() { slice := []int{1, 2} fmt.Printf("传参前内容 地址 %v, addr is %p, ptr is %p\n", slice, &slice, slice) TestSliceChange(slice) fmt.Printf("传参后内容 地址 %v, addr is %p, ptr is %p\n", slice, &slice, slice) return}func TestSliceChange(slice []int) { slice[0] = 3 // [3 2] 0xc00000e090 0xc00001a2d0 fmt.Printf("传参的内容 地址 %v, addr is %p, ptr is %p\n", slice, &slice, slice)}/* 传参前内容 地址 [1 2], addr is 0x1400011e018, ptr is 0x1400012c010 传参的内容 地址 [1 2 3], addr is 0x1400011e060, ptr is 0x14000134000 传参后内容 地址 [1 2], addr is 0x1400011e018, ptr is 0x1400012c010 传参后再修改内容 地址 [4 2], addr is 0x1400011e018, ptr is 0x1400012c010*/func TestSlice() { slice := []int{1, 2} fmt.Printf("传参前内容 地址 %v, addr is %p, ptr is %p\n", slice, &slice, slice) TestSliceChange(slice) fmt.Printf("传参后内容 地址 %v, addr is %p, ptr is %p\n", slice, &slice, slice) slice[0] = 4 fmt.Printf("传参后再修改内容 地址 %v, addr is %p, ptr is %p\n", slice, &slice, slice) return}func TestSliceChange(slice []int) { //传参 // slice[0] = 3 //使用函数append slice = append(slice, 3) fmt.Printf("传参的内容 地址 %v, addr is %p, ptr is %p\n", slice, &slice, slice)}// 不同slice声明 var c []int d := []int{} e := make([]int, 0) jc, _ := json.Marshal(c) // null jd, _ := json.Marshal(d) // [] je, _ := json.Marshal(e) // []// 使用 []int{} 或 make([]int,0) 声明的slice 不为nil //slice 可以不指定长度 array 必须指定长度 slice: var a []int a := make([]int,len,cap) array: var b [lenght]int//slice 长度可以动态扩缩容 array 长度是编译时静态计算的 func() { var s []int // s := make([]int, 100) fmt.Println(len(s)) fmt.Println(cap(s)) }() func() { var a [100]int fmt.Println(len(a)) fmt.Println(cap(a)) }() run 输出 0 0 100 100// benchmake slice array go1.18 func TestCallSlice(s []int) { } func TestCallArray(a [10000]int) { } //go:noinline func BenchmarkTestCallSlice(b *testing.B) { s := make([]int, 10000) for n := 0; n < b.N; n++ { TestCallSlice(s) } } //go:noinline func BenchmarkTestCallArray(b *testing.B) { var a [10000]int for n := 0; n < b.N; n++ { TestCallArray(a) } } goos: darwin goarch: arm64 pkg: test BenchmarkTestCallSlice BenchmarkTestCallSlice-8 1000000000 0.3501 ns/op 0 B/op 0 allocs/op BenchmarkTestCallArray BenchmarkTestCallArray-8 1000000000 0.3494 ns/op 0 B/op 0 allocs/op PASS ok test 0.848s /* 声明 []int , len is 0, cap is 0 append 1 , len is 1, cap is 1 append 2 , len is 2, cap is 2 append 3 , len is 3, cap is 4 append 4 , len is 4, cap is 4 ... append 254, len is 256, cap is 256 append 511, len is 512, cap is 512 append 511, len is 513, cap is 848 append 846, len is 848, cap is 848 append 847, len is 849, cap is 1280*/ func TestSliceLen() { var a []int fmt.Printf("声明 []int , len is %v, cap is %v\n", len(a), cap(a)) a = append(a, 0) fmt.Printf("append 1 , len is %v, cap is %v\n", len(a), cap(a)) a = append(a, 1) fmt.Printf("append 2 , len is %v, cap is %v\n", len(a), cap(a)) a = append(a, 2) fmt.Printf("append 3 , len is %v, cap is %v\n", len(a), cap(a)) a = append(a, 3) fmt.Printf("append 4 , len is %v, cap is %v\n", len(a), cap(a)) a = append(a, 4) fmt.Printf("append 5 , len is %v, cap is %v\n", len(a), cap(a)) a = append(a, 5) fmt.Printf("append 6 , len is %v, cap is %v\n", len(a), cap(a)) for i := 5; i < 1025; i++ { a = append(a, i) fmt.Printf("append %v, len is %v, cap is %v\n", i, len(a), cap(a)) } } // 由此可见slice 每次扩容都是成倍扩容 但是在达到一定阀值后 就以1.25倍扩容后判断et.size 等于 1 不做任何操作 goarch.PtrSize 编译器将除法/乘法优化为一个常量的移位。 对于2的幂，使用可变移位。 // /src/runtime/slice.go growslice newcap := old.cap doublecap := newcap + newcap if cap > doublecap { newcap = cap } else { const threshold = 256 if old.cap < threshold { newcap = doublecap } else { // Check 0 < newcap to detect overflow // and prevent an infinite loop. for 0 < newcap && newcap < cap { // Transition from growing 2x for small slices // to growing 1.25x for large slices. This formula // gives a smooth-ish transition between the two. newcap += (newcap + 3*threshold) / 4 } // Set newcap to the requested cap when // the newcap calculation overflowed. if newcap <= 0 { newcap = cap } } } var overflow bool var lenmem, newlenmem, capmem uintptr // Specialize for common values of et.size. // For 1 we don't need any division/multiplication. // For goarch.PtrSize, compiler will optimize division/multiplication into a shift by a constant. // For powers of 2, use a variable shift. switch { case et.size == 1: lenmem = uintptr(old.len) newlenmem = uintptr(cap) capmem = roundupsize(uintptr(newcap)) overflow = uintptr(newcap) > maxAlloc newcap = int(capmem) case et.size == goarch.PtrSize: lenmem = uintptr(old.len) * goarch.PtrSize newlenmem = uintptr(cap) * goarch.PtrSize capmem = roundupsize(uintptr(newcap) * goarch.PtrSize) overflow = uintptr(newcap) > maxAlloc/goarch.PtrSize newcap = int(capmem / goarch.PtrSize) case isPowerOfTwo(et.size): var shift uintptr if goarch.PtrSize == 8 { // Mask shift for better code generation. shift = uintptr(sys.Ctz64(uint64(et.size))) & 63 } else { shift = uintptr(sys.Ctz32(uint32(et.size))) & 31 } lenmem = uintptr(old.len) << shift newlenmem = uintptr(cap) << shift capmem = roundupsize(uintptr(newcap) << shift) overflow = uintptr(newcap) > (maxAlloc >> shift) newcap = int(capmem >> shift) default: lenmem = uintptr(old.len) * et.size newlenmem = uintptr(cap) * et.size capmem, overflow = math.MulUintptr(et.size, uintptr(newcap)) capmem = roundupsize(capmem) newcap = int(capmem / et.size) } // 但是append批量赋值的时候 go 会对其进行内存优化 例: append(s,1,2,3) len 3 cap 3 // 预先分配内存可以提升性能 index赋值要比append赋值性能好 func BenchmarkAppend(b *testing.B) { b.ReportAllocs() for i := 0; i < b.N; i++ { var a []int for j := 0; j < 10000; j++ { a = append(a, j) } } } BenchmarkAppend-8 46833 25123 ns/op 357626 B/op 19 allocs/op func BenchmarkAppendStaticCap(b *testing.B) { b.ReportAllocs() for i := 0; i < b.N; i++ { a := make([]int, 0, 10000) for j := 0; j < 10000; j++ { a = append(a, j) } } } BenchmarkAppendStaticCap-8 150697 7362 ns/op 81920 B/op 1 allocs/op func BenchmarkAppendIndex(b *testing.B) { b.ReportAllocs() for i := 0; i < b.N; i++ { a := make([]int, 10000) for j := 0; j < 10000; j++ { a[j] = j } } } BenchmarkAppendIndex-8 165469 6781 ns/op 81920 B/op 1 allocs/op func TestSliceBce(a []int) { _ = a[3] //检查边界 s := 0 s += a[0] //边界检查消除 s += a[1] //边界检查消除 s += a[2] //边界检查消除 s += a[3] //边界检查消除 _ = a[index:] // 需要边界检查 _ = a[:index] // 边界检查消除 // print(s) }是一种无序的键值对的集合。Map 最重要的一点是通过 key 来快速检索数据，key 类似于索引，指向数据的值。Map 是一种集合，所以我们可以像迭代数组和切片那样迭代它。不过，Map 是无序的，我们无法决定它的返回顺序，这是因为 Map 是使用 hash 表来实现的。
声明是不会分配内存的，初始化分配内存后才能赋值和使用。
声明 var map t map[int]int 初始化 t = make(map[int]int,0) var t map[int]int = map[int]int{1,1} t = map[int]int{1} 读取 i := m["a"] i,ok := m["b"] //可用第二个参数判断是否存在 删除 delete(m,"a")key类型可以是 bool、数字、string、指针、channel , 只包含前面几个类型的接口、结构体、数组，通常为 int 或 string 但是 slice map func 不可以value类型基本和key一样 通常为数字 字符串 接口map[string]stringmap[int]stringmap[int]interfacemap 在 go 中属于 reference 类型 作为传参或返回类型的时候 传递的也是地址 不是map本体 map 在没有初始化的时候为 nilappend 支持 非nil和nil的map，都能进行成功的appendmap 是非线程安全的 可以通过内嵌的结构体加 读写锁 实现线程安全声明 var counter = struct{ sync.RWMutex m map[string]int }{m: make(map[string]int)}读 counter.RLock() n := counter.m["some_key"] counter.RUnlock() fmt.Println("some_key:", n)写 counter.Lock() counter.m["some_key"]++ counter.Unlock()map 是 hashmap 读取遍历是无法保证顺序的 如果保证key的遍历顺序可以通过将key保存到一个slice import "sort" var m map[int]string var keys []int for k := range m { keys = append(keys, k) } sort.Ints(keys) for _, k := range keys { fmt.Println("Key:", k, "Value:", m[k]) }map 无法打印 kay value 的值 会随着map的扩容改变但是 map 删除key 无法自动缩容 最近发现别人的hexo访问速度是我hexo的好几倍，于是就抱着试一试的心态把next从5.0 升级到6.0，下面记录升级后遇到的坑
可能是版本太高和之前的模块不兼容造成的，有部分页面没有渲染, 尝试把hexo版本退回3.2问题没有解决，可能是因为next版本的问题尝试升级回hexo5.0，next修改为5.4 内容出现，之前修改的mores标签无法使用 导致文章部分缺失~~~
在文章下方可以使用more语句进行截断，这样博客首页只会出现文章的前面一小部分，看起来很清爽简约，但是要想展示文章的中间段落就无法实现，我们可以修改为被<!--mores-->包裹的段落展示在首页
Go语言的rpc包的是建立在net包基础之上的（内置）。基于TCP协议
服务端
#server.gopackage mainimport ( "net" "net/http" "net/rpc")// 计算type Sum struct {}// 计算方法func (s *Sum) sums(req string, resp *string) error { *resp = req+1 return nil}func main() { // 功能对象注册 sum := new(Sum) err := rpc.Register(sum) if err != nil { panic(err.Error()) } // HTTP注册 rpc.HandleHTTP() // 端口监听 listen, err := net.Listen("tcp", ":8081") if err != nil { panic(err.Error()) } // 启动服务 _ = http.Serve(listen, nil)}客户端
#client.gopackage mainimport ( "fmt" "net/rpc")func main() { // 建立连接 client, err := rpc.DialHTTP("tcp", "localhost:8081") if err != nil { panic(err.Error()) } // 参数 req := 100 var resp *string // 同步调用 err = client.Call("Sum.sums", req, &resp) if err!= nil { panic(err.Error()) } fmt.Println(*resp) // 异步调用 syncCall := client.Go("Sum.sums", req, &resp, nil) // 阻塞，异步调用成功后解除阻塞 replayDone := <-syncCall.Done fmt.Println(replayDone) fmt.Println(*resp)}Go语言的rpc包的是建立在net包基础之上的（内置）。基于TCP协议,再原有的rpc结构上把传入传出方式改为json字符串就可以实现jsonrpc
rpc 结合 protobuf 实现grpc
1.首先要安装grpc(基于mac)
brew tap grpc/grpcbrew install protobufgo get -u github.com/golang/protobuf/protogo get -u github.com/golang/protobuf/protoc-gen-go2.编写 proto 条件
#message.protosyntax = "proto3";package message;option go_package = "./;message";// 加密请求message EncryptionRequest{string str = 1;}// 加密返回值message EncryptionResult{string result = 1;}3.编译proto
protoc ./message.proto --go_out=./
4.编写程序
服务端
```
#server.go
// 加密服务实现类
type EncryptionServiceImpl struct {
}
// 加密程序
func (es *EncryptionServiceImpl) Encryption(ctx context.Context, request *message.EncryptionRequest) (*message.EncryptionResult, error){
md5Str := ToMd5(request.GetStr()) res := message.EncryptionResult{Result:md5Str} return &res,nil}
// 简单封装的 md5
func ToMd5(s string) string{
m := md5.New() m.Write([]byte (s)) return hex.EncodeToString(m.Sum(nil))}
func main() { // 创建一个 grpc server server := grpc.NewServer() message.RegisterEncryptionServiceServer(server, new(EncryptionServiceImpl)) lis, err := net.Listen("tcp", ":8081") if err != nil { panic(err.Error()) } _ = server.Serve(lis) } ```* 客户端 ``` #client_test.go func TestClient(t *testing.T) { //1、Dail连接 conn, err := grpc.Dial("localhost:8081", grpc.WithInsecure()) if err != nil { panic(err.Error()) } defer conn.Close() encryptionServiceClient := message.NewEncryptionServiceClient(conn) orderRequest := &message.EncryptionRequest{Str: "mclink"} result, err := encryptionServiceClient.Encryption(context.Background(), orderRequest) if result != nil { fmt.Println(result.Result) } } ```RPC是Remote Procedure Call Protocol 单词首字母缩写，简称RPC，中文叫：远程过程调用协议 ,特点：这种调用的过程跨越了物理服务器的限制，是在网络中完成的，在调用远端服务器上程序的过程中，本地程序等待返回调用结果，直到远端程序执行完毕，将结果进行返回本地，最终完成一次完整的调用。
Goroutine 和 channel 是 Go 语言并发编程的 两大基石。Goroutine 用于执行并发任务，channel 用于 goroutine 之间的同步、通信。
Channel 在 gouroutine 间架起了一条管道，在管道里传输数据，实现 gouroutine 间的通信；由于它是线程安全的，所以用起来非常方便；channel 还提供“先进先出”的特性；它还能影响 goroutine 的阻塞和唤醒。
Go中不通过共享内存来通信，而是通过通信来共享内存，
Channel是Go中的一个核心类型，可以把它看成一个管道，通过它并发核心单元就可以发送或者接收数据进行通讯(communication)。它的操作符是箭头 <-
ch <- v // 发送值v到Channel ch中v := <-ch // 从Channel ch中接收数据，并将数据赋值给v//箭头的指向就是数据的流向指针是指向另一个地址的值（pointer）在Go语言中可以被拆分为两个核心概念：
类型指针，允许对这个指针类型的数据进行修改，传递数据可以直接使用指针，而无须拷贝数据，类型指针不能进行偏移和运算。
切片，由指向起始元素的原始指针、元素数量和容量组成。
在Go中，指针类型的字面形式为*T，其中T为一个任意类型。类型T称为指针类型 T 的基类型（base type）如果一个指针类型的基类型为T，则我们可以称此指针类型为一个T指针类型。如果一个指针类型的底层类型是T，则它的基类型为T。如果两个无名指针类型的基类型为同一类型，则这两个无名指针类型亦为同一类型。
*int // 一个基类型为int的无名指针类型。**int // 一个多级无名指针类型，它的基类型为*int。type Ptr *int // Ptr是一个具名指针类型，它的基类型为int。type PP *Ptr // PP是一个具名多级指针类型，它的基类型为Ptr。指针类型的零值的字面量使用预声明的nil来表示。一个nil指针（常称为空指针）中不存储任何地址。如果一个指针类型的基类型为T，则此指针类型的值只能存储类型为T的值的地址。
&取出地址，*根据地址取出地址指向的值。
var ptr *int //指针声明var a int=1ptr = &afmt.Println(*ptr)func main() { var a *int fmt.Println("%#v",a) //(*int)(nil) *a = 1 //保错 panic: runtime error: invalid memory address or nil pointer dereference --> //解决办法 初始化一个内存，并把该内存地址赋予指针变量 *a = &b 或 *a = new(int) *a = 1}/* stack上分配内存效率比heap更高，而且stack上分配的内存不用做GC，超出了作用域，就自动回收内存。 放在heap上的内存，需要由GC来做内存回收，而且容易产生内存碎片。 编译器在编译期决定变量分配在stack还是heap上，需要做逃逸分析(escape analysis)，逃逸分析在编译阶段就完成了。*/type foo struct { a string b int}/* 变量result定义的时候会在这个goroutine的stack上分配result的内存空间。 当函数返回时，getFooValue的调用方如果有接收返回值，那result的值会被拷贝给对应的接收变量。 stack上变量result的内存空间会被释放(标记为不可用，不能再被访问，除非这块空间再次被分配给其它变量) 但是如果foo占用的内存空间比较小，约0.3KB，goroutine的stack空间足够存储，如果foo占用的空间过大，在stack里存储不了，就会分配内存到heap上。*/func getValueFoo () foo { var r foo return r}/* 函数getFooPointer因为返回的是一个指针，如果变量result分配在stack上，那函数返回后，result的内存空间会被释放，就会导致接受函数返回值的变量无法访问原本result的内存空间，成为一个悬浮指针(dangling pointer)。 所以这种情况会发生内存逃逸，result会分配在heap上，而不是stack上。*/func getFooPointer() *foo { var result foo return &result}func f(p *foo) { fmt.Println(p)}func main() { p := &foo{} f(p)}在Go语言中数据类型数据类型用于声明函数和变量。不同数据类型把数据分成所需内存大小，编程时根据数据的不同大小使用不同的数据类型，起到充分利用内存的作用
// src/runtime/string.go type stringStruct struct { str unsafe.Pointer //指针指向存储实际字符串的内存地址 len int }派生类型
指针类型
一个指针变量可以指向任何一个值的内存地址，它所指向的值的内存地址在 32 和 64 位机器上分别占用 4 或 8 个字节，占用字节的大小与所指向的值的大小无关。当一个指针被定义后没有分配到任何变量时，它的默认值为 nil。指针变量通常缩写为 ptr，ptr 的类型为 * T，称做 T 的指针类型，*代表指针。变量、指针和地址三者的关系是，每个变量都拥有地址，指针的值就是地址。
Go 语言的取地址符是 &，放到一个变量前使用就会返回相应变量的内存地址，在指针类型前面加上 * 号（前缀）来获取指针所指向的内容，当一个指针被定义后没有分配到任何变量时，它的值为 nil
获取变量地址 &变量 声明指针变量 var 变量 *类型 指针变量赋值 指针变量 = &变量 指针变量取值 *指针变量输出变量 指针输出地址 空指针 输出nil 数组类型
数组是具有相同唯一类型的一组已编号且长度固定的数据项序列，这种类型可以是任意的原始类型例如整型、字符串或者自定义类型。
数组声明 var 变量名称 [长度] 类型 数组初始化 var 变量 = [长度]类型{初始化值*长度} //如果不确定长度可用...代替 [...] 数组元素赋值 变量[下标] = 值 数组元素取值 变量[下标]结构体类型
结构体是由一系列具有相同类型或不同类型的数据构成的数据集合，数组中只能存储同一类型的数据，但在结构体中我们可以为不同项定义不同的数据类型。
结构体定义 type 结构体名 struct {不同类型数据....} 结构体创建 结构体名{对应的不同数据...} 结构体访问 结构体.结构体数据 结构体做数据类型 var 变量 结构体名称 结构体指针 var 变量 *结构体 结构体指针赋值 (*结构体).结构体数据 = 值 或 结构体.结构体数据 := 值Channel 类型
Channel是Go语言中比较重要的部分，经常在Go中的并发中使用。Channel可以看成一个管道，通过它并发核心单元就可以发送或者接收数据进行通讯(communication)。它的操作符是箭头 <- 。
创建channel 变量 make(chan 类型,容量) > chan T // 可以接收和发送类型为 T 的数据 > chan<- float64 // 只可以用来发送 float64 类型的数据 > <-chan int // 只可以用来接收 int 类型的数据函数类型
函数是基本的代码块，用于执行一个任务。Go 语言最少有个 main() 函数。可以通过函数来划分不同功能，逻辑上每个函数执行的是指定的任务
函数声明 func 函数名称 (传参) 返回参数 { 作用域 }切片类型
Go 语言切片是对数组的抽象。Go 数组的长度不可改变，在特定场景中这样的集合就不太适用，Go 中提供了一种灵活，功能强悍的内置类型切片(“动态数组”)，与数组相比切片的长度是不固定的，可以追加元素，在追加时可能使切片的容量增大
切片创建 var 变量 []类型 make([]类型, 长度) 切片初始化 变量 := [] int {值} 切片截取 变量 := [开始:结束] 空切片 空切片默认为nil 切片操作 len() 获取切片长度 cap() 获取切片最长长度 append() 向切片添加内容 copy() 赋值切片接口类型
所有的具有共性的方法定义在一起，任何其他类型只要实现了这些方法就是实现了这个接口
接口定义 type 接口名称 interface { 接口内容 }Map类型
Map 是一种无序的键值对的集合。Map 最重要的一点是通过 key 来快速检索数据，key 类似于索引，指向数据的值。Map 是一种集合，所以我们可以像迭代数组和切片那样迭代它。不过，Map 是无序的，我们无法决定它的返回顺序，这是因为 Map 是使用 hash 表来实现的。
创建Map var 变量 map[类型]类型 make(map[类型]类型)