徐昊·TDD 项目实战 70 讲，网盘下载(5.46G)

01-开篇词[145.00M]

开篇词丨为什么TDD是当前最具工程效能的研发流程？[131.84M]

开篇词｜为什么TDD是当前最具工程效能的研发流程？(1)【】.ts[14.57M]

开篇词｜为什么TDD是当前最具工程效能的研发流程？(2)【】.ts[15.25M]

开篇词｜为什么TDD是当前最具工程效能的研发流程？(3)【】.ts[19.93M]

开篇词｜为什么TDD是当前最具工程效能的研发流程？(4)【】.ts[27.42M]

开篇词｜为什么TDD是当前最具工程效能的研发流程？(5)【】.ts[19.19M]

开篇词｜为什么TDD是当前最具工程效能的研发流程？(6)【】.ts[5.79M]

开篇词丨为什么TDD是当前最具工程效能的研发流程？【】.html[11.36M]

开篇词丨为什么TDD是当前最具工程效能的研发流程？【】.m4a[8.73M]

开篇词丨为什么TDD是当前最具工程效能的研发流程？【】.pdf[9.61M]

课前必读丨20年前的“老古董”技术，为什么还值得开个课？[13.16M]

课前必读丨20年前的“老古董”技术，为什么还值得开个课？【】.html[2.55M]

课前必读丨20年前的“老古董”技术，为什么还值得开个课？【】.m4a[7.15M]

课前必读丨20年前的“老古董”技术，为什么还值得开个课？【】.pdf[3.46M]

02-实战项目一：命令行参数解析[866.27M]

01丨TDD演示（1）：任务分解法与整体工作流程[101.42M]

01｜TDD演示（1）：任务分解法与整体工作流程(1)【】.ts[7.73M]

01｜TDD演示（1）：任务分解法与整体工作流程(2)【】.ts[13.65M]

01｜TDD演示（1）：任务分解法与整体工作流程(3)【】.ts[14.29M]

01｜TDD演示（1）：任务分解法与整体工作流程(4)【】.ts[5.06M]

01｜TDD演示（1）：任务分解法与整体工作流程(5)【】.ts[19.38M]

01｜TDD演示（1）：任务分解法与整体工作流程(6)【】.ts[12.62M]

01丨TDD演示（1）：任务分解法与整体工作流程【】.html[12.45M]

01丨TDD演示（1）：任务分解法与整体工作流程【】.m4a[4.60M]

01丨TDD演示（1）：任务分解法与整体工作流程【】.pdf[11.66M]

02丨TDD演示（2）：识别坏味道与代码重构[74.58M]

02｜TDD演示（2）：识别坏味道与代码重构(10)【】.ts[27.12M]

02｜TDD演示（2）：识别坏味道与代码重构(8)【】.mp4[17.21M]

02｜TDD演示（2）：识别坏味道与代码重构(8)【】.ts[14.58M]

02丨TDD演示（2）：识别坏味道与代码重构【】.html[6.31M]

02丨TDD演示（2）：识别坏味道与代码重构【】.m4a[3.80M]

02丨TDD演示（2）：识别坏味道与代码重构【】.pdf[5.56M]

03丨TDD演示（3）：按测试策略重组测试[103.93M]

03｜TDD演示（3）：按测试策略重组测试(1)【】.ts[16.02M]

03｜TDD演示（3）：按测试策略重组测试(2)【】.ts[13.86M]

03｜TDD演示（3）：按测试策略重组测试(3)【】.ts[21.26M]

03｜TDD演示（3）：按测试策略重组测试(4)【】.ts[31.32M]

03丨TDD演示（3）：按测试策略重组测试【】.html[10.09M]

03丨TDD演示（3）：按测试策略重组测试【】.m4a[4.74M]

03丨TDD演示（3）：按测试策略重组测试【】.pdf[6.64M]

04丨TDD演示（4）：实现对于列表参数的支持[136.49M]

04｜TDD演示（4）：实现对于列表参数的支持(1)【】.ts[16.74M]

04｜TDD演示（4）：实现对于列表参数的支持(2)【】.ts[20.44M]

04｜TDD演示（4）：实现对于列表参数的支持(3)【】.ts[25.01M]

04｜TDD演示（4）：实现对于列表参数的支持(4)【】.ts[26.11M]

04｜TDD演示（4）：实现对于列表参数的支持(5)【】.ts[25.99M]

04丨TDD演示（4）：实现对于列表参数的支持【】.html[8.94M]

04丨TDD演示（4）：实现对于列表参数的支持【】.m4a[5.21M]

04丨TDD演示（4）：实现对于列表参数的支持【】.pdf[8.06M]

05丨TDD中的测试（1）：状态验证为什么是主要的使用方式？[77.15M]

05｜TDD中的测试（1）：状态验证为什么是主要的使用方式？(1)【】.ts[9.30M]

05｜TDD中的测试（1）：状态验证为什么是主要的使用方式？(2)【】.ts[13.22M]

05｜TDD中的测试（1）：状态验证为什么是主要的使用方式？(3)【】.ts[7.78M]

05｜TDD中的测试（1）：状态验证为什么是主要的使用方式？(4)【】.ts[25.78M]

05丨TDD中的测试（1）：状态验证为什么是主要的使用方式？【】.html[9.75M]

05丨TDD中的测试（1）：状态验证为什么是主要的使用方式？【】.m4a[5.66M]

