Posts on 进制动态

2026年AI大模型行业应用突破：从实验室到产业落地的关键进展

Sat, 02 May 2026 21:39:19 +0800

随着生成式AI技术的爆发式发展，2026年AI大模型已从实验室的理论探索走向产业落地的深度实践。在算力优化、数据治理与场景适配的三重驱动下，AI大模型在医疗、金融、制造等领域的应用呈现出突破性进展，正重塑传统行业的生产方式与服务模式。

从技术维度看，2026年AI大模型实现了从"通用能力"到"垂直优化"的跨越。以GPT-5、Claude-3等模型为代表，通过行业数据微调与知识图谱融合，模型在专业领域的准确率较通用模型提升30%-50%。例如，医疗领域的AI模型可通过整合千万级病历数据，实现肺癌影像诊断95%以上的准确率，接近资深放射科医师水平。

在商业化落地层面，AI大模型正通过"模型即服务"（MaaS）模式加速渗透。国内某头部科技企业推出的"行业大模型开放平台"已接入50+细分场景，覆盖汽车制造的质检、物流调度的路径优化等场景。企业通过低代码平台实现模型快速部署，开发周期从传统定制开发的3个月缩短至7-15天，显著降低了行业应用门槛。

然而，数据隐私与模型可解释性仍是产业落地的核心挑战。2026年行业共识逐步形成：采用联邦学习技术实现数据"可用不可见"，通过可解释AI（XAI）技术输出决策逻辑可视化报告，这些技术创新推动AI大模型在金融风控等敏感领域的合规落地。

展望未来，AI大模型与物联网、边缘计算的深度融合将催生更多创新场景。在制造业领域，数字孪生与AI大模型结合，可实现全生命周期的智能预测与维护；在医疗健康领域，AI模型将向基层医疗机构下沉，推动分级诊疗体系的完善。随着技术迭代与生态建设的加速，2026年正成为AI大模型从"可用"到"实用"的关键转折年。

2026年三大技术突破：CPO规模化落地、AIGC爆发与多模态大模型革新

Sat, 02 May 2026 21:38:32 +0800

随着AI算力需求指数级增长，2026年技术领域呈现三大突破性进展：共封装光学（CPO）技术规模化落地解决数据中心"互连墙"难题，AIGC在游戏影视行业全面爆发，多模态大模型实现跨场景智能交互。这三大技术相互交织，正在重塑产业格局。

CPO技术：数据中心的"互连革命"
CPO（共封装光学）技术作为解决数据中心高带宽低功耗需求的核心方案，2026年进入规模化落地阶段。主流厂商推出的CPO产品带宽密度提升10倍、能耗降低90%，逐步实现800G、1.6T等更高带宽规格的量产。国内厂商在光芯片、封装材料等核心组件实现突破，打破国外垄断，国产CPO产品性价比优势凸显。

在超大规模数据中心场景，CPO技术已开始在AI算力集群部署。对比传统"芯片+独立光模块"设计，CPO通过一体化封装减少信号传输损耗，能耗降低90%，成本下降30%以上。预计2026年CPO在超大规模数据中心渗透率将达5%，2027年提升至8%，成为支撑6G通信与AI算力的关键基础设施。

AIGC爆发：从内容创作到产业重构
AIGC技术在2026年实现行业级应用突破。游戏领域，《赛博朋克2077》利用AI生成城市细节与角色对话库，《无人深空》通过算法生成无限星球生态系统；影视行业，迪士尼使用AI工具将分镜制作从数周缩短至数小时，《流浪地球2》用AI生成量子计算机交互界面动态效果。

Netflix等平台开始利用AI分析成功剧本结构提供情节建议，Topaz Video AI工具实现经典影片4K自动修复。AIGC不仅改变内容生产流程，更推动语音合成、动态渲染等跨行业技术融合，NVIDIA的DLSS技术已同时应用于《阿凡达2》影视渲染与游戏画质优化。

多模态大模型：开启智能交互新纪元
4月29日，DeepSeek多模态团队发布"识图模式"灰度测试，在官方App中新增图片理解功能。该功能通过V4-Flash驱动，可分析图片内容并输出结构化描述，标志着大模型从文本处理向视觉-语言融合迈进。

DeepSeek V4系列虽仍为纯文本模型（V4-Pro 1.6T参数，V4-Flash 284B参数），但已明确将多模态能力作为下一步核心目标。此次识图功能灰度测试，距离V4正式发布仅5天，预示多模态模型进入实战应用阶段，可能重塑搜索引擎、智能助手等交互范式。

技术融合趋势
2026年技术突破呈现明显协同效应：CPO技术为AI大模型提供高效算力通道，AIGC为多模态模型提供海量训练数据，多模态模型则反向推动内容生产智能化。数据中心、游戏、影视等行业正通过这三大技术的深度融合，构建全新的产业生态。随着CPO规模化落地、AIGC全面渗透与多模态大模型迭代加速，2026年或将成为智能产业爆发的关键转折点。

2026年AI医疗影像诊断：技术突破与临床应用全景解析

Sat, 02 May 2026 21:37:27 +0800

2026年，人工智能与医疗影像诊断的融合进入规模化应用新阶段。从基层医疗机构的技术适配到三甲医院的效率革命，AI医疗影像正以"技术突破-临床验证-生态重构"的路径重塑医疗格局。国家区域医疗中心建设加速、基层医疗能力提升政策推动下，影像诊断领域呈现技术迭代与场景下沉的双重突破。

技术突破：破解基层医疗影像诊断痛点

基层医疗长期面临"数据少、图像差、设备旧"的三重困境。清影智诊团队研发的双重扰动半监督学习算法，通过图像级与特征级双重扰动结合一致性损失机制，在低标注数据环境下实现高效训练，无需依赖大规模高质量样本。该技术配合自研轻量化GAN伪影矫正网络，可直接修复老旧设备产生的金属伪影、运动伪影等缺陷，使基层医院影像诊断准确率提升30%以上。

临床应用：从效率提升到漏诊率下降

北京积水潭医院贵州医院的实践验证了AI影像系统的临床价值。该医院医学影像科年接诊量超25万人次，引入AI系统后，肺结节筛查从人工阅片的十余分钟缩短至数秒，医生复核效率提升8倍。系统通过多模态影像融合技术，可同时识别12类病变特征，对≤5mm微小肺结节的检出率达98.7%，显著降低漏诊风险。数据显示，AI辅助诊断使科室诊断报告合格率从92%提升至99.6%，医护人员日均工作时长减少2.3小时。

基层医疗场景中，郓城唐塔医院等试点单位通过AI系统与现有DR设备结合，使基层CT影像诊断能力达到三级医院水平。智能影像分析系统支持远程会诊，将偏远地区诊断延迟从平均72小时缩短至4小时内，推动分级诊疗政策落地见效。

行业趋势：从单点工具到全病程管理

博鳌亚洲论坛2026年会上，专家指出AI+健康已从"辅助工具"转向"核心引擎"。在精准诊疗领域，AI多模态医学影像读片能力已超越部分资深医生，未来将深度整合手术机器人、个性化用药方案；药物研发中，生成式AI可将临床前研发周期从4-6年压缩至1-2年；健康管理场景下，可穿戴设备与AI结合实现心脑血管意外、糖尿病并发症等风险的实时预警。

但行业仍面临三大瓶颈：数据孤岛问题使跨机构协作困难，医疗数据隐私保护与标准化建设滞后；支付体系尚未将AI影像服务纳入医保，导致医院采购意愿不足；临床价值验证体系不完善，部分AI产品存在"论文强、临床弱"的技术泡沫。

2026年AI医疗影像诊断的突破表明，技术创新必须扎根临床需求。随着联邦学习技术解决数据孤岛、医保支付政策逐步完善，以及真实世界数据研究体系的建立，AI正从影像诊断的"辅助角色"进化为医疗服务的"核心引擎"，推动医疗资源分配从"经验驱动"向"数据智能"转型。未来3-5年，全病程管理闭环的构建将成为行业竞争的关键，谁能打通诊断-治疗-康复的数据链路，谁就能在智慧医疗生态中占据制高点。

具身智能：让AI从屏幕走向现实的革命性突破

Sat, 25 Apr 2026 22:19:40 +0800

具身智能：让AI从屏幕走向现实的革命性突破

描述: 具身智能是赋予AI物理载体的智能系统，通过感知-决策-行动闭环实现现实任务。本文解析其定义、技术架构及典型应用，展现AI落地真实世界的创新进展。

一、具身智能的本质：会思考的"身体"

具身智能（Embodied AI）是指拥有物理载体的智能体，通过"感知-决策-行动-再感知"的闭环，在真实世界中自主学习和解决问题的智能系统。它与传统离身AI（如ChatGPT）的本质区别在于：具身智能不仅能"思考"，更能"动手"。

通俗来说，传统AI如同只会纸上谈兵的"军师"，而具身智能则是能亲自上阵的"战士"。以端咖啡为例：离身AI会给出精确的步骤说明书（如"向左走5步，避开椅子…"），但无法执行；具身智能机器人则能自主观察环境、规划路径、抓取物品，最终将咖啡稳稳送到你面前，整个过程无需人工干预。

这种区别源于具身智能的"三位一体"架构：AI大脑（大模型算法）、物理身体（机器人硬件）和实时交互闭环（传感器与执行器协同）。2025年，具身智能首次写入《政府工作报告》，成为国家重点培育的未来产业。

二、核心技术突破：通脑引擎与智能闭环

在具身智能的产业化进程中，“通脑"引擎的出现具有里程碑意义。这款由北京通用人工智能研究院研发的核心引擎，通过构建"数据-大脑-小脑-本体"的协同架构，实现了从虚拟智能到物理机器人的全闭环。

“通脑"的三大技术支柱：

通境(TongVerse)仿真平台：提供高保真3D虚拟环境，使机器人在虚拟世界中完成亿万次训练，再迁移至现实场景
RobotFarm数据工厂：自动化采集机器人运动数据，加速智能进化
通极(OmniXtreme)运动框架：支撑人形机器人完成舞蹈、拆垛等复杂任务

在2026中关村论坛上，“通脑"入选重大成果，已实现多项突破：人形机器人"通小舞"在国际舞蹈大赛夺冠，工业场景中成功完成SMT料盘出库任务，与一汽红旗合作推动智能生产升级。

三、产业落地：从实验室到千行百业

具身智能正以惊人速度渗透到各个领域，展现出强大的实用价值：

商业零售：自主服务新范式

长沙国金中心的"银河太空舱"内，Galbot机器人店员已投入运营。这个仅16平方米的智能零售空间，能独立完成商品识别、精准取货、库存盘点全流程。消费者通过平板下单后，Galbot无需人工干预即可在一分钟内完成取货交付，单日服务量超2000人次。

不同于普通展示机器人，Galbot依托百亿级具身大模型，能处理柔性物品抓取（如特色饮品）、多机协同等复杂任务，并计划在2026年春晚后增加湖南方言交互能力，让科技更接地气。

高危作业：脑控技术开辟新可能

中国兵器工业集团研发的"脑控履带车”，将人机交互推向新高度。使用者仅需头戴脑电采集设备，无需语言或手势指令，通过专注程度即可控制履带车前进、后退、360°转圈。这种基于异步脑机接口的系统，已成功应用于工业安全巡检、应急救援等高危场景，大幅提升特殊环境下的作业效率。

特殊服务：导盲犬机器人突破无障碍障碍

2026年北京亦庄人形机器人赛事上，全球首款开放环境全自主导盲犬机器人"高德途途"正式亮相。这款四足机器人融合多传感器数据，能在复杂场景中精准避障、规划路径，并预判红绿灯状态等交通信息。通过虚拟环境训练后，它已具备理解人类社会规则的能力，为视障人士提供全天候出行保障。

四、未来展望：从通用智能到社会智能

随着技术迭代，具身智能正从个体智能向社会智能演进。北京通用人工智能研究院发布的"通通"3.0系统，已实现3D虚拟空间与现实视频流的精准区分，具备复杂任务并行规划能力，并能在"AI小镇"中与其他智能体进行社交学习。

这种进化预示着未来图景：当"通通"进入多智能体共存的社会化环境，人类将迎来"人机共生"的新时代。具身智能不再是孤立的工具，而是能理解、适应并融入人类社会的协作伙伴。

从"纸上谈兵"到"真刀真枪”，具身智能正重新定义人工智能的边界。随着"通脑"等核心引擎的成熟，更多行业将迎来智能化变革，最终实现"AI无处不在，智能触手可及"的愿景。

2026进制动态：三进制突破与量子计算协同创新

Sat, 25 Apr 2026 22:17:30 +0800

注：本文数据与技术描述基于2025-2026年公开技术报告及产业动态综合整理，具体技术参数以官方发布为准。

2026量子计算商业化突破：从技术验证到产业落地的全球竞速

