Go语言增删改查接口事务一致性难题破解：从单表到分布式Saga的4种落地形态

第一章：Go语言增删改查接口事务一致性难题全景透视

在高并发微服务场景中，Go语言编写的CRUD接口常面临事务边界模糊、数据库连接复用不当、异常路径未回滚等导致的一致性断裂问题。典型表现包括：用户创建成功但关联配置未写入、订单状态更新与库存扣减不同步、软删除标记与关联数据清理脱节等。

事务生命周期管理失配

Go标准库database/sql的Tx对象不具备自动传播能力，HTTP handler中开启事务后，若业务逻辑分散在多个函数调用链中，极易因忘记传递*sql.Tx或误用db.Exec（直连连接池）导致部分操作脱离事务上下文。正确做法是显式传递事务对象并统一约束执行入口：

func createOrder(tx *sql.Tx, order Order, items []Item) error {
    // 使用 tx 而非全局 db，确保所有操作在同一事务内
    if _, err := tx.Exec("INSERT INTO orders (...) VALUES (...)", 
        order.ID, order.Status); err != nil {
        return fmt.Errorf("insert order: %w", err)
    }
    for _, item := range items {
        if _, err := tx.Exec("INSERT INTO order_items (...) VALUES (...)", 
            item.OrderID, item.ProductID); err != nil {
            return fmt.Errorf("insert item: %w", err)
        }
    }
    return nil // 无错误则由调用方决定 Commit 或 Rollback
}

并发修改引发的幻读与丢失更新

当多个请求同时读取同一记录进行“读-改-写”时，SELECT ... FOR UPDATE缺失将导致最终状态不可预测。例如库存扣减需满足“余额 ≥ 扣减量”，但未加行锁时可能两个请求均读到充足库存而双双扣减成功。

场景	风险类型	推荐防护机制
多表关联更新	部分回滚失效	使用 tx.QueryRow + FOR UPDATE 锁定主表及外键引用行
异步任务触发CRUD	事务跨goroutine失效	禁止在goroutine中使用handler传入的*sql.Tx，改用消息队列解耦
JSON字段原子更新	应用层竞态	改用数据库原生JSON函数（如PostgreSQL jsonb_set）或CAS模式

上下文超时与连接泄漏耦合

HTTP请求上下文超时后，若事务未及时Rollback()，空闲连接将滞留在sql.Tx中直至GC，加剧连接池耗尽。务必在defer中检查事务状态：

tx, err := db.BeginTx(ctx, nil)
if err != nil { return err }
defer func() {
    if p := recover(); p != nil || err != nil {
        tx.Rollback() // 显式回滚，避免连接泄漏
    }
}()

第二章：单表场景下的ACID保障与Go实践

2.1 基于database/sql原生事务的CRUD封装与异常回滚机制

核心封装设计原则

• 将 *sql.Tx 作为上下文透传载体，避免全局事务状态
• 所有 CRUD 方法接收 context.Context 和 *sql.Tx，统一异常出口
• 使用 defer tx.Rollback() 配合显式 tx.Commit() 实现“成功才提交”语义

关键事务控制流程

func CreateUser(ctx context.Context, tx *sql.Tx, user User) error {
    stmt := `INSERT INTO users(name, email) VALUES(?, ?)`
    _, err := tx.ExecContext(ctx, stmt, user.Name, user.Email)
    if err != nil {
        return fmt.Errorf("create user failed: %w", err) // 包装错误便于追踪
    }
    return nil
}

逻辑分析：ExecContext 支持超时与取消；%w 保留原始错误链；返回非 nil 错误将触发外层回滚。参数 ctx 控制生命周期，tx 确保操作在同事务内。

回滚触发条件对照表

场景	是否自动回滚	说明
函数返回 nil	❌	需显式调用 tx.Commit()
返回 error	✅	外层 defer 执行 Rollback
ctx.Done() 触发	✅	ExecContext 立即返回错误

graph TD
    A[Begin Tx] --> B[执行 CRUD]
    B --> C{返回 error?}
    C -->|是| D[Rollback]
    C -->|否| E[Commit]

2.2 使用sqlx增强型查询构建类型安全的增删改查接口

sqlx 通过 QueryRowx、Select 等泛型方法，将数据库行直接映射为 Go 结构体，规避 interface{} 类型断言风险。

