皮皮网

1.【解UE4源码】AI行为树系统 其二 一棵行为树是图解图文怎么被运行起来的
2.C语言的编译过程是怎样的？
3.图解+源码讲解 Nacos 客户端动态监听配置机制
4.OAuth2.0原理图解：第三方网站为什么可以使用微信登录
5.我下载了一个网站源码，现在本地安装测试一下，源码源码但是网站不知道怎么安装。。图解图文。源码源码。网站源码安装dns。图解图文。源码源码
6.火爆github的网站《Hello 算法》，动画图解无痛学习数据结构！图解图文

【解UE4源码】AI行为树系统 其二 一棵行为树是源码源码怎么被运行起来的

       让我们深入理解UE4中AI行为树的运行机制。首先，网站行为树的图解图文运行流程大致分为以下几个步骤：

发起执行: 可以通过AAIController::RunBehaviorTree()函数或Run Behavior任务节点启动新树。

抽象逻辑理解: 从Run Behavior任务节点出发，源码源码关键在于OwnerComp.PushInstance(*BehaviorAsset)，网站这涉及子树的监控和结束条件。

检查与加载: 在运行前，UBehaviorTreeComponent会对子树资源、全局UBehaviorTreeManager、发起节点的父节点意愿进行检查。只有当所有条件满足，才会加载行为树资源。

内存计算与初始化: 加载后，通过FNodeInitializationData计算节点的执行顺序、内存需求，注入顶层decorator，然后设置初始值和内存偏移。

实例化与缓存: 将计算结果的树模板存入缓存，供后续使用。加载完成后，行为树实例会被添加到InstanceStack并标记为活跃。

       新树加载并初始化完毕后，执行流程开始于根节点的服务调用和根节点的执行。每个节点的详细运行机制会在后续内容中进一步探讨。理解这些步骤有助于我们更好地掌握行为树的控制和执行逻辑。

