最近，和往常一样在刷 GitHub Trending 热榜时，突然看到又一个开源项目冲上了 Trending 榜单。

一天之内就狂揽数千 star，仅仅用两三天时间，star 数就迅速破万，增长曲线都快干垂直了！

出于好奇，点进去看了看。

好家伙，这居然还是小米开源的项目，相信不少小伙伴也刷到了。

这个项目名为：ha_xiaomi_home。

全称：Xiaomi Home Integration for Home Assistant。

原来这就是小米开源的 Home Assistant 米家集成，一个由小米官方提供支持的 Home Assistant 集成组件，它可以让用户在 Home Assistant 平台中使用和管理小米 IoT 智能设备。

Home Assistant 大家知道，这是一款开源的家庭自动化智能家居平台，以其开放性和兼容性著称，其允许用户将家中的智能设备集成到一个统一的系统中进行管理和控制，同时支持多种协议和平台。

通过 Home Assistant，用户可以轻松地实现智能家居的自动化控制，如智能灯光、智能安防、智能温控等，所以是不少智能家居爱好者的选择。

另外通过安装集成（Integration），用户可以在 Home Assistant 上实现家居设备的自动化场景创建，并且还提供了丰富的自定义功能，所以一直比较受 DIY 爱好者们的喜爱。

大家知道，小米在智能家居领域的战略布局一直还挺大的，IoT 平台的连接设备更是数以亿记，大到各种家电、电器，小到各种摄像头、灯光、开关、传感器，产品面铺得非常广。

那这次小米开源的这个所谓的米家集成组件，讲白了就是给 Home Assistant 提供官方角度的支持。

而这对于很多喜欢折腾智能家居或者 IoT 物联网设备的小伙伴来说，无疑也算是一个不错的消息。

ha_xiaomi_home 的安装方法有好几种，包括直接 clone 安装，借助 HACS 安装，或者通过 Samba 或 FTPS 来手动安装等。

但是官方是推荐直接使用 git clone 命令来下载并安装。

cd config

git clone https://github.com/XiaoMi/ha_xiaomi_home.git

cd ha_xiaomi_home

./install.sh /config

原因是，这样一来当用户想要更新至特定版本时，只需要切换相应 Tag 即可，这样会比较方便。

比如，想要更新米家集成版本至 v1.0.0，只需要如下操作即可。

cd config/ha_xiaomi_home

git checkout v1.0.0

./install.sh /config

安装完成之后就可以去 Home Assistant 的设置里面去添加集成了，然后使用小米账号登录即可。

其实在这次小米官方推出 Home Assistant 米家集成之前，市面上也有一些第三方的米家设备集成，但是多多少少会有一些不完美的地方，典型的比如设备状态响应延时，所以导致体验并不是最佳。

与这些第三方集成相比，小米这次新推出的官方米家集成无论是性能还是安全性都可以更期待一下。

如官方所言，Home Assistant 米家集成提供了官方的 OAuth 2.0 登录方式，并不会在 Home Assistant 中保存用户的账号密码，同时账号密码也不再需提供给第三方，因此也就避免了账号密码泄露的风险。

但是这里面仍然有一个问题需要注意，项目官方也说得很明确：虽说 Home Assistant 米家集成提供了 OAuth 的登录方式，但由于 Home Assistant 平台的限制，登录成功后，用户的小米用户信息（包括设备信息、证书、 token 等）会明文保存在 Home Assistant 的配置文件中。因此用户需要保管好自己的 Home Assistant 配置文件，确保不要泄露。

这个项目开源之后，在网上还是相当受欢迎的，当然讨论的声音也有很多。
小米作为一家商业公司，既然专门搞了这样一个开源项目来做 HA 米家集成，这对于他们来说不管是商业还是产品，肯定都是有利的。

不过话说回来，有了这样一个由官方推出的开源集成组件，不论是用户体验还是可玩性都会有所提升，这对于用户来说也未尝不是一件好事。

那关于这次小米官方开源的 Home Assistant 米家集成项目，大家怎么看呢？

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

牛马终究还是回到了草原

大家好呀，今天开始继续更新文章了，最近一个月因为换了城市，调整状态花了不少时间，现在才有些动力继续更新，今天来聊聊最近一年多的经历

1.回二线城市

23年12月的时候，我从北京阿里离职了，回到离家近的武汉，拿了一个国企的offer，也是在那家国企待了一年多的时间。

至于为什么会选择回武汉，主要觉得在一线城市买不起房，而且长期在外离家远，漂泊感太重，还不如早点回二线城市定居下来，免得以后年龄大了更不好回来。所以，当时看武汉的机会主要找稳定的工作，除了国企offer，还拿过高校，以及其他偏稳定的公司offer。综合考虑后，才选的国企

回来之后没到两月，就有些后悔了。虽然回来之前做好了心理预期，工资会降低，只是国企的工资也低的过于少了吧，开始几个月工资只有原来的零头。而且，呆了一段时间后发现，这个国企在北京才是研发中心，武汉这边作为分中心，只是北京的“内包”而已。

项目经理都是在北京，很多还都是校招进去工作才两三年的，就让管武汉这边几个人的工作。这些人也没啥管理经验，就只是不停给底下人施压。而且经常搞的操作就是，项目都是有时间要求的，开始的时候不拉人进来干活，等到时间比较紧的时候，才拉人进来，这就导致武汉的人收到任务时，都是重要且紧急的工作。又或者正常工作日没安排活，等到要放假，或者下班之前，才给安排活，让自行加班完成，故意恶心人

2.上着北京的班，拿着武汉的工资

这个事在24年的时候，已经发过吐槽了，就发张截图看看

3.成长的焦虑

我在北京的时候，除了阿里，之前也呆过一家互联网公司。裁员是比较常见的事情，虽然我还没被裁过。

国企这边虽然说相对比较稳定，但是自从我这批大概20个人入职后，感觉在走下坡路了，不仅福利变少，而且也变卷了，还传出后面也要搞末尾淘汰的事。我呆了一年的时候，感觉比在一线时更害怕，假如我在这里被裁了，或者呆满三年不续签了，可能很难再找到合适的工作了，自身成长和工作年限严重不匹配，想到这，我终于还是下了决定再去一线城市

找下家的经历并不顺利，国企的项目可以说就是玩具而已，完全拿不出手。只能拿之前阿里的项目去讲。有些一线互联网大厂，面试了好几轮，好不容易都过了。在焦急等待了数周后，最后给我说横向比较有更合适的了，就不考虑了。其实大家也都明白是因为啥原因不给发。

4.空窗期

经历了几个月的找工作经历后，终于是拿到上海一家公司offer，于是也就顺理成章准备跑路了。趁着中间有半个月的空闲时间，去西边青海和西藏游玩了一次。那边景点之间距离远，在携程上报跟团游就行，价钱不高，比较推荐去青海游玩，那的牛肉和羊肉非常新鲜，值得尝试，3天的时间，每天都能看不一样的风景。

5.上海

已经到上海快两个月，开始逐渐习惯天天下雨的节奏，现在下班还是比较早的，下班的时候还能见着落日，比较WLB，没有互联网大厂那么的卷，却也是有些压力的。下面是第一周下班时路上的照片

今天就写到这吧，下次有新鲜事再分享~

昨儿中午吃着饭，不知道为啥突然和同事聊起来AI发展的事儿了。虽然我们只是"🐂🐎"，但是不妨碍咱们坐井观天，瞎扯淡聊聊天。

他的主要观点是：现阶段的AI绝对无法取代程序员，大家有点过度恐慌了。AI是程序员的工具，就像从记事本升级到IDE一样。

我的主要观点是：AI一定会取代大量的程序员，尤其是初级程序员。后续程序员岗将在软件公司内的比重降低，取而代之的是产品、需求和算法岗。

诚然，他说的也有一定的道理，就目前AI发展的速度和质量来看，其实大家的确有点儿过度恐慌了。

AI的确在一定程度上替代的程序员的工作，但是大多内容仍然是程序员群体在产出，这个是不容否认的事实。

不过另一个不容否认的事实是，我们越来越依赖AI了。原来大家写代码一般都是啥不会了，就直接去网上搜。比如说js怎么截断从第2位到最后一位，想不起来了，搜一搜。

现在有了AI，一般的操作都是在上面写个注释，然后回车一下，AI会自动帮你补全代码，连搜的功夫都省了。

由此俺也big胆的预言一把，CSD*、掘*、百*这些资讯类，尤其是做程序员这个方向的资讯网站会越来越没落。

原因是：有了问题，但是没有了搜索。没有搜索就没有共享解决方案的必要，因为没人看。没人看所以不再有人分享，最后Over。

Ps：或许我被啪啪打脸呢？

之前的AI编码工具我就有在用，包括阿里的通义，百度的文心，或者是IDEA里面内嵌的编码助手，以及之前CodeGeex等等吧，确确实实是提高了效率的。

这个阶段其实重点提升的是搜索的效率，有问题直接问AI，AI直接给出答案。95%的答案都是正确的，不必再去网上费劲巴拉的找了。

后来更上一层楼，Claude2、3直接翻倍的提升了开发效率。我不必再实现了，我只需要阐述需求，AI会自动给出答案。我需要的是把内容Copy下来，然后整合进我的工程里面。

后面的工作就还是原来的老步骤了，测试一下，没啥问题的话就发版，提测了。

但是现在这个阶段又进步了，TREA2.0 SOLO出道直接整合了全流程，整个过程直接变成了"智能体"把控，不再需要我的干涉了。

我需要做的工作就是阐述清楚我的需求，然后让TREA去实现。这个过程中可能也就只需要我关注一下实现的方向不要有太大的偏差，及时纠正一下(但是到目前为止没遇到过需要纠正的情况)。

也就是说，现在AI已经从原来的片面生成代码，到后面的理解需求生成单文件代码，到现在生成工程化代码了。

而我们的角色也从一个砌墙工人，拿到了一把能自动打灰的铲子。

到后面变成一个小组长，拿着尺子和吊锤看他们盖的墙有没有问题。

到现在变成包工头看着手底下的工人一层层的盖起大楼。

但是！

你说工地上是工人多，还是组长多，还是包工头多？真的需要这么多包工头嘛？

什么是透明贴图

• 核心作用：像「镂空剪纸」一样控制物体哪些部位透明/不透明
  
  

  （想象：给树叶模型贴图，透明部分让树叶边缘自然消失而非方形边缘）



• 技术本质：一张 黑白图片（如 PNG 带透明通道），其中：
  
  
  
  
  • 黑色区域 → 模型对应位置 完全透明（消失）
  
  
  • 白色区域 → 模型 完全不透明（显示）
  
  
  • 灰色过渡 → 半透明效果（如玻璃边缘）
  
  
  
  

示例：游戏中的铁丝网、树叶、破碎特效等镂空物体常用此技术

常见问题与解决方案

技巧：透明贴图需搭配 基础颜色贴图（map）  使用，两者共同决定最终外观

实际应用场景

实践案例一

效果如图

实现思路

通过canvas绘制内容，canvasTexture用来转换为3d纹理

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

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

    canvas.width = 64;

    canvas.height = 64;

    ctx.fillStyle = '#404040';

    ctx.fillRect(0, 0, 32, 32);

    ctx.fillStyle = '#808080';

    ctx.fillRect(32, 0, 32, 32);

    ctx.fillStyle = '#c0c0c0';

    ctx.fillRect(0, 32, 32, 32);

    ctx.fillStyle = '#f0f0f0';

    ctx.fillRect(32, 32, 32, 32);

    const texture = new THREE.CanvasTexture(canvas);

这里画布大小设置为64*64，被均匀分割为4份，并填充不同的颜色