Sat, 25 Apr 2026 22:15:25 +0800

2026量子计算商业化突破：从技术验证到产业落地的全球竞速

关键词: 2026量子计算,超导量子计算机,谷歌量子密码学,IBM量子处理器,量子AI应用,生物分子模拟

描述: 2026年量子计算商业化进程加速，国内超导量子计算机落地、谷歌密码学突破、IBM技术路线升级等事件推动量子计算从实验室走向产业一线。
标签: 量子计算,2026科技动态,超导量子计算机,量子AI,生物分子模拟

量子计算2026：全球技术竞速与商业化破局

2026年的量子计算领域正经历从技术突破向产业应用的关键跨越。随着国内首台超导量子计算机在西安落地运行，谷歌在密码学领域的颠覆性进展，以及IBM新一代量子处理器的发布，全球科技巨头正以密集创新重塑产业格局。这一年成为量子计算从实验室走向实用化的标志性节点。

国内突破：超导算力网络的本土化实践

4月16日，陕西省科学技术厅宣布西北首台15量子比特超导量子计算机正式投用，这台聚焦生物医药与材料设计的"量超融合"算力平台，已为4所高校、3家企业提供药物设计服务。该设备通过融合AI与经典超算资源，成功将传统计算"算不动"的复杂分子模拟问题效率提升百倍，填补了西北地区量子算力基础设施的空白。

与此同时，中国第三代超导量子计算机"本源悟空"于4月23日上线量子AI应用，为全球163个国家和地区超4700万人次提供量子算力服务。这种开放生态建设大幅降低了量子计算使用门槛，推动开发者探索医疗、金融等多领域解决方案。

国际突破：密码学与硬件技术的双重革命

谷歌在4月披露的两项量子计算白皮书引发行业震动：其改进版秀尔算法将攻破256位加密的时间从10天压缩至10分钟，资源消耗仅为传统预估的二十分之一。这一进展虽验证了量子计算对现有加密体系的威胁，却也迫使全球重新评估后量子密码学布局的紧迫性。

IBM则在11月推出新一代量子处理器Nighthawk，通过218个可调耦合器实现更复杂量子电路运行，计划三年内实现量子优势。其实验性芯片Loon的研发，为2029年容错量子计算奠定硬件基础，展现了科技巨头对技术路线的清晰规划。

跨学科融合：生物与量子计算的深度碰撞

生命科学领域同样见证量子突破：华大基因联合香港中文大学开发的VQE-PDFT框架，首次实现对欧洲知更鸟隐花色素蛋白电子转移率的精准模拟。这种"量子+经典"分工合作模式，将复杂生物分子计算资源需求降低至传统方法的十分之一，为理解生物体内量子效应提供全新工具。

商业化加速：开放生态与行业落地

2026年量子计算商业化呈现多点突破态势：“本源悟空"构建的量子AI平台、IBM Nighthawk系统的产业适配、谷歌开源框架的安全设计，共同推动量子计算从实验室走向产业一线。这种开放生态建设正加速行业渗透，预示着未来5年量子计算将进入实用化爆发期。

面对这场变革，各行业需提前布局后量子技术，在数字经济新赛道中把握先机。量子计算的商业化竞赛已然开启，而2026年正是这场竞赛的关键转折点。

（全文共786字）

2026年AI智能体爆发：技术突破与政企应用全景

Sat, 25 Apr 2026 22:13:29 +0800

2026年AI智能体爆发：技术突破与政企应用全景

2026年AI智能体进入规模化落地阶段，模型推理能力、工具生态、治理体系与成本下降四大因素推动产业爆发，政务、金融等领域已实现降本增效规模化。

一、2026：AI智能体爆发的技术逻辑

2026年被业内公认为AI智能体规模化落地的临界点。OpenAI o1、DeepSeek-R1等新一代模型在复杂推理、长上下文处理和工具调用上实现质的飞跃，为智能体提供了"够用"的"大脑"。同时，MCP协议、A2A协议的标准化，使智能体能真正接入现实系统，而非局限于沙盒运行。

企业级AI治理体系的建立和成本拐点的出现，为行业规模化扫清了障碍——模型推理成本两年内下降超95%，让"每个业务流程部署一个Agent"成为经济可行方案。这与2007年iPhone推动智能手机普及的技术成熟路径高度相似，AI智能体正处于基础设施铺设与生态爆发的转折期。

二、政企应用：从概念到规模化创收

政务服务成为智能体落地最成熟的领域。以无锡"锡信服"政务智能体矩阵为例，其整合多部门数据，覆盖政策咨询、材料预审、进度查询等需求，实现7×24小时响应，分流30%以上窗口咨询量，让群众办事等待时间缩短60%。

金融领域展现出强劲爆发力。某银行部署的智能体单日处理1.3万笔贷款面签，风险识别准确率提升25%，人工复核成本降低60%。制造业中，能源管理智能体帮助工厂能耗降低18%，印证了智能体在生产流程优化中的实际价值。

三、技术跃迁：自主决策与多模态交互

当前AI智能体正经历三大技术突破：自主决策能力让系统能独立拆解任务、规划路径；多智能体协同构建企业级数字员工团队，实现跨场景无缝衔接；情感交互技术使智能体具备情绪识别与共情反馈能力。

多模态技术进一步重塑人机交互。Qwen-VL、Gemini等模型融合视觉、语言、语音信息，在医疗诊断、工业质检等场景实现精准识别。这种融合能力打破传统交互局限，让智能体能理解复杂物理世界信息，推动人机协作进入新阶段。

四、未来展望：基础设施到生态成熟

尽管2026年智能体已实现规模化应用，但行业仍处于"基础设施铺设期"。中国信通院数据显示，超2000家头部企业通过智能体实现降本增效，部分场景投入产出比达1:1.5。真正的"Agent原生应用生态"可能还需3-5年培育，但这场范式革命已明确开启。

从技术突破到产业落地，AI智能体正在重构数字世界的协作范式。当政务咨询、金融风控、工业管理等领域的智能体成为标配，人类将逐步从重复性劳动中解放，转向更具创造性的工作。这不仅是技术的胜利，更是生产力关系的重新定义。

2026年4月全球前沿科技趋势：AI进化、量子突破与绿色能源革新

Sat, 25 Apr 2026 17:57:39 +0800

2026年4月全球前沿科技趋势：AI进化、量子突破与绿色能源革新

本文聚焦2026年4月全球科技前沿，解析AI从工具到伙伴的进化、量子计算商业化突破、太阳能电池效率提升及机器人技术新应用，展现科技对生产生活的重塑。

引言

2026年4月的科技领域呈现多点爆发态势，人工智能从“超级工具”向“协同伙伴”转型，量子计算突破物理极限，绿色能源技术加速迭代，机器人与物理世界融合迈入新阶段。这些变革不仅推动产业升级，更深刻改变人类生产生活方式。

AI进化：从工具到“未来伙伴”的范式跃迁

中国科学院自动化研究所正高级工程师罗引在“人工智能进化简史”报告中指出，AI技术正从“被动执行指令”转向“主动协同决策”。在工业场景中，多智能体系统（MAS）实现跨任务分工协作，如医疗AI团队自动完成数据筛查、诊断报告生成及患者跟进全流程；特定领域小模型（DSLM）通过10B-30B参数模型在医疗影像、工业质检等场景中，以更高性价比超越通用大模型。

与此同时，AI与硬件深度融合催生新型交互设备：AI眼镜实现语音-视觉-环境感知三模态交互，上下文感知吊坠可根据用户习惯调节智能服务。中国科学院最新发布的《人工智能赋能科学研究》一书，系统构建了AI与学科交叉的知识框架，推动科研范式从“经验驱动”向“数据智能驱动”转型。

量子计算：中国突破硅基全栈运算，商业化加速

中国量子计算领域再获里程碑突破：深圳国际量子研究院完成硅基逻辑量子计算机原型验证，“祖冲之三号”量子优越性算力超经典超算百万倍。核心技术突破在于量子纠错与硬件校准：英伟达开源Ising量子AI模型将纠错准确率提升3倍，中国自研量子SoC芯片加密强度提升百万倍，安全手机已量产。

商业化场景加速落地：金融机构借助量子AI模型进行风险建模，效率提升1000倍；新材料研发中，传统超算需1年的分子模拟仅需1小时；低轨卫星搭载量子密钥分发设备，构建全球首个“不可破解”通信网络。预计2035年全球量子计算市场规模将突破千亿美元，中国在算力、安全与场景布局中已形成领先优势。

绿色能源：新一代太阳能电池效率突破15%

中国科学院团队研发的铜锌锡硫硒（CZTSSe）太阳能电池实现15.45%的光电转换效率，通过引入Li2SnS3界面相调控金属离子迁移，解决高温制备中晶体缺陷问题。该材料不依赖稀有金属，生产成本降低60%，且具备优异的复杂环境稳定性，适用于建筑光伏、离网供电等场景。

全球能源转型加速，光伏产业正从“规模扩张”转向“效率革命”。CZTSSe技术突破为薄膜光伏规模化应用扫清障碍，其溶液法制备工艺与低材料损耗特性，有望在2030年前降低分布式电站成本30%以上，成为碳中和目标下的关键技术支撑。

机器人技术：具身智能重塑产业与生活

人形机器人与工业具身智能成为机器人技术新焦点。特斯拉Optimus、小米CyberOne等机型进入工厂执行精密装配、物流分拣任务，具备自主环境感知与自适应操作能力。AI驱动的农业巡检机器人、养老服务机器人，通过多传感器融合实现情感交互与任务规划，人机协作场景从“简单重复”向“复杂决策”延伸。

2026年机器人技术呈现“模块化+AI原生”特征：可更换功能模块使设备快速适配多场景，如医疗机器人加装手术器械或康复训练模块；AI原生开发平台降低编程门槛，普通用户可通过自然语言指令定制机器人行为。中国正推动工业机器人密度年增15%，预计2028年将实现汽车制造全流程无人工厂覆盖率超80%。

结语

从AI伙伴到量子革命，从光伏革新到人机协作，2026年4月的科技突破正以“多技术融合”重塑产业生态。这些进展不仅是实验室成果，更已渗透到金融、能源、医疗等关键领域。未来，科技将从“单点创新”走向“系统变革”，在效率提升与可持续发展中寻找新平衡点。

{注意：文中图片链接均来自公共图片库，实际应用时需替换为符合场景的高清图片直链}

DeepSeek V4发布：百万上下文AI大模型实现国产算力突破

Sat, 25 Apr 2026 17:56:15 +0800

DeepSeek V4发布：百万上下文AI大模型实现国产算力突破

国产AI大模型迎来里程碑

2026年4月24日，AI领域迎来重大突破——DeepSeek全新一代模型DeepSeek-V4预览版正式上线并同步开源。这一里程碑事件不仅标志着国内大模型技术再次突破，更实现了从硬件到软件的完整自主可控，为我国人工智能产业发展注入强劲动力。

此次发布的DeepSeek-V4预览版提供Pro与Flash两大版本，均标配百万字（1M）上下文能力，打破长文本处理的场景限制。若以1M Token的上下文窗口等效于一次性处理75万字的中文内容计算，这一能力大约相当于一次性读完《三体》三部曲的体量，为法律文书分析、学术文献检索等长文本场景提供了革命性解决方案。

技术突破与性能跃升

DeepSeek-V4-Pro激活参数达49B，预训练数据33T，定位高性能旗舰；而DeepSeek-V4-Flash激活参数13B，主打高速与低成本，两者共同构建起覆盖不同需求场景的产品矩阵。

值得关注的是，新版本首次引入KV Cache滑窗和压缩算法，大幅减少Attention计算和访存开销，并通过模型架构创新更好地支持了Agent和Coding场景。第三方评测显示，在昇腾950PR芯片上，DeepSeek V4的推理速度较初期版本提升35倍，单卡推理性能达到英伟达特供版H20芯片的2.87倍，标志着国产AI芯片正加速从"可用"迈向"好用"。

软硬协同构建国产算力生态

此次发布最令人瞩目的合作是与华为昇腾的深度协同。通过双方芯模技术紧密协同，昇腾超节点全系列产品全面支持DeepSeek V4系列模型。华为CANN框架已实现超95%的CUDA代码兼容，辅以一键迁移工具，代码重构从"按月计"缩短到"按小时计"，全面铺开国产算力生态。

这种软硬一体的深度整合，不仅让DeepSeek V4实现了从硬件到软件的完整自主可控，更推动国产AI服务器建设加速放量。据供应链数据显示，国产AI服务器需求将随国产算力投资扩张确定性提升，预计2026年下半年将迎来新一波增长周期。

开启AI应用新时代

DeepSeek V4的发布不仅是技术的突破，更预示着AI应用将进入全新时代。凭借百万上下文能力，法律工作者可一次性分析数百份合同，科研人员能快速处理海量文献，教育工作者可构建个性化学习资源库。而Agent能力的增强，将使AI从辅助工具升级为能独立决策的智能助手。

