flowchart TB
    subgraph PublicAPI["公开 API 层 (graphdb-api)"]
        GDB[GraphDatabaseService]
        TX[Transaction]
        Node[Node]
        Rel[Relationship]
    end
    
    subgraph KernelAPI["内核 API 层 (kernel-api)"]
        Kernel[Kernel]
        KTxAPI[KernelTransaction<br/>接口]
        Read[Read API]
        Write[Write API]
        Token[Token API]
        Schema[Schema API]
        Cursors[Cursor Factory]
    end
    
    subgraph KernelImpl["内核实现层 (kernel)"]
        KernelImpl[KernelImpl]
        KTxs[KernelTransactions<br/>事务池]
        KTxImpl[KernelTransactionImpl<br/>事务实现]
        
        subgraph TxState["事务状态管理"]
            TxStateObj[TxState<br/>内存缓冲]
            Operations[Operations<br/>读写操作实现]
            TxStateUpdater[IndexTxStateUpdater<br/>索引状态同步]
        end
        
        subgraph CommitFlow["提交流程"]
            CommitProc[TransactionCommitProcess]
            Committer[TransactionCommitter]
            CmdCreator[CommandCreationContext<br/>命令生成]
        end
        
        subgraph LockMgmt["锁管理"]
            LockClient[LockManager.Client]
            EntityLocks[EntityLocks<br/>实体锁接口]
        end
    end
    
    subgraph Storage["存储引擎层"]
        StorageEng[StorageEngine]
        StorageReader[StorageReader]
        WAL[TransactionLog<br/>WAL]
    end
    
    GDB --> Kernel
    TX --> KTxAPI
    Node --> Read
    Rel --> Read
    
    Kernel --> KernelImpl
    KTxAPI --> KTxImpl
    KernelImpl --> KTxs
    KTxs --> KTxImpl
    
    KTxImpl --> TxState
    KTxImpl --> CommitFlow
    KTxImpl --> LockMgmt
    
    Operations --> TxStateObj
    Operations --> StorageReader
    
    CommitProc --> CmdCreator
    CommitProc --> WAL
    CommitProc --> StorageEng
    
    Committer --> CommitProc
    KTxImpl --> Committer
    
    LockClient --> EntityLocks
    
    Read --> Cursors
    Write --> Operations