接下来创建一个立方体，为其贴上透明度贴图alphaMap，设置transparent:true这很关键

const geo = new THREE.BoxGeometry(1, 1, 1);

const material = new THREE.MeshBasicMaterial({

    color: 'deepskyblue',

    alphaMap: texture, // 透明度贴图

    transparent: true,

    opacity: 1,

    side: THREE.DoubleSide

});

如果你尝试将transparent配置改为false, 你将看到如下效果

同样我们尝试修改canvas绘制时候的填充色，来验证黑白镂空情况

ctx.fillStyle = '#000';

ctx.fillRect(0, 0, 32, 32);

ctx.fillStyle = '#000';

ctx.fillRect(32, 0, 32, 32);

ctx.fillStyle = '#000';

ctx.fillRect(0, 32, 32, 32);

ctx.fillStyle = '#fff';

ctx.fillRect(32, 32, 32, 32);

如图所示，黑色消失，白色显示保留

总结本案例需要掌握的API

CanvasTexture

这是Texture的子类，它用于将动态绘制的 2D Canvas 内容（如图表、文字、实时数据）转换为 3D 纹理，使得HTML Canvas元素可以作为纹理映射到3d物体表面

它支持实时更新，默认needsUpdate为true

应用场景

• 动态数据可视化：将实时图表（如温度曲线）映射到 3D 面板。


• 文字标签：在 3D 物体表面显示可变文字（如玩家名称）。


• 程序化纹理：通过算法生成图案（如噪波、分形）。


• 交互式绘制：用户画布涂鸦实时投射到 3D 模型（如自定义 T 恤设计）。

性能优化

• 避免频繁更新：若非必要，减少 needsUpdate=true 的调用频率。


• 合理尺寸：Canvas 尺寸建议为 2 的幂（如 256×256, 512×512），兼容纹理映射。


• 复用 Canvas：对静态内容，复用已生成的纹理而非重新创建。


• 替代方案：静态图像用 TextureLoader，视频用 VideoTexture，以降低开销。

需要注意

• 跨域限制：若 Canvas 包含外部图片，需设置 crossOrigin="anonymous"。


• 清晰度问题：高缩放比例可能导致模糊，可通过 texture.anisotropy = renderer.capabilities.getMaxAnisotropy() 改善。


• 内存管理：不再使用的纹理调用 texture.dispose() 释放资源。

实践案例二

效果如图

实现思路

从图上可以看出，立方体每个面上有多个矩形小方块，每个方块都被赋予不同的颜色，创建grid方法来实现生产多个矩形小方块

const drawMethod = {};

drawMethod.grid = (ctx, canvas, opt={} ) => {

    opt.w = opt.w || 4;

    opt.h = opt.h || 4;

    opt.colors = opt.colors || ['#404040', '#808080', '#c0c0c0', '#f0f0f0']; 

    opt.colorI = opt.colorI || []; 

    let i = 0;

    const len = opt.w * opt.h,

    sizeW = canvas.width / opt.w, // 网格宽度

    sizeH = canvas.height / opt.h;  // 网格高度



    while(i<len) {

        const x = i % opt.w,

        y = Math.floor(i / opt.w);

        ctx.fillStyle = typeof opt.colorI[i] === 'number' ? opt.colors[opt.colorI[i]] : opt.colors[i % opt.colors.length];

        ctx.fillRect(x * sizeW, y * sizeH, sizeW, sizeH);

        i++;

    }

}

实现透明贴图

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

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

canvas.width = 64;

canvas.height = 64;

const texture = new THREE.CanvasTexture(canvas);



const geo = new THREE.BoxGeometry(1, 1, 1);

const material = new THREE.MeshBasicMaterial({

    color: 'deepskyblue',

    alphaMap: texture,

    transparent: true,

    opacity: 1,

    side: THREE.DoubleSide

});

这里要注意，canvas上并未绘制任何内容，我们将在loop循环中调用grid方法进行绘制

let frame = 0,

lt = new Date();  // 上一次时间

const maxFrame = 90, // 最大帧数90帧

fps = 20; // 每秒20帧

function loop() {

    const now = new Date(),  // 当前时间

    secs = (now - lt) / 1000, // 时间差

    per = frame / maxFrame;  // 进度

    if (secs > 1 / fps) {   // 时间差大于1/20

        const colorI = [];

        let i = 6 * 6;

        while (i--) {

            colorI.push(Math.floor(4 * Math.random()))

        }

        drawMethod.grid(ctx, canvas, {

            w: 6,

            h: 6,

            colorI: colorI

        });

        texture.needsUpdate = true;  // 更新纹理

        mesh.rotation.y = Math.PI * 2 * per;

        renderer.render(scene, camera);

        frame += fps * secs;  // 帧数累加

        frame %= maxFrame;   // 帧数取模，防止帧数溢出



        lt = now;

    }

    // 渲染场景和相机

    requestAnimationFrame( loop );

}

你可以看到这里每个面上被绘制了36个小矩形，并通过一下代码，随机填充颜色

while (i--) {

    colorI.push(Math.floor(4 * Math.random()))

}

以上就是本章的所有内容，这里并未展示完整案例代码，是希望大家能动手练一练，很多的概念，看似晦涩难懂，实则动手尝试下的话秒懂。

Spring 状态机与事件机制插件开发示例

我将为您演示一个完整的 Spring 状态机实现，包含状态机配置、事件机制和可扩展的插件体系。以下是一个订单处理系统的示例：

1. 添加依赖（pom.xml）

<dependencies>

    <!-- Spring State Machine -->

    <dependency>

        <groupId>org.springframework.statemachine</groupId>

        <artifactId>spring-statemachine-starter</artifactId>

        <version>4.2.0</version>

    </dependency>

    

    <!-- Spring Event 相关 -->

    <dependency>

        <groupId>org.springframework</groupId>

        <artifactId>spring-context-support</artifactId>

        <version>6.0.9</version>

    </dependency>

</dependencies>

2. 定义核心接口和类

2.1 状态和事件枚举

// 状态枚举

public enum OrderState {

    NEW, 

    PAYMENT_PENDING, 

    PAID, 

    SHIPPED, 

    DELIVERED, 

    CANCELLED

}



// 事件枚举

public enum OrderEvent {

    CREATE_ORDER, 

    INITIATE_PAYMENT, 

    PAYMENT_COMPLETED, 

    SHIP_ORDER, 

    DELIVERY_CONFIRMED, 

    CANCEL_ORDER

}

2.2 插件接口定义

// 状态变更监听器接口

public interface StateChangeListener {

    void onStateChange(OrderState from, OrderState to, String orderId);

}



// 订单操作插件接口

public interface OrderOperationPlugin {

    void execute(String orderId, OrderState currentState);

}



// 插件管理器接口

public interface PluginManager {

    void registerStateChangeListener(StateChangeListener listener);

    void notifyStateChange(OrderState from, OrderState to, String orderId);

    void executePlugins(String orderId, OrderState currentState);

}

3. 实现状态机配置

@Configuration

@EnableStateMachine

public class OrderStateMachineConfig extends EnumStateMachineConfigurerAdapter<OrderState, OrderEvent> {



    @Autowired

    private List<OrderOperationPlugin> plugins;



    @Override

    public void configure(StateMachineStateConfigurer<OrderState, OrderEvent> states) throws Exception {

        states

            .withStates()

            .initial(OrderState.NEW)

            .state(OrderState.PAYMENT_PENDING)

            .junction(OrderState.PAID)

            .end(OrderState.DELIVERED)

            .end(OrderState.CANCELLED)

            .fork(OrderState.SHIPPED);

    }



    @Override

    public void configure(StateMachineTransitionConfigurer<OrderState, OrderEvent> transitions) throws Exception {

        transitions

            .withExternal()

                .source(OrderState.NEW).target(OrderState.PAYMENT_PENDING)

                .event(OrderEvent.CREATE_ORDER)

                

            .and().withExternal()

                .source(OrderState.PAYMENT_PENDING).target(OrderState.PAID)

                .event(OrderEvent.INITIATE_PAYMENT)

                

            .and().withExternal()

                .source(OrderState.PAID).target(OrderState.SHIPPED)

                .event(OrderEvent.SHIP_ORDER)

                

            .and().withExternal()

                .source(OrderState.SHIPPED).target(OrderState.DELIVERED)

                .event(OrderEvent.DELIVERY_CONFIRMED)

                

            .and().withExternal()

                .source(OrderState.NEW).target(OrderState.CANCELLED)

                .event(OrderEvent.CANCEL_ORDER)

                

            .and().withExternal()

                .source(OrderState.PAYMENT_PENDING).target(OrderState.CANCELLED)

                .event(OrderEvent.CANCEL_ORDER);

    }

    

    @Bean

    public PluginManager pluginManager() {

        return new DefaultPluginManager(plugins);

    }

}

4. 插件实现

4.1 默认插件管理器

@Component

public class DefaultPluginManager implements PluginManager {

    private final List<StateChangeListener> stateChangeListeners = new ArrayList<>();

    private final List<OrderOperationPlugin> operationPlugins;



    public DefaultPluginManager(List<OrderOperationPlugin> plugins) {

        this.operationPlugins = plugins;

    }



    @Override

    public void registerStateChangeListener(StateChangeListener listener) {

        stateChangeListeners.add(listener);

    }



    @Override

    public void notifyStateChange(OrderState from, OrderState to, String orderId) {

        stateChangeListeners.forEach(listener -> listener.onStateChange(from, to, orderId));

    }



    @Override

    public void executePlugins(String orderId, OrderState currentState) {

        operationPlugins.forEach(plugin -> plugin.execute(orderId, currentState));

    }

}

4.2 示例插件实现

// 日志记录插件

@Component

public class LoggingPlugin implements OrderOperationPlugin {

    @Override

    public void execute(String orderId, OrderState currentState) {

        System.out.println("订单 " + orderId + " 当前状态: " + currentState + " - 正在记录日志");

    }

}



// 邮件通知插件

@Component

public class EmailNotificationPlugin implements OrderOperationPlugin {

    @Override

    public void execute(String orderId, OrderState currentState) {

        System.out.println("订单 " + orderId + " 当前状态: " + currentState + " - 发送邮件通知");

    }

}



// 库存管理插件

@Component

public class InventoryUpdatePlugin implements OrderOperationPlugin {

    @Override

    public void execute(String orderId, OrderState currentState) {

        if (currentState == OrderState.PAID) {

            System.out.println("订单 " + orderId + " 已支付，正在更新库存");

        }

    }

}

5. 状态监听器实现

@Component

public class AuditStateChangeListener implements StateChangeListener {

    @Override

    public void onStateChange(OrderState from, OrderState to, String orderId) {

        System.out.println("订单状态变更: " + orderId + " 从 " + from + " 到 " + to + " - 审计记录已创建");

    }

}

6. 服务层实现

@Service

public class OrderService {



    @Autowired

    private StateMachine<OrderState, OrderEvent> stateMachine;



    @Autowired

    private PluginManager pluginManager;



    public OrderService() {

        // 注册监听器

        pluginManager.registerStateChangeListener(new AuditStateChangeListener());

    }



    public void handleOrderEvent(String orderId, OrderEvent event) {

        try {

            stateMachine.start();

            OrderState currentState = stateMachine.getState().getId();

            

            // 发送事件

            stateMachine.sendEvent(event);

            

            OrderState newState = stateMachine.getState().getId();

            

            // 触发状态变更监听器

            if (currentState != newState) {

                pluginManager.notifyStateChange(currentState, newState, orderId);

            }

            

            // 执行操作插件

            pluginManager.executePlugins(orderId, newState);

            

        } catch (Exception e) {

            System.err.println("处理订单事件失败: " + e.getMessage());

        } finally {

            stateMachine.stop();

        }

    }

}