结语

DeepSeek V4的发布，不仅是中国AI技术的里程碑，更是全球人工智能发展的重要转折点。随着百万上下文能力的实现和国产算力生态的完善，我们有理由相信，AI技术将更快地融入千行百业，为社会发展注入新动能。这场技术革命，正重新定义着人机协作的边界，也让我们对未来的智能世界充满期待。

2026年4月AI技术动态：GPT-5.5重磅发布与多模态智能体新纪元

Sat, 25 Apr 2026 17:54:52 +0800

2026年4月AI技术动态：GPT-5.5重磅发布与多模态智能体新纪元

2026年4月，全球人工智能领域迎来技术爆发与产业落地并行的关键节点。OpenAI于4月24日发布新一代大模型GPT-5.5，凭借推理能力与多模态交互的双重突破引发行业震动；国内AI厂商DeepSeek同步推出V4预览版，在开源领域构建差异化竞争优势；与此同时，2026数字世界大会在日内瓦召开，为AI技术发展确立治理框架。这些动态共同勾勒出通用人工智能进入实用化阶段的产业图景。

OpenAI此次发布的GPT-5.5在性能维度实现质的飞跃。第三方评估显示，其在复杂逻辑推理任务中准确率提升37%，数学推理达到人类专家水平的89%，且同等输出token量下智能得分位居行业首位。该模型已向ChatGPT付费用户全面开放，企业级Pro版本API定价调整至$5/$30每百万Token，较GPT-5.4上涨三倍。更值得关注的是，GPT-5.5首次实现真正意义上的自主智能体功能，可独立完成代码编写、数据分析、文档生成等全流程任务，并支持多工具间的无缝切换。

国内AI势力加速追赶。DeepSeek于4月24日发布V4预览版，针对ClaudeCode等主流Agent产品进行深度适配，在代码生成、文档处理等任务中性能超越开源竞品。该版本支持1M上下文长度，提供非思考模式与max强度的思考模式，适配OpenAI与Anthropic接口标准。官方数据显示，V4-Pro版本在复杂Agent场景中决策效率提升40%，已同步上线API服务，为开发者提供灵活的技术选择。值得注意的是，DeepSeek同时推进商业化进程，计划融资3亿美元应对AI军备竞赛中的研发成本。

行业治理层面同步迎来突破。4月21日召开的2026数字世界大会上，联合国社会发展研究所提出"AI以人为本"治理框架，强调减少技术不平等、保障社会权利的核心原则。中国代表呼吁国际社会加强技术转让与能力建设，尤其关注发展中国家AI基础设施鸿沟问题。会议达成共识：AI技术既是加速联合国可持续发展目标的工具，也需建立全球协同治理机制防范技术垄断风险。

从技术演进看，多模态智能体与边缘计算成为产业新方向。中科算网报告显示，Qwen3.5等多模态模型已实现本地vLLM私有化部署，在数据安全敏感领域提供替代方案。AI系统正从"指令执行"向"主动理解"转变，人机协作效率的提升与实时交互能力的突破，标志着通用人工智能进入"好用"而非"能用"的新阶段。随着技术突破与治理完善的双轮驱动，2026年或将成为AI产业落地的关键转折点。

2026年热门技术工具深度评测：AI与低代码平台全景解析

Sat, 25 Apr 2026 09:46:27 +0000

2026年热门技术工具深度评测

AI工具生态全面升级

2026年AI工具呈现"通用大模型+智能体"双轮驱动格局。通用大模型形成"海外三强（GPT-5.4、Claude Opus 4.6、Gemini 3.1 Pro）“与"国产六强（豆包、DeepSeek V4、Kimi 2.5等）“竞争态势，国产模型突破技术壁垒，中文自然度与推理能力比肩国际水平。AI智能体成为效率革命核心，OpenClaw、通义万相2.0等支持自主规划与多任务协同，实现7×24小时全场景自动化作业。

开发工具重构工作流

编程工具进入"全流程智能体"时代。字节跳动Trae实现需求分析到部署上线的全链路自动化，国内版免费且深度适配国产框架；GitHub Copilot依托470万付费用户生态，覆盖37种编程语言，适合国际团队协作。两款工具分别代表国内本土化开发与全球生态协作的技术方向。

低代码平台多元选型

国内低代码市场规模突破131亿元，织信、奥哲、宜搭等平台各有侧重：织信全栈信创适配适合中大型企业；奥哲兼容国产软硬件，提供零代码表单与流程自动化；宜搭依托钉钉生态，主打轻量级业务场景快速搭建。建议企业根据规模与信创需求选择适配方案。

（全文约380字，覆盖AI工具、编程工具、低代码平台三大核心领域，兼顾国内外技术动态与选型建议）

2026年4月技术热点：AI智能体攻防爆发与量子安全新纪元

Sat, 25 Apr 2026 09:45:33 +0000

引言：技术变革的历史性节点

2026年4月，全球技术圈迎来爆发式迭代：AI智能体从概念走向规模化落地，量子计算突破1121量子比特，GPT-6发布倒计时引发行业震动。技术变革呈现三大特征：速度前所未有（Gemma 4发布24小时星标破5万）、深度前所未有（GPT-6支持200万Token上下文）、广度前所未有（覆盖办公/开发/运维全场景）。

十大技术热点速览

AI智能体攻防爆发：企业级渗透率超60%，身份冒充（35%）、内部威胁（28%）成主要威胁，需构建智能监控与多Agent协作防御体系
量子安全全面落地：中国发布后量子密码国标，IBM Condor突破1121量子比特，密码体系重构进入双轮防御时代
云原生服务网格：Kubernetes 1.36原生支持，零信任架构与服务网格深度融合，运维效率提升300%
AI大模型进化：GPT-6（4月14日发布）性能提升40%，Qwen 3.6-Plus编程能力超越人类，端侧部署门槛骤降
量子计算商业化：IBM Condor 1121量子比特，谷歌TPU v7单芯片功耗980W，液冷方案成标配
AI驱动网络安全：70%组织采用复合AI防御，攻击预测性提升至50%，防御进入预测性韧性阶段
数据库智能化：大模型+SQL自动优化根治慢查询，查询效率提升90%
AI芯片革命：光基计算与原子级器件重塑芯片体系，能效管控法规趋严
边缘AI普及：低延迟本地化智能处理渗透工业质检、医疗监测等场景
绿色AI计算：数据中心PUE降至1.1以下，英伟达Vera Rubin采用100%液冷方案

产业影响与数据洞察

IDC 2026 Q1数据显示：全球科技支出突破6万亿美元，AI、网络安全、主权基础设施占比超58%；网络安全市场规模达3200亿美元，人才缺口340万。技术变革正重塑产业格局，开发者需关注"AI+安全"复合型能力培养。

（注：本文技术内容均来自IDC 2026 Q1报告及企业实践案例，数据截至2026年4月22日）

2026年核心技术赛道全景解析：从实验室到产业落地的突破之路

Sat, 25 Apr 2026 09:44:45 +0000

引言

2026年全球科技产业正经历新一轮变革，中关村论坛发布的《未来产业十大赛道》显示，人形机器人具身智能、生物制造、脑机接口等十大赛道引领科技革命。这些领域呈现技术迭代加速、商业化落地提速的显著特征，成为推动生产力变革的核心引擎。

人形机器人：具身智能开启产业新纪元

人形机器人凭借物理实体与环境交互能力，从单一场景向多领域渗透。2025-2026年实现跨越式发展，已应用于商业表演、会展服务、特种作业及家庭服务等场景。预计到2035年，全球市场规模将突破万亿元，中国企业正构建从整机制造到生态协同的产业体系。

AI智能体：重塑生产组织模式

AI智能体技术进入规模化部署阶段，在企业研发、客服、办公自动化等环节实现闭环能力。《国务院人工智能+行动意见》提出2030年普及率超90%，万卡级集群支撑大模型训练，“东数西算"工程提升算力普惠性，人机交互向多模态实用化演进。

量子计算：纠错方案突破硬件瓶颈

澳大利亚团队提出的新型量子纠错方案，通过"规范理论"减少物理量子比特需求，降低大规模量子计算机构建难度。结合"量子硬盘"存储效率优势，逻辑处理器与量子存储协同，推动量子计算向实用化迈进，有望在药物研发、金融分析等领域实现突破。

生物制造与脑机接口：AI与生命科学融合

生物制造领域在AI赋能下研发迭代加速，预计2050年创造30万亿美元经济价值，中国通过政策与资源集聚巩固优势。脑机接口呈现多模态发展，非侵入式技术全球领先，医疗健康、认知增强场景商业化加速，2030年全球市场规模达64亿美元。

结语

2026年核心技术赛道呈现"硬科技突破+场景化落地"双轮驱动特征，人形机器人、AI智能体等技术正从实验室走向产业纵深。未来产业发展需依赖多技术协同，如量子计算与AI结合优化智能体决策，生物制造与核聚变能构建新型能源体系，这些突破将重塑全球科技竞争格局。

（注：本文数据均来自2026年中关村论坛《未来产业十大赛道》、科普中国AI趋势报告及科技日报量子计算研究成果）

2026年4月技术前沿：AI大模型爆发、智能体革命与量子安全新纪元

Sat, 25 Apr 2026 09:43:50 +0000

2026年4月技术前沿全景扫描

2026年4月全球技术圈迎来爆发式变革，三大特征重塑产业格局：速度（技术迭代周期从月缩至天）、深度（GPT-6支持200万Token上下文）、广度（AI智能体渗透全行业）。

AI大模型战场硝烟再起

谷歌Gemma 4于4月2日零预热开源，Apache 2.0许可证彻底降低端侧部署门槛；GPT-6于4月14日发布，性能提升40%，AI智能体框架OpenClaw星标突破13.6万，多Agent协作成主流开发模式。

量子计算商业化加速

IBM Condor量子计算机突破1121量子比特，中国“本源悟空”量子AI应用上线，为全球4700万人次提供算力服务，量子安全进入国标双轮防御时代。

安全与效率双线突破

AI驱动攻击占比达50%，防御进入预测性韧性阶段；Kubernetes 1.36发布深度集成服务网格，数据库智能化优化根治慢查询，AI编程助手代码生成准确率超90%。

行业数据透视

IDC报告显示，全球AI市场规模达1.2万亿美元（同比+67%），AI智能体开发者突破500万（同比+320%），网络安全人才缺口达340万，技术变革临界点已然显现。

SpringBoot 事务管理 @Transactional 实现转账功能（MyBatisPlus）

Thu, 23 Apr 2026 19:41:00 +0800

数据库表设计

创建 user 表，包含用户ID、姓名、余额字段：

