在当今 AI 飞速发展的时代，大型语言模型 (LLM) 如 Claude、ChatGPT 等已经在代码生成、内容创作等方面展现出惊人的能力。然而，这些强大的模型存在一个明显的局限性——它们通常与外部系统和工具隔离，无法直接访问或操作用户环境中的资源和工具。

而 Model Context Protocol (MCP) 的出现，正是为了解决这一问题。

什么是MCP？

Model Context Protocol (MCP) 是由 Anthropic 公司推出的一个开放协议，它标准化了应用程序如何向大型语言模型 (LLM) 提供上下文和工具的方式。我们可以将 MCP 理解为 AI 应用的"USB-C 接口"——就像 USB-C 为各种设备提供了标准化的连接方式，MCP 为 AI 模型提供了与不同数据源和工具连接的标准化方式。

简单来说，MCP可以做到以下事情：

• 读取和写入本地文件


• 查询数据库


• 执行命令行操作


• 控制浏览器


• 与第三方 API 交互

这极大地扩展了 AI 助手的能力边界，使其不再仅限于对话框内的文本交互。

MCP的架构

以上图片来源于 MCP 官方文档

MCP 的架构相对简单，主要包含两个核心组件：

MCP 服务器向客户端提供两种主要能力：

• 工具 (Tools)：可执行的函数，允许 AI 执行特定操作


• 资源 (Resources)：提供给 AI 的上下文信息，如文件内容、数据库结构等

浏览器自动化：MCP的实际应用

为了更直观地理解 MCP 的强大之处，让我们看一个案例：使用 Playwright MCP 服务器进行浏览器自动化。

Playwright 是一个由 Microsoft 开发的浏览器自动化工具，可以控制 Chrome、Firefox、Safari 等主流浏览器。通过 Playwright MCP 服务器，我们可以让 AI 助手直接操作浏览器，执行各种任务。

先讲讲使用场景

场景一：博客写作的图片自动化

作为技术博主，我经常需要在文章中引用网站截图来说明问题或展示效果。在传统流程中，这个过程相当繁琐：

这个过程不仅耗时，而且容易出错。使用 Playwright MCP，整个流程可以简化为：

请访问 https://tailwindcss.com，截取首页顶部导航栏区域，保存到 @public/images/ 下，并生成 markdown 图片引用代码

Cursor 通过 MCP 协议会：

• 自动打开网站


• 精确定位并截取导航栏元素


• 保存到指定目录


• 自动生成符合博客格式的图片引用代码

这不仅节省了时间，还保证了图片引用的一致性和准确性。对于需要多张截图的长篇技术文章，效率提升尤为显著。

更进阶的应用还包括：

• 自动为截图添加高亮或注释


• 对比同一网站在不同设备上的显示效果


• 跟踪网站的 UI 变化并自动更新文章中的截图

场景二：端到端测试的自动化

端到端测试是前端开发中的重要环节，但传统方式存在诸多痛点：

即便使用 Chrome 的 DevTools 的 Recorder 功能，也只能生成 Playwright 的测试代码，并且需要人工介入，比如自定义 data-cy，浏览器操作一遍保存 playwright 的测试代码并扔给 cursor 生成测试。

或者通过 cursor 与 recorder 提效后的环节：

而通过 Playwright MCP，开发者可以自然语言描述测试场景，让 Cursor 直接生成并执行测试：

用户：测试我的登录流程：访问 http://localhost:3000/login，使用测试账号 test@example.com 和密码 Test123!，验证登录成功后页面应跳转到仪表盘并显示欢迎信息

Cursor 会：

• 在必要位置插入 data-cy 属性


• 自动访问登录页面


• 填写表单并提交


• 验证跳转和欢迎信息


• 报告测试结果


• 生成可复用的 Playwright 测试代码

这种方式不仅降低了编写测试的门槛，还能根据测试结果智能调整测试策略。例如，如果登录按钮位置变化，Cursor 可以通过视觉识别重新定位元素，而不是简单地报告选择器失效。

对于快速迭代的项目尤其有价值：

• 在代码修改后立即验证功能完整性


• 快速生成回归测试套件


• 模拟复杂的用户行为路径


• 根据用户反馈自动创建针对性测试

这两个场景说明，MCP 不仅仅是连接 AI 与工具的技术桥梁，更是能够实质性改变开发者工作流程的革新力量。通过消除重复性工作，开发者可以将更多精力集中在创意和解决问题上。

示例：使用executeautomation/mcp-playwright

executeautomation/mcp-playwright 是一个基于 Playwright 的 MCP 服务器实现，它提供了一系列工具，使得 AI 助手能够：

• 打开网页


• 截取网页或元素截图


• 填写表单


• 点击按钮


• 提取网页内容


• 执行 JavaScript 代码


• 等待网页加载或元素出现

下面以一个简单的场景为例：让 AI 助手打开一个网站并截图。

传统方式下，这个任务可能需要你：

而使用 MCP，整个过程可以简化为与 AI 助手的对话：

用户：请打开 Google 首页并截图

AI 助手：好的，我将为您打开 Google 首页并截图。

[AI 助手通过 MCP 控制浏览器，打开 google.com 并截图]

AI 助手：已成功截图，这是 Google 首页的截图。[显示截图]

整个过程中，用户不需要编写任何代码，AI 助手通过 MCP 服务器直接控制浏览器完成任务。

Playwright MCP 服务器的安装与配置

如果你想尝试使用 Playwright MCP 服务器，可以按照以下步骤进行设置：

在 Cursor 中使用 Playwright MCP

Cursor 是一款集成了 AI 能力的代码编辑器，它也支持 MCP 协议。我们可以在 Cursor 中配置 Playwright MCP 服务器，使 AI 助手能够在开发过程中直接操作浏览器。

配置步骤

使用场景示例

在 Cursor 中使用 Playwright MCP 可以大大提升前端开发和测试效率。以下是一些常见的使用场景：

通过这些场景，我们可以看到，Playwright MCP 在 Cursor 中的应用不仅简化了前端开发工作流，还提供了更直观的开发体验，让 AI 助手成为开发过程中的得力助手。

MCP 的优势与局限性

优势

局限性

Cursor 的 MCP 支持限制：

未来展望

MCP 作为一种连接 AI 与外部系统的标准化协议，有着广阔的应用前景：

结语

Model Context Protocol (MCP) 正在打破 AI 助手与外部世界之间的壁垒，使 AI 能够更加深入地融入我们的工作流程。从浏览器自动化到代码编辑器集成，MCP 展示了 AI 与传统工具结合的强大潜力。

以前可以说，Cursor 虽然代码敲的好，但它不能直接操作浏览器，不能直接操作数据库，不能直接操作文件系统，开发这个流程还是需要我频繁接手的。

现在来说，需要我们接手的次数会越来越少。

最后再推荐两个 MCP 相关的资源：

参考资料

在前端开发中，很多开发者都有一个常见误解：package.json 中的 devDependencies 是开发时依赖，因此不会被打包到最终的生产环境代码中。这个理解在一定条件下成立，但在真实项目中，打包工具（如 Vite、Webpack 等）并不会根据 devDependencies 或 dependencies 的位置来决定是否将依赖打包到最终的 bundle 中，而是完全俗义于代码中是否引用了这些模块。

本文将通过一个实际例子来说明这个问题，并提出一些实践建议来避免误用。

一、dependencies vs devDependencies 回顾

在 package.json 中，我们通常会看到两个依赖字段：

{

  "dependencies": {

    "lodash": "^4.17.21"

  },

  "devDependencies": {

    "vite": "^5.0.0"

  }

}

• dependencies：运行时依赖，通常用于项目在生产环境中运行所需的库。


• devDependencies：开发时依赖，通常用于构建、测试、打包等过程，比如 Babel、ESLint、Vite 等。

很多人认为把某个库放到 devDependencies 中就意味着它不会被打包进最终代码，但这只是约定俗成，并非构建工具的实际行为。

二、一个实际例子：lodash 被错误地放入 devDependencies

我们以一个使用 Vite 构建的库包为例：

目录结构：

my-lib/

├── src/

│   └── index.ts

├── package.json

├── vite.config.ts

└── tsconfig.json

src/index.ts

import _ from 'lodash';



export function capitalizeName(name: string) {

  return _.capitalize(name);

}

错误的 package.json

{

  "name": "my-lib",

  "version": "1.0.0",

  "main": "dist/index.js",

  "module": "dist/index.mjs",

  "types": "dist/index.d.ts",

  "scripts": {

    "build": "vite build"

  },

  "devDependencies": {

    "vite": "^5.0.0",

    "lodash": "^4.17.21",

    "typescript": "^5.4.0"

  }

}

注意：lodash 被放到了 devDependencies 中，而不是 dependencies中。

构建后结果：

执行 npm run build 后，你会发现 lodash 的代码被打包进了最终输出的 bundle 中，尽管它被标记为 devDependencies。

dist/

├── index.js         ← 包含 lodash 的代码

├── index.mjs

└── index.d.ts

三、为什么会发生这种情况？

构建工具（如 Vite、Webpack）在处理打包时，并不会关心某个依赖是 dependencies 还是 devDependencies。

它只会扫描你的代码：

• 如果你 import 了某个模块（如 lodash），构建工具会把它包含进 bundle 中，除非你通过 external 配置显式告诉它不要打包进来。


• 你放在 devDependencies 中只是告诉 npm install：这个依赖只在开发阶段需要，npm install --production 时不会安装它。

换句话说，打包行为取决于代码，而不是依赖声明。

四、修复方式：将运行时依赖移到 dependencies

为了正确构建一个可以发布的库包，应该：

{

  "dependencies": {

    "lodash": "^4.17.21"

  },

  "devDependencies": {

    "vite": "^5.0.0",

    "typescript": "^5.4.0"

  }

}

这样使用你库的开发者才能在安装你的包时自动获取 lodash。

五、如何防止此类问题？

1. 使用 peerDependencies（推荐给库开发者）

如果你希望使用者自带 lodash，而不是你来打包它，可以这样配置：

{

  "peerDependencies": {

    "lodash": "^4.17.21"

  }

}

同时在 Vite 配置中加上：

export default defineConfig({

  build: {

    lib: {

      entry: 'src/index.ts',

      name: 'MyLib'

    },

    rollupOptions: {

      external: ['lodash'], // 不打包 lodash

    }

  }

})

这样打包出来的 bundle 中就不会再包含 lodash 的代码。

2. 使用构建工具的 external 配置

像上面这样将 lodash 标为 external 可以避免误打包。

3. 静态分析工具检测

使用像 depcheck 或 eslint-plugin-import 等工具，可以帮你发现未声明或声明错误的依赖。

六、总结

构建工具不会参考 package.json 中依赖的位置来决定是否打包，而是基于代码的实际引用。作为库作者，你应该确保：

• 所有运行时依赖都放在 dependencies 或 peerDependencies；


• 构建工具正确配置 external，避免不必要地打包外部依赖；


• 使用工具检查依赖定义的一致性。

接 使用three.js搭建3d隧道监测-1

加载基础线条与地面效果

在我们的隧道监控系统中，地面网格和方向指示器是重要的视觉元素，它们帮助用户理解空间关系和导航方向。

1. 网格地面的创建与优化

javascript

// 初始化场景中的地面