7. 控制器示例

@RestController

@RequestMapping("/orders")

public class OrderController {



    @Autowired

    private OrderService orderService;



    @PostMapping("/{orderId}/events")

    public ResponseEntity<String> sendEvent(@PathVariable String orderId, @RequestParam String event) {

        try {

            OrderEvent orderEvent = OrderEvent.valueOf(event.toUpperCase());

            orderService.handleOrderEvent(orderId, orderEvent);

            return ResponseEntity.ok("事件已处理: " + event);

        } catch (IllegalArgumentException e) {

            return ResponseEntity.badRequest().body("无效的事件类型: " + event);

        }

    }

    

    @GetMapping("/{orderId}/status")

    public ResponseEntity<String> checkStatus(@PathVariable String orderId) {

        // 这里应该从存储中获取当前状态，为简化示例返回固定值

        return ResponseEntity.ok("订单 " + orderId + " 当前状态: 示例状态");

    }

}

8. 可扩展性说明

如何添加新插件：

@Component

public class NewFeaturePlugin implements OrderOperationPlugin {

    @Override

    public void execute(String orderId, OrderState currentState) {

        // 新功能逻辑

    }

}

如何添加新状态监听器：

@Component

public class NewStateChangeListener implements StateChangeListener {

    @Override

    public void onStateChange(OrderState from, OrderState to, String orderId) {

        // 新监听器逻辑

    }

}

使用示例：

# 创建订单

POST /orders/123/events?event=CREATE_ORDER



# 发起支付

POST /orders/123/events?event=INITIATE_PAYMENT



# 发货

POST /orders/123/events?event=SHIP_ORDER



# 确认送达

POST /orders/123/events?event=DELIVERY_CONFIRMED



# 取消订单

POST /orders/123/events?event=CANCEL_ORDER

这个实现具有以下特点：

您可以根据具体业务需求扩展更多状态、事件和插件功能。

使用 LangChain 等 Python 工具，可以更轻松地实现多智能体系统，从而创建超越简单自动化的智能系统。

译自Collaborative Intelligence in Multiagent Systems With Python，作者 Oladimeji Sowole。

近年来，大型语言模型 (LLM)通过生成类似人类的文本、解决复杂问题和自主执行任务，重新定义了人工智能的能力。

然而，随着任务变得更加复杂和跨学科，单个 AI 模型可能并不总是足够。这就是多智能体系统(MAS) 在 LLM 中的概念发挥作用的地方。MAS 允许多个 AI 智能体协作，每个智能体专门负责问题的不同方面，共同努力实现共同目标。

本教程将使用Python探索 LLM 中多智能体系统的最新趋势。我们将介绍什么是多智能体系统、它们为什么重要以及如何使用 LangChain 等工具使用 Python 分步实现它们。

什么是多智能体系统？

多智能体系统 (MAS) 是一个环境，其中多个自主智能体相互交互、合作甚至竞争以解决问题。每个智能体都有自己的能力、优势和关注领域，使系统能够更有效地处理复杂的任务。这些系统在需要协作、并行任务执行甚至协商的场景中表现出色。

在 LLM 中，多智能体系统可以：

• 协作完成需要多个专业领域的任务（例如，一个智能体专注于数学，而另一个智能体处理自然语言理解）。


• 互相协商以解决目标冲突。


• 并行解决复杂的、多步骤的问题，提高速度和准确性。

多智能体系统的用例

• 财务规划: 一个智能体可以专注于分析股票趋势，而另一个智能体可以预测市场的未来行为。


• 医疗保健: 一个智能体专注于诊断分析，而另一个智能体协助患者病史回顾，共同为全面的医疗保健建议提供帮助。


• 供应链优化: 智能体可以专门从事物流、采购或需求预测，从而改善整个供应链的决策。

为什么要使用多智能体系统？

• 专业化: 不同的智能体专门负责不同的任务，使解决问题更加高效。


• 并行性: 智能体可以同时工作，显着减少完成多步骤操作所需的时间。


• 协作: 多个智能体共同努力，利用其独特的优势来实现最佳结果。


• 适应性: 智能体可以实时协商或调整策略，以适应不断变化的任务。

使用 Python 设置多智能体系统

让我们从理论转向实践。在本节中，我们将演示如何使用 Python 和 LangChain 库构建多智能体系统，该库允许不同 LLM 支持的智能体之间无缝交互。

安装依赖项

首先，我们需要安装 LangChain 并设置一个 LLM 服务，例如 OpenAI。

pip install langchain openai

您还需要一个 OpenAI API 密钥，您可以通过注册 OpenAI 的 API 服务来获取。

初始化智能体和工具

首先，我们将定义我们的 LLM（GPT 模型）以及我们的智能体将使用的一组工具。这些工具可以是任何东西，从计算器到网络搜索功能。让我们初始化协作解决涉及信息检索和数学计算的任务的智能体。

from langchain.agents import initialize_agent, load_tools

from langchain.llms import OpenAI



# Initialize OpenAI model

llm = OpenAI(api_key="your_openai_api_key", model="gpt-4")



# Load tools (agents) such as search and calculator

tools = load_tools(["serpapi", "calculator"], llm)



# Initialize a multi-agent system

multi_agent = initialize_agent(

    tools, 

    llm, 

    agent_type="multi-agent", 

    verbose=True

)



# Example task: Find the exchange rate of USD to EUR and calculate for 1500 units

task = "What is the current exchange rate of USD to EUR? Multiply it by 1500."



# Run the multi-agent system to complete the task

result = multi_agent.run(task)

print(result)

工作原理

• 智能体协作: 在此示例中，一个智能体使用搜索工具（例如 SERP API）获取实时汇率，而另一个智能体使用计算器工具将汇率乘以 1,500。


• 任务分解: LLM 将任务分解为子任务（获取汇率和执行计算），并将这些子任务分配给相应的智能体。

构建复杂的智能体系统

现在我们已经看到了一个基本示例，让我们构建一个更复杂的系统，该系统涉及多个智能体来解决问题的不同部分。考虑一个场景，我们正在构建一个旅行助手，它可以处理与预订航班、查看天气和执行预算计算相关的多个查询。

分步代码：旅行助手多智能体系统

# Define task-specific tools

from langchain.tools import Tool



# Weather checking tool

def get_weather(city):

    return f"The weather in {city} is sunny with a temperature of 25°C."



# Flight booking tool

def book_flight(destination, date):

    return f"Flight to {destination} on {date} has been booked."



# Budget calculation tool

def calculate_budget(amount, expenses):

    remaining = amount - sum(expenses)

    return f"Your remaining budget is {remaining}."



# Define our agents

weather_tool = Tool("get_weather", get_weather)

flight_tool = Tool("book_flight", book_flight)

budget_tool = Tool("calculate_budget", calculate_budget)



# Combine agents int0 a multi-agent system

tools = [weather_tool, flight_tool, budget_tool]

multi_agent = initialize_agent(tools, llm, agent_type="multi-agent", verbose=True)



# Example task

task = """

I want to book a flight to Paris for December 20th, check the weather in Paris, 

and calculate my remaining budget if I have $2000 and my expenses are $500 and $300.

"""



# Execute the multi-agent system

result = multi_agent.run(task)

print(result)

发生了什么？

• 航班智能体:book_flight智能体处理任务的航班预订部分。


• 天气智能体:get_weather智能体检索巴黎的天气数据。


• 预算智能体:calculate_budget智能体根据用户的输入计算用户的剩余预算。

在这种情况下，每个代理都负责解决更大问题中的特定部分，并协同工作以提供全面的结果。整个过程由 LLM 驱动，LLM 协调代理的工作。

多代理系统的先进用例

医疗保健协作

在医疗保健领域，不同的代理可以专注于患者治疗过程的不同部分。例如：

• 一个代理可以分析医学影像。


• 另一个代理审查患者的病史。


• 第三个代理提供诊断建议。

通过协同工作，这些代理可以生成一份综合报告，帮助做出更准确、更快速的医疗决策。

供应链优化

多代理系统可用于管理供应链的不同方面：

• 物流代理跟踪运输时间。


• 采购代理监控库存水平。


• 预测代理预测未来需求。

它们共同可以优化供应链，减少延误，降低成本，提高整体效率。

结论

多代理系统 (MAS) 代表了人工智能驱动解决方案发展中的一个突破性趋势。通过允许多个代理协同工作，每个代理都有自己的专业领域，MAS 极大地提高了大规模问题解决任务的效率和有效性。借助 LangChain 等 Python 工具，实现多代理系统变得越来越容易，使开发人员能够创建超越简单自动化的智能系统。

您是否想探索与 AI 代理和 Python 合作的可能性？阅读 Andela 的博客，了解如何在 Python 中使用 LangGraph 开发主 AI 代理！

本文在云云众生（yylives.cc/）首发，欢迎大家访问。

传统方案的痛点：代码入侵

在上一篇文章中，我们通过高阶函数实现了请求缓存功能：

const cachedFetch = memoReq(function fetchData(url) {

  return axios.get(url);

}, 3000);

这种方式虽然有效，但存在三个显著问题：

灵感来源：两大技术启示

1. Webpack的魔法注释

Webpack使用魔法注释控制代码分割：

import(/* webpackPrefetch: true */ './module.js');

这种声明式配置给了我们启示：能否用注释来控制缓存行为？

2. 装饰器设计模式

装饰器模式的核心思想是不改变原有对象的情况下动态扩展功能。在TypeScript中：

@memoCache(3000)

async function fetchData() {}

虽然当前项目可能不支持装饰器语法，但我们可以借鉴这种思想！

创新方案：魔法注释 + Vite插件

设计目标

使用对比

传统方式：

export const getStockData = memoReq(

  function getStockData(symbol) {

    return axios.get(`/api/stocks/${symbol}`);

  },

  5000

);

魔法注释方案：

/* abc-memoCache(5000) */

export function getStockData(symbol) {

  return axios.get(`/api/stocks/${symbol}`);

}

而有经验的程序猿会敏锐地发现三个深层问题：

技术实现深度解析

核心转换原理

// 转换前

/* abc-memoCache(3000) */

export function fetchData() {}



// 转换后

import { memoCache } from '@/utils/decorators';

export const fetchData = memoCache(function fetchData() {}, 3000);

完整实现代码如下（以vite插件为例）

/**

 * 转换代码中的装饰器注释为具体的函数调用，并处理超时配置。

 *

 * @param {string} code - 待处理的源代码。

 * @param {string} [prefix="aa"] - 装饰器的前缀，用于标识特定的装饰器注释。

 * @param {string} [utilsPath="@/utils"] - 导入工具函数的路径。

 * @returns {string} - 转换后的代码。

 */

