本文首发于公众号：托尼学长，立个写 1024 篇原创技术面试文章的flag，欢迎过来视察监督~

关于SQL语句的面试题中，有两个被面试官问到的频率特别高，一个是SQL优化，另外一个则是索引失效。

接下来我们就来一一进行盘点，索引失效的场景到底有哪些。

准备工作

我们先来创建一张订单表，并为该表生成100w+的数据，这样SQL语句所对应的执行计划会更加准确，表结构如下：

CREATE TABLE `tony_order`  (

  `id` bigint UNSIGNED NOT NULL AUTO_INCREMENT COMMENT '订单ID',

  `product_id` int NOT NULL COMMENT '商品ID',

  `user_id` int NOT NULL COMMENT '用户ID',

  `status` tinyint NOT NULL COMMENT '状态',

  `discount_amount` int NOT NULL COMMENT '总金额',

  `total_amount` int NOT NULL COMMENT '打折金额',

  `payable_amount` int NOT NULL COMMENT '实际支付金额',

  `receiver_name` varchar(255) DEFAULT NULL COMMENT '收件人名称',

  `receiver_phone` varchar(255) DEFAULT NULL COMMENT '收件人手机号',

  `receiver_address` varchar(255) DEFAULT NULL COMMENT '收件人地址',

  `note` varchar(255) DEFAULT NULL COMMENT '备注',

  `payment_time` datetime NULL DEFAULT NULL COMMENT '支付时间',

  `create_time` datetime NOT NULL COMMENT '创建时间',

  `update_time` datetime NOT NULL COMMENT '更新时间',

  PRIMARY KEY (`id` DESC) USING BTREE,

  INDEX `idx_product_id`(`product_id` ASC) USING BTREE,

  INDEX `idx_user_id_total_amount`(`user_id` ASC, `total_amount` ASC) USING BTREE,

  INDEX `idx_create_time`(`create_time` ASC) USING BTREE,

  INDEX `idx_update_time`(`update_time` ASC) USING BTREE,

  INDEX `idx_status`(`status` ASC) USING BTREE,

  INDEX `idx_receiver_phone`(`receiver_phone` ASC) USING BTREE,

  INDEX `idx_receiver_name`(`receiver_name` ASC) USING BTREE,

  INDEX `idx_receiver_address`(`receiver_address` ASC) USING BTREE

  ) ENGINE = InnoDB CHARACTER SET = utf8mb4 ROW_FORMAT = Dynamic;

接下来我们来一一验证下索引失效的场景。

索引失效场景

1、不遵循最左前缀原则

SELECT * FROM tony_order WHERE total_amount = 100;

我们从执行计划中可以看到，这条SQL语句走的是全表扫描，即使创建了索引idx_user_id_total_amount也没有生效。

但由于其total_amount字段没有在联合索引的最左边，不符合最左前缀原则。

SELECT * FROM tony_order WHERE user_id = 4323 AND total_amount = 101;

当我们把user_id这个字段补上之后，果然就可以用上索引了。

在MySQL 8.0 版本以后，联合索引的最左前缀原则不再那么绝对了，其引入了Skip Scan Range Access Method机制，可对区分度较低的字段进行优化。

感兴趣的同学可以去看下，本文中就不过多展开描述了。

2、LIKE百分号在左边

SELECT * FROM tony_order WHERE receiver_address LIKE '%北京市朝阳区望京SOHO';



SELECT * FROM tony_order WHERE receiver_address LIKE '%北京市朝阳区望京SOHO%';  

执行上面这两条SQL语句，结果都是一样的，走了全表扫描。

接下来我们将SQL语句改为%在右边，再执行一次看看。

SELECT * FROM tony_order WHERE receiver_address LIKE '北京市朝阳区望京SOHO%';  

这个原理很好理解，联合索引需要遵循最左前缀原则，而单个索引LIKE的情况下，也需要最左边能够匹配上才行，否则就会导致索引失效。

3、使用OR关键字

有一种说法，只要使用OR关键字就会导致索引失效，我们来试试。

SELECT * FROM tony_order WHERE receiver_name = 'Tony学长' OR user_id = 41323;

从结果中我们可以看到，索引并没有失效，聪明的查询优化器将receiver_name和user_id两个字段上的索引进行了合并。

接下来我们再换个SQL试试。

SELECT * FROM tony_order WHERE receiver_phone = '13436669764' OR user_id = 4323;

这次确实索引失效了，由于receiver_phone这个字段上并没有创建索引，所以无法使用索引合并操作了，只能走全表扫描。

有的同学会问，那为什么user_id上的索引也失效了呢？

因为一个字段走索引，另一个字段走全表扫描是没有意义的，反而不如走一次全表扫描查找两个字段更有效率。

所以，有时候索引失效未必是坏事，而是查询优化器做出的最优解。

4、索引列上有函数

SELECT * FROM tony_order WHERE ABS (user_id) = 4323; 

SELECT * FROM tony_order WHERE LEFT (receiver_address, 3) 

这个不用过多解释了，就是MySQL的一种规范，违反就会导致索引失效。

5、索引列上有计算

SELECT * FROM tony_order WHERE  user_id + 1 = 4324; 

这个也不用过多解释了，还是MySQL的一种规范，违反就会导致索引失效。

6、字段隐式转换

SELECT * FROM tony_order WHERE receiver_phone = 13454566332;

手机号字段明明是字符类型，却在SQL中不慎写成了数值类型而导致隐式转换，最终导致receiver_phone字段上的索引失效。

SELECT * FROM tony_order WHERE receiver_phone = '13454566332';

当我们把手机号加上单引号之后，receiver_phone字段的索引就生效了，整个天空都放晴了。

SELECT * FROM tony_order WHERE product_id = '12345';

我们接着尝试，把明明是数值型的字段写成了字符型，结果是正常走的索引。

由此得知，当发生隐式转换时，把数值类型的字段写成字符串类型没有影响，反之，但是把字符类型的字段写成数值类型，则会导致索引失效。

7、查询记录过多

SELECT * FROM tony_order WHERE product_id NOT IN (12345,12346);

那么由此得知，使用NOT IN关键字一定会导致索引失效？先别着急下结论。

SELECT * FROM tony_order WHERE status NOT IN (0,1);

从执行计划中可以看到，status字段上的索引生效了，为什么同样使用了NOT IN关键字，结果却不一样呢？

因为查询优化器会对SQL语句的查询记录数量进行评估，如果表中有100w行数据，这个SQL语句要查出来90w行数据，那当然走全表扫描更快一些，毕竟少了回表查询这个步骤。

反之，如果表中有100w行数据，这个SQL语句只需要查出来10行数据，那当然应该走索引扫描。

SELECT * FROM tony_order WHERE status IN (0,1);

同样使用IN关键字进行查询，只要查询出来的记录数过于庞大，都会通过全表扫描来代替索引扫描。

SELECT * FROM tony_order WHERE status = 0;

甚至我们不使用IN、NOT IN、EXISTS、NOT EXISTS这些关键字，只使用等号进行条件筛选同样会走全表扫描，这时不走索引才是最优解。

8、排序顺序不同

SELECT * FROM tony_order ORDER BY user_id DESC,total_amount ASC 

我们可以看下，这条SQL语句中的user_id用了降序，而total_amount用了升序，所以导致索引失效。

SELECT * FROM tony_order ORDERBY user_id ASC,total_amount ASC

而下面这两条SQL语句中，无论使用升序还是降序，只要顺序一致就可以使用索引扫描。

想象一下，你向大型语言模型抛出问题，满心期待精准回答，得到的却是答非所问，是不是让人抓狂？在复杂分类场景下，这种“大模型不听话”的情况更是常见。

提示词微调这一利器，能帮你驯服大模型，让其准确输出所需结果。

今天就来深入解析如何通过提示词工程、RAG 增强和 Few Shots 学习等核心技术，高效构建基于 LLM 的分类系统。

分类系统架构设计

graph TD

    A[输入文本] --> B[提示工程]

    C[类别定义] --> B

    D[向量数据库] --> E[RAG增强]

    F[Few Shots示例] --> B

    B --> G[LLM推理]

    G --> H[结果提取]

分类系统的核心流程围绕提示工程展开，结合 RAG 增强和 Few Shots 学习可显著提升分类准确性。系统设计需关注数据流转效率与结果可解释性，特别适合保险票据、客户服务工单等高价值场景。

提示工程核心技巧

提示设计是 LLM 分类性能的关键，以下是经过实战验证的核心技巧：

1. 结构化表示法

采用 XML 或 JSON 格式封装类别定义和输入文本，提升模型理解效率：

# 类别定义示例

<categories>

    <category>

        <label>账单查询</label>

        <description>关于发票、费用、收费和保费的问题</description>

    </category>

    <category>

        <label>政策咨询</label>

        <description>关于保险政策条款、覆盖范围和除外责任的问题</description>

    </category>

</categories>



# 输入文本

<content>我的保险费为什么比上个月高了？</content>

2. 边界控制与结果约束

通过明确的指令和停止序列控制模型输出范围：

请根据提供的类别，对输入文本进行分类。

- 只需返回类别标签，不添加任何解释

- 如果无法分类，请返回"其他"



类别: [账单查询, 政策咨询, 理赔申请, 投诉建议, 其他]

输入: 我想了解我的保险是否涵盖意外医疗费用

输出:

3. 思维链提示

对于复杂分类任务，引导模型逐步思考：

我需要对客户的问题进行分类。首先，我会分析问题的核心内容，然后匹配最相关的类别。



客户问题: "我的汽车保险理赔需要提供哪些材料？"

分析: 这个问题是关于理赔过程中所需的材料，属于理赔相关的咨询。

类别匹配: 理赔申请

最终分类: 理赔申请

Few Shots 学习技术

Few Shots 学习通过提供少量示例，帮助模型快速适应特定任务：

1. 示例选择策略

# 选择多样化示例覆盖主要类别

示例1:

输入: "我的账单金额有误"

分类: 账单查询



示例2:

输入: "我想更改我的保险受益人"

分类: 政策变更



示例3:

输入: "我的车辆在事故中受损，如何申请理赔？"

分类: 理赔申请

2. 示例排序优化

# 按与输入的相关性排序示例

1. 最相关示例

输入: "我的保险费为什么上涨了？"

分类: 账单查询



2. 次相关示例

输入: "我想了解我的保险 coverage"

分类: 政策咨询

RAG 增强技术应用

检索增强生成(RAG)通过引入外部知识提升分类准确性：

1. 向量数据库构建与检索

# 1. 准备知识库文档

文档1: 保险理赔流程指南

文档2: 保险政策条款解释

文档3: 常见账单问题解答



# 2. 构建向量数据库

为每个文档创建嵌入向量并存储



# 3. 检索相关文档

对于输入文本，检索最相关的2-3个文档片段

2. 检索结果融合提示

# 结合检索结果和输入文本进行分类

检索到的相关信息:

[来自文档3] 常见账单问题包括费用上涨原因、账单错误等



输入文本: 我的保险费为什么比上个月高了？



请根据以上信息，将输入文本分类到以下类别之一:

[账单查询, 政策咨询, 理赔申请, 投诉建议, 其他]

技术整合示例

以下是整合提示词工程、RAG 技术和 Few Shots 学习的完整分类系统伪代码：

# 整合分类系统实现

