1.UE5 ModelingMode & GeometryScript源码学习（一）
2.lodash源码之语言模块toNumber方法
3.求一个基于openssl写的ecc曲线的源代码
4.画图带你彻底弄懂三级缓存和循环依赖的问题
5.objects是什么文件

UE5 ModelingMode & GeometryScript源码学习（一）

       前言

       ModelingMode是虚幻引擎5.0后的新增功能，用于直接在引擎中进行3D建模，无需外接工具，实现快速原型设计和特定需求的模型创建。GeometryScript是用于通过编程方式创建和操控3D几何体的系统，支持蓝图或Python脚本，手动壁纸展示源码提供灵活控制能力。

       本文主要围绕ModelingMode与GeometryScript源码学习展开，涵盖DMC简介、查找感兴趣功能源码、动态网格到静态网格的代码介绍。

       起因

       在虚幻4中，通过RuntimeMeshComponent或ProceduralMeshComponent组件实现简单模型的程序化生成。动态网格组件（DynamicMeshComponent）在UE5中提供了额外功能，如三角面级别处理、转换为StaticMesh/Volume、烘焙贴图和编辑UV等。

       将动态网格对象转换为静态网格对象时，发现官方文档对DMC与PMC对比信息不直接涉及此转换。通过搜索发现，DynamicMesh对象转换为StaticMesh对象的代码位于Source/Runtime/MeshConversion目录下的UE::Modeling::CreateMeshObject函数中。

       在UE::Modeling::CreateMeshObject函数内，使用UEditorModelingObjectsCreationAPI对象进行动态网格到静态网格的转换，通过HasMoveVariants()函数接受右值引用参数。UEditorModelingObjectsCreationAPI::CreateMeshObject函数进一步处理转换参数，UE::Modeling::CreateStaticMeshAsset函数负责创建完整的静态网格资产。

       总结转换流程，DynamicMesh对象首先收集世界、变换、资产名称和材质信息，通过FCreateMeshObjectParams对象传递给UE::Modeling::CreateMeshObject函数，该函数调用UE::Modeling::CreateStaticMeshAsset函数创建静态网格资产。

       转换为静态网格后，程序创建了一个静态网格Actor和组件。此过程涉及静态网格属性设置，最终返回FCreateMeshObjectResult对象表示转换成功。

       转换静态网格为Volume、动态网格同样在相关函数中实现。

       在Modeling Mode中添加基础形状涉及UInteractiveToolManager::DeactivateToolInternal函数，当接受基础形状时，调用UAddPrimitiveTool::GenerateAsset函数，根据面板选择的输出类型创建模型。

       最后，UAddPrimitiveTool::Setup函数创建PreviewMesh对象，UAddPrimitiveTool::UpdatePreviewMesh()函数中通过UAddPrimitiveTool::GenerateMesh生成网格数据填充FDynamicMesh3对象，进而更新到PreviewMesh中。

       文章总结了Modeling Mode与GeometryScript源码的学习路径，从动态网格到静态网格的转换、基础形状添加到输出类型对应函数，提供了一条完整的自媒体 交易 源码流程概述。