export function transformMemoReq(code, prefix = "aa", utilsPath = "@/utils") {

  // 检查是否包含魔法注释模式

  const magicCommentPattern = new RegExp(`\/\*\s*${prefix}-\w+\s*\([^)]*\)\s*\*\/`);

  if (!magicCommentPattern.test(code)) {

    return code; // 如果没有找到符合模式的注释，返回原代码

  }



  let transformedCode = code;

  const importsNeeded = new Set(); // 收集需要的导入



  // 处理带超时配置的装饰器注释（带超时数字）

  const withTimeoutPattern = new RegExp(

    `\/\*\s*${prefix}-(\w+)\s*\(\s*(\d*)\s*\)\s*\*\/\s*\nexport\s+function\s+(\w+)\s*\(([^)]*)\)\s*(?::\s*[^{]+)?\s*\{([\s\S]*?)\n\}`,

    "g"

  );



  transformedCode = transformedCode.replace(

    withTimeoutPattern,

    (match, decoratorName, timeout, functionName, params, body) => {

      const timeoutValue = timeout ? parseInt(timeout, 10) : 3000; // 默认超时为3000毫秒

      const fileNameSimple = decoratorName.replace(/([A-Z].*$)/, ""); // 获取装饰器文件名



      importsNeeded.add({ fileName: fileNameSimple, functionName: decoratorName }); // 添加需要导入的函数



      // 提取类型注解（如果存在）

      const typeAnnotationMatch = match.match(/)\s*(:\s*[^{]+)/);

      const typeAnnotation = typeAnnotationMatch ? typeAnnotationMatch[1] : "";



      // 返回转换后的函数定义代码

      return `export const ${functionName} = ${decoratorName}(function ${functionName}(${params})${typeAnnotation} {${body}\n}, ${timeoutValue});`;

    }

  );



  // 处理不带超时配置的装饰器注释（无超时数字）

  const emptyTimeoutPattern = new RegExp(

    `\/\*\s*${prefix}-(\w+)\s*\(\s*\)\s*\*\/\s*\nexport\s+function\s+(\w+)\s*\(([^)]*)\)\s*(?::\s*[^{]+)?\s*\{([\s\S]*?)\n\}`,

    "g"

  );



  transformedCode = transformedCode.replace(emptyTimeoutPattern, (match, decoratorName, functionName, params, body) => {

    const fileNameSimple = decoratorName.replace(/([A-Z].*$)/, "");



    importsNeeded.add({ fileName: fileNameSimple, functionName: decoratorName });



    // 提取类型注解（如果存在）

    const typeAnnotationMatch = match.match(/)\s*(:\s*[^{]+)/);

    const typeAnnotation = typeAnnotationMatch ? typeAnnotationMatch[1] : "";



    // 返回转换后的函数定义代码，默认超时为3000毫秒

    return `export const ${functionName} = ${decoratorName}(function ${functionName}(${params})${typeAnnotation} {${body}\n}, 3000);`;

  });



  // 如果需要导入额外的函数，处理导入语句的插入

  if (importsNeeded.size > 0) {

    const lines = transformedCode.split("\n");

    let insertIndex = 0;



    // 检查是否是Vue文件

    const isVueFile = transformedCode.includes("<script");



    if (isVueFile) {

      // Vue文件导入位置逻辑...

      for (let i = 0; i < lines.length; i += 1) {

        const line = lines[i].trim();

        if (line.includes("<script")) {

          insertIndex = i + 1;

          for (let j = i + 1; j < lines.length; j += 1) {

            const scriptLine = lines[j].trim();

            if (scriptLine.startsWith("import ") || scriptLine === "") {

              insertIndex = j + 1;

            } else if (!scriptLine.startsWith("import ")) {

              break;

            }

          }

          break;

        }

      }

    } else {

      // 普通JS/TS/JSX/TSX文件导入位置逻辑...

      for (let i = 0; i < lines.length; i += 1) {

        const line = lines[i].trim();

        if (line.startsWith("import ") || line === "" || line.startsWith("interface ") || line.startsWith("type ")) {

          insertIndex = i + 1;

        } else {

          break;

        }

      }

    }



    // 按文件分组导入

    const importsByFile = {};

    importsNeeded.forEach(({ fileName, functionName }) => {

      if (!importsByFile[fileName]) {

        importsByFile[fileName] = [];

      }

      importsByFile[fileName].push(functionName);

    });



    // 生成导入语句 - 使用自定义utilsPath

    const importStatements = Object.entries(importsByFile).map(([fileName, functions]) => {

      const uniqueFunctions = [...new Set(functions)];

      return `import { ${uniqueFunctions.join(", ")} } from "${utilsPath}/${fileName}";`;

    });



    // 插入导入语句

    lines.splice(insertIndex, 0, ...importStatements);

    transformedCode = lines.join("\n");

  }



  return transformedCode; // 返回最终转换后的代码

}



/**

 * Vite 插件，支持通过魔法注释转换函数装饰器。

 *

 * @param {Object} [options={}] - 配置选项。

 * @param {string} [options.prefix="aa"] - 装饰器的前缀。

 * @param {string} [options.utilsPath="@/utils"] - 工具函数的导入路径。

 * @returns {Object} - Vite 插件对象。

 */

export function viteMemoDectoratorPlugin(options = {}) {

  const { prefix = "aa", utilsPath = "@/utils" } = options;



  return {

    name: "vite-memo-decorator", // 插件名称

    enforce: "pre", // 插件执行时机，设置为"pre"确保在编译前执行

    transform(code, id) {

      // 支持 .js, .ts, .jsx, .tsx, .vue 文件

      if (!/.(js|ts|jsx|tsx|vue)$/.test(id)) {

        return null; // 如果文件类型不支持，返回null

      }



      // 使用动态前缀检查是否需要处理该文件

      const magicCommentPattern = new RegExp(`\/\*\s*${prefix}-\w+\s*\([^)]*\)\s*\*\/`);

      if (!magicCommentPattern.test(code)) {

        return null; // 如果没有找到符合模式的注释，返回null

      }



      console.log(`🔄 Processing ${prefix}-* magic comments in: ${id}`);



      try {

        const result = transformMemoReq(code, prefix, utilsPath); // 调用转换函数



        if (result !== code) {

          console.log(`✅ Transform successful for: ${id}`);

          return {

            code: result, // 返回转换后的代码

            map: null, // 如果需要支持source map，可以在这里添加

          };

        }

      } catch (error) {

        console.error(`❌ Transform error in ${id}:`, error.message);

      }



      return null;

    },

  };

}

vite使用方式

viteMemoDectoratorPlugin({

  prefix: "abc",

}),

结语：成为解决方案的设计者

从闭包到魔法注释的演进：

在这个技术飞速发展的时代，我们牛马面临着知识爆炸，卷到没边的风气，我们只能建立更系统的技术认知体系。只会复制粘贴代码的开发者注定会陷入越忙越累的怪圈，比如最近很火的vue不想使用虚拟dom，其实我们只需要知道为什么，那是不是又多了点知识储备，因为技术迭代的速度永远快于机械记忆的速度。真正的技术能力体现在对知识本质的理解和创造性应用上——就像本文中的缓存方案，从最初的闭包实现到魔法注释优化，每一步实现都源于对多种技术思想的相融。阅读技术博客时，不能满足于解决眼前问题，更要揣摩作者的设计哲学；我们要善用AI等现代工具，但不是简单地向它索要代码，而是通过它拓展思维边界；愿我们都能超越代码搬运工的局限，成为真正的问题解决者和价值创造者。技术之路没有捷径，但有方法；没有终点，但有无尽的风景。加油吧，程序猿朋友们！！！

前言

在只有使用docker安装的容器，没有使用docker-compose或者其他客户端工具，如果要增加或者修改容器端口，也是可以增加或者修改容器端口映射=

容器端口映射

重新安装

这种方法简单粗暴，就是重新把docker容器移除，然后重新用

docker run -p 

重新做端口映射

修改配置文件

这里以rabbitmq为例子
1、 首先使用

  docker ps

查看容器id

2、 然后使用

docker inspace 容器id

查看容器配置文件放止于哪里

这里放置于/var/lib/docker/containers/29384a9aa22f4fb53eda66d672b039b997143dc7633694e3455fc12f7dbcac5d
然后使用Linux进入到该目录

3、先把docker容器停止了

 systemctl stop docker.socket

4、 修改hostconfig文件，找到里面的json数据中的PortBindings

这里将5672端口修改为5673

保存文件

5、 修改config.v2.json文件中的内容，找到里面中的ExposedPorts，把5673端口开放出来

保存文件

6、 启动docker服务

systemctl start docker.socket

这个时候就会发现5673端口映射了

总结

修改docker容器映射开放端口方法很多，现在也有很多优秀的客户端可以进行配置

上回说到，在《新三国》中荀彧对曹操说的那句名言，但相比荀彧而言，我觉得曹操的名言会更多，我一想，若能用AI重现这位乱世奸雄曹操，会得到怎样的体验？

于是这篇文章我们将以Go语言为例，展示如何通过LangChain框架调用DeepSeek大模型，重现一代枭雄曹操的独特对话风格。

工具介绍

LangChain 是一个专为构建大语言模型应用设计的开发框架，其核心使命是打通语言模型与真实世界的连接通道。它通过模块化设计将数据处理、记忆管理、工具调用等能力封装为标准化组件，开发者可像搭积木般将这些模块组装成智能应用链。经过一段时间的发展，LangChain不仅支持Python生态快速实现原型验证，也提供Go语言实现满足高并发生产需求。

在Go项目中安装：

go get -u github.com/tmc/langchaingo

使用LangChain接入DeepSeek

现在我们写一个最简单的LangChain程序，主要分为以下几个步骤：

1）函数定义和初始化OpenAI客户端

2）创建聊天消息

3）生成内容并流式输出

4）输出推理过程和最终答案

下面是代码：

func Simple() {

    // 函数定义和初始化OpenAI客户端

    llm, err := openai.New(

        openai.WithBaseURL("https://api.deepseek.com"),

        openai.WithModel("deepseek-chat"),

        openai.WithToken("xxx"), // 填写自己的API Key

    )

    if err != nil {

        log.Fatal(err)

    }

    

    // 创建聊天消息

    content := []llms.MessageContent{

        llms.TextParts(llms.ChatMessageTypeSystem, "你现在模仿曹操，以曹操的口吻和风格回答问题，要展现出曹操的霸气与谋略"),

        llms.TextParts(llms.ChatMessageTypeHuman, "赤壁之战打输了怎么办？"),

    }



    // 生成内容并流式输出

    fmt.Print("曹孟德：")

    completion, err := llm.GenerateContent(

        context.Background(),

        content,

        llms.WithMaxTokens(2000),

        llms.WithTemperature(0.7),

        llms.WithStreamingReasoningFunc(func(ctx context.Context, reasoningChunk []byte, chunk []byte) error {

            contentColor := color.New(color.FgCyan).Add(color.Bold)

            if len(chunk) > 0 {

                _, err := contentColor.Printf("%s", string(chunk))

                if err != nil {

                    return err

                }

            }

            return nil

        }),

    )

    if err != nil {

        log.Fatal(err)

    }



    // 输出推理过程和最终答案

    if len(completion.Choices) > 0 {

        choice := completion.Choices[0]

        fmt.Printf("\nFinal Answer:\n%s\n", choice.Content)

    }

}

当然，如果我们想通过控制台和大模型多轮对话的话可以基于现有程序进行改造：

func Input() {

    llm, err := openai.New(

        openai.WithBaseURL("https://api.deepseek.com"),

        openai.WithModel("deepseek-chat"),

        openai.WithToken("xxx"),

    )

    if err != nil {

        log.Fatal(err)

    }



    // 初始系统消息

    systemMessage := llms.TextParts(llms.ChatMessageTypeSystem, "你现在模仿曹操，以曹操的口吻和风格回答问题，要展现出曹操的霸气与谋略。")

    content := []llms.MessageContent{systemMessage}



    scanner := bufio.NewScanner(os.Stdin)

    for {

        fmt.Print("闫同学：")

        scanner.Scan()

        question := scanner.Text()



        if question == "exit" {

            break

        }



        // 添加新的用户问题

        userMessage := llms.TextParts(llms.ChatMessageTypeHuman, question)

        content = append(content, userMessage)



        fmt.Print("曹孟德：")

        // Generate content with streaming to see both reasoning and final answer in real-time

        completion, err := llm.GenerateContent(

            context.Background(),

            content,

            llms.WithMaxTokens(2000),

            llms.WithTemperature(0.7),

            llms.WithStreamingReasoningFunc(func(ctx context.Context, reasoningChunk []byte, chunk []byte) error {

                contentColor := color.New(color.FgCyan).Add(color.Bold)

                if len(chunk) > 0 {

                    _, err := contentColor.Printf("%s", string(chunk))

                    if err != nil {

                        return err

                    }

                }

                return nil

            }),

        )

        if err != nil {

            log.Fatal(err)

        }

        fmt.Println()

        // 将回复添加到历史消息中

        if len(completion.Choices) > 0 {

            choice := completion.Choices[0]

            assistantMessage := llms.TextParts(llms.ChatMessageTypeHuman, choice.Content)

            content = append(content, assistantMessage)

        }

    }

}