C语言的编译过程是怎样的？

       C语言编译过程详解

       C语言的编译链接过程是要把我们编写的一个C程序(源代码)转换成可以在硬件上运行的程序(可执行代码)，需要进行编译和链接。编译就是把文本形式源代码翻译为机器语言形式的目标文件的过程。链接是把目标文件、操作系统的启动代码和用到的库文件进行组织形成最终生成可执行代码的过程。过程图解如下：

       从图上可以看到，整个代码的编译过程分为编译和链接两个过程，编译对应图中的大括号括起的部分，其余则为链接过程。

       一、编译过程

       编译过程又可以分成两个阶段：编译和汇编。

       1、编译

       编译是读取源程序(字符流)，对之进行词法和语法的分析，将高级语言指令转换为功能等效的汇编代码，源文件的编译过程包含两个主要阶段：

       第一个阶段是预处理阶段，在正式的编译阶段之前进行。预处理阶段将根据已放置在文件中的预处理指令来修改源文件的内容。如#include指令就是一个预处理指令，它把头文件的内容添加到.cpp文件中。这个在编译之前修改源文件的方式提供了很大的灵活性，以适应不同的计算机和操作系统环境的限制。一个环境需要的代码跟另一个环境所需的代码可能有所不同，因为可用的硬件或操作系统是不同的。在许多情况下，可以把用于不同环境的代码放在同一个文件中，再在预处理阶段修改代码，使之适应当前的游资源码下载环境。

       主要是以下几方面的处理：

       (1)宏定义指令，如 #define a b。

       对于这种伪指令，预编译所要做的是将程序中的所有a用b替换，但作为字符串常量的 a则不被替换。还有 #undef，则将取消对某个宏的定义，使以后该串的出现不再被替换。

       (2)条件编译指令，如#ifdef，#ifndef，#else，#elif，#endif等。

       这些伪指令的引入使得程序员可以通过定义不同的宏来决定编译程序对哪些代码进行处理。预编译程序将根据有关的文件，将那些不必要的代码过滤掉

       (3) 头文件包含指令，如#include "FileName"或者#include <FileName>等。

       在头文件中一般用伪指令#define定义了大量的宏(最常见的是字符常量)，同时包含有各种外部符号的声明。采用头文件的目的主要是为了使某些定义可以供多个不同的C源程序使用。因为在需要用到这些定义的C源程序中，只需加上一条#include语句即可，而不必再在此文件中将这些定义重复一遍。预编译程序将把头文件中的定义统统都加入到它所产生的输出文件中，以供编译程序对之进行处理。包含到C源程序中的头文件可以是系统提供的，这些头文件一般被放在/usr/include目录下。在程序中#include它们要使用尖括号(<>)。另外开发人员也可以定义自己的头文件，这些文件一般与C源程序放在同一目录下，此时在#include中要用双引号("")。

       (4)特殊符号，预编译程序可以识别一些特殊的符号。

       例如在源程序中出现的LINE标识将被解释为当前行号(十进制数)，FILE则被解释为当前被编译的C源程序的名称。预编译程序对于在源程序中出现的这些串将用合适的值进行替换。

       预编译程序所完成的基本上是对源程序的“替代”工作。经过此种替代，生成一个没有宏定义、没有条件编译指令、没有特殊符号的输出文件。这个文件的含义同没有经过预处理的源文件是相同的，但内容有所不同。下一步，此输出文件将作为编译程序的输出而被翻译成为机器指令。

       第二个阶段编译、优化阶段。经过预编译得到的输出文件中，只有常量；如数字、字符串、变量的定义，以及C语言的关键字，如main,if,else,for,while,{ ,}, +,-,*,\等等。

       编译程序所要作得工作就是通过词法分析和语法分析，在确认所有的指令都符合语法规则之后，将其翻译成等价的中间代码表示或汇编代码。

       优化处理是编译系统中一项比较艰深的技术。它涉及到的问题不仅同编译技术本身有关，而且同机器的硬件环境也有很大的关系。优化一部分是对中间代码的优化。这种优化不依赖于具体的母婴用品网站源码计算机。另一种优化则主要针对目标代码的生成而进行的。

       对于前一种优化，主要的工作是删除公共表达式、循环优化(代码外提、强度削弱、变换循环控制条件、已知量的合并等)、复写传播，以及无用赋值的删除，等等。

        后一种类型的优化同机器的硬件结构密切相关，最主要的是考虑是如何充分利用机器的各个硬件寄存器存放的有关变量的值，以减少对于内存的访问次数。另外，如何根据机器硬件执行指令的特点(如流水线、RISC、CISC、VLIW等)而对指令进行一些调整使目标代码比较短，执行的效率比较高，也是一个重要的研究课题。

       2、汇编

       汇编实际上指把汇编语言代码翻译成目标机器指令的过程。对于被翻译系统处理的每一个C语言源程序，都将最终经过这一处理而得到相应的目标文件。目标文件中所存放的也就是与源程序等效的目标的机器语言代码。目标文件由段组成。通常一个目标文件中至少有两个段：

       代码段：该段中所包含的主要是程序的指令。该段一般是可读和可执行的，但一般却不可写。

       数据段：主要存放程序中要用到的各种全局变量或静态的数据。一般数据段都是可读，可写，可执行的。

       UNIX环境下主要有三种类型的目标文件：

       (1)可重定位文件

       其中包含有适合于其它目标文件链接来创建一个可执行的或者共享的目标文件的代码和数据。

       (2)共享的目标文件

       这种文件存放了适合于在两种上下文里链接的代码和数据。

       第一种是链接程序可把它与其它可重定位文件及共享的目标文件一起处理来创建另一个 目标文件；

       第二种是动态链接程序将它与另一个可执行文件及其它的共享目标文件结合到一起，创建一个进程映象。

       (3)可执行文件

       它包含了一个可以被操作系统创建一个进程来执行之的文件。汇编程序生成的实际上是第一种类型的目标文件。对于后两种还需要其他的一些处理方能得到，这个就是链接程序的工作了。

       二、链接过程

       由汇编程序生成的目标文件并不能立即就被执行，其中可能还有许多没有解决的问题。

       例如，某个源文件中的函数可能引用了另一个源文件中定义的某个符号(如变量或者函数调用等)；在程序中可能调用了某个库文件中的函数，等等。所有的这些问题，都需要经链接程序的处理方能得以解决。

       链接程序的主要工作就是将有关的目标文件彼此相连接，也即将在一个文件中引用的符号同该符号在另外一个文件中的定义连接起来，使得所有的这些目标文件成为一个能够被操作系统装入执行的统一整体。

       根据开发人员指定的同库函数的链接方式的不同，链接处理可分为两种：

       (1)静态链接

       在这种链接方式下，函数的代码将从其所在地静态链接库中被拷贝到最终的可执行程序中。这样该程序在被执行时这些代码将被装入到该进程的虚拟地址空间中。静态链接库实际上是一个目标文件的集合，其中的每个文件含有库中的一个或者一组相关函数的代码。

       (2) 动态链接

       在此种方式下，函数的代码被放到称作是动态链接库或共享对象的某个目标文件中。链接程序此时所作的只是在最终的可执行程序中记录下共享对象的名字以及其它少量的登记信息。在此可执行文件被执行时，surf算法matlab源码动态链接库的全部内容将被映射到运行时相应进程的虚地址空间。动态链接程序将根据可执行程序中记录的信息找到相应的函数代码。

       对于可执行文件中的函数调用，可分别采用动态链接或静态链接的方法。使用动态链接能够使最终的可执行文件比较短小，并且当共享对象被多个进程使用时能节约一些内存，因为在内存中只需要保存一份此共享对象的代码。但并不是使用动态链接就一定比使用静态链接要优越。在某些情况下动态链接可能带来一些性能上损害。

       我们在linux使用的gcc编译器便是把以上的几个过程进行捆绑，使用户只使用一次命令就把编译工作完成，这的确方便了编译工作，但对于初学者了解编译过程就很不利了，下图便是gcc代理的编译过程：

       从上图可以看到：

       预编译

       将.c 文件转化成 .i文件

       使用的gcc命令是：gcc –E

       对应于预处理命令cpp

       编译

       将.c/.h文件转换成.s文件

       使用的gcc命令是：gcc –S

       对应于编译命令 cc –S

       汇编

       将.s 文件转化成 .o文件

       使用的gcc 命令是：gcc –c

       对应于汇编命令是 as

       链接

       将.o文件转化成可执行程序

       使用的gcc 命令是： gcc

       对应于链接命令是 ld

       总结起来编译过程就上面的四个过程：预编译、编译、汇编、链接。了解这四个过程中所做的工作，对我们理解头文件、库等的工作过程是有帮助的，而且清楚的了解编译链接过程还对我们在编程时定位错误，以及编程时尽量调动编译器的检测错误会有很大的帮助的。

       是否可以解决您的问题？