类型安全的查询示例

type User struct {
    ID    int    `db:"id"`
    Name  string `db:"name"`
    Email string `db:"email"`
}

func GetUser(db *sqlx.DB, id int) (*User, error) {
    var u User
    err := db.Get(&u, "SELECT id, name, email FROM users WHERE id = $1", id)
    return &u, err
}

db.Get 自动完成扫描与结构体字段绑定；db:"xxx" 标签声明列名映射，缺失标签时默认匹配字段名（大小写敏感）。

sqlx vs database/sql 能力对比

特性	database/sql	sqlx
结构体自动扫描	❌	✅
命名参数支持	❌	✅ (sqlx.Named)
批量插入（In）	❌	✅

查询构建流程

graph TD
    A[定义结构体+db标签] --> B[调用db.Get/Select]
    B --> C[sqlx解析SQL+参数]
    C --> D[反射匹配字段→扫描结果]
    D --> E[返回强类型实例]

2.3 事务超时控制与上下文传播在HTTP Handler中的落地实现

超时感知的 Context 封装

使用 context.WithTimeout 在请求入口注入可取消生命周期，确保数据库操作、下游调用均受统一超时约束：

func transactionHandler(w http.ResponseWriter, r *http.Request) {
    // 从 HTTP header 提取业务超时（单位秒），默认 5s；上限防滥用设为 30s
    timeoutSec := min(max(5, getIntHeader(r, "X-Timeout", 5)), 30)
    ctx, cancel := context.WithTimeout(r.Context(), time.Duration(timeoutSec)*time.Second)
    defer cancel() // 确保资源及时释放

    // 将增强后的 ctx 透传至业务链路
    if err := runTransaction(ctx); err != nil {
        http.Error(w, err.Error(), http.StatusGatewayTimeout)
        return
    }
    w.WriteHeader(http.StatusOK)
}

逻辑分析：r.Context() 继承自 http.Server 的请求上下文，WithTimeout 创建带截止时间的新上下文。cancel() 必须显式调用以触发内部 timer 停止并释放 goroutine 引用。getIntHeader 是安全解析 header 的工具函数，避免 panic。

上下文跨层传播关键点

• ✅ 所有 I/O 操作（db.QueryContext, http.Do, redis.Client.Get(ctx, key)）必须显式接收 ctx 参数
• ❌ 不可仅依赖 time.Sleep 或无上下文阻塞调用，否则超时失效
• ⚠️ 中间件需通过 next.ServeHTTP(w, r.WithContext(newCtx)) 更新请求上下文

超时策略对比表

策略	优点	风险
全局 Server ReadTimeout	配置简单	无法区分读/写/业务逻辑超时
Context 逐层传递	精确控制各阶段生命周期	开发者易遗漏 ctx 参数传递
自定义中间件注入	统一注入 + 日志埋点	增加中间件链长度与性能开销

请求生命周期流程

graph TD
    A[HTTP Request] --> B[Middleware: 注入超时Context]
    B --> C[Handler: runTransaction ctx]
    C --> D[DB: QueryContext]
    C --> E[RPC: Do with ctx]
    D & E --> F{任一 ctx.Done?}
    F -->|是| G[Cancel all ops, return 504]
    F -->|否| H[Success]

2.4 并发写冲突应对：乐观锁（version字段）与CAS更新的Go代码范式

为什么需要乐观锁

在高并发场景下，多个协程可能同时读取同一记录、各自计算后写回，导致后写覆盖前写（Lost Update）。version 字段配合 CAS（Compare-And-Swap）是轻量级无锁解决方案。

Go 中的 CAS 更新范式

type User struct {
    ID      int64
    Name    string
    Version int64 // 乐观锁版本号，初始为0
}

// CAS 更新函数：仅当数据库中 version == expectedVersion 时才更新
func UpdateUserNameCAS(db *sql.DB, id int64, newName string, expectedVersion int64) (int64, error) {
    result, err := db.Exec(
        "UPDATE users SET name = ?, version = version + 1 WHERE id = ? AND version = ?",
        newName, id, expectedVersion,
    )
    if err != nil {
        return 0, err
    }
    rows, _ := result.RowsAffected()
    return rows, nil // 返回影响行数：0 表示冲突，1 表示成功
}