lodash源码之语言模块toNumber方法

       toNumber(value)方法的功能是将value转换为数字类型。

       lodash源码中，第一行导入了判断是否为Object类型的方法。这个方法会检查value是否为Object类型，如果是则返回true，否则返回false。

       关于ECMAScript中Object类型的定义，可以参考以下链接：.ecma-international.org...

       例如，arrays、functions、objects、regexes、new Number(0)、new String('')等都是对象类型。

       typeof运算符返回值中，isObject方法的第一行通过typeof运算符获取参数的数据类型。如果参数value不为null且类型为object或function，则返回true，否则返回false。

       第二行导入的isSymbol方法，用于判断value是否为Symbol类型。该方法首先导入getTag方法，用于获取参数value的toStringTag。

       getTag方法用于获取参数value的toStringTag。在判断一个值的类型时，仅判断为object类型有时无法满足实际需求，因此可以使用Object.prototype.toString.call()方法获取具体类型。

       具体类型字符串可以通过比较获取。getTag源码的第一行获取Object.prototype.toString方法的引用。方法体中先判断参数value是否为null，如果是，再判断是否为undefined，如果是undefined则返回[object Undefined]，否则返回[object Null]。最后通过toString.call(value)返回具体的类型字符串。

       isSymbol方法体中，首先通过typeof运算符获取value的类型。接着判断该类型是否为symbol。由于Symbol类型的数据通过typeof运算符运算后的结果就是字符串symbol，因此还需要判断[object Symbol]。

       第3-8行和第-行，如果参数本身就是number类型，则直接返回。

       第-行，如果参数是Symbol类型，则返回NaN。

       第-行，如果参数是对象类型，则继续判断其原型链上是list.sort源码否存在valueOf方法。如果有，则调用valueOf方法返回其字符串，否则原样返回。接着判断是否为Object类型，如果是则返回其字符串类型，否则原样返回。

       第-行，如果参数不是string类型，并且参数等于0，则返回本身，否则转换为number类型返回。

       第行，如果value是字符串类型，则去掉字符串的前后空格。

       第-行，如果value是二进制或八进制字符串，则调用parseInt方法将其转换为十进制数返回。如果是十六进制字符串，则返回NaN，否则隐式转换后返回。

求一个基于openssl写的ecc曲线的源代码

       下面的例子生成两对ECC密钥，并用它做签名和验签，并生成共享密钥。

       #include <string.h>

       #include <stdio.h>

       #include <openssl/ec.h>

       #include <openssl/ecdsa.h>

       #include <openssl/objects.h>

       #include <openssl/err.h>

       int main()

       {

        EC_KEY *key1,*key2;

        EC_POINT *pubkey1,*pubkey2;

        EC_GROUP *group1,*group2;

        int ret,nid,size,i,sig_len;

        unsigned char*signature,digest[];

        BIO *berr;

        EC_builtin_curve *curves;

        int crv_len;

        char shareKey1[],shareKey2[];

        int len1,len2;

        /* 构造EC_KEY数据结构 */

        key1=EC_KEY_new();

        if(key1==NULL)

        {

        printf("EC_KEY_new err!\n");

        return -1;

        }

        key2=EC_KEY_new();

        if(key2==NULL)

        {

        printf("EC_KEY_new err!\n");

        return -1;

        }

        /* 获取实现的椭圆曲线个数 */

        crv_len = EC_get_builtin_curves(NULL, 0);

        curves = (EC_builtin_curve *)malloc(sizeof(EC_builtin_curve) * crv_len);

        /* 获取椭圆曲线列表 */

        EC_get_builtin_curves(curves, crv_len);

        /

*

        nid=curves[0].nid;会有错误，原因是密钥太短

        */

        /* 选取一种椭圆曲线 */

        nid=curves[].nid;

        /* 根据选择的椭圆曲线生成密钥参数group */

        group1=EC_GROUP_new_by_curve_name(nid);

        if(group1==NULL)

        {

        printf("EC_GROUP_new_by_curve_name err!\n");

        return -1;

        }

        group2=EC_GROUP_new_by_curve_name(nid);

        if(group1==NULL)

        {

        printf("EC_GROUP_new_by_curve_name err!\n");

        return -1;

        }

        /* 设置密钥参数 */

        ret=EC_KEY_set_group(key1,group1);

        if(ret!=1)

        {

        printf("EC_KEY_set_group err.\n");

        return -1;

        }

        ret=EC_KEY_set_group(key2,group2);

        if(ret!=1)

        {

        printf("EC_KEY_set_group err.\n");

        return -1;

        }

        /* 生成密钥 */

        ret=EC_KEY_generate_key(key1);

        if(ret!=1)

        {

        printf("EC_KEY_generate_key err.\n");

        return -1;

        }

        ret=EC_KEY_generate_key(key2);

        if(ret!=1)

        {

        printf("EC_KEY_generate_key err.\n");

        return -1;

        }

        /* 检查密钥 */

        ret=EC_KEY_check_key(key1);

        if(ret!=1)

        {

        printf("check key err.\n");

        return -1;

        }

        /* 获取密钥大小 */

        size=ECDSA_size(key1);

        printf("size %d \n",size);

        for(i=0;i<;i++)

        memset(&digest[i],i+1,1);

        signature=malloc(size);

        ERR_load_crypto_strings();

        berr=BIO_new(BIO_s_file());

        BIO_set_fp(berr,stdout,BIO_NOCLOSE);

        /* 签名数据，本例未做摘要，可将digest中的数据看作是sha1摘要结果 */

        ret=ECDSA_sign(0,digest,,signature,&sig_len,key1);

        if(ret!=1)

        {

        ERR_print_errors(berr);

        printf("sign err!\n");

        return -1;

        }

        /* 验证签名 */

        ret=ECDSA_verify(0,digest,,signature,sig_len,key1);

        if(ret!=1)

        {

        ERR_print_errors(berr);

        printf("ECDSA_verify err!\n");

        return -1;

        }

        /* 获取对方公钥，不能直接引用 */

        pubkey2 = EC_KEY_get0_public_key(key2);

        /* 生成一方的共享密钥 */

        len1=ECDH_compute_key(shareKey1, , pubkey2, key1, NULL);

        pubkey1 = EC_KEY_get0_public_key(key1);

        /* 生成另一方共享密钥 */

        len2=ECDH_compute_key(shareKey2, , pubkey1, key2, NULL);

        if(len1!=len2)

        {

        printf("err\n");

        }

        else

        {

        ret=memcmp(shareKey1,shareKey2,len1);

        if(ret==0)

        printf("生成共享密钥成功\n");

        else

        printf("生成共享密钥失败\n");

        }

        printf("test ok!\n");

        BIO_free(berr);

        EC_KEY_free(key1);

        EC_KEY_free(key2);

        free(signature);

        free(curves);

        return 0;

       }

