蚂蚁课堂-java互联网架构师体系课5到10期|对标阿里p7|完结无秘

蚂蚁课堂-Java互联网架构师体系课5到10期|对标阿里P7|完结无秘
蚂蚁课堂-Java互联网架构师体系课5到10期|对标阿里P7|完结无秘 1

课程介绍(A001022):

蚂蚁课堂-Java互联网架构师体系课5到10期|对标阿里P7|完结无秘
蚂蚁课堂-Java互联网架构师体系课5到10期|对标阿里P7|完结无秘 2
蚂蚁课堂-java互联网架构师体系课5到10期|对标阿里p7|完结无秘 3

文件目录:

蚂蚁课堂-java互联网架构师体系课5到10期对标阿里p7完结无秘
│   ├─01、2022Java零基础课程精华版本
│   │   ├─0.相关粉丝群.html     115B
│   │   ├─00.javase之基础语法
│   │   │   ├─01.第一节-java语言的发展历史.mp4     41.36MB
│   │   │   ├─02.第二节-学会了java就业方向有哪些.mp4     35.25MB
│   │   │   ├─03.第三节-计算机编程语言发展的历史.mp4     27.92MB
│   │   │   ├─04.第四节-Java跨平台的原理.mp4     47.42MB
│   │   │   ├─05.第五节-JRE、JDK、JVM之间的区别.mp4     17.07MB
│   │   │   ├─06.第六节-如何下载JDK11安装包.mp4     36.78MB
│   │   │   ├─07.第七节-JavaSE&JavaEE&JavaME之间的区别.mp4     76.09MB
│   │   │   ├─08.第八节-如何安装JDK11演示.mp4     37.89MB
│   │   │   ├─09.第九节-如何打开命令提示符窗口.mp4     27.64MB
│   │   │   ├─10.第十节-在dos命令提示符窗口常用命令.mp4     87.48MB
│   │   │   ├─11.第十一节-为什么需要配置JDK环境变量.mp4     46.46MB
│   │   │   ├─12.第十二节-如何配置JDK的环境变量.mp4     115.61MB
│   │   │   ├─13.第十三节-编写第一个HelloWorld程序.mp4     66.02MB
│   │   │   ├─14.第十四节-HelloWorld案例常见错误演示.mp4     38.55MB
│   │   │   ├─15.第十五节-如何安装notepad.mp4     36.64MB
│   │   │   ├─16.第十六节-notepad编写第一个java程序.mp4     38.88MB
│   │   │   ├─17.第十七节-Java中的注释使用说明.mp4     61.13MB
│   │   │   ├─18.第十八节-什么是关键字.mp4     29.18MB
│   │   │   ├─19.第十九-什么是常量.mp4     40.52MB
│   │   │   ├─20.第二十节-输出常量值.mp4     40.78MB
│   │   │   ├─21.第二十一节-数据类型.mp4     69.21MB
│   │   │   ├─22.第二十二节-如何定义变量.mp4     82.62MB
│   │   │   ├─23.第二十三节-定义变量常见的问题.mp4     93.83MB
│   │   │   ├─24.第二十四节-标识符与大小驼峰命名法.mp4     106.24MB
│   │   │   ├─25.第二十五节-自动与强制类型转换.mp4     80.8MB
│   │   │   ├─26.第二十六节-算术运算符.mp4     57MB
│   │   │   ├─27.第二十七节-字符+的操作.mp4     83.68MB
│   │   │   ├─28.第二十八节-字符串的+操作().mp4     41.83MB
│   │   │   ├─29.第二十九节-i++的用法.mp4     78.29MB
│   │   │   ├─30.第三十节-++i的用法.mp4     19.75MB
│   │   │   ├─31第三十一节-++i的练习题.mp4     45.57MB
│   │   │   ├─32.第三十二节-i–的用法.mp4     52.89MB
│   │   │   ├─33.第三十三节-关系运算符.mp4     65.44MB
│   │   │   ├─34.第三十四节-逻辑运算符之逻辑与.mp4     66.98MB
│   │   │   ├─35.第三十五节-逻辑运算符之逻辑或.mp4     45.98MB
│   │   │   ├─36.第三十六节-逻辑运算符之逻辑异或.mp4     35.52MB
│   │   │   ├─37.第三十七节-短路运算符之&&.mp4     57.92MB
│   │   │   ├─38.第三十八节-短路运算符之双或者.mp4     37.24MB
│   │   │   ├─39.第三十九节-三元表达式用法.mp4     40.35MB
│   │   │   ├─40.第四十节-三元运算符案例01.mp4     27.35MB
│   │   │   ├─41.第四十一节-三元运算符案例01.mp4     27.35MB
│   │   │   ├─42.第四十二节-三元运算代码优化.mp4     22.22MB
│   │   │   ├─43.第四十三节-三元运算符案例02.mp4     57.34MB
│   │   │   ├─44.第四十四节-Scanner打印机用法.mp4     52.22MB
│   │   │   ├─45.第四十五节-Scanner类实现求两个数之和.mp4     26.15MB
│   │   │   ├─46.第四十六节-流程控制语句.mp4     12.16MB
│   │   │   ├─47.第四十七节-if判断语句的写法.mp4     34.9MB
│   │   │   ├─48.第四十八节-if和else的用法.mp4     27.65MB
│   │   │   ├─49.第四十九节-if判断语句案例奇偶数.mp4     33.36MB
│   │   │   ├─50.第五十节-多重if判断语句.mp4     42.14MB
│   │   │   ├─51.第五十一节-多重if判断语句案例.mp4     40.73MB
│   │   │   ├─52.第五十二节-switch语句的用法.mp4     118.79MB
│   │   │   ├─53.第五十三节-switch语句春夏秋冬案例.mp4     128.02MB
│   │   │   ├─54.第五十四节-for循环语句用法.mp4     108.55MB
│   │   │   ├─55.第五十五节-for循环输出5-1.mp4     72.84MB
│   │   │   ├─56.第五十六-求和案例.mp4     65.31MB
│   │   │   ├─57.第五十七-求偶数和.mp4     31.16MB
│   │   │   ├─58.第五十八节-水仙花数.mp4     99.97MB
│   │   │   ├─59.第五十九-水仙花总数.mp4     13.51MB
│   │   │   ├─60.第六十节-while循环.mp4     57.67MB
│   │   │   ├─61.第六十一节-珠穆拉玛峰.mp4     48.65MB
│   │   │   ├─62.第六十二节-do.while循环语句.mp4     66.84MB
│   │   │   ├─63.第六十三节-死循环.mp4     54.12MB
│   │   │   ├─64.第六十四-三种不同循环语句区别.mp4     44.86MB
│   │   │   ├─65.第六十五节-break和continue区别.mp4     45.44MB
│   │   │   ├─66.第六十六节-嵌套for循环语句.mp4     117.44MB
│   │   │   ├─67.第六十七节-Random随机数.mp4     57.22MB
│   │   │   └─68.第六十八节-猜数字游戏.mp4     48.87MB
│   │   ├─01.javase之方法定义
│   │   │   ├─100.第一百节-idea分析栈帧链.mp4     110.76MB
│   │   │   ├─101.第一百零一节-idea断点调试如何设置条件.mp4     40.76MB
│   │   │   ├─102.第一百零二节-idea在debug模式下改变变量的值.mp4     42.73MB
│   │   │   ├─103.第一百零三-idea如何清除断点 .mp4     26.83MB
│   │   │   ├─104.第一百零四.-idea断点如何回退.mp4     28.3MB
│   │   │   ├─105.第一百零五节-逢七过.mp4     98.6MB
│   │   │   ├─106.第一百零六节-数组元素求和.mp4     81.17MB
│   │   │   ├─107.第一百零七节-比较数组是否相同.mp4     56.22MB
│   │   │   ├─108.第一百零八节-数组中查找元素.mp4     100.94MB
│   │   │   ├─109.第一百零九节-评委打分.mp4     200.84MB
│   │   │   ├─110.第一百一十节-如何反转一个数组.mp4     97.76MB
│   │   │   ├─69.第六十九节-如何安装idea开发工具.mp4     76.07MB
│   │   │   ├─70.第七十节-idea如何创建项目.mp4     82.52MB
│   │   │   ├─71.第七十一节-idea工程模块的划分.mp4     64.49MB
│   │   │   ├─72.第七十二节-idea常用辅助快捷键.mp4     52.36MB
│   │   │   ├─73.第七十三节-idea操作模块.mp4     22.17MB
│   │   │   ├─74.第七十四节-数组概述.mp4     55.6MB
│   │   │   ├─75.第七十五节-定义动态初始化.mp4     58.78MB
│   │   │   ├─76.第七十六节-.访问数组中的元素.mp4     83.6MB
│   │   │   ├─77.第七十七节-画图分析单个数组访问原理.mp4     109.07MB
│   │   │   ├─78.第七十八节-画图分析多个数组访问原理.mp4     76.24MB
│   │   │   ├─79.第七十九节-画图分析多个数组指向同一个内存地址.mp4     66.8MB
│   │   │   ├─80.第八十节-数组之静态初始化.mp4     32.04MB
│   │   │   ├─81.第八十一节-使用数组常见问题.mp4     56.19MB
│   │   │   ├─82.第八十二节-如何遍历数组.mp4     68.95MB
│   │   │   ├─83.第八十三节-数组如何查找最大值.mp4     87.22MB
│   │   │   ├─84.第八十四节-方法的概述.mp4     42.4MB
│   │   │   ├─85.第八十五节-方法的定义.mp4     58.17MB
│   │   │   ├─86.第八十六节-图解方法调用的过程.mp4     56.72MB
│   │   │   ├─87.第八十七节-带参数的方法.mp4     116.78MB
│   │   │   ├─88.第八十八节-形参与实参区别.mp4     25MB
│   │   │   ├─89.第八十九节-带返回值的方法.mp4     59.4MB
│   │   │   ├─90.第九十节-定义方法的注意事项.mp4     20.86MB
│   │   │   ├─91.第九十一节-方法的通用格式.mp4     52.85MB
│   │   │   ├─92.第九十二节-方法的重载.mp4     61.46MB
│   │   │   ├─93.第九十三节-方法重载的案例.mp4     70.82MB
│   │   │   ├─94.第九十四节-方法的参数传递基本类型.mp4     111.05MB
│   │   │   ├─95.第九十五节-方法的参数传递引用类型.mp4     75.59MB
│   │   │   ├─96.第九十六节-方法的案例遍历数组.mp4     69.03MB
│   │   │   ├─97.第九十七节-方法的案例查找数组最大值.mp4     34.06MB
│   │   │   ├─98.第九十八节-debug如何调试程序.mp4     95.61MB
│   │   │   └─99.第九十九节-debug调试偶数和.mp4     55.33MB
│   │   ├─02.javase之面向对象
│   │   │   ├─114.第一百一十四节-面向对象概述.mp4     68.53MB
│   │   │   ├─115.第一百一十五节-类如何定义.mp4     81.97MB
│   │   │   ├─116.第一百一十六节.对象的使用.mp4     104.22MB
│   │   │   ├─117.第一百一十七节.学生类.mp4     39.99MB
│   │   │   ├─118.第一百一十八节.单个对象内存图.mp4     97.64MB
│   │   │   ├─119.第一百一十九节.new多个对象内存地址.mp4     52.91MB
│   │   │   ├─120.第一百二十节.new多个对象存放指向同一个内存地址.mp4     59.6MB
│   │   │   ├─121.第一百二十一节.成员变量与局部变量的区别.mp4     72.17MB
│   │   │   ├─122.第一百二十二节-.private.mp4     118.69MB
│   │   │   ├─123.第一百二十三节.this关键字使用01.mp4     103.85MB
│   │   │   ├─124.第一百二十四节-this的原理.mp4     45.6MB
│   │   │   ├─125.第一百二十五节.什么是构造方法.mp4     37.11MB
│   │   │   ├─126.第一百二十六节-使用构造方法注意事项.mp4     81.13MB
│   │   │   ├─127.第一百二十七节.构造方法的作业题.mp4     111.94MB
│   │   │   ├─128.第一百二十八节.idea自动生成模板类.mp4     40.01MB
│   │   │   ├─129.第一百二十九节-this使用细节问题.mp4     72.37MB
│   │   │   ├─130.第一百三十节-什么是封装.mp4     32.75MB
│   │   │   ├─131.第一百三十一节-什么是继承.mp4     70.57MB
│   │   │   ├─132.第一百三十二节.画图分析继承模式.mp4     55.67MB
│   │   │   ├─133.第一百三十三节.idea如何生成继承类图.mp4     48.85MB
│   │   │   ├─134.第一百三十四节.继承模式的优缺点.mp4     34.12MB
│   │   │   ├─135.第一百三十五节.如何判断使用继承模式.mp4     17.96MB
│   │   │   ├─136.第一百三十六.继承中的变量访问特点.mp4     60.86MB
│   │   │   ├─137.第一百三十七.super关键字用法.mp4     40.88MB
│   │   │   ├─138.第一百三十八.super访问父类中的构造方法.mp4     75.82MB
│   │   │   ├─139.第一三十九.访问父类中的成员方法.mp4     29.87MB
│   │   │   ├─140.第一四十节.什么是方法重写.mp4     47.13MB
│   │   │   ├─141.第一百四十一.权限修饰符.mp4     112.77MB
│   │   │   ├─142.方法重写注意事项.mp4     51.64MB
│   │   │   ├─143.画图分析java中的继承注意事项(1).mp4     61.16MB
│   │   │   ├─143.画图分析java中的继承注意事项.mp4     61.16MB
│   │   │   ├─144.继承作业题构造方法给成员属性赋值.mp4     84.35MB
│   │   │   ├─145.继承作业题set方法给成员属性赋值.mp4     32.39MB
│   │   │   ├─146.package的作用.mp4     62.64MB
│   │   │   ├─147.package细节问题.mp4     78.96MB
│   │   │   ├─148.import导入包.mp4     70.98MB
│   │   │   ├─149.import导入包细节问题.mp4     31.98MB
│   │   │   ├─150.final关键字最终态.mp4     28.58MB
│   │   │   ├─151.fina关键字修饰局部变量.mp4     59.6MB
│   │   │   ├─152.第一百五十二节.static关键字.mp4     48.27MB
│   │   │   ├─153.第一百五十三节.画图分析静态变量访问特征.mp4     73.63MB
│   │   │   ├─154.第一百五十四节-静态关键字访问特点.mp4     65.62MB
│   │   │   ├─155.第一百五十五节-静态关键字应用场景.mp4     51.38MB
│   │   │   ├─156.第一百五十六节-static修饰常量.mp4     61.17MB
│   │   │   ├─157.第一百五十七.main方法细节问题.mp4     106.22MB
│   │   │   ├─158.第一百五十八.main访问特点.mp4     54.97MB
│   │   │   ├─159.第一百五十九.idea如何设置main注入参数.mp4     47.33MB
│   │   │   ├─160.第一百六十.多态概念基本概念.mp4     73.09MB
│   │   │   ├─161.第一百六十一-多态的访问特点.mp4     85.36MB
│   │   │   ├─162.第一百六十二节-多态机制的优缺点-上.mp4     82.76MB
│   │   │   ├─163.第一百六十三节-多态机制的优缺点-下.mp4     77.78MB
│   │   │   ├─164.第一百六十四节-多态的转型.mp4     71.28MB
│   │   │   ├─165.第一百六十五节-画图分析多态的转型.mp4     74.06MB
│   │   │   ├─166.第一百六十五节-抽象类的概念.mp4     76.75MB
│   │   │   ├─167.第一百六十七节-抽象的特点.mp4     70.08MB
│   │   │   ├─168.第一百六十八节-.抽象类定义有参构造方法.mp4     113.77MB
│   │   │   ├─169.第一百六十九节-.画图分析抽象类的案例.mp4     48.1MB
│   │   │   ├─170.第一百七十节.抽象的类案例代码编写.mp4     135.91MB
│   │   │   ├─171.第一百七十一节.abstract关键字不能和哪些关键字共存.mp4     38.73MB
│   │   │   ├─172.第一百七十二节.接口的定义特点.mp4     84.4MB
│   │   │   ├─173.第一百七十三节.接口中成员变量访问特点.mp4     58.1MB
│   │   │   ├─174.第一百七十四节.接口中成员方法访问特点.mp4     33.91MB
│   │   │   ├─175.第一百七十五节.接口中是没有构造方法.mp4     53.12MB
│   │   │   ├─176.第一百七十六.猫和狗接口版本思路分析.mp4     34.4MB
│   │   │   ├─177.第一百七十七.猫和狗接口版本代码演示.mp4     130.26MB
│   │   │   ├─178.第一百七十八.类和接口的关系.mp4     92.88MB
│   │   │   ├─179.第一百七十九.抽象类和接口的区别.mp4     66.96MB
│   │   │   ├─180.第一百八十.门与报警(抽象类和接口组合).mp4     66.4MB
│   │   │   ├─181.第一百八十一节-什么是内部类.mp4     42.77MB
│   │   │   ├─182.第一百八十二节-.成员内部类.mp4     69.38MB
│   │   │   ├─183.第一百八十三节-.静态内部类.mp4     38.81MB
│   │   │   ├─184.第一百八十四节-.局部内部类.mp4     35.51MB
│   │   │   ├─185.第一百八十五节-.匿名内部类.mp4     46.43MB
│   │   │   ├─186.第一百八十六节-.匿名内部类应用场景.mp4     59.08MB
│   │   │   └─187.第一百八十七节-匿名内部类底层实现原理.mp4     109.76MB
│   │   ├─03.javase之常见API和异常
│   │   │   ├─188.第一百八十八节-什么是API.mp4     114.21MB
│   │   │   ├─189.第一百八十九节-如何使用帮助文档.mp4     66.6MB
│   │   │   ├─190.第一百九十节-Object类.mp4     109.72MB
│   │   │   ├─191.第一百九十一节.控制输出对象原理.mp4     82.74MB
│   │   │   ├─192.第一百九十二节.重写Object父类中toString方法.mp4     72.73MB
│   │   │   ├─193.第一百九十三节.String字符串.mp4     40.03MB
│   │   │   ├─194.第一百九十四节.String类中的equals方法.mp4     42.83MB
│   │   │   ├─195.第一百九十五节.三种不同方式实现用户登录.mp4     126.64MB
│   │   │   ├─196.第一百九十六节.登录加上三次登录重试机会.mp4     85.6MB
│   │   │   ├─197.第一百九十七节.Object父类中的equals方法.mp4     94.21MB
│   │   │   ├─198.第一百九十八节.重写Object父类中的equals方法.mp4     137.27MB
│   │   │   ├─199.第一百九八九.instanceof 关键字的用法.mp4     205.32MB
│   │   │   ├─200.第二百节-String类中Equals方法源码解读.mp4     106.99MB
│   │   │   ├─201.第二百零一节-.String类中Equals方法如何比较两个字符串值相同.mp4     168.14MB
│   │   │   ├─202.第二百零二节.遍历遍历字符串的原理.mp4     90.39MB
│   │   │   ├─203.第二百零三节.replace替换方法.mp4     54.77MB
│   │   │   ├─204.第二百零四节.split分割方法.mp4     35.52MB
│   │   │   ├─209.第二八零九节.ASCII码字符对照表.mp4     66.35MB
│   │   │   ├─210.第二百一十节.统计大小写字符个数代码分析.mp4     82.33MB
│   │   │   ├─211.第二百一十一节代码实现统计大小写字符出现的次数.mp4     76.44MB
│   │   │   ├─212.第二百一十二节.indexOf.mp4     89.64MB
│   │   │   ├─213.第二百一十二节.StringApi帮助文档.mp4     39.79MB
│   │   │   ├─214.第二百一十三节.jdk9为何要将String的底层实现由char数组改成了byte数组.mp4     24.49MB
│   │   │   ├─215.第二百一十四.java元空间的概念.mp4     146.23MB
│   │   │   ├─226.第二百二十六节.Math类.mp4     181.01MB
│   │   │   ├─227.第二百二十七节.sytem.mp4     83.01MB
│   │   │   ├─228.第二百二十九节.工具类的设计.mp4     75.26MB
│   │   │   ├─228.第二百二十八节.arrays类中常用方法.mp4     77.71MB
│   │   │   ├─230.第二百三十节.包装类概念.mp4     92.56MB
│   │   │   ├─231.第二百三十一节.Integer的用法.mp4     54.59MB
│   │   │   ├─232.第二百三十二节.String类中valueOF方法.mp4     66.22MB
│   │   │   ├─233.第二百三十三节.String如何转化成int类型.mp4     60.02MB
│   │   │   ├─234.包装类的基本规则.mp4     76.97MB
│   │   │   ├─235.Integer包装类底层设计原理.mp4     167.35MB
│   │   │   ├─236.Java中基本数据类型和包装类型的区别.mp4     50.04MB
│   │   │   ├─237.装箱和拆箱设计原理.mp4     85.01MB
│   │   │   ├─238.字符串中的数据排序.mp4     88.64MB
│   │   │   ├─239.date日期.mp4     113.46MB
│   │   │   ├─240.date常用方法.mp4     58.27MB
│   │   │   ├─241.SimpleDateFormat格式化日期.mp4     71.26MB
│   │   │   ├─242.SimpleDateFormat将字符串转化成date.mp4     39.5MB
│   │   │   ├─243.dateutils工具类设计.mp4     72.87MB
│   │   │   ├─244.第二百四十四.CalendarApi使用.mp4     113.99MB
│   │   │   ├─245.第二百四十五.Calendar修改日期.mp4     48.07MB
│   │   │   ├─246.第二百四十六.二月份有多少天.mp4     68.21MB
│   │   │   ├─247.第二百四十七.什么是异常.mp4     35.09MB
│   │   │   ├─248.第二百四十八.如何查看异常信息.mp4     64.85MB
│   │   │   ├─249.第二百四十九.try.catch用法.mp4     65.49MB
│   │   │   ├─250.第二百五十.catch顺序问题.mp4     83.09MB
│   │   │   ├─251.第二百五十一..Exception异常.mp4     115.09MB
│   │   │   ├─252.第二百五十二节.Throwable成员方法.mp4     170.25MB
│   │   │   ├─253.第二百五十三节.编译时与运行时异常区别.mp4     70.15MB
│   │   │   ├─254.第二百五十四节.异常处理之throws.mp4     65.85MB
│   │   │   └─255.第二百五十五节.如何自定义编译和运行时异常.mp4     76.95MB
│   │   ├─04.javase之集合框架和源码解读
│   │   │   ├─256.第二百十五六.为什么需要使用集合框架.mp4     84.1MB
│   │   │   ├─257.第二百十五七.java中的集合框架组成部分.mp4     126.68MB
│   │   │   ├─258.第二百十五八.arraylist集合使用.mp4     86.47MB
│   │   │   ├─259.第二百十五九.arraylist集合常用方法.mp4     57.25MB
│   │   │   ├─260.第二百六十.arraylist集合存入学生对象.mp4     55.62MB
│   │   │   ├─261.第二百六十一.代码优化arraylist集合存入学生对象.mp4     59.74MB
│   │   │   ├─262.第二百六十二节-学生管理系统项目演示.mp4     32.55MB
│   │   │   ├─263.第二百六十三节-学生对象管理系统代码思路分析.mp4     44.58MB
│   │   │   ├─264.第二百六十四节-学生管理系统主界面开发.mp4     42.2MB
│   │   │   ├─265.第二百六十五节-学生管理系统新增学生.mp4     50.68MB
│   │   │   ├─266.第二百六十六节-学生管理系统查询学生.mp4     38.21MB
│   │   │   ├─267第二百六十七节-学生管理系统查询学生优化.mp4     31.02MB
│   │   │   ├─268.第二百六十八节-判断学生学号不允许重复插入.mp4     51.57MB
│   │   │   ├─269.第二百六十九.学生管理系统删除方法.mp4     69.89MB
│   │   │   ├─270.第二百七十.学生管理系统删除代码优化.mp4     102.88MB
│   │   │   ├─271.第二百七十一.学生管理系统debug调试代码.mp4     38.5MB
│   │   │   ├─272.第二百七十二.学生管理系统修改学生信息.mp4     79.39MB
│   │   │   ├─273.第二百七十三.学生管理系统退出系统方式一.mp4     25.21MB
│   │   │   ├─274.第二百七十四.学生管理系统退出系统方式二.mp4     25.72MB
│   │   │   ├─275.第二百七十五.arraylist存入数据保证有序性且允许重复.mp4     32.01MB
│   │   │   ├─276.第二百七十六.迭代器的next方法.mp4     95.13MB
│   │   │   ├─277.第二百七十七.迭代器HashNext方法.mp4     74.71MB
│   │   │   ├─278.第二百七十八.手写迭代器Next方法.mp4     79.7MB
│   │   │   ├─279.第二百七十九.手写迭代器hasNext方法.mp4     38.03MB
│   │   │   ├─280.第二百八十.list集合中独有的方法.mp4     73.82MB
│   │   │   ├─281.第二百八十一.ListIterator.mp4     105.78MB
│   │   │   ├─282.第二百八十二.增强for循环.mp4     30.73MB
│   │   │   ├─283.第二百八十三.增强for循环遍历集合.mp4     19.38MB
│   │   │   ├─284.第二百八十四.三种不同方式遍历集合.mp4     42.85MB
│   │   │   ├─285.第二百八十五节-为什么要使用泛型.mp4     133.25MB
│   │   │   ├─286.第二百八十六节-如何定义泛型类.mp4     84MB
│   │   │   ├─287.第二百八十七节-如何定义泛型方法.mp4     92.47MB
│   │   │   ├─288.第二百八十八节-如何定义泛型接口.mp4     29.07MB
│   │   │   ├─289.第二百八十九节.泛型接口与泛型类区别.mp4     27.99MB
│   │   │   ├─290.第二百九十节-list接口中泛型如何设计的.mp4     42.96MB
│   │   │   ├─291.第二百九十一节.泛型通配符.mp4     49.59MB
│   │   │   ├─292.第二百九十二节.泛型通配符之上限和下限.mp4     82.64MB
│   │   │   ├─293.第二百九十三节-可变参数.mp4     58.01MB
│   │   │   ├─294.第二百九十四.可变参数的使用.mp4     29.8MB
│   │   │   ├─295.第二百九十五.泛型擦除机制.mp4     63.79MB
│   │   │   ├─296.数据结构数组的时间复杂度.mp4     127.39MB
│   │   │   ├─297.为什么arrayList集合增加删除效率非常低.mp4     56.07MB
│   │   │   ├─298.第二百九十八-.简单纯手写ArrayList集合.mp4     30.95MB
│   │   │   ├─299.第二百九十九节.Arraylist集合Add方法源码解读.mp4     92.9MB
│   │   │   ├─300.第三百节-Arraylist集合扩容源码解读源码解读.mp4     43.08MB
│   │   │   ├─301.第三百零一节-Arraylist集合Get方法源码解读.mp4     10.31MB
│   │   │   ├─302.第三百零二节-Arraylist集合Remove方法源码解读.mp4     59.37MB
│   │   │   ├─303.第三百零三节-ArrayList 与Vector 区别.mp4     44.03MB
│   │   │   ├─304.第三百零四节-总结ArrayList集合源码.mp4     19.35MB
│   │   │   ├─305.第三百零五节-数据结构链表数据结构特点.mp4     61.56MB
│   │   │   ├─306.第三百零六节-.数据结构链表-单向链表创建.mp4     44.18MB
│   │   │   ├─307.第三百零七节-.数据结构链表-单向链表遍历.mp4     59.63MB
│   │   │   ├─308.第三百零八节.单向链表数据结构如何新增.mp4     36.14MB
│   │   │   ├─309.第三百零九节.单向链表数据结构如何删除.mp4     15.24MB
│   │   │   ├─310.第三百一十节.如何定义双向链表.mp4     32.65MB
│   │   │   ├─311.第三百一十一节.linkedList基本的使用.mp4     42.67MB
│   │   │   ├─312.linkelist基本数据结构.mp4     95.67MB
│   │   │   ├─313.纯手写linkelist链表数据结构add.mp4     210.5MB
│   │   │   ├─314.linkelist中的get方法底层源码解读.mp4     103.49MB
│   │   │   ├─315.linkelist中的remove方法底层实现.mp4     83.92MB
│   │   │   ├─316.三百一十六节.hashmap集合基本特点.mp4     99.2MB
│   │   │   ├─317.三百一十七节.Map集合中的常用方法.mp4     102.44MB
│   │   │   ├─318.三百一十八节.HashSet集合用法.mp4     48.81MB
│   │   │   ├─319.三百一十九节.手写HashSet集合.mp4     34.08MB
│   │   │   ├─320.三百二十节.hashSet集合没有get方法.mp4     19.72MB
│   │   │   ├─321.三百二十一节.hashSet存入学生对象不允许重复.mp4     134.56MB
│   │   │   ├─322.三百二十二节.HashMap集合常用Get方法.mp4     83.57MB
│   │   │   ├─323.三百二十三节.HashMap集合遍历方式一.mp4     29.47MB
│   │   │   ├─324.三百二十四节.HashMap集合遍历方式二.mp4     28.02MB
│   │   │   ├─325.三百二十五节.HashMap集合遍历方式三.mp4     15.04MB
│   │   │   ├─326.三百二十六节.HashMap集合存入学生对象.mp4     41.84MB
│   │   │   ├─327.第三百二十七节.hashCode方法重写注意事项.mp4     179.6MB
│   │   │   ├─328.第三百二十八节.hashMap常见的面试题.mp4     38.34MB
│   │   │   ├─329.第三百二十九节.基于ArrayList手写HashMap集合.mp4     124.53MB
│   │   │   ├─330.第三百三十节.Key的Hash算法原理.mp4     70.4MB
│   │   │   ├─331.第三百三十一节.什么是hash冲突问题.mp4     32.37MB
│   │   │   ├─332.第三百三十二节.如何解决hash冲突问题.mp4     27.66MB
│   │   │   ├─333.第三百三十三节.手写HashMap集合Put方法.mp4     35.32MB
│   │   │   ├─334.第三百三十四节.手写HashMap集合Get方法.mp4     61.1MB
│   │   │   ├─335.第三百三十五节.HashMapKey存放自定义对象.mp4     158.17MB
│   │   │   ├─336.第三百三十六节.ArrayList存放HashMap.mp4     30.92MB
│   │   │   ├─337.第三百三十七节.HashMap 集合存放ArrayList集合.mp4     47.25MB
│   │   │   ├─338.第三百三十八节.HashMap统计每个字符出现的次数.mp4     102.21MB
│   │   │   ├─339.第三百三十九节.Collections单列集合操作工具类.mp4     69.9MB
│   │   │   ├─340.第三百四十节.HashMap集合散列概念.mp4     58.57MB
│   │   │   ├─341.第三百四十一节.LinkedHashMap有序.mp4     47.71MB
│   │   │   ├─342.第三百四十二节.LinkedHashSet.mp4     59.27MB
│   │   │   ├─343.第三百四十三节.手写LinkedHashSet.mp4     51.69MB
│   │   │   └─344.第三百四十四.生成10个不允许重复随机数.mp4     32.2MB
│   │   ├─05.javase之IO流相关
│   │   │   ├─01.什么是IO.mp4     76.25MB
│   │   │   ├─02.file类创建文件.mp4     97.61MB
│   │   │   ├─03.file类常见判断方法.mp4     52.25MB
│   │   │   ├─04.file类常见获取方法.mp4     57.48MB
│   │   │   ├─05.相对路径与绝对路径区别.mp4     73.86MB
│   │   │   ├─06.file类删除操作.mp4     45.68MB
│   │   │   ├─07.循环删除多个文件.mp4     60.79MB
│   │   │   ├─08.递归算法求阶乘.mp4     56.18MB
│   │   │   ├─09.画图演示递归算法.mp4     64.14MB
│   │   │   ├─10.debug调试递归算法.mp4     24.54MB
│   │   │   ├─11.递归算法注意事项.mp4     54.18MB
│   │   │   ├─12.递归算法遍历目录.mp4     59.5MB
│   │   │   ├─13.递归算法删除目录.mp4     19.87MB
│   │   │   ├─14.IO流概念.mp4     30.9MB
│   │   │   ├─15.IO流的分类.mp4     32.29MB
│   │   │   ├─16.字节输出流.mp4     49.39MB
│   │   │   ├─17.字节写入数据常用三种方式.mp4     85.65MB
│   │   │   ├─18.字节流写入数据换行和追加写.mp4     56.84MB
│   │   │   ├─19.正确方式关闭IO资源.mp4     41.79MB
│   │   │   ├─20.FileInputStream单个字节读取文件..mp4     60.66MB
│   │   │   ├─21.read方法循环优化.mp4     44.93MB
│   │   │   ├─22.read方法读取数据优化.mp4     21.41MB
│   │   │   ├─23.字节流文件内容拷贝.mp4     54.39MB
│   │   │   ├─24.字节流读取字节数组数据.mp4     50.67MB
│   │   │   ├─25.字节流以字节数组读取数据原理.mp4     176.86MB
│   │   │   ├─26.字节流以1024字节数组读取方式.mp4     79.63MB
│   │   │   ├─27.字节流复制图片.mp4     43.17MB
│   │   │   ├─28.什么是缓冲流.mp4     51.86MB
│   │   │   ├─29.字节缓冲区流-写入数据.mp4     77.93MB
│   │   │   ├─30.字节缓冲流-读取数据.mp4     46.94MB
│   │   │   ├─31.字节缓冲区复制视频.mp4     48.27MB
│   │   │   ├─32.字节流与缓存流复制视频效率对比.mp4     104.4MB
│   │   │   ├─33.一个汉字存储占用多少字节.mp4     62.49MB
│   │   │   ├─34.编码和解码乱码问题.mp4     108.07MB
│   │   │   ├─35.字符流写入文本数据.mp4     71.28MB
│   │   │   ├─36.字符流读取文本数据.mp4     39.89MB
│   │   │   ├─37.字符流写入数据五种方式.mp4     66.74MB
│   │   │   ├─38.字符输入流读取数据.mp4     75.86MB
│   │   │   ├─39.字符流拷贝文本文件.mp4     36.97MB
│   │   │   ├─40.FileWriterFileReader.mp4     91.2MB
│   │   │   ├─41.字符缓冲流.mp4     128.12MB
│   │   │   ├─42.字符缓冲流写入数据换行操作.mp4     55.36MB
│   │   │   ├─43.字符缓冲流读取数据换行操作.mp4     57.56MB
│   │   │   └─44.字符缓冲流拷贝java代码.mp4     49.1MB
│   │   ├─06.javase之多线程技术
│   │   │   ├─001.多线程快速入门与实际项目如何整合多线程
│   │   │   │   └─视频
│   │   │   │         ├─01.第一节-多线程第一次课程内容安排.mp4     72.86MB
│   │   │   │         ├─02.第二节-什么是线程、进程.mp4     73.71MB
│   │   │   │         ├─03.第三节-为什么在进程中还需要线程呢.mp4     20.03MB
│   │   │   │         ├─04.第四节-为什么需要使用多线程与单与并行区别.mp4     70.87MB
│   │   │   │         ├─05.第五节-使用多线程一定提高效率吗.mp4     118.53MB
│   │   │   │         ├─06.第六节-多线程的应用场景有哪些呢.mp4     33.79MB
│   │   │   │         ├─07.第七节-同步与异步之间的区别.mp4     19.99MB
│   │   │   │         ├─08.第八节-继承Thread类创建线程.mp4     62.86MB
│   │   │   │         ├─09.第九节-实现Runnable接口创建线程.mp4     37.3MB
│   │   │   │         ├─10.第十节-使用Callable和Future创建线程.mp4     126.72MB
│   │   │   │         ├─11.第十一节-使用线程池的方式创建线程.mp4     22.9MB
│   │   │   │         ├─12.第十二节-@Async异步注解创建线程.mp4     86.08MB
│   │   │   │         ├─13.第十三节-手写@Async异步注解.mp4     126.99MB
│   │   │   │         └─bandicam 2021-05-30 20-53-12-818.mp4     31.1MB
│   │   │   ├─002.synchronized锁使用与线程之间如何实现通讯
│   │   │   │   └─视频
│   │   │   │         ├─01.第一节-什么是线程安全问题.mp4     106.41MB
│   │   │   │         ├─02.第二节-如何解决线程安全问题.mp4     110.76MB
│   │   │   │         ├─03.第三节-synchronized锁基本的用法01.mp4     68.17MB
│   │   │   │         ├─04.第四节-synchronized锁基本的用法02.mp4     63.62MB
│   │   │   │         ├─05.第五节-synchronized死锁问题.mp4     74.76MB
│   │   │   │         ├─06.第六节-如何诊断synchronized死锁问题.mp4     25.73MB
│   │   │   │         ├─07.第七节-如何保证线程同步问题.mp4     22.1MB
│   │   │   │         ├─08.第八节-springmvc接口中使用synchronized.mp4     72.78MB
│   │   │   │         ├─09.第九节-使用wait、notify注意事项.mp4     61.05MB
│   │   │   │         ├─10.第十节-wait、notify生产者与消费者模型01.mp4     90.09MB
│   │   │   │         ├─11.第十一节-wait、notify生产者与消费者模型02.mp4     104.67MB
│   │   │   │         └─code
│   │   │   │               └─code.rar     774.39KB
│   │   │   ├─003.多线程核心API与Lock锁使用
│   │   │   │   ├─01.第一节-画图分析wait与notify实现原理.mp4     225.61MB
│   │   │   │   ├─02.第二节-join方法底层的设计原理.mp4     124.34MB
│   │   │   │   ├─03.第三节-多线程底层七种状态.mp4     95.88MB
│   │   │   │   ├─04.第四节-sleep防止CPU占用100%.mp4     45.84MB
│   │   │   │   ├─05.第五节-守护与用户线程的区别.mp4     31.6MB
│   │   │   │   ├─06.第六节-如何安全的停止一个线程.mp4     66.83MB
│   │   │   │   ├─07.第七节-lock与synchronized的区别.mp4     26.68MB
│   │   │   │   ├─08.第八节-简单演示lock锁使用方式01.mp4     77.32MB
│   │   │   │   ├─09.第九节-简单演示lock锁使用方式02.mp4     22.79MB
│   │   │   │   ├─10.第十节-lock的condition用法.mp4     45.3MB
│   │   │   │   ├─11.第十一节-多线程的yield方法使用.mp4     30.11MB
│   │   │   │   ├─12.第十二节-多线程的优先级.mp4     35.31MB
│   │   │   │   ├─13.第十三节-wait与sleep之间的区别.mp4     32.13MB
│   │   │   │   └─14.第十四节-为什么wait和notify在object父类中.mp4     20.27MB
│   │   │   ├─004.蚂蚁课堂&-第九期-基础知识回顾之多线程综合实战案例与纯手写日志框架
│   │   │   │   └─视频
│   │   │   │         ├─01.第一节-字节码指令角度分析线程安全问题.mp4     134.64MB
│   │   │   │         ├─02.第二节-画图分析字节码指令角度分析线程安全问题.mp4     60.98MB
│   │   │   │         ├─03.第三节-Callable与FutureTask原理分析01.mp4     129.54MB
│   │   │   │         ├─04.第四节-Callable与FutureTask原理分析02.mp4     72.41MB
│   │   │   │         └─05.第五节-纯手写日志框架设计原理.mp4     174.86MB
│   │   │   ├─code
│   │   │   │   └─相关代码.rar     124.26KB
│   │   │   └─深入理解多线程底层执行的原理.doc     1.26MB
│   │   ├─07.ConcurrentHashMap原理
│   │   │   ├─01.HashTable与HashMap区别.mp4     98.42MB
│   │   │   ├─02.HashTable集合有哪些缺陷.mp4     60.05MB
│   │   │   ├─03.ConcurrentHashMa1.7实现原理.mp4     105.42MB
│   │   │   ├─04.ConcurrentHashMap的使用.mp4     31.91MB
│   │   │   ├─05.手写出ConcurrentHashMap.mp4     65.58MB
│   │   │   ├─06.如何理解分段锁设计概念.mp4     35.59MB
│   │   │   ├─07.ConcurrentHashMap1.7计算两次index.mp4     53.11MB
│   │   │   └─code
│   │   │         └─mayikt-hashmap.rar     10.36KB
│   │   ├─08.socket网络编程
│   │   │   ├─01.什么是CS体系架构.mp4     74.4MB
│   │   │   ├─02.什么是BS体系架构(1).mp4     118.35MB
│   │   │   ├─02.什么是BS体系架构.mp4     118.35MB
│   │   │   ├─03.http协议基本概念(1).mp4     90.67MB
│   │   │   ├─03.http协议基本概念.mp4     90.67MB
│   │   │   ├─04.http协议请求格式.mp4     185.89MB
│   │   │   ├─05.http协议响应格式.mp4     137.95MB
│   │   │   ├─06.什么是网络编程技术.mp4     71.52MB
│   │   │   ├─07.IP地址和端口.mp4     51.39MB
│   │   │   ├─08.inetAddres用法.mp4     84.92MB
│   │   │   ├─09.什么是dns域名解析.mp4     100.61MB
│   │   │   ├─10.udp协议基本的概念.mp4     29.05MB
│   │   │   ├─11.创建udp发送者.mp4     73.24MB
│   │   │   ├─12.创建udp接受者.mp4     62.36MB
│   │   │   ├─13.udp协议练习题.mp4     95.7MB
│   │   │   ├─14.tcp基本概念与三次握手.mp4     66.27MB
│   │   │   ├─15.tcp协议发送数据.mp4     41.39MB
│   │   │   ├─16.tcp协议接受数据.mp4     46.07MB
│   │   │   ├─17.tcp协议实现循环发送接受数据.mp4     148.22MB
│   │   │   ├─18.改造代码多线程处理.mp4     63.53MB
│   │   │   ├─19.tcp实现服务器端验证账户和密码.mp4     113.66MB
│   │   │   ├─20.手写http服务器端.mp4     118.91MB
│   │   │   └─21.改造http服务器灵活访问资源.mp4     89.28MB
│   │   ├─09.反射技术
│   │   │   ├─01.什么是java反射机制.mp4     72.16MB
│   │   │   ├─02.java反射机制底层原理.mp4     130.23MB
│   │   │   ├─03.使用反射初始化对象.mp4     99.23MB
│   │   │   ├─04.使用反射获取成员属性.mp4     55.02MB
│   │   │   └─05.使用反射机制调用方法.mp4     76.3MB
│   │   ├─10.juc并发编程基础
│   │   │   ├─01.第一章-线程池实现原理
│   │   │   │   ├─02.第二节-为什么需要使用线程池.mp4     48.9MB
│   │   │   │   ├─03.第三节-实际项目中哪些地方使用线程池.mp4     14.19MB
│   │   │   │   ├─04.第四节-线程池有哪些作用呢.mp4     33.84MB
│   │   │   │   ├─05.第五节-线程池创建的方式有哪些呢.mp4     49.46MB
│   │   │   │   ├─06.第六节-线程池底层复用机制的原理.mp4     62.13MB
│   │   │   │   ├─07.第七节-java纯手写线程池.mp4     91.69MB
│   │   │   │   ├─08.第八节-线程池创建的线程会一直运行吗.mp4     47.31MB
│   │   │   │   ├─09.第九节-ThreadPoolExecutor构造函数原理.mp4     65.7MB
│   │   │   │   ├─10.第十节-线程池队列满了,任务会丢失吗.mp4     21.66MB
│   │   │   │   └─相关代码.rar     21.58KB
│   │   │   ├─02.第二章-CAS底层实现原理
│   │   │   │   ├─相关代码.rar     20.98KB
│   │   │   │   └─视频
│   │   │   │         ├─01.第一节-什么是悲观锁.mp4     78.5MB
│   │   │   │         ├─02.第二节-mysql乐观锁实现原理.mp4     169.34MB
│   │   │   │         ├─03.第三节-谈谈你对公平锁与非公平锁理解.mp4     101.09MB
│   │   │   │         ├─04.第四节-什么是锁的可重入性.mp4     10.48MB
│   │   │   │         ├─05.第五节-谈谈cas锁的理解.mp4     57.15MB
│   │   │   │         ├─06.第六节-cas底层实现原理.mp4     81.91MB
│   │   │   │         ├─08.第七节-如何利用cas手写一把锁.mp4     73.45MB
│   │   │   │         ├─09.第八节-使用cas锁的优缺点.mp4     22.44MB
│   │   │   │         └─10.第九节-cas锁如何避免aba的问题.mp4     32.4MB
│   │   │   ├─03.第三章-Threadlocal内存泄漏问题
│   │   │   │   ├─01.第一节-threadlocal内存泄漏常见面试题.mp4     78.83MB
│   │   │   │   ├─02.第二节-threadlocal应用场景有哪些.mp4     53.21MB
│   │   │   │   ├─03.第三节-threadlocal底层实现原理.mp4     63.38MB
│   │   │   │   ├─04.第四节-为什么线程缓存的是ThreadlocalMap对象.mp4     57.8MB
│   │   │   │   ├─05.第五节-强、软、弱引用之间的区别.mp4     71.54MB
│   │   │   │   ├─06.第六节-threadlocal内存泄漏问题.mp4     104.18MB
│   │   │   │   ├─07.第七节-threadlocal如何避免内存泄漏.mp4     46.31MB
│   │   │   │   └─code.rar     28.2KB
│   │   │   └─04.第四章-aqs底层架构设计原理
│   │   │         ├─01.第一节-谈谈Lock与synchronized区别.mp4     54.61MB
│   │   │         ├─02.第二节-LockSupport用法 .mp4     29.72MB
│   │   │         ├─03.第三节-aqs底层如何实现原理.mp4     228.08MB
│   │   │         ├─04.第四节-cas+LockSupport+aqs手写Lock锁.mp4     181.85MB
│   │   │         ├─05.第五节-Semaphore信号量底层原理.mp4     37.57MB
│   │   │         ├─06.第六节-CountDownLatch底层实现原理.mp4     22.54MB
│   │   │         └─code.rar     39.83KB
│   │   ├─相关开发工具.txt     96B
│   │   └─资料Code相关下载.txt     196B
│   ├─02、java进阶第十期
│   │   ├─001-第十期-SpringBoot源码解读-SpringBoot原理分析
│   │   │   ├─01.第一节.简单回顾springboot概念ev.mp4     40.29MB
│   │   │   ├─02.第二节.springboot设计原理ev.mp4     139.26MB
│   │   │   ├─03.第三节-spring有哪些注解ev.mp4     36.42MB
│   │   │   ├─04.第四节-基于xml方式启动springev.mp4     43.04MB
│   │   │   ├─05.第五节-基于注解方式启动springev.mp4     39.11MB
│   │   │   ├─06.第六节-@ComponentScan用法ev.mp4     33.09MB
│   │   │   ├─07.第七节-如何注解方式启动springmvcev.mp4     113.16MB
│   │   │   ├─08.第八节-注解启动springmvc返回json格式ev.mp4     53.08MB
│   │   │   ├─09.第九节.解决注解启动springmvc返回jsonbug问题ev.mp4     49.45MB
│   │   │   └─10.第十节-注解启动springmvc总结ev.mp4     9.22MB
│   │   ├─0018.蚂蚁课堂&-第十期-SpringBoot源码解读-springcloud-sentinel服务接口保护
│   │   │   └─18.mp4     1.73GB
│   │   ├─002-第十期-设计微服务框架-自定义Springboot-Starter插件-纯手写微服务服务注册中心
│   │   │   ├─01.第一节-演示springboot自定义starter插件效果ev.mp4     60.67MB
│   │   │   ├─02.第二节-什么是springboot-starterev.mp4     48.44MB
│   │   │   ├─03.第三节-自定义springboot-starter插件ev.mp4     201.72MB
│   │   │   ├─04.第四节-如何支持idea提示配置文件内容ev.mp4     19.76MB
│   │   │   ├─05.第五节-如何设计微服务框架之服务注册中心架构原理ev.mp4     43.35MB
│   │   │   ├─06.第六节-纯手写独立设计微服务注册中心Server端-服务注册ev.mp4     127MB
│   │   │   ├─07.第七节-纯手写独立设计微服务注册中心Server端-提供活跃接口查询ev.mp4     15.63MB
│   │   │   ├─08.第八节-自定义服务注册中心客户端springboot-starter插件ev.mp4     160.68MB
│   │   │   └─09.第九节-测试编写的服务注册中心客户端starter插件ev.mp4     108.24MB
│   │   ├─003-第十期-设计微服务框架-自定义Springboot-Starter插件-微服务注册中心续约与剔除实现
│   │   │   ├─00.第零节-手写服务注册中心整体效果演示.mp4     36.7MB
│   │   │   ├─01.第一节-演示手写服务注册中心续约与剔除效果-u.mp4     284.58MB
│   │   │   ├─02.第二节-如何保证注册中心服务注册线程安全性-u.mp4     356.52MB
│   │   │   ├─03.第三节-客户端正常宕机-服务注册中心服务剔除如何实现-u.mp4     466.65MB
│   │   │   ├─04.第四节-客户端非正常宕机-服务注册中心服务剔除如何实现-u.mp4     501.44MB
│   │   │   ├─05.第五节..客户端如果注册多次失败如何触发重试策略-u.mp4     269.44MB
│   │   │   └─资料.zip     195.75KB
│   │   ├─004-第十期-设计微服务框架-Eureka源码解读之服务注册-发现-高可用源码解读
│   │   │   ├─01.第一节-Eureka源码入口如何分析.mp4     77.08MB
│   │   │   ├─02.第二节-Eureka客户端如何实现服务注册.mp4     150.59MB
│   │   │   ├─03.第三节-Eureka服务器端服务注册接口源码解读.mp4     113.58MB
│   │   │   ├─04.第四节-Eureka服务器端服务注册接口如何存入接口地址.mp4     227.42MB
│   │   │   └─05.第五节-Eureka客户端正常宕机服务剔除实现.mp4     199.36MB
│   │   ├─005-第十期-设计微服务框架-Eureka源码解读之高可用Ap模式源码解读-bate非剪辑版本
│   │   │   └─10.05.bate版本非剪辑版本.mp4     526.27MB
│   │   ├─006-第十期-设计微服务框架-自定义Springboot-Starter插件-手写分布式配置中心框架
│   │   │   ├─00.前后端整合模式演示分布式配置中心框架.mp4     40.19MB
│   │   │   ├─01.第一节-演示手写分布式配置中心框架.mp4     60.4MB
│   │   │   ├─02.第二节-分布式配置中心架构设计原理.mp4     28.19MB
│   │   │   ├─03.第三节-分布式配中心原理总结.mp4     51.35MB
│   │   │   ├─04.第四节-Environment手动获取配置文件内容.mp4     142.37MB
│   │   │   ├─05.第五节-@value注解读取配置文件原理.mp4     143.53MB
│   │   │   ├─06.第六节-代码纯手写构建分布式配置中心思路分析.mp4     36.73MB
│   │   │   ├─07.第七节-代码纯手写分布式配置中心服务器端.mp4     123.82MB
│   │   │   ├─08.第八节-代码纯手写分布式配置中心客户端.mp4     302.78MB
│   │   │   ├─09.第九节-代码纯手写长轮询动态刷新配置文件.mp4     231.77MB
│   │   │   ├─10.第十节-演示纯手写分布式配置中心框架整体效果.mp4     120.75MB
│   │   │   └─11.第十一节-分布式配置中心手写常见问题.mp4     123.72MB
│   │   ├─007-第十期-设计微服务框架-自定义Springboot-Starter插件-手写openfeign客户端RPC框架-bate非剪辑版本
│   │   │   └─10.07.mp4     677.78MB
│   │   ├─008-第十期-设计微服务框架-自定义Springboot-Starter插件-改造手写openfeign客户端去除继承模式-bate非剪辑版本.rar
│   │   │   └─11.14-未剪辑版本.mp4     831.67MB
│   │   ├─009-第十期-设计微服务框架-分布式任务调度平台XXL-JOB架构设计原理-bate非剪辑版本
│   │   │   └─10.09—未剪辑版本.mp4     892.02MB
│   │   ├─010-第十期-设计微服务框架-纯手写设计微服务动态网关-bate非剪辑版本
│   │   │   └─10.10.mp4     660.88MB
│   │   ├─011-第十期-设计微服务框架-纯手写设计微服务动态网关-bate非剪辑版本
│   │   │   └─10.11.mp4     856.69MB
│   │   ├─012-第十期-设计微服务框架-构建企业级微信公众号消息模板推送
│   │   │   └─10.13.mp4     1.33GB
│   │   ├─013-第十期-设计微服务框架-构建及skyWalking监控服务
│   │   │   └─10.13.mp4     1.33GB
│   │   ├─014-第十期-设计微服务框架-elk+kafka分布式日志采集系统设计
│   │   │   └─10.15.mp4     952.83MB
│   │   ├─015-第十期-设计微服务框架-纯手写封装服务限流框架
│   │   │   └─10.15.mp4     739MB
│   │   ├─016-第十期-设计微服务框架-手写令牌桶和漏桶算法
│   │   │   └─10.17.mp4     1.1GB
│   │   ├─018-第十期-设计微服务框架-springcloud-sentinel网关整合
│   │   │   └─10.19.mp4     522.32MB
│   │   ├─020-第十期-分布式解决方案-双写一致性协议与延迟双删策略
│   │   │   ├─01.第一节-使用redis缓存用法.mp4     57.17MB
│   │   │   ├─02.第二节-先删除缓存在更新DB-延迟双删策略.mp4     90.27MB
│   │   │   ├─03.第三节-先更新DB在删除缓存.mp4     77.81MB
│   │   │   ├─04.第四节-先删除缓存在更新db还是先更新db在删除缓存.mp4     15.66MB
│   │   │   ├─05.第五节-什么是双写一致性协议.mp4     84.4MB
│   │   │   └─06.第六节-如何解决双写一致性协议数据一致性问题.mp4     99.26MB
│   │   ├─021-第十期-分布式解决方案-canal整合kafka同步数据消息顺序一致性问题
│   │   │   ├─01.第一节-kafka消费消息的模型原理.mp4     116.55MB
│   │   │   ├─02.第二节-kafka解决消息顺序一致性问题核心点.mp4     29.63MB
│   │   │   ├─03.第三节-kafka消息分区模型架构设计.mp4     106.08MB
│   │   │   ├─04.第四节-canal整合kafka分区模型.mp4     306.21MB
│   │   │   ├─06.canal整合kafka topic模式.mp4     73.46MB
│   │   │   ├─06.第六节-canal整合kaka分区模型注意事项事项.mp4     22.95MB
│   │   │   └─07.第七节-演示canal整合kakfa实现分区模型消费方式.mp4     224.59MB
│   │   ├─022-第十期-分布式解决方案-基于MQ最终一致性解决分布式事务问题
│   │   │   ├─01.分布式事务产生背景概述.mp4     89.83MB
│   │   │   ├─02.演示分布式事务发生场景.mp4     203.21MB
│   │   │   ├─03.base和cap理论.mp4     76.12MB
│   │   │   ├─04.基于rabbitmq解决分布式事务原理.mp4     56.3MB
│   │   │   ├─05.如何确保生产者投递消息到MQ服务器端一定成功.mp4     58.07MB
│   │   │   ├─06.消费者如何确保消息一定消费成功.mp4     47.46MB
│   │   │   ├─07.演示如何基于rabbitmq解决分布式事务问题.mp4     107.68MB
│   │   │   └─08.使用mq解决分布式事务问题如何降低延迟.mp4     37.26MB
│   │   ├─023-第十期-分布式解决方案-基于LCN解决分布式事务问题和源码解读
│   │   │   ├─01.回顾上节课分布式事务内容.mp4     38.05MB
│   │   │   ├─02.LCN框架的基本介绍.mp4     222.83MB
│   │   │   ├─03.LCN框架LCN模式设计原理.mp4     112.35MB
│   │   │   ├─04.搭建LCN协调者环境.mp4     164.79MB
│   │   │   ├─05.LCN客户端流程详细解读.mp4     149MB
│   │   │   ├─06.LCN源码解读之发起方如何获取全局事务id.mp4     214.04MB
│   │   │   └─07.LCN源码解读之参与方如何获取全局事务id.mp4     164.22MB
│   │   ├─024-第十期-分布式解决方案-seata解决分布式事务问题原理演示
│   │   │   ├─01.seata解决分布式事务问题效果演示.mp4     164.98MB
│   │   │   ├─02.seata基本的介绍.mp4     73.98MB
│   │   │   ├─03.seata角色的划分.mp4     36.31MB
│   │   │   ├─04.seata发起方获取全局事务id源码解读.mp4     129.8MB
│   │   │   ├─05.seata如何实现逆向回滚.mp4     179.11MB
│   │   │   └─06.seata at模式解决分布式事务效果演示.mp4     186.03MB
│   │   ├─025-第十期-分布式解决方案-seata高可用环境搭建
│   │   │   ├─01.简单回顾seata at模式实现原理.mp4     41.97MB
│   │   │   ├─02.seataServer环境构建配置.mp4     110.15MB
│   │   │   ├─03.上传配置文件到nacos中.mp4     74.52MB
│   │   │   ├─04.seata客户端的整合方式.mp4     79.67MB
│   │   │   ├─05.seataserver高可用设计.mp4     96.1MB
│   │   │   ├─06.undolog日志与当前数据不一致如何处理.mp4     115.95MB
│   │   │   └─07.undolog日志逆向生成sql语句回滚原理.mp4     125.74MB
│   │   ├─026-第十期-分布式解决方案-seata tcc模式架构原理
│   │   │   ├─01.简单回顾2PC两阶段提交协议思想.mp4     51.4MB
│   │   │   ├─02.TCC模式解决分布式事务问题效率演示.mp4     96.57MB
│   │   │   ├─03.TCC模式架构设计原理.mp4     99.12MB
│   │   │   └─04.seata代码如何整合TCC模式.mp4     304.42MB
│   │   ├─027-第十期-项目运维管理-微服务架构项目如何灰度发布
│   │   │   ├─01.灰度发布效果演示.mp4     83.36MB
│   │   │   ├─02.什么是灰度发布.mp4     41.13MB
│   │   │   ├─03.gateway+nacos实现灰度发布原理.mp4     144.3MB
│   │   │   ├─04.代码落地实战灰度发布.mp4     417.88MB
│   │   │   └─05.灰度发布环境测试.mp4     33.91MB
│   │   ├─028-第十期-运维部署-云服务器部署springboot项目
│   │   │   ├─01.第一节-宝塔部署项目演示.mp4     39.57MB
│   │   │   ├─02.第二节-专线与普通宽带区别.mp4     36.4MB
│   │   │   ├─03.第三节-SaasPaasIaaS概念.mp4     40.53MB
│   │   │   ├─04.第四节-iass基础云服务器厂商如何选择.mp4     13.19MB
│   │   │   ├─05.第五节-登录云服务器.mp4     55.3MB
│   │   │   ├─06.第六节-如何在云服务器安装jdk环境.mp4     31.62MB
│   │   │   ├─07.第七节-在云服务器部署springboot项目.mp4     93.19MB
│   │   │   ├─08.第八节-在云服务器如何安装宝塔.mp4     75.4MB
│   │   │   ├─09.第九节-使用宝塔安装nginx和docker.mp4     36.33MB
│   │   │   ├─10.第十节-配置云服务器nginx反向代理.mp4     91.05MB
│   │   │   └─11.第十一节-云服务器使用docker部署springboot项目.mp4     56.31MB
│   │   ├─029-第十期-运维部署-openresty整合lua脚本实现灰度发布
│   │   │   ├─01.第一节.什么是openresty.mp4     68.66MB
│   │   │   ├─02.第二节-安装openresty.mp4     20.15MB
│   │   │   ├─03.第三节-openresty快速入门.mp4     40.9MB
│   │   │   ├─04.第四节.openresty整合lua脚本连接mysql.mp4     87.15MB
│   │   │   ├─05.第五节.openresty整合lua脚本多级缓存.mp4     130.8MB
│   │   │   ├─06.第六节-nginx实现灰度发布实现原理.mp4     157.12MB
│   │   │   └─07.第七节-nginx整合lua脚本实现灰度发布.mp4     183.23MB
│   │   ├─030-第十期-运维部署-docker进阶网络知识
│   │   │   ├─01.第一节-docker容器网络如何运行?01.mp4     17.86MB
│   │   │   ├─01.第一节-docker容器网络如何运行?02.mp4     113.47MB
│   │   │   ├─01.第一节-docker容器网络如何运行?03.mp4     109.15MB
│   │   │   ├─02.第二节-五种docker容器网络模型01.mp4     62.53MB
│   │   │   ├─02.第二节-五种docker容器网络模型02.mp4     57.33MB
│   │   │   ├─03.第三节-network之bridg(桥)模式01.mp4     6.51MB
│   │   │   ├─03.第三节-network之bridg(桥)模式02.mp4     27.49MB
│   │   │   ├─03.第三节-network之bridg(桥)模式03.mp4     41.97MB
│   │   │   ├─03.第三节-network之bridg(桥)模式04.mp4     15.66MB
│   │   │   ├─03.第三节-network之bridg(桥)模式05.mp4     19.48MB
│   │   │   ├─04.第四节-network之host(主机)模式01.mp4     116.53MB
│   │   │   ├─04.第四节-network之host(主机)模式02.mp4     4.03MB
│   │   │   ├─04.第四节-network之host(主机)模式03.mp4     28.04MB
│   │   │   ├─04.第四节-network之host(主机)模式04.mp4     14.74MB
│   │   │   ├─05.第五节network之node模式.mp4     15.63MB
│   │   │   ├─06.第六节network之容器模式.mp4     93.19MB
│   │   │   ├─07.第七节-network之自定义网络01.mp4     10.78MB
│   │   │   ├─07.第七节-network之自定义网络02.mp4     37.16MB
│   │   │   ├─07.第七节-network之自定义网络03.mp4     71.76MB
│   │   │   ├─07.第七节-network之自定义网络04.mp4     5.13MB
│   │   │   ├─docker-compose.yml     749B
│   │   │   └─docker.doc     3.35MB
│   │   ├─031-第十期-运维部署-k8s集群环境搭建
│   │   │   ├─01.k8s课程内容安排.mp4     79.08MB
│   │   │   ├─02.为什么需要使用k8s.mp4     35.58MB
│   │   │   ├─03.k8s应用场景有哪些.mp4     50.31MB
│   │   │   ├─04.k8s架构设计原理.mp4     56.68MB
│   │   │   ├─05.k8s集群环境演示架构设计原理.mp4     119.13MB
│   │   │   ├─06.k8s集群环境搭建准备.mp4     79.52MB
│   │   │   ├─07.k8s初始化集群环境.mp4     173.81MB
│   │   │   ├─08.安装docker环境.mp4     54.57MB
│   │   │   ├─09.安装k8s集群环境.mp4     111.5MB
│   │   │   ├─10.k8s集群环境初始化—-注意xshell窗口要单独.mp4     144.53MB
│   │   │   ├─11.安装k8s网络插件.mp4     94.01MB
│   │   │   ├─12.演示k8s安装nginx.mp4     73.4MB
│   │   │   ├─13.谈谈大家安装k8s常见错误.mp4     177.21MB
│   │   │   └─资料.zip     195.75KB
│   │   ├─032-第十期-运维部署-k8s常用组件原理未剪辑
│   │   │   └─k8s第二次课.mp4     1000.81MB
│   │   ├─033-第十期-运维部署-k8s整体组件原理解析未剪辑
│   │   │   └─33.mp4     659.86MB
│   │   ├─034-第十期-运维部署-k8spod详解
│   │   │   ├─podev【 瑞客论 坛 www.ruike1.com】.mp4     501.65MB
│   │   │   └─资料.zip     195.75KB
│   │   ├─035-第十期-运维部署-k8spod生命周期
│   │   │   └─pod-生命周期ev.mp4     459.81MB
│   │   ├─036-第十期-运维部署-k8s-pod调度策略
│   │   │   └─0.36ev.mp4     325.84MB
│   │   ├─037-第十期-运维部署-k8s-deployment详解
│   │   │   └─0.37ev.mp4     499.98MB
│   │   ├─038-第十期-运维部署-k8s-hpa详解
│   │   │   └─10.38ev.mp4     364.43MB
│   │   ├─039-第十期-运维部署-k8s-service
│   │   │   └─39.k8sev.mp4     331.57MB
│   │   ├─040-第十期-运维部署-k8s-实战部署springboot项目
│   │   │   ├─0040ev.mp4     403.18MB
│   │   │   └─资料.zip     27.48MB
│   │   ├─课程资料
│   │   │   ├─第十期.所有课程资料-2021年12月17日更新
│   │   │   │   ├─01.1-7微服务解决方案
│   │   │   │   │   ├─01.第一次课设计微服务框架源码01
│   │   │   │   │   │   └─01.第一次课设计微服务框架源码01.rar     22.4KB
│   │   │   │   │   ├─05.第五次课设计eureka集群源码解读
│   │   │   │   │   │   └─05.第五次课设计eureka集群源码解读.rar     43.5KB
│   │   │   │   │   ├─08.第八次课-改造手写feign客户端
│   │   │   │   │   │   └─08.第八次课-改造手写feign客户端.rar     131.16KB
│   │   │   │   │   ├─mayikt-spring
│   │   │   │   │   │   └─mayikt-spring.rar     11.89KB
│   │   │   │   │   ├─mayikt-spring-boot-starter
│   │   │   │   │   │   └─mayikt-spring-boot-starter.rar     10.02KB
│   │   │   │   │   ├─mayikt-springmvc
│   │   │   │   │   │   └─mayikt-springmvc.rar     14.45KB
│   │   │   │   │   ├─第七次课-手写openfeign客户端RPC框架
│   │   │   │   │   │   └─mayikt-opefeign-parent.rar     13.92KB
│   │   │   │   │   ├─第三次课设计微服务框架源码03
│   │   │   │   │   │   └─mayikt-springcloud.rar     29.51KB
│   │   │   │   │   ├─第二次课设计微服务框架源码02
│   │   │   │   │   │   └─第二次课设计微服务框架源码02.rar     61.84KB
│   │   │   │   │   └─第六次手写分布式配置中心代码
│   │   │   │   │         └─mayikt-cloud.rar     93.72KB
│   │   │   │   ├─019-sentinel网关整合
│   │   │   │   │   └─mayikt-apm
│   │   │   │   │         └─mayikt-apm.rar     77.12KB
│   │   │   │   ├─09.分布式任务调度平台
│   │   │   │   │   └─09.分布式任务调度平台.rar     6.22MB
│   │   │   │   ├─10.独立设计微服务网关
│   │   │   │   │   └─10.独立设计微服务网关.rar     73.78KB
│   │   │   │   ├─11.设计动态网关
│   │   │   │   │   └─11.设计动态网关.rar     1.39MB
│   │   │   │   ├─12.分布式服务追踪框架设计原理
│   │   │   │   │   ├─mayikt-opefeign-parent
│   │   │   │   │   │   └─mayikt-opefeign-parent.rar     17.46KB
│   │   │   │   │   └─zipkin-server-2.11.8-exec.jar     36.69MB
│   │   │   │   ├─13.构建企业级微服务公众号平台
│   │   │   │   │   └─13.构建企业级微服务公众号平台.rar     54.36KB
│   │   │   │   ├─14.SkyWalking整合
│   │   │   │   │   └─14.SkyWalking整合.rar     164.58MB
│   │   │   │   ├─15.elk+kafka
│   │   │   │   │   └─15.elk+kafka.rar     170.54MB
│   │   │   │   ├─16.封装限流框架
│   │   │   │   │   └─16.封装限流框架.rar     2.73MB
│   │   │   │   ├─17.限流算法原理
│   │   │   │   │   └─17.限流算法原理.rar     42.4KB
│   │   │   │   ├─18.sentinel
│   │   │   │   │   ├─apache-jmeter-4.0
│   │   │   │   │   │   └─apache-jmeter-4.0.rar     43.39MB
│   │   │   │   │   ├─mayikt-apm
│   │   │   │   │   │   └─mayikt-apm.rar     39.44KB
│   │   │   │   │   ├─sentinel-dashboard-1.7.1.jar     20.22MB
│   │   │   │   │   └─笔记.doc     10KB
│   │   │   │   └─20-canal解决mysql与redis数据一致性问题
│   │   │   │         └─20-canal解决mysql与redis数据一致性问题.rar     16.15KB
│   │   │   └─语雀.txt     119B
│   │   └─赠送-第十期-SpringCloudAlibaba
│   │         ├─01.springcloudalibaba服务治理基本概念
│   │         │   ├─剪辑之后
│   │         │   │   ├─06.第六节.什么是SpringCloud.mp4     67.05MB
│   │         │   │   ├─07.第七节-远程调用的基本概念.mp4     115.32MB
│   │         │   │   ├─09.第九节-使用httpClient实现RPC远程调用.mp4     81.7MB
│   │         │   │   ├─10.第十节-使用HttpClient调用天气预报接口.mp4     86.26MB
│   │         │   │   ├─11.第十一节-什么是服务治理.mp4     165.9MB
│   │         │   │   ├─12.第十二节-创建生产者接口.mp4     72.46MB
│   │         │   │   ├─13.第十三节-创建消费者项目.mp4     39.99MB
│   │         │   │   ├─14.第十四节-演示如果没有治理调用接口现象.mp4     40.39MB
│   │         │   │   ├─15.第十五节-构建eurekaServer端项目.mp4     131.01MB
│   │         │   │   ├─16.第十六节-构建eurekaclient端服务注册.mp4     65.4MB
│   │         │   │   ├─17.第十七节-创建eurekaClient服务发现.mp4     125.96MB
│   │         │   │   └─SpringCloudAlibaba入门到精通.jpg     141.15KB
│   │         │   └─课程目录.txt     181B
│   │         ├─02.springcloudalibabaNacos服务注册中心
│   │         │   └─视频
│   │         │         ├─01.第一节-什么是Nacos.mp4     95.63MB
│   │         │         ├─02.第二节-如何启动nacosServer端.mp4     134.62MB
│   │         │         ├─03.第三节-如何手动实现服务的注册到Nacos.mp4     96.76MB
│   │         │         ├─04.第四节-整合nacosClient实现服务注册源码解读.mp4     309.5MB
│   │         │         ├─05.第五节-整合nacosClient实现服务发现.mp4     71.93MB
│   │         │         └─06.第六节-整合resttemplate.mp4     125.77MB
│   │         ├─03.springcloudalibaba本地负载均衡器
│   │         │   └─视频
│   │         │         ├─01.第一节-手写本地负载均衡器-轮询算法.mp4     286.09MB
│   │         │         ├─02.第二节-手写本地负载均衡器-随机算法.mp4     109.81MB
│   │         │         ├─03.第三节-消费者获取到宕机地址调用报错,如何故障转移.mp4     161.52MB
│   │         │         ├─04.第四节-权重算法如何实现思路.mp4     153.27MB
│   │         │         ├─05.第五节-手写本地负载均衡器-权重算法.mp4     109.17MB
│   │         │         ├─06.第六节-ribbon负载均衡器实使用.mp4     75.64MB
│   │         │         ├─07.第七节-ribbon负载均衡器轮询算法实现源码解读.mp4     84.52MB
│   │         │         ├─08.第八节-ribbon负载均衡器如何整合随机算法.mp4     54.29MB
│   │         │         └─09.第九节-ribbon整合nacos客户端权重算法.mp4     118.49MB
│   │         ├─04.springcloudalibabanacos集群部署方案
│   │         │   ├─01.第一节-Nacos如何实现集群.mp4     136.55MB
│   │         │   ├─02.第二节-Nacos构建集群方式注意事项.mp4     150.67MB
│   │         │   ├─03.第三节-正确方式构建Nacos集群.mp4     100.41MB
│   │         │   ├─04.第四节-Nacos客户端随机注册算法.mp4     127.15MB
│   │         │   └─05.第五节-Nacos客户端实现服务集群注册原理.mp4     65.44MB
│   │         └─springcloudalibaba资料和代码
│   │               ├─01.springcloudalibaba服务治理基本概念.zip     101.5KB
│   │               ├─02.springcloudalibabaNacos服务注册中心.zip     112.25MB
│   │               ├─03.springcloudalibaba本地负载均衡器.zip     243.86KB
│   │               ├─04.springcloudalibabanacos集群部署方案.zip     321.07MB
│   │               └─springcloudalibaba文档.zip     897.98KB
│   ├─03、java进阶第九期
│   │   ├─000-第九期课程文档资料
│   │   │   └─000-第九期课程文档资料.rar     163.16MB
│   │   ├─000.第九期-开班相关说明
│   │   │   ├─01.第一节-第九期上课时间安排ev.mp4     47.01MB
│   │   │   ├─02.第二节-常用开发的工具整理ev.mp4     24.2MB
│   │   │   ├─03第三节-程序员如何选择电脑配置ev.mp4     15.54MB
│   │   │   ├─04.第四节-腾讯课堂上课标题不一致的问题ev.mp4     16.02MB
│   │   │   ├─05.第五节-第九期新增了哪些知识点01ev.mp4     52.24MB
│   │   │   ├─06.第六节-第九期新增了哪些知识点02ev.mp4     95.57MB
│   │   │   ├─07.第七节-程序员开发资料如何下载ev.mp4     15.11MB
│   │   │   └─09.00第九期开班相关说明ev.mp4     262.14MB
│   │   ├─001.第九期-基础知识回顾之掌握Java反射自定义注解底层设计原理与封装限流的框架
│   │   │   ├─01.第一节-反射与自定义原理课程安排ev.mp4     14.32MB
│   │   │   ├─02.第二节-什么是反射&反射基本概念ev.mp4     35.62MB
│   │   │   ├─03.第三节-反射的应用场景ev.mp4     12.82MB
│   │   │   ├─04.第四节-反射机制使用的三种方式ev.mp4     54.3MB
│   │   │   ├─05.第五节-使用反射机制初始化对象ev.mp4     24.7MB
│   │   │   ├─06.第六节-反射如何给属性赋值ev.mp4     34.65MB
│   │   │   ├─07.第七节-使用反射机制调用方法ev.mp4     30.42MB
│   │   │   ├─08.第八节-反射如何越过泛型检查ev.mp4     19.99MB
│   │   │   ├─09.第九节-注解的基本概念与介绍ev.mp4     60.84MB
│   │   │   ├─10.第十节-使用guava对微服务接口实现限流ev.mp4     18.83MB
│   │   │   ├─11.第十一节-使用aop环绕通知拦截目标方法01ev.mp4     36.79MB
│   │   │   ├─12.第十二节-使用aop环绕通知拦截目标方法02ev.mp4     73.86MB
│   │   │   ├─13.第十三节-使用aop+反射+自定义注解实现限流框架ev.mp4     59.35MB
│   │   │   └─资料.zip     195.75KB
│   │   ├─002.第九期-基础知识回顾之多线程快速入门与实际项目如何整合多线程
│   │   │   ├─01.第一节-多线程第一次课程内容安排.mp4     72.86MB
│   │   │   ├─02.第二节-什么是线程、进程.mp4     73.71MB
│   │   │   ├─03.第三节-为什么在进程中还需要线程呢.mp4     20.03MB
│   │   │   ├─04.第四节-为什么需要使用多线程与单与并行区别.mp4     70.87MB
│   │   │   ├─05.第五节-使用多线程一定提高效率吗.mp4     118.53MB
│   │   │   ├─06.第六节-多线程的应用场景有哪些呢.mp4     33.79MB
│   │   │   ├─07.第七节-同步与异步之间的区别.mp4     19.99MB
│   │   │   ├─08.第八节-继承Thread类创建线程.mp4     62.86MB
│   │   │   ├─09.第九节-实现Runnable接口创建线程.mp4     37.3MB
│   │   │   ├─10.第十节-使用Callable和Future创建线程.mp4     126.72MB
│   │   │   ├─11.第十一节-使用线程池的方式创建线程.mp4     22.9MB
│   │   │   ├─12.第十二节-@Async异步注解创建线程.mp4     86.08MB
│   │   │   └─13.第十三节-手写@Async异步注解.mp4     126.99MB
│   │   ├─003.第九期-基础知识回顾之synchronized锁使用与线程之间如何实现通讯
│   │   │   ├─01.第一节-什么是线程安全问题.mp4     106.41MB
│   │   │   ├─02.第二节-如何解决线程安全问题.mp4     110.76MB
│   │   │   ├─03.第三节-synchronized锁基本的用法01.mp4     68.17MB
│   │   │   ├─04.第四节-synchronized锁基本的用法02.mp4     63.62MB
│   │   │   ├─05.第五节-synchronized死锁问题.mp4     74.76MB
│   │   │   ├─06.第六节-如何诊断synchronized死锁问题.mp4     25.73MB
│   │   │   ├─07.第七节-如何保证线程同步问题.mp4     22.1MB
│   │   │   ├─08.第八节-springmvc接口中使用synchronized.mp4     72.78MB
│   │   │   ├─09.第九节-使用wait、notify注意事项.mp4     61.05MB
│   │   │   ├─10.第十节-wait、notify生产者与消费者模型01.mp4     90.09MB
│   │   │   ├─11.第十一节-wait、notify生产者与消费者模型02.mp4     104.67MB
│   │   │   └─code.zip     810.79KB
│   │   ├─004.第九期-基础知识回顾之多线程核心API与Lock锁使用
│   │   │   ├─01.第一节-画图分析wait与notify实现原理.mp4     225.61MB
│   │   │   ├─02.第二节-join方法底层的设计原理.mp4     124.34MB
│   │   │   ├─03.第三节-多线程底层七种状态.mp4     95.88MB
│   │   │   ├─04.第四节-sleep防止CPU占用100%.mp4     45.84MB
│   │   │   ├─05.第五节-守护与用户线程的区别.mp4     31.6MB
│   │   │   ├─06.第六节-如何安全的停止一个线程.mp4     66.83MB
│   │   │   ├─07.第七节-lock与synchronized的区别.mp4     26.68MB
│   │   │   ├─08.第八节-简单演示lock锁使用方式01.mp4     77.32MB
│   │   │   ├─09.第九节-简单演示lock锁使用方式02.mp4     22.79MB
│   │   │   ├─10.第十节-lock的condition用法.mp4     45.3MB
│   │   │   ├─11.第十一节-多线程的yield方法使用.mp4     30.11MB
│   │   │   ├─12.第十二节-多线程的优先级.mp4     35.31MB
│   │   │   ├─13.第十三节-wait与sleep之间的区别.mp4     32.13MB
│   │   │   └─14.第十四节-为什么wait和notify在object父类中.mp4     20.27MB
│   │   ├─005.第九期-基础知识回顾之多线程综合实战案例与纯手写日志框架
│   │   │   ├─01.第一节-字节码指令角度分析线程安全问题.mp4     134.64MB
│   │   │   ├─02.第二节-画图分析字节码指令角度分析线程安全问题.mp4     60.98MB
│   │   │   └─03.第三节-Callable与FutureTask原理分析01.mp4     3.38MB
│   │   ├─006.第九期-JUC并发编程之CAS原子类底层原理
│   │   ├─007.第九期-JUC并发编程之基于cas+LockSupport锁手写锁的升级过程
│   │   │   ├─01.第一节-如何手写重入锁.mp4     139.67MB
│   │   │   ├─02.第二节-代码纯手写重入锁.mp4     94.64MB
│   │   │   ├─03.第三节-偏向锁轻量级锁重量级锁应用场景01.mp4     101.55MB
│   │   │   ├─04.第四节-偏向锁和轻量锁和重量锁引用场景02.mp4     104.81MB
│   │   │   ├─05.第五节-画图分析手写cas锁底层原理.mp4     53.93MB
│   │   │   ├─06.第六节-手写轻量锁升级的过程.mp4     87.46MB
│   │   │   ├─07.第七节-源码调试手写轻量锁升级过程.mp4     99.46MB
│   │   │   ├─08.第八节-纯手写轻量锁升级过程课程疑问总结.mp4     18.59MB
│   │   │   ├─09.第九节-偏向锁与重入锁之间的区别.mp4     61.43MB
│   │   │   ├─10.第十节-公平锁与非公平锁的区别.mp4     100.28MB
│   │   │   └─资料.zip     196.07KB
│   │   ├─008.第九期-JUC并发编程之从对象角度获取synchronized升级过程
│   │   │   ├─01.第一节-偏向锁轻量级锁重量级锁应用场景.mp4     101.55MB
│   │   │   ├─02.第二节-java对象的布局底层实现原理.mp4     159.74MB
│   │   │   ├─03.第三节-new出一个对象至少占用多少字节.mp4     42.19MB
│   │   │   ├─04.第四节-对象内存中offset作用.mp4     69.95MB
│   │   │   ├─05.第五节-通过对象头获取锁的升级信息.mp4     130.35MB
│   │   │   ├─06.第六节-如何在对象头获取HashCode.mp4     80.62MB
│   │   │   ├─07.第七节-如何从对象头获取偏向锁.mp4     68.13MB
│   │   │   ├─08.第八节-如何从对象头获取轻量锁.mp4     68.09MB
│   │   │   ├─09.第九节-完整链演示锁的升级过程.mp4     98.62MB
│   │   │   ├─10.第十节-如何从对象头锁的信息课程总结.mp4     40.91MB
│   │   │   └─资料.zip     196.07KB
│   │   ├─009.第九期-JUC并发编程之synchronized锁升级过程原理分析
│   │   │   ├─01.第一节-简单回顾对象头与锁的升级过程.mp4     76.13MB
│   │   │   ├─02.第二节-画图分析synchronized轻量锁获取锁实现原理.mp4     127.47MB
│   │   │   ├─03.第三节-画图分析synchronized轻量锁释放锁原理.mp4     183.18MB
│   │   │   ├─04.第四节-画图分析synchronized轻量锁释放锁原理.mp4     20.72MB
│   │   │   ├─05.第五节-字节码角度分析Monitor指令.mp4     97.25MB
│   │   │   ├─06.第六节-Monitor指令分析.mp4     66.85MB
│   │   │   ├─07.第七节-Monitor虚拟机源码解读分析.mp4     106.18MB
│   │   │   └─资料.zip     196.07KB
│   │   ├─010.第九期-JUC并发编程之画图分析synchronized锁的升级过程
│   │   │   ├─01.第一节-synchronized终极底层原理总结介绍.mp4     30.18MB
│   │   │   ├─02.第二节-画图分析synchronized偏向锁原理01【[】.mp4     113.91MB
│   │   │   ├─03.第三节-画图分析synchronized撤销原理.mp4     54.29MB
│   │   │   ├─04.第四节-画图分析synchronized轻量级锁原理【-】.mp4     118.53MB
│   │   │   ├─05.第五节-画图分析synchronized重量级锁原理.mp4     53.62MB
│   │   │   ├─06.第六节-画图分析synchronized批量重偏向锁.mp4     145.37MB
│   │   │   ├─07.第七节-画图分析synchronized批量撤销.mp4     65.95MB
│   │   │   ├─08.第八节-synchronized锁的粗化.mp4     17.16MB
│   │   │   ├─09.第九节-synchronized锁的消除.mp4     23.68MB
│   │   │   └─09.第十节-完整文字版本总结synchronized原理.mp4     130.97MB
│   │   ├─011.第九期-JUC并发编程之Threadlocal如何避免内存泄漏问题
│   │   │   ├─01.第一节-Threadlocal原理解析课程内容安排.mp4     19.27MB
│   │   │   ├─02.第二节-Threadlocal基本的用法.mp4     41.27MB
│   │   │   ├─03.第三节-Threadlocal应用场景有哪些..mp4     50.3MB
│   │   │   ├─04.第四节-Threadlocal真实例子讲解..mp4     113.42MB
│   │   │   ├─05.第五节-内存泄漏与内存溢出区别.mp4     27.91MB
│   │   │   ├─06.第六节-什么是强引用.mp4     52.98MB
│   │   │   ├─07.第七节-什么是软引用.mp4     63.3MB
│   │   │   ├─08.第八节-什么是弱引用.mp4     27.24MB
│   │   │   ├─09.第九节-Threadlocal底层源码解读.mp4     116.58MB
│   │   │   ├─10.第十节-Threadlocal内存泄漏原因分析01.mp4     108.86MB
│   │   │   ├─11.第十一节-Threadlocal内存泄漏原因分析.mp4     78.06MB
│   │   │   └─12.第十二节-Threadlocal课程内容总结.mp4     45.78MB
│   │   ├─012.第九期-JUC并发编程之Java内存模型底层原理
│   │   │   ├─01.第一节-为什么需要加上Volatile.mp4     66.73MB
│   │   │   ├─02.第二节-Volatile关键字基本概述.mp4     29.54MB
│   │   │   ├─03.第三节-Volatile基本用法.mp4     44.39MB
│   │   │   ├─04.第四节-cpu多级缓存的作用.mp4     68.11MB
│   │   │   ├─05.第五节-为什么会发生线程可见性.mp4     67.52MB
│   │   │   ├─06.第六节-什么是java内存模型.mp4     60.08MB
│   │   │   └─07.第七节-JMM八大同步规范.mp4     129.17MB
│   │   ├─013.第九期-JUC并发编程之Volatile关键字底层原理
│   │   │   ├─01.第一节-volatile关键底层实现原理.mp4     116.56MB
│   │   │   ├─02.第二节-mesi缓存一致性协议原理.mp4     80.05MB
│   │   │   ├─03.第三节-为什么volatile不能够保证原子性.mp4     66.07MB
│   │   │   ├─04.第四节-为什么System.out.println保证线程的可见性.mp4     71.41MB
│   │   │   ├─05.第五节-什么是重排序.mp4     28.57MB
│   │   │   ├─06.第六节-多线程的情况下发生重排序结果会有哪些影响.mp4     68.52MB
│   │   │   └─07.第七节-演示多线程情况下重排序产生的问题.mp4     110.88MB
│   │   ├─014.第九期-JUC并发编程之单例模式七种写法与如何破解单例
│   │   │   ├─01.第一节-什么是单例模式.mp4     21.97MB
│   │   │   ├─02.第二节-懒汉式线程不安全.mp4     39.21MB
│   │   │   ├─03.第三节-懒汉式线程安全.mp4     35.05MB
│   │   │   ├─04.第四节-懒汉式双重检验锁.mp4     62.26MB
│   │   │   ├─06.第六节-饿汉式.mp4     37.59MB
│   │   │   ├─07.第七节-静态代码单例(1).mp4     13.41MB
│   │   │   ├─07.第七节-静态代码单例.mp4     13.41MB
│   │   │   ├─08.第八节-静态内部类的形式(1).mp4     49.03MB
│   │   │   ├─08.第八节-静态内部类的形式.mp4     49.03MB
│   │   │   ├─09.第九节-枚举单例.mp4     52.91MB
│   │   │   ├─10.第十节-反射如何破解单例模式.mp4     139.55MB
│   │   │   ├─11.第十一节-序列化如何破解单例.mp4     43.65MB
│   │   │   ├─12.第十二节-序列化如何防止单例破解.mp4     99.25MB
│   │   │   ├─13.第十三节-java真的能够实现真正意义上单例吗.mp4     17.49MB
│   │   │   ├─14.第十四节-反射破解枚举单例.mp4     81.43MB
│   │   │   └─15.第十五节-枚举如何防御反射破解单例.mp4     68.59MB
│   │   ├─015.第九期-JUC并发编程之内存屏障实现原理
│   │   │   ├─01.第一节-什么是缓存行.mp4     105.61MB
│   │   │   ├─02.第二节-为什么加上Volatile效率变低01.mp4     36.72MB
│   │   │   ├─02.第二节-为什么加上Volatile效率变低02.mp4     157.72MB
│   │   │   ├─03.第三节-@sun.misc.Contended.mp4     22.47MB
│   │   │   ├─04.第四节-重排序有哪些好处.mp4     30.41MB
│   │   │   ├─05.第五节-编译与处理器重排序.mp4     182.5MB
│   │   │   ├─06.第六节-双重检验锁单例为什么需要加上Volatile.mp4     130.38MB
│   │   │   ├─07.第七节-内存屏障如何保证可见性和禁止重排序.mp4     133.11MB
│   │   │   ├─08.第八节.unsafe类调用内存屏障实现禁止重排序.mp4     74.44MB
│   │   │   ├─09.第九节-写内存屏障的疑问.mp4     17.21MB
│   │   │   ├─10.第十节-happens-before规则.mp4     47.58MB
│   │   │   └─资料.zip     196.07KB
│   │   ├─016.第九期-JUC并发编程之BlockingQueue实现原理
│   │   │   ├─01.第一节-队列模型的架构设计.mp4     58.97MB
│   │   │   ├─02.第二节-数组与链表结构模型.mp4     89.4MB
│   │   │   ├─03.第三节-基于链表实现队列原理.mp4     70.72MB
│   │   │   ├─04.第四节-简单回顾lock锁的使用.mp4     29.62MB
│   │   │   ├─05.第五节-Arrayblockingqueue的用法01.mp4     144.03MB
│   │   │   ├─06.第六节-Arrayblockingqueue的用法02.mp4     66.73MB
│   │   │   ├─07.第六节-Arrayblockingqueue的用法03.mp4     30.8MB
│   │   │   ├─08.第八节-纯手写Arrayblockingqueue存储功能.mp4     96.55MB
│   │   │   ├─09.第九节-基于Arrayblockingqueue实现生产者与消费者模型.mp4     117.96MB
│   │   │   ├─10.第十节-Arrayblockingqueue阻塞功能如何实现.mp4     116.79MB
│   │   │   ├─11.第十一节-完善手写Arrayblockingqueue.mp4     59.68MB
│   │   │   └─12.第十二节-Linked与arraylBlockingQueue区别.mp4     103.12MB
│   │   ├─017.第九期-JUC并发编程之线程池底层实现原理
│   │   │   ├─01.第一节-为什么使用线程池.mp4     111.06MB
│   │   │   ├─02.第二节-线程池的作用有哪些.mp4     76.84MB
│   │   │   ├─03.第三节-线程池四种创建方式.mp4     54.03MB
│   │   │   ├─04.第四节-线程池之可定长度和单例线程池.mp4     29.62MB
│   │   │   ├─05.第五节-可定时线程池.mp4     12.08MB
│   │   │   ├─06.第六节-手写线程池底层实现原理思路.mp4     83.76MB
│   │   │   ├─07.第七节-代码纯手写线程池.mp4     85.36MB
│   │   │   ├─08.第八节-代码手写线程池之如何停止线程池.mp4     54.26MB
│   │   │   ├─09.第九节-手写线程池如何避免cpu飙高的问题.mp4     173.89MB
│   │   │   ├─10.第十节-threadpoolexcutor核心参数.mp4     69.89MB
│   │   │   ├─11.第十一节-如何自定义线程池.mp4     150.15MB
│   │   │   ├─12.第十二节-为什么阿里巴巴Java开发手册中强制要求线程池不允许使用Executor.mp4     28.25MB
│   │   │   ├─13.第十三节-线程池队列满了如何处理呢拒绝策略.mp4     74.55MB
│   │   │   ├─14.第十四节-如何自定义线程池名称.mp4     39.55MB
│   │   │   ├─15.第十五节-线程池五种状态.mp4     49.25MB
│   │   │   ├─16.第十六节-线程池内部底层实现原理.mp4     109.35MB
│   │   │   ├─17.第十七节-线程池内部工作线程如何一直运行状态.mp4     35.63MB
│   │   │   ├─18.第十八节-线程池核心线程数如何配置.mp4     117.11MB
│   │   │   └─19.第十九节-SpringBoot如何整合线程池.mp4     21.93MB
│   │   ├─018.第九期-JUC并发编程之AQS底层实现原理
│   │   │   ├─01.第一节-什么是AQS.mp4     47.52MB
│   │   │   ├─02.第二节-简单回顾AQS设计知识点.mp4     41.54MB
│   │   │   ├─03.第三节-简单回顾CAS底层原理.mp4     51.54MB
│   │   │   ├─04.第四节-简单回顾locksupport.mp4     25.79MB
│   │   │   ├─05.第五节-lock锁源码解读.mp4     124.75MB
│   │   │   ├─06.第六节-非公平锁源码解读01.mp4     44.46MB
│   │   │   ├─07.第七节-非公平锁源码解读02.mp4     330.04MB
│   │   │   ├─08.第八节-lock双向链表结构疑问.mp4     30.99MB
│   │   │   ├─09.第九节-AQS中为什么头结点是为空的01.mp4     41.19MB
│   │   │   ├─10.第十节-AQS中为什么头结点是为空的02.mp4     8.69MB
│   │   │   ├─11.第十一节-简单回顾AQS基本实现原理.mp4     163.79MB
│   │   │   ├─12.第十二节-AQS源码分析之如何阻塞一个线程01.mp4     151.84MB
│   │   │   ├─13.第十三节-AQS源码分析之如何阻塞一个线程02.mp4     108.42MB
│   │   │   ├─14.第十四节-AQS源码之重入锁如何实现.mp4     39.22MB
│   │   │   ├─15.第十五节-Lock锁如何释放锁的.mp4     158.29MB
│   │   │   ├─16.第十六节-Lock底层公平与非公平锁实现区别.mp4     31.68MB
│   │   │   └─17.第十七节-AQS源码总结.mp4     12.26MB
│   │   ├─019.第九期-JUC并发编程之Lock锁的condition源码解读
│   │   │   ├─01.第一节-回顾等待池与锁池之间的区别.mp4     119MB
│   │   │   ├─02.第二节-等待池源码解读.mp4     57.65MB
│   │   │   ├─03.第三节-await方法底层源码解读01.mp4     103.29MB
│   │   │   ├─04.第四节-await方法底层源码解读02.mp4     150.23MB
│   │   │   └─05.第五节-如何唤醒等待池中的线程.mp4     95.57MB
│   │   ├─020.第九期-JUC并发编程之Semaphore源码解读
│   │   │   ├─01.第一节-Semaphore基本用法.mp4     146.96MB
│   │   │   ├─02.第二节-Semaphore如何实现限流.mp4     71MB
│   │   │   ├─03.第三节-Semaphore源码解读01.mp4     340.67MB
│   │   │   ├─04.第四节-Semaphore源码解读02.mp4     108.74MB
│   │   │   └─资料.zip     196.07KB
│   │   ├─021.第九期-JUC并发编程之CyclicBarrier源码解读
│   │   │   ├─01.第一节-CyclicBarrier用法.mp4     115.69MB
│   │   │   ├─02.第二节-CyclicBarrier源码解读.mp4     148.22MB
│   │   │   ├─03.第三节-CountDownLatch用法.mp4     59.52MB
│   │   │   ├─04.第四节-CountDownLatch源码解读01.mp4     68.42MB
│   │   │   ├─05.第五节-CountDownLatch源码解读02.mp4     103.25MB
│   │   │   ├─06.第六节-AQS源码总结01.mp4     156.61MB
│   │   │   ├─07.第七节-AQS源码总结02.mp4     57.41MB
│   │   │   └─08.第八节-AQS源码总结03.mp4     107.71MB
│   │   ├─022.第九期-JUC并发编程之forkjoin底层原理
│   │   │   └─视频正在努力讲解中,后期讲解完毕会更新的.txt     84B
│   │   ├─023.第九期-JUC并发编程之disruptor原理
│   │   │   └─视频正在努力讲解中,后期讲解完毕会更新的.txt     60B
│   │   ├─024.第九期-JVM专题之类加载器设计原理
│   │   │   ├─01.第一节-类加载概念引入.mp4     69.13MB
│   │   │   ├─02.第二节-class文件读取的来源.mp4     13.3MB
│   │   │   ├─03.第三节-类加载器的分类.mp4     178.3MB
│   │   │   ├─04.第四节-什么是双亲委派机制.mp4     108.63MB
│   │   │   ├─05.第五节-双亲委派机制案例演示.mp4     46.58MB
│   │   │   ├─06.第六节-双亲委派机制源码解读01.mp4     102.98MB
│   │   │   ├─07.第七节-双亲委派机制源码解读02.mp4     23.35MB
│   │   │   ├─08.第八节-双亲委派机制源码解读03.mp4     134.36MB
│   │   │   ├─09.第九节-new一个对象class如何被加载.mp4     33.98MB
│   │   │   ├─10.第十节-双亲委派机制原理细节分析.mp4     144.28MB
│   │   │   ├─11.第十一节-如何自定义一个类加载器.mp4     264.94MB
│   │   │   ├─12.第十二节-如何手写一个热部署插件.mp4     72.26MB
│   │   │   ├─13.第十三节-代码一步一步手写热部署插件01.mp4     157.65MB
│   │   │   ├─14.第十四节-代码一步一步手写热部署插件02.mp4     149.9MB
│   │   │   └─15.第十五节-手写热部署插件的演示.mp4     42.78MB
│   │   ├─025.第九期-JVM专题之SPI破解双亲委派机制
│   │   │   ├─视频正在努力讲解中,后期讲解完毕会更新的.txt     36B
│   │   │   └─资料.zip     196.07KB
│   │   ├─026.第九期-JVM专题之栈帧内部结构分析
│   │   │   ├─01.第一节-什么是程序计数器.mp4     107.75MB
│   │   │   ├─02.第二节-什么是栈01.mp4     58.81MB
│   │   │   ├─02.第二节-什么是栈02.mp4     21.33MB
│   │   │   ├─03.第三节-什么是栈帧.mp4     59.83MB
│   │   │   ├─04.第四节-什么是局部变量表01.mp4     140.44MB
│   │   │   ├─04.第四节-什么是局部变量表02.mp4     11.55MB
│   │   │   ├─06.第六节-站帧-局部变量表中-槽的概念.mp4     120.85MB
│   │   │   ├─07.第七节-栈帧-局部变量表总结.mp4     11.64MB
│   │   │   ├─08.第八节-栈帧-操作数栈分析01.mp4     172.48MB
│   │   │   ├─08.第八节-栈帧-操作数栈分析02.mp4     44.67MB
│   │   │   ├─09.第九节-I++和++i的底层原理01.mp4     76.54MB
│   │   │   ├─09.第九节-I++和++i的底层原理02.mp4     67.8MB
│   │   │   ├─10.第十节-什么是栈溢出01.mp4     7.62MB
│   │   │   ├─10.第十节-什么是栈溢出02.mp4     40.01MB
│   │   │   ├─10.第十节-什么是栈溢出03.mp4     38.38MB
│   │   │   └─10.第十节-什么是栈溢出04.mp4     39.56MB
│   │   ├─027.第九期-JVM专题之字符串常量池原理
│   │   │   ├─01.第一节-什么是常量池.mp4     157.57MB
│   │   │   ├─02.第二节-局部表与常量池关系.mp4     67.51MB
│   │   │   ├─04.第四节-什么是动态连接.mp4     88.09MB
│   │   │   ├─05.第五节-常量池分类.mp4     64.5MB
│   │   │   ├─06.第六节-JDK7之前的常量池.mp4     50.02MB
│   │   │   ├─07.第七节-String类源码解读.mp4     29.23MB
│   │   │   ├─08.第八节-JDK1.7之前和1.8开始字符串常量池存储位置.mp4     34.15MB
│   │   │   ├─09.第九节-string常见面试题.mp4     111.67MB
│   │   │   ├─10.第十节-字符串修改会创建几个对象.mp4     67.02MB
│   │   │   ├─11.第十一节-字符串在编译阶段自动优化.mp4     44.48MB
│   │   │   ├─12.第十二节-变量字符串相加的原理.mp4     117.01MB
│   │   │   ├─13.第十三节-stringbuilder底层实现原理.mp4     218.67MB
│   │   │   ├─14.第十四节-stringbuilder扩容原理.mp4     70.53MB
│   │   │   ├─15.第十五节-字符串常见面试题总结.mp4     17.72MB
│   │   │   ├─16.第十六节-字符串的延迟加载.mp4     58.55MB
│   │   │   └─17.如何证明字符串常量池是存放在堆中.mp4     49.28MB
│   │   ├─028.第九期-JVM专题之堆内存溢出&cpu飙高的问题
│   │   │   ├─01.第一节-new一个对象底层如何存放.mp4     29.64MB
│   │   │   ├─02.第二节-什么是内存泄漏问题.mp4     91.72MB
│   │   │   ├─03.第三节-堆内存溢出解决办法.mp4     104.37MB
│   │   │   ├─04.第四节-jps&jmap指令分析堆内存01.mp4     122.24MB
│   │   │   ├─04.第四节-jps&jmap指令分析堆内存02.mp4     9.86MB
│   │   │   ├─05.第五节-如何分析GC回收多次对象无法释放内存.mp4     134.5MB
│   │   │   ├─06.第六节-代码模拟内存泄漏问题.mp4     71.42MB
│   │   │   ├─07.第七节-如何排查内存泄漏问题.mp4     73.05MB
│   │   │   ├─08.第八节-如何在linux环境下执行jps.mp4     41.97MB
│   │   │   ├─09.第九节-什么是cpu飙高的问题01.mp4     170.13MB
│   │   │   ├─10.第十节-演示windows环境cpu飙高的问题.mp4     20.83MB
│   │   │   ├─11.第十一节-如何在linux环境排查cpu飙高的问题.mp4     131.17MB
│   │   │   ├─12.第十二节-使用阿里巴巴Arthas排查linux环境cpu飙高的问题.mp4     79.45MB
│   │   │   └─13.第十三节-实际生产环境中如何排查cpu飙高的问题.mp4     77.95MB
│   │   ├─029.第九期-堆内分代设计与GC日志分析
│   │   │   ├─01.第一节-堆内存细节内容安排.mp4     12.52MB
│   │   │   ├─02.第二节-JDK7和JDK8中堆内存变化.mp4     43.75MB
│   │   │   ├─03.第三节-jps指令分析堆内存情况.mp4     84.45MB
│   │   │   ├─04.第四节–XXNewRatio新生代余与老年代比例配置.mp4     39.88MB
│   │   │   ├─06.第六节-StoptheWorld机制.mp4     22MB
│   │   │   ├─08.第八节-GC的分类.mp4     36.94MB
│   │   │   ├─09.第九节-对象晋升的细节流程.mp4     128.74MB
│   │   │   ├─10.第十节-演示新生代MinorGC回收过程.mp4     92.77MB
│   │   │   ├─11.第十一节-演示老年代FullGC回收过程.mp4     141.32MB
│   │   │   ├─12.第十二节-新生代GC日志分析.mp4     171.34MB
│   │   │   ├─13.第十三节-老年代GC日志分析.mp4     37.64MB
│   │   │   ├─14.第十四节-元空间GC日志分析.mp4     8.33MB
│   │   │   ├─15.第十六节-在线工具分析GC日志01.mp4     153.49MB
│   │   │   ├─16.第十五节-在线工具分析GC日志02.mp4     128.06MB
│   │   │   └─资料.zip     196.07KB
│   │   ├─030.第九期-内存逃逸分析
│   │   │   ├─01.第一节-.new对象一定存放在堆中吗.mp4     54.22MB
│   │   │   ├─02.第二节-为什么new对象需要存放在栈中.mp4     80.71MB
│   │   │   ├─03.第三节-.jlt内存逃逸作用域.mp4     71.05MB
│   │   │   ├─04.第四节-逃逸分析代码演示.mp4     112.51MB
│   │   │   ├─05.第五节-逃逸分析案例演示.mp4     37.75MB
│   │   │   ├─06.第六节-锁的消除.mp4     44.06MB
│   │   │   └─07.第七节-.标量替换.mp4     107.32MB
│   │   ├─031.第九期-永久代(元空间分析)—待整理视频
│   │   ├─032.第九期-JVM专题之引用技术法与GCRoot(可达分析算法)
│   │   │   ├─01.第一节-如何定义垃圾对象.mp4     73.05MB
│   │   │   ├─02.第二节-什么是引用技术算法.mp4     83.97MB
│   │   │   ├─03.第三节-什么是引用计数法-循环依赖问题.mp4     100.89MB
│   │   │   ├─04.第四节-GCRoot可达分析算法.mp4     83.48MB
│   │   │   ├─05.第五节-GCRoot如何解决循环依赖问题.mp4     60.68MB
│   │   │   ├─06.第六节-哪些对象可以作为GCRoot.mp4     10.07MB
│   │   │   ├─07.第七节-通过mat分析GCRoot.mp4     105.35MB
│   │   │   ├─08.第八节-通过MAT分析GCRoot循环依赖对象.mp4     63.81MB
│   │   │   ├─09.第七引用技术法与可达分析算法区别.mp4     34.24MB
│   │   │   ├─10.第十节-finalize复活对象.mp4     142.6MB
│   │   │   └─11.第十一节-finalize方法的总结.mp4     62.64MB
│   │   ├─033.第九期-JVM专题之垃圾回收的算法(后期会修订)
│   │   │   ├─01.第一节-指针碰撞与空闲列表.mp4     68.24MB
│   │   │   ├─02.第二节-标记清除算法01—-改.mp4     44.51MB
│   │   │   ├─03.第三节-标记清除算法疑问.mp4     55.69MB
│   │   │   ├─04.第五节-标记复制算法应用场景.mp4     15.93MB
│   │   │   ├─04.第四节-标记复制算法01.mp4     74.7MB
│   │   │   ├─04.第四节-标记复制算法02.mp4     17.72MB
│   │   │   ├─04.第四节-标记复制算法03.mp4     46.65MB
│   │   │   ├─04.第四节-标记复制算法04.mp4     12.27MB
│   │   │   ├─05.第五节-标记压缩算法.mp4     45.33MB
│   │   │   ├─06.第六节-垃圾回收算法总结.mp4     45.4MB
│   │   │   └─09.033.mp4     348.18MB
│   │   ├─034.第九期-JVM专题之对象定位访问与句柄池和直接引用
│   │   │   ├─01.第一节-new对象晋升细节内容.mp4     128.74MB
│   │   │   ├─02.第二节-new对象晋升细节内容总结.mp4     12.93MB
│   │   │   ├─03.第三节-通过工具分析对象晋升的过程.mp4     82.17MB
│   │   │   └─04.第四节-对象的定位访问句柄池与直接引用.mp4     63.46MB
│   │   ├─035.第九期-JVM专题之串行&并行收集器
│   │   │   ├─01.第一节-为什么不建议调用System.gc();.mp4     22.88MB
│   │   │   ├─02.第二节-垃圾收集器与可达分析算法区别.mp4     23.04MB
│   │   │   ├─03.第三节-并行与并发收集器区别.mp4     60.67MB
│   │   │   ├─04.第四节-评估GC性能指标.mp4     97.95MB
│   │   │   ├─05.第五节-垃圾回收期发展历史.mp4     51.94MB
│   │   │   ├─06.第六节-七款经典收集器组合.mp4     93.89MB
│   │   │   ├─07.第七节-如何查看默认垃圾收集器.mp4     41.87MB
│   │   │   ├─08.第八节-串行收集器特点.mp4     47.61MB
│   │   │   ├─09.第九节-画图形式展示串行收集器.mp4     8.11MB
│   │   │   ├─10.第十节-parnew新生代gc回收原理.mp4     56.34MB
│   │   │   ├─11.第十一节-串行与并行收集器之间区别.mp4     27.55MB
│   │   │   ├─12.第十二节-配置parnew新生代gc参数.mp4     13.83MB
│   │   │   └─13.第十三节-并行回收的原理.mp4     55.21MB
│   │   ├─036.第九期-JVM专题之CMS收集器原理
│   │   │   ├─01.第一节-为什么需要使用CMS收集器.mp4     76.48MB
│   │   │   ├─03.第三节-CMS之初始标记.mp4     63.43MB
│   │   │   ├─04.第四节-CMS之并发标记.mp4     59.55MB
│   │   │   ├─05.第五节-CMS之重新标记.mp4     43.97MB
│   │   │   ├─06.第六节-CMS并发清除.mp4     16.07MB
│   │   │   ├─07.第七节-CMS四次标记总结01.mp4     38.38MB
│   │   │   ├─08.第八节-CMS在什么时候清理堆内存垃圾.mp4     19.1MB
│   │   │   ├─09.第九节-CMS收集器的优缺点.mp4     49.86MB
│   │   │   ├─10.第十节-CMS收集器并发清除阶段缺陷.mp4     34.33MB
│   │   │   └─11.第十一节-CMS收集器参数设置.mp4     109.81MB
│   │   ├─043.第九期-性能优化-MySQL实战分表分库
│   │   │   ├─01.第一节-什么是垂直拆分.mp4     27.72MB
│   │   │   ├─02.第二节-什么是水平拆分.mp4     134.84MB
│   │   │   ├─03.第三节-shadingjdbc与mycat之间的区别.mp4     39.15MB
│   │   │   ├─04.第四节-shadingjdbc分配策略.mp4     64.23MB
│   │   │   ├─05.第五节-SpringBoot项目整合shadingjdbc.mp4     144.51MB
│   │   │   ├─06.取余分片算法优缺点.mp4     91.85MB
│   │   │   ├─07.日期分片算法优缺点.mp4     30.82MB
│   │   │   ├─08.其他分片算法优缺点.mp4     44.73MB
│   │   │   ├─11.shadingjdbc整合范围分片算法.mp4     136.84MB
│   │   │   ├─12.单张表数量达到多少分表分库.mp4     13.71MB
│   │   │   ├─13.分表分库后shadingjdbc底层查询语句.mp4     101.89MB
│   │   │   └─14.分表分库后分页如何查询.mp4     81.93MB
│   │   ├─044.第九期-性能优化-MySQLBinlog原理
│   │   │   ├─01.第一节-什么是binlog01.mp4     72.57MB
│   │   │   ├─02.第二节-MySql集群架构设计原理.mp4     105.4MB
│   │   │   ├─03.第三节-基于docker安装mysql主节点.mp4     124.44MB
│   │   │   ├─04.第四节-基于docker安装mysql从节点.mp4     37.66MB
│   │   │   ├─05.第五节-演示mysql集群环境.mp4     174.34MB
│   │   │   ├─06.第六节-如果发生mysql主从数据不一致怎么办.mp4     84.82MB
│   │   │   └─07.第七节-误删除mysql数据如何恢复.mp4     81.35MB
│   │   ├─045.第九期-性能优化-Binlog实现数据同步
│   │   │   ├─01.第一节-mysql与Redis如何实现数据同步.mp4     61.35MB
│   │   │   ├─02.第二节-canal同步数据原理.mp4     104.68MB
│   │   │   ├─03.第四节-启动canal监听binlog.mp4     155.93MB
│   │   │   ├─04.第四节-如何将canal的数据同步到redis.mp4     119.33MB
│   │   │   ├─05.第五节-演示canal同步数据删除操作.mp4     65.89MB
│   │   │   └─06.第六节-canal与mysql同步数据延迟问题.mp4     58.5MB
│   │   ├─047.第九期-性能优化-MySQLB+树索引细节问题
│   │   │   ├─01.第一节-innodb为什么插入数据会根据主键索引排序.mp4     68.3MB
│   │   │   ├─02.第二节-innodb页的概念.mp4     198.26MB
│   │   │   ├─03.第三节-innodb页与页之间如何关联.mp4     46.26MB
│   │   │   ├─04.第四节-innodb页的分组概念.mp4     69.33MB
│   │   │   └─05.第五节-一颗B+树三层可以存放多少条key.mp4     91.42MB
│   │   ├─048.第九期-性能优化-MySQL查询语句优化
│   │   │   ├─02.第二节-explain中的列select列.mp4     111.03MB
│   │   │   ├─03.第三节-explain的type列all与index之间区别.mp4     76.53MB
│   │   │   ├─04.第四节-EXPLAINType需要达到什么级别.mp4     263.52MB
│   │   │   ├─05.第五节-EXPLAINkey的长度如何计算.mp4     107.69MB
│   │   │   ├─06.第六节-mysql索引需要遵循遵循最佳左前缀法则.mp4     42.07MB
│   │   │   ├─07.第七节-mysql索引列上不要使用函数或.mp4     40.61MB
│   │   │   ├─08.第八节-尽量使用覆盖索引返回数据.mp4     93.04MB
│   │   │   ├─09.第九节-索引上使用like注意事项.mp4     55.79MB
│   │   │   └─10.第十节-explain扩展列usingwhere与usingindex区别.mp4     158.33MB
│   │   ├─049.第九期-性能优化-MySQL排序如何优化
│   │   │   ├─01.第一节-排序需要注意filesort.mp4     78.51MB
│   │   │   ├─02.第二节.filesort排序设计原理.mp4     33.29MB
│   │   │   ├─03.第三节-排序如何避免filesor.mp4     103.31MB
│   │   │   ├─04.第四节-单路与双路排序设计原理.mp4     94.77MB
│   │   │   ├─05.第五节-optimizertrace(优化器跟踪).mp4     129.04MB
│   │   │   ├─06.第六节-optimizertrace分析单路与双路排序.mp4     48.72MB
│   │   │   └─资料.zip     196.07KB
│   │   ├─050.第九期-性能优化-MySQL表连接join和分页优化
│   │   │   ├─01.第一节-表连接join引入.mp4     107.18MB
│   │   │   ├─02.第二节-左、右、内连接区别.mp4     96.09MB
│   │   │   ├─03.第三节-左连接设计原理.mp4     67.16MB
│   │   │   ├─04.第四节-右连接设计原理.mp4     27.23MB
│   │   │   ├─05.第五节-内连接设计原理.mp4     25.41MB
│   │   │   ├─06.第六节-表连接必须要加上索引.mp4     101.46MB
│   │   │   ├─07.第七节-in关键字需要遵循小表驱动大表.mp4     27.93MB
│   │   │   ├─08.第八节-exists关键字需要遵循小表驱动大表.mp4     20.93MB
│   │   │   └─09.第九节-分页如何查询优化.mp4     132.13MB
│   │   ├─051.第九期-性能优化-MySQL行锁与表锁原理
│   │   │   ├─01.第一节-MySQL事务基本概念.mp4     114.34MB
│   │   │   ├─02.第二节-MyISAM和InnoDB的区别有哪些?.mp4     74.03MB
│   │   │   ├─03.第三节-myisam存储引擎表锁与InnoDB行锁概念.mp4     108.29MB
│   │   │   ├─04.第四节-mysql中的行锁和表锁.mp4     80.57MB
│   │   │   ├─05.第五节-myisam存储引擎表读锁演示.mp4     93.26MB
│   │   │   ├─06.第六节-myisam存储引擎表写锁演示.mp4     51.97MB
│   │   │   ├─07.第七节-演示InnoDB行锁.mp4     168.81MB
│   │   │   └─08.第八节-forupdate演示.mp4     50.6MB
│   │   ├─052.第九期-性能优化-MySQL间隙锁&悲观锁&乐观锁
│   │   │   ├─01.第一节-简单回顾forupdate用法.mp4     74.64MB
│   │   │   ├─02.第二节-悲观锁的用法.mp4     32.38MB
│   │   │   ├─03.第三节.乐观锁实现原理.mp4     247.47MB
│   │   │   ├─04.第四节-什么是间隙锁.mp4     39.45MB
│   │   │   └─05.第五节-注意行锁升级表锁.mp4     50.03MB
│   │   └─053.第九期-性能优化-事务隔离级别&MVCC原理
│   │         ├─01.第一节-事务隔离级别与mvcc课程安排ev.mp4     20.78MB
│   │         ├─02.第二节-mysql事务隔离级别引入ev.mp4     41.23MB
│   │         ├─03.第三节-mysql事务隔离级别之读取未提交ev.mp4     52.79MB
│   │         ├─04.第四节-mysql事务隔离级别之读已提交数据ev.mp4     63.05MB
│   │         ├─05.第五节-mysql事务隔离级别之可重复读ev.mp4     47.1MB
│   │         ├─06.第六节-mysql幻读的基本概念ev.mp4     24.23MB
│   │         ├─07.第七节-mysql可重复读实现思路ev.mp4     19.65MB
│   │         ├─08.第八节-mysql可重复能否解决幻读问题ev.mp4     86.87MB
│   │         ├─09.第九节-mysql事务隔离级别之串行化ev.mp4     32.7MB
│   │         ├─10.第十节-MVCC基本的概念ev.mp4     30.79MB
│   │         ├─11.第十一节-MVCC链表结构原理分析ev.mp4     76.63MB
│   │         ├─12.第十二节-readview视图四个不同的属性ev.mp4     68.56MB
│   │         ├─13.第十三节-mvcc版本链判断规则之为什么当前session修改数据能够立即查看?ev.mp4     25.42MB
│   │         ├─14.第十四节-mvcc版本链判断规则之读取提交或者未提交数据原理ev.mp4     84.35MB
│   │         ├─15.第十五节-mvcc版本链判断规则之可重复读设计原理ev.mp4     31.87MB
│   │         └─16.第十六节mvcc能否可以解决幻读问题?ev.mp4     7.77MB
│   ├─04、java进阶第七八期含项目
│   │   ├─第10节 MySQL深度原理解析
│   │   │   ├─52.MySQL架构与执行流程原理.mp4     2.13GB
│   │   │   ├─53.MySQL索引底层实现原理.mp4     1.28GB
│   │   │   ├─54.MySQL定位慢查询与索引优化原则.mp4     1.44GB
│   │   │   ├─55.trace分析sql与单路与双路排序区别.mp4     1.34GB
│   │   │   ├─56.分页查询&表连接&索引优化总结.mp4     1.54GB
│   │   │   ├─57.事务隔离级别&脏读&可重复读基本概念.mp4     1.25GB
│   │   │   └─58.MVCC多版本控制模型原理.mp4     1.38GB
│   │   ├─第11节 Netty深度源码解读
│   │   │   ├─01.网络编程基础课程.mp4     724.86MB
│   │   │   ├─02.站在内核角度分析NIO实现原理.mp4     2GB
│   │   │   ├─03.Netty站包与拆包与手写消息中间件框架.mp4     1.35GB
│   │   │   ├─04.Netty序列化框架与手写服务注册与发现.mp4     1.41GB
│   │   │   ├─05.基于Netty手写Dubbo框架(1).mp4     1.35GB
│   │   │   ├─06.零拷贝原理&netty线程模型原理.mp4     1.03GB
│   │   │   └─07.Netty底层线程模型源码解读.mp4     1.43GB
│   │   ├─第12节 SpringCloud微服务框架源码解读
│   │   │   ├─08.Eureka服务注册与发现深度源码解读.mp4     1.9GB
│   │   │   ├─09.Nacos服务注册与发现深度源码解读01.mp4     1.67GB
│   │   │   ├─10.Nacos服务注册与发现深度源码解读02.mp4     997.98MB
│   │   │   ├─11.Nacos服务注册与发现深度源码解读03.mp4     1.44GB
│   │   │   └─12.如何徒手写一个openfeign调用工具.mp4     1.79GB
│   │   ├─第13节 彻底搞懂分布式锁架构设计原理
│   │   │   ├─11.简单基于Zookeeper实现分布式锁.mp4     1.26GB
│   │   │   ├─12.ZK分布式锁续命&超时&避免羊群效应问题.mp4     1.63GB
│   │   │   ├─13.ZK框架Curator实现分布式锁.mp4     1.88GB
│   │   │   ├─14.Redis实现分布式锁之setnx实现方式.mp4     976.04MB
│   │   │   ├─15.Redisson实现分布式锁与续命问题.mp4     1.17GB
│   │   │   └─16.Redisson实现高可用分布式锁设计.mp4     1.75GB
│   │   ├─第14节 分布式数据一致性设计原理
│   │   │   ├─17.分布式rpc接口幂等解决方案.mp4     845.66MB
│   │   │   ├─18.mysql与缓存双写一致性原理.mp4     1.43GB
│   │   │   ├─19.XXLJOB定时任务调度原理(1).mp4     1.06GB
│   │   │   ├─20.LCN解决分布式事务实现原理.mp4     1.06GB
│   │   │   ├─21.SeataAT模式解决分布式事务原理.mp4     1.22GB
│   │   │   ├─22.SeataAT模式解决分布式事务原理.mp4     1.26GB
│   │   │   ├─23.分布式日志采集ELK架构原理.mp4     968.18MB
│   │   │   ├─25.MQ架构设计原理.mp4     1.72GB
│   │   │   ├─26.RabbitMQ架构设计原理.mp4     1.27GB
│   │   │   └─27.RabbitMQ消息确认&幂等设计.mp4     2.3GB
│   │   ├─第15节 分布式消息中间件
│   │   │   ├─024.分布式服务追踪SkyWalking.mp4     2.21GB
│   │   │   ├─28.Kafka环境构建与offset原理.mp4     1.8GB
│   │   │   ├─29.Kafka设计原理剖析.mp4     2.18GB
│   │   │   ├─30.Kafka最佳性能实战.mp4     1.96GB
│   │   │   ├─31.RocketMQ消息顺序一致性原理.mp4     1.47GB
│   │   │   ├─32.RocketMQ存储结构原理分析.mp4     1.39GB
│   │   │   ├─34.RocketMQ集群架构原理解决分布式事务.mp4     1.24GB
│   │   │   ├─35.docker架构设计原理.mp4     1.29GB
│   │   │   ├─36.docker部署springboot项目.mp4     508.22MB
│   │   │   └─37.docker-compose部署微服务项目.mp4     921.33MB
│   │   ├─第16节 实战新零售微服务电商项目
│   │   │   ├─01.项目架构技术选型与技术讨论.mp4     1.9GB
│   │   │   ├─02.分层领域模型架构设计.mp4     1.12GB
│   │   │   ├─03.企业级分布式基础设施构建.mp4     1.06GB
│   │   │   ├─04.企业级微服务公众号开发.mp4     1.57GB
│   │   │   ├─05.会员服务令牌登录与唯一登录设计.mp4     1.71GB
│   │   │   ├─06.整合rabbitmq异步实现处理耗时操作.mp4     1.57GB
│   │   │   ├─07.整合jwt&获取用户真实ip&解决跨域问题.mp4     1.85GB
│   │   │   └─08.oauth授权绑定账号.mp4     1.61GB
│   │   ├─第17节 实战新零售微服务电商项目
│   │   │   ├─09.CAS单点登录系统设计原理(1).mp4     1.16GB
│   │   │   ├─09.CAS单点登录系统设计原理(2).mp4     1.42GB
│   │   │   ├─10.shadingjdbc实战分表分库.mp4     1.07GB
│   │   │   ├─11.分布式ELK+KAFKA日志采集.mp4     1.42GB
│   │   │   ├─12.聚合支付平台架构的设计原理.mp4     1.23GB
│   │   │   ├─13.基于策略模式封装聚合支付平台.mp4     1.27GB
│   │   │   ├─14.聚合支付平台异步回调模式封装.mp4     1.39GB
│   │   │   ├─15.聚合支付平台异步回调模式.mp4     1.64GB
│   │   │   ├─16.聚合支付订单状态同步与整合任务调度.mp4     1.72GB
│   │   │   ├─17.支付与积分服务整合seata解决分布式事务.mp4     948.62MB
│   │   │   └─18.订单30分钟未支付超时设计.mp4     1.48GB
│   │   ├─第18节 实战新零售项目电商项目(补充)
│   │   │   ├─18.订单30分钟未支付超时设计.mp4     1.86GB
│   │   │   ├─19.openresty动态页面静态化.mp4     1.57GB
│   │   │   ├─20.sku和canal解决mysql与es数据同步问题(.mp4     1.26GB
│   │   │   ├─21.秒杀抢购如何防止超卖的问题.mp4     762.36MB
│   │   │   ├─22.生产环境服务配置如何选型.mp4     702.08MB
│   │   │   ├─23.jenkins自动部署微服务项目.mp4     892.42MB
│   │   │   ├─24.jenkins自动部署微服务项目.mp4     1.44GB
│   │   │   ├─25.k8s入门到精通(1).mp4     1.44GB
│   │   │   └─25.k8s入门到精通.mp4     1.44GB
│   │   ├─第1节 开班仪式
│   │   │   ├─第七期开班仪式(1).mp4     152.52MB
│   │   │   └─第七期开班仪式(2).mp4     95.04MB
│   │   ├─第2节 架构师必备技能之设计模式
│   │   │   ├─01.站在架构师角度分析Java动态代理模式.mp4     2.11GB
│   │   │   ├─02.CGLIB底层实现的原理与异步注解失效之谜.mp4     1.24GB
│   │   │   ├─03.SpringMVC源码角度分析@async失效之谜.mp4     889.41MB
│   │   │   ├─04.使用装饰模式设计分布式多级缓存框架.mp4     1.05GB
│   │   │   ├─05.使用观察者模式设计异步多渠道群发框架.mp4     894.81MB
│   │   │   ├─06.深入研究单例模式底层原理与防止破解.mp4     1.68GB
│   │   │   ├─07.基于责任链模式构建企业级风控系统.mp4     1.41GB
│   │   │   └─08.基于策略模式重构多重if判断.mp4     818.34MB
│   │   ├─第3节 架构师必备安全技能
│   │   │   ├─09.如何防御XSS攻击与防止抓包篡改数据01.mp4     728.43MB
│   │   │   ├─09.如何防御XSS攻击与防止抓包篡改数据02.mp4     834MB
│   │   │   ├─10.springsecurity实现动态权限控制.mp4     1.15GB
│   │   │   ├─11.springsecurity整合jwt实现接口授权01.mp4     1.29GB
│   │   │   ├─11.springsecurity整合jwt实现接口授权02.mp4     606.4MB
│   │   │   └─12.springsecurity整合oatuh2.0协议.mp4     1.33GB
│   │   ├─第4节 从零开始学习多线程技术
│   │   │   ├─13.多线程快速入门与创建的方式(1).mp4     1.12GB
│   │   │   ├─14.多线程之间如何实现同步.mp4     1.13GB
│   │   │   └─15.多线程之间实现通讯wait与notify.mp4     911.73MB
│   │   ├─第5节 架构师必备技能并发编程01
│   │   │   ├─16.volatile与JMM内存模型.mp4     1.22GB
│   │   │   ├─17.volatile伪共享与Volatile重排序问题.mp4     1.6GB
│   │   │   ├─18.悲观与乐观锁&公平锁&非公平锁.mp4     1.52GB
│   │   │   ├─19.深入理解CAS无锁机制与ABA的问题.mp4     1.14GB
│   │   │   ├─20.synchronized的monitor原理分析.mp4     1.38GB
│   │   │   ├─21.synchronized锁竞争与升级原理分析.mp4     1.07GB
│   │   │   ├─22.基于CAS与并发队列手写AQS.mp4     1.39GB
│   │   │   ├─23.AQS深度源码解读源码解读.mp4     1.55GB
│   │   │   ├─24.Condition源码解读分析(1).mp4     1.14GB
│   │   │   ├─24.Condition源码解读分析.mp4     1.14GB
│   │   │   └─25.CountDownLatch底层实现原理分析.mp4     1.06GB
│   │   ├─第6节 架构必备技能并发编程02
│   │   │   ├─26.线程池ThreadPoolExecutor源码解读(1).mp4     1.92GB
│   │   │   ├─26.线程池ThreadPoolExecutor源码解读.mp4     1.92GB
│   │   │   ├─27.FutureTask底层实现原理.mp4     1.43GB
│   │   │   ├─28.Threadlocal原理与内存泄漏问题.mp4     625.78MB
│   │   │   ├─29.基于并发队列手写异步日志框架.mp4     1.28GB
│   │   │   ├─30.基于并发队列手写设计消息中间件.mp4     1.62GB
│   │   │   └─31.forkjoin底层实现原理.mp4     817.47MB
│   │   ├─第7节 JVM虚拟机参数调优01
│   │   │   ├─32.类加载器实现原理之双亲委派机制.mp4     1.47GB
│   │   │   ├─33.如何破坏双亲委派机制与手写热部署.mp4     1.32GB
│   │   │   ├─34.JVM内存结构之栈帧结构原理分析.mp4     1.16GB
│   │   │   ├─35.字符串常量池原理分析.mp4     1.18GB
│   │   │   ├─36.线上如何排查Cpu飚高问题.mp4     1.08GB
│   │   │   ├─37.可达分析算法与四种引用.mp4     1.19GB
│   │   │   ├─38.标记清除&标记复制整理&分代算法原理(1).mp4     1.27GB
│   │   │   ├─38.标记清除&标记复制整理&分代算法原理.mp4     1.27GB
│   │   │   ├─39.串行和并行收集器&Stop-The-World问题.mp4     2.06GB
│   │   │   ├─40.CMS收集器底层实现原理.mp4     1GB
│   │   │   └─41.G1收集器底层实现原理.mp4     1.26GB
│   │   ├─第8节 JVM虚拟机参数调优02
│   │   │   ├─42.三色标记算法如何处理漏标问题.mp4     1.22GB
│   │   │   ├─43.jvm字节码文件原理分析.mp4     2.78GB
│   │   │   └─44.jvm生产环境实战性能调优.mp4     1GB
│   │   ├─第9节 HashMap与ConcurrenthashMap源码解读
│   │   │   ├─45.HashMap8源码解读01.mp4     1.26GB
│   │   │   ├─46.HashMap8源码解读02.mp4     1.18GB
│   │   │   ├─47.ConcurrenthashMap源码解读01.mp4     2.39GB
│   │   │   ├─48.ConcurrenthashMap源码解读02.mp4     1.71GB
│   │   │   ├─49.HashMap与ConcurrenthashMap源码总结.mp4     1.14GB
│   │   │   ├─50..ConcurrentHashMap1.8.mp4     1.14GB
│   │   │   └─51.List集合源码分析.mp4     1.75GB
│   │   └─课件
│   │         └─课件.zip     91.18MB
│   └─06、java进阶第五六期课堂java进阶
│         ├─00.第五期和第六期-开班相关说明     -1.#INDB
│         ├─01.第五期和第六期-JDK8新特性lambda与stream
│         │   ├─background.jpg     322.56KB
│         │   ├─code
│         │   │   └─mt-mayikt-jdk8.rar     95.28KB
│         │   ├─java8新特性文档.doc     192.5KB
│         │   └─视频
│         │         ├─01.第一节-JDK8新特性课程内容安排.mp4     20.15MB
│         │         ├─02.第二节-接口中默认方法修饰为普通方法.mp4     52.44MB
│         │         ├─03.第三节-为什么需要使用lambda表达式.mp4     43.03MB
│         │         ├─04.第四节-如何定义函数接口概念.mp4     38.03MB
│         │         ├─05.第五节-使用lambda调用无参函数.mp4     25.31MB
│         │         ├─06.第六节-使用lambda调用有参函数.mp4     20.79MB
│         │         ├─07.第七节-使用lambda的精简写法.mp4     22.71MB
│         │         ├─08.第八节-lambda实现集合遍历.mp4     16.15MB
│         │         ├─09.第九节-lambda实现集合排序.mp4     30.43MB
│         │         ├─10.第十节-lambda实现线程调用.mp4     15.23MB
│         │         ├─11.第十一节-stream将list集合转换为set.mp4     59.38MB
│         │         ├─12.第十二节-set集合去重复底层实现原理.mp4     75.53MB
│         │         ├─13.第十三节-stream将list集合转换成map.mp4     37.21MB
│         │         ├─14.第十四节-stream计算求.mp4     16.25MB
│         │         ├─15.第十五节-stream查找最大和最小的.mp4     13.42MB
│         │         ├─16.第十六节-stream的Match用法.mp4     12.88MB
│         │         ├─17.第十七节-stream过滤器的用法.mp4     15.3MB
│         │         ├─18.第十八节-stream实现limit.mp4     21.43MB
│         │         ├─19.第十九节-stream实现对数据排序.mp4     17.53MB
│         │         ├─20.第二十节-stream实现一个综合案例.mp4     46.26MB
│         │         ├─21.第二十一节-JDK自带的函数接口.mp4     8.86MB
│         │         ├─22.第二十二节-并行流底层实现原理.mp4     26.69MB
│         │         ├─23.第二十三节-方法引入之静态方法引入.mp4     70.93MB
│         │         ├─24.第二十四节-方法引入之实例方法引入.mp4     19.52MB
│         │         ├─25.第二十五节-构造函数方法引入.mp4     17.4MB
│         │         ├─26.第二十六节-对象方法引入使用方式.mp4     39.73MB
│         │         ├─27.第二十七节-Optional判断对象是否为空.mp4     39.78MB
│         │         ├─28.第二十八节-Optional过滤与设定默认值.mp4     19.71MB
│         │         ├─29.第二十九节-Optional实战代码优化案例01.mp4     24.54MB
│         │         ├─30.第三十节-Optional实战代码优化案例02.mp4     27.84MB
│         │         ├─31.第三十一节-Optional实战代码优化案例03.mp4     12.61MB
│         │         └─32.第三十二节-Optional实战代码优化案例04.mp4     25.77MB
│         ├─02.第五期和第六期-自定义注解与反射技术
│         │   ├─01.第一节-反射与自定义原理课程安排.mp4     26.12MB
│         │   ├─02.第二节-什么是反射&反射基本概念.mp4     66.17MB
│         │   ├─03.第三节-反射的应用场景.mp4     56.53MB
│         │   ├─04.第四节-反射机制使用的三种方式.mp4     97.26MB
│         │   ├─05.第五节-使用反射机制初始化对象.mp4     45.42MB
│         │   ├─06.第六节-反射如何给属性赋值.mp4     68.21MB
│         │   ├─07.第七节-使用反射机制调用方法.mp4     58.27MB
│         │   ├─08.第八节-反射如何越过泛型检查.mp4     35.95MB
│         │   ├─09.第九节-注解的基本概念与介绍.mp4     126.8MB
│         │   ├─10.第十节-使用guava对微服务接口实现限流.mp4     37.52MB
│         │   ├─11.第十一节-使用aop环绕通知拦截目标方法01.mp4     72.21MB
│         │   ├─12.第十二节-使用aop环绕通知拦截目标方法02.mp4     156.9MB
│         │   ├─13.第十三节-使用aop+反射+自定义注解实现限流框架.mp4     113.5MB
│         │   └─代码和文档
│         │         └─001.蚂蚁课堂&-第九期-基础知识回顾之掌握Java反射自定义注解底层设计原理与封装限流的框架.rar     240.53KB
│         ├─03.第五期和第六期-多线程与实际项目综合应用     -1.#INDB
│         ├─04.第五期和第六期-HashMap和ConcurrentHashMap源码解读
│         │   ├─01.HashMap8源码解读-数组+链表&时间复杂度关系对比
│         │   │   ├─HashMap8源码解读 – 副本.doc     88.5KB
│         │   │   ├─HashMap8源码解读.doc     300KB
│         │   │   └─视频
│         │   │         ├─01.第一节-HashMap8源码解读课程安排.mp4     58.23MB
│         │   │         ├─02.第二节-为什么重写equals还要重写hashcode.mp4     83.65MB
│         │   │         ├─03.第三节-HashMap如何避免内存泄露问题.mp4     54.53MB
│         │   │         ├─04.第四节-基于Arraylist集合实现HashMap.mp4     53.14MB
│         │   │         ├─05.第五节-三种不同时间复杂度区别.mp4     31.25MB
│         │   │         ├─06.第六节-基于数组下标方式实现HashMap.mp4     57.95MB
│         │   │         ├─07.第七节-基于链表方式解决Hash碰撞问题.mp4     60.38MB
│         │   │         ├─08.第八节-HashMap如何遍历链表数据.mp4     26.55MB
│         │   │         ├─09.第九节-HashMap如何存放key为null.mp4     33.39MB
│         │   │         └─10.第十节-第一次课HashMap源码解读总结.mp4     55.54MB
│         │   ├─02-HashMap8源码解读-手写LRU缓存淘汰算法与HashMap如何降低Hash冲突概率
│         │   │   └─视频
│         │   │         ├─01.第一节-为什么HashMap是无序集合.mp4     42.53MB
│         │   │         ├─02.第二节-LinkedHashMap有序集合原理 .mp4     54.23MB
│         │   │         ├─03.第三节-缓存淘汰算法底层实现的原理.mp4     42.74MB
│         │   │         ├─04.第四节-LinkedHashMap的使用.mp4     49.54MB
│         │   │         ├─05.第五节-手写LRU缓存淘汰算法.mp4     34.13MB
│         │   │         ├─06.第六节-为什么HashMap不使用取模运算.mp4     36.95MB
│         │   │         ├─07.第七节-Java右移2底层实现原理.mp4     40.65MB
│         │   │         ├─08.第八节-Java左移2底层实现原理.mp4     10.54MB
│         │   │         ├─09.第九节-HashCode无符号右移16位原理.mp4     34.96MB
│         │   │         ├─10.第十节-^异或运算的原理.mp4     17.11MB
│         │   │         ├─11.第十一节-HashMap计算hash值的原理.mp4     24.49MB
│         │   │         ├─12.第十二节-HashMap与运算的实现原理.mp4     19.14MB
│         │   │         ├─13.第十三节-为什么n-1变成一个奇数01.mp4     27.58MB
│         │   │         ├─14.第十四节-为什么n-1变成一个奇数02.mp4     35.6MB
│         │   │         └─15.第十五节-HashMap如何实现降低Hash冲突概率.mp4     12.19MB
│         │   ├─03-HashMap8源码解读-HashMap8与HashMap7之间区别与扩容解决死循环问题
│         │   │   └─视频
│         │   │         ├─01.第一节-HashMap扩容源码解读课程安排.mp4     38.13MB
│         │   │         ├─02.第二节-HashMap核心参数有那些.mp4     114.29MB
│         │   │         ├─03.第三节-HashMap初始容量扩容原理01.mp4     47.49MB
│         │   │         ├─04.第四节-HashMap初始容量扩容原理02.mp4     35.83MB
│         │   │         ├─05.第五节-HashMapPut方法源码解读01.mp4     36.77MB
│         │   │         ├─06.第六节-HashMapPut方法源码解读02.mp4     77.81MB
│         │   │         ├─07.48.mp4     804.29MB
│         │   │         ├─07.第七节-HashMap的modCount的作用.mp4     35.41MB
│         │   │         ├─08.第八节-HashMap提前阈值扩容原理.mp4     51.44MB
│         │   │         ├─09.第九节-HashMap8与HashMap7扩容区别01.mp4     38.76MB
│         │   │         ├─10.第十节-误区HashMap扩容的是否会重新计算Hash.mp4     51.75MB
│         │   │         ├─11.第十一节-HashMap1.7扩容底层实现原理01.mp4     106.92MB
│         │   │         ├─12.第十二节-HashMap1.7扩容底层实现原理02.mp4     60.39MB
│         │   │         ├─13.第十三节-HashMap1.7扩容如何实现死循环问题.mp4     87MB
│         │   │         ├─14.第十四节-模拟HashMap1.7扩容死循环问题.mp4     30.07MB
│         │   │         ├─15.第十五节-为什么JDK官方不承认1.7扩容死循环问题.mp4     16.82MB
│         │   │         ├─16.第十六节-HashMap1.8如何避免多线程扩容死循环问题.mp4     68.74MB
│         │   │         ├─17.第十七节-HashMap8扩容与运算高位与低位链表结构01.mp4     69.47MB
│         │   │         ├─18.第十八节-HashMap8扩容与运算高位与低位链表结构02.mp4     55.17MB
│         │   │         ├─19.第十九节-为什么加载因子是0.75而不是1.mp4     21.75MB
│         │   │         ├─20.第二十节-HashMap如何存放1万条key效率最高.mp4     20.65MB
│         │   │         └─21.第二十一节-HashMap1.7与1.8有那些区别.mp4     36.28MB
│         │   ├─04-HashMap8源码解读-ConcurrentHashMap1.7源码解读
│         │   │   └─视频
│         │   │         ├─01.第一节-ConcurrentHashMap1.7源码解读课程安排.mp4     23.35MB
│         │   │         ├─02.第二节-简单回顾CAS乐观锁机制实现原理.mp4     90.3MB
│         │   │         ├─03.第三节-为什么多线程情况下不推荐使用HashTable.mp4     29.74MB
│         │   │         ├─04.第四节-ConcurrentHashMap1.7实现原理.mp4     47.94MB
│         │   │         ├─05.第五节-简单模拟手写ConcurrentHashMap.mp4     51.41MB
│         │   │         ├─06.第六节-ConcurrentHashMap扩容原理.mp4     9.1MB
│         │   │         ├─07.第七节-ConcurrentHashMap无参构造函数原理分析01.mp4     19.09MB
│         │   │         ├─08.第八节-ConcurrentHashMap无参构造函数原理分析02.mp4     97.63MB
│         │   │         ├─09.第九节-ConcurrentHashMapPut方法原理01.mp4     50.63MB
│         │   │         ├─10.第十节-ConcurrentHashMapPut方法原理02.mp4     64.4MB
│         │   │         ├─11.第十一节-ConcurrentHashMapPut方法原理03.mp4     42.3MB
│         │   │         ├─12.第十二节-ConcurrentHashMapPut方法原理04.mp4     40.57MB
│         │   │         ├─13.第十三节-ConcurrentHashMapPut方法原理05.mp4     50MB
│         │   │         ├─14.第十四节-ConcurrentHashMapPut方法原理06.mp4     25.9MB
│         │   │         ├─15.第十五节-ConcurrentHashMapPut1.7源码总结.mp4     30.36MB
│         │   │         └─腾讯课堂
│         │   │               └─07.49.mp4     546.75MB
│         │   ├─04.第五期和第六期-HashMap和ConcurrentHashMap源码解读
│         │   │   ├─01.HashMap8源码解读-数组+链表&时间复杂度关系对比
│         │   │   │   ├─HashMap8源码解读 – 副本.doc     88.5KB
│         │   │   │   ├─HashMap8源码解读.doc     300KB
│         │   │   │   └─视频
│         │   │   │         ├─01.第一节-HashMap8源码解读课程安排.mp4     58.23MB
│         │   │   │         ├─02.第二节-为什么重写equals还要重写hashcode.mp4     83.65MB
│         │   │   │         ├─03.第三节-HashMap如何避免内存泄露问题.mp4     54.53MB
│         │   │   │         ├─04.第四节-基于Arraylist集合实现HashMap.mp4     53.14MB
│         │   │   │         ├─05.第五节-三种不同时间复杂度区别.mp4     31.25MB
│         │   │   │         ├─06.第六节-基于数组下标方式实现HashMap.mp4     57.95MB
│         │   │   │         ├─07.第七节-基于链表方式解决Hash碰撞问题.mp4     60.38MB
│         │   │   │         ├─08.第八节-HashMap如何遍历链表数据.mp4     26.55MB
│         │   │   │         ├─09.第九节-HashMap如何存放key为null.mp4     33.39MB
│         │   │   │         └─10.第十节-第一次课HashMap源码解读总结.mp4     55.54MB
│         │   │   ├─02-HashMap8源码解读-手写LRU缓存淘汰算法与HashMap如何降低Hash冲突概率
│         │   │   │   └─视频
│         │   │   │         ├─01.第一节-为什么HashMap是无序集合.mp4     42.53MB
│         │   │   │         ├─02.第二节-LinkedHashMap有序集合原理 .mp4     54.23MB
│         │   │   │         ├─03.第三节-缓存淘汰算法底层实现的原理.mp4     42.74MB
│         │   │   │         ├─04.第四节-LinkedHashMap的使用.mp4     49.54MB
│         │   │   │         ├─05.第五节-手写LRU缓存淘汰算法.mp4     34.13MB
│         │   │   │         ├─06.第六节-为什么HashMap不使用取模运算.mp4     36.95MB
│         │   │   │         ├─07.第七节-Java右移2底层实现原理.mp4     40.65MB
│         │   │   │         ├─08.第八节-Java左移2底层实现原理.mp4     10.54MB
│         │   │   │         ├─09.第九节-HashCode无符号右移16位原理.mp4     34.96MB
│         │   │   │         ├─10.第十节-^异或运算的原理.mp4     17.11MB
│         │   │   │         ├─11.第十一节-HashMap计算hash值的原理.mp4     24.49MB
│         │   │   │         ├─12.第十二节-HashMap与运算的实现原理.mp4     19.14MB
│         │   │   │         ├─13.第十三节-为什么n-1变成一个奇数01.mp4     27.58MB
│         │   │   │         ├─14.第十四节-为什么n-1变成一个奇数02.mp4     35.6MB
│         │   │   │         └─15.第十五节-HashMap如何实现降低Hash冲突概率.mp4     12.19MB
│         │   │   ├─03-HashMap8源码解读-HashMap8与HashMap7之间区别与扩容解决死循环问题
│         │   │   │   └─视频
│         │   │   │         ├─01.第一节-HashMap扩容源码解读课程安排.mp4     38.13MB
│         │   │   │         ├─02.第二节-HashMap核心参数有那些.mp4     114.29MB
│         │   │   │         ├─03.第三节-HashMap初始容量扩容原理01.mp4     47.49MB
│         │   │   │         ├─04.第四节-HashMap初始容量扩容原理02.mp4     35.83MB
│         │   │   │         ├─05.第五节-HashMapPut方法源码解读01.mp4     36.77MB
│         │   │   │         ├─06.第六节-HashMapPut方法源码解读02.mp4     77.81MB
│         │   │   │         ├─07.48.mp4     804.29MB
│         │   │   │         ├─07.第七节-HashMap的modCount的作用.mp4     35.41MB
│         │   │   │         ├─08.第八节-HashMap提前阈值扩容原理.mp4     51.44MB
│         │   │   │         ├─09.第九节-HashMap8与HashMap7扩容区别01.mp4     38.76MB
│         │   │   │         ├─10.第十节-误区HashMap扩容的是否会重新计算Hash.mp4     51.75MB
│         │   │   │         ├─11.第十一节-HashMap1.7扩容底层实现原理01.mp4     106.92MB
│         │   │   │         ├─12.第十二节-HashMap1.7扩容底层实现原理02.mp4     60.39MB
│         │   │   │         ├─13.第十三节-HashMap1.7扩容如何实现死循环问题.mp4     87MB
│         │   │   │         ├─14.第十四节-模拟HashMap1.7扩容死循环问题.mp4     30.07MB
│         │   │   │         ├─15.第十五节-为什么JDK官方不承认1.7扩容死循环问题.mp4     16.82MB
│         │   │   │         ├─16.第十六节-HashMap1.8如何避免多线程扩容死循环问题.mp4     68.74MB
│         │   │   │         ├─17.第十七节-HashMap8扩容与运算高位与低位链表结构01.mp4     69.47MB
│         │   │   │         ├─18.第十八节-HashMap8扩容与运算高位与低位链表结构02.mp4     55.17MB
│         │   │   │         ├─19.第十九节-为什么加载因子是0.75而不是1.mp4     21.75MB
│         │   │   │         ├─20.第二十节-HashMap如何存放1万条key效率最高.mp4     20.65MB
│         │   │   │         └─21.第二十一节-HashMap1.7与1.8有那些区别.mp4     36.28MB
│         │   │   ├─03-HashMap8源码解读-HashMap8与HashMap7之间区别与扩容解决死循环问题(2)
│         │   │   ├─04-HashMap8源码解读-ConcurrentHashMap1.7源码解读
│         │   │   │   ├─视频
│         │   │   │   │   ├─01.第一节-ConcurrentHashMap1.7源码解读课程安排.mp4     23.35MB
│         │   │   │   │   ├─02.第二节-简单回顾CAS乐观锁机制实现原理.mp4     90.3MB
│         │   │   │   │   ├─03.第三节-为什么多线程情况下不推荐使用HashTable.mp4     29.74MB
│         │   │   │   │   ├─04.第四节-ConcurrentHashMap1.7实现原理.mp4     47.94MB
│         │   │   │   │   ├─05.第五节-简单模拟手写ConcurrentHashMap.mp4     51.41MB
│         │   │   │   │   ├─06.第六节-ConcurrentHashMap扩容原理.mp4     9.1MB
│         │   │   │   │   ├─07.第七节-ConcurrentHashMap无参构造函数原理分析01.mp4     19.09MB
│         │   │   │   │   ├─08.第八节-ConcurrentHashMap无参构造函数原理分析02.mp4     97.63MB
│         │   │   │   │   ├─09.第九节-ConcurrentHashMapPut方法原理01.mp4     50.63MB
│         │   │   │   │   ├─10.第十节-ConcurrentHashMapPut方法原理02.mp4     64.4MB
│         │   │   │   │   ├─11.第十一节-ConcurrentHashMapPut方法原理03.mp4     42.3MB
│         │   │   │   │   ├─12.第十二节-ConcurrentHashMapPut方法原理04.mp4     40.57MB
│         │   │   │   │   ├─13.第十三节-ConcurrentHashMapPut方法原理05.mp4     50MB
│         │   │   │   │   ├─14.第十四节-ConcurrentHashMapPut方法原理06.mp4     25.9MB
│         │   │   │   │   ├─15.第十五节-ConcurrentHashMapPut1.7源码总结.mp4     30.36MB
│         │   │   │   │   └─腾讯课堂
│         │   │   │   │         └─07.49.mp4     546.75MB
│         │   │   │   └─视频(2)
│         │   │   ├─05.HashMap8源码解读-ConcurrentHashMap1.8源码解读
│         │   │   │   ├─视频
│         │   │   │   │   ├─01.第一节-ConcurrentHashMap1.8源码解读课程安排.mp4     38.48MB
│         │   │   │   │   ├─02.第二节-HashMap集合底层原理回顾.mp4     50.46MB
│         │   │   │   │   ├─03.第三节-ConcurrentHashMap1.8原理分析.mp4     73.52MB
│         │   │   │   │   ├─04.第四节-ConcurrentHashMap初始化有可能cpu飙升问题.mp4     167.24MB
│         │   │   │   │   ├─05.第五节-ConcurrentHashMapPut方法原理分析.mp4     107.29MB
│         │   │   │   │   ├─06.第六节-ConcurrentHashMap求和原理.mp4     104.06MB
│         │   │   │   │   ├─07.第七节-为什么ConcurrentHashMap1.8需要去除Segments分段锁?.mp4.baiduyun.p.downloading     -1.#INDB
│         │   │   │   │   ├─08.第八节-为什么ConcurrentHashMap1.8使用synchronized而不使用lock锁?.mp4.baiduyun.p.downloading     -1.#INDB
│         │   │   │   │   ├─09.第九节-为什么ConcurrentHashMap1.8原理总结.mp4     25.92MB
│         │   │   │   │   └─腾讯课堂
│         │   │   │   │         └─07.50.mp4     713.65MB
│         │   │   │   └─视频(2)
│         │   │   └─HashMap8源码解读.doc     851.5KB
│         │   ├─04.第五期和第六期-HashMap和ConcurrentHashMap源码解读(2)
│         │   │   ├─01.HashMap8源码解读-数组+链表&时间复杂度关系对比
│         │   │   │   └─视频
│         │   │   ├─02-HashMap8源码解读-手写LRU缓存淘汰算法与HashMap如何降低Hash冲突概率
│         │   │   ├─03-HashMap8源码解读-HashMap8与HashMap7之间区别与扩容解决死循环问题
│         │   │   └─05.HashMap8源码解读-ConcurrentHashMap1.8源码解读
│         │   │         └─视频
│         │   ├─05.HashMap8源码解读-ConcurrentHashMap1.8源码解读
│         │   │   └─视频
│         │   │         ├─01.第一节-ConcurrentHashMap1.8源码解读课程安排.mp4     38.48MB
│         │   │         ├─02.第二节-HashMap集合底层原理回顾.mp4     50.46MB
│         │   │         ├─03.第三节-ConcurrentHashMap1.8原理分析.mp4     73.52MB
│         │   │         ├─04.第四节-ConcurrentHashMap初始化有可能cpu飙升问题.mp4     167.24MB
│         │   │         ├─05.第五节-ConcurrentHashMapPut方法原理分析.mp4     107.29MB
│         │   │         ├─06.第六节-ConcurrentHashMap求和原理.mp4     104.06MB
│         │   │         ├─07.第七节-为什么ConcurrentHashMap1.8需要去除Segments分段锁?.mp4     18.56MB
│         │   │         ├─08.第八节-为什么ConcurrentHashMap1.8使用synchronized而不使用lock锁?.mp4     18.84MB
│         │   │         ├─09.第九节-为什么ConcurrentHashMap1.8原理总结.mp4     25.92MB
│         │   │         └─腾讯课堂
│         │   │               └─07.50.mp4     713.65MB
│         │   └─HashMap8源码解读.doc     851.5KB
│         ├─05.第五期和第六期-List集合源码解读
│         │   └─List集合源码分析
│         │         ├─HashMap8源码解读05.doc     928.5KB
│         │         ├─代码
│         │         ├─笔记.txt     3.25KB
│         │         └─视频
│         │               ├─01.第一节-时间复杂度o(n)、o(1)、o(n)之间的区别.mp4     68.18MB
│         │               ├─02.第二节-Arraylist集合Put方法实现原理.mp4     47.55MB
│         │               ├─03.第三节-Arraylist扩容方法底层原理分析01.mp4     47.74MB
│         │               ├─04.第四节-Arraylist扩容方法底层原理分析02.mp4     44.41MB
│         │               ├─05.第五节-Arraylist扩容方法底层缩容实现原理.mp4     72.9MB
│         │               ├─06.第六节-modCount作用有那些.mp4     19.38MB
│         │               ├─07.51.mp4     544.76MB
│         │               ├─07.第七节-Arraylist与Vector实现的区别.mp4     27.35MB
│         │               ├─08.第八节-HashMap集合中是否存在缩容.mp4     12.03MB
│         │               ├─09.第九节-HashSet集合底层实现原理.mp4     61.32MB
│         │               ├─10.第十节-LinkedList底层数据结构模型.mp4     50.45MB
│         │               ├─11.第十一节-LinkedList底层实现Add方法实现原理01.mp4     61.75MB
│         │               ├─12.第十二节-LinkedList底层实现Add方法实现原理02.mp4     40.24MB
│         │               ├─13.第十三节-LinkedList的集合折半查找原理01.mp4     36.12MB
│         │               ├─14.第十四节-LinkedList的集合折半查找原理02.mp4     52.53MB
│         │               ├─15.第十五节-LinkedList的集合remove方法原理.mp4     65.99MB
│         │               ├─发布视频.txt     840B
│         │               └─腾讯课堂
│         │                     ├─07.51.mp4     544.76MB
│         │                     ├─J[9YCTJ~FNIN](5{YC1N{}J.png     173.23KB
│         │                     ├─L%6@8QE%K5~)[ZLQ3%]]RMT.png     326.23KB
│         │                     └─~N1[02UZ`{ZB0LX)7K`8KEP.png     323.5KB
│         ├─06.第五期和第六期-精通23种设计模式
│         │   ├─001-蚂蚁课堂&-精讲设计模式之策略模式
│         │   │   ├─01.第一节-设计模式课程相关说明.mp4     89.71MB
│         │   │   ├─02.第二节-为什么需要使用策略模式.mp4     65.72MB
│         │   │   ├─03.第三节-策略模式实现底层类图01.mp4     102.03MB
│         │   │   ├─04.第四节-策略模式实现底层类图02.mp4     46.63MB
│         │   │   ├─05.第五节-基于枚举+工厂方式实现策略模式.mp4     108.71MB
│         │   │   ├─06.第六节-使用Context上下获取具体策略.mp4     95.5MB
│         │   │   ├─07.第七节-基于数据库形式实现策略模式.mp4     108.99MB
│         │   │   ├─08.第八节-Spring框架中那些地方使用策略模式.mp4     85MB
│         │   │   ├─Thumbs.db     35.5KB
│         │   │   ├─上课代码
│         │   │   │   └─mayikt_springboot_strategy.rar     24.75KB
│         │   │   ├─上课内容.txt     447B
│         │   │   ├─之前上课代码
│         │   │   │   └─springboot_strategy.rar     19.26KB
│         │   │   ├─合成.mp4     618.99MB
│         │   │   ├─备课代码
│         │   │   │   └─mayikt_strategy.rar     28.2KB
│         │   │   ├─策略模式.png     251.92KB
│         │   │   ├─精讲设计模式之策略模式.doc     229.5KB
│         │   │   └─精讲设计模式之策略模式.pptx     694.98KB
│         │   ├─002-蚂蚁课堂&-精讲设计模式之责任链模式
│         │   │   ├─01.第一节-责任链模式的应用场景.mp4     95.25MB
│         │   │   ├─02.第二节-责任链底层实现原理与类图.mp4     55.77MB
│         │   │   ├─03.第三节-使用工厂模式实现责任链模式01.mp4     73.1MB
│         │   │   ├─04.第四节-使用工厂模式实现责任链模式02.mp4     84.87MB
│         │   │   ├─05.第五节-使用数据库方式实现责任链模式01.mp4     79.36MB
│         │   │   ├─06.第六节-使用数据库方式实现责任链模式02.mp4     94.66MB
│         │   │   ├─07.第七节-断点调试数据库实现责任链模式.mp4     101MB
│         │   │   ├─08.第八节-java过滤器底层责任链模式分析.mp4     55.04MB
│         │   │   ├─Thumbs.db     39.5KB
│         │   │   ├─~$精讲设计模式之责任链模式.pptx     165B
│         │   │   ├─~WRL0003.tmp     372KB
│         │   │   ├─上课内容.txt     442B
│         │   │   ├─上课的代码
│         │   │   │   └─mayikt_handler.rar     23.07KB
│         │   │   ├─备课代码
│         │   │   │   └─meite_handler.rar     234.94MB
│         │   │   ├─精讲设计模式之责任链模式.doc     369.5KB
│         │   │   ├─精讲设计模式之责任链模式.pptx     1.35MB
│         │   │   └─责任脸设计模式.png     70.43KB
│         │   ├─003-蚂蚁课堂&-精讲设计模式之模版方法设计模式
│         │   │   ├─01.第一节-工厂模式简单的介绍.mp4     61.56MB
│         │   │   ├─02.第二节-静态工厂的使用介绍.mp4     73.79MB
│         │   │   ├─03.第三节-Spring框架源码工厂的使用.mp4     71.27MB
│         │   │   ├─04.第四节-模版方法设计模式简单介绍.mp4     82.64MB
│         │   │   ├─05.第五节-定义模版方法设计模式共同骨架.mp4     87.36MB
│         │   │   ├─06.第六节-模版方法设计模式具体的实现.mp4     95.92MB
│         │   │   ├─07.第七节-使用工厂模式获取具体实现模版.mp4     138.39MB
│         │   │   ├─08.第八节-模版方法与策略模式的区别.mp4     45.22MB
│         │   │   ├─09.第九节-servlet底层模版方法的使用.mp4     23.26MB
│         │   │   ├─mayikt_template
│         │   │   │   └─mayikt_template.rar     23.47KB
│         │   │   ├─Thumbs.db     14KB
│         │   │   ├─上课内容.txt     377B
│         │   │   ├─上课源码
│         │   │   │   └─meite_template.rar     19.23KB
│         │   │   ├─第五期互联网架构海报V1.png     5.23MB
│         │   │   ├─精讲设计模式之模版方法.doc     482.5KB
│         │   │   └─精讲设计模式之模版方法设计模式.pptx     1.35MB
│         │   ├─004-蚂蚁课堂&-精讲设计模式之装饰模式
│         │   │   ├─Redis-x64-3.2.100 (1).zip     4.98MB
│         │   │   ├─代码
│         │   │   │   └─代码.rar     33.61KB
│         │   │   ├─基于装饰模式设计多级缓存框架.pptx     3.76MB
│         │   │   ├─笔记3.doc     21.5KB
│         │   │   ├─视频
│         │   │   │   ├─01.第一节-基于装饰模式手写多级缓存框架演示.mp4     62.43MB
│         │   │   │   ├─02.第二节-一级与二级缓存基本的概念.mp4     44.06MB
│         │   │   │   ├─03.第三节-基于HashMap手写Jvm内置缓存.mp4     53.45MB
│         │   │   │   ├─04.第四节-手写模拟一级与二级缓存基本概念.mp4     76.38MB
│         │   │   │   ├─05.第五节-装饰模式基本架构设计原理.mp4     36.79MB
│         │   │   │   ├─06.第六节-定义早期装饰模式一级缓存.mp4     38.79MB
│         │   │   │   ├─07.第七节-基于装饰模式重构设计多级缓存.mp4     67.5MB
│         │   │   │   ├─08.第八节-基于继承的模式实现装饰模式.mp4     27.89MB
│         │   │   │   ├─09.第九节-基于Aop拦截自定义缓存注解.mp4     65.59MB
│         │   │   │   ├─10.第十节-使用Aop回调形式传递目标方法.mp4     88.02MB
│         │   │   │   ├─11.第十一节-补习Aop拦截目标回传思路.mp4     36.53MB
│         │   │   │   ├─12.第十二节-使用泛型接收反射获取目标方法类型.mp4     30.41MB
│         │   │   │   └─腾讯课堂
│         │   │   │         └─01.第一节-基于装饰模式手写多级缓存框架.mp4     649.74MB
│         │   │   └─设计模式04.doc     345KB
│         │   ├─005-蚂蚁课堂&-精讲设计模式之观察者模式
│         │   │   ├─源码
│         │   │   │   └─源码.rar     66.05KB
│         │   │   ├─视频
│         │   │   │   ├─01.第一节-观察者模式课程内容的引入.mp4     42.51MB
│         │   │   │   ├─02.第二节-观察者模式的应用场景.mp4     40.07MB
│         │   │   │   ├─03.第三节-观察者模式类图结构的分析.mp4     27.35MB
│         │   │   │   ├─04.第四节-定义观察者模式的接口.mp4     49.57MB
│         │   │   │   ├─05.第五节-项目启动注册读观察者.mp4     58.34MB
│         │   │   │   ├─06.第六节-测试使用观察者群发不同渠道.mp4     20.92MB
│         │   │   │   ├─07.第七节-使用Spring事件通知回调.mp4     84.53MB
│         │   │   │   ├─08.第八节-优化代码改为自动注册ObServer.mp4     22.38MB
│         │   │   │   ├─Thumbs.db     25KB
│         │   │   │   ├─基于装饰模式设计多级缓存框架.pptx     3.76MB
│         │   │   │   ├─备课
│         │   │   │   │   └─mayikt_observer.rar     23.54KB
│         │   │   │   ├─笔记4.doc     20KB
│         │   │   │   └─设计模式05.doc     452KB
│         │   │   └─讲义
│         │   │         ├─新建文本文档.txt     60B
│         │   │         ├─精讲设计模式之纯手动态代理模式.pptx     1.24MB
│         │   │         ├─精讲设计模式之观察者模式.doc     875KB
│         │   │         └─观察者模式.txt     278B
│         │   ├─006-蚂蚁课堂&-精讲设计模式之门面与状态模式
│         │   │   ├─代码
│         │   │   │   └─上课代码
│         │   │   │         ├─上课代码.rar     22.54KB
│         │   │   │         ├─上课通知.txt     286B
│         │   │   │         ├─备课代码.zip     55.32KB
│         │   │   │         └─新建文件夹
│         │   │   │               └─meite_order.rar     15.99KB
│         │   │   ├─视频
│         │   │   │   ├─01.第一节-为什么需要使用外观模式.mp4     99.38MB
│         │   │   │   ├─02.第二节-使用外观模式重构复杂业务逻辑代码.mp4     97.74MB
│         │   │   │   ├─03.第三节-总结外观模式的优缺点.mp4     35.56MB
│         │   │   │   ├─04.第四节-状态模式与策略模式的区别.mp4     110.34MB
│         │   │   │   └─05.第五节-使用状态模式解决多重if判断.mp4     146.38MB
│         │   │   └─讲义
│         │   │         ├─~$设计模式之门面与状态模式.doc     162B
│         │   │         ├─备课代码
│         │   │         │   └─备课代码.rar     20.37KB
│         │   │         └─精讲设计模式之门面与状态模式.doc     981.5KB
│         │   ├─007-蚂蚁课堂&-精讲设计模式之深入理解单例
│         │   │   ├─代码
│         │   │   │   └─代码.rar     46.59KB
│         │   │   ├─视频
│         │   │   │   ├─01.第一节-单例模式之饿汉式模式.mp4     47.32MB
│         │   │   │   ├─02.第二节-单例模式之懒汉式模式(线程不安全).mp4     80.63MB
│         │   │   │   ├─03.第三节-单例模式之双重检验锁原理.mp4     120.57MB
│         │   │   │   ├─04.第四节-单例模式之静态内部内方式.mp4     63.65MB
│         │   │   │   ├─05.第五节-单例模式之使用反射技术破节单例.mp4     62.48MB
│         │   │   │   ├─06.第六节-单例模式之使用序列化破解单例.mp4     52.84MB
│         │   │   │   ├─07.第七节-单例模式之枚举方式防止破解.mp4     24.66MB
│         │   │   │   └─新建文本文档.txt     -1.#INDB
│         │   │   └─讲义
│         │   │         ├─上课内容.txt     277B
│         │   │         ├─深入理解单例模式.doc     1.16MB
│         │   │         └─精讲设计模式之深入理解单例.pptx     1.24MB
│         │   ├─008-蚂蚁课堂&-精讲设计模式之利用反编译技术深入理解枚举单例底层实现原理
│         │   │   ├─Java反编译器.zip     309.37KB
│         │   │   ├─Thumbs.db     12.5KB
│         │   │   ├─新建文本文档.txt     365B
│         │   │   ├─精讲设计模式之枚举单例原理.pptx     1.24MB
│         │   │   ├─视频
│         │   │   │   ├─01.第一节-枚举单例源码课程介绍.mp4     50.73MB
│         │   │   │   ├─02.第二节-Java反射技术简单回顾.mp4     106.93MB
│         │   │   │   ├─03.第三节-使用反射技术破解枚举单例.mp4     40.8MB
│         │   │   │   ├─04.第四节-使用Java反编译技术分析枚举源码.mp4     118.89MB
│         │   │   │   ├─05.第五节-分析枚举单例为什么不能反射.mp4     56.48MB
│         │   │   │   ├─06.第六节-精讲设计模式总结.mp4     117.15MB
│         │   │   │   └─Thumbs.db     21.5KB
│         │   │   └─讲义
│         │   │         ├─-精讲设计模式之利用反编译技术深入理解枚举单例底层实现原理.pptx     1.24MB
│         │   │         ├─上课内容.txt     277B
│         │   │         └─精讲设计模式之利用反编译技术深入理解枚举单例底层实现原理.doc     1.37MB
│         │   └─06.第五期和第六期-精通23种设计模式
│         │         ├─001-蚂蚁课堂&-精讲设计模式之策略模式
│         │         │   ├─01.第一节-设计模式课程相关说明.mp4     90.3MB
│         │         │   ├─02.第二节-为什么需要使用策略模式.mp4     66.31MB
│         │         │   ├─03.第三节-策略模式实现底层类图01.mp4     102.61MB
│         │         │   ├─04.第四节-策略模式实现底层类图02.mp4     47.22MB
│         │         │   ├─05.第五节-基于枚举+工厂方式实现策略模式.mp4     109.3MB
│         │         │   ├─06.第六节-使用Context上下获取具体策略.mp4     96.09MB
│         │         │   ├─07.第七节-基于数据库形式实现策略模式.mp4     109.58MB
│         │         │   ├─08.第八节-Spring框架中那些地方使用策略模式.mp4     85.59MB
│         │         │   ├─上课代码
│         │         │   │   └─mayiktspringbootstrategy.rar     7.22KB
│         │         │   ├─上课内容.txt     447B
│         │         │   ├─之前上课代码
│         │         │   │   └─springbootstrategy.rar     6.81KB
│         │         │   ├─合成.mp4     619.58MB
│         │         │   ├─备课代码
│         │         │   │   └─mayiktstrategy.rar     13.65KB
│         │         │   ├─策略模式.png     251.92KB
│         │         │   ├─精讲设计模式之策略模式.doc     229.5KB
│         │         │   └─精讲设计模式之策略模式.pptx     711.22KB
│         │         ├─002-蚂蚁课堂&-精讲设计模式之责任链模式
│         │         │   ├─01.第一节-责任链模式的应用场景.mp4     95.83MB
│         │         │   ├─02.第二节-责任链底层实现原理与类图.mp4     56.36MB
│         │         │   ├─03.第三节-使用工厂模式实现责任链模式01.mp4     73.69MB
│         │         │   ├─04.第四节-使用工厂模式实现责任链模式02.mp4     85.46MB
│         │         │   ├─05.第五节-使用数据库方式实现责任链模式01.mp4     79.95MB
│         │         │   ├─06.第六节-使用数据库方式实现责任链模式02.mp4     95.25MB
│         │         │   ├─07.第七节-断点调试数据库实现责任链模式.mp4     101.58MB
│         │         │   ├─08.第八节-java过滤器底层责任链模式分析.mp4     55.63MB
│         │         │   ├─~$精讲设计模式之责任链模式.pptx     165B
│         │         │   ├─~WRL0003.tmp     372KB
│         │         │   ├─上课内容.txt     442B
│         │         │   ├─上课的代码
│         │         │   │   └─mayikthandler.rar     13KB
│         │         │   ├─备课代码
│         │         │   │   └─meitehandler.rar     6.86KB
│         │         │   ├─精讲设计模式之责任链模式.doc     369.5KB
│         │         │   ├─精讲设计模式之责任链模式.pptx     1.36MB
│         │         │   └─责任脸设计模式.png     70.43KB
│         │         ├─003-蚂蚁课堂&-精讲设计模式之模版方法设计模式
│         │         │   ├─01.第一节-工厂模式简单的介绍.mp4     62.15MB
│         │         │   ├─02.第二节-静态工厂的使用介绍.mp4     74.37MB
│         │         │   ├─03.第三节-Spring框架源码工厂的使用.mp4     71.85MB
│         │         │   ├─04.第四节-模版方法设计模式简单介绍.mp4     83.22MB
│         │         │   ├─05.第五节-定义模版方法设计模式共同骨架.mp4     87.95MB
│         │         │   ├─06.第六节-模版方法设计模式具体的实现.mp4     96.51MB
│         │         │   ├─07.第七节-使用工厂模式获取具体实现模版.mp4     138.98MB
│         │         │   ├─08.第八节-模版方法与策略模式的区别.mp4     45.81MB
│         │         │   ├─09.第九节-servlet底层模版方法的使用.mp4     23.85MB
│         │         │   ├─mayikttemplate
│         │         │   │   └─mayikttemplate.rar     17.38KB
│         │         │   ├─上课内容.txt     377B
│         │         │   ├─上课源码
│         │         │   │   └─meitetemplate.rar     8.88KB
│         │         │   ├─第五期互联网架构海报V1.png     5.23MB
│         │         │   ├─精讲设计模式之模版方法.doc     482.5KB
│         │         │   └─精讲设计模式之模版方法设计模式.pptx     1.36MB
│         │         ├─004-蚂蚁课堂&-精讲设计模式之装饰模式
│         │         │   ├─Redis-x64-3.2.100 (1).zip     4.98MB
│         │         │   ├─代码
│         │         │   │   └─代码.rar     14.54KB
│         │         │   ├─基于装饰模式设计多级缓存框架.pptx     3.86MB
│         │         │   ├─笔记3.doc     21.5KB
│         │         │   ├─视频
│         │         │   │   ├─01.第一节-基于装饰模式手写多级缓存框架演示.mp4     63.02MB
│         │         │   │   ├─02.第二节-一级与二级缓存基本的概念.mp4     44.65MB
│         │         │   │   ├─03.第三节-基于HashMap手写Jvm内置缓存.mp4     54.04MB
│         │         │   │   ├─04.第四节-手写模拟一级与二级缓存基本概念.mp4     76.96MB
│         │         │   │   ├─05.第五节-装饰模式基本架构设计原理.mp4     37.38MB
│         │         │   │   ├─06.第六节-定义早期装饰模式一级缓存.mp4     39.38MB
│         │         │   │   ├─07.第七节-基于装饰模式重构设计多级缓存.mp4     68.09MB
│         │         │   │   ├─08.第八节-基于继承的模式实现装饰模式.mp4     28.48MB
│         │         │   │   ├─09.第九节-基于Aop拦截自定义缓存注解.mp4     66.18MB
│         │         │   │   ├─10.第十节-使用Aop回调形式传递目标方法.mp4     88.61MB
│         │         │   │   ├─11.第十一节-补习Aop拦截目标回传思路.mp4     37.12MB
│         │         │   │   ├─12.第十二节-使用泛型接收反射获取目标方法类型.mp4     30.99MB
│         │         │   │   └─腾讯课堂
│         │         │   │         └─01.第一节-基于装饰模式手写多级缓存框架.mp4     650.33MB
│         │         │   └─设计模式04.doc     345KB
│         │         ├─005-蚂蚁课堂&-精讲设计模式之观察者模式
│         │         │   ├─源码
│         │         │   │   └─源码.rar     15.04KB
│         │         │   ├─视频
│         │         │   │   ├─01.第一节-观察者模式课程内容的引入.mp4     43.1MB
│         │         │   │   ├─02.第二节-观察者模式的应用场景.mp4     40.66MB
│         │         │   │   ├─03.第三节-观察者模式类图结构的分析.mp4     27.94MB
│         │         │   │   ├─04.第四节-定义观察者模式的接口.mp4     50.16MB
│         │         │   │   ├─05.第五节-项目启动注册读观察者.mp4     58.92MB
│         │         │   │   ├─06.第六节-测试使用观察者群发不同渠道.mp4     21.51MB
│         │         │   │   ├─07.第七节-使用Spring事件通知回调.mp4     85.11MB
│         │         │   │   ├─08.第八节-优化代码改为自动注册ObServer.mp4     22.97MB
│         │         │   │   ├─基于装饰模式设计多级缓存框架.pptx     3.86MB
│         │         │   │   ├─备课
│         │         │   │   │   └─mayiktobserver.rar     7.59KB
│         │         │   │   ├─备课(2)
│         │         │   │   │   └─mayiktobserver.rar     250B
│         │         │   │   ├─笔记4.doc     20KB
│         │         │   │   └─设计模式05.doc     452KB
│         │         │   └─讲义
│         │         │         ├─新建文本文档.txt     60B
│         │         │         ├─精讲设计模式之纯手动态代理模式.pptx     1.26MB
│         │         │         ├─精讲设计模式之观察者模式.doc     875KB
│         │         │         └─观察者模式.txt     278B
│         │         ├─005-蚂蚁课堂&-精讲设计模式之观察者模式(2)
│         │         │   └─源码
│         │         │         └─源码.rar     1.42KB
│         │         ├─006-蚂蚁课堂&-精讲设计模式之门面与状态模式
│         │         │   ├─代码
│         │         │   │   ├─beikedaima
│         │         │   │   │   └─mayiktfacade.rar     11.16KB
│         │         │   │   └─上课代码
│         │         │   │         ├─上课代码.rar     13.68KB
│         │         │   │         ├─上课通知.txt     286B
│         │         │   │         ├─备课代码.zip     55.32KB
│         │         │   │         └─新建文件夹
│         │         │   │               └─meiteorder.rar     5.67KB
│         │         │   ├─视频
│         │         │   │   ├─01.第一节-为什么需要使用外观模式.mp4     99.97MB
│         │         │   │   ├─02.第二节-使用外观模式重构复杂业务逻辑代码.mp4     98.33MB
│         │         │   │   ├─03.第三节-总结外观模式的优缺点.mp4     36.15MB
│         │         │   │   ├─04.第四节-状态模式与策略模式的区别.mp4     110.93MB
│         │         │   │   └─05.第五节-使用状态模式解决多重if判断.mp4     146.97MB
│         │         │   └─讲义
│         │         │         └─讲义.rar     668.39KB
│         │         ├─007-蚂蚁课堂&-精讲设计模式之深入理解单例
│         │         │   ├─.DSStore【瑞客论坛 www.ruike1     8KB
│         │         │   ├─代码
│         │         │   │   └─代码.rar     6.54KB
│         │         │   ├─视频
│         │         │   │   ├─01.第一节-单例模式之饿汉式模式.mp4     47.91MB
│         │         │   │   ├─02.第二节-单例模式之懒汉式模式(线程不安全).mp4     81.22MB
│         │         │   │   ├─03.第三节-单例模式之双重检验锁原理.mp4     121.16MB
│         │         │   │   ├─04.第四节-单例模式之静态内部内方式.mp4     64.24MB
│         │         │   │   ├─05.第五节-单例模式之使用反射技术破节单例.mp4     62.48MB
│         │         │   │   ├─06.第六节-单例模式之使用序列化破解单例.mp4     52.84MB
│         │         │   │   └─07.第七节-单例模式之枚举方式防止破解.mp4     24.66MB
│         │         │   └─讲义
│         │         │         ├─上课内容.txt     277B
│         │         │         ├─深入理解单例模式.doc     1.16MB
│         │         │         └─精讲设计模式之深入理解单例.pptx     1.26MB
│         │         └─008-蚂蚁课堂&-精讲设计模式之利用反编译技术深入理解枚举单例底层实现原理
│         │               ├─Java反编译器.zi     303B
│         │               ├─Java反编译器.zip     309.05KB
│         │               ├─新建文本文档.txt     365B
│         │               ├─精讲设计模式之枚举单例原理.pptx     1.26MB
│         │               ├─视频
│         │               │   ├─01.第一节-枚举单例源码课程介绍.mp4     51.32MB
│         │               │   ├─02.第二节-Java反射技术简单回顾.mp4     107.52MB
│         │               │   ├─03.第三节-使用反射技术破解枚举单例.mp4     41.39MB
│         │               │   ├─04.第四节-使用Java反编译技术分析枚举源码.mp4     119.48MB
│         │               │   ├─05.第五节-分析枚举单例为什么不能反射.mp4     57.07MB
│         │               │   └─06.第六节-精讲设计模式总结.mp4     117.74MB
│         │               └─讲义
│         │                     ├─-精讲设计模式之利用反编译技术深入理解枚举单例底层实现原理.pptx     1.26MB
│         │                     ├─上课内容.txt     277B
│         │                     └─精讲设计模式之利用反编译技术深入理解枚举单例底层实现原理.doc     1.37MB
│         ├─07.第五期和第六期-java并发编程入门到精通
│         │   ├─01.第一章-线程池实现原理
│         │   │   ├─02.第二节-为什么需要使用线程池.mp4     48.9MB
│         │   │   ├─03.第三节-实际项目中哪些地方使用线程池.mp4     14.19MB
│         │   │   ├─04.第四节-线程池有哪些作用呢.mp4     33.84MB
│         │   │   ├─05.第五节-线程池创建的方式有哪些呢.mp4     49.46MB
│         │   │   ├─06.第六节-线程池底层复用机制的原理.mp4     62.13MB
│         │   │   ├─07.第七节-java纯手写线程池.mp4     91.69MB
│         │   │   ├─08.第八节-线程池创建的线程会一直运行吗.mp4     47.31MB
│         │   │   ├─09.第九节-ThreadPoolExecutor构造函数原理.mp4     65.7MB
│         │   │   ├─10.第十节-线程池队列满了,任务会丢失吗.mp4     21.66MB
│         │   │   └─相关代码
│         │   │         ├─mayikt-threads2021.rar     20.67KB
│         │   │         └─相关代码.rar     4.06KB
│         │   ├─02.第二章-CAS底层实现原理
│         │   │   ├─相关代码
│         │   │   │   ├─mayiktvolatile.rar     4.33KB
│         │   │   │   └─mayikt_volatile.rar     20.36KB
│         │   │   └─视频
│         │   │         ├─01.第一节-什么是悲观锁.mp4     78.5MB
│         │   │         ├─02.第二节-mysql乐观锁实现原理.mp4     169.34MB
│         │   │         ├─03.第三节-谈谈你对公平锁与非公平锁理解.mp4     101.09MB
│         │   │         ├─04.第四节-什么是锁的可重入性.mp4     10.48MB
│         │   │         ├─05.第五节-谈谈cas锁的理解.mp4     57.15MB
│         │   │         ├─06.第六节-cas底层实现原理.mp4     81.91MB
│         │   │         ├─08.第七节-如何利用cas手写一把锁.mp4     73.45MB
│         │   │         ├─09.第八节-使用cas锁的优缺点.mp4     22.44MB
│         │   │         └─10.第九节-cas锁如何避免aba的问题.mp4     32.4MB
│         │   ├─03.第三章-Threadlocal内存泄漏问题
│         │   │   ├─01.第一节-threadlocal内存泄漏常见面试题.mp4     78.83MB
│         │   │   ├─02.第二节-threadlocal应用场景有哪些.mp4     53.21MB
│         │   │   ├─03.第三节-threadlocal底层实现原理.mp4     63.38MB
│         │   │   ├─04.第四节-为什么线程缓存的是ThreadlocalMap对象.mp4     57.21MB
│         │   │   ├─05.第五节-强、软、弱引用之间的区别.mp4     71.54MB
│         │   │   ├─06.第六节-threadlocal内存泄漏问题.mp4     104.18MB
│         │   │   ├─07.第七节-threadlocal如何避免内存泄漏.mp4     46.31MB
│         │   │   └─code
│         │   │         ├─mayiktvolatile.rar     12.7KB
│         │   │         └─mayikt_volatile.rar     27.88KB
│         │   └─04.第四章-aqs底层架构设计原理
│         │         ├─01.第一节-谈谈Lock与synchronized区别.mp4     54.61MB
│         │         ├─02.第二节-LockSupport用法 .mp4     29.72MB
│         │         ├─03.第三节-aqs底层如何实现原理.mp4     228.08MB
│         │         ├─04.第四节-cas+LockSupport+aqs手写Lock锁.mp4     181.85MB
│         │         ├─05.第五节-Semaphore信号量底层原理.mp4     37.57MB
│         │         ├─06.第六节-CountDownLatch底层实现原理.mp4     22.54MB
│         │         └─code
│         │               ├─mayiktvolatile.rar     234.95MB
│         │               └─mayikt_volatile.rar     39.42KB
│         ├─08.第五期和第六期-nginx入门到精通
│         │   ├─01-蚂蚁课堂&-Nginx与高可用实战之Nginx反向代理&负载均衡&正向代理
│         │   │   ├─Nginx.docx     86.58KB
│         │   │   ├─Nginx.pptx     1.07MB
│         │   │   ├─nginx第一天.png     543.16KB
│         │   │   ├─代码
│         │   │   │   └─mayikt_meite_2019.rar     8.19KB
│         │   │   ├─笔记.doc     72.5KB
│         │   │   ├─视频
│         │   │   │   ├─01.第一节-Nginx课程内容安全介绍.mp4     27.43MB
│         │   │   │   ├─02.第二节-DNS域名解析整个过程.mp4     69.39MB
│         │   │   │   ├─03.第三节-使用Nginx搭建反向代理整个过程.mp4     62.93MB
│         │   │   │   ├─04.第四节-Nginx实现反向代理与正向代理区别.mp4     39.36MB
│         │   │   │   ├─05.第五节-windows环境中安装Nginx服务器.mp4     39.08MB
│         │   │   │   ├─06.第六节-使用Nginx配置反向代理方式.mp4     59.34MB
│         │   │   │   ├─07.第七节-服务器集群会存在那些问题.mp4     40.36MB
│         │   │   │   ├─08.第八节-使用Nginx实现对服务负载均衡.mp4     45.87MB
│         │   │   │   ├─09.第九节-软负载与硬负载实现有那些区别.mp4     26.35MB
│         │   │   │   ├─10.第十节-Nginx课后作业题.mp4     39.8MB
│         │   │   │   └─视频观看方式.txt     347B
│         │   │   ├─视频观看方式.txt     347B
│         │   │   └─资料
│         │   │         └─nginx-1.17.3.zip     1.62MB
│         │   ├─02-蚂蚁课堂&-Nginx与高可用实战之基于Nginx实现解决网站跨域问题
│         │   │   ├─Nginx.docx     94.67KB
│         │   │   ├─nginx第二次课.png     891.63KB
│         │   │   ├─Nginx解决跨域问题.pptx     1.07MB
│         │   │   ├─Thumbs.db     6KB
│         │   │   ├─上课导入代码
│         │   │   │   └─上课准备.rar     191.29KB
│         │   │   ├─新建文本文档.txt     133B
│         │   │   ├─笔记.doc     34KB
│         │   │   ├─视频
│         │   │   │   ├─01.第一节-在Linux服务器上安装Nginx服务器.mp4     55.15MB
│         │   │   │   ├─02.第二节-Nginx root 、alias指令区别.mp4     63MB
│         │   │   │   ├─03.第三节-Nginx快速回顾实现反向代理技术.mp4     43.04MB
│         │   │   │   ├─04.第四节-实际项目中跨域问题产生的背景.mp4     100.56MB
│         │   │   │   ├─05.第五节-基于JSONP解决项目中跨域问题.mp4     67.59MB
│         │   │   │   ├─06.第六节-使用HttpClient实现转发请求解决跨域.mp4     25.43MB
│         │   │   │   └─07.第七节-基于Nginx构建微服务网关解决跨域.mp4     81.97MB
│         │   │   └─课程内容.txt     344B
│         │   ├─03-Nginx与高可用实战之基于Nginx+Lvs+keepAlived实现高可用
│         │   │   ├─01.第一节-lvs实现对nginx一主一备效果演示.mp4     27.02MB
│         │   │   ├─02.第二节-项目在发布的过程中如何保证可用性.mp4     44.75MB
│         │   │   ├─03.第三节-lvs与Nginx实现负载均衡的区别.mp4     73.11MB
│         │   │   ├─04.第四节-Nginx+Lvs+keepAlived高可用原理.mp4     48.08MB
│         │   │   ├─05.第五节-Linux环境上安装keepAlived.mp4     88.7MB
│         │   │   ├─06.第六节-将keepAlived设置开机启动服务.mp4     33.7MB
│         │   │   ├─07.第七节-keepAlived对lvs开启虚拟vip配置.mp4     63.25MB
│         │   │   ├─08.第八节-keepAlived配置自动重启nginx脚本.mp4     32.88MB
│         │   │   ├─09.第九节-lvs实现对nginx一主一备.mp4     94.8MB
│         │   │   ├─10.第十节-注意阿里云服务器不支持虚拟vip技术.mp4     18.62MB
│         │   │   ├─Nginx第三次课.docx     97.01KB
│         │   │   ├─Nginx第三次课.pptx     1.07MB
│         │   │   ├─Thumbs.db     23.5KB
│         │   │   ├─课程内容.txt     284B
│         │   │   └─资料
│         │   │         └─资料.rar     1.37KB
│         │   ├─04-蚂蚁课堂&-Nginx与高可用实战之基于Nginx实现实战解决高并发
│         │   │   ├─01.第一节-Nginx实战解决高并发课程介绍.mp4     19.23MB
│         │   │   ├─02.第二节-什么是网站动静分离架构模式.mp4     38.89MB
│         │   │   ├─03.第三节-基于Nginx解决网站动静分离.mp4     75.41MB
│         │   │   ├─04.第四节-使用Nginx反向代理外部图片查看.mp4     31.97MB
│         │   │   ├─05.第五节-什么是服务器带宽不足的原因.mp4     59.81MB
│         │   │   ├─06.第六节-CDN内容分发基本的概念介绍.mp4     31.38MB
│         │   │   ├─07.第七节-CDN内容分发底层的实现原理.mp4     67.23MB
│         │   │   ├─08.第八节-使用七牛云作为静态资源服务器.mp4     47.54MB
│         │   │   ├─Nginx第四次课.docx     100.95KB
│         │   │   ├─Nginx第四次课.pptx     1.07MB
│         │   │   ├─Thumbs.db     13.5KB
│         │   │   └─课程内容.txt     302B
│         │   └─05-蚂蚁课堂&-Nginx与高可用实战之如何减少服务端带宽传输
│         │         ├─Nginx第五次课.docx     143.36KB
│         │         ├─nginx第四课.pptx     1.07MB
│         │         ├─Thumbs.db     12.5KB
│         │         ├─上课的代码
│         │         │   └─mayikt_0052.rar     38.1KB
│         │         ├─视频
│         │         │   ├─01.第一节-一个网站访问卡慢真正的原因.mp4     91.89MB
│         │         │   ├─02.第二节-静态资源手动压缩方案.mp4     88.95MB
│         │         │   ├─03.第三节-使用Nginx静态资源压缩实现原理.mp4     92.6MB
│         │         │   ├─04.第四节-大图片分段拆分展示方案.mp4     33.8MB
│         │         │   ├─05.第五节-浏览器静态资源缓存版本控制.mp4     46.54MB
│         │         │   ├─06.第六节-使用Nginx缓存静态页面设计思想.mp4     50.91MB
│         │         │   └─07.第七节-使用Nginx缓存商品详情页面.mp4     74.49MB
│         │         ├─课程内容.txt     280B
│         │         └─资料
│         │               └─资料.rar     157.84MB
│         ├─09.第五期和第六期-SpringBoot入门到精通
│         │   ├─code
│         │   │   └─code.rar     18.41MB
│         │   ├─springboot文档电子书.docx     493.49KB
│         │   ├─素材
│         │   │   └─2020logo.png     9.98KB
│         │   └─视频
│         │         ├─01.第一节-SpringBoot课程体系介绍.mp4     30.78MB
│         │         ├─02.第二节-为什么需要使用SpringBoot框架.mp4     41.51MB
│         │         ├─03.第三节-SpringBoot与SpringCloud的区别.mp4     26.67MB
│         │         ├─04.第四节-SpringBoot依赖引入介绍.mp4     50.82MB
│         │         ├─05.第五节-@RestController作用.mp4     23.03MB
│         │         ├─06.第六节-SpringBoot启动方式01.mp4     33.88MB
│         │         ├─07.第七节-SpringBoot启动方式02.mp4     33.01MB
│         │         ├─08.第八节-SpringBoot启动方式03.mp4     37.13MB
│         │         ├─09.第九节-SpringBoot整合静态资源访问.mp4     26.01MB
│         │         ├─10.第十节-yml与properties格式区别.mp4     42.28MB
│         │         ├─11.第十一节-什么模板引擎框架.mp4     27.66MB
│         │         ├─12.第十二节-SpringBoot整合ftl模板引擎.mp4     36.54MB
│         │         ├─13.第十三节-ftl模板引擎条件判断用法.mp4     26.62MB
│         │         ├─14.第十四节-thymeleaf渲染web页面.mp4     28.67MB
│         │         ├─15.第十七节-解决thymeleaf误报问题.mp4     8.6MB
│         │         ├─16.第十六节-thymeleaf循环和if判断写法.mp4     16.5MB
│         │         ├─17.第十七节-整合JdbcTemplate.mp4     47.13MB
│         │         ├─18.第十八节-整合mybatis框架查询.mp4     69.55MB
│         │         ├─19.第十九节-整合mybatis插入操作.mp4     13.73MB
│         │         ├─20.第二十节-整合devtools工具.mp4     35.1MB
│         │         ├─21.第二十一节-整合lombok简化代码.mp4     69.76MB
│         │         ├─22.第二十二节-使用@value注解读取配置文件.mp4     23.91MB
│         │         ├─23.第二十三节-Properties转换yml格式.mp4     9.55MB
│         │         ├─24.第二十四节-@ConfigurationProperties.mp4     40.7MB
│         │         ├─25.第二十五节-配置文件占位符用法.mp4     9.51MB
│         │         ├─26.第二十六节-整合多环境不同配置文件.mp4     25.44MB
│         │         ├─27.第二十七节-修改端口与上下文路径.mp4     26MB
│         │         ├─28.第二十八节-logback配置日志级别.mp4     33.39MB
│         │         ├─29.第二十九节-整合logback配置.mp4     53.38MB
│         │         ├─30.第三十节-整合log4j日志.mp4     30.53MB
│         │         ├─31.第三十一节-使用aop统一打印日志信息.mp4     52.13MB
│         │         ├─32.第三十节-整合定时任务注解.mp4     12.19MB
│         │         ├─33.第三十三节-定时整任务合Quartz 表达式.mp4     17.44MB
│         │         ├─34.第三十四节-如何整合异步的线程.mp4     38.14MB
│         │         ├─35.第三十五节-注意@Async失效问题.mp4     54.21MB
│         │         ├─36.第三十六节-@Async整合线程池.mp4     31.15MB
│         │         ├─37.第三十七节-整合全局捕获异常.mp4     27.42MB
│         │         ├─38.第三十八节-打包运行发布.mp4     28.07MB
│         │         ├─bandicam 2021-01-27 05-19-59-289.mp4     20.44MB
│         │         └─问题反馈.png     35.43KB
│         ├─10.第五期和第六期-Redis入门到精通
│         │   ├─01.第六期微服务架构-Redis实战原理剖析-Redis持久化与集群机制
│         │   │   ├─beikedaima.rar     7.93KB
│         │   │   ├─mayikt2020redis.zip     38.38KB
│         │   │   ├─Redis持久化与集群机制.docx     148.85KB
│         │   │   ├─Redis环境搭建与数据结构原理.pptx     921.65KB
│         │   │   ├─视频
│         │   │   │   ├─01.Redis持久化原理与一致性原理课程介绍.mp4     26.35MB
│         │   │   │   ├─02.使用Redis二进制形式存储对象.mp4     94.75MB
│         │   │   │   ├─03.SpringBoot整合Redis注解版本.mp4     124.46MB
│         │   │   │   ├─04.MySQL与Redis一致性解决方案.mp4     67.78MB
│         │   │   │   ├─05.全量同步与增量同步实现的区别.mp4     54.07MB
│         │   │   │   ├─06.RedisRDB持久化实现原理.mp4     122.44MB
│         │   │   │   └─07.RedisAOF持久化实现原理.mp4     99.12MB
│         │   │   └─课程内容.txt     285B
│         │   ├─02..第六期微服务架构-Redis实战原理剖析-Redis环境搭建与数据结构原理
│         │   │   ├─Redis环境搭建与数据结构原理.docx     37.25KB
│         │   │   ├─Redis环境搭建与数据结构原理.pptx     921.51KB
│         │   │   ├─上课代码
│         │   │   │   └─mayikt2020redis.rar     5.6KB
│         │   │   ├─上课通知.txt     304B
│         │   │   ├─视频
│         │   │   │   ├─01.Redis高级内容课程内容介绍.mp4     37.09MB
│         │   │   │   ├─02.Redis分布式缓存与本地缓存.mp4     45.94MB
│         │   │   │   ├─03.Redis的应用场景有那些.mp4     47.44MB
│         │   │   │   ├─04.Redis线程模型IO多路复用.mp4     80.52MB
│         │   │   │   ├─05.Redis前台启动环境安装.mp4     65.16MB
│         │   │   │   ├─06.Redis设置允许外界访问.mp4     72.19MB
│         │   │   │   ├─07.Redis分为16个库的作用.mp4     12.12MB
│         │   │   │   ├─08.Redis的五种数据类型.mp4     47.15MB
│         │   │   │   └─09.SpringBoot整合Redis框架.mp4     109.14MB
│         │   │   └─资料
│         │   │         ├─redis-5.0.6.tar.gz     1.89MB
│         │   │         ├─redisclient-客户端工具.zip     41.86MB
│         │   │         └─新建文本文档.txt     11B
│         │   ├─03.第六期微服务架构-Redis实战原理剖析-Redis六大淘汰策略&事务原理&过期key事件监听
│         │   │   ├─Redis主从复制与集群原理.docx     165.79KB
│         │   │   ├─Redis环境搭建与数据结构原理.pptx     921.6KB
│         │   │   ├─shangkedaima
│         │   │   │   └─mayikt2020redis.rar     10.29KB
│         │   │   └─视频
│         │   │         ├─01.第一节-回顾上节课Redis核心内容.mp4     55.62MB
│         │   │         ├─02.第二节-Redis核心六大淘汰策略.mp4     106.79MB
│         │   │         ├─03.第三节-RedisKey过期回调监听.mp4     50.05MB
│         │   │         ├─04.第四节-Redis环境配置对key过期监听.mp4     78.01MB
│         │   │         ├─05.第五节-基于Redis过期回调实现订单30分钟有效期.mp4     110.32MB
│         │   │         ├─06.第六节-Redis中的事务策略Multi.mp4     97.38MB
│         │   │         └─07.第七节-Redis的Watch与Multi区别.mp4     46.21MB
│         │   ├─04.第六期微服务架构-Redis实战原理剖析-基于Redis实现分布式锁
│         │   │   ├─shengkediama
│         │   │   │   └─mayiktredislock.rar     9.51KB
│         │   │   ├─基于Redis实现分布式锁.docx     173.57KB
│         │   │   ├─基于Redis实现分布式锁.pptx     921.58KB
│         │   │   ├─视频
│         │   │   │   ├─01.第一节-Redis中为什么没有回滚的事务.mp4     54.82MB
│         │   │   │   ├─02.第二节-什么是分布式锁?应用场景有那些.mp4     47.07MB
│         │   │   │   ├─03.第三节-Redis实现分布式锁核心的思路.mp4     46.51MB
│         │   │   │   ├─04.第四节-基于Redis实现分布式锁的思路.mp4     45.01MB
│         │   │   │   ├─05.第五节-基于Redis实现获取锁代码实现.mp4     73.77MB
│         │   │   │   ├─06.第六节-基于Redis实现释放锁代码实现.mp4     28.76MB
│         │   │   │   ├─07.第七节-测试基于Redis实现分布式锁代码.mp4     51.54MB
│         │   │   │   ├─08.第八节-在使用分布式锁如果超时了,如何处理.mp4     30.37MB
│         │   │   │   └─09.第九节-zk与Redis实现分布式锁的优缺点.mp4     49.57MB
│         │   │   └─课程内容.txt     280B
│         │   ├─05.第六期微服务架构-Redis实战原理剖析-Redis主从复制&哨兵机制&集群分片原理
│         │   │   ├─~$Redis哨兵实现原理.docx     162B
│         │   │   ├─~WRL0343.tmp     318.56KB
│         │   │   ├─~WRL1298.tmp     319.92KB
│         │   │   ├─~WRL2899.tmp     319.72KB
│         │   │   ├─基于Redis哨兵实现原理.docx     315.76KB
│         │   │   ├─基于Redis哨兵实现原理.pptx     921.61KB
│         │   │   ├─视频
│         │   │   │   ├─01.第一节-上节课内容简单回顾.mp4     34.4MB
│         │   │   │   ├─02.第二节-本节课核心哨兵核心内容.mp4     26.84MB
│         │   │   │   ├─03.第三节-Redis集群主从之分概念.mp4     48.04MB
│         │   │   │   ├─04.第四节-Redis主从复制整个原理过程.mp4     53.06MB
│         │   │   │   ├─05.第五节-传统一主多从复制存在那些问题.mp4     49.68MB
│         │   │   │   ├─06.第六节-在Redis中配置一主多从关系.mp4     92.01MB
│         │   │   │   ├─07.第七节-主从复制存在那些缺陷BUg.mp4     67.7MB
│         │   │   │   ├─08.第八节-哨兵集群架构设计原理.mp4     105.5MB
│         │   │   │   ├─09.第九节-master如何确定宕机重新选举.mp4     39.23MB
│         │   │   │   ├─10.第十节-配置Redis哨兵集群高可用01.mp4     215.35MB
│         │   │   │   ├─11.第十一节-配置Redis哨兵集群高可用02.mp4     47.09MB
│         │   │   │   ├─12.第十二节-哨兵集群配置需要注意的事项1.mp4     81.72MB
│         │   │   │   ├─13.第十三节-哨兵集群配置需要注意的事项2.mp4     120.02MB
│         │   │   │   ├─14.第十四节-Redis缓存穿透概念与解决方案.mp4     120.85MB
│         │   │   │   ├─15.第十五节-Redis缓存击穿概念与解决方案.mp4     84.95MB
│         │   │   │   └─16.第十六节-Redis缓存雪崩概念与解决方案.mp4     37.03MB
│         │   │   └─课程内容.txt     345B
│         │   ├─06.第六期微服务架构-Redis实战原理剖析-RedisCluster集群实现原理
│         │   │   ├─mayikt2020redis
│         │   │   │   └─mayikt2020redis.rar     7.61KB
│         │   │   ├─redis-cluster
│         │   │   │   └─redis-cluster.rar     163.77KB
│         │   │   ├─redis.conf     60.34KB
│         │   │   ├─上课代码
│         │   │   │   └─mayikt2020redis.rar     7.65KB
│         │   │   ├─基于Redis哨兵实现原理.docx     421.67KB
│         │   │   ├─基于Redis哨兵实现原理.pptx     921.58KB
│         │   │   └─视频
│         │   │         ├─01.第一节-回顾Redis主从复制与哨兵机制.mp4     23.3MB
│         │   │         ├─02.第二节-传统Redis哨兵集群存在那些缺陷.mp4     54.17MB
│         │   │         ├─03.第三节-RedisCluster分片集群实现原理.mp4     123.26MB
│         │   │         ├─04.第四节-基于不同Redis配置文件启动多个不同的Redis.mp4     40.37MB
│         │   │         ├─05.第五节-Linux环境上搭建RedisCluster.mp4     84.15MB
│         │   │         └─06.第六节-RedisClient连接Redis分片集群.mp4     90.41MB
│         │   ├─07.第六期微服务架构-Redis实战原理剖析-RedisCluster扩容与缩容&Jedis支持集群原理
│         │   │   ├─redis-cluster
│         │   │   │   └─redis-cluster.rar     250.83KB
│         │   │   ├─RedisCluster扩容与缩容.docx     417.01KB
│         │   │   ├─Redis面试题.docx     417.01KB
│         │   │   ├─Redis面试题总结.pptx     921.73KB
│         │   │   ├─基于Redis哨兵实现原理.pptx     921.56KB
│         │   │   ├─视频
│         │   │   │   ├─01.第一节-快速回顾搭建RedisCluster集群.mp4     93.93MB
│         │   │   │   ├─02.第二节-RedisCluster快速实现扩容原理.mp4     56.95MB
│         │   │   │   ├─03.第三节-演示一个搭建RedisCluster错误场景.mp4     183.24MB
│         │   │   │   ├─04.第四节-以正确的方式搭建RedisCluster集群.mp4     118.92MB
│         │   │   │   ├─05.第五节-RedisCluster快速的实现卡槽扩容.mp4     78.77MB
│         │   │   │   ├─06.第六节-master节点宕机之后重新实现选举.mp4     20.45MB
│         │   │   │   ├─07.第七节-RedisCluster快速的实现缩容.mp4     43.75MB
│         │   │   │   └─08.第八节-JedisCluster支持集群原理.mp4     58.94MB
│         │   │   └─课程内容.txt     273B
│         │   └─08.第六期微服务架构-Redis实战原理剖析-Redis基于布隆过滤器解决缓存穿透问题
│         │         ├─code
│         │         │   └─mayikt2020redis
│         │         │         └─mayikt2020redis.rar     8.05KB
│         │         ├─Redis基于布隆过滤器解决缓存击穿问题.docx     423.58KB
│         │         ├─Redis基于布隆过滤器解决缓存击穿问题.pptx     905.53KB
│         │         ├─备课前导入代码
│         │         │   └─RedisCluster扩容与缩容.docx     417.01KB
│         │         └─视频
│         │               ├─01.第一节-缓存穿透常用解决方案有那些.mp4     86.48MB
│         │               ├─02.第二节-布隆过滤器简单的介绍.mp4     60.46MB
│         │               ├─03.第三节-布隆过滤器实现原理的分析.mp4     68.1MB
│         │               ├─04.第四节-java语言使用布隆过滤器使用.mp4     55.34MB
│         │               ├─05.第五节-布隆过滤器如何减少误判的概率.mp4     49.32MB
│         │               └─06.第六节-使用布隆过滤器解决Redis穿透问题.mp4     53.59MB
│         ├─11.第五期和第六期-Zookeeper分布式协调工具
│         │   ├─01-蚂蚁课堂&-分布式协调工具Zookeeper-基于Zookeeper实现服务注册与发现
│         │   │   ├─beikedaima
│         │   │   │   └─beikedaima.rar     7.6KB
│         │   │   ├─mayiktzk
│         │   │   │   └─mayiktzk.rar     6.63KB
│         │   │   ├─Zookeeper分布式协调.docx     28.48KB
│         │   │   ├─.DSStore     12KB
│         │   │   ├─上课代码
│         │   │   │   ├─mayiktspringbootweb.zip     20.45KB
│         │   │   │   └─mayiktzk.zip     46.71KB
│         │   │   ├─分布式协调工具Zookeeper-Zookeeper快速入门.pptx     1.07MB
│         │   │   ├─国庆节最后五节课内容.txt     629B
│         │   │   ├─视频
│         │   │   │   ├─01.基于Zookeeper实现动态负载均衡课程介绍.mp4     54.63MB
│         │   │   │   ├─02.Zookeeper实际案例中的应用场景.mp4     22.79MB
│         │   │   │   ├─03.Zookeeper基本的实现的特征.mp4     55.55MB
│         │   │   │   ├─04.基于linux环境安装Zookeeper.mp4     84.64MB
│         │   │   │   ├─05.注意安装Zookeeper前安装Jdk环境.mp4     7.67MB
│         │   │   │   ├─06.Java语言客户端连接Zookeeper.mp4     68.18MB
│         │   │   │   ├─07.Countdown计算器优化ZK代码.mp4     45.47MB
│         │   │   │   ├─08.Zookeeper四种节点类型.mp4     47.77MB
│         │   │   │   ├─09.Zookeeper节点ACL权限控制.mp4     63.11MB
│         │   │   │   ├─10.使用Zookeeper实现服务注册.mp4     118.38MB
│         │   │   │   └─11.使用Zookeeper实现服务发现.mp4     21.85MB
│         │   │   └─资料
│         │   │         └─资料.rar     38.85MB
│         │   ├─02-蚂蚁课堂&-分布式协调工具Zookeeper-基于Zookeeper实现分布式锁
│         │   │   ├─beikedaima
│         │   │   │   └─mayiktzk.rar     6.1KB
│         │   │   ├─上课代码
│         │   │   │   └─mayiktzk.rar     234.93MB
│         │   │   ├─基于Zookeeper实现分布式锁.docx     37.46KB
│         │   │   ├─基于Zookeeper实现分布式锁.pptx     1.09MB
│         │   │   ├─视频
│         │   │   │   ├─01.第一节-Zookeeper基础知识点回顾.mp4     32.98MB
│         │   │   │   ├─02.第二节-Zookeeper实现事件监听通知.mp4     92.8MB
│         │   │   │   ├─03.第三节-多线程情况下生成订单号码存在那些问题.mp4     99.13MB
│         │   │   │   ├─04.第四节-Zookeeper实现分布式锁基本设计思路.mp4     81.29MB
│         │   │   │   ├─05.第五节-使用模版方法设计模式定义共同锁骨架.mp4     56.11MB
│         │   │   │   ├─06.第六节-Zookeeper实现分布式锁代码实现.mp4     60.95MB
│         │   │   │   ├─07.第七节-Zookeeper效果整体演示.mp4     95.9MB
│         │   │   │   ├─08.第八节-Zookeeper超时了,如何防止死锁问题.mp4     26.12MB
│         │   │   │   └─09.第九节-Zookeeper实现分布式锁事件移出.mp4     7.14MB
│         │   │   └─课程内容.txt     271B
│         │   ├─03-蚂蚁课堂&-分布式协调工具Zookeeper-Zookeeper集群环境搭建
│         │   │   ├─test01.txt     82B
│         │   │   ├─Zookeeper集群一致性原理.docx     87.33KB
│         │   │   ├─Zookeeper集群一致性原理.pptx     1.07MB
│         │   │   ├─视频
│         │   │   │   ├─01.Zookeeper集群选举效果演示.mp4     51.74MB
│         │   │   │   ├─02.分布式理论强一致性概念.mp4     47.6MB
│         │   │   │   ├─03.分布式理论最终一致性概念.mp4     32.76MB
│         │   │   │   ├─04.生活案例实际讲解一致性原理.mp4     28.12MB
│         │   │   │   ├─05.Zookeeper集群选举原理策略20220609110523.mp4     57.09MB
│         │   │   │   ├─05.Zookeeper集群选举原理策略.mp4     57.68MB
│         │   │   │   ├─06.构建Zookeeper集群环境01.mp4     64.13MB
│         │   │   │   ├─07.构建Zookeeper集群环境02.mp4     126.26MB
│         │   │   │   └─08.为什么Zookeeper集群节点一定要是奇数.mp4     38.16MB
│         │   │   └─课程内容.txt     375B
│         │   └─04-蚂蚁课堂&-分布式协调工具Zookeeper-Zookeeper一致性原理
│         │         ├─zk原理图.xsd     41.13KB
│         │         ├─Zookeeper集群一致性原理.docx     228.25KB
│         │         ├─笔记.doc     21KB
│         │         ├─视频
│         │         │   ├─01.Zookeeper集群可能会存在的问题.mp4     46.31MB
│         │         │   ├─02.Zk集群使用Observer实现扩展.mp4     75.24MB
│         │         │   ├─03.如何在Zk集群配置ObServer.mp4     41.69MB
│         │         │   ├─04.Zookeeper客户端连接集群地址.mp4     66.12MB
│         │         │   ├─05.ZAB原子广播协议两种模型.mp4     42.2MB
│         │         │   ├─06.Zookeeper集群解决数据一致性原理.mp4     114.98MB
│         │         │   ├─07.Zookeeper集群策略zxid的作用.mp4     102.36MB
│         │         │   ├─08.分布式情况下网络抖动脑裂概念.mp4     31.41MB
│         │         │   ├─09.分布式架构中CAP与Base理论.mp4     25.77MB
│         │         │   ├─10.Eureka与Zk作为注册中心区别.mp4     64.33MB
│         │         │   └─11.Zookeeper集群课后疑问.mp4     27.04MB
│         │         └─课程内容.txt     371B
│         ├─12.第五期和第六期-SpringCloud入Alibaba入门到精通
│         │   ├─01.第六期微服务架构-SpringCloudAlibaba-微服务架构演变过程
│         │   │   ├─ppt.pptx     3.91MB
│         │   │   ├─SpringCloudAlibaba.doc     437.5KB
│         │   │   ├─上课代码
│         │   │   │   └─上课代码.rar     1.94MB
│         │   │   ├─备课代码
│         │   │   │   └─备课代码.rar     1.94MB
│         │   │   ├─笔记第一天.doc     35.5KB
│         │   │   ├─视频
│         │   │   │   ├─01.第一节-SpringCloudAlibaba课程内容介绍.mp4     83.81MB
│         │   │   │   ├─02.第二节-微服务架构演变过程之传统架构.mp4     60.6MB
│         │   │   │   ├─03.第三节-微服务架构演变过程之分布式架构.mp4     32.65MB
│         │   │   │   ├─04.第四节-微服务架构演变过程之SOA面向服务架构.mp4     66.27MB
│         │   │   │   ├─05.第五节-基于Idea快速搭建WebService服务.mp4     84.87MB
│         │   │   │   ├─06.第六节-SOA架构模式存在那些缺点.mp4     28.22MB
│         │   │   │   ├─07.第七节-微服务架构演变过程之微服务架构模式.mp4     49.25MB
│         │   │   │   ├─08.第八节-微服务架构与SOA架构模式实现区别.mp4     90.12MB
│         │   │   │   ├─09.第九节-微服务架构中会存在那些问题01.mp4     32.06MB
│         │   │   │   ├─10.第十节-微服务架构中会存在那些问题02.mp4     12.72MB
│         │   │   │   ├─11.第十一节-什么公司情况下互采用SpringCloud.mp4     38.72MB
│         │   │   │   └─12.第十二节-SpringCloud第一代与第二代的区别.mp4     96.14MB
│         │   │   └─课程内容.txt     345B
│         │   ├─02.第六期微服务架构-SpringCloudAlibaba-Nacos实现服务注册与发现
│         │   │   ├─1578386307(1).jpg     45.68KB
│         │   │   ├─Nacos实现服务注册与发现.pptx     3.86MB
│         │   │   ├─SpringCloudAlibaba第二次课.doc     557KB
│         │   │   ├─上课代码
│         │   │   │   └─mayiktmeitealibabanacos.rar     19.8KB
│         │   │   ├─工具
│         │   │   │   └─nacos-server-1.1.4.zip     49.7MB
│         │   │   ├─笔记第二天.doc     51.5KB
│         │   │   ├─视频
│         │   │   │   ├─01.第一节-SpringCloudalibaba与SpringCloud区别.mp4     74.76MB
│         │   │   │   ├─02.第二节-微服务服务治理核心概念.mp4     53MB
│         │   │   │   ├─03.第三节-传统服务注册中心实现方式.mp4     35.88MB
│         │   │   │   ├─04.第四节-.分布式注册中心的实现原理.mp4     102.66MB
│         │   │   │   ├─05.第五节-Nacos的基本的介绍.mp4     81.01MB
│         │   │   │   ├─06.第六节-使用命令形式对Nacos实现注册.mp4     45.34MB
│         │   │   │   ├─07.第七节-创建生产者实现服务的注册.mp4     61.1MB
│         │   │   │   ├─08.第八节-使用discoveryClient从注册中心获取接口地址.mp4     42.49MB
│         │   │   │   ├─09.第九节-使用restTemplate实现rpc远程调用.mp4     66.84MB
│         │   │   │   ├─09.第九节-联调测试异步回调代码的实现.mp4     109.47MB
│         │   │   │   ├─09.第九节-联调测试异步回调代码的实现.png     330.1KB
│         │   │   │   ├─10.第十节-纯手写本地负载均衡器轮训算法.mp4     96.18MB
│         │   │   │   └─11.第十一节-实现服务下线动态感知.mp4     46.41MB
│         │   │   └─课程内容.txt     278B
│         │   ├─03.第六期微服务架构-SpringCloudAlibaba-本地负载均衡器与opefen声明式客户端调用工具
│         │   │   ├─Nacos实现服务注册与发现.pptx     3.84MB
│         │   │   ├─SpringCloudAlibaba第三次课.doc     580.5KB
│         │   │   ├─代码
│         │   │   │   └─代码.rar     38.92KB
│         │   │   ├─备课写入的代码
│         │   │   │   ├─备课写入的.rar     251B
│         │   │   │   └─备课写入的代码.rar     40.64KB
│         │   │   ├─备课前导入的代码
│         │   │   │   └─mayiktmeitealibabanacos.rar     20.67KB
│         │   │   ├─笔记第二天.doc     59.5KB
│         │   │   ├─视频
│         │   │   │   ├─01.第一节-回顾上节课内容负载均衡器.mp4     39.02MB
│         │   │   │   ├─02.第二节-本地负载均衡与Nginx区别.mp4     61.46MB
│         │   │   │   ├─03.第三节-@LoadBalanced结合Rest.mp4     53.88MB
│         │   │   │   ├─04.第四节-使用LoadBalancedClient实现负载.mp4     106.15MB
│         │   │   │   ├─05.第五节-LoadBalanced实现的原理.mp4     69.04MB
│         │   │   │   ├─06.第六期节-openfeign客户端与feign客户端区别.mp4     76.6MB
│         │   │   │   ├─07.第七节-如何采用idea构建微服务架构项目.mp4     88.11MB
│         │   │   │   ├─08.第八节-使用openfeign客户端调用微服务接口.mp4     145.63MB
│         │   │   │   ├─09.第九节-openfeign客户端支持集群模式.mp4     23.73MB
│         │   │   │   └─10.第十节-openfeign客户端调用命名规范.mp4     46.9MB
│         │   │   └─课程内容.txt     18B
│         │   ├─04.第六期微服务架构-SpringCloudAlibaba-Nacos集群部署实现原理
│         │   │   ├─Nacos实现高可用集群环境.pptx     3.86MB
│         │   │   ├─SpringCloudAlibaba第五次课.doc     775.5KB
│         │   │   ├─代码
│         │   │   │   └─代码.rar     19.82KB
│         │   │   ├─笔记第二天.doc     98KB
│         │   │   ├─视频
│         │   │   │   ├─01.第一节-Nacos集群的课程内容介绍.mp4     20.6MB
│         │   │   │   ├─02.第二节-部署伪集群Nacos模式.mp4     132.16MB
│         │   │   │   ├─03.第三节-构建Nacos集群模式注意事项.mp4     106.57MB
│         │   │   │   ├─04.第四节-注册中心设计Ap与CP区别.mp4     110.38MB
│         │   │   │   ├─05.第五节-Eureka与Zookeeper的区别.mp4     98.8MB
│         │   │   │   ├─06.第六节-Nacos与Eureka的区别.mp4     88.31MB
│         │   │   │   ├─07.第七节-分布式一致性算法有那些.mp4     24.59MB
│         │   │   │   ├─08.第八节-简单回顾Nacos与Eureka的区别.mp4     42.68MB
│         │   │   │   ├─09.第九节-分布式事务与分布式一致性的区别.mp4     20.7MB
│         │   │   │   ├─10.第十节-简单回顾Zab协议集群模式原理.mp4     52.68MB
│         │   │   │   ├─11.第十一-Zab协议如何保持数据的一致性.mp4     67.42MB
│         │   │   │   ├─12.第十二节-Raft协议选举基本的概念.mp4     55.87MB
│         │   │   │   ├─13. 第十三节-Raft协议选举底层实现原理.mp4     83.2MB
│         │   │   │   ├─14.第十四节-Raft生成的随机一样如何处理.mp4     32.98MB
│         │   │   │   ├─15.第十五节-Raft协议故障重新选举.mp4     34.24MB
│         │   │   │   └─16.第十六节-Raft采用日志复制形式同步数据.mp4     51.87MB
│         │   │   └─课程内容.txt     503B
│         │   ├─08.第六期微服务架构-SpringCloudAlibaba-新一代服务网关Gateway
│         │   │   ├─SpringCloudAlibaba第六次课.doc     801KB
│         │   │   ├─上课代码
│         │   │   │   └─mayikt-gateway.rar     13.88KB
│         │   │   ├─备课之前代码
│         │   │   │   └─备课之前代码.rar     47.45KB
│         │   │   ├─新一代服务网关Gateway.pptx     3.86MB
│         │   │   ├─笔记第二天.doc     28KB
│         │   │   ├─视频
│         │   │   │   ├─01.第一节-新一代服务网关Gateway课程介绍.mp4     10.76MB
│         │   │   │   ├─02.第二节-为什么需要使用微服务网关.mp4     91.12MB
│         │   │   │   ├─03.第三节-过滤器与微服务网关的区别.mp4     11.27MB
│         │   │   │   ├─04.第四节-Zuul网关与Gateway之间的区别.mp4     34.44MB
│         │   │   │   ├─05.第五节-构建SpringCloudGateway.mp4     100.87MB
│         │   │   │   ├─06.第六节-GateWay实现转发真实微服务接口.mp4     46.6MB
│         │   │   │   ├─07.第七节-Nginx与网关之前存在那些区别.mp4     36.78MB
│         │   │   │   └─08.第八节-Gateway全局过滤使用方法.mp4     114.81MB
│         │   │   └─课程.txt     319B
│         │   ├─09.第六期微服务架构-SpringCloudAlibaba-Gateway高可用集群与动态网关
│         │   │   ├─95.第六期微服务架构-SpringCloudAlibaba-基于Naocs构建分布式配置中心
│         │   │   │   ├─mayikt_nacos_client.rar     8.53KB
│         │   │   │   ├─nacos-1.1.4.zip     4.39MB
│         │   │   │   ├─Nacos实现高可用集群环境(2).pptx     3.84MB
│         │   │   │   ├─Nacos实现高可用集群环境.pptx     3.84MB
│         │   │   │   ├─SpringCloudAlibaba第四次课(2).doc     739.5KB
│         │   │   │   ├─SpringCloudAlibaba第四次课.doc     730.5KB
│         │   │   │   ├─笔记第二天(2).doc     93KB
│         │   │   │   ├─笔记第二天.doc     69.5KB
│         │   │   │   ├─视频
│         │   │   │   │   ├─01.第一节-Nacos课程基本回顾(2).mp4     47.44MB
│         │   │   │   │   ├─01.第一节-Nacos课程基本回顾.mp4     47.44MB
│         │   │   │   │   ├─02.第二节-分布式配置中心产生的背景(2).mp4     66.81MB
│         │   │   │   │   ├─02.第二节-分布式配置中心产生的背景.mp4     66.81MB
│         │   │   │   │   ├─03.第三节-分布式配置中心架构原理(2).mp4     59.36MB
│         │   │   │   │   ├─03.第三节-分布式配置中心架构原理.mp4     59.36MB
│         │   │   │   │   ├─04.第四节-Nacos配置中心部署原理(2).mp4     17.01MB
│         │   │   │   │   ├─04.第四节-Nacos配置中心部署原理.mp4     17.01MB
│         │   │   │   │   ├─05.第五节-将配置文件发布Nacos配置中心(2).mp4     36.87MB
│         │   │   │   │   ├─05.第五节-将配置文件发布Nacos配置中心.mp4     36.87MB
│         │   │   │   │   ├─06.第六节-本地应用读取Nacos配置中心(2).mp4     208.3MB
│         │   │   │   │   ├─06.第六节-本地应用读取Nacos配置中心.mp4     208.3MB
│         │   │   │   │   ├─07.第七节-基于Nacos动态更新本地配置文件(2).mp4     41.62MB
│         │   │   │   │   ├─07.第七节-基于Nacos动态更新本地配置文件.mp4     41.62MB
│         │   │   │   │   ├─08.第八节-Nacos实现多环境不同配置(2).mp4     27.7MB
│         │   │   │   │   ├─08.第八节-Nacos实现多环境不同配置.mp4     27.7MB
│         │   │   │   │   ├─09.第九节-Nacos配置中心集群部署原理(2).mp4     36.97MB
│         │   │   │   │   ├─09.第九节-Nacos配置中心集群部署原理.mp4     36.97MB
│         │   │   │   │   ├─10.第十节-Nacos配置中心持久化到数据库(2).mp4     42.27MB
│         │   │   │   │   ├─10.第十节-Nacos配置中心持久化到数据库.mp4     42.27MB
│         │   │   │   │   ├─11.第十一节-基于Nginx实现Nacos集群部署(2).mp4     48.38MB
│         │   │   │   │   ├─11.第十一节-基于Nginx实现Nacos集群部署.mp4     48.38MB
│         │   │   │   │   ├─12.第十二节-本地服务注册到Nacos集群中(2).mp4     18.19MB
│         │   │   │   │   └─12.第十二节-本地服务注册到Nacos集群中.mp4     18.19MB
│         │   │   │   └─课程内容.txt     265B
│         │   │   ├─Gateway高可用集群与动态网关.pptx     3.86MB
│         │   │   ├─SpringCloudAlibaba第七次课.doc     844.5KB
│         │   │   ├─上课代码
│         │   │   │   └─mayikt-gateway.rar     26.23KB
│         │   │   ├─笔记第二天.doc     34KB
│         │   │   ├─视频
│         │   │   │   ├─01.第一节-网关部署实现集群设计思路.mp4     53.1MB
│         │   │   │   ├─02.第二节-基于Nginx部署GateWay集群环境.mp4     62.11MB
│         │   │   │   ├─03.第三节-部署动态GateWay的思路.mp4     32.26MB
│         │   │   │   ├─04.第四节-基于数据库形式构建动态网关.mp4     34.33MB
│         │   │   │   ├─05.第五节-代码实现创建动态网关实现.mp4     63.94MB
│         │   │   │   └─06.第六节-代码完全实现动态服务网关.mp4     90.5MB
│         │   │   └─课程内容.txt     280B
│         │   ├─10.第六期微服务架构-SpringCloudAlibaba-Gateway源码深度源码分析
│         │   │   ├─000
│         │   │   │   └─mayikt-meite-openfeign-parent.rar     36.96KB
│         │   │   ├─code
│         │   │   │   └─mayikt-gateway.rar     15.42KB
│         │   │   ├─Gateway高可用集群与动态网关.pptx     3.86MB
│         │   │   ├─SpringCloudAlibaba第六次课.doc     912.5KB
│         │   │   ├─视频
│         │   │   │   ├─01.第一节-GateWay深度源码解析课程介绍.mp4     80.55MB
│         │   │   │   ├─02.第二节-GateWay词汇表格介绍.mp4     106.83MB
│         │   │   │   ├─03.第三节-GateWay网关谓词用法.mp4     117.21MB
│         │   │   │   ├─04.第四节-GateWay入口配置类源码分析.mp4     98.2MB
│         │   │   │   ├─05.第五节-GateWay核心配置类源码分析.mp4     101.11MB
│         │   │   │   ├─06.第六节-GateWay路由模式底层源码分析.mp4     162.89MB
│         │   │   │   └─07.第七节-GateWay如何解决网关跨域的问题.mp4     107.66MB
│         │   │   └─课程内容.txt     318B
│         │   ├─11.第六期微服务架构-SpringCloudAlibaba-sentinel服务保护框架
│         │   │   ├─101.第六期微服务架构-SpringCloudAlibaba-sentinel数据持久化&服务降级&熔断
│         │   │   │   ├─mayikt-meite-openfeign-parent
│         │   │   │   │   └─mayikt-meite-openfeign-parent.rar     -1.#INDB
│         │   │   │   ├─sentinel数据持久化&服务降级&熔断(2).doc     1.46MB
│         │   │   │   ├─sentinel数据持久化&服务降级&熔断(2).pptx     3.84MB
│         │   │   │   ├─sentinel数据持久化&服务降级&熔断.pptx     3.84MB
│         │   │   │   ├─sentinel数据持久化&服务降级&熔断.doc     1.46MB
│         │   │   │   ├─上课编写的代码
│         │   │   │   │   └─mayikt-meite-openfeign-parent.rar     11.08KB
│         │   │   │   └─视频
│         │   │   │         ├─01.第一节-sentinel实现服务降级效果(2).mp4     38.43MB
│         │   │   │         ├─01.第一节-sentinel实现服务降级效果.mp4     38.43MB
│         │   │   │         ├─02.第二节-sentinel持久化的四种方案(2).mp4     52.11MB
│         │   │   │         ├─02.第二节-sentinel持久化的四种方案.mp4     52.11MB
│         │   │   │         ├─03.sentinel整合nacos实现数据的持久化(2).mp4     101.88MB
│         │   │   │         ├─03.sentinel整合nacos实现数据的持久化.mp4     101.88MB
│         │   │   │         ├─04.gateway整合sentinel实现服务限流(2).mp4     95.61MB
│         │   │   │         ├─04.gateway整合sentinel实现服务限流.mp4     95.61MB
│         │   │   │         ├─05.gateway整合sentinel限流返回自定义提示.mp4     29.15MB
│         │   │   │         ├─05.gateway整合sentinel限流返回自定义提示.mp4.baiduyun.p.downloading     -1.#INDB
│         │   │   │         ├─07.sentinel服务熔断降级的策略(2).mp4     48.67MB
│         │   │   │         ├─07.sentinel服务熔断降级的策略.mp4     48.67MB
│         │   │   │         ├─08.sentinel服务降级之rt平均响应时间(2).mp4     75.56MB
│         │   │   │         ├─08.sentinel服务降级之rt平均响应时间.mp4     75.56MB
│         │   │   │         ├─09.sentinel服务降级之错误比例(2).mp4     67.18MB
│         │   │   │         ├─09.sentinel服务降级之错误比例.mp4     67.18MB
│         │   │   │         ├─10-sentinel服务降级之错误次数(2).mp4     37.87MB
│         │   │   │         └─10-sentinel服务降级之错误次数.mp4     37.87MB
│         │   │   ├─Gateway高可用集群与动态网关.pptx     3.86MB
│         │   │   ├─SpringCloudAlibaba第七次课.doc     1.2MB
│         │   │   ├─代码
│         │   │   │   └─mayikt-meite-openfeign-parent.zip     61.36KB
│         │   │   ├─视频
│         │   │   │   ├─01.第一节-sentine实现动态服务限流演示.mp4     58.1MB
│         │   │   │   ├─02.第二节-服务保护、服务限流、服务降级的概念.mp4     45.57MB
│         │   │   │   ├─03.第三节-服务雪崩效应产生的背景.mp4     75.87MB
│         │   │   │   ├─04.第四节-服务隔离机制信号量与线程池隔离.mp4     49.03MB
│         │   │   │   ├─05.第五节-sentinel中文基本的介绍.mp4     48.41MB
│         │   │   │   ├─06.第六节-sentinel与hystrix的区别.mp4     25.77MB
│         │   │   │   ├─07.第七节-sentinel手动实现限流规则.mp4     95.44MB
│         │   │   │   ├─08.第八节-项目启动加载限流规则代码.mp4     38.33MB
│         │   │   │   ├─09.第九节-使用注解形式实现对服务接口限流.mp4     41.54MB
│         │   │   │   ├─10.第十节-sentinel控制台项目应用的启动.mp4     34.61MB
│         │   │   │   ├─11.第十一节-SpringBoot整合sentinel控制台.mp4     25.19MB
│         │   │   │   ├─12.第十二节-sentinel控制台动态实现接口限流.mp4     58.01MB
│         │   │   │   └─13.第十三节-sentinel控制台实现信号隔离.mp4     44.79MB
│         │   │   └─课程内容.txt     316B
│         │   ├─12.第六期微服务架构-SpringCloudAlibaba-sentinel热词限流配置
│         │   │   ├─code
│         │   │   │   └─code.rar     108.59KB
│         │   │   ├─sentinel数据持久化&服务降级&熔断.doc     1.61MB
│         │   │   └─视频
│         │   │         ├─01.第一节-秒杀接口如何实现热词的限流.mp4     32.86MB
│         │   │         ├─02.第二节-秒杀接口整合sentinel实现热词限流.mp4     128.52MB
│         │   │         ├─03.第三节-sentinel控制台环境搭建.mp4     37.53MB
│         │   │         ├─04.第四节-sentinel控制台控制客户端热词配置.mp4     129.41MB
│         │   │         └─05.第五节-sentinel控制台热词参数vip通道.mp4     14.82MB
│         │   ├─13.第六期微服务架构-SpringCloudAlibaba-分布式事务基础设施理论
│         │   │   ├─分布式事务基础设施理论.doc     1.6MB
│         │   │   └─视频
│         │   │         ├─01.第一节-分布式基础设施理论基本的概述.mp4     22.99MB
│         │   │         ├─02.第二节-传统项目分布式事务产生的背景.mp4     114.16MB
│         │   │         ├─03.第三节.RPC通讯的分布式事务产生的背景.mp4     104.57MB
│         │   │         ├─04.第四节-CAP与Base的基本设施理论.mp4     70.34MB
│         │   │         ├─05.第五节-分布式事务最终一致性的概念.mp4     99.43MB
│         │   │         └─06.第六节-分布式事务流行的解决框架.mp4     52.33MB
│         │   ├─14.第六期微服务架构-SpringCloudAlibaba-基于LCN解决分布式事务与源码分析
│         │   │   ├─01.第一节-LCN解决分布式事务问题演示.mp4     36.45MB
│         │   │   ├─02.第二节-演示RPC远程通讯产生分布式事务问题.mp4     61.95MB
│         │   │   ├─03.第三节-如何理解2PC两阶段提交协议.mp4     110.33MB
│         │   │   ├─04.第四节-LCN基本的框架的概述.mp4     61.13MB
│         │   │   ├─05.第五节-LCN模式解决分布式事务实现的原理.mp4     105.55MB
│         │   │   ├─06.第六节-LCN客户端如何整合LCN全局协调者.mp4     40.38MB
│         │   │   ├─07.第七节-LCN解决分布式事务源码分析.mp4     28.98MB
│         │   │   ├─08.第八节-TransactionAspect切面类源码分析01.mp4     100.29MB
│         │   │   ├─09.第九节-TransactionAspect切面类源码分析02.mp4     79.1MB
│         │   │   ├─10.第十节-RequestInterceptor拦截器源码分析.mp4     81.95MB
│         │   │   ├─11.第十一节-LCN如何判断是发起方还是参与方.mp4     92.88MB
│         │   │   ├─12.第十二节-参与方如何加入LCN全局协调者.mp4     132.29MB
│         │   │   ├─13.第十三节-发起方如何通知全局回滚还是提交.mp4     52.67MB
│         │   │   └─14.第十四节-A调用B,B调用C如何实现全局回滚.mp4     17.2MB
│         │   └─15.第六期微服务架构-SpringCloudAlibaba-Seata框架底层深度源码解析
│         │         ├─code
│         │         │   ├─mayikt-meite-openfeign-parent.zip     115.53KB
│         │         │   └─数据库表结构
│         │         │         └─数据库表结构.rar     4.78KB
│         │         ├─Seata解决分布式事务的问题.doc     1.82MB
│         │         ├─Seata解决分布式事务的问题.pptx     3.86MB
│         │         ├─安装包
│         │         │   └─seata-server-0.9.0.zip     32.45MB
│         │         ├─新建文本文档.txt     124B
│         │         ├─视频
│         │         │   ├─01.第一节-回顾seata解决分布式事务的问题.mp4     22.48MB
│         │         │   ├─02.第二节-seata基于undolog表逆向生成sql语句回滚.mp4     113.63MB
│         │         │   ├─02.第二节-seata基于undo_log表逆向生成sql语句回滚.mp4     113.04MB
│         │         │   ├─03.第三节-setata使用前置镜像和后置镜像保存日志信息.mp4     72.07MB
│         │         │   ├─04.第四节-seata根据undolog日志逆向回滚原理01.mp4     134.96MB
│         │         │   ├─04.第四节-seata根据undo_log日志逆向回滚原理01.mp4     134.37MB
│         │         │   ├─05.第五节-seata根据undolog日志逆向回滚原理02.mp4     54.71MB
│         │         │   ├─05.第五节-seata根据undo_log日志逆向回滚原理02.mp4     54.12MB
│         │         │   ├─06.第六节-seata与lcn回滚之间的存在那些区别.mp4     23.2MB
│         │         │   ├─07.第七节-seata全局事务注解入口源码类分析.mp4     80.42MB
│         │         │   ├─08.第八节-GlobalTransactionalInterceptor源码分析.mp4     58.32MB
│         │         │   ├─09.第九节-TM如何远程连接TC获取全局事务id.mp4     59.8MB
│         │         │   ├─10.第十节-Seata前置和后置镜像源码深度分析.mp4     110.51MB
│         │         │   └─11.第十一节-Seata发起方调用完接口后发生回滚还是提交.mp4     74.72MB
│         │         └─课程内容.txt     286B
│         ├─13.第五期和第六期-docker&dockercompose
│         │   ├─01-第八期-容器化技术-docker架构设计原理
│         │   │   ├─01.mp4     71.85MB
│         │   │   ├─02.mp4     57.11MB
│         │   │   ├─docker – 副本 (2).doc     2.45MB
│         │   │   ├─docker – 副本.doc     2.18MB
│         │   │   ├─Dockerfile     131B
│         │   │   ├─docker.doc     2.79MB
│         │   │   ├─docker运行原理图.jpg     675.71KB
│         │   │   ├─index.html     16B
│         │   │   ├─mayikt
│         │   │   │   ├─Dockerfile     581B
│         │   │   │   └─mayikt-thymeleaf-1.0-SNAPSHOT.jar     20.67MB
│         │   │   ├─mayikt-app.jar     14.71KB
│         │   │   ├─mayikt-thymeleaf-1.0-SNAPSHOT.jar     20.67MB
│         │   │   ├─meite02
│         │   │   │   ├─Dockerfile     509B
│         │   │   │   └─mayikt-thymeleaf-1.0-SNAPSHOT.jar     20.67MB
│         │   │   ├─nginx.conf     2.73KB
│         │   │   ├─test02.txt     436B
│         │   │   ├─新建文本文档.txt     384B
│         │   │   └─视频
│         │   │         ├─视频1
│         │   │         │   ├─01.第一节-为什么需要使用docker.mp4     123.75MB
│         │   │         │   ├─02.第二节-docker的架构设计原理.mp4     53.99MB
│         │   │         │   ├─03.第三节-容器与虚拟机之间的区别.mp4     32.07MB
│         │   │         │   ├─04.第四节-CentOS7安装docker说明.mp4     20.19MB
│         │   │         │   ├─05.第五节-Docker配置阿里云加速镜像.mp4     29.72MB
│         │   │         │   ├─06.第六节-docker-images使用原理.mp4     89.32MB
│         │   │         │   ├─07.第七节-.docker-run运行原理.mp4     114.76MB
│         │   │         │   ├─08.35.mp4     926.96MB
│         │   │         │   ├─08.第八节-.docker-run常见错误.mp4     61.11MB
│         │   │         │   ├─09.第九节.docker-run启动方式.mp4     55.93MB
│         │   │         │   ├─10.第十节-.docker-commit的作用.mp4     81.45MB
│         │   │         │   ├─11.第十一节-docker-数据卷的作用.mp4     58.19MB
│         │   │         │   ├─12.第十二节-docker运行底层实现原理.mp4     31.3MB
│         │   │         │   └─13.第十三节-docker镜像加载的原理.mp4     174.94MB
│         │   │         ├─视频2     -1.#INDB
│         │   │         └─视频3
│         │   │               ├─bandicam 2021-02-25 21-06-46-610.mp4     37.56MB
│         │   │               ├─bandicam 2021-02-25 21-11-13-885.mp4     85.8MB
│         │   │               ├─bandicam 2021-02-25 21-22-48-908.mp4     828.12KB
│         │   │               ├─bandicam 2021-02-25 21-23-00-730.mp4     5.01MB
│         │   │               ├─bandicam 2021-02-25 21-24-24-852.mp4     43.53MB
│         │   │               ├─bandicam 2021-02-25 21-32-50-832.mp4     84.64MB
│         │   │               └─bandicam 2021-02-25 21-46-14-114.mp4     119.77MB
│         │   ├─02-第八期-容器化技术-docker部署springboot项目
│         │   │   ├─docker.doc     2.94MB
│         │   │   ├─mayikt02
│         │   │   │   └─mayikt02.rar     19.72MB
│         │   │   ├─mayikt03
│         │   │   │   └─docker-compose.rar     621B
│         │   │   ├─mayikt04
│         │   │   │   └─mayikt04.rar     22.57MB
│         │   │   ├─mysql
│         │   │   │   └─mysql.rar     1.41KB
│         │   │   ├─视频
│         │   │   │   ├─01.第一节-dockerfile的作用.mp4     37.56MB
│         │   │   │   ├─02.第二节-dockerfile语法讲解.mp4     85.16MB
│         │   │   │   ├─03.第三节-定制一个自己的centos镜像文件01.mp4     43.53MB
│         │   │   │   ├─04.第四节-定制一个自己的centos镜像文件02.mp4     84.64MB
│         │   │   │   ├─05.第五节-dockerfile部署springboot项目.mp4     119.77MB
│         │   │   │   └─08.36.mp4     370.79MB
│         │   │   └─资料
│         │   │         ├─11172089.zip     15.22MB
│         │   │         └─资料.rar     52.44MB
│         │   └─03-第八期-容器化技术-docker-compose部署微服务项目
│         │         ├─docker.doc     2.94MB
│         │         ├─视频
│         │         │   ├─01.第一节-为什么需要使用docker-compose.mp4     106.22MB
│         │         │   ├─02.第二节-docker-compose插件-.mp4     33.78MB
│         │         │   ├─03.第三节-创建第一个docker-compose模板.mp4     99.09MB
│         │         │   ├─04.第四节-docker-compose启动多个容器.mp4     27.68MB
│         │         │   ├─05.第五节-docker-compose构建同一个局域网.mp4     86.06MB
│         │         │   ├─06.第六节-docker-compose部署微服务项目原理.mp4     55.68MB
│         │         │   ├─07.第七节-docker-compose实战部署微服务项目.mp4     149.07MB
│         │         │   ├─08.37.mp4     671.02MB
│         │         │   ├─08.第八节-docker部署项目疑问总结.mp4     49.63MB
│         │         │   ├─09.第九节-docker可视化工具用法.mp4     47.99MB
│         │         │   └─10.第十节-docker实际部署微服务流程.mp4     15.62MB
│         │         └─资料
│         │               └─资料.rar     37.5MB
│         ├─14.第五期和第六期-Rabbitmq入门到精通
│         │   ├─code和文档
│         │   │   └─code和文档.rar     97.21MB
│         │   └─视频
│         │         ├─01.第一节-rabbitmq课程说明.mp4     34.26MB
│         │         ├─02.第二节-消息中间件产生的背景.mp4     52.4MB
│         │         ├─03.第三节-消息中间件应用场景.mp4     60.18MB
│         │         ├─04.第四节-使用多线程实现异步缺点.mp4     50.37MB
│         │         ├─05.第五节-消息中间件架构思想与名词.mp4     40.88MB
│         │         ├─06.第六节-基于多线程方式手写MQ.mp4     50.51MB
│         │         ├─07.第七节-使用mq架构常见一些问题.mp4     49.52MB
│         │         ├─08.第八节-mq是如何实现抗高并发.mp4     39.88MB
│         │         ├─09.第九节-基于netty手写mq效果演示.mp4     25.87MB
│         │         ├─10.第十节-基于netty手写mq代码01.mp4     48.03MB
│         │         ├─11.第十一节-基于netty手写mq代码02.mp4     62.24MB
│         │         ├─12.第十二节-基于netty手写mq代码03.mp4     52.86MB
│         │         ├─13.第十三节-手写mq一些总结.mp4     17MB
│         │         ├─14.第十四节-异步发送短信优缺点.mp4     61.49MB
│         │         ├─15.第十五节-主流的mq对比.mp4     20.02MB
│         │         ├─16.第十六节-rabbitmq概念介绍.mp4     35.07MB
│         │         ├─17.第十七节-win版本安装rabbitmq.mp4     30.02MB
│         │         ├─18.第十八节-VirtualHosts概念.mp4     15.07MB
│         │         ├─19.第十九节-RabbitMQ控制台介绍.mp4     28.25MB
│         │         ├─20.第二十节-Rabbitmq入门案例之生产者.mp4     78.07MB
│         │         ├─21.第二十一节-Rabbitmq入门案例之消费者.mp4     36.5MB
│         │         ├─22.第二十二节-mq如何保证消息丢失.mp4     124.48MB
│         │         ├─23.第二十三节-消费者均摊消费消息缺点.mp4     28.09MB
│         │         ├─24.第二十四节-rabbitmq工作队列模型.mp4     59.98MB
│         │         ├─25.第二十五节-rabbitmq工作队列疑问01.mp4     28.64MB
│         │         ├─26.第二十六节-rabbitmq核心架构设计思想.mp4     30.52MB
│         │         ├─27.第二十七节-rabbitmq之fanout交换机01.mp4     50.68MB
│         │         ├─28.第二十八节-rabbitmq之fanout交换机02.mp4     60.49MB
│         │         ├─29.第二十九节-rabbitmq之direct路由模式.mp4     40.43MB
│         │         ├─30.第三十节-rabbitmq之topic主题模式.mp4     33.92MB
│         │         ├─31.第三十一节-整合springboot效果演示.mp4     23.74MB
│         │         ├─32.第三十二节-整合springboot生产者.mp4     90.23MB
│         │         ├─33.第三十三节-整合springboot消费者.mp4     79.19MB
│         │         ├─34.第三十四节-演示基于rabbitmq异步短信.mp4     16.38MB
│         │         ├─35.第三十五节-mq如何获取消费者结果.mp4     50.27MB
│         │         ├─36.第三十六节-根据全局id主动获取消费者结果.mp4     35.85MB
│         │         ├─37.第三十七节-rabbitmq死信队列架构设计原理.mp4     37.75MB
│         │         ├─38.第三十八节-rabbitmq演示死信队列.mp4     75.25MB
│         │         ├─39.第三十九节-死信队列订单30分钟超时设计.mp4     17.85MB
│         │         ├─40.第四十节-消费者消费失败,mq重试策略.mp4     108.22MB
│         │         ├─41.第四十一节-什么情况下,消费者需要开启重试策略.mp4     47.09MB
│         │         ├─42.第四十二节-如何触发mq主动重试策略.mp4     8.79MB
│         │         ├─43.第四十三节-mq如何解决消息幂等性问题.mp4     56.2MB
│         │         ├─44.第四十四节-rabbitmq消费者手动ack模式.mp4     53.33MB
│         │         └─code和文档
│         │               └─code和文档.rar     1.22MB
│         ├─15.第五期和第六期-分布式综合解决方案
│         │   ├─01.分布式解决方案之分布式服务追踪SkyWalking
│         │   │   ├─code
│         │   │   │   └─mayikt-meite-openfeign-parent.rar     54.47KB
│         │   │   ├─zipkin-server-2.11.8-exec.jar     36.69MB
│         │   │   ├─分布式解决方案服务追踪与调用链系统.doc     883.5KB
│         │   │   ├─视频
│         │   │   │   ├─01.第一节-分布式服务追踪系统架构原理.mp4     97.87MB
│         │   │   │   ├─02.第二节-分布式服务追踪与elk之间的区别.mp4     124.25MB
│         │   │   │   ├─03.第三节-服务追踪全局id与spanid的作用.mp4     114.17MB
│         │   │   │   ├─04.第四节-Sleuth+zipkin环境搭建.mp4     38.98MB
│         │   │   │   ├─05.第五节-Traceid与Spanid原理分析.mp4     86.14MB
│         │   │   │   ├─06.第六节-构建分布式服务追踪系统注意事项.mp4     54MB
│         │   │   │   ├─07.第七节-SkyWalking框架原理基本介绍.mp4     80.32MB
│         │   │   │   ├─08.第八节-SkyWalking四个架构组件.mp4     25.01MB
│         │   │   │   ├─09.第九节-SkyWalking环境的安装.mp4     33.55MB
│         │   │   │   ├─10.第十节-SpringBoot整合SkyWalking.mp4     117.21MB
│         │   │   │   ├─11.第十一节-feign客户端整合SkyWalking.mp4     274.02MB
│         │   │   │   ├─12.第十二节-SkyWalking重启后bug问题.mp4     38.65MB
│         │   │   │   ├─13.第十三节-SkyWalking获取全局追踪id.mp4     16.08MB
│         │   │   │   ├─14.第十四节-SkyWalking实现告警原理.mp4     68.24MB
│         │   │   │   ├─15.第十五节-SkyWalking实现告警演示.mp4     203.6MB
│         │   │   │   ├─16.第十六节-SkyWalking数据持久化.mp4     20.29MB
│         │   │   │   └─17.第七节-SkyWalking过滤端点.mp4     7.91MB
│         │   │   └─资料
│         │   │         ├─13719795.7z     134MB
│         │   │         └─OpenSkywalking-sky-walking-master.zip     9.26MB
│         │   ├─02.分布式解决方案之分布式日志采集elk+kafka     -1.#INDB
│         │   └─03.分布式解决方案之分布式数据同步canal     -1.#INDB
│         ├─16.第五期和第六期-jvm如何排查生产环境cpu飙高的问题
│         │   ├─01.第一节-如何排查cpu飙高的问题课程演示 .mp4     118.86MB
│         │   ├─02.第二节-cpu飙高的问题产生原因.mp4     153.09MB
│         │   ├─03.第三节-windows环境下如何排查cpu飙高问题.mp4     115.15MB
│         │   ├─04.第四节-linux环境下如何排查cpu飙高的问题.mp4     72.85MB
│         │   └─05.第五节-真实环境下如何排查cpu飙高的问题.mp4     29.84MB
│         ├─17.第五期和第六期-mysql索引优化原理     -1.#INDB
│         ├─18.第五期和第六期-devops&jekins部署springboot容器项目     -1.#INDB
│         ├─19.第五期和第六期-spring-security+jwt+oauth2入门到精通
│         │   ├─01.spring-security整合rbac权限模型
│         │   │   ├─spring-security相关课程代码
│         │   │   │   └─spring-security相关课程代码.rar     263.11KB
│         │   │   └─视频
│         │   │         ├─01.第一节-spring-security课程内容安排.mp4     57.45MB
│         │   │         ├─02.第二节-spring-security-basic认证.mp4     105.52MB
│         │   │         ├─03.第三节-spring-security整合form表单.mp4     21.32MB
│         │   │         ├─04.第四节-spring-security配置权限规则.mp4     148.76MB
│         │   │         ├─05.第五节-修改spring-security权限不足页面.mp4     55.79MB
│         │   │         ├─06.第六节-自定义from表单登录页面.mp4     51.9MB
│         │   │         ├─07.第七节-什么是RBAC权限模型架构设计.mp4     95.69MB
│         │   │         ├─08.第八节-spring-security整合rbac权限模型01.mp4     167.13MB
│         │   │         └─09.第九节-spring-security整合rbac权限模型02.mp4     47.2MB
│         │   ├─02.springsecurity整合oauth2
│         │   │   ├─01.第一节-开放api接口如何实现管理.mp4     59.67MB
│         │   │   ├─02.第二节-什么是oauth2.mp4     130.26MB
│         │   │   ├─03.第三节-微信联合登录oauth2原理.mp4     158.33MB
│         │   │   ├─04.第四节-springsecurity整合oauth2授权码模式.mp4     113.42MB
│         │   │   ├─05.第五节-根据授权码获取accessToken.mp4     44.53MB
│         │   │   ├─06.第六节-资源端接口整合accessToken.mp4     101.19MB
│         │   │   └─代码
│         │   │         └─代码.rar     532.33KB
│         │   └─03.springsecurity整合jwt
│         │         └─jwt
│         │               ├─01.第一节-jwt相关课程内容说明.mp4     8.61MB
│         │               ├─02.第二节-传统token存在哪些优缺点.mp4     68.49MB
│         │               ├─03.第三节-jwt的组成部分有哪些.mp4     127.59MB
│         │               ├─04.第四节-jwt的优缺点.mp4     24.58MB
│         │               ├─05.第五节-完全纯手写一个jwt之加密.mp4     93.52MB
│         │               ├─06.第六节-完全纯手写一个jwt之解密.mp4     48.26MB
│         │               ├─07.第七节-真实微服务项目如何使用jwt.mp4     77.26MB
│         │               ├─08.第八节-jwt如何实现退出.mp4     12.8MB
│         │               ├─jwt相关资料.txt     54B
│         │               └─Thumbs.db     12.5KB
│         └─第五期和第六期-相关说明.txt     307B

本站所有资源均来自网络,版权归原作者所有,本站仅提供收集与推荐,若侵犯到您的权益,请【给我们反馈】,我们将在24小时内处理!

下载权限

查看
  • 免费下载
    评论并刷新后下载
    登录后下载

查看演示

  • {{attr.name}}:
您当前的等级为
登录后免费下载登录 小黑屋反思中,不准下载! 评论后刷新页面下载评论 支付以后下载 请先登录 您今天的下载次数(次)用完了,请明天再来 支付积分以后下载立即支付 支付以后下载立即支付 您当前的用户组不允许下载升级会员
您已获得下载权限 您可以每天下载资源次,今日剩余

给TA打赏
共{{data.count}}人
人已打赏
6 条回复 A文章作者 M管理员
  1. onelun

    人啊,是利益的作品。

  2. onelun

    舞鸳鸯之形影兮,歌凤凰之涅槃。

  3. onelun

    好好学习,天天向上。

  4. onelun

    你现在的气质里,藏着你走过的路,读过的书和爱过的人。

  5. zj

    行到水穷处,坐看云起时。

  6. 111333

    侯非侯,王非王,千乘万骑走北芒。

个人中心
购物车
优惠劵
今日签到
有新私信 私信列表
搜索