package .dlock_demo.utils;
import ;
import ;
import ;
import .slf4j.Slf4j;
import .;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
/*** Concurrent verification and data processing tools
*
*@author: shf
* @date: February 14, 2025 11:13*/
@Slf4j
public class ConcurrentDataUtils {
private static final String DEFAULT_LAST_JOIN_SQL = "ORDER BY id DESC Limit 1 FOR UPDATE";
private static Map<Class<?>, SerializedLambda> CLASS_LAMDBA_CACHE = new ConcurrentHashMap<>();
/*** Verify that the data already exists
* <p>
* According to the query conditions, the last data that meets the conditions is queried by default to make judgments or updates. The query conditions are given priority to pass the unique identification fields in the tables such as ID (row lock), business number, etc.;
*
*@param<T> Entity Type
*@param<C> Query the type of the conditional column value
*@paramservice database operation service
*@paramconditionPairs database query conditions (key: condition query column field eg: delete status; value: corresponding value)*/
@SafeVarargs
public static <T, C> boolean isExist(IService<T> service, Pair<SFunction<T, C>, C>... conditionPairs) {
if (service == null || conditionPairs == null || == 0) {
throw newRuntimeException("ConcurrentDataUtils-isExist query condition is empty");
}
return lockAndGet(service, conditionPairs) != null;
}
/*** Check whether the field values of the participating database are consistent
* <p>
* According to the query conditions, the last data that meets the conditions is queried by default to make judgments or updates. The query conditions are given priority to pass the unique identification fields in the tables such as ID (row lock), business number, etc.;
* The expected value parameter type must be consistent with the entity field data type;
*
*@param<T> Entity Type
*@param<R> Type of value to be verified
*@param<C> Query the type of the conditional column value
*@paramtargetColumn Entity class query field
*@paramexpectVal expect value needs to be consistent with the entity field data type
*@paramservice database operation service
*@paramconditionPairs database query conditions (key: condition query column field eg: delete status; value: corresponding value)*/
@SafeVarargs
public static <T, R, C> boolean isEqual(SFunction<T, R> targetColumn, R expectVal, IService<T> service, Pair<SFunction<T, C>, C>... conditionPairs) {
if (targetColumn == null || service == null || conditionPairs == null || == 0) {
throw newRuntimeException("ConcurrentDataUtils-isEqual query condition is empty");
}
T t = lockAndGet(service, conditionPairs);
if (t == null) {
("ConcurrentDataUtils-expectEqual query is empty");
return false;
}
R columnVal = (t);
return (expectVal, columnVal);
}
/*** Processing to increase or decrease amount, quantity
* <p>
* According to the query conditions, the last data that meets the conditions is queried by default to make judgments or updates. The query conditions are given priority to pass the unique identification fields in the tables such as ID (row lock), business number, etc.;
* The new value-added parameter type must be consistent with the entity field data type;
* Support BigDecimal, long, int
*
*@param<T> Entity Type
*@param<R> Type of value to be verified
*@param<C> Query the type of the conditional column value
*@paramtargetColumn Entity class query field
*@paramThisVal's new value needs to be consistent with the entity field data type
*@paramservice database operation service
*@paramconditionPairs database query conditions (key: condition query column field eg: delete status; value: corresponding value)*/
@SafeVarargs
public static <T, R, C> boolean updateAmount(SFunction<T, R> targetColumn, R thisVal, IService<T> service, Pair<SFunction<T, C>, C>... conditionPairs) {
if (targetColumn == null || thisVal == null || service == null || conditionPairs == null || == 0) {
throw newRuntimeException("ConcurrentDataUtils-updateAmount query condition is empty");
}
try {
T t = lockAndGet(service, conditionPairs);
if (t == null) {
("Concurrent Verification Processing DataConcurrentDataUtils-update did not query valid data");
return false;
}
R columnVal = (t);
R compute = compute(columnVal, thisVal);
//Get fields
String fieldName = getFieldName(targetColumn);
Field field = ().getDeclaredField(fieldName);
(true);
(t, compute);
return (t);
} catch (Throwable e) {
("ConcurrentDataUtils-update exception for processing data:", e);
throw newRuntimeException("ConcurrentDataUtils-update exception");
}
}
/*** According to the query conditions, the last data that meets the conditions is queried by default to make judgments or updates. The query conditions are given priority to pass the unique identification fields in the tables such as ID (row lock), business number, etc.;
*
*@param<T> Entity Type
*@param<R> Query the type of field value
*@param<C> Query the type of the conditional column value
*@paramservice database operation service
*@paramconditionPairs database query conditions (key: condition query column field eg: delete status; value: corresponding value)
*@returnEntity data*/
@SafeVarargs
private static <T, R, C> T lockAndGet(IService<T> service, Pair<SFunction<T, C>, C>... conditionPairs) {
if (service == null || conditionPairs == null) {
return null;
}
//Locked data query
LambdaQueryWrapper<T> wrapper = new LambdaQueryWrapper<>();
//Dynamic splicing parameter pairs
for (Pair<SFunction<T, C>, C> pair : conditionPairs) {
if ((())) {
((), ());
}
}
(DEFAULT_LAST_JOIN_SQL);
return (wrapper);
}
/*** Calculate the increase or decrease result
*
*@paramcolumnVal field original value
*@paramThisVal This change value
*@param<R> Calculate result type
*@returnCalculation results of addition and decrease*/
private static <R> R compute(R columnVal, R thisVal) {
if (columnVal instanceof BigDecimal) {
BigDecimal original = ((BigDecimal) columnVal).orElse();
BigDecimal addVal = (BigDecimal) thisVal;
return (R) (addVal);
} else if (columnVal instanceof Integer) {
Integer original = ((Integer) columnVal).orElse(0);
Integer addVal = (Integer) thisVal;
Integer i = original + addVal;
return (R) i;
} else if (columnVal instanceof Long) {
Long original = ((Long) columnVal).orElse(0L);
Long addVal = (Long) thisVal;
Long l = original + addVal;
return (R) l;
} else {
throw newRuntimeException("ConcurrentCustomCurrentDataUtils-compute data type not supported");
}
}
/***
* The conversion method references to the attribute name
*@param fn
* @return
*/
public static <T, R> String getFieldName(SFunction<T, R> fn) {
SerializedLambda lambda = getSerializedLambda(fn);
String methodName = ();
String prefix = null;
if (("get")) {
prefix = "get";
}
//Intercept the string after get and convert the first letter to lowercase
return toLowerCaseFirstOne((prefix, ""));
}
/*** First letter to lowercase
*
*@param s
*/
private static String toLowerCaseFirstOne(String s) {
if (((0))) {
return s;
} else {
return (new StringBuilder()).append(((0))).append((1)).toString();
}
}
private static SerializedLambda getSerializedLambda(Serializable fn) {
SerializedLambda lambda = CLASS_LAMDBA_CACHE.get(());
if (lambda == null) {
try {
Method method = ().getDeclaredMethod("writeReplace");
();
lambda = (SerializedLambda) (fn);
CLASS_LAMDBA_CACHE.put((), lambda);
} catch (Exception e) {
();
}
}
return lambda;
}
}