CREATE TABLE `user` (
  `id` bigint NOT NULL AUTO_INCREMENT,
  `name` varchar(255) DEFAULT NULL,
  `balance` decimal(10,2) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

实体类 User

import com.baomidou.mybatisplus.annotation.TableName;
import java.math.BigDecimal;

@TableName("user")
public class User {
    private Long id;
    private String name;
    private BigDecimal balance;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public BigDecimal getBalance() {
        return balance;
    }

    public void setBalance(BigDecimal balance) {
        this.balance = balance;
    }
}

Mapper 层

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface UserMapper extends BaseMapper<User> {
}

Service 层（事务核心）

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.math.BigDecimal;

@Service
public class UserService {

    @Autowired
    private UserMapper userMapper;

    /**
     * 转账方法（添加事务）
     * @param fromUserId 转出用户ID
     * @param toUserId 转入用户ID
     * @param amount 转账金额
     */
    @Transactional
    public void transfer(Long fromUserId, Long toUserId, BigDecimal amount) {
        // 查询转出账户
        User fromUser = userMapper.selectById(fromUserId);
        // 查询转入账户
        User toUser = userMapper.selectById(toUserId);

        // 判断余额是否充足
        if (fromUser.getBalance().compareTo(amount) < 0) {
            throw new RuntimeException("余额不足，转账失败");
        }

        // 扣减转出账户余额
        fromUser.setBalance(fromUser.getBalance().subtract(amount));
        userMapper.updateById(fromUser);

        // 增加转入账户余额
        toUser.setBalance(toUser.getBalance().add(amount));
        userMapper.updateById(toUser);
    }
}

Controller 层

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import java.math.BigDecimal;

@RestController
public class UserController {

    @Autowired
    private UserService userService;

    @PostMapping("/transfer")
    public String transfer(
            @RequestParam Long fromUserId,
            @RequestParam Long toUserId,
            @RequestParam BigDecimal amount) {
        userService.transfer(fromUserId, toUserId, amount);
        return "转账成功";
    }
}

关键说明

@Transactional 注解保证方法内所有数据库操作要么全部成功，要么全部失败
抛出异常自动回滚，保证数据一致性
适用于转账、支付、订单等需要强一致性的业务场景

依赖（pom.xml）

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.5.3.1</version>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <scope>runtime</scope>
</dependency>

Python 修改图片分辨率（单张/批量/等比例/递归覆盖）

Thu, 23 Apr 2026 19:35:00 +0800

1. 修改单张图片分辨率

from PIL import Image

def resize_image(input_image_path, output_image_path, new_width, new_height):
    image = Image.open(input_image_path)
    resized_image = image.resize((new_width, new_height))
    resized_image.save(output_image_path)

# 使用示例
input_image_path = "input.jpg"
output_image_path = "output.jpg"
new_width = 800
new_height = 600

resize_image(input_image_path, output_image_path, new_width, new_height)

2. 批量修改文件夹内所有图片分辨率

import os
from PIL import Image

def resize_images_in_folder(input_folder, output_folder, new_width, new_height):
    for filename in os.listdir(input_folder):
        if filename.endswith(".jpg") or filename.endswith(".png"):
            input_image_path = os.path.join(input_folder, filename)
            output_image_path = os.path.join(output_folder, filename)
            resize_image(input_image_path, output_image_path, new_width, new_height)

def resize_image(input_image_path, output_image_path, new_width, new_height):
    image = Image.open(input_image_path)
    resized_image = image.resize((new_width, new_height))
    resized_image.save(output_image_path)

# 使用示例
input_folder = "input_folder"
output_folder = "output_folder"
new_width = 800
new_height = 600

resize_images_in_folder(input_folder, output_folder, new_width, new_height)

3. 等比例修改图片分辨率

from PIL import Image

def resize_image(input_path, output_path, new_width, new_height):
    image = Image.open(input_path)
    width, height = image.size
    aspect_ratio = width / height

    if new_width is None:
        new_width = int(new_height * aspect_ratio)
    elif new_height is None:
        new_height = int(new_width / aspect_ratio)

    resized_image = image.resize((new_width, new_height), Image.ANTIALIAS)
    resized_image.save(output_path)

if __name__ == "__main__":
    input_path = "input.jpg"
    output_path = "output.jpg"
    new_width = 800
    new_height = None

    resize_image(input_path, output_path, new_width, new_height)

4. 递归等比例修改并覆盖原图

import os
from PIL import Image

def resize_image(input_path, new_width, new_height):
    image = Image.open(input_path)
    width, height = image.size
    aspect_ratio = width / height

    if new_width is None:
        new_width = int(new_height * aspect_ratio)
    elif new_height is None:
        new_height = int(new_width / aspect_ratio)

    resized_image = image.resize((new_width, new_height), Image.ANTIALIAS)
    resized_image.save(input_path)

def resize_images_in_directory(directory, new_width, new_height):
    for root, dirs, files in os.walk(directory):
        for filename in files:
            if filename.lower().endswith(('.jpg', '.jpeg', '.png', '.gif')):
                input_path = os.path.join(root, filename)
                resize_image(input_path, new_width, new_height)

if __name__ == "__main__":
    target_directory = "your_directory_path"
    new_width = 800
    new_height = None

    resize_images_in_directory(target_directory, new_width, new_height)

使用说明

安装依赖：pip install pillow
根据需求选择对应脚本
修改文件路径、宽度、高度参数
直接运行即可
支持格式：jpg、jpeg、png、gif

Android 11/12/13 动态权限申请问题完整教程（存储、相机、相册）

Thu, 23 Apr 2026 19:15:00 +0800

一、AndroidManifest.xml 权限配置

<!-- Android 13 图片、音频、视频权限 -->
<uses-permission android:name="android.permission.READ_MEDIA_IMAGES" />
<uses-permission android:name="android.permission.READ_MEDIA_AUDIO" />
<uses-permission android:name="android.permission.READ_MEDIA_VIDEO" />

<!-- 存储权限 -->
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
<uses-permission android:name="android.permission.MANAGE_EXTERNAL_STORAGE"
    tools:ignore="ScopedStorage" />

<!-- 相机权限 -->
<uses-permission android:name="android.permission.CAMERA" />
<uses-feature android:name="android.hardware.camera" />

<!-- 网络权限 -->
<uses-permission android:name="android.permission.INTERNET" />

二、权限申请说明

Android 6.0 以上需要动态申请权限
Android 11 以上存储权限需跳转到系统设置开启
Android 13 拆分相册权限为：图片、视频、音频

三、Activity 中申请权限（基础版）

public class MainActivity extends AppCompatActivity {
    private static final String[] PERMISSIONS_STORAGE = {
        Manifest.permission.READ_EXTERNAL_STORAGE,
        Manifest.permission.WRITE_EXTERNAL_STORAGE
    };
    private static final int REQUEST_EXTERNAL_STORAGE = 1;
    private boolean havePermission = false;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }

    @Override
    protected void onResume() {
        super.onResume();
        checkPermission();
    }

    private AlertDialog dialog;
    private void checkPermission() {
        if (Build.VERSION.SDK_INT > Build.VERSION_CODES.M) {
            if (ActivityCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE)
                    != PackageManager.PERMISSION_GRANTED) {
                if (dialog != null) {
                    dialog.dismiss();
                    dialog = null;
                }
                dialog = new AlertDialog.Builder(this)
                        .setTitle("提示")
                        .setMessage("请开启文件访问权限，否则无法正常使用应用！")
                        .setPositiveButton("确定", new DialogInterface.OnClickListener() {
                            @Override
                            public void onClick(DialogInterface dialog, int which) {
                                dialog.dismiss();
                                ActivityCompat.requestPermissions(MainActivity.this,
                                        PERMISSIONS_STORAGE, REQUEST_EXTERNAL_STORAGE);
                            }
                        }).create();
                dialog.show();
            } else {
                havePermission = true;
            }
        } else {
            havePermission = true;
        }
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions,
                                           @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        switch (requestCode) {
            case REQUEST_EXTERNAL_STORAGE:
                if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                    havePermission = true;
                    Toast.makeText(this, "授权成功！", Toast.LENGTH_SHORT).show();
                } else {
                    havePermission = false;
                    Toast.makeText(this, "授权被拒绝！", Toast.LENGTH_SHORT).show();
                }
                break;
        }
    }
}

四、Fragment 中申请权限

public class PersonFragment extends Fragment {
    public static Activity context;
    private static final String[] PERMISSIONS_STORAGE = {
        Manifest.permission.READ_EXTERNAL_STORAGE,
        Manifest.permission.WRITE_EXTERNAL_STORAGE,
        Manifest.permission.CAMERA
    };
    private static final int REQUEST_EXTERNAL_STORAGE = 1;

    @Override
    public void onStart() {
        super.onStart();
        checkPermission();
    }

    private AlertDialog dialog;
    private void checkPermission() {
        if (Build.VERSION.SDK_INT > Build.VERSION_CODES.M) {
            if (ActivityCompat.checkSelfPermission(context, Manifest.permission.WRITE_EXTERNAL_STORAGE)
                    != PackageManager.PERMISSION_GRANTED) {
                if (dialog != null) {
                    dialog.dismiss();
                    dialog = null;
                }
                dialog = new AlertDialog.Builder(context)
                        .setTitle("提示")
                        .setMessage("请开启文件访问权限，否则无法正常使用应用！")
                        .setPositiveButton("确定", new DialogInterface.OnClickListener() {
                            @Override
                            public void onClick(DialogInterface dialog, int which) {
                                dialog.dismiss();
                                ActivityCompat.requestPermissions(context,
                                        PERMISSIONS_STORAGE, REQUEST_EXTERNAL_STORAGE);
                            }
                        }).create();
                dialog.show();
            }
        }
    }
}

MainActivity 绑定 Fragment 上下文

`1`	`PersonFragment.context = MainActivity.this;`

五、Android 11 及以上存储权限（完整适配）

public class MainActivity extends AppCompatActivity {
    private static final String[] PERMISSIONS_STORAGE = {
        Manifest.permission.READ_EXTERNAL_STORAGE,
        Manifest.permission.WRITE_EXTERNAL_STORAGE
    };
    private static final int REQUEST_EXTERNAL_STORAGE = 1;
    private boolean havePermission = false;
    private AlertDialog dialog;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }

    @Override
    protected void onResume() {
        super.onResume();
        checkPermission();
    }

    private void checkPermission() {
        // Android 11 (API 30) 及以上
        if (Build.VERSION.SDK_INT >= 30) {
            if (!Environment.isExternalStorageManager()) {
                if (dialog != null) {
                    dialog.dismiss();
                    dialog = null;
                }
                dialog = new AlertDialog.Builder(this)
                        .setTitle("提示")
                        .setMessage("请开启文件访问权限，否则无法正常使用本应用！")
                        .setNegativeButton("取消", new DialogInterface.OnClickListener() {
                            @Override
                            public void onClick(DialogInterface dialog, int i) {
                                dialog.dismiss();
                            }
                        })
                        .setPositiveButton("确定", new DialogInterface.OnClickListener() {
                            @Override
                            public void onClick(DialogInterface dialog, int which) {
                                dialog.dismiss();
                                Intent intent = new Intent(Settings.ACTION_MANAGE_ALL_FILES_ACCESS_PERMISSION);
                                startActivity(intent);
                            }
                        }).create();
                dialog.show();
            } else {
                havePermission = true;
            }
        }
        // Android 6.0 ~ Android 10
        else if (Build.VERSION.SDK_INT > Build.VERSION_CODES.M) {
            if (ActivityCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE)
                    != PackageManager.PERMISSION_GRANTED) {
                if (dialog != null) {
                    dialog.dismiss();
                    dialog = null;
                }
                dialog = new AlertDialog.Builder(this)
                        .setTitle("提示")
                        .setMessage("请开启文件访问权限，否则无法正常使用应用！")
                        .setPositiveButton("确定", new DialogInterface.OnClickListener() {
                            @Override
                            public void onClick(DialogInterface dialog, int which) {
                                dialog.dismiss();
                                ActivityCompat.requestPermissions(MainActivity.this,
                                        PERMISSIONS_STORAGE, REQUEST_EXTERNAL_STORAGE);
                            }
                        }).create();
                dialog.show();
            } else {
                havePermission = true;
            }
        }
        // Android 6.0 以下
        else {
            havePermission = true;
        }
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions,
                                           @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        switch (requestCode) {
            case REQUEST_EXTERNAL_STORAGE:
                if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                    havePermission = true;
                    Toast.makeText(this, "授权成功！", Toast.LENGTH_SHORT).show();
                } else {
                    havePermission = false;
                    Toast.makeText(this, "授权被拒绝！", Toast.LENGTH_SHORT).show();
                }
                break;
        }
    }
}

六、Android 13 相机 + 相册权限

@RequiresApi(api = Build.VERSION_CODES.TIRAMISU)
public class PersonFragment extends Fragment {
    public static Activity context;
    private static final int REQUEST_PICTURE_CODE = 100;

    // Android 13 以下
    private static final String[] PERMISSIONS_STORAGE = {
        Manifest.permission.READ_EXTERNAL_STORAGE,
        Manifest.permission.WRITE_EXTERNAL_STORAGE,
        Manifest.permission.CAMERA
    };
    private static final int REQUEST_EXTERNAL_STORAGE = 1;

    // Android 13 以上
    private static final String[] PERMISSIONS_STORAGE_33 = {
        Manifest.permission.READ_MEDIA_IMAGES,
        Manifest.permission.READ_MEDIA_AUDIO,
        Manifest.permission.READ_MEDIA_VIDEO,
        Manifest.permission.CAMERA
    };
    private static final int REQUEST_PERMISSION_CODE_33 = 2;

    @Override
    public void onStart() {
        super.onStart();
        ifHaveAlbumPermission(context);
    }

    private void openFile() {
        Intent intentFromGallery = new Intent();
        intentFromGallery.setType("image/*");
        intentFromGallery.setAction(Intent.ACTION_GET_CONTENT);
        context.startActivityForResult(intentFromGallery, REQUEST_PICTURE_CODE);
    }

    private void ifHaveAlbumPermission(Activity activity) {
        if (ActivityCompat.checkSelfPermission(activity, Manifest.permission.READ_MEDIA_IMAGES)
                != PackageManager.PERMISSION_GRANTED) {
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
                ActivityCompat.requestPermissions(activity,
                        PERMISSIONS_STORAGE_33, REQUEST_PERMISSION_CODE_33);
            } else {
                ActivityCompat.requestPermissions(activity,
                        PERMISSIONS_STORAGE, REQUEST_EXTERNAL_STORAGE);
            }
        } else {
            openFile();
        }
    }
}

七、适用场景

文件读写、下载、保存
相机拍照、相册选取
Android 11/12/13 分区存储适配
Activity / Fragment 权限兼容

Vue2 实现人脸检测与录入功能，基于 tracking.js 实时人脸识别

Thu, 23 Apr 2026 17:00:00 +0800

自行去下载tracking.js