画图带你彻底弄懂三级缓存和循环依赖的问题

       大家好。我们都知道，Spring可以通过三级缓存解决循环依赖的问题，这也是面试中很常见的一个面试题，本文就来着重讨论一下有关循环依赖和三级缓存的问题。

一、什么是循环依赖

       大家平时在写业务的时候应该写过这样的代码。

       其实这种类型就是循环依赖，就是AService 和BService两个类相互引用。

二、三级缓存可以解决的循环依赖场景

       如上面所说，大家平时在写这种代码的时候，项目其实是可以起来的，也就是说其实三级缓存是可以解决这种循环依赖的。

       当然除了这种字段注入，set注入也是可以解决的，代码如下。

       接下来就来探究三级缓存是如何解决这种循环依赖的？

三、Spring的Bean是如何创建出来的

       本文所说的Bean和对象可以理解为同一个意思。

       先说如何解决循环依赖之前，先来了解一下一个Bean创建的大致流程。为什么要说Bean的android源码下载 菜单创建过程，因为循环依赖主要是发生在Bean创建的过程中，知道Bean是如何创建的，才能更好的理解三级缓存的作用。

       其实Spring Bean的生命周期源码剖析我也在微信公众号 三友的java日记 中发过，并且有简单的提到三级缓存，有兴趣的同学可以在关注公众号之后回复 Bean 即可获取文章链接，里面有Bean创建过程更详细的说明。这里我简单画一张图来说一下。

       其实图里的每个阶段还可以分为一些小的阶段，我这里就没画出来了。

       来说一下每个阶段干了什么事。

       BeanDefinition的读取阶段：我们在往Spring容器注入Bean的时候，一般会通过比如xml方式，@Bean注解的方式，@Component注解的方式，其实不论哪一种，容器启动的时候都会去解析这些配置，然后为每个Bean生成一个对应的BeanDefinition，这个BeanDefinition包含了这个Bean的创建的信息，Spring就是根据BeanDefinition去决定如何创建一个符合你要求的Bean

       Bean的实例化阶段：这个阶段主要是将你配置的Bean根据Class的类型创建一个对象出来

       Bean的属性赋值阶段：这个阶段主要是用来处理属性的赋值，比如@Autowired注解的生效就是在这个阶段的

       Bean的初始化阶段：这个阶段主要是回调一些方法，比如你的类实现了InitializingBean接口，那么就会回调afterPropertiesSet方法，同时动态代理其实也是在这个阶段完成的。

       其实从这可以看出，一个Spring Bean的生成要分为很多的阶段，只有这些事都处理完了，这个Bean才是完完全全创建好的Bean，也就是我们可以使用的Bean。

四、三级缓存指的是哪三级缓存

       这里直接上源码

       第一级缓存：singletonObjects

       存放已经完完全全创建好的Bean，什么叫完完全全创建好的？就是上面说的是，所有的步骤都处理完了，就是创建好的Bean。一个Bean在产的过程中是需要经历很多的步骤，在这些步骤中可能要处理@Autowired注解，又或是处理@Transcational注解，当需要处理的都处理完之后的Bean，就是完完全全创建好的Bean，这个Bean是可以用来使用的，我们平时在用的Bean其实就是创建好的。

       第二级缓存：earlySingletonObjects

       早期暴露出去的Bean，其实也就是解决循环依赖的Bean。早期的意思就是没有完完全全创建好，但是由于有循环依赖，就需要把这种Bean提前暴露出去。其实 早期暴露出去的Bean 跟 完完全全创建好的Bean 他们是同一个对象，只不过早期Bean里面的注解可能还没处理，完完全全的java 下载pdf 源码Bean已经处理了完了，但是他们指的还是同一个对象，只不过它们是在Bean创建过程中处于的不同状态，如果早期暴露出去的Bean跟完完全全创建好的Bean不是同一个对象是会报错的，项目也就起不来，这个不一样导致报错问题，这里我会结合一个案例再来写一篇文章，这里不用太care，就认为是一样的。

       第三级缓存：singletonFactories

       存的是每个Bean对应的ObjectFactory对象，通过调用这个对象的getObject方法，就可以获取到早期暴露出去的Bean。

       注意：这里有个很重要的细节就是三级缓存只会对单例的Bean生效，像多例的是无法利用到三级缓存的，通过三级缓存所在的类名DefaultSingletonBeanRegistry就可以看出，仅仅是对SingletonBean也就是单例Bean有效果。

五、三级缓存在Bean生成的过程中是如何解决循环依赖的

       这里我假设项目启动时先创建了AService的Bean，那么就会根据Spring Bean创建的过程来创建。

       在Bean的实例化阶段，就会创建出AService的对象，此时里面的@Autowired注解是没有处理的，创建出AService的对象之后就会构建AService对应的一个ObjectFactory对象放到三级缓存中，通过这个ObjectFactory对象可以获取到AService的早期Bean。

       然后AService继续往下走，到了某一个阶段，开始处理@Autowired注解，要注入BService对象，如图

       要注入BService对象，肯定要去找BService对象，那么他就会从三级缓存中的第一级缓存开始依次查找有没有BService对应的Bean，肯定都没有啊，因为BService还没创建呢。没有该怎么办呢？其实很好办，没有就去创建一个么，这样不就有了么。于是AService的注入BService的过程就算暂停了，因为现在得去创建BService，创建之后才能注入给AService。

       于是乎，BService就开始创建了，当然他也是Spring的Bean，所以也按照Bean的创建方式来创建，先实例化一个BService对象，然后缓存对应的一个ObjectFactory到第三级缓存中，然后就到了需要处理@Autowired注解的时候了，如图。

       @Autowired注解需要注入AService对象。注入AService对象，就需要先去拿到AService对象，此时也会一次从三级缓存查有没有AService。

       先从第一级查，有没有创建好的AService，肯定没有，因为AService此时正在在创建（因为AService在创建的过程中需要注入BService才去创建BService的，虽然此刻代码正在创建BService，但是AService也是在创建的过程中，只不过暂停了，只要BService创建完，AService会继续往下创建）；第一级缓存没有，那么就去第二级看看，也没有，没有早期的AService；然后去第三级缓存看看有没有AService对应的ObjectFactory对象，惊天的发现，竟然有(上面提到过，创建出AService的对象之后，会构建AService对应的一个ObjectFactory对象放到三级缓存中)，那么此时就会调用AService对应的ObjectFactory对象的getObject方法，拿到早期的AService对象，然后将早期的AService对象放到二级缓存，为什么需要放到二级缓存，主要是怕还有其他的循环依赖，如果还有的话，直接从二级缓存中就能拿到早期的AService对象。

       虽然是早期的AService对象，但是我前面说过，仅仅只是早期的AService对象可能有些Bean创建的步骤还没完成，跟最后完完全全创建好的AService Bean是同一个对象。

       于是接下来就把早期的AService对象注入给BService。

       此时BService的@Autowired注解注入AService对象就完成了，之后再经过其他阶段的处理之后，BService对象就完完全全的创建完了。

       BService对象创建完之后，就会将BService放入第一级缓存，然后清空BService对应的第三级缓存，当然也会去清空第二级缓存，只是没有而已，至于为什么清空，很简单，因为BService已经完全创建好了，如果需要BService那就在第一级缓存中就能查找到，不需要在从第二级或者第三级缓存中找到早期的BService对象。

       BService对象就完完全全的创建完之后，那么接下来该干什么呢？此时当然继续创建AService对象了，你不要忘了为什么需要创建BService对象，因为AService对象需要注入一个BService对象，所以才去创建BService的，那么此时既然BService已经创建完了，那么是不是就应该注入给AService对象了？所以就会将BService注入给AService对象，这下就明白了，BService在构建的时候，已经注入了AService，虽然是早期的AService，但的确是AService对象，现在又把BService注入给了AService，那么是不是已经解决了循环依赖的问题了，AService和BService都各自注入了对方，如图。

       然后AService就会跟BService一样，继续处理其它阶段的，完全创建好之后，也会清空二三级缓存，放入第一级缓存。

       到这里，AService和BService就都创建好了，循环依赖也就解决了。

       这下你应该明白了三级缓存的作用，主要是第二级和第三级用来存早期的对象，这样在有循环依赖的对象，就可以注入另一个对象的早期状态，从而达到解决循环依赖的问题，而早期状态的对象，在构建完成之后，也就会成为完完全全可用的对象。

