prop_c.setProperty(key, value);

public synchronized V put(K key, V value) {

    // Make sure the value is not null

    if (value == null) {

        throw new NullPointerException();

    }

    }

role.haveRole("ADMIN_USE")

3. 日志打印居然sout和log混合双打

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

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

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

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

<type>pom

来解决这个问题，但是公司内的，而且实际也是引入这个pom里面的jar的，我实在不知道这么做的用意是什么，有谁知道；求教 

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

那有什么优点呢：

解决之道

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

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

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

先赞后看，南哥助你Java进阶一大半

geeksforgeeks.org官网给出了Facebook评论系统的高级设计图，Facebook的评论竟然是支持实时刷新的。也就是说用户不用刷新帖子，只要帖子有新的评论就会自动推送到用户端，这里Facebook使用的便是每天在全球有超过20亿设备在使用的WebSocket技术。

我是南哥，一个Java学习与进阶的领路人。

相信对你通关面试、拿下Offer进入心心念念的公司有所帮助。

⭐⭐⭐本文收录在《Java学习/进阶/面试指南》：https://github/JavaSouth

精彩文章推荐

• 面试官没想到一个ArrayList，我都能跟他扯半小时


• 《我们一起进大厂》系列-Zookeeper基础


• 再有人问你WebSocket为什么牛逼，就把这篇文章发给他！


• 全网把Kafka概念讲的最透彻的文章，别无二家


• 可能是最漂亮的Java I/O流详解

1. 评论系统设计

1.1 评论表如何设计

评论系统的表要这么设计，每条评论的id标识要么是根评论id、要么是回复评论id。如果是根评论，那parent_comment_id字段就为空；而回复别人的评论，parent_comment_id字段指向根评论id。

CREATE TABLE `comments` (

  `comment_id` INT AUTO_INCREMENT PRIMARY KEY,  -- 评论唯一ID

  `user_id` INT NOT NULL,                       -- 用户ID

  `content` TEXT NOT NULL,                      -- 评论内容

  `parent_comment_id` INT DEFAULT NULL,         -- 如果是回复，则指向原始评论ID

  `post_id` INT NOT NULL,                       -- 被评论的帖子或内容ID

  `like_count` INT DEFAULT 0,                   -- 点赞数量

  `create_time` TIMESTAMP DEFAULT CURRENT_TIMESTAMP,  -- 评论创建时间

);

我们还要给评论加上点赞数，南哥给大家看看抖音的评论设计。

用户可以给每条评论打上点赞，所以我们应该再设计一个点赞表。其实抖音这种评论模式叫嵌套式评论结构，嵌套式评论注重用户对话交流，用户可以很方便地查看一个对话里的所有回复，我们看下抖音评论里有着展开10条回复的按钮。

其他评论模式设计还有平铺式评论结构，像微信朋友圈，或者Github的issue都是平铺式评论结构。这种设计更适合用户关注重点在发布的内容本身，而不是对话。大家有没发现微信朋友圈的特点是对话比较少点，点赞反而更多。

来看看点赞表设计。