现在我们来启动调试一下：

重点步骤说明

其实纵观上面的整段代码，我认为在打造自己Agent中，最重要的一步莫过于在与AI对话前的消息组合部分，我们到底该怎样与AI对话才能得到自己想要的结果。

首先是content代码段的作用

content := []llms.MessageContent{

    llms.TextParts(llms.ChatMessageTypeSystem, "你现在模仿曹操，以曹操的口吻和风格回答问题，要展现出曹操的霸气与谋略"),

    llms.TextParts(llms.ChatMessageTypeHuman, "赤壁之战打输了怎么办？"),

}

content 是一个 []llms.MessageContent 类型的切片，用于存储一系列的聊天消息内容。

llms.TextParts是 langchaingo 库中用于创建文本消息内容的函数。它接受两个参数：消息类型和消息内容。

llms.ChatMessageTypeSystem表示系统消息类型。系统消息通常用于给 AI 提供一些额外的指令或上下文信息。在这个例子中，系统消息告知 AI 要模仿曹操的口吻和风格进行回答。

llms.ChatMessageTypeHuman表示人类用户发送的消息类型。这里的消息内容是用户提出的问题“赤壁之战打输了怎么办？”。

ChatMessageType有哪些常量？我们来看下源码：

// ChatMessageTypeAI is a message sent by an AI.

ChatMessageTypeAI ChatMessageType = "ai"

// ChatMessageTypeHuman is a message sent by a human.

ChatMessageTypeHuman ChatMessageType = "human"

// ChatMessageTypeSystem is a message sent by the system.

ChatMessageTypeSystem ChatMessageType = "system"

// ChatMessageTypeGeneric is a message sent by a generic user.

ChatMessageTypeGeneric ChatMessageType = "generic"

// ChatMessageTypeFunction is a message sent by a function.

ChatMessageTypeFunction ChatMessageType = "function"

// ChatMessageTypeTool is a message sent by a tool.

ChatMessageTypeTool ChatMessageType = "tool"

解释下这些常量分别代表什么：

1）ChatMessageTypeAI：表示由 AI 生成并发送的消息。当 AI 对用户的问题进行回答时，生成的回复消息就属于这种类型。

2）ChatMessageTypeHuman：代表人类用户发送的消息。例如，用户在聊天界面输入的问题、评论等都属于人类消息。

3）ChatMessageTypeSystem：是系统发送的消息，用于设置 AI 的行为、提供指令或者上下文信息。系统消息可以帮助 AI 更好地理解任务和要求。

4）ChatMessageTypeGeneric：表示由通用用户发送的消息。这里的“通用用户”可以是除了明确的人类用户和 AI 之外的其他类型的用户。

5）ChatMessageTypeFunction：表示由函数调用产生的消息。在一些复杂的聊天系统中，AI 可能会调用外部函数来完成某些任务，函数执行的结果会以这种类型的消息返回。

6）ChatMessageTypeTool：表示由工具调用产生的消息。类似于函数调用，工具调用可以帮助 AI 完成更复杂的任务，工具执行的结果会以这种类型的消息呈现。

这些常量的定义有助于在代码中清晰地区分不同类型的聊天消息，方便对消息进行处理和管理。

接入DeepSeek-R1支持深度思考

本篇文章关于DeepSeek的相关文档主要参考deepseek官方文档，这篇文档里我们可以看到DeepSeek的V3模型和R1模型是两个不同的模型标识，即：

model='deepseek-chat' 即可调用 DeepSeek-V3。

model='deepseek-reasoner'，即可调用 DeepSeek-R1。

因此在调用R1模型时我们需要改变初始化client的策略，然后在处理回答的时候也需要额外处理思考部分的回答，具体改动的地方如下：

1）初始化使用deepseek-reasoner：

llm, err := openai.New(

    openai.WithBaseURL("https://api.deepseek.com"),

    openai.WithModel("deepseek-reasoner"),

    openai.WithToken("xxx"),

 )

2）函数处理思考部分

completion, err := llm.GenerateContent(

    ctx,

    content,

    llms.WithMaxTokens(2000),

    llms.WithTemperature(0.7),

    llms.WithStreamingReasoningFunc(func(ctx context.Context, reasoningChunk []byte, chunk []byte) error {

        contentColor := color.New(color.FgCyan).Add(color.Bold)

        reasoningColor := color.New(color.FgYellow).Add(color.Bold)



        if !isPrint {

            isPrint = true

            fmt.Print("[思考中]")

        }



        // 思考部分

        if len(reasoningChunk) > 0 {

            _, err := reasoningColor.Printf("%s", string(reasoningChunk))

            if err != nil {

                return err

            }

        }

        

        // 回答部分

        if len(chunk) > 0 {

            _, err := contentColor.Printf("%s", string(chunk))

            if err != nil {

                return err

            }

        }

        return nil

    }),

)

基于上面这些改动我们就能使用R1模型进行接入了。

小总结

这篇文章可以说展示了LangChain对接大模型的最基本功能，也是搭建我们自己Agent的第一步，如果真的想要搭建一个完整的AI Agent，那么还需要有很多地方进行补充和优化，比如：

• 上下文记忆：添加会话历史管理


• 风格校验：构建古汉语词库验证


• 多模态扩展：结合人物画像生成

本篇文章到这里就结束啦~

引言

在现代前端开发的浪潮中，CSS 的编写方式正在经历一场深刻的变革。传统的 CSS 开发模式虽然功能强大，但往往伴随着样式冲突、维护困难、代码冗余等问题。开发者需要花费大量时间在样式的命名、组织和维护上，而真正用于业务逻辑实现的时间却相对有限。

TailwindCSS 的出现，如同一股清流，为前端开发者带来了全新的开发体验。它不仅仅是一个 CSS 框架，更是一种全新的设计哲学——原子化 CSS 的完美实践。与此同时，在处理文本显示的细节问题上，诸如 -webkit-line-clamp 这样的 CSS 属性，虽然看似简单，却蕴含着深层的浏览器渲染原理。

本文将深入探讨 TailwindCSS 的核心理念、配置方法以及实际应用，同时详细解析 -webkit-line-clamp 的底层工作机制，帮助开发者更好地理解和运用这些现代前端技术。无论你是刚接触前端开发的新手，还是希望提升开发效率的资深开发者，这篇文章都将为你提供有价值的见解和实用的技巧。

TailwindCSS：原子化 CSS 的艺术

什么是原子化 CSS

原子化 CSS（Atomic CSS）是一种 CSS 架构方法，其核心思想是将样式拆分成最小的、不可再分的单元——就像化学中的原子一样。每个 CSS 类只负责一个特定的样式属性，比如 text-center 只负责文本居中，bg-blue-500 只负责设置蓝色背景。

传统的 CSS 开发模式往往采用组件化的方式，为每个 UI 组件编写独立的样式类。例如，一个按钮组件可能会有这样的 CSS：

.button {

  padding: 12px 24px;

  background-color: #3b82f6;

  color: white;

  border-radius: 6px;

  font-weight: 600;

  transition: background-color 0.2s;

}



.button:hover {

  background-color: #2563eb;

}

这种方式在小型项目中运行良好，但随着项目规模的增长，会出现以下问题：

原子化 CSS 通过将样式拆分成最小单元来解决这些问题。上面的按钮样式在 TailwindCSS 中可以这样表示：

<button class="px-6 py-3 bg-blue-500 text-white rounded-md font-semibold hover:bg-blue-600 transition-colors">

  Click me

</button>

每个类名都有明确的职责：

• px-6：左右内边距 1.5rem（24px）


• py-3：上下内边距 0.75rem（12px）


• bg-blue-500：蓝色背景


• text-white：白色文字


• rounded-md：中等圆角


• font-semibold：半粗体字重


• hover:bg-blue-600：悬停时的深蓝色背景


• transition-colors：颜色过渡动画

TailwindCSS 的核心特性

TailwindCSS 作为原子化 CSS 的杰出代表，具有以下核心特性：

1. 几乎不用写 CSS

这是 TailwindCSS 最吸引人的特性之一。在传统开发中，开发者需要在 HTML 和 CSS 文件之间频繁切换，思考类名、编写样式、处理选择器优先级等问题。而使用 TailwindCSS，大部分样式都可以直接在 HTML 中通过预定义的类名来实现。

这种方式带来的好处是显而易见的：

• 开发速度提升：无需在文件间切换，样式即写即见


• 认知负担减轻：不需要思考复杂的类名和样式组织


• 一致性保证：使用统一的设计系统，避免样式不一致

2. AI 代码生成的首选框架

在人工智能辅助编程的时代，TailwindCSS 已经成为 AI 工具生成前端代码时的首选 CSS 框架。这主要有以下几个原因：

• 语义化程度高：TailwindCSS 的类名具有很强的语义性，AI 可以更容易理解和生成


• 标准化程度高：作为业界标准，AI 模型在训练时接触了大量 TailwindCSS 代码


• 组合性强：原子化的特性使得 AI 可以灵活组合不同的样式类

当你使用 ChatGPT、Claude 或其他 AI 工具生成前端代码时，它们几乎总是会使用 TailwindCSS 来处理样式，这已经成为了一种行业默认标准。

3. 丰富的内置类名系统

TailwindCSS 提供了一套完整而系统的类名体系，涵盖了前端开发中几乎所有的样式需求：

• 布局类：flex、grid、block、inline 等


• 间距类：m-4、p-2、space-x-4 等


• 颜色类：text-red-500、bg-blue-200、border-gray-300 等


• 字体类：text-lg、font-bold、leading-tight 等


• 响应式类：md:text-xl、lg:flex、xl:grid-cols-4 等


• 状态类：hover:bg-gray-100、focus:ring-2、active:scale-95 等

这些类名都遵循一致的命名规范，学会了基本规则后，即使遇到没用过的类名也能快速理解其含义。

配置与使用

安装和配置流程

要在项目中使用 TailwindCSS，需要经过以下几个步骤：

1. 安装依赖包

npm install -D tailwindcss @vitejs/plugin-tailwindcss

这里安装了两个包：

• tailwindcss：TailwindCSS 的核心包


• @vitejs/plugin-tailwindcss：Vite 的 TailwindCSS 插件，用于在构建过程中处理 TailwindCSS

2. 生成配置文件

npx tailwindcss init

这个命令会在项目根目录生成一个 tailwind.config.js 文件：

/** @type {import('tailwindcss').Config} */

export default {

  content: [

    "./index.html",

    "./src/**/*.{js,ts,jsx,tsx}",

  ],

  theme: {

    extend: {},

  },

  plugins: [],

}

content 数组指定了 TailwindCSS 应该扫描哪些文件来查找使用的类名，这对于生产环境的样式优化非常重要。

vite.config.js 配置详解

在 Vite 项目中，需要在 vite.config.js 中配置 TailwindCSS 插件：

import { defineConfig } from 'vite'

import react from '@vitejs/plugin-react'

import tailwindcss from '@vitejs/plugin-tailwindcss'