逻辑分析：SQL WHERE 子句强制校验 version，原子性保证“读-判-写”一体；expectedVersion 由上一次查询获得，是客户端持有的“快照版本”。

冲突处理策略对比

策略	阻塞开销	实现复杂度	适用场景
悲观锁（SELECT FOR UPDATE）	高	低	事务长、冲突频发
乐观锁（version + CAS）	零	中	读多写少、冲突率低

重试机制示意（mermaid）

graph TD
    A[获取当前User及Version] --> B{CAS更新成功？}
    B -- 否 --> C[重读最新Version]
    C --> D[重新计算业务逻辑]
    D --> B
    B -- 是 --> E[提交完成]

2.5 单元测试驱动：使用testcontainers+PostgreSQL验证事务原子性边界

为什么需要容器化数据库测试

本地H2无法准确模拟PostgreSQL的锁行为、隔离级别实现与崩溃恢复逻辑，导致事务边界验证失真。

核心依赖配置

<dependency>
    <groupId>org.testcontainers</groupId>
    <artifactId>postgresql</artifactId>
    <scope>test</scope>
</dependency>

→ 引入轻量PostgreSQL容器镜像（postgres:15-alpine），支持自动启动/清理，端口动态绑定。

原子性验证用例设计

@Test
void whenRollback_thenNoPartialInserts() {
    // 启动事务并插入两条记录，显式rollback
    jdbc.update("INSERT INTO accounts(id, balance) VALUES (?, ?)", 1, 100);
    jdbc.update("INSERT INTO accounts(id, balance) VALUES (?, ?)", 2, 200);
    transactionTemplate.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
    transactionTemplate.execute(status -> { throw new RuntimeException(); }); // 触发回滚
    assertThat(jdbc.queryForObject("SELECT COUNT(*) FROM accounts", Integer.class)).isEqualTo(0);
}

→ 使用@Transactional失效场景验证：异常抛出后，JDBC连接未提交任何变更，确保ACID中A（原子性）被容器级PostgreSQL真实保障。

验证维度	H2 模拟结果	PostgreSQL 容器结果
SERIALIZABLE 锁等待	✅（不准确）	✅（真实MVCC阻塞）
SAVEPOINT 回滚粒度	⚠️（部分支持）	✅（完整支持）

graph TD
    A[启动Testcontainer PG] --> B[初始化schema]
    B --> C[执行带异常事务]
    C --> D{PostgreSQL WAL日志是否清空?}
    D -->|是| E[原子性通过]
    D -->|否| F[事务残留 → 失败]

第三章：跨表关联操作的一致性挑战与Go解法

3.1 外键约束失效场景下基于应用层事务边界的建模与校验

当数据库外键被禁用（如分库分表、跨服务写入或兼容性降级），数据一致性保障需上移至应用层。此时，事务边界不再由数据库自动锚定，而需显式建模业务语义。

数据同步机制

采用“写后校验+补偿事务”双阶段策略：

• 先在本地事务中持久化主实体与关联引用（非外键字段）
• 再异步触发一致性校验任务

# 应用层事务边界定义示例（Django ORM）
with transaction.atomic():  # 显式事务起点
    order = Order.objects.create(user_id=123, status='pending')
    # 关联 user_id 仅作业务逻辑引用，无DB外键约束
    OrderItem.objects.bulk_create([
        OrderItem(order=order, sku='A001', qty=2),
        OrderItem(order=order, sku='B002', qty=1)
    ])
# 事务提交后，触发下游校验（如检查 user_id 是否真实存在）

该代码块中 transaction.atomic() 界定了强一致性操作范围；user_id 虽无外键约束，但通过后续校验服务验证其有效性，将完整性责任从DDL层迁移至应用契约层。

校验策略对比

策略	实时性	一致性强度	适用场景
同步RPC校验	高	强	单体/低QPS核心链路
异步消息校验	中	最终一致	分布式、高吞吐场景
定时扫描修复	低	弱	容错兜底、离线稽核

graph TD
    A[创建订单] --> B{写入Order主表}
    B --> C[写入OrderItem明细]
    C --> D[发布校验事件到MQ]
    D --> E[消费者查询User服务]
    E --> F{User存在？}
    F -->|是| G[标记校验通过]
    F -->|否| H[触发告警+补偿流程]