图解+源码讲解 Nacos 客户端动态监听配置机制

       图解+源码讲解 Nacos 客户端动态监听配置机制

       在人生中第一要紧的是发现自己。为了这个目的，各位时常需要孤独和深思 —— 南森 Nacos 源码分析系列相关文章

       从零开始看 Nacos 源码环境搭建

       图解+源码讲解 Nacos 客户端发起注册流程

       图解+源码讲解 Nacos 服务端处理注册请求逻辑

       图解+源码讲解 Nacos 客户端下线流程

       图解+源码讲解 Nacos 服务端处理下线请求

       图解+源码讲解 Nacos 客户端发起心跳请求

       图解+源码讲解 Nacos 服务端处理心跳请求

       图解+源码讲解 Nacos 服务端处理配置获取请求

       图解+源码讲解 Nacos 客户端动态监听配置机制

NacosConfigAutoConfiguration

       我们看到这里面其实注入了一个 Nacos 配置刷新的关键 NacosContextRefresherBean

@Configuration@ConditionalOnProperty(name?=?"spring.cloud.nacos.config.enabled",?matchIfMissing?=?true)public?class?NacosConfigAutoConfiguration?{ //?Nacos?配置属性@Beanpublic?NacosConfigProperties?nacosConfigProperties(ApplicationContext?context)?{ if?(context.getParent()?!=?null&&?BeanFactoryUtils.beanNamesForTypeIncludingAncestors(context.getParent(),?NacosConfigProperties.class).length?>?0)?{ return?BeanFactoryUtils.beanOfTypeIncludingAncestors(context.getParent(),NacosConfigProperties.class);}return?new?NacosConfigProperties();}//?Nacos?配置刷新属性@Beanpublic?NacosRefreshProperties?nacosRefreshProperties()?{ return?new?NacosRefreshProperties();}//?Nacos?刷新历史@Beanpublic?NacosRefreshHistory?nacosRefreshHistory()?{ return?new?NacosRefreshHistory();}//?Nacos?配置管理@Beanpublic?NacosConfigManager?nacosConfigManager(NacosConfigProperties?nacosConfigProperties)?{ return?new?NacosConfigManager(nacosConfigProperties);}//?Nacos?配置刷新@Beanpublic?NacosContextRefresher?nacosContextRefresher(NacosConfigManager?nacosConfigManager,NacosRefreshHistory?nacosRefreshHistory)?{ return?new?NacosContextRefresher(nacosConfigManager,?nacosRefreshHistory);}}NacosContextRefresher 配置中心刷新public?NacosContextRefresher(NacosConfigManager?nacosConfigManager,NacosRefreshHistory?refreshHistory)?{ //?获取配置属性信息this.nacosConfigProperties?=?nacosConfigManager.getNacosConfigProperties();//?刷新历史this.nacosRefreshHistory?=?refreshHistory;//?获取配置服务this.configService?=?nacosConfigManager.getConfigService();//?是否开启刷新，是truethis.isRefreshEnabled?=?this.nacosConfigProperties.isRefreshEnabled();}获取配置服务 getConfigService

       nacosConfigManager.getConfigService()，这行代码其实就是为了创建 NcaosConfigService 对象，我们看看你是怎么创建的，其实核心代码就是通过 NacosFactory 反射创建的 NcaosConfigService 对象，这个对象是一个核心对象后续会讲到的

public?static?ConfigService?createConfigService(Properties?properties)?throws?NacosException?{ try?{ //?加载?NacosConfigService?类Class<?>?driverImplClass?=?Class.forName("com.alibaba.nacos.client.config.NacosConfigService");//?获取构造器Constructor?constructor?=?driverImplClass.getConstructor(Properties.class);//?创建实例ConfigService?vendorImpl?=?(ConfigService)?constructor.newInstance(properties);return?vendorImpl;}?catch?(Throwable?e)?{ throw?new?NacosException(NacosException.CLIENT_INVALID_PARAM,?e);}}监听器

       NacosContextRefresher 实现了 ApplicationListener ，一看这就是一个监听器了，我们看看这个在监听器里面做了什么操作

@Overridepublic?void?onApplicationEvent(ApplicationReadyEvent?event)?{ //?这是一个?CAS?操作，只设置一次if?(this.ready.compareAndSet(false,?true))?{ //?注册?Nacos?监听器对于应用this.registerNacosListenersForApplications();}}注册 Nacos 监听/**

       register Nacos Listeners. 注册Nacos监听器 */ private void registerNacosListenersForApplications() { // 默认是 true if (isRefreshEnabled()) { // 遍历Nacos属性资源中心 for (NacosPropertySource propertySource : NacosPropertySourceRepository .getAll()) { if (!propertySource.isRefreshable()) { continue; } // 获取资源ID ?String dataId = propertySource.getDataId(); // 通过组和 dataId 注册 Nacos 监听器 registerNacosListener(propertySource.getGroup(), dataId); } } }

       private void registerNacosListener(final String groupKey, final String dataKey) { // 构建 Key 信息 String key = NacosPropertySourceRepository.getMapKey(dataKey, groupKey); // 在 listenerMap中放入了 key 对应 AbstractSharedListener 响应的方法 Listener listener = listenerMap.computeIfAbsent(key, lst -> new AbstractSharedListener() { @Override public void innerReceive(String dataId, String group, String configInfo) { // 刷新次数 refreshCountIncrement(); // 记录刷新历史，就是改变历史 nacosRefreshHistory.addRefreshRecord(dataId, group, configInfo); // 发布刷新事件 applicationContext.publishEvent( new RefreshEvent(this, null, "Refresh Nacos config")); } }); // 向配置服务中添加监听器 configService.addListener(dataKey, groupKey, listener);

       }

####?向配置服务中添加监听器&nbsp;&nbsp;&nbsp;&nbsp;此时调用的是?NacosConfigService?中的?addListener?方法，但是最终执行的还是?ClientWorker?中的?addTenantListeners?方法，后面会进行分析?ClientWorker?这个类的```java@Overridepublic?void?addListener(String?dataId,?String?group,?Listener?listener)?throws?NacosException?{ //?这个?ClientWorker?worker?也是一个核心类worker.addTenantListeners(dataId,?group,?Arrays.asList(listener));}构建 CacheData 信息

       此时向 ClientWorker 中的 CacheData 中添加数据，之后遍历监听器添加到 CacheData 中

创建 CacheData 对象public?CacheData(ConfigFilterChainManager?configFilterChainManager,?String?name,?String?dataId,?String?group,String?tenant)?{ //?dataId?不能为空if?(null?==?dataId?||?null?==?group)?{ throw?new?IllegalArgumentException("dataId="?+?dataId?+?",?group="?+?group);}this.name?=?name;this.configFilterChainManager?=?configFilterChainManager;this.dataId?=?dataId;?//?设置dataIdthis.group?=?group;?//?设置组信息this.tenant?=?tenant;?//?设置租户listeners?=?new?CopyOnWriteArrayList<ManagerListenerWrap>();?//?装饰器集合this.isInitializing?=?true;//?加载缓存数据从本地磁盘this.content?=?loadCacheContentFromDiskLocal(name,?dataId,?group,?tenant);//?计算本地缓存信息的MD5this.md5?=?getMd5String(content);}向 CacheData 中添加数据public?void?addTenantListeners(String?dataId,?String?group,List<?extends?Listener>?listeners)throws?NacosException?{ //?DefaultGroupgroup?=?null2defaultGroup(group);String?tenant?=?agent.getTenant();?//?是?""//?向缓存数据中添加监听器CacheData?cache?=?addCacheDataIfAbsent(dataId,?group,?tenant);for?(Listener?listener?:?listeners)?{ cache.addListener(listener);}}public?CacheData?addCacheDataIfAbsent(String?dataId,?String?group,?String?tenant)throws?NacosException?{ //?获取Key信息String?key?=?GroupKey.getKeyTenant(dataId,?group,?tenant);//?在缓存?Map?中获取缓存数据CacheData?cacheData?=?cacheMap.get(key);//?如果不为空的情况下那么就返回，如果为空那么就创建一个?CacheDataif?(cacheData?!=?null)?{ return?cacheData;}//?创建一个?CacheData?cacheData?=?new?CacheData(configFilterChainManager,?agent.getName(),dataId,?group,?tenant);//?将创建好的?cacheData?放入缓存?Map?中CacheData?lastCacheData?=?cacheMap.putIfAbsent(key,?cacheData);//?如果缓存数据为空的话那么从配置中心拉取，不过此时不为空if?(lastCacheData?==?null)?{ //fix?issue?#?if?(enableRemoteSyncConfig)?{ String[]?ct?=?getServerConfig(dataId,?group,?tenant,?L);cacheData.setContent(ct[0]);}//?计算任务IDint?taskId?=?cacheMap.size()?/?(int)?ParamUtil.getPerTaskConfigSize();//?设置任务IDcacheData.setTaskId(taskId);lastCacheData?=?cacheData;}//?缓存数据初始化完成//?reset?so?that?server?not?hang?this?checklastCacheData.setInitializing(true);LOGGER.info("[{ }]?[subscribe]?{ }",?agent.getName(),?key);MetricsMonitor.getListenConfigCountMonitor().set(cacheMap.size());//?返回最新的缓存数据return?lastCacheData;}

       到这里 CacheData 对象 和 cacheMap 集合已经构建完成了，后续会用到这个数据的

NacosConfigService 分析

       NacosConfigService这个类在创建的时候主要做了什么事情,这这里面创建了一个 ClientWorker对象，这个对象是一个核心的类，有关于配置的一些操作都是归功于 ClientWorker类

public?NacosConfigService(Properties?properties)?throws?NacosException?{ ......this.agent?=?new?MetricsHttpAgent(new?ServerHttpAgent(properties));this.agent.start();//?核心工作类this.worker?=?new?ClientWorker(this.agent,this.configFilterChainManager,?properties);}核心配置类 ClientWorker

       分析一下这个类都在做什么事情，都有哪些核心方法 其实能看到里面有一个构造函数、添加缓存数据、添加监听器、检查配置中心相关方法、获取服务配置、解析数据响应、移除缓存数据、删除监听器以及 shutdown方法

构造函数

       看到这里其实看到了定义了两个调度线程池，一个是用于配置检测的，一个是用于执行长轮询服务的

@SuppressWarnings("PMD.ThreadPoolCreationRule")public?ClientWorker(final?HttpAgent?agent,final?ConfigFilterChainManager?configFilterChainManager,?final?Properties?properties){ this.agent?=?agent;this.configFilterChainManager?=?configFilterChainManager;//?初始化操作init(properties);//?定义一个调度线程池，只有一个线程还是守护线程this.executor?=?Executors.newScheduledThreadPool(1,?new?ThreadFactory()?{ @Overridepublic?Thread?newThread(Runnable?r)?{ Thread?t?=?new?Thread(r);t.setName("com.alibaba.nacos.client.Worker."?+?agent.getName());t.setDaemon(true);return?t;}});//?定义一个多个线程的调度线程池，线程个数和CPU?核心数有关，也是守护线程，是一个长轮询this.executorService?=?Executors.newScheduledThreadPool(Runtime.getRuntime().availableProcessors(),?new?ThreadFactory()?{ @Overridepublic?Thread?newThread(Runnable?r)?{ Thread?t?=?new?Thread(r);t.setName("com.alibaba.nacos.client.Worker.longPolling."?+agent.getName());t.setDaemon(true);return?t;}});//?定义一个定时的调度任务，第一次执行的时候延时1毫秒，后续毫秒调度一次this.executor.scheduleWithFixedDelay(new?Runnable()?{ @Overridepublic?void?run()?{ try?{ //?检查配置信息方法checkConfigInfo();}?catch?(Throwable?e)?{ LOGGER.error("["?+?agent.getName()?+?"]?"+?"[sub-check]?rotate?check?error",?e);}}},?1L,?L,?TimeUnit.MILLISECONDS);}检查配置服务方法

       这个 cacheMap 包含了一些任务信息，这里面的任务是怎么来的呢，他是在添加监听器的时候添加的，上面已经分析过了

public?NacosContextRefresher(NacosConfigManager?nacosConfigManager,NacosRefreshHistory?refreshHistory)?{ //?获取配置属性信息this.nacosConfigProperties?=?nacosConfigManager.getNacosConfigProperties();//?刷新历史this.nacosRefreshHistory?=?refreshHistory;//?获取配置服务this.configService?=?nacosConfigManager.getConfigService();//?是否开启刷新，是android视频录制源码truethis.isRefreshEnabled?=?this.nacosConfigProperties.isRefreshEnabled();}0长轮询任务 LongPollingRunnable

OAuth2.0原理图解：第三方网站为什么可以使用微信登录

       假设小明开发了一个A网站，需要支持微信登录和淘宝账号登录。如果你是微信或者淘宝开发人员，你会怎么设计这个功能？本文结合淘宝开放平台官方文档以淘宝账号为例。

       从最简单视角去思考，用户在网站A输入淘宝用户名和密码，网站A调用淘宝接口校验输入信息，校验通过则登陆成功，整体流程如下图：

       上述思路存在什么问题？最显著问题就是信息安全问题。问题第一个方面是用户需要将淘宝用户名和密码输入网站A，这样会带来用户名和密码泄露风险。问题第二个方面是如果用户不信任网站A，那么也不会输入淘宝用户名和密码，影响网站A业务开展。

       OAuth是一种流行标准。如果执行这行这个标准，那么用户可以在不告知A网站淘宝用户名和密码情况下，使用淘宝账号登陆A网站。

       目前已经发展到OAuth2.0版本，相较于1.0版本更加关注客户端开发者简易性，而且为桌面应用、web应用、手机设备提供专门认证流程。

       OAuth2.0标准定义了四种角色：

       四种角色交互流程：

       本文场景对应四种角色：

       OAuth2.0标准定义了以下四种授权模式：

       四种授权模式中最常用的是授权码模式，例如微信开发平台文档介绍对于网站应用微信OAuth2.0授权登录目前支持授权码模式，所以本文只介绍授权码模式，后续文章会详细比较四种模式。

       第一个流程是创建应用，A网站开发者首先去淘宝开放平台创建应用，开放平台会生成一个client_id作为A网站唯一标识。

       第二个流程是授权流程，用户在A网站点击使用淘宝账号登陆时，实际上跳转至A网站拼接授权URL页面，这个页面由淘宝提供。用户在授权页面输入淘宝用户名和密码，校验成功后跳转至A网站回调地址，这时A网站会拿到一个code，后台再使用code去获取access_token。

       第三个流程是获取信息，获取到access_token相当于获取到一把钥匙，再按照规范调用淘宝对外提供接口就可以获取到用户数据。

       第一个方面A网站开发人员需要在淘宝开放平台进行申请，需要输入个人信息或者公司信息，这样A网站可靠性有了一定程度保证。

       第二个方面在第一章节方案用户需要在A网站输入淘宝用户名和密码，但是在OAuth2.0方案虽然也要输入淘宝用户名密码，但是这个页面由淘宝官方提供，安全性得到了保证。

       第三个方面access_token（令牌）并没有在浏览器中传递，而是需要A网站在获取到code之后去后台程序换取，避免了钥匙泄露风险。

       第四个方面code（授权码）在浏览器传递有一定风险，但是具有两个特性一定程度保证了安全：

       在第二章节详细分析了OAuth2.0协议，在实现流程章节分析了创建应用、授权流程、获取信息三个流程，我们发现一个问题：在流程图步骤资源服务器需要远程调用授权服务器check_token端点校验令牌是否消息，这样比较消耗性能。

       如果资源服务器和授权服务器约定一个密钥对，授权服务器用秘钥加密令牌，当资源服务器接收到令牌时进行解密直接对令牌进行校验，这样可以节省远程交互。

       JSON Web Token（JWT）可以解决上述问题，作为一个开放标准（RFC ）定义了一种紧凑的自包含方式，用于作为JSON对象在各方之间安全地传输信息。

       JWT分为头部、有效载荷和签名三个部分。头部包含签名算法以及token类型。有效载荷包含真正业务信息，例如用户ID、姓名、邮箱、权限信息。头部和有效载荷任何人都可以读出来，所以需要用签名防止篡改：头部和有效载荷分别进行Base编码，编码后用 . 连接组成新字符串，再使用头部声明算法进行签名。

       JWT令牌内容：

       JWT解码内容：

       在第二章节详细分析了OAuth2.0协议，我们还发现一个问题：客户端在获取到令牌之后，还需要调用资源服务器接口获取用户信息，有没有一种协议可以在返回令牌时同时将用户是谁返回呢？

       回答这个问题之前首先对比一组概念：授权与认证。授权关注通信实体具有什么权限，认证关注通信实体是谁。OAuth2.0只有授权流程，返回令牌之后授权流程已经完成，OpenID Connect在此基础上进行了扩展，客户端能够通过认证来识别用户。

       OpenID Connect定义了三种角色：

       三种角色交互流程：

       本文场景对应三种角色：

       OIDC标准协议新增id_token字段，这个字段符合JWT标准格式。为什么不与第三章节一样在access_token包含有效负载信息，而是新增id_token字段？因为即使access_token可以加入用户信息并且防篡改，但是用户每次请求都需要携带access_token，增加了带宽和用户信息泄露风险。

       OIDC标准协议要求提供了一个/userinfo端点，可以通过access_token调用获取用户信息，那么id_token已经包含了用户信息，为什么还要提供此端点呢？

       原因是id_token提供用户基本信息，如果客户端只要求获取基本信息，那么无需调用/userinfo端点。如果需要获取用户详细信息，那么可以调用/userinfo端点。

       JWT在线编码工具

       JWT在线解码工具

       淘宝开放平台用户授权介绍

       网站应用微信登录开发指南

       欢迎大家关注公众号「JAVA前线」查看更多精彩分享文章，主要包括源码分析、实际应用、架构思维、职场分享、产品思考等等，同时欢迎大家加我个人微信「java_front」一起交流学习

我下载了一个网站源码，现在本地安装测试一下，但是不知道怎么安装。。。。。。

       源码属于哪种语言，什么数据库？如果是asp+access，直接上传到服务器即可使用。

       如果是mysql类型的源码，需要空mysq空间和网站空间。huakai源码网，有几百个精品源码，官方技术人员报给你安装好啊

火爆github的《Hello 算法》，动画图解无痛学习数据结构！

       初学者在学习数据结构时，常常会遇到以下难题：

       1. 教材中的代码大多是伪代码，难以实际运行，导致难以验证自己的理解；

       2. 数据结构代码较为抽象，尤其是树和图等涉及递归的内容，对于代码不敏感的同学来说，理解起来较为困难。

       今天向大家推荐一本在github上广受欢迎的数据结构开源教材——《Hello 算法》。这本书以动画图解的形式呈现，内容清晰易懂。书中源代码支持一键运行，包括C++、C、python、JAVA等十二种语言版本，帮助读者在练习中提高编程技能，了解算法工作原理和数据结构底层实现。目前，该教材的star数量已经达到了.6k。

       对于一些较为抽象的代码，如图的遍历，书中还配备了动画教程，帮助读者更好地理解。

       同时，网站上还设有讨论区，读者可以在讨论区中进行交流。

       Github链接：github.com/krahets/hell...

       对于考研学生来说，这份资料适用于算法初学者或有一定刷题经验，对数据结构与算法有一定了解但不确定如何深入学习的同学。它更偏向入门性质，虽然从应试角度可能不如辅导书，但对于考研的同学来说，入门时会有很大帮助。全书内容与考研内容密切相关。而对于考研的同学，可以用来回顾和梳理算法知识体系，仓库源代码也可以作为“刷题工具库”或“算法字典”使用。

图解Lua分代GC

       一直对GC很感兴趣，最近阅读Lua GC相关资料并结合Lua5.4.6源码总结了Lua的分代GC机制。

       在Lua中，对象根据年龄被划分为新旧不同阶段。其中，NEW、SURVIVAL属于新对象；OLD、OLD0、OLD1、TOUCHED1、TOUCHED2属于老对象。

       对象的颜色表示其状态，分为黑、白、灰三种。黑色代表对象已被完全标记，灰色代表有待标记，白色代表不再被使用的对象。YoungGC通过递归标记灰色对象，清理白色对象。

       对象颜色通过mark字段中的三个比特位表示，黑色占一个比特，白色占两个比特，全0表示灰色状态。

       使用三色标记方法，对象颜色动态变化，帮助GC准确识别无用对象。

       在Lua GC中，对象的管理通过特定的链表结构实现，包含普通无析构函数对象链表、有析构函数对象链表以及灰色对象链表。

       新对象经历两次小GC才能成为老对象的机制，旨在确保新对象的生命周期大于一次年轻代GC间隔，避免错误标记。

       源码中只标记OLD1年龄态对象的原因是，G_TOUCHED1、G_TOUCHED2、OLD0年龄态对象已经在灰链中。而OLD年龄态在小GC时不进行引用标记。

       OLD1年龄态对象已经历两次小GC，理论上属于老对象范畴。但将其直接归并入OLD态会导致SURVIVAL年龄态对象的引用标记问题。

       通过上述机制，Lua的分代GC实现了高效而精准的对象管理，降低了内存碎片，提升了程序性能。

张图，剖析 Spring AOP 源码，小白居然也能看懂，大神，请收下我的膝盖！

       本文将简要介绍AOP（面向切面编程）的基础知识与使用方法，并深入剖析Spring AOP源码。首先，我们需要理解AOP的基本概念。

       1. **基础知识

**

       1.1 **什么是AOP？

**

       AOP全称为Aspect Oriented Programming，即面向切面编程。AOP的思想中，周边功能（如性能统计、日志记录、事务管理等）被定义为切面，核心功能与切面功能独立开发，然后将两者“编织”在一起，这就是AOP的核心。

       AOP能够将与业务无关、却为业务模块共同调用的逻辑封装，减少系统重复代码，降低模块间的耦合度，有利于系统的可扩展性和可维护性。

       1.2 **AOP基础概念

**

       解释较为官方，以下用“方言”解释：AOP包括五种通知分类。

       1.3 **AOP简单示例

**

       创建`Louzai`类，添加`LouzaiAspect`切面，并在`applicationContext.xml`中配置。程序入口处添加`"睡觉"`方法并添加前置和后置通知。接下来，我们将探讨Spring内部如何实现这一过程。

       1.4 **Spring AOP工作流程

**

       为了便于理解后面的源码，我们将整体介绍源码执行流程。整个Spring AOP源码分为三块，结合示例进行讲解。

       第一块是前置处理，创建`Louzai`Bean前，遍历所有切面信息并存储在缓存中。第二块是后置处理，创建`Louzai`Bean时，主要处理两件事。第三块是执行切面，通过“责任链+递归”执行切面。

       2. **源码解读

**

       注意：Spring版本为5.2..RELEASE，否则代码可能不同！这里，我们将从原理部分开始，逐步深入源码。

       2.1 **代码入口

**

       从`getBean()`函数开始，进入创建Bean的逻辑。

       2.2 **前置处理

**

       主要任务是遍历切面信息并存储。

       这是重点！请务必注意！获取切面信息流程结束，后续操作都从缓存`advisorsCache`获取。

       2.2.1 **判断是否为切面

**

       执行逻辑为：判断是否包含切面信息。

       2.2.2 **获取切面列表

**

       进入`getAdvice()`，生成切面信息。

       2.3 **后置处理

**

       主要从缓存拿切面，与`Louzai`方法匹配，创建AOP代理对象。

       进入`doCreateBean()`，执行后续逻辑。

       2.3.1 **获取切面

**

       首先，查看如何获取`Louzai`的切面列表。

       进入`buildAspectJAdvisors()`，方法用于存储切面信息至缓存`advisorsCache`。随后回到`findEligibleAdvisors()`，从缓存获取所有切面信息。

       2.3.2 **创建代理对象

**

       有了`Louzai`的切面列表，开始创建AOP代理对象。

       这是重点！请仔细阅读！这里有两种创建AOP代理对象方式，我们选择使用Cglib。

       2.4 **切面执行

**

       通过“责任链+递归”执行切面与方法。

       这部分逻辑非常复杂！接下来是“执行切面”最核心的逻辑，简述设计思路。

       2.4.1 **第一次递归

**

       数组第一个对象执行`invoke()`，参数为`CglibMethodInvocation`。

       执行完毕后，继续执行`CglibMethodInvocation`的`process()`。

       2.4.2 **第二次递归

**

       数组第二个对象执行`invoke()`。

       2.4.3 **第三次递归

**

       数组第三个对象执行`invoke()`。

       执行完毕，退出递归，查看`invokeJoinpoint()`执行逻辑，即执行主方法。回到第三次递归入口，继续执行后续切面。

       切面执行逻辑已演示，直接查看执行方法。

       流程结束时，依次退出递归。

       2.4.4 **设计思路

**

       这部分代码研究了大半天，因为这里不是纯粹的责任链模式。

       纯粹的责任链模式中，对象内部有一个自身的`next`对象，执行当前对象方法后，启动`next`对象执行，直至最后一个`next`对象执行完毕，或中途因条件中断执行，责任链退出。

       这里`CglibMethodInvocation`对象内部无`next`对象，通过`interceptorsAndDynamicMethodMatchers`数组控制执行顺序，依次执行数组中的对象，直至最后一个对象执行完毕，责任链退出。

       这属于责任链，实现方式不同，后续会详细剖析。下面讨论类之间的关系。

       主对象为`CglibMethodInvocation`，继承于`ReflectiveMethodInvocation`，`process()`的核心逻辑在`ReflectiveMethodInvocation`中。

       `ReflectiveMethodInvocation`的`process()`控制整个责任链的执行。

       `ReflectiveMethodInvocation`的`process()`方法中，包含一个长度为3的数组`interceptorsAndDynamicMethodMatchers`，存储了3个对象，分别为`ExposeInvocationInterceptor`、`MethodBeforeAdviceInterceptor`、`AfterReturningAdviceInterceptor`。

       注意！这3个对象都继承了`MethodInterceptor`接口。

       每次`invoke()`调用时，都会执行`CglibMethodInvocation`的`process()`。

       是否有些困惑？别着急，我将再次帮你梳理。

       对象与方法的关系：

       可能有同学疑惑，`invoke()`的参数为`MethodInvocation`，没错！但`CglibMethodInvocation`也继承了`MethodInvocation`，可自行查看。

       执行逻辑：

       设计巧妙之处在于，纯粹的责任链模式中，`next`对象需要保证类型一致。但这里3个对象内部没有`next`成员，不能直接使用责任链模式。怎么办呢？就单独设计了`CglibMethodInvocation.process()`，通过无限递归`process()`实现责任链逻辑。

       这就是我们为什么要研究源码，学习优秀的设计思路！

       3. **总结

**

       本文首先介绍了AOP的基本概念与原理，通过示例展示了AOP的应用。之后深入剖析了Spring AOP源码，分为三部分。

       本文是Spring源码解析的第三篇，感觉是难度较大的一篇。图解代码花费了6个小时，整个过程都沉浸在代码的解析中。

       难度不在于抠图，而是“切面执行”的设计思路，即使流程能走通，将设计思想总结并清晰表达给读者，需要极大的耐心与理解能力。

       今天的源码解析到此结束，有关Spring源码的学习，大家还想了解哪些内容，欢迎留言给楼仔。