const addGround = () => {

    const size = 40000; // 网格大小

    const divisions = 100; // 分割数（越高越密集）



    // 主网格线颜色（亮蓝色）

    const color1 = 0x6E7DB9; // 蓝色



    // 次网格线颜色（深蓝色）

    const color2 = 0x282C3C; // 深蓝色



    const gridHelper = new THREE.GridHelper(size, divisions, color1, color2);



    // 调整网格线的透明度和材质

    gridHelper.material.opacity = 1;

    gridHelper.material.transparent = true;

    gridHelper.material.depthWrite = false; // 防止网格阻挡其他物体的渲染



    // 设置材质的混合模式以实现发光效果

    gridHelper.material.blending = THREE.AdditiveBlending;

    gridHelper.material.vertexColors = false;



    // 增强线条对比度

    gridHelper.material.color.setHex(color1);

    gridHelper.material.linewidth = 100;



    // 旋转网格，使其位于水平面

    gridHelper.rotation.x = Math.PI;



    sceneRef.current.add(gridHelper);

};

知识点： Three.js 中的网格地面实现技术

• GridHelper：Three.js 提供的辅助对象，用于创建二维网格，常用于表示地面或参考平面


• 材质优化：通过设置 depthWrite = false 避免渲染排序问题，防止网格阻挡其他物体


• 混合模式：AdditiveBlending 混合模式使重叠线条颜色叠加，产生发光效果


• 性能考量：网格分割数(divisions)会影响性能，需要在视觉效果和性能间平衡


• 旋转技巧：通过 rotation.x = Math.PI 将默认垂直的网格旋转到水平面

这种科幻风格的网格地面在虚拟现实、数据可视化和游戏中非常常见，能够提供空间参考而不显得过于突兀。

2. 动态方向指示器的实现

javascript

const createPolygonRoadIndicators = (dis) => {

  const routeIndicationGeometry = new THREE.PlaneGeometry(3024, 4000); // 创建平面几何体



  // 创建文本纹理的辅助函数

  const getTextCanvas = (text) => {

    const width = 200;

    const height = 300;

    const canvas = document.createElement('canvas');

    canvas.width = width;

    canvas.height = height;

    const ctx = canvas.getContext('2d');

    ctx.font = "bold 40px Arial"; // 设置字体大小和样式

    ctx.fillStyle = '#949292'; // 设置字体颜色

    ctx.textAlign = 'center';

    ctx.textBaseline = 'middle';

    ctx.fillText(text, width / 2, height / 2);

    return canvas;

  };



  // 创建方向1文本平面

  const textMap = new THREE.CanvasTexture(getTextCanvas('方向1'));

  const textMaterial = new THREE.MeshBasicMaterial({ 

    map: textMap, 

    transparent: true, 

    depthTest: false 

  }); 

  const plane = new THREE.Mesh(routeIndicationGeometry, textMaterial);

  plane.castShadow = false; 

  plane.position.set(1024, 0, 1400);

  plane.rotateX(-Math.PI / 2);



  // 创建方向2文本平面

  const textMap1 = new THREE.CanvasTexture(getTextCanvas('方向2'));

  const textMaterial1 = new THREE.MeshBasicMaterial({ 

    map: textMap1, 

    transparent: true, 

    depthTest: false 

  }); 

  const plane1 = new THREE.Mesh(routeIndicationGeometry, textMaterial1);

  plane1.castShadow = false;

  plane1.position.set(1024, 0, -1400);

  plane1.rotateX(-Math.PI / 2);



  // 创建箭头指示器

  const loader = new THREE.TextureLoader();

  const texture = loader.load('/image/arrow1.png', (t) => {

    t.wrapS = t.wrapT = THREE.RepeatWrapping;

    t.repeat.set(1, 1);

  });

  const geometryRoute = new THREE.PlaneGeometry(1024, 1200);

  const materialRoute = new THREE.MeshStandardMaterial({

    map: texture,

    transparent: true,

    side: THREE.DoubleSide, // 确保可以从两个面看见

  });

  const plane2 = new THREE.Mesh(geometryRoute, materialRoute);

  plane2.receiveShadow = false;

  plane2.position.set(1000, 0, 0);

  plane2.rotateX(dis==="left"?-Math.PI / 2:Math.PI / 2);

  

  // 将所有元素组合成一个组

  const group = new THREE.Gr0up();

  group.add(plane2, plane, plane1);

  group.scale.set(0.4, 0.4, 0.4);

  group.position.set(dis==="left"?500:500-4000, 0, 0);



  return group;

};

知识点： Three.js 中的动态文本与指示器实现技术

• Canvas 纹理：使用 HTML Canvas 动态生成文本，然后转换为 Three.js 纹理，这是在 3D 场景中显示文本的高效方法


• CanvasTexture：Three.js 提供的特殊纹理类型，可以直接从 Canvas 元素创建纹理，支持动态更新


• 透明度处理：通过设置 transparent: true 和适当的 depthTest 设置解决透明纹理的渲染问题


• 几何体组织：使用 THREE.Gr0up 将多个相关的 3D 对象组织在一起，便于统一变换和管理


• 条件旋转：根据参数 dis 动态决定箭头的朝向，实现可配置的方向指示


• 纹理重复：通过 RepeatWrapping 和 repeat 设置可以控制纹理的重复方式，适用于创建连续的纹理效果

这种动态方向指示器在导航系统、虚拟导览和交互式地图中非常有用，可以为用户提供直观的方向引导。

3.地面方向指示器实现

在隧道监控系统中，方向指示是帮助用户理解空间方向和导航的关键元素。我们实现了一套包含文本标签和箭头的地面方向指示系统。

javascript

import * as THREE from "three";



const createPolygonRoadIndicators = (dis) => {

  const routeIndicationGeometry = new THREE.PlaneGeometry(3024, 4000); // 创建平面几何体



  const getTextCanvas = (text) => {

    const width = 200;

    const height = 300;

    const canvas = document.createElement('canvas');

    canvas.width = width;

    canvas.height = height;

    const ctx = canvas.getContext('2d');

    ctx.font = "bold 40px Arial"; // 设置字体大小和样式

    ctx.fillStyle = '#949292'; // 设置字体颜色

    ctx.textAlign = 'center';

    ctx.textBaseline = 'middle';

    ctx.fillText(text, width / 2, height / 2);

    return canvas;

  };



  const textMap = new THREE.CanvasTexture(getTextCanvas('方向1'));

  const textMaterial = new THREE.MeshBasicMaterial({ map: textMap, transparent: true, depthTest: false }); // 创建材质,depthTest解决黑色块问题

  const plane = new THREE.Mesh(routeIndicationGeometry, textMaterial);

  plane.castShadow = false; // 不投影阴影"

  plane.position.set(1024, 0, 1400);

  plane.rotateX(-Math.PI / 2);



  const textMap1 = new THREE.CanvasTexture(getTextCanvas('方向2'));

  const textMaterial1 = new THREE.MeshBasicMaterial({ map: textMap1, transparent: true, depthTest: false }); // 创建材质，depthTest解决黑色块问题

  const plane1 = new THREE.Mesh(routeIndicationGeometry, textMaterial1);

  plane1.castShadow = false; // 不投影阴影

  plane1.position.set(1024, 0, -1400);

  plane1.rotateX(-Math.PI / 2);





  const loader = new THREE.TextureLoader();

  const texture = loader.load('/image/arrow1.png', (t) => {

    t.wrapS = t.wrapT = THREE.RepeatWrapping;

    t.repeat.set(1, 1);

  });

  const geometryRoute = new THREE.PlaneGeometry(1024, 1200);

  const materialRoute = new THREE.MeshStandardMaterial({

    map: texture,

    transparent: true,

    side: THREE.DoubleSide, // 确保可以从两个面看见

  });

  const plane2 = new THREE.Mesh(geometryRoute, materialRoute);

  plane2.receiveShadow = false; // 不接收阴影

  plane2.position.set(1000, 0, 0);

  plane2.rotateX(dis==="left"?-Math.PI / 2:Math.PI / 2);

  const group = new THREE.Gr0up();

  group.add(plane2, plane, plane1);

  group.scale.set(0.4, 0.4, 0.4);

  group.position.set(dis==="left"?500:500-4000, 0, 0);



  return group;

};



export default createPolygonRoadIndicators;

知识点： Three.js 中的地面方向指示器实现技术

• 平面投影标记：使用 PlaneGeometry 创建平面，通过旋转使其平行于地面，形成"地面投影"效果
  
  
  
  
  • 使用 rotateX(-Math.PI / 2) 将平面从垂直旋转到水平位置
  
  
  
  


• 动态文本生成：使用 Canvas API 动态生成文本纹理
  
  
  
  
  • getTextCanvas 函数创建一个临时 Canvas 并在其上绘制文本
  
  
  • 使用 CanvasTexture 将 Canvas 转换为 Three.js 可用的纹理
  
  
  • 这种方法比使用 3D 文本几何体更高效，特别是对于频繁变化的文本
  
  
  
  


• 纹理渲染优化：
  
  
  
  
  • transparent: true 启用透明度处理，使背景透明
  
  
  • depthTest: false 禁用深度测试，解决半透明纹理的渲染问题，防止出现"黑色块"
  
  
  • castShadow: false 和 receiveShadow: false 避免不必要的阴影计算
  
  
  
  


• 方向性指示：使用箭头纹理创建明确的方向指示
  
  
  
  
  • 通过 TextureLoader 加载外部箭头图像
  
  
  • 根据 dis 参数动态调整箭头方向（rotateX(dis==="left"?-Math.PI / 2:Math.PI / 2)）
  
  
  • side: THREE.DoubleSide 确保从任何角度都能看到箭头
  
  
  
  


• 组织与缩放：
  
  
  
  
  • 使用 THREE.Gr0up 将相关元素（文本标签和箭头）组织在一起
  
  
  • 通过 group.scale.set(0.4, 0.4, 0.4) 统一调整组内所有元素的大小
  
  
  • 根据方向参数设置整个组的位置，实现左右两侧不同的指示效果
  
  
  
  


• 纹理重复设置：
  
  
  
  
  • RepeatWrapping 和 repeat.set(1, 1) 控制纹理的重复方式
  
  
  • 这为创建连续的纹理效果提供了基础，虽然本例中设为1（不重复）
  
  
  
  

这种地面方向指示系统在大型空间（如隧道、机场、展馆）的导航中特别有用，为用户提供直观的方向感，不会干扰主要视觉元素。

隧道指示牌制作

在隧道监控系统中，指示牌是引导用户和提供空间信息的重要元素。我们实现了一种复合结构的隧道指示牌，包含支柱、横梁和信息板。

javascript

import * as THREE from 'three';

import {TextGeometry} from "three/examples/jsm/geometries/TextGeometry";



/**

 * 创建石头柱子（竖直 + 横向）

 * @returns {THREE.Gr0up} - 返回包含柱子和横梁的组

 */

const createStonePillar = () => {

    const pillarGr0up = new THREE.Gr0up();



    // 创建六边形的竖直柱子

    const pillarGeometry = new THREE.CylinderGeometry(6, 6, 340, 6); // 直径12, 高度340, 六边形柱体

    const pillarMaterial = new THREE.MeshStandardMaterial({color: 0x808080}); // 石头颜色

    const pillar = new THREE.Mesh(pillarGeometry, pillarMaterial);

    pillar.position.set(0, 0, 0); 



    // 创建第一根横向长方体

    const beam1Geometry = new THREE.BoxGeometry(100, 10, 0.1); 

    const beam1Material = new THREE.MeshStandardMaterial({color: 0x808080}); 

    const beam1 = new THREE.Mesh(beam1Geometry, beam1Material);

    beam1.position.set(-50, 150, 0); 



    // 创建第二根横向长方体

    const beam2Geometry = new THREE.BoxGeometry(100, 10, 0.1); 

    const beam2Material = new THREE.MeshStandardMaterial({color: 0x808080}); 

    const beam2 = new THREE.Mesh(beam2Geometry, beam2Material);

    beam2.position.set(-50, 130, 0); 



    // 将柱子和横梁添加到组

    pillarGr0up.add(pillar);

    pillarGr0up.add(beam1);

    pillarGr0up.add(beam2);

    return pillarGr0up;

};