export default defineConfig({

  plugins: [

    react(),

    tailwindcss()

  ],

})

这个配置告诉 Vite 在构建过程中使用 TailwindCSS 插件来处理 CSS 文件。插件会自动：

• 扫描指定的文件查找使用的 TailwindCSS 类名


• 生成对应的 CSS 代码


• 在生产环境中移除未使用的样式（Tree Shaking）

tailwind.css 引入方式

在项目的主 CSS 文件（通常是 src/index.css 或 src/main.css）中引入 TailwindCSS 的基础样式：

@tailwind base;

@tailwind components;

@tailwind utilities;

这三个指令分别引入了：

• base：重置样式和基础样式


• components：组件样式（可以自定义）


• utilities：工具类样式（TailwindCSS 的核心）

单位系统解析

TailwindCSS 使用了一套独特而直观的单位系统。其中最重要的概念是：1rem = 4 个单位。

这意味着：

• w-4 = width: 1rem = 16px（在默认字体大小下）


• p-2 = padding: 0.5rem = 8px


• m-8 = margin: 2rem = 32px

这套系统的设计非常巧妙：

• 易于记忆：4 的倍数关系简单直观


• 设计友好：符合设计师常用的 8px 网格系统


• 响应式友好：基于 rem 单位，能够很好地适应不同的屏幕尺寸

常用的间距对照表：

这套系统不仅适用于内外边距，也适用于宽度、高度、字体大小等其他尺寸相关的属性。

-webkit-line-clamp：文本截断的底层原理

浏览器内核基础知识

在深入了解 -webkit-line-clamp 之前，我们需要先理解浏览器内核的基本概念。浏览器内核（Browser Engine）是浏览器的核心组件，负责解析 HTML、CSS，并将网页内容渲染到屏幕上。不同的浏览器使用不同的内核，这也是为什么某些 CSS 属性需要添加特定前缀的原因。

主要浏览器内核及其前缀：

由于 WebKit 内核的广泛使用，许多实验性的 CSS 属性首先在 WebKit 中实现，并使用 -webkit- 前缀。-webkit-line-clamp 就是其中的一个典型例子。

实验性属性的概念

CSS 中的实验性属性（Experimental Properties）是指那些尚未成为正式 W3C 标准，但已经在某些浏览器中实现的功能。这些属性通常具有以下特征：

-webkit-line-clamp 正是这样一个实验性属性。它最初是为了解决移动端 WebKit 浏览器中多行文本截断的需求而设计的，虽然不是 CSS 标准的一部分，但由于其实用性，被广泛采用并逐渐得到其他浏览器的支持。

-webkit-line-clamp 深度解析

属性的工作原理

-webkit-line-clamp 是一个用于限制文本显示行数的 CSS 属性。当文本内容超过指定行数时，多余的内容会被隐藏，并在最后一行的末尾显示省略号（...）。

这个属性的工作原理涉及到浏览器的文本渲染机制：

为什么不能独自生效

这是 -webkit-line-clamp 最容易让开发者困惑的地方。单独使用这个属性是无效的，必须配合其他 CSS 属性才能正常工作。这是因为 -webkit-line-clamp 的设计初衷是作为 Flexbox 布局的一部分来工作的。

具体来说，-webkit-line-clamp 只在以下条件同时满足时才会生效：

这种设计反映了早期 WebKit 对 Flexbox 规范的实现方式。在当时，-webkit-box 是 Flexbox 的早期实现，而 -webkit-line-clamp 被设计为在这种布局模式下工作。

必需的配套属性详解

让我们详细分析每个必需的配套属性：

1. display: -webkit-box

display: -webkit-box;

这个属性将元素设置为 WebKit 的旧版 Flexbox 容器。在现代 CSS 中，我们通常使用 display: flex，但 -webkit-line-clamp 需要这个特定的值才能工作。

-webkit-box 是 2009 年 Flexbox 规范的实现，虽然已经过时，但为了兼容 -webkit-line-clamp，我们仍然需要使用它。这个值会：

• 将元素转换为块级容器


• 启用 WebKit 的 Flexbox 布局引擎


• 为 -webkit-line-clamp 提供必要的布局上下文

2. -webkit-box-orient: vertical

-webkit-box-orient: vertical;

这个属性设置 Flexbox 容器的主轴方向为垂直。在文本截断的场景中，我们需要垂直方向的布局来正确计算行数。

可选值包括：

• horizontal：水平排列（默认值）


• vertical：垂直排列


• inline-axis：沿着内联轴排列


• block-axis：沿着块轴排列

对于文本截断，我们必须使用 vertical，因为：

• 文本行是垂直堆叠的


• -webkit-line-clamp 需要在垂直方向上计算行数


• 只有在垂直布局下，行数限制才有意义

3. overflow: hidden

overflow: hidden;

这个属性隐藏超出容器边界的内容。在文本截断的场景中，它的作用是：

• 隐藏超出指定行数的文本内容


• 确保省略号正确显示在可见区域内


• 防止内容溢出影响页面布局

如果不设置 overflow: hidden，超出行数限制的文本仍然会显示，-webkit-line-clamp 就失去了意义。

完整的文本截断方案

将所有必需的属性组合起来，一个完整的文本截断方案如下：

.text-clamp {

  display: -webkit-box;

  -webkit-box-orient: vertical;

  -webkit-line-clamp: 2;

  overflow: hidden;

}

这个方案会将文本限制在 2 行内，超出的内容会被隐藏并显示省略号。

浏览器兼容性分析

虽然 -webkit-line-clamp 带有 WebKit 前缀，但实际上它的兼容性比想象中要好：

现代浏览器（除了 IE）都已经支持这个属性，使得它在实际项目中具有很高的可用性。

高级用法和注意事项

1. 响应式行数控制

可以结合媒体查询实现响应式的行数控制：

.responsive-clamp {

  display: -webkit-box;

  -webkit-box-orient: vertical;

  overflow: hidden;

  -webkit-line-clamp: 3;

}



@media (max-width: 768px) {

  .responsive-clamp {

    -webkit-line-clamp: 2;

  }

}

2. 与其他 CSS 属性的交互

-webkit-line-clamp 与某些 CSS 属性可能产生冲突：

• white-space: nowrap：会阻止文本换行，使 line-clamp 失效


• height 固定值：可能与 line-clamp 的高度计算冲突


• line-height：会影响行数的计算，需要谨慎设置

3. 性能考虑

使用 -webkit-line-clamp 时需要注意性能影响：

• 浏览器需要重新计算文本布局


• 在大量元素上使用可能影响渲染性能


• 动态改变 line-clamp 值会触发重排（reflow）

实战应用与代码示例

line-clamp 在 TailwindCSS 中的应用

TailwindCSS 内置了对 -webkit-line-clamp 的支持，提供了 line-clamp-{n} 工具类。让我们看看如何在实际项目中使用这些类。

基础使用示例

// 产品卡片组件

function ProductCard({ product }) {

  return (

    <div className="card max-w-sm">

      {/* 产品图片 */}

      <div className="relative">

        <img

          src={product.image}

          alt={product.name}

          className="w-full h-64 object-cover"

        />

        {product.isNew && (

          <span className="absolute top-2 left-2 bg-red-500 text-white text-xs font-bold px-2 py-1 rounded">

            New

          </span>

        )}

      </div>

      

      {/* 产品信息 */}

      <div className="p-6">

        {/* 产品标题 - 限制1行 */}

        <h3 className="text-lg font-semibold text-gray-900 line-clamp-1 mb-2">

          {product.name}

        </h3>

        

        {/* 产品描述 - 限制2行 */}

        <p className="text-sm text-gray-600 line-clamp-2 mb-4">

          {product.description}

        </p>

        

        {/* 产品特性 - 限制3行 */}

        <div className="text-xs text-gray-500 line-clamp-3 mb-4">

          {product.features.join(' • ')}

        </div>

        

        {/* 价格和操作 */}

        <div className="flex items-center justify-between">

          <span className="text-xl font-bold text-gray-900">

            ${product.price}

          </span>

          <button className="btn-primary">

            Add to Cart

          </button>

        </div>

      </div>

    </div>

  );

}

在这个示例中，我们使用了不同的 line-clamp 值来处理不同类型的文本内容：

• line-clamp-1：产品标题保持在一行内


• line-clamp-2：产品描述限制在两行内


• line-clamp-3：产品特性列表限制在三行内

响应式文本截断

TailwindCSS 的响应式前缀可以与 line-clamp 结合使用，实现不同屏幕尺寸下的不同截断行为：

function ArticleCard({ article }) {

  return (

    <article className="card">

      <div className="p-6">

        {/* 响应式标题截断 */}

        <h2 className="text-xl font-bold text-gray-900 line-clamp-2 md:line-clamp-1 mb-3">

          {article.title}

        </h2>

        

        {/* 响应式内容截断 */}

        <p className="text-gray-600 line-clamp-3 sm:line-clamp-4 lg:line-clamp-2 mb-4">

          {article.content}

        </p>

        

        {/* 标签列表 - 移动端截断更多 */}

        <div className="text-sm text-gray-500 line-clamp-2 md:line-clamp-1">

          {article.tags.map(tag => `#${tag}`).join(' ')}

        </div>

      </div>

    </article>

  );

}

这个示例展示了如何根据屏幕尺寸调整文本截断行为：

• 移动端：标题显示2行，内容显示3行


• 平板端：标题显示1行，内容显示4行


• 桌面端：标题显示1行，内容显示2行

动态 line-clamp 控制

有时我们需要根据用户交互动态改变文本的截断行为：

import { useState } from 'react';



function ExpandableText({ text, maxLines = 3 }) {

  const [isExpanded, setIsExpanded] = useState(false);

  

  return (

    <div className="space-y-2">

      <p className={`text-gray-700 ${isExpanded ? '' : `line-clamp-${maxLines}`}`}>

        {text}

      </p>

      

      <button

        onClick={() => setIsExpanded(!isExpanded)}

        className="text-primary-600 hover:text-primary-700 text-sm font-medium"

      >

        {isExpanded ? 'Show Less' : 'Show More'}

      </button>

    </div>

  );

}



// 使用示例

function ReviewCard({ review }) {

  return (

    <div className="card p-6">

      <div className="flex items-center mb-4">

        <img

          src={review.avatar}

          alt={review.author}

          className="w-10 h-10 rounded-full mr-3"

        />

        <div>

          <h4 className="font-semibold text-gray-900">{review.author}</h4>

          <div className="flex items-center">

            {/* 星级评分 */}

            {[...Array(5)].map((_, i) => (

              <svg

                key={i}

                className={`w-4 h-4 ${i < review.rating ? 'text-yellow-400' : 'text-gray-300'} fill-current`}

                viewBox="0 0 24 24"

              >

                <path d="M12 2l3.09 6.26L22 9.27l-5 4.87 1.18 6.88L12 17.77l-6.18 3.25L7 14.14 2 9.27l6.91-1.01L12 2z" />

              </svg>

            ))}

          </div>

        </div>

      </div>

      

      {/* 可展开的评论内容 */}

      <ExpandableText text={review.content} maxLines={4} />

    </div>

  );

}

这个示例展示了如何创建一个可展开的文本组件，用户可以点击按钮来显示完整内容或收起到指定行数。

最佳实践与总结

开发建议

在实际项目中使用 TailwindCSS 和 -webkit-line-clamp 时，以下最佳实践将帮助你获得更好的开发体验和项目质量：

TailwindCSS 开发最佳实践

1. 合理组织类名

虽然 TailwindCSS 鼓励在 HTML 中直接使用工具类，但过长的类名列表会影响代码可读性。建议采用以下策略：

// ❌ 避免：过长的类名列表