class LLMClassifier:

    def __init__(self, llm_client, vector_db):

        self.llm_client = llm_client

        self.vector_db = vector_db

        self.categories = self._load_categories()

        self.few_shot_examples = self._load_few_shot_examples()



    def _load_categories(self):

        # 加载类别定义

        return {

            "账单查询": "关于发票、费用、收费和保费的问题",

            "政策咨询": "关于保险政策条款、覆盖范围和除外责任的问题",

            "理赔申请": "关于理赔流程、材料和状态的问题",

            "投诉建议": "对服务、流程或结果的投诉和建议",

            "其他": "无法分类到以上类别的问题"

        }



    def _load_few_shot_examples(self):

        # 加载Few Shots示例

        return [

            {"input": "我的账单金额有误", "label": "账单查询"},

            {"input": "我想更改我的保险受益人", "label": "政策咨询"},

            {"input": "我的车辆在事故中受损，如何申请理赔？", "label": "理赔申请"}

        ]



    def _retrieve_relevant_docs(self, query, top_k=2):

        # RAG检索相关文档

        return self.vector_db.search(query, top_k=top_k)



    def _build_prompt(self, query, relevant_docs):

        # 构建整合提示

        prompt = """

        任务：将客户问题分类到以下类别之一：{categories}



        类别定义：

        {category_definitions}



        相关知识：

        {relevant_knowledge}



        示例：

        {few_shot_examples}



        请按照以下步骤分类：

        1. 分析客户问题的核心内容

        2. 结合相关知识和示例，匹配最相关的类别

        3. 只返回类别标签，不添加任何解释



        客户问题："{query}"

        分类结果：

        """



        # 填充模板

        categories_str = ", ".join(self.categories.keys())

        category_definitions = "\n".join([f"- {k}: {v}" for k, v in self.categories.items()])

        relevant_knowledge = "\n".join([f"- {doc}" for doc in relevant_docs])

        few_shot_examples = "\n".join([f"输入: \"{ex['input']}\"\n分类: {ex['label']}" for ex in self.few_shot_examples])



        return prompt.format(

            categories=categories_str,

            category_definitions=category_definitions,

            relevant_knowledge=relevant_knowledge,

            few_shot_examples=few_shot_examples,

            query=query

        )



    def classify(self, query):

        # 1. RAG检索相关文档

        relevant_docs = self._retrieve_relevant_docs(query)



        # 2. 构建整合提示

        prompt = self._build_prompt(query, relevant_docs)



        # 3. LLM推理

        response = self.llm_client.generate(

            prompt=prompt,

            max_tokens=100,

            temperature=0.0

        )



        # 4. 提取结果

        result = response.strip()

        return result if result in self.categories else "其他"



# 使用示例

if __name__ == "__main__":

    # 初始化LLM客户端和向量数据库

    llm_client = initialize_llm_client()  # 初始化LLM客户端

    vector_db = initialize_vector_db()   # 初始化向量数据库



    # 创建分类器

    classifier = LLMClassifier(llm_client, vector_db)



    # 测试分类

    test_queries = [

        "我的保险费为什么比上个月高了？",

        "我想了解我的保险是否涵盖意外医疗费用？",

        "我的汽车保险理赔需要提供哪些材料？"

    ]



    for query in test_queries:

        category = classifier.classify(query)

        print(f"查询: {query}\n分类结果: {category}\n")

通过以上核心技术的综合应用，可构建高效、准确的 LLM 分类系统，为保险、金融、客服等领域的文本分类需求提供强大解决方案。

nine｜践行一人公司 | 🛰️codetrend

正在记录从 0 到 1 的踩坑与突破，交付想法到产品的全过程。

var a = 0;

function f1(){

    var a = 1;

    console.log(this.a); //输出为0

}

f1(); //直接调用，应用默认绑定

var a = 0;

function f1(){

    var a = 1;

    f2();

}

function f2(){

    var a = 2;

    console.log(this.a); //输出的是0

}

f1(); 

var a = 0;

function f1() {

    var a = 1;

    console.log(this.a); //this绑定的是f2这个对象字面量

}

var obj = {

    a : 2,

    f1 : f1

    

    // 也可以直接在obj内部定义f1

    // function f1() {

    //     var a = 1;

    // }

   

};

obj.f1(); // 输出为2

var a = 0;

function f1() {

    var a = 1;

    console.log(this.a); //最后输出为2

}

var obj1 = {

    a : 2,

    f1 : f1

};

var obj2 = {

    a : 3,

    obj1 : obj1

}

obj2.obj1.f1();

var a = 0;

function f1() {

    var a = 1;

    console.log(this.a); //最后输出为0

}

var obj = {

    a : 2,

    f1 : f1

}

var fOne = obj.f1; // 给f1取了一个fOne的别名

fOne();

var a = 0;

// f1为回调函数，将obj.f2作为参数传递给f1

function f1(f2) {

    var a = 1;

    f2();

}

function f2() {

    var a = 2;

    console.log(this.a); //结果为0

}

var obj = {

    a : 3,

    f2 : f2

}

f1(obj.f2);

var a = 0;

function f1 () {

    var a = 1;

    console.log(this.a);

}

//apply方法绑定this   apply(对象，参数数组)

f1.apply({a:2});  //输出2



//call方法绑定this   call(对象，参数1，参数2，...)

f1.call({a:3}); //输出3



//bind方法绑定this   bind(对象,参数1，参数2，...),bind会返回一个函数，需要调用

boundf1 = f1.bind({a:4});

boundf1(); //输出4

var a = 0;

function f1() {

    var a = 1;

    console.log(this.a);

}

var bar = function() { 

    return f1.apply({a:2});

};

setTimeout(bar, 1000);//输出为2

var a = 0;

function f1() {

    var a = 1;

    console.log(this.a); 

}



function bind(fn, obj) {

    return function () {

        return fn.apply(obj, arguments);

    };

}



var bar = bind(f1,{a:2});

bar();

var a = 0;

function f1 () {

    var a = 1;

    console.log(this.a);

}

//bind方法绑定this   

//bind(对象,参数1，参数2，...),bind会返回一个函数，需要调用

boundf1 = f1.bind({a:2});

boundf1(); //输出2

function f1(el) {

    console.log(el, this.id);

}

var obj = {

    id : "awesome"

};

[1,2,3].forEach(f1,obj);

//最后输出的结果为

// 1 'awesome'

// 2 'awesome'

// 3 'awesome'

var a = 0;

function f1() {

    var a = 1;

    console.log(this.a);

}

var obj = {

    a : 2,

    f1 : f1

};

(0,obj.f1)(); //输出0

function f1(a){

    this.a = a;

}

var bar = new f1(2);

console.log(bar.a); //输出为2

console.log(f1.a); //输出为undefined

function foo() {  

    console.log( this.a ); 

} 

var obj1 = {  

a: 2, 

foo: foo 

}; 

var obj2 = {  

a: 3, 

foo: foo  

}; 

obj1.foo(); // 2  

obj2.foo(); // 3 

obj1.foo.call( obj2 ); // 3  

obj2.foo.call( obj1 ); // 2

function foo(something) {  

    this.a = something; 

} 

var obj1 = {  

    foo: foo 

}; 

obj1.foo(1);

console.log( obj1.a ); // 1



var bar = new obj1.foo(2); 

console.log( obj1.a ); // 1 

console.log( bar.a ); // 2

var bar = new obj1.foo(2)这段代码，如果隐式绑定的优先级会大于new绑定，就会在obj1里把属性a赋值为2； 如果new绑定的优先级大于隐式绑定，就会在bar中创建一个属性a，值为2，最后看obj1.a和bar.a谁输出为2，谁的优先级就更高，很明显bar.a输出为2，所以new绑定的优先级高于隐式绑定的。

所以new调用的优先级要高于隐式调用的优先级。

3. 再来看看new调用和显式调用的优先级谁高谁低吧。

new不能和apply和call方法同时使用，但我们可以用bind方法进行硬绑定，再用bind返回的新函数再new一下以此来判断谁的优先级高。

function foo(something) {  

    this.a = something; 

} 

 

var obj1 = {}; 

 

var bar = foo.bind( obj1 );  

bar( 2 ); 

console.log( obj1.a ); // 2 

 

var baz = new bar(3);  

console.log( obj1.a ); // 2  

console.log( baz.a ); // 3

首先硬绑定了obj1，在obj1中创建了a属性，值为2，bar接收返回的bind函数。之后new bar并给a赋值为3,用baz来接收new的对象，这时如果baz.a为3就说明this应用的绑定规则是new绑定。

所以new绑定的优先级是高于显示调用的优先级的。

现在知道了四种规则，又知道了这四个规则的优先级，我们就能很清晰的判断this的绑定了。

判断this的流程

以后判断this我们可以按以下顺序来判断：

凡事都有例外，还有一些十分特殊的情况不满足上面的四条规则，我们需要单独拎出来记忆。

绑定例外

绑定例外主要有3种。

null导致的绑定意外

var a = 0;  

function f1() {  

var a = 1;  

console.log(this.a);  

}  

f1.apply(null); //输出为0  

  

var bar = f1.bind(null);  

bar() //输出为0

当我们使用显式绑定（使用apply、call、bind方法）的时候，如果我们显式绑定一个null，就会发现this绑定的不是null而是应用默认绑定，绑定全局对象。这会导致变量全局渗透的问题。

有的人可能会说，那我们不用null来绑定this不就好了吗？但有的时候我们还真不得不使用null来绑定this，下面我来介绍一下什么时候会使用这种情况。

一种常见的做法是使用apply(..)来“展开”一个数组，并当作参数传入一个函数。类似地，bind(..)可以对参数进行柯里化（预先设置一些参数），这种方法有时很好用的。

function f1 (a , b) {  

console.log("a:" + a + ",b:" + b);  

}  



f1.apply(null,[2,3])  //输出为a:2,b:3



//bind的柯里化

var bar = f1.bind(null,2);  

bar(3); //输出为a:2,b:3

现在来简单地来介绍一下柯里化是什么？柯里化是将一个接收多个参数的函数转换为一系列只接受单个参数的函数。这时bind和null的作用就体现出来了。

然而，在apply,call,bind使用null会导致全局溢出，在一些有this的函数中，给这个this绑定null，会让this绑定全局对象。该如何解决这个问题呢？

更安全的this

我们可手动创建一个空的对象，这个空的对象我们称作“DMZ”（demilitarized zoo，非军事区）对象——它是一个空的非委托的对象。

如果我们在想要忽略this绑定时总是传入一个DMZ对象，那就不用担心this会溢出到全局了，这个this绑定的就是DMZ对象。

在JavaScript中创建一个空对象最简单的方法是Object.create(null)——它会返回一个空对象，Object.create(null)。Object.create(null)和{}很像，并不会创建Object.prototype这个委托，所以它比{}“更空”。

var c = 0;

function f1 (a , b) {

    this.c = 1;

    console.log("a:" + a + ",b:" + b);  

}  

//创建自己的空对象

var myNull = Object.create(null);



f1.apply(myNull,[2,3])  //输出为a:2,b:3

console.log(c);  //输出为0 



//bind的柯里化

var bar = f1.bind(myNull,2);  

bar(3); //输出为a:2,b:3

console.log(c); //输出为0

可以发现这段代码中，我们创建了自己的空对象通过apply和bind方法把this绑定到这个空对象了。最后的输出的c是0，说明this.c并没有修改全局变量c的值。所以这个方法可以防止全局溢出。

接下来谈谈另外一个绑定的例外吧。

间接引用

有的时候你可能(有意或无意地)创建了一个函数的“间接引用”，在这种情况下，调用这个函数应用默认绑定规则。

var a = 0;

function f1() {

    console.log(this.a);

}

var obj1 = {

    a : 1,

    f1 : f1

};



var obj2 = {

    a : 2,

};

obj1.f1(); // 1

(obj2.f1 = obj1.f1)(); // 0

我们来看看这个代码。obj1中有a和f1属性或方法，a的值为1；obj2中只有a属性，值为2。我们先隐式绑定obj1，this绑定obj1，最后输出为1，这个我们可以理解。关键是下面这行代码(obj2.f1 = obj1.f1)()，obj2中没有f1，所以它在obj2中创建一个f1，然后将obj1中的f1函数赋值给obj2的f1，然后执行这个赋值表达式。那为什么输出的是0而不是obj2中的2或者obj1中的1呢？ 🤔

其实这和赋值表达式的返回值有关系，因为赋值表达式会返回等号右边的值。 所以(obj2.f1 = obj1.f1)实际上返回的obj1.f1中的f1函数，实际执行的是f1()。所以应用的是默认绑定，this绑定全局对象，结果输出为0。

我们继续看绑定的下一个例外。

箭头函数

在ES6中介绍了一种无法使用这些规则的特殊函数类型：箭头函数。

箭头函数和一般的函数不一样，它不是用function来定义的，而是使用被称作“胖箭头”的操作符=>定义的。

定义格式：(参数) => {函数体}

箭头函数不使用this的四条规则，而是继承外层（定义时所在）函数或全局作用域的this的值，this在箭头函数创建时就被确定，且永远不会被改变，new也不行。

var a = 0;

(()=>{

    var a = 1;

    console.log(this.a); // 结果输出为0

})(); 

很明显该箭头函数外部就是全局作用域，所以继承全局对象的this就是它本身，所以输出为0。

再看看如果在其他函数中定义箭头函数this如何绑定

var a = 0;

function f1() {

    var a = 1;

    (()=>{

        var a = 2;

        console.log(this.a);

    })();

}

f1();//输出0



//给f1绑定一个对象

f1.apply({a:3}); // 输出3

可以发现f1内部的箭头函数继承了其外部函数f1的this的绑定。所以一开始没给f1绑定this时，f1的this绑定的是全局对象，箭头函数的也是全局对象；当给f1的this绑定一个对象时，箭头函数的this也绑定该对象。

小结

以上是我的学习分享，希望对你有所帮助。

还有本篇的四条规则只适用于非严格模式，严格模式的this的绑定我日后再出一篇吧，其实只是有点懒😂。

参考书籍

《你所不知道的JavaScript（上卷)》

graph TB

    A[企业AI需求] --> B[MCP企业架构]

    B --> C[安全体系]

    B --> D[运维管理]

    B --> E[实施路径]

    

    C --> C1[身份认证]

    C --> C2[数据保护]

    C --> C3[访问控制]

    

    D --> D1[自动化部署]

    D --> D2[监控告警]

    D --> D3[成本优化]

    

    E --> E1[MVP阶段]

    E --> E2[扩展阶段]

    E --> E3[优化阶段]

    

    style A fill:#FFE4B5

    style B fill:#90EE90

    style C fill:#87CEEB

    style D fill:#DDA0DD

    style E fill:#F0E68C

3分钟速读：企业级MCP部署不同于个人使用，需要考虑安全合规、高可用性、统一管理等复杂需求。本文提供从架构设计到运维管理的完整企业级MCP平台构建方案，包含安全框架、监控体系和分阶段实施路径，帮助企业构建统一、安全、可扩展的AI工具平台。

"系统上线第三天就被安全部门紧急叫停，所有人都在会议室里看着我。"

那是我职业生涯中最尴尬的时刻之一。作为一家500人科技公司的架构师，我以为把个人版的MCP简单放大就能解决企业的AI工具集成问题。结果呢？权限混乱、数据泄露风险、合规审计不通过...

CEO当时问我："我们现在有20多个团队在用各种AI工具，每个团队都有自己的一套，你觉得这样下去会不会出问题？"我当时信心满满地说："没问题，给我两周时间。"

现在想想，那时的我真是太天真了。个人用Claude Desktop配置几个MCP服务器确实10分钟就搞定，但企业级别？完全是另一个世界。

从那次失败中我学到：企业级MCP部署面临的不是技术问题，而是管理和治理的系统性挑战。

🏢 企业AI工具集成的挑战与机遇

个人vs企业：天壤之别的复杂度

当我们从个人使用转向企业级部署时，复杂度呈指数级增长：

个人使用场景：

• 用户：1个人


• 数据：个人文件和少量API


• 安全：基本的API密钥管理


• 管理：手动配置即可

企业级场景：

• 用户：数百到数千人


• 数据：敏感业务数据、客户信息、财务数据


• 安全：严格的合规要求、审计需求


• 管理：统一配置、权限控制、监控告警

从我参与的十几个企业AI项目来看，大家基本都会遇到这几个头疼的问题：

1. 数据安全这道坎

企业数据可不比个人文件，涉及客户隐私、商业机密，动不动就要符合GDPR、HIPAA这些法规。我见过一个金融客户，光是数据分类就搞了3个月，更别说传统的个人化MCP配置根本过不了合规这关。

2. 权限管理的平衡艺术

这个真的很难搞。不同部门、不同级别的人要访问的数据和工具都不一样。既要保证"最小权限原则"，又不能让用户觉得太麻烦。我之前遇到过一个案例，权限设置太严格，结果销售团队抱怨查个客户信息都要申请半天。

3. 成本控制的现实考验

这个问题往往被低估。当几百号人同时用AI工具时，API调用费用真的会让财务部门头疼。我见过一家公司，第一个月账单出来，CFO直接找到CTO问是不是系统被攻击了。

4. 运维管理的复杂度爆炸

分散部署最大的问题就是运维。每个团队都有自己的一套，出了问题谁来解决？性能怎么优化？我们之前有个客户，光是梳理现有的AI工具部署情况就花了两周时间。

MCP在企业环境中的价值主张

正是在这样的背景下，MCP的企业级价值才真正显现：

• 统一标准：一套协议解决所有AI工具集成问题


• 集中管理：统一的配置、监控、审计


• 安全可控：标准化的安全框架和权限管理


• 成本透明：集中的资源使用监控和成本分析

我们最近做了个小范围调研，发现用了统一MCP平台的几家企业，AI工具管理成本大概能降低50-70%，安全事件也确实少了很多。虽然样本不大，但趋势还是挺明显的。

📊 企业级需求分析：规模化部署的关键考量

在动手设计企业级MCP方案之前，我觉得最重要的是先搞清楚企业到底需要什么。这些年参与了十几个项目下来，我发现企业级MCP部署基本都绕不开这几个核心需求：

多团队协作需求

场景复杂性：

• 研发团队：需要访问代码仓库、CI/CD系统、Bug跟踪系统


• 销售团队：需要CRM系统、客户数据、销售报表


• 运营团队：需要监控系统、日志分析、业务指标


• 财务团队：需要ERP系统、财务报表、合规数据

每个团队的需求不同，但又需要在统一的安全框架下协作。

安全合规要求

企业级部署必须满足严格的安全合规要求：

性能和可用性要求

企业级应用对性能和可用性有严格要求：

• 可用性：99.9%以上（年停机时间<8.77小时）


• 响应时间：95%的请求在2秒内响应


• 并发能力：支持数千用户同时访问


• 数据一致性：确保跨系统数据同步

成本控制需求

企业需要精确的成本控制和预算管理：

• 成本透明：每个部门、每个项目的AI使用成本清晰可见


• 预算控制：设置使用上限，避免成本失控


• 优化建议：基于使用数据提供成本优化建议

🏗️ MCP企业级架构设计：构建统一工具平台

说到架构设计，我必须承认，刚开始接触企业级MCP时，我也走过不少弯路。最开始我想的太简单，以为把个人版的MCP放大就行了，结果第一个项目就翻车了——系统上线第三天就因为权限问题被安全部门叫停。

后来痛定思痛，我重新设计了一套分层的企业级MCP架构。这套架构现在已经在好几个项目中验证过了，既能应对复杂的业务需求，扩展性也不错。

整体架构方案

graph TB

    subgraph "用户层"

        A[Web界面] 

        B[IDE插件]

        C[移动应用]

        D[API接口]

    end

    

    subgraph "网关层"

        E[MCP网关]

        F[负载均衡器]

        G[API网关]

    end

    

    subgraph "服务层"

        H[认证服务]

        I[权限服务]

        J[MCP服务注册中心]

        K[配置管理中心]

    end

    

    subgraph "工具层"

        L[开发工具MCP服务器]

        M[数据工具MCP服务器]

        N[业务工具MCP服务器]

        O[监控工具MCP服务器]

    end

    

    subgraph "数据层"

        P[关系数据库]

        Q[文档数据库]

        R[缓存层]

        S[日志存储]

    end

    

    A --> E

    B --> E

    C --> E

    D --> G

    

    E --> F

    G --> F

    F --> H

    F --> I

    

    H --> J

    I --> J

    J --> K

    

    K --> L

    K --> M

    K --> N

    K --> O

    

    L --> P

    M --> Q

    N --> R

    O --> S

核心组件详解

1. MCP网关层

功能职责：

• 路由管理：智能路由请求到合适的MCP服务器


• 负载均衡：分发请求，确保系统稳定性


• 安全认证：统一的身份验证和授权


• 限流控制：防止系统过载，保护后端服务

核心特性：支持智能路由、负载均衡、限流控制和统一认证，确保系统稳定性和安全性。

2. 服务注册中心

核心功能：

• 服务发现：自动发现和注册MCP服务器


• 健康检查：实时监控服务器状态


• 配置同步：统一的配置管理和分发


• 版本管理：支持服务的灰度发布和回滚

技术要点：采用分布式注册中心架构，支持服务自动注册、健康检查和配置热更新。

3. 配置管理中心

管理内容：

• 服务器配置：MCP服务器的连接参数和功能配置


• 权限配置：用户和角色的权限矩阵


• 业务配置：各种业务规则和策略配置


• 环境配置：开发、测试、生产环境的差异化配置

高可用性设计

为确保企业级的可用性要求，架构中集成了多种高可用保障机制：

1. 多活部署

• 多个数据中心同时提供服务


• 自动故障切换，RTO < 30秒


• 数据实时同步，RPO < 5分钟

2. 弹性扩容

• 基于负载自动扩容


• 支持水平扩展和垂直扩展


• 预测性扩容，提前应对流量高峰

3. 容错机制

• 服务熔断，防止雪崩效应


• 优雅降级，保证核心功能可用


• 重试机制，处理临时性故障

🔐 安全架构设计：保障企业数据安全

在企业环境中，安全绝对不是可选项。这个教训我学得特别深刻——前面提到的那个翻车项目，就是因为我低估了企业对安全的要求。现在我设计MCP安全架构时，坚持用"纵深防御"策略，每一层都要有安全控制，宁可麻烦一点，也不能留安全隐患。

身份认证和授权体系

1. 多层次身份认证

graph LR

    A[用户登录] --> B[SSO认证]

    B --> C[MFA验证]

    C --> D[JWT Token]

    D --> E[API访问]

    

    B --> B1[LDAP/AD]

    B --> B2[OAuth2.0]

    B --> B3[SAML]

    

    C --> C1[短信验证码]

    C --> C2[TOTP]

    C --> C3[生物识别]

技术实现：集成主流SSO提供商（Azure AD、Okta、Google），支持多种MFA方式，采用JWT令牌管理会话。

2. 基于角色的访问控制（RBAC）

权限模型设计：

# 权限配置示例

roles:

  - name: developer

    permissions:

      - mcp:tools:code:read

      - mcp:tools:code:execute

      - mcp:resources:docs:read

    

  - name: data_analyst

    permissions:

      - mcp:tools:database:read

      - mcp:tools:analytics:execute

      - mcp:resources:data:read

    

  - name: admin

    permissions:

      - mcp:*:*:*  # 超级管理员权限



users:

  - username: john.doe

    roles: [developer]

    additional_permissions:

      - mcp:tools:deploy:execute  # 额外权限

数据安全保护

1. 端到端加密

• 传输加密：所有MCP通信使用TLS 1.3


• 存储加密：敏感数据AES-256加密存储


• 密钥管理：使用HSM或云KMS管理加密密钥

2. 数据脱敏和分类

核心功能：自动识别敏感数据类型（邮箱、手机、身-份-证等），根据预设规则进行脱敏处理，确保数据隐私保护。

网络安全防护

1. API网关安全策略

• DDoS防护：智能识别和阻断攻击流量


• WAF规则：防护SQL注入、XSS等常见攻击


• IP白名单：限制访问来源IP范围


• 请求限流：防止API滥用

2. 网络隔离

安全策略：采用DMZ、内部服务区、数据库区三层网络隔离，通过防火墙规则严格控制服务间通信。

审计日志和合规

1. 全链路审计

审计范围：记录所有MCP访问操作，包括用户身份、操作类型、访问资源、操作结果、IP地址等关键信息，确保操作可追溯。

2. 合规报告自动生成

• 访问报告：用户访问行为分析


• 权限报告：权限使用情况统计


• 异常报告：安全异常事件汇总


• 合规检查：自动化合规性检查

⚙️ 运维管理体系：确保稳定高效运行

运维这块儿，说实话是我最头疼的部分。技术方案设计得再好，如果运维跟不上，照样会出问题。我见过太多项目，前期开发得很顺利，上线后各种运维问题层出不穷。所以现在我做企业级MCP平台时，会把运维管理当作一个系统工程来对待，从部署、监控到优化，每个环节都要考虑周全。

自动化部署体系

1. CI/CD流水线设计

流水线阶段：测试→构建→部署开发环境→预发布→生产环境，每个阶段都包含自动化测试、安全扫描和质量检查。

2. 蓝绿部署和灰度发布

蓝绿部署策略：新版本部署到绿环境→健康检查→流量切换→清理旧环境，确保零停机部署。

监控告警系统

1. 多维度监控指标

监控维度：

• 业务指标：请求总数、成功率、响应时间、活跃用户数


• 系统指标：CPU、内存、磁盘使用率


• 成本指标：按请求计费、部门成本分摊

2. 智能告警系统

# Prometheus告警规则