`1`	`npm install tracking`

三个canvas，一个显示完整摄像头，一个在摄像头上显示人脸矩形框，一个截取人脸（提醒大家一下，如果你选择localhost运行预览是不会报错的，但是如果选择IP地址运行预览，肯定是会报错的，因为你的浏览器在不是https协议的情况下不允许打开摄像头）

<template>
  <div>
    <div>
      <p>脸部放入红色矩形框</p>
      <video id="video" style="transform: rotateY(180deg)" autoplay preload loop muted></video>
      <canvas id="overlayCanvas" width="200" height="200" style="position: absolute; top: 20; left: 0; transform: rotateY(180deg);"></canvas>
    </div>
    <div>
      <p>检测人脸结果</p>
      <canvas id="fullCanvas" width="200" height="200" style="transform: rotateY(180deg)"></canvas>
      <canvas id="faceCanvas" width="200" height="200" style="transform: rotateY(180deg); display: none;"></canvas>
    </div>
    <div>结果：{{ img }}</div>
  </div>
</template>
 
<script>
//import { userMedia } from '../../utils/utils';
import 'tracking/build/tracking.js';
import 'tracking/build/data/face-min.js';
 
export default {
  data() {
    return {
      img: '',
      videoObj: null,
      trackerTask: null,
      overlayContext: null
    }
  },
 
  mounted() {
    this.getCompetence()
  },
 
  methods: {
    openCamera() {
      this.$nextTick(() => {
        const fullCanvas = document.getElementById('fullCanvas')
        const fullContext = fullCanvas.getContext('2d')
 
        const faceCanvas = document.getElementById('faceCanvas')
        const faceContext = faceCanvas.getContext('2d')
 
        this.videoObj = document.getElementById('video')
 
        const overlayCanvas = document.getElementById('overlayCanvas')
        this.overlayContext = overlayCanvas.getContext('2d')
 
        const tracker = new window.tracking.ObjectTracker('face')
        tracker.setInitialScale(4)
        tracker.setStepSize(2)
        tracker.setEdgesDensity(0.1)
 
        this.trackerTask = window.tracking.track('#video', tracker, { camera: true })
        this.img = this.trackerTask
 
        tracker.on('track', (event) => {
          if (event.data.length !== 0) {
            event.data.forEach((rect) => {
              fullContext.clearRect(0, 0, fullCanvas.width, fullCanvas.height)
              fullContext.drawImage(this.videoObj, 0, 0, fullCanvas.width, fullCanvas.height)
 
              faceCanvas.width = rect.width
              faceCanvas.height = rect.height
              faceContext.clearRect(0, 0, faceCanvas.width, faceCanvas.height)
              faceContext.drawImage(this.videoObj, rect.x, rect.y, rect.width, rect.height, 0, 0, faceCanvas.width, faceCanvas.height)
 
              // 绘制矩形框到 overlayCanvas
              this.overlayContext.clearRect(0, 0, overlayCanvas.width, overlayCanvas.height)
              this.overlayContext.strokeStyle = 'red'; // 设置矩形框颜色
              this.overlayContext.lineWidth = 2; // 设置矩形框线宽
              this.overlayContext.strokeRect(rect.x, rect.y, rect.width, rect.height)
 
              console.log(faceCanvas.toDataURL())
              this.img = faceCanvas.toDataURL()
            });
          }
        })
      })
    },
 
    getCompetence() {
      let _this = this;
      this.video = document.getElementById("video");
      if (navigator.mediaDevices === undefined) {
        navigator.mediaDevices = {};
      }
      if (navigator.mediaDevices.getUserMedia === undefined) {
        navigator.mediaDevices.getUserMedia = function (constraints) {
          var getUserMedia =
            navigator.webkitGetUserMedia ||
            navigator.mozGetUserMedia ||
            navigator.getUserMedia;
          if (!getUserMedia) {
            return Promise.reject(
              new Error("getUserMedia is not implemented in this browser")
            );
          }
          return new Promise(function (resolve, reject) {
            getUserMedia.call(navigator, constraints, resolve, reject);
          });
        };
      }
      var constraints = {
        video: { width: 200, height: 200, transform: "scaleX(-1)" },
        audio: false,
      };
      navigator.mediaDevices
        .getUserMedia(constraints)
        .then(function (stream) {
          if ("srcObject" in _this.video) {
            _this.video.srcObject = stream;
          } else {
            _this.video.src = window.URL.createObjectURL(stream);
          }
          _this.video.onloadedmetadata = function (e) {
            _this.video.play();
          };
 
          _this.openCamera();
        })
        .catch((err) => {
          console.log(err);
        });
    },
 
    de() {
      this.video.srcObject.getTracks()[0].stop();
      this.trackerTask.stop();
    },
 
    handleCancel() {
      this.videoObj.srcObject.getTracks()[0].stop()
      this.trackerTask.stop()
    },
 
    success(stream) {
      this.videoObj.srcObject = stream
      this.videoObj.play()
    },
 
    error(error) {
      console.log(`访问用户媒体设备失败${error.name}, ${error.message}`)
    }
  },
 
  beforeDestroy() {
    this.handleCancel()
  }
}
</script>

WebSocket实现HTML+SpringBoot聊天功能，小程序+SpringBoot聊天功能

Thu, 23 Apr 2026 16:25:00 +0800

一、认识WebSocket

首先博主在初学Java时自我感觉走了很多弯路，因为以前见识短，在接触聊天功能时根本就没能想到有WebSocket这个聊天框架，就只能用底层的UDP或TCP实现聊天功能，及其繁琐。
在入门Java后的朋友学到网络编程会知道UDP和TCP两个知识点，没错WebSocket是一种在单个TCP连接上进行全双工通信的协议。基于TCP协议的一个框架，TCP知识点比较多，具体咱们就不多说了，直接实践怎么使用吧。

二、HTML实现聊天

首先我先贴出完整代码，然后解释

html代码，这里我就不单独写js文件了（这个html实现的是一对一聊天，还有一对多，多对多群聊）

<script src="https://code.jquery.com/jquery-3.6.4.min.js"></script>
<script src="https://cdn.jsdelivr.net/sockjs/1.1.4/sockjs.min.js"></script>
<script src="https://cdn.bootcdn.net/ajax/libs/stomp.js/2.3.3/stomp.min.js"></script>
 
<script>
    var stompClient = null;
 
    function connect() {
	var content = $("#message").val();
        var sender = 'tbb';
        var socket = new SockJS('http://127.0.0.1:8080/chat');
        stompClient = Stomp.over(socket);
        stompClient.connect({}, function (frame) {
            console.log('Connected: ' + frame);
            stompClient.subscribe('/user/tbb/message', function (message) {
                showMessage(JSON.parse(message.body));
            });
        });
    }
 
    function disconnect() {
        if (stompClient !== null) {
            stompClient.disconnect();
        }
        console.log("Disconnected");
    }
 
    function sendMessage() {
        var content = $("#message").val();
        var sender = $("#sender").val();
        stompClient.send("/app/chat/send/to/user", {}, JSON.stringify({
            content: content,
            sender: sender,
	    unionId: sender,
        }));
    }
 
    function showMessage(message) {
        $("#chat").append("<div>" + message.sender + ": " + message.content + "</div>");
    }
</script>
 
<div>
    <input type="text" id="sender" placeholder="Enter your name">
    <input type="text" id="message" placeholder="Type a message...">
    <button onclick="sendMessage()">Send</button>
    <button onclick="connect()">Connect</button>
    <button onclick="disconnect()">Disconnect</button>
</div>
 
<div id="chat">123</div>

SpringBoot完整代码

（1） WebSocketConfig.java配置文件（关键文件）

package com.example.mengchuangyuan.common.chat.config;
 
import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.simp.config.MessageBrokerRegistry;
import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker;
import org.springframework.web.socket.config.annotation.StompEndpointRegistry;
import org.springframework.web.socket.config.annotation.WebSocketMessageBrokerConfigurer;
 
@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {
 
    @Override
    public void configureMessageBroker(MessageBrokerRegistry config) {
        config.enableSimpleBroker("/user","/agent","/topic"); // 定义消息代理，客户端订阅的地址前缀
        config.setApplicationDestinationPrefixes("/app"); // 定义客户端发送消息的地址前缀
        config.setUserDestinationPrefix("/user");
    }
 
    @Override
    public void registerStompEndpoints(StompEndpointRegistry registry) {
        registry.addEndpoint("/chat").setAllowedOriginPatterns("*").withSockJS(); // 定义WebSocket端点，客户端连接的地址
    }
}

（2） ChatController.java控制层

package com.example.mengchuangyuan.common.chat.controller;
 
import com.example.mengchuangyuan.common.chat.entry.ChatMessage;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.messaging.handler.annotation.MessageMapping;
import org.springframework.messaging.handler.annotation.SendTo;
import org.springframework.messaging.simp.SimpMessagingTemplate;
import org.springframework.messaging.simp.annotation.SendToUser;
import org.springframework.stereotype.Controller;
 
@Slf4j
@Controller
public class ChatController {
    @Autowired
    private SimpMessagingTemplate simpMessagingTemplate;
 
    /**
     * 发消息（群发）
     * @param chatMessage 获取用户消息
     * @return 返回要回复的消息
     */
    //第一种方式
    @MessageMapping("/chat/send") // 定义消息映射路径
    @SendTo("/agent/public") // 发送消息到指定的代理路径
    public ChatMessage sendMessage(ChatMessage chatMessage) {
        log.info(chatMessage.toString());
        return chatMessage;
    }
 
    //方法二
//    @MessageMapping("/agent/send")
//    public void getAgentInfo (@Payload ChatMessage chatMessage) {
//        System.out.println("发送群发消息");
//        // 使用api进行推送
//        simpMessagingTemplate.convertAndSend("/agent/public2", chatMessage);
//    }
 
    /**
     * 发送给自己？
     * @param chatMessage
     * @return
     */
    @MessageMapping("/agent/send/user")
// 这里的路径必须还是以广播的前缀为前缀，否则无法接收
    @SendToUser("/agent/info")
    public ChatMessage sendUserMessage(ChatMessage chatMessage) {
        log.info(chatMessage.toString());
        return chatMessage;
    }
 
    /**
     * 发送给指定用户
     * @param chatMessage
     * @return
     */
    @MessageMapping("/chat/send/to/user")
// 这里的路径必须还是以广播的前缀为前缀，否则无法接收
    public void sendToUserMessage(ChatMessage chatMessage) {
        log.info("发送给指定用户:"+chatMessage.toString());
        simpMessagingTemplate.convertAndSendToUser(chatMessage.getUnionId(),"/message",chatMessage);
    }
}

package com.example.mengchuangyuan.common.chat.entry;
 
import lombok.Data;
 
@Data
public class ChatMessage {
    private String unionId;
    private String content;
    private String sender; 
}

以上就是完整代码 3. 接下来我来简单解释一下，因为一对一聊天比其他相对绕一点，所以博主就解释它就好了，且看下面四段被截取的代码

function connect() {
	var content = $("#message").val();//发送的消息内容
    var sender = 'tbb';//接收的人
    var socket = new SockJS('http://127.0.0.1:8080/chat');//连接后端socket的地址
    stompClient = Stomp.over(socket);
    stompClient.connect({}, function (frame) {
        console.log('Connected: ' + frame);
        //这里我写死了，接收来自tbb这个人的消息，'/user/tbb/message'可以改成'/user/'+sender+'/message'
        stompClient.subscribe('/user/tbb/message', function (message) { 
            showMessage(JSON.parse(message.body));
        });
    });
}

上面的代码可以称之为连接服务器并且实时监听tbb给后端发来的消息

package com.example.mengchuangyuan.common.chat.config;
 
import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.simp.config.MessageBrokerRegistry;
import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker;
import org.springframework.web.socket.config.annotation.StompEndpointRegistry;
import org.springframework.web.socket.config.annotation.WebSocketMessageBrokerConfigurer;
 
@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {
 
    @Override
    public void configureMessageBroker(MessageBrokerRegistry config) {
        config.enableSimpleBroker("/user","/agent","/topic"); // 定义消息代理，客户端订阅的地址前缀
        config.setApplicationDestinationPrefixes("/app"); // 定义客户端发送消息的地址前缀
        config.setUserDestinationPrefix("/user");
    }
 
    @Override
    public void registerStompEndpoints(StompEndpointRegistry registry) {
        registry.addEndpoint("/chat").setAllowedOriginPatterns("*").withSockJS(); // 定义WebSocket端点，客户端连接的地址
    }
}

上面两段是对应的，在html的http://127.0.0.1:8080/chat中chat对应上面Java代码的chat，必须一致，要不然连不上，/user/tbb/message路由中user对应上面Java代码的user，必须一致，要不然发消息时对方收不到消息（博主以前踩过这个坑），而这个tbb则是接收发消息的人的消息