classDiagram
    class KernelTransaction {
        <<interface>>
        +commit() long
        +rollback() void
        +dataRead() Read
        +dataWrite() Write
        +tokenRead() TokenRead
        +tokenWrite() TokenWrite
        +schemaRead() SchemaRead
        +schemaWrite() SchemaWrite
        +locks() Locks
        +cursors() CursorFactory
        +close() long
    }
    
    class KernelTransactionImplementation {
        -TransactionId transactionId
        -TransactionWriteState writeState
        -TxState txState
        -LockManager.Client lockClient
        -long startTimeMillis
        -TransactionTimeout timeout
        -SecurityContext securityContext
        -CursorContext cursorContext
        
        +initialize(lastCommittedTx, type, ...) this
        +commit(monitor) long
        +rollback() void
        +dataRead() Read
        +dataWrite() Write
        -performCommit() long
        -releaseResources() void
    }
    
    class TxState {
        <<interface>>
        +nodeIsAddedInThisBatch(nodeId) boolean
        +nodeIsDeletedInThisBatch(nodeId) boolean
        +addedAndRemovedNodes() DiffSets~Long~
        +relationshipsWithChangedProperty(propKey) DiffSets~Long~
        +augmentWithLocalState() void
    }
    
    class Read {
        <<interface>>
        +nodeExists(nodeId) boolean
        +singleNode(nodeId, cursor) void
        +allNodesScan(cursor) Scan
        +nodeLabelScan(label, cursor) Scan
        +nodeIndexSeek(index, cursor, predicates) void
    }
    
    class Write {
        <<interface>>
        +nodeCreate() long
        +nodeCreateWithLabels(labels) long
        +nodeDelete(nodeId) boolean
        +relationshipCreate(source, type, target) long
        +nodeAddLabel(nodeId, labelId) boolean
        +nodeSetProperty(nodeId, key, value) void
    }
    
    class Operations {
        -StorageReader storageReader
        -TxState txState
        -CursorContext cursorContext
        -LockManager.Client locks
        
        +nodeCreate() long
        +nodeExists(nodeId) boolean
        +nodeGetProperty(cursor, propKey) Value
        -acquireExclusiveNodeLock(nodeId) void
    }
    
    class TransactionCommitProcess {
        <<interface>>
        +commit(batch, event, mode) long
    }
    
    class InternalTransactionCommitProcess {
        -TransactionAppender appender
        -StorageEngine storageEngine
        
        +commit(batch, event, mode) long
        -appendToLog(batch, event) long
        -applyToStore(batch, event, mode) void
    }
    
    class LockManager.Client {
        -LeaseClient leaseClient
        -long transactionSequenceNumber
        
        +acquireExclusive(resource) void
        +acquireShared(resource) void
        +releaseAll() void
        -detectDeadlock() void
    }
    
    class TransactionTimeout {
        -Duration duration
        -Status timeoutStatus
        
        +isExpired(startTime, clock) boolean
        +checkTimeout(startTime, clock) void
    }
    
    KernelTransaction <|-- KernelTransactionImplementation
    KernelTransactionImplementation --> TxState
    KernelTransactionImplementation --> Read
    KernelTransactionImplementation --> Write
    KernelTransactionImplementation --> LockManager.Client
    KernelTransactionImplementation --> TransactionTimeout
    
    Read <|-- Operations
    Write <|-- Operations
    Operations --> TxState
    
    KernelTransactionImplementation --> TransactionCommitProcess
    TransactionCommitProcess <|-- InternalTransactionCommitProcess

public enum Type {
    EXPLICIT,  // 显式事务（用户调用 beginTx()）
    IMPLICIT   // 隐式事务（executeTransactionally）
}

public interface LoginContext {
    SecurityContext authorize(TokenLookup tokenLookup, ...);
}

public interface ClientConnectionInfo {
    String clientAddress();
    String requestingAgent();
}

public interface KernelTransaction extends AutoCloseable {
    long commit() throws TransactionFailureException;
    void rollback() throws TransactionFailureException;
    Read dataRead();
    Write dataWrite();
    // ... 其他方法
}

// community/kernel/src/main/java/org/neo4j/kernel/impl/api/KernelImpl.java
public KernelTransaction beginTransaction(
        Type type,
        LoginContext loginContext,
        ClientConnectionInfo connectionInfo,
        long timeout
) throws TransactionFailureException {
    // 1. 检查数据库状态
    panic.assertNoPanic(TransactionFailureException.class);
    
    // 2. 创建超时配置
    TransactionTimeout transactionTimeout = new TransactionTimeout(
        Duration.ofMillis(timeout),
        TransactionTimedOutClientConfiguration
    );
    
    // 3. 从事务池获取实例
    KernelTransaction transaction = transactions.newInstance(
        type,
        loginContext,
        connectionInfo,
        transactionTimeout
    );
    
    // 4. 注册监控
    transactionMonitor.transactionStarted();
    transactionExecutionMonitor.start(transaction);
    
    return transaction;
}