3.2 使用GORM钩子（Hooks）与嵌入式事务管理器协调多表CRUD

在复杂业务中，用户创建需同步写入 users、profiles 和 audit_logs 三张表。GORM 钩子与事务管理器协同可保障原子性。

数据同步机制

使用 AfterCreate 钩子触发关联数据写入，并由嵌入式事务管理器统一控制回滚边界：

func (u *User) AfterCreate(tx *gorm.DB) error {
    return tx.Transaction(func(txCtx *gorm.DB) error {
        if err := txCtx.Create(&Profile{UserID: u.ID, Bio: ""}).Error; err != nil {
            return err // 自动回滚整个事务
        }
        return txCtx.Create(&AuditLog{Action: "user_created", TargetID: u.ID}).Error
    })
}

逻辑分析：AfterCreate 在主 User 记录插入后执行；tx.Transaction() 启动嵌套事务（复用父事务上下文），任一子操作失败即触发全链路回滚。参数 tx 是当前操作的 *gorm.DB 实例，已携带事务状态。

钩子执行顺序保障

钩子阶段	触发时机	是否在事务内
BeforeCreate	INSERT 前	是
AfterCreate	INSERT 成功后（含主键）	是
AfterSave	Create/Update 后	是

graph TD
    A[Begin Transaction] --> B[BeforeCreate]
    B --> C[INSERT users]
    C --> D[AfterCreate]
    D --> E[Transaction: INSERT profiles]
    E --> F[INSERT audit_logs]
    F --> G[Commit/Abort]

3.3 分布式唯一约束的本地化补偿：Snowflake ID + 业务幂等键设计

在高并发分布式写入场景中，全局唯一ID（如Snowflake）仅保障ID层面不重复，无法防止业务语义重复（如同一用户重复下单）。需叠加业务幂等键实现逻辑层唯一性控制。

核心设计模式

• Snowflake ID 提供毫秒级有序、全局唯一主键
• 业务幂等键 = 业务类型:租户ID:业务唯一标识（如 order:tenant_001:email=alice@ex.com:20240520）

幂等写入流程

-- 基于唯一索引的插入+忽略冲突（MySQL ON DUPLICATE KEY UPDATE）
INSERT INTO orders (id, user_id, email, created_at, idempotency_key)
VALUES (1234567890123456789, 'u_001', 'alice@ex.com', NOW(), 'order:tenant_001:alice@ex.com:20240520')
ON DUPLICATE KEY UPDATE status = IF(status = 'pending', VALUES(status), status);

逻辑分析：idempotency_key 建唯一索引；冲突时仅更新非关键字段，避免覆盖已处理状态。VALUES(status) 引用新值，IF 确保“首次成功写入”语义不被覆盖。

组件	作用	约束要求
Snowflake ID	物理主键，支持分库分表路由	64位整数，无业务含义
幂等键	业务维度去重锚点	必须含租户+业务标识+时间粒度

graph TD
    A[客户端生成幂等键] --> B[请求携带ID+幂等键]
    B --> C{DB执行INSERT...ON DUPLICATE}
    C -->|成功| D[返回201]
    C -->|冲突| E[查原记录状态]
    E --> F[返回原结果/重试提示]

第四章：迈向分布式：Saga模式在Go微服务CRUD链路中的渐进式演进

4.1 Choreography模式：基于NATS JetStream事件驱动的Saga编排实现

在Choreography模式中，各服务通过事件协作而非中心协调器调度。NATS JetStream 提供持久化、有序、可回溯的事件流，天然适配 Saga 的分布式事务补偿需求。

事件建模与流定义

# 创建订单事件流，保留7天，支持多副本容错
nats stream add ORDERS \
  --subjects "order.created,order.payment.failed,order.shipped" \
  --retention "limits" \
  --max-age "168h" \
  --replicas 3

该命令声明了 ORDERS 流，绑定关键业务事件主题；--max-age 确保事件在补偿窗口期内可重放，--replicas 提升 JetStream 集群可用性。

Saga 参与者职责对齐表

服务	监听事件	发布事件	补偿动作
Order Service	—	order.created	order.cancelled
Payment Service	order.created	payment.processed / payment.failed	payment.refunded
Shipping Service	payment.processed	order.shipped	shipment.reverted

执行流程（简化版）

