马士兵-MCA-架构师课程笔记-五-

马士兵 MCA 架构师课程笔记（五）

系列 5：P53：53、三级缓存解决循环依赖问题 - 马士兵学堂 - BV1E34y1w773

提问环节，提问环节第一个问题听好了，现在到总结过程了，这个总结也非常非常重要，听好了，三级，我三个缓存对象在获取数据的时候，是按照什么顺序来获取的，第一个问题，123吧，先获取一级缓存。

没有再获取二级缓存，没有再获取三级缓存，所以当好吧，前面，到缓存中存在了怎么办，我天呐，好诡异，我我我已经停了，他还在那个啥存在了对象，那么后面就需要把，什么缓存，对象，给清空，没问题吧，你想吧。

你一级缓存没有了，那么我二级三级就没有必没有存在的必要了，来这个问题听白同学给老师扣一，能听懂吗，我们一个来好吧，一个来第一个问题，来第二个问题，为什么，说如果只有一级缓存能解决循环依赖问题吗，能不能。

不能为什么不能，你告诉我为什么单例是因为单位吗，要是能spring就不写三级了，你别扯犊子好吧，如果只有一级缓存，那么成品对象和半成品对象会放到，一起这个时候没办法区分了。

所以需要两个缓存来分别存放不同状态的对象，一级缓存放什么东西成品，二级缓存放半成品，弄个不同的key，key是我们的冰name，你能弄不同的key吗，大叔K是我们的b name，你能放不同的K吗。

不能吧，所以最方便的，有人说老师我可以立即缓存，我在value里面，我给大家一个类型，value里面做一个标识不就行了吗，大叔子加一个123，你你你加多少个123啊，你加多少123。

还有人说老师我在value里面封装一个类型，我给他一个标志位，如果是一表示成品，如果零表示半成品，你还要挨个取对象，判断取对象判断你麻烦不麻烦呀，你用两个缓存就可以解决这件事情。

为什么要判断每个属性值呢，累不累啊，是这意思，可以用隐藏方式，但是你不能写那么low代码，懂我意思吧啊这东西来第三个问题，如果诶前两个问题弄懂，同学扣一，懂了第三个问题，如果只有第二级两个缓存能解决。

能否解决循环依赖问题，只有一级和二级可以解决吗，好了有说可以的，有说不能的，那这时候我问一个问题啊，在刚刚的整个流程中啊，三级缓存一共出现了几次，其次，两次吧。

第一个是在get singleton方法中出了一次，第二个是在哪，do create be方法的时候出现了一次对吧，现在我做一件事，同学们做一件事。

能和不能，我们来分情况，说明我既然知道只有这两个地方用到了好了。

我干一件事，找一下我们刚才说法叫什么叫do create b。

找对方法，然后我把我现在的这行代码给干掉，这行代码是完成了三级缓存的，一个一个一个一个存放对吧，我把下面两行给解开，下面两个解开，这是什么意思啊，告诉我，看啊我把这行代码干掉了，我把下面代码给解开。

这是几级缓存，二级吧，也就是说我现在我存放完成之后，我不往三级里面放了，我只往二级里面放对吧。

这是第一个地方，第二个地方叫get singleton。

这里面吧我把整段方法我都干掉，然后我把这段数理逻辑解开，我自己写的好吧，这段里面有三级缓存存在的意义吗，往下看啊，第一个我先从一级缓存里面取，如果取不到的话，我从二级缓存里面取，如果也取不到的话。

我就返回空，现在还有三级缓存吗。

没了吧好了，如果没了的话，我们先来干一件事，我再按照这个逻辑我去执行一遍，我们的方法处理，看一下它能否正常，呃有一个lock，我把你把它关掉啊，我把第八关掉，来把上面的lock给干掉，那文件表示锁定啊。

不让你删，走，我把它删掉，把它停了，删除好吧，来重新执行，右击run，这跟后置税方有啥关系啊，跟后置处理方案有关系吗，没关系好吧，等我等我讲完好吧，先往下看，好了，我的AB有没有打印出来，同学们看好了。

我的ab有没有打印出来，有没有AB有了吗，我二级缓存能不能解决循环依赖问题，能还是不能，能不能可以，但是如果他真的可以的话，为什么要加三级缓存呢，我来改一段逻辑，我把我们的配置文件打开，打开之后。

我把下面这段代码给解开，下面是干嘛的，现在干嘛呢，是不是加了一个a OP啊，那时候现在我需要把AB都创建代理对象了，然后这个时候我再来运行是吧，先看效果啊。

好了，非常抱歉，他报错了，报错呢，就这行代码，我把这个代码粘出来，我先站出来，站出来好吧，加上之后，我们这其实可以做到一个结论，什么结论，如果对象的创建过程中不包含a OP。

那么二级缓存就可以解决循环依赖问题啊，但是包含a OP的操作，循环依赖问题是解决不了的，没问题吧，这个结论理解的同学扣一理解吗，这么看这个结论好吧，然后这个时候我们再来看一下它报的错误，错误很多好吧。

我们把它给你们截一下分割来看一下，其实这里面分了很多错误，但只有一行错误是最主要的，来看中间这句话，他说了看上面啊，他说错误了，创建bean name a的时候说并非name a。

Has been inject into other beings，说我们的A对象已经注入到其他病死了好吧，然后in its role version as part of socreference。

在循环语句中，but好吧，Has event being viper，它已经被包装了好吧，这是什么意思呢，说this means that set other beings。

Do not use the final version of the be，这几个字非常非常重要，这说明其他病并没有使用最终版本的bean对象，那这个时候问题来了，什么叫最终版本的bean对象。

所以如果你能把这东西理解清楚，那基本上循环应用循环依赖你就搞明白了啊，所以我们现在来捋这套逻辑。

系列 5：P54：54、为什么添加aop操作后需添加三级缓存来解决问题 - 马士兵学堂 - BV1E34y1w773

第四个问题，为什么动态为什么添加了AOP的操作之后，就需要添加三级缓存来解决这个，这个问题好吧，那还是一样，我告诉你怎么做，我们先试一下吧，我们再把代码改回来啊，第一个把这代码注释起来，我把上面解开。

我们先看一下，当存在AOP的时候，它能不能解决这个问题好吧，它解开，第二个，我把这两个代码注释起来，我把它剪开，然后我们再重新测试一下，右击run看还会报错了好吧，截胡了给谁，截胡了，好了有问题吗。

没问题吧，没搞错吧，就当我有了三级缓存之后，我AOP中存在循环问题也可以解决了，这个时候很多同学能想明白到底是为什么，其实你在想为什么时候你就讲一件事，三级缓存它到底加了一个什么操作，三级缓存。

加了什么操作好，同学们加什么操作，创建代理对象不是，是不是只有一个添加了一个，Get beget early，并reference，的方法还记得吗，是不是只添加一个get定格的reference的方法。

对不对，然后想搞明白这件事情，我想问一个问题，同学们在创建对象的，在创建代理对象的时候，是否需要生成原始对象，需要还是不需要，需要吧，就因为bean的完整生命周期是这样的，我先创建出来原始对象之后。

我再创建我们具体的一个代理对象，这个过程肯定是要的，对不对，那问题来了，当创建完成原始对象之后啊，后续又需要创建代理对象，代理对象，那么对象在引用的时候应该使用哪一个，代理对象凭什么呀。

换句话说就是一个been name对应有两个对象啊，哪有对象分别是原始对象和代理对象，那这个时候我在应用的时候，我怎么知道用哪个呀，凭什么你说代理的代理，凭什么，你说原始有原始，凭什么程序是死的。

它是不会像人一样，我去做一个智能的判断，说喂我刚才用代理了诶，我刚才用延迟了，他没那么灵活，内向这件事怎么办怎么办，啊怎么办，缓存不是不是缓存在整个容器中，有且仅能有一个同名的对象啊。

当需要生成代理对象的时候，就要把代理对象覆盖原始对象，这句话能不能理解，覆盖吧，我是不是可以覆盖，我覆盖之后，我是不是就知道，是不是就可以只为对外暴露一个了，这能理解吗，啊来这句话能理解的扣个一。

不理解的扣二，可以这么理解吧，你想吧，我现在有了一个代理对象，有一个原始对象，我原始力量是先创建的，再对象是后创建的，我在创建过程中，我是不是可以把我们的代理对象去覆盖掉，原始对象。

因为我覆盖之后就意味着我要对外暴露的时候，有且仅有一个对象，而不是两个对象都能对外暴露，能理解吗，就我不管我是否需要代理对象，我对象暴露的时候，我只能有一个，我只能有一个。

但这个时候就又会又有另外的一个问题，什么问题，程序是怎么知道，在什么时候要进行代理对象的创建等等，所以怎么知道，我在进行这项复制的时候，我怎么知道我什么时候应该有这个东西呢。

所以这时候应该需要什么东西了，是不是需要一个类似于回调的接口判断，当需要第一次使用，第一次对外暴露使用的时候，来判断当前对象是否需要去创建代理对象，这样能理解吗，想想总结一下，想想。

当我第一次需要对外暴露使用的时候，我是不是可以判断对象是不是需要进行代理的，这个时候你再回想一下一件事，回想一下那个get early been reference，里面的那个if判断，把衣服判断。

还有东西吗，你想一下，你第三次在调用get bean的时候，我是不是直接从三级缓存里面，我去我取出了我们的A对象，是从三句话里面取的，我是不是直接调用的是拉姆达表达式，里面的A对象。

能理解吗啊同学们显示这个显示这个过程，如果这样不理解，来我们看一下这个判断逻辑，来找一下，完了电脑卡了，嗨嗨嗨，你还在吗，给我回个话好不好，没人说话了，来我们打开我们的代码，我们瞅一眼这个逻辑好吧。

找到那个方法是不是在这里面，我们看一下这个get early being reference，点开点开之后我说了，中间这有一个if判断，在if判断里面。

这个方法是可能去改变exposed object的，那我们来看一下这边干什么事好不好，点开这个方法，找到它的实现子类只有一个吧，叫abo abstract，Auto promise secreator。

你点进去，你再点开这个Viper，If necessary，你再点开下面的create property，你再点开里面的get propose，你再点开get propose，你再看实现类。

你告诉我这里面干了什么事什么事，不就是创建代理对象吗，所以在刚刚这个方法里面，这个get early b reference这个方法里面，他干了什么事，就是用来判断，判断判怎么写判断啊。

这个病在对外暴露，被其他对象引用的时候，我到底暴露的是原始对象，还是暴露的是代理对象，但不管你是代理还是原始，我只能对外暴露一个。

明白了吗，是不是这个逻辑又判断，如果需要代理就返回代理对象，如果没有代理就返回原始对象吗，是不是这逻辑来这块儿能听吗，同学扣个一，所以这就是为什么我需要三级缓存的意义，在这儿。

三级缓存里面他为什么不放一个object对象，他放一放一个object factory对象，就是为了里面放一个拉姆表达式，当我需要第一次对外暴露的时候，我要判断一下我暴露的对象。

到底是原始对象还是代理对象，而我对外报道的时候，我又没法判断，所以我先放到三级缓存里面，每次在取的时候，我要遵循一个123的顺序，所以不管怎么找，我都会先找到三级缓存，三极管在对外使用的时候。

就会判断到底是原始还是在于，这就是三级缓存的核心，明白意思吗，好吧，这块儿我觉得你们下去之后，肯定是还要再悟一下，我肯定还是需要再琢磨一下的，你想明白我写的这一段话好吧，李鸿章说。

为什么生成带对象要先生成原始对象呢，这个问题我不解释了好吧，我不解释了好吧，这个这个太太太简单了好吧，来刚刚这段有点感觉，听的有点感觉，同学给老师扣个一，老师是三级缓存，是处理AOP的。

刚才您将从三级缓存汇率对象这块蒙圈了，注意一件事，同学们，spring是一个框架，跟业务无关，没办法预先感知，是否需要，代理对象，所以整体的执行流程，会把所有可能的情况都考虑进去。

因此在存储的时候先要往三级缓存扔一份，明白意思吧，这就是为什么要把三角法则扔一份原因，因为你用了拉表达式之后，它传递的是一个函数，你的方法并不会实际的执行，明白吗，当你具体调的时候，你才可以执行。

懂我意思吧，啊所以这才是这才是核心，OK直接把带这项发这款还行不行不行不行，没有没有没有没有这个逻辑好吧，注意啊，你要想把带邮箱放到二级缓存里面，你要判断一件事干什么事。

你下去之后可以带着我们a OP的代码，你重新把我刚刚那个流逻辑和那个流程，再整体过一遍，过完之后你知道他到底行不行了好吧，所以啊刚刚我写的这些东西，你要好好去琢磨一下，不是说我把这套逻辑理清楚了。

这东西就可以结束了，不是这样的，你要把它想明白，到底是因为啥，他这样设计的好处到底是怎么样的，三级缓存放的是函数，怎么判断是不是代理，我说了三级缓存放的函数，你是不是代理，跟我没关系。

但是我在获取对象的时候，我是要进行判断的，刚刚那个if方法里面不就是判断吗，这逻辑这衣服里面会判断你是否需要进行代理，如果需要，我会执行里面的东西，如果不需要我就不执行了吗，明白意思吧，啊。

所以把这个呃过程你要去想明白它，它到底是怎么完成的，或者到底是怎么进行相关的一个操作的，好吧。

这是刚刚这个整体的一个流程好了，这东西我就聊这么多吧，为什么DI注入的是原始对象，不是代理对象，你可以去看一下，你可以看一下DI的逻辑吗，前面车神，你关注一下你，你把刚刚那个属性注入的逻辑。

你好好看一下，你看一下带对象能否被注入进去，你试一下就知道了，好吧行了，别的东西啊，别的东西我们就不再聊了，所以我这节课我重点讲的，就是一个循环依赖问题，这种循环依赖问题很难吗。

那我问一下难吗，刚刚为什么报错，刚刚我改代码了，我把三级缓存给删掉，该改成二级缓存了吗，只有二级缓存吗，我删了吗，对不对，下方说这句话非常对啊，来看看下面说这句话，他说没有循环依赖的时候。

创建的对象步骤应该放在填充属性之后，初始化阶段创建代理对象，也就是说注意了，如果你有循环依赖，那么我会在get early，并reference里面进行代理对象创建，如果你没有循环依赖。

那么这个时候我会在我们的bean，post processor里面的方法里面进行创建，它是两个环节，它互不干扰，明白意思吗，好吧，spring它只是提供了一种机制，说我可以在一定程度上。

解决你们的循环依赖问题，但是你的循环依赖问题，我一定百分之百能解决掉吗，1388457同学，能面对逻辑吗，我只是说我有这样一种预防机制，它能预防一部分的错误，但不能预防全部的错误，懂了吗。

所以你在写程序的时候，有些情况下你还是会出现循环依赖的问题了，这时候你就要找一下，你循环依赖是因为什么产生的，明白吗，需要什么产生的，然后你怎么去解决当前这样的一个问题。

那最简单的spring boot，你在引用我们对应的那个叫什么那个data source，数据源的时候，是不是也会出现这样的问题，对不对，这个很正常好吧，他只能说我在一定程度上期，我不能说全部都解决掉。

所以这个这个解决不了了，所以他问的也是你这样的一个设计思想，他到底是干啥使的好吧，为什么网上看到三级缓存和二级缓存，可以互换呢，从哪看的，把帖子发给我，我没见过怎么互换，换不了，好吧行了，这东西啊。

咱们大概就聊这么多吧，我呢花了一个半一个小时，40分钟的时间给大家讲解了一下，循环依赖相关的问题，我觉得我讲的够明白了。

如果谁不清楚下去之后，你还是要把刚刚那个流程再整体去过一下，同学们记住了，我只能给你阐述思想，这个东西你别指望说我一我我，我讲一遍你就听懂了，如果我真的讲一遍，你就听懂了，那这东西显得太容易了。

太简单了，它没那么容易，没那么简单，所以最关键和最核心的点在什么地方，你先听一个，大概有了整体的一个思路，当有了思路之后，你自己再去debug，再去过流程，再去捋，这个时候你的印象是非常深刻的。

而不是说你作为一个初学者，我压根没听过的一个状态，我就学这玩意儿，如果你是一个初学者，压根没学过这种状态，一听的话肯定很难受，肯定很难受，明白意思吗啊，所以把这个过程想清楚了。

大叔能回答我的问题是啥问题，刚才如果不加AOP的话，是不是就不创建带对象了，直接选选项，那肯定啊，你没有AUP的话，你创建带对象干嘛没意义了，6B本身就是因为加了一个代理代理对象嘛。

系列 5：P55：55、互联网架构演变之路 - 马士兵学堂 - BV1E34y1w773

好了同学们，咱们开始准备上那个spring boot了，好吧，来能听到我的声音，同学扣波一，呃今天啊咱们开始那个讲spring boot，很多同学一直在问说那个spring boot讲什么程度呃。

我希望讲一个完整性的课，就是说从基础，然后呢到后面的一个精通，包括到源码，我们这边都会讲的，所以有些基础的东西啊，大家可能听得很烦，因为之前你们在公司里面你用到了，但是我这还是希望把这些东西啊。

整体再做一个回顾，很重要一点信息好吧，咱们咱们做过课，大概我的计划是6~8节课，有可能时间会更长啊，这不一定，但最少也要上六次课，懂我意思吧，从spring开始讲，不会的呃。

spring啊是我们基础班的一个课，spring从基础班的一个实验一个课，基础班的时候也是一样的，我也会从基础的东西开始讲，然后讲到源码呃，还是一样，我希望就是把这个整体的知识点啊。

都做一个整体的完整的一个学习，这样的话对大家的一个好处更明显一点，如果你所有东西都听一半，或者听一个阶段可能不太好，OK大数据是不是连老师上的呃，大数据讲了，还有base。

包括那个日日志的那个小小小项目，然后后续的话可能会讲麒麟啊，基本上三门课我都讲了呃，大家还是根据自己的需要说，我到底要学什么东西，基础版SPM没开始，刚刚讲到JS啊，刚讲到JSJS这块我没去讲。

然后请了一个专业的老师来讲解的，后面的话都给大家补起来，这大家放心啊，呃刚刚很多同学提到大数据，大数据这件事情，我再说一下大数据的东西啊，怎么说呢，呃很多同学说老师我没时间看。

我没时间看或者怎么怎么样好吧，还是一样，大数据应该是一个必备技能，你们现在买了课没时间看，没关系啊，没关没关系，后续的话啊，有时间了，一定要把大数据课补起来，因为你往后看三到5年。

大数据一定会像java一样，在大街，它会成为一个必备技能，而且咱们这边大数据课和大数据课，应该是比较专业的，光HDP周老师讲了14节课，懂我意思吧，应该有很多很多这方面的一个东西，非常非常完整。

所以你需要哪一块听哪个听哪块就可以了，不叫大家不要求大家说每天必须要跟某一门课，你根据自己的需求来决定就OK了，懂我意思吧，今天结合项目吧，看情况，看能不能讲到这块，但应该讲不到。

我们只是一个刚开始的一个基础课，好吧行了，废话不多说，我们开始讲解spring呃，加spring boot，然后再说一下啊，呃大家看到了，我上课的时候，首页打开了spring官网。

之前我在讲课的时候也一样，非常喜欢好非常喜欢，或者带大家看一下我们spring的一些，包括一些其他框架，一些官方网站和官方网站，为什么官网永远是我们第一手的一个学习资料。

所以我希望你们以后学知识也是一样的，所有东西从官网里面直接去看，这些点很重要的信息好吧，人家学说腾讯课堂目录有点乱，呃这个应该不会特别乱。

因为之前给大家做了一个整理，那天有学生反馈之后，我专门做了一个整理，大家可以看一下，其实啊只是java课里面稍微有点乱，因为java里面我们加了很多的一些怎么说呢，很多的一些加了很多餐。

所以这块可能会稍微乱一点，然后这边给大家做做好整理的网络分布式，然后spring cloud多线程高并发，spring源码，Net n i o，然后呢JVM1级流量的项目。

包括MYSQL调优架构师的前置知识，这块都给他做做了总结，明白意思吧，所以这块几乎后面的东西也都会一直更新的，不用担心啊，大数据的顺序有吗，大数据就按照课程顺序往里面写就行了。

往里面去就OK了，懂我意思吧，就按照我们课程的一个呃，正正确目录顺序来SS来说啊，肺部流域说质检吗，呃没关系啊，你们能够找出来问题或者提出来bug，这很正常，我们是人不是神。

我们也会有自己认知错误的地方，如果有问题，希望大家能够及时反馈好及时反馈，没问题啊，咳现在没有意义，根本跟不上，慢慢就跟上了，总之一点你记住一定是要学的就可以了，懂我意思吧，架构设计没有。

有没有中台项目啊，呃这个怎么说呢，呃看情况吧，大家如果对中餐有有兴趣的话，可以学一下呃，给大家说一下中产项目，我们是请了一个现在已经投产的，已经在产生一些商业商业价值的。

一个项目的公司CPU来进行讲解的，所以咱们的中台才是正儿八经的中台项目啊，到时候你们期待就可以了，一定会有的啊，好了废话不多说，来先聊一下我们的spring boot好吧。

很多同学在公司里面一直在用spring bot吧，来在公司里面现在没有接触过spring boot，同学扣一没有接触过的，别说我接触过没有接触过扣一这么多吗，不可能吧，是我认知错误了吗。

人家给大家说一下呃，现现在还有很多传统项目，很多还是SSM呃，那我们就更要从刚开始来进行一个讲解了，刚开始进行讲解了，它一样，先说一下我们的SSM，其实在SM之前应该是什么叫SSH，对不对。

它是有一个整体的过渡阶段的，在S之前可能还有slate和JSP对吧，他们几乎都是一脉相承的一个东西，这块我希望从刚开始第一节课的时候，能够帮大家拔高我们整个架构的一个认知，好架构的一个认知，大家想一下。

在我们的项目，或者说我们的it行业发展起来之前，最开始的架构是咋不上最开始的架构，没人知道好吧，叫单一架构好，单一架构这块给大家看一个东西，看什么呀。

我们看一下double的一个官网，double官网里面有这样的一个描述，我不知道你们有没有看过，我们架构师根本不信这些话，不知道的东西，药性好吧，这些东西设计还是非常有意义的，我们来找一个文档。

在他文章里面有一个背景，大家可以看一下这样的一个描述，我们今天不讲double是吧，不讲double没关系，然后这单这边我们要看一下互联网的发展趋势，说随着互联网的一个发展，网站应用的规模不断扩大。

常规的垂直应用架构已无法应对，分布式服务架构以及流动计算架构势在必行，急需一个治理系统，来确保架构有条不紊地进行演进，所以这里面几乎画了这样一个学习路线图，或者说一个架构的演变过程的一个图。

这个图我不知道你们能不能看懂好吧，但大部分应该是没问题的，往上看上面放了framework什么框架吧，然后有architect，我们的架构，后面有我们的cluster，表示我们的集群。

他有这样一条时间线的这个图，我不知道你们有没有见过，没见过，没关系，我就带你们看好吧，刚开始ORMMACRPCSA，对不对，刚开始是什么呢，叫all in one，就是我们说的单一应用架构，这也说了。

当网站流量非常非常小的时候，只需要一个应用，将所有的功能都部署在一起，以减少部署节点和成本，此时用于简化增删改查工作量的数据访问框架，om是关键，这里面描述了一个什么信息啊。

就好比你们在刚刚接触java的时候好吧，一般在学到server之后，很多人可能说老师我终于学了，OK我可以做一个前后端交互的一个项目了，所以一般情况下都会开发一个非常简单的项目。

当你这个项目开发完成之后，一般都会部署一个外包，放到我们的一个top cat容器里面，好或者其他一些呃动态的一个web容器里面，然后进行一个运行，这个时候你看到你的浏览器可以进行访问。

然后书后面有一些数据交互，这是最开始这样一个过程，但是你要注意一点啊，这是最最最开始的时候一个架构思想，然后呢随着技术的一个演变，以及用户量的一个激增，慢慢的说这种单一应用架构。

不太符合我们实际的一个情况了，那怎么办，有了叫垂直应用架构，大家其实可以看一下这个图，看这个图来做一个对比，什么图对比，刚开始叫all in one，后面呢叫垂直的application应用架构。

什么意思啊，这个图是不是没有任何变化，好吧，刚开始一个蓝色块，后面变成三个蓝色块，然后下面集群规模由1_{10台变成10}1000台，这表示都是我们的应用程序，也就是说当用户的一个访问量逐渐增大的时候。

单一应用增加机器带来的加速度是越来越小，为什么你想一件事啊，你想一件事，什么事情你注意了，任何一个硬件它都是有自己的一个性能上限的，你所有东西都部署在里面的话，就算你扩大或者增加你的硬件的一个效率。

他其实对大家速度影响也是非常小的，然后他说了江西应用拆成互不相干的几个应用，以提升效率，就是我现在需要把单一的一个应用拆分成，123，或者说N多个应用了，这样的话就变成一个什么呢，叫垂直应用架构。

然后演变之后说了，在垂直应用架构中，此时用于加速前端页面开发的，web框架的MVC是关键，什么叫MVC啊，model will control吧，包括你们现在写项目的时候一般都怎么写。

现在定义control用来接受我们用户的一个请求对吧，然后定一个model，我们的实体类好吧，然后还有我们的MV没有视图，是我们的一些浏览器页面，是不是进行这样的方式，你们现在做的时候依然是一样的。

只不过现在我们用spring也好，还用spring boot也好，他帮我们做了一个整体的整合好，整理整合这块大家注意了，好之后，我们再来说好之后我们再说这块，然后呢由垂直架构之后又做了一个演变。

叫什么呢，叫分布式架构，Distributed server，好service是什么意思啊，一样的，也就是说当垂直应用架构越来越多，应用之间交互不可避免将核心业务抽离出来，作为独立的服务。

逐渐形成稳定的服务中心，这个时候你注意了，当你形成N多个服务中心之后，会存在什么问题啊，他们之间一定要产生数据的一个整体，交互过程和整体交互过程，这个交互的时候通过什么，是通过我们的RBC了。

什么叫RPC，是不是要远程过程调用这样一个东西，好，远程过程调用这样的东西，好吧，这后面这说的，通过远程工过程调用来进行一个演变，然后用它之后还没完，又往下进行一个演变，怎么演变。

说当服务越来越多的时候，容量的评估，小资源服务的浪费等问题逐渐免疫明显，此时需要增加一个调度中心，基于访问压力实时管理集群容量，提高集群利用率，此时用于提高集群利用率，资源调度和治理中心就成为了关键。

就是我们的SOA，是不是大家看到了这段有一个基本的描述，这个描述里面，就阐述了我们整个互联网架构的一个演变之路，当然很多同学可能年纪还比较小好吧，你可能没有接触过前面这些架构的一个演练，过程，好吧。

你下来之后可能直接学spring boot搞定了，或者直接学微服务，对不对，但是前面这些历史你要有一个感知，会有一个认知，他一定是要不断进行发展的好吧，而发展的最终的目的是为了什么。

是不是使我们第一开发效率提升，第二我们对应的一个应用程序，它执行的一个效率要做一个提升，所以人们怎么样呢，会发挥自己的想象力，创造出来各种各样的一个东西好吧，来达到我们想要的效果，这块要注意了。

所以刚刚这个架构演变之路，能听明白，同学来扣个一就通，看懂吧，你永远不要想老师，你这个图你是怎么知道的，我还是那句话，你多去看官网，你不一定说我学什么技术，就一定要看什么官网啊，没必要。

但是你要知道一件事，当你开官网之后，他们其实可以交叉进行学习的，double里面的东西是不是介绍这个价格演变之路，我们在spring bot这就可以进行一个使用了。

而且现在在企业里面几乎没有spring，没有公司不用spring了好吧，spring还有一个全家桶人工，里面提供了非常非常多的一个服务吧。

这块希望大家能够知道好吧，往下看，这是spring的一个官网，我刚上来打开，就是这个官网好吧，有spring boot，spring cloud和spring cloud data flow。

他这三块表示什么意思呀，什么意思，第一个叫build anything，叫构建一切好吧，第二个呢叫协调一切吧，第三个呢叫连接一切，这是spring他想做的一件事情。

然后里面分了N多个组件来进行一个描述，第一个spring fm和五就是我们的spring框架，这东西咱们加过课里面可能不会再讲了，后续的话基础课里面会讲，把基础课里面会讲。

然后呢讲完之后我们会把那个课单独拿出来，成了一个小课，之前我也说过了，我们有自己的一个视频网站，这个视频网站我还在开发好吧，大概在1月1号的时候会重新给大家进行界面，把我们整个网站的一个设计。

把整个网站的一个设计都会进行一个更新好，其实现在也在做，我可以给大家提前看一个东西，看啥呀，给他找一下，就我后面一直在做升级，很多同学可能有平常问问题的时候，可能找不到我。

为什么一般都在开发这个开发这个项目，大家看一下叫web杠test，诶没了吗，Test gun，Web gun，Index html，大家看到了这个。

现在这样看起来这图现在还没做好吧，之后的时候别老想着翻车好不好。

之后的时候，我们会把网站进行整体的一个升级啊，这是我们后期的一个网站。

这边的一个规划，应该比我们现在官网要好好看很多吧好吧。

大家今天等着以后啊，还是那句话，会提供越来越多越来越好的服务给大家，你们从官网里面。

或者通过我们的视频网站都能看到很多信息，但这开发只不过呃需要一段时间，所以希望大家能给我一段时间好吧，一个人就是一支军队啊，不是啊，我们肯定要做这块东西的，懂我意思吧，用的技术你们就不用管了吧。

好用的技术你就不用管了，前端也是一手包办包办嘛，基本上都在自己做好吧，基本上都在都在自己做啊，所以有时候可能回答问题不太不太及时，原因在这就在这一块，要是招人不，我可以去找啊，可以投简历好吧。

欢迎大家投简历，反正你能想到的东西，我还是那句话，你能想到的东西我能做的都帮你做了，所以希望大家能够珍惜自己的时间，抓紧时间学习就够了，懂我意思吧，不知道七爷头像还有没有没有了没有了，没几天了。

是没几天了，我们后续这些东西都都都都在做啊，不给你们看其他页面了，没有意义啊。

系列 5：P56：56、什么是微服务架构？ - 马士兵学堂 - BV1E34y1w773

就行了嗯好了呃。

禁止闲聊，我们接着往下看，好吧，刚刚说一下spring。

我们今天主要讲什么，讲spring boot这样东西，我还是那句话，我希望你们去看官网啊。

动画里面透露出来很多的一些相关信息，都是我们值得思考的，比如说很多人一直问我说，老师spring boot算不算是微服务啊，啊听到有问题啊，我说spring boot算不算微服务，就算同学扣一。

不算同学扣二，你觉得算吗，不算吧好吧，其实我照我的理解来说，我说一下可以说一下我个人的理解啊，在我看来在我看来，微博是什么东西或者什么东西，它其实就是一个启动器，就是原来我可能要做各种各样的一些。

配置文件的编写的啊，包括说各服模块单独起一个，然后现在呢我把它整合到一起了，所以这块他给了一个非常官方的一个描述，你可以看一下叫什么叫spring boot。

是一个什么叫starting point for building of spring base application，这句话什么意思能翻译出来吧，没有没有难单词，看错了，boot是一个什么呢。

叫构建所有spring1度为spring的应用程序，然后呢告诉你说starting point是不是一个启动点，是不是个启动点，好吧，再往下看，说boot设计用来干嘛呢。

Get you up and run，As quickly，As possible，什么意思，所以他这种设计为了什么呢，让你能够尽快的把它搭建起来，并且尽快的把它给运行起来，这是最好的一个方式好吧。

叫within minimal，叫apple phone configuration of three，减少我们对应spring的一个配置，这句话是很明清楚的描述。

你描述告诉我们spring boot是啥，有提到任何跟微服务相关的点吗，没听到过没有吧，所以你看到很多地方都在说spring spring boot微服务呃，这么说其实也没啥毛病，但是可能不太严谨。

也还是一样，看官方里面的一个基本描述，这里面是最准确的，它里面有什么特点啊。

第一个叫gun start in seconds，Using spring in the rather，什么意思，什么东西，这是啥，是不是说让你在进行配置的时候，通过在几秒钟之内就把它完成。

是不是有一个叫spring insuler的一个启动器，我们直接启动就可以了吧。

很多人在开发的时候是有这样的东西，叫study spring I/O，在里面我可以下载一个对应的一个炸包，建议运行，当然我们现在没人这么干啊，没人这么干，那怎么做，这可以，我们通过我们的idea。

是不是直接就给他进行一个集成，从idea里面直接做就可以了，好吧，S不要找事好吧。

你不来北京了吗，我等着跟你打架呢好吧，来北京找我好了，这是第一点，第二点是什么呢，叫building anything，什么意思，restful API吧，Websocket。

Web streaming task and more，是不是有很多很多这样的东西对吧，说构建任何事情再来看叫什么呢，叫更简单的一些security吧，是不是安全。

然后呢叫rich sport for circle，SQL非常丰富的一个支持，对于我们的circle和我们的NO SQL，然后内嵌的运行支持有tomcat，有gt，and you undertal对吧。

Developer production toys，是有很多开发者的一些高效率工具，比如说叫library reload，按照什么呢，auto restart自动启动，以及我们这个页面的一个自动加载好。

或者自动重载对吧。

再往下看这个翻译啊，我一直没解释解释对，我也不知道这个干嘛的啊，我也翻译不出来，谁知道可以给我说一下，懂我意思吧，在大家看看什么叫准备好一些特点，例如跟踪对吧，杜灵和我们的一些健康检查。

然后说worker in your favorite ide，可以在各种id里面进行运行，例如例如有什么spring steals，是一个工具的一个东西，还有idea以及我们的net beans。

net beans啊，现在已经没人用了，我之前的时候还用，现在已经没人用了，所以大家想一下，我们现在开发的时候更重要用什么，是用我们的idea之后，我们所有开发的时候都会在idea里面进行执行，好吧。

其实在1T架构课的时候，因为老师已经讲过我们对应的一个spring boot了，好吧，讲过我们对应的一个应用这块，大家应该都听过，为啥不说eclipse呃，这块是它集成好spring的一个工具吧。

也就是一个一个list吧，但它集成了我们spring是不是好吧，那现在你们公司没用什么用idea吧，还用玩家用的比较多一点，所以我们上课的时候也会用我们的店，不会用其他东西了，如果你觉得不习惯的话。

你可以把它切换成ELISE哇，这就无所谓啊，反正就是个DE而已，看你自己的公司notepad加加，你要能够派佳佳给我写好，你也是牛，你也是牛，我也佩服你，我也佩服你，好吧行了，这是官网的一个基本介绍。

这块就看这么多。

所以看完这些描述之后，你应该有个感知，OK我现在了解到spring boot到底是用来干嘛的，当然我现在还不会用，还不会用，不会用，没关系好吧。

一会我来教你如何进行一个使用，这边给大家画了一个什么呢，spring boot的一个思维导图呃。

我上课的时候习惯给大家画这些东西，好方便大家做一个整体的一个总结。

那我们来看一下吧，第一个叫回顾它需要某些spring的一些特点，比如说OWARE自动注入对，也就是说IOC和a OP，在我们的spring bot里面是有应用的，很多同学可能还没写spring。

没关系好吧，你不用管它，你不用管它好吧，这只是对spring的一个基本介绍，基本介绍你再简单看看就行了，好基本简单看就可以了，这干嘛呢，说spring是为了解决企业级应用开发的复杂性，而创建的。

就是为了简化开发，然后spring降低开发复杂性的一四关键策略，第一个叫基于poo的一个，轻量级和最小侵入性的一个编程，也写错了，侵入性，我写错别字啊，编程第二个什么叫通过IOC，第三个呢叫AOP好吧。

通过切面和模板减少样式的一个代码这块，我们之后再说讲spring时候我会详细讲的。

OK再来看spring boot有什么优点啊，说为所有spring开发者更提供更快的一个入门程序，然后再说第二个叫开箱，即用提供各种默认配置来简化项目配置，第三个叫内嵌式容器，简化web开发。

第四个叫没有冗余，代码生成和XM2的一个配置要求之后，我们会学一种新的配置文件，你们之前可能用XM2或者用properties之后呢，我们会有一个东西叫什么叫email y ml。

这是我们spring boot里面官网里面给的一个推荐，好官网里面给了一个推荐，到时候用起来就知道了，他写起来更简单一点好更简单一点。

然后后面我这也描述了一下，我们对你的一个架构演变之路，这是从网上找的一张图片。

可能放大吗，好大家看下图片啊，第一个单体架构什么样子好吧，SV架构以及我们的微服务架构，现在大家见到的更多是我们的微服务架构了，下面有对应的一些特点，这块下去之后自己来看好吧。

我们上课不做这样的一个演示了，没意义，下课之后我会把这个图发给大家好。

发给大家，然后呢后面有对应的一个介绍好吧，什么代理架构啊，是不是叫all in one吧。

指的是将一个应用而中的所有服务，都包含在一定程序里面，无论什么系统，都将数据库，web的各个功能模块放到一个可执行文件里面，比如说一个外包或者一个炸包好，这样来进行一个执行，第二个叫SOA架构。

面向服务的一个架构，它是一个什么叫组件模型，它将应用程序的不同功能单元简称为服务，通过这些服务之间定义良好的接口和契约，联系起来，接口是采用中立的方式进行定义的，它应该独立于实现服务的什么呢。

叫硬件平台，操作系统和编程语言，这使得构建在各种各样系统中的服务，可以以一种统一的和通用的方式进行交互。

刷完了很多同学不明白，好吧，你记住了什么叫RPC好，有这东西知道就行了，RBC叫远程过程调用啊，很多地方都在用它，很多同学如果接触过大数据，应该知道大数据很多的一些呃，框架都是一种集群的方式。

集群的方式运行的集群里面，其实用的是什么RPC吧，进行一些消息的通信好吧，包括一些健康检查了对吧，消息传输了很多点，都用它稍微听一下就可以了，如果你听到那个spring boot的那个spark的话。

应该知道周老师讲spark的时候，应该对这个点讲的比较清楚，什么叫RPC，因为在spark的源码里面有一个组件，叫什么叫RPCENV吧，这是自己一个环境对吧。

包括里面用了我们的NT有什么end point，Receive point，就有很多这样的信息好吧，你看完之后你知道了，反正不管怎么样，你记住学所有的技术啊，这些东西都是一样的啊，都是一样的。

OK被我联系说，我感觉SUV和微服务区别，就是有没有服务治理和福利，服务，注册和治理这块，我希望还是一样，我希望你们能清楚地认知到什么到底叫微服务，微服务那篇论文你们看过吗。

是关于微服务介绍那篇论文有人看过吗，没有的话，一会我带你们看看，我一会带你们看看，一会我带你们看看，我看下大道了，来看一下这边的一个文字描述对吧，叫微服务架构，什么东西，微服务架构是一种。

将单个应用程序作为一套小型服务开发的方法，每种应用程序都在自己的进程内运行，并以轻量级的机制，通常是HTP或者资源API进行通信，然后这些服务围绕业务功能构建，这个组件非常重要。

叫业务功能可以通过全自动部署机制独立部署，这些服务的集中管理，最少可以用不同的编程语言进行实现，并使用不同的数据存储技术，当然说完之后，很多人还是很懵，没关系，我们来看一个东西。

来看下他有错，等下。

看这块叫micro service，是不是要微服务。

微服务里面有一堆的一个介绍好吧，告诉你说什么到底叫微服务。

刚才说了马天鹰路德好吧，有很多这样的一个介绍吧，下面有很多的一个描述，很多老师我看这个描述。

看完就疯了好吧，我可能看不懂这些东西，没关系，这边中国人有个人做了一个翻译。

好翻译文章，我也找到了好看的船长好吧。

往下看，这告诉你们说微服务到底是个啥，好微服到底是啥，往下看，说微服务架构做做什么事情，这东西啊，注意了，这篇博客是对我们刚刚那个英文文档完整的，一个翻译，如果你谁看英文看着有问题的话。

可以参考这个中文文档来进行看一下，我还是那句话，我建议你们把这套东西好好看看好吧，翻译插件，那个翻译插件并没有这个文章翻译的好好，我还是希望你们把这个文章能够看一下，懂我意思吧，地址，可以啊。

这个这个中文的地址啊，给他找一下这个英文地址，上面是中文地址，下面是英文地址，OK把俩东西对比着，可以做一个查看好。

能帮助你理解到底什么叫微服务，因为现在面试啊，你要说你不会spring cloud，或者你不会double，面试都不敢出去，懂我意思吧，呃公司里面有些公司可能在用，有些公司可能没在用，就算没在用。

也一定是往这条线上进行呃靠拢的，懂我意思吧，这道题可能是以后的一个趋势，所以这块你必须要做一个学习，为什么在spring boot这块讲一下，微服务这个架构的一个体系。

就是为了帮大家把spring boot和微服务给区分开来，不要把spring boot当成一个微服务，反正我是觉得不太合适的，我不知道你是怎么认知的啊，好这东西每个人理解都不一样，那句话怎么说来着。

1万人眼里有1万个哈姆雷特好吧，你自己去做一个评估就可以了，我们这儿不看这些文字描述了，因为你看完这些文字描述，你整个人就疯掉了啊，太多了，我们这儿直接来看这张图，你看这个图能不能感受到一些信息啊。

能不能感受一些信息什么东西啊，这里面有个单词啊，你可能是不认识的，你可能是不认识的，没关系，这是这是不是有解释，是不是这个词，这是不是有个翻译叫整体应用架构吧，我就说我发现也无所谓了好吧。

他说一个整体应用架构，Put all its functionate into a single process，说他把他所有的一些功能组件方法，都已经放到一个单一的process里面。

是不是单一的进程里面，大家看到了这里面做了一个标识，什么标识这样子的这样子的，这样子的，这样子这样子的，是不是有各种各样的一些组件，你可以把每一个组件，每个组件都当成一个其中的服务，或者一个功能模块。

好吧，他们统一的都放到一个进程里面，是不是，这是我们刚开始那个整体应用架构，或者说单应用架构是这样的方式，然后慢慢他要做一个过渡，怎么过渡呢，他做了我所有东西都放在一起，可能不太合适。

然后呢我要把它做一个拆分，怎么拆分呢，看后面这个页面之图，是把每一个小的功能模块，或者说功能组件都做了一个独立的拆分，是不是拆分成我们看到这样子了，是不是这样子搭上了每一小块都单独的，都是单独的对吧。

他也说了，这把什么呢，把刚刚那个each elements of functionally into啊，什么东西是不是拆分好的一个服务里面去，是这样的一个方式，然后慢慢的又做了一个演变，怎么演变呢。

从这张图上往下面两分演变，大家看到了每一个功能里面，是不是就跟我们上面这块一样了，只不过呢他在外面多套了一个，就是相当于是多台的一个服务器，好吧，没服务器里面可以部署N多台的一个服务组件。

是不是有1234，这样的话大家看到管理起来其实是比较混乱的，或者比较杂乱的，然后又做了一次过渡点，在后面那个地方，这怎么做的，是不是说每一个服务里面好，每一个服务里面它会有不同的组件。

不同的组件我这块可以进行人为的一个选择，但是我规定好了一个里面是不是只有四个服务，这意味着你是不是在选择的时候，可以选择说，我往不同的物理服务器里面进行部署，这时候他们是统一工作的，而这里面每一个地方。

你都可以称之为什么一个对应的微服务。

只不过从这个图上看起来的话，它可以是一个集群形式，所以从这个图里面你能感受到很多的点。

就是这个论文里面，你是不是看到这个点了，往上翻。

这个图啊就从官网里面直接拿过来的，就这个图是不是一模一样。

是不是一模一样，好吧，这也做了一个最官方的解释，所以你把这个图如果看懂了。

你就知道哦，原来是这么回事，大概是什么样的一个意思，后面对我们的微服务做了一系列的一个解释，好朋友更多，我解释下来之后，自己看好。

我们，这不再多解释了，所以我希望你能认识到spring boot不是为服务，不要把它再说错了。

这个东西啊不是那么合适，懂我意思吧，OK我就想给你们扭转一下这个观点。

仅此而已好了，这个文章地址我已经发出来了，发完之后下载之后自己好好看看好吧，下完之后就看，把这块好好做一个理解，或者做一个了解。

这很重要，懂我意思吧，放这放哪个图，这个图也是一个颜面的一个图。

下面可以自己看好了。

系列 5：P57：57、第一个springboot程序 - 马士兵学堂 - BV1E34y1w773

长时间了。

下面我们正式进入到spring boot的一个学习，怎么学啊，很多同学又懵了，老师一涉及到知识点学就慌了，如果后面再出来一个spring po。

我要怎么学习啊，非常简单，官网我一直在强调这件事的重要性，包括之前讲讲课的时候，MYSQL也是一样，我是不是带你看官网，你们要看好吧，叫spring boot，我们现在讲课用什么用，最新版本是2。2。

2好，2。2。2也有可能我们spring boot还没讲完，他就更新了，spring boot更新啊是比较快的好，但没关系，基本的核心点应该是不会变的，懂我意思吧，基本的核心点不会变。

然后这有个reference document，你可以从这儿进行一个查看啊，进行一个查看，里面包含很多个组件，先点开之后挨个看就行了，挨个看就行了，懂我意思吧，这块一定要看，那老师我不行。

我看英文之后头疼头疼怎么办，你知道老师翻译啊，没用好吧，翻译出来之后，可能意思跟你想要的意思就不一样了，我怎么做也非常简单，我这给大家分享一个也是别人写好的博客好吧。

叫gatebook git books，这里面有spring boot2点X1个中文文档，好，大家看一下这个中文档里面有详细的一个介绍，好详细的介绍，他说了，六一时间，基于spring boot2。1。

5的官方文档进行了翻译，注意了，这是2。1。5，我们现在用多少，2。2。1吧，但我错过了这个小版本的更新的话，其实呃有些点可能会变化了，但是能帮助我们对应做一个复习。

所以这块我还是希望你们能看一下中文档，看不懂英文，我们看中文总可以吧，但是官网这个学习道路你一定要注意了，一定要秉持下去，这是我我强调过这件事情，我觉得别别的老师也强调过啊。

你不要说老师所有东西等着我喂给你的意义，在之后你看官网其实能学到很多东西，这里面导航栏你直接看就可以了，其实我错了，如果我不讲，我不讲，你也应该能学会啊，只不过说这东西怎么学的一个方式。

所以这样我会带着你说，告诉你这块应该怎么学，老师可以把这些app放到相关笔记里面吗，可以可以啊，一会我会把这个SM的文档分享分享出去，一会儿我会把相应的一些笔记，给大家都补充到里面去，下课后再补充吧。

我们上课不浪费时间了，好一会我把这个图分享出去，你们从图里面直接看就行了，懂我意思吧，一会来做啊，这个忙忘忘了往里面进行整理了，好了，来往这看吧，上面的都是一堆废话。

告诉你说我要怎么进行构建之类的东西啊，我们这儿不看了，这块他翻译还没翻译完好吧，还没翻译完，但是这些东西已经够我们进行一个使用了好吧，第一个先看入门。

如果说里面对spring boot做了一个基本的介绍，他说实用boot可以很容易地构建出直接运行的，独立的生产级别的，基于spring的一个应用，我们对spring平台和第三方类库有自己的考虑。

因此您可以从最基本的开始，大多数人不同应用只需要很少的spring配置对吧，然后说你可以使用spring boot，来创建一个可以使用java杠站的命令来运行，或基于传统的外包部署的应用程序。

还提供了一个什么叫运行spring s script，的一个命令行工具吧，有多种样一个方式，把后面告诉你目标是啥，这块用看了你知道他运行完成，或者你写完代码之后。

我可以通过java炸的一个命令来进行运行就够了，所以所以当你写完代码之后，你看到的应该是什么，是不是应该是一个完整的炸文件对吧，这样更炸这东西所有人都知道啊，所有人都知道这块不用多说了。

OK下面有什么有系统的一个要求，现在一般情况下你们的电脑可能都满足了它，现在系统什么意思，告诉你说我用什么样的一个web容器好吧，server的版本是多少，以及我们的JDK的版本是多少。

现在一共多少八吧，所有人应该都用八了吧，没人再用六和七了吧，如果你公司里面还在用，就无所谓啊，但是说了，虽然您可以在java6java上运行不好，但是我们强烈推荐你使用java8，懂我意思吧。

一定要使用我们java8这样一个版本，告诉你如何进行一个安装好吧，告诉你后面一堆的安装方式，这不再多说了好吧，这里面有这样的一个机构的一个配置是啥，问问吧，你们对maven熟吗。

我来问一下现在听课的学生，有没有不会问问的，有没有不会问问的，不会的扣一好吧，应该有一些基础班的学生啊，不过没关系，之后基础班的时候我会讲maven，这东西怎么算会呢，你知道可把我把我把我问住了。

基本的操作吧，基本操作吧，这门课和架构一般的spring课是重复的吗，呃有一部分内容会重复，但是这边的话可能讲的更加，那个就一期的时候教大家更多是些使用，这边的话会使用加原理都讲，把使用家里面都讲了。

懂我意思吧，来往下看吧，这边告诉你maven gradle好吧，安装FRAMEBOOTCLL这块我们都不用好吧，所以对于你们没有东西不用管它往哪看，11叫开发第一个spring boot应用程序。

把spring boot应用程序啥意思告诉你，我如何来进行一个最基本的创建过程，非常简单，第一步先在电脑里面安装maven，我这儿已经安装了，大家看到我电脑的C盘里面已经有了一个maven。

但是版本比较低啊，比较低无所谓，这里面我希望大家改一个东西啊，改什么东西啊，改一个settings XML文件，这个文件里面做了一些相关的一个配置，其实有两个非常重要的配置，哪两个。

第一个是我们本地的一个仓库路径，你设置好好吧，第二个是你要参考的一个镜像地址，来看这我要用谁的，是不是阿里云的，是不是阿里云的，你这块可以自己做切换，无所谓好无所谓，但是我建议你换阿里云的。

因为有可能你访问国外的话，可能速度会比较慢一点，有可能我们现在班会比较多啊，阿里云的话可能速度更快一点，所以这块做一个推荐好作为推荐，当然你可以如果你对比较熟的话，你看自己心情想要什么英雄就可以了。

对于初学者，一会我会把这个配置文件发出来，发完之后你按照我的文件改就完事了，懂我意思吧，不要在这个配置上面浪费太多的时间，懂我意思吧，就这块，这是我之前配的，这是我之前配的，我不知道地址改了没有。

反正现在还能用，现在还能用，OK地址变了，不是应该是吧，就这个吧，反正我现在还能用啊，我不知道他有没有改地址，因为基本上改完之后没动过它，没动过它好了，不再管它了，不再管它了，你下去之后自己配就行了。

反正我就一直用这个配置，不管它了，然后第二个要创建pom文件，就是你把刚刚的配置粘过来就完事了，好这样可以选对应的一个版本。

这个配置class的一个依赖，是不是分别分了N多个步骤，然后告诉你说如何进行一个编码操作。

然后使用Rest controller和request mapping注解，然后把CONFIER注解。

然后命名方法是一对的样例了好吧，这块我们来运行一下，看下应该怎么做。

好，看一下应该怎么做，其实非常简单，我说了，这是第一种方式，你可以用我们的idea来做，除此之外你可以用这样的一个工具来做，当然你在自己学的时候用它没问题好，因为它没问题。

但如果在公司里面肯定没人这么干，太麻烦了啊，怎么说呢，这可以选一个maven project，然后选择一个编程语言叫java，第三个选一个版本，我们是不是2。2。2。

就这个版本下面什么叫project match date，这可以选什么，选上你对应的一个group，这个group一般是你公司域名的一个告，写了怎么写com点把生命对吧。

这可以写一个叫spring boot下键study，这有一个options是详细的一些选择，比如package name Python，把它删掉到点到com点马士兵就够了，然后是一个炸包。

这第一个版本是八，这都可以做一个选择，除此之外好吧，除此之外，这页面里面提供了我们各种加载的一个工具，好比如说上一个什么呢，叫d EV toys，是不是进行热部署的，第二个NOBO。

是不是进行那个那个实体类的那个set get方法，进行一个填充，填充的是不是只需要加注解就可以了，包括我们的web可以配置上我们对应一个容器，现在有我们的template是模板。

比如后面我们用sim对吧，security有spring security对吧，OS2。0是不是有各种各样的版本，然后circle我们用JDBC好，或者用spring data jdbc都行。

更上版本你可以选择自己需要的东西好吧，需要什么加成就可以了，暂时我们是不是就是原生的原声的话，我就搞一个什么最基本的，比如web项目吧，大家都选上勾，选完之后拿去吧，这边告诉你说一个flat。

然后把它合起来好吧，别东西不要了，点开它合不起来吗，我看这是不是可以写一个叫spring web，然后写完之后搞定了，别的东西不需要加，你不用管它了，然后再选一个按这个按钮，它就是下载一个站文件。

对我把这文件拿出来，这很快啊，这很快啊。

CTRLC2V拿过来，拿过来之后直接解压，他就是一个项目，然后用我们的idea进行打开，呃之前群里面有人问啊，说idea过期了怎么办，你过期了，你就从淘宝买一个，或者淘宝上搜一个。

我一会可以给你分享一个，就是免就是到2099年的一个东西啊，一个注册码，你自己需要做一个配置，很麻烦，你要不想麻烦的话，你就你就搞一下啊。

这个东西很基础啊，这不再浪费时间了，你们应该都会了，呃这spring源码我再带你们看源码东西呃，我现在给大家说一下，后续的话我们会讲spring源码，spm boot源码。

很多同学可能觉得那个老师spring boot源码，就是我看起来很麻烦，很麻烦，呃这块给大家说一下，我会给大家写写笔记，写写笔记啊，呃这我几乎整理了一些，大家没整理完，后续的话会给他加东西的。

就是你在入口的时候写的东西，应该加什么样的组件，这块注释啊，我都会给大家写的啊，都给大家写的懂我意思吧。

所以希望你们很多人看源码看不懂，或者说看完之后就忘原因在哪，你很少去做一些注释或做一些笔记，你把这东西做完之后，你回头再看的时候都会感觉比较清晰，OK2099年那个工具破解完之后，就是2099年的啊。

所以你们如果需要的话，我就给你们，你们需要吗，需要的话，一会我分享一下，这没啥难的啊，这很简单的东西，需要就给你们无所谓，要啥你也要啥，你们什么你们都想要，That cost project。

这样可以选什么，选哪个有import，有open吧好吧，交易版可以用，打开我们的，desktop选他，Ok，那就这样会有一个maven的一个构建好，maven的构建啊，等一下是不是构建好了。

构建好了之后，这块可给大家说一下，你可以把几个，如果你看到这个目录比较多的话，可以把这东西删掉，这东西没用推删了，反正我每次删掉他，我感觉没啥用，OK这就来一个SRC。

然后人家s min java里面有什么com，然后呢马士兵里面有个boot study application producation，就是我们对应整个程序启动的一个入口了，明白意思吧好吧。

这块就有这东西了，所以这之后你就可以怎么样直接运行，当然我们现在运行之后没有任何效果，因为我现在是什么都没写，什么都没写吧，这几个是啥啥是啥，开启源码输入啊，现在讲到源码啊，现在讲源码已经懵了。

他不知道怎么样，现在这样直接运行了，运行完之后能开启，我们能运行，我们对应的一个东西，删了几个是啥，一个是git的，一个是那个呃，maven的一些相关配置文件都无所谓，直接删就行了，你这个id留下。

把其他东西无所谓，好现在我现在这种东西无所谓啊，然后看完了之后。

事件是不是启动好了，我们现在没法访问，因为你什么都没写，什么都没写，没意义，那怎么做非常简单，先看一个文件叫pom文件，pop文件跟我们刚刚那个spring boot是相呃。

跟我们那个maven是相互关联的，大家看一下里面有什么样的一个东西，好吧，往下找，刚开始上面写一个parent，是不是我们父母的东西，或者说一个副项目里面的东西。

还有个东西叫spring boot starter parent，这样可以点进去好吧，点击之后就看到有parent，是不是各种各样的依赖的spring boot dependency。

后面有各种各样的东西，过滤过滤器啊之类的相关相关属性配置，你这还可以往里面再接点点，点完之后往下翻插这块的吧，这块属性我希望给你们看一下，因为我们之后再加载我们spring boot的一些相关的。

一些依赖的时候，我们很少去写版本好，为什么写版本，因为在他的父亲的父亲的这个配置文件里面，已经帮我们加了各种各样的一个版本了，这里面有一套配套的，所以一般版本这件事情我们就不会搬了，我们不加了。

不加了也没啥意义，好吧，这也帮我们定义了很多东西啊，很多东西这直接导入就行了，懂我意思吧，哇这里面这个配置啊，下载之后可以详细看一下，之后将原版的时候我会带你们详细看啊，这是我们这个父亲里面的东西。

再来看是对于我们当前这个项目的，然后告诉你说这节课的版本是1。8，这有个dependency是我们的依赖，依赖里面包含两个东西，一个叫web，一个叫test，这块希望大家注意一件事，什么东西呢。

在我们的spring boot里面，它定义的这些依赖都是非常非常规范的，什么东西上面全部叫o r g spring framework。

点bot下面的都是spring boot杠start开头的后面是一个web，其实这个start就告诉你了，尤其其之后意味着什么，如果我想加一些其他额外的组件的话，只需要加载对应的一个依赖就行了。

这东西怎么加啊，也非常简单。

来往下看，我们来找一下吧，还是一样去官网找啊，知道在哪吗，官网我看英文官网在哪找，你选这个叫uzring boot，点了之后你往下看看这有个哪去了，往上看。

在这块什么东西叫spring boot application star，只有一堆的启动器对吧，Rt mq a m q p，然后呢a OP，然后呢有bench catch，是不是各种各样的组件好吧。

你后面需要用什么dj b AD DB c dj pa好吧，LDAPMONGO对吧，你有后缀REDIS是什么都有，直接点开我们的pom看一下，在泡沫之后会有一个对应的依赖，你把下面的一些加进来就可以了。

我加进来就可以了，直接粘非常方便的一个方式啊，所以官网里面都帮我们定义好了，拿过来之后直接往上粘搞定。

懂我意思吧，那么现在我们已经把当前项目给导进来了，导完之后再怎么做。

是要测试一下当前项目能不能运行啊，首先因为我导入了一个web模块，导入一个test模块，test不用说了，这是个test包里面你可以直接进行一个运行，这非常简单的一个方式啊。

里面是有一个context loader里面写就行了，主要是我们这个web，也就是说我可以把当前项目当成一个web，项目进行运行，但是你看一下，我这有部署任何跟tomcat相关的东西吗，没部署吧。

因为刚刚看到一个东西叫什么叫内建的，看官网首页，在官网里面是不是有一句话，找一下，玩法，什么东西叫内建的一个运行时的一个支持吧，例如tomcat gt and the road undertow。

是不是各种各样的一些组件，所以这块它本身里面就有了把内置的啊。

内建的这样的东西，所以我们这不需要做任何的事情了，这块所以我刚才为什么你读那块东西，你读完之后你能获得很多启示，现在现在怎么做呀，非常简单了，现在运行的时候，这你有一个package。

当同学老师写control，肯定的很多人都这么干对吧，写完control之后，new一个吧，这个class叫hello，Control，OK写完之后里面能写的东西啊。

我在左上写一个方法叫public string hello括号，然后里面写一个，比如return hello，这样写完之后本身非常非常简单好吧，写这块的时候需要你具备一个基础知识。

就是spring mvc，好像MVC当然我说过了，有些同学可能没之前没有接触过，之前没接触过，没关系，这样你按照我的写就可以了，那这块要加注解了吧，之前我们加注解怎么加的。

这是不是写个东西叫at controller，搞定了吧，是不是搞定了，然后呢这块是不是要写写什么，是写一个at叫re quest mein main，写一个对应发送的要求，发送一个请求叫杠。

比如写一个hello，是不是写他写他之后按照我们之前说的，除此之外你还要写什么东西，这个叫at response body，是不是写这样的东西，那我先这样写，先这样先这样写。

一会儿再说rase control的事，是不是先这样写，这样写完之后，我们现在该写什么了，这是不是有一个main函数，是不是有个main方法对吧，一会儿我们直接把3年项目重启，等下重启啊，现在要重启。

报错了吗，没有吧，开启端口多少是8080，端口端口开启了。

那个时候我可以打开我的浏览器进行访问，The local host8080，然后加一个叫杠hello，请求到了吗，是直接返回，就是我们的hello，这个大我们，我写一个local。

HELO这边请求到了对吧，这是一种方式，除此之外，刚刚同学说了，老师可以用一下Rest controller，什么意思，在我们刚刚这个代码里面，一定是已经发送了一个对应的请求。

请完之后，我这是不是返回去一个合格的字符串，你这可以做一个修改word，然后重新启动。

修完之后一定能看到对应效果。

改了吗，改了吧，是不是就我们刚刚写代码，其实就没问题了，当然很多同学在使用的时候，他不太喜欢用这样的方式，他应该怎么写啊，老师我要这样写，把东西干掉，不要了，然后上面这块我要改另外一个注解。

叫什么叫Rest control，打开包，等下来吧，打完之后我重新启动，让他再进行一个访问走能用吗。

刷新先缓存，刷新没问题吧。

是不是也能访问到，所以两种方式你在写的时候都行好，你喜欢用哪种就用哪种，这无所谓啊，这个东西没有什么版本的限制，说我必须要怎么样啊，这东西没有什么限制的，懂我意思吧，所以写的时候直接写就可以了。

这是一个最基本的程序，大家看到了，我刚刚运行的时候有什么区别，rise control相当于是我们的control加上我们的response，帮助他返回的时候，只能返回一个字符串，返回字符串啊。

这东西后面会讲的，不用担心好吧，这个是不是有一个这还有个control，刚刚在我们的官网里面。

官网里面看，这是不是也给了一个建议，找一下返回叫格林斯，哪去了，刚才是不是给了一个叫start，这个只要不说你第一个spring boot的一个项目吧，项目完了之后往下走，这边你说我要写什么东西。

看这这写什么东西吧好吧，官网里面是不是推荐我们这样做的，所以你写的时候也可以这样做好，也可以这样做，直接把这个写成它就可以了，刚学的时候还是那句话，在初学的时候，你就按照他的配置写就行了。

他怎么写你怎么写。

你粘过来就搞定了，懂我意思吧，在这块我希望仅提醒一件事好吧，特别是对于我们队的一个初学者，这点非常非常重要和非常非常关键，很多同学在创建我们当前这个包的时候，不太注意啊，不太注意真不太注意啊，高老师。

我这个spring boot study application，还是我们对应的整一个应用程序的一个启动器，这个启动器我能随便放位置吗，我能随便换位置吗，比如举个例子，这块我在里面在这里面吧。

再创建一个package，这写一个test，写完之后我把刚刚那个移到我们test里面去，也去了吧，移完之后，这块我是不是又可以运行我们的程序运行走。

看看这是不是已经没问题，启动好了吧，当你启动好这东西之后啊，那怎么办，我是不是可以进行访问了，还是一样，同样的请求地址告诉你说错误页面对吧，我们路过扫描不到好吧。

修改一下扫描包路径，OK所以这块你要改变你当前这个包路径的话，上面要加一个配置项吧，什么配置项叫auto a，哎哪去了，sca computer代码好吧，后面加一个组件加什么。

不加上我们对应的一个the com，第二啊，士兵看着我加加加加一个这样的组件好，加这个组件加完之后，我再重新启动。

然后呢我现在在刷新，请到了吗，请到了吧。

这是不是请到了，大家发现了，原来我默认情况下，如果我没移动之前，它默认扫描是什么，是不是看马士兵下来的包好，但有些同学当然一般是没人去动它的，这肯定没问题，但是很多初学者在建包的时候，他不注意。

不注意之后，他把这个报告位置随便都是乱放，之前我记得咱们班有一个学生，谁问我来着，就这个问题，他把包位置移动了，发现我扫描扫描不到对应的包，所以此时报错了，这个时候一般情况下最好不要动，为什么不要动。

因为在我们的这个注释里面啊，注释里面它有一堆的一些自动的一注解吧，好吧，这个注解也很重要好吧，注意这个注解也很重要好，这边讲究相关的一些相关信息，这注解一会儿我们再聊这事，但要知道如果你改变了。

你要加上我们这个干，告诉你说你扫描的包到底在哪个路径，然后把对应路径给加上，加上这个路径之后，它就能进行扫描了，但一般我们没人干这事，所以你把它给移出来好，一般不要去动它好，一般不去动它，弄弄弄错了吧。

老板点，我会把它删掉，就你发现错误之后，咱们是刚学习嘛，发完错误之后，你要知道在什么地方能做一个对应的修改，好遇到什么问题怎么解决，它就搞定了，懂我意思吧好吧。

这是我们刚开始spring boot的一个基本讲解，大家看到了难吗，不难吧好吧，非常非常简单的一些东西，一些配置啊，很简单的一些东西，后面这个resource里面有什么东西，一会我来，我来说好吧。

我们通过源码且能看到很多的一个配置，懂我意思吧，注解我问一下呃，咱们同学有人自定义过注解吗，有人自定义过注解吗，都自动过是吧，想想自行注解没好了，在这块我希望大家明确一件事，明确一件什么事情呢。

注解其实是一个非常重要的东西，而且非常怎么说，非常非常好玩的点，一会儿如果大家没接触过的话，一会我来讲一下自定义注解，在我们的JDK里面，它默认提供了14个叫圆柱解，叫圆柱解好吧，什么叫圆柱解啊。

一会儿来解释，OK我们休息一下，10分钟之后，我们回来讲一下注解相关东西之后，你再看注解的时候，你就不蒙了。

懂我意思吧，别看到这个注解之后，我看源码的时候，看这个注解干嘛呢，不知道好一会我来讲这个东西，你知道了好吧，一会再聊，所以10分钟10分钟回来之后，我们再接着讲好吧，这人就不多说了。

系列 5：P58：58、springboot配置文件及区别 - 马士兵学堂 - BV1E34y1w773

好了多余废话，咱们不多说了，再多说了，咱们就聊这么多吧，下面我们开始正式讲课程，来韩在同学扣波一，大家记住一点，还是那句话呃，因为咱们机构啊说实话成立时间并不是特别长，所以可能有很多点。

可能给大家做的不是特别到位，所以如果你对哪个点有疑惑啊，或者说那个资料找不全，这些东西你及时联系班主任，班主任老师会协调我们这边给大家补上的啊，这大家不用担心啊，该有东西都会有的，Ok。

我们后面会做的越来越好，但是希望大家如果有哪些地方找不到，不要着急好吧，就是联系班主任或者联系老师都行好了。

来我们下面正接着讲我们的spring boot，刚刚呢我们是创建了一个项目，当然这个项目在进行创建的时候，我们是从官网里面下载一个包好，下载一个炸包压缩包，然后解压之后运行的在公司里面好。

在公司里面一般没人这么干，太low了，我也说过了，在我们的idea里面，它本身自动集成了我们这样的东西，所以怎么做非常简单，我们把当前项目给close掉，我们看一下在idea里面。

idea里面怎么进行一个创建，然后给干掉，创建一个新的项目，注意在这里面你直接选择这个spring in suler，初始化的一个东西，写完之后选择默认的一个网址，点next上面写的时候也一样。

先写上我们对于一名com点发视频，再写一个study，大家看到了，跟我们刚刚那个东西几乎一模一样，然后下面呢把这个包改一下，把SD干掉掉啊，别的东西就没有了，然后点next，这样可以选择我们需要的组件。

假如说你需要web，选web，把第一个给选上，假如你需要一个开发者工具，比如说long box，再比如说这个热部署，你勾选上就可以了啊，这直接勾，不需要进行任何的一个搜索好吧，那再往下看next。

然后可以选择我们对应项目的一个目录吧，这个目录我们这改一下，我给你们单独成立了一个目录啊，这有一个spring boot。

今天尽量别拖堂了，好怕化了，今天肯定不拖堂好吧，十点钟我们准时下课，下课之后，你们该去宾馆去宾馆，该气旅店去旅店好吧，该干自己的事干自己事，哈哈不浪费大家时间啊，2123看到了。

把这些GMV这些项目都给删掉，我没用啊，他说我有时候看他难受，我就把它删掉，你们不想删也没关系，不想删也没关系，OK好了，下面创建的时候跟我们刚刚是一模一样的，大家看到这个目录的结构。

目录的结构跟我们刚看到一模一样，所以这块你直接拿过来用就行了啊，非常简单一个东西，非常简单的东西好了，下面呢我们再接着往下讲。

对应的知识点讲什么呢，刚刚我们简单部署了一个web上面的一个项目，把web上面的一个项目建完之后再说了，有两种部署的一个方式，一个是three start spring IO来生成压缩包。

解压即可导入第二个使用idea来进行运程好吧，第三个，这有一个小玩具啊，什么叫动态生成我们队的一个banner，这东西啊是一个小工具。

我们这可以做一个基本的演示，比如这块你看了之后，你每次启动的时候，这会输出一个什么呢，叫spring boot这样一个东西，如果你想改变的话，也非常简单，官网里面告诉我们了，我们这应该怎么做，往上翻。

是不是这样的东西，你看他难受。

没关系，你可以做一个更改，这块在哪啊，很简单，我们找一下官网里面的东西，还是从官网里面找，返回返回找一个un spring boot设置东西搬哪，我们找一下搬哪哪去了，没有吗，找不到了啊，这这这这有啊。

我找一下这个banner吧，Nya banner banner，诶怎么没有了，看到这里有个自定义搬哪，这是自定义banner，你点它之后，它会出来告诉你说你要仔细便说。

可以通过在class pass里面加一个banner txt的文件，然后呢，或者说把这个位置指向我们对应的一个文件。

你就可以进行一个更改了，非常简单的一个方式，我们来简单做一下，打开resource，这里面创建一个file叫banner，点TT学民歌是吧，刚才说说学民歌这块该怎么做呢，非常简单，这给大家两个网站。

这样网站你都可以直接进来进行一个生成，bot里面这个叫spring boot banner，直接写，这可以写什么呢，这是不是有些东西生成是不是对这样的图标，你把这图标直接粘过来。

CTRLC粘粘在我们这个文件里面来，粘完之后我们再重新启动，看到了吗，是不是能看到对应效果了，接下来之后你可以做自己定制化的一个manner，一个小玩具而已，如果不需要就算了，一般没人搞这东西。

反正我觉得这个东西如果初学者的话，可能觉得挺好玩，你可以试试啊，你可以试试这东西啊，没没没多大价值。

这是一个网站而已，把这网站给大家从百度直接搜就行了，这个网站，然后除此之外，除了这个网站之外，还有另外一个网站，这东西这玩意里面也能进行一个搜索，比如说叫那是不是有点东西啊。

你设置完之后拿过来之后直接改就行了，不也是一样的，明白了吧，佛祖保佑永无bug可以改啊，你可以自己去改，我们这不浪费时间了，你知道有这样的东西就行了是吧，能做一个对应的一个修改哇，非常简单。

一个小工具啊，你把它用一下就行了，所以给大家简单说一下，看完之后往下看看，这个东西叫spring boot配置文件好吧，终于到我们的配置文件了，配置文件这块其实非常简单，刚刚我们开启了一个web项目。

你可以直接进行一个运行，进行一个部署方面的东西。

我说了，它可以生成一个对应的炸包含情的吗，是对炸包打开我们的pom文件，破文件下面这呢有一个东西，是不是一个plug in，你通过plug in点开我们的maven project。

在里面有一个left cle，这有个东西叫package，你的成判决之后，它会自动进行一个打包，打包之后这个包就可以进行运行了，大家看一下这个效果，最终你们如果写完spring boot程序之后。

你可以放到我们对应一个服务器运行，运行的时候，用我们java运行就可以了，这样可以把它给是不是这样的，包好把账号拿过来，受音pro是这包。

然后呢SEVD。

这直接java杠J，回车看过吧。

它可以直接运行的，这不能报错了。

808是不是已经被占用了，因为我这是不是已经启动好了，好，嗯一样的啊，你把它运行那个炸包也可以直接进行运行，随时开启了一个8。8的端口，好运行之后能出来，我们对应效果就这东西。

所以呢你可以在我们的idea里面运行，也可以放到我们对应的一个服务器里运行，运行方式变得非常简单了，包括我们现在官网也好，还是我们对应的视频网站也好，我们在运行项目的时候都是用spring boot。

直接打大包运行的，下载之后知道怎么部署就行了，非常简单一个小点哎。

再往再往返看一下我们对应的一个配置文件，之前我们见过各种各样的配置文件。

在我们当前这个resource，resources这个资源目录下面，你可以填写我们对应的一个配置文件，这个配置文件我要写成配置文件，其实也非常简单，刚开始的时候有个东西叫什么。

叫obligation properties，这个properties你在写的时候，它有自己的一个固定格式吧，什么格式叫K等于value，是必须这么写，这样写本身也没啥问题。

但是在spring boot里面好吧，他给我们推荐了另外一种比较好的一个方式，叫YML或YML好吧，有两种这样的一个配置文件来简化我们配置，很多同学说，老师我在用那个压缩文件进行配置的时候。

发现他有很多坑，好看的，有很多坑这个坑啊，只不过说你对这个当前配置文件，不太熟悉的原因，如果你对这个文件足够熟悉的话，这块是没有问题的好吧，而且写起来是比较简单的，懂我意思吧。

那我现在怎么做这件事情，来看一下他怎么写啊，还要他说了配置文件点，他这有一个对应的文档吗，我把文档地址拿过来，怕怕自己找不到，转过来走，转过来再告诉你说，Loading y ml。

是不是使用我们这样的一个，亚马逊的一个配置文件了，告诉你了，环境里面有DV，有production，是不是开发环境有生产环境，你这都可以进行相关的一个配置，如果你不用这种方式的话会怎么办。

用我们的properties这样的方式，properties的话就是我们的K等于value，而且我们用YM的时候，前面是不是冒号，冒号冒号是不是K冒号为这样的方式，只不过前面如果你有很多重复的好吧。

如果你有很多重复的一些数据的话，这是不用重复写了，比如这个东西叫environment，那看是不是只写一遍，所以呢这块推荐大家使这东西好，使用这样的方式，如果你觉得不太习惯，如果你觉得不太习惯。

你就还用properties，没关系，好也没关系的，这块反正都一样啊，都一样啊，配置文件嘛只是为了加载我们某些的一个属性，你只要把这些属性应用对了，这块是不会有什么问题的，懂我意思吧，这也说了两种方式。

一个叫K等于V，一个叫K冒号，然后空格value好吧。

这块注意了，一定要加我们的空格，那我们要怎么写啊，来先写一个最基本的一个配置，写什么叫server，是不是有个回车，看看这是不是可以直接等于号，比如说8080，你这样在运行的时候把它关掉啊，声音响。

你在这不行，多少号，这是我们的properties这样的一个文件来运行，是不是8080，如果不指定，默认是8080啊，你这可以改8。81，再重新运行，你这样看到这个信息，更改8081吧。

好这是其中一种配置文件的方式，与此同时，我可以在这下面再建另外一个配置文件，file叫什么，Application，点YAM是这样方式，这里面怎么写，叫server，依然有提示回车，他看到了吧。

8082看到了server冒号，然后加上我们的port冒号，加上8082，那这个时候大家想想，如果我两个配置文件都在的话，我会用哪个，可以都在吗，可以吧，来运行看看效果。

多少看这个值8081吧好吧，那你怎么办，把这个文件删掉删掉删随便删这项目改，不知道看多少，8082了吧，这是不是改过来了，所以此时你在写的时候好吧，谢谢大家，反正我个人啊，我个人喜欢用这样猫。

好像音频歌词又不喜欢那个properties，这无所谓啊，这无所谓，你这写的时候你习惯的那种风格就是风格，如果你之前用properties习惯，你就用它好，如果你用YAML习惯。

你用它这东西没有什么习特殊点，不管你用properties也好，还是用我们的ml文件也好，这块都有相关的一个提示吧，比如说three dimvc点是不是可以加很多相关的。

比如data format是不是对应对应格式，特别data source是不是可以配置，我们对应source源，这username password什么的东西都有啊，都有好吧，这一定要注意了。

所以这块属性写的时候，它会有对应的一个提示，但这块注意啊，你在写具体值的时候，如果把中间这个空格给删掉，把空格给删掉，这块是不能识别的，所以建议大家把这个空格一定要加，一定要加个空格，大家看到了。

前面的字体是不是也你是不是也改变了啊，这是变成那个橙色的了，懂我意思吧，怎么配这两个数据源这个东西啊，咱们讲数据源，咱们再说好，暂时涉及不到啊，暂时涉及不到，OK就这样一个方式加一个boss ram。

在boss上发，这只是一个简单的一个配置文件好吧，简单的一个配置文件，就大家知道这个东西怎么配就行了，只不过在我们当前这个配置文件里面好吧，它会有多种多样的一个属性吧，你根据我们的属性去加就行了。

然后这边给你列出来了，说我在使用这样的方式的时候好吧，它有什么样的对应的一个区别好吧，两种配置文件的区别，这给大家写出来了，好配置属性的一个数据，啥意思呢。

这有个东西叫configuration properties，是不是提到我们的注解了，这个东西叫at value，是干嘛的啊，这干嘛的好，是不是有功能，有什么送餐绑定SPEL，然后呢。

JS2303复杂类型的一个封装，是从网上抄了一个图，网上抄了一个图，这图里面标志说，哪个配置文件支持哪些相关的一个信息啊，哪个配置文件支持哪些相关信息，这块怎么验证啊，其实也非常简单。

我们这儿可以来写一下，写什么，刚刚的配置文件是我们直接加载的。

什么是我们spring boot里面默认的一个配置，与此同时，网易同时我这其实可以定义自己的一些配置，比如说一个person冒号换写一个name冒号，张三好吧，edge冒号12。

然后呢再写一个cs冒号冒号，再写一个男，OK再写一个，还有啥呀，多少次冒号再写一个，知道一些boss了，还有什么类型政策，已经类型都都都都用到了，还有一个list吧，比如写一个叫LEX冒号。

再写一个book，看到了，如果你现在想想写一个list怎么办，写个list的这怎么写啊，写的方式也非常简单好吧，回车后面加一个杠，加一个叫gm o v i e杠，这写一个go可以吧。

是不是写这样的方式好吧，你把这些东西定义好，当你定义好之后，我可以怎么写了，在我们当前这个包下面定一个东西，定义一个，class别了，定一个包吧，page这是一个叫entity。

里面就有一个part文件，然后呢定义好之后，里面可以写了private string name，然后private integer这写一个，然后private，String sex。

然后再往下写private list，全部都是我们对应的一个私有属性，当你这块定义完之后，还要怎么写，一样的把他的一个方法生成一下，OK同样的生成一下我们对应的一个构造方法，下面再生成一个吐司。

不搞定了，好吧，是对，这样一类，现在我想做一件事情，什么事情，我想把我当前这类的属性都加载过来，你告诉我怎么做，就说我现在这些属性是不是没有值，没有值的话，我想在这个类里面把这些属性值都给付过去。

我怎么付，你们知道吗，怎么写at value，对不对，怎么写，这写一个上面写at，value l u e这样写吧，后面写上我们对应属性值是这样写吗，要写一个person，点name，这样写吗，好吧。

这样写的太麻烦了，这样太麻烦了，你是不是每个属性都要加，如果有100个属性怎么办，好吧，刚刚同学说了，按E此生上面加一个叫at，Config c o n f i g，properties加他。

然后后面加一个前缀叫perfect，好吧，后面等于什么，是一个六，大家看一下我这是不是喜欢他了，我是喜欢他了，当我写完这个属性之后，我现在是测一下我怎么测它的啊，怎么测它，现在就能把它注注注入进来了吗。

就能把这些水拿过来了吗，你需要做测试，这里面是本身提供了一个测试的一个包，对不对，这是测试类测试里面我要定义一个东西叫PO，再写一个at ow，这里面写一个属性写啥，写一个叫SOUT，报错的。

Could not weather，do not wear吗，没啊，这少写东西，上面写个啥，At，P o r e n t s o n component，写错了吗，com啊，这对吧。

写完之后这样有问题吗，没了吧，那这块的话，我是不是可以加一个对应的一个测试了，好运行一下，看看这边打印的一个属性值往下翻注进来了吗，这写的name等于张三，等于十十二。

size等于男less等于book movie girls，是不是把对应的属性都加载进来了，也就是说这样的一个属性配置文件好吧，我除了可以加载我们spring配置属性之外。

我自己的属性是不是也可以往里面定义，是不是可以这样的方式啊，这个文件是不是比较好好，你是可以直接往里面加这个对应属性了，这东西啊你们之前应该是接触过的，或者说应该是了解过东西的，这东西啊比较简单。

但关键点在于什么呢，在于说我刚刚加了个啥呀，第一个把它设置成一个组件才能进行扫描，到了第二个呢叫configuration properties之后，我会带你们看源码的话，大家注意了。

我要看到N多个什么什么properties的相关属性，好比如这可以做一个搜索嗯，诶怎么出不来，这source，怎么重重写了，看着是不是有个东西叫data source properties，对不对。

你会看到一堆的properties这样的配置文件，好吧，这配置文件就是用来加载我们对应的这个，YM里面的一个配置属性了，通过这些属性，我能够直接把相关的一些信息加进来，所以大家发现了其实最关键的点在哪。

在于我们的注解吧，好那么问题来了，注解这块是不是要讲一下啊，有多少同学了解一下我们这个注解啊，你们之前说了，海洋老师讲课的时候讲过那个自定义注解好，先注意了，注解是对于我们的JJDK里面自带的。

它里面有四个叫圆注解好，叫圆注解的东西，好吧，我不知道你们怎么去理解它，也就是说我们在定义注解的时候，如果你打开任意一个注解，打完之后看到了是一个public，然后叫at interface。

写一个东西好，它本身包含四个对应的一个属性，这四个属性分别表示不同的意思，来我这看吧，找到我们最开始的一个主类spring bot，你往上翻有什么呢。

target retention document和inherited，这四个属性干嘛的，41干嘛呢。

你是不是要做一个分别的解释了，之前在基础班的时候，其实我讲过这些注解的相关属性，给他找一下哦，原来没觉得东西特别难啊。

那可能对这个东西不太了解，我看叫资金注解，之前讲话说什么叫注解说，annotation是java5开始引入新特征啊，中文名字叫注解就不用说了吧，他说他提供了一种安全的，类似于注释的一个机制。

用来将任何的信息和原数据，与程序元素进行一个关联，为程序的元素加上更直观更明了的一个说明，这说明信息是与程序的业务逻辑无关的，并且供指令的工具和框架进行使用，也就是说。

如果你之后自己公司里面可能要封装这些框架，当你自己在封装框架的时候，你一定要自己定义自己的一些注解吧，是不是这意思，刚才说了，ANEDUCATION是一种修饰符，现在修饰符一样可用于包类型。

各个方法方法，成员变量参数以及本地变量的一些声明语句中，java注解是附加在代码中的一些原信息，用一些工具在编译运行时进行解析和使用，起到说明和配置的一个作用，注解也不会。

不会也不能影响代码的一个实际逻辑吧，仅仅起到一个辅助作用，包含在java runotation这个包中，正常相关的一些解释，看着有什么意义好吧，最关键的是什么呢，是下面这块往上翻，说注解的作用。

第一生成文档是最常用的好吧，比如说java最开始的一个注解，常用的有at pat return，你在定义好一个方法之后，你在生成注释的时候里面是不是有些属性，第一个参数，第二个返回值都见过吧。

好看源码的时候都看过这些相关信息啊，看打开看这块是不是return是吧，这没有没有PARAMSPARAMS吗，找一个你找一个有参数的方法就看到了好吧。

有的东西这些东西啊都是我们刚才说的，要注解是不是跟踪代码的一个依赖性，实现替代配置文件的一个功能，在编译时会进行一些格式检查，如ADWORRIDE放在方法之前，如果你这个方法并不是覆盖的，超越方法之后。

则编译时就能检查出来，是不是它对应的一些作用了，这些文字性说明啊，你稍微看看就行了，你要注意注解，最根本的或者最本质的原理是什么，是反射好反射这块有人知道吗，都会吧，没有人不会反射吧，不会反射。

同学给我扣个一，有不会的吗，会的扣一不会扣二有不会的吗，没有吧，聊到反射这块，我补一个额外的知识，补一个额外的知识呃，第一次你们在接触反射的时候在哪，接触的是在我们的GDBC里面，接触的应该是GDBC。

在GDC环节的时候，第一步我们要做一件事情，叫什么叫class，然后呢点for name，后面写一个com，点mysql driver是这时候用的好吧，这时候有一个问题就是为什么啊，为什么。

因为你这样写，做完这个这个呃，根据这个字符串找到这个对应类之后，你会发现它会生成一个大写C的一个class文件，但你下面用的时候用什么叫driver manager gala。

我的jy manager是怎么知道这个类的，这里面会延伸出来另外一个机制，不知道有没有听说过叫SPI，有人知道吗，有没有听过这个东西，Spi，有人听过是吧，OK啊还是有不少同学听过的。

就你可以4double用了，OK是我们学的比较好啊，忘了基础课听过，对我基础课讲过，我基础课讲了基础课讲过这东西了，你说你要讲我讲过这东西了好吧，这块如果大家不了解的话。

你可以看一下我基础课里面的一个笔记，你从边上直接下载啊，java s e这有一个O的笔记吗，SPI呢哎没在这讲了啊，在oracle是讲的AO讲了SPI，这叫java spi。

这样机制叫service provider interface，Provide interface，好吧，是JDK内置的一种服务发现啊，服务提供发现机制，SPI是一种动态替换发现的机制，比如有接口。

小心是动态的给它添加实现，你只需要添加一个时间就搞，我们经常遇到的就是什么呢，java SQL driver好吧，其他不同的厂商针对同一接口不多，不同的实现MYSQLPOS改造的不同的实现机制。

提供用户，而java的SPI机制可以为某个接口提供服务，实现好吧，所以这块下载之后可以看看，我这边带着在那个JDK源码大家看的，所以这个文档下载之后，你可以好好了解一下啊，就产生自己实验，确实是这样的。

这为什么你加载过来的，看起来是一个MYSQL或是一个oracle的一个driver，为什么driver manager的时候在用时能找到好，这边到里面，我觉得我这个注释写的比较详细了，下周可以看看。

刚看到了很多同学对这都不了解，如果面试问到了，这就是个坑啊，现在啊在学习过程中，就是一个消除坑的一个环节，所以这块大家如果不了解，那个数据库里面我讲这东西了，我稍微提一下这个东西进去之后可以好好看看。

就被皇上说流氓那个东西也不要管他，流氓不流氓啊，不管流氓不流氓，但这东西很重要好，因为很多地方其实都用到了，SPI这样的一个实现，好希望大家能够了解他老师这个文档，大家发一下吧，可以一会我给你共享出来。

共享共享出来，这还是一样，你现在学习一下，其实就是一个查漏补缺的过程，如果这个东西你没听到过，那很明显你是要学一下了，懂我意思吧。

所以大家看到了那个基础课里面，我讲的东西还是比较多的，虽然说这个基础上其实不那么基础，不基础，没听过，图片总是找不到还是一样，你下载过来top图图片之后，你把对应那个仓库都下过来，这些所有的图片。

我都放到某一个指定目录里面了，你需要把那个路径做一个自己的修改，改成你自己本地路径就可以了，好没有设置一个统一的网上图片路径，因为有些同学网不太好，你加网网网不是特别好，所以可能现在比较慢。

我骗人我骗你啥了，我没讲的东西吗，Spi，讲了吧，你，这都不基础，我再讲一遍基础课就没意义了，再讲基础课没意义了，所以里面很多深点会大家挖的比较深，所以大家如果有基础课权限的同学。

我还是建议把这个课好好听，听的好吧，我下拉姆表达式了，stream API了，我都讲的比较多对吧，好听听，OK好了，废话少，到此为止，往下看是内置注解，在我们的那个JJK里面，他提供一些内置注解。

比如all right，好吧，呃DISPICATED，然后呢，super warning这东西你们都见过啊，之前一直在用好吧，但关键是不知道在哪儿呢，在这儿在原著解说，原著解的注意作作用是干嘛呢。

说负责注释其他注释，然而负责注解其他注解，java中定义了四个标准的一个注解，它们被用来提供对其他annotation类型的一个说明，好吧，这类型和他们所支持的类在java点乱点。

notation点这个包装有什么东西，第一个at target，target表示的是用来描述注解的使用范围，也就是说你可以看一下当前这个注解，它用在哪个地方，是类上方法上还是变量上好吧。

所以刚刚你看到一个相关信息，比如找一个点开，它点开之后往上看，这是TT告诉你说element type等于type，你点上type里面有什么，有type，有failed，有method。

有pm parameter，Constructor local web，然后呢annotation type，还有我们的package，是不是告诉你说我可以用在不同的地方对吧，type是什么意思。

叫class interface好吧，Including annotation type of annual description，是不告诉你是这样的一些相关信息啊。

比如说我这可以定义在类里面接口上面对吧，都可以进行定义，这是我们type类型，刚刚你看到了这个属性，把这个这个注解是不是就放在我们的类上面了，是不是这个spring boot mtt上面对。

他也是一个自行注解了，这是第一个点，第二个叫什么叫retention，Reaction，这个属性很重要，它表示什么是不同的一个范围，大家说reaction表示需要在什么级别保存。

该注解信息描述注解的一个生命周期，有source表示源文件，有class表示我们进化文件，还有一个叫wrong time，刚刚你看到了我们刚刚那个注意在哪，这叫run time。

表示运行时环境还依然要有它，你点开刚刚这个类，你会看到有source有class有wrong time吗，是不是三个属性值，所以你在定义自定义注解的时候，你可以自己做一个合理的选择。

我应该把这个注解让它在什么时候，或者说在什么阶段进行一个生效，全部由你自己来控制啊，一个是源码阶段，一个是卡卡子建阶段，一个是我们的整个环境的一个运行周期，你自己做一个衡量就够了，懂我意思吧，好吧。

这块的一个配置再回返，第三个叫documentation，这不用说了吧，得明白什么意思啊，是不是文档说说明应该注解被包含在java doc中，是否在java DC中展示出来，就这意思好看。

第四个叫inherit，啥意思，是不是说说明子类可以继承父类中的一个，该组件，父类子类能不能进行一个继承关系，所以刚刚你通过这个圆柱体的说明之后，你这儿能够发现什么信息，target是我们的type。

可以定在line上接口上面或者自定义注解里面，然后呢，这边是范围在运行时环境还有文档，是不是生成文档会进会进行一个呃，DOC里加，DOC里面会不会有最后一个叫是否有继承，这边有了你点开任何一个注解之后。

这都有显示1234啊，这有三个啊，这这这这这个地方是不是不是不能被继承啊，对吧，再点开第三遍，这个地方是不是12344属性吧，几乎所有的属性都一样，明白了吗，所以以后如果你需要去自定义注解的时候。

你也可以用这样的一个方式，好进行这样的一个编写，这东西容易吧，来听的同学给老师扣波一，就说你要知道这些属性是干嘛的啊，这些属性的我们这儿其实可以做测试，把做什么测试来，我来写一个啊。

大家做一个测试试试啊，呃在哪写啊，定一个吧，你们都不知道我们做一个测试啊，知道容易用，简单不难，来往下看吧，这里面我定义的时候，这主意写了，要改一下，叫at interface。

interface写完了，写完之后，上面写一个at，第一个叫什么来着，第一个叫啥就四个吧，target吧，是不是告诉你他好吧，后面写text之后，你注意你看下它类型叫element type吧。

先过来哎，哪去了，Vistation2 v，然后呢点我要写个东西，比如说写在field上面可以吧，第二个写完之后可以写一个A，啥叫r r e tension，好吧，这一样的。

它也有对应的一个类型叫reaction propose，点run run tap对吧，第三个叫at dotvt，是不是他不继承，没关系，你写完了之后可以怎么写的，比如说这定义好这个注解。

我先来定义一个类，Class test，这几个para，string name定义好吧，我再加一个叫at，my audition能加吗，那么再写一个public void，叫呵呵。

括号at这写一个my annotation，是不是效果，这是报错了，为什么报错，因为你作业是不是没包含我们method的，这怎么再怎么写，逗号element type，还报错吗，不错了，这是INFD。

是不是加一个method的，你加max之后，这还有错误吗，是不是没错误，就这么自由，很简单，所以你定义好是什么，你通过这四个圆柱也能定义好，我们对应一些相关属性，用完之后拿回来之后直接就行了。

就这个意思，虽然用起来并没有很麻烦，关键是你敢不敢用它，你现在啊，很多同学在公司里面可能用的都是别人，怎么说呢，就是现成的，特别是在一些大公司里面，用的是别人现成的封装好的框架，拿这些注意之后拿过来用。

因为有一些文档有些说明文档，如果你需要自己去开发一些项目的时候，这东西必须要用，我这是不是写的简单案例，你说什么都可以不写对吧，这个自己注意有啥用啊，我是检验是一个案例嘛，简单案例嘛。

你看一下这里面写什么东西，你这边是不是可以定义，我们对着一个属性值对吧，是不是可以定义我们对应的一个方法都有了，好想定义啥就定义啥就行了，再比如说你们在写的时候，一般写注解的时候。

比如你自行注解后面那是有个括号，这是对应的括号，括号里面应该写什么呢，写一个叫，V value v a l u e，再写一个，public string name向量属性吧。

这写完之后大家发现了是报错报错，这是什么东西，说变量name might not have been insult，没有进行一个初始化操作吧，因为一般情况下我们这是不是有个默认值是吧，这默认怎么解决。

等于一个，张三是不是写的，当你写完专栏之后，意味着我每次在使用注解的时候，我这里面有个属性叫name name的话，就可以把它复制叫张三，而一般我们在自定义注解写完之后，再给我写一个at呃，叫什么。

要不是标题这ADMOUNDATION，这可以写一个什么数据，比如说括号这写一个name等于，写一个合格，是不是想这样一个属性值，有说老师这不对啊，他好像没有这样的一个方法名称。

所以下面你要提供一个与之对应，一个公共的方法，什么方法，你在不会写的时候怎么办，你看这里面的东西啊，我们找一个方法看有没有方法，看一下，看着，拿过来，Default，这写一个值吧，张三。

代表哎这怎么没有啊，这写成string，看效果了吗，它默认情况下，默认情况下是不是我们的一个张三，这个值保证粘完之后，我是不是可以改给他改属性，你们在使用注解的时候，是不是也是改里面的属性。

这是不是就可以直接定义了，就这意思啊，就这意思好，就这样一个方式应用这块，如果大家还有疑问的话，我们差不多讲10分钟了，这就够了啊，如果大家对这块还有疑问的话，怎么办，也非常简单呃。

我在基础班的时候讲过这样一段代码。

大家看一下啊，这应该有一个叫lambda，Annotation，还有annotation的一个注解，一个一个代码下之后可以好好看看，可以好好看看好吧。

这里面讲的比较清楚，包括之前那个记录完视频可以好好看看，这东西不难啊，你下去自己搜一下也能解决掉，只不过很多同学不太喜欢写这些东西，仅此而已，懂我意思吧，好了，这个资金注解能过吗，能过同学扣一，不能过。

同学扣二，这很简单啊，你下自己自己自己练一下好吧，我不说了，我基础班讲过了，如果这块有问题的话，我把那个基础班视频拿出来，还是不知道怎么写，那我要怎么办，我让你想个需求再写一下，没必要啊，没必要。

我还是那句话，你自己封装封装框架的时候可能需要好吧，所以说不封装的话就没必要用了，你关键是什么，你要能看懂这些注解是干嘛的好，现在你能看懂这些注意就行了啊，你能看懂这些注意就行了，这是什么意思。

非常能作用在什么地方好吧，还有别的用处吗，你想想你，你你这样定义这有什么用，你是不是定义一个spring application，这个spring application，它是不是在它的基础之上。

又定义了我们的spring boot configuration，你点开它点开之后，他是不是告诉你他是一个注解对方这些属性吗，那意味着我就可以用了，点开再点开再点开，到这之后是不是到头了。

这里面定义什么东西了吗，没定义吧，是不是啥都没写，跟我刚写一样，是空的，懂我意思吧，上面有对应的解释，告诉你说这个注解是用来形成什么样的作用的，比如意义的一个实现，就这意思啊。

我不知道自己还能还能还能还能怎么点啊，还能怎么讲好，现在就自己看看，如果是有疑惑的话，我们再聊好吧，本来不太浪费时间了啊，主要还是反射，肯定是反射，我刚才说了嘛，本来就是反射。

他们想看解解析器就要看里面的源码了，好解析器就要看源码了，那这东西讲完讲讲完啊，就这样，有时间的话，我专门拿专门录一个视频好不好，有时间我专门录一个视频，我们讲一下这个解析器啊，讲一下这个解析器。

我不浪费时间了好吧，这个这个这个我没想到一个注解，你们会有这么多问题啊，真的是哎。

这应该是他自己定义的注解吧，是不是发出来了，是不是有些属性值你可以自己进行一些定义。

就这东西哇，行了，下去之后看几个案例，看应长久就行了，OK好吧，删掉了啊，别打了行了，这是我们刚刚说的那个自定义注解，这个多写多写就好，对，就是多写，你写多了就知道什么意思了，这这个一点难。

真真真的一点难度都没有，没有啥意义，还是一样，在什么应用场景里面需要怎么用就可以了，好吧，这块你也不了解很深好吧，刚看到我们刚刚加一个什么，就叫at configuration properties。

点之后来看一下吧，找到我们这一类，它加载这样一个属性，加属性之后你发现了它定义一些注解好吧，这里面读一些事情叫values叫什么东西，然后呢告诉你说string perfect是啥。

这个string perfect是啥意思，promise是不是我刚刚定义列属性的时候，是不是加了一个PROVISE前缀，如果你后面这不写名称的话，我再强调一点，如果你这不写名称好，不写名称。

有可能你是不是直接写个双引号，如果你直接双引号里面写值的话，它默认读取的是我们这个values这个方法啊，是这个values的一个方法，懂我意思吧，是value的方法，所以它会往这个value里面注入。

我们对应你需要写的一些属性值，现在也一样，定义的是不是四个推荐图的方法好吧，有默认值，有初始值，OK读完之后就搞定了好吧，它有一个解析器。

当我读取到相应的一个configuration properties的时候，我要做什么样的一个处理，读取完对应处理之后，我要做什么事情，是把我们对应这个配置文件里面的，一个相关属性值给加载进来。

加载之后，加载到我们当前这个属性的变量里面去，就两个方式解析器，如果有兴趣的话，打下来之后可以自己看一下，好可以自己看一下，同学又发了个啥。

这是不是也写的，这是不是也写，也是一个应用案例，这都是大家之前应该写项目里面的东西啊。

写项目里的东西，OK所以这注意这个配置就行了，如果你没有加这样的一个属性配置的话，如果你用的是那个proper配置文件的话，你要怎么办，是不是必须要写一个东西，ADD values再写一下，再写一下吧。

value写完at value之后，这是不是也是一个注解，我是不是可以点开这个注解，你看到里面有什么，是不是有个value，那我写的时候该怎么写了，括号里面写了一个字符串，什么类型叫person。

点name吧，然后再写括号at，Value，再写一个冒号叫person点，然后写一个GEY的大写，是不是写两个，写完之后，我们来测一下吧，来运行一下，把这个注释注注注了，周周来打开。

我们刚刚看到这个测试文件，右击走，报错了，报错之后，你往上翻什么东西，他说，Integer，String require，Integer，写错了吗，没写错吧，这写的没，这没写上吗，找一下啊。

我们这写的是啥，不12吗，这不读读读进来了吗，这为啥不行啊，他说不能解决我们的依赖，通过我们的field吧，这写的是啥哦，这应该加东西啊，这样行吗，忘怎么写了，来看一下，看看属性值降下来了吗。

是不是张32都有了吧，是都有了，有了之后后面两只是空，没赋值吗，没本事变成空了，所以大家想一下，如果你的属性比较多的话，你如果用value的方式的话，你是不是每个属性都要往这边写，太麻烦了。

而如果你上面用完这个配置属性之后，你可以直接进行一个完全的一个加载，好，完全的一加载就这意思啊，所以这块并不是特别难啊，特别特别难，你注意有这样的一个属性值，你知道如何加载就够了。

好这是我们这样一个属性的配置，这我这也列出来了，说两种配置属性有什么样的一个区别，第一个叫ADD configuration properties，说批量注入配置文件中的一个属性。

ADD value是一个至今指定，还有一个叫松散绑定，这个松散绑定是什么意思啊。

所以绑定也非常好理解，这来举一个例子，比如说我在写这样的东西叫name，这写一个叫last下划线内，其他其他之后我在定义名称的时候该不要了，先把注注起来，这第一个名称叫，Name。

那把下面这些属性值都改一下，我C，就默认包含了一个就跟同学说的，下划线和中划线的一个转换，我来重新算一下，把这个属性给放开，怎么报错了，不支持吗，诶那是name set，写错了，改了吧，我哦没改。

get last time set l大写，所以同样标识一定要注意了啊，get大写走，还不行吗，Last name，你写错了，有个boss吧，哈哈这改的比较麻烦吧，这样把他干掉，不要看着我，罗马不要了。

干掉那下面这个四零开方法也干掉，写完之后再重新生成一下，CDT都要下面也是一样的，加一个TOSJ，现在没问题了，看着吧，这是读进来了，是不能把这个值读进来对吧，这是通关绑定的意思。

而如果你写一个value的话，这边是不能够进行识别的。

是它们之间的区别，好给大家演示这样的情况，再来看看什么叫SPE，L是一个表达式的一个支持和表达式，也是现在不支持的，而JS23031个数据校验，就是说我这加入之后，我会进行一些校验规则。

比如说邮箱验证对啊，邮箱是不是验证符合我们对应的规则。

那这块你可以加这样的一个属性值，比如说我这没写邮箱，我给他写邮箱之后，你上面可以加一个属性值或者加一下试试，大家可以看看at，看这块了吧，我加s email之后，这个格式必须要符合我们的email格式。

如果不符合的话，这就会报一个错误来试一下吧，再验证一下，但是这些属性不对应啊，你可以看一下对应效果就行了，稍微报个错误，没报错吗，少了一个东西，大家看一下，我再加一个email之后，这个属性是没起作用。

没起作用，为什么没起作用，为什么没起作用啊，啊为什么起作用，对这少了一个对应的一个组件at，呃value这个不行，所以大家看到了这些组件啊，几乎用的时候都是配对来进行一个使用的，是来进行使用的。

搞错了吧，往下翻，这应该有一个中文提示吧，诶你中文提示呢，看过了看着他说，这是不是一个合法的电子邮件地址吧，是不是告诉你这有提示对吧，所以就说这里面可以用一个自己的交易规则，原来是我们在前端那块。

如果你JS写的比较好的话，JS是不是可以做一个验证，只不过它把它截成到后端里面了，写了一个框架啊，写了一个那个注解，通过我们的注解来进行这样验证，就这样的方式啊，你就是你知道就行了，你知道就行了。

有这样的方式，你知道就行了，这东西都是很小的一些细节点，对于一些初学者，这可能比较重要好吧，所以你在工作中这东西也也用的不多，因为一般校验的时候我们都会放到前端，都放前端，后端这块我们其实很少做验证。

但你要知道它提供这样一个规则方式。

最后一个什么呢，叫复杂类型的一个封装，一个是支持。

系列 5：P59：59、配置文件位置的优先级 - 马士兵学堂 - BV1E34y1w773

打开了解就行了，OK再来看还有什么呢，叫配置文件的一个优先级，也就是说当我们在写完我们的配置文件之后，配置文件之后，其实我N多个目录都可以放我们的配置文件，这个没配置文件怎么放啊，来往上看。

前后的作表演一般没必要啊，一般没必要，前端只要做好，做好调研之后，后端一般没必要，一般你的规则都是一模一样的好吧，除非你的一些接口文档说明的不太清楚的话，可能都需要懂吧。

然后再看我这写出来四个对应的一个，配置文件目录，这四个配置文件的目录不是我这随便写的，是官网里面给我们展出来的，官网里面有这样一个展示目录，我再找一下，嗯找一下官网里面给出我们这样一个配置，文件路径。

就是说你在指定我们的YM文件的时候好吧，它可以有多个路径进行配置，在多个文件路径配置的时候，你可以都都都写，没关系，但它有一个优先级的概念，也就是说你配的时候不能说我随便瞎配，这不合适哪儿去了。

又没了算了不找了。

找一下不找了，大家看一下，我这已经给他写好了，我们从这图上看吧。

就说在这块它有四个配置文件的一个路径好吧，前两天这样配置文件的路径路径里面有什么呢，叫file冒号，然后呢叫点杠CONFIG杠，还有一个file封号，什么叫点杠，还有class pass。

Configure，class pass杠，大家看一下。

我刚刚写好的这个配置文件，它是在哪个对应的一个目录啊，刚配件放哪了，是放到我们这个result里面了，result下面是不是相当于是我们的class pass，这样一个资源路径，那我可以怎么做。

来往上看，这做一个验证啊，把这些属性都给干掉，不要都删掉了是吧，删完之后来做一下验证试一下吧。

在这块写的时候，第一个第一个是在哪来着，刚刚写的这是不是有一个CONFIG。

下面fail指的是我们当前这个文件的路径，这样可以创建一个directory叫CONFIG，我这里面我可以建一个配置文件叫application，点YAM写完之后，这可以写一个server冒号TT括号。

再写一个808080818081。

这第一个我们要定义一个配置文件路径，第二个是什么呢。

叫file杠，然后在这个当前目录下面，我们也可以建一个文件叫application，第2ATION点YAML这边写一个server冒号，冒号，再写一个80821样的。

在我们这个src class pass resource下面，在这下面里面依然可以接一个CONFIG吧，这写一个右击定一个directory config，在CONFIG里面也可以写一个fail。

叫application，点y a m server冒号port符号8083，然后最下面是不是，这里面再定义一个叫8084，可以吧，当你这四个端口都定义好之后，我现在重启我们当前应用程序，把它关掉。

不要搜选择应用程序来右击走，晕一下，看一下，现在可以越过去，我来看这个端口多少8081吧，是80818081的话，大家看到哪个地方配的8081来着，是不是这里面写的是8081。

可能意味着我们的CONFIG，这个的优先级是比较高的，优先级是比较高的，然后这时候你把它给删掉，别掉，上完之后，第二个是谁，是我们在外面也配了一个YML新启动运行。

多少8082了吧，他是不是也比较高，右击再把它删掉，走上完之后来再看，再次运行走，808383在哪，是不是在我们这个CONFIG里面是8083，把这东西也删掉，delete看看再运行走。

现在是不是应该变成8084了，对不对，大家看到了，我们刚刚通过这个端口号的演示，已经看到了它所对应的一个配置文件的优先级，所以你在指定的时候，你要做一个查看好吧，也就是说在这四个资源路径下面。

你都可以配置我们的demo配置文件，问题是哪个优先级更高，哪个优先级更低，但一般情况下我们推荐好吧，大家放到这里面好吧，这边的话如果你的配置文件比较多，你可以放到CONFIG里面去，它原先就会变高。

如果配置文件不太多的话，就直接扔到外面好吧，直接写到一个配置文件里去去就够了，所以这是我们对应文件的优先级，好吧，这块有问题吗，来文理同学扣个一，很简单吧，好像这些东西啊，在我们的官方网站里面。

都是有对应的一个配置的，这东西并不是特别麻烦好并不是特别麻烦，OK这样搞完之后再来看初始属性，不用说了吧，表达式表达式是什么意思啊。

这表达式是什么意思，比如说我在写的时候，刚刚写的是什么，是具体的一个值吧，找一下这块再说写它，我只能写这个值，一加哎，1+2能这样写吗，这个值能不能这样写，来我们试试就知道了，你打开刚刚那个测试类。

走啊，拿错了，呃不是这样啊，不是这样写，这写错了，不不不，这两项不是这里面写，写好这个值，而在我们外层这写的时候可以这么写啊，12找到我们的person这个类分类里面，我这可怎么写啊。

就说我这应该怎么使用我们对应的一个表达式，这样一个注释方式，假如说你们用这样的方式，不要用，它，不是自动输入这块写的时候就用它，这可以写一个1+2，我来再运行一下，哪去了这个，嗯还报错吗，什么意思啊。

哦H是把它给注掉了，好吧，这已经注定了我inject，COSVALUE诶，不是这么写的吗，是这么写的吧，井号吗，写清楚了，大家试一下吧，好吧，现在是好了，就用符号，你这是写成减号就可以了。

在这里面也可以用，我们对一个表达式这样的方式，但一般没人把它写成表达式好。

他只不过是不支持了这样一个简单用法，仅此而已，好吧，教练刚刚说过了，我都说了，最后一个叫多环境的一个配置，这个多环境配置是什么意思啊，也就是说在我们的生产环境里面好吧，在我们的那个开发环境。

在我们的实际工作环境里面。

你可能会有开发环境对吧，可能会有测试环境，可能会有生产环境，是不是更大的环境，这时候怎么办呢，啊这个怎么办，也非常简单，在当前当前这个resource目录下面，你可以创建N多个我们对应的一个配置文件。

这个问题是你要怎么建，右击念一个fail，这写一个application，写什么叫杠，比如说DEV点YAM，这写一个server冒号port，再写一个8080是吧。

然后再写一个new一个file application gu test，点YAM，这是一个server port，201是不是两个测试环境了，在这里面我可以指定这样的一个属性，这不它叫什么spring。

哎不对，这active诶叫什么来着，我忘了叫什么了，Spring profile active，对他好吧，这样可以指定我们对应属性，比如说DEV定位是多少啊，我来看是8080，现在我们重新启动一下。

我们对应用程序走，看来测试啊，8080吧，现在我把这些属性值给做一个更改，这改成哪去了，这，test来再重新运行。

多少了，8081吧，也就是说你在生产环境里面，你可以配置多套我们不同的配置文件，然后呢在做切换的时候，上线的时候换成我们DEV好吧，自己练呃，开发的时候换成第一杯，测试的时候换成test。

是多种不同配置，把这配置文件的作用，当然你也可以把它切换成properties，都一样的，一模一样东西好，所以大家发现了这样ml文件啊，其实里面做的事情很多啊，推荐我推荐大家使用这样的方式。

因为spring里面也是这么推荐的，当然你说老师我用的文件用的确实非常麻烦，我就不喜欢用它，那也没关系啊，你就用你的properties都是一样的，这些属性值有直播间里面换成什么呢。

冒号冒号这样的方式的，而其他地方你用properties的话，换成是K等于value展示方式，所以合理选择就够了，懂我意思吧，好吧，在下去之后，可以把我们spring官网里面。

关于我们的压缩文件的一个配置，这块好好详细看一看，里面竟然包含很多的一个知识点，这样我们再不再详细详细说了啊，这东西啊其实不那么重要，或者说这个东西不需要我来讲，你看官网有能力啊，把它给学会。

懂我意思吧，好了，这块来文文同学扣波一，问题啊，今天的东西算是比较基础的呃，我们基础课大概讲个三节课左右吧，三节课左右，简单带你们过一下这个知识点就够了，好就够了，下节课我们讲web相关的一个开发。

然后之后我们就主要看底层的一些，源码的讲解了，懂我意思吧，所以很多同学可能觉得这东西比较基础，比较简单哇，那你可以选择暂时不听好吧，后面的话我们会先暂时讲了，懂我意思吧行了，今天晚上咱们就不吐槽了。

大概就聊这么多呃，该过平安夜的过平安夜，该过圣诞节的过圣诞节好吧，希望你们今天晚上玩的开心，还是周二周四周日是的，周二周四周日，平安夜不平安，牧马人太太调皮了，呃，希望你们今天晚上玩的开心吧。

OK那今天咱们就聊这么多，刚刚的话就是把刚才承诺给大家发资料，一会整理一下发上去，好吧好了，同学们早点休息，拜拜同学们拜拜，试讲咱们中间插一下，这东西增删改查有必要写吗，到时候再说吧好吧。

下节课我们再说，OK好了，下课了，还book htbook。

系列 5：P6：6、GC的演化过程 - 马士兵学堂 - BV1E34y1w773

好我们先把这个故事讲清楚，随着内存大小的不断增长而演进，我们大概明白了什么叫做分类算法，对不对，好在明白了大概明白了什么叫分代算法之后啊，我们来看看这个图，先先不不跟你讲了，这图要讲起来就没完了。

好看这里你不要讲这一节课，把所有细节全掌握啊，大哥我这讲了好几十个小时的课，你非让我一节课讲完，那也不可能的，好看这里啊呃从内存特别小的时候，内存很小啊，这这java刚诞生的时候，那会内存特别小。

大概就几兆到几十兆，就就就这么少啊，我记得那会儿八兆八兆内存是吧，呃几兆到几十兆内存，Shit，好，几兆到几十兆嗯，这样一个内存这个内存啊，他的那个采用的垃圾回收器呢就叫做serial，Serial。

特别简单，我给你说你就明白了，你看这里根据jvm java虚拟机规范的定义，serial是什么呢，叫做stop the world carbon collector with uses single dies read。

是读一下来叫做stop the world，Stop the world，世界停止，这个词呢叫STWSTW这个很重要，你记住这个词以后，就说STW不要跟人说世界停止，或者说什么什么什么什么乱七八糟的。

不要不要这么说，就直接说SW专业，显得你特别专业，Ok copy collector with uses a single desist js read，使用了一个单线程的GC，GC线程形象一点。

形象一点是江子弟，江子弟，你们哥仨，你你女朋友，你男朋友好，在里边扔线团，扔到一定程度，满了满了怎么办，好，这哥们是工作在年轻代的，满了满了咋办，很简单，你慢慢进来了。

哪里拿着一根扫帚来了之后的第一件事，你们仨给我停，Stop the world，业务线程全给我停止，停到我了，你们仨给我停住，不许再动了，不管你是什么什么姿势，什么什么动作不许再动了。

因为我要清理垃圾了，接下来你妈妈就顺着你们仨捋捋捋捋，捋到的这些全都不是垃圾，把那些垃圾全都清清除掉，清完了之后说你们仨继续go on，等你们仨又玩了一段时间又满了，怎么办，你慢慢又进来听stop。

然后等他清完，你们仨继续听懂这意思了吗，就一个线程给这就叫STW叫stop the world，进来给我停止，停止之后，垃圾回收器干活，由于他工作的年轻代，所以它叫做拷贝。

collector使用了单线程，一个线程就够了，为什么一个线程就够了呀，为什么有些人就够了，很简单嘛，因为内存少啊，空间特别小，年轻代是这样的，老年代也是这样的，老年代也是单线程。

等年轻代回收了很长时间，老年代占满了，产生负利息的时候怎么办，也是单线程，你妈妈又进来了，他这时候老年代的叫做。

Stop the world maxwell compared collection that uses a single dies thread，依然是单线程，只不过他这时候是工作的老年代。

因此它的算法是标记清楚或者标记压缩，或者标记清除完了之后，碎片化过于严重了，怎么办，进行压缩可以了吗，同学们很简单吧，来可以继续的扣一，这就是serial的算法，OK所以这张图啊。

我们翻过头来再看图去哪了，你看我一下就把这哥俩给讲了，好，这是常用的组合，那么下面我觉得我都不用怎么讲，你就明白了，下面叫什么叫PARALLEGAVAGE，这句话是什么意思呢，就是当你的内存越来越大了。

同学们内存越来越大，几十兆到上百兆，甚至到一个G的时候，这个没有一定之规啊，就是他跟你的业务是有关联的，什么时候你觉得业务不好玩不好使了，我告诉你，你这个时候就得考虑所谓的调优，第一步换垃圾回收器。

这种垃圾回收器不好使了，同学们，你们想想为什么内存变大，单线程就不好使了，很简单嘛，你原来啊你们家三平米，你妈妈一个人蹭蹭蹭两秒钟就扫过来了，没关系，停两秒没关系的，很多这种业务啊，暂停两秒钟。

卡顿两秒钟，没关系的，可以接受，或者几10ms就扫过来了，没关系啊，可以接受啊，没有问题，所以在这种情况下，你单线程就完全没问题，但是你们家现在变大了，你们家现在是100个平方，100个平方。

你妈妈一个人要清理过来，清理一次性清理100个平方，要清理多长时间，太长了，半小时，妈呀有没有人能够忍受半小时你的程序不动，你们现在正在进行双11秒杀，用户下单之后，突然间半小时不动，你的服务器没响应。

为什么没想要，因为你们哥仨是不是都在那STW，都在那蹲墙角呢，听懂了吗，所以这时候单线程不够不好使了，拿大腿想想优先采用的解决方案是个啥呀，同学们，多线程吗，parallel哦，这种叫parallel。

叫并行，多线程好并行，多线程工作在年轻代叫做parallel scavenge，工作在老年代叫parallel old，如果用图来画的话，就是最开始是你们哥，你们你们哥仨在这里工作。

突然间满了满了怎么办，你骂骂你爸爸，你姥姥，你姥爷一块进来，你们仨给我停，然后他们四个一块干活，迅速的帮你清理掉整个的垃圾来，你们仨继续周而复始好，这就是serial和serial old。

parallel scavenge和parallel old，它的玩法，讲错误了吧，哪里哪里错了，你说出来，是panel，No，你错了，损伤胆，Parallegivenge，Parallel old。

这哥俩的组合，这是经常用的简称，PS加PO，傻妞，我还没讲呢，着啥急，我告诉你你你们你们生产环境里头啊，我告诉你1。8，如果你们生产环境用的1。8，你没有换过任何垃圾回收器的时候，恭喜你。

你的默认垃圾回收器就是这哥俩，请你给我记住它，它叫做PS加PO叫parallegpa ode，还有同学可能会说，老师我怎么知道我用的是哪种垃圾回收器呢，严格讲这是明天我要讲的内容。

但是今天呢既然你们问到了，就稍微给你们说两句，可以说两句吗，对于java来说，你只要敲一个指令就可以，什么情况。

嗯java装xx。

print common command line flag回车，当然带一带带一程序或者带个version吧，好这里呢他会把呃你java虚拟机启动的时候，默认的那些个参数全给你列出来。

注意看这里面有个参数是什么，叫做use pologic，看到了吗，来看一眼，这是你java启动的时候默认带的参数叫做什么，叫做use parallel gc，哎那有同学可能会说。

老师这个use parallegc到底是个什么东东呢，放心像老师这么体贴的难言，肯定给你做了笔记了是吧，好use parallel DC是个什么东东，类，你找找看找找看，我记在哪了哈。

Here，这个use parallel DC呢指的是OK，就是parallel scavenge和parallel old的组合好了，你可以继续了吗，可以继续，老师扣一来老师这个笔记在哪呢。

我今天稍微给大家调整调整，好到现在为止你们听起来应该相对比较轻松吧，也不太难吧，因为你先建立比较轻松的整体性的树干，我们再去追究那些树叶子，还那时候你就轻松好多，PPT给不不给好，我刚才讲了两种组合了。

第一种是serial的组合，第二种是PALA的组合，调优的话呢，我明天给大家讲讲这块怎么调优，因为JDK1。8，只要你没改过，就是这哥俩好吧好，我们继续随着空间越来越大，现在不是几十兆上百兆1G吗。

现在空间变得更大了，现在是1G或者几十到到什么呢，到几10G，数10G好，我告诉你啊，到数10G的时候，你会发现，无论你怎么玩，你采用多少个人来啊，你说我采用我调一个团的人，来来帮我parallel吗。

原来原来只有一个，后来我把它变成N个多个，四五个四五个不够使了，我来我来四五百个行不行，我来1万个行不行，这里面就牵扯到一个操作系统的最基本的概念，就是线程是不是越多，它的效率就越高，是不是线程阅读。

效率会线性提高，是这样的吗，不一定明确说县城到达某一个阈值之后，它的效率反而会降低，原因是什么呀，原因又回到了这张图，刚才我看最开始我讲这张图的时候，老师就就就就就同学们，不是说老老有这张图没错。

原因就回到又回到这张图，为什么，因为一颗CPU的核或者一核的CPU，同一时刻只能执行一个线程，假如我们有16核，最多在同一时刻能执行16个线程同时执行，哪怕你使用线程撕裂者啊，最多也就是说四核八线程。

八核六线程，总而言之它是有数的，就算是你16个线程同时在运行，那么你这个时候派了1万个线程过来，你猜猜看会发生什么，会发生排队和切换，什么意思呢，就是我这1万个线程，我每一个都要让他有执行机会。

我怎么办呢，我就执行，你一会执行他一会执行，你一会执行，他一会儿在执行你的过程中把你拿走，把它拿进来好，这个过程叫做线程的切换，线程切换本身也是需要消耗CPU资源的，如果线程数量特别多的时候。

上下文的切换，Context switch，这是它的专业名词，好线程切换的所占的资源，就超过了线程本身运行所占的资源，所以CPU会把大量的时间用在线程切换上，它的效率反而会降低，不知道我说清楚没有。

一个厕所只有八个吨位，最多有八个人往里蹲，在里头蹲着，后来来了8万人，你猜怎么着怎么办，CPU就把这8万人排好队来，把你拎进去，蹲十十个毫秒，把你拎出来换另外一个，注意你们哥几个排队协调这个资源。

CPU也得管着，所以CPU会把大量的精力浪费在这个上面，因此不是人数越多越好，所以在在你到达一定阈值的时候，到达啊，好几十个G的时候，我告诉你你再增加多少个线程，没有效率，提升不上去了，这时候怎么办啊。

这时候就诞生了惊天地泣鬼神的，concurrent的玩法，concurrent垃圾回收，刚才这声音有点太君的味道，抬抬抬你个头啊，说太君吗，是佘赛花吗，好这个叫做CONCURRENDC，我告诉你。

垃圾回收器里面有哪些是concurrent c呢，here著名的承前启后，继往开来，历史青史有名的CMS concurrent Mark sweep，以及和他配合的朋友好继续。

替代CMS的g one后面的z dz，后面的SHINDOOR，这些所有的后面所产生的全都是concurrent，好我们先来说明什么叫concurrent，那到底什么叫concurrent呢。

concurrent的意思是是这个here，CONCURREN的意思是这个concurrent，意思是说当我垃圾回收器干活的时候，你的业务线程可以继续，what这叫cover的，知道吧并发。

所以所谓的并罚，指的是GC线程和垃圾回收线程啊，Sorry，GC线程和垃圾回收是一个GC线程和业务线程，我主要有没有看你们认真听讲，GC线程和业务线程可以同时在运行，原来都啥样，原来是GC1运行。

业务线程就得给我STW都得给我停住，Stop the world，现在不需要了，现在没关系啊，咱家特别大，已经变成500个平方一栋别墅，你们姐儿仨在里边玩儿，随便玩儿，你们的你们在旁边玩着啊。

我们我们这个妈妈爸爸爷爷奶奶姥姥姥爷，作为摄像师哦，Sorry，作为垃圾回收者，就在旁边捡你们玩出来的这些垃圾啊，你们别玩，我们边边捡垃圾，边玩边捡垃圾，你们随便扔了，那这时候就会产生一种什么现象。

这时候产生的现象就是，我的应用程序永远有响应，为什么，因为我业务线程在这里跑着呢，我当然有响应了，所以这是concurrent的本质，不知道我说清楚没有，来能get到这一点的同学老师扣一嗯。

当然这里面就会产生各种各样特别麻烦的问题，同学们，你们想想看，我我我往这边一边扔垃圾，你这边一边捡，万一我扔一会儿你呢扫描完这个对象说啊，这个对象是个垃圾，但是万一我一会儿又把它给捡回去了呢，对吧。

他又不是垃圾了呢，你把它清掉不就完蛋完蛋了吗，而且最重要的还有还有一个叫做万一，我比如说我我我我我我我本来啊这个对象呢，你扫描它不是垃圾，但是我玩着玩着，我已经把他的连线给它剪断了，它又变成垃圾了呢。

你又怎么处理，就给标错了，所以就会产生各种各样的问题，是不是啊，同学们好，这是concurrent，我们先来介绍concurrent的这种呃，开天地，开天辟地的第一个啊，就concurrent的呃呃。

Sorry，调出来can cover，里面呢开天辟地的第一个，开天辟地的第一个是什么呢，第一个垃圾回收器是什么呢，就是我们著名的cm，CMS全称叫做concurrent Mark sweep。

叫并发的标记清除，好它主要有四个阶段构成，我们一块来解释，注意这个cm是工作在哪个年代的，OK仔细看cm工作那年代呢，他工作在老年代，那么和CMS对应的工作，在年轻代的应该用什么垃圾回收呢。

你可以用serial，也可以用PU，它不能用parallel scavenge，好，我先来再进一步解释cm之前，我来解释什么叫PU，凡是在这里虚虚的线，注意啊，虚虚的都是可以互相配合的。

但是最常用的配合就三种，serial palace cavenge以及panel，加上cm就这三种，其他的你不要跟他想来想去的，就这三种，不用不用不用不用多想，好好听我讲这个盘六是什么东西呢。

can new的意思和palace cavenge是一模一样的，卡尼就是工作在年轻一代的多线程垃圾回收器，那有同学说了，他为什么不用parallel scavenge呢，原因是什么。

原因是我们来看判定的定义，你就知道了，这是判定在oracle官方文档里的定义，他说盘妞是什么，他说他是一个rap word copy collector，Which uses multiple re。

来读一下，Is dal world gbcollector，Which uses multiple js threats，I drop the wild，Gin the way。

Using multibes with thread，Okay，阿三口音，他说it defers from palace。

Garbage in that it has enhancements that makes usable with cms，这是它的本质，他说他和TELECAVENGE的本质的区别是什么。

它有一些增强enhancements，让他能够和cm更好的配合使用，所以它就是PARALLADIVA，只不过专门和cm做配合使用的，特殊的parallel就行了，Ok，好我们可以继续了吗。

所以到现在为止，当我们看这张图的时候，我觉得你们能看个大概了，你发现没有，这张图大概就已经产生了，然后你就会发现原来这是单线程，这是多线程，这个是特殊的多线程，它配和cm1块用，所以到现在为止。

作为分类模型，起码你掌握了一个两个三个四个五个好，下面我讲这里面最难掌握的CMS，准备好开准备好开始我们新的征程了吗，老师为什么P1开始不配合，gm要出判定，因为最开始的PS是和PO的配合使用的CMS。

后来诞生之后，发现原来设计的这些不符合他的要求，很难理解吗，啊听我说，cm作为整个concurrent这样的垃圾回收器，开天辟地的第一个秦始皇，他有天生的bug，但是呢你如果不从他开始学。

你就理解不了后面的g one，理解不了后面的z DC，理解不了后面的SHENDER就OK好，所以我们先要了解了解cm效仿go浪，你疯了吧，闪电你说你非得说啊，马克思是效仿闪电的，你不扯淡吗。

人家马克思先诞生，你闪电后诞生啊，虽然你早晚要去见他，我们马家门的名人马克思同学，但是你不能这么说，不能说他效仿你，你只能说你效仿他go on，效仿java好看，这里cm它是这么来玩的。

它的原理呢也非常简单，虽然说从最底层角度讲，它由六个阶段构成，但是你跟面试官聊，基本聊够聊，聊通这四个阶段就可以了，这四个阶段分别是什么呢，分别叫初始标记，并发标记，重新标记，并发清理，1。1点来讲。

它很容易理解，这里面最难理解的是这个阶段，这个阶段就是著名的三色标记算法，今天看时间吧好不好，现在已经十点了，看这里，呃这是，它的四个阶段，四阶段是什么呢，初始标记，初始标记的意思非常简单。

就是找到根儿上的对象，找到那些root对象，大家知道我们垃圾回收过程就是从根上开始找，先把这根上对象找到，这部分叫初始标记，注意它依然是STW的，但是他STW时间会非常短，为什么。

原来的STW时间是要你把所有工作全干完，所以他时间非常长，现在这个S加时间，你只要找到根上就可以跟上对象，毕竟没那么多，所以这个SW时间特别短，一般来说没有多长，所以没有关系，接下来就是最重要的阶段。

这个阶段是什么，这个阶段是我们的业务线程继续，不管你有多少个业务线程，几十个，或者你们哥仨，你们几13随便玩，你们在那玩的时候，我垃圾回收器就在工作了，垃圾回收器开始工作，我就开始找哪些是垃圾。

哪些是垃圾，哪些是垃圾，那是垃圾，你一边玩着一边听着，我一边标记着啊，不能叫，一边听着一边标记着，这个是垃圾，这是垃圾，这是垃圾，这个不是垃圾，全给你标出来，等我标好了之后，注意他一定会产生错标。

坐标主要有两种情况，第一种情况是好好听我讲，原来这哥们是个垃圾，原来这哥们是个垃圾，但是运行过程之中呢又有一个引用指向到了，OK他就变成不是垃圾了，这种的你后面不能把它给清掉，你得把它修正过来。

还有的呢，原来这哥们儿不是垃圾，有人有引用指向的，运行过程中呢，引用没有了，它又变它就变成垃圾了，好这是两种经常见的情况，这块大家能呃听得懂吗，这块是最难的内容了。

concurrent里面就是cm里面最难的内容，能能get到吗，嗯讲错了吧，宋海强一定是你错了，你放心，我不会错，凡是怀疑老师错了的，你们都错了，引用没了，怎么又会引诱回来，我一会讲给你听。

那个叫做先引用了，然后我们的垃圾回收器以为引用没了，三色标记，我一会儿讲给你听好吗，引用没了也能引用回来，我告诉你，虽然情况比较特殊，但是完全可以，比如说缓存你命中了，然后你那些没命中的，你要清掉了。

突然之间他又来了一个命中了，比如说你重写了finalize方法，原来死了对象，你就给他复活了，放心啊，我这没错，我这没bug，成员的bug就像自己的内裤不会展示给别人的，放心，总而言之会发生两种情况。

就这两种这两种情况最终都要进行修正好，这个修正过程要重新标记，修正过程不能让原线程继续，业务线程再继续的话，那你不断的新错误在产生了肯定不行，所以从整个的cm角度，一共有两个阶段是TW的。

一个是初始标记，一个是重新标记，毕竟出错的不会特别多，所以重新标记的这个STW时间也不会特别长，好最后呢我标完了，确确定标清楚了，这就这哥几个是垃圾，那哥几个不是垃圾，好累，并发清理，清理完了之后。

下一步好，这是大体的过程，这里面有很多细节，最差的最多的细节就在这，叫做三色标记算法，著名的三色标记算法go on采用什么算法，go on知道吗，三色标记，那小点点问SW了，怎么能出错。

大哥你看看这是SW吗，我说的是出错，是在这出的，嗯三色标记go on也是啊，所以你不要说那个java超go on，别扯好了，下面我连我，我详细给大家讲这个问题可以吗，讲这个有点难，今天我告诉你。

我讲完三色标记就没有时间讲g one，就没有时间给你们讲g one，Cdc shandollar excellent，你是想听这个还是想听三色标记，你们自己挑。

系列 5：P60：60、SpringBoot基础回顾 - 马士兵学堂 - BV1E34y1w773

此时源码黄师傅讲过了，如果你们觉得还是听得不太特别清楚的话，到时候我在基础班的时候要不要重新讲一遍，重新讲一遍这东西好了，今天呢我们接下来讲我们spring boot，相关的一些知识点。

然后上节课讲完之后呢，我们讲的都是些基础的配置和应用层面的东西，很多学生说老师那个我刚学这东西，然后呢可能学的不是特别清楚，你能不能帮我写一份笔记，所以这边呢给大家准备了一些笔记，给大家放在这个地方了。

我在看到有很多markdown文档，好吧，很多东西都已经写好了，所以一会儿下课之后，我会把这个笔记给大家分享出来，以后看笔记就够了，OK我们先来对上节课的一个知识，做一个回顾好吧。

而MYSQL基础家调小课啥时候出呃，正在剪，正在剪那个视频要剪辑啊，咱们那个视频网站，大概在1月1号的时候会上线啊，一号会上线，你会看到就是一个全新的一个视频网站啊，现在还没做好，现在还没做完。

还差两天时间，做完之后，你们从从那个视频网站上就能看对应小课了，好吧好了，我们先来回顾一下上节课大概讲点什么东西，其实讲东西啊也比较简单好吧，就是spring的一个spring boot的一个基本入门。

然后加上一些相关的一个配置配置文件，这一块，很多同学啊可能之前没学过那个SSM哦，SM所以导致说老师这个spring spring boot配置啊，我不太清楚不太清楚也没关系。

这边呢给大家整理了一个文档，好给大家整理一个文档，文档里面讲的就是spring boot配置相关的东西，就是我们配置的时候，在之前的时候可能大家更青睐于用XML文档好，XMLXML文件在进行配置的时候。

每一个框架还有自己配置文件的格式，而现在到spring boot之后，你只需要配置到我们单独的spring boot的配置文件里，就可以了，那个配置文件，它支持第一个properties这样一个形式。

好，properties这样一个文件格式就是K，然后写一个等于V这样的格式，第二个可以支持什么叫YAM2好，YM或者说YML都行好吧，这是这样的一个配置文件，然后这边给大家想写了一些比较详细的配置。

比如说如果我要用properties的话，我应该怎么做配置，OK然后呢创建实例对象应该怎么进行一个引入，引入的时候也是一样，可以通过我们的ADD value来进行引入，这比较基础了或者比较简单好吧。

之前你们在学spring的时候，大家都都都是这么配的，SPMC的时候都是这么配的好吧，第二个，这有一些测试类的一个测试，下面还说了，除此之外，在我们的propose文件里面。

还可以引用相关的一些随机数的一些类，这东西啊，上节课我是没讲的好吧，这东西到哪哪来的，也是从官网里面直接拿过来的，东西还是一样，不废话，我直接带你们看官方网站里面包含的东西，这是英文的，是中文的。

给大家找到中文网站网站，你们从中文上直接看就行了啊，很多同学说老师我找不到这个中文网站，我给大家发一下，我给大家发一下，你把这东西好好看看好吧，里面有一块是专门针对我们的YM2的，我找一下，这太多了啊。

看这块他说了，使用亚马来代替我们这样的一个文件属性，里面告诉你说他是一个什么叫K，然后呢冒号V它是一个分格式的一个形式，写的下面有各种各样转换的一个形式，比如说多profile ymar的一个文档。

然后呢后面还包含我们对应一些缺点，然后按全属性的一个配置，以及后面说可以使用一些随机变量，找一下刚写代码就从官网里面粘的松三绑定，这就没有了，随机数呢，哎我的随机数呢没有了，没有了吗，找不到了。

你下去自己找一下吧，反正就是在关关于我们这个随机数，这有一个配置，这个配置哪去了，反正就是从官网里面粘出来的那个代码，都是从官网里面一模一样的代码，然后呢我只能帮你在项目里面写了一下。

然后把配置文件给追上了，大家看到了可以怎么写呢，用dollar符号加一个大括号，写个random value，Random int random lag，它分别会转换成对应的一个随机数的一个值。

也就是说之前我们写随机数的时候，必须要在java代码里面写一个random的一类，然后呢next什么东西现在不需要了，这直接能帮我们进行生成，然后后面也一样。

可以通过at value这样的一个标签进行一个引入，引入，这代码我不带你们写了非常基础的东西，下载之后粘到你的IDE工具里面，直接运行就可以了，这个文档写的比较全好吧，第三个就是多环境的一个配置。

这不用说了吧，比如说我们可以通过spring profile active好吧，通过这样的一个属性值，然后指向我们的DEV或者text，或者说大PROD，就生产环境可以由多环境进行一个切换。

这块东西啊也一样，下去之后自己去测，OK这上节课讲的东西啊，我们检测一个回顾，下面我说了，除了用properties之外，还可以用一个东西叫YMYM好吧，他什么东西啊。

他说不是一种标记语言的一个外语缩写，但是为了强调这种语言以数据作为中心，而不是以标记语言作为中心，而用反谱词重新命名，反正这东西啊很奇葩很奇怪，你知道它只是配置文件的一个形式就行了，现在回顾没关系。

现在回顾上节课都说过了好吧，然后告诉你说他是一个什么样的形式，比说了语法比XML简单很多，然后告诉你它有一些语法的规则，注意下就行了，然后如何进行编写啊，这里边写了，如果你要完成一个多环境的话。

可以用spring，然后property，然后呢active加上它后面会用杠杠杠做一个分割，这表示DV的环境，这表示test环境这块，你可以选择，你到底使用哪个环境的一个具体配置。

也就是说我们现在之前上去给大家演示的时候，我写了多个EML文档，YAYAM2文档，现在呢你可以把它写到一个里面去了，但是要加三个杠，把它做一个基本的分割，好看的更舒服一点，这是第一点，第二点。

它也可以支持我们这些属性值的一个赋值，而且你在使用这个文档进行赋值之后，它在其他属性之方也依然可以引用，我们上面指定好的变量值，又写了一个dollar person name。

Major personage，是不是可以接引用了，然后在我们实体类里面想注入这些值的话，可以怎么注入，叫configuration properties，前面必须要加一个前缀。

因为这块它是一个是一个缩进方式来表示的，person表示说，我可以引入里面对应的一个属性值了，然后引入的时候它就会自动进行装配，就不用管它，但是而且呢它只是一个松散绑定，就算你的名称写的不是那么一样。

它也能绑定上来，但是不要区别太大，因为松散绑定它有自己的一套语法标识，好吧，刚刚在官网里面看了吧，这个是不是有它的一个缺点，别这样哦，松开绑定，好兄弟们，怎么回事，这给你演示出来了，好吧。

告诉你说呃什么风格，然后建议在什么什么东西使用，然后建议什么图形标识，下划线表示法，大写风格等等东西，这块从官网里面能看到很多的一个信息，这块只给大家做了一个总结文档。

然后再往下做了一个configuration，properties和value的一个对比好，他们两个有什么样的一个特点，OK所以这个文档我代码都给它粘出来了，你下去之后拿这个文档好好配一下就行了。

这东西没啥可说的，如果很多同学是刚接触的话，熟练一下，如果是接触的比较久了，在公司里已经使用了这块，直接跳跳过去，不用看了，好吧行了，那关于我们spring boot它的基本配置。

系列 5：P61：61、SpringBoot整合Servlet - 马士兵学堂 - BV1E34y1w773

下面要干嘛呢，我们聊一个东西叫web，也就是说现在我们用spring boot搭建我们项目的时候，他在开发一个web项目的时候是比较容易的，因为在官网首页里面告诉你了。

说spring boot里面内建了一个什么像tomcat啊，真理这样的一些容器，对不对，是不是容器我们不需要再把它打成一个外包，然后直接运行了，我们可以以一个炸包的方式直接进去运行。

运行的时候java到炸就搞定了，但是在运行这些web项目的时候，我希望你能注意一些细节点，为什么在官网里面，对这块其实描述的也是比较详细的，你往下翻这个东西叫开发web应用程序。

说spring boot非常适用于开发web应用程序，你可以使用嵌入式tom tom cat，这题好吧，来创建一个独立的HTP服务器。

大多数web应用程序使用spring boot starter的杠外吧，这是我们什么，是不是它使用的启动器模块来加速呃，来加速搭建和运行，也可以使用这个web fluence好吧。

来搭建响应式的一个web应用程序，但不管怎么样，你要知道一点，用它来搭建web的时候非常容易，因为我们在创建一个普通web项目的时候，只需要勾选一个模块就够了好吧，至于说为什么要勾选这东西之后。

我给大家说还是一样，我们可以通过源码层面来说，其实啊很多同学应该都知道，spring boot里面，它底层最核心的，和原版里面最核心的介绍是什么。

叫自动装配原理，对不对，我不知道你们到底在项目里面，是否留意过我们这里面的一些包，好吧，在我们导入这些maven包里面，有一个非常非常核心的包，三下下去之后可以自己先看一下。

叫auto configauto，Config，Sto configure，往下走，这有一个spring factory，在这个factory里面，你往下翻看这块什么东西呢。

叫enable auto configuration，里面有一堆以auto configuration结尾为这些文，这些类这类干嘛的，最终就为了帮助我们完成一件事，就是自动装配好。

就是自动装配这样一个原理，这个原理后续的时候我会告诉你，他一步一步是怎么来的，但是你要有这样的一个意识，所以你需要哪个组件，直接把哪个组件直接以一个泡沫文件形式，大家加加进来就可以了，我说老师。

这里面你看一下有这么多的一些auto configre，我每次启动程序的时候都需要进行加载吗，谁能确定加载吗，不是的好，为什么，不是你可以往上翻点，随便点开一个，点开一个之后，你会看到很多的一些标签。

有两个非常显著的标签叫什么呢，叫conditional，什么东西，conditional什么东西是啥意思，什么叫condition，表示条件的意思，比如说他会进行一堆条件的判断，如果你没有引入的话。

大家看到了，这是不是爆爆了一个红，那意味着此时它是不会进行自动装配的，就说你导入对应的配置文件之后，也是我们的pom依赖之后，它才会进行相应的一个导入哇，这块先有一个基本常识。

这是为什么告诉你们说每次在开启项目之前。

先把我们的pom文件配置好，配置好之后导入对应的一个依赖，原因就在这好吧，那OK这块先聊这么多，再往下看，说spring web mvc框架对吧，告诉你说MVC是个什么东西。

应该怎么做一个最基本配置这种东西啊，其实之前我们已经讲过了，或者聊聊聊聊的已经比较多了，这块我希望提一件事，你想一下，很多同学在我不知道你们在学习的时候，特别是年龄比较小的同学。

有没有接触过这样一个东西，有接触过的东西吗，什么叫server呀，叫server lie吧，是不是一个服务的一个小程序，把它本身是这样的一个意义啊，很多记住了MVC或者说一些web的一些框架。

几乎都是用于我们的sweet来来开发出来的啊，JSPS对的，这是比较老气的一个版本好吧，其实它有一个过渡的过程啊，刚开始是JSP，然后呢加so late，后来呢切换成SSH，后来到SSM。

到现在又变成spring boot，是不是还有这样的一个历程好吧，我不知道你们这块有同学接触过没有，然后最近打电话发现有好几个同学，他们公司里面还在用SSH struts to和HARBN。

很多同学可能都没有经历过这块，这块环节也没关系啊，全经历了S刚学的时候最好都学一下，反正我认为最好学一下，因为学完之后你会感受到这些框架的升级，它带来的便利之处啊，这天带来的便利之处。

你会发现你的开发越来越简单了，包括我们之后很多的框架，很多框架又为什么要进行框架，一个迭代，原因也在这个地方，就在于说他让人或者开发人员变得越来越呃懒，或者越来越简单，开发过程能够加快一点，懂我意思吧。

那这块我们要学一个东西，说什么呢，第一个点先学一个叫server late相关的一个点，你说老师为什么要学好，为什么要学server还是一样，因为我们的spring boot里面可以集成。

我们可以集成我们的SURRATE好吧，它里面有对应的相关配置。

给大家找一下，这叫内嵌service的容器好吧，支持这东西有什么用处啊，用处非常非常多，给大家说一下，就比如说我们后面啊，今天我应该会讲到数据源这个层面啊，就是data source，大家注意啊。

你在公司里面可能在用的时候可直接获取，用GDBC现在已经没人用了，更多可能要建立我们的数据库连接，然后再写下我们的database，好行啊，data source database啊。

要写下data source，在选择data source的时候，大家想一下现在用的最多的，好用最多的一个是什么叫黑carry，是spring bot里面自带的对吧，除此之外还有什么叫德鲁伊。

这是阿里巴巴开源出来一个框架，而且大家应该知道德鲁伊他是什么，叫专门为监控而生，还记得吗，是不是监控而生，也就是说，你要想实现德鲁伊，它对应的一个监控的一个性能的话，它需要你内嵌SD进去。

所以这块要作为我们第一个优先学的点，说STBOOT包含了对这些服务器的一些支持，大部分开发人员只需要简单对应的starter来完，获取完整的配置实力，默认情况下监听8080上的HTTP请求。

这块我们已经讲过了吧，来再写个代码试试，怎么做呢，非常简单，new一个project zu，等一下com，这把是不这样写一个spring，bot下划线叫web2把拿走，刚next这要勾选了吗。

第一个勾选上我们的spring web这样一个框架啊，把它给勾选上，其他东西你可以自己去加，把自己家这里面透露出来，另外一个东西好，另外一个东西叫spring boot dev toys，这是啥呀。

这是一个开发者工具，这些笔记我说一下啊，打断一下这些笔记，我最终都会上传的。

上传什么地方啊，咱们有这样一个地址，可能喜欢的新来啊，再说一遍，在B包马士兵这里面有一个internet architect，在这里面这里面我建了一个单独的目录，叫spring boot啊。

第一天第二天讲什么东西，我这都会往里面写好吧，就拿过来之后，你直接从这下载就行了好吧，直接下载就可以了，OK这不都说了，刚刚看到一个东西叫dev toys。

叫热部署用的，很可能都知道，除此之外还有一个什么东西叫JIO吧，好吧，这俩东西我不知道你们在公司里面好吧，哪个地方用的更多一点好吧，这块我们一会都说一下，都用过是吧。

如果你要用dv twice的话怎么办，你直接加载一个maven依赖就可以了，而如果你要用我们的driver的话，这块你可能需要进行额外的一些配置，我也感觉这包好用一点啊。

直播好用一点好吧，怎么做也很简单，告诉你官网里面哪个地方有，非常简单，你往上翻往上翻，这儿有一个开发者工具，在开发者工具里面他说了，spring boot包含一套工具，你可以使你的开发体验更快。

Spring boot devtools，然后呢模块可包含在任何项目中，以提供额外的开发时的一些功能，需要支持的话，把一模块加进去好吧，加完之后告诉你说应该怎么用，下面有一堆配置文档。

解释下之后直接看就行了，但是我说啊这个dv twice我们这不介绍了，不详细介绍了，没啥用好吧，我们现在重点来说一下我们的driver，driver也非常非常简单。

我这给大家写了一个markdown文档，好markdown的一个文档，这个文档里面我写的比较清楚了好吧，第一步安装在我们在idea里面。

File setting plug in brother respect，我在里面写入我们driver driver之后，找到able for int all，弄好之后，然后重启就行了。

但是它需要进行一个激活，而这个激活的时候大家注意了，这儿有一个激活的步骤，你按照这个激活步骤去进行操作好吧，最好你自己能做一个反向代理的一个服务器，自己搭建的话，不用担心失效，而如果你不自己搭建的话。

可能需要失效，之前明哥应该也说过这东西啊，之前明哥说的时候应该是在那个eclipse里面讲过的，我这是idea里面的，所以这块都有了，下之后按照这个文档来做操作就行了。

这不演示了，我在这个ID里面已经集成好了，来看看这个这个图标了吧，只有支付宝里面的一个图标，非常简单，如果谁在安装过程中遇到问题了，私聊我好吧，很简单的东西了，这不说了好了。

刚刚我是不是选择好一个web的一个窗口了，选完之后点next，这样改一下spring boot，Spring boot web，我改我改，我改一下这个目录啊，我直接给你们上传上去。

给RETONIGHT嗯，这怎么没有，老板还没同步啊，没同步换一个吧，这写的brain boot放这里吧，杠划分时K，直接打开就行了，打开之后如果你想配置一个web项目的话，就变得非常非常简单，怎么做呀。

直接在我们把这个东西先删掉，这东西想删删不删无所谓啊，我看着难受就删掉了，SRC选择min，然后java得到我们底层的包，在这里面可以建一个control n t r o l e r，Control。

完之后，在里面可以随便写一个东西，java叫my controller，创建好之后，前面加一个at叫renrest controller，只要解除Rest control吧，它什么意思。

然后public string hello，这是我们之前写的东西啊，还是一样，Return hello，spring boot来返回上面呢，加一个at request VIP，加一个hello。

看见了吧，写完之后直接运行，我们当前这个应用程序启动一下嗯，启动好之后。

这是默认在8080端口进行一个启动，所以此时我们可以直接进行一个访问，叫local host，8080杠走，是不是告诉你返回，Hello，Spring boot，大家想一下。

这是不是就是一个web项目了，导致我们之前说的搭建非常非常简单好吧，最简单的一种方式，除此之外我说了，它可以集成我们对应的一个SL，后续的时候我们会对它进行一个使用，所以这块我希望大家能够了解。

然后在这块集成的时候注意了，他说了一点啊，你往下翻这块说什么东西，说spring boot包含了这些东西的一些支持，然后呢在使用so late的时候，你可以配什么，第一个配so late。

第二个配filter，第三个配listener好吧，此外就不用说了，就是我们实际处理的一个业务逻辑类，然后呢filter是什么东西，是过滤器吧，然后listener呢是不是我们对应的一个监听器。

这块你都可以做一个最实际的一个操作，他说了，使用它的时候，可以使用spring bean或扫描方式来注入SRT好吧，然后呢说将这些东西要干嘛，要注册到内嵌的容器中，如果你想使用这里面值的话。

这样可能会更方便一点，后面告诉你说我应该怎么加入这些过滤器，是不是写了一堆参数代码，解释一下案例吧，然后包含一些sweet上下文的一个初始化等等东西，这块我们直接来演示我们的案例，代码还是一样啊。

我这儿给大家写了一个非常重要的一个文档，web开发，大家看一下第一个smode web开发，说第一个叫整合我们的SOLI好吧，整个都进行整合，第一个你要先写一个threat好吧，先写一个threat。

这块是不是有原生代码，我直接把它拿过来了。

正好没浪费时间了，没啥没啥意思啊，来直接打开我们的代码，加完之后这是用的是sweet333。0吧，是不是直接用我们的注解就可以了，注解配的时候写什么东西，第一个叫web server late。

第二个写一个名称，第二第三个写一个叫url pattern，好吧，这两个东西什么意思啊，你们都卡吗，我这没卡，大家看到这丢包就丢了，2048K包没丢包啊，所以应该是不卡的啊，如果卡的话。

可能是你自己网络的问题，不是我这的问题是吧，自己重新调一下网络，OK来往下看，当我们导进来我们对应的一个server之后，他首先需要继承一个叫HTTP server，这必须要继承啊，介绍完了之后。

上面写了一个东西叫web servlet，表示说这是一个service的实体类，如果原来你没有用注解的话，你怎么办，你想一下你在之前搭建项目的时候，是不是都有个东西叫web xm对吧。

那这时候你需要配置什么，server name等于什么东西，server class等于什么东西，还有东西，You are pattern，pattern里面是不是写上一些呃。

mapping映射这些东西好很麻烦很麻烦好吧，所以这块再做一个简化，然后这第一个是我们的名称，你要写一个名称，第二个写上你对应请求匹配的类，把它写上就行了，写完之后把这些对应的包都引进来。

听起来嗯很麻烦，还有很多的包，那个包完之后没事了吧，就注意了，这块我们其实并没有写全，为什么，因为这里面除了一个do get之外，还能有另外一个叫do post哦，叫do post，这块其实都有用的。

比如这块你可以写一下，看到了吗，这是个do post的好，一般写的时候就说你匹配到你对应的一个get，和post post这样一个请求方式，仅此而已，我们这儿只有我们的get请求，不用管它了。

这里面我的处理逻辑啊非常简单，没处理，这就直接写了一个A1，只要能打印就够了好吧，很多老师这个C位的整合用的不多吧不多，但是我说了，我们后面会有一个应用场景好，会有一个应用场景。

什么场景就是我们在配置德鲁伊监控的时候，我们需要自己来写一个service，那时候也需要自己写好吧，其实引用sweet的东西都是一模一样的，你这块需要稍微看一看，需要理解其中的一个最基本的一个原理。

只要稍微看看就行了好吧。

说完它之后没完还要干嘛呢，说在启动类上添加如下的一个配置，这个配置才是最核心的一个点，就是说你这只是定义了一个sweet，我怎么知道，或者spring boot怎么知道你当前这个slate应该生效。

或者说什么时候生效呢，这就意味着你要在你的启动类里面好吧。

加一个东西，第一个找到我们启动类这块儿加什么东西，叫at server l component scan，是告诉你说slate它自动扫描了一个包，之前我们点击看过。

这里面是不是也包含一个叫component scan，的一个包，一个注解吧，好把它给装载进去，它会有一个自动扫描这样的过程，大概加上加完之后里面没完，你需要把你对应的那个service。

注册为我们当前spring boot容器里面的一个ban。

好吧，这块怎么注册，他写了一堆代码。

我们把这个病直接拿过来，大家看一下，这个病其实非常简单，做事情也不是特别麻烦，你注意了啊，你在写代码的时候，你没必要说老师我每个代码都是手写嘛，没必要来看看这个逻辑吧。

这边有什么东西叫get server late register bean，什么意思，获取server late注册的一个并对象吧，然后这首先创建一个东西叫serrate registration b。

然后后面告诉你说你有一个这样，并把我们当前这个server对象给放进去，放开之后，这有个东西叫b set load on startup，很多同学如果你配置过web XML的话。

应该有这样的一个呃记忆这玩意儿干嘛的，这设置我们当前server Lt它装载了一个呃，什么时候进行启动，什么时候配置我们当前这个类好，这个属性我们这配置成一了，然后配置完之后把这个并返回去。

此时就意味着我当前这个病已经加载进去了，好加进去了，那这怎么办啊，直接进行一个重新启动，之前我们中学怎么起的，是不是用我们这个直接键启动的不太好啊，我们这换成我们的JBL，启动之后的话。

我们这就不用管它了，好吧，等一下吧，给他几刀啊。

没报错吧，此时我们可以发送我们对应的一个请求了，这是什么东西，叫杠杠SRV吧，回车诶，怎么有东西啊。

看着看这个信息打印出来了吗，打印出来了吧好吧，这个大家是不是已经看到了，我刚刚写MYSQL里面，是不是打印了一个111这个请求，这是不是已经打印出来我们对应的一个结果了，懂我意思吧。

所以这个配置非常简单，只需要说我自定义实现一个server，一个类实现完了之后，然后直接把当前server类注入到我们的spring boot里面，就搞定了啊，这配置难吗，不难吧。

当然刚刚那个风声也说了，老师这个Sol单独用的话，是不是用的很少，事实确实是这样的，几乎没人用啊，但是但是你要知道一件事，什么事情呢，我在进行这样的一个呃配置的时候，我怎么把我们对应server l。

给注入到我们当前这个容器里面，也就是说在我们当前这个启动类里面，这行代码或者几行代码非常重要的好，我再写一下这个注释吧，将service，添加到，我知道好吧，除此之外注意了，这后面还可以写东西。

它这还包含了一个最基本的参数，叫什么叫u r r making，好，什么意思，这可以加一个叫杠，这写一个S2吧，随便写的东西啊，杠S2好，随便写东西，写完之后，这块你必须要重启，我们再来发一个请求。

叫S2回车。

是不是这页面没效果吧，因为我们这没有返回任何东西了，看这这返回对应结果了吗，是不是返回了返回我们对应结果了吧，好这会大家要注意了好吧，把我们当前这个结果你返回来，意味着这也能调动成功，就这意思好吧。

容器是指spring容器吗，是的，LC容器就是我们自动装配这个对象是LC，是这样的。

好这话听明白了吧，它呀并不难好它并不难，你让文档里面直接写就行了，好吧，我要说的不是这个东西，要说的是什么，是我们S2生效了。

SRV还有一还有生效吗，你就按生效吗，我把它干掉。

来配一下2V搜。

看下后台效果，答应吗，打印吧，为什么一次请求有两个打印，这块来给大家说一下这块在请求的时候，为什么会有两次打印的一个结果，他在请求我们对应的method late的时候。

这是不是按道理说是不是只打印一次就够了，是不是这样EC够了，你想一下他是怎么样的一个轮转过程，如果你的do get就是这service里面的东西啊，如果你的请求没有请示，没有请求到的话。

他还有一个icon的一个请请求，icon的一个请求再看一下啊。

很多人可能已经已经已经很少，很少有人看这东西了，我打开看一下，大家知道了，找一下我们对应的一个更多工具开发者工具诶，你看一下我们的network这块，我们来刷一下页面，大家看一下，这请求了几次。

这什么玩意儿，怎么这么多请求啊，Date image png base，诶，这啥玩意儿怎么出来，是这样的，来SVG家char trs r，注意啊，这块有点问题啊，我这怎么做的过滤啊，我想想就你这块。

你看你的XS2在哪呢，下面这块是吧，这俩东西吗，反正这块我给大家说一下原因，我给大家说一下原因是啥啊，在这块是吧，先刷一下，这没有啊，这行不，JS2的，这不发生任何请求啊。

嗯我重启一下。

好吧，清掉清完之后我们再重新刷新刷，说完之后大家看到这怎么没打印好了，现在我们来请求一个东西叫S2回车，这边依然是我们的error配置对吧。

解决完了之后，你往这儿看后台是不是打印了诶，变成一色的吗，小学事故，这不大家试过之前给大家说一下吧，呃之前的时候如果你写过策略的话，大家应该知道，当我们在发请求的时候，因为我现在过滤器什么都没写。

所以他除了会发送我们当前这个请求之外，还有一个艾克艾肯的一个请求，那ax请求如果你不过滤的话，如果你不过滤的话，它依然会发一次请求，请到我们这个地方，所以此时的话会打印两个一，现在看到了。

我这还有两个一吗，没有了吧，没有原因是啥，你现在在发送我们这个SRVRV的请求的话。

走，你往后看。

这样写不到吗，已经起不到了，因为什么，因为刚刚我在这块是不是已经配过杠S，杠S2了，当你配置好之后好吧，后面前面之前那个配置就不生效了，这可以写一下，高配置是u r map之后server d。

自己的配置，就不会生效好吧，所以这块你只能请什么请求，我们的S2这块我们再来试一下吧，刷新一下是吧。

看后台有打印吗，没有吧，我现在换一个请求，换成我们的S2走。

然后这时候来再往下看，是不是请求了这个请求是不正常了，懂我意思吧好吧，这块大家一定要注意了，OK折叠器说老师不用加到容器里面也能响一把，Server server component scan。

那可以配置包，它可以配置我们对应的一个包，但这块我相当于什么，我把它注册到我们对应一个bean里面了，好吧，这就是这意思啊，如果这块我后面加一个包，这边有个属性来着，叫base package吧。

是不是还有个package，你后面可以加一个随便的一个路径，com点马士兵点，然后加一个SERVLET，它是不是也可以自动扫描，但是你这如果要进行一个自动扫描的话，那意味着你在你对应的method里面。

这是生命，因为它了web serv，这也可以生效，但是啊最好你把它注入进来好，这样写的方式比较好的。

为什么这么说，这官网里面给我们推荐的方式给大家找一下，可以看一下我们这个server late，我找了一类啊，你看这块就知道了，这里面有这样一个东西嗯，看这他说了，默认情况下，如果上下文只包含单词。

但意识到杠多个SB的时候，变的运作前缀filter过滤到更新，如果基于约定配置的映射不够灵活，您可以使用什么呢，叫registration bean filter。

registration bean和他的东西类来进行一个完全控制，这里面告诉你说，你可以使用这样的方式来进行配置，所以我在演示的时候，就直接演示这样一个配置方式，懂我意思吗，周子姐。

那多个sweet不是得多个病吗，是这样的，一般我说了，刚刚那个风声也说了，sweet其实用的很少，关键是什么东西，关键是我们要看一下，下面要讲的这个过滤器和过滤器和监听器，过滤器监禁用的比较多。

像这块用的比较少，这种配置可以写路径还是一样。

你这个配置你后面是不是要加一个base包，你这是加一个包名啊，就跟什么一样，就跟你在boot里面，你可以加一个at component scan，这是不是也可以写一个属性，比如说写一个。

叫base package default，这写一个com点马士兵之前我是不是也这样写过，好吧，但是但是你注意了，我们现在为什么不写它，原因非常简单。

它会因为你声明了spring boot application这样一个注解，但是声明好之后，它会自动加载当前类所在目录下面的所有文件，这是为什么，刚刚开始在讲boot之前，我给你讲一个要求。

说最好你启动好这个类之后，主程序不要随便改变目录，如果你改变目录了，就意味着你要改变你当前加载路径了，是不是意思，之前是说过的东西好吧，要是重要，要是用注解有顺序吗，什么什么顺序，说说说的是哪块顺序。

你说这个上下顺序啊，这无所谓啊，这个是无所谓的，这个无所谓啊，这个无所谓啊，这无所谓的，好吧好了，这是我们surreal里面最基本的一个点。

好吧，这块用的不多，下面我们来看另外一个东西好吧，看什么呢，看看我们的过滤器，大家想一下过滤器有用吗，有用吗，你想想如果你要做一个网站，你做一个网站，做完网站之后，我们是不是要过滤掉某些请求。

比如说如果这个用户没登录，我让他进行登录，如果不能不登录的话，这块是没法进行使用的，是不是要写一个过滤，对应的一个过滤器的过滤器也非常简单，大家可以看一下这块。

一个代码是跟SERVLET里面写的一模一样，没有任何变化，还是一个web filter加filter name，加一个请求，加一个请求，后面写了一个need，有个destroy。

还有一个do filter，这啥意思啊，告诉你说我什么时候要启动，或者说初始化我们的过滤器什么时候执行，我们的过滤器，什么时候销毁我们的过滤器，这块在做的时候，我希望你注意一件事，注意什么事呢。

在我们的filter这个里面有个东西叫filter chain，它是什么，它是一个链链条，好吧，什么意思，你这可以包含N多个过滤器吧，是可以包含N度过滤器，它会沿着一个顺序。

接着每个过滤器都挨个往下进行一个执行，所以应该写的时候必须要加什么叫T点，Do filter，当你做到最里面之后，如果没有出路了怎么办，它就相当于意思这样的意思啊，比如刚开始这是filter1F一。

然后这里面可以是F2，后面是F3，然后里面才是我们对应的一个SERVLET，当你的server处理完之后，再回来F3F2，然后F1是这样一个执行顺序，好这块大家知道就行了，看你们看到视频模式是吧。

就责任练练模式这块稍微注意下就行了，就这块一样，我们把它直接给拿进来，cc拿完之后一样的吧。

在我们当前代码里面建一个目录，写完之后CTRLV粘过来导一下这里面配置的包，哎呀好麻烦，先写好就好了，好了，这就是我们对这个filter好吧，有初始化，有我们的执行，由我们对应的一个串。

当你把它配置好之后要干嘛，这是不是也要过滤我们对应的请求，所以一会我请求filter的时候，请filter的时候，你会看到这个打印这个filter对象，此时虽然你不用重启，但是我建议你重启一下，为什么。

因为重启的时候你能看到对应的一个效果，往这看什么效果。

往上看看这个东西，看这东西，这有啥，in it吧，是不是意味着当我在重新启动，我们当前这个服务器的时候，它已经完成了我们整体这样的一个初始化工作，是完成初始化工作了。

然后现在他没有执行这个filter吧，为什么没执行，我这可以发一个请求，叫杠filter走。

当你加载完杠filter之后往下翻，有filter了吗，有filter了吧，是不是已经有filter了，是不是意味着我已经执行好了啊，它会一直往里面进行执行。

但因为我们没有对应与filter啊匹配的SERVLET，所以这不就不会有任何的一个显示，不会有任何一个显示，那现在你可以干嘛把它给关掉，把它关掉，我这直接关了，所以他不会打印DIY。

如果你是一个正常结束的话，会把这个DROY也给你打印出来啊，就这样一个顺序，所以以后你可以在我们这个filter里面，添加任何的一个数据代码，比如说加什么东西，if我不可以做一个匹配，好吧。

叫request啊，不对，叫什么request get，Contest sorry，contest点get，比如session嗯，没有吗，request get哎，怎么写来着。

Get recontest，点get session，get session这块注意了，你可以设置到我们获取到我们对应的一个强转，是吧，哦这是一个哦，这是一个service contest。

这样强转一下，强转完之后你会获取到我们的C，获取到我们三人对象，如果你的三连对象里面没有包含你的user，是不是可以把跳转到我们的首页登录里面，是不是可以过渡到我们某些对应一个请求。

这是我们过滤器它最常用的应用场景，除此之外还要干嘛，比如说你的JS请求对吧，再比如说你对应的CSS请求，像这些请求就不要发送我们对应请求，直接把我们计算资源返回去就可以了，是不是也可以添加这样过滤好吧。

特别是在进行登录页面设置的时候，这块几乎是必须要做的，所以这是过滤器，你知道怎么做就行了啊，知道怎么做就可可以了，过滤器镜头是这样的，OK这块的一个相关配置配置完了之后，除此之外还有啥来着。

刚刚说的吧，刚刚我们在官网里面看到这样一个属性，叫啥叫filter registration beans了，你是不是也可以通过它来往里面注册成一个bean，这是不是也可以好吧，但之前啊我没有写啊。

这是不是写他了，OK那所有页面都要写一个filter吗，还是一样的，filter里面在写的时候，你注意一件事。

这是不是有个东西叫you are pattern，他会设置说我发送什么请求的时候，才会进行一个匹配，如果你的匹请求不匹配的话，好这就不会进来啊。

这不会进来的，比如说你这样写一个，我随便发个请求啊，刚刚那不是写了一个很好，还记得吗。

把这请求给删掉，打开我们的run哎，随便启动一下。

走了八删掉，我这发一个hello。

HERO走翻译合作之后，大家看一下这块会打印PUTER吗，不会吧，不会不会吧，你可以进行这你可以进行这样一个设置，一般我们设置怎么设，如果是首页登录的话，写个杠星对吧，你写完doc之后意味着啥。

你所有的请求都会进行一个过渡到，这个没没没没起作用，发送请叫。

我写作业吗，杠杠行吗，应该不一样，杠星啊，这不对吧，不能直接写杠杠新了，应该是怎么不管用了，我们配的配置纸质宝，这应该可以啊，初始化是不是好了，来刷一下，刷新是不是filter了，重启一下就好了吧。

这重启一下就好了，然后现在然后现在的话我们怎么做，你现在再发送另外一个，比如说发送一个ABCD随便写，你虽然请不到这边是不是有filter，是不是有filter，好这块大家注意就行了。

OK如果一个页面一二，要是match多个filter呢，URL会怎么处理，你卖的多贵也无所谓啊，我说过了，你的filter它是一个什么，以一个链式的消防车往前走的，都filter之后。

它会跳到我们下一个filter，一直往filter里面进行一个跳转，好进行一个跳转，所以还得往里面跳的，这你不用担心，好好的老师，那这个filter的顺序我应该怎么定义了。

如果你现在如果你现在写filter的时候，写filter的时候，你如果直接像我们这样写，直接写一个类别的东西不配的，那此时的话有什么顺序吗，是不是加载到哪一类，你扫描哪个类，而如果你用了。

我们刚刚在官网里面看到那个方法叫filter。

Register ban，你是不是可以设置我们对应注册的一个类。

怎么做，是不是跟我们刚刚那个service一样，你挨个往里面new对象就行了吧，也是一样的吧，ok filter可以设置不拦截某个请求吗，这应该不可以啊，这我还没写过啊，这应该不可以啊，好一般情况下。

如果你要是想设置拦截和不拦截的话，有什么有include和exclude，我不知道里面有没有这样的属性，我不知道有没有这样一个属性啊，反正有include和include，不应该有这样一个配置。

但是里面怎么配，我忘了怎么配的啊，你稍微注意一下就行了好吧，差数是这东西是吧，在上面可以加一个order，一个属性，order这个值可以指定，比如一可以指定一好吧，它的值值越高，值越高意味着什么值越小。

是不是意味着越优先执行，是不是这意思啊，这是order是顺序啊，这是顺序，要求越小越优先吧，数数数越小越先执行，这是顺序，我们可以看一下里面的属性啊，点下注解，找一下里面的东西。

Display name fname，Icon sername，You are pattern，这好像没有啊，这边好像没有对应的一个属性啊，这应该是没法控制的，这没法控制啊。

反正请求里面是不是没法做的好，如果你直接在里面加参数的话，是没法做的，in the seta叫什么叫拦截器，不叫过滤器，过滤器和拦截器还是有区别的，过滤器和拦截器还是有区别的，好吧，加逻辑自己放过去啊。

这可以这可以做操作啊，搞混了。

这是我们对应的一个过滤器，过滤器完了之后发现最后一个啊，什么叫监听器，很多同学一直搞不懂，说老师这个监听器是干嘛的，非常简单，说监听器也是service规范定义的一个特殊类，用于监听不等于监听，什么呢。

叫sweet contest，Tv session service，request等于对象的创建和消费事件，然而监听与对象的属性发生修改的一些事件，用于在事件发生前发生后做一些必要处理。

一般可以用哪些方面，第一个叫统计人数好吧，第二个加载初始化信息，第三个网站访问量，第四个用户路径访问，访问路径是不是都可以做，我找人写的好吧，来把它拿过来，当然方式都比较简单的代码都比较简单。

我直接给他粘了。

把我们的坑写到哪，我直接写filter了这些这些里面去了计算机之后，大家看到了，这是不是有一个继承了一个HTTP session listener，继承完之后定了一个正变量，online等于零。

然后告诉你说每次session创建的时候，这会创建一个三人对象，打一句话，同时online加一销毁的时候，是不是告诉你说销毁这个session对吧，这块我们不用做那么严格啊，不用做那么严格，这要怎么做。

注意了，这必须要创建好我们对应的一个3D对象，所以此时这里面没有加任何的一个注解的配置。

那此时怎么办，非常简单，你这是不是要写这样一个属性了，是不是还是把它注入进来。

LC加到我们的这个配置里面去，Ctrl v，叫server late listener，region beans吧，是不是也往里面创建好我们对应的一个对象，把对象给放到我们这个listener里面去。

翻完之后就搞定了，好吧，这东西并不是特别难，那怎么做一样，我们重新启动一下嗯，接着吧，先启动，看效果，你看看效果就知道了。

ok listener是不是启动了，启动好之后，我这是不是可以进行一些配置了，这配置的时候大家注意一件事，在我们的listener里面，这是有个session，这是打印一句话，同时哦，这还没不没占完。

还有东西，注意了，这还要加一个什么，加一个控制层的一个代码，就告诉你说我的control我要加什么样的一个信息，把拿过来找到我们的control这块，不要它了，不要rise control。

哎不加保底了，这跟我刚才写的不一样，还加了CTRL，写完之后，这是不是有这样一个值，把这导进来，告诉你说在线数多少人，是不是请求online就可以了，那现在我们把它干掉，现在来请求一下行啊，出来走。

大家看到了，我现在在线中多少，是不是零人对吧，走走走走，老师，这为什么总是零个人啊，这不太对啊，为什么。

原因非常简单，你注意你刚刚写的这个监听器，你到底是怎么写的，你写的时候是什么，是创建三层对象之后，是不是才会给他加加，但你想一下，刚刚我发了个请求的时候，有任何session对象的一个请求吗，没有吧。

那怎么做也非常简单，在里面是不是有一个hello在hello里面的时候，我这加一个信息，加一个什么叫HTTP session，这里写一个什么叫session，点set attribute，加一个东西吧。

AA逗号AA，假如我加这样一个属性，这可以吧，是不是可以往上面加一个随便一个值，这个值无所谓，我反正也不用，我们反正也不用，然后现在干嘛呢，还是一样的程序清空清空完了之后，哎这怎么又有页面页面打开。

刷完之后刷新，现在是零人，然后现在做一件事情，叫local host冒号走，是不是请求回来了，此时你再刷新变成一个了吧，然后现在我再换另外一个浏览器，你再试一下，你打不开打开了，这还是一样。

Local host，然后呢，这写一个hello走，是不是也挺有意思，这个时候你再来刷新一下，变成二了吧，我现在在请求再刷新诶，这里面有有有有有有那个session session是不是同一个。

那现在怎么办，只能换浏览器了吧，是不是只能换浏览器了，这块是不是已经看到这个值已经在变化了。

也就是说你监听器里面你监听的是什么数据啊，监听是什么数据，这块就会进行一个增长，每次这时是不是有session create，有session destroy，是不是有很多这样的一个属性值配置。

下载之后，我刚才说了，在文档里面写的比较清楚啊，我说了，你可以监听我们的session好吧，也可以建设我们的service contest。

也可以进行service service request等域对象，这对象你都可以做一个对应监控，只要里面的值发生更改了，拿过来之后直接用就行了啊，你如果实在说老师，我还想看一下到底有哪些监听器怎么办。

很简单，打开它，打开之后你看一下当前接口里面是不是有session create，是session de，是不是有两个方法好吧，这下你再往下翻，这个没有了，就这个接口啊，还有其他一些接口啊。

比如说TP session，找一下ttp server late contest，Pl，啊那，就这个类似的吗，这块儿啊。

你看一下这块怎么办，也非常简单，之前我讲过这东西很早了，大家找一下，之前我在讲那个sorry的时候，之前录过一次sorry的视频啊，找一下找哎，哪去了，找不到了，之前我录过一次那个java的一个视频。

在那个java视频里面讲了各种各样的监听器，好，Server request，JASON对，就这样，监听器每个监听器里面。

它有自己实现的一个方法，所以你把这些方法拿过来之后，直接继承过来实现一下就行了，好像不同这样一个分类，但是如果有兴趣的话，看，可以回过头来看一下sweet好，看一下SURRE这块我们看了没啥意思。

没啥意思啊，反正你知道监听器，过滤器这些东西应该如何配置就够了。

相当于回顾了一下我们之前那个thread，相关的一个知识，你下来之后自己也可以做一个演示，好自己可以做一个演示，明白了吧，OK这块大家还有问题吗，来个女同学扣个一，这非常简单啊，这不用多说了啊。

非常简单的东西啊，现在之后拿着这个笔记好好看一下，我笔记写的是比较写详细的，一般该写的都写了好了，这是第一点，第二点该看看看什么了，看一下我们对应的一个静态资源的一个配置。

刚刚是集成了我们的SERVLET，但其实大家发现了service其实写起来并不方便。

而在我们刚刚你创建好，我们对应的一个数据目录之后，和项目录之后，你发现了在我们的com下面有一个resource，在这个resource下面有一个static，有个template。

这里面是可以放置我们对应的一个静态资源的，对吧，SA里面放什么，他们里面放什么，我怎么去读取里面的一个数据文件啊，这块应该怎么做，是不是涉及到静态文件的一个资源加载过程了。

这要说了，默认情况下spring boot会在class pass或者server contest根目录下，从名为static，然后呢这有个public resource，然后呢。

resources目录的目录中，开始读取我们的精彩内容，它使用了spring mc叫resource，HTTP request handler是吧，因此你可以添加什么东西，来编写这样的一个行为。

这啥意思，告诉你，我们写页面的时候可能写了很多HTML对吧，可能写了很多JS文件，可能写了很多cs文件，可能写了很多image这样的一个图片，对于这样的一些请求好吧，我是不是要把它放在哪个地方。

原首你是有个web root啊，Web in fi，web in fi里面是不是可以随便往里面扔，但现在没有这东西了，没有这东西了，那我怎么做，我只能把它带到我们某一个静态资源的。

一个目录里面，所有人都知道说老师我应该往resource里面放，那谁能告诉我为什么要往result里面放好吧，或者说result里面还可以建什么东西，因为你们在公司里面，如果是不是自己开发项目。

如果是拿别人项目的话，你看到有些人可能到这样，我就public对不对，还有一些人可能在这里面又建了一个DET，叫resource，有人见过这项目录吗，public resources有人见过吗。

你刚建好目录的时候，是不是只有static对吧，那为什么public和resources他要创建好，他怎么把这些文件给读进来的，有人想过这东西吗，其实这东西还是一样，我们要看哪。

看到我们对应的一个源码自动装配置的吧，是这样的，你告诉我从哪找啊，下载之后我们可以来看这样一个类，什么类呢，叫web，还在单元码，Web m v c auto。

A u t o com configuration，这有了，点一下这类好吧，这一类里面就包含了我们spring vc里面好吧，包含很多的一个配置项，好，各种auto configure是这样的。

在里面你要找一下我们对应的一个资源目录，好吧，你看一下他在哪，指定了那些静态文件的配置目录，我怎么去里面查看，OK下来之后，我们进入10分钟，10分钟时间里，你看一下这个源码。

自己打开自己看看看能不能找到。

这里面肯定有你认识的东西行吧，OK那行，那我们就先休息10分钟，你们找一下这个目录。

系列 5：P62：62、SpringBoot资源配置源码分析 - 马士兵学堂 - BV1E34y1w773

后来还在同学扣波一还扣波一，我们完完讲源码了，带你们看一下源码，很多老觉得这东西简单，我们给大家点不简单的东西啊，刚刚我说了，我们都知道我们在写页面的时候要加载很多CSS，JS等这样的一些静态文件。

在官网里面告诉你了，说我们写静态文件的时候可以干嘛呢，把class pass下面的这些目录的东西给导进去啊，为什么可以导，这告诉你了。

说你可以添加叫web mvc configuration adaptor，并重启里面的as resource hader来修改此行为。

那么刚刚通过查找之后，你应该已经发现了，怎么找来着，先打开web vc of configuration，你点开了之后找到里面的一个东西叫web mvc。

Auto configuration adaptor，在里面有一个方法叫ADRESOURCEHLER，在这里面他告诉你了，我应该如何进行一个相关配置，怎么配啊，说if什么东西，然后呢这个if什么东西。

if什么东西，是不是做了三个最基本的逻辑判断，这块我们挨个来看，他说了，This resource properties is all at mapping，比如说他会判断你是否修改了自己。

对应的一个资源目录，如果你自己这已经做了一个添加，那不好意思好吧，这块就不会做一个任何，就你原来配置东西就可能不会生效了，只有这个result properties，这是不是有这样一类。

第一类你看一下哪个哪个目录叫spring resources，然后呢往里面翻，里面是不是有很多一些属性，像这些属性值，你就可以直接在我们的配置文件里面，进行一个直接的编写好，直接进行一个编写。

就这块东西好吧，但你要知道这个前缀是啥，你们之前写代码的时候，很多人写的都直接写，比如说spin点啊冒号，然后呢MVC，然后冒号后面可以加各种各样的属性，为什么要加这样的前缀，在哪，标识的。

就在于我们刚刚那个properties里面有个perfect，在这perfect里面告诉你说这块是哪个东西，懂我意思吧，这都会有一个对应的标识，回过来我们刚刚看的地方，刚刚看完之后。

你发现了它有一个东西叫爱的result handler，第一个是判断它是否等于空，这样的信息，判断完之后，第二个叫什么呢，叫多什么东西，不用看，往下看，这个东西叫什么，叫web js，这玩意儿。

我不知道你们在公司里面，是否有人用脑袋被炸死了，比如说我们在写前端页面的时候，可能需要导入很多的一些web框架，比如说JQUERY等等相关信息，而web js就指的是我们对应的一个JQUERY。

里面的相关信息，这怎么找啊，非常简单，不止可以用这块啊，你说只有这块是有这个问题的。

可以干嘛，在百度里面，你直接做一个搜索搜查搜web j a r s，他把这些静态文件，静态文件也打成了我们对应的一个，pom文件的方式，比如第一个。

这是JQUERY是不是npm bot rap swagger对吧，第三点，JS是不是有很多JS的一些文件拿过来之后好吧，你可以把里面比如说我们选1JQUERY吧，选择我们的maven，把这块东西拿过来。

按住C拿完之后，可以加载到我们当前这个项目路径里面。

找到我们的pom文件，把依赖加进去，CVOK加完之后打开我们的依赖包。

往下找一下，这是不是多了一个JQUERY，在JQUERY里面，你往下翻，因为刚刚在原版上做了个标识，哪个目录啊，往下翻是不是在web js星星，它可以读取这个资源目录。

同时有个class pass m e t a app，然后呢resource，然后web js，所以我们在看的时候点开它，点开里面的resource，点开里面的web js，再点开里面的JQUERY。

点开里面的版本号，点开里面的JQUERY的JS，这意味着什么事儿啊，有什么事，意味着，当前这个项目我其实可以进行一个直接访问了，怎么访问，选择它，第一个叫web，这是访问过，直接访问过了吧，回车嗯来吧。

JZ走，请求不到，重新重新重启一下，重启动下，前端框架都被炸死吗，不一定看你自己的需要，拿完之后来写一下，请发送一下，看这请到了吗，是不是请到当前这个文件了，这边是谁，是不是。

就相当于是我们的文包里面某一个的一个依赖。

也就是说我这可以自动设置为它，读取我们web js里面的一些相关配置信息，是不是这这这这里面的衣服，也就是说你到底是否参与这样的配置，占完了之后，第三个什么东西呢。

叫static pass pattern是啥玩意儿啊，是不是叫静态路径的一个匹配，或者说静态资源的一个匹配，那句话怎么找这个东西叫this mvc properties。

Get static passpider，点进去，点完之后你发现这有个this pass Python，点进去叫杠星星啊，这杠星星指向什么地方，这其实已经跳过了，跳到哪了。

看这叫web mvc properties，是这个文件里面了，在这个文件里面，你往上翻翻，翻哪去了，这有一个resource来着，找一个resource啊，这没有啊。

我搜一下叫resource properties，在这个文件里面，大家看到有什么东西叫class pass，Source locations，是不是指定几个目录，第一个叫resource。

第二个呢叫resource class a下面的resource，第二呢叫class a的static，第二个呢叫ss pas的public，是不是意味着里面有很多的一个目录结构。

这是the static locations等于class resource locations，是不是就指向了我们刚刚那个目录，所以我每次在进行资源查找的时候。

为什么在你的resource这个资源目录下面，有人写public，有人写resource，有人写static，有人写TEMPL，他们这写什么是模板。

主要是上面三个public resource和static里面，其实按道理来说都可以放，我们对应的一个静态资源这块，其实我们都可以进行一个请求，怎么请求来右击又一个file，这写一个一点JS。

写一个呵呵，叫什么东西，static吧，然后再放一个东西，你有一个fail，这依然叫一点JS里面写一个叫resource，他们那个里面也一样，我也可以放一个file，再写一个一点JS，大家看到了。

这写一个public，大家看到了这三个文件名称是不是一模一样，几乎没有任何变化吧，名称虽然一样，但是我在发送请求的时候，它都会从我们当前这个资源路径里面，是不是查找我们对一个一个目录啊，刚刚看到了吧。

哪来的叫m web mvc of configuration，在里面找一个东西叫resource properties，是不是三个目录，1233个目录，那你告诉我，我现在如果发送一个请求叫一点JS的话。

他会先请求哪个显示哪个哪个东西，或者显示哪个目录下面的东西，你觉得刚刚是不是在三个目录里面都创建了。

Public resource static，先启用谁后请用谁static是吧，来我们验证一下对应的情况。

推车现在谁选谁，resource吧，好吧，然后呢，现在我在做一件事情，什么事情呢，把resource里面的东西给干掉。

delete掉，OKD了。

完了之后，我现在在同样发请求刷哎呀，这个这个到哪了，是不是到static了，不到static，static完了之后。

我可以再把我们的static也给进行一个删除delete。

然后现在我再发送一个请求到哪了，public吧，所以大家看到了，这里面是有对应的一个顺序，也就是说，我可以包含N多个同名的一个数据文件。

但是它有一个加载顺序，而那个加载的顺序是不是刚刚好，跟我们这块写的一模一样，第一个叫resources，第二个叫static，第三个叫public，这里面是不是标注好了，我加载数据。

所以以后你在写资源的时候，我加你进来进来资源文件的时候，不要随便乱放好吧，谁的怨气更大，你往前放怨气更小，往后放，这样的话他不会进行随便乱覆盖，使得你的样式就乱了，懂我意思吧。

当然一般情况下也没人写那种同名的，一般也没人写同名的，如果写同名的，你要知道它对应的一个加载顺序是啥啊，加载顺序是啥，第四个是44吗，雷第四个这个吗，tap里面放的是我们对应的一个TML，页面的模板啊。

这是模板引擎里面的东西，肯定不如关，跟这个目录无关，跟这没关系，就是上面三个目录啊，上面三个目录如果不放这的话，你往哪放，是不是META杠info resource，刚想想刚刚那个web炸死你放哪了。

是不是放在我们的m e t a info，然后里面是不是有resource，Resource，下面是不是有web js jquery3。4。1，什么东西是从这儿进行下载的。

好吧，刚刚我们写静态文件，不算是这样的一个配置目录，所以此时的话只有这三个，所以你要知道他们对应的一个单顺序，第一次找的时候先去找我们这个m e t a info。

然后resource里面第二个找resources，第三个找static，第四个找public啊，这块我们那里面都给大家写了啊，web web js怎么做，加上现在资源的时候。

它的路径是杠新星会去我们的resource properties，这个类里面看到对应的资源目录就是四个，然后呢，下面固定的说，可以看到自然目录一共有如下几个resources。

Static public，它们的顺序就是这样一个顺序，所以你直接拿过来看就行了，听明白了吗，知道怎么加载了吗，这是我们的资源，所以放的时候不要随便乱放好吧，但是一般情况下，其实你们在做的时候。

可能就有一个static public和resource，你们可能没有自己没有创建过，没创建过，你不用管它了，所有的CSS文件，JS文件都直接把我们SD里面扔就完事，但是你最好把它给分好目录。

听明白了吧，OK这个静态资源的加载，听明白同学来扣个一，还是这样，你通过源码里面是不是能验证到很多东西啊，这都源码里面的信息好吧，说实话，第二个什么叫加载，下面一个叫首页资源的一个配置。

这个首页配置在哪啊，一样的，在官网里面有帮我们做了一个东西叫呃，欢迎页面，是不是有展示说spring boot支持静态和文化迎面，你首先在配置静态内容是找到index tm。

如果找不到就找index的模板好吧，如果找到其中任何一个，它能自动用用作什么应用程序的页面，是啥意思啊，也非常简单，每次写的时候都写index，为什么呀，好或者说凭什么写就是index啊。

凭什么index就是我们对应一个欢迎页面，原因也非常简单。

还是一样，找哪儿是找源码，从哪开始找啊，别忘了我刚刚说的东西好吧，还是在我们的web mvc of configuration里面。

在web vc of configuration里面找到我们的ADAPTOR，在DOTA里面我们拍下去，这边我们来找另外一个东西，找啥呀，找一个东西啊，看这这有什么信息，哎。

别走别跑过来看什么叫welcome page handler met，不要看那个get index啊，是不是看到这块了对吧，这里面怎么做的呀，你往里面翻，他说啊，这都参数啊。

说new一个welcome page handler mapping，然后new完之后呢，里面做了一件事情，说new了一个template provider，什么什么东西。

然后从里面获取的时候怎么获取的，叫get welcome page，这里面是不是掉我们的get welcome配置，你点进去是不是在下面的方法里面，这告诉你了，说get resources。

Rest resource什么的，叫get study location，是依然从我们目录里面找好吧，整完之后，这里面有一个方法叫什么呢，叫this冒号，Get index html。

这种写法大家见过吗，见过吧，这希望大家见过吧，什么时候见过拉姆达表达式对，所以如果拉玛表达式不会的话，看一下，我之前在基础班讲浪漫表达式，那个地方讲的比较清，比较比较比较清楚好吧。

方法有这东西讲的比较多，好冒冒，这样的方式加完之后，我们往下看，这个方法是掉哪了，是不是调到我们的get index HTML，到这之后往上看，说什么呢，叫location。

加上一个东西叫index htm，是不是告诉你说我默认在进行调用的时候，就会找我们的index HTML，所以这个地方是标注出来我的欢迎页面，就是我们的index HTML是不是要标注出来了。

所以思维这块，你是不是可以自己进行一个自我定制了，懂我意思吧，所以你把这个原版看完之后，你会发现很多相关的信息，你能找到说OK他是从哪来的，从哪来的，你要给别人能把这个东西给说清楚，说明白。

百度说明白就够了，听懂我意思吧，把这东西难吗，不难吧，来这块听明白，同学扣个一。

是不是你能看到很多关键的信息啊，这为什么让你看源码，源码里面都有，大家看一下这个源码难不难不难吧，我个人感觉spring boot源码相对而言还是比较简单的，但现在啊怎么说呢。

就是你们现在还没还没梳理出来框架，等咱下周开始吧，下周开始我给你讲源码的时候，我先帮你梳理出来一个整体的脉络图，根据那个脉络的图，我们再一步一步进去找找对应的实现类，你就知道哦，原来是这么回事。

明白了吧，好了，好像这块的相关信息，所以配首页配置怎么做，你应该知道了，我文档里面我这里都写了。

通过哪个类找过来，找过来之后找哪个方法，它都有展示行吧，好了。

系列 5：P63：63、SpringMvc的扩展 - 马士兵学堂 - BV1E34y1w773

下面再来第二第三个点叫spring mc的一个扩展内容，这啥意思啊，什么叫spring mvc的扩展，这块也一样，我从官网里面截取的某一部分东西，来找找一个spring mvc的一个扩展，哪去了，诶。

怎么了，希望老师不要劝退啊，不会的不会的，没那么难，没那么难吧，别想太多，来看看这块的一个最基本解释，说，spring boot提供了适用于大多数，spring vc应用的一个自动配置。

第一个叫context，什么东西是一堆ban，你看到这些bean之后叫will reserver，好吧，will reserve是干嘛的，是不是叫视图解析器啊，你们都学过MVC了吧，有不会MVC的吗。

不会的同学扣二有不会的吗，小五不会啊，不可能吧，不过没关系好吧，你知道里面有什么东西叫视图解析器，这是不是看到了，是不是里面自己已经加载了，第二个什么叫支持服务，静态资源，包括对web站支持。

刚刚已经看到了web站是可以的，第三个叫什么呢，叫自动注册converter，好，converter和FORMATTER什么意思，是不是指的，我们的转换器和我们对应一个格式化器，这个转换器是什么意思啊。

你前端输入的项目，输入的信息都是我们的字符串，它能把对对应转换成对应的一个实体类对吧，格式化什么意思，比如日期转换成对应的一个格式，是不是都有，再比如说支持什么呢，也是converter好吧。

还有个叫message code reserver啊，这东西一般在那个9message这块，主要是在我们那个那个叫什么呃，国际化的时候可能会用一下好吧，包括这块说支持静态页面，index HTML是吧。

支持自定义的一个标签吧，还有什么东西叫configuration web bounds，Insertion beans，是不是也是一堆beans1些初始化。

所以这块是spring boot里面自动装载的一些配置是吧，这样都做了解释每个属性什么意思好吧，什么意思看错了，第一个叫视图解析器对吧，然后第二个叫支引入静态资源，包括对面不炸的一个支持。

现在的自动注册converter这些东西，然后这是我们的HTPG，HTP请求和响应的一个转换，这是我们的错误代码生成规则，这是静态的index自定义的分呃，这个呃标标签不是标签那个那个图标。

再来看自动使用我们这样的东西，将请求数绑定到我们的java b中，是有很多这样的知识对吧，大注意呀，这是谁，这是我们对应的那个spring boot里面自动集成的好吧，自动集成之后。

网上看说自动配置了vs reserve之后，就是我们之前自己学的spring vc的一个视图解析器，即根据方法的返回值取得输出对象，然后呢由输出对象决定如何进行一个渲染，就是我们的重定向和转发。

这功能这块也是一样的，你干嘛，你可以在我们对应的一个类里面进行一个查找，关键找对应类好吧，还是那样找里面的类，找哪类，官网里面给我们表示出来一个类叫什么，叫它看看，把它完之后，我们去里面进行一个搜索。

怎么搜啊，是不是还是这个页面，CTRLFCTRLV找到这个吗，走往下走，往上看，这是不是有东西，是不是告诉你说这个值是这样的一个值，这是不是引入进来了，因为这之后下面告诉你说。

我这是一个will reserve表示一个视图解析器，当前这个视图解析器，然后呢new了这样一个对象，new完对象之后，往里面设置了一些相关的一些属性，是不是这里就能看到这个对线对应相关信息了。

这是不是就是我们整体那个视图处理器的一个，处理过程，是不是在我们的MVC额，web mvc of configuration这个类里面，你能看到这个信息吧对吧，但我也说过了。

这块不是说你随便写完之后就一定能生效，这是不是有很多判断叫conditional on beans，conditional on Missing beans是有很多的一些条件判断。

你只有符合了对应的一个条件之后，这块才会生效，如果你没有对应条件的话，这块是不会进行一个生效的，你懂我意思吧。

那OK写完之后往下翻，这是不是只有这样的一个具体类，这类完了之后你可以干嘛，看一下刚刚写好的具体的那个类表示什么意思，也就是说把类点开。

点完之后它是集成了继承什么东西，然后呢实现了什么样的东西，里面就告诉你说，这就是一个最基本的视图解析器，type栏里面是不是定义了N多方法，但现在你看完这个方法之后，可能还有点懵啊，不知道他是干嘛的啊。

不知道干嘛的，没关系，我这里面写了往上往下翻，看，里面有一个方法叫什么呢，叫resolve，Will name，叫处理我们当前这个视图解析器的一个名称吧，是处理器的解器的名称对吧，处理名称是怎么处理的。

来我们这方法刚刚已经翻到了get。

看看是不是叫resolve，然后呢叫view name，老师spring版本的版本多少，最新的2。2。2，最新版本我们直接看最新的不看了是吧，这是截出来一堆的一些请求集，合完之后这个东西往上翻。

这是一个if的判断，判断完了之后做些什么事情，看这看这行代码叫get啊，不会读啊，什么什么will，是不是这样获取方法，这方法返回什么，返回是一个list的一个will。

这返回是一个will的一个集合了，你点开当前这个方法好吧，这里面是不是告诉你我要循环遍历集合了，集合循环遍历的时候，是不是有for循环循环，告诉你说我要处理当前这个视图解析器了，然后呢这有一个判断。

判断完了之后也是一个循环的过程，时候把这视图解析都给拿出来，是不是这样的过程，所以你看了源码之后，你会发现说OK这里面有关于我们的视图解析器，完整的一个整体处理环节，一般是怎么找的。

我是怎么找到这个地方的，找完之后我是做哪些的处理，是不是经过选循环，你现在不要不要去看里面的东西啊，我现在只带你看一个大概的一个步骤，还有大概步骤之后讲杨老师的时候，这块我们会详细讲的，我会详细讲的。

这块你先别管，你就知道说我一步步是怎么找出来的。

怎么来处理我们对应的一个视图就够了好，所以这里面我把代码给粘出来了，粘粘出来之后，这个get什么view，然后再往里面进行一个旋转好吧，转完之后可以init service conscan。

什么东西把它给取出来，在这说了一句话，说通过上面代码的分析，我们知道了spring boot是在容器中去查找视图解析器，因此我们可以干嘛，可以给容器自定义添加输入，什么叫输入表视图啊，自己写啊。

自己写的有错别字啊，这看到可以给容器自动添加，我们是不解气，这个时候这个类会帮我们将它给组合起来，是不是这意思好吧，这块也一样，刚刚代码就告诉你说，我把它加载到一个容器里面了，通过当前这个容器。

我们就能把我们的视图给取出来，它取出来之后，这可能是一个原理，大家记住了啊，说他是在容器里面找，所以此时如果自定义了一个视图解析器，只需要把它声明为一个视图，我们意味着是不是就能自己做一个操作了。

好所以我来看我在写这样的东西啊，写什么东西，他说了public will reserver，然后呢MARYRESERVER，然后写了这样一个数据，是自己定义的东西啊，不对啊，这下面下面是自定义的东西。

叫public class，Static class，My view reserver，Imply，什么东西实现完之后，什么处理都不做，不漏出来之后。

这可以return一个my will reserver，是不是这里写了一个B，当你写了病之后，意味着我加载到我们当前容器里面了，此时你当前这个视图解析器就生效了，当然一般情况下你不需要做这件事情啊。

不需要做这件事情，为什么，因为磁盘VC里面它本身提供了数解析器，除非说它提供的视图解析器，不再满足你的需求了，你这个时候没办法，我必须要进行一个自定义了，基于这样的情况下，你猜怎么样呢。

需要自己来完成一个添加过程，这块能听明白吗，能听明白吗，这源码没带你拿个看啊，我只给你们截出来了，我说了源码，我们现在先不看它，先讲这些基础知识，先把这块东西搞明白了之后，我们再看源码好吧。

这两码下去之后，有兴趣的同学可以先看看，你可以先看看好吧，每一步我给你写，都能写注释的地方，给你写注释了，来这里吗，能听明白，同学扣个一，我们是不是蒙了，能听懂吗，摸模板引擎是不是得重写。

不需要它本身是不支持了自己的模板引擎，你知道你除非用一个自己特定的模板引擎啊，一般不需要啊，比如说你现在只需要处理一个视图解析器，就是说，如果你现在想添加一个视图解析器的时候，为什么我把它声明成一个病。

它能处理的就在刚刚代码里面，你看到了它是从容器里面进行加载的时间有限，我们带你们看一下独立源码，只有原版课的时候会详细带你们读，里面每一个步骤到底是干什么事情，好吧，怎么做这样一个处理环节。

这块我会带你们说的，听懂了吧，OK如果你这块看明白之后也一样，回到我们这个官网这个环节，官网这块就刚刚说这块好吧，怎么进行一个添加的，你配置什么东西就行了，听到回话没一步步记录下来，没关系。

我笔记会发出去，你按照我笔记里面写就行了，我这个笔记啊写的比较详细的，每一个步骤通过哪个类哪个方法找进来的，怎么都要调调，调过来的都写的比较清楚好吧，来再往下看下面这块的一个文字描述，这两字描述注意了。

是我们对应的官网里面的一个描述，看错了，如果你想保留spring boot mvc的功能，并且需要添加其他MVC的一个配置，比如拦截器，比如格式化器，比如视图控制器，可以添加自己的web mvc。

Configuration，ADAPTOR类中的and configuration类，但是不能带上nable web mvc这个标签，为什么，因为你带上这个标签之后。

就意味着你自己完全掌控了我们的spring vc，而spring boot好吧，就不再起作用了，虽然说了，如果你想自定义它它它这些实例好吧。

可以声明一个web版mc registration adaptor类，来提供这些组件啊，刚才说了叫原油配置都失效，确实是这样的，所以这可能会成为一个问题，官网里面是不是都写的很清楚了。

就告诉你说一般不要做这样一件事，那我们这其实也可以做这样一个类似的配置，怎么配置呢，还有笔记里面写的，这样我自定义好自己的一类，记住你要继承这个时间类好吧，一定要记住这个时间类好。

接下来之后我们可以添加我们的视图控制器，来写一下吧。

打开我们的项目，找到我们的com马士兵在里面，我new一个，Package，再写一个CONFIG，要写一个class叫麦CONFIG，写完之后注意了，这一定要实现一个东西。

实现叫web mvc configure，设置完成之后，在里面加一个方法叫ADD will control，当你加上control之后，你发现它里面有个什么参数啊，叫registry吧。

是不是注册的意思是registry点ADD什么东西，这个地方吧，是不是i will controller对吧，是不是CTRL，这里面你可以写什么，写一个随便的请求，它是U2地址嘛，比如写一个叫MSB。

然后呢这边写一个叫set，没有内容，这写些东西，我们有页面吗，没任何页面是吧，创建页面吧，创建页面切换页面，这是一个hello，yeah i就好了，Hello，这写一个hello e l l o。

不是不是完成这样的一个页面了，然后此时我后面可以写什么了，写上我们对应的一个请求叫杠呃，Hello，点HTMLDOCO是不是放到这样一个请求，当你写完这个请求之后，下面就告诉我再怎么写。

我需不需要在我们对应的一个control里面看到，我写这东西是不是返回一个size。

你随便换个名字就行了，这个名字无所谓，当你匹配请求之后，我需不需要在我们当前这个control里面加一个。

这是一个有字符串，我们大家现在这样写有问题没有，现在这样写的话，能请到我们这口页面吗，能不能请求到来，重启一下试试好吧，看下试试，不行来把它清空掉。

进攻到这来请求一下试试，我猜没效果，来MSD回车，为什么说404，是不是意味着我找不到当前页面这么做。

At composition，OK别忘了这东西，At configuration，刚刚啊在这是不是写的比较清楚。

官网里面看，这块是告诉你说你要添加一个哪来哪去了，at configuration类，必须要把它做一个标志吧，是不是必须要把它做一个标识，这不是写了，但是你不要带这个标签，不带这个标签。

这个标签之后可能会成为一个问题，所以这块来提问一下。

我重启一下，保证这个效果啊，好来再重新刷新一下刷，听到了吗。

听到了吧，但是你想想这个请求是什么，请求，是合作spring吧，这是我们刚才说输出的东西吗，不是吧，因为什么。

他跳转到我们刚刚那个my control里面去了吧，这时候把它改一下，我干掉，这儿返回一个信息，最后一个hello，这时候来再重启，其实不用重启啊，不用重启也可以重启一下吧，来再刷新一下。

都找不到了，哪写错了。

刚和罗写错了吗，这样写错了，找一下，Will pass，Hello，Would back conflow，这加一个东西，My conversion，不要加杠，这不加杠，不要加杠，这不要加杠，这不要加杠。

啊申请一下嗯。

就这个问题吗，control control没写错啊，my control不是hello吗，我要1hello，页面好点，Html，没错，周期一下。

哎这怎么还不对啊，我写的和楼房马士兵。

不是吧，没写错吧，这是不是4。5等于hello，访问写的是MACD。

没写错呀，然后CCESS，Request mapping，哦这是吧，所以这是不是三四。

这还跳回来啊，Hello html，Hello，Spring boot，这啥问题啊，是个目录，没墨了，这就放里面没问题啊，确实里边。

哎404。

request mapping加，这不用加杠，这有问题吗，没啥事啊，就这个不行了，blue这请求一个加不加，这加不加无所谓啊，这这这不是干的事，没有name等于他请求他写个hell。

应该写一个hello。

去掉不去掉，去掉之后跟我们不一样吗。

对啊，这哪有问题啊，我错了，我关掉，重新重新看一下啊，Confusion，这是我们自己的添加一个gm s b，然后呢发挥一个叫hello的一个请求，这样请求过来之后找到我们对应的一个杠，这没写错啊。

之前测过了，这这应该不会有问题啊。

这不有问题，Make my，Configuration tom a c，这是他请求fo return fo request mapping，继承错了，试一下，刚进行错了吗，来试一下啊，不是继承文件。

这应该就应该写hello啊，这这匹配的就是我们的hello这个请求，是不是有问题。

活动给不到我，你这个说几下试试。

这个钥匙set up flow game。

我认错了。

Confidation，这哪有问题啊，要钻进来，这奇怪了，Rest control。

Rise control，没关系，这就是control return hello，这是，没懂魔幻引擎模拟器没关系啊，我现在没用到模板引擎，把notch nol试一下，NOTEL试一下，是出东西了。

奇怪了，用CTRL就行。

这不对啊，不继承错类了吗，没写错吧。

Web mac configuration。

这也不对啊，The devior，不是他不是他，没写错啊，就是web，MVC这个，就这东西啊，这应该没问题啊，这个应该不应该出错啊。

这好奇怪啊。

是用效果器的原因吗，你想给自己试试啊，这我写的应该没问题啊，这是我们的数字点线是MSB，我是一你看啊看这意思啊，再看一下这个地方，现在我是加一个视图控制器，好叫MSB。

然后设置它一个视图名称叫hello对吧，所以我现在相当于什么呢，我要请求一下我们的MSB，当我请求MSB的时候，相当于我映射到我们的hello这个这个页面里面，是不是把它给请请请求到就行了。

是这样的意思啊，那我这写的时候，这个MACROL写的时候，这就应该写他写hello啊，这啥意思啊，都很奇葩。

又不让我请求了，非要用这两个名字换个名字也一样啊，你换一个ABCD，这可以吧，跟这名字无关啊，爱他，这应该没问题啊，这为什么会出问题，Hello，这肯定没问题啊，这不就写了个这就写了个天猫页面。

啥都没写，什么都没写。

这样我们先访问一下，看能不能合作，能请求到，我这hello请求不到啊。

这是controller reacts mapping，Return hello，我知道啥意思，好像好像这个问题啊，我们找个东西啊，额外加一个东西加一个。

找一下东西啊，找一个我们的依赖，找一个依赖，找一下SIMPLIE赖啊，很奇怪啊，Free marke，我靠官网都不用了，Sim leaf，吓死我了，那把这一点加进来加一下试试四。

这音乐有关系吗，这次爆我很抱，我很意外啊，为什么找不到啊。

现在是有了，我现在请求呃，ABCD现在好了吗，好了吧，我说咋回事啊。

我们代码写的肯定没问题啊，来这看，我来看刚好加什么是ABCD，相当于说我请求ABCD的时候，给他加了一个视图名称叫hello啊，Hello，Ok，这期刚出来的模板引擎。

我们刚刚那个目录放的时候是放这个呃，他们里面去了，这时候必须要加模板引擎之后，才能才能去便利我们这个他们的目录，要不然的话他找不到对应，找到对应的属性啊，找不到对应的页面啊，那这时候是不是没问题了。

现在我放在ABCD，改回来，Msd yy。

来再重新请求一下，这个还不行。

这个这个MSB中毒了吗，重启一下试试。

好了现在是不是好了，是不是请求到了，因为我们没加模拟引擎这块给大家标注一下，注意，需要添加，模板引擎，什么我刚刚给他粘出来的东西，给他粘过来，我这，好了是这块东西好吧，稍微注意一下就行了。

知道你们自己是添加这个数解析就行了，明白意思吧，啊这块翻车了，浪浪费了点时间啊，不好意思啊，反正我刚写就感觉代码这块肯定是没问题的。

好吧，请求过来就找不到折叠器，刚刚应该听折叠器啊，听折射器早早就解掉了行了，那这块咱们就聊这么多吧，别的不说了，来这边听白同学扣个一，这还有问题了吧。

系列 5：P64：64、thymelaf模板引擎 - 马士兵学堂 - BV1E34y1w773

好了这块有没问题，之后，这是我们这个web web开发相关的一些知识点，大家发现了这些知识点，我都是从官网里面截取了一部分，就我认为比较重要的东西拿出来之后，给你们讲了一下，来给你们讲一下。

这个我刚才大家已经发现了，我的模板引擎非常非常重要，好吧，之后我们在开发这个项目的时候，也需要用到我们对应这个模板引擎，相关的一些属性点，所以该怎么办，我们来看一下模板引擎应该怎么做。

学习在我们这块注意了，可以找一下sim，模板引擎呢找一下啊，在web开发这块注意了，一般情况下，推荐大家使用我们对应的一个模板引擎好吧，而且而且你注意一件事，模板的模板引擎。

大家看是除了Rest for a Rest web服务之外，你还可以使用small vc来服务动态HTML内容，spring vc支持多种模板技术，包括sim lab呃。

呃sim live framework和JSP，当然注意了，JSB这块，我不知道你们在公司里面还是否会使用，现在已经没人用这玩意儿了，好吧，大家想想JSP它是啥东西啊。

啊翻译过来叫啥叫java server配置吧，相当于说在JS页面里面，我可以嵌入我们对应代码java代码，然后呢，可以把我们后台返回的数据，动态的显示到我的页面里面。

而我们在使用我们对应的一个模板引擎之后啊，它也可以完成我们对应的功能功能，所以他说了，所mod里面提供了以下模板引擎的一个支持，Free mark ga，好吧哈，SIMPLIVE还有这些东西。

目前用的最多的可能是sim live这东西，所以SYMBOLIP这块我们要重点做一个学习，他说了，如果可以，请尽量避免使用JSP，当使用了内嵌SL的容器之后，会有几个已知限制，这块有限制好。

但不管怎么样，建议大家不要再用我们的JSP了，最好用我们的sim lip这块问题来了，sim lip我应该怎么学，在我们的spring boot的官网里面啊，官网里面FIREMARK这么多。

你们哎问一下，你们在公司里面用free Mark用多还是用SIMP，用多了，free Mark用多扣一，SIMPLIP用多扣二，都不用，VOEGSP指责后端前端分离行吧。

这块啊如果你用free Mark中用户多的话，你就它其实也一样的，你可以看一下官方网站，就是那个文件名称，后缀FTL，它里面有官方网站，其实也就是对应语法规则，你把这些语法标签掌握了之后就够了好吧。

直接讲完就够了，都不用清水JSP这这这这JSP现在已经不用了，大家看到了吧，这个文档里面都比较简单，其实里面有if else if是不是有些逻辑判断对吧，同样的sim live里面也是一样的。

好sim live也里面也是一样的，把它打开，这sim live里面就是说你用semi的时候，你可以怎么样呢，直接用我们的HTML页面返回就行了，好吧，它不需要形成一个单独的一个模板引擎。

就是在HTML页面里面直接进行嵌入，这个地方就是sim live，它的官网把simple lip用于官网，所以这块我把simon live这块给大家重点说一下free Mark，如果你们有需要的话。

把free Mark重点学学啊，这东西比不也不难，还是一样，从官号里面看就行了，他说了，在早期开发的时候，我们都用静态页面，也就是HTML页面，随着时间轴的发展，慢慢引入JSP页面，当在后端。

当在后端服务查询到数据之后，可以转发到我们的JS页面，可以轻松的使用JS页面实现数据的显示和交互，这里有非常强大的功能，但是在此时boot的时候，整个项目是以炸包的方式运行的，而不是外包。

而且还嵌入了tomcat容器，因此在某种情况下是不支持我们的JSP页面的，如果以纯静态页面的方式，会给我们开发带来很多的麻烦，所以推荐使用模板引擎，模块型有很多种啊，有jsp free Mark是吧。

一会儿干嘛呢，写一个页面模板，然后呢一个值动态的可以写一些表达式，这些值可以自从后台查询之后返回去，好吧，这是他这个图官网里的图啊，说TNT，然后下面页面这是dollar user。

就是这后面可以写我们的data数据，此时你用模板引擎之后，它显示的数据就是什么叫hello张三，就这样的信息，所以就是说把我们的数据做了一个，原生替换而已啊，所以sim lip啊。

他学起来并不是特别麻烦啊，并不是特别麻烦，大家看SIMLIP有些介绍，官网刚刚已经给你们打开了，还是老规矩，我们从官网里面来进行一个查看，第一个先选一下下面的有东西啊。

docs是倒钩门神DECENSION，这块有很多，大家看到了，是不是有using simi，有三的对吧，有三的下面都是三版本，之前还有用二二的版本，现在啊可能用三用的更多一点，我这讲的也是三。

你可以把这些文档可以在线看，也可以直接把它给下载回来，这块我已经下载好了，一会把分享出来，叫using sim，好同学看这个文档的时候看的很难受，因为全部都是英文的啊，全部都是英文的嘛。

所以这块也一样的，我给你们相应的匹配的找了一个中文的网站，看看这个你叫SIMF一个例文，什么sim leaf有什么样的东西，这块都是写好的，所以你看这个网站也能做一个学习。

但是我们后面如果要进行一个项目开发的话，这块你是必须要会的，所以这块我们先拿几个简单的东西来给大家，演示一下他到底做了什么样的一个事情，可以看一下什么是live，这做的比较一个比较详细的解释。

然后呢能SIMP能处理哪些对应的一个模板，网页发出来，来你们存一下，然后还有一些标准方言，如何构建一个虚拟杂货铺，这块给大家说一下，他这个网站比较好好在什么地方，它提供了一个对应的一个呃样例模板。

也是他给了一个项目，你通过这个项目之后，拿过来之后可以直接进行运行。

我这已经运行过了，可以给大家看一下，这东西叫他JVTVT，打开之后呢，怎么做，直接运行，看看这个效果啊，看这个效果，这是他那个SIMP官网里面提供出来的，一个模板的东西已经使用了是吧。

地址地址地址端口冲突了啊，停掉拜拜一小，此时的他还是一个外包来进行运行的，外包进行运行的，启动好了吗，等一下OK，启动好了。

听到之后看到了吗，这大家提供好的一个官方网址，product list是不是有这样一个展示列表，然后下面有一个order list，然后告诉你说你怎么来查看，里面有什么的相关信息，再做一个展示。

然后返回返回user home，什么东西，return之类的，就他做了这样一个页面，你可以进行自己的一个查询，好自己一个查询，所以这块你可以下载下来这个代码，把这个代码运行一下，注意不需要改任何东西。

直接需要嵌入一个tom的容器，它能运行了非常简单的一个方式，这是他官网里面给我们做了一个，最基本的一个提供啊，最基本的一个提供，提供好之后，下面更多的是什么，你要看一下这东西应该如何进行一个使用。

看到一个东西叫标准表达式语法，然后看他说了，第一个叫简单表达式，里面有变量的，有选中变量的，有消息的，有URR2的，还有我们的片段，有常量，有文本操作，有算术操作，有布尔操作，比较和相等条件。

运算符和特殊符号，是包含了很多很多对应的一个相信息表，这边是不是都有，所以你在用的时候，直接拿这东西来进行查看就可以了，而且每一个点里面他俩都给你做了一个解释，告诉你说你应该如何进行一个最基本使用。

每块都解释了，所以这里面代码你其实可以拿过来之后，直接嵌到你的HTML页面里面，直接进行一个查看，都非常简单，这是第一点，你要看的，第二点，我如何来使用我们对应sim leaf，好吧，你往下翻翻。

翻到这块有个东西叫属性，在数学这块告诉你说，如果你想引入片段的话，你要用什么叫t h insert或者t h release，如果你要用迭代片段的话，用TH意识就是我们的循环条件的话。

T是if局部变量提示object t是base，一般属性ATTRR好吧，特殊属性有value hf src，文本的话属于我们text，然后呢呃片段的话可以用我们的服regent。

然后还有个t remove，是不是用的这些标签，比如说以后我们如果要写页面的话，你可以怎么样呢，直接用我们的FRAMEK引擎，直接往里面嵌就行了，非常简单，这个属于前端吗，呃不算前端吧。

就你写好前端页面之后，你可以自己做一个基本的修改，你懂我意思吧，好了，那这块我们怎么来做呢，怎么来做呢，也非常简单，下面文章里面我给你写了比较详细的一个模式，第一点你需要先引入我们的模板引擎。

我把地址也给你站出来了，就跟up地址好，这是第一点，当你把这个地址写出来之后，你注意了，当你引入当前这个配妹妹的一个依赖之，后面的一个依赖之后，而中文网址可以放到SIMT文档里面，可以可以。

我给你加一下中文，没事挂地址给大家粘一下，哎呦下课忘了背哪去了，呃我直接打开一下，重新打开，好这样吧，你们直接访问就行了，直接访问就行了，让大家看注意了，当你导入这个依赖之后，相应的它会有会有什么呢。

叫sim leaf，然后properties，所以这块我们也可以做一个最基本的查看，怎么查看。

再写一个叫sam t h y leaf zr e f properties，打开之后你会看到它在哪，是不是指定好了，我们当前这个目录是一个template这个目录，然后呢，同时还会告诉你说。

这有一个点HTML的一个后缀对吧，里面包含很多信息，所以以后你如果需要自己开发一个web项目的话，直接写HTML页面就行了，把写HTML页面也写了，写完HTML页面之后，它会自动进行这些数据的一个渲染。

把那些值给我们给填进去。

这我也举了一些例子，你把这东西看一下怎么使用啊，看着我写了一个非常简单的一个需求，说第一你需要在java代码里面写一些对应的信息，比如说这儿有个叫model相关的信息，这怎么用啊，让我们写一下试试吧。

先看一下第一个我应该怎么进行使用。

把它关掉了没用，把拿过来，这有一个controller是my controller，这是hello hello里面加一些东西，因为这是集成MVC的嘛，所以这直接用model就行了，卧槽。

这加一个属性叫model dead tribute，MSG是吧，Hello，然后呢逗号spring boot再返回这边回页面，返回页面之后再回到页面里面，我要写东西了，写什么，这个标签不要了。

不要之后注意了，你要想在HTML页面里面嵌入我们这个CV6模板，这你必须要加载一个标识，好吧，告诉他你用的就是我们sim leaf这样一个东西，怎么加以标识啊，官网里面也有一个明确表示。

我找一下你哪去了，找一下我们的页面啊，这有页面啊，这个鸡蛋诶，没有吗，这没页面有关，应该我找一下啊，看着就这个东西，你把它给拿过来，把这段话拿过来，他说C打完之后粘到我们刚刚这个地方。

TT标签后面，粘完之后就搞定了，此时在用的时候，你可以干嘛叫显示加个东西吧，消息，为冒号后面加一个东西，比如加一个P标签吧啊这加一个叫TH冒号，是不是叫test引入的时候，这是一个变量嘛。

所以用dollar符号括号加一个东西叫MSG好，加完之后，这能做一个展示了，现在我们把当前这个应用程序启动一下，启动报错了，加一个封号，吹一下中括号，中号可以吧，可以可以可以，中框中框也可以，把那写写。

可能稍微麻烦一点，来启动好之后，我们这直接返回一个hello。

看这显示消息为HELLOSWIMT。

是不是意味着我们刚刚后台写进到model里面，的一个数据已经被我们前端这个页面给查到了，这就是C用户DF模板最基本的一个使用啊，最基本的一个使用，所以它并没有特别难，关键就是说我知道如何使用这些标签。

或者说如何使用这个贴标签就够了，理论来说所有的属性你都可以加TH冒号，但前提是一定要加上这样一个呃标识，告诉你说你要从sim live里面进行一个引入了啊，这块很重要，懂我意思吧。

下面来再接着看怎么用呢，现在告诉你说semi支持的一个语言表达式。

这块给它粘出来了，这块粘出来的信息啊，粘出来的信息就是我们刚刚给你看的东西啊，从官网里面看的哪看的，打开第四块是标准语法题的表达式里，每个里面表示什么意思，你要去边上的时候。

用dollar选出表达式的时候用星，然后呢消极表达式用井号，这个想法是，一般在国际化的时候用的比较多一点，然后还有什么选择，我们的U22用艾特符号，如果是片段的话，用波浪线对吧，你别告诉我。

还有其他的一些取值的方式，你直接拿过来取就行了，循环怎么弄呢，一会我给你演示循环应该怎么操作好，同时下面还有什么第十块，你记住了，第十个点里面告诉你说有哪些属性标签，你可以进行怎样的一个使用。

这个东西文档里面我都写好了啊，这站出来图说了，SIMI实例演示，test表示文本的一个内容，value表示当前元素的一个值，TH就是表示什么是我们的循环操作了，if表示条件判断。

insert表示我们代入的那个代码块的一个植入，然后呢FM表示定义代码块，object声明变量ATER表示修改属性，但修改属性一般没人用好，一般没人用，现在怎么做呀，来先看这地方。

我把这页面直接粘出来复制，这样写一个页面吧。

他们这里面右击new一个TML页面，Ph y m e l e f，转过来2V2V装完之后，大家发现了这个页面其实并不是特别麻烦好吧，包含什么信息，第一导入这个标签。

第二告诉你说这是一个text you test，然后呢这有个value，有个each是不循环，还有什么呢，我们这有test，然后object是不是各种各样的引用，这还可以做一些逻辑上的判断。

是不是这个意思，而且这可以做一个循环，这东西这东西并不难，关键是什么，这些数据来自于哪，这些数据在哪看还是一样，你从你对应的control层里面，给他做一个最基本的返回，怎么返回啊。

在一个public string这写一个SIMPLI括号，加一个at request mapping，括号CREMELEFSIMPLITHY加进来，加完之后，是不是可以往里面写我们对应属性值了。

这数值你也没必要自己写，我都写好了，把它拿过来，cl c认为这加一个属性叫model map map。

这是不是少了一个person类是吧，我们定一个person类吧，又一个page，这定义一个class person，Private string name。

Private int age by the stream，真的这东西都比较简单啊，然后写一个构造器，无参的，含参的就下一个set get方法，再加一个TOSTR，好了，这定义好之后。

这个值是不是就有了，OK当你这块写完之后，写完之后就OK了，现在怎么样呢，直接我这是不是启动好了，这边挺好用，重启一下吧，重启一下，感觉有点像以前SARS标签其实还是一样，不管是SARS有什么。

是不是有个东西叫OTN的表达式，好吧，你想一下你在学你在学那个JSP的时候，JSP的时候有什么东西，是不是有个东西叫ER表达式，还有一个叫什么叫egg s t r表达式是吧。

现在呢在rust里面有个叫OGNL，有人用OCN2，相当于你知道stress，很多同学已经不知道这个东西了，好像现在里面就是用了一个TH，其他现在都是什么，就是C标签，P标签是这些标签啊。

用这个标签拿来用就可以了，就这样意思啊，对象导航图语言对。

是这样的东西好了，这发完之后，我们这可以发送一个对应的请求，请问什么信息啊，叫sim lit h y m e l e a f到，从2%ph看，这听到了吗，是不是这些相关的数据我已经全部都请求到了，对吧。

这块你可以给我的页面的做对比，好做对比，对比之后你会看到这请求东西。

就是我们想要的那第一个test什么东西，然后呢引入对应的一个值，把这个值给做一个演示。

同时这里面还有啥页面了，是不是还有我们对应的一个循环链表，而list等于啥等于啥，等于啥，是往里面写出我们对应信息就行了，好判断它是否为空，然后内部等于啥等于啥，真的等于啥，关键就在于什么呢。

在于说你在使用这个HTML标签的时候，你要知道这些属性应该怎么引用，这里面我们主要用两个标签，一个是dollar开头的，一个是新开头的，dollar开头的表示引用的是什么，是对应的一个变量值。

而新开头什么意思，是指的是我刚上面是不是声明了一个变量，叫t h object，我们在这里面这个对象里面的属性，你要想引用的时候，必须要用心来进行引用了啊，这是他们之间的一个区别。

像后面刚刚看到A的标签对吧，在包括号刚看到的波浪线标签，这东西我后面会演示的，在这个页面你要会写明白，我意思吧好吧，你要知道这标签应该怎么进行引用，看到了跟我们刚才一样不一样一样吧，是不是没啥区别啊。

非常简单的一个实例啊，下来之后好好看一下这东西难吗，不难吧，这sim live最基本的一个使用这块之后。

一定要自己做一个演示，这块来听白同学扣个一能听懂吧。

好了，除了这个sim live这块之外，还有什么东西，我再说了，还有标准表达式语言，比如说DOTA变量使用先叫选择变量表达式，这两个东西在上面的时候都已经用过了啊，所以我们这儿不再演示了好不再演示了。

但是你注意了，这个变量在使用的时候，它还有很多小细节在里面，什么细节，比如这第一个我可以把我们的session里面放数据，就说它可以获取到我们对应对象的属性和方，属性方法，同时可以使用什么呢。

Cd s vs local request response，Session service contest，是不是这些内置对象里面的属性，我也能从里面取到，比如说这样我来做一个演示吧，非常简单。

打开我们的这里面。

在我们的请求里面加一个逗号参数，逗号叫HTTP session session，加一个session点，Set attribute，这写一个name，逗号杠三，加完之后你也一样的，这页面里面加一个东西。

P标签TH冒号test，这写一个叫dollar括号，session点叫name，用完之后来，我们现在重新刷新，我们对一个浏览器页面。

是吧，刚才出来了吗，出来了吧，是不是那个对象里面的属性值也能可以获取到，所以它用起来比较灵活一点，比较灵活一点，你可以按照自己的想法随意去进行一个更改好，这是第一个标准表达式，除此之外它在干嘛。

它还提供了很多内置的一个方法，比如说对日期吧，numbers数字吧，string字符串，object对象，array数组list集合，三支配集合，web设备集合。

我还可以用这些内置的这些方法来做一些处理，对吧，里面每个东西都解释了有哪些常用的方法，这块下面都给大家写案例了，好多要写案例了，下来之后，你可以把这些案例拿过来之后好好演示一下。

好看一下大概是什么样的一个效果，ok control层里面怎么往里面复数赋值，放数据我也写过了，我也写过了，很难过去之后好好看看，包括下面各种各样的演示代码，我都写的比较多，写的比较详细了。

所以你有能力好把这些东西全部给完成，懂我意思吧，好吧呃，下午时间差不多了，我们大家来聊聊这么多，晚上八点钟我们还有课，所以一会儿我把这个文档给大家分享出来，分享出来之后，你先按照我刚刚写的那些文档。

先自己去做一下操作，特别是作为初学者，一定要做一下，哪怕你把代码复制过去运行一下，也要用啊，也要试一试，懂我意思吧，刚刚没讲完，还讲什么东西，比如说国际化我们还没讲，比如说我们的数据，数据源还没讲好吧。

以及哦我们估计能把数据源讲完，讲完之后我们就开始讲源码，好给你们讲很多东西，所以一会把这个文档里面的代码，先做一个实施好，做一个演练，完了之后，我们晚上再接着聊，好吧行了，这些东西难吗。

觉得男同学扣一不，男同学扣二，难啊这还难啊，spring boot是不是一般不配置多数据源，我记得上一次是谁问我说，spring boot是配多配置那个数据源多，那个多数源配置怎么配，是是你问的吗。

风声可以配可以配，我这给大家写好了，我专门准备了一下，专门准备了一下spring boot数据源，今天刚学完数据源，找一下大纲，看着spring boot多数据源的一个配置，我这都写好了。

好晚上的时候可以给大家演示一下这个效果好，怎么来切换我们的数据源这块都有，所以你们面试问到的一些点或者自己不会的点，这都有啊，可以随local对，确实随logo，网上看挺麻烦的，比S麻烦。

需要用到spring里面的a OP，需要用到spring OP，还有很多东西啊，这块我都写好了，晚上讲的时候咱们再说行吧，MD是什么软件，这个我给大家写一下，T y p o r n。

那这里面带一些格式啊，看起来更舒服一点，看起来更舒服一点，笔记传到哪里了，传到我们的GITHUB上面去，我一会会往上传，会往上传，这个东西我都会都会给你们传上去啊，这怎么看，对按键也可以弹啊。

看搞一个maven的一个插件就行了，好像是maven插件就行了，行了，今天下午咱们就聊这么多，晚上八点钟准时再见，好同学们，OK拜拜，老师这个中文档哪找的呀，你中文文档你你你你你找就行了吧。

这个这个百度里面都有吧，其实大家发现了，其实我现在不是在百度里面找，就是你看到我们这些中文网站啊，他都在同一个根目录里面叫git book，我不知道这个网站你们有没有人看过叫git book。

这个网站下去之后，你们可以注册一下，好可以注册一下，里面有很多的一些中文的一些相关翻译，这都有要注册啊，注册的时候要需要FQ哇，这只比较麻烦好，这边东西比较多，我基本上如果需要中文文档的话。

都会从这里面搜，这搜好吧，搜一下就行了好了，就这么多吧，OK晚上再见拜拜，对，所有课都往上上传，是的。

系列 5：P65：65、springboot启动源码解析一 - 马士兵学堂 - BV1E34y1w773

🎼。🎼喵遥听话。🎼我只说这一次错过就找不到我这样的天。🎼我就是。🎼想要跟。

🎼一起从此以后，我要握紧你。😊，🎼陪你。🎼真的很犀利，第一眼看到你。😊，🎼刻拿下了我的心。😊，🎼眼里都是你。🎼现在的风景。🎼永远。🎼是你。🎼可技的美丽，轻易就让人入迷，什么道理都没关系，不妨碍，我爱你。

😊，🎼我想要见你。😊，🎼那你。🎼去看繁星。🎼夜空下。🎼新鲜伴着。🎼让愿望都实现。😊，🎼随时随地逃你。😊，🎼爱你想微笑。

Yeah。🎼People say that good。🎼为你right塞 by塞。🎼世界な为た。🎼日と セ が咲。🎼咖啡等一分吹。🎼何去努力看待洁白。🎼我然で。🎼Fly。

🎼When you name me。🎼关注你。🎼太可怕。🎼代て。🎼The味道太哥。🎼The天。🎼可 you know we。🎼多人的。🎼When you连。🎼When you。🎼N。🎼回家。Oh。

🎼Whenever I。🎼えて？🎼可最的。🎼也白。🎼爱越。🎼Will you hold the line。

Every want a Thanksgiving enough in tell me and this house of mine。

🎼Nothing never comes set of once once， tell me where this doesn't lie。

What happens that been with a safe woman saying Will this house of mine stands strong。

🎼That's the price you pay。🎼to。🎼Yesす。🎼the job。🎼Pray。Yes。🎼You敢。🎼You敢。🎼我算白 day。

🎼I me see the in of doctor shot ran without that the name。

🎼feel the glass find the wrong within the boss， knowing we are。

🎼hold to the place not work that place space be that the truth。🎼是。🎼月色。🎼你的爱。🎼face。🎼勇敢。🎼就 make it。🎼这个。

🎼You敢。🎼Yeah you。🎼you a story before it still to say。🎼Re。🎼We all got expectations。

and sometimes they go wrong。🎼把那挽里。🎼The面 so外。🎼でさ。🎼最 tell me。🎼With my head。🎼なぜて。🎼怎么切？🎼かてで。🎼えま。🎼S。

🎼不觉得 why。🎼I want if it really is。🎼Then they don't know。🎼What this feeling is like。🎼Yeah耶耶。🎼Yeah夜。

🎼Yeah。ええ？🎼黑夜。🎼Sry。🎼最。あつ。🎼く。🎼Your friend。🎼哦到最。🎼年 and。🎼我去岁。🎼人你眼的。🎼Deeaation， So with my。🎼They tell me。

🎼With my head。🎼啡平 in mycha。🎼カフで。🎼でまね。🎼Sign。🎼不雪得外。🎼one。🎼Re， it's。🎼They don't know。🎼Yeah。好了，同学们。

咱们开始准备上课了。好吧，能听到我声音同学来扣个一。呃，这节课啊咱们开始讲那个sringboard原版了。🤧贾孙傅我点宝。人有点少啊，咋回事？你把我赶这周赶到哪个房间了，正好是有自己单独的房间，好吧。

雅佳儿O。😊，好了，今天呢我们开始讲对应的一个源码课程。呃，讲原码的时候啊，我刚刚说过了内容容容易引起极度不适。很多同学啊不管自己看也好，还是听原码课也好，听都非常头疼啊，听的非常头疼。呃。

原因非常简单，大家可能很多基础知识呃不具备啊，不具备。所以可能呢呃看的时候非常非常难受，非常难受O没事啊，该去听大数据，听听听听大数据，你选择你感兴趣就可以了，这无所谓啊，只要你听课就好了。行吧？呃。

咱们现在开始讲一下sringbo的一个原码课程。呃，之前啊你们应该听过很多原码课了。问一个问题，大家觉得我应该以什么样的一个方式来看源码啊，这样的话效率更效率更好啊。呃，我不开车啊，我上课很少开车的O。

😊，就是你们有没有自己的一套原原码的一个学习方法，到底应该到底应该怎么做？😡，官网呃官网上看源码就就就看不到啥了。好吧，先流程。O好奇来给大家说一下，其实如果你作为一个初学者。

或者说你作为一个只是应用的一个应用者的话，好吧，你其实对bo这块东西可能不太了解。当我们知道它是什么，是不是另面定义了一堆启动器，所以第一件事先入手的时候，你应该知道了一些基本的配置。先想一下。

每次当我们想运行一个bo程序的时候，都是通过这样一个密函数来启动的。师透这方式来进行启动的。这个启动方式，大家看到了非常非常之简单好吧，感觉跟什么都是什么都没写一样。那我们怎么做还是一样。

在后续看的时候，跟着源码进去进行一个debug，你要看一下每句换的一个代码，好吧，到底传了什么样一个参数进去，一定要bug不 debug之后，到后面就懵了，我看我也懵懂我意思吧。大家这看到了。

我们刚开始调用是一个 application点ro的一个方法。所以你先点到ro方案里面，这打一个断点，我到这边打了。😊，你这儿直打半点，然后我们一步往里边跟好吧，老师带我们写一个责bo嘛。

不带你们写没意义啊，没意义啊。😊，第bu个启动呃，太太说，第一次上课，老师自我介绍一下呗，我姓连大连的连有啥自我介绍的，官网都有。好吧，也许循华去官网看一下。好了，我们刚刚已经打了一个最基本端点了。

现在来右击第bug开始进行启动。大家看到？这块会卡住往回卡住，同时从第一行已经跳到我们这里面的一个ro方法了。方法之后里面又是一个run方法还是一样一次一次往里边点点到里面去之后。

这大家发现了有个什么东西叫new application吧这是创建了一个对象。刚刚我们在主函数里面写的时候，我并没有创建对象嘛，是不是直接以这样一个三数来进行写的，是不是调用它进态方法，但此时你注意了。

除了这样写之外，其实很多地方你可以这样来写的叫。😊，啊，不对，s么被。SA等于另一个 application它是可以创建我们的对象的。创完对象之后。

SA点叫set banner model是不是这里面包含很多参数，你通过这个参数对象也可以进行一个直接调用说这里你可以设置自己的一个参数这块在后面码的时候。

你能看到具体的一个环节体一过稍微了解一下可了之后跳到我们的 application里上翻我强烈大家建议大家一件事干什么，每次再看源码的时候，先把它的一个最基本的注释给看了啊，最基本一个注释看了。

他说了这个class干呢？叫 to引导好吧，并且启动一个spring应用程序对于一个java主函通过va主我一个应程是啥意思说它可能会经过下面的几个步骤引导你启当前你的一个应用程序。😊，分了三个步骤。

第一个叫什么叫创建一个什么东西，叫instance吧，是不是一个实力对象，对吧？哪个实力对象叫application contest又看到当前这个上下文对象了吧。

你上下文么解释你们开始就已经开始接触我们的下文对象了就表示你可以把它理解为一个容器，可以把它理解容器解我上下文这个环境里所包含的一些值都会有一个上下文会放到里面去，这是第一点第二点什么呢？

叫reg说它要注册一个什么呢？叫com line source是命令行的一个属性参数吧对吧后就你可以启动的时候指定一命令行参数我的叫杠杠指号是这方式三种方式叫ref application重新刷新我们对应一个con上下文环吧loading a single是不加载所有的单的。

😊，bes这不用说了吧？然后再往下看叫tbes是不是触发所有的病s啊。所以所以这里面告诉你了，我大概就通过这几个步骤。然后下面告诉你说你有几种请求方式。第一种应应该怎么做，是不是写了一个主要程序。

第二种后面告诉你说了，你可以这样自己进行一个设置，先创建对象再进行设置，两种方式都是可以的。然后下面有一堆的解释，下看一下就行了。我们这不再挨个读了。完正我就我就给一个建议。

每次在写的时候一定要去看这个注释，这注释里面虽然比较少，虽然比较少，但是呃描述事情描述的还是比较清楚的，一定要去看好吧，看完之后来，我们再重新看吧？看到刚刚那个弱方法这。😊。

刚刚那个上面那个解释看懂了吧？应该稍微看懂点吧。OK来往下看热方法，然后完之后，先看它拗了一个对象，用对象的时候，一定要做一件事情干嘛，是不是点进去再点进去，是不是这样有一个主函数的，那一样的。

我们刚刚因为已经选择debug这样的一个方式了，所以你可以一步一步往后点，哎，到哪去了？到这儿了。😊，等会儿啊，我把这些断点给干掉。来干掉啊。重启一下。Yeah。好到这一行，然后呢往里边点点F7对吧？

再进到F7里面再进去加这之后，看到了它就到它的一个主函数里面了。在当前这个构造方法里面，构造方案里面做什么事。第一个叫this二个是一个断言第叫初始一方最后有一个命他发现了里面一共做这几件事。

这几件事很重要，你必须要提前把它进行一个初始好，同时在当前类上面还定义了很多的一些参数值吧，这参数值当你在创建对象的时候。

一定会进行一个创建什是不一定会执行要不要执行怎么判断一样挨这行创建走是把这些前面的一些成员变量值都给你上跳到这一行第一步等于空空空着二步断言也不管第步步关键。😊，这干嘛的？

叫primary source了，这东西怎么翻译啊？😡，啊，主要资源吧，是不是主要资源后面给了一个值说ase at least primary source primary source是谁是我们刚刚传递过来的。

就是我们刚刚写好的那个主类，听白了吗？主类，你刚刚在外面写个啥是screenringbo data application所以当前那个主类就是这里面的东西，直接拿过来。

你可那看一下是不是有一个name叫唉叫ringbo application是不我刚刚好的那个启动类能看这步吧，看完之后这第一步骤，先把它付给一个集合对象，第二步干嘛呢？

叫web aP application点deuce from pass这个是干嘛的，注意了，在翻法里面，这东西很关键，你先听我说，你不用在意说也不要做笔记，我这给你大家写好一个文档大家看一下。😊。

这文章里面怎么做的，能写注释的地方，我几乎都帮写注释了，懂我意思吧？所以你现在先跟着我的思路去走，他是怎么做的，做什么事情。😡，OK所以这个文档一会儿下课之后我会发现大家，你下周自己看啊。

这个东西我们不不不管它了啊。O一样这个文档写的比较多啊，内容大家看镜条很多的啊，能帮你们占的地方我都帮你们占了。所以现在跟着我的思路去走，不要去做笔记没有意义好吧，这干了？

刚同学说了叫解析we类型是MVC还是we就是说我们用的是最基本的点击看一下吧，一个啊，或者是我们的显示式布局或者或者是not它这儿有三个对应的参数，你可以往里边点。

同时也可以怎么做返回直接跳到我们当前一个通法里面去进去交完之后，这是不该判断了，这一个啥意思。😊。

好，后面还有什么 present什么意思？这要做一个解析，这前面都是我们对应的一个常量值。其实这里面你注意了，有个东西叫什么叫dipatcher是有这样一个常量值。

其实它表示是某一个类的完全性名包名到类名，是整体这过程然后这里面也是做一个判断，判断完之后，如果符合里面对应条件的时候，把它设置为什么叫reactive是不是响应式的一个东西。如果它不符合的话。

是不是跳到下面这地方，这返回是n一个类型。如果这两个都不满足的话，最终会返回一个东西这块就一个意义什么意义来设置我们当前这个应用程序，它是什么类型，有三个默认的值，第一个是serv。第二个是响应式的。

第三个就是我们的我们这完之后你可以往下看哪去了，是不便利了，这参数值啊，下自看我们这不做判断了，进来之后是不直接到最后一个所以这返回的值就是我们对应的一个。😊，听明白我意思吗？所以这块大家记住了。

永远记住这个we locationt等于serv late。因为之后我们在环境在上下文的时候，会有很多地方都用到这样的一个参数值好吧，这是第一个步骤啊吧，这个关键比这个点比较重要，这是第一块。

这块做完之后该看第2块了。哎，到这目前为止，能听懂的同学来扣个一，能听懂吗？😊，你知道的东西干在在干在在干嘛吧。😡，就这参数设置好吧，我现在没跟你说那个架子啊，没有意义。你现在说架子也也也不了解。

你就想一下，如果你是初学者看源码的时候，我应该怎么一步往里边跟。😡，上面其实就是一些参数值的判断。因为我现在要创建一个spring application的一个对象了，这样一个对象。

所以此时我要调查构造方法，在构造方法里面，我做了一些参数值的赋值，然后这儿做了一个当前应用程序类型的一个判断。做完之后这下面有个什么东西叫set initial。

然后呢有东西叫getspring factor instance很多同学在公司里面用spring。你对这个方法是不是应该很熟悉了，这什么东西。😊，干嘛的叫获取spring的工厂实力对吧？

这个获取工厂实力是干嘛的呀啊是干嘛的？后面这传了一个类叫plication applicationplication然后呢contex是不是相当于是我们当前上下文的一个初始化的一个类这个类注意不要小瞧它它作用非常非常之大我们可以干嘛呢？

先跳到这里面进去里面去之后往看叫get factor instance是是这样的方法里面再往里边走，这第一步先获取一个器这没问题吧。载完之后第二步往下走，是不是创建一个集合，这个集合干嘛的。

不知道但后面一注释叫us names and ensuresure un to protect againstmin是去除的一个操作。

所以里又是什么是一个et然后往后看者说这一段都是做资源加载的前置校验可以这样理解吗？不太准确，它更多是为了加载资源，没有校验的东西，就加加载资源往下看啊，这里面传一个。😊。

叫springfactor load点loadfactor names这块也一样往里边点，这个t不用我说了吧，是不是刚刚都是传过来的一个参数。

什么参数叫application context吧是传过来了，就刚刚写好那class对象刚写个那个类对象点完之后往里边依次往里边走走到这之后，这有一个名称这个名称也很简单，看到了吧？

看这吧什么plication吧，这其实你看不出来啥，它为什么要定义这样一个类啊。我知道很多同学之前其实你自己可能看过一些帖子那里面说了每次当你在进行加载资源的时候。

它会去我们当前你加载的账包里面读取一个文件，哪个文件呢？叫spring。😊。

然后第二factorory。呃，factortteries有人叫我这个东西吗？😊，应该都见过吧，是不是这样的东西，它是个啥？它可以理解为类似于是一个proper一个配置文件。

在当前这个配置文件里面定义了很多外部或者内部的一些资源来供我们进行加载。那这东西我应该如何进行查看，也非常简单。

往里边找找账包这账包找一个东西叫springbo第一行点这块再往里边点点点到这有个什么东西是不是叫spring factory。你看一下里面定义点啥。

叫ORGring framework eNper load里面是不是定义两个类的一个完全性的名，然后有个spring application listener是不是鉴听器。

再往下看exception report叫异常报告器。再往下看这个东西熟不熟。😊，收了吧，是不是跟我们刚刚你所看到那个application contest，你说la是一样的东西啊，是不是一样东西。

那类边一样的。所以它会去读取当前我们这个文件，把文件里面相当于前面是K，而后面这几行是我们的value值，它会把这些value值给你取出来，这东西也不是我瞎说的？老李同志老师。

你怎么知道它会去里面找这东西啊，你可以把你对应的一个炸包挨个打开。这个spring点 factor一个文件只在两个炸包里面有。第一个就这个spring boot好吧。第二个在哪呢？在autoconfi。

😊。

它有一个同名文件，只有这两个文件里面啊或者这两个账包里面包含这些文件，其他里面是没有的啊，其他里面没有了，你顺便点开一个第3个。😊，有吗？你再点。有吗？没有了吧，是不没有。

所以这里面我需要把这两个文件里面东西给你加载进来。好，大家看到了里面都是什么，就是一些类。好吧，已看到了这些类里面都是什么报名加类名。你看到这个东西之后，有没有一个条件反射，它要干嘛？😊。

我要去读取当前配置文件，读完之后，我根据我们的K值是能取出来一个value的。而后我的value取完之后，一定是一个字符串，对不对？那我根据这个符串，我要生成类的话，O刚才说了反射。对。

其实里面后面我们会看到有很多反射应用地方，它把这些对象都进行一个实例化，怎么实例化，是不是有东西叫class pass，对不对？那个class要 for内。

放内完了之后是不是有东西叫inst这些实例化就搞定了。好吧，但你要知道它是哪从哪来的，应该怎么进行一个最基本的读取，这块也不知是我瞎说的，我们可以来进行一个验证，我关掉了啊，两个文件没啥用。😊。

关之后往这边走，看第一个方法，往里边点点进去之后再走，是不是下面点下面这完了之后，上面告诉你了说这是一个什么东西，是不是一个map结构。😊，把你自己调大一点吧，看不清楚吗？调大一点儿。🤧放着。🤧嗯。

这样好了吗？现在好点了吧。没关系啊，大眼么大点无所谓啊。来往里边看做什么事情。我刚刚说了，这得到的一个名称是什么？叫application application contest对吧？

进来之后通过调这个方法，这个方法之后往下看，这先创建一个map结构，创建完当前map结构之后把它放大创建完那map结构之后干嘛呢？先判断一下这个结果是否不等于空，如果不等于空的话。

直接返回等于空话不做了第二步干嘛呢？叫nU这个东西是啥？一个枚举类是不是一枚举类，这东西大家应该都认识。

然后通过叫class load点ge resource从哪ge resource resource，点进去看到参数了吗？是不是META杠INF。😊。

他会去我们当前的class pass这个路径下面查找当前具备相同名文件的一个名称，找这个文件名称之后，会把里面的东西给你取出来啊，给你获取出来干嘛下面也是一样get system是不通过两个资源路径。

把这西读进来。读完之后没完然这刚告诉你说了你有另外的一个结构是我们的reult了。完之后开始挨个进行便利。因为我们当前所依赖的环境里面有两个文件嘛文件嘛。

以这时候它是一个集合要进行一个迭代迭代完了之后挨个把里面的值都取出来好吧，注意啊，根据什么取是把里面所有的K等于V这样的方式的值全部都拿回来刚我给大家粘出来了啊，这出来看我把那两个文件东西全部粘出来。

好，上面这块就是我们的K值，面就是value把这些K和value的值全部都获取出来，这块就是获取的一个操作获取完了之后没完它要干嘛呢？叫catch点put什么东西。😊。

啥意思？因为你后续的时候啊，需要不停的去加载一些，比如说监频器类。比如说初始化类。如果每次我都去文件里面进行读取的话，这个效率可能会比较低。所以在这一步的时候，我做件事情。

我提前把所有的配置文件都读取进来，然后放到我们的缓存里面之后，当我需要哪个类的时候，我直接去缓存里面读就行了，而不需要从文件里面再进行读取了，懂我意思吧？所以这就是这一步骤的一个操作。

最终会把我们的reult给反应回去。reult就是一个map结构。😊，听白了吧？这个过程应该能听明白完了之后大家看到了是不是到这一步了，这步是完成了。完成之后。

第二步叫get or default获取或者是呃获取或者是个什么一个默认值吧，叫factory type name记这个名字叫什么叫application context，然后in了，把这名字给我记住。

这是不是有这是不是有好，所以我们可以往里边走一下F7进到这里面，然后往下走一个走到做。😊，这是不一个循环结构，我也先面打打断你啊，直接跳直接跳过去啊。😊，走它会进行N次循环。

大家看到了里边多少个是不是有13个我们对应的一个结果集了，是13个吗？是不是13个很好判断，怎么判断？你打开刚刚我们粘出来这个文件，你搜一下里面有多少个K，你搜完之后你会发现里面应该我没记错的话。

应该是15个K因为什么？因为里面是连接两个文件，这两个文件里面某些K的值是重复的。比如说我举个例子，第一个叫plication看吧你往下翻，这是是还有一个再比如说 listener往上翻。

这上还有一个它有一些重复的K的值重复K值会把所有的个value值都放到一起，所这你看到只有13个懂意思了吧？往下走。😊。

回来回来之后，该从里面获取了吧。实际上在此处获取我们参数配置的时候，它从哪读的是从缓存里面读的。记住了，缓存里面读的。所以我们这进去之后，可以看一下吧，点F7进去。呃，退出来，不是这儿再点进去。

看这是不是它这开词容里面叫V等于get什么东西，然后呢，contl k什么东西，然后把我们对应的一个值直接返回回去就可以了。当你这儿返回回去之后，因为你刚刚匹配过来是啥？😊。

是哪个东西叫application context，已经什la吧。所以这时候我们可以做一件事儿，什么事儿，你数一下当前这配置里面几个几个类啊，123455个吧，你往下翻，12一共几个是不是7个。

是不是应该是7个？那意味着我当前这个集合类里面，它返回例子集合就应该是7个。😊。

这没毛病吧，所下面我们可以往里边走走，到这之后往下走一步。😡，来往上看看这names多少？是7吗？你把这个弹出框调大一点，是不是7个对应类，你可以跟我们刚刚这边做一个验证，做一个匹配，放哪儿放这儿吧。

看后缀就行了啊。看后两个第一个叫sing met data什么东西，然后呢肯定是到什么东西，后两个一样吗？一样吗？那意味着我是不是从当前配置文件里面把这个值给取出来了。

而且刚刚好跟我们的数据是不是一模一样的，所以刚刚完成什么操作？😊。

完成么操作是不是就完成了我们整体从里面获取我们数据文件的一个操作。但其实刚刚啊刚刚这块注意了，只是把那个东西给取出来了，取出来类子集合。现在有进行任何实例化操作吗？听我的问题啊，有进行任何实例化操作吗？

😊，哎。😊，怎么怎怎么没说话，没有吧，你没看到吗？是不是没看到，没看到你往下搂，这是什么东西，叫create spring factory instance。这儿告诉你说。

我要开始创建当前对象的一个实力了，它是不是也返回一个集合，折叠集合是一个实力的一个集合。点到上面集合不一样的，下面只有内，下面是跟我们的集合了。所以你依然往里边点进去之后该到这一步。😊。

这边要做什么事情，你看一下这里面是不是我说的反射啊。第一步，先把我们这个names放到里面去，先创一个空制集合TT类型。因为类型嘛你的类型都都不一样，所以这写了一个T战位符，然后开始循环便利。

我们当前names循环之后，第一步叫class点有il什么点 for name吧。一看到for name肯定是啥反射了吧，你点击看一下。😊，往下走找一下啊。拿出来。看这是不是全部都是for name。

是不是告诉你说这内部star位置什么东西，然后找一个 for name好，我们之前用过这个东西吧，class for name直接进行一个反射的一个操作，对吧？获取完之后只是什么？

找到我们当前这个大写卡斯对象，然后呢，获取它什么该构造器的吧，是不是告诉你声明它的一个构造器是啥？有了构造器之后，我再进行什么？是不是实力化类。😊，好吧，所以当你这识理完之后。

这已经变成一个instance了。此时把insance再放到我们刚刚定义好那个历子集合里面。大家想一下，当我这个步骤，如果我已经完成了，我做了什么事儿，是不是相当于我实力化了，呃。

实力画好7个已经存在的对象，是这意思吧，你得把它走一下啊，我们编一下试试吧。第一个先取出来一个值，class等于什么东西，是不是取出第一个取完之后这下下下下来看这inst。😊，有一个知道吗？

是不是已经有一个结果了，因为你现在完成一次了嘛，下面也一样7次，所以要循环7次循环。我们这不看了，我一样的把它直接跳过去了，走跳这这这一行。😊，等一下有点慢啊。嗯，走这么慢吗？诶。😊，就这么慢。

所以这块大家注意了，当你看完之后，你会发现它完成了7个类的一个识别化断点无效。不是吧。算了停了停了松送来，没事。出来声。来往下走。

看是到这一个实化多少是不是7个是不是7个这已经知到我们对应7个的一个值了。所以此时我可以把我这个值直接返回回去。当前返回去之后。

你这已经发现了干嘛了是不是已经有了7个对应值你下拉一下成现都是我什实际的对象了，是都是我们对象。这已得到对象。当这些对象是干嘛的，你现在还不知道啊。

我也不知道你看一下对应什么西就是一堆初始化的一些值地什么confi warning叫配置警告的一个初始化一个初始东西什么西往下看下面什么叫么什么什么东西就有很多这方面一些值啊我知道很同学对这些值我不知道这个干嘛没关系没关系。

我刚刚我了我在这个文件里面给你们写了一。😊。

找起来。咱们来看。刚刚我说了，这里面是什么？是一些contest的一些初始化设置。第一个叫报告spring容器的一些常见错误配置，这是第一个它的作用。

第二个叫使用呃配置那个spring上下文的一些ID的一个值，然后指定初始化器进行初始化的一些规则，设置到什么U门的环境里面去，能给大家写东西，我都给大家写好了。所以你现在先不要管这几个类是干嘛的。

因为运行的时候我也不知道，懂我意思吧。来到目前为止，能听懂的同学扣个一。😊。

你听懂吗？好，没问题。粘完了之后来再接着往上跟跟什么东西，到这之后再做一个操作，叫allocation where order compare，不知道它干嘛了？没关系，这有s shot什么意思？排序嘛。

好吧，我这要进行一个排序操作排下序，排完序之后，把当前这个结果直接返回去。你不要问老师排序干嘛的，我也不知道好，我也没看下这个排序干嘛的。但最反正最终得到一个结果，什么结果，我现在已经把它排好去了。

并且能把我当前这个实力对象都返回回去了。所以一层一层你可以往回走，到这了吧。这样做完之后注意了，只是里面东西，一会儿我们来画图，一会我们来画图好，先看这里面做做做做什么东西，一会儿来画图，好，别慌啊。

会会给你们画图的啊，别慌。😊，好，这做完之后，咱往下看是不是刚刚只是调到里面的方法，里面调完之后该掉外面了吧，是不是该设置到我们当前这个初始化器里面去了。所以往里边依次进行一个点哎呀，调过去了。

也错了来往下看这面做什么事是把你刚刚设理好那些类对象，直接放到一个集合里面去搞定了。这里面其实没做啥啊，其实没做啥，非常简单，就直接放到我们这里面去了好，这是刚刚写好那个那个步骤，来再往下看回过来。

这是做这样一件事情，你放下面这个代码的时候，你看到了跟上面是不是一样，也是get three factory instance，然后呢，plication listener这两东西是不是一模一样。

你看到lister之后是不是一样的去我们配置文件里面要找我们的lister了。几个。😊，1234567891010个吧，你再往下找，这是不是有一个，一共是不是11个我们的说法器啊。

所以你往下找也是一样的，点进去。就是就到这儿了，往回返多少个是11个吗？😡，设是一个意味着我把这个类呃监程器也给创建好了，然后往回走啊，往回走。OK然后再定到我们的lister里面，直接创造一个集合。

好吧，这是我们这个操作做完之后，上面东西都做完了啊，就完成一些参数设置。做完之后再到这儿叫this their main application class，这干嘛的？😊。

是不是找一下我们当前应用程序的一个主类啊，或者一个主函数，对不对？主函数它用的一个方法叫什么dduce命 application class这干嘛的？一个方法，你可以点到方法里面去。

这里面打印了一什么呢？叫new run time exception。然后呢点get，你看到这个方法熟不熟熟吧，你之接前代码的时候，当你看到异常信息的时候，是不是都是通过叫一点，获取到跟踪信息。

所以此时在这里面我们也能获取到我们整体这一类的一个异常对战信息。😊，好，就是说你这个代码是一步一步怎么走的。因为我要找到你的主函数嘛，这里面取到一个集合之后，你也发现了这有个什么叫if命点什么东西。

是不是找到我们的密函数，找密函数之后叫class点 for name，又开始跟踪我们当前这个类来进行当前类的一个初始化操作，或者一个呃当前类的一个什么反射操作，获取到一个大选C的一个class对象。

好吧，来点进试一下吧。😊，过完之后，你往上看后调有什么，是me application contest呃 application class吧，做完之后往后翻是啥？

是我们自己写好的com码是b点thbo data vacation吗？是吧？是不是看到这步骤了。所以这块你应该能看到很多的一个相关信息，相关信息。那这个东西来我们画下图。😊。

来看一下刚刚那个步骤，讲了这么多代码，我们做件什么事情啊，找塞桑。😊，先波它。请简刘龙图。来往们来看吧，它进去之后，第一步骤我干嘛呢？是当前。😊，哎，这咋回事儿？脚启动。当前。也有。程序怎么启动的？

是不是找到我们对应的一个密函数，在这个密函数里面，我包了一层东西。加上一包的啥？是叫spring。😊，对塔。Application。第二啊不对啊。叫苏瑞他呀。嗯。😊，第二。run方法吧，是叫run方法。

调状方法之后，最终你会看到一件事儿往后走。这里面做了什么东西？是扭了一个spring。アプリケーション。就对象嘛，是不是先救他是不是先救他，你要对象之后，你要知道在当前对象里面，我一共做了几件事情啊。

做件事情想一下。做这件事情，我们这写一下。第一步叫一。配置什么叫ressource。loader当然这个值啊刚开始的时候是空的，刚开始的时候是空的，这没关系，你就先小这，这是第一步，第二步叫判断。

什么呢？当前应用。程序的类型，这类型有三种，分别是slate。reactiveative，然后呢还有n，一共包含这三个对应值。证明问题吧？这是第二个步骤。第三个步骤在干嘛？哎，3这个吗？是不是初始化。

或者说获取初始化。气的实力。对象第四步，获取监听器的实例。对象。第五步找到。当前类的。呃，当前应用程序的主类。开始。就行。想一下，这是我们刚刚那个构造函数里面做的这几件事吗？是明有吗用吧？

所有人能看到吗？我刚刚就带你们看这这点东西啊，别的东西还没开始看呢。我说一下再说一下第一个是是他吧，第二个，第三个第四个是不是一共这么多步骤，你把它记住就行了。呃，这个哎没必要记啊，你把它理解到就行了。

当你做完这件事情之后，这块到目前为止能听懂同学来扣个一。😊，能听懂吗？你先按照这样流程去做，这样流程去去做啊，这样这样他。好了，当你剪完它之后，到第二步了。😡，干嘛了？我对象创建好之后。

这个步骤会执行一个run方法。转号码这号表什么意思？启动。😡，嗯。怎么老唠叨？启动。好，因为大家想一下，每次当你在运行，为啥从run time的异常对战信息里面找到主类啊。

来，这你看一下，知道了。是这号法里面。😊，我俩打打锻点试试啊。呃，我找一下。走。漏的走走走7个。进到里面去往下走，这是一个什么叫new timeex什么？这有一个叫get。你往那看，这get干嘛的。

你点看一下，里面有01234567，对不对？你看一下后面它都关的什么，跟你当前类里面所在的那个代码里面多多少行吧。现在多少行，279行，你找一下279是我们这一行。😊，对吧你往上翻叫274，270在哪？

你往上找，是不是刚刚你调过来的方法，你调过来之后，你往上翻253，你往上找。😡，是不是刚刚是从这行调过来的，253完之后，是不是有1226，你往下翻，一步一步找到之后，找到最后一行。

是不是有东西随便背了第十一行，第十一行找一下。😊，是我们当前一类主函数吗？是不是找他了？😡，这就直直直接找到了，所找到主函数时候，意味着我现在可以开始执行了，就这样步骤。好，所以你刚刚看到程序里面。

它会一步一步往里面接着往上走吧，挨个匹配。如果是命的话，如果是命的话，他就可以直接返回去。看这返回去之后，他找道这个单线类了，然后把当前类进行一个持际化操作。

因为我们并并没有创建这个类的一个几那个对象啊，所以这直接进行一个class，然后返回去就行了。就这样步骤啊，这我啥很难理解嘛。😊，好吧。异常在那这样就是这样的，这有啥可看的，对吧？好了。

操作完之后来往下看现在我是不是这个对象创建好了，创建好之后，我这是不会掉一个状方啊？当然后面要传一个al参数，你们在写设计程序的时候，有写过这个X参数吧，这都写什么？比如说叫杠杠，然后加一个叫ser。

😊，点port等于8081，是不是也指定我端口号，以及其他的一些参数配置，是不是都可以用杠杠的方式进行写。对吧？到现在啊我们这程序里面什么参数没写没写没写没关系。点F7进到我们当前这个ro函数没去。

到这里面这才是我们整个应用程序启动的一个过程。这个过程给大家说一下，是非常非常之麻烦的。好吧，里面涉及到很多的一些点，这些点我要挨个来说，你好好听，这才是我们的核心。😊。

第一个参数这是空，不用管它了，以后我们都直接忽略我们三数要做事儿。第一步干嘛呢？叫star stop watch，是啥东西啊？什么叫stop watch啊？😊，我可能不知道它干嘛的。但是你想一下。

你作为一个应用呃的一个应用程序，你每次启动完之后，你看到都是什么先打印一个banner，对不对？打印完我们对应的一个banner之后，后呢我打印一些异常信息正常日志信息。

打开日志信息之后会给你一个时间嘛，这一个时间就是用来计算我们当前时间的，你点进去你会发现非常简单，这this往里边点这是它出现好对象了，好吧。

就给了一个this这是一个什么空的字符串I值是空字符串完了之后这东西叫一下这个东西叫star吧，点击star这是star点进去你看都什this name不等于空当是不是空字符串空字符串并不是空好也不一样的。

如果是空的话，包抛一个异常不是空的话，计算一下告诉你说当前任务的名称是啥同告诉你说开始的时间是什么时间叫s是统计好我们当前应用程序的一搞定了是不是这样一个值。😊，因为它要计算什么？

计算你当前整个应用程序，你在启动的时候，它所浪费的一个时间啊，所浪费的一个时间，或者说所耗费的一个时间。这儿大家注意一下就行了啊，注意一下就行先生，就是一个时间东西，别东西倒没啥啊。

它为什么计算时间不用说了吧，看一下你启动东西用花多长时间嘛，对吧？完之后往下看这这样步骤很简单啊，不多说了。再往下看第三个这干嘛的。

叫configurationable application contest等于啥，这其实干嘛的，就设置是我们当前这个the应用程序的一个什么上下文环境。当然是现在的上下文环境依然是等于空的，也等于空。

什么都没有做设置啊，任何事都没做，不用管它。然后往下看第二个什么呢？叫。😊，大家叫exception reporter是个异常报告信息啊，所有人应家都知道，每次你在启动你的用程序的时候，有可能会成功。

有可能会失败。而失败的时候，我们是要把这些信息给汇总回来，所以当前这个report里面啊包含的就是你在程序启动过程中啊，启动过程中，你报的一个错误，会放到里面去，所以它出现一个什么创建一个集合。

当然现在只是new了一个ra，你别用管它如果你启动不 to的话，这对象没有用了啊，没有用了，懂我意思吧？这是这一步再按上第三步什么呢？叫config properties，这个东西也很没用啊。

几乎一点用都没有，它干嘛的？它作用也非常非常简单，你往里边点一下试试啊，走看它作什么事叫system点 set properties，然后呢，这给了一个参数值叫java点AWT点。😊，然后呢。

做完之后再来看第三个叫sytem点ge properties，也是这样的一个值。比是说我现在要设置这样的一个参数值，把当前这样参数值设置为什么？设置为t。在我们的windows环境里面是不需要的。

但是如果你在你的link环境里面，因为大家知道link环境的时候，你有对应的键盘吗？有对应的屏幕吗？有这些东西吗？😊，是没有这样的一些外部设备，是没有这样的外部设备。你说老师有啊，我自己可以连啊。

你连是通过远程进行访问的，并不是这些设备里面直接包含的懂吗？你在你服务器上装过显示器吗？😡，涛同学。你不去装我显示器啊。😡，没有吧。好吧，所以这里面只是说我在绘的，因为他用的什么，用的是AWT吧。

AW大家应该很熟了，现在可能没人学了，但这个东西大家应该很熟，是不是在Java里面又做了一个图形化一些东西。所以这块做这样一个参数的一个设置，目的就告诉你说，服务器里面啊，如果没有那种呃鼠标了。

屏幕啊这样一些外部设备的时候，我可以进行一些图像的绘制，就这意思好，所以这块我给大家做解释了啊，大家能他看一下吧。你找一下。😊。

23。找一下。看这儿。这设置系统属性啊叫java点AWT list的值默认为tro，用于运行ha list服务器是进行简单的图像处理啊，都应于什么？叫缺少显示器，然后呢键盘和鼠标识的一个系统配置。

很多监控工具如Jconl啊，需要的话把这个值设置为t就完事了。它对我们当前这个应用程序其实没有多大影响，它就是只设了一个系统参数而已。所以这你稍微记一下就可了啊，稍微过一下可以可以了。

O这个程不用说了吧。😊，不用说了吧，到这儿为止，来能听的同学扣个一，是不是相在就是一个前置准备环节，我们再来画一下图吧。😊，想要做一件什么事，装技能之后。😡，这28左一下。第一步骤叫设置。我是记录。一。

我这个键盘咋回事？设置启动时的。启动时。的时间值。时间。吃底又不着。然后呢，做完它之后。第二个。想一下刚第二做什做做什么事，就设置一下我们当前这个康t词对象，或者说创建。这怎这怎么事啊？好麻烦。

这个突然是这样。那。设置叫contest。应用。上下问啊，这都比较简单，这是第二个步骤啊，这是第二个步骤。然后第三个步骤干嘛呢？是设置一下我们的异常报告器。3。这是一常。泡高器。第四个步骤。

是这刚刚是不是上面这第四步是是不是它？然咱往家看干嘛了，是设置一个第四。我疯掉了。设置。java点儿AWT点儿。他的list系统参数。啊，喂处。cttrolM可以切换。没有啊，好，不管他了。

这是我们前面这四步要做的事情，对不对？这四步啊做的事情都比较简单，都从那挨个练下来的。😊，然后画一下。第二步。OK这是四步骤，前四步做起来还是比较简单的，好吧，或者说它几乎没设的啥。

但是从下面这步骤开始就比较麻烦了。好吧，这个步骤相当相当麻烦。其实我们看一下之后也非常容易看到说什么呢？

叫spring application wrong listener listener等于get wrong listener，你看完它之后感觉没什么感受，干嘛呢？

说获取我们的run listener这样东西，这个run listener是什么是什么是什么玩意儿啊？啊，这东西怎么看到呀？😊。

啊，分判断。怎么做这个东西吧，先想一下它有什么样的一个意义啊。其实你非常简单，我们可以做一些什么事情。你可以看一下，刚刚你看到前面这个类，它是干嘛的，点进去他说了叫 collection of什么呢？

叫spring application listener这就是一个运行时监器点到这个监听器里面这告诉你解释说lister什么呢？

for the method是不是告诉你说我要监听我们当前这个sp这样一个应用程序，对吧？然后说了这个spring application listener是一个什么呢？叫加载，通过什么呢？

叫spring factory来进行加载，并且应该被声明为成一个什么呢？叫公共的构造方法，然后呢允许接收一个什么呢？实例，并且有一些什么ring型的一个参数，就告诉你说它就是用来干嘛呢？进行监听的。

只不过前面加了个S之后它变成一个对应的集合了，变成一个集合了，这是一个集合，里面放了什么放就是单一的一个视例对象所以这块明确。😊，而且这个类里面也明确告诉你了，干嘛呢？

他说这个类必须声明介绍一个什么叫s application的一个实例，同时有一个sptrain的一个构造参数，把这块稍微记一下啊，稍不稍微稍微听一下，就刚点开这儿啊，你找一下里面多个方法，我们找一下啊。

😊，可以来看一下。呃，哪去了啊？它是个接口是吧？这儿没有是吧？它这个它它它是个接口啊，这个往往回返往回返。后面这是有个方法叫什么叫get listener run listener吧，点进去点完之后。

这就告诉你说返回这样的一个集合。这个集合啊其实也比较简单啊，其实比较简单。但是上面这不简单了，看下传参数。

第一个叫spring application class第二个叫str点 class这我们刚刚说的吧？它接受一个spring application的一个类一个class对象。

同时接受一个 string参数，这前面说东西往下看看始new了这个new这非常非常麻烦啊，非常非常麻烦啊，为什么说它非常非常麻烦啊，原因非常简单。

里面有一个new spring application run listener这样一个对象，同时还有一个什么叫get spring factory instance。

你是不是又看到这东西了你看到这东西，你觉得你熟不熟？😊，啊，这能熟吗？在刚刚我们所看的原码里面，你有没有见过类似这样的东西？😡，你见过吗？😡，有印象没？啊。😮，没有。见过吧。

哪见过我们在创建当前这个spring application对象的时候，你再往里边注入我们的初始化器和我们刚刚那个lister的时候，是不是看过这东西，他调的方法是不是都是同一个方法？

所以你告诉我这个步骤是在干嘛的？😡，又要干嘛呢？😡，对，7加11净音数字7加117个表示说我们的初始化器11个表示我们的监听器对象是不是这么东西？那这儿又用到它了。那很明显。

我又要从我们刚刚那个spring factor文件里面，是不是加载某一个类进来了，怎么加载是不是等于叫spring application wrong listener找它了，一样。

你去我们刚刚配置文件里面，你找一下有这个run什么东西吗？往上看是不是叫spring application wrong listener，然后这里面它是我们的K嘛，它返回的value值等于什么？

等于叫event publish，然后呢run listener。😡，是不是相当于一个什么叫事件发布的一个运行时监听器。那很明显，我们这拿过来之后，我所得到的一个对象。

哪个对象是不是刚刚说好了一个对象叫什么叫even精值啊，叫even listener是得到它得它之后这又干嘛首我们当前这样一个对象了。所以此时你点进去看这个方里面做成，首先把er forloger。

第二个是把我们的lister给放过来，这看完之后又蒙了。老师这个lister是啥listerlister是不是就你刚刚传进来一个对象，就刚一个eventprun listener吧。

把那类直接给他传进来，传完之后他又构建了一个什么叫spring application listener的一个对象，是不是通过它来做做这件事情了？你大家想一下。

刚刚这个方法里面我到底做了一件什么的一个事情。😊，把什么样的事情？😡，想一想。是不是就告诉你说我创建了一个spring application装 listen的一个对象，好吧。

这个对象里面它包含了一个监听器对象，那个监对象叫什么？叫evenvent。😊，Publishing。然后呢，叫啥来着？啥啥啥啥技术啊。

找一下。是不是叫pubationronner，是不是只要当当前这个这个对这个这个这个监定器了，这个监听器它有什么样的一个用处啊啊，它有什么样的用处啊？注意了这个监定器的用处其实非常非常重要啊。

非常非常重要。为什么这么说？我们可以依次来往这边走走一下试试啊，刚刚底八到哪儿啊。😊。

这哪儿啊？哎呀，这还在哪儿呢？

看这儿是到这一步了，到这儿了吧，当刚是不是获取到这个对象，这个时候它获取完之后，它有且仅有我们这样一个值。然后要点点我们的这块往里边走完之后往下翻，看你listtener，它返回的值是多少值。

找一下我们listtener，listteners。😊，感谢。几个值。一结果值叫evenvent listen吧是不这个步骤里面要做要做这样的事。我就说我把刚刚那个天天器也放到里面去了。

这放完之后没完没完，因为你放进去没啥意义，它就是一个对象，问题是我要把当前这个对象进行一个star了。你一看到staring学们就知道老师我很明确它就是用来干嘛的，用来进行一个启动的吧，是启动的？

那他要如果进行一个启动的话，我应该怎么找它呀，非常简单，点一下我们的staring往这边走啊。F7大家之后大家看到了这是一个什么操作。😊。

里面是个东西叫for for循环吧，是要循环我们刚刚写好那个list their listener吧，这个lister是谁呀？😊，listener，你看上面这它上面这个类是哪个类。

这叫th application wrong listeners。我刚刚说了，这里面有两个对象，一个叫th application wrong listener，还有叫listers，是不是加一个S。

这是一个集合。那个集合里面现在包含几个元素，是不是且仅包含一个叫疑问的pub wrong listener今天开始进行一个循环操作，往走。😊，一循环取到第一个值。

even publishublish run是不是取它取环之后，这又有啥东西，是不又开始进行一个整体的启动过程了，是不是启动了，这启动怎么启动一样，点进去到这儿了，到这一步之后，很多同学懵了。

老师这是个啥，我压根完全看不懂这样一套东西，这儿如果看不懂的话，我来问一个问题，在我们的spring里面不是spring book啊，在spring不在spring里面有没有一个事件监听机制啊。

有人知道吗？😊，有没有听过这东西？😡，对，事件发布机制行。事件发布机制在sp里面有听过吗？😡，听过吧，对吧它是什么样一个套路啊，或者说它底层到底用了什么样一个方式啊。😡，又什么东西？

是不是就用了一个最基本的设计模式，叫什么设计模式，叫观察者模式吧。哎，有有人这样的东西吗？观察者模式有人听过吗？😡，听过吧。你们应该听过这东西啊。😡，来知道扣一，不知道扣2。😡，是前置通知这些东西吗？

大部同学啊，你如果之前了解过或看过的一些源码的话，应该是知道这个东西的。里面就是观察者模式。如果大家对观察者个模式不太熟的话，回调对，就是回调，就是回掉之持。大家如果对这块不太熟的话，下去之后。

把马老师之前讲那个设计模式这个东西，好好看一下。如果你觉得还不太舒服的话，怎么办？我这给大家推荐一本书啊，这之前我在基础班的时候给给大家发一本书叫设计模式。呃，这本书啊叫设计模式之缠。

但是比呃外面卖了一个书要好很多。为什么每一个设计模式里面都给你举了一个例子，然后里面有代码有类图，他通过这样方式来给你进行解释的，告诉你这块东西干嘛的，然正我觉得这本书啊还挺好玩的，为什么？

因为里面举的例子特别好，他这观察模式干嘛的，说了一个韩非，然后韩说一个韩非子说一个李斯好吧？说几个人通过这样方式怎么一步步进行迭代，迭代完之后达到什么样效果，有代码的一个最基本实现。听白了吧？

下去之后我一会把这个书共享出来，你们可以给大家好好看看，好好看一下这东西。😊。

呃，设计模式其实说白了我们平常写代码的时候可能用的比较少一点。但是你在看原码的时候，你会发现很多原码里面都用到了我们设计模式。你如果混内设计模式的话，你的理解会非常怎么说呢？非常轻松。😊，懂我意思吧？

如果你模式你模式可能看起来稍微有点难受。headd voice怎么样？那本书挺好的，哪一系列书都挺好的，哪一书挺，那个书就是里面有配图啊，有什么东西，我觉得还还差不多。😊，啊，大化设计模式没必要。

你就看我这本书啊，这这个书也不也不多，363页里面就一些设计模式，主要代码占了很多的一个，你可以看一下，每个里面都是一个小小故事，策略模式刘备要娶回家能回娶老婆了。

走之前诸葛亮给赵云三个匹能妙计说是什么什么东西，然后呢告诉你三个魔戒是啥，然后告诉你代理模式是什么东西，代理模式举一个说西门庆找潘金莲，潘金莲不好意思答复来咋办？找王婆子代理，然后先程序这样的。

定一个woman什没个爱子为子们，happy with子们，对不对？这里面都是个小故事，就通过这个小故事能非常轻松，非常简单的告诉你说这个设计模式有什么意义。😊，啊，单立模式多立模式每个地方都是一样的。

比如说看那个丹利，告诉你说皇帝是不是这样的案例，再比如说工厂模式告诉你说女娲补天。你懂历史干嘛？谁让你懂历史了，你去看看里面人我就举举这样的例子啊，工商模是怎么做的，是不是创创建实力对象。

女娲补天女娲造人怎么造人？第一次考，你这滋字熟了，往地上一扔标一个白凳上没考熟。第二次。😡，考过头了，变成黑人。第三次，然后呢正正好黄种人是不是这样个案例？对吧所以下去正好把这个东西好好看一下。

然后我觉得这这书还挺好的啊，基本上每个地方都是一些案例，每个小案例，然后直接拿进去看一下啊，晚上躲被窝抽偷看。😊，可以，你要有这个兴趣，你就偷偷看吧，行吧？呃，一会儿我把这个书给大家共享出来。

你下周我把这个设计模式好看看。呃，如果有时间的话，最好还是把马老师那个视频再翻翻啊，再翻一翻。行吧？好了，我们刚刚讲这块了啊，刚讲哪了，是不讲这块了啊。😊。

🎼一会儿我上传到我们gtthub，上传git upub。所以你要把实体模式东西好好看一下，一定要看。不管你现在工作多少年，如果你想看原码的话，这块一定要一定要看看了都忘了，原因就在于你这些案例记忆不牢。

如果你把潘金量这个东西看了之后，你一定不会忘的，行吧。😊，好了，我们刚刚看到这块啊是要进行一个监听器的一个启动了啊，这块我们稍微休息一下。好吧，生钟回来之后，我们再接着讲整体这个启动过程。

把整体启动过程OK。😊，快睡一觉。Yes。看爷们看到现在感觉怎样懵吗？😊，本身还由于涉黄被封，先丢群瞅瞅。行。

怎么事现。

好，你们瞅一下吧。呃，我在一步一步带你看啊，但现在就是带你看的时候，你会有一种感受，什么感受呢？我每一个步骤好像能看懂，但是我整体串不起来啊，我是故意这么讲的，我是注故意这么讲的。呃，讲的原因非常简单？

大家可以看到我在这个pro2上其实给大家之前画了一张图，就整体这个流程图，其实我是有画的，每个里面做什么事情？我是有画这样图的，为什么没给你们先看这样一个东西，😊。

好，为什么先看？因为这东西只有你看了源码之后，你才能把它给画出来啊，你才能把它给画出来。但是我觉得作为一个初学者，你在刚开始学的时候，你一定没有这样能力，没有这样能力。所以你先捋原码。

等我把这个流程捋完之后，我们再回过头来画那个图的时候，你就感觉哦，原来这么回事。然后你再去看一遍源码，你就知道这东西是这么搞的，你就清晰了，懂了吗？没有人上来的时候，我再看原码的时候，我刚才啥都不知道。

我一啪啪给你画个流程图出来，这不可能。😊，懂我意思吧？所以我来给你讲什么，讲我在看原本的时候，我是怎么看的，我有什么样的一个方式，我希望你们把这个方式给学会了。这个东西呃。

以后比如说你要看其他样码的时候，也是这样的套路，懂我意思吧？😊，北京市内不是不允许抽烟吗？我们办公室允许。然要不允许抽烟的话，我跟周老师就别活了。这这日子没法过了，就。🤧嗯。老婆跟香烟，你选哪个。

那肯定选老婆呀，你疯了。现在现在娶个媳妇多难啊，对不对？那就别抽了。我媳妇不管我抽烟。我媳妇不管我了。前天看周老师头发长出来了。你开玩笑吧。为了宝宝还是少抽少抽点吧。呵你们开始劝我这个事了，是吧？😊。

我媳妇儿怀孕之前戒了半年烟。后来就就又又又又又又抽了。老师，权限管理数据权限管理系统数据库怎么设计好？这个现在是这样的啊，如果你要做权限管理的话，最logo一种方式，RBC3张表功能角色什么之类的好。

复杂一点的话，可以用一下s signature或者用一下sro。这个这个现在不是什么难点啊。你要大学生的话，你要想在学校做项目的时候，用那个全员管理的话，就设及个东西叫RBAC。

有那有RBS你可以搜一下。但是现在生产环境里面没人那么用，好吧。这是我的毕业设计企业课题。呃。之前那个在一期架构一期的时候，明哥做那个无质化办公系统的时候，里面就有RBAC啊。

你看一下那个视频之前讲过的。这三个一般适合做权限这块东西。Yeah。安全框架是不是也是这样涉及数据库表，这不一定啊这不一定啊，这要根据你公司的业务来决定啊。🤧嗯。这些框架我知道，但是自己设计数据库会。

你就这样创建。首先你有一张用户表，然后有一张角色表，然后建一张第三张表里面存两个字段，一个是用户ID，一个是角色ID每次只要操到这个关联表就行了。其他表不用设计，是最low的一种方式叫RBACC。啊。

这个东西你要想用ser或用ssp city的话，就可能稍微复杂一点。要像token这样东西。啊，这你有问题的话，下课我们单聊吧，先感叹号好吧。

过来还在的同学扣个一，我们接马讲啊。😊，うん。营化东西还是比较多的啊，一化东西比较多。好来，刚刚我们看到这波了，这播干嘛呢？是不是要进行一个监听器的一个启动，哪个监听器大家还记得吗？😊，还记得吗？

哪个监听器是不是有是不是有一个东西，有一个东西叫什么叫event。😊，然后呢，叫呃publish。然后呢叫 listener吧我们刚刚传过来是不是这样一个东西好，传过来这样一个参数好吧，你记住就行了。

先把这个参数记住。当你传过来这样一个参数之后，然后往里面看这样个东西叫什么叫this什东，后什西我看干嘛的但你发现你可以里进行一个点击这里面创建一个什象叫new又看到了第二个东西叫 event是不示说开启事件或者开始事件这个事件干嘛的。

我还不知道我还不知道事件干嘛的。但是我先记住了，它先创建好了这样的一个对象，你可以把这个对象点进去看一下，它要掉了一个最基本的一个构造方法，学往点是不是就设了一个参数，这东西都没有了。

就这块其实没有什么核心的一个含量，就告诉你说我创建好这样一个对象，创建对象之后关键是什么，在这个方法里面你可以调这个方法点进去看一下这里又开往里边掉。😊，这是是处理一个什么叫re啊，处理的一个类型啊。

后处理类型这别用管它啊，这不重要点进去你可以往这边走，是不是到下面的方法里面去了。到下面这个方案里面去之后，这有一个t类型。

说我刚刚通过这一个参数来进行一个最基本设置设置之后这有个东西叫下面之后这是不是有参数告诉你类类一个叫plication event是你刚刚创建好一对象吧刚刚创建对象告诉你了哪个even叫plication event。

后面告诉你说是不是还是我们的一个对吧？你先告诉你现在要记两个对象了啊，第一个同学们说的ub类似哪第二个叫application starting event就是有监听器像有监我们监器一个事件。

这已经有一个事件叫plication说完之后你往下走好吧这什么执行器好像没做任何事情你可以看一下有东西吗？这是不是等于空，所以他现在回来之后，这个就等于空的等于空之往这看。😊。

get application listener这东西见过吗？😡，有没有见过这个get ofplication listener，有没有见过这样东西？😡，见过没？那老师，我没见过呀，没见过吗？你想一下。

刚刚在我们那个spring啊，spring那个plication这里面的时候，我们在调那个run方法的时候，你有没有见过类似这样的东西？记住啊这多少行，134行吧，这134行，你可以往上翻译一下。

我们找一下。😊，刚刚写了一个宾语，看这儿这里有类似的叫get wrong listener了，是不是这有类类似那似？刚刚134行是不是也是获取到我们刚刚现在类类似于这样的一个间间器东西。哎。

134行哪去了？好在这儿。😊，134号哎，哪去了，找到了。看说这块这不也是一个get什么？er？直不过这又换成什么了？换成get application listeners不是在这里面这个时候问题来了。

它返回的时候一定是一个什么是一个lister的一个集合要然话要不的话不会用我们对应一个循环的那问题了，这个集合获取完之后它应该是个玩意，应该是个什么东西这块我又应该怎么做一个最基本的判断啊。

怎么做判断能做判断？去判断也非常非常简单，非常简单关键就是说你要看一下当前这一个方法里面做什么里面做什可往点下试试F点进去你发现了这什么西even获取到我们的些资源后看啊啥是不还是plication还是当的even没有关系没关系下走点看下是不告诉这没啥变化下走这告诉你说当前这样一个对象之。

😊，啊，往下走，它代表是不是还是我们的一个类型，这都没变化。这个东西来了，叫listener catch k catchK等于什么呢？

你有一个listener catch K是不是一个缓存的一个监定器的一个K的一个值。这个值是用来干嘛的呀？😊，法院干嘛的？😡，大家想一下。

我们刚刚其实在很多地方已经建成建到我们的listen listener了吧。刚刚有1个11个lister，然后呢，除这11个之外，我在里面我又放了一些其他东西。比如说第一个叫even。

刚刚才们看到了里面有一个事件叫application starting event，是至是我们这条这样一个一条路线嘛。来在application呃。

spring application这个对象里面有11个监听器，同时我在进行运行的时候，我又创建了一个什么叫evenent publishublishing，然后run listener，对吧？

在这里面有建行了一个事件，叫spring。😊，然后呢不是叫application starting event，这是事件，那是监听器。就现在我们现在一共多少个监听器了。

一共有12个11加刚刚外面的一个一共有12个监听器。同时有一个事件叫spring呃，叫application starting event把这个名称先给我记住啊，先给我记住，一定要记住啊。

因为不记得的话，你后面跟着跟着可能就跟乱了啊，可定跟乱了，懂我意思吧？那跟完之后，我们下面再要做什么事情啊，其实就是下面这段要处理的一个核心代码，是不核心代码。

这儿创建了一个lister catch key，它是一个集合，扭出来一个集合。这个集合啊，不是不是不集合，念出来一个对象啊，念出来一个对象，当这个对象有了之后，我现在在干嘛了？叫this点什么什么东西。

点get。😊，我说该get了，你要想get一定是干嘛？是从某一个地方开始取，这东西是啥呀？😡，这什么东西是啥？叫retri catch什么？你哈希 map是一个哈希 map吧。我看到了它是一个集合。

那意味着它是不是相当于是一个缓存。我要从我们当前这个集合里面来获取到我们刚才的数据，但是这个集合里面数据是我什么时候来进行创建的呀，或者说我什么时候往里面放我们具体值的，这个怎么看，很好看啊。

你点下第bug找一下我们刚刚这个对象，this叫retrive catch，看里面现在东西吗？😊，里边有什么东西没有吗？因为我们在执行过程中，你从来没有执行到任何一个步骤给它付这个值嘛，刚开一定空嘛。

既然是空的话，我可以挨个往下走啊，挨个往下走走到这之后能取到这个值吗？肯定取不到，所等于空等于空判断不等于空，回去了那我等于空我还能吗？不能了吧。

就下面要做一些判断判断this点 load等于空然后呢 catch save什么东西然后呢什么什么什么意思ca save什么东西是就是一个逻辑判断啊，刚刚我们这面等于空下面这块判断的时候一定要能进去吧。

是这是一定等于处的等于出完之后是是一个 single东干嘛呢？不知道啊，但我这知道有什么什西这是一个什么斥锁吧是互斥的一个锁这单词应该见过啊。

应该见过为什么这要加锁我们先不管管什么加锁下走叫this点 catch我还那句话，里面有东西吗？😊，没有吧往下走，这时候你看看看到了这个reserve这个值多少麻烦啊。😊，这个。看那是不是还是空子值。

那意味着我现在还没取出来，没取出来，没关系，再往下挨个走，从这之后你有一个listener什么东西，是不是开始你就这样一个集合了，当我这样啊你这样对象。

当我你了这样一个对象之后没完你只是说我把当前这个对象给我创建出来了。但是当前对象里面我到底要放啥呀，还不知道吧，你不知道放啥没关系，这个参数你看在哪用了，是像这用了，像用的时候怎么用？

listener什么东西，是不是开从里面开始加载我们对应一个数据了，所以往边走这之后点F进去进去到这之后往下lister等于什么东西吧。

一个集合之后有er listener又是ign下看lister等于什么。😊，等于什么东西等于newlink的 hasy set没有毛病吗？没问题吧？这就是新思集合。这个集合完了之后。

你往后看叫this点default retriever。这个defaultr是谁？你帮找一下this default，这里面有东西吗？😊。

找一下第二application listeners往你们看这个东西熟不熟。往上翻，你看里面这东西这啥12345670。123456789111，这11到西收不熟收吧？十1是在哪呢？

是我们在刚刚那个application。😡，里面我是往里边注入11个这样的一个监那个监听器，这是我刚开始创对象的时候，第一步是家来的。

所以此时是意味着我把我这11对象放到我们当前这个lister里面去了。那同样list就把些对象也放到里面去了。

这没问题吧是没问题完之我开始接着往下进行一个查找完之后你往下翻这是不是开始进行便利了list等于是不相当于是我们的11个监听器对象。

然后呢便利的时候这又做了一个最基本的判断逻辑什么说if就我是否支持这样东第一个已经取出来了udud什么监我不知道干没关系下这开始进行一个支持了吧？你可以点个port里面看一下这里边干嘛的。😊，干嘛呢？

他是不要进行一个判断了，是吧lister一of等于他，然后listener等于返回他，要不要返回他。所以此时我们最先或者说最应该要看的是一个什么东西啊？😊。

我要不要看一下当前这个类里面的一个最基本的继承关系，我能看一下吗？能看吧？是吧，这继承关系我该怎么看？你找谁，你告诉我。😡，你找谁？先找到我们刚刚我定义好的那个类，刚我定义好是不是这样的东西。

是不是这个类啊？对，然后呢，这时候你右击这有一个受。diagram看这这往上继成什么叫aler的，然后有东西叫thre an application run listener，这不是它有一个继承关系。

😡，这这这情况能看能看明白吧？这种传过来的一个事件嘛，对吧？传过来这个事件之后，你再往回返。😡，我反反到这儿到之后，每次是要把我们当前那个lister对象给你传出来，是不是传出来，成型之后。

我都要做一个最基本判断。所以第一个传关是啥？叫c found，我们找一下CLOUD。😊，是不是当前这样一类这样一个这一个哎。等一下，往后看这里面有一个东西啊cloud found什么东西。

procesor，对吧？你可以点到我们当前这个类里面，在这儿这块完了之后，你又可以看一下我们当前这个类的一个集成关系，关系有了吗？😊，有了吗？往这看啊，这个类它继承于谁？

首先继承一个order是个排序的东西，不用管，然后继成谁叫post processor，这不用管往这看，这儿有个啥。😊，这啥叫application listener嘛。

是不是你终于看到一个lister这样一个东西了，它是不是也是继承于它上面定义好了一个接口嘛。所以此时当我来回跳的时候，我会做一个最基本的判断。也就是说这里面要支持一下，点进去这判断判断一下。

我刚刚传过来一个lister，它是否是归属于这样一个对象了。如果你是的话，怎么样，是不是把似返回。如果你不是的话，我是不是要创建一个新的这样对象，然后把它给放进去放完之后，这是不是做一个判断。

判断完了之后，把我们当前这个值给返回去吧。所以这块只做一个最基础逻逻辑判断，这看说了懂呃这是这怎怎么过来叫决定是否给定的监监持器，然后呢支持给定的事件。

比就说我要判断一下那11个监定器里面因为我传一个什么事件，还记得吗？叫plication。😊，然后呢starting，然后呢even问他们还记得事件不？😡，哎，这个事情还记得吗？来这同学扣1，还记得吗？

是。记得吧？对吧，那我现在要干嘛？我是不是验证一下，我现在这个这这1这11个接听器里面有哪些接听器是符合这样的一个规则的，或者说能监听这样一个事件吧。所以此时是不是做这样一个最基本的判断，对吧？

你往回反反反这块来后走第一个运行支持吗？不支持吧？往回翻走第二个进来之后一判断支持吗？也不支持，第二次，第三次不支持第四次看这儿支持了吗？支持了吧？

这接来有什么东西叫loin application listener这不是当前这个类似er，那现在看一下这个list似er。😊，叫老给。appplication为什么？点去之后，我们这儿可以看一下。

这儿有一个判断，叫even instance application starting event是不是会判断一下我当前这个事件它到底归属于什么样的一个类型。如果你是这类型我是支持的。

大家看application eventpre event applicationplication prepare event，然后还有什么呢？叫contests的clo event。

大家看到了这里面是不是有很多事件的一个类型。我到时候做判断了，所以刚刚你通过你的验证之后，你能发现那11个监器里面，在我们当前这个步骤的时候，它不一定都满足我们所有的需要。

所以相当于我要把握的11个监帧器，在这儿做一次过滤吧，我过滤到能监听even starting能监听application那个star event这样事件的过滤器，这把它留下来。😊。

刚刚说那句话能听明白吗？😡，啊，就那句话能听吗？同学来给老师扣个一。😊，跟着我搜索啊，还是需要跟我搜索。你现在如果不跟着我搜索，一会儿自己看的时候更懵。😡，来捋一下思路。

刚刚我们刚开始的时候有11个监听器，这11个监听器，因为我开启了一个事件啊，因为你要监听你的事件嘛，对不对？那个事件并不是说我所有监辑器里面都能满足的，所以此时我要把这些监听器做一次过滤，验证一下。

说你到底是否符合我对应的一个这个事件监事件监听吧，所以这是这做一个判断，所它不等于空之后，是不是叫 listen往里面加东西了，这刚加了往下走，我们下干嘛判断走加进来了吧？

加完之后把 listeners点I是不是加进来，这是第一个往下走，这样判断之后能进来吗？进不来。😊，两个了吧，是不今天两个了，没有走三个吧。😊，四个吧。okK大家看到了？

我刚刚当我执行完刚刚上面的步骤之后，我一共走了几步。😊，是不是意味着我11个事件里面，我只剩下了4个，也就是说只有4个能对我们这个staring疑问的事件做一个监听，其他监听器是不符合规则的。

我是不是相当于这个地方我提前做了一次过滤的一个操作，听白了吗？好，就是这个步骤，你要做的一个事情。当你做完之后往上翻到哪儿去了？跑哪儿了？刚才这给判断的，是不刚这这是这个点复循环，循环完了之后。

这儿判断一下说当前类似的变是否是不等不等于空的，这刚刚没执行，直接跳过去了。跳完之后往下走到这步了吧，这步完了之后，判断一下你当前这个对象是否是等于空的。然后呢，判断一下它的PK变子是否等于空的。

所以这做完之后，你可以看一下我们当前这个对象，还有对象，那没没有变啊，找一下我们的哪去了。它。😊，来看一下，经过我们验证，我发现了里面剩几个是不是有且仅剩了4个我们对应的一个监听器。

把这四个监听器是不是要留下来，11个过滤完之后，只剩下这4个了。但是这11个取的时候，我是不是都是从我们的缓存里面取的？因为我说过了，你的那些监听器啊，你不一定什么时候用啊，固一定什么时候用。

但是呢我要把这些事件的东西给你判断下来或者留下来，所这留了4个对应东西，没问题吧，判断完之后往这走走清空掉，然后把它所有的东西加加进来，把这个哦 listeners给它返回回去，翻回去之后。

一共是不是只有4个，听白意思吧？所以当你完成这个步骤之后，你发现了你的listers只有几个。😊，这几个找一下let似那哎。看他类啊，有类似了是吗？那就没有了。有听人过来吗？这哪没有对象，没什么事。

不管他了，大家看到了，这里面listeners是不是有只有4个，这次个是我们反回回来的。然后完了之后往下走，叫this点 catch等于点put。想一下，这东西是我们刚刚上面创建好的一个空的一个集合。

是不是那一个缓存对象，马上走哪去了？😊，有事玩开。这怎没有了。现在是把这个东西给放进去了，放哪啊，是不是收er里面去了，呃放我们的开开K里面去了吧，是不是我们开K。😊，对吧把它给我们的直接放进去。

放完之后，把这个listers直接给他返回去。就当你返回完了之后，你想一下这个集合在变利的时候变利几次。😊，是不是只需要便利4次就可以了，是不是变离4次，便利4次之后，关键是下面干嘛的？

因为刚刚这个exq执行器是等于空的。下面监听器完了之后，我已经可以监定我们的事件了。所以此时我看一下它应该怎么进行执行了，你不能说我定义好监听器之后，定义好事件之后，我这放着没用，不可能。既然是监听器。

我一定要发生我对应的一个作用的。所以此时开始进行一个便异操作，取出其中的次条，然上走第一个等于空吗？等于空吧，所以第一个不走不走的话走第二个叫invoke listenervoke干嘛呢？

是不是进行一个执行操作，所以点F7进去。😊，然这个ever handler不管它好，这等于空的然后呢不不能空的话往下走，叫do invoke listener往下走。

是不是这块到这之后再进去接住这个lister on application event知道这一步了，到这步之后，每一个监听器里面它都有方法的它都有什么呢？一个对应方法的实现。所以我们可以干嘛呢？

再往里边进行一个点击7进去进完之后，第一个哪个类叫loin application listeners listener进下去之后是不是第一个叫什么application starting event吧。

是不是这是它它之后往下走进到叫this点 login system等于loin system点ge然后this log system你告诉我这样步是干嘛的。😊，我可能看不懂。

但你猜一下那句花蛋买干嘛干嘛的？😡，你告诉我。对，就是完善我们当前的一个日志系统。听白了吗？你想一下，每次我在操作的时候，我正常情况下启动一个sringbo呃项目的时候，刚开始先打印我们的banner。

banner打印完之后，我一定会输出一些正常的日志信息。但整个步骤里面我是不是一定要进行一个日志系统初始化。而这个日志系统的一个初始化，是就在这个步骤里完成的。由我们当前这个监听器来完成我们对应操作。

也就是说我刚开始启动的时候，我要打印哪些正常日志信息，把日志信息我打出来。😡，懂意思了吧？往下看这个event点get screen application是获得的ban对象。

然后再get class order获取完理类类对象，那不用管它点完之后，这时候有个get方法，点到get方法里面去。

这get这有个stem properties叫loading system点get class点get内就告诉你说我要混取到当前这样的一个类了啊，有这样一类的一个参数。好吧，我往回点啊，我点开看看吧。

😊，我们走一下F7。😊，这是获取到刚才那个plicationge sauce，就是我们的spring，那就是我们那个spring vacation。😊，啊，你可以看一下啊。嗯拿去了。

看看这是不是那个get application啊，就就就就这样一个值啊，能看到吗？这。是。我来找去找一下。我来看是不是spification里面是包含到这个这个这个这个这个这个三数值了。

有了这个spification之后，是吧，那这get看搜索获取我们的内加代器，不用管它，那再往下走走。😊，哎呀，点过去了啊，不好意思啊，这点过去了啊，点去之后不管它了，反正你知道这混取到一个什么。

获取到一个日志系统吧，日志系统吧，注意了，这儿有一句话说detect什么呢？and return the log system usesport log back and java logging。

啥意思啊？😊，啥意思？是不是它可以支持我们log back，同时也支持我们java的一个log的方式。完下判断这有个这样一个操作。好吧，告诉你说这儿你应该支持什么样的一个方式，它默认情况下支持什么？

是log back这样的一个方式，就log back来记录我们当前的一个日志跳看，你记住就行了。就是我们初始化我们的日志系统初始化完之后这要进行一个叫befo吧，就执行这个方法。

点击之后这开始获取我们cont内容，然后呢就进行支支持，然后呢设置一些过滤器的一些参数值这些东西，你别管它了，就是详细的日志系统里面要包含的一些具体操作了。所以大家看到了？当我初始化一个监辑器之后。

我是不是要做这样一件事走完。😊，走完，是不是第一步做完了，做完之后往回返往回返。😊，到哪了？wifi。嗯，没有啊，到哪一步骤，我看一下。返回来返回来。走，刚刚是不是执行完第一个了，执行完第一个之后。

我刚刚取的什么叫login什么什么东西好吧，看第二个第二个往下走。😊，是不是该取第二个了？第二个什么叫background，什么东西吧，是不是又是一个这样这样一个东西，点完之后也一样的。

我们可以看一下我们单前参数，点进去是不是到这了，抓之后点F7进来之后你往下走走到这一步，然后呢，点进去叫listener点plication event。

然后再往里边进行一个点击走是不是这样完成这件事情了。大家看到了？同样的方法名称都叫什么啊application event，但是它完成的事点是不一样的。这都什么事。😊。

点进去看一下参数叫spring background什么什么，一个闹啊，什么忽略什么东西，不管它，然后然后呢这要做一个验证了，先判断它是否是这样一个t或者fo的一个类型。

然后呢也就判断even instance是不是等于这样一个值。如果是的话，下面是不该做下样一的事情了。走走走到这儿吧，到这完之后往下走，这是不是开启了一个set线程，看一下我们的状况法。唉，star。

😊，哎哪去了？我看不到啊，我直直接自己自己点了，这看吧没关系啊，我们找一下这个方法。走点完之后，这是不是叫叫rung simply叫conversion service inizer validationation inizer messagess converter inizerjason inizer叉 set inizer。

你告诉我这四个东西干嘛的？😊，现在能看懂了吗？😡，他发生什么事儿？😡，对，各种的初始化。比如说第一个叫转化服务的一个初始化，验证服务的初始化，消息转化的一个初始化。jason格式的一个初始化。

以及我们字符级的初始化。是不是告诉你说你所有这些事件其实都是在我们间N器完成的，只不过说你什么时候去启动你的GN器什么时候开始进行执行的，是不是就这样一个操作。😊，现在你想一下。

你是不是已经看到两个监视器，它大概做什么样一个事，是不是搞明白了，已经两个了吧，对不对？就第一个叫什么叫login application listener，他告诉你说，我默认使用什么样的一个日志系统。

它有东西叫什么叫log然后呢就是干嘛的？是完成一些初始化的一些东西并计行弱状方法吧，里面是不是有什么转化器了，验验验证器了，jason啊是乎级了，是不是断样转换方式。所以这块你通过这个代码。

你能看到的啊，完成对应的一些基本功能啊，login日志系统。对。😊，往回反啊，到这儿吧到这儿往下往往下走啊，我们不看这儿了，往回走往回走往回走往回走，是不是到这儿了，是不是又在循环了？😊，啊。

时间系动可以做很多事情。是的，刚刚我们说过了这4个，所以你这只需要判断这四个要干什么事就行了。往下走到第三个叫dation什么东西往下走，就到这儿吧。

点进去往下走走点进去叫lister什么然后点进去到这了吧，说evenvent instance是这个事件吗？不是吧不是做不了到这儿看一下它这个值是不是等于空啊，等于空吧，对空之后，这不管了，返回去。

大发现了刚刚那个监听器，它做什么事了吗？是不是什么事情都没做，是什么事情没做，没有没关系，往下走第四个叫le base什么什么东西往下走到这儿点进去走走点进去。😊，点进去这样吧。

叫class you two点exper走走。😊，你看这儿能跳进去吗？是不是跳不进去，那意味着当前类型也不匹配，所以此时也就过去了。😡，好吧，大家刚刚我们验证完之后，你发现了，虽然我们只有4个啊监听器。

但这4个监器里面其实只有两个做事的，其他两个什么时候没做。第一个做事是log要要完成日志系统。第二个叫bground是完成我们的某些转化器了，对吧？验证器了，然后我们字符级的一些测试器的。

他做一些事情这完之后是不是搞定了懂我意思吧？也就说你刚刚初始化的时候，很多老师那11个监器干嘛的，我不知道，但是我已经用了其中4个了，并且这四个监器里面，某些东西已经完成了一些初始化功能。

这总体都是为我们当年这个所提供的一些服务所提供支持的啊文说的初始化许多service的一些服务支持系统就是这样的好，这大家要注意了好吧，做完之后往回返走。😊，来再往回吧。是不是这一款执行完了。

这sing是不是执行完了，早往回翻。😊。

放完之后，大家看一下刚刚那个步骤做完了吗？😡，做完了吧，是不是做完了，刚刚那步骤就已经做完了，所以一共就完成了这么多事情。这儿大家要注意的。好，来捋一下这做什么事情啊，这儿做什么事情，想一下做什么事儿。

这块啊很多同学可能已经跟懵了。来，现在还清楚同学扣一，不清楚同学扣2。😊，😀2。😊，这么多2是吧。WC刚刚这么大会儿才staring。所以我说这个里面做事情后面还有很多呢，后面写多少呢？😊，好吧，来。

我们现在总结一下后面那块大概做了什么样一个事情，啊，做什么样的事情来往下看。😊，这我标注一下啊，这个先11个对象。这这这这怎么调一下这个。原素选项。中文。已已经有了。这这这这。现在是不是好了？好了没？

刚刚啊再初始话11个对象啊，11个对象。😊，好了，现在好了好了来，来看好屏幕。刚刚我们在第一步的时候，我知道楚叔啊是一个对象，好吧，刚刚上面一节操稿我不说了啊，都非常简单。然后这一步的时候我喂。😊。

第五步。

第五个步骤，第五个步骤，你还一样回到我们代码这，你想要做什么事？我这个东西叫get run listeners点进去，点进去之后。

这创建了一个什么叫pe application run listener好吧？其实就是说我创建了这样一个对象。😊，好这啊。

六步。还不行。有再说吧，创建。监听器对象。位是不这样一个值好，这样值它指向或者说从。配置文文件中。读取到。把刚才站过来，遇到谁了？是不叫疑问的publish谁端了在哪儿？😊。

获取到这样一个对象。好吧，拿过来当前这个对象之后，是不是意味着我已经完成当前对的这样一个购造方法了。然后点了一个什么呢？叫return返回去。返回去之后，你再样回想。

这是不是意味着我当前已经获取到这样对象了，然后开始干嘛呢？进行一个启动，当我在启动的时候，这儿我要说一件事儿。其实刚刚我们忽略了一个步骤，你们也没人提问好。因为正常情况下，如果你跟着我走的话。

你会有一个疑问。老师，我刚刚在那个发布pre event，没到哪儿呢，没到哪没到哪呢啊，没到那个发布pre event的，没到那个地方。😊，来我来看，当我刚刚在做这件事情的时候。

我是从11个里面获取了4个，对不对？你告诉我，我这11个是归属于谁的，归属于我们的spring application的，没问题吧。但是你刚刚在进行实际操作的时候，你什么时候看到它往里边赋值了呀？😡。

啊，啥意思？你点sting，点完之后点这个starting，点sting之后，点它点完这之后，大家看啊这是有这样对象，那后从里面进行一个实际操作，操作完之后点进去点到这之后。

这是进行一个循环变利的一个过程啊，是进行循环变利过程。但此时在这个方法里面，我就开始取对应值了。你看一下当前这个类是我们的spring application吗？😊，是死way不吗？😡，不是吧，是不是。

那不是意味着什么？意味着一定在某一个环节里面，我做了这样一件事儿，或者说把我们里面原来的对象给他复制过来了，是不是给他复制过来了，set的对，确实这样东西。什么叫set，你想一下。😡，什么set的？

其实set的过程非常非常简单啊非常的简单。我这儿需要大家注意一件事儿，刚刚有一个步骤我们是直接跳过去的，哪个步骤跳过去了，往回反啊。😊，把原文捋捋捋捋系了，好吧，点这点这之后。

我刚刚是通过什么叫get spring factor instance。我说这个步骤大家都见过了啊，见过之后我们知道了就完成了一个实例化操作好吧，然后哪个东西实际化操作呀。

你点进去大开之后是获取到我们刚刚那个叫什么叫even publishublishing但是你别忘了一个操作什么操作，这除了获取到我们当前这个名字之外，如果我刚刚读过来的话，你会发现从这取的话。

只能取下一个参数，取完一个参数之后，我是要把当前一个参数执行实例化。你点这个方法的时候，这里面有个什么操作叫instance class。

而且有个东西叫什么叫get declare construct是要设置构造器，那意味着我是不是要完成整体的一个创建对象操作，但是我们刚看的时候，我带你看这个步骤了吗？没有吧。

所以首先你要看什么东西叫even然呢publishing然 listener。😊，Public。是ro类的，是不是这类？点进类之后，你要找什么？找一下我们当前这个方法的构造方法，找构造方法。😡。

那是不是这个东西？在这个方案里面，第一个叫this点application等于application，是把alplication给到它了，这第一步骤吧。你想一想刚怎么做的？😊，然一打。

是不是这步骤来操操作这是不是这个步骤来操操作的，是不是进行一个时间化操作。好吧，时间化完了之后，我们找到我们刚刚那个类。😊，一问他一问他哪去了？这这了之后，我们找一下他当前这个方法的构造方法。

走到了之后，把ap给到他是第一步骤。对吧第第之后第二步叫什么叫X，对不对？第三步往这看，这儿做一件事情。很关键事情叫this点你手什么东西，然后呢你有一个什么东西，这时候发现了你你有一个基本操作啊。

这个new基本操作什么干干了件什么事情啊，是不是给他一些新对象，你刚刚下面在调的时候，是不是都是通过this点什么东西在调的，刚调的时候，所以大家想一下这里面是不是也是指向一个对象。

所以这里面我就干嘛看一下这个里面他所支持的哪些对应的一个对象，你看到了有东西吗？没有吧，这熟都没有没有，不管他啊，就调一个创现对象。

然后往里面走走什么叫叫lister样的application点get listenersplication点get listeners，这个东西你熟不熟。😊，什吧ba是谁？

这就是我们的Sp vacation11个吧。然后从里面是不是获取到我们当前这个listers，把里面11个东西不加过来。再完之后挨一个循环循环的时候往我们当前这个对象里面是不要加东西了，点它。😡。

点完之后，这是是一个锁东西，锁完之后看这个操作叫this点defaretriver点 applicationplication listener点首不是先remoremo完之后，这是不有个ad。

这是不是艾的？所以大家想一想在哪做的？是不是在我们创建当前对象的时候，我已经把我application。

那里面的11个构造器是不是给到了我们的default retriever这里面去点 applicationplication里面去。所以刚刚你在查找的时候，从11个里面找的时候。

你是不是才能从里面取出4个来。如果你没有这个操作，你告诉我这11个凭什么能给到它连上了吗？😡，连按着操作了吗？😡，来这块听明白同学扣一太复杂了，不要这样想这件事情。就是。你在看原码的时候。

你知道最忌讳的啥吗？😡，有些东西就是可能会在判断的时候，就是我咋说呢？就是我在看这东西的时候，我是怎么看的？其实我刚开始点的时候，我第一次看在点点东西的时候，我也没往里么点没往什么点。

当我点到最后的时候，到从11个里面开始获取了4个东西的时候，我懵了，我说他们哪来的这11个构造这个监身器啊，从哪开始钻进来的，哪给他赋值的，这时候往回反，我发现哦，你要进行实例化，既然进行实例化。

那我现在是不是要看一下这个实例化里面，这个构造方案里面做什么事，我一看他的方案做事情哦，原来在构造方案里面把plication里面的1个11个监身器给到他了。然后我从这11个里面是取出了4个出来。😡。

明白了吧？所以你要想这个流程明白吗？你到底想这件事情，如果你不想的话，你就跟着源码像我一样，跟着源码啪过一遍，一点用都没有。好，你要去琢磨这件事情，懂我意思吧？😡，啊。

所以你发现了这儿是不是完成了我们刚刚那个复制操作，所以这里面其实很重要啊，其实很重要啊，一定要记住了。来，我们这写一下吧。😊。

呃，很重同西来写一下。这是干嘛呢？让我知道他咋写啊，没法写了。这是。叫创建。你问呢。好利谁。软。你似。那对象。并且好吧创建。创。创建出什么东西还记得吗？刚那个类是创建出这样一个对象。

这个类吧，然后呢，当我创建完成这个类之后。在干嘛是将。So application。的11个。监听器给到了当前对象。啊，此时。才能方便我们从中。获取出啥东西。或者啥叫符合监听视镜。的几个监听。好。

这个流程捋清楚了，一定要记住了啊，这这样的一个步骤。就选出选出了4个，就听那么一点。来往上看啊，我再说一件事，这块啊可能跟大家那个基本的一个知识是就是说呃海尔sp这块吧，大家可能稍微有点有点问题。好。

稍稍微有点问题啊，我来给大家说一下，这有什么问题啊，就是我再重新换一个图啊。🤧嗯。首先我这有一对监听器。😊，随便话啊一定间间隙。这个监听器你们应该知道是干嘛的，是吧？你想一下这块如果你不知道话。

你可想一件事儿，什么事儿。我们当时在讲那个serv late的时候，servry还记得吧？serv里面是不是可以配一个东西叫过滤器来过滤我们的请求。同时是不是可以配置我们的监听器，对吧？

当时之前我也讲th项目的时候，我还专门给你们讲一个什么？是不是一个serv一个那个监听器啊，讲那个案例，还记得吗？😊，我估计估计多忘了。找一下。卖吧哪去了。我不知道你们有没有看这文档啊，在这块的时候。

我给你们讲的个东西叫监听器啊，拿去了。😊，这监听器我们来统计什么呢？统计当前这个网站在线人数还记得吧？这个监听器东西类似哪？有类似那之后，它可以干嘛？

是不是可以监听我们的s contest而 sessions request是不是有这样的一些对象的一些监控，或者我们这些预对象一个监控这块在监控的时候。

那意味着你要想实现这样的监控功能必须要实现里面的方法了？而这些方法是不是意味着都是某一个具体的监听事件，听白了吗？😊，好，这里我再写上。这是监听器放上来吧。所有。的监听器。在运行的过程中。需要先听某些。

事件好吧，各种。不同的监听器。监听的事件是不一样的。这句话能不能看懂？😊，来这句话看懂同学扣个一。能看到吗？好了，如果你这句话能看懂的话，你想一下，刚刚我们那个类里面我是不是就完成了一件事儿。

我是不是完成了11个监听器，放到我们的就完成它的一个实例化操作。但这11个接听器一定是满足我们所有的需求吗？或者说这个事件是满足我们所有需求吗？不是吧，它是不是并不是满足我们所有需求的。

所以此时你想一下，我这儿做了一件什么事情，来往回倒我啊，刚刚那句话你先记住了，刚那句话你前记住了啊，记住完之后往回返反反。😡。

到这一步，这里面还还从这从从从这开始看啊，第二点它点它之后，你会发现这里面首先我创建这样一个呃这这这个东西吧，这没问题吧。好，文件完了之后往这边找，找一个东西叫扭这个对象，哎，不在这儿。😊，点哪去了？

别在这儿啊。找一下大家别别别别别慌啊。点一下。加个类似的点它。很那。看这儿这里面传过来的什么东西？😡，窗为啥？比如说刚刚我在海洋海那图里面啊。

赢了，所有建都运行过程中经历某些事件的。好吧呃，在。😊，是写的不太舒服啊。小点吧。在。3e。靠，这个这个输入法真的是。在the a vacation。对象创建。到时候好吧，然后呢创建。这11个。天天气。

啊，但是这是一个。监听器。的功能。是。不同的。换句话说。就是监听的事件。世件。是不同的。啊，当开始。便利。监听器的时候，或者车开始启动监听器的时候。干嘛呢？要。判断。当前类或者当前。监听器是否能监听？

该。事件如果可以正常启动。如果不可以。直接。抛弃。来，刚刚我写这段文字。放大点儿。来先将这个文字文文字描述。所有监线器在运行过程中都监每个事件这没有问题了。好吧，每个间接间事件不一样的。

然后随以说我刚开始的时候创建10个监听器，但是10个监线器完成任务肯定不一样。好吧？但是我们刚刚在进行starting的时候，也就是说我在刚刚完成启动事情的时候，你发现了这里面我扭了一个新的事件。

叫plication starting event，是不是事件？那此时你想要我要第一件要做要要做什么事，我要看一下我那11个监线器里面有几个可以监听当前事件。如果能监听把你留下来。如果我监听不了。

我就把你抛抛弃，是不是这意思？所以下面你在做这个方法的时候，调调性方法的时候，明白走。😊。

这里面首先我要做一个过滤，什么过滤，往上看叫get application listeners吧，这边怎么过滤的？点进去。😊，点完之后，这是不是开始做一个判断了？我刚给你给你们判那个判断条件了吧。

哪去了，找一下。😡，哪儿去了？哎，怎么没有了？张价，re是开的K没在这。Schronized get。一千碗一车碗。这没人没法看啊。呃，找一下我们疑问他吧，看疑问哪用啊。🤧。呃，以问。

看这块啊就这儿会有一个条件的一个判断好，条件判断。然后从里面要进行一个整体的筛选。筛选的时候是通过这个地方来进行筛选的。这里面是不是有条件判断。呃，找找这块吧，是不是东叫sport。

这是个sport点这个sport，这里面是不是有条件判断。我要判断一下说我当前这天辑是否是属于我们当前类。如果属于的话，我可以把你留下来。如果不属于的话，把你移走，这这是不是一个整体的条件条件判断。😊。

是不是这意思啊？是吧？刚刚这个点儿同学总结说，就是从11个监听器里面把可以监听application starting event的事件监听呃监听器拿出来，拿家之并启动，就这意思。😊，啊，就这意思。

所以刚刚大家也该也应该已经发现了，好吧，我们刚刚创创建的时候，这儿过滤完之后，只剩下了其中4个，剩下完这其中4个之后，然后我把这四个要分别进行一个整体的启动过程，而启动的时候，虽然有4个，但启动的时候。

大家发现了是不是只有两个有用，一个是我们的log log有用好吧，第二第二个是我们的白有用。而其他两个里面什么事情都没有做，是不是过去了。所以大家想一下，就相当于我现在毕竟还是run的一个初始阶段啊。

初始阶段，现在什么事还没做呢，只是说我要把前提之后需要用到的某些服务提前给你准备好好，准备好，因为只有准备好这些服务之后，我后面用的时候，我才能够顺序调用，就这样过程听懂了吧。😊，好，是这样一个步骤啊。

呃，如果没听懂，没关系，下去之后你再好好自己再捋一下啊，自己捋一下。刚刚我们刚看哪是不是刚刚看到我们的listener点 starting，是不是在刚看这个地方？😊。

啊，看懂了吧？好，这大家一定要注意了好一定要注意了。来，这块现在没问题的同学或者稍微清晰一点同学给我扣个6好，我扣个一也行，扣一吧。😊，🤧行不行？😊，下去之后，我还是那句话啊。

你下去之后一定要自己去点一下debug，自己去跟一下，一定要去跟，一定要去跟。因为你不跟的话，你光听我说，我觉得怎么说呢？我会了，但你会不会这还两说的啊，这时候很多同学为什么看页板的时候，他他接不上。

你知道吗？我不知道你们看页面有这种感受啊，我前面看一节，后面看一节，我突然发现两个月合不起来，但是你通过我们刚刚的讲解之后，你有这种感觉，我前期做这些准备工作都是有用的。

并且某个时间点虽然发现突然发现就上业什么呢？有一段桥突间有段缺失了，我再往回找的时候，我们把缺失的东西给你找回来，有这种感觉吗？😊，有吧啊，这儿很重要啊，这很重要，一定要做这件事情。啊吧。

所以我在给你干干什么，我再告诉你一种学习方法，还是看原版的方法。这原版方法学的时候啊一定就是很很很很很关键。因为我现在批判我给你讲明白了，讲明白之后，你不懂学习方法之后。

你要看spring call的言码的时候你怎么看？在等老师给你讲吗？但虽然我们后面也会讲啊，但是最主要还是什么？你要有这样的一个自学能力，懂我意思吧？好吧，这一定要注意了啊，😊，瞅烟，这喊得我嗓子疼了。

😊，这得练多少年？不用练多少年，你不要把它想的太难。😡，不要往想想想想想想太难啊，就是那个整理的速，就你在看样板的时候，你定要知道你在干嘛，这很重要这很重要，懂我意思吧？😡，就我刚刚说的啊。

我一上来之后，我并没有给你看这样一个图，为什么没看这样图，因为我就看这样图没有没有意义或者不重要，为什么不重要？因为你在刚开始第一次看原码的时候，第一次看原码的时候，你根本没有这样一个感觉。

就是我能看照这个图去看吗？不可能，你一定是从刚开始初始方法开始，我一步一步的么往下走，走到哪步的时候做什么事情，我要知道了，知道完了之后，你才能判断出来，懂我意思吧？所以我现在没带你们直接直接看这个图。

原因就在这儿原因在这儿。😡，O。😊，一眼就懵了，别懵别蒙，慢慢捋。呃，我相信啊你听完我讲这个原码课之后，你应该会给你一种我我我我所希望的吧，我希望是给你一种启发，什么启发，就看原码的一个启发。

我上来之后，我也没有跟你说，来，咱们先今天就讲自动装配的源码，没意义。你刚开始找的时候你找自动装配源码，你根本找不到。😡，我我我资料一定共享，你放心，资料肯定共享，这这这这这没问题。😡。

但是你重要是什么？学学习思路，学习习惯，学习学习方法，这才是最重要的。行吧？好了，废话不多说了，这个点啊就过去了，同实看圆门的勇气，一定要去看，你不看，没人帮得了，你真的。😊。

我给你灌输东西没有意义。好吧，行了，这东西啊就过了啊，我们到哪了？是不是到监器这块了。来这块我们总结一下总结一下这块做什么事。到这一步完成之后，我从11个间辑器里面。

我取出来4个间信器完成了我们日志系统的一个功能，并且完成了一些转化器，好吧，以验证器以及我们的呃那个字符集它的一些基本基本设施服务知到这就完事了。好吧，这块大家注意了啊，就到这块完事了。完事完了之后。

我们下面来再接着往下看做什么事儿，到第二步叫application arguments arguments什么东西，这干嘛的。😊，你一看还是很懵啊，b arguments叫应用程序的一个参数吧。

是不是意味着我要开始解析我们参数了。但一般我们写代码的时候，其实很少去呃看我们对应参数，但有没有有没有写的？有吧？就比如说不是黄金变量啊，不是黄金变量。就比如说你们之前写代码的时候。

我不知道你们有这样启动过java杠这样，然后写一个，就比如说hello。😊，点这想完这，我这写一个杠杠死人部的同学啊，杠杠service。😊，刚刚s点port。port等于8081，比如这样写过吧。

是不是写过这样东西，是不是意味着我在运行的时候，命令行里面带了我们对应参数了。😡，如果你带参数的话，你就意味着啊，那就意味着此时这个X就不能等于空了啊，这做了什么事情？把X封装到某一个对象里面去了。

我对象经去了点一下。看下做什么事，叫assert no no是不是叫断言，对吧？第一个叫this点 source等于new source，这个new source干嘛的，不知道，点进去看一下。

这就是一个最基本的一个静态类吧。什么new source好吧，往里面传递我们这样一个参数，并且把我们的ar给加加进去，加完之后点 full类。

是不是叫new一个叫simple command line argumentspresser点presser看见代码了吗？😊，嗯。😊，做什么事？我刚才是不是说了，在命令行启动的时候。

你是可以加我们对应参数的，这怎么做判断的？就告诉你说我要你一个简单的命令行的一个参数解析器，对吧？你点击去看一下吧，做什么事有造方法吗？看一下有没有方法，没有吧？没有意味着什么？

它自身本身自带一个无参的，能创建我们对象当你创建完当前对象之后，第二步骤该干嘛了，是不是该叫刚刚在调的时候也是一样的，返回是不是调把就传进去吧，点它点它之后怎么传的 arguments等于什么？

你有一个对象完之后开始便利我们这样一个数组调完之后说了叫star位杠杠你传参数的时候，是不是以杠杠的方式来传递的，为什么这是不原里面告诉你了是就以杠杠方传递的，传之后没完，你看里面参数解析啊。

等于 sub是不是开始截串了，解什么串第二个字母开始截，后面。😊，不来。是不这样方式？😡，对吧那进完之后取一个名称取一个值，然后呢用对号做一个分割，内部就是前面的Y6，就是后面的。对不对？

当你把这些参数都解析完成了，解完成了，干嘛？是要把它放到我们某一个对象里面去，哪个对象叫commonline arguments，是不是这里面？你通过这，你是不是看到这个具体解析过程了？😡，🤧嗯。

杠Dserv泡serv点泡的点。8080也在里面吗？是的，所有的命令行参数都会在这里面进行解析。它如果不在里面解析的话，你怎么你怎么传递过去啊？😊，懂了吗？这时候验证出来了。

就好比你们写的时候为什么是杠杠，就没人有疑问吗？我为什么写一个杠不行，为什么写两个杠。当然它这是指定指定好的。但家想一下你如果你写了一个普通的gavava代码就写你参的候是空格分割，你没有指定杠杠嘛？

在建议的时候都指定杠或者杠杠等于方式，包括你在我们的环境里面，你想一下你在myl的时候，mycle杠U root然后呢杠P呃123456是不是这样写，它一定有一个解析过程嘛。

而这个解析过程你能看到的懂我意思吧？😊，你就想吧，你要设计一个应用程序，让别人用你不指定这个参数方式，你怎么做啊吧，详细代码啊不带你们看了，不带你们看了。好吧。

你下去之后自己来看一下杠D是一个比较特殊的一个参数指定方式啊，杠D是比较特殊的。😊，杠定是比较特殊的啊，这块大家注意说一下，呃，就是你指定好一个opplication，就是sbook应用程序之后。

你在运行的时候，你是不是可以选择杠杠service呃，不是serv点port这样一个方式。😊，对吧他解完之后，他会做一个匹配，把P把这个K和value拿出来，拿完之后还没完，拿完之后还没完。为什么？

我来说一件事，你这解析完之后，这儿只是得到这样一个对象，这对象里面放了啥，你看这儿。😊，看他放什么什么东西。换啥map optionlist non option是不是有我们这样两个集合。

那意味着你解完之后，其实对象里面也是一个对应的一个集合对象。通过集合对象之后，你把它给拿过来往回返往回返往回返反完之后是不是得到这样一个类型，是到这样一类。在这个当前类里面点去。

这类里面是不是有很多一项一些这样的一个参参数值了，有了这样的一个参数值之后，后面是干嘛的？后面是一定要对我们当前这个参数值做一个引用的，什么时候引用，往后面看，看下面一行代码该干嘛了？

叫application arguments。😊，都这了吧。这是哪来的？是不是刚刚写设示好了一个参数，对吧？然后干嘛？叫prepare environment，又懵了，完了，这干嘛了？

叫prepare environment叫准备我们的环境。这个环境指是啥？啊，什么叫环境？这个怎么解释？😊，你想一下，其实你猜能猜到，你知道吗？为什么说能猜猜到。

你想一下所谓的环境应该需要的某些参数或某些依赖一个支持啊吧，而本身这里面又传来一个 argumentsguments的一个对象。你想一下arguments里面不就指定我们参数格式吗？

是不是这个意思好吧不给你的YY吗？对，就是这样东西。所以此时你要判断了，这里面我到底做了什么样一个事情，怎么判断？往下走。😊，这这个这个不在里面看了啊，直接跨过去了啊，点进去，然后到F7到里面之后。

你就懵了，我的天哪，里面这么多东西啊吧，东西多别慌，东西多别慌。你一步往里面看什么东西，叫create and confi the environment，叫创建或者配置我们的环境环境是啥，不知道好吧。

但这里面有什么什什么操作，叫get or create environment是一个方法，你可以点到当前的方法里面去点进去点完之后我来做判断。😊，点一下往里边点F7啊，走进行之后，这就判断了吧。

说类似点 environment不等于空之前做操作的时候，你有做过任何跟环境相关东西吗？从来没有，是不是从来没有没有没关系，那没有的话值可能可以等于空了，不等于空直接返回等于空的话，往下走，到这了吧？

到这之后，你看这个参数值，你熟不熟，叫类似点web application type熟不熟。😊，说么。当时我在讲那个创建 application对象的时候，里面是不是有这样的参数。

我说了有3个是不是3个，第一个，要不然值是n，要不然只是rereactive，要不然那个值是serv late吧。我说这个东西很重要吧，后面很多地方都会对它进行一个引用，是不是就关联上了，强制关联上了。

我们那个值构是serv late这servlate的话，我这做一个cases case嘛。然后走到这儿到家之后能进来吧。

返回一个什么东西叫返回一个staring server late environment。😊，告诉你了，我要创建好一个最基本的叫标准环境这样东西吧，什么叫标准环境啊？啊，这个怎么解释？解释依然很懵。

很多学不知老师，我不知道干啥的，不知道没关系啊，不知道没关系。然后这个时候我们可以往里边进行一个最基本的查看啊，最基本查看怎么看？点一下当前对象是不就对象了。那个时候你发现了它没有指向我们这个构造方法。

没指向构造方法意味着什么？😊，它是不就是一个误餐的，午餐完了之后，你右击看一下当前这个目录的一个最基本结构。最下面是我们的标准serv的一个环境。上面它的负类是谁？

负类是一个叫stand environment的一个值，叫标准环境嘛。再往下看还有什么呢？有抽象环境好吧，再往上看，这儿关键点来了，看这些值，看这些值，你看这些值，你再往上面看这些值。😊。

有没有点感觉，这干嘛呢？这些东西。😡，看名字啊，这名字起的非常好啊，你看名字这干嘛的？😊，对，叫配置解析。你看到这个confiration这东西了吗？这东西不是随便乱加的，好吧，不是说我想加就加了。

不对，这不严谨好吧，它名字起的时候一定是有具体含义的。但有一单词我们不认识没关系，但我通过我判断出来了，原来这是一个配置的一个东西，既配置的话，它最开始类叫是吧既然后。

那ok我们也可以做这样件事往上翻是不是有个好吧？在里面的时候我们可以来做一个最基本的啊，最基本查看啊，来往回返怎么看返回来哎是点之后是不是该点它点它点来之后再点它到这步之后它是一个抽象的类对不？

不抽象类抽象类也没关系，抽象类没关系，在里面你想一下，你每次是不是要了，是不是要了，你在的时候或者再进行一个实例化的时候，它会怎么做你找一下当前类里面有我们对应的构造方法吗？😊。

有没有多少方法有吧？副类里面是不有多少方法叫abtract environment，但它本身是一个抽象类。😡，是不是上称到类。那大家想一下，你再点到那方案里面去点有东西吗？有东西吗？没有吧？没有是空的。

空的话意味着我的子类里面必须要对它进行一个实现，对不对？是不是子类实现？所以这时候你点一下子类，我们叫什么来着？哪个叫stand server environment这样东西，是不是它？😡，对不对？

我们点开点它点开之后，你往这看，这儿好东西来了，宝贵的东西来了，看到什么东西了。第一步骤叫property source，这啥点进去，是不是就是一个这样一个参数值啊，我还不知道干嘛的，点下看这类吧。

它的有有有解释吗？说the default of the interface，然后呢lo什么东西。😊，看这context property source吧，是我们的属性的一些资源，是不是一些属性资源。

好，不管它先先不看它了，往回反到这后它要加东西了，加什么东西。第一个叫ad last at last new一个什么东西，你一个什么东西，这两个是干嘛的呀，不知道，关键是什么？

你看这些参数点它叫s late confiit per，第一个参数值先记得第二参数值叫s late contest initial initial呃 initial initial一个叫slate contest。

一个serv config。如果你还对slate有印象的话，这两东西很重要吧，是不是servlate里面用到的时候两个最宝贵的对象，你应该还记得。😊，是不是这东西？😡，好吧，约它之后来再往回转。😊。

这样往下看干嘛呢？是不是JNDI的这个店里有没有？如果有的话，也把它给加进去啊吧，然后把这样调出是super的一个方呃，一个一个一个一个参数的一个值啊。啊，只要往里边加我们对应的一个参数值就搞定了。

你知道了我指定了两个最基本的一个参数这没问题吧，好，但是你看一下这是不是还有个具体对象了啊，是不是具体对象，你可以点一下是不是就这样点super。😊，往里面加我们这应参数值就可以了。

把name个source给大家给复制回去。这块其实没啥可看的没啥可看的。你这样稍微注意一下就行了。其实啊你可以看一个东西啊，看一下什么东西，你看一下当前这个类的一个具体继成关系，我们来看一下吧。

受都要关。😊。

是不是他呃。这样找一下找一下它实现了一个子类，受音频的子。这么多吗？呃，怎么看他的职位啊？哪去了？那不对啊。要看什么，看一下它这里面的一个最基本的继承关系好，继行关系不继承关系啊。

算了，看不了吧，看不了，不看了。它继承了看这啊继成一个property resource的一个值啊，它是一个什么抽象类吧，抽类里面意味着它里面必然有很多子接口，再看一下它的de纲。能看吗？算了。

不看了找不到啊，找到算了找到不带你看了啊，所以在里面可以获取我们各种各样的一些呃系统的一个值啊，系统的一个值。这里面你是能够进行一个最近查的，就是说来解析我们对应的一个配置文件啊，解析我们对应配置文件。

好了，这刚刚我看到一步往回返返返返返回来。😊，大家看一下，我虽然刚刚只是拗了最基本的一个环境，但其实在new这个最基本环境的时候，我是不是意味着我可以读取一些系统的一些参数了啊吧，那个参数什么来着？

一个叫serv context的 initial，一个serv config把正两个值，你先给我记住啊，先给我记住OK当你记完它之后，进完它之后，我们现在往回返大家走啊走。😊，呃，到哪儿了？

是到第一步了，这是不是意味着我当前环境是不是已经有了好吧，有环境之后，我们看一下当前的环境里面的东西。😊。

右外面头。看到没啊，de。蓝牙3。往上看刚刚我看到什么东西，第一个叫sate config per吧，s contest initial吧？除了之外，刚想想找什么。

就找这个还有个stem properties，还有一个叫stem environment，就这些参数值，你应该是都能找到的啊，刚才我没点出来啊，没点出来。

但你要知道这里面是有对应对应东西的有对应东西之后，意味着我可以读取这里面的某些配置参数了。啊，这第一步你要记住了好，希望大都记住这记住完之后来，我们现在再往下挨个看，这干嘛了？

第二步叫config environment。这干嘛的。😊，来，刚刚第一步创建环境，P麦同学来给我扣波一。😡，能看懂吧？🤧就是说我现在可以读取我们servor里面一些配置参数。

以及我们的互环系统里面一些呃配置参数了啊，这第一步。第二步第一步换上A盘之后，第二步是不是。😊，🤧是不是该配置我们的环境了，自么配置点进去。点完之后，这里面又做了很多事儿，做事做什么事儿，往上看第一个。

叫if at conversion service这个东西什么时候见过见过吗？有没有什么时候见过？😊，你想一下，我刚刚在看一个东西的时候，哎，哪去了？看一下啊，看一什么东西叫ba。😊。

groundund它。在里面的时候，我点这里面的一个方法的时候，看这块是不是东西叫conmerci serviceconmerci service看到东西了吗？😊，还记个东西吧。

刚刚是不是大家看过这个东西了好，你要记它，你要记它啊。你你看过东西你别忘了，好吧，看过东西别忘了，用它之后再判断一下它当前这个值到底是否是 truerue还是 falsese。这边告诉你啊。

这个值当前值是true，好吧，既然处e的话，我点一下。😊，嗯，什么东西？点下这触值走点完之后到第一步走进去进去之后con service等于applicationcon service点get share instance往下走ment叫 set是把我们这个服务给设置到当前这个环境里面去是设置一个操作。

这个操作非常非常简单了，就完成一个最基本的设操作这块你击看下你看一下把里面东西给获取出来啊，这个没啥可看的，没啥可看的。

它错了return啊什么呢叫share的然defa application instance是返回一个共享的plication的一个实例是不这意思吧la building one它被使用的时候是懒加载的告诉东西就是说所有的我们当前应用应用程序里面。

它设参数用的是同一个这块别了懂意思吧？面还问了，直接淘汰了。你把这些东西记住你好歹留印象对不对？你留印象留印象之后你就可以很多事，懂我意思吧？😊，当然啊还是要熟悉还是要熟悉啊。家再往看它做完之后。

是不是获取到我们当前这样一个对象，往回卡啊，不要看。他做完之后，把我们刚刚的service给它设置到我们的环境里面去，点F去试试吧。走。

是不是叫property resolve点et conversion service吧。这时候你来看一下this点。😊，property resource这里面有什么东西，你点一下看看啊。

是不是只有4个参数，刚刚我们读到了一个叫sorate，然后呢config呃 initials contest initial system，然后呢stem environment是不是这一个参数值。

当你执行完刚刚这个代码之后，大家看到吧？是告诉你说property resource点set是不是又加了一个conver service这样一个服务，大家给我们建进去了吧。往那看对象里面是不是有值了。

对样里面是不是加了这样一个参数值，这里面包含什么东西啊，你可以看一下，我们可以看一下啊，点开这个converers。😊，conver来看。开始操作了吗？看操作什么东西。

java long number转什么东西，然后呢叫str number string number什么一堆东西，这有一堆的一个集合，这边都是啥？是都是我们对应全部的一个转化器这样的操作。

是不是cons好这个哪来的？是不是就刚刚上面这个步骤里面，我把它给加进来了，就我那个服务嘛？服务完了之后把它给直接加再加进来，加之后，我把它设置给我们的环境变量，就这意思。😊，好吧。

这上面的东西是不是完成了。就刚刚你只是创建好我们对应一个实力初始化了。但是你的应用程序想要执行的话，它是需要一个环境依赖的。而我们这个环境依赖啊，环境依赖就在于在这儿给大家是刺进去的。

但这步我大家给大家说一下，呃，我这用的版本是2。2。2，是比较新的版本。如果在老版本的时候，它不是在这完成的。老老板是没有这句话的，同是在完成的。所以每个版本的这个源码啊变还是有一些变化的。

所以你要看一下具体东西，懂我意思了吧。😊，好了，非常多嗦了，再往下再往下看啊，第三步干嘛呢？叫config property source，这步是干嘛的？

很明显是配置我们的properties的一些资源，对不对？是吧？那这块我应该怎么进行一个最基本查看啊，还是一样点进去F7进去之后。

叫evenment叫get property resource这在进行get的时候，你想一下我怎么get的，是不是从ment里面拿拿拿东西，我这里面有东西吗？有吧，是不是已经有4个对应的默认配置文件了。

even。😊，per resource是不是有4个？刚说你说过了好，先把它给拿过来，拿来之后这要做一个基本的判断，拿走。😡，说this default可放到谁点进去有值吗？没准是空。

它不等于空就道具操作，是不是等于空，等于空，不管它往下走。😡，它第二种叫this点艾 command line propertiesand x点 lens大于0，这干嘛的？😡，想样。

是不是我们命令行对应的一个参数，你是如何玩加的加载的？此时我们有参数吗？没参数吧，那没参数的话，我怎么办？😡，是不是直接跳过去了，是不是跳过去返回去了？😡，所以此时想一下这干嘛的？

是不是就用来设置我们具体的一个参数就搞定了，把，这这个具体的一个步骤啊，把它再加进去就行了啊。返回这步骤完了，把这步骤完了这步骤。😊，这个部分能听懂吗？

是不是就配置我们的property resource呃那个property source对吧？到第二个什么呢？叫configprofi是是该我们的profi这样的一个文件了。那一样的。

你也可以把它给点进去，点进去之后，这有个setprofi等于 new一个另的另这里面是表示什么呢？我要创建当前的一个集合类，把它当前一个集合类。当我创建完当前这个集合类之后哇，我还要干嘛？😊，啊。

还要干嘛？这怎么做？是不是这里面点它。组值吗？是对于空的集合，空的集合吧，你别管它往下走走这步叫profils点at all，然后呢叫environment点get active profile。

这个属性熟不熟？😊，什么。这个属性熟吗？熟吧，是不是叫spring点profi点active是不是有DEV环境test环境pro这个环境是不是可以读取这个配置文件。来点击看一下，是不是就转一个这样值。

点进去是不是active碰到下这个属性值，点进去是这个属性值吗？😊，是不是属性这是不是可以做一个最基本判断，判断一下你用的是哪个环节里面的一个配置参数吧，是把它转过来了。😡。

对吧OK整完之后来再接着往下看它什么东西，叫叫s profile。你刚刚已经把这个属性值给你加进来了，加完之后，你是不要设置成这样一个属性值，把这个pros，然后呢进行一个转换。

转换完之后把它设到我们当前这个环境里面去，环境里面去设置完之后一个就O了啊就OK了，我往下走一下。😊，这这不看了啊，联络判断。走，这样上完上完之后返回返回。大家看一下。

刚刚第一个配置一个property source，第二个看到一个配置profi吧。所以这就是我们这个配置这个步骤要做的一个事情，要做一个事情，听白了吗？😊，好，到这为止，来还能听懂同学给我扣个一。😊。

🤧嗯。你。你给我注意一件事注意一件事。现在这个地方只是为了读取我们的property source和我们对应的一个呃proper文件。你你们刚刚提到那个y玛尔和property文件，我们现在看到了吗？

😊，看到了吗？还没啊还没呢，就是说他什么时候加载我们的y，什么时候加载我们的pro文件还没开始呢，还没到那个步骤呢是吧，你要接着往下看，才能看到具体的一个相关信息和，具体相关信息还往下看吗？😡。

接下来开始解析文件了吗？对，下面开始解决文件还看吗？😊，啊。老师，再见，别呀，你你干嘛呢？😡，休息休息。这样那那个什么来，我现在带你们快速的遛一遍，快速溜一遍。遛完之后，我们下节课上来之后。

我们再接着讲，我们再接着讲。好吧，重新再过一遍。我现在现在想待什么呢？你们先看一下，就是你们想看什么呢？

那个application点Y applicationplication点 properties那个文件到底是在什么时候进行加载的，你要看到那个东西，你心里就舒服了，懂我意思吧？😊，来来看啊。

到一步这有个东西叫confiration properties点 attach，是不是加at，这是干嘛的？贴上去的意思好吧，这样点进去，这里面就做了一些判断。

accept是不是confiration这里面就加另外的一个参数值叫confiation properties。

你不用管它这步骤不重要拿走点完之后你可以看一下我们的vironment看这刚刚你看到的时候，这是不是还是4个，现在变成5个了，多了什么东西就多了一个confiation properties啊。

加一个自己的一个配置文件，加这样东西，加完之后，这这个步骤不重要不重要好吧，往下看这个步骤，这个步骤就好玩了，是不是又看到什么东西了，又看到listers了吧？好，鉴听器又是我们所熟悉的东西。

非常喜欢这玩意，对不对？喜欢的话怎么办？而一样往里边点它点进去走。😊，走点上去之后，这个干嘛呢？说spring application wrong listener， listener等于什么呢？

叫this点lister。你告诉我这个this点 listener是谁？😡，是谁？哎，给点回应好不好？谁呀？😊，来看一下是不是叫eventping wrong listener。

是不是还是他说了他这贯穿整个这个整个过程里面的，还是他让它之后往里边走，取出来它嘛，是不是把它取出来，然后点进去走到了之后，你又看到这个方案了吗？是不是类似点什么东西，点什么东西。

此时你这个监听事件换了没？😡，刚刚叫什么？刚刚叫application，然后呢starting event，现在呢叫application environmentprepar event看到吗？

事件是不是换了，那你告诉我事件换了之后，我下一步骤该干嘛了？😡，对我要准备一下你有哪些对应的一个监听器吧，是不是哪些监监听器，这个监听器才是非常非常关非常非常重要，非常非常关关键一件事儿。好吧。

来往上边点一下吧，点一下走。到这了吧，是不是创越好直接这样一个对象往下走走不管他走到这之后，是不是又该执行这个方法了，点进去到这一步点进去，然后呢，这是不是执行这个方法过去点进去就到这儿了吧。

到这之后往下走往下走又到这步了吗？是不是开始说get making listener，是不是又开始在这里面找了，找着来点进去。😊，往下走走走走，是不是跟刚刚那个重复的过程是一模一样的，是不是一模一样？

往下走走走，走到这块是不是到这儿了，到这儿之后来再点进去，是不是又到这块进行一个便利了，里边都是初始11个值啊，看这值数是11个从1一里面又要开始取值了吧？来，我们数下取多少个。😊，一个没过吧。😡。

进去一个吧，叫什么obstruct application event第一个进去了。😊，第二个接清楚吧。第3个。第4个。第5个。第6个。越过了吧。7个。几个7个吧，这儿又进不来，7个完了之后。

是不是把它给加进去，再返回回来。所以此时这里面一共有几个东西，是不是又有7个集合，有7个集合的话，那想想我是不是又该从这7个里面进行挨个的一个便利，看一下这些电力的时候在干什么事儿，是不是在干什么事儿。

对吧？来看一下干什么事儿，好吧，挨个取走。😊，第一个连曲叫什么叫config fail。然后呢，application listener，你一看这东西你应该很熟，或者说很欣慰，为什么很欣慰？

看到一个自己认识的单词吧，哪个单词叫configfa叫配置文件，对不对？这明确是不是已经告诉你了，我这就是一个配置文件。既然是配置文件的话，那O我们该往里边走了吧，点进去走到这了吧？

vo点进去往下走走点进去是不是叫类似的两个evenvent，又开始往里边进行一个点击了吧，点进去了呃，点进去。😡，看这儿even叫application。

然后呢enronment preparedpar，然后它往里边走，点进去到这了吧？叫lister呃叫post post processor等于load processor吧，是不是该到这里面去了。

对不对？到这里面去之后怎么办？😊，怎么看一样的，我可以是不是看一下这个当前这个方法，来看一下这个方法啊，点进去。😊，叫spring factory loader，叫loadfactor。

叫environment post processor，看它了吧，这干嘛了，不知道不知道来找我们参数，叫event。哪去了，啥名来着？eventp processor。找一下。

是不是这块1234是不是有对应的4个对应的一个对象，是不是把这四个对象给取出来，就是就搞定了。好吧，在这儿不看了啊，往这边过往回返叫proces艾 this是不是把它给加进来。

是不是里面有4个四个完了之后往下走，是不是又该循环我们这四个了，循环之后往这边走点进去那this次不管它。😊，不不不的方法啊，再点。也不这风吧。点去说到这儿了。

叫s name等于standard event，点什么东西点它。大家知道这是什么叫stem eRV吧，是我们刚刚设置好的一个参数，测试完之后叫even叫gege是从里面把那些参数值都给取出来。

取来之后这进行一个整体的替换啊，替换听完之后把它返回返回返回这是不是又有循环，一共有4个嘛，挨个进行一个循环好，你把它循环完之后，你就能看到对应的一个值啊。这块我们不往里面看了。

我这说一下大家所关心的东西，关键什么？老师我想看到我们的这个文件我应该从哪开始进行查看查看的时候，其实也非常非常简单非常简单，你只需要找具体的一个属性值就行了啊，哪个属性值。😊，啊哪种置。

我们这儿其实可以看一个对应的一个呃一个类图，一个类图。刚开始是哪个？第一个有environment processor哪哪去了，往回去找一下，是不是它是不是这有这样一类，对吧？

点开这类之后来点进去点开这后我们可以看一下当前这个类的一个类图，它上面是谁叫方al interface吧。呃，不是不是想看看，这类图我怎么今天都找不到了，找不到今天的类图啊，😊，回大之后我们再看一下。

在这个processor里面，我来找一个东西。给他。然后这这儿有一个。有一个什么。看这啊，这就有这样一个属性值叫system in呃pro source environment post processor这类啊非常非常长啊非常非常长长没关系啊长没关系。

然后呢，往里边进行一个点击查看。😊，这儿有一个值，不是这个值啊。这怎么没有了，不是这只啊呃想找东西没在这儿没在这儿。我们再再找一下刚刚那个你是不是。不是这，我们找另外一个东西啊，找他找这东西。找等西啊。

叫哪类人的？看一下。叫config fail啊，confi file一定要读这个类啊，config failconfi fail之后，我们可以点到这个当前类里边。得到这个类之后。

我们可以往里边看当前这个方法艾这有什么东西叫random value property source。这个random value property source熟不熟熟吧？你想一下，你想一下。

你在进行处理的时候，你的压巴文件里面我找一下。😊，我们的压码文件。source这里面你这他写的时候，你是不是可以写很的东西，写什么，比他写一个。😊，比如说AAA冒号，这写的东西写什么呢？😊，哎，错了。

B哔币。然后。random第二。怎没有啊。哎明包这样写吗？我记错了，没有吧。上一级词由吧，大家想一下，我们刚才写的时候，这里面是不是可以生成一个随机数的一个值，你记得吗？是不是写成一个随机数。

就random下什么东西，你是不是可以直接取了，没取出来呀？等一下我再试一下，可以取来的啊。😊，我应该我应该不我应该不会记错了。叫AAA冒号后面起一个dollar。看这看东西了吗？是random点浪。

randomdom点 value random点 int为什么这可以用这redom对象好吧，原因就在于哪儿？就在于刚刚我们看到的这个属性值，它是通过这个属性往里边加我们对应的一个方法的，看这。

然后呢什t uUID通过这些前缀匹配，我能够就识别识别我们对这个random这个函数了。懂我意思吧？好，这是我要说的东西啊，就这儿加一个random类，这是第一个这开完之后眉完，又用了一个什么东西。

new了一个东西叫loaderload什么意思？加类了。好，没关系，点它点loader点load之后，你往这看又看到一些非常熟悉的东西。😊。

打开啊，evenment等1ment不用管它好吧，pperty sourcepre hold resolve不用管它往这看找一东西叫load factory，收不熟？😊。

叫springfactor loader点load factories熟吗？好像有几分熟悉，对不对？如果它你比较熟的话，你想一下又有个种东西叫property source loader，又看它了吧。

你看完之后找我们那文件里面找一下，往上翻这个东西叫property source load，看了吗？你看完这类之后，你应该知道它读取过注这两个文件。

一个叫proper propertiesperty source loader，一个叫mer，然后property source loader，这看两这这这两个类，你看完两类之后。

你是不是又可以进行一个加载了，点一下啊，点点点里面去啊。😊。

再开始取取一下我们的factor type，取完的t之后，往里边开始找，是不是叫loading factor name，从你把它取一个值吧，取完之后再返完是一个例子的值，这个例子的值取的时候。

一定是取两个对应的文件，哪两个文件，第一个叫pro list把它拿过来。😊。

搜咖烧杯。好，是不是有对应的点叉码是不是叫点p，是不是ch码，这里面是不是有对应参数值的，是不是看到这个点hold缀的名字啊好，这是第一个。第二个还有啥，把那个名字粘粘出来。😊，咖C。可走。🤧看到了吗？

后缀名是谁，是不是讲YM2和YAM2是不是又看到东西了，是不是正是因为这样的东西，所以你才能把配置文件给读过来。老师那个application在什么地方啊？😊，啊，obvation是另外的一个名称。

它这只是补的后缀啊，只是补的后缀懂我意思吧？啊，所以这块就能找到这个文件了。就是说你把这个文件给读进来之后，我才能够解析我们对应的一个配置参数。如果读到这个文件，这个配置参数解解析不到了。懂我意思吧？

好，这大家要注意了。O。😊，好了，到目前为止来，还能听麦同学扣个一。😊，Yeah。都听懵了吧。😊，天。没关系，环境这块啊，我下节课我会接着讲，下节课我会接着讲的，不用担心啊不用担心啊。刚才问老师。

banner是什么时候加载的？banner它加载过程再往回找找一下。😊，斑点是个比较特殊东西啊啊斑点是个特特特殊特殊东西啊，往外找。😊，太多了。找到找到我们这搜一下吧。upplication多。

在这里面有一个。还没在这儿。做的方法有个东西叫撞。🤧嗯。看这块了吗？这是我们这个banner，这是我们班ner读取的地方。就当你的环境准备好之后，你的配置三数读读取好之后，你这样才会执行。

你这样才会执行。我们这儿其实可以做一个验证，好吧，我给大家验证一下。😊，好，太麻烦了啊。我找一下，我把这戴眼这这这这这直接打过来啊。他这り不了。好了，到这儿了吧，到这之后意味着我好你准备好了。然后呢。

你往下走。😊，看控制台看控制台，现在控制台还是空货，对不对？当你执行完下目步骤之后，走，看到了吗？这儿才会打印我们这个spring这个 banner这个文件啊，这一步骤才是完成我们具体的一个操作地方。

这东西啊我们下一个再说，现在再说，这个不说了好，这些不说了啊来这个。😊，老老师之前读出来的环境配置信息还和配置文件内容结合有吗？是的。因为注意啊，你读出来那些文件，你想象读出来都都是啥。

它这里面大家大家注意啊，你读出来啥一个是serv late，然后contexest然后加一个config，这样呢叫servlate configpy呃permal，还有什么东西叫sstem然后呃per。

还有一个是什么呢？叫stemENVpymal那些属性跟我们配置文件并不冲突啊并不冲突，这没有什么冲突的地方。😊，懂我意思吧？还有一种东学叫configuration properties，一共有5个。

一共有5个。你说那5个，这那一个配置人家没没没没还没还没关联上。等你把环节准备好之后，你开始读取数据了之后，才会把里面的参数给读过来。现在还没开始读呢，还没开始读呢。懂我意思吧。现在没开始图呢。好了。

刚刚呢我们讲了这样复杂的一个过程，相信啊很朋已经听懵了啊。呃，原码这课啊，我觉得就是不管谁讲都会懵，什么时候讲refresh。😊，如非手不大敢讲。😡，预见能好refsh不太难讲呃。

refresh它不算是我们的spring book里面的东西，它更多的应该换算谁，算是我们spring里面的东西。spring东西。因为你往里面看reflesh点进去，点完之后点进去。

这是谁啊不 contest里面的refresh好吧，这spring里面它做了N多个步骤，我要把这些步骤给你说完了，我的天哪，我就又得又得好几小时，又得好几个小时。😊，懂思？这是sp里面技术工西。

其说不太懂的话，sp里面可以好好回去看一下，好好回去看一下，懂我意思吧？好吧，这里面参数啊，现场五件java杠炸叉叉叉叉炸叉叉叉叉是啥东西？你再说，你说配置参数吗？😊，配参数刚刚不是说了嘛？

有个common line嘛，com line对象可以杜取的参数吗？是这意思吗？刚刚是不是看到了com online line里面有东西啊。😡，来来来。😊，就该执行执行呗。你你张号杠栈的时候。

也是找到我们的面函数，找到们面函数之后，也是按照我们的顺序，一行一行往里边走，只不过它会解析后面的一个杠杠杠叉杠杠OO杠杠OO的这这东西OO叉叉的东西。当你解析完之后，它就有个命令行的东西可以直接解析。

😊，看都都都懵了，回头把代码点一点，好吧，自己去点一点，自己去捋一捋你就知道了。😡，明白意思吧？来，我们总结一下，今天今天晚上这节约霸课我讲点啥？😊。

老师没看到spring application这个注解的作用呢。注解我给大家说一下，注解东西我现在会不聊为什么？因为在注解里面。😡，你们来来来聊一下注这边我跟大家说件事儿，你聊到注解的时候。

你可以点它是不是点它你点完它之后，其实在里面你最主要要看的是什么？第一个东西叫springbo configuration。第二叫enable auto configuration。第三叫comp干。

这里面最重要是谁是enable auto configuration。这是在自动装配里面讲的，我们还没到自动装配内部，还没到这个步骤，现在只是完成了一个初始化的一个基本功能，还没到那步骤，所以别慌。

纯折年代，别慌，后面的时候我会单独把这个自动装备，再给大家重新讲一下啊，我我东西都写好了，这这个一定会讲的。😊。

嗯。自动配置原理我我笔笔记笔记都写了啊吧，应该怎么做，每如怎么怎么找过来的，我都说书都写好了。好，后面一定会讲的，别慌啊，还没到那步，你先把整体这个启动化的过程，先把启动过程先搞明白了。

这才是比较重要的。先把它搞明白，再说别的。好吧，来想一下，今天晚上我们讲点啥。😊。

其实。其实讲东西不是特别难好吧，不是特别难。好吧，讲东西来，我们写一下第一步。

哎，然后是谁是吧？第一步我告诉你了，先要调一个种方法，对不对？然后在里面我们会创建一个spring application的一个对象。😊，对吧再创建好我们的spring呃sp。😊。

我不在这写啊。

放这块儿就在这块吧，想一下，刚刚我们调一个幂函数，调并函数之后调这个弱方法，然后创建一个对象。调换对象之后，我们会有一个状方法的一个启动。在启动的时候，我们设置启动时间，记录启动时间。

然后设置运行上下盘是空的，然后设置一常报告器，也是一个集合空的。现大家做我们设置这样一个的一个参数，没啥用，好吧，然后呢开始读取我们对应的一个是创建好我们对应一个间间梯对象了，对吧？在阶梯对象。

这个地方好吧，但现在发现了一共有11个，我会挨个进行一个整体的过滤过程，好吧，过滤完之后，我们要获取到一些对应的一个参数值，是这些步骤，这读完之后，你想一想还做啥了。😊，等一下啊，我们找一下东西啊。

写一下sp是application。PP那我来 get了。嗯。

找好里面的一个run网方法。这步骤前他步骤是不是都比较简单？好吧，这步骤只是干嘛的？完成一些储始化功能。制做完之后该干嘛了？该设置我们的命令行参数，然后准备我们的环境，就这给大家写一下。😊。

我这样画到这边吧。第六步。这输入法正绝了。第六步叫装配。命令。好，参数。O。撤作完之后，第七步。叫准备。是，呃系应用程序。运行的环境。好吧，然后环境里面我们做了很多的一个事情。

这环境这块我下一节课来了之后，我会重新说的。所以你们要做的事情非常简单，把从这儿开始，然后挨个步道第六个步骤之前东西你要看懂好吧，在来之后自己去挨个点一下试试，看一下能不能把这块东西给点明白，懂了吗？

😊，好吧，加当你没啥了，我就把它图给大共共共共共享出来。你回去之后好好点一下，自己点点试试。你看一下那些参数到底干嘛的，你多看几遍，你就知道什么意思了，懂了吗？🤧好吧。好了。

这就是咱们那个第一节的一个原版课啊。呃原版课程啊确实是比较麻烦，确实比较累的这东西谁都有共识。像你们自己看的时候，可能更懵更懵。但是啊我觉得怎么说呢？呃，我在给你们准备了很多东西，我在给你们讲这件事情。

而且我在把我看原码的一些习惯或者一些方法来告诉你们。下以之后一定要自己去点啊，一定要自己去看。呃，你把其实这个东西啊就是我我怎么说呢？我刚刚给你带你们看那个步骤就是我当时第一次看的时候，我的步骤。

我的过程，一点瑕疵都没有我刚看的时候你发现了中间漏很多东西，我都回过头来在接着找的，我带你们也是一样的，回过头来接着找。😊，你不可能一口气把它看看全了，一口气看全了。

其实看原版这块其实没有什么小白不小白啊，你只么可能把一个东西的原版给看完了啊，你就有自己的思路了，你就知道哦，原来是这么回事啊，原来是这么回事。😡，懂我意思吗？很多同学是欠记忆中什么情况，今天看了两眼。

看了几页之后，感觉我操，看下去就疯了，没什么成就感，不看了。😊，好，看两天不看了看两天不看了，你永远坚持不下去，你就咬着牙啊，咬着牙把一个东西看完。好吧，你看完之后，你再看原码的时候。

看其他关键原码的时候，你就不慌了，你就不慌了。如果你不看你你没办法，好吧。😡，对，就是硬肯。你想一下啊，你现在我现在带着你讲，你都听的很懵。如果你自己去看的话，你会怎么样？😊，懂我意思吧？呃。

原码只能啃只能啃，然后就是什么呃，自己自己在画的时候，自己在点源码的时候，可以就看一下题坝里面内容，好吧，同时呢做一下相应的一些小笔记。比如说你之前调哪一类，现在调哪一类，不用很认真的话。

拿篇废纸写上去就行了。😊，啊，保证你的顺序不会乱，保证你的顺序不会乱，这就够了。所以那个泪量会掉的时候，你可能看到很懵，懂意思吧？你要说有啥捷径，我跟你说没有没有什么捷径。😡，明碗东西怎么说呢？

就跟你在公司上班一样，你接手别人一个项目，你问他有什么捷径，有捷径吗？没有的，你只能硬看。啊。因为我点支烟，直接真难办。😊，呃，没有啊，就是呃之前没有给大家讲过原马课啊，你想一下，之前黄师傅讲过原马课。

然后周老师讲过原版课，我还是没讲原版课，是第一次给大家讲。呃，就是你反应不过来，或者说你你理解不了，我认为这是很正常的事情。所以你发现刚刚我给你讲的时候，很多东西我会重复很多遍，呃，不要怕我不怕有疑问。

也不怕大家不会，你慢慢听，等你把这个东西坚持下来之后，你就会感觉哦，原来是这么回事。😊，懂我意思了吧？其实今天讲的课里面，你下去之后补一个东西，补一什么东西，就是spring里面的事件发布机制。

你把这个东西补起来了，你现在在看的时候就会很容易很多就会容易很多。呃，我在讲的时候，我尽量真的是呃用我能达到一个最最最最牛的一个一个方式来给你们讲的东西啊，或者最简单的一种方式给你们讲了。啊。

所以呃如果还听不懂，你就多听两遍，多跟着多看看。好吧，如果谁还有疑问，咱们私下里边交再交流，行吧。好吧，多余的废话咱们就不多说了啊不说了啊。呃，今天咱们就聊这么多，然后周周日的时候咱们再接着聊。😊，呃。

不用管其他老师准备不准啊，我这边呃该写的笔记，该写的东西我都给你准备好了，一会儿我会共享出来。刚刚写的东西啊比较全，你下来之后把这块东西好好自己再捋一下，自己再看看啊。

有些注释啊可能写的呃不太不太不太不太详细，但是我觉得你自己可以进行补充。好吧，周六看这个课吗？不上周日，咱们周日两节，周日两节，周日下午跟周日晚上。因为周日周二的时候咱们没上课嘛，哦。

咱们周末的时候把这个课给大家补起来，给大家补补上来，行吧？🤧嗯。😊，好了，这东西咱们就聊这么多。OK呃，咱们就下课了，朋学们。😊，好吧，晚上回去好好捋一下啊。对，周末两周周末两节。😊，我去我确定啊。

周二不是没上课吗，所以给大家补吗。不补的话，这这这笔记放在gih上面，你们一会儿直接从d上geh上面下载就可以了。你是来劝退的，我这还叫劝退啊，我的天哪。😡，は。呵。好吧。😊，行，下休息了，妹们。😊。

🤧크。林老师潘电照，别忘了忘不了。😊，好了，同学们再见，拜拜。😊，嗯拜拜。

系列 5：P66：66、springboot启动源码解析二 - 马士兵学堂 - BV1E34y1w773

🎼这世界有很多爱你。🎼And那。🎼温柔啊。🎼别想他。😔，🎼是否值得你这样牵挂？🎼就放手吧。🎼别想他，我也放下过就好何必要苦苦挣扎。😔，🎼就放手吧。🎼别想他。😔，🎼把所有一切都当做是一个笑话。😔。

🎼你害が大吗？🎼是不是还留断头发？😔，Oh。🎼特别。🎼爱着爱情的童话。😔，🎼你害怕的。🎼我还记得。🎼最分手那天风很大。😔，🎼但再想不起。😔，🎼那时候。🎼的花。🎼若不是你的人闯去我生活。

我怎会把死守的寂寞放任。😔，🎼爱我的话，你都说，爱我的事你不做。😔。

う。🎼可是我。🎼一个距。🎼窗外的。🎼的风。🎼别的爱。🎼た。🎼就是在。🎼因为最。🎼你会。🎼我笑了你。🎼回到熟人眼前，回忆就在眼前，你戴着帽子而我样子，戴着腼腆，不可第一次的见面你说你有衔见，我的鲜贴。

必须难过，我能有偏见，都到着天真。🎼挂肩前轮。🎼不想成你的人。😔，🎼能力别人不是为了赚了有钱绊，我为我的成唱，希望我写的歌里面有更好的和想章谢。😔，🎼别二起。🎼说这些里。🎼你爱我。🎼第一次发长面就一骂。

大是从此在大场面，我不在站旁边我是真的感且佩服你的眼界，怎么想到和一直在度刺痛的完结。😊，🎼我只看着你一起慢慢头发，欲望巨差，惩罚价值慢慢，反岔发的失望让我。😊，🎼的心。🎼可是我。🎼终于来。🎼いな？

🎼一个去。🎼窗外不。🎼别的爱。🎼我的天。🎼お。🎼大这。🎼微笑。🎼あな？🎼谢谢你。🎼你还记。🎼说是谁。🎼Yeah害。🎼年对。🎼你说我是个商品，没有你们就不可以。这些扭曲的真理差点毁掉我的自信。

如今的我已觉醒，如今我不再哭泣，再不怕坚持自己做你没做对的决定，你知道吗？这一片。😊，🎼别操作这情人。🎼天空白的。🎼总会慢慢长，哪怕却我没法拥。😊，🎼你结话的傻瓜。🎼愛た。🎼一个圈。🎼We也。🎼问题。

🎼的挣扎。🎼我们都。🎼愛到い。🎼多少年你，多少遍离。🎼多少挫局，多少甜你。🎼太过去喝就不再介意，完真的靠心里把从的伤了却都忘记。🎼我心春了全部回忆。🎼可能觉得是你。🎼希望你偶尔也会相信。

就让我真心真意把歌唱望重新开始。🎼你还记得。🎼说出心。🎼你还来。🎼。🎼偏偏停嘱夜有。😔，🎼午夜星辰似奔走之有。😔，🎼爱你每个结痂伤口，酿成的陈年烈酒。😔，🎼入喉尚算可口。😔，🎼怎么泪水还偶尔失收？😔。

🎼要你是个心中缺口。🎼梦中留存。🎼温柔。🎼此时已莺为草场爱的人正在路上，我知道风雨兼程不今日暮。🎼不上。🎼一个人。🎼只为与你相拥。😔，🎼皓月当空，爱的人手捧星光，我知他乘风破浪去了黑暗一趟。

🎼总伸手给你救赎热。🎼还要你感受，让星光加了一点彩虹。🎼像樱花偷偷吻你耳。🎼让世界美好。🎼与你环环巷扣。😔，🎼此时已莺飞草长来的人正在路上。🎼着大鹏雨兼程的情人。🎼不常。🎼穿越人。🎼只为与你相拥。😔。

🎼这个。🎼皓月当空来流人手捧星光，我知他乘风破浪去了黑暗一趟。🎼同身手。🎼给你救赎肉。🎼此时已莺起早上来的人正在路上，我知道风雨兼程途经。🎼不上。🎼长绵人。🎼只为与你相拥。😔。

🎼此刻以皓月当空来的人手捧星光，我知他乘风破浪去了黑暗隐藏。🎼感同身受。🎼给你救赎了。🎼知道你不能还要你感受，让星光加了一点彩虹。😔，🎼当樱花开得纷纷扬扬，当世间美好。😔，🎼与你缓缓相。😔，可。

🎼Yeah。

🎼沿着路灯，一个人。😔。

🎼走回家。😔，🎼的老朋友。😔。

🎼电花。🎼你那里天气好吗？😔，🎼有什么新闻可以当做笑话？😔，🎼回忆与我都不爱。😔，🎼说话。🎼偶尔我会。😔，🎼心里有一些牵挂。😔，🎼有些爱却不得。🎼的暗天。🎼在夜深人静的时候。😔，🎼想起他。😔。

🎼送的那些花。🎼还说过一些私心。😔，🎼裂飞的情。🎼赌一把幸福的。😊，🎼筹码在人来人。🎼的街头。🎼想起。🎼他现在。🎼可我没有能。😔，🎼对你想要的回答，可是你一定要。😔，🎼幸福啊。好，同学们能听到我声音吗？

能听到话来扣个一。🤧我准备上课了。呃，今天讲什么讲s文bo的源码。放下孙叔的羊马。大家想听原马课吗？😀呵呵。😊，这个原码课啊听起来确实是比较无聊的啊，不太行。呃，原码课听起来确实比较无聊。

然后上次我讲课的时候，很多同学可能已经听懵了啊，可能已经听懵了呃，然后呢就是不知道你下课之后自己有没有啊，虽然痛但是爽呃，这个过程啊，你必须要经历。等你完完整整的把一个项目的原码如果呃听完了啊。

听完了之后然后的话你再看新原码的时候，你会有一种非常舒服的感觉。最主要就找那种感觉，有种感觉之后，你学习会变得非常顺利啊，反正原码啊之后怎么着都是要听的啊，或者怎么着都是要自己看的。你不看的话。

面试不知到怎么办，很麻烦，好吧。😊，呃，前两天的课原码课没听，今天能听懂吗？呃，估计有点够呛啊，估计有点够呛。呃，但你可以先过一遍，先听一听，先听一听呃，什么时候讲网约车。

等咱们所谓bo的原码讲完之后呃，来讲网页车项目，好，讲网约车项目啊，呃不用担心。微服务熔断没听完空难不。这块没关系啊，这个跟V服熔断那块没没有关系。我们就看一下它里面的一些实现机制。

其实像sringbo源码在问的时候啊，可能自动装配问的比较多。所以我现在在考虑说这个源码大概讲到哪哪一个层次呃，这样没想好。那最起码我们这个启动过程是要讲完的，讲完启动过程之后。

第二个就是讲一下我们对应自动装配的一个原理啊。第三个我准备讲一下我们那个star它这个整体的启动过程啊，因为我们知道每次你再搭建一ring呃 boot项目的时候，有些web这这些东西，star讲一下呃。

其他的一些细点，比如说s boot一些环境方面的东西，对吧？呃，再比如说。😊，像后面的一些自定义的东西，我们这儿就不讲了，或者第一期暂时先不讲了，我怕讲完之后很多同学就懵了。

所以我们这儿呢先讲讲一些简单的，或者说面试中经常被问到的，好吧。😊，好了，别的废话，我们这就不多说了啊，周末的人比较少啊。😊，什么时候讲完四五节课就讲完了。好吧，大概还有四节课左右吧。😊。

🤧如果跟不上的话，可以先不跟。好吧，先看那些基础东西OK。好了，来看我这个项目啊，我们还是一样先回顾一下上节课我们大概讲点什么东西。我说了，每次我们的springbo项目在启动的时候。

必须要指定我们这个run方法。然后你往里边依次进行点击的时候，你发现了它创建了一个spring application的一个对象，在这个对象里面大还记得做什么事吗？应该还有印象吧。

首先它创建了一些资源的一些管理器，但这个只是空的。第二指定了我们这个程序启动的主类是谁？叫primary source。第三个指定了我们当前应用程序，它是什么样一个类型。第四个往里边设置了一堆的什么？

是不是初始化器和我们这样的一些监听器。这些监听器和初始化器这些文件是不是在一个叫springfactor文件里面，大家应该有指有有印象吧？是在账包里面，当时我跟你们说了，我说只有两个账里面包含这个文件。

其它账号是没有的哪两个你再看一下找一下我们的spring第一个在spring里面有一堆的配置吧，这是第一个文件。第二个。😊，有auware在这里面也有一个ring这两个文件就会进行自动一个加加载。

而且它加载完之后，因为后续的源码里面会不停的从这个文件里面取对应的一个类好取对应一类文件。所以这希望大家注意一件事，注意什么事呢？它首先加载过来之后会把文件里面的全部顺序啊，全部顺序。

然后直接读取到我们的全部内容都一都堆到我们的缓存里面，以后再取的时候，就会直接从我们的缓存里面进行一个获取。懂我意思吧？好，所以这块大家注意了。

刚刚那个换换线说账包里面也有我们这说的是什么是spring里面东西啊，sp码你们之前已经讲过了，我这不再重复了，懂我意思吧ring只有两个里面有spring肯定要依赖我们的sp嘛，懂我意思吧？

O这块稍微注意下行了。😊。

就这些东西。然后呢，最后面一个找到我们当前这个应用程序，它所执行的一个主函数好，找找这是主函数，它是有一个对对战的一个路径嘛，依次往上找能找到我们对应一个主函数。就是当前这个类在创建对象的时候。

它所做的一些事情好，所做的一些事情。大家执行完成之后还要干嘛，是不是该进行整体的一个启动环节了。我们上节课也大概有讲到这个启动环节了。大家想一下。这个启动环节前期他做哪些准备工作？

第一个设置了一个stopport的一个对象，这对象里面非常简单，就给了一个名称，给了一个时间。记录一下我当前程序启动了多长时间。这是第一个第二个右建了一个上下文的一个对象。当然此时对象还是空的啊。

此时对象还是空的之后才会给它进行一个创建。第三步，我们定义了一个异常的报告器，它是一个rease，第四个配置一个什么叫javaW这样的一个属性，把加我们的系统属性里面去了。

又一个是加载了一些监听器的内容，对吧是一些监听器啊，监器我给你们说过了，首先我们会从那11个监听器里面来进行一个数据的获取，取完之后，并不是说所有东西都能进行适配的。它要干嘛？根据我们的事件来进行匹配。

刚开始你第一次刚进去的时候，这有个什么东西找一下是把我们这个呢都给获取到，当你获取到之后，第二步开始进行一个starting一点staring里面会出现一个对应的事件吧。

你点一下看看有什么东西叫plication starting第一次的时候会将这里面也是说我会从那些过滤器里面进行一个匹配，能匹配到当前事件处理的。😊，间监听器留下来，不能匹配的，直接过滤掉。

然后呢把那些监听器分别进行一个整体的处理环节。这是第一个我们讲的一个事件。后面的时候啊还有很多。然后这块我跟大家说了，我们在取的时候，是不是有这样一个这样一个数这样一个对象值。

这样对象值是在当前这个类进行呃初始化的时候，或者创入对象的时候，这里面进行了一些复制操作，这东西啊之前已经带你们看过了，好吧，是反过头来带你们直接看的所以这块要留一个印象。然后当这些间定器都启动好之后。

下一步骤是干嘛了，是不是解析我们对应的一个参数值，而当前的参数值是从哪来的，是从我们的命令行来的了，应该还记得解析了我们命令行的一个参数，然后带你们看了，是以杠杠开头K等于V这样的一个方式来指定的。

它后面会有一系列的一个匹配过程，匹配到之后，直接把它带到我们的呃那个。😊，这个配置配置参数里面来参数里面来，这是我们上节课讲的东西。然后这节课我们讲什么？主要讲一下我们当前这个环境好吧。

也就说我们spring程序想运行的时候，它是需要依托于环境的，叫converable吧，是是叫配置环境因为我们都知道啊，你虽然可以从我们的或者说plication里面读取我们的配置参数。

除此之外啊除此之外，在很多的类的上面其实你定义的一些注解吧。那些注解里面是不是也包含了部分的一个参数块一定要总结到我们对应一个什么环境里面去，所以这主要是准备环境。还记得吧？那从这开始进行一个讲解了。

这个方法，上节课大概带你们看了一下可能因为下课的原因吧，可能时间比较长原因可能同听到就已经蒙了我们今天把这个东西重重新重复讲一下来到这个环节为止，上面东西还有点印象，或者能记个大概的同学一。😊，好了。

都没问题啊。没问题的话，我们来开始执行程序。记住我说过了，每次运习的时候，第bu个来进行执行，嗯，错了。😊，这会进行一个跳转啊，往下走走走走走。说到这步骤了，好吧。

到了之后F7进到我们当前这个环境里面来，进到里面去之后，你能看到很多相关的一个呃语句啊，看下语句干嘛呢？你通过名字，你能做一个判断。第一个叫get or create environment。

先创建一个环境对象，这是第一步骤。第二步骤是进行一个合理的配置吧。第三个叫attach很同学看到tuch之后蒙了，然这个什么意思？你把它理解为什么贴上，就是说它会往这个环境里面再加载一些对应的属性值。

第四个是进行一些节身器的一些启动准备工作吧。第五个把我们当前这个环境绑定到我们的 applicationlic里面去，第六个做一个类型的一个判断，环境变量，对环境对象是否是符合我们的类型的。

不符合再进行一个转换。第七步也是往里边加一些其他属性，因此而已。听了吧。我们挨个来看一下，第一个叫创建或者说获取一个环境。大家想一下，到目前为止，我们在之前的操作里面有做过任何跟环境相关的事情嘛。

没有吧。所以此时你在进去之后。😊，这是什么？是不是一定是我们要进行一个创建工作，而不是一个获取工作。自点去看一下刚开始Ement是不是等于空，等于空的话不走这儿。然后这个位进行什么？

根据我们当前应用程序的一个类型来做一个判断，这说了什么类型？😊，叫slate吧，是不是叫solate。因为之前说过了，有三种种类型，一个是n，一个servlate，一个是reactive三种式的东西。

之前它会根据一些参数进行一个判断啊，进行一个判断。为什么要 touchuch两次，你看一会儿我要会回来再说啊，回来再说，一会再讲讲这个东西啊，回来再说。😊，来我来看这是一个servate的东西。

所以呢往下走的时候，往下走走，是不是匹配到这了，叫standard server environment吧。这个方法我希望大家能够注意一下，非常关键。为什么它这儿实际上是创建了一个对象。

而在我们当前这个对象里面，对象里面，你们可以看一下它的一个类的一个结构图啊。😊，收大家过认，看到这个层次依赖关系了吗？它的上面是谁叫stand environment。

stand environment上面是谁叫abstract environment。为什么要带大家看这样的一个依赖关系图啊？上面这个接口不用看啊，接口不用看啊，先放一边。

我们主要看它对应类的一个继承关系。因为当你创建完成当前对象之后，它默认情况下需要做一些准备工作的，什么工作来回来我们看一下。😊。

如果按我刚刚的说法的话，点赞儿。😡，点它点它之后，是不是找到了构造方法，你看一下当前这方法里面有购造方法吗？😡，有没有这考方法没有吧没有老师，那我就单单创建这样对象就行了嘛？很简单嘛？不对。

你这样看样板的时候，很容易漏到一些关键的属性值。为什么？我说了它有一个继承关系，在子类创建我们对象的时候，负类对象是不是也要进行一个创建。所以此时你要往上翻，听白我意思吧？一定要往上翻。

你看一下副类里面大概做了什么样的一个事情，大家做什么样一个事情，往上走点负类负类时候，你看一下当前这个负类里面有对应的各个方法吗？是不是也没有没有的话，再往负类里面找，它是一个什么类叫抽象类吧。

虽然是抽象类，但是当前抽象类里面，它有一个什么是不是也有一个对应的各个方法，各个方法里面它掉了一个什么，是不是这样的一个方法值，所以你发现了当你的子类对象在创建的时候，它依然是不是也会掉这个方法。

而这个方法里面做了很多的事情，做很多事情，我们这可以点一下看看点它点完之后，这是不是一空实线。空实线的话一定要找什么，是不是找具体子类的一个实现了。刚刚我们看。😊，什么叫standard server。

然后呢environment点它这里有两个选哪个下面这个吧，点下面这个点完之后，这儿告诉你一个道理，或者说这告诉你一个信息。

叫property source点ad last点ad last这个property source是什么东西啊？😊，你猜一下应该知道吧，它这边就是一个放置我们属性资源的一个对象，或者是一个集合。

点家看一下是不是传过来一个这样一个呃不可变的一个集合对象。有了它之后，往里边叫ad last，往里面边最后进行添加嘛。

加的时候new了一个什么叫STO B propertyperty source这个per source，这是一个对象，这无所谓，关键是看后面的参数值，哪个地方叫s late configper。😊，好。

init啥意思？是serv里面配置的一些初始化参数值，这是第一个。第二个再点一下，这什么叫serv lake contextt，一个是confi，一个是cont。

如果你对你的serv lake印象还比较深的话，这是serv里面两个非常非常重要的对象吧，或者会是之前的时候，如果serv的话，会从我们的外边上班里面是读取一些参数配置。😊，好，这样的话。

是不是把这个参数值也帮你给加载过来，是不是完成这样一个基本工作。所以前面做这样一件事儿，这要记住了好，这要记住了，一定要记住它。这做完之后没完啊，没完，还要做什么事。

下面这儿还有一个叫JNDIJNDI东西啊，你们一般用不到，所以不用管它好，往上看这儿有一个super点什么东西一键看到super的，一定要掉负类的，你点一下负类，下面有什么东西。😊。

是不是跟刚刚的代码一模一样，直播现在变成什么了？变成了叫property点什么东西？ssem in environment表什么东西？你点开这两个产量值。

你看到了谁是不是表示我们的系统属性是不是系统属性，对吧？你再点下面这个叫什么，是不是也是我们的系统环境。😊，看明这意思吗？所以大家能看到，刚刚我们完成那个操作之后。

实际上它是往我们的property source里面加载了4个默认的一个配置资源。啊，你想一下，你要想运行你的应用程序。当时我们在那个。😊，JDK刚刚讲deva的时候，老师让给你配环境变量。

环境变量里面是不是指定了很多的一个路径，像那些路径是不是都属于我们当前的一个系统环境了？所以那些系统环境的参数值它都会被加载进来。一会儿我们可以看一下，听白意思吧？

所以一定要看一下当前类这里面的一个继承关系。你比要说老师我就你有一个对象就完事了，那样看的话是不完整的。我说了，你会丢掉很多关键的一些属性值，所以这块是不是直接创建了，往下走了啊。

那个东西不带你们看了啊，不带你们看了，直接往回走。😊，收到了？这个时候是不是已经得到一个最基本的环境对象了，对吧？来看一下这个环境吧。

来拉一下environment找到我们的property source吧，是不是有4个，分别是serv late confi in paramal然servlate contest in para systemem systemem properties。

然后呢system environment。😊，能看到四个属形值了吗？现在是不是应该知道说哦，原来四个属性值是通过这样的方式给加来进来的。来这个点听白同学扣个一。😊，能看懂吧。😡，嗯。就是我们之后啊。

在不管在配置文件里面也好，还是在那些呃系统变量里面和也好，配置的这些值都会降到里面去。这个时候你可以看一个东西啊，叫environment systemy environmentment。

点开我们的source，你往上看这些属性值。😊，能看这东西吗？他有没有把这些东西加加载过来，是不是指定好一些路径啊。再比如说你点开上面这个叫system properties，点开你看这东西了吗？

java点呃VM version等于谁好吧，java呃javaVM什么东西，然后一堆参数看见参数了吗？😊，能看到吧，是不是能看到具体一些相关信息。所以这些信息都已经被我们给加载进来了。

如果之后的程序里面我需要用的话，是不是拿过来之后直接用就行了？懂我意思了吧？所以这块你能看到很多相关的一些参数值的，它不是说我白加载的一定是存在具体的一个意义的那上面这块东西吗？没有吧。

因为现在你还没往里边处理任何东西，以现在还没有任何的艺属性。但之后我们会往里边加载很多的一些其他属性值，这是第一步骤，先创建当前的一个环境，环境完了之后。

第二步该往当前这个环境里面进行相关参数的一个具体值的配置了吧。那这个配置其实也非常简单啊，也非常简单，你可以点一下这个参数值这方案里面去是不在这儿在这儿的时候，这儿需要大家注意一件事。

我们都知道在写ring这些程序的时候，它里面其实包含了很多转化的一些类吧。比如说转对吧？再比如说date日期转字符串字符转日期，是不是涉到很多相关的一些转化工作，而那些。😊。

转化工作最终会在这个步骤里面完成。当然啊呃这个东西啊是根据你不同那个存播的版本不一样而决定的。呃，在老期子里里面，版本里面是没有这个东西的，这是新加的。因为我讲的是2。2。2，最新的版本，听白意思吧？

这句块看做什么事？第一个谁属性指是处，所以肯定能进去，进去之后我们这来做一个判断。😊，往下走啊，注意判断。

他说了叫opplication conversion service点get shared instance，这get shared instance干嘛的？😊，不知道吧，好吧。

你们有没有印象有之前好像似曾相识过这样一个东西啊。😡，叫share的什么东西？😡，没有没有算了没有算了没有算法没没有没关系，好吧，没有的话，我们接着往里边进行点击。点完之后，这里面告诉你了。

说是一个share instance的一个值吧。这是不是有定义了这样一个属性，你往下走，刚开始这个属性值有值吗？没有吧，是不是空的，空了之后，它往里边一直往里边走走，现在还是空的啊。

一直往里边空到这块的时候，你看一下这做件什么事，是不是又开始创建我们当前这个对象了，来点进去走。😊，走在这里面做个什么事。看这块了吧？我们挨着往上看吧，挨个往上看，来走第一值等于空吗？等于空嘛。

是不跳下面这块，这有个config，你点到这个config方法里面去，第一个叫default conversion service点at default converters converters熟不熟？

什么叫converers？😊，啊，见过吧，之前是不是也自定义过一些对应的一些转化器，你自定义过实现过吗？😡，哎，还记得东西吗？double check clock不要管这个锁的事好吧。

你先理大概的一个思路，行吗？先别管连个锁的事，你先理一个大概思路，你先把这个流程给捋捋清楚了，是不是叫转化器，这个时候你可以往里边进行一个点击，走看里面做什么事。第一个叫ad什么什么东西。

点进去看里面做什么叫number to number convert然后呢，str to number objectject to string string to差 a character objectject to string然后number to a character一堆一堆看到西了吗？

这是不是我们之前看到一些相应的一些转化器东西了。😊，能看到了吗？是不是相当于在我们配置环境的时候，他已经把这些对象直接帮我们给注册进去了。这样能看懂吧？好，能看懂，我直接往上跳了啊，一行要走。😡。

这里面就是一些对象，这没啥，好吧，就些对象的一些处理过程，这个很简单，没啥，没啥可看的啊，往上走走走走。😊，东西很多啊，点进去。完之后第二个什么呢？

叫ad connections convert是集合的一些转化器的，你点进去一样的array to collection collection to array array to array然后呢col collection map to map是一堆转化器也是一样的啊一样的都完搞完之后下面还有别的什么呢？

叫 string to time to time呃time ID to time to什么什么一堆东西是不还是一堆转化器，因这里面定义了N多个的一个实体的对象，这没问题吧。这第一步要做的事情。

第二步叫什么呢？叫ad default for什么。😊，啥玩意儿格式化器吧，是不是格式化器，然后点进去依然看一下。

是不是可以加一个叫number format education format factory，什么东西，对吧？我这不不往里边点了，不往里边点了，你挨个往下走，是不是这做一个判断，判断完了之后。

这有一个叫datatime format register，对吧？后面还有一堆的一些逻辑判断，有个date format register，是不是有很多这样的一个格式化器了，就要转换完就完事了。

再来来看第三个叫at application format，把刚刚那个转化器是不是加进来，点进去。😊。

叫叉 array format address formatO of set format是不是列值再往边 string to to string number to好吧，以这大家看到了。

这里面包含了很多具体的一个我们这不用管。但我知道了整体上来说这块一共完成了一件什把我们很多的一些转换器格式化器对象都已经提前创建好创建好之后加载到我们当前这个con service了。

而这个version service最终是不是还要给到我们的ronment里所以它有一个层次递进的一个关系O来往下这时对象。

这个值是不是已经有值了后把个值回去回去之后叫ronment conversion service是把它加载到我们当前这个ment里加之后你可以看一下bug里面的一些值来找一下我们的vironment找完之后找一下刚看到着？

😊。

哥大啊。Environment。哎，哪去了？看这conver service吧，点完之后这儿有一个converers点进去。😊，conver连续多少个。多少个？一共134个吧。

这是不是意味着把我们所有这些转化器的这些工作是不是都已经加到里面去了。那这块之后在做的时候，还用我们操心吗？不用们，你在写代码的时候，他是不是有些情况下自动也会帮我们进行转化。

如果说它转换那种格式不太符合我们需求的话，我自己是不是也可以进行自定义。自定的时候，它也会进行整体的一个装载工作，加载工作也能够进行一个生效，就这块东西。所以这样啊都比较简单，来。

到到为止能听明白同学扣个一。😊，你最起码要知道说他这一步骤做什么事儿，做什么事儿，你平常用的时候看起来好像很舒服的样子，好后没不知道什么是做的。但其实在初始化的时候，或者在创建这个应用程序的时候。

他已经把这些基本工作都帮我们做好了。做完了之后往下看下面两个东西就非常非常关键了。第一个叫配置property source。第二呢叫配置pros。这个profis到底指的是啥呀？

proper source不用说了吧。😊，就我们参数的一些属性值，对不对？这proper值是啥呀？😡，有人知道吗？对spring你想一下，你在配置的时候是不是指定过多个环境。比如说有生产环境。

有测试环境，有各种各样环境，它指定一个属性叫spring点pro点active。你可以指定说我可以在多环境里面进行直接的一个切换，就是多个多个配置这块就这样一个意思来挨往里边看挨往里看好吧。

先看第一个叫config这里面做事情也比较简单，刚刚我们看到了，在我们当前这个ment里面，它所谓的pro一共有4个值，对不对？

是不是拥有4个把它4个参数直后记住 config呃 contest systems properties system把它四个值直播记住。因为这现在它要往里边加东西了，加东西了，来点一下往下走。

这时候告诉你，这是一个里面一共包含4个属性值这没吗？有吧。😊，看看看第八个里面参数值吧。点下去，这有一个sce，是不是4个，还是刚刚那四个，这个没没有变化。然这儿会做一个判断，判断的时候会干嘛？

它会往里边重新创建一个叫default properties的东西，就默认的一些参数值的配置啊，默认参数值的配置会往面加这样一个属性。但大家都知道我们现在里面包含这样一个值吗？包吗？不包吧？

所以这第一个步是什么？叫不等于空，并且什么不等于 empty的时候会进去连进去能进去吗？进不去吧，进不去没关系，往下走这this点 command大于我们这有参数吗？参数吧。

参数会跨过去参数会跨过去大家看到了这个里面好像没做什么吧？我做完这个步骤之后，它依然还是我们四个参数属性值但你要知道它后续的时候为刚刚在这个方法里面。

它指定了一个de虽然现在没有之后是不是也一定会往里边进行一个具体的添加工作，只不过在这步里面没有进行一个完成工作，那后面肯定会完成嘛，现就这样一个悬念，看一下它什么时候做这件事情呢好吧，第步干嘛叫。

是不这里面你能看到很多你认东西来看第一个你一个现在集合吧这个值现在是空的，现在是空的集合进行一个重操作这。😊，第二种往下走叫inronment的get active profile。你想一下。

我们现在我们现在有指定任何配置文件吗？没有吧，大家可以看一下我这个配置文件啊，几乎都没写，找一下我们的这一面有写东西吗？😊，没有吧，是没有哈，没有没关系，我们往里边走一下。

点进去叫getdo get X profile吧。然后再往里边点，到了之后，你看下这个属性值。😊，呃，不是不是。是这个东西。看这个名字你瞅不瞅？😡。

叫spring点perfuse点active看这名字了吗？这名字熟吧。是不是有感觉了哦，原来是读取我们当前这样的一个参数值，这东西你在生产环境里面肯定会用的，一定是多环境的配置，测试环境了，开发环境了。

对吧？包括那个上线上环境肯定肯定有这样的配置啊，这一定是有的，所以回跃之后，这里面就干嘛做这样一个参数值的一个判断完之因我面都没有没直接返回就了。们没配，以是返回但你要知道它完成了这样的一个基本工作。

如果它有的话加回来，没有的话，那这个值还是空了，是不是还是空的，什么都没有大家看干嘛，把我们刚刚设置好的这个活跃文件加载到我们当前这个ment里面来。😊，是不是加进来了？

当然这个ID profile是什么？空的嘛？我说了，我没指定任何值，所以这时候是空的。😊。

空空了吧无所谓啊，无所谓啊。回来这时候再往后走。大家看一下刚刚那步骤是完成了。所以这里面你看到了，它除了这里面其实做两件事。第一，加一个什么，或者判断一下有没有defa。

让那个pro样一个参数值第二个加一下叫就加两个东不加大家注意下行了，注意下。第三个叫configurationcon source点 attach很多刚了老师这一个at面是不是还有一个att你看完这块的一个逻辑后。

你就知道为什么这里面要包含这样一个参数值了，其实非常简单都是把什么加进去，中间只不过经这样环节做一个转换器，他怕你转换过程中里面丢失了，所以后面重新加了一次仅此而啊，试一下吧。

击看下什事第一个是断言不管它吧第二个往下走是不是获取到我们当前这proper source这里面还有几个个吧看一下是不还是4个没任何变化，没。😊。

然后呢往里边点，这儿有s点ge。😊，看那儿看上了吗？是不是叫configuration purpose。我们现在这里面有这个configuration purpose吗？😊，有没有没有了？

所以下面要做一个判断了。如果它不等于空方法怎么做？如果等于空的话怎么做？是不是我们要看一下什么，看一下这个等于空的时候，他做什么事，对不对？在当前这个等于空的时候，它跳到里面去，还是往s里面加东西。

这里面加东西就非常非常关键了啊，非常非常关键了，为什么这么说为什么这么说，一会儿往里边看一下，你知道大概是什么样的一个意思了好，往里走一下啊。😊，来看一下，点一下这个F7走。

第一个创建一个呃是不是一个构造方法，这个造方法非常简单啊，不管它了。走走走。然后第二个看这个参数值是不是还是那 configurationration properties。

第二个叫new spring configuration properties source，点这个对象。😊，点完之后点速，点完速号之后，呃，这儿也是它是吧？看刚一个属性值是吧？这点还是放死。在这儿。

往里面看站出来这个值了，刚刚取过来一个属性值，是不是叫configurationproperpro完了之后，会把把它加到我们这个property source list的集合里面去。

所以这样可以完成这样的一个基本工作，往下走走，你走完之后，你再看一下当前这个值几个了，12345了吧，是不是相当于我加一个值，而且加那个值会放到整体的最上面吧。

叫configuration propertiesper。所以它现在你看到几个了，12345个吧，是不是包含5个参数了，这5个参数是什么时候加载的，你必须要知道。😊，刚才过程我已经带你看过了。

你必须要知道它到底什么时候加载的，听白我意思吧？好吧，做完之后来回来，是不是这步做完了，做完了吗？😡，知道这个函还是干嘛了吧？就是忙主判断一下，我有没有con是proper。如果有的话加进去呃。

没有的话就加进去，有的话就不管它了。懂我意思吧？就这块的一个基本工作好了，来，到这块到目前为止能听明白的同学扣个一。😊，谁让你记他了？😡，你记得干啥？😡，这个原码不是让你去记的啊。

你要说老师我把原文背下来，我也背不住。但是里面关键的某些步骤，你把它能说清楚就行了啊，这比较重要这比较重要。OK好了，这块判断完之后，下面又到这个环境叫thisers。

然呢第vironment prepared一看到这个方法好像有点似曾相识的感觉，有这种感觉吗？😡，有没有种感觉之前是不是也见过一个listers叫什么东西？

这不之前叫什么叫listers点starting嘛，是不是startings，现在换了吧，换了叫warpre呃prepa。就说我们环境准备，刚刚是应用程序的启动，现在是环境准备，往里边点自己回头写一个。

你写一个干嘛？😡，不要重复造轮子啊，没意义，好吧，点进去点完之后看这个环境了吗？是不是又该进行一个listerer了，你告诉我还记得这个listers是谁吗？😡，这真测之前还有印象吗？

我现在不带你看那个值。😡，有没有同学记得上节课讲的叫eventp，然后呢run listeners吧？

是吧记得这个东西来往里边看一下是不是这个值even publish listener是不是还是它整个我们这个程序启动的环节里面，唯一的只有这这只有这个对象。但这里面还包含很多其他的值好还包含什么？

我们之前说的那是1个鉴听器吧，然后再往里边进行点击走点进去之后又到这了吧，这个时候看到一个新的对象了。

原来叫application starting现在呢叫applicationpre event是不是相当于我多了这样一个对象值看到了吧。这块处理逻辑啊，调度同一方法。

基本上是一没法点这是创建我们那一个对象，你往里边看一下也没啥完走，是不是就记住一个时间这没啥值好，没啥值不用管它就创建这样一个对象，完之后往里边走，走这行是不是看到它了，点走走到这方法里面去。

到这之后又熟了吧，嘛呢？往下走走到这值。😊，空的空怎么办？这样有一个方法叫get application listeners。它是一样。

我要通过干嘛从那11个对应的一个参数里面值把它取出来符合我们规则的吧。什么规则叫applicationenvironment什么？😡，application environment。

然后呢prepared吧，还记了一个疑问的事件吧，把那个事件给我记住了，我那看看这是不是有个疑问，看那叫application environmentpre疑问，把这三种值给我记住。

然后进来之后往下走走走。😊，这有一个哪去了？这样吧是不是检检索我们对应里面信息值往下走listener，这有个判断，这是从缓存里面直接把这值给读取来把它读取出来。读完之后。

这有一个叫sports events吧。我们都知道刚刚这个s这个lister有多少个。😊，看下里那是多少个。list似点list的事有吗？多少个11个吧，是吧？还是11个，所以我还是一样。

要同是1一给你们做一个筛选了吧，来走。😡，第一个你不不不符合吧，好吧，走走第二个是不是进来了，进来正好往里边进行一个添加工作，叫struct不even什么的东西这还是一样。

最终要往里边进行一个整体添加工作。但是这儿我希望能带你们好好看一下，因为他这把这个鉴定事件加进去之后，并不是说我加就完事了，不是这样的，他还是要做一些最基本的一些工作的把最基本的一些工作的连系看一下吧。

这儿先先过滤吧，先过滤好吧，一个了啊，刚家看到了，这这是第一个。😊，第二个吧。啊这边哥走走走走走，你不要说了，一会儿看，我直接看结果就行了。😊，这就是一个循环工作。OK循环完了吧。

循环之后来看底下的一些参数。😊，找一下 listeners有几个1234567，是不是包含了一共有7个参数的一个值，是不是共7个对吧？记住记住这个参数值好吧。

记住参数值同时还有一个什么叫this点还往这里面也加了一份加值多少，是不是还是7个这只是一模一样的，还是这7个都没有什么变化。你把这个值记住行了。好吧。

知这里面放这样一个对象放完之后还是一样挨个往下走吧，这里面干嘛的获取并对象，然后获取不了往下走走走把它加进来，加完之后返回我们这个值一共有7个7个围了之后往回走走走这时返回7个返回7个之后。

这开始具体的一个执行工作了。这个步骤我们看的因为之前想一下，第一次我们看那个事件的时候，是不是一共有4个我不知道你们还记得没，当然是成4个事件。那4个呃是不是有4个er个里面是只做两件事。

第一个叫log system是不是日志系统的一个初始配置。😊。

还记得吗？第二个是什么？是配置了很多转换器、格式化器等等等等很多操作参数。还有另外两个是什么做作媒体。那这块在执行的时候依然是一模一样的。我们还是要挨个进行一个最基本判断。走，第一个叫什么？😊。

叫config fail application listeners，你一看这个名字就知道这两个东西一定是有用的啊，一定是有用的。为什么说一定是有用的呀？😡，老诉啊，这个有用吗？😡。

也用啊这块可能会往里边跟的比较深，跟的比较深。因为你看到这配置文件，我们最主要处理其实就是配置文件。这个地方可能会跟的比较深。我希望这块你能够好好听，好好听听这块东西啊，来往这边走，😊，对。

就它listers往后走点进去开始执行吧，点进去走走do invoke listeners点进去点完之后，这儿有一个lister on application event。

再点进去点完之后这时候做一个判断了，判断一下当前这个事件是不是application environment event是它吗？是吧？是的话就往里边走了，再点进去是不是整体的一个处理环节。

在这个处理环节的时候，这有东西叫什么叫load post processor，这都西干嘛的。😊，啊，是干嘛呢？叫pose process吧。😡，是我们在注spplay里面，你们见过这个东西吗？😡。

在我们注入并对象的时候，它相当于是不是一个构造函数一样这样的东西。那这块大家应该知道啊，在词里面经常见到这样这样这样单词，你就把它理解为一个处语类就行了，扩展处语类就行了啊，也没什么特别难的。

然后点点去到下面了吧，这有一个东西叫springfactor loader点load。😊，唉，点点点点错了啊，不管没关系，好家看点击方法做断了吧。😊，嗯。

到这方码叫spring factory loader loadfactor这个东西搜不熟？😡，是不是还要告诉你说，我要从我们刚开始那个spring点factories这个文件里面开始加载一些具体类名了。

加什么类名？这名称告诉你了叫event post processor。来点开我们那个配置文件，我说了啊，我都提前给大家给粘出来了啊，往下再往上翻。😡，找一下叫evenvent，找一下看这儿。

是不是叫environment post processor，你点这个地方，第一个叫cloudary什么呃cloud found found什么东西。第二呢，th application什么东西？

第三个system ENV property source environment postpro。第四个叫debug agent environment post processor。😊，之前几个值。

一共。😡，我有有几个是不是一共包含4个具体的一个值，所以我这儿加载回来之后，是不是4个一定是吧，来往下走。啊，这这这这这已经过去了啊，过去之后我们看一下这个值吧，刚刚点快了，过去了，包子抛在这。

怎么5个啊。😊。

下面还有吗？看下下面还有没有了。别玩我们的pospo。没有了。没事，应该四个怎么5个呀，看这五这是啥啊，第一个这有第二个、第三个、第四个看这儿，这加了什么东西。看这加个什么东西，叫艾 at this吧。

是把自己本身也加进去了，所以是不是一共5个对着呢对着没没说错啊，是不是有共5个用过之后这 compare short是把它进行一个排序操作，当你排完序之后，这你要注意了，注意什么事。

在这里面开始进行一个for循环操作，而这个for循环操作里面叫post是不是开始往里面加这个东西了，好吧，挨个来变一下试试。第一个先取出来叫什么叫sstem是不是先读取来是这样一个重性值。

这里面它做一个什么事，你可以往里面点一下一个get environment告诉你了，是这这不管第二个数是get这就是我们当天一个主动一个程序。😊，来看一下英文配程程程程序啊。

找一下找一下这even问是这个英问的。唉，到了没有啊？没看到啊。点个单看一下吧。even问他get spring。

看看是不是我们之前说的spring datasring data application包含了我们当前这个类啊，这类是不变的啊，就是我们的一个主类主启动类，然后再往里边进行点击。

叫post process，这里面就很关键了。点一下这个参数什么值。😊，叫system environment吧，还记得我们之前那个source properties里面是不是有加两一样东西。

就现在我先把它给获取到，获取到完了之后，第二步叫environmentge process叫get，通过这个名字把它拿过来，拿完之后等于空吗？不等于空吗？不等于空。这做了整体的一个替换工作。

叫replace property source，点击看一下。😊，干嘛呢？把这些值取出来，取完之后放到一个mac结构里面，放完之后，他把刚刚那个配置参数值是不是转成什么了？

叫origin aware的stem environment property source这就做这样这样一个对换对象转换，其他操作都没做。

我到现在我也没猜测到说他为什么要把这个对象给转换成这样我不知道好，我只知道说它里面做这样事，但是我没猜到它为什么要这样干你懂我意思吧？好吧，反正不管你记住一件事，它这个操作非常简单。

就是把我们刚刚那个呃系统参数的一个值sstem是不是做了一个对象转换除了这对象转之后转换之外，其他东西都没做懂我意思吧？好，这是第一个我们要做一个事。来这块听明白同学扣个一。😡，你听我说啥吧。😡。

就是我们在读取参数的时候，有一个sstem environment这样一个对象，但那个对象拿过来之后，好吧，他在里面做一件事儿，把那个对象转成另外一个类型。但现在我也没猜到他为什么要把它转成这个类型。

还不知道如果谁有那个研究过的话，跟我说一下，我没猜到为什么这么干你懂我意思吧？好吧，没关系，来自接着往下看其他的拿循环循环。第二个叫什么叫spring application jason是什么东西。

你一看到spring jason的话是干嘛的。😊，肯定是要处理我们对应些站线数据了吧，点一下走这都不用管它啊，点进去到这块了吧。这里面你看到这样一个操作，点一下这个波包的操作于谁？😊，看一下。

是不是configuration source里面是不是传了这样一些参数值好吧？这值啊很多了，我们点看一下吧，叫property source是不是一共有对应的5个值，是不是有5个值，就这5个值。

这5个值拿过来之后，它变成一个什么是不是一个集合对象有后点是JK1。8之后，它保留出来一个流处理或者说函数成吧？songe什么 filterter过滤器吧，然后放找到第一个，然后判断一下这个值。

然后priceson是不是能处理我们对应的一个son一个对象了。😊，是这意思吧？好，它能处理整体的一个战对象，你往这里面做一下。😊，你点完之后，你发现了又了一个什么。😡，看这块儿。

是不是你了一个东西叫jason propertyty source啊，你点进去是不是就加了这样一个值，叫applicationation，叫jason嘛，这三个值说吗？😊，之前有人见过吗？😡。

来见过同学扣个一，有没有人见过？是不是就有他说哎，这东西见过吗？没见过。😡，这个参数值你们都没设过是吧？😡，就是说允许我们对应的一个参数值，它以jason的格式啊，进行一个呃数据传入啊。

就这个意思没别的东西啊。啊正就是jajason，如果没见过没关系，但你要知道说他这里面做了这样一个基本操作。😡，你把这基本操度操作给记住了，是吧？记完之后往回返，我不看它了，那我就不看它了。😊。

这接着往下处理吧，往下处理走走走做完了吧，是不是第二个过虑做完了，做完之后就相当于说我这只是说允许了一个真场的一个基本操作。别的东西没有了。来再往家看该第三个吧，往下走走，第三个是谁？

叫cloud放 found什么东西一看到cloud肯定是云下面的一些东西啊，我们这里面有涉及到云上面东西吗？没有吧。所以你方这个点之后，你会发现它里面好像什么事都没做一样，点进去，这是有一服判案走。😊。

有做任何事吗？没做没做就不管它好，这是第三个事件了。来看大家看第四个事件叫confi fail application。你看到这个值，很同学应该知道了哦，原来这看到它了吧，这里面做的事情就比较多了。

做什么事，就比如说很多老师老师我们在读取配置文件的时候，可以是application点 properties也可以是什么叫M点 properties了。那东西我怎么看的？我怎么知道它有这样一个东西的。

从这儿你就能看到，你就能看到我们来看一下吧，好不好？😊，来点下试试吧。第一个获角当前环境，不管它，第二个还是application，不管它点第三个。

然后呢再点这块叫application点get resource loader，它是不是就获取了一个resourceult loader的一个值，对吧？点一下试试吧，看一下这个返回一个值值是空的。

不管它。第四个叫ad property source，该加载我们proper这些 source资源了吧。然后往里边点点完之后。

第一个叫random value property source点ad to environment，这干嘛了。😊，re value随机值吧，你想一下之前你在你的配置参数里面有没有见过随机值这样的东西。

应该见过吧。😡，大家见过吗？就这样就这样这样写法，我们有没写过，我来写我随便写一个，就这个就这块东西，是不是到了pro加一个run点。😊，是不是int对吧？是不是还有浪是不是这样类型值上一个见过了。

对吧？O这块就注意啊，就它里面加这样一个属性值，仅此而已。所以这块你不用管它这边加完之后，我们可以往回看，看里面做了什么什么处理啊，点进去点完之后这有一个ment吧完之后这一个ad after。

然后这有一个参数的一个系统值，是不是叫sment当前系统的一个环境，加完之后，第三个叫newrandom value property source，random source name是redom。

告诉你说你可以redom进行一个开头，下面告诉你了，这是一个前缀是redom点，后面呢这里面提供了很多的一个哪去了。😊。

没在这儿啊，是不是get nice in什么range这些值，反正都是返回我们这样乱转那么一个值啊，来慢走一下试试吧，点一下，这是获取到我们的property source。😊，听到。

那再往下走ad up是不是往里边进行一个调用，是uper往里边点this都是往里边一直往里边加加东西就行了，这好不用看它了，最重要会会会。然后呢往这边走到这儿吧，叫艾 after吧。

是不是开始往里面加我们这东西了，叫ad at index是一，然后property source，是不是把我们这个值给它给加进去，是不是给它加进去，加进去之后。

意味着你当前环境里面已经允许允许我们出现random这样的东西了。这个东西怎么看也非常简单，点开我们的debug。😊，点开我们debug，debug之后往里边找，找荧光问。

找property source，看它有没有多一个东西。多了吗？说个啥？是多了一个run怎吗？这样东西。😡，啊，看这儿最后一个专代膜刚刚第一行执行完之后，是不是就是专弹膜之前是不是没见过这东西。

之前一直说是5个嘛，现在是不是6个了？😡，对吧，所以这块儿你能看到具体的一个职业情况。这做完之后没完，这东西还是比较简单的，ra道什么？我可能在工作中可能压根不用它。

因为我没有那么多的一个随机值的一些情况，下面这行代码就非常非常重要了，叫newloader点loader。😊，这个你有lologgo是干嘛的呀？😡，就是用来读取我们之前说那些配置文件的东西。

来点一下试试。new loader往走啊，这里面开始开始开始操作了啊，比较关心了。就第一个哎这是对对象啊，穿理完第一个enment等ment还是我们的标准serv一个环境。

不管它第二个叫new呃proper，然后呢s这不用管它走走到这块之后，这有个东西叫load factories这种西应该比较熟吧，是不是又看到这句话了，之前已经不止一次，是不是见到过这句话了。

就是用来配置匹配什么？匹配我们spring点factor里面的文件，这类面叫什么？叫property source点 loader，是不是它点一下往上翻。

最上面是不是叫property source loader。😊。

看东西了吗？它取完之后是不是应该取回来是两个具体的一个类，一个叫什么叫properties呃，pperty，然后s loader。第二个呢叫EMR propertyperty source load。

是把这两个文件给你加载过来。当然这是两个具体的类，把这两个具体的一个类，具类完了之后，还要干嘛？我们看一下这个logofactor啊。😊，嗯都忘了走不管他，这卡手都不要他。各father，你往下翻。

找一个东西啊。啊，走走一下吧。看这儿第一个是获取到我们这样的一个factorory实现的一个名称吧。我们可看一下这个名称是啥，找一下这两个看两个类是两类吗？😊，是吧有了两泪之后没完没完，还要干什么事。

叫呃在往找找找找这东西这干嘛的？int什么东西吧？一看到int很明显，它就是为了进行一个具体的实例化操作吧。来找一下试试吧，大家走一下到这我们走一下。第一个加载过来是什么？

叫ORG吧不第一个这加载之后点下搜是不是进行一个实化操作实际化就是我们反射叫reflerele有点什么con获取到当前一个构造吧建完之后点艾是不是把当前的类再带过来大家想一下。

你要想完成这个类的一个注册的话，你必须要干嘛？是不是看一下当前类的一个构造号TIES。😊，是不是找他是不是当前情况下，我们这个类看下这个类啊。😊，是一位老袋点开lo袋。哎。😊，PROPRTIES。啊。

LPTY source logo。是刚才这一类这里面告诉你啥了，是不是有一个东西叫点叉2同时告诉你呢叫get file extensions叫application啊，不是pro点叉2吧。

是看看是不是两个一个是proper，一个是叉2，是不是两种配置文件方式都可以进行一个整体加载，是不是这样一个方式啊？OK这是第一个第二个还有什么东西来着？叫2吧，哎，是不是来了么？😊，YA。唉。

叫啥来着？看看纸啊，把纸拿过来。大记不住啊这边告诉你了，后里面是啥，是不是YMR和YAMR那意味着此时当你完成之后，我应该就完成了具体两个类的一个实例化工作。

对不对结果回去结果里面一定两个里是是这个个pro load个叫 load加回去样就这直接返回返回完之后这就有了有了之后后面别忘了还有什么方法叫load方法吧，是方法。

你可以点一下我们当前这个方法方法里面它做事情其实也比较简单也比较简单ment里进行一个直接资源的加载这里做的bu不好g是什么我对应式里面一些西表式不太熟，块不明白但你要知道一件事。

这里就完成一件把我们当前的一个配置文件里。😊，你的一些相关属性值给你完成一个整体的加载工作。所以当你这儿完成之后，拉走拉走拉走。

哪去了？okK是不是完成了，完成好之后，你往上翻看我们刚才的绘画，找一下我们的environment。😊，唉，我给玩问去了。

点它点下我们的sourceproper source点它多了一个没多了吧，是不是多了一个什么东西叫application这样亚M啊。如果你这配的是properties的话，你改觉变成proper了。

如果你这配的是YIM2的话，就变成YIM了。所以这能够把我们当前这个文件是不是读取过来。所以又看到了你当前这些属性值加载的时候，一共是从这7个地方进行加载的，就是刚开始你整体这个加加载的过程。😊。

听白了吗？来到这儿能听白同学扣个一。能听到。刚才是不是也懵了？所以你会看到这个环境，你的环境啊吧，这里面东西都会把你给读过来。这一启动，要把那两个门件中的所有的都实例化吗？呃，需要用的实例化。

不需要用的不实例化哇，需要用的实例化，不需要用呃，不要用就不实例化了，这啥意思啊？😊，也就说刚刚给大家看那个东西啊，这里面是有很多的类，它是以K杯的形式存在的。而每次在取K杯的时候是get什么？

getfactor是不是这样的方式来读取的？你读取过来之后，读取过来之后，我会进行一个有实例化就实例化，没实例化，我就不实例化了。看你句代码怎么写。😊，明白了吗？呃，就说需要哪个用哪一个到目前为止。

我们看到哪些。第一个它是加载过了。第二个它是不是加载过了。好吧，第三个这块会一会儿就看到它加加载了。第四个初始化加载过了吧，la似是不是加载过了？好，proor是不是加加载过了？它这个暂时还没用到。

一会儿会用到它好，再往下看还有什么东西。😊，这个一会儿有用也也也会用到啊，inter用过了，用过了listener这个这这个还没有用到，一会儿一会儿用到了，一会儿用到它了。好吧，再来看这个也没用到。

这非这是那个自动导入口会用的，下面都是自动导入会会用到的东西。😊，听白吧？也就是说你需用的时候会进下来，基本上所有对象都会给你加进来，好吧，基本上都是这样的。如果有多个配置文件呢。

你多个配置文件也没关系，我说了，它会把你当前炸包路径下面的classs pass路径下面的所有sp文件都读过来。刚刚这个地方其实就是两个配置文件里面东西，就是两个配置文件呢，不是不是一个。

我只不过把两个东西合到一块合合合到一起的。我这可以看一下吧。😊，来给你看一下啊，这第一个spring boot里面的一个东西，你点开之后，你发一下最后箱都到哪到C10let reporter吧，点一下。

😊，呃，reporter reporter。拿去了？说到这到这结束了，从下面这开始都属于第二配置文件的啊，都属于第二配置文件的啊吧，它不管你有多少配置文件，它都会进行加载的啊吧。

在刚开始的时候就进行加载，而且会把它放到我们的缓存里面。你把上节课那个视频听一下就知道了。我上节课讲过这东西啊，都是聊过这东西了。好吧，这要关了啊，不管它了，不看它了。😊，所以大家看到了？

刚刚我已经把我们对应的一个配置都加进来了，加进之后，这个循环还没完还没完，还要往下走，让大家走一下走。第四个是不是又看一个post了，这叫啥？叫debug呃ag environment形式东西。

是不是这玩意儿，这玩意干嘛的呀？😊，啊，往下走看试一下吧，这是debug里面要用用到一个东西啊，走一下。往边走看看就跳好判断是不是什么都没做，这什么都没做，直接跳过去了，哪走走还有吗？没了吧。

是不是我们一共找了5个对应的一个popo的procesor，但这5个里面5个里面其实最重要是谁？是confi application listener啊。

是这里面的一些procesor一些一些相关相关相相关的一些处理，其他东西几乎都没用，懂我意思吧？这做完之后往回返好吧，往回返反到这之后，说到这呃哪哪去了？往下走走走走。😊，走走到这了吧。

是不是又该变离我们的lister了，还记得刚刚几个lister吗，是不是有7个是不是7个往上走。第二个我再往哪走。第二个叫什么叫ANSIoutput application什么东西？

这东西啊我们不往往不往里边看了，没啥用，就设置ANSI的一个输出。有人知道什么叫ANSI吗？😊，知道吧。这东西应应应该知道吧，什么时候知道他，给我举个例子。😊，不知道啊。天哪，来往那看。

你点开它是不是打APPS文件，你选文件并存为这上面你选一个东西叫ANS，看到了吗？😊，是不就是编码格式就编码格式而已，看这块了吗？默认是不是选右右编和是不是可以NNSI就编码格式这块不用管它好吧呃。

对我们的影响也不是特别大啊，就这样东西好了，这块不往里面看了，再往走。第个in application什么东西这个log application这个东西见过吗？之前我们是完成了一个初始化日志系统功能。

这块也一样的啊，也一样的往这走了，好吧，再往下走第三个叫class pass login什么东西点一下吧，我点下不舒服，点一下走能做什么事了吗？没做吧，这什都没做来没做往回这再往下走。

第五个叫background什么什么东西这个background什做什么事了吗？走点进去。😊，点进去走走看这儿是不是全部全部都没有，对吧？是什么什什么什候没做没做，再往下走。

叫digationPK什么东西，这边也一样往下走。你自己玩烦玩点点试试吧，好吧，反正几乎大部分东西啊，这时候做了。😊，这就是一个获取到一个list似的一个对象，获取完之后做一个return。

战时这接return了啊。如果这个短于空，直接return回去，所以相当于跟什么事儿也没做一样，什么事也没做一样。好吧，来后走。😊，再往回返。第四个叫fill en口点，这不用说了吧。

这也是一样指定我们对应的一个什么文件编码格式吧。这不看了啊，向下走还有吗？没了吧。刚刚大家想一下，我是把完成的7个具体的一个呃list型的一个操作做完了，做完之后往回返往回返往回返往回返往回返。😊。

是不是到这一波是不是刚刚看到这波，下面是不是还有呢？是不是下面还有好吧，但这步你要知道了，上面其实干嘛就是创建了一个最基本的环境。然后呢，往环境里面多加了一些配置参参数，仅此而已，别的东西就没有了。😊。

听白我意思吧？所以大家想一下，我们花一小时时间就讲这买东西多吗？😡，不多吧，来到目前有点没听明白，同学扣个一。多呀。😊，1。5。呃，多也要看多也要看，你就想了我现在带着你看我不带着你看你往里边走的时候。

你走多少走多深都很麻烦都很麻烦。懂吧？你现在能听多少，能听多少，能进记多少记多少，自己下课之后多迪拜了，都往里边点点试试，多看看你知道哦，原来这么回事哦，原来这么简单，你会有这样感受的。

很多同学现在没这样感受，原因是啥，是因为你们之前没自己看过，没有一个自主思维，或者说我应该看到你的层次就结束了，你没有这样感知。像我之前第一次看的时候也一样我我我怎么看也是一样。

先把整体东西能看懂的就先看过去，看不懂方法，不管了，都往里边不往里边深究。因为你的方法如果一层一层一直往里边点的话，点完之后你就疯了啊，点完之后就疯了。好吧，今天早上看到这里的，像我就听得听得懂点。好。

能听懂就好。😊，啊，不知道在干嘛。😡，配置环境啊准备我们的环境啊。😊，就是想一下，你现在如果想允许你的GDK想允许你的GDK你GDK的话需不需要一个环境？😡，需要吧。那同样的。

你要想运行你的spacebo的一个应用程序，它不需要一个环境吗？需要吧？就说在这个环境里面，我需要做哪些对应的一个准备工作，仅此而已。😡，O。😊，好了，把刚刚讲的东西啊先放一下，我们休息10分钟。

10分钟回来之后我们再接着讲。好吧啊，放酸脑子抽根烟，上个厕所，喝杯咖啡，好吧，放松一下OK。😊，🤧嗯。Yes。压力山大。呃，想一件事儿，家看他是好事儿，你看懂了，别人没看懂，你面试是不是沾光了？

别人随便的人都能看懂的话，你面试的时候没有什么优势啊，对不对？😡，补补图。呃，这个东西啊跟我们的park不太一样。park不太一样。像sk的时候，我们之前画过很多的一些图给大家画一个东西。

但为它里面有一些，比如说组件statement excuse这些对象里面干什么事？这东西都是一层一层嵌套的。我在这儿debug看的时候，往里边找的时候，我自己都找不到，有时候自己都找不到。😊，啊。

他因为他这个对象的一个嵌套功程太太麻太复杂，太麻烦了。😊，懂我意思吧。等我们把整个启动过程完了之后，给你们画图，画画整体图，行吧。我这个这个笔记你们看了吗？😡，这东西你们看了吗？😡，有有人看这东西吗？

😡，没人看啊。我在你我在这个笔记写的时候，我把我能写的东西，我基本上都给你们写进去了。只不过有些方法有些方法只不没有点那么深，因为都往里边粘的话太麻烦了。然后我其实刚开始的时候。

我设想是我要自己编一个呃s2。2的一个源码给大家看一下。其实我也编译好了，但是不能用，就很麻烦。😊。

大家看一下啊，我之前真的想在那个圆码里面自己来做这件事情的。😊，给你们看一下吧。现在这个笔记跟那个注释啊都是分离的，我原来是想往这里面写的，原来写的时候，我其实写了一部分，但写完之后发现它跳不过去。

给大家看一下。😊。

喂。大家看这里面我写一些东西，我写东西写完之后，我发现我点的时候我。😊，看东见吗？呃，不对，不是这找一个东西啊，找一个。还有这个类啊跳一个类啊。这。上边吧，看这个地方，你点完之后。

这里面它跳的还是mve里面东西，还是没法在里边直接直接直接改。而且这里面还有还有一些错误的东西。反正这我上网搜些帖子，他们都说这个2。2里面有一些bug啊，反正跑不起来。😊，低版本好像能跑起来。

但高版本跑不起来，所以我就没没没往里边写写写写注释。呃，确实跑不起来，2。2确实跑不起来。呃，低板本是能跑起来，2。2确实跑跑不起来，我试了好久，真跑不起来。所以没办法，我只能帮你们写笔记。

帮你们写笔记。呃，我觉得我的笔记写的还是足够全了，足够多了。现在之后自己看啊，慢慢看讲呃，看多了，自然而然就知道啥意思，就就知道啥啥问题了，应该怎么看了。老师面试的时候，都原板都问哪些东西。

一般问的就是启动过程，包括我们的自动装配，这样东西问的比较多。如果再问的话，就是我们的starer下面的相关东西了。所以我说了这次原码我我本来打算讲讲讲比较深，后来想想算了吧。呃。

我们讲一下这个启动的过程，讲一下那个自动装备的一些原理。然后再讲一下。😊。

那个什么还有啥，还有一那个starker就就完事了啊，不跟你们讲太深了。呃，后面如果还需要的话，我们往二期里面加二期里面往里边加呃，不是二期啊，以后课程里面往里边加加东西，更新东西不讲太深了。

我感觉你们听的也好难受。😊，不难受啊。不难受就好。对，讲一步步流程，你把每一个环节能把它给捋清楚。对清楚就行了，好吧。你把每些关键步骤记就行，没让你都记啊，都记了干嘛没意义啊。我还那句话。

你看完这个原码之后，你自己捋一个流程线出来，每一步做什么事儿啊，面试的时候，如果问到这些点了，你能把它给说出来就够了就够了。千万不要千万千万不要像我跟周老师这样开眼板。我跟周像我跟周老师这样开眼板的话。

看完之后就疯了。呃，讲完这个启动过程之后，我会画我会画的，我会说的我会说的。去。等会拿拿杯水拿杯水回来，我们接着讲啊。Yeah。是。好来，还在的同学扣个一，我们见马奖。🤧嗯。呃，你看原码的时候啊。

千万注意一件事儿，不要想着把所有东西都搞明白。就我刚刚跟你说的那个一样，那些对象为什么在外面再包一层或转换下类型，我到现在都没想明白。但是它不影响我们整体大局上面的一个查看，懂我意思吧？

这样也是一样的啊，再往上走吧。好，往下看呃，刚刚我们看到这个准备环境这个监身器里面做哪些事情，下面再往看什么呢？叫boce to application。这个很明显发现过干嘛呢？

往我们的spring application里面绑定我们对应的一个这样一个对象吧，意思？这个时你外面看的时候你会发现一件就是比较神奇的事情，看点这里面有一个东西等于空吧？当他执行完这个代码之后。

你可以外面看一下，我看完之后我也没搞明它里面想干啥，往下走走，那很简单，一点都不难，做完之后，你发现了它虽然名字叫这样名字，但是它实际上这个值还是空的吧。像这地方我又懵了。

我到我也不知道他为什么做这样一件事，我现在我也没想明白你懂我意思吧。所以这块想明白，我们先放放，先不管它，反正不会影响我们后面的一个整体思路的，这块得先往后扔一边你懂我意思吧？

所以你也别老师把全部都看明白，太不太可能正我做不到那那那一点。😊，因为你毕竟不是作者，你不知道他怎么想的，你只能说根据他写的代码，你去大概去猜，但有些东西能验证出来，有些验证不出来，不知道干嘛的。

懂我意思吧？这大家要注意了。好了，我们接着往来看吧，刚刚是一个绑定的过程，绑定逻辑也非常简单，但是我发现没绑定成功，不知道为什么原根看了看完之也没得一个结论。

不管了吧看第三个这什么东西这做一个基本判断说is customer做了一个基本判断这个值默认值是for完以点击看一下这个是for。

刚开始就是for完之后这做一个判断感叹号区反就是进去这做一个执行执行后这个过程也非常简单，干什么叫new一个是不是做了一个类型的一个转换器转换完之后，这里面有一个方法，这个方法也比较重要什么呢？

叫duce。😊，这个方法有没有见过，或者有没有一种似曾相识的感觉？😡，有吗？来点击看一下啊。这是在这个不用管他。走点这get卡点不管它走。这是一万面的卡ver塔也不管他到哪去了。看是不是题就方法了。

在这方法里面词方法里面也非常一样，是判断一下我们当前这个应用程序的一个类型。吧它返回的具体的一个值跟我们之前一样。

还是standard environment为判断判断完后这样一个对象创建一个转换如必要的话，把进行一个转换转换完之后就还是我们对象这里面事就说会判断一下你当前这个环境是什么环境。如果不符合规则的话。

会再做一下这个事情啊，把它转成我们的环境到上上面一模一样一模一样的话，它里面执行的具体逻辑也是一模一样的，没有任何的一个变化。所以这块看下就行说了只是说转换环境的时候。

它会里面再做一次验证如果里面没们对应加话个事最我个ment进行一操作所此时相当于。😊，我们这个环境已经准备好了已经准备好了，就是这个环境准备。其他发现了环境里面我们噼里啪啦说这么多东西。

其实最最最最核心的还是啥？是不就是我们的配置文件要做的一些事情。如何读取配置文件，如果将来我们的配置文件这个东西好，这块记住就行了。好吧，这是环境这块环境完了之后。

再往下看下面一行叫config一个no并 inform这干嘛呢？这行代码。😊，这样代码也非常非常简单啊吧，它其实一点都不难。其实你通过名字也能够把它给猜出来它到底完成了一具体的一件什么样的一个事情啊。

什么样的事情。其实说白了干嘛了？😊，啊，干嘛了？就说这里面设置了一个系统的一个属性值，用来忽略我们某些的一些病啊，你点进去你能发现这样一个值啊，点一下嗯走下然后点F大家之后我看看这一个什么属性。

叫ring点 for点个吧。就说我忽略哪些对应的一个属性值，这样会做一个最基本的判断。如果等于空的话往下走，是不是这样获制到这样一个bo类型的值，把这个布类型的值放哪。

是不是sstem点 set properties里面，所以这块你看完之后，当它把整体的逻辑执行完了，你在我们当前这个属性里面，你能看到这样一个值ment。😊。

Ppery sauce。往下走，找到我们的stem environmentment systemem哪去了？在里面找一个s，找一下我们刚刚设置好那个值啊，叫什么？哎，没有吗？一起涨价。

叫spring点儿。你没在这里面。在这儿在sstem properties there里面。找一下spring一个什么东西。唉，没有吗？值是不是叫spring点就把那个属性给加进来啊，别东西没做了。

所以说只是说我可以读取这样的一个属性值来后面做这个并判断的时候，做一个这样一个判断啊，是否可以忽略我某些就这块西就这代码其实无所谓其实无所谓就是一个系统属性的一判断值看该干嘛了ban banner等于print banner什么东西这样是干嘛的。

很明显大家知道就是用来读取我们对应当我的代码执行到现在之后，你会发现控制台几乎什么都没打印什么都没打印一会我是打印一下我们那个sp那个那个图标了那个样式的。

就在这里面进行完成的所这里面我们也可以详细来查看一下。其实这块看不看问题不大，看看问题不大，最好看看吧，我们带你带进去过一下，这里面东西比较简单了。

点进去告诉你说 banner在 banner里你可以一个判断 model等于啥 model是我们之前进行一个设置的，就说你创建完这个对象之后。😊，不知道你们还有没有印象啊，我们再来试试吧。😡。

之之前我给你们写过这样一东西。酒不。就是你创订单对象之后，比如说你有一个。😡，Spring application。然后点set banner modelel，这里面有个model是吧？然后model。

第二。第二是不是有ofconl log有一一堆的值，这是不是可以把这些值做一个基本判断。所以刚刚第一步骤的时候就是用来把这个参数值做了一个小的一判断而已。好，所以这块也没啥啊，你没事的话。

默认是什么默认是是们这里面等于它吗？不等于不等等直接跨过去了那第二步干嘛叫re load什么东西是不还是用来加载我们当前这个re一个资源。

那这值是空的往看这现在是有了你了一个什么叫defa resource loader吧，还是一样创建这样一个默认资源的一个加载器里面就是一个对象啊，什么都没有什么都没有不管它了。

这做完之后一样的到DJ步这波比较有意思什么呢？叫spring application print是不是也是构造了这样一个对象这象里面也非简单叫JIFN等。😊，是啥东西。我们之前在放我们对应图片的时候。

客户是不是可以是我们这样的一个格式啊，再往走。向对象之后再判断这个模式是啥好，往下走到这步了，叫banner print是不是刚创建好对象对象完之后叫什么叫print environment class什么。

后 out进行一个输出这点进去看一下叫ban等于ge还是获取到们前样一个值注意了现在我们的控台里面依然是么输出都没有是为了获取我们这样对象点进去是用了一个完之后判断一下这个get banner是否能读取到我们当前这个图下个这个属性是这个图片吗？

是不是叫spring banner点loc你是不是可以指下这个属性，直接属性之后可以把我们对应一个图片移动到不同的一个位置。但现在loc是什么空的空完之后往下这判断了吧。

来看这步干嘛的叫spring e叫干嘛的我们的扩展名FPG和NG这三种文件格式慢走。😊，点完之后来获取走ase没有ase没有ase没有就没有的话，是不是都反反问空。

也就说我们现在并没有自定义我们对应的一个banner图片往下走叫get test banner是不是获取一下我们图片没有了。那ok文本就可以了吧。

点进去也一样的ban location是不是还是这个值叫sp banner点loc样的一模一样东西再点它叫 banner location是不是叫ban点 tST之前你要想替换ban的话，呃。

之前讲过的东西吧，是是放到我们的reult资源目录下面就可以了，它会进行直接的一个读取。那后读完之后，这是什么是不是也应该是我们具体的一个banner点 tST文件，读完之后。

然后呢ressource等于get resource是不是把这个文件给你读进来看一下吧往走走。😊，走locationstar位置，然后呢后往下走，这是不是有个location告诉你它在哪好吧。

然后读取我们当前这样的一个文件，把它给读进来啊，读进来。soexist往下走，是不是还是返回空，因为我现在也没指定嘛，所以直接返回空了，翻完之后往下走走，都是逻辑判断都返回不了。

所以还是我们的默认banner默认完之后到这儿的时候开始进行整体的一个打印工作，打印工作，怎么打印，注意啊，你看起来是一个图像，但是我希望你注意，实际上它本身看起来就是一个字符t，明白了吗？

来看一下对应效果，点进去点完之后是不是有个banner点进去，你看下就行了吗？😊，这边是啥？😡，字符串吧，字符串吧，是不是后面是不是也也都是字符串，是不是全部都是字符串。你现在看起来好像是乱的。

但是你把它的格式排列好之后，它就是一个正常的一个banner的一个图片。所以此时该干嘛了？该循环我们当前这样一个banner好，循环一下，来往这边走走第一行空的嘛？第二行看打印了吗？第一行吧。

再循环说不出来这一部分了，再循环再循环再循环。😊，再循环看这化信息了吗？我是不是经过N次的一个循环之后，我就把这个图片给打印出来了，是不是打印出来了啊，我说了啊，它本本身就有个字符串嘛。

你看见来之后就打印出来了，其实并不难也没啥难的，就打印这样一个东西。打印完之后还回回来这样获取一个 book的一个version告诉你多少2。22release让version等于它如果不等于空的话。

做一个转换。为什么东西做一个格格格式化转换转换完成之后，你有一个 builder，然后呢往里面进行循环添加了一个空格。😊，加空格。加括格之后，看那这是冒号冒号thringbo冒号。

然后后面加一个这样的空格，空完之后是括号V2。2。2rele大盘输出吧。输出完之后回车往往往回走往回走，再往回走，再往回走，是不是返回了？此时这个banner输出档打印出来了啊，可以自定义的肯定可以啊。

s定义的时候你可以放一个图片嘛，对不对？是不是也可以放一个天性文档，之前我在第一节课的时候，加thringbo的时候，是不是就放了一个banner点TSD。😊，好吧。

作者为什么给一个班长设置都设置这么多逻辑扩展性扩展性。你发现了，刚刚里面虽然看起来好像很复杂样子，但其实都是在干嘛，读取一下有没有图片的配置，好吧，有没有你自定化的一个配置，对吧？如果都没有的话。

我只能用默认配置啊，默认配置就是一些字符串，那别的了。😊，啊，只不过扩展性好一点，就是你自己可以呃定制自己画呃自己的一些东西，仅此而已。😊，这东西啊没上难的啊，听一下行，也不是特别关键。行吧。好了。

这个不是banner听白同学来扣个一。😊，这块比较简单吧，彩蛋没啥彩蛋啊，就是非常漏的一种实验方式而已。😊，但扩展性好一点，就是他考虑到各种各样的情况，你可以往里边放图片，也可以往里边放一个传文文档啊。

放什么都行。所以这个东西你往往里边点点试试，你会发现它并不难。😊，不low，看样码都不low，扁都很好。你看完之后，你觉得实现没没没没没没没多大那个那个意义，好吧，搞个小电影想多了吧。😊，好了。

这样搞完之后这样搞完之后，感悟说放什么图片都可以吗？放图片必须是什么JBGJFPNG吧，但一般你就知道这是干啥啊，你这是干啥，没意义，好吧，对，跟面试官讲ban点讲究能干啥没人用，没啥用。

没没没啥用处啊。😊，好了，不多聊了，我们下看这块下面东西比较重要了。好吧，这个东西是我们今天要讲的一个最核心的一个点，最核心的一个点就是我们的application contest。

刚刚准备的是什么叫environment，对不对？😊，是不是叫环境，环境完了之后还要干嘛？还是不是还应该有一个上下文的一个对象。之前我们上面其实见过了。

有一个东西叫confitable application contest，是不是这样一个类。但这个类是空的一个值。而现在相当于干嘛？给这个空的值附上我们具体的一个对象，给他一个给给给他一个对象，对。

所要怎么做的？叫create的application contest。😊，好了，别扯了啊，手往回这往上往下看啊，这步骤很关键，很核心很核心。然后来看过干一些什么事情，这里面一样的啊。

它也有各种各样不同的一个类型。所以点的时候给您看一下。😊，又看到了吧，这干嘛呢？你看这东西之候，是不是有点似曾相识的感觉？😊，之前我在讲那个spring application这个构造方法的时候。

我说了，永远不要小看这个应用程序的类型。因为后面在很多地方是不是都用到我们的应用程序类型。第一个我们的环境对象创建的时候是不是根据类型来判断的。第二个你的contest也是根据我们应用程序类型来判断的。

所以这个值一定要注意了。吧，来看吧。第一个会制到值应该是空的，因为我们没做过负值嘛，空的话没关系，这有一个switch的一个判断，判断类型是serv如果的话匹配到第一个第一个指向是某一个类。

哪个类叫annotation confi呃configserv web server application contest名字非常长非常长。😊，唱吧？为什么剑民之义嘛，是吧？名字写的非常长。

大家知道他读取的是这样一个类，然后他通过什么，通过我们对应的一个class表 for name干嘛了？是是把它变成一个大写的一个class的一个对象。它对象完了之后，最后面还有一步是一个什么步骤。

来走一下。😊，大家走到这行是不是叫bin有点，in什么class吧，是进行一个初始化的一个呃，不是进行实力化的一个工作。刚刚只是class对象，现在要完成一个对象创建了啊，整理下这样过程。

所以你往这边点了话，这个不点了啊，连之后就是一个实力化工作，这有一个什么来着？找一下。😊，一个注解的一个东西，看这return一个女称class class点什么东西会叫多导器。然往里边点的话。

一定有一个什么叫classown，找一下。😊，拿是吧。有一个instance，就反正就是通过反射来进行一个生成的。接下来自己看吧，找不到了啊，反正就通过反射来，你看到了是吧？

有有 new instancestance吗？😊，我咋没找到啊。啊，这是不是这有个newin，是不是这就进行一个是对象创建了啊，就这样一个过程啊，所以这块都不难，也没必要往里边面看看很身东西。

知道就行了。那执现完之后往回返回。此时对象有了吗？对象有了，但是你打开当前这个对象之后，你会发现打开我们的contds。😊，这个当前康泰斯里面哪去了？对面。机构错有值都是空的吧，是不是机构所有值是空的。

有些对象有些对象好吧，那大部分值是不是都是空的，是不是都是空的一些值之后就干嘛了？是不是该往我们这个contest上下文对象里面放一堆东西了，是不是放一堆东西？所以放东西，这就会成为我们的一个重点。

当然错之外这中间夹了一个步骤叫什么？叫exception reporter，这个exception reporter大家记得吗？😊，原来是因为这块不难，就创越对象了，就有一个对象的事就不难啊。

看这地方我们之前是不是也创越个对象了，干嘛的？是在启动过程中，如果报异常了，这样会有一个异常的一个数据器。同样的，你看完代码之后叫getspring factor instance。

一看到这个方法很明显干嘛了？是不是还是从我们的spring factor文件里面来进行数据的读取。像什么类spring boot exception reporter往上翻。😊。

找一下sboexception report吧。好吧，除了这些东西外，后面还有吗？😊，明白了吧，是不是意味着我就读到了当前这样的一个类，并且把它进行实例化。

哪个类叫fairair and ladder就这样对象啊，这样的一个对象。所以你读完之后，我们可以看一下这个集合里面的一个值啊，不往里面看了啊，打开我们的exception reporter。😊。

是不是这个来到这个对象是不就有它你拿这就够了，之后其中异常报错的时候，这里面都会给他放进去，都会放进去啊，哪用到它了呀？暂时这块还还没用到还没用到这东西吧，往后面看吧。

这是抛异常这个账号才会有不抛异常的话，这用没用啊，来再往下看干嘛，我说了刚刚只是创建到我们的创这样一个对象，但对象里面很多属性值还没复呢，所以剩下时间最主要的就是往里面进行一些最基本的复值操作啊。

复值操作，这可能看起来稍微有一点点麻烦，有点麻烦啊，但是呃怎么说呢？看多了，就知道咋回事。这东西啊也不是特别难。但是在讲这个操作之前我希望大家先看一些东西什么东西呢？就是这些类，他们之间的关系。

我们都知道源码里面包含了N多个类。你如果就之前详细了解过s源码的话，其实你看会比较容易一点。如果你之前源码一点都没看过的话，你看。😊，课程确实比较麻烦。

它里面其实很多地方都用到了我们spring一些东西。啊，这是肯定的，懂我意思吧？好吧，所以这儿大家一定要一定要一定要注意了。大家注意了，然后呢往上看。😊，叫prepare content对吧？好吧。

点进去这类里面还记得刚刚16好16款好那个那个那个那个类是哪个哪哪个类吗？😊，记得吗？记不住我大家点一下看看。大家记住了啊，annotation confi，我先把这打开吧。😊，あの。Tation。哎。

没有吗？LTTY。你怎能没有吧。有啊，是不是这个类好吧，你一定记住我们当时上下的环境就是这样一类，它里面是不有构造方法啊，构造方法吧，构造方法这块我们先留先停到这儿，先停到这块。

先停到这一块这块看完之后，这块看完之后，这里面两个对象很重要，一个是rander，一个是scanner之后我们都会要两个对象。😊。

啊，都要找对象就是说你现在要往里边放东西了，放对象的时候，首先要创建好这样一个对象，对不对？这个东西大家应该是没没有疑问的。但没疑问之后，我希望大家你可以打开当前这个类。

看一下这个类的一个关系这个很重要我为什么上课因为你发现你后找某些属性值找不到其实在里面它帮你完成了整体的一个负值或说初始化的一个工作初始化工作最看起来可能会稍微有那么一丢的一个难受难受要接着看要接着看看这里较要把每一个类都看完之后。

你就疯了。但有一些类你们应该是知道的比如东叫知吧对这是最开始是最中间一但你看个蓝我看是什么最底下面有什还。😊。

这样默认的一层继承关系了，是不叫样继承关系？在继承关系里面，我希望大家注意一件事儿，什么事呢？呃，spring的时候，你们不是看过这个东西？😊，哎，在sp你看过这个东西吗？看过来扣一，没看过来扣2。

看过是吧，看过就好了啊。😡，没感判。一定要去看好，没敢看，一定要去看。那这块我就简单来说一下，简单来说一下做什么事情，做什么事情。你看到蓝色这条线了，蓝色这条线表示它整体的一个继承路线的关系。

这些对象你不要觉得它无所谓，你看起来好像我只创建这样一个对象就完事了，不对，你也看一下他父子之间的一个继承关系。因为在这些继承关系里面，它依然有很多非常重要的属性会帮你进行加载。

比如第一个叫default resource load，这里面干嘛了。😊，干嘛呢？是不是为了获取我们默认的一个类加载的一个器，对吧？获取一下上下文类加载器，这是第一个方法，要做成一个事情。

第二个叫什么呢？叫abtract不是 contest年称翻译过来叫什么？叫抽象的一个应用上下文，这是我们翻译过来一个东西，好吧？但其实但其实你注意的，这里面用到很多东西，或者说有很多东西。

比如说比叫resource pattern，有人知道吗？😊，听了东西没。😡，我给大敲一下啊。呃，resource。呃，patter这样的resserver。这东西有人知道吗？

是不是资源模式的一个解析器是不是资源模式解析器啊，没听过算了，没听过，就现在有个印象。好吧，就这里面注意一下它会完成很多事情，还有很多事情。就说为什么你在配置加载一些配置文件的时候，是通过什么呢？

叫class pass唉。😊，通过classpass这个路径写完之后，冒号，后面可以直接给我们的文件名称，它也能读取到原因在这个地方，它会完成很多这方面一些工作。把这个称压里面完成的。好吧。

包下面有个什么叫通用的一个上下文对象。😊，这里面也很重要也很重要。而且在这个通用的上下文对象里面啊，这个类里面除了之外，它还包含了很多东西，什么东西？我们可以来看一下这个呃咋说呢？看看看下这个类吧。😊。

呃，这类怎么造？想让你们看一下啊，想让你们看一下，我们找一下这个继承关系啊，sate。

Computerrate。点开之后，这里面有一个非常非常重要的一个对象，好吧，叫befactor叫default这这个东西defaultablefactor之后我们在很多地方都会看到这样的一个属性值样属性值大家看到了？

对象是不是在我们副类的构造方里面定义好的不是是在里面构到好的，所以你点开这对象，你看下当前对象这个类图也一样的看例用户里面也依然表明了一个继承的一个关系。这继承关系这其实在里面面应该会接触到的。

有一个de是最层的上面有什么叫obstruct comparablefactorstruct beingfactorfactor sport然后呢default singlespleory是不是看到很多这样一个类关系它里面依然有一个继承关系你在的时候依然会一层一层一层一层往里面进行创建其实通过这些类的名称。

我们大概能做一个最基本的一个猜测是。😊。

个叫simple alliance什么东西？这啥？😡，叫简单别名吧，你想想你注册并的时候有没有写写别名可以吧，是不是注册别别名注册器，对吧？再往下看这是什么东西。

叫default single bin什么叫单立并的一个注册器吧，是不是这意思？再往下看还有什么呢？叫factorory是不是工厂并注册的一个什么是不是注册一个方法，提供这样一个支持，对不对？

再往下看abtract binfactorory抽象工厂类，这不用说了吧，对吧？还有什么呢？呃obtractcompfactor是不抽象的有自动装配功能的一个并工厂，是不是自动装配的一个功能了。

是不是这块东西，再往一下最后一个才是我们这个默认的一个最基本的实现。😊，对吧所以刚刚啊就是为什么很多同学在看源码的时候看不懂。其实更多的还是因为这个点就是你在你有一个对象的候。

你看到源码里面你有很多对象，但是很少有人去说我一层一层往上看一下它里面到底卖生什么事儿。😊，啊吧你把这些事情的脉络如果都捋的非常非常清楚了，你再看这块的时候，其实就觉得哦原来这么回事啊。

原来并没有那么难。如果你前期的一个基础建设没有的话，你后面看的时候肯定会越来越难越来越麻烦啊，这点我希望大家能认能认认同啊，这块要注意一定要注意了。😊，这个虚线实线蓝色线是什么意思？

这这个类图里面表示具具体的一个继承关系了。大家看一下这个来自于什么？是我们具体的一个class之间继承关系。😊，好吧，这应该有一个徒弟来着，我我找一下啊。这没有是吧？这儿有一个具体图例啊。

就这块它其实表示就是一个继承和实现的一个呃，就就就你看到啊，这时候有C有II表示是我们的接口啊，I表示我们的接口。然后呢，C表示我们的类类跟A类之间的继承关系有蓝色来表示的啊，接口之间的实践。

大家看是不是用绿色线表示的就这样的关系啊，这这这没啥，这没啥这有啥好看的吗？😊，同学都说了，什是实线实线是类，虚线，虚线是接口，接口都是虚线，就这东西啊，没看过这东西是吗？😊，如果没看的话。

下一周一定要先细看一下啊，这块一定要看。呃，所以啊大家发现了。😊，呃，包括你之后，如果你要看一些，比如说像sring cloud这样源码的时候，经常看的时候，其实大们都是依托一sp的。

前能把spring原码好好听一下，好好看一下，真的很重要。啊，不要觉得这个东西难或听不懂，我就不听了。呃，硬着头皮咬着牙，一定要去看。因为你看完这东西之后，你再回来听的时候会感觉容易一点。

或者说最起码有那点感觉，有点印象，有点印象。如果都没有的话，你就看起来很麻烦。😊，绿色的实现是啥？一个是表示继承，一个是表示是我们的一个实现接口能不能继成接口，接口是不是能实现接口。

能不能继承接口也可以吧，就这两个区分。它表示是继承的关系，它表示是实现的关系，就接口之间的一个继承。你接口之间是不是可以用exense，是不是也可以用in那个imperments。这好了好了。

这没没没关系啊，不知道说这个这个没必要。😊，看右没啊。这个呃看一遍之后，你知道你记住就行了，这没啥哈，这个没啥可学的，懂我意思吧？现在四坑黄什么的spction呃，最好去看一下，最好去看一下，一定要看。

呃，看完之后你你的感受是不一样的。包括你对整理解整体的一个架构都是不一样的，懂我意思吧？😊，好了，这个不看了不看了，再不看了再不看了再不看了。😊。

，这问题咱们聊这么多，加回反啊烦。😊，该看哪了？啊，看这个这个类类类肋托是吧？

刚刚是不是讲了我们的rate application contest对吧？看完这块之后，看完这块之后，下面是什么呢？叫generate web application。

然后呢la那个 application contest吧？是不是到这块了这块也一样的，这是通用什么叫通用的应用程序上下文叫通用的web应用程序上下文也是一样。

这里面只提供一个方面的一个支持方面一个支持仅此而已下面还有什么呢叫serv web server application吧？

这里面是啥叫serv web应用程序的一个上下文 web应用程序上下文仅此而已。下面这下面是什么是我体是annotation里面的一个东西notation里面东西是我自己是上的下文对象。

你知道这样成关系把每个里面要包含的一些实现看一下因为之后啊你会看到很多bereoryory这样东西你如果这块东西不了解的话。

你听起来很懵这东西我也没法给你做一个就非常简短的一个解释说我一句话把说明白说明白。😊，听白了吧？下来之后好好看一下，最好好好看一下好吧，呃，看完之后你会有一个整体的感知的很重要行吧？好了，呃。

别的东西废话，我这就不多说了，不多说了。来回来再看看什么东西，还是看到我们刚刚的这个类啊，这类还是要看的来看这类这个类刚刚我们是在完成一个那个实例化当实例化的时候，我是直接跳过去了。

但其实你会发现在整个实力化的一个环节，它又创建了两个对象，一个叫this点read，一个叫this scanner这块东西看不懂，没关系，你往那看他说创建了一个新的这东西，然后需要干嘛呢？

叫popular through cause and then呃什么reflash，这干嘛它需要被进行调调体，并且呢需要被进行refsh，是不是进行一个刷新操作。那这个thisread是干嘛的？好吧。

上面这有明有解释啊，找一下。😊。

没解释啊。read，你翻译过来什么？是不是读取scaner是不是进行一个扫描，对吧？它干嘛呢？用于干嘛呢？用于完成我们对一些病的一些注册功能，并的一些注册功能。比如说我们之前在那个写代码的时候。

你们经常用一些，比如说像卡蒙德干。😊，啊，包括像serv service对吧？啊，不是像component，然后呢像service，对吧？还有那个呃respoory仓库那个东西，你在进行并实例的时候。

其实都是通过我们当前那个readread对象来完成的啊，都通过对象来完成的。包括后面这个scannerner它是干嘛的scanner其实它也比较简单好吧，它就是定义的一个扫描器，用来扫描我们这个地方。

它符合我们对应规则的一些并对象。因为你只有扫描通过之后，才能把我们的并注册到我们对应的一个上下环环境里面。此时在后面用的时候，你才能够完成对应的一个调取的功能。如果没有调操作的话，你是调不了的。

懂我意思吧？好吧，所以这样大家要注意了O。😊，好了，来，我们再接着往下看。呃，在这个对象里面创建的时候也非常简单，就是一个咱点进去this的一个操作吧。在这个操作里面。

我还是希望大家注意一个注意一个东西，稍微注意一下啊，你稍微留个印象也行啊，哪怕留个印象，有这样一个东西。😊，这东西不知道家有没有留意过这干嘛的？😡，有人留意过这这个东西吗？😡。

叫condition elevator是干嘛的？来，谁给我解查，这这这这东西干啥的？😡，什么叫cond？😡，啊。对，条件。我们后面在进行自动装配的时候，自动装配的时候，你会看到有很多的一个限制条件。

比如说我来举一个例子。我们来看一个类啊，看类就知道了。点。在A宝。S。这没有是吧？这没有条件吗？应该有条件来着。She。

呃，找一个吧，叫。往外吧。MVC。C二分口就行。这有没有艾特肯定是看那。有什么叫conditional，然后呢呃1on web applicationconditional on class。

然后呢conditional on missing bin然后conditional order呃，不对啊。

上面这4个是不是conditional on web application on class on missing bin是不是什么东西看错了啊，不是1啊onon web application好吧。

然后呢on class on missing bin是不是都是我们这些条件的一个判断好吧，这东西啊，你不明白，没关系，不没关系，到后面的时候我会在呃那个自动装配的时候，我会讲这个东西。

其实就是一个条件的一个判断。啊，看错了，也有点晕刚翻过来有点晕啊。😊，所以你注意啊，里面会注册这样一个条件的一个判断一个器啊，这我给大家写了啊，我给大家找一下自动装配的一个运行原理啊。上写了很多笔记啊。

为了方便你们所理解，还没在这儿。它这块它大概有这么多扩展的一个属性，就是说我必须要满足什么样一个条件，才能进行一个生效。就这块东西啊，这块的东西听白了吧？这些东西啊咱们后面聊到时候再再讲，先不管它。

你现在有这样一个印象，就是这里面会加一些条件判断的一个计算器啊，有了这个东西之后呃，我们能做很多一些条件上的判断了。这时候是比较舒服的你懂我意思了吧？啊，这块你稍微注意下就行了，稍微注意一下就行了。

好了，这是我们你有这样一个run一个对象，要有run对象。😊。

然后回来回来回来，除了这个run之外，还有一个什么，还有一个scanner吧，你点一个scanner，点进去点进去。😊，呃，再点。这个就是非常简单吧，做什么事叫呃呃先注册加油这样个注册器。

收集完了之后叫reger before filter，是获取我们默认的一些过滤器了啊，获取我们的环境，获取我们对应一个资源加载器。我说了它毕竟是完成是一个什么，完成了一个扫描包的一个功能。他说了吧。

是不是componentory service controllert，是不是会检测这方面的一些注解。有了这些注解之后，我会把你扫描起来。如果没有这些注解的话，我就不给你扫描了。😊，啊，所以整体上来说。

这个上下文环境是非常非常重要的一个对象。包括这里面你所看到的两个对象也是很重要的啊吧，这块先留一个印象，因为后面的时候我们大概会用到它，你先留印象，有到印象的时候，我们后面讲的时，我们再详细说这些东西。

行吧，好吧，这东西啊我们这就不再浪费时间了，别浪费时间了啊。呃，重点来我们再讲吧再再再再往下看。😊，再往看看什么东西啊，刚刚只是我们当前这个上下文环境的一个准备。除了这个上下文环境之外。

还有什么东西来着？是不是还要往里边添加一些对应的一个参数了，来慢回反啊到哪儿了？OK在这儿。还能跟上吧。还知道还知道我我在我我在说啥吧。😡，经常那个map爆红跟这个有关吗？呃，没关系。

那爆红是因为你没有买引入mer的一个依赖，你们没有引入克的一个注解，引了那注解之后就给我爆红了。刚才上面是写了只有4个注解，或者扫描这4个注解里面，它是否会作为一个并对象。

把它给呃自动呃那个什么角头腕进来，凹头外进来啊。😊，好了，刚刚只是我们这样一个contests的一个对象的一个解释。里面其实大家发现了包含了很多很多东西，在之后把里面包含的东西好好看看，好好看看很重要。

好了，这一步骤完成之后该到这儿了，叫prepare contest是吧？这一步骤啊？这步骤很关键啊很关键啊，这才是我们整体完成的一个核心。来往这边扫。

我们看一下完成到底它里面到底做了一件什么样的一个事情啊，什么样的事情。呃，其实是怎么说呢？难道并不难难道并不难？关键是你要知道。😊，他干嘛了？好吧，来走一下吧。

第一个叫contest两 set environmentment干嘛的？😊，是往我们的contest里面设置我们对应一个当当前对象一个环境，给您看一下走叫super点 set environment。

是是把环境对象给设进来，这是第一个第二个叫this点read点 set environment。第二个叫this点scanner set environment。

是不除了给我们当前这个对象做一个最基本的设置之外，还要往哪往我们read属性里面设一个，往我们的scanner属性里面再设一个，是不是要设很多东西。😊，对吧把sin一定要把它给设进来，把，这块很重要。

因为后面啊会用到我们这个环境里面的一些属性值，一些东据具体操作，就这样往下走就行了。不往里边看了，唯E啊，就是一个设设置的一个属性，看一下吧，是不是就往里边把in时加进来就行了，用了几个新增对象。

就础块一个操作啊，不管它了。😊，好了，这做完之后第三个叫什么呢？叫post呃 process application contest，又看这个问题了吧，这东西难吗？并不难。好吧。

一来看一下往里边到底做什么样的一个事情。走，这儿是先做一个叫Bing name generator的一个判断，这什么东西？😊，叫并的名称的一个生成器，对不对？这值刚开始是什么？因为你没做过任何操作。

所以刚开始的话一定是等于空的吧，那空没关系第一进来。第二个呢叫res等于空吗？等于空往下走。到第三步叫this conversion service这个不熟熟吧，是不是之前已经见过它了，是不是见过它了。

还是一样来用来添加我们很多这方面的一些转化化呢，包括一些格式化的，它所对应的一些服务。这不往里面看了啊，之前我们带你们带带带你们看过了，拿走走走。😊，做完之后，这步就完成了。

关键是你要看一下这个这个方法，好吧，叫apply initializer，这干嘛的？叫应用我们的初始化的一些呃初始化器，对不对？你想一下，刚开始我们在创建对象的时候，我有没有往里边读取我们一些初始化器。

有吧？还记得多少个吗？😊，记不记得？😡，啊，还记得吗？这个springfactor里面对，7个好吧，记得很清楚啊。对，就是7个。现在开始要对这7个东西进行相关的一个处理工作了，进行处理工作了。

这个处理工作记录了非常非常关键，而且非常非常重要。😊，啊，你们可多同学一直在聊老师后面那个自动装没怎么聊，面试官人学怎么答，其实就用到了这里面的某些点，某些点来看一下吧，往些点啊，点进去，点之后。

这是不是一共有7个拿家走，我们看一下这个这个这集合啊，能看到集合吗？😊，啊，看不到看不到算了，没关系啊，这get in出来点哦，我点点一下这方法试试试试啊。走，这有个东西点进去。😊，这样这这这没有是吧？

看不到this there来，看这是不是有7个7个吧，就我们从那个类文件里面直接载过来的这些呃数始化器已经输入进来了，这这一共有7个，第一个叫什么？😊。

de application content之前做什么事，不知道啊，不知道没关系，你可以接着往下看，注建一个class对象。

然后呢也是一个application content一 class照片往下然下走到这步这步是最核心的啊最核心的干嘛呢？是完成我们这样的一个初始功能，走完了点一下试试啊。

看一下第一个叫get environment是涉及我们当前的一个环金变量，往边走走不等于空。看这。😊，拿走是不是进不来进不来之后，这里面是不是相当于什么事没做，只是获取了一下我们当前一个对象。

所以这个方法什么都没做。往拿走。第二个叫shaed met dataread。然后呢，这有一个东西叫factory contest这个方法很重要很重要。这里面其他东西叫什么叫就我们的原数据。

这里面它会往里边放一个metcaching met的一个postpro的一个类往里面看一下吧，还一样里面点进去第二到这了吧，叫at bfactor post processor，你用了一个什么对象。

叫caching met datareadfactor post processor。😊，啊，这个类很重要，好吧，你记住了，它是不是往里放这样一个类类类类类的一一个对象，点一下可通构造方法，什么没有。

还一样，在副类里面，我们这不往里边看看，然后点完之后往下走走。😊，哎，这啥东西？走收加里面去了，叫at binfactor post processoror，慢慢走。

叫this beingfactor post processoror的ad是把刚才方案给加进来，加完之后也一样就是一个对象，添加集合。加完之后你可以看一下，找一下我们对应东西啊，op contest。

😊，你这个东西啊很重要，呃，找一下叫beanfactor。这儿里面有叫post processor。找一下啊。看到了吗？Pot post。想看我眼程啊。你看到了吗？我怎么没看到呢？不是这东西。

Bme processor。看到了？Post processor。哦，这个地方是这样吗？并poprocessor。这好这边没有呢。没看错吧，给你翻腿。bef变 power processor这个没有呢？

应该应该有一个对象啊。这方法是吧？拿走吧，不管他了。contest。好，在这这有了吧，看这是不是已经进来了，看错地方了，看错地方了，看错地方了。大家看这边加什么？

是不是叫catching met datareadfactor processor之后要用它，所以我这强调一下，好这加这样对象，别的东西没做拿走。

第三个叫contest ID application什么东西，依然往边走点击之这不是有个get contesttest ID啊，这contest ID是什么东西，还记得吗？😊。

这是我们刚才那个s边走获到一个ID值ID值就是谁叫compas ID然后是我们刚才进行那个初始化的一个初始化器往初器往下走，也是往里面进行设置，设置完了之后注册一个单立的一个对象。

注册单对象注册完之后就搞定了啊，这个西不用管它来看第三个叫configuration warning什么东西，这个类也很重要，往下走走到这点进去，是不是又加一个对象。

叫configuration warning是不是相当于另外一个东西的，也是往里面加另外一个对象，加之后返回来看第三个叫什么东西下走。😊，加一个什么？是加一个新的lister啊。

这是我们这儿往里边需要添加的东西。大家注意了，它是往我们那个呃posts processorer里面加吗？不是啊，它是往哪儿往我们的application listener里面加啊，加对象是不一样的啊。

加地址不一样的拿走走第四个叫servverport inform什么东西好吧，咱们走。😊，再往走这东西判断不等于空 listener是把 listener给加进来好吧 listener把 listen listener加进来加完之后就搞定了叫port然后呢 contest来加之后再往还有ditional是不也是条件的一个最基判断依次也一样。

它每次都调一个初始方法完之后我们对应的一些初始化功能，是不是也是往这个里面注册一个 listener东西之后啊，像这些lister我们都是要用的啊，都是要用的啊好再往没了吧。

是不是这7个初始化器在这个地方几乎都得完成了完成好之后往这看看一些进行属性值这里面有两个类有两个具体类这两类后面会要用到除之外还有什么呢还有个叫listers找一下。😊。

那application listen是吧有什么东西s inform condition到什么东西，是不是有包含这三个具体的一个实计操作了？把这对象给我记住，后面我们要用的时候，你要知道啊。

原来在这进行了一个最基本的赋值操作，在这完成了啊，完之后我来往回返大家看一下刚刚那个初始化就完成了吧。所以那些初始化器，在这些步骤里面，要不然我注册成一个类似的了，要不然我注册成一个什么呢？

叫post processor。😊。

不管也好，还是pospocent也好，那就说白了，最终都是为了给我们后面的一些操作做准备工作的。现在你还不知道什么用。没关系，我这给你强调到了，强好之后，你先把它留下来，等我们后面看的时候。

你要知道是干嘛用的就行了。好吧。好了，这样看完之后，听懂的同学来扣个一。😊，听懵了吧。还有千醒同学吗？0。75。好了。好了，这玩没问题之后，我们再往下看看这行列法。你看到这行之后。

是不是又会变得非常非常熟悉啊？😊，是不是似曾相识，叫laziness点contest preparedpar就看这句话了吧。那一样的要完成我们相应的一些具体功能了吧，往边走连续。😊，连击之后啊。

这时候又该始循环list似er了，lister注意了，永远只有一个，但这里面是不是又包含了11个对应的一个监持器对象，往下走走点进去，连进之后。

是不是叫你有一个叫application contest你数ize environment。来，到目前为止，告诉我，你现在见到几个evenent了。😊，几个一分钟。三个吧。

第一个叫什么oblig starting event。第二呢。😡，叫environmentprepared什么 event吧，是不是三个。

这是不是第三个叫obplication contest你称la event。你大家想一下，不管是多少个event，最终它所对应的一个处理的一个环节，或者说处理的一个流程一样不一样一样的，是不是一模一样。

它几乎注意的没有完几乎没有一些任何多余的一个操作，任何多余的一个操作。所以这儿大家应定要注意的啊，一定要注意的。😊，好了，这个没问题之后，我们下面来接着往下看，看这块来干嘛的呢？慢慢走吧，点一下试试吧。

走创建这样对象，不管它。😊，走到里面去点点进去呃。点进去到家之后又该进行处理了吧，还是一样，判断一下它是否格式是一样的。不是判断判断一下它是否呃哪些静电器符合我们的规则，你点进看一下吧，点进去。😊。

知道这块来走走走走走走，大家看一下这个代码处理逻辑啊都是一模一样，没有什么变化。同一套代码把同条代码YY个进行便利，哪个符合条件，哪个不符合条件这这边结结束了吧。

所以这第一个叫什么叫background，然后呢往边走，点进去，往走走走执行执行判断判断是不什么什么都没做，一样什么都没做完，下面来看第二个走叫deigation什么di什么东西，来往走点进去。😊。

看没判断？第二个也是依然什么都没做啊，你还一样进行X次的一个循环就可以了啊，验完之后往下走，大家发现了一共有两个间器留下，那这样监器几乎好像什么都没做，是什么没做，什么没做，什么都没做，不管它好。

不管它，然后接着往下进行便利走。😊，我说。结束了吧好，结完之后，这个准备工作就算是完成了。所以大家看到了，当我完成这个最基本的准备工作之后，相当于什么？是不跟什么都没做一样啊。

其实它对应的就是一个最基本的空时线啊，然里面留下两个器，但两个依然什么都没做，别管它了懂我意思吧？这块的一个基本操作完之后来再往下看该到这块叫什么呢？叫this点 log four它是什么？

它是一个最基本的属性值叫什么处吧，是不是一处值出完之后这一定是能进来的，一能进来当你这进来之后叫log什么东西什么东西你看到这两个方法也没有点熟悉的感觉你之前再启动我们当前这个ring程序的时候。

到这步没完吧，是不是里面还要打印多余的几行的一个日志而那些日志信息的一个打印，就是在这完成的。😊，啊，对，启动日志就这东西。所以我们可以怎么样呢？往里边看一下，第一个叫log start info。

看里面做什么事儿啊。😊，走，这片让他不管它。点进去好吧，他说判断一下是否是root是吧，然后点进去，这是不是你有一个叫start up in for log专业对象。

来log start点一个对象创建对象，不用管它了，这是这个对象创建啊，再往下走叫。😊，趴这走走这get他ap log吧。走。走再点看这叫application点呃log点in message什么呢？

叫this点get starting message吧，怎么get their message呢？往这看strring builder message等于什么东西。

然后呢mesent starting说吧application message name等于啥？然后呢，append version等于什么东西，appent on什么东西，opent pID什么东西。

appent content什么东西，return一个messageme谁是不是我们str builder。所以当你把这个代码执行完成之后，看这输出了吗？😊。

是不是叫starting什么spring boot呃，spring boot date application on rootot with PID等于谁？这个目录在哪？然后start by root。

然后in哪个目录，是不是刚刚我们看到这些相关信息啊，这是不是就直接进行输出了？😊，啊，这是我们启动日志。完了之后第二步什么呢？叫application点log点 debug啊。

log message of什么get running message点进去是不是叫running with start呃 springring boat，那加上一个s呃 class一个类名称。

加上一个喷的一个spring，然后后面加一个mesage也一样，直接把它返回吧。我们这直接运行了。😊，走。看看刚刚没输出吧，为什么没输出啊，没出原因是这这是什么级别第bu呃，是不是第bu个级别。

不是我们log个级别啊，不是我们一会级，所以这没这这没进行输出吧。呃，这应该输出吧。😡，哎，这怎么没输出啊？等一下啊，我看一下啊。Message。Lo个 message off。没一什 message。

这没输出啊，默认infer是吧？不管它了，没输没输出，变向大局啊。这第一个是不是告诉你说我启动一些信息，告诉你什么时候启动的对吧？这这块信息打印。再来看第二个什么呢？

叫logstar up profile in，是不是告诉你说我使用是哪个profi的一个文件，连续之走，这是我们的log对象，别管它往下走。😊。

str I profile等cont点get environment叫get I profile这个地方我们有指定吗？没有吧，没有的话，这有一个是不是一个空的一个值，拿走ex empty嘛，做什么事。

然后log in。😊，大家走走走看这什么东西叫no active profile set呃， for a back to default profile default是不是使用就是我们默认的一个日志。

这是不会打印。是是这情情况了，往要走。走，刚才两行这不执行完了，就是一个启动日志信息的一个打印工作。所以这块大家应该能看懂，不难吧。所以你看到了你把它每一步骤每一步骤都分解开的话。

它并不难每一步骤完成的一些事情，就是我们眼见所能看到东西。听白了吧？好来，到目前为止能看懂同学给他扣个一。还能看懂吗？😊，好了，这块如果没问题之后，下面东西就比较复杂了。我们5分钟讲完了。好吧。

大家说一下，你其实大家可以看一下，叫ed spy single beanss干完了，你看它这行的一个注释，你来告诉我他完成了一件什么样的一个事情。😊，做啥事情。

叫ad boat specific singleton beans。是添加里面指定的那些单例的病啊，是不是这意思？这个非常简单？首先获取我们的factorory，然后呢注册一下我们当前这个s个友吧。

谁是我们的spring application argument是是我们当前在初始化的时设置的那个参数个对象，把那个参数对象给你加进来就注册了这样一个并对象懂意思了吧？

记住样样样东注册完之后打印我们的对不对？然后呢告诉你说B对象属于哪个并对象，然后呢允许怎样进行一个设置，是否是加载的吧？再往下进行一些相关设置，后什么东西，然后东西这个东西，我们上再讲好吧，现在不讲了。

讲完了啊，记住到哪了我们上再接着往下打个你想下刚刚我们所看到完成的一个具体的一个过程，我们这讲讲讲点啥？😊，啊，想一下。接下给加点什么东西啊？来找一下。找一下我们的入网方法。找方法。

在当前这个弱方案里面run方案里面，首先我们讲一下这个环境的一个基本配置，对吧？是不是讲一下这个环境配置对吧？这个环境做哪些事情啊，做哪些准备工作，然后呢忽略哪些病，然后呢我们banner怎么打印的。

创建了我们的contest这样一个对象，对象里面我们又往里面做了什么事，是不是就这步完成的。其实这些东西啊呃说难吧，也不是特别难，也不是特别难。但关键在哪，其实刚刚看方法里面你留个意。

今天晚上我们重点会看里面的一个病的东西啊，不是这这个漏的一个东西，就记住了个banner。😊，但是但是比较简单是吧？😊，但是比较简单啊。哎呀，你把那个整体的流程给记住了，这个漏的方法。

我希望大家下去之后能自己先看一下漏的方法非常非常重要。漏的方法非常重要。好吧，非常非常重要。因为我们之后用到一些核心操作，其实都是在这个漏的方案里面完成的，的方案里完成的这东西啊，我们晚上再聊。

其实啊呃源代码看到现在我不知道有没有种感觉，很多类我们可能不知道是干嘛的，对吧？但是大致的流程我是能梳理出来的，我是梳理出来的。同时你会发现了里面重复的代码多不多。😊。

都懂很多吧。比如说从spring呃ring呃那个spring factor文件里面读取文件，对吧？再比如说像刚刚那个监震器那一块东西一模一样吧，只不过说我的事件换了一下而已。其他东西都一模一样。

所以我只要在这里面定义不同方法，调用不同事件就搞定了，就这意思。所以啊它并不难，你们也不要把原版想着说老师这个东西是不是特别复杂或怎么怎么样没必要啊，这还是一样，他们都只招火，慢慢往下看。

哪个地方看不懂，先跳过去，只要不影响你整体的一个布局就完事了啊，这块希望大家能够注意到啊。呃今天晚上吧，我今天晚上尽量把这个。😊，早十年我们也写出来了，别吹牛逼好吧，别吹牛别别吹牛逼啊，这个。😊。

早十年你写写不出来啊。😊，你要你要想你要想实现出来，这个太太麻烦了。所以我说我不讲了，好吧，呃，你们现在吧一会儿之后把今天刚刚讲的东西啊好好消化一下，梳理一下。然后晚上的时候我们再接着讲，呃。

我尽量在今天晚上的时间，我们把这个呃这个启动这个过程说完，启动过程说完，呃，人家说完的话其实很麻烦。因为我后面要讲的东西啊，还是比较多的，我还要讲一下自动装配，然后讲一下starer。😊，呃。

听这东西对你有帮助吗？感觉有帮助的同学扣个一。😡，慢慢讲呃，不是慢慢讲的事儿。呃，怎么说呢？还一样，我在讲课的时候，经在带你们一步一步去看，呃，按照顺序去看，原因非常简单，想教给你们这样一个学习方法。

懂我意思吧？呃，这种西啊迟早慢慢看，还等你怎不看呢。😊，我真想讲他们看的，我看到你们这这个这个这个这个这个东西我觉得讲他们看你们不一定能看的，他们看估计能能能容易点能容易点儿。😊，讲到我们就飞了。

加课呃，加课你不加了啊。呃，还是一样，我把我计划东西讲完，这个没讲的东西到后期的话，呃，我们再更新，我们再更新讲讲太多，我们一讲两节课。今天晚上就三节课，如果再讲三节课，估计你们就懵了，你们就疯了。

咱家慢慢讲，好吧，希望你们把整个流程给捋清楚了，好吧。😊，呃，他们看大家可能要等到等到年后了，年前就就没有了。野马完了是什么？野马完了是网易车网易车项目。😊，我计划计划不算今天的课，还有2到3节。

就我说东西啊，第一把启动功程讲完，第二，把自动装配讲完是吧？第三，再讲一下这个starer。就是你你想一下那个ser东西，就是我们配置的时候，你们都都都star吧，这个sta怎么用的。

如何自定义的starer这些个原理应该怎么写？这原因底底层原码是怎么走的，讲了三个点，这三个点讲完之后就就别的东西不聊了。当然除了这三点这边还有什么？比如说像呃环境的一些东西，好吧，自定义的一些东西。

其实很很麻烦。😊，好吧，呃慢慢讲吧，好吧，慢慢还一样能面最主要是什么？能在面试中帮到你们。过年讲不讲课，过年讲不讲课，听老马看老马的安排，不知道老马让不让讲。😊，行吧，好了，废话不多说了啊，呃。

利用这里3个小时时间尽快消化一下。然后呢，我们晚上8点准时再见。好，朋学们OK拜拜。😊。

系列 5：P67：67、springboot启动源码解析三 - 马士兵学堂 - BV1E34y1w773

这世界意外遇见过人的情绪，不是挣脱自己的过，失败的勇敢，把曾经都短暂停留，后来飘走的云，黑夜呀，我丢了国际风和日丽，春暖花季，但却万里无一，就当我把我的一些感情的甜蜜，白昼的夜里，我不解风情。

并继续你的给予，而飘又开始让我变得狰狞，也开始变得曾经并肩，风起风停，风行羊，喜羊羊决定了爱得死不休，你能不能慢走，那家覆水难收，假钱的人都哦没得多日的降临，没法的应收到，你带着我的表情是飘荡去了巴黎。

说英文风烟满地，乱世了回来，三级锤裂了大量记录增加而失败的正义，当事人闹声却有多神奇，你的余晖下在哪里，那段天刚被暴雨，还是控制不住自己，想到你，嘿嘿，我想找到你，那曾经有短暂停留，后来飘走的黑夜。

我丢那么远，风和日丽，春暖花季，但却万里无云，嘿，我想要到达，那曾经有短暂停留，后来飘走的，嘿耶耶耶，我丢了，我自风和日丽，春暖花季圆缺万里路，那曾经有短暂停留，后来飘走。

我爱你，无畏人海的拥挤，用尽余生的勇气，只为能靠近你，哪怕一厘米爱上你，是我落下的险棋，不惧岁月的更替，往后的朝夕，不论风雨是你就足矣，看了太多情人分分合合，爱其实很脆弱，像温室里的花朵，你这么说。

我其实很忐忑，若我没有许我承诺，你还爱我吗，听夜空的流星陨落的声音，这人我让你听，我爱你，无畏人海的拥挤，用尽余生的勇气，只为能靠近你，哪怕一厘米，爱上你，是我落下的险棋，不惧岁月的更替，往后的朝夕。

不论风雨是你就足矣，你这么说，我其实很忐忑，若我没有许雨过承诺，你还爱我吗，夜空的流星陨落的声音，这愿望让你听，我爱你，无畏人海的拥挤，用尽余生的勇气，只为能靠近你，哪怕一厘米，爱上你，是我落下的险棋。

不惧岁月的更替，往后的朝夕，不论风雨，是你就足矣，我爱你，无畏人海的拥挤，用尽余生的勇气，只为能靠近你，哪怕一厘米，爱上你，是我落下的险棋，不惧岁月的更替，不论风雨是你就足矣，The one god。

It's on degrees like you，Feeling i was the problem，We just said to be free it。

Don't feel like the starting，Run into the radio with the all，Calling the moonlight，Clono。

We don't give a fun，We got a change to think on on uh，How could we do it，Because we want two。

Day's best spine now，We playing by your own chase on the sea，Kissing doesn't wake you。

Dancing in the parking，Lot damage，The most school，We the kings of the city，All the lights are pretty。

Bad boys like daddy，We in the club by fetty e keep my feet on the desk jk gala，Regihaving a blast。

The future，So bright way and looking at the past，And we just fall in the moment。

Because it's on the degrees，Why you feeling now，What's the problem we just said to be free，It。

Don't feel like this stub，Run to already with that，So calling some moonlight close。

Don't we don't give a fu，We got a change a thing on the more，Hey yall，She looks so good。

When the sun's up，But i love fathers should we do when the sundown paying around are you。

Here is best sounds turning out music，When we get a little too，Loud turn around a smile。

And she got the polly way，So she bto sume dry，I need me some peter like，We're gonna take it，So here。

They won，The phone said，She want some more keep it on the low low e keep my feet up on the dance。

Degli，We just having a blast and future，So bright，We looking at the past，And we just stall in the。

好了同学们，咱们开始讲课了，今天是第三节源码课，这节课是第三节，第三节呃，之前如果没听的话，听起来的话可能会稍微有点难受，因为这源码这东西都是连起来讲的，稍微有点难受啊，你可以尝试着去听一下这东西啊。

呃刚刚跟那边那个陈老师沟通了一下，然后源码课呢咱们就看你们的反馈啊，都不是特别好，大家可能需要很多消化时间，所以这边计划是下周二，下周四咱们再上两节，保证了五节课的源码，基本上面试的时候应该够用了。

后面像确认一些源码课，后面会给大家补起来好大家放心好吧，你们还是一样，把我这几天讲这些源码课能够呃掌握了啊，就已经面试，反正就我觉得应该没问题了，最起码跟面试官聊肯定有的聊了行吧，之前听过也难受难受。

什么阿联原版对工作有用吗，呃给大家说一下呃，源码这东西啊，说实话对工作有用吗，稍微有一点就是如果你在用一些框架的时候，当然是小公司，大公司里面可能有自己封装的框架呃，有时候可能会遇到一些bug。

你解决不了啊，解决不了，然后呢你最好还是有可能需要看一些源码，有可能可以需要看一下源码这方面的东西，但是常规来说影响不是特别大，但是现在在面试的时候，他为了考验你对应的一个技术深度。

往往在面试的时候会问你源码好，这是很尴尬的一个点，这没办法，所以源码这东西还是要学的，而且源码学完之后，不是说我工作用不到就可以不学了，不是这样的，我不是为了应付面试，我需要源码。

就是思想层面的境界的提高，会有很大的帮助作用，所以这块我还是希望大家能够把源码，能够系统的学一下，如果你把spring mybatis，Spring vc，Mybatis，Spring boot。

包括后面spring cloud double这些原版都看完了，你之后，其实完全有能力说自己开发一个开源框架出来，这完全有可有可能的，关键是你想不想这样做好吧，小林连web快开始了。

什么叫web快开始了，哪个web，所以啊源码课我还是希望能多看一下，都看完了，感觉成仙了，那不至于好吧，看过原版的人很多啊，不至于都成仙了，呃没没大家想的那么难，OK只不过源码一直被大家。

被大家当成一个非常难的东西，所以很少有人去完完全全看一下，他，其实看完之后感觉也就那么回事，没有特别难行了，多余的，废话不多说，我们下面来接着讲我们的源码课程呃，下午的时候呢。

然后我们大概讲到哪个地方了，还记得吗，我们是不是开始准备我们对一个呃application contest，是不是意思啊，我们这现在主要是干嘛的，叫prepare context。

往我们的上下文环境里面，商业环境里面注入一些属性值，和注入一些参数值，主要这样的一个工作，上午下午的时候我们看到这个地方，就是说他已经开始打印，我们对应的一个启动日志了，好吧。

之前我也给你们看对应的一个控制台了，这东西我没关，打印了两行对应的一个日志信息，人之心怎么打印的，从哪打印的，输出什么信息，那些信息从哪从哪从哪看出来的，我都带你们看样板，看了最下面我们接着往下走。

其实下面这块才是我们整体的一个核心点，好核心点上面东西不是说不重要也重要，但是在面试的时候，其实一旦聊到spring boing，Spring boot，问更多的人是什么，是自动装配的原理，好吧。

这块可能问的比较多，而自动装配就在我们后面某一个地方实现的，讲到那我再说好吧，我们接着往下看吧，来这块，我上午下午讲这块了，这是什么东西。

说at the boat specific singleton beans，添加一个单一的实例对象，或者单一的一个是并并对象，仅此而已，他拿过来一个东西叫get bean factory。

就是我们的编制工厂类，拿过来之后呢，我们可以往下走，第二个叫being factory，Register smoon，是不是注册一个单例对象了，注册谁啊。

叫spring application arguments，大家还记得这个参数吗，记得吧，这个参数在哪见到过，在我们之前那个run方法里面，大家是不是见过这东西，让我们先找一下，找一下我的run方法。

在这块我是不是new了一个东西哪去了，叫application arguments吧，是不是指的是我们命令行里面，输入进去的一些参数值，是不是在这好吧，所以你看完之后，你会发现这终于把它给输入进去了。

嗯哪嗯哪去了，就这是不是把它给注入进去了，application arguments就把这个对象放进去，完事了，别的东西不用管它，然后再往下看，再往下是什么，if print banner不等于空。

我们现在等于空吗，下午是不是已经打印出来，我们对应binder的一个对象了，所以这直接往下走不等于空，所以往下走告诉说，我把这个banner的一个打印对象，也放到我们当前这个b factor里面。

再来看说当前bean factory是否是属于我们的default，Libbean factory，大家还记得这东西吗，我下午带你们看原版的时候，大概看了一下那样的一个目录结构。

我不知道大家还记得没往后翻看哪个对象，哪去了呃，找一下啊，看不到看不到，我们一起来看一下吧，之前下午的时候在你们见过这个对象，我们之前看了一个类叫什么。

Annotation and notation config service，web servation contest吧，是不是大家看这样一类，在当前这个类里面，我带你们看一下它整体的一个类图。

也就是说它整体的一个继承关系，应该还记得吧，放大一点来往这看吧，这块是不是看了最下面这个类，然后我带你们依次看了整体的一个继承关系，到这块的时候，这块的时候我是说，这里面帮我们完成了很多特殊的工作。

包括我们的abstract application contest，在这个abstract contest里面，我们可以再搜一下，找一下那个类，找继承关系，走点它点开它点我们的strut。

在这个里面我们可以找对应的一个构造方法，找一下，是这样吗，不是这不是这样的话，就是在哪啊，我找一下在这里面吗，看看这是不是new了一个对象，叫this bean factory，等于什么呢。

等于new一个default liebbean factory，看见对象了吗，这是不是已经帮我们完成整体的一个，创建工作了，所以刚刚我们在我们的spring application这个类里面。

你是不是能看到对应的一个代码的实现了，这东西哪来的，是不是这个be factory，所以你要判断一下，当前BETHEORY是否归属于这样的一个工厂类，如果归属于的话，是不是该接着往下走了，往下走吧。

然后往下走之后马上马上，然后往里面写的就写叫SALLABEDEFINITIONOVERRI，是告诉你我是否允许一个纯写，这里面就是一个参数值，默认是什么false吧，这是一个false值。

就这直接把它给注进来，就是不允许你进行一个重写工作，这一步骤完成一个事情能看懂吧，所以我说了啊，你在看什么boot源码的时候，如果你对spring源码有一个清楚认知的话，你看起来可能会舒服一点。

如果spring源码之前没怎么看过，现在看起来可能有点难受，有点难受，但没关系，你先把这些关键的类给记住了之后，再看的时候也会轻松很多好吧，这边我说下午有课有啊，呃大家注意啊，那个群你们不要去屏蔽它。

当然有些同学可能会在里面，我们吹一下水，或者说扯一下别的这些东西，最好把群打开，因为经常会发一些群公告，上周二的时候，因为我们做活动做活动，所以呢那个驾校课没给大家上，所以今天下午我们补了一下课。

基本上咱们所有课程保证每周三节，你们最起码有的听啊，最起码有的听，现在上课前几分钟才通知，应该是之前通知的吧，很早之前就发过群公告，你可以翻一下，每周我看看公告，已经养成习惯了，对看一下公告啊。

每周三节基本上是这样的，保证你们最起码这一周有的学也没事干，多不好啊，是不是这意思啊，所以之前就算有，如果我们个人有一些特殊情况，可能会比如有天晚上不上课了之后，也会再抽时间给大家补补回来。

我们不会说无限无限期的把这个周期给拖长，这不会的，大家放心啊，这个替大家放心啊，OK好吧，这块我就不再解释了，我们接着往下看啊，接着往下看呃，多留意一下这个群，包括如果实在不清楚的话。

周五的时候可以问一下班主任，老师这周末会补什么课，行吧，好了不多聊了，来再往下看，但是判断完之后再往下做一件事情，要this lazy initializer吧，是不是否会进行一个烂加载。

这块没做任何设置的话，会直接跳过去啊，这个不用管它了，再来看叫source点get all sources，这个get all sources是干嘛的，是获取一下我当前所有存在的一些资源值。

对我们可以点到这个方法里面，看一下他完成什么事，首先创建一个哈希set，不用说了吧，link哈希set完成判断是不是这个值等于空，然后再往里边添加一下，再判断一下这个source值是不是等于空。

往里面添加，最后把它变成一个集合，所以当这个操作完成之后，你会发现了里面是不是只有一个source的一个对象，对象是谁啊，一样点开看一下，找一下我们的source谁是。

我们之前定义好那个primary source的，在进行spring application这个类实例化的时候，我们是做这样这样一件事，把当前这个类给它加载进来，所以这样判断一下这个值。

这个值如果等于空的话，那后面就没法加载，没有加载的必要了，所以这要把这个值对象拿过来，拿过来之后再往下走是什么呢，是我们漏的这个方法，这个方法我希望所有人能够重点关注一下，为什么，因为在这个方法的里面。

它包含了我们自动装配的一些很核心的一些点，其实就在我们的方法里面讲的，来看一下这个方法吧，你把这点你能做一件事情，不要他点进去，看这做了一个什么样的一个判断，你看能不能认识第一个logo。

Is debug enable，是否允许debug，不管它好吧，第二个说创建一个bean definition loader，是不是相当于一个类的，一个加那个注射器或者加载器这样的东西啊。

这块其实你不用管它，你直接跳过就行，想看的话，把里面看一下，里面的一个代码实现，是不是new了一个bean definition loader，一个对象，别的东西没啥了，别的东西没啥了，看完之后。

这已经logo标签有了，再往下接着找找找，是不是最后挨个的一个判断，判断完之后，这还有一个loader点load的方法，你点开这个load方法，这是一个循环，因为我们的主类有且仅有一个。

就是我们的spring date application，所以这里面也只有一个值，再点我们的load跳到下面了吧，跳下来之后，你看这段代码，你能不能做一个清楚的认知，这块是干嘛的，他说了。

如果你当前的source资源是一个类的话，我会加载类的load，如果我是一个resource配置文件的话，会加载配置文件的一个allow的方法，如果你是一个包的话，会加在包的一个方法。

如果你是一个字符串的话，会使用字符串方法，这是不是帮我们做了一个判断，你想一下你每次启动的时候，是不是需要在spring boot的主程序里面，添加一个叫什么，还记得吗，主要看一下这个链接是什么。

spring boot application吧，是不是有这样的一个注解值对吧，这个值会直接加进来，我们这儿很明显看到它属于什么class吧，是属于某一个类对吧，所以往下走属于类吗，属于吧。

然后点到我们这个漏洞方法里面去，在这个漏洞方法里面，它提供了几种加载文件的方式，第一种叫GA，我不知道读对不对啊，反正你知道这种方式就行了，这个方式你们之前有没有见过，会有印象吗。

有没有这个东西在spring bot源码里面，我带你们看的时候，有没有见过这个东西，没有很多同学一点印象都没有，我给大家说一下之前讲的每一句话，不能说都有用，但大部分是有用的。

我不会白带你看一些乱七八糟的东西，好吧，我会带你看一些有用的东西，什么东西，你点开一个类叫spring application，我们看一下当前这个类，在这个类的最上面往上翻，往上翻，乱七八糟是吧。

哈哈习惯就好好吧，习惯就好，他说了，这一类是用来干嘛的，好吧，是引导我们当前这个程序来进行一个启动，在启动的时候，他告诉你说你要进行如下几个步骤，我找一下哪去了，没有了吗，诶没有啊，我带你们看过这东西。

我记得看不懂啊，使劲跟着再找一下他这个print r，看以下这些步骤吧，他说创建一个这样的实例，Register，Register，Single bean，呃，这怎么没有了，诶没有了吗，不可能。

GROOVY看着看到了吗，就是说我们在我们在读取对应配置的时候，再告诉你了，你会有几种方式，第一种是什么方式，是不加这样一个NOTREADER的东西，第二个时你可以使用一个XML文件好吧。

或者使用一个什么呢，叫GRAVA的一个脚本，是不是动态一个脚本对吧，通过交换方式也能往里面进行一个注入，所以我说过了，你看源码的时候，不要只看这些东西，最好有注释的地方，把注释也稍微看一下。

这里面其实都有一个提示，那通过这其实我们也可以验证回来，要发生什么事，你往哪走，往回走，往回走，到这时候他是先判断一下，你现在有没有管我的东西，我们现在有吗，没有吧，没有的话。

那这个东西按道理说是应该跳过去的，对不对，就跳过去来往下跳，跳，跳这块吧，这是没执行，你没配吗，所以脚本压根不会执行，是不是跟我刚开始定义那段，或者他写的注释匹配上了吧，就这块一定要做一个前前后关联。

你发现了我在讲源代码的时候，我一提到前面的东西听过吗，没听过，一找肯定能找到好肯定要找到，所以这块大家注意了呃，讲spring boot启动的时候，先把spring ioc讲一遍，我不讲这个东西。

因为之前那个spring源码已经讲过了，所以就没讲啊，所以就没讲呃，这个你们回去翻spring源码啊，好吧，来往下看，下到这步之后，这儿有一个非常非常关键的方法，叫is component。

is component不认识，但认识吧，之前我们想要把某一个类变成一个呃，spring context里面的一个对象的话，是不是要加一个标签叫component对吧，你可以看一下当前里面这个方法。

他做了一件什么事情，你可以看一下叫merge annotations from tap，然后再有一个search storage，什么type，什么东西不认识不认识，往后走。

is pert叫component class，这个component class是个什么玩意儿是啥，是不是我们定义好的那个注解，所以它会扫描当前你的注解，这个组件到底是否存在。

存在的话才能把当前对象注入进来，如果不存在的话，你是不是注不进来，所以这时候我传过来tab是谁，是不是告诉你是spring boot data application这个类，你找他之后没满没完。

你要看一下这个类上面有没有包含，我们这个component组件，有包含吗，是不是验证一下，知道了，Spring application。

CTMD就跳出来了，跳了跳出来没关系，马上翻，你看这一类这一类的上面啊，不是这类啊，是我们自己的类啊，不是这类，点开这类这类上面有这个主键吗，没有没有吧，没有没关系，你往里边点，点击之后。

你发现上面也没有component组件，你再往里边点，这是不是也没有好吧，你再往里边点，你点到这个configuration的时候，你往这看这有没有一个component的东西，有了吗，有了吧。

它里面是不是存在着一个继承关系，这能看明白了，这如果看明白了，你再回过头来看一下，刚刚我们指定好这个参数叫search，这什么搜索一个策略吧，这个策略里面它是一个枚举类。

好在大学枚举里面有什么有direct，直接的，还有什么，第二个叫什么东西，他说放or directory，Decare。

notation and wise any叫super class annotation，是包含了任意的一个子类，所以它会有一个竞争关系，因为我们之前父类里面包含声明好这个组件了。

所以当前这个注解它也会被扫描到，所以此时你告诉我，刚刚我们定义好这个主程序类，能不能进行一个B对象，一个注入，能了吗，懂了吧，那这个值判断过来直接是true吧，你往下走是不是也能true。

true完之后直接把那些方法返回return true之后，这是干嘛了，只是告诉你说当前启动类我能够用了，但对象并没有进行一个注册功能，所以到下面这之后，我才开始整体的一个register的一个注册。

往哪走，Rein release，往那边走，走完之后，下面有一堆的逻辑判断，这里面更麻烦啊，这样更麻烦，就这东西我们看我，我简单带你们看一下，简单带你们看一下，我们不详细看了这块你看下上面的名称干嘛的。

叫注册一个B从给定的1class里面好吧，Devote it metadata from class decentration，从他指定好的什么类里面的一个注解里面，把他的一些原数据给分解出来，好吧。

这方法你都不用往下看，来我们往下走走走走，就是原数据处理啊，不用管它，走到往下走走走走，这块这有个非常关键的话，叫什么叫ban definition，Rather util register。

什么是不是叫bean definition，是不是还是我们这个holder，holder就是我们对我刚才那一类的一个包装，你往这边走的话，你能看到一个东西是不是叫get definition的一个。

Get the name，获取个名称吧，来看看名称是谁，是不是spring boot data application，有有名称吗，还有对应的一类对象，这有了名称之后。

我把这个名称和当前对应这个类都加进去，我才能把它给注册成功，这才是完成注册成功，这个功能除此之外，除了这点之外，还有什么东西叫definition holder，点get allayers。

你是不是也可以给我们当前这个bean对象，来设置一些别名，这个别名同样也会完成整体的一个注册功能，所以刚刚那个步骤到底完成了一件什么事，你告诉我哎，往往回返往回返回返回返没有了，高定文表达完之后。

完了干嘛了，注册并吧，你说清楚注册是谁，注册的是谁，注意是我们当前这个spring boot application里面，那个主要的那个启动应用程序，启动类，要把这个程序启动好。

是不是也在我们的context里面完成的，明白了吧好吧，这个时候你整个的逻辑线有没有理清楚一点，来TM同学扣个一，所以啊你把它一层一层往里面找，你会找到你自己认识的东西，当你找到自己认识的东西。

原来告诉我哦，原来是这么回事，心里很舒服了吧，是不是好，这就要注意了，OK这个操作完成了之后，当然我这个东西先讲这么多之后，还有很多其他一些组件，我们到时候再聊，包括那个自动装备怎么完成的。

一会再说他一会再说他好了，这完成之后又到哪了，叫listeners，点contest loader，又看到这个方法了，每次看到listen的时候，应该有一个条件反射，我之前见过N多次这东西了。

之前最起码见过三次，是不是还是用来注册我们对应的一个监听器，触发某些事件，只不过每次的事件是不是都不一样，对吧，来我这边点一下，看这是不是又开始循环了，这个listener是谁，只有一个吧。

叫event publish run listener，整个我说过，整个启动环节里面，有且仅有的一个对应监听器的一类，点完之后把这边走，然后呢叫context loader，点进去，点完之后。

这时候又开始叫get listeners了，application get listeners开始获取我们当前这个监听器，往那边走，判断一下他是否是这样一个类型，如果是的话，做做下面这个判断。

如果不是的话，就不做下判断了吧，往这边走，这个循环把循环走完，打个断点吧，这其实就是过程里面就是一个筛选的过程，就是一个筛选的过程，这块你可以不用管它。

就判断一个类型是不是这个objection aware，这个application contest awa有人见过吗，在spring是见过没见过同学回去看spring源码，老师之前也讲过这个东西。

它是一个扩展接口吧，是不是一个非常重要的扩展接口，你看到这些的时候都是扩展接口，好回头自己看，回头仔细看，我们这不说了，最终答案之后是不是又进到这个方法里面去了，此时他这个疑问的事件变成啥了。

叫application prepared event啊，之前是不是见过三个event了，还记得吗，先交了些事件，不记得没关系，回去看源码的时候，把这个事件给我记下来，给我记下来，记下来之后。

我知道了当前是第四个事件，有了第四个事件之后，我要干什么事儿，是不是还是要过滤我们计算器，哪些东西匹配我们对应的规则来，往这边走，哎呀完了直接跳过去了，找孙权打电影，重新打，重新打麻烦，有多少行。

94行，然后删掉删掉，重新启动，自动启动，直接跳过去了，不好意思，好到这了，到这之后我们接着往下走点F7进来，这是一个new一个实例对象，你不管它不管它再点是到这了吧，再点，然后呢再往里面走点。

它是不是又到这样当前这个方法里面去了，怎么做呢，往里面挨个进行处理，先获取到我们所有的这个listeners，往这边走，这边是不是一次就是一个基本的判断，慢慢走走走走，走到这一块是不是要进行返回了。

点进去往下走走走走，走到这块是不是要进行一个判断了，叫sport event，判断一下我当前到底是否支持，我们当前这个environment这东西吧，然后再循环走走加进去，判断是多少，就判断。

大家看了是不是有N个条件的一个逻辑判断，当你把当前这个逻辑判断弄完之后，是一共有11个，最终会剩下几个符合我们对应需求的，来看看这个ODNESS吧，一共几个五个吧，怎么做条件判断呢。

这个具体规则你下去之后自己看，下周自己看，我之前再给大家看过很多次了，我们这不带大家看了，你知道还剩下五个吧，有了五个之后往回翻，返回来到这儿了吧，是不是从这五个里面挨个取出来。

第一个the cloud foundary，什么东西，一看到是一个云平台，我们这没有支持往这边走，invoke走走走，点进去是不是只带一个日志变都没有吗，没有吧，没有不用管它了，好吧。

这相当于这个事情是什么都没做好，没做完之后再往返，第二个叫config file，Application，什么东西，你看到这个config file之后，你是不是有点熟悉了，他干嘛的。

是不是还是一样加载我们对应一个配置文件的，是配置文件的，所以你往里面走一下试试啊，往下走点进去点进去点进去再说event instance of，这东西匹配吗，不匹配吧，好再往下走。

这时候匹配匹配之后往里边点点进去，这是干嘛呢，叫this log switch to，告诉你说这个logo东西，你看log先不管是不是就是日志的一个输出。

是不是这个输出再来看叫ADD post processor，这里面是不是开始往里面添加我们的post processor的，对吧，加什么东西点进去，这返回一个具体的一个值，Connect。

不管它点进去知道吧，叫contest at bean factory post processor，你有一个什么对象叫property source ordinary post processor。

此时你看到当前对象之后，我应该知道一件事了，知道什么事，我把我当前的这个context里面注册了一个什么，叫bean factory post processor，而这个b proper在干嘛。

会对我们之后所有要存储的这些资源，进行一个什么操作，叫orderly吗，是不是order排序嘛，好完成一个基本的排序功能，所以这块就它一个基本功能完成之后，往回返往回返往回返往回返返返，是不是到这了。

再看看下一个是什么，叫login application干嘛的，那这时候我们要看一下了，这个login啊，我之前用过很多次了，完成初始化系统，比如初始化日志系统，包括往里面放一些参数值。

这时候又用到了点点进去点进去点进去，这要判断了吧，判断哪个走走，这是不是能进来，点进去走，这边也说了，configuration bean factory等于啥，是获取当前B对象。

然后再判断一下当年配对象里面，是否包含这样的一个参数值，叫spring boot login system，是否有这样的一个日志系统走，是不是进来了，我进来之后往里面注册一个什么。

是不是把它注册到我们的being in factory里面，也是一个示例对象嘛，这块都是一样的，之前只是完成初始化，完成了复制操作，但是你并没有构建整个对象出来，而此时是不是开始构建对象了。

并且把我们的不是，并且是不是往我的context里面，是不是该进入进行注入了，这块是不是都有拿走走走好，这是一个log group，是不是日志组的东西，不管它了，好吧，也是往里面注册对象。

你知道就行了好了，这做完了，做完之后往回返没有了吧，这是日志，这东西要做操作，再往下看叫background什么东西，之前我们看到的所有background几乎都没做，什么事，什么都没做吧。

那这样是不是也一样的，点进去点进去点进去走走，看这两个是不是都跳过去了，不太满足条件吗，跳过去不管它是再往回返，在这最后一个叫delegate什么东西好吧，这个东西之前是不是也没做，是不是也没啥用处。

没用处也是一样的，点进去看一下，走走走，我判断判断都不符合规则吧，往回翻嗯好了，做完了，做完之后里面还有吗，没了吧，我说过一共只有五个，所以这五个做完之后，这工作就算是完成了。

还是我们监听我们对应的一个事件吧，这里面就是监听什么事件，第一个跟我们的property source进行一个排序的功能，好吧，第二个来把我们的日志系统的一个bean对象。

注册到我们的content里面去，签合作都没做了，对就完成最基本障碍功能，往回返吧，返返这还有吗，没了吧，就一个对象吧，走当然不是完成了，到达完成之后。

我们整个prepare compass这个操作就算是结束了，好来回顾一下，在这里面，我们到底做了哪些最基本的一个工作呀，啊做哪些基本工作，想一下能想到吗，这个paper context里面回顾一下。

第一，我刚刚是不是只创建好了，一个实例化的一个context对象，但是里面并没有进行参数值的一个复制，参数值一个创建，所以现在我要往里面复制某些具体的参数，而复制这些具体参数值的时候。

你注意一定要看它对应的一个，父子之间的一个依赖关系，因为它是根据我们的依赖关系，里面添加了很多其他的一些属性，包括类的一些初始化工作这块东西，如果你不看的话，你会感觉到很懵，我就感到很懵。

然后做完之后也是一样的，这里面还做什么事了，再想到什么事了，这就是设置一下对应的一个环境值好吧，设置一个post processor啊，做一些post processor创建工作。

包括一些最基本的一些content，里面注册信息是这样工作，把它做完之后，别的东西就没有了，别的东西没有了，所以这个环境准备也不是特别难好，也不是特别难，这块一样的，下去之后自己跟一下源码。

看看里面到底做了什么样的事情，但你要知道它最基本功能是干嘛的，是不是准备我们的上下文环境啊，这块认识到就行了，认识到完之后来再接着往下走，这块儿来能听懂的同学能跟上，同学扣个一能跟上吗，记住我说那句话。

你在捋的时候自己别乱了，之前看到过东西跟现在看到的东西，你要放一块做对比，放下做对比，这对比什么意思，别之前看过啥都忘了，一点印象都没有，这不对，这样的话你看看他什么时候你都一脸懵好吧。

发展完了之后get到这个东西叫refresh context，到这个步骤，这个步骤是一个非常非常麻烦的一个基本操作，来我们看一下里面做什么事吧。

你把这点点完之后叫free flash contest对吧，再往里边点好，往下走，点，点完之后是不是super好，再往里边点，讲到这块了吧，这是完成了一个最基本的一个初始化工作。

他在哪个类里面叫abstract application，然后呢contest吧，还记得这个类吗，记得当时我为什么要带你看这样的一个关系图。

那个notation呢就没了，Apple tation，T a t i n config website，这类里面我带你们看了一个整体的类图，在类图继承关系里面。

是不是有个东西叫abstract application contest，是不是在这，你刚看到这个类，这两类一样吗。

是不是一模一样，看的就是这个类，在这个类里面有一个REFLESH的一个操作，好REFLESH作，而REFLESH其实这块东西属于谁，属于spring里面的东西，而不属于我们的spring boot。

spring面是不是要进行REFLESH操作，还记得吗，这个spring里面reflect操作，知道同学来扣个一，不知道同学扣二，知道吧，这些都知道啊，当时当时讲源码的老师应该跟你说过，这东西这么多。

不知道的，我这这没法带大家看啊，这个这个没法带大家看，看的话太太多了，王师傅说过是吧，自己没看过是吧，你其实没关系，没看过，我们我们粗略的看一下，粗略的粗略看一下好吧，看着没完成什么功能好吧。

然后再看第一个叫prepare this context for reflesh，啥意思，你看注释，你讲过视频视频源码吗，没有没讲过没讲过没讲过，我加SPRBOOT源码，没加all spring源码。

我们看进来之后再做一件事情，Prepare reflesh，是不是准备，我们进行上下文环境的一个刷新工作，好吧，来往里面看，我们看一下做什么事，我们点一下点一下看，知道了好吧，点进去。

然后他告诉你说this scanner clear catch，这个scanner还记得是干嘛的吗，有没有同学记得这个词SKT是啥，我们当时在创建这个annotation config server。

Web server，application connect的时候，是不是定一个实例化对象，是不是有个扫描包小方式完成初始化工作，是不是扫描一下上下这东西，我之前讲过这东西了，好吧，你要忘了的话怎么办。

还是一样，看这个类里面找一下构造方法，这是有个scanner，scanner里面是不是指定好了，干嘛的，叫create new呃，不是这这找一个方法，看这个方法是干嘛的，他说了，定义了一个bean好吧。

能够干scanner，我们当前那个什么，当前我们这个路径里面的所有的一些组件，进行一个扫描工作，就这就这这这类来完成的，所以这个第一步是不是完成这样的操作，往回返啊，把它缓存给清空掉。

清空掉之后一样也是掉到父类里面的，we prepare reflesh做什么事，第一个switch to active，记录一下当前的一个时间好吧，把close给关掉，把active给设置成开启。

让它进行日志的一个输出吧是吧，这块不用管它好吧，再来看叫init property source是干嘛的，it初始化吧，Profesource，Professor，source source熟吗。

之前是不是看过很多proper source的东西了，就完成了我们这些prop source的一个初始化功能，把它点之后也是一样的，判断一下当前的环境是啥，然后呢如果是他的话。

进行一个初始化工作里面是不是依次往里面点，里面包含包含几个环节，还记得吗，咱们那个property source里面包含了几个环境。

还记得同学来扣个一几个，还有没有一点印象，没印象了，是不是一共有具体的四个，刚开始是四个吧，刚开始不是四个，思考完了之后，我是不是加了一个东西，叫什么叫configuration呃。

叫什么default，Configuration，还记得吧对吧，后来又加一个加一个random吧，对不对，后来又加了一个什么，是不是加了一个application，然后点EML记得吗，是包含七个。

七个是包含七个，看一下property source17个吗，看这configuration propose，然后呢server的两个，server system的两个，然后加上我们的random。

加上我们的application改压毛，是不是这几个对吧，记住记住记住一定要记得一定要记得，别忘了，你还没讲完就忘了他，所以我说了啊，你们你们为什么看源码的时候看不下来，原因在这儿。

很多同学看完我前面讲的源码了，我看完自己之前看的东西了，看完就忘，后面看到这东西，我感觉跟新东西一样不对，一定要产生一个前后关联，前后关联点进去是完成初始化工作，你印了什么东西。

get proper source干嘛的，就是一个初始化啊，这是一个初始化，这块我不往这边看了，再看就没头了，不往这边看了，你知道他完成什么事就行了，这玩意什么事，就是一个初始化工作吧，清理完之后。

这是什么东西，叫get environment，Where a balidate required properties，这是干嘛的，你怎么做到看了不忘，看多了就看的不忘了，他怎么做到的，你要有点印象。

好像有点有点有点印象，具体类名我也记不住，但大概大致的东西我会记得好吧，我来看看这个函数干嘛的，叫获取环境，并且进行一个验证必备的一些属性值吧，是不是就是验证操作。

你把这个点还有一个具体时间内看哪个看吧。

再往里面进行一个验证就行了，我们这不往里面看了啊，这是干嘛，这边就是一个环境验证验证的一个东西，好吧，就验证东西啊，验证完了之后来再往下看在干嘛，是不是。

this radification listeners等于空，我们现在就等于空，这个值没赋过值吗，等于空进来之后把刚刚那个里面类似，那是不给他付过去，创建一个集合，找上下集合之后往下走。

找this early等于什么，你有一个list是不是把它给放进去就行了，创建一个新的对象，仅此而已啊，别的东西没有了，然后返回啊，然后返回，这就是刚刚那个初始化的工作，是不是准备了一些基本的环境。

只是配置文件一些操作啊。

这吃住就行了，这块如果你实在不知道的话，没关系，我之前给你写过笔记，找一下我写哪了，Reflesh，这看完了，刷新上下文环境，初始化上下文环境好吧，对系统的环境变量或新增属性进行准备和校验。

现在这句话看明白了吗，你看完原版之后，你再看这句话是不是会好很多，大家知道啊，里面原来这样一些功能，这样一些功能，这样先先记着先记着先记着啊。

记完之后来往下看，第二个操作叫tells the success to reflesh，The internal being factory，这干嘛的，什么叫internal bean factory。

这个intel bean我告诉大家，你如果去实际的类里面找的话，你压根找不到这些东西，但是在我们debug这个环境里面，它确实存在着一些这样的值，找一下我给你找一下，找一下你就知道了。

Being in factory in it，Being map，在这吧，看这这是有一些值叫o r g spring contest，什么internal config，什么东西，什么东西，特么东西。

什么东西是有很多这样的值，我虽然不知道这个是干嘛的，没关系，我们搜一下，看能不能把这只类给搜到，好吧，叫internal in，N t e r t e r，然后呢叫NALCONFIG。

IGURA还用搜吗，没有吧，注意了，这些类值你是不存在的，是不存在的，但它干嘛，它只是指定了具体的一个路径，有一个路径之后或者一个完全限定名，根据完全限定名，它其实起的是一个名称，根据这个名称好吧。

我们能找到具体的一个实例类，相当于把那个类换了个名字，而名字起的这样一个名称，仅此而已，好这东西啊，我后面讲自动装配的时候，我会带你们看一个，看那个东西的时候，你就知道怎么回事了，好先留个印象。

然后点进去看一下吧，做什么事还是一样，reflesh being factory往里边点，然后呢这是false是吧，进不去，然后呢叫set seriid，是不是创建一个序列化的一个id值，往这边走。

返回一个id education，搞定这东西就没有了，现在没有了，然后呢return一个get bean factory，返回当前bean factory对象。

还有谁叫default libbean factory吧，还是当前这个值，这是没变化的，所以当时下午讲课的时候，为什么给你强调一类连接在这后面，你在很多地方都能看到的东西，能看到东西好吧。

就这个对象再往下走，叫prepare bean factory，刚刚是不是告诉你说我获取到了一个bean factory，现在呢是不是要进行一些准备工作了，好吧来吧，你们看这个类是谁。

是不是还是default libbean factory啊，还是当前对象好吧，你妈妈点进去就完成了一些出场工作，set beclass loader好吧。

Set being expression resolver，是不是表达式的一些操作，再来看at property editor register对吧，往下走，at bean什么东西。

ignore什么什么什么东西，是不是忽略，告诉你说我忽略这些依赖的一些接口，告诉你一些忽略，然后再往下走，就是往里面注册一些处理器，处理器这些依赖关系慢慢走走吧。

走是不是要判断一下当前那个类似是哪个类型，走都是一些判断，所以说大家看到了，我就是把我们当前这个bean factory里面好，b factory里面给他做一些参数的设置。

是不是这意思好，再注意一下行了，刚刚我这里面也写了啊，往下看，脚背上扬，准备been factory，对been factory各种功能进行填充，Roware specific。

这个这个SPEL表达式是吧，编辑指出，注射器添加app商店，国外的propost processor这样一个处理器等等东西，这块也属性值啊，没必要挨个看，你大概理解什么意思就行了。

大概什么意思，再来看叫post processor，Dean factory，是不是又是一个定factory，叫allaw post processing of the bean factory。

In contact suppsubclass。

还是为此类添加一些具体的功能，找我写了吧，提供子类覆盖了一些额外处理及此类处理，自定义的be factory postprocessor，就这个功能啊。

再注意一下行了，再往下看，这东西叫invoke，Being factory postprocessor，invoke是什么意思，表示执行处理的一个环节吧好吧，而我们注意了，我们后面再看的时候。

很多自动装配的类，它在完成这个初始化这个对象工作的时候，其实就在这个步骤里面完成的，所以这块我希望大家把这个方法给我记住，现在我不带你们看，之后的时候讲自动装配的时候，我会带你们详细把这个流程再看一下。

你就知道原来是这么回事啊，其实就是一个解析配置的环节啊，解析配置的环节好吧，再来看是干嘛的，叫register，然后呢being processor that interrupt。

Being creation。

这句话翻译过来怎么翻译，看不懂没关系，我这写了啥东西，叫注册拦截并创建并处理器好吧，即注册并post processor，那这样往下初始上下文环境的资源文件，如国际化的一个处理。

再来看初始化上下文环境广播事件，再往下看，为了子类扩展，初始化其他的一些病，还有呢就为所有在所有的bean中查找listener bean，然后呢注册到广播器中，最后完成初始化。

剩余的非懒惰性的一些bean，及初始化非延迟下载的并对象，最后一个完成刷新过程是真心的过程。

这个步骤啊里面东西很很很复杂，我没法在你们挨个往里边看，但你要知道，这个方法里面起了一个至关重要的作用，而我们之后再看的时候，就那些auto comparable呃。

那个叫auto configuration的一些并对象，都是通过这个方法注册进来的，什么时候注册的，一会这个方法我会带你们进去好好看看，进去好好看看这其他方法我就跳过去，不看了是谁，如果不清楚的话。

你上网搜一下，一搜spring contest，一搜搜spring spring contest，然后加一个REFLESH1堆解释好吧，里面有很多页面来解释，下一周自己看行吧好吧，这块不带你们去看了。

这套太浪费时间了，咱毕竟不是讲spring东西啊，你看了这些过程可能要花点时间啊，他不是说立马就往下走了，是不是要需要到执行时间啊，所以这块比较关键，这个步骤往下走，走走走走走回来往下走。

走完之后叫register shut down，shut down hook吧，这干嘛的，注册一个关闭结束的一个钩子吧，这钩子非常简单，判断一下这个值是否等于空，现在是否执行完了。

执行完之后读close，执行一个close方法，这块东西很简单好了，往回返吧，这执行完之后，这就完成了，一会儿我们再详细一会再详细看下东西，所有boss还没学全，我是不是可以撤了。

现在撤的话之后也一样看不懂哈，这东西不在于说你spring boot会不会用，跟你会不会用半毛钱关系都没有，关键是你要对整个体系结构有一个认知哇，这时候你再看就好，就舒服很多了，明白意思吧。

对硬着头皮去听，这是一个很好的方式，因为你现在听起来可能不知道我在说什么，但是当你把某些基础知识的一个储备，如果具备上来了，你再回过头来看我说这句话的时候，你知道哦，原来老师想表达这个意思，听明白了吧。

它是需要一些基础知识知识的，特别是源码里面的东西，好混脸收也可以，我相信啊，咱们班现在听的人有80多个吧，你告诉我有几个人能完完全跟下来，其实比较难，其实比较难好吧，所以希望大家能够认真去跟一下。

认真去跟一下，我我觉得很少有人能把它跟下来啊，呃多听两遍，然后多搜一些基础知识，你慢慢就知道了，因为说实话我不可能说我再讲一个存储源码，我把前面很多系统知识再从头给你讲一遍，这不太可能你哪个地方没听过。

OK记下来，下课之后搜资料，搜完资料之后可以回过头再看懂我意思吧，慢慢去补充，慢慢去扩充，这样的话你就理解是什么意思了，如果你现在，如果你现在一次都没听过，你第一次听的时候，你依然还是会有一种感受。

什么我这种又是全新的懂我意思吧，多听几遍，你会发现还是不懂，不可能好吧，多听几遍，不可能不懂的，不能不懂啊，27真可怜，可怜啥呀，我给大家说一下sn boot源码本来是没打算讲的。

是因为在那个就年前就12月份的时候，很多学生，他说老师我在面试的时候问到spring boot源码了啊，你来给我说一下这东西吧，我来讲一下吧，我们先把这个规划的课程里面懂我意思吧。

老师讲spring mod源码有画实例图吗，一会我给你画一个整体框架图，实际图我之前尝试画过，但是这里面比较恶心，比较恶心，为什么叫恶心，比如说光这个spring application这个类。

你往下翻一下就有上千行，这是来回进行调转的一个过程，所以你画完图之后，那个线勾的真的是真的是那个什么，就是乱七八糟的，割完之后你看到示意图，你画你画你画不清楚，你懂我意思吧，真的是你看了我之前画过。

真的是你画过，我想过各种方式把东西给你画出来，但是真的是凑不到，你知道吗，好吧，你先你先你先听你先听好吧，你先听完，感觉一直在累的对，就是这个类来回调，调完之后就回不来了，调完之后又回过来了。

你会发现这个东西很乱，太乱了，没法画，真没法画好吧，还是要搞清楚类图对，这是为什么，我在讲源码的时候带你们看了很多类图，原因它有一个竞争关系，里面包含很多对应对应东西啊，啊没事没事呃。

我也没指望你们一遍能听懂啊，一遍听懂，我感觉就是也不太现实，就慢慢听就行了，OK好了，刚刚是完成了我们这个context的一个刷新功能，刷新功能刷新完之后，下面还有什么东西叫after reflesh。

这啥意思啊，什么意思，什么叫after reflesh，就说你刷新完了之后，他又完成一件事，但是你往里面走的时候，你会发现这里面什么东西没做好吧，这个功能是干嘛的，是为了我们不是在插件啊。

是为了完成我们具体的一些扩展功能的，好扩展了，他说了，Called after the contest，Has been refreshed，当你刷新完成之后，我会做一些后期处理，它里面什么都没写。

但后续的话，如果你需要填充一些基本功能的时候，你可以把这个代码里面补充东西，懂的东西明白了吧，好吧呃，来我再往下看，这执行完成之后，其实我们基本的核心环节已经都做完了，核心环节都做完了，做完之后好吧。

该干嘛了，还剩下最后的一个具体的一个过程，或者最后一个步骤叫stop，watch加stop，这不用我说了吧，刚开始还记得吗，我们是不是记录了一个启动时间对吧，时间完了之后一定要关掉好吧。

点进去点点是不是会记住一个一个一个值，写完之后把它记录下来啊，把这个值返回去，返回去之后，这是不是有个this log start rainf，看下这个值讲完之后，new一个具体的对象。

这个对象里面是干嘛的，之前说过了吧，返回返回返回走，返回logo get什么这个对象，然后再往里走，是不是obligation inform，什么get message叫start in什么东西。

我们看这边m running for，是不是刚才这个时间把它加进来，然后把数据给返回去，就让你看一下我们控制台吧，看不懂他走走嗯，哪去了，是不是完成了，告诉你了吧。

说start spring fication in，这东西用多长时间，1393秒，因为我刚刚重启了，如果没重启的话，这个时间可能会更长，可能会更长，要记录一下你当年启动用多长时间，懂我意思吧。

因为我们debug的一步一步看的，所以这个时间会稍微长一点，你正常启动的时候可能不到一秒钟，启动完了，懂我意思吧，保持这个logo stars off，这个工作站做完之后来再接着往下看。

好叫listeners，点start是到这了，看来这又熟悉了，这干嘛的，是还是我们对应监听器，它所要做的一些基本工作了啊，完了点一下吧，看下这东西走，改完之后也是一个吧。

叫event publishing，然后呢run listeners慢慢走，点进去，新的事件叫application started in event吧。

是不是刚现在要开始运行我们的application了，不是开始运行了，点一下试试走走，不管他点进去，点进去往这边走，还有这个事件判断完之后往这边走，是不是又到一到又遇到这里面了，也是挨个进行一个执行。

这是返回一个对象，我管他下点到这了吧，在这之后也是获取到我们这个listeners，一共有多少个点一下，我这直接往那边跳了啊，直接往直接往后跳，直接跳，没法跳，那就走一下吧，走一下。

开始是不是RETURNENERS，这个listeners等于几啊，看一下有值吗，刚刚太快了，没看到，不算了，没关系，大家往这边点一下走，第一个叫background，Background。

想想之前做什么事了吧，没做吧，那现在你想一下，是不是按道理来说也应该是什么都不做，走走走判断这不合适吧，所以这东西过滤掉了，第二个之后也是一样的，Delegate，它是不是也是一般情况下程度不做。

不管它了，不管它了，再来看第三个，诶，哪去了跳哪去了，找不着了，诶怎么没有了，我刚才点错了啊，咱这里面是完成了一些最基本的一些，处理的功能操作，我再往回点一下试试，这我们从运行一下啊，点太快了。

把它给干掉，这300多号删掉来重新选项，带你们看一下，带你们看一下进去，然后呢进去，点进去点进去，说到这个方法里面去了，这可以获取到我们这个listeners，往这边点走走走。

这里面会有一个整体的验证过程，哎呀走走走走走，是不是到这方法了，在这个方法里面，方法里面是不是有一个又又是东西叫sp event吧，验证这个规则是否合适，如果不合适的话。

是不是直接进行一个跳转返回就行了对吧，挨个往里面进行判断，执行完，不要返回啊，太麻烦了，OK等一下等一下，这不是这还没到啊，太麻烦了，嗯到哪去了，这我更懵了，这到哪了，这好了。

到这listener等于几个，是不是一共有两个好，你就看到这个listeners一共就两个，所以到时候我们在循环的时候只循环两个就行，一叫background，一个叫delegation。

在这两个里面你也会神奇的发现一件事，往下走，这看循环了，循环之后，第一个background的之前什么都没做好吧，这也是一模一样的，你往下点一下试试走，点进去走，走两个if是不是干完了对吧。

干完之后来再往下走，在这是不是delegate这个东西，再往里面走，Invoke，Invoke，Invoke，点进去判断判断都不合格吧，他执行完之后，大家想一下是不是相当于最后一个电器。

我几乎跟什么事都没做一样，是不是这意思啊，所以他直接就进行一个最基本的打印工作了，大家注意了，这个东西啊，是新版本里面，他好像什么都没干，如果你看的是比较老的版本的话，好吧。

它的版本这个过去的值是不一样的，个数是不一样的，明白意思吧，这做完之后在干嘛，叫call runners，是干嘛的，一看到runners，你应该是比较舒服的，rs是不是正儿八经正式开始进行运行了。

是怎么运行，点进去看一下，这创建一下这个release，然后往里边开始添加我们这样的一个值走，这时候run有东西吗，没有吧，这个值没有吗，不存在，所以角进不进不进不去。

第二个呢con online是不是也没有，也进不去，进行排序，没啥可排的了，基本上就是个空的一个值，然后这个时候开始判断我们这RN，因为你当前是一个空对象，这里面会进来吗，不会吧，所以直接跳过去了啊。

直接跳过去了，再往下看，当你跳过去之后，跳过去之后到哪了，说到下面这个地方了，叫licenlisteners running，之前我们开启了很多个的一个监听器，然后呢让这些监听器是不是开始运行起来。

运行也一样的，点进去好吧，挨个进行运行，running点进去是不是又是一个叫application reevent，是不是ready event对吧，这是告诉你说我已经准备好了，这是第几个第五个了吧。

第五个疑问的事件了，完了点一下一样的published走走走，点进去，这不是开始循环，这我不看了啊，这边类似哪几个呀，进去有几个，这看不到是吧，我看下全都能看到吧，看到了看到了没关系。

我们看一下第一个是什么呢，叫spring application，Admin mx being register，这不是一个东西，它会进行一些具体的实际操作，然后把ECO里面执行多人口。

然后点进去是判断一下这个类型是吧，ready完之后，这点进去好吧，然后呢往里面进行一个判断，说是否等于这个值，如果是的话，状态告诉你说是可以的，是不是等于true了好吧，你等于true了之后。

是不是这个值可以进行一个返回工作了，告诉你说我已经准备好了，准备好之后往回返，这还有吗，第二个叫background，不用看它了吧，什么都不做，对不对，不看它了，走第三个也是一样的，不管它还有吗。

没了吧，所以这步是干嘛的，告诉你说我现在已经准备好，可以进行一个启动工作了，好这是一个ready，这个这样这样这样一个操作，ready一个操作，点完走回来到了之后。

是不是直接把我们这个context给进行一个返回，意味着context已经准备好了，准备好之后往下走，是不是告诉你new一个spring run就执行了吧，走再往回返，回到第一行了吧。

祝我们刚开始看到这个代码执行完成之后，就OK了，是不是按到一个list了，这时候你能看到一个完整的一个环境，就告诉你说我已经都启动完成了，但中间你会发现一个神奇的事情，我们好像少看了很多东西，什么东西。

第一个这块这句话我们见过，第二个active for active file，我们见过，但是像这个tom cat这东西对吧，Study tomcat，以及我们这tom cat这些服务好吧。

这东西你有见过吗，没有吧，是不是没见过，包括中间这些环节，我好像都没有怎么见过啊，然后到最后一句话的时候，我哪见过，这中间是不是省略了很多的工作，这个工作什么时候做的，对我跳过了。

他们看这块我没带你们看，在reflex的时候，他会注册很多对应的一个bean对象，在里面会完成我们很多自动装配的一个功能，是在里面完成的，懂我意思吧，所以刚刚那个环节就完成了。

我们整体这样一个启动步骤和启动步骤，所以这块希望大家能了解到好吧，来到目前为止，我们差不多花了五个小时的时间，把这个runner运行的时候就搞定了啊，就就就就就完成这个基本的操作了是吧。

大家想一下这个run麻烦吗，麻烦吧，你看起来好像说老师我一启动一个程序，然后右击运行，看起来好像很舒服好吧，跟什么事情都没做一样，其实里面涉及到N多个步骤，因为花一秒钟时间，当你debug看的时候。

里面完成了N多个对象，N多个参数等各种值的一些装配工作，有很多准备工作肯定是很麻烦的啊，所以这块你要注意一下啊，其实这里面还涉及到另外一个东西，另外一个东西是什么呢，就是自动装配的一些核心。

把自动装配的一个核心，但没关系，一会我带大家看啊，刚刚那个启动过程好吧，稍微有点感觉，同学来扣个一，我大概知道它里面做什么事，同学来扣个一，能看懂吧，好了，能看懂的话，来下面的时间，我们休息10分钟。

10分钟回来之后，我10分钟回来之后，我来带你们画一下整个启动过程，我到底做了什么样的一个事儿，好，它里面完成什么样的功能，我们一起来画一下这个图好吧，整体的一个部署的一个图好吧。

10分钟之后我们再接着聊，OK还是要撸几遍，肯定要看的，不看不行，就等这个了，今天最后一节不是不是不是不是第三节，我计划周二周四啊，周二周四再讲两节啊，计划这周再再讲两节，从下周一开始。

你们开始讲网约车，网约车好吧，好乱就记住各种listener，Context，Property source，来回prepare reflesh，他其实就是这样的过程，准备好。

然后添加属性之类的东西好吧，完成SPRL，怎么是的是的，二期比一期讲的要多，二期的计划是12节课，12节课，我还是听不懂，不至于吧啊，不用不用不用不用天，二期就好了，二期在一期基础上做了一个扩展。

做了一个扩展，我看这也没有啊，没有白皮书，白皮书可以给大家看一下，用打宝宝不用不需要听，这是spring cloud，不用打我，我是在外称吗，不讲了吧，让我歇会儿吧，我讲完这个课。

我大概要去那个基础班讲4SM了，讲SM9，再等我一下，我给你找一下那个那个白皮书，大家可以看一下。

咱考了一份啊，嗯大家可以看一下吧，就这个网约车二期中还要讲解的一些知识点，好吧，包括一些前端页面的一些设计之类的，然后呢包括像后面的一些服务设计呃，架构的一个设计，包括整体的一个架构图这块。

大家看到这个图非常复杂，非常复杂好吧，后面有课程大概讲什么东西，一共包含的是诶这一期的。

考官来一期的，搞错了，搞一期的二期也一样，在一期的基础之上做了一些扩充，做一些扩充，所以大家如果想先找工作的话，这个这个这个项目，这个项目是可以用到你的简历里面去的啊，用到简历演戏的。

大家下课之后可以找那个班主任老师，过了一会我给大家分享一下，我们这个课程与白皮书啊，下课再分享，玩的比较匆忙，所以考错了，OK反正你知道你下一步要学啥就行了好吧，可以为啥不能呢，可以可以啊。

老师这个源码你看了几遍，不知道谁还数变数啊，看懂为止吧，数变数也没没没没没没没有用处啊，常老师讲，基础班听SM那个SM为啥可听的对吧，这只是一个入门级的东西啊，我问一下那个markdown软件的名字。

T y p o r a，对就这个刚听到打火机的声音，抽根烟放松一下好吧，老师抽烟了，这声音很大吗，这你们都听不着，要下楼买烟了没有，我们办公室一般都存着好几条，就我跟周老师这种大烟枪没烟，我的天哪。

我们就疯了，你说想抽了，我一天一包够不够，一天一包肯定不够啊，不抽烟啥感觉，不抽烟感觉要死了，不抽烟课就没法上了，压力太大好吧，感觉这个世界都不好了，抽烟写代码，头发情调，三包倒不至于啊。

我回家之后一般都是去楼道抽烟，It's good，前端快完了吧，好像是快完了，那加个VE应该就没了吧，家里有孩子不能成，是这样的，12节课，27网约车计划，12节课有可能会更多，有可能会更多。

所以啊多出很多内容来啊，办公室抽烟怕是要卷铺盖了，马老师比较好，允许我们在办公室抽烟，所以支付吗这个细节我还不了解，一会我把那个白皮书分享出去，你们可以看一下，可以看一下好吧，下课之后吧，做一个分享。

下载之后发出去，好了来还在同学扣波一，我们开始要画画这个图了，你们在聊啥，会更新的那个会更新的，肯定肯定肯定会的，肯定会啊，就放心啊，你们抽烟，六六和齐老师不说吗，我跟周老师有自己的一个单独办公室。

所以在办公室抽烟没事，外面闻不到SIM讲了个T不T吗，不讲吧，一个工作流也没啥讲的吧，很简单的东西了，需要的话，我们就提一下这个工作流也没啥，我胃还用开发吗，现在网上一搜一堆老师。

你要去想的SN哪个课程，后端工程师这门课，后端工程师这门课，基础班，基础班的课程好吧。

Process on top。

诶啊把这浏览器打开错了。

好了来我先来画一下整体这个图啊，怎么打不开啊，天哪，对就是这个课就是这个你讲项目讲啊，那个那个到时候那个什么叫啥，何佳音服务平台，我讲何家英服务平台，我讲啥时候讲算法，心情没捣乱，算法讲不了算法。

往后推吧，何佳云那个云服务平台，到时候会讲这样画一个图，我们现在带大家从头画大头画好吧，我们不在之前的基础上做啊。

我们从头画好了，那个有啥问题，一会儿一会儿我们再聊一会，我们再聊好吧，我们先把这个流程梳理清楚，有啥问题，我们讲完图之后，大家再聊这个事好了，下面我们来看一下整体这个spring boot在启动的时候。

还做了哪些事情好吧，首先第一点啊，首先第一点你要知道了，我们刚开始在启启动运行的时候，这边会先有一个什么呢，叫spring，LOYC好的类，是不是他这个在这个类里面进行一个，启动过程的。

这类非常非常关键，是因为之后我们看到了，几乎所有代码里面都在这里面去，是不是在这，然后看完了之后，首先第一步骤，我们虽然在这个主方法里面，我们自己没有创建对象。

但你要知道这里面其实涉及到一个什么叫new spring，的一个过程吧，这个过程就是完成了一个这个对象的一个，基本创建，这个东西啊，其实并不是特别麻烦，好比说他拿过来，但你要知道在整体初始化里面。

他做了什么样的一个事情，要写一下，啊不这样写，这样写一下，初始化这边也一样，是分出来N多块，分成N多块吧，哪些块啊，大家想一下，第一步骤，最关键的是不是有东西叫resource loader。

你们跟我想跟我去回忆好不好，跟我去回忆这东西啊，叫result loader，Resulder，东西啊，其实刚开始是一个空的一个值，所以这东西写不写无所谓，然后写不写无所谓啊。

这第一点第二点做什么事是不是判断，然后呢当前应用程序的类型吧，是不是有这样一个类型的值，这类型里面一共包含多少个，是包含三个具体值，第一个叫none对吧，第二个叫server l，好吧。

第三个叫active reactive AC t i v e好吧，一共包含这三种最基本的情况，这块稍微注意一下好，这是第一点连过来，然后呢这是第一步你要做的一个最基本的事情，这样做完之后还有第二步工作。

想想第二步完成什么事，是不是加载，然后呢所有的初始化，初始化不用谢好吧，从哪下载的，是从我们的spring factor里面进行一个直接加加，加载啊啊这第二步你要做的事情，然后第三步该干嘛了。

是不是该加载所有的监听器，但这东西有中文翻译过来不太准确，好吧，来凑合着听到这块，OK这做完之后还有第四步操作，第四步是干嘛的，是不是找到程序，然后运行的对主类是不是在这进行执行的啊。

有一个程序的一个主类main函数，它通过一个对战的方式，依次进行向上的一个查找工作，是这块东西，好了就这个步骤要完成的事情还记得吧，这东西应该是留有一个最基本印象的啊，最基本还是一块选个颜色。

OK这是第一步，当你把这个对象初始化完成好了之后好吧，下面第二步，是不是该执行一个最基本的若方法了，这写下开始执行run方法啊，这画这些过程其实比较简单，但是你要知道。

在里面其实做了N多个最基本的一个步骤，操作吧，这里面大家想一下我做了什么样的一个事情，往下拉一下，什么样的事情还是一样，挨个码优化吧，第一步开启一个什么，是不是开启计时器吧，这个计时器啊。

我给大家写一下，大家还记得吗，我们来我们看看源码吧。

还要看下源码，不看的话，大家可能跟不上，看下，第一个是stop watch，开启这样的计时器，我把每一行代码给大家粘过来。

这是第一个步骤，你要做一个最基本的工作，这不难吧。

这第一步骤，第一步做完之后，第二步还有什么事，除了他这个东西之外，上面是不是定义一个对象，对象和建模管，第三个是配置一个headless的一个属性文件，就是第二个写一下叫配置系统属性。

java点a wt，点head list加属性值，好了，这是第二步骤，我这写一下step或者一，啊拿不过来了算了打包算了，这写一下小二啊，这这第一步骤啊，这是第二步骤，他俩合到一块了，怎么拿不出来啊。

放下吧，这可以吧，这是一这是二好吧，两个步骤就搞明白了，这是前两个步骤，他做了一个比较简单的一个事情，然后他做完之后，第三步骤该干嘛了，是不是该往里面注册，我们对一些listen的东西的。

这大家应该还记得吧，我来画一下第三步骤，求注册，加入ISTEN11listens，是不是注册了很多对应一个listener。

就在这块是不是拿过来，当然这个listener里面肯定还涉及到一个什么。

是启动的过程，把它拿过来是这些步骤，然后做完它之后，这下面包含了一个具体的启动环节，starting方法，starting进行挨个的一个匹配工作，进行一个启动，是不是这步骤当这个步骤也做完了之后。

也做完了之后在干嘛啊，在干嘛，想一下是不是该起这再写一下三三好，这第三步骤，这做完之后再往下看，是不是该启动，它刚刚写了starting，启动完了之后该准备什么了，是不是准备我们对应的一个命令行。

的一个基本参数了，好，所以再写一下第四步骤啧，都往这边画啊，这边好，第四步加载，找命令行的参数，这老师加它，同时我是不是构建出来一个新的对象，相当于是新的对象，把他过来。

我看这第四个步骤四是不是这个事情，但这个事情完成之后，注意了，这其实做的事情也算是比较多吧，好吧，你要想看的话，点到这个方法里面。

你可以看一下创建对象，然后往里面进行挨个进行一个添加的一个操作，这个东西啊，New new resource，然后读取到它对应一个值，这是不是点过了。

用了一个什么叫simple command line arguments processor，然后进行一个直接的一个解析，解完之后是不是也杠杠开头了，这东西啊，之前我都在你们点上看过了。

所以这块我们不再详细说了，再详细说了。

但是你要知道他做了一件什么事啊，这里面必须要知道他做完之后第五个步骤，丢个罩，干嘛是不是准备当前应用程序的什么呃，环境，是不是该准备我们当前应用程序的一个。

基本环境了，这是不是该准备这个环境了，这个环境里面其实也非常简单，应该做些什么事情，是不是就往里面加了一些配置，是不是创建一个对象，然后往里面加一些基本的配置，启动我们对应监听器。

在网吧里面把这个对象给返回回去对吧，那谁啊，准备硬把代码粘一下，找一下这个值。

啊这是代码准备我当前环境，这是第五个步骤五，当你当前这个环境准备好了之后，你告诉我下面你又做了啥，环境准备好之后，我在这边设置另外一个属性，就忽略某些病，不让他加入到我们的当前环境里面去吧，第六步。

麻烦叫设置系统属性，然后呢保证某些并不会添加到环境呃，我先要准备的找按键对，你说的，啊这个步骤做一下，这是我们第六个步骤要做的一个事情，这都能看懂吧，这都还记得吧，这个整体步骤应该还记得第六步骤。

然后做完之后，第七步是不是准备我们的一个打印图案，打印版的图案拿走，这么麻烦吗，直接直接画了，在准备banner的打印啊，这是我们第七个步骤，这麻烦了，怎么，算了我放弃了好吧，你知道这个步骤就行了好吧。

这是第七个步骤切入录完了之后，我们再往下看他要干嘛，是不是，开始给我们准备上下文的一个最基本环境了，是准备上下文的最基本环境，你给写一下准备，交替着写啊，准备上下文的基本环境对象，好吧。

这块你一定要记住了，记住那个最多的那个类名称，非常非常长的一个类啊，这块记住，OK这是第八步骤，这做完之后再拿走干嘛了，在干嘛，他环境准备好之后，我是不是该收集我们对这些异常报告器了，拿过来，这写一个。

假设置异常报告即对象让我来，我又把代码都补全啊，刚有的站有没粘，又把代码补全，OK这样参数值一样的，把它拿过来应该是好了，就这样的图，这图完之后一样的在干嘛，是不是准备我们当前这个环境，准备。

当前上下文，等下，拉过来准备开个环境，让大家看干嘛呢，是不是要重新刷新我们这个环境，刷新上下和环境，这标注一下叫关键操作，这种操作这关键步骤，你这一定要把它给注意了啊，一定要把记住了啊。

这是我们关键的一个操作，哎麻烦了就比较大，好了问完之后还有什么，是不是开始最后的一个刷新，图比较丑啊，来凑合看，上下文环境，上下文对象准备好，好之后，的操作默认，什么都不做好吧，方便，扩展啊。

把每个步骤步骤记住了啊，里面还有很多东西没没没往里面加，一会往里面添添添加加东西好吧，还没加东西呢，这只是把这个大致轮廓先给大家梳理一下，大家梳理一下好了，是这样的一个环境。

这玩意怎么完之后是不是计时结束好吧，计时结束，再写一下，第十结束吧，并打印是启动程序运行的时长，把这个步骤。

好了这是我们这样一个基本的步骤图，现在就是一个listener start，这里面我说了什么都没做，现在coroners也是什么都没做，这样东西跟没做都一模一样，好名字一模一样，最后还有个什么呢。

叫listen ring，让这些启动器是不是都启动起来。

监听器，找一下监听器，运行所有的监听器对象，好吧，所以你把这些基本的步骤都记住好吧，这是我还往哪加2D85，好拖过来了吧，把这块，我真的是绝了啊，这个东西第九部，几个步骤，然后往下看这个地方，第十步。

你11我，一个不值，不，重叠，等一下拖把，没事就拖吧好吧，快被整疯了，没事快快完了，T14处，我觉得我自己都想笑啊，太搞笑了好了，这些步骤前面下东西，一会儿我给你们分享完之后，我把这东西给你们补全好。

在这先写这么多，先写这么多啊，这块写完之后，就是我们整体这块的一个基本步骤，看起来好像是已经比较清晰了啊，已经比较清晰了，但是但是我说了，我要往里面加东西，加什么东西呢，首先最基本的东西你要知道好吧。

这些是什么东西，你想一下我们本身我们本身从spring property，spring factory文件里面是不是加载了很多对象的一个值，是下载很多属性值，这些属性值你拿过来之后。

其实它是通过一个什么统一的一个方法，是不是读取过来的，所以在右边这块，我希望大家做这样一件事，页面我把它放大一点，2000，好吧，我往右边加点东西，好，加点料，加什么料。

也就是说你之前在进行数据读取的时候，你到底是怎么读的啊，到底是怎么读的，想一下最开始读的是从哪读，是不是通过这两个东西，我要从某ring factory文件里面，是不是再再再再再做内容了。

所以这块拖移过来好多方打这写一下，叫根据什么叫传入的类型类名，或者就是我们的K，然后呢呃得到，需要的工厂集合的实例好吧，先把这个实例名或读过来，当你把它读过来之后，把读过之后，第二步骤在干嘛，想一想。

是不是该加载叫spring factory a AES文件内，文件中的内容，内容是不是开始读取这个文件里面内容了，我们之前所有的那些类名，几乎都是直接从这个类别里面给加载过来的，再过来的，这动完之后。

第二步骤在干嘛，先把这个文件名是不是给取到好，取到之后来获取文件中工厂啊，对应类的什么全路径，然后有钱路径之后，在干嘛，根据反射，得到具体的，的实体类对象是不是拿过来，拿实体对象之后再往下看。

然后呢叫生成，对应的对象之后，之后再返回给调用者啊，这要注意了，所以这块整体上看起来，他好像是一个独立的模块，对不对，要注意了，其实它并不是独，这里面都加加颜色，加这色吧，好看起来他好像是独立的。

但其实它并不是独立的，你想一下像这块的基本操作哪个地方用到了，第一个这块用到它吗，听懂了吧，第二个这块用它了吗，是不是用错了，都是通过什么，还记得方法名称吗，再写一下叫get啥玩意。

Spring factory o r i e s，然后呢instance吧，ANCS是通过当前这样的一个方法，把这个值给获取到了，这俩最起码这两个地方都是一模一样的啊，都是一模一样的，这块大家注意了。

把这些东西都是一模一样的，除此之外，想一下还有哪个地方用到了我们当前这个值，我在进行这类的一个初始化器的时候，它听到了吗，是不是也用到了，还是等于方法了，来再往下看，还有什么东西。

我们之前在写那个异常报告期的时候呢，这没法画了，来换一下方向，换换换方向，要不然那个图片画，拿过来，来过来，再往上挪一下，好吧，然后呢想一下刚刚那一张报告里面，我在获取具体类的属性值的时候。

是不是也是调的是这样的一个方法，是不是一模一样啊，所以这块你要知道啊，所有东西都在里面存储的，这块是不是就比较清晰了，来这块听他同学来扣个一，刚刚那个笔记会非常跟他们会不会这东西啊，全部上传的啊。

全部会上传的缩小一点，肯定会啊，我不上船，那我费劲画这个图干嘛，就为了帮助你们做一个学习嘛，好了这块画完之后，别的东西还有吗，想一下别的还有啥，别的话就是我们具体的一个细节了好吧。

涉及到细节里面的内容了，细节这块我们再接着往下画，每一个步骤里面，其实都有具体的一个细节操作对吧，这细节里面完成了哪些事情，我应该做哪些东西，我们这儿来补充一下，光画这东西没意义好吧。

如果说了你这东西你自己也能画，按照代码的顺序前后往下往下捋就行了，关键是你要知道几个最核心的一个步骤，装备步骤之后，你要知道我如何进行一些实际操作，这才是最核心的，懂我意思吧，一会下课之后。

我会把这个图再美化一下，这个图画太丑了，不太符合我的审美观啊，有对价格debug了，来再往下看，这画完之后，我们再做什么事，你还是一样想一下，刚刚我们那个群体步骤里面我会做什么事，第一个开启计时器。

其实开启计时器的东西并不是特别麻烦，好并特别麻烦，这里面你记住一个东西，哎我想下怎么链接过去，想怎么练怎么练，怎么怎么怎么练，呃这写啥，我想想这没办法，这样没法往里面画了，然后我就直接写吧。

写一下角设置，当前任务的id和启动的时间，然后呢方便后续的时候进行某些，好吧，进行某些什么进行叫计时，的操作，真的注意了，我一会把这东西再美化一下，太丑了，这个自己都受不了了，看到这两件，好了。

这是我们整体的第一个步骤，好吧，它完成了什么样的事情，这块注意就行了，跟着我的逻辑来好吧，这是第一块，它是比较简单的好吧，其实里面没有什么核心，没有什么核心代码好，非常简单的一个基本操作。

OK这做完之后来第二步该干嘛了，是不是加载我们对应命令哎，哪去了，这是第一步，第二步呢，这是第二步，第二步，好了，第二步有了之后它发生什么事，是不是就设置了一个系统的一个属性值对吧。

这个属性值意义不大好吧，可以忽略，因为这块没人去问他好吧，你大概知道是什么样的一个意思就搞定了，别东西不用在乎好了，这二块来再往下看，第三块，这是我们第三个步骤来告诉我第三步骤干嘛。

是不是就注册了一个listen的一个对象吧，说起来很容易，这东西并不是特别难，但是14怎么跑，这好，第二步骤来来看，这里面我声明了一个对应的listener对象。

但是这个listener你要知道它是怎么来的，什么东西叫event，然后呢，Publish，然后呢run listener，是不是他这个东西这写一下会贯穿，冠分开写不开，写开写不小一块，我拿过来。

写下获取一个叫event publish，然后run listener，死的对象好吧，此对象会贯穿整个，然后呢应用程序启动的过程，然后呢每次在进行，监听器，操作的时候都会从中获取具体的监听器。

是不是这个步骤好，这是我们这个步骤要做的一个事情，还要做的一个事情好吧，原装出事件发生器，对事件发生器这块记住就行了呃，调一下，好记住了，这个解释就行了，就是解释。

然后最终的时候这会有一个starting，是不是starting这个starting，这也比较关键，因为每次在进行starting这个操作的时候，其实它整体的一个处理机制，是不是也是一模一样的。

是不是也一模一样的，你告诉我这个starting他做什么事情。

我们这黑网点下看看啊，找一下12点点进去找一下，是在这块，是这有第一个呃，找这对象吧。

找这方法主要这方法，后面再再画一下，假如这怎么画对每次都重复这东西，我画到外面了，每次先听器在实际发生，我实际呃做操作的时候都会，执行叫letter si t1124点星的一个方法，好吧。

几乎每次都会执行这点新的方法，这点星可以是starting，也可以是running，也可以是各种各样的一些触发事件吧，是不是这样东西，这进进行记住了，它会调用这样的东西，当你调用当前这个方法之后。

它最终会出到哪，触发这个地方是不是这样的代码，这没问题吧，当你有了当前代码之后，有当前代码之后会干嘛，它是不是整体上还有一个总总统，统一的处理流程了，也就是说会发布不同类型的事件，别发布了会匹配。

叫匹配，不同类型的事件，然后从干嘛呢，从哪从所有的监听器中，把不符合条件的监听器给过滤掉，是不是过滤掉啊，这这个方法里面他要做的一个最基本的工作。

做完它之后来往里边看走，点，我点下试试，点一下试试，点完之后中间有一个核心处理逻辑。

符合条件的监听器会依次或者会循环执行，具体的自己的处理，逻辑通过什么来处理的，就刚刚后面我发了个代码，当然这个invoke后面的东西有点不太，不给你们画了这1vocal，剩下核心点你们下去之后自己画。

你知道有这样一套处理机制就可以了，是比如说完成一些日志化，一些初始功能对吧等等等等，相关的一些操作，这块稍微注意一下行了，跨屏好了，就这样东西大家看到了，这是我们整体这个监听器。

你在做的时候我要做的一些事情，好的，OK就这块数据环节，这记住就行了，来到目前为止，能听明白，同学扣个一能听懂吗，好了，这时候没问题，之后你发现了这个starting，它最终在调的时候。

是不是也会掉到我们这个地方算开掉吧，好吧，执行叫starting，方法是这个步骤好吧，一会我们都往这练啊，这线可能会比较乱一点，但是你凑合着看，我改一下乱没关系，我们这儿可以打成这样，就形好吧。

就这样东西好了，看完成之后，我们来再接着往下看，这启动好之后，是不是相当于做一些最基本的初始化工作了，对吧，初始化工作14，好了又跑上去了，你看这注释能把我搞疯了，我的天呐，算了，不管他了，不管他了。

不管了，来再往下看，这个第三步我们完成了，完成完了之后，我们来看第四步干嘛的，第四步其实做的事情也非常非常之简单，它其实就做了一件事，是不是，就是说我要初始化我们对应命令行的一个参数。

你最终再往里边点的过程中，你会看到一个具体的实例对象，叫simple command line，是不是一个解析器的一个东西，这样会完成我们整个参数的一个解析工作，我把这颜色给上上，换个色。

这块这样会掉到哪呢。

找一下反反反往回返，一定要足够熟练好吧，等他等他等他好了。

看完这东西，叫解析，在命令行中通过什么叫杠杠，然后呢，he等于value，输入的属性是封装。

到哪个对象记得吗，往回返。

这个项，没想到啊，把这块我get到了，他表示什么意思，一定要知道，OK这块也算个全版，第四步吧，这不难吧不难，完了之后来往下看，第五步骤改成第四步，来第五步，下一下第五步，我做什么事情。

是不是要创建我们当前这个应用程序，满足的一个准备好，一个对应的一个环境了，在环境这块你也要知道一件事，什么事呢，往后延伸，嗯都放不上去了，好了就写到这儿啊，这里面完成什么叫，准备环境的一个初始化工作吧。

在这个环境初始工作里面，其实分了最基本的几个步骤，我把这个步骤来写一下，第一个叫获取或创建一个环境。

接不着，获取，或者创建，一个环境吧，当然我们都知道，当你换创建这个环境的时候，它需要依托于谁，这怎么做啊，我想想等下把页面改大一点，诶没变化吗，有变化，好吧，这些东西都往外挪一下，好了来往下看。

这是我们整体上这一个步骤，这注意了，你是根据什么，根据，我们要根据当前应用程序的类型来做判断的，所以你想一下这个步骤，把这个步骤可以跟我们哪块东西给关联起来，还记得吗，我在完成当前这个程序初始化的时候。

这是初始化环节，在初始化是不是有一个类型的判断，所以这块其实可以勾一条线过来到这个地方，把线打一下，能看懂吗，能看懂吧好吧，根据我们这样一个参数类型，来进行一个整体的判断。

因为这会返回说你具体是什么样的一个类型，OK这没问题吧，这些能看明白吧，这是第一个，你先进行一个创建步骤，创建完成之后，第二步是干嘛，进行一个相关参数的一个配置吧，来做一下，对当前环境进行配置。

就这个属性当然配置什么东西，我这不说了，你下载之后自己可以进行一个查看，这是整体的这个细节啊，这块不走，往上走一下吧，这地盘不够啊，先放上面啊。

这个地方第三个步骤在干嘛，这个attack不用管它了吧，是不是就是配一个什么叫default properties，一个东西好，或者咖啡properties的东西，OK这又到这了。

Listener，是不是看到这个listener这块了，这个listener这块它创建一个什么东西，叫environment prepared吧，是不是相当于是一个全新的一个整体事件。

这个全新事件最终会用到谁，是不是还是贯穿到我们下面这个地方来，我这画一下，把图拿过来啊，我说了啊，这个图可能会有一些交叉，现在看的时候自己免免凑过去看一下，我把这个线给大家打过来，这块儿画一条线。

把这个环节，啊我说过了这些东西啊，都是有整体的一个关联的，不是说我想怎么做就怎么做，不是不是这样的，明白了吧，就这样一个环节来这块能看懂吧，大家读一下好了。

这样东西好了，这做完之后换做我说这东西没啥用啊，我们目前看起来还没啥用。

然后最终把我们对象返回回去，所以这里面其实就包含了这三个，最基本的一个处理，处理的一个环节，来站着听的同学扣个一，能听懂吗，还在线吗，没有，所以啊你把这些关键步骤可以做一个详细的，做一做。

大概罗列一下好吧，是这块东西好了，这块完成之后来再往下看，第六步骤，第六步哪去了，就这吧，第六步，第六步做什么事，是不是设置我们对应的一些系统属性，这就设了系统属性，所以这块其实没啥看的是吧。

那系统属性你们平常用的时候，可能也几乎没怎么用过，这句话你注意就行了，他说哪个系统属性啊，把系统属性给大家说一下哪个系统属性往回返，我们找一下劣势，All right，来来好吧，这是我们的第六步骤。

让大家看，这是我们的第七步骤，第七步，OK你是不是干嘛的，是不是准备我们banner的一个打印了，这个banner打印，banner打印其实也非常非常简单，就是说它是按照几种方式进行打印的呀。

是不是有两种方式的一个选择，那我先把这个代码给它粘过来啊，单打印别道歉，OK怎么打印的，画一下判断的时候，先判断，是否有图片是只支持，只支持什么叫JPG，然后呢GIF，然后呢PNG格式的图片。

这是第二步骤，第一步骤，这如果没有的话，如果没有的话，第二步在干嘛，是不是读取叫banner点TXT文件中的内容对吧，如果这也没有的话，第三步，叫打印的循环打印输出默认是哦logo吧。

默认的banner是不是一共就经历了这三个选项，拿过来，第一个，第二个，第三个，好吧，一共就是买东西，这样听懂吧，好默认default，对对对，就这点东西啊，很多同学能跟着我思路往里面写东西。

说明你还记得当时咱们讲课讲了点啥，还有点印象好吧，这是我们的第七步，第八步就到这了吧，第八步做什么事，如果说了，就准备上下文的一个基本对象，别别别较上下基本环境对象了，上下文，没有对象好吧。

就这个步骤要做的一个事情是第八步骤，第八周回来之后也一样，直接创建它，各位，好在创建的时候它也是一样吧，根据什么来创建的。

还记得吗，是不是还是根据我们对应一个LICATION，它的一个类型来进行创建的啊。

这要注意了啊，这样写一下，根据当前应用程序的类型，来判断创建什么格式的上下文对象，好，这块大家大家注意就行了，这块我还要再给大家写一个最写一个小提示吧，30写小提示，此处再看到上下的。

在看到创建上下文的对象之后，一定要看类图，再说吧，好在父子关系的类中，完成了很多初始化的操作，好容易忽略，还记得我说的是啥吧，大家想一下，如果你是一个application这样类型的一个参数值的话。

最终会创建一个啥来着。

还记得吗，搜一下叫ANO，Tension config service，是不是东西创建它吧，当你创建它的时候，它最终诶哪去了，找点在这里面它有一个最基本的构造方法。

是创建了一个reader和scanner的对象，有它之后，你看下它的类图，我当时在你们看了哎，我看错了，不是他，OK这类图，这图里面有一次有很多层次的一个继承关系，比如说它福利是他复利。

是他这些继承关系里面，每个里面是不是都完成很多事情，这东西啊在你们看那个呃spring源码的时候，应该有有有有机会看到啊，跟spring里面差不多，所以这块你不要忽略了，不要忽略完之后在哪呢。

在这个generate呃，写下这个类吧，在这里面啊。

这有一个非常关键的类啊，我们这儿找一下，我想给你们看一下啊，好好好，在这个类里面，它是不是也有一个对应的构造方法。

还记得吗，在这方面有个什么叫default lieb factory吧，把它拿过来，我们找一下刚刚那个类，这个类有这类之后第二个，注意这类，因为刚刚我们在看原版的ya，应该已经发现了，像刚刚说的那个类。

在后面的时候有很多地方其实都用到了，好一定要把这两个类给我记住了，它的层次关系是怎么找的，一层一层，你是怎么发现它的，一定要知道啊，这这块有一个核心，这不还有印象吗，来有印象的同学扣个一，有没有印象。

后面很多东西都都有这块东西，一定要记住他好吧，我没法再帮你们做做做做这个细化了，这里面东西太多了是吧，这块看完之后，我们还要做一个最基本的关联，从哪关联，白了点，你不能走吧，连，这块吧。

他是不是也是根据我们当前这个应用程序的一，个类型值来做一个基本判断的，好，这块大家注意了啊，两个地方都用到了我们这样一个类型判断，看完了之后来300下翻，怎么样，还有什么东西，该第六期八九该第九步了吧。

第九个是设置什么异常报告对象吗，这对象没啥可看的，就是报告我们对应程序启动过程中，它所涉及到一些异常情况，这块还是比较简单的，还是比较简单的，再来看第十步，是这样吧，是不是准备当前上下文的一个环境对象。

这块东西可能稍微麻烦一点啊，稍微麻烦点，我们依然一样往里边画对应的一个细节，现在在准备我们这个上下文环境的时候。

你需要考虑什么事，这么多吗。

叫premier context，是不是它点它点它之后，里面做了N多的一个事情嘛对吧，你想想这是干嘛用的，或者说我们只说几个比较关键的东西，就比较关键的东西，第一个是不是设置我们当前环境，这不用说了吧。

这没啥可重要的好吧，第三个叫post processor呃，叫application context，这块他做些什么事情还记得吗，判断一下你当前类到底归属于什么类型，然后呢往里边加载一下。

注册一个实例对象吧，这也没啥，这也没啥好吧，大家看第三个这东西，哦往上走一下，完了这些关键步骤啊，剩下的东西你下一周往下往里面补充啊，啊这设置初始化器进行执行啊，进行执行，而在这个执行的环节里面点进去。

那里面是不是又用到了什么叫INSULER，哎不对，这里面是不是也是一个循环过程，每次进来之后是不是都有一个循环，循环完之后，把每一个初始化器都做一个相应的执行，但你执行完之后。

能获取到对应的一个初始化的操作，好吧，这其实没啥可说的好吧，这也一样，把这些细节步骤注注注意就行了，这里面还要强调一件事，我说了后面可能会呃，可能会用到它什么东西呢，这执行完成之后，进行执行，然后呢像。

In factory，中，然后呢注入了三个叫post，cs s o r的对象好，后续在自动装配的时候会用到，为了含这些东西吧，有没有点印象了，这块东西是不是叫mate，叫catching medate。

什么东西哦，还有一个config file什么东西，应该还记得吧，我当时都都都都讲过这东西啊，做完之后在干嘛，是不是又到我们的listener了，这是不是又匹配上了第二块，好了，那这个图要指向什么地方。

这步骤是不是也指向他打一个虚线，OK他是不是也要调整整体的过程，这是一模一样的，这一模一样的，再往下看看，现在还有啥认识的输出，不用管它，注册单体并不用管它对，还有这东西，实体加载很多资源配置是吧。

自动装配，然后呢在此环节，完成是不是这意思好吧，就这样的一个步骤，就这块这做完之后，下面还有最后一句话，是不是又是listeners，什么东西拿过来，是不是，还是我们对应监听器才完成一个基本操作了。

那这块的话也一样，也要指向这个环节，把这条线虚线是不是这东西啊，这块大家还记得吗，来到目前为止，还能听懂同学扣个一，听懵了，我来帮你，我来帮你梳理一块东西啊，好了，这没问题，之后来把它改个四，变成四。

指向发，好了，然后上下之间，好了，OK是这东西啊，破坏了，清楚了些，还要自己点一下，肯定要自己点的，你不点的话肯定肯定不行啊，准备上下文对象，把代码粘过来，OK这是第十步，来。

再往回翻看一下我们的第11步骤，这干嘛呢，刷新吧，这刷新这个东西我说了，是一个关键性的一个操作，好吧，重点在spring的时候好会讲到好，随便的时候之前看没没没看，同学下来之后自己来搜一下。

我们这不再浪费时间给你们画这个细节，细节的东西来看，第12步骤就多就多了，他，老小这块这是不是可以了哇，这块好多了好了，这写完之后，第12步干嘛了，是不是上上下文准备好之后，不方便做一些扩展交易。

就是刷新之后要做的一个基本事情对吧，这个东西没啥可说的，默认就是空的嘛，你之后如果要做扩展的话，可以把这块内容做一个整体的补充，然后第13步骤是不是计时器结束，我要往里面打印一些很多新的东西了对吧。

这做完之后，还有最后一步，是运行所有的一个监视器的一个对象是吧，然后呢进行，最后的启动执行，换个颜色，这块画完之后打开明代码，我拿过来，corona之前还少了一个步骤。

叫listener starter sn，拿尺子还准备打listen to start，第12诶，这哪个步骤，啊这还有13步骤呢，这样吧，这咋回事啊，我要被我要被这东西，我要被这东西搞死了，我不想来。

嗯我的都都混合到一块了，看到了第12步骤是after reflesh，After reflesh stop。

watch上有这个东西啊，哇start把它拿过来。

少写一个步骤，把代码粘一下，Starting，开始，渲染这条线，再点它线，是这个步骤是吧，来14过来吧，14放这可以吧，哇这是这个步骤，那下面我们再多加一个，还有什么步骤。

是不是最后一个这东西吧。

当然刚刚我也带你们看这里面的一个核心代码，其实里面几乎什么事情都没做一样啊，跟什么事情没做一样，把拿下来让方法，没错，是我不，OK拿过来之后搞定了吧好吧。

这块就是我们的一个整体的running这样的一个环节，好吧，running的话点进去看一下是不是也listen running，我们这再点一条线吧，让你把这个线再点过来。

啊这OK这一样的这条线是一条虚线，是不是整体上我们这个study是不是都是这样做的，所以你看过来之后哪错了，最左边那个是三步，没错吧，如果这个顺序有问题啊，现在自己做的调整吧，好吧，画乱了来。

我们刚才图画这么多好吧，基本上能写的一些核心的环节，我都帮你们写好了，看完这个图之后，有没有感觉稍微清晰那么一丢丢啊，有吗，这图片一会我发大家，我把那个post文件也发，大家也发家。

所以下去之后按照这样的顺序依次点一下，把依次点一下，看一下整体的一个处理环节到底做了什么事，每个东西还可以往里面细点，往里面补充什么东西，所以最好啊，呃你画一个比较深的一个像思维导图也行，画这个图也行。

好这块可以做一下这个图，我给大家说一下，其实之前我说了，我画过，但画的东西不是这样的东西，之前画过一个类似的，往这看，就这样的图，这图上写的就比较简略了吧，写的比较简略了，懂我意思吧，写的比较简略啊。

里面都是一些核心应用啊，写的比较简略啊，不是特别细节，刚刚给他画的东西是比较详细的，每个里面包含了什么样的东西，来再写一下spring boot2。2。2启动过程，分析启动过程流程，Ok。

一会我会把那个pose文件和那个图片文件，都翻到下，下周一定要自己点，那关于这块的一个启动类这块东西，我们就不再浪费时间了，在之后一定要点，OK从现在开始，我们开始讲一下自动装配相关的东西。

先讲自动装配的时候，我说过了，最终啊最终还是要回到我们这个启动过程里面，因为在启动过程的时候，其实它已经帮我们完成了，自动装配这样一个过程啊，只不过大家可能没看到之后，我们会点到细节的源码里面。

看一下它到底是怎么做的，之前你们应该看过一些自动装配东西，好吧，我来我说一下你们今天怎么看的，很多人是这样告诉大家的。

你在看这个自动装配的时候，找到当前主类，然后呢在当前主页里面等一下点这东西，然后这个东西啊，enable auto config auto呃。

configuration点进去这个东西叫out configuration，Import selector，所以你可以点一下这个类，在单元类里面完成了很多，对应初始化的一些工作，做完之后就搞定了。

这不对好吧，你应该知道什么东西，你应该知道当前这个类是什么时候下来的，为什么能加在当前这个注释类，它是什么时候找到它的，这类你要知道，所以之后我带你们看的时候，还会升到原版里面。

我们找这个类到底什么时候完成了，并对象一个注册，以及它如何进行加载的，听懂我意思吧，好在这个环节我们到时候还要再走一次，还要再走一次啊，有一部分要走一次，大部分就不重不重做了，明白我意思吗，好吧。

所以你从网上看那些自动转换原理，我不是说的不对啊，呃他讲的东西比较怎么说呢，没到那个没没没没到，那个点到那个点才对，你要告诉他这个整体的一个处理流程，行吧好了，多余的废话就不多说了。

我花这几个过程给大家捋了一下，给大家捋了一下，然后续我们再讲一下自动装配什么这些东西呃，尽量给大家讲的最最清楚的一点，当然我说了，按照我的计划，其实simple源码我们还要可能还有还有好几节课。

这一次我们讲到自动装配，讲一下那个自定义的starter，咱们就结束了呃，别东西就不跟大家说了啊，不对，大家说了才能有兴趣的同学，我们之后再详细聊后续课程的时候回答补好吧，行了，还有啥问题吗。

没问题的话，咱们今天就聊这么多，Ok，好了咱们就下课了，下课了啊，你们在家休息，我也休息了，因为上了四个小时挺累的，早点休息啊。

系列 5：P68：68、Seata源码学习引入 - 马士兵学堂 - BV1E34y1w773

各位同学们大家好啊，那么从这节课开始，我们要开始讲解theta的源码部分，我们在之前啊学习了theta的应用，包括它的一些售模式啊，包括一些他的一些高高可用的部署对吧。

包括通过NUO作为注册中心配置中心啊，包括使用dB模式等等这些吧，啊什么CA的各种事物模式，什么ATTC啊这些模式，那么在学完了这些以后啊，大家一定会产生疑问，就是说这个theta的源码。

它是怎么去实现这些功能的，那么我们还是要去强调一句话，就是theta它本身啊，80%以上的分布式事务问题，通过theta的AT模式都可以去进行解决，而且T模式也是sea主推的啊。

这么一个分布式事务解决方案。

我们可以从哪可以看到，从它的官方官方网站都可以看到。

映入眼帘的，直接就告诉你有这么几个模式，然后上来就是AT模式对吧，它主要是针对AT模式做的一些讲解，那么是这样的，各位啊，呃我们源码部分，实际上也是主要是针对AT模式进行展开啊。

这样的话把这个给大家分析清楚了，其实在你的面试中，包括在你后续的一些工作中就足够使用了，好吧，各位好好，那么这节课是一个theta的源码的学习引入，那么说白了就是我们需要去啊，对源码学习前做一些准备啊。

呃呃首先啊第一件事情嘛我们先说一下，那就是说源码的下载，那么theta的源码下载地址在这给大家提供好了，我们可以打开一下来，其实在哪就可以看到啊，在这有个下载啊，SA的官网中下载点啊。

然后在这就是对应的下载中心啊，这就是我笔记里给大家截图的位置，当前我们使用的版本是这个1。4。2，就这个版本，所以你跟这儿就可以进行下载好吧，OK这就不多说了，这个对于你们来说比较简单了啊。

OK然后再接着说一下啊，那么再去正式讲之前啊，我先多说几句呃，因为我们都知道，包括我们学习NUOINO啊等等这些吧，在学习源码的时候，我们都跟我跟大家说过一个概念。

就是尽量我们去啊静态学会静态的去阅读源码，因为你必须要去掌握这种，能够去静态阅读源码的能力啊，这样的话你再碰到一些框架的源码，包括你在工作中想去阅读源码的时候会很方便，好吧，各位啊，而且我再说一下。

再强调一下，学习源码，不要去纠结于细节啊，这个在我在讲NUO源码的时候就跟大家讲过啊，源码课程不要去纠结细节啊，比如说某些细小的逻辑啊，某些细小的一种特别特别小的小逻辑，不要去陷入其中。

这样的话你的学习会很慢，而且效率很差，我说白了你真这么学就学不下去了，好吧啊，所以我们要关注源码的，不是说这源码到底是每个细节怎么写的，而是它整体的思路是什么样，核心点在哪，对啊，所以我们去学习源码。

包括老师去讲，也是从大面去给大家去讲啊，从整体的这个设计角度去给大家讲好吧，OK啊，那么我们去下载好了这个theta以后，回到正题，下载好了theta源码以后啊。

我们只需要去通过idea啊进行打开就可以了。

我可以给大家看一下，我现在这个位置已经下好了，我这是这个OK啊，theta的源码啊，在这里啊，包括theta的所有的相关的这个项目都有啊，那么可以很明显的发现，theta其实它也是一个。

类似于NUO的这种spring boot项目对吧，那既然是spring boot项目，那就好办了对吧，这个我熟啊，OK好，那接着说。

我们再去正式去讲这个CA源码之前啊，我想带大家去回顾一下AT模式，当然不光是回顾AT模式啊，在这其中啊，啊我们还要去把AT模式，我们之前没有给大家讲到的，像写隔离，读隔离啊，这个分布式锁啊。

不是分布式锁，就是全局锁的这些概念去给大家去讲清楚，因为这个是官网提供的，这个我们当时在应用的时候，只是为了让大让大家快速上手，所以我没有去详细的去讲，包括这个写隔离啊，包括这个读隔离以及这个读音。

这个应该知道啊，包括这个位置有一个叫做全局所的概念，这个我没有跟大家说说去细说啊，只是简单提了一嘴，而这节课的话简单的去把这回顾，然后呢我们还要把这详细分析一下，好吧，OK啊，那么咱们就开始啊。

先说一下啊，我们在之前讲AT模式应用的时候啊，其实我们已经通过一个特别小的案例来啊，尝试去完成这种分布式事务的一个应用啊，尤其是T模式，那么这个我们当时讲这个demo也比较简单啊，我给大家找找那张图啊。

啊这是咱们后续要看这张图啊，那个图在哪，T模式在这，这是我们当时去讲那个T模式，当然实际上我们还通过一个案例去给大家去，分析了一下，我看那个案例还在不在啊，好像，哦执行模型saga的执行应该就是这个啊。

他就是这个啊，这二阶段提交，啊这个不是讲原理的，就是它那就是它这张图啊，我们可以再看一眼，再回顾一下我们当时讲的那个案例，是一个订单，一个库存，那么去订单发起的这种全局事务啊，或者叫做分布式事务。

全局事务，那么实际上就是它有几个角色，我们一定要清楚啊，在这其中一个是TC啊，一个是TM一个是RM RM相当于事物的参与者，TM是那个啊这个这个这个可以是一个项目，它也可以是一个这个RM啊。

它既可以是T4TM啊，也可以是RM啊，那么TM相当于这个事物的发起者，说白了就是啊，那么TC就是那个socket server啊，不是socket server，去了那个theta server啊。

说错了口误啊，Sea server，那这个概念的话，如果各位还不是很清楚的话，一定要把它区分清楚啊，在SA的官网的术语这个位置啊，TC是什么啊，事务协调者对吧，TM是什么事务管理器。

他们负责的是开启全局事务，提交或者回滚全局事务啊，那么RM的话就是资源管理器，那么说白了就是事物的参与者，OK好了，最后说一遍，不再说了，那么我们之前那个案例就是说白了通过订单啊，这个位置去。

首先啊开启选举事务对吧，然后呢，他这个位置会注册相关自己的一些，开启全局事务以后，那么他会去调用我的啊库存去减库存，订单这个位置生成订单库存这个位置去减库存，这其中会必然产生分布式事务问题。

那么我们的解决方案是通过AT模式啊，在呃订单调取这个库存的时候开启全局事务啊，然后呢呃首先全局事务中的这种什么事务，参与者去进行单独执行，本地事务或者叫分支事务。

同时要记录undo log和redo log，也就是执行前的数据和执行后的数据，记录在这个undo log这个表中啊，这是一个快照，可以理解为啊，那么记录他的一个前进向和后镜像。

这个前镜像就是之前的数据和，更改之后的数据啊，叫后镜像，OK把这个数据记录完以后，那么如果当前都没有问题啊，比如说订单也增加了，库存也减少了，OK没有产生分布式数问题，那好全局提交。

OK这是之前正常思路，但如果一旦出现问题，那么就会进行回滚啊，回滚的话可能就是具体的某一个分支事务，进行回滚，比如说库存减一的时候没有减成功，那好他就通过之前所记录的undo log，来进行一个回滚。

一个补偿型的回滚啊，这是补偿性事物对吧，OK这是我们之前讲的概念，那么这个都比较简单啊，我也不用多说，简单说两句你们就能懂了，那么在这其中啊，涉及到点东西什么东西，AT模式我们都知道是一个基于2PC。

就是二阶段提交，这么演变过来的这么一个协议对吧，那么在这其中其实还涉及到一些问题，就是写隔离和读隔离的问题，看官网上包括我笔记中有啊，笔记中有在这写个离和读个离，我们先看官网，好吧啊，在官网这个位置啊。

他告诉大家说这个整体阶段一阶段，二阶段不多说了啊，OK那么写隔离是什么，毒隔离又是什么，这两点我给大家说清楚，首先写个例，我们看概念，说一阶段本地事务提交前，需要先确保拿到全局所。

拿不到全局所不能提交本地事务，那么拿全局所的啊，拿全局所的尝试被限制在一定范围内，超出范围则放弃并回滚本地事务，释放本地所，什么意思呢，这个东西我们可以通过一个案例，来给大家去说清楚啊。

当然官方这个位置也提供了案例，而这个案例的话嗯，我觉得稍微晦涩一些，所以呢我就通过了我自己的方式啊，去给大家去画两张图，让咱能好理解一些啊，咱们先说这个血隔离，其实这个所谓的血隔离。

他其实就是去避免这种脏血的问题发生啊，脏血是什么，大家应该都知道，举个例子来说，当前假如说这个位置我有一条默认数据啊，ID为一值，是值为20啊，这是个默认数据，那么当前是两个选两个全局事务啊。

T 1t2 k，T1在开启全局事务的时候，首先第一件事情他需要去啊，也就是在一阶段的时候，他需要去拿到什么这个啊稍微放大一点，global啥玩意，全局他需要去拿到全局所，拿到全局所之后。

然后呢再进行具体的commit和ROBIKE啊，那么在这个commit和ROBIKE之前，这个全局锁是一直被TX1去掌握的啊，这是事务一去掌握的，那么只有整个这个全局，事务一在执行之后才会释放本地锁啊。

不是释放全局所说错了啊，释放全局所懂吗，那么这样的话T2才能进行执行，什么意思，它为什么能防止脏写呢，其实如果说啊我们没有这个全局组的概念，假如说现在当前IDV1的值是30，那么T1在执行的时候。

当前值为30，那么TS2在执行的时候呢，他呢把这个数据加一了，变成31了啊，那么就会出现脏写，假如说T1在执行以后啊，30好，它调用服务B了啊，这时候值就是30。

但是他如果一旦出现这种问题进行回滚的时候，OK那么值会变成20，那这头现在是在你去正常执行T1事务的时候，它也可以执行去拿到这个age的值啊，去做一些事物的改变，比如说把值变成31了，那好了。

那这个时候这个值就不对了啊，就直接变成一个脏血的情况了，那么如何去防止这种情况呢，其实很简单，他在T1这个位置加了一个全局锁，加上这个全局锁的目的，就是在TS1这个全局事务执行的期间啊。

只要他没有执行完，你的T2就不能拿到这个全局锁，你依旧不能对这个age的值进行改变，所以我这写了一下，说在TS1全局事务释放全局锁之前，无法向下执行，需要等待全局锁，那也就说白了在这个位置啊。

我现在想把这个值改成31啊，但是我没有拿到全限速，所以这个位置我只能去重视他，这个重试的时候，有个细节就会释放自己的本地食物啊，然后释放之后呢，再回过来重视啊，如果还有没有还没拿到啊，再回头释放。

再重试，再回过头来重试，他会一直重试重试重试在这，直到你的TS1全局事务结束以后，那么真正的这个位置拿到了全局锁，第二个是全局事务，TS2拿到全局事务以后啊，全局全局，所以后啊，他才能去正常的去执行。

他自己对应的这么一个啊，15这是当前的写隔离，说白了就是去防止这种是吧啊，脏写的情况出现，包括我们这说完了可以看一下他的官网，哎这啊他这也说了，说他也是举个事例来说啊，分别有两个TSETS2。

然后对当前的这个IDVM啊，id为一的这个M值1000啊，进行一个更改，你看TS1开始先开启本地事务，拿到本地所，这是正常的，本地所就不用多说啊，然后更新操作变成900了，那么本地事务在提交前。

先拿到该记录的什么全局所，本地提交释放本地所，那TS2开始后啊，开启本地事务，拿到本地所，更新操作由原来的900-100变成800，在本地事务提交前，他需要先拿到全局所，也就说白了你不管这边怎么操作。

如果说你的TS大拿不到全局锁，那么他就无法执行，所以在TS1全局提交前，该记录全局所被T1直有啊，也就是说全局事务TS1它持有全局锁，那么TS2就需要重视等待全锁，你看它这个图就在这个位置呃。

获取选举所，OK获取不到怎么办，就重试重试重试等着什么时候，TS1执行完了，他释放了全局锁，他拿到了才能去执行他TS2的本地事务，去把当前的这个呃900再减100，等于800啊，这是什么情况。

OK那么如果说TS1的二阶段选举提交好看啊，TS12阶段全局提交释放全局锁啊，TS2拿到全局所提交本级事故啊，这是刚才我说的那块啊，这我说的那块，这是他正常提交的情况下，那如果说T1的二阶段是全局回滚。

则TS1需要重新获取该数据的本地所，进行反向补偿操作啊，实现分支回滚，这是我们正常的AT模式啊，它的一个操作流程，但是如果说全局锁情况下啊，就是T2在T1在全局回滚以后，TS2取必须等待该数据的清理所。

同时持有本地所，说白了就是这个意思，咱就不用看这个了，就是看着有点蒙啊，简单理解吧，不管你TS1是整体提交还是整体的去回滚，只要你的全局锁在没有释放的时候，你的TS2是无法操作的。

他只能在这个位置获取全局锁，获取不到回滚本地事务，然后再来重试，如果还拿不到回滚啊，在等着什么时候拿到全局锁，什么时候才能做，你TS2的一个全局事务的后续操作，这就是啊写隔离，他其实你看这写的说。

因为整个过程全局锁啊，在T1结束前是一直被T1持有的，那么T2就无法进行擦的操作吗，所以这样的话就会避免脏写的问题的发生啊，这就是所谓的我们AT模式的血隔离，其实就是去防止这种脏血的问题发生。

OK啊这是写个离说清楚了，OK那么还有一点就是独隔离，这个独隔离是什么呢，呃我们可以看一下啊，它这个有一个概念，就是说在数据库本地事务隔离级别啊，足以提交或以上基础，theta的AT模式。

默认全局的隔离级别是读未提交，大家可能会对这个读语提交和独立提交，这两个情况，这个隔离级别啊可能不太了解，我简单说一下吧，好吧，我们这个也是看图啊，我要把这个图都画好了，有一个独隔离，OK看这张图啊。

他这个所谓的读隔离是个什么样的意思啊，他这个我这个图跟上一个没什么区别啊，都是一样的，默认数据为20啊，然后呢你们要注意一句话的事啊，咱们先看这啊，他这句话你要注意，就是他这个位置说独隔离是说啊。

如果应用在特定场景场景下，必须需要全局足以提交这种隔离级别，那么目前theta的方式是通过这种代理，select for update语句，说白了就是加航速啊，OK那么什么叫独已提交读未提交呢。

我们来看图啊，哪去了，这个图中当前默认数据为20，然后呢TS1这个位置一样，改成30T2这个事务二啊，全局失误二啊，这个位置不是30，我就变成31好吧，我忘改了，OK好啊，他也是这么一个情况。

那么他现在什么叫读未提交呢，假如说当前T1执行事务以后，这个值变成30了啊，这个值变成30了，但是它现在是一个呃未提交状态啊，他现在是一个未提交状态，也就是说没有走到这个全局commit。

你这个时候如果是读未提交的隔离级别，当前的TS在当前这个位置，他就获取这个get的时候，它是能够读到这个30的啊啊这不是31对，他是能够读到这个30的，这是读未提交啊，也就是说白了如果是读未提交的话。

没开，当前我这头把这个数据更改为30了，但是并没有去执行全局提交的时候，我这头T2去获取这个值的值，它是可以读到这个30的，这是读未提交隔离级别啊，什么叫读已提交呢，读已提交就是指当前的T1啊。

把这个值改成30以后必须执行的commit，本地事务提交commit，真正的把这个值全部提交以后，我这头才能读到这个30，这叫做读已提交隔离级别，读未提交，就是他没有真正提交，我也能读到，读未提交。

就是他必须真正提交以后，我才能读到，就这么点区别好吧，那么这个读未提交读未提交啊，我在这给大家写了对吧，在保证在T2中能够读到TS1的H30读，已提交，是在T2中读不到数据，等待全局锁，什么意思呢。

它这其中就涉及到一个全局锁，这也是我们当前官网中给大家提供的一个概念，就是说好在这这个他代理的select for update语句，会申请全局所，如果全局所被其他事物占有，则释放本地所回滚啊，并重试。

其实跟上面那个是一样的，他这个过程中是被一个block处阻塞的，所以直到全局所达到即读取的相关数据，是已提交才返回，这说白了就是去CAT模式针对的这种说，必须做到读已提交模式的这么一个做法。

回到我们这案例中说啊，他的意思是指当前这个位置位置值为30，如果当前他是读已提交的级别啊，读已提交级别，那么在TS2这个位置，他通过这个语句去读的时候啊，他会申请拿到全局所，但是我们之前讲过。

如果当前你的全局事务一，没有完成整体操作的时候，那么这个全局锁就一直在这啊，这个锁就一直在这，那么你的T2去通过这个语句，申请全局锁的时候，由TS1持持有的全局锁，他是拿不到的，那怎么办呢。

那他就需要在这儿等回滚本地事务，并且从事，直到把这个全局锁TS1释放以后，他拿到了，他才能继续向下走，这就说白了啊，这是我们这个theta的AT模式的，读已提交模式啊，独以提交这个级别的隔离是这么做的。

但它默认记住啊，他是独立提交好吧，如果你非得做到独立提交，那就得这么做好吧，各位OK啊，这是之前没有去给大家去讲的这两个过程，所以这个位置简单去啊，不能说简单就详细把这个事给大家讲清楚了。

也就是说CAT模式的一个写隔离和读隔离啊，说白了就是去防止这种脏荼脏写脏读脏写好吧，OK那么其他的话这个位置我就不看图，不看官网了，看笔记，在笔记这个位置，我把AT的二阶段模式啊给大家去。

再详细的把流程列了一遍，那么如果你忘了的话，你可以看这个，当然啊我这个位置没有人，官网写的全，我这是摘摘抄官网的，只是我精简了一下官网的这个位置，如果你忘了是两阶段，那么AT模式的一阶段和二阶段。

在这里写的非常详细好吧，那么我在这给大家简单过一下，因为咱们都现在起码现在美貌，OK1阶段是指的说解析SQL啊，AT模式的一阶段是解析circle，得到对应的circle类型，update啊，什么语句。

说白了就是等相关信息，然后查询前进向，这个所谓的查询前进项就是第二步，就指的是改变之前的数据，假如说我们订单那个扣库存，在扣库存之前记录一个数据，就叫做前进项啊，然后根据解析得到的这种条件语句是啊。

条件信息来生成查询语句，定位数据，然后执行业务circle啊，比如说库存减一，OK那么在库存减一以后，它会生成一个后镜像，就是改变后的数据库存，真正减以后的数据叫做后定向，它是通过主线来定位数据的。

OK然后第五步啊，这还是一阶段啊，一阶段第五步会插入回滚日志，也就是说把这个ando log，说白了就是啊前后镜像以及业务业务，circle相关的信息统一啊。

成一条回滚的日志记录插入到undo log表中啊，插入到ado log表中，那么这表就是用于补偿回滚的对吧，OK啊，那么在提交前向TC注册分支，申请选举所啊，在本地事务提交之前向TC去注册分支。

而且告诉你这状态我现在要申请申请本地所，那么本地事务已经提交O申请之后，本地授经提交，那么业务数据的更新，和前面的步骤生成的analog1并提交，然后最后一阶段，最后一步就是将本地事务提交的结果啊。

上报给TC，你是成功了还是失败了，就这意思，就是说你的库存是减成功了还是减失败了，最后告诉TC，如果说你是失败了，那么就走到了二阶段的回滚，失败的时候，二阶段回滚是收到TC的分支回滚请求。

那么开启一个本地事务，执行如下操作，通过XID啊，XD是什么，知道吧，跟大家说一下这个东西，我在之前几节课跟大家聊过了，XID是指的是我们啊如何确定一些分支事务，是在我当前这一个全局分布式事务中的。

这么一个唯一的编号，说白了你这个订单本地事务和你的库存，本地事务啊，包括整个这个分布式系统的本地事务啊，不是本地事务，全局事务他们有个统一的id，就是XID，通过这个XID来确定这个全局事务中。

所包含的本地事务或者叫分支事务，然后呢这个是具体的分支事务id啊，通过XID先找到整个的全局事务，然后呢，通过具体的这个子或者叫做分支，这个这个事物的id来查询对应的这种日志记录。

然后根据这个对应的undo log，前进项进行补偿回滚，把修改之后的数据回滚回去，这是补偿回滚对吧，OK然后提交本地事务，并且把本地事务的执行结果上报给TC，就是回滚成功失败，这是回滚啊。

但如果二阶段提交的话就比较简单了，那么收到TC的分支提交请求啊，把请求放到一个异步队列中，马上返回，提交成功给TC，那么异步任务阶段分支提交请求，将异步和批量的删除相应的undo log。

也就是说你如果整整个的这个，比如说库存也减成功了，订单也没有问题，Ok，那这个时候会把相对应的，之前的所有的资源释放掉，包括安do log记录也会删除掉，这个事我们在最开始给大家演示过了。

然后最后整个的进行提交就完成了，好啊，那么这是我简单领大家去回顾了一下AT模式，以及我们之前的案例，包括源码的一些开篇啊，像源码的下载以及T模式，我们之前没有讲的多个例写个例，所以这节课就先讲到这。

这是为了我们后续讲源码做一个铺垫，下节课开始。

系列 5：P69：69、Seata源码剖析-源码入口 - 马士兵学堂 - BV1E34y1w773

好那么这节课开始，我们就开始正式的讲解theta源码啊，那这节课的话，我们先分析一下这个theta的源码入口啊，包括呃像cs的客户端启动等等一些东西吧，包括我们分析一些核心的类型啊。

嗯嗯那么我们先说一下，其实theta的客户端启动它有几个步骤啊，这几个步骤我们还是跟大家说一下啊，首先这里我说一下，就是一个theta的客户端启动，一般会分为几个流程啊。

第一就是自动加载各种bin以及配置信息啊，这个不用多说spring boot项目对吧，因为之前我就说过，你像NUOS也好，你像SA也好，它本质上就是一个spring boot项目对吧，然后第二步。

初始化TM啊，再来初始化RM就是具体的微服务啊，然后初始化分布式事务的客户端完成，那么代理数据源，而这个数据源代理这个事会回头我们再细讲啊，那么还有就是连接TC也就是theta的客户端啊。

连接TC然后注册RM注册TM然后我们之前说过啊，RMTM是可以替换的啊，因为那个我们之前讲那个AT那个例子，像那个订单和这个库存，那个订单，那个就是即使RM也是TM啊那个服务，第六步就是开启全局事务。

然后啊我这要先说一嘴啊，就是各位我们再去讲这个的时候，你们一定要去把我们之前讲过的那个案例啊，代入进来，这样的话我们会更好理解啊，在这其中啊，其实我们会涉及到几个核心的类型，就在这其中过程中。

首先我们说过，他既然是一个spring boot项目，那么spring boot项目的话，我们必然要去找谁啊，找的就是它的一个什么，找到的是spring boot项目启动的时候。

自动扫描加载类型的spring factories啊，然后呢我们找到其中的某一个类型啊，就是C它的自动的配置类啊，这样的话我们来看其中的一些核心点，那么这样吧，我呢我这是官方案例啊。

咱们这样吧，为了大家好理解，啊是吧，就在这就在这吧，我们就直接找官方案例吧好吧，这是官方啊，是那个OK在官方案例中啊，我们就找对应它引入的这个THEA包。

然后呢找它对应的这个spring boot启动加载类型啊，Spring factories，然后在这其中啊，我们来看一下啊，这个不用多解释，这个东西已经说过很多遍了啊，它自动启动的时候。

会自动扫描这个类型中的一些类型，那么你们来看啊，我为什么说，大家把之前的那个T的案例带入进来，因为我们整个的这种分布式事务的一个开启，是通过那个at哪个注解。

global transitional那个注解啊来进行开启的，所以其实这个位置是我们的一个入手的点啊，那个注解其实是我们入手的一个点，所以其实在这其中你就看呗。

那很明显只有一个global transitional auto configuration，有这么个类型，这个配置类型，所以其实这个位置就是我们主要关注的第一块，也就是源码的入口。

我们就从这分析好进来，进来以后你会发现。

这就是一个就是自动装配类对吧，其实就是说白了啊，这个这个东西如果说你之前用过XML的配置的话，其实这个跟XML配置是一样的，也是一个ban啊，包括什么其他的一些这个这个这个类型对吧，OK好啊。

所以这个位置你可以看到有一个艾特ban，那你看到艾特ban的时候，他住了一个什么叫做global transitional scanner，这个实际上是叫做全局事务扫描类啊。

所以其实我们应该从这去入手吧，啊我们就应该从这入手，为什么从这说呢，全局事务扫描类从这儿去扫描，你通过at global transitional注解所标注的对应类型，那么他从事是扫描啊。

OK所以其实我们可以看一下笔记，因为我没有办法写写注释啊，我在笔记中给大家写了一下这个类型，就是它global transitional auto configuration。

那么它就是theta的自动配置类，在这他注入了一个全局的事物扫描器，在这儿他住了一个全局事务的扫描器，然后在这其中啊。

你可以看到有个return new global transitional scanner，它是构建全局扫描器啊，包括传入参数是对应的应用名称，以及事物分组名啊，包括这种失败处理器，所以在这各位啊。

我们现在就来去看一下他。

呃这个的话我们就不通过这来看了，我们直接上源码吧，好吧，我们现在知道了，入手点在global transitional scanner啊，这个全局事务扫描器，那么我们就直接通过源码来找源码的话。

我在这里啊已经把源码给大家开起来了，OK好，那么就是他就是他global transitional scanner，那就是这个OK啊，我们来看一下这里面都干什么了啊，那么其实啊先不着急往下看啊。

我呢在这个讲源码过程中啊，给大家去做了一张图啊，我们讲到哪儿画到哪儿啊，这样的话方便大家复习，或者这个图会给大家的啊，那么可以看到我们最开始第一件事情，其实说白了就是呃。

我没有拿那个我们那个案例去解释啊，至少你们拿我们那个案例也是可以的，他通过去找到我们那个order service订单那块啊，它是TM嘛对吧，找到这个spring boot自动装配对应的一个类型。

然后找到这个艾特bin注入了全局事务扫描器，现在到这了对吧，那么在这其中我们往下来分析，在这其中你可以看到他首先继承了一个什么，Abstract，auto proceed是什么东西啊，这不用多说了吧。

这个这是a OP啊对吧，这a OP啊，我们之前NUONINO都见过OP，其实啊这个OAOP其实在我们你会发现，在我们越往后越往深学习，包括学习源码的时候，你会发现它变得越来越重要了。

很多相关的这种代理啊，都是通过a OP的形式来进行增强啊，来进行使用的，它进行动态代理对吧，OK啊，所以这个位置你可以看到全局事务扫描器，第一件事情，他继承了一个AP的对应的这么一个核心类型。

那么还有什么呢，我在这儿啊，都在这，我把这几个类型给大家列出来了，一个是监听器的一个基准接口啊，监听器因为它有一些事物事件的一些东西啊，那么包括有一个ban的初始化过程，就是引来引LAZBIN啊。

包括还有一个spring容器，这个后续我们慢慢说啊，包括有个容器销毁它，其实用到了spring容器相关的一些内容啊，这个咱们慢慢说啊，那么呃我还是说一嘴啊，我们去学源码的话。

一定要去先看整个的主流程对吧，先看整个主流程，那么这个位置我们上来有一个OP，其实我们应该从这开始入手去看一下，在这其中他做了什么，当然这里面源码有很多很多内容啊，这个咱慢慢分析，不着急啊。

然后我就大叫大家注意两点，一个是这个叫做application id，这个是服务名这个属性，还有就是一个tx service group，这是事物分组啊，这两点各位记一下好吧，我这里给大家标出来了。

那么我们可以看一眼图啊，找到这块以后，我们要分析的实际上是一个啊，这个你看我这句话把标注了at girl global transitional，注解所在类生成代理对象，并植入拦截器。

Global transitional，这个英特尔captain啊，这个东西什么意思呢，这个慢慢说啊，但是这个位置不光有他，还有一个这个呃呃ELIZENLIZBEAN啊，这个东西我们就一个个来看吧。

其实我们可以先看一下这头啊，简单来看一下这个指的是谁，指的就是他啊，那么它里面可以看啊，有这么一个方法，下载一下啊，有这么一个方法，方法可以看一下这个方法，在这他去实现了对应接口以后。

他要去实现对应方法，所以我们所以来找一下啊，在这个方法中他干了什么呢，我们来注意看啊，在这首先这个监听咱们先不着急啊，我们主要来看这位置，他调了一个叫做init client方法。

INIT初始化client是客户端是什么意思，很明显了吧，初始化客户端方法，所以在这个位置，我们就找到了一个初始化客户端方法，然后这个日志这我不看啊，咱们主要看主要流程，那么他这个位置会对应有检查。

包括检查对应的应用名称以及事物分组名，如果为空就抛异常啊，这都不用说，那么你要看这一个初始化TM和初始化RM，初始化TM是什么，不用多解释了对吧。

初始化TMOK还有一个初始化arm arm client init啊，包括application什么id，这是应用的名称，包括事物分组，应用名称，事物分组，还有一些其他的属性，那说白了在这个位置啊。

在这个global transitional c啊，这个这个这个scanner中，它有一个继承这个接口的目的，是为了去初始化你的TM和RM，这点其实符合，我们在说过那个启动流程中的几个步骤对吧。

OK但是这个位置后续我们会详细分析，现在我们就先暂且分析到这个位置，因为这好说，我先说了啊，也就是说白了他去调用对应的重写这个方法来，去初始化了客户端，初始化客户端的RM以及TM，OK这一步就完成了。

那么现在我们再回到这头啊，我们来看这这什么意思，往上翻啊，首先我们可以看一眼啊，他继承了这个AOP的这个核心类型啊，我们可以看一下，在这其中有个关键的方法，我来找一下关键方法嗯。

关键方法就是我们说的那个哎哪去了，来看一下啊，我记得是VIP什么的，在这里warp，If is if necessary，Necessnecessary，Vp，If if necessary，这个方法。

其实这个方法它就是来判断你当前所用注解，所标注的那个对象是否需要代理啊，就是那个B我们代理以后那个ban啊，我们标注注解以后那个那个类型的bean对象，它是否需要被代理，是否需要被增强。

当然这是它的一个负极写法，我们可以看一下啊，我们当前在这个全局事务扫描器中，它继承了这个类型，所以他重写了这个方法，我给你找一下啊，找一下他重写这个方法啊，在这呢OK啊，web1副necessary。

找到这个方法，我这也标注是代理增强啊，而且spring的所有的bean都会经过此方法，说白了其实就是你通过对应的那个注解，标注以后，那么他就会在这儿啊，来走他自己的这么一套模式啊。

他去继承父类方法重写之后，继承父类重写以后，重写方法以后，完成它定制化的效果，其实我们可以看一下这个方法，它的定制化效果是什么啊，首先加锁防止并发，然后你来看这检查是否是TCC模式。

check tcc啊，什么检查是否是TCC模式，是否是t cc的代理对象，说白了，这个位置，就是它根据不同模式会走一些不同的这个，对应的一些啊拦截器啊，因为你这个东西本身就是你想啊。

我们这个a OP里面就是有拦截器的对吧，这是关键点，所以这个位置不用多解释，很明显TCC模式它走了对应的是TCC的N7，所以上来他会先判断你当前啊是否是TCC模式，如果是的话，它会走对应TCC的拦截器。

但正常来说我们现在说的是AT，所以说如果不是TCC模式的话，它会判断是否有相关事物的注解啊，如果没有的话，就不代理了，那这个的话就不用很很很不用多说了，我们写的那个我们之前带入。

我们之前写的那个order订单那个和socket那个库存，那个我们在order那就去添加了对应的这个注解，所以它必然是开启啊这个全局事务的，所以他也是有注解的，那么他必然会开启相关的这什么代理对吧。

所以我们先来看啊，你看这个位置说了，说当发现存在全局事务注解admin啊，全局事务注解的be则添加拦截器，啥意思啊，哎就说白了，你这个位置他在你order订单那个位置发现对，有注解了好。

那么它就添加拦截器，而且在拦截器这个位置有这么个对象啊，global transitional啊，INTERSEPARATE这个对象这个对象啊，所以实际上后续的话，我们应该是往这个里面去深入来看一看啊。

在这里面去干了什么，当然我们先不着急往下看啊，先不着急去进到这深入啊，先往下来看它往下，还有就是说检查是否是代理对象。

也就是说当前你看a OP youtus is a p a products of pro，代理对象对吧，如果不是的话，会调用负极的这个代理，如果已经是代理对象的话，他会做一些这种集合的一些添加。

这个就不用详细去看了，我们主要还是要看哪儿的，看的是添加拦截器这个位置，要知道这个拦截器里面具体干了哪些事情，所以说到这的话，其实我们可以看一下我们这个流程啊，在这个位置我就说白了，你看这个对象。

它的作用是a OP抽象类，具有生成代理对象的功能，也就是说白了对你当前所艾滋病注解所标注的，那个类型进行增强啊，而且他后续是把标注了这个at global transitional。

注解所在内的这个代理对象啊，生成它的代理对象，并且植入到这个拦截器中，那么在拦截器中要做什么事呢，在这啊，你们要想一点，我看我这写了啊，我这写了一个说拦截器调EWORK方法。

但是去掉这个invoke方法之前怎么去触发的，是你浏览器请求触发全局事务，啥意思，我还是把之前的案例给大家开开吧，这样的话好理解，OK就是他啊，稍微等一下啊，很快好，我之前带着大家写过。

这个是应该在就是就是他啊，8001，我们之前写过一个80018002，然后呢我们现在是在8001的这个位置上，我后期改了一下，我是把它放到了这个业务层中啊，我在这儿去开启了全局事务创建订单的时候。

所以说白了我们再对照这张图，他的意思就是指通过这个AOP对象，然后呢找到你对应的这个注解，所标注的这个所在的类型，就是这个类型，然后生成一个代理对象啊，生成代理对象以后编入对应的拦截器。

然后做对应的增强，也就是说他要具体做的一些事情啊，这个增强所谓的增强就是指这个代理对象，我相信大家都玩过啊，这个所谓代理对象，就是在原有这个功能之上去加一些其他的功能，就像我们a OP一样对吧。

去做这种监听啊，环绕监听等等这东西一样的道理啊，那么怎么去触发这块呢，你看我这写了说浏览器发起请求触发全局事务，说白了，就是我们浏览器在调用这个当前订单以后，去发起创建订单的时候。

那么走到业务类型的时候啊，那么就会去触发什么呢，拦截器中其中的invoke方法，这个其实我不用给大家去试了，这个应该是比较基础的内容了啊，这个拦截器是必然会触发这个invoke方法了。

所以当我们有这个请求进来以后啊，有这个请求进来以后哪去了，这代码有点多了啊，就会走到拦截器中的in work方法，在这啊，走到拦截器中的work方法来执行对应操作，那么这里的操作是什么呢。

我们可以看一下，嗯嗯嗯首先获取执行方法啊，类型包括这有一个method获取执行方法，什么方法，就是你通过注解所标注的那个方法啊，我们那个是创建订单，他获取这个方法。

然后在这啊你们要注意看他会获取几个东西，一个是获取global transitional全局事务，还有一个就是global look什么全局所获取全局锁，这说白了就是原数据，那么这个一点就验证了。

我们之前给大家讲过那个独隔离，写隔离，其中所有的那个全局锁，而且这会写了，说这个全局所是会将本地事务执行，纳入到theta的分布式事务管理中，一起来竞争全局所，保证全局事务在执行的时候。

本地业务不可操作，全局事务中的记录张写张毒啊，就在这体现的，所以说白了我们获取到了全局事务，同时要拿到对应的全局所，拿到这以后再来往下来看，说判断啊，在这有判断说，看首先是否获取到了这个全局事务。

如果没有获取到的话，另当别论，如果获取到的就是执行全局事务啊，然后再去执行本地事务，先不着急，看这个本地事务，其实就是我们要往后分析的话，需要分析的是这个全局事务啊，分析是这个全局事务。

我们可以看图找到一个EMOKE方法，对它实际上就是解析你的这个注解，然后对应的执行全局事务，在这handler啊，global transitional啊，所以后续我们真正的核心是在这。

而且这里面的核心是在这个判断方法上，但是这块的话我们就先不往下分析了，因为现在分析的已经有点多了啊，所以回过头来的话，其实我们可以看图总结一下这节课分析的内容，就是说白了我们这个源码是从哪入手的。

把我们那个案例引入，从订单那个位置去找到对应它spring boot，自动装配的那个spring factories，找到我们对应的这个类型，Global transition。

Auto transitional auto configuration，然后找到对应它里面的一个非常核心的类型，就是全局事务扫描器，跟我们那个at global transitional。

transitional注解有关的啊，找到他在这个扫描器这个位置，比较核心的两个功能，一个是去继承了a OP相关的核心类，去做一些这种拦截器啊，环绕监听等等啊，不是环绕，就是做一些拦截器，做一些监听啊。

做一些对当前对象生成代理进行增强啊，那么还有一点就是整个的对你当前的这个病的，一个生命周期，生命周期啊，不是生命啊，生命周期啊，生命周期的管理，那么这一点的话其实没有详细分析，只是先给大家说了一下。

说白了就是初始化RM，初始化TM这一点给大家看到了，具体我们后续再分析，那么后续主要看的是，这在具有了这个a OP代理以后，那么他去重写了负极的这个方法，然后去啊生成对应的这个代理对象，然后构建拦截器。

在你去触发这种全局事务的时候，也就是controller发起请求之后，走的是invoke方法，拦截器的invoke方法解析你的全局事务注解，然后对应执行全局事务，当然对应执行全局事务具体干什么了。

我们还没有分析，这个话，我们下节课来分析，所以这节课的话我们就暂时先分析到这里，说白了就是给大家去源码开了个头，让你们知道怎么去找源码的这个入口，然后呢我们会后续慢慢根据整个的这个流程啊。

刚才我提到这个流程H1点的分析，其实这节课的话我们可以看到自动加载ban啊，这些信息包括初始化IMTM代理数据源，这个我没说，这回头再说啊，连接TC也没说啊，注册RM和注册TC注册TM这个也没说。

然后呃开启全局事务这个事儿我们看见入口了，但是我们后续会详细分析好吧，OK那么这节课的话我们就先分析到这啊，回头的话你们可以去把这个图哦，我回头把链接给你们，把这个图好好看看，跟这个图走一遍。

流程就能熟悉了，然后说一下啊，其实我们当前的这个位置，有一个global transitional scanner，这个类型是非常重要的啊，所有的基本都在这呢。

而且可以给大家看一下它的一个类关系啊，嗯嗯多说一嘴吧，哦就是他啊，这是他的相关类图啊，这他相关类图，首先它继承了哪有哪些接口啊，继承哪些类型啊，这个类型怎么回事啊，这个的话大家可以自己看一下好吧。

OK那么语法分析上来，可能大家会觉得有点空啊，老师这玩意分析的没什么意义的感觉，这个别着急啊，刚开个头。

慢慢的，我们现在只是把一些分支给大家列出来了对吧，两大分支，一个是。

AP里头的一个是这个整个的一个初始化这头的，那么后续我们会针对这两条路线再去展开分析，后续我们就会越来越清晰，好吧，各位啊。

系列 5：P7：7、JVM调优实战（上） - 马士兵学堂 - BV1E34y1w773

首先讲一点小小的概念性的东西，到底什么叫调优，我跟你说调优这个词啊，用的太烂了，所有东西都叫调优嗯，随便动点什么参数也叫调优，调这个词实际上是如果严格意义上来讲呢，它包括好几部分，什么叫调优呢。

从JVM角度，它包括三大部分，第一大部分是根据你的需求，进行这版本的规划和预调优，这是什么意思，比方说我规划之中，我要每天支撑100万的下单量好，我这时候要用什么样的机器，用多少内存。

这东西呢我们可以叫预规划，也可以叫预调用，第二个是优化运行的运行环境，比如说你现在运行环境运行特别慢，卡顿好，这个时候你需要定位到一个系统的瓶颈，来进行调优，定位一个系统瓶瓶颈呢基本上要进行压测。

要进行全链路压测，那么如果是单机的话呢，你只要通过方法进行跟踪就可以，那么如果是分布式的话，你需要用zip king呢，SKYWALKING啊，这一类的进行全链路压测，来找出来到底哪个服务特别慢。

然后再进行调优，好这块我解释的不知道大家还能不能跟得上，能跟上老师扣一英文叫ching yes，你说的太对了，英文太好了嗯，来我们继续，还有一种调优呢是面试中问特别多的。

就是解决这方面运行过程中出现的各种问题，什么问题呢，比方说memory leak，比方说om，om的全称叫out of memory，内存溢出内存报表这个意思，今天呢我用一个小例子来教大家解决这类问题。

你会用到哪些工具和它们怎么具体的使用，好好听我说，如果说调优你需要理解很多很多东西的，你需要理解怎么去设设定日子的参数，你需要理解呢，怎么啊，这个日志日志怎么去解读它，呃今天呢我给大家略过一些细节。

就像昨天我说的，希望各位小伙伴们先学最粗犷的东西，然后树干再学树枝，再慢慢去抠每一片叶子，你才会变得越来越牛，关于日志这块呢其实还是挺复杂的，每一个日志你怎么去解读它，我们暂时先略过它。

今天也用不太上用到的地方，我大概跟大家说一下，另外呢在工业生产环境之中，一个java程序应该设置什么样的参数，这块也特别重要，有一些参数很多人从书上得来的，实际人家工业环境不可能这么设。

比方说你设置日志文件就设一个，这不可能的好吗，一个日志文件你很快硬盘占满了，所以这根本不可行，必须是循环的好多个日志文件不断循环。

比方说你根本就不设heap dump on out of memory error，就是说如果说他om之后，你不把堆导出来，那你完蛋，你定位不了问题，所以这个也不行，呃这块呢我们暂时先把它略过。

作为我来说呢，我用一个具体的例子来给大家来讲，大家看这里啊，我们那有个小程序，这个小程序呢业务逻辑上我大致解释一下，这个小程序是这样一个业务逻辑，小程序来源于实际。

我们有一个小伙伴在工作之中的一个问题的，模拟JVM调优这一类问题，比较麻烦的问题在于，我很难跟你模拟真实环境，因为真实的环境很可能一个月才出一次，我给你模拟一个月，然后为了出这个问题太累了。

所以我只能用模拟的环境，用最快的速度让它fell over叫快速，so fast是吧，快速的让它展现出来它的bug之所在，所以这个小程序是模拟的，虽然是模拟的实际场景之中，它就是这样的，你好好听看。

是不是大致能理解好，这个小程序模拟了什么场景呢，这个场景是在银行体系或者是互联网金融体系，里头进行风控的这样一个模型，风控简单说我要给一个哥们放贷款，这哥们叫泊船玉，他们家有祖传的玉石，藏在柏树里头。

OK说明这哥们信誉比较高，信用额度比较高，我可以给他带100万好换，另外一个哥们，这哥们叫RIST，啊这哥们的名字起的太怪异，他的信用度很低，我只能给他带1000块钱哦，这东西怎么算出来的。

是根据每个人过去的一些信用情况，信用卡还还还还款的这种及时性啊，借了多少钱，有没有其他的债务啊，是怎么消除的，以前也没有接待过等等，有没有借债不还的好，根据这些算出来的，这叫做风险控制模型。

风险控制这个小程序就是模拟了，从数据库里面取出每一个人的个人信息，来套用一个风险控制模型来计算出来，他到底可以给不给他的贷款，或者说他的贷款额度到底给多少啊，这个背景大家听明白的，给老师扣个一。

去找找一下那个叔叔的叔，把你送出去啊，拜拜嗯嗯，好嘞我们继续啊，看大家看这里这个小程序呢，每一个人的个人信息呢，我用了一个cat effor来模拟它，只读了信用卡信息，实际当中比这复杂好多。

信用卡呢包括他的信用卡额度，包括他的名字，包括他的年龄啊，包括他的生日等等，然后我们用一个，有一个方法，他呢每次都从数据库里面读出100条数据来，读出100条数据来之后呢。

加入到我们的test list里面，加入到我们的任务列表里，我们起了一个线程池，线程池呢叫schedule spread to executor，这你学过的话，你就学过，没学过的话，大致理解就行了。

它是固定时长，固定频率的来执行任务的这样一个线程池，在这个线程池里面有50个线程，然后每隔100ms执行一次任务，在这个任务里面以固定的频率，拿出每一条数据来，每一条数据拿出来来进行计算。

大概就是这么一个模型好，这个程序呢你理解也行，不理解也可，无所谓，我现在给你把这个程序运行起来，我直接告诉你这个程序里头有毛病有bug，我举个例子稍微复杂一些，我不想举那种特别简单的。

你比如说拿一个list不断的往里扔对象，然后一会儿就内存溢出了，这个太简单了，你要跟面试官说，你说我有实际当中调优经验，面试官肯定会问你啊，你实际什么情况下需要调优，遇见什么问题呢，你跟人家说说。

有一程序员反正不是，我写了个list不断往里扔，从来不往外取，很快om了，脸书官肯定拿大嘴巴子抽你，这也太简单了，好意思拿出来说吗，可是即便是这样，确实在实际生产环境之中，真的有人犯这种错误。

由于业务逻辑混杂在其中的时候，程序就会显得特别复杂。

就有可能会产生这种错误，就没招了，但你尽量不要说这个太low，太low了，好我刚才讲这段能跟上吗，能跟上给老师扣一来，你不要太low啊。

thread local内存泄漏，那个太高大上了，我觉得你未必能cover得住，你做什么，写了thread local，它怎么产生的内存泄漏，这个你未必能cover住。

好大家看这里。

我先把这个程序跑起来，这小程序呢我加了几个参数，看看能不能认识啊，第一参数呢叫杠XM最小堆大小，第二个呢叫杠XMX叫最大对大小，print gc运行过程之中，把我们垃圾回收器的日志输出打印出来。

最后是我们的程序，这里问大家一个问题，为什么我设最小堆和最大堆设成同一个，都设200兆，最小跟最大不一般的情况下不设成一样的吗，为什么，晨晨前面没听着，太遗憾了，没关系，不耽误后面听，不用扩容没错。

防止内存抖动，既然你明确知道，我的应用程序会占到200兆内存，直接给它分配200，不要让它没事，涨来涨去啊，长一点长一点长一点，长到最大之后，如果用不着了，又往回缩，缩，完了之后又往回涨，还消耗资源。

ok get到这点之后，我们敲回车这个应用程序啊，我们的java这个进程就开始跑起来了，下面呢我开始教大家纯实战的内容，嗯排列一下嗯，好我们排列一下啊，这样我们看的会更加清楚一些呃。

我们最右边的窗口里头是我们呃，现在正在运行那个程序，这个小程序呢时间一长，它会出各种各样的问题，目前为止还没出问题，目前呢它只是展现出来了，说我产生了一次GC，这次疑似GC，这是什么意思呢。

这应该是怎么给它放到最大了。

哇。

我把这窗口呢还是，垂直排列，水平排列合并所有吧，这样我切切一切吧，让大家伙看的更加清楚一些啊。

重新运行一下这小程序，为中，回车重新运行小程序啊，这个排成三个窗口，不能把信息信息显示完全，看上去很别扭，当我们运行起来这些小程序之后呢，你会观察它的小程序呢会产生一些日志输出。

这些日志呢你看大概大概是能看明白，我稍微解释一下，这个输出日志输出的是比较粗的日志，并没有输出很详细的，如果输出很详细的，我需要跟你解释半天，还是那句话，我们先略过一些细节，大家看这里。

它产生了一次GC，GC产生的原因叫allocation failure，什么意思啊，分配失败，那意思就是说我有一块内存被占满了，好这个这个DC y DC在年轻代DC，然后这次回收产生什么效果呢。

原来我的年轻代占了54兆，接下来回收一次之后，回收成为一兆，说明回收了53兆哇，这次回收的效果很明显啊，然后我们总的GC的总的堆大小是20兆，200兆sorry，200兆时长是多少。

这块我大概说明白了吧，有没有谁在这块有疑问的，没问题吧，没问题，给老师扣一啊，嗯来我们继续，我教大家一些最基本的一些常用的命令，先作为java来说，最常用最常用的命令当然就是java是吧。

好我们下面来聊一下java的参数，java回车你会看到作为一个java命令。

它后面可以跟哪些参数，我先说第一点，就是当我们一敲java的一个命令的时候，它就会启动一个java虚拟机，以前老同学在这里头犯糊涂，说，老师我起了一个java T1，又写了一个java t2。

这是几个虚拟机啊，两个只要你敲一个java命令，就会起一个JVM，这个JVM专门给他服务，这个JVM专门给他服务，你调优的时候不能两个混在一起调啊，这件事很难很难理解吗，很容易啊，好大家看这里。

作为java来说，它本身有一堆的参数，这种以横杠开头的叫标准参数，标准参数没有多少。

看上去也并不太难理解，但是你不要忘了，这里还有一个杠X开头的，这叫什么，N standard nonstandard，非标参数非标准的。

所以你敲java杠X回车的时候，他会把非标参数全都给你列出来。

像刚x mixed，刚s interpreter，这个我在VIP课里讲过，像什么diagnostic non class DC啊等等等等，这些杠log DC这都是设置你的GC的文件的等等。

杠XMXMX我们都设过了。

好听我讲这个叫非标参数。

像这些参数都是可以用于调优的，但是真正调要用到的东西是以杠xx开头的。

但是很不幸的是，这个杠XXX开头的这些参数，它是没有一个专门的文档给你列出来，如果你想知道这些参数到底包括哪些，用这个东西，Print flags，Final，Print flash final。

叫打印所有的参数的最终值，我们后面不跟class文件名。

直接敲1conversion，我们看它有多少呢，当然你是不知道他有多少，来试一下这个杠xx开头的参数非常多。

OK大概是有这么多屏。

到底有多少呢，WC杠L回车好。

一共有728行，扣除我们这些特殊的信息，大概有700个参数左右，公会内拉知道为什么java调优比较值钱了吧，不过呢你们也不用心慌。

作为老师这么体贴的男人，肯定会告诉你到底有哪些个常用的，常用的就这么多，几十个而已，parallel常用的参数又有哪些，CMS常用的参数又有哪些，g one常用的参数又有哪些。

所以加起来呢也就几十个而已，不用担心。

比今天可以发吗，可以啊，没问题啊，皮在哪聊聊小姐姐就知道了，好我们可以继续了吗，可以继续，老师扣一来好玩啊，我跟你说，实战的东西还是比较简单又比较好玩的，太多了，我就给你700个参数里头。

我就摘了几十个出来还多，你还要怎么你还要怎么着，好，你看程序呢已经开始慢慢的在不断的产生GC了，由于它不断分配对象，所以它不断的产生GC，好下面呢我教大家一些呃常见常用的命令。

用来跟踪我们java的进程呢，到底有没有什么毛病和bug，第一个命令叫做GPS，同学们，你们呢也不用记。

作为老师这么体贴的男人，你猜我给你记下来了吗，一定是记下来了，所以不用挤了，常用的工具我都给你记下来了。

好吧好吧。

好我们先聊第一个工具，第一个命令叫做GPS，这资料可以领啊，没问题啊，第一个工具叫GPS，GPS全称叫java processes，什么意思呢，就是你给我列出来整个系统里面java的那些进程。

我们这儿有两个进程，第一个就是GPS本身，第二个是11800的T15福利，就是我们的程序就是他好，这是第一个命令，第二个命令是什么，第二个命令是JINFER，你看一眼他的名字叫java的info。

很容易就能理解这东西是个啥呢，这东西是java进程的一些相关信息。

后面当然要跟我们进程的名称11800回，这他会把11800。

这个进程相关的一些属性全都给你列出来嗯。

比如说separator是什么，比如说那个我们的java虚拟机是谁来提供的啊。

等等等等吧，其他的比如说我们的boot class。

path里面包括了哪些站文件等等等等吧，比如说我们它的默认的这种启动的参数是什么，command line的参数是什么，OK这一份这个通过这些信息呢，你可以定位一下你你的程序到底哪有问题啊。

这两个命令非常简单，我就快速过了，OK下面呢我来教大家另外一个命令，这个命令的叫j state。

this state state的嗯，statistics叫做叫做java的统计信息啊，或者叫java的数据的跟踪信息，This date，最常用的，你要跟参数，JDGGC就是跟踪他的GC的一些信息。

后面跟11800，这是什么东西呢，跟上我们的进程号，然后回车好，你会看到它会把内存里面的每一块区域，占有的大小全部给你列出来，当然这些区域呢其实它代表的什么意思，上网一搜你就知道。

但是这个东西呢读起来特别的特别的不爽，不顺啊，这东西读起来特别抽象呃，这个命令还有一个参数可以跟后面跟一个500，指的是什么呢，每500ms刷新一次，你能观察到你内存的动态的变化。

这个命令在不装我们后面，我要讲的超级的工具，之前这个东西呢完全是有用的啊，你可以用它来跟踪你内存的增长过程，你注意看这块内存它会不断的往上增长，中间这块这块从二七直到313233，当然你跟踪了之后。

你就会知道哦，原来我的程序已经在不断吃内存了，会产生这样这样的一个直观的认识，好听我说啊，就是这里面的每一个参，每一个名字代表什么，我就不给你解释了，因为后面的我会教大家，在实际当中能够用起来的。

工业级的特别棒的一个工具，阿里开源的阿尔萨斯，好吧，OK你知道人为命令就行，这些命令都是JVM自带的，JDK自带直接拿来用就行好，除了这个之外呢，我教大家另外一个命令，这个命令是什么呢。

This de clear jazz stack，这也是一个非常重要的命令，JSTACK的意思，stack叫战，这是谁来拥有来着，还有印象吗，是不是县城啊，县城才会拥有这样。

所以JDK就是用来跟踪现成的11800。

他干一件事会把11800里面所有的线程，所有的线程啊，a more吧，一瓶两瓶，三瓶四瓶，你就会看出来他会把所有的线程，线程名的线程编号，现成的优先级，操作系统级别的优先级线程的状态啊，这是现成的状态。

包括现成的调用堆栈，Stack trees，就是这个方法调了哪个方法，这个方法又掉了哪个方法，A方法调了B方法，B方法调了C方法调用栈，把这个调用栈给你打印出来，这有很重要的作用。

比如说你观察到某一个线程或者某几个线程，一直是waiting在某一个锁上面啊，这个condition看到了吗，这个线程一直是waiting on condition。

如果很多线程一直wait在某一把锁上面，那么这时候是有可能是说，你的你的程序产生了死锁，还有在面试官问问题的时候，有一个经典的问题，这个经典的问题是同学，如果你的JVMCPU爆了。

请你告诉我怎么去查这个问题，怎么追查这个问题，如果你的JVMCPU爆了，比如说你JVM90%的CPU持续居高不下，怎么查，有谁遇到过这个问题吗，面试的时候，面试官问你有遇到过吗，你看打小打小就遇到过。

因为他打小长大的向死而生，他遇到的问题比较多，Top gun hp，top gun hp呢是说你已经知道这个JVM已经占据，占据占据比较高的CPU了，他问你呢是知道你的JVM已经占据很高的CPU。

你怎么去查他呢，怎么去定位问题呢，飞火牛羊，马老师别闹，马老师什么时闹了，马老师作为中国正经老师，number one严肃课程，number one的老师怎么能闹呢，一般是某个线程在发傻。

如果一个线程在发傻，它在weight，它是不需要消耗CPU的，大哥采样分析，最后是加密算法问题小结，前两天咱们联系过是吧，好听我说，好听我说CPU标高拿什么看，其实你得去查这个线程。

它呃就是什么样的线程在占用CPU，那么这东西怎么查呢，教大家系统级的命令，所谓系统级的命令指的是听我说，所谓系统级的命令，指的是LINUX系统提供的下一个命令，top规则，当我们一条top回车的时候。

它会给我显示出来当前系统里头的哪个进程，占的CPU是多少，占的内存是多少，如果你top多观察几次的话，你就会发现它的内存会不断增长，他的CPU呢有可能是忽高忽低，这是我们程序产生的问题。

当然如果你只是观察top这个命令的话，你只能观察到某个进程占的CPU比较高，如果你想知道这个进程里面，哪个线程占的CPU比较高，小伙伴们，你得用另一个命令，这命令叫top依然是top。

但是杠hp11800回车。

他就会把你这个县城里面的，你这个进程里面的所有的线程给你列出来，然后他的CPU可以列出来，所以如果你要是玩这个的话，怎么办呢，得是这么办，得这么干，你仔细听我讲啊，就这块儿呢，如果不采用先进工具的话。

你得这么改，首先top找出来哪个进程占CPU比较高，接下来top跟hp，找出来这个进程里面哪个线程占CPU比较高，然后根据这个线程编号，用JDK对照JDK执行的结果。

JDK大家知道这会跟踪出来好多好多线程，把这个线程编号跟JDK结果对应上，看看这个县城到底是哪个，一般来说我讲到这还能跟上吗，能跟上老师扣一了可以吗，这块不难啊，就是一些思路和工具的运用。

很简单很简单啊，你放心啊，再难的问题在老师这都是很简单，So easy，看这里找到这个县城之后，需要定位这个县城有两种情况，第一种情况，这哥们是vm thread，一般就是GC垃圾回收线程。

这哥们是业务线程，那这二话不说，去看这个业务线程里调了哪些方法，是哪个方法不断的循环占CPU呢，这就是业务进程，你怎么去查，这跟业务相关，假如你定位的是GC，那么它一定是在频繁的GC不断的GC。

所以它的CPU才不会不断飙高，这时候去干嘛读GC的日志，看看日志里面是不是在频繁GC，原因是什么，有可能压力突然间爆表了，双11正好赶到12点，那那那那那一秒哗来了一大波流量报表啊，这是正常的。

你应该能撑住，撑不住的话，你扩机器还有一种内存回收，来回收去总是回收不掉，那么这种情况就是有内存泄漏，这个过程我说清楚了吗，听明白同学老师扣一了，你看他现在CPU已经占93。9%了，看到了吗。

我们看这里，当我们看这个程序的输出的时候，你会发现它已经在不断的FDC了，注意看最关键的是呢，我们来读它的这个输出信息啊，你看一眼他的输出信息呢会明确的显示出来，这哥们呢FGC的过程是这样子的。

它每次的回收内存是从20秒开始，回收198015，回收结束之后还占多少内存，198098009就回收了6K，我们总的大小198016，回收一次就回收了6K哎，这哥们儿还特别的坚持，他们也不爆啊。

内存也不报，每次就回收个6K哈哈哈，好那说明什么，说明我的内存里头一定有有人在不断的占内存，而且我回收不掉它，再说一遍，当你看到频繁FGC的时候，这个呢就叫频繁FGC，一秒钟好多次。

或者你内存比较大的时候，几秒钟一次，十几秒一次都可以认为是比较频繁，好好听我讲，频繁FGC怎么定位，这个也是面试官经常会问的，频繁FTC怎么定位，观察你频繁FGC的每次回收过程是不是正常。

比如说你这里显示的是，从每次都从200兆回收到20兆，Good，这个是正常好吗，这是normal，是正常，没毛病，不要给人家吃药，他频繁的原因，你的前端的压力太大了，他的那个负载太重了，它必须得处理。

这个很正常，但是如果是说像我这种的，每次200兆回收完还是200兆，那么你想想看他发生了什么问题啊，一定是在我的内存里头，有谁把这内存全给占住，而且呢都有引用指向，垃圾回收不掉，没问题吧，听听懂。

听懂我的意思了吗，我们可以继续吗，可以继续，老师扣一这小程序，牛叉就牛叉在他那是不断的产生毛病，他还不报哈哈，他偶尔会报，偶尔不报，就是这么个流程，clear我们再把程序跑起来，不然我没法定位呢，好了。

下面我教大家在这个小程序里面是由谁在调用，在占用我们内存，谁在占用我们内存呢，教大家另外一个命令，这个命令叫做，Come on baby，好这个命令叫做，著名的j map gmap呢。

这个命令有两大作用，第一大作用是帮我查一下堆内存里头，哪些个对象占用的情况，就是不同的类的对象占用内存的比重，占用的情况，这是第一个，第二一个呢叫产生堆转储文件，啥意思呢，什么叫堆转储文件呢。

当你怀疑这个JVM的内存里面有bug的时候，你用这个命令可以让整个的这块内存导出来，存到硬盘上，存成一个文件，然后你可以把这个文件拿出来分析，大家听明白这意思了吗，来再说一遍，这map两大作用。

我一个一个给你演示，我们先说第一大作用，j map的第一大作用，histogram生成对象，图四六，我们我们得看那个进程号是什么啊，GPS的进程号是12049，Sorry，不是11988。

说明进账号j map gun，HISTORM跟进程号11988回，它会生成什么呢。

它会当前你在正在运行的这个JVM里面，它会对你进行一个整体的分析。

从头给你分析到尾，哪种类型的class里边有多少个对应的对象。

我们看脑袋就知道了。

看这里来注意看有这种类型的对象。

333个占了这么多字节，有这种类型的对象。

什么类型的叫scatter future task，还有一个叫big decimal de，还有个叫cut info，这是我刚才读代码的时候，读到过它有多少个对象呢，这个类有多少个对象呢。

11万个占了多少个字节呢，这么多个字节，然后呢他是从大到小排列，大家看懂我的意思了。

当然其实大多数的时候，我只需要观察前面的部分就行了，取取取前20行就行了啊，我不需要观察下面这些，就只有一个对象的，他一定是占不了多少内存，他不会说让我回收不掉的。

回正好从这你就能看到，这个是目前为止在我们整个的JPM里面，最占内存的那些对象就产生了，这是j map的巨大的作用，不知道大家get到没有，所以同学们你们想想，有一些东西我回收不掉。

我执行完j map之后做个对比。

比如说就拿这个big decimal的对象来说。

big decimal对象你的前面是18万个。

我又执行一次就变成20万个没回收啊，来再继续变成22万个没回收啊。

变成哈依然是22万多，23万个，不知大家观察到没有。

有一些类的对象在不断的产生，而且回收不掉。

所以会产生什么问题啊。

你是不是get到了我的内存被占用，回收不掉。

就是由这些对象引起的。

好这块还能跟上吗。

能跟上，给老师扣一，这是int数组，char数组，BT类型数组，这种的一般都比较正常，不会出大毛病，那这事是不是就简单了。

既然你知道哦，原来是我的scattered filter task。

或者是node，或者是big animal，或者更有甚者是cut info。

是由这些类的对象不断的产生，而且回收不掉造成的，那怎么办，简单你去查你的业务逻辑吗。

你去查你业务逻辑不就完了吗，很简单啊。

查业务逻辑，好这作业留给大家吧。

我告诉你，我教你定位的东西超级简单。

他再难在老师这也是小菜，一碟豆芽都长一房高，他也是根菜，想咋吃咋吃，但是呢真正在业务环境里面，就算你定位到是由于CD info这个类不断产生对象，吃内存造成的，可是它的原因是什么。

你能知道你试试看我这小程序给你，你们自己去调，看看能不能把这bug给调出来，我告诉你，如果你不懂线程池完蛋，你还是调不出来，就算你懂线程池，你也未必知道问题出在哪，更何况在你实际工作环境之中。

这些毛病啊，你的业务逻辑呢是分布在很多特别复杂，代码比这个要长好多的那些文件里面，所以定位问题并不难，解决问题才是真正的难，好我们稍微的复习一下。

我今天呢给大家讲了几个常用的命令。

回顾一下，这个叫top，第2top gun hp好。

第二个叫GPS，很简单，这info列出信息来。

第三个继续啊，叫JDKJD，OK还有一个呢叫j map gmap的一个作用，把里面的每一个最常用的，最多的这些个类列出来，所以当面试官问你的时候，你就可以说了啊，我实际当中写了这么一个程序风险普查模型。

然后它产生了内存的泄漏，我们频繁频繁GC，但是回收不掉，后来我一定位，我发现了卡里info，经过我的努力，修正了袁成云的bug，搞定，听清楚了吗，嗯来跟上来老师扣个一，面试官问你当时什么情形。

你就像我这样噼里啪啦说一遍搞定，当然怎么改怎么改，你自己去自己去找，当然你这么说完呢，估计面试官会一个大嘴巴子抽上来，告诉我你生产环境之中，难道可以随便执行j map命令吗，如果你告诉面试官说。

我gm命令是在生产环境之中执行的，面试官估计就是要请你出门右转，拜拜还有为啥嘞，关键是怎么搞定的，哈德森还搁那纠结呢，怎么搞定的，是你的业务逻辑问题，大哥我今天给你讲的是JVM的调优。

你的业务逻辑出了问题，别人能知道吗，只有你自己知道，K就是说就是说这map，这个命令会产生一个很严重的后果，产生什么后果呢，我们现在内存啊就200兆，真正运行起来了之后，就中间我开始运行了。

估计就占了几十兆的时候，我就开始把它运行了，这map会让整个JVM卡死，卡死在某一个状态，Stop the world，然后把里面的对象全都输出出来，Very good，真正生产环境能让你卡死吗。

大哥懂吗，能不能，你现在双11正搁那秒杀呢，上来一个，你这map啊，连连连续掉十遍哇，卡死十次，关键人家内存还特别大，128G傻了一个GMAP命令两个小时以上，所以大哥别这么玩，别这么说。

这是一定有问题的，跟面试官聊的时候怎么说呢，我先卖个关子，你听我讲。

我先把j map的另外一个作用讲出来，还能跟上吗，不能强制停止吗，你看super king多牛那边双11正在秒杀呢，直接把电源给拔了，牛刀佩服，你猜马云会不会拿大鞭子抽你。

上次不是说办业执行吗，可以啊，没错，半夜执行是一种说法啊，这个没问题啊，就是你是在半夜的时候执行的，可是半夜执行他万一不是FDC特别频繁呢，是吧嗯嗯总而言之呢，要说的你要跟面试官聊，这些一定是要聊的。

系列 5：P70：70、Seata源码分析-2PC核心源码解读 - 马士兵学堂 - BV1E34y1w773

OK各位，那么咱们这节课来接着学习theta的源码，相关内容呃，上节课的话，我们讲到了说这个global transitional intercaptor，这个全局事务拦截器，说一旦执行这个拦截器啊。

就会进入到其中的这个invoke方法，那么在这其中会做一些什么注解的判断呢，有注解以后会执行全局事务啊，那么其实在这儿啊。

我去给大家纠正一点啊，我们先看先复习一下吧，上节课包括上节课给大家画一些图啊，那么这个图的话后续我还会去增加一些内容，这个还有没有增加完啊，这个咱们咱们先不看这头啊，就还是看这咱们简单去复习一下。

说这个从哪开始，我们是从这个例子的角度去分析的，其实我们这节课要分析的就是，整个的这个AT模式的，2PC的这个请求的一个流程，整体流程啊，那么这个全局事务的整体流程，其实这个流程的话是一个比较关键的点。

所以我要领大家去复习一下，上节课我们也说过啊，包括我们之前一直聊说这个啊，theta它分为三个比较重要的角色，分为哪三个，还记着吧对吧，有TC啊，这个TC这个是T画的啊。

这个TC指的就是c a server对吧，我们安装那个theta server，那么他是那个最大号的对吧，他是那个服务端，或者不能说最大号，他是那个服务端啊，那当然还有客户端，客户端包含有TM还有RM。

这是他三个非常重要的概念对吧，那么TM呢是指我具体的这个事物的开启，它从这去开启全局事务，告诉TC我开启全局事务，RM是具体的事物的参与者，说白了就是具体的一个个的微服务，那么我们之前也写过对应的案例。

那么写过像order survey，Order server，包括写个order，写个stock，订单由订单去发起请求啊，干什么，创建哎订单，那么对应的叫减库存，那么这其中存在分布式是有问题。

所以现在谁去发起的这个全局事务，谁就是那个TM那么明显order server，order server啊，就是TM所以从这开始，我们找到了对应的spring boot启动的时候。

所啊这种自动配置的这个啊，自动装配的这么一个类型，叫做global transitional auto configuration，给大家找一下啊，呃我不找他了，找他了，往下走啊，这不找了。

还得看那个不用找他了，反正最后走到哪了，他其中一个非常重要的点啊，所以他会注入一些be组件，一个非常重要的bean组件，就是这个global transitional scanner，也就是他。

那么它是干什么的，它是全局事务扫描器用来扫描啊，我可以告诉大家在扫描什么，现在我可以完全告诉大家，他扫描的就是你当前啊这些啊所有的bean组件中，哪些是带什么的。

那个at transitional注解的，如果你带，那么它就会扫描到，并且添加对应的代理来进行增强啊，完成一系列的功能O所以简单复习一下吧，来看那么在这啊。

我们现在啊要知道是这个global transitional scanner，它实际上继承了abstract out to pro，啊啊啊，Abstract auto proxy creator。

那实际上这就是a OP a p的核心的一个类型，那么a OP的话干什么进行增强并动态代理对吧，包括他还有一些其他的什么什么啊，Configuration change listener。

这是一个机监听器的一个接口啊，包括什么啊，一这个这个这个这个inter alizing bean，bean初始化，包括什么application contacts of our啊，包括等等这些吧。

但实际上这三个，其实你们看到以后会发现他比较眼熟的，而这三个实际上是是什么，我可以明确的告诉大家，它其实就是spring容器啊，他其实就是spring容器，所以说白了。

我们这个当前的这个global transitional scanner啊，在最开始的时候给大家捋流程的时候，没有告诉大家，他实际上天生就自带spring容器啊，这点要知道。

那他这个位置说白了你你找到了有这个东西，它的作用就是去初始化相关的，而这个最后这个它是spring容器销毁的时候走它，所以他就有个destroy方法啊，而他的话也有一个对应方法。

就是after propertise s在所有的bean执行了配置以后，会找他会走他啊，OK首先这不就spring嘛对吧，这不用多解释，OK啊好，那么在当前这个类型中，这不是重点，重点是猜他干了什么啊。

我们都知道他继承这个abstract auto proxy client的时候，它对应有一个方法，找一下这个方法哪去了，它有一个非常重要的方法，我看一下啊，这个方法，啊算了再看吧，这完全没点着啊。

就这个方法，我把它复制一下，哦在这啊，OK在这翻过头了啊，这个非常重要的方法，也就是说白了我们只要有对应的这个AOP，它必然会执行这个方法对吧，说白了为什么是执行它呢。

就是因为你是继承了这个对应的抽象类型，你在底下就必须重写这个方法啊，这点要注意啊，必须重启这个方法，那么它就是实际的那个代理增强spring，所有的ban都会经过此方法啊，那这里会有一些锁啊。

包括去检查是否是TCC模式还是不，如果不是t cc是干什么对吧，包括这里面啊，去什么发现当前全局事务注解并栏添加拦截器，其实上节课我们就分析到这说添加拦截器对吧。

你看我这画着呢说啊这有一个global transitional啊，INTERACTOR不就在这吗，啊添加拦截器对吧啊添加拦截器，那么这个是我们这节课重点往下分析一个地方，但是咱们先不着急看它啊。

先把这捋完啊，往下来看的话，他这个位置会跑去检测，你当前是不是代理对象啊，如果不是的话，就返回负极spring调用的方法，就是负极那个调的方法，如果是的话，那么就嗯这个去添加拦截器械组合等等这些吧。

这个就比较简单了啊，这个其实不是什么重点，我就不多说了，OK那么这其中啊嗯我刚才说过了，比较重要在哪儿，在这儿啊，global transitional啊。

INTERACTOR这块是非常重要的一个地方啊，为什么说这里非常重要呢，因为啊大家要注意呃，它是怎么来的，为什么会有这个拦截器，它怎么进来的，其实我们可以看图这个拦截器啊。

它的作用就是去调用invoke方法，那这个我们都知道，拦截器会必然调用invoke方法，那么什么时候调用的，他拦截的是什么，这点要说清楚，它拦截的，实际上是在你用户请求发到这个order之前。

也就是浏览器发起全局事务的时候，它会进行拦截啊，调用引word方法先走你对应拦截器的一些流程啊，一些逻辑走完以后再走你对应的一些啊，自己的业务对吧，所以上节课实际要分析到。

这就是走的这个invoke方法啊，对吧，哎哪去了，这个invoke方法也就是说当浏览器发送请求，那么拦截器生效调用拦截器的方法，那咱们就分析一下这个方法其中干了什么啊，抱歉啊，呛着了。

那么上节课这个位置，简单跟大家说一说他干的具体一些事情，那么我要纠正一点啊，上节课我也是着急了啊，抱歉抱歉，我刚才我上节课讲到啊，我们看图啊，说这个位置说啊啊创建完订单以后。

解析对应的global transitional注解，也就是全局事务注解，解析完注解以后，如果包含注解就执行全局事务，如果不包含执行啊，不包含注解，执行的是我说的是本地事务啊，sorry抱歉，这里不对。

他不是本地事务，他是执行全局所呃，我在最开始给大家讲源码的时候，跟大家去讲过这个锁的概念，这个全局锁的概念，它是为了防止这种脏读或者脏写的发生啊，AT模式测体特意提供这么个锁对吧。

你必须就是两个事物的时候，举个例子来说啊，复习一下TX1，他必须得获得全局锁啊，那么他在执行过程中，这个全局所一直他持有，它必须全部或者commit或者rob执行完成以后。

那么T2第二个事物才能去拿到这个全局所，执行它对应的一些事物，如果当前TS1在没有执行完的时候，T2是拿不到全集所的，那么他所做的所有的本地事务，将直接什么本地回滚，然后一直在这重试重试重试重试什么。

等待拿到这个全球所OK啊，画了一张草图，简单复习一下，所以这是我们之前讲过的一个概念，那么在这实际上就已经体现出来了，在他这个源码中啊，所以这个位置实际上是使用首先去执行啊，去获取。

看有没有对应的这个注解，这不是吗，获取global transitional全局事务注解，包括这里会获取全局，这就是获取全局锁啊，这句话实际上就是获取全局锁，在获取了以后，在获取了以后啊。

执行官在获取以后，如果有这个全局事务，那么他就会执行全局事务，如果啊获取完以后有全局所，那么会对应执行全局所相关的一些处理，全局所，这里我还没有去关注，我现在关注的是全局事务，好接着往下走。

hler global transactional走，他呃在这其中啊，上节课我也忘了，所以给大家分分析，反正我接着说吧，啊，在这里面，实际上就是我们要主要分析的一个内容啊，主要分析的一个内容啊。

为什么这么说呢，这个handler global transactional，实际上这块是非常非常关键的一块内容，我们可以先看图啊，这我写的书判断完以后，Hla global transitional。

它的作用实际上是获取事务信息，以及执行全局事务啊，或记住它是获取事物信息，执行全局事务，为什么这么说，我们来看源码，走到这以后，你往下看啊，首先这块咱们先不着急看，你先往这看这是什么。

首先这个位置我可以告诉大家，咱们主要看源码，先看流程，不要去分析细节啊，他这个位置是获取你当前的事物名称啊，就是获取你当前这个方法名，如果没有的话，就是默认方法名啊。

然后他要去解析global transitional注解属性，封装为对象，那么有哪些属性呢，其实我可以告诉大家，就是我们这个嗯global transactional注解这个注解啊。

global transactional注解，它对应是有一些自己的属性的，给大家露一眼，这个给大家看一眼啊，你看什么time out time out对应的名字等等吧，一些它是有自己的一些啊属性的。

而这些属性的话说白了是有些默认值的啊，他是有些默认值的，那他需要去拿到这些默认值，去把当前这个对应对应的这个注解啊，打成一个对象，所以在这个位置看第一件事情，他还是获取超时时间，默认是60秒。

我为什么这么说呢，你看刚才咱们看到那个time out mini了，对不对，所以你看啊说呃解析global transitional注解属性，封装为对象，那在这个位置，首先第一件事情就是获取超时时间。

默认为60秒，OK可以看到怎么去获取的，time out minutes走掉的是哪对吧，那么你看它默认的是default values值是多少，这是毫秒啊，6万毫秒，你换算一下是多少秒，对不对。

OK好啊，这不多说了，然后再回来，那么道理都是一样的，那么这能获取到，剩下就好办了对吧，你看包括构建事物对象信息，他这个事物对象信息包括什么超时时间，事物的名称，你可以默认理解为方法名。

包括事物的传播啊，那么校验或占用全局锁的什么间隔等等吧，等等等等等这些东西，把这些所有的对应的注解中的信息，不管是默认的还是可以设置啊，当然这个位置可以设置啊，一般都是默认的把这些信息打包成一个对象。

构建一个对象啊，然后进行一些其他操作等等这些，然后如果出问题会执行对应执行对应的异常，这是这块位置的一个逻辑啊，它是个整体逻辑，噗噗那么说完这块以后，我们再往下看一看，下面还有啥，看看这个方法没啥了。

那么其实这个位置啊，这个位置只是去上来获取了对应的一些啊啊，这个这个这个这个事物的一个信息啊，那么这其中还有一点，获取完事务信息以后，他执行了一个全局事务，在哪去执行呢。

其实我们这其中有一个非常关键的方法，就是它我一直没提到啊，就这个方法execute方法我们可以搂一眼啊，看他干什么了啊，走狗头往上啊，在这来XQ的方法，那么这个方法他干了什么呢。

其实啊各位我们来仔细去观察这个方法上来，第一件事情获取事物信息，唉拿到对应的事物信息，然后干什么了，获取当前的事物，主要获取XID哎XRD是什么，还记得吧，全局事物的唯一标识对吗。

OK然后根据配置的不同事物传播行为，执行不同逻辑，大家可能会对这个事务传播行为有点疑惑啊，这个实际上就是spring那个事务传播行为啊，一般它默认就有这么几种啊，对吧，OK啊。

这个如果说你对这个事物传播行为不了解的话，我建议大家去看看spring源码，或者看看spring课程啊，去把spring的事务传播行为啊，这个这个搞不清楚了，好吧，这我就不多解释了。

因为这是老相当于之前老的知识点了啊，OK那么这个位置获取完对应的这个事务，传播行为以后，再往下来看还干什么了，在这如果当前没有事务事务，则创建一个新的事物，开始执行全局事务，咱先关注主要流程啊。

发生异常回滚，各个各个数据通过undo log表进行事务补偿，这是不是AT啊，这是不是T啊，对吧，OK如果没有问题好，全局提交，最后不管怎么着都要清理资源来，我问大家，这是不是就是AT模式的一个。

或者说说，或者说这个C塔比较核心的这么一个RPC，整体的事物，全局事务的执行流程啊，那说白了，我们在这儿就能看到这些整体的执行流程，这就是我们今天要分析的一个非常关键的点。

那么说白了也就是任何你的请求进来以后，他都必然会走，这就任何你的全局事务走来进来以后，他都必须要走，这获取当前事务执行一些其他的一些呃，呃咱可以大步骤啊，第一件事获取事物信息。

然后第二点说开始执行全局事务啊，第三点说发生异常回滚啊，各数据通过undo log进行事后补偿，如果没有异常，全局提交，那很明显摆着就是整个的一个事物的执行流程，全局事务执行流程对吗，当然我们可以看图。

这就是我的是标出来的，获取事故信息，开始执行全局事务，发生异常回滚，全局提交，以最后的清除资源，所以大家说白了这个方法是干啥的啊，大家说这个方法是干啥的，execute方法是干啥的。

就是真正去执行整体2PC这个阶段的，全部的核心流程，代码全在这里啊，OK那大家可能会产生一些疑问，老师这里这里有很多细节呀，包括我们最开始去讲这个复习这个AT模式，它的EPC阶段和2PC阶段的时候。

2PC咱们好理解，EPC它有很多很多的一些细节事情，那么这些事情我们就可以分析一下了，先看这头啊，我这标了一些，你可以看到上来获取当前事物，主要获取XID，然后根据什么配置的不同的事务传播行为。

执行不同逻辑，如果当前没有事务，创建一个新的事物，这套流程在哪，就在第一部里面，上来获取事物信息以后，在这儿获取当前事物，主要获取差D从这去获取的啊，你看看查D如果为now干什么，获取查D去对吧。

OK啊这我就不细往下看了啊，那么第二点说，根据配置不同的事物的传播行为，执行不同逻辑，那么这一点其实也看这吧，来咱们看看这个类型，这个类型是干啥的，for global transactional啊。

这里面有对应的一些事物的一些传播行为，这就是spring的事务事务传播行为啊，这就是spring的事务传播行为，OK这点我们也验证了，那么还有往下说这1。3，他首先啊去拿这个事物的时候。

这个T代表就是当前这个事物，代表当前这个全局事务，如果当前这个事物没有的话，那么他就要创建一个新的事物来进行执行，那么在这块就是没有创建新的好，那么这就是第一步所做的事情，那么它对应的就是这套流程。

没问题吧对吧，OK好，然后到第二步，第二步这个位置它会发生一些事情啊，什么事情呢，就是什么事情啊，往下一点来分析啊，咱们一点点来分析，首先在第二部这个位置开始执行全局事务。

那你可以先看流程上来看我这写的一个TM对TC，也就是theta server发起请求，客户端向服务端发请求，这是那个TC，这是那个TM啊，然后还有什么有一个begin方法啊，走到默认事务管理者这个位置。

通过NT通讯，唉，其实在最开始我讲这个应用的时候，跟大家说过，这个C塔塔的底层实际上用到了NT啊，它实际上最终是通过NT通讯和谁发生的沟通啊，和服务端进行了一个沟通好，那我们就看看这一步骤啊。

第二步骤OK从这开始，我们主要关注这说开始执行全局事务走进去啊，那么在这进去之前，我还要再多说一嘴啊，再多说一嘴，各位你们先看这个主流程啊，主流程第一步说获取事务信息，第二步开始执行全局事务。

第三步发生异常回滚，第四步全球事务提交。

那我想问大家，你们就猜测一下啊，咱们可以看这张图，在这在这几个步骤中啊，就看这四个步骤在这四个步骤中哪个位置，他对TC也就是sea server发起的请求，很明显，我们获取事物信息。

以及开始执行全局事务的时候，并没有真正的与TC发生相关的通信啊，其实我可以告诉大家啊，不能这么说啊，不能说倒过来说啊，就这个位置不是说没有发生真正通讯，而是说在这整个流程中啊，这其实已经发了通讯了啊。

只是在这个整个流程中啊，哪里是1PC，哪里是2PC啊，抱歉刚才我家猫一叫，我这思路被打断了一下啊，我重新说啊哈哈，在这整个阶段中，各位来想一下，在这整个阶段中，咱们先看一下前四个阶段啊。

这整个阶段中哪里是1PC，哪里是2PC，很明显，一二都属于EPC阶段，从这儿开始出现异常了，进行全局回滚，没有异常，全局提交才是真正的2PC阶段，对吧没有了吧，所以这一点各位要注意一下啊。

这一点各位要注意一下，那么最后他清除资源就不多说了，所以说白了从这我就可以看到，这就是整个2PC的一个执行的关键点，所以现在咱们就看一下第二部这个位置，它是开启开始执行全局事务。

那我们都知道我们这个啊找一块空白机构，我简单画一下啊，比如说这是我的去找他吧，这是我的那个TM对吧。

那么他最开始要发起全局事务，他是不是要跟TC也就是sea server进行通讯对吧，OK好，那么什么位置开始通讯，开启全局事务的时候，要跟TC进行通讯，那很明显。

我们是不是应该是在第二部这个位置的时候啊，跟TC去发起一个通信呢，也就是sea server去发起通信对吧，那么怎么去发起的流程，在这OK我们搂一遍好吧，找到第二步。

找到这个begin transactional走，OK那其实这个位置各位在这TC一点begin，从这去发起的对对TC发起的请求，但是各位你们要注意看一下这个位置，实际上涉及到了一个设计模式，看这方法啊。

这调的是诶，等回来啊，这啊你看啊吹before ban啊，trigger before ban和一个trigger after begin begin，嘴瓢了，可以看一下，这是个空方法。

看这个这个这也是个空方法，那么各位你们看到这想到了什么，这实际上就是一个模板模式的应用，这个相当于就是说啊他当然默认没有啊，如果你想拓展的话，你是可以通过在发起请求前干什么事，发起请求后干什么事啊。

你可以自己拓展的，这是个模板模式的应用，好吧啊，这简单提一嘴，然后我们真正要关注的就是，这个对TC发起的请求，就是TX点begin这个位置好进去看一下，当然啊它是需要有对应的什么重写的。

我们我们走的是哪一个啊，我们这个位置走的实际上就是默认的default，因为我们知道这个theta的默认的这个模式，就是AT，所以不用看别的。

直接找define global transition的状态，OK由他进行调用，我们来看自定制方法他都干什么了啊，第二步就是与TM去发起沟通这一步啊，回到这个图中，我再说一下。

就是在这这是当前的TM与TC进行沟通，发起请求的过程啊，所以咱们来看一下他真正去发起请求的过程啊，begin首先上来就有个判断，他判断你调用者当前是否是TM那你们来想一下。

如果你是第一次发起全局请求的话啊，全局事务请求的话，很明显一定得是TM发起啊，为什么这么说。

看官网看官网啊，TM是什么，还记得吗，受管理器咱不看这看这TM在这儿呢，是不是得由他先去整个发起全局事务，是不是得他发起啊对吧，你不能说我对RM发起吧，那除非他也是TM那这不太现实对吧。

所以通过咱们图中，很明显可以知道TM发起的全局事务。

所以在这调用者必然必须第一次是TM如果不是，那就直接就拜拜了啊，直接就拜拜了，好吧OK啊，所以判断是否是TM，这是第一次发起全局请求的时候，全局事务请求啊，然后往下来看。

在这个位置获取x i d transitional manager，事务管理者点begin方法，在这获取的一个XD可以看到吧，啊在这儿获取的一个查id，OK那没有问题，那我们接着往下跟啊。

走到哪走到获取超额啊，当然这个位置也是需要有调用的，那么这个位置的调用也不用想，就找default就行啊，这个default transitional manager不就是他吗。

啊transaction transactional manager找他啊，default transacti嘴瓢了，transsessional manager默认的吧，走走到这个位置。

begin来看这这个位置就很好看了对吧，对应的请求以及对应的事物名称，超时时间等等，然后把请求给他返回一个响应，那么我们往下来跟跟哪，跟这个，啊这个这个这个这个位置，那你们来看这个位置啊。

它有一个非常重要的东西，你看它通过拆开的方式去写，然后你看这TMNT什么时候client点get instance实例，send发行球，这个很明显，如果说你对NT比较熟悉的话。

各位这一看就知道这是通过NT去发的请求啊，这是通过NT去发的请求啊，没什么毛病对吧，OK那么其实这个TM这个对应的NT类，那么你可以看名字，这tm nt client它是对应的一个TM的client。

一个客户端，所以从这里发起的请求，这也不用多说什么了对吧，所以现在我们就分析清楚了啊，我们回过头来再捋一下啊。

咱不看这看图吧，我们刚才去找到了这个啊，这个这个对应的一个执行全局流程的，一个全局事务流程的一个方法，然后在这其中有几个步骤，我们看到了有获取事务信息，开始执行全局事务，发生异常回滚，或者说全局提交。

那么说白了，这个位置整个就是一个T的2PC阶段，核心核心源码对吧，核心源码，那么在这过程中，一和二这个位置是1PC，三和四是2PC2PC阶段啊，所以当前我们第一次开启全球事务的时候。

他一定是从第二步开始的，为什么由TM发起全局事务，找TC跟TC沟通，OK所以现在我们清楚知道，OK第二步这个位置是要发起全局请求的，那第一步他说获取事务信息，那怎么获取的，主要是获取了一些什么差D啊。

包括事物的一些信息来去创建，如果你没有事务要去创建新的事物，你好第二步能执行啊对吧，所以这是第一步，那第二步他要执行的时候，就需要去真正的跟TC去发起请求，发起通讯，发起连接。

那么它使用的就是begin方法啊，一层层的走default，Default，最后走net通讯，完成对TC的请求，当然只是整体流程，这是整体流程，那么具体到连接到服务端，服务端所干了什么事。

这个咱们后续分析，但这节课我们就先分析到，这起码我们这节课把这个2PC的核心源码，核心流程这个位置搞清楚了，当然大家一定会问我说，老师第三阶段这个什么全局回滚怎么回滚呢。

对undo log怎么生成的对吧，包括这个全局提交这个位置啊，这可能好理解一些，主要是这，那这个的话我们就要去通过下节课去分析了啊，这个位置还涉及到一个点，就是大家先记住一句话，我们之前说过啊。

讲差异模式的时候我也提过，包括讲AT可能我没提过啊，但讲差异的时候，我一定提过有这个数据源代理这么一个事儿啊，其实你们要想一下AT模式，我们在搂一眼AT模式，我们之前说过，他一阶段的时候，我下来看啊。

他需要解析circle，得到circle的这些数据对吧，拿到对应的前进和后镜像，那其实你想他怎么去对应，拿到前进向后倾向，说白了他需要去把原有的这个连接对象，变成一个代理对象，通过这个代理对象来完成的。

它对应的一阶段的一些操作，所以针对于数据源代理这一块儿啊。

我们要进行分析分析以后才能知道啊，这第三步他怎么进行的，整个的安do log表，这个事务补偿回滚，这表怎么出来的，数据怎么来的等等这些，所以下这节课我们先把整体流程研究透，然后下节课来研究一下这个事务。

这个事务代理去了啊，数据源代理这块好吧，各位啊，OK那么这节课就先讲到这儿，各位那么自己可以去，如果你不信邪的话，你可以去按照我这个流程自己去debug1遍，好吧，各位OK啊。

但是我建议大家最好能够通过静态阅读，代码方式把它阅读透了，这个才是能力好吧，各位好，OK那么呃咱们这节课就先到这里了，各位啊。

系列 5：P71：71、Seata源码分析-数据源代理 - 马士兵学堂 - BV1E34y1w773

OK同志们啊，那咱们这节课来继续讲解theta源码啊，那我们这几块要分析的实际上就是CA源码的，数据源代理相关内容啊，上节课的话我们分析到了说这个theta t模式。

整个的2PC或者叫两阶段的这个执行流程，这节课的话我们要分析的就是，AT模式中的另外一个关键点叫做数据源代理，首先咱们来回顾一下说AT模式的核心点在哪，AT模式有两个点，一个是说获取全局锁。

开启全局事务，另外一个点就是解析circle，并且写入undo log啊，这个用于回滚的这么一个日志快照对吧，OK那么上节课分析的很清楚，整个2PC的阶段，我们分析明白了。

它实际上就是通过这个global transitional scanner，这个类型去继承一些抽象类，包括接口，实现一些接口来对应的一些方法来解决的问题。

所以我们可以简单回顾一下啊，给大家找一下这个啊，先来看一下啊，我们都知道这个global transitional scanner，那它是一个啥，它是一个叫做全局事务扫描器啊，所有的事物都从这里开始的。

他其实简单来说就是去扫描你对应并组件上面，那个global transactional注解，然后呢你可以看这啊，它有几个比较关键的点，在这我给大家写了。

包括笔记录给大家写了啊，看下笔记本来有这么几个关键的啊，就是一个是继承了这么一个凹凸proxy creator，这么一个抽象类啊，这是a OP的对吧，包括initializing bean。

Application，context of war和这个呃disappoint able这个B啊。

那么这么几个东西实际上简单来理解吧，这个位置其实特别简单啊，这个咱们先不说，先看这个application contest awar是啥呀，这实际上就是spring嘛。

所以你通过这一点你可以很清楚的知道，就是当spring启动完成以后啊，就是会自动去调用这个类型对吧，那么会把这个application contest去交给这个B。

也就是说当前global transitional scanner，它是天然就能拿到一个spring环境的，然后对应的这个initializing bean，和这个D就这两个啊，其实也非常简单。

它其实就是一个销毁啊，一个是开启，一个是销毁，这是之前after props啊，这个这个properties啊，set这什么意思，他说白了就是去，凡是继承或者叫实现这个接口的类型。

在初始化bean的时候，那么当所有的purpose都设置完成以后，它就会执行该方法，OK那么还有就是对应的有一个销毁方法，整个生命周期完成以后会有一个销毁，销毁方法叫做destroy啊。

这个方法就是由当前的这个，当前这个就叫disapable bin这个类型来提供了，那这是什么呀，这不就是对应着你这spring的一个生命周期的一个，感觉嘛，对吧，所以啊就是凡是去继承啊。

凡是实现这个接口并且重写对应方法的，那么它就是说白了，这个接口跟这个接口是个相反的关系啊，在销毁的时候会调用这个，这是在初始化的时候会调用它，销毁的时候会调用它，所以这个比较好理解。

这里可能唯一比较复杂的就是这个类型啊，Abstract auto proxy creator，当然这个上节课我们也讲过了啊，这个就是对应的一些整个的a OP的代理啊，自我AP增强的做AOP增强的。

那么其实总结来说吧，就这global transitional scanner，他就是去扫描你当前啊，这个bean类型上面是否有那个global transactional注解，如果有。

那么他就会做进行代理增强来做一系列的操作，完成整个RPC操作，整体流程的话，在这我上节课给大家分析过了啊，这就是我们这东西从开始从哪儿去扫描的，自动装配，扫描到以后，然后干了什么啊对吧。

整个的从这开始说有业务发起请求以后啊，触发全局事务以后干了什么，全局事务的人工流程等等等等等等啊，这全部都分析过了对吧，OK这块就不详细说了啊，那么其实我们这节课要分析的是数据代理。

所以其实我们还需要去回到，这个自动装配的这个位置，那么我还是去拿我之前这个案例，来给大家举个例子啊，关一关啊，我们正常来说的话，去找这个开头啊，分析源码开头的话，他会我们会从这找去，他找了找他引入的包。

然后呢最近找他一个自动装配类型spring boot的对吧，那在这里可以看到有个叫做sat auto configuration，那么我们之前所看到的对应的那个叫做global。

Transactional scanner，是在这对吧，那么这节课我们要看的是什么呢，看的是这个叫做sa data source bean post proxy，在这儿他对数据进行了一些代理。

拿到数据源对象以后来做代理，来做一系列的操作，所以关键点在这，我们要从这儿去看起，所以说白了你要知道就是关于数据源代理，这里啊，我们是在全局事务拦截成功之后，那么他最终是一定要执行他的业务方法的。

而且我们theta是对数据源做代理的，所以SQL的解析也好，包括安DOLOG入库，这些操作全部是由数据源代理来完成的，那么这些数据源代理在哪又给大家找啊，咱们先去找这个对应类型，你可以先看一下。

咱们进来啊，进来以后你会发现在这里面啊有这么一个方法，包括在这有这么一些方法，你可以看看，先看这来看来先看这个类型啊，它首先继承了一个接啊，不能叫继承啊。

实现了一个接口叫做bean post process，这个接口相对相呃，感觉大家或者说对于你们来说应该是很熟悉了，这是什么呀，从这图中啊，尾字在这啊，也给大家去列出了，它是spring的拓展接口。

相信大家对spring没有问题的话，这个都能知道，那么所有的bean对象再去进到这里以后，都会去执行这两个方法，哪两个方法，一个是post方法和一个before方法。

那么这两个方法都是由这个接口所提供的啊，在这啊，这对吧，这两个方法很浅显，很显而易之，就是在初始化的时候啊，首先会执行什么啊，这个比如啊在什么之前，然后执行after，在什么之后对吧。

所以说我们从这开始分析，在他执行什么什么，在在他这个初始化的时候之前所做的这个事，看看before啊，before这里面其实并没有做什么操作，哦整个都在这儿啊，你看before这我没标什么对吧。

before这里并没有做什么操作，他只是说对当前的bean组件啊类型做对比，看一下是不是这个代理对象授权代理对象对吧，所以这其实并没有什么可看头的，关键点在于哪，在这方法在方法中你可以看这个判断啊。

说并当前并列并并这个对象啊，我们所有的这个bean对象，bean对象进来以后都会走这两个方法，那么走到这的时候，会判断当前你这个B是不是data source，也就是不是数据源，如果是K好看，第二头。

这不是一个与或非的那个雨吗，对吧好，第二头头是什么，这头就是说那个啊，并判断是不是代理对象类型取反了，那说白了这里的判断是不是就指你当前的对象，是不是一个数据源，这是啥玩意啊，不用管他是不是数据源对吧。

如果是数据源的话，如果是数据源的话，他是不是这个这个这个data source，这个proxy代理对象类型啊，如果不是好，那么这个位置它调用了一个方法。

Return policy data source ban，把ban传进去，这个方法做了什么，Data source process desource pro，去掉对应的方法。

把你的这个data source传入，说白了它最后返回的对象类型，不就是一个数据源代理对象吗，那也就是拿到你的ban这个这个数据源的bean，bean类型啊，对它进行一个代理。

所以其实这里我们要分析的关键点就在于，data source process啊。

要分析它，OK这些整个流程我在这在这给大家标注了。

你可以看到说有拓展接口实现两个方法，在这个方法这个位置，当data source进入到这里以后，就会被直接代理成data source proxy，OK所以其实在这我们就要去分析这个东西了。

那么分析谁啊，分析的就是这个叫做data source proxy代理对象，OK那么我们找到入口了，那么咱们现在就看源码，OK我在这给大家找一下啊，data source来定位一下。

首先啊大家先来看这儿看这儿，这个data source process啊，它存在于这个包中，你会发现啊，嗯诶不对，我看一下啊，不对不对不对，点错了啊，找他找他啊，我点错了，Sorry，找的是啊。

我这边找错了，Sorry，再找一下啊，不对劲，不是这HLER啊，不是这HLER直接找这个啊，Data source process，嘿data source process啊，OK然后我们再定位一下。

我们来看这里啊，你会发现这里不光是有这个数据源代理对象，还有connection policy，Statement process，Prepared statement policy。

首先我们都知道data source是干啥，数据源connection是什么，连接对吧，连接对象，然后statement包括prepared statement，他们都是SQL语句的执行对象。

那也就是说白了这些关于数据源代理连接对象，执行SQL语句的这些组件，他们全部都被ca进行了代理，那么为什么要被theta进行代理，代理后的目的就是为了去执行你C，它的对应的逻辑。

就是AT模式里面这些逻辑生成undo log呀，全局事务开启啊等等这些东西，执行SQL语句，解析SQL语句等等，这些全部在这里面去执行了，所以这个位置授权代理，我们应该去从哪分析呢。

就是从这个data source process开始，也是从这开始的，而且笔记中啊，我给大家记录了一些内容，不是这。

这点我都标出来了啊，然后你看啊，数据源代理是个非常重要的环节，我们知道在分布式事务运行过程中，undo log等记录资源锁定等都是用户无感知的，那这些操作实际上都在数据源代理中完成了。

这刚才说过O所以数据源代理对象他这个位置，Data source proxy，它主要分成了三个功能，而且其中有非常关键的方法，叫做引力的方法，初始化方法啊，一会儿给大家去看，咱们先看这三个功能是什么。

它实际上是为为第一点，为每个数据源标识着资源组id，就是数据源，不同的数据源有不同id啊，都不不同的资源组id啊，那么同时有一个配置，如果这个配置打开的话，会对整个的定时线程池进行更新原数据。

并且把信息缓存到本地，这个实际上就是去说白了你当前呃，比如说我们之前所做的业务订单和库存那个啊，那么他需要去拿到你对应的一些呃，表里面的数据嘛对吧，库存表的数据，包括你订单表的数据。

那么他在时时刻刻的应该没记错，是一分钟一一更新，一分钟一更新，却拿到你准确的这个数据信息缓存到本地，为什么要缓存过来呢，是因为缓存的操作要快对吧，OK啊，然后最后一点就是生成代理。

连接对象就是connection proxy，所以这个位置，我们就先来去分析它的初始化方法，INIT方法，OK那这就不看了，我们直接看代码。

音译的方法实际上是在它构造方法这个位置，调用构造方法以后，那么他这个位置会传入资源，做id完了是对应的一个data source对吧，然后在这调用的方法，OK所以咱们来看这个方法，它的前两点。

其它的前两点其实比较好理解啊，就是一个是资源组id，当前这个id覆盖id只是比较比较简单啊，然后呃通过原始的这种数据源，得到GDBC连接和数据库类型。

你看g DB c u l d d DB type数据源，数据源类型对吧，这都不用说，然后主要是我们看这个类型啊，如果配置打开会在定时啊，会定时呃，啊应该少写个字儿啊，会在。

会定时在数这个线程池不断的更新，表着原数据信息缓存到本地，什么意思啊，这个位置其实这么看不太好理解，但咱们先理解答面啊，我先跟大家说意思，这个意思其实就是说白了你在业务开启的时候，你在有业务发生的时候。

有这种数据，这种分布式事物出现以后，它会把对应相关的表的数据缓存到本地，为什么要缓存到本地呢，其原因就是在于缓存到本地以后，它的速度快，因为它在缓存中他可以去节省一些查。

因为你数据库查询这个时间是比较长的，如果你每次都查询的话，会浪费时间啊，会时间变长，所以他每次都缓存到本地，你从本地缓存拿数据去比你查肯定要快对吧，所以就这个意思啊。

其实所以所以所以说白了这个音译的方法中，只做了这三点增强，只做这三点增强。

所以这就比较好理解了，OK那么这里说完之后，我们再往下看，他第一件事情是有INIT，那么刚才说过了，还有一点就是说去创建一个连接代理对象。

那么这个所谓的连接代理对象在哪啊，你们可以注意看一下一个东西，就是他继承了一个abstract data source propose，数据连接对象啊，数学这个抽象的这么一个数学代理对象对吧。

在这其中有很多很多方法，这个咱们先不关注，其中我们要关注的点在哪啊，有一个方法，给大家找找哪去了啊，这get connection，这是什么连接，获取数据连接对吗，获取数据连接，那包括这有很多啊。

你看这也是一个，这是一个无参数，一个是有参数的，应该啊对是你看get get connection，Get connection，这是那个有那个用户名和密码的那个，所以说白了这个位置，他的第二件事情。

就是对整个的这个连接对象做了个代理，因为你可以看到他最后return new connection proxy，这也是一个连接对象的数据代理对吧，证明哪儿它是用哪啊，用的是这个咳啊。

所以说过了SA最开始我说过了，他整个球全部都是用的这个数据代理，那么你的数据源对象被代理以后，那么建立的连接也是通过啊，连接对象来这个这个代理对象来完成的，所以到这我们再来看这两点，我分析明白了对吧。

一个是说这个整个的数据源加D，然后去打开配置定时更新，然后生成连接对象，通过的是get connection这个方法来返回的，get connection connection proxy啊。

pose不是方法，是一个代理啊，这这个连接代理，所以现在这没什么可分析的，我们主要看这个连接连接代理对象又干什么了，走往下走啊，这就是那个connection proxy继承了一个abstract。

connection proxy又是个什么性类啊。

实际上在这个里面啊，我先跟大家说一下，看笔记，啊这我还提一嘴啊，就是在这个增增强里面，这三个其实就前两个比较容易，第三个是最重要的AT模式里面会自动记录，undo log和资源锁定等等。

其实都是通过这个connection policy完成的，所以其实我们主要去分析的话，就是这个connection policy分析啊，那么你们可以看一下啊，Connection py。

它继承了一个叫做abstract connection py，那么一般看到abstract，我们都知道他的工作是啊，父类封装了很多通用的工作。

而且它的父类里面还使用了prepared statement，policy和statement prose，包括还有data source prose，这一点的话，我们这有一个类图，大家可以看一下。

放大一下abstract开始，首先他这个实现这个里面，然后包括引用了对应的三个类型啊，那么现在我们主要分析的话。

就不能去分析当前它了，看的应该是这个父类，因为这里封装了一些通用方法，所以我们先来搂一眼啊，来看，那么这里大家可以看一下我为什么说啊，有这几个东西，你看data source proxy是不是用了对吧。

然后还有啊往下来看，说白了这个步骤你们可以简单这么理解啊，就是我们再去用普通的这种数据源的时候，去操作SQL语句的时候啊，我们都知道有数据源连接对象啊，数据源代理数据源对象，然后有连接对象。

有具体执行SQL语句的对象，就是statement prepared statement对吧，所以这里我们可以看到数据源有了连接对象，也有了对吧，然后现在我们要看的是。

它连接对象所定义的一些针对数据库SQL语句，操作的对应类型，可以看到这有一个statement，Create three statement，创建这个执行SQL语句的这么一个对象。

包括有防SQL注入的一个prepared statement，这里都有啊，那你们可以看到这两个方法中，比较关键的点在于哪呢，statement和prepared statement。

不管他俩是谁用的是哪一个，他最终都会返回一个prepared statement，proxy和statement policy都是数据源代理啊，不是都是这个执行对象代理，执行SQL语句对象代理。

它并不是用的原声的，原声的statement和prepared statement，所以这个位置我们要往下分析的话。

分析应该是这对吧，你看我在这给大家标出来了啊，呃所以这里我们需要关注的是prepared statement，proxy和这个statement proxy，其实这里通用逻辑啊。

就是数据源连接步骤获取连接，然后执行对象等等，这些明白了吧啊就是这样，这就是步骤是一样的，只不过每一个步骤SA他都做了代理啊，然后啊我们可以分析一下这两个方法。

先看一下这两个方法，在这两个方法中，首先statement没什么好说的，他就是获取连接对象，然后最后返回的是一个代理对象，然后呢这个里面可以看一下，它实际上就是上来先获取数据库类型。

比如说你是MYSQL或oracle，有一个模式的判断，如果当前你是T模式啊，那么就开启全局事务，当然默认走就是AT模式啊，然后会进入到if分支，那if分支这里其实就不用多说了，就是得到原数据。

然后获取表的一些主键名，然后通过它对应的一个这个prepare statement，这个方法传SQL语句和对应的一些参数就完了啊，这都是基础操作了，不多说啊，然后最终关键点资源在这啊。

他会去创建prepared statement，proxy代理啊，所以可以现在发现，不管是这个prepared statement还是statement，它都是通过代理对象来执行。

那我们就来看一下这个代理对象，它里面的一些具体执行方法啊，在这其中其实你会发现有三个比较关键的方法，就这就这仨看到result set不用做体啊，这有一个or query，Execute。

Execute，Execute，Execute update，还有一个execute方法，这三个方法实际上就是具体执行SQL语句的，三个方法，你可以可以看到啊，这里拿就是SQL语句。

拿完SQL语句以后呢，他通过这个叫做execute template，execute方法，都是这个方法，看到吗，都是这个类型对应这个方法，而这个execute template它是啥。

它实际上你可以理解为是一个这种，不同类型的一个处理器啊，他来执行不同的这种SQL语句，通过不同的代理，那么这个咱们一会分析啊，先不说它，主要是你来看一下这个当前是statement prepared。

这个代理对象，关键点在于这方法，那么其实你可以看到，不光是他啊，这两个执行逻辑差不多，你看这个prepared statement proce，他的非常关键的方法也是这三个，看到了吗啊，Execute。

Execute，query和execute update也是这三个方法，同时你会发现这里他们所使用的都是这个，Execute template，通过它来完成的来调用的。

对应的excuse方法来完成一些操作的，所以这个位置各位啊，现在应该知道关键点在于哪呢对吧，所以啊各位回到笔记中，这里我都给大家分析清楚了，这个数据连接对象啊，有对应的一个abstract。

那么实际上它实现的接口啊，我可以我可以告诉大家，它所实现的呃，这个啊它所实现的接口就是connection连接对象对吧，所以在这里面实际上就是设计了一些通用方法，只不过说你在最后执行SQL语句的时候。

你是选择这个statement还是prepared statement，并且都是代理对象执行啊，然后啊然后往下重写对应方法返回代理对象，然后执行SQL语句，通过的都是这三个方法来执行，说过了。

然后实际上是不同的SQL语句类型来执行，不同的SQL语句类型的执行模板就是谁，就这玩意儿为什么说他呢，你看这底下插入的修改的，删除的，这是我之前说过的，开启开启全局锁ect update对吧。

OK那这些我们一会儿来分析，现在我们分析到就是找到了这个数据源，代理对象，整个的入口和找到了一些关键的代理对象，那么还有一些什么生成ando log这些东西，这些东西怎么来的呢。

这些东西我们留到下节课分析，我们先把这个整体的大流程先分析出来，好吧，各位OK啊。

系列 5：P72：72、Seata源码分析-数据源代理-undoLog生成 - 马士兵学堂 - BV1E34y1w773

好了同学们啊，我们这节课来接着去分析这个theta的，数据源代理相关内容啊，那这节课的话我们就要去找一找它当前对应的，比如说你数据源代理，他怎么去生成的这些ando log相关内容啊。

OK那么先来看一下吧，啊那么在这啊，我们上节课就分析到了一个类型，叫做abstract connection policy啊，这个父类的抽象，父类的一个代理，在这其中啊。

他有对应的创建了create statement，Prepared statement，那么他最终这两个创建的类型，都是一个代理类型啊，是prepared statement proxy。

包括这个statement policy对吧，OK我们可以看上节课这个图啊，在这首先abstract重写这两个方法，重写的实际上是这个接口所对应的这两个方法，然后返回的是一个代理对象。

那么在这两个代理对象中，就对应执行SQL语句的方法啊，这也是人生的方法，我们可以看一眼来，就咱们就拿statement prepared啊，这个PROPOXY啊，说错了来举个例子。

你看这其中啊是不是有对应的，你看query update execute对吧，那其实这就是我们主要去看的对应方法对吧，它的对应所有的执行其实都是这样的，你不光是statement policy。

你包括prepared，Statement policy，它的执行方法也是这三个，这是最关键的对吧，OK那么不管是prepared还是sement statement来举例子，你看这里面。

他这最终所执行的是一个叫做execute template，点上execute方法啊，是通过这个timing的模板去调的这个execute方法，所以这是核心关键，我们就需要去看一下这个EXO的方法。

他具体做什么了，可以先看图，在这我给大家标出来了，其实这个叫做executor template，这个模板，它是根据你不同的SQL语句的类型来生成，不同的执行模板有哪些呢。

在这儿你像有update insert delete，包括还有这个seleful update是加锁的对吧，包括有个叫做ploying excel execute啊，这是执行普通的查询SQL语句。

这是原生的，包括还有一个复合的，那这里实际上我们比较关注的就是这三个update，insert和delete，所以这啊各位你们要记住，还有一点，就是实际上这个位置它应用的一个模式，叫做模板模式。

就是这是他具体生成的执行器，根据不同SQL语句类型，那么这些不同的这种执行的一个类型来说的话，他们有个共同的父类，就这个abstract dml base executor，这是那个模板模式啊。

这上节课我没提过的，从这开始是新东西对吧，所以现在我们就可以看一眼啊，首先我们先进到这个execute方法中，那return execute zk，首先核心方法就在这儿，那么这个方法上来。

首先会判断说当前有没有全局锁，而且是不是AT模式，这个不用多解释啊，再往下来说得到数据库类型，当前一定是MYSQL类型，然后注意看这个啊这个circle这个类型啊，我跟大家说一下。

你可以把它姑且理解为circle的语句解析器，那么它可以执行这个这个获得执行circle，通过它呀，还可以去获得对应的一些SQL语句的表明，相关的列名以及类型等信息，最后解析出对应的SQL表达式。

相信大家都知道，我们在讲这个AT模式的时候，说过它对应的这个什么呢，它对应的这种呃SQL语句在这个二阶段提交中，它是需要解析的，那么怎么解析的，就在这解析的啊，然后往下可以具体来看，在这啊。

比较关键的在哪，如果说这个位置啊，你看他没有找到对应合适的SQL语句解析器，那么它就会执行这个对应这个解析器，那这个解析器，实际上就是直接通过原生对象来执行，所以这个不用我多看。

主要是看else里面来看这啊，它有一个switch这么一个东西，它去判断你当前circle的类型，如果你当前是增删改查任何一项，包括这种枷锁查询等等啊，包括普通查询等等啊，那么只要任何一项。

他就会对应去生成一个执行器啊，可以看到这个insert啊，execute查询这音色插入的啊，还有update，还有delete，还有这个枷锁的，包括这种普通的默认的，默认就是普通的这种原声的执行。

OK包括最后他可以去处理多条语句，就是多语句SQL的，那么各位我们刚才为什么说它是模板模式呢，其实啊比如说我们可以看一下，你就看任何一个，比如说update这个你看啊他这个位置它的父类是谁。

abstract dml base executor啊，OK然后你再来看啊，还有什么delete，你看他是不是继承的父类一，就是这个啊，包括这个insert，这，他首先这个位置还有一个贝斯继承啊。

你看他是不是还是长，所以这个位置各位啊，要知道就是这些所有的我们关注的是这三个，insert delete啊，这个update这三个这三个对应的执行器，他们的这种父类型，不光是他们仨。

就是所有的执行器所对应的父类型。

都是那个abstract，也就从图中可以看到这个，嗯哪去了，Abstract dml base execute，他就是最大的，那有了这个模板，我们就很清楚的知道，也就是说当前我这些对应执行器里面。

所执行的语句，那么有一些共同的方法都在这个模板类型中，OK那我们就可以往下继续来看啊，当然我说的这些在我的笔记中都有体现在哪呢，给大家露一眼啊，或者你们复习好，复习啊，就在这看到吗啊那这不多说了。

然后在这啊给大家看一眼笔记中，我给大家去找一个关系图，就是当前我们整个的这块一个类型的关系图，你可以看到啊，Statement，这是最大，上面包括还有个ECUTOR。

那么你这个位置你可以看到delete update，是不是都从哪来的，base instant base呃，这个这个insert execute是不是也从这来的对吧。

OK然后这个abstract还有一个上级，就是这个base transitional execute。

所以各位要知道这个关系，那么现在我们就可以往下继续观看这个代码啊，它最终执行是在哪，是在这，那也就是说白了当前这个executor点上，execute方法，这个方法就是你具体选择，比如说是插入。

比如insert，OK咱拿他举例子，当前你语句类型为insert，那么找的就是一个insert execute，那么就是通过这个具体的插入执行器，来调它的execute方法好。

那么现在我们来找一下这个位置，调的就是负极帮八，当然啊他这个位置调的是最大的那个负极base，这个啊走看一眼，在这其中他做了什么事呢，往下看啊，在这个位置execute进来以后。

你看首先他去拿到对应的XD，这是个全局id对吧，OK然后获取XD这个位置statement proxy，我们现在不用它执行了对吧好stephen proxy。

等点上get connection proxy啊，点上BD去绑定当前的这个叉id，也就是说把这个全局事务id给他绑上，然后再来去设置全局锁，那么就证明你当前的这个全局事务加上了对吧。

这是个标识嘛对吧OK好，那么全局事务这些关键的东西加好以后，这个位置有个叫做do execute方法，这个方法就是我们比较关键的一个方法啊，可以往下继续看，但但但在这之前我跟大家说一个事儿哦。

大家一定会发现一个问题，就是如果你看过spring源码啊，你会发现什么execute啊，Do execute，包括后续我们可以看到commit有do commit，这个方式跟spring非常像。

所以我建议大家，如果说你之前没有看过源码，你最好是把spring的源码看一遍，把它理解透了以后，你再看这些源码的话，其实大同小异好吧，OK啊，那么可能说它的意思一般都代表说。

你这个execute是一些具体操作前的设置，到do这个位置是具体执行这个do，这个位置具体执行找的是谁呢，你可以看他是个抽象方法，那么当前这是个最大的分类，这个抽象方法是由谁来实现呢。

就是刚才我所说的一个模板，Abstract dm base executor，OK找的就是他，所以来看在这就是我们这个具体的执行方法，看到了吗，嗯然后在这个位置各位注意看啊。

我先给大家看图啊，到哪一步我先跟大家说啊。

到图中的哪一步啊，你看首先绑这个execute，绑定id，设计设置全局锁啊，就此方法是用来判断当前要执行的SQL语句，那么执行哪个具体的执行器啊，然后子类重写。

这个子类重写是不是我们的abstract啊，然后这我要问大家一个问题，这是关键了啊，注意看你们要知道当前我们这种啊数据库，就是MYSQL，它是自动提交事务，是自动提交，或者说我们写语句的时候是自动提交。

还是手动提交，这一点相信大家应该都知道，我们MYSQL举个例子来说，我们再写一条查询语句，或者写一条insert或update语句的时候，是不需要在我们就是我们写完，比如说写个select语句。

没开放大镜稍等啊，比如说我们写一个select语句以后啊，S e l e c t，这应该都知道吧，这是比较基础的东西，我们是不需要自己写的，Commit，我只要回车就能看见我查询结果。

比如说insert就能看到我插入的结果对吧，所以说白了从这我们应该就很清楚的知道，这也是比较基础的内容，就是MYSQL这个位置他都是自动提交的，所以你可以看当前这个具体执行的方法。

在这是不是有个return executor，auto commit true和commit force把参数传进来，那你想我们当前是自动提交，那是不是应该走的就是这个commit true。

OK所以在这我们进到这里，方法好，进到这了，那我们可以看一下到哪了，现在现在走到这自动提交这对吧，走到自动提交日了，OK那么现在我们就可以观察，在这个自动提交的这个位置，他具体做了哪些内容啊。

我们仔细来看啊，首先在这儿啊，在这之前我先说清楚，各位你要知道，我们这2PC阶段是在第一阶段与这个数据库，就不配与这个TC交互以后，那么他再去提交的时候，最开始最开始这个事物是没有直接提交的。

所以他需要做一些相关在提交前的一些准备，比如说啊啊记录信息，这些乱七八糟的东西都包括在第一阶段的时候，你本身在提交以后，你需要去得到一个具体执行结果，你去把这个结果去告诉这个TC，然后由TC来通知你。

你是具体的一个执行还是回滚的，提交还是回滚对吧，所以当前这个位置你要知道，在这儿他并没有真正的去做执行啊，去做这个这个提交，为什么这么说呢，你上来第一句话，Connection policy。

点上auto commit，我们可以看一下这个auto commit是干什么的，这个不用管它，就来这个set auto commit，你看他传了个false。

相信大家应该都知道这个set auto commit什么意思，我们可以看一下来看这这是原生的connection，原生的给的一个方法，这个方法，说白了意思不就是是否开启自动提交吗，对吧。

如果你这个位置传的是个false，那你回过来看这啊，哎回哪去啊，回到这儿啊，你看他这个位置传过来的值为false，那是不是证明，说白了把当前的自动提交模式，改为了手动提交模式，为什么这么改呢。

是因为这个位置，我们先不让他真正的去完成提交对吧，OK那么改完真正的提交模式啊，不是改完手动提交模式以后，再往下来看看，这关键点在这啊，调用手动提交方法得到分支的业务最终结果，你看这方法是什么。

executor auto啊，Commit false，那这个方法的话，你看他干了什么，也就是说在你真正去提交前，他做了一些事情，首先你看before image是不是快照的意思啊。

这个快照就是我们那个前镜像，就是执行SQL语句之前的前进向啊，就是那个undo log中所记录的那个前镜像，用于回滚的，那么还有一个after image，这是后镜像，而这句话result等于什么塞啊。

这个这个statement call back，点上这个这个这个呃iterator这个位置，我可以跟大家说啊，他就是来具体执行业务了啊，这个位置就是具体执行业务了，哎具体执行业务了，这就不用多说了吧。

啊，执行执行我们具体的业务不是业余啊，业务打错了，OK然后还有就是这一句话，就是呃prepared undo log，看到了吗，然后把before image和after image传过去。

可以看一下它是什么，他这个位置这个prepare它实际上是把它存到了，你看before哦，我看一下不是空啊，这是判断它实际上是把它存下来的，啊先不看这吧，这个回头咱们后面看，后面看不着急不到这啊。

你就记住他这个位置实际上是暂存，安卓logo是不在commit的时候再去提到数据库，他把目前的这个数据先保存下来，前进向和后镜像，我先给你保存下来，暂存好吧，OK啊那咱们接着说。

那现在我们就找到关键点了，哎什么关键点，首先在这个位置的时候，我先把它改为手动提交，然后调的是一个什么手动交方式，把前镜像和后镜像要搞出来啊，但是这个语句最终还没有真正提交呢，真正提交在哪儿。

是在这儿的，Connection proxy or commit，这是真正提交对吧，OK啊，所以说我们可以看图总结一下，在这个图中给大家画出来了，在这儿上来，比如说我们这首先啊你看啊。

这个这个这个到这都是把自动提交，这然后呢把当前的自动提交改为手动提交模式，然后这个位置他做了几件事情，就刚才咱们看的那儿啊，手动交方法，这首先生成了前镜像，然后具体执行啊，执行具体业务，然后生成后镜像。

然后暂时储存镜像，为了后续真正写入数据库，就是把你的undo log中的一些前镜像，后镜像就两个快照去写入到你的那个数据库中，所以这个最终目的是为了得到执行结果啊，得到一个执行结果。

就是说你SQL业务执行完以后，你就是那个本地的那个分支事务的执行结果，OK那么现在把这个执行结果完，完事以后再回到这，我们下来接着看，再往下看的就是这个connection policy commit。

这个connection policy commit到哪，这才是真正的去执行提交啊，这才是那个真正的去执行提交，我们可以再往下来看啊，直接进到这个拷贝的方法中，现在前进向后定向是不是找的对吧，好啊。

没关系，一会会找他车怎么写，咱们先往下看it走，然后你来看啊，进入到这个commit方法中，在这还有一个do commit，那这个就是跟spring源码的方式就非常类似了啊，如果你阅读过的话。

你应该很清楚的知道，所以很明显就直接往这里进do commit，看他干什么了，OK来看这进入到这个读卡密的方法中，首先他判断你是否存在全局事务，你看in global transactional。

他这个就是在这啊，说白了判断有没有查id，如果你插id不为空，就全局事故对吧，OK那很明显，我们现在走的就是这proxy global transactional，这个这个这个commit再往里进走好。

然后进入到这个方法，我们先来通过看一眼，进入到的是这是这个方法对吧，OK这个方法它实际上干了三个事，第一个是注册分支事务，生成分支id啊，说白了这个位置就是真正去注册分支事务了，去生成一些分支id。

然后第二点还做了一件事，就是去真正的写入这个undo log，然后最后才是执行提交，也就是告诉结果是把这个数据真正提交起来啊，OK所以咱们可以先看一下搁哪啊，第一件事情在这呢，REJECTOR走。

你看他干什么了，logo这个不知道是这个id，它代表的就是分支，然后他通过这个default result manager点get点by rejector，这个方法就是注册分支id。

注册有哪些模式相关的这个代理，以及这种资源id等等一系列的相关内容，他把当前的这个分支id给他注册进去了，OK这是注册方法好，再回来往下有一个写入数据库，写什么，把undo log真正的去写进去。

可以看核心方法在这fish and log啊，然后最后你看这执行原生提交，这不就是一阶段提交吗，对吧，你看这target这个connection是谁，就是原生的connection。

然后呢在这调了一个方法叫commit，commit是谁，原生的commit，提交方法是不是在这是真正的提交啊对吗，OK那么现在我们要关注的是数据源这一块，那么数据源他最后要写入那个analog前镜像。

后镜像，所以在这我们要关注的就是这个flash方法，Flash undo logs，走往里看看这个方法干什么了啊，当然这个位置是一个接口，还有实现类，那么对应的实现类就找到他。

在这flash undo log，我们可以通过这看一眼来，在这flash undo log，然后再往下找找哪个方法啊，首先咱们先去先看一眼，在这个方法中，你看首先干啥了，都上来string xd啊。

Connection content，获取叉id，分支id等等相关的一些信息，看到了吗，相关的一些信息，undo log set什么什么什么什么undo log，怎么着呢，是不是拿到相关信息啊。

然后这些啊拿到以后真正写入数据库的位置，在这有一个insert up啊，这个这个undo log with啊，这个方法有没有方法，那你可以看啊，超级参数，什么XDBD啊等等这些东西。

那你可以看一下这方法怎么写的啊，当然也可以看到这是个抽象方法。

它也需要具体的实现类，那你来看这仨实现类都是啥，My circle oracle，还有这个不同的对应的你的这个数据源。

你是MYSQL的类型的数据库，还是oracle的还是什么的，当然这个位置很明显，我们目前用的就是MYSQL，所以直接去找mysql undo log manager就行了。

然后你再看这个insert方法，其中调用了一个叫做insert undo log方法走，你来看这干啥了，这是不是就是最终去写入相关的那个XD，不是那个undo log，那个那个写入方法。

就真正去往数据库里写的那个范儿对吗，所以在这个位置，是不是就把相关的所有的这个undo logo中的表，中的数据写入进来了对吧，这个这个这个很熟吧，这个不能说不认识了对吧，OK好，所以分析到这里。

我们就很清楚的知道这个数据是咋回事，这个数据最终是怎么写去的，OK我们就全分析清楚了，可以看图再总结一下啊。

来这个数据这个位置我们最开始是从这过来的，然后呢绑定元素以后都这个啊，不是绑定元素，绑定XD以后进来子类重写，然后自动提交，自动提交这个位置改为手动提交，就说白了先不让他提交。

然后把对应的这个调用手动提交方法，首先生成前进项去执行具体业务，生成后进项，那么这个时候生成前进下，是为了保留这个之前的数据，执行这个具体业务就是执行你当前分支事务。

那个具体业务生成后镜像就是更改之后的数据，然后暂时去储存这个镜像啊，去为了后续真正去写入到你的数据库里面去，所以这个位置再往下再走，真正的一个提交执行，找到do commit，写入原声啊。

写入这个undo log，然后并且执行原声的提交，首先注册分支，然后通过对应的这个方法，这个fish方法来写入，写入完以后真正的去执行commit提交啊，这个时候commit提交以后。

就会有对应的结果去告诉服务端，成功还是失败对吧，然后这个位置往下怎么写入呢，走的是flag这个flash这个方法执行，具体SQL我给大家看的是通过MYSQL实现的那块对吧，OK这就是我们数据源啊。

theta数据源源码的整个的分析，那就分析到这里好吧，各位各位这张图发给大家啊，我现在就发给大家分享，OK那么都在我这个笔记中的，最后都在这个笔记中的，最后我这样给大家写一下啊。

在这个风云笔记啊写一个原嘿漂亮原理图行了，原理图地址，OK在这好吧，你们直接去打开这个链接就能看到，我给大家画一张图，通过那个自己再捋一捋就可以了，好吧，各位OK啊，那咱们这节课啊。

SA的这个数据源代理。

系列 5：P73：73、Seata源码分析- Seata服务端（TC）源码解读 - 马士兵学堂 - BV1E34y1w773

Hello，同志们啊，我们这节课来继续讲解这个theta的源码啊，稍等一下，我把它调一调，OK啊，嗯这节课的话给大家讲一讲，我们这个theta的服务端，也就是TC相关的一个源码的一个阅读呃。

因为这段时间各位我们一直在讲，他客户端相关内容啊，包括我们从最开始的这个稍微缩小一点啊。

从最开始的哪儿呢，这个它对应的一个自动装配，找到这个全局扫描的注解，然后包括这个什么abstract out to prosecreator，然后它的一个重写的方法，然后再去程序启动的时候呃。

事物发起时所调用的一个invoke方法啊，然后到解析注解以及对应的处理，当我们找到这个啊这个execute方法，最终执行我们这个整个核心的几个步骤，全局事务的几个步骤，包括获取这种事务信息。

然后他的一些操作，包括执行全局事务和他的一些操作对吧啊，去什么发起与TMTC发起请求等等这些，然后呢包括这个呃这个commit，整体的这个全局回滚或提交对吧，然后呢啊全局回滚到最后的提交以及清除资源。

这个位置，是我们之前所看到的整个非常核心的一块内容，什么内容呢，就是我们的呃全局事务提交整个流程，那么之前我在这讲过说在第四部commit的时候，他需要跟theta server端进行一个调用。

那么调用以后呢，我们需要去找到sea server端相关的一些内容啊，就是说呃，这节课我们要分析的就是去开启这个全局事务，提交以后，如在theta server端，它是如何进行调用的，还干了什么事啊。

这是我们这节课主要分析内容好吧，那么废话不多说，我们就来实际分析啊，当然我们可以先找一下哪个类型啊，先找一下，我们先看一下，来找这个handler，这个啊我们来到源码这啊，搜索一下，OK好。

然后我们来看一下之前给大家讲过这个过程，什么invoke，从这开始对吧，OK然后呢到他整个执行全局事务，从这开始，Handler transactional，然后进来啊，然后再具体的步骤我来看一下啊啊。

合理去聊，超时时间，然后这是最开始的构建信息执行一场，哎不是我哪去了，我来看一下啊啊啊在这在这看错了啊啊，Hler global transactional，这找cute方法，从这进去。

OK然后呢我们可以看到它整体的执行流程，第一步去获取事物信息，然后这是第一步相关的操作对吧，这个我们都讲过了啊，然后到哪第二步呢到的是1。3，第二这个位置开始执行全局事务，然后第三步发生异常。

全局回滚对吧，然后进行安do log的补偿，包括最后的第四部提交资源啊，全局提交啊，然后以及最后的清除资源啊，当然这个位置，我们其实实际是从这儿可以去看到，从这儿开始提交全局事务去调用我的服务端。

那么服务端的话，各位从图上来看怎么去找啊，实际上它的服务端是这样的，呃，我们这个服务端，是我们在这个我们自己电脑上配置的，那个theta server端对吧，这个应该都知道我们之前装过啊。

带大家去应用的时候，大家去讲过sa sub端，那么这个C的搜索端，它实际上本质上它也是个项目，它也是个spring项目，而且各位你们要知道一点，关键就是不管任何看笔记啊，就是我这写过了，说就是我先说啊。

不管任何的这种牛逼的项目或者牛逼的框架，它的这个都是java项目，java项目的主体动类肯定是灭啊，幂函数，所以一会我们去找就找这个函数啊，所以这点不要着急，我们一起来看一下啊。

然后现在我这还要解释一个事，就是我们服务端所做的一些事情，那这个位置的话，我需要把我的数据库开一下，我先解释一下这个位置，有一点啊，有几点我需要跟大家说一下啊，稍等一下哟，哦这个不要不要不要着急啊。

我那个服务掉了，这个电脑内存有点不太够使，稍等一下啊，服务我来找一下我的MYSQL应该是关了关了，把服务器下好了，然后咱们回到回到数据库，这回到数据库，这再点一下好。

我们之前去构建这个theta server的时候，去创建过一个表，一个库就叫theta，在这个theta中有三个表，靠这来啊，brush这个这个table global table，还有LOTABLE。

这三个是什么东西，各位还记得吗啊可能同学忘了啊，所以我给大家回忆一下，这三张表，实际上是我们sea server端所用到的三张表，在这给大家看一下，在我的笔重啊，在这第一个实际上它是分支事务表。

也是它进行存储你的分支事务相关信息，第2global table是什么全局事务表啊，还有一个就是logo全局锁表，所以这是这三张表的作用，也就是说白了我们全局事务在开启的时候，它是需要对这三张表。

进行相关的一些信息的填写的，前提是你使用的是dB模式，也是数据库模式，当然各位应该都知道，我们之前讲过theta是分为这种呃文件模式嗯，还有dB模式，数据库模式好像还有个release模式。

我们目前用的是数据库模式对吧，所以这张三张表是我们自己构建的，OK那么我们现在说完这点了，刚才也说过，就是任何java工程的启动程序都是主函数命，所以现在我们就要从这入手，去看一下整个的构建过程。

其实我们今天主要看就是个全局表，好吧啊，来那我们就找一下啊，这个我就不给大家去现找了。

就是你们全局这个暴力搜索一下，搜索找到这个密方法，它实际上是在server在这里面的，type server在这里面啊，在这里你可以看到方法在这对吧，main方法在这，然后在这其中我们要找一个关键点啊。

在这他就是那个关键点，默认的调用者不能叫调用者，叫默认的协调者DEFCONVERDINATOR啊，那么这个东西的话是我们就可以从这儿去进行。

去查看啊，包括从我的这个图中，你可以看到这标出来了啊。

不是这个图啊，从这个图中可以看到啊，到c c a Sol端，找到这个默认的协调者，然后去找这么个方法，叫做do global begin，你可以往下来看啊，在哪儿啊。

在这在这个默认协调者中有一个叫做do global begin，从这开始是一个处理全局事务的开始，那我们首先看一下这个方法里面具体做什么了，第一件事情你看响应客户端查看到了吗。

response点set x i d去把对应的XD响应过去，哎那实际上关键点就在于哪啊，咱们先不着急看啊，先看这个，这是个do global begin，还有什么，Do global commit。

全局事务提交，还有什么do global roll back，全球事务回滚，包括全球事务的一些状态等等一些其他信息，这三个是我们比较关注的对吧，当然今天我们主要关注这啊全局事务的开启，他怎么去做的。

我们往下来瞅啊，所以在这首先啊你可以看这有一个靠点begin，核心begin，从这开始，我们从这看来走，OK看到这个begin方法啊，在这个begin方法中，他做了哪些事情呢，我们一点点来分析。

我们一点来分析，那么你看这个比例方法中啊，上来第一件事，global session session等于global session，点create global session，这干啥呀。

实际上它是创建了一个叫做全局session，从图中我们可以看到就在这啊创建了一个begin，在构建一个全局session，这是第一件事情，那么第二件事在这还有session ADD session。

listener是什么东西啊，那么各位要注意中间这个词什么意思，Life cycle at session，life cycles listener是啥呀，首先这是一个添加一个监听。

而且这是个观察者的设计模式，同时这个位置life cycle它代表的意思是什么，生命周期session at session，Lifecycle listener，说白了是干什么，就是给他去添加监听嘛。

那么还有就是一件事，再往下看啊，全局事务开启session点begin，这是一个全局事务开启，那么这这三件事儿啊，我分别在这个图中给大家列出来了，这也是我们主要分析的三件事。

第一件事情构建全局session，我们看到了，这不用多说，很简单的事，然后第二点就是为全局session去添加监听，那么第三点是调用调用全局session点begin方法，来开始对应的一些具体处理。

所以啊第一步不需要分析，我们先来分析，第二步就是为全局session监听他干了什么事，所以从这开始啊，从这开始at这开始，OK啊，那我们从这开始对吧，OK啊，那么在这之前我们还是先看一下吧。

这个固定全局session啊，其实他所谓这个固定全局session就是把金刚application id，包括transactional service group group分组。

包括name time out，把一些相关的信息传去，它，构建全球session的目的，就是为了相互能够去进行一个啊，session的目的是什么，相互有个信息的互通对吧，OK所以这不用多解释。

再往下来看看这啊，那么session点i session啊，leaf这个东西，listener我们可以看这啊，他是他在这个位置去干了什么啊，其实啊在这儿我们可以看它session holder点上啊。

get root session manager这个位置他做了些什么事情，他实际上是获得了一个全局的session管理器，那么各位可以注意到的是，他虽然说这写的是获得了一个全局的session管理器。

这个session管理器到底是谁呢，这有个常量root session manager，我们可以看一下，是常量啊，你看它的默认值是session manager，这是个啥，这是个接口对吧。

OK那么它是怎么去构建的，是谁的，具体这个session管理器是谁呢，其实可以往下来看看它的初始化方法的方法，那么在引力的方法中往下来搂一眼啊，看来他上来这都不用管啊，你就看这来啊。

这个是一个模式的判断，这是个模式的model model，其实这个位置他是去读取你的配置文件，来获取你当前的一个什么sat的模式，而很明显我们当前的SA就是个dB模式，所以说你看当前这个模式。

如果是dB，那好我们现在这个位置是equals嘛对吧，如果是dB模式的话，那就走相关这个位置啊，如果是其他的file模式，走的是file相关的，那么还有如果是REDIS，那走REDIS的，看到了吧。

它是根据这个模式去读取对应的文件，然后来拿到你具体的那个真正的什么session的，一个全局的这么一个管理器，OK所以很明显当前我们是dB模式，那我们就看这，然后你看啊。

我们要找的那个常量值叫做root session manager，然后他这是读取了一个叫做session manager class啊，如果是dB模式获取名字，他这个位置实际上如果各位你们自己来看的话。

其实你们应该能看出来，它实际上采用了SPI的机制，却读取了对应的接口实现类，那么它读取的是哪里，它实际上读取的是哪啊，读取的是当前这个resource中，对应的这个文件下的。

一个叫做dB模式的这么一个文件，在这看到了吗，啊他读取的是他，所以咱可以看一下走啊，在这其中你就可以看到哎我看一下啊，是不是这个文件，哦不对，Sorry，看错了，不是他啊，不是他啊，他读取的是这个。

看错了，这是这是data source provider啊，这不是他啊，看来他读取的是这个session server，Session。

session manager在这里面所记录的对应它的一些专门的类，不同类型的一个实现类，你看啊有failed文件的实现类型，session manager有database，数据库类型的。

还有REDIS，很明显这个位置我们是database对吧，所以当前这个位置我们再回来回到哪啊，回到就是他在往下翻找了个哪来着，这个这个这个这个INIT往下，算了看别推进了啊。

就这啊这个方法这个root是谁啊，那不就是我们看到的这个对应的配置文件中，这个吗，是不是database session manager，OK所以在这我给大家去记录了，说去添加全全局这个监听以后。

那么然后呢，这个位置啊，还要去通过SPI的机制去读取对应的session，的一个持有者，这个session的持有者，实际上就是我们读取到的这个文件。

也就是dB模式返回的是他database session manager，所以当前我们这个管理者就是他，所以当前第一步构建了全局事务id，第二步干什么，获取了一个啊。

这个这个去为这个当这是个观察者设计模式啊，去添加了一个对应的创建了一个database session manager啊，添加监听，同时找了这么一个管理者对吧。

全局session根据你的这个类型去管理的，我当前数据库也行，所以找的是database，然后再来就是全局事故的开启，那么就再关注这往下走啊，session点begin走。

OK那么进到begin这个方法以后，你看他干了什么，这个方法首先声明全局事务开始，为什么这么说呢，你看当前全局事务状态，你看global status，点begin begin，实际上就是个开始状态。

OK他是个开始状态，然后当前的开始时间以及激活全局事务，active状态为true啊，然后将当前的这个session manager去放到这个集合中，去调用它的什么on begin方法啊。

去掉它的on begin方法，所以这个位置啊，我们现在就来看一下这个begin方法啊，需要去进入到哪，进入到这个on begin方法，这是关键走，当然这个位置啊掉的是谁啊。

这个位置有个父类叫做abstract session manager啊，这个abstract session manager就是它相关的一些session manager的父类，所以我们现在就找到他啊。

on begin有个叫做EGLOBAL3神啊，那么现在我们可以看一下这个at global session，在这又干了什么，往下看往下看啊，当然这个位置啊，其实如果你直接进的话，它是负类的。

那么这个位置你要想刚才我是不是说过了啊，在这个位置哪去了，哎哪去了，回来回来回来回来就在这啊，我是不是在这搞了一个叫做什么那个，这个东西data database session manager吧。

找到他，所以当前我们在abstract session manager中去调用，这个at global session方法，它应该是谁，是不是就是我的database这个而不是fire或REDIS。

因为当前是database模式，数据库模式嘛对吧，所以找他在这进去，在这实际上真正去执行的方法是这个。

也就是我的database session manager所执行的这个at global session方法啊，添加这个方法，那么这个方法它具体干什么呢，首先第一件事情写入session啊。

写入相关session在这right session对吧，OK然后关键点就在于这，我们走看这个RELEASESSION啊，当然这也是一个需要去找他的一个实现类啊，也是这个database的啊。

一定是database的，因为现在数据库模式就是它好走，这那么你走到这个写入方法以后，来看他干了什么，当前这个位置他判断说啊，你这个是否是啊，第一次写入，如果你当前我们一定是第一次写入，因为刚开始调嘛。

如果你当前是第一次写入的话，你看他一定是走的insert啊，如果你你如果不是的话，可能是有修改，有删除，有其他的，但当前我们第一次进来。

一定是insert global transactional d o走，这对吧，那再往下看，我就看看这个sert global transacd是干啥的，当然这个位置还是需要对应的时间来看一下。

看这干啥呢，这个东西是不是就很明显很直接了，他是不是就是去真正的写文件了，写什么往数据库里写东西了，那么它往哪个数据库里写啊，有对应的一个类型，Global transactional dio。

看一下这个类型，string child l啊，这个这个transactional id，Status，application id等等这些，你看看这些跟他是不是一样的。

跟他是不一样的，前四个是不是对上了。

包括后面service group是什么对应的transitional name。

是不是对，所以分析到这，各位明白咋回事了吧，啊咱们看图来说啊，这个位置调用全局session，实际上就是调用负极的on begin，然后走的是database session manager啊。

是我们那个dB模式的，然后进入到dB的储存模式的这个write写方法，第一次进来一定是向当前这个音色去写入数据，写的就是你这个global table表中的数据，也就是去记录一个当前的全局事务。

所以这就是我们这个位置，全局事务提交的时候干的事，就是在你当前的这三张表中，哪三张表啊，刚才课本笔记中说过，这三张表中在全局事务表中去记录一条数据，证明当前有一个全局事务进来了。

这就是这个位置的交互相关内容，当然今天我们主要分析的就是这个global table。

这张表能理解了吗，各位OK，那么讲到这的话。

其实这个事我基本说完了，整个流程我在这个笔记中都有记录，你们可以去按照这个笔记再过一遍，包括这个图也会给大家啊，它其实非常简单，就是服务端开启以后找这个默认的。

然后去找这个do global开启全局事务，然后对应的begin方法做了三件事，构建全局session，为全局session添加添加一个监听，那么这个位置实际上找的就是一个叫做database。

什么session manager这么一个呃数据库模式的一个manager，然后再去调用全局session的时候，它调用的方式，其实最终的最终干的事，就是去向DB模式储存全局事务的那个表中。

去写入一条数据，证明当前有一个全局事务，当然你们要知道是这个东西在最后写入完以后，为什么我们在这个表中看不到相关的内容啊，就是我们这个数据库的表中，为什么看不到相关内容，是因为他每一次执行完成之后。

会把当前这个表中所有内容清除掉，他也就是一个记录的事，好吧各位啊，当然其他的这两张表道理其实差不多啊，就是其他这两张表，一个是，分支15，一个全局锁，这两个其实差不太多，道理都一样。

所以这里就不详细分析了，我们主要分析就是这个全局事务表明白了，各位啊，这就是服务端交互，这个时候啊。

尤其是服务端交互这个位置，他所干的事就是全局，全局事务提交以后，他干的事就这些好吧，各位啊。

系列 5：P74：74、深入剖析MySQLl背后的架构设计，带你充分了解MySQL的架构设计 - 马士兵学堂 - BV1E34y1w773

呃这个东西啊，我先说一下，你连了他之后，对你对于MYSQL调优也好，还是对MYSQL的深入理解也好，都是有帮助的好吧，那我们在划分的时候，基本上会划分为三个层次，第一个层次我们经常称之为叫客户端。

客户端，什么叫客户端，就比如说我们自己写的代码，像JDBC的对吧，比如说你们自己之前用过的一些工具，NAVCAT对吧，再比如说用的SQL这些东西全部都属于客户端，客户端它存在的意义和价值是什么，注意的。

只是为了提交SQL语句就建立连接，提交搜索，明白意思吧，把这件事你要先搞明白了，叫建立连接，提交SQL第一个步骤，当客户端完了之后，客户端是向谁fast连接，并且建立连接呢。

在下面第二部分包含了第二个组件，叫做server，server是什么意思，指的是MYSQL的服务，这东西啊怎么去理解它，很明显，假如说你想运行你当前的MYSQL的话。

那么意味着你必须要先开启MYSQL的服务吧，比如打开你的电脑里面一定有一个MYSQL5。7，显示的是正在运行，它表示的是MYSQL在运行的这个进程，运行的进程，如果你想正确的正常的连接MYSQL。

这东西必须要有的，如果你在LINUX服务器里面，比如service mysql d start，它也属于启动MYSQL的服务服务，必须要正常，但大家看到了，我在服务端这块我画了很大很大的一个框。

为什么很大原因很简单，这里面其实也包含了非常非常多的组件好吧，什么组件，第一部分听好了，第一部分叫做连接器，这个连接器代表什么意思，就其中一个组件一个部分好吧，它主要承担的功能也非常简单，叫做管理连接。

管理连接，第二个叫验证权限，每次在进行数据库的访问的时候，必然是需要输入用户名密码，它会进行权限的一个验证之类的，好吧，这是这块的一个基本操作，而且我们是可以查看我们MSL对应连接的。

我问一下有多少同学之前查看过MYSQL的链接。

看过吗，有一个很简单的命令啊，我们来看看。

比如说我这先登录NGO杠u root杠P123456，进来使个东西叫show process list。

看了吗，这就表示我们当前数据库里面正在建立的连接。

有几个，有两个正在访问我们当前的一个数据库，The connector to master，还有一个叫starting对吧，只是我们对应的一些连接操作。

你知道这玩意儿就可以了，就是这个连接器我们一般很少关注于这个模块，我是第一部分，第一部分连接器，当我连接成功建立之后，第二个步骤叫什么叫分析器，这个分析器是个什么玩意呢，什么叫分析器啊，其实非常简单诶。

怎么连连连连跑了，这分析非常简单，其实大家注意了啊，什么叫分析器，我们的SQL语句，最终是要提交给mysql server来开始执行的，但是SQL语句是个啥呀，其实在我本人看来，你写的一个SQL语句。

比如最简单的select星from table，这句足够简单吧，你在公司里面也可能写一个上百行的SQL语句，它可能会变得非常非常复杂，但不管是简单还是复杂，你都要搞明白一件事，他说白了就是一堆的字符串。

而我的server拿到这一系列字符串之后，我是需要对当前的字符串进行，某些简单的解析操作的，有些同学应该听过一个名词，我不知道有没有听过啊，叫AST，你们听过吗，什么叫asp，它的全称叫做抽象，语法术。

最终一个简单的SQL语句，不管多简单多复杂，SQL语句都会转变成一个树形的结构，有人见过这个抽象语法树长什么样子吗，见过的扣一，没见过的扣二见过吗，好吧，很多同学没见过，今天我来带你看一下。

其实啊树长什么样子，它又长什么样子，这东西啊，你善于去看官网，我要打开一个官网，有一个组件叫sd sphere，它是一个分库分表的一个组件，在当前这个组件的官网里面，他给我们展示了一张图。

图里面展示的就是抽象语法树这样一个结构，比如说不管你的语句，SQL语句什么样子，他都会帮我们进行一个转换，明白吗，来中文这个网站，有中文网站拿过来之后可以直接进行查看的，什么情况都这么慢，四点X。

这咋了，是我网络问题吗，来打开concept，这太慢了，4。1。0，可能因为我同时开了两个直播间，所以有点有点卡，哎呀这看不了帖子，重新连接一下，我搭上梯子之后，你们就这个客户端听课，这东西就断掉了。

什么情况，这是，取出来了，算了有点慢，咱们慢慢开着吧，咱慢慢开着，开完之后我们再说，这不是公司网速的问题啊，老师笔记本什么配置，我怕说出来吓死你好吧，懂了吗，一会我带你看，然后慢慢打开的。

那这里面会进行两个最基本的操作，一个叫死法分析，你找语法分析，但不管你怎么进行词法分析还是进行语法分析，最终都会转换成一个抽象语法树，而我们SQL语句在进行正常执行的时候。

都是按照这样的一个树形结构来执行的，当然有很多同学可能会对这个呃，分析这个工具啊，或者分析这个插件有感比有比较感兴趣，我再给大家说一下，一般情况下SQL语句进行语法解析的时候。

重点或者用的比较多的有两个组件，第一个组件叫ANTL2，这是第一个，第二个是阿帕奇的，这东西我也不知道怎么读好吧，我就不给大家读了，这样东西用的是比较多的，如果谁不清楚的话，也很简单。

你可以百度搜一下ANTLR，想了解可以详细了解一下，就告诉你了，说这东西是可以根据输入自动生成语法数，并可视化的显示出来的，开源语法分析，这是第一个好吧，除了他之外，还有第二个叫阿帕奇。

这东西它也是一个开源的SQL解析工具，可以将各种SQL语句解析成抽象语法树，明白意思吧，就这么两个玩意儿，如果你在公司里面需要去开发，或者说需要去自研啊，自研一些呃SQL语句的一些中间件的话。

这个时候可能会涉及到Sol的语法解析工作，如果不需要的话，那这块是没是没必要了解的，可以不了解哈，好吧，来找一下sharing cos，官网又变了，这这盖子做宽敞内核内核的一个引导。

这边有个pass engine叫解析引擎，在当前解析引擎里面有这样一个东西，来看好了，出来了啊，往上看这个SQL语句，没有人不熟吧，Sit name from the oder。

where this等于active and age大于18，我们从这里面能够发现什么信息，像这里面的slide from where and，这些东西是不是都是我们对应的关键字。

但是像id name table名称加上我们的字段，加上我们对应的一个值，这些东西都是可变的吧，所以它会把你当前的这个思路语句，转成一个这样的树形结构，整成这样数据结构，看到了吗，最上面是root节点。

下面绿色的表示我们对应的关键字，这里面叫做token标识token，然后有files属性，有id和name好吧，有tables告诉你，User clections，有条件，首先里面有and等于大于。

这都是我们的脱困关键字，下面是我们具体的一些变量值，它都会填充到这个地方，所以不管你写的SQL语句，Sl，SL语句多么复杂，都会转成这样一个数据结构，按照这样的一个数据结构来进行，具体Sol的解释工作。

来这个东西了解的话，给老师扣个一，看到了吧，就这样子好吧，就这样子，当然你不需要不需要详细去了解这个过程，没意义，好吧小子，你说这是录播吗，对是录播，你就回答非常正确啊。

好了，这是第二部分核心的一个组件，两个色吧，再加个色，总感觉很丑的样子，剪完色之后效果立马就不一样了，好吧，OK这是第二部分，然后呢第三部分除了分析器之外，下面还有一个东西叫什么呢，叫做优化器。

优化优化什么意思，我们经常说我要进行SQL语句的调用了，其实在my SQL内部里面，他已经要进行相关的一些优化调整了，刘老师，这需要进行什么优化调整吗，比如说我举个例子吧。

我们经常写一个SQL语句叫flat，星from T1，然后join t22T一T2D是等于T2点D，我问一下，对于这样的一个SQL语句，它是先读取T1这张表，还是先读取T2这张表啊，先读取哪个。

你知道吗，这个时候一定有人会告诉老师，先读取驱动表，然后再读取另外一张表，你告诉我什么叫驱动表，他每次一定是都先读T1或都先读T2吗，不是吧，对不对，这是不一定的，所以对于先读T1还是先读T2。

这个时候就是由我们对应的一个优化器来选择，执行的优化，选择执行，而优化器跟大家说一下，优化器在进行优化的时候，主要依据于两个标准，第一个标准叫RBO，第二个第二名叫CBO，什么叫RBO。

所谓的RBO表示叫基于规则的优化，CPU要基于成本的优化，在现在的主流数据库里面，像这个CPU用的是比较多的，RBO用的是比较少的，但是你不要说老师，你能给我说一下，具体的优化器有哪些优化规则吗。

如果你想看优化规则，不好意思，需要看源码这块，我也没有怎么看过，我虽然没看过MYSQL关于樱花树方面的一个解释，但是我看过一个框架叫做have，有人知道吗，你知道这玩意儿吗，还有有人知道这个东西吗。

gave数仓应税仓库哇，去仓库里面在进行思路解析的时候，它也需要一个优化器，在have里面我看过have源码，看源码里面我那是2。1。1。2版本，1。1。2版本，在这个版本的时候。

它里面大概包含了134个优化器，134个，就根据你不同的SQL语句的情况，来判断说我到底使用什么样的一个优化规则，是这样的方式，而MYSQL里面有多少个，我具体我也不确定。

原MYSQL源码是用C语言写的，我看C语言虽然能看，但有点困难，所以这块儿了解比他少，所以你大概知道两个东西就可以了，如果你想详细看的话，这东西也是有地方可以查的，你就送一个东西，一个MSLCPU。

别动，看到了吗，MSCPU和什么体系什么之类的，SQL优化器CPU或RBO分别代表什么意思，里面有一堆的解析工作，把CPU也是cost r b o早期作基于规则的优化器，和基于代价或基于成本的优化器。

就这意思好吧，我还以为是直播呢，不是直播，是录播好吧，RB基本团队现在主用的就是CPURBU，现在进入的很少了，所以大概知道两个概念就够了，这是第三个组件，包含这三个组件之后。

下面还有第四个组件叫什么叫做执行器，时间线有什么有什么作用呢，它的意义在什么地方，其实也非常简单，它的作用是，执行circle跟执行circle，跟存储引擎，交互组织已经进行交互，这句话是什么意思呢。

其实非常简单，朋友们，比如说我们现在换了客户端了，我们下面画了中间的server层，其实在这两层的下面还有一个层次，这个层次这个层次干嘛呢，我们叫做存储引擎好吧，什么叫存储引擎。

就是你们之前说的一些东西，像my sam对吧，像英伦dB对吧，像memory，对吧，这三个东西都是指我们存储引擎，那最终我们的执行器是需要跟我们的存储引擎，进行交互的。

它需要从存储引擎里面把数据给查询出来，并且返回给我们具体的一个客户端，明白意思吧，来我画这张图能看明白，同学给老师扣一自信点把吧，去掉这些东西好吧，当然很多同学啊一直对于存储引擎的概念。

可能理解的并不是特别清楚，我想问一下什么叫存储引擎啊，这东西到底怎么去理解它，谁能告诉我，我们怎么理解存储引擎，先问一下MYSQL的数据文件存在磁盘还是存在内存，知道吗，在我们看到文件的时候。

其实说白了它就是一个一个单独的数据文件，但是你注意了，你在换不同的存储引擎的时候，他们在磁盘上面的存储形式是不一样的，也就是说叫不同的数据文件，在磁盘的不同组织组织，形式好吧。

我们给他们起了一个统一的描述，或者统一的概述，叫做存储引擎，我举一个例子，你就明白了，很多同学啊可能经常看的是表，通过可视化工具直接看表了，你其实很少了解过这些对应的数据文件，那么在这样的数据文件里面。

我们可以看一下，打开我的电脑好，选择C盘，找到program date，找到mysql max，5。7找到date，我打开随便打开一个库，比如demo在这个库里面，或者在这个目录文件里面。

大家可以看到同名的文件，是不是有两个A就是同名的文件，一个是f RM，一个是IDDFRM表示什么意思，它表示存储的是表结构相关的一些元数据信息，而ABD表示什么意思，它表示存放的是我们的数据文件。

以及对应的索引文件，所以当你看到这样的一些东西的时候，就表示说当前AA这张表，我所使用的存储引擎用的是什么，叫in low dB这种存储引擎，明白意思吧好吧，同样的我可以换另外的一个目录。

比如打开MYSQL这个目录，这个时候你同样看同名的文件，包含几个三个吧好吧，后缀名名名称不一样，f RM还是表示我们对应的表结构，而MYD表示是my sum的date文件state。

而MYI表示存储是my suindex文件，大家看到了，在windows dB存储引擎里面，数据跟索引是放在一块的，而在我们当前的这个呃，怎么说这个max sum里面。

你的数据文件和所有文件就是分开存储的，这是他们区别的，也就是说你在使用不同存储引擎的时候，他们在磁盘里面实际存储的时候是不一样的，虽然都是以文件的方式来进行存储，但是不好意思，他们是不一样的。

明白意思吧，来刚刚讲的东西能听懂，同学给老师扣一，哇这是整个体系的一个架构，当然有很多同学可能还会知道一个东西，说老师MYSQL里面不是还应该包含另外一个组件吗，什么组件在这块儿。

这里面是不是还包含另外一个东西，叫做查询缓存啊，什么叫查询缓存，这东西怎么去理解，非常简单啊，比如说我从数据库里面查到一堆数据，查完之后，我下次有可能还会再次查询，那这个时候我是不是。

如果能够在缓存里面放好数据的话，直接从缓存里面取就行了，是这意思啊，注意啊，这我说明一件事，在以前的版本的时候，MYSQL确实有这样的一个查询缓存，这样的一个组件，但是注意了，8。0以上版本，取消。

所以这就没换了，为什么，因为它的数据命中率非常非常低，好吧，需要经常的更新里面的数据，所以这个东西被删掉了，直接给干掉了，所以大家也现在不需要去记这么个玩意儿，你大概了解有这么个东西就可以了好吧。

旭东说，老师你画出的什么笔记叫分页云笔记，那个process on给大家说一下，之前我也用process on，但那个如果你不注册会员的话，只能画几张图片，有些东西叫分页云笔记，你可以用一下。

这东西跟POS是一样的，它里面也支持在线买一个客户端，你可以在里面画图，跟PC上几乎一模一样，可以拿它来进行一个画图，好吧，是这样的东西啊，这个小工具你们可以用它不限制图片的个数，不限制图片的个数。

而且没有那种呃对应的一些充值的一些需要，这个没有啊，所以踏实的放开用就行了，OK好了，就刚刚我讲的一些MYSQL整体的一个架构，你把这东西首先要理解清楚了，当你把这东西理解清楚之后，它有什么好处啊。

好处就在于，我们可以在各个层次或在各个级别的时候，对MYSQL的一些东西进行举进行基本的了解，比如说同学们经常要在面试中被问到，优化的问题，当被问到优化问题的时候，大部分同学会条件反射出来说。

老师我要通过添加索引的方式来进行优化，那么我在想问的时候，所以是怎么存储的，你不了解这样架构的时候，其实对于索引仪式很难理解的，再比如说刚刚我看到有个同学问我一个问题啊，说老师方便的时候。

一会儿讲了一个东西叫什么，对索引下推和索引覆盖它们两个之间的区别，那叫signal还叫什么，那叫signal吧，同学们的索引下推，所以我把那个索引覆盖的区别，你了解完这个架构之后。

你就会了解说什么叫覆盖，什么叫下推，好一会我都会讲，你这张图是一个预先了解的一个知识图，因为一会索引的时候。

我们会用到对应的一个知识点，好吧，这是这些相关的东西啊，我是小白，不管你白不白。

系列 5：P75：75、聚簇索引、二级索引和联合索引具备哪些特点 - 马士兵学堂 - BV1E34y1w773

咱们就过了，过了之后来聊下一个话题是吗，说剧组索引。

二级索引和联合索引，它们具备什么样的一些特点，什么叫剧组索引，什么叫联合索引，什么叫二级索引，记住，对，二级，所以还有一个叫联合索引，哇这三个对应的点，抽根烟抽根，MYSQL普通表行记录大行记录大的话。

插入上亿数据会失败吗，失败应该不会啊，失败应该不会，但是数量越大的话，你的查询效率肯定会降低的好吧，来我们来解释几个概念给大家，你算了，不给时间，给他一分钟时间吧，给你们一分钟时间，我点根烟。

你们上个厕所好不好，现在是二十八两分钟吧，我们09：30接着讲，上厕所去好吧，上厕所去一会儿，我们接着讲下一个话题啊，叶子节点包含了完整的行记录，对叶子节点包含了完整的行记录，是的，袁老师有回放吗。

我也不知道有没有啊，我，这没录啊，就确定对等等，没问题好吧，是包含的，但是这东西啊你要说你要说完全包含，也也不能说完全对，为什么一会儿我讲到这个二级索引的时候，你就知道了。

二级索引和普及索引它是有区别的，像二级索引里面就不一定不一定好吧，一会儿来解释啊，算了算了，李老师，这回放我都不敢二倍速，我这个人语速比较快啊，所以那个二倍速可能倍速不了，倍速干啥对吧。

主键字节我就随便指了一个数据嘛，假设嘛对吧，假设，好了09：30了，我们接着往下讲，有问题的话，我们会专门答疑好吧，一会儿答疑来，我接着往下说，这东西第一个句子索引，什么叫句子索引。

像这哎还在同学出门一，我们接着往下讲了，来聊剧索引的事，什么意思，想了解剧索引，你需要知道一个最基本的概念是什么概念，注意啊，我这有指定的条件，叫音动dB存储引擎中数据在进行插入的时候，好吧。

数据必须跟某一个索引列绑定在一起，如果表中有主键，那么跟主键绑定，如果没有主键，那么跟唯一键绑定，如果没有唯一键，那么选择一个六字节ROID，进行绑定这东西啊，它是一个墨守成规的一个前提。

刚刚在讲课之前，我给大家看了inno dB的存储文件，还记得吧，在ino dB这种存储引擎里面，你看到了你的数据和你的索引，都放在ABD这样的一个文件里面去，里面既有数据又有索引。

所以印度DV存储引擎在实际的数据插入的时候，是必须要跟我们的，所以绑定在一起的，那么它就会有一个选择的过程，逐渐有就用主线，没主线我们就用唯一键，没有唯一性的话。

我们就用六字节的ROID来进行实际的数据存储，这句话能理解的，给老师扣个一，能理解吗，能吧，所以这就会有一个问题，那到底什么叫聚素索引，什么叫非剧组索引呢，记住了，听好了，叫数据。

跟索引放在一起的叫做聚簇索引数据跟索引，分开存储的叫做非巨富，所以明白意思吧，所以把两个东西你要分清楚了，你要分清楚了，六字节的ROID是什么，就是一个随机字符，六字节的一个随机字符串被绑定到一起。

绑定在一起，所以这里面与生俱来的会有另外的一个问题，垂直着的说，所以my su是非激素，非常正确，记住了叫my sum中，只有非剧组，所以因为你的数据文件，你的数据文件和你的索引文件是分开存放的。

全加存放的好吧，按你自己说，如果表中没有六字节的呢，他那个64年ROID是隐藏的，你是看不到的，跟你表有名字字段没关系，它是一个隐藏字段，明白说的非常对啊，它是一个隐藏字段，你是看不到的。

在我们实际的MYSQL的数据行里面，其实包含了非常多的隐藏字段，比如说有什么流动性当中啊，这个叫RODB下划线肉下划线id隐藏字段，还有dB下划线肉下划线PT2对吧，还有dB下划线TRX下划线id。

还有还有delete，相信D它有很多对应的隐藏字段，这些隐藏字段你是看报道，你怎么看都看不到，怎么看不到，除非你看源码明白了吗，是类似于oracle rememb跟Z好像不太一样，是有可能显示查出来的。

而MYSQL是绝对查不出来的，明白意思吧，绝对查不出来啊，这些东西，所以下面还有一个问题是什么，刚刚说了，my son是结果非去索引，那么in NO dB中有没有技术作业。

有吧有句索引有没有非聚簇索引呢，有没有非技术索引，转移，NO bb g支持句速索引，也支持，叫非居住，所以这时候肯定有很多同学就会有问题，它其实是跟我们下面的二级索引，要产生关联的一个核心点。

关于一个核心点，我一样，再给大家个问题来讲完，现在能听懂的同学给老师扣个一，能听懂吗，问题吧，下面来聊几个问题，什么问题，我们就来解释，首先第一个一个表可以有几个索引，记住，无限三个可以吧。

第二个每一个索引都是一颗B加速，还是所有的索引供应共共用，BB加数，关键是独立的独立啊，独立也就是说是一个表中会存在多颗一加数，明白了，第三个数据，数据表中数据存储几份。

我们都知道叶子烟里面存的是数据行，存几份，记住一份，如果存一份的话，就会存在一个问题，同学们什么问题，我一个表里面会包含N多个B加数，如果你的数据只存储实际的一份的话。

那么其他的B加数的叶子间里面存储什么数据，什么数据，所以记住一句话，同学们记住我下面写这句话，数据是只存储一份的，是存储一份好吧，其他的非聚簇索引的叶子节点中，存储的是什么计数索引的K值叫K值。

能理解意思吧，所以，电动GB中也包含了，非句错，所以吧能听明白了吗，也包含了非技术索引，它放的是AB值，这一样给大家举一个例子吧，比如说看这张图表里面这个表有三个字段，Id name age。

一共有三个对应的数据列，三个序列之后，我现在id是主键，内部是一颗普通索引，那么id主键的索引建成之后是这样子，下面啊空间有限，所以只自动没写，这是我们对应的这个剧组索引，而name也是一颗B加速的话。

name这个里面存的是什么，看到了吗，名字对应下来之后，最底下放的是什么，放的是我们对应的id值，所以像内部这颗B加树，它就是一颗非聚素索引，而id这个B加树它就是一颗巨树索引，明白了吗。

同学们听明白了吗，来这块听明白，同学给老师扣个一吧，能不能听懂，啊把这东西啊你要搞清楚了，所以什么叫二级索引呀，或者说什么叫辅助索引，表示意思一样的是吧，引导dB中的非聚簇。

所以都可以称之为叫二级索引或者辅助，明白吧，这是它最基本的一个概念，我希望同学们把这个概念可以了解清楚了，OK就这块的一个基本讲解，这块的基本讲解啊，来这东西能过的，来给老师扣个一，能够吗，两个概念。

二级索引跟回表没关系，回表描述是一个过程，所以描述是一个具体的物理结构，看还是不一样的，一会儿我来解释回表的事情，一会儿我来解释回表的事情好吧，二级作业那个没有很多，举举个例子吧，举例来说没有。

文章表里面有id逗号，Name，逗号逗号tender，四个列，这四个列里面id是主键，name是普通索引，好吧，那我问一下在查询的时候，数据跟谁绑定在一块，数据跟id绑定在一起对吧。

name对应的B加数叶子节点中存储的什么值，id吧哇40，Name，就叫做辅助索引或者二级，所以就这意思明白了吗，它是用来帮助辅助查询的，那加索引就这意思明白了吗，好吧，如何来确定哪个索引是二级索引。

你非剧组索引都是R级索引，就这么简单好吧，没有任何唯一建和主键的表，是建立的第一个索引吗，没有任何主见，没有任何文件的话，他会选择六六字节的ROID，作为你的技术索引存在，作为你的基础逻辑存在。

就是我刚刚说的顺序是优先主键，主键，没有唯一键，唯一键没有的话，会生成一个六字节的rod，这是我们的顺序，把顺序要记清楚了好吧，就这一块啊，小孟说优先pk嘛，什么意思，没懂，来下面来解释多个链接。

所以呢不管你有多少个列，非句索引，都是我们对应的辅助索引或者二级索引，明白了吗，不管有多少个列好吧，但是你的表里面可能出现这种情况，主线可能只有一个，但是唯一件有多个，如果存在多个唯一键的话。

那么这个时候表里面又没有主见，那么你的剧组索引，会按照你唯一键指定的顺序来，比如ABC3个列都是唯一键，A在前就选择AB在前，选择BC在前，选择C好吧，V4C指针吗，要要，没有任何唯一件和组件的表。

多个列建索引呢，哪个是主线六字节的ROID，明白了吗，六字节的ROID，六字节的ROID公布，V4C指令吗，要要没指定的话，就是ID了好吧，来下面解释下一个概念叫联合索引，这还有个概念叫符合。

所以这什么意思。

很简单好吧，类似于联合主键的意思，一般情况下我们在设置索引列，所以列的时候只会选择一个列作为索引字段，好吧，但是在某些特殊情况下，需要将多个列共同组成一个索引字段，把称之为叫句啊，所以这个叫联合。

所以就相当于原来是一个列，现在变成了多个列，仅此而已，仅此而已好吧，这能听明白吗，这个联合索引，联合主键和联合组有啥区别，他俩能在一块比，这俩能在一块比吗，他俩没有什么可比性，明白了吗。

my sum中索引都是辅助索引吗，可以这么理解，因为它没有去索引，只有非去索引，所以他都是辅助来进行查询的，来点亮个索引，明白了吗，明白了，给老师扣个一，所以你就查找标记嘛，是你查找的字段吗。

用你的字段来判断吧，是这意思好吧好了，这是这几个存在的最基本的概念，我觉得你应该了解了吧好吧，来再往下看，说第四个在进行索引优化的时候。

需要注意什么问题，我刚刚已经展示了非常非常多的索引相关的，一些信息了，你告诉我根据上面学的东西，我们如何来进行索引优化呢，可以说my sum里面存的是什么，存的是地址，存的是地址，看好了。

上面已经讲了这么多点了，下一个问题是，啥东西来着。

系列 5：P76：76、在进行索引优化时应该注意什么问题？ - 马士兵学堂 - BV1E34y1w773

所以优化的时候，要注意啥，注意什么，同时到了啊，第一个，所以占用的存储空间要小，尽可能索引字段，要尽可能少的占用存储空间，还有吗，在满足业务系统的需求类，尽可能自增，还有吗，还有啥，没了。

所以在进行索引字段，我刚才没提这东西，Hope说了就尽可能不要为空，我帅的东西啊，呃空这玩意儿在数据库里面，它是一个非常非常特殊的存在，因为在很多情况下面，空都不等于空对吧，空调none。

你叫is none or is not n对吧，但是尽量不要选择为空的字段，听明白意思吧好吧，这东西还有第四个选择索引的时候，索引，的基数要尽可能的，大有人知道什么叫基数吗，你知道什么叫基数吗。

这里面有一个计算公式，什么计算公式，就是说我们在建索引的时候，到底给哪些列来建我们对应的索引，这边有计算公式，记住了，叫DV除以count，大于等于80%，这字段适合创建，所以明白意思吗。

刚刚那个同学恶龙咆哮说，假如给性别加字段，你给性别加索引一点意义都没有，一点意义都没有，DV是啥，不知道DV是啥吗，Be in value，第4value唯一值，唯一值除以count要大于等于80%。

明白了吗，性别这个字段，你加索引一点意义都没有，就是要给你前面加作业没意义啊，你加作业干嘛，你身边只有男和女男女，你加索引之后，你通过索引来查询没有意义啊，你加这玩意儿明白意思吧，这没意义啊。

对你的不重复的值要尽可能的多好吧，重复值多的话，这长期的话要比较麻烦，还有什么，看到了吗，加了也不会怎么样嘛，你在另外一个字段查询的时候，查出来都是重复数据吗，那没意义，也不会怎么样，还有啥。

不要给所有的字段都添加索引，并不是索引越多越好，明白了吗，这点是很重要的，很多同学老师，我能不能给表里面的每一个字段都添加上，所以不要这样，你给你表里面的每一个字段都添加索引之后，效率不一定高。

效率不一定高，它会占用大量的存储空间，明白意思吧，好吧，再往下看第六个还有什么，看吧，尽量避免索引失效，尽量避免索引失效，尽量避免索引失效，那这里面就涉及到一个问题，老师索引失效都有哪些场景。

比如下一个我要聊的话题，什么情况下会导致索引失效，有人能说一下吗，所以呢应该是很少修改的，这个是对的，加一个吧，这个我之前没准备啊，下一个，尽量选择的索引字段尽量不要频繁，修改，来第一种情况。

所以实际情况你们说的啥来着，like查询的时候，左边的时候，不要加感叹号对吧，还有吗，中国中国，is not all的情况，我建议你不要说all的情况，不要说，看到吗，所以是这样的。

所以字段上不要添加任何的表达式操作，明白了吧，不要加任何表达式操作啊，这是第二个，还有吗，第三个对，所以，字段在使用的时候不要出现类型的影视，影视，转换，还有啥索引，上不要出现函数计算。

说什么组合索引在进行使用的时候，要遵循最左匹配原则，我还没说这东西啊，匹配原则，这最多比原则我还没说，不了解你是转换啥意思，来给你举个例子啊，等下我给你找个案例啊，嗯找一个案例，我想想在哪放着呢。

我让你列一堆情况，是多少下，你找一下这个东西，所以失效，嗯还有啥，诶你现在睡觉吗，找不到从哪讲这玩意，嗯等我找一下。

我忘了在哪在哪讲的，所以失效的情况我这写了一堆啊，先找到，不算了，给大家举个例子啊，就是这个东西是啥意思，什么叫隐式转换，比如说我们在进行具体的数据库操作的时候，有一个叫做什么来着，From。

来看这个东西来演示这个这个这个这个案例啊，来打开我们的数据库，演示一个案例，Use them。

打开user存在draviable user。

你看看表吧，表里面有几个字段，三个字段好吧，123d name和phone，只有且只有这三个字段好吧，当包含了三字段之后，还有一件事，我现在给我们的phone字段，我添加一个索引，建完了。

建完之后查询语句，你在写的时候，比如说我随便写一个，大家看到这个SQL语句吗，我问一下，我现在这种作文字段是什么类型的，什么类型，观察类型了，我现在写什么类型数字啊，是不是数字类型，你运行之后。

你看一下你的执行计划，在执行计划里面K这页里面显示的就是N，如果现在我换一种操作，我把这个东西加单引号引起来。

这有值了吗，你知道吧，这就是我们对应的类型，如果你的类型发生一种转换的话，它可能会导致我们对应的索引失效，就这意思明白了，看明白了吗，来这个案例看明白，同学给他扣个一。

能看懂吗，就就这意思好吧，大家这种情况好吧，再往下看，还有一个东西，我就给大家说一下，in或者on，在很多情况下会导致，所以失效，但是要根据实际的情况来进行判断，明白意思吧。

你不要上来就说印会失效或者or会失效，这种说法都是不对的，都是不对的，OK直播不是直播，是录播，所以啊把这几种情况给大家说清楚，说完之后，你随便哪个地方能举出一些案例就够了，能举出一些案例。

我记得我之前用过这东西，在那忘好吧，来再看还有什么，第七个，在使用组合索引的时候，如果中间的某个索引列使用了范围查询，那么会导致后续表索引失效，这东西啊一会儿也是一样，我会给大家举个例子。

来说明这几种对应的一个情况，好吧，这我写了七个，我就差不多够了吧，你面试的时候去给面试官说这些情况就可以了，好来这几个点能听明白，同学给我扣一，能看懂吗，这样啊这个东西啊我来给大家一会。

我来解释几个名词，解释几个名词的时候，我们把对应的案例啊给大家做一个演示，做一个演示，好吧好了，这是刚刚上面讲的这些核心的一些知识啊，讲完核心知识之后，我们再讲几个关键名词吧，把几个关键名词讲完之后。

基本上就结束了，第一个名词刚才提到的叫回表，来知道回表是啥意思，给老师扣一，不知道扣二，你知道什么叫回表吗，回表是这样一个意思啊，给大家解释一下，我们来列举一个场景，什么场景，比如说表里面有id逗号。

name逗号，真的四个字段好，先明确这四个字段，当我定好数字段之后，我来规定一下，这里面有ID，组件好吧，name是普通，所以我写一个语句叫select星from table，where name等于。

张三问一下，这条SL语句的查找过程是什么样子的，啥样的，先根据，name的值去name b加数，找到对应的叶子节点吧，我问一下这个叶子节点取得数据是什么数据啊，页面放什么，取出D值吧，再根据D值去D。

B加速攻找到查找全部的结果，这个过程称之为回表，是回表的意义，明白意思吧，那我问的是什么，回表的效率高还是低啊，回转的效率高还是低，火页表的效率比较低好吧，尽可能不要使用，我尽可能避免回表的产生。

明白意思吧，就是这些东西，这是回表，那这个没问题的，扣一这是回归概念啊，他需要来回去回到原来表里面，查询我们对应的一个数据记录，这是第一个来聊第二个东西，刚才要求讲的，第二个叫索引覆盖，什么叫索引覆盖。

表示一模一样的数据一模一样，我把这个语句改一下，改成什么呢，改id逗号，Name，想问一下他的操作过程是什么样子的，什么样子，是不是先根据name的值去name的B加数，查找结果能够。

直接获取到id和内容，还需要就不需要去D的B加速查找，其他的查找数据的这个过程，叫做索引覆盖，明白了吗，什么叫索引覆盖，也非常简单，就是说索引的叶子节点中包含了，要查询的全部数据，是叫做索引覆盖。

能听懂吗，这效率高还是低啊，是高还是低高吗，这谁啊，推荐使用索引，对这些东西来，再往下看下一个它都叫什么叫最左匹配原则，这是什么东西啊，什么叫最左匹配原则呀，其实他也挺好理解的，它主要针对什么。

针对的是组合索引，一样改一下条件吧，id name和逗号位置是组合所有，组合索引就在查询，有时候必须要从左向右匹配这东西啊，就跟我们呃去购物网站，你在购物网站里面写写写地址的时候一样，必须要先学省。

再选市，再选缺缺一是不可的，必须按照这样这样这样一个数据来保存，这里面会与生俱来对应几个语句啊，让大家查一下flag行，From table，where name等于根号，and age等于问号。

这是第一个语句，下面还有几条，把他干一下，删掉，呃删掉，我问一下这四条语句里面哪个会用到组合索引，14134134，还是那句话，你记住我刚刚说的那个标准顺序，必须要从左向右挨个匹配，所以在匹配的时候。

我们先匹配第一个name age是不是符合这个顺序，所以是没问题的，第二个age能复合吗，必须要先匹配name再匹配，你这里面没有内幕，所以第二个是不行的，第三个可以吗，可以啊，虽然没有。

但是我能匹配到name也是可以使用的，第四个把name和age顺序换了一下，第四个行不行，第四个项目，这是比较有争议的地方，其实我问一个问题就行了，如果把name和age的顺序来回换一下。

会影响我们最终的查询结果吗，会影响吗，不会吗，所以这块会有一个东西，就刚刚说的是优化器会优化，明白了会调整好我们对应的一个顺序就完了，这就是我们说的最左匹配原则对吧，除了最左匹配原则之外。

还有下面一个东西，什么原理是啥，没啥原理，就是从此就先取为第一个。

系列 5：P77：77、什么情况下会导致索引失效？ - 马士兵学堂 - BV1E34y1w773

在比较数据的时候，你要先比较第一个才能比较第二个，只有第一个相同了，我才能比较第二个的，可能如果第一个不一样，第二个没必要比较了，就这么简单好吧，来啊下面最后一个我们来讲一个索引。

下推优化器后会不会走索引，首先优化器会不会走索引，它优化完成之后，会把你这两个条件的顺序换一下，换完之后不就符合内部和值了吗，他就会走啊，会走啊，汇总好吧，为什么一定要在前。

因为你在创建对应的B加数的时候，大家看好了，我们刚刚给大家展示的，找一下刚给大家展示这个索引结构的时候，它这个key是不是只有一个值，当你是一个组合索引的时候，它就变成两个值了。

比如张三和28会放在一起，李四和39会放到一起，所以我在匹配的时候，它相当于是一个二元组，明白吗，XY2元组我必须要先比较X才能比较Y，如果X不一样，我就连Y比较的意义都没有了，Y就永远不可能比到。

只有X相同的时候，我才可能才可能会比较Y，就这意思好吧，就这意思来你最后面一个话题吧，叫三能行吗，三行啊，三可以啊，我刚刚说话吗，国木三可以的，虽然可以啊，虽然没用，但是name的符合那个顺序嘛。

所以是可以用的，来聊最后一个东西叫索引下推，什么叫索引下推，其实它也非常好理解啊，非常好理解什么意思，还是当前这样一个情况，我来写一个色素语句吧，slide行from。

where name等于根号and等于根号，就这样的一个普通思路语句，在没有，所以下推之前它是怎么处理的呢，处理原则非常非常简，单，是先根据name的值从存储，引擎中拿到符合条件的数据。

然后什么在server中对age进行数据过滤，这没有索引，开始之前有了，索引下推之后怎么做的，直接，根据name和age，从存储引擎中筛选对应的数据返回给server，不需要，做数据过滤，明白意思吧。

就这意思不要数据过滤好吧，这个叫索引下推，所以你把这东西想到之后，你再联想一下，刚刚最上面我给你画了个图，它下推是现在的什么的，下推，这是什么是下推是吧，原来在server层。

我要对age做的下推挪到了哪，挪到了存储引擎层，明白意思吧，从server层度到存储引擎层，什么叫有了，什么叫没有，在MYSQL5。6还是5。7之前，是不包含索引下推这个东西的，是5。6还是5。78。

我忘了一个版本了，忘了这个版本之后，它才具备了索引下推这个功能。

当然这个功能是不需要用户开启的，它默认是开启的，有一个属性。

叫啥来着，叫。

Switch，我来看啊，有一个东西叫索引下推，这个叫index，肯定是不知道它默认是开启的。

默认是开启了，在5。7之后默认就开启了，所以你不需要管这些东西，你大概知道，所以下跌是什么意思就可以了，明白意思了吧，这叫顺应下退，没别的意思，来直接点看学校的同学给老师扣个一，能看懂吗，没问题吧。

好了，当这些东西都没问题之前都都没问题之后。

下面我们要说一个东西了，说啥最后一个问题，刚刚讲了这么多，讲这么多是吧，如有有啥用来告诉我索引下载有用吗。

所以下载有用吗哈，它的数据量是一个级别吗，你只匹配内是把所有name匹配的数据返回回去了，还没做数据筛选，你把name和age两个东西一起数据筛选，看筛选完数据是不是少了，你IO量有多少，少了吧，好吧。

好了聊完这东西之后，下面我们来聊最后一个东西，这个东西什么东西，所以优化我刚刚讲那多东西了，讲那么多东西了，我们在回答索引优化问题的时候，我到底应该怎么去回答，你不要上来之后。

你不要上来之后就给面试官说，我通过判断之后发现我们的索引，我们索引那个我没，所以没有失效，所以我加了个索引字段，你这样去描述是没有意义的，你告诉我这个，所以这个优化问题我应该怎么去回答。

没有你所学的知识能回答吗，能不能回答，大家永远记住啊，你在回答优化问题的时候，你要给人的感觉是什么，是你真真正正的你做过优化，而不是说我从网上随便看了个帖子，我就能把优化的问题给大家说出来，不是这样的。

你要怎么去判断这件事情，非常简单，来听好了，这样的方式回答在之前，做叉叉项目的时候，我们有一个表，数据量非常大哇，千万级别，千元级别好吧，写了一个非常简单的SQL语句，就是一个条件，过滤好吧。

但是查询的效果非常差，花费了十几秒，通过分析之后，我发现通过查看执行计划后，也确实用到了索引是吧，而且查询条件非常简单，只有一个，怎么办，只有一个，怎么定义优化，能优化吗，啊怎么做。

利用前面所学的知识组合索引对覆盖话费，剃头说的非常对，现在可以说一下，只有一个经过分析发现我要查询的字段，字段用四个字段好吧，但是这四个字段啊，而且这四个字段包含了查询的某一个查。

包含了查询的包含查询条件，因此不考虑减少回表，因此考虑在查询过程中出现了大量的回表好吧，此时将所有的查询的字段，和条件是组成了组合，所以是达到了优化效果是执行完成之后，只需要。

花费一秒左右就可以完成查询，你这么说吗，开始说绝对录播了，今天我看过对，是录播，我不是一直说录播吗，一直说录播吗，看到吗，你能这样说吗，好同学们能能不能这样说，谁说就能扣一，不能扣二能吗，不严谨。

那不严谨吗，我上课临时写了吗，你觉得哪编辑不能自己去优化，能不能自己再编一下，能不能带上你自己的业务量，带上你自己的数据量可以吗，可以吧，我这没问题吧，好吧，哦1000万数据加索引要DBA来。

要DBA1来没关系，你后面可以再加一个补充大量数据，添加索引字段信息的时候，可能会出现锁表情况，所以我跟那个那个，所以我提出建议使用什么，MYSQL提供的在线DDL操作，来完成添加索引的功能，行不行。

可以吗，这有漏洞对吧，给你补上了吧，有什么东西吗，可能都不知道，这东西在线DDLMYSQL，5。6版本之后出现了一个在线dd2，你可以给它进行索引的一个添加，没关系的，这个具体的东西下去自己看明白了吗。

这可以了吧对吧，你黑马加嘛，我只是给了大家一个案例，我我并不是想把这个例子交给你们好吧，因为我既然公开课上讲到这玩意了，这玩意儿就烂大街了，明白吗，很多人都会抄走，很多人都会有这个东西。

所以这东西不是你的加分项，加分项在什么地方是这样的描述方式，你在写的时候一定要突出什么几个点，同学们记清楚了，第一个叫实际场景，你需要进行切换，第二个第一个是场景，第二个是什么是问题的情况。

第三个是优化的方式，和你和思考思考的过程好吧，第四个是达到的效果，能懂我意思吗，这是你在回答对应的优化问题的时候，你整体的思路，你要以这样的方式去回答，而不是上来之后不要用三星，再用索引。

不要这么去描述，能听懂我想教给你的是啥吗，来听一下同学给个一，能不能听懂，所以你把这种方式画出技巧，学会了，套用上你之前项目里面的案例不就完了吗，我不记得你们项目里面没有对应的SQL优化案例。

不可能没有吧，光我现在学生问到我了，我给你看一个实际的案例好吧，一个学生之前问我的，它实际公司里面的应用场景出现了问题，这数据量消耗比较慢，我给你看一下这个这个太太多了好吧，再往下看叶学生问我的。

李老师打扰你一下。

来看一下干什么事，这个学生他的情况也非常简单，这是对应查询语句，SD什么cell number cancel，什么什么chinese name，Type of，Type of product，这不多吧。

这句能看懂吗，能看懂吧，我觉得这一句已经非常简单了，执行完成之后，他花费的时间是多少，0。104秒，我问一下这个0。104秒是快还是慢，快还是慢，大哥们负点责任，你们在说快说慢的时候。

能不能问一嘴数据量，他过亿的数据量还还卖吗，别上来就慢慢快，你问一下数据量吗。

对不对，所以下次问一个问题，他说打扰你一下，他说这个表总共才35万，数据category id等于6980，有26万条好看的id。

也要有索引字段了，好吧，我发完之后，他给我发了什么，发现它对应的执行计划，杜老师，你看这个真心话，这样的这个字段明显用到了索引，不是没有索引。

用到了用到索引了，但是效率依然很低，不太能满足我们的业务需要怎么办。

我看完他之后，我说我可以OK，你可以考虑关闭一个属性叫index merge，我我刚开始怀疑啊，他可能触发了一些索引合并，所以导致他出现了一些问题。

好吧，做完之后他说老师运行完了还是100多秒，没有任何变化。

0。106反而还慢了一点，我觉得这个这东西肯定不行了对吧，再给他进行优化，我说这有组合索引吗，可是没有组合索引，我说你创一个组合索引试试是吧，我创建完之后，他说还不行，我说把排序再去掉试试。

看是不是排序的问题是吧，做了一堆，做了一堆检测完啊，都不行，还是一样，这东西是要慢慢去调整的，这次是0。1118秒，还是很慢好吧，再优化再优化。

我说你加上这个东西，再加上排序，加完之后，这是它对应的结果，再看看效果什么效果，我们除一下吧，0。106÷0。006，快了17倍。

看明白了吗，就快了，这么多，自己都自己都惊讶了，明白了吗，这是对应的数据吗，所以你要想明白说我要在哪些地方去进行优化，我要去调整哪些地方，你别两眼一抹黑，硬猜，我最怕什么东西，你知道吗。

很多VIP同学找到我说，梁老师，你帮我看一下这个色素语怎么优化，你发给我，我也懵逼，真懵逼，我根本不知道怎么做，你想你发给我一个那么复杂的SQL语句，然后你让我说，老师你帮我优化一下，我咋能给你优化呢。

我是个人，我又不是个神，你懂我意思吗，这经常说的一个一个很重要的一个问题，好吧，等下我给你找一下午一个同学，今天下午一个学生刚给我发的呃，找一下，就这个，我等会儿等会儿我们看这个SQL语句啊，我跟你说。

看完四个句，我自己心态都崩了，还没翻到，等一下看这个，这是他给我发了一个SQL语句，从select开始往下走走走走走，你去看这个SQL语句，你去看，这最后一句，来你告诉我这样的语句，你告诉我。

你让我去怎么优化我，我我打电话，你告诉我怎么做，一枪就一枪没完，你告诉我能优化吗，我又挂不了。

我是个人，我不是个神，好不好，所以你们要搞清楚这个东西明白了，所以不同的案例你要去分析它，说到底哪出现了问题，应该怎么去做，这些东西应该以怎样的方式进行优化，这才是最关键和最核心的点，明白了吗。

啪啪都打结了，不是打结了，这个东西展开了，微信里面可能看的比较长，微信里面看的比较长，打开之后大概几十几百行，但是依然很很麻烦，是不是，不是故意难为我，我在公司里面见过最长的一个一个搜索页，搜500行。

系列 5：P78：78、如果通过索引知识来进行优化？ - 马士兵学堂 - BV1E34y1w773

下次不允许，这很正常，所以你们需要说的是什么，我需要给你讲啥啊，不是让你们去说这个SL语句长度的问题，而是说你们在进行优化的时候，不要两眼一抹黑，明白吗，最害怕的就是这玩意儿啊，你要干嘛。

哪怕SQL语句，SQL语句再复杂，不管它多么复杂都没关系，你要学会去做拆分，你要自己学会去拆分，你要一层一层的去迭代，一层一层的去搞这些东西，反正你也做了，这才是最关键，最核心的还是封闭生命干啥。

这很正常啊，好多表在关联这这这这复杂一点，复杂点也正常吧，明白意思吧，所以掌握合理的方式方法地点很重要啊，包括你们在提到这些优化问题的时候，再好好去思考，一定要按照我说的这个思路你去进行处理。

如果你把照这样的思路去解决的话，真的很麻烦，真的很麻烦，不要上来之后，老师你帮我调一下U哎我咋调都调不了，好吧行了，这东西啊，咱们大概就聊这么多吧好吧来，其实今天晚上有收获的同学给老师扣个一吧，好不好。

讲了两个多小时啊，我觉得我讲的已经够多了好吧，老师数据量过亿，增加索引会非常慢，有什么好的方式吗，没办法，就是用在线DDL的方式来加索引，这个没别的招，动作框架慢就慢，这个没办法好吧，我们打扰一下。

现在几位是不是应该分表了，举个例子，10万的问题比较合适，低于多少条加索引反而应该写C罗，我觉得是这样哈，帮主听好你的问题，我们一般情况下数据量过千万级的时候，就要进行分库分表了，但这只是一个预估量。

它没有明显的一个数据统计，你过期了，你还要判断一件事，除了过千万这个级别之外，你还要判断什么东西，你要判断一个点，您每一行记录占用的空间是多大，每一行记录你一个一行记录里面。

十个字段和50个字段和30个字段，效果一定是不一样的，所以不一定说过千万，我就要分部分表，这东西是干什么，是根据你实际的需求来判定，当你发现你的表数据变多之后，你查询不管怎么优化都优化不了了。

这个时候可以考虑添加我们对应的哦，可以进我们的分工分表，但不是说我一旦过千万之后，就一定要分出去秒，这也没这么说的，你这么说的好吧，如果my mysql中某个字段是汉字的话。

在汉字键索引该B加数是汉字的话，怎么保证有序干嘛吗，字典序嘛，念文就字典序嘛，数字就是数值嘛，汉字的话要嘛嘛，但是建议不要用汉字，不要用汉字，汉字的话这个太麻烦了，好吧好吧嗯行了，这东西啊。

咱们大概就聊这么多吧，这只是MYSQL里面的一丢丢或者一内内，刚刚也给大家提到了相关的一些优化的问题啊。

给大家看一个文档，就是之前我在讲这个MYSQL优化课的时候啊，大家看一下，这叫MSL调优，讲MYSQL调优的时候给大家讲到的一些细节，上面的一些点，大家看一下，你条件里面包含的东西非常多。

你不要上来之后就想着说我要加索引，最优化的时候，你可以分几个维度和几个细节，比如说你关于MYSQL性能的一个监控是什么样子的，对吧，你对应MYSQL的一些呃spammer表结构是什么样子的。

你的索引要怎么进行优化，包括你对应的SQL语句要怎么调整，包括你的参数要怎么去优化，怎么去调整，包括你是不是要加分那个分布式的数据库。

这东西都要合理判断好吧，沈阳马天志说，看不到我说话吗，对看不到的，因为是录播，所以看不到，好吧对，开玩笑，画风有什么软件啊，我刚说过嘛，分页云笔记，枫叶云笔记是直播，是直播，哎呀是直播啊，那你不理我。

没看到你发的消息啊，你发啥了，没看到梁老师结束的时候，可以谈一下不同的存储引擎，对于事物的知识区别吗，可以另外点一下锁，来说一下它们的区别呃，我之前讲过这东西，我想在哪讲，我找一下。

我记得之前讲过这玩意儿，好像，注册的，对，装一下，所以，太多了都忘了，看这图吧，这是之前画的一张图啊，就是关于这个组合是这个mysql max和WINDODB的呃。

首先第一个索引类型mason里面只有非剧组索引，印度地域里面有剧组索引，也有非剧索引，第二个事物呃，my sum是不支持事务的，印度dB是支持事务的，第二第三个表所my sum支持表锁。

印度dB也支持表锁行锁，my sum不支持，但印度dB支持外界MAMATHM不支持，in NO dB支持学员索引，MATHM支持，然后应用db5。0之后支持操作，大量查询的时候用我们的my sum。

然后增删改查的时候用印度dB，但这东西啊，坦白说一般情况下印度dB用的更多一点，其他用的并不是特别多，好你大概了解一下错了，OK所有东西啊，咱们明天讲吧，明天我讲一下事物相关的点啊，讲下事物一些特性。

检查事物特性的一些实现原理，讲一下MVCC，咱们到时候再聊好吧，老师有主从知识吗，有主从的话，我讲过主从复制，然后讲过读写分离，讲过分部分表都都讲过哦，包括像mt这样的东西，我也讲过好吧。

就是你学生问你的那个，有学生问我，那个为啥那个索引添加之后排序变坏了，就减少了回表嘛，就减少了回表，就是减少回表那个东西我没公开课，那那个那个不是主从，这东西我公开课没讲过，都是在VIP里面讲的。

公开课没讲过，来看一下吧，这里面有一堆的文档可以给大家看一下，就是比如说主动复制的原理，我之前写的什么主动复制原理是啥，怎么去复制的步骤是啥，形式有哪些，然后只能复制延时应该怎么去做，这应该都提到过。

都讲过这个东西好吧，包括他的一些安装配置，你要怎么去配，搭建的时候要怎么去搭建详细的步骤，这些东西都有好吧，他那也是减少了回表的产生，就这么干的是吧，然后包括像mcd shing spare，我也讲过。

讲过，OK笔记能发下吗，笔记不发了吧，发吗，写这个东西要发吗。

再说吧好吧，都发下来吧，那么多markdown想多了好吧，就发OK好了，今天的这个具体干货，咱们就聊这么多吧好吧，下面呢聊点更好玩的东西，聊点什么呃，不发怎么学，听我讲的东西，你就慢慢消化吧。

不发你那那那些都发了，跟VIP同学太太不公平了好吧，下面聊点好玩的东西吧，聊点好玩的啥，呃刚刚给大家讲了MYSQL相关的东西，我刚才给大家看了下MSL调的一个文档啊。

呃下面给大家说一东西，就是呃你在学基础的时候，或者你在学习的时候，到底要怎么去学习其他广告，我不不打广告，我们就聊会天，我们不卖课，今天不卖课，不给大家找广告里面点好玩的东西啊，就是聊到一个问题。

你们觉得我今天讲完这个课之后，你们都觉得收获比较大，我能学到很多东西，这样我想跟大家说一件事是什么，希望大家在以后学习的时候，能有一个很重要的东西，叫什么叫方向性的东西，这东西啊我觉得是比较重要的。

什么意思啊，有很多同学听完我这个讲的东西之后，你觉得我把所以讲完了吗，或者你觉得我把索引讲完整了吗，其实没有，就是所有里面包含的东西还有很多，这只是其中的一些细节，或者一些比较重要的部分。

或者面试中问的比较多的东西，我优先拿出来给你讲，但其实所有里面包含的东西还很多，所以大家以后在学习的时候啊，你们既然晚上来听课了，意味着你们平常的时候，自己可能也会学点别的东西，包括以后琢磨点东西对吧。

一定要一直在不断的学习，那么我想说的是什么，你们在学习的时候一定要有一个方向，同时一定要注意一件事，什么事儿叫体系化学习，体系化学习这件事情是非常非常重要，什么叫体系化学习嗯，很多同学出去面试的时候。

应该收到过一些评价，比如说知识碎片化，比如知识不成体系，一定收到过这样的一些评价，这些评价都反映了你在学习技术的时候，你自己存在的一些短板，所以我希望同学们在学习的时候，一定要有一个体系化学习啊。

就是不要说我今天学一点，明天学一点，后天学一点，但是学的东西都不一样，这是最可怕的一件事情，包括我们的VIP也经常问我一个问题的老师，我在学技术的时候，我是多个技术，并行的学，还是说我学完某一个点之后。

我再去学另外一个点，你们觉得哪个好一点，你们觉得并行好，还是单独学一个好，语法一般都是看到什么学什么，告诉大家，我个人的建议，大家在学习的时候一个一个来，你千万不要同一时刻看三轮新技术。

或者看N门新技术或者看门技术，千万不要这样，这边一定要一个一个来，因为11111堆东西堆到你这之后，你很麻烦，或者你看起来会很容易忘，或者说学习效果是非常非常差的，学习就是把某一个体系，某个体系学完了。

还有一个点，还有一点也很重要，一定会用到自己的一些知识盲区，老师讲课的时候一定会提到一些点，当你提到了一些点之后，你会发现一件事，什么事，这些东西我不会，那东西不会那么很多同学会干嘛呢。

会从这个点里面离开，把我要搞明白的东西，我搞明白之后，我再接着来学习，有多少人是这么干的，有吗，就比如我学MYSQL，昨天讲了一个OLAP，我不知道是啥意思好了，我去学OLAP，我把OLP搞明白之后。

我再回过头来学MYSQL，这种方式也是大家非常非常要的，就一定要摒弃掉了，我刚才有好的方式是什么，你在学习技术的时候，学习技术的时候，先去过一遍整体的知识的总体概括，概括完了之后，当你不会的点。

拿一个本或拿一个文档，在线文档把它给记录下来，你把它记录下来之后，接着往下学，等你有时间了，一些零碎的时间，额外的时间之后再去补那些你不会的点，千万不要让自己跑偏了。

也有可能有很多学生是学生是这样学习的，他沿着一条主线去学习，学着学着发现东西不会了好了，我从中间分一条叉出来，对方从这分段拆出来，然后又有同学说，老师这个东西我也不会好了，又分叉出来，又回到了出来。

有些同学还比较好，他能回归到主线上面去，但有很多同学你是回归不到主线的，你学学pp了，明白吗，你学完之后就变得很麻烦，你懂我意思吧，所以这些东西才是你要摒弃一些点，这都是学习方法上面的一些小技巧。

然后除了这个东西之外，约等于1米8，说有详细的路线分享吗，呃想要路线，一会儿我可以给你，但是我在讲路线之前啊，我还想再说明一个东西，或者再说明一件事儿，你们有人对学习路线有疑惑吗，老师我现在要学。

要学什么东西，有疑惑就要扣一，没疑惑的，扣二有疑惑吗，都有是吧，当你在有疑惑之前，或者说当你在要路线之前，路线之前，我需要你们先做一件事情，什么事情，这东西，叫定位，你们知道什么定位吗，什么叫定位啊。

谁能给我解释一下，目标菜头师，目标是全站，想保全站，同学，我建议你换一个换换换一个目标好吧，先生东西叫定位，什么叫定位啊，现在啊这个技术它它太多了，明白吗，就是你要学的话，你根本学不过，你根本学不过来。

这个学起来是非常非常吃力，而且他学习的时候，他不一定能收到对应好的效果，所以我非常不建议说，你真的是把所有句都学完了，但是你一定要有一个定位，定位什么意思，自己处于哪一个水平。

之前我有一个VIP学生报名了，报名之后让我做规划，规划的时候说，老师我现在年薪14K年薪是不是月薪14K，我想冲明年冲击年薪50万，你觉得可能吗，挺好啊，现在预计14K明年冲击年薪50万，你觉得可能吗。

不可能太难了太难了，真的太难了，好吧，记住一句话，叫饭要一口一口吃，路要一步一步走，技术要一个一个学，所以我为什么说你要定位另一个老师，那我现在到底处于初级中级，高级到底属于哪个哪个阶段。

我没法去判断啊，很简单，现在国内或者说现在的市场市场，商店没有一个明确的标准，说你掌握了什么技术，你就是一个初级的掌握了什么技术啊，就是高级的掌握什么技术，就是中级的，没有这样的评标准。

但是有一个标准是存在的，什么东西叫职级，你们知道吗，当你们进到大厂之后，一般情况下都要有职级评级的，是最简单的题题，举个例子，比如说阿里的我们从P5到P8，对不对，这就是最基本的一个直接像你上网搜。

你是能看到很多，对于不同职级的一些技术要求的进行更改的，当你掌握好这些东西之后，你可以对号入座，你自己现在大于位移某一个水平，同学们来方便同学，你可以给我发一下，你现在的工作年限加你的薪水。

能方便发一下吗，我觉得今天晚上大部分来听课的同学，你们大部分人的就是薪水等级，或者说你们大部分职级应该处于一个中级往上，稍微多那么一点点的一个阶段，就可能很少有那种高级这样的。

一个一个一个一个一个一个水平的学生，因为接下来要讲的东西其实并不是特别难，它其实属于是一些基础的必备的常用知识，9年16×14，在合肥3年十五六年10万和6。5K实习，刚毕业10K哇。

JA80K合肥java，大家发现了，你们其实大部分人其实应该处于的是什么，是P5这个级别什么意思，我能去做一些独立的开发了，我对我们基本的一些框架，比如说SSM对吧，比如说spring boot。

比如说spring cloud这些基本的应用是没问题的啊，基本应用是没问题的，那其实你当你了解完这些东西之后，下一步你就要考虑了，我老师我要掌握P6，或者说我要达到P6这个级别，如果要达到P6级别。

那P6我应该具备什么样的能力，或者我应该学什么样的技术，当你聊到P6这块之后，下一步开始聊什么，聊路线的事情，明白吗，所以不要把这个前后的顺序给颠倒了，很多同学就是因为把前后的顺序颠倒之后。

导致你学起来一直处于一个迷茫的阶段，迷茫阶段哦，不要迷茫，就一定是先搞清楚你自己的定位，就是我做事情一直是这样的，第一步先有一个定位或者分析，分析完之后，第二步数据对应的目标，网站的目标是小目标。

不是大目标，比老师我要年薪百万，老师我要领取白富美，别扯淡，我现在45K下一份我就要20K，我就25K，这是比较现实的，一上来就我架构师，我年薪百万，你是尺度的，我才知人狂笑目标28岁才富自由。

这个梦做的有点大啊，并不是达不到好吧，但是比较难，所以先树立一个小目标，比如先赚他一个亿，是不是这个意思，现有目标，有了目标之后，下一步干什么事，干什么，这叫制定计划，明白吗，对吧，当计划完成之后。

下一步才是什么东西，就算一件事叫落实，张老师，当然这里面最关键，什么叫定下一个目标，你还没干呢，就定下一个目标，等这些东西实现之后实现了，然后再回过头来搞搞定位，搞目标是这样的逻辑，你还没干呢。

你就定下一个目标干嘛，一点意义都没有，明白意思吗，你们以后在学习也好，干嘛也好，一定要遵循这样的一个路线，这东西我觉得这行为有效的啊，当然这里面最关键的是什么，是这个步骤目标，你的目标不太远大。

不要太红的，对这个实现不了，不要对这个东西没意义没意义好吧，最关键的是什么，你要树立一个你能好吧，经过一段时间努力之后，你能够得着的一个目标，而不是一个痴人说梦的目标哇，这才是最重要。

最最关键的是年龄不是问题吧，年龄又会有问题，但是你要结合你自己的情况，在最短时间之内达到你想要的东西就完事了，就这么简单，所以把这东西你要想明白了，不要去抱怨卷这件事情了，卷是常态，明白吗。

你是改变不了卷这件事情的，所以你能做的事情只有一件事，你去改变你自己，而不是改变卷这个现现状，既然这个行业动态改变不了，明白意思吗，你要改变的是你自己，所以当你把这套东西搞清楚之后好了。

我们再来聊路线的事情，也就是说这个计划的事情，我说老师那P6应该学什么东西来，有人好奇P6要学什么吗，好奇给老师扣个一，有没有人好奇，地址不能说年龄大了怎么办，好了，一会儿我们留出点时间。

你们把你们的个人情况告诉我，咱们一会简单聊一下你们个人的规划，我先告诉大家路线是什么样子，路线什么样子好吧，P6年薪多少，P6的年薪大概是40万到60万啊，当然前两天我听曹老师说。

阿里出了一个P6的顶薪，大概是90万，信这个底薪90万，但这个很难了很难了好吧，他不是一个短期内能实现的目标啊，所以你需要的是什么，比如说这个地方P6他看中的是什么，PC他看中的是什么。

你要做到心里有数明白吗，P6需要是啥呀，其实非常简单，给大家看一下，这里面其实就对应路线注意了，P6它针对的是什么操作与落地，明白吗，什么叫操作落地，这个操作与落地里面包含了非常多的东西。

我们一块合一下就能把你们吓到了，好吧，这是PU里面P6里面要包含的，相关的核心竞争力和核心知识点，好吧，比如说现在你要想达到P6的话，你要有一些自己的前置知识，什么叫前置知识。

比如s m spring boot，我能做一些独立的开发对吧，了解一些新特性什么之类的东西是前置知识，我觉得基本上你做开发了都要具备这样的能力，那再往下看，你还要掌握什么，掌握一些底层技术。

比如说操作系统的，比如说计算机组成原理的，比如说网络的，比如说IO的，比如说LINUX的，比如运维的以及数据结构和算法的东西，这都是你要掌握的必备的一些底层的技术，现在面试他就问这些，其实不单单是P6。

你再念一些上规模的公司的这些开发的时候，中高级职位的时候，基本上都会涉及到这些东西是吧，再比如说并发编程，你要了解操作系统的并发支持队列的东西，内存模型的东西。

线程池的并发集合的cs sr local的，GUC的，GMH的，你都要掌握是吧，华生总说，掌握的话要掌掌握到什么样的一个程度，你要能把这套东西形成自己的一套知识图谱，或者说知识体系或者知识体系。

什么意思，我一样可以给大家看一个东西，就是我们之前VIP他自己做的一个笔记，他在学JVM的时候，他做了一套东西，我给你看一下，不是能描述出来，当你学完一个东西之后，你如果能把笔记做成这样就OK了。

在我的评估范围内我就OK了，这是这个学生，他学完JVM之后，他自己画了一套笔记，我做了一个自己的JVM思维导图，如果你能做成这样子，我觉得你就学到位了，这么简单，还是那句话，你要掌握是什么。

同学们永远记住这两个字，叫体系，能懂吗，不是某一个点，不是问到垃圾回收器的，我知道是个啥，那你能不能理解，同时更好知道是啥，不是这些东西，你要对各个细节你都要搞明白，我可以给你放大看。

每个地方都是他做的一些详细的东西，看了吗，做的很清楚啊，参数也好，调整也好，什么东西啊都做的非常完善，非常完整，这才是你应该掌握的哇，你要能形成这样的东西出来，所以就说当面试官问到你。

不管问到你什么技术的时候，脑海里面啪能打开一张图，图里面包含了非常多的东西，他只要问到相关点了，你能侃侃而谈，这才是最主要的是吧，那现在应该很牛吧，确实很厉害，确实很厉害哦。

所以这才是你们需要学习的东西对吧，这是并发编程这块，除此之外你要掌握一些通信框架的一些东西，比如说the paper里面通信double对吧，RPC的rust thrust的好，net些东西都要掌握。

从中间件你要掌握rock mq卡不卡对吧，都是必备的基础，包括像中间件的一些应用，Mem cch，还有这个REDIS对吧，包括你要掌握一些软件设计的，一些基础的理论知识，设计模式，软件工程了对吧。

敏捷开发了对吧，一些文档案例编写的都要有，包括你们的分布式架构实践，分布式架构时间，不单单里面包含什么分布式事务，分布式锁，分布式id了，不单单包含这些东西，还包含了一系列上分布式密度，分布式绘画。

分布式任务，分布式权限控制，分布式预警系统，分布式链追踪等等东西都是你要进行掌握的啊，包括你要掌握的微服务对吧，注册发现了网关路由了，服务调用了负载，均衡了NFLIX，阿里巴巴了都要掌握对吧。

以及性能调优的CVM调优，MYSQL调优，tomcat调优，NGC调优对吧，海量数据存储的对吧，E的肯定house mysql news ttv的，对不对，包括我们搜索E的，对不对。

包括像海量数据处理的一些东西，flink high的东西，包括像运维的，你要了解一点啊，DT你要了解一点，然后测试的你肯定要稍微了解一点对吧，service nt东西了解一下。

所以这些东西都是你要进行储备的，明白意思吧，也就是说，如果你想达到P6这样的一个技术实力的话，那么这些核心点就是你要处理的东西来，觉得多的同学对吧，我扣个一东西多了，那你们觉得多不多多吧很多吧。

这些东西你都需要学习吗，啊你需要把所有的东西都一口气学完吗，需不需要，我告诉大家，如果谁想说，我要一口气把这些东西学完，我觉得你肤浅，为什么技术这东西它是没有边界的，明白吗，你今天学完一个东西。

明天可能出一个新的东西，你永远学不完，那你要学的是什么东西，学的是啥东西，掌握你现在必备的基础，那么你可能会疑惑，老师我现在必备的是啥，这里面有你一点都不会的吗，有没有你现在一点都不会的。

你能不能抓紧时间学，能不能从这些模块里面挑一些东西拿出来，优先去学习，能不能可以吧，这是没问题的对吧，你能不能给自己固定一个时间轴，就刚刚说的，我这一周的目标或这一列的目标，我要把什么。

我要把并发编程搞定，下一个目标，我要把中间件搞定，再下一个目标，我要把什么东西搞定，能不能做这样的东西，不怕你不干是吧，就怕你什么，就怕你们瞎干，盲目的干，明白意思吗，所以当你这个东西给到你之后。

你能不能有明显的一个路线或大纲，在当你有这样路线之后，你一块一块学不行吗，好吧，虽然说可以，但是不知道选哪些，不知道选哪些，也非常简单，也非常简单，怎么做，我告诉你第一路线给到你了，你从这个路线里面诶。

我问一下，有人想要这个路线吗，想要给老师扣个一，有人想要的，谁如果想要的去找咱们的班主任老师，找他们去领取，扫这个二维码，扫码器进行领取，能明白这个意思吧，层面进行领取。

如果你之前加入咱们任何一个咨询老师，转发领取也是OK的，也是OK的，明白意思了吗，好吧，我要说的是什么，当你有这东西之后，你可以自己从里面选择一些你不会的点，但这是一个方式，除了这样的方式之外。

还有什么方式，我再解释一下，还可以干一件事，你找一个领路人，找一个你的师哥师姐，找一下你的一个领导，让他来根据你个人的技术实力，帮你从里面能不能提取出一些关键的点，有没有这样的人。

如果这样的人也没有的话，那我告诉你，你就需要报名马士兵教育的课，什么意思，你不知道，没关系，老师知道，我们会告诉你一步一步你要怎么做，你懂我意思吗，是哪个马3C差了好多，差就对了。

人不怕自己说我现在混的差，而最怕什么，最怕不自不自知，明白吗，就我不知道学什么了，所以你要掌握的是什么东西，把这些关键的核心点你要知道我哪缺乏了，我要把什么技术给弥补起来，这才是最主要和最核心的关键点。

听明白了吗，所以如果有需要的话，是专门设计领取好，详细看一下东西，我说了东西很多，但不需要你，你你每个挨个都选一下，刘老师可以帮你慢慢的捋出一条适合你自己的，独特的路线，而且每个人的目标是不一样的。

所以你每个人需要储备的技术，也不是也是不一样的，如果你真的把这些点都学会了，在P6级别里面，你真的可以拿到顶薪，明白了吗，顶薪难度最高，这个东西完全不夸张好，这才是你要储备的，这只是P6这个职级。

这个级别你需要储备的，有人想看PC吗，想看P7的，给老师扣个一，想看吗，就PC我需要掌握什么样的技术实力，这是P6的P6层高是什么叫操作与落地，PC想要什么叫原理与设计。

这里面我们依然包含了一系列的东西，哇先合一下好吧，然后什么第一个叫分布式设计的理论基础，这里面包含了一些像CAP的puzzles了，rap了啊，跟SIP了这样的一些协议，第二个你要掌握一些核心的算法。

分别是架构相关的算法和机器学习的算法，第三个你要掌握一些框架的原理，所以全家桶多好，my BIS对吧，他们看似cod的m q net hosport e l k的，你都需要掌握。

这些东西是包括一个高性能架构设计，什么叫高性能架构设计，比如说分流设计怎么做，服务并行并发怎么做，缓存设计怎么做，存储设计怎么做，可靠性设计怎么做，应用保护设计怎么做段位高点。

再比如下面还有一个案例驱动设计，我们这里面提供了一堆的项目设计的课程，比如说每秒数是每秒数10万，超高并发通用设计专题，有一堆的案例告诉你怎么去设计好吧，应该用什么的技术键，技术站进行相关的一个搭建。

比如说有N个九全链路，高可用通用设计专题对吧，有云几百万年薪好吧，案例驱动式架构设计专题对吧，由我们的一级流量，多级缓存的架构设计专题，那这里面我们更多层次性，不单单是那些比你基础的技术实力了。

或基础的应用了，更多强调是什么，就是我们整体的架构设计能力了啊，这才是你能拿到PC这个级别，最最最重要和最最最核心的关键点，明白意思吗，除此之外，这只是P7的，这边还给你搭配了一堆的项目的课程对吧。

有一些用户中心的，有一些架构设计的，比如说我们有一堆项目课，有些网多人在线网游服务器的对吧，东方商城的有没有飞机出行的，有推荐的，有流云平台的对吧，这都是你要讲的相关的核心点，讲数据库连接池了吗。

讲了数据连接是最最基础的内容吗，肯定要讲了，包括有人说老师我现在技术学完了，我需要准备面试怎么办。

没关系。

系列 5：P79：79、事务的四个特点是什么？他们的实现原理是什么？ - 马士兵学堂 - BV1E34y1w773

刚说的东西，假设两个日志啊，我明确了都要记住，我如果先写redo log，谢谢他，然后再写blog对吧，先给大家再给它这样两个方式，如果再这样写的话，这里面会有一个问题，同学们听好了，什么问题。

如果我写完redo log之后，突然写了个G，还没来得及写编lo的时候，我突然断电了，这时候会发生什么情况，写一下，刚写完redo log，没有写完blog的时候，会有什么情况发生。

你觉得会有什么情况发生，注意啊，我的read log里面写完了，写完之后，我一定会把它译写到我们磁盘里面，就算我在一起的时候突然断电了，我的read log里面只要有数据或只要有对应的记录，我在哪。

我是可以根据redo log来进行重启的，但是你要考虑一件事，你写完的redo log，你的blog里面是不记录对应信息的，那这个时候假设你有两台机器，A的操作，A机器和A服务A数据库是吧。

然后B数据库，是通过什么blog来进行数据同步的，此时你考虑清楚了，当他写完了，他没写完，你的B数据库在同步数据的时候，会不会代表这一条数据，会还是不会，对外，不会如果不会的话，就会出现一种情况。

什么情况，你的A数据库里面已经做完了这条更新操作，但是你把blog同步到B机器的时候，你的B机器里面并没有这个操作，你告诉我你ab两个机器里面数据还一致吗，一致不一致了，不一致了吧。

那不一致你的主从同步不就失败了吗，不就存在对应的一个问题了吗，是不是这意思啊，所以它是不可以的，不能先写redo log再写blog，那其实反过来道理也是一样的，如果我先写个blog。

然后后面我再写我的RELOG，这样的情况一样的吧，什么叫一样的，想好了，我先写完blog，然后没有写完redo log，这时候我们什么情况，你blog里面记录了对应数据VLOG，记录了对应的数据，好吧。

B机器我B服务器B已经将数据同步，但是REDUG都没有，此时如果出现了凡是save，或者说如果出现了断电，出现断电之后，你告诉我，你能够根据blog把数据给恢复回去吗，这个问题啊，你当你断电之后。

你能够把你根据BINLOG把数据给恢复回去吗，能不能，不能吧，里面那数据嘛肯定恢复不了，他恢复不了，意味着AGG是A的数据是有问题的，少一条，但是你的blog已经同步到B机器里面了。

B机器里面是不是会多一条记录或多一个操作，那此时你的AB两个里面的数据还一致吗，一致不一致啊，不就又不一致了吗，是不是意思，所以不管你先写redo log还是先写blog，它都是有问题的好吧。

所以这种机制有问题，因此才诞生了我刚刚给大家展示的东西，什么呢，叫两阶段提交，什么意思，我先写redo log，只不过此时我的read log，它处于的是叫prepare这个状态，然后我再写blog。

当我把blog写完之后，我事务提交了，我再把我们的redo log置为commit状态，那在整个这个执行过程中，依然在任何步骤的时候，都有可能会出现断电情况，比如说这如果断电了，可以了，听好了。

这如果断电了，当这断电之后，我需要做什么判断它的运行机制是这样的，听好了，如果在此处出现断电了，那我在恢复的时候，我会先检测我的redo log，我只是do log里面状态。

我检测log之后发现当前的RELOG属于PREPA状态，当它处于prep状态之后，我再去blog里面找对应的数据，比如blog里面是否同步记录了与之相同的操作，如果有，如果有。

那么此时把刚刚redo里面的prepare状态，改成commit状态，如果没有的话，干什么事，把刚刚redo log里面的PDD这条日志，直接置为失效，我直接认为无效数据，这样的话。

我的redo log和我们的blog，能不能保持保持数据一致，可以吧，是刚刚这个锻炼的过程那一样的，在下面这个步骤里面，它也可能断电，当它翻面之后一样逻辑啊，我先找log，我一找诶。

发现一个log里面有prepare状态的数据，这时候我在找blog里面找我一找blog，blog里面是不是有对应的记录，有对应记录怎么办，把刚刚的prepare状态的数据改成commit状态。

这样的话两条数据记录都保持了完全一致，所以不管你依靠哪个数据来进行，数据恢复的时候，它都不会出现数据的不一致性的问题，这东西就称之为叫两阶段提交来，这东西TM同学给老师扣一，能听懂吗。

所以啊这东西在面试中也会经常被问到，你要给面试官把这东西给讲清楚，它对应它对应的东西，老师redo和blog fpl的方式能替换吗，不可以，因为blog它没有prepare这样一个状态。

blog没有prepare这样一个状态，没有prepare一个状态好吧，所以他不可以互换位置好了，这是个两阶段提交，这东西我知道这么多，所以当提到log的时候，你要把blog整合起来。

了解一下它的两阶段提交就可以了，VLOG在server端链中还有吗，它是持久化到磁盘的，怎么会没有呢，它是持久化到磁盘的，所以一定是有的，注意断电之后数据丢失的话，只会把内存里面的数据给丢失掉。

你磁盘里面的数据是不会发生丢失的，所以不用担心这件事，好吧好了，刚刚我解释了原子性，通过undo log来实现隔离性，通过MVCC加锁来实现持久性，通过redo log来实现，但是我唯独没有提一个东西。

就是我们的一致性，这一年我要强调一件事，同学们听好了，这里面我会写一句话，记住了，为什么一致性没有写具体的实现方式，因为有很重要的一句话，一致性是我们根本的追求，一致性是实现。

方式是由其他三个特点来保证的，明白意思吧，也就是说它没有什么具体的实现点，其他三个特征共同保证了我们的一致性，问题来这儿能听懂，同学扣一能听懂吗，赶快记一点好不好，好了当这些问题都聊完了之后。

下面我们进入到一个环节，什么环节，我们就要讲一下我们的MVCC这玩意儿，把重点了一下，MCC这玩意，MVCC坦白说还是有那么一丢丢复杂的，很多同学在了解MCC的时候。

其实怎么说理解的都有多少有点有失偏颇，那今天我们重点把MVCC对应的实现机制，给大家讲清楚啊，MVC这玩意儿VC刚刚读完的，我都说过了啊，先聊聊mv cc刚刚解释过了啊，什么叫MVCC啊。

它的翻译是什么县城所吗，不是跟县城所没有半毛关系，它叫做什么叫多版本并发啊，这它对应的一个全称啊，既然涉及到并发了，那这里面会有一个问题，同学们数据库里面的并发大概分几种情况挺好。

数据库里面的并发大概分几种情况，这是什么，有多个事物在进行同时操作的时候，有几种情况，三种哪三种啊，第一种叫读读好吧，第二种叫读写啊，第三种叫写写，这都是我们产生这种并发读取的时候，要产生的一些操作。

比如说同时读都是读还是写还是有毒有写啊，这样的一个这样三种情况，那这样的情况我们要解决问题什么问题，这三种情况在进行并发操作的时候，它会有对应的问题呢，比如第一个读读会有数据安全问题吗。

他需要进行立法控制吗，需不需要，不需要不存在任何问题，也不需要并发控制，因为你在进行数据读取的时候，它并没有实际的改变我们的数据值吧，所以他不需要了好吧，那第二个读写会有问题吗，有吧有数据安全问题。

比如说我们之前提到的什么脏读对吧，幻读不可重复读啊，都是这种各种机制里面它要存在的一个问题啊，这东西，然后第三个写写写写会有问题吗，有没有有有数据安全问题，是可能存在丢失而叫更新丢失问题。

就说是存在这些对应的一些情况的，当存在这些对应情况之后，我们总要考虑解决方案，对不对，在考虑解决方案的时候，你就什么解决方案，最普通的方式我可以通过锁的机制来实现吗，比如说加锁锁是可以解决这个问题的。

但是我在使用锁的时候，明显有一个问题是什么，效率低吧，是不是效率低啊，那如果我想保证我的效率足够高，我应该怎么办，怎么做幻读的问题，一会儿来解释，别着急好吧，锁它的效率一定是很低的。

但是这个时候你可以联想一下，你之前在java那种并发编程的时候，java里面在进行并发编程的时候，你除了可以加这种single max这样的一些锁之外，还可以干什么事，好了话费剃头说了一个东西叫CAS。

CAS叫什么叫compare and sweep，其实我们的mv cc类似于这样的机制，也就是说他不需要去进行加锁，当然在MACC里面，它并不是进行对比的，只不过它减少了我们所对应的一些存在的问题。

就是说它是用来解决枷锁这样的一个问题的，明白意思吧，跟cs不一样，但类似的机制是一样的，类似的机制是一样的，那到底它怎么实现呢，实现的方式非常简单，刚刚有些同学提到了隔离级别，隔离级别的东西。

我希望同学们能够一会儿再聊，我们一会再聊隔离级别相关的问题，先扔一边，等需要聊的时候再来个离别，不需要聊，先不聊它好，在讲MVCC对应的实现原理之前，我需要同学们先具备两个最基础的概念。

第一个概念叫什么叫当前读，第二个概念叫快照读，就是说你必须要把这两个名词搞清楚，什么叫当前读，是啥意思，啊什么当前局记住了所谓的当前读，表达的意思是说在进行数据读取的时候，读取的都是最新的版本数据。

记住啊，叫最新的版本数据啊，而且在读取的时候，还要保证其他并发事务不能够修改，我们当前的这些记录，会对我们读取的记录进行加锁操作，这叫当前组，除了当前读之外，还有第二个概念，叫什么叫快照读。

那什么叫快照读啊，一个是读最新的数据，那快照读读啥读什么，对读取的是历史版本的数据，好吧，是有可能读取到对应的历史版本数据的哇，那这里面会有一个问题，老师什么样的操作会触发当前读。

什么样的操作会触发快照读呢，注意了，这样说明一下，我们当前读触发操作有以下几个，写下第一个，比如说select lock in share model，什么意思，加读锁吧。

比如说select for update加解锁吧，比如说我们执行的update操作对吧，delete操作对吧，包括A4的操作，像这些操作在进行操作的时候，都都都基本上都是当前读完全读，它并没有快照读。

那什么时候会触发我们的快照读呢，也非常简单，它有且仅有一个，什么东西呢，叫select，注意，最普通的select有可能触发的是我们的快到数据，而不是我们最新的数据，有人有这样的感受吗。

就你读到的数据是旧的数据，有这样的感受吗，你之前在操作数据库的时候，有读到过旧的数据吗，有没有，想想回忆一下有没有，如果你说没有，那么我就要给大家举例子了啊，如果你说没有，就要举例子了。

举例子来看一下它到底是什么样的一个情况。

已经更新了，但还是旧的，是这样的情况，来看好这个例子啊。

下面我来举例子说明了还是一样，我们不可能光讲理论知识。

还是要带点实操的好吧，let's go root杠P。

我来演示一个场景，你来告诉我对应的关掉吧，我来演示一个场景。

你来告诉我，对应的答案和对应的效果分别是什么，因为很重要，好吧。

来了两个窗口同时进来。

mysql u root杠P123456，进来进来之后，我们use demo这个数据库，然后呢在里面我去创建一张表，grade table ut18连开八九个字的id，Int primary ke。

内部watch。

这个SQL语句足够简单了，我觉得这个SQL语句有人看不懂吗，没有吧，足够简单了啊，然后insert into t18value，写这个值一逗号一，好了，往里面插入了三条结果。

select将from p18问题吧，这边也是一样的，Select。

行from t18。

两边数据一样不一样，告诉我两边数据是否一致，一样吧，没有任何的区别好吧，下面我要做一些最基本的操作了，第一个操作是干嘛，我们为了模拟事物的一个执行过程，或者执行情况，我需要把自动提交事务的按钮给关闭掉。

所以叫set auto commit等于零走。

然后commit一下，我现在把事务自动提交给关闭掉了，当我关闭掉之后，我为了模拟两个事物啊，AB是两两个，这是两个窗口，一个A1个B，那么我能不能手动的去开启我们的事物，我能手动开启事务吗，可以吧。

两种方式，第一种是第二个begin。

我依然执行begin操作，当我开启事务之后，我的问题来了，同学们，现在我开启了一个新的事物，两边数据是否一致，你这个意思一是吧，这个没啥问题啊，肯定是一致的，如果一致的话，我们就要考虑一件事。

我在第二个窗口里面，我做一个update操作，比如说update t18，set name等于连。

然后结束，我现在更新完成之后，两边的数据是否一致，现在一样吗，有人会说老师应该不一样吧，为什么，因为你从右边窗口里面是我没提交，我现在把它给提交掉，我的问题听好了，问题来了，当我这边提交完成之后。

我在这边进行数据的查询，我查询到的是零还是123，告诉我零还是123，来各抒己见好吧，发表你们的看法，好了，有说连的，有说123的，但是我看到的情况是123的，情况应该是偏多的。

但是实际查询起来你的结果它是连，并不是123，还有刘大说，老师要看隔离级别，这块跟隔离级跟隔离级别没有半毛钱关系，没有半毛钱关系，我先问一下我们当前的隔离级别，MYSQL默认的隔离级别是什么。

什么查一下嘛，At at at trition，什么repeatable read，因为我从来没有改变过隔离级别，所以别的级别是一模一样的。

没有任何的区别，这样你首先要记住了好吧，先把这东西记住来。

现在我把两边的事物全部提交掉，commit我在演示另外一种情况，看好了另外一种情况，什么情况，我现在都commit掉了，我同时再开启我们的输入，开始之后，我看一下我们的数据，三星from p18。

现在是一样吗，现在数据一样吗，一样吗，一模一样，隔离系列我也没动过，我依然在第二个窗口里面，我做一个更新操作，Update p18，set name等于回合单走，我一样在提交。

我现在读取到的结果是123还是连，什么，连是吧，是连吧是连哎，为什么，为什么在刚刚这里面的时候，我就可以读到最新的数据，为什么在这的时候我就读不到最新的数据了。

挺好啊，在我第一次演示的时候，它是可以读到最新的数据的，修改之后的数据，但在第二次的时候。

我就读取不到修改之后的数据了，你在这边进行查询的话，他已经改了，他的面，数据明显已经不一致了，小孩那桌数据库bug，怎么可能数据库bug。

这里面其实涉及到的就是当前读和快，照读的问题，跟缓存没有半毛钱关系，这也是MVCC它存在的一个重要的原理，重要的点好吧，对，区分点是什么，是我在读取之前，我进行了一次查询操作。

为什么我执行一次查询操作之后，就能够达到当前的事物，但是达到效果了，原因是什么，这个原因在于MVCC。

所以下面我要详细的去讲一下，MVCC具体的实现机制了。

你准备好了吗，想搞明白刚刚为什么会出现这种情况吗。

为什么我多执行了一次查询操作之后，两次结果就不一样了，来想知道的扣一体验一下自己好吧。

这时候核心点和重点来了，来先说MCCMACC在进行底层实现的时候，它总共包含了三部分操作，第一部分叫什么叫隐藏字段，什么叫隐藏字段，也就是说在我们的MVCC进行实际操作的时候。

它其实除了我们看到的字段之外，会包含一些包含一些我们看不到的字段，cover字段有几个呢，有很多这块我重点说三个，第一个叫什么叫dB下划线，TRX下划线ab，这是第一个隐藏字段。

它要表述的或它表示什么意思呢，其实非常简单啊，表示什么叫记创建这条记录啊，或者最后一次修改该记录的事务id，这是第一个字段要表示的意思，还有第二个隐藏字段叫什么叫DB下划线，肉下划线PT2。

它表示什么意思，它叫做，哪来叫做回滚指针好吧，指向数据的上一个版本，上一版本不一样的，还包含第三个字段，叫dB下划线，我昨天说过的东西叫ROID吗，什么意思啊。

系列 5：P8：8、JVM调优实战（下） - 马士兵学堂 - BV1E34y1w773

For slb，摘下来执行，good不错，还有一种说法是什么，来的访问，复制一份，复制到备份机，在备份机上执行，good不错，测试环境压测的执行，good不错，都可以get了吗，嗯我们来看第j map。

第二个命令，第二个作用，我看这里呃，那么j map的第二个作用，我先把我的头像拖出去，再看这里，JIMAP第二个作用是什么呢，第二个作用是它可以用这样来写dump。

for a dob就是binary2进制类型，产生一个dump文件，file等于他说叫今天是2020年9月11号，20200912。2，H profi，后缀名无所谓啊，后缀名写什么都行。

这是产生一个我们整个堆内存转储文件，然后呢来对它进行分析啊，然后后面跟我们的id号id号是什么来着，1198811988回好了，他这时候开始把堆进行转储。

产生完了。

这是我们新产生的20200912的H方法，好听，我说一句。

这个堆专注文件的意思是把java的整个对，整个堆JVM的整个队导成一个文件，然后下面可以你对这个文件进行分析，对对文件进行分析的时候，就完全可以使用那些网上。

你们喜闻乐见的各种工具了，比如说图形界面的JVOVM，这是j visual vm，嗯你你你你打开文件装入，你就直接把那个刚才那个文件呀，给他装入进来就可以了，这种的profile给它装进来好吧。

然后呢装入进来之后呢，你找到内存，找到抽样，然后你就观察出来到底是哪些个呃，你对象啊占的内存比较多，你就观察出来了，嗯这是一种好吧，这是第一种，有同学说了，老师这个JVRVM我没接触过。

这是java自带的这东西，这东西用我说吗，这东西用我说吧，不用吧，不用不用，很简单啊，这是java jdk自带的好吧，说两句，我同学实在是基础太弱了，你基础这么弱，我就没招了，简单跟你说两句吧。

你你就是你java装完了之后，jdk binary里面你找到JVIVOVM，就是这个图形界面的工具，这图形界面的工具呢它也比较强大，他们除了可以观察你本机的这些id之外，也可以装入用文件来观察。

也可以干嘛呢，也可以远程来观察。

比如说这是你LINUX服务器，你也可以用一个GB ram远程连接去观察它，这也是可以的，这个没问题嗯。

然后你就可以对它进行分析了，分析完之后你也得出结论了。

原来是cut info那个类太多了，依然是这个结论，没有什么其他的好吧。

然后下一步查你业务逻辑，查业务逻辑，别人就替不了你了。

好这块内容讲的稍微快了一些，来能跟上老师扣个一。

我觉得这个比较简单，没问题吧。

但是但是。

我讲这么快是有原因的，因为实际生产环境之中很少这么玩。

原因是啥，你往外导文件依然会产生卡死，会让JVM卡死，你能不能让你随便倒吗，不能，所以这就涉及到，你什么时候才能把这个文件给拿到，生产环境里头的第一件事，好好听我讲生产环境。

第一件事叫做设置好你的启动参数。

这个启动参数啊。

包括这个参数，Heap dump on out of memory error，就是当我们启动的时候，一定要把这个参数设置好，这个设置好的意思是什么呢，就是hit down，什么时候产生OOM了。

什么时候它会帮我自动生成堆转储文件，再说一遍，什么时候你的内存爆了，它会自动帮你生成一个对转储文件DP文件，这时候你内存爆了，相当于你java进程已经死了，这时候就没关系了。

把你的文件拿出来做分析分析的工具特别多，我呢跟大家说过，JBJVMJDK自带的JHG命令行的eclipse，带的MAD完全也可以，还有其他各种各样的工具都可以，刚才有同学提到GCEY，那是读日志的。

跟这没有半毛钱关系，好了，同学们这块不知道我说清楚没有，所以你在生产环境之中，你说我用GMAP导的不对，这个事儿不对，这是第一个，第二个，你跟面试官聊的时候，说我远程是LINUX。

我用JVM远程连接上去，这事儿对吗，能这么说吗，告诉我一下这console也可以远程连接，比如VM也可以远程连接，这PROFILER收费的也可以远程连接来，你要跟面试官说。

你说我在生产环境之中，双11那机器人在那玩着呢，我上一个JBVM去观察它完蛋，面试官估计一个大嘴巴子抽上来，哪凉快，哪呆着去搁哪，学的吧，你出门右转啊，拜拜，听我说一句，在生产环境中的机器。

一般情况下除了运维之外，尽量不多开任何端口，但是你如果用远程的这种图形界面去连接它，sorry必须得开各种各样的端口，产生各种各样安全问题，另外呢它会对性能造成一定的影响，大概性能会下降10%到15%。

因为它需要不断的对这VIVM往外传，我每一个对象的状态，好吧，所以这是不行的，还有同学说老师，那我人家面试官问我，我是怎么查出来的呀，我该怎么办呢，好听我说一句，如果说你说是图形界面的工具观察出来的。

也可以，什么情况，比较牛逼的说法是我是在压测环境里头，压测的时候好挂一个上去，远程观察，这个没问题，这是第一种说法，第二种说法是我们机器做了负载均衡，我们发现程序有问题之后，我把这台摘出来。

从负载环境里头摘出来，我把它的堆转储文件导出来，好这个也没问题，Very good，这是第二种，第三种，由于双11的或者是什么样的，这些个从互联网过来的连接特别多。

我用TCP dump这个命令给他复制一份，一份打到我们的生产环境里头，一份打到我们测试环境里头，我们用测试在测试集上做观察，good牛逼，说明你不仅懂负载均衡，你还懂TCP蛋。

你还懂生产环境里头这么调优的手段好了，50万给你了，恭喜你。

呃我说清楚了吗。

Tcp sorry，TCP copy吧，Tcp copy，sorry啊，不是不是TCP dumb。

I'm sorry。

Super king，这是50万必备的技能之一。

反正不是你那按电源好吧，super你要按电门那个你别说50万了。

5000多钱多。

super king啊，好嘞。

我们可以继续了吗。

但是呢在这我今天给大家介绍的并不是这个，我今天给大家介绍的是阿里开源的工具，这个工具很有名，目前用的特别多，这工具名字叫做阿尔萨斯，叫S好听，我讲啊，作为ARTHAS来说，是阿里开源的中文文档的工具。

今天呢我带大家用一下，但是我不想带大家安装了，这个没问题吧，我不想带大家安装了，安装你们自己去玩，我要跟你讲，安装就没劲了，好，作为阿尔萨斯来说，下载下来之后解压，解压开之后得到这个目录。

进到这个目录里去，我已经进来了，想执行它的时候，执行这个站文件就可以，它有好多种启动方式，这是最简单的java杠站，Others gone boot，要站会说当它启动之后，它会自动寻找。

你当前机器里面的那些个java的进程，目前呢只有119988号进程，在他的阿尔萨斯的内部编号里头叫做一，所以你敲一阿尔萨斯，尝试着把自己挂到这个进程上，可能挂不上去了，因为他已经死了，重新起。

挂不上去了，稍等卡屏了，卡屏了吗，我还在吗，我还活着吗，你们还在吗。

你们还活着吗，一书ban。

重新启动，我们重新过一下嗯，Ok，重新启动了小程序，我们在阿尔萨斯里面挂上它。

回到当你看到这个输出的时候。

说明阿尔萨斯已经正常的挂到了。

我们这个进程上，这个进程号是12202，这块能跟上吧，就是在我们整个系统里头，这是1java进程，阿尔萨斯的进程，在这里阿尔萨斯挂到这个进程上，然后对他进行观察好了，可以继续吗。

下面我来介绍阿尔萨斯它的一些功能，这个不会STW这个性能上会有所降低，但降的不多，至于会不会STW大哥，取决于你要执行什么命令，阿尔萨斯完全可以替代我前面敲的，基本上能替代我们敲的所有命令。

而且他比较直观，大家看这里234还有好多命令，如果你不知道的话。

你就叫help就好了。

他有这么多命令，Help key map，I c s m class，Loader，JD带等等等等等等，乱七八糟的好了，同学们。

在这些命令里面，我教大家几个，一个叫dashboard。

这是最常用最简单的一个命令，dashboard仪表盘回车，他用命令行底下模拟一个仪表盘，在这里面基本上综合了top那个命令和top，GUHP命令以及g info命令的一个组合。

在这你能看到你的整个进程里面有哪些个线程，有哪些线程在吃CPU，线程吃CPU的都放在最前面，然后线程的状态是什么，接下来内存占了多大一点，区占多少，survivor占多少，老年代占多少。

非堆内存占多少K好。

这些都是常用的一些参数的信息，所以这个一个dashboard搞定了。

很直观，最关键的，最最好用的是，这个就是到底哪个线程在吃内存啊，吃CPU，你如果用JDK和top gun hp组合的话，你得来回的换算，因为他哥俩啊。

一个是十进制，一个16进制，我跟你说，这哥俩你得来回换算，但是你如果用阿尔萨斯的话。

直接一观察就知道了哦，原来是52号线程。

它的线程名字叫pro1three39，他在吃CPU，不知道大家听清楚没有好。

这是第一个命令，我们继续，除了这个命令之外。

还有一些什么命令呢，help看这个命令heap dump还用我解释吗。

这个命令不用我解释吧，hp dump替代谁的，替代哪个命令能告诉我，gm map是吧，这太简单了啊。

hdmp k j map对哦。

还有一个命令叫thread回车，它会把整个你的进程里面所有的线程全给你，列出来哪个线程吃CPU最多，最关键，这个工具有一个特别牛叉的地方，thread your gun help呃。

第一个呢他的帮助非常的给力啊，完全也有中文版，虽然这是英文版啊，但它是完全有中文版，另外呢还有好多好多这些examples，你都可以直接拿来用就行了，特别简单，来教大家thread里面最常用的一个参数。

这个参数叫杠B，看一眼这是什么意思，读一下thread，钢笔叫include blocking thread，啥意思，Final thread。

Who is holding a log that blocks，The most number of threads，啥意思，对查找死锁，查找死锁，你像我教你用JDK的时候，你还记得吗。

JDK如果你要观察死锁的话，你得去观察每一个线程，它是不是weight在同一把锁上，为了好长时间，这个时候有可能会产生死锁，链会检查，但是在阿尔萨斯里面一个命令就可以搞定了，直接敲，四代钢笔。

当然我由于我们这个线程呢，我们这程序它没有思索，所以他找不出来，Nous blocking three f，如果是你自己故意写一个搜索程序，你用这个来观察一下，一把就给你找出来，好用点赞，可以继续吗。

嗯还有一个命令叫JVM，Jvm，当然这个命令呢其实很简单。

他就是那个j info，差不多他会把这个java的进程。

一些常见的参数是怎么设的，给你列出来哈哈这里面有一个比较好玩的，你可以观察它的garbage collectors，就是它默认用的哪种垃圾回收器呢，Garbage collectors。

那你会你会发现年轻代用的是CP，老年代用的是Mark sweep compact，一般max sweep，max swept到一定程度碎片化了，compact进行压缩。

好还有其他命令吗，还有这几个比较酷的。

这就太简单了，这几个比较酷的。

来我们来看这个命令，可以跟上吗，新时代说抽奖吧，不抽不要带节奏带节奏。

我先把你的名字给踢出去，我再抽奖。

为啥这工具不会影响系统性能，大哥我哪句话说不会影响系统性能啊，我说过吗。

这个会影响系统性能10%到15%，好看这里，看这里教大家这个命令，这个命令叫JADKJAD的意思是什么呢，就在这个命令的话，那我就换一个程序吧，不用这个程序了，我们换一个小程序，clear在这。

我还有个小程序啊，这小程序叫。

叫T我们先来看这小程序啊。

there more t点java好看这里啊这个小程序。

我这个T这个小程序是干了这么一件事，你读一下很简单，3D main函数里面写一个死循环，这个死循环system nein read，我从命令行上读一个字符进来啊。

读一次我就new出一个TT对象来调它的M方法。

mt7点点了，com t t t t m方法怎么写的，这方法超级简单，就是system out prinline1就打了个一，所以你执行这个程序，执行起来是这样子的，java t回车输入一个字符。

它要出出一个一输一个字符，出一个一输个字符，出个一输出字符，出个一嗯，这个输了三个字符，所以出了三个一好的小程序，能看懂吗，相当简单，下面呢我们通过阿尔萨斯挂上哪，教大家一个命令。

就是GADGAD的意思是反编译，叫java d compile，反编译java j AD t就这好。

你就会看到诶，他把整个呃源代码呢给你反编译了出来啊。

然后你JADTT等TT回车啊，在线反编译啊，给你反编译出来，有同学在这就开始说了，老师你逗我玩呢，这破工具能有啥用啊，我代码是我自己写的，我还用反编译，我不是有毛病吗，来认为这个工具没用的，给老师扣二。

认为有用的给老师扣一，有扣二的吗，没有吗，嗯还有的说太有用了，还有cod说没有用来凡是科二的，我估计你们就是在小P公司里，一个小P工程师拧着一个小P螺丝，为啥呢，其实啊，在一个超级大型的项目里头。

是由很多个团队共同把代码往上写，A团队的代码有可能依赖B团队，B团队，一个程序员把整个程序上运行起来之后，发现代码怎么不对啊，我检查我自己代码也没问题啊，为什么输出结果是不对的呢，本来这里想输出的是二。

结果你问您老人家为什么输出的是一呢，好我给你听，我讲，你这时候怎么查呀，这个时候你如果怀疑有可能A团队用错了，B团队的版本版本，听懂了吗，很有可能是A团队用错了B团队的这个版本。

我的第一个版本里面输出的是二，第二个版本输出的是一，结果你用错版本了，你输出的不对，并不是我B团队的问题，我怎么定位这个问题啊，没办法，在线反编译对，先开始开始扯皮啊。

两个两个那个那个为什么我这图像这么模糊啊。

关闭摄像头，重新打开，诶为什么这么模糊呢，有点模糊，大家凑合看吧，对两个小组的组长，A组和B组开始扯皮。

看看谁嗓门大，互相猜忌，然后论证。

这时候呢其实很简单，去上线反编译一下，看看正在运行的是哪个版本就搞定了，建筑清零长得模糊，对你是怎么知道的，我用了好多锐化技术才达到这种情形，混淆过代码可以反编译吗，反编译，不管你什么代码。

当然可以反编译，只不过混淆之后，它反编译出来是那个混淆的那份代码，好了我知道这个问题大家听清楚了吗，在线定位一些问题，bug到底出在哪啊，这个反编译工具很重要，很有用，JD是哪个命令。

exception的名字是哪个，哎呦我的妈呀，这AD是哪个命令，你还要问我，这AD命令当然就是这AD了，大哥，idea自带反编译来super king，super king提出的问题总是能触及灵魂。

super team的意思是说，当你这个程序在远程你的服务器上运行的时候，它可以用idea远程连上去，给你反编译下来，哎呀super king，你赶紧，你这个骚操作如果能做出来，赶紧教我一下啊，佩服啊。

简直实在是太佩服了啊，我，可以用java p好，可以可以可以完全可以，好吧好吧好吧，你们别搁这扯了啊，那个凡是提出奇奇怪怪的问题的，那些奇奇怪的知识，奇怪的问题啊，奇怪的问话你就不要再提了。

好好反思你自己，你就是那个小P公司的小皮螺丝钉，记住这个就行了啊，好嘞，来我们继续，那现在下面我再讲另外一个比较酷的，比较酷的这样的一个命令，这个命令叫redefine，好refine是什么意思。

Define，define是定义，如果你学过老师讲的class loader，你就应该知道这个东西呢是定义一个class，用的是可以修改一个class的，refine叫在线修改class，啥意思呢。

仔细看现在这个小程序，当我们一敲回车，它输出一，一敲回车输出一，但是经过定位，你用错版本了，我不应该输出一，而应该输出的是二，那么这时候怎么办呢，一个骚操作是这样子的，注意看我不要把程序停掉。

你继续运行。

我干这么一件事。

我干这么一件事，VMT一点点啊，我把这里的一，直接给改成二，存盘退出，然后呢加了CTT，大家把它编译好，把这class上传到远程去，这是我本地上传到远程，接下来在阿尔萨斯里面redefine。

root下面的一点class，回收好redefine成功之后，直接在原来程序上回车，诶已经变成二了，这又是一个骚操作，当然有同学可能就会说了，老师这破东西有用吗，我难道就不能本地代码改好了，把一改成二。

编译好了，把原来的程序覆盖掉就行了吗，原来程序停掉，等我改好了覆盖，然后不就搞定了吗，对不对，你没事，在线改，你不是有病吗，来认为有用的老师扣一，认为没用的扣二，那又有人说可太有用了是吧。

嗯李晨李晨扣二扣二的不多，特别有用是吧嗯，你们该担心这种权限问题的，那是人家运维的权限的管理，跟这有半毛钱关系吗，担心的问题都不知道，担心在哪，这边你跟你媳妇结婚呢，你担心呀。

那个美国那边要大地震着火了，这不扯呢吗，对在线改代码，这个呢最关键的点就不用重启，你的在线程序听懂了吗，因为什么呢，如果说敲二的，您，您还是那个小P公司的小P螺丝钉，为啥大企业做项目，做在线项目。

我就问你这在线项目能随便停吗，随便说哦，我这有1bug来把它停掉，等我修改完了之后，传上去，发现产生了新的bug，没事停掉，传上去能这样干吗，大哥，你知道在一个大型的公司里头，咱们不说大型互联网公司。

说银行吧，银行一个系统上线上线之后启动开始服务，经过多长时间呢，多长时间的审批，有没有在银行呢，有没有挺好发公告的，对啊，一周两周很正常吧，就是一个新系统上线的审批过程，很可能就要一周两周。

长则一周两周，短则一天两天，就为了修改你一个特别小的bug，你得把这些东西全部停掉，如果是大bug，灰度恢复原系统，如果是小bug，直接在线先把它改了，双11马上到了一个小时之后，秒杀开始了。

你的这个价格原来是100，你不小心写成了1000，你怎么改啊，能停掉吗，没关系，直接在线，先把它改过来，等下一个版本升级的时候，整个bug全部覆盖成新的，这就是救命用的紧急救命用，嗯好了。

集群用脚本批量执行替换，对啊，你集群只能用脚本啊，没错一般这是救命用的，并不是特殊的情况下都特别有用好吗，好这个是阿尔萨斯的骚操作之二，还有一些其他的骚操作，你想看吗，比如说我前面讲过的。

你怎么定位一个系统的系统瓶颈呢，阿尔萨斯是可以的，瓶颈平静静还写错了，一会教你234的下一个骚操作好吧，你看音传宁啊，我就知道有人得有人问这个问题，炸包情况下怎么操作呢，哎呦我的音传宁啊，我的音传宁。

你你你先拿大腿给我想想这边操作怎么操作，其他同学也帮他解答一下，指向炸包里，哎呦我的妖娆尾随你，赶紧嫁给银川宁，你们夫妻两个叫做对眼水平一致，大哥我就想问你啊，各位小伙伴们。

在JVM的内存里有炸包这件事情吗，有没有有没有一个炸包在JVM内存里，这包是干嘛的，里面装了好多class，放在硬盘上，这VM启动的时候，从这个炸包里面解压，把这class漏到内存，JVM管理里边。

有没有什么大包啊，对你咋不说落包呢，没错啊，你咋不说zip呢，你咋不说R呢，你看super king又问了个突击灵魂的问题，super king问的问题一般水平都比较高啊，super king什么的。

VIP中P只要他说话，所有人都给我停止，认真看100台服务器怎么改啊，不能一个一个改吧，怎么改，写个脚本呗，写个脚本批量改呗，good嗯，找另，好了呃，09：30了，我怎么说来着，09：30是09：

30，是开一个二等奖是吧，那个听我说啊，你已经录入过信息的，就不要再录入了，如果没录过信息的话。

微信搜索马士兵老师服务号，点抽奖，抽个二等奖。

一会儿我们抽个二等奖好不好，万一我又中了，你中了不算ALAN，我定一下规则，elan中了不算，那不可能能换吗，然而并不能，嘿嘿嘿，李先生来给大家几十秒时间，没有录过信息的，抓紧录完了给老师扣一灰。

没看到我的名字，哭了，无图无真相啊，你到底哭没哭啊。

没有哭的话，其他人把他打哭，好我们准备开始抽奖，这个奖品是小米手环，321，恭喜张文来，张帆，你在吗，张湾在吗，加文在吗，不在我们就不算了，在张直啊。

bug好了，不是bug啊，这个是人家开发那边给起了一个新的地址，昨天我用的是那个老地址，不是人家开发的问题，是我的问题嗯，好嘞好嘞好嘞好吧好，恭喜张万啊，自己去截屏截屏，好我们继续讲我们的骚操作好不好。

开完二等奖，大家别着急啊，就算你今天没有奖品，课程结束，每个人都送一本书，OK跟着老师把课程结束，陪着老师聊会天好，每个人都送一本三选一，我填了一个贼长的名字，没看到过，会有的面包会有的，好好了。

我们继续来看，另外一个骚操作，这骚操作呢我重新起一个小程序啊，我记得这小程序我忘了，有点小程序叫ABC吧，我记得ABC点，jav more abc点的，先读一下啊。

clear more abc AAA来读一下。

小程序很简单，看能不能读懂，看一眼，十几秒钟读一下，还有小程序干了件什么事呢，new就在for循环里面，main方法里面new了一个ABC点点，A调用了ABC调用它的A方法。

A方法呢是睡了一秒钟之后掉了B方法，B方法睡了两秒钟之后掉了C方法，C方法睡了三秒钟，哼哼哼，很很简单啊，好听我讲啊，就这东西呢，呃我主要是模拟每一个方法的调用栈，就是这里面你一定知道A是调用了B。

B调用了C，然后我用sleep模拟的是什么，sleep模拟的是我业务逻辑，在里面执行了多长时间，大家应该知道作为一个系统来说，有的时候呢，你会观察到你的系统响应速度特别慢，这种的呢。

我在我们学员里头已经遇见过好多次了，他说老师我这个系统呢想要做的特别慢，并发量特别低，比方说这个并发量，你你做一个压测访问我的A方法，发现我设计是要达到1万的QQPS好，但实际当中呢我只能达到100。

原因是啥，原因很简单，一定是A方法执行速度特别慢吗，本来设计之中是10ms完成，结果你500ms完成一次，你一秒钟也就执行个二次啊，听听懂我意思了吗，同学们这块大概知道什么意思吧。

OK就是说我们要查的时候，我们我们我们不知道这个系统的性能点，到底这个瓶颈在哪呢，是A呢还是B呢，还是C呢，这个调用栈有可能非常长，C又掉了，D又掉了F，F又掉了E等等，这个调用栈可能特别长。

这个链路上，整个这条链路上到底是哪个方法出问题了呢。

OK阿尔萨斯可以帮我们干这件事，好这个过程中我说清楚了吗，可以继续给老师扣个一来，嗯true boy，你看人家是真正的男孩，他说链路追踪，这叫单机版的链路追踪，单机版的就是你在这一个JVM内部里面。

A掉了，BB的，掉了C，但如果是微服务版的呢，这个服务调用了另外一台机器上的，另外一个服务，他又掉了其他的服务，它又掉了别的服务，好，这个叫做分布式链路追踪，今天我给大家讲的是单机版的阿尔萨斯就可以。

这个呢如果你要用分配律动，zip k sky walking都可以好吧，这在咱们VIP课里全都有，好听讲阿尔萨斯就可以，当然这种工具特别多，除了S之外呢，好多好多其他工具都可以用。

比如JPROFILER，但是JK自带的还有一个命令，我忘了叫什么了，其实也可以命令很多，但是阿尔萨斯的很好用，这个东西是收费的，这PROFILER是收费的，JDK自带的呢相对于阿尔萨斯的难用。

所以我讲阿尔萨斯这个版本好吧，好看这里厚德载物，厚德载物，不要停啊，你居然你居然说的是名字，是我们学校的校训，知道清华的校训是什么，自强不息，厚德载物是吧，清华的校歌是什么，清华的校训是什么，忘了啊。

你们知道北大的小哥是什么，肖俊是什么，小辉是什么，没有啊，北大的全没有，所以北大又称三无学校，北大每年那个都探讨，说我们距离国际双一流学校代理还差，到底还差多远，一般情况下我们都会告诉他。

出你们东门左转100米就到了，就差100米，嗯北大就是这么一个牛逼的学校啊，开个玩笑啊，我们继续，我们来我们来来来来，追踪整个呃这个链路到底哪出了问题啊，这怎么追踪呢，我们先把它跑起来。

java abc回车，依然是挂上阿尔萨斯，挂上阿尔萨斯，一回正好这次我们的命令是什么呢。

是这个这个命令的叫trace，trace的意思叫trace the execution，Time of specific method invocation，看一眼这啥意思啊。

trace这个没这个方法的执行时间嘛，嗯choose your help。

来看看它的例子程序就知道了啊，trace这个类名方法名来trace trace。

ABC方法名是A回正，然后他就开始trace这个方法，Effetic classon one on one coin。

这是他方法的分析过程，看到了吗。

他分析出来了，他说呃他分析了好几次，他说你看那个我执行A的时候，我执行了六秒钟，我的老大爷哇，你会发现哇，不会吧，我A设计的是500ms，你居然给我执行出六秒钟出来，什么情况哦，他给你定位。

在A里面自己睡了一秒钟，给你跟踪出来了，我的我的娘啊，所以B1定是有问题的，这能看懂吗，能看懂的，给老师扣一，那既然您老人家B是有问题的，咋办啊，追B吗，看看B是啥情况，怎么回事，怎么执行这么长时间。

好B追踪出来了，说B总共花了五秒，他自己执行的时间是两秒钟，sleep了两秒，但是呢它掉了C你会发现C执行了三秒，我勒个去C怎么回事，C1定一定是有问题的，所以跟到C里面去嗯，然后来看看。

当然你一路追踪下来，你就会发现你这条链路上到底哪个方法，它的执行过程花费的时间太多了，剑走轻灵啊，前几天刚调是吧，嗯剑走轻灵不错，super king这功能好哇，遭到了super king的表扬啊。

今天晚上没白讲，VIP有这些吗，必须有的歌，我公开，各位都有了，Vip。

系列 5：P80：80、MySQL的redolog、undolog、binlog分别有什么作用？ - 马士兵学堂 - BV1E34y1w773

好如果没有显示，主线说话就会多一个隐藏主线去抓下。

就是说我们在创建完一张表之后，创建一张表之后，比如说我建一张表，里面有以下几个字段啊，看好了，比如说有id先复制吧，比如创建表里面有什么，有name好吧，有age有真的有这四个属性。

除了这三也是三个属性，除了三个属性之外，在这个行程记录后面还会包含这三个字段，只不过这三个字段是人为看不到的，或者说你肉眼看不到的。

不管你怎么查，你都是查询不到的，实际数据就变成这样子。

好的需要注意了，如果我插入一条记录之后，就变成了内幕，写个字张三，比如age12tender man，然后DBTRSID表示什么意思来着，表示创建这条记录，或者说最后一次修改该记录的id值。

这里面有一个情况，我需要说明一下，在事务操作里面，在事务操作的时候，事物id的值是递增的，新增的。

所以我们才刚开始的时候，假设他现在是新增的操作，那么我这个值给它写成一，还有个东西叫DBOPTR，表示上一个历史版本的状态，那我现在是没有历史版本，所以这个值现在是N，如果有历史版本，你就指向历史版本。

还有一个ZVOPT2，我这个表里面是没有主见的，所以这里面可以给一个值，如果有主见的话，他会写上我们对应默认的主键还是有区别的，能明白这意思吗，好来这个东西能看明白的同学给老师扣个一。

能看懂吗，实际上你的数据还在存储的时候。

除了这三个字段之外，还会包含三个隐藏字段，这是最开始的一个状态，最开始状态有一行记录，所表示的一个最基本的状态，这是第一部分叫隐藏字段，好吧，除了隐藏字段之外，第二部分，所以呢我们之前说到这个东西。

就是刚刚说的叫on dolog，啥意思，undo log表示来着叫回滚日志吗，对不对，它里面记录是什么，记录的是数据的历史版本。

是不是这意思，历史版本吗，所以像刚刚那有一个dB rop t2，它是不会指向历史版本，那指向的历史版本在哪，就在我们的on log里面，那如果直接这么说的话，很多同学可能没有具象的一个感知或认知。

我们来模拟一个数据，插入一个场景来看一下到底什么效果，我来举个例子，比如说现在第一次来了一个11行不行，事务一好吧，插入一条记录，当我的事物一开始插入记录的时候，干什么事非常简单。

不就是刚开始的数据的状态吗，是不是只有一个这东西，所以在最开始你进行数据插入的时候，它就是我们对应的最新结果，没有对应任何历史的数据，它就是最新的，来这东西能听明白的，扣一，没问题吧。

那现在我来了一些其他事物。

什么事物来了一个事务，22，我要做一个操作失误二更新什么name等于第四，如果我要更新name等于李四的话，我是不是需要去改变我们对应数据结果值了。

把它拿过来放到这块，我要改了，首先name值改成李四，除了这个内幕值改成李四之外，我还需要去改变什么东西，还要改别的吗，想想需不需要，哪些东西。

这个字要不要改啊，刚刚说了DBPTR是这个TR。

SD是啥意思来着，表示说我新增这条记录的事务id，或者说最后一次修改的事务id的值了，我现在是不是十五二D修改了。

这是票改成二对吧，改成二之后，dB rop t r是什么意思。

叫回滚指针，我是不是要指向上一个历史数据的版本状态，上一个文章在哪。

不就这个记录吗，我把它拿下来放下来就可以了，放下来放完之后给一个地址，0x123，我随便写个地址啊，地址随便写的无所谓，它就指向了当前的数据版本是同时注意了。

我要拿一个框把这部分内容给框住。

这最后，当我框住之后好吧，下面这个框里面表示的东西是个啥，就是我们之前说的叫undo vlog，能听明白吗，这就是我们说的UNLOG，它是不是存储了我们对应历史数据的版本状态，此时它是最新。

结果那你告诉我这里面存的是啥什么东西，历史结果吧，这个存在是历史记录吗，来这儿能听懂，同学给老师扣一，能听懂吗。

好了，这是第二个，那同样的我们可以进行第三个事物来进行操作，我第三个事务也来了，干什么事儿叫事故三更新，H等于21可以改吧。

那是不是一样道理，我只需要把这个结果挪下来，改变我们的数据，把它改成21，他是不是要改地址变成几了，别着急，三嘛，他地址是不是要改0X比如说345随便写的。

然后我要把下面这部分数据也拿过来放下来。

放完之后呢干一件事。

这部分的东西都要往下挪。

为什么往下挪，因为现在你多了一个新的历史版本状态，这是他。

把它混到这个地方，这个箭头要指向它，指向它，然后它指向他，能看明白吗。

再说这个时候下面的它属于历史结果，这东西它属于最新结果。

来这个图能看懂的，扣一，没问题吧，这是对应的状态。

比如说最后我们其实可以得到一个结论，最终undo log里面存储的是什么东西。

帮助log中会形成一个链表吧。

啊练手是最新的旧记录好吧，列维是最旧的旧记录，是不是意思练手练尾有对应的具体数据。

这是第一块，那这时候有个问题。

老师那on board里面不是会一直变大吗，你就想一个数据可能会无限增大吗。

同学们，他可能一直膨胀下去吗。

可能不可能啊，他可能一直无限涨下去吗，不可能吧，肯定不会的，肯定不会无限涨上去的是吧，如果不会无限转下去的话，那怎么办，所以在这个里面它会有一个东西下来之后，你们自己去查，目前面试中还没人问到这个东西。

有一个后台的线程叫PORGE，线程会清除数据，清除，数据不说清除没用的数据啊，这改成三会清楚什么清除没用的数据。

明白意思吗，这东西是啥，你们自己去查吧，我这边不讲了。

因为目前还没还没有面试官问到MYSQL，O r g e perch。

有移动dB是一个破纸。

什么意思，移动地并发机制开始为了更好支持并发，基于回滚蛋的一个方式。

nod b真正删除记录这个记录标志来的，通过什么解决数据和这个undo log文档的问题。

需要引入或者机制来进行回收啊，POS机的回收背景是如下所示。

下载之后详细了解一下，它也是完整的一个知识体系。

明白意思吧，所以我们不提这L不提这L下载之后，有需要的同学下去之后自己聊。

OK这是第二部分，我们记录的on the wall，来这听明白。

同学扣一能听懂吗。

问题吧是第二部分。

这东西还不是最主要的，最主要的东西应该是第三部分组件。

第三部分是什么，有一个新的东西记住了，它叫啥呢，叫random view，review这玩意儿怎么怎么翻译啊，或者怎么理解什么叫review，啊你翻译过来叫什么，叫不是图嘛对吧，但这里面有一个明确定义。

叫什么叫事物进行快照读，操作的时候好吧，是产生的读视图，如果只是这么去理解的话，会这么去看这个概念的话，很多同学依然是一脸懵逼。

根本不知道咋回事，根本不知道啥情况，其实非常好理解，在review里面它叫读视图，在当前的读视图里面，读视图里面包含什么信息，它包含的就是三个关键的字段，你只需要把这三个字段搞清楚就完事了好吧。

那三个字段呢老师说老师是453。

不应该改不动吗，什么改不动，真要改啊，因为你是453更新吗。

这肯定要改好吧，我先来下啊，你这个六里面，它其实包含了包含了三个对应的结果吧，我们三个对应的字段，哪三个字段呢，第一个叫t rs下划线list代表什么意思呢，它表示的意思是这样的。

记住了表示reveal生存时刻，好吧，当前系统活跃的事务id，注意啊，它是一个列表，它不是一个值，它是一个列表，然后dB肉体这个地方下来之后，还有第二个字叫什么叫up下划线，limit下划线id。

代表什么意思呢，也非常简单，代表的意思是活页，列表中是最小的事物IP值。

除了这个字段，这还有第三个字段叫low下划线，limit下划线IP，这个表示什么意思啊，它表示系统，尚未分配的下一个事务id的值，来这三个字段能不能记住，不需要理解了吗，记住能不能记住来，能记住的。

给老师扣一，能不能，这个小不点说老师为什么up是最小，露是下一个没有啥问题，他就这么规定的，他就这么规定的，我没写错啊，我没写错，他就这么规定的，没办法好吧，这东西是需要你是需要是需要你掌握的哎。

给点回应给点回应，大哥们能能记住不，我不要你理解啊，能不能记住就记住就完了好吧，其实这些东西都是死的，固定的概念，固定的概念好吧。

这东西都不是核心重要的点啊，重要点在什么地方，重点是当我在生成一个review的时候，他会把这些字段里面的值给进行一个填充。

当填充完成之后，在下面这个环节里面会有一个东西叫什么。

叫做可见性算法，也就是说当我生成read view之后，会根据可定性算法生成的review，会根据可见性算法来判断是否，可以读取到对应的历史对应的数据结果。

如果你记不住，没关系，多听两遍理解，多讲点理解。

因为第一遍听我没办法要求你们都理解的，都理解到，但你把这东西给我记住就完了。

那可见性算法是什么呢，它就是一段非常复杂且沉重的文字描述。

文字描述啊，有点恶心的文字描述啊，这个不需要大家记。

我每次我也没记过，我都是讲课之前放到桌面上，我都直接给你粘过来，我也没记过这玩意儿，你这玩意儿太费脑子了，估计就放过来完事，然后一会儿，我们需要进行可执行算法的一个判断，因为我们要判断原则。

那下面当这些东西我都聊完了之后，我们要干一件事，干点什么事情。

我们要去做一个最基本的判断，什么判断，把我们刚刚的例子来做一个复线好吧，刚上来有时候做了个例子，根据我们刚刚那个案例，我们来进行一个复线，来看一下对应的效果到底是什么样子。

来我给大家写具体情况啊，这么多，这是时刻，不要说掉头发的事好吧，你你不要去抱怨这东西没意义，别人会的，你要你要不要会，你要会调整这东西时刻，比如T1时刻T20克，T30克，这样事物一事物二十五三。

然后这个时候呢干什么事，刚开始的时候，三个事物里面都执行了一个begin状态，Begin，底蕴，然后在施工的时候，我执行了一个update操作，然后我commit掉了对吧，然后在T3时刻。

我这进行了一个select的一个查询，刚刚的问题是什么来着，问题是当我这块进行select操作的时候，能否，读取到修改之后的结果吧，来告诉我结果是什么，结果是什么。

能不能读取到在当前这个flag操作的时候，能不能读取到数据，结果能还是不能，还有人说不能啊，我刚刚设置都已经演示过了，我刚设置都已经演示过了，演示的时候能还不能，能吗，那为什么能啊，他是怎么做的呀。

非常简单，我们来做一个判断，做一个判断，什么判断。

把刚刚我们要填充的字段给拿过来，这是我们在生成review的时候要生成的东西。

刚刚也说过了，什么时候生成review来着，在进行快照读操作的时候会产生平视图。

那什么叫快照读。

是不是刚才也解释过了，所谓的快照读就只是select操作，我们在刚刚T3时刻。

我是不是执行了一个select操作，所以此时是不是要进行一个快照读了，那现在我只需要去填充好对应的字段信息。

就完了，来告诉我，当我在T3时刻执行快照读的时候，我现在当前系统的活跃事务列表有几个，这个值是几，十几，就不能多说全了吗，一三嘛是不是一和三，这没问题吧，一和三第二个最小的活跃列表里面有二吗。

这边有二吗，同学们，什么叫活页，你事务已经提交到了，这还叫活力吗，已经提交了还叫活跃吗，同学们不能了吧，就一个三两个好吧，没有二，因为我已经提交了，第二个，当前活力列表里面最小的事务id是几一码。

对不对，毫无疑问，下一个系统尚未分配的下一个事务id是几几，四好了，把这些数据都写完整，然后除了这几个字段之外，你还要再多一个字段信息，叫什么叫DB下划线，TRX下划线D8加进来。

它也是需要进行条件判断的，这个值是几，是一吗，想想是一吗。

是三吗，哎呀还四啊，什么叫DBTSID啊。

要创建这条记录，或最后一次修改该记录的事务id。

我现在谁修改了。

数二数改了吧，知几。

对不对，其实是二好吧，来把这几个值我都已经写完整了。

当我把这几个值写完整之后，下一步干什么事。

我需要按照这个表，针对于我们当前的可见性算法。

我要去做一个判断，判断一下我能不能看到对应的结果。

然后来看第一个，首先比较dB t s d知识节。

二小于up limit id等于几等于一。

二小于一吗，说如果小于，则当前事故能看到所在这记录，我们现在小于不小于不小于吧，二是大于等于一的，对不对，如果大于等于怎么办，进入到下一个判断环节里面去。

所以再接着来判断db7236等于几等于二，LLB加X等于几等于四说如果大于等于，则表代表DBTICID所在的记录，在review生成之后才出现。

那么对于当前事物肯定不可见，我们现在二是小于四的，如果小于。

则进入下一判断，它依然往下走，这样看看dB t s i d2是否在活跃事务中在吗，在不在，二有没有在活跃列表里面不在吗，如果在，则代表巴拉巴拉巴拉巴拉巴拉巴拉，如果不在。

则说明这个事物在review生成之前，就已经开始commit了，那么修改的结果是能够看见的，所以我们的结论是能跟我们的实际情况，能否匹配上，能不能匹配上，能吧，这就是最终最终结果吗。

结果就是这样的，就是这样的，来下面再演示情况。

我们把第二次我做那个操作。

我也画成图来演示出来什么图，第二次画成图的时候变成亮的效果了。

再改成T4，这没有。

系列 5：P81：81、什么是二阶段提交，如何保证宕机时数据的一致性？ - 马士兵学堂 - BV1E34y1w773

好如果没有显示，主线说话就会多一个隐藏主线去抓下，就是说我们在创建完一张表之后，创建一张表之后。

比如说我建一张表，里面有以下几个字段啊，看好了，比如说有id先复制吧，比如创建表里面有什么，有name好吧，有age有真的有这四个属性，除了这三也是三个属性，除了三个属性之外。

在这个行程记录后面还会包含这三个字段，只不过这三个字段是人为看不到的，或者说你肉眼看不到的，不管你怎么查，你都是查询不到的，实际数据就变成这样子，好的需要注意了，如果我插入条记录之后，就变成了内幕。

写个字张三，比如age12tender man，然后DBTRSID表示什么意思来着，表示创建这条记录，或者说最后一次修改该记录的id值，这里面有一个情况，我需要说明一下，在事务操作里面。

在事务操作的时候，事物id的值是递增的，新增的，所以我们才刚开始的时候，假设他现在是新增的操作，那么我这个值给它写成一，还有个东西叫DBOPT2，表示上一个历史版本的状态，那我现在是没有历史版本。

所以这个值现在是N，如果有历史版本，你就指向历史版本，还有一个ZVOPT2，我这个表里面是没有主见的，所以这里面可以给一个值，如果有主见的话，他会写上我们对应默认的主键，它是有区别的，能明白这意思吗。

好来这个东西能看明白的同学给老师扣个一，能听懂吗，实际上你的数据还在存储的时候，除了这三个字段之外，还会包含三个隐藏字段，这是最开始的一个状态，最开始状态有一行记录，所表示的一个最基本的状态。

这是第一部分叫隐藏字段，好吧，除了隐藏字段之外，第二部分，所以呢我们之前说到这个东西，就是刚刚说的on dolog，啥意思，on the log表示来着叫回滚日志吗，对不对，它里面记录是什么。

记录的是数据的历史版本，是不是这意思，历史版本吗，所以像刚刚那有一个dB rop t2，它是不会指向历史版本，那指向的历史版本在哪，就在我们的on log里面，那如果直接这么说的话。

很多同学可能没有具象的一个感知或认知，我们来模拟一个数据，插入一个场景来看一下到底什么效果，我来举个例子，比如说现在第一次来了一个11行不行，事务一好吧，插入一条记录，当我的事物一开始插入记录的时候。

干什么事非常简单，不就是刚开始的数据的状态吗，是不是只有一个这东西，所以在最开始你进行数据插入的时候，它就是我们对应的最新结果，没有对应任何历史的数据，它就是最新的，来这东西能听明白的，扣一，没问题吧。

那现在我来了一些其他事物，什么事物来了一个事务，22，我要做一个操作失误二更新什么name等于第四，如果我要更新name等于李四的话，我是不是需要去改变我们对应数据结果值了，把它拿过来放到这块。

我要改了，首先name值改成李四，除了这个内幕值改成李四之外，我还需要去改变什么东西，还要改别的吗，想想需不需要，哪些东西，这个字要不要改啊，刚刚说了DBPTR是这个TR，SD是啥意思来着。

表示说我新增这条记录的事务id，或者说最后一次修改的事务id的值了，我现在是不是十五二D修改了，这是票改成二对吧，改成二之后，dB rop t r什么意思叫回滚指针。

我是不是要指向上一个历史数据的版本状态，上一个文章在哪，不就这个记录吗，我把它拿下来放下来可以吧，放下来放完之后，这改一个地址，0x123，我随便写个地址，这个地址随便写的无所谓。

它就指向了当前的数据版本好吧，同时注意了，我要拿一个框把这部分内容给框住。

这最后，当我框住之后好吧，下面这个框里面表示的东西是个啥，就是我们之前说的叫undo vlog，能听明白吗，这就是我们说的UNLOG，它是不是存储了我们对应历史数据的版本状态，此时它是最新。

结果那你告诉我这里面存的是啥什么东西，历史结果吧，这个存在是历史记录吗，来这儿能听懂，同学给老师扣一，能懂吗，好了，这是第二个，那同样的我们可以进行第三个事物来进行操作，我第三个事务也来了。

干什么事儿叫事故三更新，H等于21可以改吧。

那是不是一样道理，我只需要把这个结果挪下来，改变我们的数据，把它改成21，他是不是要改地址变成几了，别着急，三嘛，他地址是不是要改0X比如说345随便写的，然后我要把下面这部分数据也拿过来放下来。

放完之后呢干一件事，这部分的东西都要往下挪。

为什么往下挪，因为现在你多了一个新的历史版本状态，这是他。

把它混到这个地方，这个箭头要指向它，指向它，然后它指向他，能看明白吗。

再说这个时候下面的它属于历史结果，这东西它属于最新结果。

来这个图能看懂的，扣一，没问题吧，这是对应的状态。

比如说最后我们其实可以得到一个结论，最终undo log里面存储的是什么东西，帮助log中会形成一个链表吧，啊练手是最新的旧记录好吧，列维是最旧的旧记录，是不是意思练手练尾有对应的具体数据，这是第一块。

这时候会有一个问题，老师那on board里面不是会一直变大吗，你就想一个数据可能会无限增大吗，同学们，他可能一直膨胀下去吗，可能不可能啊，他可能一直无限涨下去吗，不可能吧，肯定不会的。

肯定不会无限涨上去的是吧，如果不会无限转下去的话，那怎么办，所以在这个里面它会有一个东西下来之后。

你们自己去查，目前面试中还没人问到这个东西，有一个后台的线程叫PORGE，线程会清除数据，清除，数据不说清除没用的数据啊，这改成三会清楚什么清除没用的数据，明白意思吗，这东西是啥，你们自己去查吧。

我这边不讲了，因为目前还没还没有，面试官问到mysql o RGE perch。

有运动定律是一个破值，什么意思，移动并发机制开始为了更好支持并发，基于回滚蛋的一个方式，nod b真正删除记录这个记录标志来的，通过什么解决数据和这个undo log文档的问题。

需要引入或者机制来进行回收啊，POS机的回收背景是如下所示，下载之后详细了解一下，它也是完整的一个知识体系，明白意思吧，所以我们不提这L不提这L下载之后，有需要的同学下去之后自己聊。

OK这是第二部分，我们记录的on the wall，来这听明白，同学扣一能听懂吗。

问题吧是第二部分，这东西还不是最主要的，最主要的东西应该是第三部分组件。

第三部分是什么，有一个新的东西记住了，它叫啥呢，叫random view，review这玩意儿怎么怎么翻译啊，或者怎么理解什么叫review，啊你翻译过来叫什么。

叫不是图嘛对吧，但这里面有一个明确定义，叫什么叫事物进行快照读，操作的时候好吧，是产生的读视图，如果只是这么去理解的话，会这么去看这个概念的话，很多同学依然是一脸懵逼，根本不知道咋回事。

根本不知道啥情况，其实非常好理解，在review里面它叫读视图，在当前的读视图里面，读视图里面包含什么信息，它包含的就是三个关键的字段，你只需要把这三个字段搞清楚就完事了好吧。

那三个字段呢老师说老师是453。

不应该改不动吗，什么改不动，真要改啊，因为你是453更新吗。

这肯定要改好吧，我先来下啊，你这个六里面，它其实包含了包含了三个对应的结果吧，我们三个对应的字段，哪三个字段呢，第一个叫t rs下划线list代表什么意思呢，它表示的意思是这样的。

记住了表示reveal生存时刻，好吧，当前系统活跃的事务id，注意啊，它是一个列表，它不是一个值，它是一个列表，然后dB肉体这个地方下面之后还有第二个字，叫什么叫up下划线，limit下划线id。

代表什么意思呢，也非常简单，代表的意思是活页，列表中是最小的事物IP值，除了这个字段，这还有第三个字段叫low下划线，limit下划线IP，这个表示什么意思啊，它表示系统，尚未分配的下一个事务id的值。

来这三个字段能不能记住，不需要理解了吗，记住能不能记住来，能记住的，给老师扣一，能不能，这个小不点说老师为什么app是最小，漏成下一个，没有啥就这么规定的，他就这么规定的，我没写错啊，我没写错。

他就这么规定的，没办法好吧，这东西是需要你是需要是需要你掌握的，哎给点回应给点回应，大哥们能能记住不，我不要你理解啊，能不能记住就记住就完了好吧，其实这些东西都是死的，固定的概念，固定的概念好吧。

这东西都不是核心重要的点啊，重要点在什么地方，重点是当我在生成一个review的时候，他会把这些字段里面的值给进行一个填充，当填充完成之后，在下面这个环节里面会有一个东西叫什么，叫做可见性算法。

也就是说当我生成read view之后，会根据可定性算法生成的review，会根据可见性算法来判断是否，可以读取到对应的历史对应的数据结果，如果你记不住，没关系，多听两遍理解，多讲点理解。

因为第一遍听我没办法要求你们都理解的，都理解到，但你把这东西给我记住就完了，那可见性算法是什么呢，它就是一段非常复杂且沉重的文字描述，文字描述啊，有点恶心的文字描述啊，这个不需要大家记。

我每次我也没记过，我都是讲课之前放到桌面上，我都直接给你粘过来，我也没记过这玩意儿，你这玩意儿太费脑子了，估计就放过来完事，然后一会儿，我们需要进行可执行算法的一个判断，因为我们要判断原则。

那下面当这些东西我都聊完了之后，我们要干一件事，干点什么事情，我们要去做一个最基本的判断，什么判断，把我们刚刚的例子来做一个复线好吧，刚上来有时候做了个例子，根据我们刚刚那个案例，我们来进行一个复线。

来看一下对应的效果到底是什么样子，来我给大家写具体情况啊，这么多，这是时刻，不要说掉头发的事好吧，你你不要去抱怨这东西没意义，别人会的，你要你要不要会，你要会调整这东西10克，比如T10克，T20克。

T30克，这样事物一十五二十五三，然后这个时候呢干什么事，刚开始的时候三个事物里面都是一个begin状态，begin1面，然后在施工的时候，我执行了一个update操作，然后我commit掉了对吧。

然后在T3时刻，我这进行了一个select的一个查询，刚刚的问题是什么来着，问题是当我这块进行select操作的时候，能否，读取到修改之后的结果吧，来告诉我结果是什么，结论是什么。

能不能读取到在当前这个flag操作的时候，能不能读取到数据，结果能还是不能，还有人说不能啊，我刚刚设置都已经演示过了，我刚设置都已经演示过了，演示的时候能还不能，能吗，那为什么能啊，他是怎么做的呀。

非常简单，我们来做一个判断，做一个判断，什么判断，把刚刚我们要填充的字段给拿过来，这是我们在生成review的时候要生成的东西，刚刚也说过了，什么时候生成review来着。

在进行快照读操作的时候会产生平视图，那什么叫快照读，是不是刚才也解释过了，所谓的快照读就只是select操作，我们在刚刚T3时刻，我是不是执行了一个select操作，所以此时是不是要进行一个快照读了。

那现在我只需要去填充好对应的字段信息。

就完了，来告诉我，当我在T3时刻执行快照读的时候，我现在当前系统的活跃事务列表有几个，这个值是几，十几，就不能多说全了吗，一三嘛是不是一和三，这没问题吧，一和三第二个最小的活跃列表里面有二吗。

这边有二吗，同学们，什么叫活页，你事务已经提交到了，这还叫活力吗，已经提交了还叫活跃吗，同学们不能了吧，就一个三两个好吧，没有二，因为我已经提交了，第二个，当前活力列表里面最小的事务id是几一码。

对不对，毫无疑问，下一个系统尚未分配的下一个事务id是几几，四好了，把这些数据都写完整，然后除了这几个字段之外，你还要再多一个字段信息，叫什么叫DB下划线，TRX下划线D8加进来。

它也是需要进行条件判断的，这个值是几，是一吗，想想是一吗，是三吗，哎呀还四啊，什么叫DBTSID啊，要创建这条记录，或最后一次修改该记录的事务id，我现在谁修改了，数二数改了吧，知几，对不对。

其实是二好吧，来把这几个值我都已经写完整了，当我把这几个值写完整之后，下一步干什么事，我需要按照这个表，针对于我们当前的可见性算法，我要去做一个判断，判断一下我能不能看到对应的结果，然后来看第一个。

首先比较dB t s d知识节，二小于up limit id等于几等于一，二小于一吗，说如果小于，则当前事故能看到所在这记录，我们现在小于不小于不小于吧，二是大于等于一的，对不对，如果大于等于怎么办。

进入到下一个判断环节里面去，所以再接着来判断db7236等于几等于二，LLB加X等于几等于四说如果大于等于，则表代表DBTICID所在的记录，在review生成之后才出现，那么对于当前事物肯定不可见。

我们现在二是小于四的，如果小于，则进入下一判断，它依然往下走，这样看看dB t s i d2是否在活跃事务中在吗，在不在，二有没有在活跃列表里面不在吗，如果在，则代表巴拉巴拉巴拉巴拉巴拉巴拉，如果不在。

则说明这个事物在review生成之前，就已经开始commit了，那么修改的结果是能够看见的，所以我们的结论是能跟我们的实际情况，能否匹配上，能不能匹配上，能吧，这就是最终最终结果吗，结果就是这样的。

就是这样的，来下面再演示情况，我们把第二次我做那个操作，我也画成图来演示出来什么图，第二次画成图的时候变成亮的效果了。

再改成T4，这没有。

系列 5：P82：82、MVCC如何实现多版本并发控制？如何解决读写冲突？ - 马士兵学堂 - BV1E34y1w773

这没有，那这先select，S挪到下面，这只是一个自来操作对吧，然后这是一次快照读，这是一次快照读，来一样的，我错了，每次在进行快照读的时候，需要生成我们的review吧，这里面是不是有两次快照读。

第一个在T2时刻，第二个在T4时刻，所以我们分别要把对应的数据写写完整，把它弄下来，Cl c ctrl v，明白了，回来之后先看蓝色的，首先在这块我在进行查询的时候。

我当前系统的活跃列表里面的事务id是几，你告诉我是几，123123没问题好吧，第二个回形列表里面最小的数id是几一吧，不用动，尚未分配的下一个事关系是几四，也不用动，这个值是几啊。

叫新增这条记录或最近修改这条记录的值，现在我有新增呢，我没看到我的新增操作，但是因为我们的事务id的值是递增的，它一定是小于一的，我能不能给他成零，反正你小于就行了，是不是这意思，小于就行了，无所谓啊。

我这写成一个零，这没问题吧，来下面再来做操作，这是蓝色部分，还有绿色部分，把绿色拿下来，如果是绿色部分的话，我们依然要进行判断，判断啥在这个时候，当前活跃列表数值，这个活页列表id是几啊。

在蓝色部分的时候，我有事务二有提交吗，听同学听我在这执行的时候，二有提交吗，没有还没提交呢，在绿色部分，这时候是不是也提交了，所以回忆里变成几了，一逗号三对吧，然后最少收益地址是不是一。

是不是一最小说话题绿色好吧，我现在是啥都给你标注好还是绿色，这是一尚未分配的，下一个XYD是几四，没问题吧，然后这个值是几，加二，当你改完这个数据之后，我不知道你是否有一种毛骨悚然的感觉。

为什么有毛骨悚然的感觉，这个绿色部分的数据值，跟我们红色部分的数据值一样不一样，为啥是二，你在这查询的时候，你的事务二有没有对这条记录做修改，松饼做了没，你做完修改了，不就是改成二了吗，对不对，看好啊。

这个绿色部分跟红色部分数据值一样不一样，一模一样的，没有任何区别对吧，我们的可见性算法它会变吗，都会变吗，不会变，可见性方法是固定死的，那你就要思考一件事，同学们数据值是一样的，可见性算法是一样的。

但是结果确实不能，我们都要验证了，结果是不同的，那问题出哪了，所以你要考虑一件事，在整个过程里面哪可能会发生变化，你是要做开猜测了好了，很多事情上说radio生成的时刻是不一样的。

那我们这个地方能不能大胆的去做出一个猜测，什么猜测，猜测他说啥呢，第二次的review并没有重新生成，而是用的之前的review，看看是不是这个东西，那所以我最后我这张表应该变成什么样的一，个状态了。

前面东西拿过来复制一下到这边，然后这样123我只需要把这个值改成二，比如说这个地方它是最终状态，这东西能理解的扣一，能理解吧，我猜啊我们现在只是猜测，猜测完成之后再做一件事，什么事，别忘了。

我们最终是要拿我们的可见性算法，来进行对比的，我就拿这个图和这个可见算法来进行判断，判断哪来第一个，首先比较DBTRCID等于几等于二，小于up limd，它等于几等于一，很明显二不小于一。

如果大于等于，则进入下一阶段，一定要尽量下来，记下来之后，这再来DBT23D等于二，漏里面等于几等于四说如果小于，则进入下一判断依然往下走，这时候再判断验证这个值是否在活跃事故中。

问一下在没在活跃事故中，在没在活跃事务中，在吧，这不是1232，是在里面的，如果在则代表在review生成的时刻，这个事物还是活跃状态，还没有commit修改的数据，当前事物也是看不到的。

所以这个时候你验证完可见性算法之后，跟我们最终的结论能不能对上，能还是不能，能吧，所以这个时候我们可以大胆的做一个结论，什么结论，在第二次进行快照读的时候，确实使用了第一次生成的read view。

而没有重新生成来，这句话能理解的，扣一能理解吗，那这个时候很多同学会有问题啊，说老师你这要讲的东西啊，我听懂了，但是按照我之前的认知和感知来说，它有点问题，什么问题，我之前我记得是这样的。

他是跟隔离级别有关系的，什么有关系，如果你的隔离级别是RC这种隔离级别，不管不管你之前有没有查询，那么最终我都是能看到数据的结果的，而如果你用的是RR这种隔离级别，他确实是看不到最终结果的。

这是我之前不管是看帖子也好，还是我自愿的也好，我得到的一个结论，这是你们之前认知，刚刚我在演示那个案例的时候，为什么很多同学都说错了，根本原因在于你是存在这样一个认知的。

来这东西任何同学扣一是不是这么说的，你们之前看帖子也好，干嘛也好，都是这么说的吧，别人都是这么教给你们的，是不是这意思，那问题出在哪了，问题就出在最后面，我要总结的这一句话，同学们记好了。

在RC隔离级别里，每次进行快照读操作的时候，都会重新生成新的review，所以每次可以查询到最新的结果记录，这是第一个RC这种隔离级别，既然有RC了，那么就意味着有RR的隔离级别，在R2隔离级别离。

注意了啊，只有当前事物在第一次进行快照读的时候，才会生成，review之后进行的快照读操作都会沿用，之前的read view，听明白了吗，来听白同学666刷一波。

这就是我们MVACC最终要解决的一个结论，所以为什么在隔离级别里面，你看到的效果是不一样的，原因就在于此，明白意思了，所以这一整套东西就是MVCC，它所对应的实现机制，你是需要把这套东西给搞清楚。

同时给搞明白的。

明白了吧，当然了，这东西还是很多的啊，我讲了差不多一个小时了，光这一点讲一个小时了，下来之后还是需要把这些东西好好去理解一下，好好去悟一下，把这些东西搞清楚搞清楚啊，老师是读了C吗，什么意思没懂啊。

所以把这些东西好好搞清楚一下，对看过一部分源码没看全啊，MYSQL源码太多了，没看全，看了一部分，看了一部分，我说了C语言这东西我能看懂，但让我写都写不出来，我不会写C语言，但我能看懂好吧。

是这块的一些相关的知识，把它搞坏就行了好吧，所以刚刚上面的问题，我基本上也都给大家聊完了吧，还剩下最后一个问题叫MYSQL中的幻读是啥。

手机如何解决幻读问题，来刚刚还有同学问换个问题吧，换读吧，小不点问了，问老师，二二项代替select之前如果进行了update呢，对这就是我马上要讲的换足的问题，来我们演示一个换个问题。

你来看看这换读大家都接触过吧，换读到底是啥，到底什么叫幻读问题，来，我打开这个文档给大家看一下，我这有个换图的案例。

我给你解释一下，你这边是个数据表，把数据表给大家弄一下，MVCC解决不了换图好吧，MVCC解决不了换图，我从来没有说过MVCC能够解决换图，从来没说过换图通过什么，通过加速的方式来解决的。

来做一个演示操作，看一下啊，先commit吧。

然后drop table builder删掉，然后呢我先插一张表，创建一张表，这个表足够简单吧，D好吧，name age id是主键，一共包含了三个字段信息，然后再往里面插入几条对应的数据。

结果走commit，然后select星from user14的结果吧。

这没问题吧，然后呢再来做一件事，这边一样commit select星from user，两边数据一致不一致，同学们两边数据一样不一样一模一样吗，那换读问题到底怎么产生的呢，非常简单，来笔记。

还是同时开启我们的事物，当我开启事务之后，我这边先做一个查询，Let sing from user where age，等于20走几个。

结果两个吧，那这边查询呢，一样的两个结果一一模一样吗，两边数据是一致的，然后我在右边窗口里面做一件事，什么事叫insert into user values，封号二十五十二二十五，括号80。

我现在插入一条语句，然后我再commit一下这条语句，监听好我的第一个问题，我在这边进行select查询的时候，我查询到的结果是两条还是三条，两张卡三条，吴阳系专，你白听几节课了。

chine也白听几节课了，怎么还有人做三头呢，不是说了吗，在RR隔离级别里面，只会用第一次生成的review，看这一次操作会生成read view吗，不会吧，所以这是几两条，它不会动的，当你说老师。

你是真的猛，我哪儿猛啊，没猛好吧，这两条这东西还不叫幻读，但现在我要做一次操作，看好了，叫update user set name等于连where age等于20，我的问题是，现在我更新的时候。

我更新了几条，两条还是三条，肯定成功了，两条还是三条，三条吧，看结果他告诉你三行受影响了，我明明查询到的数据是两条，但是我更新了三条，此时不就是产生了幻读问题吗，这就是幻读问题产生的由来。

是换毒产生的问题由来，所以这东西来这东西听明白，同学给老师扣一能听懂不，这不是幻读吗，明明查到这两条，更新完就是三条，明白意思吧，那换个问题你能听懂吧，那换读问题我应该怎么解决呀，怎么解决能解决吗。

能没有解决不了的问题好吧，Commit，然后呢做一件事叫TRAC，丢了把自己干掉干掉，完成之后，我再重新插入一条我们的数据老师一样走，然后commit，准备完成之后呢。

我再重新开启我们的15PB，开启之后我再查询吧，fl经from user where age等于20，检查结果吧，明白结果吧，这下是没有任何区别的，那我如何组织换换的问题呢，你在查询的时候干这么一件事。

加锁吗，加什么锁，后面加一个for update，当我加上for data之后，我在这边我依然往里面插入我们的数据，当我在插入的时候，你看到了什么效果，同学们，什么效果，我现在还能插进去吗，怎么办呢。

现在是不是被阻塞了，你这边被阻塞者，你当前插入的这条结果，你根本就插不进去，你右边这可能会产生幻读问题吗，会讲话的问题吗，不会的，产生不了半读问题，好吧。

这就是我们如何解决换图文件存在，我这边如果一旦提交了，一提交这边立马成功了。

明白意思吧，我们这边我会加锁，加锁之后解决我们对应的问题，但是我想问的是啥，刚刚缓换读的方式情况我也演示了，演示完成之后呢，我也告诉你解决方案了，我问一下幻读问题产生的本质原因是什么。

不知道为什么会产生幻读，谁能告诉我根本原因是啥，是啥也没有，不是，来记住我下面说的这句话的一个描述，这句话很重要，如果事务中进行操作的都是快照图，那么是不会产生幻读问题的啊。

但是当快照读和当前读一起使用的时候，才会产生幻读问题，来TMD扣六，这是刚刚扫描点说这个问题，因为我中间执行了一个update操作，他用了当前读，所以此时我读取的数据是不一致的。

所以此时我产生了幻读的问题，就这么简单好吧，把这东西给想明白，给解释清楚就完事了，就这样东西唉，终于讲完了，松了一口气，好玩吧，你你学会体会其中的乐趣好不好，同学们，你学会体会其中的乐趣。

我们能突然音音，这边三亚三亚是因为我嗓子哑了，不是这个麦的问题，我喊了一晚上，我喊我喊哑了好不好，为什么update是当前读，没有，为什么就是规定好了，我刚刚上面解释了，同学们，我刚上来就解释了。

我说什么叫当前途，Lost in share model，Select for update，Update，Delete in，四属于当前读，slice是快照读，我之前就说过了吗。

我之前都告诉你这些操作是啥了吗，我之前说过这东西了所有东西了好吧，所以啊这里面的细活，个人认为还是非常非常多的，还是非常非常多的，你们啊需要把这些东西给掌握清楚，这效率也太低了，什么叫下的太多了。

不是因为没加锁，加锁是为了解决幻读问题，不是说我在写思路操作的时候，我一定要加锁，你加不加锁，这件事情是跟你的实际的业务需求挂钩的，不是说我写的所有操作操作我就一定要加锁，没意义，你枷锁干嘛呢，好吧。

嗯很多人说为啥不能一样，什么意思没懂，老师你串一下吧，这没啥串的，我刚上来，我讲了事物的一些特点，然后告诉你说事物各个特点，它对应的实现原理分别是什么，我们讲了MYSQL里面的一些关键的日志系统日志。

然后呢重点聊了一下MVCC，它所对应的实现机制，你就记住MVCC它到底怎么实现的，刚刚有同学说的很对啊，别的东西你都可以记不住，但是最后的结论我希望你一定要记得。

就是这个黄框里面的东西一定要记得，这个结论才是最关键的，我刚刚讲课讲的时间比较久的，原因是什么，是因为我要带着你把这套东西给捋出来，给捋出来好吧，所以讲的时间比较久。

但其实你只需要把当前的结论给记住就完事了，南昌说当前读和快消毒与隔离级别有关系吗，没关系，跟隔离级别没关系，带节奏什么意思，带啥节奏，不带节奏好吧，男生不要再发了，当前读和快照读。

跟隔离级别没有半毛钱关系，好不好。

系列 5：P83：83、MySQL中的幻读是什么？如何解决幻读问题？ - 马士兵学堂 - BV1E34y1w773

这个加的是不加的，加的叫排他锁，排他锁，Login shr model，叫什么叫共享锁啊，你间隙锁和零件都讲一下什么叫间隙锁呀，比如说我在一个表里面插入了对应的数据，结果数据值我建索引了数据值是多少。

是一逗号，三逗号，五逗号，五逗号七，如如果你在加限期所，这时候它的构成是什么样子的，是负无穷，负无穷怎么打负无穷，无穷到一，然后中间有一个一的记录所，一的记录所就行，所然后有一个1~3间隙所。

然后有一个三的记录所，然后有一个3_{5的阶梯锁，然后有一个五，还有一个5}7，间隙锁，还有一个还有一个括号，吸到正无穷，这是我们的间接锁，那什么叫零件锁呢，零件锁也非常简单。

零件所表示什么叫左开右闭区间，连接口是这样的样子，它表示什么意思，叫负无穷到一这样的逗号，然后一逗号三，逗号，然后三根号五，然后五，编号七，然后括号七到正无穷，明白意思吗，什么叫零件锁。

零件锁不就是把间隙锁和行锁合到一块了吗，这叫零件锁，是他们之间的区别，就这玩意儿好吧嗯，就是我如果表演的记录是1357的话，我在进行加锁的时候，如果加零件锁区间就是负无穷到一，然后加一个记录锁。

然后1_{3是间隙三，然后3}5是一个间隙，五，5~7，这个间隙七到中心是一个间隙，好，这中间这样少个七，而如果你是零件锁的话，就相当于左边是开区间，右边是闭区间，开区间闭区间，开区间，闭区间。

开区间闭区间，就这些东西好吧，有啥不一样，你所定的范围不一样啊，一个带具体值的，一个没带具体值，就这点区别，没别的区别了，行吧行吧，所有东西不讲了好吧，锁东西太复杂了，如果要单独讲锁的话。

我们要讲讲好久，我觉得两个小时讲不完，讲不完一个锁的东西，讲不完一个小东西啊，这东西不聊了啊，后面我有时间我们再详细聊具体的一个知识点，server锁是在server层还是引擎层。

你要那个500锁是给谁加的，锁是给数据加的还是给索引加的，我问一下锁是给数据加的还是给索引加的，对给索引加的好吧，给索引加的一定要搞清楚了，你搞清楚，OK给索引给索引，给索引分，数据封闭，给索引加啊。

这锁这事不聊了，好吧好了，今天我花了差不多将近两个小时的时间，给大家进行了这些知识的一个讲解，下去之后，一定要把这些核心的知识给大家进行一个讲解，这两天我讲了两天MYSQL相关的知识来。

有收获的同学给老师扣波六好不好，我也辛辛苦讲两天了，有说过吗，好了讲完这东西之后，我最后面还是要强调一件事，同学们，这东西我只是把其中的某一块，的知识是吧，拿出来做了，讲解下去之后好吧。

还是要自己学会总结回顾，把整个体系给补充完整，这事很重要，我昨天在上课的时候，咱们俩讲完干货之后，我就给大家说过了，你们在学习的时候，一定要强调一个东西叫体系性，完整性，虽然很重要啊，这些知识从哪来的。

第一你可以看书，第二你可以看帖的，第三你去学会上官网，很多东西在官网里面都有非常详细，以及具体的一些描述，同时这套东西在咱们课程里面，我都进行了一个非常详细且完善的讲解。

你是需要把这些基础知识给掌握精通的，我昨天去说过了，你把这套东西如果你真的理解了，掌握了，你去面试，我告诉大家，很容易很容易，包括你在你们公司里面去面试，这些东西都会变得很容易。

我在公司里面如果遇到一些现象问题的时候，我觉得是可以解决这些问题的，前两天我记得还有一个同学也是一样的，它通过MYSQL的东西就听完这节课之后好吧，他解决了他们生长环境里面所存在的。

一些对应的问题都是有的啊，所以你需要去了解这些关键的核心点，把这些核心的知识你都要掌握清楚清楚，因为你只有掌握清楚这些东西之后，你才能够完整的知道怎么去解决问题，以及怎么样去描述这些对应的问题。

明白了吗，这就是调优所带来的知识，你需要把东西搞搞明白好吧，之前感觉了解的差不多了，现在感觉有点懵，还是那句话，那是因为你接收到了新的知识，或者你之前讲解接触的东西是不完整的。

所以导致你会出现这样的一些错觉，明白了吗，还是要把这些东西做一个完整的体系的学习的，反正东西都掌握好了，OK好了，聊完这东西之后，我们聊点其他东西，昨天上课的时候，我也给大家说过一件事。

我说同学们永远记住了，我希望听课的同学你也听两天课了，听我一句话，以后在做事情的时候，做些事情的时候，或者在学习的时候，一定要保证一个完整性，同时我希望所有人能够去树立对应的目标，这件事情很重要。

你学MYSQL就学MYSQL，不要今天学MYSQL，明天随便意思，后天学GBM大号连接微服务，不要这样一个体系一个体系的去学习，一个块一个块去学对应的学习，因为只有进行这样的学习之后。

你才能收获到对应的一个效果，才能达到对应的效果，明白吗，好吧，还是那句话，你永远不要刚学问老师这些问题，你是怎么学的，有人对学习方法好奇吗，这东西该怎么去学啊，怎么去学这些东西啊，大学啊怎么学习。

非常简单，我刚才说了书官网论坛帖子，但是你在看这些东西的时候，同学们永远记住一件事，别人给你说的东西，我希望你能够有一个最基本的判断力，明白吗，最基本的一个判断力，这点是很重要，你要能去判断。

好像你要能去判断，要不然的话你记的东西可能都是错的，特别是现在这个帖子吧，或者现在很多东西还没那么规范，所以导致很多东西可能会有一些错误的知识，会影响到你，所以你要具备对应的判断力啊，同时还有一件事。

叫这东西为什么，当你看到别人说的一些结论，或者一些对应的概念之后，我希望你能够搞明白，或者希望你能去问，说到底是为什么，别人到底是怎么实现的，这样实现的好处到底是啥，你要说清楚为什么。

然后并且寻找到对应的答案，这件事情还是很重要的好吧，选子太乱了，现在水平优势无法区分，就就这意思，所以啊找到一些关键的核心东西，或者说正确的东西尽量去学去看一下，你要有这样的判断力啊，你不能说他说错了。

你还觉得是对，我觉得你所以基本这方面判断力应该是有的，好吧行了，这东西啊咱们就聊这么多吧好吧，聊完这些东西之后呢，阿白说时间成本，所以这里面就会有个问题啊，就是你要去花时间，我再说一句话啊。

现在这个人啊不是不止你们啊，现在社会上的人不止你们，包括我在内，其实大家都有点浮躁，我希望大家能做一件事，或者你要认知到一件事情是技术，这玩意儿是需要沉淀，需要花时间来琢磨的。

我不知道你们自己私下的时候，有没有琢磨过这件事情，你也别想说，老师别人333两，别人研究了好几年的东西，我能够在很短时间内搞清楚，这事儿不太现实，就是你一定要沉下心来，知道吗。

很多同学上来之后就考虑一件事，老师我想一个月之内找到什么工作，我想音乐肯定怎么样，我觉得不对，是思路错了，你要学会去慢慢沉淀，等你沉淀好了之后，你的技术实力是能够储备上来的，如果你沉淀不好。

你的技术实力你就没法储备的，能懂这意思吗，这层现这些很重要，别着急心急，吃不了热豆腐这么简单啊，你作为一个技术人员，你应该掌握这东西，好行了，这东西啊我就不再给大家进行其他概述了。

关于my SQL相关的点干货的东西，咱们就聊这么多好吧，聊完这些东西之后呢，安排问你说现在学明年金三银四跳槽合适吗，呃我问一下有多少同学想跳槽，给老师扣个一下大楼了吗，有吗，听我一句话。

同学们跳投这件事情，是没有合适不合适，跟时间点是无关的，很多人说老师我要等精彩一课，老师我要等金，有延时，没这必要，你所需要判断和衡量的只有一个东西是什么，我现在的技术实力能否支撑我跳槽。

或者说能否支撑拿到更高的薪水，你只需要去判断这么一件事就够了，你不用去在乎时间，年底的时候岗位是少，虽然岗位少，但是不代表没有招聘机会，金三银四机会是多，但不代表能把你要搞明白吗，他一样。

你的技术实力能否具备足够的支撑，昨天晚上上课的时候，其实我说过这件事情，兄弟们，我也强调过这件事情了，昨天我问一下，昨天有多少人领过咱们的路线了，留着给老师扣一，有多少人领过了，懂吗。

昨天上课的时候给大家分享了很多，我们关于学习，我关于你自己定位相关的一些路线，就说你到底要怎么样去完成，自己的一个技术储备，永远记住一件事，同学们这件事，技术是学习不凡的。

你不可能真的把所有的技术都掌握精通，但是你要有自己的加分项和你自己的亮点，你只要有自己的加分项和自己亮点啊，那我觉得就可以去试一试，昨天我在展示我们对应的课程路线，比如我们课程大纲的时候，人家说过了。

你们现在做开发的同学，或者你们现在的同学，我不知道你们现在是什么样的一个水平，什么样的一个层次啊，但是你现在最起码是一个基本的开发人员，那么我觉得你做一些最基本的开发功能，完成一些CD的工作。

你是没问题的，如果你能够独立的去做一些开发了，那么下一步你的目标你就要去做，什么叫操作与落地，不单单是说我只会CLD，你要掌握非常非常丰满的一些技术战，我也说过了，说这东西很难去评判，说我什么。

我现在是什么水平，以及我要达到对应的什么水平，这个很难去评判，但是阿里是有一些对应的职级的，你是可以把这些职级来匹配到你个人的身上，然后按照这样的一个直接的要求，去做一些对应的技术储备的安排。

说我昨天拿到之后，不知道从何下手，这样我一会儿把路线再给大家详细的描述一下，你到底应该怎么去学习，路线，应该怎么学习啊，如果你还有困惑，一会儿每个同学可以把你个人的情况说明一下，说明介绍之后。

我依靠我个人的经验，和我们现在收到学生的一个情况，给你做出一条合适的规划出来，我的个人情况里面，我希望你能突出的是啥，有以下几个信息，我需要知道，第一个是你的城市，第二个年龄，第三个薪水，第四个学历。

第五个基本情况就是你工作的一个情况，跳槽情况，第二个就是你的预期，你把这些东西告诉我，我一会给你一些针对性的建议啊，每个同学你可以发一下，那下面我来聊一下我们的这个路线，你到底应该怎么学哇。

我们一步一步聊，先聊P6这个级别，如果你现在能做独立开发了，那么我认为你下一步应该冲击的目标就是P6，当前这样的一个级别了，那P6里面你需要掌握什么技术，其实没几块，第一块就是底层技术实力。

很多同学进入这个行业之后，都是培训进来的，你可能没有对应的计算机的底层技术的支撑，所以你需要储备一些像turbo系统，计算机组成原理，网络IO，LINUX系统，数据结构和算法这样的一些基础知识。

像这块知识它属于什么，这属于啥，有人知道吗，他是你在上大学的时候，你科班应该学的东西，但是咱们有很多同学都是非本专业的吧，来有多少是非本专业的，或者说非计算机专业的，给老师扣个一，有没有，没有啊。

都是很专业的吗，不可能吧，就你是非非本专业的，所以你是需要把这些基本的技术和基本的技能，给弥补起来的，这东西它会影响你对于很多技术，底层的储备和学习，所以你是必须要看的明白吗，必须要看的好吧。

这是第一块底层知识，咱们都有对应的课程进行讲解处理方式，第二部分，像现在聊并发编程聊的比较多，聊多线程聊的比较多，所以像多系统并发支持队列的知识，内存逻辑的东西，线程池的东西，cs的SLOCAL的。

GOC的，你都要掌握这些东西啊，你在工作中可能用不到，压根用不到，我坦白说可能用到的几率并不是特别大，但是面试中这是一个重灾区，为什么说面试是存在性，因为大部分同学因为工作中接触不到。

所以他对这块知识的掌握是有失偏颇的，或者有欠缺的，所以导致他这块是个弱项，那面试官为了考验你个人的技术实力，他就会拿着你的弱项来问吗，所以你需要把这块当成你的一个强项，来进行相关的技术储备，明白了吗。

这是第二块并发编程相关的技术，我觉得这块是所有人都必须要学的，第一第二都是所有人必须要学的，第三块叫RPC通信框架，原理这里面包含什么，像OKEEPER，像double rpc gr。

Pc rascal rap，NIKE等一些东西这块啊，我觉得你尽可能的去了解和掌握，为什么，因为现在这样都是分布式，微服务的一些交通框架，它都是分布式要进行这些消息通信的。

这里面一定会进行到一些通信框架的一些包装，或者使用这种东西，它不是一个必备技能，但是它一定是一个加分技能，幸好加分技能，如果面试中你提到NT，你能把底层那些NL这些东西，聊的非常非常清楚的啊。

对面试官而言，对你的评价一定很高，因为很多同学或一般的开发程序员，对这块知识是缺失的，而如果你了解了，你就是加分项，你就是能比别人多赚几千块钱的点，就在这是这部分好吧，第四部分中间件，这就不用说了吧。

在公司里面，你除了在一些外包和传统行业里面设计中间件，几乎必用，现在现在用的比较火的两个周边，mp卡夫卡这样东西你必须要掌握，像ITMQ的好，rock mq这东西有些公司在用，有些公司没用。

但我不要求你全部都会有选择性的看，最起码你要做到一个是精通的，其他几个懂我略懂明白吗，你别提到中间件了，是谁都哪个都说不出来，哪个都不精通，完蛋了，把一个京东啊，其他的东西基本了解构思了。

面试的时候有你自己的一个长处，和你自己的一个加分项啊，这是中间件的这个级别，然后再往下是缓存应用的级别对吧，像map catch是原来用的，现在几乎map catch都已经被淘汰掉了，除了MCD之外。

下面的REDISREDIS不再是那种单机的REDIS，是分布式的或集群的REDIS，现在dis到六了啊，后面我们马上也会进行六版本的一个更新，你都要进行储备对吧，包括像科班要学的软件设计基础这东西啊。

它属于一个怎么说基础技能吧，如果这块你不了解没关系，时间紧的话，暂时可以先不了解，但有时间的话，最好还是看一下像敏捷开发这样的东西，我觉得你还是要了解一下好吧，以便于你自己能做更高效的开发工作对吧。

再往下就是分布式架构问题，分布式架构专题里面，并不单单是包含，咱们之前了解的什么分布式事务了，分布式锁了分布式id了，不单是这些东西，还有很多其他技能，比如说分布式预警对吧，分布式链路追踪。

分布式权限控制，分布式id，分布式幂等分布式任务，分布式通话，这都算了解的，对你不要说老师我拿个分布式锁，分布式事务是不是就可以了，现在面试分布式事务，分式锁几乎必问，问的也很多了，几乎也烂大街了。

所以啊掌握一些其他的核心点好吧，再往下像微服务的什么配置中心了，注册服务与发现了网关路由了，服务端用了负载均衡了，熔断降级限流了，这东西好吧，包括现在主流的NETFLIX和阿里巴巴。

两套微服务的技术体系站，能够了解它也是一个必备技能好吧，性能优化的它是加分项，便于勘测你对应的工作实力，向这边M采购MYSQL调优，tomcat调优N这个调用对吧，以及超大流量的一些项目。

调优方面的点都有啊，这块也是一个重要的点，因为调优项能表示你具体的工作经验，和你的工作实力，这块如果答得非常好的话，他100%的是一个很好的加分项，好吧，再往下降一些海量数据存储的。

现在比较好像E了click house了吧，MYSQL的太dd了对吧，像这样MYSQL你们可能是最熟的，就像E了house和带dB也要有所了解了，它表示的是最新的技术。

很多同学在公司里面或者在生产环境里面，可能暂时用不到这些技术，但是我觉得你要储备，还是那句话，你要保证你技术的一个东西叫前瞻性，明白了吗，前瞻性虽然没用，但是我要会，如果公司要用了，我能够立马上手。

而不至于说我所有东西我要重新开始学，如果你所有东西都重新开始学的话，那这个效率就太低了，明白意思了吗，好吧，再往下还有什么ELK相关的东西，就ES的对吧，还有海量数据存储的，像大数据的一些东西。

还DOHBASE，还有FLINK这些东西好吧，以及下面的像网络设施运维的知识，要了解一点，注意啊，运维这个东西它表示的是什么，你要具备运维的一些基础能力，最起码LINUX相关东西教会吧，CDN啊。

DNS这个词你要会吧，把静态资源也要会吧，这东西就是基础知识啊，包括像DIOS的对吧，Docker k8 s，另外这东西你要你要了解到，这边还有些武器的测试，相关的最基本的测试要了解吧。

以及我们service mesh，像excel相关的点都要了解，所以这就是P6级别你要储备的点，这里面有重点有非重点，你可以把你自己的薄弱项先重点补全，这边画的，比如说并发编程比较重要，中间件比较重要。

缓存原件比较重要对吧，性能优化比较重要对吧，你能不能先看这几块，看完这几块之后，如果你还有时间，我再看其他东西行不行，是不是这意思，这么多技术点，并不是说让你一口气，全部在很短时间之内我都补充完整。

不是这种目标，是为了让你能够有一个方向，有一个目标，我能够持续地学习下去，不至于像一个无头苍蝇一样随便乱转，今天看这个，明天看那个哪个都看不清楚，不要这样啊，这不想看怎么办，不想看，你就等着被社会淘汰。

被行业淘汰，如果你想在这个行业里面干的时间更久，必须要看，逼着自己看，也要看，不看怎么行呢，必看好吧，还不想看怎么办，想拿高工资吗，想脑筋吗，人生在世总有很多你要逼自己做的事情，但是还是那句话。

你想不想做，其实说白了就是懒嘛，就是懒嘛，懒这玩意儿啊，有的天性，但是怎么说，当你遇到一些更加现实的一些情况的时候，你会为你之前来买单，但现在听课学生啊，我不知道你们的年龄多大。

特别是一些年龄大一点的学生，人大的学生，他很多同学发现在出去找工作的时候，容易被行业淘汰掉，原因是什么，原因就在于他之前欠的债，其实你们现在感觉薪水要不上去，工作年限很久好吧，都要不上去。

薪水其实都是债，那是出来混总是要还的，你现在之前年轻的时候欠下债，你现在就要还了吗，可能会很辛苦，可能会很疲惫，没办法好，下方飞车老师这技术图能翻译一下吗，如果谁需要要当前的技术路线图，好不好。

报告小姐姐找你的班主任老师，去进行相关的一个允许把对应的资料领取过来，路线给免费发送给大家，这东西只是我们对应的P6级别的相关技术，除了P6级别的相关技术之外，我们还有什么，刘老师老师，我达到P6了。

我现在要准备pg级别的知识怎么办，咱们P7也有P，这叫什么叫落地以实战好吧，还有P7的，有人想看PC吗，啊有想看P7吗，想看扣个一吧，有没有，行吧行吧，你去看一眼，简单看一眼好吧，你可以不了解。

但是我觉得简单看一眼好吧，PC里面主要包含什么，包含是另外一块东西叫原理与设计，这里面呢其实我们也包含了几个重要的模块，第一个是分布式的一些理论基础，像什么CP了。

popuels rap这些东西都要有啊，还有一些分布式算法的一些支撑的东西对吧，好通过算法支撑的一些东西，包括像我们有一些架构原理和源码的一些设计，这里面包含了像spring全家桶源码对吧。

ORM相关的一些源码，老头们看的源码，spring color源码，MQ的源码对吧，net源码propose源码ELK的源码，几乎各个源码环节，我们都会给大家讲的比较详细。

因为你想成为一个高开或想成为一个主城，想成为一个架构师的话，那么必须要储备这样的知识，明白吗，好吧，当然原版的东西啊很难难是难，但是该储备的依旧要储备，你不能说因为它难，所以我就不学了。

你如果因为难不学了，你告诉我，你怎么样能保证更好的一个那个那个薪水呢，就一定要注意啊，你如果想比别人要的薪水更高，就意味着一件事，什么事你必须要会点别人不会的东西，如果别人会的东西你也会。

那你告诉我凭什么凭什么你拿高薪，别人拿低薪没道理的对吧，除此之外还有我们的高性能架构设计的东西，比如说分流的设置，服务并行并发的设置，缓存的设置，存储的设置，可靠性的设置对吧。

应用保护层的设置都要有好吧，这块大家需要记住了，O下面还有最后面就是最关键的一些东西，如果你想成为一个高开或成为一个主城，还有一个最主要和最核心的一个点是，什么叫架构设计方案，什么叫架构设计方案。

这东西怎么去理它，记住了同学们所谓的架构设计方案，指的是里面包含这几块，第一个叫每秒数10万超高并发通用设计专题，叫N个九全员路高可用通用设计专题，有云集百万年薪案例驱动架构设计专题。

以及我们的一级流量，多级缓存架构设计专题，现在啊，你在面对一些大厂的比较高级别的职位的时候，基本上都会聊到架构设计相关的点，那么架构设计是啥，比如说红包雨怎么设置，怎么设置，你需要哪些技术。

站在面试的时候，如果问你这样的问题怎么办，你如果对于技术的储备是有问题的话，你很明显这东西达不到的好吧，这是P6和P7，你要掌握相关的一些技术，除此之外，有些同学说老师我项目也比较薄弱，怎么办，没关系。

咱们呢也有很多落地的项目，网游服务器的东宝商城的单体版本的电商，单体单体电商，包括我们的分布式电商，包括我们的飞机出行，包括我们的推荐系统流程平台我们都会有好吧，课程到底课程到P8好。

我们现在授课老师里面都有P8，老师来给我们进行授课，真P81会来给大家聊一下，是老师好吧，这后面还有说老师如果想去面试怎么办，没关系，我们有短期的这种面试必须跳槽的东西，比如说难题的解析，简历的指导。

面试指南，晋升的指南都会有的，除此之外，还给了很多高级别的工程师，和高级别的开发人员，也准备了一些设计专题，比如说资深架构师应该掌握的技术体系，这里面有云原生相关的技术，有常见的大厂bug处理专题。

我们请了一堆的大厂的兼职老师，让他们把他们在生产环境里面遇到的问题，给大家进行复现，复习完成之后，上课给大家讲出来以后，你在面试的时候就能够游刃有余地去回答，这些线上事故点啊，都会有。

对应一些架构设计的解决方案对吧，这东西除此之外，我们还有CPU级别的一些加固专题，这里面涉及到是什么团队的管理对吧，领域驱动的一些设计，包括像智能化应用的一些设计，以及我们的产品管理都是比较完善的。

这里面的东西也都是需要进行储备和学习的，所以如果谁需要完成路线，扫描屏幕右上角二维码，或者找咱们的班主任老师领取，如果你之前已经加过咱们的小姐和班，主任老师了，好吧，直接直接告诉他。

我来领取对应的路线就完事了，是刚刚给你们看到的，只是说你们当下这个阶段里面，你们应该储备和学习的东西，其实除了这些东西之外，你觉得学技术的最应该保持什么东西，朋友们啊，除了这个之外，还要还要有啥。

同学们永远记住一件事，技术是不断的更新的，技术是不断的迭代的，技术是要不断的进行学习的，所以除了这些具体的技术点之外，咱们还推出了一定，每天每个月对应的一些课程更新的计划。

可以给大家看一下，我们在官网首页，你们自己可以点开我们的官网去访问一下。

在官网里面，我们上面有一个专门的专题叫做科研更新，这是我们在11月份要进行的相关的课程更新，大家可以看一下对吧，go web相关的课程，open CV的课程，鸿蒙系统的课程，typescript课程。

三高项目课的课程，随便点开一个里面都有对应的课程，课程大纲以及对应的课程授课老师，以及对应的具体的时间安排，全部都有啊，光我们的科研更新每天都有，包括我们的fable对吧，包括我们的数据中台，对不对。

包括项目部署的领域驱动的，以及后面还有XTP7的哦，开里的一些设设计东西，游戏高级架构师的网络安全的，air flow的分布式那个任务调度的对吧，以及后面的jvm tomcat源码，卡夫卡的源码。

包括P3高项目商城的，连青岛普罗米修斯的对吧，还有我们的TDV的dis es nbis，三个项目课的等等一系列科研更新啊，课程每天每天都在进行不停的直播，不停的更新，所以你过来之后，你能享受到的是什。

除了现有的知识体系，知识框架之外，你能一直跟着咱们的直播课程去学下去，我可以给大家展示一个东西，就是马士兵教育对应的直播课表，这个课表你们可以随便去看，随便去对比，没有人能比得过。

这是我们这一周的这一周的直播课表，今天晚上我给你们上完公开课之后，训练营之后，明天晚上接我的VIP课，我明天晚上还要讲去VIP对吧，每一周至少应该是十节课，加上VIP课。

你可以跟着VIP课进行不断的技术储备，听明白了吗，所以有很多的课程，你都是需要进行储备和学习的。

这才是能保证你长期在这个行业里面活下去的。

一个最根本的核心点，懂我意思吧，啊这是我们对应的科研中心是吧，那我们同学会问刚刚那个路线，我解释清楚了吧，有没有同学好奇说老师我到底应该怎么学的，有人放心吗，这老师你刚刚展示大纲里面展示了那么多东西。

那么多东西我到底应该怎么去学习，或者说我应该学习哪些点，我该怎么办，这告诉大家，我们为了能够更好的服务和帮助我们的学生，我们对每一个报名的学生，会制定对应的课程学习计划，有大问说怎么成为VIP。

说老师我想成为VIP学员，他会告诉你你要进行什么样的一个操作，以及做什么样的操作，你能够成为对应的VIP用户啊，就是购买我们对应的一个课程就完事了，就这么简单啊，购买对应课程就完事了是吧。

这个课程叫什么叫MCA，一会儿我来给你详细说一下MC课程体系，刚刚我展示的课程大纲，包括那个路线，其实就是MC课程体系的一个路线对吧，而且我们要做的事情其实不止于此，我们还在做什么。

我们给每一个报名的学生，其实都制定了我们对应的课程的路线，因为东西点很多嘛，同学们也知道很多课程点是非常非常多的，所以你可以免费注册码视频教育的官网，搜官网之后，你会有对应的体系课程，你购买什么课。

什么课都有对应的讲解好吧，然后呢下面之后会有一个东西叫学习路线，当你报名之后，老师会根据你个人的情况，给你制定一套属于你自己的学习路线，这些路径也包含了很多的点，比如说这个同学的里面要包含。

它是一个年龄比啊，只需要技术提升，年龄比较大，不需要换工作，他需要做一个体系性的学习，那么里面就包含了这一堆东西，从技术计算机底层开发技能源码，补充分布式服务，微服务的中间件的，云原生的项目。

实操的等一系列东西，他在搜到这样路线之后，可以干些什么事情。

当你的鼠标放到每一门具体的课程之后，就可以直接去点击到对应的课程里面。

进行相关的技术学习了，而不需要你去找别的课课，老师已经给你排好了，你直接在这地方进行查看和学习就可以了，而且你可以在当前这个平台里面。

是提问自己的问题啊。

可以有问答对吧，提问题之后，针对当前这节课，老师会给你做做对应的答疑，同时还有对应的笔记，我可以上传自己的笔记，做好对应的总结都会有，你在平台里面你可以学直接就学了。

明白明白意思吧，对而且每一个学生跟每个学生，我们真正的路线其实都是不一样的，这是王志刚的对吧，他因为工作一年经验不太多，需要储备，这样的一些技术，把面试或工作中常备的一些技能项，你要储备精精通。

储备基础对吧，包括下面还有存宝骏的对吧，这样的一些课程路线，当然有一些同学，他的情况可能符合绝大部分的情况，那么我们也会给予对应的呃路线的一个讲解，或者对于路线的一个分配，而且每一个学生并不是说。

这个路线就一次就不变了，不是这样的好吧，你后面如果有需要，我们会把你的课程都进行一个更新，或者都进行路线的一个安排，循环一次再来一次，再来一次之后再来一次都是没关系的，所以在你整个学习过程中。

老师会为你保驾护航，你在什么时候遇到什么问题，请找老师沟通，老师都会给你讲解对应的路线点，以及最适合你自己的一个安排，好吧，那么讲到这了，有人好奇这门课多少钱呢，好奇的给老师扣个一，有人好奇吗。

就刚刚我还少了一个很重要的环节，没有讲很重要的环节，没有讲什么东西，这些课都是有一些老师讲解的，有人好奇咱们机构老师吗，燕青瑶说，所以说有没有怎么学讲解，没听懂啥意思啊，2万多啊，不需要2万多。

不需要2万多，这里面啊我先跟大家说一些东西啊，先把咱们的老师给大家说一下吧，就是你看完这些老师之后，你就会知道这个课程里面，具备什么样的一个实例好吧，首先老师有哪些马思明老师给我解释了吧。

很多同学可能都是看马老师的视频，直接入行的吧，这是马思明老师，除了马思明老师之外，还有我们的周志磊，是老师对吧，讲IO的，讲REDIS啊，大牛老师把这个视频关掉，声音大妮老师好吧。

很多同学评价周老师的课，跪着听周老师课，如果你见过周老师本人的话，你会发现周老师的发量也非常感人对吧，除朱老师之外，还有我们的曹鹏飞，曹老师，他是之前阿里的啊，花名叫霍州，我们一样支持备调对吧。

包括还有我们的徐克徐老师，他也是阿里的阿里的P8，花名梁琴，一样支持被调好吧，还有还没写啊，等会拖拖一下，对吧，还有我们的黄金王俊，黄老师之前也是阿里的，发名叫博西，熟悉好吧，包括还有我本人好吧。

你们听了我讲两天课了，应该这个吧对吧，应该对我意思就有一定的了解了对吧，包括还有我们的左成云郭老师对吧，俗称左神嘛啊，讲数据结构和算法的老师，包括我们还有一堆的张福刚，张老师主要是讲大数据的。

国内第一第一批检查数据的呃，老师包括还有我们的肖斌啊，肖老师以及我们对应的杨淑娟，赵老师，赵珊珊，我都不相信姐姐介绍了，赵珊珊老师对吧，还有还有谁啊，吴磊老师E的专家，还有我们的呃，陈瑞丰老师对吧。

我们的邓洪波老师，对我们的严振涛老师，我们的呃谭老师对吧，包括我们从那个呃之前在京东，现在碰到新浪微博的孙老师，给大家讲大厂15班的对吧，包括我们有呃录冯坤陆老师对吧，还有我们的毕老师李旺盛。

毕老师对吧，一级点点点点点一堆啊，这老师我给你数不完，马士兵教育光老师好，四五十类肯定是有的啊，这一点都不夸张，所以你过来之后，你能收到各个老师详细的一个照顾，所以把心放肚里边过来。

踏踏实跟着学就可以了，这些课程都是由这些老师来给大家进行讲解的，所以这么牛的课，这么完整的学习路线，加上这么多老师啊，对写错字了，我对不起你啊对吧，这么多老师是吧，所以足以保证我们对应的课程质量。

所以当我提到了，我们说这个课程课程多少钱，阿白说2万多，其实不需要2万多是吧，今天是咱们的训练营，那么我想说的是啥，同学们今天训练营有一个专门的专享福利。

可以给大家看一下什么专项福利呢，就这东西好吧，今天晚上训练营里面我们就要顺势而为，乘风而起，MYSQL调优专属直播间，MCA架构课程，架构师课程，今晚原价格是24980，今晚只有十个名额。

可以领取一个121万2000元的大额优惠券，比如说今天晚上，你实际的成交价是12980好吧，这些优质的课程内容我就不说了，最关键是这边今晚报名之后，你能够享受我们对应的课程更新是吧，同时再说明一件事。

同学们一件事什么事，仅限前五名赠送VIP的黑卡服务，我们有一个VIP的黑卡啊，这个VIP黑卡我希望你领取一下，今天晚上仅限前五名黑卡是什么意思，黑卡代表的是你对应的福利保障，这图有点小啊。

哪个小姐姐把这个黑卡图片给我发一下，没有小姐把这个黑卡图片给我发一下，我这没有这个黑卡图片，谁给我发一下，这黑卡里面代表什么，代表你对应的福利啊，代表你对应的福利啊，好了来给大家看一下好吧，叫成就定制。

未来成就更好的你，这是我们的口号，说了第一你的VIP黑卡会想到什么，第一叫个性化方案定制，第二个这大厂的优先类推的机会，第三个叫已报名体系课，一元每年的持续更新服务，什么意思，刚刚我给大家看到了。

我们的课程一直在持续不断的更新的好吧，那么每年你只需要象征性的给我们交一块钱，那么我们就可以把这个课程更新，你可以永久的一直听下去，一直听下去，但如果你不是VIP黑卡的话，那不好意思。

你能享受权限只有两年的时间好吧，当然这个一元的这个权限给大家说，很快就没有了，前两天马老师做直播的时候已经说过了，之后我们的VIP黑卡的权限，如果想享受课程升级的话，每年是888元。

今天这个训练营只有一元每年。

当然我也说过了，这个权益不是所有人都有的，仅限前五名，所以抓紧时间去抢就完了，同时今天晚上报考的同学可以享受白条，有钱花，信用卡，花呗等一系列的六期分期免息名额，当然这个名额也是只有十个哇。

多的也是没有的，所以我说了，抓紧时间联系咱们的小姐姐，扫屏幕上的二维码就可以了，如果你之前加过任何一个咱们的咨询老师，不需要重复加，告诉他，我是从连老师直播间过来的。

我要去领取对应的优惠以及黑卡服务就完事了，这么简单好吧，所以抓紧时间吧，龙帅说，都是网课，对咱们现在没有这种线下课，全部都是网上直播，因为现在啊我们的学生人群，重点的话是在职的学生。

所以他们不可能说我拖延多长时间，我来做一个完整的机器学习，这是不可以的啊，所以我们更多是网课，每天晚上你只需要拿出两个小时的时间，随机几个月的机会，3~5个月涨个几千块钱，对这边而言是非常非常容易的啊。

非常非常容易的，所以抓紧时间抓紧机会就可以了，这边所有想做的课程更新都聊到这了，如果你想做的课程更新更新，今天来就完了，就这么简单好吧，关于活动相关的点，我大概就要这么多好吧。

我身边一个PC一个批发一个P9，所以如果你想拿到更高的一个薪水，你是需要跟更牛的人一起服务的啊，同学们永远注意一件事，如果你想让自己变得更牛逼，一定要认识比你牛逼的人，你在跟人做对比的时候。

不要只看那些比你差的，你要看那些比你好的，混的比你强的，这样的话你才有提升，你现在跟比你差的，比你优越感很足，你同时意识不到自己存在的问题，懂我意思了吗，好吧嗯，有没有项目实战。

我刚刚在展示大纲的时候已经给大家说过了，好吧，在最下面的时候，我们有对应的项目实战，比如说我们的多人在线网游服务器，相关的一些课程，包括我们的东宝商城一个电商的单体版本，包括我们的东宝商城的一个。

分布式微服务的一个版本，以及我们对应的网约车，飞机出行，网约车项目，还有我们的推荐系统的项目，和我们的流水云平台的项目，这边全都有是吧，东宝商城里面包含什么，包含这些东西好吧。

完整发现DIOS代码规范落地实践，包含了我们一系列的基础设施，服务之间包含了我们对应的分布式id中心，配置中心，分布式锁集群，事务集群缓存集群，网关服务集群注册中心，监控中心，MQE任务调度。

Tx mysql，业务方面的话，包含了用户中心，商品中心，库存中心，订单中心，搜索中心，评价中心，客服中心，推荐中心等等东西，自己看网课遇到不会的，找谁问，你这个问题说的非常非常好，如果说老师。

如果我在学习过程中遇到不会的问题，我应该怎么办，好吧，来给你看，我们看别的啊，看这东西，这些学生，前两天就前两天刚给我发的这些学生嗯，文件完整的东西好吧，这说了老师这个注解会导致什么问题好吧。

这是我的问题，老师给我们解答一下，好吧，两个字要这么讲的，这是跟这个人整体的一个答疑的过程，他发的信息，然后我来给大家做一些解释，给他进行相关的一个调整，看到了吗，你有问题，每一个学生报名之后。

老师会给你做规划，除了做规划之外，会给你拉一个独特与主属于你自己的一个群，你有任何问题，可以直接在群里面跟老师进行沟通，明白了吧，好，包括你相关的一些面试过程中，你遇到一些面试题也可以老师自行沟通。

包括我们在官网上面有自己专门的知识，问答社区，就类似于是一个问答系统，你可以把你的问题都提上来，看一下已解决的问题，每天我们有专门的老师，专门答疑团队在里面去解决这些相关的问题，都是有回复的，明白了吗。

这啥玩意儿对吧，CAP模式看到了吗，老师都会给予对应的回复，所以不管是群里面也好，还是我们自己的问答也好，你都可以在里面进行提问，明白意思吧是吧，那学生说，过去每个学生都是这么回回的过来的吗。

反正大部分同学遇到问题之后，老师都会给可以回答，就比如说我今天晚上上课，我在上课，你们去看一下我个人微信，我都没去微信，这是我个人的微信，现在有44条消息没回，我下课之后。

我也要去给学生们做一些问题的答疑，问题的解答，这也没办法，因为学生们在学习过程中，一定会遇到各种各样的问题，那遇到问题的时候，你只能去回顾吗，很大的工作量，咱们有老师。

这你不用担心好吧嗯，这不是你需要担心的问题，你需要担心的问题就直接就一点好吧，你能不能学会东西，能不能学到东西，就这么简单啊，回到几点，老师上午的时候老师一般都在休息，但是像下午和晚上。

老师一般都在回答问题，昨天晚上我还在跟一个学生聊天，我可以给你看一下，是一个国外的学生，我们聊到差不多一点多，我给你看啊，这个学生我直接给你看嘛，没关系的，能看到吗，看了吗，再跟大家聊天，回到几点。

我这事不给你不敢领导了，但是我最终跟他聊天的时候，聊到0。46分，0。46，这老师有问题的话，老师也一定会给你对应的回馈，而一定会对你给你给你回答，是凌晨的时候。

今天凌晨看到了吗，这个你不需要担心好吧，如果这个东西我们做不到，问题是我们的问题，这个你不需要不需要担心，OK这种问题可以直接问老师吗，那不问老师问谁啊，所以你过来之后，你不是说你单单买了一套课。

我们其实一直想打造的是一套东西，什么叫程序员的一套在线，职业提升的一个技术解决方案，所以从你开始学习开始，老师会在你整个职业生涯里面为你保驾护航哦，你只需要踏踏实实干就完了，所以我说了。

今天晚上在这个训练营期间之内，同学们报名的话，成交价只需要12980，前五名可以免费获得我们对应的黑卡服务，同时有的同学老师我手里没钱没关系，我们有六期分期的名额，但是依然只有前五名。

所以同学们有需要的话，干就完了，就这么简单好吧行了，多余的废话，我这就大家都说了吧啊，我觉得相关的点我都解释清楚了，或者你们有什么问题的话，也可以直接抛出来问一下，如果没问题的话。

同学们可以仿照上面这样的格式，我会给大家做出一些对应的规划，或者给他做出一些对应的建议，当然有很多同学可能会好奇一件事，老师我学完你们的课程之后，我最终能达到什么样的一个效果。

今天下午在群里面还有一个学生在问，说他有一个学生我忘了是谁说的啊，说他有一个朋友从8K涨到了25K，你觉得可能吗，那么我问一下，我忘了下午是谁在群里面聊这个话题了，你觉得一个人有可能从8K涨到25K吗。

有没有可能，所以有可能扣一没可能画半年嘛，我也不知多长时间就半年了，可能吗，说明一下这种情况有，但它不是它不是一个普遍情况，但是不意味着这件事情他做不到，做不到明白吗，是挺离谱的。

但是确确实实还有人做到这件事情，我一样，我可以给大家看一下，下午那同学说完之后，我给大家截了一个图，我手里面还确确实实确实有这样一个学员，可以给大家看一下，这是去年的时候报名的一个学员。

2022年十11月13日说李老师，我阿里巴巴面试通过了啊，我说我说我属于在迁移数据，刚买了新手机再迁移数据对吧，没法给他打电话，说没事，微信跟您说，不知道，P6昨天谈到offer。

下周应该offer被调了，上个月28号开始面试的，给了25K直接就接了，我直接算快的了，涨薪多少，所以说去了飞猪出行，原来是8K涨了三倍多，我说厉害了，他说我说我这个是中学招生。

我说我说必须可以国企出身，学了多久，学了应该半年多，20年4月份买的课，才看了课程的1/3，看了吗，迈进大门了，后续继续努力，感谢李老师，感谢机构，就知道报这个准没错，看没意思了吗，好吧，然后往下走。

他还干什么事，他自己成功之后，他说老师11月16号的时候说，老师我有个室友想报名，想了解咱们的课程，啥时候有空，咱们电话沟通一下对吧，打电话，然后还有什么老师。

我这边缺人，咱们这有差不多的吗，HC还挺多的，把他们的招聘要求发过来了。

要求要要人，所以你只要跟着咱们的课程体系，踏踏实实的去进行学习，进行技术的一个储备，涨薪这件事情真的没有大家想象中的那么难，明白意思吗，啊我一直给大家说一句话，我说如果你想干一件事情，办法总比困难多。

而如果你不想干一件事情，那么困难总比办法多，就这么简单，所以你想不想或者说你想达到什么样的目标，你想追求什么样的目标，如果你想，你就要动起来了啊，而且你要抓紧时间跟着干，加油干，明白意思吗。

如果你不跟着干，那就完犊子了吗，这么简单是吧，软蛋如是说，妈耶妈耶咋了，别人拿到目标，你能拿到吗，这个也不是一个个例，我不是说拿一个个例情况给大家进行展示呃，我会给大家看一个东西啊。

我之前记录过我手里边掌心学员的一些情况，找一下这个文档啊，我专门留了一个文档，然后文档里面就是我们的学员的情况诶，怎么没了，这里面我把我们现在掌心的学员的情况，基本上都记录名字，基本上记录下来了。

我一会儿我可以可以看一下，对应学生的一个信息，诶，我们游到哪去了，搜一下，嗯找一下，等一下这个，来我给你看一下好吧，这手里有一堆的学员都找到对应的工作了，给你看几个吧，咱也别多看了好吧，3年正常是多少。

这要看你在哪个城市啊，你城市不一样的话是不一定的，看看这学生的，真的联想通过你的修改简历好吧，我已经拿到了20K的offer，给他发的东西如你所愿，17+2，17+3转正，就是9月1号可以入职吗。

甲方是吧，做的海外金融项目，我本来是去试水的，没想到就成了，谢谢连桑，如果没有联想的，知道我没有没，不仅没这么快，找到满身明教育联三最好满分服务，看到了吗，拿了几个offer，173K的，19×13的。

看到这意思了吗，这是学生基本情况，12说认真学四个月能涨多少，这要取决于你现在的贝斯多少，以及你对应的目标多少，这个没法统一给你概述啊，但是按照我们学生大部分的一个普遍情况来说，普遍情况来说。

如果你学四个月涨个5000块钱是问题不大的，涨5000块钱问题不大好吧，这是一个学生了吧，还还想看其他学生资源案例吗，想看给老师扣个一，你想看什么，所以我给你看，我手里面到底有多少同学，他成功找到工作。

还有吗，有很多是很离谱的，有很多也不太离谱，好吧，来给你看一下吧，看这哥们儿，这哥们什么情况，我来看，这是21年6月份找我的，说梁老师上次那个面试的，我学完了，可以给我制定一个新的技术提升方案吗。

已经规划过一次了，这是规划第二次，大家要重新规划，我说涨薪了吗，他说涨薪了到40了吗，这个学生我印象比较深，他年龄比较大，然后想从想一个月之内，从一从31K涨到41K吧，应该是我没记错。

就这样我到40了吗，我记得你心花40的都对到了，拿到了41K是吧，我说这才多久两个月吗，说是的，大家可以看一下这个时间，他找我汇报的时候是6月23号，你可以往上翻，我们整个规划服务里面给他做的答疑。

简历的批改，整个这个过程，他当时报名的时候可以给大家看一下，这是几号，2021年4月29号，从4月份到6月份好吧，他的期望其实也非常简单，往上看，目前薪水是31K对吧，计划一到两个月之内期望40。

他真的成了这个成了，所以不要小瞧说我能不能做到，你只要敢想就能做到安排，说有成都的吗，还真的有成都的呃，成都的我给你找一下啊，成都，不是这个你从哪搜吧，我从这边搜吧，嗯这是我们对应的就业起爆墙。

在里面一定有成都的，看这个，这有写吗，看一下有写成功吗，没写是吧，那些换一个，看到他说已经入职了，看这选项情况啊，他说已经入职了好吧，然后呢，薪资多少涨多少，接近翻倍了，学多长时间，学了三个月啊。

他也是成都的，再来一个这个这有写吗，怎么没写到啊，收到几个offer，电力封了，然后叫用有的，然后两个公司好吧，感谢马士兵教育什么东西，去年的时候面12K都是比较虚的，袁老师好，哎，这个有。

这是我的学员，我说一下电力风，诶知道了，再往下看看，这哥们儿，我说了，我这有很多成功的一个案例啊，王二狗看这个吧，老师是哪几个offer便利方的好吧，然后呢创业公司的，然后拥有的给多少钱好吧。

第一个是外包面试官聊怎么怎么样，我来看这次去做工作，拉项目丰富经验对吧，涨薪了13K吗，对涨薪三不止，还有两金和期权，以前的五险一金都是最低标准，还是全额对吧，以前一年15万，现在40万好。

差差点三倍了啊，今年沉淀学习了半年，去年练12K的都很虚，今年各种大厂都不带怕了，看完意思吧，是个人的一个情况，我可以看一下他是不是成都的啊，中间被清理了，算了都被清理了，看不到了。

很有程度的好吧，明显程度的保持个人的一个情况，所以呢掌声那里有很多，关山月说我没有自制力，没有自制力不可怕，没关系，咱们可以有帮助老师督促你来学习，这就不担心好吧，陈说没那么多时间来学习。

每天两个小时的时间，有没有，我要求不高，你每天只要拿出两个小时的时间，进行技术储备就够了，只要两小时，明白了吗，袁老师除以K咳咳来看这个吧，刚刚有个学生发了一个规划的案例啊，来看一下呃，微信昵称啊。

问号，然后呢哪的辽辽阳是哪，24岁男，目前就是2000点5年大专如火，如果体是啥意思啊，被学生在吗，大家也可以把你个人的情况，按照这样的方式发一下，发完之后给出一些个人的建议好吧，是如何储备技术吗。

你现在我不知道辽阳是，我不知道辽阳是哪个城市啊，有人知道吗，不知道城市哪个城市啊，但是按照你现在的薪水，和你现在的工作年限的话，你的成长空间是非常非常大的，你需要把你现在具体的技术。

踏踏实实的储备完善起来好吧，什么技术，比如说像现在面试中必问的一些微服务的，一些分布式的好吧，一些关键的核心点都掌握好，把一些技术的底层实现掌握好，我觉得如果你在辽阳，我不清楚这个城市的薪水。

如果你去到北京的话，学到明年金三银四，你到北京至少保证你10K以上的薪水，挨着沈阳是吧，最起码保证你10K以上的薪水，如果达不到，我个人可以掏腰包退你学费，就这么简单啊，所以关于提升技术这块没问题好吧。

好的学生说，我在，如果你现在只是想提升一下，你个人的天天学生啊，如果你现在只是想提升一下，你自己的一个技术的话，好没问题，放心，再，然后建议你24岁还小，最好能去大城市里面冲一冲，拼一拼啊。

拿到更高的薪水，还是那句话，学到明年金三银四到北京10K加的薪水，如果达不到，我退你学费，明白了吗，可以啊好吧，关山月说，我看小姐跟我说，这个课程越早待会越划算，我目前准备图一换工作，需要多久时间。

如果突击的话，看一下你观察也挺好的，你是否是想脱产学习，如果脱产的话，一个月一个月时间，一个月时间，把把咱们对应的一些面试，突击的关键的核心技术，踏踏实实的储备和完善一下，百分之百是没问题的。

不脱产不脱产，每天两个小时，拿出两个月的时间，拿出两个月的时间，把你的技术做一个完整的提升，我现在还不知道说你期望的薪水，大概涨幅到什么样的一个地步啊，如果你只是说涨了几千块钱，那这事非常容易非常注意。

所以你最好把你的详细情况能给我说明一下，可以按照这个同学写的这个格式啊，可以说明一下你对应的一个呃这个核心点好吧，我们现在对于我们现在的学生也是一样的，我们并不要求你每天要学四五个小时，六七个小时。

不需要，我们只需要你每天拿出两个小时的时间，来进行对应的技术储备就完事了，就这么简单好吧，我们一直强调一件事是，什么叫零碎片化时间，系统化学习，你不需要一定要有说很多的一个整块的时间，来进行技术储备。

只要你不停的在学习，按照咱们老师给你规划好的路线，来进行技术储备就完了，就这么简单好吧。

关山月听明白了吗，所以如果你有需求的话，最好能给我详细的做一个描述，好详细的描述一下，Ok，你的比如你的城市啊，你对应的情况了，就好好说一下啊，这样的话了解你的情况更具体，更具体的话能给你什么的建议。

就是越完善的，反正我们脱产学习的同学，基本上就是一个月两个月左右时间，一个月两年左右时间脱产啊，不是不是脱产了，突击的学生有短期内开房的，如果说你短期跳槽的话，你还需要储备很长时间的话，你就没必要了。

所以呢每一个学生在进行学习的时候，他大概其实分为两个维度，第一个维度，第一个维度我们叫突击学习，第二维度叫系统化学习，初期学习只是为了保证你在短期之内能涨薪，但是最根本的和最核心的点。

还是要进行系统化学习的，比如说我们会为每一个学生规划系统化的路线，然后你按照路线来进行技术储备，完了好吧，唉，好了，别再发什么问题吧，AR你还在吗，唉其实啊刚刚给大家展示我们的课程大纲，展示咱们的老师。

然后展示咱们的学习路线，给大家展示这些东西的意义在什么地方，其实就是为了给大家显示说你过来学习之后，你需要把把心放肚子里面，只要按照路线，踏踏实实的去储备和完善你的技术就完事了，就这么简单好吧。

最后再说一下吧，今天晚上咱们训练营期间有专门的专项名额，好吧，然后呢只有十个名额，前五名可以抢占对应的黑卡啊，过了这5年之后，黑卡就不再赠送了，Ok，是不是这个优惠优惠咋了，哪里领，我说了。

扫描屏幕右上角的二维码，如果你已经加过马士兵教育，的任何一个咨询老师了，那么没关系，直接去找他，说我是从李老师直播间过来的就可以了，好吧，我说了，你扫码吧，应该能找到吧，我试一下，扫码应该没整过吧。

可以扫啊，你可以直接扫了，可以直接扫码，主要是学费太高了，有点压力，我说了，如果你觉得学费高的话，咱们这边有分期免息的名额，你分六期的话，1万2000块钱，每个月大概还2000块钱吧，好吧。

安排说只能今天吗，对只能今天，因为我说了这些黑卡福利也好，还是六期免息，分期福利也好，只是当前这个训练营专享的，过这个训练营或过了今天晚上12点就没有了，没有了，OK我还要和媳妇商量一下，不是你商量吧。

这个花这么多钱肯定是要商量一下嘛，你该商量就商量吧，怕什么，钱在他手上，知道我也结婚了，我深有同感，我的钱也都在我媳妇手上，已婚男人的悲哀我可以理解好吧，但是啊你抓紧时间找你媳妇聊，还是那句话。

今天现在的这些福利只有心海有过了，今晚就没有了，就这么简单，好了别的还有什么问题吗，没问题的话，我就不聊了，我讲了两天了，我也挺累的，昨天啊还有很多同学找我做规划，今天没了，都都交完了。

昨天我觉得分析了好多同学最现实的一些情况，老师介绍的活动就是学路线的优惠是啥意思，什么叫老师介绍的活动，就是学习路线的优惠是什么意思，这个活动啊是对应的学习路线的一个课程。

那个学习路线的课程叫什么叫MCA马士兵，certified art tech哇，这C课程体系里面包含了java整个体系里面，所有的技术点，只要按照技术点去进行技术储备就完了，所以这个刚刚展示的优惠。

也是MC架构师课程的一个优惠，猪鼻说你们有go on老师吗，有啊我们有张三老师又来讲go on的，刚给大家看了一个东西啊，就是去了科研更新里面有一个go web的一个实例，就这个美女老师给大家讲波浪。

好，给大家看一下课吧。

教育乐课好吧，go web刚开始进行更新，还没上传吗。

什么意思，无法播放，这有问题啊，明明还没上传上去啊，上去之后就都会有对应的课程了，好吧，这个老师来讲了，找商山老师好吧，数学老师不是说有一个6+12的分期吗，那个是什么，那个是嗯有钱花一个学习。

一个分析平台里面提供的，优惠和细节方面的东西，我也不太了解啊，如果你需要的话，可以找咱们的那个小姐姐去问一下信息呢，我也不太清楚好吧，老师现在我有一种现象，我是学java的，但是公司需要V的前端。

没办法啊，这是小公司里面存在的一个通病啊。

大家永远记住这件事，什么通病非常简单，所以有多少同学想做全栈的，给老师扣个一有吗，有多少人想做全站，给老师扣个一，在正儿八经的大公司里面，其实是没有全站工程师这样的一个职位的，注意了。

小公司里面他想让一个人发挥多个人的价值，所以他会让你做前传，前后端什么东西你都要一个人接触，但其实但凡上点规模的公司，基本上是专人做专事，明白吗，现在有专门的前端工程师，如果你把前端的职位的工作都干了。

那前端的人干嘛呢，闲着没事干了吗，能明白这意思吧，所以这不是最主要也不是最关键的啊，你需要的是干嘛，把你的技能里面的某一块做到极致或学到精通，这才是最主要的最主要的好吧嗯，所以啊我不建议大家做旋转。

如果你是做后端的，做java的，就把java后面那条路线给储备扎实，储备扎实，高级工程师往架构发展，不是还需要会前端吗，不需要你会前端，不需要会前端好吧，现在前端的体系也变得非常非常复杂。

也变得非常非常复杂，你不能说按照一个就是呃怎么说，你把整个前端的架构也要搞得非常清楚，这个不需要，这不需要好吧，专人做专事是最高效的开发方式，这个VIP黑卡是干嘛的，刚才说了一堆都白说了。

我再来解释一下黑卡是干什么事了，好吧，这是我们黑卡的福利，黑卡里面享受的福利是什么，第一个叫个性化定制方案，第二个叫大卡优先内推，第三个是最值钱的，刚刚给大家展示了我们课程的更新，如果你没有黑卡的话。

你只能享受课程的权限，两年的时间，但是如果你有了黑卡之后，你可以享受一元的持续每年的升级更新服务，如果你没有黑卡的话，你想升级对应的课程服务的话，你需要花888块钱来进行购买，听明白意思吗。

所以这是最值钱的，包括你可以去手机上面的应用商店里面，下载马士兵教育的APAPP，里面有很多的课程，如果你是黑卡用户的话，可以享受最低的折扣价，这都是给予我们的VIP学生的一个福利，一个福利好吧。

是黑卡存在的意义，我说了，黑卡不是每个学期都有的，包括我们之前报名的VIP也是一样的，不是每个人都有，我们只是在不定时的时候会送出一些黑卡，福利啊，这个要多少钱买，今晚报名的话。

黑卡前五名是免费送给你的，当然我不知道现在还有没有前五名了啊，那今天晚上是免费送给你的，如果你正常情况买的话，我还是那句话嗯，黑卡现在我们不卖，黑卡现在是不卖，我们只会给我们定期的给一些VIP福利。

不定期的给我们的一些多名学员进行赠送，今天晚上和当前训练营里面是前五，有只有前五名是有的，非前五名是没有的，好吧，VIP能看go on的课程吗，我们会赠送一期go on的课程。

但go on后续的课程更新就没有了，波浪课课后续的课程更新就没有了好吧，呃内推有什么要求，还是直接就可以内推，我怕我到时候学着学着找不到满意工作，阿白把你的心放肚子里边，呃前两天我们有一个学生。

他也是他自己的学历是有问题的，所以导致他进不了京东，然后我们的老师帮他内推到了我们的京东，就这啊，我说的是内推到京东了，什么写京东，它捏碎京东之后，他还给我们的那个陈老师还送了一面锦旗，我给大家看一下。

诶，给景琦呢，我又完了又没了，来看一下这个，这是我们的曹老师好吧，金星培育传技能受益终身赶尸人来MC班，白宏宇赠予。

看到了吧，就是内推这方面你可以放心，而且我给大家看一下咱们内推有多么有实力，好吧嗯，叫这个吧，应该，医院没了吗，我给大家看一下字节，给我们内推好吧，你看这张图片，他说我是字节跳动直播平台的研发负责人。

看到马老师的课程材料，觉得可能有不错的学员推给我，直接安排面试，就这个人工牌叫什么涛，你们如果有自己有朋友的话，自己有朋友的话，可以支持被调，看到了吗，这个你放心是吧，包括这边我们一堆的企业内推。

如果你需要你可以来看看好吧，都是给你推的，国内一线大厂里面。

我们几乎都有内推，几乎都内推好吧，余墨发了一个人情况，我给大家看看好吧，21岁，吴期望薪资1万5半年本科想走后端路线，学过招啊，没做过什么项目，如果春招想进中小厂，是项目重要还是基础重要呃。

如果你是参加校招的话，我觉得技术实力比较重要，就是比较重要，这块我也可以给你看一个学生的情况好吧，也是之前的一个学生，他个人什么情况呢，可以给大家看一下，是昨天啊，我给大家展示过这个相关的信息了。

这个学生的他这个学生报名的时候是什么，报名呢，是2020年11月份报名的，这就相当于是你的学长上一届的一个学生，你可以看一下啊，这学生这是给中间答疑服务啊，他找我的时候是12月19号，很多消息没同步啊。

12月19号，然后找我的时候往下走，这个学生他也是想参加春招，感觉参加春招没希望了，后面给他改简历，告诉他你怎么进行储备，怎么去谈心，怎么去储备技术，做了一堆的工作，然后呢往下看，在最后面的时候。

他搜到对应的offer了，入职哪了，入职是滴滴了，虽然薪水不是特别高，但他入职了，往下看，老师那边已经确定下来了，也签好了，三方最低的白菜价，1915加5K的握手费啊，今年6月份毕业，招的时候是21年。

看到了吧，就相当于去年的时候。

他跟你一样，也是10月份来报名的，报完名之后收到必须的offer，在这个余某把心放肚子里边，没问题的，你过来之后，老师会给你规划一个单独，适合于你的内推的服务，你跟着这个服务啊，不是内存。

单独适应你的路线，你按照路线去储备你自己的一个技术就行了，还要握手费吗，握手费这东西啊，看公司，有的公司是有的公司是没有的，好吧，呃这个要多少钱啊，签名赠送，还有一个叫令若心，来看一下吧。

用心是什么城市，3年南京29任信息工程培训出身，运营商项目中业务一直是919十一六，CLOD刚离职多个offer方向，我不信怎么走到这边来，方向互联网有希望吗，如果不行，互联网架构有天花板吗。

呃个人建议，个人建议最好能进到互联网公司里面，这样的话对你之后的发展是比较有好处的，如果你进不到这种官网公司，还是这些传统企业，那么对你之后的发展可能会受限，最好还是进互联网的公司。

你现在的话大概是93K拆补，然后期望是18K，南京拿18K我觉得没问题啊，南京有一个公司叫苏宁易购，你知道光苏宁易购有多少学生能报名吗，苏宁易购的学员至少有十几个，他们都是直接朋友推荐过来的，就很简单。

因为南京啊大卡相对于比较少一点，所以如果你想拿到更高的薪水的话，你的技术实力是一定要足够扎实的，所以拿18K这件事情可没那么难，好吧，没那么难，给大家看一下，应该有南京的吧，挺难听的啊。

这哥们跳了涨了4000，南京好吧，但是还是在外包，然后再看这个这个学生涨了3000好吧。

后面教教程刷完再考虑跳槽，现在底气还不是很足对吧。

这个呢从北京到南京这边好吧，你在北京收了多少14，然后说20，他们说涨幅只能在20到30%之间，T3这边给到24，南京有个T3出行直接给了24K的月薪，主要看数学班的课程。

MYSQLREDISJVM多线程是吧，现在没时间看，今年3月份开始看的好，后面还是想系统的进行一个技术储备，所以南京拿到18K的薪水是没问题的对吧，这也是南京专科学生这些长相过吗，翻倍从8K到15K。

南京看到了吗，同学病，若心，你还在吗，这都是咱们南京的成功的案例。

我们来看前两天面了，也给我发offer了，税前30K年薪大概40万，接着就是创业公司24。53星对吧。

他也是南京的，你懂我意思吧好吧，所以看这种情况，像亲自double这件事情没那么难，OK完了我还在加班，老婆睡了，能不能给我留个名额，拜拜好吧，小明说有定向内推吗，听动力推吗，呃有啊。

大家知道我们跟京东现在的合作是什么，有一个东西给大家找一下，我们现在啊跟京东那边是定向的合作，给大家看一下，这是我们马士兵教育，跟京东java互联课程的一个独家合作，我们派曹老师和我们的老师。

去其中一边进行合作的一个谈判，并且签署了专业的一个合作协议啊，这里面包含了我们对应的一些架构师，课程的一个课程共研和人才的一个共建体系，看到了吗，包括我们后面会给京东那边进行课程，一个宣讲课程的授课。

所以如果你想进京东这边，百分之百是没问题的，听到了吗，孙女好，你只要把技术储备扎实了，进京东还是很容易的，我给你送一下京东吧，咱们进京的学生还真的很多啊，看那个李老师，我是京东了好吧。

之前的offer没跟你说是吧，15×14，他是在武汉，他是在武汉，武汉入职京东了，然后这个形容也是感谢在他们机构老师，我这边最终还是决定入职京东了好吧，18号上班。

感谢咱们机构10月到12月两个月的时间，能让我支持和技能提升到大厂水平，结果还是牛逼，看了吧，这学生准备入职京东了好吧，交B17到25K涨了8000块钱好吧，8月20号到10月8号。

大概就一个月的时间对吧，这也是我大概写的，也刚过了京东一面，后续还有什么要注意的，好往下看，然后呢走了涨了4000对吧，京东振兴什么之类的，所以把钱放多点没问题的，OK繁花3年，说两年开发经验。

在杭州上海能拿到多少钱的水平，如果你是两年的真实开发经验，上海我觉得15_{20吧，最起码15}20，15~20，如果更高的话，这个上不封顶，看你个人的技术实力了，看你个人技术实力了，这个没法给你预估啊。

主要还是看你技术水平，但我觉得最低也要15~20，这个范围最低的我只敢跟你说保底了啊，上上面的话就不确定了，好吧，所以还是看你个人的技术储备吧，所以说课程都是直播吗，怎么个模式。

上课时间加上自己的学习时间怎么分配，每天需要多久，两个小时课程有直播，直播完的课程会变成录播，所以你在过来学习的时候，是以直播加录播的方式来进行学习的，是你自己的时间，我就要求不高。

每天晚上只要能拿出两个小时的时间来学习，就够了，这个孤观每天只要两个小时，要求不高，只要你能拿出两个小时时间，把你的技术踏踏实实的储备和完善一下。

涨薪这件事情还是很容易的好吧，基本上3_{5个月吧，3}5个月涨涨涨，涨一下薪水，刚刚给大家看了，我给大家看了直播课表了，然后除了直播课表之外，已经掌握的直播课录播了，录播课了好吧，莫丘尼城东27。

目前九期望23年自考大专，目前专升本中，从事其他行业，17年转行培训六个月，18年工作3年，外包没有三高项目成交地，我该怎样提升自己，你这说的很清楚了，你没有三高经验，都是COD原理，源码都不了解。

那你后面再进行学习的时候，就要把原理和源码当成一个重心，来进行技术储备了，先记住啊，现在如果你想拿到更高的薪水，或者成都拿到20K的薪水，那么你需要做的事情就变得非常简单。

要把技术不但不仅仅停在应用层面，对很多底层的原理和对应源码的实现，你都要储备扎实，因为你只有储备扎实之后，你才能收获或者获取对应的薪水，如果只是那种基础应用的话，肯定不行，像现在面试中比较笨的。

我经常说的微服务，分布式中间件，数据库架构设计，这几块东西你都要掌握好，当然哪个点先学，哪个点后学，我还是需要经过对你的技术做一个评估，评估完成之后，才能告诉你说你的路线到底是什么样子的，明白了吗。

没修理，所以你自己其实说的很清楚啊，你哪弱就补哪就可以了好吧，珠海36岁，一本5年研发项目，13。5K减少芯片业务开发，还有希望，我在珠海为什么会没希望呢，我你知道我在给我们的这个这个雨墨春晓同学。

听好了，你知道我在给我们的VIP做规划的时候，你知道我最害怕什么东西吗，我最害怕的就是学生给我说一句话，我给你搜一下，这是这些学生们经常给我发了一句话，就这东西，看了吗，这个这个这个东西真的是我我我。

我最害怕同学们这么说，你知道吗，看到了吗。

有很多同学我不知道你接受了什么，是接受了多么严重的社会的毒打对吧，让你感觉自己还有救吗，为什么没救，为什么没希望，我一直说一句话，你只要开始学了，你只要开始补充你的技能了，你只要开始完善你的技术储备了。

你的薪水一定会涨，这不长得不科学，明白吗，所以不存在有救没救，你想达到什么目标，我来评判评判你这件事情说能不能达到，如果达不到，我会给你调整出最合适的一个目标，你按照对应的目标去进行技术储备就完事了。

怎么会有那么多有救没救这种话题呢，所有人都有救，只要开始学就不晚，这是我们一直秉承一个话题，所以不管什么学员来之后，一直说老师有救，没有希望没有不可能没希望，有希望就要开始学啊，最怕是什么，你不学了。

你不学就真的没救了，明白吗，听明白了没有没生效，所以没有就有涨薪这件事情很容易，你现在36岁进大厂可能希望不大了，但是如果你只是想单纯的涨个薪水，我觉得是没问题的，好吧，太不自信也不好，不是太不自信。

是你们真的一点自信都没有，能懂我意思吗，所以跟着老师的路线，我们这边服务了成千上万名的学生，总结出了一系列的学习路线的规划，你只要按照路线去储备，他怎么可能没救，其实我们对于学生人群的。

就是这个这个这个分析其实非常非常到位的，我给你看一个东西啊，我忘了问下在不在了，你们还在吗，在页面里面我们看一下，这是我们现在学生的一个情况，我们对我们现在所有报名的学生，做了非常详细的人群分类。

比如说你是大学生还是研究生，想进大厂吗，比如说你是非计算机专业的吗，你还是专科学历的，你还是在职海归，你看常年外包，你还想冲大厂，还是移居外企，还是想转行，想涨薪的，想镀金的，想创业的，想传统项目的。

还是想开发爱好的，非java语言的，大龄危机的，大连人才的转岗提升的极速副业等，只要你是这里的类别的人群，你放宽心过来，百分之百是没问题的，一个人可能会覆盖里面的多种情况。

但是每一种情况其实我们都有对应的成功案例，听懂了吗，同学们每一个情况都有成功案例，我们服务的学生太多了，我们也见识了太多太多的情况，明白了吗，所以在老师这一块，他不存在说没就这一说不存在啊，只要你想学。

只要你肯学，就没有没就这一说好吧，我们这个路线一定是最适合你的路线，你只要按照这个路线去进行技术的一个储备，百分之百乘这么简单，就刚刚那这些细胞强啊，多少个结构成功案例了，你可以自己去打开看看。

你自己刷一下，你光看这个就业喜报，你要看一阵子，这都是成学生成功的案例，怎么可能到你这就突然没救了呢，为啥没救了，不可能没救好吧，你一定有救，Ok，漫里风铃音，你们这名字都咋起的。

上海24拿23年大专通信技术跳两次，早年6月份收到上海市资金融公司薪资，14K之前在郊区作家互联网医疗工作的，这些技术的话，相关之后学习技术进步了不少，但是目标还有很大，一后面该怎么发展呃。

你现在学历不占优势好吧，但是好在你的年龄还是比较小的，不知道你之前跳槽跳了多少家公司呃，跳了两次槽啊，3年两次也还行吧，但不要再多了呃，建议其实非常非常简单，现在把你的技术穿插实储备一下。

你现在14K3年，坦白说这个薪水有点低了啊，或者换一句更加委婉的表达方式，你薪水的成长空间还是比较大的，还是比较大的，所以把你现在的技术储备扎实，原来学技术有提升，但更多的可能还是停留在表面。

或者说没有形成自己的知识体系，所以你需要从现在开始进行技术储备，把你的技术体系给提升上来，不要再跳槽了啊，从今年开始到明年6月份之前之前，都不要再跳槽了，下班之后不要抽空学习，养成长期学习的习惯。

每天拿出两个小时的时间，来进行技术的一个储备，把技术给成扎实了，好吧，然后下一份找工作至少20加以上，记住啊，至少20加以上，就你记住，永远永远记住一句话，你的技术主要储备扎实的。

你想拿到这个薪水没那么难，最怕什么，最怕你的技术不扎实，还想要高薪，懂我意思吧，所以你想你这次跳完之后，14K你之前的话可能更低，所以技术储备是一定需要了，6月份到现在五个月时间了，你基础成长了多少。

还是要进行系统化学习的这种单片的，或者说单崩的这种碎片化学习，他真的对你的成长没那么大的好处，好了吗，这个曼丽风音听明白了，给老师扣个一好吧，明白了吗，系统化学习储备你的技术，完善你的技术储备。

把技术给成长起来，就这么简单好吧，呃半夏北京二十四十一，希望18+1点，5年本科一年研发经验该怎么提升，建议今年报哪个班呃，最合适，你的班就是MCA架构师课程，把MCA架构师课程其实不需要多学啊。

我不知道你之前有没有跳过跳过槽，如果没跳过槽的话，从现在开始学，储备到明年金三银四，在北京城市里面拿一个18的薪水，如果明年金三银四达不到，我可以自己掏腰包，把学费退给你，这就是我的信心，明白了吗。

搬下，这就是我的信心，你现在报名学到明年34月份好吧，拿出四五个月的时间来进行去储备，按照我给你制定的路线去学习，如果达不到18页的薪水，我可以退你学费，这么简单，怎么西安18家。

你如果想回到西安拿18加，它的难度还是比较大的，西安虽然现在发展也还挺好的，但是跟北京的城市的薪水还是有所区别的，明白这意思吧好吧，而且你现在年纪还小24岁，我建议你在一线城市里面多拼一拼，多搏一搏。

为什么那么早回去呢，你在北京混一段时间，拿到更好的薪水，拿到更好的offer之后再回去，你的身价都不一样，它不香吗，是不是，何必这么早要回去呢，回去干啥，好吧，行了，差不多也十点多了吧。

现在还有什么问题吗，如果没问题的话，咱们今天晚上就聊这么多吧，好吧嗯，很多同学也说了个人的情况，我也把个人的一些经验或者一些建议，也分享给大家了，还是那句话，赛季之后把你的技术储备扎实。

所以说定向内推有啥要求，没啥要求呃，如果你想进哪个企业，我们会把你的简历给你，陈同学听好了，如果你想进到某个大厂和某个企业，我们会提前把你的简历给你润色好，复制做好完成之后，你就可以直接去。

我们会把你的简历直接投递过去，你就等着面试就行了，就这么简单，他没有啥要求，不需要说老师我一定要具备什么样的实力，什么之类的，当然你的技术啊一定要储备扎实的技术储备，不扎实的话，相当于白白浪费机会。

白浪费机会嗯，想去网易，网易有啊，还是觉得有点贵，没关系，觉得贵你就再看看，还是那句话，你永远记住一个课程的价值，它在什么地方，而且我告诉大家，这个课这个价你可能觉得比较贵啊。

但是这个价格其实也不是我们定的，不是我们定的，是腾讯课堂要求我们这么定的，这样一套完善的课程体系，这样一套平面化的学习，你觉得多少钱值，如果真的话，五六千块钱你会买吗，很没意义的好吧，而且如果你觉得贵。

我说了，今天晚上前五名同学还会有对应的免息补贴，所以需要的话找咱们小决定领一下，看看现在还有没有对应的名额。

系列 5：P84：84、常识介绍--磁盘、内存、IO - 马士兵学堂 - BV1E34y1w773

有一些常识。

常识常识是什么意思，常识不是你该炫耀的知识点，常识你必须要知道的。

但是在这呢我们统一来说一下这个常识，就是首先在计算机当中。

数据是存在磁盘，数据在磁盘里的。

那么以磁盘的维度，它有两个指标，第一个是寻址。

寻址的速度是毫秒级的，然后第二一个是带宽。

也就是说单位时间可以有多少个字节流过去。

多大的力量流过去，然后基本上是G或者照这种级别啊。

就是多少G或多少兆，几百兆或者12G这么这样一个一个带宽速度。

这是磁盘带来这样的一个一个基础知识。

另外一个就是内存，内存它有一个寻址。

它的寻址是纳秒。

十纳秒，那么秒这个时间单位里边秒。

然后再往下小是毫秒，然后再往下小是微秒。

微秒，再往下小是纳秒。

这应该都知道。

所以你现在得出一个基本的常识，就是磁盘在磁盘中获取数据的时候。

它是毫米级很慢，然后但是在那个数据如果在内存里的话。

找到它，把它放到C盘计算，一定会很快就进了一个常识。

磁盘比内存慢了10万倍，在选址上。

慢了10万倍。

大家注意啊，是寻址，寻址上是寻址上慢了10万倍。

后面还会出一个小的知识点，然后内存的带宽。

内存里面数据完走这个带宽一定会很高，就是它的带宽。

带宽多大，我忘了。

但是一定会很大很大，因为内存就直接怼到我们这个CPU去计算，他直接走的那个数据的CPU的前端总线。

所以他无论怎么样，内存各种数据只在内存里。

各种优势是优于我们磁盘的，然后还有一个小常识没有讲过的小常识。

还有一个小常识就是I/O buffer。

I/O buffer是什么意思，我就用了一个buffer。

我就用了一个buffer，首先其实这是一个成本问题，什么叫成本问题。

磁盘有扇区。

磁道和扇区磁道磁道。

和扇区。

那么移山区一扇区多少字节。

是不是512个字节。

这应该是基础常识，这都是基础常识，那么这个时候注意有一个成本问题。

什么叫成本问题，如果我们访问一个硬盘，这个硬件的时候都是最小力度。

以一个扇区一个512来找。

那么一块硬盘是不是1T2T，是不是会有很多512，那么每一个512在哪呢。

我的数据在哪，一个512的那个里面放着呢。

那么这样你要明白一个点，就是如果容器就是一个区域足够小。

那么它一定带来一个成本。

成本变大，什么成本变大。

索引，也就是你如果用，如果一个1T里面都是512。

这么一个一个一个小格子，小格子小格子的话。

那么你上你上层操作系统当中的准备一个索引，这个索引就不是四个字节了。

可能得八个字节或者很多个字节，它一个能表示一个很很大的一个数的一个区间。

才能索引出这么多的512个小格子。

所以成本会变大，所以会变大，这所以造造就了一个东西。

就是在我们格式化磁盘的时候有一个4K对齐，对不对，是不是会有一个4K对齐。

也就是硬件的时候，并不是按照512个字节为一次读写量。

他会把这个变得更大一点，你读一个字节。

读百一十二，读1K他给到硬盘了，硬盘都是咣当给你返回4K。

它是如果你看512跟4K就差了很大，它俩大小就不一样了，那么一个硬盘512很多小点点。

4K可能点会变少，那么这时候其实索引的体量大小就会随着变化。

所以一般磁盘都是4K为，默认我们格式化4K操作系统。

操作系统。

无论你。

读多少都是最少4K。

从磁盘哪都是最早从从磁盘拿这个这个这个事。

这个知识点。

系列 5：P85：85、数据存储发展进程 - 马士兵学堂 - BV1E34y1w773

好数据可以存在文件里。

然后数据如果存在文件里的话，如果我们要查询这个文件里面有马士兵，要怎么怎么怎么去查啊，一个文件里面有数据，比如说什么data，点TT可以怎么去查，LINUX当中有grape，有AWK等等的这样的命令。

你还可以用java语言等语言写个程序，然后做一个基于这个文件的IO流读取。

查找数据就放在文件里的话，然后你用相同命令去查的话，随着文件的变大，它就一定会查询速度变慢，对不对。

是不是这么一个结论。

随着文件变大。

速度变慢，那么为什么为什么呀，是因为文件如果变大的话，这时候访问硬件的时候，访问硬盘的时候会受到硬盘的瓶颈的影响，对不对，硬盘成为瓶颈，换言之，也就是IO成为瓶颈，这是计算机目前不可逾越的，对不对好吧。

这是第一个时间点，这是一个基础知识啊，这个基础知识当中带出这些常识，那么随着时间的发展，如果数据都这么放的话，肯定节奏特别慢，如果让它变快呢，数据库是不是出现了，当时数据库出现出现的时候。

他做了一件什么事情，注意数据库这最基本的两到三点可以去描述。

第一有了一个data配置，data配置概念。

它的dd配置大小多大呢，是4K，现在如果再跟你说数据库里面，如果你有一张表，你建一张表，表里面那么多行存档存到磁盘的时候，他其实在里面物理存的时候，好像用了很多很多4K这样的一个小格子。

那么这个4K刚好和谁一样，是不是刚好和我们硬件的这个磁盘子里边，那个4K这样能对上，能理解什么意思吧。

所以这时候如果我们的数据库准备很多，这样的4K。

也就是曾经数据就在一个文件里面线性，它虽然到底层的时候还是4K，但是这批文件混在了一起，这个4K连起来了，不能把他们隔开，找不到他们在那，但是如果现在在在在在我上面软件里边，先定义出一个4K。

然后每个4K有自己的id0号一号2号，且这个4K啊，读取这个，这个你要读这个4K里面，某某一个某要读它的时候，正好符合你磁盘那一次的IO，符合一次IO也没有浪费的一个IO，没有吧，你可以把它变得更小。

比如变成变成1K，但你会发现你你你上层软件，这个数据库想读1K的时候，硬盘是不是还是读4K，索性你还不知怎么样，直接上面是4K，反正你你要查什么东西的时候，从我上面就掉某某一个某一个DVD了。

底层就咣当就把这个拿出来了，然后比他大可以，比如我定义成8K16K可不可以定义，小了会有浪费，定义大了无所谓，定义大了是无所谓的吧，就是这个可以往大数调一点，但是调小的话其实浪费了。

因为你独一K底层还是抖4K没必要啊，那么这样的话注意这是第一个知识点，它会分成很多小小格子，那么曾经这个文件里面可能1万行，10万行就散在了这么多的小格子里边，但是这个时候。

如果光有这个4K的那种小格子的话，其实你查找数据的，数据的成本复杂度还是和前面一样，为什么，因为你还是要从第一个4K先读到内存，然后再读到内存这种挨挨个去找，所以他走的还是全量。

IO跟前面IO量是一样的，所以他一定会很慢，那么数据库怎么样可以让它变快，也就是建表，如果你使用数据库只是建表了，没有去建索引的话，其实那时候根本用这个任何提速。

这个这个不可能出现的速度一定会会会会很慢，所以数据库的时候。

另外一个东西就是索引，索引其实也是使用的4K这种存储模型。

是对应模型，无非就是前面那个4K格子里面放的，就是我一行一行的数据，然后这里边4K里面放的是什么呀，是我内行里边你面向某一个列。

比如身份证那一列，我就把身份证那列数据拿到这边4K里边。

然后每一个身份证号指向的是哪一个，data配置有一个指向关系，这就是水的索引，那么这个索引随你数据变大的话，那么你这个索引肯定也会很多，能看懂，同学们这块能理解吧。

唉就是一定要明白一个概念，数据是用4K4K去存的，然后你的你的数据如果没有索引的话，速度会查，查询速度还是很慢，如果想提升这个速度，你就必须有一套索引系统，索引系统其实变相来说它也是一笔数据。

然后还有一个知识点，就是在我们建关系型数据库表的时候，在建表的时候，就是关系数据库一般是用什么作用方式。

在见面的时候必须给出什么呀，必须给出，什么叫必须给他cheer，就必须给出这个表的啊，一共有多少个列，每个列它的类型是啥，就是约束是啥，那么这里边的每一个列的类型，类型其实是什么呀，字节宽度。

比如我第一列是watch21，第一列未来就是上线开开辟，一定会开辟20个字节，那么当一个表，为什么在使用之前要先给出schemer，只要scheme给出类型都给出之后。

那么这个表里边的每一行的数据的宽度，就已经定死了，能明白什么意思吧，那么这样的话，未来如果你像这张表插入了一行，假设这一行有十个字段，有十个字段，你只给出第一个和第七个，剩下的字段都没有给。

但是像这个data配置里去放的时候，第一个和第七个以及其他那些没有知道，那些字节都会就会用零去开辟，用空的东西去补充那些字节，那么这样会有什么好处，注意听啊，首先表里有这个概念。

然后存的时候更倾向于行级存储。

就是以行为单位来存，为什么，如果你给出schemer了，给出宽度了，那么我这一行假设有十个字段，每个字段都是四的话，就40个，即便你只给了其中一个字段有值，那么剩下的那个30多个我也会占空。

把这一行位置占出来，占位占位，这样一个好处就是未来你的增删改，你比如在向其他地方补充的时候，你不用移动数据，直接拿你新的数据在那个位置复写就可以了。

也就是数据库关系，数据库表是行迹存储的，然后呢数据是数据，索引是数据，但是这时候如果有了这个索引之后。

其实还差一个东西，为什么你还要注意一点，就是数据和索引其实都是存储在硬盘当中的。

都是存储在硬盘，然后就是真正查的时候是要用到一个东西。

就是在内存里面准备一个B加数，内存是速度最快的地方，所以在内存里面准备了一个B数，什么B加数，B加数，所有的叶子就是这些4K小格子，B加数，其实树干是在内存里的，也就是所有的区间和偏移。

然后这个时候如果用户想查，只要命中索引了，那么这个查询在B加树会走树干，最终找到某一个叶子，比如你的身份证号，那个号刚好在那个叶子代表这个区间里。

那么把它会读到从磁盘读到内存，把它解析完之后，最最最笨的话，便利完了之后，可以知道应该下一次把哪个data的配置放到。

放到内存里面读进来，那么就可以找到什么呀，找到我们那个类比记录了最简单的B加数。

如果复杂的话，你就选二叉树，中间如果是八的话，左边是小于八的，右边是大于八的，如果你要查查22的话，是不是一定走右边那条路，所以树干的话，一定会沿着一个这个最小的方向去找，最终找到一个叶子。

叶子里边可能给定区间是，比如说从那个9_{30，那你阿法一定出现出现在里边，但是9}30，这些明细记录是在这个磁盘的那个小格子里的。

你需要从磁盘读到内存，如果把这些索引再堆到内存里的话。

你的内存不够，存不下这些索引，所以索引和数据都放在磁盘内存里，只存一个树干，只存一些区间，就这么想就可以了，这样的话是充分利用了各自的能力，磁盘能存很多东西，然后呢内存速度快。

然后呢用一种数据结构可以加快你的便利，这个查找的速度，然后从而呢又数据又是分而治之的存储，所以这时候你获取数据速度极快，最终的目的是为了什么，减少IO的流量，就是磁盘有这么多缺点。

那么我就不让它发生大量的IO，以及减少和寻址，这个过程明白了吧。

那么这是我们所谓的数据库这块应该很好理解。

当这个理解之后注意，那么随着这个数据量的变大，假设这张表这张表我不止这几个data的配置了，这张表本身涨到几千一行，几万一行啊，或者几百万行，数据量变大的时候变成一T2T了。

那么这时候你都应该听过这么这样的一句描述，就是数据库的表如果很大，检测速度一定会变低，也不是检索，就是这个性能一定会变低，对不对，那么这句话如果没什么问题的话，应该怎么去打，怎么去打，这个知道不知道。

就是如果是U的表里不行，很多性能就会就会降低，对不对，那么这句话在回答的时候，你要小心了，我把这个笔记都给你做下。

表示很大的时候速度就性能下降。

那么这句话描述的对不对。

首先增删改，如果表有索引。

如果没有索引的话，然后增删改变慢，因为你要增删改数据，修改里面数据的话，这个数据你见过多少索引，都会找这个索引列索引，这批数据去修改这个索引，调整它的位置，对没错。

就是维护索引会让你的增删增删增删改变慢，但是查询速度呢，查询速度会不会变慢呢，查询速度会不会变慢，增删改一定会慢慢，查询速度会不满，那么这个时候你要两把，第一把有两个打法，这两个渠道出来，第一个。

假设我这个表100个T硬盘内存装下100个T，然后内存也刚把所有这个这个批注的书干，能都能存下，然后呢哪儿都没有溢出，哪都没有没有问题，那么这时候注意来了一个人的一条简单SQL查询。

且他VR条件能够命中索引，那么这时候如果少量。

它就是一个或少量一个或少量查询依然很快。

问六是什么意思吧，就是一个查询进来之后，因为你VR条件走的还是内存，必数走的还是一个索引块，这个块到到到内存依然走的是一个配置，他并没有说你数据量变大，我未来会把别的位置也也要带到内存里面去。

但是什么时候会查询的时候，速度速度会变慢，也就是说当并发很多人到达了，很多的查询都到达了，或者一个复杂的思路到达了，那么这时候查询的时候不是要获取一个data配置。

当内存了，有可能要获取。

因为你数量变大，数据量越大，能够被很多查询命中的几率，被不同命中的几率就会很大，所以这个时候会受什么病，发大的时候，受刚才不是说了一个常识吗。

也就是说硬盘的带宽对不对，受硬盘带宽影响速度。

也就是说假设来了1万个查询，每个查询查一个4K，就每个人查那边的条件都不一样，刚好是又散在不同4K上，那么这1万个人查询官网进入到这条服务器，服务器之后，那么这1万个人的每个4K是留着。

挨个的向我们这个内存去走的，差一个你走查一个，你走查一个，你走查一个走，那么这时候其实有一部分就会等待，前面那个4K他们走完之后能轮到自己，能听懂什么意思吧，我刚才假设他是B数，不会受到影响。

对存还可以，这块是梁庆同学，就这句话很重要，因为你一定要明白硬盘的慢，除了寻址慢，是不是还得带宽，是不是还有一个带宽。

所以这两点你都要说出来，说把哪个少说了，其实都是少覆盖的范围。

OK吗。

好嘞，那么接着聊。

那么数据库先简单聊这么多分库分表啊，分制分布式那个事情相互去描述它。

那么如果说数据库已经使用磁盘了，那么这个时候其实尤其到后边这个查询，这也发现了，如果数据量特别大的时候，他就一定会对增删改查，尤其在并发下的时候，查的速度都会同等下降，都会变慢。

那么这个时候如何去解决这个问题呢，那么首先看一个极端。

也就是如果发展到最最最顶头的话，会一个极端。

这个极端是sap这家公司有一个HANA数据库，这家公司有没有听说过这个HANA数据库，我没听说过这个sap hana数据库是一个什么，数据库。

是一个内存级别的，内存级别的关系型数据库在这一个小常识啊。

这个故事我相信你在哪都听说过。

但是这有一个小常识，就是数据在内存和磁盘体积不一样，数据在磁盘和内存体积不一样。

这句话能不能找找找找找到这个点，什么叫数据在磁盘和内存体积不一样，什么意思，你要明白，在磁盘当中是没有所谓的指针的概念的，数据是不可能出现什么呀，出现一个所谓像我们对象一样，我队里就一个对象。

我可以不同的县城里边，或者不同的地方有不同的引用，如果数据想出现在索引，那么比如身份证号就在这一定会出现，然后他原原本这还得有一个身份证号，所以这个数据一定会长出，一定会涨出，但是同等。

如果关于数据库使用磁盘存存了2T数据，那么如果迁移到ha数据库的话，到内存里面的不是2T，可能1T多一点，因为你这边不可能建一套索引，而且它可以启动一些压缩优化的策略，好吧好吧。

那么这个时候注意两个极端。

有了这片有这么一个使用磁盘的数据库了，这边有一个基于内存了。

这边我们大家都买不起，这边呢我们的数据量又会变大，然后性能又会变低，咋办咋办，然后在企业架构当中，如果你现在给公司在维护着一个web一个架构，那么这个系统一定会越来越大。

里面的页面里面的数据一定会越来越多，然后这个时候如果这个东西，你们公司肯定买不起，就甭想这个速度了，那么这边的话你肯定使用的是关于数据库。

那么关于数据库，数据变大的时候，增删改查都会相应变慢，尤其并发到这个这个这个出现的时候。

所以这个时候什么概念出现了，那么有人说有没有折中。

折中的方案，这个折中的方案就是缓存。

这个过渡的过程有点快，但是能知道我为什么要说这个事了吧，明白吗，就是说我还因为没有办法，这个内存级的我买不起。

然后呢，我还得使用磁盘机的，但是我磁盘机又特别慢，那么我就用少一点的内存把一些数据牵出来。

放到这个位置，那么缓存的概念就被提出了，缓存里的记录有很多。

然后还有我们今天要讲的主角REDIS这样的技术，好吧，这就是今天要讲的东西，就把它带出来，那么你就想成这个MAREDIS，其实就目前来说什么呀，目前来说没有办法，所有的it信息系统都这么多年了。

从194几年到现在，1966几年还是4年，到现在4年应该是第一个这个计算机出现，有两个最基本的常识，两个基础设施，一个是缝。

索诺依曼体系的。

硬件制约一个什么呀，以太网和TCPIP的网络，这是所有目前的所有信息系统，两个最基本的基础设施，这两个基础设施没有办法，所以REDIS才能出现，如果现在硬件不是一般体系，什么量子计算机出现了。

然后所有的硬盘IO带宽的问题都解决了，那么估计就没有人再用REDIS，用MCD做缓存这个事了，另外一个以太网，TCP网络这种网络潜潜台词就是不稳定，所所以这个时候如果你曾经用一个技术。

现在要整合多个技术的时候，那么就一定会带来一些问题，数据一致，双写等等很多很多问题。

所以这时候后边知识讲的时候。

系列 5：P86：86、数据库引擎介绍 - 马士兵学堂 - BV1E34y1w773

有这么一个网址是dB的engines，就是引擎数据库引擎点com啊。

你现在可以随时在你身边，如果富余电脑，你可以看一眼啊，然后打开这个网站，上面有这么几个，一个是排名数据库引擎的排名，一个是数据库系统有哪些系统，每个系统它是干什么用的，以及什么特征，一个是相应的百科。

现在百科我们先来看一下排名点他。

那么会得到一个很多的很多的数据库。

数据库这块有很多东西。

首先你明白我为什么要讲他还是话，大家都是架构师，未来你都是架构师，无论你是你是真的架构还是剧的，你都是架构师，架构师必须有一个能力，就是技术选型和这个技术的对比，就是你一定要给公司做出一个正确的选型。

你选对了，选对了，那就用这个数据库吧，就用这个了，那么你公司可能就上市了啊，你选错了一堆人跟着你往下走，那么公司可能破产了，就这么一个最基本的一个概念，架构师可以把一家公司带到上市。

才有可能把一家公司带到破产。

这并不是跟你说笑，能理解吧，那么来看这个排名，在排名当中都是我们数据库。

看第一名的是谁，是oracle，这是关于数据库，对不对，注意后面的每行描述，它是一个relational的一个关于数据库，第二名MYSQL，那么也是一个关于数据库第三名微软的sl server。

然后等等，巴拉巴拉IPNDB2到第七名的时候也来search，注意这个时候这个MONGODB是什么呀，是document文档型的，然后呢原来third的时候是搜索搜索引擎的，然后到第七名的时候。

REDIS出现了，但是注意他什么呀，他是k value型的，基于内存的，那么这个数据库的排名你可以往下多看一看。

但在这儿要注意点啊，他的排名是全部的排名，大家注意看左边是不是有很多的分类，对不对，那么这里面关系型数据库排名，你可以单看关系型数据库的排名都是关系的，这里面也会出现我们刚才说的SAP的HANA。

看了吧，这个数据库也是有的。

然后你可以再看KV的，KV的数据库，第一名是谁，是REDIS队的，而且是基于内存的速度很快的，这时候你就知道为什么，现在所有出去面试的时候，如果达到二三十万年薪以上了。

REDIS这个词汇一定会出现在什么呀，他那么一点点区域里面必须要写些话，描述要招什么人，但是大部分的企业，BT等等都会把这几个字母放进去，就是它的地位很重要，别急，再往下走，这个网站有很多可以学的地方。

你先去把每个分类排名都去看一看，看看之后，其实这些分类如果因为咱们肯定还有一些小白。

然后从事之前没有怎么从事过这个行业的，除了排名这个这个这个区域还有一个systems。

这里面会列出所有的，比如说我们拿两个最基本的关了啊，哪两个最基本的，拿一个今天要学的REDISREDIS吗，然后再拿一个，我们好像是应该会用的什么呀，My circle，好像我们大家都应该会用的呗。

那么找到架构师的感觉。

这俩刚才也给你演示了，一个是基于磁盘存储的关系型数据库，一个是今天讲的REDIS内存就缓存，你现在看MYSQL的时候，他会给出很多的评价，这个这个很多维度的一个一个一个一个统计，比如说官网。

然后呢第一年什么时候，第一个稳定版什么时间，当前的码是多少，然后开源开源否，然后等等的下边，然后这个operating system操作系统，然后以及下边的API，然后以及客户端语言。

你可以分析出他有没有什么优势，如果你你企当中有有一部分人使用某种语言，但是这个这个这个数据库您不支持的话，可能就有风险了，或者你要么让你团队接受它，要么是换另外一种引擎等等的。

然后下边还有什么这种分布式的方式，可谓知识分布式可谓之主从复制副本啊，主主复制主从复制是MYSQL可以支持的，他很多功能都可以支持，事务是否支持一致性是什么，一致性不强，一致性还是最终一致性。

你可以在这不用去搜任何的百度，在这块的可以拿到所有维度，对对这个产品的描述，未来如果写标书或者和项目组开会的时候，就拿这个东西往往外释放输出就可以了。

而且除了这些往下，还有一些相关的评价和一些别的东西可以去看。

那么除了他再来看REDISREDIS一样，我们多出来REDISREDIS呢，它的网站是哪，REDIS点I这是他的网站，走起后面就可以关了，再来回来，然后他的初始版本稳定版是09年，现在19年是5。

0的版本，5。0版本，然后它下边是这个可以用的操作系统，然后呢最主要往下看SQL与否是NO circle，不支持SQL语言的查询，也不是关系的，因为它是KV型的，前边看到MYSQL的时候，SQL哪去了。

买SL的时候，他SQL为一定是一个SQL，明白吧，然后再往下看，客户端语言很多很多也就是它的生命力，其实我们的REDIS为什么火，这点也很重要，因为它可以和很多的项目，很多的语言去集成。

然后再往下还有它的分布式情况，集群集群模型是沙丁分片的，是沙丁分片集群，然后呢像MYSQL一般就是会做分桶啊，这边这个分库分表之类的，像REDIS的话，后边给你讲到他的集群的时候，是一种上次分片。

也就是把你公司的数据切成几个几个片，然后存在不同的节点里边，然后还有一个复制主动复制啊，然后再往下它的一致性，这块是一种最终一致性，最终一致性并不是一个特别强的，因为其使用REDIS的时候。

你要做技术选型，对他的评价就是我为什么用它，就是因为它速度快，但是如果其他的维度去影响它的速度快的话，那么这时候你可以降低不用它，而用一个更强大更稳定的其他的引擎，所以这时候什么叫架构师。

你不能破坏一个技术它的特征，你破坏了它的特征的时候，其实它可能降级成别的别的别的产品了，能理解吧，所以他这块他自己的时候就没有使用强一致性，而使用的最终一致性，然后事务这块也是他自己做的一个链式事务。

In memory yes。

然后往下看，有一些描述，最最重要，往下看，有这么一段描述。

哎这页面哪去了，我刷新一下，有一个东西得看一眼。

嗯在这其实很多知识你都不用去刻意的去找，你看，看到这儿的时候有这么一个描述，Redis in memory database，Fastest in memory database。

然后注意OPS每秒每秒的那个操作的数量，是1。5M兆，那么这是多少次，每秒多少多少操作，MK是三个零，M是六个零，1×6个零是10万，对不对，不是150万，哥不是150万是15万。

接近每秒钟15万笔操作，那么15万其实说白了就是什么呀，毫秒级的约等于小号，小于毫秒级的操作，其实一般听到就是REDIS可以达到什么呀，秒级10万操作这个东西，这个速度性能是远超过什么呀。

我们我们的观影数据库的，关于这数据库的话，如果一般的话，它千级别就差不多了，千级别已经差不多了啊好吧。

你看就是你很多的知识都不需要老师，你只需要知道一些域名，你根本就看一看，出去面试的时候和别人聊的时候都都还OK，对不对。

系列 5：P87：87、 redis简单介绍 - 马士兵学堂 - BV1E34y1w773

这个听懂之后，然后最后来到他的官方主页。

工作主页是英文的，然后呢，现在我们的市面上会有很多的关于中文的。

像REDISCN好吧，这是他英文的主页官方的，然后呢也会有国内会有很多中文的。

我那个英文水平其实不是特别高啊，所以这块你知道他在哪儿。

在哪儿去找他英文英文官方，然后多数看看这个中文就可以了，在中文里的话。

我们把这几个点拿一下，技能介绍他这个特征，你看现在教你的是学习方法。

所有的学习过程都是可以完全达到自主学习，不需要老师的，但是需要我什么东西需要，那就是要找到这种学习方法和条件反射的过程，以及基础知识积攒，当我把这些东西教教会你之后，未来你学新的技术的时候就变得容易了。

这是他的一个官方的一个描述，REDIS是一个大一点，REDIS是一个开源的，然后内存中的数据结构存储系统，它可以用作数据库缓存和消息中间件，然后这是前面第一句，第二句它支持多种的数据结构类型。

它支持多种数据类型，也就是如字符串等等，但是这要强调一点，REDIS的模型是，它首先是建立对的，有K，有歪了，那么一定要在这注意，REDIS里面的K和value才代表他是一个键值对，然后像这句话。

它支持多种类型的数据结构，如字串跟这几个这几个类型啊，说的是value的类型，也就是第一个，还有一个所谓的string，像建筑队这个非常好理解，因为你通过键可以找到这个value。

这个value类型有string类型，然后相应的还有一个，String，然后哈希，类型的，这是一个学习的过程，如果你们来学习新的知识的时候，也像这样去学习，然后还有list，最基本的是五大类型。

然后后面我会给每个类型给你讲，然后主要讲的场景和如何使用，然后还有set，那么现在你其实要回忆拉回了，你在做编程的时候，你离得开吗，这些在在你做普通编程的时候，是不是也会用到数据。

数据类型的概念和数据结构，对不对，因为程序等于算法加上数据结构，还有一个词汇，这已经是够五个了，然后向下延伸出来的还有一个beat max，这个知识点也很重要，它是完全用内存里面的二进制位来进内存。

存储空间，但是可以解决很多重要的事情，然后string其实后面会给你讲，它既是string，也就是可以用字符串操作字符类型，然后也有整形整数类型操作或者数值类型，你为我写了个max版，写出来就是类型。

嗯然后等等，其他的后面先不用写，有这么多，然后这是这一句，然后待会总结REDIS内置了复制，然后落脚本LRU这种驱动事件，也就是过期等事物和不同级别的磁磁盘持久化，并通过REDIS哨兵和自动分区提供高。

这个提供高可用性就可以，它有集群class，然后也有一种主从复制的东西，那么以上这里面先过多的先不说，过多的先不说，首先回到圆脸上，把它露出来之后，要去聊一个什么事情，在缓存。

就是现在你读完一个技术之后啊，你给他简单画一个像，画出像了之后，你必须做类比，其实在这个世界上，在专业之前已经有一个技术，这个技术叫做MAD catch，或者你不知道他不知道他。

但是你应该能找到这种感觉，就是键值对的，他也是对的，KV的，都是KV的，那么REDIS是KV的，然后呢MCAT是KV的，那么ready出来之后，反而还渐渐取代Mac生存的地位。

那么为什么为什么他会取代这个map CD，那么如果稍微一查资料，就会知道mp中它的value没有类型的概念，value没有类型的概念，但是redis value就有类型的概念了，这是两个最本质的区别。

你随便上网一搜就可以搜到这样一个结论，那么这时候你要正确的根据条件反射，你学过什么知识，或者你活这么大的时候，如果看到这样的一个区别，你能给出怎样的一个结论，这就是知识，你要善于动脑，找到条件反射。

能理解什么意思吧，首先你要明白一点，如果曾经我在第一次学这个字的时候，我上了一搜RASE，说他有value有类型，然后我们开始没有类型，然后当时我大脑条件反射第一个东西是啥，跟着我的思路走啊。

跟着我的思路走，为什么条件反射JASON这个东西，因为肯定开始没有REDIS，那么如果假设世界上只有这种这个段，然后外面没有类型，那么我们使用这个技术的时候，可不可以存一些复杂的东西。

那么这时候你的条件反射是JASON，对不对，JASON它可以表示很复杂的对数据结构，那么还有一句话，这是在我曾经第一次接触杰森的时候，我随便上个苏思量，我忘了什么地方，有这么一句话，就是说世界上。

三种数据表示，比如说K等于A或者K等于一，然后这是第一种，或者是K等于一，二三或者是K等于，然后ax f也就是上面这个等号，后边上边单元素或者线性元素或者是K等于，然后一个X，然后等于Y就是建队。

或者你再可以整合出K等于复杂的这种应用，比如1K等于一个数组，数组里边又是对象，嗯没毛病吧，这个你面试的时候都可以聊这个事情，为什么要聊他，其实这里面这就是为什么REDIS。

它这个类型会优于我们的来看的，首先如果你条件反射想起这个知识，那么你会得出一个间接结论，也就是说你value有没有类型无所谓，好像好像是不是无所谓，因为我们开始只要有建筑队了。

我的value是不是也可以放一个JASON，然后来代表肯有有数组，这边你有list，我这边是不是也可以，也可以用JS表示一个list，你这边有这种hash set high table这种建筑队的。

我这边是不是也可以放这个这个理论，能不能听明白，听懂同学来刷波一，好吧，当这个理论你明白之后，也就是说其实我可以不用REDIS，我用Mac catch的，它的value也可以存很复杂的东西。

但是但是注意了，你要再逆推一件事情，那么他们的成本，这个value的类型的意义是什么，因为你上多了，他有这个类型，那么它的类型的意义在哪，如果注意听下面一个很重要的一句话描述。

你就知道为什么你要学REDIS，如果我的客户端，客户端想通过一个缓存系统，而且是KV的缓存系统当中取回，取回这个value当中的取回，value中的某一个元素，取出value当中的某一个因素。

也就是这个麦片当中Y里面存了一个一个数组，然后呢你用原力的value当中存了一个list，那么这时候如果想取回其中的这个，它的JS里面的某一个元素和直接，如果他有类型这个例子某一个元素的话。

那么成本就不一样了，那么相对MCARE来说的话，MCD怎么做的，你需要返回所有的，返回value所有的数据到client端，那么慢慢开始台服务器，如果很多人都这么获取的话，网卡那个IO就是最大的瓶颈。

而且这是第一个要访问的客户端，第一个就是服务server网卡，卡IO，第二个就是client端，要有你实现的代码去这个编码或者解码，解码解码你的JSJS数据解码出来，也就是说只有两个复杂度。

但是如果换成release的话，因为它有类型了，类型是什么意思，类型其实并不是太重要的，面试一定要跟面试官说，类型其实不是很重要，重要的什么，重要的是redis server。

中对每种类型都有自己的方法，也就是说其实他可能给你提供了一个基于index，让你给出一个索引下标或者l pop怎么样，也就是你的客户端只需要向对方调一个，我取那个value的某一个元素。

或者左边或者右边弹出一个元素，那么这个时候其实它就规避了上面的问题，你客户端不需要写很多的，因为它不需要把全量数据取走，你RESERVER网卡就OK，然后你客户端的代码也比较轻盈，好吧。

诶这个图为什么不往下扩展呢，本质是解耦，那么在这个如果学过大数据的话，应该能给出一个词，这个词叫什么词，学过大数据的话，应该可以给出一个词来描述这个过程，优势其实没计算向数据移动，计算是向数据移动的。

因为你的客户端不是把数据拿回来，在这方计算，而是说调用它的方法，你的计算方法是在这边发生的，数据直接回来了，好吧，OK那么粗略的这么一个介绍，粗略的介绍，从开始这个位置到这个位置的一个演变的过程。

先做一个简单介绍，一会计算向数据移动，没懂是什么意思，很好解释啊，Memory catch，你是不是要把数据你的计算在哪，在使用的时候，你的计算是在这个位置，这个计算是什么，就是解析，JS字符串。

你的数据是不是一定会存在你的MC里面那个value，然后你的客户端是不是一定要盖的那个K，然后把这个六是不是要通过他的网卡，然后是不是要回到你客户端，然后走这个计算，这计算对不对，规矩就。

然后但是如果是REDIS的话，这个计算是不是REDIS中针对这个value类型，是不是会有一个计算，然后这个阶段就在这等着，然后其实只等着你的调用了，如果你客户端说掉了一个一个计算。

这个计算并给出的是某一个K对应的value，那么这个计算就会在服务端发生这个过程，然后发射完之后计算的小量的结果会返回给你。

磁盘固定4K大小，这是不一定的，磁盘其实有缓冲区啊，就是其实其实硬件都有缓冲，你硬盘上面会有一个缓冲区，也是基于芯片的，而且现在不止有缓冲了，还有一个这个加加速，就是固固态机械混合这种混合版，然后呢。

你的磁盘可以格式化成4K大小的一个格子，或者格式成更大，为什么，因为取决于你上层应用访问数据的量，就是我掉你一次可能要多少，一般操作系统4K大小合适，不怎么浪费，然后呢也能支持你存一些小的文件。

小念不怎么太浪费，然后基本上中职的文件就可以了，但是如果你买了一台服务器，想做视频录像，就你又买了几个摄像头，记得这台机器上买了一个采集卡，那么这个时候其实你未来你想你把你写的数据。

和你监控上面播放的那些数据，对磁盘的话就不是很小很小的访问了，那么这时候你磁盘4K其实就有点得不偿失，因为寻址带来的时间这个碎片化太太太大了，你磁头绕来绕去的，还不如把4K变得更大一点。

让你的磁头飘到某一磁道上，直接读出更多的东西，就减少磁头空难中去寻址的时间，就把寻址再降低，也就是说其实硬盘这个格子大小是4K呢，还是更大呢，其实取决于你上层应用，对于IO的这个熊量，就是想怎么用它。

我是想更多地读它，就是IO密集型的。

系列 5：P88：88、 redis安装实操 - 马士兵学堂 - BV1E34y1w773

首先要安装，要去做的话，我来介绍一下我这个环境啊，Snoos，这是一个LINUX操作系统，我用的是六点叉的版本，六点差的版本，然后呢，我们安装REDIS就直接从官网拿最新就可以了。

因为虽然版本变化可能从曾经的二点差，三点差，4。05点差，其实里边最核心的东西变化不是特别大啊，直接官网，啊这现在有点长。

这个环境，然后呢，我的计算机在上课之前已经重置了一台，非常干净的，比如在你们实操的时候也最好做一件事情，就随便拿了一台机器，然后呢给他拍了一个快照，然后拿了一个原始出装那个状态给他转到。

然后拿到了一个非常干净，那么现在我运行这个状态就是没有任何配置。

等于系统刚装完能解，什么意思吧，得到了这样一个系统非常干净。

什么都没有装过，然后根据刚才看你可以看中网，可以看应用网，它都提供了一个download，然后呢让你下载的是5。0这个版本，把鼠标挪过去之后，看左下角那个状态提示，就是一个踏实地压缩包。

所以你直接复制复制链接地址，在这做一个复制链接，然后可以给你粘过来啊，最好最好你们还是养成一个习惯，就是少去抄，然后能记住这个步骤和原理，你会发现这就是一个app的一个一个，一个资源的地址。

那么拿到它之后，可以在当中怎么做，使用w get，然后后面接了个地址就可以把它下载下载，所以但是这个命令没有啊，因为是新系统，该系统你要装一下这个w get这个命令，现在他先跟这个仓库同步一下。

这个稍微延迟一小会，等他一下，他家目录，随便建一个目录也是干净一点，CD到soft里，然后w get把你刚才那个地址粘过来。

条条大路通罗马，并不这种方法并不是唯一的方法，有可能公司里边根本连外网访问不了，所以你还得使用一些插TV等终端上传，无所谓的，咳咳咳，然后清完之后，你会发现压缩包有了这个之前的知识。

应该两边的两边学院的同学都有过记载，就是他JZ的压缩包怎么解压，是不是看XF直接REDIS解，因为它的源码体量很小，其实他才1。9兆，他自己才1。9兆，它源码嘛很小，然后解完之后，这个目录这是源码目录。

进入REDIS，那么这是一个常识，基本是源码，LINUX当中呢要按的程序都是C语言开发的，基本上都是C语，然后呢像源码安装的时候基本都是一个套路，什么套路，源码安装上来看的第一个东西叫做read me。

你在GITHUB上面去访问那些java开发的代码的时候，他进去之后，GITHUB任何项目的也是那个页面也是read me，就是无论你未来安装啥，就先看read me就可以了回车，然后你可以细读。

也可以粗看，基本上他会告诉你，这个REDIS的编译build在编译这个REDIS怎么去编译的，他说it's as simple as就是make命令就可以了，执行make命令就可以编译。

你还可以强调它编译成二十二十四，32位或64位，还有test还要清除make，后面加DILEAN就可以清除你之前编译，如果编译出错的话，再往下找，除了编译过程，下面应该还有一些关于安装的。

编译完其实好像可以直接使用，但是后面会教你编译完之后run redis，你直接在它的源码里边，就可以找到那些编译完的可执行程序，就可以把它跑起来了，这是一种方式，还可以把它装到你的这个系统里。

这是如何去使用它，启动它的客户端就可以使用，所以这时候其实根本就不需要老师，你们需要的是学习方法和一些套路，然后installing redis，如果把它装在系统里面。

是直接执行make install，或者是接上一个你想安装的位置，就修改它的位置，因为它默认位置装在什么，User local bin，这个这个是它的默认的目录，你可以更改它的安装目录。

就是在make install中间加上这么一个perfect，这个环境变量的定义，但是这个环境变量是随着这个命令执行是有效，命，令执行完这个变量就失效了。

然后他的UTILS这个目录下还有一个install server，点SH执行这个脚本，可以交互式的完成既有后端服务脚本，又有配置文件等等一系列的输出，完成这种服务器的安装，以上听不听得懂，但是你知道了。

要上来看，Read me，这句话听懂同学来刷一波六，好吧，但是你要注意了，你们都是用java语言，对不对，java语言编译的时候是不可能缺少什么编译环境，就是编译器对，那么这个时候你看我们无非就做了它。

让我们执行在这个目录下执行make，但是在这多说一句，其实make的原理make是make和我们的源码没有关系，make是编译命令，它是我们LINUX操作系统带的。

它是LINUX操作系带的，它是一个编译工具，但是他并不知道你不同的下载不同的源码包。

应该怎么编译，它不知道它需要跟随一个文件，叫做就必须找到一个文件，就是make f，你之前index的时候是没有make file，所以你要先执行CONFIG。

CONFIG完了之后会生成make file文件，你可以回去再试一把，打开你index那个源码，然后它里面是没有make file的，你所以你看他read me，他告诉你先执行CONFIG。

看完之后会有make file文件，然后那么其实make命令直接如果回回身拍的话，他是要读这个make file，我们先简单看一下这个文件，max max其实就是一个文件，一个编译脚本。

然后这里面会说了哎default or，然后什么还有一个title install，然后里面会怎么去，如果你什么都不输出的话，make后面什么参数都不带，那么走，他走的其实是让他要CD到SRC。

然后下边然后再去执行make命令，一旦你的参数，如果你install的话，如果你make后面带着install，刚才看安装的时候是不是可以make install，对不对。

你make后面install并不是make命令，install是你make file文件里面的那个title，你把它换成圈圈叉叉，那么你就要安装的话，就make军事圈就会触发这一行，明白啥意思吧。

所以这时候其实你会发现这个源码根目录下的，MAMAFILE文件就是一个跳远，它会跳到某一个目录下，然后那里边会真实的去执行你的Mac命令，一旦一个参数，所以真实的代码真身并不是他真身。

是在RC目录目录下，我们来看一下VVISRC哎，别别别别别，VN是CDCD的SRC的源码目录，这是我多讲一点，因为你们之前肯定是对电系统用的人，不是特别多的，不然后在这里面你会找会有一个真身文件。

Make file，是不是在SNSRC目录下，是不是也有一个file文件，然后这时候vi make file文件打开，这才是真正的一个文件里面写了很多了，所有的编译的环节细节怎么去编译。

以及你可以杠这个斜线，然后install so，未来是不是他make后面可以带一个36install，那个INO会间接的从外面的make file让你掉到里面，那个SRCM下INTEL参数还会带过来。

所以打开这个文件之后，他也会找install，找到开头这个title，那么上面是编译的过程，下面就是安装的过程。

那么你看软件什么叫编译程序，安装编译就是拿着源码变成那些可执行程序。

安卓的安装其实就是一些什么拷贝的过程，拷贝过程，那么这里面会用到一个东西，就是有一个，找不到哪去了，有一个release install redis server name install b。

有一个perfect，来回忆一下，把这个推到文件上面，然后在这会找到一个，Thanks，是不是在使用make命令的时候可以接install，是不是里边还可以再让你设置一个perfect。

然后这时候他你看他，他如果这个这个变量他没有找到的话，那user local如果找找找到你设置的话，那么就会使使用你设置那个能理解什么意思吧，然后给你演示一遍，就知道先把这个记住啊。

所以这个时候真正干活的回退，你还要回到这个源码，因为原文件会有一个make file，他让我们执行Mac，但是注意他还缺一个编译器，但是他让我们怎么做，你就完全按着read me的流程去走。

他让我们怎么做，我们就怎么做走，然后这时候他一定会报错，Cc command not found，cc是什么意思，C就是C语言的编译器，对不对，是不是C语言编译器没有。

那么这时候条件反射基于LINUX的话，一般都装什么，是装GCC，In all，因为我们的LINUX是gal linux，这个D是gal那个开源组织的意思，所以装的是GCC回车能听懂吗，同学们能跟上吧。

你看我们装的是GCZ，而且使用样的方式，它会装很多的依赖以及该升级的东西，同意走，先把编译环境给他，给他装起来，条理清晰吗，听得清楚吗，同学们，稍等一下把它装完，好了装完之后，因为你不是神。

你肯定不知道未来会发生什么事，但是你知道read me让你干啥了，所以你就干啥，make还是make，而而而且这你要回忆刚才关键的知识点，make后面是不是任何参数都没带，任何参数没带。

就是make里面那个default，就是要跳进去执行编译的环节，所以make命令如果一般来说通俗来说make直接执行，就是拿着make file去做编译，回车就报错了，报了个啥错，Depend。

我们来切一下，make点c t this cream，因为刚才执行一次编辑的时候报错了，所以你要清一下刚才那个编译，编译报错，那那那那个临时文件，而且这个命令并不是我从哪学来的。

是不是reading mei给我们提供的，比如你编译刚才是不是你只要通读一遍，read me里面是不是告诉你了，有那么一个make this is clean，没毛病吧，所以我也不是神，对不对。

有笔记后边都我先给你带一带，那个流程先跟着思路走，然后到时候把笔记给你写到图上去，好了装完了，他说it's a good idea to run make test，可以做一下测试。

但是一般我们都比较懒，这不就就不去做了，因为它的消耗时间太多，但是到公司的时候，你肯定是要编译的时候要测一下，看看是不是编译有有有这个有bug漏洞等问题，好吧，那么清收刚才做了什么事情了。

是不是就执行一个make，缺什么补什么，缺这资就补这资金，然后执行make时出错的时候该清清，清完只make之后成功了，make完注意分几个阶段，make完之后去你的SRC目录下。

就有了一些可执行程序了，比如redis server和redis CLI client就有了，那么一般你在这，比如在这个录下，我就可以REDIS，然后server让它跑起来了，回车他就一定能跑起来。

明白吧，但是这个时候其实你到公司的时候，你的软件的启动不可能每次都人工干预，这种方式是不是特别low，对不对，所以这时候你肯定是希望把REDIS的程序的进程，CTRLCCTRLC可以给他结束掉。

那么你期望的是让这个程序，它更像一个服务软件，就曾经装了一些服务，让它变成一个服务，但是你怎么去构建呢，Ok，刚才在read me里面也看到了，他是不会说有一个在UTILS目录下。

UT目录下会有一个脚本叫做install server，明白了吧，这些东西都不是我跟别人学的，就跟着read me，来来来来来来学的，所以这时候你就直接按照这个来做就可以了，但是毕竟我装过。

我告诉你一个前置条件啊，不少做少做一步少做，先先要去装，因为再带你看一遍看一遍吧，Read me，然后找到install，咱们就按流程走，也就是上边如果你编译完make编译完之后。

然后你可以在它源码目录当中CDSRC跑server，然后跑client可以来使用，但是你更期望的是把这个程序install，你的这个操作系统里去。

所以我们有可能要执行make install或者make，带着perfect install就装到某一个目录下，这个装完之后软件安装进去了，但是你更期望的是把它变成service。

所以在执行intel server走这么几个流程，这些流程都是从REDMI来来来来来得到的，能理解吧，所以我按照流程走，第一个是先去安装make，然后你要装的是install，安装安装哪去呢。

你可以接一个perfect，然后告诉他装到OPT，然后B咱们叫什么呢，马士兵吧，马士兵，然后下面有一个REDIS5这个目录，这能看懂吗，make install这个all是不是make sc目录下的。

inside里面是不是会执行安装的过程，perfect是不是覆盖他那个脚本，那个脚本文件里面那个那个那个变量，告诉他一定要装到这个目录下，然后回车，然后这时候你去看OPT，然后马士兵。

然后这个目下就会帮你创建REDIS，然后去到REDIS目录下，然后会有一个bin去到bin目录下，你就可以看到相应这个刚才定义完了，可执行程序，帮你牵出了签到你系统的一个你的安装路径。

下了就没有和源码混在一起，这部看懂的同学来刷一波，一，你看懂了这部在干什么事情，好吧，但是这时候你要注意啊，我只是把可执行程序这个文件放到了系统的，我希望这个路径下，但是这时候想执行的话。

依然还是这个目录下，我要执行redis server，让它好起来，但我更期望的是使用曾经那种比如说什么service，然后REDIS，然后star把它跑起来，但现在它不支持，所以还缺了一步。

把它变成服务，那么别的服务怎么去做，然后回忆那个read me文件里面，是不是让你这么做的，来到源码目录当中，Python让你去UTILS目录下，会有一个RESULSERVER安装成一个服务，安装一个。

那么执行它的时候，注意这个隐匿的那些东西都不用手工做，执行它就可以了，但是这个脚本，未来他需要知道你的程序安装到哪个目录了，我们要多做一件事情，vi etc profile文件到文件。

最后新开一行export，定义一个redis home，一般我们在操作运用当中装了什么，什么什么程序了，是不是都要把它home，然后以及它的bean目录，可执行程序文件追加到pass那个环境变量里。

你追加进去了，你就可以在任何位置使用那些可执行程序，这是一个基本常识，兄弟们，你java是不是装完之后也得试加home，目标不是为了设置jaa home。

是要为java home接他那个bin接到pass里去，所以你的所有你的java命令在这个位置可以执行，所以我们在这来做是opt，Release5，先把它的安装路径加进来，然后export。

然后是大写的pass里面等于dollar把pass拿出来，再拼上我们的REDIS，home下的bin目录主要是要接这个bean bean，里面有那个RESERVERRELP，然后把它加完之后保存。

保存完之后注意配置文件是死的，它存在磁盘，当内存里面做程序只能跟你配置不知道，所以source etc profile文件，然后这个时候echo dollar pass。

里面就会出现你REDIS那个闭目录了，所以你可以在任何位置，起码说我可以直接REDISCI就可以起客户端了，这个命令在任何位置可以用了，这个听这个环节，听同学再说，波一这是一个常识吧，对不对。

这是一个小常识，当你有了这个之后，你再来调这个install server，它就可以通过上面这个目录里面找到一个命令，就知道你的安装路径在哪了，这是他需要一个过程，如果你不是的话。

其实你到时候手敲也可以，我们来走一遍，下一个流程就是在当前目录下执行install server，注意看回车。

这时候please select the redis端口号for this instance，也就是，我们希望在我的win系统中安装一个REDIS服务，但是他告诉你，你必须选一个端口号。

这个逗号是为你当前实力的，这句话，另外一个意思就是，一个物理机上边可以跑一个REDIS，也可以跑多个REDIS，他们靠什么区分啊，靠什么区分，是不是靠端口号来区分，对不对。

那么这时候注意他括号叫做默认选项，你不填东西，后边等着你输，你不填东西，它默认就用6379，而且也得出一个基本常识，REDIS默认端口号是6379，如果不选，就20 6379。

因为这是目前的第一个实例回车，他会继续追问你，please select是什么呀，Redis config file，配置文件程序都是有配置文件的，注意他放到哪去了，ADC是不是放配置的目录。

他在里面会准备一个release目录，且为你这个实力准备一个为你准备的，6379点cf，也就是如果这台服务器这个脚本，我吊起十次，我可以装十个in30个实例，十个端口号，那么每一个实例。

它的配置文件的名字都是随着端口号而变化，不会覆盖这个在提醒同学来刷一波一，也能也能跟得上，对不对，然后再看除了配置文件，程序运行的时候，是不是还需要日志文件，日志文件放。

他帮你规划到word word是不是放数据目录的，放数据目录，对不对，所有的日志都放这个目录目录就放，然后那边会准备log redis，然后加上端口号的日志，然后只要你上面给个端口号。

所有的资源文件都能通过端口号来区分隔离，对不对啊，然后我们再走，默认再走，下周会告诉你，slice data directory就是数据目录，那么这问一句，REDIS不是内存数据库吗。

他为什么会有一个磁盘目录来存数据呢，因为只要提到内存的软件，它都必须触发一个技能叫持久化，因为内存掉电易失，对不对，那么注意，你看这个目录是不是又是拿着多个号去区分的，也就是6379。

所以你装很多的实力是不受影响的，回车最后police slice什么REDISACCUSABLE，就可执行程序的路径，那么在这他怎么知道是装在这个目录下了，是不是我刚才那个环境变量的配置。

如果环境变量没配，你是不是在这手敲这个命令的路径，这也能听懂吧，所以我配了它就自动识别到这个位置了。

那么好，OK就这个位置回车上面一系列选择完之后。

因为第一个我就不去改，待会再装一遍，我再去改它，然后这时候告诉你这个selected，你选择的配置如下，逗号是379，巴拉巴拉巴拉，然后这时候如果你觉得OK没有问题的话，然后press enter回车。

然后要么就CTRLC结束这个流程，什么事情都没发生，我们现在就回车，注意看回车之后啊，注意看，回车之后回车拷贝他在临时目录当中书写，这个637有点com，把你前面很多东西都写到配置文件里去了。

然后并根据上面的描述放在这个目录下，这是第一件事情，第二件事情，installing service安装服务，他其实是把什么把一个启动脚本装到哪去了，装到了etc的引力的目录下。

BQCONFIG做了开机启动，在2345启动，并他还帮你把REDIS提起来了，那么这是常识，注意听啊，这是常识，他能做这个CONFIG，能做开E服务启动的话，他一定会向哪个目录。

是CD etc init d的一个目录下，他一定放了一个东西，这是REDIS6379这么一个脚本，注意这是一个脚本，这个脚本当中他书写的，你看我们的可执行程序，就是刚才他识别那个程序。

然后它的配置文件就是他刚生成配置文件，只能看同学来刷波一，那么有了这个脚本了，并且执行了带绿色了，那么这时候我们是不是可以在任意目录当中，REDIS服务名叫什么，是REDIS，然后start吗。

或者studies吗，一定要写这个脚本的名称，才能是这个脚本名称，就是service这个后面接这个东西，对不对，所以后面接的下划线6379。

然后可以studies来看一眼redis is running，在6244id，为什么，因为你上面安装完之后，是不是还给你做了一个study，服饰已经跑起来了，以上流程整体看明白的同学来刷一波六，好吧。

你能装一个实例，今天是不是可以装多个实例，你再回到这个目录下，去哪儿是不是去UT，注意这个时候注意我的程序在磁盘，那个可执行程序是不是装在OP里目录一份，对不对，但是这时候未来我这个计算机的内存里。

是不是可以用REDIS的几个技能，几个实例程序文件是不是只需要一份，那么内存里的时候会出现它多个进程的呗，一来自这个肯定程序有多个进程，多个进程他们是不是来自于不同的配置文件，未来使用不同的持久化目录。

对不对，也就是程序是一个，剩下的资源和内存是多个副本对吧，那么这时候我们还执行这个脚本，install server回车，那么这时候他走的肯定是脚本里默认值，那么639我是不是装过了。

我只要告诉他6380，然后回车，然后这个时候你看以下的配置目录，所有文件是不是都使用6380，对不对，都能区分出来，你根本就不用管，然后但是程序不是来自于一份程序一个版本的。

然后再来回车是不是告诉你一个三八，你觉得有问题吗，没问题回车，然后这时候会告诉你怎么样，又是你这个安装完了并给你启动了，所以这时候service redis6380studies，是不是又一个跑起来了。

然后这时候你可以用什么去验证PS杠，F grape redis，这里面REDIS是不是一个一个进程，646244，刚才那个一个6288，这两个进程是不是使用了不同的端口号，跑在了不同的。

就是两个独立进程了。

但是程序是来自同一目录下，同一个程序在内存里边。

系列 5：P89：89、redis安装实操总结 - 马士兵学堂 - BV1E34y1w773

好吧，讲一遍写一遍，做遍笔记，回来趁热打铁，别忘了静静地回忆一遍，安装的流程和步骤是什么，把它背一遍，这样记得更清楚一些，关关说跟其他讲的是不一样，你看过谁的呀，第一步要什么，要准备一件什么事情。

我给你写完整吧，是不是在你系统当中，要么install w get这个命令，优秀有一个版本也是我讲的，懂了吧，但是后面的版本不知道谁讲的了，来先不讨论这个事，咱们接着来啊，接着来，第一步是要装W盖。

有了这个命令之后，你可以下载这个源源码，对不对啊，然后CD到你的家目录，然后呢第三步make dl创建一个salt目录，然后第四步CD到salt目录下，进去之后第五步是w get。

然后那个地址是来自于上面那个地址，我写啊，你得跟着跟着一块回忆好吧，我给你放大点，这个字应该有人看不清楚，这样清楚一点吧，再拉大一点，第六步有了它之后。

然后TXF有人说你为什么不加V，别人是不是写了好长啊，带一个中间对，中间带不带无所谓，是不是要带着V，然后这时候有一个小常识，就是你要明白啊，我们你在公司当中拿的是客户端。

这是一个插上windows的一个东西。

你带着V它解压的过程，所有细节会通过网线回想到你的客户端，会对你台服务器造来造造成一些IO的影响，那网卡是不是得把东西数据包发出来，对不对，所以其实你越搞得深的人，其实更期望什么呀。

IO上规避一下就可以了，所以我把那V我不我不看了，反正要么成功，要么失败，直接就是xx撕毁了，解压这个文件就可以了，没错，到时候归BO，然后把它解压完之后，然后你要C到源码目录，我就用别名了。

你信了他那个源码目录之后，然后第八步很重要，看什么，任何的源码安装都要看什么，没错，你只要把这个学会了，未来你装啥都不怕，你现在可以，今天晚上可以回去之后再装一遍NYX，你读一遍他的read me之后。

你再来，你再来看看它是一个什么流程，对不对，看完之后，然后呢你肯定跟着他的流程走执行，make这个妹子的时候一定缺失一个什么东西，你要安装em install一个GCC，然后肯定是还得去需要什么呀。

Make，清楚一下，会有这么三步缺失，这么几个缺失，就是你肯定先make make，已经产生一些变异的东西了，垃圾了，然后报错了，然后你补全报告诉你缺了缺了cc，然后你就安装GCC。

但那些垃圾已经产生了，然后你如果在这种Mac命令会报错，所以说要先清一下，切完之后，然后第十最终在执行1M，那个执行完之后，你会发现去他的SRC目录下，然后里边儿就已经生成生成什么了，生成了可执行程序。

然后但是我们更期望的是未来把它变成服务化，服务化之后，你需要在这个它的源码目录，这是刚才CD了，CD进去了，你再退回来，看完之后再退回来，退回来之后，然后再执行一个make，然后install。

但是给了一个环境变量覆盖他那个脚本P等于，然后OPT，然后是马士兵，然后REDIS5RI没，你随便给这个目录没有无所谓，他会帮你创建好吧，然后这个时候执行完之后，你去检查那个目录就有了。

然后这时候多做一件事情，VIETC现在profile文件，然后15步啊，这个打开文件之后在里面写什么东西，要export，然后一个redis home等于你刚才那个OPT马士兵，REDIS5没毛病吧。

然后再在下面再写一个，这是pod pass，等于dollar pass，拼上一个dollar redis home，你主要的那个闭幕，可能程序那个位置，然后这步做完之后保存15步，当这件事做完之后。

你可以CD到UTIL目录。

CD它源码的UTIL目录下，然后在这里面16步。

然后触发他当前目录下执行install server点SH，我看见那个中线是中线，是下划线啊，下划线是一个下划线，执行执行的过程当中，有几个东西，有几个知识点，也就是说第一个知识点什么知识点。

一个物理机，一个物理机中可以有，多个REDIS实力就是进程的意思，我做个ready进程，通过part区分，因为他们要通信嘛，通信的时候肯定需要有，各自有各自的那个端口号，然后第二一个。

然后这个程序可执行程序就一份在目录，就上面这个目录下面放着，但是内存，中未来的多个实例需要各自的配置文件持久化，持久化目录，懂资源就是这个流程当中，你要给出不同的端口号，它自动会帮你完成不同目录。

不同配置文件的一个初始，对不对，听力了吧嗯好，刚才少做一个S，搁这加吧，一个SALUCESOURCE，然后ABC的哦，这部你要不做的话，他是发现不了的，然后再到它按照它能跟上吧，是不是这么一个流程。

然后这样完成之后，然后其实最后你会发现，他还给给你做了一件事情，就是一个最基本的一个常识，这个常识就是service，后面接的是REDIS杠6379，然后start stop或者studies。

或者是638063666381，这个东西这个东西会变，对不对，然后他的知识常识来自于LINUX，用的是etc的n it点D下边会有这个脚本，行行星，这样行星这一个脚本。

这个脚本也是通过它来实现给你部署进去的，而且绑定了一个端口号，我就做一个简单的一个笔记了，回去你可以拿着图之后，可以自己在网上写的更细一点，可以吗，同学们，好吧，当执行完之后，然后下一步他还会帮你启动。

脚本还会帮你启动，OK搞定，你可以装这个这个脚本可以执行一次或多次，对他帮你做了check config啊，他帮你做了check config啊。

好啊，你只要按照这个做，就一定能把它装成功，碰着A边线降成一个降细一点好吧。

Ok，那么好放一同来说。

现在我已经装完了啊，对验证这个命令你可以再加一下，你可以做这么一件事情，是P杠FE管道grape，REDIS可以看到是不是会有多个进程，PS杠b grape，然后REDIS是不是两个阶段就跑起来了。

为啥要装到LINUX系统下，是只能安装在LINUX系统中的，不是windows也可以装，问题能装，但是我们基本上服务都是跑在LINUX下的，我不make直接安装GC，然后去make是不是就不用清除了。

如果你直接安装GCC，就不需要做Mac清除，因为你没有Mac，你就不会产生这个垃圾，对不对，脚本是自动做了开机启动吗，是啊，你看下面直言脚本之后，我看到你看读啊，你一定要注意细节，好多。

我带过这么多年的学生了，其实大家都有一个通病，就是你在盯着执行命令之后，你就一闭眼，我看不见看不见看不见，但人家真的说了，人家说了啥了，拷贝这个东西过去了，然后安装服务。

安装服务其实就是在向那个EDZ引擎点低，蒙下拷贝那个脚本，然后并执行了什么呀，这个CONFIG，然后它运行机是345的级别，就是命令行和图形界面都会默认开机启动，然后并且把服务给你start去了。

就等于执行了service redis，6379start，然后比如告诉你诶成功了，所以这时候你直接看这些提示，都能知道他在干什么，make是干啥的，make是一个编译工具，make是编译工具。

make加上make file文件，Mac缺失了Mac文件，但是不知道应该先编译什么，后边什么的，make file文件是你的源码的厂商给你提供出来的，Mac只是个工具。

就跟你那个java c这个命令一样，但是编译下你后边是给出参数的，对不对。

或者NT编译这样的一种工具的，没错，这是类似于JAVC的命令，好吧你这么理解也可以了，但是它不是只面向一类言的啊。

系列 5：P9：9、以阿里为例，补全你的简历缺陷 - 马士兵学堂 - BV1E34y1w773

首先我跟大家说一句啊，这个P5是一个什么直径，P5是一个入门级别的大厂，入门级别的职级，实际上以前阿里是有P4的实习生，但是后来P4这个直接就不招了，现在基本上就是P5，P5是什么样的人，会是P5呢。

按理说应该是零到3年，他们认为你是P5好吧，也就是说你社招3年以上的，那直接就是P6了，但是到在目前的情况下来说呢，大多数的情况下，作为P5是你刚刚毕业的应届生，应届生往往是定级P5呃。

不管你是本科生也还是研究生啊，我这里没有提专科，因为专科屁股这个直直击你进不去好吧，刚刚毕业的应届生，然后呢大概在你工作，你比方说你最开始的时候没有进到大厂里面，你进到了一家中小厂工作3年左右。

哎你社招通过社招进大厂了，这个时候往往是P6，然后你在你项目组里头，慢慢成长为带那么四五个人，这个时候你往往是P7，当你负责完整的整个的项目组的时候，我告诉你，你这个时候呃，大概你手底下是几十个人的。

这样的一个一个一个规模的时候，大概就是P8了，当你手底下有不同的技术团队，包括业务团队的时候，你这个时候就是P9啊，那个如果从额薪资的角度来说，P5的薪资的话呢，大概是20万到40万左右。

那么如果是从嗯。

P6的薪资来说呢，大概是40万到60万左右啊，呃如果是P7的话呢，大概是50万到70万，但是这时候是有股票的，就是大部分P7是有股票的，只有少部分没有，因为阿里有一种文档，P7也比较好玩啊。

他专门写文档的，他那个薪资就低很多，50万到70万，大概再加上800~1000 200股啊，你这个股票比较值钱的时候呢，这个差不多P7的薪水能拿到120万左右，顶薪，哎我讲到这。

有没有同学想想看看那个P7的简历的有没有，有没有有的话给老师扣个一来，3年以上还可以练屁股吗，3年以上你就要搬P6去了，你为什么还要练屁股啊，干嘛这么看不起自己，嗯我给大家看一个非常牛逼的简历啊。

这个是顶薪的，120万年薪的简历，我找一下。

这个呃这哥们儿当时是29岁，拿到的是阿里的P7plus，它不叫P7，这个叫P7plus，我一会给你解释什么叫P7plus，P7plus那个100就是80万的正常薪资，外加40万每年的股票嗯。

就类似于大概的估算的值啊，120万年薪呃，你们也可以读一读，看看看这个简历呢，自己能不能罩得住这个简历呢，如果你仔细读的话，其实你会看得出来，那个这里面最重要的最值钱的点到底在哪，5年java开发经验。

其中3年以上全是大型系统架构设计经验，3年以上团队管理经验，分布式高并发，高可用大数据量的系统架构设计和研发经验，好了，这是最值钱的，当然目前政府的注册用户多少，日活多少，日访问量多少。

这种的比较吹牛逼的啊，这实际当中的数据很可能到不了这么多，对开源源码有过深度阅读，好，从这儿呢你大概可以看出来，P7到底是一个什么样的水平，架构设计，源码阅读，这就是为什么我在课程里面。

会给大家这么设计的原因。

明白吧，就是老师的课程设计，不是说随随便便给你设计的啊，为什么要读读源码，读原理，为什么要做架构的设计，其实就在于这就是希望你们能达到这样的水平。

当然不是说每个人的薪资都能达到120万，不是那么容易的呃，取法乎上得乎中，取法乎中得乎下，你的目标定的高一点，哪怕没有道，你跟其他人相比，你都是赚的，你的目标本身就定的非常低，我今天就吃掉一个饺子。

你就算达到了，你也就吃了一个，我今天要吃100个饺子，然后就算没吃完，我吃了50个，那我比你这一个也要牛逼的多得多好，这是他的一个技术站，这些技术站咱们课程体系里全有呃，可以这么说。

我的很多的课程的设计，是根据咱们同学们遇到的各种各样的问题，来设计的，那个这这这这全是一堆一堆精通了啊，这个你放心啊，其实看上去很难，但是呢不是想象中的那么难，无非就是你需要掌握架构的一些个技术。

选型是吧，当然最新的还有power啊，然后呢搜索上的一些技术选型啊，这种那种呃这个持久化的一些技术选型，缓存的一些技术选型等等，就这么多，加上一些底层的知识啊，呃他这个呢还没有写算法，写太多啊。

嗯其实还需要有一点算法的知识就OK了，这背后究竟付出了多少。

呃不要不要羡慕别人，我有的时候会说可以拿别人来举例子，但是呢每个人的路啊，每个人的人生路都是不一样的，你不可能完完全全的复制另外一个人的人生，跟自己比就OK你比自己更强了，今天我比昨天强一点点。

明天比今天强一点点，时间稍微一积累都不用长，几个月的时间，你就会发现你已经脱颖而出了，其实就这么简单，那个嗯，你们你们你们，你们想知道那个那个那个他现在的一个状况吗。

这个这哥们是是咱们史上最牛逼的一个学生啊，史上最牛逼的学生，你找一下他现在的一个状况啊，这里是大概有1000多位我的学生，然后做的一些小小的总结和聊天的这个过程，我找一下啊，嗯就是他，对。

呃这个呢是他那个最近，然后拿了5000万的股票呃，套现之后，然后从公司离开，做了一个小小的总结，就是P7的一些一些一些内容啊，P7说到底是硬通货，是个分水岭呃，这里面需要你掌握什么，需要你掌握什么。

需要你掌握什么，K大家可以到这个网站上去访问访问看看啊，这里面都是很多同学非常真实的聊天啊，你们看看就会知道了，那个呃当然还是那句话啊，就是这种的比较极端，我也绝对不会说奢望。

说我们每个人都能达到这样一个水平，我在他这个年龄的时候，也达不到这样的一个水平，好吧，所以大家呢也不要说太羡慕，这个也没有意义，但是呢最起码这份简历会给你指出方向来，我们可以朝这个方向去吧。

我们今天啃下来，其中的一小点是不是就进步了一点点。

我说今天我们甭啃别的，我今天啃了一个分布式事务，这东西不难的，咱们一堂课里头呢，差不多你花个三天，顶多花个三天左右的业余时间，就能把这个就能就能够把这个搞定，你知道吗，我们是不是搞定一条好。

我今天不干别的，我就聊一个自动化部署，我今天不干别的，我就把docker给搞定了，你想想看这个三天，这个五天，然后那个七天加起来的话能有多长时间。

最重要的是你根本没有必要每一个都全部精通，面试的时候，我说过了十加成两家就可以了，不用面面俱到，这大家能听进去吗，天神下凡对什么学历学历相对比较好，985，浙江大学，浙江大学是985吧，嗯肯定是啊。

当然我说到这很多同学就开始给自己找借口了，老哥我是大专，所以我不如他很正常，因此我又可以安心的躺平了，我说我再给你说一遍，我说他这个案例不是要你跟他比，而是要你建立起来跟自己比的感觉。

你今天要比昨天强一点，以他的这个技术为目标，能听进去吗，就是你天天跟比尔盖茨比，那你这辈子永远完蛋，你天天跟埃隆马斯克比，哎你这辈子就别活了，所有人都别活了，对不对，跟自己比，我今天比昨天强一点。

明天比今天强一点不就成了吗，嗯能忽悠大钱的背景，肯定背景必须放光，这就是背景背景决定论嘛，来我想问你那个马云背景怎么样，马云985的对不对，马云是杭州师范的大专生吧，如果没记错的话。

任正非是原来当兵的嘛，对不对，英语老师对啊，所以不要找借口，我跟你说，你所有的这些这么说的，其实都是在暗示自己，我没有他的硬件，所以我有自己的不成功的借口，其实就是这个给自己一点心理安慰嘛。

嗯我是种田的，对嗯嗯好了，但这个就比较夸张了啊，我们想想想起来了，拿这个举个案例呃，这是一个P7的薪资，那P8的薪资的话呢，多数人应该是到不了的，到目前为止，我直接培训的学生里头还没有还还目前啊。

我跟大家说，我确实我还没有能把一个人直接呃，学完咱们课给干到P8的，I'm sorry，我这个还确实还没有干到，因为P8呢真的就很难培养了，他的这个薪资呢大概是200万呃，就是按照官方的说法。

应该是120万到200万啊，这是这样的一个薪资，那么这里面就有很多很多的非技术的因素了，技术层面我完全可以让你到这个水平，但是非技术层面我也在尝试呃，目前呢也有一点点好一点的好消息了啊。

就是这这这这种层面的也。

我我也在给大家做尝试，就是课程体系里面。

为什么给大家要增加团队的管理课，产品的管理课。

其实呢就是想让大家在你以后的职业生涯里头，走到高端的时候。

也能够还有空间呃，到现在为止，我是我们现在有一个学生啊，我在我的微信里已经把他给置顶了，我只有一个学生，他已经灭了七面了，明白吗，他现在面P8，他灭了七次了，已经灭完这七次之后呢，还有第八轮的交叉面。

就是为什么说，那个那个那个那个那个那个哥们说那个我靠，这灭了，灭了七次了，还没这个P8，定级太难了，确实非常的难，然后呢还有最后一轮的交叉面，因为什么，因为他要求的定级太高了，所以就一轮面一轮面。

一轮面一轮面，然后很多人都认为你确实到这个程度之后，才会给你这个职级，当然这个职级到来的时候，就意味着200万年薪了，OK呃据我知道的，从京东跳到高德的，就是那个有一本书叫亿级流量。

我不知道你们了解过没有，那本书，它的作者就是从京东跳到高德啊，我当时微信联系了，说给咱们来讲讲课，然后呢高德实在太忙了，高德可能是阿里里面所有最忙的BO，然后那个没有时间讲课啊。

不然的话把他请过来讲课呃，从京东跳到高德，大概是据我了解，应该是这个数400万啊，嗯所以小伙伴们，你首先要敢于想，就是你要知道呢，这个世界上是有好多好多潜力的，你首先你你的潜力呢也不要想那么高。

我现在拿12万好，我明年的目标能不能拿到18万，听懂了吧，这就是一步一个脚印的扎扎实实的，今天比昨天强的非常科学的一个目标的定级，OK怎么说呢，机会有的是啊，在这里呢大概是1000多份。

1000多位的同学啊，好同学说，老师你做假放心，老师这里头全部的案例要有一份是假的，十倍学费赔付给你，你随便找，你想找任何一个人，说他的那个那个找他联系方式，只要他同意，我都可以给你联系上啊。

嗯怎么说呢，这里面的案例呢就是不同的人，不同的案例都多的是有顶级的，我刚才介绍的都是顶级的案例，当然也有呢刚刚入门级别的，我还是有话就是路是一步一步走的啊，比方说入门级别的像什么样子的呢。

嗯这种的最开始呢原来是拿8000块钱，然后学学四个月给拿到1万，1万4还可以吧。

一年就7万多呀，这就是学习的收获啊，当然扯得远了，我们翻过头来再来看看啊，就是什么样的人可以到P5，什么样的人呢可以到P6，什么样的人可以到P7，他到底是都需要哪些哪些东西。

呃我刚才呢给大家讲了一个概念，这个概念呢叫什么呢，叫P7plus，你们这个你们知道这个plus是什么意思吗，有没有知道这个plus什么意思，SSPP最高呃，我想问大家一个小小的问题，这里有一堆P6。

1233个P6，我要在这三个P6里面挑一个人做晋升，升值为P7，来你告诉我谁会升上来，谁会升上来，Who，当然有同学说就开玩笑了，开始是吧，长得漂亮的跟评跟那个考考评官有一腿的，跟考评官关系好的。

首先第一点，高级别的晋升并不是只有一个考评官，也不是只有你熟悉的那个第一点，长得漂亮跟漂亮，长得漂亮确实有点优势啊，但是呢他肯定不能不是决定性的因素，好好听我说，如果我要在三个P6里面挑一个P7出来。

那么我一定会找那个优先，已经开始做P7事情的人，能听懂吗，我再说一遍，如果我要在一堆P6里找一个P7出来，我一定会找那个已经开始在做P7事情的人，好了，这个就是P6plus，同理那个就是P7plus。

就是我为什么说在你们平时工作的时候，要多承担一些，多做一些，不要老在那斤斤计较，我给我这点钱，我就干这点活，我多干点我就亏了，我是真的遇见过这样的人，这样的人最终的结果就是滚蛋，没有别的。

所以让自己就是简单说提前一步好吧，来听进去的，给老师扣个一啊，讲点，今天感觉讲的比较碎，因为主要我没有给大家解释为什么自己体系，典型的自己体系是什么样，嗯以及呢他的一些个各种的说法啊。

我简单跟大家说一说，也就是大概是一个什么样的，什么样的，什么样的一个一个一个一个水平吧，就是P5呢他大概做了一些哪些事情啊，P5大概是这样的，它叫做嗯直职级的入门就是新兵啊，给你一个模块。

独立完成就是给你个程序，在别人的指导之下，我告诉你啊，这个这个东西要完成这个业务，然后告诉你用什么技术好了，你能独立完成这个基本上就是就是P5，听懂了吧，然后作为P6来说呢。

就是你独立开发某一个这个不能叫模块啊，就是P5来说就是某一个模块的分支，就是一个小程序啊，独立完成你自己的一份呃编程的工作，就这样简单，那么P6呢可以独立完成一个模块模块级别。

那么P7的话呢实际上就是项目整个项目级别，你可以带领团队来完成整个项目，好吧，呃基本上大多数人都是集中在这三个职级啊，我目前只有一个学生在冲P吧，他冲不冲的下来，冲下来我会告诉大家，冲不下来的话。

我也不会跟着吹牛逼啊，那个呃作为P5来说呢，一般来说我刚才说过了，就是应届生，所以呢你社招生呢。

系列 5：P90：90、 epoll介绍 - 马士兵学堂 - BV1E34y1w773

谭总啥时候一炮啊，刹车一炮这块从这讲吧，我这讲就有点有点累，我简单给你说一下吧，公开课有人听，有人没听过，是不是不是，现在简单说一下，咳咳咳，计算机啊，在这插一个小小插曲，做个查询，计算机是用内核。

内核呢像内核可以接得住很多的连接，然后向下是有连接的，是有所谓的客户端，我就直接下边就是客户端连接，有很多的客户端连接，然后客户端连接肯定有很多，然后所有的连接肯定是先到达内核，对不对，新内核。

然后这个时候早先的，我们的内核里面会有这个连接，其实就是文件描述符，然后呢早先是通过瑞的命令，只有一个read可以读文件描述符FD，一个连接就是一个FD文件描述符，比如文件描述符八。

然后这个是文件描述符九，然后这里面这个瑞子说我要读一下八，我要读一下吧，这个文件标识符，那么这是你的一个线程，你可以有一个线程或者一个进程线程，或者是因为java中我们可是线程，然后另一个就是进程。

因为你一个进程可以复刻出很多紫禁城，HP老是那个web server，他就是fork出来的，但是NINDEX就是使用的什么一种义不飞则，但现在描述是早先的，那么这个时候他肯定是期望着什么呀，去瑞的。

FD9我加这个差距可以吧，同学们加这么一个差距，因为的确是要讲他那个模型啊，这讲的还是靠谱的，那么这样的话为什么，因为re，因为socket在这个时期，是block blocking是阻塞的。

socket是阻塞的，也就是socket产生的这些文件描述符，你读它的时候，他如果数据包没到的时候，你这个read命令就不能返回，就在那阻塞着，所以是blocking的，那么这时候我们之前。

我们的早先的7。01版本，之前的top hat是不是阻塞的，IO也就是说你需要抛出一个线程，然后读这个网网卡，这个链接有数据就处理，没数据，在这阻塞的下面，那行不了，你只能抛出更多的线程。

抛出更多线程的话，如果你只有一颗CPU的话，其实某一时间片上面，某一个时间点上只能用一个线程助理，这里边数据还没到，但是别人数据到他还不还轮不到他处理，所以整个的计算机其实CPU并没有时刻在处理。

那些真正到达的数据，会有很多资源浪费，以及线程更多的话，切换线城市也有成本的，所以这就是早期的bl时期，因为socket是阻塞的，所以叫bl，好吧，这是第一个时期，那么这样的话。

计算机硬件是很难被利用起来的，所以谁发生了变化，内核发生了变化，注意再来画一张图，内核肯定是有一个跃迁，一个变化的过程，什么叫一个跃迁，一个变化的过程，在系统中都可以看到这个东西。

首先我们可以通过yum install一个man帮助man，然后杠pag menu是看帮助的一个帮助程序，manage的所有帮助页回车。

他给补一下，你要想这么去做，先用这个知识，ym install men和menu page。

首先把刚才的知识理论验证一下，menu可以看，比如我们之前用的命令，比如LS这个命令怎么去帮助的，他是一位文档，还有八类文档，帮助程序可以看八种类型的文档，然后二类是系统调用。

就是内核可以对外提供，像那个瑞的命令。

就是一个系统调用，然后比如说看read回车，然后它是二类的系统调用啊，就是内核给我们程序暴露了调用的方法，对吧，然后这个是一个总称，它的系统调用有三个create poctrl e weight啊。

现在看这个早先的那么调re的时候，这个raid方法里面是传承，是传了一个文件描述符，文件描述符就是file descriptor，而java当中是用object来代表一个对象，代表一个输入输出流。

就是input output，在系统中它不是面向对象的，它是一切皆文件，所以都是拿着文件描述符文件来代表，这其实是一个数值，1234讲成这样的时候，应该都知道零是标准输入，一是标准输出，二是错误输出。

然后你再开启这个新的这个这个IO的话，就会产生更多的，比如说我们可以看一眼啊，克隆一下这个标签，任何进程在操作系统里面都会有它自己的，IO对应的文件描述符，PS杠F杠grape redis。

然后就看6244这个进程，然后怎么去看CDPLC6244，然后你看FD就是看这个进程，它有多少个文件描述符，有多少个IO呢，一切皆文件，在你的系统中都能看到，程序里面的那些东西回车。

然后这里面有零标准输入，一标准输出二包括输出，且这个REDIS有动用了pap的调用和e even pl，这是一炮，有socket，因为它开启了一个6379号，这就是所谓的文件描述符。

这个10123456就是文件描述符，任何的进程都有，你去我们当前这个bh k l c dog dog f d，那么也有012，就任何进程012肯定都有的，剩下的是V其他的好吧，那么回来看。

先知道你瑞的这是内核，内核报的内核报了一个raid，然后他能读一些描述符，那么关键这个描述符对应那个socket也好，对应的那个连接那个文件也好，他是一个什么什么什么形式的，然后再来看。

man2socket学java的时候，我们是不是可以用server socket socket来开启连接，对不对，所有链接对不对，那么这个时候你注意看那个你要调solid的话，然后给出读慢域名。

然后号拉的，然后这时候看，如果你所有的看下边，这里边会有一个隐秘的tab pro，就是八零或者22这个协议，前面就是那个IP地址，然后int tab tab是什么意思，往下往下走。

就是这个方法的时候给你返回一个，这是什么类型的呢，这个tab类型的往下走。

这就是currently defended tax，再往下下面。

这是做的tab，然后如果你传了一个socket nblock，NG什么意思，NBLOCK什么意思，是不是非得那么这时候并不是给你瞎忽悠啊，就是socket内核当中socket可以是非阻塞的。

所以才有了一个非阻塞的，就是你一定要明白，IO好像看似BIONIO和AO3，但是它的发展过程是很细节有很多的，首先是因为内核的socket可以是nine block，刚才是不是blocking。

也就是对应的文件描述符是NBLOCK，这个文件描述符是不是可以NBLOCK了，那么NBLOCK之后，这个时候刚才说了，线程多是不是会有弊端，那么这时候哎你不阻塞了，我是不是可以用一个线程。

比如说用一个线程，我就一个CPU，那我就这一颗CPU上面只跑了一个线程，只跑了一个进程，它不切换就尽量少切换一个没用的，然后这个县城里边写一个循环死循环，while死循环先去问read，然后文件名八诶。

你给我给我给我给我读一下，然后他肯定给你返回什么呀，因为他是非读错了，告诉你有数据或者没有数据，然后这时候你变成了八，发现没有数据好，你在便利谁啊，再调read，然后FD9没什么意思吧。

就你这个进程可以循环先调，先先去读它给你返回没有，那你就再去读它给搞，你有了拿着有的东西可以开始处理，处理完之后才能再去循环并列文件符标，文件符名符八，他没有，然后再进来往下循环，一直循环遍历，叫轮询。

这个轮询发生在哪了，轮询发生在了用户用空间，能听懂吧，这个时期叫什么，这个时期就是非阻塞IO的到到到达了，但是它是同步还是异步的，什么叫同步，什么叫异步，什么叫同步啊，什么叫异步。

便利取出来处理都由他自己来完成，所以叫同步，非阻塞时期，是不是不注册了，是不是堵你一下就可以进去玩做代码，但是这个所有你有的时候我从你取出去的事，是不是还得自己做，是不是同步非子是能听懂了吧。

然后这个时候就可以叫什么，是不是可以叫NIO了，很清晰吧，但是技术是永远向前发展的，但是技术的发展不是因为技术，而技术就是你非得酷炫，技术一定是要解决问题，那么请问我现在的问题是什么。

请问现在的问题是什么，这个模型已经是同步非阻塞NL了，那么问题在哪呢，问题在问题在哪，还没有倒钩子呢，因为先要再出现一个多路复用，后面才能是什么，才能是这种所谓的AL异步的。

那么问题出现在如果有1000个FD，注意听1000个FD代表什么意思，代表用户进程，轮询调用1000次kernel，就是成本问题，注意这叫成本问题了，是不是成本很大。

因为想找到问题问题才能促使科技的进步，也就是说这个进程不是自己处理，不处理的问题啊，你写那个后边的多路复用，也是也是自己做这件事情，他是自己的，用空间查询一个文件描述符，就得调一次系统调用。

然后内核用它内容切换，CPU保护现场恢复现场一大堆事在那换来换去，换来换去，这随着你的这个连接数，如果其实连接数很少的话，无所谓，两三个两三个连接切入也就这样了，没必要往前发展一。

那么怎么解决这个问题啊，当你翻问题怎么解决问题，如果有1000个，但是这1000个里面谁能不能读了，不需要触发1000次性掉一次，掉两次就能发现这个问题，是不是可以加快这个速度。

就是将这个问题不解决就可以了，但是要想解决这个问题，少减少这个这个这个信条用，那么用户自个儿能实现吗，是不是实现不了，所以内核得向前发展，能跟着这个思路吧，就是内核不变，这辈子你可能实现不了，没错。

就是把你这轮的事扔到内核里去，内核里从而多了一个系统调用，他就是增加一个性能，这个性能用早餐叫什么呀，叫做select，增加了这么一个系统调用select，然后这个时候其实你的用户间是调到新的系统。

调用了新的掉落的时候，其实就是调个select，这个系统要用select，但是调它的时候我们可以看一下啊，如果你的进程想调select。

下面假设有1000个文件描述进来了，来看推出来menu2select系统调用select，然后这个时候注意看这是一个select方法，然后int然后有多少个文件描述符，然后这需要一个指针。

指向一个没有符的一个结构，这里面是你要想读的那个，一共有1000个文件描述符，然后set有有就读写了两个方向的，你要把1000文明都作为参数传给这个系统调用，然后有没报错，就这么三类啊。

以及这个这个轮询时间，是立刻还是阻塞在这个这个轮询结果上就掉了，一个系统不用，那么这个select可以完成什么事情，就是内核里面提供1slide，然后select就完成这件事情。

你看这个字根本就不需要老师，完全你你看看看人的帮助就知道了，就是同意a program一个程序to monitor，监控更多的file depression，文件描述符S是个负数。

然后waiting until等待直到什么呀，直到one or more，一个或多个of the file distributor，文件描述符become reading就可以触发IO操作了。

这英文读的还行吧，还可以吧，啥意思啥意思。

画一下画图是这个世界上表示知识，表示语言，人类沟通最容易的事情，比如调select时候你穿啥了，曾经进了一个一个链接，你这边拿到了他一个文件描述符，以前是自己用写一个死循环，现在不写死循环了。

哎我统一的把这1000个文件描述传给你，然后你去做一件事情，你内核去什么呀。

这个监控这些东西，然后waiting until什么，One or more。

文件描述准备好之后给你return返回，返回之后，然后他再返回之后，你再拿着返回的那个文件描述符，水有了，然后再去调什么叫re，如果还有一个性调用，就再去调这个read，就是把RT不会掉。

那些没有数据的那个文件名，Read，是你在这步完成之后，是第一步，第二步，第三步，黑返回之后，你拿着反思结果编译一遍，哎你因为你给他传1000个，他给你给你返回1000个。

你的1000个里面的便利1000个哎，在这个里边看一眼，谁谁谁那个状态标识那个有了，然后直接调read，然后把那个文件传进去，给个传单，传的是有数据的那个文件描述符。

那么这样的话这个时期和前面那个时期一对比，你会发现多了一个什么好处，精确了，这两个时期比较，是不是内核的发展决定了一件事情，让你用空间复杂度是不是变低了，这是应该FDS严谨一点，这是一个复数，能看懂吧。

没错，批量批量交给别人去，你给我的时候，我这个主要不是多少的问题是以前1000个，我说掉你1000次，现在1000个我吊你一次，我等着你回来告诉我这里边50个，那我觉得这50个挨个挨个去读。

它还是这个同步非阻塞的，这只是减减少了这个内容太动态的切换，对不对，这个东西叫什么呀，叫做多路复用，是不是出现多路复用了，选择一些有的我直接去直接执行就可以了，那谁有了是你，我第一次叫你。

你来告诉多多少个，有了，多路复用的NL，就是为了减少UI切换，对不对，能看懂这个意思吧，没错，这些都是底层壳的碰撞的，其实这些事情这些东西谁掉的，是你代码调的吗，谁掉的，你一定要明白，我们的程序。

我们的逻辑跑在谁身上，我们的逻辑跑在JVM身上，GEM用什么写的，你的代码是java语言，GM言写的，C语言写的，没错，如果内核不加，这些系统都要用不增，不不出现这个NBLOCK这辈子实现不了这些东西。

就像LINUX能实现NIO，但是LINUX实现不了AIO，内核上还没有还没调动一件事情，只有windows才能真正实现AI好吧，但是这时候注意听，如果你的思路就停止到这个环节了，觉得OK了。

已经可以多个复用了，但是这里面你会发现一个问题，什么问题啊，我每次都给你传很多的文件描述符，你得给我回，然后我还得挑在里面谁能用，然后再去再去找，再再再再再去调，这个还是有点复杂。

如果把这个复杂度再降低，就追求更快的速度，就尽量的做一种伪AI o vi，这件事情也是增加再去减少这个这个过程，我把这个调大一点，讲REDIS把这个L全讲了一遍，然后select有了pl我就不讲了。

后面出现一炮了，我们快点说完了，赶紧说完，我想这个是不是也想听，对不对，不投诉我吧，你们要有人说不想听，我就直接讲REDIS，但是我觉得REDIS如果大部分人这块没听懂的话，讲的话，其实有点有点跳。

那时候还得发展，前面的问题你得找到问题，前面的问题是啥，你找到问题才能找到突破，问题是啥，前面的问题，你学知识一定要找到问题，你才能知道我要学啥，这里面一定要明白一个事情，就是用在内核态。

只有两个菜或者两个空间，你的进程啊有一堆有自己的一个内存空间，里面放着1000个文件描述符，这个这个所有的二零制，你调内核的时候得传参，你把它传过去，只要数据的拷贝，听过零拷贝吧。

是不是大家在传输的时候都希望有零拷贝，不考来考去，不考来考去，速度变得更快了，那么其实现在找到问题了，就是拷贝拷贝来拷贝去的数据，并不是我说的数据，并不是你IO里面到达那个数据啊。

是我对内核跟我用户进程俩人沟通，这IO里面有没有数据的事，咱俩还得传数据，跑来跑去，跑来跑去，能不能听懂这个过程，就在决策的环节的时候，文件描述符这样的数据都成为累赘了，当这个成为累赘的时候。

内核如果出现新的东西可以解决这个问题，做好呢，有什么问题出现了什么东西。

来看一个一个调用，Mm ap，map或者是卸载files or davis memory，挂一个映射，map是映射这个事情的，是不是都硬着来啊，然后这个时候他可以解决什么问题。

曾经你的内核有内核的内存地址空间，你的应用进程和应用进程地址空间，那么这时候其实都是虚拟地址空间，那么站在物理内存上面无非就是两个区域，然后这个时候内核的区域你进程是不能访问的，所以需要传参传这批数据。

所以考来考去，那么怎么规避这个问题，如果内核说得了，咱俩喝出一个空间来，你也能访问，我也能访问，然后你直接在你这个你这，而且这个空间在你这是属于你的，虚虚拟空间里边，你往8号位置写了一个东西。

其实间接写到那个位置，等于如果你来调一个信条，要用的话，就不需要传单，把这东西拷给我，你只要告诉我8号的位置，然后我翻我通过CPU翻译一下，我就知道是我这边的9号位置，我直接可以读那个数据了，换言之。

我这边如果有一个这个地址空间，我把那个10号的位置放了一个东西，一个文件描述符是可以可以读的，然后这个10号位置，其实对应的是你里边8号位置，你直接就可以通过你，那不是那个那个那个7号位置。

通过你七独断的那个数据，就不要再给你拷贝的过程减少减少拷贝，说通俗点就是一个所谓的共享空间，没错就是这个意思，但是共享空间是通过什么系统调用实现的，你一定要知道，这都是内核来实现的，这个系统调用就到了。

没错，相当于用它那个态度，有一个空间是共享的，当有这个共享之后，有了一个共享之后，那么做了一件什么事情，内核内核怎么去用这个空间，应用空间，我们程序怎么用这个空间呢，在这个空间里边，他做了这样一件事情。

三线不在线，我忘了，这是一个链表，明白什么意思吧，然后这个空间里面放了一些数据结构，数据结构里面什么东西啊，我的我的进程通过一炮一炮可以看啊。

它是一个整体，它不是一个性别，用你直接搜，系列杂项杂项里面给你解释什么EPOE，POE里面会有相应的调用，这个性标用是一炮二类的，有1create易爆的CTL，e weight和EPOCTL。

这是三个三个系统调用，你可以读一段英文就知道怎么工作了吧。

我简单给你解释一下，你的用空间只需要我我我手里有个文件文，有1000个文件描述符，OK我就写到这个共享空间里去，把这1000个，其实自己就是一定要明白自己还会有一个空间，你都有共享空间了。

还需要再准备一个空间去存1000个，完全描述符吗，先把这点弄明白了，有了共享空间，这个共享空间其实间接可以得出一个结论，共享空间就是他自己的空间，对不对，他可以直接访问，对不对。

所以曾经如果把1000多硬币放到自己的进程的，某一个自己私有地址地址里边，是不是可以换换位，换到这个位置了，这个听的同学来刷不了，这才是本质，你要明白，共享空间是进程了自己的空间的一部分。

也是内核那个虚拟机的一部分，所以这时候从这个歌词就不用，不用单单独去维护这1000个文件，描述这个地理数据，所以进程里边多了一个文件描述符，就把这个固定空间的宏宏数据放往里放，往里放，往里放。

他放的这边只要调性调用，不需要传这个数据，就没有拷贝的过程，内核是不是就可以看到这个分数，一共都是文件描述符的对，然后由红由我们那盒当中拿着刘文那边服，去通过所有的IO这个中断谁的数据到达了。

谁的缓冲区有了，然后把到达的放到列表里，放到列表之后，然后这时候如果这边有数据了，你上层用空间，是不是可以从列表中取出这个文件，直接发生读取DNA文件描述符就可以了，这跟零拷贝没有关系。

这跟零拷贝没有关系，这叫共享空间，各自的零拷贝是什么意思。

零拷贝是另外一个性质，用来来来给你看一下，零拷贝叫做SFSN，写错了，send the f sofile是完成零拷贝的，然后center file是什么意思，也多了一个系统。

要用它有一个输出的文件描述符，一个输入的文件描述符，给出片量和8号和这个的统计。

明白吧，也就是说再给你画的，举个例子，也就是内核里面多了一个坑，里边，多了一个性能用，Sf，但是说SOFILE这个系统调用的时候，SOFILE里面它需要俩参数，一个输入，一个输出。

跟你使用阿帕奇那个IOUTILS，里面会有一个out in的对象，是不是一个概念，但是你要明白，有他之前内核发展出这个系统调用之前，它还会有另外两个系统调用，一个是刚才看的瑞德可以读一个文件描述符。

有re的读就一定会对应有一个什么write写，对不对，还是应该是right，回来吧，你以前程序，如果你有一个文件，有一个文件，然后有一块网卡，网卡到内核肯定是一个socket。

socket IO文件到内核肯定是一个文件的，IO对不对，这俩是两个IO，两个IO是不是文件描述符，假设这是FD3，然后这个是FD4，然后你之前re的时候，你之前的时候肯定read读三。

从三把文件读出来，然后再去掉血写出去，然后这个时候你的这两个系统调用，发生在内核身上，内核得完成一件事，是不是得先瑞的给你，你再rise出去，这能看懂吧，也就是你的数据。

你的文件数据先到内核的800能区，然后再由这个这个这个调用，然后这个调用还考虑你用空间，用空间再再尽量再拷回来，然后再发出去，这是需要拷贝的过程，是需要拷贝的过程，那么现在有了之后，你的程序是一个过程。

是直接掉了这一个，然后由内核当中内核拿着缓冲区直接读，它放到缓冲区，然后直接发出去，就不给你的程序考来考去了，这是SFILE，它跟前面那个一样吗，跟那个MV一样吗，不一样，然后send file。

如果加上MVP可以组建一个什么东西啊，一个高效的技术，谁不卡不卡，卡卡是不是肯定会有网卡来的数据，网卡的数据来，然后写进了数据之后必须走，你卡玛卡玛是什么JM，对不对，GBM我多说一点吧，说的开心了。

他是GBM，是一个用户关键进程，网卡肯定走内核，然后走塌塌完了之后，然后它里面一定会使用map，然后Mac里面他是不是可以对files和DAVIS进行挂载，对不对，它可以挂载到你的文件，直接挂载到文件。

然后又因为这个map做的空间是是这个共享空间，内核是共享的，所以这时候其实你map，你这卡夫卡通过map看到这个内存空间，完了写了东西之后，其实内核也能看到，他直接触发内核就减少系统调用，减少数据拷贝。

也约等于是达成了一个他的到时零拷贝，但是零拷贝不是两个文件描述符之间的，是内存到，是用用用户空间到内存空间，减少了一个拷贝的过程，所以直接写文件了，然后这是为什么他进来的数据，让你打数据的时候可以很快。

而且可以存存存到文件上，然后这时候但是别的人是不是有消费者，消费者是不是还得需要去把它读出来，消费者是不会拿着拼音来读数据，学者拿着pl来读数据的时候，其实这时候走到哪了，是不是走到零拷贝了。

Simple f，确实走到零零拷贝了，零拷贝里边，他的输入来自于文件，输出，来自于他，不迷惑吧。

一切的知识来自于底底层的内核。

系列 5：P91：91、redis原理 - 马士兵学堂 - BV1E34y1w773

画一张图开始。

引出这个这个这个这个思维逻辑了，有些基本之王带领的，比如说我如果有一个物理机，如果有一个物理操作系统LINUX，其实这里面是可以有一个REDIS实力，比他用的就是63796379号。

然后呢在这个句子当中，我是不是还可以有一个6380，对不对，这上面这个知识点就是一个计算机当中，可以有多个进程，多个REDIS进程，然后这是一个上面的知识点，另外一点我告诉你REDIS是单进程单实力的。

把它放大一点，REDIS是单线程，单线程单实力的单，这床单上床按实力就这样，类似这样的一个一个名词，但是这时候这是我告诉你的，就是REDIS他自个儿它并不是一个多线程。

因为我们学JAA他给的多线程对不对，那么re它不是多线程，是单进程的，但是这个时候又根据刚才的描述，他一秒钟可以hold住很多的请求，那么并发到来的时候，并发并发一定是很多的请求，很多的请求。

那么很多球他在单单进程单线程的时候，它是如何变得很快的，如何变得很快的呢，是不是这么一个概念，对不对，那么这时候要注意了，操作系统是不是会有一个内核的概念，Ko，操作系统是有内核的概念的。

那么注意你的所有客户端的连接，如果有一个客户端，你的连接并发一个客户端，可能带来一个链接或者若干个连接，然后所有的连接是先到达哪，先到达你的内核，TCP握手，对不对，你所有的连接是心脏内核。

然后会有很多的所谓的socket，然后这时候其实REDIS进程和内核之间，使用的是EPO，这样的一种多路复用的概念，非阻塞多路复用的这么一个概念，这个E炮是内核提供了一种系统调用。

也就是说其实它是可以用一个进行一个线程，然后通过系统调用来遍历这么多链接，谁有数据我就处理谁。

且它可以满足一个现象，什么现象，他为什么要讲他REDIS为什么快。

REDIS是单进程，是不是用了它一炮了，怕吗不怕，然后所有的客户端发来的数据，因为你内存是不是快的，IO是不是慢的内存，在这等了好多年，数据中心哎，慢慢悠慢慢过了一个。

然后这时候因为有一炮放到这个map区，然后他就直接可以拿那个女服诶，蹲出来，我助理，然后这时候其实间接在它里边，完成了一个什么事情，因为使用的易爆，使用了单进程，它间接有一个这个所有的数据到达来。

是有顺序的，但是这个顺序是加引号的，这个顺序的，真正的事物顺序是由你那边的负载来做的，但是这里面顺序强调什么呀，我会一笔一笔的处理，挨个挨个的处理，因为它是单进程，它不是多进程，不是多线程。

他并不是说这里面他还爆了，太糟了，然后我一个线程处理它，一个线程处理他两个同时进行，那么这样的话有可能两个人都对某一个K，一个一个删除一个创建就撞车了，你得加锁，但是这时候因为我是单进程的。

所以你俩一个删一个，一个删除一个创建或者一个修改，你们俩一定是虽然你可能一块到达，有可能一块到达，但是进了网卡之后，一定排着队挨个来的，因为我肯定是便利的，泥头里面那个文件描述符。

那个列表我肯定是按照顺序取的。

无非就是先取到谁了，那么这时候其实是由你前端前面，再往前一格去控制，如果你想保证事物的话，对于同一个K的增删改查，你要负责让让一个线程一个链接发出来，而不能负载多个，跟你使用卡卡一样，卡夫卡。

其实我可以客户端打很多数据，打到一个topic的很多分区里，但是如果创建删除同一个同一个资源的，我要打到一个topic的一个分区里，而不能让他做其他分区的这种行。

这块跟哪个知识其实也很像，跟你NX知识也可以挂钩，index他要求怎么怎么启动index，index要满足什么呀，多少颗CPU启动多少个进程，就是worker进程，w o r k worker进程。

一个worker进程，是不是，就可以把他的数据压到CPU的123级缓存了，然后你有多少个CPU，就有多少个index进程，每个每个work进程它使用的是什么呀。

多路复用IO，之前是不是也看到ex介绍使用了LINUX1炮了吧，其实更主要的是什么呀，EPOEPO不知道不要紧，是同步非阻塞，然后鸡翅虾的一种什么多路复用，只有windows才有AIOLINUX。

系列 5：P92：92、 redis及NIO原理复习 - 马士兵学堂 - BV1E34y1w773

简单回顾一下，是把REDIS安装了一下，装完之后呢还没来得及使用。

然后呢就讲到这个IO模型这块了，因为要我我让你脑子里有一张图。

就是这个计算机当中这个REDIS怎么运行的，就说就是大力的1PO就讲到IO模型这块来了。

然后讲完之后呢，跑到后边的时候又讲到这个零拷贝。

结果一炮这块说的还不太清楚，先把那个E炮，因为现在无论你的N个等用的这个一炮的那种，IO复用的模式比较多一些，咳咳对不对。

安装资料就在咱们这个大数据的那个GITHUB就有啊，所有的安装的步骤，但是那个东西包的话，你check一下，如果是网盘链接失效的话，然后我再给你发一下好吧。

收回来，然后在这个E炮这个模型，这说这个画着这个这个图的眼睛过程。

先是BIO就是阻塞的一个美连接。

会抛出一个线程去，然后内核发生变化之后，连接这个soc上就可以是NBLOCK，就可以不用阻塞了，那么会发生用户空间程序，拿着1000个连接描述符，然后疯狂的去掉裂痕。

然后这样的话虽然他可以不用抛出很多的线程，在这多说一句，在这多说一句，就是大家都是搞JVM的，在GBM当中，一个线程的内存成本多少，一个线程为什么说前面这个模式当中。

抛一个线程对应一个连接，这个就有问题，你知道问题了，就是因为每年1000年就一个县城的县城多了，到底哪不好，有人知道一个连接的成本是多少吗，不是一个线程的成本，我们可以控制，我们可以调。

然后呢但是我们只聊啊，java内存当中堆是共享的，但是县城站是独立的，县城那个站是独立的，这个站的大小默认可以是一兆一兆B，然后呢你也可以调调，把这个这个站的这个线程，占的这个单位调小一点。

也就是代表着你的单位内存内，可以创建更多的这个线程，现在数上去了，但是你CPU数还就那么几个，其实线程多了，第一在这你要知道D就有两，有两个有两个不好的地方，第一线程多了，调度成本CPU浪费。

CPU正在忙着调度这个事，消耗在内核空间，第二个内存成本，你想如果你是32位的话，就一个4G内存，一一千个，约等于下1000个线程就消耗出一个G去了，3000个县城，你内存就光光把县城占据了。

然后你还不能new对象，因为堆米还没地儿了，一堆怎么也得给个12G嗯，所以这种抛线程的方式肯定不太好，而且一般也会限制，就是无论C的还是做java还是做C的，都会控制这个线程的数量。

那么就聊县城不好，所以才有这么一种方式，就是我最低可以一个县城，或者几个县城来做这件事情，那么这就是非阻塞，因为只要你消费不阻塞，我调你询问的时候，你不阻塞的，你就告诉我立刻立刻回话，有没有。

所以这时候我可以用一个线程厚度1000个连接，但是每一个连接都要调一次内核。

那个调性调用，所以成本又很高。

这个很高，怎么降低，就无非把这个1000个连接的1000次调用，这个数减下去。

所以才出了这个IO多路复用，也就是用我们的一个线程，就是1000个链接复用了一个线程去处理，那么县城这次只需要调用内核给的select这种方式，然后把1000个文文件名传给他，他就在那等着内核在内核态。

因为掉了他一次，他把1000个遍了一遍，然后给你返回几个，然后这个时候注意，你这个还得拿着这几个文件描述符，自己调这个阅读数据，或者写程序的这种系统调用，所以你这边还得是自己去完成数据的写出和读。

回来就是这个数据的拷贝拷贝来拷贝去，这个事情就是rewrite方法，还是用过去调的，那么这个时候其实叫做同步非阻塞，前面那个也叫去，就是你无论便利有没有数据到达和读数取出事。

都是你现实空间自己做的事情的时候，都是你都是你用空间自己做的时候，那么叫同步的，只不过是非阻塞的。

然后在这种情况下又一个问题，虽然他解决了这个疯狂迭代这个便利，这个文件描述符的数量，然后但是它有一个新的问题，就是每次我这写一个死循环，每次都要传了1000个，然后他给我编了一下。

然后返回来后我再编辑这个返回的可用的，找找到可用的，然后再去调方法，这样的话用山在传递数据的成本比较高，而且完全你自个儿去，每次要传了1000多个标书，回来变一个1000个文件描述符。

然后等于其实力度不够细，因为你在便利的时候可能有数据到达了等等，这个就因为时间上和那个用餐间的切换。

数据库的话确实程度比较高，所以才出了一套这种方式。

那么除了一炮的话，一炮是一个大的概念，它里面其实有三个调用，它select就是一个一个select调用，那么一炮有三个调用，第一个就是我用户空间当中可以create create。

那么在这就不是select，我在叫的时候，和我肯定给我返回一个EPO的完全描述符，E po，那么反问一破文描述之后，然后未来我用空间有一个连接进来了，我就把这个连接交给这个，写给这个E的那个描述符。

文件描述符，其实这边会准备一个共享空间，是MAAP，明白吧，就就就一个共享空间，一定要明白，它们两者的变化，是在这块有一个非常重要的一个东西，那么有了一个共享空间之后，它里面只需要维护一个红位数。

用中间的每连接1000个连接的话，以前是每调每每学学C4之后，1000个城给他，现在是一清，来了之后1000块钱注册进去就注册红黑树了，那么注意这个空间里边，增删改的操作是内核外完成的。

然后查询是两边都可以查，两边都有查，尤其我们要查这边这个供电分类的数据，然后当你注册一个链接写进去之后，写的同位数，然后由这个运动空间还会掉一个东西，对这个一个信标用调到一上。

这么去写了会掉一个weight，有两个调用，一个是CTRL的调用是往里加，比如app或者delete我的这个真正的socket文件描述符，然后还有一个方法就是wait，为什么吗，那么往里掉了。

这种传递这个新来的链接就往里放，传送红玉柱了，然后用空间调位置调位置，在等待等待等待事件，这个其实叫做事件驱动，就是这么来的，因为这个内核里边去完成这，你注册这个红树这个这么多文件。

描述1000个谁数据到了，到了之后就会把这个节点，然后放到列表里去，并维护这个这个数据是写可写而可读，然后呢你这个wait只要这边有了wait，就可以返回你wait从阻塞，然后就可以变成不阻塞。

然后取了个链表，把实际到达的那几个文件描述符，然后因为这个空间是共享的，直接取出来到你这边，然后你自己还得单独去调read方法，re的方法，所以它不叫AIO，千万记住了，一炮也叫做NIO。

它不叫做AIO，什么时候你用空间这个录音的方法掉它了，就是这个给了他一个八分，我不管了，然后数据什么时候到的，我也不不是你数据，到时候我才去调这个方法，我是先注册，把所有化注册到内核。

然后内核里边某一个来了数据之后，re的方法假假设是在内核当中完成这个读写了，然后最终给了你一个消息，或者给了你一个通知，你或者毁掉了你一个，就比如那边准备了一个线程池回调。

把你那个方法要到他那个线程站里面去，然后这个时候你的主线程忙你自己的两边事，根本那边的读数的事都不是不是不是你去做的，就读这句话，不是你到了之后才把它吊起的，那个时候才叫AIO。

但是000很难实现这种方式，0AO发展的历程非常复杂，有兴趣的可以去看，所以这时候一般就停到NL就不聊了，虽然它也有AO相调调用方法，但是LINUO发展发展路程是相当相当复杂。

好吧，就给补这么一点。

把这个知识补起来就可以了，好吧，OK收IO这块就不做更多的细讲了。

那么回来回到这块的时候，当你IO的模型能听懂吗。

这个时候要把学有所用，把学校的那个理论应用到实际场景，比如第一个redis release的话，就会有很多的客户端，很多稍微连接进来，可能一个客户端，比如你准备了一个一个一个套卖的，还有一个线程池。

他连过了很多或者是几台机子分布式的，很多台去连着一个REDIS，不管怎么样，最终站在这个release所机器来说，就是进了SKET，很多全打在内核，上了，内核内核的时候，你的REDIS是一个进程进程。

可以调我们所谓的e poo，然后来便利寻找这里面哪一个客户端，soc的那个信息就发过来了，然后这个时候注意他REDIS是单进程，单线程来处理用户这种，这关于他这个数据的处理的。

但是他人类自身是就一个线程一个进程吗，不是，明白了就是你要明白处理用户的对数据的操作，是它里面的一个线程来完成的，但是他可能还有别的线程在做别的事情，但是那个事情可能跟你的数据没有关系。

所以这时候一般我们就直接说REDIS是单体能，单线程来处理我们用户的请求，那么这样的一种单机能单线程处理用户请求，会有什么好处，这个顺序性，但是这个顺序我再给你强调一下，因为一旦在分布式情况下。

这个数据一致性等等就很重要，而且是一个非常头疼的事情，注意这个顺序什么顺应是连接内，或者以每每连接，美联接内的命令，这个能听懂什么意思吧，每连接每个链接里面的这个命令，是顺序到大的顺序处理的。

但是如果说比如说这个UK这个K为A，那么他也发了一个对A的操作，他也发了一个对A的操作，那么无论从你网络当中跳跃，谁先到达的，或者一报名只能先轮到谁了，那么其实这两个人对一个的操作。

就很难判定是谁先谁后，但是如果是一个人，它里边线性，而且没有使用多线程，线程，线程还是安全的，虽然它可以有多线程，但是只要线程安全，对A的操作，他这边能控制住，先创建A再删除A，只要他那边能操作的话。

那么这个顺序是可以保证的，如果他是单线程，这个客户端就是一个线程，就是一个socket，里边也是一个线程，那么这个线程肯定是先发出一个创建，创建A再发出一个删除A。

但是如果他自己这个库存里边是多线程多线程，那么这一个创建和删除的指不定谁跑到前面的，如果线程不安全的话，那么有可能先把这个删除的发出去，再把这个创建的发出去，这块能不能听懂，尤其在分布情况下。

多线的情况下，无论什么场景，这个数据一致等等，这个事物的情况一定是最头疼的好吧，所以以后开发的时候一定要关注这一点，注意这个小细节。

也就是说你在前面会有很长的路，你在做负载的时候，或者在做业务这个这个这个网关路由的时候，你要把尽量的把相同的东西打到一个节点上去，就跟卡夫卡一样，为了保证一个资源的顺序，虽然顺序可能是差差。

时间差差很久，但是尽量用在一个topic的一个分区里放，对于一个K的所有的操作，那么这时候他们到达的是相互可以保证的。

这简单说一下它的顺序，那么这里面注意他这一个线程来处理这么多，然后每每连接里面是可以有顺序的，那么这块完事之后，那么到后边到REDIS里release，再往后是什么样的，而且我把客户端拿到这个方向来。

因为画到这边就有点看不清楚了，假设一个客户端，未来我可能还有一个客户端去访问的REDIS，那么我客户端和REDIS访问的时候，数据如何传输的，以及release应该怎么去使用。

系列 5：P93：93、redis使用 - 马士兵学堂 - BV1E34y1w773

理论东西都铺起来了，开始比较实用，比使用的时候注意看。

首先我这台计算当中已经起了REDIS，PS杠F杠grape redis，这里面有6379和6380，只有两个REDIS进程已经跑起来了，那么客户端内容是什么，客户端怎么去连我们先讲命令行的客户端。

APS先不说，因为REDIS其实还是源于的，你只要会用命令行的那些指令了，那个指令在他的app当中，基本上可以找到那种API的那个对应的，对应的那个调用。

那么客户端是用redis gun client这个命令来直接启动，那么直接回车的话，它默认是连着6379，但是如果你退出的话，EE退出，你还可以REDIS杠CLI，然后杠H看帮助帮助里面它会有一些选项。

比如说你连到具体哪一个主机的哪一个端口的，像我们当前这台主机就有两个端口，63796380，所以这么一个过程，然后后面讲验证的时候可以输密码，然后下面还注意还有一个杠N。

这是选一个dB database number，然后还有一个杠杆RAW，这是要么使用的是默认的，要么使用格式化的这个新技术大纲给你讲，首先先看到一个dB在这扩展一下到图上。

那么只要是数据库，学MYSQL的时候也会建库库里面的电表，不同的部门可以建立自己的那个库，然后表是隔离的，在REDIS里面也有这么一个概念，就是REDIS里边准备了16个，默认是16个库，默认16个库。

也就是有一个0号库，然后还会有一号库，2号库一直到16，但是这个东西可以在你的配置当中去修改，配置文件，也一会来讲，这是一个概念，有0号库，一号库，你连接的时候可以通过杠来指定。

我连那个库或者到内部的进去之后，来切换那个库，但是这个零一这个是死的啊，他是不能起名字的。

就这么一个概念，好吧，我们演示一下，比如REDMCLI，然后呢先是用P，然后呢接一个6380，这给多尔号，那么进来的时候就连6380了，然后呢你还可以在里边，先在这边这边简单设置一下下一个K1。

这个是比如说K0号库的380，380里边的，然后K380，然后第一个冒号一，这是第一个K，然后value是hello回车，那么这时候GK380里边就会有一个hello，然后你还可以select。

比如选择一个8号库回车，那么差异在这出现了，你可通过内行，你也发现刚才肯定是走的0号库，默认就进了零，然后现在进了8号库了，8号库里边，然后你get k380冒号一是没有数据的。

new就是没有的意思，所以现在知道REDIS，它里边这个进程里边分为了16个独立的区域，你的K串在哪个区域里了。

那么其他区域看不到是隔离的好吧，然后退出来，也可以通过刚才连接的时候直接给定，比如去8号库，那么连点二八就是简单的操作没写明白了。

好吧好吧，那么你可以连接的了，那么在使用的时候，注意rise里面刚才简单的是使用了几个命令。

那么正确的如何去学呢，不需要老师进来之后，学任何东西都有一个help回车，那么在REDIS客户端客户端里面有这个help，客户端的help当中，你如果直接输help。

它可以告诉你这个help的使用有run几种使用方式，第一个help加一个那叫符符，后面可以跟一些组GRP，他把很多命令分组了，或者是直接接到的命令，他告诉你怎么去用。

或者help后面可以直接用table，他挨个给你提示，给你提示，现在这个前面带符的，就是后面各种组，后面再出现命令，或者你直接写一个SE它还能补全，这是他客户端比较人性的一个地方。

好当这个help这个事情会用了之后，我们来简单看一眼help，用at它分了很多组呢，第一个通用组是全局的意思，基本配置，那么回车之后，他会告诉你在这个哪些是属于这一组的，我们先简单看一眼。

这里面比如说鉴定之意比例的删除K，你给这个K它会删除，然后呢exist判断K是否存在，或者是像这种给出定义时间的啊，K的这个存活时间，这个后边讲他这个内存优化的时候，再说这件事情，还有K使用的时候。

case是可以接个这个通配符，或者是这个这个一个一个一个描述吧，可以筛选我们的Q有哪些，然后还有move移动，然后object可以查询关于我们K，关于我们K他自身的这个诶，怎么黑了自身的定义。

后面会讲这个proceed，可以将一个你定一下，过期的东西给它持久化下来等等，这是面向K的，等于这些命令，其实都是在面向K去做些什么事情好吧，还有一个tag常用的就这几个啊，我先给你标一下，你走一遍。

这是关于常用组的，比如说我在这里面可以简单的用case加一个星号，脱位符，然后这个时候可以显示我曾经见过哪些K，然后有一个命令在这说一下，large flash或flash dB这两个东西我演示一遍。

你知道吧，然后那头忘掉它，比如flash dB回车，然后在K星就没有了，那么你也知道他做一件什么事情了，他其实是在做清库的这种命令，在生产当中就尽量的不要使用这个命令，而且一般运维都会把这个命令给你。

Relime，就是你到预约到你到公司的时候，你可能会发现没有这个命令，他给自己改名了啊，咳咳好了，那么这是刚才用的是一个通用的一个组，再来看除了通用组往下，那么说了，还有五种基本的类型啊。

五种基本类型value的value，那么value型为string that on table list，然后有set，然后有so sad排序的哈，希然后向下的这种就是消息队列了，往下就不是了事物。

这是它的几种几种功能等等的，然后先不说，那么一个来看，先看我们今天先学的第一个string类型，那么切了类型之后。

他会把关于string这个Y类型里面的，所有的命呢给你展示出来。

一定要记住那句话，就是上面给你描述这个图，那么比如说在0号库或者拿一号库来说吧，你按库分好了之后，这里面有会有K，会有一个K还是key，会有个key，它因为它release是这个间接对的。

所以有key了，key还会有一个指针指向一个value，那么value里边它是具备五种类型，这个概念要找出来有五种类型，今天先学哪个，先学spring string就行了。

但是string其实你要把它想成是BT，后面给你解释就有这个string string，其实后面还可以再说它有关于字符串，字符串，字符串或者直接数组的操作，这是第一个反应。

有哪些命令还可以基于数值和位图的，Bitter m，这就是REDIS非常强大的一点。

那么现在我们看到哪了，看到K然后上面那个value，然后根据A的组可以显示这么多命令好吧，那么刚才比如我set的时候，我通过set设置了一个K，然后value是hello，然后可以通过get现在取出。

可以通过一个get箱子取出，那么这就是关于spring的一个那么修思路。

带回来看这张图，你要会看懂，脑子里面一定要明白LINUX操作系统当中，然后可以有多个REDIS实例，一个REDIS实例当中会有0~10，这个就是多个库，但是库就是从0123789开始做。

做隔离的这个东西，后面配置文件告诉你能改一个库下都是存在的，键值，对存的都是建筑队从新建设过程当中，然后K其实是个对象，除了K自身的这个名字之外，还有他的tag类型。

然后以及encoding type类型是用户访问的时候，直接看你的方法，这个这个这个类型是不是具备这个方法操作，可以快速返回，你是我这个这个这个方法，这个命令执行错了，不需要去真的去拿这个数。

真正参与计算的时候，报报异常可以规避异常，然后用Q音的话也可以规避，你后续直接透穿到拿这个字节拿出来做计算，这个事可以在前面做挡挡一次，对这个能听懂吧，然后就是他身上有这些东西，然后什么浪等等。

其实你的value长度LSS当中，K当中那个对象当中也会保存，因为只要你做增删改这个value了，做资产，同时把这个长度算完之后，后边如果1亿次定位查询的话，不需要再重复计算的长度，长度直接返回。

因为你从来在再也没有改过它，所以这是要用这个作者在这个K上的小心思，它让我们的rise虽然是单单记单线程，但是有一些操作都会预埋下来完成，对后续与高并发的查询速度极快的返回。

基本都是online oe的复杂度，这是K然后value当中他的REDISVUE类型丰富，value的类型的丰富，现在只看到了string，它的使用类型当中，我给你总结的可以面向最少三三类使用场景。

纯字符串的名词化的切割覆盖，然后还有基本的设置统一长度，还有那个数值类型的增删改查，那么数值类型的这种快速的，其实有一个场景这块没有说完，这个也是他的一个地方，下面这个位图这个场景给写出来了。

那么面向这个数值计算的场景，其实就是我们的这个抢购商品，要什么东西来着抢购，还有什么什么场景来着，那叫什么叫什么来着，这词突然忘了，那就秒杀，秒杀还有详情页，像淘宝的详情页。

详情页当中大部分静态的图表中的信息，但是他一定会这个后后端发起一个异步查询，用异步查询，查询你这个商品的这个所有的购买数额，然后等一系列的东西，所以这个数如果REDIS没有这个数值。

没有RODEGREES的话，你要到数据库的话，等于一个并行度的，多个人想去同时对一个商品加加加减的话，必然会触发数据库的事物，对不对，所以这时候其实如果有了这种REDIS，对数值类型的话。

可以规避并发下对数据库的事务操作，然后完全由REDIS内存内存代替，完全有REDIS的内存操作代替，而且这个东西叫做计算项，数据移动上上节课其实也说过这个事了，这个能看懂吧，嗯像微博当中的。

除了这个这个这个像页微博当中呢，是不是还有什么点赞，评论等等这样的一个评论数，评论数，好友数，凡是那些看似不是特别重要的数据，看似不需要必须精准的，但是银行里的钱这种事他出了多少钱，利息多少。

这个事他不适合用REDIS那个东西，必须要染指事物和必须要持久化存储，数据可靠性必须要保证，所以这时候在不同的场景下，你要做正确的技术选型，就这句话就是他就光一个string，我可以讲出这么多东西来。

right的事物是另外一回事，现在说的是一个值，在关于库里表里面的一个值的变化，使用关系数据库肯定得触发事物，在并发情况下多的情况下，但是这个值挪到REDIS里，因为它自身它就是一个进程。

一个线程所有的请求增改查，而且计算机数据移动，所以发生它的那个内存地址空间自身上面，所以这个时候他其实是比关键数据要快很多的，可以规避这个事物的那个那个发起。

但是但是如果对REDIS里面如果多条执行的话，必须先前前面成立，后边后边才能才能成立，他对多比命令会组成一个事物，那是那是另外一个事，好吧，没错，这个世界上肯定，关系数据库是你们最最能看到的。

而且是被公认的，但是这个世界不可能就只有这一种关系型模型，肯定键值对的数据库能出现，就一定都有它的意义，还是那句话，那节课有没有让你去做这件事情，dB engines嗯。

这个世界上不止不是只有关系型数据库，这一种数据模型，并不是所有的数据都必须是主外键，然后这种翻1F2换三，还有很多的模型，比如说这里边还有我们的键值对key value的模型。

然后还有宽列列式的这种模型，然后还有document storage这种模型的啊，所以还有图的，还有时序的有很多，我建议你们回去之后把这个网站这几个模型，游戏会标准的，必须要看的，什么是文档存储的。

什么是图的，什么是时序的，什么是关系的，什么是键值的，什么是劣势的，这几个必须要看，你看完这个之后，把这些都背下来，心里面有点概念了，什么搜索引擎那种的，他们各自的差异在哪，所以面试的时候聊这些东西。

都让面试官觉得你和别人掌握的东西不一样，好像具备3年工作经验，而不是只只是被简单背背背概念，背知识。

好吧。

系列 5：P94：94、 redis中value类型--字符串 - 马士兵学堂 - BV1E34y1w773

站在字符串的角度，现在开始讲这个外套，站在这个字符串的角度，如果没有字符串的时候，你想一想面向字符串都有哪些操作，面向字符串你可以有操作。

最简单的可以设置，比如set一个K啊。

注意这个K并没有类型的区分，只有value才有K。

你是要随便给一个K的名字，比如说K1，然后value里边，比如刚刚给一个hello回车，然后可以get k1，这是他最基本的一个面向字符串的一个，就是这个字符串类型可以设置，可以取出。

然后还可以什么关于set这个这个at string的时候，或者是你直接看那个set set的时候，不应该加这个这个这个这个and符，看set的时候，可以看出这个set命令后面除了可以接KJY。

还有相应的可以追的参数啊，那么前边这个是可以接一个过期时间，后边以毫秒到后面秒了，这个先不用管后还有两个，一个是NX，一个是XXNXX什么意思，就是我在设置的时候，比如设置一个K1。

然后我想给它变成刚才hello，我现在变成圈圈叉叉，然后后面接一个NX，那么回车，然后他又反映一个new，然后这时候你get k1依然是hello，那么NX什么意思，是不存在的时候才去设置这个K1。

如在里边没有出现过，那么你这个size才能把它设置上去，但一旦K1有这个K了，只是啥无所谓，你再想给他变成吞噬差是不允许的，就是不存在的时候才才让你设置，那么这个时候像什么，它的使用场景是什么场景。

比如说分布式锁的时候，分布式锁没错，那么一一堆人拿着一个REDIS来这个做一个参考，说这堆人都想都想删一个删一个文件，那这堆人谁谁去删呢，谁去操作这个文件呢，一堆人拿着很多链接。

对一个单线程的REDIS发起set k1，然后NX那么谁成功了，谁就拿到锁了，剩下的人都返回失败，因为别人抢了他前面创建了一个K了，能这个意思吧，然后xx是什么意思，比如说我set一个K2。

然后给他赋一个值，Hello，然后xx回车也是6get k2，然后发现没有值，等于上面没有设置成功，是什么意思，只有存在的时候才可以操作，也就只指它只能更新，只能更新NX只能只能新建，只能只能更新。

能理解什么意思吧，就是他们两个最基本的这么一个选项，那么除了单条的get set，还有多比的，比如说M3，然后M3之后你看他现在5。0之后很人性化，你给出命令之后，他会给你一个灰色的动态提示。

比如我可以设置一个K3，Ak4，B可以设置两个，然后这个时候你get的K3就是A，get k4就是B然后同样的有m set，就有M盖，我可以把K3K四两个K都给出，分别给你取出好吧。

这就是面向字串这个K的类型的最基本操作，然后web这个类型，如果string的时候想想还有什么操作，比如说append，我们可以拿string这个类型来看一眼，下面会第一个就是append，可以追加。

可以追加，然后big map这个未读先不用管，然后数值的操作的也不用管，然后下边还有get range，取你这个K对那个value里面的某一部分截取，然后还有干set取出来，然后放到这个取回老的值。

设置新的值，还有M盖茨讲过了，还有，还有一个东西三认证，可以把一个字串，这个覆盖到你原有这个KY的某一个位置，偏移量那个位置，好吧，我们先统一的演示一下，比如说GK1，现在里面hello。

我可以用append来对我的一个K1，追加一个这个word回车，那么get k1取出来就是一个hello world，等于把刚才word追加上去了，能理解吗，同学们，然后除了append。

还有比如说像这个字符串当中，我要取出其中word，把这个word去了，怎么取，那么最后一个get range在乱整，这时候注意看你要给出KK是谁，肯定K1，然后找到这个value value之后。

他有一个start和end这个概念，那么and什么意思，你要给出从哪取到哪结束，对不对，那么数一数最简单的123456，空格也是一个，然后第七个七的话其实就是什么呀，从K17就是六。

因为我们程序员是从零下标，从零开始的，然后我取到哪了，然后就是6789十，你发现这个过程现在看是不是把word取出来了，但是这一过程是不是好麻烦。

你是不是去数，对不对，那么在这说一下它后面一系列的相似的知识，就是正反向索引，正反向索引什么，什么叫正反向缩减，如果你有一系列的元素，如果你有一系列元素，比如像刚才hello，我就简单写了一下HE。

L那么简单写，如果你的字符串是HEL的话，然后他有一个正向索引，第一个就是零，第二个就是一，然后以此类推，它会自动的这个递增，然后就是二还有一个反向的，最后一个就是零这个一，然后前面那个就是一个二。

也就是面向元素，它有正向索引和逆向索引。

所以这个时候如果我们想取的话，给的话，如果想取出这个word的话，你后边完全可以写一个一，你只要找到它从哪边起了，我就写到最后，那么给一个一可以了，如果game是从零开始到一呢，就是取正向索引。

零开始到它一这个位置，所有的元素，这是正正负向索引，这个能理解，同学们，然后再来看K1，除了grange，然后还有一个set range，所以说也是给出K1，然后这时候注意给出一个奥赛，奥赛的话。

比如说刚才给一个从这个word变成这个马士兵，怎么怎么去给，那么offset是从六第七个位置开始，后面给出一个外角，那个Y轴多长都无所谓，超过这个长度，它整个会整个整个整个覆盖覆盖进去。

会会这个做个扩充，比如给个马士兵回车，那么再get k1，那么就会从刚才那个位置，从你偏向那个位置，然后把它覆盖进去，这是这是面向字符串最基本的操作，这个都没问题的，同学们好吧，面向字符串还有什么操作。

你在编程的时候，面向一个字符串的类型，string类型，你还有什么操作，是他们想查看它的长度，对不对，客户端也给你封封，这个也不是他的服务器也给你封好了，就是STRLTH。

后面可以接我们的K1回车会告诉你有15个，为什么有15个你盖了K10个字符，是不是一共15个字符，对不对，那么这个取出来的长度就取出来的长度了，OK当这个都听懂的时候。

当这个听的时候，注意以上那些字符串很简单，常有的操作直接放这边占地儿啊，嗯面向字符串常有的操作，回去我在这给你标出来，你自己去补笔记，自己去补，我不给你写完整的笔记，因为太low了，好吧。

这里我就简单跟你说，肯定有set，然后get，然后还会有append，然后还有会有s range，range等等的一系列的名字符串，该有的操作还要取它的长度，取得长度OK。

系列 5：P95：95、redis中value类型--数值 - 马士兵学堂 - BV1E34y1w773

D那么在这当对REDIS的基本使用有一个认知之后，那么现在高级的地方就出现了，马上出现了，那么首先进来一个命令，刚才看这个全局命令的时候，一个tab type，比如接我的K1，它会返回什么。

tab是不是看类型的意思，我刚才面前K1调过一些命令，你命令其实都归属于spring组，所以type kk1的时候，可以看这个K它的value值的类型是string类型，这是一个常识。

你用tab命令审视一个K的时候，可以是类型。

为什么，因为它有五种value类型，每一种value类型都会有相应的什么，都会有相应自己的方法，每一种方法是和类型绑定的。

如果你从客户端就是发出了一个，非死亡类型的方法，想操作这个spring k的话，不用发生实际的操作，他只需要拿你那个方法对应0K类型找不匹配。

直接给反应报错，这是最基本的一个一个优化，也就是说他这个K里边会登记，K里面会有一个属性，就在这加了，除了value上面说的一个知识，先补一个，在K里面会有一个最基本的态度。

tab描述的是value的类型，tab描述就是value的类型，那么除了有一个tab，还有什么东西。

还有什么东西来注意看，如果我用set连清一下库啊，Flash d flash，然后我用S首先看一眼help，下个命令这个set这个一定是属于类型的，对不对，所以说我set一个K1个99回车。

那么现在注意我刚才set一个什么hello之类的，这个可以hello跟set99，那么这时候注意看type k1请我回去之后，他应该是个啥来看，如果他们可以用它回来的时候是个啥，没错是个string。

因为我说了你这个命令是哪个分组的，那么未来这个K的value就是哪个类型的，所以肯定是string类型，对不对，哎那么这时候再来看我set一个K2，然后一个hello，那么这时候不用想。

因为你的命令是什么类型的，所以K2的tag类型也是类型的好了。

这两个都是之后，然后注意看他的type是绝对外面的形，那么K其实它就是一个ob de，在越南就是O价格，除了这个type也是你客户端，只要调到这个K上面，同学tape去审视它的话。

就告诉你外面类型除了他之外，简直是ob的，还有一个东西，还有一个命令是审视K里面其他元素的，比如说它里面还有一个命令可以看到coding。

那么因为CODY是什么意思，ob ject有这样一个命令，在read当中有OPGG的命令，它可以接受一些子命令，你可以通过help，Ob ject，然后ob jack e c t直接回车吧。

可以通过ob dx后面这个help看不到，我让他调一下，OKI可以接受，子命令当中就有一个encoding编码的意思，你要给个K那么什么意思，比如object，然后对我们的bn coding。

然后刚才K28楼，注意我回去之后就会显示啥，走会告诉你是一个EMB编码的一个string，不管怎么样，它看成string了，因为我刚才K2是不是就是一个hello，就是一个string，对不对。

这个应该认可吧，没有没有毛病，对不对，那么除了大家注意看刚才是1K1，如果用ob dein coding对K1，请问回来之后应该是啥，是最高的行吗，是不是自传类型来刷一下，是不是自传类型。

这应该大一个是int类型好，如果这个你能懂，因为毕竟刚才我给你演示的时候，可想你看到了我对K1C的一个99，对不对，那么这时候注意看。

一定要记住，人类当中类型当中五个类型里边有这种例子，还有什么类型吗，并没有int类型，我们这个int是个啥意思，这个int0是啥意思，它并不是太好注意，你并不是用tab去看的，这一定要注意了。

是这个对象，B站指向这个value里面，它的编码说的现在的include编码，这个编码如果是运营的话。

这个value的话，它有可能是使用，有可能是int，为什么，因为面向，因为面向release使用类型除了刚才字符串的操作，还有一些计算的操作，如果发现这个K1K1，你存的99，如果他发现int类型。

比如说impress，对我们的K1做一个增加，那么这时候跟K1就变成100了。

所以这时候立刻先排除一个概念，就是面向的话，除了自传这些操作指令，他还有一系列数值的操作。

能看到increase，Increase，怎么了呀，怎么不加一，而且你看，Include the integer value of key by one，它是固定加一的，那么除了，除了有加一。

还有一个带带，后边是可以跟我们那个K1，然后后面给出一个加几，加一个就是这个22回车，那么再盖个K1，就从刚才100变成122了，这是哪家，那么有哪家的demine DC d com对着K1会减一。

然后d create，然后Y然后这时候对着我们的K1-22，就变成99，能加能减，加个Y就可以加东西，那么除了可以加整数，还可以接后边by float，然后对着我们的K1，然后加了一个0。5。

然后get k1就会有一个小数加进来了，这就进了一个常识，没问题，同学们那个EMDSCR什么意思，就前面不用管，你只需要关注TR就可以了，为啥比如我给你再设一个size，就就这么几种提示啊，比如K3。

然后Y轴是123456789十十一十二十，三十四十五十六十七十八十九，二十二十122324252627，2829，33，1323334，35363738393 19吧，设置了39个字符。

然后这个时候在ob，然后EN头顶，然后我们的K3哎，那我再给他看一下append k3，注意看现在是不是还是SR类型的啊，刚39个，再给他追加追加几个123454 14左右的。

然后在object encoding k3roll，就这么瞎提示一个roll，一个是EMBS2，一个是int，刚才有这个int类型好吧，这是啥，这是啥，你现在肯定不懂，我要把下面讲完了才可以了。

现在收做减法，现在知道了，我们一直在讲string这个value的类型，它里面有字符串的操作，然后呢还有面向数值的操作，这里面有increment decrement。

Increment decrement by，还有一个这个关于防火的浮点型的计算，都可以在上实现，对不对啊，这个都听懂了，没问题了，那么这时候首先你要知道还有这种操作。

但是它来自于string，对不对，那么现在问大家一个问题，flash清一下，清完之后，如果看现在case里面库里什么都没有了，注意看，如果我在一个K1hello，如果用star lost来看K1。

请问长度多少，前面两个枝都铺完了，金块了，树枝都铺完了，那么现在接着往下走，一个一个过渡的知识，赛文K12楼请的长度多少，长度是多少，长度是多少啊，为什么是五呢，回车的确是五，为啥是五。

好像是按照字符的字符的个数，一个两个三个四个五个，对不对，是不是按照逻辑损的，对不对，但是这时候注意下，先往上攒，慢慢攒，跟着我往坑里走，下来一个K2，如果我设置一个九，设置一个九回车，牛射成功。

然后ob ject，然后encoding，然后K2它能设置成int类型，那么这时候如果再用string这个spring lose，然后对K2的长度进行判断，请问他是几，请问它是几。

那么这时候其实有一些常识，一些理论，就是如果我用一个字节可以表示零到多少，25或者正负的话，是0~127或负127到正127，对不对，然后呢在不同语言里边，比如java语言里边还分为具体的类型。

比如说double和int不同的宽度，那么在REDIS里边，在REDIS里边如果它能识别出int的话，那么这个int代表的是java，给他开辟四个字节来存到一个数值呢，还是就开辟了一个字节呢。

是不是相关的很多知识带出来，对不对，你要先把这个知识铺垫一下，这都是常识，为什么，先来看结果是一，明白这是一对不对，那么这时候注意看，如果注意看，如果append对着K2，刚才那个九，我append。

比如对九，这个再再end一个九，后来我占了三个九，三个九回车之后，然后我get k二一定变成了四个九，对不对，四个九，然后再看OP g，然后ANQ兵，然后对我们的K2注意看是弱弱的行为，对不对。

是不是先分类型英语，除非是end之后，他哎哎这四个角应该能为什么还漏了呢，这是他的方法的问题，但是不要紧，如果increase对着我们的K2是不是这样加一，能不能加一，能不能加一，能还是不能回答。

可能的也能加一，你发这也能加一，对不对，也能加一，那么这时候加个一之后再看，应该是int了，特别是int，也就是说一些方法，一些方法会让这个类型变了，一些方法会提前固定的这个编码。

这个in in int对不对，那么这些都能看懂，比较基本比较基本，但是这个时候要问大家一个问题了，如果在their loss，然后看我们的K2，现在蒙是对的，因为我一步把你往这个坑里带。

那么齿轮的长度是多少，都1万了，一半的时候应该是几个长度多少来，变成了五，为啥变成了五，为啥是标示标，都为啥都改，不算完还不算完还不算完还不算完。

再来看，给你演示这么半天就是为了带出来什么呀，注意他的二进制安全的一个事，然后还有数值计算。

那么还有一个命令可能没有演示的，这是作者非常细腻的地方，help string类型，它里边还有一个比较长一个get set，Get set，有这么一个小命令，这个get set什么意思。

就是get string value of the key and return is old value，不是set，设置你这个K的新址，并把老老值给你返回，很简单，比如我塞了一个K。

把刚才K1设置成hello，那么get k1的时候肯定是哈喽，然后这时候还有一个证明，set get get set get set get set里面我可以对着K1，然后给他一个马士兵。

然后注意看回车的时候，如果你扣扣弄掉的话，他会把哈罗给你取回来，老的值给你取回来，写新的值，这是马士兵了，更新了，那么这个命令有啥意思没有，你要感觉REDIS在各种场景下，为你的这个系统的一个考虑。

其实这个命令可以完全不需要开发出来，不是原则性，不需要开发出来，也就是用户直接可以先get k1，然后呢在SK1，那么用户等于既取到老的值，又更新了新的值，但是这时候你要考虑什么问题，就是成本问题。

什么叫成本问题，你发送一个get，再发送一个set，等于在通信的时候发了两个包，两次的IO的请求，但是这个时候其实这两个命令如果合成一的话，等于在通信上你就发了这么一个命令，过去就发了这么一个命令。

过去能理解什么意思吧，同学们就带了一个value的过程，会减少一次IO通通信，这就是做的比较细腻的一个地方，然后除了这些你说的原则性了，然后看help当中还有一个关于多比操作的。

波比操作的一个more set，在more set设置很多K的时候，K y k y k value，还有一个more set是more snx和ex，比如说像NXNNX是什么意思。

Only if none of the key exist，就只有k line的时候是不是才能才能设置，但是这个前面注意多了一个M，就可以设置多个k value key value key value。

那么注意来看走一个过程，比如我先把它清库，把我们的库清掉之后，现在case都没有了，那么这时候如果m set nx，然后你可以设置一个K1AK2，B两个K那么走，然后m get把你的K1K20来。

这个值都能更新上去了，对不对对吧，但是这时候注意看，如果你要这么做，M set nx，然后对着K2给它变成CK3，变成D做这样一个操作，那么注意听注意看回车，然后m get k1K二K三回车。

那么你会K1AK2还是存在，B没有变成CK3，也没有设置上去，那么这个时候这个东西才叫做原子性操作，能能能能盖过这个点吧，也就是你在同时设置多笔直的，这个时候加这个M多比的，加个N顿。

在的时候他其实想多多多比的时候，它一定是一个原子的，有一个失败了，有一个失败了，其实这里边谁失败了，K3肯定能充电，只不过K2已经已经存在了，他失败代表着所有人都失败了，好吧。

K3根本没上去啊，根本没上去啊，好了，那么这时候他们向我们的string，这个类型里面的组织数值的基本操作好吧。

系列 5：P96：96、redis--二进制安全 - 马士兵学堂 - BV1E34y1w773

下载一个K3，如果A然后这个时候你get k3就是一个A，然后lost，然后看K3也是一个字节，对不对，这都没问题，如果append我对着K3注意看追加一个什么，我不能增加一个中国的中字，回车。

然后你get，K3不应该先盖子漏出来了，赶紧刷一下，K3，请问它的长度是多少，我刚才K3是不是一个A后面不是中国的中字，对不对，那么现在的长度是四，不是二，好像都已经懵掉了。

演示这么半天，为啥我给你带一个概念，叫做二进制安全，好用，红色看不出来，有一个概念叫做二进制安全，就是在raid当中自有的一个特征，什么叫做二进制安全，这些low的听上去很高级，但是这些low也就是说。

在rise进程与外界交互的时候，他与外界交互的时候，可能给他东西的时候，永远给他的字节数组等于其实按压，你想，我们一般面向流有字节流和字符流，那么REDIS如果别人通过solid访问他的时候。

大家从socket里面拿到的什么流呢，他只拿出了字节流，并没有拿字符流，他并没有拿自助球，为什么，因为如果REDIS它只存字节，没有同字节取出东西，按照某一编码集转换的话，也就换言之。

只要你未来的双方客户端有统一的编解码，数据就不会被破坏，这句话听懂听懂吗，所以叫做二进制安全重要是安全这个字，如果REDIS它自身除了value那种大的类型type之外。

他还有一个真正要动这个音coding，比如你给了我一个999，我就存成什么什么东西，然后你别人取的时候可能一出还不同不同语言，因为他知客户端语言很多嘛，那么不同语言的时候。

其实对整形的宽度理解是不一样的，就有可能发生阶段一出这样的一个错误，我有什么意思，同学们就像在多语言开发的时候，我们更倾向于使用JASON，使用XML这种文本表示数据的方式来交互，而不使用序列化。

序列化之后，这个时候大家就必须要自己增加一个什么，编码器和解码器，对不对，如果编码器解码器不一样，你那边认为int是四个，我这边认为int就俩，你那边写的时候成功了，我用一个比较大的一个四四字节。

能表示一个特别大的数写进去了，然后release也是四字节，但是这客户端认为这一类型不应该俩字节吗，求出来之后一出了不够了，说完显不对了，所以这时候其实REDIS作为一个非常核心的一个，中间一个中间者。

他其实有个二进制安全，它只只只取字节流，所以再来看刚才所有的和你想的不一样的地方。

第一再清一下拉是，哦听到之后，第一个数值这块set一个K19999999，这是五个九，但是SPIRLK1是五，现在就明白了吧，他并没有，虽然他知道o b I/O b i encoding。

它是int类型，但是他并不会把它按某一种数据类型给你存，比如按四个字节或两个字节，它就是一个字符，一个字节，一个字符，因为REDIS拿的是字节流，你这个它形容那个客户端，它的编码也是一个字符，一个字节。

然后直接向字节流去写，首先说先听一步来先听，这能听懂吧，是不是能听懂这块能够有，因为保证2D的安全，但是它里面的确会有increase decre，这样的一个计算，这个计算的过程。

其实他是要把这一个字节的内存里面拿出来，先转换成数值的。

转成数值之后，然后他会更新，我们K上那个这个encoding编码是int。

那为什么要加这么一个，因为加了它之后会方便，如果我调一次encoding，然后呢把他可能开始绕，可能是字符串，但是我把我把它识别出来之后，把它转成数字，没有报没有报错，没有报异常，没有报异常。

你给的参数也是一个数值，我加成功了，只要我计算成功，我就给encoding更新成int，代表着这个K状态往后都是int类型的，下次如果加计算的话，是不是就可以直接拿出来往上加，如果发现不是int类型。

那么它其实可以尝试来规避这个报错的问题，明白什么意思吧，就是为了一个加速，就是要更新这个这个这个这个这个所谓编码，这个过程，但是它的编码现在我强调的是，你要看这个长度，它的编码并没有影响数据的存储。

这是第一个知识点，还有一个迷惑，刚才那个中的中字为什么四个字节，对不对，是不是为什么四个字节这数据来看，SK二一个中国，我直接写一个中国的中子，我直接写一个中字中字回车。

那么这个时候我get我现在看长度，Length，看K2形的长度是啥，是三个，为什么是三个，那么注意看我这有关系的是看工具，然后看看在哪看看属性吧，我当前的这个插销连我的REDIS还有一个编码，编码在哪。

我在这也就是我这个x shell，这个软件和我的ready通信是UTF杠八的，然后呢，你看我刚才在一个地方下，我试了一个中度中字，长度是三，然后我给他切成JBK编码集，切成JBK回车。

这个时候我再set一个K3，然后再写一个中国的中字回车也OK了，那么这时候relax，然后来看我们的K3，请问长度多少，长度是二，因为中国的中字在UT当中是占三个字节，在JP当中。

JPGBK就偏向于我们中国自己的语言，所以它其他语言不会顾不会顾虑，所以压缩空间，然后用两个字也可以表示变成二，这能看懂吧，也就是说其实他真的走的是字节流，当这个看懂之后，然后把客户端退出。

注意客户端连接的时候，他默认啊不能退出啊，再来看一眼case星，那么这里面有K2K3，那么这时候注意看get k2，get k2的时候走，说三个字节，一个16~8，然后GK3是不是K30K是两个字节。

一个三个字节，一个两个字节，这这个这个是16进制的，它的值，它那里面的代表的值就是UT8当中，中国的中字，他这个值代表的是GJBK编码集中，中国的中字，它的编码这两个听懂之后，然后再退出。

然后这时候用怎么进redis client，然后杠杠roll这个ROS触发一个格式化回车，进来之后注意看，如果你get了K3是中的中子，get k2是这个字，为什么别忘了。

我现在现在连接的编码机是不是已经JDK了，如果你只需要知道，如果不带着它，也就是无力，只会识别什么呀，只只会识别阿斯玛了，超出阿斯玛他就直接按照16进制给你显示，但是如果你加了这个选项。

它就会触发编码集的格式化，也就是他发现了这三个16进制，且符合U这个你当前那个编码集的编码规则，就从编码集当中给你找到那个字符，就不给你显示三个或两个了，现在这个K2因为预定了八的UT和马当中。

这三个东西在这当中就是他就属于乱码了，其实最核心就是一句话，REDIS是2D的安全的，学大数据的同学应该更懂谁，还是2D的安全的，HBASE是不是也是二进制安全的，是不是我们在向HBASE写数据的时候。

也是要先给它做序列化，变成一个字节数组，HBASE根本不会去破坏你的编码的，这个时候再看看长度长度这个事，它就是长度K3，就这俩K2就是三长度是不会发生变化的，底层就是即便我在这个这种模式下。

即便在这个模式下，比如我set一个K4，一个中国的中子走，然后star lose一个K4，依然是俩字节，在JDK的情况下，也就是说给你上层客户端外围你啥编码，REDIS不知道raise不知道。

你只要想使用raise给他的，就一定是你这个客户端先变成字节数组，可以一开始就设置这个int类型，不是自己设置的，是在你设置的时候，你设置了一个K5，一个五，然后这时候object然后encoding。

而且这个时候虽然我告诉你，有这个编码这个事了，但是忽略了他会做一些预判断，它是一个int类型，那么这个时候如果他已经判断int类型的话，你未来调increase，然后K5的时候。

他就直接可以触发这个计算，而不需要做一个排错的过程，就不需要判断他能不能转成，只能直接发生计算就可以了，就提速，可以把一个判断转转转内行，这过程给他忽略掉。

没错，其实说白了就是它底层存的时候，就是按照字节去存的，上面只是说在K上面要做一些优化，K上面如果没有in coin的话，你每次计算的时候，他都要先走一次，判断这东西能不能转成，如果发现诶。

你上次的计算是围绕着这个spring的字节，数组的类型当中，作为一个数据数值计算体积就成功了，我就在include给你标标准例子之后，你下次计算的时候直接直接对着二进制，然后做累加就可以了。

就反正他就会加速一点，相当的就是适当的会加速这个加速这个过程，如果他说识别出是这个M4S2的话。

如果你加的话，他就根本就不需要去转码。

直接给你报错，这个类型不符，它不能完成计算，是大啊，这个点一定要get到啊，这个其实就是作者比较细腻的一个地方了，作者剩下的时候完全可以不用带它，但是带它的话就会稍微好一点啊。

它可以让他的一些方法这个速度更快一些啊，OK现在什么是二进制安全，听明白了吧，就是未来代表一个什么问题，代表一个什么问题，所有使用REDIS，你在很多人使用REDIS时候。

大家一定要在用户端这个叫什么呀，沟通好我们的数据的编码和解码，REDIS里面是没有数据类型的，他虽然是为了客户端，但其实也给客户端稍微带来了一个问题所在，公司当中大家一定要预约。

系列 5：P97：97、redis中value类型问题解决 - 马士兵学堂 - BV1E34y1w773

你可以试吗，比如说MSK2K，3DIMGK2K三，那么谁是谁触发原则的呀，什么叫原子，你如果就一比的话，谈不上原子，因为它单线程的肯定是原子，那么一定是在多M的情况下，然后且出现NX的时候。

那么这个时候肯定是原子的大大脸猫理解了吧，你回想关关雎鸠，你回想你在写NIO的java，java是不是他的这个模型使用的是EPOD本，你在修的时候是不是也是需要他那个selector。

你虽然看他那个DK里面的selector，但是其他底层如果发现内核里面有select就用select，没有SLG，如果有一炮使用一炮，没有一炮就看有没有select。

所以其实JDK对着操作系统做了一层屏蔽，他给用户暴露的是一个selector，是不是道理，但是它底层根据内核优先使用IP，所以那时候你会发现注册完之后，是不是自个儿，你每次还得循环要这个数据，对不对。

等于他底层循环是循环这个位置，其实说白了还是你用户自个儿那边有一个县城，得去循环为，或者给你返回了，你就拿出这个，拿出所有的K，每个K都拿出通道，然后开始读写，处理完之后，然后再去wait，他就调一下。

调一下再调一次，这个selector，区别区别怎么会没有区别。

他俩区别多大啊，他俩区别多大了，一个select1炮，这俩区别，你select你用中间调select吧，这不是java select，就是内核里边就是操作用CLINUXC的时候，如果叫SLG。

你要给他1000个文件描述符，但是这个时候如果是一炮的话，你只需要调一次wait等着就可以了，之前的时候有一个就放一个，有一个放一个，有一放通过CTRL，有一个放进一个，有一个放进一个来。

然后后边你只需要轮询调wait，等一个事件就可以了，有几个吧为他左侧一取消，然后开始开始读那几个处理，处理那几个IO，前面那个是我每次循环的时候，都得都得压进1000个文件描符，告诉你你啊你我阻塞。

然后你告诉我这个1000里面有有能读的了，有几个我还得把这1000个就过一遍，找出那些K来找这些文件，不如哪个哪个可以读了，然后不再便利他们吊坠的方法，这边是我来一个压一个，来一个等于1000。

如果select循环了十次，循环了十次select的话，1000要压十次，1000个文明能压十次，那么在一炮的时候有1000个的话，如果我就是每个每个socket只压一个状态的话。

比如都压读物都压血的话，那么其实每个只会压一次C条，只会一次，1000个就压一压1000个就可以了，不需要再有，即便循环十次，这位置循环十次，也不需要压那么多，肯定有诅咒的，可以调，你可以调成非阻塞的。

但是这个时候这个点不重要，重要的重要的是哪一块的变化，就是前面成本比较高，压1000押1000，押1000就压一次之后，就为了等列表上有了，我就取出来那几个文件描述符，挨个DOREAD，或者用多个线程。

每个线程发一个，然后这几个线程同时对不同的那个那个，那个那个文件文去读，对不对，然后你这个线程又可以再去注册这个这个列表，这种叫做同步的模式，什么叫异步，什么叫AIO，什么叫AIO。

其实你可以在这个模式下自个包装一下，也就是说我把这个底层还是这种同步的上层，我可以基于事件驱动，那其实不叫不叫ALO就是伪伪LO，就是感觉我这个用户写代码的时候，我把一个re的方法里边。

要传这个某一个文件描述符，就是某一个socket一个对象，然后再接上一个回调的那个对那个对象的方法，因为面向接口嘛，然后我发出去之后扔给一个线程，那个线程底层其实还是要走这个wait。

只不过你不需要自己端着那个线程去处理了，那个线程只要拿到之后，然后毁掉你这个方法，但是这时候其实你跟自个儿脱了裤子放屁一样，所以NT就根本没有使用这个所谓的伪AIO。

他直接用的是直接用这个NLOO这种方式，因为真正基于事件驱动的AIO，在LINUX系统当中是很难实现的，光最早先的时候IBM想实现AIO，然后后来oracle想实现AIO，结果这俩人玩到最后都退出了。

而且最至关重要的，你要明白LINUX的生态和windows生态不一样，windows是自个一家说了算琳琳的生态，然后他是有一个人占主要地位，就是林纳斯琳科隆内核的地道者，这个缔造者其实他是有代码洁癖。

洁癖这么一个问题，就林纳斯的代码那个有有代码洁癖，他就要求如果想在LINU内核当中开辟的话，这个AIO除了是异步之外，它有all in all l，意思就是所有就统一所有的IO，无论你烧黑种的会堵塞的。

还是那种所谓的磁盘文件的IO，所有IO都必须使用统一的接口，写这个接口一定是内核系统调用机的，且必须是速度最快的，要超过这种，但是这个所有的条件压出来之后，这个代码一上来的话。

他就一直在否定所有人给出的这个框架，结果那其实net也测试了，目前GMC当中实现的IO的速度，跟NLO的速度，就是这种方式的速度基本差不多，因为现在的实现的模式，DFC的代码当中也底层调的，其实还是一。

因为它不像windows内存空间访问那么随意，因为LINUX它更倾向于服务器级别，它是要求安全的，快啊这个哲思问了一个问题，就是说这么多客户端往外发东西的时候，那么你这边只有一个线程。

那么是不是就会处理处理一个的时候，别人都排队等着，的确是一定要注意，刚才说为什么强调个顺序，但是排队进来的，但是这时候你就明白了，之前给你讲那个那个那个最近的常识的时候，内存寻址是纳秒。

你这个socket其实对于那个网卡，它的寻址是毫秒，也就是说差了将近小10万倍，你除非有10万个连接，我有10万个链接，大家疯狂的同一时刻到达，那么这时候可能会造成秒级的响应，没错的确15万。

你看他俩的倍数可以看出来了，这都是小学算法吧，是不是小学算法，因为它的寻址之间那种级别吗，而且是记得像是移动就在内存里边，也没有磁带，我话说我就单一个建成，然后呢，我这个E炮这种方式。

还是基于这种内内核和内技能之间共享内存的，等于哪个文件描述，有了之后，我直接就从调一个raid，把你的这个链接里面拿出来之后，然后8K加一，然后加一之后，我手里知道你下一个下一个文件描述是谁。

因为共享内存嘛，我就直接入了另外一个文件描述符，又把你那个命令拿出来，你可能是减一就减一，所以那时候其实你看所有的通信的距离，跳这个折板都是很少的，所以这时候近似于可以达到十个，而且15万1秒钟。

15万收入的单机都没有走网卡，我对这个这个还得强调一点，就是它是单机压测的，就是这个计算机当中不需要走网卡，计算机有一个客户端，然后呢有一个REDIS他俩走的内核都直接回来，这么请求完全纯内存的话。

15万是没问题的，但是如果走了网卡的话，就会降到10万以下，67万78万，我头发这个问题的确的确点到这个点上了，很好奇内存是啥结构的，不是善道吗，硬盘是扇区，是磁道，内存就是一个线性地址空间。

内存就是一个线性的一个地址空间，其实你就想这么一个事情，如果我给你100个格子，格子长得一一模一样，从格子标号从0~100，然后但是我会给你不同重量的大米，黄豆红米，然后不同东西，然后你怎么往里去放呢。

重量不一样代表体积不一样，所以那时候他们需要的格子是不一样的，对不对，然后这时候还不能把他们混在一起放，那么一定会有浪费，对不对，所以这时候其实在内存相比，这种小格子上面又多了一个叫这个内存页。

然后呢如果100格的从0_{10这里边放大米，而且大米的权重比较高，大米是可以去访问别的那些格子的，那么这个大米就是内核，剩下那个从一从这个11}100，这一个小盒子里面放红豆，放小米也放，放黑豆。

他们就用无线的程序，这些动物还不如混起来，所以各自有各自的物理空间，这个这个这个这个这个范围，但是这个时候其实每个程序都是靠什么训地址，讯地址，通过C的MV管理做映射，单线程是不是规避了线程切换的时候。

用户太像内核态切换的过程，所以选择单进程，单线程不是不完全是不完全是用户，这个多个用户进程切换的确是有性能的损耗，但是这个损耗站在数据一致性面前，这个损耗算不了啥，是不是换开了就跟你写java程序一样。

你到底是写一个线程，然后用NIO都能复用，让每个人的操作都是原子的，还是说我要在融入多线程，融入所，让多尔多多多多多服用进来，是不是有道理，所以这时候你就看把两个东西摆在一起的时候。

就是做歌手的一个过程，举手的一个过程，这就跟讲集群一样，集群里面为什么都是主从集群，主从集群的主，就是单单单个他说191说话就这样，他不需要和别人协商，所以主要是主入口，它的性能必须高。

所以一般这个它就是一个这样速度才能最快，那多线程只不过是并行了磁盘IO时间，如果没有网络或磁盘IO完全没必要多线程，这个脑洞有点大，我这个脑子转不过来，你再问啥，我再读一遍。

那多线程只不过是并行了磁盘IO的时间，如果没有网络或磁盘IO完全没必要多线程，那么在这注意一点啊，是REDIS，就是在面向网络很多IO的时候都复用的时候，REDIS用单线单线程单进程就可以处理，对不对。

然后你再想另外一个存储数据的就是MYSQL，MYSQL是不是处理也是存数据的，但是MYSQL的数据不是放在内存，它是放在磁盘，对不对，那么MYSQL就它更倾向于使用的是那种BO。

MYSQL更倾向于使用BLO就是一个链接一个线程，一个链接一个线程，他反而不倾向于使用IP，它需要更多的线程，一个链接来一个线程，为什么，因为你你去想，如果MYSQL它让连接进来了很多。

进了个10万百万条连接的话，但是这时候其实这么多连接，可以很快到达很多的请求，这个请求如果每个请求都要触发磁盘IO的话，在磁盘IO带宽上就会阻塞住，所以说你好似让很多人进来了，但大家要等很久。

所以其实你前面用e poo反而没有意义，还不如直接用bl更省事一点，索引会有预加载，然后索引的叶子是在你的磁盘当中的主干，可以预见到内存的，而且MYSQL也可以开启缓存。

就是比如你发了一个SQL select from a这张表，这个SQL你发过一次，他查完了数据，如果你开启了缓存，这个数据缓存内存里边主要它不大，然后就把这个SQL哈希亚放在内存里。

如果你下一条SQL长得一模一样，他其实MYSQL是先预判断你这个SQL，我是不是刚刚查过，查过的话，直接从缓存给你返回，后边什么SQL的语法书啊等等就不做了，就省了一大块的东西。

但是好像听上去开局缓存可以逼近REDIS的性能，但是毕竟你MYSQL肯定是数据大过内存的，内存可能就四个G，MYSQL数据库可以一个T两个T，所以这个时候其实开机缓存，如果表行比较多的时候。

它会降低MYSQL的性能，反而不它没加速，反而降低了性能了，因为多多一次判断的一个过程和缓存，这个这个内存内存空间被占用的过程，还不如直接把缓存关掉，所以说了，这个要的是你这个SQL。

他会做一个整个搜索字符串的，你前后两次SL都串外条件都是都是难，前面一个难，后面一个难，你这俩肯定还一直一样，那么这个上一次好像都可以用，你这个如果事后万一每次执行结果不一样呢，这个什么意思。

那你就说这个数据被改过了，所以这还这还有一个问题，所以这个它会断不判断，所以这个你开启了MYSQL的缓存，虽然想模拟REDIS充分利用内存，但是反而不好，的确是这个意思，你像之前你讲。

这个时候NDEX是不是，就是他你有多少个物理核心，开启多个进程，对不对，是不是道理，而且除了开启相应的技能数，还有一个亲密度，差一个亲密度，比如我这台电系统有四颗核心，我起了一个REDIS。

我会把这个rise亲密到第三颗核心上，然后把所有其他的事情，其他的那些进程，可以让他们在别的那个核心上去跑，那么等于因为你CPU是有时间片的，等于更多的时间片，这个3号四号核心就一直在处理REDIS。

尽量减少他去处理别的进程，那么这样的话，它缓存123级缓存也不会听来听去，所以这时候release才能达到最快的那个所谓的秒级，10万或8万这样的一个速度，就是你让这个进程一直内核调度的时候。

一直跑在哪个核心上。

系列 5：P98：98、 redis中value类型--bitmap - 马士兵学堂 - BV1E34y1w773

下面开始讲这个未除B的map，呃，我上节课为什么花了一点点时间把你往坑里带，然后为什么你带带出这个二进制安全，最终为什么让你明白他就是一个字节流，而非一个字符流。

然后最终为什么让你明白它底层存的就是字节，其实知道字节这种存储形式之后，位图这个事就好学了，好吧，比如说自己要什么意思。

你看我先清一下库，什么叫做位图，都没有了，那么第一个命令CD，注意这个SB的命令它也归属于string，value类型为字符串里面会有这么一个命令，然后这个命令会给出一个会给出一个offset。

然后给出一个value，当然这时候注意了，他已经带出这个BITV的操作了，那么这就意听outside是二进制位，而非数字节，数组是二进制位的偏移量。

那么通俗来说画一个画一个东西来说，首先一个字节有多少个二进制位啊，12345678，这是一个字节，对不对，一个字有八个胃，然后再有一个字节的话，是不是也会有八嘎那味，对不对。

那么这个字节刚才说在release里面的时候才说，他这个索引的时候，它是面向面向的字符，也就是面向字节它会有索引，也就是说第一个字节的索引offset是零，对不对，第二个是不是一了，这个理解吧。

大家注意听注意PO面向二进制位也有索引，它的二进制位也有索引，如果你在使用未命令的时候，使用未命令的时候，他的二进制位也是有索引的，它的索引是从左向右，0123456789十十一，那么这个就很难画了。

就是前七个是肯定是起这里面对应他那个位置，然后八九十十一二十三十四出是对应他的，就是二进制位，虽然字节是割裂的分开的，但是对于react里面二进制位，它就想成一长串，所以按这位从左向右。

一直从零一直到他那个位置最大最大。

这个模型先先先到的柳树，那么像这里面set bat时候给出一个K。

你给出这个offset，注意这个offset说的哪个offset，说的是二零之外的offset。

而非字节道赛，举个例子，这个位置我对K1，然后注意all set是一，然后value那么二进制的value无非就两种，要么是零，要么是一，对不对，哎我给一个一，那么回车想大脑里有几个问题。

第一K1的长度是多少，第二它的二进制表示什么东西，有两个问题，先告诉我的长度多少，没错就是一个字节，那么这时候你要明白这个一是什么意思。

这个一是他这个第一个字，第二个字节的一个作用吗，不是他说的什么呀，是这个一，也就是说其实它的内存当中是把从左向右，第二个因为从零下标开始把它变成一了，刚才在B上是发生了这么一件事情。

能理解吧，那么它是个啥东西呢，这个艾福在阿斯玛当中01000的一个字节，正好是艾福好吧，然后注意再看到这个门门的感觉，如果set date，Co k k1，请问长度是多少，请问它是个啥东西，长度是多少。

没错还是一个字节，V1是因为七代表的是第八个二进制位，从零开始的，在02478还没超过一个字节呢，所以他不需要开辟新的字节，他最小的开闭空间是一个字节，对不对，它它它不需要开辟第二个，刚开辟一个就够了。

所以它的长度就还是一个字节，但是它它的数值是什么呀，你要看你对阿斯玛熟不熟了，是大写的A就是那按照这表示表示。

注意是01234567，是不是第八个是把它变成了一，注意01000001。

现在K1的只有一个字节，这一说字节的二进制位就是01000001，那么它的阿斯玛值就是大写的A，你可以怎么去验证mu阿斯玛，你就去找大写的A大连一多少啊，这里面是，这是16进制，对不对。

然后这两个数字代表的是前面四位，这个数字代表后四位。

后四位是不是一样，16进制是不是这么表示的，因为1248满的话，就是16该进一了，对不对，就0~15，然后16就到这了，所以这个后面四个正好是这个一，前面这个四是什么意思，124这个位唯一就是代表四。

41就代表的是大写的A没毛病。

同学们，然后这个会了，注意再看，如果做这样一个操作，set beat对着我的K1，然后对他一个九，如果设成一了回车，那么请问这个长度多少，没错长度二九已经超过了，因为他第一个字节的下标是0。35789。

已经超过了第一个字节的这个八的宽度，所以长度为二，那么请告诉我，根据刚才的知识get了K1的值的时候，它是什么，GK1的值是什么，没错是AI，就是这么简单。

它的命令行客户端是可以不全都显示，这个16进制。

如果那个时定制，刚好那一个字节能能转成阿斯玛的，给你按阿斯玛给你给你显示能看懂意思吧，因为现在这个K1在内存里面。

第一个字节就是01000001，因为我刚刚对九九其实就是八七，下标为0123789，把这个位置改成一了，他就是at，现在看懂了吗，追风，因为开始的时候你注意我这个这个这个命令，这个顺序。

我这个位置是这么顺序的，Set beat，然后对K1开始是为一的时候给了一个一，对不对，注意K1可能就是我一个K，然后第一个offset偏移量偏移量为一的时候，就是零一在这等一个一这个命令执行完之后。

我是不是set b对我的K1的，然后为七七的话，你就是下下标为七，就是第八个，对不对，就是012301234567，就是第八个在这摆了一个一，就变成他了，然后下面又执行了一个set beat。

然后对K1对九打了一个一，那么这时候一定要知道二进制，这个offset是从整个所有二进制里边，从左向右写的，就是012347899的话，是不是第二个第二个第二个位置打一了。

那么这时候你的需要天量没有超过两个字节，其实最终就两个字节，这两个字节就是你的K整个value的内容。

所以这时候你在get k1的时候得到了AI，因为它是以一个字节来显示的，刚才这个追风这个这个这个过程听明白了吧，OK好吧，这是面向我们的二进制位，可以做这个设置了，这个能听懂，比较简单。

为啥是ask ask了，不是UTF8啊，首先你退出去啊，注意看。

这是我给你补上吧，有这么一个基本常识，这个我都讲过，这个字符集，字符集标准的是sci阿斯玛字符集，其他的一般叫做什么呀，扩展，扩展字符集，关键是这个扩展这个意思，什么叫做扩展啊，什么叫做扩展啊。

其他字符集不再对ASCII重编码，服用服用的时候注意阿斯玛有个规律，就是零必须的，然后1234567，也就阿斯玛里边第一个第一个字节，第一个必是零，后面可以从全0~1个全新的变化，代表不同的东西。

所以这时候当这个常识，这叫常识，有了之后，任何的程序你自己写的程序，你自己写一个程序，字节流读取，然后你肯定是每字节，美字节判断，你要每字节判断，如果你读到的第一个字节就是零开口，那么你脑子根本不用想。

你都不考虑你自己是JPK还是108，直接拿着这一个字节，只要他是第一个是零开头，直接去阿克曼那把这个字符就显示出来了，但是一旦发现不是零开头，是一开头，比如一个一个一个八当中有三个一一个零的话。

那么你除了这个字节，还在读出两个字节，因为三个一代表我用三个字节来表示，把那个东西之后，然后再把他的前导码踢掉之后，拿剩余的二进制位拼成一个数值，去你的那个你这个客户端，那个现在那个字符集当中。

把那个东西取出来，那个字符显示出来，这中有中字，字符集这块能听懂的同学来刷波一。

好吧，所以这时候你会发现很多客户端，你比如DX当中也是哎，这个英文字符怎么能显示我别的东西，怎么还是那种16进制都乱码似的，就是因为什么软件字符集里面，大家都认识阿斯玛，但是他未必去认识其他的嘛。

而且他一般也不会给你做强转。

因为人家放的时候，因为你release2里的安全，我这边需要客户端是那个U6杠八了，但是人家放的是不是按U放的，我不知道，所以我就一定是什么呀。

就是按实时定给你显示了，但是如果你课文当中给出什么呀，REDISCLI告诉他，你尽量的拿着我打开的这个就是把它一加，然后我客观现代一执行的时候是啥编码集，那么就尝试着拿那些16进制的，那个不是零开始的。

拿着我这个这个字符集去找那个字符去显示，但是就有可能会出现乱码，因为人家对方可能拿拿UT网吧，到这里是二进制安全的，还是那个U妈的编码，到时候到这边拿JDK1翻译就错了，就乱码了，好吧说的有点多。

回来收好，我们再讲我们的两位除了一件事情，现在往里设置，往里设置这个事情可以可以可以会了，然后再来看还有什么相关其他的随便组当中，面向B的操作，这个操作还有什么bit co。

然后big field这个往后讲啊，这个这个3。2出来之后，这个东西比较复杂，今天讲的更晕了，先看简单的be co b beat operation，然后beat pose，还有下面有sat beat。

看别了，就这么多，一般来说你都往里设置了，现在还有一个是beat，pose这个命令big post命令是做什么事情呢，是find first beat，寻找第一个按键位置。

然后在你的这个字符中在哪个位置，它的语法格式用这个命令后面接你单位一个K，然后呢给出你要寻找的二进制位，这是我们无非就两种状态，要么零，要么一，然后你要给出一个区间，但在这注意了。

这给的是start end，它并不是说outside。

那么这个3end说的谁说的是你这个字节的索引。

我们来演示一下，如果用beat pose，我要查20_{120制，这个一二进制，这个一在0}0，star0N零，那么请问他会出现吗，Bipose，你要注意这些干什么，干什么事情呢，我要找的是二进制为一。

在这个零到这个零。

这俩零是什么意思，其实这俩零说的是第零个，就是第一个字节，那么找一的话。

它出现在哪了，是不是出现在一这个位置了，走回车。

零我没有给出K。

没有给出K是哪个K是我的K1，对不对，你要先给出一个K回车，是不是在这个这个唯一的位置，在这个一的位置，然后注意看，如果把这个零换成一的话，换成一的话，应该反反反什么1~1。

那么这两个1STR都指向一的话。

其实说白了就是第二个字节，对不对，是不是第二个字节。

那么请问如果查一的话，它的偏移量，它返回的偏移量偏量是多少，是多少。

要小心回答了是多少。

是多少，没错是九。

他给你返回的是那个一在二对，26中位置的位置，这么翻译就对了，而不是在这个字节里，它出现在第几个二位的时候。

它是全亮的，它是全亮的，那么这个时候如果改成0~1呢，它返回多少，他是找到第一个的first。

如果beat pose，我要在K1这样的一个二这两个字节这么多。

二进制状态当中，我要找一个二进制第一次出现的位置。

且是在零和一这两个字节数当中去找，那么回回这就是一，就是这个下标一，他找的是第一个出现的位置。

这应该能听懂，这个还比较简单好吧，好了，那么除了BP这个beat pose，还有一个是bit co beaccount，BEACCOUNT后面要接个K然后给出end。

注意end说的是什么，是你的字节的起始和结束。

然后count是什么意思，count他只是抗抗的一只抗抗的一出现几次了，那么这时候如果对着K1，我从0~1这个范围，这个字节单位的范围区间内，统计一出现了几次审问后。

回解是不是出了一次两次三次。

对不对，那么这时候回的就是一个三，他可以做二进制为一的统计，你给出这个字节的区间，如果给的是0_{0的话，就第一个字节里面两个一，如果1}1的话，这个时候出现出现过一次，这个一二是这个一，那么接着往下讲。

好那么接着看，除了这些，还有一个是叫做beat option operation，为了操作，那么这个语法的命令是我可以注意注意，这DISS就是目标K，目标K后面可以接一个K或者更多的K。

这个目标K是结果是结果不打印了，是要放到这里面来，那么你参与的K会触发什么，触发一个关于二进制，为了逻辑操作与或非异，或是and or travel或者not学过计算机二进制的。

这应该都知道是不是面向二进制会有与或非，对不对，抑或按按位的按位操作的，那么举个例子，比如说要注意听啊，我先准备两个，我先把这个库清一下flash，然后清完了，然后我塞了一个K1，然后把他的一标成一。

然后，然后再set dk1的七标成一时候K1大写的A，对不对，然后这时候再注意看，如果我想得通过二进制位的操作，得到一个大写的B我应该怎么设置，我通过给K2，我最终想把K2里面重新代理的B。

但是通过四个B这种方式怎么去设置，是不是set beat，然后对K2的第二个，这个V是不是标一个一就可以了，就零幺啥啥的不对，当我给你讲哪哪用它，然后再set beat对着K2是什么呀。

AB是不是顺着来的，零一是A10是不是B了，一一是不是C对不对，所以这时候我对他的六这个位置打一，这能看懂吧，所以这时候get了C2是不是带个B，因为后面要用到它做逻辑与逻辑与或的时候，用它好了。

现在我KK二一个分别是A1个分别B，我给你写出来了。

因为咱们的确有的人可能对，这个这个值是不是大写的A，对不对，然后换一个值，后面改成1020，这个零一是110是不是二，所以对应的是B了。

对不对，现在这就是K1，这就是K2，我要做一件什么事情，Be operation operation，然后目标k and t，先写的是operation and做and安慰语。

然后目标K是and key，参与的是K1和K2，明白啥意思吧，然后这时候回车，那么目标把k car的安慰语的操作，是不是存到目标K里去了，所谓目标K的话，那么这时候我get and key它的值是什么。

请告诉我值是啥，按位与的操作的时候，直接回答我，知识上，这全答错吗，按位与操作，什么叫按位与啊，什么语操作，有一则一，不是这个有有零则零。

全一为一，对不对，你琢磨琢磨，这俩如果按位与的话，得出这是个啥呀。

是不是01000000，所以它的值是at明白了吗，现在这个时候的安慰啊，B的BOORIN了吧，如果改一下，如果bit operation，然后给的是一个按位或操作，然后是all key。

然后也是K1K2，那么这个时候我get ok。

那么它里面存的是啥，这是不是C了，安慰或操作的时候，是不是有一则一了，全因为赢得不对，那就是01011。

明白了吧，好了，OK这就是按位操作。

有这么几种方式，那么有人说了，老师你在讲啥，你在讲啥，这点这个支点很重要，在国内当中最值钱的就是BM，这是位图，举一个经典的例子，首先我先告诉你的命令，你回去自己整理，这里面是不会有这个CD。

然后还有beat count，回忆一下，还有beat pose，然后bit operation有这么几种方式，对不对。

系列 5：P99：99、 redis中value类型--bitmap例一 - 马士兵学堂 - BV1E34y1w773

这个位置因为上面都很容易理解数值运算，字符串的操作就是位图，你们很多人可能第一次听说，所以给大家这个这这单独给你做一个笔记，就把场景写出来，两个场景，第一个听需求，第一个听需求，如果你的公司有用户系统。

公司有用户，那就用户点呗，是不是很多用户对不对，然后这时候这个需求是什么需求，帮统计未来这个需求是统计用户的登录天数，且窗口随机什么意思，比如说在电商的公司当中，电商的网站一般都是说你老板心血来潮好说。

马上这个今天是8128828，马上就9月了，那么9月1号往前推一周，9月1号往后推一推一周，这14天所有用户的登录的天数帮我统计一下，然后没过两天，该双11双11的前后帮我总结一下。

然后哪天他老婆生日了，我老婆生日前后前后几天给我统计一下，就是你的老板会随机的让你统计，指不定哪天到哪天结束这个范围之内，能听懂我什么意思，同学们，在这个需求下，你是怎么维护这P术语。

支持用户登录的时候登记，且可以把这用户一年的数据随机窗口去查询，比如就查A的用户，A这个用户在某一个时间窗口内都有几次，那么怎么去处理，不处理的解放是不是很多，你尝试着多想一想，多说一说。

用你之前的这个思想和过往的经验，你是不是可以拿一个数据库MYSQL，然后呢创建一张用户登录表，用户每一笔登录，是不是可以在里面产生一行记录，然后登记他的时间，哪天登录的，对不对。

然后用户的所有东西是不是可以往里灌，但是这时候你想一想这样的存储的时候，是不是就要从存用户的id，因为MYSQL是关系型数据库，它里边关表表之间必然有一个主外键，对不对，关联对不对。

所以D这个D可能就是几个字，几个字节了，最少得三四个字节，存一个id吧，能听出来表达什么的，咱们现在算这个成本复杂度，对不对，这张表最少每行是不是得存一个日期，再存一个它哪天登的吗，日期日期的话。

你最少也得准备一个四个字节，ID你得准备一个四个字节，这是八个字节，表示一个用户的一笔登录要消耗八个字节，这是第一反应，那么你京东有多少人，每个人一年基本上得有200多天登录。

这张表的数据是不是其大查询的时候，用户老板给出一个随机端口，是不是要所有的数据成本高，怎么优化，怎么优化大数据处理，不需要REDIS足矣。

来看各有思路走啊，各有思路走，你只需要算一个成本，这里面有一个固定的一个数值，有两个固定的数值，第一个固定的数值，就是一年有365天或者366天，对不对，我大方一点，一年400天。

如果每一天对应一个二进制位，就是从左向右，第一个二进制位代表第一天，第二个二进制位代表第二天，也就是四个四个二进制位，400÷8是50个字节，用50个字节可以最大记录一个用户，全年365天的登录状态。

比如比如说这么做，Set date，肖恩我就说，那么我这个人就是key，然后给我的1+1个一是什么意思，回车这是什么意思，我第二天登录一次，因为你一定明白20位偏向是零，对不对，所以是我第二天登录了。

然后我过两天之后，如果我的用户再产生登录，你就看哪天了，第八天就下班为七打一个一，我第365天登录的时候要做什么，364打一个一，对不对，打一个一，我第一年是不是就是第二天，第八天，第365天登录了。

只有三笔登录，顶天46个字节，顶天是最浪费的，如果天天登录的话，是不是也是四个字，也是四十四十六个字节，你就算你你的电商当中有多少个用户，无所谓了，就用户每个用户是不是一比一录，哎。

这个数据能登了，那么最终问题是不是老板会给出随机窗口。

随机窗口什么意思，这个用户最后最后的这几天有没有登录啊，一个字节是不是八天的，是不是八个人是八天的，那么看这用户最后两周有没有登录，你只需要取什么就可以了，beat count肖恩。

然后给出sand360，不是一共是天，是这么多，要除以八，对不对，就是负二和一是不是最后两个字节，两个字就是最后16天，对不对，是不是登录过一次，是不是按照字节的逆向索引，这是统一用户的登录，对不对。

这是第一个场景，再来这个思路走，能看懂吧。

我把这个笔记给做一下。

什么意思。

这就是所谓位图。

然后你学过你就去思考一些事情，比如劣势存储或者什么大量的数据。

然后想理解就是有的有的有的行有数据没数据。

是不是你可以挂一个索引来标识这个用户的，某些行业，有数据好像没数据。

然后是不是可以外挂一个位图了，你看这位的一个状态，一个缩影，按这位的缩影对不对，其实内存消耗很小，好吧，这是第一个需求展现出来的，这个矩阵是什么矩阵，上面这个矩阵和矩阵分别长什么样的。

上面矩阵是比如说肖恩，然后这里面如果二进制的话，这是key value的话，比如说0101010101，这是在不同的天出现，对不对对不对，然后比如说有消音了，然后库里边还有这个JS。

然后0101011111，这是他的不同的登录这种场景，然后上边对应的是日期上面，比如说这个0102，然后零三第三天，然后零四，把这个最好向右，我就不画全了好吧，其实你整个公司无论你怎么去设计。

就这么点数据，要么就是用户id为key，天为位，要么就是什么，这个时候其实整个内存消耗你可以算算上边，如果如果上边每一个用户，每个用户是多大的，每用户46字节，每用户40，刚才看是不是46字节。

然后乘以什么用户数乘以无数，那么46个字节乘以乘以乘以乘以千万个，十百千万，10万百万千万就拿1000万为单位，说1000万的话，就是46乘以它最终等于四十六四十六，然后后边加上个十百千万，10万百万。

是不是这样一个，然后就是1K然后兆十兆百兆就知道不是，这是1K然后怎么算1K10K8K照，然后40兆是应该四五十兆的，这是三个三位是1K对不对，三位是1K然后这是1K了。

这是1K10K百K然后兆十兆百兆，400多兆，400多到400多道可以放下，你精通所有人，就是1000万人的全年的登录的明细，然后如果你觉得大的话，是不是可以把这个用户拿出来。

十这个一半的用户放到一个REDIS，另外一个REIS的另外一台存，另外一半一半的用户，是不是可以单独去统计他们了，是不是可以分开了，问问我爸下面的字表来算算，基本上，但是这东西一定会小于什么呀。

第一小于MYSQL，第二速度快过MYSQL，都是二人之位的计算。

系列 6：P1：什么是垃圾？ - 马士兵学堂 - BV1RY4y1Q7DL

嗯首先我们先来聊什么叫gc啊，gc，好g c这个是这个事先理解啊，g c的全称叫什么呢，它叫做garbage collector，或者叫garbage collecting，看你用在什么语境上。

简单说就是垃圾收集或者垃圾收集器，是这么个意思，嗯既然是垃圾收集，垃圾收集收集器，那么到底什么是垃圾，到底什么是垃圾啊，呃我原来讲的一般都从c和c加加开始讲，但是好多同学呢是没有这方面经验的。

所以呢我就不专门的来给大家讲，这个c和c加加内容了。

好吧，就直接我们来聊java里面到底什么是垃圾。

什么垃圾呢，看这里就是当我们溜出来一个对象的时候，没有任何引用指向它了，好这个就是垃圾，ok先说我们两天讲什么内容啊，我简单说一下，有一些基础的内容补给大家，就是what is garbage。

到底什么是垃圾，或者find it到底怎么去定位它，垃圾回收哪些算法，jc的egorithms，以及呢，目前在jvm里面存在的这些个垃圾回收器，一共有十种，最后呢我们来聊在线上的生产环境底下的调用，呃。

大家注意啊，这个调优呢如果你是在测试环境下，那你可用的东西特别多，但是生产环境里头可用的东西真心不多，在生产环境里的调优好看，这里我们一点点讲，首先来聊呢到底什么是垃圾，什么是垃圾呢。

由于这个内容呢我在预习的课程里头啊，其实也讲给大家听了，所以呢我在这呢快速过一遍好吧，好比如说我们new了一个对象出来，这个对象有一个成员变量，这个就是它的成员变量，这个成员变量指向了我们。

新旧程的另外一个对象，那么这时候的问题就来了，假如在运行的过程中，那不好，在这里不是，这个引用啊没有了没有了怎么办，好这块内容就是垃圾，垃圾的意思就是我我再也用不到的那个内存嗯。

你跟你的小伙伴在房间里头玩小线团，一个小线团连着一个小线团，一个小线团连了个小线团，什么时候呢，断了，中间有个小线团啊，这就是垃圾了，ok这是垃圾的最基本的概念，一个对象没有任何引用指向，它就是垃圾。

那现在问题就来了，这个垃圾啊是要进行回收的，不然的话当你程序不断的产生，不断的运行，垃圾越来越多的时候，你的内存就会被占光了，在c和c加加的领域，是我们手动回收，你自己手工去管啊，这块不用了。

你自己要标记一下啊，这块我用不着了，这块用不着了，你自己要标记一下，但是这块是c和c加加，写程序的时候非常容易出错的内容啊，为了让程序员们写的程序更容易，更加容易写得好，更加容易健壮。

让它的开发效率变高，所以诞生了java呀，python啊，go啊这类的语言好，这类语言有什么特点呢，就是不用你自己去回收垃圾，谁来帮你回收垃圾回收器，简单说，如果是c和c加加语言。

你在房间里扔小线团的话，你的小线头不用了，你自己得拿起来把它扔垃圾桶去拿走，但是如果是java go，python，julia啊，rust这样的一些语言的话，这东西不需要你用到。

不需要你用用用用用到用到呃，不需要你自己去清理，谁来清理呢，会有专门的人啊，你的妈妈，你的爸爸，专门的这种垃圾回收器来帮你清理这件事，当然现在呢我们就来聊一聊啊，呃如果你站在一个垃圾回收器的角度。

你已经知道什么样的东西是一个垃圾了，那么我们怎么才能找着这个垃圾，找到这个垃圾的话，一般的情况下有两种方式，第一种呢叫reference count，叫引用计数，这个特别简单，就是咱们不是说了吗。

没有没有任何引用指向的对象，那就是垃圾，那很简单，如果有一个对象，像这个对象，它有三个引用指向它，那么我就在这里给他记个数，上面写了个三，由某一个已经消失了，它就变成二，由某个引擎再消失。

它就变成一由某个引擎再消失，ok它就变成零，当它变成零的时候，它就变成垃圾了，这叫做引用计数，引用计数呢也是有好多的语言在用的，比如python python目前用的就是引用计数呃，js啊。

好多js的引擎用的也是引用计数，并不是说它没有用作为运营技术来说，解决不了一些问题，什么你呢，就是它不能够解决这种循环引用的问题，比如说这哥仨a指向b，b指向c好，指完了之后没有其他任何引用。

指向这哥仨中的任何一个好，这个时候这哥仨全是垃圾，叫做一坨垃圾，一堆垃圾嗯，这三个全是垃圾，那这时候如果有奇数的话，你会发现啊，这里是一，这里也是一，这里是一，因为有有印有指向它。

所以你是定位不出这样的循环引用的，这样的一些垃圾来的，所以这是引用计数的，它的不足之处，所以在jvm里面，或者我们讲我们说的那么直白一点，叫在hospital里面，在oracle的对于jvm的实现里面。

他用的不是这种方式，他用的一种方式叫做research根可达算法，根可达算法的意思就是，当我们跑起来一个程序的时候，我们一运行这个程序的main方法，在这个main方法里面开始分配内存的时候。

比如在这个内存在这个ma方是这么写的，t小t等于啊new t好了，从现在开始开始分配内存，也许在windot的过程之中，它里面又维护着一个队列，在这个队列里面又维护了一系列的对象，好了。

整个程序我们开始跑，所以最后就会形成一种对象图，对象图，这是我们根对象，这是我们的根对象，根儿指的是什么，最开始运行的时候需要用到的对象，好，这个写个叫做根对象，所以跟对象来说。

顺着这个根儿一直找能够找到的对象，那都是有用的，凡是找不着的都是没用的，顺着根儿找找找找找，找到这个了，顺着根儿找找找，找到这个了，找到这个了，找到这个了，但是顺着任何一个根下来都找不到这根俩。

哪怕这哥俩他们引用计数不为零好，这哥俩也是垃圾，这种呢就叫做根可达算法，它解决了那个reference count，解决不了的这种循环引用的问题，当然作为大厂来说呢，他们的面试题呢有的时候会特别变态。

他会问你，他说呃哥们儿，你这个所谓的根卡拉算法，那哪些对象是根呢，好听我说嗯，由于大多数人呢他是没有这个jvm基础的，所以我建议你们学东西的时候呢，先不要使劲玩命的抠细节，等，建立起来知识体系之后。

建立知识体系，去把这个整个的脉络先建立起来，你的知识脉络啊，知识点全建立起来之后，再去抠里面的一些小小的细节，这样的学习方法才是正确的，不识庐山真面目，只缘你在庐山里头研究某一棵小松树。

这个肯定是不行的，你应该是架起飞机在庐山上，整个上面飞过，你就知道了庐山整个的梗概好了，如果说有人问你这样的一些细节，这时候怎么办呢，听我说先把梗概掌握住，所以呢今天呢我不太想跟你解释。

这么这么这么细的一些东西，那如果你想知道的话，我推荐大家一本书，这本书呢叫jvm虚拟机规范，当然这书的话你自己要看，嘿有点那啥。

其实我建议大家呢，你你你听老师讲就行了，因为这规范呢还是挺挺挺繁琐，挺详细的，它是用来查的，并不是用来那个呃让你从头到尾阅读的，我把它打开一下，呃现在应该要出，应该是出那个14版本了，那么这个呢是一个。

第13版本呃，这说那叫java virgmachine specification，呃，你读那个老，这是java虚拟机的标准，java虚拟的规范，它就像是一本说明书，一本国家标准读起来是很枯燥的。

但是你想弄清楚一些精确概念的时候，这本书还真是少不了的好。

那什么叫跟对象呢，在这本书里面是这么写的，这个对象包括jvm stack，native method，stack，run time constant prove。

以及steady reference in method area和class，这几个都要分对象了，那么大家听我说，先不要去细究这些细节，因为你要弄清楚什么叫stack。

这个stack什么叫native method stack，什么叫run time cos to，什么叫做steady reference in method area，什么叫做看来这个东西的话。

需要你补的东西太多，因此呢大家伙暂时先放一边，总而言之，最开始运行的时候需要用到的那些对象，那些对象都叫跟对象啊，通过这些对象找找找找找能找到的对象，ok这些都是有用的，剩下的全是没用的，你你女朋友。

你男朋友啊都在这里一个房间里玩好，这个他们手里头签的第一个线团，这些个都是跟对象，我这么讲，大家是不是能理解，来我们可以继续往下聊的，李老师扣个一，还有抽奖吗，他你让自己变得更强一些，但比抽奖不香吗。

就是好，我们稍微回顾一下啊，我刚才讲了什么内容呢，就是呃到底什么是什么，是垃圾，没有任何引用指向对象啊，这个叫垃圾，那怎么定位一个垃圾呢，两种方式，第一种呢叫reference count，他有毛病。

他解决不了循环引用问题，第二个呢叫根可达算法，好，这个是可以的，这是目前hosport用到的方法，当找到这些垃圾之后，那么常见的垃圾清除的算法有哪些呢，常见垃圾清除算法有这么几个，三个从60年代开始。

就这三个，上世纪60年代，1960年，我忘了是196几年了，到现在为止就这仨，就这根仨后面所有涉及到的垃圾回收器，其实都是这哥仨的来回的组合，灵活运用而已。

这哥仨呢分别叫做mark sweep copy以及mark compact，背过就行了，第一个呢叫标记清除，第二个叫拷贝，第三个叫标记压缩，这哥仨是什么意思，看这图就相当简单。

mark swift的意思就是我们找到一些垃圾之后，比如说这些黑的全是垃圾，我们就直接给他标记一下啊，你这身垃圾可可可以用了，可以清除了，我们把它清掉，换成绿色，你看啊，这原来是黑的，直接换成绿色。

ok了，可以了，这个就叫max sp，也是最简单最容易理解的方式，这块是垃圾，我就把它清掉，这块是垃圾，我就把清掉，这块是垃圾，我就把它清掉，ok这个就叫mark sweep，好，这个方式叫做简单直接。

但是有他的问题，这个问题呢叫碎片，这个这里面呢如果说这块也清掉了对吧，这里面就会产生各种各样的碎片啊，比如这个我用了这个我也用了，结果你就会发现在我整个内存里头，如果我要用一个三个格。

连续起来分配的对象的时候，我发现就找不着了，为什么都是碎片化了，所以这个会产生碎片的话，这是mark sweep固有的缺点嗯，那么第二种不会产生碎片化，第二种是什么，第二种叫copy。

copy的算法也特别简单，无论你有多大，内存一分为二，你要用的时候只能用一半，当我们要回收的时候，怎么回收啊，这些不是垃圾吗，这些黑的全是垃圾，我找到那些不是垃圾的好，这个不是垃圾。

不是我考到像拷贝到下面来，把第二个哎本考到下面来，把第三个诶分考到考下面来，这样你会发现当我们回收完之后，所有有用的连在一起，所有的空余空间连在一起，所以这个时候他是没有碎片的，而且这个算法也超级简单。

拷贝一下就可以了，但是问题我相信小伙伴们拿大腿想想，也应该能想明白问题出在哪，很简单嘛，空间浪费对上面的时候啥啥时候删除呢，拷贝完了呀，把上面的这些所有的该拷贝的东西，拷贝到下面以后。

上面那块空间挂机整个全清掉，是录播吗，是录播啊，晓风残月啊，拜拜好看，这里啊，mark compact，mk compact，第三种呢叫标记压缩，标记压缩不会产生碎片，标记压缩也不会浪费空间。

但是标记压缩需要挪对象，啥意思呢，你看啊，呃回收之前呢，这些东西全是垃圾，当我们回收的时候怎么回收啊，其实就是把这个地儿给它剃掉，这不是有用的吗，哎复制到这里来，下一个有用的哎复制到这里来。

复制到这里来，把那些最终呢就是有用的连在一起，标记清除完了之后呢，再进行一次压缩，把所有用到的压缩到一起来，把所有没用着的连在一起，而这时候就不会产生啊，随便画，当然，大腿想一想也应该知道。

这个的问题就在于效率偏低，为什么效率偏低啊，哎你一边呢还有挪对象，一边进行压缩，一边进行清理，所以它的效率偏低，因此这三种算法呀就是叫做各有特点，另外呢各有毛病，各有问题好。

第一种回顾一下叫max sweep，给它标出来，直接清掉，会产生碎片，第二种叫拷贝算法，很简单，也很快，也不会产生碎片，但是空间浪费，第三种叫mark contact，把它那个标记好了之后。

再进行一个压缩，把那个有用的压缩到一堆去啊，你本来在屋里头扔线团，小屋里头扔线团，扔扔扔扔，扔的满地都是，得把你给清理一下，全挪到全挪到一起来，整排排列整齐，当然它的效率偏低好了。

这三种方式能get到的，老师扣一可以继续的给老师扣，一来也叫标记整理。

系列 6：P10：mca3.0更新升级！全新内容，全新教学模式 - 马士兵学堂 - BV1RY4y1Q7DL

听我说，你听完这一遍是对整个java课程体系的梳理，你可以梳理一下你什么地方还有欠缺的，听明白了吧，梳理完你就知道你以后的学习方向，奔哪个方向去，整个mc后端的架构师。

我大概是用分大厂级别的方式来给大家设计的，整个课程体系大概会分成四个大的方向，第一个是关于技术的，第二是关于项目的，第三个是关于面试的，第四个是关于进阶的，我们先来聊关于技术的，关于技术这块儿。

我首先给大家聊的是p6 级别的技术，这个技术呢是集中在操作和落地上，这是大多数人目前努努力就可以到达的水平，阿里的p6 大概是30万~70万年薪，你可以对应一下你现在的薪水呃，为了由于这是一个进阶的课。

当然如果你今天愿意找老师来报名，我送你一个入门的课，好吧，今晚送送十个，就是你现在觉得水平还比较差，没关系，在进阶课之前，我们还有一门专门入门课，我送给你从零基础开始的，所以呢在进阶课里面。

首先会给大家来聊前置知识，常用的工具，jdk的特性，mysql的基础，s s m的核心，spring boot的应用，java ee的项目，在这个基础之上开始正式进入p6 的内容。

p6 内容大概分成底层基础，这块比较重要，主要是操作系统，计算机组成原理，在马老师这堂课里面组成了一门课，java成员应该掌握的底层知识，io和网络计算机网络，linux系统，算法与数据结构。

这是我们的底层基础，正常的一个二本左右的计算机系要学的内容，在这个之后非常重要的并发编程的内容，今天我讲的很多内容是jz于这门课，然后是rpc的通信框架原理，为什么要讲这个分布式必用。

接下来是消息中间件的应用和原理，这个比较重要，消息中间件目前用的最多的，原来讲叫四大消息中间件，active rabbit，rocket，卡夫卡，但是active已经基本没人用了。

rabbit用的越来越少，现在用的最多的有两个，一个叫rocket，一个叫卡夫卡，大概都讲到源码级别，那么后起之秀有可能流行起来的新型叫power，所以这是我们的消息中间件，然后叫做缓存中间件。

这里面最流行的叫redis，这是面试的重中之重，重灾区中的重灾区，redis搞定架构师成了一半，作为一个java架构师，有两大工具你是必不可少，一个叫redis，另外一个叫什么呀，叫engines。

这两个弄完你架构师就成了一半了，听懂了吧，所以架构师没那么难，但是呢这两门课都不太都不太容易，他们的源码都是c写的啊，我们抠会抠到它的源码，但是你你你得你得做好这样的心理准备啊。

嗯因为我们面向的阿里的p6 ，35万~70万年薪也不是很容易能达到，接下来呢是软件设计的基础，这里面主要讲u m l设计模式啊，软件工程的发展史，中小系统的开发，软件工程常用的文档的案例。

这些呢主要是你项目组工作的时候，遇见这些东西不要觉得生疏，然后是分布式的架构实践，这里面的内容就会相对多一些，现在最流行的是分布式，主要是包括高频和高可用，通信和调用rpc thrift。

ninety double缓存的中间件，就是我们的redis存储的中间件，这就比较多了，大概有这么多个啊，fedf s h d f s h base mongotdb。

neil for the influence db，ocean base click house啊，皮皮诺德peanut呃，这些红色的呢是小众一些，但是有流行的可能性，这是存储中间件，那么关于分布式锁。

各种各样的分布式锁的实现是etc d的锁，db的锁，还是手写的，还是场景方案和选择，分布式事物，到底是two pic，three pc tcc saga，还是柔性事物，分布式的链路追踪。

这个呢最主要是skywalking，这用的是比较多的啊，zip in用的稍微少一些，分布式的预警监控，这里头最多的用的最多的，最流行的叫普罗米修斯给大家讲这个课的呢，就是咱们字节亲自落地。

普罗字节定制版，普罗米修斯的老师很牛逼很牛逼，一个课就把你分布式预警监控，就给你搞到位了啊，分布式的权限控制，这个主要涉及到jw t o r s二点，spring security和shero呃。

新手的老师也是原来京东他们内部怎么落地，怎么实现的，都是这么讲，分布式的id密等分布式的任务，分布式的绘画，这个大概是分布式的专题，那么在分布式专题的基础之上呢，我们要聊服务，微服务架构，微服务。

你了解了分布式在聊微服务就方便多了，那么这时候呢就是配置中心注册与发现，网关与路由，当然内容也会比较多，因为这里面主要涉及到两个大小，一个是spring cloud奈飞。

一个是spring cloud阿里巴巴，那么阿里巴巴呢，是在奈飞的基础之上发展起来的，这两个呢有可能会混着用，目前呢我们主要通过两个项目来给大家讲清楚，什么是奈飞，什么是阿里巴巴。

分别是网约车的第三版和第四版，讲完分布式，讲完微服务，下面要进行系统的性能优化，主要分成四个大的层面，jvm调优，今天呢我也大概给大家讲清楚了啊，它是什么，长什么样，但这里面内容也会比较多。

因为它有十种，到目前为止是有十种垃圾回收器，不同的垃圾回收器用不同的调节方式，mysql性能优化，tom cat性能优化，nginx的性能优化，高并发大流量的服务调优的实战好吧，这是系统的性能优化。

想多要钱，我所有标红的东西，那么这是面试的重灾区，也是展现你水平的时候，好除了这个之外，我们讲数据的处理，主要讲海量数据的存储，搜索和处理，处理呢主要有批处理和实时处理，现在最多的实际上叫湖仓一体。

这只能慢慢学吧，你先从最基本的批处理开始好，湖仓一体批流一体啊，二合一的处理，那么在这个基础之上呢，我们讲基本的运维知识呃，你作为一个架构师，要懂一点基本的运维，比如说多机房的问题。

比如说自动摘除的发现，比如说d n s相关的，比如c d n相关的，这些东西呢都是跟你的优化有关系，就是你搞高并发大数据量，在很大程度上是离不了这部分知识的，在这个的基础之上。

我们再来聊deos dv o p s，我这是没什么可说的，这是这是现代的，只要你跟跟跟紧我们的开发的流行趋势的话呢，应该都会有，我们作为一个小公司，我们研发部目前为止，大概有30位左右的研发人员。

他们呢为大家研发了大概是我们的网站。

我们的app啊，我网站大家看到了，也包括我们的直播，我们的录播系统都是他们来研发的，然后研发了呢我们的笔记软件。

就是这个风叶云笔记，大家也可以拿来用啊，欢迎大家用，这个挺好用的，你们用用就知道了，比如我给你举个例子啊，我我我我现在的枫叶云笔记，我给大家分享的，这不是我给大家分享的这个内容吗。

就是我一键就可以给大家分享出去，你就可以拿来用了。

然后我里面呢还可以，比方说我想给大家做讲解的话，我还可以插图，我可以插入一个画图，这个是很多笔记软件都没有的好吧，网易云差不多，网易云差得多了，我们在那个专业支持it上比网易云做的要好。

因为他需要漏的一些东西稍微有点慢，所以大家稍等一下就就可以了，就是我可以在做md笔记的时候，直接插入我们的画图，有点有点太慢了啊，演示一下吧，就是你那个自己可以进行相关的画图啊，反正这方面还得优化。

它确实前端这块挺耗资源的啊，loading嗯正在漏的嗯，这是咱们的那个画图呃，你比如说啊我给你举个例子，就是你如果想做笔记的时候这样来做呃，我截了一段代码是吧，然后我把这个代码贴这好，把代码贴这之后呢。

你就可以用随便拿一个画笔取个颜色，红色，我就可以在这做标记啊，这段代码是长这样，为什么这段代码长这样，为什么，ok然后呢，你可以把这个东西直接插入到我们的md里面。

就是插入到我们的那个那个markdown里面，这个有bug也正常啊，如果说没有bug，这么大一个软件也也不太正常，大家多用免费好吧，当然我们现在所有老师都会有啊，你大家知道吗。

我们现在整个研发部devops k，实际当中我们在实践的，我们现在整个研发部我跟你说，阿里云就是基于云的开发，基于divers的开发，运维一体化，非常好用，比腾讯笔记好用吗，我只能说在代码这方面。

我们还没有找到比我们更好用的，听懂了吧，好所以这块的知识呢你一定要学啊，这是能够切实提升你开发效率的啊，我们研发人员试过引入divers的整个流程之后，它的研发的效率确实是有大幅度提升的，呃软件测试。

这个呢主要是基于架构师的角度考虑，你需要了解一些测试的知识，所以在这里呢赠送大家一期软件测试，然后呢是service mesh，service mesh叫做第二代的微服务，这是下一代微服务的。

关键是基于云原生的微服务，很多地可能还不知道这是什么东西呢，没有关系，马老师这里已经教你怎么落地了，我们网约车的第五版用的就是service mesh，好了，这是p6 的内容，在我讲到这里。

我估计有同学该叫唤了老师，这么多，我什么时候才能学完呀，有这个疑问的同学听我说，it技术永远在发展，你从一岁，你从六岁开始学，学到20多岁知识，你曾经学完过吗，不要想着把它学完。

而想着在其中找你最需要的知识，跳槽涨薪之后再来整体搞定，我们的学生曾经测算过，大概用业余的时间来学习，把整个大纲学完，差不多需要1年左右时间听懂了吧，但是在绝大多数情况下呢，我不需要你学完。

我只需要你按照我们的路线学，那录这个路线长什么样子呢，其实这个路线呀就是老师来帮你做定制的啊。

这个我得我得把我的那个手机号引去啊，嗯这个路线的定制是什么意思，稍微给大家做一点小小的演示。

卧槽这现在需要让我改密码，哎呀算了，我没我没法给大家演示了啊。

对不起，主要是我们我们刚才登录了一下。

需要需要改密码啊，嗯我看看能不能给大家大概交代清楚。

是定制化路线长什么样子啊，啊大家从这里可以大概的演示能看到，比如说啊给你举个例子，张宝骏的学习路线，我们打开来看看，就是说这个学校是一个零基础的学员，简单接触过，没有系统深入学习，所以他应该怎么学。

首先先学习先导部分，在学习初阶再学jdbc，再学何嘉元什么，再学到这儿再学这m调优好，大概呢你给你个路线，你简单跟着学就可以了，点开直接跟着学好吧，我们来这两个人，呃不是让你全学完，这个大家能理解了吗。

能理解的给老师扣个一来，我觉得这是我们的一个亮点啊，我非常喜欢这个功能，怎么说呢，就是这个功能呢，让咱们同学们的学习效率变得无比的高，就你不用你走弯路啊，不用你非得a b c d e这么堆着走。

没有这个必要呃，大概在这种情况下呢，最长的最长的基本学个半年左右啊，你看你看像这种的学个两周涨5000的，怎么来的，你不可能把所有课全学完再去找心结，对不对，没有这个必要啊，但是完全你可以做到什么呢。

短期涨完薪，长期继续跟着学，第二次再涨薪，然后由于我们每年都在更新，大家看到了，这是我们的更新的内容，这是我们更新的内容，科研更新，你都能看得到啊，这是我们d d d的内容好，由于我们每次都在更新。

你年年跟着雪年年涨薪，它不香吗，你为什么要想着学完它呢，这块大家能听懂了吧，o内容我是追求整个课程体系要给全，我不太想给大家一点简单的体系，所以整个课时已经讲完了3000多个小时，没有讲完，正在直播的。

每周都有，我知道在整个市场上有很多比较短课时的，300多个都算多的呃，但我觉得我们讲一个东西要讲细讲透，讲到位，时间不够是不可能能达到这种效果的，举个最简单的例子，我们讲源码课。

拿连老师的源码课来举例子，源码，这是林老师讲的源码课，大概一共有277节，整体的时长我记得是80多个小时嗯，我知道有好，市面上有好多讲那个spring源码的课，但是大多数六七个小时搞定。

梁老师呢大概用了80多个小时给大家讲，清楚了spring的源码课的所有的内容，讲完之后的效果长什么样呢，你可能只用听这一个源码课，大概就能达到p7 级别的内容，这个不夸张，我，首先看。

这小伙spring源码面试直接通过蚂蚁金服，这是他的原画，第三面的时候，和面试官扯了一个多小时的spring源码，面试官怎么说，理解的很不错，很少见到对spring源码理解这么深的，然后就给过了p7 。

呃一门课我觉得就是说体现我们的态度，就是把它讲精了，讲深了，而不是囫囵吞枣的带大家过一遍好吧，所以这是为什么课时比较多的原因，讲得深，讲得多，讲得全，然后用定制化的方案来帮你做到效果最好好了。

这是p6 ，再说一遍，不需要你学完，也没必要听老师的，走捷径，不走弯路，然后接下来是p7 的内容，p7 呢就到架构师这个级别了，这时候主攻的是原理和设计，会涉及到理论基础，会涉及到分布式的算法。

会涉及到框架的原理和源码的剖析，刚才大家看到的spring的源码就属于这部分，在这个基础之上，还有tom cat源码，还有mq的源码，net的源码，lk的源码等等，呃读源码的话呢，多数读一篇就可以了。

没有必要说所有篇全读，除非你时间非常的充裕，在这个基础之上，高性能的架构设计理论，这个内容就比较多了，高性能架构怎么做，分流设计怎么做，并行并发怎么做，缓存怎么设计，存储怎么设计，可靠性怎么设计。

应用保护怎么设计，这个课程来自于阿里的实战，很多年的老师为大家做分享，了解理论之后，要了解实战，了解案例，所以在这里头再设计不同的情况下，不同的案例情况下做，应该做出什么样的设计，不同的专题抢红包。

红包与微博互关，12306，b站弹幕等等，应该做出什么样的设计，才能做到高并发，高可用亿级流量，多级缓存的专题设计又该怎么做，那么这部分内容大概能够支撑你很高，很高的一个薪水，举个小例子。

昨天我举过这个哥们儿，90万年薪干进腾讯，腾讯的面试就是案例架构设计，好了，我觉得呢大体的技术内容就讲完了，你们呢自学跟老师学都可以，把这个按把这个把这个呃咱们的大纲拿走，对照着学好吧，不走弯路啊。

当然好多人学了技术之后，尤其是一些没有项目经验的，我简历上没项目可写怎么办，没关系，东宝商城的大型架构，这个是完全模拟了淘宝京东他们的技术实现，我们的顾问就是来自于京东呃，会牵扯到方方面面的架构。

前端架构，后端架构，后端架构是核心，注册中心，配置中心，网关服务调用，限流认证，授权链路追踪数据同步，全文检索词等等等等，把这些综合起来完成一个项目大数据的架构，做数据推荐，ai的数据分析。

做推荐云原生的架构直接部署在云上，这个项目的第一版，目前在网上应该是直接能访问的，现在在讲的应该是第二版啊，那我们应该是在更新第二版了啊，shopping的这我得问一下研发部啊，应该是在更新第二版啊。

我问一下网址在嗯，需要等你白皮书就可以了啊，就是白皮书上写的也非常的清楚，那么这些架构长什么样，目前呢我们是部署在了华为云上面，与此同时呢，我们跟华为云是合作关系，大家伙想用华为云的内容免费。

咱们的学员用华为云做实验，免费听，明白了吧，然后还有其他的可以写在项目里的各种项目，网约车推荐流失平台，单体版，网游服务器等等等等，我在这就不一一展开了，好吧，这怎么可能链接第一版，第二版都有啊。

过去听就可以了，呃怎么说呢，我们今年呢还将落地四个项目，就是每个季度一个，你不用担心没有项目可写，马老师，这里呢你简历上没项目找咱们就可以了，好面试相关，昨天我也大概介绍过，主要是我们短期的冲刺。

当我讲完昨天短期冲刺之后，这个冲刺效果也是非常好的，快的两周其实有三天的，慢的一个月就能达到跳槽涨薪的效果，这也是很牛逼的，我跟我跟你讲啊，乱七八糟的，没有这个这是很牛逼的，非常短期。

一个冲刺就让你长心了，昨天有同学就一直问我说，那这个面试冲刺能不能单独买呀，我跟你说，面试冲刺单独买起来没有用，你知道为什么吗，因为我们在讲冲刺的时候，某一个技术点我们会会会聊这个问题，就说你去哪个课。

第几节老师讲到的内容去复习一下，你说你买了这个有用吗，只买这个有用吗，不单独卖，因为它和其他的完全是综合在一起的，呃今年金三银四的课呢已经开始了，今年g314 的课已经开始了。

2022请看g314 面试突击班，后端开发部分已经开始了啊，星期三的晚上啊，这是星期星期六的晚上，那个如果你特别着急，还可以去跟去年的，我们去年的讲的内容，你大概读完。

你也就知道冲刺班冲刺课的内容长什么样了，为什么效果比较好了好吧，这是咱们的去年的面试突击，大概464节课，当然这课呢实际上不是很长，为什么呢，因为有一些我们就是以内容，以以以以以以以提作为标题的。

它有的时间非常短，五分钟，有的是一分钟，有的是两分钟啊，所以他不要想着时间特别长，就是一个冲刺，比如说说一个直白一点的，就是hr问你为什么跳槽，你的优点是什么，你的缺点是什么，你对你上司怎么看。

这一类的问题就能死好多人，所以我们对这类问题呢，大概有70个软性问题是在第一部分搞定的，然后在软性问题之后才是我们的简历怎么写，然后呢才是被调的问题该怎么做，没有项目经验该怎么办。

然后再来谈具体的spring面试题长什么样，redis面试题长什么样，jvm的面试题长什么样，你但是呢我们讲的这个面试题，我们说老年的新生代，我会告诉你去哪个课去把这个复习一下。

你说你你你你你只买这部分能成吗，不成的啊，好这是面试的突击部分，然后是咱们的简介部分也很重要，在整个的大纲里面列了很多进阶的内容，这个内容呢是我认为将来未来的趋势，比如说云原生，这肯定是重中之重。

云计算到云原生，这以后移，一切都是云原声，大家伙看到的马士兵教育的网站，看到的枫叶云都是在云上面，你们现在没有用运，只能说你们公司现在比较落后，听懂了吧，但是并不意味着你们将来不会用。

你可以建议你们公司要用，远比你们自己去维护一些东西，成本要低得多，这个大家能不能，这个大家能理解吗，云原生aaas paas，saas到fa as到bas是吧。

到s s storage as a service啊，到云基础到云架构，docker k8 s源码解读，普罗监控dios研发流水线持续集成，科普菲尔的多云集群服务网格。

istio terraform和androbot，自动化编排公有云和私有云的搭建方案，无服务器方案，混沌工程方案，这些是未来的架构，尤其是哪些个在二三线三四线城市的，怎么装逼。

拿这个绝对唬得很多人一愣一愣的，当你去面试，别人问你，你的项目里面遇到什么难点，没有有人遇到过这个问题的，给老师扣个一，项目里面你们你遇到过什么难点吗，你有什么亮点吗，多数人说我就天天c r u d。

我有什么亮点，难点根本就没有，这里专门为这个为大家设计了一个课，这个课叫痛点规避和大厂bug处理，这是咱们在京东和新浪做开发的时候，真正遇到的线上事故，非常宝贵的经验，你写出来说出来。

对于面试官那就是强烈的加分项，你知道吧，他一听就知道哦，你是干过大项目的人，大厂的bug处理，关于管理层面的技术技术，实战层面，技术管理实战，大规模促销系统的架构设计和演练规划。

双11 618我怎么去调动各个层面的内容，软性的，ok总监级别架构师，当你年薪已经相当牛逼了，像年龄也差不多了，想朝更高程度走怎么办，欢迎参加咱们的大型团队管理，还有里边儿教你。

怎么样用实际的管理工具去带队伍，怎么样去做任务的监控，怎么样去做质量的监控，怎么样去做绩效的监控，怎么样去做项目管理，这个老师本身就是阿里p8 ，请阿里p8 为大家讲课，讲句实在话，也叫马老师。

有这面子，他年薪是200万，你要觉得说他在乎这点课时费，在乎大家这点学费，你可能就想多了，好好听，认真听手下管理过上百个人，上百个人的管理经验，好中台构建和架构领域，领域和这个领域驱动设计ddd d呃。

ai的人工智能以及产品管理，产品管理呢是咱们p9 的老师，他是真正的阿里p9 ，年薪大概400万左右，真正为大家讲了代理一个带一个整个的产品线，一系列的队伍，跨部门的带应该怎么去做呃。

初级的程序员意识不到这个课的宝贵，但我觉得应该有人能够意识到它的价值，能意识到的，给老师扣个一吧，如果觉得这种课没价值，我以后也就不不给大家请这么高端的老师了，反正教点简单的技术也能搞得定是吧。

不吸血管好吧，不计成本为大家设计了这些这些课程，这是我们的课程大纲，大家把它拿走，当然在这个基础之上还有一系列的更新，每年的新技术it层出不穷，老有同学说我能不能什么时候学完，同学你觉得你真的能学完。

我不太相信每年都有新技术，但我觉得吧你真正能掌握的是一些底层的基础，万年不变的东西，是值得你真真正正掌握的，我给你举个例子，左老师的算法，所有进大厂的人逃不过去的，也是比较难的内容，我跟我跟你讲，就是。

源码算法啊，啊算法，但是另外一门课啊，sorry数结尾算法啊，源码算法，就是这个呢大概是你进大厂永远比不过的，内容呢也非常的多，但是呢都是从零开始，什么是微运算，算法是什么，简单怎么简单排序啊。

有序数组呃，整个算法课呢，到目前为止是820个小时左右，然后呢，呃这个高频面试的，每周有营养的大厂算法面试题啊，11月4号，第四周的流行题目是第一周的流行题目啊，这都是咱们学生面试的时候所遇到的啊。

这是咱们新增的嗯，这些东西呢叫做万年不变的，基本上你算法掌握完一遍之后呢，他几十年几十年都不会变，我觉得这些是值得你人人掌握的，有好多新的内容啊。

优先学会怎么用，再慢慢去探究它的原理就可以了，但是优先学会怎么用，你以后就每天来查查马老师的讲过没有，你们公司要遇到过一个什么新的东西了，来到马老师查一下马老师讲过没有讲过，直接拿去用就ok了。

这就是方便之所在，好了，我的整体性的东西我就介绍完了，关于价格，那个市面上的大多数的300个小时左右的，他们的价格大概是8000块左右，我们是3000个小时，我们应该是8万块对吧。

每天每周直播只有三节课的8000块钱左右，我们每天都有直播的10万块，没问题吧，好除以11万块给你了，1万多一点，不能再便宜了，每个课时算下来，一个课时三块多，三点x人民币一个小时。

如果你觉得大厂的老师20多位不值这个钱，我也就不该不知道该说啥了，这1万多投下来取得的效果，大家去访问这个网站，1100位学员的就业案例，向你明确的表述这个效果长什么样，报名三天涨薪2000。

怎么做到的，就改简历，啥都没干。

遭遇企业争抢，这就不说了，两个月涨薪5000，1年6万，1万多块钱的投入，6万多块钱的产出，每年年年有，这还算低的，薪资翻倍，原来年薪25，现在给51，你们这技术教得太好了，也是麻烦事儿。

值不值自己判断，33岁的研究生报名之前离职学四个月，5k涨薪，回到行业。

点点滴滴，方方面面，一个字儿都没有造假，自己去比较就可以了，所以对自己有能够负责任的，平时你学个什么东西都知道找个专业教练的，学个健身，学个乒乓球，你都知道找个专业教练学个四级，你也知道报个新东方。

当跟你息息相关，每年都能让你涨薪，你就不知道跟一个专业教练来训练了吗，o，今晚的活动介绍完，看这里，今晚活动啊，这也是咱们的那个枫叶云做的p p t啊，就是咱们在枫叶云上可以直接做。

做我自己的p p t呃。

今晚活动我们有最后的白金卡十张，就今晚送完为止就十个多，一个都没有，白金卡意味着什么，我刚说了以后每年有新增的内容，新增1年只需要188元，1年，一整年大概每年接近1000个小时的更新内容啊。

呃各位兄弟们自己想着值不值，就成了最后十张思域优先内推个性化的方案，定制我们自己app的使用权限，现在呢大家可以通过手机下载马舒新钓鱼app，上面也有一些免费的课，上面你是vip，也可以直接用来学。

另外今晚报名，2月28号，明天晚上的咱们每月最后一天的抽奖活动，这是我们的奖品，这个不是很重要，最重要的是你买来的是你将来的职业发展，好吧，我会对你进行技术评测，量身定制学习内容，一对一的实战指导。

简历优化，面试指导，我们的学习服务，我们的专属福利。

系列 6：P100：分布式锁如何解决缓存击穿问题？ - 马士兵学堂 - BV1RY4y1Q7DL

今晚有录播了，加小姐姐有录播。

来刚才讲的是组keeper怎么去存数据的对吧，以及它的一些节点类型，还要再给大家讲一个组合的特点，这也是我们写分布式所必要的一个特点，什么特点呢，事件回调机制。

事件回调机制，画图来讲，诶这个图怎么回事啊，图个方框，假设这是我三来组k宝，我现在有个客户端，我客户端啊连的是它，然后在这个节点上创建了一个，创建一个节点，比如说叫log节点，好吧，叫log节点。

那么这个节点是不会同步到其他的节点上去，比如说在logo下再又创建了一个log 1，这也一样。

创一个log 2，这个也一样，创一个lock 3，这是我client一创建的，然后我client这个client 2他做了一件这样的事，它连接上我们的节点之后啊，随随便连，其实连谁都一样。

因为数据一致性嘛，它假设连接上了它，然后就在这个lock这个目录上面，就在这个层级目录上。

他注册了一个事件，听懂了吧，注册了一个事件。

那么这个事件触发的条件是什么，我们可以自己来设置，比如说我这个目录下的子节点。

发生了数据的改变，或者说发生了节点的删除，发生了节点的删除哎，这个事件都会触发，那么一旦漏一下这个节点发出删除之后，它就会回调我客户端上的回调函数。

它就会回调我客户端上的回调函数，如果你这个回调函数实际上火箭上天，那么火箭就上天了，我再说一遍，我们现在假设来的客户端。

它创建了一堆目录，又来一个客户端，我基于它的父目录，我注册了一个事件。

那么事件处罚的条件，我们可以选择你的节点数据发生了改变，或者你这个子节点发生删除哎，不管发生了哪一个改变。

你这个事件都会触发，它就会回调你客户端上的回调函数。

它就会执行你回调函数里边的逻辑。

这就是事件回调，简单来说来，现在听明白了，666告诉我必须全要点。

好，继续来聊，那么掌握了这三个特点之后啊。

再来聊组keeper分布式锁就轻松很多了。

就轻松很多了，那么在聊这个组k分布式锁的原理之前。

先给大家讲一个小例子。

讲一个小故事，我们应该都去银行去办过业务。

都是中国银行办业务窗口啊，只有一个，窗口只有一个银行里边，下面现在呢都有一个叫叫号机，都有一个叫号机嗯，在这个银行没有开门之前啊，比如在门口堆了一堆的人，等待去银行办业务。

那么就在就在开门的那一刻。

就在上班的那一刻，这九个人。

是不是全部进来了，那么银行是怎么解决这种变呃，这个并发问题的银行怎么解决的，他让这九个人啊，你不要来窗口，这你先来叫号机去叫个号，我最后窗口在受理业务的时候。

通过你的号牌来给你受理，比如说这个人叫的号是一，这个人叫的号是二，这个人叫的号是三，这个人是五，这个人是四，这个人是六，这是九，诶这怎么回事，这个是九。

那继续说继续说啊，我们还我们还是来聊这个这个这个中国银行，去银行办业务这件事，这个办业务的窗口啊，只有一个，上面只有一个，然后这边呢有一个叫号机，假如他们九个人已经过来了。

在这，啊假设就六个吧，不用那么多了，然后这是1号，这是2号，这是3号，这是4号，这是6号，这个是5号。

现在每个人手上是不是都有一个号牌对吧，有个号牌就是杜兰。

这个叫号机，这叫的，那么首先第一个人呢他先去办业务。

先去办业务，那怎么知道1号先去办业务，还有我们说银行里边是不是有个小喇叭。

这个你这个小喇叭是不会会通知啊。

接下来几几号来这边办业务，那1号办完之后，2号是不是也来翻。

你看这个喇叭是相当于是一个，是不是事件的通知啊，对不对，相当于一个事件的通知，我们基于组k一撇去实现一个分布式锁。

一模一样，就这样一个思想，就是这样一个思想来这个例子能听懂的，666告诉我。

ok来。

回到我们这个主题本，这三台节点，然后这个客户端，两个。

三个，然后这是我那个卖票窗口火车票。

好吧好了，那么现在有这么三个人啊，client 1 client 2和client 3。

那么这三个人你想去买火车票，ok先来我这住厕所，先来抢所。

比如说所谓的场所啊。

就是往lock这个目录下去创建一个有序的log。

有序的节点，比如说第一个客户端他先创建的。

那么它的序号就是log 01，那么客户端二它后创建的。

那么它的就叫log 02，你记着我们创建的这个序号，它不可能相同，因为刚才给你演示了。

我们也推断出了，就可以把他给我维护一个全局有序。

并且唯一的序号听懂了吧，那么client 3给我创建的那就是log 03，当然这些数据啊它会同步到各个节点上，没毛病吧，会同步到各个节点上。

这就相当于说我这用户去叫号机。

前面是不是分别叫到一个号啊，听懂了吧。

教导一个号。

比如你客户端一先创建的是log 01，客户端二创建的log 02，这个时候客户端二其实还要做一件事。

他会在log一上注册一个事件，在这些，client 2，那么client 2在创建的时候，他发现还有比它是不是更小的一个序号，那就在它前边那个序号，那个节点上去注册一个事件，那么client 3。

他也是在它前面那个节点上去注册一个事件。

也就是在log 02上听懂了吧，那么第一个去买火车票的肯定是client一啊，因为它的序号最小啊，那么当loud一买完票之后，cloud一是不会把这个节点给干掉。

这个节点一干掉，我注册在log 01上的事件，就会去回调log 2上的回调函数。

那这个回调函数就是去买火车票。

那client 2买完之后，这个节点是不是也会干掉，当然这些都是同步啊。

那你log 02干掉之后，他那个节点上我class 3是不是出错一个事件。

这个时候再定义它的回调函数去买票。

你看基于组cp实现分布式锁的这个思想，并没有使用什么有效期啊，或者说超时时间啊，所以这就解决了我们所说的mysql那些问题。

以及redis那些问题有效期的问题。

来我给你讲明白了，666告诉他。

ok了。

如果大家想听，再再细的这个这个这个组keeper的原理。

二维码去听一下我之前讲的好吧，听一下我之前讲的。

我先来，有同学说，等会儿讲一下pk，我们下一次行吗，我们下一次乖。

ok刚才那位同学说不存在死锁吗。

会不会有死锁啊，来看一下啊。

来看一下，如果我组kep 1，他的我说了。

他的序号是不log一啊，那么他在这买票的时候，假设他宕机了，是不是这个节点挂了，进程挂了，那这个进程挂了和他是不是失去了心跳，对不对啊，这里边忘说了，这些节点必须是一个临时有顺序的节点。

就是这个log 1 log 2 log 3，必须是临时有顺序的。

那你这个节点关了没了心跳，就ka集群自动会给你，把对应的节点是不是给干掉，那你这个节点干掉之后，是不是会通知他去买票。

对不对，那你lock 2档机也一个道理啊，它会自动给你把这个节点干掉。

让下一个人去买票，这不也完美的解决了死锁问题吗，唉我给你讲明白了。

系列 6：P101：高并发秒杀场景下MySQL分布式锁实战 - 马士兵学堂 - BV1RY4y1Q7DL

先从先从一个业务场景入手，第一步先从业务场景入手，然后秒杀的解决方案通常是这样的，就是在极短的秒杀的关键词，为什么叫秒杀，秒就是时间短，杀就是用户量大，就是在极短的时间内，忽然涌来的大量的用户请求。

然后你的业务系统如何能承载住，这么大的业务系统请求，并且数据还不出错，理解了吧，现在把秒秒杀秒杀的关键词我已经说完了，大家记住了吧，在面试中问你秒杀，你应该能分析出这两个点时间短，用户量大。

然后还要保证保证数据就是业务系统不崩溃，然后数据还要一致理解了吧，是我我说清楚了吗，你在面试中打秒杀的时候，你们是在听课还是不听啊，问问问问话都没人吱声，懂了是吧，懂了，那我们懂了，继续啊。

秒杀场景我已经说完了，就那几个点，然后业务实现业务实现怎么做，我们这节课的例子是这么做的，整体架构上市用户的请求进来之后，我有一个服务呃，这个服务是接收用户的请求，然后另外它有一个功能是做负载均衡。

然后呢再调用后面的服务来实现业务逻辑，后面的服务就是业务逻辑最终实现的地方，所以我在我们的项目里，我要起两个服务，就是一个服务接收用户的请求，一个服务执行最核心的业务代码，ok这块听懂了吗。

我在这堂课上的例子是什么样子的。

懂了吗，清楚了吗。

一个一个是这个接收用户的请求，一个呃service执行核心的业务逻辑，ok ok我们继续啊，然后说一下呃，先说一下秒杀中间的数据怎么做呃，秒杀秒杀的核心业务，大家想一下，你如果去买一个东西。

比如说抢茅台酒，然后呢你抢茅台的时候，你想一下你的业务逻辑是什么样的，是不是第一我的请求过来之后，我先查一下茅台的库存有没有，如果库存大于零，然后我才去购买，是不是这个是不是这个核心代码的逻辑。

请求进来，先查库存，如果库存大于零，然后扣减库存，就是把库存减一个，然后呢创建一条订单，这个订单就是我就是我的订单，然后呢如果库存不够的话，那就购买失败，这块理解的同学敲个一，这块都比较简单啊。

接收请求是前端，那么对接收不管是前端h5 的还是还是安卓的，什么端发来的，我都说我是后端，好了理解我们继续啊，简单的东西我们就快点过，然后直接就上代码了。

ok然后呢这就是我们的代码，大家看一下核心的代码。

刚才我说了这个这个这个核心代码的流程。

然后这块儿就这就是实现先去库存表里查库存，然后这块我休眠了两秒钟，为什么休眠了两秒，是因为等后面其他的并发都一起，涌入到这个地方，这话能理解吗，我秀我在这写睡眠的目的，我不是为了拖慢性能啊。

我是为了等并发，能理解我这话说的目的吗，就是如果要模拟出并发睡眠，睡一会效果会更好一些，能能否理解我这这个点理解是吧，ok直接直接把库清了，然后呢，把库设置好，这个就这个表，这个表是库存表。

然后查完库存睡一会儿，然后判断一下库存如果是大于零，进行库存的扣减，然后呢扣减完库存之后新增订单，ok也有逻辑带大家看完了可以继续了吧，继续的敲个一，直接压测了，ok那我直接压了啊，然后现在库存是二。

然后呢订单没有好了。

直接拿缜密特压测，点击添加地址，这就是我们要请求的地址，然后呢有一个接收器，这个技术是模拟用户的id，就是用户是递增的，然后呢我一共发十次请求，ok现在直接开始，我把这个关一下好了，已经关掉了好了。

直接秒模拟并发并发已经过去了。

感觉并发连秒没效果，为什么叫并发两秒没效果好了，来大家看结果，一堆的日志中，一堆的简单成功是不是，然后我们看一下这边，这边的数据，然后数据先看一下库存是两个是吧，库存是两个，然后刷一下库存变成一。

库存变成一，然后但是我们发了十个请求变成一，明显是不对的，然后呢订单大家看一下订单新增了十个，是不是也不对，来这块能理解的同学，你敲个一，就是说我有两个库存，有十个请求，然后呢库存只少了一。

然后订单加了十，这是一个错误，这是不是一个错误的例子，但是这么一看代码其实写的也没毛病是吧，我代码选择其实是吧，乍一看也没毛病，先查库存，库存大于零，我我去扣减它，然后呢我再新增订单，是不是没毛病是吧。

但是问题出在哪呢，问题就出在这块地方，给大家简单解释一下，执行到这的时候，有一个请求进来，一个请求，两个请求，三个请求，四个请求，一直到十个请求都在这，他在这查出来的库存都是二，然后判断一下二大于零。

然后十个请求都进入到这个里面，然后都执行的是2-1=1，所以库存最后是一这块大家理解了吧，然后呢，然后就新增订单，那么就是十个请求都都进入这个if循环的话，那就新增了十个订单，知道吧。

所以这块错这块错误的原因，就是因为大量的并发都涌入这个方法，然后怎么解决这个问题呢，加锁用什么synchronize或者lock都可以，这就在j v j v m级别加锁，因为现在只起了。

只启动了一个服务，我看一下啊，然后把它切换一下，切换成有锁的，然后呢把服务重启一下，不锁吗，我先从最简单的没锁的给你演示到有锁的，再演示到分布式锁的啊，sweet有点甜，别着急别着急啊，明白是吧。

o好了，然后呢重启一下，现在把锁已经加上了，然后重启一下，然后把那个数据我们再恢复一下，对山本力所在分布式锁，你说的对，you are right，好了，然后呢库存刚才已经改过来了吧，库存变成二。

然后订单还是没有，然后呢再来压一把，ok但是这十个请求都走完，你看十还是现在还是9765，郭鑫鑫，谢谢，二三等他走完啊，这边二一，ok。

然后呢看结果先上库存从二变成零，是不是库存对了，刚才是一，现在变成了零对吧，然后看订单，两个十个用户来买库存，就有两瓶茅台，然后呢库存减了二，东西卖完了，然后只有两个用户买到了来。

现在的结果大家能理解的，敲个一就结果已经正确了，不像刚才那样，库存最后变成了一，然后订单加了十。

ok那那接着继续啊，但是这种情况下还有这种情况呢。

还有一个问题，这个锁是怎么加的，好的，我给你看一下啊，这里有一个gm什么，我我把这个注解打开，然后呢点一下这个呃，有一个jvm锁lock，谁就写了个synchronized。

你也可以用用lock去做简单吗，就实现了j u m级别的枷锁。

但是这个不是我们课程的重点，这个比较简单好了，然后在在实际在实际的工作中呢，肯定会遇到这么一个问题，是集群的问题，第四集群的集群问题，什么问题啊，就是说处理就是为了避免服务的单点故障。

我们会用多台服务来实现，就是说这个服务挂了，有另外一个服务能顶上，这个大家可以理解吧，就是在实际工作中，然后呢通前面通过加一层负载均衡，然后来平衡这两个符，就是有比如说有十个请求过来，先给这边加放五个。

再给这边放五个线程，一直能量后遇到会被超时呃，这个一会儿再说啊，这个你先听，我把主线就是把我们主要的思路捋完，然后呢中间课程中有任何的问题，到时候你再问老师一一给你解答好吧。

然后现在我们就说呃有两个业务处理的服务。

我们再额外来起两个，刚才是一个8004，你看下面是8004，然后现在呢我再起一个8005。

这样的话我们的架构就变成了我图上的这个样，子，就是这边是8004，这边是8005，两个业务服务来执行。

然后等它起完之后，我来压测一下它的结果，咱这边启动完成，好8005基本上启动了8004日志清掉，然后呢，这边再重启一下，然后呃代码给它删，数据库给他删掉嗯，库存给它变成二。

然后呢再来压测一下呃，压刚才有同学问压测什么，压测用的gma，然后负载均衡怎么做的，负载均衡其实就是用微服务ribbon做的，用ribbon做的就是spring car ribon，但是现在最新的。

大家知道spring cloud最新的负载均衡用什么做吗，现在现在不用ribon了，好了直接压了点，好等着请求一个一个示范完，剩下九个八个不是，不是fan也不是完了，最后给大家好好讲一讲。

因为这个一讲话题又扯出去了。

先收回来，先看我当前这个结果，然后当天的结果是我起了两个业务服务，然后呢还是像原来的请求一样，原来的压在一样，请求压过来，看我们的数据还对不对。

我们直接看数据库，数据库的库存现在是几个二，一刷新变成了零是吧，库存变成了零，没毛病是吧，然后呢看这边订单变成了四，是不是又发现问题了，四个用户来买两个库存的东西，结果库存卖光了。

结果是有四个用户抢到了，是不是有，因为原来的库存是二，我们有十个人来买，结果呢有四个人买到了，是不是有问题，应该是有两个人买到才对，这块大家能理解吧，结果现在有四个人买到了，明显是错误的。

错误的原因是什么，就是因为多了，表面上看是因为多了一个服务。

就是原来只有一台，现在多了两台来这块大家能理解吗，就是我做了一个操作，是另又起了一台服务来压榨这个业务，导致了这个结果，然后我们分析一下原因，原因就是最开始在这个在这个服务里。

你看两个服务在这个服务里加的锁，和在这个服务里加的锁，它不是同一把锁，所以他们两个拿到了两把锁，都去执行业务，知道吧，load balance，对你说的对好了，微服务的事先放一边。

一会儿我统一给大家讲一下，spring cloud最新版本怎么着啊，先那个先翻一会再说原因，我给大家说清楚了，就因为起了两个服务之后，两个服务加的锁不是同一把锁，他们不具备互斥性。

所以导致了跟他的错误结果这块大家能理解吗，能理解的，敲个一老师就继续，要不你不吱声，老师在这在这不知道该退还是该进，进退两难好了，怎么才能让他们两个拿到一把锁互斥一下呢，大家想一下，在我们的实际生活中。

你就是他家的锁，他不认他家的锁，他不认怎么着，你在工作中是不是是吧，房东和租客和房东之间是吧，你不信你不信我，我不信你，那么找个中介，然后在那个政府的软件处理中也是一样的，我们也找一个中介。

下面给大家看这么一个一个小小的动画。

我把这个缩小放进来，就是说还是用户的请求请求到这个服务之后呢，这个服务要加锁的时候，去这个中介中介拿一把锁，然后中介把锁给他之后，然后又有另外一个请求打到这台服务器上，然后这台服务器再去中介拿锁。

他就拿不到了，理解吗，这就解决了，刚才多个服务之间不是同一把锁的问题，就是说我在我服务里拿的锁给你，在你服务拿的锁不是一把锁，那么我们都把锁放出来，我们都别自己在自己屋里玩，我们都放出来。

都去一个公共的地方去哪所，这一块大家能够理解理解的。

敲个一继续o，好了这就是我们做分布式系统，分布式系统，分布式锁的思路给大家说一下啊，就是这个，然后呢他思路的实现有这么几种方式，就是用有my circle的方案，有release的方案。

如kb的方案和etc d的方案，当时这几种方案都给大家说一下，我们先说第一种mysql，mysql的方案，说mysql方案之前为了便于大家理解第三方，第三方这个呃。

第三方中介这个事儿给大家拿文件举了个例子，就是说在同一个目录下，比如说名字叫一的文件，只能有一个理解吧，就是说比如说这个线程来这个目录下，创建了民族唯一的文件，然后又有另外一个线程来这个目录下去。

创建名字唯一的文件之后，发现原来已经有了，所以他就创建不了了，就是说明这个锁被别人拿着了，就是别人来获取所的时候，就创建一个1号文件在下面，然后当另外一个人再来呃，文件系统拿死的时候。

发现别人已经有这个1号文件，所以我就拿不着锁了，这块能否理解，理解是吧，其实这就是他最本最核心的思路，然后紧接着我们来说mysql，mysql的方案呢，其实跟刚才我说的那个思路，大家想一下。

如果要去mysql拿锁，就是一个线程进来一个，甚至进来之后去mysql插一条数据，然后让别人进来，再插不进来就成功了，怎么做，大家想一下是不是用组件第一用主键pk，然后在这一行记录中。

我插一插一个组件为一的这么一行记录，我插进来了，然后别人再来插的时候，也是要抢这个商品，商品的id是一，它也要往这里面插一，那么它就插不去，插不进去，他就报错了，这是主键，还有可以用唯一索引。

唯一索引保证这个列在这张表中只有一个，就说你在唯一索引，你放一个一，别人再来插，唯一索引是一的这一行记录他就插不进来，他就会他就会有问题，就拿不到锁好了，mysql的思路已经说完。

大家理解的超过一为什么都是一啥意思啊，你是说我屏幕中写的一吗，比如说你买某一件商品，它的商品的编号就是一，大家都来抢这个商品的编号，把一放在这里，就是我就说明我要来抢他了，你们谁都别来抢了。

你别人再来抢一的时候，要往里面插一个一，你就插不进去，就说我抢这个东西，你不能抢，等我抢完你再来再锁住它，看看库存有没有，那这个值怎么生成的呢，为啥值是一呢，商品id，这是商品的id。

你你要去锁抢哪个商品，哪个商品的id就是一，不一定是一，有的时候你商品id是二，有的时候你商品id是三，不是一，这这懂了是吧啊，懂了懂了懂了就继续啊，怎么锁锁，刚才我已经说了。

就是说差数据就叫锁一个相对来插一个一，他就锁住了，只要这条这行记录还在另外一个线程，再来插一，它就插不进来，他就锁不住，就这么个规规定，大白菜白菜懂了吗，因为这块比较这块啊，懂了是吧。

这块比较简单一些哈，好了呃，对用pk用用主键和唯一索引，ok，释放所就删除这条记录吗，你说的对，jonny你说的对，释放锁就是把这条记录给干掉，然后别人再来插这行记录，他不就能插进来了吗，懂了吧。

释放者就是把这条记录给干掉，get o好开心，看到你们每次发一个get懂了，我就非常开心好了，那我们就来实践一把。

拿我的代码实践一把，好了，把它切换成mysql的锁，这就是java的好处，要换啥业务，不用动，直接换注解好了，我重启一下服务，这个太危险了，崩溃了，怎么整，这个四谋青年等着别走，等我把代码演示完。

告诉你怎么它就不危险了，这个注解什么意思，autowire qualifire，这个什么意思，这个spring就是把一个bean注入到这个内容吗，这个很简单啊，老师你条理很清晰，听着清楚舒服，你舒服。

我也舒服是吧，好了，把它两个人都起来，然后呢这边再稍微重启一下，然后呢我去数据库把它恢复掉，然后把它清掉，把库存恢复成二，你这个，库存释放有点问题，你看出啥问题来了，一会你说啊，等我把代码演示完。

一会你说问题我一一给你解答，随便问，好了来再来一把亚瑟。

那个亚瑟好了，开始压了啊，好了，十个线程顶上去，现在十杠十，八七，三，你等一下啊，你别走，带着你的问题别走。

等我把这个演示完给你回答好了，零现在是零，我们看结果刚才的结果是二变成了零，然后订单加了四个，是不是有问题的，现在的结果我用了mysql的锁，应该是正确的，二变成零，正确没毛病。

然后呢订单是几个才是正确的，订单是几个才是正确的，一直听课的同学，ok刷新一下，两个对了吧，mysql解决了吧好了，刚才mysql问的那一系列问题都甩上来，我现在给你回答，现在成功的结果已经看到了。

刚才刚才我记得有两个问题，你甩上来，老师刚才说唯一这个人刚才说唯一建设good id，可明明两件商品的id都是一样的，我我在这个系统里只抢一件商品，只抢一件商品，我经常记录，你看库存id就是一。

它的库存就是二，我这里我这个例子里只有一个商品释放，锁断完怎么办，ok回答你这个问题，如果释放所断网的话，刚才加那条记录来，我把ppt打开。

p p t打开这边释放锁的时候断网是吧，然后这是一这是i d，比如说这是主键1号，然后呢你加一个什么start time，然后加一个end time，就是在这个有效，比如说呃在一分就是在零一秒到零三秒。

这个锁是有效的，哪怕网断了，下一个人再来插手的时候，发现超过了不在这个时间内，它就可以接着插，知道吧，你可以把它的唯一索引再加上时间来判断，懂了吗，对类似于一个过期时间。

就是说你判断所所是不是有效的时候，你可以再加上时间，懂了是吧，懂了继续刚才的问题还有吗，有问题甩上来，然后mysql就过了，会不会竞争过大，导致表所两个商品是同时两两把两把锁并行吗。

对的两个商品就是两把锁并行，时间完不成，时间完不成怎么办，就说这个业务没有执行完，另开一个线程，为了做手，用一个买sl数据库，有点杀鸡用牛刀的感觉，这个就看怎么去衡量，知道吗。

有的人有的人有的公司的业务，比如说就十个人，他搞两台服务器都觉得是浪费，但是有的公司的业务有1亿个人，他搞100台他都觉得不够能懂吗，不是说用几个mysql的问题啊，行云流水，我这么说你能懂吗。

mysql只有一台挂什么，那就做mysql的集群，咕咕咕，懂了是吗，好了这个能否过，因为这个mysql，它一般人一般的也就是一些小型系统，有mysql大系统用的redis，我在后面给大家详细的讲一个商。

一个商品可以抢两份，好像不行了，什么叫一个商品可以填两份，好像不行了，就是买两买两个是吗，那个是业务那个业务的情况，等我课后再跟你聊啊，就是这里把我的先抢一个，然后拿这个把所有的锁讲完给你聊。

给你聊抢多个的时候怎么做啊，实际业务与白色分布者不多吧，实际业务用一些小项目会会用，会不会把mysql压垮了，呃mysql的话呢。

看你是什么样的mysql，我给你看过，你看看这个mysql，我就我就知道你们会问的一些问题，我都给你准备好了，这个mysql它的q p s是10万，他的q p s是10万。

你写的业务代码能达到10万的qp吗，mysql说mysql能把mysql压垮了，你得看是什么样的mysql是吧，用这个mysql你压不垮，你就往死的压，你的q p s也达不到10万，你压不垮了。

mysql都能顶得住100000q p s，它已经不是你系统的瓶颈了，所以没关系啊，得看配置，对硬件好了，这不是这不是都一样啊，我说这个的目的是刚才有人说mysql的性能不行，我是给你拿这个举例子。

看是什么样的配置，才能达到什么样的性能o，好了mysql过。

然后下面给大家说redis的解决方案。

系列 6：P102：高并发秒杀场景下Redis分布式锁实战 - 马士兵学堂 - BV1RY4y1Q7DL

对一些中小型项目会用。重点是reice，对，重点是reice，reice用的才是最多最多最多的重要的事情说三遍ok。下面先说readdies单节点解决方案。刚才用mysql的时候，我讲过了。

加锁的时候用主键或者唯一索引。那么用redice的时候，用什么东西来。做他的唯一的那么一个东西，您你真硬。嗯，你说的对，醉梦今宵，你说的对，就是用这个命令side NX。戴taNX的意思就是什么呢？

就是说原来reies里有这个reies的存储结构，就是KV值啊。不懂reice，我简单过一下KV值。如果原来这个reice里有这个key，如果有我set就set不成功，如果没有，我才能set成功。

大家这么一想，是不是就能想到加锁了。如果原来没人给他加锁，那么我加锁成功，如果有人加锁，我去加锁就失败。懂了吗？这块如果没有readiness基础的同学，我简单的这么一说，可以懂吗？😡，可以的。

我继续了，get继续好吧。😊，来，除了加锁之后，还有一个放锁，就是说通过set NX去加锁，还要通过deelete key去放锁。就是你加了锁，你执行完业务了，你不能不放锁吧。如果这个key一直在这。

你执行完业务，你不管它，别人再来加key就加不了了，懂了吧？所以除了加锁还有放锁的操作，记住啊，s NX加锁，delete NX放锁。好了，给大家简单说一下这个死锁的概念，就是刚用刚才的。😊。

set key value和delete key有一个死锁的概念。大家可以看先看一下我这个小小的动画。

先拿拿一台rediis过来，然后呢，这台服务器给它加锁里面设置了1个KV值。就是K1Y6的值已经有了。然后呢。这台服务器挂掉了，就是说它的业务没有执行到释放所，就是说它没有执行delete的时候。

没有执行dele这个key的时候，它挂掉了。那么你说。key还在不在reads里？😡，嗯。在是吧，如果可以在的话。😡，其他的服务再来加锁。他还能加上吗？对他就抢不到了是吧？所以这个就造成了。死索。

能理解吧？就是如果你单纯的如果你要单纯的看代码的话，就是用这个代码去写的话，是不是那么完美的。

就说你的业务代码挂了，没有执行delete的时候，会造成死锁，其他的其他的业务再来加锁加不到，那怎么解决呢？

怎么解决，看这么一段动画。然后呢，就是你这边加锁的时候给它设置一个过期时间，就是说这个KV值有一个过期时间。比如说这边服务挂了，挂了之后，它里面的key就消失了。然后呢，其他的服务再来加锁，它就可以。

加得上。理知啦嘛。😡。

的。用这个。设置过期时间设置过期时间怎么做？就是有的时有的时候有的人写代码这么写是吧？s nX一个key，一个value值，设完之后再写一个exel是吧？exp key。😡，1秒有是吧。这么写也不对。

因为你的程序如果执行到这，刚加完锁之后，在这个地方挂了。就是你还没有等过期给他设置过期时间的时候，他就挂了。然后这个key也会一直存在于reice中，其他的服务器再来加锁，它还是加不到。还有这种事儿。

太有了，这不是告诉你了吗？我我跟你说清楚了吗？那个积木。😡，积木，那咋整？咋整肯定会告诉你咋整是吧？然后跟照这个加锁的方式就不对嘛，那怎么加？😡，通过这样去加s KVNXEX10。这就是一行命令。

让他用一行去加，也不用lowa脚本，直接就这么一行命令reice支持直接可以加好了。直接有参位。对，就是我的意思就是说你不要把过期时间和sNX分两行去写，你把它写在一行里就没问题了。😊，OK懂了吧？😊。

然后呢，好多人用的reis是老版本的，老版本的它不支持这个的话也没有关系。然后呢，老师这里面也给你准备了。

落脚本。是吧撸尔也有撸尔加锁的代码。Alu啊。放锁的代码，这里面都有这个找丨小丨姐姐。领取这段代码OK然后这块加锁的时候，加锁的时候就先过。好了，扫完小姐姐吱一声，我们继续讲课。给你刚才给你说到了啊。

用撸老版本的reis用lua也可以。我给你说到这了。好了，小姐姐抬走。😊。

继续我们的课程。然后呢，就是基于刚才的这种情况，就是这不是set一个key，一个value，然后它也有了过期时间。知道吧？就这个这个时候大家看似完美是吧？过期时间也有了，我能保证我的服务挂了，锁也不挂。

😡，不是保证我的服务挂了，所以自己会慢慢的释放掉，让别的服务也来加锁，是不是感觉此时很完美？大家觉得这里面还有很还有坑吗？好了，我给大家看一段例子。😊，给大家看这么一段一段小动画，大家理解一下啊。😊。

然后呢，你看啊ready设置设置过期时间引发的一些问题。还没到还没到单机挂了的时候啊来。他给res设置了一个key一个value，它的过期时间是10秒。结果呢这边的程序就是它的程序执行了10秒钟。啊。

程序在左边已经执行了10秒，然后它接着。到10秒的时候，key没了，因为这个key。😡，他过期了，知道吧？K过期了没了。😡，然后呢，他还在往下执行。他还在执行。他一共执行了14秒，当它这最后4秒的时候。

看这里面颜色一样。这个程序进来加锁能不能加得到？因为它的reies里面已经没key了，所以它可以。加锁成功，然后这个时候呢，就有两个线程同时拿到了一把锁，这样往下走的话，它还会遇到超卖的问题。

就是刚才说的。本来一个一个的来，结果两个人一起来了，就会遇到两个定两个库存被卖了10个人的问题。来这块清楚的同学，你敲个一，就是为什么两个县程同时拿到了一把锁，是因为程序还没有执行完锁过期了。

在程序的执行过程中，这边的程序来了之后，同时加上了这把锁。好了，这是这个问题。然后紧接着这个思路啊。😊，这个思路还有一个问题是什么呀？它这个程序比如说执行到这个地方的时候，它去执行delete操作。

那么是不是就把。😡，这个程序s的那个key给。delete掉了。没想到这一层是吗？没事，老师会给你把你没想到的东西都给你想到，让你这节课不白来，好了。😊，他去执行delete的时候。

是不是把这个线程加载锁就给delete掉了？就是说。我删除了别人的锁。能听懂的敲个一。好啦。😊，我删了别人的，那么往后，如果别人再来呢？然后就会造成。这个又去伤他的锁以后这么一直上下去，你你他伤他的。

他再伤后面的是不是就乱了？首先咱就不说又抢到又不抢到的是吧，他肯定就是宁您你说的这个是对的，他后面呢又能抢到，只不过是他说只不过这个里面更更纠结的问题就是我删你的锁，你去删他的锁，他要来删我的锁。😡。

知道吧？这是会会引起程序的混乱。那么怎么解决这个问题呢？我们这么解决。😊，删除锁的时候。加那么一个判断，就说如果这把锁是我家的，那么我来删除它。如果不是我家的，我直接略过。

是不是就解决了我删你你删他的这个问题，听懂的敲一。增加识别吗？增加一个判断，一会儿告诉你判断怎么写。好了，这是一个问题，这个问题解决掉了，然后再解决另外一个问题，就是说锁过期的问题。

就是说我程序给锁设置了10秒，结果我程序执行了14秒，怎么解决？那么我给锁设置1个14秒，好不好？😊，如果设置14秒，因为程序的执行时间你无法控制，万一它就执行了15秒呢。反正是说设置15秒。

那我程序就是执行20秒是吧？那只设置100秒，那我程序就是执行101秒，你无法预估你程序的执行时间。😡，懂了吧？所以我们需要引入。另外一个机制。另外一个机制是什么？看门狗。看门狗是一个什么情况呢？

给大家举一个例子，就是说比如说这边有一个大房子。这个大房子是什么呢？就是说你要进行业务处理的一个代码块。是吧然后我给这房子标个标个名字叫toilet。然后你要进去进行业务逻辑的处理。

你进去处理业务的时候呢。你在reis外面，你给它设置设置一把锁。然后这个锁呢，你看这把锁已经有了，然后你再给锁设置一个过期时间是一分钟。然后呢，你再拉条狗。到门口。这条狗呢它干啥的呢？他就说。😡。

如果过半分钟主人不出来。我再把锁的有效期再续一分钟。能理解我这个意思吗？就是说你不用管那个锁有效期是多长时间，就是你就给它设置一分钟。然后只要你在里面不出来，你的狗到第30秒的时候，自动把它续到一分钟。

😡，老师，我发现别人和你举的例子都一样哈，行业通用的，谁跟我举的例子一样。😊，那那就是抄我的啊。好啦。😊，这块大家理解了吗？😡，能够理解。就说拉条狗放门口，这条狗呢就是另外一个县程。

结另外一个线程就监视着你的主线程完成没完成。get到了是吧，理解不知道怎么实现，哎，肯定会教你怎么实现的，别着急啊。😡，好啦。Yeah。ok。😊，那我就给给大家看一下这条狗怎么实现。

重启一下。就是你来了，别乱刷屏啊。你要在乱刷屏。不要影响大家学习。好了，reis我起了。然后呢，其实我起了很多个reies在我本地，然后这是一个reies。然后呢呃我去看一下这个锁点开。😊。

Reiesister。锁。然后这里面呢我让他睡，我把这个5分钟打开吧。睡5分钟意思是啥？让大家看到那个狗狗生效不生效，就是主人进去卫生间，在主人在里面待5分钟才出来。哈。老师会延伸到红锁吗？太会了。

今天给你把红锁也讲完。踢了是吧？对，捣乱了就踢掉。大家都是来好好学习的。你要想听了就好好听，不想听了，你自己走就行了，就不要在这捣乱啊。好啦。😊，老师，我想问一下ZK的分布热锁情况下。

可以实现类似的看mon狗的功能吗？可以的。呃，这个Z一会儿到课程的后面，我给你说一下ZK的怎么实现啊。ZK其实呃它有它不叫看门狗，它叫临时节点，你给它连上，你给它连上它的临时节点就一直生效。

它就不需要看门狗，知道吧？一会儿到后面我会给大家讲，就讲到reice的缺点的时候，我给你讲ZK的时候，给你讲到这一点啊，你别着急。好了，然后程序起来，我把数据恢复一下。好了，代码删掉。然后再来进行压测。

好了，压瑟的时候他肯定走不完，为什么呢？因为我程序睡了5分钟。😊。

睡5分钟的情况下，看那条狗在不在。大家看一下这边的数字。这个22我圈住他。然后看一下啊，212030看到没有？它变到20的时候，它就增加增加到30、25、24、23、22、21、2030看到没有？

看到我圈州的这块了吗？好神奇是吧？先看先看结果，狗生效了，然后我把程序停掉。

别压了，因为我睡了5分钟。狗怎么做的？简单给大家看一眼狗怎么做的。chlock。点开点开。点开。点开。嗯，然后看这个schedule exp，renew，就看这个点进去。然后看到没有？

按照这个delay。一个时间除以3，这什么意思呢？大家大家看到我刚才演示的时候，就是我在我在这边演这边看看reice的时候，刚才看到的结果是这边是30秒，当它降到20秒的时候，又把它变到30秒。

你算一下。30除以3是不是等于10？就是说它往下降10秒的时候就降到了20，再给它续上。来，这块听清楚的敲个一。好啦。😊，那我们我们继续啊，然后这个是用reds做锁的一个例子代码的演示。我给大家说过了。

然后。

呃，说完这个之后，res还有这么一个问题。叫单节点故障。就是说呃你的业务来一台reli去加锁的时候，如果这台reis整个都挂掉了，你其他的业务再来加锁是加不上的。能能否懂。呃，如何判断需不需要过期？呃。

需不需要过期这么判断啊，就是说你不是你的主业务在执行吗？你的主业务执行的时候是不是设置了一个K1个V。比如说这写个V一吧，然后你的你又另外开启了一个线程，这个线程就去get那个key。

如果get的K等于V一，就说明你是你在执行。那么我把这个key给它延长。10秒就延长到30秒。是吧如果你主页执行完deelete的那个key，这个key就没有了。你在这块在get的时候，get不到。

所以这块也就不用延，也就不用去延时了。懂了吗？刚才问那个怎么get kid的同学。😡，是哪个同学问的，如何判断是不是早晨不起床？😊，早晨不起床懂了吗？我把你的问题回答完了。😊，哦，懂了是吧？

找着木地床好的。😊，那空的他还在get吗？因为你程序就程序就走完了，他就。😡，不再去执行他那个起的那个后台那个demon的项程了。知道吧？好了，狗不会死的，狗随着主人与主人共存晚。

因为狗和主人都在1个JM进城里。好了，我们说reice的单点故障。rease如果说有一台re，如果挂了之后，它就加不了锁怎么办？那么我们要用reisister。集群方案。知道吧？有re集群方案的话呢。

这么做集群一组。二从三少斌，我这里面就写了一个主，一个从。好吧，就是用两台reice之间做主存。主业务挂了，导致key一直在怎么说。😡，我我在前面课程已经说过了啊，那个这个知乐同学。

你可以找丨小丨姐姐要一下录播。来，这块大家记了么？为了避免reice的故单点故障，我引入了主存。这个。记住单点故障。但那故障就是一台热就子挂了。😡，怎么办？然后我引入多台，然后这多台之间做主存好了。

这块能清楚的同学敲个一，就是我为什么要做主从，为什么在此时要做这么一件事，把一台readd扩成多台redies好了，懂了是吧？懂了就继续，那做主从之间它还有问题吗？他还有他还有问题吗？

他的问题给大家解释一下啊。😊。

没有问题是吧，来。看这么一个reies主存的问题。你好，readdiness一主一从是吧？然后呢，一个服务过来加锁，然后呢加到了锁是吧？这边服务左边的服务加到了锁，然后呢，忽然之间。

这台relish挂了，就是这个master。挂掉了挂掉之前呢，数据还没同步到这边来，这边里面是空的空的空的。然后那么你说另外一个服务再进来的时候。它能否设置成功，能否加锁成功，因为它里面没T。

它能成功吗？不能。能。能啊当然能，因为它这里面没有key。没有key，就是key在这边还没有同步到这边来，这里面没key，我说的是没key的情况啊，没key，所以呢它就可以成功。

然后呢他俩加锁加锁加锁还有成功。那么。两个线程都拿到锁成功，是不是又会导致我们课程最开始的那个问题？多个县城拿到一把锁，导致超卖。卖出去俩库存少了俩，然后订单加了4，是不是又会导致那个问题？来。

这块理解了吧，这就是主存之做主存会有这么一个问题。O理解了吧。😊，好了，那理解了之后，我们怎么解决这个问题？😊，脑子里把这个词记住。单点故障，一会肯定有人会问这个单点故障，记住啊。的从机能写啥意思？

class好吧，它的问题我们分析一下原因，原因就是说它的数据没有同步没有同步给他。知道吧？所以我们又为了解决单点呃，避免单点故障，我们要用多个redis，但是多个redies又不能做集群。

那么我们怎么做，那就用reds，不用集群就好了。这是我们分析出来的啊。知道吧？😡，第一，为了避免单点故障，我们要用dotareies。dotare之间用主存同步的话会有问题，那么我们就不用主存同步。

怎么整？😡，这里面。😊，有一套解决方案叫红锁。

系列 6：P103：Redis红锁方案 - 马士兵学堂 - BV1RY4y1Q7DL

为什么叫红锁？😡，这个名字取的它本来其实它的本名叫radis。L。然后把意思给去掉了，所以叫readd lock，翻译成中文就叫红锁，知道吧？为什么叫红锁？懂了吧。

然后红锁的话给大家演示一下是怎么加的啊。😊。

5台元意思。这就是我们准备好的舞台readdies啊，这是readdis rais，它们之间没有数据同步，这是舞台独立的readdies。然后好了，业务来进行加锁，来了一个业务，然后先加锁的时候。

先在第一台redase加，你看它变绿的加锁成功。然后接着他去第二台reds加加锁成功，接着去第三台加加锁成功。😊，🤧超过一。超过一半，比如说5台它超过了三台，就算它加锁成功。来，这就是红锁的解决方案。

就这么简单。然后呢，这样的话另外一台服务来加锁的话，他去这个地方加锁肯定失败，去这加锁肯定失败，去这加锁肯定失败。去这加锁它可以成功去这加锁，它可以成功，但是它整体加锁还是失败。因为他只有两个没有过半。

知道吧？没有过半，所以加锁失败。谂不懂。挂了一个这个李亚问挂了一个怎么办？挂一个就挂一个呗，挂一个，他他又能怎么着挂一个。你比如说这这台挂了，挂一个，它加速成功，它加速成功，它加速成功。

那么它整体还是可以加速成功的。只要它超过5个的一半就可以成功，懂了吗？利啊。😊，5台readD之间没有主存关系吗？没有没有舞台readD之间没有主存关系。😡，为什么用这种方案？

就是为了要避免reice之间主从导致的数据同步的问题，所以它们之间没有半毛钱的关系，就是独立的reice。会不会出现同时请求一个readice情况下冲突的问题？这个呢如果说你就说这么情况，你看啊。

来两个请求，他加他他也加他，他加他，他也加他他加他，他也加他reies是单线程的，只能有一个来加速成功。比如说一个加速成功，那么他来加锁就不成功。然后他又加锁成功，他俩加锁又不成功，所以不存在。😊。

懂了吗？这不是耗性能吗？搞这么多台re。首先这个耗性能其实。也没有那么厚，因为reis本来操作就很快。第二。😊，性能和你的业务的正确性之间，这个你要做平衡，不能说因为因为怕耗性能，就让我的业务去出错。

能理解我这个意思吗？我要保证业务的一致性，哪怕我提升性能都可以。就像123061样，或者银行一样。我可以让你用的慢一点，但是我的数据绝对不能出错。12306，哪怕让你抢不到票。

我也不要让一个车厢多卖两张票。😡，懂了吗？Yeah。好了，红锁的解决方案就是这。😊，大家有什么问题可以问一下啊。😊，我觉得应该在在实际工作中，应该这块这块集中的问题会比较多一些。有问题了。

没问题就过了啊。有问题随便问。再减一面re的lock一个线程加三个锁，我都我都剪完了。你看啊5台reis呃，这里面加锁成功，这里面叫什么？这面加锁成功，只要有3台reis加锁成功。😊，他就是加的。

就是过半就加做成功。偶数咋办呀？来偶数正好给你说这个点，就是你们问问题的时候啊，就能把这些。你们需要注意的点全给问出来，偶数尽量不要用偶数，就像国家是吧，常那个最近比较火的那个老杨。是吧老杨是吧。

美国没有资格跟中国这么说话的老杨，他是一个什么人啊？是吧。常委。长尾有你见过有4个长尾，6个长位，有8个长尾的吗？啊，还有10个长尾的，你见过偶数的长尾的吗？你见过偶术哥的长尾吗？

所以这个系统是你自己来搭的，你就搭基数个就OK了。😡，这敢举例子，我又没说什么。我又没说什么，我就说常委是基数个的，怎么了？联合国五大联合国五大常任理事国也是基数个的。挂一台就是偶数了，哈哈。

莫名的笑点。首先挂一台，我程序启动的时候，在程序中就配5台。如果你挂一台的话，我程序认为的总数还是5台。大家看一下我的代码啊。

大家看一下我的代码。一台、两台、三台、四台、5台，我程序一启动，它就是5台。哪怕你挂一台。

这台挂了，我也认为它是5台，只要还存在的高于三台就能加锁成功。那要是剩俩呢，来进来这个人，我得把你拖进来。😡，这个利亚是吧，这个同学你啊首先我们为什么要用多台re是为了解决。单点故障呢。

单点故障就是因为一台挂了，业务实在没法搞，所以我要用多台。你还说我搞了5台又挂三台，那你这多台不白搞了吗？😡，知道吧？所以别忘了初心，我就知道有人会问这个问题，你就是要避免一个问题的。

结果你好像大多数都挂了。那这不是这个集群不是白搞了吗？😡，你就啦哇，你啊。就剩两台云养加速失败积木，你还没懂我刚才说的意思吗？就剩两台。😡，啊，你找多台，你你为了避免单点故障，你找了多台reies。

然后你还要让大多数reies都挂，你搞这个单点故障，你这个运维就该被开了。知道吧。如果如果你如果你这样如。如果不是。嗯，你懂是吧？懂了好了，刚才懂了吧？😊，你要想到你是为了解决什么问题的。

然后说我那个问题其实我不解决是吧？解决问题时我不解决它是吧？这没没没没必要啊。😡，好了，那么这个。三个机器怎么保证三个机器怎么保证都成功。首先三个机器啊，你看啊。给他的keyset成功，这台机器成功。

然后紧接着有一台成功之后，赶紧去另外一台也set，它又成功给它又set，它又成功。就是s NX执行完这个命令之后，成功不成功，你自己是你自己是知道的。然后呢，只要成功的数量超过三台，就算它加索成功。

懂了吗？三台加网锁后挂了一台锁呢。三台交管锁和挂一台锁，我一会给你解释，先把红锁的方案说完。紧接着我会就要说三台挂一台的问题。如果绿色的挂一台呢，好了，你们迫不及待，那我就开讲了。

本来想着在这块把你们的问题都答一答。你看你们问的这些问题，如果绿色挂一台呢，马上讲，还有刚才三台挂一台呢，马上讲好了。😊，都集中在我后面要讲的问题，你们太聪明了。好吧，接着讲红锁的问题。中间这地址挂了。

怎么整来看着啊。😡，5台ed紧接着加锁，这个业务来了，给他加锁。好了，这个成功，然后这个成功。😊，加锁成功，这个加锁成功，现在有三台relis，看绿颜色的，三台res都加锁成功。

那么我这个业务的线程是不是加锁成功？那么此时就像刚才那些同学问的那些问题。绿的readies挂了。好了，这台挂了。😡，这台redis挂了，你别管他怎么挂的，反正硬盘硬盘丢了，机房爆炸了，被水冲了。

反正数据没了。运维哥哥很勤快，又搞了一台redis上来。这台reis里面你原来不是 set了 key值吗？😡，你原来不是 set载了K值吗？现在呢K值没了，变空了，我还用个白色的来表示，就是里面空了。

然后呢，紧接着另外一个线程又进来，用另外一个业务又进来加锁。你说这个业务他来之后，他去他家能加上吗？此时他能否加上。😡，加不上去他家也加不上去他家能否加上？去他家成功。去他家成功。去他家。成功，然后又。

成功，然后又回到了我们最开始的问题，两个县程拿到了。同一把锁又会造成了。超卖。这字写的有点飘逸，好了，懂了吗？用红锁，你依然会造成超卖。理解了吧。不知道挂了还能成功吗？这不是给你给你说。

他又会造成超卖吗？虽然说多卖一个没事儿，但是对程序员是吧，伤害不大，侮辱性、侮辱性极强是吧？这是侮辱程序员的一件事儿。😊，为啥还没懂吗？神雕大侠。😡，Yeah。第三开不是挂了吗？怎么加锁成功的？😡。

你不好好听课。竖起你的耳朵好好听哦，我现在再给你重新说一遍。第三台挂了，我说的是你的运维哥哥又起了一台。😡，一台空白的赶紧起来，因为很积极。就因为做了自动化。是吧111一挂马上起一挂马上起。😡。

所以就会导导致后面又加锁成功了。来这块听懂的同学敲个一。手噶。好，懂了是吧？那这个问题如何解决呢？就是解决问题的时候，我们要分析问题产生的原因，产生的原因是什么呀？原因就是因为。😊，运维太勤快了。

这块起的太快了，还没等这个程序执行完，或者说这里面的锁都过期，它就起来了。导致这个程序一一来拿到了锁，就是两个程序都拿着一都拿着同样的所在执行业务就超卖了。所以这个reies如果运维要启的话。

要么等这个业务执行完，要么等这边的锁全过期。OK懂了吗？所以这个里面在你的部署方案里，你要用红锁的话，你告诉你的运维哥哥要延迟启动是吧？哪怕延迟一天都可以。😊，把约费关小黑屋是吗？程序员的天敌有很多种。

有产品，有测试，有运维。还有boss是吧，程序员啊。Yeah。对，隔隔隔一段时间再起，哪怕就写上24小时之后再重启，就是这几台挂了，24小时之后就是这5台燃D嘴挂了不要紧，你别起早了，起早了会出问题。

就是挂了时间长了时间长一会儿没有问题。😊，程序员全是天敌，程序员是所有人的天敌是吧？好吧，这块听懂的同学。😊，敲个一。基本上reies的锁都给你们已经讲清楚了吧，喝口水啊，让老师喝口水。😊，好了。

到这之后，大家觉得这个。这个方案就特别完美了吗？嗯。😊，讲清楚了，不知道怎么写代码，代码给你代码都已经写好了。你们刚才没看到我的配置吗？😡，红锁真强好了，stop。然后红色。

怎么做延迟启动都已经给你说清楚了。好了，接下来要给大家再说红锁的另外一个问题。好啦。😊，然后我把这个问题呢抽象一下，就是这个JVM呢，就是说所有的程序，你别管是一一个服务，两个服务还是三个服务。

它就是多个服务。然后这个reice，你别管他这一个reies还是多个人的，我就当它是一或多个reies。😡，我抽象成这两个概念，然后呢。在java里面有这么一个概念，就是说你程序在执行时候。

你锁也加上了狗也开始不停的给它续期，一切看似很美好。然后呢。java里面有这么一件有这么一件事情。叫stop the world。嗯top。日。😔，Word。在负JC的时候。会有stop world。

当stop the world发生的时候。狗这个续期就是你家狗狗也被冻住了，就是整个世界都stop了，你的狗也冻住了。你的狗冻住之后，这个key是不是会慢慢的过期？是吧然后这里面就没有key了。然后呢。

另外1个JVM进程又来了，它没有key，他来加锁能否成功。😡，能是吧能成功之后他加成功了。然后这边呢stop word它没了，又开始start正常执行业务了。你说是不是？他他在同时执行。

同时拿到了所在执行业务。来这块听懂的同学，你敲个一。又超卖了是吧，你看大家都懂了，不用我说又懂了。😡，那么此时。要封了是吗？没事，到时都快快好了，马上就让你不封，马上把你拉回来。😡，好吧。

那么此时这个问题怎么解决？这个问题怎么解决？class那冒出class class不就是集群吗？😡，好了，这个问题的原因就是第一，readdis的 key会过期。第二。

用GVM会有stop word发生。只要它ki会过期，它就stop the word，那么它就会发生刚才的问题。🤧Okay。那么怎么解决？你让reis keep过期了吗？

你让这JM不发生stop the world吗？no，你都干不了。😡，你都干不了的情况下，在负J4的时候会发生stop the world呀，你都干不了的情况下，只有去换掉它。😡。

那你说是把res换掉呢，还是把JVM换掉呢？换哪个？如果你要换它的话是吧？找一个没有stop word的语言去写是吗？你的代码是不是改动量很大？换redice是吧？换redice的话，你换什么呀？😡。

用阿里的reis。阿里的readdis它也是reis用ZK是吗？有的同学说用ZK用ZK就没有这个问题了吗？😊，用ZK用ZK的话，一般我们都用临时节点做分布制锁。

临时节点的话是靠心跳去保持stop the world的话，心跳也没了，所以这个节点又挂了。知道吧？所以换ZK。也有问题。那如何解决呢？没想到转语没想到转语言是因为一条狗，哈哈西塔怎么能冒出西塔？天哪。

你们这都什么来想一会儿想一会儿怎么解决。😊，来，想想这就课让大家把这个把这个知识点都彻彻底底搞搞懂了。崩了放弃，别放弃。手写如keeper鸵鸟算法。哎，默默，我喜欢你这个词。陌陌。我喜欢你这个词啊。

鸵鸟算法。就这个到就是问题，如果你能跟你能跟如果你在面试中能达到这一步，你已经很优秀了。😡。

然后刚才有人说鸵鸟算法，我们先看一下鸵鸟算法是什么。因为这个问题太罕见了。鸵鸟算法解决什么问题了？看百度百科。这都没有百度百科呢怎么。好啦。鸵鸟算法。在计算机科学中。

鸵鸟算法是一个忽略潜在问题的一种算法策略。这种策略对计算机程序可能出现的问题。可能出现的问题，采取无视态度，类似于鸵鸟在遇到危险时间头埋在地里，假装看不见是吧？就是有这个问题了，我假装没有不解决了。

知道吧？有这个这还是在计算机科学里。😊，就是有这么个算法，知道吧？然后呢，这个问题使用的前提就是问题出现的概率极低，对吧？那有个前提啊，问题出现的概率极低。靠还有为什么高深的东西，你别着急。

我给你把这个解决掉啊，鸵鸟算法是一种。好多人都这么解决，都忽视。因为这个stop world太不常见了，可能你开发代码一辈子到80多岁，就算你80岁不退休，你在生产环境中也。😊，也遇不到这种问题。

一般面试官也问问到这也就差不多了。好了，但是呢作为老师很既然你都来了，很负责任，我们是马志敏教育，但是肯定给你把这个问题给你解决掉，不能让你是吧？遇到问题逃避，知道吧？要积极的面对人生，那叫什么来着？

😊。

刚产生的问题没听明白。你哪个问题没明白，你到时候打出来呀。😡，好啦。给大家说解决这个问题。解决这个问题给你解决马世频教育什么问题都能给你解决掉。好了。😊，为什么遇不到负为什么遇不到f负来来来好了。

拉收收收别讨论这个问题了啊，可以讨论fJC是可能遇到的吧，是可能遇到的哥哥，我刚才跟你说了，可能遇到它，只不过是遇到它的概率极低，知道吧？我没有说你说的不对啊，只是说这个问题概率极低，你可以忽略它。

采用鸵鸟算法忽略它。但是呢老师给你讲的，讲讲一下怎么用它。😊，好啦。😊，回来回来回来收怎么解决这个问题？😡，还是用ZK。是吧刚才同学说了，老师说了，用ZK不行。😊。

因为sstock the world之后，它跟ZK的连接也断了。好了，那怎么解决？😊，在加锁的时候返回一个序号。ZK临时节点有序号。number比如说加了个number one，然后加到序号之后。

再配合一个ready呃，配合一个my circlecle。mycircle中加一行记录，这行记录里面有个wason。等于一第一这里面有两步，第一步去ZK拿临时节点。第二步，拿到临时节点之后，把它s到。

数据库里这是一行记录，我省是一这个一对应于这个临时节点。好了，此时哪怕它stop the world了。狗狗停了ZK的临时节点，一号临时节点过期了无所谓。另外一个程序再来。

它拿到的是几号节点回答我的问题。怎么还是一这个reies不是roki学的不合格啊，这个le啊去找丨小丨姐姐要一份roki啊，好多同学说二是吧，他拿到的是2号节点，2号节点，他拿到了2号节点，他去。😊。

更新这条也插这么一条数据，把这个version变成了2，它拿到了2号节点。然后这边star the world，哪怕他世界重启了，它去数据库执行业务的时候，它update数据的时候，它加一个Y条件。

Y are version等于我这边加的number one。此时发现version已经变成了2，所以我。执行失败，因为不是我家的锁了，说明我当时昏过去了，被别人抢了，那么不是我了。😡，懂了吗？

此事就解决了。😡，res和JVM的所有的恩怨情仇。懂了吗？

总结一下方案其实很简单。

系列 6：P104：如何在双十一大促中提升分布式锁性能 - 马士兵学堂 - BV1RY4y1Q7DL

诶y。就是如keeper加mysl的乐光锁。再讲一遍可以吗？可以。再讲一遍啊。最后一遍啊ZK。一号县城。来拿锁拿一号节点。然后呢，把一号节点存在数据库里，数据库有个字段叫一。然后呢。

stop the word之后。他不续期了，然后一号节点没了，然后2号线程进来，他拿了一个节点是2，然后他去把这个数据库这行记录改成2，说明他拿到锁了。然后呢，这边star the word之后。

他要去执行往下执行业务的时候呢，我们都加一个判断where条件where啊version是不是等于我这边加的。第一个节点，一号节点。如果是，那么说明是我的锁正常执行。如果不是，说明有别人来执行，我就。

退出。懂了吧？sweet有点甜。我觉得我说的很清楚了。呃，reis加UUID是不是也能也能解决锁得这个问题？呃，如果你用redis加UUUID的话，你只你那个key，你看啊。

我们用为什么用ZK是因为ZK的这个节点，它有序号。你用reis的 key的话，你仔细想一下key里面的value只是UUID你用UUID能解决它的key，它的key会有序号吗？你仔细思考，你慢慢知乐。

你慢慢的品这个问题，它的key没有序号，你把reis的什么东西存到数据库里。😡，开始执行产生的问题更能讲一遍吗？我要上头条ss word又之后 store什么意思啊，没懂。好了。

这块问题老师说清楚的同学敲个一。就说面试的时候，如果你能达到这个地步，那么你已经你已经。已经很很厉害了，但是是。为什么stop会引起所失效后？那个神雕侠侣stop之后，他也不续期了，就是说他也不去续期。

所以所会失效。好啦。😊，比如说ZK和数据库没有reies效率高吧，是没有reies效率高。就是说呃。😊，效率和数据的正确性方面，你要做平衡。就你在公司设计架构的时候，这块你要你要做平衡。懂吗？

对show word引起com门狗不续期。好了，我说一下实际工作中怎么用啊，实际工作中其实这块的用法呢，好多公司就用一台reis做的。这个你们就用一台relish，也没有做主从，也没有做红锁够。

包括某个大公司。他的某个挺大的业务，每天的交易交易额差不多上亿的业务，他也用一台reis做。啊，说为什么用一台，人家就觉得这一台reice它能保证不挂。😡，知道不？😡，人家就能保证不挂。

所以就用一台是吧？他的队友很厉害，我相信队友。其实好多公司啊，你别看今天我解的我今天我讲的方案特别全，但是好多公司呢你没必要用这么多方案，你就选一个readit book。为什么就怎么怎么做这件事呢？

你比如说你这是你公司。😊，你买个阿里云的res。如果rey挂了是吧？那是阿里云挂，那是阿里云的事。我们公司的业务正常，只不过是阿里云挂了。你别别以为我是在开玩笑。😡，不要以为我是在开玩笑。

好多公司都这么干，包括好多独角兽公司，我就不说名字了，特别特别多，因为这么干都能上头条。嗯。对，那个不说不那个收啊，为什么为什么说这件事呢？😡，就是在2019年3月份的时候。

有好多公司运维大半夜三四点去公司加班，这个事情你们知道吗？但家都上头条了。第二天早上一醒来，新闻上全是这件事儿，好多运维，好多独角兽公司的运维去知道是吧？你看有的有的人知教知道这么一件事是吧？

说明2019年是吧？这个人知道叫什么包着你包着你，说明你2019年你出生了是吧？

知道是吧？你看好多人都知道你也去加哎小宋，你也去加班了，是吗？😊。

这个这个当时应该在当时轰动挺大的啊。呃，从从那个事说明什么事呢？好多人用阿里云的就全部依赖阿里云，就自己都不做plan B。自己都没有plan币，知道吧？一些独角兽是吧，估值过百亿的公司都这么干。

你是吧？你在小公司有什么理由不可这么干呢？所以。无所谓了。可以吧，实际生产中怎么怎么简单，怎么方便，怎么搞。知道吧？没必要考虑特别全。是吧马老师说过，马世斌老师说过，追求完美是一种人格缺陷，是吧？

所以在工在工作中啊没必要用这么多。今天跟你说这么多呢，是为了让你去。是吧跟面试官怼的是吧？面试如果你能回答到这儿，OK这个问题你你无敌了。😊，主要是没钱找牛人，我记得是腾讯云出问题以后，工司都倒闭了。

我跟你说，哎呀，你看你这个你这个同学遇到的这个问题，我原来也遇到过，我跟你说，原来我不是黑哪家公司啊，就是只能说他们最开始哦就是慢慢就是所有的人都有所有的公司其实都有个眼进的过程。

就你像阿里最开始做淘宝的时候，2003年的时候，淘宝不也就台。

你你拿linux做了一个程序，前面加了个NG，然后后面两台服务器，然后后面一个主买Crcle做了一台从，不就这么搞起来的吗？你知道吧？所以就是最开始也是这么搞。

你说如果是这个架构到现在他能扛的这么扛不住，他也是1。1点发展起来的。最开始我们用腾讯云的时候，呃，最在2015年我用腾讯云的时候，有一件事，就是那天也是也是一个夜深人静的晚上。

结果发现呃我们的服务挂了。😊，服务挂了之后，我我就去看嘛，看服务，结果发现磁盘的数据全没了，然后给腾讯打电话，腾讯说。那个宿主机的硬盘坏了。是吧然后给我们免了免了免了送了我们一年的腾讯云的服务器。

是吧这个事儿就算过去了。知道吧？所起。Nin。刚才那个是吧，你说你出问题，我你你这还倒闭了是吧？腾腾讯员出问题，你公司还倒闭了，我我们这没倒闭，还好。😊。

好啦，今天说的这个就今天给大家讲的这段课，呃，这些课呢简单总结一下啊，就是说从一个呃最开始的一台服务器。😊，然后呢，到多台服务器，就一台服务器加锁很简单，多台服务器加锁呢就用分布式锁。

然后分布式锁一点小小一点的项目，你可以用mycircle，然后大一点的你用redisreis呢我们讲了从单节点的redies到主从redis，然后最后到红锁是吧？

然后红锁给大家讲了红锁的方案就里面的延迟启动呀，由于GMJM的fo这些导致stop word，我也给大家讲了，然后stop word怎么解决呢？要么换GM要么换reis是吧？

然后我们选择换掉redis用ZK。😊，然后用ZK之后呢，再加上买s口的乐光锁，就把这件事给搞定了。这就是这节课关于这个基数点的所有的问题，你大家。怎么样？有收获吗？有收获的敲个一敲个一。

我们我们聊聊一点别的，再可以聊聊其他的。好了，这个这个课呢我记得从头到尾都给大家讲清楚了。好了。就是这个课是我们众多课程里面的那么一点点，老师花上20分钟给大家介绍一下我们的课程。好吧，介绍我们的课程。

我们再聊怎么面试O。就是今天讲的这个锁呢是是我们在呃我我讲的一个课，是在我们的网约车，就我们有个项目叫网约车项目。就是我刚才在前面给大家演示的这个。

就这个这个项目。这就这这是一个实际中运上线运营的项目。我我呢就在课程的课程里面带的是这个项目，就这个项目的解决方案里面呢，就有红锁这么一个就有分布式锁这么一个东西。

然后这个东西就是我今天给大家聊了有一个半小时。但是我在我们的课上呢讲了差不多有4到6个小时，就是关于分布日锁这一块。然后除了分布日锁，就是这个项目里面，它还有分布式事务。

还有怎么提升你的QPS怎么减少你的响应时间。大家可稍等一下，我打开课程大课程大纲给大家看一眼。就在这个这个项目中，就是项目怎么启动人员怎么分配，接口怎么设计等等等等。所有所有所有的。

你在实际中能遇到的问题呢，都在项目里讲，包括什么灰度发布呀、狼力发布呀、滚动发布呀、分布式事物呀，然后还有动态路由等等等等。就你在工程中能遇到的所有的问题，我们这个课里都有稍等一下啊，你看这个。

课程内容比较多，插慢的打开都比较慢。因为我这机器配置已经非常非常高了，减少QPS是提升QPS减少响应时间。ZMTD这个这个同学。我再回答你的问题啊。是提升QPS。减少响应时间，缩小一下。

这是我们MC架构师的呃，这这个是。我们MC架构师的课，这叫这个MC什么呀？马士斌cerfactor architecture叫马士兵认证的架构师。

然后我跟才说的这些内容呢是我们这个项目里面的网约网约车项目。然后我们现在叫飞机出行。然后呢，这里面从项目怎么启动？人员怎么安排，需求怎么分析，然后怎么设计，就是设计的一些原则，你该注意什么。

这个项目里面都有，然后服务怎么拆分，就是说还有接口怎么设计，你怎么保证你的接口的安全？还有中台就是怎么怎么做中台这个项目里面都有。然后异常的包装异常怎么处理，然后呢，就是怎么提升QPS。

怎么减少响应的时间是吧？就是刚才我跟大家提到过的啊，然后还有业务，就是整个项目的业务是怎么做的？我都给大家把主要的业务的时序，就接口交互的时序图给大家画出来。然后还有后就是就是后面因为我这是网约车嘛。

就是司机跟乘客他们之间要进行交互。嗯。我可以给大家演示一个例子吧，我直接跑代码吧，可以吗？大家有有没有想想想我我跑跑代码吧，好不好？😡，给你跑一下网源上的代码就OK了。😊，这个。很快，等一下啊。

给你跑一下。启动。然后呢，我拿俩浏览器给大家看看。嗯。看一下网约车什么样子的是吧？然后这是一这这这个是一个浏览器啊，这代表乘客端。😊，这个代表时机短。乘客司机。好吧，这是两个端。把它摆好啊。

这代表两个手机啊。😊，好了。😊，然后呢，输入一个乘客的地址。好了，这是乘客打开的一个界面，是不是特别很像那个德德。😊，把它缩小一下啊，大家看不见下面的好吧，缩小了。然后呢，司机也缩小一下，把司机也打开。

司机。系啦。😊，好了，就是司机你要打车之前，司机得先上线是吧？司机开始工作出车是吧？然后乘客呢选地址，我们在这个选一个地方，川荣府鸡蛋灌美吗，还是选哪？呃，学院餐厅邮电邮大邮电大学的吧。好了。

我们从这是吧，这是我们隔壁啊，定位定到我们我们在文教园是吧，点呼叫。😊，哎，你看从文教园到。邮邮电大学接单司机接单了是吧？然后司机开着车去去到达预定地点，然后呢，接到乘客，然后就拉着乘客走嘛，是吧？

乘两边一个车在跑呜呜呜，然后是吧，到达那个目的地。😊。

到达目的地之后是吧？然后22块钱你给吧，然后司机发你收款，乘客调取微信或者支付宝的SDK已付款。好了，司机收款成功OK。😊。

over。是吧这就是网源上的整个业务。好了，我把这块先先停了啊，我让车系统先停了。😊，牛是吧，应该是不是得刷刷一波鲜花？是吧这就是我我在那个我们课上实际讲的一个项目。然后这个项目有什么好处呢？就是。😊。

我原来有好多学生，他一直做的是那种传统的项目，甚至他没有工作经验，然后拿着我的网约车项目，他就可以就原来找工作特别不好找，是因为项目不行，公司不行，做外包的，然后一直做传统项目做CRUD的。

没有经历过微服务高并发项目的，拿着这个项目找到的工作，还有一些应届生，应届生大学毕业，你想想，他就压根没做过项目，去公司面试是拿不到高的薪水的。但是我们这我有一个学生，他学我们的他学我们的项目。

学完之后直接拿了一个应届毕业生，大学本科拿了个22K的。薪水。我给你看一下啊，这是我在我的。微信里。嗯，这个这个孩子叫许。好了，我给你看一下他我们我和他的聊天。😊，好了，没有露出隐私吧。好了好了好了。

你看一下这是一个应届生。😊，他学项目怎么学？他。好啦，你看啊。😊，这是这是问派单派单的业务逻辑，他问了好多，你看还列12怎么问怎么问怎么问，然后我又给他回答，然后呢，又问这个怎么怎么，我又给他回答。

然后又问这个不停的问怎么回答，他为什么不停的问，因为他是。😡，他是一个应届生，压根没做过业务。你看12月9号，你看一直问，然后一直回12月10号，你看项目有啥亮点，我又给他回，然后呢。

什么优注册中心优化怎么做，我又给他回。然后一其他的一些困难又怎么回。然后再麻烦老师再麻烦问几个问题吗？项目的盈利点是什么？定制化的人怎么计中计价中算法是怎么样的，等等等等等等。我又给他回。😊。

12月10号回回回又问你看又这个不明白，定制化服务不明白，怎么着，我又给他回懂了，谢谢老师。然后又是计价的时候一。😊，11号又开始问怎么回怎么回怎么回。老师，我想问问当时服务器数量多少呀？😊。

为什么他这么问，因为他就压根儿没做过项目，然后我给他回，他说啊，好了好了，他说并发量多少啊，司机数量多少啊，又开始问又怎么回。然后最后说感谢你看27号了，都从12月初到12月底，感谢老师这段时间的解答。

这周找到工作了。😊，开了21K，我这厉害。是吧说老师指导的好，主要是他他问的东西啊，也真的是他自己就是花心思去琢磨。然后呢，就是我也能给他就是把他那个他不知道的点给他说清楚，他没做过项目，让他理解的。

实际中项目是怎么做的，然后里面会遇到一些什么样的坑，然后给他说，然后我就问他原来薪水多少。他说今年刚毕业。包装了一下才有这么高。这是这哪年2020年的12月27号，他是2020年的7月份毕业的。

当时毕业之后找不到工作，然后报了我们的课程，报了我们课程之后，学了5个月差不多，然后呢就拿了21K。你说他值不值？一个大学毕业生。太能吹了，我这这是吹了吗？我这是事实。你好啊。后面还有一个。

当时我上上课的时候。上课的时候呢。那个有一个还有一个小孩知道也这个小孩也是个应届生，然后他说跟这哥们交流交流，我说可以，你们都是VIP是吧？我说有个同学想有个同学想找你取取经，你方便和他聊聊吗？他说没。

等下班了，直实他说他很菜是吧？还谦虚一下，我说没问题。然后你看他下班了还告诉我老下班了，老师微信聊了吗？后来我就直接给他拉了群，就就OK了。😊，这样过不了实习期，在你们在你们平安。呃，为什么？

首先说明一点啊，为什么过不了为什么过不了实习期？是因为实际中的问题你解决不了。你想想这个问题是不是？如果说有那么一群老师在你的实习期在给你保驾护航呢，是吧？有什么问题来问问老师。

是吧老师该老师我该怎么做这个方案该怎么做？我遇到什么问题了，该怎么解决？一堆的老师，220多个老师。😊，从前到后有微服务的，有中间件的，有有源码的，有java基础的，有云原生的，有测试的等等等等。

一堆老师。都可以回答你的问题。你还过不了实习期吗？如果如果是试用期吗，你如果如果你说再再再过不了，那真的没办法了。一群人在后面顶着你20多个全是大厂下来的老师。😡，应届生凭啥过不去实习期，社长有可能。

首先不是我是回答那个同学的问题嘛。首先啊就是他学了我们的课，就是我这个项目里面我这个项目里面讲的这些东西，如果都学了，都不用说过实习期了。😡，就就算你直接去上手开发一个微服务项目都没问题。

你看我当时讲那个分布式事务都讲了20个小时，就你把我这些课全听完，你就像我今天讲的这个分布日所一样，你把你今天你把我今天的这个课学了，你觉得你在你工作中，就是遇到分遇到分布日所的问题，你解决不了吗？

然后我还给你全套的代码，还给你全套的代码，代码都给你。然后我这代码写的呢，又直接让你能套你的业务，你怎么套你的业务点开。😡，点开这个service，就是你公司自己的业务。点进去就你的业务逻辑。

外面我都给你全给你分装好了，你直接拿到公司就能用，脑子都不用动。😡。

开发都是CRUD。太多了，什么时候学完？我们的课程确实挺多的，你。首先给你说一下，我们今天的这个课。刚才大哥只看了一点点啊，我们课里有什么包含哪些内容？

我们这门就是MC课程里呢有P5就业班P6崭新课、P7架构班、P8精行课，还有源马课、云原生服务网格等等这些课一堆的课都在MC里。如果你要单买的话，每一门都在79010多项目实战我讲的16000是吧？

还是最贵的课。然后呢。

MC里全包括这些。然后今天呢今天有一个活动。

今天的活动原价是。23980，这是腾讯课堂的啊，这是腾讯课堂的原价23980，在直播间优惠20个名额，13980。

系列 6：P107：redis、kafka、es、hbase等技术技术选型总结 - 马士兵学堂 - BV1RY4y1Q7DL

乘以100。对吧那好，这个如果能听懂我们延伸到什么地方去啊，做架构的时候，注意听，在你做这种架构，做三高系统的时候。很多人都说三高三高三高。🤧三高的话刚才给出好多词，什么高并发、高性能、高扩展、高可用。

这都不止三个高好多高。但是这里面有一个核心的点。整个架构当中，你最后最后存数据的地方，注意啊，其实无论你是做单体还是做架构，数据，是最终的有价值有意义的东西。数据之外的都其实可以成为函数方法或者是服务。

那些东西其实是一种可以理解为单立的，可以为理解为可云可弹性的。听懂听不懂，不要怕。往这看，如果前面有服务。那这时候其实还有客户端请求。那么到数据库粘数据的时候，像刚才说了，欧N复杂度这个这个成本很高。

那数据库的操作也是会很慢的。我们不应该把什么呀？无效请求打到数据库上。我们不应该把无效的请求，为什么？因为这个数据库一秒钟如果支持100次查询，注意听。100次每秒钟的一个查询。

那这时候如果你把无效的请求的50次传过来了，那么你只能有它还能只能承担50个有效请求。那但是前面你还积压着好几百个有效请求，就被你有效有有效请求被被被拖慢了。

但是这时候如果注意听你用了一个readdies。在ready当中，我们用了这种二进制的这种字节的。这种布能过滤器。那么这个时候其实你再大的请求进来之后，先不透传到DB，而是通过我们的reis布能过滤器。

通过刚才那个焊线函数拿这个这个字节空间这个这个事情做一个比对，把无效请求给它过滤掉。那么这个时候再到达数据库的，就是精准的一定有数据的就可以放过来了。也不是精准的，有有有有有数据的。

就是它会放过一就是因为因为它不能过滤器，说数据库有不一定百分百有，但是说没有是不是一定一一定没有说有，但是这个事儿你得思考是不是呢？但是不能过滤器告诉你这个请求说，数据库里边没有没有是不是一定精准的。

就根据刚才这得出结论，就是过滤无效请求是一定精准的。😡，就一定会把无效请求过滤掉。但是还有一部分请求是不能过滤器hold不住的，因为碰撞成一了。那么这时候说有了，但是这个又里边比如说刚才所所说的。

它只能接受100个请求，那这个时候就会明显降低到什么呀？曾经可能有50个无效的那现在可能变成了4个无效。然后96个有效的。因为布鲁模具说有这事儿碰撞这事儿是一个概率的问题了。所以如何降低这个损耗。

这个误差，其实在这加函数就可以了。函数越多，这个宽度越宽，牺牲的空间再大一点。那么这时候可以降低无效请求的放这个这个这个这个风这个。这个通行率对不对？计算越慢OK有这个想法真的很屌了。

已经你已经你已经知道这种线性增长的这个这个这个事情了。但是线性增长一般要和我后边说的分制挂上钩了，前面这块都能听懂了吧。那么这时候注意听。当你能得出前面这个结论之后，我们随着函数越多，字节空间越来越大。

体积越来越大，计算的函数越多。那么每笔就是它就注意看啊这个位置不容过不容过滤器的增长，它越增长，它会什么呀？让这个的ON请求复杂度就是每一个请求。都会变慢一点。每个请求都会变变慢，这个能听懂出来刷一。

这这都是理论知识啊。其实你没做过，没见没借触过三高系统，没去过BAT这都听懂。就是如果你把一个东西，它本来就一个函数两个函数两调两个函数可以计算完的事情。你让调10个函数调10个函数。然后呢。

本来是可以在这个这个几百几百K变成几十兆几百兆。那这个整体的每一个请求因为做到组时先判断一下，整体的每个人都会变慢，对不对？但是在真正的互联网解决三高的时候，其实最核心的就是后边其实要讲的。

我现在前置了解决这个问题应该怎么解决，尽量的做到是一个什么呀？哎我用一个波龙过滤器两个可不可以。😊，对不对？我用一个服务，两个服务可不可以？我将请求给他分摊分摊，可不可以？对不对？然后做一些规则上去。

比如说做上每种布能步滤器，因为这个其实到这儿，首先这叫分制了。我是不是两个reis里边各包含了，我把它扯扯一半出来。是不是可扯一半出来，把这个帮一撅撅一半出来。但是这个东西是注意听啊，这个东西叫做分制。

😡，跟着我速度走，我现在我现在把你我明确告诉你，我现在把你往坑里带嘛，跟着我的速度走，这是不是要分制了。😡，但是告诉我，我现在这个模型里边存在什么问题，到底真的分支了吗？性能真的降低了吗？

反而还是说反而变高了。😡，回答我。这个过程很自激。😡，能跟着思路吧，就是我本来在re个一个reit里边放了一个布隆路理器，我把它剪剪掉一半，这边放到前半拉，这边放到后半放到后半拉。

那这时候我准备两台服务器，你高并发的话，一部分并发走置，一部分并发走置，能把请求是不是分开了。那这时候理论上看那个图来说的话，是不是请求就这边请求就访问他，这边请求就访问它。这边的请求需要访问它吗？😡。

需要仿他吗？需要还是不需要？😡，Yeah。有需要有不需要需要和不需要取决于另外一个词汇。当你只是做了分而置之，那么其实并不能像你们在网上看的说性能会提升，反而下降。为啥你缺了另外一个至关重要的词汇。

就是路由加索引。就路由啊锁引啊。等等巴拉拉一些词汇。什么意思？如果只做分制的话，其实你把它东西分开了。但是你如果查那边的话，又考虑那边是不是是不是应该在那边，你是不是不知道应该一个请求应该去哪儿去判断。

对不对？😡，你说要把两个分制全部走一遍，是不是还是ON的？😡，还是那个全亮的，而且这次还有两次IO通信了，两次网络连接了，对不对？😡，到这儿能接受同学来刷波一。所以只有分制的话。

往往你这个架构设计的是有问题的。你看你学过的任何的技术，其实都会有一个分制，只是一种结构存把它分开了，隔离了。但是外边都得挂一个什么如索引能够区分。比如说我们确定啊这边不能过滤器里边。

就是那些个商品的ID从0到1万的，这是1001到1001到2万的，你加了这么一个索引了，每一个请求过来之后，我这个东西是在哪个区间里，我只需要连谁。那个东西我绝对不需要碰减少一次请求。😡。

就是每一个请求都不是两边都扫了。那这这个时候才真的可以做到什么呀？分开听同学来敲包666。😡，是吧其实这个思想你慢慢的放大放大放大，可以套在什么秒杀系统啊，红包啊，那什么什么位置都可以套收。

那这个其实想的有点早了。我本来是想顺滑的去引出啊，往下聊，因为聊太多了，收回来啊，这这这块惊验了一下，咱们收回来了。那回到原点上开始这个列表查找的话，那么我们我们来说布伦不离器能符合我这个开始的问题吗。

是不是不符合。因为你在布隆过滤器想使用的时候，还得开辟空间，还得又不精确。最终有一部分请求还得推回到欧N复杂度。所以其实。不对啊，这些回答都是不对的。

都因为都要在现有的一个基础这个数据结构之上再去开辟数据结构，对不对？哎，O收那么怎么办呢？还没有其他的方式注意听啊，下边的跟着我的思路走了，已经已经已经这个这个这个这个露馅了。

已经这个这个这个跟这个这个叫什么剧透了，那我就直接快速讲了。其实如果上边一万个元素是ONO1万很复很复杂的话，那注意跟着个思路走，链太长了，一万个好难，那我可不可以做这么一件事情，跟着我的思路走啊。😊。

场景什么的不容易过滤器给你讲完了，差不多了，你就先跟着我思路往下还有好多知识。那么我的链表如果只有4个宽度，一个链表，两个链表、三个列表、四个列表，5个列表。那要存现1万个元素的话。

我只需要准备2500个列表。到这儿能接受吧？我只需要准备2500个列表，每个列表4个4个宽度，那我就能存现这1万个元素。那这个时候一看这个现象叫什么呀？这是不是就分而制制了，就隔离了，隔离开了。

把数据是不是打散了，四个4个四个这么装成4个桶了。那这个装完之后，请请回答我性能速度有没有提升，就是做了分支之后，速度是否提升。😊，回答有的我告诉你回答有的，你给我站着，你别走。我刚才讲了半天。

尺脖子长了半天。😡，你听什么呢？😡，呵。你如果只是把它们分制分开了，我现在问你一个问题，查找一个X，你要怎么去做，你是不是拿X从第一个链，虽然这长度是4个变量完，你能确定它有吗？

这个机子里边是拍的第二个链，第三个链有可能是最后一个链的，最后一个元素，它依然是1个ON的复杂度。😡，所以只做分置，只做隔离并不能做到一个真正的提速，还缺个什么东西，缺一个路由缩引。路由索引。什么意思？

就像刚才举一个例子一样，如果查找一个元素，只确定其中的某一个链，就像刚才使用这个把布隆科器的拆解的时候，我只需要知道连某一个re用一半的这种布隆，我就不用碰另外一个布隆。那这时候性能是有提升的。

能能能挂上关系吧。所以这时候其实你差的什么？还是差路由所引映射这一类名词代表的这个这个逻辑。那这是怎么怎么实现的？注意看，首先就2万两2500个列，那你是要扭出2500个变量吗？能不能用一个变量持有。

哎，你准备一个数组数度下标这个数组的宽度是2500。那你数组速循环的时候，循环到下标为零的时候，有一个列表，四个元素帮引引上了下标为一的时候，再引一个链，下标为2，再引一个链。

那这时候有一个数组就持有了所有的链。那这时候跟着速度走啊，X你要做一件事情，我哈希。Yeah。哈奇是个应用算法，对不对？嗯，哈奇 code的应用算法得到了一个数值。😊。

这个算法可以帮我得到一个映射的一个数值。这个数值我在哈西这个，然后再取膜膜上2500。就是取余的取余数这个过程。那么取模取余的一个特这个这个计算的特征就是。取完那个结果，那个余数值是什么呀？

是这个你磨的这个数的，从0到2499，就是N减一的这个区间之内的某一个值。比如摩安的纸是三啊，比如摩安纸是一吧，假设X哈西啊99999摩安25001代表什么意思？你就找到了这个数度下标为一。

那就找到这个链映射关系就有了。映射关有了之后，其实你就可以得出一个结论，只要这个链上有就有这个链上没有就没有。这找到了唯一性，可以排除其他的了。分制。如果只质分制还是全ON的，但是加上这个东西。

它就不会是ON的。就像前面讲这个redis不能过滤器一样。所以你会发现真的是我说那个道理，很多基础知识，很多知识点它是通用互通的。感觉找的同学来刷波666。碰撞的碰撞是会在这个链上。

比如说XZW他们三个来了，然后他们的其实结果都就哈希碰撞，那哈希碰撞成一个值，代表他们的模式余数值都都是一样的。那么他们都会在这一个链上。对不对？OK那这个能听懂的话，其实这一个小坑，什么小坑？😊。

开始的时候是这个链都是空的，里面是没有元素的。第一步是存，对不对？存的时候这样存的。比如Z先过来了，嗨取猫是一就放那个链上了。大不来的时候刚巧碰撞了，也是这个链上了。然后这这个下边的元素再来。

那就会造成一个现象，有的链长，有的链短，其实它并不是很均匀，有的长一点，有的短一点，但是即便是这样，这个链儿它的长度也远小于曾经那个O1万ON那个长度。😊，对吧路由数组是怎么存的？其实刚才我解释了。

你只需要准备一个数组，这个数组的宽度是2500，那么它下标的区间就是0到2499。然后呢，便利它的时候用出了2500个链表，列表都是空的，然后呢准备一个算法，注意前面这是一个算法。这个算法准备好之后。

来一个元素，经过算法，找到数组的下标，往这个链上去append或者去set去装装装装装。那随着这个所有元素，1万个元素过一遍之后，有的在这个链上装了，有有的有的在这个链上。

那最终其实就趋向于把数据散列开了。但是其实未来查找的时候，只要再经过这个算法，就可以确定某一条链而排除其他的链。这才叫什么呀？真正的分值的处理的方式。对吧这个时候它叫什么？其实它叫个哈西table。

或者你们知道哈西迈ap可以这样去理解吧。但这是一个小细节啊，有一个小细节，就是哈西map。😊，它里边的K的数，这个这个K是不是去虫的？对不对？然后他是建的都是K value的value支撑n。

其实就只剩个K了。K是去虫的那这时候得到了一个什么呀？是不是得到了哈西赛。😡，这种思路走啊，哈西麦它是KV的。然后如果把vio value全都制成那只存K在这个这个这个这个这个就这个这个集合里边。

那这时候其实它的就得到一个结果，就是哈西赛集合集合是去虫的，对不对？那其实有人说了，那1万个元素里边，比如说如果重复元素，那这个结果是不是存不进去了，其实关键的点是什么呀？

找哈这个路由找到某一条链的时候，你是如何向这个链上去放这个放法可以append追加也可以什么呀？put进去。在put的时候加上一个判断。如果存在了，就forget它。他是不会去相互追加的。

只有这种追加行为的时候，哎，有一个Z出现了，一会儿又来了一个Z，肯定还在这个链上。那Z可能追到追到后边去了。完了你要提取的时候，就把它提取出来，到这儿能听出来刷波6。

就这个结构有很能小细节一调就得得到不同的结果。😊，对吧？OK收其实转了这么大一大圈儿，随便咱们随便聊，然后呢梳理你可能知道的一些个知识点，别人问的问题，然后呢，我就给他回答了，咱们互动一下。

其实你被动的去学学习接收一下。然后呢也给你展示了，其实最最最核心心得出这个结论来分制。🤧是要做的是隔离这件事情。然后但是光有分制是不行的，他必须要路由速映射这一类你可能听过的词。比如数据库里边有索引。

比如像我们的依赖设置里边会有路由。像数据库里边，其实它是数据也是分制的。像一来设置也是分制也是分制，对不对？哎，像映射的话，你比如说我们对数据做了区间的映射，做AKO划分等等的。

其实你会听到很多这样的思维，其实他们合在一起才是一个基础理论。这个理论很重要，很值钱，把它记住。好吧，那接下来向下延伸，我们从一些其他的技术站去感悟这个过程。这个过程这么讲可以吧，能接受吧。喝水。

Okay。Yeah。🤧再往下捋。再往下捋。那么接下来我会用一系列的技术。推院的一个过程。这个技术什么东西？以以一类技术啊，注意听一类技术。以前你可能学知识点的时候是垂直学的，今儿学了一个readdis。

人学了一个数据库，后学了一个蓝色者，大会又学了一个Hb。那那天我学了HTHTFS。那你是垂直学的，然后你很少有的时候把它们横向关联起来，他们之间有什么特点特征。为什么前后我这个技术的出现，对不对？

那这节课我是按照横向知识点，找到他们像刚才找这个内聚的这个这个支识点一样给你穿起来。所以接下来好好听。Okay。存储注意心啊，存储我们计算机存数据的话，其实。存储加查找这个事情有很多种技术方案。

要么存在文件里边，用代码的方式，要么用数据库，要么用redice，要么用Hb等等。还有很多像卡法其实都可以做存储层，像流式的数仓等等的，实时数仓，用卡法也可以实现。有很多技术都是它是天生就可以存数据的。

但是我们先按照这个时间轴的发展，先砍掉后后续的技术回到远古时代。比如说只有文件，那文件如何存数据，注意跟着思路走完啊，你是不是可以在文件里边用换行符的方式？然后把刚才那1万个元素。

是不是就是一行存一个元素，一行存一个元素，用换行符涂这个存进去，它能存能不能查找也能查找，随便用门语言或者是一个命令。然后呢读取这个文件，读出一行比较一下，读出一行比较一下，最终也可以达到查找。

这个都能听懂吧。很简单的一个事儿。但是在这儿有一个前置的一个一个基础知识，一个常识要给大家灌输一下，这也是你学到架构的时候。要就是你在扩展学技术站的时候，必须要向这个维度去想。即便学大数据的时候。

这是一个核心。这个常识什么东西？就是计算机存数据可以存到哪儿？有两个位置可以存，一个是在磁盘当中可以存数据，一个是放到内存。但是大家都知道放到内存，一条电数据丢了，对不对？

但是其实也会出现一些内存技术的这种存储。那为什么？因为它们的性能不一样，如果存在磁盘上，数据存进去了，我要把它找出来，注意听，我要把它找出来。那么磁盘的寻址时间是毫秒级别。内存的循址之间是纳秒级别。

磁盘归属于IO系统IO设备。那网卡也是IO设备。其实网卡磁盘它们速度损耗是差不多的，只有内存是很快是纳秒级别，它们之间的差距有多少？将近10万倍，秒的1000分之1是毫秒毫秒的1000分之1是微秒。

微秒的10分之1才是纳秒。他们将近有10万倍的一个差距。在这可以举一个例子。特别特别明显。来看啊，如果我信。3W点儿百度点儿COM。拼百度百度肯定没在咱们公司，那一定我拼百度这件事情。

这个数据包从我的网卡物理网卡发出去，发到百度又回来了，给了一个时间是4毫秒，看到吧？是4毫秒。但是同样是这个聘啊同样是这一个行为聘。我拼另外一个东西。😡，或者聘用local house的。

注意看它的时间路长是不是小于1毫秒。都是病，为什么时间差异这么大？😡，为什么呀？因为拼百度的时候走网卡网卡和磁盘一样是IO设备，但是P1270。0。1或者local house这种这种回环接口。

这个地址所在那个网卡，它是一个虚拟网卡是内核是操作系统，在内存里给你虚构出来的，它并不是一个物理的一个设备，一块网卡，是内存里的，所以内存里的操作的速度要远大于什么呀？物理IO上的这个速度。

这是一个明显的一个结论，到这儿有感受的同学来敲一，这是常识。第一个维度寻址时间是差了很多，所以你大胆思考。如果未来你开发程序的时候，尤其在数据量特别大的时候，你如果想追求速度的话，先不考虑其他的维度。

那一定是放在内存里，而不能放在磁盘或者网络当中。

对吧就是你有有的学大数据的时候也听说过尽量本地化，哎，咱们不走网卡，就走本地磁盘就可以了。而是尽量什么？在内存里边做缓存层。那这样的话，速度，你的大数据计算分布计算速度很快。

也是因为这这一点就是整个计算机的瓶颈，就在IO设备上，在磁盘上，这是第一个维度。还有一个维度被大大家忽略的就是带宽和吞吐。磁盘如果一秒钟想从磁盘里边读点东西出来的话，那么它有一个上限。

不同的硬件接口不一样，有百兆级别的，有GB级别的23G34G或者6个G顶天了。它有个吞吐。如果恰巧你的程序需要读取100个G的数据，一秒钟只能读出一个G。那你这个程序碰了一个数据的时候。

就一定是最最最最低是100秒才能过完那批数据。😊，能懂什么意思吧？所以硬件，尤其IO设备，它的这两个指标真的是最终体验到你程序的跑的这个快慢了，也决定了一个决策的事情。好吧，这个能听懂之后。

把它听懂之后啊，来回到这个问题，往后延延延续延伸啊。当你使用文件的时候，一般会得出这么一个结论。随着文件体积从几K几十K变成几兆几十兆几G几十G。那么也是这样，一行存一个元素。

那么这个时候它会随着文件越大。查询的速度越慢，请问为什么？嗯。其实我直接跟你说了，就都最起忘忘了删这个已已已已已经穿帮了，因为触发了一个全量IO的过程，能听懂这意思吧？因为它是全量IO的过程。

为什么注意这是两个词儿？😡，我都说了，IO什么，就就两个词儿，一个是选量，一个叫做IOIO这边已经说我平静了，速度一定会慢。你10个G的话，每秒钟一个G，这最少得10秒。而且它是不是10秒。

还取决于是不是全量操作。因为如果这个文件做了某种分制行为了的话，其实你可以跳过一些数据的话，那这时候他就不需要读全全部。😡，跳过前面跳过前面9个G，直接去最后一个G，那它就一秒就可以完成了。

所以你一定说它的慢是因为没有办法，因为这个存储结构像什么呀？像上面哪种存储结构，是不是像我的这种单项链表，一个元素排在一个元素后边，它没有做所谓的分制和路由索引。😡，所以他就一定会触发全量L。

所以它随着文件越大，速度越慢，听不出来敲6。这是文件，这么单一文件的形式，必然存在的一个一个特点。哎，那OK了。那这个数据我想查快点怎么办？😡，长的快是怎么办？那么我们跳过自己想解决方案。

我们直接去学习另外一个解释另外一个解决方案。那比如说来到数据库啊，注意听来到数据库，首先问几个问题啊，一定要跟我互动问题。你这样咱们学的还还有还有还还有还有劲儿啊。同样一批数据放到文件里边。😡。

和把这个数据放到数据库里边，谁更快一些？查询的话，你们告诉我答案，同样一批数据我放到文件里和放到数据库里，谁的查询更快？😡，疯狂的刷数据库，疯狂的刷数据库啊。😡，文文件还需要读取。

那数据库好像是是这这就是凌空的一样。哟哎我这么一说，一一吓唬你还一样快了，你根本没有原则，你们。😡，还有如文件块的。😀呵。😊，好，这就是你看啊这这个过程很重要啊。

就是突然因为这个问题是不是从来没有人问过你？我这么问你了，你没有给出一个我我满意的答案。那因为什么？因为你在学习知识的时候，没有成体系，没有考虑过what外好，为什么这点很重要，很多人面试面不好。

就是因为你没有做横向的学习知识，这点认可吧？😡，都是LO应该一样快啊。那我上面讲这堆东西有有毛意义吗？这个东西是很值钱的，对不对？跟着思路走啊，最终有两个结果，它有可能速度一样，有可能快是未知的。

就取决于什么呀？有没有所引命众这件事情，对不对？但是先这种思路走。数据库我讲一个粗略的一个理解啊。数据库是怎么保存数据是怎么查找数据的？数据库里边注意听，在存储数据的时候，它和单文件有一定有一定差异。

它有一个概念，就是小格子的概念。😡，这个小格子比如说都是叫这个有的有的技术管的叫dta配，有的叫做这个t，有的叫block这个数据页呀、格子呀，然后槽位啊等等不同不同的叫法，这个叫法不用统一。

你只需要知道它是一个一个小格子就可以了。它的大小可以是4K8K106K32K64K或者大数据里边的64兆、18兆，512兆。明了吧？就反正一堆堆小格子，它有一堆的小格子组成。那这时候注意听。

曾经的数据是放到一个大格子里边的，一个问题是大格子。现在把这批数据啊扔到很多小格子里边去了，给它散开了。那这明眼一看是一个什么东西啊，它就做了一个分制了。那数据库是通过这个分制查找而快的吗？是还是不是？

😡，Yeah。Okay。又有答势又答不势的。我前面铺垫那么多，你们再去想什么？这个知识点注意听，注意听，一定应用到你未来学东西。假设现在是第一次学数据库，这个知识点就开始条件反射往里去想啊。

要完你去想啊。😡，分制了，你只是做分制，是不是差另外一个词，路有索引，在没有路由索引的时候，它能快吗？它是不是依然是一个全代O的过程？😡，为什么你把它分开了之后，如果查想查询某一个东西的话。

是不是打开第一个格子走走了走了IO了，没找到打开第二个格子，走了IO没找到。第三个格子走了IO没找到。最大的复杂情况就是最后一个格子最后一行。那其实它还是一个全表扫描的过程。

它和文件的一个速度是一样慢的。😡，对吧那这句话其实鉴今你经得出结论了。如果使用数据库的时候，没有锁引。😡，没有索引的情况下，或者是如果触发了选表扫描，就对着整张表扫描的话。

其实它和单文件存储这个数字是差不多的。这点任何同来刷波666，你只有分制，其实不能达到提速。那真正提速怎么提速的，注意听。😡，加缩引。什么叫缩引？索引的话，比如说表里边这一行有100个列。

宽度是不是很宽，每个列四个字节的话，还400个字节呢？什么叫缩引？你比如说对里边身份证这一列做了索引了。身份证，比如就假设假设身份证就四个字节。那其实把这个身份证号是不是拿出来放到这个再准备dta配置。

把这个身份证号放进去了，并且告诉他是来自于哪个data配置，这个身份证号来自哪哪哪个哪个小格子。那这样的话，每一行其实就垂直切割了一小粒数据放放进来了，并补了一小溜什么呀，他们在哪个格子里。

你就想这就是所谓的索引。那注意听数据是数据，索引也是数据，索引也消耗空间，但是索引的体积远小于数据的体积。😊，这点认可吧？索引的体系远小于数据体。如果索引有两阶段发展的话，就现在这种傻瓜式的索引。

就来这数据，我就把它这个除了把他这存下，把那个身份证号拿出来，搁这把格子也放这儿质要好了。那这时候存完之后，这次再查找怎么查找的，速度会提升吗？是不是查的时候，第一要要怎么查找。

是不是你要查的东西过来之后，我先从第一个索引格子里边看看。如果这个时候注意听啊，你必须在这个写字口的时候给出什么呀？😡，这个你的那个所有那个列那个列的那个那个名称，以及你要查那个身份证号。

要给出这个东西，然后呢，他才能触发索引，拿着那个你要查那个身份证号，然后在所有里边第一个格子里找，哎，没没找到第二格子，第三个格子，第四个格子，那最大复杂度是什么呀？是对着索引走了一个全量的IO。

把所有的格子全部穿了一遍。它最后一行找到了命中了，并且知道是在哪个数据的格子里了。😊，能听懂什么意思吧？找到数据格子之后，是不是数据里边只需要碰一个格子，也就是全量的索引格子加上一个数据格子。

就可以找到你要找的东西。而且前提是索引命中。中要给出索引条件，命中了就会走这个。而且我得出一个结论，所谓的体积远小于数据的体积。那么这个速度一定会比你做全量数据遍利要快。😡，对吧索引比喻有序，那是后话。

到这儿能能能能听懂吧？这是不这是不是就是一个提速的过程了，对不对？这是最low一种索引的方式啊，就这样也可以了。😡，对不对？你只需要做索引的全量，那索引题永远小于它码，速度肯定比你之前做这个过程。

那这是不是缩这个简单索引。但是这个索引的过程又翻一个词汇，注意啊，作为程序员。😡，你只要知道某一个技术是全链IO的，有问题。这东西肯定能优化。如果在你做架构设计的时候，他需要扫描所有的东西才能得出结论。

或者做所有的操作，这东西一定能拆解。那比如说在索引上再做二级索引，比如我对索引做有序维护，用某种数据结构，对不对？比如B加术。对不对？毕加树树干体积更小了，所有的缩影了。

所引的这个这个这个这个这个东西它体积更小了。😡，是不是一层比一层体积更小。那这个东西假设能放到内存里去了。那这时候再查找怎么查找，从内存纳种级别快速定位到了某一个分支，分支就指向了某一个索引页。

索引页取出来之后，8G一判断直接取出数据页。那这时候你的索引那块数据还是全量吗？是不是就不是全量LO了。那么整个数据库是不是可以规避全量O这件事情？😡，到这儿能听懂的同学来刷波一。

在这不深不太深入追究某一厂商的，你这个围绕的就是一个核心概念，你找到的是他们水平走的这个这个特点。😡，Yeah。好，那你这个能听懂了之后，然后一般还会伴随着一道问题。那，这先说啊，就是所有民众才会快。

全面扫描的话依然是慢的这是一个结论。那再来一个问题，这个问题是如果。也不是我就是是不是随着表的体积越来越大。那么查这个这个速度。会变慢，跟着速度啊，随着表的体积越来越大，比如说达到了1050万哈。

然后呢10个G，那么这时候就开始变慢了。会不会变慢？有人说会有人说是的，有人说不会再来一个叫许峰峰说为啥我听了半天，感觉什么东西没有学会，是这个这这个是这个意思吗？注意听啊。

这节课咱们一个公业课就两个小时，我能教你的是什么东西，梳理的是一个学习方法，横向总结的一个过程。找到的是脉络。因为如果这个这个东西我不给你讲的话，你未来也能找到感觉。

但是你要拿你的时间去拿你的时间去换这件事情。😡，能懂我什么意思吧？你要拿你的时间，拿你未来工作了好多年，用过的工作更多之后，可能遇到一个面试题的时候，才能想到这个这个问题。

这节课是从这个维度去解决根本的一个问题，也是改变什么本质。😊。

系列 6：P109：分布式场景系统中数据一致性问题如何解决 - 马士兵学堂 - BV1RY4y1Q7DL

我走不动。好，那个这是今天我们呃今天一晚上的所有的课程内容，然后。

第一个我们讲一下分布式场景中数据一致性的问题如何解决。因为分布式就是涉及到多个服务或者多个数据库之间数据的同步，就是是吧？比如说现在比如说这是服务一服务2，然后每个服务挂一个库，每个服务挂一个库。

怎么能保证这两个服务和两个库之间数据的同步呢？这是我们今天的课程的主题呃，还有就是。分布式事物问题比在在面试中就是分布式事务和分布式锁，它是呃几乎是做分布式系统必问的一些问题。

然后这里面呢我会把分布式事物的解决的思路，在这节课里告诉大家，呃，这个思路有几个目的。一个是你在面试中回答的时候，能把它说清楚。第二呢，就是你知道这个思路之后，你在学习后面的分布式事务的方案。

那你就会更加的从容。好了，这是第二点啊。然后还有就是呃我会在课程里面介绍一下两阶段和三阶段提交协议，就这两个协议。对学习后面的分布式事物就是特别有帮助。虽然是一些理论性的基础，但是你把它掌握了之后。

不管你学以后的西塔还是LCN都会有一些帮助。然后再有就是第四点组合。存储中间件如何解决数据一致性的问题。这个大家能理解吧？比如说我这里面写了两个reis和myscle。也就是说你在一个方法里。

比如说是你的方法，你在一个方法里呃调用了，比如说set呃KV就调用了reis，然后也也update了，就是update了一个数据库是吧？这是第一个调用reies，第二个调用呃myscle。

如何保证它俩的数据一致性呢，这是个这是我们要解决的这个问题，还有就是什么是TCC然后TCC的解决方案是什么？这个我们课程里也会说到第有就是如何利用本地事件表实现分布式事务，这种这个实现事务的解决方案呢？

就是不不需要引入额外的任何组件，只需要利用本地的一些特殊的设计，就可以完成分布式事务，这个就比较简单也好理解。第七点呢给大家解呃那个讲一下最大努力通知方案是什么。好了。

这就是我们今天晚上要讲的所有的内容。大家脑子里应该大概有个印象吧。刚才有个同学问讲西塔吗？西塔必须得讲啊，必须得讲西塔。我们讲两阶段和三阶段的时候就会讲西塔。然后讲TCC的时候也会讲西塔。

我们都是基于西塔框架实现的O。可以吧。然后听这个。这节课所有的内容就这些。然后呃听这个课的时候呢，建议大家认真听讲，然后该问问题的时候，我会留出时间让大家问问题，要不然就会拖慢我们讲课的速度啊。老师。

这个上周不是讲过吗？是啊，上周讲过。是的，上周讲过，因为这个这个是公开课。啊。公开的话公开课的话，我们就是因为就是内容有一些重复。如果呃我们VIP课里的话是不重复的。啊，好了，我们开始可以开始讲课了吧。

😊，嗯。😊，听你们的啊，确定就写一啊，有有有疑问就把疑问打出来。曹老师听十遍都行。好，那你听着啊。好了，开始上课了啊。😊，好啦。😊，好了，开始上课。好了，讲课的。讲课之前我们从一个场景来入手。

因为我们做技术的，好多人都以为我们做技术的，其实就感觉是一种特别伟大高尚的职业，是吧？我也这么我也这么认为，但是。谦虚一点说，我们技术其实就是个服务行业，我们是为业务服务的，脱离了业务。

你说这技术还有什么用？是吧这这个大家能理解吧。😡，就是虽然我们敲着键盘是吧，拿着鼠标感觉是吧？自己不种田不种地，感觉现在玩高科技是吧？但是其实我们不是这样的是吧？我们是为业务服务的。

所以我们的技术都要围绕业务产景出发。O好了，业务场景。给大家说两个例子。第一个例子。大家如果用过第三方支付的话，比如说用过呃支付宝或者微信用过这两个吧，直播间里用过的同学。直播间里用过没有？用过是吧？

OK好的，用过的话应该知道。比如说这是一个服务。举个例子啊，这是一个服务，就是我们呃一个serverer，他提供一个web外b接口，让别人来调用。然后这个呢也是一个web服务，提供一个外b接口。

让别人来调用。首先我们把这个人理解成第三方是吧？第三方收到钱之后，调用我们的服务。然后我们的服务呃，支付服务，更新数据之后，这边一般的指的是支付的流水，就是更新完支付流水之后。

我们再去更新我们的业务服务。业务，比如说是订单。是吧比如说我们系统里呃买了一个东西要成交一个呃，比如说买了一个手机，要付款，付完款之后，这个款是打到了第三方。打到第三方之后，第三方来回掉我方的系统。

那么我方的系统一般是这么做，它先回掉我的支付系统就告诉我，你把哪个订单给我支付了。我想把支付流水给改了。这样的话我知道我的订单是支付完成的状态。然后同时再去修改我们的订单系统，把订单的状态变成已支付。

一般的是分这么两步进行的。这两步呢也会涉及到两个服务。比如说支付服务和订单服务，这里面每个服务呢都挂了一个数据库。我们呢我们这节课的目的就是要保证这两个服务之间数据是一致性的。这个老师说的这个。

目的大家能ge得到吧？能不能get到，能get到就敲一。OK好了好了，这是这是一个例子啊。其实这种例子非常多。还有一个我们大家更好理解的理解的例子就是比如说我在电商业务中。

比如说有这么一个业务场景叫下单。下单的话，比如说这是用户，用户要去购买一部手机。举个例子，他买一个手机之后。😊，它会生成一条订单，比如说某某某某年某月某日呃，买了一个手机多少钱？

是吧多少多少多少多少人民币是吧，这是一条订单记录。OK但是在生成这条订单记录的时候，因为它要下单嘛，下单在生成这条订单记录之前，他会去判断一下库存还够不够。在一般的大型电商系统中会涉及到。

其实在那个一般的大型电商系统中，它这个下单的服务会非常的复杂。有直播间里有做过电商的同学吗？直播间里有没有做过电商的同学？有的话给老师敲个一，小马这么多同学都做过是吧？你没有啊，有是吧？做电商的。

有过做电商的同学应该知道下单这一步我图中画的是比较简单的，但是它实际会非常的复杂，它会涉及到比如说销售层，就是库存这个服务，它会有它会有很多层。比如说销售层的库存，然后还有调度层的库存。调度层的库存。

还有就是仓库层的库存。okK这是这个服务就分了好几级。我这个里面只不过是把它。抽象成了一级，统一叫做库存服务。做过电商的同学应该能理解这三个层是做什么意思，做什么的吧。能不能理解这块儿。

如果不能理解的话，我们呢我们有我们有零基础的小白项目课，这里面我们都把这些说的说的很清楚。就是在一些大型电商系统里，一个库存就分这么多层。然后只不过是我在这个例子中呢，把它呃抽象成了一个库存。

就是它去调库存，先把库存减去一个。比如说要买一个手机，就是把库存减1，然后订单呢加乙，这时候是两个服务，两个库，这边又是一个服务，一个库，理解了吧？我们的目的。

我们的目的就是要保证这两个服务和这两个数呃，这两个库之间数据是一致的，就是不能说库存减了，然后订单没增，或者说订单增加了，结果库存没减，没减，这就尴尬了。能理解我们我说的这个例子里面，我们的目的吧。

分多餐还有载图量。嗯，你说的对啊。好了，哎，那个叫载途库存。好了，能理解是吧？能理解我们就继续了啊。😊，好了，在刚才我们所说的场景就是分布式事物要解决的数据一致性的场景。在我们讲那个分布式事物之前呢。

我们先来熟悉一下我们最就是最开始上学的时候，就最开始接触事物的时候，事物到底是个什么样子。事物是什么样子？😡，事物就是用户定义的一系列数据库的操作。这些操作可以视为一个完整的逻辑处理单元。要么。

要么全部都执行，要么全部不执行，主要就是这个。也就是我们前面所说的那两个服务，要么。这边增加这边该扣的扣掉，他俩同时执行，要么他做不成，他也得回滚。能理解吧，就这两个是一个原子操作，要么他俩都干。

要么他俩都不干，不能说一个干了，一个没干，这就不是这就不是事物了。O事物就是不可分割的工作单元。这是我们最开始学事物的时候，它的一些定义，同样把它迁移到我们分布式事务中，它的定义还是这个样子的。

OK好了。😊。

我们往下看一下事物的这几个状态，我们快速过一遍ACID大家都理解吧，原则性、一致性、隔离性和持久性ACID怎么做的？😊。

ACID通过什么实现呢？就是当今事物的时候，ACID通过什么实现的？就是它最底层的技术是通过什么做的？ACID最底层的技术。有木有人知道？数据库是我是数据库事务呀。

是数据库事务日志数据库锁blogMVCC说的都对。它其实最重要的就是通过锁和日志做的。

理解吧？其实就是锁和日志，最底层就是用了这两这两个技术，把数据把那个数据库的事物给它实现了，就是锁和日志。在数据库里面有一句话。数据。就是日志比数据重要。那大家能不能理解这句话，就是数据可以丢。

日志不能丢，就是日志肯定日志比数据重要。就是一般的操作数据之前先写日志，这是在数据库里面有这么一句话，大家能理解吧？我跟才所说的这些，这都是数据库的基础知识。为啥？呃，为啥稍等一下啊。至于为什么的话。

我给你我给你一个东西，你去找我们的咨询老师。呃，要为啥就可以了。因为这节课我们不讲扫描屏幕右下角的二维码，找我们的咨询老师去要一些资料，你就知道知道为啥了。因为我们这节课是讲分布式事务这些东西呢。

我就我这节课里不讲，但是我也给你提供了资料，你扫描屏幕右下方的二维码，让我们的咨询老师给你一些数据库的基础的视频，它里面都会有的OK可以吧？这个这个G。😊，好了，我们往我们往下走啊。😊。

我们在实现事物的时候，我们一般怎么做的？我们一般怎么做？打一个标记，就是一个开始标记，得声明这是一个事物的开始。事物开始之后，我们执行业务逻辑，执行业务逻辑之后再给事物收割尾，就是开始结束。

中间是业务逻辑。这个大家能理解吗？这个是比较基础的数据库的知识。能不能理解能力的话是敲一。嗯。能理解能理解是吧？好的。😊，好了，然后这个begin try三个就是标记标记事物的开启。

然后commit呢表示事物的提交，也就是落库，这个也就是刷到磁盘中落盘。然后这个row back呢就是回滚，就是把原来做过的反悔，就是全部撤销，这叫回滚。然后中间就是也有逻辑。O这个基础理解的。

我们后面学分布数的时候就会简单好多啊。我们先回忆一下好了。在我们单体的服务和单个库的情况下，怎么实现分布式事物呢？如果我们用如果做过这方面同学的话，如果我们用呃用spprintring框架的话是吧？

加一个艾特出来三个人注解就OK了，是吧？这是做单体服务挂一个库的时候，用这个就可以，是不是？这个用过吧。😡，艾着出三个人住去。有没有用过？用过的就敲一。O ok好了。😊，好了，嗯，我知道这人问啥好了。

这不是我们这节课的重点，我只是带大家回忆一下。😊，啊，好了，前面说的是事物最基础的一些概念。我们进入我们这节课的正题，分布式事物。OK分布式事务是什么？它它的应用场景是这个样子。

前面我们也讲了一些案例是吧？比如说一个用户的请求进来之后，他请求想打到这个服务上。这个服务通过调用这个服务。和调用这个服务完成它整体的业务逻辑，明白什么意思吗？比如说一个下单请求。

就是用户发出一个下单请求，先他先调用到这个服务。比如说呃这是个user服务啊，就是对接user的一个service。然后user服务呢要调用订单服务。然后要调用库存服务，能理解吧？或者说库存在前。

订单在后，因为先判断库存在呃在新增订单，或者说他调了订单，订单再去调库存返回之后再去新增订单都是可以的。我这个图画的这个意思呢，就是呃不一定这么做，但是通过这个呢，你应该能清楚。

就是说会涉及到一个请求调用多个服务以及多个库的场景。而我们的目的就是要保证。这两个服务。就是这是一个服务这是一个服务，这是一个库，这是库这两个服务以及他们对应库之间数据的一致性。

这就是我们要讲的分布式数物跟前面那个前面那个只是调用一个相对应啊。好了，我们开始往我们开始往下了啊。😊，嗯。好了，分布式事务是指会涉及到操作多个数据库或者多个服务的事务。大家这块注意一下啊。

其实就多个数据库或者多个服务。好多同学以为一个一个服务调用俩库，就不算分布式事务，其实也算，只要你涉及到多个库或者多个服务。比如说这是一个服务，这是一个服务，他俩调了同一个库，这也算分布式事务。

ok这块理解吧，就是一个服务调多库，多个服务调一个库。也算一个分布式事务。其实就是将对同一数据库或者对同一服务的事物的概念扩大到了多个数据库或者多个服务。目的是为了保证分布式系统中数据的一致性。

O这个这个大家都可以理解吧，这样我我应该把分布式事物。😊，他所涉及到的各种各样的场景都给大家说说清楚了，理解是吧？okK好了，那我们继续啊。好了，我们往我们往下。😊，我们先来分析一下思路。呃。

分析就是解决这个问题的思路，我们该从哪里入手呢？大家想象一下啊，我给大我给大家看一句话，看完不知道大家能不能知道它的一个整体的思路。分析这个就是分布式事物数据不一致的原因，是因为事情做了无法后悔。

大家能不能理解，大家想把这句话记在脑子里，事情做了无法后悔。然后我给你详细的解释一下，为什么说事情做了无法后悔呢？大家想一下啊。一个用户发一个请求到订单，订单调一个请求到库存库存。比如说减一。

也就是说买一个商品，库存减一，减完一之后，库存给订单一个响应，响应就是说我减一成功，然后呢，订单收到这个响应之后，在订单里insert一条订单。这个大家可以理解吧。

就是insert orderinser一条记录。O当它insert的时候，这边报错了。这边报错，怎么让库存服务回滚呢？大家思考一下这个问题。如果我们要让库存服务回滚，我们应该怎么做？最笨的办法。

我们说订单服务再给库存服务发一个请求呗，说发一个请求，你把刚才你做的那些事给我撤掉，这也可以。但是我们在实际调用中，这条链路只是发过去发过去有响应执行，然后给用户一个响应。

这个事情只能这么做OK只能这么做。也就是一条链路只能这么做，但是中间没有我所说的那个后悔的这么一个步骤。就是说订单告诉库存服务，你要后悔，没有这个理解了吧？所以这个就是我我前面所说的这句话的意思。

就是事情做了无法后悔，所以说它是导致两个服务之间数据无法一致的一个原因。这块我说清楚了吗？这话说清楚了吗？有清楚的话，你就敲个一，我就知道你清楚了，我就继续了。清楚是吧？好嘞好嘞。

那他无法反悔我们实际工作中怎么去做呢？其实我们软件设计的好多解决思路，其实大部分是来源于工业设计，不知道大家能不能理解我说的这句话，大部分来源于工业设计。这句话如果不能理解，就当我没说啊。好了。

能理解的swift理解是吧？swift的理解是吧？能理解更好啊。然后这些设计呢也有一部分是来源于我们的生活。😊，生活中怎么做这些无法让我们无法后悔的事情呢？大家有没有想过这些这个东西？

生活中怎么做这些让我们无法后悔的事情呢？就是这个事我只要做了，他就定了，我就没法后悔了。那么我为了保证他的万无一失，我该怎么去做？惹女朋友生气，时光倒流，遇啊，青云青云说玉对了吗？是吧？彩排嘛。

先试一把嘛，预言。是吧先试一下，如果说都能成功，那么我就彻底去做了。如果不能成功，那我就不做了，能理解吧？彩排这个事儿能不能理解？也就是说我原来去做我原来去做这两件事儿。第一次做了，然后他又去掉了它。

结果他回来之后，他出错了，我是无法让它进行回滚的。如果有彩排之后，我怎么我怎么做，我先调它哎，你先试着做一把，然后他掉它试着做一把，然后他说成功他试了一下，说我成功了，但是我实际是吧。

可以不是最终的抵销，这只是我。预预演一遍是吧，这叫什么演习一下是吧？又不是真打你是不是？然后完了之后给他一个成功，结果执接他的时候错了，那没关系，我又不是真打。那我这边回过我这边是吧，做了。

相当于没做是吧？能理解能理解这个意思吧？😡，能不能理解这个意思，能理解是吧？OK好了，然后在演习的过程中，是需要有这么一个中间的第三方来收集演习的信息的，也就是说两个他做对了，他做对了。

都汇总到一个人这，然后这个人说哦，你们这你这哥俩都做对了，那我们正式去做吧是吧，去吧，然后说如果有一个做错了。然后这哥们说，哎，不行，他做错了，你做的也不算是吧，你俩重来一次是吧？所以。

得有一个得有一个中间人来收集这个信息是吧？像鬼谷子说的是吧，裁判可以这么理解是吧？才可以叫裁判是吧？在春晚中呢就叫导演，是不是？是不是就这个意思，然后在分布认1务中呢，我们就叫呃TM是吧？

叫transction manager事物管理器或者说事物协调器，这就是一个第三方的角色。OK这个你要理解清楚之后，就明白了LCN和西塔为什么需要启动一个第三方中间键OK彩排这个我说清楚了吧。

从彩排里面我也说出了需要需要一个协调者。这个清楚这个也清楚吧。会不会有这种情况，彩排没问题，但是正式就有问题了。会的。会的啊，你说的这个问题会的。

但是我在后面会讲到这个live just for love。是吧为爱为只为爱生，只为爱活着，是不是？好了，我后面你把你这个问题记住，后面我会讲到这个问题的啊。

系列 6：P11：Java线程模型 - 马士兵学堂 - BV1RY4y1Q7DL

在这里讲的一些个内容呢，感觉都比较深入一些，大家凑合听啊，能听懂多少是多少，你也感受一下，现在大厂的问的都是哪方面的东西，其实凡事你只要能够打好的话，现在涨个薪水什么的，那跟玩一样，给大家15秒钟。

你扫一下这些题，尤其是没有呃读过的那些同学，对于底层，对于锁，对于多线程不是很了解的，读一下，这是19年到20年一线大厂的，他们的关于多线程和锁这方面的面试题，黄老师还在吗啊，黄老师，黄老师还健在。

怎么了，他才25岁，正常的情况下，52度都会在，lucifer，这个和b站一样，这个和b站不一样，好多陌生词汇是吧，steam，25怎么了，25不行吗，25也可以有牛人的，周志磊，周老师什么背景。

他是原来民生银行的架构师嗯，我25的时候还是个废物，如果不学的话，52也是个废物，讲讲吧，太磨叽了就不讲了。

使劲儿磨叽，聊会天嘛，讲着玩嘛，不要天天讲技术，我现在把技术都讲的，我自己都快讲吐了，如何才能当架构师，嗯需要有一系列的努力路径才可以啊，不废话了啊，我们开始讲今天的内容，看都有人着急了。

开始给我带节奏了，好看这里啊，不开玩笑了啊，呃我花两天呢给大家讲一些，现在面试之中问的非常多的这一类的问题，由于它牵扯到很底层的内容，牵扯到很基础的内容，所以呢我想从基础和底层来给大家讲起。

首先呢在这呢我先给大家解释一些基础的概念，如果这些概念你不理解的话，估计大厂的面试就跟你说拜拜了，看这里。

嗯我重新画图吧，我重新画图的话呢。

大家会看的更清楚，拿手工给你画一下，好看这里啊，我我呢首先给大家解释一个最基本的概念，这个概念呢叫用户态和内核态，关于这个概念，那个不清楚的同学给老师扣个二，我看有没有必要讲多少好吧，嗯好大家看这里啊。

这个呃如果把这件事要讲清楚的话，实际上得从那个操作系统的历史开始讲起，呃，我玩操作系统呢当然玩的比较多，因为我的年龄比较大了嘛，最早的操作系统我是玩过那个os two。

然后最早那个苹果机的making top，那些个操作系统，当然大家比较熟悉的应该是dos操作系统，不知道有没有同学玩过，当然还有win 31文九五啊，文文文文2000，win 7 win 8。

win 9 win 10，各个各个操作系统呢，以前的操作系统有这么一个特点，什么特点呢，就是一个是应用程序，能够直接把操作系统给干掉，啥意思，如果我们从专业一点的角度来说，相当于什么呢。

相当于这是我的操作系统程序，然后呢，这是我的应用程序，然后这个操作系统的程序和我们的应用程序，它们两个是同权的，什么叫同权的，就是我也可以访问同一块内存，你也可以访问同一块内存。

那我这个程序要是不怀好意的话，我就能直接把你操作系统内存给你给你干掉，把里面的值给你改了，还有一种呢是我也可以控制硬件，我的我的应用程序也可以直接控制硬件，那我把某个硬件呢给你干掉。

把格式硬盘给你格式化了等等，总而言之，那个时候呢，应用程序和操作系统这两个软件没有区分开来，所以就会诞生，经常的操作系统运行运行某个程序就死机了，就蓝屏了，这块大家能不能能不能够理解这个，理解到这一点。

大家伙都比较年轻嘛，没有经历过那个时代，但是你能够想象得到吗，唉能应该能想到现在呢，作为一个应用程序来说，很少能把操作系统给直接干死，原因是什么呀，原因是他们做了一个分权处理，分权处理的意思是。

把这哥们儿的权重等级给提高了，这个操作系统能干的事，好多应用程序是不能直接干的，比方说什么事呢，直接跟硬件打交道，去接收网络的数据，去访问，直接访问内存，比如比如说跟那个键盘，跟显示器等等打交道。

这些操心都能干，应用程序干不了，那有同学会说，我应用程序写的程序也可以控制你，你那个显示器上显示什么呀，我也可以读网络数据啊，那这时候怎么做的呢，这个时候由于它的权重降低了，就变成这样子了。

app啊是跑在可以认为是跑在操作系统的外围的，需要和硬件打交道的部分，都是要经过操作系统的帮忙才可以有一老大啊，这就是你们的老大，你写的应用程序都需要调用操作系统，对外所提供的那些个库函数，系统函数。

你得需要通过操作系统提供的，这些个核心的功能，你才能完成自己想要的一些操作，所以我们可以简单说，操作系统是工作在内核态，而应用程序是工作在用户态，这样的话，我操作系统能管理的东西就会比较的底层和直，接。

不让不让我们的应用程序直接去干掉，我们那些个硬件，从这个角度来讲，我们操作系统就会更加的安全，所以现在的操作系统很少有应用程序，直接能把它给干掉，给卡死掉的，来，能get到这点，同学老师扣一。

那有同学说老师这跟高并发有半毛钱关系吗，这是高并发的底层的核心，大家知道作为java来说，我们我们讲清楚是第一个问题之后，我们来讲第二个问题，第二个问题是什么呢，第二个问题是看这里。

第二个问题是java的，线程模型，有同学说老师这个java线程模型，那还有什么特殊的吗，不就是有一个thread吗对吧，或者是new一个rnable，再new一个thread。

或者new一个colorable，再new一个thread，无论如何不都是要new一个thread吗，这东西有有还有什么模型吗，有它的模型在于哪里呢，在于是作为java来说，同学们，你们想一下。

它是用来运行class文件的一个虚拟机吗，而我们的jav程序对于操作系统来说，它就是一个普通的应用程序，站在操作系统角度，你jvm和你的qq啊，和你的office啊，没有人没有半毛钱区别。

都是运营在我用户态的这样的一些个应用程序，那现在这个问题又来了，作为这个class里面，它能够启动好多好多的java的线程，这个大家应该知道，嗯随便画个图吧，来简单说啊，用这个来表示线程。

这是java里面的一个线程，一个thread，第二个第三个作为一个java整理来说，它可以启动好多个线程，那现在的问题是，这些个线程在操作系统的这个级别，它到底是怎么运行的，这就是java的线程模型。

它的一个底层机制好听我说作为这个东西，jvm虚拟机规范并没有做出任何要求，这标题拟机的规范呢并没有做出任何要求，他什么意思呢，就是说你这个一个线程在这，你扎到里面的jvm级别的这种线程。

这是jvm级别的线程，好作为这种线程来说，它在操作系统的级别底层到底怎么来实现，它并没有做出具体的要求，那么hosport是怎么实现的呢，这几个名词都不用我解释了，什么叫jy m虚拟机。

什么叫hosport，应该是不需要我解释的，对不对，那可以继续的给老师扣个一，这不是不是，这不是内存模型啊，这是线程模型，hosport是java虚拟机的一种具体的实现。

目前也是应用最广泛的是oracle公司的实现，hot sport是啥，jvm虚拟机的一种具体实现，oracle对于jm实现好，你们练到这种程度的，下次就别问问题了，好好安安静静的听就行了，你们不开口。

没人知道你们好看，这里，作为jpm来说，一个线程启动的时候对应的是什么呢，对应的是操作系统级别，也有它的内核线程，操作系统呢有它自己级别的内核线程，就是操作系统底层要实现的时候。

管理的是一系列的内核线程，这线程呢我们简单简单称之为k，这是操作系统级别的建筑，好好好听，我说目前java虚拟机的实现也就是hot sport的实现，它是怎么实现的呢，这个时间叫做一比一。

就是一个内核线程对应一个操作系统，对应一个虚拟机级别的线程，好久不一一画这箭头了，大家理解什么意思就行了，目前它的实现是一个一比一的关系，有同学说老师难道还有除了这个东西之外，还有别的对应关系吗。

有go语言的是什么，有多少同学知道go语言的，go语言的线程模型是什么，当然它的线程不叫线程，叫什么叫线程对吧，腾讯的面试县城和县县城的最准的区别，我一会给大家讲几道腾讯的面试题，它也比较好玩。

go语言的编程模型它是什么一个实现呢，注意它和具体的操作系统内核的线程，它是一个m比n的关系，当然还有其他虚拟机的实现，还有其他虚拟机实现什么，就是我的用户的虚拟机级别的线程。

对应的可能是底层的一个线程，m比一的关系，n比一的关系也是有可能的，当然也没有那种111比n的关系，这个很少，作为java来说，他就偷了个懒，为什么说go语言叫天生支持高并发，是因为go呢。

我一会儿给大家讲啊，go语言呢呃它底层的这种m mba的模型呢，就相当于一种自自然而然地实现了java的线程池，这样一种关系，而作为java来说，他就偷了一个懒，这个偷懒的意思就是说，hosport。

透露了，线程调度交给了操作系统，啥意思，就是hosport特别懒，hosport一个实现就是我jvm级别出一个线程，我就在我的jvm实现里面，直接去启动一个操作系统级别的线程就可以了。

我不需要在用户空间里头做一些线程，这方面的管理，比如说县城所，比如说线程调度好，所有的这些事情都交给操作系统，老大来帮我完成，这是一个很核心的概念，但是go语言不是go语言，它的线程是在操作系统。

是在我的用户空间，这个级别做了很多很多的管理操作，他们之间的同步，他们之间的通信都是发生在我们的用户空间的，所以站在这个角度讲，就有这样一种提法，这个提法是这样的，认真听重要的概念来了。

这个提法呢叫做java的线程模型，叫重量级线程，而go语言的编程模型本身的线程它也叫什么呀，叫轻量级线程，线程呢也是一种线程，但是它属于轻量级的轻量，在什么地方，重量又在什么地方。

轻和重的最主要的核心的点就在于，要不要通过老大带我管理，再强调一遍构造携程是吧，哦ok ok你说的很对啊，没错他说的很对啊，这个我错了，对不起，勾脚携程go routine啊，专业名词叫routine。

就是我需不需要操作系统参与调度，这个就叫重量和轻量级的最根本的区别，再说一遍，所以后你看到重量级，轻量级，还有还有一种一些一些专业的名词，叫什么重量级锁，轻量级锁，这都是什么概念，什么叫重，什么叫轻。

非常简单，记得这个概念就可以，就是需要操作系统参与调度的，这个叫重量级，不需要操作系统参与调度，只需要我自己的在用户空间就可以搞定的，这部分内容叫轻量级，需要内核态，不不能说需要内核态啊。

就原来这个概念我讲的太粗了，不是说需要内核态，因为好的内核态你总是要翻译成汇编语言的，但是你像这种java这种线程模型，就需要操作系统来帮你管理，帮你做现成这方面的一个调度。

帮你做出锁之间的一个同步来帮你做这事，我的虚拟机没做，我把麻烦事都交给我老大了，ok这种实现叫重量级，因为你需要经过一个老大的处理，但是有一些叫轻量级，为什么叫轻量级，因为我不需要经过老大处理。

不需要请出这么重要的人物出场，这个叫轻量点，好了来能get到这一点，同学老师扣一，那看这里，大家明白这个概念之后呢，有同学说老师那说了半天go语言，你能不能聊一聊这个go语言的，它的一个携程的一个实现。

go routine的一个实现，它到底是什么样的呢。

听我说歌手听的一个实践呢，算了，这个图我就不放了，节省时间，歌手听的时间是这样子的啊，勾入定的时间，看这里作为go语言来说，它的一个一个的线程称之为携程，专业名词叫go routine。

如果学过go语言呢，这个我需要给大家写一个go语言程序吗，应该不用了吧，go and我刚刚给过期了，还准备用vs code了。

但是不管他。

呃作为go语言来说，如果你有一个函数，想让它启动一个不同的呃，这种携程的话应该怎么处理啊，比方说我有一个函数，是不是就这么写啊，go f哎就可以了对吧，同学们就这么来处理，平时我们调用的时候。

我们写f就是对于函数的调用，而我也是个f呢，就相当于我开启了另外一条通道，开启了传统意义上的一种另外的线程，f在这边执行我的mamain函数呢，继续往下执行，ok所以它的叫做go语言叫什么。

天生支持高并发吗，天生支持高并发啊，这字写的好难看，这是我的字吗，天生之至高秉范就在于这儿，就是它特别简单，注意这个天生支持的意思，并不是说java不支持，而且java要实现这个功能非常麻烦。

但是呢作为go语言来说呢，它就特别简单，就一个go这个关键字就可以了。

非常的简单，那它的底层模型到底是什么样的呢，底层模型的在于它每要启动一个携程的时候，就没启动一个go routine的时候，注意它和我们的内核线程是一个什么关系呢，是一个m b n的关系，bn好。

我们来聊一聊它具体的一个实现，同学们，你们认真听，作为go语言里面呢。

系列 6：P110：分布式事务的设计思路分析 - 马士兵学堂 - BV1RY4y1Q7DL

好了，刚才这个清楚了吗？😊。

还有可能导演得病了。对，这个问题我后面也会讲啊这个问题这个猫猫喵猫喵还是这个我后面也会讲这个我后面也会讲，你俩记住啊，为爱活着，还有这个猫。嗯。好啦。😊，我后面会讲到的啊，先说这个清楚了就敲一。

比喻很形象是吧？能理解就好啊，就是比喻不比喻的，主要是为了方便大家理解啊。好了好了，然后我们我把这个缩小一点，还是放这吧。😊。

这样的话我说大家提问的会方便一些。好了，然后通过前面我们所说的我们所说的一个。

分析。那么我们知道分布式事物处理的关键是必须有一种方法，可以知道事物在任何地方所做的。

所有的动作，其实这个就是我们刚才所说的一个第三方是吧，或者说裁判或者叫协调者知道事物在任何地方所做的任何动作。也就是你要知道在这个服务里做的事和在这个服务里做的事。

提交或回滚事物的决定必须产生统一的结果。也就是说让你俩你俩先试最后你俩都没问题，我说提交你俩都提交。我说回滚，如果说有一个有问题，我说回滚，你俩都回滚。

这样的话就将他们的提交和回滚统一了一起统一在了一起。这样也就保证了数据的一致性。O这就是我们通过前面的思路分析，我们得出的一个结论。O好了，那么我们在我们的整个服务的架构中呢，我们就引入了这么一个东西。

这个东西叫协调者就是你服务该调你的服务，调你的服务，该调调去。但是呢参与参与这个事物的这两个服务需要给协调者。

呃，做一次汇报。也就是说这两个服务里需要集成跟协调者通信的组建。这个理解吧，大家能不能理解？就是根据我前面所说，我们推论我们推推论出这么一个东西。OK理解是吧，所以。😊。

这个能力的话就知道我们我们我们所说的LCN呀，或者说se塔呀，西塔这些框架，为什么需要在每个服务里引入一个se塔的架包，再加一个艾g个程的注解，主要就是为了跟第三方进行通信。

也就是说在这两个服务里面做改造。okK好了，那我我们我们就继续了啊。好了，然后分布式事物说分布式事物呢，还有一个东西就是一些呃理论性的东西。这个大家也得知道。

就是叉A规范是叉open组织定的一个叉A的规范。然后这个规范里面涉及到三个角色APTM和RMAP就是应用程序，就是我们平时写java代码的地方是吧？我们的外部地方写java代码主要集中在这个地方。

然后TM叫做事务管理器要协调者，也就是我们前面所分析的第三者啊，不是第三方。

然后再有就是RMresource manager。resource manager呢就是我们所说的。买C口你可以这么理解。O现在的话这三个角色大家都清楚了吧。我们的代码第三方。

mycyclcle也就是我们的数据库。这么说就清楚了吧，你们就不用看百度百科里那么那么长篇大论的一些东西了，就没有必要了。你记住这仨就就可以了。OK好了，然后我们往下走啊。

然后这三者的关系关系是这个样子的，我们的应用程序和第三方做交互okK然后第三方和IM做交互，他们之间做交互。OK就是他们之间进行相互的交互。这个图呢无所谓，我们到时候写代码，我们到时候拿代码来过一遍。

你就知道他们三个人之间的关系了。OK好了，这个图像放这里啊，到时候我们拿代码去看它。

好了，我们往往下走。拆规范总结一句话，什么话，就是事物协调者与数据库之间的接口规范。为什么它叫规范呢？是吧？为什么它叫规范，其实就是啥事不干，指定规矩是吧？就是什么事也不干，指定一些规矩。

然后让全世界所有的人来遵守他这个规矩进行开发。是吧这个可以把它理解成。我们的JDBC就是和GDBC的地位是同等的是吧？就是。J twoEE是吧，它定义了JDBC的规范。

然后呢my circlecle是吧？然后呃oracle是吧？然后circle server，然后DB two是吧，等等等等。一些数据库的厂商来实现GDBC的规范。OK然后拆规范也是同样的道理。

我定义了分布式事物的解决方案。然后你们每个数据库厂商自己去实现它去。ok 。能理解吧？乌龟的屁股规定对，然后乌龟倒立。上面规定是吧，规定在上面是吧？好了，这个这种这种东西我们就过了啊，我们先过了啊。

好了，叉I规范的实现在分布式集群下，一般的加代理层来充当TM的角色，实现对事物的支持。叉I规范是吧？它主要都定义了一个第三方是吧？第三方跟其他人的就TM和AP和RM之间的交互。

那么这里面其实我们额外引入的就是1个TM。因为前面的东西呢，外部程序和数据库我们都是必备的，我们只需要额外引入1个TM就OK了。好了，我们往下走。

两阶段提交协议和三阶段提交协议就是根据这一思想衍生出来的，就说前面有差异规范，然后所后面才有了两阶段和三阶段提交协议。两阶段提交协议主要保证着分布数的原则性，以及所有的节点，要么全做，要么全部不做。

这个是比较重要的一套理论。这个理论呢支撑了后面好多框架的实现。比如说LCN啊C塔啊都是两阶段的两阶段的实现。然后把这个学了，你再学它们，那就非常简单了。OK好了，我们现在开始学习两阶段提交协议。

OK好了，往下走。两阶段提交协议呢，我呢不准备从那个。😊，就是那些特别理论的什么第一阶段投票啊，那些开始，我准备从一个实际的例子来给大家讲，就是讲完这个例子，我估计你对两阶段提交协议。

基本上80%就掌握了。好了，实际的例子是什么呢？就是这个西式的婚礼。大家可以看一下啊，图中所画的三个角色，这个这哥们儿是一个服务。它是一个服务，它也是一个服务。他挂着一个数据库。他也挂着一个数据库。

就是他们两个是独立的两个服务。然后这个呢是一个第三方啊，这是牧师是吧？你从穿着上应该能看出他是牧师，不是是第三方啊，不是第三者，这是第三方。好了，我们来我们来看一下啊。

第一阶段就是牧师给这个服务发一个请求。说你愿意娶这个这个女人吗？怎么着怎么着怎么着，然后他发个誓，等会儿我把微信和钉钉退了。那么太吵大家了。好了，这是D，这是牧师给他发出去的一个请求。这个请求就是让他。

😊，去做一些事情，他去想一下这些事情是吧？我先彩排在我内心里先彩排一下，这是我能不能做。然后呢，然后他心里嘀咕嘀咕了一会儿，可能当时也没想是吧，已经嘀咕好了，嘀咕了一会儿说我我愿意，然后呢。

牧师又向他发一个请求，说你愿意嫁给他们怎么着怎么着，然后他也嘀咕了一会儿，说我我愿意这就是两阶段中的第一阶段，他向他发请求，他说他愿意给他一个响应，他向他发请求，他说他愿意给他一个响应。这样的话。

这个第三方协调者是不是就收到了两个服务执行没有问题的一个反馈的结果，说这俩都愿意ok这就是这就是第一阶段就完成了，就是彩排先完成了。那你们俩先有个心理准备，是不是这是第一阶段，然后呢，第一阶段完成。

如果都说愿意的话，那么就进入第二个阶段。第二个阶段就是牧师，然后再向他发一个请求，说那你就提交吧，说既然如此，面向对方握住双手宣告那个发个誓交换个戒指是吧？这就是最后落库了，知道吧？

就是这件事已经已经敲定了，落库了，就是就是持久化到磁盘上了，然后他呢然后开始开始心理经过复杂的心理斗争，哎呀，我某某某怎么着怎么着怎么着好了，落库踏实了。然后这边呢也向他发一个请求说是吧？

你赶紧你也你你你你也落库吧，你也持久化吧，反正你俩都没问题是吧？然后他就说我愿意嫁给他，他说他愿意娶他是吧？不管以后离不离的，反正现在都先同意了，然后最后失误完成。

保证了数据一致性也就是说他执行的业务逻辑，和他执行的业务逻辑。目前来说保证的是一致的，就是说他想娶，他想嫁。不会说在第一阶段的时候，他想娶，他不想嫁，牧师也不会说是吧，说你愿意你愿意娶他吗？他说他愿意。

然后他你愿意嫁给他吗，他说他不愿意，牧师也不会也不会那么尴尬的发起第二阶段嘛，是吧？应该应该不会啊，所以这就是两阶段保证了最终的数据一致性。

ok。好了，这个通过这个例子，大家应该大概理解脸就段是干嘛使的了吧。😊，单方反悔。嗯。咱现在先不讨论这个异常情况啊，异常情况后面再讨论，先把正常的流程我们搞清楚，理解了吧？理解的话给老师敲个一。嗯。

好好吧，老老宋我又来了，你6岁的孩子来了吗？😊，牧师不愿意了啊。没关系，牧师不愿意，又不是他姐啊，好了，老宋的儿子也来了。好了，往下走啊。好了，通过前面的学习，我们大概知道两阶段整体是一个干嘛的。

但是我们还是得把两阶段快速的过一遍，两阶段分为。😊。

投票阶段和提交阶段。第一阶段叫投票阶段，就是这个第三事务协调者向每一个服务发送一个请求，就是投票预预提交。然后每个服务呢执行事务，大家注意执行事务，呃。

回到我们的那个实际编码中就是执行我们的circle语句。大家看我这只是执行circle语句。还记得我们在最开始所说的begin transaction action执行业务。

然后commit或者row back吗？还记得这句话吗？还记不记得刚才我所说的这个第一步、第二步、第三步。记得是吧？如果记得这句话，大家应该看到我这边写的这个只是执行事务。

也就是说只是执行我的第二步并没有提交。也就是说第一步开始了，第二步执行业务，没有干别的是吧？等着最后的提交，所以这就是第一两阶段的第一阶段只干这么点事。然后同样的道理，这边的服务也是这样的。

他也不干别的，只是执行业务，并没有说我们的第三步他也执行完了。okK这就是第一阶段投票阶段。好了，往下走。如果在第一阶段。

所有的操作都为同意的时候。也就是说两个服务执行的都没有问题。那么我们的系统进入第二个阶段，第二个阶段就叫提交阶段，提交阶段怎么整，就是他给他给每个服务发请求，说提交去吧。然后大家注意一下。然后服务里面。

这里面会有一句话释放资源。大家理解一下这个这个字啊，就是这边把把它所发的请求给它提交掉，提交完了之后把资源给它释放掉。你想把这几个词记在脑海中，一会儿我会总结两句段的时候，把这些东西都给大家讲到。

就是它的优点缺点，就这几个字释放资源。理解啊，释放资源之前呢，它肯定要进行提交或者回滚。因为资源一旦释放了，它就失去了对数据的控制权。所以在释放之前要么提交，要么回滚。

此时我收到的是提交O这是正常情况下是提交。然后完了之后给他一个响应，反馈一个结果，最后完成事务。OK这是正常情况下，那么异常情况下呢。就是说在第一个阶段，有一个参与者返问是no。

就是有一个服务执行出错了，协调者在规定时间内没有收到参与者的反馈。也就是说，那个第三方在那等你给他发了个请求，等他的响应，结果没等到他的响应丢了，还不知道怎么了，或者他服务挂了，没等到。那么。

就属于我们所说的这个第二种情况，协调者在规定的时间内没有收到参与者的反馈。此时，两个条件满足其一就发送回滚的指令。回滚的指令怎么发送，就发发一个回滚，说你回滚嘛。然后这时候他利用本地的日志进行回滚。

大家注意一下，利用本地的日志进行回滚。其实这个里面还是利用到了我们我们单击的事物的。原理就是单击事物的实现机制。单机的事物的机制，这个应该理解吧。为什么我跟他说日志比数据重要呢？

也就是说数据可以丢无所谓。只要日志在，我可以对它进行潜滚，也可以给它进行。回滚。这个能否理解？嗯，Ladiesd and gentlemen，现在能不能理解？把这些点都记着，一会儿我会总结的时候。

把你们的疑问全部一个一个给你们解开。好了，能理解就好啊。好了，那么这边的服务呢也同意我们快速过过完就OK了。好了，没了好了。😊，前面就是两阶段的正常情况和异常情况，我都给大家说清楚了。

但是它里面会有各种各样的问题。包括大家刚才也提问了好多，你们提问的那些问题呢，都在我这张PPT里，我全给你总结出来了。

好了，刚才有一个人说牧师不愿意了呢，或者牧师挂掉呢，那就是单点故障。也就是说协调者是吧？有的叫TMtry三个man，有的叫TC叫try三个coordinatorTC如果他挂了呢，那整个事物就无法保证了。

就是两个服务，不知道谁给他发指令，也不知道他给谁响应这个指令，所以他挂了就有单点故障。okK这个说清楚了吗？这个清楚了吗？清楚是吧？好吧，那么第一个清楚，我们说第二个，第二个阻塞资源占用数据库连接。

导致性能低下。这什么意思？还记得我刚才所说的在第二阶段有一个东西叫释放资源，还记得吧？释放资源。示放的前提是占有为什么要占有资源？大家想一想，为什么要占有。你比如说我执行了一些circle，我不提交。

我等着协调着给我发指令，让我去提交，我再提交。在我等待的这段时间内，我能不能把资源放掉？思考一下这个问题，在我等下一步指令之前，我能不能把我占用的这个数据库的连接给它放掉？不能是吧？好了。

这个大家都达成一致啊，不能是吧？喵喵喵喵和这叫。这叫新名子名是吧，还是新名呀？能且听且且听风盈，冒出一个棱。那我给你解释一下它不能为什么不能？如果它释放掉了，比如说这是一个外b服务。

外包服务连了一个数据库。我现在通过这个连接操作了一些circle， update date insertser等等等等，操作了一些circle。然后我把连接释放掉了。下次我再建立一个连接。

我能提交上一个链接操作的。是事物吗？就是上一个连接操作的这些srcle语句吗？能不能？且听且吟。且听分吟，能不能。这个应该很好理解吧。肯定不能啊是吧，肯定不能是吧？这个那哥们呢那哥们且听风吟啊。

不能好了，你已经理解了啊。好了好了，我就当你理解了啊，所以说连接必须占用，不能释放掉。冲冲冲。太莽撞了，怎么又能怎么又能呢？哎呦，我的天，清楚了吗？这句话就阻塞资源。占用资源。

所以占用了数据库的连接这个连接如果它占用了，比如说数据库的连接有100个。你100个请求来了，这100个请求占住了。那么第101个请求来了，没没有连接去服务了，所以会导致性能低下。这个我说清楚了吗？

说清楚的同学敲个一。清楚了是吧？好了，哎，这个清楚之后，我们接着说第三个。数据不一致，两阶段出错，数据不一致，什么意思？举个例子啊，这是第一阶段。定一阶段的话，我给你发一个请求，说你去执行吧。

给你发一个请求，你去执行吧。结果你你俩都说都可以，那么我就会进入第二个阶段。第二个阶段我就会说你去提交吧，叫commit是吧？然后呢也会给他发一个请求，说你也去提交吧，commit结果。

这个请求在路上丢了。OK这个请求丢了。😊，知道吧？所以他执行了他没有执行。所以就会导致数据不一致了。理解吧？因为一共就这两个阶段，我们第一次为了防止单向调用的连接，无法后悔。我们加了连阶段。

但是两阶段第二阶段又出错了，我们没有其他的服务做保障了，所以数据就不一致了。这块能不能理解？也就是说，两阶段会有数据不一致的场景。真正结婚的时候，新娘和伴郎跑了。对。就最后让交换戒指的时候是吧？

然后然后斑郎实在看不下去了。

抱着新娘的就跑了是吧？这也挺尴尬的是吧？新郎那边数据执行完了，落库了是吧？然后新娘跑了也会有这种情况啊，那怎么办？

好了，这个问题我先给你说怎么办？我举一个实际例子，回滚不了了，也没法回滚是吧？新新来还可以回滚是吧？去民政局把结婚证撕了，换成那个换成离婚证，这都可以。但是实际中可以那么搞是吧？因为人是活的。

那么在我们的系统里怎么搞呢？是吧？系统里要要要有备份，举个例子啊。😊，第一个服务，比如说订单服务。第二个服务叫库存服务。订单服务呢要做一个事叫insert订单，这个大家能理解吧？就是插入一条订单。

库存服务就是uper date的一个库存减一是吧？uper date的一张表里，将那个将那个库存字段减去一个一。然后减去一之后没问题，这边insert order加一个一。

系列 6：P111：两阶段提交协议、三阶段提交协议 - 马士兵学堂 - BV1RY4y1Q7DL

或者insert不好理解的话，大家该这么这么来理解啊，insert啊，不是阿巴 data一个字段all呃从一把它变成2，这是一个状态啊。就是说这边比如说库存有两个，就是从二变成一就是少一个库存。

然后这边呢当它做成功之后，把订单里面某一个状态，从一改成2来这块这两个事物能不能这两个事物的操作，我说清楚了吗？这块说没说没说清楚。清楚了是吧？好了，那当遇到数据不一的情况该怎么办呢？是吧？

我们可以写circle。去检查检查一下，比如说这个表里它是不是2，如果它是2。我去看这个表里是不是一，如果是一，说明这俩人啥也没干是吧？就是连连那个教堂都没去，在去之前就反悔了，那无所谓，不管了。

如果说这边改成了一。也就库存变成了一，少了一个，结果这边还是一。现在是不是就不一致了？因为如果它变成一。下面这个应该变成2，这才是数据一致性的，结果到这就不一致了，这是一种情况，这是一种异常的情况。

那么还有一种情况。那就是他。是2。然后呢，他。变成了2。就说这个还是原来的二，就是库存没少。结果这边呢订单把状态变成了2。能理解吧？此时这也是一种不一致的状态。这个能不能理解？要么就是它是一，它是一。

这都是不一致的。它上面库存是一的时候。下面的订单应该变成2，这才是正确的是吧？这是正确的。然后一一也是错误的。好了，如果你知道数据哪种情况是正确的，哪种情况是错误的，那么你是不是就知道哪种情况下出问题？

比如说这两举这两举这两个例子，这两个例子出问题了。它上面是一，也就是从二变成了一，结果下面是一，下面是一，我怎么整，要么把它。调成2。要么把他调成2。能理解吧？也就是说上面是一和上面是一。

下面就必然是2，上面是2，下面必然是一，这才是正确的状态。要么只能把它俩都调了，要么。从这个例子，要么它减去一个一是吧，要么它减去一个一就是一个货的关系，这个能不能理解？就是我们发现异常数据之后。

手动给它改掉。能不能理解能不能理解我说的这种方式？能离的话就敲一。

如果不能理解，把你的问题打出来，手动改是不是很累，当然很累了。

好啦。前面有个同学说手动改很累是吧？当然当然是很累的了。所以在好多大公司里有一些脚本一直在线上跑着批量的去修改你的就是一些监控类型的脚本在线上跑着。当发生数据不一致的时候，它会这些脚本会去自动执行。

能理解吧？这些脚本会去自动执行。理解吧，什么时候去现证数据，这个取决于你的业务。举个例子，当。😡，比如说现在是呃8点52，举个例子，现在是8点52，那么我的脚本肯定要去查吧，是吧？先去查分两步。

第一步去查。第二步去改是吧？那么查的时候是不是查这个数据before是吧，再。

8点50之前的OK8点50之前的数据，我要看它是不是符合一致性。如果不符合，我把它改掉。如果符合拉倒。

能理解吧？可能有的有的人查的，我说的是8点50，这个条件你可以自定义是吧？你可以选成是8点45到8点50，就是用between去查是吧？between45到50，然后这个查过之后。

再between50到55，然后再beten55到60，能理解吧，就是分阶段分阶段的去查一批一批的去扫描。OK这话能理解吗？😊。

万一两个业务服务都是更新操作呢，我刚才所说的不就是都是更新操作吗？

我刚才所举的例子都是更新操作呀。你好好想一下。为什么要执行这些脚本？因为为了防止数据不一致，这是这叫这叫兜底的方案。兜子咋写呢？就是裤兜的兜兜底的方案。OK你也可以把它弄说成是降级的方案。

这个不同的公司定义不一样啊，能理解吧？前面我所说的这个意思能对吧？从手动变成自动。能力他的目的是做啥吧？这是目的啊。我一开始就是要。😡，啊，对，就这个意思啊，麦多的都老师再讲一次。花了马，如果你。

大厂真的都是这样做的吗？当然。好啦。我晕。啥啥意思，你晕了，还是我说的不不不明白。来，这块清楚的同学给老师敲个一。再讲一遍吧，清楚的敲个一，不清楚的敲2，我看看有多少人需要讲，有多少人不需要讲。

因为这是公开课照顾大多数同学。好了。好了，这是一一的一的多一些啊。😊，好啦。😊，怎么二又多了？好尴尬，如果不懂的话，你可以扫描屏幕右下方的二维码，让老师给我拉群给你解答就行。

你你把问题提交给屏幕下方的二维码，到时候我给你解答啊。好吧，可以吧？这样跳二的同学，我也给你提供了你的解决的渠道，你可以扫描右下角的二维码，到时候我会让咨询老师联系我，我给你解答，好吧，这样可以吧？😊。

一对一比这样集中集中解答，更能节省一些其他的时间啊。好了，这个问题就过了啊。😊，讲快点，太慢了。这个刚才还有的同学说可整的快呢，还让冲奖，你说我怎么整，所以。😡，一个一个来啊。确实慢。那你说咋整。

速度正好，有的说快了，有的时慢点，说速度正好行吗。我们看代码啊。我们看下代码吧。是的，每个人理解都不一样啊。坏的同学呢，你先忍一忍是吧？等会我现在起段代码，大家直接看代码就好了。😊，众口难调是吧。

那个这个你你自己调整你自己的时间啊，时间在你在你手里把握着是吧？😡。

等等，我请一下服务。我想一个一个起，把这仨服务，这个是一个库存服务。然后这里面呢一个订单服务。然后。

不影响那个PPT啊，我想把它去掉。我把地我把那个代码起来，你们应该就差不多知道知道怎么啥意思了。

Yeah。好了，先把代码上上来啊，然后我再给你。打开一个数据库。idea该更新了。

这个很重要吗？再说了，你怎么能看出我idea的版本呢？

是吧下面该更新了是吧？2020年1月3号的差不多了。才过了10个月嘛？不就是啊没必要啊。好了。然后我现在给大家看一下我的数据库。然后数据库呢，我这边有两个库，这一个库这是一个库。然后这个库呢是库存。

然后这个里面呢。

商品ID我写个一，然后。呃，库存我写个100吧。OK就是我现在去购买一号商品，一号商品有100个库存。大家记着啊，然后呢，我去新建一个这个订，这是订单库，订单库里什么也没有。OK好了，然后现在我来。

我来做这么一件事儿。好了，大家先先理解一下我所说的这个业务啊，先调库存服务去扣库存。我们执行这个接口，这是订单服务里的这是订单服务里的一个接口。

是吧啊那个old add，然后点进去之后，它去调了一个库存服务的接口。这个这个ID呢我一会儿会传进来，它传的是一，然后呢，我也会把它写到呃，先看这个吧。

固I在这收，然后我传进来的是一个一，然后呢把它调过去，然后他去调用库存服务，然后减一。然后我这里面呢模拟了一个异常是吧？就是说。执行订单新增的时候出错了，但是在库存的时候没有错。来家看一下啊。

库存的时候没错，然后代码在这里。是吧库存直接就看它是吧，把这个库存减进去一个一，然后直接就更新掉了。okK代码很简单。好了，然后我们现在开始直接请求。😊，好了，我先请求一下啊。😊，好了。

报1个500错很正常是吧？这是我故意模拟的500错。然后大家看一眼啊是吧？这是50错是我们故意模拟的。然后我们看一下数据库。数据库呢大家看一下，原来是库存是100。我们看一下它的结果变成了99，对吧？

库存少了一个。是不是？然后订单呢？并没有新增，看到问题了吧。来这块如果能看到问题的同学给老师交一。代码很简单，问题看出来了吧，库存少了一个一，调这边的服务少了一个一，结果这边的服务呢想加一没加上。

是不是就数据不一致了？O所以这就是我们这节课要解决的问题。好了，怎么解决这个问题呢？很简单。😊。

嗯。大家看一眼，马上就解决了。然后等他起来，我把数据恢复一下。

库存给它变成100吧。

。

。好了，我们现在再来请求好吧，还是跟他的请求走走一把。好，还是报50错。然后我们看一下日志。😊，还是报500错，错误跟跟他一模一样。然后现在看库存。我们期万的库存是多少？是不是报错了。

就是两个服务之间处理出错了，是不是库存不应该少100是吧？然后刷新一下，不停的刷新还是100，订单呢也不增加。😡，是不是这就对了。😊，能理解吧，现在能理解吧？所以说现在这个问题我们已经解决掉了它。

改对了。😊，怎么控制的，你先看结果。怎么控制的，我会告诉你的。来，结果能理解吧？就是我现在实现了这么一个功能，把它给把这个问题给解决了。能理解吧？好了，结果能理解的话，我们我们看一下它怎么做的啊。

首先怎么做的，首先得启动一个。😊。

第三方这个第三方叫西塔是吧？大家可以看到我是用我是这么启动的，然后怎么启动的呢？它在这里有一个。

这个组件叫西塔。ok。😊，你直接执行它启动就OK了，是吧？直接进行它启动OK了。😊，然后它里面会有一些配置，然后配置的话呢，你可以去这里看，然后叫registtry count。然后大家可以看一下这个。

然后这个配置里面呢，我我在需要修改的地方都加了修改两个字。你如果拿到这段代码的同学呢，你你看修改的地方就可以了，是吧？我这里面用了配置了一些注册中心，然后呢呃这里面用了fill。

这个type用的fill，这个都不用改，这个是它默认的fill，然后fill呢对应的是file点com是吧？然后我们去看file点com，然后点开。大点com这里面我也写了修改，需要修改的地方。

这个大家现去自己看就可以了，然后往下走，主要是store这块目呃，我用的是DB，然后DB呢对应的对应的数据库的配置是这个样子的。OK是不是是配置数据库的呃连接。

就JDBCULU的 password这些东西，这些简单好了，这就配完了。中间件就配完了，这是我们前面所说的第三方协调者。那么我们呢再来看每个服务需要做些什么。其实如果你都用默认的话，每个服务很简单。

只需要引入一个架包。

引用一个价包就可以了。阿里巴巴的sta架包就OK了，别的不用。知道吧？然后这个服务也是别的，不用，只用阿里巴巴的一个战包，别的不用。然后呢，在order里面，也就是说在服务开始调用的地方。

大家可以看一眼，在服务开始调用的地方，我写一个global transaction省。把它当成一个全局事务，就加一个这么一个注角。原来不是艾 try三嘛，现在写gbal try三就OK了。理解吧？

现在理解要做这几件是吧？然后还有你去网上会找一些文章，会在或者说在某个在服务里还要配置呃配置这些呃result下面写fi andcom和 rejection co。其实这些不用默认情况下不用也是可以的。

你只需要引入一个炸包。这块引入一个炸包，然后加一个注解。就O了。加一个注解。就OK了，别的没啥。怎么用清楚了吧？然后想要这套代码的同学呢，扫描屏幕右下方的二维码，招募的咨询老师去要就OK了。

很简单很简单。

没有吧。然后代码呢，我大概给你过了一遍，然后其他的呃其他的细节呢，你扫描二维码，要代码就可以了。and度log表需要自己创建吗？需要需要自己创建。

大家可以看到我在呃我在每个服务里都创建了一个安度log表，这个都需要自己创建的啊。ok k。好了，这个都需要自己创。因为每个服务的回滚都需要依赖自己的自己库里的andlog。然后这个西塔呢。

它对两阶段做了一个优化，大家知道优化在哪吗？好了，现在我给大家讲一下s塔的优化。

西塔把这个阻塞资源给它优化掉了，就是西塔里面这个两阶段没有这个了，它优化掉了。为什么说西塔是一个高性能的分布式事务解决方案呢？是吧？毕竟阿里的东西它必须得承受高性能的考验。为什么它高性能的nction。

大家思考一下，如果让你去解决性能低，你怎么去解决。西塔怎么解决的？大家思考一下啊，它。性能的平静点在哪？在占用连接是吧？占用数据库的连接，也就是这个这是它的平静点，它怎么解决呢？

它解决的办法就是释放连接是吧？只要把连接释放掉，我就知道我我就提升了我的性能了。先说这个点，先说这个思路，大家能不能理解？思路能理解吗？能理解是吧？好了，既然思路我们能达成一致的话。

那怎么去怎么去释放它呢？我们原来不去释放它是为了保证我们的提交提交和回滚是吧？在一个链接里，就上一个链接，我们做了一些数据，通过同样的连接，我们去提交它去回滚它。那么我们把连接释放掉之后。

没有连接可以依赖了。那我们依赖什么呀？我们就去依赖每个服务里面的undolog表。anddo log表能能明白啥意思吗？大家大家看一下啊，我我我给大家看代码的就知道这个这个东西是啥啥意思了。呃。

我在执行这个表的时候呢，我我我在这打个断点嘛，然后拿debug启动。

等会我拿debug启动，在这打个断点，大家就能看到了。我在这里打一个断点，也就是程序执执行到这之后卡住了，卡住之后。调用库存服务是不是就执行完了？大家思考一下，调用库存服务是不是就已经有返回了？

这块能不能理解，就这个找错误去验证它的这个这个思路能不能理解啊，在这打一个断点，到时候直到执行到这卡住。然后这个服务是不是已经调用完了？能不能理解，给点给点反馈。

是是吧？是是吧？好了，那我现在就来请求了啊，请求那就等断点卡着，请求一下。好了，断点卡在这里呢，大家看我的数据库。😊。

然后我们去库存表好了，这张表。好了，来看数据库里。这是我前几天做验证的这条数据不管，这是19号的不管。我们只来看这这条22号21。0嘛，这是现在的数据库。好了，我把这个东西复制出来，然后把我程序停了。

OK停了吧，别浪费我的精气心能在这耗着。好了，我把成员停了。然后我把这段我把这段给大家复制出来。😊，然后复制。编辑。怎么换行呢？看到换行给我说一声啊。回车。行了，不管了，无所谓了。我们来搜一下啊。

我们说befo大家可以看到一个看beimage。然后我们再搜after。

系列 6：P112：组合存储组件，分布式事务如何解决？ - 马士兵学堂 - BV1RY4y1Q7DL

没事，这些东西不重要啊。然后看after image。视图自动换行是吧，视图。自动换啊啊。行吧，无所谓，语言人能选jason是吗？啊。啊，无所谓了啊，让他看一下就就知道了。那个。我不不那么费劲啊。

这不是重要的，重点是看这个beforeim好吧。After。in卖主要看这两个。好了，从这两个名字你们能看出什么什么什么东西来了。😊，能看出啥东西来了，那从这两个名字没关系，工具不用纠结啊，工具无所谓。

里面有一个befo。有一个after。是不是在第一阶段，我把链接释放掉之后，我放心大胆的去释放。因为我那数据库已经存了，它从哪来的，befo之前是什么样子，after之后是什么样子，我都存下来了。

以后你要提交，要回滚，我这都有记录的，所以我把连接释放掉了。现在理解了吗？理解了是吧？okK这就是这就是西塔对连阶段性能的一个改进。好了。的，到此为止啊，对他把数数据放到了表里。对的，是这个样子的。

O不是不是呃，你说的这句话是对，你说的这句话是对，就是死糖。你这个话是对的。但是大家要记住，它是把全局global全局事物的分支事物的回滚信息放到了表里。并不是说数据库原来的那些日志信息放在表里啊。

能理解吧？这是全局事务分支事物的业务信息，业务的回滚记录放到了表里。是这么一个意思啊，并不是数据库自身的那个read do log and log，还有blog，并不是那些啊。

因为你看啊，这里面其实涉及到一个框你要做框架开发的一个一个东西，就是你要做框架类的开发，就是你尽量的不要去改基础组件的一些机制。就是mycyclcle它本来什么机制，你不要改。

你只是基于它的上层去改动它。一般的做呃框架或者中间件的开发都是这样子。人家原来是什么样，几乎不改在上面做扩展OK。好啦。我看一下啊，现在给大家一分钟的时间提问啊，两次提交还要读出来再写吗？

那不会性能很低吗？什么叫两次提交还要读出来再写。这句话没懂啊，没懂，为什么要读出来呢？为什么要读出来？没我没有说读出来啊，回购前，如果有其他事误操作成功呢，如果这样如果有这种情况，那就算倒霉是吧？

那就算倒霉了。这个情况呢也会有处理方式。首先第一个。你的这些业务操作的，比如说update从1到2是吧？你一般的业务操作，这个只是这个业务把它从1到2。如果说其他的业务也把它从1到2。

那你说这个一这两个业务是不是要合并呢？你写两个代码，实现实现一样的sircle语句。首先在实际工程中，这种概率很低。所以你说的这个其他事物操作成功也不是那么大概率的存在。O这是一个问题。第二。

如果说你真有这些问题，那么自认倒霉人工补偿。只能这么做，但是人工补偿的概率也很少很少，几乎不会遇几乎不会遇到。

理解吧，刚才那个谁夕岩理解了吗？

示放掉以后。回滚的请求怎么找到这条记录，根据根据什么键然后然后嗯好了，这个问题啊，这个问题呢呃我在这里不做过多的解释，大家可以你仔细研究一下这张表结构叉D。

全局是5ID不nch IDD分支是5ID是吧？能确定。这样就能确定是哪个全局事务的，哪个分支事务。改的了吧，是吧你从这个表结构就能就能就能知道啊。Branch IDD叉ID圈接数ID分支数ID是吧？

这这这这个都有。

所以这就这个不用担心他怎么查的，肯定是能查的。啊，第一次写入log，因为数据库连接释放了，连接上提交，不需要从underlog里面读之前的操作吗？之前的操作，我刚才就是刚才解释的也是你这个问题啊。

就是你从他这读。

这不就读出来了吗？OK你从他这读也就读出来了。😊，并且还有一个。如果提交的话，大家想一下啊，你想想这个影响性能，如果是提交，你该怎么做？直接把这个数据delete就行了嘛。把嗯把那个。

underdo log这条数据delete就行了吗？这不就完了。😡，な也ば。如果要回滚呢，那就把它回滚了。但是在现实工作中，99%是delete。所以很简单。只有10%可能呃1%要回滚，可能都不到。

可能是99点多少多少多少是吧？是delete，其他的是回滚，这个概率非常小。那你就话。如果服务是多个数据源怎么解决？多个数据源我这里面没有写代码和这个思路类似。ok。因为要再读一次话。

所以刚刚问性能会不会，所以刚刚问性能会不会下降。如果说读与不读来做对比的话，读性能肯定会下降。OK读与不读来对比肯定会下降。但是读也比占用连接占的资源要小。你把连接迟迟把着别人来用用不了。

至少你把连接释放掉，我现在来读一次又能又能咋地？孰轻孰重，我觉得你对比一下就能对比出来。理解了吗？这个叫啥小这个小孩儿小孩啊小孩儿。😊，明显了吧？哦，好了。😊，没想到你就长大了啊。

好了，这块可以过了吧。😊，这三个缺点我都说了。听到嘛？能过来就敲个一啊。嗯。我觉得我说的已经够够清楚了。所以涉报资的时候已经提交过了，这里面就不存在不需要回滚了。嗯那个。还需要加本地的售后助解吗？

这个啊HW华为，你下去自己试一下，就这种加的这个代码和不加这个代码的区别，你下去拿到我的代码自己去做。我现在告诉你，你下去也得做一遍，万一我告诉你的是错的呢。😡，能理解吧？

这种这种就是自己马上就能知道的东西，自己试一下啊。严炎是啥意思？我怎。😊，好了，这话可以了吧。😊，我们下一我们下一步了啊。下一步okK。

好了，下一步三阶段协交协议。😊。

O是吧？好了，三阶段提交协议有了前面的基础，三阶段会特别简单，课前休息吗？不休息。😊，好了，三阶段提交请就会特别简单。单阶段有有这么三个阶段看commit，等会拿着拿着笔过来。😊。

can commit pray commit or do commit三个阶段。为什么要有三阶段呢？大家想一下啊，它有这里面有，其实三阶段在实际中用的几乎是没有。但是他这个理论提出来呢。

也对二阶段有一个改善，就是对二阶段有一些改善，仅此而已改善。大家记住这个词啊，改善没有说全部解决二阶两阶段的问题，这是什么意思呢？😊，就说三阶段提交协议，你看啊和两阶段相比主要的区别在哪？

两阶段提交协议是啥？比如说这个这个猫嘛。😊，我说猫，你去给我干一件事儿去是吧？抓个老鼠去。😡，然后比如说咱俩是两阶段，我说你去给我抓老鼠去，然后你。😡，嗖一下就上房了是吧？开始抓老鼠去了是吧？

我说你去干，你就开始动了。😡，这是两阶段的第一阶段，然后你把老鼠抓来给我摁在爪子下，然后问我主人要不要吃是吧？我说吃是吧？这是提交是吧？这是两阶段。第一，你先去抓是吧？第二。

你回来等我的指令要不要吃是吧？这是两个阶段，这这块能清楚吗？好了，三阶段是啥呢？😊，就是你从两阶段来看，我说你去抓，然后你马上搜就跑了。然后三阶段是什么意思呢？就是说我说你去抓你不动。

你还在那你还在那猫着。😡，你脑子里想了一下，我该不该去抓这个老鼠，我能不能逮得到哦，可以，这个老鼠比较胖，跑得慢，我肯定能抓住，我给主人说一声，我能抓得住是吧？你不动，你知道吗？你不占有任何系统的资源。

你还在那待着。😡，是吧这叫要看肯命的，你先评估一下。是不是？然后你把你的评估给我反馈之后，我说你能做是吧？你能做，那你去吧，然后你嗖你才跑了是吧？这是这是三阶段的第二阶段，相当于两阶段的第一阶段。😡。

这有什么好处呢？就是说。😡，我能把那些。发生错误的情况，对资源的占用给他下降。这句话说的比较绕，能不能理解？就是说你本来抓不住老鼠是吧？你抓不住结果如果在两阶段的情况下，你搜上房了，结果没抓住回来了。

你浪费了。😡，系统的资源。如果是三阶段呢，你第一次说老鼠这个老鼠很瘦很强壮，跑的很快是吧？弹跳力特别好是吧？我就抓不住，然后呢，你呢你也不用动，你告我一声，你抓不住，拉倒，你又没有消耗任何能量。

浪没有浪费系统的任何资源。😡，能理能理解我说他俩的他俩的主要区别在哪了吗？能不能理解啊，猫喵。喵呢喵跑了。你已经执行第二阶段去了，完了。这孩子三阶段三阶段没学会就跑了。哎，又回来了是吗？抓了一下。

没抓着又回来了是吗？啊，理解理解就好啊，开个玩笑啊，不要介意啊。😊，怎么就知道抓不住呢？莫言，你还获诺贝尔奖了，你这你你自己想想怎么就知道抓不住，他看老鼠比较瘦，老鼠弹跳率还比较好，距离还比较远。

猫杆吃饱是吧？如果回到我们系统中，举个例子update一条数据，比如说叫flagflag只能是0或者一是吧？这个记录或者说叫if deletete这个字段。我举个例子啊。

只能是零或者一一是删除零是不删除这个字段只能是这俩，结果你来一个请求，说给我把它干成3。😊，我能不能知道我能不能把它改成3？当然不能了，它只能改成零和一，不能改成3，我就说改改不了。😊，理解了吧？

这只是举一个例子啊，我觉得从这个例子上来说，你应该懂了吧啊，莫言。😡，谁来管理这个谁里库自己去管理。可以结合订单模结合订单模块呢，订单模块if这个订单是否删除。

就是订单表里有一个字段叫if deleteelete，这也可以啊。这样可以吗？是吧。就是先校验一下。对，就是先校验一下。OK这个校验一下，比你去执行业务逻辑占用的资源要少的多。明白吗？

又不是真去改别upate，直接upate一条语句下去了，结果出错了，又回来，是不是这这就这就没必要了。就是从资源的利用率来说，就是对资源的耗费上来说，校验肯定比实际去做耗费的资源要少。😊。

你入话。这个需要资金简代码这样吗？一般不用这个不用，这个不需要。这个一般都是框架给它分装，框架给你分装好的。如果让你自己去写这种这种教验的话，累死了，累死了。OK还要给大家说一点啊。

不管两阶段不管两阶段还是三阶段，就大家觉得很复杂，就这些东西很复杂。什么第一阶段等着等着响应，等着同意，然后等着no，等着超时，考虑各种各样的情况很复杂，因让我把它实现的太复杂了。

大家大家要想一个问题啊，在我们做软件。在我们做软件开发的过程中，你想到很多很复杂的中间件或者组件的原理是吧？这些东西做起来特别复杂，你不用担心越复杂的东西，越有人给你分装好了，让你直接用所以不需要担心。

😊，知道吧？活人还能被不得翠配传到桥头自然值，对吧？就这意思。当你要用的时候，你要实现两阶段，我怎么做怎么做？好了，阿里巴巴给你提供了一个sta，引用一个价包写一行注解搞定。对。

就是这个人说的program对吧？就几行配置而已，所以不要担心啊。好了，这块可以过了吧。😊，但是面试官会问，所以我才给你讲的这一个半小时呀，就因为面试官会问我才给你讲了这一个半小时嘛啊，懂了吗？喵有？

😡，我跟你讲了这么多长时间，是是让你们干嘛的，是吧？如果说讲讲它的使用，引入一个架包，引入一个写一个注解，你你就会用了，是不是？讲了那么多，不就是为了让你理解原理是吧？跟面试官聊嘛。

然后抓抓老鼠的时候先评估一下再去抓嘛，是吧？提高一下自己系统系统的性能啊。😊，好了，三阶段主要的就在这里啊，我们我们下一步啊，下一步三阶段呢我把我只说里面主要的这个第一三阶段的第一阶段看commit。

刚才我说过了，评估这个很简单，是吧检查。😊。

检查circleOK这个评估是怎么做到的？能简单聊聊吗？跟他聊过了呀，莫言。😊，我K刚他聊过了，刚才我已经给你举个例子了，if服delete已经给你举个例子了。😊，好了，第一阶段检查circle往下走。

然后在第一阶段。

是吧都返回yes的时候，就是第一阶段都没问题的时候，我们再执行第二阶段PRE commitit好了。第二阶段呢就是我们刚才所说的两阶段的第一阶段，这个也很好理解是吧？这个就快速过一遍这个动画。😊。

好了，然后这个完了。😊。

然后第第一阶段。有这么三种情况，就是有一个参与者返回no协调者等待超时，参与者没有收到协调者的指令。OK这里面多了一个参与者没收到协调者指令，所以他执行。upshop这里面是放弃提交。理解吧。

这块这三个挑战单从字面意s大家能看出来这三个挑战啥意思吗？😊，能不能理解？能看看的看的看的清楚吗？啊。清楚是吧？清楚就不不做过多的解释啊。因为这个前面两阶段已经讲了很多，放弃就好了，放弃直接回滚。

利用本地的数据库进行回滚OK。😊。

然后这个快速过一遍，因为前面脸阶段说这话说的比较多，好了。😊。

PRE阶段执行的都是yes，那么执行do commit这个也简单是吧？do commit执行完了就拉倒了是吧？执行事务释放资源好了，这是do commit。然后呢我们往下走。完成事务。

那么第二阶段发生这种异常，就有一个参照访问no或者协调者等待超时，我们发送absorcomit。就是说有这两种情况的时候，我们发送放弃提交，也就是类似于回滚。okK好吧。

这就是absor commitit，这也很简单，这个回滚一下，无所谓了。

好了，这个动画走完，我们来看几个关键的地方。超时机制的设置。好了，这里面有超时机制，一个是协调者，后面还有参与者。大家可以比较一下两阶段和三阶段他对。性能的一个优化在哪里？

就是说你看啊两阶段在第一阶段发出请求是吧？你去执行去。此时这个服务呢占用了连接，一直占着第二阶段。他第三方要给他发请求，如果请求没来，他就一直等着。

是吧就像可可托海的牧羊人一直在那等着那个等着那个养蜂女的归来，他就一直等着死脑子，一直等着。那么他一直等是不是就占用资源了？😊，一直等是不是就占一直占用着资源，他不懂得超时，等不到了还在等。

所以资源一直在占用。那么三阶段对他做了优化呢，就是说有超时机制，不仅协调者有参与者，也有参与者。在后面我说。这块理解吧？所以说就是等不到了，我释放了。😡，是吧释怀了，你爱来不来，我不用了。

讨论讨论什么月月呢是吧？快点，这块懂了吗？别我在这商量。说呢你还真的在在想莫言和养光女呢，你还想你的月月呢？月月丢了对，月月丢了就别找了，回来是吧，回来接着上课。😊，是吧丢了一个月月。

还有无数个月月在等着你是吧？比如说好多好了，能理解这个超时设置超时的目的吧？你听着呢是吧？好了好了，这是超时的目的啊。PRE commitit超时之后。行调准超市之后，发送回滚的指令。

然后do meet之后发送回滚的指令。节奏快点，时间不多了，刚才让重复讲的也是你时间不够的，也是你放心，时间再不够也给你讲完了。啊，肯定给你讲完是吧，讲不完你别走。到。好了，这这这只超时机制。

协调者超时之后，两个阶段发送的都是回滚的指令。那么大家来思考一下参与者呢。参与者在第二阶段超时就是收不到第三方给我的指令。在第二阶段。我该怎么做？我是放弃还是提交absor，还是接着往下走？

在第二阶段就说我说喵，你去抓老鼠吧，你喵说好。然后呢，第二阶段。你要等不到，我给他说去抓老鼠这个指令。😡，那你说喵该去抓还是不该去抓，放弃，好多人都说放弃是吧？那么喵肯定放弃嘛？是吧？

我说主任我能抓到老鼠，结果主人没告诉我去抓，那我就不抓好了。😡，是吧。好啊，再是回滚。结果呢你看啊到第三阶段的时候，我说喵，你去抓老鼠吗？喵说好，我能抓。然后我说那你去吧，然后喵嗖一下上房了，去了。

那么第三阶段喵抓回了老鼠之后放在我面前了，结果我我走神了，我我我在想回答莫言的问题呢，结果喵不知道我我让他吃还是不让它吃。那你说这只猫老鼠都抓到手里了，它吃还是不吃。😡，是要放走还是吃了他？

系列 6：P113：TCC（Try Confirm Cancel）解决方案 - 马士兵学堂 - BV1RY4y1Q7DL

吃呀是吧吃是吧，那就是。那就提交嘛，对吧，小强是吧，吃。是吧当然得吃了。因为对猫来说，第一主人问我能不能抓，我我说能抓，然后主人让我去抓，结果我也抓回来，也把老鼠摁死在这了。

然后主人又不让我吃我对这个主人有多失望，所以为了表示我对主人的信赖，我把它提交了。😡，是吧因为因为大概率主人让我吃，不然他让我抓他干啥呀？😡，我只是说大概率。啊，没有说绝对的啊。

万一主人就是让我抓来玩一玩，看一看老鼠长啥样子。是吧大概率让他吃，所以他提交记住这块啊，就第一阶段成功，第二阶段。业成功。第三阶段大概率是让我提交的。ok k。如果出现这种张数据，是我们的脚本来检验吗？

是的。是的啊是的。好了，这话能理解吧？大概率大概率大概率。好了，这个我总结一下啊，如果说用两阶段。这种强一致性的事物。没有人能做到百分之百的保证。数据与直线这个C。数据执行。

没有人能百分之百的保证数据执行。ok。我说的清楚了吗？所以只能大概率降低发生脏数据的。情况就是只能降低发生脏数据的概率，但是不能百分之百的保证。O可以了吗。老师三阶段怎么做？三阶段我跟他说了。

百分之市面上99%呢不用。😊，两只段已经够了。第二阶段PRE执行超时收回收到回文指令。回滚指令有没有可能比之前的PI指令相知，那回滚就不白，那回滚不就白回滚了。好了，这个同学说的这些问题呢？呃。

是属于一些异常的情况。这个呢有这么几种情况叫空回滚，叫密档，还有叫悬挂。这个里面的各种异常情况很多，但是这个东西呢我要给你解释清楚呢。耗时很长。所以在这个课里呢不解释这些东西啊。

这些东西在我们VIP课里有在我们VIP课里有这个解释，就是各种异常情况的解释ok。因为公开课我只能把一些核心的观念告诉大家，因为就只有两个多小时是吧？要么3个小时。

我在VIP这个东西我上了20个小时的课。所以不能面面俱到是吧？公开课就so say sorry了啊，对大家。好了，可以理解了吧，这块。😊，能不能理解啊，啥啥情况？咋了？伤心了，你也不是VIP课。

听不着伤心了。不要伤心。是吧毕竟VIP跟非VIP还是有区别的嘛。是不是要不然你让我们那些交了钱的VIP情何以堪？没事，不理解我们报VIP是吧？老师剩下的时间管告了吗？我能理解，如果我想复习份资料。😊。

没课还没讲完呢，管啥告呢？别着急啊，你咋这么想听广告呢？你要想听广告，我就给你说说广告。😡，好啊。Okay。别哭别哭，课还没讲完呢啊。好了，往下走啊，你要想听课多着呢。😊。

老师VIP的课在哪个包里面呢嗯。找班主任找你的班主任去，课证名叫啥？来来来来来来来，等会儿我我。耽误30秒的时间，我让这哥们看一下客栈哪啊。

客栈哪？等会啊，这30秒啊别走，不是广告啊，他说不是广告啊，只是给我们VIP找一下课啊。😊，在网原车三板里。然后这个。分是5从2十一节课开始，一直到20到3030节课。一共时间每节2小时自己去找去啊。

找你的班主任去要我在这里面都讲过了。OK好了。😊。

是吧，go ahead。好了，说着下一个说TCC。现在还有多少人在听课，敲个一。嗯。都在是吧。🤧嗯。哦，都在啊，这移动联通天翼也来了。对对他啊吧，感觉白了头的。啊，猫还在啊猫还在就行。好好好好好。

带着好带着继续讲啊。好了，来继续讲听CC。😊，TCC什么意思？如果学过前面的两阶段，那么你理解TCC就方便多了。从名字上好好看一下，try confirmc中间加一个O，这俩是一伙的，这俩是一伙的。

明白了吗？现在能不能明白，能认识这这这这这仨单词的意思吧？第一阶段。拜一下是一下。如果没问题，第二阶段confirm。如果有问题，第二阶段cancel好了，PCC说完了。听楚了吗？

为什么前面花那么花那么长时间给你讲两阶段是吧？学完两阶段，你再理解TCC这不很很容易吗？😊，为什么要有TCC？😡，大家想过这个问题吗？为什么有脸阶段了还有TCC？😡，想过这个问题吗？讲得好，鼓掌。

谢谢啊。好了，想过这个问题吗？😊，提高性能TC在太差。哎，这。这这有什么性能提升呢？虽然说也有一些性能提升的考虑啊，首先第一步try它是落库的，就类似于C塔的那个操作方式一样，是落库的。性能是有所提升。

但是最主要的原因是这个。你在你的方法里。调用了that KV。调用了up date circle。ok。所以用这个，如果你用前面的连接段，那个的话，你能保证他和他。在一个事物里吗？

能保证readninginess和my circlecle在一个事物里吗？能不能保证？能不能保证快点的？Quly， quietly。能不能往证想想。不能是吧不能保证是吧，都不能保证okK那不就得了。

有TCC来了，明白了是吧？OK我就喜欢这样的这样的学那个。😊，那个这样的朋友啊，一说就一说就懂。系话，好啦。明白了是吧？好了，明白就好，其他的我去。😊，这什么？来其就是明白的同学敲一。不明白的同学敲2。

明白的敲一不明白的敲2，有不明白的啊。嗯。为爱活着了，只为爱活着。小迪。我去怎么二变多了呢？😡，明天会更好。怎么二还边，我操，怎么哎呀，我去。这这啥又是小强，又是老孙的，又是猴子，又是啥呢？

好了好了好了，那不明白没关系啊，给你解释清楚就好了。好了，这个二太多了啊，都都都都2好了。😊，喂。😊，嗯，对不起啊，刚才有口误的地方，大家不要介意啊。好了，我举一个例子，你就明白了。好了，现在。😊。

现在我们做一个业务，这个业务上呢，张三给李四转账转100块钱，明白了吧？张三给李四转转100。ok。待阶段怎么做？出外阶段啊。踹阶段。张三的余额钱包表里有这么两个字段，一个叫余额字段，一个叫冻结字段。

踹阶段就是张三的余额表里减100。冻结字段加100能理解是啥意思不？来这块刚才敲二的同学能理解的话，你现在敲个一。😡，是吧超了相对先理解这一点啊。小强懂了是吧？我知道小强乔二了啊。😊，嗯，好了。

明天更好，我知道你也敲二了啊。好了，喵，你刚才敲的是问号。😊，是吧这是你刚才抄的，你也抄到了，好了好了。😊，这话能懂是吧？比较快要试一下。然后李四呢冻结字段加100，你可以看到整个系统中全在尝试。

并没有说李四的余额加了100，只是余李四的冻结字段你先加了100是吧？先做一个缓冲，先大家先试一下嘛，能不能成。是吧就像你跟你你偷你女朋友钱出来花一样。你们俩抽屉里。一共有1000块钱。举个例子啊。

你要偷100块钱出来花，你胆子够我大吗？😡，是吧如果胆子不够大，先拿出100是吧？先到抽屉里是吧？放冰箱里。是吧先放冰箱里先不花，万一女朋友发现了，说哎，怎么放冰箱里了是吧，再把这钱还回去。

万一女朋友过了半年了也没发现。然后你从冰箱里把这100块钱拿着出去花了。😊，是吧这不就神不知鬼不觉吗？所以这个道理一样，先把这个钱拿出来，放冻结字段里先待一会儿。😡，如果说整个系统都没有发现。

都没有出错的话，那再把它花了，这只要踹，先去踹一下。好了，这个应该好理解了啊。好了，如果说前面没有任何问题，那么执行的是。conform。是吧就是什么张三从冰箱里把钱拿走，花掉。是吧这次彻底花了。

钱没了，女朋友有没有发现？😡，是吧然后李四呢是吧，也也大大方方的接受了。😊，是吧张三媳妇没有发现，然后李四是吧，冻结这段把刚才那100减掉，余额加了皆大欢喜。明白了吧？这叫conform确认是吧？

如果在踹阶段被媳妇发现了呢？很简单吗？还回去吗？是吧从哪少的放哪去，从抽屉里捡了100，给他加回去，冰箱里多了100给他减回去。你是呢冰箱里原来多了100，也给他还回去是吧？世界恢复平静，白干一场。

明显了吗？那里是的余额加100的时候，系统出错了，咋办？哎，一问如果李四的余额加100系统出错，那就把你媳妇抬出来，让你媳妇来解决是吧？也就叫人工补偿，大不了你挨一顿是吧？要么潜滚，要么李四就加100。

张三打一顿是吧？要么李四少100给张三退回去，要么这就叫系统里叫要么叫潜滚，要么叫回滚，反正就就就这这么这么个意思。李四为什么要冻结？😡，好吧，那我我这么给你解释啊，这个灶看来你没投过钱，我跟你说。

来往回走。😊，往往往回走啊。如果李四不冻结，你现想会遇到一个什么情况？举个例子，张三余额减100，李四不冻结，李四的余额直接加100。是吧这是李四余额里加100。OK然后还在踹阶段。

然后张三被媳妇发现了，偷钱了。然后李四一看他的余额，我去，我的余额怎么加100，李四把他的媳妇叫过来了，说媳妇，你看我多了100块钱。😊，结果张三被媳妇张三事发，然后媳妇说你把钱给我要回来。

结果张三把钱恢复了。那么李四加了这100是不是也得减回去？😊，然后李四的10元减回去了，然后张三莫名其妙媳妇说你骗我。你玩我。是吧然后炒一下再打一顿，李斯是不是白白的瘦了？受这么个罪。

是吧所以冻结一下嘛，缓冲一下嘛，不就完了。明白吧？从用户体验上来说。😡，你不要让你的用户有这种大喜大悲的情绪。怎么我卡里多了这么多钱呢，忽然间花一下又没了。😡，是吧多尴尬，所以缓冲一下嘛。

从用户体验的角度来说这个事啊。好了，现在理解了吧，给你解释清楚了吧？你是不动也不加呢，那你这个业务干啥呢？😡，两个人两个人通过心灵感应就做了数据传输。是吧没必要嘛。是吧好了，这个过了啊。😊，好了。

这个可以过了吗？能不能过了，快点，能过敲一，刚才超二的那那那帮人。难过了吗？哦，这就对了嘛，是吧？节奏得得带好，是不是？好了，往下走啊。然后下一步。下一个方案。消息队列加本地事件表加定时任务。

OK从这个从我PPT上列的这这一行字里，大家应该明白。我所用的技术就是这些技术，没别的了是吧，也不用中间键，也不用第三方就这么搞。然后再来看这张图。

我把大家都挪走了啊，先挪走看这张图能看明白吗？😊，能不能看明白？把它挪到这儿吧。能不能看明白？是吧刚才我说了不能看明白。鬼谷子也不懂啊，鬼谷子，你不是智慧的化身吗？你也不懂。😡，刘能也不懂。

不懂啊，不懂，那再看一张图。

好了，我这张图懂了吗？刚才刘南跟鬼谷子，你俩应该是西安区啊，你俩应该懂啊。啊，东北F4。啊，鬼谷子懂了嗯，鬼谷子懂了，果然是鬼谷子。辽达吗？我能哥呢？赵本章不让你拍戏之后，你你你也不懂了，是吗？

这个刘能还换了个外国名字，赵四有个外国名字叫。尼古拉要亚洲武王尼古拉斯赵四啊，现在懂了吗？啊？其他人懂了吗？能懂的给老师敲个一。通过流程明白了是吧，刚才又也是流程啊，刚才也是流程懂了是吧？

我工作就是用的这个是吧，你敲代码敲的挺好的。懂了吗？啊，还用还用还用说吗？只为爱活着。也懂了是吧？你看前面好好听课的都懂了。唉C一个懂，哎呦，我去都懂了。好了，懂了，那就过了，不讲了啊，可以过吗？😊。

不可以，我操。讲一下小强讲一下啊，小强还小是吧？照顾一下，你看这个猫，我跟你说，这个猫每次都打问号，别过。😊，哎，不要是吧，不要过好了好了，来说一下啊，画几个圈。😊，先看大圈。这两个这是什么什么颜色的？

咖啡色吧，这两个咖啡色的圈。来看这两个咖啡色的圈。是两个服务。这是俩服务O。机长，这是两个服务。好了，我删掉。这个用户的请求进来，这是用户发起请求进来。第一步执行业务逻辑。第二步，插入事件表。

第三步给用户一个响应，OK用户干的事就这么多。嚟。从这个流程里大家看到执行业务的circle和插入事件表的circle。是一个事物吗？是是吧，这是一个单机的事误是吧？所以能保证是吧？

加个at second注解OK没问题。好了，这步过了啊，第二步读取事件表里未处理的未发送的事件，然后把它发送到消息队列，然后回来发送成功更新状态以后就不读它了。OK这也在一个事物里。能不能。

理解还在一个事物里。是吧可以吧？okK好，一敲起来了啊。好了，再往再往下走。3。😊，这边有一个服务去监听这个队列。监听完之后，监听到一个消息，把消息插入到这个表里。插入成功。

然后给消息队列一个响应ACK1个响应。OK点完协议之后，以后就再也收不到这个消息了。也说这个消息我平安的把它从这放到了这，我以后就不管了。可这块可以理解吧？能不能理解能理解是吧？OK好了。😊。

那个事件到这之后，那么就执行他的业务呗，把事件取出来，该执行你的circle，该操作的操作，该更新更新，这又在一个事务里。老师ACK如何执行呢？这是MQ自带的。MQ自带的是吧，rocket MQ呃。

rocket MQ有activeMQ也有这后队队都有都有SCK都有SK。你可以你要用过的话，你可以知道。😊，OK好了，一般的发送失败尝试，比如说roingMQ16次。如果没有记错的话。

就是这个消息发16次。如果16次都接受失败的话，进入死信队列就呆的量。那个死性对列死性对列它也是一个对列，你还可以去监听，监听到死性对列之后人工处理。就OK了吗。理解了吧？其实他的整体思想就是把一个。

大的跨服务的事物把它拆掉，拆成小的每个服务的事物。现在理解了吧。是吧积少成多。今夜陈裘。什么，还有什么，反正就这个意思。😡，能能来这块能懂的给老师敲个一。手机砸脸了，那啥呀？这个会有时效性问题吗？会的。

会有时效性问题的。是吧这叫b斯理论。保证了最终一致性，但是牺牲了时效性。好了，那么它新生的时效性，它有什么优点呢？它的优点是。性能提升了，仔细仔细琢磨一下这句话。性能提升了。

考虑一下为什么性能提升了。

系列 6：P114：消息队列+本地事件表+定时任务方案 - 马士兵学堂 - BV1RY4y1Q7DL

这个服务比如说要花10秒钟处理时间，这个服务也要花10秒钟处理时间。我这个用户调用完这个服务，再调用完这个服务，一共需要20秒。但是我用这个方案。我10秒就能返回，我只需要10秒。

是不是用户的平均响应时间降低了？是不是平均显示时间降低，那就是我能接受的用户的请求就更多了。你又嘛。能不能理解有好处也有坏处吗？是不是一个是在同一个服务吗？是啊，是在同一个服务。第二个服务失败了。

第一个服务怎么回滚，不回滚。记住我说的话，这个时候就不回滚，怎么回滚呀啊，为什么我都给你解偶了，你还要我好不容易把这俩这俩在一块打架，我把他俩拆开了，你还让他俩再打回去。😡，这个时候不回滚。不回滚。

你错了，就一直消费一直消费一直消费消费到此。😡，他进入死金对量人工补偿。那你入啊。这个就是只能前进，不能后退。你有啊。嗯。😊，这个处理方案叫啥呀？这个处理方案叫且听分盈，分布式事物解决方案。好了。

如果没有名字，拿你命名。且听叫QT风win银上。是吧QTWS级的方案好了，不用纠结名字。好啦。明嘢了吗。

这个方案的名字呢叫这个。消息对待加本地时件表加定时任务解决方案，是吧？名字太长。那第二个一直不成功不就不一致了吗？第二个一直不成功，叫bug。能理解吗？叫bug大写的BU goBUG bugg。

自己去改代码去。你又话。刚才的新宇呢，新宇还在吗？好吧，这么不情愿的应个好吧，就是bug自己改去。好啦。好吧，这这是这种解决方案啊。😊，好了，我们再往后走，再讲一个解决方案。

rocket MQ事物消息解决方案，直接看图。

看这个图的话。来能不能看得懂？看看代码吧，这个那个还需要看代码吗？就是本地数据库加I。来这个图仔细看1到81到8，从顺序开始往后看，1到8。先自己先看一眼啊，我就不念了。看完之后，难懂的敲一。Yeah。

为爱活着，你懂了？我的天。啊，团团也懂了。没事，不懂的把疑问打出来。😡，不懂得把疑问打出来，因为项目用的就是这个哦。好了，那那那那正好讲对了，但是我不知道ACKACK的话小毁对列。😊，呃，你哎消息队列。

那你看消息看我们消息队列的课吧，这些消息队列的基本操作呀。😊，消息框盖住了，没关系，我挪一挪。我挪一挪好吧。攞一攞可啦吗。先看着嘛，几秒钟啊，让我喝口水。啊，嗯。

本地上是不知道不知道我如何执行ACK插入成功之后，不知道如何ACK。这样吧，你加我们的右下角的二维码，加完之后。我给你找找啊，我原来写过这些代码，我给你找找我们VIP里都有都有这些代码。啊，好了。

这个这个这个东西我简单过一遍啊。第一步发送一个half message。这个half message其实这个方案里面最关键的就是half message。发完hal message之后。

后面的食物是后面的服务是无法消费。h message，就是它是一条消息发到消费堆里，消费对的消息消费不了他，等他把他的事务执行完，然后再给他发一个提交h message，他才能消费。这样这样理解了吧。

这样的话就把消息和这边对数据库的操作绑定在了一起。也就是执行业务和发送消息是一个原子的操作。知道这个方案里面的目的是啥了吗？有消息队列的基础吗？这个需要有消息队列的基础。如果没有这个基础的话。

这个课这个我这么说，估计你也不好懂。来，能理解我说的这个关键点在哪了吗？能理解是吧？okK好了，为了保证它的原子性，还给它有。兜底的方案也有兜底的方案。兜底方案是啥呢？是这个你看啊一条消息。

我发送给消息队列了，就是have message到了。但是呢第四在路上丢了。也就是说这个消息存在于消息队容，迟迟的我不知道他该怎么办，我怎么给它兜底，兜底就是第五步，未收到四步骤的命令，我去回查查一下。

检查一下本地数据库的执行状态。如果。数据库执行的没有问题，那么我就提交。如果数据库执行的有问题，那我就回滚，把have message直接干掉。ok。理白了吧？这是第一步保证它的原子性。

如果说第其实原子性就出问题，出在第四步上。如果第四步出问题，我再兜个底。是吧planlan B。OK现在清楚了吧，您说。😊，Ccle业务的执行。和消息的发送是原子的操作。rapitM好友没。

现在只有rocketMQ有啊，我了解的只有rocketMQ有是我消息。嗯。明有吧？对，第七步很关键，听鬼谷子的鬼谷子说什么关键，什么就关键。啊。可以理解了吧，电话。🤧嗯。能不能理解这块？怎么没人了？

你要不理解的话，你把问题打上来，我给你解答O。😊，这个有意思，把消息和数据绑一起。对的，卡不卡能动吗？卡不卡不能做。half message讲讲half message记住就好了。

half message不能收费。b message其实就是一个一个消息进入到你看啊，就是它里面比如说用它里面有一个队列，队列存储了一个消息，这一行消息，消息里面一个标记，有一个flag。

如果flag是一，能让它消费。如果flag是零，它就叫半消息，这不就这不就得了。是吧就是消息在MQ里的一个标记，我标记你能消费，你就能消费。我标记你不能消费，你就是个慢消息。仅此而已。好吧，是现在选率。

然后消息队列的这些东西呢，你可以扫描这个二维码，找我们的咨询老师给你要一些我们消息队列的公开课都可以的啊。😊，消息没有提交，只是存在MQ里面啥意思？不不不不这是这个意思啊，就是说消息呢都是都是一堆消息。

不过是消息里面有一些状态是不一样的，是一，我就能让消费者消费，是零，我就不让他消费。我提交就是把一把零变成一，我回滚就是把它干掉。就这么简单。第五步怎么做的？第五步怎么做的话，如果你用呃用roMQ的话。

它有。它有一个loc localal transaction，有一个方法就是你实现它的一个接口，那个接口自动会让你实现这个方法。这个方法呢就是做回查用的。这个这个很简单，你要你要用它的售物消息。

它就它就会有这个好了，这里面其实有一个关键点啊，这里面有一个小技巧，就是这个你们一直纠纠结在第五步啊，第五步里面有一个小技巧，我估计你问的也是这个啊包子。😊，好了，就是你看啊。

我执行我的业务的circle是吧？业务的circle我该干嘛干嘛。这这是业务的 circle口。同时。我插入一个事件表，就是一个事件的表。然后这俩C口呢在一个库里。就是在一个库里。OK这是不是一个事物？

先理解一下这个这是不是一个事物。包着。还在吗？嗯。啥情况？负JC了，是是就禁止了。不理解这个是不是一个失误。我跟你说，你们要不不回答，我不讲了。😡，是是吧，那你回查的时候。😡，回一查第五步的时候。

查这个事务表不就OK了。是吧不用，虽然你的业务可能操作了10张表，我没必要把时间表查一遍嘛，我只查这张表里的一行记录就OK了。理解了吧，所以回查也很简单。最怕空气突然安静，真是的，这个安静。理解了是吧？

OK好了，这就是里面的一个小技巧啊，也就可以了嘛。😊，是不是？Yeah。好了，可以过了吗？这个。😡，嗯。如果执行到第四步，程序挂掉了，还能回查吗？当然可以了，回查可以重试，就是回查这块可以重试的啊。

可以重试，就第一次没查出结果，过一段时间再重试。ok嘅。过是吧。好吧，过往下了啊。

好了，我们还差最后一种方案叫最大努力通知方案。好了，那现在为止已经讲了整整两个小时了。😊，然后呢。今天是我们那个呃昨天活动的一次返场，然后我想把今天的就是打个广告晃换脑子，然后过20分钟。

我们再开始讲我们最大努力通知方案，可以吧？先歇一歇啊，我讲的口干舌燥。可有吧。

可以是吧？是吧？谢谢大家理解啊，好了。😊，嗯，给大家看一下PPT。然后。

说一下我们的服务。这边就是我们你就是买我们的课程呢，可以享受到我们我屏幕上的这么多服务。第一是我们的课程内容对标互联网公司的技术站，就是跟呃现在主流的大厂原来的技术是对应的。

甚至比一些呃大厂还要更超前一些。啊，就是就是说大厂计划在用还没用的技术，我们的课程里也有了。OK好了，我讲一下啊，就第一部分我们的课程内容，课程内容有哪些？我们一这8个东西我们一个月来讲。

预计20分钟就讲完了。课程内容我们有哪些。大家可以看一下我们的课程大纲，就刚才在找那个。😊。

呃，找那个分布式事物的时候，我给大家已经看过一眼了。大家可以看一下，我把这个课程大纲收起来。然后你可以把我们的课程档纲缩缩小。看一下我们科程大杆的整体。看一下这是什么东西。

这是我们MCjava后端架构师最新版的一个课程大纲。然后这个课程大纲按什么来组织的呢？按技术项目面试，还有一些不定期新增的内容。OK就是我们我们学课程主要学技术嘛，但是学完技术呢，我们得得有实践是吧？

技术是为业务服务的，得有通过业务去把技术实践一遍。然后这是项目然后学完技术和项目呢，大家都是为了跳槽或者涨薪嘛，是吧？如果说在企业内部涨薪的话，你需要晋升是吧？需要答辩这也相当于一次面试，是不是？

然后如果说你要跳槽的话，这更相当于一次面试了，我们会有。针对短期的跳槽，还有长期的提升，我们都有相应的课程给大家进行辅导，包括简历辅导、职业规划，还有面试突击班。ok这是面试的东西。新增的东西呢。

这包括我们的一些呃比如说新技术，我们会我们会在这里面新增。当然这个内容是不定期新增的。比如说最近的云原生，还有呃大厂bug的处理专题，就是说在大厂里面遇到什遇到什么样的线上的事故。然后怎么对它进行定位。

怎么对它进行解决，这个在我们的课程里都有。还有就是京东618阿里双十一大规模的促销系统，呃，怎么设计的。然后我们也有，还有就是。团队团队的管理课就是技术管理课，团队怎么管理DDD怎么用是吧？

AI然后产品课就是做一个技术人员呢，你也需要懂一些产品的知识，尤其是你以后如果说你的这辈子的目标是当一个高级开发工程师，到此为止，那就啥也不说了。你只会前面的技术就OK了。但是如果说你有更高的追求。

想当一个呃架构师或者说一个技术经理这种岗位的话，或者说更高技术总监技术副总裁你想当这些的话是吧？如果说再远大一些当个CEO是吧？产品的知识，你必须得会是吧？还有原来有句话嘛，产品经理是CEO的摇篮是吧？

就是说你想呃在技术上有一个高维度的突破，产品的知识，你是必须得掌握了。OK这就是我们大的内容。好了，我们来看一下小的内容。技术里面我们有哪些技术呢我们分2块，一块是P6，一块是P7。😊。

我们为什么这里面没有说P8呢？大家知道我们原来有课程的有P8，但是我们我们其实P8和P7，大家知道他们技术上的差别在哪里。大家知道P8和P10基本上的差别在哪里吗？有没有人知道？管理吧。对，就是这个。

其实他们的技术几乎没有什么没有什么质的差别，技术就那么多是吧？差不多就是他能不能带着团队能不能开拓新的业务，能不能调配资源，主要主要就这些了。😡，OK好了，我们那我们来看一下P6和P7需要掌握哪些知识。

P6打开从前往后前置知识。大家可以看一下P6的前置知识其实就相当于一个P5的要求是吧？你需要掌握一些基本的开发工具，将SE你得会然后SSM框架，你得会spring boot，你得会，然后再做一个小项目。

这就是一个P5的水平，前置知识就这么点是吧？P5的水平是一个什么样的水平呢？就是大学刚毕业，不管你是本科生还是研究生，刚毕业，如果你要去大厂，那就是P5是吧？阿里是P5其他的公司呢可能是T是吧？

这个就不说了。我们以阿里为例来说好，这是需要掌握的前置知识，然后。讲问完之后，这个应学院要求新增的这些课呢，这个是我们就是我们学生要求我们实时更新的这些课是吧？

快速上手二手项目怎么重构公司的项目等等等等。这节课是我们临时新加的，就是我们学生，比如说迫切需要什么课，我们也会加到我们这个里面。还有往下走第一个底层知识。大家可以看一下操作系统网络IO呃。

网络min的运维算法是吧？这个是底层需要掌握的知识。第二个并发编程并发编程是吧，需要了解操作系统对并发的知识阻塞队列GUCGMH等等等等这些东西，现征池这些东西你得了解，然后把它说起来。

然后第三RPC通信框架是吧？如那会遇到一些呃第三方协调者是吧？用keeper呀，是d doubleou呀，它也是用的W系统RPC调源方式嘛是吧？resres。规范是吧，ntynty长件也是IPC用是吧？

IRPCremoteproc call是吧？反正是你要调用别的系统，就叫IPC。😊，好了，往下呢前置知识也会讲吗？都会讲的，放心，这里面列的我们都会讲，只要是我们这个大纲里列的，都会讲到。😊，好了。

前置知识不是说你需要你需要先具备这个再学，再来学我们的课，不是这样的，就是你啥也不会，你先学先学前置知识，我们都有对应的课程，就是我们java追学班的课程都有okK好了，然后消遇中间键。

比如说actMQraitMQ卡普卡和rockyMQ这四个消语队列。😊，这四个消息中间键是吧？HDMQ太老了，这是我小时候用的不用了是吧？raidMQ用的少不用了是吧？所以只剩下卡夫卡和rocketMQ。

而我们今天所说的事物消费呢，只有rocketMQ有是吧？所以你知道你该选哪个了吗？这个这个。😊，ok。还有最新出的这个。这个都可以都可以学一学。好了，这是消息中间消息中间键，然后收起来。第五。

缓存中间键reis my catch。等等，就是一用到一些缓存。好了，往下走。然后软件软件设计的基础是吧？UML设计模式、敏捷开发等等等等这些东西。第七，分布式架构的实践。

这个里面啪一堆全是分布式的一些解决方案。是吧分布式锁分布数缓存存储分布式ID分布任命的分布式任务分布式绘画等等。这是第七。第八，微服务架构实践。

这里面有配置中心、注册中心、网络路由服务调用、负载均衡熔断间极限流隔离。奈菲阿里巴巴这两套我们都讲好了。第九系统的性能优化GOM优化，mysl优化tome head n等等一堆优化。第十。

海量数据的存储。是吧ES click个 housemy circle，no circle，这里面都有。然后数据的搜索。Loss了ESEOK。排量数据的处理。ha do map reduce。

然后flink等等等等。have这里面都有好了，再往下走。网络运维的基础是吧？多机房的问题，伊利多活的问题，联地三中心的问题。怎么怎么解决，这里面都有dalops的东西，开发运维一体化。

开发运维不分家是吧？这都需要会。然后测试的东西。OK就是写完代码，你怎么去测试是吧？这个我里面我们都有。然后不过网格的东西，这里面我们也有。

我们用int still去做去做的古网格int still也是古网格呃，现在落地比较广的以比较成熟的一个方案啊，这是P6。OK好了，P6说完，然后P7。😊，P7的东西呢是在掌握P6的基础之上。

需要再掌握这么多基础，分布式理论基础篇是吧？CAP拍个sraftgo这些都有分布式算法，杀丁算法，拍个损做法ZI。漏桶令牌桶这些都有，这些算法都得会，就是分布式解决方案中的一些算法。好了，这是第第二个。

第三。框架原理源码剖析，几乎所有框中间件和框架的源源码，我们的课程里都有讲到。一堆spring的n的MQ的或者sportELK的这里面都有有。好了，第四，分布式架构设计核心技核心高性能架构设计篇。

这个也是我讲的，这是我们的三高项目，软件质量的标准。是吧怎么做DNSCDN多地制质量正反向代理分流。然后服务的并并行并发，整体服务服务内部并行、服务集群。然后再往下走。缓存的设计，缓存的收益。

缓存的分享点，缓存更新清理地址等等等等。然后存储的设计关系、关系数据库、索引、海量数据的优化等等可靠性设计。是吧串联并梁冗余，连内三中心一地多活。然后应用保护类的设计。隔离限流、间极熔断、恢复都有。

好了，这个是我们这个是我们的高性能架构设计片，分布式架构设计片案例驱动。然后这里面就有很多是吧？数十万超高并发的设计N科9是吧，99。999%。😊，那个通用的设计。

还有就是呃基于云的云计算的一些架构的东西，还有就是一级流量多级缓存的专题，这里面都有好了，P7的技术我给大家说完了。ok k。好了，这是上面这是上面的技术点。学完技术点之后呢，我们还有项目。

比如说我们有一个东宝商城，然后这个商城的项目呢里面有前端的架构点开。就是作为一个后端，你也懂一些前后端是如何交互的。如果你懂前端之后，你在工作中会更加顺利一些。就是你知道跟前端该怎么交流。

别前端说我要这么调，你说不行，然后你又说不出理由，这就尴尬了，是不是？然后还有就是后端的架构，这个你当然得懂啊，然后后端架构需要用到这么多东西是吧？包括配置中心注册中心网关路由限流认证。

链路追踪数据同步数据检索缓存。分布式解决方案等等，这里面都会有。好了，大数据。link离线数仓实时数藏数据弧。在这个项目里都会讲到，还有AI数据分析。

用户画像、用户画像、购买预测、购物车分析推荐系统用户行为分析是吧？包括库存的预测，这里面都会有。还有就是云原生架构以后怎么把它放到云源身上。

docker kubernets、国斯fi、普罗米修斯这些都会有ok所以说我们以这个项目为。为驱动把前端后端大数据AI云原生全部在这个项目里给大家实现。好了，还有就是呃其他的一些项目。

比如说游戏服务游戏服务器，然后东宝，这是单体版的东保，这是给没有做过项目同学做做技术储备的一个前置的一个项目，还有网约车，这是我讲的，然后今天所讲的那些内容呢，就是网约车里，我原来在课上讲的一些内容。

比如说今天讲的分布式事务，我在网页这课里讲了。好久是吧，分门书我就讲了后面的十节课。你也课两个小时，还有前面的就是在生产，在工作中项目怎么做的，这里面都有。好了，这是我们的呃课程。这是我们的项目。

还有就是大规模电商个性化追加系统，这个就呃放到了AI数据分析里，放到了东宝商城里面。还有就是流市流市处理平台，这个放到了大数据里面。是吧就是把它都融合在我们的电商项目里了。OK好了，这个收起来了啊。😊。

同们，这些都是自己在线看视频学习吗？这么这么多需要学多久啊？一时苦笑是吧？你也不用苦笑，在我们这里呢，我们会给你根据你的情况给你制定你的专属的学习路线。你也不用说担心东西太多，需要学太久。

其实不用根据我们以往的经验，大部分人学3到6个月就能达到，就看你什么什么诉求吧。你要说明年金三一次涨薪，那你就学3个月了是吧？只有3个月时间，那你就学3个月，我们有面试突击班让你学习。

如果说我要做一个两年的规划是吧？那我们可以从技术的深度技术的广度，从架构从大数据给你做规划，这些都是可以的。对，就是这个冰冰说的学多久，看你的需求，是看你的诉求是吧？你要想一个月是吧。

一周两周、一个月、三个月、半年，一年两年是吧，看你看你自己对自己的规划是多久，我们都有对应的学习路线给到你。OK这个就是我们呃我们课程。哎呀去这个就是我们课程的一个。呃，课程大纲的一个介绍。

如果想要这份大纲的同学呢，扫描屏幕右下方的二维码，找我们的咨询老师去要这份大纲。好了，这是我们的课程内容。第一部分。

还有第二个。学习规划刚才我也说了，就是报名之后，我们有一对一的学习规划，可以给你制定学习路线。OK就是你跟着随习路线走就行了。然后我们的教学方式呢是直播和录播。就比如说我们每天晚上我们有直播。

大家可以看一下我们的课程表，稍等一下啊。

这是我们的一个课程表，大家可以看一下。

系列 6：P115：Seata源码学习引入 - 马士兵学堂 - BV1RY4y1Q7DL

啊，各位同学们大家好啊，那么从这节课开始，我们要开始讲解西塔的源码部分。我们在之前啊学习了cita的应用，包括它的一些呃事物模式啊，包括一些它的一些高高可用的部署，对吧？

包括通过nas作为注册中心配置中心啊，包括使用DB模式等等这些吧。啊，什么sta的各种事物模式，什么AT啊TCC啊这些模式。那么在学完了这些以后啊，大家一定会产生疑问。

就是说这个西塔的源码它是怎么去实现啊这些功能的？那么我们还是要去强调一句话，就是se塔它本身啊80%以上的分布式事务问题。通过西塔的AT模式都可以去进行解决。

而且AT模式也是sta主推的啊这么一个分布式事务解决方案。我们可以从哪儿可以看到啊，从它的官方官方网站中就可以看到。

映入眼帘的直接就告诉你有这么几个模式，然后上来就是AT模式，对吧？它主要是针对AT模式做了一些讲解啊，那么是这样的，各位啊，呃，我们原码部分实际上也是主要是针对AT模式进行展开啊。

这样的话把这会给大家分析清楚了。其实在你的面试中啊，包括在你后续的一些工作中啊，就足够使用了。好吧，各位OK啊。那么这节课是一个sta的源码的学习引入。

那么说白了就是我们需要去啊对源码学习前做一些准备啊。呃呃首先啊第一件事情嘛，我们先说一下，啊就是说源码的下载。那么s塔的源码下载的话，地址在这儿啊，给大家提供好了，我们可以打开一眼来。

其实在哪就可以看到啊，在这儿有个下载啊，在s塔的官网中下载点这。啊，然后在这就是对应的下载中心啊，这就是我笔记里给大家截图的位置。当前我们使用的版本是这个1。4。2，就这个版本。

所以你跟这儿就可以进行下载，好吧啊，O这就不多说了，这个对于你们来说比较简单了啊OK。然后再接着说一下啊，那么再去正式讲之前啊，我先多说几嘴。呃，因为我们都知道。

包括我们学习nauckscentino啊等等这些吧。在学习源码的时候，我们都跟我跟大家说过一个概念，就是尽量我们去啊静态，学会静态的去阅读源码。因为你必须要去掌握这种能够去静态阅读源码的能力啊。

这样的话，你再碰到一些框架的源码，包括你在工作中想去阅读源码的时候会很方便。好吧，各位啊，而且我再说一下，再强调一下，学习源码不要去纠结于细节啊，这个在我在讲ncos源码的时候，就跟大家讲过啊。

源码课程不要去纠结细节啊，比如说某些细小的逻辑啊，某些细小的一种特别特别小的小逻辑，不要去陷入其中。这样的话，你的学习会很慢，而且效率很差。我说白了你真那么学就学不下去了。好吧啊，所以我们要关注源码的。

不是说这源码到底是每个细节怎么写的，而是它整体的思路是什么样。核心点在哪？对吧？啊，所以我们去学习源码，包括老师去讲，也是从大面去给大家去讲啊，从整体的这个呃设计角度去给大家讲，好吧，OK啊。

那么我们去下载好了这个sta以后啊，回到正题，下载好了se塔源码以后啊，我们只需要去通过idea啊，进行打开就可以了。我们可以给大家看一下啊，我现在这个位置已经下好了，我这是这个ok啊，西塔的源码啊。

在这里啊，包括塔的所有的相关的这个项目都有啊，那么可以很明显的发现s塔其实它也是一个类似于nacos的这种sring boot的项目，对吧？那既然是spriring boot的项目，那就好办了，对吧？

这个我们熟啊。

OK好，那接着说。

我们在去正式去讲这个s塔源码之前啊，我想带大家去回顾一下AT模式。当然不光是回顾AT模式。呃，在这其中啊啊我们还要去把AT模式。我们之前没有给大家讲到的像写隔离读隔离啊，这个分布式锁啊，不是分布式锁啊。

就是全局锁的这些概念去给大家去啊讲清楚。因为这个是官网提供的。这个我们当时在应用的时候，只是为了让大家让大家快速上手，所以我没有去详细的去讲，包括这个写隔离啊，包括这个读隔离以及这个什么读疑啊。

这个应该知道啊，包括这个位置有一个叫做。拳局所的概念。这个我没有跟大家说说去细说啊，只是简单提一例嘴。那这节课的话简单去把这回顾，然后呢，我们还要把这去详细分析一下，好吧，OK啊。那么咱们就开始啊。

先说一下啊。我们在之前讲AT模式应用的时候啊，其实我们已经通过一个特别小的案例来啊尝试去完成这种分布式事物的一个应用啊，尤其是AT模式。那么这个我们当时讲这个demo也比较简单啊，我给大家找找那张图啊。

呃，这是咱们后续要看这张图啊，那个图在哪儿？AT模式在这儿OK啊。这是我们当时去讲的个AT模式。呃，当然实际上我们还通过一个案例去给大家去分析了一下，我看那个案例还在不在啊。好像。呃，执行模型。

撒嘎的这你应该就是这个啊，那就是这个。啊，这而且有提交。啊，这个不是，只是讲原理，那就是他啊那就是他OK。这张图啊我们可以再看一眼，再回顾一下啊，我们当时讲的个案例是一个订单啊，一个库存啊。

那么去订单发起的这种全局事务啊，或者叫做分布式事务啊，全局事务。那么实际上就是它有几个角色，我们一定要清楚啊，在这其中，一个是TC啊，一个是TM一个是RM啊。

RM相当于事物的参与者TM是那个啊这个这个这个可以是一个项目啊，它也可以是一个这个。呃，RM啊，它既可以是TTM啊，也可以是RM啊，那么TM相当于这个事物的发起者。

说白了就是啊那么TC就是那个sock server啊，不 server了那个塔 server啊，说错了，口误啊塔 server那这个概念的话，如果各位还不是很清楚的话，一定要把它去分清楚啊。

在塔的官网的术语这个位置啊，TC是什么啊，事务协调者对吧？TM是什么事务管理器它分负责是开启全局事务啊，提交或者回滚全局事务啊，那么RM的话就是资源管理器。那么说白了就是事物的参与者O好了。

最后说一遍不再说了啊。那么我们之前那个案例就是说白了通过订单啊，这个位置去首先啊开启选居事务，对吧？然后呢，它这个位置会注册相关自己的一些啊开启选居事务以后，那么它会去调用我的啊库存去减库存。

订单这个位置生成订单，库存这个位置去减库存，这其中会必然产生分布式事物问题。那么我们的解决方案是通过AT模式啊，在呃订单调取这个库存的时候。开启全局事务啊，然后呢呃首先全局事务中的这种什么。

事物参与者去进行单独执行本地事务或者叫分支事务。同时要记录andlog和redolog，也就是执行前的数据和执行后的数据记录在这个andlog这个表中啊，这是一个呃快照可以理解为啊。

那么记录它的一个前镜像和后镜像，这个前镜像就是之前的数据和更改之后的数据啊，叫后镜像OK把这个数据记录完以后，那么如果当前都没有问题啊。比如说订单也。增加了库存也减少了。okK没有产生分布式数问题。

那好，全局提交okK。这是之前正常思路。但如果一旦出现问题，那么就会进行回滚啊。回滚的话可能就是具体的某一个分支事物进行回滚。比如说库存减一的时候没有减成功，那好。

他就通过之前所记录的安log来进行一个回滚啊，一个补偿型的回滚啊，这是补偿型事务，对吧？OK这是我们之前讲的概念。那么呃这个都比较简单啊，我也不用多说，简单说两句，你们就能懂了。那么在这其中啊。

涉及到点东西，什么东西AT模式我们都知道是一个基于2PC就是二阶段提交这么演变过来的这么一个协议，对吧？那么在这其中，其实还涉及到一些问题，就是写隔离和读隔离的问题啊，看官网上，包括我笔记中有啊。

笔记中有在这儿啊。写个离和读个离，我们先看官网，好吧啊。在官网这个位置啊。他告诉大家说这个整体阶段一阶段二阶段不多说了啊ok那么写隔离是什么？读隔离又是什么？这两点我跟大家说清楚。首先写个例。

我们看概念说，一阶段本地事务提交前需要先确保拿到全局所，拿不到全局所不能提交本地事务。那么拿全局所的啊拿全局所的尝试被限制在一定范围内，超出范围则放弃，并回滚本地事务释放本地所。什么意思呢？

这个东西我们可以通过一个案例来给大家去说清楚啊。但然官方这个位置也提供了案例。啊，这个案例的话呃，我觉得稍微晦涩一些，所以呢我就通过了我自己的方式啊去给大家去呃画两张图，让大家能够好理解一些啊。

咱们先说这个血隔离，其实这个所谓的血隔离，它其实就是去避免这种脏血的问题发生啊，脏血是什么？大家应该都知道。举个例子来说，当前假如说这个位置我有一条默认数据啊，IDV一值是A值为20啊，这是个默认数据。

那么当前是呃两个两个全局事务啊，TS1TS2OK。TSE在开启全局事务的时候，首先第一件事情它需要去啊也就是在一阶段的时候啊，他需要去拿到什么这个啊稍微放大一点。global look啥玩意儿？

全局所它需要去拿到全局所，拿到全局所之后，然后呢再进行具体的commit和ro back啊。那么在这个commit和ro back之前，这个全局所是一直被TXE去掌握的。啊，这是事务一去掌握的。

那么只有整个这个全局事务一在执行之后才会释放本地所啊，不是释放全局所说错了啊，释放全局所。懂吗？那么这样的话，TS2能进行执行。什么意思？它为什么能防止脏写呢？其实如果说啊我们没有这个全局锁的概念。

假如说现在当前IDV一的age是30，那么TS1在执行的时候，当前置位30。那么TS2在执行的时候呢，它呢把这个数据加一了，变成31了啊，那么就会出现脏写。假如说TS1在执行以后啊，30好。

它掉服务币了，那这时候值就是30。但是它如果一旦出现这种问题进行回滚的时候，OK那么值会变成20。那这头现在是在你去正常执行TSE事务的时候，它也可以执行去拿到这个H的值啊，去做一些事物的改变。

比如说把值变成31了。那好了，那这个时候这个值就不对了。啊，就直接变成一个脏血的情况了。那么如何去防止这种情况呢？其实很简单，它在TSE这个位置加了一个拳击锁。

加上这个全局锁的目的就是在TS1这个全局事务执行的期间啊，只要他没有执行完，你的TS2就不能拿到这个全局锁，你就不能对这个A值的值进行改变。所以我这写了一下，说在TS1全局事务释放全局锁之前。

无法向下执行，需要等待全局锁。那也就说白了，在这个位置啊，我现在想把这个值改成31啊，但是我没有拿到全局锁，所以这个位置我只能去重试它这个重试的时候有个细节，就是会释放自己的本地事务啊，然后释放之后呢。

再回过来重试啊。如果还有没有还没拿到啊，再回头释放，再重试，再回过头来重试他会一直重试重试重试。在这儿直到你的TS1全局事务结束以后，那么真正的这个位置拿到了全局锁。第二个全局事务。

TS2拿到了全局事务以后啊，全局全局锁以后啊，它才能去正常的去执行它自己对应的这么一个呃事务。这是当前的写隔离，说白了就是去防止这种是吧啊。脏血的情况出现啊，包括我们这述完了可以看一眼它的官网。

这啊他这也说了说他也是举一个事例来说啊，分别有2个TS1TS2。然后对当前的这个IDVM啊IDV1的这个M值1000啊进行一个更改。你看TS1开始先开启本地事务，拿到本地锁。

这是正常的本地锁这个工作数啊，然后更新操作变成900了。那么本地事务在提交前先拿到该记录的什么全局锁。本地提交释放本地锁，那TS2开始后啊，开启本地事务，拿到本地锁更新操作。

由原来的900减100变成800。在本地事务提交前，他需要先拿到全局锁。也就说白了，你不管这边怎么操作。如果说你的TS2拿不到全局锁，那么它就无法执行。所以在TS1全局提交前该记录全局锁被TS1持有啊。

也就是说全局事务TS1它持有全局锁。那么TS2就需要重试等待全局锁。你看他这个图就在这个位置呃获取全局锁O获取不到怎么办就重试重试重试等着什么时候TS1执行完了，它释放了全局锁。

它拿到了才能去执行它TS2的本地事务去把当前的这个呃900再减100等于800啊，这是这么个情况。OK那么如果说TS1的二阶段全局提交看啊TS1二阶段全局提交释放全局锁啊。

TS2拿到全局所提交本级事务啊，这这是刚才我说那块啊，这刚才我说那块儿。这是他正常提交的情况下。那如果说TSE的二阶段是全局回滚，则TS1需要重新获取该数据的本地锁进行反向补偿操作啊，实现分值回滚。

这是我们正常的AT模式啊，它的一个操作流程。但是如果说全局锁情况下啊，就是TS2在TS1在全局回滚以后，TS2去必须等待该数据的全局锁，同时持有本地锁，说白了就是这个意思，咱就不不用看这个了。

就是看着有点懵啊，简单理解吧，不管你TS1是整体提交还是整体的去回滚。只要你的全局锁在没有释放的时候，你的TS2是无法进行操作的，它只能在这个位置获取全局锁获取不到回滚本地事务，然后再来重试。

如果还拿不到回滚啊，再等着什么时候拿到全局锁，什么时候才能做你TS2的一个全局事务的一个后续操作。这就是啊。写隔离。他其实你看这写的说，因为整个过程全居所啊在TS1结束前是一直被TS1持有的。

那么TS2就无法进行擦的操作嘛，所以这样的话就会避免脏血的问题的发生啊，这就是所谓的我们AT模式的。血隔离其实就是去防止这种脏血的问题发生。O啊，这是写隔离，说清楚了。OK那么还有一点就是读隔离。

这个读隔离是什么呢？呃，我们可以看一下啊，它这个有一个概念，就是说在数据库本地事物隔离级别啊读已提交或以上基础C塔的AT模式默认全局的隔离级别是独未提交。呃。

大家可能会对这个读已提交和读未提交这两个情况，这个隔离级别啊，呃可能不太了解，我简单说一下吧，好吧。我们这个也是看图啊，我要把这个图都画好了。有一个读个里OK看这张图啊。

他这个所谓的读隔离是个什么样的意思啊？它这个我这个图跟上一个没什么区别啊，都是一样，我默认数据为20啊。然后呢，你们要注意一句话的是啊，咱们先看这儿啊，他这有一句话你要注意。

就是他这个位置说读隔离是说呃。如果应用在特定场景场景下，必须需要全局独以提交这种隔离级别。那么目前sta的方式是通过这种代理slect for update语句。说白了就是加行速。啊。

OK那么什么叫读已提交？什么叫读未提交呢？我们来看图啊。哪去了啊，这道。这个图中，当前默认数据为20。然后呢，TS一这个位置一样改成30TS2这个事物2啊，全局事物2啊，这个位置不是30，我就变成31。

好吧，这忘改了。OK好啊。😊，他也是这么一个情况。那么他现在什么叫读未提交呢？假如说当前TSE执行事务以后，这个值变成30了。啊，这个值变成30了，但是它现在是一个呃未提交状态啊。

它现在是一个未提交状态，也就是说没有走到这个全局commit。你这个时候。如果是读未提交的隔离级别，当前的TS这当前这个位置它去获取这个get age的时候，它是能够读到这个30的。啊啊，这不是31对。

它是能够读到这个30的这是读未提交。啊，也就说白了，如果是独未提交的话。没开啊。当前我这头。把这个数据更改为30了，但是并没有去执行全局提交的时候，我这头TS2去获取这个A值的值。

它是可以读到这个30的这是读已提交隔离级别啊，什么叫读已提交呢？读已提交就是指当前的TS1啊，把这个值改成30以后必须执行的commit本地事务提交commit真正的把这个值全部提交以后。

我这头才能读到这个30，这叫做读已提交。隔离级别读未提交，就是它没有真正提交，我也能读到。读未提交就是它必须真正提交以后，我才能读到，就这么点区别。好吧。那么这个读位提交和读位提交啊，我在这给大家写了。

对吧在保证在TS2中能够读到TS1的H30读已提交是在TS2中读不到数据等待全局锁。什么意思呢？它这其中就涉及到一个全局锁，这也是我们当前官网中给大家提供的一个概念，就是说。好，在这儿。

这个它代理的slight for update语句会申请全局所。如果全局所被其他事物占有，则释放本地锁回滚啊，并重试。其实跟上面那个是一样的。它这个过程中是被一个block阻塞的。

所以直到全局所拿到即啊读取的相关数据是已提交才返回。这说白就是去呃staAT模式针对的这种说必须做到读已提交模式的这么一个啊做法。回到我们这个案例中说啊，它的意思是指。当前这个位置位置是为30。

如果当前它是读已提交的级别啊，读已提交级别。那么在TS2这个位置，它通过这个语句去读的时候啊，它会申请拿到全居锁。但是我们之前讲过，如果当前你的全局事务一没有完成整体操作的时候。

那么这个全局锁就一直在这儿啊，这个锁就一直在这，那么你的TS2去通过这个语句申请全局所的时候，由TS1持持有的全局锁，它是拿不到的。那怎么办呢？那他就需要在这儿。等回滚本地事务，并且重试。

直到把这个权击锁TSE释放以后，它拿到了，它才能继续向下走。这就说白了啊，这是我们这个se塔的AT模式的读已提交模式啊，读已提交这个级别的隔离是这么做的。但它默认记住啊，它是。都未提交。好吧。

如果你非得做到对已提交，那就得这么做。好吧，各位OK啊，那这是之前没有去给大家去讲的这两个过程。所以这个位置简单去啊不能说简单就详细把这个事儿给大家讲清楚了。

也就是说staAT模式的一个呃写隔离和读隔离啊，说白就是去防止这种脏图脏写啊，脏图脏写，好吧，OK啊。那么其他的话这个位置我就不看图了，不不看官网了，看笔记吧。在笔记这个位置。

我把AT的二阶段模式啊给大家去再详细的把流程列了一遍。那么如果你忘了的话，你可以看这个当然啊，我这个位置没有人官网写的全，我这是摘摘抄官网呢，只是我精简了一下官网的这个位置，如果你忘了这两阶段。

那么AT模式的一阶段和二阶段在这里写的非常详细。好吧，那么我在这儿啊给大家简单过一下，因为咱们都现在起码现在没忘，对吧？O。一阶段是指的是说解析circle啊。

AT模式的一阶段是解析circle得到对应的circle类型update啊，什么呃语句，说白了就是等相关信息，然后查询前进项。这个所谓的查询前进项，就是第二步，就指的是改变之前的数据。

假如说我们订单那个扣库存。在扣库存之前记录一个数据，就叫做前进项。啊，然后根据解析得到的这种条件语句是啊条件信息来生成查询语句定位数据，然后执行业务circle啊，比如说库存检易OK那么在库存检易以后。

它会生成一个后镜像。就是改变后的数据。库存真正减易以后的数据叫做后镜像。它是通过主件来定位数据的OK。然后第五步啊，这还是一阶段啊，一阶段第五步会插入回滚日志。也就是说把这个andlog。

说白了就是啊前后镜像以及业务业务circle相关的信息统一啊成一条回滚的日志记录，插入到andlog表中。啊，插入到安lo表中，那么这表就是用于补偿回滚的对吧？OK啊。

那么在提交前向TC注册分支申请全局锁。啊，在本地事务提交之前向TC去注册分支，而且告诉人的状态，我现在申请申请本地锁。那么本地事务进行提交OK申请之后，本地事务进行提交。

那么业务数据的更新和前面的步骤生成的andlog一并提交。然后最后一阶段最后一步就是将本地事务提交的结果啊上报给TC你是成功了还是失败了？就这意思。就说你的库存是减成功了而是减失败了，最后告诉TC。

如果说你是失败了，那么就走到了二阶段的回滚。失败的时候，2阶的回滚是收到TC的分支回滚请求。那么开启一个本地事务执行如下操作。通过叉ID啊叉ID是什么，知道吧？跟大家说一下啊。

这个东西我在之前几节课跟大家聊过了，叉ID是指的是我们呃如何确定一些分支事务是在我当前这一个全局分布式事务中的这么一个唯一的编号说白了你这个订单本地事务和你的库存本地事务啊。

包括整个这个分布式系统的本地事务啊，不是本地事务，全局事务，他们有个统一的ID就是叉ID通过这个叉ID来确定这个全局事务中所包含的本地事务或者叫分支事务。然后呢，这个是具体的分支事务ID啊。

通过叉ID先找到整个的全局事务，然后呢，通过具体的这个子或者叫做分支这个这个事务的ID来查询对应的这种日志记录。然后根据这个对应的andlog前进项进行补偿回滚，把修改之后的数据回滚回去，就是补偿回滚。

对吧？OK然后提交本地事务，并且把本地事务的执行结果上报给TC就是回滚成功失败。这是回滚啊，但如果二阶段提交的话就比较简单了。那么收到TC的分支提交请求啊，把请求放到一个异部对立中。

马上返回提交成功给TC。那么异部任务阶段分支提交请求将异步和批量的删除相应的andlog。也就是说你如果整整个的这个比如说库存也检成功了，订单也没有问题O那这个时候会把相对应的之前的所有的资源释放掉啊。

包括andlog记录也会删除掉。这个时候我们在最开始给大家演示过了，然后最后整个的进行提交就完成了。好啊，那么这是我简单领大家去回顾了一下AT模式，以及我们之前的案例，包括源码的一些开篇啊。

像源码的下载以及AT模式。我们之前没有讲的读个离写个离。所以这节课啊就先讲到这儿，这是为了我们后续讲源码做一个铺垫。下节课开始，我们就正式的开始去讲啊源码相关内容。

系列 6：P116：Seata源码剖析-源码入口 - 马士兵学堂 - BV1RY4y1Q7DL

好，那么这节课开始我们就开始正式的讲解s塔源码啊。那这节课的话，我们先分析一下这个se塔的源码入口啊，包括呃像sta的客户端启动等等一些东西吧。包括我们分析一些呃核心的类型啊。那么我们先说一下。

其实sta的客户端启动它有几个步骤啊，这几个步骤我们还是跟大家说一下的啊。首先这里我说一下，就是一个Cta的客户端启动一般会分为几个流程啊，第一就是自动加载各种bin以及配置信息啊。

这个不用多说spring boot的项目，对吧？因为之前我就说过，呃，你像ns也好，你像sta也好，它本质上就是一个啊spring boot的项目，对吧？然后第二步。初始化TM。啊。

再来初始化RM就是具体的微服务啊，然后初始化分布式事务的客户端完成。那么代理数据源啊这个数据源代理这个事会回头我们再细讲啊，那么还有就是连接TC，也就是sta的客户端啊，连接TC。然后注册RM注册TM。

然后我们之前说过啊，RMTM是可以替换的啊。因为那个我们之前讲那个AT那个例子，像AT那个订单和这个库存那个订单那个就是既是RM也是TM啊，那个服务。第六步就是开启全局事务。然后啊我这要先说一嘴啊。

就是各位我们再去讲这个的时候，你们一定要去把我们之前讲过的那个案例啊带入进来。这样的话我们会更好理解啊。呃，在这其中啊，其实我们会涉及到几个核心的类型，就在这个集中过程中啊。呃，首先我们说过。

它既然是一个spring boot的项目，那么spring boot的项目的话，我们必然要去找谁啊？找的就是它的一个什么。找到的是spring pool项目启动的时候。

自动扫描加载类型的spring factories啊，然后呢我们找到其中的某一个类型啊，就做seta的自动的配置类啊。这样的话我们来看其中的一些啊核心点。那么这样吧，我呢。

我这是官方案例啊，咱们这样吧，为了问大家好理解啊嗯。啊是吧就在这就在这吧啊，我们就直接找官方案例吧，好吧。这是不是那个方案例啊，是那个O在官方案例中啊，我们就找对应它引入的这个s塔包。

然后呢找它对应的这个spring的启动加载类型啊，spring factories。然后在这其中啊，我们来看一下啊，这个不用多解释这个东西已经说过很多遍了啊。

它自动启动的时候会自动去扫描这个类型中的一些类型。那么你们来看啊，我为什么说大家把之前的那个AT的案例带入进来。

因为我们整个的这种啊分布式事物的一个开启是通过那个艾那个注解global transitional那个注解啊来进行开启的。所以其实这个位置是我们的一个入手的点啊，那个注解其实是我们入手的一个点。

所以其实在这其中你就看呗，那很明显只有一个。thelobal transitional auto configuration有这么个类型，这么一个配置类型。所以其实这个位置就是我们要主要关注的第一块。

也就是源码的入口。我们就从这分析好进来。进来以后啊，你会发现这就是一个就是自自动装配类，对吧？啊，其实就是说白了啊，这个这个东西如果说你之前用过chair的配置的话，其实这个跟chm配置是一样的。

也是一个bin啊，包括什么其他的一些这个这个这个类型，对吧？OK好啊，所以这个位置你可以看到有一个艾 bin。那你看到艾 bin的时候，它注了一个什么？

叫做 globalbal transitional scanner，这个实际上是叫做全局事物扫描类。啊，所以其实我们应该从这去入手嘛啊，我们就应该从这儿去入手。为什么从这说呢？

全局事物扫描类从这儿去扫描，你通过at特global transitional注解所标注的对应类型。那么他从事是扫描。啊，OK所以其实我们可以看一下笔记，因为这我没有办法写写注释啊。

我在笔记中给大家写了一下。

这个类型就它啊global transitional auto configuration，那么它就是sta的自动的配置类。在这儿它注入了一个全局的事物扫描器。在这它注了一个全局事物的扫描器。

然后在这其中啊。你可以看到有个return newglobal transitional scanner，它是构建全局扫描器啊，包括传入的参数是对应的应用名称以及事物分组名啊，包括这种失败处理器。

所以在这儿各位啊，我们现在。

就来去看一下他。呃，这个的话我们就不通过这来看了，我们直接上源码吧。好吧，我们现在知道了入手点在global transitional scanner啊，这个全局事物扫描器。那么我们就直接通过源码来找。

原码的话，我在这里啊。已经把源码给大家开起来了。OK好，那么就是它啊就是它global transitional scanner那就这个。OK啊，我们来看一下这里面都干什么了。

那么其实啊先不着急往下看啊，我呢在这个讲源码过程中啊，给大家去做了一张图啊，我们讲到哪儿画到哪儿啊，这样的话方便大家复习，回头这个图会给大家的啊。那么可以看到我们最开始第一件事情。

其实说白了就是呃我没有拿那个我们那个案例去演示啊，至常你们拿我们那个案例也是可以的，他通过去找到我们那个older service订单那块啊，它是TM嘛，对吧？

找到这个sring boot自动装配对应的一个类型，然后找到这个ide注入的这个全局事务扫描器，现在到这儿了。对吧那么在这其中啊，我们往下来分析。在这其中你可以看到它首先继承了一个什么。啊。

obstract auto pro这什么东西啊，这不用多说了吧，这个这是AOP啊。对吧这AOP啊，我们之前nacocentino都见过AOP其实啊这个OAOP其实在我们你会发现，在我们越往后越往深学习。

包括学习源码的时候，你会发现它变得越来越重要了。很多相关的这种代理啊，都是通过AOP的形式来进行增强啊，来进行使用的。它进行动态代理。对吧？OK啊，所以这个位置你可以看到全局事务扫描器第一件事情。

它继承了一个啊AOP的对应的这么一个核心类型。那么还有什么呢？我在这儿啊都在这儿。我把这几个类型给大家列出来了。一个是监听器的一个基准接口啊，监听器因为它有一些呃事物事件的一些东西啊。

那么包括有一个啊bin的初始化过程，就这个in南引。ling bin啊，包括还有一个啊spring容器。这个后续我们慢慢说啊，包括有一个容器销毁，它其实用到了spplayring容器相关的一些内容啊。

这个咱们慢慢说啊。那么呃我还是说一嘴啊，我们去学源码的话，一定要去先看整个的主流程，对吧？先看整个主流程，那么这个位置我们上来有1个AOP其实我们应该从这开始入手去看一下，在这其中它做了什么。

当然这里面源码有很多很多内容啊，这个咱慢慢分析，不着急啊。然后我要就大让大家注意两点啊，一个是这个叫做application ID这个是服务名。

这个属性还有就是一个TX service group只是事务分组啊，这两点各位记一下。好吧，我这给大家标下来了。那么我们可以看一眼图啊，找到了这块以后，我们要分析的实际上是一个啊。

这个你看我这写了一句话，把标注了at特ggbal transitional注解所在类生成代理对象，并植入拦截器啊，global transitional这个inter capture啊。

这个东西什么意思呢？这个咱慢慢说啊，但然这个位置不光有它，还有一个这个。

啊，呃lesser en bin啊这个东西我们就一个个来看吧。其实我们可以先看一下这头啊，简单来看一下。这个指的是谁？指的就是他。啊，那么它里面可以看啊，有这么一个方法。下载一下啊。有这么一个方法。

after方法，对吧？可以看一下这个方法在这儿它去实现了对应这个接口以后，他需要去实现对应方法。所以我们。所以再找一下啊。🤧嗯。在这个方法中，他干了什么呢？我们来注意看啊。

在这儿首先这个监听咱们先不着急看啊，我们主要来看这个位置。他调用一个叫做init client方法。init初始化cle是客户端，这什么意思啊？很明显了，对吧？初始化客户端方法。

所以在这个位置我们就找到了一个初始化客户端方法。然后这个日志这我不看啊，咱们主要看看主要流程。那么它这个位置会对应有个检查，包括检查对应的应用名称以及事物分组名。如果唯空就抛异常啊，这都不用说。

那么你要看这儿一个初始化TM和初始化RM。初始化TM是什么？不用多不用多解释了。对吧初始化TM。O还有一个初始化RMRM clientant点init。啊，包括obplication。

什么ID这是应用的名称，包括事物分组，应用名称、事物分组，还有一些其他的属性。那说白了在这个位置啊，在这个global transitional呃这个这个这个scanner中。

它有一个继承这个接口的目的是为了去初始化你的TM和RM这点其实符合我们在说过那个启动流程中的几个步骤。对吧？OK当然这个位置后续我们会详细分析，现在我们就先暂且啊分析到这个位置。因为这好说。

我就先说了啊，也就说白了他去调用对应的重写这个方法来去初始化的客户端，初始化客户端的RM以及TMOK这一步就完成了。那么现在我们再回到这头。啊，我们来看这儿。这什么意思？往上翻啊，首先我们可以看一眼啊。

它继承的这个AOP的这个核心类型啊，我们可以看一眼，在这其中有个关键的方法，嗯，我来找一下啊，有个关键方法。嗯。关键方法就是我们说的那个。哎，哪去了？来看一下啊。我记得是wep什么这儿啊，找着在这里啊。

vap if if if necessary啊 necessaryces necessary啊vap if if necessary这个方法。

其实这个方法它就是来判断你当前啊所用注解所标注的那个对象是否需要代理啊，就是那个bin我们代理以后那个bin啊，我们标注注解以后那个那个类型的那个并对象，它是否需要被代理，是否需要被增强。

当然这是它的一个负集写法。我们可以看一下啊，我们当前在这个呃全局事务扫描器中它继承了这个类型，所以它重写的这个方法，我们给它找一下啊。找一下再重写这个方法啊。

在这呢OK啊wep一副necessary找的这个方法，我这也标注是代理增强啊，而且spring的所有的 bin都会经过此方法。说白了，其实就是你通过对应的那个注解标注以后。

那么他就会在这儿啊来走它自己的这么一套模式。啊，它去继承负类方法重写之后啊，继承负类重写以后啊，重写方法以后完成它定制化的效果。其实我们可以看一下这方法。🤧它的定制化效果是什么啊？首先加锁。防止并发。

然后你来看这儿啊，检查是否是TCC模式。Check TCC。啊，什么检查是否是TCC模式，是否是TCC的代理对象。说白了这个位置就是它根据了不同模式会走一些不同的这个对应的一些呃拦截器啊。

因为你这个东西本身就是你想啊我们这个AOP里面就是有拦截器的对吧？这是关键点，所以这个位置不用多解释。很明显。TCC模式它走了对应的是TCC的拦截器，所以上来才会先判断你当前啊是否是TCC模式。

如果是的话，它会走对应TCC的拦截器。啊，但正常来说，我们现在说它是AT。所以说如果不是TCC模式的话，它会判断是否有相关事物的注解。啊，如果没有的话就不代理了。那这个的话就不用很很不用多说了。

我们写的那个我们之前代入，我们之前写的那个order订单那个和scket的那个库存那个我们在order那就去添加了对应的这个注解，所以它必然是开启啊这个全局事务的，所以它也是有注解的。

那么它必然会开启相关的这什么代理，对吧？所以我们先来看啊，你看这个位置说了，说当发现存在全局事物注解at变啊，全局全局事物注解的bin则添加拦截器。啥意思啊？也就说白了。

你这个位置它在你oldder订单那个位置发现对应有注解了。好，那么它就添加拦截器。而且在蓝截器这个位置有这么个对象啊，global transitional啊 interrate这个这个对象啊。

所以实际上后续的话我们应该是往这个里面去深入来看一看啊，在这里面去干了什么。当然我们先不着急往下看啊，先不着急去进到这深入啊，先往下来看。他往下还有就是说检查是否是代理对象。

也就是说当前你看AOP u点isAOP啊 products啊。代理对象对吧？如果不是的话，会调用负级的这个代理。如果已经是代理对象的话，他会做一些这种集合的一些添加，这个就不用详细去看了。

我们主要还是要看哪儿呢，看的是添加拦截器这个位置。啊，要知道这个拦截器里面具体干了哪些事情。所以说到这儿的话，其实我们可以看一下我们这个流程。嗯。在这个位置我就说白了。

你看这个对象它的作用是AOP抽象类具有生成代理对象的功能。也就说白了，对你当前所艾特 bin注解所标注的那个类型进行增强啊。

而且它后续是把标注了这个艾特global transitional注解所在类的这个代理对象啊，生成它的代理对象并且植入到这个蓝截器中。那么在拦截器中要做什么事呢？在这儿啊，你们要想一点。

我你看我这写了啊，我这写了一个说拦截器调用这个inwork方法。但是去调这个invo方法之前，怎么去触发的？是你浏览器请求触发全局数。啥意思？我还是把之前的案例给大家开开吧，这样的话好理解啊。

OK就是他啊，稍微等一下啊，很快。好啊，我之前带着大家写过，这个是应该在就是就是它啊8001。我们之前写过1个80018002，然后呢，我们现在是在8001的这个位置上。我后期改了一下。

我是把它放到了这个业务层中啊，我在这儿去开启的全局事务，创建订单的时候。所以说白了我们再对照这张图。他的意思就是指啊通过这个AOP对象，然后呢找到你对应的这个注解所标注的这个所在的类型，就这个类型啊。

然后生成一个代理对象。啊，生成代理对象以后编入对应的拦截器，然后做对应的增强。也就是说他要具体做的一些事情啊，这个增强所谓的增强就是指这个代理对象，我像大家都玩过啊。

这个所谓代理对象就是在原有的这个功能之上去加一些其他的功能，就像我们AOP1样，对吧？啊，去做这种监听啊，环绕监听等等这些东西一样的道理啊。🤧那么怎么去触发这块呢？你看我这写了说浏览器发起请求。

触发全局事务。说白了就是我们浏览器在调用这个当前订单以后去发起创建订单的时候，那么走到业务类型的时候啊，那么就会去触发什么呢？拦截器中其中的inwork方法。这个其实我不用给大家去试了。

这个应该是比较基础的内容了啊，这个蓝截器实必然会触发这个inwork和方法了。所以啊。当我们。有这个请求进来以后啊，有这个请求进来以后啊，哪去了？这个代码有点多了啊。就会走到拦截器中的。

in work方法。在这儿。🤧啊，走到拦截系中的inwork方法来执行对应操作。那么这里的操作是什么呢啊？我们可以看一下。首先，获取执行方法。啊，类型包括这有一个messr的获取执行方法，什么方法？

就是你通过注解所标注的那个方法。啊，我们那个是创建订单，它获取是这个方法。然后在这儿啊，你们要注意看，它会获取几个东西，一个是获取global。transitional全局事务。

还有一个就是global look什么全局锁获取全局锁，这说白了就是原数据。那么这个一点就验证了我们之前给大家讲过那个读隔离且隔离其中所有的那个全局锁。

而且这会写了说这个全局锁是会将本地事务执行纳入到西塔的分布式事务管理中啊，一起来竞争全局锁，保证全局事务在执行的时候，本地业务不可操作全局事务中的记录。张写张读啊，就在这儿体现的。🤧所以说白了。

我们获取到了拳局事务，同时要拿到对应的拳击锁。拿到这儿以后再来往下来看说判断啊，在这有判断说看首先是否获取到了这个全局事务。如果没有获取到的话，另当别论。如果获取到的就执行全局事务啊。

然后再去执行本地事务。先不着急看这个本地事务。其实就我们要往后分析的话，需要分析的是这个全局事务。啊，分析是这个全局实物，我们可以看图。走到一个一mo方法，对吧？它实际上就是解析你的这个注解。

然后对应的执行全局事务。在这儿handler啊global transitional啊，所以后续我们真正的核心是在这儿。而且这里面的核心是在这个判断方法上。但是这块的话啊，我们就先不往下分析了。

因为现在分析的已经有点多了啊。所以回过头来的话，其实我们可以看图总结一下这节课分析的内容就是说白了我们这个源码是从哪入手的？把我们那个案例引入。

从订单那个位置去找到对应它spring boot自动装配的那个spring factories，找到我们对应的这个类型。

global transition auto to啊transal auto configuration，然后找到对应它里面的一个非常核心的类型。

就是全局事物扫描器跟我们那个atglobal transition transitional那个注解有关的啊，找到它。在这个。扫描器这个位置比较核心的两个功能。

一个是去继承AOP相关的核心类去做一些这种拦截器啊，环绕监听等等啊，不是环绕，就是做一些拦截器，做一些监听啊，做一些对当前对象生成代理进行增强啊。那么还有一点就是整个的对你当前的这个病的一个生命周期啊。

生命周期啊，不是生命啊，生命周期。啊，生命周期的管理。那么这一点的话其实呃没有详细分析，只是先给大家说了一下，说白就是初始化RM初始化TM这一点给大家看到了，具体我们后续再分析。那么。

后续主要看的是这儿。在具有了这个AOP代理以后，那么他去重写了负极的这个方法，然后去啊生成对应的这个代理对象，然后构建拦截器。在你去触发这种全局事故的时候，也就是controller发起请求。啊。

之后走的是in work方法，拦截器的in work方法，解析你的全局事务注解，然后对应执行全局事务。当然，对应执行全局事务具体干什么了，我们还没有分析。这个话我们下节课来分析。啊。

所以这里块的话我们就暂时先分析到这里，说白了就是给大家去原码开了个头。让你们知道怎么去找源码的这个入口，然后呢啊我们会后续慢慢根据整个的这个流程啊，刚才我提到这个流程来一点分析。其实这里课的话。

我们也可以看到自动加载并啊这些信息，包括初始化IMTM。

啊，代理数据源这个我没说，这回头再说啊，连接TC也没说啊，注册RM和注册TC啊，注册TM这个也没说，然后呃开启选举事务。这个事儿我们看见入口了，但是我们后续会详细分析。好吧啊。

OK那么这节课的话我们就先分析到这儿啊，回头的话你们可以去把这个图啊，我回头把链接给你们，把这个图好好看看，跟这个图走一遍流程啊，就能熟悉了。然后说一下啊。

其实我们当前的这个位置有一个global transitional scanner，这个类型是非常重要的啊，所有的基本都在这呢，而且可以给大家看一下它的一个类关系啊。

多说一嘴吧。啊，就是他啊。这是它的相关类图啊这是它相关类图。首先它继承了哪有哪些接口啊，继承哪些类型啊，这个类型怎么回事啊？这个的话大家可以自己看一下。好吧啊，OK。😊。

那么原码分析上来可能大家会觉得有点空啊，说老师这玩意分析的没什么意义的感觉。这个别着急啊，刚开个头，慢慢的我们现在只是把一些分支给大家列出来了，对吧？两大分支，一个是这个。

AOP这头的一个是这个整个的一个初始化这头的。那么后续我们会针对这两条路线再去展开分析。后续我们就会越来越清晰。好了，各位啊，那么这节课就先到这里了。

系列 6：P117：Seata源码分析-2PC核心源码解读 - 马士兵学堂 - BV1RY4y1Q7DL

OK各位，那么咱们这节课来接着学习s塔的源码相关内容。呃，上节课的话我们讲到了说这个global transitional intercap这个全局事务拦截器，说一旦执行这个拦截器啊。

就会进入到啊其中的这个in work方法。那么在这其中会做一些什么注解的判断呢？有注解以后会执行全局事务啊。那么呃其实在这儿啊，我去给大家纠正一点啊，我们先看先复习一下吧啊。

呃，上节课包括上节课给大家去画一些图啊，那么这个图的话呃后续我还会去增加一些内容。这个还有没有增加完啊，这个咱们先咱们先不看这头啊，就还是看这儿，咱们简单去复习一下说这个。从哪儿开始？

我们是从这个例子的角度去分析的。其实我们这节块要分析的就是整个的这个AT模式的2PC的这个请求的一个流程整体流程啊，那么这个全局售务端整体流程。其实这个流程的话是一个比较关键的点。

所以我们要等大家去复习一下，上节课我们也说过啊，包括我们之前一直聊说这个呃ta它分为三个比较重要的角色，分别哪三个记着吧对吧？有TC啊，这个TC这个替的啊，这个TC指的就是sta server对吧？

我们安装那个塔 server啊，那么它是那个最大号的对吧？它是那个服务端，或者不能说最大号，它是那个服务端啊，那当然还有客户端客户端包含有TM。还有RM就是它三个非常重要的概念，对吧？

那么TM呢是指我具体的这个事物的开启，它从这去开启全局事务，告诉TC，我开启全局事务。RM是具体的事物的参与者，说白了就是具体的一个个的微服务。那么我们之前也写过对应的案例。

那么写过像alder serveroldder server，包括写个alder，写个t订单，由订单去发起请求啊，干什么创建。哎，订单啊那么对应的要减库存，那么这其中存在分布式是用问题。

所以现在谁去发起的这个全局事务，谁就是那个TM。那么明显outder server order server啊就是TM。所以从这开始。

我们找到了对应的spring boot启动的时候所啊这种自动配置的这个啊自动装配的这么一个类型，叫做global transitional auto configuration。可给大家找一下啊。呃。

我甭甭着他了甭他了，往下走啊，这就甭找了，那个还得看那个啊，甭找他了，反正最后走到哪儿呢？它其中一个非常重要的点啊，就以它会注入一些bin组件，一个非常重要的 bin组件。

就是这个global transitional scanner，也就是它啊那么它是干什么呢？它是全局事务扫描器，用来扫描啊，我可以告诉大家，他扫描什么。现在我可以完全告诉大家。

它扫描的就是你当前啊这些啊所有的 bin组件中哪些是带什么的那个at transitional注解的。如果你带，那么它就会扫描到，并且添加对应的代理来进行增强啊，完成一系列的功能。😊。

okK所以简单复习一下吧来看。那么在这儿啊，我们现在啊呃要知道是这个global transitional scanner，它实际上继承了abstract auto to pro呃。😊，呃。

蒙住了啊obstract auto proxy啊c那实际上这就是AOP嘛，对吧？AOP的比较核心的一个类型。那么AOP的话干什么进行增强并动态代理，对吧？啊。

包括它还有一些其他的什么什么啊confiration change listener，这是一个机这个这个监听器的一个接口啊，包括什么呃以这个这个这个这个。interizing bin啊bin初始化。

包括什么applicationation context award啊，包括等等这些吧。那实际上这三个其实你们看到以后会发现它比较眼熟的而这三个实际上是是什么？我可以明确的告诉大家，它其实就是。

spring容器啊。它其实就是spring容器。所以说白了我们这个当前的这个global transitional scanner啊，在最开始的时候给大家捋流程的时候，没有告诉大家。

它实际上天生就自带spring容器。啊，这点要知道，那它这个位置说白了你你找到了有这个东西，它的作用就是去呃初始化相关的。而这个最后这个它是sprint容器销毁的时候走它。

所以它对应有个desstroy方法啊，而它的话也有一个对应方法，就是after proper test set啊，在所有的 bin执行了配置以后会找它会走它啊。ok首际先这不就是spring嘛，对吧？

这不用多解释O啊。好，那么在当前这个类型中，这不是重点，重点是它在干了什么啊，我们都知道它继承这个obstract auto topro cl的时候，它对应有一个方法。找一下啊。呃，这个方法哪去了？呃。

他有一个非常重要的方法，我看一下啊嗯。这个方法。喂。啊。算了，咱看这儿吧，我找完全没找着啊，就这个方法啊，我我我把它复制一下。😊，哦，在这儿OK啊。OK在这儿啊，我翻过头的啊，这个非常重要的方法。

也就是说白了，我们只要有对应的这个AOP，它必然会执行这个方法，对吧？说白了为什么是执行它呢？就是因为你去继承了这个对应的抽枪类型，你在底下就必须重写这个方法啊，这也要注意。😊，啊，必须重启这个方法。

那么它就实际的那个代理增强spring所有的bin都会经过此方法啊，那这里会有一些锁啊，包括去检查是否是TCC模式，还是不如果不是TCC是干什么什么什么什么对吧？

包括这里面啊去什么啊发现当前全局数注解并啊，拦添加拦截器。其实上节课的候，我们就分析到这儿，说添加蓝截器，对吧？

你看我这画着呢说啊这有一个global transitional啊intercap不就在这吗？啊，添加链接器。对吧啊，添加来近期。那么这个是我们这节课重要往下分析的一个地方。但是咱们先不着急看它啊。

先把这捋完啊，往下来看的话，它这个位置会盘去检测你当前是不是代理对象啊。如果不是的话，就返回负极spring掉的方法，就是负极那个调的方法。如果是的话啊，那么就呃。😊，这个去添加了些细节组合等等这些吧。

这个就比较简单了啊，这个其实不是什么重点，我就不多说了OK啊，那么这其中啊嗯我刚才说过了，比较重要在哪儿？😊，在这儿。啊。

thelogo transitional啊intercap这块是非常重要的一个地方啊，为什么说这里非常重要呢？因为啊大家要注意。呃，它是怎么来的？为什么会有这个拦截器，它怎么进来的？

其实我们可以看图这个拦截器啊，它的作用就是去调用in work方法。那这个我们都知道，拦截器会必然调用这个inwork方法。那么什么时候调用的它拦截的又是什么？

这点要说清楚它拦截的实际上是在你用户请求发到这个alder之前，也就是浏览器发起全局事务的时候，它会进行拦截啊，调用in work方法，先走你对应拦截器的一些流程啊。

一些逻辑走完以后再走你对应的一些啊自己的业务。😊，对吧所以上节课实际上分析到这儿，就是走的这个in work方法。😊，啊，对吧。哎，哪去了？这个inwork方法。也就是说当浏览器发送请求。好。

那么拦截器生效，调拦截器的inwork方法。那咱们就分析一下这个in work方法。其中。干了什么？啊，抱歉啊，呛住了嗯。那么上节课这个位置简单跟大家说了一说他干的具体一些事情。那么我要纠正一点啊。

上节课我也是着急了啊，抱歉抱歉，我刚才我上节课这会讲到啊，我们看图啊，说这个位置说啊啊创建完订单以后解析对应的global transitional注解，也就是全局事务注解。解析完注解以后。

如果包含注解就执行全局事务。如果不包含执行呃，不包含注解执行的是。😊，我说的是本地事务啊，sorry抱歉，这里不对，它不是本地事务，它是执行全局所。嗯，我在最开始给大家讲源码的时候。

跟大家去讲过这个锁的概念。这个全局所的概念，它是为了防止这种脏毒或者脏写的发生啊，AT模式特意提供这么个锁对吧？你必须就是两个事务的时候，举个例子来说啊，复习一下TX1他必须得获得全局所啊。

那么他在执行过程中，这个全局所一直他持有。他必须全部或commit或者执行完成以后，那么TS2第二个事务才能去拿到这个全局所执行它对应的一些事务。如果当前TS1在没有执行完的时候。

TS2是拿不到全局所的。那么他所做的所有的本地事务将直接什么本地回滚，然后一直在这重事重事重试重事什么，等待拿到这个全局锁。O啊，画的有点草图，简单复习一下。所以这是我们之前讲过的一个概念。

那么在这实际上就已经体现出来了。在它这个源码中啊，所以这个位置实际上是需要首先去执行啊，去获取看有没有对应的这个注解，这不是吗？获取个global transitional全局事务注解。

包括这里会获取全局，这就是获取全局锁啊，这句话实际上就是获取全局锁。在获取了以后。在获取了以后啊，执行完在获取以后，如果有这个全局事务，那么他就会执行全局事务。如果啊获取完以后有全局锁。

那么会对应执行全局锁相关的一些处理。全局锁这里我还没有去关注，我们现在关注的是全局事务。好，接着往下走，handler globalbal transactional座套啊。呃，在这其中啊，上节科呃。

我也忘了会给给大家分分析，反正我接着说吧啊，在这里面实际上就是我们要主要分析的一个内容。啊，主要分析一个内容啊，为什么这么说呢？这个handlerg啊transal实际上这块是非常非常关键的一块内容。

我们可以先看图啊。这我写了说判断完以后。handler globalbal transitional它的作用实际上是获取事物信息以及执行全局事务。啊，或记住啊，它是获取事物信息，执行全局事务。

为什么这么说，我们来看源码。走到这以后，你往下来看啊，首先这块咱们先不着急看，你先往这儿看，这是干什么？😊，首先这个位置我可以告诉大家，咱们主要看源码，先看流程，不要去分析细节啊。

它这个位置是获取你当前的事物名称啊，就是获取你当前那个方法名。如果没有的话，就是默认方法名啊。然后它要去解析global transitional注解属性封装为对象。那么有哪些属性呢？

其实我可以告诉大家，就是我们这个。嗯，global transitional这个注解啊这个注解啊，global transitional这个注解它对应是有一些自己的属性的，给大家搂一眼。啊。

这个数解给大家看一眼啊，你看什么time out啊，min time outmin，包括对应的名字等等吧，一些它是有自己的一些啊属性的啊，这些属性的话，说白了是有一些默认值的啊。

它是有一些默认值的那他需要去拿到这些默认值去把当前这个对应对应的这个注解啊，打成一个对象，所以在这个位置看第一件事情，它是获取超时时间，默认是60秒。为什么这么说呢？

你看刚才咱们看到那个time out minutes了，对不对？所以你看啊说呃解析global transitional注解属性封装为对象。那在这个位置首先第一件事情就是获取超时时间。

默认为60秒O可以看到怎么去获取的。😊，time out minutes走，它掉的是哪儿，是不是它？对吧那么你看它默认的是deunt values，这值是多少？这是毫秒啊，6万毫秒，你换算一下是多少秒。

对不对？OK。好啊，这不多说了。然后再回来，那么道理都是一样的。那么这能获取到剩下就好办了，对吧？你看包括构建事务对象信息，它这个事务对象信息，包括什么超时时间，事物的名称，你可以默认理解为方法名。

包括事物的传播啊，那么呃校验或占用全局所的什么间隔等等啊等等等等等这些东西，把这些所有的对应的。😊，注解中的信息啊，不管是默认的还是可以设置啊，当然这个位置可以设置啊，一般都是默认的。

把这些信息打包成一个对象，构建一个对象啊，然后啊进行一些其他操索等等这些啊。然后如果出问题，会执行对应执行对应的异常，这是这块位置的一个逻辑啊，它是一个整体逻辑。那么啊说完这块以后。

我们再往下来看一看啊，下面还有啥看看啊嗯啊这个方法没啥了。那么其实这个位置啊这个位置只是去上来获取了对应的一些啊啊这个这个这个这个。事物的一个信息啊。那么。这其中还有一点。获取完事物信息以后。

它执行的一个全局事务在哪儿去执行呢？其实我们这其中有个非常关键的方法，就它我一直没提到。啊，就这个方法。XQ的方法我们可以搂一眼啊，看他干什么了啊，走。😊，哎，过头往上啊，在这儿来XQ的方法。

那么这个方法它干了什么呢？其实啊各位我们来仔细去观察这方法。上来第一件事情，获取事物信息。哎。拿到对应的事物信息，然后干什么呢？获取当前的事物，主要获取叉ID哎叉ID是什么？还记得吧？

全局事物的唯一标识对吗？OK然后什么根据配置的不同事物传播行为执行不同逻辑大家可能会对这个事物传播行为会有点疑惑啊，这个实际上就是spring那个事物传播行为啊呃，一般它默认就就有这么几种啊，对吧？

OK啊。这个如果说你对这个事物传播行为不了解的话，我建议大家去看看spring源码，或者看看spring课程啊，去把spring的事物传播行为啊，这个这个搞不清楚了。好吧，这我就不多解释。

因为这是老相当于之前老的知识点了啊OK。那么呃这个位置获取完对应的这个事物传播行为以后，再往下来看。还干什么了？在这儿，如果当前没有事物，事物则创建一个新的事物。开始执行存局事务。咱先关注主要流程啊。

发生异常回滚呃，哎怎么这个这个这个字呢个数据啊。各个吧okK各个数据通过under log表进行事物补偿，这是不AT啊？这是吧AT啊，对吧？OK如果没有问题好，全局提交。最后不管怎么着都要清理资源。来。

我问大家，这是不是就是AT模式的一个，或者说说或者说这个C塔比较核心的这么1个2RPC整体的事务全局事务的执行流程。啊，那说白了我们在这儿就能看到这些整体的执行流程。

这就是我们今天要分析的一个非常关键的点。那么说白了也就是任何你的请求进来以后，他都必然会走这儿啊，就任何你的全局事务走来进来以后，他都必须要走这儿，获取当前事务啊执行一些其他的一些呃呃，咱可以大步骤啊。

第一件事获取事物信息。然后。第二点说开始执行全局事务啊。第三点说发生异常回滚啊，各数据通过anttolog进行这个事务补偿。如果没有异常，全局提交。那很明显摆这就是整个的一个事务的执行流程。

全局事入这个流程对吗？当然我们可以看图。这就是我在这标出来的，获取事务信息开始执行全局事务，发生异常回滚，全局提交以最后的清除资源。所以大家说白了这个方法是干啥的啊，大家说这个方法干啥的？

exccuse的方法是干啥的，就是真正去执行整体2PC这个阶段的全部的核心流程代码全在这里。啊，O那大家可能会产生一些疑问。老师这里呢这里有很多细节呀，包括我们最开始去讲这个复习这个AT模式。

它的EPC阶段和2PC阶段的时候，2PC咱们好理解EPC它有很多很多的一些细节事情。那么这些事情我们就可以分析一下了。😊，先看这头。啊，我这标了一些，你可以看到上来获取当前事物，主要获取叉ID。

然后根据什么配置的不同的事物传播行为执行不同逻辑。如果当前没有事物创建一个新的事物，这套流程在哪儿？

就在第一步里吗。上来获取事物信息以后。在这儿获取当前事物，主要获取叉ID从这去获取的。啊，你看叉ID如果为no干什么获取叉ID去。对吧？ok啊，这我就不不细往下看了啊。那么第二点说。

根据配置不同的事物的传播行为执行不同逻辑。那么这一点其实也。看这吧，来。咱们看看这个类型。这个类型是干啥的？for global transitional啊，这里面有对应的一些事物的一些传播行为。

这就是spring那个事物事故什播行为啊，这就是spring的事故传播行为。OK这点我们验证了。那么还有往下来说。😊，这儿1。3。他首先啊去拿这个事物的时候，这个TS代表就是当前这个事物啊。

代表当前这个全局事务。如果当前这个事务没有的话，那么它就要创建一个新的事务来进行执行。那么在这块就是如果没有创建新的。好，那么这就是第一步所做的事情。那么它对应的就是这头流程。

没问题吧，对吧？ok好，然后到第二步，那么第二步这个位置它会发生一些事情。😊，啊，什么事情呢？就是。什么事情啊？往下说一下，一点儿来分析啊，咱们一点儿来分析。首先在第二步这个位置开始执行全局事务。

那你可以先看流程。上来看我这写了1个TM对TC，也就是sta server发起请求。客户端向服务端发起请求，这是那个TC这是那个TM。啊，然后还有什么？有一个begin方法啊。

走到默认事物管理者这个位置，通过nT通讯。哎，其实在最开始我讲这个应用的时候，我跟大家说过，这个se塔它的底层实际上用到了nT。啊，它实际上最终是通过nT通讯和谁发生的沟通啊，和服务端进行的一个沟通。

好，那我们就看看这一步骤啊。第二步骤okK从这开始，我们主要关注这儿说开始执行全局事务走进去。啊，那么在这进去之前，我还要再说多说一嘴啊，再多说一嘴。各位你们先看这个主流程啊，主流程。

第一步说获取事物信息，第二步，开始执行全区事务。第三步发生异常回滚。第四步，全区事务提交。那我想问大家，你们就猜测一下啊，咱们可以看这张图。在这四在这几个步骤中啊，就看这四个步骤。在这四个步骤中。

哪个位置它对。TC也就是sta server发起的请求。很明显，我们获取事物信息以及开始执行全局事务的时候，并没有真正的与TC发生相关的通信。啊。其实我可以告诉大家啊，也不能这么说啊，不能说倒过来说啊。

就这个位置不是说没有发生真正通讯，而是说在这整个这个流程中。😡，啊，这儿其实已经发展通讯了啊，只是在这个整个流程中啊，哪里是EPC，哪里是2PC啊，抱歉，刚才我家猫一叫，我这思路被打断了一下啊。

我重新说啊，在这整个阶段中各位来想一下，在这整个阶段中，咱们先看一下前四个阶段啊，这整个阶段中哪里是EPC哪里是2PC很明显。😊，12都属于EPC阶段。从这儿开始出现异常了，进行全局回滚，没有异常。

全局提交才是真正的这个2PC阶段。对吧明有白吧？所以这一点各位要注意一下啊，这一点各位要注意一下。那么最后它清除资源就不多说了啊，所以说白了从这儿我就可以看到，这就是整个2RPC的一个执行的关键点。

所以现在咱们就看一下第二步这个位置，它是开启开始执行全局事务。那我们都知道。😊，我们这个嗯找一块空白机会，我简单画一下啊，比如说。这是我的。啊，去找他吧。这是我的那个TM。

对吧那么他最开始要发起全局事务，他是不是得需要跟TC，也就是s塔 server进行通讯呢？对吧？OK好，那么什么位置开始通讯开启全局事务的时候，要跟TC进行通讯。那很明显。

我们是不是应该是在第二步这个位置时候啊，跟TC去发起一个通讯呢？也就是setta server去发起通信，对吧？那么怎么去发起的流程在这儿O我们搂一遍，好吧嗯。😊，找到第二步啊。

找到这个begin transitional走。O。那其实这个位置各位啊呃在这儿TC1点begin从这儿去发起的对发对TC发起的请求。但是各位你们要注意看一下，这个位置实际上涉及到了一个。设计模式。

看这方法。啊，这是掉着水哎，等回来啊，这是啊你看啊trigg呃bebe bin啊，trigger before bin和一个trigger after beginin啊，bein啊，最漂了ok。

可以看一下。这是个空方法。看这个after这个。这也是个空方法。那么各位你们看到这儿想到了什么？😡，这实际上就是一个模板模式的应用。这个相当于就是说啊它当然默认没有啊。如果你想拓展的话。

你是可以通过在发起请求前干什么事儿，发起请求后干什么事儿啊，你可以自己拓展的，这是个模板模式的应用。好吧啊，这简单提一嘴。然后我们要真正要去关注的就是这个对TC发起的请求，就是TX点begin这个位置。

好，我们进去看一眼。当然啊。他是需要有对应的什么。重写的我们我们走的是哪一个啊？我们这个位置走的实际上就是默认的deefund。因为我们知道这个sta的默认的这个模式就是AT，所以不用看别的。

直接找deefundgbal transition找它O。😊，由它进行调用，我们来看制定制方法，他都干什么了啊。第二步，这是与TM去发起沟通。这一步啊，回到这个途中，我再说一下，就是在这儿。

这是当前的TM与TC进行沟通，发起请求的过程啊。所以咱们来看一下它真正去发起请求的过程啊，begin。首先上来就有一个判断。他判断你调用者当前是否是TM。那你们来想一下。

如果你是第一次发起全局请求的话啊，全局事务请求的话很明显一定是得是TM发起。啊，为什么这么说，看官网看官网啊。😡。

TM是干什么？他记得吗？😡，事物管理器，咱不看这儿，看这儿来。😡，天M在这儿呢。是不是得由他先去整个发起全局事务？是不是得他发起啊，对吧？你不能说我对应RM发起吧，那除非他也是TM，那这不太现实，对吧？

所以通过咱们图中很明显可以知道TM发起的全局事务。所以在这调用者必然必须第一次是TM。如果不是，那就是直接就拜拜了啊哈，直接就拜拜了。好吧，OK啊，所以这判断是否是TM这是第一次发起全局请求的时候。

全局事务请求啊，然后往下来看，在这个位置。😊。

获取叉ID。啊，transitional manager啊，事务管理者点begin方法在这儿获取的1个叉ID。可以看到吧啊，在这儿获取了1个叉ID。O那没有问题，那我们接着往下来跟啊，走到哪儿。

走到这个获取叉ID呃。啊，这 beginO往下来接着个再往下来跟啊，当然这个位置也是需要有调用的。那么这个位置的调用也不用想，就找deon就行啊。

这个ded transition transitional manager不是他吗啊，trans transitional manager找他啊。

de transition最漂亮transal manager啊，默认的对吧？走ok走到这个位置beginok大家来看这。😊，这个位置就很好看了，对吧？对应的请求以及对应的事物名称、超时时间等等。

然后把请求给他返回一个响应。那么我们往下来跟跟哪儿跟这个。这儿。啊，这个这个这跟这个位置。那你们来看这个位置啊，它有一个非常重要的东西，你看。他通过try开始方式去写。然后你看这儿。

TMnty什么时候ant点get instance实例，send发行球。这个很明显，如果说你对nty比较熟悉的话，各位这一看就知道这是通过nty去发的行球。啊，这是通过nT就发的请求啊，没什么毛病。

对吧？OK那么其实这个TM这个对应的nT类，那么你可以看名字。😊，的TMn clientant它是对应的1个TM的 clientant一个客户端。所以从这去发起的请求，这也不用多说什么了，对吧？

所以现在我们就分析清楚了啊，我们回过头来再捋一下啊，咱不看这看图吧。

我们刚才去找到了这个啊这个这个对应的一个执行全局流程的一个全局事务流程的一个方法。然后在这其中有几个步骤，我们看到了有获取事务信息开始执行全局事务，发生异常回滚，或者说全局提交。

那么说白了这个位置整个就是1个AT的2PC阶段。核心核心源码对吧？核心源码。那么在这过程中，一和2。这个位置是EPC。三和四是2PC2PC阶段啊，所以当前。我们第一次开启旋军事务的时候。

它一定是从第二步开始的。为什么由TM。发起全局事务找TC跟TC沟通OK所以现在我们清楚知道OK第二步这个位置是要发起全局请求的那第一步他说获取事物信息，那怎么获取的？主要是获取了一些什么叉 IDD啊。

包括事物的一些信息来去创建。如果你没有事务，我要去创建新的事务，你好，第二步能执行啊，对吧？所以这是第一步。那第二步它要执行的时候，就需要去真正的跟TC去发起请求，发起通讯发起连接。

那么它使用就是begin方法啊，一层层的走dede最后走n通讯完成对TC的请求。😊，当然这是整体流程。这是整体流程。那么具体它到连接到服务端以后，服务端所干了什么事，这个咱们后续分析。

但这节课我们就先分析到这儿，起码我们这节课把这个2RPC的核心源码，核心流程这个位置搞清楚了。😊，当然大家一定会问我说老师第三阶段这个什么全局回滚怎么回滚的？对安log怎么生成的对吧？

包括这个全局提交这个位置啊，这事可能好理解一些。主要是这儿啊，那这个的话我们就要去通过下节课去分析了啊，这个位置还涉及到一个点，就是大家先记住一句话，我们之前说过啊，讲差异模式的时候，我也提过。

包括讲AT可能我没提过啊，但讲差异的时候，我一定提过有这个数据源代理这么一个事儿。😊，其实你们要想一下AT模式，我们再搂一眼啊。AT模式我们之前说过它一阶段的时候。😊，我下来看啊。

它需要解析circle得到circle的这些数据，对吧？拿到对应的前镜像和后镜像。那其实你想它怎么去对应拿到前进像后镜像，说白了，它需要去把原有的这个连接对象变成一个代理对象。通过这个代理对象来完成的。

它对应的一阶段的一些操作。所以，针对于数据源代理这一块儿。

啊，我们要进行分析分析以后才能知道啊，这第三步它怎么进行的整个的一个安log表，这个事物补偿回滚，这表怎么出理，数据怎么来的等等这些。所以下这节课我们先把整体流程研究透。

然后下节课来研究一下这个事务这个事务代理去了啊，数据源代理这块。好吧，各位啊，OK那么这节课就先讲到这儿。各位那么自己可以去，如果你不信邪的话，你可以去按照我这个流程自己去debug一遍。好吧。

各位okK啊，但是我建议大家最好能够去通过静态阅读代码方式把它阅读透了，这个才是能力。好吧，各位啊，OK那么呃咱们这节课就先到这里了。各位啊，那么我们下节课继续。😊。

系列 6：P118：Seata源码分析-数据源代理 - 马士兵学堂 - BV1RY4y1Q7DL

O同志们啊，那咱们这节课来继续讲解西塔源码啊。那我们这节课要分析的实际上就是西塔源码的数据源代理相关内容啊。上节课的话，我们分析到了说这个staAT模式整个的2PC或者叫两阶段的这么个执行流程。

这节课的话我们要分析的就是AT模式中的另外一个关键点叫做授据权代理啊。首先咱们来回顾一下说AT模式的核心点在哪儿。AT模式有两个点，一个是说获取全局锁开启全局事务。另外一个点就是解析circle。

并且写入andlog啊，这个用于回滚的这么一个日志快照，对吧？OK。那么上节课分析的很清楚，整个2PC的阶段我们分析明白了。

它实际上就是通过这个global transitional scanner这个类型去继承一些啊抽象类，包括接口啊，实现一些接口来对应的一些方法来解决的问题。所以我们可以简单先回顾一下啊。

给大家找一下这个啊。先来看一下啊，我们都知道这个global transitional scanner，那它是一个啥？它是一个叫做全局事务扫描器啊，所有的事物都从这咋开始的。

它其实简单来说就是去扫描你对应并组件上面那个global transitional那个注件啊。然后呢你可以看这儿啊，它有几个比较关键的点啊，在这我给大家写了，包括笔记中给大家写了啊，看一下笔记本来。

有这么几个关键的啊，就是一个是继承了这么一个obstract auto to proxy creator这么一个出现类啊，这是AOP的对吧？

包括initializing病application contest of award和这个is呃。Ddispointable这个 bin啊，那么这么几个东西，实际上简单来理解吧啊。

这个位置其实特别简单啊，这个咱们先不说，先看这个application contest award这啥呀？

这实际上就是spring嘛。所以你通过这一点，你可以很清楚的知道，就是当spring启动完成以后啊，就是会自动去调用注应这个类型，对吧？那么会把这个obplication contest去交给这个病。

也就是说，当前global transitional scanner，它是天然就能拿到一个spring环境的。然后对应的这个initializing bin和这个d就就就这两个啊，其实也非常简单。

它其实就是一个销毁啊，一个是开启，一个是销毁。这是之前after。purse呃这个这个p啊s这个什么意思？它说白了就是去凡是继承或者叫实现这个接口的类型。在初始化并的时候。

那么当所有的pur都设置完成以后，它就会执行该方法。OK那么还有就是对应的有一个销毁方法，整个生命周期完成以后会有一个销毁方，销毁方法叫做destroy。那这个方法就是由当前的这个。

当前这个这叫叫dispointable bin这个类型来提供了。那这是什么呀？这不就是对应着你这spring的一个生命周期的一个感觉嘛，对吧？所以啊就是凡是去继承啊，凡是实现这个接口。

并且重写对应方法的。那么它就是说白了这个接口跟这个接口是个相反的关系啊，在销毁的时候会调用这个，这是在初始化时候会调用它，销毁的时候会调用它。所以这个比较好理解。这里可能唯一比较复杂的就是这个类型。啊。

obstract auto pro。那当然这个上节课我们也讲过了，那这个就是对应的一些整个的AOP的代理啊，做AOP增强的。啊，作AOP增强的。那么其实总结来说吧。

就这个global transitional啊scanner它就是去扫描你当前啊这个 bin类型上面是否有那个global transitional那个注解。如果有。

那么它就会做进行代理增强来做一系列的操作，完成整个RPC操作啊。整体流程的话在这儿。我上节课也给大家分析过了啊，在这儿。啊，就是我们这东西。从开始从哪去扫描的啊，自动装配扫描到以后，然后干了什么啊。

对吧？整个的从这儿开始说有业务发起请求以后啊，触发全局事务以后干了什么，全局事务的执行流程等等等等等等啊，这全部都分析过了，对吧？OK这块就不详细说了啊，那么其实我们这节课要分析的是数据源代理。

所以其实我们还需要去回到这个自动装配的这个位置。那么我还是去拿我之前这个案例来给大家举例子啊，把它关一关。我们正常来说的话，去找这个开头啊，分析源码开头的话哎。他会我们会从这找。去他找了找他引入的包。

然后呢对应找他一个自动装备类型，s boot的对吧？那在这可以看到有个叫做sit auto configuration。

那么我们之前所看到的对应的那个叫做global transactional scanner是在这儿的。对吧，那么这节课我们要看的是什么呢？

看的是这个叫做seta data source bin post proxy啊，在这儿他对授据员进行了一些代理啊，拿到授据员对象以后来做代理来做一系列的操作。所以关键点在这儿，我们要从这儿去看起。啊。

所以说白了你要知道，就是关于授据源代理这里啊，我们是在全局事务拦截成功之后，那么它最终是一定要执行它的业务方法的。而且我们sta是对数据源做代理了，所以sqcle的解析也好。

包括andellog入库这些操作全部是由授据源代理来完成的啊。那么这些授据权代理是在哪儿，又给大家找啊，咱们先去找这个对应类型。你可以先看一下，咱们进来啊，进来以后你可以发现啊，在这里面。啊。

有这么一个方法啊，包括在这儿有这么一些方法，你可以看看，先看先看这儿来先看这儿来。😊，先看这个类型啊，它首先继承了一个接啊，不是它叫继承啊，实现了一个接口叫做be post policycy。

这个接口相对相呃感觉大家或者说对于你们来说应该是很熟悉了。这是什么呀？从这图中啊，我在在这儿啊也给大家去列出来了，它是spring的拓展接口。相信大家对spring没有问题的话，这个都能知道啊。

那么所有的B对象再去进到这里以后都会去执行这两个方法。哪两个方法，一个是post啊after方法和一个before方法。那么这两个方法都是由这个接口所提供的。啊在这儿。我这。

对吧这两个方法很浅显很显而易知，就是在初始化的时候啊，首先会执行什么。啊，这个be啊在什么之前，然后执行after在什么之后，对吧？所以说我们从这开始分析，在它执行什么什么。

在在他这个初始化的时候之前啊，所做这个事儿，看after看be啊，befo这里面其实并没有做什么操作。啊，整个都在这儿啊。你看比这我没标什么，对吧？befo这里并没有做什么操作。

它只是说对当前的并组件啊类型做对比，看一下是不是这个代理对象，授权员代理对象，对吧？所以这儿其实并没有什么可看头的关键点在于哪在这儿。After房款。你在after方法中，你可以看这有个判断啊。

说bin当前并类 bin bin这个对象啊，我们所有的这个bin类象， bin对象进来以后都会走这两个方法。那么走到这儿的时候会判断说当前你这个 bin是不是data source也就是不是数据源。

如果是O好，看第二头，这不是一个与或飞的那个语吗？对吧？好，第二头这头是什么？这头就是说这个啊 bin判断是不是代理对象类型取法了。那说白了这里的判断是不是就指你当前的对象是不是一个数据源。

这是啥玩意儿啊啊，不用管它啊，是不是数据源，对吧？如果是数据源的话啊，如果是数据源的话，它是不是这个这个这个data source这个procy代理对象类型啊，如果不是好。

那么这个位置它调用了一个方法returnprocy data source什么bin把 bin传进去，这个方法做了什么？Did source policy。 Did source policy。

去调对应的方法，把你的这个data source传入。说白了，它最后返回的对象类型不就是一个数据源代理对象吗？那也就是拿到你的并这个这个数据源的并 bin类型啊，对它进行一个代理。

所以其实这里我们要分析的关键点就在于data source proy啊要分析它。O这些整个的流程我在这给在这儿啊给大家标注了。你可以看到说有拓展接口实现两个方法。在这个after方法这个位置。

当data source进入到这里以后，就会被直接代理成data source proxy。OK所以其实在这儿我们就要去分析这个东西了。那么分析谁呀？

分析的就是这个叫做data source proxy代理对象。啊，O那么这儿我们找到入口了。那么咱们现在就看源码。OK我再这给大家找一下啊。😊，data source Per，然后来盯了一下。

首先啊大家来先来看这儿啊。看这头。这个data source privacycy啊，它存在于这个包中，你会发现啊，嗯哎不对，我看一下啊，不不不对不对不对，点错了啊，找他找他啊，我点错了，sorry。

找的是。我这边找错了啊，sorry，再找一下啊，我说不对劲儿。不是这handler啊不是这handler，直接找这个啊dta source pro。可以。Data source Pro啊， O。

然后我们再定论一下，我们来看这里啊。你会发现这里不光是有这个数据源代理对象。还有什么connection property，还有什么？Statement policy。

Ppared statement policy。首先我们都知道data source是干啥，授权员connection是干什么？连接对吧？连接对象。

然后statement包括prepared statementment，他们都是circle语句的执行对象。那也就是说白了这些关于数据源代理连接对象执行 circle扣语句的这些组件。

他们全部都被sta进行了代理。那么，为什么要被sta进行代理，代理后的目的就是为了去执行你sta的对应的一些逻辑，就是AT模式里面这些逻辑生成andlog呀。

全局事务开启呀等等这些东西执行搜扣语句解析搜扣语句等等。这些全部在这里面去执行的。所以这个位置授权代理我们应该去从哪分析呢？就是从这个dta source privacycy开始，你是从这开始的。

而且笔记中啊我给大家去记录了一些内容。

🎼哎，不是他啊呃，这儿。啊，这点我都标出来了啊，然后你看啊数据源代理是个非常重要的环节。我们知道在分布式事务运行过程中。

安度log等记录、资源锁定等都是用户无感知的那这些操作实际上都在数据源代理中完成了。这刚才说过O所以数据源代理对象它这个位置dta它主要分成了三个功能。而且其中我非常关键的方法叫做in方法。

数始化方法啊，一会儿给大家去看咱们先看这三个功能是什么？它实际上是为为第一点为每个数据源标识着资源组ID就是数据源不同的数据源有不同的ID啊，都不不同的资源组ID啊，那么同时有一个配置。

如果这个配置打开的话，会对整个的定时现程池进行更新原数据，并且把信息缓存到本地。这个实际上就是去说白了你当前呃。比如说我们之前所做的个业务就订单和那个库存那个啊。

那么他需要去拿到你对应的一些呃表里面的数据嘛，对吧？库存表的数据，包括你订单表的数据，那么它在时时刻刻的应该没记错是一分钟一个一更新一分钟一更新，却拿到你准确的这个数据信息，缓存到本地。

为什么要缓存过来呢？是因为缓存的操作要快，对吧？OK啊，然后最后一点就是生成代理连接对象，就是connection propertycy。所以这个位置我们就先来去分析它的初始化方法，阴力的方法。O啊。

那这儿就不看了，我们直接看代码。

以内的方法实际上是在它构造方法这个位置，调用完构造方法以后，那么它这个位置会传入。你看啊。资源组ID完了是对应的一个data source，对吧？OK然后在这儿调动引匿方法。O所以咱们来看这个引匿方法。

它的前两点它的前两点其实比较好理解啊，就是一个是资源组ID当前这个ID覆盖ID只是这比较比较简单啊。然后呃通过原始的这种数据源得到GDBC连接和数据库类型。

你看GDBCUL对的DDB type数据源数据源类型，对吧？这都不用说，然后主要是我们看这个类型。啊，如果配置打开，会在定时啊会定时。呃。啊，你该少写个字啊，会在。

会定时在数这个线程池不断的更新表的原数据信息啊缓存到本地。什么意思啊？这个位置其实这么去看不太好理解，但咱们先理解大面啊，我先跟大家说意思。这个意思其实就是说白了你在业务开启的时候。

你在有业务发生的时候，有这种数据这种分布式事务出现以后，它会把对应相关的表的数据缓存到本地。为什么要缓存到本地呢？其原因就是在于缓存到本地以后，它的速度快，因为它在缓存中，它可以去节省一些查。

因为你数据库查询这个时间是比较长的。如果你每一次都查询的话，会浪费时间。啊，会时间变长，所以它每次都缓存到本地，你从本地缓存拿数据去比你查肯定要快，对吧？所以就这个意思啊。

其实所以所以所以说白了这个阴利的方法中只做了这三点增强啊，只做了这三点增强。所以这就比较好理解了。OK那么这里说完之后啊，我们再往下看。他第一件事情是有引it。那么刚才说过的。

还有一点就是说去创建一个连接代理对象。那么这个所谓的连接代理对象在哪儿啊？你们可以注意看一下一个东西，就是它继承了一个。Obstract， data source property。数据源连接对象啊。

数据员这个呃抽象的这么一个数据源代理对象，对吧？在这其中啊有很多很多方法啊，这个咱们先不关注啊，其中我们要关注的点在哪儿啊？有一个方法。嗯。给大家找找啊。哪儿去了？啊，这儿。概率可能是。

这什么连接获取数据源连接，对吧？获取数据连接，那包括这有很多啊，你看这也是一个，这是一个无参数，一个是有参数，应该。啊，对，是你看。gege connection get connection。

这是那个有那个用户名和密码的那个啊。所以说白了这个位置，它的第二件事情就是对整个的这个连接对象做了一个代理。因为你可以看到它最后return new connection proxy。

这也是一个连接对象的授据权代理，对吧？证明哪儿，它用哪儿啊？用的是这个。啊，所以说过了C塔最开始我说过了，它整个就是全部都是用的这个授权代理。那么你的授权对象被代理以后。

那么建立的连接也是通过啊连接对象来完这个这个代理对象来完成的OK所以到这儿我们再来看。这两点我分析明白了，对吧？一个是说这个整个的数据源加ID，然后去打开配置定时更新，然后生成连接对象。

通过的是get connection这个方法来返回的get connection啊，connection pro方法。啊，pocy不是方法是一个代理啊这个。这个连接代理。OK所以现在这儿没什么可分析了。

我们主要看这个连接对连接代替对象又干什么了？走往下走啊。这就是那个connection啊，pro proxy继承了一个obstractconnection pro，又是个出生类。

啊，实际上在这个里面啊，我先跟大家说一下，看笔记。啊，在这我还提一嘴啊，就是在这个增增强里面啊，这三个其实就这前两个比较容易。第三个是最重要的AT模式里面会自动记录andlog和资源锁定等等。

其实都是通过这个connection policycy完成的。所以其实我们主要去分析的话，就是这个connection policycy分析啊那么你们可以看一下啊，connection policy。

它继承了一个叫做obstract connection policycy。那么一般看到obstract，我们都知道它的工作是啊副类封装了很多通用的工作。

而且它的副类里面还使用了prepared statement policycy和state policy，包括还有dta source policycy啊，这一点的话我们这有一个类图，大家可以看一眼啊。

放大一下。obtract开始。首先它啊这个实现这个里面，然后包括引用了对应的三个类型。啊，那么现在我们主要分析的话，就不能去分析当前它了，看的应该是这个负类，因为这里封装了一些痛方法。

所以我们先来搂一眼它。

啊，来看。那么这里大家可以看一下啊，我为什么说啊有这几个东西呢？你看data source是不是用了，对吧？然后还有啊往下来看，说白了这个步骤，你们可以简单这么理解啊。

就是我们再去用普通的这种数据源的时候去操作srcle语句的时候啊，我们都知道有数据源连接对象啊，数据源代理数据源对象，然后有连接对象，有具体执行circle语句的对象。

就是statement preparedpared statement，对吧？所以这里我们可以看到数据源有了，连接对象也有了，对吧？

然后现在我们要看的是它连接对象所定义的一些针对数据库circle语句操作的对应类型，可以看到这有一个statementcreate statement创建这个执行circle语句的这么一个对象。

包括有防sql注入的一个prepared statement，这里都有。啊，那你们可以看到这两个方法中。比较关键的点在于哪儿呢？statement和prepared statement，不管他俩是谁。

用的是哪一个，他最终都会去返回一个prepared statement privacycy和statement policycy，都是数据源代理啊，不是都是这个执行对象代理啊。

执行sqcle有据对象代理。他并不是用了原生的原生的statement和prepared statement。所以这个位置我们要往下分析的话，分析应该是这儿。

对吧你看我在这给大家标水了。啊。呃，所以这里我们就要关注的是prepared statement proxy和这个statement proxy。其实这里通用逻辑啊，就是数据源连接步骤，获取连接。

然后执行对象等等，这些明白了吧？啊，就是这样，这就是步骤是一样的，只不过每一个步骤seta它都做了代理。啊，然后啊我们可以分析一下这两个方法，先看一下这两个方法啊。在这两个方法中。

首先state没什么好说的，它就是获取连接对象，然后最后返回的是一个代理对象。然后呢，这个里面可以看一下啊，它实际上就是上来先获取数据库类型。比如说你是mycicle或者是orracle，然后呢。😊。

有一个模式的判断。如果当前你是AT模式啊，那么就开启全局事务，当然默认走就是AT模式啊，然后会进入到if分支。那if分支这里其实就不用多说了，就是得到原数据，然后获取表的一些主件名。

然后通过它对应的一个这个prepared statement这个方法，传srcle语句和对应的一些参数就完了啊，这都是技术操作了，不多说啊。然后最终关键点在行这在这啊。

它会去创建prepared statement pro代理啊，所以可以现在发现，不管是这个prepared statement还是state，它都是通过代理对象来执行。那我们就来看一下这个代理对象。

它里面的一些具体执行方法。啊，在这其中，其实你会发现有三个比较关键的方法，就这就这仨。看到了吗？result set公共部体啊，这有一个呃exator query。

ex呃exex啊ex啊exe updatedate，还有一个exec方法。这个三个方法实际上就是具体执行circle语句的三个方法。你可以可以看到啊，这里拿就是。

srcle语句拿完ciqcle语句以后呢，它通过这个叫做execetlate点ex方法，都是这个方法看到吗？都是这个类型对应这个方法。而这个exece templatelate它是啥？

它实际上你可以理解为是一个这种不同类型的一个处理器。啊，它来执行不同的这种scle语句啊，通过不同的代理。那么这个咱们一会儿分析啊，先不说它。主要是你来看一下这个。

这当前是statement prepared这个代理对象关键点在于这方法。那么其实你可以看到，不光是它啊这两个执行逻辑差不多。你看这个prepared statement policy。

它的非常关键的方法也是这三个，看到了吗？嗯。excuse啊excuse query和exece update也是这三个方法。同时你会发现这里他们所使用的都是这个excuse template。

通过他来完成的来调用的对应的excuse方法来完成一些操作的。所以这个位置各位啊现在应该知道关键点在于哪儿了，对吧？OK所以啊各位回到笔记中。这里我都给大家分析清楚了。

这个数学连接对象啊有对应的一个obstract。那么实际上它实现的接口啊，我可以告我可以告诉大家啊，它所实现的。呃。这个啊。它所实现的接口就是connection连系对象，对吧？

所以它这里面实际上就是设计了一些通用方法。只不过说你在最后执行circle语句的时候，你是选择这个statement还是prepared statementment并且都是代理对象执行啊。

然后啊然后往下重写对应方法返回代理对象，然后执行ciircle语句通过了就是这三个方法来执行。说过了。然后实际上是不同的circle语句类型来执行啊，不同的circle语句类型的执行模板，就是谁。

就这门儿。为什么说它呢？你可以看这底下啊。插入的修改的删除的这是我直接说过的开启全开启全局锁那块啊，select of update，对吧？O那这些我们一会儿来分析。

现在我们分析到就是找到了这个数据源代理对象，整个的入口和找到了一些关键的代理对象。那么还有一些什么生andlog这些东西怎么这些东西怎么来呢？这些东西我们留到下节个分析，我们先把这个整体的大流程。

先分析出来。好吧，各位okK啊，那么这节课我们就先到这里。

系列 6：P119：Seata源码分析-数据源代理-undoLog生成 - 马士兵学堂 - BV1RY4y1Q7DL

好了，同学们啊，我们这节课来接着去分析这个sta的数据源代理相关内容啊。那这节课的话我们就要去找一找它当前对应的，比如说你数据源代理它怎么去生成的这些andlog相关内容啊，OK那么先来看一下吧啊。

那么在这儿啊，我们上节课去分析到了一个类型叫做obstract connection pro啊，这个副类的这么一个抽象负类的一个代理。在这其中啊，它有对应的创建了create statement。

包括prepared statement。那么它最终这两个创建的类型都是一个代理类型。你看这。啊，是prepared statementment prox，包括这个statement proy。对吧？

OK我们可以看上节课这个图啊。在这儿，首先obstract重写这两个方法。重写的实际上是这个接口所对应的这两个方法，然后返回的是一个代理对象。那么在这两个代理对象中就对应执行ciircle语句的方法啊。

这也是人生方法。我们可以看一眼啊来。

就是咱们就拿statement prepared啊，这个pro啊，说错了。来举例子，你看这其中啊。😊，是不有对应的，你看。Qury， update， execute。

对吧那其实这就是我们主要要去看的对应方法。对吧它的对应所有的执行其实都是这样的。你不光是state proy啊，你包括prepared statement proy，它的执行方法也是这三个。

这是最关键的。对吧。ok好，那么不管是prepared还是这个statement啊，我们比如说就拿state来举例子。

你看这里面它这儿啊最终所执行的是一个叫做exece templatelate点上exece方法。啊，是通过这个time美的模板去调的这个execcuse的方法。所以这是核心关键。我们就需要去看一下这个。

exclude的方法，他具体做什么了？可以先看图。啊。在这儿我给大家去标出来了，其实这个叫做excutor template这个模板，它是根据你不同的circle语句的类型来生成不同的执行模板有哪些呢？

在这儿你像有update，有insert，有delete，包括还有这个slate for update，就是加锁的对吧？包括有个叫做ploing呃呃excutor啊，它是执行普通的查询cicle语句。

这是原生的啊，包括还有一个复合的。那这里实际上我们比较关注就是这三个update insert和deelete。所以这儿啊各位你们要记住，还有一点就是实际上这个位置它应用了一个模式叫做模板模式。

就是这是它具体生成的执行器，根据不同sical语句类型。那么这些。不同的这种执行的一个呃类型来说的话，它们有个共同的flay，就这个abstract电脉而baseex，这是这个模板模式啊。

这上节课没提过的，从这开始是新东西，对吧？O所以现在我们就可以看一眼啊，首先我们先进到这个exex方法中，那return execute走O。

首先核心方法就在这儿。那么这个方法上来，首先会判断说当前有没有全居锁，而且是不是AT模式，这个不用多解释啊。再往下来说，得到数据库类型，当前一定是myciql类型。然后注意看这个。啊。

这个circle这个类型啊，我跟大家说一下，你可以把它姑且理解为circle的语句解析器。那么它可以执行这个这个获得执行circle。

通过它呀还可以去获得对应的一些circle语句的表明相关的列名以及类型等信息，最后解析出对应的circle表达式。相信大家都知道，我们在讲这个AT模式的时候说过它对应的这个。什么呢？

它对应的这种呃circle语句，在这个二阶段提交中，它是需要解析的。那么怎么解析的？就在这儿解析的。啊，然后往下可以具体来看在这儿啊，比较关键的在哪儿。如果说这个位置啊。

你看它没有找到对应合适的sQ语句解析器，那么它就会执行这个对应这个解析器。那这个解析器实际上就是直接通过原声对象来执行。所以这个不用我们多看，主要是看Ios里面来看这。😊，啊。

它有一个switch这么一个东西，它去判断你当前srcle的类型。如果你当前是增删改查任何一项，包括这种加锁查询等等啊，包括普通查询等等啊。那么只要任何一项，它就会对应去生成一个执行器啊。

可以看到这有个insert啊excuser查询，这是这这个inser插入的啊，还有update的还有delete的，还有这个加锁的，包括这种普通的默认的啊，默认就是普通的这种原声的执行。

ok包括最后他可以去处理多条语句啊，就是多语句cicle的。那么各位我问刚才为什么说它是模板模式呢？其实啊比如说我们可以看一下，你就看任何一个，比如说update这个。你看啊他这个位置它的副类是谁？

obbstract DML basease Exor。啊，OK然后你再来看啊，还有什么？😊，delete，你看他是不是继承的负累，依旧是这个。啊，包括。这个音色是这。啊。

他首先这个位置还有一个被s继承啊，你看他来。是不是还是他？所以这个位置各位啊要知道，就是这些所有的我们关注的是这三个insert deleteele啊，这个upate这三个这三个对应的执行器。

它们的这种副类型啊，不光是他们仨就是所有的执行器所对应的副类型都是那个obstract那个，也就从图中可以看到看这个。

嗯，哪去了啊，这个obstract dML baseaseex，它就是这个最大的模板。那有了这个模板，我们就很清楚的知道。也就是说当前我这些对应执行器里面所执行的语句。

那么有一些共同的方法都在这个模板类型中OK那我们就可以往下继续来看啊，当然我说的这些啊，在我的笔记中都有体现在哪儿呢？给大家搂一眼啊，或者头你们复习好复习啊，就在这。看到吗？啊，那这不多说了。

然后在这儿啊给大家看一眼笔记中，我给大家去找的一个关系图，就是当前我们整个的这块一个类型的关系图。你可以看到啊statement这是最大上面，包括还有个excutor。

那么你这个位置你可以看到呃delete。😊。

update是不是都从哪来的？base insert啊base呃这个这个inexer是不是也从这来的对吧？OK然后这个obtract呢，还有一个上级。

就是这个base transitional啊exer。😊。

所以各位啊要知道这个关系，那么现在我们就可以往下继续来观看这个代码啊。它最终执行是在哪儿？是在这儿。那也就是说白了，当前这个excuter点上excut方法，这个方法就是你具体选择。比如说是个插入。

比如说insertok咱拿它举例子，当前你语句类型为insert，那么找的就是一个insertex。那么就是通过这个具体的插入执行器来调它的excut方法。好。

那么现在我们来找一下这个位置调的就是负极绑法。当然啊它这个位置调的是最大的一个负极base这个啊，走看一眼。在这其中他做了什么事呢？往下来看啊，在这个位置，excuscuter进来以后。

你看首先他去拿到对应的叉RD，这是个全局ID对吧？O然后获取叉RD这个位置statement proxy我们现在不用它执行吧，对吧？好state proxy等点上get connectionxy啊。

点上ban去绑定当前的这个叉ID也就是说把这个全局事务ID给它绑上。😊，然后再来去设置全局锁，那么就证明你当前的这个全局事务加上了。对吧这是个标识嘛？对吧？OK好，那么全局事务这些关键的东西加好以后。

这个位置有个叫做doex方法。这个方法就是我们比较关键一个方法啊，可以往下续续看。但在但在这之前啊，我跟大家去说一个事儿。😊，哦大家一定会发现一个问题，就是如果你看过spring源码啊。

你会发现什么excusor啊，doex。包括后续我们可能看到comit，有do commitit这个方式跟spring非常像。所以啊我建议大家如果说你之前没有看过源码。

你最好是把spring的源码看一遍，把它理解透了以后，你再看这些源码的话，其实大同小异。😊，好吧，OK啊。

那么可能说它的意思一般都代表说你这个excuser是一些啊具体操作前的设置到do这个位置是具体执行。这个do这个位置具体执行找的是谁呢？你可以看它是个抽象方法。那么当前这是个最大的负类。

这个抽象方法是由谁来实现呢？就是刚才我所说的一个模板obtract baseO找的就是它所以来看在这儿就是我们那个具体的执行方法。😊，看到了吗？嗯，然后在这个位置，各位啊注意看啊。😊。

我先给大家看图啊，到哪一步，我先跟大家说啊，到图中的哪一步啊。你看首先绑这个这个excusor绑定ID设计权设置选局锁啊，就是此方法是用来判断当前要执行的circle语句，那么执行哪个具体的执行器啊。

然后子类重写，这个子类重写就是我们的abstract。

啊，然后这儿我要问大家一个问题。😡。

这是关键了啊，注意看。你们要知道当前我们这种啊数据库就是mysqcle，它是自动提交呃，就事物是自动提交，或者说我们写语句的时候是自动提交还是手动提交。这一点相信大家应该都知道。

我们买sqcle举个例来说，我们在写一条查询语句，或者写一条insert或update语句的时候，是不需要在我们啊就是我们写完，比如说写一个select语句哎呀。啊，没开放大镜，稍等啊。

比如说我们写一个st语句以后啊，SELECT啊，星号我随便写啊，写这么条语句以后，我们是不是不需要在这个语句后面写个commit？这应该都知道吧，这是比较基础东西。我们是不需要自己写的commit。

我只要回车，我就能看见我查询结果。比如说音色上就能看到我插入的结果。😊，对吧所以说白了从这儿我们应该就很清楚的知道，这也是比较基础内容，就是mycyclqcle这个位置它都是自动提交的。

所以你可以看当前这个具体执行的方法，在这是不是有个returnex auto tocommit true和commit force把参数传进来。那你想我们当前是自动提交。

那是不是应该走的就是这个commit true。O所以在这儿我们进到这里方法。😊，好，就到这儿了。那我们可以看一眼到哪儿了，现在现在走到的是这儿自动提交这。

对吧走到自动提交这了。OK那么现在我们就可以观察在这个自动提交的这个位置，它具体做了哪些内容啊，我们仔细来看啊。

首先在这儿啊在这之前我要先说清楚各位你们要知道我们这2PC阶段是在第一阶段与这个数据库交不是呸与这个TC交互以后，那么他再去提交的时候，最开始最开始这个事务是没有直接提交的。😊。

所以他需要做一些相关在提交前的一些准备。比如说啊啊记录信息，这些乱七八糟的东西。那包括在第一阶段的时候，你本身在提交以后，你需要去得到一个具体执行结果，你去把这个结果去告诉这个TC。

然后由TC来通知你你是具体的一个执行还是回滚，对提交还是回滚，对吧？所以当前这个位置，你要知道在这儿它并没有真正的去做执行啊，去做这个这个提交，为什么这么说呢？你看上来第一句话。

connection privacycy点上称着all to commit。我们可以看一下这个称职all to commit是干什么的。这个不用管它，你就看这儿来。

这个set auto to commit，你看它传了个false，我相信大家应该都知道这个set auto to commit什么意思。我们可以看一眼来看这儿啊。

这是原生的connection原生的给的一个方法。这个方法说白了意思不就是是否开启自动提交嘛，对吧？如果你这个位置传的是个false，那你回过来看这儿啊。哎，回哪去啊，回到这儿啊。

你看它这个位置传过来的值为 false，那是不是就证明说白了把当前的自动提交模式改为了手动提交模式。为什么这么改呢？是因为这个位置我们先不让它真正的去完成提交。对吧OK那么改完真正的提交模式啊。

不是改完手动提交模式以后，再往下来看，看这儿关键点在这儿啊，调用手动提交方法得到分支的业务最终结果。你看这方法是什么？excut or to呃 commitit force那这个方法的话。

你看它干了什么？😊，也就是说，在你真正去提交前，他做了一些事情。首先你看。before image是不是快照的意思啊？这个快照就是我们那个前镜像。就是执行sql语句之前的前镜像啊。

就是那个and log中所记录的那个前进像用于回滚的。那么还有一个after image，这是后镜像。

而这句话result等于什么s呃这个这个statement call back点上这个这个这个呃iterator这个位置我可以跟大家说啊，它就是来具体执行业务了啊，这个位置就就是具体执行业务了哎。😊。

具体执行业务了，这就不用多说了吧啊，局行执行我们具体的业务不是业余啊，业务打错了ok。😡，然后还有就是这有一句话就是。呃，prepared un do log看到了吗？

然后把befo image和after image传过去，可以看一下它是什么啊。他这个位置这个ppere。他实际上是把它存到了。你看be啊，我看一下不是空啊，这里判断它实际上是把这存下来的。啊。

先不看这吧，这个回头咱们后面看，后面看不着急，不到这儿啊，你就记住它这个位置实际上就是暂存and卓log是不在commit的时候再去提到数据库。它把目前的这个数据先保存下来。

前镜像和后镜像我先给你保存下来，暂存。😊，好吧，OK啊，那咱们接着说，那现在我们就找到关键点了。哎，什么关键点？首先在这这个位置的时候，我先把它改为手动提交，然后调的是一个什么。😊，手动交方式。

把前镜像和后镜像要搞出来啊，但是这个语句最终还没有真正提交呢，真正提交在哪儿是在这儿的。connection policy点 commitit，这是真正提交。

对吧OK啊，所以说这儿我们可以看图总结一下。在这个图中我给大家画出来了。在这儿上来，比如说我们这儿首先啊你看啊这个这个这个到这儿嘟是吧，自动提交这儿，然后呢把当前的自动提交改为手动提交模式。

然后这个位置他做了一些事情。

就刚才咱们看的这儿啊。手动交方法，这儿首先生成了前镜像。然后具体执行具啊执行具体业务，然后生成后镜象。然后暂时储存镜像，为了后续真正写入数据库，就是把你的安度log中的一些前镜像后镜像。

就两个快照去写入到你的那个数据库中。所以这个最终目的是为了得到执行结果。啊，得到一个执行结果。就是说你C口业务执行完以后，你就是你那个本地的那个分支事务的一个执行结果。

OK那么现在把这个执行结果完完事以后再回到这儿，我们往下来接着看。😊，再往下看到就是这个connection policy点commit。

这个connection policycy点 commitit搁哪搁这呢？这才是那个真正的去执行提交。啊，这才是那个真正的去执行提交。我们可以再往下来看啊，直接进到这个commit方法中。

现在前镜向后镜向是不找着的对吧？好啊，没关系，一会儿我会找他具体怎么写，咱们先往下看commit走。😊，然后你来看这儿啊，进入到这个commit方法中，在这儿还有一个docommit。

那这个就是跟spring源码的那个方式就非常类似了。😊，啊，如果你阅读过的话，你应该很清楚就知道。所以很明显就直接往这里进，do commitit看他干什么了。OK来看这。进入到这个读卡密的方法中。

首先它判断你是否存在全局事务。你看in globalbal transactional，它这个就是在这儿啊，就是说白了判断有没有叉ID啊。如果你叉ID不为空，就全局事务，对吧？

okK那很明显我们现在有走的就是这。procyglobal transitionals这个这个这个commit再往里进走。好，然后进入到这个方法啊，我们先来通过这看一眼。进入到的是这儿。是这个方法。

对吧？OK这个方法它实际上干了三个事儿。😊，第一个事儿，注册分支事物，生成分支ID。啊，说白了这个位置就是真正去注册分支事物了，去生成一些分支ID。然后第二点还做了一件事。

就是说去真正的写入这个andlog。然后最后才是执行提交，也就是告诉结果去把这个数据真正提交起来。啊，ok所以咱们可以先看一搁哪儿啊。第一件事情在这儿呢，rejectctor。😊，走，你看他干什么了。

log这个啊。b这个ID它代表的就是分支 IDD。然后它通过这个det result manager点get点bsh reject。

这个方法就是注册分支ID注册哪些模式相关的这个代理以及这种呃资源ID等等一系列的相关内容。他把当前的这个分支ID给它注册进去了。OK这是注册方法。好，再回来。😊，往下有一个写入数据库。

写什么把and do log真正的去写进去。你可以看这啊。核心方法在这儿。face andlo。啊，然后最后你看这执行原生提交，这不就是那个一阶段提交嘛？对吧？你看这儿。

target这个这connection是谁？就是原生的connection。然后呢，在这调了一个方法，叫commit。这commit是谁？原生的commit提交方法是不是在这是真正的提交啊，对吗？

OK那么现在我们要关注的是数据源这块，那么数据源它最后要写入那个andlog前镜像后镜像。所以在这儿我们要关注的就是这个。😊，flash方法flash and logs走往里看看这个方法干什么了啊。

当然这个位置是一个接口，它有实现类，那么对应的实现类就找到它在这flash and log，我们可以通过这看一眼来。在这儿啊flash andlog，然后再往下来找找哪个方法啊？首先咱们可以先看一眼。

在这个方法中，你看首先。干啥了都。上来str叉 IDD啊，connection contactt获取叉ID分支ID等等相关的一些信息。看到了吗？相关的一些信息。

and logs什么什么什么什么什么andlog怎么怎么着的，是不是拿到相关信息啊？😊，然后这些啊拿到以后，真正写入数据库的位置，在这儿有一个insert up啊。

这个这个under log维斯啊这个方法。有没有方法？那你可以看啊超作参数什么叉ID啊，blashID啊等等等这些东西。那你可以看一这方法里面怎么写的。啊，当然你可以看到这是个抽象方法。

它也需要我具体的实现类。那你来看这仨实现类都是啥？😊。

my circle oracle，还有这个。不同的对应的你的这个数据源，你是买circle的类型的数据库，还是oracle的还是什么的啊，当然这个位置很明显，我们目前用的就是mycircle。

所以直接去找mycicle andlog manager就行了。

然后你再看这个insert的方法，其中调用了一个叫做insert and do look方法。走，你来看这是干啥了？这是不是就是最终去写入相关的那个叉D不是那个安 do log。那个那个写入方法。

就真正去往数据库里写的那个号啊。对吗？所以在这个位置时候，就把相关的所有的这个and dolog中的表中的数据。写入进来了。对吧这个这个这个很熟吧，这个不能说不认识了。😡，对吧？OK好，所以分析到这里。

我们就很清楚的知道这个数据源是咋回事了。这个数据最终是怎么写去的。okK我们就全分析清楚了，可以看图再总结一下啊。来这个数据源这个位置。😊。

我们最开始是从这过来的，然后呢绑定元素以后嘟这个啊，不是绑定元素，绑定叉ID以后。进来子类重选，然后自动提交自动提交这个位置改为手动提交。就说白了先不让它提交，然后把对应的这个调用手动提交方法。

首先生成前进项去执行具体业务，生成后镜像。那么这个时候生成前进项是为了保留这个之前的数据。😊，执行这个具体业务就是执行你当前分支事务那个具体业务生成后镜像，就是是更改之后的数据。

然后暂时去储存这个镜像啊，去为了后续真正去写入到你的数据库里面去。所以这个位置再往下来走，真正的一个提交执行，找到do commit写入原生啊，写入这个andlog，然后并且执行原生的提交。

首先注册分支，然后通过对应的这个方法，这个face方法来写入写入完以后，真正的去执行commit提交。啊，这个时候comit提交以后，就会有对应的结果去告诉服务端成功还是失败，对吧？

然后这个位置往下怎么写入呢？走的是flash这个flash这个方法执行具体circle。我给大家看的是通过买cil实现的那块。对吧？OK这就是我们数据源啊sta数据源源码的整个的分析啊，那就分析到这里。

好吧，各位OK那么各位这张图回头会发给大家啊，我现在就把它分发给大家。😊。

分享。OK那么都在我这个笔记中的最后。

啊，都在这个笔记中的，最后我这样给大家去写一下啊。再是咱们这个风云笔记啊，在最后给大家说写一个就是这个呃原。很漂亮。原理图。行了，原理图。地址。O在这好吧，你们直接去打开这个链接。

就能看到我给大家去画一张图，通过那个自己再捋一捋就可以了。好吧，各位okK啊，那咱们这节课啊sta的这个数据源代理我们就讲到这儿。😊。

系列 6：P12：GPM模型 - 马士兵学堂 - BV1RY4y1Q7DL

大家不要管这个专业名词。

你听我讲就行了，呃作为我们go语言来讲。

你在这里起的任何一个的go routine。

go routine，go routine，go routine一堆。

你可以写了一堆，这个东西呢叫做一个一个的g。

就是一个一个的购入outine，这个g的意思就是go入outine，那么p是什么意思呢，p叫processor，processor的意思，简单理解为啥很简单，理解为一个一个的队列好了。

这就是一个一个的队列。

ok。

这个叫一个p，那什么叫m呢，m就可以具体理解为一个真正的底层的线程。

这是我们操作系统级别的线程。

作为go语言里面，你要启动一个一个的go routine的时候。

相当于什么呢，相当于往队列里面扔了一个任务。

扔了一个task，那么这个任务具体由谁来执行呢，具体的执行人是我们操作系统级别的，内核级别的这种线程，ok这是内核级别线程，同学们你们看一下，来看一下这个模型，看能不能看懂，我再给大家说一遍。

比如说我刚才的那句话，go f就相当于我起了一个f这样一个任务，然后呢可能还有其他任务，比如说f1 f2 f3 f4 m5 啊，n等等，每一个任务都是一个方法，我只要前面加一个go字的话。

就不是方法调用，而是我直接把这个任务扔在了一个队列里，再说一遍，那这些队列由谁来执行的，是由底层的一些线程来取，这些任务里头，任务队列里头去找好多线程去找诶，这个里面空着的，我去执行它。

这个我去执行另外一个这个给阻塞了，怎么办，他就等他正在等待网络的写回的数据，我现在没有执行了怎么办，我跳到其他里面去执行，我找到另外一个去执行，能执行的，我马上执行，那么这两个之间要需要交通信怎么办。

go语言里面叫channel对吧，那是go语言的那两个携程之间，两个go入t之间的通信模型，ok同学们好好看一下这个模型。

不知道大家看上去眼熟不眼熟，不知道能不能大家听得懂，大概大家能get到go语言这个模型吗，能get到的话，给老师扣个一来，如果你学过java线程池，我相信这个模型对你来说很简单。

java的线程池是什么意思。

同学们，你们想想看，作为java线程池来说，他是不是首先得启动一堆的核心线程，有一个线程的最大值，线程数量的最大值，然后呢他自己有一个阻塞队列。

对不对，阻塞队列，接下来队列里面，你是不是可以往里头扔各种各样的test呀，那这个test是什么样的呀，不就是一个一个rable吗，或者是一个一个colorable吗，其实本质上和这个有区别吗，没区别。

go语言先进就先进。

在他把这些东西全给你封装了，他不像java语言，你要做这个模型，必须得起线程池，然后自己往里扔任务，任务和任务之间的同步需要你自己做，go把这个模型封装的超级简单，一个关键字go就可以了好了。

这就是go语言比java语言所谓牛逼之处就牛在这，m表示具体的限制好吧。

m它就是它专业名词叫machine。

实际上就是线程线程池里面那个线程的意思，所以go on就是自带线程池。

没错你说的太对了，eddy以后这个课你来讲。

所以go on的意思其实你只要把牛逼就牛逼在这，这是他最牛逼的一点，就是它简单，并不是说他它效率到底有多高，运行的效率到底有多高，no它简单，你懂吗，非常的简单，test里放线程吧，不对。

test里放的是任务的歌，java为啥不封装，因为它古老，每一个新诞生的语言。

总是在原来语言的基础之上要做一点新东西，不然你怎么超过原语言啊。

既然讲到这了，我就多说两句，go语言以后会取代java，不会go会抢谁的市场，说到这多说两句啊，go语言会抢谁的市场，会抢c加加的市场，会抢java的部分市场，会抢菲律宾的市场，好多pp都转了够了。

为什么呢，简单但是请大家注意简单这个事情，如果一个事情特别简单，他要想多赚钱，他就在别的地方得增强，所以go语言呢他主要是做的做什么呢，做中间件，原来占位语言开发的中间件也非常多。

现在go语言开发的中间件越来越多，所以将来我预测应该是什么呢，构造中间件，java做业务逻辑，这是两个黄金组合，站在牛逼架构师的角度，不要跟我那区分语言，牛逼掉狗是什么，都要选大人，大人从不做选择。

我们都要小孩才做选择，牛壁架构师，这个地方该用水泥柱子，用水泥柱子，该用玻璃柱子，用玻璃柱子，所以这个地方该用java语言，用java，该用够用够，该用python，用python，该用julia。

用julia，该用rust。

用rust k，好这是我们底层的一个线程模型，当我说到这里之后，同学们，我来呃，不知道有多少同学能够理解，这个线程在本质上到底是个什么东西的啊。

系列 6：P120：Seata源码分析- Seata服务端（TC）源码解读 - 马士兵学堂 - BV1RY4y1Q7DL

hello，同志们啊，我们这节课来继续讲解这个西塔的源码啊，稍等一下，我把这调一调OK啊。呃，这节课的话给大家去讲一讲我们这个sta的服务端，也就是TC相关的一个源码的一个阅读啊。呃。

因为这段时间各位我们一直在讲它客户端相关内容啊，包括我们从最开始的这个稍微缩小一点啊，从最开始的哪儿呢？这个它对应的一个自动装配。

找到这个全局扫描的注解，然后。包括这个什么obstract auto pro，然后它的一个重写的一个方法，然后再去程序启动的时候，呃，事物发起时所调用的一个in work方法啊。

然后到解析注解以及对应的处理。到我们找到这个啊这个exccuse方法，最终执行我们这个整个核心的几个步骤，全局事物的几个步骤，包括获取这种事务信息，然后它的一些操作，包括执行全局事务和它的一些操作。

对吧？啊，去什么发起于TMTC发起请求等等这些，然后呢，包括这个呃。这个这个commit整个整体的这个全局回滚或提交，对吧？然后呢啊全局回滚啊，然后到最后的提交以及清除资源。

这个位置是我们之前所看到的整个非常核心的一块内容。什么内容呢？就是我们的呃。全局事务提交整个流程。那么之前我在这讲过说在第四步commit的时候，它需要跟sta server端进行一个调用。

那么调用以后呢，我们需要去找到sta server端相关的一些内容。啊，就是说呃这节课我们要分析的就是去开启这个全局事务提交以后，如在sta server端它是如何进行调用的，还干了什么事儿？啊。

这是我们这一课主要分析内容。好吧好，那么废话不多说，我们就来实际分析啊。当然我们可以先找一下哪个类型啊，先找一下这个我们先看一下来。找这个handler这个啊我们来到源码这儿啊。搜索一下okK好啊。

然后我们来看一下之前我给大家去讲过这个过程，什么in work从这开始对吧？O然后呢，到它整个执行全局事务，从这开始，handler transactional，然后进来啊，然后它具体的步骤。

我来看一下啊呃。合理去聊。超时时间。然后。这是最开始的构建信息执行异常。哎，不是。哪儿去了？我来看一下啊。啊啊在这儿在这儿看错了ok啊，在这啊handlergbal transal啊。

从这找找这个excuter方法啊，从这进去OK然后呢，我们可以看到它整体的执行流程，第一步去获取事物信息，然后这是第一步相关的操作，对吧？这个我们都讲过了啊，然后到哪第二步呢，到的是。1。

3第二这个位置开始执行全局事务。然后第三步发生异常，全局回滚，对吧？然后进行安多loggo的补偿啊，包括最后的这个第四步提交资源啊，全局提交啊，然后以及最后的清除资源啊。

当然这个位置我们其实实际是从这儿可以去看到，从这儿开始提交全局事务去调用我的服务端。

那么服务端的话，各位从图上来看，怎么去找啊？实际上他这服务端是这样的。

呃，我们这个服务端是我们在这个我们自己电脑上配置的那个sta serverber端，对吧？这个应该都知道，我们之前装过啊，带大家去呃应用的时候，带大家去讲过seta serverber端。

那么这个staso端，它实际上本质上它也是个项目，它也是个s的项目。而且各位你们要知道一点关键就是不管任何看笔记啊，就是我这写过了说。就是我先说啊，就不管任何的这种牛逼的项目或者牛逼的框架。

它的这个都是java项目。那Java项目的主启动类肯定是幂啊幂函数。所以一会儿我们去找就找这个密函数啊，所以这点不要着急，我们一会来看一下啊。然后现在我让还要解释一个事儿，就是我们服务端所做的一些事情。

那这个位置的话，我需要把我的这个数据库开一下，我先解释一下。😊，这个位置有一点啊，有几点，我需要跟大家说一下啊，稍等一下。有哦，这个不要不要不要着急啊，是我那个服务掉了。这个电脑内存有点不太够使。

稍等一下啊。服务我来找一下我的myscle应该是。自己关了啊，你看关了，okK把服务器一下啊。好了啊，然后咱们回答回到数据库这儿啊，回到数据库这啊。😊，再连一下。好。

我们之前啊去构建这个s塔 server的时候，去创建过一个表哦，一个库就叫西塔。在这个s塔中呢有三个表。看这来。啊，brsh这个这个tableglobal table，还有look table。

这三个是什么东西？各位还记得吗？啊，可能同学忘了啊，所以这我给大家回忆一下，这三张表，实际上是我们sta server端所用到的三张表。在这给大家看一下来，在我的笔记中啊，在这儿。

第一个实际上它是分支事务表，也是它进行存储你的分支事务相关信息。第二个global table它什么全局事务表啊，还有一个就是look全局锁表。所以这是这三张表的作用。也就是说白了。

我们全局事务在开启的时候，它是需要对这三张表进行相关的一些信息的填写的。前提是你使用的是DB模式，还有数据库模式。当然各位应该都知道，我们之前讲过，sta是分为这种呃文件模式，嗯，还有DB模式。

数据库模式，包后还有个redis模式，我们目前用的是数据库模式，对吧？所以这张3张表是我们自己构建的。OK啊，那么我们现在说完这点了，刚才也说过，就是任何java工程的启动程序都是主函数密。

所以现在我们就要从这入手去看一下整个的构建过程。其实我们今天主要看就是个全局表，好吧啊来。😊，那我们就找一下啊，这个我就不给大家去现找了。就是你们全局这个暴力搜索一下，搜索找到这个秘方法。

它实际上是在server在这里面，这type server在这里面啊，在这里面你可以看到秘方秘方法在这儿。

对吧命方法在这儿，然后在这其中我们要找一个关键点啊。在这儿。他就是那个关键点，默认的调用者。不能叫调用者，叫默认的协调者，叫deund coordinator啊。

那么这个东西的话是我们就可以从这儿去进行去查看啊，包括从我的这个图中你可以看到这标出来了啊，不是这个图啊，从这个图中可以看到啊，到塔搜端，找到这个默认的协调者然后去找这么个方法。

叫做do global begin，你可以往下来看啊，在哪儿啊。

在这儿。在这个默认协调者中，有一个叫做dog begin。从这开始是一个处理全局事务的开始。那我们来首先看一下这个方法里面具体做什么了。第一件事情，你看啊响应客户端叉 IDD看到了吗？

response点set IDD去把对应的叉 IDD响应过去。哎，那实际上关键点就在于哪啊？咱们先不着急看啊。

先看这个这是个do global begin还有什么do global commitit全局事务提交，还有什么do global全局事务回滚，包括全局事务的一些状态等等些其他信息。

这三个是我们比较关注的对吧？当然今天我们主要关注这。😊，啊，全局事务的开启它怎么去做的？我们往下来瞅啊，所以在这儿首先啊你可以看这有一个call点begin。核心begin从这去开始，我们从这看来走。

OK看到这个begin方法啊，在这个begin方法中，它做了哪些事情呢？我们一点点来分析啊，我们一点来分析。那么你看这个比方法中啊，上来第一件事，global session。

session等于global呃session点create globallobal session，这干啥呀？实际上它是创建了一个叫做全局session。从图中我们可以看到就在这儿。啊。

创建了一个啊begin在这啊构建一个全局session，这是第一件事情。那么第二件事在这儿还有。session点I的 sessionession。Listener。是什么东西啊？

那么各位要注意中间这个词儿是什么意思？lifecycl。at session lifecycls listener是啥呀？首先这是一个添加一个监听，而且这是个观察者的设计模式。

同时这个位置lecycl它代表的意思是什么生命周期。session点 and sessionession lifecycl listener说白了是干什么？就是给他去添加监听嘛。

那么还有就是一件事再往下来看啊，全局事务开启section点be，这是一个全局事务开启。那么这这三件事啊，我分别在这个图中给大家列出来了，这也是我们主要分析的三件事儿。第一件事情。

构建全局session，我们看到了，这不用多是很简单的事儿。然后第二点就是为全局session去添加监听。那么第三点是调用调用全局session点 beging方法来开始对应的一些。具体处理。

所以啊第一步不需要分析。我们先来分析。第二步就是个为全局session添加监听。他干了什么事儿。所以从这儿开始。啊，从这开始爱的时候开始。O啊，那我们从这开始对吧？O啊，那么在这之前我们还是先看一下嘛。

这个构建全局session啊，其实它所谓这个固建全session就是把看plication ID包括transal service group group分组，包括name把一些相关的信息传去。

它构建全局session的目的就是为相互能够去进行一个么相互有个信息的互通对吧？所以这不用多解释再往下来看看这啊那么点 session leave这个东西list我可以看这他在这个位置去干了什么啊？

其实啊在这我们可以看它。😊，session holder点上get root session manager这个位置他做了一些什么事情，它实际上是获得了一个全局的session管理器。

那么各位可以注意到的是它虽然说这写的是获得了一个全局的session管理器。这个session管理器到底是谁呢？这有一个常量root sessionession manager，我们可以看一下这常量啊。

你看它的默认值是session manager，这是一个啥，这是个接口。对吧okK那么它是怎么去构建的是谁的？具体这个筛选管理器是谁呢？其实我可以往下来看，看它的初始化方法，init方法嗯。😊。

那么在引匿的方法中啊，往下来搂一眼啊，看这来。😊，他上来这都不用管啊，你就看这儿来啊。😡，这个是一个模式的判断，看到了吗？啊，这是个模式的判断。store model点get model。

其实这个位置它是去读取你的配置文件来获取你当前的一个。什么sta的模式。而很明显我们当前的sta就是个DB模式。所以说你看当前这个模式，如果是DB那好，我们现在这个位置它 equals嘛，对吧？

如果是DB模式的话，那就走相关这个位置啊，如果是其他的file模式，走的是fi相关的。那么还有如果是res的那走res。😊，看到了吗？它是根据这个模式去读取对应的文件。

然后来拿到你具体的那个真正的什么session的一个全局的这这这么一个管理器。OK所以很明显当前我们是DB模式，那我们就看这儿。然后你看啊我们要找那个长量值叫做root session manager。

然后他这是读取了一个叫做session manager class啊，如果是DB模式获取名字，它这个位置实际上如果各位你们自己来看的话，其实你们应该能看出来，它实际上采用了SPI的机制。

去读取了对应的接口时间类。那么他读取的是哪里？它实际上读取的是哪儿啊？读取的是当前这个ressource中对应的这个文件下的一个叫做DB模式的这么一个文件。在这儿呢看到了吗？啊，它读取的是它。

所以咱可以看一下走啊，在这其中啊，你就可以看到哎，我看一下啊呃，是不是这文件。😊，啊，不对，sorry看错了啊，不是他啊不是他啊，他读取的是这个。看错了。

就是这是data source provider啊，这不是他啊看这个来它读取的是这个session server sessionession啊，session manager。😊。

在这里面所记录了对应它的一些专门的类不同类型的一个实现类。你看啊有fi文件的实现类型，session manager有dabase的数据库类型的，还有redist的。很明显这个位置我们是dabbase。

对吧所以当前这个位置我们再回来回到哪儿啊，回到啊，就是它再往下翻啊，咱看才找了个哪儿来着？😊，这个这个这个这个init往下啊。咱算了，这么看，别推进了啊。就这啊。这个方法这个root是谁呀？

那不就是我们看到的这个对应的配置文件中。这个吗？是不是dabb session managerO所以在这儿我给大家去记录了，说去添加全全局这个监听以后。

那么然后呢这个位置啊还要去通过SPI的机制去读取对应的session的一个持有者。这个session的持有者实际上就是我们读取到的。

这个文件也就是DB模式。啊，返回的是它dabb session manager。所以当前我们这个管理者就是他。

好明好明确了吧，这块O那么咱们再回到这儿。😊，啊，回到这。所以当前第一步构建了全局事务ID第二步干什么获取了一个啊这个这个就为这个当这是个观察者设计模式啊。

去添加了一个对应的创建了一个daatabbasesession manager啊，添加今定同时找了这么一个管理者，对吧？全局session根据你的这个类型去管理的。我当前数据库也行。

所以找的是daatabbase，然后再来就是全局事务的开启。😊，那我们就再关注这儿。往下来走啊，sction点 beging走O。😊，那么进到begin这个方法以后，你看他干了什么。

这个方法首先声明全局事务开始。为什么这么说呢？你看当前全局事物状态，你看global status点begin点begin实际上就是个开始状态。O它是个开始状态。

然后当前的开始时间以及激活全局事物active状态为 true。啊，然后将当前的这个session manager去放到这个集合中去调用它的什么on。begin方法啊，去调它的un begin方法。

所以这个位置啊，我们现在就来看一下这个begin方法啊，需要去进入到哪儿，进入到这个un begingin方法，这是关键奏。啊，当然这个位置啊。调的是谁呀？

这个位置有个副类叫做obstract session manager啊，这个obstract session manager就是它相关的一些session manager的副类。所以我们现在就找到它啊。

on begin有个叫做at global session啊。那么现在我们可以看一下啊，这个at global session在这儿。他又干了什么？往下来看啊往下来看啊。当然这个位置啊。

其实如果你直接进的话，它是负类的。那么这个位置你要想刚才我们是不是说过了啊，在这个位置。😊，哪儿去了？哎，哪去了？回来回来回来回来啊，就是在这儿啊。😊，我是不是在这去搞了一个叫做什么那个。这个东西。

dta database session manager对吧？从这找到它。所以当前我们在abstract session manager中去调用这个at global session方法，它应该是谁？

是不是就是我的datase，这个，而不是fi或者re。因为当前是database模式嘛，数据库模式嘛，对吧？所以找它在这进去。😡，在这儿实际上真正去执行的方法是这个。

也就是我的dabbase session manager所执行的这个at global session方法。啊，添加这个方法。那么这个方法它具体干什么呢？首先第一件事情写入session。啊。

写入相关s审。在这right session。对吧ok然后关键点就在于这儿，我们走看这个readd session啊，当然这也是一个。需要去找它的一个实现类啊，也是这个datb的啊。

一定是dabbase的。因为现在数据库模式就是它好造汁儿。那么你走到这个写入方法以后，来看啊，他干了什么？当前这个位置他判断说啊你这个。是否是啊第一次写入？如果你当前我们可一定是第一次写入。

因为刚开始掉嘛，如果你当前是第一次写入的话，你看它一定是走的insert。啊，如果你你如果不是的话，可能是有修改，有删除，有其他的。

但当前我们第一次进来一定是insert global transactional deal走这。对吧那再往下来看。

我们就看看这个insert global transactional deal是干啥的啊，当然啊这个位置还是有需要对应的时现类啊，来看一下。他这干啥呢？这个东西是不是就很明显很直接了。

它是不是就是去真正的写文件了，写什么，往数据库里写东西了。😊，那么它往哪个数据库里写啊？有对应的一个类型。global transactional什么DO看一下这个类型。

strring chin long啊，这个这个transal ID啊，ts application ID等等这些。你看看这些跟它是不是一样的。

跟他是不是一样的，前四个是不是对上了？

啊，包括后面什么service group，是不是也对上了什么对应的transal name是不是也对上了？😊。

所以分析到这儿，各位明白咋回事了吧？啊，咱们看图来说啊。这个位置调用全局session实际上就是调用负极的un begin，然后走的是datbase session manager啊。

是我们那个DB模式的。然后进入到DB的储存模式的这个right写方法。第一次进来一定是向当前这个inser去写入数据，写的就是你这个global table表中的数据，也就是去记录一个当前的全局事务。

所以这就是我们这个位置。全局事务提交的时候干的事儿就是在你当前的这三张表中，哪三张表啊？刚才课户笔记中说过，这三张表中在全局事务表中去记录一条数据，证明当前有一个全局事务进来了。

这就是这个位置的交互相关内容啊。当然今天我们主要分析的就是这个global table这张表。

能理解了吗？各位OK那么讲到这儿的话，其实这个事儿我就基本说完了啊，整个流程我在这个笔记中都有记录，你们可以去按照这个笔记再过一遍，包括这个图也会给大家。😊。

啊，它其实非常简单，就是服务端开启以后找这个默认的，然后去找这个dogle logo开启全局事务，然后对应的 begingin方法做了三件事，构建全局session。

为全局session添加添加一个监听。那么这个位置实际上找的就是一个叫做dabbase什么session manager这么一个呃数据库模式的一个manager，然后再来去调用全局session的时候。

它调用的方式，其实最终的最终干的事就是去向DB模式储存全局事务的那个表中去写入一条数据，证明当前有一个全局事务。当然你们要知道，就这个东西在最后写入完以后，为什么我们在这个表中看不到相关的内容。😊，啊。

就是我们这个数据库的表中为什么看不到相关内容？是因为他每一次执行完成之后，会把当前的这个表中所有内容清除掉，它也就是一个记录的事儿。好吧，各位啊，当然其他的这两张表道理其实差不多。啊，就是其他这两张表。

一个是。分支事务，一个全局锁，这两个其实差不太多，道理都一样。所以这我就不详细分析了。我们主要分析就是这个全局事务表，明白了，各位啊，这就是服务端交互这个时候啊，尤其是服务端交互这个位置，他所干的事儿。

就是全局事务全局事务提交以后，他干的事就这些。

好吧，各位啊，OK那么这节课就分析到这里。

系列 6：P121：为什么要学习RocketMQ源码？ - 马士兵学堂 - BV1RY4y1Q7DL

然后在正式上课之前的话呢，我们抛三个问题啊，就是对于roing的源码解读。第一个我们为什么要去学reing随源码，这是我们的第一个点啊，就是今天这节课的话，你可能会接住就是要听上两个多小时。

我们首先要知道啊我们为什么要去学req，这是非常重要的一点啊，然后第二点的话，该怎么去学呢，对不对？所以我们在课程当中，我们去解决怎么学源码的问题啊，然后学完之后的话。

比如说你要去面试或者你工作当中要进行运用。然后学完源码对你什么帮助啊。所以我们今天就围绕啊这三个点，然后把这三个点把它搞清楚的话，那么你这节课就没有白来。好。

那么首先我把这个东西copy到我的笔记里面来啊。😊，Okay。这节课的话我就围绕这三个点来进行讲解啊。第一个点，为什么要学re的源码？😡，OK有没有小伙伴能够跟老李一起互动一下？😊，啊，MCA是谁？😊。

MCA是我们的一个java体系架构啊。首先学源码啊，第一点大家要注意为什么面试官会问，对不对？有的同学说，我学源码的目的是为了干嘛？那是不是有可能面试的时候会问？😊，所以第一个问题啊就是。😊。

为什么要学roingQ的源码？啊。首先呢源码它分很多种啊，第一种的话呢就是这种开源架构，对不对？开源架构里面呢，像roken歌的源码的话，它是阿里开源的。好，阿里开源的一个消息中间键，对不对？😊。

然后这个消息中间。建的话呢请注意啊，他为什么今天老李李锦老师要去讲他了？一个主要的原因他是阿帕奇啊阿帕奇的一个顶级项目。也就这个项目的话呢，不是不单纯说阿里的内部认可，就是在编程行业啊。

或者是我们传说的这种程序员这个行业，你能够成为一个阿帕奇的顶级项目，那说明你这个项目对不对？你的代码，然后你的这个性能，然后你的这个拓展性，还有呢你这个代码比较逼格啊，肯定非常高的。

但是站在我们自身来说，对不对？我们要学的话，那无非就是第一个要去解决面试问题。😡，你去解决解决面试问题的话呢，大家知道我们经常所说的在面试过程当中，很多情况下面你要去展示自我。😡，啊。什么叫展示自我呢？

就是如果说像re的源码，你能跟跟面试官是吧，然后把自己的源码，然后讲出来，然后加以条理的说出来，说出其中的亮点，或者说出其中的一些核心关键点。那么这样的话呢可以展示自我啊。

并且这个自我的相对来说是比较优秀的自我。😡，优秀。😊，好，那么这是我们讲的第一个点啊，就是你面试的时候，大家注意了，你不能说我平时的这个项目里面对不对？然后就是一些简单的CRD。然后我可能就只会。😊。

用一些con API或者 API或者pen API等等之类的啊。那这样的话呢，你可能会比较的掉逼格啊。然后第二点就是不单纯是解决面试。你在工作当中对不对？你比如说用它啊。

这个时候那可能会在用它的过程当中会有一些比如说一些困难点，一些难点，或者是一些什么bug点。这个时候你可以去解决它。因为你如果读过recon源码啊，比如说你当中如果说使用它报错了。

或者要使用它去搭建集群，或者使用它进进行性的优化，你读过它的源码的话，那一定能够做到啊，不是简单的去百度。然后第三个点站在我们一个长远的角度来考虑。就是大家知道啊，一个程序员要成长。😊。

我们经常所说的啊，我们做技术要成长，这个成长是依据于什么？那依据于不是我写了多少的if else，不是我写了多少的业务逻辑，而是说我要去编写这种叫做优雅。😡，啊，优雅，还有呢。😡，高效的这个代码。

而这个代码的话呢，我们知道啊你平时写的这些，比如说你们公司用的这些框架，公司用的这些项目啊，里面呢可能涉及的点比较少。但如果我可以做一个像rockQ源码，然后呢做个参考。😊，啊。

那这个时候你的收益会非常非常大啊。所以呢学着更多的源码的话呢，我们可以去增长我们编写优雅优雅高效代码的一个经验。OK啊，另外的话呢也不用说了，如果说你要去面大厂。😊，就是说你要去面大厂的话。

那这个时候啊别人一一定会认可你啊，不是因为你去大厂面试的话呢，你说一下你们公司的项目，对不对？那你公司的项目肯定没有像阿里京东，还有像字节跳动，他们的这些项目相对来说啊你们的项目比较low逼。

你们项目当中运用。😡，这个技术应用啊它比较的低。所以的话呢我们可以得到一些大厂的认可啊。然后同时最后一点啊，其实是非常关键的。尤其是像像我们做java开发的这是我们要去锻炼一种思维。😊，什么思维呢？

就是我们去做一个东西，对不对？或者我们完成一个对应的需求。我们要提高这种叫做架构设计的能力。好，这是我们讲的啊，前面我给大家聊了一些，就是我们为什么要去学recon嘛。

所以呢给大家去分享一个一节这样的课啊，当然re源嘛，如果说要进行一个全盘读的话，比如说我们要去全部去读的话，那可能两个小时读不完。所以呢今天我把中间的一部分非常重要非常核心的点。然后我给大家提炼出来。

然后给大家进行一个讲解。😊。

系列 6：P122：RocketMQ源码之JUC锁优化 - 马士兵学堂 - BV1RY4y1Q7DL

OK那首先的话呢，我们再进入第二个问题。第一个问题就是我们为什么要学，对不对？然后第二个问题的话就是我们该怎么学。😡，好，怎么学这个问题？首先的话呢给大家看源码好不好？😡，我李建老师的话呢。

特意给大家把这个runq比较新的版本啊，叫4。8。0的这个源码给大家下下来了。大家可以看到在这个源码里面呢，它有很多的子工程，什么ACL的bro的c的，然后comode configurefid的。

还有了一些什么叫呃exle，还有像loin，还有像name server，还有像stone，还有像其他等等之类的啊。所以大家去读源码的时候。😊。

第一个困难点会是什么？就是我把这个源码全盘下下来，你会发现这个源码里面大概有几千个类。然后工程的话有十几个。所以这是我们遇到的第一个问题点，就是我们无论去学这种什么像spring也好，像那种reQ也好。

对不对？或者只要是一个比较完整的大型的项目，那一定会遇到这样的问题。那首先。😡。

啊，我给大家一个忠告啊，李老师给大家一个忠告，如果你去想去学圆嘛，首先应该要进行一个梳理。这梳理什么了？梳理它的主线。😡，啊，那么首先梳理这个主主线该怎么梳呢？啊。

这个时候啊请在听的各位小伙伴跟着老李的这个思路，好不好？😊，OK跟着老李的这个思路啊，首先我给大家给画出来啊。第一个的话，我们要知道，如果说你要去了解rock源嘛，你必须要知道roq它是怎么运转的。😊。

好，那首先。大家知道。😡，在rock andq里面，他首先肯定会有一个叫做bro的东西。啊，这个b用来干嘛了？😊，给大家说一下，它主要就是负责存储消息啊，就是因为作为一款消息中间件，它的这个目的是干嘛？

就是有消息来了，然后发给我，我来存进去。所以在这个req里面有一个非常核心的角色称之为broker用来存储消息的。然后除此之外的话，我们知道一个消息中间键，它肯定不是说啊它单独的存在。

它有一个消息的来源。所以在一个消息键消息中间件的组成里面，还有一个叫做proder。😊，好，这个proder是什么？是生产者。😊，我们常说的生产者啊。😊，生产者这个生产者用来干嘛去发送消息。

所以呢大家可以看到啊，在我这里面我把这个箭头改一改。😊，就是有一个生产者，他要向我们的broer叫做send message，对不对？发送一个消息，或者是发送批量的消息，他都可以。好，那除此之外。

作为消息中间键，它的作用是什么？我把这个消息从生产者，然后发给这个broker之后，那是不是还有一个角色叫做consumer叫消费者。所以我再拉出了一个角色叫做consumer。😡，好。

这个康索码呢是我们常说的消费者。那消费者的话呢，其实在rock conQ里面啊，它是进行消息的拉取，我们称之为普尔消息。😡，喂。Poor message。OK大家可以看到啊，在我的这张图里面的话。

其实已经完成了一个消息中心件最基本的功能，对不对？就是进行一个消息的发送，以及进行一个消息的消费。好，那么在其实在真实的rockQ里面。😊，他还会有一个角色。

这个角色呢我们把它称之为nmo server。😊，就是如果你玩过。那个rocon的话，你会知道它有一个name server的角色，这个负责什么叫做服务的。😊，注册与发现哎。

为什么会要有一个 server这样的一个角色呢？啊，我给大家说明一下啊，就是我们在进行消息生产和发送的时候，往往你可能这个bro，它不是一个单体，因为大家都是追求分布式微服架构啊。

追求这种什么多主多层的这种架构。所以在真实你去部署的时候，这个bro它可能会有很多个，对不对？比如说我这个地方就画出三个，那三个的话，它可能部署在不同的机器上面，如果我作为一个客户端，对不对？

就比如说你的这个订单系统或者是你的这种比如说你的这种什么业务系统，然后你是一个proer，你是个生产者，你像我们的这个broer发送消息的时候，你发现它是个集群，它有多台。

啊这个时候的话啊我怎么去知道每一个bro它的IP地址，它的端口呢？所以啊在里面它还会。😊，还有一个非常重要的组成，就是这个name server。

这个name server就是类似于我们之前讲的这个ZK做 keep啊，它是一样的，它完成服务的注册与发现啊，所以这里面我要再画一条线啊。

就是我们的生产者和我们的消费者在正式去发消息或者是进行这种拉消息的时候，首先他必须做一点，就是把这一个相关的路由拉到。😊，ok这个地方我画一根这样的线啊。这个称之为什么？叫做topic。Root。

给大家说一下这个topic road是来干嘛呢？我们可以打开源码里面啊。😊。

像李老师的话呢，给大家解释一给大家介绍一下，在这个源码里面的话呢，它其实写了一个一些事例啊，这些事例的代码呢就是告诉我们怎么去使用roq。那么使用rock q的话呢，我给大家举个最简单的例子啊。

比如说像我这张代码叫做步发送生产者，就是我写这里面写了一个简单的man方法，这个man方法把它运行的时候呢，如果你要去向roq发送消息。那么你引入它的API引入它API的时候呢。

然后你 new出一个de m producer new出这这样的一个东东，对不对？然后在这个pro里面啊给他命个名字啊，比如说叫做g下划线。然后第二步的话大家可以看到你在发送消息之前。

你要针对这个proer给它设置一个的地址。😊。

啊，这就相当于是说我如果向rock q里面发消息，其实本质上面你只要设置name server的ad，设置它的地址。比如说我设置成本机127。0。0。1，然后端口是9876。这个9876啊。

其实就是我们刚才给大家画的这一个namemo server默认情况下面，它起的端口，就是你要在你的服务。😡，服器上面启动一台的话，首先你要把这个namemo server给它启动启动起来。

然后除此之外的话，你还要把bro启动出来。当然，namemo server和bro它都可以是多台。O那么这个name server的话呢，本质上它的多台是完成这种副本或者是完成这种备份。

就是它多台里面保存的信息是一样的。但是针对这个bro的话呢，它可能会有不同。就是一个bro对不对？它可能会存主题当中的一部分消息啊，比如说你定定义了一个主题叫做主题A。那么主题A底下如果有8个队列。

然后我有两个bro的话，可能在进行分布式部署的时候，四个队列在这一台bro一，然后4个队列在我们的bro2。😊，OK他可能有这样的一个设置。所以我们在进行发送消息的时候，大家可以看到，在我们的代码里面。

你如果向rockq发送消息，你只需要设置name server，然后设置完name server之后，然后再去进行一个叫做prod点star就是。😊，让我们的roQ进行启动。😡。

那你调了它这个方法的时后，请注意，在我们的这一个流程里面，你只要启动了一个prodduer生产者，或者是说类似的启动了一个consumer。

那首先它就需要从我们的lemo server当中去拿相关的路由信息。这个这个路由信息，我们把它称之为topic root，就是我们的相关的主题相关的东东。这个东西会包含什么呢？给大家解释一下。😡。

这个东西会包含，比如说。啊，我们的一些配置。啊，包含一些IP包含一些端口。啊，这个配置比如说我这个地方啊先不画集群，我把这个变形方画大一点，然后把这个线提上去。😊，好，把这个线提上去。

然后在我们的ber里面呢，把这个标题啊提上去。大家知道你在发送消息的时候，本质上面在我们MQ里面，它会有一个Q的概念。😊，大家知道MQ它就是messageQ，它就是一个消息队列，对不对？

但是在MQ的这个定义范围之内，它其实还有一一个更大的概念叫做topic。😊，叫做topic主题。啊，这个主题为什么去定义呢？就是在阿里里面或者在你们的这个业务场景里面，我们很多情况下面。

我可能要定义一类消息。比如啊如果我把rock andQ把它部署在淘宝，那么淘宝里面它会有各种消息。你比如说你作为一个生产者，对不对？这个生产者是一个什么应用呢？是我的订单系统，你像淘宝下了一个订单。

然后这个订单它属于服装类的，那是不是有一个对应的主题叫做服装的消息，你去下一个订单，这个时候它就会发送一条消息到我们的ro。😊，comp的，然后告诉你，我要写入一条服装的消息。然后除此之外。

那我可能下了一比如说下了一个叫做手机的订单。那这个时候那可能我发送消息的时候，还是发给rock q。但是在这个地方我会另外再创建一个主题，它标识着一类消息。然后这个主题的消息呢。

可能就是我们的这个手机相关的主题。OK好，所以呢这是我们讲的第二个概念啊，就是在rock q里面，哪怕是卡夫卡里面，它都有这样的一个概念，叫做topic。好，在top底下的话。

一般来说我们底下会划分成很多的这种Q队列啊Q。😊，1234啊，它有多个Q，就是在一个主题下面啊，像reconq默认情况下面，它最少会有4个Q。好，那么我去发消息的时候，比如。😊，说我举个例子啊。

我用这个东东表示一个消息，把它变小一点。😊，这个消息首先在生产者启动的时候，他需要去从我们name server当中干嘛要去拿取相关的配置路由信息。为什么拿到这个信息呢？我们来看代码。

在我们的这个demo里面，对不对？在我们刚才看到的这个demo里面，我把这个proder把它启动完之后，剩下来我就是写了一个for循环。这个for循环用来干嘛呢？就是for循环10次。

然后每一次new出一个message，这个message呢是re里里面提供的一个API啊，就是你如果要发送消息的话，在它原生的API里面。😊，就是这个里面引用的API里面啊。😊，ORG阿帕奇rockq。

然后coma，然后message，然后一个大写的message啊，这是一个类啊，你把这一个类然后扭出来，扭出来的时候，你需要去定义你的这个消息是发到哪一个主题所以在它的第一个参数里面，对不对？

你可以写上对应的主题啊。比如说这个地方我可以改一下我发送的时候，我改一下叫做topic test。😊，或者是top个A，对不对？那么就是这条消息，你就告诉rockQ，我要发送到topic A。

然后除此之外的话，在我们每一个消息里面还会加一个tg。😡，这个tg的话呢，它是一个二级标题。因为你像淘宝里面如果要发送消息的话，你衣服那衣服的话，那我有男装女装，我还有童装。

是不是我们虽然是归到一个主题，但是很多时候我还要做一些消息的过滤，做一些消息的这种分类。这个时候你就可以用上二级主题。这个二级主题呢，我们把它称之为tg。好，那么发送消息的时候，它会有两个核心的点。

就是核心的数据部分，一个叫做kis。这个key的话呢，一般情况下面可以把你的订单作为送物。就是我们刚才如果下了一个订单，有一个订单ID那么你可以把这个唯一的ID作为key送到roq啊。这个key的话呢。

以后如果说你要去查相关的信息，你可以根根据这个K。😊，快速的定位。但是这个消息它的主体是。😡，哪个部分是最后的这个参数，就是你发消息，对不对？那这个消息的组成，比如说你购买了一一台手机。

或者是你买了一件衣服，那么是不是它会要生成一个消息体，那这个消息体的话，在roq或者是其他的任何MQ，它都是这么规定的，只会做字节数组啊，就是你如果想传一个str。

可以比如说传一个hello word没问题。啊这个时候你把它转成一个by数组啊，然后呢把它的这个啊其他东西设置一下，这样的话呢就完成了我们一个消息的创建。😊，好，所以完成消息创建之后。

我们的生产者发送消息就变得非常简单了，就只需要去调用它的send方法，就是把这个message把它 new出来之后，把它作为一个第一个参数送入到我们的send方法，然后呢如果这个消息有没有发送成功。

对不对？这个地方我可以起一个异步的监听，所以我你了一个send call back的这样的一个回调方法，或者称之为回调函数啊，这个里面呢会有两个方法，第一个方法叫做un success。

就是如果说你这个消息发送成功的，那么它就会触发un success啊，给你进行打印，你可以拿到send result的结果，如果说中间发生异常了，对不对？还有一个unex啊，把这个相关的异常进行捕捉。

到底什么地方处发生了问题。所以这个类呢。😊，就是你在去学源码之前，你必须要知道的啊，我作为一个生产者，我要去发送消息，对不对？这个时候首先前面的步骤就是new出一个proder。

然后设置name server的地址，然后再启动，然后再分别new消息，然后再进行发送。好，那么基于这个点大家发现没有？你去往roQ发送消息的时候，本质上面它只配name server。😊，对不对？

他只配name server。因为在rockkenq里面，它还有一个非常重要的角色是什么？是bro。就是你实际上这条消息它并不是发给name server的，不是发给他的。😡，因为那么so他只做什么？

😡，他只做服务的注册与发现，大家可以看到这张图，他只做这个服务的注册与发现。所以大家可以看到，首先在我们这个流程里面这个步骤。😊，他一定是发消息前面的步骤，比如说他是第一步，对不对？

然后第二步你才是发送消息。😡，OK就首先我们先不讲启动，对不对？比如说我把这个name server把它启动了，把我的bro把它启动了。那启动完之后的话，作为我生产者发送消息的话。

那首先是不是第一步要去从我们的name server当中获取相关的路由，然后拿到这个路由之后，我才知道哎，你刚才比如说你要去向topic a发送消息啊，因为它有了路由。

那么我就知道这个topic a应该在哪一个bro上面，因为刚才老李讲过这个bro，它可能是个分布式的，它可能会有多个，对不对？比如说这个是bro一，那这个地方有个bro2。😊，甚至像reQ里面的。

它还可以这么玩。就是你如果定义的这个主题叫做topic a。😡，啊。topic A好，那这个topic A呢，它在定义的时候，可以说把它跨到两个bro里面。哎，就是在我们的每一个。

相当于是每一个主题底下。每一个broty。像他都有topicA。并且你发送消息的时候，它默认情况下面在两台broer上面创建一个topic A，并且它都是主，它都不是从，他都不是备份。他发消息的时候。

我们展示出来的这一个topic A，它就有8个队列，就4个队列在我们的broke一四个队列在我们的broke2，就是你发消息的时候，如果中间像这个broke一，它挂了，没关系。😡，挂了的话只有4个队列。

对不对？没了，但是我还有4个队列，对不对？就是我整个去往这个top game里面发消息的话，那这个时候我是不是还有4个队列，这个时候它就可以确保高可用。😡，所以呢他就通过这个name server啊。

结合我们的bro完成整个消息的一个发送。同理你可以退啊。那么做我们的consumer，对不对？我们消费的时候，他其实也是这么玩的。😊，因为这作为这我们的生产者和我们的消费者。

它本质上面它都属于我们的客户端。😡，嗯，比如说这个地方哎。😊，Okay。就是你生产者和消费者启动的时候，生产者就是往里面发消息。然后消费者的话呢就是从里面去拿消息。😡，它只是一个过程的相反。😡，啊。

因为作为消息中间介的话，他要完成一个叫做异步解偶，还有销风填谷的功能。本质上面呢它是做一个消息的中转啊，就是你发消息发给我，对不对？然后这个时候的话呢，我就相当于中介一样的。

然后再把这个东西呢推给我们的消费者。这样的话呢，就可以确保我们之间完成一个结偶。这消息只要到了我的这个地方就OK了。剩下的工作了，消费者他会监听我，然后我把消息推给他，这样的话呢。😊。

也可以完成我们的一个异步，完成我们的结耦功能。😊，好，今天只讲roQ吗？今天你想听其他的我都可以讲啊，但是我们的还是抓核心，抓主干好不好？然后大家可以看到在这个图里面呢，其实还少了一个步骤，什么步骤呢？

😊，就是我问一下大家，作为numb server和broer。😊，谁先启动？是name server启动的，可以在公屏上面刷个一。😊，broker启动的可以在公屏上面刷个2。😡，谁应该先启先启动。😡。

有刷一的，也有刷二的。有的小伙伴说，bro重要一点，那他当然要先启动。😡，哎，那问题来了。如果它先启动的话，那么这个路由信息你要知道name server里面的路由信息并不是自己去生成的。

而是说一般来说你启动一台，就像我们的name server去注册的。😡，所以我这个地方再把这个启动流程给大家回顾一下。😊，就是其实很多这种有什么服务注册与发现的这种东东的话。

你首先应该要把服务注册的这个插件，它的这个组件先启动。😊，啊，因为呢他需要去获取一些路由信息，对不对？你broker如果先启动的话，我问个问题啊，如果这个东西先启动，那他是不是要把这个路由信息发出去。

发给谁呢？你这个没有起啊。😡，对不对？所以大家如果去玩这种double也好，玩这种什么一些其他东西也好，对不对？他如果有服务注册组件的话，一般是要先把服务注册的组件先启动。

所以这个流程是先把name server启动，为什么要启动它？因为先启动我的话。😊，这个时候你的broke一b2bro3broke4，对不对？哪怕你跑了一段时间，过了两天，你们老板说哎。

我再给你分配5台机器，你可以再部署两台rebro啊，来了一个5来了一个6，对不对？你再往里面加就可以了。所以它的流程是我们bro如果启动的时候。

它就需要向我们的这个name server去发我们的注册相关的信息。所以这里面还有一个流程。就是当我们bro启动的时候，我们要向name server里面去发起注册。😊，啊，所以这一步应该是第零步。

就是在我们去发送消息之前，对不对？他要干嘛进行一个topic相关信息的reg。😊，就是进行一个相关主题的注册。因为这个东西如果不注册的话，那么我生产者，我消费者，我再去发消息，或者我要去消费消息的时候。

😊。

系列 6：P123：RocketMQ源码之GC优化 - 马士兵学堂 - BV1RY4y1Q7DL

哦，我的这个路由信息从哪里来呢？😡，所以啊大家记得的一点，所以在我们源码里面，我可以给大家演示一下啊，给大家把这个romeQ打开。然后一般情况下面，我这地方配了两个啊，一个是bro的启动啊。

就是在源码里面启动，其实很简单，就是找到它的一个源码启动类，叫做bro start up，还有了一个叫做n server啊，这是一个n sRVn server的一个简称。

然后它也一个star up的一个启动类啊，比如说如果我要把它启动的话，首先。😊，需要把name server先把它跑起来。😡，好，然后把它跑起来之后的话。

它会返回一个the of boot success，对不对？然后的signchizable就是他们进行这种传导数据的序列化，采用的是jason格式啊。然后第二个我再把这个bro把它启动。😊，Yeah。

Okay。所以它不是这个bro的服务先启动，而是说注册中心先启动。你看到当我们的这个bro启动的时候，它自身启动的端口，对不对？我的IP地址，然后我的这个机器的名称，除此之外。

它后面and加了一句number的地址是多少。所以当他打印这个的时候，就说明在我们的这个bro启动的时候，除了自身把这个服务把这个当端口开始占用。那么还要去向n server发起注册。好。

那么发起完注册的话，这个时候大家可以看到在我的生产者的这里面我就可以进行发送消息了。比如说我像这个top gate里面发送一条这样的消息。好，发送10条啊，我就可以把它运行起来。😊，Yeah。

大家可以看到。😊，我发送完之后的话，调到这个send方法，然后通过这个回调函数叫做send call back里面返回的都是send ok就是send，就是我们的这个状态啊。

就是我们打印的其实都都是这个点，就是on success里面，然后打印里面返回的一个对象叫做send result里面的内容。这个reult里面会包含哎你的这一条消息有没有发送成功。

成功的标识是send ok。然后你这个消息在我ro里面，它有一个唯一的message ID。😊，啊，这个ID的话呢是一个很长的序号，就代表它是唯一性的ID。然后除此之外的话呢，还有一个消息的偏移量。

就是因为消息要去进行存储的话，它必定会有一个偏移量，这是一个offset。除此之外的话你。😡，可以看到在我发送消息里面，他还告诉我这条消息，它的相关的Q，就是因为我发送的是一个topic a的主题。

但是在这个top a主题底下，你可以看到有Q IDD等于一的，代表它是这个top a的一个Q有ID等于零的有ID等于二的，还有ID等于三的，也就是我们刚才的这个10条消息。

它会均匀的分布在我们的Q0Q1Q2Q3就是总共是4个Q，然后在每一个Q里面，我们可以看到啊它有一个Q的of。因为Q就是我们的队列嘛，在队列里面的话，每一个队列它都是从零开始，对不对？所以像第一条是0。

然后呢如果在跑到Q一的话，这个地方变成一，然后再跑下去就变成我们的2所以这是我们可以返回相关的东西。好，我们就今天不去讲太多的应用啊。我们今天首先讲的为什么要学源码。然后讲了中间的一个点。😊。

怎么去学rock的源码，先把它搭起来，先把它的整体的东西把它运转起来，对不对？然后这样的话大家才会对我们rock的整体有个概念。那么这里面我再来讲一点，就是如果你想去读rock的源码。

其实只要读三个方面的内容，哪三三个方面呢？大家知道第一个核心就是刚才我们所说的启动流程。😊，就是你任何的一个，比如说源码框架也好，对不对？那首先是不是我要去了解里面的启动流程。😡。

所以第一个点非常核心的叫做启动流程。然后第二个的话，我们知道作为roQ里面它只有两个功能，一个功能叫做消息的生产。所以我们看消息的生产过程。然后第二个就是消息的消费过程。所以大家知道啊。

就算我们下载的roQ里面有这么多类，对不对？几百个类几千个类。但是大家其实需要读的无非就三个流程。第一个怎么启动的？第二个的话，消息怎么生产的？第三个的话，消息怎么消费的。😡，好，那么。

首先呢我们给大家说一下啊，我们可以看到前面启动的几个类。第一个里面我找到这个name叫做name server start这个类。我们来分析它的启动流程好不好？

然后大家可以看到在这个name叫做name server这个类里面呢，其实本质上面跟我们写的一般的类它没什么区别它里面呢也是一个man方法，只是man方法里面调了一个man，然后把我们的里面送入进来。

对不对？然后在这里面可以看到我这个地方加了一个注释，这个注释是理解老师写的啊，就是我讲课的时候，我讲的时候。

我写的然后它在man方法里面拿到了一个叫做name server的 controllertroll，也就是在里面呢，它的这个写法跟我们写的这种叫做 vc啊，写这种什么 boot非常的类似。

它也使用到了一个controll类啊，只是说它通过一个叫做gr server就是这个服务的注册与发现的这个启动类里面啊，本质上面。😊，也就是他用的controll啊，大家可以看到前面这些内容。

这个东西就是设置系统的参数，然后判断一下我们的命令行啊，就是我们是就是进行启动的时候，我可以在一些命令行里面加些参数啊。所以这个地方呢也可以判断一下。然后除此之外的话，大家可以看到。

其实在rockQ里面它的端口是绑死的。😊，啊，就是如果有面试官问你roq怎么去改他的name server的启动地址啊，我可以告诉你，外部改不了，就是他没有配置参数去改他的name server的地址。

因为这个端口写死的就是9876。😡，OK所以大家可以看到啊，这个地方的话呢是写死的。如果要改的话呢，必须要去改它的原嘛啊。然后除此之外的话呢，就是我们一些启动的杠C的参数的一些解析。好，紧接着往下面走。

都是一些判断啊，就是它加了一些什么启动的杠P的参数的解析。然后除此之外的话呢，来判断一下它的一些什么它的一些后相关的信息，对不对？然后再接着往下面走啊，这些东西你都可以理解成它都是解析一些参数。😊，啊。

就是我们在配置的时候有pro的参数，对不对？然后呢，它可以把它打印出来，把它把它设置进去。然后最关键的一点，因为本质上面他要去用一个controller。

所以呢它扭出了一个跟他同名的叫n server的controller。😊，啊，大家可以看到啊，这是一个构造类啊，这个构造类里面呢就是分成了一部分的信息，都是前面的配置配置，对不对？

name over的配置late因为 compute本质上面用late体启动的，所以它late体的配置，还有呢包括里面的一个叫做key value configurefi manager它的配置。

还有包括我们的root in manager。😊，就是我们的路由相关的信息，还有一些什么叫做什么keep alive吧，这是一些什么我们的主机相关的一些啊心跳啊，一关相关的服务信息。

还有一些配置相关的信息，对不对？所以你可以看到这个le server，它其实启动的时候，它无非就是带了这些参数，然后通过它的构造方法，然后拿到这个controller。

然后拿到这个controller之后，对不对？然后紧接着。😊，大家可以看到我们就可以返回了。😊，可以返回到我们name server controlt的这一层啊，返回到我们的前面。😊，好。

完成了我们的核心步骤，一就是new出一个conttroroll，让但是它启动真正的地方是在我们的star方法里面。😊，啊，就是从源码的启动流程，大家可以看到啊，其实它最核心的还是这个star。

在这个star里面呢，大家可以看到，我们前面只是把这个controller new出来，但是它并没有对它进行初始化。所以呢我们可以看它的in这一个初始化的方法。然后在这个初始化方法只要干完之后。

其实整个流程它就结束了。看到没有？整个流程最后面初始化之后，最核心的第三步，就是除了去设置一个叫做钩子方法，什么叫勾子方法呢？就是我们启动完之后，我们要通过外部的命令把它关闭的话。

那么我就需要去通过这个钩子方法啊，你向我发个命令，这个时候我就可以调controll点 down。😊，啊，所以这个地方呢设置一个钩子，设完之后，把这个controllr初始化之后，它就会到最后一步。

叫做它的star方法。😊，好，首先我们看初始化的这个方法。在初始化的这个方法里面，我写了很多的注释，就是作为一个name server作为一个服务的注册中心。

其实本质上面它肯定要去嵌叫做什么启动网络监听网络。所以呢它要去创建我的remoing service，就是相当于我要去监听一个网络，它里面用到了一个laty的主件啊，这个东西我们就可以先不看。

反正就是相当于是说我扭出一个laty remote service，到时候我把它注册上去，我就会去绑一个端口。比如说我们之前讲的9876这个端口，然后除此之外，我还要开启一些定时任务。

这个开启定时任务给大家说一下，因为这个服务的注册与发现这个中心，它要干的活，不单纯只是完成服务的注册与发现，它还要完成一些我们常说的集群相关的功能。😊，就是我们有broke一注册上来了。

有broke2注册上来了，有broke3注册上来了，对不对？那么有可能你的这一台，比如说像broke3。😊，他可能发生了故障。那发生故障之后的话，那肯定跟我name server之间。

我可以感知到为什么我们中间肯定会有心跳机制。所以这个地方我就可能要采用扫描的方式。😊，就是我定期扫描一下，如果发现这个brook3，它的心跳信息已经超时了。比如说超过120秒，我没有收到了。

这个时候我就认为啊这个broke3它已经是掉线了，它已经是宕机的状态啊，所以我就需要把相关的路由给剔除掉。😊，啊，就是我原来在注册的时候，我这个top a底下有可能有有什么有12个，对不对？

除了这里面的4个，这个4个之外，还有一个brorke3的4个。那当我的broke3如果宕机了。😊，那是不是我要告诉我的proder，还要告诉我的consumer，告诉他们，哎。

第三台broker他已经不在线了，对不对？他已经是下线状态了，你发消息的时候或者是监听消息的时候，不要再从这一台bro三上面去进行处理了。OK所以这叫做故障的转移啊，然后我们继续走代码啊。

再走代码的时候，我们先把这些东西慢慢的放啊，本质上面它都是启动了一些什么定时任务，定时任务，定时任务，对不对？去扫描去打印，然后呢去扫描OK然后做完这个事情之后。😊，他就会返回一个te，然后返回一个t。

我们再来看。😊，初始化的方法仅仅只是初始化，对不对？最终运行的话要调它的star方法。所以在这个star方法里面呢，它其实只完成一件事情，就是把我们的reming service点star。😊，啊。

这个地方我给大家说了叫做启动NRS组件。这什么叫NRS组件呢？就是它本质上面是基于累体。😊，La体。So what。🤧啊，然后。这叫做latetyso啊remoing server啊NRS。😊。

remoing RRET。So。这个组件。啊，所以它是NRS的一个简称，就是把它然后点star。大家可以看到把它点散的时候，其实内部呢它就会去调我们lateate的服务啊，这一节他用了封装。

用到的是我们lateate当中的serv but strap。😊，在里听课的同学有没有玩过laate的？😡，如果你玩过lay的话，你会发现这样的代码非非常熟悉了。就是当你要去启动一个lay服务的话。

就会用到lay里面的叫做servver butstr，然后调它的点group方法，然后调它的点什么channel方法，然后设置相关的参数。设置完最后的话呢，就调我们的这一个叫做差的hand，对不对？

然后调完的话往里面去添加相关的什么pe添加相关的这一个handler，然后进行对应的处理。一般来说，最核心的就是这一个serv handle。😊，就是相当于只要说把启动之后，一般来说有请求来了。

就交给这个serv handle进行最核心的业务处理。好。😊，那么再回来啊再回来。😊，再回来啊，刚才其实我们已经把rockq的这一个启动流程，对不对？给大家差不多讲了一个大概啊，但是其实大家发现没有？

在读源码的时候，最核心的并不是我们把这个源码给跟了。😊，就是这里面我给大家一个这样的建议啊，就是读员嘛。😊，他最关键的点。或者是大家最有收获的点是什么？😡，在这里听课的几百位同学，你给老李说一下。

你们觉得读圆嘛？如果说你想读，那是不是不是说简单的把这个流程给过了？😡，而是说要去找源码当中的一个亮点。啊，赞不赞成老李这个观点啊，赞成的话可以刷个一。😊，啊，这是我们读源码的时候。

其实本质上面不是把这个源码哎呀，第一步、第二步、第三步、第四步、第五步、第二步把它列举出来，然后就OK了。本质上面是要抓亮点。为什么？因为读源码最关键最核心的点。😡，我们要面试啊，我要展现优秀的自我啊。

你不可能跟面试官说，我读了ro的源码，他的第一步，然后启动什么？第二步又拿了个组件，第三步又拿了另外一个组件，第四步又走这个流程。面试官听到的话，昏昏欲睡，对不对？他想听哎，你读了ro源码。

你到底从这个源码里面收获了啥？好，我们就讲他的一个亮点。😊，大家可以看到，我把rockq里面最核心的一个包叫做namemo server给它展开。

是这个包。就是刚才给大家介绍的这个服务的注册中心啊，是它的一个子工程叫做name这个工程。然后在这个工程里面，我们打开它的SRC，打开它的代码，你会惊奇的发现，其实这里面的代码总共没有几个类。😊。

啊，它只有那么几个类。第1个keyY6confi很明显就是一些配置。😡，就是我name server，我在启动的时候，我可以设置很多配置，所以它是一个key value的confi。

然后第二个叫做postpost搜是什么呢？啊，post搜就是有请求来了。😊，啊，就是我们刚才所说的。😊，你在这里面是不是要像我namemo server发起topic的注册？然后像我生产者。

还有像consumer。如果说你要去启动的话，你也要从我这里拿取相关的路由。所以我是不是要有一些进程，或者是有一些postso来处理。所以第二个部分就是proso里面也只有两个类，并且还有一个是测试类。

😊，一个集群的测试的类。然后最核心的其实就就是这个deport request错。然后第三个部分叫做remote inform，就是我们相关的路由信息。然后在路由信息里面呢分成了两个部分啊。

一个叫做broker housekeeping啊，这个service，这是我们常说的bro的一些也保持相关的信息。但是最核心的应该是这一个叫做ro in manager。😊，就这样的一个类。

大家可以看到这个类非常非常的大非常非常的长。我给大家解释一下，就是所有的路由注册相关的信息保存的其实最核心的都是这一个管理类。😊，为什么是个管理类呢？因为在这个管理类里面，它定义了很多map。😡。

看到没有？比如说这个地方有个哈y map叫做topicq table，就是我们主题对应的队列信息。然后还有一个叫做broker address table是什么？也是一个哈西 map。

里面存储的是broker相关的信息。好，下面的话，如果你搭建了一个集群。那又有一个m，叫做cast address map。😊，对不对？也是一个哈希麦。然后还有包括我们的一些心跳，哎。

这个地方也有一个哈希麦。还有包括你要去，如果说你要去过滤消息，因为我们刚才讲到这个tg的话，是个二级目，它可以它可以过滤消息。那你也可以设置专门的过滤消息的服务的列表。😊，所以本质上面啊，你可以发现。

其实name server。😡，他有没有进行磁盘的存储？他是一个纯内存的，对不对？就是他除了定义这些map之外，你可以看到。😡，下面。下面这个。给大家看到啊，把它构造出来。😊。

就是调大了调它的这个构造方法的时候，把这个map扭出来，并且new出来的时候，它也会去初始化的容量。就是它不是默认的这个哈西map。因为大家知道默认的这个哈西map一般情况下面，它的数组的长度是多少？

😡，是16。对不对？所以他在new哈西 mapap的时候，因为你要知道一个rockq启动的时候，它的什么Q啊，它的bro address啊，还有包括它的一些心跳相关的信息啊，一些过滤信息它都很大。

所以它 new出哈西 mapap的时候，默认它让它的容量，比如说像它的Q相关的信息是1024。而像它的地址相关的信息是128，而像它的一些什么心跳信息是256，对不对？那除了这个集群啊。

因为集群里面呢一般数量不会太多，所以的话呢它的这个容量就是32。😊，所以大家看到没有？哎，这个地方跟我们平时写代码就有差别了。😊，如果说你是经常去写代码的小伙伴，我你有一个哈信 mapap。

我一定会什么把它的初始容量就这个地方我不会设置。😡，啊，就是如果你能够去预估它的数量。😡，如果有这样的一个业务场景，我建议啊可以把这样的数量设大一点。其实大家知道我在这个业务场景当中。

我把它启动往这个map里面放的肯定是几十上百个数据。那么当然我在第一次初始化的时候，我就把它的容量变大了。😡，去减少我们什么扩容带来的一个开销。好。这个还并不是关键点啊，这个是老李随机点一点的。

其实在这个m的关键点是什么？大家发现没有？它里面提供了很多这种get方法，还有提供了dele的方法，还提供了一些set方法，还提供了一些什么其他7788的方法。

就是我们把这个方法的列表可以拉出来给大家展示一下。😊，它其实本质上面就什么quarral。😡，get对不对？reg还有一些什么remove，还有什么update，还有quarrual。

还有一些什么pink，还有一些什么其他的东东就是。😊。

其实你看一个类看一段代码的时候，你会发现本质上面。😡。

系列 6：P124：RocketMQ源码之CompletableFuture的运用 - 马士兵学堂 - BV1RY4y1Q7DL

这就是最核心的部分，就是name server里面所有的数据都是存在这个地方，并且它都是存在哈西 map里面。😡，那么为什么存耗新卖？为什么不写磁盘呢？😡，对不对？

为什么不像做 keep一样的把它写到我们的磁盘里面？😡，所以你看到这段代码的时候，你要想到为什么在rock conq当中，我要单独去写一个name server。😡，啊，这么长的代码呀，为什么不分文件？

😡，哎，好控制啊，哥们，它叫做我们的manage这个类。就意味着我所有的存储，我就是放一个类里面。😡，好不好？我就用一个类管理不可以吗？😡，就是这个地方我管了所有的map的存储不好吗？😡，啊。

你管其他几个地方的话，我问你一个点。好，如果其他几个点要去加锁，要确保多多线程安全，你怎么办？😡，那是不是在每一个你的管理类里面，你都要去加锁，或者是采用一种一些同步方案，或者采用一些并发安全的方案。

但如果我写在一个类里面，是不是可以统一处理？😊，对不对？这是第一个点。第二个点的话，我好交互啊。😡，比如说有的东西的话，我可能要从另外的信息获取或者另外的信息判断。😊。

中间要去类似于一个完成一个业务查询，就是我提供的功能对外面提供的时候，心跳里面的信息不全。但是我要返回我的客户端，或者返回我的这一个生产者或者是消费者，告诉他这个心跳的一些详情。

那是不是还要结合他跟他进行查询。😊，对不对？如果说在同一个类里面它处理起来方便很多。好，其实这个地方最本质啊给大家说一下关键点是什么？你会发现。😊，name server就是服务的。注册与发现它的存储。

它都是基于哈西m。哈西 map是什么？是内存。啊，就是为什么说roq它快的一个原因，就是因为他对这些服务的路由和注册，它都没有放到磁盘，它都放到内存。所以这是它的第一个原因，比较快。你要抓它的亮点。

抓它的核心点。😊，啊，就是如果你使用的是做keeper，那么它是写文件。但如果这个地方你使用的是一个哈西 map，你写的是内存，那谁快？当然是内存快。😡，对不对？

这就好比说readdis快还是我们的mycyclq快，它是原因是一样的那当然是readdis快。所以为什么我们查询的时候，需要把数据从我们的mycyclq放到readdis呢？是不是很简单？😊。

就是因为内存很快。好，这是第一个。第二个问题来了。😡，大家可以看到回顾一下我这张图，在这张图当中，生产者也好，消费者也好，还有我们的bro也好，对不对？我们是不是可以启动多台，像生产者。

你也可以启动10台，消费者你也可以启动10台，然后他们需要去从我们的namemo server当中拿取信息。同时的话，大家发现没有。在我们bro的时候，我也可以向我的namemo server注册信息。

😊，另外的话呢，我还可以去改变我相关的信息。所以在我们n server这里面保存相关的哈西 map，你是不是会遇到一个问题叫做多线程安全。因为这些API提供出去之后，你可以看到。😡。

每一个方法里面他都没有加锁的。看到没有？每一个方法，无论是查询还是修改还是删除，还是创建，它都没有加锁。那。怎么确保的他的多线程安全？我给大家看了啊。

就是在我的最上面这个地方写了一个它确保多线程安全使用的是一把读写锁。😡，什么叫读写锁呢？其实它就是一对锁。😡，就是我们像GOC的编程里面有一个叫做reentread write knocker啊。

本质上面它属于nock接口。所以呢你把这个锁扭出来，然后通过这个锁，它可以控制下面的各个m在并发读写情况下面的安全。😊，啊，它适合于我们常说的读多写少的这种场景。为什么这个是读多写少？

因为这个name server它是服务的注册与发现。😡，那注册的信息可能在启动的时候，可能在你去增加一个主题的时候，对不对？可能在你发生这种节点之间变化的时候，他才会去进行写进行注册。而读的话。

我只要启动一个生产者，启动一个消费者。那么是不是我就要经常向这里面进行读。所以这个业务叫做读多写少。所以我们可以去搜一下这个n。😊，啊。在这个nock里面。😡，哎，看到没有？

你如果要去删除topic这个地方它就拿到一把解锁了，就是通过通过这个n点rightite lock这个接口，然后调它的n对应的impurity。这个东西就可以拿到一把解锁，就是拿这个解锁的时候。

它会针对我们的写操作。针对我们的读操作全会阻塞。😡，好，当然干完之后记得啊n。好，紧接着再来看。啊，你去拿的时候看到没有？叫做get our topic list，就是拿到所有的主题相关的列表。

这个地方是一把毒锁。😡，啊，这个读锁的话呢，基本上就是他除非遇到我们这把锁里面，对不对？它是一对锁嘛，一个是解锁，一个是读锁。这个读写锁就是一旦有解锁了，那么你就读不行了。但是如果是多个读的话。

它没有冲读，所以它可以确保我们发送时的一个高效。😊，所以这个地方我可以检索一下，很多地方用到了这个。看到没？包括这个地方只要发送，就是你的bro。如果说进行注册，就是你启动了我们刚才所说的。

先启动name server再启动bro。😊，那bro启动的时候，是不是他要调我们的这个regest broker这个地方用到解锁。因为你要去向我们lemon server写数据了，所以在这个地方。😊。

有哪一个系。没错，这个锁把它 copypy出来。😡，那在这个地方我再进行一个灵魂的拷问，好不好？我再拷问一下大家一个问题。为什么要采用读写锁？😡，就是大家知道为什么不采用。

就是在我们name server当中，其实。😊，还有一个数据结构啊，我给大家找一找嗯。😊，啊，有一个康坤的哈希迈普。😊，大家这个东西应该用的多。😊，嗯，conquestent哈西 map。

就是就是为什么不采用它哎。😡，怎么一点的话就卡死了。啊，这个地方比较卡。と。对。东。con困的哈希迈，对不对？我这里面提一个这样的问题啊。😊，就是为什么不采用它。😊，有没有同学有这样的一个疑问。

因为我们学并发编程的时候，你会发现，其实很多情况下面我可以不用锁啊，我解决哈西 mapap的线程安全问题，为什么不用康坤的哈希 mapap，而你要去定一个哈西 mapap普通的，然后外加一把读写锁呢？

😡，ok。😊，同学们。所以我们读原文的时候经常会遇到这些问题啊，我希望你在读原文的时候可以提出这样的质疑。😡，读多写少。如果你是说这样的，读多写少的话，康坤的哈西迈普也没问题，这不是本质的啊。😡。

你没有达到一个关键的点，就是你对康冠的哈西迈他的语言嘛，你也没有读过。😡，Yeah。你要知道，如果你使用读写锁，它可以确保并发的叫做什么一致性，就是读写锁，它可以确保我们的。叫做什么强移制性。😡。

但是如果采用的是康冠纳哈西迈。你要知道一个专业词叫做弱已知性。这是中间有差别的。就是如果你能够把一致性这个问题讲清楚，你才能讲到点。😡，它关键点就是针对这个业务场景，他必须要求的是强移致性的场景。

而不是弱移致性的场景。ok。就是你理解的这种什么康棍的哈希 mapap这些东西里面采用的CAS加什么lock机制啊，我可以告诉大家，其实像康棍的哈希 mapap里面。😊，他没有去实现我们所说的强义执性。

什么叫强义执性呢？就是我们再回回到前面的图。😊，这是我们bro，我们的bro，或者是说你往里面去创建的一些主题。比如说你的conproer或者conser，或者是你后台来了一个控制台，对不对？

你也可以去创建一个topic，或者是删除一个topic，或者是更改一个topic里面的Q相关的信息。好，当然你干了这件事情之后。😊，我们是不是要去改里面的这些哈新m？对不对？

所以这个地方我画出一个在我们nmmo server里面很多的哈希 mapap。😊，而如果说你使用的是con观难还是map就有一个问题了。往里面写的时候，我生产者和消费者是不是还会同时去拿？对不对？

这个地方con官的哈新ap没有保没有保证我们的强一致性，就是你写入的数据，只要写入成功了，你就可以立马拿到。😡，Yeah。就是你去发消息的时候，那别人会说，哎，我这个地方我要创建一个主题，创建完之后。

我立马去调我的生产者。你只要创建成功了，我就发消息，结果说失败了，结果拿不到。😡，是不是有这种可能性？结果从我们的la server里面就拿不到，它就不会去往对应的bro里面去。😡。

发虽然看起来他的并发会更高一点。😡，但是本质上面跟我们的业务长。景他不符合好不好？所以我们平时为什么去读一些源嘛，或者是读一些东东，你会发现哎康官的哈西 map它并不是说多线程在线程安全的场景当中。

一定百分之百用，要看场景。😡，就像这种场景的话，就用一个普通的ac心 map，然后使用这种锁机制，确保我们的一个强意制性。什么叫强意制性？只要写成功了，立马可以读到。😡，OK这个点能够get到的话。

可以给老李刷个6。😊，有没有问题？😊，这个点啊。就是你回答面试题的时候。😊，或者是跟面试官去读解读原嘛的时候啊，说你的这个感受的时候，一定要去说到关键点啊，不是说什么看冠的哈西 map里面的性能更高。

不是这些东西啊，它就是一个所谓的强一致性和弱意致性，强一致性就是。😊，在多线程并发啊。就是多呃并发场景当中啊。😊，场景中只要写了。只要写入了。立马可以读到，这叫强一执性啊。弱一致性的话呢就是说不能确保。

但是可以确保最终可以读到。😊，只要写了。就可以读到。然后这个写了。😊，不一定啊。不一定。可以读到。但是的话呢，他可以确保最终读到。可以确保最终就是最终我可以读到啊。OK这叫做弱移制性啊。

当然站在我们的这一个性能角度来说的话，弱移致性它肯定并发可会更高一点。但是这种场景的话，它必须要使用强硬制性啊，所以强硬制性只有使用锁。那锁的话为了去减少我们锁的一个性能的话。

这个地方就使用的是读写锁OK所以我们通过读源嘛的时候，我们抓它的亮点，好不好？😊，然后装完奈奶之后，紧接着我们再来去讲。就是在我们的刚才的这个过程当中，你会发现，其实这个消息啊，它经过produer。

然后发给我们的broker。而broker请注意一个点。😊，我们下面再来讲几个亮点啊。就是在消息进入到。我们的bro之后。对不对？作为我们的roQ，他最终要把这个消息保存到磁盘。就是卡夫卡也好。

还有像rockq也好，你给他发消息之后，最终他需要把这个消息保存到磁盘。那么关键点就是这个磁盘这个文件它该怎么去设计，这里面是一个非常关键的点。😊，Okay。

就是大家知道像mycycl里面最关键的就是它的文件系统的设计。😊，啊，不单纯是它的一些什么应用层啊，更多的时候涉及到它的一些存储文件的设计，这是mycycl它的一个优势，包括ES它也是。😊。

OK所以在这里面大家可以看到啊。😊，看过的哈心脉不是弱一之性。😊，Yeah。有没有问题啊？你你怎么去抵线？😡，ok。😊，因为它里面没有完全采用锁的机制，好不好？它们里面没有完全采用锁的机制。

它里面是CES机制。😡，对不对？然后里面加锁的话，它也不是全部加锁。😡，ok。😊，内存挂了怎么办？哎，这个问题提的很好啊，有位同学说这个内存挂了怎么办？😡，内存挂了的话，在ro compute里面。

它有配置文件。😡，啊，就是这个地方给大家说一下这个这个name server底下呢，它会有一些jason的配置。😊，就是他除了把这个信息保存到我们的这个哈希 mapap之外啊。

它还会一些jason的配置。然后另外一个点的话，name server它总是先启动的，就是它是一个服务的注册与发现。它的信息来源是什么？是我们bro启动。😊，所以一般来说在bro启动的时候。

就算你之前创建的主题，对不对？这个地方它也有对应的jason来保存我们相关的信息。只要它启动了之后，就要向我们的lemo server发送信信息。所以你要知道，服务的注册与发现中心。

首先它的数据必须要从我们的这一个什么。😊，这个brolock里面来，所以它放到内存里面是没问题的。所以这一块放到一个哈西 mapap里面是没啥问题的。😡，好不好？就是你服务启动的时候。

首先必须要那broer启动往我这里面进行注册，我这些数据才能来，对不对？😊，ok。😊，我自身本身就是一个专门来负责服务与注册与发现的。好，这是刚才一位同学提的点啊，现在紧接着我们要进入第二个点。😊。

就是第二个点给大家怎么去说呢？😊，OK我把一些东西关掉啊，太卡了。😊，太卡了啊。不知道是网络的问题，还是什么其他的问题啊，就是刚才消息进入book的时候，消息要保存到磁盘，这个地方会涉及到文件的设计。

😊，好，文件设计里面我给大家提示一个点，就如说conq。😊，哎，他的早期是完全抄袭卡不卡。Right。这是rockq它的第一个版本啊，就是把卡夫卡全部抄了。卡布卡使用的是scara语言编写。

而roQ使用的java语言编写，就是把它的代码把它复制过来，然后用java版本做了一个重写。所以在它的文件设计里面，它的早期版本。😊，是一样的。啊，但是runq里边呢，它进入它的3。0啊，就是。😊，3。

0的这个版本之后。然后他的文件进行了一个大改。这个大概给大家说一下啊，就是这里。😊，方需要要把一些知识进行普及。这个普及的话呢，我把这一个再调大一点啊，拖下面一点。好。就这个地方。

我把一个卡夫卡把它扭出来啊。卡不卡是怎么做的呢？卡不卡，就是比如你定义了一个主题，比如说叫做topic。😊，在它存储的时候，这个主题下面你对应的有多个队列。ok。这个地方叫做Q。比如说Q。好。😊。

这叫做Q1。Yeah。Q1嗯这个地方可能不好去画这个，用这个东西来画吧，会方便很多啊，然后把这个变大一点。😊，变长一点。然后在卡夫卡里面，它这个名字呢不叫Q1啊，本质上面叫做什么part第。

但是在我们理解里面可以把它理解成Q，比如说Q1、Q2、Q3、Q4、Q5、Q6、Q7、Q8等等之类的啊。😊，在它的一个主题下面，请注意。比如说我这个地方扭出4个Q。😊，这4个Q它都是一个单独的文件。啊。

就是你有一个主题，比如说你这个主题创建出来叫topic A或者是叫李锦的主题。那么在底下你划分出了4个Q的话，那么它就会有4个文件，这是卡夫卡的一个设计。😊，好，那么在roq的早期版本，它也是这么干的。

OK那问题来了，在它的新的版本里面。😊，或者是在他的3。0之后的版本里面，以及3。0的版本里面，他不这么玩了。😡，啊，我我告诉大家他怎么玩，就是他的文件存储里面是这么设计的。我不管你里面有多少个主题。

😡，在我的这一个rockQ里面。OK我不管你底下有多少个主题，我只有一个文件叫做community。😡，Yeah。log这个文件。并且一般来说只会。写一个。Okay。啊，就是这个文件的话。

一般情况下面它只有一个。所以你可以看到它们中间对于数据，然后进到我们磁盘里面，它的处理方式是完全不同的。ok。😊，啊，大家想一下，对比一下卡夫卡，对不对？就相当于。😊，你创建了一个主题。

那么底下有4个队列，那么它就有4个文件。而rock andq的话，我不管你创建100个主题还是1万个主题，它只会去写一个文件。这个文件称之为community log文件。这个文件在哪里呢？😡。

OK我给大家看一下。😊，打开我的磁盘啊，给大家看一看。😊，比如说打开我的。这个叫做roq的一个目录，然后底下有一个stone。这个stone的话呢就是我们ro的存储目录。

然后在这个存储目录里面有一个community log的文件夹。那么我刚。😡。

系列 6：P125：RocketMQ源码之零拷贝技术 - 马士兵学堂 - BV1RY4y1Q7DL

刚才所说的这个come log就是讲的这个文件夹里面的文件。然后这个底下。只有一个就是一个全零的文件，并且这个文件默认的大小是一个G。

OK好，把它复制出来。😊，然后对，放在这里。大家发现没有？😡，就是当我们rockq启动的时候，本质上面，哎，你去写消息的时候，为什么只写到一个文件？😡，啊，请注意，其实这是它设计的一个优化。

就是在卡夫卡里面，它有一个性能瓶颈。什么瓶颈呢？就是当你的这一个主题数量特别多。比如说你的主题达到了100，甚至达到了200，达到了300之后，大家发现没有？卡夫卡里面它不适合于创建非常多的主题。

为什么呢？因为你的文件数量非常非常的多，会降低我们生产的效率。😊，啊，这个就好比我们经常所说的，你要给别人传单代码。😡，专代码里面包含很多的文件夹，很多的文件。如果这个文件夹和文件数量超过100的话。

你把它传给李锦老师，你不打包，请注意意。效率很低。为什么？因为这个网络的开销，这个IO的通道，这个创建的话，它非常的频繁频繁，对不对？😡，啊，就算这个项目它只有几百兆如果你不打包啊。

里面包含了2000个目录，然后每个目录下面有几个类，所以它总共加起来可能有一两千个文件。这个时候你传给我，你不打包的话，我可能不断的在这里进行文件的读取，读取它读取它他他他他他他他它，然后就卡死了啊。

😡，但是如果你打成一个包呢。你给我发的时候，把这个项目打成一个压缩包，你再发给李静老师，是不是效率很高？所以reconq它为什么只会设计一个存储文件，它的原因是什么？😡。

就是它可以满足海量主题下面性能的稳定。而run你Q它应用场景是什么？是阿里的淘宝，还有它的天猫系统，还有像他的什么滴滴之类的，还有像他的一些其他的这种很多的系统。你像这种电商场景当中的淘宝。😡。

或者天猫，哎，他如果要对消息进行分类的话，那分类起码是成百上千，对不对？你比如说把衣服化成一个主题，那么衣服是不是有一个topic？😡，然后把手机化成一个主题，手机有个topic，把电器化成一个主题啊。

把我们的啊这种什么零时，把我们的一些什么啊叫做电脑，还有一些什么大街大家电小家电，还有等等之类的。所以像这种淘宝像这种京东，他们这种电商的话，主题动不动成百上千。而如果再采用卡夫卡这种存储架构的话。

会导致它的消息写入速度很慢。所以呢它就不管你三窍二十一，哪怕里面是100个主题，我都是按照顺序的方式写到这样的一个存储文件，这个存储文件默认情况下面，它就有一个G。😊，Okay。OK那具体怎么写？😊。

具体怎么写？这个地方还要有第二个问题就是。我们做了这个之后，是不是还有一个问题？还有他关心他的性能。大家知道，如果我们去写文件的话。这个地方它会有一个性能瓶颈，这个瓶颈的最核心或者是最关键的点是什么？

😊，ok。你进行IO这个地方它会有涉及到。拷贝问题。哎，这个地方为什么会涉及到拷贝问题？我问大家一个。这样的面试题啊面试题大家有没有听过零拷贝，听过的小伙伴可以刷个一，没有的话可以刷个2。Okay。一。

OK大家有没有听过零拷贝零拷贝这个技术？😊，好，我给大家分析一下，无论是卡夫卡也好，还是rock andQ也好，你一旦要把这个消息把它写到一个文件，或者写到多个文件，它肯定会涉及到IO中间的拷贝问题。

原因在哪里呢？因为本身作为roQ或者作为卡夫卡，它都属于我们中间更大的一个范围。这个范围我们把它称之为。😊，应用。😡，这叫做应用层。啊，这一点我不知道大家能不能理解啊。😊，叫应用层。

那与之对应的还会有一个什么？😡，它会有一个内核。所以我再往下面画。不。这个地方会有一个叫做内核，内核就是我们所说的操作系统，或者我们经常所说的cannel。好，那么我问问大家，在内核里面。

首先作为我们前面这个架构的话，大家发现。无论是生产者也好，还是我们的消费者也好，还是我们的bro也好，还是我们的lemo server也好。😊，啊，这些角色他都是单独部署的。😡，他都是。😡。

属于中间的一个应用啊，一般情况下面，我们的生产者，还有我们的消费者去发消息的话，他肯定不会跟我们的roq在一台机器上面，就是你的roq像它的broer，你把它部署在阿里云服务器上面。

那么我可能是在本地的电脑上面跑了一个produer。或者是我在另外的一台阿里云的服务器上面跑了一个proer。所以我向你去发消息的时候，本质上面就涉及到了网络通讯。😊，网络通讯底层一般来说，TCP。啊。

发消息给你对不对？然后发消息给你的时候，首先站在我们这台机器上面接收这一个消息的肯定是网卡。😊，对不对？比如说有一个消息发过来了，我们称之为叫做。😊，Ser。Message。好，有消息来了。

他他当然首先是进到我们的网卡，然后进到我们网卡的时候，大家可以看到OK。😊，进到网款就结束了吗？😡，网卡里面是不是要读取数据，所以在我们的操作系统内核里面，它还会有一个叫做。😊，内核的。啊。读取缓冲。

好。😊，就是我们所说的这种，你也可以称之为内核的独具缓冲。这个地方要把相关的数据拷贝过来。😊，好。大家可以看到，在这个地方涉及到了一次叫做DMA拷贝。就数据你如果说发送过来的话呢，首先从我们的网卡。

然后跑到我们的内核的读取缓冲区啊，这个地方它会涉及到一次DMA拷贝。然后紧接着数据再要跑到我们的runQ或者跑到我们的卡夫卡，这个地方又会要涉及到一次拷贝，这次拷贝给大家说一下，称之为CPU拷贝。😊。

好，这个地方大家发现没有？一次DMA拷贝，一次CPU拷贝，它才会把我们的数据从网卡送到了我们的roQ的应用，然后送到应用之后。😊，我们干嘛？我们接收它，我们要写文件。哎，那问题来了，这个文件。

我们不能说是应用层的啊。这个文件它要写的话是我们应用程序写段代码，然后获取这个come log。那一般来说它是个fire嘛。它是个文件嘛，那fire点read这个方法，大家知道哎。

你往里面拿到了相关的缓冲区的数据，对不对？这是通过网络来的。网络来了之后的话，这个数据最终是不是要去写写的话，你去调这个fire点read这个方法，或者往里面去写的话。

文件最终其实还是我们的内核来操作的。😊，啊，因为文件最终是交给什么文件系统的驱动来干。所以这个数据的话呢，还需要去经过一次拷贝。啊，这次搞拷贝的话呢，到就叫做什么文件。😊，内核的换出去好。

这个地方它又有一次CPU拷贝。嗯。好，做完这次之后的话。😊，OK它仅仅还只是我们的文件内核的一个拷贝，最终要调什么？要调文件驱动。😡，OK所以这个地方它其实到了文件里面，它还有一次拷贝。

这也是一次DEMA拷贝。就是我们常说啊，很多时候为什么我们不愿意跟文件进行交互？但是站在reQ的角角度来说，我必须要把数据写到文件。因为数据不写到文件，它就会发生丢失。😡，好，这个地方大家可以看到。

像我们就用这个原点表示数据啊，数据然后跑到了网卡。跑到网卡之后的话呢，经过第一次拷贝啊，我的拷贝数量加1。😊，好，然后呢考完这个之后到我们的内核的读取缓冲区，然后到了我们的这一个应用。

就是rockq又进行了第二次拷贝。好，就是数据来了，走了第二次拷贝，拷完之后，因为我的应用的话呢要去调用文件，对不对？我使用文件，然后给它写，所以又会把这个数据从我们的应用，然后传给我们的内核。

然后走了第三次拷贝，然后紧接着。😊，这个数据最重要写入的话，它是不是还要调我们的驱动，文件的驱动，调磁盘的驱动。不这个地方最终这个数据写入要经过4次拷贝。我给大家分析出来啊，以前我在做测试的时候。

这四次拷贝它的开销大概是什么样子？😊，就是当时我测试的时候用了200兆的数据。200兆的数据的话呢，大概。😊，把它做一次DEMA拷贝。啊，就是这200兆的数据。如果经过一次DMA拷贝。

它的耗时大概是2毫秒。很快的啊，但是如果经过了一次CPU拷贝。它的这个耗时大概是在200毫秒左右。啊。就是站在这一个性能角度里面，你会发现其实DMA拷贝是不可怕的，为什么呢？

因为DMA拷贝其实是操作系统站在硬件，它去进减少我们的这一个拷贝的时间。😊，进行了一个优化。但是一旦涉及到了CPU拷贝，它就没有办法优化了。因为这个地方它要涉及到CPU的调度。

所以它的耗时的话呢需要200毫秒。所以我们刚才这四次拷贝给大家算一下，我之前做了测测试的话呢，基本上如果你要去走4次拷贝。😊，大概他需要的这个时间就是404毫秒。啊，因为他有两次DMA也有两次CPU。

OK好，那现在站在这个点，如果是runckQ，对不对？他的开发者的话，他知道每一条消息我最重要写的文件，这个地方我就该采用零拷贝技术优化。😊，注意这个零拷贝技术优化的话，很多同学可能对零拷贝有个误区。

叫什么？零拷贝是不是等于。名次拷贝。答案是不是。啊，这个地方给大家说，零拷贝技术不是零次拷贝。为什么呢？哎，因为你的这个数据的话，它总是要经过内核啊，那操作系统大家知道操作系统是windows也好。

是linux也好，这操作系统它管的内存，然后操作系统上面是不是你还要安装驱动？😡，就是默认情况下面，很多的这种原生的操作系统，它是没有所谓的网卡驱动的，没有所谓的磁盘驱动的啊，一般来说都是给你自带了。

所以这个地方DMA拷贝它是百分之百去不掉的。😊，对所以零拷贝技术它的本质是什么？叫做减少没有必要的。😡，拷贝。大家看一下哪个地方没有必要，好像就是这两次CPU拷贝，没有必要。OK就是这CPU拷贝的话。

我是不是能减少一次。所以在rockQ里边呢，它针对这个叫做com log文件，它会做一个优化，叫做M map。😊，的零拷贝优化。哎，这个Mm给大家说一下啊。😊，本质上面我们经常所说的Mm的零拷贝。

它就是减少的这一次拷贝。这意思。就是减少的中间这一次。OK那看他怎么做的。😡，OK他的处理方式是怎么玩的呢？😊，首先在它文件启动的时候，就是roQ启动的时候，对不对？我知道了文件的目录。

然后知道了这个文件的目录之后，我可以通过一种调用方式，我给大家找圆码。😊，就是在rock andq里面，我们刚才讲到的这一个comity log这个文件大家可以看一下。😊，他有一个专门的类。

跟他同名的类叫做。come log啊，但是往这个com log底下找的时候，你会发现一点，好像这个地方它没有去写存储，它存储的地方是放哪里了？叫一做mify这个东东。好，在这个mify这个东东之后呢。

你可以看到这里面其实本质上面它使用的是m fire文件。😊，啊，就是它里面用到了一个叫做copy on write写实复制的容器容器啊，里面存的是m file。啊，这个怎么去理解啊？

可能很多些看代码的时候会有点晕。我告诉大家。😊，这个comy log。是它的一个叫做什么跟我们保存的文件是个同命类，就是涉及到你专门这个文件的存储。你可以把它比喻成我们经常所说的。啊，这个serv沃斯。

啊，业务层。对不对？然后到了具体的数据处理的时候，我们知道所有的东西他都是写文件。😊，所以他要拉文件的时候，你只要送一个文件名，对不对？比如说你的文件名是零还是一还是2，而是哪个目录下面的012。

你只要告诉我，那剩下是不是可以经过一个包装类叫做mify这个类。而在mify这个类里面，大大家可以看到它提供的构造方法。😡，啊，他有一些有餐的构造方法，所以这个无餐的可以不看。😊。

因为在我们的这个类里面，一般提供的有餐的构造方法，我们就看有餐的。😊，好，这个有餐里面一般送入两个参数，一个叫做faair name文件的名字，一个叫做f size，就是文件的大小。好。

那么我们看到它调它的init这个方法。你会发现就是当我们的一个文件，如果他要去构造的话，他要在我们ro启动的话，一定会去调我们的unitity这个方法。送一个文件，送这个文件的大小。

然后干嘛new出一个fill，因为这一个地方它可能代表的就是cover log这样的一个文件。所以呢他把这个文件扭出来。扭出来之后的话，大家可以看到，为了让它的读写效率更高。😊，他怎么办？

他不是说你拿的这个文件直接往里面进进行读进行写，而是要经过下面的一些骚操作啊。这个操作我们把它称之为Mm的零拷贝技术。也就是说拿到这个文件之后。干嘛？

然后扭出一个readdon access that一个高级类，然后点它的channel方法就可以拿到一个文件通道啊，这个chnel也是通道的意思。所以拿到一个fi china的文件通道。

然后再调这个文件通道里面的点m方法，就是这一段代码，我把它copy出来。😊，然后再放到老李的这张图当中。Okay。😊，啊，把上面提前好不？这图的话还可以往这边放这边放这边放。就是这段代码。

就是在我们rock andQ启动的时候，会干嘛会调这个文件点map方法。如果调了文件点map方法，那么在这个地方，比如说有一个community。😡，log这个文件啊这个fin。Yeah。啊，这个文件。

好，这个文件如果掉了这一个点m方法的话，那么它就可以中间做一个内存映射。啊，中间可以完成一个这样的活。😊，哎，这个地方。你这个地方。完成一个内存映射。好，把这个内存映射了，把它变大变粗。😊，Okay。

啊，完成一个内存映射。这个内存映射意味着什么？中间它就没有这个CPU拷贝了，就没有这个东西了。内存。😊，映射本质上面什么？😡，是两个意思，文件及内存。然后呢，内存即文件。及文件。8。这怎么去理解。

对不对？什么叫做文件及内存内存及文件。😡，大家可能有没有听过一个叫做分页文件的概念？😡，我打开我的电脑给大家展示一下啊。打开我的电脑，我的电脑啊里面有没有高级这个属性，看一下。嗯，高级的系统。设置啊。

好。我给大家展示出来。😊，什么叫做内存映射？就是我们的windows里面，它也有内存映射啊，它的名字叫做虚拟内存。😡，OK叫做虚拟内存。大家可以看到，在我们windows启动的时候啊，他也说了。

它有一块叫做分页文件。我们知道分页文件，它说了是磁盘上的一块区域。但是windows却可以当做RAM当做内存来使用。看到没有？就是当我们的操作系统启动的时候，本质上面像windows也好。

linux也好，很多系统也好，它都支持这样的一个映射技术，就是磁盘及文件啊，磁盘及内存内存及磁盘。😊，就是文件和内存的话，它可以通用。你只要把它进行了映射。这中间它的优势点在于哪里呢？

就是你去往这个地方的内存写的时候，然后他要去写到磁盘，它就会去减少我们刚才所说的中间的一次CPU拷贝，就这一个没有了。看到没有？之前这个地方它有一次CPU拷贝。😊，啊，只是在你启动的时候。

他需要加一个额外的操作。😊，那当然我们rock没有启动的时候，我知道里面就只有那么一个文件。那启动的时候是不是很快？😡，不对，把这个文件把它变成一个内存映射。比如说一个G，那我内存映射一个G。😡，啊。

如果说这个地方的数据不多，我映射512G也可以。那么把这个数据映射完之后的话，当我们收到相关的生产者发送消息的时候，他就只需要进行一次DMA1次CPU再加最后的一次DMA。😊。

对不对？相当于是说我们。

系列 6：P126：RocketMQ源码之Netty的运用 - 马士兵学堂 - BV1RY4y1Q7DL

可以看一下它的效率，就如果采用了这种M map。按照我们之前的这个推算，就是老李做的这样的一个测试，一次DMA2毫秒。😊，然后再加一次DMA2毫秒，再加一次CPU拷贝200等于204毫秒。Yeah。啊。

就是我们如果进行了这种零拷贝技术优化的话，大家发现没有？之前是404。😡，如果没有零拷贝技术，但是如果我们使用的零拷贝技术就变成了204毫秒。所以在这个点是不是可以极大的提高我们的效率？😊。

所以我们通过读原嘛的时候啊。你可以看到在我们的这一个mified的这个init这个方法里面，明显就进进行了零拷贝。然后拷贝完之后，请注意拷贝完之后，这个点m方法。

它就会把刚才的这个文件fi文件和我们的一个叫做map beat buff给它进行一个一一映射。然后映射完之后，我们再点哎，这个地方。😊，哪个地方用到它？哪个地方用到了他呢？我们可以接着往下面走。

看到这里。啊，应该是。往下面走。这是mb fat要到我们的。Community logger， community logger。这是追加。对。啊，往下面走，有一个专门存储。わ下面た。

OK这个找不好找啊，我们换一个思路，好不好？😊，我们再往下面换一个思路，换一个什么样的思路呢？就是刚才讲到我们若。😊，QQ里面。我们讲到了。😊，我们消息的启动流程对不对？我们讲了亮点，中间是内存。

还有包括我们的这一个le server里面呢用到了读写锁。然后作为消息的生产过程，我们讲个过程好不好？就是消息生产过程的话呢，我们先跟个流程，什么流程呢？就是当我们的这一个生产者，如果发送消息的时候。

它中间会通过lay里面的协议啊，它自定义的协议，然后发送到我们的bro。我们bro接收到这个消息之后，是不是要把这个数据写到我们的磁盘。😊，对不对？所以我们就跟这个流程啊。

当然作为生产者中间这个地方它涉及到网络通讯，我们就先把它过掉。我们需要找到的这个出发点就是作为run good broker。😊，他怎么去接触他？所以我们可以找一个这样的类。叫做。Pro搜索。

Requester。Default a request proposal诶。大家看到这个类。啊，大家看到这个类没有，叫做defa request per。哎，这个类代表什么啊？

就是代表我们经常所说有消息来了，我们怎么处理？当然这个类你会发现它是namemo server当中的那肯定不行。😊，Message it。

request proposal default message proposal，然后有一个。往下面找啊。

quaual message proposal应该叫做send message proposal。你去行消息发送嘛。所以我们找到一个跟我们名字差不多的啊，叫做send a message。

其实这个地方我给大家把两个东西copy出来啊。😊，三嗯。找嘞。send message processor大家可以看到这个类的话呢属于rock的bro processor里面提供的。😊，也就是说。

如果你去找目录也比较简单。就在recon的源码里面，我们可以找到它一个包叫做broer。这个包。这个包的话呢就专门负责我们bror的一个相关处理，对不对？然后在里面我们可以找到。😊，嗯。

找到这个目录叫做prooc这个目录啊。然后在这个posts目录里面。就有我们刚才所说的send a message proposal。请注意在这里面呢还有一个叫做que messagepost啊。

就是我把这两个东西给大家贴出来，然后放到我的架构里面。😊。

好，给大家指一下啊，就是最终生产者发送消息的时候，接收到他的这个处理是send message per。因为你要发消息，而如果你是消费者，那么你是不是要去查消息。

所以的话呢它主要的一个类叫做query message per，你去拿消息的时候，就是调我们的query message per。😊，啊，就是通过我们的架构，通们的图，大家知道一个是生产者的入口。

一个是消费者在我们bro的一个入口。好，那找到这个之后，我们紧接着干嘛？😊，就是有消息来了，首先会调它的第一个方法叫做po request，然后里面会带上我们熟悉latey相关的东西的一些参数啊。

因为它网络传输用到的是lay，所以呢lay里面有一个叫做china handle了 contest cTX，然后它消息放哪里了？放它的一个叫做reming command，就是放这个request。😊。

就是一旦说生产者也要发送消息，那么消息就会到我们的bro里面的这个方法里面来啊，中间经过了late体的一些处理啊，就是经过了lateate的一些什么handle，handle handle处理。好。

那经过这个处理之后，大家可以看到。😊，他为了提高性能。大家发现没有？大家平时写代码的时候，有没有这种方式，我去调一个方法，然后拿到这个方法之后，再调它的get这个方法。😊。

这是一种典型的多线程异步调用的方式啊，玩过异步调用的这种方式的同学，可以在公屏上面刷个一啊，没有的话，你可以刷个2。Yeah。ok。😊，啊，在听圆码的各位小伙伴，你们没有玩过多线程异步调用吗？😡。

Okay。而 synchizer request哎，这个地方为什么这么去写？就是你看到这个方法的时候，你觉得有点诡异，根本跟平时写的代码的方式不一样。掉了这个方法，为什么还要掉它的点get？😡。

我是拿response，其实本质上面就是发request的请求，我要去响应response。😡，对不对？😡，然然后紧接着大家往下面走。这个地方跳到哪里？Cotableable future。

就是你在进行方法转跳的时候，你一旦看到里面用到了con future，你就知道这个地方采用的是异步调用。😡，就是这个方法里面，它本身返回的参数应该是一个叫做reming command这样的类型。啊。

但是呢它是通过一个叫做con future来包装的。所以说当我们去调用这个方法的时候，本身就采用了异步的线程调用啊，这个地方交给一个异步线程来处理我这个方法。然后这个方法如果处理完了。

它是不是会返回一个reming command，然后我我我在刚才这个线程里面，比如说有个方法进入我的processor request，我怎么去拿了，调它的点get方法，然后去拿。😊。

就是我的主线程在这个地方启动的时候，是runckq的主线程。😡，对不对？然后一旦转跳进去之后，剩下交给我a synchronizer proposal request的话，它就是子线成的。😡。

然后子线程的话呢就来处理各种东东啊，根据它的消息的类型，对不对？然后可能是批量消息，可能是一般的非批量消息。那么调到我们的a synch said message，然后调这个方法里面。

大家可以看到它所有的名字前面都加了一个a synchron。😊，啊，就说明他是异步的。😡，其实这个在新的版本里面，它全部这么写。但是我告诉大家，在4。6以及4。6以前的版本，它都没有这个as。😊。

就是在新的版本里面，4。7及4。7以后，它全部加了呃sch，全部加了con future。为什么就是为了提高它的性能。😊，啊，包括你可以看到为什么要提高它的性能。因为你如果让主流程参与的话。

里面涉及到很多步骤啊，比如说要去检查读写权限，自动创建topic，对不对？然后调这些东。😊，东西。然后的话呢，如果你发送消息的时候，没有指定你这个消息的QID也要指定一个。还要呢给你这个消息包装一层。

因为我内部的message跟你发过来的mesage，那还是不同的。同时的话呢，如果是死性消息逻辑，那也要进入死性队列，还有包括这些消息头的包装啊，这一个message in里面设置体设置标识。

设置我的诞生时间，设置我的一些存储的host设置我的一些重事消费的时间，对不对？😊，然后干完这个之后，哎还有可能有分布式事务消息的处理，或者是普通消息的处理。普通消息的处理交给谁？到了这步之后。

还要交给存储。😊，因为你消息最终是不是要进入到文件，所以通过bro controlt拿到它的messagestone，然后再调它的a synchizer to message。就是到了下面的步骤。

全部走异步，就是你消息传导的时候，全部用conemp future来传导。😡，然后传到这里之后，进入default M。叫做message stone。请注意啊。进入这个地方之后。

大家可以看到我把这个东西截出来。😊，ok。截出来啊。这个地方有点不同的。😡，有什么不同呢？就是从我们刚才所说的都是bro类。现在它进入了另外一个组件，叫做runckq杠stone。😡。

就是他有一个专门负责存储的类，这个存储类的入口是default message stone。😊，啊，就是你要知道，其实在我们的。Rucking cute。刚才给大家画的这个架构里面，在每一个bro底下。

或者在它的里面，或者在它的这个复数里面，它还有一个s。😊，存储。啊，一个这样的组件。好，那么这个存储的组件干嘛？我们接着可以掉进去。掉进去了，前面的这个参数都是conable future。

为了去提高我们的效率。好，请接着往下面走。😊，往下面走，大家可以看到前面这些东西都是if else，就是if的判断是说如果中间发生了异常，对不对？你不O，那当然就直接把异常信息抛出来。

或者是检查的时候发现你的这个消息的参数不合不合理，也把这个相关的消息抛出来。对不对？然后紧接着最终它会进入com log里面的消息处理流程。

就是我们所说的消息的生产所有的东西它都会进入一个同名的类叫做com log这个类，然后调它的a synchizer put message这个方法。好，那么再调进去。😊，再掉进去之后的话。

你会发现本质上面都是什么？再把消息去加一些参数，就是你送过来的这个message，我还要加一些时间戳，加一些CRC的校验，防篡改，对不对？甚至我还要去上监控系统收集数据，还有包括一些延时消息的处理。

事物消息的处理，啊，这个意服可以过掉，然后最终。😊。

通过这个东东叫做this点mifierqget lastifier，就是拿最近的一个comelog文件。😡，哎，为什么说拿最近的一个comme log文件呢？😡，再回来。😊。

这个common log默认情况下面，在我bro conq创建的时候是一个G。

但是大家要注意了，就是在我们启动之后，我不断的往roq里面发消息，发消息发消息，这一个既满了会怎么样呢？它又会去创建一个这样的文件。只是说这个文件的话呢，它不会是全部是0，那可能是什么007啊。

可能是这样的一个数字，这个地方它代表的是偏一亮。😊，就是在我们消息的偏移量。啊，这个偏一量叫做消息的起起始啊启始。啊，就是你第一条消息，你起始的偏移量，而前面这个文件为什么是零？😡。

因为你还没有数据过来，所以第一个文件它叫00000。当你如果说这个地方写的最大一条消息是712311，那么它的下一个文件就叫做712312。😊，对不对？我就比你多那么一个偏移量。

然后接着往这里面写写写写。所以在ro设计里面，它始终只会取一个最新的最近的。😊，就是如果这个文件写完了，那么最近呢就会变成另外再新建了。😊，所以我在写的时候，我始终只会写一个。

那这个东西历史文件它只可能查了，但是不可能写了。😡，OK就是你查的时候，如果说要去拿消息，那还可以查到。但是如果说你要写的话。😊，金增的全部会放到另外新建的一个G的文件。好，就是默认创建一个G。

如果一个G写满了，再写一个G，一个G再写满了，再写一个G，对不对？所以随着我们roQ，如果说你在生产当中消息特别多，你会发现com log里面它并不是只有一个，可能有两三个，可能有上十个，但是没有关系。

😊，他始终只有一个活跃。

啊，所以在我们这段代码里面，大家可以看到。😊，当我们拿到这个。他们log之后。大家可以看到这个地方去调呃 synizer to message对不对？然后拿到最近的一个m fan，拿到这个之后的话。

还要加锁。😊，哎，这个地方又会涉及到并发编程当中的锁了，为什么？因为我们。😡，传过来的它都是异步调用，可以多个线程进入我们的方法。我们在前面看到它没有任何的锁，包括方法前面包括方法的代码快，它都没有锁。

😡，为什么没有锁？高并发架构就不应该上锁。😡，就是同学们有过经验啊，就是你如果说你想写一个架构，就轻易的不要在一个方法前面加锁，不要什么加schizer，不要加ner，好不好？原因在哪里？

就是当你如果把这个东西干完之后，哎，在关键部分加锁，你要开始写文件了，已经拿到这一个文件了，我要进行写入，对不对？进行写入的时候，其实很简单，因为m前面经过了零拷贝，所以。😊。

一在你写入之前点nock方法上把锁。然后干完这些事情之后，在finally代码里面unlook解锁标准的look锁的方式。啊，这个地方一定要写到finner里的代码块里面。😊，因为他有可能会抛异常。

如果你不写在这个地方会有思索问题。好，在代码当中的话，我们再来看。😊，这个地方叫做append message，就是进行消息的写入了啊。😊，这个步骤我们可以先不管。

但是你会发现我这个地方包括它的原版的代码里面就写了一个叫做splink orreent knock。😡，然后取决于存储的配置，depending on stone configure什么意思呢？

就是这把锁的话，还不是你想的locker锁。为什么它叫做自悬或者是可重入所，可以中间选择一个。那这个锁是怎么出来的？我们可以看一下它的定义，在这里定义的。😊，那这里定义的话，必然会在它的构造方法里面。

同名的com log这个构造方法里面把它初始化。😊，啊，所以前面快速过，然后找到最后。看到这段代码。诶。😊，这个put message knock就是去写消息的锁。😡，他通过一个配置文件。

然后这个配置文件的名字叫做is user reent not when put message。啊，比较长啊比较的中式英文啊叫做你是不是使用reentn。当你去写消息的时候，然后我可以告诉你。

这个地方的配置值默认的是forth。哎，看到没有？就是你不去配的话，没关系，它默认里面就是个forse。那for的话就意味着默认情况下面就不使用reent knock，而使用什么？

而使用这个叫做put message speak knock。😡，诶，你会发现。本质这个地方它不是reentern的锁，而是一个自选锁。看到没有？

这个put messagepin knock是用来干嘛的？😡，它虽然实现了一个put message的接口里面有lock方法啊lock方法，但是他在写的时候用了一个atomicbuing。

用了一个原子操作类。这个原子操作类默认情况下面是te。我去加锁的时候，那么这个时候我来进行一次比较和交换。针对这个原子操作类，如果比较和交换，期望你的值是te，我就把它改成force。😊，好。

改成forth之后，我这次循环就结束了。如果说改不成功怎么办？再来丢看到没有？这个地方有一个外的取反判断。😊，就这个地方的话，如果我的flag变成force就结束了，就说明你已经拿到锁了。

如果这个值是错的话，说明没有抢到锁，它就会在这里自旋自悬。😊，所以这个地方要注意啊，就是它实现锁的方式，它也是通过配置文件。😊，这种锁的话呢，我们不能称之为锁，因为它是无锁化的机制。

叫做CAScompare and swipe。

这个地方是个典典型的compar andwipe。啊，compare and swipe叫做compare and sit。啊，swipe的话呢是基本数据类型啊，如果说你是一个sit的话呢。

就是一个我们的啊buing值，它是一个大写的buoling值。OK所以这个地方它都可以。好，那通过这样的设置，大家发现为什么这么做，很简单，就这个地方它可以去减少。😊，上下文切换。OK请记住这一点啊。

就是我们。😊。

看源码，看代码的时候，我们非常注重的一点就是性能。😊，因为run它能够成为一个阿帕奇的顶级项目，我再去往这个文件里面写的时候，请注意我们拖到上面。😡，拖到这边，把它变小，把它变粗。看到没有？

我去写一个文件的时候，如果我去加一个n锁标准的reentn。它会涉及到上下文切换，并且这把锁的频率是非常非常高的。为什么？因为我只有一个文件。😡，生产者我有10个，有100个，我往里面写的话。

都要去抢这把锁。那抢这把锁的话，那必然竞争很激烈。所以为了去减少我们的上下文切换的话，这个地方使用到的是CAS机制。😡，所以本质上面你看ro个源码，我建议你可以把多线程的知识补一补，像什么锁的知识啊。

像什么哈西 mapap的知识啊，对不对？还有像一些我们的这个底层相关的知识。如果你能够补好的话，你读它的源码会轻松很多。😊。

Okay。