// community/kernel/src/main/java/org/neo4j/kernel/impl/api/KernelTransactions.java
public KernelTransaction newInstance(
        Type type,
        LoginContext loginContext,
        ClientConnectionInfo clientInfo,
        TransactionTimeout timeout
) {
    // 1. 防止在阻塞新事务时创建事务
    assertCurrentThreadIsNotBlockingNewTransactions();
    
    // 2. 创建安全上下文
    SecurityContext securityContext = loginContext.authorize(
        new TokenHoldersIdLookup(tokenHolders, procedureView, isStale),
        sessionDatabase,
        securityLog
    );
    
    // 3. 分配事务序列号（全局递增）
    long sequenceNumber = sequenceNumberCounter.incrementAndGet();
    
    // 4. 从池中获取实例并初始化
    KernelTransaction tx = pool.acquire().initialize(
        lastCommittedTransactionId.get(),
        type,
        securityContext,
        timeout,
        sequenceNumber,
        clientInfo,
        procedureView
    );
    
    // 5. 获取串行执行锁（如果启用）
    databaseSerialGuard.acquireSerialLock(tx);
    
    return tx;
}

public interface KernelTransactionMonitor {
    void beforeApply(); // 在应用存储命令前调用
    void afterCommit(ExecutionStatistics statistics); // 提交后调用
}

// community/kernel/src/main/java/org/neo4j/kernel/impl/api/KernelTransactionImplementation.java
public long commit(KernelTransactionMonitor monitor) throws TransactionFailureException {
    // 1. 状态检查
    assertOpen();
    markAsClosed();
    
    // 2. 检查终止状态
    if (terminationMark != null) {
        rollback();
        failOnTermination();
    }
    
    try {
        // 3. 触发 PreCommit 事件
        transactionEventListeners.beforeCommit(txState, this, storageReader);
        
        // 4. 执行提交流程
        long txId = performCommit();
        
        // 5. 触发 AfterCommit 事件
        transactionEventListeners.afterCommit(txState, this, txId);
        
        // 6. 监控回调
        monitor.afterCommit(statistics);
        
        return txId;
    } finally {
        // 7. 释放资源
        release();
    }
}

private long performCommit() throws TransactionFailureException {
    // 只读事务直接返回
    if (txState == null || !txState.hasChanges()) {
        return READ_ONLY_ID;
    }
    
    // 1. 生成存储命令
    List<StorageCommand> commands = new ArrayList<>();
    storageEngine.createCommands(
        txState,
        storageReader,
        commandCreationContext,
        locks,
        commands
    );
    
    // 2. 提交到存储引擎
    long txId = committer.commit(
        commands,
        kernelTransactionMonitor
    );
    
    // 3. 记录统计信息
    statistics.addHeapAllocatedBytes(transactionMemoryPool.usedHeap());
    statistics.addNativeAllocatedBytes(transactionMemoryPool.usedNative());
    
    return txId;
}

// community/kernel/src/main/java/org/neo4j/kernel/impl/api/InternalTransactionCommitProcess.java
public long commit(
        StorageEngineTransaction batch,
        TransactionWriteEvent transactionWriteEvent,
        TransactionApplicationMode mode
) throws TransactionFailureException {
    try {
        // 阶段 1：预分配存储空间（可选优化）
        if (preAllocateSpaceInStores) {
            storageEngine.allocate(batch);
        }
        
        // 阶段 2：预取页面到 PageCache（可选优化）
        if (prefetchCommands.getAsBoolean()) {
            storageEngine.prefetchPagesForCommands(batch, mode);
        }
        
        // 阶段 3：写入 WAL（持久化保证）
        long lastAppendIndex = appendToLog(batch, transactionWriteEvent);
        
        try {
            // 阶段 4：应用到存储引擎
            applyToStore(batch, transactionWriteEvent, mode);
        } finally {
            // 确保批次关闭
            close(batch);
        }
        
        // 阶段 5：通知成功
        commandCommitListeners.registerSuccess(batch, lastAppendIndex);
        
        return lastAppendIndex;
    } catch (Exception e) {
        commandCommitListeners.registerFailure(batch, e);
        throw e;
    }
}

private long appendToLog(
        StorageEngineTransaction batch,
        TransactionWriteEvent event
) throws IOException {
    // 序列化命令到 WAL
    return appender.append(batch.commands(), event.chunkAppender());
}

