代码之美-代码整洁之道

一、开篇引言

2024年,跨进21世纪已经两个轮回,这些计算机技术基础问题似乎并没有因为软件工程和计算机相关专业的发展,而有所改善。需求在各个域中表现千差万别,问题在各处代码中也似乎毫无规律,本文说代码之美是希望大家认识代码的美,化繁为简,创造出美好的产品。

代码之美有很多方面,可以谈高级编程语言以及各语言的框架/类库,也可以聊算法和数据结构,还可以谈操作系统内核或是层出不穷的中间件,不过这里我们看最不起眼的代码整洁之道。

从上面两个建筑的对比可以看出:系统整洁度与系统规模非强相关,一切从心开始。

二、整洁之道

说起代码整洁之道,不得不提到人称Bob大叔的Robert C. Martin,以及他写的《Clean Code》一书。

在这里插入图片描述

《Clean Code》告诉我们,糟糕的代码也能运行,但如果代码不整洁会使整个团队深陷泥潭,让系统危如累卵,让每一次修改都如履薄冰,每年耗费难以计数的时间、资源和士气。然而这一切并非不可避免。

2.1 什么是整洁代码?

可能有人觉得谈代码太基础,有点low,不够高大上,应该谈谈设计、模型、算法,亦或是业务域;或者也有人觉得随着AI技术发展,代码可以自动生成了;我也曾一度觉得代码包括整洁代码,对于以此为生的专业人士,应该人人已经掌握。现实的世界却是啪啪地打脸,我们的注册应用系统数量以万记,没听说一个系统的代码是靠AI自动生成,而每个月的故障汇总中都有代码引起的问题,要解决这些基础问题,还是要从基础说起。

《Clean Code》中引用了数位知名程序员的话,Bjarne Stroustrup,C++之父提到的核心词:“优雅”、“高效”、“只做好一件事”。《面向对象分析与设计》的作者Grady Booch比喻“整洁的代码如同优美的散文”,《修改代码的艺术》的作者Michael Feathers指出整洁代码的关键在于代码作者在意代码。

整洁代码我总结为以下4点:

◦可读性:代码是给人阅读的,不只是让机器运行的

◦减少认知负担:层次抽象适度,避免主逻辑被细节扰乱

◦简明扼要:每个函数、对象都为一个主旨服务

◦让写和维护代码变得有趣:整洁代码既是果又是因

2.2 概念对比

2.2.1 整洁代码vs.设计模式

整洁代码是为了代码可读性,让代码的读者易于理解和维护代码;设计模式是为了系统具有良好的可扩展性。当然他们之间也有联系,如果你能够恰当的运用设计模式,可以提高系统代码的可读性,降低了系统复杂度。但如果你过度设计,为功能相对简单的应用抽象出一堆接口、工厂、策略、代理,反而增加了应用复杂度。所以整洁代码和设计模式是两个不同维度的概念,有关联但侧重点不同。

2.2.2 整洁代码vs.整洁架构

整洁代码关注的是代码层面的整洁,整洁架构关注的是设计层面的整洁,设计反映在代码逻辑应该写在哪个服务或者模块更为合理,服务之间的接口如何定义可以减少服务间的依赖。所以整洁代码和整洁架构有相似之处,但关注的粒度完全不同。

2.2.3 整洁代码vs.快速代码

理想情况下,一个新项目,从开始你就可以写下完美的整洁代码,但现实中你的编程水平在进步,项目的需求在变更,你需要不断地质疑并重构已有的代码。项目中的整洁代码往往不是一个完美的不变的代码,而是一个不断调整的精进的代码。

在这里插入图片描述

项目开发过程中,重构是一个非常正常的事情,如果你可以做到不断质疑和改进代码,你才可以在系统演进的过程中保持代码的整洁,保持系统的可维护性,加快明天的速度。

相对而已,如果你从项目开始,只是快速的开发功能,输出大量的代码和功能特性。但随着时间的推移,代码库成为一种负担,不论是bugfix还是新增特性开发都变得异常困难,最终不得不在某个时候新建一个下一代系统来替代它。这不是臆测,下图是业界的研究分析,我也在几家企业中见证了数个大型系统的轮回,其中几家欢喜几家愁,对于组织系统的不断推倒重建无疑是个巨大的损失。

在这里插入图片描述

2.3 如何实现整洁代码?

要实现整洁代码,手段有多种,可以是前面提到的设计模式的运用、代码的重构,也可以通过集体code review来发现代码中的bad smell,团队的代码规范、检查工具等。这里将整洁代码中的关键点列举出来,你可以在写代码或重构时加以关注。

代码真正 “读” 的成分比 “写” 多得多,读与写花费时间的比例超过 10:1。写新代码时,我们一直在读旧代码,所以我们要让读的过程变得轻松,即便这会对写代码提出更高的要求。

在这里插入图片描述

代码格式在本文不再赘述,Java代码可以参考《Java代码之美,从遵循样式规范开始》,c++代码可以使用clang-format,go代码可以使用gofmt,团队只需要选择统一的规范配置即可。

2.3.1 命名

软件应用中命名随处可见,我们给变量、函数、类命名,我们给代码文件、目录、模块、应用服务命名,这里范围且限定在代码里面的变量、函数、类命名,对于其它命名规则和道理是相通的。

