添加分布式相关

Author: wangyazhou

.obsidian/workspace.json

@@ -41,16 +41,30 @@
             "state": {
               "type": "markdown",
               "state": {
-                "file": "eBPF/ebpf.md",
+                "file": "架构/分布式.md",
                 "mode": "source",
                 "source": false
               },
               "icon": "lucide-file",
-              "title": "ebpf"
+              "title": "分布式"
+            }
+          },
+          {
+            "id": "420f6196d6d3217b",
+            "type": "leaf",
+            "state": {
+              "type": "markdown",
+              "state": {
+                "file": "go/go_package.md",
+                "mode": "source",
+                "source": false
+              },
+              "icon": "lucide-file",
+              "title": "go_package"
             }
           }
         ],
-        "currentTab": 2
+        "currentTab": 3
       }
     ],
     "direction": "vertical"
@@ -123,7 +137,7 @@
             "state": {
               "type": "backlink",
               "state": {
-                "file": "eBPF/ebpf.md",
+                "file": "go/go_package.md",
                 "collapseAll": false,
                 "extraContext": false,
                 "sortOrder": "alphabetical",
@@ -133,7 +147,7 @@
                 "unlinkedCollapsed": true
               },
               "icon": "links-coming-in",
-              "title": "ebpf 的反向链接列表"
+              "title": "go_package 的反向链接列表"
             }
           },
           {
@@ -171,13 +185,13 @@
             "state": {
               "type": "outline",
               "state": {
-                "file": "eBPF/ebpf.md",
+                "file": "go/go_package.md",
                 "followCursor": false,
                 "showSearch": false,
                 "searchQuery": ""
               },
               "icon": "lucide-list",
-              "title": "ebpf 的大纲"
+              "title": "go_package 的大纲"
             }
           }
         ],
@@ -198,21 +212,24 @@
       "obsidian-excalidraw-plugin:新建绘图文件": false
     }
   },