private void applyToStore(
        StorageEngineTransaction batch,
        TransactionWriteEvent event,
        TransactionApplicationMode mode
) throws Exception {
    // 应用命令到存储引擎（更新 NeoStores）
    storageEngine.apply(batch, mode);
}

// community/kernel-api/src/main/java/org/neo4j/internal/kernel/api/Write.java
public interface Write {
    /**
     * 创建节点
     * @return 节点 ID
     */
    long nodeCreate();
    
    /**
     * 创建节点并分配标签
     * @param labels 标签 ID 数组
     * @return 节点 ID
     */
    long nodeCreateWithLabels(int[] labels) throws ConstraintValidationException;
    
    /**
     * 删除节点
     * @param nodeId 节点 ID
     * @return true 如果节点存在并被删除
     */
    boolean nodeDelete(long nodeId) throws AutoIndexingKernelException;
    
    /**
     * 添加标签到节点
     * @param nodeId 节点 ID
     * @param labelId 标签 ID
     * @return true 如果标签被添加（之前不存在）
     */
    boolean nodeAddLabel(long nodeId, int labelId) 
        throws EntityNotFoundException, ConstraintValidationException;
    
    /**
     * 设置节点属性
     * @param nodeId 节点 ID
     * @param propertyKey 属性键 ID
     * @param value 属性值
     */
    void nodeSetProperty(long nodeId, int propertyKey, Value value) 
        throws EntityNotFoundException, ConstraintValidationException;
    
    /**
     * 创建关系
     * @param sourceNode 起点节点 ID
     * @param relationshipType 关系类型 ID
     * @param targetNode 终点节点 ID
     * @return 关系 ID
     */
    long relationshipCreate(long sourceNode, int relationshipType, long targetNode) 
        throws EntityNotFoundException;
}

// community/kernel/src/main/java/org/neo4j/kernel/impl/newapi/Operations.java
public long nodeCreate() {
    // 1. 检查写权限
    ktx.securityAuthorizationHandler.assertAllowsCreateNode(ktx.securityContext(), labels);
    
    // 2. 分配节点 ID
    long nodeId = commandCreationContext.reserveNode();
    
    // 3. 获取排他锁
    acquireExclusiveNodeLock(nodeId);
    
    // 4. 记录到 TxState
    ktx.txState().nodeDoCreate(nodeId);
    
    return nodeId;
}

public void nodeSetProperty(long nodeId, int propertyKey, Value value) 
        throws EntityNotFoundException, ConstraintValidationException {
    // 1. 检查节点存在性
    if (!nodeExists(nodeId)) {
        throw new EntityNotFoundException(EntityType.NODE, nodeId);
    }
    
    // 2. 获取排他锁
    acquireExclusiveNodeLock(nodeId);
    
    // 3. 检查约束
    ConstraintDescriptor constraint = getUniqueConstraint(propertyKey);
    if (constraint != null) {
        validateUniqueConstraint(nodeId, propertyKey, value, constraint);
    }
    
    // 4. 记录属性变更
    ktx.txState().nodeDoReplaceProperty(nodeId, propertyKey, storageProperty, value);
    
    // 5. 更新索引状态
    indexTxStateUpdater.onPropertyAdd(nodeId, propertyKey, value);
}

