Skip to content

I
isc-common
Commit 82b6d938 by gechengyang
Options

提交lck表相关操作

parent 30c9c300
Showing with 117 additions and 56 deletions
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 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);
boolean isSuccess = lckComponent.tryInsert(lockInfo);
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;
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment