注册
环信即时通讯云

环信即时通讯云

单聊、群聊、聊天室...
环信开发文档

环信开发文档

Demo体验

Demo体验

场景Demo,开箱即用
RTE开发者社区

RTE开发者社区

汇聚音视频领域技术干货,分享行业资讯
技术讨论区

技术讨论区

技术交流、答疑
资源下载

资源下载

收集了海量宝藏开发资源
iOS Library

iOS Library

不需要辛辛苦苦的去找轮子, 这里都有
Android Library

Android Library

不需要辛辛苦苦的去找轮子, 这里都有

Java 8 魔法:利用 Function 接口告别冗余代码,打造高效断言神器

前言 在 Java 开发的征途中,我们时常与重复代码不期而遇。这些重复代码不仅让项目显得笨重,更增加了维护成本。幸运的是,Java 8 带来了函数式编程的春风,以 Function 接口为代表的一系列新特性,为我们提供了破除这一难题的利剑。本文将以一个实际应用...
继续阅读 »

前言


Java 开发的征途中,我们时常与重复代码不期而遇。这些重复代码不仅让项目显得笨重,更增加了维护成本。幸运的是,Java 8 带来了函数式编程的春风,以 Function 接口为代表的一系列新特性,为我们提供了破除这一难题的利剑。本文将以一个实际应用场景为例,即使用 Java 8 的函数式编程特性来重构数据有效性断言逻辑,展示如何通过 SFunction(基于 Java 8Lambda 表达式封装)减少代码重复,从而提升代码的优雅性和可维护性。


背景故事:数据校验的烦恼


想象一下,在一个复杂的业务系统中,我们可能需要频繁地验证数据库中某个字段值是否有效,是否符合预期值。传统的做法可能充斥着大量相似的查询逻辑,每次都需要手动构建查询条件、执行查询并处理结果,这样的代码既冗长又难以维护。


例如以下两个验证用户 ID 和部门 ID 是否有效的方法,虽然简单,但每次需要校验不同实体或不同条件时,就需要复制粘贴并做相应修改,导致代码库中充满了大量雷同的校验逻辑,给维护带来了困扰。


// 判断用户 ID 是否有效
public void checkUserExistence(String userId) {
User user = userDao.findById(userId);
if (user == null) {
throw new RuntimeException("用户ID无效");
}
}

// 判断部门 ID 是否有效
public void checkDeptExistence(String deptId) {
Dept dept = deptDao.findById(deptId);
if (dept == null) {
throw new RuntimeException("部门ID无效");
}
}

Java 8 的魔法棒:函数式接口


Java 8 引入了函数式接口的概念,其中 Function<T, R> 是最基础的代表,它接受一个类型 T 的输入,返回类型 R 的结果。而在 MyBatis Plus 等框架中常用的 SFunction 是对 Lambda 表达式的进一步封装,使得我们可以更加灵活地操作实体类的属性。


实战演练:重构断言方法


下面的 ensureColumnValueValid 方法正是利用了函数式接口的魅力,实现了对任意实体类指定列值的有效性断言:


/**
* 确认数据库字段值有效(通用)
*
* @param <V> 待验证值的类型
* @param valueToCheck 待验证的值
* @param columnExtractor 实体类属性提取函数
* @param queryExecutor 单条数据查询执行器
* @param errorMessage 异常提示信息模板
*/

public static <T, R, V> void ensureColumnValueValid(V valueToCheck, SFunction<T, R> columnExtractor, SFunction<LambdaQueryWrapper<T>, T> queryExecutor, String errorMessage) {
if (valueToCheck == null) return;

LambdaQueryWrapper<T> wrapper = new LambdaQueryWrapper<>();
wrapper.select(columnExtractor);
wrapper.eq(columnExtractor, valueToCheck);
wrapper.last("LIMIT 1");

T entity = queryExecutor.apply(wrapper);
R columnValue = columnExtractor.apply(entity);
if (entity == null || columnValue == null)
throw new DataValidationException(String.format(errorMessage, valueToCheck));
}

这个方法接受一个待验证的值、一个实体类属性提取函数、一个单行数据查询执行器和一个异常信息模板作为参数。通过这四个参数,不仅能够进行针对特定属性的有效性检查,而且还能生成具有一致性的异常信息。


对比分析


使用 Function 改造前


// 判断用户 ID 是否有效
public void checkUserExistence(String userId) {
User user = userDao.findById(userId);
if (user == null) {
throw new RuntimeException("用户ID无效");
}
}

// 判断部门 ID 是否有效
public void checkDeptExistence(String deptId) {
Dept dept = deptDao.findById(deptId);
if (dept == null) {
throw new RuntimeException("部门ID无效");
}
}

使用 Function 改造后


public void assignTaskToUser(AddOrderDTO dto) {
ensureColumnValueValid(dto.getUserId(), User::getId, userDao::getOne, "用户ID无效");
ensureColumnValueValid(dto.getDeptId(), Dept::getId, deptDao::getOne, "部门ID无效");
ensureColumnValueValid(dto.getCustomerId(), Customer::getId, customerDao::getOne, "客户ID无效");
ensureColumnValueValid(dto.getDeptId(), Dept::getId, deptDao::getOne, "部门ID无效");
ensureColumnValueValid(dto.getSupplieId(), Supplie::getId, supplierDao::getOne, "供应商ID无效");

// 现在可以确信客户存在
Customer cus = customerDao.findById(dto.getCustomerId());

// 创建订单的逻辑...
}

对比上述两段代码,我们发现后者不仅大幅减少了代码量,而且通过函数式编程,表达出更为清晰的逻辑意图,可读性和可维护性都有所提高。


优点



  1. 减少重复代码: 通过 ensureColumnValueValid 方法,所有涉及数据库字段值有效性检查的地方都可以复用相同的逻辑,将变化的部分作为参数传递,大大减少了因特定校验逻辑而产生的代码量。

  2. 增强代码复用: 抽象化的校验方法适用于多种场景,无论是用户ID、订单号还是其他任何实体属性的校验,一套逻辑即可应对。

  3. 提升可读性和维护性: 通过清晰的函数签名和 Lambda 表达式,代码意图一目了然,降低了后续维护的成本。

  4. 灵活性和扩展性: 当校验规则发生变化时,只需要调整 ensureColumnValueValid 方法或其内部实现,所有调用该方法的地方都会自动受益,提高了系统的灵活性和扩展性。


举一反三:拓展校验逻辑的边界


通过上述的实践,我们见识到了函数式编程在简化数据校验逻辑方面的威力。但这只是冰山一角,我们可以根据不同的业务场景,继续扩展和完善校验逻辑,实现更多样化的校验需求。以下两个示例展示了如何在原有基础上进一步深化,实现更复杂的数据比较和验证功能。


断言指定列值等于预期值


首先,考虑一个场景:除了验证数据的存在性,我们还需确认查询到的某列值是否与预期值相符。这在验证用户角色、状态变更等场景中尤为常见。为此,我们设计了 validateColumnValueMatchesExpected 方法:


/**
* 验证查询结果中指定列的值是否与预期值匹配
*
* @param <T> 实体类型
* @param <R> 目标列值的类型
* @param <C> 查询条件列值的类型
* @param targetColumn 目标列的提取函数,用于获取想要验证的列值
* @param expectedValue 期望的列值
* @param conditionColumn 条件列的提取函数,用于设置查询条件
* @param conditionValue 条件列对应的值
* @param queryMethod 执行查询的方法引用,返回单个实体对象
* @param errorMessage 验证失败时抛出异常的错误信息模板
* @throws RuntimeException 当查询结果中目标列的值与预期值不匹配时抛出异常
*/

public static <T, R, C> void validateColumnValueMatchesExpected(
SFunction<T, R> targetColumn, R expectedValue,
SFunction<T, C> conditionColumn, C conditionValue,
SFunction<LambdaQueryWrapper<T>, T> queryMethod,
String errorMessage)
{

// 创建查询包装器,选择目标列并设置查询条件
LambdaQueryWrapper<T> wrapper = new LambdaQueryWrapper<>();
wrapper.select(targetColumn);
wrapper.eq(conditionColumn, conditionValue);

// 执行查询方法
T one = queryMethod.apply(wrapper);
// 如果查询结果为空,则直接返回,视为验证通过(或忽略)
if (one == null) return;

// 获取查询结果中目标列的实际值
R actualValue = targetColumn.apply(one);

// 比较实际值与预期值是否匹配,这里假设notMatch是一个自定义方法用于比较不匹配情况
boolean doesNotMatch = notMatch(actualValue, expectedValue);
if (doesNotMatch) {
// 若不匹配,则根据错误信息模板抛出异常
throw new RuntimeException(String.format(errorMessage, expectedValue, actualValue));
}
}

// 假设的辅助方法,用于比较值是否不匹配,根据实际需要实现
private static <R> boolean notMatch(R actual, R expected) {
// 示例简单实现为不相等判断,实际情况可能更复杂
return !Objects.equals(actual, expected);
}


这个方法允许我们指定一个查询目标列(targetColumn)、预期值(expectedValue)、查询条件列(conditionColumn)及其对应的条件值(conditionValue),并提供一个查询方法(queryMethod)来执行查询。如果查询到的列值与预期不符,则抛出异常,错误信息通过 errorMessage 参数定制。


应用场景:
例如在一个权限管理系统中,当需要更新用户角色时,系统需要确保当前用户的角色在更新前是 “普通用户”,才能将其升级为 “管理员”。此场景下,可以使用 validateColumnValueMatchesExpected 方法来验证用户当前的角色是否确实为“普通用户”。


// 当用户角色不是 “普通用户” 时抛异常
validateColumnValueMatchesExpected(User::getRoleType, "普通用户", User::getId, userId, userMapper::getOne, "用户角色不是普通用户,无法升级为管理员!");

断言指定值位于期望值列表内


进一步,某些情况下我们需要验证查询结果中的某一列值是否属于一个预设的值集合。例如,验证用户角色是否合法。为此,我们创建了 validateColumnValueMatchesExpectedList 方法:


/**
* 验证查询结果中指定列的值是否位于预期值列表内
*
* @param <T> 实体类型
* @param <R> 目标列值的类型
* @param <C> 查询条件列值的类型
* @param targetColumn 目标列的提取函数,用于获取想要验证的列值
* @param expectedValueList 期望值的列表
* @param conditionColumn 条件列的提取函数,用于设置查询条件
* @param conditionValue 条件列对应的值
* @param queryMethod 执行查询的方法引用,返回单个实体对象
* @param errorMessage 验证失败时抛出异常的错误信息模板
* @throws RuntimeException 当查询结果中目标列的值不在预期值列表内时抛出异常
*/

public static <T, R, C> void validateColumnValueInExpectedList(
SFunction<T, R> targetColumn, List<R> expectedValueList,
SFunction<T, C> conditionColumn, C conditionValue,
SFunction<LambdaQueryWrapper<T>, T> queryMethod,
String errorMessage)
{

LambdaQueryWrapper<T> wrapper = new LambdaQueryWrapper<>();
wrapper.select(targetColumn);
wrapper.eq(conditionColumn, conditionValue);

T one = queryMethod.apply(wrapper);
if (one == null) return;

R actualValue = targetColumn.apply(one);
if (actualValue == null) throw new RuntimeException("列查询结果为空");

if (!expectedValueList.contains(actualValue)) {
throw new RuntimeException(errorMessage);
}
}

这个方法接受一个目标列(targetColumn)、一个预期值列表(expectedValueList)、查询条件列(conditionColumn)及其条件值(conditionValue),同样需要一个查询方法(queryMethod)。如果查询到的列值不在预期值列表中,则触发异常。


应用场景: 在一个电商平台的订单处理流程中,系统需要验证订单状态是否处于可取消的状态列表里(如 “待支付”、“待发货”)才允许用户取消订单。此时,validateColumnValueInExpectedList 方法能有效确保操作的合法性。


// 假设 OrderStatusEnum 枚举了所有可能的订单状态,cancelableStatuses 包含可取消的状态
List<String> cancelableStatuses = Arrays.asList(OrderStatusEnum.WAITING_PAYMENT.getValue(), OrderStatusEnum.WAITING_DELIVERY.getValue());

// 验证订单状态是否在可取消状态列表内
validateColumnValueInExpectedList(Order::getStatus, cancelableStatuses, Order::getOrderId, orderId, orderMapper::selectOne, "订单当前状态不允许取消!");

通过这两个扩展方法,我们不仅巩固了函数式编程在减少代码重复、提升代码灵活性方面的优势,还进一步证明了通过抽象和泛型设计,可以轻松应对各种复杂的业务校验需求,使代码更加贴近业务逻辑,易于理解和维护。


核心优势



  1. 代码复用:通过泛型和函数式接口,该方法能够适应任何实体类和属性的校验需求,大大减少了重复的查询逻辑代码。

  2. 清晰表达意图:方法签名直观表达了校验逻辑的目的,提高了代码的可读性和可维护性。

  3. 灵活性:使用者只需提供几个简单的 Lambda 表达式,即可完成复杂的查询逻辑配置,无需关心底层实现细节。

  4. 易于维护与扩展:



    1. 当需要增加新的实体验证时,仅需调用 ensureColumnValueValid 并传入相应的参数,无需编写新的验证逻辑,降低了维护成本。

    2. 修改验证规则时,只需调整 ensureColumnValueValid 内部实现,所有调用处自动遵循新规则,便于统一管理。

    3. 异常处理集中于 ensureColumnValueValid 方法内部,统一了异常抛出行为,避免了在多个地方处理相同的逻辑错误,减少了潜在的错误源。




函数式编程的力量


通过这个实例,我们见证了函数式编程在简化代码、提高抽象层次上的强大能力。在 Java 8 及之后的版本中,拥抱函数式编程思想,不仅能够使我们的代码更加简洁、灵活,还能在一定程度上促进代码的正确性和可测试性。因此,无论是日常开发还是系统设计,都值得我们深入探索和应用这一现代编程范式,让代码如魔法般优雅而高效。


作者:最光阴2023
来源:juejin.cn/post/7384256110280572980
收起阅读 »

火山引擎多款大模型产品能力升级,开发者使用门槛再降低

12 月 19 日,火山引擎 Force 原动力大会开发者论坛在上海世博中心举行。上午主论坛中亮相的火山方舟、扣子、豆包MarsCode 等产品,展示了从高代码到低代码,火山引擎如何在大模型时代通过大模型产品和能力,助力开发者高效创新。作为火山引擎的大模型服务...
继续阅读 »

12 月 19 日,火山引擎 Force 原动力大会开发者论坛在上海世博中心举行。上午主论坛中亮相的火山方舟、扣子、豆包MarsCode 等产品,展示了从高代码到低代码,火山引擎如何在大模型时代通过大模型产品和能力,助力开发者高效创新。

作为火山引擎的大模型服务平台,火山方舟于 2023 年发布,在助力企业高效安全地应用大模型以外,也是开发者的友好帮手。本次会上,火山引擎智能算法负责人吴迪发布了方舟应用实验室——一套高代码 SDK 和企业级示例模板,可为客户和开发者提供完整的场景化解决方案和完整的源代码,支持业务深度自定义拓展,提高代码使用体验。吴迪表示,“我们将着眼于那些高难度,高价值的问题,用开源的方式把应该怎么做告诉大家,也鼓励开发者基于我们的代码去随意自定义和发挥,构造各自的产品”。通过方舟实验室,大模型使用门槛将进一步降低。

除了高代码智能体,火山方舟还推出了 API 接口,开发者通过这些接口即可高效调用大模型。本次亮相的火山 AI 搜推引擎则通过多模态大模型与信息检索技术的融合,支持自然语言理解,多轮多模态交互,使用户能够便捷地获取全域丰富信息,为用户提供一站式搜索推荐服务。

图片1.png

火山引擎智能算法负责人 吴迪

针对数据研发治理场景,火山引擎大数据研发治理套件 DataLeap 在本次会上公布了全新能力——开放平台。据介绍,DataLeap 开放平台提供完整的 IDE 界面扩展和流水线扩展体系以及多种开放能力,让开发者只需根据开发手册,就能低成本、快速完成扩展程序的开发。结合先进的 AI 能力,DataLeap 将智能化融入开发、运维、资产查询等数据研发流程中,并在开放平台中以插件形式开放,为开发者提供开发助手、运维助手等工具,进一步降低开发门槛,提升运维效率。

图片2.png

火山引擎数智平台产品总监 张辉

本次会上展示的大模型应用工具也同样带来了不少亮点,让 AI 应用开发可以更简单。

扣子是新一代应用开发平台,在今年 5 月份的 Force 大会上首次亮相。时隔半年多,扣子来到 1.5,完成了 3 个方面的重要升级。

首先,扣子 1.5 提供全新的应用开发环境,支持 Chatbot 之外更丰富的 AI 应用范式,包括小程序、API、WebSDK 等多种形态。结合扣子推出的无限画布,用扣子已经可以低代码、可视化搭建出完整的 AI 应用。

其次,不仅仅是大语言模型,扣子接入的多模态能力也全面升级。其中在语音交互能力方面,借助火山引擎 RTC 超低延时、智能打断、抗弱网的优势,能够实现更流畅、更自然、更可靠的语音通话功能;在硬件应用方面,通过和火山引擎边缘智能的协同,借助边缘智能理解边缘设备能力,能让大模型更好地连接物理世界。而 12 月 18 日新发布的豆包·视觉理解模型、豆包文生图 2.1 和豆包音乐模型,在扣子也都能通过插件的方式第一时间体验到。

在本次升级中,扣子同步发布了模板功能,旨在帮助所有用户更快地理解扣子各项能力的最佳实践。扣子产品经理姚慧在现场向大家展示了机智云 AI 养鱼项目、猫王妙播 AI 音响、和府捞面顾客点评分析智能体等多个利用扣子实现的 AI 场景案例,鼓励开发者可以快速投入到所希望开发的应用方向中去。

图片3.png

扣子产品经理 姚慧

姚慧表示,扣子已成为 AI 时代开发者首选的应用开发平台。目前扣子有超过100万的活跃开发者,发布超过200万个智能体。扣子 1.5 通过更强的产品能力进一步降低了开发者的使用门槛,让 Al 离应用再近一步。

在大模型时代,开发者还急需更高效的开发工具来提升编程效率。此次大会上,火山引擎协同豆包MarsCode 为开发者提供了智能 AI IDE,在代码补全、Bug 修复、代码问答等各编程阶段为开发者提供协助支持。在关注代码生成 AI 化的同时,豆包MarsCode 也关注开发工具本身的 AI 化,通过交互方式的转变和多种大模型能力的接入,为开发者提供更好的用户体验。

图片4.png

豆包MarsCode 产品经理 王海建

“大模型时代,开发者的定义已经被极大地拓宽,开发者画像变得更加丰富。”正如火山引擎总裁谭待在大会开场时的致辞所言,火山引擎将通过提供更易用的 AI 应用开发平台和工具普惠开发者,与大家一起共创无限可能。(作者:李双)

收起阅读 »

如果你没有必须要离职的原因,我建议你在忍忍

自述 本人成都,由于一些原因我在八月离职了,因为我终于脱离了那个压抑的环境,我没有自己想象中的那么开心,我离职的那天,甚至后面很长的一段时间;离职后的我回了一趟家,刚好在最热的那几天,在家躺了几天,然后又出去逛了逛,玩了差不多一个月吧!我觉得心情逐渐恢复了;然...
继续阅读 »

自述


本人成都,由于一些原因我在八月离职了,因为我终于脱离了那个压抑的环境,我没有自己想象中的那么开心,我离职的那天,甚至后面很长的一段时间;离职后的我回了一趟家,刚好在最热的那几天,在家躺了几天,然后又出去逛了逛,玩了差不多一个月吧!我觉得心情逐渐恢复了;然后开始慢慢的投递简历。


前期


刚投递简历那会,基本上每天都是耍耍哒哒的投递;有面试就去面试,没有面试就在家刷抖音也不看看面试题,可能我找工作的状态还在几年前或者还没从上家公司的状态中走出来,也有可能我目前有一点存款不是特别焦虑,所以也没认真的找。


就这样刷刷哒哒的又过了半月,然后有许多朋友跟我说他们被裁员了,问他们的打算是怎么样的:有的人休息了两三天就开始了找工作当中,而有的人就玩几个月再说。


休息两三天就开始找工作的人基本上都是有家庭有小孩的,反之基本上都是单身。


在跟他们聊天的过程中发现,有些人半年没找到工作了,也有一些人一年都没有找到工作了。可能是年级大了、也可能是工资不想要的太低吧!但是工作机会确实比原来少很多。


在听了大家的话以后,我觉得我差不多也该认真找工作了,我开始逐渐投递简历。


疯狂投递简历


我在9月的下旬开始了简历的修改以及各大招聘App的下载,拉钩、智联、boos以及一下小程序的招聘软件(记不住名字了,因为没啥效果);在我疯狂的投递了几天以后我迎来了第一家面试,是一个线上面试;刚一来就给了我迎头一棒,或许我只忙着修改简历和投递简历去了,没有去背面试题吧(网上说现在都问场景题,所以没准备);


具体的问题我记不全了,但是我记得这么一个问题,面试官问:“深克隆有哪些方法”,我回答的是递归,然后他说还有吗?我直接呆住说不知道了。然后我们就结束了面试,最后他跟我说了这么一句话:“现在的市场行情跟原来没法比,现在的中级基本上要原来的高级的水平,现在的初级也就是原来的中级的水平,所以问的问题会比原来难很多,你可以在学习一下,看你的简历是很不错的;至少简历是这样的。”


当这个面试结束以后我想了想发现是这样的,不知是我还没有接受或者说还没有进入一个面试的状态,还是因为我不想上班的原因,导致我连一些基本的八股文都不清楚,所以我决定开始学习。


给准备离职或者已经离职的朋友们一个忠告:“做任何事情都需提前准备,至少在找工作上是这样的。”


学习


我去看了招聘网站的技术要求(想了解下企业需要的一些技术),不看不知道一看吓一跳,真的奇葩层出不穷,大概给大家概述一下:



  • 开发三班倒:分为早中晚班

  • 要你会vue+react+php+java等技术(工资8-12)

  • 要你会基本的绘画(UI)以及会后端的一些工作,目前这些都需要你一个人完成

  • 要你会vue+react+fluter;了解electron以及3d等

  • 还有就是你的项目跟我们的项目不一致的。


我看到这些稀奇古怪的玩意有点失望,最终我选择了fabricjs进行学习,最开始的时候就是在canvas上画了几个矩形,感觉挺不错的;然后我就想这不是马上快要国庆了吗?我就想用fabric做一个制作头像的这么一个工具插件,在经过两天的开发成功将其制作了出来,并且发布到了网站上(插件tools),发布第一天就有使用的小伙伴给我提一些宝贵的建议了,然后又开始了调整,现在功能也越来越多;


fabricjs在国内的资料很少,基本上就那么几篇文章,没有办法的我就跑去扒拉他们的源码看,然后拷贝需要的代码在修修改改(毕竟比较菜只能这样....);然后在学习fabric的时候也会去学习一些基本知识,比如:js内置方法、手写防抖节流、eventloop、闭包(一些原理逻辑)、深拷贝、内存回收机制等等。


在学习的过程中很难受,感觉每天都是煎熬;每次都想在床上躺着,但是想想还是放弃了,毕竟没有谁会喜欢一个懒惰的人...


在战面试(HR像是刷KPI)


在有所准备的情况下再去面试时就得心应手了,基本上没有太多的胆怯,基本上问啥都知道一些,然后就在面试的时候随机应变即可,10月我基本上接到的面试邀请大概有10多家,然后有几家感觉工资低了就没去面试,去面试了的应该有7/8家的样子,最终只要一家录取。


说说其中一家吧(很像刷KPI的一家):这是一家做ai相关的公司,公司很大,看资料显示时一家中外合资的企业,进去以后先开始了一轮笔试题(3/4页纸),我大概做了50分钟的样子;我基本上8层都答对了(因为他的笔试题很多我都知道嘛,然后有一些还写了几个解决方案的),笔试完了以后,叫我去机试;机试写接口;而且还是在规定的一个网站写(就给我一个网站,然后说写一个接口返回正确结果就行;那个网站我都不会用);我在哪儿磨磨蹭蹭了10多分钟以后,根据node写了一个接口给了hr;然后HR说你这个在我们网站上不能运行。我站起来就走了...


其实我走的原因还有一个,就是他们另一个HR对带我进来的这个HR说:你都没有协调好研发是否有时间,就到处招面试...


是否离职


如果你在你现在这公司还能呆下去的情况下,我建议你还是先呆呆看吧!目前这个市场行情很差,你看到我有10来个面试,但是你知道嘛?我沟通了多少:



  • boos沟通了差不多800-900家公司,邀请我投递简历的只有100家左右。邀请我面试的只有8/9家。

  • 智联招聘我投递了400-600家,邀请我面试的只有1家。

  • 拉钩这个不说了基本上没有招聘的公司(反反复复就那几家);投递了一个月后有一家叫我去面试的,面试了差不多50来分钟;交谈的很开心,他说周一周二给我回复,结果没有回复,我发消息问;也没有回复;看招聘信息发现(邀约面试800+)


我离职情非得已,愿诸君与我不同;如若您已离职,愿您早日找到属于自己的路,不一定是打工的路;若你在职,请在坚持坚持;在坚持的同时去做一些对未来有用的事情,比如:副业、耍个男女朋友、拓展一下圈子等等。


后续的规划


在经历了这次离职以后,我觉得我的人生应该进行好好的规划了;不能为原有的事物所影响,不能为过去所迷茫;未来还很长,望诸君互勉;


未来的计划大致分为几个方向:



  • 拓展自己的圈子(早日脱单)

  • 学习开发鸿蒙(我已经在做了,目前开发的app在审核),发布几款工具类app(也算是为国内唯一的系统贡献一些微弱的力量吧!)

  • 持续更新我在utools上的绘图插件

  • 学习投资理财(最近一月炒股:目前赚了4000多了)

  • 持续更新公众号(前端雾恋)、掘金等网站技术文章


结尾


我们的生活终将回归正轨,所有的昨天也将是历史,不必遗憾昨天,吸取教训继续前进。再见了...


作者:雾恋
来源:juejin.cn/post/7435289649273569334
收起阅读 »

入职第一天,看了公司代码,牛马沉默了

web
入职第一天就干活的,就问还有谁,搬来一台N手电脑,第一分钟开机,第二分钟派活,第三分钟干活,巴适。。。。。。打开代码发现问题不断读取配置文件居然读取两个配置文件,一个读一点,不清楚为什么不能一个配置文件进行配置 一边获取WEB-INF下的配置文件,一...
继续阅读 »

入职第一天就干活的,就问还有谁,搬来一台N手电脑,第一分钟开机,第二分钟派活,第三分钟干活,巴适。。。。。。

4f7ca8c685324356868f65dd8862f101~tplv-k3u1fbpfcp-jj-mark_3024_0_0_0_q75.jpg

打开代码发现问题不断

  1. 读取配置文件居然读取两个配置文件,一个读一点,不清楚为什么不能一个配置文件进行配置

image.png

image.png

image.png 一边获取WEB-INF下的配置文件,一边用外部配置文件进行覆盖,有人可能会问既然覆盖,那可以全在外部配置啊,问的好,如果全用外部配置,咱们代码获取属性有的加上了项目前缀(上面的两个put),有的没加,这样配置文件就显得很乱不可取,所以形成了分开配置的局面,如果接受混乱,就写在外部配置;不能全写在内部配置,因为

prop_c.setProperty(key, value);

value获取外部配置为空的时候会抛出异常;properties底层集合用的是hashTable

public synchronized V put(K key, V value) {
// Make sure the value is not null
if (value == null) {
throw new NullPointerException();
}
}
  1. 很多参数写死在代码里,如果有改动,工作量会变得异常庞大,举例权限方面伪代码
role.haveRole("ADMIN_USE")
  1. 日志打印居然sout和log混合双打

image.png

image.png

先不说双打的事,对于上图这个,应该输出包括堆栈信息,不然定位问题很麻烦,有人可能会说e.getMessage()最好,可是生产问题看多了发现还是打堆栈好;还有如果不是定向返回信息,仅仅是记录日志,完全没必要catch多个异常,一个Exception足够了,不知道原作者这么写的意思是啥;还是就是打印日志要用logger,用sout打印在控制台,那我日志文件干啥;

4.提交的代码没有技术经理把关,下发生产包是个人就可以发导致生产环境代码和本地代码或者数据库数据出现不一致的现象,数据库数据的同步是生产最容易忘记执行的一个事情;比如我的这家公司上传文件模板变化了,但是没同步,导致出问题时开发环境复现问题真是麻烦;

5.随意更改生产数据库,出不出问题全靠开发的职业素养;

6.Maven依赖的问题,Maven引pom,而pom里面却是另一个pom文件,没有生成的jar供引入,是的,我们可以在dependency里加上

<type>pom

来解决这个问题,但是公司内的,而且实际也是引入这个pom里面的jar的,我实在不知道这么做的用意是什么,有谁知道;求教 a972880380654b389246a3179add2cca~tplv-k3u1fbpfcp-jj-mark_3024_0_0_0_q75.jpg

以上这些都是我最近一家公司出现的问题,除了默默接受还能怎么办;

那有什么优点呢:

  1. 不用太怎么写文档
  2. 束缚很小
  3. 学到了js的全局调用怎么写的(下一篇我来写,顺便巩固一下)

解决之道

怎么解决这些问题呢,首先对于现有的新项目或升级的项目来说,spring的application.xml/yml 完全可以写我们的配置,开发环境没必要整外部文件,如果是生产环境我们可以在脚本或启动命令添加 nohup java -Dfile.encoding=UTF-8 -Dspring.config.location=server/src/main/config/application.properties -jar xxx.jar & 来告诉jar包引哪里的配置文件;也可以加上动态配置,都很棒的,

其次就是规范代码,养成良好的规范,跟着节奏,不要另辟蹊径;老老实实的,如果原项目上迭代,不要动源代码,追加即可,没有时间去重构的;

我也曾是个快乐的童鞋,也有过崇高的理想,直到我面前堆了一座座山,脚下多了一道道坑,我。。。。。。!


作者:小红帽的大灰狼
来源:juejin.cn/post/7371986999164928010
收起阅读 »

金价大跳水?写一个金价监控脚本

web
说在前面 😶‍🌫️国庆过后,金价就大跳水,一直往下跌,看样子暂时是停不下来了,女朋友之前也入手了一点黄金,因此对黄金价格的变化比较关心,为了让她不用整天盯着实时金价,所以就搞了一个金价监控工具,超出设置的阈值就会发送邮件提醒✉。 一、金价信息获取方案 金...
继续阅读 »

说在前面



😶‍🌫️国庆过后,金价就大跳水,一直往下跌,看样子暂时是停不下来了,女朋友之前也入手了一点黄金,因此对黄金价格的变化比较关心,为了让她不用整天盯着实时金价,所以就搞了一个金价监控工具,超出设置的阈值就会发送邮件提醒✉。



c7acc1daf5b30174b34bdd85cd34d25.jpg


一、金价信息获取方案


金价实时信息有两种方案可以获取到:


1、网页信息爬取


我们可以先找到一些官方的金价信息网站,然后直接利用爬虫直接爬取,比如:quote.cngold.org/gjs/jjs.htm…



2、通过接口获取


例如nowapi中就有黄金数据信息接口,我们可以直接通过接口来获取:



二、提醒阈值设置


1、创建数据库



2、监控页面编写


简单编写一个页面用于添加和调整提醒内容。



三、修改配置信息


1、邮箱配置


这里我使用的qq邮箱作为发件账号,需要开启邮箱授权,获取授权码。


{
host: "smtp.qq.com", // 主机
secureConnection: true, // 使用 SSL
port: 465, // SMTP 端口
auth: {
user: "jyeontu@qq.com", // 自己用于发送邮件的账号
pass: "jyeontu", // 授权码(这个是假的,改成自己账号对应即可,获取方法: QQ邮箱-->设置-->账户-->POP3/IMAP/SMTP/Exchange/CardDAV/CalDAV服务-->IMAP/SMTP开启 复制授权码)
}
}


  • (1)打开pc端qq邮箱,点击设置,再点击帐户




  • (2)往下拉 可开启POP3/SMTP服务 根据提示即可获取qq邮箱授权码




  • (3)将获取到的授权码复制到配置信息里即可



2、数据库配置


填写数据库对应的配置信息。


{
host: "localhost",
user: "root", //数据库账号
password: "jyeontu", //数据库密码
database: "test", //数据库名称
}

3、nowapi配置


免费开通后将AppKeySign替换成自己的就可以了。



{
AppKey: AppKey,
Sign: "Sign",
}

四、脚本功能编写


1、获取金价信息


我直接使用nowapi的免费试用套餐,配额是10 次/小时



const { nowapiConfig } = require("./config.js");
async function getGoldPrice() {
const result = await axios.get(
`https://sapi.k780.com/?app=finance.gold_price&goldid=1053&appkey=${nowapiConfig.AppKey}&sign=${nowapiConfig.Sign}&format=json`
);
return result.data.result.dtList["1053"];
}

获取到的数据如下:



2、获取消息提醒阈值


(1)连接数据库


使用填写好的数据库配置信息连接数据库


const mysql = require("mysql");
const { dbConfig } = require("./config.js");

const connection = mysql.createConnection(dbConfig);

function connectDatabase() {
return new Promise((resolve) => {
connection.connect((error) => {
if (error) throw error;
console.log("成功连接数据库!");
resolve("成功连接数据库!");
});
});
}

(2)查询数据


function mysqlQuery(sqlStr) {
return new Promise((resolve) => {
connection.query(sqlStr, (error, results) => {
if (error) throw error;
resolve(results);
});
});
}

async function getMessage() {
const sqlStr =
"select * from t_message where isShow = 1 and isActive = 1 and type = '金价监控';";
const res = await mysqlQuery(sqlStr);
return { ...res[0] };
}

获取到的数据如下:



3、发送提醒邮件


(1)创建邮件传输对象


使用填写好的邮箱配置信息,创建邮件传输对象


const nodemailer = require("nodemailer");
const { mail } = require("./config.js");

const smtpTransport = nodemailer.createTransport(mail);
const sendMail = (options) => {
return new Promise((resolve) => {
const mailOptions = {
from: mail.auth.user,
...options,
};
// 发送邮件
smtpTransport.sendMail(mailOptions, function (error, response) {
if (error) {
console.error("发送邮件失败:", error);
} else {
console.log("邮件发送成功");
}
smtpTransport.close(); // 发送完成关闭连接池
resolve(true);
});
});
};
module.exports = sendMail;

(2)阈值判断


判断获取到的金价信息是否超出阈值范围来决定是否发送邮件提醒


async function mail(messageInfo, goldInfo) {
let { minVal = -Infinity, maxVal = Infinity } = messageInfo;
let { buy_price } = goldInfo;
minVal = parseFloat(minVal);
maxVal = parseFloat(maxVal);
buy_price = parseFloat(buy_price);
if (minVal < buy_price && maxVal > buy_price) {
return;
}
const mailOptions = {
to: messageInfo.mail.replaceAll("、", ","), // 接收人列表,多人用','隔开
subject: "金价监控",
text: `当前金价为${buy_price.toFixed(2)}`,
};
await sendMail(mailOptions);
}

五、定时执行脚本


可以使用corn编写一个定时任务来定时执行脚本即可。



  • * * * * * *分别对应:秒、分钟、小时、日、月、星期。

  • 每个字段可以是具体的值、范围、通配符(*表示每一个)或一些特殊的表达式。


例如:


0 0 * * *:每天午夜 0 点执行。
0 30 9 * * 1-5:周一到周五上午 9:30 执行。

你可以根据自己的需求设置合适的 cron 表达式来定时执行特定的任务。


六、效果展示


如果金价不在我们设置的阈值内时,我们就会收到邮件告知当前金价:





七、脚本使用


1、源码下载


git clone https://gitee.com/zheng_yongtao/node-scripting-tool.git


  • 源码已经上传到gitee仓库


gitee.com/zheng_yongt…



  • 具体目录如下:



2、依赖下载


npm install

3、配置数据填写



这里的配置信息需要修改为你自己的信息,数据库、gitee仓库、nowapi配置。


4、脚本运行


node index.js

更多脚本


该脚本仓库里还有很多有趣的脚本工具,有兴趣的也可以看看其他的:gitee.com/zheng_yongt…




🌟觉得有帮助的可以点个star~


🖊有什么问题或错误可以指出,欢迎pr~


📬有什么想要实现的工具或想法可以联系我~




公众号


关注公众号『前端也能这么有趣』,获取更多有趣内容。


说在后面



🎉 这里是 JYeontu,现在是一名前端工程师,有空会刷刷算法题,平时喜欢打羽毛球 🏸 ,平时也喜欢写些东西,既为自己记录 📋,也希望可以对大家有那么一丢丢的帮助,写的不好望多多谅解 🙇,写错的地方望指出,定会认真改进 😊,偶尔也会在自己的公众号『前端也能这么有趣』发一些比较有趣的文章,有兴趣的也可以关注下。在此谢谢大家的支持,我们下文再见 🙌。



作者:JYeontu
来源:juejin.cn/post/7437006854122815497
收起阅读 »

程序员设计不出精美的 UI 界面?让 V0 来帮你

web
大家好,我是双越,也是 wangEditor 作者。 今年我致力于开发一个 Node 全栈 AIGC 知识库 划水AI,包括 AI 写作、多人协同编辑。复杂业务,真实上线,大家可以去注册试用。 本文分享一下前端实用的 AI 工具 v0.dev 以及我在 划...
继续阅读 »

大家好,我是双越,也是 wangEditor 作者。



今年我致力于开发一个 Node 全栈 AIGC 知识库 划水AI,包括 AI 写作、多人协同编辑。复杂业务,真实上线,大家可以去注册试用。



本文分享一下前端实用的 AI 工具 v0.dev 以及我在 划水AI 中的实际应用经验,非常推荐这款工具。


不同 AI 工具写代码


ChatGPT 不好直接写代码


去年 ChatGPT 发布,但它一直是一个聊天工具,直接让它来写代码,用一问一答的形式,体验其实并不是非常友好。


可以让它来生成一些单一的代码或工具,例如 生成一个 nodejs 发送 Email 的函数 。然后我们把生成的代码复制粘贴过来,自己调整一下。


它可以作为一个导师或助理,指导你如何写代码,但它没法直接帮你写,尤其是在一个项目环境中。


image.png


PS. 这里只是说 ChatGPT 这种问答方式不适合直接写代码,但 ChatGPT 背后的 LLM 却未后面各种 AI 写代码工具提供了支持。


Cursor 非专业程序员


Cursor 其实去年我就试用过,它算是 AI 工具 + VSCode ,付费试用。没办法,AI 接口服务现在都是收费的。


前段时间 Cursor 突然在社区中很火爆,国内外都有看过它的宣传资料,我记得看过一个国外的 8 岁小女孩,用 Cursor 写 AI 聊天工具的视频,非常有意思,我全程看完了。


image.png


Cursor 可能会更加针对于非专业编程人员,去做一些简单的 demo ,主要体验编程的逻辑和过程,不用关心其中的 bug 。


例如,对于公司的 PM UI 人员,或者创业公司的老板。它真的可以产生价值,所以它也可以收费。


Copilot 针对专业程序员


我们是专业程序员,我更加推荐 Copilot ,直接在 vscode 安装插件即可。


我一直在使用 Copilot ,而且我现在都感觉自己有点依赖它了,每次写代码的时候都会停顿下来等待它帮我生成。


在一些比较明确的问题上,它的生成是非常精准的,可以大大节省人力,提高效率。


image.png


如果你遇到 Copilot 收费的问题,可以试试 Amazon CodeWhisper ,同样的功能,目前是免费的,未来不知道是否收费。


UI 很重要!!!


对于一个前端人员,有 UI 设计稿让他去还原开发这并不难,但你让他从 0 设计一个精美的 UI 页面,这有点困难。别说精美,能做到 UI 的基本美观就已经很不容易了。


举个例子,这是我偶遇一个笔记软件,这个 UI 真的是一言难尽:左上角无端的空白,左侧不对齐,icon 间距过大,字号不统一,tab 间距过小 …… 这种比较随性的 UI 设计,让人看了就没有任何试用的欲望。


image.png


可以在对比看一下 划水AI 的 UI 界面,看颜色、字号、艰巨、icon 等这些基础的 UI ,会否更加舒适一些?专业一些?


image.png


PS. 无意攻击谁(所以打了马赛克),只是做一个对比,强调 UI 的重要性。


V0 专业生成 UI 代码


V0 也是专业写代码的,不过它更加专注于一个方向 —— 生成 UI 代码 ,能做到基本的美观、舒适、甚至专业。


给一个指令 a home page like notion.com 生成了右侧的 UI 界面,我觉得已经非常不错了。要让我自己设计,我可设计不出来。


image.png


这一点对于很多人来说都是极具价值的,例如中小公司、创业公司的前端人员,他们负责开发 UI 但是没有专业的 UI 设计师,或者说他们开发的是一些 toB 的产品,也不需要招聘一个专职的 UI 设计师。


你可以直接拷贝 React 代码,也可以使用 npx 命令一键将代码转移到你自己的项目中。


image.png


它甚至还会考虑到响应式布局和黑白主题,这一点很惊艳


image.png


再让 V0 生成一个登录页,看看能做到啥效果。在首页输入指令 A login form like Github login page


image.png


等待 1-2 分钟,生成了如下效果,我个人还是挺满意的。如果让我自己写,我还得去翻阅一些 UI 组件库文档,看 form 表单怎么写,怎么对齐,宽度多少合适 …… 光写 UI 也得搞半天。


image.png


划水AI 中“我的首页” 就是 V0 生成的,虽然这个页面很简洁,但是我个人对 UI 要求很高,没有工具帮助,我无法短时间做到满意。


image.png


最后


任何行业和领域,看它是否成熟、是否能发展壮大,一个很重要的特点就是:是否有庞大的细分领域。例如现代医学、现代制造业、计算机领域…… 专业细分及其周密,大家各司其职,整个领域才能欣欣向荣。


AI 领域也是一样,AI 编程将是一个细分领域,再往下还有更多细分领域,像针对 UI 的、针对数据库的、针对云服务的,未来会有更多这方面的发展。


作者:前端双越老师
来源:juejin.cn/post/7438647233219903542
收起阅读 »

只写后台管理的前端要怎么提升自己

本人写了五年的后台管理。每次面试前就会头疼,因为写的页面除了表单就是表格。抱怨过苦恼过也后悔过,但是站在现在的时间点回想以前,发现有很多事情可以做的更好,于是有了这篇文章。 写优雅的代码 一道面试题 大概两年以前,面试美团的时候,面试官让我写一道代码题,时间单...
继续阅读 »

本人写了五年的后台管理。每次面试前就会头疼,因为写的页面除了表单就是表格。抱怨过苦恼过也后悔过,但是站在现在的时间点回想以前,发现有很多事情可以做的更好,于是有了这篇文章。


写优雅的代码


一道面试题


大概两年以前,面试美团的时候,面试官让我写一道代码题,时间单位转换。具体的题目我忘记了。


原题目我没做过,但是我写的业务代码代码里有类似的单位转换,后端返回一个数字,单位是kb,而我要展示成 KBMB 等形式。大概写一个工具函数(具体怎么写的忘记了,不过功能比这个复杂点):


function formatSizeUnits(kb) {
let units = ['KB', 'MB', 'GB', 'TB', 'PB'];
let unitIndex = 0;

while (kb >= 1024 && unitIndex < units.length - 1) {
kb /= 1024;
unitIndex++;
}

return `${kb.toFixed(2)} ${units[unitIndex]}`;
}

而在此之前,是一个后端同学写的代码(说起来,后台管理系统前端人力不够后端帮忙写好像是常规操作,后端总觉得写前端简单,而我只能说你们那代码写的,一言难尽……),如下:


function formatSizeUnits(kb) {
var result = '';

if (kb < 1024) {
result = kb + ' KB';
} else if (kb < 1024 * 1024) {
result = (kb / 1024).toFixed(2) + ' MB';
} else if (kb < 1024 * 1024 * 1024) {
result = (kb / 1024 / 1024).toFixed(2) + ' GB';
} else {
result = (kb / 1024 / 1024 / 1024).toFixed(2) + ' TB';
}

return result;
}

虽然功能都一样,但是我写在面试的时候写了上面的代码得到了面试官的赞扬,也因此非常顺利的通过了面试。而如果我写成了下面的样子,估计不会有这种效果。


如何提升代码质量


想提升代码质量,最理想的是靠 code review ,但实际上这玩意在大多数公司根本就不存在。其次就只能多看看大佬们写的代码,但是一来后台管理本来就没太大难度很少有大佬,二来很多时候一个后台管理系统就一两个人负责。


还好现在有了各种 AI 工具,可以非常方便的优化自己的代码了。


还是上面的问题,看看 GPT 给的答案


// 提问:写一个工具函数,对文件大小的单位进行转换,加注释
// 回答:下面是一个JavaScript工具函数,它接受文件大小、初始单位、目标单位和小数位数,然后返回目标单位下的文件大小。

/**
* 将文件大小从一个单位转换为另一个单位。
*
* @param {number} size 文件大小。
* @param {string} fromUnit 初始单位('B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB')。
* @param {string} toUnit 目标单位('B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB')。
* @param {number} [decimalPoint=2] 结果保留的小数位数,默认为2。
* @return {string} 转换后的文件大小,带单位。
*/

function convertFileSize(size, fromUnit, toUnit, decimalPoint = 2) {
// 定义单位与字节之间的转换关系
const units = ['B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
// 获取初始单位和目标单位的索引
const fromIndex = units.indexOf(fromUnit);
const toIndex = units.indexOf(toUnit);

// 如果单位不在列表中,抛出错误
if (fromIndex === -1 || toIndex === -1) {
throw new Error('Invalid units');
}

// 计算初始单位与目标单位之间的转换系数
const exponent = toIndex - fromIndex;
// 计算结果大小
const resultSize = size / Math.pow(1024, exponent);

// 返回格式化后的结果
return parseFloat(resultSize.toFixed(decimalPoint)) + ' ' + toUnit;
}

// 示例使用
console.log(convertFileSize(1, 'GB', 'MB')); // 输出: 1024.00 MB
console.log(convertFileSize(1, 'MB', 'KB')); // 输出: 1024.00 KB
console.log(convertFileSize(1, 'KB', 'B')); // 输出: 1024.00 B
console.log(convertFileSize(1, 'MB', 'GB', 5)); // 输出: 0.00098 GB

还能说什么,我只能说 NB!(经评论区提示,此段代码可能有问题,建议大家在使用AI工具时,重点是借鉴思路,直接使用代码需要谨慎~)


我现在每次写大段逻辑之后都习惯拿给 AI 看看,有什么更好的实现方式,或者用什么设计模式。AI 是非常低成本且高效提升代码质量的工具。


学会封装


一个功能用到了好多次,为什么不封装成组件?一个组件用到了好几个项目,为什么不单独写个npm包?差不多的项目创建了好几个,为什么不封装成脚手架?


你说,没时间,没必要,复制粘贴反而更快。


那你就完全没理解,这么做不一定是为了让工作更快完成,而是可以让你在年年终述职时更有话说(你就算写了一百个表单表格没有写一个脚手架更值得炫耀),如果不会写可以问问 AI。


而当你真正开始封装组件,开始写工具库了,你会发现你需要思考的确实比之前多了。


关注业务


对于前端业务重要吗?


相比于后端来说,前端一般不会太关注业务。就算出了问题大部分也是后端的问题。


但是就我找工作的经验,业务非常重要!


如果你做的工作很有技术含量,比如你在做低代码,你可以面试时讲一个小时的技术难点。但是你只是一个破写后台管理,你什么都没有的说。这个时候,了解业务就成为了你的亮点。


一场面试


还是拿真实的面试场景举例,当时前同事推我字节,也是我面试过N次的梦中情厂了,刚好那个组做的业务和我之前呆的组做的一模一样。



  • 同事:“做的东西和咱们之前都是一样的,你随便走个过场就能过,我在前端组长面前都夸过你了!”

  • 我:“好嘞!”


等到面试的时候:



  • 前端ld:“你知道xxx吗?(业务名词)”

  • 我:“我……”

  • 前端ld:“那xxxx呢?(业务名词)”

  • 我:“不……”

  • 前端ld:“那xxxxx呢??(业务名词)”

  • 我:“造……”


然后我就挂了………………


如何了解业务



  1. 每次接需求的时候,都要了解需求背景,并主动去理解


    我们写一个表格简简单单,把数据展示出来就好,但是表格中的数据是什么意思呢?比如我之前写一个 kafka 管理平台,里面有表格表单,涉及什么 cluster controller topic broker partition…… 我真的完全不了解,很后悔我几年时间也没有耐下心来去了解。


  2. 每次做完一个需求,都需要了解结果


    有些时候,后台管理的团队可能根本没有PM,那你也要和业务方了解,这个功能做了之后,多少人使用,效率提高了吗?数据是怎样的?


  3. 理解需求,并主动去优化


    产品要展示一千条数据,你要考虑要不要分页,不分页会不会卡,要不要上虚拟表格?


    产品要做一个可拖拽表单,你要考虑是否需要拖动,是否需要配置。


    其实很多时候,产品的思维可能会被局限在竞品的实现方式,而前端可以给TA更多选项。在和产品沟通的时候,你不仅是沟通页面的实现,也更能理解业务。



关注源码


说到源码, Vue,React 这些基本是每次必问,也有太多大佬们的总结我就不多说了。


除此之外,我想大家每次面试应该都会被问,你写了什么亮点的项目,困难的项目,你会说什么?哦,都是表单表格,都用 Element UI 实现的,没什么难度。那估计你面试也就到这里了。


那说什么,后台管理就这些啊?!


如果你用了 Element UI 你可以说写了什么自定义 Element UI 表单组件,Element UI 表单源码是什么原理,怎么通信的?用了 Axios 可以说 Axios 的原理,它的拦截器怎么实现的?用了编辑器 diff 那你知道 diff 算法是什么吗?用了 ECharts 那你知道他底层是用什么绘制的吗?用了 husky ?husky的原理是什么?用了Vite,它为什么快?是怎么打包的?写过插件吗?


可能有人觉得我离谱,事实上上面每一个问题都是我在面试中真实被问到的。当然,如果全部去了解,肯定不现实,每个人的精力有限,不可能每个用到的每个工具每个库都去了解原理,不过只要有一两个你去了解过,就可以在面试中引导面试官来问,要学会表现出你擅长的点


至于怎么读源码?以前我不知道,现在嘛…… 为什么不问问神奇的 ChatGPT 呢?



讲一下 Axios 源码中,拦截器是怎么实现的?


Axios 的拦截器实现基于 Axios 的核心原理,即 Axios 实例是一个包含请求和响应拦截器堆栈的对象。当发出请求或接收响应时,Axios 会遍历这些拦截器,并按照添加的顺序执行请求拦截器,以及按照相反的顺序执行响应拦截器。


在 Axios 的源码中,拦截器是通过一个 AxiosInterceptorManager 实例来管理的,它维护了一个拦截器数组。每个拦截器都是一个包含 fulfilledrejected 函数的对象。这两个函数分别对应于拦截器成功处理和拦截器处理出错的情况。


以下是 Axios 拦截器管理器的一个简化版本,展示了其核心实现思路:


class InterceptorManager {
constructor() {
this.handlers = []; // 存储拦截器的数组
}

use(fulfilled, rejected) {
this.handlers.push({
fulfilled: fulfilled,
rejected: rejected
});
return this.handlers.length - 1; // 返回拦截器的ID
}

eject(id) {
if (this.handlers[id]) {
this.handlers[id] = null; // 移除拦截器
}
}

forEach(fn) {
this.handlers.forEach((h) => {
if (h !== null) {
fn(h);
}
});
}
}

在发送请求或接收响应时,Axios 会创建一个 promise 链,并通过 forEach 方法将拦截器中的 fulfilledrejected 函数添加到这个链中。这样,每个拦截器都可以对请求或响应进行处理,然后将结果传递到链的下一个拦截器,或者在出错时结束链的执行。


axios.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {
chain.unshift(interceptor.fulfilled, interceptor.rejected);
});

axios.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {
chain.push(interceptor.fulfilled, interceptor.rejected);
});

在 Axios 的完整实现中,这个拦截器机制被集成到了 Axios 的请求发送和响应处理流程中。通过这种方式,Axios 可以在发送请求之前和接收响应之后,但在用户定义的 .then.catch 执行之前,插入自定义的逻辑。


请注意,这里提供的代码只是为了说明 Axios 拦截器的实现原理,并不是 Axios 源码的完整复制。如果你对 Axios 的拦截器实现细节感兴趣,建议查看 Axios 的官方 GitHub 仓库中的源码。



前端基建


当我们工作时间久了面试难免会遇到这些问题,前端工程化,前端监控,工作流,部署,性能等等。其实我们在工作中绝大部分时间都在写代码,对于这些不是所有人都有机会接触到,不过这些和所做的业务无关,是我们提升自己很好的一个思路。


技术选型


技术栈选 Vue 还是 React?Vue 选 Vue2 还是 Vue3?组件库选 ElementUI 还是 Ant Design?微前端有没有使用过?打包工具用 Vite 还是 Webpack?有那么多表单怎么实现的,有没有什么表单配置化方案,比如Formily?


对于我这种菜鸡,我这种只写简单的表单表格的人,这些都……无所谓……


image.png

不过为了应对面试我们还是需要了解下未选择技术栈的缺点,和已选择技术栈的优点(有点本末倒置…但是常规操作啦)


Vue 你可以说简单高效轻量级,面试必会问你为什么,你就开始说 Vue 的响应式系统,依赖收集等。


React 你可以说 JSX、Hooks 很灵活,那你必然要考虑 JSX 怎么编译, Hooks 实现方式等。


总体而言,对于技术选型,依赖于我们对所有可选项的理解,做选择可能很容易,给出合理的理由还是需要花费一些精力的。


开发规范


这个方面,在面试的时候我被问到的不多,我们可以在创建项目的时候,配置下 ESlintstylelintprettiercommitlint 等。


前端监控


干了这么多年前端,前端监控我是……一点没做过。


image.png

前端监控,简单来说就是我们在前端程序中记录一些信息并上报,一般是错误信息,来方便我们及时发现问题并解决问题。除此之外也会有性能监控,用户行为的监控(埋点)等。之前也听过有些团队分享前端监控,为了出现问题明确责任(方便甩锅)。


对于实现方案,无论使用第三方库还是自己实现,重要的都是理解实现原理。


对于错误监控,可以了解一下 Sentry,原理简单来说就是通过 window.onerrorwindow.addEventListener('unhandledrejection', ...) 去分别捕获同步和异步错误,然后通过错误信息和 sourceMap 来定位到源码。


对于性能监控,我们可以通过 window.performancePerformanceObserver 等 API 收集页面性能相关的指标,除此之外,还需要关注接口的响应时间。


最后,收集到信息之后,还要考虑数据上报的方案,比如使用 navigator.sendBeacon 还是 Fetch、AJAX?是批量上报,实时上报,还是延迟上报?上报的数据格式等等。


CI/CD


持续集成(Continuous Integration, CI)和 持续部署(Continuous Deployment, CD),主要包括版本控制,代码合并,构建,单测,部署等一系列前端工作流。


场景的工作流有 Jenkins、 Gitlab CI 等。我们可以配置在合并代码时自动打包部署,在提交代码时自动构建并发布包等。


这块我了解不多,但感觉这些工具层面的东西,不太会涉及到原理,基本上就是使用的问题。还是需要自己亲自动手试一下,才能知道细节。比如在 Gitlab CI 中, Pipeline 、 Stage 和 Job 分别是什么,怎么配置,如何在不同环境配置不同工作流等。


了解技术动态


这个可能还是比较依赖信息收集能力,虽然我个人觉得很烦,但好像很多领导级别的面试很愿意问。


比如近几年很火的低代码,很多面试官都会问,你用过就问你细节,你没用过也会问你有什么设计思路。


还有最近的两年爆火的 AI,又或者 Vue React的最新功能,WebAssembly,还有一些新的打包工具 Vite Bun 什么的,还有鸿蒙开发……


虽然不可能学完每一项新技术,但是可以多去了解下。


总结


写了这么多,可能有人会问,如果能回到过去,你会怎么做。


啊,我只能说,说是一回事,做又是另一回事,事实上我并不希望回到过去去卷一遍,菜点没关系,快乐就好,一切都是最好的安排。


image.png

作者:我不吃饼干
来源:juejin.cn/post/7360528073631318027
收起阅读 »

用 vue 给女主播写了个工具,榜一大哥爱上了她,她爱上了我

web
用 vue 写了个直播助手,榜一大哥爱上了她,她爱上了我 这是一个什么样的程序?这是一个使用 sys-shim/vue3/vite 开发的一个 windows 程序。用于向网站注入自己的代码以实现一些自动化功能。 sys-shim 是什么?它是一个我开发的个人...
继续阅读 »

用 vue 写了个直播助手,榜一大哥爱上了她,她爱上了我


这是一个什么样的程序?这是一个使用 sys-shim/vue3/vite 开发的一个 windows 程序。用于向网站注入自己的代码以实现一些自动化功能。


sys-shim 是什么?它是一个我开发的个人工具,力求前端人员无需了解其他语言的情况下快速制作轻量的 windows 程序,详情请移步 electron 和 tauri 都不想用,那就自己写个想用的吧


为什么要开发这样的程序


虽然已经过去了很久,但那天的场景还是历历在目。


那天是在周五晚上 23 点过,大楼的中央空调都关了,我搓了搓手,看着还未完成的工作,想了想再不回去公车就没了,到家的话饭店也关门了。


然后按了一下显示器的电源按钮,让电脑继续工作着,准备回家吃饭后远程继续工作。


在大楼电梯遇到一个长得很挺好看的女生,由于这一层我们公司,然后看样子好像是直播部门的同事,虽然平时也都不怎么遇见,更没什么交集,只是公司偶尔让大家去主播间刷下人气,有点印象,猜想应该是直播部门的吧啦吧啦**蕾


虽然是同事,却不熟悉,想打个招呼都不知道说啥,有点尴尬。然后我索性无所是事刷微信列表去了,虽然微信列表里一条消息也没有。。。


突然她给我来了句:“小哥哥你是我们公司的吧,你们平时下班都这么晚的吗?”一边哈气搓手。


我礼貌性笑了一下:“嗯,不是每天都这么晚。”,然后继续低头无所是事的刷微信列表。


大约一两秒之后,她说:“哦”。然后再停顿一会,好像又找到了什么话题:“那你们最近工作也很忙吗?但是我前两几天也没基本没遇到我们公司这么晚下班的人”。


这句话听起来好像传达了很多信息。但时间可不允许我慢慢思考每个信息应该如何正确应对,就像领导给的项目开发时间根据来不及完善好每一个细节一样。


我只能粗略回答:“没有特别忙,只是有时候我喜欢弄些小工具啥的,一不小心就已很晚了”。我心里想:感觉有点像面试,没有说公司不好,又显得自己爱学习,是一个能沉浸于思考的人,应该没问题吧。


“真好,看得出来你还十分热爱你这份职业。能够愿意花自己的时候去研究它们。”听语气好像是有一点羡慕我,感觉还有一点就是她不太喜欢她现在的工作。是呀,我也经常在想,做直播的那些人,有多少是喜欢整蛊自己,取悦别人,有多少是喜欢见人就哥哥好,哥哥帅,哥哥真的好可爱?


“只是觉得,能有一些工具,能帮助减少些重复劳动,就挺好”。


“对对对,小哥哥你说得太对了,就是因为有工具,减少了很多像机器一样的工作,人才可以去做更多有意义的,不像是机器那样的事情。”


当她说这句话的时候,我想,有一种不知道是不是错觉的错觉,真是个有想法的人!还有,这难道是在夸我们这些做工具的人吗?但是她说这句时的微笑,一下子就让人感到了她的热情和礼貌。


我心想,竟然这么有亲和力,很想有愿意继续沟通的想法。对!不然人家怎么能做主播?要换我上去做主播,绝对场也冷了,人也散了。


我一边告诉自己,因为能做主播,所以她本身就很有亲和力,所以你感觉她很热情,是因为这个热情是固有属性,并不是对于你热情。


一边竟开始好奇,这么漂亮又有亲和力的妹子,谁的下属?忍心让她上班这么晚?谁的女朋友?忍心让她上班这么晚?


好奇心害死猫。我竟然还是问出那句话:


“为什么你这么晚才下班呢?”


“最近销售量有点下滑,我想保住我销售额前一至少前二名的位置。”听到这句话的时候,我有点惊讶。我靠,居然是销冠。然后我不温不火的说到:“是啊,快过年了,得拿年终奖。”


“不是,就是想着让成绩保持着,马上快一年了。”尴尬,人家只是想保持成绩。是我肤浅了。等等!保持快一年?没记错的话她好像也才在公司直播一年不到吧!这就是传说中的入职即巅峰吗?我突然觉得我好菜!好想快点自觉走开,奈何地铁还没到!


“原来是销冠,这么厉害!我以为是年底为了冲年终奖,是我肤浅了~”我简单表达一下敬意和歉意。有颜值有能力,突然人与人之间的距离一下就拉开了。


“没有没有!钱也重要,钱也重要!”她噗呲一笑。然后用期盼的眼神看着我,“对了,你喜欢研究小工具来着,你有没有知道哪种可以在直播时做一些辅助的小工具?我网上找了好多,都是只能用在抖音斗鱼这些大公司的辅助工具,我们公司的这个直播平台的一直没有找到。哎呀!好烦~”


完犊子了,这题我不会。看着她好像是工具花了很久没有找到,焦急得好像就要跺脚的样子,我只感觉头皮发麻,要掉头发了!怎么办?怎么办?哪里有这种工具?


但话题还是要接着啊!我开始答非所问:“到没关注过这方面的小工具,但我听说现在有些自动直播的工具,可以克隆人像和声音二十四小时直播。”


“不需要不需要,我不需要这么高端的工具,而且那些自动播的很缺少粉丝互动的。我只要可以帮我定时上下架商品啥的就好。”


我心想,这不搞个脚本 setInterval 一下就行?虽然但是要做得方便他们使用的形式还是得折腾下。我们这个直播平台又不是大平台,网上肯定也没有现成的,不过要做一个没什么难度。


我回答说:“那我帮你找找。”


“谢谢谢谢小哥哥!你人真好!”看着她一边开心的笑着一边双手拜托的样子,我既感觉完犊子了入坑了,又恨不得现在就给她做一个出来!


车来了。她转头看了一下,然后又转过头来问我“小哥哥可以加下你微信吗?你有消息的话随随时通知我,我都在的。”


我:“行的。”


她:“我加你我加你~”


我竟然一下子没有找到我的微信二维码名片在哪,确实,从来就没有其他女生加过我,没什么经验倒也正常,是吧?她又转头看了看停车的车,我知道她是她的车,可她还告诉我没事的慢慢来。


她加上了我的微信,然后蹦上滴滴滴快要关门的列车,在窗口笑着向我挥手告别。在转角那一刻她指了指手机,示意我看微信。


“我叫李蕾^_^”。


“收到”。


alt


功能设计


在上一节为什么要开发这样的程序花费了一定量的与技术无关的笔墨,可能有些读者会反感。对此我表示:你以为呢?接到一个项目哪那么容易?手动狗头。


在功能方面,主要考虑以下特性:


开发时方便


不方便肯定会影响开发进度啦。热更新热部署啥的,如果没有这些开发体验那可是一点都不快乐~


使用时点开就能用


解压、下一步下一步安装了都不要了。


多设备下多平台下多配置支持


如果不做设备隔离,万一主播把这软件发给别人用,岂不是乱套了。多平台的考虑是因为反正都是注入脚本,就统一实现。多配置主要实现每个配置是不同的浏览器配置和数据隔离。


便于更新


减少文件发来发去、版本混乱等问题。


便于风控


如果改天主播说这软件不想用了,那我远程关闭就行。


看下总体界面


alt


一个设备支持多个主配置,每个主配置可以绑定密钥进行验证。


主配置验证通过之后,才是平台配置,平台配置表示系统已支持自动化的平台,例如疼训筷手这些平台。这些每个平台对应自己的 logo、自动化脚本文件和状态。


自动化脚本文件在开发过程中可以修改,用户侧不可见,直接使用即可。


每个平台下有多个配置,比如疼训这个平台下,创建配置A作为账号A的自动化程序,配置B作为账号B的自动化程序。因为每个配置启动的是不同的浏览器实例,所以疼训理论上不会认为多个账号在同一浏览器下交叉使用。反正我司的平台肯定不会认为~


然后配置下有一些通用的功能:例如智能客服可以按关键字进行文字或语音回复。


例如假设你配置了一个关键字列表为


keys = [`小*姐姐`, `漂亮`]
reply = [`谢谢大哥`, `大哥你好呀`, `你也好帅`]

当你进入直播间,发了一句小*姐姐真漂亮时,就可能会自动收到小*姐姐的语音谢谢大哥, 你也好帅


在场控助手这边,根据场控需求,直播间可以按指定规则进行自动发言,自动高亮评论(就是某个评论或系统设定的内容以很抢眼的形式展示在屏幕上),这是防止直播间被粉丝门把话题逐渐带偏的操作方法之一。


商品助手这边,有一些按指定规则、时间或顺序等配置展示商品的功能。


技术选型



  • 使用 vue3/vite 进行界面开发。这部分众所周知是热更新的,并且可以在浏览器中进行调试。

  • 使用 sys-shim 提供的 js api 进行浏览器窗口创建、读写操作系统的文件。当创建浏览器窗口后,需要关闭窗口。

  • 使用 mockm 进行接口开发,自动实现多设备、平台、配置的 crud 逻辑支持。


在 vue3 进行界面开发的过程中,这个过程可以在浏览器里面也可以 sys-shim 的 app 容器中。因为界面与 sys-shim 进行通信主要是通过 websocket 。前端调用某个函数,例如打开计算器,然后这个函数在内部构造成 websocket 的消息体传给 sys-shim 去调用操作系统的 api 打开计算器。就像是前端调用后端提供的 api 让后端调用数据库查询数据,返回数据给前端。


在界面完成之后,把界面部署在服务器上,这样如果有更新的话,就像普通的前端项目一样上传 dist 中内容在服务器上即可。发给主播的 app 读取服务器内容进行界面展示和功能调用。


计划安排



  • 周五加加班,用两小时完成数据模型、API实现

  • 周六完成主要功能界面、交互开发

  • 周日上午进行体验完善、发布测试


开发过程


由于我只是个做前端的,并且只是个实习生。所以用到的技术都很简单,下面是具体实现:


数据模型、API实现


由于是多设备、多平台、多配置,所以数据模型如下:


const db = util.libObj.mockjs.mock({
// 设备
'device|3-5': [
{
'id|+1': 1,
电脑名: `@cname`,
},
],
// 主配置
'config|10': [
{
'id|+1': 1,
deviceId() {
const max = 3
return this.id % max || 3
},
名称: `@ctitle`,
卡密: `@uuid`,
激活时间: `@date`,
过期时间: `@date`,
},
],
// 平台
platform: [
{
id: 1,
封面: [
{
label: `@ctitle`,
value: `@image().jpg`,
},
],
网址: `https://example.com/`,
状态: `可使用`,
脚本文件: [
{
label: `@ctitle().js`,
value: `@url().js`,
},
],
名称: `豆印`,
},
],
'devicePlatformConfig|1-3': [
{
'id|+1': 1,
名称: `默认`,
deviceId() {
const max = 3
return this.id % max || 3
},
platformId() {
const max = 3
return this.id % max || 3
},
configId() {
const max = 3
return this.id % max || 3
},
数据目录() {
return `data/${this.id}`
},
// 功能配置
action: {
智能客服: {
文字回复: {
频率: `@integer(1, 5)-@integer(6, 10)`,
启用: `@boolean`,
'配置|1-5': [
{
关键词: `@ctitle`,
回复: `@ctitle`,
},
],
},
// ... 省略更多配置
},
// ... 省略更多配置
},
},
],
}),

观察上面的数据模型, 例如主配置中有一个 deviceId,由于这个字段是以驼峰后缀的 Id 结尾,所以会自动与 device 表进行关联。


platform 这张表由于没有与其他表有关联关系,所以无需添加含有 ...Id 的字段。


devicePlatformConfig 平台设备配置这张表,是某设备创建的针对于某一主配置下的某平台下的某一配置,所以会有 deviceId / platformId / configId


这样如何要查某设备下的所有平台的配置,直接 /devicePlatformConfig?deviceId=查某设备ID 即可。


由于上面这些表声明关联关系之后,模拟数据和接口都是自动生成的,所以这一块并没有其他步骤。


在 api 层面,有一个需要处理的小地方,就是类似于登录(token/用户标识)的功能。由于这个程序并不需要登录功能,所以使用设备ID作为用户标记。


const api = {
async 'use /'(req, res, next) {
// 不用自动注入用户信息的接口, 一般是系统接口, 例如公用字典
const publicList = [`/platform`]
const defaultObj =
!publicList.includes(req.path) &&
Object.entries({ ...req.headers }).reduce((acc, [key, value]) => {
const [, name] = key.match(/^default-(.*)$/) || []
if (name) {
const k2 = name.replace(/-([a-z])/g, (match, group) => group.toUpperCase())
acc[k2] = value
}
return acc
}, {})
if (req.method !== `GET`) {
req.body = {
...defaultObj,
...req.body,
}
}
req.query = {
...defaultObj,
...req.query,
}
next()
},
}

在后端 api 入口上,我们添加了一个拦截器,含有 default- 开头的键会被当成接口的默认参数。如果传设备 id 就相当于给每个接口带上设备标记,后面这个设备创建和修改、查询配置都会被限定在改设备下,实现了类似某用户只能或修改查看某用户的数据的功能。对于之前提到的公用数据,例如 /platform 这个接口的数据是所有用户都能看到,那直接配置到上面的 publicList 中即可。


前端的请求拦截器是这样的:


http.interceptors.request.use(
(options) => {
options.headers[`default-device-id`] = globalThis.userId
return options
},
(error) => {
Promise.reject(error)
},
)

什么?并不严谨?啊对对对!


界面实现:首先做一个浏览器


由于只会一些简单的跑在浏览器里的 js/css ,所以我们要先做一个浏览器来显示我们的软件界面。


经常用 google chrome,用习惯了,并且听说它还不错。所以打算做一个和它差不多的浏览器。


它封装了 chromium 作为内核,那我们也封装 chromium 吧。


微软听说大家都想要做个基于 chromium 的的界面渲染程序,于是微软就给我们做好了,叫 microsoft-edge/webview2


听说大家都在用这个渲染引擎,那么微软干脆把它内置于操作系统中,目前 win10/win11 都有,win7/8 也可以在程序内自动在线安装或引用安装程序离线安装。


不知不觉的浏览器就做好了。


如何使用这个做好的浏览器


由于只会 js ,所以目前我使用 js 创建这个 webview 实例是这样的:


const hwnd = await hook.openUrl({
url: platformInfo.value.网址,
preloadScript,
userDataDir: row.数据目录 || `default`,
})

可以看到,上面的 js 方法支持传入一个网址、预加载脚本和数据目录。


在这个方法的内部,我们通过构造一个 aardio 代码片段来创建 winform 窗口嵌入 webview 实例。


至于要构造什么 aardio 片段,是 aardio 已经做好相关示例了。复制粘贴就能跑,需要传参的地方,底层是使用 ipc 或 rpc 进行通信的。


ipc 是进程之前通知,可以简单的理解为一个基于事件的发布订阅程序。


rpc 是远程调用,可以简单理解为我们前端经常调用的 api。服务端封装好的 api,暴露给前端,直接调用就好了。


aardio示意片段


var winform = win.form({text: `sys-shim-app`}) // 创建一个 windows 窗口
var wbPage = web.view(winform, arg.userDataDir, arg.browserArguments) // 使用指定配置启动一个浏览器示例
wbPage.external = { // 向浏览器注入全局变量
wsUrl: global.G.wsUrl;
}
wbPage.preloadScript(arg.preloadScript) // 向浏览器注入 js 脚本
wbPage.go(arg.url) // 使用创建的浏览器打开指定 url
winform.show() // 显示窗口

有了上面的代码,已经可以做很多事情了。因为向浏览器注入了一个全局变量 wsUrl,这是服务端的接口地址。然后在注入的脚本里去连接这个接口地址。


脚本由于是先于 url 被加载的,所以首先可以对页面上的 fetch 或者页面元素这些进行监听,实现拦截或代理。另外 webview 也提供了 cdp 层面实现的数据监听。


功能实现:让宿主与实现分离


这里的宿主是指除开 注入自定义脚本 的所有功能。根据之前的设计,网站地址是用户配置的,脚本也是用户上传的。所以一切都是用户行为,与平台无关?


啊对对对就这样!


把自动化这块功能分离出去,让其他人写(我不会!手动狗头)。然后我们在程序里为现有功能做一个事件发布。当用户开启了某个功能,脚本可以知道,并可以得到对应配置的值,然后去做对应功能的事。


const keyList = Object.keys(flatObj(getBase()))
keyList.forEach((key) => {
watch(
() => {
return deepGet(devicePlatformConfig.value, key)
},
(newVal, oldVal) => {
keyByValueUpdate(key, newVal, oldVal)
},
{
immediate: true,
},
)
})


getBase 是一个配置的基础结构对象。把这个对象扁平化,就能等到每个对象的 key,使用 vue 的 watch 监听每个 key 的变化,变化后分别发布 [key, 当前值, 占值, 整个配置对象]


这样在自动化脚本那边只需要订阅一下他关心的 key 即可。


例如:当 场控助手.直播间发言.频率 从 2 变成 6 。


alt


ws.on(`action.场控助手.直播间发言.频率`, (...arg) => {
console.log(`变化了`, ...arg)
})

好了,接下来的内容就是在群里 v50 找人写写 js 模拟事件点击、dom监听啥的了(具体自动化脚本略,你懂的~手动狗头)。


alt


测试过程


总算赶在了周一完成了功能,终于可以进行测试啦~


alt


她同事进行功能测试的时候,提出了一些修改意见(还好是自己写的,不然真改不动一点),然后有个比较折腾的是原来我的配置窗口和平台直播页面是分别在不同的 windows 窗口下的,可以相互独立进行拖拽、最小化等控制,因为想着独立开来的话配置窗口就不会挡住直播页面的窗口了。


没想到她希望配置窗口可以悬浮在直播平台的页面上,并且可以展开折叠拖动。这对于之前设计的架构有一些差异,修改花了点时间。


alt


alt


alt


最终结果


alt


我很满意,手动狗头。


相关内容



声明:本文仅作为 sys-shim 的程序开发技术交流,本人没有也不提供可以自动化操作某直播平台的脚本。


作者:四叶草会开花
来源:juejin.cn/post/7448951076685119529
收起阅读 »

BOE(京东方)“向新2025”年终媒体智享会首站落地上海 六大维度创新开启产业发展新篇章

12月17日,BOE(京东方)以“向新2025”为主题的年终媒体智享会在上海启动。正值BOE(京东方)新三十年的开局之年,活动全面回顾了2024年BOE(京东方)在各领域所取得的领先成果,深度解读了六大维度的“向新”发展格局,同时详细剖析了BOE(京东方)在智...
继续阅读 »

12月17日,BOE(京东方)以“向新2025”为主题的年终媒体智享会在上海启动。正值BOE(京东方)新三十年的开局之年,活动全面回顾了2024年BOE(京东方)在各领域所取得的领先成果,深度解读了六大维度的“向新”发展格局,同时详细剖析了BOE(京东方)在智能制造领域的领先实践。BOE(京东方)执行委员会委员、副总裁贠向南,BOE(京东方)副总裁、首席品牌官司达出席活动并发表主旨演讲。

经过三十年创新发展,秉持着对技术的尊重和对创新的坚持,在“屏之物联”战略指导下,BOE(京东方)从半导体显示领域当之无愧的领军巨擘迅速蝶变,成功转型为全球瞩目的物联网创新企业,并不断引领行业发展风潮。面对下一发展周期,BOE(京东方)将从战略、技术、应用、生态、模式、ESG六大方面全方位“向新”突破,以实现全面跃迁,并为产业高质发展注入强劲动力。

战略向新:自2021年“屏之物联”战略重磅发布以来,BOE(京东方)又于2024年京东方全球创新伙伴大会(BOE IPC·2024)上发布了基于“屏之物联”战略升维的“第N曲线”理论,以半导体显示技术、玻璃基加工、大规模集成智能制造三大核心优势为基础,精准布局玻璃基封装、钙钛矿光伏器件等前沿新兴领域,全力塑造业务增长新赛道。目前,玻璃基封装领域,BOE(京东方)已布局试验线,成立了玻璃基先进封装项目组,实现样机产出;钙钛矿领域,仅用38天就已成功产出行业首片2.4×1.2m中试线样品,标志着钙钛矿产业化迈出了重要一步。

技术向新:2021年,BOE(京东方 )发布了中国半导体显示领域首个技术品牌,开创了产业“技术+品牌”双价值驱动的新纪元。以技术品牌为着力点,BOE(京东方)深入赋能超5000家全球顶尖品牌厂商和生态合作伙伴,包括AOC、ROG、创维、华硕、机械师、雷神、联想等,助力行业向高价值增长的路径迈进,也为用户提供了众多行业领先、首发的更优选择。 BOE(京东方)还将全力深化人工智能与半导体显示技术以及产业发展的深度融合,并在AI+产品、AI+制造、AI+运营三大关键领域持续深耕,并依托半导体显示、物联网创新、传感器件三大技术策源地建设,与产业伙伴和产学研合作伙伴共同创新,为产业高质量可持续发展保驾护航。

应用向新: BOE(京东方)不仅是半导体显示领域的领军企业,也是应用场景创新领域的领跑者,BOE(京东方)秉持“屏之物联”战略,以全面领先的显示技术为基础,通过极致惊艳的显示效果、颠覆性的形态创新,为智慧座舱、电竞、视觉艺术、户外地标等场景注入了新鲜血液,带给用户更加美好智慧的使用体验。以智慧座舱为例,根据市场调研机构Omdia最新数据显示,2024年前三季度京东方车载显示出货量及出货面积持续保持全球第一,在此基础上BOE(京东方)还推出“HERO”车载场景创新计划,进一步描绘智能化时代汽车座舱蓝图。

生态向新: BOE(京东方)持续深化与电视、手机、显示器、汽车等众多品牌伙伴的合作,共同打造“Powered by BOE”产业生态集群,赢得众多客户的认可与赞誉。与此同时,BOE(京东方)还持续拓展跨产业生态,通过与上海电影集团、故宫博物院、微博等文化产业领先机构展开跨界合作,以创新技术赋能传统文化艺术与影像艺术。此外,通过战略直投、产业链基金等股权投资方式协同众多生态合作伙伴,通过协同合作、资源聚合共同构筑产业生态发展圈层。

模式向新: 为适配公司国际化、市场化、专业化的长远发展,BOE(京东方)持续深化“1+4+N+生态链”的业务发展架构,以及“三横三纵”组织架构和运营机制。在充分市场化和充分授权的机制保障下,形成了以半导体显示核心业务为牵引,传感、物联网创新、MLED业务、智慧医工四大高潜航道全面开花,聚焦包括智慧车联、工业互联、数字艺术、3D光场等规模化应用场景,生态链确保产业上下游合作伙伴协同跃迁的“万马奔腾”的发展图景。此外,BOE(京东方)还鼓励员工创新创业,通过激发人才创新热情,共同为集团发展注入强劲内生动力。

ESG向新: 2024年,BOE(京东方)承诺将在2050年实现自身运营碳中和,并通过坚持“Green+”、“Innovation+”、“Community+”可持续发展理念,推动全球显示产业高质永续发展。“Green+”方面,BOE(京东方)依托 16 家国家级绿色工厂、1 座灯塔工厂及1座零碳工厂,以绿色产品、制造与运营践行低碳路径;“Innovation+”方面,BOE(京东方)凭借全部为自主创新的9万件专利的行业佳绩,以及技术策源地、技术公益池等举措,携手产业上下游伙伴协同创新;“Community+”方面,BOE(京东方)在教育、医疗、环境等公益领域持续投入,积极履行社会责任,例如,在“照亮成长路”公益项目中,BOE(京东方)十年间在偏远地区建设的智慧教室已经突破120所。

BOE(京东方)智能制造:铸就行业新典范

BOE(京东方)智能制造在引领标准、数字化变革、AI+制造和可持续发展四个方面,树立了全球智能制造卓越标杆,并引领产业迈向智能化、绿色化新时代。在引领标准方面,BOE(京东方)已建立起遍布全球的智能制造体系,包括18条半导体显示生产线和6大全球智能终端服务平台,并荣膺全球智能制造最高荣誉——世界经济论坛“灯塔工厂”。为应对布局全球的产供销业务体系,BOE(京东方)已构建起设供产销集成管理系统,可实现业财一体的全生命周期智能决策;在数字化变革方面,BOE(京东方)正致力于打造“一个、数字化、可视的京东方”,包括流程、组织、IT、数据四大管理要素,通过建立一个基于流程的、端到端的、高效的数字化管理体系为智能制造赋能;在AI+制造方面,通过系统化运用AI、大数据等技术,BOE(京东方)结合生产制造痛点难点问题,聚焦效率领先、品质卓越,务实高效地执行AI+制造规划。在品质把控方面,BOE(京东方)打造的IDM质检平台(Intelligence defect management)是面向业务人员开发的系统,功能覆盖工业质检全场景及AI建模全流程,引入大模型标注、判定技术,打通场景、工序、代际壁垒,极大提升了人机协同下的复判效率和判定准确率,在确保产品高质量的同时实现成本的有效控制;在可持续发展方面,BOE(京东方)始终秉承“以绿色科技推动生产发展理念”,旗下16家工厂获得国家级“绿色工厂”称号,以绿色制造助力产业可持续升维发展。

“向新2025”年终媒体智享会,是BOE(京东方)2024创新营销的收官之作和全新实践,系统深化了大众对BOE(京东方)品牌和技术创新实力的认知与理解。近年来,BOE(京东方)通过多种创意独具的品牌破圈推广,包括“你好BOE”系列品牌线下活动、技术科普综艺《BOE解忧实验室》等生动鲜活地传递出BOE(京东方)以创新科技赋能美好生活的理念,为企业业务增长提供了强大动力,也为科技企业品牌推广打造了全新范式。据了解,BOE(京东方)该“向新2025”主题系列活动还将于12月20日和12月27日分别落地成都和深圳。

面向未来,BOE(京东方)将胸怀“Best on Earth”宏伟愿景,坚持“屏之物联”战略引领,持续推动显示技术和物联网、AI等前沿技术的深度融合。从提升产品视觉体验到优化产业生态协同,从升级智能制造体系到践行社会责任担当,BOE(京东方)将砥砺奋进、创新不辍,为全球用户呈献超凡科技体验,领航全球产业创新发展的新篇章。

收起阅读 »

BOE(京东方)北京京东方医院主体结构开工 打造医工融合创新典范

12月12日,BOE(京东方)旗下北京京东方医院主体结构正式开工。北京京东方医院是2024年北京市“3个100”重点工程项目,定位为BOE(京东方)智慧物联网医院总院,位于房山区京东方生命科技产业基地,总占地面积约152亩, 总床位1500张,其中一期建设10...
继续阅读 »

12月12日,BOE(京东方)旗下北京京东方医院主体结构正式开工。北京京东方医院是2024年北京市“3个100”重点工程项目,定位为BOE(京东方)智慧物联网医院总院,位于房山区京东方生命科技产业基地,总占地面积约152亩, 总床位1500张,其中一期建设1000床,预计2026年建成开诊。北京京东方医院的建设将打造分级诊疗体系区域样板,为大众提供优质便捷高效的医疗服务,同时积极构建医工融合的产业集群,为区域医疗产业的智慧转型注入强劲动力。

京东方科技集团党委书记、副董事长冯强在致辞中表示,智慧医工业务作为BOE(京东方)在大健康领域的重要战略布局,历经十年发展,形成了以健康管理为核心,医工产品为牵引、数字医院为支撑的健康物联生态系统,并按照医工融合的发展理念,在房山布局了集“医教研产用”于一体的生命科技产业基地,北京京东方医院正是基地的核心支撑平台。医院以三级综合医院为基础,结合BOE(京东方)在显示、物联网、智慧医工等方面的核心优势,按照“补缺、合作、差异化”的原则,着力打造“技术领先、数字驱动、模式创新”的BOE(京东方)智慧物联网医院总院。

北京京东方医院将聚焦重症康复、急诊急救等重点学科,积极引进顶尖技术,推动诊疗技术向精准医学方向发展,做卓越医疗的践行者,并充分利用物联网和人工智能技术,建立数字孪生医院,做智慧医疗的引领者。同时,建立开放创新的平台化体系,汇聚专家资源,建立核心能力,将服务体系延伸到社区和家庭,做新型服务模式的创建者。作为生命科技产业基地的核心支撑,北京京东方医院将持续与全国一流高校、医疗机构、创新企业等有机协同,共同构建“从临床来,到临床去”的创新转化体系,推动生命科技产业新质生产力发展。

多年来,BOE(京东方)不断探索未来医疗健康产业的高潜发展方向,通过科技与医学融合创新,打通了“防治养”的全链条,实现了“医”为“工”提供需求来源和临床转化,“工”为“医”的技术提升持续赋能。目前,BOE(京东方)已在北京、合肥、成都、苏州四地建设并运营5家数字医院。面向未来,BOE(京东方)将坚持以“屏之物联”战略为牵引,积极推动医疗健康产业的智慧转型,以创新驱动和科技赋能开启医工融合发展的崭新篇章。

收起阅读 »

大学生编程第一人,一人抵一城!

就在上个月底,领域内知名的自动驾驶公司小马智行在纳斯达克成功挂牌上市,成为自动驾驶领域新焦点,这个新闻相信不少同学都看到了。 提到小马智行这个公司,可能有些同学还不是很了解。 但是提到小马智行公司的CTO,那相信不少同学就耳熟能详了。 没错,他就是那个神一...
继续阅读 »

就在上个月底,领域内知名的自动驾驶公司小马智行在纳斯达克成功挂牌上市,成为自动驾驶领域新焦点,这个新闻相信不少同学都看到了。



提到小马智行这个公司,可能有些同学还不是很了解。



但是提到小马智行公司的CTO,那相信不少同学就耳熟能详了。


没错,他就是那个神一般的男人,有着「中国大学生计算机编程第一人」称号,并且江湖人尊称为「楼教主」的计算机编程大牛:


楼天城博士



2016年底,楼天城和他的合伙人创立了小马智行,致力于提供安全、先进、可靠的全栈式自动驾驶技术。



不过在此之前,楼天城就以比赛ID “ACRush” 为计算机编程界所熟知。


楼教主毕业于清华,曾连续11年蝉联TopCoder中国区冠军,并且两次获得谷歌全球编程挑战赛冠军。他的职业生涯开始于谷歌,并且在创立小马智行之前,也曾是百度历史上最年轻的T10工程师。


2024年,楼天城以60亿元人民币财富登上《2024年·胡润百富榜》第875位。



从某一程度上也实现了靠写代码,登上了胡润财富榜!


看到这里,相信大家也都好奇这位编程大佬的的成长经历和成神之路。


究竟是怎样一个环境和经历才能造就今天的楼教主呢,今天这篇文章我们就来好好聊一聊。


0x01


1986年,楼天城出生于一个知识分子家庭,父母均为教育工作者,这样的家庭环境为他提供了良好的学习氛围。


尽管童年时期的他并未直接接触到计算机编程,但楼天城却展现出了对数学和逻辑的浓厚兴趣。


楼天城的理科思维十分敏捷,甚至在踢球时,也会计算战术中的各种概率,展现了他对细节的极致追求,这也为他日后的编程之路奠定了坚实的基础。


楼天城高中毕业于杭十四中。


众所周知,这是一所具有悠久历史的百年名校,位于美丽的西子湖畔,同时也是浙江省一级重点中学。



在进入杭十四中后,一次偶然的机会,楼天城加入了学校的计算机兴趣小组,从此开启了与编程的不解之缘。


在短短三个月内,他凭借自学,就在全国青少年信息学联赛(浙江赛区)中脱颖而出,荣获一等奖,这标志着他在编程领域的初步成功,也点燃了他对计算机和编程的巨大热情。


而这,只是他成绩的开端。


0x02


高中时期的楼天城由于竞赛成绩十分优秀,因此也成功保送进入清华大学计算机系,并在后来加入由图灵奖得主姚期智院士领导的清华计算机科学实验班(俗称“姚班”),并成为姚班的首届学生之一。



姚期智先生是世界著名的计算机科学家,唯一的图灵奖华人得奖者;而姚班则是中国乃至全球顶尖的计算机科学人才培养基地。


在这里,楼天城不仅系统学习了计算机科学的基础理论,更是参加了各类编程竞赛,成为校园内的传奇人物。


本科期间,楼天城以其深厚的编程功底和卓越的思维能力在各类竞赛中大放异彩,经常以一人单挑一个队,并且曾多次带领团队获得国内外编程竞赛的冠军,在ACM等编程竞赛界可谓是无人不知、无人不晓,因此也获得了“楼教主”的称号。


本科毕业以后,楼天城选择继续留校读博,并且继续师从姚期智院士。


在这个阶段,楼天城接受了更为严格的学术训练和前沿的科研指导。


在博士阶段,楼天城前期做的偏向theoretical computer science(理论计算机科学),后期偏向Social Network。


这个阶段的积累,为他日后的科研和创业之路打下了坚实的基础。


从高中到本科到读研,回顾楼天城的竞赛经历,可以说堪称传奇。
从高中开始,他几乎每一年都能拿到有关数学或者计算机方面的奖。


而且楼天城的竞赛经历几乎囊括了国内外所有重要的编程赛事,每一次参赛都留下了令人瞩目的成绩。


从高中时期的全国青少年信息学竞赛,到国际信息学奥林匹克竞赛(IOI)金牌,再到Google全球编程挑战赛冠军,楼天城用一次次胜利证明了自己的实力。


尤其是TopCoder,楼天城曾连续11年蝉联TopCoder中国区冠军,并且两次获得谷歌全球编程挑战赛冠军。


这些竞赛经历不仅锻炼了楼天城的编程能力和团队协作能力,更为他日后的职业发展奠定了坚实的基础。


0x03


毕业后的楼天城,职业生涯开始于谷歌,曾在谷歌总部从事社交网络和机器学习相关问题的研究。



2016年,楼天城受邀加入了百度美国研发中心,并且与当时的百度自动驾驶部门首席架构师彭军一起参与百度无人车和自动驾驶技术的研发。



在百度的工作期间,楼天城致力于自动驾驶相关技术的研究,同时他凭借卓越的技术实力和丰富的经验,也成为了百度历史上最年轻的T10工程师。
这段经历不仅加深了他对自动驾驶技术的理解,也让他看到了自动驾驶技术改变未来出行的巨大潜力,更是为即将到来的创业埋下了伏笔。


在百度工作了一段时间后,楼天城选择了从百度离职,并且与同时离职百度的首席架构师彭军一起创业,创立了自动驾驶创业公司小马智行。


至此,小马智行正式诞生



公司成立以后,彭军担任小马智行首席执行官,负责公司总体事务,而热爱技术和编程的楼天城则担任小马智行首席技术官,主要负责技术研发。


而且小马智行的初创团队成员不少都是楼天城曾经在竞赛中认识的朋友,或者是因其名气而慕名加入的。


楼天城作为公司的CTO,亲自参与了自动驾驶相关技术的设计与测试,带领团队攻克了一个个技术难题,推动小马智行的自动驾驶技术不断向前发展。



小马智行自成立之日起,就以其技术实力和前瞻性市场布局迅速成为了自动驾驶领域的佼佼者。而经过这几年的发展,如今的小马智行已经成为自动驾驶领域的领军企业之一。



0x04


回顾楼天城一路走来的成长经历:


从中学时期对编程的兴趣出露,到大学成为一个顶尖算法竞赛选手,再到研究生期间从事理论计算机等研究,最后再到走向业界与创业。


虽说这个过程充满了传奇色彩,但其中也不乏兴趣务实长期主义,以及坚持


楼教主曾说:


要学习认识你自己,了解什么样的事情会让自己开心,爱好就像一个多臂老虎机,要每个臂多拉几下才能知道自己的兴趣所在。


的确,像楼教主这样,在前行的路上找到自己所热爱的事业,并为之全力奔赴,这是一件何其幸运的事情。



注:本文在GitHub开源仓库「编程之路」 github.com/rd2coding/R… 中已经收录,里面有我整理的6大编程方向(岗位)的自学路线+知识点大梳理、面试考点、我的简历、几本硬核pdf笔记,以及程序员生活和感悟,欢迎star。



作者:CodeSheep
来源:juejin.cn/post/7447103424360349732
收起阅读 »

87年,37岁,脱下孔乙己的长衫,我开了家一人公司。

你好, 我是微笑哥。在职场做了 10 年的程序员,从 Java 开发做到研发副总,离职前带领着100+的研发队伍。19年开启自由职业,全世界一边旅行一边工作,2020年回西安创业,换了3个客厅2个办公楼走到今天。这中间,真的是脱了几层皮,从一名少年成为现在的沧...
继续阅读 »

你好, 我是微笑哥。
在职场做了 10 年的程序员,从 Java 开发做到研发副总,离职前带领着100+的研发队伍。
19年开启自由职业,全世界一边旅行一边工作,2020年回西安创业,换了3个客厅2个办公楼走到今天。
这中间,真的是脱了几层皮,从一名少年成为现在的沧桑大叔。借着这个日子,和大家聊聊我的经历。


1


毕业即失业

去流水线感悟人生


我大学学的是信息与科学,是一个没有对口就业的专业,我的同学各凭本事分布在各行各业。

大学玩了4年,到大四我慌了,我没背景也没能力,真不知道未来怎么走,只能疯狂去面试。

当时在宝鸡上的大学,大四上半年全部时间都去西安面试,2个月时间面试了几十上百家,最后入职了一家炒股软件公司。

说是储备干部,其实就是销售,去各个证券交易所里面找人要电话号码,然后邀请去公司做活动买软件。

这不是我想要的工作,年前快放寒假的时候辞职了,没有底薪只有提成,一分钱没有拿到回学校了。

临近过年,更着急了。

那个时候老大在比亚迪工厂,于是想去深圳看看有没有就业机会,于是坐了20多个小时火车来到深圳。

求职无果后,入职了比亚迪流水线车间,车间里面做了一周时间,差点和车间主任干起来了,工作是给硬纸板打孔很危险,墙上到处是事故照片,没有指头的那种,想了想还是辞了。

我在富士康工厂,周边环境

临近过年总不能空手回家吧,又去了富士康观澜的物流部,不说有多辛苦好歹扎扎实实工作了2个月。

人生真的很神奇,我去的那个厂子就是富士康当年十几跳的第一跳,我刚去就有工友给我说前几天有人跳楼了。

那是09年,我人生第二次在外地过春节;第一次是06年被我兄弟骗到传销组织安徽阜阳,被限制自由了28天。

而最夸张的是,我有个很铁的朋友,妹妹被骗到传销组织中,中间我竟然还请了2周假,想办法把他妹妹从传销组织搞了出来,不过那就是另外一个故事了。

总感觉大四那一年,经历了很多事情,很混乱很懵懂也很迷茫,就像青春少年本身就是迷茫一样

我在流水线挥汗如雨的时候,我就只想了一件事情,我一个大学生要在这流水线干一辈子吗,我这大学不是白读了。

于是3月份春暖花开的时候,又回陕西了。



2


误入程序员


人生有时候就是需要一个契机,刚经历的时候没觉得有啥,当把这些都串起来的时候,就成为了人生。

我在大三的时候,突然感觉大学白读了,不学点啥好像又对不起这4年,上课感觉毫无意义工作又不用(我们是数学专业,天天玩高数、微积分)

刚好听说有数学建模竞赛,我就报名了,玩命的学了3个月,我是小组负责编程的那位也是组长,把C语言玩的贼溜。

没想到几个月后也获奖了,好像是省级二等奖,上图左下方那个人就是我,在学校宾馆小组3天3夜写一份论文出来。

让我对程序有了启蒙,毕业的时候也不是没有找过程序员岗位,但都是简历投递出去没有人回复的状态。

但也一直有关注,知道程序员有培训这么一回事,也知道程序员工资蛮高的,但有一定的门槛。

从深圳回来后,我下定了决心学软件开发,计划做一名程序员。

本来去咨询培训C语言、C++的,结果跑了一圈都说 Java 好就业,就最后选择了培训 Java。

找我姐借了1万元(我大学四年,学费也是借的)。

去银行取钱的那一天,我抱着1万元在柜台业务员的注视下,数了好多遍,那是我第一次见这么钱(09年)

培训班的事情就不说了,从刚开始的二指禅敲键盘,以及对 Java 一无所知,不过培训班氛围不错都是大四学生,有不会的大家都相互帮助。

培训班期间某次团建

我在编程这方面还是有点天赋的,很快到毕业的时候,已经给同班其他人讲编程了。



3


入职2周就被辞退了。


培训班会推荐几个公司,我是第一批推荐名单里的,很快就拿到入职的 Offer 了。

对比了一下,选择当时李嘉诚儿子的一家公司,是港企。

确实不一样,入职先培训一个月再上岗,那一批入职了18个人,其中就有我们培训中的5个人。

当时心态还是学生状态, 做出成果之后也不主动汇报,一个人坐在角落里面瞎捣鼓。

2周后,我被辞退了。

给我姐打电话的时候,我姐说,关键18个人里面仅仅辞退了2个人,就有你


可能当时也不服气吧,憋着一股劲投了几十家公司,最后被华为的外包公司录取了,人力外包直接到华为公司上班。

一个月工资,1800元。

当时华为比较正规,平时加班有加班费,周末加班双倍工资,于是我疯狂加班,一个月工资3000+。

外包是学不到东西的,虽然领导对我都很不错,入职几个月竟然又搞起了C++编程。

第一份工作,小巴组集体去团建

我一想花1万学的Java不就白费了,而且 Java 未来的就业更广阔一点,我不能就这样走弯了。

9个月后,离职,又找了一家港资,做电信业务,工资4000。

在这家公司,我遇到了人生最好的几个朋友,Jerry、鸽子、不会笑,我们四个人一起入职。

Flyever户外组织,秦岭某个地方

在这家公司和鸽子、不会笑,还创建了一个户外组织 Flyever,其实就是组织一群年轻人去山里玩。

几乎每周都有活动,不是吃饭喝酒唱歌通宵,就是半夜4、5起床去爬山游水,度过了人生中最快乐的一个阶段。

也和Jerry、鸽子、不会笑建立起来了革命友谊,我们四个后来在创业的路上有过多次交集。

在这家公司工作了1年半,从一个初级Java工程师开始做起,走的时候已经可以独立负责一个项目了。

当时又有一个契机

我妈要在老家盖房,我给了2万还不够,又借了亲戚大概十几万,我想了想我这4000的工资。

除去日常花销,要还多少年呀?

听说我们一个同事去了北京工资1万,我同事说那个人技术水平还没有我高,说者无心听者有意。

当年 Jeryy 也要去北漂,他想创业,我说那一起吧。

一起就一起。



4


北漂7年。


他比我早一周到北京,找了一家做 OA 的公司。

那个时候,北京的分钟寺还没拆,一个巨大无比的城中村,我当时拿了3000元,租房一个月1000。

刚去北京第二天,在鸟巢留念

我用了一周时间,拿到了4个Offer。

印象中北京的风是真大,能把我吹上天,当时还用的是小米1,一接电话就死机,耽搁了我好多事。

最高的一家给了1.3万,不过我当时目标很明确,只进互联网公司,1万的月薪入职了一家第三方支付公司。

其实我北漂7年,几乎可以说就在这一家公司干了。


2013年,那真是一个波澜壮阔的时代,也是移动互联网的时代,更是万众创业的时候。

我们公司就在中关村创业一条街附近,当时还叫海淀图书街,因为创业氛围太过浓烈,后面才改名叫做创业街。

Jeryy想创业,我们几乎跑遍了这条街的所有咖啡馆,车库咖啡、3W咖啡等等,周末点上一本咖啡坐上一整天。

一起想创业的点子,一起开发程序做Demo,写商业策划书去融资,刚去的1年,我几乎没有任何空余时间。

失败是必然的。

Flyever,被我带到了北京

组建了一个叫做陕西人在北京的

继续组织爬山、吃饭、唱歌、喝酒

不过,我工作的那家支付公司1年后迎来了一个契机。

当时互联网金融大行其道,我们作为第三方支付公司,董事长旗下还有不少其它业务需要融资。

于是决定要做一个互联网借贷平台,当时称P2P,我们的模式是B2P,企业向用户借钱,给用户利息。

刚开始是一个百度过来的高管负责,也是清华大学毕业的,结果干了半年后,这名高管自己创业了。

团队也被带走了,技术开发就剩了一个人。


我的领导的领导的领导,临危受命要把这项目接下来,但是找不到合适的人选来负责落地。

我们那一批来不少人,但大部分技术高手1年后都离职了,我其实也刚好找到了外部的工作。

领导说让我接手,我说可以呀,得涨工资,领导说行,那就我干了。

领导说,可以让我在部门调两个人过去,我选择了一个实习生,一名年轻有潜力的程序员。

就这样把这个项目接了起来。


一个月后项目上线,当天融资了1000万;但没过多久,一天的融资能力就变成了好几个亿。

项目成了,从一个项目组变成集团的一个子公司。

3年时间,

我就从一个项目组长,变成了技术经理、部门经理(测试、运维都管),再到公司的技术负责人。

2015年,北戴河团建
生命不息,奋斗不止!

互联网金融真是一个疯狂的年代,是我人生中最忙的一个阶段,也是我成长最为迅速的一个阶段

早上第一个来公司,晚上也几乎是最晚离开,23点之前没有离开过公司,有一次下班出车祸也就隔了一天又去上班了。

因为所有的事儿,都是必须我来扛。


16年,

也就是那个时候,我觉得应该把我段人生经历记录下来,特别是在互联网金融公司工作的那些事。

太好玩了。

高并发、大数据、微服务、分布式、黑客攻击、黑客勒索等等,我们又用的是市面上最新的技术栈,遇到了很多很多问题,也解决了很多很多问题。

我想要有一个窗口和技术人交流。

就到博客园写文章,没想到写一篇火上一篇,1年的时间,我就成为博客园推荐博客排名前10。

老版博客园的推荐博客列表

也写了一些开源项目,Github关注数量中国排名前50。

1年后,开通了个人公众号纯洁的微笑。


2017年,因为母公司要上市,我们被卖给了海淀国资委,公司的风格一下子就变了。

于是,我离职又重新去了母公司。

从这个互联网金融公司离开时

团队瞒着我,送了一个全体签名的短袖


从一名架构师开始做起,负责公司新支付系统的大数据平台建设,处理每天几十亿交易数据。

半年后,连跳3级被提拔为研发副总,当时研发事业部已经有超过100+的研发人员。

我只负责一个事情,把公司研发的第四代收单平台,推动上线迁移替换旧的收单系统。

中间又是遇到了 N 多的事情,除了技术问题之后,在高管的位置上自然有其它是非在其中。

有时候,你不站队也是一种站队。


18年,萌生去意,但老领导们提拔我不容易,至少要有知遇之恩,又咬着牙坚持了1年。

2018年,上海出差

19年,研发中心出现一次事故,借此就离开了。

19年离职的时候,我的副业自媒体收入早已经超过了主业,收入这方面倒也不是很在乎。

只是那个时候,也有别的互联网公司开出年薪百万工资挖我去做技术总监,当然了也是和支付相关的。

那我就面临人生一个最重要的选择,继续在北京互联网公司做高管,还是尝试一个人做点事情。

其实也没太多纠结,因为上班确实上够了。

从09年开始培训到19年离职,我的每一份工作和上一份工作都是连着的,10年时间没休息过。

HR劝我的时候,我说你觉得我现在创业风险大,还是几年后创业风险大,HR说应该是几年后吧。

我说,那就对了。



5


自由职业


离职之后,我就成为自由职业了。

那个时候,我还不敢对外说是创业,毕竟在我的印象中,创业应该是一件蛮大的事情了。

那个时候,我只能养活自己。

在离职之前,公司在美国有一个业务,需要派别人过去,我当时也申请了,顺势办理了美国10年签证。

于是,离职第一件事,搬家。

从三环边搬到五环旁,先改变自己的居住环境,毕竟自由职业要在家里上班的。

第二件事情,就是到处溜达,当然也包括美国。

现实自驾草原天路,再是北海道那一带,然后就是环京大环线,还在深圳附近自驾来半个月。

感觉还是不过瘾,又去美国旅游了一个月,从东海岸到西西海岸,从黄石公园到约书亚树国家公园。

2019年,纽约时代广场

所以,自由职业的头一年,大概就是不断的旅游,不断的折腾自媒体事业。


不过,从美国回来之后,让我意识到了一件事。

好像出国旅游花不了多少钱,既然是这样,何不计划一下环游世界,我从来都是一个说干就干的人。

要环游世界,那就要把英语学好,也要把北京的房子退了(一个月租金6500,几乎一半时间都空着)。

当时的计划是这样的。

第一步,把北京房子退了,东西都打包回老家。

第二步,在菲律宾报了一个语言学校,3个月先把英语给学扎实了,并且要拿到托福证书。

第三步,西安去亚洲,再去新西兰澳洲,最后环游欧洲,欧洲走完了再说后面的人生计划。


如果不是当初的那一场疫情,还不知道现在我在世界的哪个角落呆着,不知道从事着什么样的工作?

谋事在人,成事在天!



6


回到西安,创业


2019年,春节。

行李均已经邮寄到了老家,我从北京回到西安,准备在西安待上几天见见老朋友回家过春节。

当时菲律宾签证已经搞定,菲律宾当地的学校也联系好了,就连定金也给学校交了。

同时日本、新西兰的签证也办理好了。

一切静等在老家过完春节,开启自己环游世界的人生。


我在西安计划住5天,到了第3天就从新闻上传出,武汉那边好像出了一点事情,而且有蔓延的趋势。

到第3天,我看趋势不太对,没有坐班车,就打车直接回老家了。

在老家整整呆了6个月,这应该是我毕业以后,在老家呆过最久的一段时间了。

在老家的年轻人,也都陆陆续续回城市工作了,村里面的老大爷老大哥问我,你怎么还不走。

我是闲不住的人,既然环球旅游无望了,那就踏踏实实创业。

到西安后,就申请创建了公司。

在淘宝上,花了 600 元买了一个很大的黑色桌子,放在了客厅,作为办公桌,我坐这边,不会笑青年坐对面。

就这样开启创业了。


1月后,又搬到了不会笑青年家的客厅。

2020年,不会笑青年家的客厅

在他们小区可以打乒乓球,于是每天下午3点,无论夏日还是寒冬,我们都准时下去和老大爷抢场地打乒乓球。

1年后(2022年),不会笑青年要结婚,又搬到我新装修的房子客厅办公,顺势又把团队从2个人扩展到4个人。

公司变成了4个人。

集团活动从乒乓球又变成了羽毛球,于是4个人每天下午3点,又准时去小区打羽毛球。

这一打又是1年。


到了2023年,AI爆发。

我们觉得这是未来的大趋势,公司的整体发展方向全部转向AI,于是创建了 AI 俱乐部星球。

AI俱乐部用户已高达800人,AI俱乐部社群的推出

代表公司全部转向AI创业,后面的业务都和AI有关系。

2023年7月,又把公司从西安东北角搬到了西南角的高新区,终于有了一个相对正式的办公室。

搬家有两方面的原因:

一方面,不会笑青年当时住高新,来回通勤的压力很大;另一方面,想找一个办公楼方便后续招聘扩张。


搬家1个月后(2023年9月),掩体来西安旅游。

带来了AI变现训练营这个项目,我们当时测试了一下,一个月的时间80%的人可以月入过万。

那还有什么说的,全力 All in 继续搞!

又1年后,这个项目越做越大,团队规模又翻了一倍,从最初的4个人变成了8个人。

原来的办公司又坐不下了。

2023年,第一次搬到写字楼办公,在这个小办公室里面,加了N多次班。

今年7月,又重新租下了现在的办公室,也就是视频开头我拍摄的那个办公环境,可以容纳12人。

现在的这个办公室,才真正有点像一家公司的样子,在这之前我们都是草根游击队。

未来,公司能够发展多大,能够赚多少钱?已经不是我第一关心的事情了,更关心的是有没有更享受创业的这个过程。

从来没有想过要做多大的一个公司,一直想的是怎么做一个小而美的公司,有激情有奋斗有冲劲但又不是那么忙。

当然了,现在还差很远,还在既苦逼又享受的那个阶段。


人必有痴,而后有成,痴于物,而成于心。

09年到24年,

眨眼间,已经过去了15年,最大的感慨就是,人如果真要做成一件事,是不容易的。

特别对于我们这种出身贫穷的普通人。

每一步都不能错,错了就没有回头路能走,能够帮你的人永远只有你自己而已。

当然除了下苦功夫努力,也需要机缘更需要运气和贵人,才能让努力可以开花结果。

我特别喜欢一段话,作为这篇文章的结尾:

北冥有鱼,其名为鲲。鲲之大,不知其几千里也;化而为鸟,其名为鹏。鹏之背,不知其几千里也,怒而飞,其翼若垂天之云


作者:纯洁的微笑
来源:mp.weixin.qq.com/s/TBlJdOfzDCYDZ9NQVcTneQ
收起阅读 »

狂肝两周,写了一个"本地化"的桌面端工具:超级待办

web
事情是这样的,上一年写了一个基于uTools的插件,超级待办,目前日活300+,插件累计下载量24000+,有很多用户期望能够开发独立版本且数据可控(在本地保存),所以在插件版的基础上,优化UI,交互,新增相关功能,开发了一个桌面端版本(win+mac)的超级...
继续阅读 »

事情是这样的,上一年写了一个基于uTools的插件,超级待办,目前日活300+,插件累计下载量24000+,有很多用户期望能够开发独立版本且数据可控(在本地保存),所以在插件版的基础上,优化UI,交互,新增相关功能,开发了一个桌面端版本(win+mac)的超级待办。


1.gif


应用特色:


一、快速记录待办


二、所有数据保存在本地


很多人在记了一两条就放弃了,很难坚持下来,所以先把待办记下来,后续使用拖拽的形式快速修改待办状态,在此场景下,设计了多个快速记录待办的方式:


一、使用快捷键Ctrl+Space快捷键(可自定义)快速呼出应用,自动聚焦输入待办


二、剪切板转待办,应用会记录剪切板记录,你可以查看记录并转为待办


该应用共分为任务主面板、日历、列表、随心记(富文本)、分类、剪切板等模块。


任务主面板模块


在这里根据完成状态把任务分成未开始,进行中,已完成三个框体,不同状态之间支持拖拽,排序等快速操作;并且根据任务的紧急状态把每个任务分为紧急,高,中,低四个状态,方便标记任务,区分优先级;支持关联随心记,编辑,修改,删除,归档等操作。
image.png


日历模块


在这里根据每个任务的时间,分布在日历视图上,日历包含节假日等信息,能够查看任务分布及完成情况,支持关键字搜索,编辑任务,删除任务等操作。


image.png


列表模块


把任务汇总为列表模式,你可以在这里取消归档,按照任务状态进行筛选,关键字搜索,分类搜索,查看关联的随心记,删除,编辑等操作,并能直观的查看你所记录的待办事项。
image.png


随心记


这里使用了富文本编辑器,支持上传图片,方便记录待办所关联的一些信息,例如:我完成了一个模块的开发,可以把具体的注意事项关联写到随心记里,方便日后查看。不仅如此,你可以记录你想记录的任何文本。


image.png


分类


在这里你可以去维护应用的分类信息,在创建任务及随心记时,可以进行关联,方便归类管理。虽然模块名是分类,但在使用过程中,你可以把分类定义为项目名,日期归总等等。
image.png


剪切板


我们在应用后台,实时记录剪切板内容并保存到本地,你可以在这里把剪切板某个内容转为待办,也可以根据关键词进行搜索,同时可以一键删除所有,删除单个内容等。
image.png


设置


如果你觉得不希望每次都出现很大的框体,只希望在桌面上出现一个还未完成的任务面板并进行操作,你可以在设置中开启待办事项面板,开启后,你可以固定到桌面的任意位置。我们默认保存该面板的位置信息,在你重启电脑后,面板依旧在你设置的位置。


同时你可以在这里设置是否开机自启,是否显示快速添加待办的面板,启动时是否只显示一个输入框还是整个应用,以及呼出应用的快捷键,怎么使用,任你发挥。


为了极少的收集用户信息,我们采用微信绑定许可码(一机一码)形式,当应用安装后,可以按照操作申请试用许可码,每个微信支持绑定多个机器。
image.png


在公测期间,一共收获了300个用户,并提了很多宝贵的建议,后续迭代会持续的进行优化更新~


最后,如果你也有记录待办的需求,不妨体验一下呀~


作者:探路
来源:juejin.cn/post/7423583639081664564
收起阅读 »

极狐 GitLab 双重风波,Git 私服该如何选择?

极狐 GitLab 的双重风波 (一)间谍风波 前两天,极狐 GitLab 陷入了员工实名举报公司高管为美国间谍的漩涡之中。这一事件犹如一颗重磅炸弹,在业界引起了轩然大波。尽管目前尚未被实锤,但此消息一经传出,便迅速吸引了众多目光,也让极狐 GitLab 的企...
继续阅读 »

极狐 GitLab 的双重风波


(一)间谍风波


前两天,极狐 GitLab 陷入了员工实名举报公司高管为美国间谍的漩涡之中。这一事件犹如一颗重磅炸弹,在业界引起了轩然大波。尽管目前尚未被实锤,但此消息一经传出,便迅速吸引了众多目光,也让极狐 GitLab 的企业形象蒙上了一层阴影。这一事件不仅引发了内部员工的震动,也使得外界对其公司的信任度产生了动摇,其后续发展仍有待进一步观察。


(二)绝户网计划


就在今天早上,极狐 GitLab 的 “绝户网计划” 也浮出水面。据爆料,极狐 GitLab 要求销售人员在与使用 GitLab CE(社区版)免费版的用户交流时,引导用户明确表达正在使用免费版,并将此作为证据存档,以便未来可能的发函或起诉。 从其告知函来看,极狐 GitLab 强调其核心产品 GitLab 受法律保护,指出用户涉嫌未经授权使用软件,违反相关法律法规。公司内部对此计划也存在分歧,部分销售和技术同事反对,认为这会得罪潜在客户,影响长期生意,但公司高层却决定推行,寄希望于小部分害怕被起诉的用户付费来提升今年业绩。此计划引发了广泛争议,因为 GitLab 的免费版在全球范围内被大量程序员使用,且一直以来被认为是可商用的,这一举措无疑打破了以往的认知,让许多用户感到不满和担忧。



告知函内容如下:



GitLab 替代品分析


巧合的是,前不久我刚好对 GitLab 私服替代品进行了一波调研,同时成功将 GitLab 仓库迁移到新的仓库中,这次正好分享一下替代品的优缺点。


(一)Gitea



  • 优点

    • 轻量级:资源占用较低,对于硬件配置要求不高,适合小型团队或个人开发者在有限资源环境下搭建 Git 私服。

    • 功能较为完善:能够满足基本的代码托管、版本控制、分支管理等常见需求,支持多种主流操作系统的部署。

    • 社区活跃:有大量的开发者参与社区贡献,遇到问题时能够在社区中较快地获取解决方案和技术支持。



  • 缺点

    • 在大规模团队协作和复杂项目管理场景下,一些高级功能可能相对薄弱,例如在代码审查流程的精细化管理方面不如一些大型商业 Git 工具。

    • 与一些大型企业级工具相比,其集成能力可能稍逊一筹,在与其他企业内部系统如 CI/CD 平台、项目管理软件等的深度整合上存在一定局限性。

    • Gitea 的域名和商标在社区不知情、未经社区批准的情况下被转让给一家营利性公司,有一定开源风险。




(二)Gogs



  • 优点

    • 易于安装和使用:安装过程简单,即使是技术基础相对薄弱的用户也能快速上手搭建自己的 Git 私服。

    • 性能表现不错:在处理中等规模的代码仓库和团队协作时,能够保持较为稳定的运行速度和响应效率。

    • 界面简洁:对于注重简洁操作界面的用户来说,Gogs 的界面设计较为友好,易于操作和管理。



  • 缺点

    • 功能扩展性相对有限:虽然基本功能齐全,但在面对一些特殊需求或新兴技术场景时,可能难以通过插件或扩展机制快速实现功能增强。

    • 社区规模和活跃度不如一些头部的 Git 工具,这可能导致在长期发展过程中,功能更新和问题修复的速度相对较慢。




(三)OneDev



  • 优点

    • 强大的项目管理功能:除了基本的 Git 代码托管功能外,OneDev 在项目管理方面表现出色,提供了丰富的项目进度跟踪、任务分配、团队协作等功能,适合以项目为导向的团队使用。

    • 支持多语言:能够很好地适应不同语言环境下的开发团队需求,方便国际化团队协作。

    • 可定制性强:用户可以根据自己团队的特定需求,对 OneDev 的功能和界面进行一定程度的定制,以提高工作效率。



  • 缺点

    • 学习成本相对较高:由于其功能丰富且较为复杂,新用户需要花费一定时间来熟悉和掌握其操作流程和功能配置。

    • 部署相对复杂:相比一些轻量级的 Git 私服工具,OneDev 的部署过程需要更多的配置和环境依赖,对于运维人员的技术要求较高。




(四)GitBucket



  • 优点

    • 与 GitHub 风格相似:对于熟悉 GitHub 操作的用户来说,GitBucket 的界面和操作方式具有较高的相似度,降低了用户的迁移成本。

    • 支持多种数据库:可以灵活选择数据库类型,如 MySQL、PostgreSQL 等,方便根据现有技术架构进行整合。

    • 插件丰富:提供了大量的插件来扩展其功能,例如代码质量检测、代码统计等插件,能够满足不同团队的多样化需求。



  • 缺点

    • 性能优化方面可能存在不足:在处理大规模代码库和高并发请求时,可能会出现性能瓶颈,需要进行额外的性能调优工作。

    • 社区文档相对不够完善:在一些复杂功能的使用和问题排查上,由于社区文档的不全面,可能会给用户带来一定困扰。




(五)Gitblit



  • 优点

    • 专注于 Git 核心功能:对 Git 的核心功能支持得非常稳定和高效,如代码托管、分支管理、权限管理等,适合那些只需要基本 Git 功能且追求稳定性的团队。

    • 轻量级且资源占用少:在硬件资源有限的情况下,能够稳定运行,不会对服务器资源造成过大压力。

    • 安全性能较高:提供了较为完善的权限管理和安全机制,能够有效保护代码仓库的安全。



  • 缺点

    • 功能相对单一:缺乏一些现代 Git 工具所具备的高级项目管理和团队协作功能,如敏捷项目管理工具集成等。

    • 用户界面相对简陋:在美观度和交互体验上不如一些新兴的 Git 私服工具,可能会影响用户的使用感受。




Forgejo 的选择理由


经过个人调研和综合考量,最终选择了 Forgejo 替代 GitLab。Forgejo 是 Gitea 的一个硬分叉,它继承了 Gitea 的所有优点,如轻量级、功能完善、社区活跃等。同时,Forgejo 还具有自身独特的优势,其界面美观,给用户带来了良好的视觉体验;部署简单,降低了迁移成本和技术门槛,即使是非专业运维人员也能轻松上手;加载速度快,能够提高团队成员的工作效率,减少等待时间。


在迁移项目时,可以参考我之前写的迁移教程:



综上所述,个人认为 Forgejo 在应对极狐 GitLab 近期风波所带来的不确定性时,是一个较为理想的 Git 私服替代品。


相关资料



作者:子洋
来源:juejin.cn/post/7446578471901626420
收起阅读 »

面试了一个45岁的程序员,他要月薪2万,我同意了。结果面试完送他到电梯口,他说14薪月薪1.8万也行。

电梯口最后的那句话,让我整整失眠一夜。震惊!昨天的一场面试,让这个面试官陷入深深的自我反思。作为一个互联网公司的技术总监,8年来面试过上千名候选人,但这次经历让面试官久久不能平静,甚至彻夜难眠...在BAT大厂干了12年技术管理,面试过形形色色的程序员。有意气...
继续阅读 »

电梯口最后的那句话,让我整整失眠一夜。


震惊!昨天的一场面试,让这个面试官陷入深深的自我反思。作为一个互联网公司的技术总监,8年来面试过上千名候选人,但这次经历让面试官久久不能平静,甚至彻夜难眠...


在BAT大厂干了12年技术管理,面试过形形色色的程序员。有意气风发的应届生,有经验丰富的大牛,有从外企跳槽的专家,但从没有一次面试像这次一样,让我感受如此复杂,如此揪心。


昨天下午3点,一个穿着深色格子衬衫的中年人准时出现在会议室门口。他个子不高,微微有些谢顶,背着一个看起来有些年头的双肩包。包的肩带有些磨损,但被主人仔细地缝补过。


"您好,我是来面试Java开发岗位的。"他的声音透着一丝紧张,手里紧握着一份打印得整整齐齐的简历。


看了看简历,我心里一惊 —— 45岁,20年开发经验,科班出身,Java后端出身,精通分布式架构,曾经在几个知名公司待过,技术栈相当扎实。"这么资深为什么还在找工作?这个年龄段找工作会遇到什么困难?"我心里冒出一连串疑问。


面试正式开始。我们聊了他最近在研究的技术领域,他说起SpringCloud微服务架构时,眼睛里闪烁着光芒:"最近我在研究服务网格,看到社区有个问题,还提了个PR..."


当我抛出一个个技术难题,他的回答让我眼前一亮。Spring源码分析、JVM调优、分布式架构设计、性能优化经验...每个答案都精准到位,不仅能说出理论基础,更难得的是能结合实际场景,说出各种坑的实践经验。这绝对是一位技术大牛!


面试中他提到一个有趣的细节:"有次生产环境遇到一个诡异的Bug,年轻同事们试了好多方案都没解决。我凭着多年经验,想起12年前遇到过类似问题,最后找到根源是JVM的一个默认参数设置有问题..."


就在我准备问收入预期时,他的手机响了。他有些慌乱地掏出手机,看了一眼赶紧按掉:"对不起,是我女儿的电话,她今天考试..."我注意到他手机屏幕上的裂痕和掉漆的边框。


"您期望的薪资是多少?"问到这个问题时,他略显犹豫,目光有些闪躲。


"如果可以的话...希望月薪2万。"他的声音有点发抖,"我知道可能比市场价低一些..."


2万?我愣住了。以他的技术水平和经验,在深圳互联网公司要个35k-40k一点问题都没有。难道是我听错了?记得上个月刚招的一个3年经验的小伙子,谈价时底气十足地要价25k,最后我们也给了。


"您确定只要2万吗?以您的能力和经验..."


"是的,我觉得够用了。"他打断了我的话,语速突然变快,"主要是想找一个稳定的工作环境。现在这个行业...您也知道...我的年龄...其实能有工作机会我就很感激了。"


看着他局促不安的样子,我决定不再讨价还价:"好的,2万没问题,我们这边非常认可您的能力。"


他的眼睛一下子亮了起来,露出欣慰的笑容,甚至有些激动:"真的非常感谢!我一定会好好干,加班什么的完全没问题,我身体很好的,每天都在坚持跑步..."


面试结束后,按惯例我送他到电梯口。看得出来他心情不错,脚步都轻快了许多。


就在电梯门快关上的瞬间,他突然回头说了一句话:"其实...如果是14薪的话,月薪1.8万也可以...我就是希望能有个稳定的岗位..."


那一刻,我的心狠狠地揪了一下。电梯门缓缓关上,我却久久站在原地。


回到办公室,我的脑海里一直回荡着他说的那句话。打开电脑,我忍不住搜索了一下"中年程序员"这个话题。一篇篇文章像刀子一样戳着我的心:"35岁程序员职业危机"、"互联网公司青睐年轻人"、"中年程序员如何自救"...


原来在这个年轻人主导的互联网行业,45岁居然已经被贴上"高龄"的标签。这个数字像一道无形的门槛,挡住了多少技术大牛的职业发展之路?


想起面试时的细节:问到加班时,他特别强调自己的抗压能力,说周末随叫随到,身体素质一点问题都没有。一个45岁的技术大牛,却要用"随叫随到"来证明自己的价值...这句话背后,是多少无奈和妥协?


这个行业太狂热地追逐年轻,以至于忽视了经验的珍贵。 那些深夜里背后的debug经历、重重坑里趟出来的实践经验、危机时刻的临危不乱,都是年轻人用996都换不来的宝贵财富。


我开始回想他说过的话:"现在的新技术学起来也很快,我每天都在看技术博客,Github上的开源项目也一直在关注..."这句话背后,是多少个加班后的深夜自学时光?是多少个被质疑"老了学不动"后的倔强证明?


突然想起去年一个深夜,生产环境出现重大事故,年轻员工们手忙脚乱,是一个45岁的老程序员站了出来,凭着多年经验在半小时内定位到问题。那一刻,我就明白了什么叫"经验的价值"。


我立刻给HR打了电话:"这位候选人非常合适,请按2万月薪给offer,年终奖至少3个月。对了,入职后把他安排到王工组,让他带带新人。"


与其花20万培养一个年轻人踩坑,不如用同样的钱留住一个踩过无数坑的技术专家。 这不仅是对团队负责,更是对整个行业的价值观负责。


今天早上,我收到了他愉快的入职确认。想起昨天电梯口那一幕,我暗暗发誓:一定要让团队里的每个人,不分年龄,都能被公平对待,都能实现自己的价值。


也许有一天,当我也到了45岁,也会面临同样的困境。但我希望到那时,整个行业都能多一些包容,少一些偏见。技术,永远不该被年龄定义。


朋友们,你们觉得技术行业真的存在"年龄歧视"吗?在你心目中,技术人的黄金年龄是多少?欢迎在评论区分享你的想法和经历。


PS:今天我特意找物业,把他的停车位安排在了地下车库最方便的位置。这或许是我能做的,最微小但也最真诚的关照了。


PPS:刚才和CTO聊了这事,我们决定在公司推动一个"经验导师"计划,专门邀请一些资深程序员来做技术分享。毕竟,程序员的价值,不应该用年龄来衡量。


为什么他愿意主动降薪?


他的降薪行为背后,藏着许多深层次的职场逻辑。


1. 现实的自知之明


45岁,对于程序员来说已经算是“高龄”。在互联网行业,35岁被称为“职场分水岭”,他显然很清楚自己的处境。


他主动降低薪资,是在用“性价比”消除我的顾虑,同时也为自己争取更多的机会。


2. 对稳定的渴求


从简历上看,她的职业生涯很稳定,前一份工作待了十几年。这种“稳定感”不仅是他的一种职场标签,也是他的核心诉求。对于45岁的他来说,找一份能长期发展的工作,远比短期的高薪重要。


3. 一种不显山露水的智慧


他看似是退让,实际上是在“示弱”中展现了自己的诚意。他让招聘方觉得,他不是一个只谈薪资、不顾团队的人,而是愿意为公司利益妥协的合作者。这样的沟通方式,比硬碰硬的谈判更容易让人接受。


高龄程序员的职场困境与价值


他的故事,让我重新思考了“高龄程序员”在职场中的价值和困境。


1. 困境:行业的无情现实


  • 技术更新速度快,高龄程序员容易被贴上“跟不上时代”的标签。

  • 用人成本高,很多企业更愿意选择年轻且“便宜”的新人。

  • 体力和精力相比年轻人有劣势,难以适应高强度加班文化。


2. 价值:丰富经验不可替代


  • 高龄程序员的优势在于对复杂系统的理解能力,这种能力并不是通过短时间学习能掌握的。

  • 他们往往有很强的团队协作能力,能起到“传帮带”的作用。

  • 稳定性和责任感是他们的职业标签,尤其适合对稳定性要求高的岗位。


这次面试经历让我明白了两个道理:


  1. 职场不是简单的年龄比较,而是价值的体现。
    他虽然45岁,但他的经验和态度是团队里稀缺的宝藏。年轻人的速度和创造力,和老员工的稳定与深度,是互补关系,而不是对立关系。


  2. 谈判不是赢输,而是双赢。
    他的降薪行为,并不是单纯的退让,而是一种职场智慧。他通过主动示弱,换来了更多的机会,也打消了用人方的顾虑。


朋友们,你们对高龄程序员怎么看?你是否愿意为团队引入一个经验丰富但年龄偏大的同事?欢迎在评论区分享你的看法!


作者:小乐

来源:编程技术圈

收起阅读 »

真.i18n自动化翻译

web
背景 懒,不想因为文案的问题复制,所以做一个全自动翻译脚本(插件) 前置 想要的功能 开发者无感,不用做任何和翻译有关的工作,开过过程中只需要将文案写到标签中 不影响现存的文案 思路 通过husky,将脚本写在pre-commit 通过git diff,...
继续阅读 »

背景


懒,不想因为文案的问题复制,所以做一个全自动翻译脚本(插件)


前置


想要的功能



  1. 开发者无感,不用做任何和翻译有关的工作,开过过程中只需要将文案写到标签中

  2. 不影响现存的文案


思路



  1. 通过husky,将脚本写在pre-commit

  2. 通过git diff,获取发生变动的文件

  3. 对文件做一层过滤, 只对.vue、js文件中的文案进行翻译

  4. fs读取发生变动的文件的内容,最好将其解析成ast

  5. 遍历行数提取待翻译的文本,需要过滤掉注释中的文案,将需要翻译的文案回写到源语言json中

  6. 将每个文件内容中的文案替换成对应的i18n键值

  7. 读取源语言json,和目标语言json对比找出需要翻译的文案,文案调用第三方翻译接口对进行翻译(不要用公开的,容易挂)

  8. 统一将新翻译的文案注入json中


准备



  1. 一个第三方接口

  2. npm i husky

  3. 框架接入i18n


代码


const fs = require('fs')
const crypto = require('crypto')
const path = require('path')
const { execSync } = require('child_process')
const fetch = require('node-fetch').default

const apiUrl = '自己的接口'
const scriptDirectory = __dirname
const projectRootDir = path.resolve(scriptDirectory, '../..')
const sourceFilePath = path.join(projectRootDir, './src/assets/lang/json/zh-CN.json')
const targetFilePath = path.join(projectRootDir, './src/assets/lang/json/en-US.json')
const source = require(sourceFilePath)
const target = require(targetFilePath)

function md5(text) {
return crypto.createHash('md5').update(text).digest('hex')
}

function containsChinese(text) {
return /[\u4e00-\u9fa5]/.test(text)
}

async function translate(data, languageCode) {
let sign = 'bwcode.'
sign += data.map(item => item.fieldName).sort().join('.')
sign = md5(sign)
const bodyRequest = {
sign,
languageCode,
translateList: data,
}
try {
const response = await fetch(apiUrl, {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
body: JSON.stringify(bodyRequest),
})
if (!response.ok) {
throw new Error(`HTTP error! Status: ${response.status}`)
}
const resJSON = await response.json()
if (resJSON.code !== 0) {
throw new Error(`result error! Status: ${JSON.stringify(resJSON)}`)
}
return resJSON.data.translateList
} catch (error) {
console.error('Error during translation request:', error.message)
}
}

// 暂时只翻译英语,后面有需要再拓展
async function startTranslate(data) {
const res = await translate(data, 'en-US')
// 转成对象
const fileContent = target
res.map(item => {
const key = item.fieldName.split('-')
if (key.length === 2) {
if (!fileContent[key[0]]) {
fileContent[key[0]] = {}
}
fileContent[key[0]][key[1]] = item.translateContent
} else {
fileContent[key[0]] = item.translateContent
}
})
fs.writeFileSync(targetFilePath, JSON.stringify(fileContent, null, 2), 'utf-8')
}

// 获取在 Git 中修改的文件列表
function getModifiedFiles() {
try {
// const result = execSync('git diff --name-only --cached', { encoding: 'utf-8' }) // 获取暂存区的修改
const result = execSync('git diff --name-only', { encoding: 'utf-8' }) // 获取工作区的修改
return result.split('\n').filter(item => item.includes('views'))
} catch (error) {
console.error('Error getting modified files:', error)
return []
}
}

function extractTemplateChinese(node) {
// 在线ast tree解析:https://astexplorer.net/
if (node.children && node.children.length) {
// console.log('node parent ------------------', node)
node.children.forEach(item => {
extractTemplateChinese(item)
})
} else if (containsChinese(node.value)) {
const regex = /[\u4e00-\u9fa5\s]+/
const content = node.value.match(regex)
source[content] = content
const newValue = node.value.replace(regex, match => `{{ $t('${match}') }}`)
node.value = newValue
}
}

function scanAndReplace(fileDirectory) {
const filePath = path.join(projectRootDir, `/${fileDirectory}`)
const pageContent = fs.readFileSync(filePath, 'utf8')
// vue2好像不支持ast,没有相关的ast库,所以还是直接用文本替换吧
// extractTemplateChinese(ast.templateBody)
// 匹配非注释的中文
const translationRegex = /[\u4e00-\u9fa5\s]+/g
// todo: js文件、template标签、scripts标签中的文案替换格式会不一样的
const translateData = pageContent.match(translationRegex)
const replacedPageContent = pageContent.replace(translationRegex, match => `{{ $t('${match}') }}`)
if (translateData && translateData.length) {
// 将替换后的内容写回文件
fs.writeFileSync(filePath, replacedPageContent)
// 记录文案,等所有文件扫描完毕后再回填数据
translateData.forEach(item => { source[item] = item })
}
}

function main() {
console.log('-- start translate --')
// 获取git diff的文件,寻找需要翻译的文案,并将文案提取出来新增到json后,文案替换成i18n格式
// 提取文案的过程最好用ast的方法,否则很难判断哪些中文是需要提取,哪些是注释
// 然而vue2的库太少了,要自己写,后面升级到vue3再完善这个自动提取的过程吧。目前要翻译什么文案还是手动去提取吧
// const modifiedFiles = getModifiedFiles()
// console.log('need translate file:', modifiedFiles)
// modifiedFiles.forEach(item => {
// // 暂时只对.vue文件进行翻译
// if (item.includes('.vue')) scanAndReplace(item)
// })

// 读取json,批量进行翻译(需要过滤掉已经翻译的文案)
const flat = []
// const sourceEntries = Object.entries(source)
// const targetEntries = Object.entries(target)
const translate = {}
for (const key in source) {
if (source.hasOwnProperty(key) && !target.hasOwnProperty(key)) {
translate[key] = source[key]
}
}
const translateEntries = Object.entries(translate)
translateEntries.forEach(([sourceKey, sourceValue]) => {
flat.push({ fieldName: sourceKey, content: sourceValue })
// if (typeof sourceValue === 'object' && sourceValue !== null) {
// const entriesChild = Object.entries(sourceValue)
// entriesChild.forEach(([entriesChildKey, entriesChildValue]) => {
// flat.push({
// fieldName: sourceKey+'-'+entriesChildKey,
// content: entriesChildValue,
// })
// })
// } else {
// flat.push({ fieldName: sourceKey, content: sourceValue })
// }
})
if (flat && flat.length) startTranslate(flat)
else console.log('no translate data')
console.log('-- end translate --')
}

main()

后续



  1. 因为vue2支持的ast转化库太少了,没找到合适的,需要自己写,懒得写了,所以2~6步跳过,代码上面也有,无非就是递归遍历ast树,替换文案,再转回字符串会写到文件中

  2. 感觉写成webpack/vite的插件会更好。有空在做吧。


作者:濷褚餾㨉㺭
来源:juejin.cn/post/7316357622847782931
收起阅读 »

为什么小明刚入职就碰到跨域问题然后转身离职?

故事的开始 故事还要从某个大厂的前端工程师 小明 说起。 小明兴高采烈的入职了某大厂的前端工程师岗位,就小明的水平的话,写写前端代码不在话下。 周四这天,小明吃完肯德坤之后,打开电脑浏览器,刷新页面,控制台就出现了下面的报错信息: 小明摸了摸自己大大的鼻子,...
继续阅读 »

故事的开始


故事还要从某个大厂的前端工程师 小明 说起。


小明兴高采烈的入职了某大厂的前端工程师岗位,就小明的水平的话,写写前端代码不在话下。


周四这天,小明吃完肯德坤之后,打开电脑浏览器,刷新页面,控制台就出现了下面的报错信息:


QQ_1733404303364.png


小明摸了摸自己大大的鼻子,一眼就看到了问题:



demo.hamm.cn 访问 api.hamm.cn 跨域了。



凭借多年的经验,小明瞬间就想到了解决方案:


那就摇人


因为刚入职,碰到这个问题他也不知道该找哪个人来处理,因为他没有 API 服务器的权限,于是在群里说了一句:



小明(前端):“哪位大哥帮忙配置下跨域, api.hamm.cn 需要允许来自 demo.hamm.cn 的跨域请求。”



三分钟后...



小贾(Java):“收到,我看看”


小董(运维):“好的,现在在外面,半小时后回”



五分钟后,小明收到了来自 Java 同学 小贾 的私聊



小贾(Java):“好的,已配置好跨域头,你看看”


小明(后端):“咦,可以了。感谢大哥!”



出幺蛾子了


半小时后,运维的 小董 同学回到公司,马不停蹄的给配了跨域头。


刚准备私聊告诉小明,却见 Java 的小贾同学在群里 @ 自己:



小贾(Java):“@小董(运维) 董哥,你的网关侧是不是有问题,我配置了跨域头,小明这边刚才还好好的可以跨域,这会又炸了。。。”



只见小明发了张图:


QQ_1733404994187.png


群里炸锅了


咦,两个请求头


QQ_1733405055850.png


怎么请求头两个了之后反而跨域失败了呢?


查找问题


运维哥 和 Java哥 一脸懵,于是开始查找问题。


只见小明不慌不忙的在群里 @ 了两人:



小明(前端):“@小董(运维) @小贾(Java) 两位哥,你们俩应该都配置了跨域头,两个跨域头也会跨域失败的哦~”


小董(运维):“@小贾(Java) 你应用服务里的去掉吧”


小贾(Java):“...”,心想 不是我先配置的么,凭什么。。。



你们都是在网关侧还是业务侧配置的允许跨域呢?欢迎评论区讨论


多跨域头禁止跨域


原来,多跨域头下,浏览器认为数据可能是被中间代理过,觉得不够安全,所以禁止了跨域访问。


MDN关于跨域 origin 的解释:


developer.mozilla.org/zh-CN/docs/…


第二天


小明递上了自己的离职申请书。


作者:Hamm
来源:juejin.cn/post/7444840771779690530
收起阅读 »

跨平台开发的新纪元:Tauri 2.0 横空出世,移动端、桌面端一网打尽!

前言 Tauri 2.0 正式版终于在 2024 年 10 月 2 日正式发布了。这次重大更新不仅带来了令人兴奋的新特性,更是为跨平台应用开发开辟了一条全新的道路。让我们一起来看看这个重量级版本带来了哪些惊喜! 1.移动端支持:拥抱全平台时代 Tauri 2...
继续阅读 »


前言


Tauri 2.0 正式版终于在 2024 年 10 月 2 日正式发布了。这次重大更新不仅带来了令人兴奋的新特性,更是为跨平台应用开发开辟了一条全新的道路。让我们一起来看看这个重量级版本带来了哪些惊喜!


1.移动端支持:拥抱全平台时代



Tauri 2.0 最引人注目的特性莫过于对 iOS 和 Android 的全面支持。现在,您可以用同一套代码库开发桌面端(Windows、macOS、Linux)和移动端应用,真正实现"一次编写,到处运行"的梦想。这不仅大大提高了开发效率,还为您的应用打开了更广阔的市场。


2.插件系统升级:灵活性与可扩展性的完美结合



新版本中,Tauri 将大量核心功能转移到了插件中。这意味着您可以根据需求自由选择功能,让应用更加轻量化。同时,插件系统的改进也为社区贡献打开了大门,期待看到更多创新的插件涌现。Tauri 2.0 的插件系统不仅更加灵活,还提供了丰富的官方插件,满足各种开发需求。以下是部分官方插件及其功能:



  • 自动启动 (Autostart): 让您的应用在系统启动时自动运行。

  • 条形码扫描器 (Barcode Scanner): 在移动应用中使用相机扫描二维码和条形码。

  • 生物识别 (Biometric): 在Android和iOS上进行生物识别认证。

  • 剪贴板 (Clipboard): 读取和写入系统剪贴板。

  • 命令行接口 (CLI): 解析命令行参数。

  • 深度链接 (Deep Linking): 将您的Tauri应用设置为特定URL的默认处理程序。

  • 对话框 (Dialog): 用于打开/保存文件和显示消息的原生系统对话框。

  • 文件系统 (File System): 访问文件系统。

  • 全局快捷键 (Global Shortcut): 注册全局快捷键。

  • HTTP客户端: 使用Rust编写的HTTP客户端。

  • 本地主机 (Localhost): 在生产应用中使用本地主机服务器。

  • 日志 (Logging): 可配置的日志记录。

  • NFC: 在Android和iOS上读写NFC标签。

  • 通知 (Notifications): 向用户发送原生通知。

  • 操作系统信息 (OS Information): 读取操作系统信息。

  • 持久化作用域 (Persisted Scope): 在文件系统中持久化运行时作用域更改。

  • 定位器 (Positioner): 将窗口移动到常用位置。

  • 进程 (Process): 访问当前进程。

  • Shell: 使用默认应用程序管理文件和URL,以及生成子进程。

  • 单实例 (Single Instance): 确保Tauri应用同时只运行一个实例。

  • SQL: 提供前端与SQL数据库通信的接口。

  • 存储 (Store): 持久化的键值存储。

  • Stronghold: 加密、安全的数据库。

  • 系统托盘 (System Tray): 系统托盘功能。

  • 更新器 (Updater): Tauri应用的应用内更新。

  • 上传 (Upload): 通过HTTP进行文件上传。

  • WebSocket: 在JavaScript中使用Rust客户端打开WebSocket连接。

  • 窗口自定义 (Window Customization): 自定义窗口外观和行为。

  • 窗口状态 (Window State): 保存窗口大小和位置。


这些插件涵盖了从基础功能到高级特性的广泛范围,让开发者能够根据项目需求灵活选择。通过这种模块化的方式,Tauri不仅保持了核心框架的轻量级,还为开发者提供了强大的扩展能力。无论您是开发一个简单的工具还是复杂的企业级应用,Tauri的插件系统都能满足您的需求。


3.安全性大幅提升:告别allowlist,迎接新的权限系统


Tauri 2.0 抛弃了旧的 allowlist 系统,引入了更加灵活和强大的权限、作用域和功能系统。这不仅提高了安全性,还让开发者能够更精细地控制应用的权限。值得一提的是,Tauri 还通过了独立的安全审计,让您使用起来更加放心。


4.性能优化:IPC层重写,更快更强


通过重写进程间通信(IPC)层,Tauri 2.0现在支持原始有效载荷,这意味着在前端和后端之间传输大量数据时,性能得到了显著提升。如果您的应用需要处理大量数据,这个特性绝对不容错过。


5.开发体验升级:HMR支持更给力


热模块替换(HMR)现在扩展到了移动设备和模拟器。这意味着您可以实时预览应用在不同设备上的表现,大大加速了开发和调试过程。


6.分发更简单:一站式解决方案



Tauri 2.0提供了详尽的分发指南,覆盖了从App Store到Google Play,再到Microsoft Store等多个平台。无论您的目标市场在哪里,Tauri都能帮您轻松应对。


结语


Tauri 2.0 的正式发布无疑是跨平台开发领域的一个重要里程碑。它不仅延续了 Tauri 一贯的轻量、快速的特点,还通过移动端支持、增强的插件系统和改进的安全机制等特性,为开发者提供了更强大、更灵活的工具。


如果您正在寻找一个能够同时覆盖桌面端和移动端的开发框架,Tauri 2.0绝对值得一试。它不仅能帮您节省时间和资源,还能为您的应用带来卓越的性能和安全性。


参考文章


v2.tauri.app/blog/tauri-…


v2.tauri.app/blog/tauri-…


作者:前端徐徐
来源:juejin.cn/post/7423231530498031631
收起阅读 »

跟 Antfu 一起学习 CSS 渐入动画

web
周末无事,翻阅 Antfu 的博客,发现一篇很有意思的文章,用简单的 CSS animation 动画实现博客文章按照段落渐入,效果如下: 是不是很有意思呢?作为一名前端开发,如果产品给你提出这样的动画需求,你能否实现出来呢?在继续阅读之前,不妨先独立思考一...
继续阅读 »

周末无事,翻阅 Antfu 的博客,发现一篇很有意思的文章,用简单的 CSS animation 动画实现博客文章按照段落渐入,效果如下:


sliding-p.gif


是不是很有意思呢?作为一名前端开发,如果产品给你提出这样的动画需求,你能否实现出来呢?在继续阅读之前,不妨先独立思考一下,如何用 CSS 来完整这种动画。


PS:什么,你问 Antfu 是谁?他可是前端圈里面的偶像级人物:



Antfu 是 Anthony Fu 的昵称,他是一位知名的开源软件开发者,活跃于前端开发社区。Anthony Fu 以其对 Vue.js 生态系统的贡献而著名,包括但不限于 Vite、VueUse 等项目。Antfu 也因为他在 GitHub 上的活跃参与和贡献而受到许多开发者的尊敬和认可。



首先用 CSS 写一个渐入动画,相信这个大家都看得懂:


@keyframes enter {
0% {
opacity: 0;
transform: translateY(10px);
}

to {
opacity: 1;
transform: none;
}
}

上述代码定义了一个名为 enter 的关键帧动画,其效果使得元素从透明度为0(完全透明)逐渐变为透明度为1(完全不透明),同时元素会在垂直方向上从 10px 以上的位置移动到最终位置。具体来说,关键帧如下:



  • 0%:动画的起始状态(动画开始时刻)。在这个状态中,元素的透明度 opacity设置为0,表示元素是完全透明的,看不见的。同时,transform: translateY(10px); 属性表示元素在垂直方向上被推移了 10px,即元素的起始位置是它最终位置的上方 10px



  • to100%:动画的结束状态(动画结束时刻)。在这个状态中,元素的透明度 opacity设置为1,表示元素完全不透明,完全可见。transform: none; 表示取消了之前的变换效果,元素恢复到它的原始形态和位置。


难道这样就行了吗?当然不行,如果仅仅对内容添加上述动画,效果是文章整体渐入,效果如下:


sliding.gif


然而我们想要的效果是一段一段渐入呀,那怎么办呢?思路很简单:



给每个段落分别添加上述动画,然后按照先后顺序延迟播放动画。



[data-animate] {
--stagger: 0;
--delay: 120ms;
--start: 0ms;
animation: enter 0.6s both;
animation-delay: calc(var(--stagger) * var(--delay) + var(--start));
}

上面的关键就是 animation-delay 这个属性,为了方便 HTML 编码,这里使用了 CSS 变量来进行控制,把元素的延迟时间总结到如下的公式里面:



calc(var(--stagger) * var(--delay) + var(--start));



其中变量的含义如下:



  • --stagger 是段落序号,值为1、2、3...

  • --delay 是上下两个段落的延迟时间间隔

  • --start 是初始延迟时间,即整片文章第一段的延迟偏移量


有了这些变量,就可以按照段落的前后顺序,写出如下 HTML 代码了:


<p style="--stagger: 1" data-animate>Block 1</p>
<p style="--stagger: 2" data-animate>Block 2</p>
<p style="--stagger: 3" data-animate>Block 3</p>
<p style="--stagger: 4" data-animate>Block 4</p>
<p style="--stagger: 5" data-animate>Block 5</p>
<p style="--stagger: 6" data-animate>Block 6</p>
<p style="--stagger: 7" data-animate>Block 7</p>
<p style="--stagger: 8" data-animate>Block 8</p>

实现的效果如下:


sliding-d.gif


可以说相当棒了!但是这里还有个问题,就是 markdown 文章转成 HTML 的时候,不会总是 p 标签吧,也有可能是 divpre 等其他标签,而且你还要手动给这些标签添加 --stagger 变量,这个简直不能忍啊。Antfu 最后给出的解决方案是这样的:


slide-enter-content > * {
--stagger: 0;
--delay: 150ms;
--start: 0ms;
animation: slide-enter 1s both 1;
animation-delay: calc(var(--start) + var(--stagger) * var(--delay));
}

.slide-enter-content > *:nth-child(1) { --stagger: 1; }
.slide-enter-content > *:nth-child(2) { --stagger: 2; }
.slide-enter-content > *:nth-child(3) { --stagger: 3; }
.slide-enter-content > *:nth-child(4) { --stagger: 4; }
.slide-enter-content > *:nth-child(5) { --stagger: 5; }
.slide-enter-content > *:nth-child(6) { --stagger: 6; }
.slide-enter-content > *:nth-child(7) { --stagger: 7; }
.slide-enter-content > *:nth-child(8) { --stagger: 8; }
.slide-enter-content > *:nth-child(9) { --stagger: 9; }
.slide-enter-content > *:nth-child(10) { --stagger: 10; }
.slide-enter-content > *:nth-child(11) { --stagger: 11; }
.slide-enter-content > *:nth-child(12) { --stagger: 12; }
.slide-enter-content > *:nth-child(13) { --stagger: 13; }
.slide-enter-content > *:nth-child(14) { --stagger: 14; }
.slide-enter-content > *:nth-child(15) { --stagger: 15; }
.slide-enter-content > *:nth-child(16) { --stagger: 16; }
.slide-enter-content > *:nth-child(17) { --stagger: 17; }
.slide-enter-content > *:nth-child(18) { --stagger: 18; }
.slide-enter-content > *:nth-child(19) { --stagger: 19; }
.slide-enter-content > *:nth-child(20) { --stagger: 20; }

只要给文章容器增加 slide-enter-content 样式,那么通过 nth-child() 就能为其直接子元素按照顺序设置 stagger 变量啦!


image.png


秒啊,实在是妙!不得不佩服大佬的脑洞,不过,杠精的你可能会说,我的文章又不止 20 个子元素,超过 20 怎么办呢?我说哥,你不会自己往后加嘛!


感兴趣的同学可以查看最终的样式代码,跟上述 demo 有一点点区别,相信你能从中学到不少东西,例如 Antfu 把 data-animate 属性关联的样式拆成了两段:


[data-animate] {
--stagger: 0;
--delay: 120ms;
--start: 0ms;
}

@media (prefers-reduced-motion: no-preference) {
[data-animate] {
animation: enter 0.6s both;
animation-delay: calc(var(--stagger) * var(--delay) + var(--start));
}
}

写前端这么多年,我是第一次见到 @media (prefers-reduced-motion: no-preference) 这个媒体查询的用法,一脸懵逼,赶紧恶补了一把才知道:



在 CSS 中,@media 规则用于包含针对不同媒体类型或设备条件的样式。prefers-reduced-motion 是一个媒体查询的功能,该功能用于检测用户是否有减少动画和动态效果的偏好。一些用户可能对屏幕上的快速或复杂动作敏感,这可能会导致不适或干扰体验,因此他们在操作系统中设置了减少动画的选项。



因此,对于那些讨厌动画的用户,就不用展示这么花哨的效果,直接展示文章就行啦!


作者:乔珂力
来源:juejin.cn/post/7338742634167205900
收起阅读 »

写了个自动化打包工具,大大滴解放了电脑性能

web
前段时间手底下的小伙伴跟我吐槽,说后端一点小改动就马上要包,电脑性能很差一旦run build之后就得等好几分钟的空窗期,被迫摸鱼导致加班,我灵机一动,是不是可以利用服务器的性能,编写自动化构建从而实现让后端、测试点点点,就能得到他们想要的不同版本的包、或者不...
继续阅读 »

前段时间手底下的小伙伴跟我吐槽,说后端一点小改动就马上要包,电脑性能很差一旦run build之后就得等好几分钟的空窗期,被迫摸鱼导致加班,我灵机一动,是不是可以利用服务器的性能,编写自动化构建从而实现让后端、测试点点点,就能得到他们想要的不同版本的包、或者不同分支的构建产物呢?


于是乎就有了我的设计并产出的开源:Sa-io https://github.com/LIAOJIANS/sa-io.git


Sa-io操作流程:新建项目(指定gitURL) => 内部执行(npm install)=> run build => SE(推送Sucesss日志) => publish(指定目标地址)=> dowl (下载专属产物)


image.png


项目架构


1、UI层


image.png


2、逻辑层


image.png
3、数据层


image.png


4、所需环境层


image.png


核心实现逻辑


1、技术清单



  • child_process:创建子进程并执行构建脚本;

  • chokidar: 监听日志文件内容;

  • scp2:建立SSH连接并传输文件;

  • Vue3:UI界面采用VUE3 + TS


2、核心逻辑


Run Build


router.post('/build', [
(() =>
['shell', 'install', 'projectName'].map((fild) =>
body(fild)
.notEmpty()
.withMessage('username or token is null'),
))(),
], (req, res, next) => {
checkBeforRes(next, req, async () => {

const {
shell,
install,
removeNm,
shellContent,
branch,
projectName,
pull,
...onter
} = req.body

if (os.platform() !== 'linux' && shell) {
return new Result(null, 'Running shell scripts must be in a Linux environment!!!')
.fail(res)
}

const curTime = Date.now()
const id = `${projectName}-${curTime}`
const fileName = `${id}.log`
const logPath = path.resolve(__dirname, `../log/${fileName}`)

let status = 'success'

const getHistory = () => getFileContentByName('history', [])

// 生成构建历史
let data = [
...getHistory(),
{
id,
projectName,
buildTime: curTime,
status: '',
branch
}
]

// 生成日志文件
getFileContentByName(
'',
'',
logPath
)

// 写入history基本信息
setFileContentByName(
'history',
data,
true
)

if (removeNm) {
await rmDir(projectName, 'node_modules') // 删除node_modules 防止不同分支不同版本的依赖冲突

rmFile(`${projectName}/package-lock.json`) // 删除安装依赖日志,防止版本缓存
}

if (branch) { // 如果有分支,并且分支不能等于当前分支,否则切换分支并拉取最新
const projects = getFileContentByName('projects')

const project = projects.find(p => p.projectName === projectName)

if (project.branch !== branch) {
try {
if (install) {

rmFile(`${projectName}/package-lock.json`) // 删除安装依赖日志,防止版本缓存
}

await gitCheckoutPro(projectName, branch)

setFileContentByName('projects', [
...projects.map(p => {
if (p.projectName === projectName) {
p.branch = branch
}

return p
})
], true)
} catch (e) {

console.log(e)

setFileContentByName(
'history',
[
...data,
{
projectName,
buildTime: curTime,
status: 'error',
branch
}
],
true
)

res.status(500).send('checkout error!!! Please review the log output!!!!!!')
}

} else if (pull) { // 拉取最新
try {
await gitPullPro(projectName, logPath)
} catch (e) {
res.status(500).send('checkout error!!! Please review the log output!!!!!!')
}
}
}


new Result(`${id}`, 'building, Please review the log output!!!!!!').success(res)

const compressedPro = () => {
status = 'success'
compressed(`${projectName}-${curTime}`, projectName)

console.log('success')
copyFile(
path.resolve(__dirname, `../project/${projectName}/dist`),
path.resolve(__dirname, `../builds/${projectName}-${curTime}`)
)

const {
publish,
...left
} = onter

if (publish) {
publishTragetServer({
...left,
localPath: path.resolve(__dirname, `../builds/${projectName}-${curTime}`)
})
}

}

if (shell) { // 执行sh脚本

setFileContentByName(
projectName,
shellContent,
true,
path.resolve(__dirname, `../project/${projectName}/build.sh`)
)

await shellPro(projectName, logPath)
.then(compressedPro)
.catch(() => {
status = 'error'
console.log('error')
})
} else { // 执行打包工作流
(
await (install ? installAfterBuildPro : buildPro)(projectName, logPath)
.then(compressedPro)
.catch(() => {
status = 'error'
console.log('error')
})
)
}

let newData = getHistory()

newData = newData.map(c => {
if (c.id === id) {
c.status = status
}

return c
})

setFileContentByName(
'history',
newData,
true
)
})
})

UI界面展示


build.gif


history.gif


最后放个项目地址:github.com/LIAOJIANS/s…


作者:大码猴
来源:juejin.cn/post/7445098587808514082
收起阅读 »

一个js库就把你的网页的底裤🩲都扒了——import-html-entry

web
概述 import-html-entry 是一个用于动态加载和处理 HTML 和 JS 文件的库,主要用于微前端架构中。它能够从远程服务器拉取 HTML 内容,并对其中的 JS 和 CSS 进行处理,以便在主应用中加载和执行。这个库是 qiankun 微前端框...
继续阅读 »

概述


import-html-entry 是一个用于动态加载和处理 HTML 和 JS 文件的库,主要用于微前端架构中。它能够从远程服务器拉取 HTML 内容,并对其中的 JS 和 CSS 进行处理,以便在主应用中加载和执行。这个库是 qiankun 微前端框架的核心依赖之一,提供了强大的动态加载和执行能力。在微前端框架 qiankun 中,import-html-entry 被用来解决 JS Entry 的问题,通过 HTML Entry 的方式,让用户接入微应用就像使用 iframe 一样简单。


使用方法


安装


首先,你需要通过 npm 或 yarn 安装 import-html-entry


npm install import-html-entry

或者


yarn add import-html-entry

基本使用


以下是一个简单的示例,展示如何使用 import-html-entry 加载一个远程的 HTML 文件,
我们看官网的例子

在index.html中
使用import-html-entry加载./template.html


<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>index</title>
</head>
<body>
<script type="module">
window.onerror = e => {
console.log('error', e.message);
};
window.onunhandledrejection = (e) => {
console.log('unhandledrejection', e.reason.message);
};

import('./dist/index.js').then(({ importEntry }) => {
importEntry('./template.html').then(res => {
console.log(res);
return res.execScripts().then(exports => {
console.log(exports);
});
}).catch(e => {
console.log('importEntry failed', e.message);
});
});
</script>
</body>
</html>


template.html如下:


<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>test</title>
<link href="https://unpkg.com/antd@3.13.6/dist/antd.min.css" rel="stylesheet">
<link href="https://unpkg.com/bootstrap@4.3.1/dist/css/bootstrap-grid.min.css" rel="stylesheet">
</head>
<body>

<script src="./a.js"></script>
<script ignore>alert(1)</script>
<script src="./b.js"></script>
<script src="./c.js"></script>
<script src="https://unpkg.com/react@16.4.2/umd/react.production.min.js"></script>
<script src="https://unpkg.com/mobx@5.0.3/lib/mobx.umd.js"></script>
<script src="https://www.baidu.com"></script>
</body>
</html>


template.html被import-html-entry处理过后如下:


<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>test</title>
<style>
/* antd样式被内链进入 */
</style>
<style>
/* bootstrap样式被内链进入 */
</style>
</head>
<body>

<!-- script http://127.0.0.1:7001/a.js replaced by import-html-entry -->
<!-- ignore asset js file replaced by import-html-entry -->
<!-- script http://127.0.0.1:7001/b.js replaced by import-html-entry -->
<!-- script http://127.0.0.1:7001/c.js replaced by import-html-entry -->
<!-- script https://unpkg.com/react@16.4.2/umd/react.production.min.js replaced by import-html-entry -->
<!-- script https://unpkg.com/mobx@5.0.3/lib/mobx.umd.js replaced by import-html-entry -->
<!-- script https://www.baidu.com/ replaced by import-html-entry -->
</body>
</html>


可以发现html中的css被处理成为内链样式的了,其中的js代码script被注释掉了


importHTML返回值有如下几个:

1、template---处理过后的html

2、assetPublicPath---资源路径

3、getExternalScripts---执行后返回脚本信息

image.png
4、getExternalStyleSheets---执行后返回样式信息


image.png
5、execScripts---js代码执行器,可以传入代理的window对象


我们可以看出来,经过import-html-entry 处理后能够拿到这个html中的js、css内容,其中css会被处理成为内链样式嵌入HTML中,js我们可以通过execScripts传入自己的代理window可以实现js沙箱隔离


qiankun中如何使用的?


我们观察qiankun源码中是如何使用的import-html-entry

在src/loader.js中如下:


// 266行
const { template, execScripts, assetPublicPath, getExternalScripts } = await importEntry(entry, importEntryOpts);
// 347行
const scriptExports: any = await execScripts(global, sandbox && !useLooseSandbox, {
scopedGlobalVariables: speedySandbox ? cachedGlobals : [],
});
// get the lifecycle hooks from module exports
const { bootstrap, mount, unmount, update } = getLifecyclesFromExports(
scriptExports,
appName,
global,
sandboxContainer?.instance?.latestSetProp,
);

可以看到和预期一样

1、使用import-html-entry拿到js执行器

2、执行execScripts,并且传入自己的globalContext

3、根据导出,拿到生命周期函数lifecycle


源码解析


import-html-entry 的核心功能是通过 fetch 获取指定 URL 的 HTML 内容,然后解析并处理这个 HTML 模板,最终返回一个包含处理后的 HTML、CSS 和 JS 的 Promise 对象。具体步骤如下:



  1. 拉取 HTML 并处理:通过 fetch 获取到 URL 对应的全部内容(即 HTML 文件的字符串),然后解析出以下内容:经过初步处理后的 HTML(去掉外链 CSS 和外链 JS)、由所有 script 组成的数组、由所有 style 组成的数组。

  2. 嵌入 CSS:通过 fetch 拉取到上述 style 数组里面对应的 CSS,然后将拉取到的每一个 href 对应的 CSS 通过 <style> 包裹起来且嵌入到 HTML 中。

  3. 执行 JS 脚本:支持执行页级 JS 脚本以及拉取上述 HTML 中所有的外联 JS 并支持执行。因此,在微前端中,使用此依赖可以直接获取到子应用(某 URL)对应的 HTML 且此 HTML 上已经嵌好了所有的 CSS,同时还可以直接执行子应用的所有 JS 脚本且此脚本还为 JS 隔离(避免污染全局)做了预处理。


整体流程如下图所示:
image.png


execScripts


image.png


code = getExecutableScript()


通过function+with实现js沙箱


function getExecutableScript(scriptSrc, scriptText, opts = {}) {
const { proxy, strictGlobal, scopedGlobalVariables = [] } = opts;

const sourceUrl = isInlineCode(scriptSrc) ? '' : `//# sourceURL=${scriptSrc}\n`;

// 将 scopedGlobalVariables 拼接成变量声明,用于缓存全局变量,避免每次使用时都走一遍代理
const scopedGlobalVariableDefinition = scopedGlobalVariables.length ? `const {${scopedGlobalVariables.join(',')}}=this;` : '';

// 通过这种方式获取全局 window,因为 script 也是在全局作用域下运行的,所以我们通过 window.proxy 绑定时也必须确保绑定到全局 window 上
// 否则在嵌套场景下, window.proxy 设置的是内层应用的 window,而代码其实是在全局作用域运行的,会导致闭包里的 window.proxy 取的是最外层的微应用的 proxy
const globalWindow = (0, eval)('window');
globalWindow.proxy = proxy;
// TODO 通过 strictGlobal 方式切换 with 闭包,待 with 方式坑趟平后再合并
return strictGlobal
? (
scopedGlobalVariableDefinition
? `;(function(){with(this){${scopedGlobalVariableDefinition}${scriptText}\n${sourceUrl}}}).bind(window.proxy)();`
: `;(function(window, self, globalThis){with(window){;${scriptText}\n${sourceUrl}}}).bind(window.proxy)(window.proxy, window.proxy, window.proxy);`
)
: `;(function(window, self, globalThis){;${scriptText}\n${sourceUrl}}).bind(window.proxy)(window.proxy, window.proxy, window.proxy);`;
}


evalCode(scriptSrc, code)


通过eval执行代码


export function evalCode(scriptSrc, code) {
const key = scriptSrc;
if (!evalCache[key]) {
const functionWrappedCode = `(function(){${code}})`;
evalCache[key] = (0, eval)(functionWrappedCode);
}
const evalFunc = evalCache[key];
evalFunc.call(window);
}

processTpl


const { template, scripts, entry, styles } = processTpl(getTemplate(html), assetPublicPath, postProcessTemplate);

看一下执行结果。


image.png


通过processTpl实现。

1、替换HTML

2、导出js入口列表

3、style列表

4、找到入口文件


作者:吃饺子不吃馅
来源:juejin.cn/post/7445090940278276147
收起阅读 »

大屏适配方案--scale

web
CSS3的scale等比例缩放 宽度比率 = 当前网页宽度 / 设计稿宽度 高度比率 = 当前网页高度 / 设计稿高度 设计稿: 1920 * 1080 适配屏幕:1920 * 1080 3840 * 2160(2 * 2) 7680 * 2160(4 * ...
继续阅读 »

CSS3的scale等比例缩放


宽度比率 = 当前网页宽度 / 设计稿宽度


高度比率 = 当前网页高度 / 设计稿高度


设计稿: 1920 * 1080


适配屏幕:1920 * 1080 3840 * 2160(2 * 2) 7680 * 2160(4 * 2)


方案一:根据宽度比率进行缩放(超宽屏比如9/16的屏幕会出现滚动条)


方案二:动态计算网页的宽高比,决定根据宽度比率还是高度比率进行缩放


首先基于1920 * 1080进行基础的布局,下面针对两种方案进行实现


<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>Document</title>
<style>
body,
ul {
margin: 0;
padding: 0;
}
body {
width: 1920px;
height: 1080px;
box-sizing: border-box;

/* 在js中添加translate居中 */
position: relative;
left: 50%;

/* 指定缩放的原点在左上角 */
transform-origin: left top;
}

ul {
width: 100%;
height: 100%;
list-style: none;

display: flex;
flex-direction: row;
flex-wrap: wrap;
}

li {
width: 33.333%;
height: 50%;
box-sizing: border-box;
border: 2px solid rgb(198, 9, 135);
font-size: 30px;
}
</style>
</head>
<body>
<ul>
<li>1</li>
<li>2</li>
<li>3</li>
<li>4</li>
<li>5</li>
<li>6</li>
</ul>

<script>
// ...实现适配方案
</script>
</body>
</html>

方案一:根据宽度比率进行缩放


// 设计稿尺寸以及宽高比
let targetWidth = 1920;

// html的宽 || body的宽
let currentWidth =
document.documentElement.clientWidth || document.body.clientWidth;

console.log(currentWidth);
// 按宽度计算缩放比率
let scaleRatio = currentWidth / targetWidth;

// 进行缩放
document.body.style = `transform: scale(${scaleRatio})`;

实现效果如下:


b.gif
这时我们发现在7680 * 2160尺寸下,屏幕根据宽度缩放会出现滚动条,为了解决这个问题,我们就要动态的选择根据宽度缩放还是根据高度缩放。


方案二:动态计算网页的宽高比,决定根据宽度比率还是高度比率进行缩放


// 设计稿尺寸以及宽高比
let targetWidth = 1920;
let targetHeight = 1080;
let targetRatio = 16 / 9; // targetWidth /targetHeight

// 当前屏幕html的宽 || body的宽
let currentWidth =
document.documentElement.clientWidth || document.body.clientWidth;
// 当前屏幕html的高 || body的高
let currentHeight =
document.documentElement.clientHeight || document.body.clientHeight;

// 当前屏幕宽高比
let currentRatio = currentWidth / currentHeight;

// 默认 按宽度计算缩放比率
let scaleRatio = currentWidth / targetWidth;
if (currentRatio > targetRatio) {
scaleRatio = currentHeight / targetHeight;
}

// 进行缩放
document.body.style = `transform: scale(${scaleRatio}) translateX(-50%);`;

效果如下:


b.gif
这样就可以解决在超宽屏幕下出现滚动条的问题,另外我们做了居中的样式处理,这样在超宽屏幕时,两边留白,内容居中展示显得更加合理些。


作者:Polepole
来源:juejin.cn/post/7359077652416725018
收起阅读 »

使用uniapp制作安卓app容器

1. 背景项目需要做一个安卓app,而且不需要上架应用市场,部门也没有安卓开发,想着就套个webview就行了吧。没有选择react native之类的是因为这些工具需要安装很多环境工具,我只是开发一个壳子没必要这么复杂。用webview也方便快速修复页面问题...
继续阅读 »

1. 背景

项目需要做一个安卓app,而且不需要上架应用市场,部门也没有安卓开发,想着就套个webview就行了吧。没有选择react native之类的是因为这些工具需要安装很多环境工具,我只是开发一个壳子没必要这么复杂。

webview也方便快速修复页面问题。

所以最后选择了uniapp,但是uniapp本身就是套在一个大的webview下的, 所以再套一个webview难免会有一些意想不到的问题,下面就是一些踩过的坑记录。

2. 项目初始化

新建项目就默认模板就行,我只需要壳子。

image.png 启动了之后可以看到有两个调试工具

image.png

第一个就是网页上常用的vue调试工具,可以看到vue组件属性啥的,第二个就是类似chrome的控制台,但是无法查看元素,还有就是必须让设备和电脑在同一个网段下才行,不然连接不上。

hbuilder的控制台本身也有一些输出,比如页面的console

image.png

但是这里输出对象的时候不是很方便查看,如果你需要的话就打开上面说的第二个调试工具。

3. webview使用

整个项目很简单,大概就这样一个页面

<template>
<web-view :src='PROJECT_PATH' @message="onMessage">web-view>
template>
<script>
// ...
script>

3.1 网页与app通信

这是最重要的一个功能,可以参考官方文档

网页和app交互总结起来就是这两点:

  • 网页 -> APPwindow.uni.postMessage();
  • APP -> 网页webview.evalJS()

3.1.1. 网页 -> APP

首先要在项目中引入uni.webview.js,这个就相当于jsbridge,可以让网页操作uniapp

初始化完成后会在window上挂载一个uni对象,通过uni.postMessage就能往app发送消息,app中监听onMessage就行。

这里有几个小坑:

  1. 发送的格式window.uni.postMessage({ data: 数据 }),必须要有个字段data,这样app才能收到数据。源码

image.png 2. 发送的数据不需要序列化成字符串,uniapp会转换json。 3. appmessage事件中接收到事件参数应该这样解构

function onMessage(e) {
const {
type,
data
} = e.detail.data[0]
}

3.1.2. APP -> 网页

app向网页传输消息就直接调用网页的js就行了。这里我统一封装了一个函数:

// app向网页发送消息
const deliverMessage = (msg) => {
// 调用webview中的deliverMessage函数
// 这个函数是我在网页挂载的一个全局函数,调用deliverMessage后会触发页面中的一些事件
currentWebview.evalJS(`deliverMessage(${JSON.stringify(msg)})`)
}

上面的代码例子中出现的currentWebview需要我们自己去获取。

// vue2中
const rootWebview = this.$scope.$getAppWebview()
this.currentWebview = rootWebview.children()[0]

// vue3中
import {
getCurrentInstance,
ref,
} from "vue";
const currentWebview = ref(null)
const vueInstance = getCurrentInstance()
const rootWebview = vueInstance.proxy.$scope.$getAppWebview()
currentWebview.value = rootWebview.children()[0]

这里也有一个坑,rootWebview.children()如果你一渲染就获取是无法获取到webview实例的,具体原因没有深入研究,估计是异步的原因

这里提供两个思路:

  1. 加一个定时器,延迟获取webview,这个方法虽然听起来不保险,但是实际测试还是挺稳当的。关键是简单
setTimeout(() => {
currentWebview.value = rootWebview.children()[0]
}, 1000)
  1. 你要是觉得定时器不保险,那就使用plusapi手动创建webview。但是消息处理这块比较麻烦。官网参考
<template>

template>
// 我这里vue3为例
onMounted(() => {
plus.globalEvent.addEventListener('plusMessage', ({data: {type, args}}) => {
// 是网页调用uni的api
if(type === 'WEB_INVOKE_APPSERVICE') {
const {data: {name, arg}} = args
// 是发送消息事件
if(name === 'postMessage') {
// arg就是传过来的数据
}
}
})
const wv = plus.webview.create("", "webview", {
'uni-app': 'none',
})
wv.loadURL(网页地址)
rootWebview.append(wv);
})

plus.globalEvent.addEventListener这个是翻源码找到的,主要是我不想改uni.webview.js的源码,所以只有找到正确的监听事件。

WEB_INVOKE_APPSERVICEuniapp内部定义的一个名字,反正就是用来交互操作的命名空间。

这样基础的互操作就有了。

3.1.3. 整个流程

  1. 网页调用window.uni.postMessage({ data }) => app监听(用组件的onMessage或者自定义的globalEvent
  2. app调用网页定义的函数deliverMessage并传递参数,网页中的deliverMessage内部处理监听
// 网页中的deliverMessage
window.deliverMessage = (msg) => {
// 触发网页注册的监听器
eventListeners.forEach((listener) => {

});
};

3.2. 返回拦截

默认情况下,手机按下返回键,app会响应提示是否退出,但是实际我需要网页进入二级路由的时候,按下手机返回键是返回上一级路由而不是退出。当路由是一级路由时才提示是否退出app

import {
onBackPress,
onShow,
} from '@dcloudio/uni-app'
// 页面当前的路由信息
const pageRoute = shallowRef()
onBackPress(() => {
// tab页正常app返回逻辑
if (pageRoute.value?.isTab) {
return false
} else {
// 二级路由拦截app返回
return true
}
})

pageRoute是页面当前路由信息,页面通过监听路由变化触发routeChange事件,将路由信息传给app。当按下返回键的时候,判断当前路由配置是不是tab页,如果是就正常退出,不是就拦截返回。

4. 总结

有了通信功能,很多操作就可以实现了,比如获取设备safeArea,获取设备联网状态等等。


作者:头上有煎饺
来源:juejin.cn/post/7313740940773097482

收起阅读 »

即梦AI上线新功能,可一句话生成中文海报

近日,即梦AI升级了图片生成功能,用户使用即梦pc版或app时,选择最新上线的图片2.1生图模型,通过输入文本描述,即可生成带有指定文字的海报。例如,输入:生成一张含有筷子夹起饺子的冬至插画海报,标题是“Winter Solstice”下方是“冬至”两字,即梦...
继续阅读 »

近日,即梦AI升级了图片生成功能,用户使用即梦pc版或app时,选择最新上线的图片2.1生图模型,通过输入文本描述,即可生成带有指定文字的海报。

图片5.png

例如,输入:生成一张含有筷子夹起饺子的冬至插画海报,标题是“Winter Solstice”下方是“冬至”两字,即梦就能按照指令快速完成。

图片6.png

据测试用户反馈,即梦AI新功能已经可以较为准确地生成中文文字,生图效果也更具影视质感。测试期间,用户已衍生出表情包、四格漫画、手写风格等多种玩法,更大限度地释放了创意。

字节豆包大模型团队相关负责人表示,豆包文生图模型通过打通LLM和DIT架构,具备更好的原生中文数据学习能力,并在此基础上强化汉字生成能力,大幅提升了生成效果。不过目前对于复杂的汉字生成还有提升的空间。据即梦相关负责人,团队正持续对文生图功能进行优化升级,近期还将上线对生成文字进行涂抹修改的功能,助力创作者们更好地实现想象力。

即梦AI是字节跳动旗下的AI内容平台,支持通过自然语言及图片输入,生成高质量的图像及视频。平台提供智能画布、故事创作模式,以及首尾帧、对口型、运镜控制、速度控制等AI编辑能力,并有海量影像灵感及兴趣社区,一站式提供用户创意灵感、流畅工作流、社区交互等资源,为用户的创作提效。(作者:李双)

收起阅读 »

前端实现画中画超简单,让网页飞出浏览器

web
Document Picture-in-Picture 介绍     今天,我来介绍一个非常酷的前端功能:文档画中画 (Document Picture-in-Picture, 本文简称 PiP)。你有没有想过,网页上的任何内容能悬浮在桌面上?😏 🎬 视频流媒...
继续阅读 »

Document Picture-in-Picture 介绍


    今天,我来介绍一个非常酷的前端功能:文档画中画 (Document Picture-in-Picture, 本文简称 PiP)。你有没有想过,网页上的任何内容能悬浮在桌面上?😏


🎬 视频流媒体的画中画功能


        你可能已经在视频平台(如腾讯视频哔哩哔哩等网页)见过这种效果:视频播放时,可以点击画中画后。无论你切换页面,它都始终显示在屏幕的最上层,非常适合上班偷偷看电视💻


pip.gif


        在今天的教程中,不仅仅是视频,我将教你如何将任何 HTML 内容放入画中画模式,无论是动态内容、文本、图片,还是纯炫酷的 div,统统都能“飞”起来。✨


        一个如此有趣的功能,在网上却很少有详细的教程来介绍这个功能的使用。于是我决定写一篇详细的教程来教大家如何实现画中画 (建议收藏)😁


体验网址:Treasure-Navigationpip08.gif


github地址




📖 Document Picture-in-Picture 详细教程


🛠 HTML 基本代码结构


    首先,我们随便写一个简单的 HTML 页面,后续的 JS 和样式都会基于它实现。


<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document Picture-in-Picture API 示例</title>
<style>
#pipContent {
width: 600px;
height: 300px;
background: pink;
font-size: 20px;
}
</style>
</head>

<body>
<div id="container">
<div id="pipContent">这是一个将要放入画中画的 div 元素!</div>
<button id="clickBtn">切换画中画</button>
</div>
<script>
// 在这里写你的 JavaScript 代码
</script>
</body>
</html>



1️. 请求 PiP 窗口


    PiP 的核心方法是 window.documentPictureInPicture.requestWindow。它是一个 异步方法,返回一个新创建的 window 对象。

    PIP 窗口可以将其看作一个新的网页,但它始终悬浮在屏幕上方。


document.getElementById("clickBtn").addEventListener("click", async function () {
// 获取将要放入 PiP 窗口的 DOM 元素
const pipContent = document.getElementById("pipContent");
// 请求创建一个 PiP 窗口
const pipWindow = await window.documentPictureInPicture.requestWindow({
width: 200, // 设置窗口的宽度
height: 300 // 设置窗口的高度
});

// 将原始元素添加到 PiP 窗口中
pipWindow.document.body.appendChild(pipContent);
});

演示:


pip01.gif


👏 现在,我们已经成功创建了一个画中画窗口!
这段代码展示了如何将网页中的元素放入一个新的画中画窗口,并让它悬浮在最上面。非常简单吧


关闭PIP窗口


可以直接点右上角关闭PIP窗口,如果我们想在代码中实现关闭,直接调用window上的api就可以了


window.documentPictureInPicture.window.close();



2️. 检查是否支持 PiP 功能


    一切不能兼容浏览器的功能介绍都是耍流氓,我们需要检查浏览器是否支持PIIP功能
实际就是检查documentPictureInPicture属性是否存在于window上 🔧


if ('documentPictureInPicture' in window) {
console.log("🚀 浏览器支持 PiP 功能!");
} else {
console.warn("⚠️ 当前浏览器不支持 PiP 功能,更新浏览器或者换台电脑吧!");
}

    如果是只需要将视频实现画中画功能,视频画中画 (Picture-in-Picture) 的兼容性会好一点,但是它只能将元素放入画中画窗口。它与本文介绍的 文档画中画(Document Picture-in-Picture) 使用方法也是十分相似的。




3️. 设置 PiP 样式


    我们会发现刚刚创建的画中画没有样式,一点都不美观。那是因为我们只放入了dom元素,没有添加css样式。


3.1. 全局样式同步


假设网页中的所有样式如下:


<head>
<style>
#pipContent {
width: 600px;
height: 300px;
background: pink;
font-size: 20px;
}
</style>
<link rel="stylesheet" type="text/css" href="https://abc.css">
</head>

为了方便,我们可以直接把之前的网页的css样式全部赋值给画中画


// 1. document.styleSheets获取所有的css样式信息
[...document.styleSheets].forEach((styleSheet) => {
try {
// 转成字符串方便赋值
const cssRules = [...styleSheet.cssRules].map((rule) => rule.cssText).join('');
// 创建style标签
const style = document.createElement('style');
// 设置为之前页面中的css信息
style.textContent = cssRules;
console.log('style', style);
// 把style标签放到画中画的<head><head/>标签中
pipWindow.document.head.appendChild(style);
} catch (e) {
// 通过 link 引入样式,如果有跨域,访问styleSheet.cssRules时会报错。没有跨域则不会报错
const link = document.createElement('link');
/**
* rel = stylesheet 导入样式表
* type: 对应的格式
* media: 媒体查询(如 screen and (max-width: 600px))
* href: 外部样式表的 URL
*/

link.rel = 'stylesheet';
link.type = styleSheet.type;
link.media = styleSheet.media;
link.href = styleSheet.href ?? '';
console.log('error: link', link);
pipWindow.document.head.appendChild(link);
}
});

演示:

image.png




3.2. 使用 link 引入外部 CSS 文件


向其他普通html文件一样,可以通过link标签引入特定css文件:


创建 pip.css 文件:


#pipContent {
width: 600px;
height: 300px;
background: skyblue;
}

js引用:


// 其他不变
const link = document.createElement('link');
link.rel = 'stylesheet';
link.href = './pip.css'; // 引入外部 CSS 文件
pipWindow.document.head.appendChild(link);
pipWindow.document.body.appendChild(pipContent);

演示:

pip02.gif


3.3. 媒体查询的支持


可以设置媒体查询 @media (display-mode: picture-in-picture)。在普通页面中会自动忽略样式,在画中画模式会自动渲染样式


<style>
#pipContent {
width: 600px;
height: 300px;
background: pink;
font-size: 20px;
}

<!-- 普通网页中会忽略 -->
@media (display-mode: picture-in-picture) {
#pipContent {
background: lightgreen;
}
}
</style>

在普通页面中显示为粉色,在画中画自动变为浅绿色


演示:

pip03.gif




4️. 监听进入和退出 PiP 模式的事件


我们还可以为 PiP 窗口 添加事件监听,监控画中画模式的 进入退出。这样,你就可以在用户操作时,做出相应的反馈,比如显示提示或执行其他操作。


// 进入 PIP 事件
documentPictureInPicture.addEventListener("enter", (event) => {
console.log("已进入 PIP 窗口");
});

const pipWindow = await window.documentPictureInPicture.requestWindow({
width: 200,
height: 300
});
// 退出 PIP 事件
pipWindow.addEventListener("pagehide", (event) => {
console.log("已退出 PIP 窗口");
});

演示


pip04.gif




5️. 监听 PiP 焦点和失焦事件


const pipWindow = await window.documentPictureInPicture.requestWindow({
width: 200,
height: 300
});

pipWindow.addEventListener('focus', () => {
console.log("PiP 窗口进入了焦点状态");
});

pipWindow.addEventListener('blur', () => {
console.log("PiP 窗口失去了焦点");
});

演示


pip05.gif




6. 克隆节点画中画


我们会发现我们把原始元素传入到PIP窗口后,原来窗口中的元素就不见了。

我们可以把原始元素克隆后再传入给PIP窗口,这样原始窗口中的元素就不会消失了


const pipContent = document.getElementById("pipContent");
const pipWindow = await window.documentPictureInPicture.requestWindow({
width: 200,
height: 300
});
// 核心代码:pipContent.cloneNode(true)
pipWindow.document.body.appendChild(pipContent.cloneNode(true));

演示


pip07.gif


PIP 完整示例代码


<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document Picture-in-Picture API 示例</title>
<style>
#pipContent {
width: 600px;
height: 300px;
background: pink;
font-size: 20px;
}
</style>
</head>
<body>
<div id="container">
<div id="pipContent">这是一个将要放入画中画的 div 元素!</div>
<button id="clickBtn">切换画中画</button>
</div>

<script>
// 检查是否支持 PiP 功能
if ('documentPictureInPicture' in window) {
console.log("🚀 浏览器支持 PiP 功能!");
} else {
console.warn("⚠️ 当前浏览器不支持 PiP 功能,更新浏览器或者换台电脑吧!");
}

// 请求 PiP 窗口
document.getElementById("clickBtn").addEventListener("click", async function () {
const pipContent = document.getElementById("pipContent");

// 请求创建一个 PiP 窗口
const pipWindow = await window.documentPictureInPicture.requestWindow({
width: 200, // 设置窗口的宽度
height: 300 // 设置窗口的高度
});

// 将原始元素克隆并添加到 PiP 窗口中
pipWindow.document.body.appendChild(pipContent.cloneNode(true));

// 设置 PiP 样式同步
[...document.styleSheets].forEach((styleSheet) => {
try {
const cssRules = [...styleSheet.cssRules].map((rule) => rule.cssText).join('');
const style = document.createElement('style');
style.textContent = cssRules;
pipWindow.document.head.appendChild(style);
} catch (e) {
const link = document.createElement('link');
link.rel = 'stylesheet';
link.type = styleSheet.type;
link.media = styleSheet.media;
link.href = styleSheet.href ?? '';
pipWindow.document.head.appendChild(link);
}
});

// 监听进入和退出 PiP 模式的事件
pipWindow.addEventListener("pagehide", (event) => {
console.log("已退出 PIP 窗口");
});

pipWindow.addEventListener('focus', () => {
console.log("PiP 窗口进入了焦点状态");
});

pipWindow.addEventListener('blur', () => {
console.log("PiP 窗口失去了焦点");
});
});

// 关闭 PiP 窗口
// pipWindow.close(); // 可以手动调用关闭窗口
</script>
</body>
</html>




总结


🎉 你现在已经掌握了如何使用 Document Picture-in-Picture API 来悬浮任意 HTML 内容!
希望能带来更灵活的交互体验。✨


如果你有什么问题,或者对 PiP 功能有更多的想法,欢迎在评论区与我讨论!👇📬


作者:前端金熊
来源:juejin.cn/post/7441954981342036006
收起阅读 »

new Image() 预加载 为什么比 <img>直接加载要好?

web
<img> 直接加载对比 new Image() 预加载 1. 加载时机和页面渲染的差异 直接渲染到 <img> 标签: 当你直接在 HTML 中通过 <img> 标签加载图片时,浏览器在遇到 <img> 标签...
继续阅读 »

<img> 直接加载对比 new Image() 预加载


1. 加载时机和页面渲染的差异



  • 直接渲染到 <img> 标签: 当你直接在 HTML 中通过 <img> 标签加载图片时,浏览器在遇到 <img> 标签时会立即开始加载图片。这意味着浏览器在渲染页面的过程中,会同步进行图片请求。当页面需要渲染图片时,可能会导致图片显示之前页面的其它部分无法完全显示,或者图片加载的过程中页面会出现闪烁或布局跳动。


    这种加载方式是 同步 的,即浏览器渲染页面时,图片的加载和显示是直接相关的。如果图片较大或者网络慢,用户可能会看到空白的占位符,直到图片加载完成。


  • 使用 new Image()img.src = src: 这种方式会在后台加载图片,不直接影响页面的渲染。也就是说,图片资源在浏览器缓存中已经加载好了,页面显示图片时,浏览器能快速地从缓存读取图片,而不必等待网络请求。浏览器不会因为加载图片而延迟页面的渲染。


    关键点是:通过 new Image() 加载图片会提前发起请求,将图片缓存到浏览器中,这意味着你可以在用户滚动或需要展示图片时,直接从缓存加载,而不需要重新请求网络资源。这个过程是 异步 的。



2. 浏览器的资源管理和缓存



  • 图片预加载的缓存: 当你通过 new Image() 加载图片时,图片会被缓存在浏览器的内存中(通常是浏览器的资源缓存),因此如果图片已经被加载过,后续使用该图片时会直接从缓存读取,而不需要重新请求网络资源。


    而如果你直接用 <img> 标签来加载图片,浏览器同样会请求并缓存图片,但如果图片在初次加载时不可见(比如在页面下方),用户滚动到该位置时,可能会再次触发网络请求,尤其是在使用懒加载(lazy load)等技术时。如果图片已经预加载过,浏览器就可以从缓存中直接加载,避免了再次请求。



3. 避免页面阻塞



  • 直接使用 <img> :当浏览器在解析页面时遇到 <img> 标签,会立即发起网络请求来加载图片。如果图片资源很大或者服务器响应很慢,浏览器可能需要等待这些资源加载完成,才能继续渲染其他部分。这会导致页面的 渲染阻塞,即页面内容渲染较慢,特别是在图片多的情况下。

  • 使用 new Image() 预加载:通过 new Image() 预加载图片,可以避免渲染时对页面的阻塞。浏览器在后台加载图片,直到需要展示图片时,图片已经准备好了,这样页面展示可以更快,用户体验也更好。


4. 适用场景



  • 直接 <img> 标签加载:适用于图片较少且页面上几乎所有图片都需要立即展示的场景。例如,单一图片展示的页面。

  • new Image() 预加载:适用于图片较多或需要延迟加载的场景,例如动态加载的图片、长页面或者需要懒加载的图片库。它允许你提前将图片加载到浏览器缓存中,减少后续显示时的加载时间。


5. 加载速度和时间


如果从加载速度和时间上来看,两者的差别可能不大,因为它们最终都会发起一次网络请求去加载图片。但是,new Image() 的优势在于:



  • 它允许你在图片真正需要显示之前就开始加载,这样当用户需要看到图片时,图片已经在浏览器缓存中,可以即时显示。

  • 使用 new Image() 可以提前加载图片,而不会影响页面的渲染顺序和内容显示,不会造成页面的阻塞。


6. 网络请求优化


new Image() 还可以和 并发请求 进行优化。如果你有多个图片需要预加载,可以通过多个 new Image() 实例来并行加载这些图片,而不影响页面的渲染。并且,如果你知道某些图片很可能会被需要(例如图片懒加载场景中的下拉加载图片),你可以提前加载这些图片,确保用户滚动时能立刻看到图片。


image.png


7. 总结对比


特性<img> 标签加载new Image() 预加载
渲染影响直接渲染图片,可能导致页面闪烁或布局跳动异步加载图片,不影响页面渲染
缓存图片加载后会缓存,但可能会重复请求图片预先加载到缓存中,避免重复请求
适用场景单一图片,少量图片,图片快速加载图片较多,懒加载,预加载
加载时机页面渲染时加载,可能导致渲染延迟提前加载,确保图片准备好时显示

结论


虽然从技术上讲,直接在 <img> 标签中加载图片和使用 new Image() 设置 src 都会触发相同的图片加载过程,但是 使用 new Image() 进行预加载 提供了更灵活的控制,使得你可以在页面渲染时避免图片加载阻塞,提升页面的加载速度和用户体验。


(补充:代码示例小demo传送门)


1再见.png


作者:不爱说话郭德纲
来源:juejin.cn/post/7441246880666107931
收起阅读 »

微信小程序批量自动化部署

CI/CD这个概念很实用,但我们这种小作坊,没有一些很高大上的应用。 最常见的使用场景就是,开发者一键提交分支master,交给工作流工具完成构建,部署的后续操作,自动更新测试或线上环境。 个人博客等项目可以使用Github action来实现,但公司的代码在...
继续阅读 »

CI/CD这个概念很实用,但我们这种小作坊,没有一些很高大上的应用。


最常见的使用场景就是,开发者一键提交分支master,交给工作流工具完成构建,部署的后续操作,自动更新测试或线上环境。


个人博客等项目可以使用Github action来实现,但公司的代码在云效上,我更习惯于使用云效Flow来实现自动化部署。他的操作菜单是可视化的,非常方便,还有一些推送机器人消息的傻瓜化配置插件。


目前遇到一个需求,就是同一个uni-app小程序项目,需要部署到多个不同的小程序上。每个小程序的主要功能类似,但都有一些定制改动。


每次项目发版时,如果要手动挨个在微信开发者工具上切换、上传,会非常繁琐,而且uni-app使用dev命令输出的开发环境微信小程序项目代码也没有优化,正式发版时哪怕只有一个小程序也需要在dev、build两个项目里来回切。


因此非常需要自动化部署来节省精力。


下面梳理一下微信小程序的批量自动化部署实现流程。


准备工作


常见的web项目自动化部署,至少包含代码触发、构建、部署这3个步骤。


其中构建步骤中操作的产物会被打包上传,并在部署步骤中,下载到目标服务器,然后执行后续目录操作、启动等操作。


但是微信小程序的部署不需要这些操作,而是通过在node脚本中执行miniprogram-ci这个工具的相关方法来实现的。


miniprogram-ci的相关文档请参考这里


密钥及IP白名单配置


跟着文档操作,首先需要到微信小程序管理后台的开发设置中进行配置。


点击生成按钮即可创建密钥,关闭后只能重新生成。


1.png


将密钥文件下载到安全的位置。由于我们的项目是私有库,这里就直接放到了项目deploy目录下。多个小程序的密钥可以放在一起,默认已经用appId做了区分。


云效Flow的构建集群提供了一组IP地址,将这些IP地址加入白名单即可。地址如下:


47.94.150.88
47.94.150.17
47.93.89.246
123.56.255.38
112.126.70.240

来源


IP地址不在白名单的话,调用上传时会报错。如果在本地调试,别忘了将本机的公网IP加入白名单,或者临时关闭。


构建脚本


uni-app项目使用vite框架,这里用到了.env环境变量的相关功能,原生微信小程序请自行实现或省略此功能。


更新版本号


微信小程序上传时,需要指定版本号。


版本号标准的用法还是放在package.json中,所以我在自动化部署实现过程中,顺便就引入了standard-version版本号管理。(项目被标记为deprecated,但我没有找到其他适合私有库的版本号管理工具,欢迎指点。)


standard-version可以自动根据git提交记录生成CHANGELOG.md


并按照以下初始规则来生成版本号:


如果上个版本之间的提交只有fixed,更新patch版本号,比如1.0.0更新到1.0.1


否则更新minor版本号,比如1.0.0更新到1.1.0


更新版本号的同时,它会将CHANGELOG.md与更新版本号以后的package.json一同提交到git,同时创建一个版本号对应的tag。




在一般项目中这样就足够了,但是如果还想在小程序中展示这个版本号,就会存在问题——无法引入package.json文件。


而且使用wx.getAccountInfoSync虽然也能获取版本号,但只有正式环境能用,在体验版、开发版中是空字符串。


因此,我只能修改部署版本命令,加上了一些后处理脚本,将版本号同步更新到环境变量中。


在package.json的script中,添加以下命令:


{
"scripts": {
"release": "standard-version && node deploy/deploy.js version",
"release:minor": "standard-version -- --release-as minor && node deploy/deploy.js version",
"release:beta": "standard-version -p beta && node deploy/deploy.js version"
}
}

多提一嘴,release:minor是在提交记录只有fixed但又希望更新minor版本时使用的,可以无视默认规则。当然也可以无视所有规则直接指定具体版本号,具体使用可查看文档(github.com/conventiona…


后处理脚本


在deploy目录下,创建deploy.js文件,内容如下:


const fs = require('node:fs')
const path = require('node:path')
const process = require('node:process')
const { execSync } = require('node:child_process')
const JSON5 = require('json5')
const ci = require('miniprogram-ci')
const { Command } = require('commander')
const dayjs = require('dayjs')
const dotenv = require('dotenv')
const { version } = require('../package.json')

const program = new Command()

// 同步版本号
program
.command('version')
.option('-a, --appid <type>', 'application id')
.action((options) => {
const envPath = path.resolve(__dirname, '../.env')
// 读取 .env 文件的内容
const envContent = fs.readFileSync(envPath, 'utf8')

// 分割每一行
const lines = envContent.split('\n')

// 定义新的内容数组
const newLines = []

// 遍历每一行,查找并修改 VITE_APP_VERSION 的值
lines.forEach((line) => {
if (line.startsWith('VITE_APP_VERSION=')) {
newLines.push(`VITE_APP_VERSION=${version}`)
}
else {
newLines.push(line) // 保留其他行,包括注释
}
})

// 将修改后的内容写回 .env 文件
fs.writeFileSync(envPath, newLines.join('\n'))

// 添加文件到暂存区
execSync(`git add ${envPath}`)

// 获取前一次提交的标签
let tag
try {
tag = execSync('git describe --tags --abbrev=0').toString().trim()
}
catch (error) {
console.error('没有找到标签')
process.exit(1)
}

// 将当前暂存区的改动追加到前一次提交中
execSync('git commit --amend --no-edit')

// 删除旧的标签
execSync(`git tag -d ${tag}`)

// 将标签移动到新的提交
execSync(`git tag ${tag}`)
})

program.parse(process.argv)

这个脚本会读取.env文件,找到VITE_APP_VERSION这一行,将其值更新为package.json中的version,然后将改动合并到前一次的git提交中,也就是standard-version所创建的提交。


没有用dotenv是因为这个工具更适合读取配置,但写入时会丢失注释信息。


构建小程序


如果只有一个小程序,可以略过此步,直接执行构建命令然后上传。


有多个小程序时,需要先执行一些定制脚本,再执行构建。比如至少要做的一项操作是更新appId,在uni-app中,这项配置位于manifest.json中。


deploy/deploy.js中添加以下代码:


// 切换小程序
program
.command('toggle')
.option('-a, --appid <type>', 'application id')
.action((options) => {
if (!options.appid) {
console.error('请输入 application id')
process.exit(1)
}
// 定义文件路径
const filePath = path.join(__dirname, '../src/manifest.json')
// 读取 JSON 文件
fs.readFile(filePath, 'utf8', (err, data) => {
if (err) {
console.error('读取文件失败:', err)
return
}

try {
// 解析 JSON 数据(支持注释)
const jsonData = JSON5.parse(data)

// 修改 appid 字段
jsonData['mp-weixin'].appid = options.appid

// 将修改后的 JSON 数据转换为字符串(支持注释格式)
console.log(jsonData)
const updatedData = JSON.stringify(jsonData, null, 2)
console.log(updatedData)
// 写入修改后的数据到 JSON 文件
fs.writeFile(filePath, updatedData, 'utf8', (err) => {
if (err) {
console.error('写入文件失败:', err)
return
}
console.log('文件已成功更新')
})
}
catch (err) {
console.error('解析 JSON 数据失败:', err)
}
})
})

这个脚本会读取manifest.json文件,找到mp-weixin.appid这一行,将其值更新为命令行参数中的appid,然后将改动写入manifest.json文件。


调用脚本的命令例子为:


node deploy/deploy.js toggle --appid=你的appid

上传小程序


deploy/deploy.js中添加以下代码:



// 上传小程序
program
.command('upload')
.option('-a, --appid <type>', 'application id')
.action((options) => {
if (!options.appid) {
console.error('请输入 application id')
process.exit(1)
}

// 获取当前工作目录的父路径
const projectDir = path.join(__dirname, '../')

const project = new ci.Project({
appid: options.appid,
type: 'miniProgram',
projectPath: `${projectDir}/dist/build/mp-weixin`,
privateKeyPath: `${projectDir}/deploy/private.${options.appid}.key`,
// ignores: ['node_modules/**/*'],
})
ci.upload({
project,
version,
desc: `CI机器人于${dayjs().format('YYYY-MM-DD HH:mm:ss')}上传`,
setting: {
es6: true,
es7: true,
minify: true,
// autoPrefixWXSS: true,
minifyWXML: true,
minifyJS: true,
},
}).then((res) => {
console.log(res)
console.log('上传成功')
process.exit(0)
}).catch((error) => {
if (error.errCode === -1) {
console.log('上传成功')
process.exit(0)
}
console.log(error)
console.log('上传失败')
process.exit(-1)
})
})

program.parse(process.argv)


这个脚本会调用微信小程序的CI接口,将小程序上传到微信服务器。调用脚本的命令例子为:


node deploy/deploy.js upload --appid=你的appid

其中appid在命令行中传入,而version是从package.json中读取的。


完整的deploy.js文件


const fs = require('node:fs')
const path = require('node:path')
const process = require('node:process')
const { execSync } = require('node:child_process')
const JSON5 = require('json5')
const ci = require('miniprogram-ci')
const { Command } = require('commander')
const dayjs = require('dayjs')
const dotenv = require('dotenv')
const { version } = require('../package.json')

const program = new Command()

// 同步版本号
program
.command('version')
.option('-a, --appid <type>', 'application id')
.action((options) => {
const envPath = path.resolve(__dirname, '../.env')
// 读取 .env 文件的内容
const envContent = fs.readFileSync(envPath, 'utf8')

// 分割每一行
const lines = envContent.split('\n')

// 定义新的内容数组
const newLines = []

// 遍历每一行,查找并修改 VITE_APP_VERSION 的值
lines.forEach((line) => {
if (line.startsWith('VITE_APP_VERSION=')) {
newLines.push(`VITE_APP_VERSION=${version}`)
}
else {
newLines.push(line) // 保留其他行,包括注释
}
})

// 将修改后的内容写回 .env 文件
fs.writeFileSync(envPath, newLines.join('\n'))

// 添加文件到暂存区
execSync(`git add ${envPath}`)

// 获取前一次提交的标签
let tag
try {
tag = execSync('git describe --tags --abbrev=0').toString().trim()
}
catch (error) {
console.error('没有找到标签')
process.exit(1)
}

// 将当前暂存区的改动追加到前一次提交中
execSync('git commit --amend --no-edit')

// 删除旧的标签
execSync(`git tag -d ${tag}`)

// 将标签移动到新的提交
execSync(`git tag ${tag}`)
})

// 切换小程序
program
.command('toggle')
.option('-a, --appid <type>', 'application id')
.action((options) => {
if (!options.appid) {
console.error('请输入 application id')
process.exit(1)
}
// 定义文件路径
const filePath = path.join(__dirname, '../src/manifest.json')
// 读取 JSON 文件
fs.readFile(filePath, 'utf8', (err, data) => {
if (err) {
console.error('读取文件失败:', err)
return
}

try {
// 解析 JSON 数据(支持注释)
const jsonData = JSON5.parse(data)

// 修改 appid 字段
jsonData['mp-weixin'].appid = options.appid

// 将修改后的 JSON 数据转换为字符串(支持注释格式)
console.log(jsonData)
const updatedData = JSON.stringify(jsonData, null, 2)
console.log(updatedData)
// 写入修改后的数据到 JSON 文件
fs.writeFile(filePath, updatedData, 'utf8', (err) => {
if (err) {
console.error('写入文件失败:', err)
return
}
console.log('文件已成功更新')
})
}
catch (err) {
console.error('解析 JSON 数据失败:', err)
}
})
})

// 上传小程序
program
.command('upload')
.option('-a, --appid <type>', 'application id')
.action((options) => {
if (!options.appid) {
console.error('请输入 application id')
process.exit(1)
}

// 获取当前工作目录的父路径
const projectDir = path.join(__dirname, '../')

const project = new ci.Project({
appid: options.appid,
type: 'miniProgram',
projectPath: `${projectDir}/dist/build/mp-weixin`,
privateKeyPath: `${projectDir}/deploy/private.${options.appid}.key`,
// ignores: ['node_modules/**/*'],
})
ci.upload({
project,
version,
desc: `CI机器人于${dayjs().format('YYYY-MM-DD HH:mm:ss')}上传`,
setting: {
es6: true,
es7: true,
minify: true,
// autoPrefixWXSS: true,
minifyWXML: true,
minifyJS: true,
},
}).then((res) => {
console.log(res)
console.log('上传成功')
process.exit(0)
}).catch((error) => {
if (error.errCode === -1) {
console.log('上传成功')
process.exit(0)
}
console.log(error)
console.log('上传失败')
process.exit(-1)
})
})

program.parse(process.argv)


如果是原生微信小程序,且使用了npm依赖,只需要在upload之前执行一下构建命令即可:


// 在有需要的时候构建npm
const warning = await ci.packNpm(project, {
ignores: [],
reporter: (infos) => { console.log(infos) }
})
console.warn(warning)
// ci.upload()

在本地调试时,用以下命令即可模拟构建的完整操作了:


node deploy/deploy.js toggle --appid=小程序A
pnpm run build:mp-weixin:小程序A
node deploy/deploy.js upload --appid=小程序A

注意这里的build命令,对应package.json中脚本的写法为:


"build:mp-weixin:小程序A": "uni build -p mp-weixin --mode 小程序A",

传入mode参数时,执行时会读取.env.小程序A中定义的环境变量,从而实现一些定制化的操作。


可以将这组命令写成sh脚本,每个小程序一个,都放在deploy目录下,在Flow工作流中调用。


上传命令执行成功后,微信小程序后台版本管理中就可以看到这个版本了:


2.png


后续的提审、发布操作目前仍需人工操作。


配置云效Flow


本地调试正常后,最后来配置云效Flow。


前面的代码触发不变,后面的部署步骤可以直接删除。


构建脚本为:


npm i -g pnpm
pnpm config set registry https://registry.npmmirror.com
pnpm i
node deploy/deploy.js toggle --appid=小程序A
pnpm run build:mp-weixin:小程序A
node deploy/deploy.js upload --appid=小程序A

如果有多个小程序,可以配置多个并行步骤:


3.png


待优化


依赖应该只需要安装一次,即将安装依赖步骤与构建步骤分开。


(可选)配置通知机器人


4.png


在构建步骤窗口的底部,可以添加通知插件。


这里使用的是钉钉机器人,教程参考这里


大致步骤为:



  1. 在钉钉中拉上同事或者小号,凑满3人,创建一个外部群。

  2. 在钉钉群的群设置中,添加机器人,获得api接口地址与签名。

  3. 在云效Flow的钉钉机器人插件中填入接口地址与签名。


此后每次发版,只需提版合并到master分支,等待片刻收到钉钉机器人的提示,就可以准备提审了。


5.png


参考来源:



作者:mirari
来源:juejin.cn/post/7392558409743548466
收起阅读 »

为了解决小程序tabbar闪烁的问题,我将小程序重构成了 SPA

web
(日落西山,每次看到此景,我总是会想到明朝(明朝那些事儿第六部的标题,日落西山))  前言 几个月前,因工作需求,我开发了一个小程序,当时遇到了一个需求,是关于tabbar权限的问题。小程序的用户分两种,普通用户和vip用户,普通用户tabbar有两个,vip...
继续阅读 »

1.jpg


(日落西山,每次看到此景,我总是会想到明朝(明朝那些事儿第六部的标题,日落西山))


 前言


几个月前,因工作需求,我开发了一个小程序,当时遇到了一个需求,是关于tabbar权限的问题。小程序的用户分两种,普通用户和vip用户,普通用户tabbar有两个,vip用户小程序下面的tabbar有五个。  

因为涉及自定义tabbar的问题,所以官方自带的tabbar肯定就不能用了,我们需要自定义tabbar。官方也提供了自定义tabbar的功能。


官网自定义tabbar


官网地址:基础能力 / 自定义 tabBar (qq.com)


{
"tabBar": {
"custom": true,
"list": []
}
}

就是需要在 app.json 中的 tabBar 项指定 custom 字段,需要注意的是 list 字段也需要存在。


然后,在代码根目录下添加入口文件:


custom-tab-bar/index.js
custom-tab-bar/index.json
custom-tab-bar/index.wxml
custom-tab-bar/index.wxss

具体代码,大家可以参考官网案例。


需要注意的是每个tabbar页面 / 组件都需要在onshow / show 函数中执行以下函数,否则就会出现tabbar按钮切换两次,才会变成选中色的问题。


      if (typeof this.getTabBar === 'function' &&
this.getTabBar()) {
this.getTabBar().setData({
selected: 0 // 第n个tabbar页面就填 n-1
})
}

接下来就是我的思路


2.png


我在 custom-tab-bar/index.js 中定义了一个函数,这个函数去判断当前登录人是否为vip,如果是就替换掉tabbar 的数据。


那么之前每个页面的代码就要写成这样


      if (typeof this.getTabBar === 'function' &&
this.getTabBar()) {
this.getTabBar().change_tabbar_list()
this.getTabBar().setData({
selected: 0 // 第n个tabbar页面就填 n-1
})
}

ok,我们来看一下效果。注意看视频下方的tabbar,每个页面,第一次点击的时候,有明显的闪烁bug。(大家也可以参考一下市面上的小程序,小部分的小程序有这个闪烁问题,大部分的小程序没有这个闪烁的问题(如:携程小程序))



bug产生原因


那么我们就要去思考了,为什么人家的小程序没有这个bug呢?


想这个问题前,要先去想这个bug是怎么产生的,我猜测是每个tabbar页面都有个初始化的过程,第一次渲染页面的时候要去重新渲染tabbar,每个页面的tabbar都是从0开始渲染,然后会缓存到每个页面上,所以第二次点击就没有这个bug了。


解决tabbar闪烁问题


为了解决这个问题,我想到了SPA ,也就是只留一个页面,其他的tabbar页面都弄成组件。


效果展示



已经解决,tabbar闪烁的问题。


代码思路,通过wx:if 控制组件的显示隐藏。


3.png


4.png


源码地址:gitlab.com/wechat-mini…

https克隆地址:gitlab.com/wechat-mini…


写在最后


1、我也是在网上见过别人的一些评论,说如果将小程序重构成这种单页面,会有卡顿问题,我目前没有发现这个问题,可能是我做的小程序功能比较少。


2、至于生命周期,将页面切换成组件后,页面的那些生命周期也肯定都不能使用了,只能用组件的生命周期,我之前开发使用组件的生命周期实现业务逻辑也没什么问题。 触底加载这些也只能换成组件去实现了。


3、小程序最上面的标题,也可以使用以下代码来实现。就是在每个组件初始化的时候要去执行下列代码。


            wx.setNavigationBarTitle({
title: '',
});

作者:楚留香Ex
来源:juejin.cn/post/7317281367111827475
收起阅读 »

一句话让cursor爬取到大量美女图片!!!

AI编程大大的提高了人们的开发效率。 cursor cursor是一个集成了GPT4、Claude 3.5等先进LLM的类VScode的编译器,可以理解为在vscode中集成了AI辅助编程助手。 cursor内置了很多LLMs,包括最先进的GPT4s、Clau...
继续阅读 »

AI编程大大的提高了人们的开发效率。


cursor


cursor是一个集成了GPT4、Claude 3.5等先进LLM的类VScode的编译器,可以理解为在vscode中集成了AI辅助编程助手。


cursor内置了很多LLMs,包括最先进的GPT4s、Claude3.5s和openai最新发布的推理模型o1-preview和o1-mini,在右上角的设置中即可打开相应的模型进行辅助编程。
最常用的快捷键就下面四个:



  • Tab:自动填充

  • Ctrl+K:编辑代码

  • Ctrl+L:(compose模式对话)回答用户关于代码和整个项目的问题,适合复杂的多轮对话,需要处理文件的场景,能长期保存对话历史

  • Ctrl+i:(chat模式对话)简单的问答,系统快速的文本,生成实时对话需求


下面将带大家使用cursor去爬取美女图片。这个项目并不复杂,我们使用chat模式来进行对话。我们使用ctrl+i调出对话框,输入要求即可


image.png
接着cursor就会给你回复,直接按照回复运行即可。可以看到图片已经爬取出来了
image.png


当然,这种方式也能很快的帮我们学习。当我们成品做出来之后,我们可以使用vscode的marscode进行问答,让他告诉我们代码的作用是什么,小编称之为面向实战学习,下面带着大家迅速学习一个简单demo感受一下学习的效率。


marscode


marscode是vscode集成的一款AI插件,能够让AI给用户进行页面内部的问答,这样就不用打开外置的AI应用进行询问,给程序员沉浸式的体验。
这是一个爬取微博热榜的简单小demo


const request = require('request-promise');
const cheerio = require('cheerio');
const createCsvWriter = require('csv-writer').createObjectCsvWriter;

// 目标URL
const url = 'https://tophub.today/n/KqndgxeLl9';

// 发送HTTP请求并解析HTML
request(url)
.then(html => {
const $ = cheerio.load(html);
const hotList = [];

// 选择表格中的每一行
$('table tr').each((index, element) => {
if (index === 0) return; // 跳过表头行

const rank = $(element).find('td:nth-child(1)').text().trim();
const title = $(element).find('td:nth-child(2) a').text().trim();
const heat = $(element).find('td:nth-child(3)').text().trim();
const link = $(element).find('td:nth-child(2) a').attr('href');

hotList.push({ rank, title, heat, link });
});

// 创建CSV写入器
const csvWriter = createCsvWriter({
path: 'hot_list.csv',
header: [
{ id: 'rank', title: 'Rank' },
{ id: 'title', title: 'Title' },
{ id: 'heat', title: 'Heat' },
{ id: 'link', title: 'Link' }
]
});

// 写入CSV文件
csvWriter.writeRecords(hotList)
.then(() => console.log('CSV file has been saved.'))
.catch(err => console.error('Error writing CSV file:', err));
})
.catch(err => console.error('Error fetching the webpage:', err));

我们是没有学过爬虫的哦,里面的内容都看不太懂,我们让AI来带着我们学习。


const request = require('request-promise');
const cheerio = require('cheerio');
const createCsvWriter = require('csv-writer').createObjectCsvWriter;

首先发起疑惑,这个require是什么啊?我们打开marscode选中要询问的代码就可以直接询问


image.png


image.png
可以看到marscode已经给了我们回复,原来这是es6之前的导入模块的方式。这三个模块的作用分别是发送请求的模块,解析HTML的模块和将爬取到的文本写入csv文件的模块。
我们可以接着询问。我们发现了一个 $ 符号看不懂,我们再问问AI这是什么


image.png
更多的就不再演示了,总之通过这种方式能极大的提高学习的效率


作者:ZXT
来源:juejin.cn/post/7442731383615389733
收起阅读 »

优雅解决uniapp微信小程序右上角胶囊菜单覆盖问题

web
前言 大家好,今天聊一下在做uniapp多端适配项目,需要用到自定义导航时,如何解决状态栏塌陷及导航栏安全区域多端适配问题,下文只针对H5、APP、微信小程序三端进行适配,通过封装一个通用高阶组件包裹自定义导航栏内容,主要是通过设置padding来使内容始终保...
继续阅读 »

前言


大家好,今天聊一下在做uniapp多端适配项目,需要用到自定义导航时,如何解决状态栏塌陷及导航栏安全区域多端适配问题,下文只针对H5、APP、微信小程序三端进行适配,通过封装一个通用高阶组件包裹自定义导航栏内容,主要是通过设置padding来使内容始终保持在安全区域,达到低耦合,可复用性强的效果。


一、创建NavbarWrapper.vue组件


大致结构如下:


<template>
<view class="navbar-wrapper" :style="{
paddingTop: statusBarHeight,
paddingRight: rightSafeArea
}"
>

<slot/>
</view>

</template>

<script>
export default {
name: 'NavbarWrapper',
data() {
return {
// 像素单位
pxUnit: 'px',
// 默认状态栏高度
statusBarHeight: 'var(--status-bar-height)',
// 微信小程序右上角的胶囊菜单宽度
rightSafeArea: 0
}
}
}
</script>


<style scoped>
.navbar-wrapper {
/**
* 元素的宽度和高度包括了内边距(padding)和边框(border),
* 而不会被它们所占据的空间所影响
* 子元素继承宽度时,只会继承内容区域的宽度
*/

box-sizing: border-box;
}
</style>


目的


主要是动态计算statusBarHeight和rightSafeArea的值。


解决方案


APP端只需一行css代码即可


.navbar-wrapper {
padding-top: var(--status-bar-height);
}

下面是关于--status-bar-height变量的介绍:


image.png


从上图可以知道--status-bar-height只在APP端是手机实际状态栏高度,在微信小程序是固定的25px,并不是手机实际状态栏高度;


微信小程序时,除了状态栏高度还需要获取右上角的胶囊菜单所占宽度,保持导航栏在安全区域。


以下使用uni.getWindowInfo()uni.getMenuButtonBoundingClientRect()来分别获取状态栏高度和胶囊相关信息,api介绍如下图所示:


image.png


image.png


主要逻辑代码


在NavbarWrapper组件创建时,做相关计算


created() {
const px = this.pxUnit
// #ifndef H5
// 获取窗口信息
const windowInfo = uni.getWindowInfo()
this.statusBarHeight = windowInfo.statusBarHeight + px
// #endif

// #ifdef MP-WEIXIN
// 获取胶囊左边界坐标
const { left } = uni.getMenuButtonBoundingClientRect()
// 计算胶囊(包括右边距)占据屏幕的总宽度:屏幕宽度-胶囊左边界坐标
this.rightSafeArea = windowInfo.windowWidth - left + px
// #endif
}

用法


<NavbarWrapper>
<view class="header">header</view>
</NavbarWrapper>

二、多端效果展示


微信小程序


b15a0866000c13e58259645f2459440.jpg


APP端


45ee33b12dcf082e5ac76dc12fc41de.jpg


H5端


22b1984f8b21a4cb79f30286a1e4161.jpg


三、源码


NavbarWrapper.vue


<template>
<view class="navbar-wrapper" :style="{
paddingTop: statusBarHeight,
paddingRight: rightSafeArea
}"
>

<slot/>
</view>

</template>

<script>
export default {
name: 'NavbarWrapper',
data() {
return {
// 像素单位
pxUnit: 'px',
// 默认状态栏高度
statusBarHeight: 'var(--status-bar-height)',
// 微信小程序右上角的胶囊菜单宽度
rightSafeArea: 0
}
},
created() {
const px = this.pxUnit
// #ifndef H5
// 获取窗口信息
const windowInfo = uni.getWindowInfo()
this.statusBarHeight = windowInfo.statusBarHeight + px
// #endif

// #ifdef MP-WEIXIN
// 获取胶囊左边界坐标
const { left } = uni.getMenuButtonBoundingClientRect()
// 计算胶囊(包括右边距)占据屏幕的总宽度:屏幕宽度-胶囊左边界坐标
this.rightSafeArea = windowInfo.windowWidth - left + px
// #endif
}
}
</script>


<style scoped>
.navbar-wrapper {
/**
* 元素的宽度和高度包括了内边距(padding)和边框(border),
* 而不会被它们所占据的空间所影响
* 子元素继承宽度时,只会继承内容区域的宽度
*/

box-sizing: border-box;
background-color: deeppink;
}
</style>


往期文章回顾


一文学会请求中断、请求重发、请求排队、请求并发


一文学会vue3如何自定义hook钩子函数和封装组件


table表格自适应浏览器窗口变化解决方案


作者:vilan_微澜
来源:juejin.cn/post/7309361597556719679
收起阅读 »

uniapp微信小程序授权后得到“微信用户”

web
背景 近日在开发微信小程序的时候,发现数据库多了很多用户名称是"微信用户"的账号信息。接口的响应信息如下。 (nickName=微信用户, avatarUrl=https://thirdwx.qlogo.cn/mmopen/vi_32/POgEwh4mIHO4...
继续阅读 »

背景


近日在开发微信小程序的时候,发现数据库多了很多用户名称是"微信用户"的账号信息。接口的响应信息如下。


(nickName=微信用户, avatarUrl=https://thirdwx.qlogo.cn/mmopen/vi_32/POgEwh4mIHO4nibH0KlMECNjjGxQUq24ZEaGT4poC6icRiccVGKSyXwibcPq4BWmiaIGuG1icwxaQX6grC9VemZoJ8rg/132, gender=0, country=, province=, city=, language=), code=0e1abNFa1dBwRG0lnoJa18qT0i2abNFk)

经过排查,发现官方是对微信授权的接口做出了调整。小程序用户头像昵称获取规则调整公告


WX20240206-112518@2x.png

根据上面标红的字体说明,官方的意图就是只提供openid和unionid, 不暴露用户头像昵称数据。

基于此才会在新版的接口中返回"微信用户"的信息。



  • 针对这个问题,官方提供的解决方案如下。


WX20240206-112912@2x.png
以上解决方案,表达的意思是新版用户授权的接口中, 官方只会给你提供unionid和openid.

至于用户的昵称和头像,开发者可以提供功能,以用户的意志去完成修改和更新。

tips: 建议授权接口生成用户名和昵称,采用系统默认的方式。


微信授权流程


152f3cb28a734e768381f986cec1dd26.png


uniapp代码实现


uni.login接口文档


WX20240207-221556@2x.png


后端代码


WX20240207-221641@2x.png


异常分析


//如果你的接口出现如下信信息,该如何处理呢?
# {errMsg: “getUserProfile:fail api scope is not
declared in the privacy agreement“, errno: 112}

出现问题的原因: api 范围未在隐私协议中声明,建议大家更具公告,更新对应的隐私协议。

【设置-服务内容声明-用户隐私保护指引】,更新隐私协议,在第一条:开发者处理的信息中,点击【增加信息类型】,选择需要授权的信息,头像昵称我已经勾选了,所以列表中不显示了,根据需求选择和填写其他内容,最后确定并生成协议。等待隐私协议审核通过。


68b3f3f0c4ee419d9ca5dec8aa5b0a4c.png
建议按需添加,以防审核不通过。


为了分辨用户,开发者将在获取你的明示同意后,收集你的微信昵称、头像。
为了显示距离,开发者将在获取你的明示同意后,收集你的位置信息。
开发者收集你的地址,用于获取位置信息。
开发者收集你的发票信息,用于维护消费功能。
为了用户互动,开发者将在获取你的明示同意后,收集你的微信运动步数。
为了通过语音与其他用户交流互动,开发者将在获取你的明示同意后,访问你的麦克风。
开发者收集你选中的照片或视频信息,用于提前上传减少上传时间。
为了上传图片或者视频,开发者将在获取你的明示同意后,访问你的摄像头。
为了登录或者注册,开发者将在获取你的明示同意后,收集你的手机号。
开发者使用你的通讯录(仅写入)权限,用于方便用户联系信息。
开发者收集你的设备信息,用于保障你正常使用网络服务。
开发者收集你的身-份-证号码,用于实名认证后才能继续使用的相关网络服务。
开发者收集你的订单信息,用于方便获取订单信息。
开发者收集你的发布内容,用于用户互动。
开发者收集你的所关注账号,用于用户互动。
开发者收集你的操作日志,用于运营维护。
为了保存图片或者上传图片,开发者将在获取你的明示同意后,使用你的相册(仅写入)权限。
为了用户互动,开发者将在获取你的明示同意后,收集你的车牌号。
开发者访问你的蓝牙,用于设备连接。
开发者使用你的日历(仅写入)权限,用于用户日历日程提醒。
开发者收集你的邮箱,用于在必要时和用户联系。
开发者收集你选中的文件,用于提前上传减少上传时间。


当你选择所需的接口后,需要您填写使用说明。 可以参考上面的内容进行填写。

给大家看一下我申请的接口。折腾半天终于把授权登录给整好了。


WX20240208-100953@2x.png


做完上述隐私设置后,需要你重新发布自己的小程序。 并且设置成采集用户隐私。

审核通过后就可以啦。如下图, 请一定注意!!!


WX20240208-101216@2x.png


参考文档


头像昵称填写-微信官方文档

uniapp头像昵称填写

getUserProfile:fail api scope is not declared in the privacy agreement


作者:代码次位面
来源:juejin.cn/post/7332113324651610150
收起阅读 »

被antdesign的恐怖的scripts吓到了

web
近日无意中打开antdesign的package.json,然后就看到一砣恐怖的scripts "scripts": { "api-collection": "antd-tools run api-collection", "authors"...
继续阅读 »

近日无意中打开antdesignpackage.json,然后就看到一砣恐怖的scripts


 "scripts": {
"api-collection": "antd-tools run api-collection",
"authors": "tsx scripts/generate-authors.ts",
"build": "npm run compile && cross-env NODE_OPTIONS='--max-old-space-size=4096' npm run dist",
"changelog": "npm run lint:changelog && tsx scripts/print-changelog.ts",
"check-commit": "tsx scripts/check-commit.ts",
"clean": "antd-tools run clean && rimraf es lib coverage locale dist report.html artifacts.zip oss-artifacts.zip",
"clean:lockfiles": "rimraf package-lock.json yarn.lock",
"precompile": "npm run prestart",
"compile": "npm run clean && antd-tools run compile",
"predeploy": "antd-tools run clean && npm run site && cp CNAME _site && npm run test:site",
"deploy": "gh-pages -d _site -b gh-pages -f",
"deploy:china-mirror": "git checkout gh-pages && git pull origin gh-pages && git push git@gitee.com:ant-design/ant-design.git gh-pages -f",
"predist": "npm run version && npm run token:statistic && npm run token:meta",
"dist": "antd-tools run dist",
"format": "biome format --write .",
"install-react-16": "npm i --no-save --legacy-peer-deps react@16 react-dom@16 @testing-library/react@12",
"install-react-17": "npm i --no-save --legacy-peer-deps react@17 react-dom@17 @testing-library/react@12",
"bun-install-react-16": "bun remove react react-dom @testing-library/react && bun add --no-save react@16 react-dom@16 @testing-library/react@12",
"bun-install-react-17": "bun remove react react-dom @testing-library/react && bun add --no-save react@17 react-dom@17 @testing-library/react@12",
"prelint": "dumi setup",
"lint": "npm run version && npm run tsc && npm run lint:script && npm run lint:biome && npm run lint:md && npm run lint:style && npm run lint:changelog",
"lint:changelog": "tsx scripts/generate-component-changelog.ts",
"lint:deps": "antd-tools run deps-lint",
"lint:md": "remark . -f -q",
"lint:script": "eslint . --cache",
"lint:biome": "biome lint",
"lint:style": "tsx scripts/check-cssinjs.tsx",
"prepare": "is-ci || husky && dumi setup",
"prepublishOnly": "tsx ./scripts/pre-publish.ts",
"prettier": "prettier -c --write . --cache",
"prettier-import-sort": "npm run prettier -- --plugin=@ianvs/prettier-plugin-sort-imports",
"biome": "biome check --write",
"pub": "echo 'Please use `npm publish` instead.'",
"postpublish": "tsx scripts/post-publish.ts",
"presite": "npm run prestart",
"site": "npm i --no-save --legacy-peer-deps react@18.3.0-canary-c3048aab4-20240326 react-dom@18.3.0-canary-c3048aab4-20240326 && dumi build && cp .surgeignore _site",
"size-limit": "size-limit",
"sort:api-table": "antd-tools run sort-api-table",
"sort:package-json": "npx sort-package-json",
"prestart": "npm run version && npm run token:statistic && npm run token:meta && npm run lint:changelog",
"start": "tsx ./scripts/set-node-options.ts cross-env PORT=8001 dumi dev",
"pretest": "npm run version",
"test": "jest --config .jest.js --no-cache",
"test:all": "sh -e ./scripts/test-all.sh",
"test:dekko": "node ./tests/dekko/index.test.js",
"test:image": "jest --config .jest.image.js --no-cache -i -u --forceExit",
"test:node": "npm run version && jest --config .jest.node.js --no-cache",
"test:package-diff": "antd-tools run package-diff",
"test:site": "jest --config .jest.site.js",
"test:site-update": "npm run site && npm run test:site -- -u",
"test:update": "jest --config .jest.js --no-cache -u",
"test:visual-regression": "tsx scripts/visual-regression/build.ts",
"token:meta": "tsx scripts/generate-token-meta.ts",
"token:statistic": "tsx scripts/collect-token-statistic.ts",
"tsc": "tsc --noEmit",
"tsc:old": "tsc --noEmit -p tsconfig-old-react.json",
"version": "tsx scripts/generate-version.ts"
},

面对如此复杂的scripts,有没有被吓到。


相信我,在团队开发中,不要说团队成员,就算是开发者本身一段时间后也不一定能一眼就看到每一条脚本的作用了。


怎么呢?最好是加点注释


但是众所周知,package.json是不支持注释了。


这里给大家推荐一个VSCODE插件json_comments_extension,可以用来给任意JSON文件添加注释.


效果如下:


preview.gif


preview2.gif


开源推荐


以下是我的一大波开源项目推荐:



作者:渔夫正在掘金
来源:juejin.cn/post/7442573821444227109
收起阅读 »

Canvas 轻量图文编辑器的一些实践

web
1. 前言 简而言之,我们需要一个能够在 H5 端和桌面端使用的轻量级图文编辑器。具体的使用流程是在桌面端制作编辑模板(上传一张底图,指定编辑区域的大小),然后在 H5 端允许用户在模板的基础之上添加文本,图片...
继续阅读 »

1. 前言


简而言之,我们需要一个能够在 H5 端和桌面端使用的轻量级图文编辑器。具体的使用流程是在桌面端制作编辑模板(上传一张底图,指定编辑区域的大小),然后在 H5 端允许用户在模板的基础之上添加文本,图片,支持对文本图片的多种编辑等。


2. 核心问题和分析


主要诉求是需要自研一套商品图文定制编辑器,在 PC 上支持模板定制,在 H5 上支持图文编辑。模板定制主要是确定底图的编辑区域,图文编辑器则是在底图上添加图片和文字。


2.1 社区现状


在图文编辑器上,目前社区中各式各样的编辑器非常丰富:



  • 专业的修图软件:PS、Pixelmator 等

  • 手机 App:美图秀秀、Picsart 等,功能也非常完善且强大,不比 PS 差

  • 轻量级编辑器:视频封面编辑、公众号图文排版、商品定制等面向业务场景


PhotoShopPixelmator
imageimage
美图秀秀Picsart
image

在 Web 上的编辑器种类也非常丰富,毕竟 canvas 能做的事情非常多。比如 miniPaint基本复刻了 ps,基于 farbic.js的 Pintura.和 tui.image-editor,基于 Konva的 polotno等等。这些编辑器也基本是个 app 级别的应用了。


miniPainttui.image-editor
imageimage
polotnopintura
imageimage

总结一下:


1、不论是软件型应用还是 Web 编辑器,一种是做得非常通用的编辑器,功能丰富且完善,另一种就是面向业务流程定制的轻量型编辑器,只有一些特定交互操作和属性配置能力,可操作内容很少;


2、上述的这些 Web 编辑器大部分都是在 PC 上被使用,在手机上的编辑器也基本是在 Native 容器里开发。所以可以参考的 H5 编辑器基本没有。


3、PC 和 H5 编辑器一个明显的不同是,在 PC 上编辑操作,是选中元素后,元素的属性在工具栏或侧边栏进行编辑,画布上的操作只有缩放和旋转。在 H5 上的编辑器,元素选中后的操作会主要放在四个锚点控制器上,添加自定义操作,其余一些次相关的操作放在底部操作栏。所以在设计和实现这个编辑器的过程中,我们参考了很多类似手机 App 的交互。



2.2 分析


操作流程


1、在 PC 设置模板,上传底图,并设置定制区域,定制区域可调整


2、在 H5 上基于模板进行图文编辑,可添加图片和文字,文字可修改字体 颜色 大小。同时可控制元素的缩放旋转、层级移动、删除和复制。


3、最后基于模板和元素,导出定制图。


我们这次的场景显然只需要一个轻量型的图文编辑器,技术上如何选型?



  • 如果基于完整的第三方编辑类库(如 polotno),太重了,可能有现成的功能,但改造成本更高;

  • 基于图形处理库(封装了 Cavnas 或者 SVG 的 API)直接开发会更容易管理,但可能需要从头实现一些功能。


我们准备基于 Konva 来实现这次的编辑器需求。也想借这次机会,沉淀一些通用的编辑能力,如元素锚点操作的控制、拖转限制的计算逻辑、蒙层遮罩的绘制逻辑、坐标转换的逻辑等等。


Why Konva?


Konva 和 Fabric 都是比较热门的开源 2D 图形库,封装了 Canvas 的一系列 API。


FarbicKonva
比较老牌,比 Konva上线时间更早一些。使用 TypeScript 编写,TS 原生支持
常用转换(放大、缩小、拖拽)都已经封装好,内置了丰富的笔刷,基本的对齐、标线都有,特别适合用 Canvas 写交互性的界面渲染分层比较清晰,Stage -> Layer -> Gr0up -> Shape
代码集成度比较高,内置了可交互富文本(纯 Canvas 实现)代码简洁、干净,易于阅读
代码使用 ES5开发,不能很好的支持 TypeScript,开发效率可能会有影响文档清晰,容易上手
由于库本身集成了很多功能点,代码包的大小偏大(压缩后308 kB)核心代码精简,代码包较小(压缩后155 kB
细节功能还需要完善,比如标线系统实现相对简单部分功能实现基于 DOM(富文本)
.后起之秀,周边生态还比较薄弱

2.3 编辑器设计思路


编辑器按照图层叠加的顺序自上而下是 底图 -> 蒙层 -> 元素 -> 控制器




3. 详细功能设计


3.1 数据


3.1.1 数据格式定制


目前支持两种编辑区域,圆形和矩形。编辑区域的数据类型为


    export type EditAreaType = RectArea | CircleArea;

export interface RectArea {
/** 类型 */
type: 'Rect';
/** 属性 */
attrs: { x: number, y: number, width: number, height: number };
}

export interface CircleArea {
/** 类型 */
type: 'Circle';
/** 属性 */
attrs: { x: number, y: number, radius: number };
}


其中,x,y 均是相对于底图所在容器的坐标。


3.1.2 坐标转换


由于服务端考虑到数据流量成本,在PC和H5的底图会做分辨率的限制,例如在PC上传的底图是 1200x1200,在 H5 上提供的底图是 400x400(但最后合成的时候会用原图)。因此定义编辑器数据过程中,元素和蒙层的坐标不能相对于底图,需要相当于容器大小计算。同时能够互相转换。


如下图所示,用户可以再 PC 端定制编辑区域的大小和位置,然后将模板的数据导出到 h5。这里的问题就是 PC 端制作的模板数据(底图,编辑区域相对于容器的位置,宽高)如何做转换的问题。





但本质上也是三个坐标系之间的转换问题。第一个坐标系是 PC 端底图的容器,第二个坐标系是图片底图本身,第三个坐标系是 h5 端底图的容器。底图填充容器的逻辑为:保持宽高比,填满容器的宽或高,另一个方向上居中处理。


用户在定制编辑区域的时候其实是以底图为坐标系的,但为了方便处理,我们将编辑区域的数据保存为以容器为坐标系。这样在 h5 端加载编辑区域的时候需要一套转换逻辑。实际的转换过程如下图所示,我们只需要计算出将底图填充到两个容器的的变换的 ”差“,或者说两个变换结果之间的变换即可,然后就是将求出的变换应用到编辑区域或具体的元素上。



实际的代码可能更好理解一些


/**
* 映射编辑区域,将编辑区域从旧容器映射到新容器
* @param area 原始编辑区域数据
* @param ratio 底图比例
* @param containerSize 原始容器尺寸
* @param newContainerSize 新容器尺寸
* @returns 映射后的编辑区域 EditAreaType
*/

export const projectEditArea = (
area: EditAreaType,
ratio: number,
containerSize: Vector2,
newContainerSize: Vector2,
) => {
const { type, attrs } = area;
// 编辑区域相对于旧的容器的 transform
const transform = {
x: attrs.x,
y: attrs.y,
rotation: 0,
scaleX: 1,
scaleY: 1,
};
// 编辑区域相对于旧容器的 transform 转换为相对于 新容器的 transform
const newTransform = projectTransform(transform, ratio, containerSize, newContainerSize);
// 编辑区域是矩形
if (type === 'Rect') {
const { width, height } = attrs as { width: number, height: number };
return {
type,
attrs: {
x: newTransform.x,
y: newTransform.y,
width: width * newTransform.scaleX,
height: height * newTransform.scaleY,
},
};
}
// 编辑区域是圆形
if (type === 'Circle') {
attrs as { x: number, y: number, radius: number };
const { radius } = attrs as { radius: number };
return {
type,
attrs: {
x: newTransform.x,
y: newTransform.y,
radius: radius * newTransform.scaleX,
},
};
}

return area;
};


/**
* 映射元素的形变
* @param transform 原始容器下的形变
* @param ratio 底图比例
* @param containerSize 原始容器尺寸
* @param newContainerSize 新容器尺寸
* @returns { TransformAttrs } 新容器下的形变
*/

export const projectTransform = (
transform: TransformAttrs,
ratio: number,
containerSize: Vector2,
newContainerSize: Vector2,
) => {
const {
x, y, rotation, scaleX, scaleY,
} = transform;

const [oldContainerWidth, oldContainerHeight] = containerSize;
const oldContainerRatio = oldContainerWidth / oldContainerHeight;

// 底图相对于旧容器的位置,按比例缩放后居中
let origin: null | { x: number, y: number } = null;
// 底图在旧容器按比例缩放后的 size
let imgSize: null | { width: number, height: number } = null;
// 图片宽高比 < 旧容器宽高比 旧容器更宽,横向有空白
if (ratio < oldContainerRatio) {
imgSize = {
height: oldContainerHeight,
width: oldContainerHeight * ratio,
};
origin = {
x: (oldContainerWidth - oldContainerHeight * ratio) / 2,
y: 0,
};
} else {
// 图片宽高比 > 容器宽高比 旧容器更高,上下有空白
imgSize = {
width: oldContainerWidth,
height: oldContainerWidth / ratio,
};
origin = {
x: 0,
y: (oldContainerHeight - oldContainerWidth / ratio) / 2,
};
}

const [newContainerWidth, newContainerHeight] = newContainerSize;
const newContainerRatio = newContainerWidth / newContainerHeight;

let newOrigin: null | { x: number, y: number } = null;
let newImgSize: null | { width: number, height: number } = null;
// 底图比例小于新容器的宽高比,新容器更宽,缩放后横向有空白
if (ratio < newContainerRatio) {
newImgSize = {
width: newContainerHeight * ratio,
height: newContainerHeight,
};

newOrigin = {
y: 0,
x: (newContainerWidth - newContainerHeight * ratio) / 2,
};
} else {
// 底图比例大于新容器的宽高比,新容器更高,缩放后上下有空白
newImgSize = {
width: newContainerWidth,
height: newContainerWidth / ratio,
};
newOrigin = {
x: 0,
y: (newContainerHeight - newContainerWidth / ratio) / 2,
};
}

// 保持宽高比
// 计算旧容器内底图到新容器内底图的缩放比例
const scale = Math.min(newImgSize.width / imgSize.width, newImgSize.height / imgSize.height);
// 累积两次缩放,实现到新容器保持宽高比缩放效果
const newScaleX = scaleX * scale;
const newScaleY = scaleY * scale;

// 编辑区域相对于旧容器底图的位置转换为相对于新容器底图的位置
const newX = (x - origin.x) * scale + newOrigin.x;
const newY = (y - origin.y) * scale + newOrigin.y;

return {
x: newX, y: newY, rotation, scaleX: newScaleX, scaleY: newScaleY,
};
};


3.2 元素操作


3.2.1 缩放 && 旋转元素


缩放和旋转元素的功能如下图所示,要求按住元素右下角的 icon 的时候,可以绕元素中心旋转元素或缩放元素。


image


这里最好是有一些 2维 平面上仿射变换的知识,理解起来会更轻松,可以参考  闫令琪关于计算机图形学入门的课程中的介绍,这里就直接介绍解法了。


上面动图中所展示的一共有三种仿射变换,缩放,旋转,还有平移。缩放和旋转都很明显,但是为什么有平移 ?因为 Konva 默认的旋转是围绕 ”左上角“ 的,而实际位移的又是 “右下角”,所以如果想要一个围绕中心旋转的效果,就需要移动 “左上角” 把 “右下角”的位移抵消掉。举个例子,放大的时候,右下角向编辑器右下方移动,左上角向编辑器左上方移动,他们的位移方向总是相反且距离相等。


这里我们只需要在拖拽过程中计算出此刻 ”右下角“ 和元素中心构成的向量 和 上个时刻 ”右下角“ 和元素中心构成的向量,之间的比值,角度,和位移。然后再将这三中变换应用到元素上即可,如下图所示,具体的代码这里不再讲解。


image


3.2.2 拖拽区域限制


元素的拖拽范围限制是一个常见的问题,h5 上期望的效果为元素不可拖出蒙版所在区域,也就是 h5 上底图实际所在的区域。


image


实现拖拽范围限制功能的一个思路是在拖拽的回调函数中判断当前的元素坐标是否越界,如果越界则修改元素的坐标为不越界的合法坐标。拖动是一个连续的过程,元素在被拖出限定区域之前会有一个临界的时刻,在此之前元素完全在限定区域内,在此之后,元素开始被拖出限定区域。所以,将元素限制在编辑区域内就是要在元素将要离开的最后一刻,修改元素下一刻的位置把它拉回来。


image


Konva 也直接提供了一个元素的 dragBoundFunc(pos: Konva.vector2d) => Konva.vector2d函数,其入参是下一个拖动过程中下一个时刻元素 “左上角” 本来的坐标,返回值是下一个时刻元素 “左上角” 最终的坐标。该函数会在拖动过程中不断执行,只需在此函数中填入限制逻辑即可。


需要注意的是,这里面有两个棘手的问题



  1. 由于元素自身支持旋转,元素的 “左上角” 并不一定一直处于左上角的位置

  2. 只有元素 “左上角” 下一时刻的坐标,无法计算下一个时刻元素是否越界 


image
image


这两个问题的解决过程可谓是一波三折。这里需要注意两个点:一是,拖拽是一个连续的过程,拖拽的过程中只有位移,没有其他变换。二是,我们知道的不仅仅是 dragBoundFunc 传入的下一个时刻的 “左上角” 的坐标,我们还可以计算出当前时刻的元素的四个顶点的坐标。


所以,我们可以计算出下一个时刻 “左上角” 坐标和此刻 “左上角” 坐标的偏移量,从而计算出下一个时刻元素的四个顶点的坐标。然后检测,下个时刻的元素是否在限制区域内即可。如下图所示。


image


好的,现在我们找到了那个将要越界的时刻,我们该如何计算出一个合法的坐标作为下个时刻元素 “左上角” 的坐标 ?你不能直接把边界值,minX minY maxX maxY 这些值返回,因为“左上角”不一定在左上角。


那如果我找到越界的那个点,然后把对应的点和边界对齐,然后再通过三角函数计算呢 ?就像下图中画的这样。


image


当然可以 😂 ,但是这也太复杂,太不优雅了,你还要获取元素当前旋转的角度,还要判断到底是哪个点越界 ...


有没有更快更简单的方法,当然也有,这又不是在造火箭。如果精确解很困难,找到一个准确度还不错的近似解就是有价值的。 越界的上一刻还是合法的,我们可以“时间回溯”,用上一个时刻 左上角合法的坐标来返回就行了。


    if(crossLeft || crossRight || crossTop || crossBottom){
pos = lastPos;
}else {
lastPos = pos;
}


到此为止就已经能实现开头动图中的效果了。


3.3 控制器


Konva 虽然提供了 Transfomer,可以用于实现拖拽缩放、旋转元素。但在 H5 上对操作功能做了定制,如调整层级,删除元素等等,仍然需要自己定义和实现一个元素控制器。


如下图所示,控制器主要包含虚线边框和四角的可点击 icon。要求点击 icon 分别实现弹窗调整层级,复制,删除,按住拖拽缩放大小的能力。


image
image


3.3.1 单例模式


控制器最开始是根据元素实例化的,即每添加一个元素都有一个控制器实例。元素被激活(点击)时会显示该元素的控制器 同时隐藏其他所有控制器,元素失焦之后会隐藏该元素的控制器。拖拽元素,缩放元素的过程中需要同步元素的大小到其自身的控制器。


image


如上图所示,每个 Shape 类都有一个控制器属性,绘制控制器的时候,会传入包含icon 的回调函数的配置。Shape 的拖拽,缩放过程中需要调用控制器提供的公有方法 updateByShape 来同步位置和缩放比例。


这种做法较为简单,易于理解,但会带来以下两个问题



  1. 画布上的 Shape 增多,难以区分不同元素的 Shape,对于调整元素之间的层级关系(zIndex)造成困难。

  2. 画布上的控制器的 Shape 增多,可能会造成性能变差。

  3. 控制器和 Shape 类混杂在一起,概念不清晰,代码上不好维护。


将控制器和 Shape 类拆分后,两个类的职责更单一。 Shape 类面相外部导出,可以做更多定制。控制器类只面相交互,实现编辑功能。


后面梳理后发现并不需要多个控制器实例子,同一时刻处于激活状态的元素只有一个,不会同时编辑(拖拽,缩放)两个元素。使用一个控制器实例,能够减少画布上的 Shape,便于控制元素的层级。后续的代码逐步演变成下图所示。


image


控制器通过 id 关联当前激活的 ShapeElementShapeElement 类是对 Konva.Shape 类的简单包装,在其上添加了一些生命周期方法和导出方法等。 而控制器类中则实现了 缩放,拖拽等编辑能力,这种模式下,用户缩放和拖拽的其实是外层的控制器,然后控制器再将这些编辑操作通过 syncBorderRect 方法同步到当前激活的 ShapeElement


而为了实现点击不同的 ShapeElement 时切换控制器的效果,我们提供了 updateByShapeElement 方法,在 shape 的 onClick 回调中,只需要调用该方法即可。


在这种模式下,原来控制器位于蒙层之上的效果也容易实现了。如下图所示,画布上从下到上分别是:底图,文本/图片元素,蒙层,控制器。


imageimage


3.3.2 判断当前选中元素


实现当前控制器的另一个难点在于,元素处于蒙版的遮盖的时候,点击元素如何唤起控制器。如上图所示,当元素完全被蒙版遮盖的时候,Konva 提供的元素的 onClick 事件是不会触发的。


image


这样只能回到在 canvas 上实现点击事件的思路,监听点击事件,根据点击事件的坐标和元素的位置关系来判断选中的元素。


具体的逻辑为:



  1. 获取点击事件中的坐标

  2. 通过 d3-polygon 提供的方法判断点击事件的坐标在不在元素的包围盒中。

  3. 排序找到命中的最上层的元素

  4. 激活对应元素,直接执行元素的 onClick 回调函数。


3.4 蒙层


3.4.1 蒙层绘制 


蒙层的功能主要有两个:1. PC 端方便用户定制编辑区域的大小。2 H5 端起到编辑区域外起到半透明遮盖的效果,编辑区域内可视的效果。


image
image


蒙层的元素主要有三个部分,一是背景的半透明的黑色区域,二是拖拽编辑区域大小时外层的框所在的矩形,三是实现透明效果的矩形。可拖拽,缩放的透明矩形框的实现是 Konva Rect + Konva Transformer,借助了 transfomer 提供的能力实现编辑区域的缩放。而透明效果的矩形主要是借助 Konva Shape 的 sceneFunc 定制形状的能力,通过 canvas 中的 clip 函数实现透明的矩形或者圆形的效果。


3.4.2 导出特定区域


导出图片时限定只导出编辑区域内的功能主要依赖 Konva 提供的 clipFunc 函数,该函数会传入 canvas2d 绘制上下文,只需要绘制出特定的区域,konva 会自动帮我们只导出区域内的内容。


4. 总结


本文介绍了基于 Konva 实现 H5端的轻量级图文编辑器的一种方法,在实现这个轻量级的图文编辑器的过程中我们总结了设计思路和常见的问题处理方案。当然,编辑器的实现是一个需要不断打磨交互和细节的过程,比如像拖拽过程中的辅助线提示、支持文本和图片更丰富的属性等等。篇幅所限,这里不再展开介绍了。希望本文对有志于动手实现编辑器的前端同学能有所助益。


作者:ES2049
来源:juejin.cn/post/7312243176835334196
收起阅读 »

three.js实现3D汽车展厅效果展示

web
今天简单实现一个three.js的小Demo,加强自己对three知识的掌握与学习,只有在项目中才能灵活将所学知识运用起来,话不多说直接开始。 相关源码和模型的下载链接地址 点击链接进行跳转 项目搭建 本案例还是借助框架书写three项目,借用vite构建工具...
继续阅读 »

今天简单实现一个three.js的小Demo,加强自己对three知识的掌握与学习,只有在项目中才能灵活将所学知识运用起来,话不多说直接开始。


相关源码和模型的下载链接地址 点击链接进行跳转


项目搭建


本案例还是借助框架书写three项目,借用vite构建工具搭建vue项目,搭建完成之后,用编辑器打开该项目,在终端执行 npm i 安装一下依赖,安装完成之后终端在安装 npm i three 即可。


因为我搭建的是vue3项目,为了便于代码的可读性,所以我将three.js代码单独抽离放在一个组件当中,在App根组件中进入引入该组件。具体如下:


<template>
<!-- 3D汽车展厅 -->
<CarShowroom></CarShowroom>
</template>

<script setup>
import CarShowroom from './components/CarShowroom.vue';
</script>

<style lang="less">
*{
margin: 0;
padding: 0;
}
</style>

初始化three.js代码


three.js开启必须用到的基础代码如下:


导入three库


import * as THREE from 'three'

初始化场景


const scene = new THREE.Scene()

初始化相机


// 创建相机
const camera = new THREE.PerspectiveCamera(40,window.innerWidth / window.innerHeight,0.1,1000)
camera.position.set(4.25,1.4,-4.5)

初始化渲染器


// 创建渲染器
const renderer = new THREE.WebGLRenderer({ antialias: true })
renderer.setSize(window.innerWidth,window.innerHeight)
document.body.appendChild(renderer.domElement)

监听屏幕大小的改变,修改渲染器的宽高和相机的比例


window.addEventListener("resize",()=>{ 
renderer.setSize(window.innerWidth,window.innerHeight)
camera.aspect = window.innerWidth/window.innerHeight
camera.updateProjectionMatrix()
})

导入轨道控制器


// 添加轨道控制器
import { OrbitControls } from 'three/examples/jsm/controls/OrbitControls'
// 添加控制器
const controls = new OrbitControls(camera,renderer.domElement)
controls.enableDamping = true // 设置控制阻尼

设置渲染函数


// 设置渲染函数
const render = (time) =>{
controls.update()
renderer.render(scene,camera)
requestAnimationFrame(render)
}
render()

ok,写完基础代码之后,接下来开始具体的Demo实操。


加载汽车模型


通过使用模型加载器GLTFLoader,然后使用DRACOLoader加载Draco压缩过的模型可以显著减小模型文件体积,从而加快加载速度和提高用户体验。代码如下:


import { GLTFLoader } from "three/examples/jsm/loaders/GLTFLoader";
import { DRACOLoader } from "three/examples/jsm/loaders/DRACOLoader";

// 加载汽车模型
const loader = new GLTFLoader()
const dracoLoader = new DRACOLoader()
dracoLoader.setDecoderPath("/draco/")
loader.setDRACOLoader(dracoLoader)
loader.load("/public/model/Lamborghini.glb",(gltf)=>{
scene.add(gltf.scene)
})

模型加载完成,画面如下:

图片.png


因为没有灯光,所以我们需要给一个灯光让模型展现出来,这里设置一下环境光源:


// 设置环境光源
const ambientLight = new THREE.AmbientLight('#fff',0.5)
scene.add(ambientLight)

3a886e62e2d949ee88132dcb5a9ff1cb.gif


设置展厅效果


这里通过three库中自带的一些模型来实现展厅的效果,如下:


设置地板样式


// 设置地板样式
const floorGeometry = new THREE.PlaneGeometry(20,20)
const floormaterial = new THREE.MeshPhysicalMaterial({
side: THREE.DoubleSide,
color: 0x808080,
metalness: 0, // 设置金属度
roughness: 0.1, // 设置粗糙度
wireframe: false // 关闭网格线
})
const mesh = new THREE.Mesh(floorGeometry,floormaterial)
mesh.rotation.x = Math.PI / 2
scene.add(mesh)

7c03c298b206422eab96aa86adbfa69f.gif


底部样式设置完,设置一个圆柱体将整个地板进行包裹:


// 设置圆柱体模拟展厅
const cylinder = new THREE.CylinderGeometry(12,12,20,32)
const cylindermaterial = new THREE.MeshPhysicalMaterial({
color: 0x6c6c6c,
side: THREE.DoubleSide
})
const cylinderMesh = new THREE.Mesh(cylinder,cylindermaterial)
scene.add(cylinderMesh)

图片.png


接下来在圆柱体中设置一个聚光灯,让聚光灯偏垂直照射汽车模型,如下:


// 设置聚光灯(让汽车更具有立体金属感)
const spotLight = new THREE.SpotLight('#fff',2)
spotLight.angle = Math.PI / 8 // 散射角度,和水平线的夹角
spotLight.penumbra = 0.2 // 横向,聚光锥的半影衰减百分比
spotLight.decay = 2 // 纵向,沿着光照距离的衰减量
spotLight.distance = 30
spotLight.shadow.radius = 10
spotLight.shadow.mapSize.set(4096,4096)
spotLight.position.set(-5,10,1)
spotLight.target.position.set(0,0,0) // 光照射的方向
spotLight.castShadow = true
scene.add(spotLight)

图片.png


为了不让展厅穿帮,这里将控制器的缩放以及旋转角度进行一个限制,让其只能在展厅中灵活查看而不能跑到展厅外面去:


controls.maxDistance = 10 // 最大缩放距离
controls.minDistance = 1 // 最小缩放距离
controls.minPolarAngle = 0 // 最小旋转角度
controls.maxPolarAngle = 85 / 360 * 2 * Math.PI // 最大旋转角度

设置GUI面板动态控制车身操作


这里我使用three.js库中自带的gui库,来动态的改变车身相关操作,因为我仅仅是控制车身材质和玻璃材质相关的数据操作,这里就线设置一下其相关的材质:


// 车身材质
let bodyMaterial = new THREE.MeshPhysicalMaterial({
color: 'red',
metalness: 1,
roughness: 0.5,
clearcoat: 1.0,
clearcoatRoughness: 0.03
})
// 玻璃材质
let glassMaterial = new THREE.MeshPhysicalMaterial({
color: '#793e3e',
metalness: 0.25,
roughness: 0,
transmission: 1.0 // 透光性
})

在glb模型中,通过traverse函数遍历场景中的所有对象(包括Mesh、Gr0up、Camera、Light等),并对这些对象进行相应操作或处理(这里的门操作后面会讲解到):


loader.load("/public/model/Lamborghini.glb",(gltf)=>{
const carModel = gltf.scene
carModel.rotation.y = Math.PI
carModel.traverse((obj)=>{
if(obj.name === 'Object_103' || obj.name === 'Object_64' || obj.name === 'Object_77'){
// 车身
obj.material = bodyMaterial
}else if(obj.name === 'Object_90'){
// 玻璃
obj.material = glassMaterial
}else if(obj.name === 'Empty001_16' || obj.name === 'Empty002_20'){
// 门
// doors.push(obj)
}else{
return true
}
})
scene.add(gltf.scene)
})

最后得到的结果如下:


图片.png


接下来通过控制面板来动态的监视汽车模型的车身和玻璃材质:


// 设置gui模板控制
// 修改默认面板名称
gui.domElement.parentNode.querySelector('.title').textContent = '3D汽车动态操作'

const bodyChange = gui.addFolder("车身材质设置")
bodyChange.close() // 默认关闭状态
bodyChange.addColor(bodyMaterial,'color').name('车身颜色').onChange(value=>{
bodyMaterial.color.set(value)
})
bodyChange.add(bodyMaterial,'metalness',0,1).name('金属度').onChange(value=>{
bodyMaterial.metalness = value
})
bodyChange.add(bodyMaterial,'roughness',0,1).name('粗糙度').onChange(value=>{
bodyMaterial.roughness = value
})
bodyChange.add(bodyMaterial,'clearcoat',0,1).name('清漆强度').onChange(value=>{
bodyMaterial.clearcoat = value
})
bodyChange.add(bodyMaterial,'clearcoatRoughness',0,1).name('清漆层粗糙度').onChange(value=>{
bodyMaterial.clearcoatRoughness = value
})
const glassChange = gui.addFolder("玻璃设置")
glassChange.close() // 默认关闭状态
glassChange.addColor(glassMaterial,'color').name('玻璃颜色').onChange(value=>{
glassMaterial.color.set(value)
})
glassChange.add(glassMaterial,'metalness',0,1).name('金属度').onChange(value=>{
glassMaterial.metalness = value
})
glassChange.add(glassMaterial,'roughness',0,1).name('粗糙度').onChange(value=>{
glassMaterial.roughness = value
})
glassChange.add(glassMaterial,'transmission',0,1).name('透光性').onChange(value=>{
glassMaterial.transmission = value
})

f2a6a032280c4325bb3416c60485421f.gif


车门操作与车身视角展示


这里依然用GUI控制面板来动态实现开关车门以及车内车外视角动态切换的操作,如下:


var obj = { carRightOpen,carLeftOpen,carRightClose,carLeftClose,carIn,carOut }
// 设置车身动态操作
const doChange = gui.addFolder("车身动态操作设置")
doChange.close() // 默认关闭状态
doChange.add(obj, "carLeftOpen").name('打开左车门')
doChange.add(obj, "carRightOpen").name('打开右车门')
doChange.add(obj, "carLeftClose").name('关闭左车门')
doChange.add(obj, "carRightClose").name('关闭右车门')
doChange.add(obj, "carIn").name('车内视角')
doChange.add(obj, "carOut").name('车外视角')

每个操作都对应一个函数,如下:


// 打开左车门
const carLeftOpen = () => {
setAnimationDoor({ x: 0 }, { x: Math.PI / 3 }, doors[1])
}
// 打开右车门
const carRightOpen = () => {
setAnimationDoor({ x: 0 }, { x: Math.PI / 3 }, doors[0])
}
// 关闭左车门
const carLeftClose = () => {
setAnimationDoor({ x: Math.PI / 3 }, { x: 0 }, doors[1])
}
// 关闭右车门
const carRightClose = () => {
setAnimationDoor({ x: Math.PI / 3 }, { x: 0 }, doors[0])
}

// 车内视角
const carIn = () => {
setAnimationCamera({ cx: 4.25, cy: 1.4, cz: -4.5, ox: 0, oy: 0.5, oz: 0 }, { cx: -0.27, cy: 0.83, cz: 0.60, ox: 0, oy: 0.5, oz: -3 });
}
// 车外视角
const carOut = () => {
setAnimationCamera({ cx: -0.27, cy: 0.83, cz: 0.6, ox: 0, oy: 0.5, oz: -3 }, { cx: 4.25, cy: 1.4, cz: -4.5, ox: 0, oy: 0.5, oz: 0 });
}

这里使用了补间动画tween.js,其github网址为 github.com/tweenjs/twe… ,终端安装其第三方插件之后,直接引入即可,如下(这里不再过多介绍该库的使用,想学习的可以自行寻找其官方文档学习):


图片.png


接下来借助tween.js库实现补间动画,如下:


// 设置补间动画
const setAnimationDoor = (start, end, mesh) => {
const tween = new TWEEN.Tween(start).to(end, 1000).easing(TWEEN.Easing.Quadratic.Out)
tween.onUpdate((that) => {
mesh.rotation.x = that.x
})
tween.start()
}
const setAnimationCamera = (start, end) => {
const tween = new TWEEN.Tween(start).to(end, 3000).easing(TWEEN.Easing.Quadratic.Out)
tween.onUpdate((that) => {
// camera.postition 和 controls.target 一起使用
camera.position.set(that.cx, that.cy, that.cz)
controls.target.set(that.ox, that.oy, that.oz)
})
tween.start()
}

最终实现的效果如下:


bd52745477bb428b88ba49e0220e634f.gif


点击查看车内视角的话,画面如下:


图片.png


设置手动点击打开关闭车门


通过设置监听点击事件函数来动态实现打开关闭车门:


// 设置点击打开车门的动画效果
window.addEventListener('click', onPointClick);
function onPointClick(event) {
let pointer = {}
pointer.x = (event.clientX / window.innerWidth) * 2 - 1;
pointer.y = - (event.clientY / window.innerHeight) * 2 + 1;
var vector = new THREE.Vector2(pointer.x, pointer.y)
var raycaster = new THREE.Raycaster()
raycaster.setFromCamera(vector, camera)
let intersects = raycaster.intersectObjects(scene.children);
intersects.forEach((item) => {
if (item.object.name === 'Object_64' || item.object.name === 'Object_77') {
if (!carStatus || carStatus === 'close') {
carLeftOpen()
carRightOpen()
} else {
carLeftClose()
carRightClose()
}
}
})
}

然后给每个车门设置汽车状态,如下:


图片.png


a7c25f153c814007aede998980cfef64.gif


设置图片背景


为了让展厅更具有视觉效果,接下来设置一个画面背景让其更具有画面感,如下:


// 创建聚光灯函数
const createSpotlight = (color) => {
const newObj = new THREE.SpotLight(color, 2);
newObj.castShadow = true;
newObj.angle = Math.PI / 6;;
newObj.penumbra = 0.2;
newObj.decay = 2;
newObj.distance = 50;
return newObj;
}

// 设置图片背景
const spotLight1 = createSpotlight('#ffffff');
const texture = new THREE.TextureLoader().load('src/assets/imgs/奥特曼.jpg')
spotLight1.position.set(0, 3, 0);
spotLight1.target.position.set(-10, 3, 10)
spotLight1.map = texture
const lightHelper = new THREE.SpotLightHelper(spotLight1);
scene.add(spotLight1);

最终呈现的效果如下:


图片.png


demo做完,本案例的完整代码获取 地址


作者:亦世凡华
来源:juejin.cn/post/7307146429004333094
收起阅读 »

实现敏感字段脱敏注解@Sensitive

前言 在B2C项目中,就以电商项目举例,都有前台与后台。并且这类项目的后台往往都会开放给公司内大部分人,甚至有些是将电商项目作为Saas服务提供给外部厂商的,这样后台中记录的用户数据就成为一个风险点,随着越来越多的人可以接触到后台系统,我们必须对用户的数据进行...
继续阅读 »

前言


在B2C项目中,就以电商项目举例,都有前台与后台。并且这类项目的后台往往都会开放给公司内大部分人,甚至有些是将电商项目作为Saas服务提供给外部厂商的,这样后台中记录的用户数据就成为一个风险点,随着越来越多的人可以接触到后台系统,我们必须对用户的数据进行加密不仅限于在数据库层面加密存储,前端展示的时候也必须要对例如:手机号,地址,身-份-证号等等隐私数据进行脱敏处理。


实现方式


1.最容易想到的就是利用硬编码的形式,哪些接口中涉及到了隐私数据,我们就去接口中对隐私数据进行脱敏。(ps一开始我确实是这么做的)


2.但是我发现太多太多接口都需要使用用户隐私数据了,我人工一个一个手工改也太不优雅了!我就想到我们能不能在SpringMVC将数据写入response的时候就将他拦截住,然后我实现一个注解,其实这个注解也就是一个标识。我们通过反射对于被这个注解标注的字段进行脱敏处理,然后再写回对象中。


这样不就可以只对响应类中加一个注解,然后所有使用用户敏感数据的接口都直接脱敏了吗,而且我们也可以很方便的改变我们的脱敏策略!!!


代码


hutools工具依赖


最适合中国宝宝体质的中国工具包,虽然网上很多人喷他,但是我个人觉得还是挺好用的,可能是我段位还不够。


<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-all</artifactId>
<version>5.8.11</version>
</dependency>

@Sensitive注解


/**
* @projectName: BlossomKnowledge
* @package: blossom.project.bk.common.annotaion
* @className: Sensitive
* @author: Link Ji
* @description: GOGO
* @VX: _Aeeee86
* @date: 2024/9/28 16:36
* @version: 1.0
*/

@Retention(java.lang.annotation.RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface Sensitive {
SensitiveDataType type() default SensitiveDataType.PASSWORD;

}

脱敏策略枚举类


/**
* @projectName: BlossomKnowledge
* @package: blossom.project.bk.common.enums
* @className: SensitiveDataType
* @author: Link Ji
* @description: GOGO
* @VX: _Aeeee86
* @date: 2024/9/28 16:40
* @version: 1.0
*/

public enum SensitiveDataType {
//脱敏数据类型
NAME("name"),
ID_CARD("idCard"),
PHONE("phone"),
EMAIL("email"),
BANK_CARD("bankCard"),
ADDRESS("address"),
PASSWORD("password"),
;

SensitiveDataType(String type) {
this.type = type;
}
@Getter
private String type;
}

响应拦截器


这里就是最核心的代码了,利用了SpringMVC提供的钩子接口,ResponseBodyAdvice接口,其中提供了一个beforeBodyWrite方法,这个方法就可以在数据写入响应前可以对数据进行处理。


/**
* @projectName: BlossomKnowledge
* @package: blossom.project.bk.common.enums
* @className: SensitiveDataType
* @author: Link Ji
* @description: GOGO
* @VX: _Aeeee86
* @date: 2024/9/28 16:40
* @version: 1.0
*/

@ControllerAdvice
public class SensitiveDataAdvice implements ResponseBodyAdvice<Object> {

private final ObjectMapper objectMapper = new ObjectMapper();

@Override
public boolean supports(MethodParameter returnType, Class<? extends HttpMessageConverter<?>> converterType) {
// 拦截所有响应
return true;
}

@Override
public Object beforeBodyWrite(Object body, MethodParameter returnType, org.springframework.http.MediaType selectedContentType,
Class<? extends HttpMessageConverter<?>> selectedConverterType,
org.springframework.http.server.ServerHttpRequest request,
org.springframework.http.server.ServerHttpResponse response
) {
// 如果返回类型是result
if (body instanceof Result<?>){
// 处理对象,进行脱敏操作
handleSensitiveFields((Result<?>) body);
}

return body;
}

private void handleSensitiveFields(Result<?> res) {
Object data = res.getData();
//获取data的下的全部字段
if (data == null) {
return;
}
Field[] fields = data.getClass().getDeclaredFields();
for (Field field : fields) {
// 判断是否有 @SensitiveData 注解
if (field.isAnnotationPresent(Sensitive.class)) {
Sensitive annotation = field.getAnnotation(Sensitive.class);
SensitiveDataType sensitiveDataType = annotation.type();
field.setAccessible(true);
try {
Object value = field.get(data);
if (value instanceof String) {
// 执行脱敏操作
String maskedValue = DesensitizationUtils.maskData((String) value, sensitiveDataType.getType());
field.set(data, maskedValue);
}
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
}
}
}

脱敏工具类


这个工具类依赖于hutools提供的DesensitizedUtil


public class DesensitizationUtils {

public static String maskData(String data, String type) {
if (data == null) {
return null;
}
//使用switch匹配SensitiveDataType枚举中的类型,并且使用hutool脱敏工具类进行脱敏
return switch (type) {
case "name" -> DesensitizedUtil.chineseName(data);
case "idCard" -> DesensitizedUtil.idCardNum(data, 2, data.length() - 2);
case "phone" -> DesensitizedUtil.mobilePhone(data);
case "email" -> DesensitizedUtil.email(data);
case "bankCard"-> DesensitizedUtil.bankCard(data);
case "address" -> DesensitizedUtil.address(data, data.length() - 6);
default -> data;
};

}
}

效果演示



作者:refreshGogo
来源:juejin.cn/post/7419148660796293139
收起阅读 »

Spring Boot + liteflow 居然这么好用!实战

在我们的日常开发中,经常会遇到一些需要串行或并行处理的复杂业务流程。那我们该如何利用Spring Boot结合liteflow规则引擎来简化我们的业务流程先看一个实战案例!!在电商场景下,当订单完成后,我们需要同时进行积分发放和消息发送。这时候,我们可以利用l...
继续阅读 »

在我们的日常开发中,经常会遇到一些需要串行并行处理的复杂业务流程。

那我们该如何利用Spring Boot结合liteflow规则引擎来简化我们的业务流程

先看一个实战案例!!

在电商场景下,当订单完成后,我们需要同时进行积分发放和消息发送。

这时候,我们可以利用liteflow进行规则编排,处理这些并行任务。

1. 引入依赖

首先,在pom.xml文件中添加liteflow的依赖:

xml

<dependency>
<groupId>com.yomahubgroupId>
<artifactId>liteflow-spring-boot-starterartifactId>
<version>2.6.5version>
dependency>

2. 增加配置

application.yml文件中添加liteflow的配置:

yaml

spring:
application:
name: liteflow-demo

liteflow:
rule-source: "classpath:flow.xml" # 指定规则文件的位置
node-retry: 3 # 节点重试次数
thread-executor:
core-pool-size: 10 # 线程池核心线程数
max-pool-size: 20 # 线程池最大线程数
keep-alive-time: 60 # 线程存活时间

3. 编写规则文件

resources目录下创建flow.xml文件,编写规则文件内容:

xml

<flow>
<parallel>
<node id="pointNode"/>
<node id="messageNode"/>
parallel>
flow>

4. 编写业务逻辑组件

按照规则文件中的定义,编写相应的业务逻辑组件:

java

@LiteflowComponent("pointNode")
public class PointNode extends NodeComponent {
@Override
public void process() throws Exception {
// 发放积分逻辑
System.out.println("Issuing points for the order");
}
}

@LiteflowComponent("messageNode")
public class MessageNode extends NodeComponent {
@Override
public void process() throws Exception {
// 发送消息逻辑
System.out.println("Sending message for the order");
}
}

5. 流程触发

当订单完成后,我们需要触发liteflow的流程来执行积分发放和消息发送的逻辑。

我们可以在订单完成的服务方法中添加如下代码:

java

@Service
public class OrderService {

@Autowired
private FlowExecutor flowExecutor;

public void completeOrder(Order order) {
// 完成订单的其他逻辑
System.out.println("Order completed: " + order.getId());

// 执行liteflow流程
flowExecutor.execute2Resp("flow", order);
}
}

在上述代码中,我们使用FlowExecutor来执行liteflow流程,并将订单对象传递给流程。

这将触发flow.xml中定义的规则,执行并行的积分发放和消息发送逻辑。

性能统计

liteflow在启动时完成规则解析和组件注册,保证高性能的同时,还能统计各业务环节的耗时,帮助我们进行性能优化。

以下是一个性能统计示例:

java

@LiteflowComponent("performanceNode")
public class PerformanceNode extends NodeComponent {
@Override
public void process() throws Exception {
long start = System.currentTimeMillis();
// 业务逻辑
long end = System.currentTimeMillis();
System.out.println("PerformanceNode execution time: " + (end - start) + "ms");
}
}

liteflow组件概览

liteflow中,主要有以下几种组件:

  • 普通组件:集成NodeComponent,用于执行具体的业务逻辑;
  • 选择组件:通过业务逻辑选择不同的执行路径;
  • 条件组件:基于条件返回结果,决定下一步的业务流程。
java

// 普通组件示例
@LiteflowComponent("commonNode")
public class CommonNode extends NodeComponent {
@Override
public void process() throws Exception {
// 业务逻辑
System.out.println("Executing commonNode logic");
}
}

// 选择组件示例
@LiteflowComponent("choiceNode")
public class ChoiceNode extends NodeSwitchComponent {
@Override
public String processSwitch() throws Exception {
// 根据条件返回不同的节点ID
return "nextNodeId";
}
}

// 条件组件示例
@LiteflowComponent("conditionNode")
public class ConditionNode extends NodeIfComponent {
@Override
public boolean processIf() throws Exception {
// 判断条件
return true;
}
}

EL规则文件

liteflow中,规则文件可以采用XML格式编写,下面是一个简单的规则文件示例。

xml


id="commonNode"/>
id="conditionNode">
id="nextNode"/>
id="otherNode"/>

id="choiceNode">
id="case1" to="node1"/>
id="case2" to="node2"/>


如何使用EL规则文件

  1. 创建规则文件:将上述规则文件保存为flow.xml,放在项目的resources目录下;
  2. 配置liteflow:在Spring Boot项目中添加liteflow的配置,指定规则文件的位置;
yaml

liteflow:
rule-source: "classpath:flow.xml"
node-retry: 3
thread-executor:
core-pool-size: 10
max-pool-size: 20
keep-alive-time: 60
  1. 编写业务逻辑组件:按照规则文件中的定义,编写相应的组件逻辑。

数据上下文

liteflow中,数据上下文非常重要,它用于参数传递业务逻辑的执行。

我们可以通过以下代码示例了解数据上下文的用法。

java

@LiteflowComponent("contextNode")
public class ContextNode extends NodeComponent {
@Override
public void process() throws Exception {
// 获取数据上下文
LiteflowContext context = this.getContextBean();
// 设置数据
context.setData("key", "value");
// 获取数据
String value = context.getData("key");
System.out.println("Context data: " + value);
}
}

配置详解

在使用liteflow时,我们需要对一些参数进行配置,如规则文件地址、节点重试、线程池参数等。

以下是一个配置示例。

yaml

liteflow:
rule-source: "classpath:flow.xml" # 指定规则文件的位置
node-retry: 3 # 节点重试次数
thread-executor:
core-pool-size: 10 # 线程池核心线程数
max-pool-size: 20 # 线程池最大线程数
keep-alive-time: 60 # 线程存活时间

总的来说,liteflow在简化业务流程管理方面起到了非常重要的作用,可以提升开发效率和业务流程管理能力。



作者:程序员蜗牛
来源:juejin.cn/post/7388033492570095670
收起阅读 »

只CURD的Java后端要如何提升自己?

你是否工作3~5年后,发现日常只做了CURD的简单代码。 你是否每次面试就会头疼,自己写的代码,除了日常CURD简历上毫无亮点可写 抱怨过苦恼过也后悔过,但是站在现在的时间点回想以前,发现有很多事情我们是可以做的更好的。 于是有了这篇文章。 小北将带大家从六...
继续阅读 »

你是否工作3~5年后,发现日常只做了CURD的简单代码。

你是否每次面试就会头疼,自己写的代码,除了日常CURD简历上毫无亮点可写



抱怨过苦恼过也后悔过,但是站在现在的时间点回想以前,发现有很多事情我们是可以做的更好的。


于是有了这篇文章。


小北将带大家从六个方面深入探讨如何在Java后台管理开发中不断进步,帮助你在职业道路上稳步前行


一、写优雅的代码


优雅代码的重要性


优雅的代码不仅易于阅读和维护,还能减少错误,提高开发效率。对于后台管理系统,代码的整洁与规范尤为重要,因为它们通常涉及复杂的业务逻辑和大量的数据处理。


我们看一个简单的案例,我们直观的感受下,需求如下:



用户可以通过银行网页转账给另一个账号,支持跨币种转账。

同时因为监管和对账需求,需要记录本次转账活动



拿到这个需求之后,一个开发可能会经历一些技术选型,最终可能拆解需求如下:



1、从MySql数据库中找到转出和转入的账户,选择用MyBatis的mapper实现DAO

2、从Yahoo(或其他渠道)提供的汇率服务获取转账的汇率信息(底层是http开放接口)

3、计算需要转出的金额,确保账户有足够余额,并且没超出每日转账上限

4、实现转入和转出操作,扣除手续费,保存数据库

5、发送Kafka审计消息,以便审计和对账用



而一个常规的代码实现如下:



public class TransferServiceImpl implements TransferService {
private static final String TOPIC_AUDIT_LOG = "TOPIC_AUDIT_LOG";
private AccountMapper accountDAO;
private KafkaTemplate<String, String> kafkaTemplate;
private YahooForexService yahooForex;

@Override
public Result<Boolean> transfer(Long sourceUserId, String targetAccountNumber, BigDecimal targetAmount, String targetCurrency) {
// 1. 从数据库读取数据,忽略所有校验逻辑如账号是否存在等
AccountDO sourceAccountDO = accountDAO.selectByUserId(sourceUserId);
AccountDO targetAccountDO = accountDAO.selectByAccountNumber(targetAccountNumber);

// 2. 业务参数校验
if (!targetAccountDO.getCurrency().equals(targetCurrency)) {
throw new InvalidCurrencyException();
}

// 3. 获取外部数据,并且包含一定的业务逻辑
// exchange rate = 1 source currency = X target currency
BigDecimal exchangeRate = BigDecimal.ONE;
if (sourceAccountDO.getCurrency().equals(targetCurrency)) {
exchangeRate = yahooForex.getExchangeRate(sourceAccountDO.getCurrency(), targetCurrency);
}
BigDecimal sourceAmount = targetAmount.divide(exchangeRate, RoundingMode.DOWN);

// 4. 业务参数校验
if (sourceAccountDO.getAvailable().compareTo(sourceAmount) < 0) {
throw new InsufficientFundsException();
}
if (sourceAccountDO.getDailyLimit().compareTo(sourceAmount) < 0) {
throw new DailyLimitExceededException();
}

// 5. 计算新值,并且更新字段
BigDecimal newSource = sourceAccountDO.getAvailable().subtract(sourceAmount);
BigDecimal newTarget = targetAccountDO.getAvailable().add(targetAmount);
sourceAccountDO.setAvailable(newSource);
targetAccountDO.setAvailable(newTarget);

// 6. 更新到数据库
accountDAO.update(sourceAccountDO);
accountDAO.update(targetAccountDO);

// 7. 发送审计消息
String message = sourceUserId + "," + targetAccountNumber + "," + targetAmount + "," + targetCurrency;
kafkaTemplate.send(TOPIC_AUDIT_LOG, message);

return Result.success(true);
}
}


我们可以看到,一段业务代码里经常包含了参数校验、数据读取存储、业务计算、调用外部服务、发送消息等多种逻辑。

在这个案例里虽然是写在了同一个方法里,在真实代码中经常会被拆分成多个子方法,但实际效果是一样的,而在我们日常的工作中,绝大部分代码都或多或少的接近于此类结构。


那么优雅的代码应该是什么样的?


public class TransferServiceImplNew implements TransferService {

// 可以看出来,经过重构后的代码有以下几个特征:
// 业务逻辑清晰,数据存储和业务逻辑完全分隔。
// Entity、Domain Primitive、Domain Service都是独立的对象,没有任何外部依赖,
// 但是却包含了所有核心业务逻辑,可以单独完整测试。
// 原有的TransferService不再包括任何计算逻辑,仅仅作为组件编排,
// 所有逻辑均delegate到其他组件。这种仅包含Orchestration(编排)的服务叫做Application Service(应用服务)。
// 我们可以根据新的结构重新画一张图:

private AccountRepository accountRepository;
private AuditMessageProducer auditMessageProducer;
private ExchangeRateService exchangeRateService;
private AccountTransferService accountTransferService;

@Override
public Result<Boolean> transfer(Long sourceUserId, String targetAccountNumber, BigDecimal targetAmount, String targetCurrency) {
// 参数校验
Money targetMoney = new Money(targetAmount, new Currency(targetCurrency));

// 读数据
Account sourceAccount = accountRepository.find(new UserId(sourceUserId));
Account targetAccount = accountRepository.find(new AccountNumber(targetAccountNumber));

// 获取汇率
ExchangeRate exchangeRate = exchangeRateService.getExchangeRate(
sourceAccount.getCurrency(), targetMoney.getCurrency()
);

// 业务逻辑
accountTransferService.transfer(sourceAccount, targetAccount, targetMoney, exchangeRate);

// 保存数据
accountRepository.save(sourceAccount);
accountRepository.save(targetAccount);

// 发送审计消息
AuditMessage message = new AuditMessage(sourceAccount, targetAccount, targetMoney);
auditMessageProducer.send(message);

return Result.success(true);
}
}

虽然功能都一样,但是在面试的时候写了上面的代码能得到了面试官的赞扬,而如果写成了上面的样子,估计不会有这种效果。



最近无意间获得一份阿里大佬写的刷题笔记,一下子打通了我的任督二脉,进大厂原来没那么难。这是大佬写的,[7701页的BAT大佬写的刷题笔记,让我offer拿到手软]



二、提升代码质量


如果说优雅的代码是我们程序员的里子,那代码质量就是我们的面子。


想象一下,如果你写的代码,提测后测试出来各种bug,上线后也出现bug,就算你代码写的再优雅也没用了。


如何提升代码质量


想提升代码质量,最理想的是靠 code review,但是实际上这玩意在大多数公司根本就推行不下去。



为什么呢?因为大家都很忙,忙着改上一个迭代的bug,忙着写下一个迭代的需求,忙着做各种性能优化,忙着做各种日报、周报、月报等等...



所以靠人不如靠己,我们在日常工作中要善于利用工具,来帮我们发现问题,解决问题。


例如以下实践方法:



  1. 自动化测试:编写单元测试、集成测试,确保代码功能的正确性和稳定性。使用JUnit、Mockito等工具进行测试驱动开发(TDD)。

  2. 持续集成(CI):通过Jenkins、GitHub Actions等工具,自动化构建和测试流程,及时发现并解决问题。

  3. 静态代码分析:使用工具如SonarQube,对代码进行静态分析,检测代码中的潜在问题和代码风格违规。

  4. 合理利用大模型,对我们的代码进行分析,发现bug。


三、关注业务



看到这里有的人不禁要问,我一个后端开发,写好代码就行了,还需要关注业务吗?



如果你有这样的想法,那就大错特错了。


中国的企业,90%的开发都是面向业务开发,纯做研究的公司少之又少。所以你想要在互联网行业走的更高,那就一定不能脱离业务。


而且只有深刻理解业务了,才能对系统有一个整体的规划意识,才能设计出一个好的系统。


实践方法



  1. 多与业务团队沟通:定期与产品经理、业务分析师沟通,了解业务流程和需求变化。

  2. 参与需求讨论:积极参与需求评审和讨论,提出技术上的可行性建议和优化方案。

  3. 业务文档学习:阅读业务相关的文档和资料,全面了解系统的功能和使用场景。

  4. 业务架构梳理:梳理公司整体系统业务领域架构图,先从整体对公司业务有一个清晰的概念


实践建议



  1. 业务流程图:绘制业务流程图,帮助理解各个业务环节之间的关系和数据流动。

  2. 用户故事:通过用户故事的方式,站在用户角度思考功能设计,提高系统的用户体验。

  3. 持续学习:随着业务的发展,持续学习和更新业务知识,确保技术方案与业务需求保持一致。



四、培养架构思维


5年以上的程序员,就一定要培养自己的架构思维了,也就是要把自己的技术视角由自己的点扩展到线,再扩展到面。

从而对公司整体系统技术架构有一个整体的认知。


例如到一个公司之后,你一定要具有自我绘制如下技术架构图的能力。



架构思维的重要性


良好的架构设计是系统稳定、高效运行的基础。

培养架构思维,能够帮助你在项目初期做出合理的技术选型和系统设计,提升系统的可扩展性和维护性。


实践方法



  1. 学习架构设计原则:如单一职责原则(SRP)、开闭原则(OCP)、依赖倒置原则(DIP)等,指导架构设计。

  2. 分层架构:采用DDD领域分层架构,如适配层、应用层和领域层、防腐层,明确各层的职责,降低耦合度。

  3. 模块化设计:将系统拆分为独立的领域模块或微服务,提升系统的可维护性和可扩展性。



最近无意间获得一份阿里大佬写的刷题笔记,一下子打通了我的任督二脉,进大厂原来没那么难。这是大佬写的,[7701页的BAT大佬写的刷题笔记,让我offer拿到手软]



五、关注源码


源码学习的价值


其实学习源码最市侩的价值那就是面试会问了,比如说 HashMap 的一些经典问题:



1、加载因子为什么是 0.75?

2、为什么链表改为红黑树的阈值是 8?

3、HashMap的底层数据结构是什么?

4、解决hash冲突的办法有哪些?

5、HashMap数组的长度为什么是 2 的幂次方?

6、HashMap 的扩容方式?



这些问题只有通过源码才能得出比较准确的回答。


但是我个人认为阅读源码对我们最大的价值其实是我们可以学习借鉴源码设计中的优秀思想。



想象一下,我们每天做着CURD的996工作,根本没有机会接触优秀的项目设计思想。而阅读源码是我们最容易接触到优秀项目设计核心思想的机会。



其次阅读源码也可以在系统出现棘手的问题时候,可以快速定位解决。大大提升自己在职场中的核心竞争力。



有个同学说过一句话,给我的印象特别深刻,就是“有啥解决不了的?只要你肯阅读源码。”



六、项目管理能力


实现一个软件系统的过程,不仅只有编码,还涉及到项目安排,团队协调等一系列非技术因素,如果想从一名程序员走向管理岗,成为 team leader 或者开发经理,软件工程方面的知识就必须得跟得上。


要想写出一个好而美的程序,需要经过三个阶段。


第一阶段:有扎实的基本功,简单点说,就是要做到语法熟练、框架熟练,成为一名能够完成开发任务的“码农”。


第二阶段:从“码农”到“工程师”,在局部上,不仅要能够实现功能,还能关注功能之外的维度,比如健壮性、低耦合、可扩展等指标。


第三阶段:从“工程师”到“架构师”,不仅在局部上追求一个模块的好坏,而且还要从整个系统层面去掌控,合理安排资源的优先级,保证整个系统不会出现腐败等等。


所以要想成为一名优秀的架构师,项目管理能力是必不可少的。


比如项目范围管理、质量管理、资源/成本管理、风险管理等一系列管理能力。有兴趣的同学可以学习PMP,提升一下自己的项目管理能力。


传统预测项目管理



敏捷开发项目管理



说在最后


学习的过程,就好像登山一样,大概有 80% 的人在这个过程中会掉队。要想成为一名优秀的架构师,除了自身的努力,也需要一点点运气。


那么请相信我,只要目标明确,努力加上坚持,再加上一点点好运气,你就能登顶!


免费看 500 套技术教程的网站,希望对你有帮助


程序员快看-教程,程序员编程资料站 | CXYKK.COM


*最近无意间获得一份阿里大佬写的刷题笔记,一下子打通了我的任督二脉,进大厂原来没那么难。这是大佬写的, *[7701页的BAT大佬写的刷题笔记,让我offer拿到手软]


求一键三连:点赞、分享、收藏


我的技术网站:cxykk.com 里面有,500套技术系列教程、1万+道,面试八股文、BAT面试真题、简历模版,工作经验分享、架构师成长之路,全部免费,欢迎收藏和转发。


作者:江小北
来源:juejin.cn/post/7418061055228215322
收起阅读 »

买了个mini主机当服务器

虽然有苹果的电脑,但是在安装一些软件的时候,总想着能不能有一个小型的服务器,免得各种设置导致 Mac 出现异常。整体上看了一些小型主机,也看过苹果的 Mac mini,但是发现它太贵了,大概要 3000 多,特别是如果要更高配置的话,价格会更高,甚至更贵。所以...
继续阅读 »

虽然有苹果的电脑,但是在安装一些软件的时候,总想着能不能有一个小型的服务器,免得各种设置导致 Mac 出现异常。整体上看了一些小型主机,也看过苹果的 Mac mini,但是发现它太贵了,大概要 3000 多,特别是如果要更高配置的话,价格会更高,甚至更贵。所以,我就考虑一些别的小型主机。也看了一些像 NUC 这些服务器,但是觉得还是太贵了。于是我自己去淘宝搜索,找到了这一款 N100 版的主机。


成本的话,由于有折扣,所以大概是 410 左右,然后自己加了个看上去不错的内存条花了 300 左右。硬盘的话我自己之前就有,所以总成本大概是 700 左右。大小的话,大概是一台手机横着和竖着的正方形大小,还带 Wi-Fi,虽然不太稳定。


iowejofwjeofjwoeifjwoe


一、系统的安装


系统我看是支持windows,还有现在Ubuntu,但是我这种选择的是centos stream 9, 10的话我也找过,但是发现很多软件还有不兼容。所以最终还是centos stream 9。


1、下载Ventoy软件


去Ventoy官网下载Ventoy软件(Download . Ventoy)如下图界面


QQ_1727625608185


2、制作启动盘


选择合适的版本以及平台下载好之后,进行解压,解压出来之后进入文件夹,如下图左边所示,双击打开Ventoy2Disk.exe,会出现下图右边的界面,选择好自己需要制作启动盘的U盘,然后点击安装等待安装成功即可顺利制作成功启动U盘。


3、centos安装


直接取官网,下载完放到u盘即可。


QQ_1727625711792


它的BIOS是按F7启动,直接加载即可。


image-20241007222938414


之后就是正常的centos安装流程了。


二、连接wifi


因为是用作服务器的,所以并没有给它配置个专门的显示器,只要换个网络,就连不上新的wifi了,这里可以用网线连接路由器进行下面的操作即可。


在 CentOS 系统中,通过命令行连接 Wi-Fi 通常需要使用 nmcli(NetworkManager 命令行工具)来管理网络连接。nmcli 是 NetworkManager 的一个命令行接口,可以用于创建、修改、激活和停用网络连接。以下是如何使用 nmcli 命令行工具连接 Wi-Fi 的详细步骤。


步骤 1: 检查网络接口


首先,确认你的 Wi-Fi 网络接口是否被检测到,并且 NetworkManager 是否正在运行。


nmcli device status

输出示例:


DEVICE         TYPE      STATE         CONNECTION
wlp3s0 wifi disconnected --
enp0s25 ethernet connected Wired connection 1
lo loopback unmanaged --

在这个示例中,wlp3s0 是 Wi-Fi 接口,它当前处于未连接状态。


步骤 2: 启用 Wi-Fi 网卡


如果你的 Wi-Fi 网卡是禁用状态,可以通过以下命令启用:


nmcli radio wifi on

验证 Wi-Fi 是否已启用:


nmcli radio

步骤 3: 扫描可用的 Wi-Fi 网络


使用 nmcli 扫描附近的 Wi-Fi 网络:


nmcli device wifi list

你将看到可用的 Wi-Fi 网络列表,每个网络都会显示 SSID(网络名称)、安全类型等信息。


步骤 4: 连接到 Wi-Fi 网络


使用 nmcli 命令连接到指定的 Wi-Fi 网络。例如,如果你的 Wi-Fi 网络名称(SSID)是 MyWiFiNetwork,并且密码是 password123,你可以使用以下命令连接:


nmcli device wifi connect 'xxxxxx' password 'xxxxx'

你应该会看到类似于以下输出,表明连接成功:


Device 'wlp3s0' successfully activated with 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'.

步骤 5: 验证连接状态


验证网络连接状态:


nmcli connection show

查看当前连接的详细信息:


nmcli device show wlp3s0

三、VNC远程连接


桌面还是偶尔需要用一下的,虽然用的不多。


root@master:~# dnf install  -y  tigervnc-server
root@master:~# vncserver
bash: vncserver: command not found...
Install package 'tigervnc-server' to provide command 'vncserver'? [N/y] y


* Waiting in queue...
* Loading list of packages....
The following packages have to be installed:
dbus-x11-1:1.12.20-8.el9.x86_64 X11-requiring add-ons for D-BUS
tigervnc-license-1.14.0-3.el9.noarch License of TigerVNC suite
tigervnc-selinux-1.14.0-3.el9.noarch SELinux module for TigerVNC
tigervnc-server-1.14.0-3.el9.x86_64 A TigerVNC server
tigervnc-server-minimal-1.14.0-3.el9.x86_64 A minimal installation of TigerVNC server
Proceed with changes? [N/y] y


* Waiting in queue...
* Waiting for authentication...
* Waiting in queue...
* Downloading packages...
* Requesting data...
* Testing changes...
* Installing packages...

WARNING: vncserver has been replaced by a systemd unit and is now considered deprecated and removed in upstream.
Please read /usr/share/doc/tigervnc/HOWTO.md for more information.

You will require a password to access your desktops.

getpassword error: Inappropriate ioctl for device
Password:

之后在mac开启屏幕共享就可以了


image-20241007225855305


QQ_1728313164289


四、docker 配置


docker安装我以为很简单,没想到这里是最难的一步了。安装完docker之后,总是报错:


Error response from daemon: Get "https://registry-1.docker.io/v2/": context deadline exceeded

即使改了mirrors也毫无作用


{
"registry-mirrors": [
"https://ylce84v9.mirror.aliyuncs.com"
]
}

看起来好像是docker每次pull镜像都要访问一次registry-1.docker.io,但是这个网址国内已经无法连接了,各种折腾,这里只贴一下代码吧,原理就就不讲了(懂得都懂)。


img


sslocal -c /etc/猫代理.json -d start
curl --socks5 127.0.0.1:1080 http://httpbin.org/ip

sudo yum -y install privoxy

vim /etc/systemd/system/docker.service.d/http-proxy.conf


[Service]
Environment="HTTP_PROXY=http://127.0.0.1:8118"

/etc/systemd/system/docker.service.d/https-proxy.conf


[Service]
Environment="HTTPS_PROXY=http://127.0.0.1:8118"

最后重启docker


systemctl start privoxy
systemctl enable privoxy
sudo systemctl daemon-reload
sudo systemctl restart docker

QQ_1729956484197


五、文件共享


sd卡好像读取不了,只能换个usb转换器


fdisk -l
mount /dev/sdb1 /mnt/usb/sd

在CentOS中设置文件共享,可以使用Samba服务。以下是配置Samba以共享文件的基本步骤:



  1. 安装Samba


sudo yum install samba samba-client samba-common


  1. 设置共享目录


    编辑Samba配置文件/etc/samba/smb.conf,在文件末尾添加以下内容:



[shared]
path = /path/to/shared/directory
writable = yes
browseable = yes
guest ok = yes


  1. 设置Samba密码


    为了允许访问,需要为用户设置一个Samba密码:



sudo smbpasswd -a your_username


  1. 重启Samba服务


sudo systemctl restart smb.service
sudo systemctl restart nmb.service


  1. 配置防火墙(如果已启用)


    允许Samba通过防火墙:



sudo firewall-cmd --permanent --zone=public --add-service=samba
sudo firewall-cmd --reload

现在,您应该能够从网络上的其他计算机通过SMB/CIFS访问共享。在Windows中,你可以使用\\centos-ip\shared,在Linux中,你可以使用smbclient //centos-ip/shared -U your_username


QQ_1730035390803


参考:


https://猫代理help.github.io/猫代理/linux.html


stackoverflow.com/questions/4…


作者:wwwzh
来源:juejin.cn/post/7430460789067055154
收起阅读 »

three 写一个溶解特效,初探 three 着色系统

web
背景溶解特效是一个在游戏里非常常见的特效,通常用来表示物体消失或者出现,它的原理也比较简单,这次就来实现一下这个效果,并且通过它来探究下 three.js 的着色器系统。原理使用一张噪波图,根据时间动态改变进度 progress,...
继续阅读 »

Fire.gif

背景

溶解特效是一个在游戏里非常常见的特效,通常用来表示物体消失或者出现,它的原理也比较简单,这次就来实现一下这个效果,并且通过它来探究下 three.js 的着色器系统。

原理

使用一张噪波图,根据时间动态改变进度 progress, 根据这个值与噪波图数值做比较,决定使用过渡色还是舍弃当前片元。

过渡色

为了使用过渡色,我们定义一个作用范围变量 edgeWidth 用来表示当前进度和 噪波数值(noiseValue) 之间的区域,这个区域填充 过渡色(edgeColor)

变化速度

progress 的变化通过变化速度(DissolveSpeed) 来控制。

类型

溶解可以分为 出现和消失 两种类型,两种类型可以互相转换,我们可以通过判断 progress 的边界来重新设置 progress 的增加量符号(加号变减号,减号变加号),并重新设置 progress 的值等于 0 || 1 来重新设置变化边界。

原理讲完了,接下来进入实践。

实践

先从最简单的 wavefront 格式说起,再拓展到其他更通用模型或者材质的用法。

波前 wavefront 格式

作为 3D 模型最早的格式之一,.obj 后缀的格式是由 wavefront 公司开发的,由于容易和其他常见类型的文件比如 gcc 编译的过程文件 .obj 混淆,将其表述为 wavefront 模型格式。

对于这个格式来说,几何数据和材质数据是分开加载的,你需要先加载 .obj 格式的文件,然后再去加载材质数据文件 .mtl。对于我们的示例来说是需要使用 ShaderMaterial 来自定义着色效果,因而我们直接加载对应的 材质贴图 做原理展示,就不使用 .mtl 的加载器了。

需要做的其实只有两步:

    1. 读取的模型后用 Geometry 和 ShaderMaterial 创建新的 Mesh 。
    1. ShaderMaterial 的 unifroms.progress 在 requestAnimationFrame 里做更新。

直接来看下着色器怎么写:

顶点着色器:

let vertexShader = /* glsl */`
varying vec2 vUv;
void main()
{
vUv = uv;
gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
}
`
;

主要是定义了 vUv 这个可传递变量,为了把内置的纹理坐标传递到 fragmentShader

片元着色器:

 let fragShader = /* glsl */`
uniform float progress;
uniform float edgeWidth;
uniform vec3 edgeColor;
uniform sampler2D mainTexture;
uniform sampler2D noiseTexture;
varying vec2 vUv;void main(void){

vec4 originalColor = texture2D(mainTexture, vUv);
float noiseValue = texture2D(noiseTexture, vUv).r;
vec4 finalColor = originalColor;

if(noiseValue > progress)
{
discard;
}

if(noiseValue + edgeWidth > progress){
finalColor = vec4(edgeColor, 1.0);
}

gl_FragColor = finalColor;

}
`
;

其中 originColor 是原始材质贴图,类型是 vec4noiseValue 是读取的噪波贴图取 r 通道的值,事实上,噪波图是灰度图,所以取 rgb 任意通道的都可以。然后对于 noiseValue ,随着 progress 逐渐增大,小于 progress 数值的噪波片元越来越少,模型出现。下面那句 + edgeWidth 则是把 edgeColor 填充到里面,原理是一样的。最后输出颜色。

这是出现的逻辑,如果是要消失呢?控制下边界条件就可以了:

function render() {
requestAnimationFrame(render);

controller.update();
// 出现
if (uniforms.progress.value < 0) {
uniforms.progress = 0;
stride = dissolveSpeed;
}
// 消失
if (uniforms.progress.value > 1) {
uniforms.progress = 1;
stride = -dissolveSpeed;
}
uniforms.progress.value += stride;

renderer.render(scene, camera);
}

效果立竿见影:

Spot.gif

再想一遍

写着色器和通用程序不大一样,单纯按上面这么讲可能不是很清晰,我们更深度地分析下,培养一下 rgb 思维。

已知出现和消失是互为逆过程,通过 CPU 端程序重新改变变化方向即可,我们按照一个状态,关注边界条件,分别从正向和逆向进行思考,给出两个版本分别的代码。

按照上面说的,我们关注,比如就 出现 的状态吧,边界条件是 阈值 和 噪波值 的比较结果。也就是 progress 和 noiseValue

用 Exclidraw 画下示意图:

Exclidraw_explain.png

考虑 出现 的情况,剩余的进度或者叫阈值(越来越小), 与当前片元噪声值比较大小,如果更大则舍弃掉表示还没出现的部分;与当前值往前剪掉的部分比较,如果更大则使用这个过渡色;其他情况是已经出现的部分,直接保留就可以了。

写成代码:

void main() {
...

float restProgress = 1.0 - dissolveProgress;
if(noiseValue < restProgress) {
discard;
}
if(noiseValue - edgeWidth < restProgress ) {
gl_FragColor = finalColor;
}

...
}

反向来思考,随着阈值增加,出现的图像越来多,往前减掉过渡值(edgeWidth), 这部分呈现过渡色;小于当前 noiseValue 的部分舍弃,是还没出现的部分。

写成代码:

void main() {
...
if(noiseValue > dissolveProgress)
{
discard;
}

if(noiseValue + edgeWidth > dissolveProgress){
gl_FragColor = vec4(edgeColor, 1.0);
}
...
}

这样,我们就用两种等价的方法实现了同一效果,后面的章节我们使用 glsl 函数把 条件判断 语句去掉。

这里其实叫 edgeWidth 有歧义,换成 edgeThickness 可能比较符合,如果这个值过大,就会超出变化范围出现异常,所以还是要把其限制在一个比较小的范围,这里为了调试先让它最大值等于 1

edgeWidth 值过大:

Over_Thickness.png

其他格式

我们拿更常用的其他格式来研究一下。通常 web 端会使用 gltf, fbx 等通用格式,我们这里拿 web 端最通用的 gltf 格式模型来说明,其他通用模型类型道理一样。

对于 gltf 格式来说,加载完模型就赋予了材质,可能的类型有 MeshStandardMaterial, MeshPhongMaterial, MeshBasicMaterial 等,我用封面的士兵模型,使用的是 MeshStandardMaterial 类型的材质,接下来看如何修改内置着色器而实现效果。

ShaderChunk 和 ShaderLib

来看下 three 的目录,较新版本的 three 把核心代码安排在 src 目录下,/examples/jsm 目录下则是以 插件addons的形式引入的额外功能,比如 GLTFLoader 之类比较通用的功能。而内部着色器的实现在 src/renderers/shaders 目录下:

Three-Shaders.png

我们直接打开 ShaderLib.js 文件找下模型使用的 MeshStandardMaterial 的定义:

Standard_Shader.png

可以看到是复用了 meshphysical 的着色器,这对着色器还在 MeshPhysicalMaterial 材质里被使用,通过材质类定义的 defines 字段来开启相应的计算,这样的做法使得 MeshStandardMaterial 作为 MeshPhysicalMaterial 的回退选项。到 ShaderChunk目录下打开 meshphysical.glsl.js 看下宏定义:

Macro_Define.png

OK,已经了解了材质定义和对应着色器的关系了,接下来就是如何把我们的逻辑加到相应着色器字符串里了。

onBeforeCompile

官方文档约等于没写,还是去看 examples 的代码吧,关键字 onBeforeCompile 搜索下:

OnBeforeCompile_Case.png

右下角点进去看代码:

OnBeforeCompile_Code.png

这下就明白了,顾名思义,这个函数可以在编译着色器程序之前允许我们插入自己的代码, 我们可以根据功能对相应模块进行覆写或者添加功能,我们不希望修改修改默认着色器的内容,直接把溶解效果加到最后,接下来看下怎么做。

调试

按照这个做法,非常依赖 javascript 的 replace 方法,我们需要小心操作,经过实验,把所有代码放到同一串里是没问题的,这里需要反复打印调试,如果有问题请使用双引号来使用原始字符串。

如果没有处理格式,直接塞进去不会对齐的,很好辨认:

Log_Shader.png

接下来直接移植代码:

Code_No_Linear_Convertion.png

看到注释的那句话了吗,如果注释掉,并把阈值开到最大覆盖全部范围,可以明显看到和设置的颜色不一样,原因是因为之前的 shader 代码处理结果是转化到线性输出显示的,我们在标准着色器最后处理,一样要做线性转化。这个线性转化的意思是 gamma 变换的逆变换, gamma 变换是由于人眼对于颜色的感知非线性,非线性的原因和视锥细胞,视杆细胞数量比例不一样有关,省略一万字,大家有兴趣自己去搜~

没有线性转换:

Result_No_Linear_Convertion.png

线性转换后颜色就正常了:

Result_Linear_Convertion.png

拓展

再换一种写法

之前我们用直接舍弃片元的方法来实现过渡,接下来我们使用更 shader 风格的写法来重写,因为这个效果显示和消失具有二值性(要么有颜色要么透明),可以用 step(x,y) 函数来写,这个函数比较 y > x 的结果,true 则返回 1,否则返回 0 , 正好可以来表达透明度。

看代码,只有 fragmentShader 不一样:

Use_GLSL_STEP.png

这里的想法是先控制是否显示颜色,找的边界就是 noiseValue - edgeWidth,然后再判断使用原来的像素或者过渡色,如果大于 noiseValue 使用原来的像素,否则使用过渡的颜色,然后 mix 函数这里的第三个变量刚好是 step 函数的结果,所以就可以切换这两颜色了。

哦对,记得设置这个 material.transparent = true; ,否则会使用默认的混合颜色白色:

No_Transparent.png

整活

昨天在沸点发了两张图,其实很简单,到这里把过渡色换成贴图采样就行了,比如这样:

Flower_Body.png

学会了吗?赶紧搬到项目里惊艳领导吧。

思考

  • 能否和环境做交互?

更新

代码: github.com/wwjll/three…

在线 Demo: wwjll.github.io/three-pract…

写文章不易,点赞收藏是最好的支持~


作者:网格体
来源:juejin.cn/post/7344958089429254182
收起阅读 »

别再手动拼接 SQL 了,MyBatis 动态 SQL 写法应有尽有,建议收藏!

1.Mybatis 动态 sql 是做什么的? Mybatis 动态 sql 可以让我们在 Xml 映射文件内,以标签的形式编写动态 sql,完成逻辑判断和动态拼接 sql 的功能。 2.Mybatis 的 9 种 动 态 sql 标 签有哪些? 3.动态 ...
继续阅读 »

1.Mybatis 动态 sql 是做什么的?


Mybatis 动态 sql 可以让我们在 Xml 映射文件内,以标签的形式编写动态 sql,完成逻辑判断和动态拼接 sql 的功能。


2.Mybatis 的 9 种 动 态 sql 标 签有哪些?


图片


3.动态 sql 的执行原理?


原理为:使用 OGNL 从 sql 参数对象中计算表达式的值,根据表达式的值动态拼接 sql,以此来完成动态 sql 的功能。


MyBatis标签


1.if标签:条件判断


MyBatis if 类似于 Java 中的 if 语句,是 MyBatis 中最常用的判断语句。使用 if 标签可以节省许多拼接 SQL 的工作,把精力集中在 XML 的维护上。


1)不使用动态sql


<select id="selectUserByUsernameAndSex"
        resultType="user" parameterType="com.ys.po.User">

    <!-- 这里和普通的sql 查询语句差不多,对于只有一个参数,后面的 #{id}表示占位符,里面          不一定要写id,
         写啥都可以,但是不要空着,如果有多个参数则必须写pojo类里面的属性 -->

    select * from user where username=#{username} and sex=#{sex}
</select>

if 语句使用方法简单,常常与 test 属性联合使用。语法如下:


<if test="判断条件">    SQL语句</if>

2)使用动态sql


上面的查询语句,我们可以发现,如果 #{username} 为空,那么查询结果也是空,如何解决这个问题呢?使用 if 来判断,可多个 if 语句同时使用。


以下语句表示为可以按照网站名称(name)或者网址(url)进行模糊查询。如果您不输入名称或网址,则返回所有的网站记录。但是,如果你传递了任意一个参数,它就会返回与给定参数相匹配的记录。


<select id="selectAllWebsite" resultMap="myResult">  
    select id,name,url from website 
    where 1=1    
   <if test="name != null">        
       AND name like #{name}   
   </if>    
   <if test="url!= null">        
       AND url like #{url}    
   </if>
</select>

2.where+if标签


where、if同时使用可以进行查询、模糊查询



注意,<if>失败后, <where> 关键字只会去掉库表字段赋值前面的and,不会去掉语句后面的and关键字,即注意,<where> 只会去掉<if> 语句中的最开始的and关键字。所以下面的形式是不可取的



<select id="findQuery" resultType="Student">
    <include refid="selectvp"/>
    <where>
        <if test="sacc != null">
            sacc like concat('%' #{sacc} '%')
        </if>
        <if test="sname != null">
            AND sname like concat('%' #{sname} '%')
        </if>
        <if test="sex != null">
            AND sex=#{sex}
        </if>
        <if test="phone != null">
            AND phone=#{phone}
        </if>
    </where>
</select>

这个“where”标签会知道如果它包含的标签中有返回值的话,它就插入一个‘where’。此外,如果标签返回的内容是以AND 或OR 开头的,则它会剔除掉。


3.set标签


set可以用来修改


<update id="upd">
    update student
    <set>
        <if test="sname != null">sname=#{sname},</if>
        <if test="spwd != null">spwd=#{spwd},</if>
        <if test="sex != null">sex=#{sex},</if>
        <if test="phone != null">phone=#{phone}</if>
    sid=#{sid}
    </set>
    where sid=#{sid}
</update>

4.choose(when,otherwise) 语句


有时候,我们不想用到所有的查询条件,只想选择其中的一个,查询条件有一个满足即可,使用 choose 标签可以解决此类问题,类似于 Java 的 switch 语句


<select id="selectUserByChoose" resultType="com.ys.po.User" parameterType="com.ys.po.User">
      select * from user
      <where>
          <choose>
              <when test="id !='' and id != null">
                  id=#{id}
              </when>
              <when test="username !='' and username != null">
                  and username=#{username}
              </when>
              <otherwise>
                  and sex=#{sex}
              </otherwise>
          </choose>
      </where>
  </select>

也就是说,这里我们有三个条件,id、username、sex,只能选择一个作为查询条件



  • 如果 id 不为空,那么查询语句为:select * from user where id=?

  • 如果 id 为空,那么看username 是否为空,如果不为空,那么语句为 select * from user where username=?;

  • 如果 username 为空,那么查询语句为 select * from user where sex=?


5.trim


trim标记是一个格式化的标记,可以完成set或者是where标记的功能


①、用 trim 改写上面第二点的 if+where 语句


<select id="selectUserByUsernameAndSex" resultType="user" parameterType="com.ys.po.User">
    select * from user
    <!-- <where>
        <if test="username != null">
           username=#{username}
        </if>
         
        <if test="username != null">
           and sex=#{sex}
        </if>
    </where>  -->
    <trim prefix="where" prefixOverrides="and | or">
        <if test="username != null">
           and username=#{username}
        </if>
        <if test="sex != null">
           and sex=#{sex}
        </if>
    </trim>
</select>


  • prefix:前缀

  • prefixoverride:去掉第一个and或者是or


②、用 trim 改写上面第三点的 if+set 语句


<!-- 根据 id 更新 user 表的数据 -->
<update id="updateUserById" parameterType="com.ys.po.User">
    update user u
        <!-- <set>
            <if test="username != null and username != ''">
                u.username = #{username},
            </if>
            <if test="sex != null and sex != ''">
                u.sex = #{sex}
            </if>
        </set> -->

        <trim prefix="set" suffixOverrides=",">
            <if test="username != null and username != ''">
                u.username = #{username},
            </if>
            <if test="sex != null and sex != ''">
                u.sex = #{sex},
            </if>
        </trim>
     
     where id=#{id}
</update>


  • suffix:后缀

  • suffixoverride:去掉最后一个逗号(也可以是其他的标记,就像是上面前缀中的and一样)


③、trim+if同时使用可以添加


<insert id="add">
    insert  int0 student
    <trim prefix="(" suffix=")" suffixOverrides=",">
        <if test="sname != null">sname,</if>
        <if test="spwd != null">spwd,</if>
        <if test="sex != null">sex,</if>
        <if test="phone != null">phone,</if>
    </trim>

    <trim prefix="values (" suffix=")"  suffixOverrides=",">
        <if test="sname != null">#{sname},</if>
        <if test="spwd != null">#{spwd},</if>
        <if test="sex != null">#{sex},</if>
        <if test="phone != null">#{phone}</if>
    </trim>

</insert>

6.MyBatis foreach标签


foreach是用来对集合的遍历,这个和Java中的功能很类似。通常处理SQL中的in语句。


foreach 元素的功能非常强大,它允许你指定一个集合,声明可以在元素体内使用的集合项(item)和索引(index)变量。它也允许你指定开头与结尾的字符串以及集合项迭代之间的分隔符。这个元素也不会错误地添加多余的分隔符


你可以将任何可迭代对象(如 List、Set 等)、Map 对象或者数组对象作为集合参数传递给 foreach。当使用可迭代对象或者数组时,index 是当前迭代的序号,item 的值是本次迭代获取到的元素。当使用 Map 对象(或者 Map.Entry 对象的集合)时,index 是键,item 是值


//批量查询
<select id="findAll" resultType="Student" parameterType="Integer">
    <include refid="selectvp"/> WHERE sid in
    <foreach item="ids" collection="array"  open="(" separator="," close=")">
        #{ids}
    </foreach>
</s
elect>
//批量删除
<delete id="del"  parameterType="Integer">
    delete  from  student  where  sid in
    <foreach item="ids" collection="array"  open="(" separator="," close=")">
        #{ids}
    </foreach>
</d
elete>

整合案例

xml


<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.yzx.mapper.StuMapper">
    <sql id="selectvp">
        select  *  from  student
    </sql>
    
    <select id="find" resultType="Student">
        <include refid="selectvp"/>
    </select>

    <select id="findbyid"  resultType="student">
        <include refid="selectvp"/>
        WHERE 1=1
        <if test="sid != null">
            AND sid like #{sid}
        </if>
    </select>

        <select id="findQuery" resultType="Student">
            <include refid="selectvp"/>
            <where>
                <if test="sacc != null">
                    sacc like concat('%' #{sacc} '%')
                </if>
                <if test="sname != null">
                    AND sname like concat('%' #{sname} '%')
                </if>
                <if test="sex != null">
                    AND sex=#{sex}
                </if>
                <if test="phone != null">
                    AND phone=#{phone}
                </if>
            </where>
        </select>

    <update id="upd">
        update student
        <set>
            <if test="sname != null">sname=#{sname},</if>
            <if test="spwd != null">spwd=#{spwd},</if>
            <if test="sex != null">sex=#{sex},</if>
            <if test="phone != null">phone=#{phone}</if>
        sid=#{sid}
        </set>
        where sid=#{sid}
    </update>

    <insert id="add">
        insert  int0 student
        <trim prefix="(" suffix=")" suffixOverrides=",">
            <if test="sname != null">sname,</if>
            <if test="spwd != null">spwd,</if>
            <if test="sex != null">sex,</if>
            <if test="phone != null">phone,</if>
        </trim>

        <trim prefix="values (" suffix=")"  suffixOverrides=",">
            <if test="sname != null">#{sname},</if>
            <if test="spwd != null">#{spwd},</if>
            <if test="sex != null">#{sex},</if>
            <if test="phone != null">#{phone}</if>
        </trim>

    </insert>
    <select id="findAll" resultType="Student" parameterType="Integer">
        <include refid="selectvp"/> WHERE sid in
        <foreach item="ids" collection="array"  open="(" separator="," close=")">
            #{ids}
        </foreach>
    </select>

    <delete id="del"  parameterType="Integer">
        delete  from  student  where  sid in
        <foreach item="ids" collection="array"  open="(" separator="," close=")">
            #{ids}
        </foreach>
    </delete>



</mapper>

测试类:


package com.yzx.test;

import com.yzx.entity.Student;
import com.yzx.mapper.StuMapper;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class StuTest {
    SqlSession sqlSession=null;
    InputStream is=null;

    @Before
    public   void  before() throws IOException {
        //1.读取核心配置文件
        is= Resources.getResourceAsStream("sqlMapperConfig.xml");
        //2.拿到工厂构建类
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder=new SqlSessionFactoryBuilder();
        //3.拿到具体工厂
        SqlSessionFactory build=sqlSessionFactoryBuilder.build(is);
        //4.拿到session
        sqlSession = build.openSession();
    }

    @After
    public  void  after(){
        //7,提交事务
        sqlSession.commit();
        //8.关闭资源
        sqlSession.close();
        if(is!=null){
            try {
                is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        };
    }

    //查询所有
    @Test
    public  void  find(){
        //5.获取具体的mapper接口
        StuMapper mapper=sqlSession.getMapper(StuMapper.class);
        //6.调用执行
        List<Student> list=mapper.find();
        list.forEach(a-> System.out.println(a));
    }
    //查询单个
    @Test
    public  void  findbyid(){

        StuMapper mapper=sqlSession.getMapper(StuMapper.class);
        List<Student> list=mapper.findbyid(2);
        list.forEach(a-> System.out.println(a));
    }
    //模糊查询
    @Test
    public  void  findQuery(){

        StuMapper mapper=sqlSession.getMapper(StuMapper.class);

        Student  stu=new Student();
        stu.setSname("小");
        stu.setSex("男");
        List<Student> list=mapper.findQuery(stu);
        list.forEach(a-> System.out.println(a));
    }
    //修改
    @Test
    public  void  upd(){

        StuMapper mapper=sqlSession.getMapper(StuMapper.class);

        Student  stu=new Student();
        stu.setSid(3);
        stu.setSname("小若");
        stu.setSex("人妖");
        int i=mapper.upd(stu);
        System.out.println("修改了"+i+"条数据"+"  "+stu.toString());

    }
    //添加
    @Test
    public  void  add(){

        StuMapper mapper=sqlSession.getMapper(StuMapper.class);

        Student  stu=new Student();
        stu.setSname("小贺");
        stu.setSex("男");
        stu.setPhone("99999999");
        int i=mapper.add(stu);
        System.out.println("添加了"+i+"条数据"+"  "+stu.toString());

    }

    //批量操作
    @Test
    public  void  findAll(){

        StuMapper mapper=sqlSession.getMapper(StuMapper.class);
        Integer[] i={1,2,3,4};
        List<Student> list=mapper.findAll(i);
        list.forEach(a-> System.out.println(a));
    }
    //批量操作

    //批量删除
    @Test
    public  void  del(){
        StuMapper mapper=sqlSession.getMapper(StuMapper.class);
        Integer[] i={1,2,3,4};
        int i1=mapper.del(i);
        System.out.println("删除了"+i1+"条数据");
    }
}

7.sql


在实际开发中会遇到许多相同的SQL,比如根据某个条件筛选,这个筛选很多地方都能用到,我们可以将其抽取出来成为一个公用的部分,这样修改也方便,一旦出现了错误,只需要改这一处便能处处生效了,此时就用到了<sql>这个标签了。


当多种类型的查询语句的查询字段或者查询条件相同时,可以将其定义为常量,方便调用。为求<select>结构清晰也可将 sql 语句分解。


<sql id="selectvp">
    select  *  from  student
</sql>

8.include


这个标签和<sql>是天仙配,是共生的,include用于引用sql标签定义的常量。比如引用上面sql标签定义的常量


refid这个属性就是指定<sql>标签中的id值(唯一标识)


<select id="findbyid"  resultType="student">
    <include refid="selectvp"/>
    WHERE 1=1
    <if test="sid != null">
        AND sid like #{sid}
    </if>
</select>

9.如何引用其他XML中的SQL片段


比如你在com.xxx.dao.xxMapper这个Mapper的XML中定义了一个SQL片段如下:


<sql id="Base_Column_List"> ID,MAJOR,BIRTHDAY,AGE,NAME,HOBBY</sql>

此时我在com.xxx.dao.PatinetMapper中的XML文件中需要引用,如下:


<include refid="com.xxx.dao.xxMapper.Base_Column_List"></include>

MyBatis关联查询


1.MyBatis一对多关联查询


<!--一对多-->
<resultMap id="myStudent1" type="student1">
    <id property="sid" column="sid"/>
    <result property="sname" column="sname"/>
    <result property="sex" column="sex"/>
    <result property="sage" column="sage"/>
    <collection property="list" ofType="teacher">
        <id property="tid" column="tid"/>
        <result property="tname" column="tname"/>
        <result property="tage" column="tage"/>
    </collection>
</resultMap>

<!--一对多-->
<select id="find1" resultMap="myStudent1">
    select  *  from  student1  s  left  join  teacher  t  on s.sid=t.sid
</select>

2.MyBatis多对一关联查询


<!--多对一-->
<resultMap id="myTeacher" type="teacher">
    <id property="tid" column="tid"/>
    <result property="tname" column="tname"/>
    <result property="tage" column="tage"/>
    <association property="student1" javaType="Student1">
        <id property="sid" column="sid"/>
        <result property="sname" column="sname"/>
        <result property="sex" column="sex"/>
        <result property="sage" column="sage"/>
    </association>
</resultMap>


<!--多对一-->
<select id="find2" resultMap="myTeacher">
select  *  from  teacher  t right join student1 s on  t.sid=s.sid
</select>

3.MyBatis多对多关联查询


<!--多对多 以谁为主表查询的时候,主表约等于1的一方,另一方相当于多的一方-->
<select id="find3" resultMap="myStudent1">
    select  *  from  student1 s  left join relevance r on  s.sid=r.sid  left join teacher t on  r.tid=t.tid
</select>

最后说一句(求关注!别白嫖!)


如果这篇文章对您有所帮助,或者有所启发的话,求一键三连:点赞、转发、在看。


关注公众号:woniuxgg,在公众号中回复:笔记  就可以获得蜗牛为你精心准备的java实战语雀笔记,回复面试、开发手册、有超赞的粉丝福利!


作者:程序员蜗牛
来源:juejin.cn/post/7382394009199034387
收起阅读 »

手把手使用Blender+ThreeJS制作跨栏小游戏

web
效果展示 先录制的视频,再转化为GIF图片导致展示效果有点延迟,实际效果还是挺丝滑的,感兴趣的可以上手尝试一下 人物模型和动画获取 在mixamo.com网站,需要先登录一下,可以直接使用Google邮箱登录,然后来到Characters页,下方有10...
继续阅读 »

效果展示



  • 先录制的视频,再转化为GIF图片导致展示效果有点延迟,实际效果还是挺丝滑的,感兴趣的可以上手尝试一下
    demo.gif


人物模型和动画获取



  • mixamo.com网站,需要先登录一下,可以直接使用Google邮箱登录,然后来到Characters页,下方有100多种人物模型,点击左边卡片可以选择自己喜欢的人物模型,或者如下图和我选的一样
    image.png

  • 然后来到Animations页,默认如下图红框内展示的也是刚才我们选择的人物模型,如果右侧展示不对,需要回到Characters页重新选择人物模型
    image.png

  • 因为动画比较多,这里我们直接在左上角搜索框内搜索自己想要的动作动画即可,首先搜索Idle,我这里使用的动画是Happy Idle,还将右侧的Overdrive的值从50调整到75,值越大动画频率越快,调整好后直接点击右上方的DOWNLOAD
    image.png

  • 弹出的弹窗里的内容都不想要修改,直接点击如下图右下角的DOWNLOAD,等待一会后,选择本地文件夹下载即可
    image.png

  • 接着左上角搜索Running,选择Running卡片,并且勾选右侧的In Place,让人物模型在原地跑动;如果不勾选的话,因为动画本身带有位移,会影响我们使用ThreeJS改变人物模型的position控制人物位移的;设置好后直接点击DOWNLOAD,同样弹出的弹窗不需要修改,直接点击弹窗右下角的DOWNLOAD下载即可
    image.png

  • 继续左上角搜索Jump,选择Jump卡片,并且勾选右侧的In Place,让人物模型在原地跑动;设置好后直接点击DOWNLOAD,同样弹出的弹窗不需要修改,直接点击弹窗右下角的DOWNLOAD下载即可
    image.png

  • 继续左上角搜索Death,选择Falling Back Death卡片,这个动画不需要其他调整,直接点击DOWNLOAD,同样弹出的弹窗不需要修改,直接点击弹窗右下角的DOWNLOAD下载即可
    image.png

  • 这样就下载好了Idle(待机动作)、Running(跑步动作)、Jump(跳跃动作)、Death(死亡动作)的一组动作,以上动作的都可以根据个人喜好调整;如果打开mixamo.com网站比较慢或者下载有问题的话,也可以直接使用我下载好的actions里的动画模型
    image.png


动画模型合并



  • 打开Blender新建文件选择常规,我使用的版本是3.6.14的,不同版本可能存在差异
    image.png

  • 在右上角场景集合内,鼠标左键拖拽框选默认已有的Camera、Cube和Light,然后右键选择删除或者英文输入法下按下x键快速删除;后续在Blender里的所有操作,均需将输入法切换到英文输入;如果对Blender不是特别熟悉,可以优先阅读我之前整理的Blender学习整理这篇文章
    image.png

  • 选择左上角菜单栏里文件-->导入-->FBX(.fbx),就会弹出导入设置弹窗
    image.png

  • 弹窗内只需选中之前下载好的Idle.fbx文件,然后直接点击右下角导入FBX即可
    image.png

  • 文件导入后,在右上角场景集合内,将动画下一级的目录鼠标双击重命名成idle
    image.png

  • 在中间布局窗口,将右上角的视图着色方式切换到材质预览,然后把观察点切换到-X方向,将下方窗口切换到非线性动画
    image.png

  • 点击动画右侧的按键,作用是下推动作块(将动作块作为新的片段下推到NLA堆栈顶部),有点类似展开下拉菜单的效果,实际作用是创建NLA轨道,然后将idle动作放到一个单独的通道中
    image.png

  • 取消勾选通道对结果是否有影响(切换通道是否启用)
    image.png

  • 导入Running.fbx,导入流程和上述一致,导入后在右上角场景集合内重命名动画下一级目录为running
    image.png

  • 同样点击动画右侧的按键,下推动作块
    image.png

  • 同样取消勾选通道对结果是否有影响(切换通道是否启用)
    image.png

  • 鼠标点击选中idle动作,变成如下图颜色即被选中
    image.png

  • 选择上方添加-->添加动作片段
    image.png

  • 然后选中running
    image.png

  • 这时,在idle动作上方就添加了一个running动作通道,双击左侧如下图红框内重命名为running,左侧的名称就是我们后续使用ThreeJS控制人物模型切换动画时要使用的动作变量名
    image.png

  • 在右上角场景集合内,选中后面导入的模型右键后点击删除或者按下x键快速删除,将其删除
    image.png

  • 第一次删除可能删除不干净,场景集合内还有多余的文件,布局窗口也有遮挡物,这个遮挡物其实就是第二个模型里的人物建模,第一次只是把动画给删除掉了,所以需要再次如下图选中右侧红框内文件继续删除才能删除干净;注意删除的时候最好把导入的第一个模型收起来,防止误删
    image.png

  • 如上述操作后,就把idle动画和running动画合并到一个人物模型里,再重复上述操作,把Jump.fbxDeath.fbx文件依次导入进来,并且把jump动画和death动画添加到idle动画上方,每个动作一个通道;全部搞定后,可以点击如下图红框内的五角星,实心就代表被选中,依次选中每个动作,取消勾选通道影响,还可以按下键盘的空格播放各个动画
    image.png

  • 最后选择左上角文件-->导出-->glTF2.0(.glb/.gltf),会弹出导出设置弹窗
    image.png

  • 弹窗内选择本地合适的文件夹,直接点击右下角的导出glTF2.0即可
    image.png

  • 可以参考我仓库里的models里的actions.glb
    image.png


跨栏和跑道模型获取



  • sketchfab.com网站,首先需要先登录,同样可以使用Google邮箱登录,然后在搜索框输入hurdle,按下回车
    image.png

  • 然后可以在下方很多的跨栏模型中选择自己喜欢的,我这里选择的是Wii - Wii Play - Hurdle
    image.png

  • 点击模型左下角的Download 3D Model,会弹出下载选项弹窗
    image.png

  • 弹窗里选择下载GLB格式的文件,这个格式会将所有内容(包含模型的结构、材质、动画和其他元数据等)打包在一起,文件大小可能会更大,但管理方便,所有内容都在一个文件中
    image.png

  • 下载到本地后,重命名为hurdle.glb
    image.png

  • 同样的方式,搜索track,我这边使用的模型是Dusty foot path way in grass garden,忘记了当时的筛选条件了,怎么就在搜索track的时候找到了这个模型;因为需要游戏里面的跑道不间断的出现,所以需要这种能够重复拼接的跑道模型,大家也可以自行选择喜欢的模型,下载好后,本地重命名为track.glb
    image.png

  • 如果访问sketchfab.com网站比较慢,或者下载有问题的话,可以直接使用我仓库里的models里的hurdle.glbtrack.glb
    image.png


模型合并



  • 为了和之前的内容不搅合,就不在之前的actions.blender文件里添加其他两个模型,这里使用Blender新建一个常规文件,同样删除默认的Camera、Cube和Light
    image.png

  • 选择左上角文件-->导入-->glTF2.0(.glb/.gltf),会弹出导入弹窗
    image.png

  • 选择之前保存的actions.glb,直接点击右下角的导入glTF2.0即可
    image.png

  • 导入后,同样把视图着色方式切换到材质预览,观察点切换到—X方向上
    image.png

  • 在右上角的场景集合内,将当前模型重命名为acitons
    image.png

  • 导入下载好的hurdle.glb,在右上角的场景集合内,刚导入的模型只有最里面的Object_2才是真的跨栏网格对象,外面两层结构没有作用,还可能出现外层结构的旋转缩放等属性和内部实际的网格对象的属性不一致,影响我们对实际网格对象的控制,所以最好删除掉
    image.png

  • 依次选中外面两层文件,按下x键删除,最后把Object_2重命名为hurdle
    image.png

  • hurdle模型尺寸比较大,旋转方向也不对,鼠标左键选中hurdle模型,然后在属性栏,将旋转的X调整成-1.0,将缩放的XYZ全部调整成0.1,这里不需要调整的特别精确,后续编码时还能使用ThreeJS继续调整模型的旋转和尺寸;如果布局窗口没有属性栏,可以按下n键显示/隐藏属性栏;输入值时,鼠标拖动三个输入框能够同时改变XYZ的值
    image.png

  • 继续选中hurdle模型,按下ctrl + a然后选择全部变换,需要把之前调整的旋转和缩放应用为自身数据
    image.png

  • 导入下载好的track.glb,可以切换右侧红框的眼睛图标显示/隐藏该对象来观察整体模型变化,会发现实际起作用的是Object_2Object_3的两个网格对象,两个外层结构的显示/隐藏看似对模型的显示没有影响,其实它们是有属性是对模型有影响的,需要把它们的属性变换应用到自身
    image.png

  • 在右上角场景集合选中第一层结构,在属性栏会发现它有一些旋转和缩放,在布局窗口按下ctrl+a,然后选择应用全部变换;再选中第二层结构,同样按下ctrl+a应用全部变换
    image.png

  • 这时就会发现,外层的旋转和缩放都已经作用到Object_2Object_3的两个网格对象上了,就可以依次选中两个外层结构,按下x键删除两个外层结构了;并且依次选中Object_2Object_3的两个网格对象按下ctrl+a选择全部变换把外层结构的旋转和缩放应用到自身
    image.png

  • 然后在右上角场景集合内,鼠标先选中Object_3,按下shift键再选中Object_2,然后鼠标回到布局窗口,按下ctrl+p选择物体,这里发现Object_2变成了Object_3的子级了,理论上最后被选中的对象是父级,我想要的效果是Object_3变成了Object_2的子级,所以这里我又撤销(ctrl+z)重新先选中Object_2,按下shift键再选中Object_3,再按下ctrl+p选择物体绑定的父子关系;这里不清楚是因为我使用中文翻译的问题还是Blender有更新,有了解的大佬希望帮忙解释一下
    image.png

  • 将合并后的父级Object_2重命名为track
    image.png

  • 左键选中track模型,右键选择设置原点-->原点->几何中心
    image.png

  • 在选中track模型的情况下,继续按下shift+s选择选中项->游标,如果游标没有在世界原点,需要先将游标设置到世界原点
    image.png

  • 将观察点切换到顶视图,按下r+z绕着Z轴旋转,使跑道的长边和Y轴平行
    image.png

  • 再切换到-X方向,按下r+x绕着X轴旋转,使跑道的上面和Y轴平行
    image.png

  • 选择左上角文件-->导出-->glTF2.0(.glb/.gltf)
    image.png

  • 导出设置弹窗内,直接将合并后的模型导出到我们后续编码要用的文件夹内,其他无需设置,直接选择导出glTF2.0即可
    image.png


编码渲染



  • 使用vite搭建的项目工程,完整源码点这里code,整个渲染过程都在src/hooks/userDraw.js文件里
    image.png

  • 首先是ThreeJS的基础代码,放到了src/hooks/modules/base.js文件里,我这里只是往scene添加了一个背景纹理,最后就是把scenecamerarenderer暴露出来方便其他模块引用


import * as THREE from 'three';

/**
* 基础代码
*/

export default function () {
const scene = new THREE.Scene();
const camera = new THREE.PerspectiveCamera(
75,
window.innerWidth / window.innerHeight,
0.1,
1000
);
camera.position.set(0, 0, 5); // 设置相机位置
const renderer = new THREE.WebGLRenderer({
antialias: true // 开启抗锯齿
});
renderer.setSize(window.innerWidth, window.innerHeight);
document.body.appendChild(renderer.domElement);

// 加载背景纹理
const textureLoader = new THREE.TextureLoader();
textureLoader.load('./bg.jpeg', function (texture) {
// 将纹理设置为场景背景
scene.background = texture;
});

// 适配窗口
window.addEventListener('resize', () => {
camera.aspect = window.innerWidth / window.innerHeight; // 重置摄像机视锥体的长宽比
camera.updateProjectionMatrix(); // 更新摄像机投影矩阵
renderer.setSize(window.innerWidth, window.innerHeight); // 重置画布大小
});

return {
scene,
camera,
renderer
};
}


  • src/hooks/modules/controls.js文件里添加控制器,并且需要禁用控制器


import { OrbitControls } from 'three/addons/controls/OrbitControls.js';

/**
* 控制器
*/

export default function (camera, renderer) {
const orbitControls = new OrbitControls(camera, renderer.domElement); // 轨道控制器
orbitControls.enabled = false; // 禁用控制器
orbitControls.update(); // 更新控制器
}


  • src/hooks/modules/light.js文件里添加环境光,上下方各添加了一个平行光


import * as THREE from 'three';

/**
* 灯光
*/

export default function (scene) {
const ambientLight = new THREE.AmbientLight(0x404040, 20); // 环境光
scene.add(ambientLight);
const directionalLight = new THREE.DirectionalLight(0xffffff, 5); // 平行光
directionalLight.position.set(0, 10, 5);
scene.add(directionalLight);
const directionalLight2 = new THREE.DirectionalLight(0xffffff, 5); // 平行光
directionalLight2.position.set(0, -10, -5);
scene.add(directionalLight2);
}


  • src/hooks/userDraw.js文件没有进一步优化,下面主要介绍几个核心部分

    • 把之前合并好的模型,使用GLTFLoader加载进来,然后初始化人物、跨栏、跑道等模型;因为模型的XYZ轴向和ThreeJS的没有对应上,所以需要给各个模型创建一个Gr0up方便单独控;获取跑道宽度时,因为获取的不是特别准确,所以又减去了2,让跑道叠加在一起了,不是特别严丝合缝;然后就是创建动画混合器,把动作保存起来了,然后默认播放待机动作;最后开始帧循环渲染


    // 加载人物模型
    const loader = new GLTFLoader();
    loader.load('./models/group.glb', function (gltf) {
    const children = [...gltf.scene.children];

    // 初始化人物模型
    global.characterGr0up.add(children[0]);
    global.characterGr0up.rotation.set(0, Math.PI / 2, 0); // 改变人物朝向
    scene.add(global.characterGr0up);

    // 初始化跨栏模型
    global.hurdleGr0up.add(children[1]);
    global.hurdleGr0up.scale.set(0.7, 0.7, 0.7); // 缩小跨栏
    global.hurdleGr0up.rotation.set(0, Math.PI / 2, 0); // 改变跨栏朝向
    global.hurdleGr0up.position.set(3, 0, 0); // 设置第一个跨栏位置
    global.hurdleArr.push(global.hurdleGr0up); // 添加第一个跨栏触发碰撞检测
    scene.add(global.hurdleGr0up);

    // 初始化跑道模型
    global.trackGr0up.add(children[2]);
    global.trackGr0up.rotation.set(0, Math.PI / 2, 0); // 改变跑道朝向
    scene.add(global.trackGr0up);

    // 获取跑道宽度
    const boundingBox = new THREE.Box3().setFromObject(global.trackGr0up); // 创建包围盒
    const size = new THREE.Vector3(); // 计算包围盒的尺寸
    boundingBox.getSize(size);
    global.trackWidth = size.x - 2; // 跑道宽度不是特别准确,需要模糊计算
    // 默认使用trackNum个跑道拼接
    for (let i = 0; i < trackNum; i++) {
    const newTrackModel = global.trackGr0up.clone(); // 克隆原始跑道模型
    newTrackModel.position.x = i * global.trackWidth; // 按照宽度依次排列
    scene.add(newTrackModel);
    global.trackArr.push(newTrackModel); // 保存引用
    }

    // 创建动画混合器
    global.animationMixer = new THREE.AnimationMixer(global.characterGr0up);

    // 将每个动画剪辑存储在actions对象中
    gltf.animations.forEach((clip) => {
    global.actions[clip.name] = global.animationMixer.clipAction(clip);
    });

    // 播放默认的 idle 动作
    global.currentAction = global.actions['idle'];
    global.currentAction.play();

    // 开始渲染循环
    animate();
    });


    • animate函数里主要功能有开启帧循环;更新动画混合器;在跳跃动作结束后切换回跑步动作;当人物处于跑步和跳跃动作时,更新人物位置及让相机跟随人物移动,并且在移动过程中,在间隔帧数内生成新的跨栏;更新跑道的位置,如果最左侧的跑道超出屏幕后,把它移动到最右侧;当人物处于跳跃动作时,更新人物Y轴位置;如果人物和跨栏发生碰撞时,切换到死亡动作并且开启死亡状态,防止键盘按键还能继续触发;当播放完死亡动作后,提示游戏结束,并结束帧数循环;渲染场景


    function animate() {
    global.frame = requestAnimationFrame(animate); // 开启帧循环

    global.animationMixer.update(global.clock.getDelta()); // 更新动画混合器

    // 检查 jump 动作是否完成,并恢复到 running 动作
    if (
    global.currentAction === global.actions['jump'] &&
    global.currentAction.time >= global.currentAction.getClip().duration
    ) {
    switchAction('running', 0.3);
    }

    // 当处于 running 动作时,移动相机
    if (
    global.currentAction === global.actions['running'] ||
    global.currentAction === global.actions['jump']
    ) {
    global.characterGr0up.position.x += moveSpeed;
    camera.position.x = global.characterGr0up.position.x;

    // 间隔随机帧数生成跨栏
    if (
    global.hurdleCountFrame++ >
    hurdleInterval + Math.random() * hurdleInterval
    ) {
    generateHurdles(global.hurdleGr0up, global.hurdleArr, scene); // 生成跨栏
    global.hurdleCountFrame = 0;
    }
    }

    // 更新跑道位置
    updateTrack(camera, global.trackArr, global.trackWidth);

    // 当人物处于跳跃动作时,更新人物位置
    updateCharacterPosition(
    global.animationMixer,
    global.clock,
    global.currentAction,
    global.actions,
    global.characterGr0up
    );

    // 碰撞检测
    if (
    checkCollisions(
    global.characterGr0up,
    global.characterBoundingBox,
    global.hurdlesBoundingBoxes,
    global.hurdleArr
    )
    ) {
    switchAction('death');
    global.isDeath = true;
    }

    // 如果 death 动作完成了,则停止帧动画
    if (
    global.currentAction === global.actions['death'] &&
    !global.currentAction.isRunning()
    ) {
    Modal.error({
    title: 'Game Over',
    width: 300
    });
    cancelAnimationFrame(global.frame);
    }

    // 渲染场景
    renderer.render(scene, camera);
    }


    • 切换动作函数主要是在一定时间内淡出前一个动作,并且淡入新动作,如果是跳跃动作或者死亡动作的话只执行一次


    function switchAction(newActionName, fadeDuration = 0.5) {
    const newAction = global.actions[newActionName];
    if (newAction && global.currentAction !== newAction) {
    global.previousAction = global.currentAction; // 保留当前的动作
    // 淡出前一个动作
    if (global.previousAction) {
    global.previousAction.fadeOut(fadeDuration);
    }

    // 如果切换到 jump 动作,设置播放一次并在结束后停止
    if (newActionName === 'jump') {
    newAction.loop = THREE.LoopOnce;
    newAction.clampWhenFinished = true; // 停止在最后一帧
    }

    // 如果切换到 death 动作,设置播放一次并在结束后停止
    if (newActionName === 'death') {
    newAction.loop = THREE.LoopOnce;
    newAction.clampWhenFinished = true; // 停止在最后一帧
    }
    global.currentAction = newAction; // 设置新的活动动作

    // 复位并淡入新动作
    global.currentAction.reset();
    global.currentAction.setEffectiveTimeScale(1);
    global.currentAction.setEffectiveWeight(1);
    global.currentAction.fadeIn(fadeDuration).play();
    }
    }


    • 键盘事件监听,给按键WSAD和方向键上下左右都添加了切换动作的功能,如果是死亡状态的,按键失效


    window.addEventListener('keydown', (event) => {
    if (global.isDeath) {
    return;
    }
    switch (event.code) {
    case 'keyD':
    case 'ArrowRight':
    switchAction('running');
    break;
    case 'keyA':
    case 'ArrowLeft':
    switchAction('idle');
    break;
    case 'keyW':
    case 'ArrowUp':
    switchAction('jump');
    break;
    }
    });


  • src/configs/index.js文件配置了一些常量,可以用来控制游戏状态


// 初始跑道数量
export const trackNum = 3;

// 跨栏之间的间隔帧数
export const hurdleInterval = 50; // 50~100帧之间

// 跨栏之间的间隔最小距离
export const hurdleMinDistance = 5; // 5~10距离之间

// 人物移动的速度
export const moveSpeed = 0.03;


  • src/utils/index.js文件主要是一些辅助函数


import * as THREE from 'three';
import { hurdleMinDistance } from '../configs/index';

/**
* 生成新的跨栏
*
* @param {Object} oldModel - 要克隆的原始跨栏模型。
* @param {Array} hurdleArr - 现有跨栏模型的数组。
* @param {Object} scene - 要添加新跨栏模型的场景。
* @return {undefined}
*/

export function generateHurdles(oldModel, hurdleArr, scene) {
const newModel = oldModel.clone(); // 克隆原始跨栏模型

const nextPosition =
hurdleArr[hurdleArr.length - 1].position.x +
hurdleMinDistance +
Math.random() * hurdleMinDistance;

newModel.position.set(nextPosition, 0, 0);
hurdleArr.push(newModel);
scene.add(newModel);
}

/**
* 更新跑道位置
*
* @param {Object} camera - 具有位置属性的摄像机对象。
* @param {Array} trackArr - 具有位置属性的轨道段对象数组。
* @param {Number} trackWidth - 每个轨道段的宽度。
* @return {undefined}
*/

export function updateTrack(camera, trackArr, trackWidth) {
const cameraPositionX = camera.position.x; // 相机的 x 坐标
// 遍历所有跑道段
for (let i = 0; i < trackArr.length; i++) {
const trackSegment = trackArr[i];
// 提前检测跑道段是否即将超出视野(增加一个提前量,比如半个跑道段的宽度)
const threshold = cameraPositionX - trackWidth * 1.5;
if (trackSegment.position.x < threshold) {
// 找到当前最右边的跑道段
let maxX = -Infinity;
for (let j = 0; j < trackArr.length; j++) {
if (trackArr[j].position.x > maxX) {
maxX = trackArr[j].position.x;
}
}
// 将当前跑道段移动到最右边
trackSegment.position.x = maxX + trackWidth;
}
}
}

/**
* 人物跳跃时,更新人物Y轴位置
*
* @param {Object} animationMixer - 动画混合器对象。
* @param {Object} clock - 用于获取增量时间的时钟对象。
* @param {Object} currentAction - 当前正在执行的动作。
* @param {Object} action - 可用动作的集合。
* @param {Object} characterGr0up - 角色组对象。
* @return {undefined}
*/

export function updateCharacterPosition(
animationMixer,
clock,
currentAction,
actions,
characterGr0up
) {
// 更新动画混合器
animationMixer.update(clock.getDelta());

// 检查动画状态并调整位置
if (currentAction === actions['jump']) {
// 根据跳跃动画的时间调整人物位置
const jumpHeight = 0.8; // 你可以调整这个值
characterGr0up.position.y =
Math.sin(currentAction.time * Math.PI) * jumpHeight;
} else {
characterGr0up.position.y = 0; // 恢复到地面位置
}
}

/**
* 检测人物是否与跨栏发生了碰撞
*
* @param {Object} characterGr0up - 角色组对象。
* @param {Object} characterBoundingBox - 角色的边界框对象。
* @param {Array} hurdlesBoundingBoxes - 跨栏的边界框数组。
* @param {Array} hurdleArr - 跨栏对象数组。
* @return {Boolean} 是否发生了碰撞。
*/

export function checkCollisions(
characterGr0up,
characterBoundingBox,
hurdlesBoundingBoxes,
hurdleArr
) {
// 更新人物的边界框
if (characterGr0up) {
characterBoundingBox.setFromObject(characterGr0up);
}

// 更新跨栏的边界框
hurdlesBoundingBoxes = hurdleArr.map((hurdle) => {
const box = new THREE.Box3();
box.setFromObject(hurdle);
return box;
});

for (let i = 0; i < hurdlesBoundingBoxes.length; i++) {
if (characterBoundingBox.intersectsBox(hurdlesBoundingBoxes[i])) {
return true; // 检测到碰撞
}
}
return false; // 没有检测到碰撞
}

不足



  • 跑道的纹理和材质没有渲染出来,不知道是否是导出的模型有问题,有懂的大佬可以帮忙看看

  • 目前合并后的模型导出后体积比较大,还需要解决模型压缩的问题


作者:LoveDreaMing
来源:juejin.cn/post/7405153695506022451
收起阅读 »

工作中用Redis最多的10种场景

前言 Redis作为一种优秀的基于key/value的缓存,有非常不错的性能和稳定性,无论是在工作中,还是面试中,都经常会出现。 今天这篇文章就跟大家一起聊聊,我在实际工作中使用Redis的10种场景,希望对你会有所帮助。 8000页BAT大佬写的刷题笔记,...
继续阅读 »

前言


Redis作为一种优秀的基于key/value的缓存,有非常不错的性能和稳定性,无论是在工作中,还是面试中,都经常会出现。


今天这篇文章就跟大家一起聊聊,我在实际工作中使用Redis的10种场景,希望对你会有所帮助。


图片


8000页BAT大佬写的刷题笔记,让我offer拿到手软


1. 统计访问次数


对于很多官方网站的首页,经常会有一些统计首页访问次数的需求。


访问次数只有一个字段,如果保存到数据库中,再最后做汇总显然有些麻烦。


该业务场景可以使用Redis,定义一个key,比如:OFFICIAL_INDEX_VISIT_COUNT。


在Redis中有incr命令,可以实现给value值加1操作:


incr OFFICIAL_INDEX_VISIT_COUNT

当然如果你想一次加的值大于1,可以用incrby命令,例如:


incrby OFFICIAL_INDEX_VISIT_COUNT 5

这样可以一次性加5。


2. 获取分类树


在很多网站都有分类树的功能,如果没有生成静态的html页面,想通过调用接口的方式获取分类树的数据。


我们一般为了性能考虑,会将分类树的json数据缓存到Redis当中,为了后面在网站当中能够快速获取数据。


不然在接口中需要使用递归查询数据库,然后拼接成分类树的数据结构。


这个过程非常麻烦,而且需要多次查询数据库,性能很差。


因此,可以考虑用一个定时任务,异步将分类树的数据,直接缓存到Redis当中,定义一个key,比如:MALL_CATEGORY_TREE。


然后接口中直接使用MALL_CATEGORY_TREE这个key从缓存中获取数据即可。


可以直接用key/value字符串保存数据。


不过需要注意的是,如果分类树的数据非常多可能会出现大key的问题,优化方案可以参考我的另外一篇文章《分类树,我从2s优化到0.1s》。


3. 做分布式锁


分布式锁可能是使用Redis最常见的场景之一,相对于其他的分布式锁,比如:数据库分布式锁或者Zookeeper分布式锁,基于Redis的分布式锁,有更好的性能,被广泛使用于实际工作中。


我们使用下面这段代码可以加锁:


try{
  String result = jedis.set(lockKey, requestId, "NX""PX", expireTime);
  if ("OK".equals(result)) {
      return true;
  }
  return false;
finally {
    unlock(lockKey);
}  

但上面这段代码在有些场景下,会有一些问题,释放锁可能会释放了别人的锁。


说实话Redis分布式锁虽说很常用,但坑也挺多的,如果用不好的话,很容易踩坑。


如果大家对Redis分布式锁的一些坑比较感兴趣,可以看看我的另一篇文章《聊聊redis分布式锁的8大坑》,文章中有非常详细的介绍。


4. 做排行榜


很多网站有排行榜的功能,比如:商城中有商品销量的排行榜,游戏网站有玩家获得积分的排行榜。


通常情况下,我们可以使用Sorted Set保存排行榜的数据。


使用ZADD可以添加排行榜的数据,使用ZRANGE可以获取排行榜的数据。


例如:


ZADD rank:score 100 "周星驰"
ZADD rank:score 90 "周杰伦"
ZADD rank:score 80 "周润发"
ZRANGE rank:score 0 -1 WITHSCORES

返回数据:


1"周星驰"
2"100"
3"周杰伦"
4"90"
5"周润发"
6"80"

5. 记录用户登录状态


通常下,用户登录成功之后,用户登录之后的状态信息,会保存到Redis中。


这样后面该用户访问其他接口的时候,会直接从Redis中查询用户登录状态,如果可以查到数据,说明用户已登录,则允许做后续的操作。


如果从Redis中没有查到用户登录状态,说明该用户没有登录,或者登录状态失效了,则直接跳转到用户登录页面。


使用Redis保存用户登录状态,有个好处是它可以设置一个过期时间,比如:该时间可以设置成30分钟。


jedis.set(userId, userInfo, 1800);

在Redis内部有专门的job,会将过期的数据删除,也有获取数据时实时删除的逻辑。


6. 限流


使用Redis还有一个非常常用的的业务场景是做限流


当然还有其他的限流方式,比如:使用nginx,但使用Redis控制可以更精细。


比如:限制同一个ip,1分钟之内只能访问10次接口,10分钟之内只能访问50次接口,1天之内只能访问100次接口。


如果超过次数,则接口直接返回:请求太频繁了,请稍后重试。


跟上面保存用户登录状态类似,需要在Redis中保存用户的请求记录。


比如:key是用户ip,value是访问的次数从1开始,后面每访问一次则加1。


如果value超过一定的次数,则直接拦截这种异常的ip。


当然也需要设置一个过期时间,异常ip如果超过这个过期时间,比如:1天,则恢复正常了,该ip可以再发起请求了。


或者限制同一个用户id。


7. 位统计


比如现在有个需求:有个网站需要统计一周内连续登陆的用户,以及一个月内登陆过的用户。


这个需求使用传统的数据库,实现起来比较麻烦,但使用Redis的bitmap让我们可以实时的进行类似的统计。


bitmap 是二进制的byte数组,也可以简单理解成是一个普通字符串。它将二进制数据存储在byte数组中以达到存储数据的目的。


保存数据命令使用setbit,语法:


setbit key offset value

具体示例:


setbit user:view:2024-01-17 123456 1

往bitmap数组中设置了用户id=123456的登录状态为1,标记2024-01-17已登录。


然后通过命令getbit获取数据,语法:


getbit key offset

具体示例:


getbit user:view:2024-01-17 123456

如果获取的值是1,说明这一天登录了。


如果我们想统计一周内连续登录的用户,只需要遍历用户id,根据日期中数组中去查询状态即可。


最近就业形式比较困难,为了感谢各位小伙伴对苏三一直以来的支持,我特地创建了一些工作内推群, 看看能不能帮助到大家。


你可以在群里发布招聘信息,也可以内推工作,也可以在群里投递简历找工作,也可以在群里交流面试或者工作的话题。


图片


进群方式


添加,苏三的私人微信:su_san_java,备注:内推+所在城市,即可加入。


8. 缓存加速


我们在工作中使用Redis作为缓存加速,这种用法也是非常常见的。


如果查询订单数据,先从Redis缓存中查询,如果缓存中存在,则直接将数据返回给用户。


如果缓存中不存在,则再从数据库中查询数据,如果数据存在,则将数据保存到缓存中,然后再返回给用户。


如果缓存和数据库都不存在,则直接给用户返回数据不存在。


流程图如下:图片但使用缓存加速的业务场景,需要注意一下,可能会出现:缓存击穿、穿透和雪崩等问题,感兴趣的小伙伴,可以看看我的另一篇文章《烂大街的缓存穿透、缓存击穿和缓存雪崩,你真的懂了?》,里面有非常详细的介绍。


9. 做消息队列


我们说起队列经常想到是:kafka、rabbitMQ、RocketMQ等这些分布式消息队列。


其实Redis也有消息队列的功能,我们之前有个支付系统,就是用的Redis队列功能。


PubSub(发布订阅)是Redis2.0版本引入的消息传递模型。


顾名思义,消费者可以订阅一个或多个channel,生产者向对应channel发送消息后,所有订阅者都能收到相关消息。对应channel发送消息后,所有订阅者都能收到相关消息。


在java代码中可以实现MessageListener接口,来消费队列中的消息。


@Slf4j
@Component
public class RedisMessageListenerListener implements MessageListener {
    @Autowired
    private RedisTemplate<StringObject> redisTemplate;

    @Override
    public void onMessage(Message message, byte[] pattern) {
        String channel = new String(pattern);
        RedisSerializer valueSerializer = redisTemplate.getValueSerializer();
        Object deserialize = valueSerializer.deserialize(message.getBody());
        if (deserialize == nullreturn;
        String md5DigestAsHex = DigestUtils.md5DigestAsHex(deserialize.toString().getBytes(StandardCharsets.UTF_8));
        Boolean result = redisTemplate.opsForValue().setIfAbsent(md5DigestAsHex, "1"20TimeUnit.SECONDS);
        if (Boolean.TRUE.equals(result)) {
            log.info("接收的结果:{}", deserialize.toString());
        } else {
            log.info("其他服务处理中");
        }
    }
}

10. 生成全局ID


在有些需要生成全局ID的业务场景,其实也可以使用Redis。


可以使用incrby命令,利用原子性操作,可以执行下面这个命令:


incrby userid 10000

在分库分表的场景,对于有些批量操作,我们可以从Redis中,一次性拿一批id出来,然后给业务系统使用。


作者:苏三说技术
来源:juejin.cn/post/7325132133168971813
收起阅读 »

访问者模式:多品类商品打折场景

0.基础 0.0解决的痛点 它可以在不修改原有类的情况下,扩展新的操作,而策略模式则需要改变上下文类来引入新的策略。 扩展性更强 访问者模式使得你可以在不修改现有类的情况下添加新的操作。假设你有多个对象构成的复杂结构,并且要在这些对象上执行不同的操作。 使...
继续阅读 »

0.基础


0.0解决的痛点


它可以在不修改原有类的情况下,扩展新的操作,而策略模式则需要改变上下文类来引入新的策略。



  • 扩展性更强



    • 访问者模式使得你可以在不修改现有类的情况下添加新的操作。假设你有多个对象构成的复杂结构,并且要在这些对象上执行不同的操作。

    • 使用访问者模式,你可以为每个对象定义一个访问者,而每次需要添加新的操作时,只需要增加一个新的访问者类。这样,原有类不会被修改,符合开闭原则(对扩展开放,对修改关闭)。

    • 相反,策略模式更多是通过替换算法来改变行为。如果你的业务逻辑复杂,需要在同一个对象中实现多个策略,频繁地改变策略可能会导致对象内部逻辑变得非常复杂,增加维护成本。



  • 职责单一,逻辑分离



    • 访问者模式将行为与对象结构分离,访问者本身只关心如何对不同对象执行操作,而不需要关心对象的具体实现。这种方式将操作逻辑与数据结构解耦,符合单一职责原则。

    • 策略模式中,每种策略会嵌入到目标对象中,这会使得目标对象承担过多的责任,尤其是在需要处理大量策略的情况下,会导致对象变得非常臃肿。



  • 操作集中统一管理



    • 使用访问者模式时,所有的操作都集中在访问者类中进行管理。

    • 假设有多个元素需要执行不同的操作,访问者模式将这些操作集中到访问者中,避免了分散在各个策略中的问题,便于管理和维护。

    • 策略模式则往往需要将每个策略分散在不同的策略类中,随着策略增多,管理和维护会变得越来越困难,尤其是当策略之间有依赖或交互时,复杂性会迅速增加。



  • 适合复杂结构对象的处理



    • 访问者模式特别适合在对象结构复杂且需要遍历的场景中使用。

    • 例如,树形结构或对象图的遍历,这时每个节点的处理逻辑可以独立出来,并通过访问者来实现。

    • 访问者可以对这些节点类型的元素进行访问和操作,无需修改元素类本身。

    • 策略模式一般用于动态地改变同一对象的行为,不适合处理复杂的对象结构,特别是当需要在多个元素中进行遍历和操作时,策略模式会显得不够灵活。



  • 总结:



    • 访问者模式更适合在你需要对复杂结构的对象执行多个操作,并且希望操作与对象本身分离的场景。

    • 它更方便扩展,避免了复杂的继承结构或不断修改已有类。

    • 而策略模式则适合于在单一对象上动态替换行为,但对于复杂对象结构的处理往往会导致逻辑分散,扩展性差。




0.1代码结构图


访问者模式-商品打折场景-代码结构图.drawio.png


0.2业务流程图


访问者模式业务流程图.png


0.3请求Json


localhost:8080/VisitorPattern/calculateDiscount
   POST类型
  ["electronics", "clothing", "food"]


1.代码结构


1.1Pojo


package com.xiaoyongcai.io.designmode.pojo.VisitorPattern;

public interface Product {
   void accept(ProductVisitor visitor);
}


package com.xiaoyongcai.io.designmode.pojo.VisitorPattern;

import com.xiaoyongcai.io.designmode.pojo.VisitorPattern.ProductImpl.Clothing;
import com.xiaoyongcai.io.designmode.pojo.VisitorPattern.ProductImpl.Electronics;
import com.xiaoyongcai.io.designmode.pojo.VisitorPattern.ProductImpl.Food;

public interface ProductVisitor {
   void visit(Electronics electronics);
   void visit(Clothing clothing);
   void visit(Food food);
}


package com.xiaoyongcai.io.designmode.pojo.VisitorPattern.ProductImpl;

import com.xiaoyongcai.io.designmode.pojo.VisitorPattern.Product;
import com.xiaoyongcai.io.designmode.pojo.VisitorPattern.ProductVisitor;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Clothing implements Product {
   private double price;
   @Override
   public void accept(ProductVisitor visitor) {
       visitor.visit(this);  // 传递给访问者
  }
}


package com.xiaoyongcai.io.designmode.pojo.VisitorPattern.ProductImpl;

import com.xiaoyongcai.io.designmode.pojo.VisitorPattern.Product;
import com.xiaoyongcai.io.designmode.pojo.VisitorPattern.ProductVisitor;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Electronics implements Product {
   private double price;
   @Override
   public void accept(ProductVisitor visitor) {
       visitor.visit(this);  // 传递给访问者
  }
}


package com.xiaoyongcai.io.designmode.pojo.VisitorPattern.ProductImpl;

import com.xiaoyongcai.io.designmode.pojo.VisitorPattern.Product;
import com.xiaoyongcai.io.designmode.pojo.VisitorPattern.ProductVisitor;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Food implements Product {
   private double price;
   @Override
   public void accept(ProductVisitor visitor) {
       visitor.visit(this);  // 传递给访问者
  }
}


package com.xiaoyongcai.io.designmode.pojo.VisitorPattern.VisitorImpl;

import com.xiaoyongcai.io.designmode.pojo.VisitorPattern.ProductImpl.Clothing;
import com.xiaoyongcai.io.designmode.pojo.VisitorPattern.ProductImpl.Electronics;
import com.xiaoyongcai.io.designmode.pojo.VisitorPattern.ProductImpl.Food;
import com.xiaoyongcai.io.designmode.pojo.VisitorPattern.ProductVisitor;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.extern.slf4j.Slf4j;

@Data
@AllArgsConstructor
@NoArgsConstructor
@Slf4j
public class DiscountVisitor implements ProductVisitor {
   private double totalDiscount = 0;
   @Override
   public void visit(Electronics electronics) {
       //电子产品打八折
       totalDiscount += electronics.getPrice()*0.2;
       log.info("[访问者模式]:电子产品打8折后价格为"+electronics.getPrice()*0.2+"原价为"+electronics.getPrice());

  }

   @Override
   public void visit(Clothing clothing) {
       //衣物商品打7折
       totalDiscount+=clothing.getPrice()*0.3;
       log.info("[访问者模式]衣物商品打7折后价格为"+clothing.getPrice()*0.2+"原价为"+clothing.getPrice());
  }

   @Override
   public void visit(Food food) {
       //食品商品打9折
       totalDiscount += food.getPrice()*0.1;
       log.info("[访问者模式]食品商品打9折后价格为"+food.getPrice()*0.2+"原价为"+food.getPrice());
  }
}


1.2Service


package com.xiaoyongcai.io.designmode.Service.VisitorPattern;

import com.xiaoyongcai.io.designmode.pojo.VisitorPattern.Product;
import com.xiaoyongcai.io.designmode.pojo.VisitorPattern.VisitorImpl.DiscountVisitor;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class ProductService {

   public double calculateTotalDiscount(List<Product> products) {
       // 创建一个DiscountVisitor实例
       DiscountVisitor discountVisitor = new DiscountVisitor();

       // 遍历每个商品,执行折扣计算
       for (Product product : products) {
           product.accept(discountVisitor);
      }

       // 返回总折扣
       return discountVisitor.getTotalDiscount();
  }
}


1.3Controller


package com.xiaoyongcai.io.designmode.Controller.VisitorPattern;

import com.xiaoyongcai.io.designmode.Service.VisitorPattern.ProductService;
import com.xiaoyongcai.io.designmode.pojo.VisitorPattern.Product;
import com.xiaoyongcai.io.designmode.pojo.VisitorPattern.ProductImpl.Clothing;
import com.xiaoyongcai.io.designmode.pojo.VisitorPattern.ProductImpl.Electronics;
import com.xiaoyongcai.io.designmode.pojo.VisitorPattern.ProductImpl.Food;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.ArrayList;
import java.util.List;

@RestController
@RequestMapping("VisitorPattern")
public class ProductController {

   @Autowired
   private ProductService productService;

   @PostMapping("/calculateDiscount")
   public String calculateDiscount(@RequestBody List<String> productTypes) {
       List<Product> products = new ArrayList<>();

       // 根据传入的商品类型,创建不同的商品实例
       for (String type : productTypes) {
           switch (type) {
               case "electronics":
                   products.add(new Electronics(100));  // 假设价格是100
                   break;
               case "clothing":
                   products.add(new Clothing(150));    // 假设价格是150
                   break;
               case "food":
                   products.add(new Food(50));         // 假设价格是50
                   break;
          }
      }
       productService.calculateTotalDiscount(products);
       // 调用Service层计算折扣
       return "请在控制台检查访问者模式是否工作";
  }
}


作者:Asthenia0412
来源:juejin.cn/post/7440842636228919348
收起阅读 »

那些大厂架构师是怎样封装网络请求的?

好的设计是成功的一半,好的设计思想为后面扩展带来极大的方便 一、前言 网络请求在开发中是必不可少的一个功能,如何设计一套好的网络请求框架,可以为后面扩展及改版带来极大的方便,特别是一些长期维护的项目。作为一个深耕Android开发十几载的大龄码农,深深的体会...
继续阅读 »

5235a0e62ecd314a216da5209ff88326.jpeg



好的设计是成功的一半,好的设计思想为后面扩展带来极大的方便



一、前言


网络请求在开发中是必不可少的一个功能,如何设计一套好的网络请求框架,可以为后面扩展及改版带来极大的方便,特别是一些长期维护的项目。作为一个深耕Android开发十几载的大龄码农,深深的体会到。


网络框架的发展:


1. 从最早的HttpClientHttpURLConnection ,那时候需要自己用线程池封装异步,Handler切换到UI线程,要想从网络层就返回接收实体对象,也需要自己去实现封装


2. 后来,谷歌的 Volley, 三方的 Afinal 再到 XUtils 都是基于上面1中的网络层再次封装实现


3. 再到后来,OkHttp 问世,Retrofit 空降,从那以后基本上网络请求应用层框架就是 OkHttp Retrofit 两套组合拳,基本打遍天下无敌手,最多的变化也就是在这两套组合拳里面秀出各种变化,但是思想实质上还是这两招。


我们试想:从当初的大概2010年,2011年,2012年开始,就启动一个App项目,就网络这一层的封装而言,随着时代的潮流,技术的演进,我们势必会经历上面三个阶段,这一层的封装就得重构三次。


现在是2024年,往后面发展,随着http3.0的逐渐成熟,一定会出现更好的网络请求框架

我们怎么封装一套更容易扩展的框架,而不必每次重构这一层时,改动得那么困难。


本文下面就示例这一思路如何封装,涉及到的知识,jetpack 中的手术刀: Hilt 成员来帮助我们实现。


二 、示例项目


36c2d036-472c-4aa1-acbc-a15bafe2ae6f.jpeg



  1. 上图截图圈出的就是本文重点介绍的内容:怎么快速封装一套可以切换网络框架的项目 及相关 Jetpack中的 Hilt 用法

  2. 其他的1,2,3,4是之前我写的:花式封装:Kotlin+协程+Flow+Retrofit+OkHttp +Repository,倾囊相授,彻底减少模版代码进阶之路,大家可以参考,也可以在它的基础上,再结合本文再次封装,可以作为 花式玩法五


三、网络层代码设计


1. 设计请求接口,包含请求地址 Url,请求头,请求参数,返回解析成的对象Class :


interface INetApi {
/**
* Get请求
* @param url:请求地址
* @param clazzR:返回对象类型
* @param header:请求头
* @param map:请求参数
*/


suspend fun <R> getApi(url: String, clazzR: Class<R>, header: MutableMap<String, String>? = null, map: MutableMap<String, Any>? = null): R

/**
* Get请求
* @param url:请求地址
* @param clazzR:返回对象类型
* @param header:请求头
* @param map:请求参数
* @param body:请求body
*/

suspend fun <R> postApi(url: String, clazzR: Class<R>, header: MutableMap<String, String>? = null, body: String? = null): R
}

2. 先用早期 HttpURLConnection 对网络请求进行实现:


class HttpUrlConnectionImpl  constructor() : INetApi {
private val gson by lazy { Gson() }

override suspend fun <R> getApi(url: String, clazzR: Class<R>, header: MutableMap<String, String>?, map: MutableMap<String, Any>?): R {
//这里HttpUrlConnectionRequest内部是HttpURLConnection的Get请求真正的实现
val json = HttpUrlConnectionRequest.getResult(BuildParamUtils.buildParamUrl(url, map), header)
android.util.Log.e("OkhttpImpl", "HttpUrlConnection 请求:${json}")
return gson.fromJson<R>(json, clazzR)
}

override suspend fun <R> postApi(url: String, clazzR: Class<R>, header: MutableMap<String, String>?, body: String?): R {
////这里HttpUrlConnectionRequest内部是HttpURLConnection的Post请求真正的实现
val json = HttpUrlConnectionRequest.postData(url, header, body)
return gson.fromJson<R>(json, clazzR)
}
}

3. 整个项目 build.gradle 下配置 Hilt插件


buildscript {
dependencies {
classpath 'com.google.dagger:hilt-android-gradle-plugin:2.42'
}
}

4. 工程app的 build.gradle 下引入:


先配置:


plugins {
id 'com.android.application'
id 'org.jetbrains.kotlin.android'
id 'dagger.hilt.android.plugin'//Hilt使用
id 'kotlin-kapt'//
}

里面的 android 下面添加:


kapt {
generateStubs = true
}

dependencies 里面引入 Hilt 使用


//hilt
implementation "com.google.dagger:hilt-android:2.42"
kapt "com.google.dagger:hilt-android-compiler:2.42"
kapt 'androidx.hilt:hilt-compiler:1.0.0'

5. 使用 Hilt


5.1 在Application上添加注解 @HiltAndroidApp

@HiltAndroidApp
class MyApp : Application() {

}

5.2 在使用的Activity上面添加注解 @AndroidEntryPoint

@AndroidEntryPoint
class MainActivity : BaseViewModelActivity<MainViewModel>(R.layout.activity_main), View.OnClickListener {

override fun onClick(v: View?) {
when (v?.id) {
R.id.btn1 -> {
viewModel.getHomeList()
}
else -> {}
}
}
}

5.3 在使用的ViewModel上面添加注解 @HiltViewModel@Inject

@HiltViewModel
class MainViewModel @Inject constructor(private val repository: NetRepository) : BaseViewModel() {


fun getHomeList() {
flowAsyncWorkOnViewModelScopeLaunch {
repository.getHomeList().onEach {
val title = it.datas!![0].title
android.util.Log.e("MainViewModel", "one 111 ${title}")
errorMsgLiveData.postValue(title)
}
}
}
}

5.4 在 HttpUrlConnectionImpl 构造方法上添加注解 @Inject 如下:

class HttpUrlConnectionImpl @Inject constructor() : INetApi {
private val gson by lazy { Gson() }

override suspend fun <R> getApi(url: String, clazzR: Class<R>, header: MutableMap<String, String>?, map: MutableMap<String, Any>?): R {
val json = HttpUrlConnectionRequest.getResult(BuildParamUtils.buildParamUrl(url, map), header)
android.util.Log.e("OkhttpImpl", "HttpUrlConnection 请求:${json}")
return gson.fromJson<R>(json, clazzR)
}

override suspend fun <R> postApi(url: String, clazzR: Class<R>, header: MutableMap<String, String>?, body: String?): R {
val json = HttpUrlConnectionRequest.postData(url, header, body)
return gson.fromJson<R>(json, clazzR)
}
}

5.5 新建一个 annotationBindHttpUrlConnection 如下:

@Qualifier
@Retention(RetentionPolicy.RUNTIME)
annotation class BindHttpUrlConnection()

5.6 再建一个绑定网络请求的 abstract 修饰的类 AbstractHttp 如下:让 @BindHttpUrlConnectionHttpUrlConnectionImpl 在如下方法中通过注解绑定

@InstallIn(SingletonComponent::class)
@Module
abstract class AbstractHttp {


@BindHttpUrlConnection
@Singleton
@Binds
abstract fun bindHttpUrlConnection(h: HttpUrlConnectionImpl): INetApi
}

5.7 在viewModel持有的仓库类 NetRepository 的构造方法中添加 注解 @Inject,并且申明 INetApi,并且绑定注解 @BindHttpUrlConnection 如下: 然后即就可以开始调用 INetApi 的方法

class NetRepository @Inject constructor(@BindHttpUrlConnection val netHttp: INetApi) {

suspend fun getHomeList(): Flow<WanAndroidHome> {
return flow {
netHttp.getApi("https://www.wanandroid.com/article/list/0/json", HomeData::class.java).data?.let { emit(it) }
}
}
}

到此:Hilt使用就配置完成了,那边调用 网络请求就直接执行到 网络实现 类 HttpUrlConnectionImpl 里面去了。


运行结果看到代码执行打印:


7742b372-a54e-4110-9df5-2e2402c033f1.jpeg


5.8 我们现在切换到 Okhttp 来实现网络请求:

新建 OkhttpImpl 实现 INetApi 并在其构造方法上添加 @Inject 如下:


class OkhttpImpl @Inject constructor() : INetApi {

private val okHttpClient by lazy { OkHttpClient() }
private val gson by lazy { Gson() }

override suspend fun <R> getApi(url: String, clazzR: Class<R>, header: MutableMap<String, String>?, map: MutableMap<String, Any>?): R {
try {
val request = Request.Builder().url(buildParamUrl(url, map))
header?.forEach {
request.addHeader(it.key, it.value)
}
val response = okHttpClient.newCall(request.build()).execute()
if (response.isSuccessful) {
val json = response.body?.string()
android.util.Log.e("OkhttpImpl","okhttp 请求:${json}")
return gson.fromJson<R>(json, clazzR)
} else {
throw RuntimeException("response fail")
}
} catch (e: Exception) {
throw e
}
}

override suspend fun <R> postApi(url: String, clazzR: Class<R>, header: MutableMap<String, String>?, body: String?): R {
try {
val request = Request.Builder().url(url)
header?.forEach {
request.addHeader(it.key, it.value)
}
body?.let {
request.post(RequestBodyCreate.toBody(it))
}
val response = okHttpClient.newCall(request.build()).execute()
if (response.isSuccessful) {
return gson.fromJson<R>(response.body.toString(), clazzR)
} else {
throw RuntimeException("response fail")
}
} catch (e: Exception) {
throw e
}
}
}

5.9 再建一个注解 annotation 类型的 BindOkhttp 如下:

@Qualifier
@Retention(RetentionPolicy.RUNTIME)
annotation class BindOkhttp()

5.10 在 AbstractHttp 类中添加 @BindOkhttp 绑定到 OkhttpImpl,如下:

@InstallIn(SingletonComponent::class)
@Module
abstract class AbstractHttp {

@BindOkhttp
@Singleton
@Binds
abstract fun bindOkhttp(h: OkhttpImpl): INetApi

@BindHttpUrlConnection
@Singleton
@Binds
abstract fun bindHttpUrlConnection(h: HttpUrlConnectionImpl): INetApi
}

5.11 现在只需要在 NetRepository 中持有的 INetApi 修改其绑定的 注解 @BindHttpUrlConnection 改成 @BindOkhttp 便可以将项目网络请求全部改成由 Okhttp来实现了,如下:

//class NetRepository @Inject constructor(@BindHttpUrlConnection val netHttp: INetApi) {
class NetRepository @Inject constructor(@BindOkhttp val netHttp: INetApi) {

suspend fun getHomeList(): Flow<WanAndroidHome> {
return flow {
netHttp.getApi("https://www.wanandroid.com/article/list/0/json", HomeData::class.java).data?.let { emit(it) }
}
}
}

运行执行结果截图可见:


ff042ce9-2e1b-452a-82a1-ddbebef25779.jpeg


到此:网络框架切换就这样简单的完成了。


四、总结



  1. 本文重点介绍了,怎么对网络框架扩展型封装:即怎么可以封装成快速从一套网络请求框架,切换到另一套网络请求上去

  2. 借助于 Jetpack中成员 Hilt 对其整个持有链路进行切割,简单切换绑定网络实现框架1,框架2,框架xxx等。


项目地址


项目地址:

github地址

gitee地址


感谢阅读:


欢迎 点赞、收藏、关注


这里你会学到不一样的东西


作者:Wgllss
来源:juejin.cn/post/7435904232597372940
收起阅读 »

这段时间 weapp-vite 的功能更新与优化

web
这段时间 weapp-vite 的功能更新与优化 自从上次宣布 weapp-vite 的发布,已经过去三个月;weapp-vite 也逐渐迭代至 1.7.6 版本。 在此期间,我对其进行了多项功能的增强和优化,接下来我将为大家详细介绍近期的阶段性成果。 下面...
继续阅读 »

这段时间 weapp-vite 的功能更新与优化


自从上次宣布 weapp-vite 的发布,已经过去三个月;weapp-vite 也逐渐迭代至 1.7.6 版本。


在此期间,我对其进行了多项功能的增强和优化,接下来我将为大家详细介绍近期的阶段性成果。



下面列出的功能皆为增强特性,开发者可自由选择启用或关闭,不影响原生小程序的兼容性。



核心功能更新


1. 自动构建 npm


在项目启动时,weapp-vite 会自动构建 npm 依赖,无需再手动点击微信开发者工具中的 构建 npm,提升了一定程度的开发体验。


详细信息请参考:自动构建 npm 文档


2. 语法增强


2.1 JSON 文件增强

1. 支持注释

weapp-vite 支持在项目中的 JSON 文件中添加注释。例如:


{
/* 这是一个组件 */
"component": true,
"styleIsolation": "apply-shared",
"usingComponents": {
// 导航栏组件
"navigation-bar": "@/navigation-bar/navigation-bar"
}
}

这些注释会在最终产物内被去除。



注意: project.config.jsonproject.private.config.json 不支持注释,因为这些文件直接由微信开发者工具读取。



2. 智能提示

我生成了许多小程序的 $schema 文件,部署在 vite.icebreaker.top 上。


通过指定 JSON$schema 字段,实现了配置文件的智能提示功能,优化了一点点开发体验。


QQ20241117-004208.png


详见:JSON 配置文件的智能提示


3. 别名支持

可以在 vite.config.ts 中配置 jsonAlias.entries 字段, 在 usingComponents 中使用别名定义路径,这些在构建时会自动转化为相对路径。


例如:


import type { UserConfig } from 'weapp-vite/config'
import path from 'node:path'

export default <UserConfig>{
weapp: {
jsonAlias: {
entries: [
{
find: '@',
replacement: path.resolve(__dirname, 'components'),
},
],
},
},
}

那么就可以在 json 中这样编写:


{
"usingComponents": {
"navigation-bar": "@/navigation-bar/navigation-bar",
"ice-avatar": "@/avatar/avatar"
}
}

构建结果:


{
"usingComponents": {
"navigation-bar": "../../components/navigation-bar/navigation-bar",
"ice-avatar": "../../components/avatar/avatar"
}
}

4. 编程支持

weapp-vite 支持使用 JS/TS 文件来编写 JSON,你需要将 component.json 更改为 component.json.ts



智能提示定义 API 都在 weapp-vite/json 中导出



比如普通写法:


import { defineComponentJson } from 'weapp-vite/json'

export default defineComponentJson({
component: true,
styleIsolation: 'apply-shared',
usingComponents: {},
})

还支持引入异步数据、编译时变量或其他文件:


import type { Page } from 'weapp-vite/json'
import fs from 'node:fs/promises'
import path from 'node:path'
import shared0 from '@/assets/share'
import shared1 from './shared.json'

console.log('import.meta.env: ', import.meta.env)
console.log('import.meta.dirname: ', import.meta.dirname)
console.log('MP_PLATFORM: ', import.meta.env.MP_PLATFORM)
console.log(import.meta.env.DEV, import.meta.env.MODE, import.meta.env.PROD)
const key = await fs.readFile(
path.resolve(import.meta.dirname, 'x.txt'),
'utf8'
)

export default <Page>{
usingComponents: {
't-button': 'tdesign-miniprogram/button/button',
't-divider': 'tdesign-miniprogram/divider/divider',
'ice-avatar': '@/avatar/avatar',
},
...shared0,
...shared1,
key,
}

2.2 WXML 文件增强

事件绑定语法糖

weapp-vite 借鉴了 Vue 的事件绑定风格,为 WXML 增加了事件绑定语法糖:


这里我们以最常用的 tap 事件为例:


<!-- 原始代码 -->
<view @tap="onTap"></view>
<!-- 编译后 -->
<view bind:tap="onTap"></view>

支持的事件绑定增强规则如下:


源代码编译结果
@tapbind:tap
@tap.catchcatch:tap
@tap.mutmut-bind:tap
@tap.capturecapture-bind:tap
@tap.capture.catch / @tap.catch.capturecapture-catch:tap

详见:事件绑定增强文档


这部分还能做的更多,欢迎与我进行讨论!


2.3 WXS 增强

编程支持(实验性)

weapp-viteWXS 提供了 JS/TS 编程支持,支持通过更改 wxs 后缀为 wxs.jswxs.ts 文件定义逻辑:


比如 index.wxs.ts:


export const foo = '\'hello world\' from hello.wxs.ts'

export const bar = function (d: string) {
return d
}

另外内联 WXS 也支持使用 lang="js"lang="ts" 直接启用编译功能:


<view>{{test.foo}}</view>
<view @tap="{{test.tigger}}">{{test.abc}}</view>

<wxs module="test" lang="ts">
const { bar, foo } = require('./index.wxs.js')
const bbc = require('./bbc.wxs')
export const abc = 'abc'

export function tigger(value:string){
console.log(abc)
}

export {
foo,
bar,
bbc
}
</wxs>

详情请参考:Wxs 增强


3. 生成脚手架


weapp-vite 内置了生成脚手架工具,可快速生成一系列文件(如 jswxmlwxssjson),用于提升开发效率。


最基础的用法只需要 weapp-vite g [outDir]


详情请参考:生成脚手架文档


4. 分包支持


针对普通分包和独立分包的加载需求进行了优化,用户几乎无需额外配置即可实现分包加载。


尤其是独立分包的场景,创建了独立的编译上下文。


详情请参考:分包加载文档


不忘初心,持续改进


weapp-vite 的初衷是实现对原生小程序的增强,现有原生小程序几乎可以零成本地迁移过来,并享受更高效的开发体验。


在此,希望各位开发者试用,欢迎反馈与参与。


如果您对文中的任何功能或增强有疑问、建议,欢迎到 Github Discussions 提出讨论!


作者:icebreaker
来源:juejin.cn/post/7437876830487363599
收起阅读 »

JavaScript内存管理机制解析

web
前言 内存,作为计算机系统中存储数据和指令的关键资源,其管理效率直接影响着程序的性能和稳定性。在JavaScript的世界里,理解内存机制并非遥不可及,每一位开发者必须面对并掌握的实用技能。无论是初涉开发的新手,还是经验丰富的老手,深入理解JavaScript...
继续阅读 »

前言


内存,作为计算机系统中存储数据和指令的关键资源,其管理效率直接影响着程序的性能和稳定性。在JavaScript的世界里,理解内存机制并非遥不可及,每一位开发者必须面对并掌握的实用技能。无论是初涉开发的新手,还是经验丰富的老手,深入理解JavaScript的内存机制都是通往更高层次编程能力的必经之路。


语言类型


静态语言


静态语言是指在编译时变量的数据类型就已经确定的语言,比如java定义一个整数类型需要先用int去定义一个变量。这类语言在编写程序时,要求开发者明确地声明变量的类型,并且在程序的整个生命周期内,该变量的类型都不能改变。换句话说,静态语言的类型检查是在编译阶段完成的,而不是在运行时,常见的静态语言包括Java、C++、C#、Go等。


动态语言


动态语言(Dynamic Language),也称为动态编程语言或动态类型语言,与静态语言相反,是指在程序运行时可以改变其结构的语言。这种改变可能包括引进新的函数、删除已有的函数,或者在运行时确定变量的类型等。动态语言的特点使得它们通常具有更高的灵活性和表达能力。常见的动态语言有我们学的JavaScript,还有Python,PHP等。


弱类型语言


弱类型语言是指变量的类型检查和转换方式相对宽松的一种编程语言。在弱类型语言中,变量可以在不明确声明类型的情况下直接使用,并且在运行时可以自动改变类型,或者可以在不同类型之间自由进行操作和转换,常见的弱类型语言包括JavaScript、Python等。


强类型语言


强类型语言(Strongly Typed Language)是一种在编译时期就进行类型检查的编程语言。这类语言要求变量在使用前必须明确声明其类型,并且在使用过程中,变量的类型必须保持一致,不能随意更改,常见的强类型语言包括Java、C++、C#、Go等。


数据类型


在每种语言里面都会有一个方法去查看数据的类型,js也不例外,我们可以用typeof去查看一个数据的类型,那我们来看看js中所有的数据类型吧


let a = 1
// console.log(typeof a); //Number
a = 'hello'
// console.log(typeof a); //String
a = true
// console.log(typeof a); //boolean
a = null
// console.log(typeof a); //object
a = undefined
// console.log(typeof a); //undefined
a = Symbol(1)
// console.log(typeof a); //symbol
a = 123n
// console.log(typeof a); //bigint
a = []
// console.log(typeof a); // object
a = {}
// console.log(typeof a); //object
a = function () {}
// console.log(typeof a); // function

我们可以看到所有判断类型的结果,大部分还正常,可是数组和null怎么也被判断成了object类型呢?


那我们要来了解一下typeof的判断原理,怎么给a判断出来它的数据类型的呢,其实是通过转换为计算机能看懂的二进制,然后通过二进制的数据进行的分析,所有的引用类型转换成二进制前三位一定是零,然后数组是引用类型,而typeof判断时如果前三位是零,那么就无脑认为它是object类型,但是函数是一个特例,在js中函数是一个对象,它做了一些特殊操作,所以能够判断出来,但是null是原始数据类型,为什么也能被判断为object类型呢,因为null在被读取成二进制时,它会被读取为全是零。而这个不是编程语言能够决定的,在计算机创建出来时就是这样设定的,因此这是一个bug,在设计这门语言的的bug,这个bug如果要修复并不困难,但是一旦修复,所有用js语言开发的项目都需要修复,影响太大,因此这个bug就被默认为js语言里面的规则。


内存空间


内存空间的分布


在v8引擎执行你写的代码时,会占用一部分的运行空间,而执行时占用的内存空间在v8的视角里会被分布成这个样子的


46.png


代码空间是专门存储你所写的代码,栈空间就是我们之前讲过的调用栈juejin.cn/post/743706…


用来存储函数被调用时,它的执行上下文,维护函数的调用关系,调用栈被分布的空间是比较小的。


堆空间(Heap Space)是内存管理的一个重要部分,它用于存储动态分配的对象和数据结构。


栈和堆之间的关系


让我们来看看栈和堆之间的关系


function foo() {
var a = 1
var b = a
var c = {name: '熊总'}
var d = c
}
foo()

47.png


此时foo函数已经完成编译,且已经执行到了b=a这一行,然后将一个对象赋值给c的时候,并不会直接把这个对象存储在函数的执行上下文里面,而是会在旁边在创建一个堆空间,将对象存储在堆空间里面,而这个c存储的就是对象在堆空间的地址值


48.png
然后在执行将c的值赋给d其实就是将对象的地址值赋值给了d,因此cd的地址值指向的是同一个对象,并没有创建出一个新的对象,如果这个对象发生改变,那么cd所代表的对象都会发生改变。


那为什么原始数据类型可以直接存储在栈当中,而引用数据类型却要存储在堆空间里面,因为原始类型数据所占的空间小,而引用数据类型所占的空间较大,比如一个对象,它可以有无数个属性,而原始类型,它就只有一个固定的值,所占内存不大,而栈被分布的空间比较小,堆被分布的空间比较大,因此原始数据类型可以直接存储在栈当中,而引用数据类型要存储在堆当中。


栈设计为什么这么小


首先我们要明白栈是用来维护函数的调用关系,而如果将栈设计的很大,那么程序员就可以写很长作用域链,并且不考虑代码的执行效率,写出不断嵌套的屎山代码。举个例子,栈就好比在你身上的空间,比如你的衣服裤子口袋,而堆就相当于一个分层的柜子,你把衣服上的口袋设计的很大,不要柜子,把你的东西全部装在口袋里面,首先看起来就十分丑陋,其次,你如果想将你想要的东西拿出来就要在口袋里翻来覆去的找,那样的效率是很低的


成果检验


function fn(person) {
person.age = 19
person = {
name: '庆玲',
age: 19
}
return person
}
const p1 = {
name: '凤如',
age: 18
}
const p2 = fn(p1)

console.log(p1);
console.log(p2);

请分析上面的代码中的p1p2的输出结果


49.png
我们创建全局上下文进行编译执行,然后对函数fn进行编译,编译过程中形参和实参要进行统一,接下来,我们要开始执行函数fn了,首先它将p1所指向的对象age修改为了19,然后再函数中它将p1的地址值修改指向为了新对象,并将新对象返回,然后在全局接着执行,将返回的地址值赋给了p2,所以p2的值就是函数中新对象的地址值,接下来输出p1,此时函数已经执行完毕,在调用栈中被销毁了,那我们就在全局中查找,在全局中p1的指向就是#001,但是函数销毁前他将地址值为#001的对象age属性修改为19,所以p1打印出来的只有age改为了19,而p2就是返回的新对象的值,然我们看看结果是不是我们分析的那样


50.png


没错,p1name为'凤如',age19p2name为'庆玲',age为19


最后来一道添加闭包的内存管理机制代码分析,如果不熟悉闭包的概念,可以先看看这篇文章
](juejin.cn/post/743814…)


function foo() {
var myname = '彭于晏'
let test1 = 1
const test2 = 2
var innerBar = {
setName: function (name) {
myname = name
},
getName: function () {
console.log(test1);
return myname
}
}
return innerBar
}
var bar = foo()
bar.setName('金城武')
console.log(bar.getName());

总结


本文探讨了JavaScript的内存机制,包括语言类型(静态与动态、强类型与弱类型)、数据类型及typeof的判断原理,并解析了内存空间的分布,特别是栈空间和堆空间的作用及它们之间的关系。通过示例代码,阐述了原始数据类型和引用数据类型在内存中的存储差异,以及栈为何设计得相对较小的原因。最后,通过实际代码演示和结果分析,检验了对JavaScript内存机制的理解。本文是掌握JavaScript编程能力的关键一步,适合各层次开发者阅读。


作者:竺梓君
来源:juejin.cn/post/7440717815709057050
收起阅读 »

surya,一个优秀的OCR开源项目,更专注于表格识别

写这篇文件,因为一条评论。 我写过识别计算器屏幕的文章,讲了它可以独立部署在App、小程序、树莓派等嵌入式设备上。有个老哥说,这都是应用多年的老技术了。 他说得没错,可能多少年前就有了。不过,实际上,一项技术不管应用了多少年,每年依然还有人花钱去做新的。 不...
继续阅读 »

写这篇文件,因为一条评论。


chat.png


我写过识别计算器屏幕的文章,讲了它可以独立部署在App、小程序、树莓派等嵌入式设备上。有个老哥说,这都是应用多年的老技术了。


他说得没错,可能多少年前就有了。不过,实际上,一项技术不管应用了多少年,每年依然还有人花钱去做新的。


不知道八零、九零后是否还记得,零几年时的非智能手机,就已经有了手写识别这个功能。甚至它还给你配一个手写笔。


mobile.png


即便这项技术已经30年了。你现在去软件企业问问,如果他家的产品需要一个手写识别的功能,他是不是依然还得花钱买第三方的服务。


为啥?


这个问题非常好,值得思考。


首先,那时候的技术和现在不一样。在非AI时代,手写识别用的是模板匹配技术,是基于规则的。你写的字,它要拿去库里同模板做比对。就像是机器人客服,靠关键字回复一样。你问“房子”它知道,问“屋子”它说听不懂。而现在的手写识别是基于深度学习的,你问它house,它一样知道是住的地方。


其次,就算技术没变化,它的落地实践也是有壁垒的。这体现在两点。第一,给你一个开源项目,你不一定能用起来。第二,每个人的细分需求不一样,就算你能跑起来,也很难改动,个性化定制。


今天,我就讲解一个开源的OCR项目。以此论证我的观点。


我看到这个项目公布好几个月了,各类新闻也是来了一波又一波:《比xx更好的用OCR》《表格识别神器》《今年最火的十个开源项目》……


大家都在传播、转发,哎呀,这个东西好,好用。包括我做卷帘门的朋友都分享给我,说这个好用。但是,没有谁发一篇文章,说他真的用了,是如何用的,效果怎么样,它的原理是什么,它是如何训练的,它有什么优点,它有什么缺点,缺点是否能优化,该如何优化。今天,我就来填补一下。不然又会有人说,哎呀,这东西早就解决,零成本,多少年前就很成熟了。


这个项目的名字叫surya,是一个OCR识别项目,开源地址是 github.com/VikParuchuri/surya ,目前在github上拥有14K个star。它支持本地化部署,面对年收入低于500万美元的商用,可免费。


我在自己电脑上搭了一套,CPU就可以运行,GPU效率更高。稍微试验了下,给大家展示下功能。


一、功能展示


我拿这张图来进行试验,这是某报纸中的一篇新闻稿件。


a16.png


它可以检测出图中有哪些类型的结构。比如,段落、图片、标题等。下面的图,就是将检测到的区域标记展示。


a16_type.jpg


另外,区域检测还附赠一个阅读顺序的功能。所谓阅读顺序,就是你读这篇文档时,先读哪里后读哪里。比如按照从左到右,从上到下的顺序。有时候,阅读顺序也很重要,不然容易剧透。


a16_order.jpg


既然是OCR,那么必定要将图像转为文字。想要转换文字,首先得知道哪些区域是文字。这个文本行检测,它也有。


a16_text.jpg


检测到文字的位置,下一步就是识别文字了。下面是识别的结果。


a16_ocr.jpg


最后,展示一下,它的表格识别。测试图片这样。


table_o.png


做一下表格检测,效果如下。
table_row.jpg


从识别到的数据信息看,它有4行,3列,12个单元格。
table_info.png


再来进行ocr内容识别。
table_ocr.jpg


二、算法集成


上面是它的功能。咱先不谈效果。下面我想问,它为什么能做到这些?回答完这个问题,才能更好地理解它的水平。


作者在最后列举了很多感谢,他说不借助这么多优秀的开源模型,他不可能完成这个项目。比如感谢CRAFT项目,这是一个超3k star的开源文本检测模型。


craft_example.gif


再比如它还采用了donut,这是一个利用无OCR理解文档的新方法。我们知道,想要理解文档,一般先要知道它上面写了什么,然后对文档进行分析,才能做出判断。而Donut结合多模态直接解析图像,极少处理文字,省去了全文分析的这个步骤。


craft_example.gif


看上面这张图。你问donut这张图的标题是什么?它可以正确地回答出来。这就是对文档的理解。


因此,从算法层面上,surya是借助了很多顶级的开源模型。而那些模型,也是站在巨人的肩膀上。可以说,它集成的算法是目前公开的一流水平。


我们再来说它的训练数据。他的训练数据,我们可以在 huggingface.co/vikp 上找到。


三、训练数据


比如文本区域类型检测,它的训练数据是这样的:


dataset3_layout_list.png


我们来看它的其中一组数据。image是一张图,bboxes是区域框,labels是区域类型,有文本类型,有表格类型。这些数据,是需要标注的,也就是在图片上画框,标注出区域类型。训练总量是1910张图片。不多。


比如表格的分析检测,它的训练数据是这样的:


dataset_table.png


image是一张表格图片,bboxes是单元格,rows是每一行的区域,cols是每一列的区域。把这些标记好的数据交给算法,让它学习什么样的特征的是行,什么样的是列。数据相对多一些,9680张图片。所以人家说它的表格识别很强。


对于文本行的检测,它的训练数据是这样的:


dataset_doclaynet.png


训练数据的结构组成:图片,图片中的某个区域,此区域对应的文本类型,另外还附加了一个文本内容。就拿上图选中的那条数据来说。这里面只标记了一条文本行区域。它告诉模型,这张图里面有一个类型为7的文本行,其区域是[88, 96, 865, 134](左、上、右、下)围成的矩形,请认真学习。


dataset_doclaynet2.png


最后到了,OCR识别了。


dataset_rec.png


训练数据的组成还是老一套,图片,区域框,文本内容。主要是告诉模型,我的这张图里面有几个区域,这些区域是什么文本内容,请你仔细学习。另外,这里面还有一个language字段,这表示文字的语言类型。


surya自称支持90多种语言的识别。这不是胡说,因为他的训练数据里,确实有90多种语言的标注。但是,总量太少了。一共4635张图片,如果平均的话,每种语言只有50来张训练数据。


因此,其实surya对于中文的OCR识别效果不是特别好(虽然自称并肩Tesseract)。其主要原因并不是算法不好,而是中文的训练数据太少。英文26个字母,50张纸可以覆盖。但是中文几万字,很难覆盖全。而对于手写识别,surya只能说随缘,因为根本没有训练数据,识别成啥样就是啥样。


这里面训练数据最多的是表格的识别,共9700张样本。训练数据最少的是阅读顺序的检测,才126张。因此,数据量决定了它的识别效果。对于海量的训练数据,就算对强大的商业公司来说也是一个难题。而作者能够凑足这几千张数据,已然很不容易了。


最终,我可以下一个结论。对于surya,它是一流的算法开源项目,是免费的。它对于表格的分析确实很强大。但是,它的训练数据还是太少,而且主要用于识别电子版的文档(清晰、无扭曲),手写识别基本不支持。如果你想要不做改动直接平替收费的OCR,可行性不高。就算是只用表格识别,你也得有稍微专业一些的人,进行从拍照到预处理成电子版的工作。如果收费的效果都不好,你想用免费替换它,可以打消这个念头。算法是开源的,但是训练数据和训练设备的投入,总得有人出。


如果,你想要学习并调整它,或者想自己训练,那么可以接着往下看。


四、源码运行


我不会讲官方ReadMe.md文档上明明白白写着的内容。比如你需要运行pip install streamlit。或者它有这么几个参数,第一个--langs是用于指定OCR的语言。


readme.png


这样的话,我很像一个复读机。


另外,既然你都想要研究它了,应该不至于按照操作都跑不起来。你去看看它的源码,我只讲关键点。


首先,下载源码。你在源码中可以看到两个文件pyproject.tomlpoetry.lock。这说明surya用的是poetry作为项目管理工具。poetry既能管理依赖包,也能管理虚拟环境。


咱们最好找一个Linux环境,再安装poetry。即便你在windows下,现在也可以很简单地安装个ubuntu虚拟机。因为linux实在是可以避免很多问题。


ubuntu.png


打开liunx命令行,进入到源码根目录。先运行pip install poetry,安装poetry。再运行poetry install安装依赖环境。最后运行poetry shell进入环境,你会看到:


(surya-ocr-py3.12) root@tf:/mnt/d/surya# 

这时运行surya_gui,会启动它的web页面。正常情况下,你会看到如下的输出:


https://huggingface.co/vikp

(surya-ocr-py3.12) root@tf:/mnt/d/surya# surya_gui

You can now view your Streamlit app in your browser.

Local URL: http://localhost:8501
Network URL: http://192.168.1.109:8501

gio: http://localhost:8501: Operation not supported
Loaded detection model /mnt/d/surya/vikp/surya_det3 on device cpu with dtype torch.float32
Loaded recognition model /mnt/d/surya/vikp/surya_rec2 on device cpu with dtype torch.float32
Loaded detection model /mnt/d/surya/vikp/surya_layout3 on device cpu with dtype torch.float32
Loaded reading order model /mnt/d/surya/vikp/surya_order on device cpu with dtype torch.float32
Loaded recognition model /mnt/d/surya/vikp/surya_tablerec on device cpu with dtype torch.float32

访问localhost:8501还有这样的页面:


web.png


但实际上,极有可能不正常。因为它在自动下载权重模型访问 huggingface.co 时会访问失败。这时,需要你想办法手动下载模型,然后放到一个固定的位置。


从报错信息能看到说加载不到模型。跟着代码就找到了surya/settings.py


# Text detection
DETECTOR_MODEL_CHECKPOINT: str = "vikp/surya_det3"
DETECTOR_BENCH_DATASET_NAME: str = "vikp/doclaynet_bench"

# Text recognition
RECOGNITION_MODEL_CHECKPOINT: str = "vikp/surya_rec2"
RECOGNITION_BENCH_DATASET_NAME: str = "vikp/rec_bench"

# Layout
LAYOUT_MODEL_CHECKPOINT: str = "vikp/surya_layout3"
LAYOUT_BENCH_DATASET_NAME: str = "vikp/publaynet_bench"

# Ordering
ORDER_MODEL_CHECKPOINT: str = "vikp/surya_order"
ORDER_BENCH_DATASET_NAME: str = "vikp/order_bench"

# Table Rec
TABLE_REC_MODEL_CHECKPOINT: str = "vikp/surya_tablerec"
TABLE_REC_BENCH_DATASET_NAME: str = "vikp/fintabnet_bench"
……

这里面是它5大功能(检测、识别、类型、排序、表格)的权重模型以及训练数据集的路径配置。正常情况下,会自动下载并缓存读取。但现在我们要自己下载并手动配置。下载方式就是去 huggingface.co/vikp 上找对应的模型文件。


用哪个就下载哪个模型文件,即用什么功能就下载什么功能。其实,对于新手来说,这并不好区分。因为有些功能是相互依赖的。比如表格识别,往往需要先检测出表格区域,才能识别行列区域。实际上会走好几个模型。因此,不熟悉的时候,把MODEL_CHECKPOINT全下载就行了。


DATASET_NAME是数据集,如果你要重新训练,就下载它。不调用训练的代码,不下载也不报错。


你可以把权重文件下载到项目的根目录。然后做如下的配置:


code.png


"vikp/surya_det3"改为os.path.join(BASE_DIR, "vikp/surya_det3")。因上面定义了BASE_DIR是项目根目录,所以这个路径没错。


后面再运行surya_gui就正常了。


访问 localhost:8501 可以上传文件进行5大功能的测试。


web2.png


它会展示相应的结果。


web3.png


而在控制台,也会输出操作类型和时间消耗:


Detecting bboxes: 100%|███████| 1/1 [00:02<00:00,  2.61s/it]
Detecting bboxes: 100%|███████| 1/1 [00:02<00:00, 2.06s/it]
Detecting bboxes: 100%|███████| 1/1 [00:02<00:00, 2.44s/it]
Recognizing tables: 100%|███████| 1/1 [00:01<00:00, 1.19s/it]

这样,你就可以研究它的源码了。你可以改一点代码,运行一下,查看变化。具体的功能模块和代码对应,官方readMe.md上有说明。不管是暴露接口能力,还是修改内部函数,或者重新训练自己的数据,都有了着手点。


五、总结


优秀的开源项目就像一个质量很好的毛坯房,相对于商业软件,它往往不具备舒适的居住条件。但是,它的底子很好,结构合理,质量精良。它想发达,需要有人去做一个精装修。但是反过来,有些商业软件去了精装修,很可能就是豆腐渣框架。


为什么说现在是数据为王的时代。从上面的论述可以发现,在一定时空内,算法是公开的,算力投钱就可以,可能就是数据难搞。有好的、大量的数据投喂,才能产生好的AI模型。

作者:TF男孩
来源:juejin.cn/post/7436713044246806578
收起阅读 »

前端如何做截图?

web
一、 背景 页面截图功能在前端开发中,特别是营销场景相关的需求中, 是比较常见的。比如截屏分享,相对于普通的链接分享,截屏分享具有更丰富的展示、更多的信息承载等优势。最近在需求开发中遇到了相关的功能,所以调研了相关的实现和原理。 二、相关技术 前端要实现页面截...
继续阅读 »

一、 背景


页面截图功能在前端开发中,特别是营销场景相关的需求中, 是比较常见的。比如截屏分享,相对于普通的链接分享,截屏分享具有更丰富的展示、更多的信息承载等优势。最近在需求开发中遇到了相关的功能,所以调研了相关的实现和原理。


二、相关技术


前端要实现页面截图的功能,现在比较常见的方式是使用开源的截图npm库,一般使用比较多的npm库有以下两个:



以上两种常见的npm库,对应着两种常见的实现原理。实现前端截图,一般是使用图形API重新绘制页面生成图片,基本就是SVG(dom-to-image)和Canvas(html2canvas)两种实现方案,两种方案目标相同,即把DOM转为图片,下面我们来分别看看这两类方案。


三、 dom-to-image


dom-to-image库主要使用的是SVG实现方式,简单来说就是先把DOM转换为SVG然后再把SVG转换为图片。


(一)使用方式


首先,我们先来简单了解一下dom-to-image提供的核心api,有如下一些方法:



  • toSvg (dom转svg)

  • toPng (dom转png)

  • toJpeg (dom转jpg)

  • toBlob (dom转二进制格式)

  • toPixelData (dom转原始像素值)


如需要生成一张png的页面截图,实现代码如下:


import domtoimage from "domtoimage"

const node = document.getElementById('node');
domtoimage.toPng(node,options).then((dataUrl) => {
const img = new Image();
img.src = dataUrl;
document.body.appendChild(img);
})

toPng方法可传入两个参数node和options。


node为要生成截图的dom节点;options为支持的属性配置,具体如下:filter,backgroundColor,width,height,style,quality,imagePlaceholder,cacheBust。


(二)原理分析


dom to image的源码代码不是很多,总共不到千行,下面就拿toPng方法做一下简单的源码解析,分析一下其实现原理,简单流程如下:


image.png


整体实现过程用到了几个函数:



  • toPng(调用draw,实现canvas=>png )

  • Draw(调用toSvg,实现dom=>canvas)

  • toSvg(调用cloneNode和makeSvgDataUri,实现dom=>svg)

  • cloneNode(克隆处理dom和css)

  • makeSvgDataUri(实现dom=>svg data:url)

  • toPng


toPng函数比较简单,通过调用draw方法获取转换后的canvas,利用toDataURL转化为图片并返回。


function toPng(node, options) {
return draw(node, options || {})
.then((canvas) => canvas.toDataURL());
}


  • draw


draw函数首先调用toSvg方法获得dom转化后的svg,然后将获取的url形式的svg处理成图片,并新建canvas节点,然后借助drawImage()方法将生成的图片放在canvas画布上。


function draw(domNode, options) {
return toSvg(domNode, options)
// 拿到的svg是image data URL, 进一步创建svg图片
.then(util.makeImage)
.then(util.delay(100))
.then((image) => {
// 创建canvas,在画布上绘制图像并返回
const canvas = newCanvas(domNode);
canvas.getContext("2d").drawImage(image, 0, 0);
return canvas;
});
// 新建canvas节点,设置一些样式的options参数
function newCanvas(domNode) {
const canvas = document.createElement("canvas");
canvas.width = options.width || util.width(domNode);
canvas.height = options.height || util.height(domNode);
if (options.bgcolor) {
const ctx = canvas.getContext("2d");
ctx.fillStyle = options.bgcolor;
ctx.fillRect(0, 0, canvas.width, canvas.height);
}
return canvas;
}
}


  • toSvg

  • toSvg函数实现从dom到svg的处理,大概步骤如下:

  • 递归去克隆dom节点(调用cloneNode函数)

  • 处理字体,获取所有样式,找到所有的@font-face和内联资源,解析并下载对应的资源,将资源转为dataUrl给src使用。把上面处理完的css rules放入中,并把标签加入到clone的节点中去。
  • 处理图片,将img标签的src的url和css中backbround中的url,转为dataUrl使用。

  • 获取dom节点转化的dataUrl数据(调用makeSvgDataUri函数)


function toSvg(node, options) {
options = options || {};
// 处理imagePlaceholder、cacheBust值
copyOptions(options);
return Promise.resolve(node)
.then((node) =>
// 递归克隆dom节点
cloneNode(node, options.filter, true))
// 把字体相关的csstext放入style
.then(embedFonts)
// clone处理图片,将图片链接转换为dataUrl
.then(inlineImages)
// 添加options里的style放入style
.then(applyOptions)
.then((clone) =>
// node节点转化成svg
makeSvgDataUri(clone,
options.width || util.width(node),
options.height || util.height(node)));
// 处理一些options的样式
function applyOptions(clone) {
...
return clone;
}
}


  • cloneNode


cloneNode函数主要处理dom节点,内容比较多,简单总结实现如下:



  • 递归clone原始的dom节点,其中, 其中如果有canvas将转为image对象。

  • 处理节点的样式,通过getComputedStyle方法获取节点元素的所有CSS属性的值,并将这些样式属性插入新建的style标签上面, 同时要处理“:before,:after”这些伪元素的样式, 最后处理输入内容和svg。


function cloneNode(node, filter, root) {
if (!root && filter && !filter(node)) return Promise.resolve();
return Promise.resolve(node)
.then(makeNodeCopy)
.then((clone) => cloneChildren(node, clone, filter))
.then((clone) => processClone(node, clone));
function makeNodeCopy(node) {
// 将canvas转为image对象
if (node instanceof HTMLCanvasElement) return util.makeImage(node.toDataURL());
return node.cloneNode(false);
}
// 递归clone子节点
function cloneChildren(original, clone, filter) {
const children = original.childNodes;
if (children.length === 0) return Promise.resolve(clone);
return cloneChildrenInOrder(clone, util.asArray(children), filter)
.then(() => clone);
function cloneChildrenInOrder(parent, children, filter) {
let done = Promise.resolve();
children.forEach((child) => {
done = done
.then(() => cloneNode(child, filter))
.then((childClone) => {
if (childClone) parent.appendChild(childClone);
});
});
return done;
}
}
function processClone(original, clone) {
if (!(clone instanceof Element)) return clone;
return Promise.resolve()
.then(cloneStyle)
.then(clonePseudoElements)
.then(copyUserInput)
.then(fixSvg)
.then(() => clone);
// 克隆节点上的样式。
function cloneStyle() {
...
}
// 提取伪类样式,放到css
function clonePseudoElements() {
...
}
// 处理Input、TextArea标签
function copyUserInput() {
...
}
// 处理svg
function fixSvg() {
...
}
}
}


  • makeSvgDataUri


首先,我们需要了解两个特性:



  • SVG有一个元素,这个元素的作用是可以在其中使用具有其它XML命名空间的XML元素,换句话说借助标签,我们可以直接在SVG内部嵌入XHTML元素,举个例子:


<svg xmlns="http://www.w3.org/2000/svg">
<foreignObject width="120" height="50">
<body xmlns="http://www.w3.org/1999/xhtml">
<p>文字。</p>
</body>
</foreignObject>
</svg>

可以看到标签里面有一个设置了xmlns=“http://www.w3.org/1999/xhtml”…标签,此时标签及其子标签都会按照XHTML标准渲染,实现了SVG和XHTML的混合使用。



  • XMLSerializer对象能够把一个XML文档或Node对象转化或“序列化”为未解析的XML标记的一个字符串。


基于以上特性,我们再来看一下makeSvgDataUri函数,该方法实现node节点转化为svg,就用到刚刚提到的两个重要特性。


首先将dom节点通过


XMLSerializer().serializeToString() 序列化为字符串,然后在


标签 中嵌入转换好的字符串,foreignObject 能够在 svg


内部嵌入XHTML,再将svg处理为dataUrl数据返回,具体实现如下:


function makeSvgDataUri(node, width, height) {
return Promise.resolve(node)
.then((node) => {
// 将dom转换为字符串
node.setAttribute("xmlns", "http://www.w3.org/1999/xhtml");
return new XMLSerializer().serializeToString(node);
})
.then(util.escapeXhtml)
.then((xhtml) => `<foreignObject x="0" y="0" width="100%" height="100%">${xhtml}</foreignObject>`)
// 转化为svg
.then((foreignObject) =>
// 不指定xmlns命名空间是不会渲染的
`<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}">${
foreignObject}
</svg>`
)
// 转化为data:url
.then((svg) => `data:image/svg+xml;charset=utf-8,${svg}`);
}

四、 html2canvas


html2canvas库主要使用的是Canvas实现方式,主要过程是手动将dom重新绘制成canvas,因此,它只能正确渲染可以理解的属性,有许多CSS属性无法正确渲染。


支持的CSS属性的完整列表:


html2canvas.hertzen.com/features/


浏览器兼容性:


Firefox 3.5+ Google Chrome Opera 12+ IE9+ Edge Safari 6+


官方文档地址:


html2canvas.hertzen.com/documentati…


(一)使用方式


// dom即是需要绘制的节点, option为一些可配置的选项
import html2canvas from 'html2canvas'
html2canvas(dom, option).then(canvas=>{
canvas.toDataURL()
})

常用的option配置:


image.png


全部配置文档:


html2canvas.hertzen.com/configurati…


(二)原理分析


html2canvas的内部实现相对dom-to-image来说要复杂一些, 基本原理是读取DOM元素的信息,基于这些信息去构建截图,并呈现在canvas画布中。


其中重点就在于将dom重新绘制成canvas的过程,该过程整体的思路是:遍历目标节点和目标节点的子节点,遍历过程中记录所有节点的结构、内容和样式,然后计算节点本身的层级关系,最后根据不同的优先级绘制到canvas画布中。


由于html2canvas的源码量比较大,可能无法像dom-to-image一样详细的分析,但还是可以大致了解一下整体的流程,首先可以看一下源码中src文件夹中的代码结构,如下图:


image.png


简单解析一下:



  • index:入口文件,将dom节点渲染到一个canvas中,并返回。

  • core:工具函数的封装,包括对缓存的处理函数、Context方法封装、日志模块等。

  • css:对节点样式的处理,解析各种css属性和特性,进行处理。

  • dom:遍历dom节点的方法,以及对各种类型dom的处理。

  • render:基于clone的节点生成canvas的处理方法。


基于以上这些核心文件,我们来简单了解一下html2canvas的解析过程, 大致的流程如下:


image.png



  • 构建配置项


在这一步会结合传入的options和一些defaultOptions,生成用于渲染的配置数据renderOptions。在过程中会对配置项进行分类,比如resourceOptions(资源跨域相关)、contextOptions(缓存、日志相关)、windowOptions(窗口宽高、滚动配置)、cloneOptions(对指定dom的配置)、renderOptions(render结果的相关配置,包括生成图片的各种属性)等,然后分别将各类配置项传到下接下来的步骤中。



  • clone目标节点并获取样式和内容


在这一步中,会将目标节点到指定的dom解析方法中,这个过程会clone目标节点和其子节点,获取到节点的内容信息和样式信息,其中clone dom的解析方法也是比较复杂的,这里不做详细展开。获取到目标节点后,需要把克隆出来的目标节点的dom装载到一个iframe里,进行一次渲染,然后就可以获取到经过浏览器视图真实呈现的节点样式。



  • 解析目标节点


目标节点的样式和内容都获取到了之后,就需要把它所承载的数据信息转化为Canvas可以使用的数据类型。在对目标节点的解析方法中,递归整个DOM树,并取得每一层节点的数据,对于每一个节点而言需要绘制的部分包括边框、背景、阴影、内容,而对于内容就包含图片、文字、视频等。在整个解析过程中,对目标节点的所有属性进行解析构造,转化成为指定的数据格式,基础数据格式可见以下代码:


class ElementContainer {
// 所有节点上的样式经过转换计算之后的信息
readonly styles: CSSParsedDeclaration;
// 节点的文本节点信息, 包括文本内容和其他属性
readonly textNodes: TextContainer[] = [];
// 当前节点的子节点
readonly elements: ElementContainer[] = [];
// 当前节点的位置信息(宽/高、横/纵坐标)
bounds: Bounds;
flags = 0;
...
}

具体到不同类型的元素如图片、IFrame、SVG、input等还会extends ElementContainer拥有自己的特定数据结构,在此不详细贴出。



  • 构建内部渲染器


把目标节点处理成特定的数据结构之后,就需要结合Canvas调用渲染方法了,Canvas绘图需要根据样式计算哪些元素应该绘制在上层,哪些在下层,那么这个规则是什么样的呢?这里就涉及到CSS布局相关的一些知识。


默认情况下,CSS是流式布局的,元素与元素之间不会重叠。不过有些情况下,这种流式布局会被打破,比如使用了浮动(float)和定位(position)。因此需要需要识别出哪些脱离了正常文档流的元素,并记住它们的层叠信息,以便正确地渲染它们。


那些脱离正常文档流的元素会形成一个层叠上下文。元素在浏览器中渲染时,根据W3C的标准,所有的节点层级布局,需要遵循层叠上下文和层叠顺序的规则,具体规则如下:


image.png


在了解了元素的渲染需要遵循这个标准后,Canvas绘制节点的时候,需要生成指定的层叠数据,就需要先计算出整个目标节点里子节点渲染时所展现的不同层级,构造出所有节点对应的层叠上下文在内部所表现出来的数据结构,具体数据结构如下:


// 当前元素
element: ElementPaint;
// z-index为负, 形成层叠上下文
negativeZIndex: StackingContext[];
// z-index为0、auto、transform或opacity, 形成层叠上下文
zeroOrAutoZIndexOrTransformedOrOpacity: StackingContext[];
// 定位和z-index形成的层叠上下文
positiveZIndex: StackingContext[];
// 没有定位和float形成的层叠上下文
nonPositionedFloats: StackingContext[];
// 没有定位和内联形成的层叠上下文
nonPositionedInlineLevel: StackingContext[];
// 内联节点
inlineLevel: ElementPaint[];
// 不是内联的节点
nonInlineLevel: ElementPaint[];

基于以上数据结构,将元素子节点分类,添加到指定的数组中,解析层叠信息的方式和解析节点信息的方式类似,都是递归整棵树,收集树的每一层的信息,形成一颗包含层叠信息的层叠树。



  • 绘制数据


基于上面两步构造出的数据,就可以开始调用内部的绘制方法,进行数据处理和绘制了。使用节点的层叠数据,依据浏览器渲染层叠数据的规则,将DOM元素一层一层渲染到canvas中,其中核心具体源码如下:


async renderStackContent(stack: StackingContext): Promise<void> {
if (contains(stack.element.container.flags, FLAGS.DEBUG_RENDER)) {
debugger;
}
// 1. the background and borders of the element forming the stacking context.
await this.renderNodeBackgroundAndBorders(stack.element);
// 2. the child stacking contexts with negative stack levels (most negative first).
for (const child of stack.negativeZIndex) {
await this.renderStack(child);
}
// 3. For all its in-flow, non-positioned, block-level descendants in tree order:
await this.renderNodeContent(stack.element);
for (const child of stack.nonInlineLevel) {
await this.renderNode(child);
}
// 4. All non-positioned floating descendants, in tree order. For each one of these,
// treat the element as if it created a new stacking context, but any positioned descendants and descendants
// which actually create a new stacking context should be considered part of the parent stacking context,
// not this new one.
for (const child of stack.nonPositionedFloats) {
await this.renderStack(child);
}
// 5. the in-flow, inline-level, non-positioned descendants, including inline tables and inline blocks.
for (const child of stack.nonPositionedInlineLevel) {
await this.renderStack(child);
}
for (const child of stack.inlineLevel) {
await this.renderNode(child);
}
// 6. All positioned, opacity or transform descendants, in tree order that fall int0 the following categories:
// All positioned descendants with 'z-index: auto' or 'z-index: 0', in tree order.
// For those with 'z-index: auto', treat the element as if it created a new stacking context,
// but any positioned descendants and descendants which actually create a new stacking context should be
// considered part of the parent stacking context, not this new one. For those with 'z-index: 0',
// treat the stacking context generated atomically.
//
// All opacity descendants with opacity less than 1
//
// All transform descendants with transform other than none
for (const child of stack.zeroOrAutoZIndexOrTransformedOrOpacity) {
await this.renderStack(child);
}
// 7. Stacking contexts formed by positioned descendants with z-indices greater than or equal to 1 in z-index
// order (smallest first) then tree order.
for (const child of stack.positiveZIndex) {
await this.renderStack(child);
}
}

在renderStackContent方法中,首先对元素本身调用renderNodeContent和renderNodeBackgroundAndBorders进行渲染处理。


然后处理各个分类的子元素,如果子元素形成了层叠上下文,就调用renderStack方法,这个方法内部继续调用了renderStackContent,这就形成了对于层叠上下文整个树的递归。


如果子元素是正常元素没有形成层叠上下文,就直接调用renderNode,renderNode包括两部分内容,渲染节点内容和渲染节点边框背景色。


async renderNode(paint: ElementPaint): Promise<void> {
if (paint.container.styles.isVisible()) {
// 渲染节点的边框和背景色
await this.renderNodeBackgroundAndBorders(paint);
// 渲染节点内容
await this.renderNodeContent(paint);
}
}

其中renderNodeContent方法是渲染一个元素节点里面的内容,其可能是正常元素、文字、图片、SVG、Canvas、input、iframe,对于不同的内容也会有不同的处理。


以上过程,就是html2canvas的整体内部流程,在了解了大致原理之后,我们再来看一个更为详细的源码流程图,对上述流程进行一个简单的总结。


五、 常见问题总结


在使用html2canvas的过程中,会有一些常见的问题和坑,总结如下:


(一)截图不全


要解决这个问题,只需要在截图之前将页面滚动到顶部即可:


document.documentElement.scrollTop = 0;
document.body.scrollTop = 0;

(二)图片跨域


插件在请求图片的时候会有图片跨域的情况,这是因为,如果使用跨域的资源画到canvas中,并且资源没有使用CORS去请求,canvas会被认为是被污染了,canvas可以正常展示,但是没办法使用toDataURL()或者toBlob()导出数据,详情可参考:developer.mozilla.org/en-US/docs/…


解决方案:在img标签上设置crossorigin,属性值为anonymous,可以开启CROS请求。当然,这种方式的前提还是服务端的响应头Access-Control-Allow-Origin已经被设置过允许跨域。如果图片本身服务端不支持跨域,可以使用canvas统一转成base64格式,方法如下。


function getUrlBase64_pro( len,url ) {
//图片转成base64
var canvas = document.createElement("canvas"); //创建canvas DOM元素
var ctx = canvas.getContext("2d");
return new Promise((reslove, reject) => {
var img = new Image();
img.crossOrigin = "Anonymous";
img.onload = function() {
canvas.height = len;
canvas.width = len;
ctx.drawImage(img, 0, 0, len, len);
var dataURL = canvas.toDataURL("image/");
canvas = null;
reslove(dataURL);
};
img.onerror = function(err){
reject(err)
}
img.src = url;
});
}

(三)截图与当前页面有区别


方式一:如果要从渲染中排除某些elements,可以向这些元素添加data-html2canvas-ignore属性,html2cnavas会将它们从渲染中排除,例如,如果不想截图iframe的部分,可以如下:


html2canvas(ele,{
useCORS: true,
ignoreElements: (element: any) => {
if (element.tagName.toLowerCase() === 'iframe') {
return element;
}
return false;
},
})

方式二:可以将需要转化成图片的部分放在一个节点内,再把整个节点,透明度设置为0, 其他部分层级设置高一些,即可实现截图指定区域。


六、 小结


本文针对前端截图实现的方式,对两个开源库dom-to-image和html2canvas的使用和原理进行了简单的使用方式、实现原理方面,进行介绍和分析。


参考资料:


1.dom-to-image原理


2.html2image原理简述


3.浏览器端网页截图方案详解


4.html2canvas


5.html2canvas实现浏览器截图的原理(包含源码分析的通用方法)


作者:庚云
来源:juejin.cn/post/7400319811358818340
收起阅读 »

推荐一个小而全的第三方登录开源组件

大家好,我是 Java陈序员。 我们在企业开发中,常常需要实现登录功能,而有时候为了方便,就需要集成第三方平台的授权登录。如常见的微信登录、微博登录等,免去了用户注册步骤,提高了用户体验。 为了业务考虑,我们有时候集成的不仅仅是一两个第三方平台,甚至更多。这就...
继续阅读 »

大家好,我是 Java陈序员


我们在企业开发中,常常需要实现登录功能,而有时候为了方便,就需要集成第三方平台的授权登录。如常见的微信登录、微博登录等,免去了用户注册步骤,提高了用户体验。


为了业务考虑,我们有时候集成的不仅仅是一两个第三方平台,甚至更多。这就会大大的提高了工作量,那么有没有开源框架来统一来集成这些第三方授权登录呢?


答案是有的,今天给大家介绍的项目提供了一个第三方授权登录的工具类库


项目介绍


JustAuth —— 一个第三方授权登录的工具类库,可以让你脱离繁琐的第三方登录 SDK,让登录变得So easy!


JustAuth


JustAuth 集成了诸如:Github、Gitee、微博、钉钉、百度、Coding、腾讯云开发者平台、OSChina、支付宝、QQ、微信、淘宝、Google、Facebook、抖音、领英、小米、微软、今日头条、Teambition、StackOverflow、Pinterest、人人、华为、企业微信、酷家乐、Gitlab、美团、饿了么、推特、飞书、京东、阿里云、喜马拉雅、Amazon、Slack和 Line 等第三方平台的授权登录。


功能特色:



  • 丰富的 OAuth 平台:支持国内外数十家知名的第三方平台的 OAuth 登录。

  • 自定义 state:支持自定义 State 和缓存方式,开发者可根据实际情况选择任意缓存插件。

  • 自定义 OAuth:提供统一接口,支持接入任意 OAuth 网站,快速实现 OAuth 登录功能。

  • 自定义 Http:接口 HTTP 工具,开发者可以根据自己项目的实际情况选择相对应的HTTP工具。

  • 自定义 Scope:支持自定义 scope,以适配更多的业务场景,而不仅仅是为了登录。

  • 代码规范·简单:JustAuth 代码严格遵守阿里巴巴编码规约,结构清晰、逻辑简单。


安装使用


回顾 OAuth 授权流程


参与的角色



  • Resource Owner 资源所有者,即代表授权客户端访问本身资源信息的用户(User),也就是应用场景中的“开发者A”

  • Resource Server 资源服务器,托管受保护的用户账号信息,比如 Github
    Authorization Server 授权服务器,验证用户身份然后为客户端派发资源访问令牌,比如 Github

  • Resource ServerAuthorization Server 可以是同一台服务器,也可以是不同的服务器,视具体的授权平台而有所差异

  • Client 客户端,即代表意图访问受限资源的第三方应用


授权流程


OAuth 授权流程


使用步骤


1、申请注册第三方平台的开发者账号


2、创建第三方平台的应用,获取配置信息(accessKey, secretKey, redirectUri)


3、使用 JustAuth 实现授权登陆


引入依赖


<dependency>
<groupId>me.zhyd.oauth</groupId>
<artifactId>JustAuth</artifactId>
<version>{latest-version}</version>
</dependency>

调用 API


// 创建授权request
AuthRequest authRequest = new AuthGiteeRequest(AuthConfig.builder()
.clientId("clientId")
.clientSecret("clientSecret")
.redirectUri("redirectUri")
.build());
// 生成授权页面
authRequest.authorize("state");
// 授权登录后会返回code(auth_code(仅限支付宝))、state,1.8.0版本后,可以用AuthCallback类作为回调接口的参数
// 注:JustAuth默认保存state的时效为3分钟,3分钟内未使用则会自动清除过期的state
authRequest.login(callback);


说明:
JustAuth 的核心就是一个个的 request,每个平台都对应一个具体的 request 类。
所以在使用之前,需要就具体的授权平台创建响应的 request.如示例代码中对应的是 Gitee 平台。



集成国外平台



国外平台需要额外配置 httpConfig



AuthRequest authRequest = new AuthGoogleRequest(AuthConfig.builder()
.clientId("Client ID")
.clientSecret("Client Secret")
.redirectUri("应用回调地址")
// 针对国外平台配置代理
.httpConfig(HttpConfig.builder()
// Http 请求超时时间
.timeout(15000)
// host 和 port 请修改为开发环境的参数
.proxy(new Proxy(Proxy.Type.HTTP, new InetSocketAddress("127.0.0.1", 10080)))
.build())
.build());

SpringBoot 集成


引入依赖


<dependency>
<groupId>com.xkcoding.justauth</groupId>
<artifactId>justauth-spring-boot-starter</artifactId>
<version>1.4.0</version>
</dependency>

配置文件


justauth:
enabled: true
type:
QQ:
client-id: 10**********6
client-secret: 1f7d08**********5b7**********29e
redirect-uri: http://oauth.xkcoding.com/demo/oauth/qq/callback
union-id: false
WEIBO:
client-id: 10**********6
client-secret: 1f7d08**********5b7**********29e
redirect-uri: http://oauth.xkcoding.com/demo/oauth/weibo/callback
GITEE:
client-id: 10**********6
client-secret: 1f7d08**********5b7**********29e
redirect-uri: http://oauth.xkcoding.com/demo/oauth/gitee/callback
DINGTALK:
client-id: 10**********6
client-secret: 1f7d08**********5b7**********29e
redirect-uri: http://oauth.xkcoding.com/demo/oauth/dingtalk/callback
BAIDU:
client-id: 10**********6
client-secret: 1f7d08**********5b7**********29e
redirect-uri: http://oauth.xkcoding.com/demo/oauth/baidu/callback
CSDN:
client-id: 10**********6
client-secret: 1f7d08**********5b7**********29e
redirect-uri: http://oauth.xkcoding.com/demo/oauth/csdn/callback
CODING:
client-id: 10**********6
client-secret: 1f7d08**********5b7**********29e
redirect-uri: http://oauth.xkcoding.com/demo/oauth/coding/callback
coding-group-name: xx
OSCHINA:
client-id: 10**********6
client-secret: 1f7d08**********5b7**********29e
redirect-uri: http://oauth.xkcoding.com/demo/oauth/oschina/callback
ALIPAY:
client-id: 10**********6
client-secret: 1f7d08**********5b7**********29e
redirect-uri: http://oauth.xkcoding.com/demo/oauth/alipay/callback
alipay-public-key: MIIB**************DAQAB
WECHAT_OPEN:
client-id: 10**********6
client-secret: 1f7d08**********5b7**********29e
redirect-uri: http://oauth.xkcoding.com/demo/oauth/wechat_open/callback
WECHAT_MP:
client-id: 10**********6
client-secret: 1f7d08**********5b7**********29e
redirect-uri: http://oauth.xkcoding.com/demo/oauth/wechat_mp/callback
WECHAT_ENTERPRISE:
client-id: 10**********6
client-secret: 1f7d08**********5b7**********29e
redirect-uri: http://oauth.xkcoding.com/demo/oauth/wechat_enterprise/callback
agent-id: 1000002
TAOBAO:
client-id: 10**********6
client-secret: 1f7d08**********5b7**********29e
redirect-uri: http://oauth.xkcoding.com/demo/oauth/taobao/callback
GOOGLE:
client-id: 10**********6
client-secret: 1f7d08**********5b7**********29e
redirect-uri: http://oauth.xkcoding.com/demo/oauth/google/callback
FACEBOOK:
client-id: 10**********6
client-secret: 1f7d08**********5b7**********29e
redirect-uri: http://oauth.xkcoding.com/demo/oauth/facebook/callback
DOUYIN:
client-id: 10**********6
client-secret: 1f7d08**********5b7**********29e
redirect-uri: http://oauth.xkcoding.com/demo/oauth/douyin/callback
LINKEDIN:
client-id: 10**********6
client-secret: 1f7d08**********5b7**********29e
redirect-uri: http://oauth.xkcoding.com/demo/oauth/linkedin/callback
MICROSOFT:
client-id: 10**********6
client-secret: 1f7d08**********5b7**********29e
redirect-uri: http://oauth.xkcoding.com/demo/oauth/microsoft/callback
MI:
client-id: 10**********6
client-secret: 1f7d08**********5b7**********29e
redirect-uri: http://oauth.xkcoding.com/demo/oauth/mi/callback
TOUTIAO:
client-id: 10**********6
client-secret: 1f7d08**********5b7**********29e
redirect-uri: http://oauth.xkcoding.com/demo/oauth/toutiao/callback
TEAMBITION:
client-id: 10**********6
client-secret: 1f7d08**********5b7**********29e
redirect-uri: http://oauth.xkcoding.com/demo/oauth/teambition/callback
RENREN:
client-id: 10**********6
client-secret: 1f7d08**********5b7**********29e
redirect-uri: http://oauth.xkcoding.com/demo/oauth/renren/callback
PINTEREST:
client-id: 10**********6
client-secret: 1f7d08**********5b7**********29e
redirect-uri: http://oauth.xkcoding.com/demo/oauth/pinterest/callback
STACK_OVERFLOW:
client-id: 10**********6
client-secret: 1f7d08**********5b7**********29e
redirect-uri: http://oauth.xkcoding.com/demo/oauth/stack_overflow/callback
stack-overflow-key: asd*********asd
HUAWEI:
client-id: 10**********6
client-secret: 1f7d08**********5b7**********29e
redirect-uri: http://oauth.xkcoding.com/demo/oauth/huawei/callback
KUJIALE:
client-id: 10**********6
client-secret: 1f7d08**********5b7**********29e
redirect-uri: http://oauth.xkcoding.com/demo/oauth/kujiale/callback
GITLAB:
client-id: 10**********6
client-secret: 1f7d08**********5b7**********29e
redirect-uri: http://oauth.xkcoding.com/demo/oauth/gitlab/callback
MEITUAN:
client-id: 10**********6
client-secret: 1f7d08**********5b7**********29e
redirect-uri: http://oauth.xkcoding.com/demo/oauth/meituan/callback
ELEME:
client-id: 10**********6
client-secret: 1f7d08**********5b7**********29e
redirect-uri: http://oauth.xkcoding.com/demo/oauth/eleme/callback
TWITTER:
client-id: 10**********6
client-secret: 1f7d08**********5b7**********29e
redirect-uri: http://oauth.xkcoding.com/demo/oauth/twitter/callback
XMLY:
client-id: 10**********6
client-secret: 1f7d08**********5b7**********29e
redirect-uri: http://oauth.xkcoding.com/demo/oauth/xmly/callback
# 设备唯一标识ID
device-id: xxxxxxxxxxxxxx
# 客户端操作系统类型,1-iOS系统,2-Android系统,3-Web
client-os-type: 3
# 客户端包名,如果 clientOsType 为1或2时必填。对Android客户端是包名,对IOS客户端是Bundle ID
#pack-id: xxxx
FEISHU:
client-id: 10**********6
client-secret: 1f7d08**********5b7**********29e
redirect-uri: http://oauth.xkcoding.com/demo/oauth/feishu/callback
JD:
client-id: 10**********6
client-secret: 1f7d08**********5b7**********29e
redirect-uri: http://oauth.xkcoding.com/demo/oauth/jd/callback
cache:
type: default

代码使用


@Slf4j
@RestController
@RequestMapping("/oauth")
@RequiredArgsConstructor(onConstructor_ = @Autowired)
public class TestController {
private final AuthRequestFactory factory;

@GetMapping
public List<String> list() {
return factory.oauthList();
}

@GetMapping("/login/{type}")
public void login(@PathVariable String type, HttpServletResponse response) throws IOException {
AuthRequest authRequest = factory.get(type);
response.sendRedirect(authRequest.authorize(AuthStateUtils.createState()));
}

@RequestMapping("/{type}/callback")
public AuthResponse login(@PathVariable String type, AuthCallback callback) {
AuthRequest authRequest = factory.get(type);
AuthResponse response = authRequest.login(callback);
log.info("【response】= {}", JSONUtil.toJsonStr(response));
return response;
}

}

总结


JustAuth 集成的第三方授权登录平台,可以说是囊括了业界中大部分主流的应用系统。如国内的微信、微博、Gitee 等,还有国外的 Github、Google 等。可以满足我们日常的开发需求,开箱即用,可快速集成!


最后,贴上项目地址:


https://github.com/justauth/JustAuth

在线文档:


https://www.justauth.cn/

最后


推荐的开源项目已经收录到 GitHub 项目,欢迎 Star


https://github.com/chenyl8848/great-open-source-project

或者访问网站,进行在线浏览:


https://chencoding.top:8090/#/


大家的点赞、收藏和评论都是对作者的支持,如文章对你有帮助还请点赞转发支持下,谢谢!



作者:Java陈序员
来源:juejin.cn/post/7312060958175559743
收起阅读 »

fishhook--终于被我悟透了

iOS
fishhook 作为一个 hook 工具在 iOS 开发中有着高频应用,理解 fishhook 的基本原理对于一个高级开发应该是必备技能。很遗憾,在此之前虽然对 fishhook 的基本原理有过多次探索但总是一知半解,最近在整理相关知识点对 fishhook...
继续阅读 »

fishhook 作为一个 hook 工具在 iOS 开发中有着高频应用,理解 fishhook 的基本原理对于一个高级开发应该是必备技能。很遗憾,在此之前虽然对 fishhook 的基本原理有过多次探索但总是一知半解,最近在整理相关知识点对 fishhook 又有了全新的认识。如果你跟我一样对 fishhook 的原理不甚了解那这篇文章会适合你。


需要强调的是本文不会从 fishhook 的使用基础讲起,也会不对照源码逐行讲解,只会着重对一些比较迷惑知识点进行重点阐述,建议先找一些相关系列文章进行阅读,补充一些基本知识再回过头来阅读本文。



注1:所有代码均以 64 位 CPU 架构为例,后文不再进行特别说明


注2:请下载 MachOView 打开任意 Mach-O 文件同步进行验证


注3:Mach-O 结构头文件地址



MachO 文件结构


image.png


0x01


Mach-O 文件结构有三部分,第一部分是 header,描述 Mach-O 文件的关键信息。其数据结构如下:


struct mach_header_64 {
uint32_t magic; /* mach magic number identifier */
cpu_type_t cputype; /* cpu specifier */
cpu_subtype_t cpusubtype; /* machine specifier */
uint32_t filetype; /* type of file */
uint32_t ncmds; /* number of load commands */
uint32_t sizeofcmds; /* the size of all the load commands */
uint32_t flags; /* flags */
uint32_t reserved; /* reserved */
};

如上面结构体所示,Mach-O 文件 header 的关键信息包括:



  • cputype:当前文件支持的 CPU 类型

  • filetype:当前 MachO 的文件类型

  • ncmds: Load Command 的数量

  • sizeofcmds:所有 Command 的总大小


每个 iOS 的可执行文件、动态库都会从 header 开始加载到内存中。


0x02


第二部分是 Load Commands,Load Commands 有不同的类型,有的用于描述不同类型数据结构(在文件中的位置、大小、类型、限权等),有的单纯用来记录信息,比如记录:dyld 的路径、main 函数的地址、UUID 等,用于记录信息的 Command 一般不会出现在数据区(Data)内。


不同的类型的 Load Command 对应着不同的结构体,但所有 Load Command 的前两个字段(cmd/cmdsize)都是相同的。所以,所有的 Load Command 都可以通过类型强转为 load_command 结构体类型。


有了 load_command 就可以通过每一个 Load Command 的 cmdsize 计算出下一个 Load Command 的位置。


struct load_command {
uint32_t cmd; /* type of load command */
uint32_t cmdsize;` /* total size of command in bytes */
};

struct segment_command_64 { /* for 64-bit architectures */
uint32_t cmd; /* LC_SEGMENT_64 */
uint32_t cmdsize; /* includes sizeof section_64 structs */
char segname[16]; /* segment name */
uint64_t vmaddr; /* memory address of this segment */
uint64_t vmsize; /* memory size of this segment */
uint64_t fileoff; /* file offset of this segment */
uint64_t filesize; /* amount to map from the file */
vm_prot_t maxprot; /* maximum VM protection */
vm_prot_t initprot; /* initial VM protection */
uint32_t nsects; /* number of sections in segment */
uint32_t flags; /* flags */
};

有文章说 load_command 是所有 Command 的基类,你也可以这样理解(虽然在代码语法层面不是)。


segment_command_64 作为一个 Load Command 重点类型,一般用来描述 __PAGEZERO、__TEXT、__DATA、__DATA_CONST 、__LINKEDIT 等包含实际代码数据的段(位于 Data 部分)。


因此对于 segment_command_64 类型的 Load Command 也称之为: segment


segment 内部还包含一个重要的类型:section,section 用于描述一组相同类型的数据。例如:所有代码逻辑都位于名为 __text 的 section 内,所有 OC 类名称都位于名为 __objc_classname 的 section 内,而这两个 section 均位于 __TEXT 段(segment)。


image.png


segment_command_64 关键字段介绍:



  • segname: 当前 segment 名称,可为 __PAGEZERO、__TEXT、__DATA、__DATA_CONST 、__LINKEDIT 之一

  • vmaddr: 当前 segment 加载到内存后的虚拟地址(实际还要加上 ALSR 偏移才是真实的虚拟地址)

  • vmsize: 当前 segment 占用的虚拟内存大小

  • fileoff: 当前 segment 在 Mach-O 文件中的偏移量,实际位置 = header 开始的地址 + fileoff

  • filesize: 当前 segment 在 Mach-O 文件中的实际大小,考虑到内存对齐 vmsize >= filesize

  • nsects: 当前 segment_command_64 下面包含的 section 个数



关于随机地址偏移(ALSR) 的相关容内可自行查找相关资料进行了解,这里不再贅述



section 只有一种类型,其结构体定义如下:


struct section_64 { /* for 64-bit architectures */
char sectname[16]; /* name of this section */
char segname[16]; /* segment this section goes in */
uint64_t addr; /* memory address of this section */
uint64_t size; /* size in bytes of this section */
uint32_t offset; /* file offset of this section */
uint32_t align; /* section alignment (power of 2) */
uint32_t reloff; /* file offset of relocation entries */
uint32_t nreloc; /* number of relocation entries */
uint32_t flags; /* flags (section type and attributes)*/
uint32_t reserved1; /* reserved (for offset or index) */
uint32_t reserved2; /* reserved (for count or sizeof) */
uint32_t reserved3; /* reserved */
};

section 关键字段介绍:



  • sectname: section 的名称,可以为 __text,__const,__bss 等

  • segname: 当前 section 所在 segment 名称

  • addr: 当前 section 在虚拟内存中的位置(实际还要加上 ALSR 偏移才是真实的虚拟地址)

  • size: 当前 section 所占据的大小(磁盘大小与内存大小)

  • reserved1: 不同 section 类型有不同的意义,一般代表偏移量与索引值

  • flags: 类型&属性标记位,fishhook 使用此标记查找懒加载表&非懒加载表


需要注意:有且仅有 segment_command_64 类型的 Command 包含 section。


0x03


最后是数据区(Data),就是 Mach-O 文件所包含的代码或者数据;所有代码或者数据都根据 Load Command 的描述进行组织、排列。其中由segment_command_64 描述的数据或代码在 Data 部分中均以 section 为最小单位进行组织,并且这部分内容占大头。segment 再加上其它类型 Load Command (其实就是 __LINKEDIT segement)描述的数据共同组成了数据区。


注意:虽然名称为 __LINKEDIT (类型为:segment_command_64) 的 segment 下面所包含的 section 数量为 0,但根据其 fileoff,filesize 计算发现:


__LINKEDIT 的 segement 所指向的文件范围其实包含其它 Load Command (包含但不限于:LC_DYLD_INFO_ONLY、LC_FUNCTION_STARTS、LC_SYMTAB、LC_DYSYMTAB、LC_CODE_SIGNATURE)所指向的位置范围。


推导过程如下:


image.png


image.png


如上图所示在 Load Commands 中 __LINKEDIT 在 Mach-O 文件的偏移:0x394000 大小为:0x5B510。而 Mach-O header 的开始地址为 0x41C000。所以 __LINKEDIT 在 Mach-O 文件中的地址范围是:{header + fileoffset, header + fileoffset + filesize},代入上式就是 {0x41C000+0x394000, 0x41C000+0x394000+0x5B510},最终得到 {0x7B0000,0x80B510} 的地址范围。


从下图看,segment 最后一个 section 结束后的第一个地址就是上面的开始的范围,文件的结束地址也是上面计算结果的结束范围(最后一个数据地址占 16 字节)。


image.png


image.png


所以可以这样理解:名称为 __LINKEDIT Load Command 是一个虚拟 Command。它用来指示LC_DYLD_INFO_ONLY、LC_FUNCTION_STARTS、LC_SYMTAB、LC_DYSYMTAB、LC_CODE_SIGNATURE 等这些 Command 描述的数据在「文件与内存」中的总范围,而这些 Command 自己本身又描述了自各的范围,从地址范围来看 __LINKEDIT 是这些 Command 在数据部分的父级,尽管它本身并没有 section。


yuque_diagram (1).png


fishhook 的四个关键表


fishhook 的实现原理涉及到四个「表」,理解这四个表之间的关系便能理解 fishhook 的原理,且保证过目不忘。



  • 符号表(Symbol Table)

  • 间接符号表(Indirect Symbol Table)

  • 字符表(String Table)

  • 懒加载和非懒加载表(__la_symbol_ptr/__non_la_symbol_ptr)


符号表&字符表


yuque_diagram (2).png


其中符号表(Symbol Table)与字符表(String Table)在 LC_SYMTAB 类型的 Load Command 中描述。


struct symtab_command {
uint32_t cmd; /* LC_SYMTAB */
uint32_t cmdsize; /* sizeof(struct symtab_command) */

uint32_t symoff; /* 符号表(Symbol Table)在文件中相对 header 的偏移 */
uint32_t nsyms; /* 符号表(Symbol Table)数量 */

uint32_t stroff; /* 字符表(String Table)在文件中相对 header 的偏移 */
uint32_t strsize; /* 字符串(String Table)表总大小*/
};

符号表(Symbol Table)内容的数据结构用 nlist_64 表示:


struct nlist_64 {
union {
uint32_t n_strx; /* index int0 the string table */
} n_un;
uint8_t n_type; /* type flag, see below */
uint8_t n_sect; /* section number or NO_SECT */
uint16_t n_desc; /* see <mach-o/stab.h> */
uint64_t n_value; /* value of this symbol (or stab offset) */
};

nlist_64 的第一个成员 n_un 代表当前符号的名称在字符表(String Table)中的相对位置,其它成员变量这里不需关注。


字符表(String Table)是一连串的字符 ASCII 码数据,每个字符串之间用 '\0' 进行分隔。


间接符号表


而间接符号表(Indirect Symbol Table)在 dysymtab_command 结构体的 Load Command(类型为LC_DYSYMTAB)中描述。


struct dysymtab_command {
uint32_t cmd; /* LC_DYSYMTAB */
uint32_t cmdsize; /* sizeof(struct dysymtab_command) */

/* 省略部分字段 */

uint32_t indirectsymoff; /* 间接符号表相对 header 的偏移 */
uint32_t nindirectsyms; /* 间接符号表中符号数量 */

/* 省略部分字段 */
};

间接符号表本质是由 int32 为元素组成的数组,元素中存储的数值代表当前符号在符号表(Symbol Table)中的相对位置。


懒加载和非懒加载表


懒加载与非懒加载表位于 __DATA/__DATA_CONST segment 下面的 section 中。


image.png


image.png


懒加载与非懒加载表有如下特点:



  • 当前可执行文件或动态库引用外部动态库符号时,调用到对应符号时会跳转到懒加载与非懒加载表指定的地址执行

  • 懒加载表在符号第一次被调用时绑定,绑定之前指向桩函数,由桩函数完成符号绑定,绑定完成之后即为对应符号真实代码地址

  • 非懒加载表在当前 Mach-O 被加载到内存时由 dyld 完成绑定,绑定之前非懒加载表内的值为 0x00,绑定之后同样也为对应符号的真实代码地址


敲黑板知识点:fishhook 的作用就是改变懒加载和非懒加载表内保存的函数地址


由于懒加载和非懒加载表没有包含任何符号字符信息,我们并不能直接通过懒加载表和非懒加载表找到目标函数在表中对应的位置,也就无法进行替换。因此,需要借助间接符号表(Indirect Symbol Table)、符号表(Symbol Table)、字符表(String Table)三个表之间的关系找到表中与之对应的符号名称来确认它的位置。


如何找到目标函数地址


这里借用一下 fishhook 官方给的示意图,可以先自行理解一下再往下看:


image.png


引用外部函数时需要通过符号名称来确定函数地址在懒加载和非懒加载表的位置,具体过程如下:



  1. 懒加载表与非懒加载表中函数地址的索引与间接符号表(Indirect Symbol Table)中的位置对应;


    以表中第 i 个函数地址为例,对应关系可以用伪公式来表述:


    间接符号表的偏移 = 间接符号表开始地址 + 懒加载表或非懒加载表指定的偏移(所在 section 的 reserved1 字段)+ i


  2. 间接符号表中保存的 int32 类型的数组,以上一步计算到的「间接符号表的偏移」为索引取数组内的值得到符到号中的位置


    同样得到一个等效伪公式:符号表的偏移 = 间接符号表开始地址 + 间接符号表的偏移


  3. 符号表中保存的数据是 nlist_64 类型,该第一个字段(n_un.n_strx)的值就是当前符号名称在字符表中的偏移


    等效伪公式:符号名称在字符表中的偏移 = (符号表的开始地址 + 符号表的偏移).n_un.n_strx


  4. 按照上面得到的偏移,去字符表中取出对应字符串(以 \0)结尾


    等效伪公式:懒加载表与非懒加载表中第 i 个函数名 = 字符表的开始地址 + 符号名称在字符表中的偏移



到这里我们从下至上进行公式代入,合并三个伪公式得到:


懒加载表或非懒加载表中第 i 个函数名 = 字符表的开始地址 + (符号表的开始地址 + 间接符号表开始位置 + 懒加载表或非懒加载表指定的偏移(所在 section 的 reserved1 字段)+ i).n_un.n_strx


现在,上面这个公式里还不知道的是三个开始地址:



  • 字符表(String Table)的开始地址

  • 符号表(Symbol)的开始地址

  • 间接符号表(Indirect Symbol Table)开始地址


而懒加载表或非懒加载表中函数地址个数也可以通过对应 section 的 size 字段(详情查看上文 section_64 结构体中的描述)计算而得到,公式:(section->size / sizeof(void *))。


到这里 fishhook 四个表的关系应该非常清楚了,fishhook 所做的无非是通过这个公式在懒加载表与非懒加载表中找到与目标函数名匹配的外部函数,一旦发现匹配则将其地址改为自定义的函数地址。


何为 linkedit_base


如果不考虑其它因素,实际上面三个表的开始地址可以直接通过 Mach-O 的 header 地址 + 对应的偏移就可以直接得到。以符号表(Symbol Table)为例:


image.png


Mach-O header 的开始地址如上文所述为:0x41C000,计算 0x41C000 + 0x3BECD8 = 0x7DACD8;再用 MachOView 查看这个地址,确实是符号表在文件中的位置:


image.png


同时上面的的推导也证明了 symtab_command->symoff symtab_command->stroff 是相对 Mach-O header 的偏移,并不是相对 __LINKEDIT 的偏移;


而 fishhook 源码中计算符号表开始地址的方式是:


nlist_t *symtab = (nlist_t *)(linkedit_base + symtab_cmd->symoff);

导致不少博文说 linkedit_base 是 __LINKEDIT 段的基地址,symoff 是相对 __LINKEDIT segment 的偏移,这完全是错误的,在此可以明确的是:



  • linkedit_base 并不是 __LINKEDIT segment 在内存中的开始地址

  • linkedit_base 并不是 __LINKEDIT segment 在内存中的开始地址

  • linkedit_base 并不是 __LINKEDIT segment 在内存中的开始地址


fishhook 中计算 linkedit_base 的计算方式如下:


uintptr_t linkedit_base = (uintptr_t)slide + linkedit_segment->vmaddr - linkedit_segment->fileoff;

忽略掉随机地址偏移(ALSR)值: slide 后:


linkedit_base = linkedit_segment->vmaddr - linkedit_segment->fileoff;


linkedit_segment->vmaddr:代表 __LINKEDIT segment 在「虚拟内存」中的相对开始位置
linkedit_segment->fileoff:代表 __LINKEDIT segment 在「文件」中的相对开始位置


那这两个相减有什么意义呢?


要解答这个问题先来看 MachOView 给出的信息:


image.png


如上图,在 __LINKEDIT segment 之前的几个 segment (红框标记)可以解析出几个事实:



  • 每个 segment 的在「 Mach-O 文件」中的开始地址都等于上一个 segment 的 File Offset + File Size,第一个 segment 从 0 开始

  • 同理,每个 segment 在「虚拟内存」中的位置都等于上一个 segment 的 VM Address + VM Size,第一个 segment 从 0 开始

  • __PAGEZERO_DATAVM Size > File Size,而其它 segment 中这两个值相等,意味着两个 segment 加载到虚拟内存中后有一部分「空位」(因内存对齐而出现)

  • __PAGEZERO 不占 Mach-O 文件的存储空间,但在虚拟内存在占 16K 的空间


用图形表示即为:


image.png


故而 linkedit_base = linkedit_segment->vmaddr - linkedit_segment->fileoff 的意义为:



  • Mach-O 加载到内存后 __LINKEDIT 前面的 segment 因内存对齐后多出来的空间(空位)

  • Mach-O 加载到内存后 __LINKEDIT 前面的 segment 因内存对齐后多出来的空间(空位)

  • Mach-O 加载到内存后 __LINKEDIT 前面的 segment 因内存对齐后多出来的空间(空位)


这才是 linkedit_base 在物理上的真正意义,任何其它的定义都是错误的。


image.png


__LINKEDIT 本身的 VM Size == File Size 说明它包含的符号表、字符表与间接符号表三个表本身是内存对齐的,它们之间没有空位,所以它们本身在文件中的偏移 + linkedit_base 即为在内存中的实际位置。


  // 符号表在内存中的开始位置
nlist_t *symtab = (nlist_t *)(linkedit_base + symtab_cmd->symoff);
// 字符表在内存中的开始位置
char *strtab = (char *)(linkedit_base + symtab_cmd->stroff);
// 间接符号表在内存中的开始位置
uint32_t *indirect_symtab = (uint32_t *)(linkedit_base + dysymtab_cmd->indirectsymoff);

最后


fishhook 在 APM、防逆向、性能优化等方向均有较多的应用,从本质上来看 fishhook 是对 Mach-O 文件结构的深度应用。相信在了解完原理之后再去看 Mach-O 文件的结构就比较简单了,与 Mach-O 文件结构相关的应用还有符号表的还原。下篇文章再与大家共同学习符号表还原的具体过程(虽然文件夹还没有创建 😂)。


如对本文有任何疑问,我们评论区交流 😀


作者:码不理
来源:juejin.cn/post/7360980866796388362
收起阅读 »