sequenceDiagram
    autonumber
    participant User as 用户代码
    participant GDB as GraphDatabaseService
    participant Kernel as Kernel
    participant KTx as KernelTransaction
    participant TxState as TxState
    participant Locks as LockManager
    participant CommitProc as CommitProcess
    participant WAL as TransactionLog
    participant Storage as StorageEngine
    participant PageCache as PageCache
    
    User->>GDB: beginTx()
    GDB->>Kernel: beginTransaction(EXPLICIT, loginContext, ...)
    Kernel->>KTx: pool.acquire().initialize(...)
    KTx->>Locks: lockClient.initialize()
    KTx->>TxState: 创建空 TxState
    Kernel-->>GDB: 返回 KernelTransaction
    GDB-->>User: 返回 Transaction
    
    User->>User: tx.createNode(Label.label("Person"))
    User->>KTx: dataWrite().nodeCreate()
    KTx->>Locks: acquireExclusiveNodeLock(nodeId)
    Locks-->>KTx: 锁获取成功
    KTx->>TxState: nodeDoCreate(nodeId)
    TxState-->>KTx: 记录节点创建
    
    User->>KTx: dataWrite().nodeSetProperty(nodeId, key, value)
    KTx->>Locks: acquireExclusiveNodeLock(nodeId)
    KTx->>TxState: nodeDoReplaceProperty(nodeId, key, value)
    TxState-->>KTx: 记录属性变更
    
    User->>User: tx.commit()
    User->>KTx: commit()
    KTx->>KTx: 检查 terminationMark
    KTx->>KTx: 触发 beforeCommit 事件
    
    KTx->>Storage: createCommands(txState, storageReader, ...)
    Storage->>TxState: 遍历变更集
    Storage->>Storage: 生成 NodeCommand、PropertyCommand
    Storage-->>KTx: 返回 StorageCommand 列表
    
    KTx->>CommitProc: commit(commands, transactionWriteEvent, mode)
    CommitProc->>WAL: append(commands)
    WAL->>PageCache: 写入日志页面
    PageCache->>PageCache: 标记 Dirty Page
    WAL-->>CommitProc: 返回 TransactionId
    
    CommitProc->>Storage: apply(commands, mode)
    Storage->>PageCache: 更新节点/属性页面
    PageCache->>PageCache: 修改 Page Buffer
    Storage-->>CommitProc: 应用完成
    
    CommitProc-->>KTx: 返回 TransactionId
    
    KTx->>KTx: 触发 afterCommit 事件
    KTx->>Locks: lockClient.releaseAll()
    Locks->>Locks: 释放所有锁
    KTx->>TxState: 清空 TxState
    KTx->>KTx: pool.release(this)
    KTx-->>User: 返回 TransactionId
    
    Note over PageCache: Checkpoint 线程<br/>定期刷新 Dirty Pages

sequenceDiagram
    autonumber
    participant Tx1 as Transaction 1
    participant Tx2 as Transaction 2
    participant Locks as LockManager
    participant Deadlock as DeadlockDetector
    
    Tx1->>Locks: acquireExclusive(Node 100)
    Locks-->>Tx1: 锁获取成功
    
    Tx2->>Locks: acquireExclusive(Node 200)
    Locks-->>Tx2: 锁获取成功
    
    Note over Tx1,Tx2: 两个事务持有不同节点的锁
    
    Tx1->>Locks: acquireExclusive(Node 200)
    Locks->>Locks: 检测冲突（Tx2 持有锁）
    Locks->>Tx1: 阻塞等待
    
    Tx2->>Locks: acquireExclusive(Node 100)
    Locks->>Locks: 检测冲突（Tx1 持有锁）
    
    Locks->>Deadlock: 构建等待图
    Deadlock->>Deadlock: 检测到环：Tx1 → Tx2 → Tx1
    
    Deadlock->>Deadlock: 选择代价最小的事务（Tx2）
    Deadlock->>Tx2: 抛出 DeadlockDetectedException
    Tx2->>Tx2: 自动回滚
    Tx2->>Locks: lockClient.releaseAll()
    
    Locks->>Tx1: 唤醒等待
    Locks-->>Tx1: 锁获取成功
    
    Tx1->>Tx1: 继续执行
    Tx1->>Locks: commit()
    Locks->>Locks: releaseAll()