/**

 * 创建一个用于绘制文本的 Canvas

 * @param {string} text - 要绘制的文本

 * @returns {HTMLCanvasElement} - 返回 Canvas 元素

 */

const getTextCanvas = (text) => {

    const canvas = document.createElement('canvas');

    const context = canvas.getContext('2d');



    // 设置 Canvas 尺寸

    const fontSize = 32;

    canvas.width = 512;

    canvas.height = 128;



    // 设置背景色

    context.fillStyle = '#1E3E9A'; // 蓝底

    context.fillRect(0, 0, canvas.width, canvas.height);



    // 设置文本样式

    context.font = `${fontSize}px Arial`;

    context.fillStyle = '#ffffff'; // 白色文本

    context.textAlign = 'center';

    context.textBaseline = 'middle';

    context.fillText(text, canvas.width / 2, canvas.height / 2);



    return canvas;

};



/**

 * 创建交通指示牌并添加到场景中

 * @param {Object} sceneRef - React ref 对象，指向 Three.js 的场景

 * @returns {Promise<THREE.Gr0up>} - 返回创建的指示牌组

 */

export default (sceneRef, png, dis) => {

    const createSignBoard = async () => {

        const signGr0up = new THREE.Gr0up();



        const loader = new THREE.TextureLoader();

        loader.load(png, texture => {

            // 创建一个平面作为标志背景

            const signGeometry = new THREE.PlaneGeometry(100, 50); // 宽100，高50

            texture.encoding = THREE.sRGBEncoding // 设置纹理的颜色空间

            texture.colorSpace = THREE.SRGBColorSpace;

            const signMaterial = new THREE.MeshStandardMaterial({

                map: texture,

                transparent: true,

                side: THREE.DoubleSide,

            })



            const sign = new THREE.Mesh(signGeometry, signMaterial);

            sign.position.set(-60, 140, 0.3)

            signGr0up.add(sign);

        })



        // 创建并添加石头柱子

        const pillar = createStonePillar();

        signGr0up.add(pillar);



        if (dis == "left") {

            signGr0up.position.set(370, 180, 3750); // 左侧位置

        } else {

            signGr0up.rotateY(Math.PI); // 旋转180度

            signGr0up.position.set(-370 - 2000, 180, 3450 - 7200); // 右侧位置

        }



        signGr0up.add(pillar);

        sceneRef.current.add(signGr0up);



        return signGr0up; // 返回整个组

    };



    // 调用创建指示牌函数

    return createSignBoard().then((signGr0up) => {

        console.log('交通指示牌创建完成:', signGr0up);

        return signGr0up;

    });

};

知识点： Three.js 中的复合结构与指示牌实现技术

• 模块化设计：将指示牌分解为柱子、横梁和信息板三个主要组件，便于维护和复用


• 几何体组合：使用简单几何体（圆柱体、长方体、平面）组合构建复杂结构
  
  
  
  
  • CylinderGeometry 创建六边形柱体作为支撑
  
  
  • BoxGeometry 创建横向支撑梁
  
  
  • PlaneGeometry 创建平面显示信息
  
  
  
  


• 空间层次：使用 THREE.Gr0up 将相关元素组织在一起，便于整体变换和管理


• 纹理映射：使用 TextureLoader 加载外部图像作为指示牌内容
  
  
  
  
  • 设置 colorSpace = THREE.SRGBColorSpace 确保颜色正确显示
  
  
  • 使用 side: THREE.DoubleSide 使平面从两面都可见
  
  
  
  


• 条件定位：根据 dis 参数动态决定指示牌的位置和朝向
  
  
  
  
  • 使用 rotateY(Math.PI) 旋转180度实现方向反转
  
  
  
  


• Canvas 动态文本：使用 getTextCanvas 函数创建动态文本纹理
  
  
  
  
  • 可以方便地生成不同内容和样式的文本标识
  
  
  
  


• 异步处理：使用 Promise 处理纹理加载的异步过程，确保资源正确加载
  
  
  
  
  • 返回 Promise 使调用者可以在指示牌创建完成后执行后续操作
  
  
  
  

这种组合式设计方法允许我们创建高度可定制的指示牌，适用于隧道、道路、建筑内部等多种场景，同时保持代码的可维护性和可扩展性。

多渲染器协同工作机制

在我们的项目中，实现了 WebGL 渲染器、CSS2D 渲染器和 CSS3D 渲染器的协同工作：

const initRenderer = () => {

    // WebGL 渲染器

    rendererRef.current = new THREE.WebGLRenderer({

        antialias: true,

        alpha: true,

        logarithmicDepthBuffer: true

    });

    rendererRef.current.setSize(window.innerWidth, window.innerHeight);

    rendererRef.current.setPixelRatio(Math.min(window.devicePixelRatio, 2));

    rendererRef.current.shadowMap.enabled = true;

    rendererRef.current.shadowMap.type = THREE.PCFSoftShadowMap;

    rendererRef.current.outputEncoding = THREE.sRGBEncoding;

    rendererRef.current.toneMapping = THREE.ACESFilmicToneMapping;

    containerRef.current.appendChild(rendererRef.current.domElement);

};



const initCSS2DScene = () => {

    // CSS2D 渲染器

    css2DRendererRef.current = new CSS2DRenderer();

    css2DRendererRef.current.setSize(window.innerWidth, window.innerHeight);

    css2DRendererRef.current.domElement.style.position = 'absolute';

    css2DRendererRef.current.domElement.style.top = '0';

    css2DRendererRef.current.domElement.style.pointerEvents = 'none';

    containerRef.current.appendChild(css2DRendererRef.current.domElement);

};



const initCSS3DScene = () => {

    // 初始化 CSS3DRenderer

    css3DRendererRef.current = new CSS3DRenderer();

    css3DRendererRef.current.setSize(sizes.width, sizes.height);

    css3DRendererRef.current.domElement.style.position = 'absolute';

    css3DRendererRef.current.domElement.style.top = '0px';

    css3DRendererRef.current.domElement.style.pointerEvents = 'none'; // 确保CSS3D元素不阻碍鼠标事件

    containerRef.current.appendChild(css3DRendererRef.current.domElement);

};

知识点： Three.js 支持多种渲染器同时工作，每种渲染器有不同的优势：

• WebGLRenderer：利用 GPU 加速渲染 3D 内容，性能最佳


• CSS2DRenderer：将 HTML 元素作为 2D 标签渲染在 3D 空间中，适合信息标签


• CSS3DRenderer：将 HTML 元素转换为 3D 对象，支持 3D 变换，适合复杂 UI

多渲染器协同可以充分发挥各自优势，实现复杂的混合现实效果。

后期处理管线设计

项目中实现了基于 EffectComposer 的后期处理管线：

const initPostProcessing = () => {

    composerRef.current = new EffectComposer(rendererRef.current);

    

    // 基础渲染通道

    const renderPass = new RenderPass(sceneRef.current, cameraRef.current);

    composerRef.current.addPass(renderPass);

    

    // 环境光遮蔽通道

    const ssaoPass = new SSAOPass(

        sceneRef.current,

        cameraRef.current,

        window.innerWidth,

        window.innerHeight

    );

    ssaoPass.kernelRadius = 16;

    ssaoPass.minDistance = 0.005;

    ssaoPass.maxDistance = 0.1;

    composerRef.current.addPass(ssaoPass);

    

    // 抗锯齿通道

    const fxaaPass = new ShaderPass(FXAAShader);

    const pixelRatio = rendererRef.current.getPixelRatio();

    fxaaPass.material.uniforms['resolution'].value.x = 1 / (window.innerWidth * pixelRatio);

    fxaaPass.material.uniforms['resolution'].value.y = 1 / (window.innerHeight * pixelRatio);

    composerRef.current.addPass(fxaaPass);

};

知识点： 后期处理(Post-processing)是一种在 3D 场景渲染完成后对图像进行额外处理的技术：

• EffectComposer：Three.js 中的后期处理管理器，可以将多个处理效果组合在一起


• RenderPass：基础渲染通道，将场景渲染到目标缓冲区


• SSAOPass：屏幕空间环境光遮蔽，增强场景深度感和真实感


• FXAAShader：快速近似抗锯齿，提高图像质量

后期处理可以大幅提升画面质量，添加如景深、发光、色彩校正等专业效果。

多层次动画系统

项目实现了一个多层次的动画系统：

// 骨骼动画控制

const getActions = (animations, model) => {

    const mixer = new THREE.AnimationMixer(model);

    const mixerArray = [];

    mixerArray.push(mixer);

    

    const actions = {};

    animations.forEach((clip) => {

        const action = mixer.clipAction(clip);

        actions[clip.name] = action;

    });

    

    return {actions, mixerArray};

};



// 动画播放控制

const playActiveAction = (actions, name, startTime = true, loopType = THREE.LoopOnce, clampWhenFinished = true) => {

    const action = actions[name];

    if (!action) return;

    

    action.reset();

    action.clampWhenFinished = clampWhenFinished;

    action.setLoop(loopType);

    if (startTime) {

        action.play();

    }

};

知识点： Three.js 提供了多种动画技术：

• AnimationMixer：用于播放和控制模型骨骼动画的核心类，相当于动画播放器


• AnimationClip：包含一组关键帧轨道的动画数据，如"走路"、"跑步"等动作


• AnimationAction：控制单个动画的播放状态，包括播放、暂停、循环设置等


• 动画混合：可以实现多个动画之间的平滑过渡，如从走路切换到跑步

合理使用这些技术可以创建流畅、自然的角色动画和场景变换。

第一人称视角控制算法

项目实现了一种先进的第一人称视角控制算法：

const animate1 = () => {

    requestRef1.current = requestAnimationFrame(animate1);

    if (isFirstPerson && robotRef.current) {

        // 获取机器人的世界坐标

        const robotWorldPosition = new THREE.Vector3();

        robotRef.current.getWorldPosition(robotWorldPosition);

        

        // 计算摄像机位置偏移

        const offset = new THREE.Vector3(0, 140, 20);

        

        // 获取机器人的前方方向向量

        const forward = new THREE.Vector3(0, 0, -1).applyQuaternion(robotRef.current.quaternion);

        const lookAheadDistance = 150;

        

        // 计算摄像头位置和视线目标

        const targetCameraPosition = robotWorldPosition.clone().add(offset);

        const lookAtPosition = robotWorldPosition.clone().add(forward.multiplyScalar(lookAheadDistance));

        

        // 使用 TWEEN 实现平滑过渡

        cameraTweenRef.current = new TWEEN.Tween(cameraRef.current.position)

            .to({

                x: targetCameraPosition.x,

                y: targetCameraPosition.y,

                z: targetCameraPosition.z,

            }, 1000)

            .easing(TWEEN.Easing.Quadratic.Out)

            .onUpdate(() => {

                cameraRef.current.lookAt(lookAtPosition);

                controlsRef.current.target.set(lookAtPosition.x, lookAtPosition.y, lookAtPosition.z);

            })

            .start();

    }

};

知识点： 第一人称相机控制涉及多个关键技术：

• 世界坐标计算：通过 getWorldPosition() 获取对象在世界坐标系中的位置


• 四元数旋转：使用 applyQuaternion() 将向量按对象的旋转方向进行变换


• 向量运算：通过向量加法和标量乘法计算相机位置和视线方向


• 平滑过渡：使用 TWEEN.js 实现相机位置的平滑变化，避免生硬的跳变


• lookAt：让相机始终"看着"目标点，实现跟随效果

这种技术常用于第一人称游戏、虚拟导览等应用。

递归资源释放算法

项目实现了一种递归资源释放算法，用于彻底清理 Three.js 资源：