六、三级缓存无法解决的循环依赖场景1）构造器注入无法解决循环依赖

       上面的例子是通过@Autowired注解直接注入依赖的对象，但是如果通过构造器注入循环依赖的对象，是无法解决的，如代码下

       构造器注入就是指创建AService对象的时候，就传入BService对象，而不是用@Autowired注解注入BService对象。

       运行结果

       启动时就会报错，所以通过构造器注入对象就能避免产生循环依赖的问题，因为如果有循环依赖的话，那么就会报错。

       至于三级缓存为什么不能解决构造器注入的问题呢？其实很好理解，因为上面说三级缓存解决循环依赖的时候主要讲到，在AService实例化之后，会创建对应的ObjectFactory放到第三级缓存，发生循环依赖的时候，可以通过ObjectFactory拿到早期的AService对象；而构造器注入，是发生在实例化的时候，此时还没有AService对象正在创建，还没完成，压根就还没执行到往第三级添加对应的ObjectFactory的步骤，那么BService在创建的时候，就无法通过三级缓存拿到早期的AService对象，拿不到怎么办，那就去创建AService对象，但是AService不是正在创建么，于是会报错。

2）注入多例的对象无法解决循环依赖**

       启动引导类

       要获取AService对象，因为多例的Bean在容器启动的时候是不会去创建的，所以得去获取，这样就会创建了。

       运行结果

       为什么不能解决，上面在说三级缓存的时候已经说过了，三级缓存只能对单例Bean生效，那么多例是不会起作用的，并且在创建Bean的时候有这么一个判断，那就是如果出现循环依赖并且是依赖的是多例的Bean，那么直接抛异常，源码如下

       注释其实说的很明白，推测出现了循环依赖，抛异常。

       所以上面提到的两种循环依赖的场景，之所以无法通过三级缓存来解决，是因为压根这两种场景就无法使用三级缓存，所以三级缓存肯定解决不掉。\