public KernelTransactionImplementation initialize(
    long lastCommittedTx,
    Type type,
    SecurityContext frozenSecurityContext,
    TransactionTimeout transactionTimeout,
    long transactionSequenceNumber,
    ClientConnectionInfo clientInfo,
    ProcedureView procedureView
)

public KernelTransactionImplementation initialize(...) {
    // 1. 重置内存状态
    assert transactionMemoryPool.usedHeap() == 0;
    assert transactionMemoryPool.usedNative() == 0;
    
    // 2. 创建游标上下文（绑定到当前线程）
    CURSOR_CONTEXT_HANDLE.setRelease(
        this, 
        contextFactory.create(TRANSACTION_TAG)
    );
    this.transactionalCursors.reset(cursorContext);
    
    // 3. 初始化访问能力（只读/读写）
    this.accessCapability = accessCapabilityFactory.newAccessCapability(
        readOnlyDatabaseChecker
    );
    
    // 4. 初始化锁客户端
    this.leaseClient = leaseService.newClient();
    this.lockClient.initialize(
        leaseClient, 
        transactionSequenceNumber, 
        memoryTracker, 
        config
    );
    
    // 5. 重置事务状态
    this.terminationMark = null;
    this.commit = false;
    this.writeState = TransactionWriteState.NONE;
    this.startTimeMillis = clocks.systemClock().millis();
    this.startTimeNanos = clocks.systemClock().nanos();
    this.timeout = transactionTimeout;
    this.lastTransactionIdWhenStarted = lastCommittedTx;
    
    // 6. 启动事务追踪
    this.transactionEvent = transactionTracer.beginTransaction(
        cursorContext, 
        transactionSequenceNumber
    );
    
    // 7. 设置安全上下文
    this.overridableSecurityContext = new OverridableSecurityContext(
        frozenSecurityContext
    );
    
    // 8. 初始化操作接口
    this.commandCreationContext.initialize(
        kernelVersionProvider,
        cursorContext,
        transactionalCursors,
        kernelTransactions::startTimeOfOldestExecutingTransaction,
        lockClient,
        currentStatement::lockTracer
    );
    this.currentStatement.initialize(lockClient, cursorContext, startTimeMillis);
    this.operations.initialize(cursorContext);
    
    // 9. 设置内存限制
    this.transactionMemoryPool.setLimit(transactionHeapBytesLimit);
    
    // 10. 设置事务序列号（volatile 写，happens-before）
    this.transactionSequenceNumber = transactionSequenceNumber;
    this.closing = false;
    this.closed = false;
    
    return this;
}

private void release()

private void release() {
    try {
        // 1. 释放锁
        lockClient.close();
        
        // 2. 释放 Lease
        if (leaseClient != NO_LEASE) {
            leaseClient.close();
        }
        
        // 3. 关闭游标
        transactionalCursors.close();
        
        // 4. 关闭存储读取器
        if (storageReader != null) {
            storageReader.close();
        }
        
        // 5. 释放命令创建上下文
        commandCreationContext.close();
        
        // 6. 清空 TxState
        if (txState != null) {
            txState.release();
            txState = null;
        }
        
        // 7. 释放内存
        transactionMemoryPool.reset();
        
        // 8. 停止事务追踪
        if (transactionEvent != null) {
            transactionEvent.close();
            transactionEvent = null;
        }
        
        // 9. 归还对象到池
        pool.release(this);
    } catch (Exception e) {
        // 标记为失败清理，此对象不应再被复用
        failedCleanup = true;
        throw e;
    }
}

// ❌ 低效实现：每次循环都提交事务
for (int i = 0; i < 100000; i++) {
    try (Transaction tx = db.beginTx()) {
        tx.createNode(Label.label("Person"));
        tx.commit();
    }
}

// ✅ 高效实现：批量提交
int batchSize = 10000;
for (int i = 0; i < 100000; i++) {
    if (i % batchSize == 0) {
        if (tx != null) {
            tx.commit();
        }
        tx = db.beginTx();
    }
    tx.createNode(Label.label("Person"));
}
if (tx != null) {
    tx.commit();
}