命名是如此常见,常常被技术人所轻视,认为命名没有什么技术含量。我的态度恰恰相反,命名是如此的重要,可以说是整洁代码的基石。code review中能看到有意义的命名,不论是类、函数还是变量,都会让我对这段代码信任度提高,对代码开发者也有很好的印象。通常能把命名这种基本功做好的人,逻辑的全面性一般不会差,质量就有了保障。

命名有意义

看左侧的这段代码,它可能是任何对象,做了一个不知道什么操作的处理动作。再看右侧的代码段,即使没有任何注释,也能明白用户保存操作。

一段有逻辑没有意义的代码 const us = new MainEntity(); us.process(); if (login) { // … }一段自描述有意义的代码 const user = new User(); user.save(); if (isLoggedIn) { // … }

命名基本规则
分类简短定义命名规则示例
变量数据存储的容器使用名词或有限定词的短语const userData = {…} bool isValid = …
函数/方法完成某项特定功能使用动词或动宾结构的短语sendData() inputIsValid()
类一类事物的抽象描述,用来创建对象使用名词或名词短语class User {…} class RequestMessage {…}

变量命名

存储的数据描述糟糕的命名可接受的命名好的命名
一个用户对象u datauserData personuser customer
没有意义,"u"或"data"可以存储任何数据"userData"有点啰嗦,"person"指向不明确"user"是自描述的 "customer"指向明确
检查用户输入是否有效(boolean)v valcorrect validatedInputisCorrect isValid
"v"可能表达任何数据,"val"可能是value的缩写这两个不能表示boolean值(true/false)自描述的,且数据类型清晰

函数命名

功能描述糟糕的命名可接受的命名好的命名
保存用户数据到数据库process(…) handle(…)save(…) storeData(…)saveUser(…) user.store(…)
两个都没有含义,没有回答对什么东西做了什么处理执行动作是存储,但什么东西被存储没有明确从命名看到明确的意图
检查用户的输入process(…) save(…)validateSave(…) check(…)validate(…) isValid(…)
"process"动作不明确 "save"有误导性两个都不太明确两个都有明确意义的,可根据情况选择

类命名

事物描述糟糕的命名可接受的命名好的命名
一个用户class UEntity class ObjAclass UserObj class AppUserclass User class Admin
两个都没有含义两个都有冗余信息"User"中规中矩 "Admin"用户类型更为明确
一个数据库class Data class DataStorageclass Db class Dataclass Database class SQLDatabase
两个都指代不明确不够具体,缩写易有歧义数据库指代明确,"SQLDatabase"限定类型更好
命名大忌

代码的变量、函数、类的命名有几大忌讳:

忌讳示例建议命名说明
中文拼音缩写long hlUserId;long goldProcessUserId;黄流缩写为hl,在没有注释的情况让阅读者抓狂
俚语item.gotoDie()item.delete()国内用英语俚语的少
不明确的英文缩写ymdt = ‘20241218CST’dateWithTZ=‘20241218CST’可以接受的缩写,如:ts(timestamp)
误导性名字userList = {u1: …, u2: …} uniqueNames = {a, b, b, … }userMap = {u1: …, u2: …} nameList = {a, b, b, … }误导性名字会被其他开发者误用

2.3.2 注释

如果你的代码本身就是自描述的,让阅读者可以清晰地识别代码意图,注释是不必要的。注释是为了弥补代码表达意图的失败,如果有能力尽量把你的代码收拾的整洁点,其次才是使用注释来解释。

糟糕的注释比代码还让人困惑,因为注释存在的时间越久,会越偏离代码的本意,因为程序员在修改代码时很少维护注释。

坏注释

•重复信息

注释和代码表示的是一个意思,且代码已经足够自描述,这时的注释是多余的

在这里插入图片描述

•分隔标记

使用大段的块注释作为分隔标记,全局变量、类这些关键字就足够标记,这些注释也是多余的

在这里插入图片描述

•误导信息

注释和代码的意思不一致,明明是插入一条数据,注释偏偏写成更新

在这里插入图片描述

•注释代码块

将代码块注释掉,担心有朝一日这块还会再次被使用。其实不论哪种代码仓库(git、svn…)都可以保证代码的修改历史,注释掉的代码块无形中给代码阅读者带来认知负担。

在这里插入图片描述

好注释

•法律信息

•解释或意图

•警示信息

•TODO注释

•API中的Javadoc

上面是对正则表达式的解释,并给出正则匹配的示例,这对不熟悉正则的人非常友好。下面的例子是一个警示信息,提醒方法适用的工作环境,补充代码难以表达的信息。

在这里插入图片描述

2.3.3 函数

在《Clean Code》中,Bob说了十多项原则,我这里只提两点:函数长度和函数参数。

函数长度

基本原则:函数应该短小。Bob无法证实小函数更好的研究成果,我也不能给出一个科学的解释。回到整洁代码的问题上,短小的函数可读性更强,一个函数只负责一件事,在阅读时不需要背负过多的上下文信息,读代码时心情更轻松愉快,维护修改代码时也不容易犯错。

•单一职责

一个函数应该做一件事,做好这件事,只做这一件事。

•一个抽象层次

"这个函数只做一件事,但这件事逻辑比较复杂,有很多步骤,要把这件事做完整就会写很长。"解决这个问题,就需要对函数内部操作分层抽象,函数内只写这一层的操作。

就如经典笑话"要把大象装冰箱,总共分几步?三步,第一步,把冰箱门打开;第二步,把大象装进去;第三部,把冰箱门盖上。"这里三个步骤就是很好的抽象,它也适用于把长颈鹿装冰箱,把骆驼装冰箱。而测量大象大小、检查冰箱大小是否足够,就不是这个问题下的三个步骤同层抽象。

下面再看一个javascript的函数示例,这个函数只做了一件事,但看上去还是有点杂乱。因为它把内容检查、渲染内容构建和最后的渲染动作一一平铺上这个函数内。

function renderContent(renderInformation) {
    const element = renderInformation.element;
    if (element === 'script' || element === 'SCRIPT') {
        throw new Error('Invalid element.');
    }

    let partialOpeningTag = '<' + element;

    const attributes = renderInformation.attributes;

    for (const attribute of attributes) {
        partialOpeningTag = 
            partialOpeningTag + ' ' + attribute.name + '="' + attribute.value + '"';
    }

    const openingTag = partialOpeningTag + '>';
    const closingTag = '</' + element + '>';
    const content = renderInformation.content;

    const template = openingTag + content + closingTag;

    const rootElement = renderInformation.root;
    rootElement.innerHTML = template;
}

对比下面代码,函数里面的几个操作抽成几个独立的子函数,在renderContent函数内操作是一个抽象层次,没有细节层面的干扰。同时也解决了大家长抱怨的函数难以单元测试的问题,函数、子函数输入输出明确,单元测试用例水到渠成。

function renderContent(renderInformation) {
    const element = renderInformation.element;
    const rootElement = renderInformation.root;
    
    validateElementType(element);

    const content = createRenderableContent(renderInformation);
    renderOnRoot(rootElement, content);
}
函数参数

基本原则:函数参数越少越好,最好是零参数,其次是单参数,再次是双参数,尽量避免三参数或更多参数。

看下面的函数重构的示例,让一个保存用户的双参数函数,重构为一个类的无参数方法,使用的时候构造用户对象并保存,丝滑地顺应了人的正常思维逻辑。

◦双参数函数saveUser

function saveUser(email, password) {
    const user = {
        id: Math.random().toString(),
        email: email,
        password: password
    };

    db.insert('users', user);
}

saveUser('test@test.com', 'test-pass');

◦类的无参数函数save

class User {
    constructor(email, password) {
        this.email = email;
        this.password = password;
        this.id = Math.random().toString();
    }

    save() {
        db.insert('users', this);
    }
}

const user = new User('test@test.com', 'test-pass');
user.save();

2.3.4 控制逻辑

要清除复杂的控制逻辑代码,我们要面对if else控制流、各种嵌套逻辑,以及错误处理。这里介绍两个处理方法:使用Guard尽早返回,使用异常替代返回码。

使用Guard

看一个五层嵌套的代码示例,如何重构避免多层嵌套呢?

void processTransactions(List<Transaction> transactions) {
    if (transactions && transactions.length > 0) {
        for (Transaction transaction: transactions) {
            if ("PAYMENT".equals(transaction.type)) {
                if ("OPEN".equals(transaction.status)) {
                    if ("CREDIT_CARD".equals(transaction.method)) {
                        processCreditCardPayment(transaction);
                    } else if ("PAYPAL".equals(transaction.method)) {
                        processPayPalPayment(transaction);
                    } else if ("ALIPAY".equals(transaction.method)) {
                        processAliPayPayment(transaction);
                    }
                } else {
                    console.log("Invalid transaction status!");
                }
            } else if ("REFUND".equals(transaction.type)) {
                if ("OPEN".equals(transaction.status)) {
                    if ("CREDIT_CARD".equals(transaction.method)) {
                        processCreditCardRefund(transaction);
                    } else if ("PAYPAL".equals(transaction.method)) {
                        processPayPalRefund(transaction);
                    } else if ("ALIPAY".equals(transaction.method)) {
                        processAliPayRefund(transaction);
                    }
                } else {
                    console.log("Invalid transaction status!");
                }
            }
        }
    }
}

使用Guard,尽早发现尽早返回,对上述代码逻辑按照一个抽象层次进行重构

void processTransactions(List<Transaction> transactions) {
    if (isEmpty(transactions)) {
        showErrorMessage("No transactions provided!");
        return;
    }

    for (Transaction transaction: transactions) {
        processTransaction(transaction);
    }
}

void processTransaction(Transaction transaction) {
    if (!isOpen(transaction)) {
        showErrorMessage("Invalid transaction status!");
        return;
    }

    if (isPayment(transaction)) {
        processPayment(transaction);
    } else if (isRefund(transaction)) {
        processRefund(transaction);
    } else {
        showErrorMessage("Invalid transaction method!");
    }
}

boolean isEmpty(List<Transaction> transactions) {
    return transactions == null || transactions.length == 0;
}

boolean isOpen(Transaction transaction) {
    return "OPEN".equals(transaction.status);
}

boolean isPayment(Transaction transaction) {
    return "PAYMENT".equals(transaction.type);
}

boolean isRefund(Transaction transaction) {
    return "REFUND".equals(transaction.type);
}
使用异常

上述案例中对于错误的处理是检查判断再返回,还可以使用抛异常代替错误返回。异常的捕获和处理集中在两处:1、调用processTransactions()的位置;2、下沉到processTransaction()。在检查中抛出异常,而不是返回错误,try catch捕获异常并统一处理,这样让processTransactions()和processTransaction()的主干逻辑保持简洁。

main() {
    List<Transaction> transactions = [...];

    try {
        processTransactions(transactions);
    } catch (Exception e) {
        showErrorMessage(e.message);
    }
}

void processTransactions(List<Transaction> transactions) {
    validateTransactions(transactions);

    for (Transaction transaction: transactions) {
        processTransaction(transaction);
    }
}

void validateTransactions(List<Transaction> transactions) {
    if (isEmpty(transactions)) {
        throw new TransactionException("No transactions provided!");
    }
}

void processTransaction(Transaction transaction) {
    try {
        validateTransaction(transaction);

        if (isPayment(transaction)) {
            processPayment(transaction);
        } else if (isRefund(transaction)) {
            processRefund(transaction);
        }
    } catch(Exception e) {
        showErrorMessage(e.message);
    }
}

void validateTransaction(Transaction transaction) {
    if (!isOpen(transaction)) {
        throw new TransactionException("Invalid transaction status!");
    }

    if (!isPayment(transaction) && !isRefund(transaction)) {
        throw new TransactionException("Invalid transaction method!");
    }
}

2.3.5 类&数据结构

谈到类和数据结构,不得不提到面向对象编程。类和对象的概念是随着面向对象编程的提出而出现的,在面向过程编程时代只有数据结构,没有类的抽象和封装。

理解差异

引入面向对象编程就是为了将一个事物抽象,事物内部的数据和操作逻辑封装为一个黑盒,使用方不需要关心对象内部的细节。

类/对象私有的数据,公开的操作接口类的业务逻辑包在接口内部黑盒 一个事物的抽象
数据结构公开的数据,没有操作接口只为保存和传输数据白盒 具体的数据

理解了对象和数据结构的区别,可以在程序中根据应用场景的需求,选择合适的数据类型。如果选择了类,就要按照面向对象设计原则:迪米特法则(Law of Demeter),一个类对于其他类知道的越少越好。那这个原则怎么影响到代码的可读性呢?

符合迪米特法则的代码片段,db作为一个独立完整的对象进行操作,代码具有良好的可读性。

class Database {
    private String uri;
    private Provider provider;
    private Connection connection;

    void connect() {
        try {
            connection = provider.establishConnection(uri);
        } catch (Exception e) {
            log.error("Failed to connect!");
        }
    }

    void disconnect() {
        connect.close();
    }

    void storeData(Data data) {...}
}

const Database db = new Database("mysql-db:8100", sqlEngine);
db.connect();
db.storeData(data);
db.disconnect();

如果违反迪米特法则,操作db对象内部的成员变量,Database类修改disconnect操作逻辑需要在至少两处修改,同时代码的可读性因为引入db.connection破坏db的独立性。

class Database {
    private String uri;
    private Provider provider;
    public Connection connection;     // 设置为public
}

const Database db = new Database("mysql-db:8100", sqlEngine);
db.connect();
db.connection.close();               // 违反原则

即使类为内部的成员变量提供的get/set方法,迪米特法则也不提倡通过get方法去获取类的成员变量,这样暴露了类的内部结构,破坏了类的封装性。

类大小

基本原则:类应该短小。这个原则和函数基本原则一致,我们应该将大的类尽可能拆分为多个小的类结构。不同于函数,一个类因为封装了多个数据和操作,可能不只是完成一件事;但与函数相同的是,类应该职责单一,只是一个事物的抽象。

如何检验一个类的设计是单一职责呢?可以计算下类的内聚度:类的成员函数如何使用这个类的成员变量。如果每个成员函数都使用了所有的成员变量,那么这个类的内聚度就是100%;如果每个成员函数都没有使用成员变量,那么这个类的内聚度就是0%,这个类就应该改拆分为数据结构(Data Structure)和外部函数。内聚度高的类就是单一职责,不用拆分;否则就可以考虑将关联度高的成员函数和成员变量拆分为一个独立的类。

三、实践案例

在技术风险复盘案例,选择一个代码案例,不考虑业务逻辑和线上问题,从代码整洁角度来分析代码片段。

public ServiceResponse<List<List<Long>>> batchQueryBelongedIdsFromGivenCrowdIds(QueryCrowdIdsBatchReqDTO batchReqDTO) {
    ...
    List<List<Long>> result = Lists.newArrayList();
    CallerInfo callerInfo = UmpUtil.methodReg("bmallCrowdPinQueryProvider.batchQueryBelongedIdsFromGivenCrowdIds", batchReqDTO.getForcebot());
    try {
        PipelineClient pipeline = bmallCrowdJimdb.pipelineClient();
        Map<String, JimFuture<Set<String>>> jimFutureMap = Maps.newHashMap();
        List<String> jimdbKeyList = Lists.newArrayList();
        Map<String, List<Long>> jimdbKeyCrowdIdListMap = Maps.newHashMap();
        String bmallUseOriginalPin = labelDuccManager.getAvailConfigStr("bmallUseOriginalPin");
        for (int index = 0; index < batchReqDTO.getBatchReq().size(); ++index) {
            QueryCrowdIdsReqDTO queryCrowdIdsReqDTO = batchReqDTO.getBatchReq().get(index);
            String fieldVersion = dorisExecuteComponent.getBmallFieldJimdbValidVersion(queryCrowdIdsReqDTO.getFieldId());
            String jimdbKey = String.format(virtualBpinJimdbKeyFormat, queryCrowdIdsReqDTO.getFieldId(), queryCrowdIdsReqDTO.getCrid(),
                    (queryCrowdIdsReqDTO.getFieldId().equals(LabelConstants.BMallPlatformFieldId) ? queryCrowdIdsReqDTO.getIndustryId() : ""),
                    (StringUtils.isNotBlank(bmallUseOriginalPin) && bmallUseOriginalPin.equals("true")) ? queryCrowdIdsReqDTO.getPin().trim() : queryCrowdIdsReqDTO.getPin().trim().toLowerCase(),
                    queryCrowdIdsReqDTO.getSceneId(), fieldVersion, envAlias);
            Long maxCrowdId = 0L;
            Long minCrowdId = Long.MAX_VALUE;
            for (Long crowdId : queryCrowdIdsReqDTO.getCrowdIds()) {
                ...
            }

            jimdbKeyList.add(index + "_" + jimdbKey);
            jimdbKeyCrowdIdListMap.put((index + "_" + jimdbKey), queryCrowdIdsReqDTO.getCrowdIds());

            JimFuture<Set<String>> jimFuture = pipeline.zRangeByScore(jimdbKey, minCrowdId, maxCrowdId);
            jimFutureMap.put((index + "_" + jimdbKey), jimFuture);
        }
        // 执行管道中的命令
        pipeline.flush();
        for (String jimdbKey : jimdbKeyList) {
            ...
        }
        return ServiceResponse.ok(result);
    } catch (Exception e) {
        ...
    } finally {
        ...
    }
}

可以闻到几处bad smell代码:

1、控制逻辑:存在try catch、两层for循环,再加if判断逻辑,即4层逻辑;可以使用函数拆分将循环逻辑独立;

2、函数参数:Ln14-17的String format参数有8个,其中还有复杂的表达式参数,开发者极易在参数表达式调整、参数位置调整上犯错,且难以发现;

3、命名:Ln24的jimdbKeyList保存的不是jimdbKey,而是新构成的一个key;这样的命名有误导性,且不止一处;

4、重复代码:index + “_” + jimdbKey连续出现3次;

5、注释:Ln30的注释"执行管道中的命令"和Ln31的代码含义重复,可以更换为使用pipeline执行命令的意图;

代码不够整洁带来的就是系统维护风险的飙升。代码维护者往往遵循最小改动原则,在本已经复杂的逻辑上再加上几个if else判断来处理异常问题,让圈复杂度再上一个台阶。“勿以恶小而为之,勿以善小而不为”,要改变系统的代码质量,需要每个人都行动起来,重构:重命名一个变量,抽取一个函数,也是一份无量功德。

四、小结寄语

本文从代码之美引出代码整洁之道,代码整洁的重要性不言而喻,它不仅影响着代码的可读性,还关系到项目的整体质量和每个开发者的工作环境。

追求代码之美,追求代码整洁,应该是每位程序员的目标。本文整理了代码整洁最核心的关键点供大家参考,也结合了组织的案例进行分析,这些只是个起点。更为重要的是大家在日常开发中的实践,需要不断地反思和改进系统中的代码,已达到更高的代码整洁度。

“种一棵树最好的时间是十年前,其次就是现在。”

在这里插入图片描述

相关推荐

京东云推出全新JoyCode智能编码工具,让AI Coding从代码生成走向成果交付

全新JoyCode结合项目背景与任务目标,通过Agent Loop持续规划、执行、验证与迭代,并支持多智能体并行协作、模型灵活配置及工具与流程复用,贯通从需求分析到开发验证的任务链路,推动AI Coding从代码生成走向可运行软件与可用工具的成果交付。模型使用的关键,不只是选择更强的能力,而是让投入与任务需要相匹配。作为面向严肃开发场景的企业级编码产品,京东云JoyCode所拓展的,不只是代码生成的能力,更是将专业经验与日常灵感付诸实现的路径,让技术承接实现过程中的繁复,让人更专注于问题、判断与创造。

京东科技开发者 28

GPT-6凌晨上线智能UI:智能UI时代的技术架构重构与应对之道

从命令行到图形界面,计算机行业用了三十年证明了同一件事:人类需要视觉的、空间的、可重复的交互表面,纯文字从来只是过渡形态。智能界面的出现,意味着AI行业第一次大规模承认了这个规律——对话是创造的接口,界面是使用的归宿。生成的界面如何稳定下来?个人的数据与身份如何安全地沉淀?Agent的行动能力如何可信地放大?谁能把这三个问题答好,谁就站在了Personal Agent图形界面时刻的浪潮之巅。

京东科技开发者 221

AI 会写代码之后,交付为什么还没变快?

AI 写代码,只是这场变革的起点,而不是终点。真正决定一个组织能否吃到 AI 红利的,不是"能不能用 AI 写出代码",而是敢不敢用 AI 重新设计交付流程、重新划分角色分工、重新组织团队结构。研发视角能把工具和个人推到极致,却会在组织的边界前止步;只有站上组织视角,把AI × 工具一路推进到AI × 组织,那些被 AI 照出来的摩擦,才会真正被抹平。国际技术部 Multi AI Native 想做的,正是这件事——让 Agent 成为你可靠的数字战友,让每一次迭代交付都快一个量级;

京东科技开发者 311

OxygenData-Vibe搭建:用 AI Coding重新定义数据看板搭建

长期以来,数据看板开发主要有两种方式:一种是使用标准化 BI 工具,交付快、成本低,但图表样式、交互体验和功能扩展都受限于 BI 本身的能力;另一种是自研定制开发,能够充分满足复杂和个性化需求,但需要投入大量研发资源,交付周期也更长。比如一个通过 BI 只需要 1 天就能搭建出来的看板,如果采用自研方式,可能需要投入 30 PD 的研发人力。既然 BI 交付这么快,为什么不把所有看板需求都交给 BI?原因在于,业务某些场景需要的不只是把数据展示出来。

京东科技开发者 374

当我谈数据库高可用时我谈些什么

大家都经常听到说数据库的双1,那双1指的是什么呢?参数=1(最安全)≠1(更快但可能丢)每次提交都把 redo 刷盘0/2:攒着刷,崩溃丢最近 1 秒每次提交都把 binlog 刷盘0/N:攒着刷,崩溃丢最近若干条"双 1"(都设为 1)= 单机不丢已提交事务的前提。生产核心库必须双 1;代价是每次提交两次 fsync。小结:单机层用 WAL 提速、用 2PC 保证 redo/binlog 一致、用崩溃恢复裁决半成品事务、用双 1 兜底持久性。

京东科技开发者 319

ScoAI:面向供应链的运筹原生决策智能

ScoAI 关注的并非 AI 能否进入供应链,而是 AI 参与供应链决策之后,哪些内容适合通过数据学习,哪些关系必须显式计算,以及哪些结果需要依据执行记录进行验证。其基本分工是:供应链业务定义问题、资源与行动后果,运筹学表达目标、约束和协同关系,AI 提供可复用的估计与判断。真正用于改进后续决策的,不仅是模型生成的初始结果,还包括实际采取的行动及其产生的业务反馈。

京东科技开发者 405

拆解海博 AI-Native 落地保障:海博团队 AI 知识库能力建设

绕了一大圈,回头看,我们其实一直在解开头那三个结:AI 读不懂系统、影响面靠人脑记、测试预期没处查。做到这里,本质上是把"AI 用不好"这个问题,从"是不是该换个更强的模型"重新定义成了"怎么把上下文经营好"。顺着这个思路,我们攒下了这么几样东西:•。

京东科技开发者 561

从零构建一个生产级记忆型 AI Agent —— AgentScope 项目全景技术与学习指南

domain 层端口接口(domain)职责适配器实现(infra)对话流水账读写经验记忆检索/落库请求级幂等四态会话元数据 CRUD会话级 Skill 选择态Skill 元数据HITL 权限网关(domain 内含逻辑,见第四篇)StreamSink技术中立的流式下沉(client 层桥接)以幂等端口为例,头部注释明确写道:实现 domain 端口,持有实体不出 infra 边界,对外只暴露嵌套视图GateResult。

京东科技开发者 613

数据涅槃:Agentic 重塑搜推数据生产体系

当前大模型已经能够理解需求、生成代码和解释错误,但数据生产的难点并不只是“写出一段 SQL”。一个需求还要经过数据源确认、口径澄清、加工编排、资源规划、任务提交、调度运行、结果交付和故障处置。任何一步缺少都可能让“看起来正确”的任务变成生产事故。

京东科技开发者 380

81.8 秒的视频,我们改了 15 个版本:一次纯 Codex 驱动的 AI-native 视频实践

81.8 秒、15 个版本,这些数字真正想说明什么?视频制作正在从一组专业软件里的复杂操作,变成一场围绕目标、参考和反馈展开的持续对话。AI 已经可以接住从脚本到交付的大量工作。你可以把精力留给更重要的部分:理解观众、选择故事、判断好坏。过去停在 PPT 和脑海里的想法,现在有机会被快速做成一支能看、能改、也愿意转发的视频。如果明天就要介绍你手头的项目,你最想先把哪一步交给 AI?

京东科技开发者 467

Codex 驱动的移动端AI全栈开发:从 Relay 原型图到可交付链路

AI 编程工具降低了跨端开发门槛,但“让 AI 写页面”并不等于“完成移动端交付”。PC 运营端页面通常以功能闭环为中心,设计约束较弱,研发可以基于组件库快速搭建;移动端 C 端页面直接面对用户,Relay 原型图和 UI 设计稿不仅是视觉参考,更是交互、信息层级、状态反馈和业务信任感的综合契约。

京东科技开发者 593

Claude Code vs Codex 记忆体系深度对比

Claude Code —— 分层自动记忆系统四层分层架构(CLAUDE.md / Auto Memory / Session Memory / AutoDream)构成自优化闭环,系统主动捕获、分类、去冗并跨会话接力经验。走的是自动化优先路线——让机器替人记忆、替人整理,以少量可控性的不确定换取强大的经验积累能力。Codex —— 声明式契约系统两层扁平架构(AGENTS.md 静态声明层 + 会话上下文层),记忆完全由人显式订立、显式修改,系统只读契约、绝不擅自变更。走的是可控性优先。

京东科技开发者 628

上游给空、下游拿到 -1,我把故障一直追到了 commons-beanutils 的构造函数

这篇手记是一份事后复盘,写在我们已经把修复推上线、把测试用例跑绿、把约束文档沉淀进团队库之后。非研发同事,可以直接从第八章开始看,前七章都是讲排障和代码分析。故障本身不复杂,修复也不复杂,但这次排查真正让我想写下来的,不是技术本身——而是从问题提报到解决全程AI的作用:问题定位:业务方反馈了一个异常单号说「下发失败」,一线运维同事直接在日志系统捞到相关的系统日志,用IDE打开下游代码库,把异常信息给到JoyCode——AI 直接指向了问题是serialType值非法,系统只接受0和1,而当前上游给的是-1。

京东科技开发者 719

SKill测评:谁才是真正的Skill之王?

巧合的是,阿里近期开源了一款名为 Skill-Up 的测评工具——它专门面向 Agent Skill 开发者,支持在 Claude Code、Codex、Qoder CLI 等真实 Agent Engine 环境中验证 Skill 的功能正确性,并可将失败用例转化为精准的修复指引,同时支持本地与 CI 环境的持续回归。2026年,Skill 的热度不减,已成为 AI 辅助编程领域的标配。在日常研发中,无论是沉淀个人经验,还是将团队的优秀范本标准化,将知识“蒸馏”为 Skill 已是大家的常规操作。

京东科技开发者 640

让AI真正参与工作!JoyDesk已上线京东云

JoyDesk提供覆盖AI资产管理、权限控制、安全策略、审批审计、运营监控等企业级治理能力,支持按组织、角色和项目进行精细化权限管理,并支持私有化部署,确保企业数据边界清晰、AI行为全程可追溯、安全策略灵活可配置,满足金融、政企等行业对数据安全和合规治理的要求,让AI真正成为企业可信赖的生产力。JoyDesk支持MCP协议、标准API、技能等多种开放接入方式,可快速连接企业现有业务系统,将业务能力封装为AI可调用的技能和专家,让AI能够理解业务流程、调用业务系统、完成业务任务,而无需改变企业原有IT架构。

京东科技开发者 673

【全栈实践】第一个 AI Agent 项目:从零搭建 AI 音频创作助手【最终版】

这个项目展示了AI Agent 在垂直内容创作领域端到端自动化:从内容理解到播客输出,全流程 AI 驱动多模态融合:文字、图片、音频、视频统一处理专业级音频质量:音色设计 + 智能混音,输出广播级品质低门槛使用:可视化配置 + 自然语言交互,无需技术背景。

京东科技开发者 563

【全栈实践】第一个 AI Agent 项目:从零搭建 AI 音频创作助手(高级篇)

这是一个 AI 驱动的播客创作助手,专注于从文字/视频/音频内容识别到播客制作的全流程。你可以用自然语言与它对话,也可以上传视频和音频,它会理解意图、调用相应的语音合成工具,把他们变成真实的播客音频。

京东科技开发者 728

【全栈实践】第一个 AI Agent 项目:从零搭建 AI 音频创作助手(进阶篇)

这是一个AI 驱动的音频内容创作助手。你可以用自然语言与它对话,它会理解意图、调用相应的语音合成工具,把文字变成真实的播客音频,并保存在本地。关于项目的详细介绍见第一篇文章:第一个 AI Agent 项目:从零搭建 AI 音频创作助手(入门篇)这篇文章更多介绍进阶篇添加的功能。

京东科技开发者 552

【全栈实践】第一个 AI Agent 项目:从零搭建 AI 音频创作助手(入门篇)

这个项目让我第一次把前端、后端、AI Agent 三块内容独立串联起来。技术选型上每一块都是当下主流的方案,实际跑通整条链路之后对"全栈"有了更具体的感受。框架版本要锁定:LangChain 这类快速迭代的框架,版本差异带来的问题远比你想象的多先跑通链路,再追求完美:新手阶段能把用户输入 → AI 处理 → 结果展示这条链跑通,比深入某个技术点更有价值多看官方文档:相比博客和教程,官方文档更新及时,特别是 LangGraph 这种新框架后续计划继续迭代,欢迎交流!

京东科技开发者 610

ICLR 2026 | 面向序列决策的贝叶斯集成方法

在这篇工作中,我们关注的是。

京东科技开发者 296

ICML 2026|NaviAgent:面向 Oxygen 智能体的可扩展工具编排

大型语言模型(LLM)越来越多地作为函数调用代理,调用外部工具来处理超出其静态知识范围的任务。然而,它们通常一次只调用一个工具,缺乏对任务结构的全局视图。由于工具之间往往相互依赖,这会导致错误累积和可扩展性差,尤其是在扩展到数百或数千个工具时。为了解决这些局限性,我们提出了NaviAgent,一种显式的双层架构,它通过基于图的工具关系建模将任务规划与工具执行解耦。在规划层,基于 LLM 的代理决定是直接响应、澄清意图,还是检索并执行一个独立于工具间复杂性的工具链。

京东科技开发者 389

实测 9 款 AI 架构图工具:从 Mermaid 美化到 GPT-Image2,一份选型清单

支持 5 类图(架构图、工作流图、时序图、数据流图、生命周期/状态机图),主题 4 种(Classic、Signal Flow、Blueprint、Editorial)+ 3 种色彩模式(Dark / Light / System Auto),输出格式含 HTML、PNG、SVG、WebM、Share Card PNG、JSON IR。它把提示词图库、图像生成案例、参考图编辑流程和命令行工具整合在一起,让 AI Agent 能直接调用 GPT Image 2 模型完成文生图、图生图、参考图编辑等任务。

京东科技开发者 906

别再守着 Claude Code 了——学会指挥它自主干活

回到开头那句:别再一句一句地喂它、然后守着屏幕。真正的用法是——把一件事想清楚、划好边界、给它一个能自我验证的目标,然后交出去。你会发现,省下来的时间不是一点半点。把重复的判断和执行还给机器,把真正需要你的判断留给自己。

京东科技开发者 587

CVPR 2026|Oxygen XR 团队在原生鱼眼高斯泼溅技术上带来新突破

京东零售技术团队联合清华大学提出DirectFisheye-GS框架,创新性地将鱼眼相机模型原生嵌入3D高斯泼溅管线,通过跨视角联合优化策略直接处理鱼眼图像,避免了传统去畸变预处理导致的信息损失。该方案在多个公开数据集上达到SOTA性能,有效解决了单视角优化引起的几何畸变和视角不一致问题,同时保持与现有3DGS工具链的兼容性。技术已应用于电商3D重建和4D体积视频等场景,显著提升了沉浸式体验。相关论文被CVPR 2026接收,为宽视场场景重建提供了高效解决方案。

京东科技开发者 355

拆解海博 AI-Native 落地保障:Harness、双 Loop、知识库与技能自主迭代实践

海博研发RoadMap 的落地,彻底终结了 AI 编程“对话式玄学”的旧模式,真正落地了AI Native 研发工程化。它证明 AI 规模化赋能研发的核心,不在于堆砌大模型能力,而在于用工程思维重构 AI 的工作范式:用结构化流程替代随机对话,用固化规则约束模型行为,用持续沉淀实现能力复利,用分层架构支撑规模化落地。

京东科技开发者 638

让 AI 快速「读懂」你的代码仓:Joy-Code-Graph 云端图谱服务的三次进化

代码知识图谱不是要取代 AI 的智能,而是要补齐它对代码全局关系的认知盲区。当 AI 能一眼看清「谁调用了谁、改动会波及哪里」,它写出的代码才真正靠谱;当这份认知安全地留在自己手里、随时被 Joygen 调用、并且永久沉淀在代码仓里——AI 编程的体验,才算真正上了一个台阶。这,就是我们做 Joy-Code-Graph 云端服务的初衷。能力共享,数据自主;一次建图,长期受用。

京东科技开发者 752

【Coding生态】从代码托管到 AI 能力底座:与Coding一起共建 AI 研发生态

前两种框架能够很好地支撑对话式能力和预设流程式能力。它们适合基于提示词或预设工作流完成研发问答、知识查询、流程编排等任务。但在更复杂的研发场景中,仅仅“回答问题”还不够。当用户业务逻辑复杂时,一旦场景进入真实落地阶段,例如下载代码、修改文件、执行命令、安装依赖、运行测试、读取完整代码文件,或者与自有系统联动、将结果渲染到 Coding 页面、推送到京 ME,AI 应用需要的不只是知识能力,还需要真实的代码库操作能力和独立可执行环境。

京东科技开发者 768

GPT-5.6、ChatGPT Work 与 Codex 更新食用指南

三档模型当前都提供 1,050,000 tokens 上下文、922,000 tokens 最大输入和 128,000 tokens 最大输出,接受文本与图像输入、输出文本,并支持 web search、file search、Computer Use、MCP、Tool Search、Skills、Apply Patch 等工具。Work 可以读取你提供的文件,通过插件连接 Slack、Google Drive、SharePoint、邮箱、日历、CRM 或项目系统,调用获批工具,并在执行中展示进度。

京东科技开发者 871

把业务流程沉淀成高质量 Skill 的实践路径

使用Record & Replay创建的Skill,尽管创建流程简单,但它的本质实际是让 AI 去操作页面,这不但有可能影响我们对电脑的操作,还有可能无法稳定复现。创建Skill时,可以使用 Codex 的 Record & Replay 插件,把一次手工操作录下来,再让 AI 生成可复用流程。刚开始切换时,很容易遇到接口报错,可以让Codex排查原因进行优化,直到可以稳定执行;补充相应业务背景,说明这件事为什么要做,谁会用,输入从哪来,输出给谁看。电脑休眠、关机、软件没开时,本地任务可能无法执行。

京东科技开发者 836

政企前台AI-Agent的架构实践:打造可复用的 AI 服务平台-【灯塔计划】

不止是爆火的龙虾,还是各种Skills,MCP、Agent,脱离的具体的场景谈方案,最后只会是一场空。这一套可复用的 AI 服务平台,截止目前,通过前后端对接规范文档,多项能力已快速接入到各个场域的不同端平台,大幅降低研发成本, 并且各业务线新场景的接入从原来的 “开发驱动” 转为 “配置驱动”,接入周期从天维度缩短至小时级。

京东科技开发者 864
上一篇: 行稳、致远 | 技术驱动下的思考感悟
下一篇: RAG实践:一文掌握大模型RAG过程
京东云开发者
京东云开发者 企业官方账号 企业官方账号
博客等级 码龄8年 1万+粉丝 2141原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值