groups:

  - name: mcp-platform

    rules:

      - alert: MCPHighErrorRate

        expr: rate(mcp_requests_failed_total[5m]) / rate(mcp_requests_total[5m]) > 0.05

        for: 2m

        labels:

          severity: critical

        annotations:

          summary: "MCP平台错误率过高"

          description: "过去5分钟MCP请求错误率超过5%"

          

      - alert: MCPHighLatency

        expr: histogram_quantile(0.95, rate(mcp_request_duration_seconds_bucket[5m])) > 2

        for: 5m

        labels:

          severity: warning

        annotations:

          summary: "MCP平台响应延迟过高"

          description: "95%的请求响应时间超过2秒"

          

      - alert: MCPServerDown

        expr: up{job="mcp-server"} == 0

        for: 1m

        labels:

          severity: critical

        annotations:

          summary: "MCP服务器宕机"

          description: "{{ $labels.instance }} MCP服务器无法访问"

成本优化管理

1. 成本监控和分析

成本分析功能：自动分析计算、存储、网络、API等各项成本，按部门分摊费用，并提供优化建议。

2. 自动扩缩容策略

# Kubernetes HPA配置

apiVersion: autoscaling/v2

kind: HorizontalPodAutoscaler

metadata:

  name: mcp-server-hpa

spec:

  scaleTargetRef:

    apiVersion: apps/v1

    kind: Deployment

    name: mcp-server

  minReplicas: 3

  maxReplicas: 50

  metrics:

  - type: Resource

    resource:

      name: cpu

      target:

        type: Utilization

        averageUtilization: 70

  - type: Resource

    resource:

      name: memory

      target:

        type: Utilization

        averageUtilization: 80

  - type: Pods

    pods:

      metric:

        name: mcp_requests_per_second

      target:

        type: AverageValue

        averageValue: "100"

🚀 实施路径和最佳实践

关于实施策略，我觉得最重要的一点是：千万别想着一步到位。我之前就犯过这个错误，想着一次性把所有功能都上线，结果搞得团队疲惫不堪，用户体验也很糟糕。现在我都是推荐分阶段实施，这套策略在好几个项目中都验证过了，确实比较靠谱。

分阶段实施计划

第一阶段：MVP验证（1-2个月）

目标：验证MCP在企业环境中的可行性

实施内容：

• 选择1-2个核心团队作为试点


• 部署基础的MCP服务器（文件系统、Git、简单API）


• 建立基本的安全和监控机制


• 收集用户反馈和性能数据

成功标准：

• 试点团队满意度 > 80%


• 系统可用性 > 99%


• 响应时间 < 2秒


• 零安全事件

第二阶段：功能扩展（2-3个月）

目标：扩展功能覆盖范围，优化用户体验

实施内容：

• 集成更多业务系统（CRM、ERP、数据库）


• 完善权限管理和审计功能


• 优化性能和稳定性


• 扩展到更多团队

成功标准：

• 覆盖50%以上的核心业务场景


• 用户数量增长3倍


• 平均响应时间减少30%


• 成本控制在预算范围内

第三阶段：全面推广（3-6个月）

目标：在全公司范围内推广使用

实施内容：

• 部署完整的企业级架构


• 建立完善的运维体系


• 开展全员培训


• 建立持续优化机制

成功标准：

• 全公司80%以上员工使用


• 系统可用性 > 99.9%


• 用户满意度 > 85%


• ROI > 200%

团队组织和协作

1. 核心团队构成

graph TB

    A[项目指导委员会] --> B[项目经理]

    B --> C[架构师]

    B --> D[开发团队]

    B --> E[运维团队]

    B --> F[安全团队]

    

    C --> C1[系统架构师]

    C --> C2[安全架构师]

    

    D --> D1[后端开发]

    D --> D2[前端开发]

    D --> D3[MCP服务器开发]

    

    E --> E1[DevOps工程师]

    E --> E2[监控工程师]

    

    F --> F1[安全工程师]

    F --> F2[合规专员]

2. 协作机制

定期会议制度：

• 周例会：项目进展同步和问题解决


• 月度评审：里程碑检查和计划调整


• 季度总结：成效评估和策略优化

文档管理：

• 架构文档：系统设计和技术规范


• 操作手册：部署和运维指南


• 用户指南：使用教程和最佳实践

风险控制和应急预案

1. 风险识别和评估

2. 应急响应流程

应急流程：故障分级→通知相关人员→启动应急响应→执行应急措施→跟踪处理进度→事后总结，确保快速响应和持续改进。

📈 案例研究：中大型企业MCP平台实践

说了这么多理论，我觉得还是用真实案例更有说服力。下面分享几个我亲身参与的项目，有成功的，也有踩坑的，希望对大家有帮助。

案例一：中型科技公司（800人规模）

公司背景：

• 行业：SaaS软件开发


• 规模：800名员工，15个研发团队


• 挑战：AI工具使用分散，成本控制困难

实施方案：

• 架构选择：单数据中心部署，微服务架构


• 核心功能：代码助手、文档管理、项目协作


• 安全措施：RBAC权限控制、API网关防护

实施效果：

实施前后对比:

  开发效率:

    before: "基线"

    after: "+35%"

    measurement: "功能交付速度"

    

  成本控制:

    before: "月成本$15,000"

    after: "月成本$12,000"

    savings: "20%"

    

  安全事件:

    before: "月均3起"

    after: "月均0.5起"

    reduction: "83%"

    

  用户满意度:

    before: "6.5/10"

    after: "8.7/10"

    improvement: "+34%"

关键成功因素：

案例二：大型金融机构（5000+人规模）

公司背景：

• 行业：银行业


• 规模：5000+名员工，严格合规要求


• 挑战：数据安全、合规审计、多地部署

实施方案：

• 架构选择：多活数据中心，容器化部署


• 核心功能：风险分析、客户服务、合规报告


• 安全措施：端到端加密、零信任架构

金融级安全要求：TLS 1.3传输加密、AES-256数据加密、HSM密钥管理、PCI-DSS/SOX合规、7年审计日志保留、本地化数据存储。

实施效果：

• 合规性：通过所有监管审计，零合规违规


• 效率提升：客户服务响应时间减少50%


• 成本节约：年度IT成本降低25%


• 风险控制：欺诈检测准确率提升40%

经验教训总结

通过这些案例，我们总结出企业级MCP实施的关键经验：

成功要素

常见陷阱

💡 写在最后：从失败到成功的思考

回想起那次项目失败，我现在反而挺感谢那次经历。它让我明白了一个道理：企业级MCP集成绝不是技术的简单堆砌，而是一个涉及人、流程、技术的复杂系统工程。

如果重新来过，我会这样做：

现在我参与的企业级MCP项目，成功率已经提升到90%以上。不是因为我的技术水平提高了多少，而是因为我学会了从企业的角度思考问题。

最好的架构不是最复杂的，而是最适合的。

如果你正在考虑为企业部署MCP平台，我的建议是：先找一个小团队试点，积累经验和信心，然后再考虑大规模推广。记住，每个企业都有自己的特色，别人的成功方案未必适合你。

🤔 互动时间

分享你的经验：

• 你的企业在AI工具集成方面遇到了什么挑战？


• 你觉得统一的AI工具平台对企业来说最大的价值是什么？


• 有没有类似的项目失败经历想要分享？

实践练习：

欢迎在评论区分享你的想法和经验，我会认真回复每一条评论。

📧 如果你正在规划企业级MCP项目，可以私信我，我很乐意分享更多实战经验和踩坑心得。

下期预告：《MCP最佳实践与性能优化》将深入探讨MCP使用过程中的优化技巧和故障排查方法，敬请期待！

关注专栏，获取更多MCP实战干货！

在 Java 开发领域，缓存机制的构建通常依赖于 Redis 等专业缓存数据库。这类解决方案虽能提供强大的缓存能力，但引入中间件意味着增加系统架构复杂度、部署成本与运维负担。本文将深入探讨一种轻量级替代方案 —— 基于 Java 原生Map实现的带过期时间的缓存机制。该方案无需引入外部工具，仅依托 Java 标准库即可快速搭建起缓存体系，特别适用于对资源占用敏感、架构追求极简的项目场景，为开发者提供了一种轻量高效的缓存数据管理新选择。

优点：

缺点：该方案存在明显局限性，即数据无法持久化。一旦应用程序停止运行，缓存中的所有数据都会丢失。相较于 Redis 等具备持久化功能的专业缓存数据库，在需要长期保存缓存数据，或是应对应用重启后数据恢复需求的场景下，基于 Java 原生Map的缓存机制就显得力不从心。

代码实现

package com.sunny.utils;



import java.util.Iterator;

import java.util.Map;

import java.util.concurrent.ConcurrentHashMap;

import java.util.concurrent.Executors;

import java.util.concurrent.ScheduledExecutorService;

import java.util.concurrent.TimeUnit;



public class SysCache {



    // 单例实例

    private static class Holder {

        private static final SysCache INSTANCE = new SysCache();

    }



    public static SysCache getInstance() {

        return Holder.INSTANCE;

    }



    // 缓存存储结构，Key为String，Value为包含值和过期时间的CacheEntry对象

    private final ConcurrentHashMap<String, CacheEntry> cacheMap = new ConcurrentHashMap<>();

    // 定时任务执行器

    private final ScheduledExecutorService  scheduledExecutorService;



    // 私有构造方法，初始化定时清理任务

    private SysCache() {

        scheduledExecutorService = Executors.newSingleThreadScheduledExecutor();

        // 每隔1秒执行一次清理任务

        scheduledExecutorService.scheduleAtFixedRate(this::cleanUp, 1, 1, TimeUnit.SECONDS);

        // 注册JVM关闭钩子以优雅关闭线程池

        Runtime.getRuntime().addShutdownHook(new Thread(this::shutdown));

    }



    /**

     * 存入缓存

     * @param key 键

     * @param value 值

     */

    public void set(String key, Object value){

        cacheMap.put(key, new CacheEntry(value, -1));

    }



    /**

     * 存入缓存

     * @param key 键

     * @param value 值

     * @param expireTime 过期时间，单位毫秒

     */

    public void set(String key, Object value, long expireTime) {

        if (expireTime <= 0) {

            throw new IllegalArgumentException("expireTime must be greater than 0");

        }

        cacheMap.put(key, new CacheEntry(value, System.currentTimeMillis() + expireTime));

    }



    /**

     * 删除缓存

     * @param key 键

     */

    public void remove(String key) {

        cacheMap.remove(key);

    }



    /**

     * 缓存中是否包含键

     * @param key 键

     */

    public boolean containsKey(String key) {

        CacheEntry cacheEntry = cacheMap.get(key);

        if (cacheEntry == null) {

            return false;

        }

        if (cacheEntry.getExpireTime() < System.currentTimeMillis()) {

            remove(key);

            return false;

        }

        return true;

    }





    /**

     *获取缓存值

     * @param key 键

     */

    public Object get(String key) {

        CacheEntry cacheEntry = cacheMap.get(key);

        if (cacheEntry == null) {

            return null;

        }

        if (cacheEntry.getExpireTime() < System.currentTimeMillis()) {

            cacheMap.remove(key);

            return null;

        }

        return cacheEntry.getValue();

    }





    private static class CacheEntry {

        private final Object value;

        private final long expireTime;



        public CacheEntry(Object value, long expireTime) {

            this.value = value;

            this.expireTime = expireTime;

        }



        public Object getValue() {

            return value;

        }



        public long getExpireTime() {

            return expireTime;

        }

    }



    /**

     * 定时清理过期条目

     */

    private void cleanUp() {

        Iterator<Map.Entry<String, CacheEntry>> iterator = cacheMap.entrySet().iterator();

        long currentTime = System.currentTimeMillis();

        while (iterator.hasNext()) {

            Map.Entry<String, CacheEntry> entry = iterator.next();

            CacheEntry cacheEntry = entry.getValue();

            if (cacheEntry.expireTime < currentTime) {

                // 使用iterator移除当前条目，避免ConcurrentModificationException

                iterator.remove();

            }

        }

    }



    /**

     * 关闭线程池释放资源

     */

    private void shutdown() {

        scheduledExecutorService.shutdown();

        try {

            if (!scheduledExecutorService.awaitTermination(5, TimeUnit.SECONDS)) {

                scheduledExecutorService.shutdownNow();

            }

        } catch (InterruptedException e) {

            scheduledExecutorService.shutdownNow();

            Thread.currentThread().interrupt();

        }

    }

}

测试

如上图，缓存中放入一个值，过期时间为5秒，每秒循环获取1次，循环10次，过期后，获取的值为null

共用css

body {

    padding: 50px;

    background-color: black;

    color: white;

}