05丨TDD中的测试（1）：状态验证为什么是主要的使用方式？【】.pdf[5.66M]

06丨TDD中的测试（2）：行为验证为什么应该尽量避免使用？[79.08M]

06｜TDD中的测试（2）：行为验证为什么应该尽量避免使用？(1)【】.ts[11.14M]

06｜TDD中的测试（2）：行为验证为什么应该尽量避免使用？(2)【】.ts[17.77M]

06｜TDD中的测试（2）：行为验证为什么应该尽量避免使用？(3)【】.ts[13.76M]

06｜TDD中的测试（2）：行为验证为什么应该尽量避免使用？(4)【】.ts[9.31M]

06｜TDD中的测试（2）：行为验证为什么应该尽量避免使用？(5)【】.ts[9.05M]

06丨TDD中的测试（2）：行为验证为什么应该尽量避免使用？【】.html[1.67M]

06丨TDD中的测试（2）：行为验证为什么应该尽量避免使用？【】.m4a[6.96M]

06丨TDD中的测试（2）：行为验证为什么应该尽量避免使用？【】.pdf[9.41M]

07丨TDD中的测试（3）：集成测试还是单元测试？[52.40M]

07丨TDD中的测试（3）：集成测试还是单元测试？【】.html[2.58M]

07丨TDD中的测试（3）：集成测试还是单元测试？【】.m4a[6.08M]

07丨TDD中的测试（3）：集成测试还是单元测试？【】.mp4[39.94M]

07丨TDD中的测试（3）：集成测试还是单元测试？【】.pdf[3.80M]

08丨TDD中的驱动（1）：驱动的极限是什么？[77.67M]

08｜TDD中的驱动（1）：驱动的极限是什么？(1)【】.ts[10.10M]

08｜TDD中的驱动（1）：驱动的极限是什么？(2)【】.ts[17.27M]

08｜TDD中的驱动（1）：驱动的极限是什么？(3)【】.ts[22.49M]

08｜TDD中的驱动（1）：驱动的极限是什么？(4)【】.ts[15.94M]

08丨TDD中的驱动（1）：驱动的极限是什么？【】.html[4.01M]

08丨TDD中的驱动（1）：驱动的极限是什么？【】.m4a[5.27M]

08丨TDD中的驱动（1）：驱动的极限是什么？【】.pdf[2.60M]

09丨TDD中的驱动（2）：重构发挥了什么作用？[80.51M]

09｜TDD中的驱动（2）：重构发挥了什么作用？(1)【】.ts[10.40M]

09｜TDD中的驱动（2）：重构发挥了什么作用？(2)【】.ts[14.58M]

09｜TDD中的驱动（2）：重构发挥了什么作用？(3)【】.ts[12.46M]

09｜TDD中的驱动（2）：重构发挥了什么作用？(4)【】.ts[15.45M]

09｜TDD中的驱动（2）：重构发挥了什么作用？(5)【】.ts[12.75M]

09丨TDD中的驱动（2）：重构发挥了什么作用？【】.html[5.58M]

09丨TDD中的驱动（2）：重构发挥了什么作用？【】.m4a[4.48M]

09丨TDD中的驱动（2）：重构发挥了什么作用？【】.pdf[4.82M]

10丨TDD中的驱动（3）：何为经典学派？何为伦敦学派？[62.82M]

10｜TDD中的驱动（3）：何为经典学派？何为伦敦学派？(1)【】.ts[32.49M]

10｜TDD中的驱动（3）：何为经典学派？何为伦敦学派？(2)【】.ts[9.26M]

10｜TDD中的驱动（3）：何为经典学派？何为伦敦学派？(3)【】.ts[14.06M]

10丨TDD中的驱动（3）：何为经典学派？何为伦敦学派？【】.html[1.78M]

10丨TDD中的驱动（3）：何为经典学派？何为伦敦学派？【】.m4a[3.98M]

10丨TDD中的驱动（3）：何为经典学派？何为伦敦学派？【】.pdf[1.24M]

11丨作为工程化方法的TDD：更低的成本与更高的效能[20.22M]

11丨作为工程化方法的TDD：更低的成本与更高的效能【】.html[7.29M]

11丨作为工程化方法的TDD：更低的成本与更高的效能【】.m4a[6.54M]

11丨作为工程化方法的TDD：更低的成本与更高的效能【】.pdf[6.40M]

03-TDD首发·代码评点[92.78M]

代码评点01｜不同语言TDD的节奏有何不同？(1)【】.ts[8.89M]

代码评点01｜不同语言TDD的节奏有何不同？(2)【】.ts[13.16M]

代码评点01｜不同语言TDD的节奏有何不同？(3)【】.ts[17.42M]

代码评点01丨不同语言TDD的节奏有何不同？【】.html[2.70M]

代码评点01丨不同语言TDD的节奏有何不同？【】.m4a[917.88K]

代码评点01丨不同语言TDD的节奏有何不同？【】.pdf[3.41M]

代码评点02｜什么是合适TDD的语言和IDE？(1)【】.ts[26.03M]

代码评点02｜什么是合适TDD的语言和IDE？(2)【】.ts[15.97M]

代码评点02丨什么是合适TDD的语言和IDE？【】.html[1.37M]

代码评点02丨什么是合适TDD的语言和IDE？【】.m4a[1.03M]

代码评点02丨什么是合适TDD的语言和IDE？【】.pdf[1.90M]