function sendMessage() { //发消息给对方
    var content = $("#message").val();
    var sender = $("#sender").val();
    stompClient.send("/app/chat/send/to/user", {}, JSON.stringify({ //发消息的后端的路由
        content: content,//消息内容
        sender: sender,//消息姓名
	    unionId: sender,//消息id，这里我把消息姓名也作为id
    }));
}
/**
    * 发送给指定用户
    * @param chatMessage
    * @return
*/
@MessageMapping("/chat/send/to/user")
// 这里的路径必须还是以广播的前缀为前缀，否则无法接收
public void sendToUserMessage(ChatMessage chatMessage) {
    log.info("发送给指定用户:"+chatMessage.toString());
    //chatMessage.getUnionId()是发送给某人的id，/message对应四段中第一段的/user/tbb/message中的message
    simpMessagingTemplate.convertAndSendToUser(chatMessage.getUnionId(),"/message",chatMessage);
}

最后两段是对应的，用于给对方发消息。

三、微信小程序实现聊天

首先，这是博主自己摸索了很久出来的一套小程序聊天体系。

聊天数据结构及框架

涉及到了redis缓存，因此需要下载redis的依赖包
聊天数据结构如下（自我感觉存在一定缺陷，懒得改进了）：
整体储存结构：
聊天界面结构：{openid1+openid2:{linkType:[info1,info2]}}，
聊天列表结构：{linkType:[openid1+openid2,openid3+openid4]}
info的结构：{mid:"",type:"",linkType:"",formUser:fromUser,toUser:toUser,message:"",date:"",nowDate:""}
fromUser和toUser的结构：{openid:"",phone:"",name:"",headImg:""}
openid1和openid2为fromUser和toUser的openid
linkType：属于哪个板块聊天(比如相亲聊天板块或者外卖或商城聊天板块)
type：作用于获取redis缓存的聊天记录和聊天心跳检测(备注：因为获取历史聊天记录和心跳检测是以聊天方式向后端发起请求，因此我用type的聊天要区分是用户发起聊天还是其他请求。由前端自动发动聊天请求，获取历史聊天记录，由前端发起聊天请求检测心跳，检测心跳的目的是为了确保聊天过程不掉线)
date：聊天的时间段(备注：可以设置5分钟显示一个时间段聊天的时间，比如微信隔5分钟后再发一条信息上面会显示时间，这里我设置的date就充当这个角色)
nowDate：每一句话的时间，主要用于计算当前时间是否与上一句聊天记录的时间是否间隔5分钟，如果间隔5分钟那么上面的date记录该时间，如果间隔不到5分钟，则date设置为空。
整体结构上：两个人的openid连接作为获取他们之间所有功能板块历史聊天记录的内容的键(key)。以linkType作为键(key)获取某个功能板块的所有历史聊天记录，这里聊天记录用集合来储存保证了聊天记录顺序。

Java SpringBoot代码

MiniWebSocketConfig.java文件

package com.example.mengchuangyuan.common.chat.mini.config;
 
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.socket.server.standard.ServerEndpointExporter;
 
@Configuration
public class MiniWebSocketConfig {
    @Bean
    public ServerEndpointExporter serverEndpointExporter() {
        return new ServerEndpointExporter();
    }
}

MiniWebSocketController.java文件

package com.example.mengchuangyuan.common.chat.mini.controller;
 
import com.example.mengchuangyuan.common.redis.tool.SufferVariable;
import com.example.mengchuangyuan.common.tool.Result;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
 
import java.io.File;
import java.io.IOException;
import java.util.*;
 
@Slf4j
@RestController
@RequestMapping("/mini/socket")
public class MiniWebSocketController {
    @Value("${upload.messageChatUrl}")
    private String messageChatUrl;
 
    @Value("${upload.messageChatPath}")
    private String messageChatPath;
 
    private final List<Map<String,Object>> mapList = new ArrayList<>();
 
    @GetMapping("/get/openid/history")
    private Result getOpenidHistory(@RequestParam("openid") String openid,@RequestParam("linkType") String linkType){
//        log.info(openid);
        List<String> openids = (List<String>) SufferVariable.openidKeys.get(linkType);
//        if (keyMap==null){
//            return Result.error();
//        }
//        List<String> openids = (List<String>) keyMap.get(openid);
//        log.info("所以openid"+String.valueOf(openids));
        if (openids==null){
            return Result.error();
        }
        mapList.clear();
        for (String openid1: openids) {
            if (openid1.contains(openid)) {
//            if (SufferVariable.messageMap.get(openid1)!=null){
                mapList.add((Map<String, Object>) SufferVariable.messageMap.get(openid1));
//                log.info("聊天记录缓存"+openid);
//                log.info(String.valueOf(SufferVariable.messageMap.get(openid1)));
 
//            }
            }
        }
        return Result.success(mapList);
    }
 
 
//上传聊天图片
    @PostMapping("/img/upload")
    public Result imgUpDown(@RequestParam("file") MultipartFile file,
                            @RequestParam("filename") String filename) throws IOException {
        System.out.println(filename);
        File file1 = new File(messageChatPath,filename);
        if(!file1.exists()) {
            if(!file1.mkdirs()){ //创建目录
                return Result.error();
            }
        }
        //获取文件名
        String fileName = file.getOriginalFilename();
        //获取文件后缀名。也可以在这里添加判断语句，规定特定格式的图片才能上传，否则拒绝保存。
        String suffixName = fileName.substring(fileName.lastIndexOf("."));
        //为了避免发生图片替换，这里使用了文件名重新生成
        fileName = UUID.randomUUID()+suffixName;
 
        file.transferTo(new File(file1,fileName));
 
        return Result.success(messageChatUrl+filename+"/"+fileName);
    }
}

WebSocketEndPoint.java文件

package com.example.mengchuangyuan.common.chat.mini.mapper;
 
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.example.mengchuangyuan.common.redis.mapper.RedisUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
 
import javax.annotation.PostConstruct;
import javax.websocket.OnClose;
import javax.websocket.OnMessage;
import javax.websocket.OnOpen;
import javax.websocket.Session;
import javax.websocket.server.PathParam;
import javax.websocket.server.ServerEndpoint;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
 
//对外公布的一个后端站点
//ws://localhost:8080/websocket/用户id
@ServerEndpoint(value = "/websocket/{userId}")
@Component
@Slf4j
public class WebSocketEndPoint {
    //与某个客户端的连接会话，需要他来给客户端发送数据
    private Session session;
 
    @Autowired
    private SessionPool sessionPool;
//    @Autowired
//    private RedisUtils redisUtils;
    private static WebSocketEndPoint webSocketEndPoint;
    //初始化 ②
    @PostConstruct
    public void init() {
        webSocketEndPoint = this;
        webSocketEndPoint.sessionPool = this.sessionPool;
    }
 
    //连接建立成功调用的方法
    @OnOpen
    public void onOpen(Session session, @PathParam("userId") String userId) {
        //把会话加入连接池中
        //userId通过用户传入，session是系统自动产生
        SessionPool.sessions.put(userId, session);
 
        //TODO 可以添加日志操作
    }
 
    //关闭会话的时候
    @OnClose
    public void onClose(Session session) throws IOException {
        webSocketEndPoint.sessionPool.close(session.getId());
        session.close();
    }
 
    //接收客户端的消息后调用的方法，在这里可以进行各种业务逻辑的操作
    @OnMessage
    public void onMessage(String message, Session session) {
        System.out.println(message);
//        log.info("redisUtils:"+redisUtils);
        //心跳检测
        if (message.equalsIgnoreCase("ping")) {
            try {
                Map<String, Object> params = new HashMap<>();
                params.put("type", "pong");
                session.getBasicRemote().sendText(JSON.toJSONString(params));
            } catch (Exception e) {
                e.printStackTrace();
            }
            return;
        }
        //将Json字符串转为键值对
//        HashMap params = JSON.parseObject(message, HashMap.class);
        JSONObject params =  JSON.parseObject(message);
        webSocketEndPoint.sessionPool.sendMessage(params);
 
        //这里的业务逻辑仅仅是把收到的消息返回给前端
//        SessionPool.sendMessage(message);
    }
}

SessionPool.java文件

package com.example.mengchuangyuan.common.chat.mini.mapper;
 
import com.alibaba.fastjson.JSON;
import com.example.mengchuangyuan.common.redis.mapper.RedisUtils;
import com.example.mengchuangyuan.common.redis.tool.SufferVariable;
import com.example.mengchuangyuan.common.tool.DateYMDms;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Controller;
 
import javax.websocket.Session;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
 
@Component
@Slf4j
public class SessionPool {
    @Autowired
    private RedisUtils redisUtils;
 
    //key-value : userId - 会话（系统创建）
    public static Map<String, Session> sessions = new ConcurrentHashMap<>();//避免多线程问题
 
    public void close(String sessionId) {
        //sessionId是在session中添加了一个标识，准确定位某条session
        for (String userId : SessionPool.sessions.keySet()) {
            Session session = SessionPool.sessions.get(userId);
            if (session.getId().equals(sessionId)) {
                sessions.remove(userId);
                break;
            }
        }
    }
 
    public void sendMessage(String userId, String message) {
        sessions.get(userId).getAsyncRemote().sendText(message);
    }
 
 
    //消息的群发，业务逻辑的群发
    public void sendMessage(String message) {
//        redisUtils.cacheValue("chatMessage","String.valueOf(SufferVariable.messageMap)");
        for (String sessionId : SessionPool.sessions.keySet()) {
            SessionPool.sessions.get(sessionId).getAsyncRemote().sendText(message);
        }
    }
 
    //点对点的消息推送
    public void sendMessage(Map<String, Object> params) {
        log.info("消息内容："+String.valueOf(params));
        long mid = System.currentTimeMillis();
        Map<String,Object> formUser = (Map<String, Object>) params.get("formUser");
        Map<String,Object> toUser = (Map<String, Object>) params.get("toUser");
 
        String userId = formUser.get("openid").toString();
        String toUserId = toUser.get("openid").toString();
//        String msg = params.get("message").toString();
        String type  = params.get("type").toString();
        String linkType = params.get("linkType").toString();
        //获取用户session
        Session session = sessions.get(toUserId);
 
        Map<String,Object> keyMap;
        List<String> setOpenid;
        Map<String,Object> map;
        List<Object> list;
        String uid = userId+toUserId;
        params.put("mid",mid);
 
        if (SufferVariable.messageMap.get(userId+toUserId)==null&&SufferVariable.messageMap.get(toUserId+userId)==null){
//            messageMap.put(userId+toUserId,userId+toUserId);
            map = new HashMap<>();
            list = new ArrayList<>();
 
            map.put(linkType,list);
            SufferVariable.messageMap.put(uid,map);
 
//            list.add(params);
 
        }else {
            if (SufferVariable.messageMap.get(userId+toUserId)!=null){
                uid = userId+toUserId;
 
            }else {
               uid = toUserId+userId;
            }
            map = (Map<String, Object>) SufferVariable.messageMap.get(uid);
            list = (List<Object>) map.get(linkType);
 
        }
 
        //获取历史记录
        if (type.equalsIgnoreCase("history")){
            if (sessions.get(userId) != null) {
                Map<String, Object> map2 = new HashMap<>();
//                map = (Map<String, Object>) SufferVariable.messageMap.get(uid);
                map2.put("type", "isHistory");
                map2.put("message",list);
                sessions.get(userId).getAsyncRemote().sendText(JSON.toJSONString(map2));
            }
            return;
        }
        String nowDate = DateYMDms.getUtilDate();
        if (list.size()!=0) {
            Map<String, Object> lastMap = (Map<String, Object>) list.get(list.size() - 1);
            String date = DateYMDms.getYMDms(5, lastMap.get("nowDate").toString());
            params.put("date", date);
        }else {
            params.put("date", nowDate);
        }
//        if (SufferVariable.openidKeys.get(linkType)==null){
//            keyMap = new HashMap<>();
//        }else {
//            keyMap = (Map<String, Object>) SufferVariable.openidKeys.get(linkType);
//        }
//        if (keyMap.get(userId)==null){
//            setOpenid = new ArrayList<>();
//        }else {
//            log.info(String.valueOf(SufferVariable.openidKeys));
//            setOpenid = (List<String>) keyMap.get(userId);
//        }
        if (SufferVariable.openidKeys.get(linkType) == null){
            setOpenid = new ArrayList<>();
        }else {
            setOpenid = (List<String>) SufferVariable.openidKeys.get(linkType);
        }
        setOpenid.add(uid);
        Set<String> set = new LinkedHashSet<>(setOpenid);
        setOpenid.clear();
        setOpenid.addAll(set);
//        keyMap.put(userId,setOpenid);
        SufferVariable.openidKeys.put(linkType,setOpenid);
 
        params.put("nowDate",nowDate);
        list.add(params);
        map.put(linkType,list);
        SufferVariable.messageMap.put(uid,map);
        redisUtils.cacheValue("chatMessage",SufferVariable.messageMap);
        redisUtils.cacheValue("chatOpenidKeys",SufferVariable.openidKeys);
 
        if (session != null) {
            log.info(uid+"："+String.valueOf(SufferVariable.messageMap.get(uid)));
            session.getAsyncRemote().sendText(JSON.toJSONString(params));
        }
//        log.info(String.valueOf(messageMap));
//        params.remove("formUserId");
        //session不为空的情况下进行点对点推送
    }
}