svg {

    --text_fill: orange;

    --svg_width: 120px;

    --svg_height: 40px;

    width: var(--svg_width);

    height: var(--svg_height);

    cursor: pointer;

    /* 创建图层 */

    will-change: transform;



    &:hover {

        --text_fill: #fed71a;

    }



    text {

        fill: var(--text_fill);

        font-size: 1rem;

        transform: translate(50%, 50%);

        text-anchor: middle;

        dominant-baseline: middle;

        stroke: yellowgreen;

        stroke-width: .5px;

        cursor: pointer;

    }



    rect {

        --stroke_width: 4px;

        width: calc(var(--svg_width) - var(--stroke_width));

        height: calc(var(--svg_height) - var(--stroke_width));

        stroke-width: var(--stroke_width);

        rx: calc(var(--svg_height)/2);

        x: calc(var(--stroke_width)/2);

        y: calc(var(--stroke_width)/2);

        fill: none;

        cursor: pointer;

    }

}

移入执行、移出暂停

<body>

    <svg style='position:absolute;left:-9999px;width:0;height:0;visibility:hidden;'>

        <defs>

            <linearGradient id='strokeColor1' x1='0%' y1='0%' x2='100%' y2='0%'>

                <stop offset='0%' stop-color="#00ccff" stop-opacity="1" />

                <stop offset='50%' stop-color="#d400d4" stop-opacity="1" />

                <stop offset='100%' stop-color="#ff00ff" stop-opacity=".7" />

            </linearGradient>

        </defs>

    </svg>



    <svg id="svg1">

        <text>渐变按钮</text>

        <rect stroke='url(#strokeColor1)' />

        <animateTransform id="ani1" href="#strokeColor1" attributeName='gradientTransform' dur='5s' type="rotate"

            form="0,.5,.5" to="360,.5,.5" repeatCount='indefinite' begin="indefinite" />

    </svg>

</body> 

<script>

    svg1.addEventListener('mouseover', function () {

        if (!this.beginMark) {

            ani1.beginElement();

            this.beginMark = true;

            return;

        }

        this.unpauseAnimations();

    })



    svg1.addEventListener('mouseleave', function () {

        this.pauseAnimations();

    })

</script>

svg1效果图

移入暂停、移出执行

<body>

    <svg style='position:absolute;left:-9999px;width:0;height:0;visibility:hidden;'>

        <defs>

            <linearGradient id='strokeColor2' x1='0%' y1='0%' x2='100%' y2='0%'>

                <stop offset='0%' stop-color="#ec261b" />

                <stop offset='50%' stop-color="#ff9f43" />

                <stop offset='100%' stop-color="#ffe66d" stop-opacity="1" />

            </linearGradient>

        </defs>

    </svg>



    <svg id="svg2">

        <text>渐变按钮</text>

        <rect stroke='url(#strokeColor2)' />

        <animateTransform id="ani2" href="#strokeColor2" attributeName='gradientTransform' dur='5s' type="rotate"

            form="0,.5,.5" to="360,.5,.5" repeatCount='indefinite' begin="0s" />

    </svg>

</body>



<script>

    svg2.addEventListener('mouseover', function () {

        this.pauseAnimations();

    })

    svg2.addEventListener('mouseleave', function () {

        this.unpauseAnimations();

    })

</script>

sv2效果图

总结

个人感觉svg实现渐变边框相比较css的实现来说，相对代码量更大一些，但是svg其实还有很多好玩的地方。
用svg来做渐变边框也是另外的一种思路，也许以后能够用的上。

css按钮渐变边框

sorted() 函数的基本语法

sorted(iterable, key=, reverse=False)

• iterable: 要排序的可迭代对象（列表、元组、字符串等）


• key: 可选，指定排序的依据函数


• reverse: 可选，True 为降序，False 为升序（默认）

基本用法

简单排序

# 数字排序

numbers = [3, 1, 4, 1, 5, 9, 2, 6]

print(sorted(numbers))  

# 输出: [1, 1, 2, 3, 4, 5, 6, 9]



# 字符串排序

names = ['Alice', 'Bob', 'Charlie', 'David']

print(sorted(names))  

# 输出: ['Alice', 'Bob', 'Charlie', 'David']



# 字符排序

chars = ['z', 'a', 'x', 'b']

print(sorted(chars))  

# 输出: ['a', 'b', 'x', 'z']

降序排序

numbers = [3, 1, 4, 1, 5, 9, 2, 6]

print(sorted(numbers, reverse=True))  # 输出: [9, 6, 5, 4, 3, 2, 1, 1]

示例解析

traveler_ids = [('USA', '31195855'), ('BRA', 'CE342567'), ('ESP', 'XDA205856')]

for passport in sorted(traveler_ids):

    print('%s/%s' % passport)



# 输出:

# BRA/CE342567

# ESP/XDA205856  

# USA/31195855

解析: 对于元组列表，sorted() 默认按第一个元素排序，如果第一个元素相同，则按第二个元素排序，以此类推。

使用 key 参数进行自定义排序

按字符串长度排序

words = ['python', 'java', 'javascript', 'go', 'rust']

print(sorted(words, key=len))  

# 输出: ['go', 'java', 'rust', 'python', 'javascript']

按照绝对值排序

numbers = [-5, -1, 0, 1, 3, -2]

print(sorted(numbers, key=abs))  

# 输出: [0, -1, 1, -2, 3, -5]

按照元祖的特定循序排序

# 按第二个元素排序

students = [('Alice', 85), ('Bob', 92), ('Charlie', 78)]

print(sorted(students, key=lambda x: x[1]))  # 输出: [('Charlie', 78), ('Alice', 85), ('Bob', 92)]



# 按第一个元素的长度排序

traveler_ids = [('USA', '31195855'), ('BRA', 'CE342567'), ('ESP', 'XDA205856')]

print(sorted(traveler_ids, key=lambda x: len(x[0])))  # 输出: [('USA', '31195855'), ('BRA', 'CE342567'), ('ESP', 'XDA205856')]

复杂排序示例

多级排序

# 先按年龄排序，年龄相同时按姓名排序

people = [

    ('Alice', 25, 'Engineer'),

    ('Bob', 30, 'Doctor'),

    ('Charlie', 25, 'Teacher'),

    ('David', 30, 'Engineer')

]



# 按年龄升序，然后按姓名升序

sorted_people = sorted(people, key=lambda x: (x[1], x[0]))

print(sorted_people)

# 输出: [('Alice', 25, 'Engineer'), ('Charlie', 25, 'Teacher'), ('Bob', 30, 'Doctor'), ('David', 30, 'Engineer')]

字符串忽略大小写排序

names = ['alice', 'Bob', 'CHARLIE', 'david']

print(sorted(names))  

# 输出: ['CHARLIE', 'Bob', 'alice', 'david'] (按ASCII码)

print(sorted(names, key=str.lower))  

# 输出: ['alice', 'Bob', 'CHARLIE', 'david'] (忽略大小写)

自定义排序规则

def custom_sort_key(item):

    """自定义排序：数字优先，然后按字母顺序"""

    if item.isdigit():

        return (0, int(item))  # 数字类型，按数值排序

    else:

        return (1, item.lower())  # 字母类型，按字母顺序



data = ['z', '10', 'a', '2', 'B', '1']

print(sorted(data, key=custom_sort_key))  # 输出: ['1', '2', '10', 'a', 'B', 'z']

排序复杂数据结构

字典列表排序

students = [

    {'name': 'Alice', 'grade': 85, 'age': 20},

    {'name': 'Bob', 'grade': 92, 'age': 19},

    {'name': 'Charlie', 'grade': 78, 'age': 21}

]



# 按成绩排序

print(sorted(students, key=lambda x: x['grade']))

# 按年龄排序

print(sorted(students, key=lambda x: x['age']))

# 按姓名排序

print(sorted(students, key=lambda x: x['name']))

使用 operator 模块

from operator import itemgetter, attrgetter



# 对字典列表排序

students = [

    {'name': 'Alice', 'grade': 85},

    {'name': 'Bob', 'grade': 92},

    {'name': 'Charlie', 'grade': 78}

]



# 使用 itemgetter 替代 lambda

print(sorted(students, key=itemgetter('grade')))

# 等同于: sorted(students, key=lambda x: x['grade'])



# 多字段排序

print(sorted(students, key=itemgetter('grade', 'name')))

解决 Python requests.post() 返回 406 错误

HTTP 406 "Not Acceptable" 错误表示服务器无法生成符合客户端请求中 Accept 头部指定的响应内容。

问题分析，最好的方法还是一段代码一段代码的调试

今天是模型一个登录的脚本，以前都用得好好的，现在突然不行了，出现了406的错误，觉得有点奇怪，代码如下：

header = {'Content-Type':'application/x-www-form-urlencoded',

'User-Agent':'Mozilla/5.0 (Macint0sh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36'



form_data = {

    "actionFlag":"login",

    "uid":"xxxxx",

    "password":"xxxxx"

}



data = parse.urlencode(from_data)

response = request.post(url=login_url,header=header, data = data, verify=False)

以前上面这段代码是没有什么问题的，但最近才发现一直是406，跟踪到代码中的
sessions.py中adapter的值是对的，上面是显示访问成功而且返回值是200，这说明访问代码是没有问题的，但什么时候出的问题呢？继续往下

发现了这一段代码，其中allow_redirects的值就有点意思了，这个值的默认值是Ture，但我们登录后，后面肯定有一个redirect的，也就是说后面那个跳转的地址有问题了，所以才会导致出问题

所以只需要将这个参数设计为false就正常了

allow_redirects=False

下面是我解决问题时用deepseek查问题时，出现的一些总结，也不能说它全部不对，但也是由于这个让我有了一些思路，所以放上来，大家参考一下也是好了。

常见原因及解决方案

1. 请求头 (headers) 问题

确保你的请求头中包含正确的 Accept 和 Content-Type：

python

headers = {

    'Accept': 'application/json',  # 或其他服务器期望的类型

    'Content-Type': 'application/json',  # 或其他适当的内容类型

    # 其他必要的头部，如授权信息

}

2. 数据格式问题

确保发送的数据格式与 Content-Type 头部匹配：

python

import json



data = {'key': 'value'}

response = requests.post(url, data=json.dumps(data), headers=headers)

或者使用 json 参数自动处理：

python

response = requests.post(url, json=data, headers=headers)

3. 用户代理问题

有些服务器要求特定的 User-Agent：

python

headers = {

    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) ...',

    # 其他头部

}

4. 认证问题

如果 API 需要认证，确保提供了正确的凭证：

python

headers = {

    'Authorization': 'Bearer your_token_here',

    # 其他头部

}

5. 服务器端限制

检查 API 文档，确认：

• 是否支持 POST 方法


• 是否接受你发送的内容类型


• 是否有其他特殊要求

完整示例

python

import requests

import json



url = 'https://api.example.com/endpoint'

headers = {

    'Accept': 'application/json',

    'Content-Type': 'application/json',

    'User-Agent': 'MyApp/1.0',

    'Authorization': 'Bearer abc123...'

}

data = {'key1': 'value1', 'key2': 'value2'}



try:

    response = requests.post(url, json=data, headers=headers)

    response.raise_for_status()  # 如果响应状态码不是200，抛出异常

    print(response.json())

except requests.exceptions.RequestException as e:

    print(f"请求失败: {e}")

如果问题仍然存在，建议：

大家好呀，我是猿java。

String.replace()是我们日常开发中经常用到的一个方法，那么，你有看过其底层的源码实现吗？你知道String.replace()是如何工作的吗？String.replace()的性能到底怎么样？这篇文章我们来深入地分析。

在开始今天的问题之前，让我们先来看一个问题：

String original = "Hello, World!";

// 替换字符

String result = original.replace('World', 'Java');

original.replace('World', 'Java')，是把 original的内容直接修改成Hello, Java了，还是重新生成了一个 Hello, Java的 String并返回？

1. String.replace()是什么？

String.replace()位于java.lang包中，它是 Java中的一个重要方法，用于替换字符串中的某些字符或子字符串。以下String.replace()的源码截图。

String.replace()方法用于替换字符串中的某些字符或子字符串。它有多个重载版本，常见的有：

// 用于替换单个字符

public String replace(char oldChar, char newChar);

// 用于替换子字符串

public String replace(CharSequence target, CharSequence replacement);

下面是一个简单的示例，演示了replace方法的用法：

public class ReplaceExample {

    public static void main(String[] args) {

        String original = "Hello, World!";

        

        // 替换字符

        String replacedChar = original.replace('o', 'a');

        System.out.println(replacedChar); // 输出: "Hella, Warld!"

        

        // 替换子字符串

        String replacedString = original.replace("World", "Java");

        System.out.println(replacedString); // 输出: "Hello, Java!"

    }

}