04-实战项目二丨RESTful开发框架：依赖注入容器[2.13G]

12丨实战中的TDD：RESTfulAPI的开发框架[77.59M]

12丨实战中的TDD：RESTfulAPI的开发框架(2)【】.mp4[58.42M]

12丨实战中的TDD：RESTfulAPI的开发框架【】.html[2.23M]

12丨实战中的TDD：RESTfulAPI的开发框架【】.m4a[2.05M]

12丨实战中的TDD：RESTfulAPI的开发框架【】.mp4[12.53M]

12丨实战中的TDD：RESTfulAPI的开发框架【】.pdf[2.35M]

13丨DIContainer（1）：如何实现基本的DI容器结构？[55.35M]

13丨DIContainer（1）：如何实现基本的DI容器结构？【】.html[3.63M]

13丨DIContainer（1）：如何实现基本的DI容器结构？【】.m4a[1.64M]

13丨DIContainer（1）：如何实现基本的DI容器结构？【】.mp4[46.50M]

13丨DIContainer（1）：如何实现基本的DI容器结构？【】.pdf[3.58M]

14丨DIContainer（2）：如何通过SadPath为容器增加功能？[83.82M]

14丨DIContainer（2）：如何通过SadPath为容器增加功能？(2)【】.mp4[43.18M]

14丨DIContainer（2）：如何通过SadPath为容器增加功能？【】.html[4.57M]

14丨DIContainer（2）：如何通过SadPath为容器增加功能？【】.m4a[888.16K]

14丨DIContainer（2）：如何通过SadPath为容器增加功能？【】.mp4[30.20M]

14丨DIContainer（2）：如何通过SadPath为容器增加功能？【】.pdf[5.00M]

15丨DIContainer（3）：如何重构已有的代码？[76.89M]

15｜DIContainer（3）：如何重构已有的代码？(1)【】.ts[10.35M]

15｜DIContainer（3）：如何重构已有的代码？(2)【】.ts[39.03M]

15｜DIContainer（3）：如何重构已有的代码？(3)【】.ts[17.55M]

15丨DIContainer（3）：如何重构已有的代码？【】.html[3.65M]

15丨DIContainer（3）：如何重构已有的代码？【】.m4a[993.17K]

15丨DIContainer（3）：如何重构已有的代码？【】.pdf[5.34M]

16丨DIContainer（4）：如何实现对循环依赖的处理？[96.97M]

16丨DIContainer（4）：如何实现对循环依赖的处理？【】.html[4.18M]

16丨DIContainer（4）：如何实现对循环依赖的处理？【】.m4a[1.45M]

16丨DIContainer（4）：如何实现对循环依赖的处理？【】.mp4[88.78M]

16丨DIContainer（4）：如何实现对循环依赖的处理？【】.pdf[2.56M]

17丨DIContainer（5）：API接口该怎么设计？[70.29M]

17丨DIContainer（5）：API接口该怎么设计？【】.html[3.35M]

17丨DIContainer（5）：API接口该怎么设计？【】.m4a[1.22M]

17丨DIContainer（5）：API接口该怎么设计？【】.mp4[64.15M]

17丨DIContainer（5）：API接口该怎么设计？【】.pdf[1.57M]

18丨DIContainer（6）：如何实现循环依赖的检查？[73.87M]

18丨DIContainer（6）：如何实现循环依赖的检查？【】.html[3.72M]

18丨DIContainer（6）：如何实现循环依赖的检查？【】.m4a[1.48M]

18丨DIContainer（6）：如何实现循环依赖的检查？【】.mp4[63.55M]

18丨DIContainer（6）：如何实现循环依赖的检查？【】.pdf[5.12M]

19丨DIContainer（7）：如何实现FieldInjection部分的功能？[81.54M]

19丨DIContainer（7）：如何实现FieldInjection部分的功能？【】.html[2.39M]

19丨DIContainer（7）：如何实现FieldInjection部分的功能？【】.m4a[1.02M]

19丨DIContainer（7）：如何实现FieldInjection部分的功能？【】.mp4[75.61M]

19丨DIContainer（7）：如何实现FieldInjection部分的功能？【】.pdf[2.52M]

20丨DIContainer（8）：如何实现MethodInjection部分的功能？[91.15M]

20丨DIContainer（8）：如何实现MethodInjection部分的功能？【】.html[2.23M]

20丨DIContainer（8）：如何实现MethodInjection部分的功能？【】.m4a[650.07K]

20丨DIContainer（8）：如何实现MethodInjection部分的功能？【】.mp4[85.71M]

20丨DIContainer（8）：如何实现MethodInjection部分的功能？【】.pdf[2.57M]

21丨DIContainer（9）：怎样重构测试代码？[115.01M]

21丨DIContainer（9）：怎样重构测试代码？【】.html[2.50M]

21丨DIContainer（9）：怎样重构测试代码？【】.m4a[1.14M]

21丨DIContainer（9）：怎样重构测试代码？【】.mp4[108.64M]

21丨DIContainer（9）：怎样重构测试代码？【】.pdf[2.73M]

22丨DIContainer（10）：怎样将大粒度的测试重构为等效的小粒度测试代码？[96.87M]

22丨DIContainer（10）：怎样将大粒度的测试重构为等效的小粒度测试代码？【】.html[1.70M]