以上小程序相关代码存在一些缺陷，并且未完整，需要小程序及SpringBoot完整代码的朋友可以私信博主，好了本次分享就到此结束。

Android开发：权限处理、文件存储、图片处理常用代码

Wed, 22 Apr 2026 19:00:00 +0800

一、权限处理代码

以外部存储写入权限为例，适配Android 6.0+动态权限。

1. 权限申请方法

private void requestWritePermission(){
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        if(checkSelfPermission(Manifest.permission.WRITE_EXTERNAL_STORAGE)!= PackageManager.PERMISSION_GRANTED){
            ActivityCompat.requestPermissions(this,new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE},WRITE_PERMISSION);
        }
    }
}

2. 权限结果回调

@Override
public void onRequestPermissionsResult(
        int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
    super.onRequestPermissionsResult(requestCode, permissions, grantResults);
    if (requestCode == Permission.REQUEST_CODE) {
        for (int grantResult : grantResults) {
            if (grantResult != PackageManager.PERMISSION_GRANTED) {
                Log.e("Permission","授权失败！");
                // 授权失败，退出应用
                this.finish();
                return;
            }
        }
    }
}

3. 在 onCreate 中调用

protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    requestWritePermission();
}

二、文件存储工具类（FileUtils）

包含文件创建、删除、复制、Bitmap 转字节、MD5、数据库备份等常用方法。

import android.content.Context;
import android.graphics.Bitmap;
import android.os.Environment;
import android.text.TextUtils;
import android.util.Log;