在上面的例子中，我们演示了如何使用replace方法替换字符和子字符串。需要注意的是，String对象在Java中是不可变的（immutable），因此replace方法会返回一个新的字符串，而不会修改原有字符串。

2. 源码分析

上述示例，我们演示了replace方法的用法，接下来，我们来分析下replace方法的实现原理。

2.1 String的不可变性

Java中的String类是不可变的，这意味着一旦创建了一个String对象，其内容不能被改变。这样的设计有助于提高性能和安全性，尤其在多线程环境下。String源码说明如下：

2.2 replace()工作原理

让我们深入了解replace方法的内部实现。以replace(CharSequence target, CharSequence replacement)为例，以下是其基本流程：

2.3 源码解析

让我们看一下String类中replace方法的源码（简化版）：

public String replace(char oldChar, char newChar) {

   if (oldChar != newChar) {

      String ret = isLatin1() ? StringLatin1.replace(value, oldChar, newChar)

              : StringUTF16.replace(value, oldChar, newChar);

      if (ret != null) {

         return ret;

      }

   }

   return this;

}







public String replace(CharSequence target, CharSequence replacement) {

   String tgtStr = target.toString();

   String replStr = replacement.toString();

   int j = indexOf(tgtStr);

   if (j < 0) {

      return this;

   }

   int tgtLen = tgtStr.length();

   int tgtLen1 = Math.max(tgtLen, 1);

   int thisLen = length();



   int newLenHint = thisLen - tgtLen + replStr.length();

   if (newLenHint < 0) {

      throw new OutOfMemoryError();

   }

   StringBuilder sb = new StringBuilder(newLenHint);

   int i = 0;

   do {

      sb.append(this, i, j).append(replStr);

      i = j + tgtLen;

   } while (j < thisLen && (j = indexOf(tgtStr, j + tgtLen1)) > 0);

   return sb.append(this, i, thisLen).toString();

}

解析步骤

性能考虑

由于String的不可变性，每次修改都会创建新的String对象。如果需要进行大量的字符串替换操作，推荐使用StringBuilder或StringBuffer来提高性能。

三、实际示例演示

接下来，我们将通过几个实际的例子，来更好地理解String.replace()的使用场景和效果。

示例1：替换字符

public class ReplaceCharDemo {

    public static void main(String[] args) {

        String text = "banana";

        String result = text.replace('a', 'o');

        System.out.println(result); // 输出: "bonono"

    }

}

解释：将所有的'a'替换为'o'，得到"bonono"。

示例2：替换子字符串

public class ReplaceStringDemo {

    public static void main(String[] args) {

        String text = "I love Java. Java is versatile.";

        String result = text.replace("Java", "Python");

        System.out.println(result); // 输出: "I love Python. Python is versatile."

    }

}

解释：将所有的"Java"替换为"Python"，结果如上所示。

示例3：替换多个不同的子字符串

有时，我们可能需要在一个字符串中替换多个不同的子字符串。例如，将文中的标点符号替换为空格：

public class ReplaceMultipleDemo {

    public static void main(String[] args) {

        String text = "Hello, World! Welcome to Java.";

        String result = text.replace(",", " ")

                            .replace("!", " ")

                            .replace(".", " ");

        System.out.println(result); // 输出: "Hello  World  Welcome to Java "

    }

}

解释：通过链式调用replace方法，依次将,、!和.替换为空格。

示例4：替换不匹配的情况

public class ReplaceNoMatchDemo {

    public static void main(String[] args) {

        String text = "Hello, World!";

        String result = text.replace("Python", "Java");

        System.out.println(result); // 输出: "Hello, World!"

    }

}

解释：由于"Python"在原字符串中不存在，replace方法不会做任何替换，直接返回原字符串。

四、String.replace()的技术架构图

虽然文字描述已能帮助我们理解replace方法的工作原理，但通过一个简化的技术架构图，可以更直观地抓住其核心流程。

+---------------------------+

|        String对象         |

| "Hello, World!"           |

+------------+--------------+

             |

             | 调用replace("World", "Java")

             v

+---------------------------+

|   搜索目标子字符串 "World" |

+------------+--------------+

             |

             | 找到位置 7

             v

+---------------------------+

| 构建新的字符串 "Hello, Java!" |

+---------------------------+

             |

             | 返回新字符串

             v

+---------------------------+

|      新的 String对象      |

| "Hello, Java!"            |

+---------------------------+

图解说明

五、总结

通过本文的介绍，相信你对Java中String.replace()方法有了更深入的理解。从基本用法到内部原理，再到实际应用示例，每一步都帮助你全面掌握这个重要的方法。

记住，String的不可变性设计虽然带来了安全性和线程安全性，但在频繁修改字符串时，可能影响性能。因此，合理选择使用String还是StringBuilder，根据具体场景优化代码，是每个Java开发者需要掌握的技能。

希望这篇文章能对你在Java编程的道路上提供帮助。如果有任何疑问或更多的讨论，欢迎在评论区留言！

8. 学习交流

如果你觉得文章有帮助，请帮忙转发给更多的好友，或关注公众号：猿java，持续输出硬核文章。

上个月在 趣谈AI 发布了我实现的多维表格1.0版本，没有用到任何第三方组件，完全组件化设计。最近对多维表格进行了进一步的升级优化，满打满算花了接近3个月时间，累计代码接近1w行。

接下来就和大家聊聊我做的 flowmix/mute多维表格 的核心功能和技术实现。

核心功能介绍

1. 多视图模式

目前多维表格支持多种视图模式：表格视图，看板视图，人员分配视图。用户可以轻松在不同视图下切换并进行可视化操作数据。

2. 多条件筛选功能

我们可以基于不同维度进行筛选和排序，并支持组合筛选。

3. 多维度分组功能

表格视图中，我们可以基于用户，优先级，状态，对数据进行分组管理，提高表格数据的查看效率。

4. 表格字段管理功能

多维表格中不仅支持字段的管理控制，同时还支持添加自定义字段：

5. 表格行列支持自定义拖拽排序功能

表格我们不仅仅支持列的宽度拖拽，还支持拖拽调整列的排序，同时表格的行也支持拖拽，可以跨分组进行拖拽，也支持在组内进行拖拽排序，极大的提高了数据管理的效率。

6. 表格支持一键编辑

我们可以在菜单按钮中开启编辑模式，也可以双击编辑单元格一键编辑表格内容，同时大家还可以进行扩展。

7. 表格支持一键转换为可视化分析视图表

我们可以将表格数据转换为可视化分析图表，帮助管理者更好地掌握数据动向。

8. 表格支持一键导入任务数据

目前多维表格支持导出和导入json数据，并一键渲染为多维表格。技术实现多维表格的设计我采用了组件化的实现的方式， 并支持数据持久化，具体使用如下：

<div className="flex-1 bg-gray-50">

    {currentView === "tasks" && <TaskManagementTable sidebarOpen={sidebarOpen} setSidebarOpen={setSidebarOpen} />}

    {currentView === "statistics" && <StatisticsView />}

    {currentView === "documentation" && <DocumentationView />}

    {currentView === "assignment" && <AssignmentView />}

    {currentView === "deployment" && <DeploymentView />}

</div>

在开发多维表格的过程中其实需要考虑很多复杂逻辑，比如表格用什么方式渲染，如何优化表格性能，如何实现表格的列排序，行排序，表格编辑等。传统表格组件大多基于div模拟行列，虽然灵活但渲染性能差。所以可以做如下优化：

• 虚拟滚动当数据量超过 500 行时，启用虚拟滚动机制，仅渲染可见区域的 DOM 节点，内存占用降低 70%；


• 行列冻结通过固定定位position: sticky实现表头和固定列冻结，解决大数据表格的滚动迷失问题；


• 异步加载采用Intersection Observer监听表格滚动事件，动态加载可视区域外的数据，避免一次性请求全量数据。

接下来分享一下简版的虚拟滚动的实现方案：

// 虚拟滚动核心代码（简化版）

function renderVirtualTable(data, visibleHeight) {

  const totalRows = data.length;

  const rowHeight = 40; // 行高固定

  const visibleRows = Math.ceil(visibleHeight / rowHeight);

  const startIndex = scrollTop / rowHeight | 0;

  const endIndex = startIndex + visibleRows;

  // 渲染可见区域数据

  const fragment = document.createDocumentFragment();

  for (let i = startIndex; i < endIndex; i++) {

    const row = document.createElement('tr');

    row.innerHTML = data[i].cells.map(cell => `<td>${cell.value}</td>`).join('');

    fragment.appendChild(row);

  }

  // 更新滚动条高度和偏移量

  table.scrollHeight = totalRows * rowHeight;

  table.innerHTML = `<thead>${header}</thead><tbody>${fragment}</tbody>`;

}

对于大表格数据量需要在本地缓存，所以需要设计表格数据的缓存处理逻辑，目前我采用的是hooks的实现方案，具体实现如下：

import { useState, useEffect } from "react"

export function useLocalStorage<T>(key: string, initialValue: T): [T, (value: T | ((val: T) => T)) => void] {

  // 初始化状态

  const [storedValue, setStoredValue] = useState<T>(() => {

    try {

      // 获取本地存储中的值

      if (typeof window === "undefined") {

        return initialValue

      }

      const item = window.localStorage.getItem(key)

      // 解析存储的JSON或返回初始值

      return item ? JSON.parse(item) : initialValue

    } catch (error) {

      // 如果出错，返回初始值

      console.error(`Error reading localStorage key "${key}":`, error)

      return initialValue

    }

  })

  // 返回一个包装版本的 useState setter 函数

  // 将新值同步到 localStorage

  const setValue = (value: T | ((val: T) => T)) => {

    try {

      // 允许值是一个函数

      const valueToStore = value instanceof Function ? value(storedValue) : value

      // 保存到 state

      setStoredValue(valueToStore)

      // 保存到 localStorage

      if (typeof window !== "undefined") {

        window.localStorage.setItem(key, JSON.stringify(valueToStore))

      }

    } catch (error) {

      console.error(`Error setting localStorage key "${key}":`, error)

    }

  }

  // 监听其他标签页的变化

  useEffect(() => {

    const handleStorageChange = (e: StorageEvent) => {

      if (e.key === key && e.newValue) {

        try {

          setStoredValue(JSON.parse(e.newValue))

        } catch (error) {

          console.error(`Error parsing localStorage item "${key}":`, error)

        }

      }

    }

    // 添加事件监听器

    if (typeof window !== "undefined") {

      window.addEventListener("storage", handleStorageChange)

    }

    // 清理事件监听器

    return () => {

      if (typeof window !== "undefined") {

        window.removeEventListener("storage", handleStorageChange)

      }

    }

  }, [key])

  return [storedValue, setValue]

}

其实在实现多维表格的过程中，我也调研了很多开源的方案，但是对于扩展性，灵活度和功能复杂度上，都略显简单，所以我才考虑花时间来实现这款多维表格方案。另一个比较复杂的逻辑是表格的列拖拽和排序，我们需要对可展开折叠的表格支持排序和拖拽，并保持优秀的用户体验：

技术实现如下：

import { useState, useEffect } from "react"

export function useLocalStorage<T>(key: string, initialValue: T): [T, (value: T | ((val: T) => T)) => void] {

  // 初始化状态

  const [storedValue, setStoredValue] = useState<T>(() => {

    try {

      // 获取本地存储中的值

      if (typeof window === "undefined") {

        return initialValue

      }

      const item = window.localStorage.getItem(key)

      // 解析存储的JSON或返回初始值

      return item ? JSON.parse(item) : initialValue

    } catch (error) {

      // 如果出错，返回初始值

      console.error(`Error reading localStorage key "${key}":`, error)

      return initialValue

    }

  })

  // 返回一个包装版本的 useState setter 函数

  // 将新值同步到 localStorage

  const setValue = (value: T | ((val: T) => T)) => {

    try {

      // 允许值是一个函数

      const valueToStore = value instanceof Function ? value(storedValue) : value

      // 保存到 state

      setStoredValue(valueToStore)

      // 保存到 localStorage

      if (typeof window !== "undefined") {

        window.localStorage.setItem(key, JSON.stringify(valueToStore))

      }

    } catch (error) {

      console.error(`Error setting localStorage key "${key}":`, error)

    }

  }

  // 监听其他标签页的变化

  useEffect(() => {

    const handleStorageChange = (e: StorageEvent) => {

      if (e.key === key && e.newValue) {

        try {

          setStoredValue(JSON.parse(e.newValue))

        } catch (error) {

          console.error(`Error parsing localStorage item "${key}":`, error)

        }

      }

    }

    // 添加事件监听器

    if (typeof window !== "undefined") {

      window.addEventListener("storage", handleStorageChange)

    }

    // 清理事件监听器

    return () => {

      if (typeof window !== "undefined") {

        window.removeEventListener("storage", handleStorageChange)

      }

    }

  }, [key])

  return [storedValue, setValue]

}