22丨DIContainer（10）：怎样将大粒度的测试重构为等效的小粒度测试代码？【】.m4a[1.00M]

22丨DIContainer（10）：怎样将大粒度的测试重构为等效的小粒度测试代码？【】.mp4[92.54M]

22丨DIContainer（10）：怎样将大粒度的测试重构为等效的小粒度测试代码？【】.pdf[1.62M]

23丨DIContainer（11）：如何对ContainerTest进行文档化改造？[118.83M]

23丨DIContainer（11）：如何对ContainerTest进行文档化改造？【】.html[1.79M]

23丨DIContainer（11）：如何对ContainerTest进行文档化改造？【】.m4a[878.34K]

23丨DIContainer（11）：如何对ContainerTest进行文档化改造？【】.mp4[114.14M]

23丨DIContainer（11）：如何对ContainerTest进行文档化改造？【】.pdf[2.04M]

24丨DIContainer（12）：如何增补功能？[92.80M]

24丨DIContainer（12）：如何增补功能？【】.html[1.78M]

24丨DIContainer（12）：如何增补功能？【】.m4a[1.10M]

24丨DIContainer（12）：如何增补功能？【】.mp4[88.13M]

24丨DIContainer（12）：如何增补功能？【】.pdf[1.78M]

25丨DIContainer（13）：任务上的遗漏该怎么处理？[92.94M]

25丨DIContainer（13）：任务上的遗漏该怎么处理？【】.html[2.03M]

25丨DIContainer（13）：任务上的遗漏该怎么处理？【】.m4a[741.40K]

25丨DIContainer（13）：任务上的遗漏该怎么处理？【】.mp4[88.48M]

25丨DIContainer（13）：任务上的遗漏该怎么处理？【】.pdf[1.71M]

26丨DIContainer（14）：如何重构对Type类型判断的逻辑？[85.09M]

26丨DIContainer（14）：如何重构对Type类型判断的逻辑？【】.html[2.58M]

26丨DIContainer（14）：如何重构对Type类型判断的逻辑？【】.m4a[1.04M]

26丨DIContainer（14）：如何重构对Type类型判断的逻辑？【】.mp4[78.32M]

26丨DIContainer（14）：如何重构对Type类型判断的逻辑？【】.pdf[3.16M]

27丨DIContainer（15）：如何封装类型判断逻辑？[125.86M]

27丨DIContainer（15）：如何封装类型判断逻辑？【】.html[2.38M]

27丨DIContainer（15）：如何封装类型判断逻辑？【】.m4a[879.16K]

27丨DIContainer（15）：如何封装类型判断逻辑？【】.mp4[120.11M]

27丨DIContainer（15）：如何封装类型判断逻辑？【】.pdf[2.50M]

28丨DIContainer（16）：行为封装会对测试产生什么影响？[75.22M]

28丨DIContainer（16）：行为封装会对测试产生什么影响？【】.html[2.75M]

28丨DIContainer（16）：行为封装会对测试产生什么影响？【】.m4a[757.24K]

28丨DIContainer（16）：行为封装会对测试产生什么影响？【】.mp4[69.26M]

28丨DIContainer（16）：行为封装会对测试产生什么影响？【】.pdf[2.47M]

29丨DIContainer（17）：如何重构ContextConfig内部的实现？[111.00M]

29丨DIContainer（17）：如何重构ContextConfig内部的实现？【】.html[2.54M]

29丨DIContainer（17）：如何重构ContextConfig内部的实现？【】.m4a[1.02M]

29丨DIContainer（17）：如何重构ContextConfig内部的实现？【】.mp4[105.28M]

29丨DIContainer（17）：如何重构ContextConfig内部的实现？【】.PDF[2.16M]

30丨DIContainer（18）：如何增补依赖缺失和循环依赖的测试？[99.39M]

30丨DIContainer（18）：如何增补依赖缺失和循环依赖的测试？【】.html[2.46M]

30丨DIContainer（18）：如何增补依赖缺失和循环依赖的测试？【】.m4a[1.26M]

30丨DIContainer（18）：如何增补依赖缺失和循环依赖的测试？【】.mp4[93.30M]

30丨DIContainer（18）：如何增补依赖缺失和循环依赖的测试？【】.PDF[2.37M]

31丨DIContainer（19）：Qualifier部分的功能要如何完成？[97.40M]

31丨DIContainer（19）：Qualifier部分的功能要如何完成？【】.html[2.56M]

31丨DIContainer（19）：Qualifier部分的功能要如何完成？【】.m4a[0.99M]

31丨DIContainer（19）：Qualifier部分的功能要如何完成？【】.mp4[90.87M]

31丨DIContainer（19）：Qualifier部分的功能要如何完成？【】.PDF[2.97M]

32丨DIContainer（20）：如何对代码和测试进行重构？[112.50M]

32丨DIContainer（20）：如何对代码和测试进行重构？【】.html[2.44M]

32丨DIContainer（20）：如何对代码和测试进行重构？【】.m4a[1.61M]

32丨DIContainer（20）：如何对代码和测试进行重构？【】.mp4[105.77M]

32丨DIContainer（20）：如何对代码和测试进行重构？【】.PDF[2.68M]

33丨DIContainer（21）：如何处理Singleton生命周期部分的功能？[127.58M]

33丨DIContainer（21）：如何处理Singleton生命周期部分的功能？【】.html[1.93M]