// ❌ 长事务：持有锁数小时
try (Transaction tx = db.beginTx()) {
    for (Node node : tx.getAllNodes()) {
        // 处理每个节点（可能数百万个）
        processNode(node);
    }
    tx.commit();
}

// ✅ 分批处理：每批处理 1000 个节点
long lastId = 0;
while (true) {
    List<Long> nodeIds = new ArrayList<>();
    
    // 只读事务：获取节点 ID
    try (Transaction tx = db.beginTx()) {
        Result result = tx.execute(
            "MATCH (n) WHERE id(n) > $lastId " +
            "RETURN id(n) ORDER BY id(n) LIMIT 1000",
            Map.of("lastId", lastId)
        );
        while (result.hasNext()) {
            nodeIds.add((Long) result.next().get("id(n)"));
        }
        tx.commit();
    }
    
    if (nodeIds.isEmpty()) break;
    
    // 写事务：处理节点
    try (Transaction tx = db.beginTx()) {
        for (long nodeId : nodeIds) {
            Node node = tx.getNodeById(nodeId);
            processNode(node);
        }
        tx.commit();
    }
    
    lastId = nodeIds.get(nodeIds.size() - 1);
}

# 事务超时（防止死锁与长事务）
db.transaction.timeout=60s

# 锁获取超时（快速失败，避免长时间阻塞）
db.lock.acquisition.timeout=30s

# 事务内存上限（防止 OOM）
db.memory.transaction.max=50m

# 并发事务数（根据 CPU 核心数调整）
db.transaction.concurrent.maximum=1000

import org.neo4j.dbms.api.DatabaseManagementService;
import org.neo4j.dbms.api.DatabaseManagementServiceBuilder;
import org.neo4j.graphdb.GraphDatabaseService;
import org.neo4j.graphdb.Transaction;

public class EmbeddedNeo4j {
    public static void main(String[] args) {
        // 1. 创建数据库管理服务
        DatabaseManagementService managementService = 
            new DatabaseManagementServiceBuilder(
                Paths.get("/path/to/neo4j-db")
            )
            .setConfig(GraphDatabaseSettings.pagecache_memory, "512M")
            .setConfig(GraphDatabaseSettings.transaction_timeout, Duration.ofSeconds(60))
            .build();
        
        // 2. 注册关闭钩子
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            managementService.shutdown();
        }));
        
        // 3. 获取数据库实例
        GraphDatabaseService db = managementService.database("neo4j");
        
        // 4. 执行事务
        try (Transaction tx = db.beginTx()) {
            Node person = tx.createNode(Label.label("Person"));
            person.setProperty("name", "Alice");
            tx.commit();
        }
    }
}

import org.neo4j.kernel.internal.event.TransactionEventListeners;
import org.neo4j.graphdb.event.TransactionData;
import org.neo4j.graphdb.event.TransactionEventListenerAdapter;

public class AuditListener extends TransactionEventListenerAdapter<Void> {
    @Override
    public Void beforeCommit(TransactionData data, Transaction transaction, 
                             GraphDatabaseService databaseService) {
        // 审计日志：记录变更
        for (Node node : data.createdNodes()) {
            System.out.println("Created node: " + node.getElementId());
        }
        
        for (Node node : data.deletedNodes()) {
            System.out.println("Deleted node: " + node.getElementId());
        }
        
        return null;
    }
    
    @Override
    public void afterCommit(TransactionData data, Void state, 
                           GraphDatabaseService databaseService) {
        System.out.println("Transaction committed successfully");
    }
    
    @Override
    public void afterRollback(TransactionData data, Void state, 
                             GraphDatabaseService databaseService) {
        System.out.println("Transaction rolled back");
    }
}

// 注册监听器
db.registerTransactionEventListener(new AuditListener());