家族升级处理

rc-service/rc-service-other/other-infrastructure/src/main/java/com/red/circle/other/infra/common/family/FamilyCommon.java

@@ -131,13 +131,6 @@ public class FamilyCommon {
     );
   }
 
-  /**
-   * 增加家族经验值并处理升级
-   *
-   * @param userId    用户userId
-   * @param sysOrigin 系统平台
-   * @param exp       经验值
-   */
   public void addFamilyExpAndLevelUp(Long userId, String sysOrigin, Long exp) {
     FamilyMemberInfo member = getFamilyMember(userId);
     if (Objects.isNull(member)) {
@@ -147,34 +140,69 @@ public class FamilyCommon {
     String lockKey = "family:level:lock:" + member.getFamilyId();
     int maxRetry = 5;
     int retryCount = 0;
+    boolean lockAcquired = false;
 
     while (retryCount < maxRetry) {
       try {
-        boolean locked = redisService.setIfAbsent(lockKey, "1", 30, TimeUnit.SECONDS);
+        lockAcquired = redisService.setIfAbsent(lockKey, "1", 30, TimeUnit.SECONDS);
-        if (locked) {
+
+        if (lockAcquired) {
           try {
             processExpAndLevelUpWithLock(member, sysOrigin, exp);
             return;
+          } catch (Exception ex) {
+            log.error("处理家族经验升级异常,FamilyId:{},userId:{},exp:{},error:{}",
+                    member.getFamilyId(), userId, exp, Throwables.getStackTraceAsString(ex));
+            throw ex;
           } finally {
-            redisService.delete(lockKey);
+            try {
+              redisService.delete(lockKey);
+              lockAcquired = false;
+            } catch (Exception e) {
+              log.error("释放家族升级锁异常,FamilyId:{},error:{}",
+                      member.getFamilyId(), e.getMessage());
+            }
           }
         }
 
+        // 未获取到锁，进行重试
         retryCount++;
         if (retryCount < maxRetry) {
-          Thread.sleep(100 * retryCount);
+          Thread.sleep(100L * retryCount);
         }
+
       } catch (InterruptedException e) {
+        // 中断异常处理
         Thread.currentThread().interrupt();
         log.error("获取家族升级锁被中断,FamilyId:{}", member.getFamilyId());
+
+        if (lockAcquired) {
+          try {
+            redisService.delete(lockKey);
+          } catch (Exception ex) {
+            log.error("中断时释放锁异常,FamilyId:{}", member.getFamilyId());
+          }
+        }
         return;
       } catch (Exception ex) {
-        log.error("FamilyCommon.addFamilyExpAndLevelUp.userId:{},{}", userId, Throwables.getStackTraceAsString(ex));
+        // 其他异常处理（包括业务异常）
+        log.error("获取家族升级锁异常,FamilyId:{},userId:{},error:{}",
+                member.getFamilyId(), userId, Throwables.getStackTraceAsString(ex));
+
+        if (lockAcquired) {
+          try {
+            redisService.delete(lockKey);
+          } catch (Exception e) {
+            log.error("异常时释放锁失败,FamilyId:{}", member.getFamilyId());
+          }
+        }
         return;
       }
     }
 
-    log.error("获取家族升级锁失败,重试{}次后放弃,FamilyId:{},userId:{},exp:{}", maxRetry, member.getFamilyId(), userId, exp);
+    // 重试失败日志
+    log.error("获取家族升级锁失败,重试{}次后放弃,FamilyId:{},userId:{},exp:{}",
+            maxRetry, member.getFamilyId(), userId, exp);
   }
   
   /**
@@ -204,7 +232,7 @@ public class FamilyCommon {
    * 处理经验值增加和升级逻辑
    */
   private void processExpAndLevelUp(FamilyMemberInfo member, FamilyDetailsDTO currentLevel,
-      Long exp, String sysOrigin, String regionId) {
+                                    Long exp, String sysOrigin, String regionId) {
 
     long remainingExp = exp;
     FamilyDetailsDTO levelInfo = currentLevel;
@@ -212,23 +240,30 @@ public class FamilyCommon {
     while (remainingExp > 0) {
       FamilyLevelConfig nextLevel = getNewLevel(sysOrigin, levelInfo);
 
+      // 已经是满级，无法继续升级
       if (Objects.isNull(nextLevel)) {
         addExpWithoutLevelUp(member, levelInfo, remainingExp, regionId);
         break;
       }
 
-      long currentLevelCompleteExp = levelInfo.getLevelExp();
+      long currentLevelCompleteExp = levelInfo.getLevelExp();  // 当前等级满级所需总经验
-      long currentFamilyExp = familyLevelExpService.getExp(levelInfo.getFamilyId(), levelInfo.getFamilyLevelId()).longValue();
+      long currentFamilyExp = familyLevelExpService.getExp(levelInfo.getFamilyId(),
-      long expNeeded = currentLevelCompleteExp - currentFamilyExp;
+              levelInfo.getFamilyLevelId()).longValue();  // 当前已有经验
+      long expNeeded = currentLevelCompleteExp - currentFamilyExp;  // 还需要多少经验才能升级
 
-      if (remainingExp <= expNeeded) {
+      // 经验不足以升级，只增加经验不升级
+      if (remainingExp < expNeeded) {
         addExpWithoutLevelUp(member, levelInfo, remainingExp, regionId);
         break;
       }
 
-      performLevelUp(member, nextLevel, currentLevelCompleteExp, regionId);
+      // 经验足够升级：先增加升级所需的经验，然后执行升级
+      addExpWithoutLevelUp(member, levelInfo, expNeeded, regionId);
+      updateFamily(member, nextLevel);
+
       remainingExp -= expNeeded;
 
+      // 重新获取升级后的等级信息
       levelInfo = getFamilyDetails(sysOrigin, member.getFamilyId());
     }
   }
@@ -241,17 +276,6 @@ public class FamilyCommon {
     expAccumulate(member, exp, regionId);
   }
 
-  /**
-   * 执行升级操作
-   */
-  private void performLevelUp(FamilyMemberInfo member, FamilyLevelConfig newLevel, Long exp, String regionId) {
-    addFamilyExpIncreaseRecord(exp, member, newLevel.getId());
-    expAccumulate(member, exp, regionId);
-    updateFamily(member, newLevel);
-  }
-
-
-
   /**
    * 更新家族
    *