文件树

Go开发工程师全新版/
│   ├── 01 阶段一：Go语言基础入门和并发编程/
│   │   ├── 03 Go并发编程和工程管理/
│   │   │   ├── 02 第2章 单元测试/
│   │   │   │   ├── 01 2-1 如何写单元测试用例 （0943）.mp4 (19.37 MB)
│   │   │   │   ├── 04 2-4 benchmark性能测试 （1016）.mp4 (22.92 MB)
│   │   │   │   ├── 03 2-3 基于表格驱动测试 （0408）.mp4 (23.88 MB)
│   │   │   │   └── 02 2-2 如何跳过耗时的单元测试用例 （0335）.mp4 (20.32 MB)
│   │   │   ├── 01 第1章 package和go modules/
│   │   │   │   ├── 04 1-4 设置GOProxy国内镜像 （0608）.mp4 (35.14 MB)
│   │   │   │   ├── 07 1-7 go编码规范 （2027）.mp4 (116.21 MB)
│   │   │   │   ├── 01 1-1 package的定义和导入 最近学习.mp4 (64.68 MB)
│   │   │   │   ├── 05 1-5 go get、go mod相关命令 （0606）.mp4 (30.18 MB)
│   │   │   │   ├── 02 1-2 import各种姿势 （0641）.mp4 (11.99 MB)
│   │   │   │   ├── 03 1-3 go.mod文件的下载方式 （0636）.mp4 (38.60 MB)
│   │   │   │   └── 06 1-6 go mod replace的应用场景 （0708）.mp4 (39.79 MB)
│   │   │   └── 03 第3章 并发编程/
│   │   │   │   ├── 01 3-1 go并发编程初体验 （2223）.mp4 (127.41 MB)
│   │   │   │   ├── 06 3-6 通过channel进行goroutine之间的通信 （1621）.mp4 (31.11 MB)
│   │   │   │   ├── 03 3-3 通过waitgroup等待协程的执行 （0816）.mp4 (15.63 MB)
│   │   │   │   ├── 13 3-13 通过context解决goroutine的信息传递 （2120）.mp4 (118.53 MB)
│   │   │   │   ├── 02 3-2 go的gmp调度原理 （1729）.mp4 (97.83 MB)
│   │   │   │   ├── 10 3-10 通过channel实现交叉打印 （0855）.mp4 (50.59 MB)
│   │   │   │   ├── 09 3-9 单向channel的应用场景 （1017）.mp4 (22.87 MB)
│   │   │   │   ├── 07 3-7 有缓冲channel和无缓冲channel的应用场景 （0321）.mp4 (18.79 MB)
│   │   │   │   ├── 11 3-11 监控goroutine的执行 （0746）.mp4 (44.37 MB)
│   │   │   │   ├── 04 3-4 通过mutex和atomic完成全局变量的原子操作 （1737）.mp4 (98.48 MB)
│   │   │   │   ├── 14 3-14 witchvalue、withtimeout的应用场景 （1006）.mp4 (56.40 MB)
│   │   │   │   ├── 08 3-8 for range对channel进行遍历 （0728）.mp4 (41.68 MB)
│   │   │   │   ├── 12 3-12 select 完成对多个channel的监控 （1643）.mp4 (48.24 MB)
│   │   │   │   └── 05 3-5 RWMutex读写锁 （1615）.mp4 (91.60 MB)
│   │   ├── 01 Go基础知识入门/
│   │   │   ├── 05 第5章 字符串基本操作/
│   │   │   │   ├── 04 5-4 高性能字符串拼接 - strings.builder （0405）.mp4 (23.74 MB)
│   │   │   │   ├── 06 5-6 字符串操作常用方法 （1432）.mp4 (81.32 MB)
│   │   │   │   ├── 02 5-2 转义符是什么 （0746）.mp4 (14.45 MB)
│   │   │   │   ├── 01 5-1 rune和字符串长度 （0915）.mp4 (51.56 MB)
│   │   │   │   ├── 05 5-5 字符串的比较 （0259）.mp4 (6.95 MB)
│   │   │   │   └── 03 5-3 格式化输出 （1222）.mp4 (68.59 MB)
│   │   │   ├── 02 第2章 go开发环境搭建/
│   │   │   │   ├── 01 2-1 go的安装 （0842）.mp4 (48.79 MB)
│   │   │   │   ├── 03 2-3 go开发之hello-world （1008）.mp4 (57.95 MB)
│   │   │   │   └── 02 2-2 goland安装和快捷键 （0920）.mp4 (24.05 MB)
│   │   │   ├── 03 第3章 变量和常量/
│   │   │   │   ├── 02 3-2 常量的定义和使用 （1021）.mp4 (17.56 MB)
│   │   │   │   ├── 03 3-3 iota的使用细节 （1346）.mp4 (77.87 MB)
│   │   │   │   ├── 04 3-4 匿名变量的定义和用途 （0345）.mp4 (21.06 MB)
│   │   │   │   ├── 01 3-1 如何定义变量 （1803）.mp4 (102.62 MB)
│   │   │   │   └── 05 3-5 变量的作用域 （0642）.mp4 (14.69 MB)
│   │   │   ├── 04 第4章 go的基础数据类型/
│   │   │   │   ├── 03 4-3 format进行格式化转换 （1422）.mp4 (37.59 MB)
│   │   │   │   ├── 02 4-2 基本类型的转换 （1141）.mp4 (66.17 MB)
│   │   │   │   ├── 04 4-4 运算符和表达式 （1553）.mp4 (88.79 MB)
│   │   │   │   └── 01 4-1 数值、浮点数和字符类型 （1902）.mp4 (105.75 MB)
│   │   │   ├── 01 第1章 2022新版go工程师体系课导学以及Go的发展/
│   │   │   │   ├── 02 1-2 go语言介绍 （1450）.mp4 (81.95 MB)
│   │   │   │   └── 01 1-1 Go开发工程师体系课全新版导学 最近学习.mp4 (20.99 MB)
│   │   │   └── 06 第6章 条件判断和for循环/
│   │   │   │   ├── 03 6-3 for循环打印九九乘法表 （0553）.mp4 (34.34 MB)
│   │   │   │   ├── 02 6-2 for循环基础用法 （0749）.mp4 (13.28 MB)
│   │   │   │   ├── 04 6-4 for range的循环用法 （1335）.mp4 (76.20 MB)
│   │   │   │   ├── 06 6-6 goto语句的基本用法 （0630）.mp4 (37.50 MB)
│   │   │   │   ├── 05 6-5 for循环的continue和break语句 （0404）.mp4 (9.77 MB)
│   │   │   │   ├── 01 6-1 if条件判断 （1006）.mp4 (57.05 MB)
│   │   │   │   └── 07 6-7 switch语法 （1018）.mp4 (62.71 MB)
│   │   └── 02 容器，go编程思想/
│   │   │   ├── 05 第5章 接口/
│   │   │   │   ├── 03 5-3 多接口的实现 （1016）.mp4 (22.36 MB)
│   │   │   │   ├── 02 5-2 如何定义接口 （0755）.mp4 (43.75 MB)
│   │   │   │   ├── 07 5-7 接口遇到了slice的常见错误 （0721）.mp4 (42.01 MB)
│   │   │   │   ├── 01 5-1 什么是鸭子类型 （1138）.mp4 (67.03 MB)
│   │   │   │   ├── 06 5-6 接口嵌套 （0643）.mp4 (17.74 MB)
│   │   │   │   ├── 04 5-4 通过interface解决动态类型传参 （0903）.mp4 (50.28 MB)
│   │   │   │   └── 05 5-5 通过switch语句进行类型判断 （0600）.mp4 (34.25 MB)
│   │   │   ├── 01 第1章 数组、切片和map/
│   │   │   │   ├── 11 1-11 map的初始化和赋值 （1219）.mp4 (71.34 MB)
│   │   │   │   ├── 04 1-4 切片的定义和赋值 （0713）.mp4 (11.14 MB)
│   │   │   │   ├── 08 1-8 切片的元素删除和拷贝 （0849）.mp4 (49.74 MB)
│   │   │   │   ├── 15 1-15 list的基本用法 （1300）.mp4 (71.69 MB)
│   │   │   │   ├── 13 1-13 判断map中是否存在元素和删除元素 （0749）.mp4 (18.27 MB)
│   │   │   │   ├── 12 1-12 map进行for循环遍历的坑 （0555）.mp4 (32.76 MB)
│   │   │   │   ├── 01 1-1 数组的基本用法 （0940）.mp4 (18.40 MB)
│   │   │   │   ├── 03 1-3 多维数组 （0941）.mp4 (55.20 MB)
│   │   │   │   ├── 06 1-6 切片的数据访问 （0603）.mp4 (33.80 MB)
│   │   │   │   ├── 14 1-14 list和slice的区别 （0703）.mp4 (39.50 MB)
│   │   │   │   ├── 09 1-9 为什么需要懂切片的原理 （0508）.mp4 (29.54 MB)
│   │   │   │   ├── 10 1-10 切片的底层存储原理 （2121）.mp4 (46.16 MB)
│   │   │   │   ├── 02 1-2 数组的初始化 （0523）.mp4 (29.97 MB)
│   │   │   │   ├── 07 1-7 通过省略号添加多个元素到切片 （0437）.mp4 (12.04 MB)
│   │   │   │   └── 05 1-5 切片的多种初始化方式 （1043）.mp4 (60.04 MB)
│   │   │   ├── 04 第4章 指针/
│   │   │   │   ├── 02 4-2 指针的初始化 （0757）.mp4 (44.23 MB)
│   │   │   │   ├── 01 4-1 指针的定义和使用 （1601）.mp4 (32.84 MB)
│   │   │   │   ├── 03 4-3 通过swap交换指针的值 （1043）.mp4 (60.17 MB)
│   │   │   │   └── 04 4-4 nil在go中的细节 （1422）.mp4 (29.30 MB)
│   │   │   ├── 02 第2章 函数/
│   │   │   │   ├── 07 2-7 如何正确使用recover和panic （1111）.mp4 (28.19 MB)
│   │   │   │   ├── 02 2-2 函数的可变参数 （0853）.mp4 (49.61 MB)
│   │   │   │   ├── 04 2-4 go函数的闭包特性 （0939）.mp4 (21.46 MB)
│   │   │   │   ├── 05 2-5 defer的应用场景 （1113）.mp4 (63.81 MB)
│   │   │   │   ├── 03 2-3 函数一等公民特性 （1525）.mp4 (85.49 MB)
│   │   │   │   ├── 06 2-6 go的error设计理念 （0723）.mp4 (40.98 MB)
│   │   │   │   └── 01 2-1 函数的定义 （1304）.mp4 (25.40 MB)
│   │   │   └── 03 第3章 结构体/
│   │   │   │   ├── 02 3-2 结构体的定义和初始化 （1212）.mp4 (69.12 MB)
│   │   │   │   ├── 01 3-1 type关键字的用法 （1352）.mp4 (77.73 MB)
│   │   │   │   ├── 05 3-5 结构体定义方法 （1132）.mp4 (64.70 MB)
│   │   │   │   ├── 04 3-4 结构体嵌套 （0916）.mp4 (52.62 MB)
│   │   │   │   └── 03 3-3 匿名结构体 （0543）.mp4 (12.69 MB)
│   ├── 免费试看/
│   │   ├── 03 2-3 go开发之hello-world （1008）.mp4 (57.95 MB)
│   │   └── 02 2-2 goland安装和快捷键 （0920）.mp4 (50.54 MB)
│   ├── 05 阶段五：分布式系统核心、微服务的部署/
│   │   ├── 03 链路追踪、限流、熔断、降级/
│   │   │   ├── 03 第3章 熔断、限流 - sentinel/
│   │   │   │   ├── 09 3-9 gin集成sentinel实现限流 （1130）.mp4 (62.13 MB)
│   │   │   │   ├── 01 3-1 什么是限流、熔断和降级 （1618）.mp4 (24.92 MB)
│   │   │   │   ├── 03 3-3 sentinel的qps限流 （2229）.mp4 (120.94 MB)
│   │   │   │   ├── 05 3-5 sentinel的Throttling配置策略 （0523）.mp4 (29.67 MB)
│   │   │   │   ├── 07 3-7 sentinel的熔断接口-基于错误数 （1210）.mp4 (40.18 MB)
│   │   │   │   ├── 02 3-2 sentinel和hystrix对比 （0604）.mp4 (33.71 MB)
│   │   │   │   ├── 06 3-6 sentinel的熔断接口 （1059）.mp4 (60.65 MB)
│   │   │   │   ├── 04 3-4 sentinel的预热和冷启动 （2125）.mp4 (56.32 MB)
│   │   │   │   └── 08 3-8 sentinel的熔断接口-基于错误率和慢请求 （0805）.mp4 (46.40 MB)
│   │   │   ├── 01 第1章 链路追踪技术概述/
│   │   │   │   ├── 03 1-3 jaeger的安装和架构介绍 （0919）.mp4 (57.89 MB)
│   │   │   │   ├── 04 1-4 opentracing中的tracer、span、spancontext （1746）.mp4 (58.82 MB)
│   │   │   │   ├── 02 1-2 链路追踪技术选型 （0802）.mp4 (44.61 MB)
│   │   │   │   └── 01 1-1 为什么我们需要链路追踪 （1232）.mp4 (32.51 MB)
│   │   │   └── 02 第2章 go集成jaeger/
│   │   │   │   ├── 03 2-3 go下通过grpc发送span消息 （1242）.mp4 (39.95 MB)
│   │   │   │   ├── 07 2-7 grpc集成opentracing的原理 （0708）.mp4 (39.24 MB)
│   │   │   │   ├── 01 2-1 go通过jaeger-client发送单个span （1616）.mp4 (87.48 MB)
│   │   │   │   ├── 05 2-5 修改grpc_opentracing源码 （1936）.mp4 (106.52 MB)
│   │   │   │   ├── 02 2-2 go发送多级嵌套span （1023）.mp4 (57.40 MB)
│   │   │   │   ├── 04 2-4 gin中添加拦截器实现jaeger注入 （2340）.mp4 (130.21 MB)
│   │   │   │   ├── 06 2-6 配置订单服务的web层逻辑 （0952）.mp4 (44.97 MB)
│   │   │   │   └── 08 2-8 grpc的server端如何获取客户端的span （2549）.mp4 (137.75 MB)
│   │   ├── 02 学习rocketmq实现幂等性机制等/
│   │   │   ├── 02 第2章 rocketmq快速入门/
│   │   │   │   ├── 06 2-6 为什么要使用延迟消息解决库存超时归还问题 （0859）.mp4 (49.47 MB)
│   │   │   │   ├── 07 2-7 通过TransactionProducer发送事务消息 （1144）.mp4 (65.40 MB)
│   │   │   │   ├── 08 2-8 测试rocketmq的事务消息 （0843）.mp4 (31.22 MB)
│   │   │   │   ├── 03 2-3 rocketmq的消息类型 （1301）.mp4 (73.94 MB)
│   │   │   │   ├── 01 2-1 rocketmq的安装和配置 （1651）.mp4 (92.84 MB)
│   │   │   │   ├── 05 2-5 通过pushconsumer消费消息 （1442）.mp4 (37.81 MB)
│   │   │   │   ├── 02 2-2 rocketmq的基本概念 （0546）.mp4 (7.27 MB)
│   │   │   │   └── 04 2-4 go发送普通消息 （1440）.mp4 (82.58 MB)
│   │   │   ├── 04 第4章 实现接口的幂等性/
│   │   │   │   ├── 03 4-3 哪些情况下需要考虑幂等性问题 （0748）.mp4 (15.83 MB)
│   │   │   │   ├── 05 4-5 常用的幂等性解决方案 （1202）.mp4 (68.26 MB)
│   │   │   │   ├── 02 4-2 超时、重试和幂等性机制 （1036）.mp4 (58.35 MB)
│   │   │   │   ├── 01 4-1 什么是服务雪崩 （1024）.mp4 (58.18 MB)
│   │   │   │   └── 04 4-4 使用grpc-middleware实现grpc调用的重试 （1025）.mp4 (58.01 MB)
│   │   │   ├── 01 第1章 mq的应用场景和选型/
│   │   │   │   ├── 01 1-1 mq的应用场景 （1611）.mp4 (38.87 MB)
│   │   │   │   └── 02 1-2 mq消息队列技术选型 （1301）.mp4 (72.53 MB)
│   │   │   └── 03 第3章 基于可靠消息的最终一致性、订单超时归还/
│   │   │   │   ├── 10 3-10 gorm定义具备嵌套对象的列 （0735）.mp4 (41.48 MB)
│   │   │   │   ├── 09 3-9 库存扣减服务中表结构的设计 （1137）.mp4 (37.41 MB)
│   │   │   │   ├── 07 3-7 ExecuteLocalTransaction本地事务的逻辑 （1321）.mp4 (73.71 MB)
│   │   │   │   ├── 15 3-15 rocketmq中shutdown造成的坑 （1701）.mp4 (95.00 MB)
│   │   │   │   ├── 03 3-3 tcc在解决库存扣减中的问题 （0611）.mp4 (17.27 MB)
│   │   │   │   ├── 13 3-13 测试rocketmq的事务回查后的库存归还 （1012）.mp4 (56.34 MB)
│   │   │   │   ├── 08 3-8 本地事务消息回查应该如何做 （0507）.mp4 (29.08 MB)
│   │   │   │   ├── 05 3-5 如何通过基于可靠消息实现库存的一致性 （0650）.mp4 (38.57 MB)
│   │   │   │   ├── 02 3-2 先扣减库存和后扣减库存是否能解决分布式事务的问题 （0552）.mp4 (33.33 MB)
│   │   │   │   ├── 06 3-6 在createorder中发送事务消息 （1029）.mp4 (55.00 MB)
│   │   │   │   ├── 01 3-1 订单新建过程中会出现哪些不可控因素导致数据不一致的问题 （1333）.mp4 (75.20 MB)
│   │   │   │   ├── 11 3-11 库存服务的sell逻辑修改和归还逻辑重构 （1700）.mp4 (93.36 MB)
│   │   │   │   ├── 04 3-4 基于可靠消息最终一致性方案在库存服务上的不足 （0905）.mp4 (52.03 MB)
│   │   │   │   ├── 12 3-12 测试库存服务和库存扣减历史记录 （1408）.mp4 (75.61 MB)
│   │   │   │   └── 14 3-14 在订单服务中发送延时消息解决库存归还的问题 （1600）.mp4 (88.08 MB)
│   │   ├── 04 api网关、部署/
│   │   │   ├── 05 第5章 课程总结/
│   │   │   │   └── 01 5-1 课程总结 （2002）.mp4 (109.52 MB)
│   │   │   ├── 04 第4章 通过jenkins部署服务/
│   │   │   │   ├── 06 4-6 发布go项目到远程服务器上 （0815）.mp4 (44.88 MB)
│   │   │   │   ├── 02 4-2 前端代码上传到git并启动 （0808）.mp4 (48.27 MB)
│   │   │   │   ├── 03 4-3 nginx中部署vuejs （2237）.mp4 (127.35 MB)
│   │   │   │   ├── 07 4-7 通过shell脚本启动gin服务 （1217）.mp4 (29.74 MB)
│   │   │   │   ├── 01 4-1 有哪些服务器我们需要部署 （1052）.mp4 (19.59 MB)
│   │   │   │   ├── 04 4-4 jenkens部署vuejs项目 （1759）.mp4 (71.56 MB)
│   │   │   │   └── 05 4-5 通过go build构建go微服务 （2202）.mp4 (122.42 MB)
│   │   │   ├── 02 第2章 kong的配置/
│   │   │   │   ├── 05 2-5 kong配置jwt实现登录校验 （1653）.mp4 (95.17 MB)
│   │   │   │   ├── 01 2-1 kong的8001、800和1337端口号的关系 （0746）.mp4 (47.45 MB)
│   │   │   │   ├── 03 2-3 kong的service、routes、upstream的请求过程 （0625）.mp4 (15.54 MB)
│   │   │   │   ├── 04 2-4 kong集成consul实现服务发现和负载均衡 （0714）.mp4 (42.71 MB)
│   │   │   │   ├── 06 2-6 kong配置反爬和ip黑名单 （0918）.mp4 (28.65 MB)
│   │   │   │   └── 02 2-2 基本的路由转发配置 （1018）.mp4 (58.87 MB)
│   │   │   ├── 03 第3章 jenkins入门/
│   │   │   │   ├── 01 3-1 敏捷开发中的持续集成痛点 （1248）.mp4 (71.11 MB)
│   │   │   │   ├── 05 3-5 通过free style构建项目 （1414）.mp4 (77.73 MB)
│   │   │   │   ├── 03 3-3 jenkins构建服务器流程 （1035）.mp4 (26.43 MB)
│   │   │   │   ├── 06 3-6 将构建服务器上的代码上传到运行服务器 （1520）.mp4 (33.39 MB)
│   │   │   │   ├── 07 3-7 通过pipeline实现持续集成 （1617）.mp4 (92.50 MB)
│   │   │   │   ├── 09 3-9 通过远程和其他工程触发构建 （0643）.mp4 (16.87 MB)
│   │   │   │   ├── 02 3-2 安装jenkins和关闭防火墙 （1002）.mp4 (56.90 MB)
│   │   │   │   ├── 11 3-11 参数化pipeline构建项目 （0457）.mp4 (28.79 MB)
│   │   │   │   ├── 10 3-10 定时构建和轮询SCM构建 （0804）.mp4 (44.01 MB)
│   │   │   │   ├── 04 3-4 安装jenkins常用插件 （0834）.mp4 (46.35 MB)
│   │   │   │   └── 08 3-8 通过jenkinsfile管理构建pipeline脚本 （0506）.mp4 (30.39 MB)
│   │   │   └── 01 第1章 kong的安装和配置/
│   │   │   │   ├── 01 1-1 什么是api网关 （0652）.mp4 (14.51 MB)
│   │   │   │   ├── 04 1-4 kong的安装 （2100）.mp4 (79.85 MB)
│   │   │   │   ├── 02 1-2 api网关具备的功能有哪些 （0444）.mp4 (27.32 MB)
│   │   │   │   └── 03 1-3 api网关技术选型 （1011）.mp4 (53.97 MB)
│   │   └── 01 分布式理论基础、分布式事务解决方案/
│   │   │   ├── 02 第2章 cap理论和分布式事务解决方案/
│   │   │   │   ├── 02 2-2 BASE理论 （1040）.mp4 (60.70 MB)
│   │   │   │   ├── 05 2-5 TCC分布式事务实现方案 - 订单服务的tcc接口 （1338）.mp4 (74.54 MB)
│   │   │   │   ├── 08 2-8 基于可靠消息的最终一致性 （1433）.mp4 (83.48 MB)
│   │   │   │   ├── 03 2-3 2pc两阶段提交分布式事务 （1050）.mp4 (62.54 MB)
│   │   │   │   ├── 06 2-6 TCC分布式事务实现方案 - tcc实现难点 （1308）.mp4 (73.42 MB)
│   │   │   │   ├── 09 2-9 最大努力通知方案 （1448）.mp4 (82.76 MB)
│   │   │   │   ├── 04 2-4 TCC分布式事务实现方案 （1106）.mp4 (19.94 MB)
│   │   │   │   ├── 07 2-7 基于本地消息的最终一致性方案 （1203）.mp4 (28.79 MB)
│   │   │   │   └── 01 2-1 cap理论 （1616）.mp4 (40.27 MB)
│   │   │   └── 01 第1章 电商系统中的库存归还、超时归还、事务等/
│   │   │   │   ├── 02 1-2 数据库事务的ACID特性 （1403）.mp4 (77.54 MB)
│   │   │   │   ├── 03 1-3 分布式系统中出现哪些故障会导致数据不一致 （0937）.mp4 (53.73 MB)
│   │   │   │   └── 01 1-1 为什么订单会有超时机制 最近学习.mp4 (26.70 MB)
│   ├── 09 阶段九：自研微服务框架-gmicro/
│   │   ├── 01 三层代码结构/
│   │   │   └── 01 第1章 三层代码结构规范/
│   │   │   │   ├── 11 1-11 使用copier简化do和dto之间的拷贝 （1043）.mp4 (58.44 MB)
│   │   │   │   ├── 09 1-9 service层的代码如何做到可测试性 （2447）.mp4 (75.18 MB)
│   │   │   │   ├── 06 1-6 三层代码结构降低代码耦合 （2123）.mp4 (55.79 MB)
│   │   │   │   ├── 03 1-3 重构app启动项目 （1028）.mp4 (29.54 MB)
│   │   │   │   ├── 01 1-1 导入common和app包 （0819）.mp4 (46.66 MB)
│   │   │   │   ├── 10 1-10 controller层如何减少对service层的依赖 （1115）.mp4 (62.22 MB)
│   │   │   │   ├── 04 1-4 app启动的原理 （0551）.mp4 (33.43 MB)
│   │   │   │   ├── 08 1-8 DO、DTO、VO这些概念是什么意思 （1023）.mp4 (61.55 MB)
│   │   │   │   ├── 05 1-5 已有代码存在哪些耦合 （0915）.mp4 (51.69 MB)
│   │   │   │   ├── 07 1-7 service和data层的解耦 （0938）.mp4 (54.52 MB)
│   │   │   │   └── 02 1-2 通过app启动配置文件映射和flag映射 （2206）.mp4 (121.42 MB)
│   │   ├── 05 可观测的终极解决方案/
│   │   │   └── 01 第1章 opentelemetry实现链路追踪/
│   │   │   │   ├── 16 1-16 gin集成opentelemetry （1602）.mp4 (90.06 MB)
│   │   │   │   ├── 15 1-15 gorm集成opentelemetry的源码解读 （0533）.mp4 (19.87 MB)
│   │   │   │   ├── 10 1-10 设计opentelemetry的options （0856）.mp4 (49.94 MB)
│   │   │   │   ├── 05 1-5 函数中传递span的context （1406）.mp4 (78.21 MB)
│   │   │   │   ├── 14 1-14 gorm集成opentelemetry （1631）.mp4 (90.77 MB)
│   │   │   │   ├── 09 1-9 otelgrpc源码解读 （0840）.mp4 (40.30 MB)
│   │   │   │   ├── 02 1-2 opentelemetry快速体验 （1509）.mp4 (84.05 MB)
│   │   │   │   ├── 08 1-8 grpc集成opentelemetry （0741）.mp4 (42.06 MB)
│   │   │   │   ├── 11 1-11 gmicro集成opentelemetry （2729）.mp4 (156.13 MB)
│   │   │   │   ├── 03 1-3 SetAttribute设置链路的属性 （1619）.mp4 (51.22 MB)
│   │   │   │   ├── 13 1-13 opentelemetry集成log的源码解读 （0651）.mp4 (38.72 MB)
│   │   │   │   ├── 01 1-1 opentelemetry的前世今生 - 重要！ （1615）.mp4 (90.05 MB)
│   │   │   │   ├── 04 1-4 open telemetry的系统架构 （1610）.mp4 (90.36 MB)
│   │   │   │   ├── 06 1-6 opentelemetry通过http完成span的传输 （2311）.mp4 (92.46 MB)
│   │   │   │   ├── 12 1-12 log和opentelemetry集成体验 （0647）.mp4 (31.58 MB)
│   │   │   │   ├── 07 1-7 自定义inject和extract源码 （1635）.mp4 (91.42 MB)
│   │   │   │   └── 17 1-17 go-redis集成opentelemetry （0827）.mp4 (47.07 MB)
│   │   ├── 02 grpc服务封装更方便的rpc服务/
│   │   │   ├── 02 第2章 开发通用的rpc服务/
│   │   │   │   ├── 06 2-6 app中如何启动gmicro的rpc服务 （1053）.mp4 (59.29 MB)
│   │   │   │   ├── 08 2-8 启动rpc服务进行调试 （1311）.mp4 (72.70 MB)
│   │   │   │   ├── 09 2-9 通过mock底层的数据返回响应数据 （1559）.mp4 (88.26 MB)
│   │   │   │   ├── 07 2-7 自定义ServerOptions启动用户服务 （1923）.mp4 (67.07 MB)
│   │   │   │   ├── 04 2-4 实现recover拦截器 （0933）.mp4 (32.52 MB)
│   │   │   │   ├── 03 2-3 rpc服务的启动和关闭 （0641）.mp4 (37.56 MB)
│   │   │   │   ├── 01 2-1 rpc的server数据模型设计 （1220）.mp4 (33.08 MB)
│   │   │   │   ├── 10 2-10 使用gin自动完成rpc服务的api代理 （0832）.mp4 (33.93 MB)
│   │   │   │   ├── 02 2-2 rpc服务启动过程中的拦截器，rpc接口反射等功能 （2213）.mp4 (125.55 MB)
│   │   │   │   └── 05 2-5 service的timeout的拦截器实现原理 （1736）.mp4 (97.49 MB)
│   │   │   └── 01 第1章 通用微服务框架需求/
│   │   │   │   ├── 02 1-2 微服务框架应该具备的功能 （1250）.mp4 (73.28 MB)
│   │   │   │   ├── 06 1-6 如何封装rpc和http服务 （0616）.mp4 (34.52 MB)
│   │   │   │   ├── 03 1-3 通过函数选项模式启动app （2233）.mp4 (127.21 MB)
│   │   │   │   ├── 01 1-1 为什么我们需要自己开发微服务框架 （1159）.mp4 (24.75 MB)
│   │   │   │   ├── 04 1-4 实现服务注册的抽象 （1449）.mp4 (39.66 MB)
│   │   │   │   └── 05 1-5 服务注册的监听实现原理 （1446）.mp4 (82.83 MB)
│   │   ├── 06 系统监控核心/
│   │   │   └── 01 第1章 监控系统 - prometheus、grafana/
│   │   │   │   ├── 04 1-4 promql基本语法 （0841）.mp4 (20.17 MB)
│   │   │   │   ├── 06 1-6 导入grafana的模板 （0537）.mp4 (30.95 MB)
│   │   │   │   ├── 13 1-13 测试ginmetrics （0730）.mp4 (29.82 MB)
│   │   │   │   ├── 12 1-12 gin集成prometheus （1201）.mp4 (67.75 MB)
│   │   │   │   ├── 01 1-1 监控有哪些指标 （1900）.mp4 (33.26 MB)
│   │   │   │   ├── 11 1-11 rpc的client的interceptor集成prometheus （0538）.mp4 (31.53 MB)
│   │   │   │   ├── 03 1-3 安装prometheus和node-exporter （0709）.mp4 (38.95 MB)
│   │   │   │   ├── 05 1-5 grafana的安装和使用 （1301）.mp4 (71.30 MB)
│   │   │   │   ├── 08 1-8 histograms指标 （0613）.mp4 (36.33 MB)
│   │   │   │   ├── 02 1-2 prometheus、grafana架构 （1253）.mp4 (69.61 MB)
│   │   │   │   ├── 09 1-9 gin集成prometheus （1226）.mp4 (69.31 MB)
│   │   │   │   ├── 10 1-10 rpcserver的interceptor集成prometheus （1623）.mp4 (58.85 MB)
│   │   │   │   └── 07 1-7 guages和counter指标 （0730）.mp4 (14.11 MB)
│   │   ├── 04 基于gin封装api服务/
│   │   │   └── 01 第1章 基于gin封装通用的restserver/
│   │   │   │   ├── 06 1-6 errgroup解决一组task启动的问题 （1308）.mp4 (74.64 MB)
│   │   │   │   ├── 07 1-7 通过errgroup完善restserver和rpcserver的启动 （1457）.mp4 (56.65 MB)
│   │   │   │   ├── 09 1-9 优雅退出如何通知到rpc和rest的server （1000）.mp4 (55.29 MB)
│   │   │   │   ├── 08 1-8 restserver启动并测试 （2115）.mp4 (119.38 MB)
│   │   │   │   ├── 12 1-12 如何集成basic、cache和jwt认证服务 （1631）.mp4 (91.22 MB)
│   │   │   │   ├── 11 1-11 basic认证、cache认证和jwt认证的需求 （0751）.mp4 (42.85 MB)
│   │   │   │   ├── 02 1-2 通过函数选项模式完成newServer （1300）.mp4 (72.85 MB)
│   │   │   │   ├── 10 1-10 基于restserver封装middleware （0725）.mp4 (34.99 MB)
│   │   │   │   ├── 13 1-13 basic、cache认证源码解析 （1553）.mp4 (64.51 MB)
│   │   │   │   ├── 04 1-4 封装验证翻译器 （1345）.mp4 (68.77 MB)
│   │   │   │   ├── 01 1-1 设计restserver的通用结构 （1503）.mp4 (33.71 MB)
│   │   │   │   ├── 05 1-5 gmicro在app中分别启动rest和rpc服务 （0942）.mp4 (53.67 MB)
│   │   │   │   └── 03 1-3 完成restserver的start过程 （2102）.mp4 (115.50 MB)
│   │   └── 03 深入grpc的服务注册、负载均衡原理/
│   │   │   └── 01 第1章 服务注册、服务发现和负载均衡/
│   │   │   │   ├── 13 1-13 grpc的负载均衡架构原理 （1951）.mp4 (110.32 MB)
│   │   │   │   ├── 17 1-17 负载均衡使用测试 （1250）.mp4 (71.94 MB)
│   │   │   │   ├── 06 1-6 封装client端的timeout拦截器 （1017）.mp4 (39.34 MB)
│   │   │   │   ├── 01 1-1 配置服务注册配置 （1014）.mp4 (57.89 MB)
│   │   │   │   ├── 10 1-10 通过WithResolvers显示指定resolver （0928）.mp4 (52.72 MB)
│   │   │   │   ├── 04 1-4 客户端封装的数据结构设计 （1503）.mp4 (86.03 MB)
│   │   │   │   ├── 05 1-5 封装dial方法进行客户端生成 （0900）.mp4 (51.14 MB)
│   │   │   │   ├── 08 1-8 自定义实现directBuilder实现服务发现 （1520）.mp4 (88.02 MB)
│   │   │   │   ├── 14 1-14 grpc负载均衡的源码分析 （1149）.mp4 (65.20 MB)
│   │   │   │   ├── 12 1-12 测试consul的服务发现功能 （0417）.mp4 (17.49 MB)
│   │   │   │   ├── 11 1-11 通过观察者模式实现服务发现 （2130）.mp4 (119.83 MB)
│   │   │   │   ├── 15 1-15 pickfirst和roundrobin源码分析 （0902）.mp4 (42.14 MB)
│   │   │   │   ├── 03 1-3 将服务注册到consul中 （2108）.mp4 (73.47 MB)
│   │   │   │   ├── 02 1-2 kratos对consul服务注册的封装 （1246）.mp4 (71.14 MB)
│   │   │   │   ├── 16 1-16 kratos负载均衡源码解析 （1930）.mp4 (108.75 MB)
│   │   │   │   ├── 07 1-7 grpc的服务发现的resolver接口 （0913）.mp4 (50.48 MB)
│   │   │   │   └── 09 1-9 grpc的服务发现和负载均衡的原理 （0909）.mp4 (21.75 MB)
│   ├── 11 阶段十一：基于k8s部署项目/
│   │   ├── 01 通过k8s部署服务/
│   │   │   ├── 01 第1章 docker入门/
│   │   │   │   ├── 10 1-10 最简单的Dockerfile （1439）.mp4 (98.96 MB)
│   │   │   │   ├── 13 1-13 entrypoint和cms命令的区别 （0826）.mp4 (49.31 MB)
│   │   │   │   ├── 06 1-6 容器相关命令 （2032）.mp4 (125.50 MB)
│   │   │   │   ├── 05 1-5 镜像相关的操作命令 （1716）.mp4 (30.47 MB)
│   │   │   │   ├── 03 1-3 为什么go是云原生最佳语言 （1101）.mp4 (61.65 MB)
│   │   │   │   ├── 09 1-9 docker的环境变量 （1029）.mp4 (80.88 MB)
│   │   │   │   ├── 07 1-7 docker网络端口映射 （1416）.mp4 (78.44 MB)
│   │   │   │   ├── 08 1-8 docker外部数据挂载 （1322）.mp4 (40.63 MB)
│   │   │   │   ├── 02 1-2 容器化技术 （1708）.mp4 (35.99 MB)
│   │   │   │   ├── 12 1-12 制作一个gin服务的镜像 （1520）.mp4 (90.34 MB)
│   │   │   │   ├── 01 1-1 docker介绍 （0947）.mp4 (54.95 MB)
│   │   │   │   ├── 04 1-4 docker的基本概念-镜像、容器、仓库 （1506）.mp4 (84.58 MB)
│   │   │   │   ├── 14 1-14 env、arg和workdir （1608）.mp4 (25.60 MB)
│   │   │   │   └── 11 1-11 dockerfile的COPY命令 （1120）.mp4 (25.57 MB)
│   │   │   └── 02 第2章 kubesphere部署服务/
│   │   │   │   ├── 13 2-13 rocketmq安装-nameserver （0512）.mp4 (28.19 MB)
│   │   │   │   ├── 04 2-4 安装kubesphere （1325）.mp4 (71.88 MB)
│   │   │   │   ├── 07 2-7 kubesphere部署mysql （1101）.mp4 (60.99 MB)
│   │   │   │   ├── 18 2-18 部署jaeger （0618）.mp4 (10.83 MB)
│   │   │   │   ├── 06 2-6 创建存储卷和配置 （1141）.mp4 (19.88 MB)
│   │   │   │   ├── 14 2-14 rocketmq安装-broker （1141）.mp4 (63.04 MB)
│   │   │   │   ├── 12 2-12 安装elasticsearch （1618）.mp4 (34.39 MB)
│   │   │   │   ├── 02 2-2 k8s系统选型 （0838）.zip (46.03 MB)
│   │   │   │   ├── 01 2-1 为什么我们需要k8s （1232）.mp4 (69.60 MB)
│   │   │   │   ├── 08 2-8 配置服务允许外部访问 （1611）.mp4 (87.45 MB)
│   │   │   │   ├── 09 2-9 kubesphere安装redis （0731）.mp4 (14.83 MB)
│   │   │   │   ├── 15 2-15 安装harbor （1732）.mp4 (58.22 MB)
│   │   │   │   ├── 10 2-10 kubesphere安装consul （0526）.mp4 (28.76 MB)
│   │   │   │   ├── 05 2-5 kubesphere的工作负载、服务和容器组 （1641）.mp4 (100.92 MB)
│   │   │   │   ├── 17 2-17 推送本地镜像到harbor并部署 （0923）.mp4 (55.88 MB)
│   │   │   │   ├── 03 2-3 云服务器安装docker （0933）.mp4 (31.88 MB)
│   │   │   │   ├── 11 2-11 安装nacos （0723）.mp4 (39.56 MB)
│   │   │   │   ├── 16 2-16 kubesphere配置harbor镜像仓库 （0827）.mp4 (44.87 MB)
│   │   │   │   └── 02 2-2 k8s系统选型 （0838）.mp4 (48.45 MB)
│   │   └── 02 devops和k8s/
│   │   │   ├── 02 第2章 k8s入门/
│   │   │   │   ├── 08 2-8 k8s的configmap、secret （0809）.mp4 (46.24 MB)
│   │   │   │   ├── 07 2-7 k8s的持久卷 （1212）.mp4 (69.49 MB)
│   │   │   │   ├── 02 2-2 pod是什么 （0923）.mp4 (52.37 MB)
│   │   │   │   ├── 10 2-10 课程总结和进一步学习建议 （2112）.mp4 (121.79 MB)
│   │   │   │   ├── 09 2-9 k8s的架构 （1340）.mp4 (38.62 MB)
│   │   │   │   ├── 06 2-6 k8s的ingress （1049）.mp4 (32.24 MB)
│   │   │   │   ├── 01 2-1 k8s学习路线 （0855）.mp4 (51.21 MB)
│   │   │   │   ├── 03 2-3 kubectl相关的pods命令 （1653）.mp4 (50.66 MB)
│   │   │   │   ├── 05 2-5 k8s的service （1846）.mp4 (106.90 MB)
│   │   │   │   └── 04 2-4 k8s的控制器 - deployment （1853）.mp4 (109.78 MB)
│   │   │   └── 01 第1章 devops进行持续集成/
│   │   │   │   ├── 01 1-1 基于docker进行go build构建 （1408）.mp4 (76.98 MB)
│   │   │   │   ├── 11 1-11 对user服务进行ci构建 （1450）.mp4 (79.02 MB)
│   │   │   │   ├── 06 1-6 如何构建一个生产环境的镜像 （0632）.mp4 (8.50 MB)
│   │   │   │   ├── 07 1-7 pipeline参数化构建 （1945）.mp4 (112.10 MB)
│   │   │   │   ├── 15 1-15 测试用户服务 （0634）.mp4 (23.88 MB)
│   │   │   │   ├── 13 1-13 修改user服务的配置 （1953）.mp4 (118.46 MB)
│   │   │   │   ├── 17 1-17 部署admin的api服务 （1139）.mp4 (62.81 MB)
│   │   │   │   ├── 12 1-12 kubesphere部署用户服务 （2330）.mp4 (54.00 MB)
│   │   │   │   ├── 14 1-14 解决gmicro的ip地址的bug （1122）.mp4 (59.74 MB)
│   │   │   │   ├── 16 1-16 k8s的service的负载均衡和本地负载均衡的区别 （1816）.mp4 (101.54 MB)
│   │   │   │   ├── 09 1-9 编写jenkinsfile完成docker构建和发布 （1443）.mp4 (40.77 MB)
│   │   │   │   ├── 02 1-2 通过多阶段构建对go镜像瘦身 （1416）.mp4 (76.55 MB)
│   │   │   │   ├── 18 1-18 通过ingress暴露service （1421）.mp4 (23.26 MB)
│   │   │   │   ├── 04 1-4 devops、ci、cd和gitops等概念 （2137）.mp4 (125.53 MB)
│   │   │   │   ├── 08 1-8 编写Dockerfile （0933）.mp4 (53.55 MB)
│   │   │   │   ├── 05 1-5 安装git parameter插件 （1220）.mp4 (64.10 MB)
│   │   │   │   ├── 10 1-10 jenkins构建后发布到k8s中 （2333）.mp4 (128.24 MB)
│   │   │   │   └── 03 1-3 完善多阶段构建的dockerfile （0600）.mp4 (13.12 MB)
│   ├── 02 阶段二：Go电商项目- 微服务基础/
│   │   ├── 04 gin快速入门/
│   │   │   └── 01 第1章 gin快速入门/
│   │   │   │   ├── 05 1-5 获取get和post表单信息 （1816）.mp4 (45.73 MB)
│   │   │   │   ├── 09 1-9 表单验证错误翻译成中文 （1606）.mp4 (85.98 MB)
│   │   │   │   ├── 07 1-7 登录的表单验证 （1635）.mp4 (88.27 MB)
│   │   │   │   ├── 16 1-16 static静态文件的处理 （0511）.mp4 (28.30 MB)
│   │   │   │   ├── 11 1-11 自定义gin中间件 （1621）.mp4 (37.06 MB)
│   │   │   │   ├── 13 1-13 gin的中间件原理源码分析 （0922）.mp4 (51.33 MB)
│   │   │   │   ├── 15 1-15 加载多个html文件 （1328）.mp4 (74.08 MB)
│   │   │   │   ├── 12 1-12 通过abort终止中间件后续逻辑的执行 （1115）.mp4 (61.51 MB)
│   │   │   │   ├── 06 1-6 gin返回protobuf （1308）.mp4 (73.55 MB)
│   │   │   │   ├── 03 1-3 gin的路由分组 （0758）.mp4 (43.40 MB)
│   │   │   │   ├── 17 1-17 gin的优雅退出 （1355）.mp4 (30.49 MB)
│   │   │   │   ├── 14 1-14 gin返回html （2402）.mp4 (55.77 MB)
│   │   │   │   ├── 02 1-2 使用New和Default初始化路由器的区别 （0646）.mp4 (18.84 MB)
│   │   │   │   ├── 08 1-8 注册表单的验证 （1433）.mp4 (38.45 MB)
│   │   │   │   ├── 01 1-1 gin的helloworld体验 （1045）.mp4 (58.58 MB)
│   │   │   │   ├── 10 1-10 表单中文翻译的json格式化细节 （0904）.mp4 (49.75 MB)
│   │   │   │   └── 04 1-4 获取url中的变量 （1854）.mp4 (103.89 MB)
│   │   ├── 02 grpc和protobuf进阶/
│   │   │   └── 01 第1章 protobuf和grpc进阶/
│   │   │   │   ├── 02 1-2 option go_package的作用 （0637）.mp4 (37.00 MB)
│   │   │   │   ├── 03 1-3 proto文件同步时的坑 （1659）.mp4 (39.46 MB)
│   │   │   │   ├── 09 1-9 grpc的metadata机制 （2008）.mp4 (61.11 MB)
│   │   │   │   ├── 13 1-13 1-12-2grpc的验证器 （1520）.mp4 (84.77 MB)
│   │   │   │   ├── 15 1-15 grpc中的错误处理 （0930）.mp4 (27.82 MB)
│   │   │   │   ├── 14 1-14 grpc的状态码 （0716）.mp4 (37.18 MB)
│   │   │   │   ├── 08 1-8 使用protobuf内置的timestamp类型 （0644）.mp4 (39.16 MB)
│   │   │   │   ├── 16 1-16 grpc的超时机制 （0619）.mp4 (43.00 MB)
│   │   │   │   ├── 01 1-1 protobuf的基本类型和默认值 （0955）.mp4 (55.02 MB)
│   │   │   │   ├── 12 1-12 grpc的验证器 （1436）.mp4 (55.25 MB)
│   │   │   │   ├── 06 1-6 protobuf中的enum枚举类型 （0707）.mp4 (22.67 MB)
│   │   │   │   ├── 11 1-11 通过拦截器和metadata实现grpc的auth认证 （1703）.mp4 (93.49 MB)
│   │   │   │   ├── 10 1-10 grpc拦截器 （2001）.mp4 (110.81 MB)
│   │   │   │   ├── 04 1-4 proto文件中import另一个proto文件 （1049）.mp4 (62.68 MB)
│   │   │   │   ├── 05 1-5 嵌套的message对象 （0817）.mp4 (47.85 MB)
│   │   │   │   ├── 17 1-17 protoc生成的go的源码里面有什么 （1225）.mp4 (69.12 MB)
│   │   │   │   └── 07 1-7 map类型 （0511）.mp4 (28.41 MB)
│   │   ├── 03 yapi文档管理、gorm详解/
│   │   │   ├── 03 第3章 yapi的安装和配置/
│   │   │   │   ├── 02 3-2 接口文档管理之痛 （0701）.mp4 (39.50 MB)
│   │   │   │   ├── 03 3-3 yapi的安装和配置 （1224）.mp4 (56.65 MB)
│   │   │   │   ├── 04 3-4 yapi基本功能使用 （1617）.mp4 (91.80 MB)
│   │   │   │   ├── 05 3-5 接口的导入和导出 （1012）.mp4 (56.49 MB)
│   │   │   │   └── 01 3-1 前后端分离的系统开发演变过程 （0908）.mp4 (51.42 MB)
│   │   │   ├── 02 第2章 单体应用到到微服务架构演进/
│   │   │   │   ├── 03 2-3 单体应用的架构演变 （1719）.mp4 (97.56 MB)
│   │   │   │   ├── 04 2-4 服务拆分变动 （0829）.mp4 (21.70 MB)
│   │   │   │   ├── 06 2-6 分层微服务架构 （1104）.mp4 (61.63 MB)
│   │   │   │   ├── 05 2-5 微服务的基本拆分 （0938）.mp4 (53.22 MB)
│   │   │   │   ├── 07 2-7 微服务需要解决的问题 - 重要！！ （1926）.mp4 (51.41 MB)
│   │   │   │   ├── 02 2-2 单体应用开发痛点 （1346）.mp4 (77.04 MB)
│   │   │   │   └── 01 2-1 单体应用如何部署 （1034）.mp4 (22.50 MB)
│   │   │   ├── 01 第1章 项目需求分析/
│   │   │   │   ├── 03 1-3 电商系统需求分析 （0544）.mp4 (32.62 MB)
│   │   │   │   ├── 01 1-1 如何启动电商系统和后台管理系统 （0420）.mp4 (11.73 MB)
│   │   │   │   └── 02 1-2 后台管理系统需求 （0514）.mp4 (28.42 MB)
│   │   │   └── 04 第4章 gorm快速入门/
│   │   │   │   ├── 01 4-1 什么是orm如何正确看待orm （1518）.mp4 (29.02 MB)
│   │   │   │   ├── 10 4-10 gorm的基本查询 （1847）.mp4 (56.38 MB)
│   │   │   │   ├── 04 4-4 gorm的Model的逻辑删除 （0927）.mp4 (33.44 MB)
│   │   │   │   ├── 03 4-3 快速体验auto migrate功能 （1225）.mp4 (69.81 MB)
│   │   │   │   ├── 17 4-17 gorm的表名自定义、自定义beforecreate逻辑 （1110）.mp4 (62.08 MB)
│   │   │   │   ├── 09 4-9 通过take，first、last获取数据 （1213）.mp4 (66.88 MB)
│   │   │   │   ├── 05 4-5 通过NullString解决不能更新零值的问题 （0810）.mp4 (45.68 MB)
│   │   │   │   ├── 02 4-2 gorm连接数据库 （1257）.mp4 (69.62 MB)
│   │   │   │   ├── 11 4-11 gorm的更新操作 （0920）.mp4 (53.00 MB)
│   │   │   │   ├── 07 4-7 通过create方法插入记录 （1322）.mp4 (43.78 MB)
│   │   │   │   ├── 15 4-15 has many关系 （1610）.mp4 (90.47 MB)
│   │   │   │   ├── 06 4-6 表结构定义细节 （1453）.mp4 (82.22 MB)
│   │   │   │   ├── 12 4-12 gorm的软删除细节 （0930）.mp4 (53.07 MB)
│   │   │   │   ├── 08 4-8 批量插入和通过map插入记录 （1015）.mp4 (57.02 MB)
│   │   │   │   ├── 16 4-16 gorm处理多对多的关系 （1615）.mp4 (46.68 MB)
│   │   │   │   ├── 14 4-14 通过preload和joins查询多表 （0809）.mp4 (45.83 MB)
│   │   │   │   └── 13 4-13 表的关联插入 （1459）.mp4 (40.06 MB)
│   │   └── 01 从0开始理解rpc和grpc/
│   │   │   ├── 02 第2章 rpc核心概念理解/
│   │   │   │   ├── 02 2-2 go编码规范-1 （2039）.mp4 (114.17 MB)
│   │   │   │   ├── 06 2-6 通过http完成add服务端的功能 （1635）.mp4 (35.50 MB)
│   │   │   │   ├── 04 2-4 什么是rpcrpc开发的挑战是什么-1 （2250）.mp4 (134.52 MB)
│   │   │   │   ├── 05 2-5 什么是rpcrpc开发的挑战是什么- 2 （2149）.mp4 (120.61 MB)
│   │   │   │   ├── 08 2-8 rpc架构技术要点 （0544）.mp4 (32.20 MB)
│   │   │   │   ├── 07 2-7 通过http完成add客户端的功能 （0711）.mp4 (40.54 MB)
│   │   │   │   ├── 03 2-3 go编码规范-2 （1539）.mp4 (30.04 MB)
│   │   │   │   └── 01 2-1 gopath开发模式和go modules开发模式对比 （2140）.mp4 (127.65 MB)
│   │   │   ├── 01 第1章 开发环境搭建/
│   │   │   │   ├── 09 1-9 linux下安装和配置nodejs开发环境 （0432）.mp4 (26.78 MB)
│   │   │   │   ├── 04 1-4 xshell的安装和使用 （0340）.mp4 (6.61 MB)
│   │   │   │   ├── 10 1-10 代码提示神器 - kite的安装和配置 （0719）.mp4 (16.35 MB)
│   │   │   │   ├── 03 1-3 windows中安装centos7虚拟机 （1659）.mp4 (94.10 MB)
│   │   │   │   ├── 02 1-2 课程中需要用到的开发环境介绍 （0630）.mp4 (36.87 MB)
│   │   │   │   ├── 07 1-7 mysql和navicat的安装和配置 （1009）.mp4 (23.37 MB)
│   │   │   │   ├── 05 1-5 git的安装和配置 （0541）.mp4 (31.32 MB)
│   │   │   │   ├── 01 1-1 课程学习前的说明 - 很重要！！ （1015）.mp4 (12.97 MB)
│   │   │   │   ├── 06 1-6 docker和docker-compose的安装 （1031）.mp4 (60.61 MB)
│   │   │   │   └── 08 1-8 windows下安装nodejs开发环境 （0438）.mp4 (27.35 MB)
│   │   │   ├── 04 第4章 grpc快速入门/
│   │   │   │   ├── 03 4-3 goland下配置protobuf插件 （0957）.mp4 (56.58 MB)
│   │   │   │   ├── 07 4-7 grpc的流模式的定义 （2027）.mp4 (122.12 MB)
│   │   │   │   ├── 06 4-6 go下grpc快速体验 （2446）.mp4 (136.14 MB)
│   │   │   │   ├── 05 4-5 为什么我们需要安装protoc和protoc-gen-go （1150）.mp4 (25.39 MB)
│   │   │   │   ├── 01 4-1 什么是grpc和protobuf （1334）.mp4 (74.98 MB)
│   │   │   │   ├── 08 4-8 grpc的单向流，双向流代码实现 （2240）.mp4 (53.71 MB)
│   │   │   │   ├── 04 4-4 protobuf和json的直观对比 （1934）.mp4 (108.29 MB)
│   │   │   │   └── 02 4-2 grpc开发环境的搭建 （0751）.mp4 (20.16 MB)
│   │   │   └── 03 第3章 go内置rpc快速开发/
│   │   │   │   ├── 03 3-3 替换rpc的传输协议为http （0929）.mp4 (52.81 MB)
│   │   │   │   ├── 02 3-2 替换rpc的序列化协议为json （2117）.mp4 (116.84 MB)
│   │   │   │   ├── 05 3-5 进一步改造rpc调用的代码-2 （1720）.mp4 (95.56 MB)
│   │   │   │   ├── 04 3-4 进一步改造rpc调用的代码-1 （1746）.mp4 (46.65 MB)
│   │   │   │   └── 01 3-1 go快速体验rpc开发 （2259）.mp4 (39.89 MB)
│   ├── 07 阶段七：效率工具开发/
│   │   └── 01 protoc插件开发、cobra命令行/
│   │   │   ├── 02 第2章 命令行开发神器-cobra/
│   │   │   │   ├── 03 2-3 通过cobra简化项目启动 （0821）.mp4 (48.01 MB)
│   │   │   │   ├── 04 2-4 通过cobra-cli简化开发 （0558）.mp4 (34.06 MB)
│   │   │   │   ├── 01 2-1 不同服务的通用性在哪里 （1501）.mp4 (84.75 MB)
│   │   │   │   ├── 05 2-5 为命令添加flag解析 （0326）.mp4 (10.92 MB)
│   │   │   │   └── 02 2-2 不使用cobra如何完成项目启动参数检查 （0853）.mp4 (23.48 MB)
│   │   │   └── 01 第1章 protoc自定义插件/
│   │   │   │   ├── 07 1-7 gin转发到grpc服务的原理和实现 （2743）.mp4 (152.44 MB)
│   │   │   │   ├── 04 1-4 proto文件中的package和go_package的作用 （0722）.mp4 (42.14 MB)
│   │   │   │   ├── 01 1-1 工程实践中如何更好的使用proto文件 （2557）.mp4 (143.39 MB)
│   │   │   │   ├── 03 1-3 protoc执行的插件加载原理是什么 （0647）.mp4 (18.20 MB)
│   │   │   │   ├── 05 1-5 protoc插件开发原理 （1213）.mp4 (69.38 MB)
│   │   │   │   ├── 10 1-10 protoc生成gin的插件 （2333）.mp4 (130.28 MB)
│   │   │   │   ├── 09 1-9 go的template实现动态生成代码 （2358）.mp4 (79.20 MB)
│   │   │   │   ├── 08 1-8 一些细节的处理和纠正 （0445）.mp4 (27.17 MB)
│   │   │   │   ├── 02 1-2 protoc命令如何查询依赖的proto文件 （1255）.mp4 (70.37 MB)
│   │   │   │   └── 06 1-6 修改protoreflect源码便于调试 （2049）.mp4 (90.65 MB)
│   ├── 00 电子书/
│   │   ├── 05 第7周 gin快速入门/
│   │   │   ├── 07 6. 中间件和next函数.html (0.04 MB)
│   │   │   ├── 01 gorm是什么.html (0.04 MB)
│   │   │   ├── 09 8. 优雅重启或停止.html (0.04 MB)
│   │   │   ├── 06 5. 表单验证.html (0.07 MB)
│   │   │   ├── 05 4. JSON、ProtoBuf 渲染.html (0.04 MB)
│   │   │   ├── 02 1. 快速入门.html (0.04 MB)
│   │   │   ├── 04 3. 获取参数.html (0.04 MB)
│   │   │   ├── 03 2. url和路由分组.html (0.04 MB)
│   │   │   └── 08 7. 设置静态文件路径和html文件.html (0.04 MB)
│   │   ├── 09 第12周 商品微服务的gin层和oss图片服务/
│   │   │   ├── 01 1. 商品列表接口.html (0.04 MB)
│   │   │   ├── 07 7. oss快速入门.html (0.07 MB)
│   │   │   ├── 02 2. 新建商品.html (0.03 MB)
│   │   │   ├── 10 10. 内网穿透.html (0.07 MB)
│   │   │   ├── 03 3. 删除，更新商品.html (0.05 MB)
│   │   │   ├── 08 8. 阿里云oss开发入门.html (0.04 MB)
│   │   │   ├── 05 5. 轮播图接口.html (0.06 MB)
│   │   │   ├── 09 9. 服务端签名直传.html (0.09 MB)
│   │   │   ├── 06 6. 品牌分类.html (0.09 MB)
│   │   │   ├── 04 4. 商品分类接口.html (0.07 MB)
│   │   │   └── 11 11. 项目文档和资源.html (0.04 MB)
│   │   ├── 20 第25周 ast代码生成工具开发/
│   │   │   └── 01 错误码.html (0.03 MB)
│   │   ├── 22 第27周 grpc服务封装更方便的rpc服务/
│   │   │   └── 01 host.go源码.html (0.05 MB)
│   │   ├── 07 第10周 服务注册发现、配置中心、负载均衡/
│   │   │   ├── 06 6. 动态获取可用端口号.html (0.03 MB)
│   │   │   ├── 07 7. 负载均衡策略.html (0.21 MB)
│   │   │   ├── 14 14. gin集成nacos.html (0.04 MB)
│   │   │   ├── 02 2. consul的安装和配置.html (0.03 MB)
│   │   │   ├── 03 3. consul的api接口.html (0.03 MB)
│   │   │   ├── 09 9. grpc的负载均衡策略.html (0.04 MB)
│   │   │   ├── 11 11. 分布式配置中心选型.html (0.03 MB)
│   │   │   ├── 04 4. go操作consul.html (0.04 MB)
│   │   │   ├── 13 13. nacos的基本使用.html (0.03 MB)
│   │   │   ├── 01 1. 什么是服务注册和发现.html (0.03 MB)
│   │   │   ├── 10 10. 为什么需要分布式配置中心.html (0.03 MB)
│   │   │   ├── 12 12. nacos的安装和配置.html (0.03 MB)
│   │   │   ├── 08 8.常见的负载均衡算法.html (0.04 MB)
│   │   │   └── 05 5. grpc下的健康检查.html (0.03 MB)
│   │   ├── 15 第20周 api网关、部署/
│   │   │   ├── 01 1. api网关对比.html (0.03 MB)
│   │   │   ├── 09 9. 定时构建的语法.html (0.03 MB)
│   │   │   ├── 04 4. 什么是敏捷开发.html (0.04 MB)
│   │   │   ├── 07 7. 部署到远程服务器并运行.html (0.03 MB)
│   │   │   ├── 10 10. shell脚本启动go服务.html (0.04 MB)
│   │   │   ├── 03 3. 配置jwt.html (0.03 MB)
│   │   │   ├── 02 2. kong的安装和配置.html (0.04 MB)
│   │   │   ├── 08 8. jenkins的pipeline参数详解.html (0.05 MB)
│   │   │   ├── 06 6. jenkins的插件管理.html (0.04 MB)
│   │   │   └── 05 5. jenkin的安装和配置.html (0.04 MB)
│   │   ├── 27 第34+周 devops和k8s/
│   │   │   ├── 05 课程总结.html (0.03 MB)
│   │   │   ├── 02 kubesphere的ingress的坑.html (0.03 MB)
│   │   │   ├── 04 k8s的控制器.html (0.03 MB)
│   │   │   ├── 03 k8s中的基础概念 - pod.html (0.03 MB)
│   │   │   └── 01 jenkinsfile执行docker的坑.html (0.03 MB)
│   │   ├── 04 第6周 yapi文档管理、gorm详解/
│   │   │   ├── 01 1. docker安装yapi.html (0.46 MB)
│   │   │   └── 02 2. 接口数据下载.html (0.03 MB)
│   │   ├── 06 第9周 用户服务的web服务/
│   │   │   ├── 07 7. 图形验证码.html (0.03 MB)
│   │   │   ├── 08 8. 阿里云发送短信.html (0.04 MB)
│   │   │   ├── 04 4. json web token（jwt）详解.html (0.19 MB)
│   │   │   ├── 01 1. go 日志库 zap.html (0.04 MB)
│   │   │   ├── 03 3. 自定义验证器.html (0.04 MB)
│   │   │   ├── 02 2. go的配置文件管理-viper.html (0.05 MB)
│   │   │   ├── 05 5. jwt集成gin.html (0.03 MB)
│   │   │   ├── 06 6. 浏览器的跨域请求问题.html (0.17 MB)
│   │   │   └── 09 9. redis的安装.html (0.03 MB)
│   │   ├── 03 第5周 grpc和protobuf进阶/
│   │   │   ├── 04 4. token认证.html (0.05 MB)
│   │   │   ├── 01 1. protobuf官方文档参考.html (0.10 MB)
│   │   │   ├── 03 3. grpc拦截器 - go.html (0.05 MB)
│   │   │   ├── 05 5. grpc验证器.html (0.05 MB)
│   │   │   ├── 02 2. go控制grpc的metadata.html (0.05 MB)
│   │   │   └── 06 6. grpc中的异常处理.html (0.03 MB)
│   │   ├── 16 第21周 开发规范和go基础扩展/
│   │   │   ├── 06 6. 微服务的目录结构（ mono-repo）.html (0.03 MB)
│   │   │   ├── 03 3. go代码规范.html (0.03 MB)
│   │   │   ├── 02 2. git的简单规范.html (0.04 MB)
│   │   │   ├── 01 1. 有哪些规范我们应该遵循.html (0.03 MB)
│   │   │   ├── 04 4. go项目目录规范.html (0.03 MB)
│   │   │   ├── 07 7. go代码的检测工具.html (0.03 MB)
│   │   │   ├── 08 8. go中常见的错误.html (0.05 MB)
│   │   │   └── 05 5. 微服务该采用multi-repo还是mono-repo.html (0.04 MB)
│   │   ├── 14 第19周 链路追踪、限流、熔断、降级/
│   │   │   ├── 01 1. 什么是链路追踪.html (0.04 MB)
│   │   │   ├── 03 3. jaeger安装和架构.html (0.03 MB)
│   │   │   ├── 06 6. 熔断、限流技术选型.html (0.03 MB)
│   │   │   ├── 05 5. grpc下添加jaeger.html (0.03 MB)
│   │   │   ├── 04 4. opentracing解析.html (0.05 MB)
│   │   │   └── 02 2. 链路追踪技术选型.html (0.03 MB)
│   │   ├── 02 第4周 从0开始理解rpc和grpc/
│   │   │   ├── 07 7. go语言编码规范.html (0.05 MB)
│   │   │   ├── 13 13. go的grpc开发体验.html (0.04 MB)
│   │   │   ├── 01 1. 课程需要用到的开发环境介绍.html (0.11 MB)
│   │   │   ├── 08 8. 什么是rpc.html (0.04 MB)
│   │   │   ├── 02 2. 安装docker-compose.html (0.21 MB)
│   │   │   ├── 06 6. nodejs的安装和配置.html (0.13 MB)
│   │   │   ├── 14 14. grpc的四种数据流.html (0.05 MB)
│   │   │   ├── 09 9. rpc、http以及restful 之间的区.html (0.04 MB)
│   │   │   ├── 10 10. rpc开发的要素分析.html (0.28 MB)
│   │   │   ├── 11 11. go语言的rpc之hello world.html (0.04 MB)
│   │   │   ├── 03 3. 安装navicat和mysql.html (0.03 MB)
│   │   │   ├── 04 4. 虚拟环境的安装和配置.html (0.03 MB)
│   │   │   ├── 05 5. go的安装和配置.html (0.03 MB)
│   │   │   └── 12 12. 什么是grpc和protobuf.html (0.25 MB)
│   │   ├── 28 总结/
│   │   │   └── 01 总结.html (0.04 MB)
│   │   ├── 08 第11周 商品微服务的grpc服务/
│   │   │   ├── 03 3. 商品列表页功能.html (0.07 MB)
│   │   │   ├── 07 7. 品牌相关的接口.html (0.05 MB)
│   │   │   ├── 04 4. 库存的微服务设计.html (0.15 MB)
│   │   │   ├── 05 5. 商品分类的各个函数.html (0.05 MB)
│   │   │   ├── 01 1. model定义.html (0.23 MB)
│   │   │   ├── 06 6. 轮播图的各个handler.html (0.04 MB)
│   │   │   ├── 08 8. 品牌分类接口.html (0.06 MB)
│   │   │   └── 02 2. protobuf定义.html (0.07 MB)
│   │   ├── 10 第13周 库存服务和分布式锁/
│   │   │   ├── 04 4. mysql的for update实现悲观锁.html (0.05 MB)
│   │   │   ├── 03 3. 为什么需要分布式锁.html (0.03 MB)
│   │   │   ├── 07 7. 常见的分布式锁实现方案.html (0.04 MB)
│   │   │   ├── 06 6. redlock详解.html (0.04 MB)
│   │   │   ├── 02 2. 库存服务表结构.html (0.03 MB)
│   │   │   ├── 01 1. 库存服务架构设计.html (0.03 MB)
│   │   │   └── 05 5. 基于redis实现分布式锁.html (0.04 MB)
│   │   ├── 19 第24周 log日志包设计/
│   │   │   └── 01 日志源码.html (0.03 MB)
│   │   ├── 12 第16周 elasticsearch实现搜索微服务/
│   │   │   ├── 06 6. 更新和删除数据.html (0.03 MB)
│   │   │   ├── 02 2. elasticsearch安装.html (0.03 MB)
│   │   │   ├── 11 11. 分词的重要性.html (0.67 MB)
│   │   │   ├── 12 12. ik分词器安装和配置.html (0.03 MB)
│   │   │   ├── 01 1. 什么是elasticsearch.html (0.04 MB)
│   │   │   ├── 07 7. 批量插入和批量查询.html (0.04 MB)
│   │   │   ├── 05 5. 获取数据.html (0.03 MB)
│   │   │   ├── 14 14. 倒排索引算法 - 扩展文档.html (1.19 MB)
│   │   │   ├── 09 9. mapping.html (1.81 MB)
│   │   │   ├── 08 8. query dsl查询.html (0.04 MB)
│   │   │   ├── 13 13. es集成到mxshop_srvs.html (0.04 MB)
│   │   │   ├── 10 10. Elasticsearch Analyze.html (0.04 MB)
│   │   │   ├── 04 4. 新建数据.html (0.03 MB)
│   │   │   └── 03 3. es中的type、index、mapping.html (0.03 MB)
│   │   ├── 17 第22周 设计模式和单元测试/
│   │   │   ├── 01 1. go最常用的设计模式 - 函数选项.html (0.03 MB)
│   │   │   ├── 02 2. 单例模式和懒加载.html (0.05 MB)
│   │   │   └── 03 3. 测试金字塔.html (0.04 MB)
│   │   ├── 25 第31周 系统监控核心/
│   │   │   ├── 01 metric源码.html (0.03 MB)
│   │   │   └── 02 安装 prometheus、 grafana.html (0.03 MB)
│   │   ├── 18 第23周 protoc插件开发、cobra命令行/
│   │   │   ├── 02 2. protoc自定义gin插件.html (0.03 MB)
│   │   │   ├── 03 cobra快速入门.html (0.05 MB)
│   │   │   └── 01 1. protoc调试源码.html (0.05 MB)
│   │   ├── 23 第28周 深入grpc的服务注册、负载均衡原理/
│   │   │   ├── 01 服务发现源码.html (0.04 MB)
│   │   │   └── 02 负载均衡相关源码.html (0.03 MB)
│   │   ├── 01 第1周：go基础知识/
│   │   │   ├── 02 2. 数据类型的转换.html (0.04 MB)
│   │   │   ├── 01 1. go基本数据类型.html (0.04 MB)
│   │   │   ├── 04 4. 转义符.html (0.03 MB)
│   │   │   ├── 03 3. 运算符和表达式.html (0.06 MB)
│   │   │   └── 05 5. 输出格式化.html (0.04 MB)
│   │   ├── 24 第30周 可观测的终极解决方案/
│   │   │   └── 01 opentelemetry.html (0.03 MB)
│   │   ├── 11 第14周 订单和购物车微服务/
│   │   │   ├── 06 6. userop-web代码.html (0.10 MB)
│   │   │   ├── 04 4. 用户服务 - proto定义.html (0.05 MB)
│   │   │   ├── 05 5. service代码.html (0.07 MB)
│   │   │   ├── 03 3. 用户操作 - 表结构设计.html (0.04 MB)
│   │   │   ├── 01 1. 表结构设计和proto文件定义.html (0.05 MB)
│   │   │   └── 02 2. 支付宝支付的相关链接.html (0.11 MB)
│   │   ├── 21 第26周 三层代码结构/
│   │   │   └── 01 通用app项目启动.html (0.03 MB)
│   │   ├── 26 34周 通过k8s部署服务/
│   │   │   ├── 09 kubernets 安装redis.html (0.03 MB)
│   │   │   ├── 08 k8s技术选型.html (0.03 MB)
│   │   │   ├── 03 dockerfile.html (0.04 MB)
│   │   │   ├── 04 docker外部数据挂载.html (0.03 MB)
│   │   │   ├── 10 kubesphere安装mysql.html (0.03 MB)
│   │   │   ├── 01 docker介绍.html (0.04 MB)
│   │   │   ├── 02 docker 网络相关.html (0.03 MB)
│   │   │   ├── 05 镜像相关操作.html (0.03 MB)
│   │   │   ├── 07 安装kubesphere.html (0.03 MB)
│   │   │   └── 06 容器相关命令.html (0.03 MB)
│   │   └── 13 第17周 分布式理论基础、分布式事务解决方案/
│   │   │   ├── 10 10. mq技术选型.html (0.03 MB)
│   │   │   ├── 05 5. tcc分布式事务.html (0.05 MB)
│   │   │   ├── 04 4. 两_三阶段提交.html (0.04 MB)
│   │   │   ├── 08 8. 最大努力通知.html (0.04 MB)
│   │   │   ├── 03 3. CAP和BASE理论.html (0.04 MB)
│   │   │   ├── 06 6. 基于本地消息表的最终一致性.html (0.04 MB)
│   │   │   ├── 01 1. 事务和分布式事务.html (0.04 MB)
│   │   │   ├── 12 12. rocketmq的基本概念.html (0.03 MB)
│   │   │   ├── 13 13. rocketmq的消息类型.html (0.04 MB)
│   │   │   ├── 07 7. 基于可靠消息的最终一致性- 最常用.html (0.04 MB)
│   │   │   ├── 16 16. grpc的超时和重试.html (0.03 MB)
│   │   │   ├── 02 2. 程序出哪些问题会导致数据不一致.html (0.03 MB)
│   │   │   ├── 14 14. go操作rocketmq开发环境搭建.html (0.03 MB)
│   │   │   ├── 15 15. 什么是服务雪崩.html (0.04 MB)
│   │   │   ├── 17 17. 常见的幂等性解决方案.html (0.04 MB)
│   │   │   ├── 11 11. rocketmq安装和配置.html (0.03 MB)
│   │   │   └── 09 9. mq（message queue）的使用场景.html (0.04 MB)
│   ├── 04 阶段四：微服务实现电商系统/
│   │   ├── 06 elasticsearch实现搜索微服务/
│   │   │   ├── 03 第3章 前后端联调/
│   │   │   │   ├── 06 3-6 品牌管理联调 （0447）.mp4 (25.01 MB)
│   │   │   │   ├── 05 3-5 商品分类联调 （1729）.mp4 (95.88 MB)
│   │   │   │   ├── 09 3-9 登录相关页面功能联调 （0410）.mp4 (24.28 MB)
│   │   │   │   ├── 02 3-2 后台管理系统-商品列表页联调 （0919）.mp4 (51.00 MB)
│   │   │   │   ├── 04 3-4 新增商品接口联调 （0710）.mp4 (27.05 MB)
│   │   │   │   ├── 03 3-3 商品详情页联调 （1037）.mp4 (57.51 MB)
│   │   │   │   ├── 01 3-1 项目启动前的url配置 （0757）.mp4 (23.50 MB)
│   │   │   │   ├── 08 3-8 电商系统-商品相关功能联调 （1012）.mp4 (56.05 MB)
│   │   │   │   └── 07 3-7 联调只读数据 （0755）.mp4 (32.43 MB)
│   │   │   ├── 01 第1章 elasticsearch常用接口/
│   │   │   │   ├── 07 1-7 通过bulk和mget批量操作数据 （1303）.mp4 (73.05 MB)
│   │   │   │   ├── 16 1-16 mapping中的keyword和text类型区别 （1417）.mp4 (77.07 MB)
│   │   │   │   ├── 11 1-11 通过multi_match指定查询字段权重 （0541）.mp4 (13.45 MB)
│   │   │   │   ├── 03 1-3 elasticsearch中的基本概念 （0558）.mp4 (34.01 MB)
│   │   │   │   ├── 10 1-10 match_phrase进行短语查询 （0446）.mp4 (25.93 MB)
│   │   │   │   ├── 20 1-20 自定义分词器词库 （0747）.mp4 (12.76 MB)
│   │   │   │   ├── 06 1-6 通过es更新数据的坑 （0737）.mp4 (42.07 MB)
│   │   │   │   ├── 04 1-4 通过put和post方法添加数据 （1530）.mp4 (88.49 MB)
│   │   │   │   ├── 02 1-2 安装elasticsearch和kibana （1137）.mp4 (29.09 MB)
│   │   │   │   ├── 14 1-14 range区间查询、exists查询、fuzzy模糊查询 （1224）.mp4 (34.99 MB)
│   │   │   │   ├── 08 1-8 一个完整的查询api是如何的-match查询 （0943）.mp4 (37.43 MB)
│   │   │   │   ├── 12 1-12 query_string查询和match_all查询 （0829）.mp4 (45.95 MB)
│   │   │   │   ├── 05 1-5 通过url和query body查询数据 （0856）.mp4 (17.19 MB)
│   │   │   │   ├── 17 1-17 match查询原理分析 - analyzer查询过程 （1457）.mp4 (47.00 MB)
│   │   │   │   ├── 09 1-9 es是如何通过倒排索引查询数据的（1：30-2：30 代码小） （1302）.mp4 (71.37 MB)
│   │   │   │   ├── 18 1-18 分词对于elasticsearch为什么很重要 （1509）.mp4 (84.50 MB)
│   │   │   │   ├── 13 1-13 term查询有哪些需要注意的地方 （1232）.mp4 (67.93 MB)
│   │   │   │   ├── 01 1-1 我们为什么要用elasticsearch进行搜索_音频 （1342）.mp4 (77.12 MB)
│   │   │   │   ├── 19 1-19 ik分词器的安装和使用 （1424）.mp4 (78.92 MB)
│   │   │   │   └── 15 1-15 bool复合查询- must、must_not、should、filter （0918）.mp4 (52.92 MB)
│   │   │   └── 02 第2章 将elasticsearch集成到项目中/
│   │   │   │   ├── 02 2-2 将es中的对象转换为struct类型 （0514）.mp4 (28.93 MB)
│   │   │   │   ├── 03 2-3 保存数据到es中 （0542）.mp4 (20.78 MB)
│   │   │   │   ├── 11 2-11 如何通过mysql和es协作完成商品的查询-2 （1705）.mp4 (93.49 MB)
│   │   │   │   ├── 09 2-9 将mysql中的商品数据同步到es中 （1048）.mp4 (37.44 MB)
│   │   │   │   ├── 06 2-6 mysql和es分别在系统中的角色是什么 （0934）.mp4 (34.38 MB)
│   │   │   │   ├── 10 2-10 如何通过mysql和es协作完成商品的查询-1 （1425）.mp4 (79.79 MB)
│   │   │   │   ├── 13 2-13 确保商品添加到es中的事务一致性 （1646）.mp4 (91.52 MB)
│   │   │   │   ├── 01 2-1 go实现match查询 （2227）.mp4 (124.97 MB)
│   │   │   │   ├── 05 2-5 有哪些接口需要使用es （0440）.mp4 (26.04 MB)
│   │   │   │   ├── 07 2-7 建立商品对应的struct和mapping （0824）.mp4 (46.53 MB)
│   │   │   │   ├── 12 2-12 调试商品列表的es搜索 （0620）.mp4 (30.38 MB)
│   │   │   │   ├── 08 2-8 启动gin的初始化过程新建index和mapping （1312）.mp4 (73.13 MB)
│   │   │   │   ├── 14 2-14 es实现商品的更新和商品的删除 （1245）.mp4 (71.41 MB)
│   │   │   │   └── 04 2-4 通过go语言完成mapping的新建 （0508）.mp4 (29.53 MB)
│   │   ├── 02 商品微服务的gin层和oss图片服务/
│   │   │   ├── 02 第2章 阿里云的oss服务集成/
│   │   │   │   ├── 02 2-2 oss的基本概念介绍 （1042）.mp4 (29.89 MB)
│   │   │   │   ├── 01 2-1 为什么要使用阿里云oss （0710）.mp4 (40.10 MB)
│   │   │   │   ├── 04 2-4 前端直传oss的流程 （1415）.mp4 (81.58 MB)
│   │   │   │   ├── 07 2-7 内网穿透技术解决前端直传的回调 （1349）.mp4 (77.86 MB)
│   │   │   │   ├── 03 2-3 使用代码控制文件上传 （1749）.mp4 (97.74 MB)
│   │   │   │   ├── 05 2-5 gin集成前端直传文件 （2143）.mp4 (78.43 MB)
│   │   │   │   ├── 06 2-6 为什么我们需要内网穿透 （0850）.mp4 (47.56 MB)
│   │   │   │   └── 08 2-8 将oss集成到gin微服务中 （1456）.mp4 (57.61 MB)
│   │   │   └── 01 第1章 gin完成商品服务的http接口/
│   │   │   │   ├── 06 1-6 用户的web服务服务注册和优雅退出 （0541）.mp4 (25.59 MB)
│   │   │   │   ├── 05 1-5 gin的退出后的服务注销 （0520）.mp4 (29.46 MB)
│   │   │   │   ├── 09 1-9 商品删除，更新 （1531）.mp4 (56.57 MB)
│   │   │   │   ├── 02 1-2 商品的列表页接口 - 1 （1421）.mp4 (80.01 MB)
│   │   │   │   ├── 08 1-8 获取商品详情 （0927）.mp4 (52.18 MB)
│   │   │   │   ├── 12 1-12 品牌列表页接口 （0639）.mp4 (24.82 MB)
│   │   │   │   ├── 04 1-4 如何设计一个符合go风格的注册中心接口 （2224）.mp4 (123.48 MB)
│   │   │   │   ├── 11 1-11 轮播图接口和yapi的快速测试 （1546）.mp4 (84.22 MB)
│   │   │   │   ├── 10 1-10 商品分类的接口 （2210）.mp4 (119.88 MB)
│   │   │   │   ├── 03 1-3 商品的列表页接口 - 2 （1245）.mp4 (50.05 MB)
│   │   │   │   ├── 13 1-13 品牌分类接口 （1111）.mp4 (63.28 MB)
│   │   │   │   ├── 01 1-1 快速将用户的web服务转换成商品的web服务 （1823）.mp4 (100.87 MB)
│   │   │   │   └── 07 1-7 新建商品 （1912）.mp4 (105.41 MB)
│   │   ├── 03 库存服务和分布式锁/
│   │   │   ├── 02 第2章 分布式锁/
│   │   │   │   ├── 05 2-5 mysql的for update语句实现悲观锁 （1353）.mp4 (77.73 MB)
│   │   │   │   ├── 07 2-7 基于mysql的乐观锁实现原理 （1312）.mp4 (73.61 MB)
│   │   │   │   ├── 08 2-8 gorm实现基于mysql的乐观锁 （1537）.mp4 (86.19 MB)
│   │   │   │   ├── 13 2-13 redis分布式锁源码解析 -如何防止锁被其他的goroutine删除 （0743）.mp4 (43.98 MB)
│   │   │   │   ├── 06 2-6 gorm实现for update悲观锁 （0608）.mp4 (23.23 MB)
│   │   │   │   ├── 02 2-2 通过锁解决并发的问题 （1607）.mp4 (91.80 MB)
│   │   │   │   ├── 12 2-12 redis分布式锁源码解析 - 过期时间和延长锁过期时间机制 （1102）.mp4 (27.71 MB)
│   │   │   │   ├── 01 2-1 并发场景下的库存扣减不正确的问题 （0822）.mp4 (46.77 MB)
│   │   │   │   ├── 11 2-11 redis分布式锁源码解析 - setnx的作用 （1033）.mp4 (58.65 MB)
│   │   │   │   ├── 10 2-10 redsync集成到库存服务中 （0835）.mp4 (47.54 MB)
│   │   │   │   ├── 03 2-3 什么是分布式锁 （0736）.mp4 (21.05 MB)
│   │   │   │   ├── 14 2-14 redis的分布式锁在集群环境之下容易出现的问题 （0723）.mp4 (41.28 MB)
│   │   │   │   ├── 04 2-4 悲观锁机制和mutex有什么关系 （0853）.mp4 (49.06 MB)
│   │   │   │   ├── 15 2-15 redlock源码分析 （1625）.mp4 (49.73 MB)
│   │   │   │   └── 09 2-9 基于redsync的分布式锁实现同步 （1035）.mp4 (30.20 MB)
│   │   │   └── 01 第1章 库存服务/
│   │   │   │   ├── 02 1-2 表结构设计 （1506）.mp4 (82.92 MB)
│   │   │   │   ├── 07 1-7 订单超时归还的重要性 （0526）.mp4 (30.74 MB)
│   │   │   │   ├── 06 1-6 本地数据库事务解决库存扣减的失败问题 （1416）.mp4 (38.86 MB)
│   │   │   │   ├── 01 1-1 库存服务的重要性 （0743）.mp4 (43.32 MB)
│   │   │   │   ├── 04 1-4 快速启动库存服务 （0740）.mp4 (44.02 MB)
│   │   │   │   ├── 05 1-5 设置库存和获取库存接口 （0807）.mp4 (45.91 MB)
│   │   │   │   ├── 09 1-9 为所有的商品添加库存信息 （0339）.mp4 (15.75 MB)
│   │   │   │   ├── 03 1-3 proto接口设计 （2245）.mp4 (47.01 MB)
│   │   │   │   └── 08 1-8 测试库存接口 （2013）.mp4 (109.95 MB)
│   │   ├── 05 支付宝支付、用户操作微服务、前后端联调/
│   │   │   ├── 02 第2章 收藏、收货地址、留言服务开发/
│   │   │   │   ├── 01 2-1 需求分析 （0434）.mp4 (15.83 MB)
│   │   │   │   ├── 07 2-7 gin的api源码解读 （1919）.mp4 (65.04 MB)
│   │   │   │   ├── 05 2-5 service的handler源码解读 （1727）.mp4 (94.35 MB)
│   │   │   │   ├── 04 2-4 启动用户服务 （0521）.mp4 (18.82 MB)
│   │   │   │   ├── 08 2-8 通过yapi测试接口 （1002）.mp4 (56.54 MB)
│   │   │   │   ├── 02 2-2 定义用户操作服务的表结构 （0833）.mp4 (46.57 MB)
│   │   │   │   ├── 06 2-6 web服务启动 （1352）.mp4 (74.66 MB)
│   │   │   │   └── 03 2-3 定义proto接口 （0857）.mp4 (50.23 MB)
│   │   │   └── 01 第1章 支付宝支付/
│   │   │   │   ├── 05 1-5 gin集成支付宝支付 （1757）.mp4 (98.45 MB)
│   │   │   │   ├── 02 1-2 私钥、公钥的概念以及支付宝如何解决订单的安全性问题 （2009）.mp4 (111.95 MB)
│   │   │   │   ├── 04 1-4 生成支付宝的支付url （1350）.mp4 (44.16 MB)
│   │   │   │   ├── 06 1-6 支付宝回调通知url逻辑接口 （1854）.mp4 (103.76 MB)
│   │   │   │   ├── 03 1-3 支付宝的公钥、私钥和回调url配置 （0829）.mp4 (45.51 MB)
│   │   │   │   └── 01 1-1 支付宝沙箱环境开发流程 （0543）.mp4 (10.76 MB)
│   │   ├── 01 商品微服务的grpc服务/
│   │   │   └── 01 第1章 商品服务-service服务/
│   │   │   │   ├── 06 1-6 生成表结构和导入数据 （0700）.mp4 (24.41 MB)
│   │   │   │   ├── 07 1-7 定义proto接口 （1634）.mp4 (94.64 MB)
│   │   │   │   ├── 05 1-5 商品表结构设计 （1616）.mp4 (90.44 MB)
│   │   │   │   ├── 04 1-4 品牌、轮播图表结构设计 （1117）.mp4 (64.32 MB)
│   │   │   │   ├── 18 1-18 商品列表页接口 - 2 （1336）.mp4 (52.71 MB)
│   │   │   │   ├── 09 1-9 品牌列表实现 （2107）.mp4 (84.38 MB)
│   │   │   │   ├── 20 1-20 批量获取商品信息、商品详情接口 （1149）.mp4 (64.29 MB)
│   │   │   │   ├── 15 1-15 商品分类的新建，删除和更新接口 （0501）.mp4 (20.43 MB)
│   │   │   │   ├── 10 1-10 品牌新建，删除、更新 （1150）.mp4 (65.95 MB)
│   │   │   │   ├── 21 1-21 新增、修改和删除商品接口 （0716）.mp4 (29.45 MB)
│   │   │   │   ├── 01 1-1 需求分析-数据库实体分析 （1017）.mp4 (55.60 MB)
│   │   │   │   ├── 19 1-19 商品列表页接口 - 3 （1718）.mp4 (94.93 MB)
│   │   │   │   ├── 16 1-16 品牌分类相关接口 （1551）.mp4 (88.39 MB)
│   │   │   │   ├── 08 1-8 快速启动grpc服务 （1851）.mp4 (101.66 MB)
│   │   │   │   ├── 13 1-13 商品分类的列表接口 - 2 （1421）.mp4 (78.23 MB)
│   │   │   │   ├── 14 1-14 获取商品分类的子分类 （1504）.mp4 (82.15 MB)
│   │   │   │   ├── 17 1-17 商品列表页接口 - 1 （1703）.mp4 (94.03 MB)
│   │   │   │   ├── 12 1-12 商品分类的列表接口 - 1 （1824）.mp4 (59.25 MB)
│   │   │   │   ├── 02 1-2 需求分析-商品微服务接口分析 （0919）.mp4 (52.43 MB)
│   │   │   │   ├── 03 1-3 商品分类表结构设计应该注意什么 （2112）.mp4 (48.25 MB)
│   │   │   │   └── 11 1-11 轮播图的查询、新增、删除和修改 （0330）.mp4 (19.37 MB)
│   │   └── 04 订单和购物车微服务/
│   │   │   ├── 01 第1章 订单和购物车服务-service/
│   │   │   │   ├── 07 1-7 订单列表页接口 （1328）.mp4 (73.76 MB)
│   │   │   │   ├── 16 1-16 订单服务接口调试-2 （1524）.mp4 (83.12 MB)
│   │   │   │   ├── 05 1-5 购物车列表和添加商品到购物车接口 （1525）.mp4 (86.32 MB)
│   │   │   │   ├── 14 1-14 更新订单的状态接口 （0649）.mp4 (37.56 MB)
│   │   │   │   ├── 13 1-13 通过mysql本地事务确保订单新建过程的顺利 （2103）.mp4 (116.09 MB)
│   │   │   │   ├── 04 1-4 启动订单服务 （0401）.mp4 (23.44 MB)
│   │   │   │   ├── 11 1-11 调用商品微服务查询商品基本信息 （1225）.mp4 (68.32 MB)
│   │   │   │   ├── 08 1-8 查询订单详情接口 （1608）.mp4 (88.43 MB)
│   │   │   │   ├── 10 1-10 订单微服务连接商品和库存微服务 （0825）.mp4 (46.79 MB)
│   │   │   │   ├── 03 1-3 proto接口定义 （2308）.mp4 (57.96 MB)
│   │   │   │   ├── 12 1-12 调用库存微服务扣减库存 （0453）.mp4 (23.07 MB)
│   │   │   │   ├── 01 1-1 需求分析 （0828）.mp4 (46.75 MB)
│   │   │   │   ├── 02 1-2 订单相关表结构设计 （1835）.mp4 (101.26 MB)
│   │   │   │   ├── 06 1-6 更新购物车、删除购物车记录接口 （0818）.mp4 (32.15 MB)
│   │   │   │   ├── 15 1-15 订单服务接口调试 -1 （1915）.mp4 (68.51 MB)
│   │   │   │   └── 09 1-9 新建订单的流程分析 （1532）.mp4 (48.59 MB)
│   │   │   └── 02 第2章 订单和购物车服务-web层/
│   │   │   │   ├── 03 2-3 添加商品到购物车 （1717）.mp4 (93.25 MB)
│   │   │   │   ├── 07 2-7 新建订单接口开发和测试 （1124）.mp4 (61.68 MB)
│   │   │   │   ├── 05 2-5 订单列表页 （1932）.mp4 (56.70 MB)
│   │   │   │   ├── 04 2-4 更新和删除购物车记录 （2529）.mp4 (136.61 MB)
│   │   │   │   ├── 02 2-2 购物车列表页接口 （1719）.mp4 (41.68 MB)
│   │   │   │   ├── 01 2-1 快速启动订单服务 （2114）.mp4 (115.56 MB)
│   │   │   │   └── 06 2-6 订单详情接口开发和测试 （1225）.mp4 (67.05 MB)
│   ├── 03 阶段三：从0到1实现完整的微服务框架/
│   │   ├── 01 用户服务的grpc服务/
│   │   │   └── 01 第1章 用户服务-service开发/
│   │   │   │   ├── 08 1-8 新建用户 （0732）.mp4 (42.66 MB)
│   │   │   │   ├── 01 1-1 定义用户表结构 （1310）.mp4 (75.47 MB)
│   │   │   │   ├── 02 1-2 同步表结构 （0628）.mp4 (35.49 MB)
│   │   │   │   ├── 13 1-13 课后作业 （0850）.mp4 (50.98 MB)
│   │   │   │   ├── 11 1-11 批量生产用户 （0527）.mp4 (31.18 MB)
│   │   │   │   ├── 09 1-9 修改用户和校验密码接口 （1005）.mp4 (35.74 MB)
│   │   │   │   ├── 03 1-3 md5加密 （1658）.mp4 (31.64 MB)
│   │   │   │   ├── 07 1-7 通过id和mobile查询用户 （0702）.mp4 (38.55 MB)
│   │   │   │   ├── 12 1-12 测试用户微服务接口 （1309）.mp4 (39.66 MB)
│   │   │   │   ├── 06 1-6 用户列表接口 （1935）.mp4 (57.16 MB)
│   │   │   │   ├── 04 1-4 md5盐值加密解决用户密码安全问题 （1830）.mp4 (103.50 MB)
│   │   │   │   ├── 05 1-5 定义proto接口 （1511）.mp4 (87.30 MB)
│   │   │   │   └── 10 1-10 通过flag启动grpc服务 （0835）.mp4 (48.05 MB)
│   │   ├── 02 用户服务的web服务/
│   │   │   ├── 01 第1章 web层开发-基础项目架构/
│   │   │   │   ├── 02 1-2 go高性能日志库 - zap使用 （1429）.mp4 (35.86 MB)
│   │   │   │   ├── 07 1-7 gin调用grpc服务-2 （2237）.mp4 (125.67 MB)
│   │   │   │   ├── 06 1-6 gin调用grpc服务-1 （2047）.mp4 (114.76 MB)
│   │   │   │   ├── 03 1-3 zap的文件输出 （0835）.mp4 (47.30 MB)
│   │   │   │   ├── 10 1-10 viper集成到gin的web服务中 （1506）.mp4 (84.45 MB)
│   │   │   │   ├── 08 1-8 配置文件 - viper （2409）.mp4 (60.42 MB)
│   │   │   │   ├── 04 1-4 集成zap和理由初始到gin的启动过程 - 1 （1343）.mp4 (77.26 MB)
│   │   │   │   ├── 09 1-9 viper的配置环境开发环境和生产环境隔离 （1825）.mp4 (102.31 MB)
│   │   │   │   ├── 05 1-5 集成zap和理由初始到gin的启动过程 - 2 （1414）.mp4 (41.26 MB)
│   │   │   │   └── 01 1-1 新建项目和目录结构构建 （0502）.mp4 (26.55 MB)
│   │   │   └── 02 第2章 web层开发-用户接口开发/
│   │   │   │   ├── 02 2-2 自定义mobile验证器 （1252）.mp4 (70.77 MB)
│   │   │   │   ├── 04 2-4 session机制在微服务下的问题 （0811）.mp4 (20.60 MB)
│   │   │   │   ├── 05 2-5 json web token的认证机制 （0957）.mp4 (56.44 MB)
│   │   │   │   ├── 01 2-1 表单验证的初始化 （2544）.mp4 (94.05 MB)
│   │   │   │   ├── 03 2-3 登录逻辑完善 （1108）.mp4 (61.51 MB)
│   │   │   │   ├── 12 2-12 用户注册接口 （2030）.mp4 (110.70 MB)
│   │   │   │   ├── 07 2-7 给url添加登录权限验证 （1428）.mp4 (50.25 MB)
│   │   │   │   ├── 08 2-8 如何解决前后端的跨域问题 （2129）.mp4 (118.06 MB)
│   │   │   │   ├── 06 2-6 集成jwt到gin中 （1941）.mp4 (108.05 MB)
│   │   │   │   ├── 09 2-9 获取图片验证码 （2238）.mp4 (124.08 MB)
│   │   │   │   ├── 10 2-10 阿里云发送短信 （2106）.mp4 (67.27 MB)
│   │   │   │   └── 11 2-11 redis保存验证码 （1906）.mp4 (105.68 MB)
│   │   └── 03 服务注册发现、配置中心、负载均衡/
│   │   │   ├── 02 第2章 负载均衡/
│   │   │   │   ├── 02 2-2 什么是负载均衡，负载均衡的策略有哪些 （2118）.mp4 (119.39 MB)
│   │   │   │   ├── 03 2-3 常用负载均衡算法 （0822）.mp4 (47.63 MB)
│   │   │   │   ├── 05 2-5 grpc从consul中同步服务信息并进行负载均衡-2 （1524）.mp4 (84.60 MB)
│   │   │   │   ├── 06 2-6 gin集成grpc的负载均衡 （0632）.mp4 (35.53 MB)
│   │   │   │   ├── 04 2-4 gin从consul中同步服务信息并进行负载均衡-1 （1602）.mp4 (48.93 MB)
│   │   │   │   └── 01 2-1 动态获取可用端口 （1458）.mp4 (48.27 MB)
│   │   │   ├── 01 第1章 注册中心-consul/
│   │   │   │   ├── 02 1-2 consul的安装和配置 （1634）.mp4 (91.20 MB)
│   │   │   │   ├── 07 1-7 将grpc服务注册到consul中 （1257）.mp4 (50.00 MB)
│   │   │   │   ├── 05 1-5 为grpc服务添加viper和zap （1749）.mp4 (99.01 MB)
│   │   │   │   ├── 04 1-4 go集成consul （2120）.mp4 (62.80 MB)
│   │   │   │   ├── 06 1-6 grpc服务如何进行健康检查 （0513）.mp4 (29.17 MB)
│   │   │   │   ├── 09 1-9 将用户的grpc连接配置到全局共用 （0917）.mp4 (51.66 MB)
│   │   │   │   ├── 01 1-1 什么是服务注册和发现以及技术选型 （1617）.mp4 (39.94 MB)
│   │   │   │   ├── 03 1-3 服务注册和注销 （1709）.mp4 (100.91 MB)
│   │   │   │   └── 08 1-8 gin集成consul （1719）.mp4 (96.60 MB)
│   │   │   └── 03 第3章 分布式配置中心/
│   │   │   │   ├── 04 3-4 nacos的组、配置集、命名空间 （1514）.mp4 (28.17 MB)
│   │   │   │   ├── 01 3-1 为什么需要配置中心 （1441）.mp4 (40.88 MB)
│   │   │   │   ├── 07 3-7 service集成nacos （0727）.mp4 (34.06 MB)
│   │   │   │   ├── 02 3-2 配置中心选型-apollo vs nacos （0655）.mp4 (38.27 MB)
│   │   │   │   ├── 06 3-6 gin集成nacos （2300）.mp4 (126.26 MB)
│   │   │   │   ├── 05 3-5 通过api获取nacos的配置以及nacos的配置更新 （2008）.mp4 (116.27 MB)
│   │   │   │   └── 03 3-3 nacos的安装 （0514）.mp4 (27.91 MB)
│   ├── 08 阶段八：深入底层库封装、ast代码生成方案/
│   │   ├── 01 log日志包设计/
│   │   │   └── 01 第1章 如何设计日志包/
│   │   │   │   ├── 10 1-10 自定义的logger是如何实现解耦的 （0731）.mp4 (41.81 MB)
│   │   │   │   ├── 07 1-7 生产环境中的日志系统架构 （0936）.mp4 (53.60 MB)
│   │   │   │   ├── 02 1-2 go-zero和kratos中日志的处理 （0933）.mp4 (51.78 MB)
│   │   │   │   ├── 01 1-1 为什么需要自己去设计日志包 （1023）.mp4 (60.46 MB)
│   │   │   │   ├── 03 1-3 全局logger和传递参数的logger的用法 （1010）.mp4 (35.07 MB)
│   │   │   │   ├── 04 1-4 日志包的基本需求 （0851）.mp4 (48.94 MB)
│   │   │   │   ├── 06 1-6 日志打印的实践经验 （0555）.mp4 (11.72 MB)
│   │   │   │   ├── 05 1-5 日志debug、info、error等级别的使用场景 （1605）.mp4 (89.06 MB)
│   │   │   │   ├── 08 1-8 自定义log的options （2032）.mp4 (113.07 MB)
│   │   │   │   ├── 09 1-9 自定义log接口 （1953）.mp4 (55.43 MB)
│   │   │   │   └── 11 1-11 导入已经开发好的log日志包 （0543）.mp4 (31.88 MB)
│   │   └── 02 ast代码生成工具开发/
│   │   │   ├── 02 第2章 通过ast自动生成代码/
│   │   │   │   ├── 02 2-2 go的ast包能做什么 （0933）.mp4 (54.17 MB)
│   │   │   │   ├── 06 2-6 通过codegen自动生成注册源码 （1201）.mp4 (62.43 MB)
│   │   │   │   ├── 03 2-3 ast语法树的基本元素 （1143）.mp4 (20.92 MB)
│   │   │   │   ├── 01 2-1 go的generate自动生成代码 （1549）.mp4 (88.74 MB)
│   │   │   │   ├── 05 2-5 将ast生成的源码写入文件中 （0816）.mp4 (48.09 MB)
│   │   │   │   └── 04 2-4 通过ast包解析变量名和变量的注释 （2303）.mp4 (130.11 MB)
│   │   │   └── 01 第1章 如何设计errors错误包/
│   │   │   │   ├── 05 1-5 通过is和as方法判断error的值 （0758）.mp4 (43.76 MB)
│   │   │   │   ├── 02 1-2 常用的errors、fmt和pkg errors错误处理包 （1115）.mp4 (62.89 MB)
│   │   │   │   ├── 11 1-11 自定义的error放入grpc返回造成的不兼容怎么办 （0923）.mp4 (52.42 MB)
│   │   │   │   ├── 13 1-13 kratos中如何处理errors （0607）.mp4 (18.31 MB)
│   │   │   │   ├── 04 1-4 使用wrapf保存和打印error错误栈 （0843）.mp4 (23.24 MB)
│   │   │   │   ├── 09 1-9 errors实现withcode模式和实现code的注册 （2300）.mp4 (127.30 MB)
│   │   │   │   ├── 06 1-6 http响应应该全部返回200还是返回标准的http code （1146）.mp4 (66.12 MB)
│   │   │   │   ├── 07 1-7 如何设计错误码更加科学 （1709）.mp4 (38.71 MB)
│   │   │   │   ├── 03 1-3 使用errors打印调用栈 （0633）.mp4 (35.56 MB)
│   │   │   │   ├── 08 1-8 如何自定义错误码 （0643）.mp4 (37.19 MB)
│   │   │   │   ├── 12 1-12 增加fromerror解决grpc转换为内部error （1445）.mp4 (80.99 MB)
│   │   │   │   ├── 01 1-1 go的error和其他语言的try catch的区别 （2731）.mp4 (56.87 MB)
│   │   │   │   └── 10 1-10 grpc中的error处理 （1519）.mp4 (70.09 MB)
│   ├── 06 阶段六：开发规范、设计模式、单元测试/
│   │   ├── 02 设计模式和单元测试/
│   │   │   ├── 02 第2章 单元测试/
│   │   │   │   ├── 10 2-10 通过gomonkey进行单元测试 （2047）.mp4 (116.62 MB)
│   │   │   │   ├── 03 2-3 如何写出方便测试的代码 （2212）.mp4 (80.37 MB)
│   │   │   │   ├── 05 2-5 通过sqlmock对gorm进行单元测试 （1743）.mp4 (97.37 MB)
│   │   │   │   ├── 09 2-9 解决模糊测试发现的bug以及testdata目录用途 （1416）.mp4 (44.91 MB)
│   │   │   │   ├── 12 2-12 如何将ginkgo和gomonkey、gomock结合使用 （1255）.mp4 (49.57 MB)
│   │   │   │   ├── 08 2-8 go fuzz模糊测试 （1926）.mp4 (110.48 MB)
│   │   │   │   ├── 02 2-2 简单回顾一下测试用例 （0853）.mp4 (50.72 MB)
│   │   │   │   ├── 04 2-4 通过gomock进行测试用例编码 （2200）.mp4 (122.61 MB)
│   │   │   │   ├── 01 2-1 测试金字塔是什么 （1323）.mp4 (76.49 MB)
│   │   │   │   ├── 07 2-7 如何对grpc、redis和rocketmq等进行测试 （0602）.mp4 (32.56 MB)
│   │   │   │   ├── 11 2-11 ginkgo测试框架快速入门 （1708）.mp4 (94.09 MB)
│   │   │   │   └── 06 2-6 通过ExpectExec和assert判断测试结果 （1449）.mp4 (49.62 MB)
│   │   │   └── 01 第1章 设计模式/
│   │   │   │   ├── 05 1-5 简单工厂模式 （0838）.mp4 (49.67 MB)
│   │   │   │   ├── 03 1-3 如何实现函数选项模式 （1205）.mp4 (66.94 MB)
│   │   │   │   ├── 04 1-4 单例模式和sync.Once原理 （1527）.mp4 (32.58 MB)
│   │   │   │   ├── 01 1-1 为什么需要函数选项模式 （1030）.mp4 (22.83 MB)
│   │   │   │   ├── 02 1-2 kratos和grpc中如何使用函数选项模式的 （0606）.mp4 (34.44 MB)
│   │   │   │   ├── 07 1-7 责任链模式 （0846）.mp4 (24.59 MB)
│   │   │   │   └── 06 1-6 抽象工厂模式 （1026）.mp4 (57.92 MB)
│   │   └── 01 开发规范和go基础扩展/
│   │   │   ├── 01 第1章 开发规范/
│   │   │   │   ├── 12 1-12 golangci-lint进行代码检测 （2015）.mp4 (111.21 MB)
│   │   │   │   ├── 09 1-9 使用mono-repo还是multi-repo管理项目源码 （1453）.mp4 (83.49 MB)
│   │   │   │   ├── 05 1-5 git的代码分支管理 （1213）.mp4 (39.45 MB)
│   │   │   │   ├── 04 1-4 项目开发流程 （1131）.mp4 (65.28 MB)
│   │   │   │   ├── 03 1-3 项目开发有哪些规范需要注意 （1132）.mp4 (64.99 MB)
│   │   │   │   ├── 11 1-11 go vet 进行代码检测 （0749）.mp4 (15.78 MB)
│   │   │   │   ├── 01 1-1 开始后续学习前的说明 （0429）.mp4 (27.79 MB)
│   │   │   │   ├── 02 1-2 课程基本开发工具说明 - 重要！ （0626）.mp4 (9.24 MB)
│   │   │   │   ├── 08 1-8 go的项目目录规范 （1128）.mp4 (39.81 MB)
│   │   │   │   ├── 06 1-6 git的commit规范 （0740）.mp4 (44.01 MB)
│   │   │   │   ├── 07 1-7 go的代码规范简介 （1243）.mp4 (71.53 MB)
│   │   │   │   └── 10 1-10 微服务的项目目录规范 （0820）.mp4 (45.95 MB)
│   │   │   └── 02 第2章 go基础知识扩展/
│   │   │   │   ├── 04 2-4 什么是泛型 （0349）.mp4 (20.97 MB)
│   │   │   │   ├── 05 2-5 go中如何使用泛型 （0841）.mp4 (17.01 MB)
│   │   │   │   ├── 06 2-6 泛型的常见用法 （0900）.mp4 (50.91 MB)
│   │   │   │   ├── 03 2-3 常见错误 - 使用对循环迭代器变量的引用 （0743）.mp4 (44.00 MB)
│   │   │   │   ├── 02 2-2 常见错误 - 结构体空指针 （0403）.mp4 (8.98 MB)
│   │   │   │   ├── 07 2-7 泛型的错误用法 （0932）.mp4 (53.32 MB)
│   │   │   │   └── 01 2-1 map初始化容易犯的错 （0552）.mp4 (33.42 MB)
│   ├── 10 阶段十：基于gmicro重构项目/
│   │   ├── 02 订单、库存等服务重构/
│   │   │   ├── 01 第1章 重构库存服务/
│   │   │   │   ├── 05 1-5 重构reback库存归还接口 （1657）.mp4 (95.56 MB)
│   │   │   │   ├── 04 1-4 库存扣减接口重构 （2416）.mp4 (94.25 MB)
│   │   │   │   ├── 01 1-1 api服务的service层重构 （3007）.mp4 (141.20 MB)
│   │   │   │   ├── 02 1-2 重构库存服务的data层接口实现 （1723）.mp4 (97.43 MB)
│   │   │   │   └── 03 1-3 service层重构get和create方法 （0750）.mp4 (44.08 MB)
│   │   │   └── 02 第2章 dtm分布式事务框架/
│   │   │   │   ├── 05 2-5 转账服务的saga事务调试 （1756）.mp4 (81.21 MB)
│   │   │   │   ├── 04 2-4 dtm快速体验saga分布式事务 （2509）.mp4 (140.32 MB)
│   │   │   │   ├── 06 2-6 grpc服务的事务编排 （2631）.mp4 (147.29 MB)
│   │   │   │   ├── 02 2-2 各种分布式事务的应用场景 （0544）.mp4 (11.57 MB)
│   │   │   │   ├── 07 2-7 基于服务发现完成分布式事务的调度 （1338）.mp4 (76.18 MB)
│   │   │   │   ├── 03 2-3 dtm的安装 （1027）.mp4 (57.97 MB)
│   │   │   │   ├── 01 2-1 saga分布式事务的原理 （2258）.mp4 (127.69 MB)
│   │   │   │   └── 08 2-8 子事务屏障和gin集成测试 （2549）.mp4 (135.50 MB)
│   │   ├── 01 用户、商品服务重构/
│   │   │   ├── 01 第1章 重构用户服务/
│   │   │   │   ├── 04 1-4 重构controller层代码-list和通过id查询用户 （0915）.mp4 (51.29 MB)
│   │   │   │   ├── 10 1-10 启动服务的bug修复 （0311）.mp4 (17.62 MB)
│   │   │   │   ├── 13 1-13 用户服务的data层重构 （2103）.mp4 (117.83 MB)
│   │   │   │   ├── 06 1-6 重构controller层代码-用户更新和密码校验 （1049）.mp4 (46.63 MB)
│   │   │   │   ├── 20 1-20 重构注册接口 （1945）.mp4 (110.51 MB)
│   │   │   │   ├── 16 1-16 封装底层的rpc链接 （1628）.mp4 (92.45 MB)
│   │   │   │   ├── 17 1-17 封装rpc服务的client端tracing拦截器 （1223）.mp4 (67.84 MB)
│   │   │   │   ├── 14 1-14 重构login的service等代码 （1532）.mp4 (87.01 MB)
│   │   │   │   ├── 02 1-2 userstore接口的实现 （2305）.mp4 (127.70 MB)
│   │   │   │   ├── 21 1-21 登录校验 （2056）.mp4 (81.09 MB)
│   │   │   │   ├── 01 1-1 data层接口设计 （1139）.mp4 (64.78 MB)
│   │   │   │   ├── 11 1-11 用户服务的api层服务初始化 （1008）.mp4 (55.63 MB)
│   │   │   │   ├── 05 1-5 重构controller层代码-通过mobile查询用户 （1245）.mp4 (71.36 MB)
│   │   │   │   ├── 09 1-9 mysql配置文件映射启动 （1045）.mp4 (52.26 MB)
│   │   │   │   ├── 23 1-23 更新用户信息接口重构 （0535）.mp4 (31.60 MB)
│   │   │   │   ├── 22 1-22 调试token解析 （1522）.mp4 (84.62 MB)
│   │   │   │   ├── 15 1-15 完成login的controller层重构 （2009）.mp4 (103.29 MB)
│   │   │   │   ├── 12 1-12 重构login接口 （1445）.mp4 (49.49 MB)
│   │   │   │   ├── 07 1-7 底层数据库的链接封装 （1606）.mp4 (88.99 MB)
│   │   │   │   ├── 18 1-18 重构短信发送逻辑 （1720）.mp4 (63.13 MB)
│   │   │   │   ├── 19 1-19 基于redis的封装 （2447）.mp4 (136.66 MB)
│   │   │   │   ├── 08 1-8 mysql的配置和映射启动服务 （1612）.mp4 (91.06 MB)
│   │   │   │   └── 03 1-3 重构service层接口实现 （0645）.mp4 (26.18 MB)
│   │   │   └── 02 第2章 重构商品服务/
│   │   │   │   ├── 10 2-10 通过map-reduce完成并发调用控制 （1641）.mp4 (64.11 MB)
│   │   │   │   ├── 17 2-17 商品服务的api接口重构-1 （2236）.mp4 (124.45 MB)
│   │   │   │   ├── 16 2-16 gorm打印日志的集成 （0851）.mp4 (41.45 MB)
│   │   │   │   ├── 06 2-6 重构商品服务的es查询接口 （1058）.mp4 (62.39 MB)
│   │   │   │   ├── 05 2-5 重构商品服务的es接口 （1633）.mp4 (91.24 MB)
│   │   │   │   ├── 04 2-4 商品列表页重构需求分析 （1057）.mp4 (44.05 MB)
│   │   │   │   ├── 13 2-13 启动商品服务 （0923）.mp4 (48.02 MB)
│   │   │   │   ├── 12 2-12 通过工厂模式改造service和data层 （3012）.mp4 (166.99 MB)
│   │   │   │   ├── 09 2-9 通过canal消费mysql的binlog完成数据最终一致性的方案 （1022）.mp4 (57.89 MB)
│   │   │   │   ├── 07 2-7 重构service层商品列表页接口 （1443）.mp4 (63.54 MB)
│   │   │   │   ├── 01 2-1 定义商品服务的DO模型 （1851）.mp4 (78.81 MB)
│   │   │   │   ├── 02 2-2 重构商品相关的接口 （1217）.mp4 (67.93 MB)
│   │   │   │   ├── 08 2-8 基于事务完成商品的创建 （2218）.mp4 (123.19 MB)
│   │   │   │   ├── 11 2-11 启动goods的service服务 （2903）.mp4 (161.85 MB)
│   │   │   │   ├── 14 2-14 完成controller层的商品列表接口 （0545）.mp4 (32.48 MB)
│   │   │   │   ├── 18 2-18 商品服务的api接口重构-2 （1418）.mp4 (78.97 MB)
│   │   │   │   ├── 15 2-15 调试商品列表页接口 （1602）.mp4 (90.03 MB)
│   │   │   │   └── 03 2-3 重构商品服务其他接口的data接口 （1123）.mp4 (63.40 MB)
│   │   └── 03 订单服务重构、wire进行ioc控制/
│   │   │   ├── 01 第1章 订单系统重构/
│   │   │   │   ├── 01 1-1 订单系统data层数据接口定义 （1543）.mp4 (85.62 MB)
│   │   │   │   ├── 03 1-3 完成datafactory的重构 （1509）.mp4 (73.12 MB)
│   │   │   │   ├── 10 1-10 调试新建订单接口(下) （2033）.mp4 (113.12 MB)
│   │   │   │   ├── 06 1-6 新建订单和补偿接口实现 （1753）.mp4 (73.96 MB)
│   │   │   │   ├── 02 1-2 实现order和购物车的接口重构 （2906）.mp4 (162.06 MB)
│   │   │   │   ├── 08 1-8 启动订单服务重构 （1732）.mp4 (96.50 MB)
│   │   │   │   ├── 07 1-7 重构controller层的submitorder接口 （2628）.mp4 (146.76 MB)
│   │   │   │   ├── 05 1-5 通过saga事务重构分布式事务 （2306）.mp4 (129.42 MB)
│   │   │   │   ├── 09 1-9 调试新建订单接口(上) （2250）.mp4 (124.93 MB)
│   │   │   │   └── 04 1-4 订单服务的service层重构 （1045）.mp4 (59.91 MB)
│   │   │   └── 02 第2章 依赖注入和ioc思想/
│   │   │   │   ├── 05 2-5 通过wire重构user的service服务(下) （1853）.mp4 (78.12 MB)
│   │   │   │   ├── 08 2-8 集成sentinel和nacos （2349）.mp4 (104.28 MB)
│   │   │   │   ├── 04 2-4 通过wire重构user的service服务(上) （2236）.mp4 (126.37 MB)
│   │   │   │   ├── 06 2-6 通过providerset简化初始化 （0833）.mp4 (47.70 MB)
│   │   │   │   ├── 09 2-9 调试sentinel集成nacos （1323）.mp4 (72.44 MB)
│   │   │   │   ├── 02 2-2 ioc框架选型 （1109）.mp4 (19.91 MB)
│   │   │   │   ├── 03 2-3 wire快速入门 （1325）.mp4 (76.69 MB)
│   │   │   │   ├── 01 2-1 什么是ioc （3003）.mp4 (168.55 MB)
│   │   │   │   └── 07 2-7 sentinel集成nacos （3103）.mp4 (172.32 MB)
│   └── 00 源码/
│   │   └── mxshop.zip (34.37 MB)
链接

https://pan.quark.cn/s/ec8641e21bc1