graph TD
  A[Order Created] --> B[Payment Processed]
  B --> C[Shipment Dispatched]
  B -.-> D[Payment Failed → Refund]
  C -.-> E[Shipment Failed → Revert]

各服务独立消费、处理并发布事件，无共享状态，仅依赖事件最终一致性。

4.2 Orchestration模式：使用Temporal Go SDK构建可观察、可重试的Saga工作流

Saga模式通过一系列本地事务与补偿操作保障分布式数据一致性。Temporal以持久化工作流状态机为核心，天然支持长周期、高可靠编排。

核心优势对比

特性	传统Saga（手动实现）	Temporal Saga
状态恢复	依赖外部存储+人工干预	自动快照+断点续跑
补偿触发	显式调用+幂等设计复杂	ExecuteChildWorkflow + CancelWorkflow 声明式编排

工作流定义示例

func TransferWorkflow(ctx workflow.Context, input TransferInput) error {
    ao := workflow.ActivityOptions{
        StartToCloseTimeout: 10 * time.Second,
        RetryPolicy: &temporal.RetryPolicy{MaximumAttempts: 3},
    }
    ctx = workflow.WithActivityOptions(ctx, ao)

    // 扣减余额（正向活动）
    if err := workflow.ExecuteActivity(ctx, DeductBalance, input).Get(ctx, nil); err != nil {
        return err
    }

    // 转账（正向活动）
    if err := workflow.ExecuteActivity(ctx, TransferFunds, input).Get(ctx, nil); err != nil {
        // 触发补偿：仅当后续失败时回滚前序
        workflow.ExecuteActivity(ctx, RefundDeducted, input).Get(ctx, nil)
        return err
    }
    return nil
}

该工作流利用Temporal的确定性执行引擎：所有workflow.*调用被序列化为事件日志；超时与重试由服务端自动注入；补偿逻辑与正向逻辑共享同一上下文，确保语义一致。RetryPolicy参数控制指数退避策略，StartToCloseTimeout保障单次活动不无限挂起。

4.3 补偿事务的Go泛型封装：CompensatableCommand[T]与自动回滚策略注册中心

补偿事务需解耦业务逻辑与恢复行为。CompensatableCommand[T] 以泛型统一命令契约：

type CompensatableCommand[T any] struct {
    Execute func() (T, error)
    Compensate func(T) error
    ID string
}

• Execute 执行主操作并返回结果（如订单ID、库存快照）；
• Compensate 接收该结果执行逆向操作，保障幂等性；
• ID 用于全局追踪与去重。

自动回滚策略注册中心

注册中心通过 map[string]func(interface{}) error 维护类型化补偿器：

类型标识	补偿器作用	幂等保障方式
“order”	取消订单并释放库存	基于订单状态校验
“payment”	原路退款并更新支付流水	依赖外部支付单号

数据同步机制

当 Execute() 成功后，其返回值自动传入注册中心匹配的 Compensate 函数，触发条件式回滚：

graph TD
    A[Execute()] -->|success → T| B[Register.Get(ID)]
    B --> C{Compensate found?}
    C -->|yes| D[Call Compensate(T)]
    C -->|no| E[panic: missing strategy]

4.4 Saga日志持久化与断点续传：基于WAL+SQLite轻量级事务状态机设计

Saga模式需可靠记录每步执行状态，以支持失败回滚与断点续传。我们采用 SQLite 的 WAL（Write-Ahead Logging）模式作为底层日志载体，兼顾 ACID 语义与嵌入式轻量性。

数据同步机制

WAL 模式下，所有 Saga 步骤写入 saga_log 表，含字段：id, saga_id, step, status, payload, created_at, retries。

字段	类型	说明
saga_id	TEXT	全局唯一 Saga 跟踪 ID
status	TEXT	pending/executed/compensated/failed

状态机核心逻辑

def persist_step(saga_id: str, step: str, status: str, payload: dict):
    conn.execute(
        "INSERT INTO saga_log (saga_id, step, status, payload, created_at) "
        "VALUES (?, ?, ?, ?, datetime('now'))",
        (saga_id, step, status, json.dumps(payload))
    )
    conn.commit()  # WAL 模式下仅刷写 WAL 文件，低延迟

该函数确保每步原子落盘；conn.commit() 在 WAL 模式中不触发完整 checkpoint，仅追加日志页，保障高吞吐。

