diff --git a/common/src/main/java/org/apache/seata/common/ConfigurationKeys.java b/common/src/main/java/org/apache/seata/common/ConfigurationKeys.java
index e31bc8e72e2..a35cac0c246 100644
--- a/common/src/main/java/org/apache/seata/common/ConfigurationKeys.java
+++ b/common/src/main/java/org/apache/seata/common/ConfigurationKeys.java
@@ -138,6 +138,21 @@ public interface ConfigurationKeys {
      */
     String STORE_FILE_DIR = STORE_FILE_PREFIX + "dir";
 
+    /**
+     * The constant STORE_FILE_ENGINE
+     */
+    String STORE_FILE_ENGINE = STORE_FILE_PREFIX + "engine";
+
+    /**
+     * The constant STORE_FILE_ROCKSDB_PREFIX
+     */
+    String STORE_FILE_ROCKSDB_PREFIX = STORE_FILE_PREFIX + "rocksdb.";
+
+    /**
+     * The constant STORE_FILE_ROCKSDB_DIR
+     */
+    String STORE_FILE_ROCKSDB_DIR = STORE_FILE_ROCKSDB_PREFIX + "dir";
+
     /**
      * The constant SERVICE_GROUP_MAPPING_PREFIX.
      */
diff --git a/common/src/main/java/org/apache/seata/common/store/LockMode.java b/common/src/main/java/org/apache/seata/common/store/LockMode.java
index 23abb91ba0a..4a5e5c5e27e 100644
--- a/common/src/main/java/org/apache/seata/common/store/LockMode.java
+++ b/common/src/main/java/org/apache/seata/common/store/LockMode.java
@@ -32,7 +32,11 @@ public enum LockMode {
     /**
      * raft store
      */
-    RAFT("raft");
+    RAFT("raft"),
+    /**
+     * RocksDB lock mode for file store engine.
+     */
+    ROCKSDB("rocksdb");
 
     private String name;
 
diff --git a/common/src/main/java/org/apache/seata/server/console/entity/param/GlobalSessionParam.java b/common/src/main/java/org/apache/seata/server/console/entity/param/GlobalSessionParam.java
index 8327a17433c..df60ad0d748 100644
--- a/common/src/main/java/org/apache/seata/server/console/entity/param/GlobalSessionParam.java
+++ b/common/src/main/java/org/apache/seata/server/console/entity/param/GlobalSessionParam.java
@@ -30,6 +30,10 @@ public class GlobalSessionParam extends BaseParam implements Serializable {
      * the xid
      */
     private String xid;
+    /**
+     * the transaction id
+     */
+    private Long transactionId;
     /**
      * the application id
      */
@@ -63,6 +67,14 @@ public void setXid(String xid) {
         this.xid = xid;
     }
 
+    public Long getTransactionId() {
+        return transactionId;
+    }
+
+    public void setTransactionId(Long transactionId) {
+        this.transactionId = transactionId;
+    }
+
     public String getTransactionName() {
         return transactionName;
     }
@@ -105,9 +117,13 @@ public void setVgroup(String vgroup) {
 
     @Override
     public String toString() {
-        return "GlobalSessionParam{" + "xid='" + xid + '\'' + ", applicationId='" + applicationId + '\'' + ", status="
-                + status + ", transactionName='" + transactionName + '\'' + ", vgroup='" + vgroup + '\''
-                + ", withBranch="
+        return "GlobalSessionParam{" + "xid='"
+                + xid + '\'' + ", transactionId="
+                + transactionId + ", applicationId='"
+                + applicationId + '\'' + ", status="
+                + status + ", transactionName='"
+                + transactionName + '\'' + ", vgroup='"
+                + vgroup + '\'' + ", withBranch="
                 + withBranch + '}';
     }
 }
diff --git a/common/src/test/java/org/apache/seata/common/store/LockModeTest.java b/common/src/test/java/org/apache/seata/common/store/LockModeTest.java
index cff12f3f485..fbae5dd3c4b 100644
--- a/common/src/test/java/org/apache/seata/common/store/LockModeTest.java
+++ b/common/src/test/java/org/apache/seata/common/store/LockModeTest.java
@@ -27,6 +27,7 @@ void testGetName() {
         Assertions.assertEquals("db", LockMode.DB.getName());
         Assertions.assertEquals("redis", LockMode.REDIS.getName());
         Assertions.assertEquals("raft", LockMode.RAFT.getName());
+        Assertions.assertEquals("rocksdb", LockMode.ROCKSDB.getName());
     }
 
     @Test
@@ -40,6 +41,8 @@ void testGet() {
         Assertions.assertEquals(LockMode.REDIS, LockMode.get("REDIS"));
         Assertions.assertEquals(LockMode.RAFT, LockMode.get("raft"));
         Assertions.assertEquals(LockMode.RAFT, LockMode.get("Raft"));
+        Assertions.assertEquals(LockMode.ROCKSDB, LockMode.get("rocksdb"));
+        Assertions.assertEquals(LockMode.ROCKSDB, LockMode.get("RocksDB"));
     }
 
     @Test
@@ -57,6 +60,7 @@ void testContainsValid() {
         Assertions.assertTrue(LockMode.contains("db"));
         Assertions.assertTrue(LockMode.contains("redis"));
         Assertions.assertTrue(LockMode.contains("raft"));
+        Assertions.assertTrue(LockMode.contains("rocksdb"));
     }
 
     @Test
diff --git a/console/src/main/java/org/apache/seata/mcp/entity/dto/McpGlobalSessionParamDto.java b/console/src/main/java/org/apache/seata/mcp/entity/dto/McpGlobalSessionParamDto.java
index c7f4c95499c..dbe59d4f710 100644
--- a/console/src/main/java/org/apache/seata/mcp/entity/dto/McpGlobalSessionParamDto.java
+++ b/console/src/main/java/org/apache/seata/mcp/entity/dto/McpGlobalSessionParamDto.java
@@ -29,6 +29,9 @@ public class McpGlobalSessionParamDto implements Serializable {
     @McpToolParam(description = "Global transaction ID", required = false)
     private String xid;
 
+    @McpToolParam(description = "Global transaction numeric ID", required = false)
+    private Long transactionId;
+
     @McpToolParam(description = "applicationId", required = false)
     private String applicationId;
 
@@ -95,6 +98,14 @@ public void setXid(String xid) {
         this.xid = xid;
     }
 
+    public Long getTransactionId() {
+        return transactionId;
+    }
+
+    public void setTransactionId(Long transactionId) {
+        this.transactionId = transactionId;
+    }
+
     public String getTransactionName() {
         return transactionName;
     }
diff --git a/console/src/main/java/org/apache/seata/mcp/entity/param/McpGlobalSessionParam.java b/console/src/main/java/org/apache/seata/mcp/entity/param/McpGlobalSessionParam.java
index 8adaec20cbb..f317098e5be 100644
--- a/console/src/main/java/org/apache/seata/mcp/entity/param/McpGlobalSessionParam.java
+++ b/console/src/main/java/org/apache/seata/mcp/entity/param/McpGlobalSessionParam.java
@@ -34,6 +34,7 @@ public static McpGlobalSessionParam convertFromDtoParam(McpGlobalSessionParamDto
         param.setPageNum(paramDto.getPageNum());
         param.setStatus(paramDto.getStatus());
         param.setXid(paramDto.getXid());
+        param.setTransactionId(paramDto.getTransactionId());
         param.setApplicationId(paramDto.getApplicationId());
         param.setTransactionName(paramDto.getTransactionName());
         param.setWithBranch(paramDto.isWithBranch());
diff --git a/console/src/main/resources/static/console-fe/src/pages/TransactionInfo/TransactionInfo.tsx b/console/src/main/resources/static/console-fe/src/pages/TransactionInfo/TransactionInfo.tsx
index 54453471612..740972a4b4a 100644
--- a/console/src/main/resources/static/console-fe/src/pages/TransactionInfo/TransactionInfo.tsx
+++ b/console/src/main/resources/static/console-fe/src/pages/TransactionInfo/TransactionInfo.tsx
@@ -469,6 +469,13 @@ class TransactionInfo extends React.Component<GlobalProps, TransactionInfoState>
   }
 
   searchFilterOnChange = (key: string, val: string) => {
+    if (key === 'transactionId') {
+      const transactionId = val && /^(?!0+$)\d+$/.test(val) ? val : undefined;
+      this.setState(prevState => ({
+        globalSessionParam: { ...prevState.globalSessionParam, transactionId },
+      }));
+      return;
+    }
     if (key === 'namespace') {
       const selectedNamespace = this.state.namespaceOptions.get(val);
       const clusters = selectedNamespace ? selectedNamespace.clusters : [];
@@ -1094,6 +1101,12 @@ class TransactionInfo extends React.Component<GlobalProps, TransactionInfoState>
               onChange={(value: string) => { this.searchFilterOnChange('xid', value); }}
             />
           </FormItem>
+          <FormItem name="transactionId" label="transactionId">
+            <Input
+              placeholder={inputFilterPlaceholder}
+              onChange={(value: string) => { this.searchFilterOnChange('transactionId', value); }}
+            />
+          </FormItem>
           <FormItem name="applicationId" label="applicationId">
             <Input
               placeholder={inputFilterPlaceholder}
diff --git a/console/src/main/resources/static/console-fe/src/service/transactionInfo.ts b/console/src/main/resources/static/console-fe/src/service/transactionInfo.ts
index ca293cb772f..a35734746b5 100644
--- a/console/src/main/resources/static/console-fe/src/service/transactionInfo.ts
+++ b/console/src/main/resources/static/console-fe/src/service/transactionInfo.ts
@@ -20,6 +20,7 @@ import qs from 'qs';
 
 export type GlobalSessionParam = {
   xid?: string,
+  transactionId?: string,
   applicationId?: string,
   status?: number,
   transactionName?: string,
diff --git a/dependencies/pom.xml b/dependencies/pom.xml
index 20df1aa86df..811db60ac18 100644
--- a/dependencies/pom.xml
+++ b/dependencies/pom.xml
@@ -142,6 +142,7 @@
         <janino-version>3.1.10</janino-version>
         <mockwebserver-version>4.12.0</mockwebserver-version>
         <native-lib-loader.version>2.4.0</native-lib-loader.version>
+        <rocksdbjni.version>10.10.1.1</rocksdbjni.version>
 
         <!--  for fory  -->
         <fory.version>0.12.3</fory.version>
@@ -604,6 +605,11 @@
                 <artifactId>native-lib-loader</artifactId>
                 <version>${native-lib-loader.version}</version>
             </dependency>
+            <dependency>
+                <groupId>org.rocksdb</groupId>
+                <artifactId>rocksdbjni</artifactId>
+                <version>${rocksdbjni.version}</version>
+            </dependency>
             <dependency>
                 <groupId>javax.inject</groupId>
                 <artifactId>javax.inject</artifactId>
diff --git a/server/pom.xml b/server/pom.xml
index 9de1f407868..9b40d44da33 100644
--- a/server/pom.xml
+++ b/server/pom.xml
@@ -167,6 +167,10 @@
             <artifactId>seata-metrics-all</artifactId>
             <version>${project.version}</version>
         </dependency>
+        <dependency>
+            <groupId>org.rocksdb</groupId>
+            <artifactId>rocksdbjni</artifactId>
+        </dependency>
 <!--
 
         <dependency>
diff --git a/server/src/main/java/org/apache/seata/server/console/impl/db/GlobalSessionDBServiceImpl.java b/server/src/main/java/org/apache/seata/server/console/impl/db/GlobalSessionDBServiceImpl.java
index 16e772e7d14..e63377f88af 100644
--- a/server/src/main/java/org/apache/seata/server/console/impl/db/GlobalSessionDBServiceImpl.java
+++ b/server/src/main/java/org/apache/seata/server/console/impl/db/GlobalSessionDBServiceImpl.java
@@ -136,6 +136,10 @@ private String getWhereConditionByParam(GlobalSessionParam param, List<Object> s
             whereConditionBuilder.append(" and xid = ? ");
             sqlParamList.add(param.getXid());
         }
+        if (param.getTransactionId() != null && param.getTransactionId() > 0) {
+            whereConditionBuilder.append(" and transaction_id = ? ");
+            sqlParamList.add(param.getTransactionId());
+        }
         if (StringUtils.isNotBlank(param.getApplicationId())) {
             whereConditionBuilder.append(" and application_id = ? ");
             sqlParamList.add(param.getApplicationId());
diff --git a/server/src/main/java/org/apache/seata/server/console/impl/file/GlobalSessionFileServiceImpl.java b/server/src/main/java/org/apache/seata/server/console/impl/file/GlobalSessionFileServiceImpl.java
index 2a57e6d24e6..506349f538b 100644
--- a/server/src/main/java/org/apache/seata/server/console/impl/file/GlobalSessionFileServiceImpl.java
+++ b/server/src/main/java/org/apache/seata/server/console/impl/file/GlobalSessionFileServiceImpl.java
@@ -17,17 +17,21 @@
 package org.apache.seata.server.console.impl.file;
 
 import org.apache.seata.common.result.PageResult;
+import org.apache.seata.core.model.GlobalStatus;
 import org.apache.seata.server.console.entity.param.GlobalSessionParam;
 import org.apache.seata.server.console.entity.vo.GlobalSessionVO;
 import org.apache.seata.server.console.impl.AbstractGlobalService;
 import org.apache.seata.server.console.service.GlobalSessionService;
 import org.apache.seata.server.session.GlobalSession;
+import org.apache.seata.server.session.SessionCondition;
 import org.apache.seata.server.session.SessionHolder;
+import org.apache.seata.server.session.SessionManager;
 import org.apache.seata.server.storage.SessionConverter;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnExpression;
 import org.springframework.stereotype.Component;
 
 import java.util.Collection;
+import java.util.Collections;
 import java.util.List;
 import java.util.Objects;
 import java.util.function.Predicate;
@@ -35,6 +39,7 @@
 
 import static java.util.Objects.isNull;
 import static org.apache.seata.common.util.StringUtils.isBlank;
+import static org.apache.seata.common.util.StringUtils.isNotBlank;
 
 /**
  * Global Session File ServiceImpl
@@ -51,8 +56,7 @@ public PageResult<GlobalSessionVO> query(GlobalSessionParam param) {
             throw new IllegalArgumentException("wrong pageSize or pageNum");
         }
 
-        final Collection<GlobalSession> allSessions =
-                SessionHolder.getRootSessionManager().allSessions();
+        final Collection<GlobalSession> allSessions = findCandidateSessions(param);
 
         final List<GlobalSession> filteredSessions =
                 allSessions.parallelStream().filter(obtainPredicate(param)).collect(Collectors.toList());
@@ -61,6 +65,56 @@ public PageResult<GlobalSessionVO> query(GlobalSessionParam param) {
                 SessionConverter.convertGlobalSession(filteredSessions), param.getPageNum(), param.getPageSize());
     }
 
+    private Collection<GlobalSession> findCandidateSessions(GlobalSessionParam param) {
+        SessionManager sessionManager = SessionHolder.getRootSessionManager();
+        if (isNotBlank(param.getXid()) && isCompleteXid(param.getXid())) {
+            GlobalSession globalSession = sessionManager.findGlobalSession(param.getXid(), param.isWithBranch());
+            return globalSession == null ? Collections.emptyList() : Collections.singletonList(globalSession);
+        }
+        if (param.getTransactionId() != null && param.getTransactionId() > 0) {
+            SessionCondition sessionCondition = new SessionCondition();
+            sessionCondition.setTransactionId(param.getTransactionId());
+            sessionCondition.setLazyLoadBranch(!param.isWithBranch());
+            return sessionManager.findGlobalSessions(sessionCondition);
+        }
+        if (param.getStatus() != null) {
+            GlobalStatus globalStatus = getGlobalStatus(param.getStatus());
+            if (globalStatus == null) {
+                return Collections.emptyList();
+            }
+            SessionCondition sessionCondition = new SessionCondition(globalStatus);
+            sessionCondition.setLazyLoadBranch(!param.isWithBranch());
+            return sessionManager.findGlobalSessions(sessionCondition);
+        }
+        return sessionManager.allSessions();
+    }
+
+    private GlobalStatus getGlobalStatus(int status) {
+        try {
+            return GlobalStatus.get(status);
+        } catch (IllegalArgumentException e) {
+            return null;
+        }
+    }
+
+    private boolean isCompleteXid(String xid) {
+        int lastSplitIndex = xid.lastIndexOf(':');
+        if (lastSplitIndex <= 0 || lastSplitIndex == xid.length() - 1) {
+            return false;
+        }
+        int portSplitIndex = xid.lastIndexOf(':', lastSplitIndex - 1);
+        if (portSplitIndex <= 0 || portSplitIndex == lastSplitIndex - 1) {
+            return false;
+        }
+        try {
+            Integer.parseInt(xid.substring(portSplitIndex + 1, lastSplitIndex));
+            Long.parseLong(xid.substring(lastSplitIndex + 1));
+            return true;
+        } catch (NumberFormatException e) {
+            return false;
+        }
+    }
+
     /**
      * obtain the condition
      *
@@ -71,9 +125,14 @@ private Predicate<? super GlobalSession> obtainPredicate(GlobalSessionParam para
 
         return session -> {
             return
-            // xid
+                    // xid
             (isBlank(param.getXid()) || session.getXid().contains(param.getXid()))
                     &&
+                    // transactionId
+                    (param.getTransactionId() == null
+                            || param.getTransactionId() <= 0
+                            || Objects.equals(session.getTransactionId(), param.getTransactionId()))
+                    &&
                     // applicationId
                     (isBlank(param.getApplicationId())
                             || session.getApplicationId().contains(param.getApplicationId()))
diff --git a/server/src/main/java/org/apache/seata/server/console/impl/redis/GlobalSessionRedisServiceImpl.java b/server/src/main/java/org/apache/seata/server/console/impl/redis/GlobalSessionRedisServiceImpl.java
index 0bd932aed7f..2ce050cb795 100644
--- a/server/src/main/java/org/apache/seata/server/console/impl/redis/GlobalSessionRedisServiceImpl.java
+++ b/server/src/main/java/org/apache/seata/server/console/impl/redis/GlobalSessionRedisServiceImpl.java
@@ -67,7 +67,9 @@ public PageResult<GlobalSessionVO> query(GlobalSessionParam param) {
 
         RedisTransactionStoreManager instance = RedisTransactionStoreManagerFactory.getInstance();
 
-        if (isBlank(param.getXid()) && param.getStatus() == null) {
+        boolean hasDirectGlobalQuery = isNotBlank(param.getXid())
+                || (param.getTransactionId() != null && param.getTransactionId() > 0);
+        if (!hasDirectGlobalQuery && param.getStatus() == null) {
             total = instance.countByGlobalSessions(GlobalStatus.values());
             globalSessions =
                     instance.findGlobalSessionByPage(param.getPageNum(), param.getPageSize(), param.isWithBranch());
@@ -79,10 +81,16 @@ public PageResult<GlobalSessionVO> query(GlobalSessionParam param) {
                 sessionCondition.setLazyLoadBranch(!param.isWithBranch());
                 globalSessions = instance.readSession(sessionCondition);
                 total = (long) globalSessions.size();
+            } else if (param.getTransactionId() != null && param.getTransactionId() > 0) {
+                SessionCondition sessionCondition = new SessionCondition();
+                sessionCondition.setTransactionId(param.getTransactionId());
+                sessionCondition.setLazyLoadBranch(!param.isWithBranch());
+                globalSessions = instance.readSession(sessionCondition);
+                total = (long) globalSessions.size();
             }
 
             if (param.getStatus() != null && GlobalStatus.get(param.getStatus()) != null) {
-                if (CollectionUtils.isNotEmpty(globalSessions)) {
+                if (hasDirectGlobalQuery || CollectionUtils.isNotEmpty(globalSessions)) {
                     globalSessionsNew = globalSessions.stream()
                             .filter(globalSession -> globalSession.getStatus().getCode() == (param.getStatus()))
                             .collect(Collectors.toList());
diff --git a/server/src/main/java/org/apache/seata/server/lock/LockerManagerFactory.java b/server/src/main/java/org/apache/seata/server/lock/LockerManagerFactory.java
index a301fa563a1..b1f11bef3ed 100644
--- a/server/src/main/java/org/apache/seata/server/lock/LockerManagerFactory.java
+++ b/server/src/main/java/org/apache/seata/server/lock/LockerManagerFactory.java
@@ -18,9 +18,6 @@
 
 import org.apache.seata.common.loader.EnhancedServiceLoader;
 import org.apache.seata.common.store.LockMode;
-import org.apache.seata.common.store.StoreMode;
-import org.apache.seata.config.Configuration;
-import org.apache.seata.config.ConfigurationFactory;
 import org.apache.seata.server.store.StoreConfig;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -32,7 +29,6 @@
 public class LockerManagerFactory {
 
     private static final Logger LOGGER = LoggerFactory.getLogger(LockerManagerFactory.class);
-    private static final Configuration CONFIG = ConfigurationFactory.getInstance();
 
     /**
      * the lock manager
@@ -62,13 +58,10 @@ public static void init(LockMode lockMode) {
             synchronized (LockerManagerFactory.class) {
                 if (LOCK_MANAGER == null) {
                     if (null == lockMode) {
-                        lockMode = StoreConfig.getLockMode();
+                        lockMode = StoreConfig.getEffectiveLockMode();
                     }
                     LOGGER.info("use lock store mode: {}", lockMode.getName());
-                    // if not exist the lock mode, throw exception
-                    if (null != StoreMode.get(lockMode.name())) {
-                        LOCK_MANAGER = EnhancedServiceLoader.load(LockManager.class, lockMode.getName());
-                    }
+                    LOCK_MANAGER = EnhancedServiceLoader.load(LockManager.class, lockMode.getName());
                 }
             }
         }
diff --git a/server/src/main/java/org/apache/seata/server/session/GlobalSession.java b/server/src/main/java/org/apache/seata/server/session/GlobalSession.java
index 6768b013e88..4b1d34bb596 100644
--- a/server/src/main/java/org/apache/seata/server/session/GlobalSession.java
+++ b/server/src/main/java/org/apache/seata/server/session/GlobalSession.java
@@ -772,7 +772,7 @@ private int calGlobalSessionSize(
 
     @Override
     public void decode(byte[] a) {
-        this.branchSessions = new ArrayList<>();
+        this.branchSessions = isLazyLoadBranch() ? null : new ArrayList<>();
         ByteBuffer byteBuffer = ByteBuffer.wrap(a);
         this.transactionId = byteBuffer.getLong();
         this.timeout = byteBuffer.getInt();
diff --git a/server/src/main/java/org/apache/seata/server/session/SessionHolder.java b/server/src/main/java/org/apache/seata/server/session/SessionHolder.java
index 32baf181503..e3d55f749cb 100644
--- a/server/src/main/java/org/apache/seata/server/session/SessionHolder.java
+++ b/server/src/main/java/org/apache/seata/server/session/SessionHolder.java
@@ -33,13 +33,22 @@
 import org.apache.seata.core.store.DistributedLocker;
 import org.apache.seata.server.cluster.raft.RaftServerManager;
 import org.apache.seata.server.cluster.raft.context.SeataClusterContext;
+import org.apache.seata.server.lock.LockManager;
+import org.apache.seata.server.lock.LockerManagerFactory;
 import org.apache.seata.server.lock.distributed.DistributedLockerFactory;
+import org.apache.seata.server.storage.rocksdb.RocksDBStoreEngine;
+import org.apache.seata.server.storage.rocksdb.RocksDBStoreEngineFactory;
+import org.apache.seata.server.storage.rocksdb.index.RocksDBIndexManager;
+import org.apache.seata.server.storage.rocksdb.lock.RocksDBLockManager;
+import org.apache.seata.server.storage.rocksdb.migration.RocksDBMigrationService;
+import org.apache.seata.server.store.FileStoreEngine;
 import org.apache.seata.server.store.StoreConfig;
 import org.apache.seata.server.store.VGroupMappingStoreManager;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import java.io.IOException;
+import java.nio.file.Paths;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.List;
@@ -121,6 +130,7 @@ public static void init(SessionMode sessionMode) {
                 RaftServerManager.init();
                 RaftServerManager.start();
             } else {
+                FileStoreEngine fileStoreEngine = StoreConfig.getFileEngine();
                 String vGroupMappingStorePath =
                         CONFIG.getConfig(ConfigurationKeys.STORE_FILE_DIR, DEFAULT_VGROUP_MAPPING_STORE_FILE_DIR)
                                 + separator
@@ -137,15 +147,24 @@ public static void init(SessionMode sessionMode) {
                         SessionMode.FILE.getName(),
                         new Object[] {vGroupMappingStorePath});
 
-                ROOT_SESSION_MANAGER =
-                        EnhancedServiceLoader.load(SessionManager.class, SessionMode.FILE.getName(), new Object[] {
-                            ROOT_SESSION_MANAGER_NAME, sessionStorePath
-                        });
-                ROOT_SESSION_MANAGER =
-                        EnhancedServiceLoader.load(SessionManager.class, SessionMode.FILE.getName(), new Object[] {
-                            ROOT_SESSION_MANAGER_NAME, sessionStorePath
-                        });
-                reload(sessionMode);
+                if (FileStoreEngine.ROCKSDB == fileStoreEngine) {
+                    RocksDBStoreEngine rocksDBStoreEngine = RocksDBStoreEngineFactory.getInstance();
+                    new RocksDBMigrationService()
+                            .migrate(Paths.get(sessionStorePath, ROOT_SESSION_MANAGER_NAME), rocksDBStoreEngine);
+                    new RocksDBIndexManager(rocksDBStoreEngine).ensureReady();
+                    ROOT_SESSION_MANAGER = EnhancedServiceLoader.load(
+                            SessionManager.class,
+                            FileStoreEngine.ROCKSDB.getName(),
+                            new Object[] {ROOT_SESSION_MANAGER_NAME});
+                    cleanRocksDBOrphanLocks();
+                    reload(ROOT_SESSION_MANAGER.allSessions(), sessionMode);
+                } else {
+                    ROOT_SESSION_MANAGER =
+                            EnhancedServiceLoader.load(SessionManager.class, SessionMode.FILE.getName(), new Object[] {
+                                ROOT_SESSION_MANAGER_NAME, sessionStorePath
+                            });
+                    reload(sessionMode);
+                }
             }
         } else if (SessionMode.REDIS.equals(sessionMode)) {
             ROOT_SESSION_MANAGER = EnhancedServiceLoader.load(SessionManager.class, SessionMode.REDIS.getName());
@@ -158,15 +177,28 @@ public static void init(SessionMode sessionMode) {
         }
     }
 
+    private static void cleanRocksDBOrphanLocks() {
+        LockManager lockManager = LockerManagerFactory.getLockManager();
+        if (!(lockManager instanceof RocksDBLockManager)) {
+            return;
+        }
+        int cleaned = ((RocksDBLockManager) lockManager).cleanOrphanLocks();
+        if (cleaned > 0) {
+            LOGGER.warn("Cleaned RocksDB orphan locks, count:{}", cleaned);
+        }
+    }
+
     /**
      * Reload.
      *
      * @param sessionMode the mode of store
      */
     protected static void reload(SessionMode sessionMode) {
-        if (sessionMode == SessionMode.FILE) {
+        if (sessionMode == SessionMode.FILE && ROOT_SESSION_MANAGER instanceof Reloadable) {
             ((Reloadable) ROOT_SESSION_MANAGER).reload();
             reload(ROOT_SESSION_MANAGER.allSessions(), sessionMode);
+        } else if (sessionMode == SessionMode.FILE) {
+            reload(ROOT_SESSION_MANAGER.allSessions(), sessionMode);
         } else {
             reload(null, sessionMode);
         }
@@ -209,6 +241,8 @@ public static void reload(Collection<GlobalSession> allSessions, SessionMode sto
                     case CommitFailed:
                     case RollbackFailed:
                     case TimeoutRollbackFailed:
+                    case CommitRetryTimeout:
+                    case RollbackRetryTimeout:
                         removeInErrorState(globalSession);
                         break;
                     case AsyncCommitting:
diff --git a/server/src/main/java/org/apache/seata/server/storage/file/store/FileSessionLogReplayer.java b/server/src/main/java/org/apache/seata/server/storage/file/store/FileSessionLogReplayer.java
new file mode 100644
index 00000000000..6d048cac0ae
--- /dev/null
+++ b/server/src/main/java/org/apache/seata/server/storage/file/store/FileSessionLogReplayer.java
@@ -0,0 +1,146 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.seata.server.storage.file.store;
+
+import org.apache.seata.common.exception.StoreException;
+import org.apache.seata.common.util.BufferUtils;
+import org.apache.seata.server.storage.file.TransactionWriteStore;
+import org.apache.seata.server.store.StoreConfig;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardOpenOption;
+
+/**
+ * Replays file-mode session logs without starting the file store writer.
+ */
+public class FileSessionLogReplayer {
+
+    private static final String HISTORY_FILE_POSTFIX = ".1";
+    private static final String MIGRATION_MARKER_POSTFIX = ".rocksdb_migrated";
+    private static final int MARK_SIZE = Integer.BYTES;
+
+    public boolean hasSessionLogs(Path currentLogPath) {
+        return hasReadableData(historyLogPath(currentLogPath)) || hasReadableData(currentLogPath);
+    }
+
+    public boolean hasMigrationMarker(Path currentLogPath) {
+        return Files.isRegularFile(migrationMarkerPath(currentLogPath));
+    }
+
+    public void markMigrated(Path currentLogPath) {
+        Path markerPath = migrationMarkerPath(currentLogPath);
+        try {
+            if (markerPath.getParent() != null) {
+                Files.createDirectories(markerPath.getParent());
+            }
+            Files.write(
+                    markerPath,
+                    "migrated to rocksdb\n".getBytes(StandardCharsets.UTF_8),
+                    StandardOpenOption.CREATE,
+                    StandardOpenOption.TRUNCATE_EXISTING);
+        } catch (IOException e) {
+            throw new StoreException(e, "mark file session log migrated failed, marker:" + markerPath);
+        }
+    }
+
+    public int replay(Path currentLogPath, TransactionWriteStoreVisitor visitor) {
+        int count = replayFile(historyLogPath(currentLogPath), visitor);
+        return count + replayFile(currentLogPath, visitor);
+    }
+
+    private int replayFile(Path logPath, TransactionWriteStoreVisitor visitor) {
+        if (!hasReadableData(logPath)) {
+            return 0;
+        }
+        int count = 0;
+        try (FileChannel fileChannel = FileChannel.open(logPath, StandardOpenOption.READ)) {
+            ByteBuffer sizeBuffer = ByteBuffer.allocate(MARK_SIZE);
+            while (fileChannel.position() < fileChannel.size()) {
+                BufferUtils.clear(sizeBuffer);
+                if (!readFully(fileChannel, sizeBuffer)) {
+                    break;
+                }
+                BufferUtils.flip(sizeBuffer);
+                int bodySize = sizeBuffer.getInt();
+                if (bodySize <= 0) {
+                    throw new StoreException("invalid file session log body size:" + bodySize + ", file:" + logPath);
+                }
+                if (bodySize > maxReplayBodySize()) {
+                    throw new StoreException("file session log body size exceeds limit:" + bodySize + ", max:"
+                            + maxReplayBodySize() + ", file:" + logPath);
+                }
+
+                ByteBuffer bodyBuffer = ByteBuffer.allocate(bodySize);
+                if (!readFully(fileChannel, bodyBuffer)) {
+                    break;
+                }
+                TransactionWriteStore writeStore = new TransactionWriteStore();
+                writeStore.decode(bodyBuffer.array());
+                visitor.visit(writeStore);
+                count++;
+            }
+            return count;
+        } catch (StoreException e) {
+            throw e;
+        } catch (Exception e) {
+            throw new StoreException(e, "replay file session log failed, file:" + logPath);
+        }
+    }
+
+    private boolean hasReadableData(Path logPath) {
+        try {
+            return Files.isRegularFile(logPath) && Files.size(logPath) > 0;
+        } catch (IOException e) {
+            throw new StoreException(e, "inspect file session log failed, file:" + logPath);
+        }
+    }
+
+    private Path historyLogPath(Path currentLogPath) {
+        return currentLogPath.resolveSibling(currentLogPath.getFileName() + HISTORY_FILE_POSTFIX);
+    }
+
+    private Path migrationMarkerPath(Path currentLogPath) {
+        return currentLogPath.resolveSibling(currentLogPath.getFileName() + MIGRATION_MARKER_POSTFIX);
+    }
+
+    private int maxReplayBodySize() {
+        return Math.max(StoreConfig.getMaxGlobalSessionSize(), StoreConfig.getMaxBranchSessionSize()) + 1;
+    }
+
+    private boolean readFully(FileChannel fileChannel, ByteBuffer buffer) throws IOException {
+        while (buffer.hasRemaining()) {
+            int read = fileChannel.read(buffer);
+            if (read < 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Visitor for decoded file-mode transaction write stores.
+     */
+    @FunctionalInterface
+    public interface TransactionWriteStoreVisitor {
+        void visit(TransactionWriteStore writeStore);
+    }
+}
diff --git a/server/src/main/java/org/apache/seata/server/storage/rocksdb/RocksDBColumnFamily.java b/server/src/main/java/org/apache/seata/server/storage/rocksdb/RocksDBColumnFamily.java
new file mode 100644
index 00000000000..80748896623
--- /dev/null
+++ b/server/src/main/java/org/apache/seata/server/storage/rocksdb/RocksDBColumnFamily.java
@@ -0,0 +1,79 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.seata.server.storage.rocksdb;
+
+import org.rocksdb.RocksDB;
+
+import java.nio.charset.StandardCharsets;
+
+/**
+ * RocksDB column families used by file store engine.
+ */
+public enum RocksDBColumnFamily {
+    /**
+     * The default column family required by RocksDB.
+     */
+    DEFAULT("default", RocksDB.DEFAULT_COLUMN_FAMILY),
+    /**
+     * Metadata column family.
+     */
+    METADATA("metadata"),
+    /**
+     * Global session column family.
+     */
+    GLOBAL_SESSION("global_session"),
+    /**
+     * Branch session column family.
+     */
+    BRANCH_SESSION("branch_session"),
+    /**
+     * Lock holder column family.
+     */
+    LOCK("lock"),
+    /**
+     * Branch to lock index column family.
+     */
+    LOCK_BRANCH_INDEX("lock_branch_index"),
+    /**
+     * Global status query index column family.
+     */
+    GLOBAL_STATUS_INDEX("global_status_index"),
+    /**
+     * Global transaction id query index column family.
+     */
+    TRANSACTION_ID_INDEX("transaction_id_index");
+
+    private final String name;
+    private final byte[] nameBytes;
+
+    RocksDBColumnFamily(String name) {
+        this(name, name.getBytes(StandardCharsets.UTF_8));
+    }
+
+    RocksDBColumnFamily(String name, byte[] nameBytes) {
+        this.name = name;
+        this.nameBytes = nameBytes;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public byte[] getNameBytes() {
+        return nameBytes.clone();
+    }
+}
diff --git a/server/src/main/java/org/apache/seata/server/storage/rocksdb/RocksDBKeyCodec.java b/server/src/main/java/org/apache/seata/server/storage/rocksdb/RocksDBKeyCodec.java
new file mode 100644
index 00000000000..6013a82d7cf
--- /dev/null
+++ b/server/src/main/java/org/apache/seata/server/storage/rocksdb/RocksDBKeyCodec.java
@@ -0,0 +1,131 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.seata.server.storage.rocksdb;
+
+import org.apache.seata.core.model.GlobalStatus;
+
+import java.io.ByteArrayOutputStream;
+import java.nio.ByteBuffer;
+import java.nio.charset.StandardCharsets;
+
+/**
+ * Stable binary key codec for RocksDB file store engine.
+ */
+public final class RocksDBKeyCodec {
+
+    private static final int LONG_BYTE_SIZE = Long.BYTES;
+    private static final int INT_BYTE_SIZE = Integer.BYTES;
+
+    private RocksDBKeyCodec() {}
+
+    public static byte[] encodeXid(String xid) {
+        return encodeComponent(xid);
+    }
+
+    public static byte[] encodeXidPrefix(String xid) {
+        return encodeComponent(xid);
+    }
+
+    public static byte[] encodeBranch(String xid, long branchId) {
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        write(out, encodeComponent(xid));
+        writeLong(out, branchId);
+        return out.toByteArray();
+    }
+
+    public static byte[] encodeBranchPrefix(String xid, long branchId) {
+        return encodeBranch(xid, branchId);
+    }
+
+    public static byte[] encodeRowLock(String resourceId, String tableName, String pk) {
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        write(out, encodeComponent(resourceId));
+        write(out, encodeComponent(tableName));
+        write(out, encodeComponent(pk));
+        return out.toByteArray();
+    }
+
+    public static byte[] encodeLockBranchIndex(String xid, long branchId, byte[] lockKey) {
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        write(out, encodeBranch(xid, branchId));
+        write(out, encodeComponent(lockKey));
+        return out.toByteArray();
+    }
+
+    public static byte[] encodeLockBranchIndexBranchPrefix(String xid, long branchId) {
+        return encodeBranch(xid, branchId);
+    }
+
+    public static byte[] encodeLockBranchIndexGlobalPrefix(String xid) {
+        return encodeXidPrefix(xid);
+    }
+
+    public static byte[] encodeGlobalStatusIndex(GlobalStatus status, long beginTime, String xid) {
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        writeInt(out, status.getCode());
+        writeLong(out, beginTime);
+        write(out, encodeComponent(xid));
+        return out.toByteArray();
+    }
+
+    public static byte[] encodeGlobalStatusPrefix(GlobalStatus status) {
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        writeInt(out, status.getCode());
+        return out.toByteArray();
+    }
+
+    public static byte[] encodeTransactionIdIndex(long transactionId) {
+        return ByteBuffer.allocate(LONG_BYTE_SIZE).putLong(transactionId).array();
+    }
+
+    public static boolean startsWith(byte[] key, byte[] prefix) {
+        if (key == null || prefix == null || key.length < prefix.length) {
+            return false;
+        }
+        for (int i = 0; i < prefix.length; i++) {
+            if (key[i] != prefix[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private static byte[] encodeComponent(String value) {
+        byte[] valueBytes = value == null ? new byte[0] : value.getBytes(StandardCharsets.UTF_8);
+        return encodeComponent(valueBytes);
+    }
+
+    private static byte[] encodeComponent(byte[] value) {
+        byte[] valueBytes = value == null ? new byte[0] : value;
+        ByteBuffer buffer = ByteBuffer.allocate(INT_BYTE_SIZE + valueBytes.length);
+        buffer.putInt(valueBytes.length);
+        buffer.put(valueBytes);
+        return buffer.array();
+    }
+
+    private static void writeLong(ByteArrayOutputStream out, long value) {
+        write(out, ByteBuffer.allocate(LONG_BYTE_SIZE).putLong(value).array());
+    }
+
+    private static void writeInt(ByteArrayOutputStream out, int value) {
+        write(out, ByteBuffer.allocate(INT_BYTE_SIZE).putInt(value).array());
+    }
+
+    private static void write(ByteArrayOutputStream out, byte[] bytes) {
+        out.write(bytes, 0, bytes.length);
+    }
+}
diff --git a/server/src/main/java/org/apache/seata/server/storage/rocksdb/RocksDBLocalLocks.java b/server/src/main/java/org/apache/seata/server/storage/rocksdb/RocksDBLocalLocks.java
new file mode 100644
index 00000000000..d1787677ed2
--- /dev/null
+++ b/server/src/main/java/org/apache/seata/server/storage/rocksdb/RocksDBLocalLocks.java
@@ -0,0 +1,114 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.seata.server.storage.rocksdb;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.IdentityHashMap;
+import java.util.List;
+import java.util.Objects;
+import java.util.Set;
+import java.util.concurrent.locks.ReentrantLock;
+
+/**
+ * Local striped locks used to protect RocksDB read-modify-write sections.
+ */
+public class RocksDBLocalLocks {
+
+    private static final int DEFAULT_STRIPES = 1024;
+
+    private final ReentrantLock[] locks;
+
+    public RocksDBLocalLocks() {
+        this(DEFAULT_STRIPES);
+    }
+
+    public RocksDBLocalLocks(int stripes) {
+        if (stripes <= 0) {
+            throw new IllegalArgumentException("stripes must be greater than 0");
+        }
+        locks = new ReentrantLock[stripes];
+        for (int i = 0; i < locks.length; i++) {
+            locks[i] = new ReentrantLock();
+        }
+    }
+
+    public LockScope lock(byte[] key) {
+        return lockAll(Collections.singletonList(key));
+    }
+
+    public LockScope lockAll(Collection<byte[]> keys) {
+        if (keys == null || keys.isEmpty()) {
+            return new LockScope(Collections.emptyList());
+        }
+        List<byte[]> sortedKeys = new ArrayList<>(keys.size());
+        for (byte[] key : keys) {
+            sortedKeys.add(Objects.requireNonNull(key, "key must not be null"));
+        }
+        Collections.sort(sortedKeys, RocksDBLocalLocks::compare);
+
+        List<ReentrantLock> acquiredLocks = new ArrayList<>();
+        Set<ReentrantLock> seen = Collections.newSetFromMap(new IdentityHashMap<>());
+        for (byte[] key : sortedKeys) {
+            ReentrantLock lock = lockFor(key);
+            if (seen.add(lock)) {
+                lock.lock();
+                acquiredLocks.add(lock);
+            }
+        }
+        return new LockScope(acquiredLocks);
+    }
+
+    private ReentrantLock lockFor(byte[] key) {
+        int hash = Arrays.hashCode(key);
+        return locks[Math.floorMod(hash, locks.length)];
+    }
+
+    private static int compare(byte[] left, byte[] right) {
+        if (left == right) {
+            return 0;
+        }
+        int length = Math.min(left.length, right.length);
+        for (int i = 0; i < length; i++) {
+            int result = Byte.compare(left[i], right[i]);
+            if (result != 0) {
+                return result;
+            }
+        }
+        return Integer.compare(left.length, right.length);
+    }
+
+    /**
+     * Scope object that releases locks in reverse acquisition order.
+     */
+    public static class LockScope implements AutoCloseable {
+        private final List<ReentrantLock> acquiredLocks;
+
+        private LockScope(List<ReentrantLock> acquiredLocks) {
+            this.acquiredLocks = acquiredLocks;
+        }
+
+        @Override
+        public void close() {
+            for (int i = acquiredLocks.size() - 1; i >= 0; i--) {
+                acquiredLocks.get(i).unlock();
+            }
+        }
+    }
+}
diff --git a/server/src/main/java/org/apache/seata/server/storage/rocksdb/RocksDBStoreConfig.java b/server/src/main/java/org/apache/seata/server/storage/rocksdb/RocksDBStoreConfig.java
new file mode 100644
index 00000000000..bb3329d7399
--- /dev/null
+++ b/server/src/main/java/org/apache/seata/server/storage/rocksdb/RocksDBStoreConfig.java
@@ -0,0 +1,63 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.seata.server.storage.rocksdb;
+
+import org.apache.seata.common.ConfigurationKeys;
+import org.apache.seata.common.XID;
+import org.apache.seata.common.util.StringUtils;
+import org.apache.seata.config.ConfigurationFactory;
+import org.apache.seata.server.storage.file.FlushDiskMode;
+import org.apache.seata.server.store.StoreConfig;
+
+import static java.io.File.separator;
+import static org.apache.seata.common.DefaultValues.DEFAULT_SESSION_STORE_FILE_DIR;
+
+/**
+ * RocksDB store configuration.
+ */
+public class RocksDBStoreConfig {
+
+    private final String dbPath;
+    private final boolean syncWrite;
+
+    public RocksDBStoreConfig(String dbPath, boolean syncWrite) {
+        this.dbPath = dbPath;
+        this.syncWrite = syncWrite;
+    }
+
+    public static RocksDBStoreConfig fromConfiguration() {
+        org.apache.seata.config.Configuration config = ConfigurationFactory.getInstance();
+        String configuredDir = config.getConfig(ConfigurationKeys.STORE_FILE_ROCKSDB_DIR);
+        String dbPath = configuredDir;
+        if (StringUtils.isBlank(dbPath)) {
+            dbPath = config.getConfig(ConfigurationKeys.STORE_FILE_DIR, DEFAULT_SESSION_STORE_FILE_DIR)
+                    + separator
+                    + XID.getPort()
+                    + separator
+                    + "rocksdb";
+        }
+        return new RocksDBStoreConfig(dbPath, StoreConfig.getFlushDiskMode() == FlushDiskMode.SYNC_MODEL);
+    }
+
+    public String getDbPath() {
+        return dbPath;
+    }
+
+    public boolean isSyncWrite() {
+        return syncWrite;
+    }
+}
diff --git a/server/src/main/java/org/apache/seata/server/storage/rocksdb/RocksDBStoreEngine.java b/server/src/main/java/org/apache/seata/server/storage/rocksdb/RocksDBStoreEngine.java
new file mode 100644
index 00000000000..98419d658dd
--- /dev/null
+++ b/server/src/main/java/org/apache/seata/server/storage/rocksdb/RocksDBStoreEngine.java
@@ -0,0 +1,362 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.seata.server.storage.rocksdb;
+
+import org.apache.seata.common.exception.StoreException;
+import org.rocksdb.ColumnFamilyDescriptor;
+import org.rocksdb.ColumnFamilyHandle;
+import org.rocksdb.ColumnFamilyOptions;
+import org.rocksdb.DBOptions;
+import org.rocksdb.FlushOptions;
+import org.rocksdb.ReadOptions;
+import org.rocksdb.RocksDB;
+import org.rocksdb.RocksDBException;
+import org.rocksdb.RocksIterator;
+import org.rocksdb.WriteBatch;
+import org.rocksdb.WriteOptions;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.EnumMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+
+/**
+ * Shared RocksDB engine for file store engine.
+ */
+public class RocksDBStoreEngine implements AutoCloseable {
+
+    public static final int FORMAT_VERSION = 1;
+
+    private static final int DELETE_BATCH_SIZE = 1024;
+    private static final Logger LOGGER = LoggerFactory.getLogger(RocksDBStoreEngine.class);
+    private static final byte[] FORMAT_VERSION_KEY = "format_version".getBytes(StandardCharsets.UTF_8);
+
+    static {
+        RocksDB.loadLibrary();
+    }
+
+    private final RocksDBStoreConfig config;
+    private final Map<RocksDBColumnFamily, ColumnFamilyHandle> handles = new EnumMap<>(RocksDBColumnFamily.class);
+    private final DBOptions dbOptions;
+    private final ColumnFamilyOptions columnFamilyOptions;
+    private final ReadOptions readOptions;
+    private final WriteOptions writeOptions;
+    private final RocksDB db;
+
+    private volatile boolean closed;
+
+    private RocksDBStoreEngine(RocksDBStoreConfig config) {
+        this.config = config;
+        DBOptions openedDbOptions = null;
+        ColumnFamilyOptions openedColumnFamilyOptions = null;
+        ReadOptions openedReadOptions = null;
+        WriteOptions openedWriteOptions = null;
+        RocksDB openedDb = null;
+        List<ColumnFamilyHandle> openedHandles = new ArrayList<>();
+        Map<RocksDBColumnFamily, ColumnFamilyHandle> openedHandleMap = new EnumMap<>(RocksDBColumnFamily.class);
+        try {
+            Files.createDirectories(Paths.get(config.getDbPath()));
+            openedDbOptions = new DBOptions().setCreateIfMissing(true).setCreateMissingColumnFamilies(true);
+            openedColumnFamilyOptions = new ColumnFamilyOptions();
+            openedReadOptions = new ReadOptions();
+            openedWriteOptions = new WriteOptions().setDisableWAL(false).setSync(config.isSyncWrite());
+
+            List<ColumnFamilyDescriptor> descriptors = new ArrayList<>();
+            for (RocksDBColumnFamily columnFamily : RocksDBColumnFamily.values()) {
+                descriptors.add(new ColumnFamilyDescriptor(columnFamily.getNameBytes(), openedColumnFamilyOptions));
+            }
+
+            openedDb = RocksDB.open(openedDbOptions, config.getDbPath(), descriptors, openedHandles);
+            for (int i = 0; i < RocksDBColumnFamily.values().length; i++) {
+                openedHandleMap.put(RocksDBColumnFamily.values()[i], openedHandles.get(i));
+            }
+            initMetadata(openedDb, openedHandleMap.get(RocksDBColumnFamily.METADATA), openedWriteOptions);
+            dbOptions = openedDbOptions;
+            columnFamilyOptions = openedColumnFamilyOptions;
+            readOptions = openedReadOptions;
+            writeOptions = openedWriteOptions;
+            db = openedDb;
+            handles.putAll(openedHandleMap);
+            LOGGER.info(
+                    "RocksDB file store engine opened, path:{}, columnFamilies:{}, formatVersion:{}, syncWrite:{}",
+                    config.getDbPath(),
+                    handles.keySet(),
+                    FORMAT_VERSION,
+                    config.isSyncWrite());
+        } catch (StoreException e) {
+            closeQuietly(
+                    openedHandles,
+                    openedDb,
+                    openedWriteOptions,
+                    openedReadOptions,
+                    openedColumnFamilyOptions,
+                    openedDbOptions);
+            throw e;
+        } catch (Exception e) {
+            closeQuietly(
+                    openedHandles,
+                    openedDb,
+                    openedWriteOptions,
+                    openedReadOptions,
+                    openedColumnFamilyOptions,
+                    openedDbOptions);
+            throw new StoreException(e, "open RocksDB file store engine failed, path:" + config.getDbPath());
+        }
+    }
+
+    public static RocksDBStoreEngine open(RocksDBStoreConfig config) {
+        return new RocksDBStoreEngine(config);
+    }
+
+    public RocksDBStoreConfig getConfig() {
+        return config;
+    }
+
+    public boolean isSyncWrite() {
+        return config.isSyncWrite();
+    }
+
+    public byte[] get(RocksDBColumnFamily columnFamily, byte[] key) {
+        try {
+            return db.get(handle(columnFamily), key);
+        } catch (RocksDBException e) {
+            throw new StoreException(e, "read RocksDB failed, columnFamily:" + columnFamily.getName());
+        }
+    }
+
+    public void put(RocksDBColumnFamily columnFamily, byte[] key, byte[] value) {
+        try {
+            db.put(handle(columnFamily), writeOptions, key, value);
+        } catch (RocksDBException e) {
+            throw new StoreException(e, "write RocksDB failed, columnFamily:" + columnFamily.getName());
+        }
+    }
+
+    public void delete(RocksDBColumnFamily columnFamily, byte[] key) {
+        try {
+            db.delete(handle(columnFamily), writeOptions, key);
+        } catch (RocksDBException e) {
+            throw new StoreException(e, "delete RocksDB failed, columnFamily:" + columnFamily.getName());
+        }
+    }
+
+    public void write(WriteBatch batch) {
+        try {
+            db.write(writeOptions, batch);
+        } catch (RocksDBException e) {
+            throw new StoreException(e, "write RocksDB batch failed");
+        }
+    }
+
+    public List<RocksDBEntry> prefixScan(RocksDBColumnFamily columnFamily, byte[] prefix) {
+        List<RocksDBEntry> entries = new ArrayList<>();
+        try (RocksIterator iterator = db.newIterator(handle(columnFamily), readOptions)) {
+            for (iterator.seek(prefix); iterator.isValid(); iterator.next()) {
+                byte[] key = iterator.key();
+                if (!RocksDBKeyCodec.startsWith(key, prefix)) {
+                    break;
+                }
+                entries.add(new RocksDBEntry(copy(key), copy(iterator.value())));
+            }
+            iterator.status();
+            return entries;
+        } catch (RocksDBException e) {
+            throw new StoreException(e, "scan RocksDB failed, columnFamily:" + columnFamily.getName());
+        }
+    }
+
+    public void scanByPrefix(RocksDBColumnFamily columnFamily, byte[] prefix, RocksDBEntryConsumer consumer) {
+        Objects.requireNonNull(prefix, "prefix must not be null");
+        Objects.requireNonNull(consumer, "consumer must not be null");
+        try (RocksIterator iterator = db.newIterator(handle(columnFamily), readOptions)) {
+            for (iterator.seek(prefix); iterator.isValid(); iterator.next()) {
+                byte[] key = iterator.key();
+                if (!RocksDBKeyCodec.startsWith(key, prefix)) {
+                    break;
+                }
+                consumer.accept(copy(key), copy(iterator.value()));
+            }
+            iterator.status();
+        } catch (RocksDBException e) {
+            throw new StoreException(e, "scan RocksDB prefix failed, columnFamily:" + columnFamily.getName());
+        }
+    }
+
+    public boolean prefixExists(RocksDBColumnFamily columnFamily, byte[] prefix) {
+        Objects.requireNonNull(prefix, "prefix must not be null");
+        try (RocksIterator iterator = db.newIterator(handle(columnFamily), readOptions)) {
+            iterator.seek(prefix);
+            boolean exists = iterator.isValid() && RocksDBKeyCodec.startsWith(iterator.key(), prefix);
+            iterator.status();
+            return exists;
+        } catch (RocksDBException e) {
+            throw new StoreException(e, "check RocksDB prefix failed, columnFamily:" + columnFamily.getName());
+        }
+    }
+
+    public void deleteByPrefix(RocksDBColumnFamily columnFamily, byte[] prefix) {
+        Objects.requireNonNull(prefix, "prefix must not be null");
+        ColumnFamilyHandle columnFamilyHandle = handle(columnFamily);
+        while (true) {
+            int count = 0;
+            try (RocksIterator iterator = db.newIterator(columnFamilyHandle, readOptions);
+                    WriteBatch batch = new WriteBatch()) {
+                for (iterator.seek(prefix); iterator.isValid(); iterator.next()) {
+                    byte[] key = iterator.key();
+                    if (!RocksDBKeyCodec.startsWith(key, prefix)) {
+                        break;
+                    }
+                    batch.delete(columnFamilyHandle, copy(key));
+                    count++;
+                    if (count >= DELETE_BATCH_SIZE) {
+                        break;
+                    }
+                }
+                iterator.status();
+                if (count == 0) {
+                    return;
+                }
+                db.write(writeOptions, batch);
+            } catch (RocksDBException e) {
+                throw new StoreException(e, "delete RocksDB prefix failed, columnFamily:" + columnFamily.getName());
+            }
+        }
+    }
+
+    public void flush() {
+        try (FlushOptions flushOptions = new FlushOptions().setWaitForFlush(true)) {
+            db.flush(flushOptions);
+        } catch (RocksDBException e) {
+            throw new StoreException(e, "flush RocksDB failed");
+        }
+    }
+
+    public ColumnFamilyHandle handle(RocksDBColumnFamily columnFamily) {
+        ColumnFamilyHandle handle = handles.get(columnFamily);
+        if (handle == null) {
+            throw new StoreException("RocksDB column family handle not found:" + columnFamily.getName());
+        }
+        return handle;
+    }
+
+    @Override
+    public void close() {
+        if (closed) {
+            return;
+        }
+        closed = true;
+        for (ColumnFamilyHandle handle : handles.values()) {
+            handle.close();
+        }
+        db.close();
+        writeOptions.close();
+        readOptions.close();
+        columnFamilyOptions.close();
+        dbOptions.close();
+    }
+
+    private static void initMetadata(RocksDB db, ColumnFamilyHandle metadataHandle, WriteOptions writeOptions)
+            throws RocksDBException {
+        byte[] existing = db.get(metadataHandle, FORMAT_VERSION_KEY);
+        if (existing == null) {
+            db.put(
+                    metadataHandle,
+                    writeOptions,
+                    FORMAT_VERSION_KEY,
+                    Integer.toString(FORMAT_VERSION).getBytes(StandardCharsets.UTF_8));
+            return;
+        }
+        int existingFormatVersion;
+        try {
+            existingFormatVersion = Integer.parseInt(new String(existing, StandardCharsets.UTF_8));
+        } catch (NumberFormatException e) {
+            throw new StoreException(e, "invalid RocksDB format version metadata");
+        }
+        if (existingFormatVersion != FORMAT_VERSION) {
+            throw new StoreException(
+                    "unsupported RocksDB format version:" + existingFormatVersion + ", expected:" + FORMAT_VERSION);
+        }
+    }
+
+    private static void closeQuietly(
+            List<ColumnFamilyHandle> handles,
+            RocksDB db,
+            WriteOptions writeOptions,
+            ReadOptions readOptions,
+            ColumnFamilyOptions columnFamilyOptions,
+            DBOptions dbOptions) {
+        for (ColumnFamilyHandle handle : handles) {
+            handle.close();
+        }
+        if (db != null) {
+            db.close();
+        }
+        if (writeOptions != null) {
+            writeOptions.close();
+        }
+        if (readOptions != null) {
+            readOptions.close();
+        }
+        if (columnFamilyOptions != null) {
+            columnFamilyOptions.close();
+        }
+        if (dbOptions != null) {
+            dbOptions.close();
+        }
+    }
+
+    private static byte[] copy(byte[] bytes) {
+        return bytes == null ? null : Arrays.copyOf(bytes, bytes.length);
+    }
+
+    /**
+     * RocksDB key-value entry.
+     */
+    public static class RocksDBEntry {
+        private final byte[] key;
+        private final byte[] value;
+
+        public RocksDBEntry(byte[] key, byte[] value) {
+            this.key = key;
+            this.value = value;
+        }
+
+        public byte[] getKey() {
+            return copy(key);
+        }
+
+        public byte[] getValue() {
+            return copy(value);
+        }
+    }
+
+    /**
+     * Streaming RocksDB entry consumer.
+     */
+    @FunctionalInterface
+    public interface RocksDBEntryConsumer {
+
+        void accept(byte[] key, byte[] value) throws RocksDBException;
+    }
+}
diff --git a/server/src/main/java/org/apache/seata/server/storage/rocksdb/RocksDBStoreEngineFactory.java b/server/src/main/java/org/apache/seata/server/storage/rocksdb/RocksDBStoreEngineFactory.java
new file mode 100644
index 00000000000..01f878339ab
--- /dev/null
+++ b/server/src/main/java/org/apache/seata/server/storage/rocksdb/RocksDBStoreEngineFactory.java
@@ -0,0 +1,61 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.seata.server.storage.rocksdb;
+
+import org.apache.seata.common.exception.StoreException;
+
+/**
+ * Shared RocksDB store engine factory.
+ */
+public final class RocksDBStoreEngineFactory {
+
+    private static volatile RocksDBStoreEngine ENGINE;
+
+    private RocksDBStoreEngineFactory() {}
+
+    public static RocksDBStoreEngine getInstance() {
+        return getInstance(RocksDBStoreConfig.fromConfiguration());
+    }
+
+    public static RocksDBStoreEngine getInstance(RocksDBStoreConfig config) {
+        if (ENGINE == null) {
+            synchronized (RocksDBStoreEngineFactory.class) {
+                if (ENGINE == null) {
+                    ENGINE = RocksDBStoreEngine.open(config);
+                }
+            }
+        }
+        if (!ENGINE.getConfig().getDbPath().equals(config.getDbPath())) {
+            throw new StoreException("RocksDB file store engine already opened with path:"
+                    + ENGINE.getConfig().getDbPath() + ", requested path:" + config.getDbPath());
+        }
+        if (ENGINE.getConfig().isSyncWrite() != config.isSyncWrite()) {
+            throw new StoreException("RocksDB file store engine already opened with syncWrite:"
+                    + ENGINE.getConfig().isSyncWrite() + ", requested syncWrite:" + config.isSyncWrite());
+        }
+        return ENGINE;
+    }
+
+    public static void destroy() {
+        synchronized (RocksDBStoreEngineFactory.class) {
+            if (ENGINE != null) {
+                ENGINE.close();
+                ENGINE = null;
+            }
+        }
+    }
+}
diff --git a/server/src/main/java/org/apache/seata/server/storage/rocksdb/RocksDBValueCodec.java b/server/src/main/java/org/apache/seata/server/storage/rocksdb/RocksDBValueCodec.java
new file mode 100644
index 00000000000..a9f0d32c38d
--- /dev/null
+++ b/server/src/main/java/org/apache/seata/server/storage/rocksdb/RocksDBValueCodec.java
@@ -0,0 +1,130 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.seata.server.storage.rocksdb;
+
+import org.apache.seata.common.exception.StoreException;
+
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+
+/**
+ * Versioned value codec for RocksDB file store engine.
+ */
+public final class RocksDBValueCodec {
+
+    private static final int MAGIC = 0x53415244;
+    private static final short VERSION = 1;
+    private static final int HEADER_SIZE = Integer.BYTES + Short.BYTES + Byte.BYTES;
+
+    private RocksDBValueCodec() {}
+
+    public static byte[] encode(ValueType type, byte[] payload) {
+        byte[] value = payload == null ? new byte[0] : payload;
+        ByteBuffer buffer = ByteBuffer.allocate(HEADER_SIZE + value.length);
+        buffer.putInt(MAGIC);
+        buffer.putShort(VERSION);
+        buffer.put(type.getCode());
+        buffer.put(value);
+        return buffer.array();
+    }
+
+    public static DecodedValue decode(byte[] value) {
+        if (value == null || value.length < HEADER_SIZE) {
+            throw new StoreException("invalid RocksDB value header");
+        }
+        ByteBuffer buffer = ByteBuffer.wrap(value);
+        int magic = buffer.getInt();
+        if (magic != MAGIC) {
+            throw new StoreException("invalid RocksDB value magic");
+        }
+        short version = buffer.getShort();
+        if (version != VERSION) {
+            throw new StoreException("unsupported RocksDB value version:" + version);
+        }
+        ValueType type = ValueType.get(buffer.get());
+        byte[] payload = Arrays.copyOfRange(value, HEADER_SIZE, value.length);
+        return new DecodedValue(version, type, payload);
+    }
+
+    /**
+     * Encoded value type.
+     */
+    public enum ValueType {
+        /**
+         * Global session value.
+         */
+        GLOBAL_SESSION((byte) 1),
+        /**
+         * Branch session value.
+         */
+        BRANCH_SESSION((byte) 2),
+        /**
+         * Lock holder value.
+         */
+        LOCK_HOLDER((byte) 3),
+        /**
+         * Metadata value.
+         */
+        METADATA((byte) 4);
+
+        private final byte code;
+
+        ValueType(byte code) {
+            this.code = code;
+        }
+
+        public byte getCode() {
+            return code;
+        }
+
+        public static ValueType get(byte code) {
+            for (ValueType valueType : values()) {
+                if (valueType.getCode() == code) {
+                    return valueType;
+                }
+            }
+            throw new StoreException("unknown RocksDB value type:" + code);
+        }
+    }
+
+    /**
+     * Decoded RocksDB value.
+     */
+    public static class DecodedValue {
+        private final short version;
+        private final ValueType type;
+        private final byte[] payload;
+
+        private DecodedValue(short version, ValueType type, byte[] payload) {
+            this.version = version;
+            this.type = type;
+            this.payload = payload;
+        }
+
+        public short getVersion() {
+            return version;
+        }
+
+        public ValueType getType() {
+            return type;
+        }
+
+        public byte[] getPayload() {
+            return Arrays.copyOf(payload, payload.length);
+        }
+    }
+}
diff --git a/server/src/main/java/org/apache/seata/server/storage/rocksdb/index/RocksDBIndexManager.java b/server/src/main/java/org/apache/seata/server/storage/rocksdb/index/RocksDBIndexManager.java
new file mode 100644
index 00000000000..556ece2fcfd
--- /dev/null
+++ b/server/src/main/java/org/apache/seata/server/storage/rocksdb/index/RocksDBIndexManager.java
@@ -0,0 +1,186 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.seata.server.storage.rocksdb.index;
+
+import org.apache.seata.common.exception.StoreException;
+import org.apache.seata.core.model.GlobalStatus;
+import org.apache.seata.server.session.GlobalSession;
+import org.apache.seata.server.storage.rocksdb.RocksDBColumnFamily;
+import org.apache.seata.server.storage.rocksdb.RocksDBKeyCodec;
+import org.apache.seata.server.storage.rocksdb.RocksDBStoreEngine;
+import org.apache.seata.server.storage.rocksdb.RocksDBValueCodec;
+import org.rocksdb.RocksDBException;
+import org.rocksdb.WriteBatch;
+
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+import java.util.function.Consumer;
+
+/**
+ * Secondary index manager for RocksDB global sessions.
+ */
+public class RocksDBIndexManager {
+
+    public static final int INDEX_VERSION = 1;
+    public static final String INDEX_VERSION_KEY = "index_version";
+    public static final String INDEX_BUILD_STATUS_KEY = "index_build_status";
+    public static final String INDEX_BUILD_STATUS_IN_PROGRESS = "in_progress";
+    public static final String INDEX_BUILD_STATUS_COMPLETED = "completed";
+
+    private static final byte[] EMPTY_PREFIX = new byte[0];
+
+    private final RocksDBStoreEngine storeEngine;
+
+    public RocksDBIndexManager(RocksDBStoreEngine storeEngine) {
+        this.storeEngine = storeEngine;
+    }
+
+    public void ensureReady() {
+        String version = getMetadata(INDEX_VERSION_KEY);
+        String status = getMetadata(INDEX_BUILD_STATUS_KEY);
+        if (version != null) {
+            int parsedVersion = parseIndexVersion(version);
+            if (parsedVersion > INDEX_VERSION) {
+                throw new StoreException("unsupported RocksDB index version:" + parsedVersion);
+            }
+        }
+        if (Integer.toString(INDEX_VERSION).equals(version) && INDEX_BUILD_STATUS_COMPLETED.equals(status)) {
+            return;
+        }
+        rebuildFromGlobalSessions();
+    }
+
+    public void rebuildFromGlobalSessions() {
+        putMetadata(INDEX_BUILD_STATUS_KEY, INDEX_BUILD_STATUS_IN_PROGRESS);
+        storeEngine.deleteByPrefix(RocksDBColumnFamily.GLOBAL_STATUS_INDEX, EMPTY_PREFIX);
+        storeEngine.deleteByPrefix(RocksDBColumnFamily.TRANSACTION_ID_INDEX, EMPTY_PREFIX);
+
+        WriteBatch[] batch = new WriteBatch[] {new WriteBatch()};
+        int[] count = new int[] {0};
+        try {
+            storeEngine.scanByPrefix(RocksDBColumnFamily.GLOBAL_SESSION, EMPTY_PREFIX, (key, value) -> {
+                putGlobalIndexes(batch[0], decodeGlobalSession(value));
+                count[0]++;
+                if (count[0] >= 1024) {
+                    storeEngine.write(batch[0]);
+                    batch[0].close();
+                    batch[0] = new WriteBatch();
+                    count[0] = 0;
+                }
+            });
+            if (count[0] > 0) {
+                storeEngine.write(batch[0]);
+            }
+        } finally {
+            batch[0].close();
+        }
+
+        try (WriteBatch metadataBatch = new WriteBatch()) {
+            metadataBatch.put(
+                    storeEngine.handle(RocksDBColumnFamily.METADATA),
+                    bytes(INDEX_VERSION_KEY),
+                    bytes(Integer.toString(INDEX_VERSION)));
+            metadataBatch.put(
+                    storeEngine.handle(RocksDBColumnFamily.METADATA),
+                    bytes(INDEX_BUILD_STATUS_KEY),
+                    bytes(INDEX_BUILD_STATUS_COMPLETED));
+            storeEngine.write(metadataBatch);
+        } catch (RocksDBException e) {
+            throw new StoreException(e, "write RocksDB index metadata failed");
+        }
+    }
+
+    public void putGlobalIndexes(WriteBatch batch, GlobalSession globalSession) throws RocksDBException {
+        byte[] xidValue = bytes(globalSession.getXid());
+        batch.put(
+                storeEngine.handle(RocksDBColumnFamily.GLOBAL_STATUS_INDEX),
+                RocksDBKeyCodec.encodeGlobalStatusIndex(
+                        globalSession.getStatus(), globalSession.getBeginTime(), globalSession.getXid()),
+                xidValue);
+        batch.put(
+                storeEngine.handle(RocksDBColumnFamily.TRANSACTION_ID_INDEX),
+                RocksDBKeyCodec.encodeTransactionIdIndex(globalSession.getTransactionId()),
+                xidValue);
+    }
+
+    public void deleteGlobalIndexes(WriteBatch batch, GlobalSession globalSession) throws RocksDBException {
+        batch.delete(
+                storeEngine.handle(RocksDBColumnFamily.GLOBAL_STATUS_INDEX),
+                RocksDBKeyCodec.encodeGlobalStatusIndex(
+                        globalSession.getStatus(), globalSession.getBeginTime(), globalSession.getXid()));
+        batch.delete(
+                storeEngine.handle(RocksDBColumnFamily.TRANSACTION_ID_INDEX),
+                RocksDBKeyCodec.encodeTransactionIdIndex(globalSession.getTransactionId()));
+    }
+
+    public String findXidByTransactionId(long transactionId) {
+        byte[] value = storeEngine.get(
+                RocksDBColumnFamily.TRANSACTION_ID_INDEX, RocksDBKeyCodec.encodeTransactionIdIndex(transactionId));
+        return value == null ? null : string(value);
+    }
+
+    public List<String> scanXidsByStatus(GlobalStatus status) {
+        List<String> xids = new ArrayList<>();
+        scanXidsByStatus(status, xids::add);
+        return xids;
+    }
+
+    public void scanXidsByStatus(GlobalStatus status, Consumer<String> consumer) {
+        Objects.requireNonNull(consumer, "consumer must not be null");
+        storeEngine.scanByPrefix(
+                RocksDBColumnFamily.GLOBAL_STATUS_INDEX,
+                RocksDBKeyCodec.encodeGlobalStatusPrefix(status),
+                (key, value) -> consumer.accept(string(value)));
+    }
+
+    private GlobalSession decodeGlobalSession(byte[] value) {
+        RocksDBValueCodec.DecodedValue decodedValue = RocksDBValueCodec.decode(value);
+        if (decodedValue.getType() != RocksDBValueCodec.ValueType.GLOBAL_SESSION) {
+            throw new StoreException("unexpected RocksDB value type for global session:" + decodedValue.getType());
+        }
+        GlobalSession globalSession = new GlobalSession(null, null, null, 0, true);
+        globalSession.decode(decodedValue.getPayload());
+        return globalSession;
+    }
+
+    private int parseIndexVersion(String version) {
+        try {
+            return Integer.parseInt(version);
+        } catch (NumberFormatException e) {
+            throw new StoreException(e, "invalid RocksDB index version metadata:" + version);
+        }
+    }
+
+    private String getMetadata(String key) {
+        byte[] value = storeEngine.get(RocksDBColumnFamily.METADATA, bytes(key));
+        return value == null ? null : string(value);
+    }
+
+    private void putMetadata(String key, String value) {
+        storeEngine.put(RocksDBColumnFamily.METADATA, bytes(key), bytes(value));
+    }
+
+    private static byte[] bytes(String value) {
+        return value.getBytes(StandardCharsets.UTF_8);
+    }
+
+    private static String string(byte[] value) {
+        return new String(value, StandardCharsets.UTF_8);
+    }
+}
diff --git a/server/src/main/java/org/apache/seata/server/storage/rocksdb/lock/RocksDBLockManager.java b/server/src/main/java/org/apache/seata/server/storage/rocksdb/lock/RocksDBLockManager.java
new file mode 100644
index 00000000000..adae379e22c
--- /dev/null
+++ b/server/src/main/java/org/apache/seata/server/storage/rocksdb/lock/RocksDBLockManager.java
@@ -0,0 +1,73 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.seata.server.storage.rocksdb.lock;
+
+import org.apache.seata.common.loader.LoadLevel;
+import org.apache.seata.core.exception.TransactionException;
+import org.apache.seata.core.lock.Locker;
+import org.apache.seata.server.lock.AbstractLockManager;
+import org.apache.seata.server.session.BranchSession;
+import org.apache.seata.server.session.GlobalSession;
+import org.apache.seata.server.storage.rocksdb.RocksDBLocalLocks;
+import org.apache.seata.server.storage.rocksdb.RocksDBStoreEngine;
+import org.apache.seata.server.storage.rocksdb.RocksDBStoreEngineFactory;
+
+/**
+ * RocksDB lock manager for file store engine.
+ */
+@LoadLevel(name = "rocksdb")
+public class RocksDBLockManager extends AbstractLockManager {
+
+    private final RocksDBLocker locker;
+
+    public RocksDBLockManager() {
+        this(RocksDBStoreEngineFactory.getInstance());
+    }
+
+    public RocksDBLockManager(RocksDBStoreEngine storeEngine) {
+        this.locker = new RocksDBLocker(storeEngine, new RocksDBLocalLocks());
+    }
+
+    @Override
+    public boolean releaseLock(BranchSession branchSession) throws TransactionException {
+        try {
+            return getLocker().releaseLock(branchSession.getXid(), branchSession.getBranchId());
+        } catch (Exception t) {
+            LOGGER.error("unLock error, xid {}, branchId:{}", branchSession.getXid(), branchSession.getBranchId(), t);
+            return false;
+        }
+    }
+
+    @Override
+    public boolean releaseGlobalSessionLock(GlobalSession globalSession) throws TransactionException {
+        try {
+            return getLocker().releaseLock(globalSession.getXid());
+        } catch (Exception t) {
+            LOGGER.error("unLock globalSession error, xid:{}", globalSession.getXid(), t);
+            return false;
+        }
+    }
+
+    public int cleanOrphanLocks() {
+        return locker.cleanOrphanLocks();
+    }
+
+    @Override
+    protected Locker getLocker(BranchSession branchSession) {
+        return locker;
+    }
+}
diff --git a/server/src/main/java/org/apache/seata/server/storage/rocksdb/lock/RocksDBLocker.java b/server/src/main/java/org/apache/seata/server/storage/rocksdb/lock/RocksDBLocker.java
new file mode 100644
index 00000000000..c65b6c4ae59
--- /dev/null
+++ b/server/src/main/java/org/apache/seata/server/storage/rocksdb/lock/RocksDBLocker.java
@@ -0,0 +1,416 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.seata.server.storage.rocksdb.lock;
+
+import org.apache.seata.common.exception.StoreException;
+import org.apache.seata.common.util.CollectionUtils;
+import org.apache.seata.common.util.StringUtils;
+import org.apache.seata.core.exception.BranchTransactionException;
+import org.apache.seata.core.lock.AbstractLocker;
+import org.apache.seata.core.lock.RowLock;
+import org.apache.seata.core.model.LockStatus;
+import org.apache.seata.core.store.LockDO;
+import org.apache.seata.server.storage.rocksdb.RocksDBColumnFamily;
+import org.apache.seata.server.storage.rocksdb.RocksDBKeyCodec;
+import org.apache.seata.server.storage.rocksdb.RocksDBLocalLocks;
+import org.apache.seata.server.storage.rocksdb.RocksDBStoreEngine;
+import org.apache.seata.server.storage.rocksdb.RocksDBValueCodec;
+import org.rocksdb.RocksDBException;
+import org.rocksdb.WriteBatch;
+
+import java.io.ByteArrayOutputStream;
+import java.nio.ByteBuffer;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+import static org.apache.seata.core.exception.TransactionExceptionCode.LockKeyConflictFailFast;
+
+/**
+ * RocksDB locker for file store engine.
+ */
+public class RocksDBLocker extends AbstractLocker {
+
+    private static final byte[] EMPTY_VALUE = new byte[0];
+
+    private final RocksDBStoreEngine storeEngine;
+    private final RocksDBLocalLocks localLocks;
+
+    public RocksDBLocker(RocksDBStoreEngine storeEngine, RocksDBLocalLocks localLocks) {
+        this.storeEngine = storeEngine;
+        this.localLocks = localLocks;
+    }
+
+    @Override
+    public boolean acquireLock(List<RowLock> locks) {
+        return acquireLock(locks, true, false);
+    }
+
+    @Override
+    public boolean acquireLock(List<RowLock> locks, boolean autoCommit, boolean skipCheckLock) {
+        if (CollectionUtils.isEmpty(locks)) {
+            return true;
+        }
+        List<LockDO> lockDOs = distinctByRowKey(convertToLockDO(locks));
+        try (RocksDBLocalLocks.LockScope ignored = localLocks.lockAll(toLockKeys(lockDOs))) {
+            List<LockDO> unrepeatedLockDOs = new ArrayList<>();
+            boolean failFast = false;
+
+            for (LockDO lockDO : lockDOs) {
+                LockDO existingLock = readLock(lockDO);
+                if (existingLock == null) {
+                    unrepeatedLockDOs.add(lockDO);
+                    continue;
+                }
+                if (StringUtils.equals(existingLock.getXid(), lockDO.getXid())) {
+                    continue;
+                }
+
+                LOGGER.info(
+                        "Global lock on [{}:{}] is holding by xid {} branchId {}",
+                        existingLock.getTableName(),
+                        existingLock.getPk(),
+                        existingLock.getXid(),
+                        existingLock.getBranchId());
+                if (!autoCommit && existingLock.getStatus() == LockStatus.Rollbacking.getCode()) {
+                    failFast = true;
+                }
+                if (failFast) {
+                    throw new StoreException(new BranchTransactionException(LockKeyConflictFailFast));
+                }
+                return false;
+            }
+
+            if (CollectionUtils.isEmpty(unrepeatedLockDOs)) {
+                return true;
+            }
+            writeLocks(unrepeatedLockDOs);
+            return true;
+        } catch (StoreException e) {
+            throw e;
+        } catch (Exception e) {
+            LOGGER.error("AcquireLock error, locks:{}", CollectionUtils.toString(locks), e);
+            return false;
+        }
+    }
+
+    @Override
+    public boolean releaseLock(List<RowLock> locks) {
+        if (CollectionUtils.isEmpty(locks)) {
+            return true;
+        }
+        List<LockDO> lockDOs = distinctByRowKey(convertToLockDO(locks));
+        try (RocksDBLocalLocks.LockScope ignored = localLocks.lockAll(toLockKeys(lockDOs));
+                WriteBatch batch = new WriteBatch()) {
+            for (LockDO lockDO : lockDOs) {
+                LockDO existingLock = readLock(lockDO);
+                if (existingLock == null
+                        || !StringUtils.equals(existingLock.getXid(), lockDO.getXid())
+                        || !Objects.equals(lockDO.getBranchId(), existingLock.getBranchId())) {
+                    continue;
+                }
+                byte[] lockKey = encodeLockKey(lockDO);
+                batch.delete(storeEngine.handle(RocksDBColumnFamily.LOCK), lockKey);
+                batch.delete(
+                        storeEngine.handle(RocksDBColumnFamily.LOCK_BRANCH_INDEX),
+                        RocksDBKeyCodec.encodeLockBranchIndex(lockDO.getXid(), lockDO.getBranchId(), lockKey));
+            }
+            storeEngine.write(batch);
+            return true;
+        } catch (StoreException e) {
+            throw e;
+        } catch (Exception e) {
+            LOGGER.error("unLock error, locks:{}", CollectionUtils.toString(locks), e);
+            return false;
+        }
+    }
+
+    @Override
+    public boolean releaseLock(String xid, Long branchId) {
+        if (StringUtils.isBlank(xid) || branchId == null) {
+            return true;
+        }
+        return releaseByIndex(RocksDBKeyCodec.encodeLockBranchIndexBranchPrefix(xid, branchId), xid, branchId);
+    }
+
+    @Override
+    public boolean releaseLock(String xid) {
+        if (StringUtils.isBlank(xid)) {
+            return true;
+        }
+        return releaseByIndex(RocksDBKeyCodec.encodeLockBranchIndexGlobalPrefix(xid), xid, null);
+    }
+
+    @Override
+    public boolean isLockable(List<RowLock> locks) {
+        if (CollectionUtils.isEmpty(locks)) {
+            return true;
+        }
+        List<LockDO> lockDOs = distinctByRowKey(convertToLockDO(locks));
+        try (RocksDBLocalLocks.LockScope ignored = localLocks.lockAll(toLockKeys(lockDOs))) {
+            for (LockDO lockDO : lockDOs) {
+                LockDO existingLock = readLock(lockDO);
+                if (existingLock != null && !StringUtils.equals(existingLock.getXid(), lockDO.getXid())) {
+                    return false;
+                }
+            }
+            return true;
+        } catch (Exception e) {
+            LOGGER.error("isLockable error, locks:{}", CollectionUtils.toString(locks), e);
+            return false;
+        }
+    }
+
+    @Override
+    public void updateLockStatus(String xid, LockStatus lockStatus) {
+        if (StringUtils.isBlank(xid)) {
+            return;
+        }
+        List<RocksDBStoreEngine.RocksDBEntry> indexEntries = storeEngine.prefixScan(
+                RocksDBColumnFamily.LOCK_BRANCH_INDEX, RocksDBKeyCodec.encodeLockBranchIndexGlobalPrefix(xid));
+        try (RocksDBLocalLocks.LockScope ignored = localLocks.lockAll(indexValues(indexEntries));
+                WriteBatch batch = new WriteBatch()) {
+            for (RocksDBStoreEngine.RocksDBEntry indexEntry : indexEntries) {
+                byte[] lockKey = indexEntry.getValue();
+                byte[] value = storeEngine.get(RocksDBColumnFamily.LOCK, lockKey);
+                if (value == null) {
+                    continue;
+                }
+                LockDO lockDO = decodeLock(value);
+                if (!StringUtils.equals(lockDO.getXid(), xid)) {
+                    continue;
+                }
+                lockDO.setStatus(lockStatus.getCode());
+                batch.put(storeEngine.handle(RocksDBColumnFamily.LOCK), lockKey, encodeLock(lockDO));
+            }
+            storeEngine.write(batch);
+        } catch (RocksDBException e) {
+            throw new StoreException(e, "update RocksDB lock status failed, xid:" + xid);
+        }
+    }
+
+    @Override
+    public void cleanAllLocks() {
+        try (WriteBatch batch = new WriteBatch()) {
+            deleteByPrefix(batch, RocksDBColumnFamily.LOCK, EMPTY_VALUE);
+            deleteByPrefix(batch, RocksDBColumnFamily.LOCK_BRANCH_INDEX, EMPTY_VALUE);
+            storeEngine.write(batch);
+        } catch (RocksDBException e) {
+            throw new StoreException(e, "clean RocksDB locks failed");
+        }
+    }
+
+    public int cleanOrphanLocks() {
+        List<RocksDBStoreEngine.RocksDBEntry> indexEntries =
+                storeEngine.prefixScan(RocksDBColumnFamily.LOCK_BRANCH_INDEX, EMPTY_VALUE);
+        if (CollectionUtils.isEmpty(indexEntries)) {
+            return 0;
+        }
+        int cleaned = 0;
+        try (RocksDBLocalLocks.LockScope ignored = localLocks.lockAll(indexValues(indexEntries));
+                WriteBatch batch = new WriteBatch()) {
+            for (RocksDBStoreEngine.RocksDBEntry indexEntry : indexEntries) {
+                byte[] lockKey = indexEntry.getValue();
+                byte[] lockValue = storeEngine.get(RocksDBColumnFamily.LOCK, lockKey);
+                if (lockValue == null) {
+                    batch.delete(storeEngine.handle(RocksDBColumnFamily.LOCK_BRANCH_INDEX), indexEntry.getKey());
+                    cleaned++;
+                    continue;
+                }
+
+                LockDO existingLock = decodeLock(lockValue);
+                byte[] expectedIndexKey = RocksDBKeyCodec.encodeLockBranchIndex(
+                        existingLock.getXid(), existingLock.getBranchId(), lockKey);
+                if (!Arrays.equals(expectedIndexKey, indexEntry.getKey())) {
+                    batch.delete(storeEngine.handle(RocksDBColumnFamily.LOCK_BRANCH_INDEX), indexEntry.getKey());
+                    cleaned++;
+                    continue;
+                }
+
+                if (storeEngine.get(
+                                RocksDBColumnFamily.BRANCH_SESSION,
+                                RocksDBKeyCodec.encodeBranch(existingLock.getXid(), existingLock.getBranchId()))
+                        == null) {
+                    batch.delete(storeEngine.handle(RocksDBColumnFamily.LOCK), lockKey);
+                    batch.delete(storeEngine.handle(RocksDBColumnFamily.LOCK_BRANCH_INDEX), indexEntry.getKey());
+                    cleaned++;
+                }
+            }
+            storeEngine.write(batch);
+            return cleaned;
+        } catch (RocksDBException e) {
+            throw new StoreException(e, "clean RocksDB orphan locks failed");
+        }
+    }
+
+    private void writeLocks(List<LockDO> lockDOs) {
+        try (WriteBatch batch = new WriteBatch()) {
+            for (LockDO lockDO : lockDOs) {
+                byte[] lockKey = encodeLockKey(lockDO);
+                batch.put(storeEngine.handle(RocksDBColumnFamily.LOCK), lockKey, encodeLock(lockDO));
+                batch.put(
+                        storeEngine.handle(RocksDBColumnFamily.LOCK_BRANCH_INDEX),
+                        RocksDBKeyCodec.encodeLockBranchIndex(lockDO.getXid(), lockDO.getBranchId(), lockKey),
+                        lockKey);
+            }
+            storeEngine.write(batch);
+        } catch (RocksDBException e) {
+            throw new StoreException(e, "write RocksDB locks failed");
+        }
+    }
+
+    private boolean releaseByIndex(byte[] indexPrefix, String xid, Long branchId) {
+        List<RocksDBStoreEngine.RocksDBEntry> indexEntries =
+                storeEngine.prefixScan(RocksDBColumnFamily.LOCK_BRANCH_INDEX, indexPrefix);
+        try (RocksDBLocalLocks.LockScope ignored = localLocks.lockAll(indexValues(indexEntries));
+                WriteBatch batch = new WriteBatch()) {
+            for (RocksDBStoreEngine.RocksDBEntry indexEntry : indexEntries) {
+                byte[] lockKey = indexEntry.getValue();
+                byte[] lockValue = storeEngine.get(RocksDBColumnFamily.LOCK, lockKey);
+                if (lockValue != null) {
+                    LockDO existingLock = decodeLock(lockValue);
+                    if (StringUtils.equals(existingLock.getXid(), xid)
+                            && (branchId == null || branchId.equals(existingLock.getBranchId()))) {
+                        batch.delete(storeEngine.handle(RocksDBColumnFamily.LOCK), lockKey);
+                    }
+                }
+                batch.delete(storeEngine.handle(RocksDBColumnFamily.LOCK_BRANCH_INDEX), indexEntry.getKey());
+            }
+            storeEngine.write(batch);
+            return true;
+        } catch (RocksDBException e) {
+            throw new StoreException(e, "release RocksDB locks failed");
+        }
+    }
+
+    private LockDO readLock(LockDO lockDO) {
+        byte[] value = storeEngine.get(RocksDBColumnFamily.LOCK, encodeLockKey(lockDO));
+        return value == null ? null : decodeLock(value);
+    }
+
+    private void deleteByPrefix(WriteBatch batch, RocksDBColumnFamily columnFamily, byte[] prefix)
+            throws RocksDBException {
+        for (RocksDBStoreEngine.RocksDBEntry entry : storeEngine.prefixScan(columnFamily, prefix)) {
+            batch.delete(storeEngine.handle(columnFamily), entry.getKey());
+        }
+    }
+
+    private List<LockDO> distinctByRowKey(List<LockDO> lockDOs) {
+        Map<String, LockDO> result = new LinkedHashMap<>();
+        for (LockDO lockDO : lockDOs) {
+            result.putIfAbsent(lockDO.getRowKey(), lockDO);
+        }
+        return new ArrayList<>(result.values());
+    }
+
+    private Collection<byte[]> toLockKeys(List<LockDO> lockDOs) {
+        return lockDOs.stream().map(this::encodeLockKey).collect(Collectors.toList());
+    }
+
+    private Collection<byte[]> indexValues(List<RocksDBStoreEngine.RocksDBEntry> entries) {
+        return entries.stream().map(RocksDBStoreEngine.RocksDBEntry::getValue).collect(Collectors.toList());
+    }
+
+    private byte[] encodeLockKey(LockDO lockDO) {
+        return RocksDBKeyCodec.encodeRowLock(lockDO.getResourceId(), lockDO.getTableName(), lockDO.getPk());
+    }
+
+    private byte[] encodeLock(LockDO lockDO) {
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        writeString(out, lockDO.getXid());
+        writeLong(out, lockDO.getTransactionId());
+        writeLong(out, lockDO.getBranchId());
+        writeString(out, lockDO.getResourceId());
+        writeString(out, lockDO.getTableName());
+        writeString(out, lockDO.getPk());
+        writeString(out, lockDO.getRowKey());
+        writeInt(out, lockDO.getStatus());
+        return RocksDBValueCodec.encode(RocksDBValueCodec.ValueType.LOCK_HOLDER, out.toByteArray());
+    }
+
+    private LockDO decodeLock(byte[] value) {
+        RocksDBValueCodec.DecodedValue decodedValue = RocksDBValueCodec.decode(value);
+        if (decodedValue.getType() != RocksDBValueCodec.ValueType.LOCK_HOLDER) {
+            throw new StoreException("unexpected RocksDB value type for lock holder:" + decodedValue.getType());
+        }
+        ByteBuffer buffer = ByteBuffer.wrap(decodedValue.getPayload());
+        LockDO lockDO = new LockDO();
+        lockDO.setXid(readString(buffer));
+        lockDO.setTransactionId(readLong(buffer));
+        lockDO.setBranchId(readLong(buffer));
+        lockDO.setResourceId(readString(buffer));
+        lockDO.setTableName(readString(buffer));
+        lockDO.setPk(readString(buffer));
+        lockDO.setRowKey(readString(buffer));
+        lockDO.setStatus(readInt(buffer));
+        return lockDO;
+    }
+
+    private void writeString(ByteArrayOutputStream out, String value) {
+        if (value == null) {
+            writeInt(out, -1);
+            return;
+        }
+        byte[] bytes = value.getBytes(StandardCharsets.UTF_8);
+        writeInt(out, bytes.length);
+        out.write(bytes, 0, bytes.length);
+    }
+
+    private String readString(ByteBuffer buffer) {
+        int length = buffer.getInt();
+        if (length < 0) {
+            return null;
+        }
+        byte[] bytes = new byte[length];
+        buffer.get(bytes);
+        return new String(bytes, StandardCharsets.UTF_8);
+    }
+
+    private void writeLong(ByteArrayOutputStream out, Long value) {
+        write(
+                out,
+                ByteBuffer.allocate(Long.BYTES)
+                        .putLong(value == null ? 0L : value)
+                        .array());
+    }
+
+    private long readLong(ByteBuffer buffer) {
+        return buffer.getLong();
+    }
+
+    private void writeInt(ByteArrayOutputStream out, Integer value) {
+        write(
+                out,
+                ByteBuffer.allocate(Integer.BYTES)
+                        .putInt(value == null ? 0 : value)
+                        .array());
+    }
+
+    private int readInt(ByteBuffer buffer) {
+        return buffer.getInt();
+    }
+
+    private void write(ByteArrayOutputStream out, byte[] bytes) {
+        out.write(bytes, 0, bytes.length);
+    }
+}
diff --git a/server/src/main/java/org/apache/seata/server/storage/rocksdb/migration/RocksDBMigrationService.java b/server/src/main/java/org/apache/seata/server/storage/rocksdb/migration/RocksDBMigrationService.java
new file mode 100644
index 00000000000..83c630b36c7
--- /dev/null
+++ b/server/src/main/java/org/apache/seata/server/storage/rocksdb/migration/RocksDBMigrationService.java
@@ -0,0 +1,298 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.seata.server.storage.rocksdb.migration;
+
+import org.apache.seata.common.exception.StoreException;
+import org.apache.seata.common.util.StringUtils;
+import org.apache.seata.core.model.GlobalStatus;
+import org.apache.seata.server.session.BranchSession;
+import org.apache.seata.server.session.GlobalSession;
+import org.apache.seata.server.storage.file.TransactionWriteStore;
+import org.apache.seata.server.storage.file.store.FileSessionLogReplayer;
+import org.apache.seata.server.storage.rocksdb.RocksDBColumnFamily;
+import org.apache.seata.server.storage.rocksdb.RocksDBStoreEngine;
+import org.apache.seata.server.storage.rocksdb.store.RocksDBTransactionStoreManager;
+import org.apache.seata.server.store.SessionStorable;
+import org.apache.seata.server.store.TransactionStoreManager.LogOperation;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Path;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Migrates legacy file-mode session logs to RocksDB current-state storage.
+ */
+public class RocksDBMigrationService {
+
+    public static final String MIGRATION_STATUS_KEY = "migration_status";
+    public static final String MIGRATION_STATUS_IN_PROGRESS = "in_progress";
+    public static final String MIGRATION_STATUS_COMPLETED = "completed";
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(RocksDBMigrationService.class);
+
+    private final FileSessionLogReplayer fileSessionLogReplayer;
+
+    public RocksDBMigrationService() {
+        this(new FileSessionLogReplayer());
+    }
+
+    public RocksDBMigrationService(FileSessionLogReplayer fileSessionLogReplayer) {
+        this.fileSessionLogReplayer = fileSessionLogReplayer;
+    }
+
+    public boolean migrate(Path fileSessionLogPath, RocksDBStoreEngine storeEngine) {
+        String migrationStatus = getMetadata(storeEngine, MIGRATION_STATUS_KEY);
+        if (MIGRATION_STATUS_COMPLETED.equals(migrationStatus)) {
+            return false;
+        }
+        if (StringUtils.isBlank(migrationStatus) && fileSessionLogReplayer.hasMigrationMarker(fileSessionLogPath)) {
+            throw new StoreException("file session logs were already migrated to RocksDB, but RocksDB migration "
+                    + "metadata is missing. Restore the RocksDB directory or remove the migration marker explicitly, "
+                    + "file:" + fileSessionLogPath);
+        }
+        if (StringUtils.isNotBlank(migrationStatus) && !MIGRATION_STATUS_IN_PROGRESS.equals(migrationStatus)) {
+            throw new StoreException("unknown RocksDB migration status:" + migrationStatus);
+        }
+
+        boolean hasFileLogs = fileSessionLogReplayer.hasSessionLogs(fileSessionLogPath);
+        if (MIGRATION_STATUS_IN_PROGRESS.equals(migrationStatus) && !hasFileLogs) {
+            throw new StoreException("RocksDB migration was interrupted but source file logs are missing");
+        }
+        if (StringUtils.isBlank(migrationStatus) && hasCurrentState(storeEngine)) {
+            throw new StoreException("RocksDB current state exists without migration status");
+        }
+        if (!hasFileLogs) {
+            putMetadata(storeEngine, MIGRATION_STATUS_KEY, MIGRATION_STATUS_COMPLETED);
+            return false;
+        }
+
+        putMetadata(storeEngine, MIGRATION_STATUS_KEY, MIGRATION_STATUS_IN_PROGRESS);
+        clearCurrentState(storeEngine);
+
+        MigrationState migrationState = new MigrationState();
+        int replayed =
+                fileSessionLogReplayer.replay(fileSessionLogPath, writeStore -> apply(writeStore, migrationState));
+        writeCurrentState(storeEngine, migrationState.globalSessions.values());
+        putMetadata(storeEngine, MIGRATION_STATUS_KEY, MIGRATION_STATUS_COMPLETED);
+        storeEngine.flush();
+        fileSessionLogReplayer.markMigrated(fileSessionLogPath);
+
+        LOGGER.info(
+                "Migrated file session logs to RocksDB, file:{}, records:{}, globalSessions:{}",
+                fileSessionLogPath,
+                replayed,
+                migrationState.globalSessions.size());
+        return true;
+    }
+
+    private void apply(TransactionWriteStore writeStore, MigrationState migrationState) {
+        LogOperation logOperation = writeStore.getOperate();
+        SessionStorable sessionStorable = writeStore.getSessionRequest();
+        switch (logOperation) {
+            case GLOBAL_ADD:
+            case GLOBAL_UPDATE:
+                applyGlobalUpdate((GlobalSession) sessionStorable, migrationState);
+                break;
+            case GLOBAL_REMOVE:
+                applyGlobalRemove((GlobalSession) sessionStorable, migrationState);
+                break;
+            case BRANCH_ADD:
+            case BRANCH_UPDATE:
+                applyBranchUpdate((BranchSession) sessionStorable, migrationState);
+                break;
+            case BRANCH_REMOVE:
+                applyBranchRemove((BranchSession) sessionStorable, migrationState);
+                break;
+            default:
+                throw new StoreException("Unknown LogOperation:" + logOperation);
+        }
+    }
+
+    private void applyGlobalUpdate(GlobalSession globalSession, MigrationState migrationState) {
+        if (!validTransactionId(globalSession.getTransactionId(), globalSession.getXid(), "globalSession")) {
+            return;
+        }
+        String xid = globalSession.getXid();
+        if (migrationState.removedGlobals.contains(xid)) {
+            return;
+        }
+        GlobalSession existing = migrationState.globalSessions.get(xid);
+        if (existing == null) {
+            if (shouldKeep(globalSession)) {
+                migrationState.globalSessions.put(xid, globalSession);
+                attachUnhandledBranches(globalSession, migrationState);
+            } else {
+                removeGlobalState(xid, migrationState);
+            }
+            return;
+        }
+        if (shouldKeep(globalSession)) {
+            existing.setStatus(globalSession.getStatus());
+        } else {
+            removeGlobalState(xid, migrationState);
+        }
+    }
+
+    private void applyGlobalRemove(GlobalSession globalSession, MigrationState migrationState) {
+        if (!validTransactionId(globalSession.getTransactionId(), globalSession.getXid(), "globalSession")) {
+            return;
+        }
+        removeGlobalState(globalSession.getXid(), migrationState);
+    }
+
+    private void applyBranchUpdate(BranchSession branchSession, MigrationState migrationState) {
+        if (!validTransactionId(branchSession.getTransactionId(), branchSession.getXid(), "branchSession")) {
+            return;
+        }
+        String xid = branchSession.getXid();
+        if (migrationState.removedGlobals.contains(xid)) {
+            return;
+        }
+        GlobalSession globalSession = migrationState.globalSessions.get(xid);
+        if (globalSession == null) {
+            migrationState
+                    .unhandledBranches
+                    .computeIfAbsent(xid, key -> new HashMap<>())
+                    .put(branchSession.getBranchId(), branchSession);
+            return;
+        }
+        addOrUpdateBranch(globalSession, branchSession);
+    }
+
+    private void applyBranchRemove(BranchSession branchSession, MigrationState migrationState) {
+        if (!validTransactionId(branchSession.getTransactionId(), branchSession.getXid(), "branchSession")) {
+            return;
+        }
+        String xid = branchSession.getXid();
+        if (migrationState.removedGlobals.contains(xid)) {
+            return;
+        }
+        Map<Long, BranchSession> bufferedBranches = migrationState.unhandledBranches.get(xid);
+        if (bufferedBranches != null) {
+            bufferedBranches.remove(branchSession.getBranchId());
+        }
+        GlobalSession globalSession = migrationState.globalSessions.get(xid);
+        if (globalSession == null) {
+            return;
+        }
+        BranchSession existing = globalSession.getBranch(branchSession.getBranchId());
+        if (existing != null) {
+            globalSession.remove(existing);
+        }
+    }
+
+    private void attachUnhandledBranches(GlobalSession globalSession, MigrationState migrationState) {
+        Map<Long, BranchSession> branches = migrationState.unhandledBranches.remove(globalSession.getXid());
+        if (branches == null) {
+            return;
+        }
+        branches.values().forEach(branchSession -> addOrUpdateBranch(globalSession, branchSession));
+    }
+
+    private void addOrUpdateBranch(GlobalSession globalSession, BranchSession branchSession) {
+        BranchSession existing = globalSession.getBranch(branchSession.getBranchId());
+        if (existing == null) {
+            globalSession.add(branchSession);
+        } else {
+            existing.setStatus(branchSession.getStatus());
+        }
+    }
+
+    private void removeGlobalState(String xid, MigrationState migrationState) {
+        migrationState.globalSessions.remove(xid);
+        migrationState.unhandledBranches.remove(xid);
+        migrationState.removedGlobals.add(xid);
+    }
+
+    private boolean shouldKeep(GlobalSession globalSession) {
+        GlobalStatus globalStatus = globalSession.getStatus();
+        switch (globalStatus) {
+            case UnKnown:
+            case Committed:
+            case CommitFailed:
+            case Rollbacked:
+            case RollbackFailed:
+            case TimeoutRollbacked:
+            case TimeoutRollbackFailed:
+            case RollbackRetryTimeout:
+            case Finished:
+                return false;
+            default:
+                return true;
+        }
+    }
+
+    private boolean validTransactionId(long transactionId, String xid, String type) {
+        if (transactionId != 0) {
+            return true;
+        }
+        LOGGER.error("Migrate {} from file failed, the transactionId is zero, xid:{}", type, xid);
+        return false;
+    }
+
+    private void writeCurrentState(RocksDBStoreEngine storeEngine, Collection<GlobalSession> globalSessions) {
+        RocksDBTransactionStoreManager storeManager = new RocksDBTransactionStoreManager(storeEngine);
+        for (GlobalSession globalSession : globalSessions) {
+            storeManager.writeSession(LogOperation.GLOBAL_ADD, globalSession);
+            globalSession
+                    .getSortedBranches()
+                    .forEach(branchSession -> storeManager.writeSession(LogOperation.BRANCH_ADD, branchSession));
+        }
+    }
+
+    private boolean hasCurrentState(RocksDBStoreEngine storeEngine) {
+        return storeEngine.prefixExists(RocksDBColumnFamily.GLOBAL_SESSION, new byte[0])
+                || storeEngine.prefixExists(RocksDBColumnFamily.BRANCH_SESSION, new byte[0])
+                || storeEngine.prefixExists(RocksDBColumnFamily.LOCK, new byte[0])
+                || storeEngine.prefixExists(RocksDBColumnFamily.LOCK_BRANCH_INDEX, new byte[0])
+                || storeEngine.prefixExists(RocksDBColumnFamily.GLOBAL_STATUS_INDEX, new byte[0])
+                || storeEngine.prefixExists(RocksDBColumnFamily.TRANSACTION_ID_INDEX, new byte[0]);
+    }
+
+    private void clearCurrentState(RocksDBStoreEngine storeEngine) {
+        storeEngine.deleteByPrefix(RocksDBColumnFamily.GLOBAL_SESSION, new byte[0]);
+        storeEngine.deleteByPrefix(RocksDBColumnFamily.BRANCH_SESSION, new byte[0]);
+        storeEngine.deleteByPrefix(RocksDBColumnFamily.LOCK, new byte[0]);
+        storeEngine.deleteByPrefix(RocksDBColumnFamily.LOCK_BRANCH_INDEX, new byte[0]);
+        storeEngine.deleteByPrefix(RocksDBColumnFamily.GLOBAL_STATUS_INDEX, new byte[0]);
+        storeEngine.deleteByPrefix(RocksDBColumnFamily.TRANSACTION_ID_INDEX, new byte[0]);
+    }
+
+    private String getMetadata(RocksDBStoreEngine storeEngine, String key) {
+        byte[] value = storeEngine.get(RocksDBColumnFamily.METADATA, key.getBytes(StandardCharsets.UTF_8));
+        return value == null ? null : new String(value, StandardCharsets.UTF_8);
+    }
+
+    private void putMetadata(RocksDBStoreEngine storeEngine, String key, String value) {
+        storeEngine.put(
+                RocksDBColumnFamily.METADATA,
+                key.getBytes(StandardCharsets.UTF_8),
+                value.getBytes(StandardCharsets.UTF_8));
+    }
+
+    private static class MigrationState {
+        private final Map<String, GlobalSession> globalSessions = new HashMap<>();
+        private final Map<String, Map<Long, BranchSession>> unhandledBranches = new HashMap<>();
+        private final Set<String> removedGlobals = new HashSet<>();
+    }
+}
diff --git a/server/src/main/java/org/apache/seata/server/storage/rocksdb/session/RocksDBSessionManager.java b/server/src/main/java/org/apache/seata/server/storage/rocksdb/session/RocksDBSessionManager.java
new file mode 100644
index 00000000000..f2486628f9e
--- /dev/null
+++ b/server/src/main/java/org/apache/seata/server/storage/rocksdb/session/RocksDBSessionManager.java
@@ -0,0 +1,120 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.seata.server.storage.rocksdb.session;
+
+import org.apache.seata.common.loader.LoadLevel;
+import org.apache.seata.common.loader.Scope;
+import org.apache.seata.core.exception.TransactionException;
+import org.apache.seata.core.model.GlobalStatus;
+import org.apache.seata.server.lock.LockerManagerFactory;
+import org.apache.seata.server.session.AbstractSessionManager;
+import org.apache.seata.server.session.GlobalSession;
+import org.apache.seata.server.session.SessionCondition;
+import org.apache.seata.server.storage.rocksdb.RocksDBKeyCodec;
+import org.apache.seata.server.storage.rocksdb.RocksDBLocalLocks;
+import org.apache.seata.server.storage.rocksdb.RocksDBStoreEngine;
+import org.apache.seata.server.storage.rocksdb.store.RocksDBTransactionStoreManager;
+
+import java.util.Collection;
+import java.util.List;
+
+/**
+ * RocksDB-backed session manager for file store engine.
+ */
+@LoadLevel(name = "rocksdb", scope = Scope.PROTOTYPE)
+public class RocksDBSessionManager extends AbstractSessionManager {
+
+    private final RocksDBLocalLocks xidLocks;
+
+    public RocksDBSessionManager() {
+        this(null);
+    }
+
+    public RocksDBSessionManager(String name) {
+        super(name);
+        this.xidLocks = new RocksDBLocalLocks();
+        this.transactionStoreManager = new RocksDBTransactionStoreManager(xidLocks);
+    }
+
+    public RocksDBSessionManager(String name, RocksDBStoreEngine storeEngine) {
+        super(name);
+        this.xidLocks = new RocksDBLocalLocks();
+        this.transactionStoreManager = new RocksDBTransactionStoreManager(storeEngine, xidLocks);
+    }
+
+    @Override
+    public GlobalSession findGlobalSession(String xid) {
+        return findGlobalSession(xid, true);
+    }
+
+    @Override
+    public GlobalSession findGlobalSession(String xid, boolean withBranchSessions) {
+        return transactionStoreManager.readSession(xid, withBranchSessions);
+    }
+
+    @Override
+    public void removeGlobalSession(GlobalSession session) throws TransactionException {
+        if (!LockerManagerFactory.getLockManager().releaseGlobalSessionLock(session)) {
+            throw new TransactionException("Release RocksDB global session lock failed, xid = " + session.getXid());
+        }
+        super.removeGlobalSession(session);
+    }
+
+    @Override
+    public Collection<GlobalSession> allSessions() {
+        return findGlobalSessions(new SessionCondition(
+                GlobalStatus.UnKnown,
+                GlobalStatus.Begin,
+                GlobalStatus.Committing,
+                GlobalStatus.CommitRetrying,
+                GlobalStatus.Rollbacking,
+                GlobalStatus.RollbackRetrying,
+                GlobalStatus.TimeoutRollbacking,
+                GlobalStatus.TimeoutRollbackRetrying,
+                GlobalStatus.AsyncCommitting,
+                GlobalStatus.Committed,
+                GlobalStatus.CommitFailed,
+                GlobalStatus.CommitRetryTimeout,
+                GlobalStatus.Rollbacked,
+                GlobalStatus.RollbackFailed,
+                GlobalStatus.RollbackRetryTimeout,
+                GlobalStatus.TimeoutRollbacked,
+                GlobalStatus.TimeoutRollbackFailed,
+                GlobalStatus.Finished,
+                GlobalStatus.StopRollbackOrRollbackRetry,
+                GlobalStatus.StopCommitOrCommitRetry,
+                GlobalStatus.Deleting));
+    }
+
+    @Override
+    public List<GlobalSession> findGlobalSessions(SessionCondition condition) {
+        return transactionStoreManager.readSession(condition);
+    }
+
+    @Override
+    public <T> T lockAndExecute(GlobalSession globalSession, GlobalSession.LockCallable<T> lockCallable)
+            throws TransactionException {
+        try (RocksDBLocalLocks.LockScope ignored = xidLocks.lock(RocksDBKeyCodec.encodeXid(globalSession.getXid()))) {
+            return lockCallable.call();
+        }
+    }
+
+    @Override
+    public void destroy() {
+        transactionStoreManager.shutdown();
+    }
+}
diff --git a/server/src/main/java/org/apache/seata/server/storage/rocksdb/store/RocksDBTransactionStoreManager.java b/server/src/main/java/org/apache/seata/server/storage/rocksdb/store/RocksDBTransactionStoreManager.java
new file mode 100644
index 00000000000..36e3e38a49f
--- /dev/null
+++ b/server/src/main/java/org/apache/seata/server/storage/rocksdb/store/RocksDBTransactionStoreManager.java
@@ -0,0 +1,339 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.seata.server.storage.rocksdb.store;
+
+import org.apache.seata.common.exception.StoreException;
+import org.apache.seata.common.util.CollectionUtils;
+import org.apache.seata.common.util.StringUtils;
+import org.apache.seata.core.model.GlobalStatus;
+import org.apache.seata.server.session.BranchSession;
+import org.apache.seata.server.session.GlobalSession;
+import org.apache.seata.server.session.SessionCondition;
+import org.apache.seata.server.storage.rocksdb.RocksDBColumnFamily;
+import org.apache.seata.server.storage.rocksdb.RocksDBKeyCodec;
+import org.apache.seata.server.storage.rocksdb.RocksDBLocalLocks;
+import org.apache.seata.server.storage.rocksdb.RocksDBStoreEngine;
+import org.apache.seata.server.storage.rocksdb.RocksDBStoreEngineFactory;
+import org.apache.seata.server.storage.rocksdb.RocksDBValueCodec;
+import org.apache.seata.server.storage.rocksdb.index.RocksDBIndexManager;
+import org.apache.seata.server.store.AbstractTransactionStoreManager;
+import org.apache.seata.server.store.SessionStorable;
+import org.apache.seata.server.store.TransactionStoreManager;
+import org.rocksdb.RocksDBException;
+import org.rocksdb.WriteBatch;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * RocksDB transaction store manager for file store engine.
+ */
+public class RocksDBTransactionStoreManager extends AbstractTransactionStoreManager implements TransactionStoreManager {
+
+    private final RocksDBStoreEngine storeEngine;
+    private final RocksDBLocalLocks xidLocks;
+    private final RocksDBIndexManager indexManager;
+    private final boolean factoryManaged;
+
+    public RocksDBTransactionStoreManager() {
+        this(RocksDBStoreEngineFactory.getInstance(), new RocksDBLocalLocks(), true);
+    }
+
+    public RocksDBTransactionStoreManager(RocksDBLocalLocks xidLocks) {
+        this(RocksDBStoreEngineFactory.getInstance(), xidLocks, true);
+    }
+
+    public RocksDBTransactionStoreManager(RocksDBStoreEngine storeEngine) {
+        this(storeEngine, new RocksDBLocalLocks(), false);
+    }
+
+    public RocksDBTransactionStoreManager(RocksDBStoreEngine storeEngine, RocksDBLocalLocks xidLocks) {
+        this(storeEngine, xidLocks, false);
+    }
+
+    private RocksDBTransactionStoreManager(
+            RocksDBStoreEngine storeEngine, RocksDBLocalLocks xidLocks, boolean factoryManaged) {
+        this.storeEngine = storeEngine;
+        this.xidLocks = xidLocks;
+        this.indexManager = new RocksDBIndexManager(storeEngine);
+        this.indexManager.ensureReady();
+        this.factoryManaged = factoryManaged;
+    }
+
+    @Override
+    public boolean writeSession(LogOperation logOperation, SessionStorable session) {
+        if (session == null) {
+            return true;
+        }
+        String xid = getXid(session);
+        try (RocksDBLocalLocks.LockScope ignored = xidLocks.lock(RocksDBKeyCodec.encodeXid(xid))) {
+            switch (logOperation) {
+                case GLOBAL_ADD:
+                case GLOBAL_UPDATE:
+                    writeGlobalSession((GlobalSession) session);
+                    return true;
+                case GLOBAL_REMOVE:
+                    removeGlobalSession((GlobalSession) session);
+                    return true;
+                case BRANCH_ADD:
+                case BRANCH_UPDATE:
+                    writeBranchSession((BranchSession) session);
+                    return true;
+                case BRANCH_REMOVE:
+                    removeBranchSession((BranchSession) session);
+                    return true;
+                default:
+                    throw new StoreException("Unknown LogOperation:" + logOperation.name());
+            }
+        } catch (RuntimeException e) {
+            throw e;
+        } catch (Exception e) {
+            throw new StoreException(e, "write RocksDB session failed, logOperation:" + logOperation.name());
+        }
+    }
+
+    @Override
+    public GlobalSession readSession(String xid) {
+        return readSession(xid, true);
+    }
+
+    @Override
+    public GlobalSession readSession(String xid, boolean withBranchSessions) {
+        byte[] value = storeEngine.get(RocksDBColumnFamily.GLOBAL_SESSION, RocksDBKeyCodec.encodeXid(xid));
+        if (value == null) {
+            return null;
+        }
+        GlobalSession globalSession = decodeGlobalSession(value, !withBranchSessions);
+        if (withBranchSessions) {
+            readBranchSessions(xid).forEach(globalSession::add);
+        }
+        return globalSession;
+    }
+
+    @Override
+    public List<GlobalSession> readSortByTimeoutBeginSessions(boolean withBranchSessions) {
+        return readSession(new GlobalStatus[] {GlobalStatus.Begin}, withBranchSessions);
+    }
+
+    @Override
+    public List<GlobalSession> readSession(GlobalStatus[] statuses, boolean withBranchSessions) {
+        if (statuses == null || statuses.length == 0) {
+            return Collections.emptyList();
+        }
+        SessionCondition sessionCondition = new SessionCondition(statuses);
+        sessionCondition.setLazyLoadBranch(!withBranchSessions);
+        return readByStatuses(sessionCondition);
+    }
+
+    @Override
+    public List<GlobalSession> readSession(SessionCondition sessionCondition) {
+        if (sessionCondition == null) {
+            return Collections.emptyList();
+        }
+        if (StringUtils.isNotBlank(sessionCondition.getXid())) {
+            GlobalSession globalSession = readSession(sessionCondition.getXid(), !sessionCondition.isLazyLoadBranch());
+            if (globalSession == null || !matches(globalSession, sessionCondition)) {
+                return Collections.emptyList();
+            }
+            return Collections.singletonList(globalSession);
+        }
+        if (sessionCondition.getTransactionId() != null && sessionCondition.getTransactionId() > 0) {
+            return readByTransactionId(sessionCondition);
+        }
+        if (CollectionUtils.isNotEmpty(sessionCondition.getStatuses())) {
+            return readByStatuses(sessionCondition);
+        }
+        return scanGlobalSessions(sessionCondition);
+    }
+
+    @Override
+    public void shutdown() {
+        if (factoryManaged) {
+            RocksDBStoreEngineFactory.destroy();
+        } else {
+            storeEngine.close();
+        }
+    }
+
+    private void writeGlobalSession(GlobalSession session) {
+        byte[] key = RocksDBKeyCodec.encodeXid(session.getXid());
+        try (WriteBatch batch = new WriteBatch()) {
+            byte[] oldValue = storeEngine.get(RocksDBColumnFamily.GLOBAL_SESSION, key);
+            if (oldValue != null) {
+                indexManager.deleteGlobalIndexes(batch, decodeGlobalSession(oldValue, true));
+            }
+            batch.put(storeEngine.handle(RocksDBColumnFamily.GLOBAL_SESSION), key, encodeGlobalSession(session));
+            indexManager.putGlobalIndexes(batch, session);
+            storeEngine.write(batch);
+        } catch (RocksDBException e) {
+            throw new StoreException(e, "write RocksDB global session failed, xid:" + session.getXid());
+        }
+    }
+
+    private void removeGlobalSession(GlobalSession session) {
+        try (WriteBatch batch = new WriteBatch()) {
+            byte[] oldValue =
+                    storeEngine.get(RocksDBColumnFamily.GLOBAL_SESSION, RocksDBKeyCodec.encodeXid(session.getXid()));
+            if (oldValue != null) {
+                indexManager.deleteGlobalIndexes(batch, decodeGlobalSession(oldValue, true));
+            }
+            batch.delete(
+                    storeEngine.handle(RocksDBColumnFamily.GLOBAL_SESSION),
+                    RocksDBKeyCodec.encodeXid(session.getXid()));
+            for (RocksDBStoreEngine.RocksDBEntry entry : storeEngine.prefixScan(
+                    RocksDBColumnFamily.BRANCH_SESSION, RocksDBKeyCodec.encodeXidPrefix(session.getXid()))) {
+                batch.delete(storeEngine.handle(RocksDBColumnFamily.BRANCH_SESSION), entry.getKey());
+            }
+            storeEngine.write(batch);
+        } catch (RocksDBException e) {
+            throw new StoreException(e, "remove RocksDB global session failed, xid:" + session.getXid());
+        }
+    }
+
+    private void writeBranchSession(BranchSession session) {
+        storeEngine.put(
+                RocksDBColumnFamily.BRANCH_SESSION,
+                RocksDBKeyCodec.encodeBranch(session.getXid(), session.getBranchId()),
+                encodeBranchSession(session));
+    }
+
+    private void removeBranchSession(BranchSession session) {
+        storeEngine.delete(
+                RocksDBColumnFamily.BRANCH_SESSION,
+                RocksDBKeyCodec.encodeBranch(session.getXid(), session.getBranchId()));
+    }
+
+    private List<BranchSession> readBranchSessions(String xid) {
+        List<BranchSession> branches = new ArrayList<>();
+        for (RocksDBStoreEngine.RocksDBEntry entry :
+                storeEngine.prefixScan(RocksDBColumnFamily.BRANCH_SESSION, RocksDBKeyCodec.encodeXidPrefix(xid))) {
+            branches.add(decodeBranchSession(entry.getValue()));
+        }
+        return branches;
+    }
+
+    private List<GlobalSession> scanGlobalSessions(SessionCondition sessionCondition) {
+        List<GlobalSession> result = new ArrayList<>();
+        storeEngine.scanByPrefix(RocksDBColumnFamily.GLOBAL_SESSION, new byte[0], (key, value) -> {
+            GlobalSession globalSession = decodeGlobalSession(value, sessionCondition.isLazyLoadBranch());
+            if (matches(globalSession, sessionCondition)) {
+                if (!sessionCondition.isLazyLoadBranch()) {
+                    readBranchSessions(globalSession.getXid()).forEach(globalSession::add);
+                }
+                result.add(globalSession);
+            }
+        });
+        return result;
+    }
+
+    private List<GlobalSession> readByTransactionId(SessionCondition sessionCondition) {
+        String xid = indexManager.findXidByTransactionId(sessionCondition.getTransactionId());
+        if (StringUtils.isBlank(xid)) {
+            return Collections.emptyList();
+        }
+        GlobalSession globalSession = readSession(xid, !sessionCondition.isLazyLoadBranch());
+        if (globalSession == null || !matches(globalSession, sessionCondition)) {
+            return Collections.emptyList();
+        }
+        return Collections.singletonList(globalSession);
+    }
+
+    private List<GlobalSession> readByStatuses(SessionCondition sessionCondition) {
+        Set<String> seenXids = new LinkedHashSet<>();
+        List<GlobalSession> result = new ArrayList<>();
+        for (GlobalStatus status : sessionCondition.getStatuses()) {
+            indexManager.scanXidsByStatus(status, xid -> {
+                if (!seenXids.add(xid)) {
+                    return;
+                }
+                GlobalSession globalSession = readSession(xid, !sessionCondition.isLazyLoadBranch());
+                if (globalSession != null && matches(globalSession, sessionCondition)) {
+                    result.add(globalSession);
+                }
+            });
+        }
+        return result;
+    }
+
+    private boolean matches(GlobalSession globalSession, SessionCondition sessionCondition) {
+        if (sessionCondition.getOverTimeAliveMills() != null
+                && sessionCondition.getOverTimeAliveMills() > 0
+                && System.currentTimeMillis() - globalSession.getBeginTime()
+                        <= sessionCondition.getOverTimeAliveMills()) {
+            return false;
+        }
+        if (sessionCondition.getTransactionId() != null
+                && sessionCondition.getTransactionId() > 0
+                && !sessionCondition.getTransactionId().equals(globalSession.getTransactionId())) {
+            return false;
+        }
+        if (CollectionUtils.isNotEmpty(sessionCondition.getStatuses())) {
+            for (GlobalStatus status : sessionCondition.getStatuses()) {
+                if (status == globalSession.getStatus()) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        if (sessionCondition.getStatus() != null) {
+            return sessionCondition.getStatus() == globalSession.getStatus();
+        }
+        return true;
+    }
+
+    private byte[] encodeGlobalSession(GlobalSession session) {
+        return RocksDBValueCodec.encode(RocksDBValueCodec.ValueType.GLOBAL_SESSION, session.encode());
+    }
+
+    private byte[] encodeBranchSession(BranchSession session) {
+        return RocksDBValueCodec.encode(RocksDBValueCodec.ValueType.BRANCH_SESSION, session.encode());
+    }
+
+    private GlobalSession decodeGlobalSession(byte[] value, boolean lazyLoadBranch) {
+        RocksDBValueCodec.DecodedValue decodedValue = RocksDBValueCodec.decode(value);
+        if (decodedValue.getType() != RocksDBValueCodec.ValueType.GLOBAL_SESSION) {
+            throw new StoreException("unexpected RocksDB value type for global session:" + decodedValue.getType());
+        }
+        GlobalSession globalSession = new GlobalSession(null, null, null, 0, lazyLoadBranch);
+        globalSession.decode(decodedValue.getPayload());
+        return globalSession;
+    }
+
+    private BranchSession decodeBranchSession(byte[] value) {
+        RocksDBValueCodec.DecodedValue decodedValue = RocksDBValueCodec.decode(value);
+        if (decodedValue.getType() != RocksDBValueCodec.ValueType.BRANCH_SESSION) {
+            throw new StoreException("unexpected RocksDB value type for branch session:" + decodedValue.getType());
+        }
+        BranchSession branchSession = new BranchSession();
+        branchSession.decode(decodedValue.getPayload());
+        return branchSession;
+    }
+
+    private String getXid(SessionStorable session) {
+        if (session instanceof GlobalSession) {
+            return ((GlobalSession) session).getXid();
+        }
+        if (session instanceof BranchSession) {
+            return ((BranchSession) session).getXid();
+        }
+        throw new StoreException(
+                "unsupported session type:" + session.getClass().getName());
+    }
+}
diff --git a/server/src/main/java/org/apache/seata/server/store/FileStoreEngine.java b/server/src/main/java/org/apache/seata/server/store/FileStoreEngine.java
new file mode 100644
index 00000000000..b978c8fad2f
--- /dev/null
+++ b/server/src/main/java/org/apache/seata/server/store/FileStoreEngine.java
@@ -0,0 +1,50 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.seata.server.store;
+
+/**
+ * The file store engine inside file mode.
+ */
+public enum FileStoreEngine {
+    /**
+     * The default file log engine.
+     */
+    FILE("file"),
+    /**
+     * The RocksDB engine.
+     */
+    ROCKSDB("rocksdb");
+
+    private final String name;
+
+    FileStoreEngine(String name) {
+        this.name = name;
+    }
+
+    public static FileStoreEngine get(String name) {
+        for (FileStoreEngine engine : FileStoreEngine.values()) {
+            if (engine.getName().equalsIgnoreCase(name)) {
+                return engine;
+            }
+        }
+        throw new IllegalArgumentException("unknown file store engine:" + name);
+    }
+
+    public String getName() {
+        return name;
+    }
+}
diff --git a/server/src/main/java/org/apache/seata/server/store/StoreConfig.java b/server/src/main/java/org/apache/seata/server/store/StoreConfig.java
index 89f1e3f3fea..2068bb944f2 100644
--- a/server/src/main/java/org/apache/seata/server/store/StoreConfig.java
+++ b/server/src/main/java/org/apache/seata/server/store/StoreConfig.java
@@ -16,18 +16,19 @@
  */
 package org.apache.seata.server.store;
 
+import org.apache.seata.common.ConfigurationKeys;
+import org.apache.seata.common.exception.StoreException;
 import org.apache.seata.common.store.LockMode;
 import org.apache.seata.common.store.SessionMode;
 import org.apache.seata.common.store.StoreMode;
 import org.apache.seata.common.util.StringUtils;
 import org.apache.seata.config.Configuration;
 import org.apache.seata.config.ConfigurationFactory;
-import org.apache.seata.core.constants.ConfigurationKeys;
 import org.apache.seata.server.env.ContainerHelper;
 import org.apache.seata.server.storage.file.FlushDiskMode;
 
+import static org.apache.seata.common.ConfigurationKeys.STORE_FILE_PREFIX;
 import static org.apache.seata.common.DefaultValues.SERVER_DEFAULT_STORE_MODE;
-import static org.apache.seata.core.constants.ConfigurationKeys.STORE_FILE_PREFIX;
 
 /**
  */
@@ -88,6 +89,17 @@ public static FlushDiskMode getFlushDiskMode() {
         return FlushDiskMode.findDiskMode(CONFIGURATION.getConfig(STORE_FILE_PREFIX + "flushDiskMode"));
     }
 
+    public static FileStoreEngine getFileEngine() {
+        String fileEngine =
+                CONFIGURATION.getConfig(ConfigurationKeys.STORE_FILE_ENGINE, FileStoreEngine.FILE.getName());
+        try {
+            return FileStoreEngine.get(fileEngine);
+        } catch (IllegalArgumentException e) {
+            throw new StoreException(
+                    "unknown file store engine:" + fileEngine + ", config:" + ConfigurationKeys.STORE_FILE_ENGINE);
+        }
+    }
+
     /**
      * only for inner call
      *
@@ -128,6 +140,34 @@ public static SessionMode getSessionMode() {
     }
 
     public static LockMode getLockMode() {
+        LockMode configuredLockMode = getConfiguredLockMode();
+        if (configuredLockMode != null) {
+            return configuredLockMode;
+        }
+        // complication old config
+        return LockMode.get(getStoreMode().name());
+    }
+
+    public static LockMode getEffectiveLockMode() {
+        LockMode configuredLockMode = getConfiguredLockMode();
+        if (StoreMode.FILE == getStoreMode() && FileStoreEngine.ROCKSDB == getFileEngine()) {
+            if (configuredLockMode != null && configuredLockMode != LockMode.ROCKSDB) {
+                throw new StoreException("RocksDB file engine requires rocksdb lock mode, but configured lock mode is "
+                        + configuredLockMode.getName());
+            }
+            return LockMode.ROCKSDB;
+        }
+        if (configuredLockMode == LockMode.ROCKSDB) {
+            throw new StoreException("RocksDB lock mode requires store.mode=file and store.file.engine=rocksdb");
+        }
+        if (configuredLockMode != null) {
+            return configuredLockMode;
+        }
+        // complication old config
+        return LockMode.get(getStoreMode().name());
+    }
+
+    private static LockMode getConfiguredLockMode() {
         // startup
         if (null != lockMode) {
             return lockMode;
@@ -142,7 +182,6 @@ public static LockMode getLockMode() {
         if (StringUtils.isNotBlank(lockModeConfig)) {
             return LockMode.get(lockModeConfig);
         }
-        // complication old config
-        return LockMode.get(getStoreMode().name());
+        return null;
     }
 }
diff --git a/server/src/main/resources/META-INF/services/org.apache.seata.server.lock.LockManager b/server/src/main/resources/META-INF/services/org.apache.seata.server.lock.LockManager
index c6f6f41e14a..a4ee2594e8b 100644
--- a/server/src/main/resources/META-INF/services/org.apache.seata.server.lock.LockManager
+++ b/server/src/main/resources/META-INF/services/org.apache.seata.server.lock.LockManager
@@ -17,4 +17,5 @@
 org.apache.seata.server.storage.db.lock.DataBaseLockManager
 org.apache.seata.server.storage.file.lock.FileLockManager
 org.apache.seata.server.storage.redis.lock.RedisLockManager
-org.apache.seata.server.storage.raft.lock.RaftLockManager
\ No newline at end of file
+org.apache.seata.server.storage.raft.lock.RaftLockManager
+org.apache.seata.server.storage.rocksdb.lock.RocksDBLockManager
diff --git a/server/src/main/resources/META-INF/services/org.apache.seata.server.session.SessionManager b/server/src/main/resources/META-INF/services/org.apache.seata.server.session.SessionManager
index 2f68b517b06..8d46b1b4d46 100644
--- a/server/src/main/resources/META-INF/services/org.apache.seata.server.session.SessionManager
+++ b/server/src/main/resources/META-INF/services/org.apache.seata.server.session.SessionManager
@@ -15,6 +15,7 @@
 # limitations under the License.
 #
 org.apache.seata.server.storage.file.session.FileSessionManager
+org.apache.seata.server.storage.rocksdb.session.RocksDBSessionManager
 org.apache.seata.server.storage.db.session.DataBaseSessionManager
 org.apache.seata.server.storage.redis.session.RedisSessionManager
-org.apache.seata.server.storage.raft.session.RaftSessionManager
\ No newline at end of file
+org.apache.seata.server.storage.raft.session.RaftSessionManager
diff --git a/server/src/main/resources/application.example.yml b/server/src/main/resources/application.example.yml
index eff0d0bbbe8..cf7a0201b13 100644
--- a/server/src/main/resources/application.example.yml
+++ b/server/src/main/resources/application.example.yml
@@ -189,12 +189,17 @@ seata:
     lock:
       mode: file
     file:
+      # support: file, rocksdb
+      engine: file
       dir: sessionStore
       max-branch-session-size: 16384
       max-global-session-size: 512
       file-write-buffer-cache-size: 16384
       session-reload-read-size: 100
       flush-disk-mode: async
+      rocksdb:
+        # Phase1 only reserves the config key; RocksDB engine becomes available in Phase2.
+        dir: sessionStore/rocksdb
     db:
       datasource: druid
       db-type: mysql
diff --git a/server/src/main/resources/application.yml b/server/src/main/resources/application.yml
index e7d7c3c2bc4..5f1a2741844 100644
--- a/server/src/main/resources/application.yml
+++ b/server/src/main/resources/application.yml
@@ -53,5 +53,8 @@ seata:
   store:
     # support: file 、 db 、 redis 、 raft
     mode: file
+    file:
+      # support: file, rocksdb
+      engine: file
   #  server:
   #    service-port: 8091 #If not configured, the default is '${server.port} + 1000'
diff --git a/server/src/test/java/org/apache/seata/server/console/impl/db/GlobalSessionDBServiceImplTest.java b/server/src/test/java/org/apache/seata/server/console/impl/db/GlobalSessionDBServiceImplTest.java
index c91abfcdf4d..179ff7facdb 100644
--- a/server/src/test/java/org/apache/seata/server/console/impl/db/GlobalSessionDBServiceImplTest.java
+++ b/server/src/test/java/org/apache/seata/server/console/impl/db/GlobalSessionDBServiceImplTest.java
@@ -26,6 +26,7 @@
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
+import org.mockito.ArgumentCaptor;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.mock.mockito.MockBean;
 import org.springframework.test.context.TestPropertySource;
@@ -176,6 +177,7 @@ void queryWithMultipleParamsTest() throws SQLException {
         param.setPageNum(1);
         param.setPageSize(10);
         param.setXid("test-xid-001");
+        param.setTransactionId(1001L);
         param.setApplicationId("test-app");
         param.setStatus(1);
         param.setTransactionName("test-transaction");
@@ -204,6 +206,34 @@ void queryWithMultipleParamsTest() throws SQLException {
         verify(connection, times(1)).close();
     }
 
+    @Test
+    void queryWithTransactionIdConditionTest() throws SQLException {
+        GlobalSessionParam param = new GlobalSessionParam();
+        param.setPageNum(1);
+        param.setPageSize(10);
+        param.setTransactionId(1001L);
+        param.setWithBranch(false);
+
+        when(dataSource.getConnection()).thenReturn(connection);
+        when(connection.prepareStatement(anyString()))
+                .thenReturn(preparedStatement)
+                .thenReturn(countPreparedStatement);
+        when(preparedStatement.executeQuery()).thenReturn(resultSet);
+        when(countPreparedStatement.executeQuery()).thenReturn(countResultSet);
+        when(resultSet.next()).thenReturn(false);
+        when(countResultSet.next()).thenReturn(true);
+        when(countResultSet.getInt(1)).thenReturn(0);
+
+        PageResult<GlobalSessionVO> result = globalSessionDBService.query(param);
+
+        Assertions.assertNotNull(result);
+        Assertions.assertTrue(result.isSuccess());
+        ArgumentCaptor<String> sqlCaptor = ArgumentCaptor.forClass(String.class);
+        verify(connection, times(2)).prepareStatement(sqlCaptor.capture());
+        Assertions.assertTrue(
+                sqlCaptor.getAllValues().stream().allMatch(sql -> sql.contains("transaction_id = ?")));
+    }
+
     @Test
     void queryEmptyResultTest() throws SQLException {
         GlobalSessionParam param = new GlobalSessionParam();
diff --git a/server/src/test/java/org/apache/seata/server/console/impl/file/GlobalSessionFileServiceImplTest.java b/server/src/test/java/org/apache/seata/server/console/impl/file/GlobalSessionFileServiceImplTest.java
index 117b6bdaabc..7a87a670920 100644
--- a/server/src/test/java/org/apache/seata/server/console/impl/file/GlobalSessionFileServiceImplTest.java
+++ b/server/src/test/java/org/apache/seata/server/console/impl/file/GlobalSessionFileServiceImplTest.java
@@ -22,11 +22,13 @@
 import org.apache.seata.server.console.entity.param.GlobalSessionParam;
 import org.apache.seata.server.console.entity.vo.GlobalSessionVO;
 import org.apache.seata.server.session.GlobalSession;
+import org.apache.seata.server.session.SessionCondition;
 import org.apache.seata.server.session.SessionHolder;
 import org.apache.seata.server.session.SessionManager;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
+import org.mockito.ArgumentCaptor;
 import org.mockito.MockedStatic;
 import org.mockito.Mockito;
 
@@ -117,6 +119,35 @@ public void testQuery_WithXidFilter() {
             when(mockGlobalSession.getBeginTime()).thenReturn(System.currentTimeMillis());
             sessions.add(mockGlobalSession);
 
+            sessionHolderMock.when(SessionHolder::getRootSessionManager).thenReturn(mockSessionManager);
+            when(mockSessionManager.findGlobalSession(param.getXid(), false)).thenReturn(mockGlobalSession);
+
+            PageResult<GlobalSessionVO> result = service.query(param);
+
+            Assertions.assertNotNull(result);
+            Assertions.assertFalse(result.getData().isEmpty());
+            verify(mockSessionManager).findGlobalSession(param.getXid(), false);
+            verify(mockSessionManager, never()).allSessions();
+        }
+    }
+
+    @Test
+    public void testQuery_WithPartialXidFilterFallsBackToScan() {
+        try (MockedStatic<SessionHolder> sessionHolderMock = Mockito.mockStatic(SessionHolder.class)) {
+            GlobalSessionParam param = new GlobalSessionParam();
+            param.setPageSize(10);
+            param.setPageNum(1);
+            param.setXid("123456");
+
+            List<GlobalSession> sessions = new ArrayList<>();
+            when(mockGlobalSession.getXid()).thenReturn("192.168.1.1:8091:123456");
+            when(mockGlobalSession.getApplicationId()).thenReturn("test-app");
+            when(mockGlobalSession.getStatus()).thenReturn(GlobalStatus.Begin);
+            when(mockGlobalSession.getTransactionName()).thenReturn("test-tx");
+            when(mockGlobalSession.getTransactionServiceGroup()).thenReturn("default");
+            when(mockGlobalSession.getBeginTime()).thenReturn(System.currentTimeMillis());
+            sessions.add(mockGlobalSession);
+
             sessionHolderMock.when(SessionHolder::getRootSessionManager).thenReturn(mockSessionManager);
             when(mockSessionManager.allSessions()).thenReturn(sessions);
 
@@ -124,6 +155,8 @@ public void testQuery_WithXidFilter() {
 
             Assertions.assertNotNull(result);
             Assertions.assertFalse(result.getData().isEmpty());
+            verify(mockSessionManager, never()).findGlobalSession(anyString(), anyBoolean());
+            verify(mockSessionManager).allSessions();
         }
     }
 
@@ -144,6 +177,82 @@ public void testQuery_WithStatusFilter() {
             when(mockGlobalSession.getBeginTime()).thenReturn(System.currentTimeMillis());
             sessions.add(mockGlobalSession);
 
+            sessionHolderMock.when(SessionHolder::getRootSessionManager).thenReturn(mockSessionManager);
+            when(mockSessionManager.findGlobalSessions(any(SessionCondition.class)))
+                    .thenReturn(sessions);
+
+            PageResult<GlobalSessionVO> result = service.query(param);
+
+            Assertions.assertNotNull(result);
+            Assertions.assertFalse(result.getData().isEmpty());
+            ArgumentCaptor<SessionCondition> captor = ArgumentCaptor.forClass(SessionCondition.class);
+            verify(mockSessionManager).findGlobalSessions(captor.capture());
+            Assertions.assertArrayEquals(
+                    new GlobalStatus[] {GlobalStatus.Begin}, captor.getValue().getStatuses());
+            Assertions.assertTrue(captor.getValue().isLazyLoadBranch());
+            verify(mockSessionManager, never()).allSessions();
+        }
+    }
+
+    @Test
+    public void testQuery_WithTransactionIdFilter() {
+        try (MockedStatic<SessionHolder> sessionHolderMock = Mockito.mockStatic(SessionHolder.class)) {
+            GlobalSessionParam param = new GlobalSessionParam();
+            param.setPageSize(10);
+            param.setPageNum(1);
+            param.setTransactionId(123456L);
+            param.setWithBranch(true);
+
+            List<GlobalSession> sessions = new ArrayList<>();
+            when(mockGlobalSession.getXid()).thenReturn("192.168.1.1:8091:123456");
+            when(mockGlobalSession.getTransactionId()).thenReturn(123456L);
+            when(mockGlobalSession.getApplicationId()).thenReturn("test-app");
+            when(mockGlobalSession.getStatus()).thenReturn(GlobalStatus.Begin);
+            when(mockGlobalSession.getTransactionName()).thenReturn("test-tx");
+            when(mockGlobalSession.getTransactionServiceGroup()).thenReturn("default");
+            when(mockGlobalSession.getBeginTime()).thenReturn(System.currentTimeMillis());
+            sessions.add(mockGlobalSession);
+
+            sessionHolderMock.when(SessionHolder::getRootSessionManager).thenReturn(mockSessionManager);
+            when(mockSessionManager.findGlobalSessions(any(SessionCondition.class)))
+                    .thenReturn(sessions);
+
+            PageResult<GlobalSessionVO> result = service.query(param);
+
+            Assertions.assertNotNull(result);
+            Assertions.assertFalse(result.getData().isEmpty());
+            ArgumentCaptor<SessionCondition> captor = ArgumentCaptor.forClass(SessionCondition.class);
+            verify(mockSessionManager).findGlobalSessions(captor.capture());
+            Assertions.assertEquals(123456L, captor.getValue().getTransactionId());
+            Assertions.assertFalse(captor.getValue().isLazyLoadBranch());
+            verify(mockSessionManager, never()).allSessions();
+        }
+    }
+
+    @Test
+    public void testQuery_WithNonPositiveTransactionIdDoesNotFilter() {
+        assertNonPositiveTransactionIdDoesNotFilter(0L);
+        assertNonPositiveTransactionIdDoesNotFilter(-1L);
+    }
+
+    private void assertNonPositiveTransactionIdDoesNotFilter(long transactionId) {
+        reset(mockSessionManager, mockGlobalSession);
+        try (MockedStatic<SessionHolder> sessionHolderMock = Mockito.mockStatic(SessionHolder.class)) {
+            GlobalSessionParam param = new GlobalSessionParam();
+            param.setPageSize(10);
+            param.setPageNum(1);
+            param.setTransactionId(transactionId);
+
+            List<GlobalSession> sessions = new ArrayList<>();
+            when(mockGlobalSession.getXid()).thenReturn("192.168.1.1:8091:123456");
+            when(mockGlobalSession.getTransactionId()).thenReturn(123456L);
+            when(mockGlobalSession.getApplicationId()).thenReturn("test-app");
+            when(mockGlobalSession.getStatus()).thenReturn(GlobalStatus.Begin);
+            when(mockGlobalSession.getTransactionName()).thenReturn("test-tx");
+            when(mockGlobalSession.getTransactionServiceGroup()).thenReturn("default");
+            when(mockGlobalSession.getBeginTime()).thenReturn(System.currentTimeMillis());
+            sessions.add(mockGlobalSession);
+
             sessionHolderMock.when(SessionHolder::getRootSessionManager).thenReturn(mockSessionManager);
             when(mockSessionManager.allSessions()).thenReturn(sessions);
 
@@ -151,6 +260,27 @@ public void testQuery_WithStatusFilter() {
 
             Assertions.assertNotNull(result);
             Assertions.assertFalse(result.getData().isEmpty());
+            verify(mockSessionManager, never()).findGlobalSessions(any(SessionCondition.class));
+            verify(mockSessionManager).allSessions();
+        }
+    }
+
+    @Test
+    public void testQuery_WithInvalidStatusFilter() {
+        try (MockedStatic<SessionHolder> sessionHolderMock = Mockito.mockStatic(SessionHolder.class)) {
+            GlobalSessionParam param = new GlobalSessionParam();
+            param.setPageSize(10);
+            param.setPageNum(1);
+            param.setStatus(Integer.MAX_VALUE);
+
+            sessionHolderMock.when(SessionHolder::getRootSessionManager).thenReturn(mockSessionManager);
+
+            PageResult<GlobalSessionVO> result = service.query(param);
+
+            Assertions.assertNotNull(result);
+            Assertions.assertTrue(result.getData().isEmpty());
+            verify(mockSessionManager, never()).allSessions();
+            verify(mockSessionManager, never()).findGlobalSessions(any(SessionCondition.class));
         }
     }
 
diff --git a/server/src/test/java/org/apache/seata/server/console/impl/redis/GlobalSessionRedisServiceImplTest.java b/server/src/test/java/org/apache/seata/server/console/impl/redis/GlobalSessionRedisServiceImplTest.java
index a3794dc5809..140af27b239 100644
--- a/server/src/test/java/org/apache/seata/server/console/impl/redis/GlobalSessionRedisServiceImplTest.java
+++ b/server/src/test/java/org/apache/seata/server/console/impl/redis/GlobalSessionRedisServiceImplTest.java
@@ -140,6 +140,25 @@ void queryByXidTest() throws Exception {
         Assertions.assertEquals("127.0.0.1:8091:1001", result.getData().get(0).getXid());
     }
 
+    @Test
+    void queryByTransactionIdTest() throws Exception {
+        createTestGlobalTransaction("127.0.0.1:8091:1001", 1001L, GlobalStatus.Begin);
+
+        GlobalSessionParam param = new GlobalSessionParam();
+        param.setPageNum(1);
+        param.setPageSize(10);
+        param.setTransactionId(1001L);
+        param.setWithBranch(false);
+
+        PageResult<GlobalSessionVO> result = globalSessionRedisService.query(param);
+
+        Assertions.assertNotNull(result);
+        Assertions.assertTrue(result.isSuccess());
+        Assertions.assertEquals(1, result.getData().size());
+        Assertions.assertEquals(1, result.getTotal());
+        Assertions.assertEquals("127.0.0.1:8091:1001", result.getData().get(0).getXid());
+    }
+
     @Test
     void queryByStatusTest() throws Exception {
         createTestGlobalTransaction("127.0.0.1:8091:1001", 1001L, GlobalStatus.Begin);
diff --git a/server/src/test/java/org/apache/seata/server/lock/LockerManagerFactoryTest.java b/server/src/test/java/org/apache/seata/server/lock/LockerManagerFactoryTest.java
new file mode 100644
index 00000000000..e1375d8304f
--- /dev/null
+++ b/server/src/test/java/org/apache/seata/server/lock/LockerManagerFactoryTest.java
@@ -0,0 +1,68 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.seata.server.lock;
+
+import org.apache.seata.common.ConfigurationKeys;
+import org.apache.seata.common.exception.StoreException;
+import org.apache.seata.config.ConfigurationCache;
+import org.apache.seata.server.BaseSpringBootTest;
+import org.apache.seata.server.storage.file.lock.FileLockManager;
+import org.apache.seata.server.storage.rocksdb.lock.RocksDBLockManager;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+class LockerManagerFactoryTest extends BaseSpringBootTest {
+
+    @BeforeEach
+    void beforeEach() {
+        clearConfig();
+    }
+
+    @AfterEach
+    void afterEach() {
+        clearConfig();
+    }
+
+    @Test
+    void testDefaultFileLockManager() {
+        LockerManagerFactory.init();
+        Assertions.assertInstanceOf(FileLockManager.class, LockerManagerFactory.getLockManager());
+    }
+
+    @Test
+    void testRocksDBEffectiveLockManager() {
+        System.setProperty(ConfigurationKeys.STORE_FILE_ENGINE, "rocksdb");
+        LockerManagerFactory.init();
+        Assertions.assertInstanceOf(RocksDBLockManager.class, LockerManagerFactory.getLockManager());
+    }
+
+    @Test
+    void testRocksDBEffectiveLockManagerRejectsMixedLockMode() {
+        System.setProperty(ConfigurationKeys.STORE_FILE_ENGINE, "rocksdb");
+        System.setProperty(ConfigurationKeys.STORE_LOCK_MODE, "file");
+        Assertions.assertThrows(StoreException.class, LockerManagerFactory::init);
+    }
+
+    private void clearConfig() {
+        LockerManagerFactory.destroy();
+        System.clearProperty(ConfigurationKeys.STORE_LOCK_MODE);
+        System.clearProperty(ConfigurationKeys.STORE_FILE_ENGINE);
+        ConfigurationCache.clear();
+    }
+}
diff --git a/server/src/test/java/org/apache/seata/server/session/SessionHolderRocksDBTest.java b/server/src/test/java/org/apache/seata/server/session/SessionHolderRocksDBTest.java
new file mode 100644
index 00000000000..238665b7a15
--- /dev/null
+++ b/server/src/test/java/org/apache/seata/server/session/SessionHolderRocksDBTest.java
@@ -0,0 +1,170 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.seata.server.session;
+
+import org.apache.seata.common.Constants;
+import org.apache.seata.common.XID;
+import org.apache.seata.common.holder.ObjectHolder;
+import org.apache.seata.common.store.SessionMode;
+import org.apache.seata.config.ConfigurationCache;
+import org.apache.seata.core.constants.ConfigurationKeys;
+import org.apache.seata.core.model.BranchStatus;
+import org.apache.seata.core.model.BranchType;
+import org.apache.seata.core.model.GlobalStatus;
+import org.apache.seata.server.lock.LockerManagerFactory;
+import org.apache.seata.server.storage.file.TransactionWriteStore;
+import org.apache.seata.server.storage.rocksdb.RocksDBStoreEngineFactory;
+import org.apache.seata.server.storage.rocksdb.session.RocksDBSessionManager;
+import org.apache.seata.server.store.SessionStorable;
+import org.apache.seata.server.store.TransactionStoreManager.LogOperation;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+import org.springframework.mock.env.MockEnvironment;
+
+import java.io.IOException;
+import java.lang.reflect.Field;
+import java.nio.ByteBuffer;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardOpenOption;
+import java.util.Collections;
+import java.util.Map;
+
+class SessionHolderRocksDBTest {
+
+    @TempDir
+    Path tempDir;
+
+    private Object originalEnvironment;
+
+    @BeforeEach
+    void beforeEach() {
+        originalEnvironment = ObjectHolder.INSTANCE.getObject(Constants.OBJECT_KEY_SPRING_CONFIGURABLE_ENVIRONMENT);
+        ObjectHolder.INSTANCE.setObject(Constants.OBJECT_KEY_SPRING_CONFIGURABLE_ENVIRONMENT, new MockEnvironment());
+        ConfigurationCache.clear();
+    }
+
+    @AfterEach
+    void afterEach() throws Exception {
+        System.clearProperty(ConfigurationKeys.STORE_FILE_DIR);
+        System.clearProperty(ConfigurationKeys.STORE_FILE_ENGINE);
+        System.clearProperty(ConfigurationKeys.STORE_FILE_ROCKSDB_DIR);
+        SessionHolder.destroy();
+        LockerManagerFactory.destroy();
+        RocksDBStoreEngineFactory.destroy();
+        ConfigurationCache.clear();
+        restoreEnvironment();
+    }
+
+    @Test
+    void testRocksDBFileEngineInitializesRocksDBSessionManager() {
+        configureRocksDBFileMode();
+
+        SessionHolder.init(SessionMode.FILE);
+
+        Assertions.assertTrue(SessionHolder.getRootSessionManager() instanceof RocksDBSessionManager);
+    }
+
+    @Test
+    void testRocksDBFileEngineReloadsBranchLocks() throws Exception {
+        configureRocksDBFileMode();
+        SessionHolder.init(SessionMode.FILE);
+
+        BranchSession branchSession = branchSession(1001L, 1L, "t_order:1");
+        GlobalSession globalSession = globalSession(branchSession);
+        globalSession.add(branchSession);
+
+        SessionHolder.reload(Collections.singletonList(globalSession), SessionMode.FILE);
+
+        BranchSession conflict = branchSession(1002L, 2L, "t_order:1");
+        Assertions.assertFalse(LockerManagerFactory.getLockManager().acquireLock(conflict));
+    }
+
+    @Test
+    void testRocksDBFileEngineMigratesFileSessionLog() throws Exception {
+        configureRocksDBFileMode();
+        GlobalSession globalSession = globalSession(2001L);
+        appendFileLog(globalSession, LogOperation.GLOBAL_ADD);
+
+        SessionHolder.init(SessionMode.FILE);
+
+        GlobalSession actual = SessionHolder.getRootSessionManager().findGlobalSession(globalSession.getXid(), true);
+        Assertions.assertNotNull(actual);
+        Assertions.assertEquals(globalSession.getXid(), actual.getXid());
+    }
+
+    private void configureRocksDBFileMode() {
+        System.setProperty(
+                ConfigurationKeys.STORE_FILE_DIR, tempDir.resolve("file").toString());
+        System.setProperty(ConfigurationKeys.STORE_FILE_ENGINE, "rocksdb");
+        System.setProperty(
+                ConfigurationKeys.STORE_FILE_ROCKSDB_DIR,
+                tempDir.resolve("rocksdb").toString());
+    }
+
+    private GlobalSession globalSession(BranchSession branchSession) {
+        GlobalSession globalSession = globalSession(branchSession.getTransactionId());
+        globalSession.setXid(branchSession.getXid());
+        return globalSession;
+    }
+
+    private GlobalSession globalSession(long transactionId) {
+        GlobalSession globalSession = new GlobalSession("app", "group", "tx", 60000);
+        globalSession.setXid("127.0.0.1:8091:" + transactionId);
+        globalSession.setTransactionId(transactionId);
+        globalSession.setStatus(GlobalStatus.Begin);
+        return globalSession;
+    }
+
+    private BranchSession branchSession(long transactionId, long branchId, String lockKey) {
+        BranchSession branchSession = new BranchSession(BranchType.AT);
+        branchSession.setXid("127.0.0.1:8091:" + transactionId);
+        branchSession.setTransactionId(transactionId);
+        branchSession.setBranchId(branchId);
+        branchSession.setStatus(BranchStatus.Registered);
+        branchSession.setResourceId("jdbc:mysql://127.0.0.1/db");
+        branchSession.setLockKey(lockKey);
+        return branchSession;
+    }
+
+    private void appendFileLog(SessionStorable session, LogOperation logOperation) throws IOException {
+        byte[] data = new TransactionWriteStore(session, logOperation).encode();
+        ByteBuffer buffer = ByteBuffer.allocate(Integer.BYTES + data.length);
+        buffer.putInt(data.length);
+        buffer.put(data);
+        Path fileLog = tempDir.resolve("file")
+                .resolve(String.valueOf(XID.getPort()))
+                .resolve(SessionHolder.ROOT_SESSION_MANAGER_NAME);
+        Files.createDirectories(fileLog.getParent());
+        Files.write(fileLog, buffer.array(), StandardOpenOption.CREATE, StandardOpenOption.APPEND);
+    }
+
+    @SuppressWarnings("unchecked")
+    private void restoreEnvironment() throws Exception {
+        Field field = ObjectHolder.class.getDeclaredField("OBJECT_MAP");
+        field.setAccessible(true);
+        Map<String, Object> objectMap = (Map<String, Object>) field.get(ObjectHolder.INSTANCE);
+        if (originalEnvironment == null) {
+            objectMap.remove(Constants.OBJECT_KEY_SPRING_CONFIGURABLE_ENVIRONMENT);
+        } else {
+            objectMap.put(Constants.OBJECT_KEY_SPRING_CONFIGURABLE_ENVIRONMENT, originalEnvironment);
+        }
+    }
+}
diff --git a/server/src/test/java/org/apache/seata/server/session/SessionHolderTest.java b/server/src/test/java/org/apache/seata/server/session/SessionHolderTest.java
index 692a37fc953..5f5e8fbc5dd 100644
--- a/server/src/test/java/org/apache/seata/server/session/SessionHolderTest.java
+++ b/server/src/test/java/org/apache/seata/server/session/SessionHolderTest.java
@@ -18,6 +18,7 @@
 
 import org.apache.seata.common.XID;
 import org.apache.seata.common.store.SessionMode;
+import org.apache.seata.config.ConfigurationCache;
 import org.apache.seata.core.constants.ConfigurationKeys;
 import org.apache.seata.server.BaseSpringBootTest;
 import org.junit.jupiter.api.AfterEach;
@@ -50,6 +51,7 @@ public class SessionHolderTest extends BaseSpringBootTest {
 
     @BeforeEach
     public void before() {
+        ConfigurationCache.clear();
         String sessionStorePath =
                 SessionHolder.CONFIG.getConfig(ConfigurationKeys.STORE_FILE_DIR, DEFAULT_SESSION_STORE_FILE_DIR)
                         + separator
@@ -78,6 +80,8 @@ public void testInit() throws IOException {
 
     @AfterEach
     public void after() {
+        System.clearProperty(ConfigurationKeys.STORE_FILE_ENGINE);
+        ConfigurationCache.clear();
         final File actual = new File(pathname);
         if (actual.exists()) {
             actual.delete();
diff --git a/server/src/test/java/org/apache/seata/server/spring/loader/SeataPropertiesLoaderTest.java b/server/src/test/java/org/apache/seata/server/spring/loader/SeataPropertiesLoaderTest.java
new file mode 100644
index 00000000000..3219448f2e1
--- /dev/null
+++ b/server/src/test/java/org/apache/seata/server/spring/loader/SeataPropertiesLoaderTest.java
@@ -0,0 +1,107 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.seata.server.spring.loader;
+
+import org.apache.seata.common.ConfigurationKeys;
+import org.apache.seata.common.Constants;
+import org.apache.seata.common.exception.StoreException;
+import org.apache.seata.common.holder.ObjectHolder;
+import org.apache.seata.config.ConfigurationCache;
+import org.apache.seata.server.store.StoreConfig;
+import org.apache.seata.spring.boot.autoconfigure.loader.SeataPropertiesLoader;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.springframework.mock.env.MockEnvironment;
+
+import java.lang.reflect.Field;
+import java.util.Map;
+
+class SeataPropertiesLoaderTest {
+
+    private Object originalEnvironment;
+
+    @BeforeEach
+    void beforeEach() throws Exception {
+        originalEnvironment = ObjectHolder.INSTANCE.getObject(Constants.OBJECT_KEY_SPRING_CONFIGURABLE_ENVIRONMENT);
+        clearConfig();
+    }
+
+    @AfterEach
+    void afterEach() throws Exception {
+        clearConfig();
+        restoreEnvironment();
+    }
+
+    @Test
+    void testLoadDefaultSessionAndLockModes() {
+        new SeataPropertiesLoader().loadSessionAndLockModes();
+
+        Assertions.assertEquals("file", System.getProperty("sessionMode"));
+        Assertions.assertEquals("file", System.getProperty("lockMode"));
+    }
+
+    @Test
+    void testLoadEffectiveLockModeForRocksDBFileEngine() {
+        System.setProperty(ConfigurationKeys.STORE_FILE_ENGINE, "rocksdb");
+
+        new SeataPropertiesLoader().loadSessionAndLockModes();
+
+        Assertions.assertEquals("file", System.getProperty("sessionMode"));
+        Assertions.assertEquals("rocksdb", System.getProperty("lockMode"));
+    }
+
+    @Test
+    void testLoadEffectiveLockModeRejectsMixedLockMode() {
+        System.setProperty(ConfigurationKeys.STORE_FILE_ENGINE, "rocksdb");
+        System.setProperty(ConfigurationKeys.STORE_LOCK_MODE, "file");
+
+        Assertions.assertThrows(StoreException.class, () -> new SeataPropertiesLoader().loadSessionAndLockModes());
+    }
+
+    private void clearConfig() throws Exception {
+        System.clearProperty("sessionMode");
+        System.clearProperty("lockMode");
+        System.clearProperty(ConfigurationKeys.STORE_MODE);
+        System.clearProperty(ConfigurationKeys.STORE_LOCK_MODE);
+        System.clearProperty(ConfigurationKeys.STORE_FILE_ENGINE);
+        ObjectHolder.INSTANCE.setObject(Constants.OBJECT_KEY_SPRING_CONFIGURABLE_ENVIRONMENT, new MockEnvironment());
+        ConfigurationCache.clear();
+        resetStoreConfig("storeMode");
+        resetStoreConfig("sessionMode");
+        resetStoreConfig("lockMode");
+    }
+
+    private void resetStoreConfig(String fieldName) throws Exception {
+        Field field = StoreConfig.class.getDeclaredField(fieldName);
+        field.setAccessible(true);
+        field.set(null, null);
+    }
+
+    @SuppressWarnings("unchecked")
+    private void restoreEnvironment() throws Exception {
+        Field field = ObjectHolder.class.getDeclaredField("OBJECT_MAP");
+        field.setAccessible(true);
+        Map<String, Object> objectMap = (Map<String, Object>) field.get(ObjectHolder.INSTANCE);
+        if (originalEnvironment == null) {
+            objectMap.remove(Constants.OBJECT_KEY_SPRING_CONFIGURABLE_ENVIRONMENT);
+        } else {
+            objectMap.put(Constants.OBJECT_KEY_SPRING_CONFIGURABLE_ENVIRONMENT, originalEnvironment);
+        }
+    }
+}
diff --git a/server/src/test/java/org/apache/seata/server/storage/rocksdb/RocksDBKeyCodecTest.java b/server/src/test/java/org/apache/seata/server/storage/rocksdb/RocksDBKeyCodecTest.java
new file mode 100644
index 00000000000..b327ac10284
--- /dev/null
+++ b/server/src/test/java/org/apache/seata/server/storage/rocksdb/RocksDBKeyCodecTest.java
@@ -0,0 +1,82 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.seata.server.storage.rocksdb;
+
+import org.apache.seata.core.model.GlobalStatus;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+class RocksDBKeyCodecTest {
+
+    @Test
+    void testBranchKeyStartsWithXidPrefix() {
+        byte[] branchKey = RocksDBKeyCodec.encodeBranch("127.0.0.1:8091:12345", 10L);
+        byte[] xidPrefix = RocksDBKeyCodec.encodeXidPrefix("127.0.0.1:8091:12345");
+
+        Assertions.assertTrue(RocksDBKeyCodec.startsWith(branchKey, xidPrefix));
+    }
+
+    @Test
+    void testLockBranchIndexKeyStartsWithGlobalAndBranchPrefix() {
+        byte[] lockKey = RocksDBKeyCodec.encodeRowLock("jdbc:mysql://127.0.0.1/db", "t_order", "id:1|name:a");
+        byte[] indexKey = RocksDBKeyCodec.encodeLockBranchIndex("xid:with#separator", 11L, lockKey);
+
+        Assertions.assertTrue(RocksDBKeyCodec.startsWith(
+                indexKey, RocksDBKeyCodec.encodeLockBranchIndexGlobalPrefix("xid:with#separator")));
+        Assertions.assertTrue(RocksDBKeyCodec.startsWith(
+                indexKey, RocksDBKeyCodec.encodeLockBranchIndexBranchPrefix("xid:with#separator", 11L)));
+        Assertions.assertFalse(RocksDBKeyCodec.startsWith(
+                indexKey, RocksDBKeyCodec.encodeLockBranchIndexBranchPrefix("xid:with#separator", 12L)));
+    }
+
+    @Test
+    void testStartsWithRejectsShorterKey() {
+        Assertions.assertFalse(RocksDBKeyCodec.startsWith(new byte[] {1}, new byte[] {1, 2}));
+    }
+
+    @Test
+    void testGlobalStatusIndexKeySortsByStatusAndBeginTime() {
+        byte[] beginEarly = RocksDBKeyCodec.encodeGlobalStatusIndex(GlobalStatus.Begin, 10L, "xid-b");
+        byte[] beginLate = RocksDBKeyCodec.encodeGlobalStatusIndex(GlobalStatus.Begin, 20L, "xid-a");
+        byte[] committing = RocksDBKeyCodec.encodeGlobalStatusIndex(GlobalStatus.Committing, 1L, "xid-c");
+
+        Assertions.assertTrue(compare(beginEarly, beginLate) < 0);
+        Assertions.assertTrue(compare(beginLate, committing) < 0);
+        Assertions.assertTrue(
+                RocksDBKeyCodec.startsWith(beginEarly, RocksDBKeyCodec.encodeGlobalStatusPrefix(GlobalStatus.Begin)));
+        Assertions.assertFalse(RocksDBKeyCodec.startsWith(
+                beginEarly, RocksDBKeyCodec.encodeGlobalStatusPrefix(GlobalStatus.Committing)));
+    }
+
+    @Test
+    void testTransactionIdIndexKeySortsByTransactionId() {
+        Assertions.assertTrue(
+                compare(RocksDBKeyCodec.encodeTransactionIdIndex(1L), RocksDBKeyCodec.encodeTransactionIdIndex(2L))
+                        < 0);
+    }
+
+    private int compare(byte[] left, byte[] right) {
+        int length = Math.min(left.length, right.length);
+        for (int i = 0; i < length; i++) {
+            int result = (left[i] & 0xff) - (right[i] & 0xff);
+            if (result != 0) {
+                return result;
+            }
+        }
+        return left.length - right.length;
+    }
+}
diff --git a/server/src/test/java/org/apache/seata/server/storage/rocksdb/RocksDBLocalLocksTest.java b/server/src/test/java/org/apache/seata/server/storage/rocksdb/RocksDBLocalLocksTest.java
new file mode 100644
index 00000000000..cca3535645d
--- /dev/null
+++ b/server/src/test/java/org/apache/seata/server/storage/rocksdb/RocksDBLocalLocksTest.java
@@ -0,0 +1,44 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.seata.server.storage.rocksdb;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import java.util.Arrays;
+
+class RocksDBLocalLocksTest {
+
+    @Test
+    void testLockAllDeduplicatesSameStripe() {
+        RocksDBLocalLocks locks = new RocksDBLocalLocks(1);
+
+        try (RocksDBLocalLocks.LockScope ignored =
+                locks.lockAll(Arrays.asList(new byte[] {1}, new byte[] {2}, new byte[] {1}))) {
+            Assertions.assertNotNull(ignored);
+        }
+    }
+
+    @Test
+    void testRejectsNullKey() {
+        RocksDBLocalLocks locks = new RocksDBLocalLocks(1);
+
+        Assertions.assertThrows(NullPointerException.class, () -> locks.lock(null));
+        Assertions.assertThrows(
+                NullPointerException.class, () -> locks.lockAll(Arrays.asList(new byte[] {1}, null)));
+    }
+}
diff --git a/server/src/test/java/org/apache/seata/server/storage/rocksdb/RocksDBStoreEngineTest.java b/server/src/test/java/org/apache/seata/server/storage/rocksdb/RocksDBStoreEngineTest.java
new file mode 100644
index 00000000000..ce7c20a48be
--- /dev/null
+++ b/server/src/test/java/org/apache/seata/server/storage/rocksdb/RocksDBStoreEngineTest.java
@@ -0,0 +1,190 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.seata.server.storage.rocksdb;
+
+import org.apache.seata.common.exception.StoreException;
+import org.apache.seata.core.model.GlobalStatus;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Path;
+import java.util.List;
+
+class RocksDBStoreEngineTest {
+
+    @TempDir
+    Path tempDir;
+
+    @AfterEach
+    void afterEach() {
+        RocksDBStoreEngineFactory.destroy();
+    }
+
+    @Test
+    void testPutGetDelete() {
+        try (RocksDBStoreEngine engine = open("db", true)) {
+            byte[] key = RocksDBKeyCodec.encodeXid("xid-1");
+            byte[] value = RocksDBValueCodec.encode(
+                    RocksDBValueCodec.ValueType.GLOBAL_SESSION, "global".getBytes(StandardCharsets.UTF_8));
+
+            engine.put(RocksDBColumnFamily.GLOBAL_SESSION, key, value);
+
+            Assertions.assertArrayEquals(value, engine.get(RocksDBColumnFamily.GLOBAL_SESSION, key));
+
+            engine.delete(RocksDBColumnFamily.GLOBAL_SESSION, key);
+            Assertions.assertNull(engine.get(RocksDBColumnFamily.GLOBAL_SESSION, key));
+        }
+    }
+
+    @Test
+    void testPrefixScan() {
+        try (RocksDBStoreEngine engine = open("scan", false)) {
+            byte[] value = "branch".getBytes(StandardCharsets.UTF_8);
+            engine.put(RocksDBColumnFamily.BRANCH_SESSION, RocksDBKeyCodec.encodeBranch("xid-1", 1L), value);
+            engine.put(RocksDBColumnFamily.BRANCH_SESSION, RocksDBKeyCodec.encodeBranch("xid-1", 2L), value);
+            engine.put(RocksDBColumnFamily.BRANCH_SESSION, RocksDBKeyCodec.encodeBranch("xid-2", 1L), value);
+
+            List<RocksDBStoreEngine.RocksDBEntry> entries =
+                    engine.prefixScan(RocksDBColumnFamily.BRANCH_SESSION, RocksDBKeyCodec.encodeXidPrefix("xid-1"));
+
+            Assertions.assertEquals(2, entries.size());
+        }
+    }
+
+    @Test
+    void testPrefixExistsAndDeleteByPrefix() {
+        try (RocksDBStoreEngine engine = open("delete-prefix", false)) {
+            byte[] value = "branch".getBytes(StandardCharsets.UTF_8);
+            engine.put(RocksDBColumnFamily.BRANCH_SESSION, RocksDBKeyCodec.encodeBranch("xid-1", 1L), value);
+            engine.put(RocksDBColumnFamily.BRANCH_SESSION, RocksDBKeyCodec.encodeBranch("xid-1", 2L), value);
+            engine.put(RocksDBColumnFamily.BRANCH_SESSION, RocksDBKeyCodec.encodeBranch("xid-2", 1L), value);
+
+            Assertions.assertTrue(
+                    engine.prefixExists(RocksDBColumnFamily.BRANCH_SESSION, RocksDBKeyCodec.encodeXidPrefix("xid-1")));
+            Assertions.assertFalse(engine.prefixExists(
+                    RocksDBColumnFamily.BRANCH_SESSION, RocksDBKeyCodec.encodeXidPrefix("missing")));
+
+            engine.deleteByPrefix(RocksDBColumnFamily.BRANCH_SESSION, RocksDBKeyCodec.encodeXidPrefix("xid-1"));
+
+            Assertions.assertFalse(
+                    engine.prefixExists(RocksDBColumnFamily.BRANCH_SESSION, RocksDBKeyCodec.encodeXidPrefix("xid-1")));
+            Assertions.assertTrue(
+                    engine.prefixExists(RocksDBColumnFamily.BRANCH_SESSION, RocksDBKeyCodec.encodeXidPrefix("xid-2")));
+            Assertions.assertEquals(
+                    1,
+                    engine.prefixScan(RocksDBColumnFamily.BRANCH_SESSION, RocksDBKeyCodec.encodeXidPrefix("xid-2"))
+                            .size());
+        }
+    }
+
+    @Test
+    void testMetadataInitialized() {
+        try (RocksDBStoreEngine engine = open("metadata", true)) {
+            byte[] formatVersion =
+                    engine.get(RocksDBColumnFamily.METADATA, "format_version".getBytes(StandardCharsets.UTF_8));
+
+            Assertions.assertEquals(
+                    Integer.toString(RocksDBStoreEngine.FORMAT_VERSION),
+                    new String(formatVersion, StandardCharsets.UTF_8));
+        }
+    }
+
+    @Test
+    void testPhase3IndexColumnFamiliesAvailable() {
+        try (RocksDBStoreEngine engine = open("phase3-index-cf", true)) {
+            byte[] statusKey = RocksDBKeyCodec.encodeGlobalStatusIndex(GlobalStatus.Begin, 1L, "xid-index");
+            byte[] transactionIdKey = RocksDBKeyCodec.encodeTransactionIdIndex(1L);
+            byte[] value = "xid-index".getBytes(StandardCharsets.UTF_8);
+
+            engine.put(RocksDBColumnFamily.GLOBAL_STATUS_INDEX, statusKey, value);
+            engine.put(RocksDBColumnFamily.TRANSACTION_ID_INDEX, transactionIdKey, value);
+
+            Assertions.assertArrayEquals(value, engine.get(RocksDBColumnFamily.GLOBAL_STATUS_INDEX, statusKey));
+            Assertions.assertArrayEquals(value, engine.get(RocksDBColumnFamily.TRANSACTION_ID_INDEX, transactionIdKey));
+        }
+    }
+
+    @Test
+    void testOpenRejectsUnsupportedFormatVersion() {
+        RocksDBStoreConfig config = config("metadata-unsupported", true);
+        try (RocksDBStoreEngine engine = RocksDBStoreEngine.open(config)) {
+            engine.put(
+                    RocksDBColumnFamily.METADATA,
+                    "format_version".getBytes(StandardCharsets.UTF_8),
+                    Integer.toString(RocksDBStoreEngine.FORMAT_VERSION + 1).getBytes(StandardCharsets.UTF_8));
+        }
+
+        StoreException exception = Assertions.assertThrows(StoreException.class, () -> RocksDBStoreEngine.open(config));
+
+        Assertions.assertTrue(exception.getMessage().contains("unsupported RocksDB format version"));
+    }
+
+    @Test
+    void testOpenRejectsInvalidFormatVersion() {
+        RocksDBStoreConfig config = config("metadata-invalid", true);
+        try (RocksDBStoreEngine engine = RocksDBStoreEngine.open(config)) {
+            engine.put(
+                    RocksDBColumnFamily.METADATA,
+                    "format_version".getBytes(StandardCharsets.UTF_8),
+                    "invalid".getBytes(StandardCharsets.UTF_8));
+        }
+
+        StoreException exception = Assertions.assertThrows(StoreException.class, () -> RocksDBStoreEngine.open(config));
+
+        Assertions.assertTrue(exception.getMessage().contains("invalid RocksDB format version metadata"));
+    }
+
+    @Test
+    void testFactoryReturnsSharedInstanceForSamePath() {
+        RocksDBStoreConfig config = config("factory", true);
+
+        RocksDBStoreEngine first = RocksDBStoreEngineFactory.getInstance(config);
+        RocksDBStoreEngine second = RocksDBStoreEngineFactory.getInstance(config);
+
+        Assertions.assertSame(first, second);
+        Assertions.assertTrue(first.isSyncWrite());
+    }
+
+    @Test
+    void testFactoryRejectsDifferentPath() {
+        RocksDBStoreEngineFactory.getInstance(config("factory-a", true));
+
+        Assertions.assertThrows(
+                StoreException.class, () -> RocksDBStoreEngineFactory.getInstance(config("factory-b", true)));
+    }
+
+    @Test
+    void testFactoryRejectsDifferentSyncWrite() {
+        RocksDBStoreConfig config = config("factory-sync", true);
+        RocksDBStoreEngineFactory.getInstance(config);
+
+        Assertions.assertThrows(
+                StoreException.class,
+                () -> RocksDBStoreEngineFactory.getInstance(new RocksDBStoreConfig(config.getDbPath(), false)));
+    }
+
+    private RocksDBStoreEngine open(String name, boolean syncWrite) {
+        return RocksDBStoreEngine.open(config(name, syncWrite));
+    }
+
+    private RocksDBStoreConfig config(String name, boolean syncWrite) {
+        return new RocksDBStoreConfig(tempDir.resolve(name).toString(), syncWrite);
+    }
+}
diff --git a/server/src/test/java/org/apache/seata/server/storage/rocksdb/RocksDBValueCodecTest.java b/server/src/test/java/org/apache/seata/server/storage/rocksdb/RocksDBValueCodecTest.java
new file mode 100644
index 00000000000..58149d80d84
--- /dev/null
+++ b/server/src/test/java/org/apache/seata/server/storage/rocksdb/RocksDBValueCodecTest.java
@@ -0,0 +1,51 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.seata.server.storage.rocksdb;
+
+import org.apache.seata.common.exception.StoreException;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import java.nio.charset.StandardCharsets;
+
+class RocksDBValueCodecTest {
+
+    @Test
+    void testEncodeDecode() {
+        byte[] payload = "payload".getBytes(StandardCharsets.UTF_8);
+
+        RocksDBValueCodec.DecodedValue decoded =
+                RocksDBValueCodec.decode(RocksDBValueCodec.encode(RocksDBValueCodec.ValueType.GLOBAL_SESSION, payload));
+
+        Assertions.assertEquals(RocksDBValueCodec.ValueType.GLOBAL_SESSION, decoded.getType());
+        Assertions.assertEquals(1, decoded.getVersion());
+        Assertions.assertArrayEquals(payload, decoded.getPayload());
+    }
+
+    @Test
+    void testDecodeRejectsInvalidHeader() {
+        Assertions.assertThrows(StoreException.class, () -> RocksDBValueCodec.decode(new byte[] {1, 2, 3}));
+    }
+
+    @Test
+    void testDecodeRejectsUnknownType() {
+        byte[] encoded = RocksDBValueCodec.encode(RocksDBValueCodec.ValueType.METADATA, new byte[0]);
+        encoded[6] = 99;
+
+        Assertions.assertThrows(StoreException.class, () -> RocksDBValueCodec.decode(encoded));
+    }
+}
diff --git a/server/src/test/java/org/apache/seata/server/storage/rocksdb/benchmark/RocksDBQueryIndexBenchmark.java b/server/src/test/java/org/apache/seata/server/storage/rocksdb/benchmark/RocksDBQueryIndexBenchmark.java
new file mode 100644
index 00000000000..f9ce721b2dd
--- /dev/null
+++ b/server/src/test/java/org/apache/seata/server/storage/rocksdb/benchmark/RocksDBQueryIndexBenchmark.java
@@ -0,0 +1,333 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.seata.server.storage.rocksdb.benchmark;
+
+import org.apache.seata.common.Constants;
+import org.apache.seata.common.holder.ObjectHolder;
+import org.apache.seata.config.ConfigurationCache;
+import org.apache.seata.core.model.BranchStatus;
+import org.apache.seata.core.model.BranchType;
+import org.apache.seata.core.model.GlobalStatus;
+import org.apache.seata.server.session.BranchSession;
+import org.apache.seata.server.session.GlobalSession;
+import org.apache.seata.server.session.SessionCondition;
+import org.apache.seata.server.storage.rocksdb.RocksDBColumnFamily;
+import org.apache.seata.server.storage.rocksdb.RocksDBKeyCodec;
+import org.apache.seata.server.storage.rocksdb.RocksDBStoreConfig;
+import org.apache.seata.server.storage.rocksdb.RocksDBStoreEngine;
+import org.apache.seata.server.storage.rocksdb.RocksDBValueCodec;
+import org.apache.seata.server.storage.rocksdb.index.RocksDBIndexManager;
+import org.apache.seata.server.storage.rocksdb.store.RocksDBTransactionStoreManager;
+import org.apache.seata.server.store.TransactionStoreManager.LogOperation;
+import org.rocksdb.RocksDB;
+import org.springframework.mock.env.MockEnvironment;
+
+import java.lang.reflect.Field;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Manual benchmark for RocksDB query indexes.
+ *
+ * <p>Run from an IDE or with a test classpath. This class is intentionally not named *Test, so it does not run in the
+ * regular unit test suite.
+ */
+public final class RocksDBQueryIndexBenchmark {
+
+    private static final GlobalStatus[] STATUSES = {
+            GlobalStatus.Begin,
+            GlobalStatus.Committing,
+            GlobalStatus.RollbackRetrying,
+            GlobalStatus.AsyncCommitting,
+            GlobalStatus.Committed
+    };
+    private static final GlobalStatus TARGET_STATUS = GlobalStatus.RollbackRetrying;
+    private static volatile int sinkCount;
+    private static volatile String sinkXid;
+
+    private RocksDBQueryIndexBenchmark() {
+    }
+
+    public static void main(String[] args) throws Exception {
+        Object originalEnvironment =
+                ObjectHolder.INSTANCE.getObject(Constants.OBJECT_KEY_SPRING_CONFIGURABLE_ENVIRONMENT);
+        ObjectHolder.INSTANCE.setObject(Constants.OBJECT_KEY_SPRING_CONFIGURABLE_ENVIRONMENT, new MockEnvironment());
+        ConfigurationCache.clear();
+        try {
+            new RocksDBQueryIndexBenchmark().run();
+        } finally {
+            ConfigurationCache.clear();
+            restoreEnvironment(originalEnvironment);
+        }
+    }
+
+    private void run() throws Exception {
+        BenchmarkOptions options = BenchmarkOptions.fromSystemProperties();
+        Path rootPath = options.rootPath();
+        Files.createDirectories(rootPath);
+
+        List<GlobalSession> sessions = new ArrayList<>(options.sessionCount);
+        long[] writeNanos = new long[options.sessionCount];
+        Path queryDbPath = rootPath.resolve("query");
+        try (RocksDBStoreEngine engine = open(queryDbPath, options.syncWrite)) {
+            RocksDBTransactionStoreManager storeManager = new RocksDBTransactionStoreManager(engine);
+            long baseBeginTime = System.currentTimeMillis() - options.sessionCount;
+            for (int i = 0; i < options.sessionCount; i++) {
+                GlobalSession globalSession = globalSession(i, baseBeginTime + i);
+                sessions.add(globalSession);
+                long startedAt = System.nanoTime();
+                storeManager.writeSession(LogOperation.GLOBAL_ADD, globalSession);
+                for (int branchIndex = 0; branchIndex < options.branchFanOut; branchIndex++) {
+                    storeManager.writeSession(LogOperation.BRANCH_ADD, branchSession(globalSession, branchIndex));
+                }
+                writeNanos[i] = System.nanoTime() - startedAt;
+            }
+            engine.flush();
+
+            long[] transactionIdNanos = repeat(options.repetitions, i -> {
+                GlobalSession globalSession = sessions.get((i * 9973) % sessions.size());
+                SessionCondition condition = new SessionCondition();
+                condition.setTransactionId(globalSession.getTransactionId());
+                condition.setLazyLoadBranch(true);
+                List<GlobalSession> result = storeManager.readSession(condition);
+                sinkXid = result.isEmpty() ? null : result.get(0).getXid();
+            });
+            long[] statusIndexNanos = repeat(options.repetitions, i -> {
+                SessionCondition condition = new SessionCondition(TARGET_STATUS);
+                condition.setLazyLoadBranch(true);
+                sinkCount = storeManager.readSession(condition).size();
+            });
+            long[] beginSortedNanos = repeat(options.repetitions, i -> {
+                sinkCount = storeManager.readSortByTimeoutBeginSessions(false).size();
+            });
+            long[] fullScanNanos = repeat(options.repetitions, i -> {
+                SessionCondition condition = new SessionCondition();
+                condition.setLazyLoadBranch(true);
+                int count = 0;
+                for (GlobalSession globalSession : storeManager.readSession(condition)) {
+                    if (globalSession.getStatus() == TARGET_STATUS) {
+                        count++;
+                    }
+                }
+                sinkCount = count;
+            });
+
+            long rebuildNanos = benchmarkIndexRebuild(rootPath.resolve("upgrade"), options);
+            printReport(
+                    options,
+                    rootPath,
+                    writeNanos,
+                    transactionIdNanos,
+                    statusIndexNanos,
+                    beginSortedNanos,
+                    fullScanNanos,
+                    rebuildNanos);
+        }
+    }
+
+    private long benchmarkIndexRebuild(Path dbPath, BenchmarkOptions options) {
+        long baseBeginTime = System.currentTimeMillis() - options.sessionCount;
+        try (RocksDBStoreEngine engine = open(dbPath, options.syncWrite)) {
+            for (int i = 0; i < options.sessionCount; i++) {
+                GlobalSession globalSession = globalSession(i, baseBeginTime + i);
+                engine.put(
+                        RocksDBColumnFamily.GLOBAL_SESSION,
+                        RocksDBKeyCodec.encodeXid(globalSession.getXid()),
+                        RocksDBValueCodec.encode(
+                                RocksDBValueCodec.ValueType.GLOBAL_SESSION, globalSession.encode()));
+            }
+            engine.flush();
+        }
+        try (RocksDBStoreEngine engine = open(dbPath, options.syncWrite)) {
+            RocksDBIndexManager indexManager = new RocksDBIndexManager(engine);
+            long startedAt = System.nanoTime();
+            indexManager.ensureReady();
+            engine.flush();
+            return System.nanoTime() - startedAt;
+        }
+    }
+
+    private static RocksDBStoreEngine open(Path dbPath, boolean syncWrite) {
+        return RocksDBStoreEngine.open(new RocksDBStoreConfig(dbPath.toString(), syncWrite));
+    }
+
+    private static GlobalSession globalSession(int index, long beginTime) {
+        GlobalSession globalSession = new GlobalSession("benchmark-app", "benchmark-group", "tx-" + index, 60000);
+        globalSession.setStatus(STATUSES[index % STATUSES.length]);
+        globalSession.setBeginTime(beginTime);
+        return globalSession;
+    }
+
+    private static BranchSession branchSession(GlobalSession globalSession, int branchIndex) {
+        BranchSession branchSession = new BranchSession(BranchType.AT);
+        branchSession.setXid(globalSession.getXid());
+        branchSession.setTransactionId(globalSession.getTransactionId());
+        branchSession.setBranchId(globalSession.getTransactionId() * 1000 + branchIndex);
+        branchSession.setStatus(BranchStatus.Registered);
+        branchSession.setResourceId("jdbc:mysql://127.0.0.1/benchmark");
+        branchSession.setLockKey("benchmark_table:" + globalSession.getTransactionId() + ":" + branchIndex);
+        return branchSession;
+    }
+
+    private static long[] repeat(int repetitions, BenchmarkTask task) {
+        long[] samples = new long[repetitions];
+        for (int i = 0; i < repetitions; i++) {
+            long startedAt = System.nanoTime();
+            task.run(i);
+            samples[i] = System.nanoTime() - startedAt;
+        }
+        return samples;
+    }
+
+    private static void printReport(
+            BenchmarkOptions options,
+            Path rootPath,
+            long[] writeNanos,
+            long[] transactionIdNanos,
+            long[] statusIndexNanos,
+            long[] beginSortedNanos,
+            long[] fullScanNanos,
+            long rebuildNanos) {
+        System.out.println("RocksDB query index benchmark");
+        System.out.println("rootPath=" + rootPath);
+        System.out.println("availableProcessors=" + Runtime.getRuntime().availableProcessors());
+        System.out.println("jdk=" + System.getProperty("java.version") + " " + System.getProperty("java.vm.name"));
+        System.out.println("rocksdbJniVersion=" + rocksDbJniVersion());
+        System.out.println("syncWrite=" + options.syncWrite);
+        System.out.println("sessionCount=" + options.sessionCount);
+        System.out.println("branchFanOut=" + options.branchFanOut);
+        System.out.println("repetitions=" + options.repetitions);
+        System.out.println("targetStatus=" + TARGET_STATUS);
+        System.out.println("indexRebuild=" + millis(rebuildNanos) + " ms");
+        printStats("writeGlobalWithBranches", writeNanos);
+        printStats("queryByTransactionIdIndex", transactionIdNanos);
+        printStats("queryByStatusIndex", statusIndexNanos);
+        printStats("queryBeginSortedIndex", beginSortedNanos);
+        printStats("queryFullGlobalScanThenFilter", fullScanNanos);
+        System.out.println("sinkCount=" + sinkCount);
+        System.out.println("sinkXid=" + sinkXid);
+    }
+
+    private static void printStats(String name, long[] samples) {
+        Arrays.sort(samples);
+        System.out.println(name + ".p50=" + millis(percentile(samples, 50)) + " ms");
+        System.out.println(name + ".p95=" + millis(percentile(samples, 95)) + " ms");
+        System.out.println(name + ".p99=" + millis(percentile(samples, 99)) + " ms");
+    }
+
+    private static long percentile(long[] sortedSamples, int percentile) {
+        int index = (int) Math.ceil(sortedSamples.length * percentile / 100.0D) - 1;
+        return sortedSamples[Math.max(0, Math.min(index, sortedSamples.length - 1))];
+    }
+
+    private static String millis(long nanos) {
+        return String.format("%.3f", nanos / 1_000_000.0D);
+    }
+
+    private static String rocksDbJniVersion() {
+        Package rocksDbPackage = RocksDB.class.getPackage();
+        String version = rocksDbPackage == null ? null : rocksDbPackage.getImplementationVersion();
+        if (version != null) {
+            return version;
+        }
+        try {
+            java.security.CodeSource codeSource = RocksDB.class.getProtectionDomain().getCodeSource();
+            if (codeSource == null || codeSource.getLocation() == null) {
+                return "unknown";
+            }
+            String fileName = Paths.get(codeSource.getLocation().toURI()).getFileName().toString();
+            String prefix = "rocksdbjni-";
+            String suffix = ".jar";
+            if (fileName.startsWith(prefix) && fileName.endsWith(suffix)) {
+                return fileName.substring(prefix.length(), fileName.length() - suffix.length());
+            }
+            return fileName;
+        } catch (Exception e) {
+            return "unknown";
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    private static void restoreEnvironment(Object originalEnvironment) throws Exception {
+        Field field = ObjectHolder.class.getDeclaredField("OBJECT_MAP");
+        field.setAccessible(true);
+        Map<String, Object> objectMap = (Map<String, Object>) field.get(ObjectHolder.INSTANCE);
+        if (originalEnvironment == null) {
+            objectMap.remove(Constants.OBJECT_KEY_SPRING_CONFIGURABLE_ENVIRONMENT);
+        } else {
+            objectMap.put(Constants.OBJECT_KEY_SPRING_CONFIGURABLE_ENVIRONMENT, originalEnvironment);
+        }
+    }
+
+    private interface BenchmarkTask {
+        void run(int iteration);
+    }
+
+    private static final class BenchmarkOptions {
+        private final int sessionCount;
+        private final int repetitions;
+        private final int branchFanOut;
+        private final boolean syncWrite;
+        private final String dbPath;
+
+        private BenchmarkOptions(
+                int sessionCount, int repetitions, int branchFanOut, boolean syncWrite, String dbPath) {
+            this.sessionCount = sessionCount;
+            this.repetitions = repetitions;
+            this.branchFanOut = branchFanOut;
+            this.syncWrite = syncWrite;
+            this.dbPath = dbPath;
+        }
+
+        private static BenchmarkOptions fromSystemProperties() {
+            return new BenchmarkOptions(
+                    intProperty("rocksdb.benchmark.sessions", 10000),
+                    intProperty("rocksdb.benchmark.repetitions", 100),
+                    intProperty("rocksdb.benchmark.branchFanOut", 0),
+                    booleanProperty("rocksdb.benchmark.syncWrite", false),
+                    System.getProperty("rocksdb.benchmark.dbPath"));
+        }
+
+        private Path rootPath() throws Exception {
+            if (dbPath == null || dbPath.trim().isEmpty()) {
+                return Files.createTempDirectory("seata-rocksdb-query-index-benchmark-");
+            }
+            return Paths.get(dbPath);
+        }
+
+        private static int intProperty(String key, int defaultValue) {
+            String value = System.getProperty(key);
+            if (value == null || value.trim().isEmpty()) {
+                return defaultValue;
+            }
+            return Integer.parseInt(value);
+        }
+
+        private static boolean booleanProperty(String key, boolean defaultValue) {
+            String value = System.getProperty(key);
+            if (value == null || value.trim().isEmpty()) {
+                return defaultValue;
+            }
+            return Boolean.parseBoolean(value);
+        }
+    }
+}
diff --git a/server/src/test/java/org/apache/seata/server/storage/rocksdb/index/RocksDBIndexManagerTest.java b/server/src/test/java/org/apache/seata/server/storage/rocksdb/index/RocksDBIndexManagerTest.java
new file mode 100644
index 00000000000..f5de820c850
--- /dev/null
+++ b/server/src/test/java/org/apache/seata/server/storage/rocksdb/index/RocksDBIndexManagerTest.java
@@ -0,0 +1,170 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.seata.server.storage.rocksdb.index;
+
+import org.apache.seata.common.Constants;
+import org.apache.seata.common.exception.StoreException;
+import org.apache.seata.common.holder.ObjectHolder;
+import org.apache.seata.config.ConfigurationCache;
+import org.apache.seata.core.model.GlobalStatus;
+import org.apache.seata.server.session.GlobalSession;
+import org.apache.seata.server.storage.rocksdb.RocksDBColumnFamily;
+import org.apache.seata.server.storage.rocksdb.RocksDBKeyCodec;
+import org.apache.seata.server.storage.rocksdb.RocksDBStoreConfig;
+import org.apache.seata.server.storage.rocksdb.RocksDBStoreEngine;
+import org.apache.seata.server.storage.rocksdb.RocksDBValueCodec;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+import org.springframework.mock.env.MockEnvironment;
+
+import java.lang.reflect.Field;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+class RocksDBIndexManagerTest {
+
+    @TempDir
+    Path tempDir;
+
+    private Object originalEnvironment;
+
+    @BeforeEach
+    void beforeEach() {
+        originalEnvironment = ObjectHolder.INSTANCE.getObject(Constants.OBJECT_KEY_SPRING_CONFIGURABLE_ENVIRONMENT);
+        ObjectHolder.INSTANCE.setObject(Constants.OBJECT_KEY_SPRING_CONFIGURABLE_ENVIRONMENT, new MockEnvironment());
+        ConfigurationCache.clear();
+    }
+
+    @AfterEach
+    void afterEach() throws Exception {
+        ConfigurationCache.clear();
+        restoreEnvironment();
+    }
+
+    @Test
+    void testRebuildsIndexesFromGlobalSessions() {
+        try (RocksDBStoreEngine engine = open("rebuild")) {
+            GlobalSession begin = globalSession("tx-begin", GlobalStatus.Begin);
+            GlobalSession committing = globalSession("tx-committing", GlobalStatus.Committing);
+            putGlobal(engine, begin);
+            putGlobal(engine, committing);
+
+            RocksDBIndexManager indexManager = new RocksDBIndexManager(engine);
+            indexManager.ensureReady();
+
+            Assertions.assertEquals(begin.getXid(), indexManager.findXidByTransactionId(begin.getTransactionId()));
+            Assertions.assertEquals(
+                    committing.getXid(), indexManager.findXidByTransactionId(committing.getTransactionId()));
+            Assertions.assertEquals(
+                    1, indexManager.scanXidsByStatus(GlobalStatus.Begin).size());
+            Assertions.assertEquals(
+                    begin.getXid(),
+                    indexManager.scanXidsByStatus(GlobalStatus.Begin).get(0));
+            List<String> streamedBeginXids = new ArrayList<>();
+            indexManager.scanXidsByStatus(GlobalStatus.Begin, streamedBeginXids::add);
+            Assertions.assertEquals(1, streamedBeginXids.size());
+            Assertions.assertEquals(begin.getXid(), streamedBeginXids.get(0));
+            Assertions.assertEquals(
+                    RocksDBIndexManager.INDEX_BUILD_STATUS_COMPLETED,
+                    getMetadata(engine, RocksDBIndexManager.INDEX_BUILD_STATUS_KEY));
+        }
+    }
+
+    @Test
+    void testInProgressIndexBuildIsClearedAndRebuilt() {
+        try (RocksDBStoreEngine engine = open("in-progress")) {
+            GlobalSession active = globalSession("tx-active", GlobalStatus.Begin);
+            putGlobal(engine, active);
+            engine.put(
+                    RocksDBColumnFamily.METADATA,
+                    bytes(RocksDBIndexManager.INDEX_BUILD_STATUS_KEY),
+                    bytes(RocksDBIndexManager.INDEX_BUILD_STATUS_IN_PROGRESS));
+            engine.put(
+                    RocksDBColumnFamily.GLOBAL_STATUS_INDEX,
+                    RocksDBKeyCodec.encodeGlobalStatusIndex(GlobalStatus.Committed, 1L, "stale"),
+                    bytes("stale"));
+
+            RocksDBIndexManager indexManager = new RocksDBIndexManager(engine);
+            indexManager.ensureReady();
+
+            List<String> committedXids = indexManager.scanXidsByStatus(GlobalStatus.Committed);
+            Assertions.assertTrue(committedXids.isEmpty());
+            Assertions.assertEquals(
+                    active.getXid(),
+                    indexManager.scanXidsByStatus(GlobalStatus.Begin).get(0));
+        }
+    }
+
+    @Test
+    void testFutureIndexVersionFailsFast() {
+        try (RocksDBStoreEngine engine = open("future")) {
+            engine.put(
+                    RocksDBColumnFamily.METADATA,
+                    bytes(RocksDBIndexManager.INDEX_VERSION_KEY),
+                    bytes(Integer.toString(RocksDBIndexManager.INDEX_VERSION + 1)));
+
+            StoreException exception =
+                    Assertions.assertThrows(StoreException.class, () -> new RocksDBIndexManager(engine).ensureReady());
+            Assertions.assertTrue(exception.getMessage().contains("unsupported RocksDB index version"));
+        }
+    }
+
+    private RocksDBStoreEngine open(String name) {
+        return RocksDBStoreEngine.open(
+                new RocksDBStoreConfig(tempDir.resolve(name).toString(), true));
+    }
+
+    private GlobalSession globalSession(String name, GlobalStatus status) {
+        GlobalSession globalSession = new GlobalSession("app", "group", name, 60000);
+        globalSession.setStatus(status);
+        return globalSession;
+    }
+
+    private void putGlobal(RocksDBStoreEngine engine, GlobalSession globalSession) {
+        engine.put(
+                RocksDBColumnFamily.GLOBAL_SESSION,
+                RocksDBKeyCodec.encodeXid(globalSession.getXid()),
+                RocksDBValueCodec.encode(RocksDBValueCodec.ValueType.GLOBAL_SESSION, globalSession.encode()));
+    }
+
+    private String getMetadata(RocksDBStoreEngine engine, String key) {
+        byte[] value = engine.get(RocksDBColumnFamily.METADATA, bytes(key));
+        return value == null ? null : new String(value, StandardCharsets.UTF_8);
+    }
+
+    private byte[] bytes(String value) {
+        return value.getBytes(StandardCharsets.UTF_8);
+    }
+
+    @SuppressWarnings("unchecked")
+    private void restoreEnvironment() throws Exception {
+        Field field = ObjectHolder.class.getDeclaredField("OBJECT_MAP");
+        field.setAccessible(true);
+        Map<String, Object> objectMap = (Map<String, Object>) field.get(ObjectHolder.INSTANCE);
+        if (originalEnvironment == null) {
+            objectMap.remove(Constants.OBJECT_KEY_SPRING_CONFIGURABLE_ENVIRONMENT);
+        } else {
+            objectMap.put(Constants.OBJECT_KEY_SPRING_CONFIGURABLE_ENVIRONMENT, originalEnvironment);
+        }
+    }
+}
diff --git a/server/src/test/java/org/apache/seata/server/storage/rocksdb/lock/RocksDBLockManagerTest.java b/server/src/test/java/org/apache/seata/server/storage/rocksdb/lock/RocksDBLockManagerTest.java
new file mode 100644
index 00000000000..1cd3780cc3f
--- /dev/null
+++ b/server/src/test/java/org/apache/seata/server/storage/rocksdb/lock/RocksDBLockManagerTest.java
@@ -0,0 +1,269 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.seata.server.storage.rocksdb.lock;
+
+import org.apache.seata.common.Constants;
+import org.apache.seata.common.exception.StoreException;
+import org.apache.seata.common.holder.ObjectHolder;
+import org.apache.seata.config.ConfigurationCache;
+import org.apache.seata.core.exception.BranchTransactionException;
+import org.apache.seata.core.model.BranchStatus;
+import org.apache.seata.core.model.BranchType;
+import org.apache.seata.core.model.LockStatus;
+import org.apache.seata.server.session.BranchSession;
+import org.apache.seata.server.session.GlobalSession;
+import org.apache.seata.server.storage.rocksdb.RocksDBColumnFamily;
+import org.apache.seata.server.storage.rocksdb.RocksDBKeyCodec;
+import org.apache.seata.server.storage.rocksdb.RocksDBStoreConfig;
+import org.apache.seata.server.storage.rocksdb.RocksDBStoreEngine;
+import org.apache.seata.server.storage.rocksdb.store.RocksDBTransactionStoreManager;
+import org.apache.seata.server.store.TransactionStoreManager.LogOperation;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+import org.springframework.mock.env.MockEnvironment;
+
+import java.lang.reflect.Field;
+import java.nio.file.Path;
+import java.util.Map;
+
+class RocksDBLockManagerTest {
+
+    @TempDir
+    Path tempDir;
+
+    private Object originalEnvironment;
+
+    @BeforeEach
+    void beforeEach() {
+        originalEnvironment = ObjectHolder.INSTANCE.getObject(Constants.OBJECT_KEY_SPRING_CONFIGURABLE_ENVIRONMENT);
+        ObjectHolder.INSTANCE.setObject(Constants.OBJECT_KEY_SPRING_CONFIGURABLE_ENVIRONMENT, new MockEnvironment());
+        ConfigurationCache.clear();
+    }
+
+    @AfterEach
+    void afterEach() throws Exception {
+        ConfigurationCache.clear();
+        restoreEnvironment();
+    }
+
+    @Test
+    void testAcquireLockAllowsSameXidAndRejectsConflict() throws Exception {
+        try (RocksDBStoreEngine engine = open("conflict")) {
+            RocksDBLockManager lockManager = new RocksDBLockManager(engine);
+            BranchSession first = branchSession(1001L, 1L, "t_order:1,2");
+            BranchSession sameXid = branchSession(1001L, 2L, "t_order:1");
+            BranchSession conflict = branchSession(1002L, 3L, "t_order:2");
+
+            Assertions.assertTrue(lockManager.acquireLock(first));
+            Assertions.assertTrue(lockManager.acquireLock(sameXid));
+            Assertions.assertFalse(lockManager.acquireLock(conflict));
+        }
+    }
+
+    @Test
+    void testReleaseBranchLock() throws Exception {
+        try (RocksDBStoreEngine engine = open("release-branch")) {
+            RocksDBLockManager lockManager = new RocksDBLockManager(engine);
+            BranchSession first = branchSession(1001L, 1L, "t_order:1");
+            BranchSession next = branchSession(1002L, 2L, "t_order:1");
+
+            Assertions.assertTrue(lockManager.acquireLock(first));
+            Assertions.assertFalse(lockManager.acquireLock(next));
+            Assertions.assertTrue(lockManager.releaseLock(first));
+            Assertions.assertTrue(lockManager.acquireLock(next));
+        }
+    }
+
+    @Test
+    void testReleaseSameXidDifferentBranchDoesNotReleaseHolder() throws Exception {
+        try (RocksDBStoreEngine engine = open("release-same-xid-branch")) {
+            RocksDBLockManager lockManager = new RocksDBLockManager(engine);
+            BranchSession first = branchSession(1001L, 1L, "t_order:1");
+            BranchSession sameXid = branchSession(1001L, 2L, "t_order:1");
+            BranchSession conflict = branchSession(1002L, 3L, "t_order:1");
+
+            Assertions.assertTrue(lockManager.acquireLock(first));
+            Assertions.assertTrue(lockManager.acquireLock(sameXid));
+            Assertions.assertTrue(lockManager.releaseLock(sameXid));
+            Assertions.assertFalse(lockManager.acquireLock(conflict));
+            Assertions.assertTrue(lockManager.releaseLock(first));
+            Assertions.assertTrue(lockManager.acquireLock(conflict));
+        }
+    }
+
+    @Test
+    void testReleaseGlobalSessionLock() throws Exception {
+        try (RocksDBStoreEngine engine = open("release-global")) {
+            RocksDBLockManager lockManager = new RocksDBLockManager(engine);
+            BranchSession first = branchSession(1001L, 1L, "t_order:1");
+            BranchSession second = branchSession(1001L, 2L, "t_order:2");
+            BranchSession next = branchSession(1002L, 3L, "t_order:1,2");
+            GlobalSession globalSession = new GlobalSession("app", "group", "tx", 60000);
+            globalSession.setXid(first.getXid());
+
+            Assertions.assertTrue(lockManager.acquireLock(first));
+            Assertions.assertTrue(lockManager.acquireLock(second));
+            Assertions.assertFalse(lockManager.acquireLock(next));
+
+            Assertions.assertTrue(lockManager.releaseGlobalSessionLock(globalSession));
+            Assertions.assertTrue(lockManager.acquireLock(next));
+        }
+    }
+
+    @Test
+    void testIsLockable() throws Exception {
+        try (RocksDBStoreEngine engine = open("lockable")) {
+            RocksDBLockManager lockManager = new RocksDBLockManager(engine);
+            BranchSession first = branchSession(1001L, 1L, "t_order:1");
+
+            Assertions.assertTrue(lockManager.isLockable(first.getXid(), first.getResourceId(), first.getLockKey()));
+            Assertions.assertTrue(lockManager.acquireLock(first));
+            Assertions.assertTrue(lockManager.isLockable(first.getXid(), first.getResourceId(), first.getLockKey()));
+            Assertions.assertFalse(lockManager.isLockable(xid(1002L), first.getResourceId(), first.getLockKey()));
+        }
+    }
+
+    @Test
+    void testRollbackingConflictFailFast() throws Exception {
+        try (RocksDBStoreEngine engine = open("rollbacking")) {
+            RocksDBLockManager lockManager = new RocksDBLockManager(engine);
+            BranchSession first = branchSession(1001L, 1L, "t_order:1");
+            BranchSession conflict = branchSession(1002L, 2L, "t_order:1");
+
+            Assertions.assertTrue(lockManager.acquireLock(first));
+            lockManager.updateLockStatus(first.getXid(), LockStatus.Rollbacking);
+
+            StoreException exception = Assertions.assertThrows(
+                    StoreException.class, () -> lockManager.acquireLock(conflict, false, false));
+            Assertions.assertTrue(exception.getCause() instanceof BranchTransactionException);
+        }
+    }
+
+    @Test
+    void testSkipCheckLockDoesNotOverwriteExistingLock() throws Exception {
+        try (RocksDBStoreEngine engine = open("skip-check")) {
+            RocksDBLockManager lockManager = new RocksDBLockManager(engine);
+            BranchSession first = branchSession(1001L, 1L, "t_order:1");
+            BranchSession conflict = branchSession(1002L, 2L, "t_order:1");
+
+            Assertions.assertTrue(lockManager.acquireLock(first));
+            Assertions.assertFalse(lockManager.acquireLock(conflict, true, true));
+            Assertions.assertFalse(
+                    lockManager.isLockable(conflict.getXid(), conflict.getResourceId(), conflict.getLockKey()));
+        }
+    }
+
+    @Test
+    void testCleanAllLocks() throws Exception {
+        try (RocksDBStoreEngine engine = open("clean")) {
+            RocksDBLockManager lockManager = new RocksDBLockManager(engine);
+            BranchSession first = branchSession(1001L, 1L, "t_order:1");
+
+            Assertions.assertTrue(lockManager.acquireLock(first));
+            lockManager.cleanAllLocks();
+
+            Assertions.assertTrue(
+                    engine.prefixScan(RocksDBColumnFamily.LOCK, new byte[0]).isEmpty());
+            Assertions.assertTrue(engine.prefixScan(RocksDBColumnFamily.LOCK_BRANCH_INDEX, new byte[0])
+                    .isEmpty());
+        }
+    }
+
+    @Test
+    void testCleanOrphanLocksRemovesLockWithoutBranchSession() throws Exception {
+        try (RocksDBStoreEngine engine = open("clean-orphan")) {
+            RocksDBLockManager lockManager = new RocksDBLockManager(engine);
+            BranchSession orphan = branchSession(1001L, 1L, "t_order:1");
+            BranchSession next = branchSession(1002L, 2L, "t_order:1");
+
+            Assertions.assertTrue(lockManager.acquireLock(orphan));
+            Assertions.assertFalse(lockManager.acquireLock(next));
+
+            Assertions.assertEquals(1, lockManager.cleanOrphanLocks());
+            Assertions.assertTrue(lockManager.acquireLock(next));
+        }
+    }
+
+    @Test
+    void testCleanOrphanLocksKeepsLockWithBranchSession() throws Exception {
+        try (RocksDBStoreEngine engine = open("clean-valid")) {
+            RocksDBLockManager lockManager = new RocksDBLockManager(engine);
+            RocksDBTransactionStoreManager storeManager = new RocksDBTransactionStoreManager(engine);
+            BranchSession holder = branchSession(1001L, 1L, "t_order:1");
+            BranchSession conflict = branchSession(1002L, 2L, "t_order:1");
+
+            storeManager.writeSession(LogOperation.BRANCH_ADD, holder);
+            Assertions.assertTrue(lockManager.acquireLock(holder));
+
+            Assertions.assertEquals(0, lockManager.cleanOrphanLocks());
+            Assertions.assertFalse(lockManager.acquireLock(conflict));
+        }
+    }
+
+    @Test
+    void testCleanOrphanLocksDeletesStaleIndexWithoutLockValue() throws Exception {
+        try (RocksDBStoreEngine engine = open("clean-stale-index")) {
+            RocksDBLockManager lockManager = new RocksDBLockManager(engine);
+            BranchSession holder = branchSession(1001L, 1L, "t_order:1");
+            byte[] lockKey = RocksDBKeyCodec.encodeRowLock(holder.getResourceId(), "t_order", "1");
+
+            engine.put(
+                    RocksDBColumnFamily.LOCK_BRANCH_INDEX,
+                    RocksDBKeyCodec.encodeLockBranchIndex(holder.getXid(), holder.getBranchId(), lockKey),
+                    lockKey);
+
+            Assertions.assertEquals(1, lockManager.cleanOrphanLocks());
+            Assertions.assertTrue(engine.prefixScan(RocksDBColumnFamily.LOCK_BRANCH_INDEX, new byte[0])
+                    .isEmpty());
+        }
+    }
+
+    private RocksDBStoreEngine open(String name) {
+        return RocksDBStoreEngine.open(
+                new RocksDBStoreConfig(tempDir.resolve(name).toString(), true));
+    }
+
+    private BranchSession branchSession(long transactionId, long branchId, String lockKey) {
+        BranchSession branchSession = new BranchSession(BranchType.AT);
+        branchSession.setXid(xid(transactionId));
+        branchSession.setTransactionId(transactionId);
+        branchSession.setBranchId(branchId);
+        branchSession.setStatus(BranchStatus.Registered);
+        branchSession.setResourceId("jdbc:mysql://127.0.0.1/db");
+        branchSession.setLockKey(lockKey);
+        return branchSession;
+    }
+
+    private String xid(long transactionId) {
+        return "127.0.0.1:8091:" + transactionId;
+    }
+
+    @SuppressWarnings("unchecked")
+    private void restoreEnvironment() throws Exception {
+        Field field = ObjectHolder.class.getDeclaredField("OBJECT_MAP");
+        field.setAccessible(true);
+        Map<String, Object> objectMap = (Map<String, Object>) field.get(ObjectHolder.INSTANCE);
+        if (originalEnvironment == null) {
+            objectMap.remove(Constants.OBJECT_KEY_SPRING_CONFIGURABLE_ENVIRONMENT);
+        } else {
+            objectMap.put(Constants.OBJECT_KEY_SPRING_CONFIGURABLE_ENVIRONMENT, originalEnvironment);
+        }
+    }
+}
diff --git a/server/src/test/java/org/apache/seata/server/storage/rocksdb/migration/RocksDBMigrationServiceTest.java b/server/src/test/java/org/apache/seata/server/storage/rocksdb/migration/RocksDBMigrationServiceTest.java
new file mode 100644
index 00000000000..d7540f8d257
--- /dev/null
+++ b/server/src/test/java/org/apache/seata/server/storage/rocksdb/migration/RocksDBMigrationServiceTest.java
@@ -0,0 +1,253 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.seata.server.storage.rocksdb.migration;
+
+import org.apache.seata.common.Constants;
+import org.apache.seata.common.exception.StoreException;
+import org.apache.seata.common.holder.ObjectHolder;
+import org.apache.seata.config.ConfigurationCache;
+import org.apache.seata.core.model.BranchStatus;
+import org.apache.seata.core.model.BranchType;
+import org.apache.seata.core.model.GlobalStatus;
+import org.apache.seata.server.lock.LockerManagerFactory;
+import org.apache.seata.server.session.BranchSession;
+import org.apache.seata.server.session.GlobalSession;
+import org.apache.seata.server.session.SessionCondition;
+import org.apache.seata.server.storage.file.TransactionWriteStore;
+import org.apache.seata.server.storage.file.store.FileSessionLogReplayer;
+import org.apache.seata.server.storage.rocksdb.RocksDBColumnFamily;
+import org.apache.seata.server.storage.rocksdb.RocksDBStoreConfig;
+import org.apache.seata.server.storage.rocksdb.RocksDBStoreEngine;
+import org.apache.seata.server.storage.rocksdb.RocksDBStoreEngineFactory;
+import org.apache.seata.server.storage.rocksdb.store.RocksDBTransactionStoreManager;
+import org.apache.seata.server.store.SessionStorable;
+import org.apache.seata.server.store.StoreConfig;
+import org.apache.seata.server.store.TransactionStoreManager.LogOperation;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+import org.springframework.mock.env.MockEnvironment;
+
+import java.io.IOException;
+import java.lang.reflect.Field;
+import java.nio.ByteBuffer;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardOpenOption;
+import java.util.Map;
+
+class RocksDBMigrationServiceTest {
+
+    @TempDir
+    Path tempDir;
+
+    private Object originalEnvironment;
+
+    @BeforeEach
+    void beforeEach() {
+        originalEnvironment = ObjectHolder.INSTANCE.getObject(Constants.OBJECT_KEY_SPRING_CONFIGURABLE_ENVIRONMENT);
+        ObjectHolder.INSTANCE.setObject(Constants.OBJECT_KEY_SPRING_CONFIGURABLE_ENVIRONMENT, new MockEnvironment());
+        ConfigurationCache.clear();
+    }
+
+    @AfterEach
+    void afterEach() throws Exception {
+        LockerManagerFactory.destroy();
+        RocksDBStoreEngineFactory.destroy();
+        ConfigurationCache.clear();
+        restoreEnvironment();
+    }
+
+    @Test
+    void testMigratesFileSessionsToRocksDBCurrentState() throws Exception {
+        Path fileLog = tempDir.resolve("file").resolve("root.data");
+        GlobalSession active = globalSession("tx-active", GlobalStatus.Begin);
+        BranchSession branch = branchSession(active, 1L);
+        GlobalSession committed = globalSession("tx-committed", GlobalStatus.Committed);
+        appendLog(fileLog, active, LogOperation.GLOBAL_ADD);
+        appendLog(fileLog, branch, LogOperation.BRANCH_ADD);
+        appendLog(fileLog, committed, LogOperation.GLOBAL_ADD);
+
+        try (RocksDBStoreEngine engine = open("rocksdb-current-state")) {
+            RocksDBMigrationService migrationService = new RocksDBMigrationService();
+
+            Assertions.assertTrue(migrationService.migrate(fileLog, engine));
+            Assertions.assertEquals(RocksDBMigrationService.MIGRATION_STATUS_COMPLETED, getMigrationStatus(engine));
+
+            RocksDBTransactionStoreManager storeManager = new RocksDBTransactionStoreManager(engine);
+            GlobalSession actual = storeManager.readSession(active.getXid(), true);
+            Assertions.assertNotNull(actual);
+            Assertions.assertEquals(1, actual.getBranchSessions().size());
+            Assertions.assertEquals(
+                    branch.getBranchId(), actual.getBranchSessions().get(0).getBranchId());
+            Assertions.assertNull(storeManager.readSession(committed.getXid(), true));
+            SessionCondition transactionIdCondition = new SessionCondition();
+            transactionIdCondition.setTransactionId(active.getTransactionId());
+            Assertions.assertEquals(
+                    active.getXid(),
+                    storeManager.readSession(transactionIdCondition).get(0).getXid());
+            Assertions.assertEquals(
+                    active.getXid(),
+                    storeManager
+                            .readSession(new GlobalStatus[] {GlobalStatus.Begin}, false)
+                            .get(0)
+                            .getXid());
+            Assertions.assertTrue(Files.isRegularFile(migrationMarker(fileLog)));
+
+            Assertions.assertFalse(migrationService.migrate(fileLog, engine));
+        }
+    }
+
+    @Test
+    void testInterruptedMigrationWithoutSourceFailsFast() {
+        try (RocksDBStoreEngine engine = open("rocksdb-missing-source")) {
+            putMigrationStatus(engine, RocksDBMigrationService.MIGRATION_STATUS_IN_PROGRESS);
+
+            StoreException exception = Assertions.assertThrows(StoreException.class, () -> new RocksDBMigrationService()
+                    .migrate(tempDir.resolve("missing").resolve("root.data"), engine));
+            Assertions.assertTrue(exception.getMessage().contains("source file logs are missing"));
+        }
+    }
+
+    @Test
+    void testCurrentStateWithoutMigrationStatusFailsFast() {
+        try (RocksDBStoreEngine engine = open("rocksdb-missing-status")) {
+            RocksDBTransactionStoreManager storeManager = new RocksDBTransactionStoreManager(engine);
+            storeManager.writeSession(LogOperation.GLOBAL_ADD, globalSession("tx-existing", GlobalStatus.Begin));
+
+            StoreException exception = Assertions.assertThrows(StoreException.class, () -> new RocksDBMigrationService()
+                    .migrate(tempDir.resolve("missing").resolve("root.data"), engine));
+            Assertions.assertTrue(exception.getMessage().contains("without migration status"));
+        }
+    }
+
+    @Test
+    void testInterruptedMigrationClearsAndReplays() throws Exception {
+        Path fileLog = tempDir.resolve("file").resolve("root.data");
+        GlobalSession stale = globalSession("tx-stale", GlobalStatus.Begin);
+        GlobalSession active = globalSession("tx-replayed", GlobalStatus.Begin);
+        appendLog(fileLog, active, LogOperation.GLOBAL_ADD);
+
+        try (RocksDBStoreEngine engine = open("rocksdb-replay")) {
+            RocksDBTransactionStoreManager storeManager = new RocksDBTransactionStoreManager(engine);
+            storeManager.writeSession(LogOperation.GLOBAL_ADD, stale);
+            putMigrationStatus(engine, RocksDBMigrationService.MIGRATION_STATUS_IN_PROGRESS);
+
+            Assertions.assertTrue(new RocksDBMigrationService().migrate(fileLog, engine));
+
+            Assertions.assertNull(storeManager.readSession(stale.getXid(), true));
+            Assertions.assertNotNull(storeManager.readSession(active.getXid(), true));
+            Assertions.assertEquals(RocksDBMigrationService.MIGRATION_STATUS_COMPLETED, getMigrationStatus(engine));
+        }
+    }
+
+    @Test
+    void testMigratedFileLogsWithoutRocksDBMetadataFailFast() throws Exception {
+        Path fileLog = tempDir.resolve("file").resolve("root.data");
+        appendLog(fileLog, globalSession("tx-active", GlobalStatus.Begin), LogOperation.GLOBAL_ADD);
+        new FileSessionLogReplayer().markMigrated(fileLog);
+
+        try (RocksDBStoreEngine engine = open("rocksdb-migrated-marker")) {
+            StoreException exception = Assertions.assertThrows(
+                    StoreException.class, () -> new RocksDBMigrationService().migrate(fileLog, engine));
+            Assertions.assertTrue(exception.getMessage().contains("already migrated"));
+        }
+    }
+
+    @Test
+    void testReplayRejectsOversizedBody() throws Exception {
+        Path fileLog = tempDir.resolve("file").resolve("root.data");
+        appendFrameSize(fileLog, StoreConfig.getMaxBranchSessionSize() + 2);
+
+        try (RocksDBStoreEngine engine = open("rocksdb-oversized-frame")) {
+            StoreException exception = Assertions.assertThrows(
+                    StoreException.class, () -> new RocksDBMigrationService().migrate(fileLog, engine));
+            Assertions.assertTrue(exception.getMessage().contains("exceeds limit"));
+        }
+    }
+
+    private RocksDBStoreEngine open(String name) {
+        return RocksDBStoreEngine.open(
+                new RocksDBStoreConfig(tempDir.resolve(name).toString(), true));
+    }
+
+    private GlobalSession globalSession(String name, GlobalStatus status) {
+        GlobalSession globalSession = new GlobalSession("app", "group", name, 60000);
+        globalSession.setStatus(status);
+        return globalSession;
+    }
+
+    private BranchSession branchSession(GlobalSession globalSession, long branchId) {
+        BranchSession branchSession = new BranchSession(BranchType.AT);
+        branchSession.setXid(globalSession.getXid());
+        branchSession.setTransactionId(globalSession.getTransactionId());
+        branchSession.setBranchId(branchId);
+        branchSession.setStatus(BranchStatus.Registered);
+        branchSession.setResourceId("jdbc:mysql://127.0.0.1/db");
+        branchSession.setLockKey("t_order:1");
+        return branchSession;
+    }
+
+    private void appendLog(Path fileLog, SessionStorable session, LogOperation logOperation) throws IOException {
+        byte[] data = new TransactionWriteStore(session, logOperation).encode();
+        ByteBuffer buffer = ByteBuffer.allocate(Integer.BYTES + data.length);
+        buffer.putInt(data.length);
+        buffer.put(data);
+        Files.createDirectories(fileLog.getParent());
+        Files.write(fileLog, buffer.array(), StandardOpenOption.CREATE, StandardOpenOption.APPEND);
+    }
+
+    private void appendFrameSize(Path fileLog, int bodySize) throws IOException {
+        ByteBuffer buffer = ByteBuffer.allocate(Integer.BYTES);
+        buffer.putInt(bodySize);
+        Files.createDirectories(fileLog.getParent());
+        Files.write(fileLog, buffer.array(), StandardOpenOption.CREATE, StandardOpenOption.APPEND);
+    }
+
+    private Path migrationMarker(Path fileLog) {
+        return fileLog.resolveSibling(fileLog.getFileName() + ".rocksdb_migrated");
+    }
+
+    private String getMigrationStatus(RocksDBStoreEngine engine) {
+        byte[] value = engine.get(
+                RocksDBColumnFamily.METADATA,
+                RocksDBMigrationService.MIGRATION_STATUS_KEY.getBytes(StandardCharsets.UTF_8));
+        return value == null ? null : new String(value, StandardCharsets.UTF_8);
+    }
+
+    private void putMigrationStatus(RocksDBStoreEngine engine, String migrationStatus) {
+        engine.put(
+                RocksDBColumnFamily.METADATA,
+                RocksDBMigrationService.MIGRATION_STATUS_KEY.getBytes(StandardCharsets.UTF_8),
+                migrationStatus.getBytes(StandardCharsets.UTF_8));
+    }
+
+    @SuppressWarnings("unchecked")
+    private void restoreEnvironment() throws Exception {
+        Field field = ObjectHolder.class.getDeclaredField("OBJECT_MAP");
+        field.setAccessible(true);
+        Map<String, Object> objectMap = (Map<String, Object>) field.get(ObjectHolder.INSTANCE);
+        if (originalEnvironment == null) {
+            objectMap.remove(Constants.OBJECT_KEY_SPRING_CONFIGURABLE_ENVIRONMENT);
+        } else {
+            objectMap.put(Constants.OBJECT_KEY_SPRING_CONFIGURABLE_ENVIRONMENT, originalEnvironment);
+        }
+    }
+}
diff --git a/server/src/test/java/org/apache/seata/server/storage/rocksdb/session/RocksDBSessionManagerTest.java b/server/src/test/java/org/apache/seata/server/storage/rocksdb/session/RocksDBSessionManagerTest.java
new file mode 100644
index 00000000000..b52ad947b51
--- /dev/null
+++ b/server/src/test/java/org/apache/seata/server/storage/rocksdb/session/RocksDBSessionManagerTest.java
@@ -0,0 +1,319 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.seata.server.storage.rocksdb.session;
+
+import org.apache.seata.common.Constants;
+import org.apache.seata.common.holder.ObjectHolder;
+import org.apache.seata.config.ConfigurationCache;
+import org.apache.seata.core.model.BranchStatus;
+import org.apache.seata.core.model.BranchType;
+import org.apache.seata.core.model.GlobalStatus;
+import org.apache.seata.server.session.BranchSession;
+import org.apache.seata.server.session.GlobalSession;
+import org.apache.seata.server.session.SessionCondition;
+import org.apache.seata.server.storage.rocksdb.RocksDBStoreConfig;
+import org.apache.seata.server.storage.rocksdb.RocksDBStoreEngine;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+import org.springframework.mock.env.MockEnvironment;
+
+import java.lang.reflect.Field;
+import java.nio.file.Path;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.stream.Collectors;
+
+class RocksDBSessionManagerTest {
+
+    @TempDir
+    Path tempDir;
+
+    private Object originalEnvironment;
+
+    @BeforeEach
+    void beforeEach() {
+        originalEnvironment = ObjectHolder.INSTANCE.getObject(Constants.OBJECT_KEY_SPRING_CONFIGURABLE_ENVIRONMENT);
+        ObjectHolder.INSTANCE.setObject(Constants.OBJECT_KEY_SPRING_CONFIGURABLE_ENVIRONMENT, new MockEnvironment());
+        ConfigurationCache.clear();
+    }
+
+    @AfterEach
+    void afterEach() throws Exception {
+        ConfigurationCache.clear();
+        restoreEnvironment();
+    }
+
+    @Test
+    void testGlobalSessionLifecycle() throws Exception {
+        try (RocksDBStoreEngine engine = open("global")) {
+            RocksDBSessionManager sessionManager = new RocksDBSessionManager("root.data", engine);
+            GlobalSession globalSession = globalSession("tx-global", GlobalStatus.Begin);
+
+            sessionManager.addGlobalSession(globalSession);
+
+            GlobalSession found = sessionManager.findGlobalSession(globalSession.getXid(), false);
+            Assertions.assertNotNull(found);
+            Assertions.assertEquals(GlobalStatus.Begin, found.getStatus());
+
+            sessionManager.updateGlobalSessionStatus(globalSession, GlobalStatus.Committing);
+            Assertions.assertEquals(
+                    GlobalStatus.Committing,
+                    sessionManager
+                            .findGlobalSession(globalSession.getXid(), false)
+                            .getStatus());
+
+            sessionManager.removeGlobalSession(globalSession);
+            Assertions.assertNull(sessionManager.findGlobalSession(globalSession.getXid()));
+        }
+    }
+
+    @Test
+    void testBranchSessionLifecycle() throws Exception {
+        try (RocksDBStoreEngine engine = open("branch")) {
+            RocksDBSessionManager sessionManager = new RocksDBSessionManager("root.data", engine);
+            GlobalSession globalSession = globalSession("tx-branch", GlobalStatus.Begin);
+            BranchSession branchSession = branchSession(globalSession, 1L);
+
+            sessionManager.addGlobalSession(globalSession);
+            sessionManager.addBranchSession(globalSession, branchSession);
+
+            GlobalSession found = sessionManager.findGlobalSession(globalSession.getXid(), true);
+            Assertions.assertEquals(1, found.getBranchSessions().size());
+            Assertions.assertEquals(
+                    branchSession.getBranchId(),
+                    found.getBranchSessions().get(0).getBranchId());
+
+            branchSession.setStatus(BranchStatus.PhaseOne_Done);
+            sessionManager.updateBranchSessionStatus(branchSession, BranchStatus.PhaseOne_Done);
+            found = sessionManager.findGlobalSession(globalSession.getXid(), true);
+            Assertions.assertEquals(
+                    BranchStatus.PhaseOne_Done, found.getBranchSessions().get(0).getStatus());
+
+            sessionManager.removeBranchSession(globalSession, branchSession);
+            Assertions.assertTrue(sessionManager
+                    .findGlobalSession(globalSession.getXid(), true)
+                    .getBranchSessions()
+                    .isEmpty());
+        }
+    }
+
+    @Test
+    void testFindGlobalSessionsAndAllSessions() throws Exception {
+        try (RocksDBStoreEngine engine = open("query")) {
+            RocksDBSessionManager sessionManager = new RocksDBSessionManager("root.data", engine);
+            GlobalSession begin = globalSession("tx-begin", GlobalStatus.Begin);
+            GlobalSession committed = globalSession("tx-committed", GlobalStatus.Committed);
+            GlobalSession commitRetryTimeout =
+                    globalSession("tx-commit-retry-timeout", GlobalStatus.CommitRetryTimeout);
+            GlobalSession rollbacked = globalSession("tx-rollbacked", GlobalStatus.Rollbacked);
+            GlobalSession rollbackRetryTimeout =
+                    globalSession("tx-rollback-retry-timeout", GlobalStatus.RollbackRetryTimeout);
+            GlobalSession timeoutRollbacked = globalSession("tx-timeout-rollbacked", GlobalStatus.TimeoutRollbacked);
+            GlobalSession finished = globalSession("tx-finished", GlobalStatus.Finished);
+
+            sessionManager.addGlobalSession(begin);
+            sessionManager.addGlobalSession(committed);
+            sessionManager.addGlobalSession(commitRetryTimeout);
+            sessionManager.addGlobalSession(rollbacked);
+            sessionManager.addGlobalSession(rollbackRetryTimeout);
+            sessionManager.addGlobalSession(timeoutRollbacked);
+            sessionManager.addGlobalSession(finished);
+
+            SessionCondition condition = new SessionCondition(GlobalStatus.Begin);
+            condition.setLazyLoadBranch(true);
+            List<GlobalSession> beginSessions = sessionManager.findGlobalSessions(condition);
+            Assertions.assertEquals(1, beginSessions.size());
+            Assertions.assertEquals(begin.getXid(), beginSessions.get(0).getXid());
+
+            condition = new SessionCondition();
+            condition.setTransactionId(committed.getTransactionId());
+            List<GlobalSession> byTransactionId = sessionManager.findGlobalSessions(condition);
+            Assertions.assertEquals(1, byTransactionId.size());
+            Assertions.assertEquals(committed.getXid(), byTransactionId.get(0).getXid());
+
+            Collection<GlobalSession> allSessions = sessionManager.allSessions();
+            Assertions.assertEquals(7, allSessions.size());
+            Assertions.assertTrue(contains(allSessions, begin));
+            Assertions.assertTrue(contains(allSessions, committed));
+            Assertions.assertTrue(contains(allSessions, commitRetryTimeout));
+            Assertions.assertTrue(contains(allSessions, rollbacked));
+            Assertions.assertTrue(contains(allSessions, rollbackRetryTimeout));
+            Assertions.assertTrue(contains(allSessions, timeoutRollbacked));
+            Assertions.assertTrue(contains(allSessions, finished));
+        }
+    }
+
+    @Test
+    void testCoordinatorStatusQueries() throws Exception {
+        try (RocksDBStoreEngine engine = open("coordinator-query")) {
+            RocksDBSessionManager sessionManager = new RocksDBSessionManager("root.data", engine);
+            GlobalSession begin = globalSession("tx-timeout-begin", GlobalStatus.Begin);
+            GlobalSession timeoutRollbacking = globalSession("tx-timeout-rollbacking", GlobalStatus.TimeoutRollbacking);
+            GlobalSession timeoutRollbackRetrying =
+                    globalSession("tx-timeout-rollback-retrying", GlobalStatus.TimeoutRollbackRetrying);
+            GlobalSession rollbackRetrying = globalSession("tx-rollback-retrying", GlobalStatus.RollbackRetrying);
+            GlobalSession commitRetrying = globalSession("tx-commit-retrying", GlobalStatus.CommitRetrying);
+            GlobalSession rollbacking = globalSession("tx-rollbacking", GlobalStatus.Rollbacking);
+            GlobalSession committing = globalSession("tx-committing", GlobalStatus.Committing);
+            GlobalSession asyncCommitting = globalSession("tx-async-committing", GlobalStatus.AsyncCommitting);
+            GlobalSession rollbacked = globalSession("tx-rollbacked-end", GlobalStatus.Rollbacked);
+            GlobalSession timeoutRollbacked =
+                    globalSession("tx-timeout-rollbacked-end", GlobalStatus.TimeoutRollbacked);
+            GlobalSession committed = globalSession("tx-committed-end", GlobalStatus.Committed);
+            GlobalSession finished = globalSession("tx-finished-end", GlobalStatus.Finished);
+
+            for (GlobalSession globalSession : Arrays.asList(
+                    begin,
+                    timeoutRollbacking,
+                    timeoutRollbackRetrying,
+                    rollbackRetrying,
+                    commitRetrying,
+                    rollbacking,
+                    committing,
+                    asyncCommitting,
+                    rollbacked,
+                    timeoutRollbacked,
+                    committed,
+                    finished)) {
+                sessionManager.addGlobalSession(globalSession);
+            }
+            sessionManager.addBranchSession(commitRetrying, branchSession(commitRetrying, 1001L));
+
+            SessionCondition timeoutCondition = new SessionCondition(GlobalStatus.Begin);
+            timeoutCondition.setLazyLoadBranch(true);
+            List<GlobalSession> timeoutSessions = sessionManager.findGlobalSessions(timeoutCondition);
+            assertXids(timeoutSessions, begin.getXid());
+            Assertions.assertTrue(timeoutSessions.get(0).isLazyLoadBranch());
+
+            SessionCondition retryRollbackingCondition = new SessionCondition(
+                    GlobalStatus.TimeoutRollbacking,
+                    GlobalStatus.TimeoutRollbackRetrying,
+                    GlobalStatus.RollbackRetrying);
+            retryRollbackingCondition.setLazyLoadBranch(true);
+            assertXids(
+                    sessionManager.findGlobalSessions(retryRollbackingCondition),
+                    timeoutRollbacking.getXid(),
+                    timeoutRollbackRetrying.getXid(),
+                    rollbackRetrying.getXid());
+
+            SessionCondition retryCommittingCondition = new SessionCondition(GlobalStatus.CommitRetrying);
+            retryCommittingCondition.setLazyLoadBranch(true);
+            List<GlobalSession> retryCommittingSessions = sessionManager.findGlobalSessions(retryCommittingCondition);
+            assertXids(retryCommittingSessions, commitRetrying.getXid());
+            Assertions.assertTrue(retryCommittingSessions.get(0).isLazyLoadBranch());
+
+            retryCommittingCondition.setLazyLoadBranch(false);
+            retryCommittingSessions = sessionManager.findGlobalSessions(retryCommittingCondition);
+            assertXids(retryCommittingSessions, commitRetrying.getXid());
+            Assertions.assertFalse(retryCommittingSessions.get(0).isLazyLoadBranch());
+            Assertions.assertEquals(
+                    1, retryCommittingSessions.get(0).getBranchSessions().size());
+
+            assertXids(
+                    sessionManager.findGlobalSessions(new SessionCondition(GlobalStatus.Rollbacking)),
+                    rollbacking.getXid());
+            assertXids(
+                    sessionManager.findGlobalSessions(new SessionCondition(GlobalStatus.Committing)),
+                    committing.getXid());
+            assertXids(
+                    sessionManager.findGlobalSessions(new SessionCondition(GlobalStatus.AsyncCommitting)),
+                    asyncCommitting.getXid());
+
+            SessionCondition endStateCondition = new SessionCondition(
+                    GlobalStatus.Rollbacked,
+                    GlobalStatus.TimeoutRollbacked,
+                    GlobalStatus.Committed,
+                    GlobalStatus.Finished);
+            endStateCondition.setLazyLoadBranch(true);
+            assertXids(
+                    sessionManager.findGlobalSessions(endStateCondition),
+                    rollbacked.getXid(),
+                    timeoutRollbacked.getXid(),
+                    committed.getXid(),
+                    finished.getXid());
+        }
+    }
+
+    @Test
+    void testLockAndExecute() throws Exception {
+        try (RocksDBStoreEngine engine = open("lock")) {
+            RocksDBSessionManager sessionManager = new RocksDBSessionManager("root.data", engine);
+            GlobalSession globalSession = globalSession("tx-lock", GlobalStatus.Begin);
+            AtomicBoolean called = new AtomicBoolean(false);
+
+            Boolean actual = sessionManager.lockAndExecute(globalSession, () -> {
+                called.set(true);
+                return true;
+            });
+
+            Assertions.assertTrue(actual);
+            Assertions.assertTrue(called.get());
+        }
+    }
+
+    private RocksDBStoreEngine open(String name) {
+        return RocksDBStoreEngine.open(
+                new RocksDBStoreConfig(tempDir.resolve(name).toString(), true));
+    }
+
+    private GlobalSession globalSession(String name, GlobalStatus status) {
+        GlobalSession globalSession = new GlobalSession("app", "group", name, 60000);
+        globalSession.setStatus(status);
+        return globalSession;
+    }
+
+    private BranchSession branchSession(GlobalSession globalSession, long branchId) {
+        BranchSession branchSession = new BranchSession(BranchType.AT);
+        branchSession.setXid(globalSession.getXid());
+        branchSession.setTransactionId(globalSession.getTransactionId());
+        branchSession.setBranchId(branchId);
+        branchSession.setStatus(BranchStatus.Registered);
+        branchSession.setResourceId("jdbc:mysql://127.0.0.1/db");
+        branchSession.setLockKey("t_order:1");
+        return branchSession;
+    }
+
+    private boolean contains(Collection<GlobalSession> sessions, GlobalSession expected) {
+        return sessions.stream().anyMatch(session -> expected.getXid().equals(session.getXid()));
+    }
+
+    private void assertXids(Collection<GlobalSession> sessions, String... xids) {
+        Assertions.assertEquals(xids.length, sessions.size());
+        Set<String> actual = sessions.stream().map(GlobalSession::getXid).collect(Collectors.toSet());
+        Assertions.assertEquals(new HashSet<>(Arrays.asList(xids)), actual);
+    }
+
+    @SuppressWarnings("unchecked")
+    private void restoreEnvironment() throws Exception {
+        Field field = ObjectHolder.class.getDeclaredField("OBJECT_MAP");
+        field.setAccessible(true);
+        Map<String, Object> objectMap = (Map<String, Object>) field.get(ObjectHolder.INSTANCE);
+        if (originalEnvironment == null) {
+            objectMap.remove(Constants.OBJECT_KEY_SPRING_CONFIGURABLE_ENVIRONMENT);
+        } else {
+            objectMap.put(Constants.OBJECT_KEY_SPRING_CONFIGURABLE_ENVIRONMENT, originalEnvironment);
+        }
+    }
+}
diff --git a/server/src/test/java/org/apache/seata/server/storage/rocksdb/store/RocksDBTransactionStoreManagerTest.java b/server/src/test/java/org/apache/seata/server/storage/rocksdb/store/RocksDBTransactionStoreManagerTest.java
new file mode 100644
index 00000000000..1642df284b8
--- /dev/null
+++ b/server/src/test/java/org/apache/seata/server/storage/rocksdb/store/RocksDBTransactionStoreManagerTest.java
@@ -0,0 +1,385 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.seata.server.storage.rocksdb.store;
+
+import org.apache.seata.common.Constants;
+import org.apache.seata.common.holder.ObjectHolder;
+import org.apache.seata.config.ConfigurationCache;
+import org.apache.seata.core.model.BranchStatus;
+import org.apache.seata.core.model.BranchType;
+import org.apache.seata.core.model.GlobalStatus;
+import org.apache.seata.server.session.BranchSession;
+import org.apache.seata.server.session.GlobalSession;
+import org.apache.seata.server.session.SessionCondition;
+import org.apache.seata.server.session.SessionHolder;
+import org.apache.seata.server.session.SessionManager;
+import org.apache.seata.server.storage.rocksdb.RocksDBColumnFamily;
+import org.apache.seata.server.storage.rocksdb.RocksDBKeyCodec;
+import org.apache.seata.server.storage.rocksdb.RocksDBStoreConfig;
+import org.apache.seata.server.storage.rocksdb.RocksDBStoreEngine;
+import org.apache.seata.server.storage.rocksdb.session.RocksDBSessionManager;
+import org.apache.seata.server.store.TransactionStoreManager.LogOperation;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+import org.springframework.mock.env.MockEnvironment;
+
+import java.lang.reflect.Field;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Map;
+
+class RocksDBTransactionStoreManagerTest {
+
+    @TempDir
+    Path tempDir;
+
+    private Object originalEnvironment;
+    private SessionManager originalRootSessionManager;
+    private Map<String, SessionManager> originalSessionManagerMap;
+
+    @BeforeEach
+    void beforeEach() throws Exception {
+        originalEnvironment = ObjectHolder.INSTANCE.getObject(Constants.OBJECT_KEY_SPRING_CONFIGURABLE_ENVIRONMENT);
+        ObjectHolder.INSTANCE.setObject(Constants.OBJECT_KEY_SPRING_CONFIGURABLE_ENVIRONMENT, new MockEnvironment());
+        ConfigurationCache.clear();
+        originalRootSessionManager = getRootSessionManager();
+        originalSessionManagerMap = getSessionManagerMap();
+    }
+
+    @AfterEach
+    void afterEach() throws Exception {
+        ConfigurationCache.clear();
+        restoreSessionHolder();
+        restoreEnvironment();
+    }
+
+    @Test
+    void testWriteAndReadGlobalSession() {
+        try (RocksDBStoreEngine engine = open("global")) {
+            RocksDBTransactionStoreManager storeManager = new RocksDBTransactionStoreManager(engine);
+            GlobalSession globalSession = globalSession("tx-global", GlobalStatus.Begin);
+
+            Assertions.assertTrue(storeManager.writeSession(LogOperation.GLOBAL_ADD, globalSession));
+
+            GlobalSession actual = storeManager.readSession(globalSession.getXid(), false);
+            Assertions.assertNotNull(actual);
+            Assertions.assertEquals(globalSession.getXid(), actual.getXid());
+            Assertions.assertEquals(GlobalStatus.Begin, actual.getStatus());
+            Assertions.assertTrue(actual.isLazyLoadBranch());
+        }
+    }
+
+    @Test
+    void testReadGlobalSessionWithBranches() {
+        try (RocksDBStoreEngine engine = open("branches")) {
+            RocksDBTransactionStoreManager storeManager = new RocksDBTransactionStoreManager(engine);
+            GlobalSession globalSession = globalSession("tx-branches", GlobalStatus.Begin);
+            BranchSession branchSession = branchSession(globalSession, 1L);
+
+            storeManager.writeSession(LogOperation.GLOBAL_ADD, globalSession);
+            storeManager.writeSession(LogOperation.BRANCH_ADD, branchSession);
+
+            GlobalSession actual = storeManager.readSession(globalSession.getXid(), true);
+
+            Assertions.assertNotNull(actual);
+            Assertions.assertEquals(1, actual.getBranchSessions().size());
+            Assertions.assertEquals(
+                    branchSession.getBranchId(),
+                    actual.getBranchSessions().get(0).getBranchId());
+        }
+    }
+
+    @Test
+    void testRemoveBranchAndGlobalSession() {
+        try (RocksDBStoreEngine engine = open("remove")) {
+            RocksDBTransactionStoreManager storeManager = new RocksDBTransactionStoreManager(engine);
+            GlobalSession globalSession = globalSession("tx-remove", GlobalStatus.Begin);
+            BranchSession branch1 = branchSession(globalSession, 1L);
+            BranchSession branch2 = branchSession(globalSession, 2L);
+
+            storeManager.writeSession(LogOperation.GLOBAL_ADD, globalSession);
+            storeManager.writeSession(LogOperation.BRANCH_ADD, branch1);
+            storeManager.writeSession(LogOperation.BRANCH_ADD, branch2);
+            storeManager.writeSession(LogOperation.BRANCH_REMOVE, branch1);
+
+            Assertions.assertEquals(
+                    1,
+                    storeManager
+                            .readSession(globalSession.getXid(), true)
+                            .getBranchSessions()
+                            .size());
+
+            storeManager.writeSession(LogOperation.GLOBAL_REMOVE, globalSession);
+
+            Assertions.assertNull(storeManager.readSession(globalSession.getXid(), true));
+            Assertions.assertTrue(engine.prefixScan(
+                            RocksDBColumnFamily.BRANCH_SESSION, RocksDBKeyCodec.encodeXidPrefix(globalSession.getXid()))
+                    .isEmpty());
+        }
+    }
+
+    @Test
+    void testReadByStatus() {
+        try (RocksDBStoreEngine engine = open("status")) {
+            RocksDBTransactionStoreManager storeManager = new RocksDBTransactionStoreManager(engine);
+            GlobalSession begin = globalSession("tx-begin", GlobalStatus.Begin);
+            GlobalSession committed = globalSession("tx-committed", GlobalStatus.Committed);
+
+            storeManager.writeSession(LogOperation.GLOBAL_ADD, begin);
+            storeManager.writeSession(LogOperation.GLOBAL_ADD, committed);
+
+            List<GlobalSession> actual = storeManager.readSession(new GlobalStatus[] {GlobalStatus.Begin}, false);
+
+            Assertions.assertEquals(1, actual.size());
+            Assertions.assertEquals(begin.getXid(), actual.get(0).getXid());
+        }
+    }
+
+    @Test
+    void testGlobalUpdateMovesStatusIndex() {
+        try (RocksDBStoreEngine engine = open("status-update")) {
+            RocksDBTransactionStoreManager storeManager = new RocksDBTransactionStoreManager(engine);
+            GlobalSession globalSession = globalSession("tx-status-update", GlobalStatus.Begin);
+
+            storeManager.writeSession(LogOperation.GLOBAL_ADD, globalSession);
+            globalSession.setStatus(GlobalStatus.Committing);
+            storeManager.writeSession(LogOperation.GLOBAL_UPDATE, globalSession);
+
+            Assertions.assertTrue(storeManager
+                    .readSession(new GlobalStatus[] {GlobalStatus.Begin}, false)
+                    .isEmpty());
+            List<GlobalSession> committingSessions =
+                    storeManager.readSession(new GlobalStatus[] {GlobalStatus.Committing}, false);
+            Assertions.assertEquals(1, committingSessions.size());
+            Assertions.assertEquals(
+                    globalSession.getXid(), committingSessions.get(0).getXid());
+        }
+    }
+
+    @Test
+    void testGlobalRemoveDeletesIndexes() {
+        try (RocksDBStoreEngine engine = open("remove-indexes")) {
+            RocksDBTransactionStoreManager storeManager = new RocksDBTransactionStoreManager(engine);
+            GlobalSession globalSession = globalSession("tx-remove-indexes", GlobalStatus.Begin);
+
+            storeManager.writeSession(LogOperation.GLOBAL_ADD, globalSession);
+            storeManager.writeSession(LogOperation.GLOBAL_REMOVE, globalSession);
+
+            SessionCondition condition = new SessionCondition();
+            condition.setTransactionId(globalSession.getTransactionId());
+            Assertions.assertTrue(storeManager.readSession(condition).isEmpty());
+            Assertions.assertTrue(storeManager
+                    .readSession(new GlobalStatus[] {GlobalStatus.Begin}, false)
+                    .isEmpty());
+        }
+    }
+
+    @Test
+    void testStaleIndexesDoNotReturnMismatchedGlobalSession() {
+        try (RocksDBStoreEngine engine = open("stale-indexes")) {
+            RocksDBTransactionStoreManager storeManager = new RocksDBTransactionStoreManager(engine);
+            GlobalSession globalSession = globalSession("tx-stale-indexes", GlobalStatus.Begin);
+            storeManager.writeSession(LogOperation.GLOBAL_ADD, globalSession);
+
+            byte[] xidValue = globalSession.getXid().getBytes(StandardCharsets.UTF_8);
+            engine.put(
+                    RocksDBColumnFamily.GLOBAL_STATUS_INDEX,
+                    RocksDBKeyCodec.encodeGlobalStatusIndex(
+                            GlobalStatus.Committing, globalSession.getBeginTime(), globalSession.getXid()),
+                    xidValue);
+            long staleTransactionId = globalSession.getTransactionId() + 1;
+            engine.put(
+                    RocksDBColumnFamily.TRANSACTION_ID_INDEX,
+                    RocksDBKeyCodec.encodeTransactionIdIndex(staleTransactionId),
+                    xidValue);
+
+            Assertions.assertTrue(storeManager
+                    .readSession(new GlobalStatus[] {GlobalStatus.Committing}, false)
+                    .isEmpty());
+            SessionCondition condition = new SessionCondition();
+            condition.setTransactionId(staleTransactionId);
+            Assertions.assertTrue(storeManager.readSession(condition).isEmpty());
+        }
+    }
+
+    @Test
+    void testReadSortByTimeoutBeginSessionsUsesBeginTimeOrder() {
+        try (RocksDBStoreEngine engine = open("begin-order")) {
+            RocksDBTransactionStoreManager storeManager = new RocksDBTransactionStoreManager(engine);
+            GlobalSession late = globalSession("tx-late", GlobalStatus.Begin);
+            late.setBeginTime(System.currentTimeMillis());
+            GlobalSession early = globalSession("tx-early", GlobalStatus.Begin);
+            early.setBeginTime(late.getBeginTime() - 1000);
+
+            storeManager.writeSession(LogOperation.GLOBAL_ADD, late);
+            storeManager.writeSession(LogOperation.GLOBAL_ADD, early);
+
+            List<GlobalSession> actual = storeManager.readSortByTimeoutBeginSessions(false);
+
+            Assertions.assertEquals(2, actual.size());
+            Assertions.assertEquals(early.getXid(), actual.get(0).getXid());
+            Assertions.assertEquals(late.getXid(), actual.get(1).getXid());
+        }
+    }
+
+    @Test
+    void testLazyReadLoadsRetryBranchesOnDemand() throws Exception {
+        try (RocksDBStoreEngine engine = open("lazy-retry-branches")) {
+            RocksDBTransactionStoreManager storeManager = new RocksDBTransactionStoreManager(engine);
+            setRootSessionManager(new RocksDBSessionManager("root.data", engine));
+            GlobalSession committing = globalSession("tx-commit-retry", GlobalStatus.CommitRetrying);
+            GlobalSession rollbacking = globalSession("tx-rollbacking", GlobalStatus.Rollbacking);
+            BranchSession committingBranch = branchSession(committing, 1L);
+            BranchSession rollbackingBranch = branchSession(rollbacking, 2L);
+
+            storeManager.writeSession(LogOperation.GLOBAL_ADD, committing);
+            storeManager.writeSession(LogOperation.BRANCH_ADD, committingBranch);
+            storeManager.writeSession(LogOperation.GLOBAL_ADD, rollbacking);
+            storeManager.writeSession(LogOperation.BRANCH_ADD, rollbackingBranch);
+
+            SessionCondition condition = new SessionCondition(GlobalStatus.CommitRetrying, GlobalStatus.Rollbacking);
+            condition.setLazyLoadBranch(true);
+            List<GlobalSession> actual = storeManager.readSession(condition);
+
+            Assertions.assertEquals(2, actual.size());
+            for (GlobalSession globalSession : actual) {
+                Assertions.assertTrue(globalSession.isLazyLoadBranch());
+                Assertions.assertEquals(1, globalSession.getBranchSessions().size());
+            }
+        }
+    }
+
+    @Test
+    void testReadBySessionConditionXid() {
+        try (RocksDBStoreEngine engine = open("condition")) {
+            RocksDBTransactionStoreManager storeManager = new RocksDBTransactionStoreManager(engine);
+            GlobalSession globalSession = globalSession("tx-condition", GlobalStatus.Begin);
+            storeManager.writeSession(LogOperation.GLOBAL_ADD, globalSession);
+
+            List<GlobalSession> actual = storeManager.readSession(new SessionCondition(globalSession.getXid()));
+
+            Assertions.assertEquals(1, actual.size());
+            Assertions.assertEquals(globalSession.getXid(), actual.get(0).getXid());
+        }
+    }
+
+    @Test
+    void testReadBySessionConditionTransactionIdAndOvertime() {
+        try (RocksDBStoreEngine engine = open("condition-filter")) {
+            RocksDBTransactionStoreManager storeManager = new RocksDBTransactionStoreManager(engine);
+            GlobalSession oldSession = globalSession("tx-old", GlobalStatus.Begin);
+            oldSession.setBeginTime(System.currentTimeMillis() - 60000);
+            GlobalSession newSession = globalSession("tx-new", GlobalStatus.Begin);
+
+            storeManager.writeSession(LogOperation.GLOBAL_ADD, oldSession);
+            storeManager.writeSession(LogOperation.GLOBAL_ADD, newSession);
+
+            SessionCondition condition = new SessionCondition();
+            condition.setTransactionId(oldSession.getTransactionId());
+            condition.setOverTimeAliveMills(1000L);
+            List<GlobalSession> actual = storeManager.readSession(condition);
+
+            Assertions.assertEquals(1, actual.size());
+            Assertions.assertEquals(oldSession.getXid(), actual.get(0).getXid());
+        }
+    }
+
+    @Test
+    void testReadByEmptySessionConditionScansAll() {
+        try (RocksDBStoreEngine engine = open("condition-all")) {
+            RocksDBTransactionStoreManager storeManager = new RocksDBTransactionStoreManager(engine);
+            GlobalSession begin = globalSession("tx-begin-all", GlobalStatus.Begin);
+            GlobalSession committed = globalSession("tx-committed-all", GlobalStatus.Committed);
+
+            storeManager.writeSession(LogOperation.GLOBAL_ADD, begin);
+            storeManager.writeSession(LogOperation.GLOBAL_ADD, committed);
+
+            List<GlobalSession> actual = storeManager.readSession(new SessionCondition());
+
+            Assertions.assertEquals(2, actual.size());
+        }
+    }
+
+    private RocksDBStoreEngine open(String name) {
+        return RocksDBStoreEngine.open(
+                new RocksDBStoreConfig(tempDir.resolve(name).toString(), true));
+    }
+
+    private GlobalSession globalSession(String name, GlobalStatus status) {
+        GlobalSession globalSession = new GlobalSession("app", "group", name, 60000);
+        globalSession.setStatus(status);
+        return globalSession;
+    }
+
+    private BranchSession branchSession(GlobalSession globalSession, long branchId) {
+        BranchSession branchSession = new BranchSession(BranchType.AT);
+        branchSession.setXid(globalSession.getXid());
+        branchSession.setTransactionId(globalSession.getTransactionId());
+        branchSession.setBranchId(branchId);
+        branchSession.setStatus(BranchStatus.Registered);
+        branchSession.setResourceId("jdbc:mysql://127.0.0.1/db");
+        branchSession.setLockKey("t_order:1");
+        return branchSession;
+    }
+
+    @SuppressWarnings("unchecked")
+    private void restoreEnvironment() throws Exception {
+        Field field = ObjectHolder.class.getDeclaredField("OBJECT_MAP");
+        field.setAccessible(true);
+        Map<String, Object> objectMap = (Map<String, Object>) field.get(ObjectHolder.INSTANCE);
+        if (originalEnvironment == null) {
+            objectMap.remove(Constants.OBJECT_KEY_SPRING_CONFIGURABLE_ENVIRONMENT);
+        } else {
+            objectMap.put(Constants.OBJECT_KEY_SPRING_CONFIGURABLE_ENVIRONMENT, originalEnvironment);
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    private Map<String, SessionManager> getSessionManagerMap() throws Exception {
+        Field field = SessionHolder.class.getDeclaredField("SESSION_MANAGER_MAP");
+        field.setAccessible(true);
+        return (Map<String, SessionManager>) field.get(null);
+    }
+
+    private SessionManager getRootSessionManager() throws Exception {
+        Field field = SessionHolder.class.getDeclaredField("ROOT_SESSION_MANAGER");
+        field.setAccessible(true);
+        return (SessionManager) field.get(null);
+    }
+
+    private void setRootSessionManager(SessionManager sessionManager) throws Exception {
+        Field rootField = SessionHolder.class.getDeclaredField("ROOT_SESSION_MANAGER");
+        rootField.setAccessible(true);
+        rootField.set(null, sessionManager);
+        Field mapField = SessionHolder.class.getDeclaredField("SESSION_MANAGER_MAP");
+        mapField.setAccessible(true);
+        mapField.set(null, null);
+    }
+
+    private void restoreSessionHolder() throws Exception {
+        Field rootField = SessionHolder.class.getDeclaredField("ROOT_SESSION_MANAGER");
+        rootField.setAccessible(true);
+        rootField.set(null, originalRootSessionManager);
+        Field mapField = SessionHolder.class.getDeclaredField("SESSION_MANAGER_MAP");
+        mapField.setAccessible(true);
+        mapField.set(null, originalSessionManagerMap);
+    }
+}
diff --git a/server/src/test/java/org/apache/seata/server/store/FileStoreEngineTest.java b/server/src/test/java/org/apache/seata/server/store/FileStoreEngineTest.java
new file mode 100644
index 00000000000..842493a744b
--- /dev/null
+++ b/server/src/test/java/org/apache/seata/server/store/FileStoreEngineTest.java
@@ -0,0 +1,44 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.seata.server.store;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+class FileStoreEngineTest {
+
+    @Test
+    void testGetName() {
+        Assertions.assertEquals("file", FileStoreEngine.FILE.getName());
+        Assertions.assertEquals("rocksdb", FileStoreEngine.ROCKSDB.getName());
+    }
+
+    @Test
+    void testGet() {
+        Assertions.assertEquals(FileStoreEngine.FILE, FileStoreEngine.get("file"));
+        Assertions.assertEquals(FileStoreEngine.FILE, FileStoreEngine.get("FILE"));
+        Assertions.assertEquals(FileStoreEngine.ROCKSDB, FileStoreEngine.get("rocksdb"));
+        Assertions.assertEquals(FileStoreEngine.ROCKSDB, FileStoreEngine.get("RocksDB"));
+    }
+
+    @Test
+    void testGetUnknown() {
+        Assertions.assertThrows(IllegalArgumentException.class, () -> FileStoreEngine.get("unknown"));
+        Assertions.assertThrows(IllegalArgumentException.class, () -> FileStoreEngine.get(""));
+        Assertions.assertThrows(IllegalArgumentException.class, () -> FileStoreEngine.get(null));
+    }
+}
diff --git a/server/src/test/java/org/apache/seata/server/store/StoreConfigTest.java b/server/src/test/java/org/apache/seata/server/store/StoreConfigTest.java
new file mode 100644
index 00000000000..0dfd27afe18
--- /dev/null
+++ b/server/src/test/java/org/apache/seata/server/store/StoreConfigTest.java
@@ -0,0 +1,110 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.seata.server.store;
+
+import org.apache.seata.common.ConfigurationKeys;
+import org.apache.seata.common.exception.StoreException;
+import org.apache.seata.common.store.LockMode;
+import org.apache.seata.config.ConfigurationCache;
+import org.apache.seata.server.BaseSpringBootTest;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.lang.reflect.Field;
+
+class StoreConfigTest extends BaseSpringBootTest {
+
+    @BeforeEach
+    void beforeEach() throws Exception {
+        clearConfig();
+    }
+
+    @AfterEach
+    void afterEach() throws Exception {
+        clearConfig();
+    }
+
+    @Test
+    void testDefaultFileEngine() {
+        Assertions.assertEquals(FileStoreEngine.FILE, StoreConfig.getFileEngine());
+    }
+
+    @Test
+    void testConfiguredFileEngine() {
+        System.setProperty(ConfigurationKeys.STORE_FILE_ENGINE, "rocksdb");
+        Assertions.assertEquals(FileStoreEngine.ROCKSDB, StoreConfig.getFileEngine());
+
+        System.setProperty(ConfigurationKeys.STORE_FILE_ENGINE, "file");
+        ConfigurationCache.clear();
+        Assertions.assertEquals(FileStoreEngine.FILE, StoreConfig.getFileEngine());
+    }
+
+    @Test
+    void testInvalidFileEngine() {
+        System.setProperty(ConfigurationKeys.STORE_FILE_ENGINE, "unknown");
+        Assertions.assertThrows(StoreException.class, StoreConfig::getFileEngine);
+    }
+
+    @Test
+    void testDefaultEffectiveLockMode() {
+        Assertions.assertEquals(LockMode.FILE, StoreConfig.getEffectiveLockMode());
+    }
+
+    @Test
+    void testRocksDBEffectiveLockMode() {
+        System.setProperty(ConfigurationKeys.STORE_FILE_ENGINE, "rocksdb");
+        Assertions.assertEquals(LockMode.ROCKSDB, StoreConfig.getEffectiveLockMode());
+    }
+
+    @Test
+    void testRocksDBEffectiveLockModeAllowsExplicitRocksDB() {
+        System.setProperty(ConfigurationKeys.STORE_FILE_ENGINE, "rocksdb");
+        System.setProperty(ConfigurationKeys.STORE_LOCK_MODE, "rocksdb");
+        Assertions.assertEquals(LockMode.ROCKSDB, StoreConfig.getEffectiveLockMode());
+    }
+
+    @Test
+    void testRocksDBEffectiveLockModeRejectsMixedLockMode() {
+        System.setProperty(ConfigurationKeys.STORE_FILE_ENGINE, "rocksdb");
+        System.setProperty(ConfigurationKeys.STORE_LOCK_MODE, "file");
+        Assertions.assertThrows(StoreException.class, StoreConfig::getEffectiveLockMode);
+    }
+
+    @Test
+    void testRocksDBLockModeRequiresRocksDBFileEngine() {
+        System.setProperty(ConfigurationKeys.STORE_LOCK_MODE, "rocksdb");
+        Assertions.assertThrows(StoreException.class, StoreConfig::getEffectiveLockMode);
+    }
+
+    private void clearConfig() throws Exception {
+        System.clearProperty(ConfigurationKeys.STORE_MODE);
+        System.clearProperty(ConfigurationKeys.STORE_LOCK_MODE);
+        System.clearProperty(ConfigurationKeys.STORE_FILE_ENGINE);
+        ConfigurationCache.clear();
+        resetStoreConfig("storeMode");
+        resetStoreConfig("sessionMode");
+        resetStoreConfig("lockMode");
+    }
+
+    private void resetStoreConfig(String fieldName) throws Exception {
+        Field field = StoreConfig.class.getDeclaredField(fieldName);
+        field.setAccessible(true);
+        field.set(null, null);
+    }
+}
diff --git a/server/src/test/resources/META-INF/services/org.apache.seata.server.lock.LockManager b/server/src/test/resources/META-INF/services/org.apache.seata.server.lock.LockManager
index df4c40a0cab..f5d7ce2233c 100644
--- a/server/src/test/resources/META-INF/services/org.apache.seata.server.lock.LockManager
+++ b/server/src/test/resources/META-INF/services/org.apache.seata.server.lock.LockManager
@@ -16,4 +16,5 @@
 #
 org.apache.seata.server.storage.db.lock.DataBaseLockManager
 org.apache.seata.server.storage.file.lock.FileLockManager
-org.apache.seata.server.storage.redis.lock.RedisLockManager
\ No newline at end of file
+org.apache.seata.server.storage.redis.lock.RedisLockManager
+org.apache.seata.server.storage.rocksdb.lock.RocksDBLockManager
diff --git a/spring/seata-spring-autoconfigure/seata-spring-autoconfigure-core/src/main/java/org/apache/seata/spring/boot/autoconfigure/StarterConstants.java b/spring/seata-spring-autoconfigure/seata-spring-autoconfigure-core/src/main/java/org/apache/seata/spring/boot/autoconfigure/StarterConstants.java
index e63341fed04..95b29767f3f 100644
--- a/spring/seata-spring-autoconfigure/seata-spring-autoconfigure-core/src/main/java/org/apache/seata/spring/boot/autoconfigure/StarterConstants.java
+++ b/spring/seata-spring-autoconfigure/seata-spring-autoconfigure-core/src/main/java/org/apache/seata/spring/boot/autoconfigure/StarterConstants.java
@@ -101,6 +101,7 @@ public interface StarterConstants {
     String STORE_SESSION_PREFIX = STORE_PREFIX + ".session";
     String STORE_LOCK_PREFIX = STORE_PREFIX + ".lock";
     String STORE_FILE_PREFIX = STORE_PREFIX + ".file";
+    String STORE_FILE_ROCKSDB_PREFIX = STORE_FILE_PREFIX + ".rocksdb";
     String STORE_DB_PREFIX = STORE_PREFIX + ".db";
     String STORE_DB_DRUID_PREFIX = STORE_DB_PREFIX + ".druid";
     String STORE_DB_HIKARI_PREFIX = STORE_DB_PREFIX + ".hikari";
diff --git a/spring/seata-spring-autoconfigure/seata-spring-autoconfigure-core/src/main/java/org/apache/seata/spring/boot/autoconfigure/loader/SeataPropertiesLoader.java b/spring/seata-spring-autoconfigure/seata-spring-autoconfigure-core/src/main/java/org/apache/seata/spring/boot/autoconfigure/loader/SeataPropertiesLoader.java
index 9b24c79e0c8..e5083b6a4f4 100644
--- a/spring/seata-spring-autoconfigure/seata-spring-autoconfigure-core/src/main/java/org/apache/seata/spring/boot/autoconfigure/loader/SeataPropertiesLoader.java
+++ b/spring/seata-spring-autoconfigure/seata-spring-autoconfigure-core/src/main/java/org/apache/seata/spring/boot/autoconfigure/loader/SeataPropertiesLoader.java
@@ -93,13 +93,18 @@ public void loadSessionAndLockModes() {
         try {
             Class<?> storeConfigClass = Class.forName("org.apache.seata.server.store.StoreConfig");
             Optional<String> sessionMode = invokeEnumMethod(storeConfigClass, "getSessionMode", "getName");
-            Optional<String> lockMode = invokeEnumMethod(storeConfigClass, "getLockMode", "getName");
+            Optional<String> lockMode = invokeEnumMethod(storeConfigClass, "getEffectiveLockMode", "getName");
             sessionMode.ifPresent(value -> System.setProperty("sessionMode", value));
             lockMode.ifPresent(value -> System.setProperty("lockMode", value));
-        } catch (ClassNotFoundException
-                | NoSuchMethodException
-                | InvocationTargetException
-                | IllegalAccessException e) {
+        } catch (InvocationTargetException e) {
+            Throwable cause = e.getCause();
+            if (cause instanceof RuntimeException) {
+                throw (RuntimeException) cause;
+            }
+            if (cause instanceof Error) {
+                throw (Error) cause;
+            }
+        } catch (ClassNotFoundException | NoSuchMethodException | IllegalAccessException e) {
             // The exception is not printed because it is an expected behavior and does not affect the normal operation
             // of the program.
             // StoreConfig only exists on the server side
diff --git a/spring/seata-spring-autoconfigure/seata-spring-autoconfigure-server/src/main/java/org/apache/seata/spring/boot/autoconfigure/SeataServerEnvironmentPostProcessor.java b/spring/seata-spring-autoconfigure/seata-spring-autoconfigure-server/src/main/java/org/apache/seata/spring/boot/autoconfigure/SeataServerEnvironmentPostProcessor.java
index d0365d09b8c..86086296319 100644
--- a/spring/seata-spring-autoconfigure/seata-spring-autoconfigure-server/src/main/java/org/apache/seata/spring/boot/autoconfigure/SeataServerEnvironmentPostProcessor.java
+++ b/spring/seata-spring-autoconfigure/seata-spring-autoconfigure-server/src/main/java/org/apache/seata/spring/boot/autoconfigure/SeataServerEnvironmentPostProcessor.java
@@ -60,6 +60,7 @@
 import static org.apache.seata.spring.boot.autoconfigure.StarterConstants.STORE_DB_HIKARI_PREFIX;
 import static org.apache.seata.spring.boot.autoconfigure.StarterConstants.STORE_DB_PREFIX;
 import static org.apache.seata.spring.boot.autoconfigure.StarterConstants.STORE_FILE_PREFIX;
+import static org.apache.seata.spring.boot.autoconfigure.StarterConstants.STORE_FILE_ROCKSDB_PREFIX;
 import static org.apache.seata.spring.boot.autoconfigure.StarterConstants.STORE_LOCK_PREFIX;
 import static org.apache.seata.spring.boot.autoconfigure.StarterConstants.STORE_PREFIX;
 import static org.apache.seata.spring.boot.autoconfigure.StarterConstants.STORE_REDIS_PREFIX;
@@ -90,6 +91,7 @@ public static void init() {
             PROPERTY_BEAN_MAP.put(STORE_SESSION_PREFIX, Session.class);
             PROPERTY_BEAN_MAP.put(STORE_LOCK_PREFIX, Lock.class);
             PROPERTY_BEAN_MAP.put(STORE_FILE_PREFIX, StoreFileProperties.class);
+            PROPERTY_BEAN_MAP.put(STORE_FILE_ROCKSDB_PREFIX, StoreFileProperties.RocksDB.class);
             PROPERTY_BEAN_MAP.put(STORE_DB_PREFIX, StoreDBProperties.class);
             PROPERTY_BEAN_MAP.put(STORE_DB_DRUID_PREFIX, DruidProperties.class);
             PROPERTY_BEAN_MAP.put(STORE_DB_HIKARI_PREFIX, HikariProperties.class);
diff --git a/spring/seata-spring-autoconfigure/seata-spring-autoconfigure-server/src/main/java/org/apache/seata/spring/boot/autoconfigure/properties/server/store/StoreFileProperties.java b/spring/seata-spring-autoconfigure/seata-spring-autoconfigure-server/src/main/java/org/apache/seata/spring/boot/autoconfigure/properties/server/store/StoreFileProperties.java
index 3a33624312a..c3a386c8a31 100644
--- a/spring/seata-spring-autoconfigure/seata-spring-autoconfigure-server/src/main/java/org/apache/seata/spring/boot/autoconfigure/properties/server/store/StoreFileProperties.java
+++ b/spring/seata-spring-autoconfigure/seata-spring-autoconfigure-server/src/main/java/org/apache/seata/spring/boot/autoconfigure/properties/server/store/StoreFileProperties.java
@@ -21,10 +21,12 @@
 
 import static org.apache.seata.common.DefaultValues.DEFAULT_SERVICE_SESSION_RELOAD_READ_SIZE;
 import static org.apache.seata.spring.boot.autoconfigure.StarterConstants.STORE_FILE_PREFIX;
+import static org.apache.seata.spring.boot.autoconfigure.StarterConstants.STORE_FILE_ROCKSDB_PREFIX;
 
 @Component
 @ConfigurationProperties(prefix = STORE_FILE_PREFIX)
 public class StoreFileProperties {
+    private String engine = "file";
     private String dir = "sessionStore";
     private Integer maxBranchSessionSize = 16384;
     private Integer maxGlobalSessionSize = 512;
@@ -32,6 +34,15 @@ public class StoreFileProperties {
     private Integer sessionReloadReadSize = DEFAULT_SERVICE_SESSION_RELOAD_READ_SIZE;
     private String flushDiskMode = "async";
 
+    public String getEngine() {
+        return engine;
+    }
+
+    public StoreFileProperties setEngine(String engine) {
+        this.engine = engine;
+        return this;
+    }
+
     public String getDir() {
         return dir;
     }
@@ -85,4 +96,19 @@ public StoreFileProperties setFlushDiskMode(String flushDiskMode) {
         this.flushDiskMode = flushDiskMode;
         return this;
     }
+
+    @Component
+    @ConfigurationProperties(prefix = STORE_FILE_ROCKSDB_PREFIX)
+    public static class RocksDB {
+        private String dir = "sessionStore/rocksdb";
+
+        public String getDir() {
+            return dir;
+        }
+
+        public RocksDB setDir(String dir) {
+            this.dir = dir;
+            return this;
+        }
+    }
 }
diff --git a/spring/seata-spring-autoconfigure/seata-spring-autoconfigure-server/src/test/java/org/apache/seata/spring/boot/autoconfigure/ServerPropertiesTest.java b/spring/seata-spring-autoconfigure/seata-spring-autoconfigure-server/src/test/java/org/apache/seata/spring/boot/autoconfigure/ServerPropertiesTest.java
index c0dd4fb8170..c7f74610175 100644
--- a/spring/seata-spring-autoconfigure/seata-spring-autoconfigure-server/src/test/java/org/apache/seata/spring/boot/autoconfigure/ServerPropertiesTest.java
+++ b/spring/seata-spring-autoconfigure/seata-spring-autoconfigure-server/src/test/java/org/apache/seata/spring/boot/autoconfigure/ServerPropertiesTest.java
@@ -25,6 +25,7 @@
 import org.apache.seata.spring.boot.autoconfigure.properties.server.store.HikariProperties;
 import org.apache.seata.spring.boot.autoconfigure.properties.server.store.StoreDBProperties;
 import org.apache.seata.spring.boot.autoconfigure.properties.server.store.StoreFileProperties;
+import org.apache.seata.spring.boot.autoconfigure.properties.server.store.StoreFileProperties.RocksDB;
 import org.apache.seata.spring.boot.autoconfigure.properties.server.store.StoreProperties;
 import org.apache.seata.spring.boot.autoconfigure.properties.server.store.StoreRedisProperties;
 import org.apache.seata.spring.boot.autoconfigure.properties.server.store.StoreRedisProperties.Sentinel;
@@ -77,6 +78,8 @@ public void testStoreProperties() {
     @Test
     public void testStoreFileProperties() {
         assertEquals(context.getBean(StoreFileProperties.class).getDir(), "sessionStore");
+        assertEquals(context.getBean(StoreFileProperties.class).getEngine(), "file");
+        assertEquals(context.getBean(RocksDB.class).getDir(), "sessionStore/rocksdb");
     }
 
     @Test
diff --git a/spring/seata-spring-autoconfigure/seata-spring-autoconfigure-server/src/test/java/org/apache/seata/spring/boot/autoconfigure/properties/server/store/StoreFilePropertiesTest.java b/spring/seata-spring-autoconfigure/seata-spring-autoconfigure-server/src/test/java/org/apache/seata/spring/boot/autoconfigure/properties/server/store/StoreFilePropertiesTest.java
index 9f2c949b412..f1222382dc9 100644
--- a/spring/seata-spring-autoconfigure/seata-spring-autoconfigure-server/src/test/java/org/apache/seata/spring/boot/autoconfigure/properties/server/store/StoreFilePropertiesTest.java
+++ b/spring/seata-spring-autoconfigure/seata-spring-autoconfigure-server/src/test/java/org/apache/seata/spring/boot/autoconfigure/properties/server/store/StoreFilePropertiesTest.java
@@ -25,17 +25,22 @@ public class StoreFilePropertiesTest {
     public void testStoreFileProperties() {
         StoreFileProperties storeFileProperties = new StoreFileProperties();
         storeFileProperties.setDir("dir");
+        storeFileProperties.setEngine("rocksdb");
         storeFileProperties.setFlushDiskMode("disk");
         storeFileProperties.setFileWriteBufferCacheSize(1);
         storeFileProperties.setMaxBranchSessionSize(1);
         storeFileProperties.setMaxGlobalSessionSize(1);
         storeFileProperties.setSessionReloadReadSize(1);
+        StoreFileProperties.RocksDB rocksDB = new StoreFileProperties.RocksDB();
+        rocksDB.setDir("rocksdb-dir");
 
         Assertions.assertEquals("dir", storeFileProperties.getDir());
+        Assertions.assertEquals("rocksdb", storeFileProperties.getEngine());
         Assertions.assertEquals("disk", storeFileProperties.getFlushDiskMode());
         Assertions.assertEquals(1, storeFileProperties.getFileWriteBufferCacheSize());
         Assertions.assertEquals(1, storeFileProperties.getMaxGlobalSessionSize());
         Assertions.assertEquals(1, storeFileProperties.getMaxBranchSessionSize());
         Assertions.assertEquals(1, storeFileProperties.getSessionReloadReadSize());
+        Assertions.assertEquals("rocksdb-dir", rocksDB.getDir());
     }
 }