七、不用三级缓存，用二级缓存能不能解决循环依赖

       遇到这种面试题，你就跟面试官说，如果行的话，Spring的作者为什么不这么写呢？

       哈哈，开个玩笑，接下来说说到底为什么不行。

       这里我先说一下前面没提到的细节，那就是通过ObjectFactory获取的Bean可能是两种类型，第一种就是实例化阶段创建出来的对象，还是一种就是实例化阶段创建出来的对象的代理对象。至于是不是代理对象，取决于你的配置，如果添加了事务注解又或是自定义aop切面，那就需要代理。这里你不用担心，如果这里获取的是代理对象，那么最后完全创建好的对象也是代理对象，ObjectFactory获取的对象和最终完全创建好的还是同一个，不是同一个肯定会报错，所以上面的理论依然符合，这里只是更加的细节化。

       有了这个知识点之后，我们就来谈一下为什么要三级缓存。

       第一级缓存，也就是缓存完全创建好的Bean的缓存，这个缓存肯定是需要的，因为单例的Bean只能创建一次，那么肯定需要第一级缓存存储这些对象，如果有需要，直接从第一级缓存返回。那么如果只能有二级缓存的话，就只能舍弃第二级或者第三级缓存。

       假设舍弃第三级缓存

       舍弃第三级缓存，也就是没有ObjectFactory，那么就需要往第二缓存放入早期的Bean，那么是放没有代理的Bean还是被代理的Bean呢？

       1）如果直接往二级缓存添加没有被代理的Bean，那么可能注入给其它对象的Bean跟最后最后完全生成的Bean是不一样的，因为最后生成的是代理对象，这肯定是不允许的；

       2）那么如果直接往二级缓存添加一个代理Bean呢？

       假设没有循环依赖，提前暴露了代理对象，那么如果跟最后创建好的不一样，那么项目启动就会报错，

       假设没有循环依赖，使用了ObjectFactory，那么就不会提前暴露了代理对象，到最后生成的对象是什么就是什么，就不会报错，

       如果有循环依赖，不论怎样都会提前暴露代理对象，那么如果跟最后创建好的不一样，那么项目启动就会报错

       通过上面分析，如果没有循环依赖，使用ObjectFactory，就减少了提前暴露代理对象的可能性，从而减少报错的可能。

       假设舍弃第二级缓存

       假设舍弃第二级缓存，也就是没有存放早期的Bean的缓存，其实肯定也不行。上面说过，ObjectFactory其实获取的对象可能是代理的对象，那么如果每次都通过ObjectFactory获取代理对象，那么每次都重新创建一个代理对象，这肯定也是不允许的。

       从上面分析，知道为什么不能使用二级缓存了吧，第三级缓存就是为了避免过早地创建代理对象，从而避免没有循环依赖过早暴露代理对象产生的问题，而第二级缓存就是防止多次创建代理对象，导致对象不同。

       本文完。

       如果觉得这篇文章对你有所帮助，还请帮忙点赞、在看、转发给更多的人，码字不易，非常感谢！

欢迎关注公众号 三友的java日记，更多技术干货及时获得。原文：/post/

objects是什么文件

       Objects文件是编译过程中生成的目标文件。

       在详细解释之前，我们先来了解一下编译的基本过程。在软件开发中，编译是将高级编程语言编写的源代码转换成机器语言的过程，这样计算机硬件才能够理解和执行。编译过程通常分为几个阶段，其中包括预处理、编译、汇编和链接。Objects文件就是在编译阶段的产物，它们包含了源代码转换后的机器指令，但还未进行最终的链接。

       具体来说，当我们使用编译器编译源代码时，编译器会将每个源文件单独编译成对应的目标文件，这些目标文件就是Objects文件，通常具有.o或.obj的扩展名。这些文件包含了由编译器生成的机器代码，以及用于链接的符号信息。

       Objects文件在软件开发中扮演着重要角色。它们允许开发者将大型项目分解为多个较小的模块，每个模块可以单独编译。这样做的好处是可以提高编译速度，因为当某个模块发生变化时，只需要重新编译该模块，而不需要重新编译整个项目。此外，Objects文件还使得库的使用变得方便，库是由预先编译好的目标文件组成的集合，可以被多个项目共享。

       举个例子，假设我们有一个C++项目，其中包含main.cpp和utility.cpp两个源文件。当我们使用编译器编译这个项目时，编译器会首先分别编译这两个源文件，生成main.o和utility.o两个目标文件。然后，在链接阶段，链接器会将这两个目标文件以及项目所依赖的库文件一起链接成一个可执行文件。在这个过程中，目标文件起到了桥梁的作用，它们将源代码和最终的可执行文件连接起来。