-  "active": "b7d07db209d422b0",
+  "active": "420f6196d6d3217b",
   "lastOpenFiles": [
-    "eBPF/bpftrace.md",
+    "go/go_module.md",
+    "go/go.md",
+    "架构/知识学习模板.md",
+    "架构/分布式.md",
+    "middleware/redis.md",
     "eBPF/ebpf.md",
+    "eBPF/bpftrace.md",
     "k8s/kubernetes.md",
     "containerd/docker.md",
     "架构/架构设计.md",
     "calico/calico.md",
-    "go/go_module.md",
     "架构/().md",
     "go/高并发.md",
     "go/go_package.md",
     "go/gRPC.md",
     "go/memory.md",
-    "架构/分布式.md",
     "calico/calico架构.md",
     "middleware/etcd.md",
     "db/DBA(Database administrator).md",
@@ -223,9 +240,6 @@
     "k8s/kube_state_metirc.md",
     "k8s/kube_prometheus.md",
     "k8s/harbor.md",
-    "go/go.md",
-    "eBPF/bcc.md",
-    "calico/calicoctl.md",
     "k8s/attachments/Pasted image 20250430202140.png",
     "k8s/attachments/Pasted image 20250430202042.png",
     "k8s/attachments/Pasted image 20250430201959.png",

eBPF/ebpf.md

@@ -1028,7 +1028,7 @@ funccount -i 1 't:block_*'
 funccount -i 1 c:getaddrinfo
 ```
 
-=== stackcount
+### stackcount
 
 ```bash
 # 对创建块I/O的栈踪迹进行计数
@@ -1049,9 +1049,9 @@ stackcount t:sched:sched_switch
 
 ## 参考
 
-https://arthurchiao.art/blog/cilium-bpf-xdp-reference-guide-zh/#bpf_helper[bpf-helper]
+https://arthurchiao.art/blog/cilium-bpf-xdp-reference-guide-zh/#bpf_helper[bpf-helper
 
-https://mp.weixin.qq.com/s/25mhUrNhF3HW8H6-ES7waA[epbf-st]
+https://mp.weixin.qq.com/s/25mhUrNhF3HW8H6-ES7waA[epbf-st
 
 https://gist.github.com/BruceChen7/8b15bdc26d2831e91983b3b52f114e60?permalink_comment_id=3263483[bcc-understand]
 

go/go.md

@@ -1238,3 +1238,12 @@ To completely disable this security protection add
 ```
 
 
+
+
+
+
+## 文章
+
+
+
+官网上的 Effective Go

go/go_package.md

@@ -16,6 +16,76 @@
 
 
 
+## gin 
+
+*中间件进行路径重写*
+```go
+package main
+
+import (
+    "github.com/gin-gonic/gin"
+    "strings"
+)
+
+func rewriteMiddleware() gin.HandlerFunc {
+    return func(c *gin.Context) {
+        if strings.HasPrefix(c.Request.URL.Path, "/api/data") {
+            // 重写请求路径为/api/v1/data
+            c.Request.URL.Path = strings.Replace(c.Request.URL.Path, "/api/data", "/api/v1/data", 1)
+        }
+        c.Next()
+    }
+}
+
+func main() {
+    r := gin.Default()
+    r.Use(rewriteMiddleware())
+
+    r.GET("/api/v1/data", getDataHandler)
+
+    r.Run(":8080")
+}
+
+func getDataHandler(c *gin.Context) {
+    c.JSON(200, gin.H{"message": "Data from /api/v1/data"})
+}
+```
+
+
+
+
+*通过设置路由器别名的方式，让多个路由指向同一个处理函数*
+
+```go 
+package main 
+import ( 
+	"github.com/gin-gonic/gin" 
+	"net/http" ) 
+	
+func proxyMiddleware() gin.HandlerFunc { 
+	return func(c *gin.Context) { 
+		targetPath := "/api/v1/data" 
+		if c.Request.URL.Path == "/api/data" { 
+			http.Redirect(c.Writer, c.Request, targetPath, http.StatusPermanentRedirect) 
+			c.Abort() 
+			return 
+		} 
+		c.Next() 
+	} 
+} 
+
+func main() { 
+	r := gin.Default() 
+	r.Use(proxyMiddleware()) 
+	r.GET("/api/v1/data", getDataHandler) 
+	r.Run(":8080") 
+} 
+
+func getDataHandler(c *gin.Context) { 
+	c.JSON(200, gin.H{"message": "Data from /api/v1/data"}) 
+}
+```
+
 
 
 

middleware/redis.md

@@ -0,0 +1,13 @@
+
+
+
+
+
+
+Redis 的数据结构，Redis 的性能优化、高可用配置、分布式锁什么
+
+
+
+
+
+

架构/分布式.md

@@ -35,3 +35,4 @@
 [# A pattern language for microservices](https://microservices.io/patterns/index.html) 各式各样的微服务架构图，开发微服务可以找相似的进行参考
 
 
+分布式架构，那么 CAP 理论、微服务架构、弹力设计

架构/知识学习模板.md

@@ -0,0 +1,81 @@
+
+## 系统学习一门知识模板
+1. **这个技术出现的背景、初衷和要达到什么样的目标或是要解决什么样的问题。** 这个问题非常关键，也就是说，你在学习一个技术的时候，需要知道这个技术的成因和目标，也就是这个技术的灵魂。如果不知道这些的话，那么你会看不懂这个技术的一些设计理念
+
+2. **这个技术的优势和劣势分别是什么，或者说，这个技术的 trade-off 是什么**。任何技术都有其好坏，在解决一个问题的时候，也会带来新的问题。另外，一般来说，任何设计都有 trade-off（要什么和不要什么），所以，你要清楚这个技术的优势和劣势，以及带来的挑战。
+
+3. **这个技术适用的场景**。任何技术都有其适用的场景，离开了这个场景，这个技术可能会有很多槽点，所以学习技术不但要知道这个技术是什么，还要知道其适用的场景。没有任何一个技术是普适的。注意，所谓场景一般分别两个，一个是业务场景，一个是技术场景。
+
+4. **技术的组成部分和关键点**。这是技术的核心思想和核心组件了，也是这个技术的灵魂所在了。学习技术的核心部分是快速掌握的关键。
+
+5. **技术的底层原理和关键实现**。任何一个技术都有其底层的关键基础技术，这些关键技术很有可能也是其它技术的关键基础技术。所以，学习这些关键的基础底层技术，可以让你未来很快地掌握其它技术。可以参看我在 CoolShell 上写的 Docker 底层技术那一系列文章。
+
+6. **已有的实现和它之间的对比**。一般来说，任何一个技术都会有不同的实现，不同的实现都会有不同的侧重。学习不同的实现，可以让你得到不同的想法和思路，对于开阔思维，深入细节是非常重要的。
+## 举一反三
+1. 联想能力。这种能力的锻炼需要你平时就在不停地思考同一个事物的不同的用法，或是联想与之有关的其他事物。对于软件开发和技术学习也一样。
+
+2. 抽象能力。抽象能力是举一反三的基本技能。平时你解决问题的时候，如果你能对这个问题进行抽象，你就可以获得更多的表现形式。抽象能力需要找到解决问题的通用模型，比如数学就是对现实世界的一种抽象。只要我们能把现实世界的各种问题建立成数据模型（如，建立各种维度的向量），我们就可以用数学来求解，这也是机器学习的本质。
+
+3. 自省能力。所谓自省能力就是自己找自己的难看。当你得到一个解的时候，要站在自己的对立面来找这个解的漏洞。有点像左右手互博。这种自己和自己辩论的能力又叫思辨能力。将自己分裂成正反方，左右方，甚至多方，站在不同的立场上来和自己辩论，从而做到不漏过一个 case，从而获得完整全面的问题分析能力
+
+## 如何阅读代码
+杰夫·阿特伍德（Jeff Atwood）说过这么一句话：`Code Tells You How, Comments Tell You Why`
+可见，代码并不会告诉你 Why，看代码只能靠猜测或推导来估计 Why，是揣测，不准确，所以会有很多误解。而且，我们每个人都知道，Why 是能让人一通百通的东西，也是能让人醍醐灌顶的东西。
+但是，代码会告诉你细节，这是书和文档不能给你的。细节是魔鬼，细节决定成败。书和文档是人对人说的话，代码是人对机器说的话
+
+1. 如果你想知道人为什么要这么搞，那么应该去看书（像 Effective C++、CodeComplete、Design Pattern、Thinking in Java 等），看文档。
+2. 如果你要知道让机器干了什么？那你应该看代码！（就像 Linus 去看 zlib 的代码来找性能问题。）
+
+如果你想了解一种思想，一种方法，一种原理，一种思路，一种经验，恐怕，读书和读文档会更有效率一些
+如果你想了解的就是具体细节，比如某协程的实现，某个模块的性能，某个算法的实现，那么你还是要去读代码的
+
+首先，在阅读代码之前，我建议你需要有下面的这些前提再去阅读代码，这样你读起代码来会很顺畅
+1. 基础知识。相关的语言和基础技术的知识
+2. 软件功能。你先要知道这个软件完成的是什么样的功能，有哪些特性，哪些配置项。你先要读一遍用户手册，然后让软件跑起来，自己先用一下感受一下
+3. 相关文档。读一下相关的内部文档，Readme 也好，Release Notes 也好，Design 也好，Wiki 也好，这些文档可以让你明白整个软件的方方面面。如果你的软件没有文档，那么，你只能指望这个软件的原作者还在，而且他还乐于交流
+4. 代码的组织结构。也就是代码目录中每个目录是什么样的功能，每个文档是干什么的。如果你要读的程序是在某种标准的框架下组织的，比如：Java 的 Spring 框架，那么恭喜你，这些代码不难读了。
+
+ 接下来，你要了解这个软件的代码是由哪些部分构成的，我在这里给你一个列表，供你参考
+ 1. 接口抽象定义。任何代码都会有很多接口或抽象定义，其描述了代码需要处理的数据结构或者业务实体，以及它们之间的关系，理清楚这些关系是非常重要的。
+2. 模块粘合层。我们的代码有很多都是用来粘合代码的，比如中间件（middleware）、Promises 模式、回调（Callback）、代理委托、依赖注入等。这些代码模块间的粘合技术是非常重要的，因为它们会把本来平铺直述的代码给分裂开来，让你不容易看明白它们的关系。
+3. 业务流程。这是代码运行的过程。一开始，我们不要进入细节，但需要在高层搞清楚整个业务的流程是什么样的，在这个流程中，数据是怎么被传递和处理的。一般来说，我们需要画程序流程图或者时序处理图
+4. 具体实现。了解上述的三个方面的内容，相信你对整个代码的框架和逻辑已经有了总体认识。这个时候，你就可以深入细节，开始阅读具体实现的代码了。对于代码的具体实现，一般来说，你需要知道下面一些事实，这样有助于你在阅读代码时找到重点
+	- 代码逻辑。代码有两种逻辑，一种是业务逻辑，这种逻辑是真正的业务处理逻辑；另一种是控制逻辑，这种逻辑只是用控制程序流转的，不是业务逻辑。比如：flag 之类的控制变量，多线程处理的代码，异步控制的代码，远程通讯的代码，对象序列化反序列化的代码等。这两种逻辑你要分开，很多代码之所以混乱就是把这两种逻辑混在一起了（详情参看《编程范式游记》）。
+	- 出错处理。根据二八原则，20% 的代码是正常的逻辑，80% 的代码是在处理各种错误，所以，你在读代码的时候，完全可以把处理错误的代码全部删除掉，这样就会留下比较干净和简单的正常逻辑的代码。排除干扰因素，可以更高效地读代码
+	- 数据处理。只要你认真观察，就会发现，我们好多代码就是在那里倒腾数据。比如DAO、DTO，比如 JSON、XML，这些代码冗长无聊，不是主要逻辑，可以不理。
+	- 重要的算法。一般来说，我们的代码里会有很多重要的算法，我说的并不一定是什么排序或是搜索算法，可能会是一些其它的核心算法，比如一些索引表的算法，全局唯一 ID 的算法、信息推荐的算法、统计算法、通读算法（如 Gossip）等。这些比较核心的算法可能会非常难读，但它们往往是最有技术含量的部分
+	- 底层交互。有一些代码是和底层系统的交互，一般来说是和操作系统或是 JVM 的交互。因此，读这些代码通常需要一定的底层技术知识，不然，很难读懂。
+5. 运行时调试。很多时候，代码只有运行起来了，才能知道具体发生了什么事，所以，我们让代码运行进来，然后用日志也好，debug 设置断点跟踪也好。实际看一下代码的运行过程，是了解代码的一种很好的方式。
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+