const disposeSceneObjects = (object) => {

    if (!object) return;



    // 递归清理子对象

    while (object.children.length > 0) {

        const child = object.children[0];

        disposeSceneObjects(child);

        object.remove(child);

    }



    // 清理几何体

    if (object.geometry) {

        object.geometry.dispose();

    }



    // 清理材质

    if (object.material) {

        if (Array.isArray(object.material)) {

            object.material.forEach(material => disposeMaterial(material));

        } else {

            disposeMaterial(object.material);

        }

    }



    // 清理纹理

    if (object.texture) {

        object.texture.dispose();

    }

};



// 清理材质的辅助函数

const disposeMaterial = (material) => {

    if (!material) return;



    // 清理所有纹理属性

    const textureProperties = [

        'map', 'normalMap', 'roughnessMap', 'metalnessMap',

        'emissiveMap', 'bumpMap', 'displacementMap',

        'alphaMap', 'lightMap', 'aoMap', 'envMap'

    ];



    textureProperties.forEach(prop => {

        if (material[prop] && material[prop].dispose) {

            material[prop].dispose();

        }

    });



    material.dispose();

};

知识点： WebGL 资源管理是 3D 应用开发中的关键挑战：

• JavaScript 垃圾回收的局限性：虽然 JS 有自动垃圾回收，但 WebGL 资源（如纹理、缓冲区）需要手动释放


• 深度优先遍历：通过递归算法遍历整个场景图，确保所有对象都被正确处理


• 资源类型处理：不同类型的资源（几何体、材质、纹理）需要不同的释放方法


• 内存泄漏防护：不正确的资源管理是 WebGL 应用中最常见的内存泄漏原因

合理的资源释放策略对长时间运行的 3D 应用至关重要，可以避免性能下降和浏览器崩溃。

资源预加载与缓存策略

项目实现了资源预加载与缓存策略：

// 资源管理器

const ResourceManager = {

    // 资源缓存

    cache: new Map(),

    

    // 预加载资源

    preload: async (resources) => {

        const loader = new GLTFLoader();

        

        // 并行加载所有资源

        const loadPromises = resources.map(resource => {

            return new Promise((resolve, reject) => {

                loader.load(

                    resource.url,

                    (gltf) => {

                        ResourceManager.cache.set(resource.id, {

                            data: gltf,

                            lastUsed: Date.now(),

                            refCount: 0

                        });

                        resolve(gltf);

                    },

                    undefined,

                    reject

                );

            });

        });

        

        return Promise.all(loadPromises);

    },

    

    // 获取资源

    get: (id) => {

        const resource = ResourceManager.cache.get(id);

        if (resource) {

            resource.lastUsed = Date.now();

            resource.refCount++;

            return resource.data;

        }

        return null;

    },

    

    // 释放资源

    release: (id) => {

        const resource = ResourceManager.cache.get(id);

        if (resource) {

            resource.refCount--;

            if (resource.refCount <= 0) {

                // 可以选择立即释放或稍后由缓存清理机制释放

            }

        }

    }

};

知识点： 3D 应用中的资源管理策略：

• 预加载：提前加载关键资源，减少用户等待时间


• 并行加载：使用 Promise.all 并行加载多个资源，提高加载效率


• 资源缓存：使用 Map 数据结构存储已加载资源，避免重复加载


• 引用计数：跟踪资源的使用情况，只有当引用计数为零时才考虑释放


• 最近使用时间：记录资源最后使用时间，可用于实现 LRU (最近最少使用) 缓存策略

这种资源管理策略可以平衡内存使用和加载性能，适用于资源密集型的 3D 应用。

总结

通过这个隧道监控可视化系统的开发，我们深入实践了 Three.js 的多项高级技术，包括多渲染器协同、后期处理、动画系统、相机控制和资源管理等。这些技术不仅适用于隧道监控，还可以应用于数字孪生、产品可视化、教育培训等多个领域。

希望这次分享对大家了解 Web 3D 开发有所帮助！如有任何问题或改进建议，非常欢迎与我交流讨论。我将在后续分享中带来更多 Three.js 开发的实用技巧和最佳实践。

在前端开发中，判断用户设备类型是常见需求，可通过浏览器环境检测、设备能力特征分析等方式实现。以下是具体实现思路及代码示例：

一、通过User-Agent检测设备类型

原理：User-Agent是浏览器发送给服务器的标识字符串，包含设备、系统、浏览器等信息。

实现步骤：

// 设备检测工具函数

function detectDevice() {

  const userAgent = navigator.userAgent.toLowerCase();

  const device = {};

  

  // 判断是否为移动设备

  const isMobile = /android|webos|iphone|ipad|ipod|blackberry|iemobile|opera mini/i.test(userAgent);

  device.isMobile = isMobile;

  

  // 具体设备类型

  if (/(iphone|ipad|ipod)/i.test(userAgent)) {

    device.type = 'ios';

    device.model = /iphone/i.test(userAgent) ? 'iPhone' : 'iPad';

  } else if (/android/i.test(userAgent)) {

    device.type = 'android';

    // 提取Android版本

    const androidVersion = userAgent.match(/android (\d+\.\d+)/);

    device.version = androidVersion ? androidVersion[1] : '未知';

  } else if (/windows phone/i.test(userAgent)) {

    device.type = 'windows phone';

  } else if (/macint0sh/i.test(userAgent)) {

    device.type = 'mac';

  } else if (/windows/i.test(userAgent)) {

    device.type = 'windows';

  } else {

    device.type = '其他';

  }

  

  // 判断是否为平板（需结合屏幕尺寸进一步确认）

  device.isTablet = (/(ipad|android tablet|windows phone 8.1|kindle|nexus 7)/i.test(userAgent)) && !device.isMobile;

  

  // 浏览器类型

  if (/chrome/i.test(userAgent)) {

    device.browser = 'Chrome';

  } else if (/firefox/i.test(userAgent)) {

    device.browser = 'Firefox';

  } else if (/safari/i.test(userAgent) && !/chrome/i.test(userAgent)) {

    device.browser = 'Safari';

  } else if (/msie|trident/i.test(userAgent)) {

    device.browser = 'IE/Edge';

  } else {

    device.browser = '未知';

  }

  

  return device;

}



// 使用示例

const deviceInfo = detectDevice();

console.log('设备类型:', deviceInfo.type);

console.log('是否为移动设备:', deviceInfo.isMobile);

console.log('浏览器:', deviceInfo.browser);

二、结合屏幕尺寸与触摸事件检测

原理：移动设备通常屏幕较小，且支持触摸操作，而PC设备以鼠标操作为主。

function enhanceDeviceDetection() {

  const device = detectDevice(); // 基于User-Agent的检测

  

  // 1. 屏幕尺寸检测（响应式设备类型）

  if (window.innerWidth <= 768) {

    device.layout = 'mobile'; // 移动端布局

  } else if (window.innerWidth <= 1024) {

    device.layout = 'tablet'; // 平板布局

  } else {

    device.layout = 'desktop'; // 桌面端布局

  }

  

  // 2. 触摸事件支持检测

  device.hasTouch = 'ontouchstart' in window || navigator.maxTouchPoints > 0;

  

  // 3. 指针类型检测（WebKit特有属性，判断鼠标/触摸/笔）

  if (navigator.maxTouchPoints === 0) {

    device.pointerType = 'mouse';

  } else if (navigator.maxTouchPoints > 2) {

    device.pointerType = 'pen';

  } else {

    device.pointerType = 'touch';

  }

  

  return device;

}

三、设备能力API检测（更准确的现代方案）

原理：通过浏览器原生API获取设备硬件特性，避免User-Agent被伪造的问题。

async function detectDeviceByAPI() {

  const device = {};

  

  // 1. NavigatorDevice API（需HTTPS环境）

  if (navigator.device) {

    try {

      const deviceInfo = await navigator.device.getCapabilities();

      device.brand = deviceInfo.brand; // 设备品牌

      device.model = deviceInfo.model; // 设备型号

      device.vendor = deviceInfo.vendor; // 厂商

    } catch (error) {

      console.log('NavigatorDevice API获取失败:', error);

    }

  }

  

  // 2. 屏幕像素密度（区分高清屏）

  device.retina = window.devicePixelRatio >= 2;

  

  // 3. 电池状态（移动端常用）

  if (navigator.getBattery) {

    navigator.getBattery().then(battery => {

      device.batteryLevel = battery.level;

      device.batteryCharging = battery.charging;

    });

  }

  

  return device;

}

四、框架/库方案（简化实现）

如果项目中使用框架，可直接使用成熟库：

五、注意事项

六、面试延伸问题

通过以上方案，可全面检测用户设备类型、系统、浏览器及硬件特性，为前端适配提供依据。

我用Python写了个实时板块资金热力图 🎨💰

大家好，这里是花姐，今天带来一个有点“热辣滚烫”的Python实战项目——实时板块资金热力图！🔥

这两年，股市的热度时高时低，但大家对资金流向的关注度始终不减。有没有办法直观地看到哪些板块在吸金，哪些板块在被资金抛弃呢？答案是：当然有！

于是，我撸起袖子，用 Python + Streamlit + AkShare + Plotly 搞了一款实时的资金流向可视化工具，颜值爆表，还能自动刷新，堪称炒股助手！🎯

📌 需求分析

在金融市场里，资金流向是一个很重要的指标，主力资金的流入流出往往决定了一个板块的短期走势。

我们希望做到：

✅ 实时获取资金流向数据，并展示行业板块的资金进出情况。

✅ 可视化呈现数据，用颜色区分资金净流入和净流出，一眼就能看出哪些板块是**“香饽饽”，哪些是“弃儿”**。

✅ 自动刷新，让用户无需手动点刷新，信息一直是最新的。

有了目标，就开始撸代码吧！🚀

🛠 技术栈

• Streamlit：Python神器，一键搞定Web应用。


• AkShare：国内行情数据神器，能直接获取资金流向数据。


• Plotly：强大的可视化库，这次用它做树状热力图。


• Pandas：数据处理少不了它。

📊 代码实现

1. 获取资金流向数据

股市数据当然得从靠谱的地方获取，我们用 AkShare 的 stock_sector_fund_flow_rank 来搞定资金流数据：

import akshare as ak

import pandas as pd



def process_data(indicator):

    """获取并处理资金流数据"""

    try:

        raw = ak.stock_sector_fund_flow_rank(

            indicator=indicator,

            sector_type="行业资金流"

        )

        df = raw.rename(columns={'名称': '板块名称'})

        df['资金净流入(亿)'] = df['主力净流入-净额'] / 100000000  # 转换为“亿”

        df['资金净流入(亿)'] = df['资金净流入(亿)'].round(2)  # 保留两位小数

        df['涨跌幅'] = pd.to_numeric(df['涨跌幅'], errors='coerce')

        df['流向强度'] = abs(df['资金净流入(亿)'])

        return df.dropna(subset=['资金净流入(亿)'])

    except Exception as e:

        print(f"数据获取失败: {e}")

        return pd.DataFrame()

这样，我们可以用 process_data("今日") 来获取今日的行业板块资金流数据。

2. 生成热力图 🎨

有了数据，接下来就是可视化部分了，我们用 Plotly 画一个树状热力图：

import plotly.express as px



COLOR_SCALE = [

    [0.0, "#00ff00"],  # 绿色（流出最大）

    [0.45, "#dfffdf"], # 浅绿色（小幅流出）

    [0.5, "#ffffff"],  # 白色（平衡点）

    [0.55, "#ffe5e5"], # 浅红色（小幅流入）

    [1.0, "#ff0000"]   # 红色（流入最大）

]



def generate_heatmap(df):

    """生成树状热力图"""

    fig = px.treemap(

        df,

        path=['板块名称'],

        values='流向强度',

        color='资金净流入(亿)',

        color_continuous_scale=COLOR_SCALE,

        hover_data={

            '涨跌幅': ':%',

            '资金净流入(亿)': ':'

        },

        height=800

    )

    return fig