多维表格还支持多种视图的转换，比如可以将表格视图一键转换为可视化分析图表：

对用户和团队进行多维度的数据分析。技术实现如下：

import { PieChart, Pie, Cell, Tooltip, Legend, ResponsiveContainer } from "recharts"

import type { Task } from "@/lib/types"

interface PriorityDistributionChartProps {

  tasks: Task[]

}

export function PriorityDistributionChart({ tasks }: PriorityDistributionChartProps) {

  // 计算每个优先级的任务数量

  const priorityCounts: Record<string, number> = {}

  tasks.forEach((task) => {

    const priority = task.priority || "未设置"

    priorityCounts[priority] = (priorityCounts[priority] || 0) + 1

  })

  // 转换为图表数据格式

  const chartData = Object.entries(priorityCounts).map(([priority, count]) => ({

    priority,

    count,

  }))

  // 为不同优先级设置不同颜色

  const COLORS = ["#FF8042", "#FFBB28", "#00C49F", "#0088FE"]

  return (

    <div className="w-full h-[300px]">

      <ResponsiveContainer width="100%" height="100%">

        <PieChart>

          <Pie

            data={chartData}

            cx="50%"

            cy="50%"

            labelLine={true}

            outerRadius={80}

            fill="#8884d8"

            dataKey="count"

            nameKey="priority"

            label={({ priority, percent }) => `${priority}: ${(percent * 100).toFixed(0)}%`}

          >

            {chartData.map((entry, index) => (

              <Cell key={`cell-${index}`} fill={COLORS[index % COLORS.length]} />

            ))}

          </Pie>

          <Tooltip formatter={(value, name, props) => [`${value} 个任务`, props.payload.priority]} />

          <Legend />

        </PieChart>

      </ResponsiveContainer>

    </div>

  )

}

项目的体验地址：mute.turntip.cn

如果大家有好的想法，欢迎评论区留言反馈～

更新方式

定时更新（默认）

执行以下命令后，Watchtower 会在后台每 24 小时自动检查并更新所有运行中的容器：

docker run -d \

  --name watchtower \

  -v /var/run/docker.sock:/var/run/docker.sock \

  containrrr/watchtower

手动立即更新

添加 --run-once 参数启动临时容器，检查更新后自动退出，适合按需触发：

docker run --rm \

  -v /var/run/docker.sock:/var/run/docker.sock \

  containrrr/watchtower --run-once

更新指定容器

在命令末尾添加需要监控的容器名称，多个容器用空格分隔。例如仅监控 nginx 和 redis 容器：

docker run -d \

  --name watchtower \

  -v /var/run/docker.sock:/var/run/docker.sock \

  containrrr/watchtower nginx redis

简化命令

手动更新时，如果使用上面的命令未免太麻烦了，所以我们可以将更新命令设置为别名：

将下面的命令放到对应shell的环境文件中（比如bash对应~/.bashrc，zsh对应~/.zshrc）

alias update-container="docker run --rm -v /var/run/docker.sock:/var/run/docker.sock containrrr/watchtower --run-once"

编辑完环境文件后，重新打开命令窗口，或使用source ~/.bashrc或source ~/.zshrc加载命令。
然后就可以通过下面的方式更新容器了：

update-container 容器标识

比如：

update-container nginx-ui-latest

用了 Bun 之后，并不是完全不用 Vite。Bun 虽然内置了打包器和运行时，且速度非常快，但其打包功能目前还不够完善，缺少对前端项目非常重要的功能，比如对代码分块（chunk splitting）的精细控制和开发服务器（dev server）支持，这些都是 Vite 在前端开发中非常关键的优势

具体来说：

• Bun 是一个高性能的 JavaScript 运行时和包管理器，集成了打包器和测试工具，适合全栈开发和快速安装依赖，但其前端打包功能还处于实验阶段，缺少灵活的代码拆分和热更新支持


• Vite 专注于前端开发体验，提供极快的冷启动和热模块替换（HMR），以及灵活且成熟的生产构建流程，它的生态和插件系统也非常丰富，适合现代前端框架（如 Vue3、React）


• 目前推荐的做法是用 Bun 替代 Node.js 作为运行时和包管理器，用 Vite 负责前端的开发服务器和构建打包。这样可以结合 Bun 的高速安装和执行优势，以及 Vite 的快速开发反馈和优化生产构建的能力

关于 pnpm 和 Vite 的叠加：

• pnpm 是一个高效且节省磁盘空间的包管理器，完全可以和 Vite 一起使用。pnpm 通过内容寻址存储和符号链接机制，避免依赖重复，提升安装速度和项目管理效率，特别适合 monorepo 和多项目共享依赖的场景


• pnpm 和 Vite 的结合非常常见，pnpm 负责依赖管理，Vite 负责开发和构建，两者互不冲突，反而能互补提升开发效率

总结：

因此，用了 Bun 后，建议继续用 Vite 负责前端开发和构建，pnpm 依然可以用来管理依赖，三者结合能发挥各自优势，提升开发体验和性能

如果你想快速上手，可以用 Bun 创建 Vite 项目：

bun create vite my-app

cd my-app

bun install

bun run dev

这样就用 Bun 作为运行时和包管理器，用 Vite 作为开发服务器和构建工具

综上，Bun 目前还不能完全替代 Vite，Vite 在前端开发体验和构建优化上仍有不可替代的优势；pnpm 作为包管理器可以和 Vite 叠加使用，带来依赖管理的高效和节省空间的好处。三者结合是现代前端项目的一个高效组合方案。

用了next.js之后，是不是就不用vite了

用了 Next.js 之后，一般情况下是不需要再单独使用 Vite 了，因为 Next.js 内部已经集成了自己的构建和开发服务器功能。

具体原因和分析如下：

• Next.js 是一个基于 React 的全栈框架，内置了开发服务器（通过 next dev 命令启动）、构建工具和打包器，它自动处理代码编译、热模块替换（HMR）、代码拆分和优化等工作，开发体验和构建性能都非常优秀


• Next.js 使用了基于 Rust 的编译器 SWC 来加速构建和转译，性能上已经非常接近甚至优于传统的打包工具


• Vite 主要是一个前端构建工具和开发服务器，适合纯前端项目或需要快速启动的 React/Vue 应用，而 Next.js 是一个框架，包含了路由、服务器端渲染（SSR）、静态站点生成（SSG）、API 路由等功能，功能层面更全面


• 使用 Next.js 时，所有的构建和开发流程都由 Next.js 自己管理，开发者无需额外配置 Vite，避免了工具链的重复和冲突。


• 如果你只是做纯前端项目，Vite 是很好的选择；但如果你需要 SSR、API 路由、全栈功能，Next.js 是更合适的框架，且内置了构建和开发支持，不需要再叠加 Vite。

总结：

因此，用了 Next.js 后，基本上不需要再用 Vite 了，Next.js 已经集成了类似 Vite 的开发和构建功能，且提供了更多全栈特性

xcode做新项目时，设置了app图标。发现点击app进入前台时，App Icon是正常的，但是回到桌面时App Icon又变成了默认的雪花图标。

之前也遇到过，但是不求甚解，在此列出解决方案。

问题1: AppIcon的设置

随便设置了个图片为app图标,编译报错xxx/Assets.xcassets: The stickers icon set or app icon set named "AppIcon" did not have any applicable content.
同时appIcon可视化窗口显示黄色⚠️图标。

Xcode 提示你在 Assets.xcassets 中名为 "AppIcon" 的 App 图标集合里没有提供任何有效的图片资源。

iOS 应用要求必须有完整的 AppIcon 集合，并且要包含适用于各种设备和分辨率的图标尺寸。如果没有正确设置这些图标，App 就无法通过 App Store 审核，甚至可能在某些模拟器或真机上运行异常。

我使用了makeappicon.com/ 生成appIcon图标。
网站生成的结果包含AppIcon.appiconset，直接把AppIcon.appiconset替换原项目中Assets中的appIcon即可。

结果如下

问题2: 切后台appIcon变成默认雪花icon

现在成功设置appIcon后，切后台时发现appIcon变成了默认的雪花icon。

原因是系统缓存了旧图标，iOS 系统有时会缓存应用的图标缩略图，尤其是多任务界面中的预览图。即使你更新了图标，也可能不会立即刷新。

解决办法： 卸载重装

现在能正常显示了

前沿导读

各位同学很久没有分享技术文章给大家了，因为最近需要兼职讲课，所以我比较忙。都也没有多少个人时间，所以也是趁着现在有空我们就分享下

效果图

• 
  

  调用效果

  
  

• 
  

  日志打印

  
  

• 
  

  需求背景

  
  

工作中最近接到需求，需要接入鸿蒙的游戏授权登录和内购支付，今天把流程走完整，所以现在就做一个分享

• 
  

  开发步骤

  
  

• 
  

  初始化

  
  

这里如果不是在 EntryAbility 接入初始化代码需要做调整

// 在EntryAbility 里面初始化

try {

  gamePlayer.init(this.context,()=>{

    hilog.info(0x0000, 'testTag', `Succeeded in initing.`);

  });

} catch (error) {

  let err = error as BusinessError;

  hilog.error(0x0000, 'testTag', `Failed to init. Code: ${err.code}, message: ${err.message}`);

}

// 不在EntryAbility 里面执行初始化

try {

 gamePlayer.init(context as  common.UIAbilityContext ,()=>{

   hilog.info(0x0000, 'testTag', `Succeeded in initing.`);



 });

} catch (error) {

 let err = error as BusinessError;

 hilog.error(0x0000, 'testTag', `Failed to init. Code: ${err.code}, message: ${err.message}`);

}

获取 gamePlayerId

let context = getContext(this) as common.UIAbilityContext;



let request: gamePlayer.UnionLoginParam = {

  showLoginDialog: false,  // 是否弹出联合登录面板。true表示强制弹出面板，false表示优先使用玩家上一次的登录选择，不弹出联合登录面板，若玩家首次登录或卸载重装，则正常弹出。

  thirdAccountInfos: [] // 若游戏无官包或无官方账号体系，请传空数组。

};

try {

  gamePlayer.unionLogin(context, request).then((result: gamePlayer.UnionLoginResult) => {

    hilog.info(0x0000, 'testTag', `Succeeded in logining: ${result?.accountName}`);

    console.log("gamePlayerId accountName --- >" +result.accountName)

    console.log("gamePlayerId thirdOpenId --- >" +result.boundPlayerInfo.thirdOpenId)

    console.log("gamePlayerId bindType --- >" +result.boundPlayerInfo.bindType)



    let  localPlayer=result.localPlayer;

    if(localPlayer.gamePlayerId){

      console.log("index gamePlayerId  localPlayer gamePlayerId  --- >" +localPlayer.gamePlayerId)



    }



    if(localPlayer.teamPlayerId){

      console.log("index gamePlayerId  localPlayer teamPlayerId  --- >" +localPlayer.teamPlayerId)



    }



  }).catch((error: BusinessError) => {

    hilog.error(0x0000, 'testTag', `Failed to login. Code: ${error.code}, message: ${error.message}`);

  });

} catch (error) {

  let err = error as BusinessError;

  hilog.error(0x0000, 'testTag', `Failed to login. Code: ${err.code}, message: ${err.message}`);

}

• 
  

  获取authorizationCode

  
  

let loginRequest = new authentication.HuaweiIDProvider().createLoginWithHuaweiIDRequest();

loginRequest.state = util.generateRandomUUID();

// 执行认证请求

try {

  let controller = new authentication.AuthenticationController(getContext(this));

  controller.executeRequest(loginRequest, (err, data) => {

    if (err) {

      hilog.error(0x0000, 'testTag', `Failed to login. Code: ${err.code}, message: ${err.message}`);

      return;

    }

    let loginWithHuaweiIDResponse = data as authentication.LoginWithHuaweiIDResponse;

    let state = loginWithHuaweiIDResponse.state;

    console.log("index  authorizationCode  state   ---> "+state)

    if (state != undefined && loginRequest.state != state) {

      hilog.error(0x0000, 'testTag', `Failed to login. State is different.`);

      return;

    }

    hilog.info(0x0000, 'testTag', `Succeeded in logining.`);



    let loginWithHuaweiIDCredential = loginWithHuaweiIDResponse.data!;

    let authorizationCode = loginWithHuaweiIDCredential.authorizationCode;

    console.log("index  authorizationCode  ---> "+authorizationCode)

    // 开发者处理authorizationCode

  });

} catch (error) {

  let err = error as BusinessError;

  hilog.error(0x0000, 'testTag', `Failed to login. Code: ${err.code}, message: ${err.message}`);

}

