提交lck表相关操作

isc-common-service-public/src/main/java/com/brilliance/isc/common/lock/impl/AbstractBizLocker.java

 package com.brilliance.isc.common.lock.impl;
 
+import com.brilliance.isc.common.context.SpringEnvContext;
 import org.slf4j.LoggerFactory;
 import org.slf4j.Logger;
 import com.brilliance.isc.common.lock.BizLocker;
@@ -49,13 +50,15 @@ public abstract class AbstractBizLocker implements BizLocker {
 
     @Override
     public boolean lock(LockInfo lockInfo, long seconds) {
-        return this.lock(lockInfo.genLockKey(),lockInfo.genLockValue(),seconds);
+        //   return this.lock(lockInfo.genLockKey(),lockInfo.genLockValue(),seconds);
+        return SpringEnvContext.getBean(AbstractBizLocker.class).lock(lockInfo.genLockKey(),lockInfo.genLockValue(),seconds);
     }
 
 
     @Override
     public boolean lock(LockInfo lockInfo) {
-        return this.lock(lockInfo.genLockKey(),lockInfo.genLockValue(),DEFAULT_LEASE_TIME);
+        //  return this.lock(lockInfo.genLockKey(),lockInfo.genLockValue(),DEFAULT_LEASE_TIME);
+        return SpringEnvContext.getBean(AbstractBizLocker.class).lock(lockInfo.genLockKey(),lockInfo.genLockValue(),DEFAULT_LEASE_TIME);
     }
 
     /**

isc-common-service-public/src/main/java/com/brilliance/isc/common/lock/impl/DBLckBizLocker.java

 package com.brilliance.isc.common.lock.impl;
 
+import com.brilliance.isc.common.util.StringUtils;
 import com.brilliance.isc.bo.Lck;
 import com.brilliance.isc.bo.Stb;
-import com.brilliance.isc.common.lock.LockInfo;
 import com.brilliance.isc.mda.dao.StbMapper;
 import com.brilliance.isc.vo.manager.StbVo;
-import org.apache.commons.lang3.StringUtils;
-import org.slf4j.Logger;
+import org.redisson.api.RBucket;
+import org.redisson.api.RedissonClient;
 import org.slf4j.LoggerFactory;
+import org.slf4j.Logger;
+import com.brilliance.isc.common.lock.LockInfo;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.context.annotation.Primary;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Propagation;
 import org.springframework.transaction.annotation.Transactional;
 
+import javax.annotation.Resource;
 import java.util.List;
+import java.util.concurrent.TimeUnit;
 
 
 @Service
-@Primary
 public class DBLckBizLocker extends AbstractBizLocker {
-    private final Logger logger = LoggerFactory.getLogger(DBLckBizLocker.class);
+    private static Logger logger  = LoggerFactory.getLogger(RedisBizLocker.class);
 
     @Autowired
     private LckComponent lckComponent;
@@ -32,62 +34,97 @@ public class DBLckBizLocker extends AbstractBizLocker {
 
     private final String DBLOCKER = "DBLOCK";
 
-    private boolean getSwitchFlag() {
+    private boolean getSwitchFlag(){
         StbVo stbVo = new StbVo();
         stbVo.setTbl(DBLOCKER);
         List<Stb> stbs = stbMapper.queryByPage(stbVo);
-        if (stbs == null || stbs.size() == 0) {
+        if(stbs == null || stbs.size() == 0){
             return false;
         }
         return "Y".equals(stbs.get(0).getCod()) ? true : false;
     }
 
+    @Resource
+    private RedissonClient redissonClient;
+
+
     /**
      * @param key 为业务主键，使用LockInfo的方法生成key
      * @param value 为业务锁定信息，一般为交易码+操作人，使用LockInfo的方法生成value
      * @param seconds 锁定时间,db模式下无效
      * @return
      */
-    @Transactional(propagation = Propagation.REQUIRES_NEW, rollbackFor = Exception.class)
-    public boolean lock(String key, String value, long seconds) {
-        if (!getSwitchFlag()) {
+    @Transactional(propagation = Propagation.REQUIRES_NEW,rollbackFor = Exception.class)
+    public boolean lock(String key,String value, long seconds) {
+        if(!getSwitchFlag()){
             logger.info("锁定函数暂时关闭");
             return true;
         }
-        LockInfo lockInfo = new LockInfo(key, value);
+        LockInfo lockInfo = new LockInfo(key,value);
+
+        //insert前增加redis分布式锁
+        boolean isRedisSucess = false;
+        RBucket<String> bucket = redissonClient.getBucket(key);
+        String oldbucketValue = bucket.get();
+        // 不存在时，新增
+        if (StringUtils.isEmpty(oldbucketValue)) {
+            isRedisSucess = bucket.trySet(value, seconds, TimeUnit.SECONDS);
+            logger.info("锁key:{},value:{}，结果:{}",key,value,isRedisSucess);
+            if (isRedisSucess == false)
+            {
+                return false;
+            }
+        }
+        // 相同时，刷新时间
+        if (!StringUtils.isEmpty(oldbucketValue) && oldbucketValue.equals(value)) {
+            if(value.endsWith("#true")) {
+                isRedisSucess = bucket.setIfExists(value, seconds, TimeUnit.SECONDS);
+                logger.info("锁已重入并刷新时间key:{},value:{}",key,value);
+            }else{
+                logger.info("锁无法重入key:{},value:{}",key,value);
+            }
+            if (isRedisSucess == false)
+            {
+                return false;
+            }
+        }
+
+
+
         boolean  isSuccess = lckComponent.tryInsert(lockInfo);
 
         // 插入成功，新增
         if (isSuccess) {
-            logger.info("锁key:{},value:{}，结果:成功", key, value);
+            logger.info("锁key:{},value:{}，结果:成功",key,value);
             return true;
         }
         lockInfo = getLock(lockInfo);
         String oldValue = lockInfo.genLockValue();
         // 相同时，刷新时间
         if (oldValue.equals(value)) {
-            if (value.endsWith("#true")) {
-                logger.info("锁已重入key:{},value:{}", key, value);
+            if(value.endsWith("#true")) {
+                logger.info("锁已重入key:{},value:{}",key,value);
                 isSuccess = true;
-            } else {
-                logger.info("锁无法重入key:{},value:{}", key, value);
+            }else{
+                logger.info("锁无法重入key:{},value:{}",key,value);
             }
         }
         return isSuccess;
     }
 
 
+
     @Override
     public LockInfo getLock(LockInfo lockInfo) {
-        if (!getSwitchFlag()) {
+        if(!getSwitchFlag()){
             logger.info("锁定函数暂时关闭");
             return null;
         }
         String key = lockInfo.genLockKey();
         LockInfo dbLockInfo = lckComponent.getLck(lockInfo);
-        if (dbLockInfo != null) {
+        if(dbLockInfo != null){
             String value = dbLockInfo.genLockValue();
-            logger.info("返回锁信息key:{},value:{}", key, value);
+            logger.info("返回锁信息key:{},value:{}",key,value);
             return dbLockInfo;
         }
         return null;
@@ -96,36 +133,56 @@ public class DBLckBizLocker extends AbstractBizLocker {
 
     @Override
     public boolean unlock(LockInfo lockInfo) {
-        if (!getSwitchFlag()) {
+        if(!getSwitchFlag()){
             logger.info("锁定函数暂时关闭");
             return true;
         }
         String key = lockInfo.genLockKey();
+
+
+
         LockInfo oldLockInfo = getLock(lockInfo);
-        if (oldLockInfo != null) {
-            logger.info("返回锁信息key:{},value:{}", key, oldLockInfo.genLockValue());
-            if (oldLockInfo.getUsrId().equals(lockInfo.getUsrId())) {
-                logger.info("删除锁{}", key);
+        if(oldLockInfo != null){
+            logger.info("返回锁信息key:{},value:{}",key,oldLockInfo.genLockValue());
+            if(oldLockInfo.getUsrId().equals(lockInfo.getUsrId())){
+                logger.info("删除锁{}",key);
                 int cnt = lckComponent.deleteLck(oldLockInfo);
-                logger.info("删除锁成功{}，影响行数{}", key, cnt);
+                logger.info("删除锁成功{}，影响行数{}",key,cnt);
                 return true;
-            } else {
-                logger.info("{}锁定人不一致，不允许删除,oldUserId:{},curUserId{},", key, oldLockInfo.getUsrId(), lockInfo.getUsrId());
+            }else{
+                logger.info("{}锁定人不一致，不允许删除,oldUserId:{},curUserId{},",key,oldLockInfo.getUsrId(),lockInfo.getUsrId());
             }
         }
+
+//        删除redis事务锁
+        RBucket<String> bucket = redissonClient.getBucket(key);
+        String value = bucket.get();
+        logger.info("返回锁信息key:{},value:{}",key,value);
+        if(value != null){
+            LockInfo oldRedisLockInfo = new LockInfo(key,value);
+            if(oldRedisLockInfo.getUsrId().equals(lockInfo.getUsrId())){
+                logger.info("删除锁{}",key);
+                bucket.delete();
+                return true;
+            }else{
+                logger.info("{}锁定人不一致，不允许删除,oldUserId:{},curUserId{},",key,oldLockInfo.getUsrId(),lockInfo.getUsrId());
+            }
+        }
+
         return false;
     }
 
-    @Transactional(propagation = Propagation.REQUIRES_NEW, rollbackFor = Exception.class)
-    public boolean lockForce(String key, String value, long seconds) {
-        logger.info("强制占用锁{}:{}", key, value);
-        LockInfo lockInfo = new LockInfo(key, value);
+    @Transactional(propagation = Propagation.REQUIRES_NEW,rollbackFor = Exception.class)
+    public boolean lockForce(String key,String value, long seconds) {
+        logger.info("强制占用锁{}:{}",key,value);
+        LockInfo lockInfo = new LockInfo(key,value);
         lckComponent.updateLockInfo(lockInfo);
-        logger.info("强制占用锁{}:{}成功", key, value);
+        logger.info("强制占用锁{}:{}成功",key,value);
         return true;
     }
 
 
+
     /**
      * 强制解锁
      *
@@ -135,9 +192,9 @@ public class DBLckBizLocker extends AbstractBizLocker {
     @Override
     public boolean unlockForce(LockInfo lockInfo) {
         String key = lockInfo.genLockKey();
-        logger.info("强制删除锁{}", key);
+        logger.info("强制删除锁{}",key);
         int cnt = lckComponent.deleteLck(lockInfo);
-        logger.info("强制删除锁成功{}，影响行数{}", key, cnt);
+        logger.info("强制删除锁成功{}，影响行数{}",key,cnt);
         return true;
     }
 
@@ -150,10 +207,10 @@ public class DBLckBizLocker extends AbstractBizLocker {
     @Override
     public boolean unlockAllOfTrans(String transName, String userId) {
         Lck lck = new Lck();
-        lck.setLcktrn(StringUtils.upperCase(transName));
+        lck.setLcktrn(transName);
         lck.setLckusr(userId);
         int cnt = lckComponent.deleteLckByUserAndTrn(lck);
-        logger.info("解除{}用户在{}交易的所有锁定，影响行数{}", userId, transName, cnt);
+        logger.info("解除{}用户在{}交易的所有锁定，影响行数{}",userId,transName,cnt);
         return true;
     }
 
@@ -165,12 +222,12 @@ public class DBLckBizLocker extends AbstractBizLocker {
      */
     @Override
     public boolean unlockAllOfUser(String userId) {
-        logger.info("退出锁定{}", userId);
+        logger.info("退出锁定{}",userId);
         Lck lck = new Lck();
         lck.setLcktrn(null);
         lck.setLckusr(userId);
         int cnt = lckComponent.deleteLckByUserAndTrn(lck);
-        logger.info("退出锁定成功{}，影响行数{}", userId, cnt);
+        logger.info("退出锁定成功{}，影响行数{}",userId,cnt);
         return false;
     }
 }

isc-common-service-public/src/main/java/com/brilliance/isc/common/lock/impl/LckComponent.java

 package com.brilliance.isc.common.lock.impl;
 
+import org.slf4j.LoggerFactory;
+import org.slf4j.Logger;
 import com.brilliance.isc.bo.Lck;
 import com.brilliance.isc.common.lock.LockInfo;
 import com.brilliance.isc.mda.dao.LckMapper;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
@@ -24,39 +24,40 @@ public class LckComponent {
             int cnt = lckMapper.insert(lck);
             logger.info("锁定信息插入成功，影响行数:{}", cnt);
             return true;
-        } catch (Exception e) {
-            logger.info("已存在锁{}", lockInfo.genLockKey());
-        } finally {
+        }catch(Exception e){
+            logger.info("已存在锁{}",lockInfo.genLockKey());
+        }
+        finally {
 
         }
         return false;
     }
 
-    public Lck lockInfo2Lck(LockInfo lockInfo) {
+    public Lck lockInfo2Lck(LockInfo lockInfo){
         Lck dataLck = new Lck();
         dataLck.setLckdattim(new Date());
         dataLck.setLcktrn(lockInfo.getTrnName());
         dataLck.setLckusr(lockInfo.getUsrId());
         dataLck.setLckstr(lockInfo.genLockKey());
-        if (lockInfo.isReentrant()) {
+        if(lockInfo.isReentrant()){
             dataLck.setLckhld("");
-        } else {
+        }else{
             dataLck.setLckhld("X");
         }
         return dataLck;
     }
 
-    public LockInfo lck2Info(Lck dataLck) {
-        if (dataLck == null) {
+    public LockInfo lck2Info(Lck dataLck){
+        if(dataLck == null){
             return null;
         }
         LockInfo lockInfo = new LockInfo(dataLck.getLckstr());
         lockInfo.setTrnName(dataLck.getLcktrn());
         lockInfo.setUsrId(dataLck.getLckusr());
 
-        if (dataLck.getLckhld() == null || dataLck.getLckhld().trim().isEmpty()) {
+        if(dataLck.getLckhld() == null || dataLck.getLckhld().trim().isEmpty()){
             lockInfo.setReentrant(true);
-        } else {
+        }else{
             lockInfo.setReentrant(false);
         }
         return lockInfo;