这张图的颜色代表资金的流向，红色表示资金流入，绿色表示资金流出，一眼就能看出主力资金的动向！

3. 使用 Streamlit 构建交互界面

有了数据和图表，我们用 Streamlit 搭建一个 Web 界面：

import streamlit as st

from datetime import datetime



def sidebar_controls():

    with st.sidebar:

        st.header("控制面板")

        indicator = st.radio("分析周期", ["今日", "5日", "10日"], index=0, horizontal=True)

        refresh_interval = st.slider("自动刷新间隔 (秒)", 60, 3600, 60, 60)

        return indicator, refresh_interval



def main_display(df):

    st.title("📊 资金流向热力图")

    st.caption(f"数据更新时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")



    if not df.empty:

        st.plotly_chart(generate_heatmap(df), use_container_width=True)

    else:

        st.warning("⚠️ 数据获取失败，请检查网络连接")

4. 自动刷新系统 ⏳

资金流是动态的，当然不能只显示静态数据，我们加个 自动刷新功能：

import time



def auto_refresh_system(refresh_interval):

    time.sleep(refresh_interval)

    st.rerun()

5. 整合一键运行 🚀

if __name__ == "__main__":

    st.set_page_config(layout="wide")

    indicator, refresh_interval = sidebar_controls()

    df = process_data(indicator)

    main_display(df)

    auto_refresh_system(refresh_interval)

只要运行 streamlit run app.py，就能看到实时的资金流向热力图了！🎉

🎯 成果展示

运行之后，你会看到一个 大屏可视化的热力图，资金流向一目了然：

• 颜色：红色代表资金流入，绿色代表流出，越深代表金额越大。


• 自动刷新，完全不用手动点击更新！


• 交互性：鼠标悬停可以查看详细数据。

这比在 Excel 里手动分析好用多了吧？😆

最终源码（粘贴过来就能用）

import streamlit as st

import akshare as ak

import plotly.express as px

import pandas as pd

import time

from datetime import datetime

from decimal import Decimal, ROUND_HALF_UP



# 自定义颜色映射

COLOR_SCALE = [

    [0.0, "#00ff00"],  # 绿色（资金流出最大）

    [0.45, "#dfffdf"], # 浅绿色（小幅流出）

    [0.5, "#ffffff"],  # 白色（平衡点）

    [0.55, "#ffe5e5"], # 浅红色（小幅流入）

    [1.0, "#ff0000"]   # 红色（资金流入最大）

]



# 数据预处理增强版

@st.cache_data(ttl=300)

def process_data(indicator):

    """强化数据预处理逻辑"""

    try:

        raw = ak.stock_sector_fund_flow_rank(

            indicator=indicator,

            sector_type="行业资金流"

        )

        raw.columns = raw.columns.str.replace(indicator, '', regex=False)

        

        # 数值转换

        df = raw.rename(columns={'名称': '板块名称'})

        

        df['资金净流入(亿)'] = df['主力净流入-净额'] / 100000000

        df['资金净流入(亿)'] = df['资金净流入(亿)'].round(2)



        df['涨跌幅'] = pd.to_numeric(df['涨跌幅'], errors='coerce')

        

        # 流向强度计算

        df['流向强度'] = abs(df['资金净流入(亿)'])

        

        return df.dropna(subset=['资金净流入(亿)'])

    except Exception as e:

        st.error(f"数据错误: {str(e)}")

        return pd.DataFrame()



# 热力图生成引擎

def generate_heatmap(df):

    """生成符合金融行业标准的树状热力图"""

    fig = px.treemap(

        df,

        path=['板块名称'],

        values='流向强度',

        color='资金净流入(亿)',

        color_continuous_scale=COLOR_SCALE,

        range_color=[-max(abs(df['资金净流入(亿)'].min()), abs(df['资金净流入(亿)'].max())),

                 max(abs(df['资金净流入(亿)'].min()), abs(df['资金净流入(亿)'].max()))],

        color_continuous_midpoint=0,

        branchvalues='total',

        hover_data={

            '涨跌幅': ':%',

            '资金净流入(亿)': ':',

            '主力净流入-净占比': ':%'

        },

        height=1000

    )

    

    # 高级样式配置

    fig.update_traces(

        texttemplate=(

            "<b>%{label}</b><br>"

            "📈%{customdata[0]}%<br>"

            "💰%{customdata[1]}亿"

        ),

        hovertemplate=( 

            "<b>%{label}</b><br>"

            "涨跌幅: %{customdata[0]}%<br>"

            "资金净流入: <b>%{customdata[1]}</b>亿<br>"

            "主力占比: %{customdata[2]}%"

        ),

        textfont=dict(size=18, color='black')

    )

    

    fig.update_layout(

        margin=dict(t=0, l=0, r=0, b=0),

        coloraxis_colorbar=dict(

            title="资金流向(亿)",

            ticks="inside",

            thickness=20,

            len=0.6,

            y=0.7

        )

    )

    return fig



# 侧边栏控件组

def sidebar_controls():

    with st.sidebar:

        st.header("控制面板")

        indicator = st.radio(

            "分析周期",

            ["今日", "5日", "10日"],

            index=0,

            horizontal=True

        )

        refresh_interval = st.slider(

            "自动刷新间隔 (秒)",

            min_value=60, max_value=3600,

            value=60, step=60,

            help="设置自动刷新间隔，默认1分钟"

        )

        return indicator, refresh_interval



# 主界面

def main_display(df):

    st.title("📊 资金流向热力图")

    st.caption(f"数据更新于: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")

    

    if not df.empty:

        with st.spinner("生成可视化..."):

            st.plotly_chart(generate_heatmap(df), use_container_width=True)

        

        # 动态摘要面板

        with st.expander("📌 实时快报", expanded=True):

            col1, col2, col3 = st.columns(3)

            col1.metric("🔥 最强流入", 

                       f"{df['资金净流入(亿)'].max():.2f}亿",

                       df.loc[df['资金净流入(亿)'].idxmax(), '板块名称'])

            col2.metric("💧 最大流出", 

                       f"{df['资金净流入(亿)'].min():.2f}亿",

                       df.loc[df['资金净流入(亿)'].idxmin(), '板块名称'])

            col3.metric("⚖️ 多空比", 

                       f"{len(df[df['资金净流入(亿)']>0])}:{len(df[df['资金净流入(亿)']<0])}",

                       f"总净额 {df['资金净流入(亿)'].sum():.2f}亿")

    else:

        st.warning("⚠️ 数据获取失败，请检查网络连接")



# 自动刷新系统

def auto_refresh_system(refresh_interval):

    time.sleep(refresh_interval)

    st.rerun()

    print("数据刷新了")



# 主程序

if __name__ == "__main__":

    st.set_page_config(layout="wide")

    indicator, refresh_interval = sidebar_controls()

    df = process_data(indicator)

    main_display(df)

    auto_refresh_system(refresh_interval)

🏆 总结

这个项目用 Python 搞定了：
✅ 数据抓取（AkShare）

✅ 数据处理（Pandas）

✅ 交互式可视化（Plotly）

✅ Web 界面（Streamlit）

✅ 自动刷新机制

一句话总结：用最少的代码，做出了最直观的金融数据可视化！💡

对于炒股的朋友，这个工具可以帮助你快速了解市场资金流向，不用再看密密麻麻的表格了！📈

喜欢的话，记得点个赞❤️，咱们下次见！🎉

前端获取本地文件目录内容

一、核心原理说明

由于浏览器的 “沙箱安全机制”，前端 JavaScript 无法直接访问本地文件系统，必须通过用户主动授权（如选择目录操作）才能获取文件目录内容。目前主流实现方案基于两种 API：传统 File API（兼容性优先）和现代 FileSystem Access API（功能优先），以下将详细介绍两种方案的实现流程、代码示例及适用场景。

二、方案一：基于 File API 实现（兼容性首选）

1. 方案概述

通过隐藏的 <input type="file"> 标签（配置 webkitdirectory 和 directory 属性）触发用户选择目录操作，用户选择后通过 files 属性获取目录下所有文件的元数据（如文件名、大小、相对路径等）。该方案兼容几乎所有现代浏览器（包括 Chrome、Firefox、Safari 等），但仅支持 “一次性获取选中目录内容”，无法递归遍历子目录或修改文件。

2. 完整使用示例

2.1 HTML 结构（含 UI 交互区）

<!DOCTYPE html>

<html lang="zh-CN">