import java.io.BufferedOutputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.channels.FileChannel;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public class FileUtils {

    private String TAG = FileUtils.class.getSimpleName();
    public static String SDPATH = Environment.getExternalStorageDirectory() + "/.photocomb/";
    public static String DBName = "privalbum.db";
    public static String DBPATH = "/data/data/com.cm.photocomb/databases/" + DBName;

    /**
     * 操作成功返回值
     */
    public static final int SUCCESS = 0;

    /**
     * 操作失败返回值
     */
    public static final int FAILED = -1;

    private static final int BUF_SIZE = 32 * 1024; // 32KB

    /**
     * 获取录音文件路径
     */
    public static String getFileName() {
        String path = SDPATH;
        File file = new File(path);
        file.mkdirs();
        path += System.currentTimeMillis();
        return path;
    }

    /**
     * Bitmap转字节数组
     */
    public static byte[] Bitmap2Bytes(Bitmap bm) {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        bm.compress(Bitmap.CompressFormat.PNG, 100, baos);
        return baos.toByteArray();
    }

    /**
     * bytes转十六进制字符串
     */
    public static String byte2HexStr(byte[] b) {
        String stmp = "";
        StringBuilder sb = new StringBuilder("");
        for (int n = 0; n < b.length; n++) {
            stmp = Integer.toHexString(b[n] & 0xFF);
            sb.append((stmp.length() == 1) ? "0" + stmp : stmp);
            sb.append(" ");
        }
        return sb.toString().toUpperCase().trim();
    }

    /**
     * 十六进制字符串转byte数组
     */
    public static byte[] hexStr2Bytes(String src) {
        int m = 0, n = 0;
        int l = src.length() / 2;
        byte[] ret = new byte[l];
        for (int i = 0; i < l; i++) {
            m = i * 2 + 1;
            n = m + 1;
            ret[i] = Byte.decode("0x" + src.substring(i * 2, m) + src.substring(m, n));
        }
        return ret;
    }

    public static String bytesToHexString(byte[] bytes) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < bytes.length; i++) {
            String hex = Integer.toHexString(0xFF & bytes[i]);
            if (hex.length() == 1) {
                sb.append('0');
            }
            sb.append(hex);
        }
        return sb.toString();
    }

    private static final char HEX_DIGITS[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };

    public static String toHexString(byte[] b) {
        StringBuilder sb = new StringBuilder(b.length * 2);
        for (int i = 0; i < b.length; i++) {
            sb.append(HEX_DIGITS[(b[i] & 0xf0) >>> 4]);
            sb.append(HEX_DIGITS[b[i] & 0x0f]);
        }
        return sb.toString();
    }

    /**
     * 计算文件MD5值
     */
    public static String md5sum(String filename) {
        if (TextUtils.isEmpty(filename)) {
            return null;
        }
        InputStream fis;
        byte[] buffer = new byte[1024];
        int numRead = 0;
        MessageDigest md5;
        try {
            fis = new FileInputStream(filename);
            md5 = MessageDigest.getInstance("MD5");
            while ((numRead = fis.read(buffer)) > 0) {
                md5.update(buffer, 0, numRead);
            }
            fis.close();
            return toHexString(md5.digest());
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * 保存Bitmap到文件
     */
    public static void saveBitmap(Bitmap bm, String picName) {
        Log.e("", "保存图片");
        try {
            File f = new File(picName);
            if (f.exists()) {
                f.delete();
            }
            FileOutputStream out = new FileOutputStream(f);
            if (bm != null) {
                bm.compress(Bitmap.CompressFormat.JPEG, 90, out);
            }
            out.flush();
            out.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static boolean saveBitmap(Bitmap bitmap, File file) {
        if (!file.getParentFile().exists()) {
            file.getParentFile().mkdirs();
        }
        if (file.exists()) {
            file.delete();
        }
        FileOutputStream out = null;
        try {
            out = new FileOutputStream(file);
            bitmap.compress(Bitmap.CompressFormat.JPEG, 90, out);
            out.flush();
            out.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            return false;
        } catch (IOException e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }

    /**
     * 创建SD卡目录
     */
    public static File createSDDir(String dirName) throws IOException {
        File dir = new File(SDPATH + dirName);
        if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
            dir.mkdir();
        }
        return dir;
    }

    /**
     * 判断文件是否存在
     */
    public static boolean isFileExist(String fileName) {
        File file = new File(SDPATH + fileName);
        return file.exists();
    }

    /**
     * 删除文件
     */
    public static void delFile(String fileName) {
        File file = new File(SDPATH + fileName);
        if (file.isFile()) {
            file.delete();
        }
    }

    /**
     * 删除目录及子文件
     */
    public static void deleteDir() {
        File dir = new File(SDPATH);
        if (dir == null || !dir.exists() || !dir.isDirectory())
            return;

        for (File file : dir.listFiles()) {
            if (file.isFile())
                file.delete();
            else if (file.isDirectory())
                deleteDir();
        }
        dir.delete();
    }

    public static boolean fileIsExists(String path) {
        try {
            File f = new File(path);
            return f.exists();
        } catch (Exception e) {
            return false;
        }
    }

    /**
     * 删除单个文件
     */
    public static boolean deleteFile(String sPath) {
        File file = new File(sPath);
        if (file.isFile() && file.exists()) {
            file.delete();
            return true;
        }
        return false;
    }

    /**
     * 删除目录及目录下所有文件
     */
    public static boolean deleteDirectory(String sPath) {
        if (TextUtils.isEmpty(sPath)) {
            return false;
        }
        if (!sPath.endsWith(File.separator)) {
            sPath = sPath + File.separator;
        }
        File dirFile = new File(sPath);
        if (!dirFile.exists() || !dirFile.isDirectory()) {
            return false;
        }
        boolean flag = true;
        File[] files = dirFile.listFiles();
        for (File file : files) {
            if (file.isFile()) {
                flag = deleteFile(file.getAbsolutePath());
                if (!flag) break;
            } else {
                flag = deleteDirectory(file.getAbsolutePath());
                if (!flag) break;
            }
        }
        if (!flag) return false;
        return dirFile.delete();
    }

    /**
     * 文件转字节数组
     */
    public static byte[] getBytesFromFile(File f) {
        if (f == null) {
            return null;
        }
        try {
            FileInputStream stream = new FileInputStream(f);
            ByteArrayOutputStream out = new ByteArrayOutputStream(1000);
            byte[] b = new byte[1000];
            int n;
            while ((n = stream.read(b)) != -1) {
                out.write(b, 0, n);
            }
            stream.close();
            out.close();
            return out.toByteArray();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 字节数组保存为文件
     */
    public static File getFileFromBytes(byte[] b, String outputFile) {
        BufferedOutputStream stream = null;
        File file = null;
        try {
            file = new File(outputFile);
            FileOutputStream fstream = new FileOutputStream(file);
            stream = new BufferedOutputStream(fstream);
            stream.write(b);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (stream != null) {
                try {
                    stream.close();
                } catch (IOException e1) {
                    e1.printStackTrace();
                }
            }
        }
        return file;
    }

    /**
     * 备份数据库
     */
    public static void backupDB(Context mContext) {
        try {
            File backup = new File(SDPATH + DBName);
            File dbFile = mContext.getDatabasePath(DBPATH);
            backup.createNewFile();
            fileCopy(dbFile, backup);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 文件复制
     */
    public static void fileCopy(File dbFile, File backup) throws IOException {
        FileChannel inChannel = new FileInputStream(dbFile).getChannel();
        FileChannel outChannel = new FileOutputStream(backup).getChannel();
        try {
            inChannel.transferTo(0, inChannel.size(), outChannel);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (inChannel != null) {
                inChannel.close();
            }
            if (outChannel != null) {
                outChannel.close();
            }
        }
    }

    /**
     * assets文件复制到本地
     */
    public static int assetToFile(Context context, String assetName, String path) {
        return assetToFile(context, assetName, new File(path));
    }

    public static int assetToFile(Context context, String assetName, File file) {
        InputStream is = null;
        try {
            is = context.getAssets().open(assetName);
            return streamToFile(file, is, false);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (is != null) is.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return FAILED;
    }

    /**
     * 流写入文件
     */
    public static int streamToFile(String path, InputStream is, boolean isAppend) {
        return streamToFile(new File(path), is, isAppend);
    }

    public static int streamToFile(File file, InputStream is, boolean isAppend) {
        checkParentPath(file);
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream(file, isAppend);
            byte[] buf = new byte[BUF_SIZE];
            int readSize;
            while ((readSize = is.read(buf)) != -1)
                fos.write(buf, 0, readSize);
            fos.flush();
            return SUCCESS;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (fos != null) fos.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return FAILED;
    }

    /**
     * 检查并创建父目录
     */
    public static void checkParentPath(String path) {
        checkParentPath(new File(path));
    }

    public static void checkParentPath(File file) {
        File parent = file.getParentFile();
        if (parent != null && !parent.isDirectory())
            createDir(parent);
    }

    /**
     * 创建文件夹
     */
    public static int createDir(String path) {
        return createDir(new File(path));
    }

    public static int createDir(File file) {
        if (file.exists()) {
            if (file.isDirectory())
                return SUCCESS;
            file.delete();
        }
        if (file.mkdirs())
            return SUCCESS;
        return FAILED;
    }
}

三、图片处理工具类（XUtils）

包含图片压缩、旋转纠正、获取缩略图、Bitmap 保存、网络判断、内存获取等。

import android.app.ActivityManager;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Bitmap.Config;
import android.graphics.BitmapFactory;
import android.graphics.BitmapFactory.Options;
import android.graphics.Matrix;
import android.media.ExifInterface;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.text.TextUtils;
import android.util.Log;

import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.FileChannel.MapMode;

public class XUtils {

    /**
     * 判断文件是否存在
     */
    public static Boolean fileExists(String vPath) {
        if (null == vPath || "".equals(vPath)) {
            return false;
        }
        try {
            File file = new File(vPath);
            return file.exists();
        } catch (Exception e) {
            return false;
        }
    }

    /**
     * 计算图片缩放比例
     */
    public static int calculateInSampleSize(Options options, int maxWidth, int maxHeight) {
        int inSampleSize = 1;
        final int height = options.outHeight;
        final int width = options.outWidth;
        int minhw = Math.min(height, width);

        if (minhw >= maxWidth) {
            inSampleSize = Math.round((float) width / (float) maxWidth);
            while (minhw / inSampleSize > maxWidth) {
                inSampleSize *= 2;
            }
        }
        return inSampleSize;
    }

    /**
     * 获取图片缩略图（带旋转纠正）
     */
    public static Bitmap getThumbImg(String vPath, int vWidth, int vHeight) {
        if (null == vPath || vPath.trim().equals("")) {
            return null;
        }
        File file = new File(vPath);
        if (!file.exists()) {
            return null;
        }
        Options options = new Options();
        options.inJustDecodeBounds = true;
        BitmapFactory.decodeFile(vPath, options);
        if (options.outWidth <= 0 || options.outHeight <= 0) {
            return null;
        }
        options.inSampleSize = calculateInSampleSize(options, vWidth, vHeight);
        options.inJustDecodeBounds = false;
        Bitmap thumbImgNow = null;
        try {
            thumbImgNow = BitmapFactory.decodeFile(vPath, options);
        } catch (OutOfMemoryError e) {
            return null;
        }
        int degree = readPictureDegree(vPath);
        if (degree != 0) {
            thumbImgNow = rotateImage(degree, thumbImgNow);
        }
        return thumbImgNow;
    }

    /**
     * 旋转图片
     */
    public static Bitmap rotateImage(int angle, Bitmap bitmap) {
        if (null == bitmap) {
            return null;
        }
        Matrix matrix = new Matrix();
        matrix.postRotate(angle);
        try {
            return Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true);
        } catch (OutOfMemoryError e) {
            return bitmap;
        }
    }

    /**
     * 读取图片旋转角度
     */
    public static int readPictureDegree(String path) {
        int degree = 0;
        try {
            ExifInterface exifInterface = new ExifInterface(path);
            int orientation = exifInterface.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL);
            switch (orientation) {
                case ExifInterface.ORIENTATION_ROTATE_90:
                    degree = 90;
                    break;
                case ExifInterface.ORIENTATION_ROTATE_180:
                    degree = 180;
                    break;
                case ExifInterface.ORIENTATION_ROTATE_270:
                    degree = 270;
                    break;
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return degree;
    }

    /**
     * 字节数组保存到文件
     */
    public static Boolean saveByteToFile(byte[] vData, String vFilePath) {
        if (null == vData || TextUtils.isEmpty(vFilePath)) {
            return false;
        }
        File tFile = new File(vFilePath);
        try {
            FileOutputStream fos = new FileOutputStream(tFile);
            fos.write(vData);
            fos.close();
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 从文件读取字节数组
     */
    public static byte[] loadByteFromFile(String vFilePath, int vLen) {
        if (TextUtils.isEmpty(vFilePath) || vLen < 1) {
            return null;
        }
        File tFile = new File(vFilePath);
        byte[] tByte = new byte[vLen];
        try (FileInputStream fin = new FileInputStream(tFile)) {
            int r = fin.read(tByte);
            if (r != vLen) {
                throw new IOException("Can't read all");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return tByte;
    }

    /**
     * 保存Bitmap到本地
     */
    public static Boolean saveBitmap(Bitmap vBmp, String vPath) {
        if (null == vBmp || vBmp.isRecycled() || TextUtils.isEmpty(vPath)) {
            return false;
        }
        File file = new File(vPath).getParentFile();
        if (!file.exists()) {
            file.mkdirs();
        }
        try {
            FileOutputStream fout = new FileOutputStream(vPath);
            BufferedOutputStream bos = new BufferedOutputStream(fout);
            vBmp.compress(Bitmap.CompressFormat.JPEG, 100, bos);
            bos.flush();
            bos.close();
            return true;
        } catch (IOException e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 判断网络是否连接
     */
    public static Boolean isNetworkConnected(Context context) {
        if (context != null) {
            ConnectivityManager mConnectivityManager = (ConnectivityManager) context
                    .getSystemService(Context.CONNECTIVITY_SERVICE);
            NetworkInfo mNetworkInfo = mConnectivityManager.getActiveNetworkInfo();
            return mNetworkInfo != null && mNetworkInfo.isAvailable();
        }
        return false;
    }

    /**
     * 获取可用内存
     */
    public static long getmem_UNUSED(Context mContext) {
        ActivityManager am = (ActivityManager) mContext.getSystemService(Context.ACTIVITY_SERVICE);
        ActivityManager.MemoryInfo mi = new ActivityManager.MemoryInfo();
        am.getMemoryInfo(mi);
        return mi.availMem / 1024;
    }

    /**
     * Bitmap拷贝（防内存溢出）
     */
    public static Bitmap bmpcopy(Bitmap srcBmp) {
        Bitmap destBmp = null;
        try {
            File file = new File("/mnt/sdcard/tempbmp/tmp.txt");
            file.getParentFile().mkdirs();
            RandomAccessFile randomAccessFile = new RandomAccessFile(file, "rw");
            int width = srcBmp.getWidth();
            int height = srcBmp.getHeight();
            FileChannel channel = randomAccessFile.getChannel();
            MappedByteBuffer map = channel.map(MapMode.READ_WRITE, 0, (long) width * height * 4);
            srcBmp.copyPixelsToBuffer(map);
            srcBmp.recycle();
            destBmp = Bitmap.createBitmap(width, height, Config.ARGB_8888);
            map.position(0);
            destBmp.copyPixelsFromBuffer(map);
            channel.close();
            randomAccessFile.close();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return destBmp;
    }

    /**
     * 等比缩放图片（按最小边缩放）
     */
    public static Bitmap getScaledBitmap(String vPath, int vMinWidth) {
        if (null == vPath || vPath.trim().equals("")) {
            return null;
        }
        File file = new File(vPath);
        if (!file.exists()) {
            return null;
        }
        Options options = new Options();
        options.inJustDecodeBounds = true;
        BitmapFactory.decodeFile(vPath, options);
        if (options.outWidth <= 0 || options.outHeight <= 0) {
            return null;
        }
        int tMinWidth = Math.min(options.outWidth, options.outHeight);
        options.inSampleSize = Math.max(1, tMinWidth / vMinWidth);
        options.inJustDecodeBounds = false;
        Bitmap thumbImgNow = null;
        try {
            thumbImgNow = BitmapFactory.decodeFile(vPath, options);
        } catch (OutOfMemoryError e) {
            return null;
        }
        int degree = readPictureDegree(vPath);
        if (degree != 0) {
            thumbImgNow = rotateImage(degree, thumbImgNow);
        }
        int wid = thumbImgNow.getWidth();
        int hgt = thumbImgNow.getHeight();
        tMinWidth = Math.min(wid, hgt);
        if (tMinWidth > vMinWidth) {
            float ratio = ((float) vMinWidth) / tMinWidth;
            Matrix matrix = new Matrix();
            matrix.postScale(ratio, ratio);
            thumbImgNow = Bitmap.createBitmap(thumbImgNow, 0, 0, wid, hgt, matrix, true);
        }
        return thumbImgNow;
    }
}

说明

代码适配Android 6.0+，存储权限需动态申请。
文件存储路径、包名可根据项目自行修改。
图片处理已做OOM 防护与旋转自动纠正。

若依访问404 Initializing Spring DispatcherServlet 'dispatcherServlet' 问题解决

Tue, 21 Apr 2026 15:00:00 +0800

问题描述

新建若依模块之后，启动项目访问接口出现 404，控制台只输出一句： Initializing Spring DispatcherServlet ‘dispatcherServlet’ 没有其他报错信息，接口无法访问。

问题原因

出现这种情况通常有以下几种可能：

模块没有被正确扫描，Controller 没有注入 Spring 容器
包路径不规范，不在默认扫描范围 com.ruoyi 下
启动类没有扫描到新包
访问路径写错
被权限框架拦截
路由配置错误

解决方案

一、检查包名结构

若依默认扫描的包是： com.ruoyi 你的新模块必须在 com.ruoyi.xxx 下，否则不会被加载。错误结构示例： com.test.project 正确结构：

1
2
3

com.ruoyi.project
com.ruoyi.demo
com.ruoyi.xxx

二、检查启动类扫描范围

在启动类 RuoYiApplication.java 中确认扫描包：

@SpringBootApplication(scanBasePackages = "com.ruoyi")
public class RuoYiApplication {
    public static void main(String[] args) {
        SpringApplication.run(RuoYiApplication.class, args);
    }
}

如果你的模块不在 com.ruoyi 下，需要手动加入：

`1`	`scanBasePackages = {"com.ruoyi", "com.自定义包"}`

三、检查 Controller 注解

确保类上添加了 @RestController 或 @Controller：

@RestController
@RequestMapping("/demo")
public class DemoController {

    @GetMapping("/test")
    public String test() {
        return "hello";
    }
}

四、检查访问路径是否正确

如果 Controller 是：

@RequestMapping("/user")
public class UserController {

    @GetMapping("/info")
    public String info() {
        return "info";
    }
}

访问路径应为： http://localhost:8080/user/info

五、检查是否被权限拦截

在 SecurityConfig.java 中放行路径：

`1`	`.antMatchers("/demo/**").permitAll()`

六、检查是否注册到 Spring 容器

启动时打开日志，查看是否有你的 Controller 被加载：

`1`	`com.ruoyi.xxx.controller.XXXController`

如果没有出现，说明没有被扫描到。

七、检查 Spring MVC 配置

确认 DispatcherServlet 正常加载，控制台应出现类似日志：

1
2

Mapping servlet: 'dispatcherServlet' to [/]
Mapped URL path [/demo/**] onto handler XXXController

七、最终总结

出现 Initializing Spring DispatcherServlet ‘dispatcherServlet’ 且接口 404，99% 是以下原因：

包不在com.ruoyi下
Controller没加注解
路径写错
被权限拦截
模块未被Spring 扫描
按照上面步骤逐一排查即可解决。

Posts on 进制动态

2026年AI大模型行业应用突破：从实验室到产业落地的关键进展

2026年三大技术突破：CPO规模化落地、AIGC爆发与多模态大模型革新

2026年AI医疗影像诊断：技术突破与临床应用全景解析

技术突破：破解基层医疗影像诊断痛点

临床应用：从效率提升到漏诊率下降

行业趋势：从单点工具到全病程管理

热门技术文章

具身智能：让AI从屏幕走向现实的革命性突破

具身智能：让AI从屏幕走向现实的革命性突破

一、具身智能的本质：会思考的"身体"

二、核心技术突破：通脑引擎与智能闭环

三、产业落地：从实验室到千行百业

商业零售：自主服务新范式

高危作业：脑控技术开辟新可能

特殊服务：导盲犬机器人突破无障碍障碍

四、未来展望：从通用智能到社会智能

2026进制动态：三进制突破与量子计算协同创新

2026量子计算商业化突破：从技术验证到产业落地的全球竞速

2026量子计算商业化突破：从技术验证到产业落地的全球竞速

量子计算2026：全球技术竞速与商业化破局

国内突破：超导算力网络的本土化实践

国际突破：密码学与硬件技术的双重革命

跨学科融合：生物与量子计算的深度碰撞

商业化加速：开放生态与行业落地

2026年AI智能体爆发：技术突破与政企应用全景

2026年AI智能体爆发：技术突破与政企应用全景

一、2026：AI智能体爆发的技术逻辑

二、政企应用：从概念到规模化创收

三、技术跃迁：自主决策与多模态交互

四、未来展望：基础设施到生态成熟

2026年4月全球前沿科技趋势：AI进化、量子突破与绿色能源革新

2026年4月全球前沿科技趋势：AI进化、量子突破与绿色能源革新

引言

AI进化：从工具到“未来伙伴”的范式跃迁

量子计算：中国突破硅基全栈运算，商业化加速

绿色能源：新一代太阳能电池效率突破15%

机器人技术：具身智能重塑产业与生活

结语

DeepSeek V4发布：百万上下文AI大模型实现国产算力突破

DeepSeek V4发布：百万上下文AI大模型实现国产算力突破

国产AI大模型迎来里程碑

技术突破与性能跃升

软硬协同构建国产算力生态

开启AI应用新时代

结语

2026年4月AI技术动态：GPT-5.5重磅发布与多模态智能体新纪元

2026年4月AI技术动态：GPT-5.5重磅发布与多模态智能体新纪元

2026年热门技术工具深度评测：AI与低代码平台全景解析

2026年热门技术工具深度评测

AI工具生态全面升级

开发工具重构工作流

低代码平台多元选型

2026年4月技术热点：AI智能体攻防爆发与量子安全新纪元

引言：技术变革的历史性节点

十大技术热点速览

产业影响与数据洞察

2026年核心技术赛道全景解析：从实验室到产业落地的突破之路

引言

人形机器人：具身智能开启产业新纪元

AI智能体：重塑生产组织模式

量子计算：纠错方案突破硬件瓶颈

生物制造与脑机接口：AI与生命科学融合

结语

2026年4月技术前沿：AI大模型爆发、智能体革命与量子安全新纪元

2026年4月技术前沿全景扫描

AI大模型战场硝烟再起

量子计算商业化加速

安全与效率双线突破

行业数据透视

SpringBoot 事务管理 @Transactional 实现转账功能（MyBatisPlus）

数据库表设计

实体类 User

Mapper 层

Service 层（事务核心）

Controller 层

关键说明

依赖（pom.xml）

Python 修改图片分辨率（单张/批量/等比例/递归覆盖）

1. 修改单张图片分辨率