CREATE TABLE `comment_likes` (

  `user_id` INT NOT NULL,                       -- 点赞用户ID

  `comment_id` INT NOT NULL,                    -- 被点赞的评论ID

  `liked_timeMESTAMP DEFAULT CURRENT_TIMESTAMP,  -- 点赞时间

);

1.2 评论数据存储

抖音每天产生视频几百万、上千万，每个视频的评论高的甚至有上万条评论，要怎么样的数据查询设计才能支持每天亿级的评论？

南哥先假设我们用MySQL作为实际的数据存储，这么高的并发肯定不能让查询直接冲击数据库 。再分库分表也是没用。

Elasticsearch官网这么宣传它的产品：

Elasticsearch 极其快速，快到不可思议

当用户发表评论时，我们首先把评论写入MySQL数据库，再使用异步机制把评论同步到Elasticsearch中。当在用户请求查询评论时，优先从 Elasticsearch 中进行查询。

// 评论存储到MySQL、Elasticsearch

public void storeComment(Comment comment) {

    // 将评论存入 MySQL

    commentRepository.save(comment);



    // 异步将评论同步到 Elasticsearch

    CompletableFuture.runAsync(() -> {

        elasticsearchService.indexComment(comment);

    });

}

1.3 事务控制

大家想一想以上设计，有哪些需要进行事务控制？

例如comment_likes点赞表的插入和comment评论表的更新，用户为某一个评论点赞，会在comment_likes表插入一条新记录，同时会更新comment表的点赞数量。

但是，从用户需求的角度来看，用户并不在意点赞数的强一致性和实时性，这点不使用事务也可以接受。

我曾经和老外程序员在论坛聊过，他说他们的点赞后端分布式服务用的本地缓存，即使每一个服务的本地缓存相对不太一致，对系统完全没有影响。

// 事务控制

@Transactional

public void likeComment(int commentId, int userId) {

    // 插入一条点赞记录

    commentLikesRepository.insert(userId, commentId);



    // 更新评论表中的点赞数量，假设有一个专门的方法来处理这个更新

    commentRepository.incrementLikeCount(commentId);

}

1.4 点赞数加入Redis

点赞数相比评论来说，量更加巨大，用户点赞时直接落到MySQL数据库肯定不合理，服务器扛不住也没必要扛。

假如点赞数没有进行事务控制。南哥打算这样处理，用户点赞后，后端服务接受到点赞请求，把用户内容、点赞数放到Redis里，这里采用Redis五大基本类型之一：Map。

// Map结构

comment_like_key = [comment_id_6:like_count = 66, comment_id_7:like_count = 77]

我们需要查询点赞数时直接从高性能内存数据库Redis查询。

当然这还没完，MySQL数据库和Elasticsearch的点赞量需要去同步更新，我们设置定时任务每个一段时间完成数据同步任务。上文的comment_likes点赞记录表同样需要记录，把点赞放到Redis时进行异步添加点赞记录即可。

// 定时任务数据同步任务

@Scheduled(fixedRate = 10000)

public void syncLikes() {

    // 从 Redis 中读取最新的点赞数据

    Map<Integer, Integer> likes = redisService.fetchAllLikes();



    // 同步到 MySQL 和 Elasticsearch

    likes.forEach((commentId, likeCount) -> {

        commentRepository.updateLikeCount(commentId, likeCount);

        elasticsearchService.updateLikeCount(commentId, likeCount);

    });

}

戳这，《JavaSouth》作为一份涵盖Java程序员所需掌握核心知识、面试重点的神秘文档。

我是南哥，南就南在Get到你的点赞点赞。

创作不易，不妨点赞、收藏、关注支持一下，各位的支持就是我创作的最大动力❤️

Visual Studio Code 是由微软开发的一款开源的代码编辑器，它有了一个丰富的插件市场，提供了很多实用的插件。本文就来分享 2024 年开发必备的 VS Code 插件！

功能强化

驼峰翻译助手

纠结怎么取变量? 中文一键翻译转换成常用大小驼峰等格式。

change-case

Change-case插件提供了一种简单的方法来将单词或变量名更改为各种情况，包括驼峰命名（camelCase）、下划线命名（snake_case）、标题命名（TitleCase）等多种格式。

Codelf

变量命名神器，搜索 Github、Bitbucket、Google Code、Codeplex、Sourceforge、Fedora Project、GitLab 中的项目以查找实际使用的变量名称。

Surround

用于在代码块周围添加包装代码片段。该插件支持语言标识符、多选区操作、完全可自定义、自定义包装代码片段，并为每个包装代码片段单独分配快捷键。

Duplicate Action

一键复制并创建文件或文件夹，提高了开发过程中的文件操作效率。

CSS Peek

它允许开发者直接从HTML文档中快速跳转到匹配的CSS样式定义，并提供预览功能，从而大大提高CSS样式的查找和编辑效率。

Regex Previewer

可以实时预览正则表达式匹配结果，并适用于多种前端框架和语言，同时提供快捷键操作、全局和多行选项等便捷功能，以提升开发效率。

Code Spell Checker

Code Spell Checker 插件可以检查单词拼写是否出现错误，检查的规则遵循 camelCase （驼峰拼写法）。

Markdown Preview Enhanced

支持实时预览 Markdown 文件效果，并具备导出 PDF、支持数学公式、流程图等多种高级功能，提供了丰富的定制选项和兼容性，极大地提升了 Markdown 文档的编辑和预览体验。

Markdown All in One

用于提供Markdown编辑的全方位支持，包括实时预览、语法提示、目录生成、表格生成等多种功能。

i18n-ally

主要用于国际化多语言开发，提供内联提示、快速修改key值对应的语言文件、统一管理翻译、自动翻译等功能。

GitHub Repositories

在 VS Code 中快速打开 Github 仓库，无需克隆到本地。

Turbo Console Log

一键生成有意义的 console.log 消息，支持多语言、多光标操作，提供可定制的日志类型和输出格式，提高调试效率。

indent-rainbow

一款代码缩进可视化插件，它通过为文本前面的缩进着色，使缩进更具可读性。

Remote-SSH

允许开发者通过 SSH 协议连接到远程服务器或虚拟机，直接在本地 VS Code 编辑器中操作远程服务器上的代码，实现无缝的远程开发体验。主要功能包括远程连接、无缝的代码编辑和调试、扩展兼容性、多种连接选项、优化的性能以及支持多个远程服务器同时连接等。

前端框架

ES7+ React/Redux/React-Native snippets

提供了许多速记前缀来加速开发并帮助开发人员为 React、Redux、GraphQL 和 React Native 创建代码片段和语法。

Typescript React Code Snippets

此插件包含了使用 Typescript 的 React 代码片段，它支持 Typescript(.ts) 或 TypeScript React (.tsx) 等语言。以下是使用 TypeScript 创建 React 组件的两个片段。

• 默认导出 React：

• 导出 React 组件：

Vue - Official

Vue 官方扩展。

Vue 3 Snippets

这个插件包含了所有的 Vue.js 2 和 Vue.js 3 的 api 对应的代码片段。

Vue VSCode Snippets

此插件将 Vue 2 Snippets 和 Vue 3 Snippets 添加到 Visual Studio Code 中。

React Native Tools

允许在不同的模拟器或仿真器上轻松运行和调试代码，从命令面板快速运行 react-native 命令，而无需在终端中手动运行命令，并使用 IntelliSense 浏览 React Native 的函数、对象和参数等。

JavaScript (ES6) code snippets

通过此插件可以使用预定义的 ES6 语法片段速记，从而提高开发效率。这个 VS Code 插件可以自定义，因为它不特定于任何框架。

Tailwind CSS IntelliSense

专为使用 Tailwind CSS 的开发者设计，提供实时的类名建议、自动完成、文档预览等功能，以提升 Tailwind CSS 的开发效率和代码质量。

Git 集成

GitLens

该插件增强了 VS Code 中的 Git，并从每个存储库中释放隐藏数据。可以快速查看代码的编写者、轻松导航和探索 Git 存储库、通过丰富的可视化效果和强大的比较命令获取有效信息，以及执行更多操作，帮助我们更好地理解代码。

Git History

该插件用于查看 Git 日志和文件历史记录并比较分支或提交。

Git Graph

Git Graph 插件用于可视化查看存储库的 Git 操作，并从图形中轻松执行Git操作。

统计分析

Import Cost

在项目中导入多个包时可能会出现性能问题，Import Cost 就用于查看将特定库导入项目的成本。该插件会显示导入库的大小，如果大小为绿色，则表示库很小，而红色表示库很大。

Time Master

从编程活动中自动生成的指标、见解和时间跟踪。它是一个开源项目，独立于网络环境，安全轻量。

VS Code Counter

VS Code Counter 插件用于统计项目代码的行数，安装插件之后，右键点击需要统计代码的文件夹，选择“Count lines in directory”，这时就会在项目根目录出现一个名为 .VSCodeCounter 的文件夹，包含了不同格式的结果，编辑器会打开其中的的 .md 格式。结果中会显示代码总行数，不同格式文件行数，不同路径文件函数等。代码行数中有纯代码行数、空白行数、注释行数。

AI 编程辅助

GitHub Copilot

GitHub Copilot 是 Github 推出的一款 AI 结对编程工具，可以帮助开发者更快、更智能地编写代码，不过该插件并不是免费的。

Tabnine

Tabnine 是一款 AI 代码助手，可加速和简化软件开发，同时保证代码的私密性、安全性和合规性。

Codeium

一个基于 AI 技术的免费代码加速工具包，为VSCode提供70多种语言的快速自动补全、聊天和搜索功能，支持IDE内聊天和多种编程语言的建议。

TONGYI Lingma

通义灵码是阿里云推出的一款基于通义大模型的智能编码辅助工具，提供实时续写、自然语言生成代码、单元测试生成、代码注释生成、代码解释、研发智能问答、异常报错排查等能力。

CodeGeeX

CodeGeeX 是一款基于大模型的智能编程助手，它完善了代码的生成与补全，自动为代码添加注释，此外，它还针对代码问题的智能问答，当然还包括代码解释，实现代码，修复代码bug等非常丰富的功能。

代码美化

Highlight Matching Tag

用于实时高亮显示匹配的标签对，方便用户在 HTML 或 XML 代码中快速找到配对的标签。它可以在点击一个标签时，自动显示配对的标签，并通过下划线或其他样式来指示它们之间的对应关系。

TODO Highlight

实时高亮显示代码中的TODO、FIXME等标记，支持自定义关键字和正则表达式匹配，方便开发者快速识别、管理和追踪待办事项。

Todo Tree

用于在Visual Studio Code中搜索、管理和高亮代码中的待办事项标记（如TODO、FIXME等）。它支持自定义标签、颜色编码、实时更新、过滤与排序等功能，并以可视化的树形结构展示待办事项列表，方便开发者快速定位、编辑和跟踪代码中的待办事项。

Better comments

该插件对不同类型的注释会附加了不同的颜色，更加方便区分，帮助我们在代码中创建更人性化的注释。

Colorize

Colorize 会给颜色代码增加一个当前匹配代码颜色的背景。它通过 CSS 变量、预处理器变量、hsl/hsla 颜色、跨浏览器颜色、exa、rgb、rgba和argb的彩色背景将 CSS 颜色可视化，帮助开发者快速区分颜色。

Image preview

通过此插件，当鼠标悬浮在图片的链接上时，可以实时预览该图片，除此之外，还可以看到图片的大小和分辨率。

CodeSnap

CodeSnap 用于对代码的进行截图和共享。屏幕截图可以用文本或形状进行注释，并通过链接共享或包含在网站或文档中。只需使用 ctrl + shift + P 并输入 CodeSnap，然后按回车键，CodeSnap 窗口就会打开。

Error Lens

Error Lens 是一款把代码检查(错误、警告、语法问题)进行突出显示的插件。Error Lens 通过使诊断更加突出，增强了语言的诊断功能，突出显示了由该语言生成的诊断所在的整行，并在代码行的位置以行方式在线打印了诊断消息。

Pretty TypeScript Errors

Pretty TypeScript Errors 旨在使 TypeScript 的错误信息更易读、更人性化。随着 TypeScript 类型复杂性的增加，错误消息可能会变得混乱不堪，充满了难以理解的括号和“...”。这个扩展通过重新格式化或解释 TypeScript 编译器产生的原始错误信息，来帮助开发者更容易地理解发生了什么。

编辑器美化

Power Mode

Power Mode 旨在通过添加视觉特效来增强编程体验，通过了诸如粒子效果、烟火、火焰、魔法效果等特效，让编程过程更加生动有趣。

One Dark Pro

一款编辑器主题。

Dracula Official

一款编辑器主题。

GitHub Theme

一款编辑器主题。

Winter Is Coming Theme

一款编辑器主题。

Ayu

一款编辑器主题。

vscode-icons

VSCode 官方出品的图标库。

Material Icon Theme

该插件根据最新的 Material Design 主题为文件和文件夹提供图标。它可以帮助我们识别文件并为编辑器添加自定义的外观。

Peacock

允许开发者为 Visual Studio Code 的工作区界面（如侧边栏、底栏和标题栏）自定义颜色，以区分不同的项目或编码环境。

你好呀，我是歪歪。

前几天我在网上冲浪，看到一个哥们在吐槽，说他工作三年多了，没使用过多线程。

虽然八股文背的滚瓜烂熟，但是没有在实际开发过程中写的都是业务代码，没有使用过线程池，心里还是慌得一比。

我只是微微一笑，这不是很正常吗？

业务代码中一般也使不上多线程，或者说，业务代码中不知不觉你以及在使用线程池了，你再 duang 的一下搞一个出来，反而容易出事。

所以提到线程池的时候，我个人的观点是必须把它吃得透透的，但是在业务代码中少用或者不用多线程。

关于这个观点，我给你盘一下。

Demo

首先我们还是花五分钟搭个 Demo 出来。

我手边刚好有一个之前搭的一个关于 Dubbo 的 Demo，消费者、生产者都有，我就直接拿来用了：

这个 Demo 我也是跟着网上的 quick start 搞的：

cn.dubbo.apache.org/zh-cn/overv…

可以说写的非常详细了，你就跟着官网的步骤一步步的搞就行了。

我这个 Demo 稍微不一样的是我在消费者模块里面搞了一个 Http 接口：

在接口里面发起了 RPC 调用，模拟从前端页面发起请求的场景，更加符合我们的开发习惯。

而官方的示例中，是基于了 SpringBoot 的 CommandLineRunner 去发起调用：

只是发起调用的方式不一样而已，其他没啥大区别。

需要说明的是，我只是手边刚好有一个 Dubbo 的 Demo，随手就拿来用了，但是本文想要表达的观点，和你使不使用 Dubbo 作为 RPC 框架，没有什么关系，道理是通用的。

上面这个 Demo 启动起来之后，通过 Http 接口发起一次调用，看到控制台服务提供方和服务消费方都有对应的日志输出，准备工作就算是齐活儿了：

上菜

在上面的 Demo 中，这是消费者的代码：

这是提供者的代码：

整个调用链路非常的清晰：

来，请你告诉我这里面有线程池吗？

没有！

是的，在日常的开发中，我就是写个接口给别人调用嘛，在我的接口里面并没有线程池相关的代码，只有 CRUD 相关的业务代码。

同时，在日常的开发中，我也经常调用别人提供给我的接口，也是一把梭，撸到底，根本就不会用到线程池。

所以，站在我，一个开发人员的角度，这个里面没有线程池。

合理，非常合理。

但是，当我们换个角度，再看看，它也是可以有的。

比如这样：

反应过来没有？

我们发起一个 Http 调用，是由一个 web 容器来处理这个请求的，你甭管它是 Tomcat，还是 Jetty、Netty、Undertow 这些玩意，反正是个 web 容器在处理。

那你说，这个里面有线程池吗？

在方法入口处打个断点，这个 http-nio-8081-exec-1 不就是 Tomcat 容器线程池里面的一个线程吗：

通过 dump 堆栈信息，过滤关键字可以看到这样的线程，在服务启动起来，啥也没干的情况下，一共有 10 个：

朋友，这不就是线程池吗？

虽然不是你写的，但是你确实用了。

我写出来的这个 test 接口，就是会由 web 容器中的一个线程来进行调用。所以，站在 web 容器的角度，这里是有一个线程池的：

同理，在 RPC 框架中，不管是消费方，还是服务提供方，也都存在着线程池。

比如 Dubbo 的线程池，你可以看一下官方的文档：

cn.dubbo.apache.org/zh-cn/overv…

而对于大多数的框架来说，它绝不可能只有一个线程池，为了做资源隔离，它会启用好几个线程池，达到线程池隔离，互不干扰的效果。

比如参与 Dubbo 一次调用的其实不仅一个线程池，至少还有 IO 线程池和业务线程池，它们各司其职：

我们主要关注这个业务线程池。

反正站在 Dubbo 框架的角度，又可以补充一下这个图片了：

那么问题来了，在当前的这个情况下？

当有人反馈：哎呀，这个服务吞吐量怎么上不去啊？

你怎么办？

你会 duang 的一下在业务逻辑里面加一个线程池吗？

大哥，前面有个 web 容器的线程池，后面有个框架的线程池，两头不调整，你在中间加个线程池，加它有啥用啊？

web 容器，拿 Tomcat 来说，人家给你提供了线程池参数调整的相关配置，这么一大坨配置，你得用起来啊：

tomcat.apache.org/tomcat-9.0-…

再比如 Dubbo 框架，都给你明说了，这些参数属于性能调优的范畴，感觉不对劲了，你先动手调调啊：

你把这些参数调优弄好了，绝对比你直接怼个线程池在业务代码中，效果好的多。

甚至，你在业务代码中加入一个线程池之后，反而会被“反噬”。

比如，你 duang 的一下怼个线程池在这里，我们先只看 web 容器和业务代码对应的部分：

由于你的业务代码中有线程池的存在，所以当接受到一个 web 请求之后，立马就把请求转发到了业务线程池中，由线程池中的线程来处理本次请求，从而释放了 web 请求对应的线程，该线程又可以里面去处理其他请求。

这样来看，你的吞吐量确实上去了。

在前端来看，非常的 nice，请求立马得到了响应。

但是，你考虑过下游吗？

你的吞吐量上涨了，下游同一时间处理的请求就变多了。如果下游跟不上处理，顶不住了，直接就是崩给你看怎么办？

而且下游不只是你一个调用方，由于你调用的太猛，导致其他调用方的请求响应不过来，是会引起连锁反应的。

所以，这种场景下，为了异步怼个线程池放着，我觉得还不如用消息队列来实现异步化，顶天了也就是消息堆积嘛，总比服务崩了好，这样更加稳妥。

或者至少和下游勾兑一下，问问我们这边吞吐量上升，你们扛得住不。

有的小伙伴看到这里可能就会产生一个疑问了：歪师傅，你这个讲得怎么和我背的八股文不一样啊？

巧了，你背过的八股文我也背过，现在我们来温习一下我们背过的八股文。

什么时候使用线程池呢？

比如一个请求要经过若干个服务获取数据，且这些数据没有先后依赖，最终需要把这些数据组合起来，一并返回，这样经典的场景：

用户点商品详情，你要等半天才展示给用户，那用户肯定骂骂咧咧的久走了。

这个时候，八股文上是怎么说的：用线程池来把串行的动作改成并行。

这个场景也是增加了服务 A 的吞吐量，但是用线程池就是非常正确的，没有任何毛病。

但是你想想，我们最开始的这个案例，是这个场景吗？

我们最开始的案例是想要在业务逻辑中增加一个线程池，对着一个下游服务就是一顿猛攻，不是所谓的串行改并行，而是用更多的线程，带来更多的串行。

这已经不是一个概念了。

还有一种场景下，使用线程池也是合理的。

比如你有一个定时任务，要从数据库中捞出状态为初始化的数据，然后去调用另外一个服务的接口查询数据的最终状态。

如果你的业务代码是这样的：

//获取订单状态为初始化的数据(0:初始化 1:处理中 2:成功 3:失败)

//select * from order where order_status=0;

ArrayList initOrderInfoList = queryInitOrderInfoList();

//循环处理这批数据

for(OrderInfo orderInfo : initOrderInfoList){

    //捕获异常以免一条数据错误导致循环结束

    try{

        //发起rpc调用

        String orderStatus = queryOrderStatus(orderInfo.getOrderId);

        //更新订单状态

        updateOrderInfo(orderInfo.getOrderId,orderStatus);  

    } catch (Exception e){

        //打印异常

    }

}

虽然你框架中使用了线程池，但是你就是在一个 for 循环中不停的去调用下游服务查询数据状态，是一条数据一条数据的进行处理，所以其实同一时间，只是使用了框架的线程池中的一个线程。

为了更加快速的处理完这批数据，这个时候，你就可以怼一个线程池放在 for 循环里面了：

//循环处理这批数据

for(OrderInfo orderInfo : initOrderInfoList){

    //使用线程池

    executor.execute(() -> {

        //捕获异常以免一条数据错误导致循环结束

        try {

            //发起rpc调用

            String orderStatus = queryOrderStatus(orderInfo.getOrderId);

            //更新订单状态

            updateOrderInfo(orderInfo.getOrderId, orderStatus);

        } catch (Exception e) {

            //打印异常

        }

    });

}

需要注意的是，这个线程池的参数怎么去合理的设置，是需要考虑的事情。

同时这个线程池的定位，就类似于 web 容器线程池的定位。

或者这样对比起来看更加清晰一点：

定时任务触发的时候，在发起远程接口调用之前，没有线程池，所以我们可以启用一个线程池来加快数据的处理。

而 Http 调用或者 RPC 调用，框架中本来就已经有一个线程池了，而且也给你提供了对应的性能调优参数配置，那么首先考虑的应该是把这个线程池充分利用起来。

如果仅仅是因为异步化之后可以提升服务响应速度，没有达到串行改并行的效果，那么我更加建议使用消息队列。

好了，本文的技术部分就到这里啦。

下面这个环节叫做[荒腔走板]，技术文章后面我偶尔会记录、分享点生活相关的事情，和技术毫无关系。我知道看起来很突兀，但是我喜欢，因为这是一个普通博主的生活气息。

荒腔走板

不知道你看完文章之后，有没有产生一个小疑问：最开始部分的 Demo 似乎用处并不大？

是的，我最开始构思的行文结构是是基于 Demo 在源码中找到关于线程池的部分，从而引出其实有一些我们“看不见的线程池”的存在的。

原本周六我是有一整天的时间来写这篇文章，甚至周五晚上还特意把 Demo 搞定，自己调试了一番，该打的断点全部打上，并写完 Demo 那部分之后，我才去睡觉的，想得是第二天早上起来直接就能用。

按照惯例周六睡个懒觉的，早上 11 点才起床，自己慢条斯理的做了一顿午饭，吃完饭已经是下午 1 点多了。

本来想着在沙发上躺一会，结果一躺就是一整个下午。期间也想过起来写一会文章，坐在电脑前又飞快的躺回到沙发上，就是觉得这个事情索然无味，当下的那一刻就想躺着，然后无意识的刷手机，原本是拿来写文章中关于源码的部分的时间就这样浪费了。

像极了高中时的我，周末带大量作业回家，准备来个悬梁刺股，弯道超车，结果变成了一睡一天，捏紧刹车。

高中的时候，时间浪费了是真的可惜。

现在，不一样了。

荒腔走板这张图片，就是我躺在沙发上的时候，别人问我在干什么时随手拍的一张。

我并不为躺了一下午没有干正事而感到惭愧，浪费了的时间，才是属于自己的时间。

很久以前我看到别人在做一些浪费时间的事情的时候，我心里可能会嘀咕几句，劝人惜时。

这两年我不会了，允许自己做自己，允许别人做别人。

在电商系统或任何涉及订单操作的场景中，用户多次点击“提交订单”按钮可能会导致重复订单提交，造成数据冗余和业务逻辑错误，导致库存问题、用户体验下降或财务上的错误。因此，防止订单重复提交是一个常见需求。

常见的重复提交场景

防止重复提交的需求

常用解决方案

前端防重机制：在前端按钮点击时禁用按钮或加锁，防止用户多次点击。

后端幂等处理：

• 利用Token机制：在订单生成前生成一个唯一的Token，保证每个订单提交时只允许携带一次Token。


• 基于数据库的唯一索引：通过对订单字段（如订单号、用户ID）创建唯一索引来防止重复数据的插入。


• 分布式锁：使用Redis等分布式缓存加锁，保证同一时间只允许处理一个订单请求。

功能实践

Spring Boot 提供了丰富的工具和库，今天我们基于Spring Boot框架，可以利用 Token机制 和 Redis分布式锁 来防止订单的重复提交。

功能原理与技术实现

通过Redis的原子性操作，我们可以确保高并发情况下多个请求对同一个订单的操作不会冲突。

Token机制

Token机制是一种常见的防止重复提交的手段，通常的工作流程如下：

这种机制确保每次提交订单时都需要一个有效且唯一的Token，从而有效防止重复提交。

Redis分布式锁

在多实例的分布式环境中，Token机制可以借助 Redis 来实现更高效的分布式锁：

流程设计

功能实现

依赖配置（pom.xml）

<dependency>

    <groupId>org.springframework.boot</groupId>

    <artifactId>spring-boot-starter-data-redis</artifactId>

</dependency>

<dependency>

    <groupId>org.springframework.boot</groupId>

    <artifactId>spring-boot-starter-web</artifactId>

</dependency>

application. properties

# Thymeleaf ??

spring.thymeleaf.prefix=classpath:/templates/

spring.thymeleaf.suffix=.html

spring.thymeleaf.mode=HTML

spring.thymeleaf.encoding=UTF-8

spring.thymeleaf.cache=false



spring.redis.host=127.0.0.1

spring.redis.port=23456

spring.redis.password=pwd

订单Token生成服务

生成Token并存储到Redis： 当用户请求生成订单页面时，服务器生成一个唯一的UUID作为订单Token，并将其与用户ID一起存储在Redis中。

package com.example.demo.service;



import lombok.extern.slf4j.Slf4j;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.data.redis.core.RedisTemplate;

import org.springframework.stereotype.Service;



import java.util.UUID;

import java.util.concurrent.TimeUnit;



@Service

@Slf4j

public class OrderTokenService {



    @Autowired

    private RedisTemplate<String, String> redisTemplate;

    // 生成订单Token

    public String generateOrderToken(String userId) {

        String token = UUID.randomUUID().toString();

        // 将Token存储在Redis中，设置有效期10分钟

        redisTemplate.opsForValue().set("orderToken:" + userId, token, 10, TimeUnit.MINUTES);

        return token;

    }

    // 验证订单Token

    public boolean validateOrderToken(String userId, String token) {

        String redisToken = redisTemplate.opsForValue().get("orderToken:" + userId);

        log.info("@@ 打印Redis中记录的redisToken ：{} `VS` @@ 打印当前请求过来的token ：{}", redisToken, token);

        if (token.equals(redisToken)) {

            // 验证成功，删除Token

            redisTemplate.delete("orderToken:" + userId);

            return true;

        }

        return false;

    }

}

订单控制器

订单提交与验证Token： 提交订单时，系统会检查用户传递的Token是否有效，若有效则允许提交并删除该Token，确保同一Token只能提交一次。

package com.example.demo.controller;



import com.example.demo.entity.Order;

import com.example.demo.service.OrderTokenService;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.http.HttpStatus;

import org.springframework.http.ResponseEntity;

import org.springframework.web.bind.annotation.*;



@RestController

@RequestMapping("/order")

public class OrderController {



    @Autowired

    private OrderTokenService orderTokenService;

    // 获取订单提交的Token

    @GetMapping("/getOrderToken")

    public ResponseEntity<String> getOrderToken(@RequestParam String userId) {

        String token = orderTokenService.generateOrderToken(userId);

        return ResponseEntity.ok(token);

    }

    // 提交订单

    @PostMapping("/submitOrder")

    public ResponseEntity<String> submitOrder(Order order) {

        // 校验Token

        if (!orderTokenService.validateOrderToken(order.getUserId(), order.getOrderToken())) {

            return ResponseEntity.status(HttpStatus.BAD_REQUEST).body("订单重复提交，请勿重复操作");

        }



        // 此处处理订单逻辑

        // ...

        

        // 假设订单提交成功

        return ResponseEntity.ok("订单提交成功");

    }

}

前端实现

前端通过表单提交订单，并在每次提交前从服务器获取唯一的订单Token：

<script>



    document.getElementById('orderForm').addEventListener('submit', function(event) {

    event.preventDefault();



    const userId = document.getElementById('userId').value;

    if (!userId) {

        alert("请填写用户ID");

        return;

    }



    // 先获取Token，再提交订单

    fetch(`/order/getOrderToken?userId=${userId}`)

        .then(response => response.text())

        .then(token => {

            document.getElementById('orderToken').value = token;



            // 提交订单请求

            const formData = new FormData(document.getElementById('orderForm'));

            fetch('/order/submitOrder', {

                method: 'POST',

                body: formData

            })

            .then(response => response.text())

            .then(result => {

                document.getElementById('message').textContent = result;

            })

            .catch(error => {

                document.getElementById('message').textContent = '订单提交失败，请重试';

            });

        })

        .catch(error => {

            document.getElementById('message').textContent = '获取Token失败';

        });

});



</script>

为了验证功能，我们在代码中增加 Thread.sleep(2000); 来进行阻塞。

然后快速点击提交表单，可以看到提示表单重复提价的信息

**技术选型与优化：**通过Redis结合Token机制，我们有效地防止了订单的重复提交，并通过Token的唯一性和时效性保证了订单操作的幂等性。

• Redis缓存：通过Redis的分布式锁和高并发处理能力，确保系统在高并发情况下仍然可以正常运行，并发订单提交的场景中不会出现Token重复使用问题。


• UUID：使用UUID生成唯一的Token，保证Token的唯一性和安全性。


• Token时效性：Token通过设置Redis的TTL（过期时间）来控制有效期，避免无效Token长期占用资源。

总结

防止订单重复提交的关键在于：

这套基于Token机制和Redis的解决方案具有简单、高效、可扩展的特点，适合各种高并发场景下防止重复订单提交。

前言

2024年9月17日，Java开发者们迎来了期待已久的JDK23版本。

下载地址：jdk.java.net/23/

文档地址：jdk.java.net/23/release-…

为 JDK 21 之后的第一个非 LTS 版本，最终的 12 个 JEP 特性包括：

JEP 455：模式、instanceof 和 switch 中的原始类型（Primitive Types in Patterns, instanceof, and switch，预览）

JEP 466：类文件 API（Class-File API，第二轮预览）

JEP 467：Markdown 文档注释（Markdown Documentation Comments）

JEP 469：Vector API（第八轮孵化）

JEP 471：废弃 sun.misc.Unsafe 中的内存访问方法以便于将其移除（Deprecate the Memory-Access Methods in sun.misc.Unsafe for Removal）

JEP 473：流收集器（Stream Gatherers，第二轮预览）

JEP 474：ZGC：默认的分代模式（ZGC: Generational Mode by Default）

JEP 476：模块导入声明（Module Import Declarations，预览）

JEP 477：隐式声明的类和实例主方法（Implicitly Declared Classes and Instance Main Methods，第三轮预览）

JEP 480：结构化并发（Structured Concurrency，第三轮预览）

JEP 481：作用域值（Scoped Values，第三轮预览）

JEP 482：灵活的构造函数体（: Flexible Constructor Bodies，第二轮预览）

基本上每次JDK的升级，在带来一些新功能的同时，也会提升一些性能。

一些优秀的语法，也能提升开发效率。

除了编程语言升级能提升开发效率之外，一些好的开发工具或者设备，也可以。

2 提升开发效率

显示器可以提升开发效率？

答：是真的。

2.1 屏幕尺寸

在之后的一段时间内，我尝试过一些不同品牌和型号的外接显示器。

常见的显示器的屏幕比是16:9。

而我现在正在用的明基RD280U显示器的屏幕比是3:2。

跟我的笔记本电脑屏幕相比，高度是笔记本电脑的两倍了。

我第一次使用时，就明显感觉到，明基RD240Q显示器的屏幕更高一些，一屏可以多看十几行代码。

在开发过程中，每次滚动屏幕，都可以多看几行代码，如果次数多了，可以多看很多行代码，真的可以提高开发效率。

2.2 专业编程模式

我后来才知道明基RD280U是一个专业的编程显示器，专门给程序员设计的。

屏幕正下方的这个按键，可以调整编程模式，可以优化IDE上代码的显示效果，让代码更加清晰：

2.3 背光灯

我们之前在晚上编程的时候，经常需要打开台灯，才能让屏幕看到更清楚。

为了解决这个问题，明基RD280U提供了Moonhalo背光灯的功能，下面这张图是我在关灯的情况下拍摄的：

可以看到屏幕有黄色的背景灯光。

下面的这张灯光图更直观：

可以让你沉浸在开发中，不被打扰。

3 全方位呵护

明基RD280U显示器使用了莱茵认证护眼技术，实现了：低蓝光、无屏闪的效果。

3.1 护眼模式

在夜间开发，可以切换夜间保护模式：

如果切换成自动模式，当外面环境变亮时，屏幕会自动变暗。当外面环境变暗时，屏幕会自动变暗。

保护我们的眼睛。

智慧蓝光模式是为了减少蓝光对眼睛的刺激，提供更舒适的视觉体验。

我们可以调节让自己眼睛感到舒服的蓝光。

3.2 抗反射面板

当我们的屏幕出现其他的灯光直射时，笔记本电脑的效果是这样的：

代码完全看不清楚。

而明基RD280U显示器，即使遇到强光也能看清代码。

这是我非常喜欢的设计。

4 软件协同

明基RD280U显示器为了方便我们操作，还提供了一个驱动软件：Display Pilot2。

里面包含了画面切换，快速搜索，桌面分区和键盘快速切换功能。

我们可以在电脑上直接控制显示器：

文章前面介绍的这些功能，都可以直接在电脑上通过Display Pilot2进行控制。

比如开启显示器的Moonhalo背光灯。

新增的flow功能可以设置特定时间场景下的一些显示器的参数。

5 总结

本文主要介绍了JDK23的12项新特性，涵盖了语言预览、API增强、性能优化等多个方面，可能会对开发者的工作流程和编程习惯产生深远的影响。

同时也介绍了我正在使用的明基RD280U显示器的一些优秀的功能，比如：屏幕尺寸更大、专业编程模式、Moonhalo背光灯、护眼功能（夜间防护功能、智慧蓝光）、抗反射面板、display pilot2功能，能够提升开发效率和保护我们的眼睛。

早上刚来，就看到仓库那边不停发消息说，我们的某个功能用不了了。赶紧放下早餐加紧看。

原来是调的一个三方接口报错了：

javax.net.ssl.SSLHandshakeException: sun.security.validator.ValidatorException: PKIX path building failed: sun.security.provider.certpath.SunCertPathBuilderException: unable to find valid certification path to requested target

	at sun.security.ssl.Alert.createSSLException(Alert.java:131)

	at sun.security.ssl.TransportContext.fatal(TransportContext.java:353)

	at sun.security.ssl.TransportContext.fatal(TransportContext.java:296)

	at sun.security.ssl.TransportContext.fatal(TransportContext.java:291)

	at sun.security.ssl.CertificateMessage$T12CertificateConsumer.checkServerCerts(CertificateMessage.java:652)

	at sun.security.ssl.CertificateMessage$T12CertificateConsumer.onCertificate(CertificateMessage.java:471)

	at sun.security.ssl.CertificateMessage$T12CertificateConsumer.consume(CertificateMessage.java:367)

	at sun.security.ssl.SSLHandshake.consume(SSLHandshake.java:376)

	at sun.security.ssl.HandshakeContext.dispatch(HandshakeContext.java:444)

	at sun.security.ssl.HandshakeContext.dispatch(HandshakeContext.java:422)

	at sun.security.ssl.TransportContext.dispatch(TransportContext.java:183)

	at sun.security.ssl.SSLTransport.decode(SSLTransport.java:154)

	at sun.security.ssl.SSLSocketImpl.decode(SSLSocketImpl.java:1279)

	at sun.security.ssl.SSLSocketImpl.readHandshakeRecord(SSLSocketImpl.java:1188)

	at sun.security.ssl.SSLSocketImpl.startHandshake(SSLSocketImpl.java:401)

	at sun.security.ssl.SSLSocketImpl.startHandshake(SSLSocketImpl.java:373)

查看原因：

由于JVM默认信任证书不包含该目标网站的SSL证书，导致无法建立有效的信任链接。

奥...原来是他们把接口从http改为了https,导致我们获取数据报错了。再看看他们的证书，奥...新的。

好了，看看我们的逻辑，这其实是一个获取对方生成的PDF文件的接口

PdfReader pdfReader = new PdfReader(url);

url就是他们给的链接，是这行代码报的错。这时候，开始研究，在网上扒拉，找到了初版方案

尝试1

写一个程序专门获取安全证书，这代码有点长，全贴出来影响阅读。我给扔我hithub上了github.com/lukezhao6/I… 将这个文件贴到本地，执行javac InstallCert.java将其进行编译

编译完长这样：

然后再执行java InstallCert http://www.baidu.com （这里我们用百度举例子，实际填写的就是你想要获取证书的目标网站）

报错不用怕，因为它会去检查目标服务器的证书，如果出现了SSLException,表示证书可能存在问题，这时候会把异常信息打印出来。

在生成的时候需要输入一个1

这样，我们需要的证书文件就生成好了

这时候，将它放入我们本地的 jdk的lib\security文件夹内就行了

重启，这时候访问是没有问题了。阶段性胜利。

但是，但是。一顿操作下来，对于测试环境的docker，还有生产环境貌似不能这么操作。 放这个证书文件比较费事。

那就只能另辟蹊径了。

尝试2

搜到了，还有两种方案。

1.通过System.setProperty("javax.net.ssl.trustStore", "你的jssecacerts证书路径");

2.程序启动命令-Djavax.net.ssl.trustStore=你的jssecacerts证书路径 -Djavax.net.ssl.trustStorePassword=changeit

我尝试了第一种，System.setProperty可以成功，但是读不到文件，权限什么的都是ok的。
检查了蛮多地方

• 路径格式问题


• 文件是否存在


• 文件权限


• 信任库密码


• 系统属性优先级

貌似都是没问题的，但肯定又是有问题的，因为没起作用。但是想着这样的接口有4个，万一哪天其他三个也改了，我又得来一遍。所以就算研究出来了，还是不能稳坐钓鱼台。有没有一了百了的方法嘞。

尝试3

还真找到了：这个错是因为对方网站的证书不被java信任么，那咱不校验了，直接全部信任。这样就算其他接口改了，咱也不愁。而且这个就是获取pdf，貌似安全性没那么重。那就开搞。

代码贴在了下方，上边的大概都能看懂吧，下方的我加了注释。

URL console = new URL(url);

HttpURLConnection conn = (HttpURLConnection) console.openConnection();

if (conn instanceof HttpsURLConnection)  {

    SSLContext sc = SSLContext.getInstance("SSL");

    sc.init(null, new TrustManager[]{new TrustAnyTrustManager()}, new java.security.SecureRandom());

    ((HttpsURLConnection) conn).setSSLSocketFactory(sc.getSocketFactory());

    ((HttpsURLConnection) conn).setHostnameVerifier(new TrustAnyHostnameVerifier());

}

conn.connect();

InputStream inputStream = conn.getInputStream();

PdfReader pdfReader = new PdfReader(inputStream);

inputStream.close();

conn.disconnect();

private static class TrustAnyTrustManager implements X509TrustManager {

    //这个方法用于验证客户端的证书。在这里，方法体为空，表示不对客户端提供的证书进行任何验证。

    public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {

    }

    //这个方法用于验证服务器的证书。同样，方法体为空，表示不对服务器提供的证书进行任何验证。

    public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {

    }

    //这个方法返回一个信任的证书数组。在这里，返回空数组，表示不信任任何证书，也就是对所有证书都不做任何信任验证。

    public X509Certificate[] getAcceptedIssuers() {

        return new X509Certificate[]{};

    }

}

//这个方法用于验证主机名是否可信。在这里，无论传入的主机名是什么，方法始终返回 true，表示信任任何主机名。这就意味着对于 SSL 连接，不会对主机名进行真实的验证，而是始终接受所有主机名。

private static class TrustAnyHostnameVerifier implements HostnameVerifier {

    public boolean verify(String hostname, SSLSession session) {

        return true;

    }

}

解决了解决了，这样改算是个比较不错的方案了吧。

如果你经常开发web类的的项目，那你一定经常会接触到后端服务，给项目找一个简单、好用的后端服务可以大大加速开发。

今天我们分享的开源项目，它可以作为SaaS或者是Mobile的后端服务，最简单情况只要一个文件，它就是：PocketBase

PocketBase 是什么

PocketBase是一个开源的Go后端框架，它以单个文件的形式提供了一个实时的后端服务。这个框架特别适合于快速开发小型到中型的Web应用和移动应用。它的设计哲学是简单性和易用性，使得开发者能够专注于他们的产品而不是后端的复杂性。

PocketBase包含以下功能：

• 内置数据库（SQLite）支持实时订阅


• 内置文件和用户管理


• 方便的管理面板 UI


• 简洁的 REST 风格 API

安装使用PocketBase

首先你可以下载PocketBase的预构建版本，你可以在github的release页面下载到对应平台的包。

下载后，解压存档并./pocketbase serve在解压的目录中运行。

启动完成后会3个web服务的路由：

• http://127.0.0.1:8090 - 如果存在pb_public目录，则提供其中的静态内容（html、css、图像等）


• http://127.0.0.1:8090/_/ - Admin的管理页面


• http://127.0.0.1:8090/api/ - Rest API

默认情况下，PocketBase 在端口上运行8090。但您可以通过在 serve 命令后附加--http和--https参数将其绑定到任何端口。

Admin panel

第一次访问管理仪表板 UI 时，它会提示您创建第一个管理员帐户。在管理页面里您可以完全使用 GUI 构建数据架构、添加记录并管理数据库。

API

它带有一个开箱即用的 API，可让您操作任何集合，还具有一个优雅的查询系统，可让您分页搜索记录。这将使您不必自己编写和维护同样无聊的 CRUD 操作，而可以更专注于产品特定的功能。

内置访问规则

PocketBase 可让您通过简单的语法直接从 GUI 定义对资源的访问规则。例如，这有助于定义访问范围和控制对用户特定数据的访问。同样，这将使您无需担心编写身份验证和授权代码。

SDK

使用PocketBase的API可以通过官方SDK，目前官方提供了JS SDK和Dart SDK。

• JavaScript - pocketbase/js-sdk (浏览器和nodejs)


• Dart - pocketbase/dart-sdk（网页、移动、桌面）

它们提供了用于连接数据库、处理身份验证、查询、实时订阅等的库，使开发变得简单。

开发定制应用

PocketBase 作为常规 Go 库包分发，允许您构建自己的自定义应用程序特定的业务逻辑，并且最后仍具有单个可移植的可执行文件。

这是一个简单的例子：

package main



import (

    "log"

    "net/http"



    "github.com/labstack/echo/v5"

    "github.com/pocketbase/pocketbase"

    "github.com/pocketbase/pocketbase/apis"

    "github.com/pocketbase/pocketbase/core"

)



func main() {

    app := pocketbase.New()



    app.OnBeforeServe().Add(func(e *core.ServeEvent) error {

        // add new "GET /hello" route to the app router (echo)

        e.Router.AddRoute(echo.Route{

            Method: http.MethodGet,

            Path:   "/hello",

            Handler: func(c echo.Context) error {

                return c.String(200, "Hello world!")

            },

            Middlewares: []echo.MiddlewareFunc{

                apis.ActivityLogger(app),

            },

        })



        return nil

    })



    if err := app.Start(); err != nil {

        log.Fatal(err)

    }

}

总结

整体来说PocketBase是一个非常不错的后端服务，它兼顾了易用性和定制的灵活性，如果你有项目的需要或是想要自己开发一个SAAS的服务，都可以选择它来试试。

项目信息

• 项目名称：pocketbase


• GitHub 链接：github.com/pocketbase/…


• Star 数：37K

今天给大家分享一个使用匿名结构体，提升Go编程效率的小技巧，属于在日常写代码过程中积累下来的一个提升自己效率的小经验。

这个技巧之所以提效率主要体现在两方面：

• 减少一些不会复用的类型定义


• 节省纠结该给类型起什么名字的时间

尤其第二项，通过匿名结构体这个名字就能体现出来，它本身没有类型名，这能节省不少想名字的时间。再一个也能减少起错名字给其他人带来的误解，毕竟并不是所有人编程时都会按照英文的词法做命名的。

下面我先从普通结构体说起，带大家看看什么情形下用匿名结构体会带来编码效率的提升。

具名结构体

具名结构体就是平时用的普通结构体。

结构体大家都知道，用于把一组字段组织在一起，来在Go语言里抽象表达现实世界的事物，类似“蓝图”一样。

比如说定义一个名字为Car的结构体在程序里表示“小汽车”

// 定义结构体类型'car'

type car struct {

    make    string

    model   string

    mileage int

}

用到这个结构体的地方通过其名字引用其即可，比如创建上面定义的结构体的实例

// 创建car 的实例

newCar := car{

    make:    "Ford",

    model:   "taurus",

    mileage: 200000,

}

匿名结构体

匿名结构体顾名思义就是没有名字的结构体，通常只用于在代码中仅使用一次的结构类型，比如

func showMyCar() {

    newCar := struct {

        make    string

        model   string

        mileage int

    }{

        make:    "Ford",

        model:   "Taurus",

        mileage: 200000,

    }

    fmt.Printlb(newCar.mode)

}

上面这个函数中声明的匿名结构体赋值给了函数中的变量，所以只能在函数中使用。

如果一个结构体初始化后只被使用一次，那么使用匿名结构体就会很方便，不用在程序的package中定义太多的结构体类型，比如在解析接口的响应到结构体后，就可以使用匿名结构体

用于解析接口响应

func createCarHandler(w http.ResponseWriter, req *http.Request) {

    defer req.Body.Close()

    decoder := json.NewDecoder(req.Body)

    newCar := struct {

        Make    string `json:"make"`

        Model   string `json:"model"`

        Mileage int    `json:"mileage"`

    }{}

    err := decoder.Decode(&newCar)

    if err != nil {

        log.Println(err)

        return

    }

    ......

    return

}

类似上面这种代码一般在控制层写，可以通过匿名结构体实例解析到请求后再去创建对应的DTO或者领域对象供服务层或者领域层使用。

有人会问为什么不直接把API的响应解析到DTO对象里，这里说一下，匿名结构体的使用场景是在觉得定一个Struct 不值得、不方便的情况下才用的。 比如程序拿到接口响应后需要按业务规则加工下才能创建DTO实例这种情况，就很适合用匿名结构体先解析响应。

比用map更健壮

这里再说一点使用匿名结构体的好处。

使用匿名解析接口响应要比把响应解析到map[string]interface{}类型的变量里要好很多，json数据解析到匿名结构体的时候在解析的过程中会进行类型检查，会更安全。使用的时候直接通过s.FieldName访问字段也比map访问起来更方便和直观。

用于定义项目约定的公共字段

除了上面这种结构体初始化后只使用一次的情况，在项目中定义各个接口的返回或者是DTO时，有的公共字段使用匿名结构体声明类型也很方便。

一般在启动项目的时候我们都会约定项目提供的接口的响应值结构，比如响应里必须包含Code、Msg、Data三个字段，每个接口会再细分定义返回的Data的结构，这个时候用匿名结构题能节省一部分编码效率。

比如下面这个Reponse的结构体类型的定义

type UserCouponResponse struct {

 Code int64  `json:"code"`

 Msg  string `json:"message"`

 Data []*struct {

  CouponId           int    `json:"couponId"`

  ProdCode           string `json:"prodCode"`

  UserId             int64  `json:"userId"`

  CouponStatus       int    `json:"couponStatus"`

  DiscountPercentage int    `json:"discount"`

 } `json:"data"`

}

就省的先去定义一个UserCoupon类型

type UserCoupon struct {

    CouponId           int    `json:"couponId"`

    ProdCode           string `json:"prodCode"`

    UserId             int64  `json:"userId"`

    CouponStatus       int    `json:"couponStatus"`

    DiscountPercentage int    `json:"discount"`

} 

再在Response声明里使用定义的UserCoupon了

type UserCouponResponse struct {

    Code int64  `json:"code"`

    Msg  string `json:"message"`

    Data []*UserCoupon `json:"data"`

}

当然如果UserCoupon是你的项目其他地方也会用到的类型，那么先声明，顺带在Response结构体里也使用是没问题的，只要会多次用到的类型都建议声明成正常的结构体类型。

还是那句话匿名结构体只在你觉得"这还要定义个类型？”时候使用，用好的确实能提高点代码生产效率。

总结

本次的分享就到这里了，内容比较简单，记住这个口诀：匿名结构体只在你写代码时觉得这还要定义个类型，感觉没必要的时候使用，采纳这个技巧，时间长了还是能看到一些自己效率的提高的。

前言

家里床头离开关太远了，每次躺在床上玩手机准备睡觉时候还的下去关灯，着实麻烦，所以用目前仅有的一点单片机知识，做了一个小小小的智能开关，他有三个模块构成，如下：

1. 主模块是ESP32（20元）

   他是一个低成本、低功耗的微控制器，集成了 Wi-Fi 和蓝牙功能，因为我们需要通过网络去开/关灯，还有一个ESP8266，比这个便宜，大概6 块钱，但是他烧录程序的时候比较慢。

2. 光电开关(10元)

   这个可有可无，这个是用来当晚上下班回家后，开门自动开灯使用的，如果在他前面有遮挡，他的信号线会输出高/低电压，这个取决于买的是常开还是常闭，我买的是常开，当有物体遮挡时，会输出低电压，所以当开门时，门挡住了它，它输出低电压给ESP32，ESP32读取到电压状态后触发开灯动作。

3. 舵机 SG90(5元)

   这是用来触发开/关灯动作的设备，需要把它用胶粘在开关上，他可以旋转0-180度，力度也还行，对于开关足够了。还有一个MG90舵机，力度特别大，但是一定要买180度的，360度的舵机只能正转和反转，不能控制角度。

4. 杜邦线(3元)

Arduino Ide

Arduino是什么就不说了，要烧录代码到ESP32，需要使用官方乐鑫科技提供的ESP-IDF工具，它是用来开发面向ESP32和ESP32-S系列芯片的开发框架，但是，Arduino Ide提供了一个核心，封装了ESP-IDF一些功能，便于我们更方便的开发，当然Arduino还有适用于其他开发板的库。

Arduino配置ESP32的开发环境比较简单，就是点点点、选选选即可。

接线

下面就是接线环节，先看下ESP32的引脚，他共有30个引脚，有25个GPIO(通用输入输出)引脚，如下图中紫色的引脚，在我们的这个设备里，舵机和光电开关都需要接入正负级到下图中的红色(VCC)和黑色(GND)引脚上，而他们都需要在接入一个信号作为输出/输入点，可以在着25个中选择一个，但还是有几个不能使用的，比如有一些引脚无法配置为输出，只用于作输入，还有RX和TX，我们这里使用26(光电开关)和27(舵机)引脚就可以了。

esp32代码

下面写一点点代码，主要逻辑很简单，创建一个http服务器，用于通过外部去控制舵机的转向，外部通过http请求并附带一个角度参数，在通过ESP32Servo这个库去使舵机角度发生改变。

esp32的wifi有以下几种模式。

1. Station Mode（STA模式）： 在STA模式下，esp32可以连接到一个wifi，获取一个ip地址，并且可以与网络中的其他设备进行通信。
2. Access Point Mode（AP模式）： 在AP模式下，它充当wifi热点，其他设备可以连接到esp32，就像连接到普通路由器一样，一般用作配置模式使用，经常买到的智能设备，进入配置模式和后，他会开一个热点，你的手机连接到这个热点后，在通过他们提供的app去配置，就是用这种模式。
3. Soft Access Point Mode（SoftAP模式）： 同时工作在STA模式和AP模式下。

下一步根据自己的逻辑，比如当光电开关被遮挡时，并且又是xxxx时，就开灯，或者当xxx点后就关灯。

#include 

#include 

#include 

#include 

#include 

#define SERVO_PIN_NUMBER 27

#define STATE_PIN_NUMBER 26

#define CLOSE_VALUE 40

#define OPEN_VALUE 150

const char* ssid = "wifi名称";

const char* password = "wifi密码";



AsyncWebServer server(80);

Servo systemServo;



bool openState = false;

void setup() {

  Serial.begin(115200);

  WiFi.mode(WIFI_AP_STA);

  WiFi.begin(ssid, password);

  Serial.println("\nConnecting");



  while (WiFi.status() != WL_CONNECTED) {

    Serial.print(".");

    delay(100);



  }

  systemServo.attach(SERVO_PIN_NUMBER);

  systemServo.write(90);

  openState = false;

  write_state(CLOSE_VALUE);//启动时候将灯关闭



  Serial.print("Local ESP32 IP: ");

  Serial.println(WiFi.localIP());

  pinMode(STATE_PIN_NUMBER, INPUT);

  int timezone = 8 * 3600;

  configTime(timezone, 0, "pool.ntp.org");



  server.on("/set_value", HTTP_GET, [](AsyncWebServerRequest * request) {

    if (request->hasParam("value")) {

      String value = request->getParam("value")->value();

      int intValue = value.toInt();

      write_state(intValue);

      request->send(200, "text/plain", "value: " + String(intValue));

    } else {

      request->send(400, "text/plain", "error");

    }

  });

  server.begin();

}



void write_state(int value) {

  openState = value < 90 ? false : true;



  systemServo.write(value);

  delay(100);

  systemServo.write(90);

}

void loop() {

  time_t now = time(nullptr);

  struct tm *timeinfo;

  timeinfo = localtime(&now);



  //指定时间关灯

  int currentMin = timeinfo->tm_min;

  int currentHour = timeinfo->tm_hour;

  if (currentHour == 23 && currentMin == 0 && openState ) {

    write_state(CLOSE_VALUE);

    openState = false;

  }

  //下班开灯

  if (digitalRead(STATE_PIN_NUMBER) == 0 && currentHour > 18 && !openState) {

    write_state(OPEN_VALUE);

    openState = true;

  }

}

Android下控制

当然，还得需要通过外部设备进行手动开关，这里就简单写一个Android程序，上面写了一个http服务，访问esp32的ip地址，发起一个http请求就可以了，所以浏览器也可以，但更方便的是app，效果如下。

package com.example.composedemo



import android.content.Context

import android.content.SharedPreferences

import android.os.Bundle

import android.util.Log

import android.view.View

import android.widget.TextView

import androidx.activity.ComponentActivity

import androidx.activity.compose.setContent

import androidx.compose.foundation.layout.Row

import androidx.compose.foundation.layout.fillMaxSize

import androidx.compose.material.*

import androidx.compose.runtime.*

import androidx.compose.ui.Modifier

import androidx.compose.ui.graphics.Color

import androidx.compose.ui.tooling.preview.Preview

import com.example.composedemo.ui.theme.ComposeDemoTheme

import kotlinx.coroutines.Dispatchers

import kotlinx.coroutines.GlobalScope

import kotlinx.coroutines.launch

import kotlinx.coroutines.withContext

import java.net.HttpURLConnection

import java.net.URL



class MainActivity : ComponentActivity() {

    private val state = State()

    private lateinit var sharedPreferences: SharedPreferences

    override fun onCreate(savedInstanceState: Bundle?) {

        super.onCreate(savedInstanceState)

        sharedPreferences = getPreferences(Context.MODE_PRIVATE)

        state.ipAddressChange = {

            with(sharedPreferences.edit()) {

                putString("ipAddress", it)

                apply()

            }

        }

        state.slideChange = {setValue(it) }

        state.lightChange = {

            Log.i(TAG, "onCreate: $it")

            if (it) openLight()

            if (!it) closeLight()

        }

        state.esp32IpAddress.value = sharedPreferences.getString("ipAddress", "")!!



        setContent {

            ComposeDemoTheme {

                Surface(

                    modifier = Modifier.fillMaxSize(),

                    color = MaterialTheme.colors.background

                ) {

                    SlidingOvalLayout(state)

                }

            }

        }

    }



    private fun closeLight() =setValue(40)



    private fun openLight() = setValue(150)



    private fun setValue(value: Int) {

        sendHttpRequest("http://${state.esp32IpAddress.value}/set_value/?value=$value:")

    }



    private fun sendHttpRequest(url: String) {

        GlobalScope.launch(Dispatchers.IO) {

            try {

                val connection = URL(url).openConnection() as HttpURLConnection

                connection.requestMethod = "GET"

                connection.connect()

                if (connection.responseCode == HttpURLConnection.HTTP_OK) {

                    val response = connection.inputStream.bufferedReader().readText()

                    withContext(Dispatchers.Main) {

                    }

                } else {

                    withContext(Dispatchers.Main) {

                    }

                }

                connection.disconnect()

            } catch (e: Exception) {

                e.printStackTrace()

                withContext(Dispatchers.Main) {

                }

            }

        }

    }

}





@Preview(showBackground = true)

@Composable

fun DefaultPreview() {

    ComposeDemoTheme {

    }

}

ui组件

package com.example.composedemo



import androidx.compose.foundation.background

import androidx.compose.foundation.clickable

import androidx.compose.foundation.layout.*

import androidx.compose.foundation.shape.RoundedCornerShape

import androidx.compose.material.*

import androidx.compose.runtime.*

import androidx.compose.ui.Alignment

import androidx.compose.ui.Modifier

import androidx.compose.ui.draw.shadow

import androidx.compose.ui.geometry.Offset

import androidx.compose.ui.graphics.Color

import androidx.compose.ui.graphics.graphicsLayer

import androidx.compose.ui.input.pointer.pointerInput

import androidx.compose.ui.layout.layout

import androidx.compose.ui.tooling.preview.Preview

import androidx.compose.ui.unit.Dp

import androidx.compose.ui.unit.IntOffset

import androidx.compose.ui.unit.dp

import com.example.composedemo.ui.theme.ComposeDemoTheme



const val TAG = "TAG"



@Composable

fun SlidingOvalLayout(state: State) {

    var offset by remember { mutableStateOf(Offset(0f, 0f)) }

    var parentWidth by remember { mutableStateOf(0) }

    var sliderValue by remember { mutableStateOf(0) }

    var closeStateColor by remember { mutableStateOf(Color(0xFFDF2261)) }

    var openStateColor by remember { mutableStateOf(Color(0xFF32A34B)) }

    Box(

        modifier = Modifier

            .fillMaxSize()

            .padding(40.dp)

            .width(100.dp)

    ) {

        Column(

            modifier = Modifier

                .fillMaxSize()

                .padding(16.dp),

            verticalArrangement = Arrangement.SpaceBetween,

            horizontalAlignment = Alignment.CenterHorizontally

        ) {

            Column {

                Box() {

                    TextField(

                        value = state.esp32IpAddress.value,

                        onValueChange = {

                            state.esp32IpAddress.value = it

                            state.ipAddressChange(it)

                        },

                        colors = TextFieldDefaults.textFieldColors(

                            disabledTextColor = Color.Transparent,

                            backgroundColor = Color(0xFFF1EEF1),

                            focusedIndicatorColor = Color.Transparent,

                            unfocusedIndicatorColor = Color.Transparent,

                            disabledIndicatorColor = Color.Transparent

                        ),

                        modifier = Modifier

                            .fillMaxWidth()

                            .background(color = Color(0xFFF1EEF1))

                    )



                }

                Box() {

                    Column() {

                        Text(text = sliderValue.toString())

                        Row(

                            verticalAlignment = Alignment.CenterVertically,

                            horizontalArrangement = Arrangement.spacedBy(8.dp)

                        ) {

                            Slider(

                                value = sliderValue.toFloat(),

                                onValueChange = {

                                    sliderValue = it.toInt()

                                    state.slideChange(sliderValue)},

                                valueRange = 0f..180f,

                                onValueChangeFinished = {



                                },

                                colors = SliderDefaults.colors(

                                    thumbColor = Color.Blue,

                                    activeTrackColor = Color.Blue

                                )

                            )

                        }

                    }



                }

            }

            Box(

                modifier = Modifier

                    .fillMaxWidth()

                    .height(70.dp)

                    .shadow(10.dp, shape = RoundedCornerShape(100.dp))

                    .background(color = Color(0xFFF1EEF1))

                    .layout { measurable, constraints ->

                        val placeable = measurable.measure(constraints)

                        parentWidth = placeable.width

                        layout(placeable.width, placeable.height) {

                            placeable.place(0, 0)

                        }

                    }

            ) {

                Box(

                    modifier = Modifier

                        .offset {

                            if (state.lightValue.value) {

                                IntOffset((parentWidth - 100.dp.toPx()).toInt(), 0)

                            } else {

                                IntOffset(0, 0)

                            }

                        }

                        .graphicsLayer {

                            translationX = offset.x

                        }

                        .clickable() {

                            state.lightValue.value = !state.lightValue.value

                            state.lightChange(state.lightValue.value )

                        }

                        .pointerInput(Unit) {

                        }

                        .background(

                            color = if(state.lightValue.value) openStateColor  else closeStateColor,

                            shape = RoundedCornerShape(100.dp)

                        )

                        .size(Dp(100f), Dp(80f))

                )

            }

        }

    }

}



@Preview

@Composable

fun PreviewSlidingOvalLayout() {

    ComposeDemoTheme {

    }

}

class State {

    var esp32IpAddress: MutableState = mutableStateOf("")

    var lightValue :MutableState<Boolean> = mutableStateOf(false)



    var ipAddressChange :(String)->Unit={}



    var slideChange:(Int)->Unit={}



    var lightChange:(Boolean)->Unit={}



}

作者：i听风逝夜
来源：juejin.cn/post/7292245569482407988