<head>

    <meta charset="UTF-8">

    <title>File API 目录访问示例</title>

    <!-- 引入 Tailwind 简化样式（也可自定义 CSS） -->

    <script src="https://cdn.tailwindcss.com"></script>

    <style>

        .file-item { display: flex; align-items: center; padding: 8px; border-bottom: 1px solid #eee; }

        .file-icon { margin-right: 8px; font-size: 18px; }

        .file-info { flex: 1; }

        .file-size { color: #666; font-size: 14px; }

    </style>

</head>

<body class="p-8 bg-gray-50">

    <div class="max-w-4xl mx-auto bg-white p-6 rounded-lg shadow">

        <h2 class="text-2xl font-bold mb-4">File API 目录内容获取</h2>

        <!-- 触发按钮（隐藏原生 input） -->

        <button id="selectDirBtn" class="bg-blue-500 text-white px-4 py-2 rounded hover:bg-blue-600">

            选择本地目录

        </button>

        <input type="file" id="dirInput" webkitdirectory directory style="display: none;">

        

        <!-- 文件列表展示区 -->

        <div class="mt-4 border rounded-lg max-h-80 overflow-y-auto">

            <div id="fileList" class="p-4 text-center text-gray-500">

                请选择目录以查看文件列表

            </div>

        </div>

    </div>



    <script>

        // 2.2 JavaScript 逻辑实现

        const dirInput = document.getElementById('dirInput');

        const selectDirBtn = document.getElementById('selectDirBtn');

        const fileList = document.getElementById('fileList');



        // 1. 点击按钮触发原生 input 选择目录

        selectDirBtn.addEventListener('click', () => {

            dirInput.click();

        });



        // 2. 监听目录选择变化，处理文件数据

        dirInput.addEventListener('change', (e) => {

            const selectedFiles = e.target.files; // 获取选中目录下的所有文件（含子目录文件）

            if (selectedFiles.length === 0) {

                fileList.innerHTML = '<div class="p-4 text-center text-gray-500">未选择任何文件</div>';

                return;

            }

            

            // 3. 解析文件数据并渲染到页面

            let fileHtml = '';

            Array.from(selectedFiles).forEach(file => {

                // 判断是否为目录（通过 type 为空且 size 为 0 间接判断）

                const isDir = file.type === '' && file.size === 0;

                // 获取文件在目录中的相对路径（webkitRelativePath 为非标准属性，但主流浏览器支持）

                const relativePath = file.webkitRelativePath || file.name;

                // 格式化文件大小（辅助函数）

                const fileSize = isDir ? '—' : formatFileSize(file.size);



                fileHtml += `

                    <div class="file-item">

                        <span class="file-icon ${isDir ? 'text-yellow-500' : 'text-gray-400'}">

                            ${isDir ? '📁' : '📄'}

                        </span>

                        <div class="file-info">

                            <div class="font-medium">${file.name}</div>

                            <div class="text-xs text-gray-500">${relativePath}</div>

                        </div>

                        <div class="file-size text-sm">${fileSize}</div>

                    </div>

                `;

            });



            fileList.innerHTML = fileHtml;

        });



        // 辅助函数：格式化文件大小（Bytes → KB/MB/GB）

        function formatFileSize(bytes) {

            if (bytes === 0) return '0 Bytes';

            const k = 1024;

            const units = ['Bytes', 'KB', 'MB', 'GB'];

            const i = Math.floor(Math.log(bytes) / Math.log(k));

            return `${(bytes / Math.pow(k, i)).toFixed(2)} ${units[i]}`;

        }

    </script>

</body>

</html>

3. 关键特性与限制

• 优势：兼容性强（支持 Chrome 15+、Firefox 4+、Safari 6+），无需额外依赖，实现简单。


• 限制：

三、方案二：基于 FileSystem Access API 实现（功能优先）

1. 方案概述

FileSystem Access API 是 W3C 正在标准化的现代 API（目前主要支持 Chromium 内核浏览器，如 Chrome 86+、Edge 86+），提供 “目录选择、递归遍历、文件读写、持久化权限” 等更强大的能力。通过 window.showDirectoryPicker() 直接请求用户授权，授权后可主动遍历目录结构，支持复杂的文件操作。

2. 完整使用示例

2.1 HTML 结构（含子目录遍历功能）

<!DOCTYPE html>

<html lang="zh-CN">

<head>

    <meta charset="UTF-8">

    <title>FileSystem Access API 目录访问示例</title>

    <script src="https://cdn.tailwindcss.com"></script>

    <style>

        .dir-tree-item { padding: 4px 0 4px 16px; border-left: 1px solid #eee; }

        .dir-header { display: flex; align-items: center; cursor: pointer; padding: 4px 0; }

        .dir-icon { margin-right: 8px; }

        .file-meta { color: #666; font-size: 14px; margin-left: 8px; }

    </style>

</head>

<body class="p-8 bg-gray-50">

    <div class="max-w-4xl mx-auto bg-white p-6 rounded-lg shadow">

        <h2 class="text-2xl font-bold mb-4">FileSystem Access API 目录遍历</h2>

        <!-- 触发目录选择按钮 -->

        <button id="openDirBtn" class="bg-green-500 text-white px-4 py-2 rounded hover:bg-green-600">

            打开并遍历目录

        </button>

        

        <!-- 目录树展示区 -->

        <div class="mt-4 border rounded-lg p-4 max-h-80 overflow-y-auto">

            <div id="dirTree" class="text-gray-500">

                请点击按钮选择目录

            </div>

        </div>

    </div>



    <script>

        // 2.2 JavaScript 逻辑实现（含递归遍历）

        const openDirBtn = document.getElementById('openDirBtn');

        const dirTree = document.getElementById('dirTree');



        openDirBtn.addEventListener('click', async () => {

            try {

                // 1. 检查浏览器兼容性

                if (!window.showDirectoryPicker) {

                    alert('您的浏览器不支持该功能，请使用 Chrome 或 Edge 浏览器');

                    return;

                }



                // 2. 请求用户选择目录（获取 DirectoryHandle 对象）

                const dirHandle = await window.showDirectoryPicker({

                    mode: 'read', // 权限模式：read（只读）/ readwrite（读写）

                    startIn: 'documents' // 默认打开目录（可选：documents、downloads 等）

                });



                // 3. 递归遍历目录结构并渲染

                dirTree.innerHTML = '<div class="text-center text-gray-500">正在读取目录...</div>';

                const treeHtml = await renderDirectoryTree(dirHandle, 0);

                dirTree.innerHTML = treeHtml;



            } catch (err) {

                // 捕获用户取消选择或权限拒绝错误

                if (err.name === 'AbortError') {

                    dirTree.innerHTML = '<div class="text-center text-gray-500">用户取消选择</div>';

                } else {

                    dirTree.innerHTML = `<div class="text-center text-red-500">错误：${err.message}</div>`;

                    console.error('目录访问失败：', err);

                }

            }

        });



        /**

         * 递归渲染目录树

         * @param {DirectoryHandle} handle - 目录/文件句柄

         * @param {number} depth - 目录深度（用于缩进）

         * @returns {string} 目录树 HTML

         */

        async function renderDirectoryTree(handle, depth) {

            const isDir = handle.kind === 'directory';

            const indent = 'margin-left: ' + (depth * 16) + 'px;'; // 按深度缩进

            let itemHtml = '';



            if (isDir) {

                // 处理目录：添加展开/折叠功能

                itemHtml += `

                    <div class="dir-header" style="${indent}" onclick="toggleDir(this)">

                        <span class="dir-icon text-yellow-500">📁</span>

                        <span class="font-medium">${handle.name}</span>

                        <span class="file-meta">（目录）</span>

                    </div>

                    <div class="dir-children" style="display: none;">

                `;



                // 遍历目录下的所有子项（递归）

                for await (const childHandle of handle.values()) {

                    itemHtml += await renderDirectoryTree(childHandle, depth + 1);

                }



                itemHtml += '</div>'; // 闭合 dir-children



            } else {

                // 处理文件：获取文件大小等元数据

                const file = await handle.getFile();

                const fileSize = formatFileSize(file.size);

                itemHtml += `

                    <div style="${indent} display: flex; align-items: center; padding: 4px 0;">

                        <span class="dir-icon text-gray-400">📄</span>

                        <span>${handle.name}</span>

                        <span class="file-meta">${fileSize}</span>

                    </div>

                `;

            }



            return itemHtml;

        }



        // 目录展开/折叠切换（全局函数，用于 HTML 内联调用）

        function toggleDir(el) {

            const children = el.nextElementSibling;

            children.style.display = children.style.display === 'none' ? 'block' : 'none';

            el.querySelector('.dir-icon').textContent = children.style.display === 'none' ? '📁' : '📂';

        }



        // 复用文件大小格式化函数（同方案一）

        function formatFileSize(bytes) {

            if (bytes === 0) return '0 Bytes';

            const k = 1024;

            const units = ['Bytes', 'KB', 'MB', 'GB'];

            const i = Math.floor(Math.log(bytes) / Math.log(k));

            return `${(bytes / Math.pow(k, i)).toFixed(2)} ${units[i]}`;

        }

    </script>

</body>

</html>

3. 关键特性与限制

• 优势：

• 限制：兼容性差，仅支持 Chromium 内核浏览器，Firefox 和 Safari 暂不支持。

四、两种方案对比分析

五、注意事项与最佳实践

if (window.showDirectoryPicker) {

    // 使用方案二（FileSystem Access API）

} else {

    // 使用方案一（File API）

}

前言

七夕，这个充满浪漫气息的传统节日，总是让人心生期待。对于程序员来说，虽然我们日常与代码为伴，但浪漫的心思也从不缺席。今年七夕，不妨用一种特别的方式表达爱意——用代码绘制一朵玫瑰花，送给那个特别的他/她。

编程与浪漫的结合

程序员的世界里，代码是我们的语言，逻辑是我们的画笔。虽然我们不常在言语上表达情感，但通过代码，我们可以创造出独一无二的浪漫。

绘制一朵玫瑰花，不仅是一次技术的挑战，更是一份心意的传递。在这个特别的日子里，用代码绘制的玫瑰花，或许能成为你表达爱意的特别方式。

依旧是让我们的ai编程大师Trae出手，看看能不能有惊艳的效果

第一次的提问，生成的效果很差

然后我就让他搜索一下目前互联网上的玫瑰花demo，模仿一下

这次看得出是一朵花，但是没有叶子，花瓣得仔细看才有，所以再次提问

一运行报错了，不要慌，我让我们得ai编程大师Trae 他自己修复一下

过了一分钟，Trae修复了之前的报错，看起来还是不错的，还可以支持旋转，很有艺术感的气氛，非常好~

Trae的实现思路

1. 结构优化

• 花瓣结构 ：引入了多层花瓣概念（5层），每层花瓣具有不同的形状、大小和卷曲效果，使花朵更加立体和真实


• 花茎改进 ：增加了花茎长度，调整了半径，并添加了椭圆横截面、自然弯曲和小刺，增强真实感


• 叶子优化 ：增加了叶子数量，采用交错排列，并实现了更复杂的叶子形状，包括中脉、宽度变化和向下弯曲效果

创建花茎和花茎的弯曲程度

玫瑰花的叶子，设计一定的曲度，看起来像真实的叶子

粒子系统优化

• 粒子数量 ：增加了粒子总数从20,000到30,000，提供更细腻的视觉效果


• 粒子分配 ：优化了花朵(70%)、花茎(20%)和叶子(10%)的粒子分配比例


• 粒子大小和透明度 ：根据粒子在花朵、花茎和叶子中的位置，以及与中心的距离，动态调整粒子大小和透明度

总结

在这个充满爱的节日里，程序员也可以用自己独特的方式表达浪漫。

用代码绘制一朵玫瑰花，不仅是一次有趣的编程实践，更是一份特别的礼物，希望这个小小的创意能为你的七夕增添一份特别的浪漫，如果你还有其他想法，可以把你的idea发给Trae，让他帮助你完成你的idea，对他/她进行爱意的表达，祝愿天下有情人终成眷属。

在实际开发中，你可以根据具体需求进一步优化和调整样式。希望这篇文章能对你有所帮助！

什么是抽象工厂模式

抽象工厂模式是一种创建型设计模式，它提供一个接口来创建一系列相关或相互依赖的对象家族，而无需指定它们的具体类。简单来说，抽象工厂模式是工厂模式的升级版，它不再只生产一种产品，而是生产一整套产品。

抽象工厂vs工厂方法：关键区别

• 工厂方法模式：关注单个产品的创建，一个工厂创建一种产品


• 抽象工厂模式：关注产品族的创建，一个工厂创建多种相关产品

这就像一个生产手机的工厂（工厂方法）和一个生产整套电子设备（手机、平板、耳机）的工厂（抽象工厂）的区别。

抽象工厂模式的核心实现

// 产品A接口

public interface ProductA {

    void operationA();

}



// 产品B接口

public interface ProductB {

    void operationB();

}



// 产品A1实现

public class ConcreteProductA1 implements ProductA {

    @Override

    public void operationA() {

        System.out.println("产品A1的操作");

    }

}



// 产品A2实现

public class ConcreteProductA2 implements ProductA {

    @Override

    public void operationA() {

        System.out.println("产品A2的操作");

    }

}



// 产品B1实现

public class ConcreteProductB1 implements ProductB {

    @Override

    public void operationB() {

        System.out.println("产品B1的操作");

    }

}



// 产品B2实现

public class ConcreteProductB2 implements ProductB {

    @Override

    public void operationB() {

        System.out.println("产品B2的操作");

    }

}



// 抽象工厂接口

public interface AbstractFactory {

    ProductA createProductA();

    ProductB createProductB();

}



// 具体工厂1 - 创建产品族1（A1+B1）

public class ConcreteFactory1 implements AbstractFactory {

    @Override

    public ProductA createProductA() {

        return new ConcreteProductA1();

    }

    

    @Override

    public ProductB createProductB() {

        return new ConcreteProductB1();

    }

}



// 具体工厂2 - 创建产品族2（A2+B2）

public class ConcreteFactory2 implements AbstractFactory {

    @Override

    public ProductA createProductA() {

        return new ConcreteProductA2();

    }

    

    @Override

    public ProductB createProductB() {

        return new ConcreteProductB2();

    }

}

抽象工厂模式的关键点

实际应用示例：跨平台UI组件库

下面通过一个跨平台UI组件库的例子来展示抽象工厂模式的强大应用：

// ===== 按钮组件 =====

public interface Button {

    void render();

    void onClick();

}



// Windows按钮

public class WindowsButton implements Button {

    @Override

    public void render() {

        System.out.println("渲染Windows风格的按钮");

    }

    

    @Override

    public void onClick() {

        System.out.println("Windows按钮点击效果");

    }

}



// MacOS按钮

public class MacOSButton implements Button {

    @Override

    public void render() {

        System.out.println("渲染MacOS风格的按钮");

    }

    

    @Override

    public void onClick() {

        System.out.println("MacOS按钮点击效果");

    }

}



// ===== 复选框组件 =====

public interface Checkbox {

    void render();

    void toggle();

}



// Windows复选框

public class WindowsCheckbox implements Checkbox {

    @Override

    public void render() {

        System.out.println("渲染Windows风格的复选框");

    }

    

    @Override

    public void toggle() {

        System.out.println("Windows复选框切换状态");

    }

}



// MacOS复选框

public class MacOSCheckbox implements Checkbox {

    @Override

    public void render() {

        System.out.println("渲染MacOS风格的复选框");

    }

    

    @Override

    public void toggle() {

        System.out.println("MacOS复选框切换状态");

    }

}



// ===== 文本框组件 =====

public interface TextField {

    void render();

    void getText();

}



// Windows文本框

public class WindowsTextField implements TextField {

    @Override

    public void render() {

        System.out.println("渲染Windows风格的文本框");

    }

    

    @Override

    public void getText() {

        System.out.println("获取Windows文本框内容");

    }

}



// MacOS文本框

public class MacOSTextField implements TextField {

    @Override

    public void render() {

        System.out.println("渲染MacOS风格的文本框");

    }

    

    @Override

    public void getText() {

        System.out.println("获取MacOS文本框内容");

    }

}



// ===== GUI工厂接口 =====

public interface GUIFactory {

    Button createButton();

    Checkbox createCheckbox();

    TextField createTextField();

}



// Windows GUI工厂

public class WindowsFactory implements GUIFactory {

    @Override

    public Button createButton() {

        return new WindowsButton();

    }

    

    @Override

    public Checkbox createCheckbox() {

        return new WindowsCheckbox();

    }

    

    @Override

    public TextField createTextField() {

        return new WindowsTextField();

    }

}



// MacOS GUI工厂

public class MacOSFactory implements GUIFactory {

    @Override

    public Button createButton() {

        return new MacOSButton();

    }

    

    @Override

    public Checkbox createCheckbox() {

        return new MacOSCheckbox();

    }

    

    @Override

    public TextField createTextField() {

        return new MacOSTextField();

    }

}

如何使用抽象工厂模式

// 应用类 - 与具体工厂解耦

public class Application {

    private Button button;

    private Checkbox checkbox;

    private TextField textField;

    

    // 构造函数接收一个抽象工厂

    public Application(GUIFactory factory) {

        button = factory.createButton();

        checkbox = factory.createCheckbox();

        textField = factory.createTextField();

    }

    

    // 渲染表单

    public void renderForm() {

        System.out.println("=== 开始渲染表单 ===");

        button.render();

        checkbox.render();

        textField.render();

        System.out.println("=== 表单渲染完成 ===");

    }

    

    // 表单操作

    public void handleForm() {

        System.out.println("\n=== 表单交互 ===");

        button.onClick();

        checkbox.toggle();

        textField.getText();

    }

}



// 客户端代码

public class GUIDemo {

    public static void main(String[] args) {

        // 检测当前操作系统

        String osName = System.getProperty("os.name").toLowerCase();

        GUIFactory factory;

        

        // 根据操作系统选择合适的工厂

        if (osName.contains("windows")) {

            factory = new WindowsFactory();

            System.out.println("检测到Windows系统，使用Windows风格UI");

        } else {

            factory = new MacOSFactory();

            System.out.println("检测到非Windows系统，使用MacOS风格UI");

        }

        

        // 创建并使用应用 - 注意应用不依赖于具体组件类

        Application app = new Application(factory);

        app.renderForm();

        app.handleForm();

    }

}

运行结果（Windows系统上）

检测到Windows系统，使用Windows风格UI

=== 开始渲染表单 ===

渲染Windows风格的按钮

渲染Windows风格的复选框

渲染Windows风格的文本框

=== 表单渲染完成 ===



=== 表单交互 ===

Windows按钮点击效果

Windows复选框切换状态

获取Windows文本框内容

运行结果（MacOS系统上）

检测到非Windows系统，使用MacOS风格UI

=== 开始渲染表单 ===

渲染MacOS风格的按钮

渲染MacOS风格的复选框

渲染MacOS风格的文本框

=== 表单渲染完成 ===



=== 表单交互 ===

MacOS按钮点击效果

MacOS复选框切换状态

获取MacOS文本框内容

抽象工厂模式的常见应用场景

抽象工厂模式的实际案例

许多知名框架和库使用抽象工厂模式，如：

• Java的JDBC：ConnectionFactory创建特定数据库的连接


• Spring Framework：通过BeanFactory创建和管理各种组件


• javax.xml.parsers.DocumentBuilderFactory：创建DOM解析器


• Hibernate：SessionFactory为不同数据库创建会话

抽象工厂模式的优点

抽象工厂模式的缺点

抽象工厂的实现变体

使用反射简化工厂实现

public class ReflectiveFactory implements GUIFactory {

    private String packageName;

    

    public ReflectiveFactory(String stylePrefix) {

        packageName = "com.example.gui." + stylePrefix.toLowerCase();

    }

    

    @Override

    public Button createButton() {

        return (Button) createComponent("Button");

    }

    

    @Override

    public Checkbox createCheckbox() {

        return (Checkbox) createComponent("Checkbox");

    }

    

    @Override

    public TextField createTextField() {

        return (TextField) createComponent("TextField");

    }

    

    private Object createComponent(String type) {

        try {

            Class<?> clazz = Class.forName(packageName + "." + type);

            return clazz.getDeclaredConstructor().newInstance();

        } catch (Exception e) {

            throw new RuntimeException("无法创建组件", e);

        }

    }

}

带有默认实现的抽象工厂

public abstract class BaseGUIFactory implements GUIFactory {

    // 提供默认实现

    @Override

    public TextField createTextField() {

        return new DefaultTextField(); // 所有平台通用的默认实现

    }

    

    // 其他方法需要子类实现

    @Override

    public abstract Button createButton();

    @Override

    public abstract Checkbox createCheckbox();

}

实现抽象工厂的设计考虑

抽象工厂模式最佳实践

// 使用配置驱动的工厂

public class ConfigurableGUIFactory {

    public static GUIFactory getFactory() {

        String factoryType = ConfigLoader.getProperty("ui.factory");

        

        switch (factoryType) {

            case "windows": return new WindowsFactory();

            case "macos": return new MacOSFactory();

            case "web": return new WebFactory();

            default: throw new IllegalArgumentException("未知UI工厂类型");

        }

    }

}

抽象工厂与依赖倒置原则

抽象工厂是实现依赖倒置原则的绝佳方式：高层模块不依赖于低层模块，两者都依赖于抽象。

// 不好的设计：直接依赖具体类

public class BadForm {

    private WindowsButton button; // 直接依赖具体实现

    private WindowsCheckbox checkbox;

    

    public void createUI() {

        button = new WindowsButton(); // 硬编码创建具体类

        checkbox = new WindowsCheckbox();

    }

}



// 好的设计：依赖抽象

public class GoodForm {

    private Button button; // 依赖接口

    private Checkbox checkbox;

    private final GUIFactory factory; // 依赖抽象工厂

    

    public GoodForm(GUIFactory factory) {

        this.factory = factory;

    }

    

    public void createUI() {

        button = factory.createButton(); // 通过工厂创建

        checkbox = factory.createCheckbox();

    }

}

抽象工厂模式小结

抽象工厂模式是一种强大但需谨慎使用的创建型模式。它在需要一套相关产品且系统不应依赖于产品的具体类时非常有用。这种模式有助于确保产品兼容性，并为产品族提供统一的创建接口。

适当应用抽象工厂模式可以使代码更具灵活性和可维护性，但也要避免过度设计导致的复杂性。理解产品族的概念和如何设计良好的抽象工厂接口是掌握这一模式的关键。

关注我的公众号：【编程朝花夕拾】，可获取首发内容。

01 引言

在现代微服务架构中，应用实例的数量动辄成百上千。传统的逐个登录服务器查看日志、检查状态的方式早已变得低效且不现实。

因此，一个集中化、可视化、且能提供实时健康状态的管理平台变得至关重要。Spring Boot Admin (SBA) 正是为了满足这一需求而生的强大工具。

然而，各种厂商的云服务提供了各种监控服务解决客户的各种痛点。Spring Boot Admin这样的工具似乎关注度没有那么高。小编也是无意间发现这款产品，分享给大家。

02 简介

Spring Boot Admin 是一个用于管理和监控 Spring Boot 应用程序的开源社区项目。它并非官方 Spring 项目，但在社区中备受推崇并被广泛使用。

其核心原理是：一个作为“服务器”（Server）的中央管理端，通过收集并展示众多作为“客户端”（Client）的 Spring Boot 应用的监控信息。

Spring Boot Admin 通过集成 Spring Boot Actuator 端点来获取应用数据，并提供了一个友好的 Web UI 界面来展示这些信息。

主要分为两部分：

• 服务端：监控平台


• 客户端：业务端

SpringBoot的版本和Spring Boot Admin有一定的对应关系：

GitHub地址：github.com/codecentric…

文档地址：docs.spring-boot-admin.com/

03 Admin服务端

服务的端配置相当简单，只需要引入依赖，启动增加注解。服务端的基础配置就算完成了。

3.1 基础配置

Maven依赖

<dependency>

    <groupId>de.codecentric</groupId>

    <artifactId>spring-boot-admin-starter-server</artifactId>

    <version>${latest.version}</version>

</dependency>

增加注解

@EnableAdminServer

这两个配置就可访问项目的IP+端口，进入管理页面了。

3.2 增加鉴权

为了数据安全，可以增加鉴权。拥有账号和密码方可进入。

Maven依赖

<dependency>

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

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

</dependency>

配置文件

# 设置自己的用户名和密码

spring.security.user.name=admin

spring.security.user.password=123456

输入对应的用户名和密码就可以进入了。

3.3 增加邮件推送

官方提供了各种通知，也可以自定义，如图：

我们以邮件通知为例。

Maven依赖

<dependency>

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

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

</dependency>

配置

# 邮箱配置

spring.mail.host=smtp.163.com

spring.mail.port=25

spring.mail.username=用户名

spring.mail.password=*****[授权码]



# 发送和接受邮箱

spring.boot.admin.notify.mail.to=wsapplyjob@163.com

spring.boot.admin.notify.mail.from=wsapplyjob@163.com

客户端下线之后会触发邮件：

04 Adamin客户端

因为服务端是依赖Spring Boot Actuator 端点来获取应用数据，所以我们需要开放期其所有的服务。

4.1 基础配置

Maven依赖

<dependency>

    <groupId>de.codecentric</groupId>

    <artifactId>spring-boot-admin-starter-client</artifactId>

    <version>${latest.version}</version>

</dependency>



<dependency>

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

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

</dependency>

# 服务端地址

spring.boot.admin.client.url=http://127.0.0.1:8081

# 鉴权信息

spring.boot.admin.client.username=admin

spring.boot.admin.client.password=123456



# 开发所有的暴漏的信息

management.endpoints.web.exposure.include=*

4.2 监控界面

进入之后，我们就会发现上面的页面。点击应用墙，就会展示所有监控的实例。进入之后如图：

进入之后就可以看到五大块。其中②就是我们之前看到的日志级别的控制。还包含了缓存、计划任务、映射甚至类之间的依赖关系。

因为界面支持中文，里面具体的功能就不做描述，感兴趣的可以自己的探索。

4.3 日志配置增加日志

默认的日志进去只有日志的级别，并不会打印日志。

这是官方的描述：

我们增加配置：

logging.file.name=/var/log/boot-log.log

logging.pattern.file=%clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){faint} %clr(%5p) %clr(${PID}){magenta} %clr(---){faint} %clr([.15t]){faint} %clr(%-40.40logger{39}){cyan} %clr(:){faint} %m%n%wEx (2)

启动查看结果：

我们就可以看到信的菜单：日志文件

4.4 缓存

【缓存】是没有数据的：

缓存依赖

<!-- 监控缓存需要的依赖 -->

<dependency>

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

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

</dependency>

代码

触发缓存任务之后，就会出现缓存的管理：

4.5 计划任务

【计划任务】和缓存基本一样，但是无需引入第三方依赖。使用@Scheduled即可。

监控结果：

05 小结

Spring Boot Admin 以其简洁的配置、强大的功能和友好的界面，成为了 Spring Boot 微服务监控领域的事实标准。它极大地降低了监控和运维的复杂度，让开发者能够更专注于业务逻辑开发。

对于中小型规模的微服务集群，直接使用 SBA 是一个高效且成本低廉的解决方案。

赶快去探索里面不同的功能的吧！

1. 前言

比上班更可怕的是什么？是加班。

比加班更可怕的是什么？是固定加班，也就是 996，大小周。

作为一个荣获 996 福报的牛马，我认为我的际遇已经很可怕了。

没想到还有比这更可怕的，拖着被996折腾过的疲惫身体回家后。我儿子向我展示他一天的劳动成果。

这时候你肯定会说让他收起来不就行了？这时候我应该拿出标志性的礼貌三问：你有对象吗？你有儿子吗？你让你儿子收他就收吗？

不会吧，你儿子收啊。那我和你换个儿子吧。

我对我儿子威逼利诱什么招式都试过了，他每次就3招我就没辙了：

爸爸，我累了你帮我收吧。

爸爸，地上的玩具太多了你和我一起收吧，收着收着这小子就不见了。

爸爸，我要睡觉了，晚安。

每天晚上我都要花时间收拾这个烂摊子，收过十几次后我后知后觉有了个想法。

平时我工作的时候，一个5分钟就能手写完搞定的配置我都要花10分钟写个脚本自动化。

为啥不能让收玩具这件事情自动化呢？我可是个优雅的程序员啊。重复做一个动作在我这应该是严格禁止的才对。

所以我打算做一个自动收玩具的机器。

不是哥们，这我真做不了。在我这自动化是什么意思呢？

不需要自己动手干的就是自动化，把配置做到管理后台，让运营自己去配置算不算自动化？那必须是的呀。

那么，想一种办法让我儿子自己把玩具收起来是不是自动化？那也必须是的呀。

自动化的定义就是不需要自己动手干，管是机器干还是人干，反正不要我来干。

说干就干，我儿子特别喜欢数字，迷恋加法。那不就盖了帽了。给他安排一个任务APP，收完一件玩具就加分，他肯定特满足特有成就感。

我虽然是一个前端后端运维测试攻城狮，但我的的确确没有开发过APP。除了大学要交 Android 作业抱过同学大腿喵了一眼，从那之后我就下定决定干后端去了。因为艺术细菌不是说本人没有，是本人想有但它对我不感冒啊。

但是别忘了，现在是 AI 的时代。产品的活我不会，AI 来。APP 开发我不会，AI 来。貌似不需要后端，那我只能当当测试了。

2. 正片开始

我调研了一圈，目前有几种方案可以实现：

原生做起来体验最好，但是搭个环境真是要了我的老命了，所以弃之。

flutter总体感觉不错，但是要另外学一门语言，想想我就脑壳疼，亦弃之。

uni-app 看起来不咋滴，蛮多人吐槽但也有真正的案例。但我发现它能云打包，不用我在本地配一堆乱七八糟的。下载一个HBuilder 就行了，虽然很多人吐槽这个 IDE，但关我啥事？是 AI 来写代码，又不是我写代码，尽管恶心 AI 去。选它选它

2.1 画原型图

Cursor，Gemini，claude code 我都试了，Gemini的设计感最强，豆包的体验最好。豆包的效果看起来非常的奈斯啊！

2.2 开发

有了原型那就好办了，直接贴图让cursor 或者 claude code 对着实现就行了。

这里要吐槽一下claude code，不能粘贴板直接贴图，只能把图片拖进去，差评。

现在可以粘贴图片了，Mac 可以尝试用ctrl+v（没错，不是command+v）

把所有的原型图贴进去之后，输入这句简单的Prompt，claude code 就会开始干活了。

请根据原型图，使用uniapp 开发一个app

2.3 加需求

第一版完成了他的使命，最近儿子有点腻烦了，收个玩具磨磨蹭蹭的。不行，我得想点法子，加点东西让他保持新鲜感，然后养成习惯，以后就不用我管了，想想就非常的苏胡啊。

所以为了调动他的积极性，更营造一个紧张的氛围，我加入了倒计时功能：

接下来有个新功能。我想为任务增加一个计时完成功能：



  1. 完成任务时，不再是简单的点击即可；



  2. 完成任务时，应该提供一个开始完成按钮，然后启动倒计时



  3. 创建任务时，应该配置预计完成时间



  4. 完成任务时，遵循规则：a.如果在预计时间的一半完成可以得到2倍的分数；b.如果超过一半时间完成则得到1.5倍分数；c.如果超时完成则得到1倍分数

直接把需求丢给AI实现去，自己测试测试，没问题就打包。

2.3 测试打包

先浏览器运行看看效果，可以 F12 切换成手机视图看有没有挤压之类的。

测试没问题就直接打包。因为我是尊贵的 Android 用户，所以我只跑了 Android 打包。

我坦白，uni-app部分我基本是看这个老哥的：juejin.cn/post/729631…

2.4 看看效果

在Java开发中，哈希码的使用无处不在，但许多开发者对System.identityHashCode()和Object.hashCode()的区别仍然模糊不清。本文将深入剖析二者的核心区别，并通过实际代码演示它们在不同场景下的行为差异。

一、本质定义：两种哈希码的起源

二、核心区别对比（表格速查）

三、关键差异深度解析

1. 重写行为对比（核心区别）

class CustomObject {

    private int id;

    

    // 重写hashCode（基于内容）

    @Override

    public int hashCode() {

        return id * 31;

    }

}



public static void main(String[] args) {

    CustomObject obj = new CustomObject();

    obj.id = 100;

    

    System.out.println("hashCode: " + obj.hashCode());         // 3100

    System.out.println("identityHashCode: " + System.identityHashCode(obj)); // 356573597

}

输出说明：

✅ hashCode()返回重写后的计算值

✅ identityHashCode()无视重写，返回JVM原始哈希

2. null安全性对比

Object obj = null;



// 抛出NullPointerException

try {

    System.out.println(obj.hashCode());

} catch (NullPointerException e) {

    System.out.println("调用hashCode()抛NPE");

}



// 安全返回0

System.out.println("identityHashCode(null): " 

                    + System.identityHashCode(obj)); 

3. 哈希码不变性验证

String str = "Hello";

int initialIdentity = System.identityHashCode(str);



str = str + " World!"; // 修改对象内容



// 身份哈希码保持不变

System.out.println(initialIdentity == System.identityHashCode(str)); // true

四、经典应用场景

1. 使用Object.hashCode()的场景

// 在HashMap中作为键（依赖内容哈希）

Map<Student, Grade> gradeMap = new HashMap<>();

Student s = new Student("2023001", "张三");

gradeMap.put(s, new Grade(90));



// 重写需遵守规范：内容相同则哈希码相同

class Student {

    private String id;

    private String name;

    

    @Override

    public int hashCode() {

        return Objects.hash(id, name);

    }

}

2. 使用identityHashCode()的场景

场景1：实现身份敏感的容器

// IdentityHashMap基于身份哈希而非内容

IdentityHashMap<Object, String> identityMap = new IdentityHashMap<>();

String s1 = new String("ABC");

String s2 = new String("ABC");



identityMap.put(s1, "第一对象");

identityMap.put(s2, "第二对象"); // 不同对象，均可插入



System.out.println(identityMap.size()); // 2

场景2：检测hashCode是否被重写

boolean isHashCodeOverridden(Object obj) {

    return obj.hashCode() != System.identityHashCode(obj);

}



// 测试

System.out.println(isHashCodeOverridden(new Object())); // false

System.out.println(isHashCodeOverridden(new String("Test"))); // true

场景3：调试对象内存关系

Object objA = new Object();

Object objB = objA; // 指向同一对象



// 身份哈希相同证明是同一对象

System.out.println(System.identityHashCode(objA) 

                == System.identityHashCode(objB)); // true

五、底层机制揭秘

六、总结与最佳实践

黄金准则：

• 当对象作为HashMap等内容敏感容器的键时 → 重写hashCode()+equals()


• 当需要对象身份标识（如调试、IdentityHashMap)时 → 使用identityHashCode()


• 永远不要在重写的hashCode()中调用identityHashCode()，这违反哈希契约！

通过合理选择这两种哈希码，可以避免常见的HashMap逻辑错误和身份混淆问题。理解它们的差异，将使你的Java代码更加健壮高效！

针对DeepSeek回答过于笼统的问题，可通过以下方法优化，使输出更具体、详细：

一、优化提示词设计

二、参数调整与功能设置

三、迭代优化技巧

四、进阶解决方案

若常规方法仍不理想，可尝试：

效果对比示例

通过以上方法，可系统化解决回答笼统的问题。

前言

在Vue项目开发中，弹窗组件的管理一直是一个令人头疼的问题。传统的声明式弹窗开发方式需要管理大量的状态变量、处理复杂的props传递，甚至可能面临多个弹窗嵌套时的状态管理困境。今天给大家介绍一个能够彻底改变这种开发体验的库：Vue-Command-Component。

为什么需要命令式组件？

在传统的Vue开发中，弹窗的使用通常是这样的：

<template>

  <el-dialog v-model="visible" title="提示">

    <span>这是一段信息</span>

    <template #footer>

      <span class="dialog-footer">

        <el-button @click="visible = false">取消</el-button>

        <el-button type="primary" @click="handleConfirm">确认</el-button>

      </span>

    </template>

  </el-dialog>

</template>



<script setup>

const visible = ref(false)

const handleConfirm = () => {

  // 处理确认逻辑

  visible.value = false

}

</script>

这种方式存在几个明显的问题：

Vue-Command-Component 解决方案

使用Vue-Command-Component，上述问题都可以得到优雅的解决。来看看它是如何使用的：

import { useDialog } from "@vue-cmd/element-plus";



const CommandDialog = useDialog()



// 直接调用函数显示弹窗

CommandDialog(<div>这是一段信息</div>)

是的，就是这么简单！一行代码就能唤起一个弹窗，不需要管理状态，不需要写模板，一切都变得如此流畅。

核心特性

1. 极简API设计

无需管理状态，一个函数调用搞定所有事情，符合直觉的开发体验。

2. 完整的类型支持

提供完整的TypeScript类型支持，开发体验一流。

3. 灵活的控制能力

提供了多种控制方式：

• destroy：销毁弹窗


• hide/show：控制弹窗显示/隐藏


• destroyWithResolve/destroyWithReject：支持Promise风格的控制

4. 强大的扩展性

支持多种UI框架：

• Element Plus


• Naive UI


• Vant


• ...更多框架支持中

5. 原生特性支持

完整支持原生组件的所有特性：

• 属性传递


• 事件处理


• 插槽支持


• Provide/Inject

安装

# 使用 npm

npm install @vue-cmd/core @vue-cmd/element-plus



# 使用 yarn

yarn add @vue-cmd/core @vue-cmd/element-plus



# 使用 pnpm

pnpm add @vue-cmd/core @vue-cmd/element-plus



# 使用 bun

bun add @vue-cmd/core @vue-cmd/element-plus

实战示例

基础用法

import { useDialog } from "@vue-cmd/element-plus";



const CommandDialog = useDialog()



// 基础弹窗

CommandDialog(<Content />)



// 带配置的弹窗

CommandDialog(<Content />, {

  attrs: {

    title: '标题',

    width: '500px'

  }

})