<div className="flex items-center justify-between p-6 bg-white rounded-lg shadow-sm border border-gray-200 hover:shadow-md transition-shadow duration-200 ease-in-out">



// ✅ 推荐：使用组件抽象

const Card = ({ children, className = "" }) => (

  <div className={`card hover:shadow-md transition-shadow ${className}`}>

    {children}

  </div>

);



// ✅ 推荐：使用 @apply 指令创建组件类

// 在 CSS 中定义

.card {

  @apply flex items-center justify-between p-6 bg-white rounded-lg shadow-sm border border-gray-200;

}

2. 建立设计系统

充分利用 TailwindCSS 的配置系统建立项目专属的设计系统：

// tailwind.config.js

module.exports = {

  theme: {

    extend: {

      // 定义项目色彩系统

      colors: {

        brand: {

          primary: '#3B82F6',

          secondary: '#10B981',

          accent: '#F59E0B',

        }

      },

      // 定义间距系统

      spacing: {

        '18': '4.5rem',

        '88': '22rem',

      },

      // 定义字体系统

      fontSize: {

        'xs': ['0.75rem', { lineHeight: '1rem' }],

        'sm': ['0.875rem', { lineHeight: '1.25rem' }],

        'base': ['1rem', { lineHeight: '1.5rem' }],

        'lg': ['1.125rem', { lineHeight: '1.75rem' }],

        'xl': ['1.25rem', { lineHeight: '1.75rem' }],

      }

    }

  }

}

3. 性能优化策略

TailwindCSS 的性能优化主要体现在生产环境的样式清理：

// tailwind.config.js

module.exports = {

  content: [

    // 精确指定扫描路径，避免不必要的文件扫描

    "./src/**/*.{js,jsx,ts,tsx}",

    "./public/index.html",

    // 如果使用了第三方组件库，也要包含其路径

    "./node_modules/@my-ui-lib/**/*.{js,jsx}",

  ],

  // 启用 JIT 模式获得更好的性能

  mode: 'jit',

}

4. 响应式设计策略

采用移动优先的设计理念，合理使用响应式前缀：

// ✅ 移动优先的响应式设计

<div className="

  grid grid-cols-1 gap-4

  sm:grid-cols-2 sm:gap-6

  md:grid-cols-3 md:gap-8

  lg:grid-cols-4

  xl:gap-10

">

  {/* 内容 */}

</div>



// ✅ 响应式文字大小

<h1 className="text-2xl sm:text-3xl md:text-4xl lg:text-5xl font-bold">

  标题

</h1>

line-clamp 使用最佳实践

1. 选择合适的截断行数

不同类型的内容需要不同的截断策略：

2. 考虑内容的语义完整性

// ✅ 好的实践：为截断的内容提供完整查看选项

function ProductDescription({ description }) {

  const [isExpanded, setIsExpanded] = useState(false);

  

  return (

    <div>

      <p className={isExpanded ? '' : 'line-clamp-3'}>

        {description}

      </p>

      {description.length > 150 && (

        <button 

          onClick={() => setIsExpanded(!isExpanded)}

          className="text-blue-600 text-sm mt-1"

        >

          {isExpanded ? '收起' : '查看更多'}

        </button>

      )}

    </div>

  );

}

3. 处理不同语言的截断

不同语言的文字密度不同，需要相应调整截断行数：

// 根据语言调整截断行数

function MultiLanguageText({ text, language }) {

  const getLineClampClass = (lang) => {

    switch (lang) {

      case 'zh': return 'line-clamp-2'; // 中文字符密度高

      case 'en': return 'line-clamp-3'; // 英文需要更多行数

      case 'ja': return 'line-clamp-2'; // 日文类似中文

      default: return 'line-clamp-3';

    }

  };

  

  return (

    <p className={`text-gray-700 ${getLineClampClass(language)}`}>

      {text}

    </p>

  );

}

性能考虑

TailwindCSS 性能优化

1. 构建时优化

TailwindCSS 在构建时会自动移除未使用的样式，但我们可以进一步优化：

// postcss.config.js

module.exports = {

  plugins: [

    require('tailwindcss'),

    require('autoprefixer'),

    // 生产环境启用 CSS 压缩

    process.env.NODE_ENV === 'production' && require('cssnano')({

      preset: 'default',

    }),

  ].filter(Boolean),

}

2. 运行时性能

避免在运行时动态生成类名，这会影响 TailwindCSS 的优化效果：

// ❌ 避免：动态类名生成

const dynamicClass = `text-${color}-500`; // 可能不会被包含在最终构建中



// ✅ 推荐：使用完整的类名

const colorClasses = {

  red: 'text-red-500',

  blue: 'text-blue-500',

  green: 'text-green-500',

};

const selectedClass = colorClasses[color];

line-clamp 性能影响

1. 重排和重绘

-webkit-line-clamp 的使用会触发浏览器的重排（reflow），在大量元素上使用时需要注意性能：

// ✅ 使用 CSS containment 优化性能

.text-container {

  contain: layout style;

  -webkit-line-clamp: 2;

  display: -webkit-box;

  -webkit-box-orient: vertical;

  overflow: hidden;

}

2. 虚拟化长列表

在处理大量带有文本截断的列表项时，考虑使用虚拟化技术：

import { FixedSizeList as List } from 'react-window';



function VirtualizedProductList({ products }) {

  const Row = ({ index, style }) => (

    <div style={style}>

      <ProductCard product={products[index]} />

    </div>

  );



  return (

    <List

      height={600}

      itemCount={products.length}

      itemSize={200}

    >

      {Row}

    </List>

  );

}

总结

TailwindCSS 和 -webkit-line-clamp 代表了现代前端开发中两个重要的技术趋势：工具化的 CSS 开发和细粒度的样式控制。

TailwindCSS 的价值在于：

-webkit-line-clamp 的意义在于：

在实际项目中，这两个技术的结合使用能够帮助开发者：

• 快速原型开发：在设计阶段快速验证界面效果


• 响应式布局：轻松适配各种设备和屏幕尺寸


• 内容管理：优雅处理动态内容的显示问题


• 性能优化：减少 CSS 体积和运行时计算

随着前端技术的不断发展，我们可以期待看到更多类似的工具和技术出现，它们将继续推动前端开发向着更高效、更标准化的方向发展。对于前端开发者而言，掌握这些现代技术不仅能提升当前的开发效率，更重要的是能够跟上技术发展的步伐，为未来的项目做好准备。

无论你是刚开始学习前端开发的新手，还是希望优化现有项目的资深开发者，TailwindCSS 和 -webkit-line-clamp 都值得你深入学习和实践。它们不仅是技术工具，更代表了现代前端开发的最佳实践和发展方向。

在当今快速发展的软件开发领域，灵活性和动态性是开发者不可或缺的能力。.NET 提供的反射机制和代码生成技术，为开发者提供了强大的工具，能够在运行时动态地探索和操作代码。这些技术不仅能够提升开发效率，还能实现一些传统静态代码无法完成的功能。本文将深入探讨 .NET 反射机制的核心功能、高级技巧以及代码生成的实际应用，帮助你在开发中更好地利用这些强大的工具。

.NET 反射：运行时的魔法

反射是 .NET 中一个极其强大的特性，它允许开发者在运行时动态地检查和操作类型信息。通过反射，你可以获取类型信息、动态创建对象、调用方法，甚至访问私有成员。这种能力在许多场景中都非常有用，比如实现插件系统、动态调用方法、序列化和反序列化等。

反射基础

反射的核心是 System.Type 类，它代表了一个类型的元数据。通过 Type 类，你可以获取类的名称、基类、实现的接口、方法、属性等信息。System.Reflection 命名空间提供了多个关键类，如 Assembly、MethodInfo、PropertyInfo 和 FieldInfo，帮助你更深入地探索类型信息。

获取 Type 对象有三种常见方式：

反射的常见操作

反射可以完成许多强大的操作，以下是一些常见的用法：

获取类型信息

通过 Type 对象，你可以获取类的各种信息，例如类名、基类、是否泛型等。

Type type = typeof(List<int>);

Console.WriteLine($"类名: {type.Name}"); // 输出：List`1

Console.WriteLine($"基类: {type.BaseType?.Name}"); // 输出：Object

Console.WriteLine($"是否泛型: {type.IsGenericType}"); // 输出：True

动态调用方法

假设你有一个类 Calculator，你可以通过反射动态调用它的方法。

public class Calculator

{

    public int Add(int a, int b) => a + b;

}



Calculator calc = new Calculator();

Type type = calc.GetType();

MethodInfo? method = type.GetMethod("Add");

if (method != null) {

    int result = (int)method.Invoke(calc, new object[] { 5, 3 })!;

    Console.WriteLine(result); // 输出：8

}

访问私有成员

反射可以绕过访问修饰符的限制，访问私有字段或方法。

public class SecretHolder

{

    private string _secret = "Hidden Data";

}



var holder = new SecretHolder();

Type type = holder.GetType();

FieldInfo? field = type.GetField("_secret", BindingFlags.NonPublic | BindingFlags.Instance);

if (field != null) {

    string secret = (string)field.GetValue(holder)!;

    Console.WriteLine(secret); // 输出：Hidden Data

}

动态创建对象

通过 Activator.CreateInstance 方法，你可以动态实例化对象。

Type type = typeof(StringBuilder);

object? instance = Activator.CreateInstance(type);



StringBuilder sb = (StringBuilder)instance!;

sb.Append("Hello");

Console.WriteLine(sb.ToString()); // 输出：Hello

高级反射技巧

反射的高级用法可以让你在开发中更加灵活，以下是一些进阶技巧：

调用泛型方法

如果方法带有泛型参数，你需要先使用 MakeGenericMethod 指定类型。

public class GenericHelper

{

    public T Echo<T>(T value) => value;

}



var helper = new GenericHelper();

Type type = helper.GetType();

MethodInfo method = type.GetMethod("Echo")!;

MethodInfo genericMethod = method.MakeGenericMethod(typeof(string));



string result = (string)genericMethod.Invoke(helper, new object[] { "Hello" })!;

Console.WriteLine(result); // 输出：Hello

性能优化

反射调用比直接调用慢很多，因此在高性能场景下，可以缓存 MethodInfo 或使用 Delegate 来优化性能。

MethodInfo method = typeof(Calculator).GetMethod("Add")!;

var addDelegate = (Func<Calculator, int, int, int>)Delegate.CreateDelegate(

    typeof(Func<Calculator, int, int, int>),

    method

);



Calculator calc = new Calculator();

int result = addDelegate(calc, 5, 3);

Console.WriteLine($"result: {result}"); // 输出：8

动态加载插件

假设你有一个插件系统，所有插件都实现了 IPlugin 接口，你可以通过反射动态加载插件。

public interface IPlugin

{

    void Execute();

}



public class HelloPlugin : IPlugin

{

    public void Execute() => Console.WriteLine("Hello from Plugin!");

}



Assembly assembly = Assembly.LoadFrom("MyPlugins.dll");

var pluginTypes = assembly.GetTypes()

    .Where(t => typeof(IPlugin).IsAssignableFrom(t) && !t.IsAbstract);



foreach (Type type in pluginTypes)

{

    IPlugin plugin = (IPlugin)Activator.CreateInstance(type);

    plugin.Execute();

}

代码生成：运行时的创造力

在某些高级场景中，你可能需要在运行时生成新的类型或方法。.NET 提供的 System.Reflection.Emit 命名空间允许你在运行时构建程序集、模块、类型和方法。

使用 Reflection.Emit 生成动态类

以下是一个示例，展示如何使用 Reflection.Emit 生成一个动态类 Person，并为其添加一个 SayHello 方法。