33丨DIContainer（21）：如何处理Singleton生命周期部分的功能？【】.m4a[1.04M]

33丨DIContainer（21）：如何处理Singleton生命周期部分的功能？【】.mp4[121.73M]

33丨DIContainer（21）：如何处理Singleton生命周期部分的功能？【】.PDF[2.88M]

34丨DIContainer（22）：如何对Bind的逻辑进行重构？[89.74M]

34丨DIContainer（22）：如何对Bind的逻辑进行重构？【】.html[1.72M]

34丨DIContainer（22）：如何对Bind的逻辑进行重构？【】.m4a[991.07K]

34丨DIContainer（22）：如何对Bind的逻辑进行重构？【】.mp4[84.45M]

34丨DIContainer（22）：如何对Bind的逻辑进行重构？【】.PDF[2.60M]

35丨DIContainer（23）：项目回顾与总结[35.84M]

35丨DIContainer（23）：项目回顾与总结【】.html[4.07M]

35丨DIContainer（23）：项目回顾与总结【】.m4a[3.39M]

35丨DIContainer（23）：项目回顾与总结【】.mp4[23.84M]

35丨DIContainer（23）：项目回顾与总结【】.pdf[4.54M]

05-实战项目三｜RESTfulWebServices[2.25G]

36丨实战中的TDD：RESTfulWebServices[70.14M]

36丨实战中的TDD：RESTfulWebServices(2)【】.mp4[50.15M]

36丨实战中的TDD：RESTfulWebServices【】.html[1.59M]

36丨实战中的TDD：RESTfulWebServices【】.m4a[1.30M]

36丨实战中的TDD：RESTfulWebServices【】.mp4[15.69M]

36丨实战中的TDD：RESTfulWebServices【】.pdf[1.41M]

37丨RESTfulWebServices（1）：明确架构愿景与架构组件间的交互[95.73M]

37丨RESTfulWebServices（1）：明确架构愿景与架构组件间的交互【】.html[3.10M]

37丨RESTfulWebServices（1）：明确架构愿景与架构组件间的交互【】.m4a[4.16M]

37丨RESTfulWebServices（1）：明确架构愿景与架构组件间的交互【】.mp4[84.88M]

37丨RESTfulWebServices（1）：明确架构愿景与架构组件间的交互【】.pdf[3.60M]

38丨RESTfulWebServices（2）：根据Spike的结果，要如何调整架构愿景？[87.79M]

38丨RESTfulWebServices（2）：根据Spike的结果，要如何调整架构愿景？【】.html[1.89M]

38丨RESTfulWebServices（2）：根据Spike的结果，要如何调整架构愿景？【】.m4a[1.16M]

38丨RESTfulWebServices（2）：根据Spike的结果，要如何调整架构愿景？【】.mp4[83.04M]

38丨RESTfulWebServices（2）：根据Spike的结果，要如何调整架构愿景？【】.pdf[1.70M]

39丨RESTfulWebServices（3）：明确架构愿景与调用栈顺序[101.68M]

39丨RESTfulWebServices（3）：明确架构愿景与调用栈顺序(1)【】.mp4[24.77M]

39丨RESTfulWebServices（3）：明确架构愿景与调用栈顺序【】.html[3.16M]

39丨RESTfulWebServices（3）：明确架构愿景与调用栈顺序【】.m4a[1.22M]

39丨RESTfulWebServices（3）：明确架构愿景与调用栈顺序【】.mp4[70.01M]

39丨RESTfulWebServices（3）：明确架构愿景与调用栈顺序【】.pdf[2.52M]

40丨RESTfulWebServices（4）：在当前架构愿景下，要如何分解任务？[68.71M]

40丨RESTfulWebServices（4）：在当前架构愿景下，要如何分解任务？【】.html[4.60M]

40丨RESTfulWebServices（4）：在当前架构愿景下，要如何分解任务？【】.m4a[3.34M]

40丨RESTfulWebServices（4）：在当前架构愿景下，要如何分解任务？【】.mp4[56.59M]

40丨RESTfulWebServices（4）：在当前架构愿景下，要如何分解任务？【】.pdf[4.18M]

41丨RESTfulWebServices（5）：如何通过对数据测试的管理来凸显意图？[94.05M]

41丨RESTfulWebServices（5）：如何通过对数据测试的管理来凸显意图？【】.html[3.62M]

41丨RESTfulWebServices（5）：如何通过对数据测试的管理来凸显意图？【】.m4a[1.17M]

41丨RESTfulWebServices（5）：如何通过对数据测试的管理来凸显意图？【】.mp4[86.02M]

41丨RESTfulWebServices（5）：如何通过对数据测试的管理来凸显意图？【】.pdf[3.25M]

42丨RESTfulWebServices（6）：如何处理JAX-RS定义的异常类？[81.43M]

42丨RESTfulWebServices（6）：如何处理JAX-RS定义的异常类？【】.html[3.47M]

42丨RESTfulWebServices（6）：如何处理JAX-RS定义的异常类？【】.m4a[918.83K]

42丨RESTfulWebServices（6）：如何处理JAX-RS定义的异常类？【】.mp4[74.07M]

42丨RESTfulWebServices（6）：如何处理JAX-RS定义的异常类？【】.pdf[3.00M]

43丨RESTfulWebServices（7）：剩下两个SadPath场景该如何处理？[64.92M]

43丨RESTfulWebServices（7）：剩下两个SadPath场景该如何处理？【】.html[3.48M]