我们拿到了 gamePlayerId 和 authorizationCode 去请求服务端去获取

• 
  

  服务端流程

  
  

获取 Access Token地址

• 
  

  调用on接口注册playerChanged事件监听

  
  

aboutToAppear(): void {

  // 调用on接口注册playerChanged事件监听

  try {

    gamePlayer.on('playerChanged', this.onPlayerChangedEventCallback);

    hilog.info(0x0000, 'testTag', `Succeeded in registering.`);

  } catch (error) {

    let err = error as BusinessError;

    hilog.error(0x0000, 'testTag', `Failed to register. Code: ${err.code}, message: ${err.message}`);

  }



}

监听事件回调

private onPlayerChangedEventCallback(result: gamePlayer.PlayerChangedResult) {

  if (result.event === gamePlayer.PlayerChangedEvent.SWITCH_GAME_ACCOUNT) {

    // ...

    // 游戏号已切换，完成本地缓存清理工作后，再次调用unionLogin接口等



  }

}

提交玩家角色信息

let context = getContext(this) as common.UIAbilityContext;

let request: gamePlayer.GSKPlayerRole = {

  roleId: '123', // 玩家角色ID，如游戏没有角色系统，请传入“0”，务必不要传""和null。

  roleName: 'Jason', // 玩家角色名，如游戏没有角色系统，请传入“default”，务必不要传""和null。

  serverId: '456',

  serverName: 'Zhangshan',

  gamePlayerId: '789', // 请根据实际获取到的gamePlayerId传值。

  thirdOpenId: '123' // 接入华为账号登录时不传该字段。接入游戏官方账号登录时，请根据实际获取到的thirdOpenId传值。

};

try {

  gamePlayer.savePlayerRole(context, request).then(() => {

    hilog.info(0x0000, 'testTag', `Succeeded in saving.`);

  });

} catch (error) {

  let err = error as BusinessError;

  hilog.error(0x0000, 'testTag', `Failed to save. Code: ${err.code}, message: ${err.message}`);

}

参数配置

我们需要在 添加如此下配置

"metadata": [

  // 配置如下信息

  {

    "name": "client_id",

    "value": "xxxxxxxxx"  

    // 华为Client ID  请替换成你自己的正式参数

  },

  {

    "name": "app_id",

    "value": "6917581951060909508"

    // 华为APP ID 请替换成你自己的正式参数

  }

],



"requestPermissions": [

  {

    "name": "ohos.permission.INTERNET"

  },

],

• 
  

  配置手动签名测试

  
  

查看日志

• 
  

  写在最后

  
  

整个鸿蒙游戏授权登录相对比较简单，但是有一个槽点，就是获取 gamePlayerId 和 authorizationCode需要分开两个方法回调 。其实可以做成一个回调更简单，这个希望后期能完善， 服务端逻辑对比客户端来说，还是相对复杂一点点，不过对着文档也是很快能解决这次接入 华为技术支持也帮了不少忙，这个点赞， 对于鸿蒙生态的推广这块，华为确实下了决心，也非常积极的回应。希望鸿蒙越来越好，国产系统早日完善。我依然是你们最爱的徐老师。我们下一期再见。

JS 和 Android

• 原生调用 JS
  4.4 版本之前

// mWebView = new WebView(this); //当前webview对象

// 通过loadUrl方法进行调用 参数通过字符串的方式传递

mWebView.loadUrl("javascript: 方法名('参数1,参数2...')");



//也可以在UI线程中运行

runOnUiThread(new Runnable() {

    @Override

    public void run() {

        // 通过loadUrl方法进行调用 参数通过字符串的方式传递

        mWebView.loadUrl("javascript: 方法名('参数1,参数2...')");

        // 安卓中原生的弹框

        Toast.makeText(Activity名.this, "调用方法...", Toast.LENGTH_SHORT).show();

    }

});

4.4 版本之后

// 通过异步的方式执行js代码,并获取返回值

mWebView.evaluateJavascript("javascript: 方法名('参数1,参数2...')", new ValueCallback() {

    @Override

    // 这个方法会在执行完毕之后触发, 其中value就是js代码执行的返回值(如果有的话)

    public void onReceiveValue(String value) {



    }

});

• JS 调用Android
  安卓配置：

// Android4.2版本以上，本地方法要加上注解@JavascriptInterface，否则无法使用

private Object getJSBridge(){

    // 实例化新对象

    Object insertObj = new Object(){

        @JavascriptInterface

        // 对象内部的方法1

        public String foo(){

            // 返回 字符串 foo

            return "foo";

        }

        @JavascriptInterface

        // 对象内部的方法2 需要接收一个参数

        public String foo2(final String param){

            // 返回字符串foo2拼接上传入的param

            return "foo2:" + param;

        }

    };

    // 返回实例化的对象

    return insertObj;

}



// 获取webView的设置对象，方便后续修改

WebSettings webSettings = mWebView.getSettings();

// 设置Android允许JS脚本，必须要！！！

webSettings.setJavaScriptEnabled(true);

// 暴露一个叫做JSBridge的对象到webView的全局环境

mWebView.addJavascriptInterface(getJSBridge(), "JSBridge");

在 web 页面中调用

//调用方法一

window.JSBridge.foo(); //返回:'foo'

//调用方法二

window.JSBridge.foo2('test');//返回:'foo2:test'

JS 和 IOS

• 原生调用 JS

class ViewController: UIViewController, WKNavigationDelegate, WKScriptMessageHandler {

    // 加载完毕会触发(类似于Vue的生命周期钩子)

    func webView(_ webView: WKWebView, didFinish navigation: WKNavigation!) {

        // 类似于console.log()

        print("触发啦");

        // wkWebView调用js代码，其中doSomething()会被当做js解析

        webView.evaluateJavaScript("doSomething()");

    }

}

• JS 调用 IOS

1. JS 部分

window.webkit.messageHandlers.方法名.postMessage(数据)

2. iOS 部分注册监听

wkWebView.configuration.userContentController.add(self, name: 方法名)

3. iOS 部分遵守协议相关方法

func userContentController(_ userContentController: WKUserContentController, didReceive message: WKScriptMessage) {

    // message.body 就是传递过来的数据

    print("传来的数据为", message.body)

}

url scheme(互通协议)

web 调用

class="ios" type="button" value="使用iframe加载url">



// 加载url 通过iframe 设置URL 目的是让ios拦截

function loadUrl(url) {

  // 创建iframe

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

  // 设置url

  iframe.src = url;

  // 设置尺寸(不希望他被看到)

  iframe.style.height = 0;

  iframe.style.width = 0;

  // 添加到页面上

  document.body.appendChild(iframe);

  // 加载了url之后他就没用了

  // 移除iframe

  iframe.parentNode.removeChild(iframe);

}



document.querySelector('.ios').onclick = function () {

  loadUrl('taobao://click');

}

IOS 监听

// 拦截url

func webView(_ webView: WKWebView, decidePolicyFor navigationAction: WKNavigationAction, decisionHandler: @escaping (WKNavigationActionPolicy) -> Void) {

    // 获取url

    let url = navigationAction.request.url?.absoluteString;

    if(url=="taobao://click"){

        print("调用系统功能");

        decisionHandler(.cancel);

    }else{

        decisionHandler(.allow);

    }

}

HyBridApp

• 开发框架

1. 提供前端运行环境
2. 实现前端和原生交互
3. 封装原生功能，提供插件机制 

加载优化

• 骨架屏

<style>

  .shell .placeholder-block{

    display: block;

    height: 5em;

    background: #ccc;

    margin: 1em;

  }

  .novel {

    height: 5em;

    background-color: yellowgreen;

  }

style>

head>

<body>

<div class="shell">

  <div class="placeholder-block">div>

div>

body>

html>

<script>

setTimeout(()=>{

  // 移除 占位dom元素

  document.querySelector('.shell').innerHTML = ''

  // 创建数据的dom元素 添加到页面上

  let p = document.createElement('p')

  p.innerHTML = '黑马程序员'

  p.className = 'novel'

  document.querySelector('.shell').appendChild(p)

},3000)

script>

webview

import UIKit

import WebKit



class ViewController: UIViewController, WKNavigationDelegate {

    override func viewDidLoad() {

        super.viewDidLoad()

        // Do any additional setup after loading the view.

        // 创建webView

        var webView = WKWebView(frame: self.view.bounds)

        // 设置自己为WebView的代理

        webView.navigationDelegate = self

        // 添加到页面上

        self.view.addSubview(webView)



        // 创建URL对象

        var url = URL(string: "https://www.baidu.com")

        // 创建URLRequest对象

        var request = URLRequest(url: url!)

        // 加载URL

        webView.load(request)

    }

}

JSBridge

• 设计思想

1. JS 向原生发送消息
2. 原生向 JS 发送消息

window.JSBridge = {

    invoke: function(action, params, callback) {

        // 生成唯一回调ID

        const callbackId = 'cb_' + Date.now();

        // 存储回调函数

        window[callbackId] = callback;

        

        // 构建标准化消息

        const msg = {

            action: action,

            params: params || {},

            callbackId: callbackId

        };

        

        // 根据平台调用不同原生桥

        if (isIOS()) {

            window.webkit.messageHandlers.nativeBridge.postMessage(JSON.stringify(msg));

        } else if (isAndroid()) {

            window.android.postMessage(JSON.stringify(msg));

        }

    },

    // 原生调用此方法来回调结果

    receiveMessage: function(msg) {

        const { callbackId, result, error } = msg;

        const callback = window[callbackId];

        if (callback) {

            if (error) {

                callback(null, error); // 错误回调

            } else {

                callback(result, null); // 成功回调

            }

            // 执行后删除回调，避免内存泄漏

            delete window[callbackId];

        }

    }

};



// 使用示例：调用原生相机

JSBridge.invoke('takePhoto', { quality: 'high' }, (result, error) => {

    if (error) {

        console.error('拍照失败：', error);

    } else {

        console.log('照片路径：', result.imagePath);

    }

});

解释：

1. 前端调用 JSBridge.invoke 时：存储回调函数，生成唯一的 callbackId（如 cb_1725000000000），确保每个回调能被唯一识别；把回调函数挂载到 window 对象上（即 window[callbackId] = 回调函数），相当于 “暂时存档”，避免函数被垃圾回收。
2. 前端向原生发送 “带回调 ID 的消息”，然后根据平台（iOS/Android）把消息发给原生，此时原生收到的是  “操作指令 + 回调 ID”
3. 原生执行操作（如调用相机），原生接收到消息后，解析出 action 和 params，执行对应的原生逻辑

• iOS：调用 UIImagePickerController（系统相机接口），按 quality: 'high' 配置拍照质量；
• Android：调用 Camera 或 CameraX 接口，同样按参数执行拍照。 这个阶段完全在原生环境（Objective-C/Swift 或 Java/Kotlin）中运行，与前端 JS 无关。

4. 原生将 “结果 + 回调 ID” 回传给前端
   原生执行完操作后（无论成功 / 失败），会构建一个 “结果消息”，包含：callbackId: 'cb_1725000000000'（必须和前端传过来的一致，才能找到对应的回调）； result: { imagePath: '/var/mobile/.../photo.jpg' }（成功时的结果，如照片路径）； 或 error: '用户取消拍照'（失败时的错误信息）。

然后原生会主动调用前端 JSBridge 预留的 receiveMessage 方法，把 “结果消息” 传回去。

5. 前端 receiveMessage 执行回调函数

• 解析原生传过来的消息，提取 callbackId、result、error；
• 通过 callbackId 找到之前挂载在 window 上的回调函数（即 window['cb_1725000000000']）；
• 执行回调函数：
  • 成功：调用 callback(result, null)（如打印照片路径）；
  • 失败：调用 callback(null, error)（如打印 “用户取消拍照”）；
• 执行完后删除 window[callbackId]，避免内存泄漏。

到这一步，回调函数才真正在前端 JS 环境中执行，完成整个跨端通信闭环。

作者：code_YuJun
来源：juejin.cn/post/7544077353371222067