断点恢复流程

graph TD
    A[启动恢复] --> B{扫描最新 saga_id}
    B --> C[按 created_at 排序]
    C --> D[定位首个 status != 'executed']
    D --> E[重放或补偿]

• WAL 启用：PRAGMA journal_mode = WAL;
• 自动 checkpoint 阈值设为 1000 页，平衡性能与恢复速度。

第五章：从理论到生产：Go事务一致性架构的演进路线图

从单体数据库事务到分布式Saga模式

某跨境电商平台在2022年Q3将订单服务从MySQL单库单表重构为微服务架构。初期采用本地事务（sql.Tx）保障下单、库存扣减、积分发放三步原子性，但随着履约中心拆分为独立服务，跨服务调用导致ACID失效。团队引入基于消息队列的Saga模式：下单成功后发布OrderCreated事件，库存服务消费后执行ReserveStock并发布StockReserved，失败则触发CompensateStock反向操作。关键代码片段如下：

func (s *OrderService) CreateOrder(ctx context.Context, req *CreateOrderReq) error {
    tx, err := s.db.BeginTx(ctx, nil)
    if err != nil { return err }
    defer tx.Rollback()

    if err = s.repo.CreateOrder(tx, req); err != nil { return err }
    if err = s.repo.CreateOrderEvents(tx, req.ID, "ORDER_CREATED"); err != nil { return err }
    return tx.Commit()
}

基于TCC的精细化资源控制

在秒杀场景中，Saga的最终一致性无法满足毫秒级库存强校验需求。团队改用TCC（Try-Confirm-Cancel）模式，将库存服务拆解为三个阶段：Try阶段预占库存（写入stock_reservation表并设置TTL）、Confirm阶段真正扣减、Cancel阶段释放预留。通过github.com/go-redsync/redsync/v4实现分布式锁保障Try幂等性，并在Confirm阶段使用UPDATE stock SET quantity = quantity - ? WHERE id = ? AND reserved_quantity >= ?进行CAS校验。

混合一致性策略的灰度演进路径

下表展示了该平台在18个月内分阶段落地的事务一致性方案对比：

阶段	时间窗口	核心组件	一致性模型	平均端到端延迟	失败回滚耗时
V1	2022.07-2022.12	MySQL本地事务	强一致性	42ms	0ms
V2	2023.01-2023.06	RabbitMQ + Saga	最终一致性	187ms	3.2s
V3	2023.07至今	Redis分布式锁 + TCC	强一致+补偿	95ms	86ms

生产环境可观测性增强实践

为追踪跨服务事务链路，在OpenTelemetry SDK基础上扩展了TransactionContext结构体，自动注入trace_id、tx_id、compensation_chain字段。当ConfirmStock超时失败时，Prometheus指标transaction_compensation_failed_total{service="inventory",reason="timeout"}触发告警，并通过Grafana面板关联展示该tx_id下的所有Saga步骤状态变迁。

flowchart LR
    A[Order Service: Try] -->|ReserveStock| B[Inventory Service]
    B -->|Success| C[Order Service: Confirm]
    B -->|Failure| D[Order Service: Cancel]
    C -->|Success| E[Points Service: AddPoints]
    E -->|Failure| F[Order Service: CompensatePoints]

故障注入验证机制

团队在CI/CD流水线中集成Chaos Mesh，对Kubernetes集群中的库存服务Pod随机注入网络延迟（500ms±200ms）和CPU压力（80%占用率），持续运行72小时。统计显示V2版本Saga模式在127次故障中，93%的事务在5秒内完成补偿，剩余7%因消息重复消费导致双倍扣减——该问题通过在CompensateStock中增加ON CONFLICT DO NOTHING语句修复。

灰度发布中的事务兼容性设计

新旧事务模式并存期间，采用“双写+读取路由”策略：所有订单创建同时写入order_v1（本地事务表）和order_v2（事件溯源表），读取时根据feature_flag决定返回哪个版本数据。通过github.com/google/uuid生成全局唯一tx_id，确保跨版本日志可追溯。上线首周监控发现1.3%的order_v2记录缺失StockReserved事件，经排查系RabbitMQ镜像队列同步延迟导致，最终将镜像队列同步策略从all调整为exactly。