43丨RESTfulWebServices（7）：剩下两个SadPath场景该如何处理？【】.m4a[755.47K]

43丨RESTfulWebServices（7）：剩下两个SadPath场景该如何处理？【】.mp4[57.64M]

43丨RESTfulWebServices（7）：剩下两个SadPath场景该如何处理？【】.pdf[3.05M]

44丨RESTfulWebServices（8）：如何在现有代码的基础上构造测试？[95.66M]

44丨RESTfulWebServices（8）：如何在现有代码的基础上构造测试？【】.html[3.56M]

44丨RESTfulWebServices（8）：如何在现有代码的基础上构造测试？【】.m4a[1.10M]

44丨RESTfulWebServices（8）：如何在现有代码的基础上构造测试？【】.mp4[88.20M]

44丨RESTfulWebServices（8）：如何在现有代码的基础上构造测试？【】.pdf[2.80M]

45丨RESTfulWebServices（9）：通过伦敦学派得到的测试风格是什么样的？[56.77M]

45丨RESTfulWebServices（9）：通过伦敦学派得到的测试风格是什么样的？【】.html[3.87M]

45丨RESTfulWebServices（9）：通过伦敦学派得到的测试风格是什么样的？【】.m4a[1.09M]

45丨RESTfulWebServices（9）：通过伦敦学派得到的测试风格是什么样的？【】.mp4[48.91M]

45丨RESTfulWebServices（9）：通过伦敦学派得到的测试风格是什么样的？【】.pdf[2.90M]

46丨RESTfulWebServices（10）：伦敦学派与经典学派的测试节奏有何不同？[10.28M]

46丨RESTfulWebServices（10）：伦敦学派与经典学派的测试节奏有何不同？【】.html[3.46M]

46丨RESTfulWebServices（10）：伦敦学派与经典学派的测试节奏有何不同？【】.m4a[3.17M]

46丨RESTfulWebServices（10）：伦敦学派与经典学派的测试节奏有何不同？【】.pdf[3.65M]

47丨RESTfulWebServices（11）：如何通过Spike来验证架构愿景？[63.83M]

47丨RESTfulWebServices（11）：如何通过Spike来验证架构愿景？【】.html[1.82M]

47丨RESTfulWebServices（11）：如何通过Spike来验证架构愿景？【】.m4a[1.19M]

47丨RESTfulWebServices（11）：如何通过Spike来验证架构愿景？【】.mp4[59.83M]

47丨RESTfulWebServices（11）：如何通过Spike来验证架构愿景？【】.pdf[1.00M]

48丨RESTfulWebServices（12）：如何调整接口和架构愿景？[65.17M]

48丨RESTfulWebServices（12）：如何调整接口和架构愿景？【】.html[1.87M]

48丨RESTfulWebServices（12）：如何调整接口和架构愿景？【】.m4a[1.09M]

48丨RESTfulWebServices（12）：如何调整接口和架构愿景？【】.mp4[60.89M]

48丨RESTfulWebServices（12）：如何调整接口和架构愿景？【】.pdf[1.33M]

49丨RESTfulWebService（13）：如何SpikeSub-ResourceLocator？[62.79M]

49丨RESTfulWebService（13）：如何SpikeSub-ResourceLocator？【】.html[2.06M]

49丨RESTfulWebService（13）：如何SpikeSub-ResourceLocator？【】.m4a[1.40M]

49丨RESTfulWebService（13）：如何SpikeSub-ResourceLocator？【】.mp4[58.11M]

49丨RESTfulWebService（13）：如何SpikeSub-ResourceLocator？【】.pdf[1.21M]

50｜RESTfulWebServices（14）：分解任务与Setup测试[62.92M]

50｜RESTfulWebServices（14）：分解任务与Setup测试【】.mp4[57.23M]

50丨RESTfulWebServices（14）：分解任务与Setup测试【】.html[2.80M]

50丨RESTfulWebServices（14）：分解任务与Setup测试【】.m4a[992.18K]

50丨RESTfulWebServices（14）：分解任务与Setup测试【】.pdf[1.93M]

51｜RESTfulWebServices（15）：为什么选择在第一个测试之后就开始重构？[63.85M]

51｜RESTfulWebServices（15）：为什么选择在第一个测试之后就开始重构？【】.mp4[57.57M]

51丨RESTfulWebServices（15）：为什么选择在第一个测试之后就开始重构？【】.html[2.93M]

51丨RESTfulWebServices（15）：为什么选择在第一个测试之后就开始重构？【】.m4a[1.02M]

51丨RESTfulWebServices（15）：为什么选择在第一个测试之后就开始重构？【】.pdf[2.34M]

52｜RESTfulWebServices（16）：重构手法之设计方法名的名称[61.23M]

52｜RESTfulWebServices（16）：重构手法之设计方法名的名称【】.mp4[54.21M]

52丨RESTfulWebServices（16）：重构手法之设计方法名的名称【】.html[3.06M]

52丨RESTfulWebServices（16）：重构手法之设计方法名的名称【】.m4a[1.09M]

52丨RESTfulWebServices（16）：重构手法之设计方法名的名称【】.pdf[2.88M]

53｜RESTfulWebServices（17）：如何进行Spike的架构愿景细化？[59.37M]

53｜RESTfulWebServices（17）：如何进行Spike的架构愿景细化？【】.mp4[53.04M]