using System;

using System.Reflection;

using System.Reflection.Emit;



public class DynamicTypeDemo

{

    public static void Main()

    {

        // 创建一个动态程序集

        AssemblyName assemblyName = new AssemblyName("DynamicAssembly");

        AssemblyBuilder assemblyBuilder =

            AssemblyBuilder.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run);



        // 创建一个模块

        ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule("MainModule");



        // 定义一个类：public class Person

        TypeBuilder typeBuilder = moduleBuilder.DefineType(

            "Person",

            TypeAttributes.Public

        );



        // 定义一个方法：public void SayHello()

        MethodBuilder methodBuilder = typeBuilder.DefineMethod(

            "SayHello",

            MethodAttributes.Public,

            returnType: typeof(void),

            parameterTypes: Type.EmptyTypes

        );



        // 生成 IL 代码，等价于 Console.WriteLine("Hello from dynamic type!");

        ILGenerator il = methodBuilder.GetILGenerator();

        il.Emit(OpCodes.Ldstr, "Hello from dynamic type!");

        il.Emit(OpCodes.Call, typeof(Console).GetMethod("WriteLine", new[] { typeof(string) })!);

        il.Emit(OpCodes.Ret);



        // 创建类型

        Type personType = typeBuilder.CreateType();



        // 实例化并调用方法

        object personInstance = Activator.CreateInstance(personType)!;

        personType.GetMethod("SayHello")!.Invoke(personInstance, null);

    }

}

运行上述代码后，你将看到输出：

Hello from dynamic type!

表达式树：更安全的代码生成

如果你希望在运行时生成代码行为，但又不想深入 IL 层，表达式树（System.Linq.Expressions）是一个更现代、更安全的替代方案。以下是一个示例，展示如何使用表达式树生成一个简单的 SayHello 方法。

using System;

using System.Linq.Expressions;



public class ExpressionTreeDemo

{

    public static void Main()

    {

        // 表达式：() => Console.WriteLine("Hello from expression tree!")

        var writeLineMethod = typeof(Console).GetMethod("WriteLine", new[] { typeof(string) });



        // 构建常量表达式 "Hello from expression tree!"

        var messageExpr = Expression.Constant("Hello from expression tree!");



        // 调用 Console.WriteLine(string) 的表达式

        var callExpr = Expression.Call(writeLineMethod!, messageExpr);



        // 构建 lambda 表达式：() => Console.WriteLine(...)

        var lambda = Expression.Lambda<Action>(callExpr);



        // 编译成委托并执行

        Action sayHello = lambda.Compile();

        sayHello();

    }

}

运行上述代码后，你将看到输出：

Hello from expression tree!

Source Generator：编译期代码生成

Source Generator 是 .NET 提供的一种编译期代码生成工具，可以在编译过程中注入额外的源代码。它不依赖反射，无运行时开销，适合构建高性能、可维护的自动化代码逻辑。

以下是一个简单的 Source Generator 示例，展示如何为类自动生成一个 SayHello 方法。

运行上述代码后，你将看到输出：

Hello from Source Generator!

总结

反射和代码生成是 .NET 中非常强大的特性，它们为开发者提供了运行时动态探索和操作代码的能力。反射机制允许你在运行时检查类型信息、动态创建对象、调用方法，甚至访问私有成员。代码生成技术则让你能够在运行时生成新的类型和方法，或者在编译期生成代码，从而提升开发效率和代码的灵活性。

在实际开发中，反射虽然功能强大，但需要注意性能开销。在需要高性能的场景下，可以考虑使用 Delegate 缓存、表达式树，或 .NET 6 的 Source Generators 来替代反射。通过合理使用这些技术，你可以在开发中更加灵活地应对各种复杂场景，提升代码的可维护性和性能。

希望这篇文章能帮助你更好地理解和应用 .NET 反射和代码生成技术，让你在开发中更加得心应手！

✨ 为什么写这篇文章？

很多前端朋友在用 React 的时候：

• 只会用 useState 做局部状态，结果项目一大就乱套。


• 不了解 useReducer 和 Context，复杂页面全靠 props 一层层传。


• 性能卡顿后，只知道用 React.memo，但为什么卡？


• useMemo和useCallback的区别 ？


• 明明只是个 Modal，结果被卡在组件层级里动弹不得，不知道可以用 Portals。

👉「在什么场景下选用哪个 API」+「如何写出最合理的 React 代码」。

🟢 1. useState：局部状态管理

🌳 场景：表单输入管理

比起枯燥的计数器，这里用表单输入做示例。

import { useState } from 'react';



export default function LoginForm() {

  const [username, setUsername] = useState('');

  const [password, setPassword] = useState('');



  const handleSubmit = e => {

    e.preventDefault();

    console.log("登录中", username, password);

  }



  return (

    <form onSubmit={handleSubmit}>

      <input value={username} onChange={e => setUsername(e.target.value)} placeholder="用户名"/>

      <input type="password" value={password} onChange={e => setPassword(e.target.value)} placeholder="密码"/>

      <button type="submit">登录</button>

    </form>

  );

}

🚀 优势

• 简单、直接


• 适用于小型、独立的状态

🟡 2. useEffect：副作用处理

🌍 场景：组件挂载时拉取远程数据

import { useEffect, useState } from 'react';



export default function UserProfile({ userId }) {

  const [user, setUser] = useState(null);



  useEffect(() => {

    fetch(`/api/user/${userId}`)

      .then(res => res.json())

      .then(data => {

         setUser(data);

      });



    return () => {

      // 组件销毁执行此回调

    };

  }, []);



  return user ? <h1>{user.name}</h1> : <p>加载中...</p>;

}

🚀 优势

• 集中管理副作用（请求、订阅、定时器、事件监听）

🔵 3. useRef & useImperativeHandle：DOM、实例方法控制

场景 1：聚焦输入框

import { useRef, useEffect } from 'react';



export default function AutoFocusInput() {

  const inputRef = useRef();



  useEffect(() => {

    inputRef.current.focus();

  }, []);



  return <input ref={inputRef} placeholder="自动聚焦" />;

}

场景 2：在父组件调用子组件的方法

import { forwardRef, useRef, useImperativeHandle } from 'react';



const FancyInput = forwardRef((props, ref) => {

  const inputRef = useRef();

  useImperativeHandle(ref, () => ({

    focus: () => inputRef.current.focus()

  }));

  return <input ref={inputRef} />;

});



export default function App() {

  const fancyRef = useRef();

  return (

    <>

      <FancyInput ref={fancyRef} />

      <button onClick={() => fancyRef.current.focus()}>父组件聚焦子组件</button>

    </>

  );

}

🧭 4. Context & useContext：解决多层级传值

场景：用户登录信息在多层组件使用

import React, { createContext, useContext } from 'react';



const UserContext = createContext();



/** 设置在 DevTools 中将显示为 User */

UserContext.displayName = 'User'



function Navbar() {

  return (

      <div>

          <UserInfo />

      </div>

  )

}



function UserInfo() {

  const user = useContext(UserContext);

  return <span>欢迎，{user.name}</span>;

}



export default function App() {

  return (

    <UserContext.Provider value={{ name: 'Zheng' }}>

      <Navbar />

    </UserContext.Provider>

  );

}

🚀 优势

• 解决「祖孙组件传值太麻烦」的问题

🔄 5. useReducer：复杂状态管理

import { useReducer } from 'react';



function reducer(state, action) {

  switch(action.type){

    case 'next':

      return { ...state, step: state.step + 1 };

    case 'prev':

      return { ...state, step: state.step - 1 };

    default:

      return state;

  }

}



export default function Wizard() {

  const [state, dispatch] = useReducer(reducer, { step: 1 });



  return (

    <>

      <h1>步骤 {state.step}</h1>

      <button onClick={() => dispatch({type: 'prev'})}>上一步</button>

      <button onClick={() => dispatch({type: 'next'})}>下一步</button>

    </>

  );

}

🆔 6. useId：避免 SSR / 并发下 ID 不一致

import { useId } from 'react';



export default function FormItem() {

  const id = useId();

  return (

    <>

      <label htmlFor={id}>姓名</label>

      <input id={id} type="text" />

    </>

  );

}

🚀 7. Portals：在根元素渲染 Modal

import { useState } from 'react';

import ReactDOM from 'react-dom';



function Modal({ onClose }) {

  return ReactDOM.createPortal(

    <div style={{ position: "fixed", top: 100, left: 100, background: "white" }}>

      <h1>这是 Modal</h1>

      <button onClick={onClose}>关闭</button>

    </div>,

    document.getElementById('root')

  );

}



export default function App() {

  const [show, setShow] = useState(false);

  return (

    <>

      <button onClick={() => setShow(true)}>打开 Modal</button>

      {show && <Modal onClose={() => setShow(false)} />}

    </>

  );

}

在上面代码中，我们将要渲染的视图作为createPortal方法的第一个参数，而第二个参数用于指定要渲染到那个DOM元素中。

尽管 portal 可以被放置在 DOM 树中的任何地方，但在任何其他方面，其行为和普通的 React 子节点行为一致。由于 portal 仍存在于 React 树， 且与 DOM 树中的位置无关，那么无论其子节点是否是 portal，像 context 这样的功能特性都是不变的。

这包含事件冒泡。一个从 portal 内部触发的事件会一直冒泡至包含 React 树的祖先，即便这些元素并不是 DOM 树中的祖先。

🔍 8. 组件渲染性能优化

🐘 之前类组件时代：shouldComponentUpdate与PureComponent

import { Component } from 'react'



export default class App extends Component {

  constructor() {

    super();

    this.state = {

      counter: 1

    }

  }

  render() {

    console.log("App 渲染了");

    return (

      <div>

        <h1>App 组件</h1>

        <div>{this.state.counter}</div>

        <button onClick={() => this.setState({

          counter : 1

        })}>+1</button>

      </div>

    )

  }

}

在上面的代码中，按钮在点击的时候仍然是设置 counter 的值为1，虽然 counter 的值没有变，整个组件仍然是重新渲染了的，显然，这一次渲染是没有必要的。

当 props 或 state 发生变化时，shouldComponentUpdate 会在渲染执行之前被调用。返回值默认为 true。首次渲染或使用 forceUpdate 方法时不会调用该方法。

下面我们来使用 shouldComponentUpdate 优化上面的示例：

import React from 'react'



/**

 * 对两个对象进行一个浅比较，看是否相等

 * obj1

 * obj2

 * 返回布尔值 true 代表两个对象相等， false 代表不相等

 */

function objectEqual(obj1, obj2) {

  for (let prop in obj1) {

    if (!Object.is(obj1[prop], obj2[prop])) {

      // 进入此 if，说明有属性值不相等

      // 只要有一个不相等，那么就应该判断两个对象不等

      return false

    }

  }

  return true

}



class PureChildCom1 extends React.Component {

  constructor(props) {

    super(props)

    this.state = {

      counter: 1,

    }

  }



  // 验证state未发生改变，是否会执行render

  onClickHandle = () => {

    this.setState({

      counter: Math.floor(Math.random() * 3 + 1),

    })

  }



  // shouldComponentUpdate 中返回 false 来跳过整个渲染过程。其包括该组件的 render 调用以及之后的操作。

  // 返回true 只要执行了setState都会重新渲染

  shouldComponentUpdate(nextProps, nextState) {

    if (

      objectEqual(this.props, nextProps) &&

      objectEqual(this.state, nextState)

    ) {

      return false

    }

    return true

  }



  render() {

    console.log('render')

    return (

      <div>

        <div>{this.state.counter}</div>

        <button onClick={this.onClickHandle}>点击</button>

      </div>

    )

  }

}



export default PureChildCom1