53丨RESTfulWebServices（17）：如何进行Spike的架构愿景细化？【】.html[2.90M]

53丨RESTfulWebServices（17）：如何进行Spike的架构愿景细化？【】.m4a[836.48K]

53丨RESTfulWebServices（17）：如何进行Spike的架构愿景细化？【】.pdf[2.61M]

54｜RESTfulWebServices（18）：如何实现UriTemplate的主要功能？[65.79M]

54｜RESTfulWebServices（18）：如何实现UriTemplate的主要功能？【】.mp4[59.38M]

54丨RESTfulWebServices（18）：如何实现UriTemplate的主要功能？【】.html[2.98M]

54丨RESTfulWebServices（18）：如何实现UriTemplate的主要功能？【】.m4a[1.04M]

54丨RESTfulWebServices（18）：如何实现UriTemplate的主要功能？【】.pdf[2.38M]

55｜RESTfulWebServices（19）：如何更有效地构造测试数据？[67.12M]

55｜RESTfulWebServices（19）：如何更有效地构造测试数据？【】.mp4[60.86M]

55丨RESTfulWebServices（19）：如何更有效地构造测试数据？【】.html[3.07M]

55丨RESTfulWebServices（19）：如何更有效地构造测试数据？【】.m4a[918.33K]

55丨RESTfulWebServices（19）：如何更有效地构造测试数据？【】.pdf[2.30M]

56｜RESTfulWebServices（20）：为什么要通过测试的方法来驱动出代码结构？[61.66M]

56｜RESTfulWebServices（20）：为什么要通过测试的方法来驱动出代码结构？【】.mp4[55.58M]

56丨RESTfulWebServices（20）：为什么要通过测试的方法来驱动出代码结构？【】.html[2.74M]

56丨RESTfulWebServices（20）：为什么要通过测试的方法来驱动出代码结构？【】.m4a[1.11M]

56丨RESTfulWebServices（20）：为什么要通过测试的方法来驱动出代码结构？【】.pdf[2.24M]

57｜RESTfulWebServices（21）：按照三角法，该如何增加新的测试案例？[82.65M]

57｜RESTfulWebServices（21）：按照三角法，该如何增加新的测试案例？【】.mp4[76.29M]

57丨RESTfulWebServices（21）：按照三角法，该如何增加新的测试案例？【】.html[3.01M]

57丨RESTfulWebServices（21）：按照三角法，该如何增加新的测试案例？【】.m4a[1.15M]

57丨RESTfulWebServices（21）：按照三角法，该如何增加新的测试案例？【】.pdf[2.20M]

58｜RESTfulWebServices（22）：重构还是继续完成功能？[63.15M]

58｜RESTfulWebServices（22）：重构还是继续完成功能？【】.mp4[55.57M]

58丨RESTfulWebServices（22）：重构还是继续完成功能？【】.html[3.39M]

58丨RESTfulWebServices（22）：重构还是继续完成功能？【】.m4a[1.35M]

58丨RESTfulWebServices（22）：重构还是继续完成功能？【】.pdf[2.83M]

59｜RESTfulWebServices（23）：如何构造测试数据？[82.79M]

59｜RESTfulWebServices（23）：如何构造测试数据？【】.mp4[76.50M]

59丨RESTfulWebServices（23）：如何构造测试数据？【】.html[2.97M]

59丨RESTfulWebServices（23）：如何构造测试数据？【】.m4a[912.03K]

59丨RESTfulWebServices（23）：如何构造测试数据？【】.pdf[2.43M]

60｜RESTfulWebServices（24）：RootResource的测试要如何改造？[76.42M]

60｜RESTfulWebServices（24）：RootResource的测试要如何改造？【】.mp4[71.14M]

60丨RESTfulWebServices（24）：RootResource的测试要如何改造？【】.html[2.84M]

60丨RESTfulWebServices（24）：RootResource的测试要如何改造？【】.m4a[904.92K]

60丨RESTfulWebServices（24）：RootResource的测试要如何改造？【】.pdf[1.55M]

61｜RESTfulWebServices（25）：如何重构DefaultResourceRouter中的Result结构？[64.78M]

61｜RESTfulWebServices（25）：如何重构DefaultResourceRouter中的Result结构？【】.mp4[58.11M]

61丨RESTfulWebServices（25）：如何重构DefaultResourceRouter中的Result结构？【】.html[3.29M]

61丨RESTfulWebServices（25）：如何重构DefaultResourceRouter中的Result结构？【】.m4a[939.88K]

61丨RESTfulWebServices（25）：如何重构DefaultResourceRouter中的Result结构？【】.pdf[2.46M]

62｜RESTfulWebServices（26）：如何继续划分ResourceLocator的任务？[69.71M]

62｜RESTfulWebServices（26）：如何继续划分ResourceLocator的任务？【】.mp4[62.24M]

62丨RESTfulWebServices（26）：如何继续划分ResourceLocator的任务？【】.html[3.35M]

62丨RESTfulWebServices（26）：如何继续划分ResourceLocator的任务？【】.m4a[1.35M]

62丨RESTfulWebServices（26）：如何继续划分ResourceLocator的任务？【】.pdf[2.77M]

63｜RESTfulWebServices（27）：如何通过重构修改接口？[73.75M]

63｜RESTfulWebServices（27）：如何通过重构修改接口？【】.mp4[66.22M]

63丨RESTfulWebServices（27）：如何通过重构修改接口？【】.html[3.30M]

63丨RESTfulWebServices（27）：如何通过重构修改接口？【】.m4a[1.33M]

63丨RESTfulWebServices（27）：如何通过重构修改接口？【】.pdf[2.91M]

64｜RESTfulWebServices（28）：如何重构Resource、SubResource等接口与实现？[104.35M]

64｜RESTfulWebServices（28）：如何重构Resource、SubResource等接口与实现？【】.mp4[98.36M]

64丨RESTfulWebServices（28）：如何重构Resource、SubResource等接口与实现？【】.html[3.26M]

64丨RESTfulWebServices（28）：如何重构Resource、SubResource等接口与实现？【】.m4a[984.34K]

64丨RESTfulWebServices（28）：如何重构Resource、SubResource等接口与实现？【】.pdf[1.77M]

65｜RESTfulWebServices（29）：后续任务将要如何划分与实现？[57.47M]

65｜RESTfulWebServices（29）：后续任务将要如何划分与实现？【】.mp4[50.81M]

65丨RESTfulWebServices（29）：后续任务将要如何划分与实现？【】.html[3.18M]

65丨RESTfulWebServices（29）：后续任务将要如何划分与实现？【】.m4a[1.21M]

65丨RESTfulWebServices（29）：后续任务将要如何划分与实现？【】.pdf[2.27M]

66｜RESTfulWebServices（30）：什么情况下应该使用行为验证？[48.81M]

66｜RESTfulWebServices（30）：什么情况下应该使用行为验证？【】.mp4[41.99M]

66丨RESTfulWebServices（30）：什么情况下应该使用行为验证？【】.html[3.14M]

66丨RESTfulWebServices（30）：什么情况下应该使用行为验证？【】.m4a[1.21M]

66丨RESTfulWebServices（30）：什么情况下应该使用行为验证？【】.pdf[2.47M]

67｜RESTfulWebServices（31）：对于option的测试策略应该是怎样的[58.67M]

67｜RESTfulWebServices（31）：对于option的测试策略应该是怎样的【】.mp4[52.03M]

67丨RESTfulWebServices（31）：对于option的测试策略应该是怎样的【】.html[3.29M]

67丨RESTfulWebServices（31）：对于option的测试策略应该是怎样的【】.m4a[1.19M]

67丨RESTfulWebServices（31）：对于option的测试策略应该是怎样的【】.pdf[2.15M]

50丨RESTfulWebServices（14）：分解任务与Setup测试【】.html[2.80M]

50丨RESTfulWebServices（14）：分解任务与Setup测试【】.m4a[992.18K]

50丨RESTfulWebServices（14）：分解任务与Setup测试【】.pdf[1.92M]

51丨RESTfulWebServices（15）：为什么选择在第一个测试之后就开始重构？【】.html[2.92M]

51丨RESTfulWebServices（15）：为什么选择在第一个测试之后就开始重构？【】.m4a[1.02M]

51丨RESTfulWebServices（15）：为什么选择在第一个测试之后就开始重构？【】.pdf[2.31M]

52丨RESTfulWebServices（16）：重构手法之设计方法名的名称【】.html[3.06M]

52丨RESTfulWebServices（16）：重构手法之设计方法名的名称【】.m4a[1.09M]

52丨RESTfulWebServices（16）：重构手法之设计方法名的名称【】.pdf[2.88M]

53丨RESTfulWebServices（17）：如何进行Spike的架构愿景细化？【】.html[2.89M]

53丨RESTfulWebServices（17）：如何进行Spike的架构愿景细化？【】.m4a[836.48K]

53丨RESTfulWebServices（17）：如何进行Spike的架构愿景细化？【】.pdf[2.51M]

54丨RESTfulWebServices（18）：如何实现UriTemplate的主要功能？【】.html[2.08M]

54丨RESTfulWebServices（18）：如何实现UriTemplate的主要功能？【】.m4a[1.04M]

54丨RESTfulWebServices（18）：如何实现UriTemplate的主要功能？【】.pdf[2.37M]

55丨RESTfulWebServices（19）：如何更有效地构造测试数据？【】.html[2.99M]

55丨RESTfulWebServices（19）：如何更有效地构造测试数据？【】.m4a[918.33K]

55丨RESTfulWebServices（19）：如何更有效地构造测试数据？【】.pdf[2.29M]

56丨RESTfulWebServices（20）：为什么要通过测试的方法来驱动出代码结构？【】.html[2.66M]

56丨RESTfulWebServices（20）：为什么要通过测试的方法来驱动出代码结构？【】.m4a[1.11M]

56丨RESTfulWebServices（20）：为什么要通过测试的方法来驱动出代码结构？【】.pdf[2.21M]

57丨RESTfulWebServices（21）：按照三角法，该如何增加新的测试案例？【】.html[2.93M]

57丨RESTfulWebServices（21）：按照三角法，该如何增加新的测试案例？【】.m4a[110.93K]

57丨RESTfulWebServices（21）：按照三角法，该如何增加新的测试案例？【】.pdf[2.19M]

58丨RESTfulWebServices（22）：重构还是继续完成功能？【】.html[3.32M]

58丨RESTfulWebServices（22）：重构还是继续完成功能？【】.m4a[1.35M]

58丨RESTfulWebServices（22）：重构还是继续完成功能？【】.pdf[2.79M]