A appendTo(A appendable, Iterator parts) throws IOException {
+ Objects.requireNonNull(appendable);
+ if (parts.hasNext()) {
+ appendable.append(toString(parts.next()));
+ while (parts.hasNext()) {
+ appendable.append(separator);
+ appendable.append(toString(parts.next()));
+ }
+ }
+ return appendable;
+ }
+
+ CharSequence toString(Object part) {
+ Objects.requireNonNull(part);
+ return (part instanceof CharSequence) ? (CharSequence) part : part.toString();
+ }
+}
diff --git a/hippo4j-common/src/main/java/cn/hippo4j/common/toolkit/MapUtil.java b/hippo4j-common/src/main/java/cn/hippo4j/common/toolkit/MapUtil.java
new file mode 100644
index 00000000..7436cfda
--- /dev/null
+++ b/hippo4j-common/src/main/java/cn/hippo4j/common/toolkit/MapUtil.java
@@ -0,0 +1,167 @@
+/*
+ * 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 cn.hippo4j.common.toolkit;
+
+import java.util.Collection;
+import java.util.Dictionary;
+import java.util.Map;
+import java.util.Objects;
+import java.util.function.BiFunction;
+import java.util.function.Predicate;
+
+/**
+ * Map util.
+ */
+public class MapUtil {
+
+ /**
+ * Null-safe check if the specified Dictionary is empty.
+ *
+ * Null returns true.
+ *
+ * @param map the collection to check, may be null
+ * @return true if empty or null
+ */
+ public static boolean isEmpty(Map map) {
+ return (map == null || map.isEmpty());
+ }
+
+ /**
+ * Null-safe check if the specified Dictionary is empty.
+ *
+ *
Null returns true.
+ *
+ * @param coll the collection to check, may be null
+ * @return true if empty or null
+ */
+ public static boolean isEmpty(Dictionary coll) {
+ return (coll == null || coll.isEmpty());
+ }
+
+ /**
+ * Null-safe check if the specified Dictionary is not empty.
+ *
+ *
Null returns false.
+ *
+ * @param map the collection to check, may be null
+ * @return true if non-null and non-empty
+ */
+ public static boolean isNotEmpty(Map map) {
+ return !isEmpty(map);
+ }
+
+ /**
+ * Null-safe check if the specified Dictionary is not empty.
+ *
+ *
Null returns false.
+ *
+ * @param coll the collection to check, may be null
+ * @return true if non-null and non-empty
+ */
+ public static boolean isNotEmpty(Dictionary coll) {
+ return !isEmpty(coll);
+ }
+
+ /**
+ * Put into map if value is not null.
+ *
+ * @param target target map
+ * @param key key
+ * @param value value
+ */
+ public static void putIfValNoNull(Map target, Object key, Object value) {
+ Objects.requireNonNull(key, "key");
+ if (value != null) {
+ target.put(key, value);
+ }
+ }
+
+ /**
+ * Put into map if value is not empty.
+ *
+ * @param target target map
+ * @param key key
+ * @param value value
+ */
+ public static void putIfValNoEmpty(Map target, Object key, Object value) {
+ Objects.requireNonNull(key, "key");
+ if (value instanceof String) {
+ if (StringUtil.isNotEmpty((String) value)) {
+ target.put(key, value);
+ }
+ return;
+ }
+ if (value instanceof Collection) {
+ if (CollectionUtil.isNotEmpty((Collection) value)) {
+ target.put(key, value);
+ }
+ return;
+ }
+ if (value instanceof Map) {
+ if (isNotEmpty((Map) value)) {
+ target.put(key, value);
+ }
+ return;
+ }
+ if (value instanceof Dictionary) {
+ if (isNotEmpty((Dictionary) value)) {
+ target.put(key, value);
+ }
+ }
+ }
+
+ /**
+ * ComputeIfAbsent lazy load.
+ *
+ * @param target target Map data.
+ * @param key map key.
+ * @param mappingFunction function which is need to be executed.
+ * @param param1 function's parameter value1.
+ * @param param2 function's parameter value1.
+ * @return
+ */
+ public static V computeIfAbsent(Map target, K key, BiFunction mappingFunction, C param1,
+ T param2) {
+ Objects.requireNonNull(target, "target");
+ Objects.requireNonNull(key, "key");
+ Objects.requireNonNull(mappingFunction, "mappingFunction");
+ Objects.requireNonNull(param1, "param1");
+ Objects.requireNonNull(param2, "param2");
+ V val = target.get(key);
+ if (val == null) {
+ V ret = mappingFunction.apply(param1, param2);
+ target.put(key, ret);
+ return ret;
+ }
+ return val;
+ }
+
+ /**
+ * remove value, Thread safety depends on whether the Map is a thread-safe Map.
+ *
+ * @param map map
+ * @param key key
+ * @param removeJudge judge this key can be remove
+ * @param key type
+ * @param value type
+ * @return value
+ */
+ public static V removeKey(Map map, K key, Predicate removeJudge) {
+ return map.computeIfPresent(key, (k, v) -> removeJudge.test(v) ? null : v);
+ }
+}
diff --git a/hippo4j-common/src/main/java/cn/hippo4j/common/toolkit/Md5Util.java b/hippo4j-common/src/main/java/cn/hippo4j/common/toolkit/Md5Util.java
index 2586f90d..931f683d 100644
--- a/hippo4j-common/src/main/java/cn/hippo4j/common/toolkit/Md5Util.java
+++ b/hippo4j-common/src/main/java/cn/hippo4j/common/toolkit/Md5Util.java
@@ -33,6 +33,16 @@ public class Md5Util {
private static final char[] DIGITS_LOWER = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
+ private static final char XF0 = 0xF0;
+
+ private static final char XF = 0x0F;
+
+ private static final int DATA_ID_GROUP_ID_THREE_LEN = 3;
+
+ private static final int DATA_ID_GROUP_ID_FOUR_LEN = 4;
+
+ private static final int DISPLACEMENT = 4;
+
private static final ThreadLocal MESSAGE_DIGEST_LOCAL = ThreadLocal.withInitial(() -> {
try {
return MessageDigest.getInstance("MD5");
@@ -65,8 +75,8 @@ public class Md5Util {
int l = bytes.length;
char[] out = new char[l << 1];
for (int i = 0, j = 0; i < l; i++) {
- out[j++] = DIGITS_LOWER[(0xF0 & bytes[i]) >>> 4];
- out[j++] = DIGITS_LOWER[0x0F & bytes[i]];
+ out[j++] = DIGITS_LOWER[(XF0 & bytes[i]) >>> DISPLACEMENT];
+ out[j++] = DIGITS_LOWER[XF & bytes[i]];
}
return new String(out);
}
@@ -86,12 +96,12 @@ public class Md5Util {
sb.append(Constants.WORD_SEPARATOR);
sb.append(dataIdGroupId[1]);
// if have tenant, then set it
- if (dataIdGroupId.length == 3) {
+ if (dataIdGroupId.length == DATA_ID_GROUP_ID_THREE_LEN) {
if (StringUtil.isNotBlank(dataIdGroupId[2])) {
sb.append(Constants.WORD_SEPARATOR);
sb.append(dataIdGroupId[2]);
}
- } else if (dataIdGroupId.length == 4) {
+ } else if (dataIdGroupId.length == DATA_ID_GROUP_ID_FOUR_LEN) {
if (StringUtil.isNotBlank(dataIdGroupId[2])) {
sb.append(Constants.WORD_SEPARATOR);
sb.append(dataIdGroupId[2]);
diff --git a/hippo4j-common/src/main/java/cn/hippo4j/common/toolkit/MessageConvert.java b/hippo4j-common/src/main/java/cn/hippo4j/common/toolkit/MessageConvert.java
index fdf529f9..3be85745 100644
--- a/hippo4j-common/src/main/java/cn/hippo4j/common/toolkit/MessageConvert.java
+++ b/hippo4j-common/src/main/java/cn/hippo4j/common/toolkit/MessageConvert.java
@@ -41,7 +41,7 @@ public class MessageConvert {
MessageWrapper wrapper = new MessageWrapper();
wrapper.setResponseClass(message.getClass());
wrapper.setMessageType(message.getMessageType());
- List> messageMapList = new ArrayList();
+ List> messageMapList = new ArrayList<>();
List messages = message.getMessages();
messages.forEach(each -> {
String eachVal = JSONUtil.toJSONString(each);
diff --git a/hippo4j-common/src/main/java/cn/hippo4j/common/toolkit/ReflectUtil.java b/hippo4j-common/src/main/java/cn/hippo4j/common/toolkit/ReflectUtil.java
index db5c343d..35ae9095 100644
--- a/hippo4j-common/src/main/java/cn/hippo4j/common/toolkit/ReflectUtil.java
+++ b/hippo4j-common/src/main/java/cn/hippo4j/common/toolkit/ReflectUtil.java
@@ -17,22 +17,27 @@
package cn.hippo4j.common.toolkit;
-import cn.hutool.core.convert.Convert;
-import cn.hutool.core.exceptions.UtilException;
-import cn.hutool.core.util.ClassUtil;
+import cn.hippo4j.common.web.exception.IllegalException;
+import lombok.AccessLevel;
+import lombok.NoArgsConstructor;
import java.lang.reflect.AccessibleObject;
import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.Map;
+import java.util.Objects;
import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ThreadPoolExecutor;
/**
* Reflect util.
*/
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
public class ReflectUtil {
- private static final Map, Field[]> FIELDS_CACHE = new ConcurrentHashMap();
+ private static final Map, Field[]> FIELDS_CACHE = new ConcurrentHashMap<>();
public static Object getFieldValue(Object obj, String fieldName) {
if (null == obj || StringUtil.isBlank(fieldName)) {
@@ -55,13 +60,13 @@ public class ReflectUtil {
result = field.get(obj);
} catch (IllegalAccessException e) {
String exceptionMsg = String.format("IllegalAccess for %s.%s", field.getDeclaringClass(), field.getName());
- throw new RuntimeException(exceptionMsg, e);
+ throw new IllegalException(exceptionMsg, e);
}
return result;
}
public static T setAccessible(T accessibleObject) {
- if (null != accessibleObject && false == accessibleObject.isAccessible()) {
+ if (null != accessibleObject && !accessibleObject.isAccessible()) {
accessibleObject.setAccessible(true);
}
return accessibleObject;
@@ -69,7 +74,7 @@ public class ReflectUtil {
public static Field getField(Class beanClass, String name) throws SecurityException {
final Field[] fields = getFields(beanClass);
- return ArrayUtil.firstMatch((field) -> name.equals(getFieldName(field)), fields);
+ return ArrayUtil.firstMatch(field -> name.equals(getFieldName(field)), fields);
}
public static Field[] getFields(Class beanClass) throws SecurityException {
@@ -109,32 +114,137 @@ public class ReflectUtil {
return field.getName();
}
- public static void setFieldValue(Object obj, String fieldName, Object value) throws UtilException {
- cn.hutool.core.lang.Assert.notNull(obj);
- cn.hutool.core.lang.Assert.notBlank(fieldName);
+ public static void setFieldValue(Object obj, String fieldName, Object value) throws IllegalException {
+ Assert.notNull(obj);
+ Assert.notBlank(fieldName);
final Field field = getField((obj instanceof Class) ? (Class) obj : obj.getClass(), fieldName);
- cn.hutool.core.lang.Assert.notNull(field, "Field [{}] is not exist in [{}]", fieldName, obj.getClass().getName());
+ Assert.notNull(field, "Field [" + fieldName + "] is not exist in [" + obj.getClass().getName() + "]");
setFieldValue(obj, field, value);
}
- public static void setFieldValue(Object obj, Field field, Object value) throws UtilException {
- cn.hutool.core.lang.Assert.notNull(field, "Field in [{}] not exist !", obj);
+ public static void setFieldValue(Object obj, Field field, Object value) throws IllegalException {
+ Assert.notNull(field, "Field in [" + obj + "] not exist !");
final Class fieldType = field.getType();
if (null != value) {
- if (false == fieldType.isAssignableFrom(value.getClass())) {
- final Object targetValue = Convert.convert(fieldType, value);
+ if (!fieldType.isAssignableFrom(value.getClass())) {
+ final Object targetValue = cast(fieldType, value);
if (null != targetValue) {
value = targetValue;
}
}
} else {
- value = ClassUtil.getDefaultValue(fieldType);
+ value = getDefaultValue(fieldType);
}
setAccessible(field);
try {
field.set(obj instanceof Class ? null : obj, value);
} catch (IllegalAccessException e) {
- throw new UtilException(e, "IllegalAccess for {}.{}", obj, field.getName());
+ throw new IllegalException("IllegalAccess for " + obj + "." + field.getName(), e);
+ }
+ }
+
+ /**
+ * find the method associated with the method name
+ * if find multiple, return the first, parameter is equivocal
+ *
+ * @param clazz the class
+ * @param methodName retrieves the method name
+ * @return find method
+ */
+ public static Method getMethodByName(Class clazz, String methodName) {
+ if (Objects.nonNull(clazz) && Objects.nonNull(methodName)) {
+ Method method = Arrays.stream(clazz.getMethods())
+ .filter(m -> Objects.equals(m.getName(), methodName))
+ .findFirst().orElse(null);
+ if (method != null) {
+ return method;
+ }
+ return Arrays.stream(clazz.getDeclaredMethods())
+ .filter(m -> Objects.equals(m.getName(), methodName))
+ .findFirst().orElse(null);
+ }
+ return null;
+ }
+
+ /**
+ * find the method associated with the method name
+ *
+ * @param clazz the class
+ * @param methodName retrieves the method name
+ * @param arguments matched parameters class
+ * @return find method
+ */
+ public static Method getMethodByName(Class clazz, String methodName, Class... arguments) {
+ try {
+ if (Objects.nonNull(clazz) && Objects.nonNull(methodName)) {
+ return clazz.getMethod(methodName, arguments);
+ }
+ } catch (NoSuchMethodException e) {
+ throw new IllegalException(e);
+ }
+ return null;
+ }
+
+ /**
+ * Cast the value to the type
+ * If a ClassCastException occurs, return null
+ *
+ * @param clazz Cast class
+ * @param value The cast value
+ * @return The value after the cast is completed
+ */
+ public static Object cast(Class clazz, Object value) {
+ try {
+ return clazz.cast(value);
+ } catch (ClassCastException e) {
+ return null;
+ }
+ }
+
+ /**
+ * the default value is obtained if it is a primitive type, and NULL if it is not
+ *
+ * @param clazz clazz
+ * @return default value
+ */
+ public static Object getDefaultValue(Class clazz) {
+ if (Objects.isNull(clazz) || !clazz.isPrimitive()) {
+ return null;
+ }
+ if (long.class.isAssignableFrom(clazz)) {
+ return 0L;
+ } else if (int.class.isAssignableFrom(clazz)) {
+ return 0;
+ } else if (short.class.isAssignableFrom(clazz)) {
+ return (short) 0;
+ } else if (char.class.isAssignableFrom(clazz)) {
+ return (char) 0;
+ } else if (byte.class.isAssignableFrom(clazz)) {
+ return (byte) 0;
+ } else if (double.class.isAssignableFrom(clazz)) {
+ return 0D;
+ } else if (float.class.isAssignableFrom(clazz)) {
+ return 0f;
+ } else if (boolean.class.isAssignableFrom(clazz)) {
+ return false;
+ }
+ return null;
+ }
+
+ /**
+ * invoke
+ *
+ * @param obj the obj
+ * @param method the method
+ * @param arguments parameters
+ * @return result for zhe method
+ */
+ @SuppressWarnings("unchecked")
+ public static T invoke(Object obj, Method method, Object... arguments) {
+ try {
+ return (T) method.invoke(obj, arguments);
+ } catch (IllegalAccessException | InvocationTargetException e) {
+ throw new IllegalException(e);
}
}
}
diff --git a/hippo4j-common/src/main/java/cn/hippo4j/common/toolkit/Singleton.java b/hippo4j-common/src/main/java/cn/hippo4j/common/toolkit/Singleton.java
index 4e5ef959..03633e46 100644
--- a/hippo4j-common/src/main/java/cn/hippo4j/common/toolkit/Singleton.java
+++ b/hippo4j-common/src/main/java/cn/hippo4j/common/toolkit/Singleton.java
@@ -29,7 +29,7 @@ import java.util.function.Supplier;
@NoArgsConstructor(access = AccessLevel.PRIVATE)
public final class Singleton {
- private static final ConcurrentHashMap SINGLE_OBJECT_POOL = new ConcurrentHashMap();
+ private static final ConcurrentHashMap SINGLE_OBJECT_POOL = new ConcurrentHashMap<>();
/**
* Get a singleton object by key.
@@ -55,8 +55,11 @@ public final class Singleton {
*/
public static T get(String key, Supplier supplier) {
Object result = SINGLE_OBJECT_POOL.get(key);
- if (result == null && (result = supplier.get()) != null) {
- SINGLE_OBJECT_POOL.put(key, result);
+ if (result == null) {
+ result = supplier.get();
+ if (result != null) {
+ SINGLE_OBJECT_POOL.put(key, result);
+ }
}
return result != null ? (T) result : null;
}
diff --git a/hippo4j-common/src/main/java/cn/hippo4j/common/toolkit/StringUtil.java b/hippo4j-common/src/main/java/cn/hippo4j/common/toolkit/StringUtil.java
index a092278f..c9fcde40 100644
--- a/hippo4j-common/src/main/java/cn/hippo4j/common/toolkit/StringUtil.java
+++ b/hippo4j-common/src/main/java/cn/hippo4j/common/toolkit/StringUtil.java
@@ -17,6 +17,9 @@
package cn.hippo4j.common.toolkit;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
/**
* String util.
*/
@@ -26,6 +29,8 @@ public class StringUtil {
public static final char UNDERLINE = '_';
+ public static final String[] EMPTY_ARRAY = new String[0];
+
/**
* Returns the given string if it is nonempty; {@code null} otherwise.
*
@@ -49,9 +54,11 @@ public class StringUtil {
/**
* Returns {@code true} if the given string is null or is the empty string.
*
+ * this method has been deprecated, use isEmpty() instead.
* @param str
* @return
*/
+ @Deprecated
public static boolean isNullOrEmpty(String str) {
return str == null || str.isEmpty();
}
@@ -63,14 +70,17 @@ public class StringUtil {
* @return
*/
public static boolean isBlank(CharSequence str) {
- int length;
- if ((str == null) || ((length = str.length()) == 0)) {
+ if ((str == null)) {
+ return true;
+ }
+ int length = str.length();
+ if (length == 0) {
return true;
}
for (int i = 0; i < length; i++) {
char c = str.charAt(i);
boolean charNotBlank = Character.isWhitespace(c) || Character.isSpaceChar(c) || c == '\ufeff' || c == '\u202a';
- if (charNotBlank == false) {
+ if (!charNotBlank) {
return false;
}
}
@@ -104,7 +114,7 @@ public class StringUtil {
* @return
*/
public static boolean isNotBlank(CharSequence str) {
- return isBlank(str) == false;
+ return !isBlank(str);
}
/**
@@ -114,7 +124,7 @@ public class StringUtil {
* @return
*/
public static boolean isAllNotEmpty(CharSequence... args) {
- return false == hasEmpty(args);
+ return !hasEmpty(args);
}
/**
@@ -188,4 +198,162 @@ public class StringUtil {
}
return sb.toString();
}
+
+ /**
+ * to camel case
+ *
+ * @param str CharSequence
+ * @param symbol symbol
+ * @return toCamelCase String
+ */
+ public static String toCamelCase(CharSequence str, char symbol) {
+ if (null == str || str.length() == 0) {
+ return null;
+ }
+ int length = str.length();
+ StringBuilder sb = new StringBuilder(length);
+ boolean upperCase = false;
+ for (int i = 0; i < length; ++i) {
+ char c = str.charAt(i);
+ if (c == symbol) {
+ upperCase = true;
+ } else if (upperCase) {
+ sb.append(Character.toUpperCase(c));
+ upperCase = false;
+ } else {
+ sb.append(c);
+ }
+ }
+ return sb.toString();
+ }
+
+ /**
+ * combination CharSequence, get a String
+ *
+ * @param charSequences CharSequence, if null or empty, get {@link StringUtil#EMPTY}
+ * @return String
+ */
+ public static String newBuilder(CharSequence... charSequences) {
+ if (charSequences == null || charSequences.length == 0) {
+ return StringUtil.EMPTY;
+ }
+ return createBuilder(charSequences).toString();
+ }
+
+ /**
+ * combination CharSequence, get a StringBuilder
+ *
+ * @param charSequences CharSequence
+ * @return StringBuilder
+ */
+ public static StringBuilder createBuilder(CharSequence... charSequences) {
+ StringBuilder builder = new StringBuilder();
+ if (charSequences == null || charSequences.length == 0) {
+ return builder;
+ }
+ for (CharSequence sequence : charSequences) {
+ builder.append(sequence);
+ }
+ return builder;
+ }
+
+ /**
+ * combination CharSequence, to StringBuilder
+ *
+ * @param builder StringBuilder, if null create a new
+ * @param charSequences CharSequence
+ * @return StringBuilder
+ */
+ public static StringBuilder appends(StringBuilder builder, CharSequence... charSequences) {
+ if (builder == null) {
+ return createBuilder(charSequences);
+ }
+ if (charSequences == null || charSequences.length == 0) {
+ return builder;
+ }
+ for (CharSequence sequence : charSequences) {
+ builder.append(sequence);
+ }
+ return builder;
+ }
+
+ /**
+ * Replace a portion of the string, replacing all found
+ *
+ * @param str A string to operate on
+ * @param searchStr The replaced string
+ * @param replaceStr The replaced string
+ * @return Replace the result
+ */
+ public static String replace(String str, String searchStr, String replaceStr) {
+ return Pattern
+ .compile(searchStr, Pattern.LITERAL)
+ .matcher(str)
+ .replaceAll(Matcher.quoteReplacement(replaceStr));
+ }
+
+ /**
+ * Splits the provided text into an array, separators specified.
+ *
+ *
+ * StringUtils.split(null, *) = null
+ * StringUtils.split("", *) = []
+ * StringUtils.split("abc def", null) = ["abc", "def"]
+ * StringUtils.split("abc def", " ") = ["abc", "def"]
+ * StringUtils.split("ab:cd:ef", ":") = ["ab", "cd", "ef"]
+ *
+ * @param str the String to parse, may be null
+ * @param separatorChars the characters used as the delimiters,
+ * @return an array of parsed Strings
+ */
+ public static String[] split(final String str, final String separatorChars) {
+ if (str == null) {
+ return null;
+ }
+ if (isBlank(str)) {
+ return EMPTY_ARRAY;
+ }
+ if (isBlank(separatorChars)) {
+ return str.split(" ");
+ }
+ return str.split(separatorChars);
+ }
+
+ /**
+ * Tests if this string starts with the specified prefix.
+ *
+ * @param str this str
+ * @param prefix the suffix
+ * @return Whether the prefix exists
+ */
+ public static boolean startWith(String str, String prefix) {
+ if (isEmpty(str)) {
+ return false;
+ }
+ return str.startsWith(prefix);
+ }
+
+ /**
+ * get the string before the delimiter
+ *
+ * @param str string
+ * @param symbol separator
+ * @return String
+ */
+ public static String subBefore(String str, String symbol) {
+ if (isEmpty(str) || symbol == null) {
+ return str;
+ }
+ if (symbol.isEmpty()) {
+ return EMPTY;
+ }
+ int pos = str.indexOf(symbol);
+ if (-1 == pos) {
+ return str;
+ }
+ if (0 == pos) {
+ return EMPTY;
+ }
+ return str.substring(0, pos);
+ }
}
diff --git a/hippo4j-common/src/main/java/cn/hippo4j/common/toolkit/UserContext.java b/hippo4j-common/src/main/java/cn/hippo4j/common/toolkit/UserContext.java
index 5b433671..22c1a286 100644
--- a/hippo4j-common/src/main/java/cn/hippo4j/common/toolkit/UserContext.java
+++ b/hippo4j-common/src/main/java/cn/hippo4j/common/toolkit/UserContext.java
@@ -28,7 +28,7 @@ import java.util.Optional;
*/
public class UserContext {
- private static final ThreadLocal USER_THREAD_LOCAL = new ThreadLocal();
+ private static final ThreadLocal USER_THREAD_LOCAL = new ThreadLocal<>();
public static void setUserInfo(String username, String userRole) {
USER_THREAD_LOCAL.set(new User(username, userRole));
@@ -46,6 +46,9 @@ public class UserContext {
USER_THREAD_LOCAL.remove();
}
+ /**
+ * User info.
+ */
@Data
@NoArgsConstructor
@AllArgsConstructor
diff --git a/hippo4j-common/src/main/java/cn/hippo4j/common/toolkit/http/Header.java b/hippo4j-common/src/main/java/cn/hippo4j/common/toolkit/http/Header.java
new file mode 100644
index 00000000..14d85b6f
--- /dev/null
+++ b/hippo4j-common/src/main/java/cn/hippo4j/common/toolkit/http/Header.java
@@ -0,0 +1,199 @@
+/*
+ * 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 cn.hippo4j.common.toolkit.http;
+
+import cn.hippo4j.common.constant.Constants;
+import cn.hippo4j.common.constant.HttpHeaderConstants;
+import cn.hippo4j.common.constant.HttpMediaType;
+import cn.hippo4j.common.toolkit.MapUtil;
+import cn.hippo4j.common.toolkit.StringUtil;
+
+import java.util.*;
+
+/**
+ * Http header.
+ *
+ * @author liaochuntao
+ */
+public class Header {
+
+ public static final Header EMPTY = Header.newInstance();
+
+ private final Map header;
+
+ private final Map> originalResponseHeader;
+
+ private static final String DEFAULT_CHARSET = "UTF-8";
+
+ private static final String DEFAULT_ENCODING = "gzip";
+
+ private Header() {
+ header = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
+ originalResponseHeader = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
+ addParam(HttpHeaderConstants.CONTENT_TYPE, HttpMediaType.APPLICATION_JSON);
+ addParam(HttpHeaderConstants.ACCEPT_CHARSET, DEFAULT_CHARSET);
+ }
+
+ public static Header newInstance() {
+ return new Header();
+ }
+
+ /**
+ * Add the key and value to the header.
+ *
+ * @param key the key
+ * @param value the value
+ * @return header
+ */
+ public Header addParam(String key, String value) {
+ if (StringUtil.isNotEmpty(key)) {
+ header.put(key, value);
+ }
+ return this;
+ }
+
+ public Header setContentType(String contentType) {
+ if (contentType == null) {
+ contentType = HttpMediaType.APPLICATION_JSON;
+ }
+ return addParam(HttpHeaderConstants.CONTENT_TYPE, contentType);
+ }
+
+ public Header build() {
+ return this;
+ }
+
+ public String getValue(String key) {
+ return header.get(key);
+ }
+
+ public Map getHeader() {
+ return header;
+ }
+
+ public Iterator> iterator() {
+ return header.entrySet().iterator();
+ }
+
+ /**
+ * Transfer to KV part list. The odd index is key and the even index is value.
+ *
+ * @return KV string list
+ */
+ public List toList() {
+ List list = new ArrayList<>(header.size() * 2);
+ Iterator> iterator = iterator();
+ while (iterator.hasNext()) {
+ Map.Entry entry = iterator.next();
+ list.add(entry.getKey());
+ list.add(entry.getValue());
+ }
+ return list;
+ }
+
+ /**
+ * Add all KV list to header. The odd index is key and the even index is value.
+ *
+ * @param list KV list
+ * @return header
+ */
+ public Header addAll(List list) {
+ if ((list.size() & 1) != 0) {
+ throw new IllegalArgumentException("list size must be a multiple of 2");
+ }
+ for (int i = 0; i < list.size();) {
+ String key = list.get(i++);
+ if (StringUtil.isNotEmpty(key)) {
+ header.put(key, list.get(i++));
+ }
+ }
+ return this;
+ }
+
+ /**
+ * Add all parameters to header.
+ *
+ * @param params parameters
+ */
+ public void addAll(Map params) {
+ if (MapUtil.isNotEmpty(params)) {
+ for (Map.Entry entry : params.entrySet()) {
+ addParam(entry.getKey(), entry.getValue());
+ }
+ }
+ }
+
+ /**
+ * set original format response header.
+ *
+ * Currently only corresponds to the response header of JDK.
+ *
+ * @param key original response header key
+ * @param values original response header values
+ */
+ public void addOriginalResponseHeader(String key, List values) {
+ if (StringUtil.isNotEmpty(key)) {
+ this.originalResponseHeader.put(key, values);
+ addParam(key, values.get(0));
+ }
+ }
+
+ /**
+ * get original format response header.
+ *
+ * Currently only corresponds to the response header of JDK.
+ *
+ * @return Map original response header
+ */
+ public Map> getOriginalResponseHeader() {
+ return this.originalResponseHeader;
+ }
+
+ public String getCharset() {
+ String acceptCharset = getValue(HttpHeaderConstants.ACCEPT_CHARSET);
+ if (acceptCharset == null) {
+ String contentType = getValue(HttpHeaderConstants.CONTENT_TYPE);
+ acceptCharset = StringUtil.isNotBlank(contentType) ? analysisCharset(contentType) : Constants.ENCODE;
+ }
+ return acceptCharset;
+ }
+
+ private String analysisCharset(String contentType) {
+ String[] values = contentType.split(";");
+ String charset = Constants.ENCODE;
+ if (values.length == 0) {
+ return charset;
+ }
+ for (String value : values) {
+ if (value.startsWith("charset=")) {
+ charset = value.substring("charset=".length());
+ }
+ }
+ return charset;
+ }
+
+ public void clear() {
+ header.clear();
+ originalResponseHeader.clear();
+ }
+
+ @Override
+ public String toString() {
+ return "Header{" + "headerToMap=" + header + '}';
+ }
+}
diff --git a/hippo4j-common/src/main/java/cn/hippo4j/common/toolkit/http/HttpClientResponse.java b/hippo4j-common/src/main/java/cn/hippo4j/common/toolkit/http/HttpClientResponse.java
new file mode 100644
index 00000000..e3cc8ce4
--- /dev/null
+++ b/hippo4j-common/src/main/java/cn/hippo4j/common/toolkit/http/HttpClientResponse.java
@@ -0,0 +1,70 @@
+/*
+ * 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 cn.hippo4j.common.toolkit.http;
+
+import java.io.Closeable;
+import java.io.InputStream;
+
+/**
+ * Represents a client-side HTTP response.
+ *
+ * @author mai.jh
+ */
+public interface HttpClientResponse extends Closeable {
+
+ /**
+ * Return the headers of this message.
+ *
+ * @return a corresponding HttpHeaders object (never {@code null})
+ */
+ Header getHeaders();
+
+ /**
+ * Return the body of the message as an input stream.
+ *
+ * @return String response body
+ */
+ InputStream getBody();
+
+ /**
+ * Return the HTTP status code.
+ *
+ * @return the HTTP status as an integer
+ */
+ int getStatusCode();
+
+ /**
+ * Return the HTTP status text of the response.
+ *
+ * @return the HTTP status text
+ */
+ String getStatusText();
+
+ /**
+ * Return the body As string.
+ *
+ * @return
+ */
+ String getBodyString();
+
+ /**
+ * close response InputStream.
+ */
+ @Override
+ void close();
+}
diff --git a/hippo4j-common/src/main/java/cn/hippo4j/common/toolkit/http/HttpUtil.java b/hippo4j-common/src/main/java/cn/hippo4j/common/toolkit/http/HttpUtil.java
new file mode 100644
index 00000000..a992c521
--- /dev/null
+++ b/hippo4j-common/src/main/java/cn/hippo4j/common/toolkit/http/HttpUtil.java
@@ -0,0 +1,360 @@
+/*
+ * 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 cn.hippo4j.common.toolkit.http;
+
+import cn.hippo4j.common.constant.Constants;
+import cn.hippo4j.common.constant.HttpMediaType;
+import cn.hippo4j.common.constant.HttpMethod;
+import cn.hippo4j.common.constant.HttpResponseCode;
+import cn.hippo4j.common.toolkit.CollectionUtil;
+import cn.hippo4j.common.toolkit.IoUtil;
+import cn.hippo4j.common.toolkit.JSONUtil;
+import cn.hippo4j.common.toolkit.StringUtil;
+import cn.hippo4j.common.toolkit.logtracing.LogMessage;
+import cn.hippo4j.common.web.exception.ServiceException;
+import lombok.AccessLevel;
+import lombok.NoArgsConstructor;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+
+import java.io.OutputStream;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.net.URLEncoder;
+import java.util.Map;
+import java.util.Optional;
+
+import static cn.hippo4j.common.constant.HttpHeaderConstants.CONTENT_LENGTH;
+
+/**
+ * Http request utilities.
+ *
+ * @author Rongzhen Yan
+ */
+@Slf4j
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
+public class HttpUtil {
+
+ /**
+ * Default connect timeout
+ */
+ private static final int DEFAULT_CONNECT_TIMEOUT = 10000;
+
+ /**
+ * Default read timeout
+ */
+ private static final int DEFAULT_READ_TIMEOUT = 30000;
+
+ /**
+ * Send a get network request.
+ *
+ * @param url target url
+ * @param headers headers
+ * @param params form data
+ * @param timeout request timeout
+ * @param clazz return the target data type
+ * @param return the target data type
+ * @return
+ */
+ public static T get(String url, Map headers, Map params, long timeout, Class clazz) {
+ return execute(buildUrl(url, params), HttpMethod.GET, null, headers, timeout, clazz);
+ }
+
+ /**
+ * Send a get network request.
+ *
+ * @param url target url
+ * @param params form data
+ * @return
+ */
+ public static String get(String url, Map params) {
+ return execute(buildUrl(url, params), HttpMethod.GET, null, null);
+ }
+
+ /**
+ * Send a get network request.
+ *
+ * @param url target url
+ * @return
+ */
+ public static String get(String url) {
+ return execute(url, HttpMethod.GET, null, null);
+ }
+
+ /**
+ * Send a get network request.
+ *
+ * @param url target url
+ * @param clazz return the target data type
+ * @param return the target data type
+ * @return
+ */
+ public static T get(String url, Class clazz) {
+ return JSONUtil.parseObject(get(url), clazz);
+ }
+
+ /**
+ * Send a post network request.
+ *
+ * @param url target url
+ * @param body request body
+ * @param clazz return the target data type
+ * @param return the target data type
+ * @return
+ */
+ public static T post(String url, Object body, Class clazz) {
+ String result = post(url, body);
+ return JSONUtil.parseObject(result, clazz);
+ }
+
+ /**
+ * Send a post network request.
+ *
+ * @param url target url
+ * @param body request body
+ * @param timeout request timeout
+ * @param clazz return the target data type
+ * @param return the target data type
+ * @return
+ */
+ public static T post(String url, Object body, long timeout, Class clazz) {
+ String result = post(url, body, timeout);
+ return JSONUtil.parseObject(result, clazz);
+ }
+
+ /**
+ * Send a post network request.
+ *
+ * @param url target url
+ * @param headers headers
+ * @param params form data
+ * @param timeout request timeout
+ * @param clazz return the target data type
+ * @param return the target data type
+ * @return
+ */
+ public static T post(String url, Map headers, Map params, long timeout, Class clazz) {
+ return execute(buildUrl(url, params), HttpMethod.POST, null, headers, timeout, clazz);
+ }
+
+ /**
+ * Send a post network request.
+ *
+ * @param url target url
+ * @param headers headers
+ * @param body request body
+ * @param timeout request timeout
+ * @param clazz return the target data type
+ * @param return the target data type
+ * @return
+ */
+ public static T post(String url, Map headers, Object body, long timeout, Class clazz) {
+ return execute(url, HttpMethod.POST, body, headers, timeout, clazz);
+ }
+
+ /**
+ * Send a post network request.
+ *
+ * @param url target url
+ * @param body request body
+ * @return
+ */
+ public static String post(String url, Object body) {
+ return execute(url, HttpMethod.POST, body, null);
+ }
+
+ /**
+ * Send a post network request.
+ *
+ * @param url target url
+ * @param body request body
+ * @param timeout request timeout
+ * @return
+ */
+ public static String post(String url, Object body, long timeout) {
+ return execute(url, HttpMethod.POST, body, null, timeout, String.class);
+ }
+
+ /**
+ * Send a post network request.
+ *
+ * @param url target url
+ * @param json json data
+ * @return
+ */
+ public static String postJson(String url, String json) {
+ return executeJson(url, HttpMethod.POST, json, null);
+ }
+
+ /**
+ * Send a put network request.
+ *
+ * @param url target url
+ * @param body request body
+ * @return
+ */
+ public static String put(String url, Object body) {
+ return execute(url, HttpMethod.PUT, body, null);
+ }
+
+ /**
+ * Send a put network request.
+ *
+ * @param url target url
+ * @param body request body
+ * @param headers headers
+ * @return
+ */
+ public static String put(String url, Object body, Map headers) {
+ return execute(url, HttpMethod.PUT, body, headers);
+ }
+
+ /**
+ * Constructs a complete Url from the query string.
+ *
+ * @param url target url
+ * @param queryParams query params
+ * @return
+ */
+ @SneakyThrows
+ public static String buildUrl(String url, Map queryParams) {
+ if (CollectionUtil.isEmpty(queryParams)) {
+ return url;
+ }
+ boolean isFirst = true;
+ StringBuilder builder = new StringBuilder(url);
+ for (Map.Entry entry : queryParams.entrySet()) {
+ String key = entry.getKey();
+ if (key != null && entry.getValue() != null) {
+ if (isFirst) {
+ isFirst = false;
+ builder.append("?");
+ } else {
+ builder.append("&");
+ }
+ String value = URLEncoder.encode(queryParams.get(key), Constants.ENCODE)
+ .replaceAll("\\+", "%20");
+ builder.append(key)
+ .append("=")
+ .append(value);
+ }
+ }
+ return builder.toString();
+ }
+
+ private static String executeJson(String url, String method, String json, Map headers) {
+ if (!JSONUtil.isJson(json)) {
+ log.error(LogMessage.getInstance().setMsg("Http Call error.")
+ .kv("url", url)
+ .kv("method", method)
+ .kv("json", json)
+ .kv2String("headers", JSONUtil.toJSONString(headers)));
+ throw new ServiceException("Invalid http json body, please check it again.");
+ }
+ return execute(url, method, json, headers);
+ }
+
+ private static String execute(String url, String method, Object param, Map headers) {
+ HttpURLConnection connection = createConnection(url, method);
+ HttpClientResponse response = null;
+ try {
+ response = doExecute(connection, param, headers);
+ return response.getBodyString();
+ } finally {
+ Optional.ofNullable(response).ifPresent(each -> each.close());
+ }
+ }
+
+ private static T execute(String url, String method, Object body, Map headers, long timeout, Class clazz) {
+ HttpURLConnection connection = createConnection(url, method, timeout);
+ HttpClientResponse response = null;
+ try {
+ response = doExecute(connection, body, headers);
+ if (clazz == String.class) {
+ return (T) response.getBodyString();
+ }
+ return JSONUtil.parseObject(response.getBodyString(), clazz);
+ } finally {
+ Optional.ofNullable(response).ifPresent(each -> each.close());
+ }
+ }
+
+ @SneakyThrows
+ private static HttpClientResponse doExecute(HttpURLConnection connection, Object body, Map headers) {
+ try {
+ if (headers != null && headers.size() > 0) {
+ for (Map.Entry entry : headers.entrySet()) {
+ connection.setRequestProperty(entry.getKey(), entry.getValue());
+ }
+ }
+ String bodyString;
+ if (body instanceof String) {
+ bodyString = (String) body;
+ } else {
+ bodyString = JSONUtil.toJSONString(body);
+ }
+ if (!StringUtil.isEmpty(bodyString)) {
+ connection.setDoOutput(true);
+ byte[] b = bodyString.getBytes();
+ connection.setRequestProperty(CONTENT_LENGTH, String.valueOf(b.length));
+ OutputStream outputStream = connection.getOutputStream();
+ outputStream.write(b, 0, b.length);
+ outputStream.flush();
+ IoUtil.closeQuietly(outputStream);
+ }
+ connection.connect();
+ JdkHttpClientResponse response = new JdkHttpClientResponse(connection);
+ if (HttpResponseCode.SC_OK != response.getStatusCode()) {
+ String msg = String.format("HttpPost response code error. [code] %s [url] %s [body] %s", response.getStatusCode(), connection.getURL(), response.getBodyString());
+ throw new ServiceException(msg);
+ }
+ return response;
+ } catch (Throwable ex) {
+ log.error(LogMessage.getInstance().setMsg("Http call error. ")
+ .kv("url", connection.getURL())
+ .kv("method", connection.getRequestMethod())
+ .kv("body", JSONUtil.toJSONString(body))
+ .kv2String("headers", JSONUtil.toJSONString(headers)), ex);
+ throw ex;
+ }
+ }
+
+ @SneakyThrows
+ private static HttpURLConnection createConnection(String url, String method) {
+ HttpURLConnection connection = (HttpURLConnection) new URL(url).openConnection();
+ connection.setDoInput(true);
+ connection.setDoOutput(true);
+ connection.setConnectTimeout(DEFAULT_CONNECT_TIMEOUT);
+ connection.setReadTimeout(DEFAULT_READ_TIMEOUT);
+ connection.setRequestMethod(method);
+ connection.setRequestProperty(Constants.CONTENT_TYPE, HttpMediaType.APPLICATION_JSON);
+ return connection;
+ }
+
+ @SneakyThrows
+ private static HttpURLConnection createConnection(String url, String method, long timeout) {
+ HttpURLConnection connection = (HttpURLConnection) new URL(url).openConnection();
+ connection.setDoInput(true);
+ connection.setDoOutput(true);
+ connection.setConnectTimeout(Integer.parseInt(String.valueOf(timeout)));
+ connection.setReadTimeout(Integer.parseInt(String.valueOf(timeout)));
+ connection.setRequestMethod(method);
+ connection.setRequestProperty(Constants.CONTENT_TYPE, HttpMediaType.APPLICATION_JSON);
+ return connection;
+ }
+}
diff --git a/hippo4j-common/src/main/java/cn/hippo4j/common/toolkit/http/JdkHttpClientResponse.java b/hippo4j-common/src/main/java/cn/hippo4j/common/toolkit/http/JdkHttpClientResponse.java
new file mode 100644
index 00000000..683b6191
--- /dev/null
+++ b/hippo4j-common/src/main/java/cn/hippo4j/common/toolkit/http/JdkHttpClientResponse.java
@@ -0,0 +1,97 @@
+/*
+ * 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 cn.hippo4j.common.toolkit.http;
+
+import cn.hippo4j.common.constant.Constants;
+import cn.hippo4j.common.constant.HttpHeaderConstants;
+import cn.hippo4j.common.toolkit.IoUtil;
+import lombok.SneakyThrows;
+
+import java.io.ByteArrayInputStream;
+import java.io.InputStream;
+import java.net.HttpURLConnection;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Represents a client-side HTTP response with JDK implementation
+ *
+ * @author Rongzhen Yan
+ */
+public class JdkHttpClientResponse implements HttpClientResponse {
+
+ private final HttpURLConnection conn;
+
+ private InputStream responseStream;
+
+ private Header responseHeader;
+
+ private static final String CONTENT_ENCODING = "gzip";
+
+ public JdkHttpClientResponse(HttpURLConnection conn) {
+ this.conn = conn;
+ }
+
+ @Override
+ public Header getHeaders() {
+ if (this.responseHeader == null) {
+ this.responseHeader = Header.newInstance();
+ }
+ for (Map.Entry> entry : conn.getHeaderFields().entrySet()) {
+ this.responseHeader.addOriginalResponseHeader(entry.getKey(), entry.getValue());
+ }
+ return this.responseHeader;
+ }
+
+ @Override
+ @SneakyThrows
+ public InputStream getBody() {
+ Header headers = getHeaders();
+ InputStream errorStream = this.conn.getErrorStream();
+ this.responseStream = (errorStream != null ? errorStream : this.conn.getInputStream());
+ String contentEncoding = headers.getValue(HttpHeaderConstants.CONTENT_ENCODING);
+ // Used to process http content_encoding, when content_encoding is GZIP, use GZIPInputStream
+ if (CONTENT_ENCODING.equals(contentEncoding)) {
+ byte[] bytes = IoUtil.tryDecompress(this.responseStream);
+ return new ByteArrayInputStream(bytes);
+ }
+ return this.responseStream;
+ }
+
+ @Override
+ @SneakyThrows
+ public int getStatusCode() {
+ return this.conn.getResponseCode();
+ }
+
+ @Override
+ @SneakyThrows
+ public String getStatusText() {
+ return this.conn.getResponseMessage();
+ }
+
+ @Override
+ public String getBodyString() {
+ return IoUtil.toString(this.getBody(), Constants.ENCODE);
+ }
+
+ @Override
+ public void close() {
+ IoUtil.closeQuietly(this.responseStream);
+ }
+}
diff --git a/hippo4j-common/src/main/java/cn/hippo4j/common/toolkit/logtracing/LogMessage.java b/hippo4j-common/src/main/java/cn/hippo4j/common/toolkit/logtracing/LogMessage.java
new file mode 100644
index 00000000..47ef1090
--- /dev/null
+++ b/hippo4j-common/src/main/java/cn/hippo4j/common/toolkit/logtracing/LogMessage.java
@@ -0,0 +1,100 @@
+/*
+ * 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 cn.hippo4j.common.toolkit.logtracing;
+
+import cn.hippo4j.common.toolkit.StringUtil;
+import lombok.AccessLevel;
+import lombok.NoArgsConstructor;
+import org.slf4j.helpers.FormattingTuple;
+import org.slf4j.helpers.MessageFormatter;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * Log message.
+ *
+ * @author Rongzhen Yan
+ */
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
+public class LogMessage {
+
+ private Map kvs = new ConcurrentHashMap<>();
+
+ private String msg = "";
+
+ public static LogMessage getInstance() {
+ return new LogMessage();
+ }
+
+ public LogMessage setMsg(String msg) {
+ this.msg = msg;
+ return this;
+ }
+
+ public String msg(String msg, Object... args) {
+ LogMessage l = new LogMessage();
+ l.kvs = this.kvs;
+ return l.setMsgString(msg, args);
+ }
+
+ public LogMessage setMsg(String msg, Object... args) {
+ FormattingTuple ft = MessageFormatter.arrayFormat(msg, args);
+ this.msg = ft.getThrowable() == null ? ft.getMessage() : ft.getMessage() + "||_fmt_throw=" + ft.getThrowable();
+ return this;
+ }
+
+ public String setMsgString(String msg, Object... args) {
+ FormattingTuple ft = MessageFormatter.arrayFormat(msg, args);
+ this.msg = ft.getThrowable() == null ? ft.getMessage() : ft.getMessage() + "||_fmt_throw=" + ft.getThrowable();
+ return toString();
+ }
+
+ public LogMessage kv(String k, Object v) {
+ this.kvs.put(k, v == null ? "" : v);
+ return this;
+ }
+
+ public String kv2String(String k, Object v) {
+ this.kvs.put(k, v == null ? "" : v);
+ return toString();
+ }
+
+ @Override
+ public String toString() {
+ StringBuilder sb = new StringBuilder();
+ if (StringUtil.isNotEmpty(msg)) {
+ sb.append(msg);
+ }
+ int tempCount = 0;
+ for (Map.Entry kv : kvs.entrySet()) {
+ tempCount++;
+ Object value = kv.getValue();
+ if (value != null) {
+ if (value instanceof String && StringUtil.isEmpty((String) value)) {
+ continue;
+ }
+ sb.append(kv.getKey() + "=").append(kv.getValue());
+ if (tempCount != kvs.size()) {
+ sb.append("||");
+ }
+ }
+ }
+ return sb.toString();
+ }
+}
diff --git a/hippo4j-common/src/main/java/cn/hippo4j/common/web/exception/AbstractException.java b/hippo4j-common/src/main/java/cn/hippo4j/common/web/exception/AbstractException.java
index 22ccaec5..07429614 100644
--- a/hippo4j-common/src/main/java/cn/hippo4j/common/web/exception/AbstractException.java
+++ b/hippo4j-common/src/main/java/cn/hippo4j/common/web/exception/AbstractException.java
@@ -25,7 +25,7 @@ import lombok.Getter;
public class AbstractException extends RuntimeException {
@Getter
- public final ErrorCode errorCode;
+ private final ErrorCode errorCode;
public AbstractException(String message, Throwable throwable, ErrorCode errorCode) {
super(message, throwable);
diff --git a/hippo4j-common/src/main/java/cn/hippo4j/common/web/exception/IllegalException.java b/hippo4j-common/src/main/java/cn/hippo4j/common/web/exception/IllegalException.java
new file mode 100644
index 00000000..86250b4a
--- /dev/null
+++ b/hippo4j-common/src/main/java/cn/hippo4j/common/web/exception/IllegalException.java
@@ -0,0 +1,47 @@
+/*
+ * 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 cn.hippo4j.common.web.exception;
+
+/**
+ * A generic exception to handle illegal operations
+ */
+public class IllegalException extends RuntimeException {
+
+ private static final long serialVersionUID = 8247610319171014183L;
+
+ public IllegalException() {
+ super();
+ }
+
+ public IllegalException(String message) {
+ super(message);
+ }
+
+ public IllegalException(Throwable e) {
+ super(e.getMessage(), e);
+ }
+
+ public IllegalException(String message, Throwable throwable) {
+ super(message, throwable);
+ }
+
+ public IllegalException(String message, Throwable throwable, boolean enableSuppression, boolean writableStackTrace) {
+ super(message, throwable, enableSuppression, writableStackTrace);
+ }
+
+}
diff --git a/hippo4j-common/src/main/java/cn/hippo4j/common/web/exception/ServiceException.java b/hippo4j-common/src/main/java/cn/hippo4j/common/web/exception/ServiceException.java
index 79d03838..f0a357da 100644
--- a/hippo4j-common/src/main/java/cn/hippo4j/common/web/exception/ServiceException.java
+++ b/hippo4j-common/src/main/java/cn/hippo4j/common/web/exception/ServiceException.java
@@ -59,9 +59,9 @@ public class ServiceException extends AbstractException {
@Override
public String toString() {
- return "ServiceException{" +
- "code='" + errorCode.getCode() + "'," +
- "message='" + errorCode.getMessage() + "'" +
- '}';
+ return "ServiceException{"
+ + "code='" + getErrorCode().getCode() + "',"
+ + "message='" + getErrorCode().getMessage() + "'"
+ + '}';
}
}
diff --git a/hippo4j-common/src/test/java/cn/hippo4j/common/function/MatcherFunctionTest.java b/hippo4j-common/src/test/java/cn/hippo4j/common/function/MatcherFunctionTest.java
index 93287ed2..df98ab27 100644
--- a/hippo4j-common/src/test/java/cn/hippo4j/common/function/MatcherFunctionTest.java
+++ b/hippo4j-common/src/test/java/cn/hippo4j/common/function/MatcherFunctionTest.java
@@ -18,9 +18,10 @@
package cn.hippo4j.common.function;
import cn.hippo4j.common.toolkit.Assert;
-import java.math.BigDecimal;
import org.junit.Test;
+import java.math.BigDecimal;
+
public final class MatcherFunctionTest {
public static boolean matchTest(Matcher matcher, T value) {
diff --git a/hippo4j-common/src/test/java/cn/hippo4j/common/toolkit/ArrayUtilTest.java b/hippo4j-common/src/test/java/cn/hippo4j/common/toolkit/ArrayUtilTest.java
index 3a314c4d..1505d9ac 100644
--- a/hippo4j-common/src/test/java/cn/hippo4j/common/toolkit/ArrayUtilTest.java
+++ b/hippo4j-common/src/test/java/cn/hippo4j/common/toolkit/ArrayUtilTest.java
@@ -18,8 +18,8 @@
package cn.hippo4j.common.toolkit;
import cn.hippo4j.common.function.Matcher;
-import com.google.common.base.Strings;
import org.junit.Test;
+import org.springframework.util.StringUtils;
public class ArrayUtilTest {
@@ -39,11 +39,11 @@ public class ArrayUtilTest {
public void assertFirstMatch() {
Matcher matcher = (str) -> "1".equalsIgnoreCase(str);
String[] array = new String[0];
- Assert.isTrue(Strings.isNullOrEmpty(ArrayUtil.firstMatch(matcher, array)));
+ Assert.isTrue(StringUtils.isEmpty(ArrayUtil.firstMatch(matcher, array)));
array = new String[]{"0"};
- Assert.isTrue(Strings.isNullOrEmpty(ArrayUtil.firstMatch(matcher, array)));
+ Assert.isTrue(StringUtils.isEmpty(ArrayUtil.firstMatch(matcher, array)));
array = new String[]{"1"};
- Assert.isTrue(!Strings.isNullOrEmpty(ArrayUtil.firstMatch(matcher, array)));
+ Assert.isTrue(!StringUtils.isEmpty(ArrayUtil.firstMatch(matcher, array)));
}
@Test
diff --git a/hippo4j-config/src/test/java/cn/hippo4j/config/toolkit/BeanUtilTest.java b/hippo4j-common/src/test/java/cn/hippo4j/common/toolkit/BeanUtilTest.java
similarity index 64%
rename from hippo4j-config/src/test/java/cn/hippo4j/config/toolkit/BeanUtilTest.java
rename to hippo4j-common/src/test/java/cn/hippo4j/common/toolkit/BeanUtilTest.java
index 7f44fa32..05caeaf0 100644
--- a/hippo4j-config/src/test/java/cn/hippo4j/config/toolkit/BeanUtilTest.java
+++ b/hippo4j-common/src/test/java/cn/hippo4j/common/toolkit/BeanUtilTest.java
@@ -15,21 +15,16 @@
* limitations under the License.
*/
-package cn.hippo4j.config.toolkit;
+package cn.hippo4j.common.toolkit;
-import cn.hippo4j.common.toolkit.Assert;
import com.github.dozermapper.core.converters.ConversionException;
-import com.google.common.collect.Lists;
-import com.google.common.collect.Maps;
-import com.google.common.collect.Sets;
import lombok.*;
+import org.junit.Assert;
import org.junit.Test;
+import java.lang.reflect.Method;
import java.util.*;
-/**
- * BeanUtil Test
- */
public class BeanUtilTest {
@Test
@@ -41,47 +36,47 @@ public class BeanUtilTest {
person.setAddress("hippo4j.cn");
person.setSize(999);
final Map convert = BeanUtil.convert(person, Map.class);
- Assert.isTrue(Objects.equals("Hippo4j", convert.get("name")));
- Assert.isTrue(Objects.equals(1, convert.get("age")));
- Assert.isTrue(Objects.equals("hippo4j.cn", convert.get("address")));
- Assert.isTrue(Objects.equals(999, convert.get("size")));
+ Assert.assertEquals("Hippo4j", convert.get("name"));
+ Assert.assertEquals(1, convert.get("age"));
+ Assert.assertEquals("hippo4j.cn", convert.get("address"));
+ Assert.assertEquals(999, convert.get("size"));
}
@Test
public void mapToBeanConvertTest() {
// 测试MapToBean
- final HashMap map = Maps.newHashMap();
+ final HashMap map = new HashMap<>();
map.put("name", "Hippo4j");
map.put("age", 1);
map.put("address", "hippo4j.cn");
map.put("size", 999);
final Person person = BeanUtil.convert(map, Person.class);
- Assert.isTrue(Objects.equals("Hippo4j", person.getName()));
- Assert.isTrue(Objects.equals(1, person.getAge()));
- Assert.isTrue(Objects.equals("hippo4j.cn", person.getAddress()));
- Assert.isTrue(Objects.equals(999, person.getSize()));
+ Assert.assertEquals("Hippo4j", person.getName());
+ Assert.assertEquals(1, person.getAge());
+ Assert.assertEquals("hippo4j.cn", person.getAddress());
+ Assert.assertEquals(999, (int) person.getSize());
}
@Test
public void ListToListConvertTest() {
- final List list = Lists.newArrayList();
+ final List list = new ArrayList<>();
list.add(Person.builder().name("one").age(1).build());
list.add(Person.builder().name("two").age(2).build());
list.add(Person.builder().name("three").age(3).build());
final List persons = BeanUtil.convert(list, PersonVo.class);
- Assert.isTrue(Objects.equals(list.size(), persons.size()));
+ Assert.assertEquals(list.size(), persons.size());
}
@Test
public void SetToSetConvertTest() {
- final Set sets = Sets.newHashSet();
+ final Set sets = new HashSet<>();
sets.add(Person.builder().name("one").age(1).build());
sets.add(Person.builder().name("two").age(2).build());
sets.add(Person.builder().name("three").age(3).build());
final Set persons = BeanUtil.convert(sets, PersonVo.class);
- Assert.isTrue(Objects.equals(sets.size(), persons.size()));
+ Assert.assertEquals(sets.size(), persons.size());
}
@Test
@@ -91,10 +86,10 @@ public class BeanUtilTest {
person.setName("Hippo4j");
final Map convert = BeanUtil.convert(person, Map.class);
- Assert.isTrue(Objects.equals("Hippo4j", convert.get("name")));
+ Assert.assertEquals("Hippo4j", convert.get("name"));
// static属性应被忽略
- Assert.isTrue(!convert.containsKey("STATIC_NAME"));
+ Assert.assertFalse(convert.containsKey("STATIC_NAME"));
}
/**
@@ -109,6 +104,28 @@ public class BeanUtilTest {
// -----------------------------------------------------------------------------------------------------------------
+ @Test
+ public void testMapToBean() {
+ Map map = new HashMap<>();
+ map.put("name", "Test");
+ map.put("status_code", 12);
+ Customer customer = BeanUtil.mapToBean(map, Customer.class, true);
+ Assert.assertEquals("Test", customer.getName());
+ Assert.assertEquals(Integer.valueOf(12), customer.getStatusCode());
+ }
+
+ @Test
+ public void testGetter() {
+ Method name = BeanUtil.getter(Customer.class, "name");
+ Assert.assertEquals("getName", name.getName());
+ }
+
+ @Test
+ public void testSetter() {
+ Method name = BeanUtil.setter(Customer.class, "name");
+ Assert.assertEquals("setName", name.getName());
+ }
+
@Getter
@Setter
@Builder
@@ -130,4 +147,20 @@ public class BeanUtilTest {
private String name;
private int age;
}
+
+ @Getter
+ @Setter
+ static class Customer {
+
+ String name;
+ Integer statusCode;
+ }
+
+ @Getter
+ @Setter
+ static class PreCustomer {
+
+ String name;
+ Integer statusCode;
+ }
}
diff --git a/hippo4j-common/src/test/java/cn/hippo4j/common/toolkit/BooleanUtilTest.java b/hippo4j-common/src/test/java/cn/hippo4j/common/toolkit/BooleanUtilTest.java
index e8112b89..85ff30f5 100644
--- a/hippo4j-common/src/test/java/cn/hippo4j/common/toolkit/BooleanUtilTest.java
+++ b/hippo4j-common/src/test/java/cn/hippo4j/common/toolkit/BooleanUtilTest.java
@@ -17,19 +17,20 @@
package cn.hippo4j.common.toolkit;
+import org.junit.Assert;
import org.junit.Test;
public class BooleanUtilTest {
@Test
public void assertToBoolean() {
- Assert.isTrue(BooleanUtil.toBoolean("true"));
- Assert.isTrue(BooleanUtil.toBoolean("yes"));
- Assert.isTrue(BooleanUtil.toBoolean("1"));
+ Assert.assertTrue(BooleanUtil.toBoolean("true"));
+ Assert.assertTrue(BooleanUtil.toBoolean("yes"));
+ Assert.assertTrue(BooleanUtil.toBoolean("1"));
}
@Test
public void assertIsTrue() {
- Assert.isTrue(BooleanUtil.isTrue(true));
+ Assert.assertTrue(BooleanUtil.isTrue(true));
}
}
diff --git a/hippo4j-common/src/test/java/cn/hippo4j/common/toolkit/CollectionUtilTest.java b/hippo4j-common/src/test/java/cn/hippo4j/common/toolkit/CollectionUtilTest.java
index 78715122..04e011dd 100644
--- a/hippo4j-common/src/test/java/cn/hippo4j/common/toolkit/CollectionUtilTest.java
+++ b/hippo4j-common/src/test/java/cn/hippo4j/common/toolkit/CollectionUtilTest.java
@@ -17,10 +17,10 @@
package cn.hippo4j.common.toolkit;
-import com.google.common.collect.Maps;
import org.assertj.core.util.Lists;
import org.junit.Test;
+import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
@@ -44,7 +44,7 @@ public class CollectionUtilTest {
Assert.isTrue(!CollectionUtil.isEmpty(list));
Map map = null;
Assert.isTrue(CollectionUtil.isEmpty(map));
- map = Maps.newHashMap();
+ map = new HashMap<>();
Assert.isTrue(CollectionUtil.isEmpty(map));
map.put("key", "value");
Assert.isTrue(!CollectionUtil.isEmpty(map));
@@ -66,7 +66,7 @@ public class CollectionUtilTest {
Assert.isTrue(CollectionUtil.isNotEmpty(list));
Map map = null;
Assert.isTrue(!CollectionUtil.isNotEmpty(map));
- map = Maps.newHashMap();
+ map = new HashMap<>();
Assert.isTrue(!CollectionUtil.isNotEmpty(map));
map.put("key", "value");
Assert.isTrue(CollectionUtil.isNotEmpty(map));
diff --git a/hippo4j-common/src/test/java/cn/hippo4j/common/toolkit/FileUtilTest.java b/hippo4j-common/src/test/java/cn/hippo4j/common/toolkit/FileUtilTest.java
index 75b5edf4..b3b15b2e 100644
--- a/hippo4j-common/src/test/java/cn/hippo4j/common/toolkit/FileUtilTest.java
+++ b/hippo4j-common/src/test/java/cn/hippo4j/common/toolkit/FileUtilTest.java
@@ -18,6 +18,10 @@
package cn.hippo4j.common.toolkit;
import org.junit.Test;
+import org.junit.Assert;
+
+import java.nio.charset.StandardCharsets;
+import java.util.List;
public class FileUtilTest {
@@ -25,7 +29,7 @@ public class FileUtilTest {
public void assertReadUtf8String() {
String testFilePath = "test/test_utf8.txt";
String contentByFileUtil = FileUtil.readUtf8String(testFilePath);
- Assert.notEmpty(contentByFileUtil);
+ Assert.assertFalse(contentByFileUtil.isEmpty());
}
@Test
@@ -36,6 +40,13 @@ public class FileUtilTest {
"empty line next" + linebreaks;
String testFilePath = "test/test_utf8.txt";
String contentByFileUtil = FileUtil.readUtf8String(testFilePath);
- Assert.isTrue(testText.equals(contentByFileUtil));
+ Assert.assertTrue(testText.equals(contentByFileUtil));
+ }
+
+ @Test
+ public void assertReadLines() {
+ String testFilePath = "test/test_utf8.txt";
+ List readLines = FileUtil.readLines(testFilePath, StandardCharsets.UTF_8);
+ Assert.assertEquals(3, readLines.size());
}
}
diff --git a/hippo4j-common/src/test/java/cn/hippo4j/common/toolkit/GroupKeyTest.java b/hippo4j-common/src/test/java/cn/hippo4j/common/toolkit/GroupKeyTest.java
index b512704a..6d6c4009 100644
--- a/hippo4j-common/src/test/java/cn/hippo4j/common/toolkit/GroupKeyTest.java
+++ b/hippo4j-common/src/test/java/cn/hippo4j/common/toolkit/GroupKeyTest.java
@@ -17,14 +17,8 @@
package cn.hippo4j.common.toolkit;
-import org.checkerframework.checker.units.qual.A;
import org.junit.Test;
-import java.util.Arrays;
-import java.util.List;
-
-import static org.junit.Assert.*;
-
public class GroupKeyTest {
@Test
diff --git a/hippo4j-common/src/test/java/cn/hippo4j/common/toolkit/IdUtilTest.java b/hippo4j-common/src/test/java/cn/hippo4j/common/toolkit/IdUtilTest.java
new file mode 100644
index 00000000..79700086
--- /dev/null
+++ b/hippo4j-common/src/test/java/cn/hippo4j/common/toolkit/IdUtilTest.java
@@ -0,0 +1,37 @@
+/*
+ * 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 cn.hippo4j.common.toolkit;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class IdUtilTest {
+
+ @Test
+ public void randomUUIDTest() {
+ String randomUUID = IdUtil.randomUUID();
+ Assert.assertNotNull(randomUUID);
+ }
+
+ @Test
+ public void simpleUUIDTest() {
+ String simpleUUID = IdUtil.simpleUUID();
+ Assert.assertNotNull(simpleUUID);
+ Assert.assertFalse(simpleUUID.contains("-"));
+ }
+}
\ No newline at end of file
diff --git a/hippo4j-common/src/test/java/cn/hippo4j/common/toolkit/ReflectUtilTest.java b/hippo4j-common/src/test/java/cn/hippo4j/common/toolkit/ReflectUtilTest.java
index 8f065ab8..8a72c358 100644
--- a/hippo4j-common/src/test/java/cn/hippo4j/common/toolkit/ReflectUtilTest.java
+++ b/hippo4j-common/src/test/java/cn/hippo4j/common/toolkit/ReflectUtilTest.java
@@ -18,10 +18,13 @@
package cn.hippo4j.common.toolkit;
import lombok.Getter;
+import lombok.Setter;
import org.junit.Test;
+import org.junit.Assert;
import java.lang.reflect.Field;
-import java.util.Objects;
+import java.lang.reflect.Method;
+import java.util.concurrent.ThreadPoolExecutor;
public class ReflectUtilTest {
@@ -29,10 +32,10 @@ public class ReflectUtilTest {
public void getFieldValueTest() {
TestSubClass testSubClass = new TestSubClass();
Object privateField = ReflectUtil.getFieldValue(testSubClass, "privateField");
- Assert.isTrue(Objects.equals("privateField", privateField));
+ Assert.assertEquals("privateField", privateField);
Object field = ReflectUtil.getFieldValue(testSubClass, "field");
- Assert.isTrue(Objects.equals("field", field));
+ Assert.assertEquals("field", field);
}
@@ -42,57 +45,106 @@ public class ReflectUtilTest {
Field privateField = ReflectUtil.getField(TestSubClass.class, "privateField");
Object privateFieldVal = ReflectUtil.getFieldValue(testSubClass, privateField);
- Assert.isTrue(Objects.equals("privateField", privateFieldVal));
+ Assert.assertEquals("privateField", privateFieldVal);
}
@Test
public void getFieldTest() {
Field privateField = ReflectUtil.getField(TestSubClass.class, "privateField");
- Assert.notNull(privateField);
+ Assert.assertNotNull(privateField);
Field field = ReflectUtil.getField(TestSubClass.class, "field");
- Assert.notNull(field);
+ Assert.assertNotNull(field);
}
@Test
public void getFieldsTest() {
Field[] fields = ReflectUtil.getFields(TestSubClass.class);
- Assert.isTrue(Objects.equals(4, fields.length));
+ Assert.assertEquals(4, fields.length);
}
@Test
public void getFieldsDirectlyTest() {
Field[] fields = ReflectUtil.getFieldsDirectly(TestSubClass.class, false);
- Assert.isTrue(Objects.equals(2, fields.length));
+ Assert.assertEquals(2, fields.length);
fields = ReflectUtil.getFieldsDirectly(TestSubClass.class, true);
- Assert.isTrue(Objects.equals(4, fields.length));
+ Assert.assertEquals(4, fields.length);
}
@Test
public void getFieldNameTest() {
Field privateField = ReflectUtil.getField(TestSubClass.class, "privateField");
String fieldName = ReflectUtil.getFieldName(privateField);
- Assert.notNull(fieldName);
+ Assert.assertNotNull(fieldName);
Field subField = ReflectUtil.getField(TestSubClass.class, "subField");
String subfieldName = ReflectUtil.getFieldName(subField);
- Assert.notNull(subfieldName);
+ Assert.assertNotNull(subfieldName);
}
@Test
public void setFieldValueTest() {
TestClass testClass = new TestClass();
ReflectUtil.setFieldValue(testClass, "field", "fieldVal");
- Assert.isTrue(Objects.equals("fieldVal", testClass.getField()));
+ Assert.assertEquals("fieldVal", testClass.getField());
Field privateField = ReflectUtil.getField(TestSubClass.class, "privateField");
ReflectUtil.setFieldValue(testClass, privateField, "privateFieldVal");
- Assert.isTrue(Objects.equals("privateFieldVal", testClass.getPrivateField()));
+ Assert.assertEquals("privateFieldVal", testClass.getPrivateField());
}
+ @Test
+ public void castTest() {
+ TestClass testClass = new TestSubClass();
+ Object cast = ReflectUtil.cast(TestSubClass.class, testClass);
+ Assert.assertTrue(cast instanceof TestSubClass);
+ }
+
+ @Test
+ public void getDefaultValueTest() {
+ Object defaultValue = ReflectUtil.getDefaultValue(Long.class);
+ Assert.assertNull(defaultValue);
+ Object primitiveValueLong = ReflectUtil.getDefaultValue(long.class);
+ Assert.assertEquals(0L, primitiveValueLong);
+ Object primitiveValueInt = ReflectUtil.getDefaultValue(int.class);
+ Assert.assertEquals(0, primitiveValueInt);
+ Object primitiveValueFloat = ReflectUtil.getDefaultValue(float.class);
+ Assert.assertEquals(0f, primitiveValueFloat);
+ Object primitiveValueShort = ReflectUtil.getDefaultValue(short.class);
+ Assert.assertEquals((short) 0, primitiveValueShort);
+ Object primitiveValueChar = ReflectUtil.getDefaultValue(char.class);
+ Assert.assertEquals((char) 0, primitiveValueChar);
+ Object primitiveValueDouble = ReflectUtil.getDefaultValue(double.class);
+ Assert.assertEquals(0D, primitiveValueDouble);
+ Object primitiveValueBoolean = ReflectUtil.getDefaultValue(boolean.class);
+ Assert.assertEquals(false, primitiveValueBoolean);
+ }
+
+ @Test
+ public void getMethodByNameTest() {
+ // private method
+ Method runStateLessThan = ReflectUtil.getMethodByName(ThreadPoolExecutor.class, "runStateLessThan");
+ Assert.assertNotNull(runStateLessThan);
+ // public method
+ Method field = ReflectUtil.getMethodByName(TestClass.class, "setPrivateField");
+ Assert.assertNotNull(field);
+ // parameters
+ Method privateField = ReflectUtil.getMethodByName(TestClass.class, "setPrivateField", String.class);
+ Assert.assertNotNull(privateField);
+ }
+
+ @Test
+ public void invokeTest() {
+ TestClass testClass = new TestClass();
+ Method method = ReflectUtil.getMethodByName(TestClass.class, "getPrivateField");
+ String invoke = ReflectUtil.invoke(testClass, method);
+ Assert.assertEquals(invoke, "privateField");
+ }
+
@Getter
+ @Setter
static class TestClass {
private String privateField;
diff --git a/hippo4j-common/src/test/java/cn/hippo4j/common/toolkit/StringUtilTest.java b/hippo4j-common/src/test/java/cn/hippo4j/common/toolkit/StringUtilTest.java
index 7c0067ff..4c92830b 100644
--- a/hippo4j-common/src/test/java/cn/hippo4j/common/toolkit/StringUtilTest.java
+++ b/hippo4j-common/src/test/java/cn/hippo4j/common/toolkit/StringUtilTest.java
@@ -18,76 +18,158 @@
package cn.hippo4j.common.toolkit;
import org.junit.Test;
+import org.junit.Assert;
-import java.util.Objects;
+import java.util.Arrays;
+import java.util.Optional;
public class StringUtilTest {
+ @Test
+ public void replace() {
+ String url = "http://localhost:8088/hippo4j_manager?";
+ String replace = StringUtil.replace(url, "/hippo4j_manager?", "?");
+ Assert.assertEquals(replace, "http://localhost:8088?");
+ }
+
+ /**
+ * Splits the provided text into an array, separators specified.
+ *
+ *
+ * StringUtils.split(null, *) = null
+ * StringUtils.split("", *) = []
+ * StringUtils.split("abc def", null) = ["abc", "def"]
+ * StringUtils.split("abc def", " ") = ["abc", "def"]
+ * StringUtils.split("ab:cd:ef", ":") = ["ab", "cd", "ef"]
+ *
+ */
+ @Test
+ public void split() {
+ String str1 = null;
+ String separator1 = "*";
+ String[] res1 = StringUtil.split(str1, separator1);
+ assert res1 == null;
+
+ String str2 = "";
+ String separator2 = "*";
+ String[] res2 = StringUtil.split(str2, separator2);
+ Assert.assertArrayEquals(res2, new String[0]);
+
+ String str3 = "abc def";
+ String separator3 = null;
+ String[] res3 = StringUtil.split(str3, separator3);
+ Assert.assertArrayEquals(res3, new String[]{"abc", "def"});
+
+ String str4 = "abc def";
+ String separator4 = " ";
+ String[] res4 = StringUtil.split(str4, separator4);
+ Assert.assertArrayEquals(res4, new String[]{"abc", "def"});
+
+ String str5 = "ab:cd:ef";
+ String separator5 = ":";
+ String[] res5 = StringUtil.split(str5, separator5);
+ Assert.assertArrayEquals(res5, new String[]{"ab", "cd", "ef"});
+
+ }
+
@Test
public void assertIsEmpty() {
String string = "";
- Assert.isTrue(StringUtil.isEmpty(string));
+ Assert.assertTrue(StringUtil.isEmpty(string));
}
@Test
public void assertIsNotEmpty() {
String string = "string";
- Assert.isTrue(StringUtil.isNotEmpty(string));
+ Assert.assertTrue(StringUtil.isNotEmpty(string));
}
@Test
public void emptyToNull() {
String string = "";
- Assert.isNull(StringUtil.emptyToNull(string));
+ Assert.assertNull(StringUtil.emptyToNull(string));
}
@Test
public void nullToEmpty() {
String string = "null";
- Assert.notEmpty(StringUtil.nullToEmpty(string));
+ Assert.assertEquals("null", StringUtil.nullToEmpty(string));
}
@Test
public void isNullOrEmpty() {
String string = "null";
- Assert.isTrue(!StringUtil.isNullOrEmpty(string));
+ Assert.assertFalse(StringUtil.isEmpty(string));
}
@Test
public void isBlank() {
String string = "";
- Assert.isTrue(StringUtil.isBlank(string));
+ Assert.assertTrue(StringUtil.isBlank(string));
}
@Test
public void isNotBlank() {
String string = "null";
- Assert.isTrue(StringUtil.isNotBlank(string));
+ Assert.assertTrue(StringUtil.isNotBlank(string));
}
@Test
public void isAllNotEmpty() {
String strings = "str";
- Assert.isTrue(StringUtil.isAllNotEmpty(strings));
+ Assert.assertTrue(StringUtil.isAllNotEmpty(strings));
}
@Test
public void hasEmpty() {
String strings = "";
- Assert.isTrue(StringUtil.hasEmpty(strings));
+ Assert.assertTrue(StringUtil.hasEmpty(strings));
}
@Test
public void toUnderlineCase() {
String string = "str";
String s = StringUtil.toUnderlineCase(string);
- Assert.isTrue(Objects.equals(s, "str"));
+ Assert.assertEquals("str", s);
}
@Test
public void toSymbolCase() {
String string = "str";
String s = StringUtil.toSymbolCase(string, StringUtil.UNDERLINE);
- Assert.isTrue(Objects.equals(s, "str"));
+ Assert.assertEquals("str", s);
+ }
+
+ @Test
+ public void toCamelCase() {
+ String string = "str_str";
+ String s = StringUtil.toCamelCase(string, StringUtil.UNDERLINE);
+ Assert.assertEquals("strStr", s);
+ }
+
+ @Test
+ public void newBuilder() {
+ String s1 = StringUtil.newBuilder(null);
+ Assert.assertEquals("", s1);
+ String s2 = StringUtil.newBuilder("H", "ippo", "4j");
+ Assert.assertEquals("Hippo4j", s2);
+ }
+
+ @Test
+ public void createBuilder() {
+ StringBuilder s1 = StringUtil.createBuilder(null);
+ Assert.assertEquals("", s1.toString());
+ StringBuilder s2 = StringUtil.createBuilder("H", "ippo", "4j");
+ Assert.assertEquals("Hippo4j", s2.toString());
+ }
+
+ @Test
+ public void appends() {
+ StringBuilder sb1 = StringUtil.appends(null, "H", "ippo", "4j");
+ Assert.assertEquals("Hippo4j", sb1.toString());
+ StringBuilder sb2 = StringUtil.appends(StringUtil.createBuilder("To "), null);
+ Assert.assertEquals("To ", sb2.toString());
+ StringBuilder sb3 = StringUtil.appends(StringUtil.createBuilder("To "), "H", "ippo", "4j");
+ Assert.assertEquals("To Hippo4j", sb3.toString());
}
}
diff --git a/hippo4j-common/src/test/java/cn/hippo4j/common/toolkit/ThreadUtilTest.java b/hippo4j-common/src/test/java/cn/hippo4j/common/toolkit/ThreadUtilTest.java
index e428a733..88c2890a 100644
--- a/hippo4j-common/src/test/java/cn/hippo4j/common/toolkit/ThreadUtilTest.java
+++ b/hippo4j-common/src/test/java/cn/hippo4j/common/toolkit/ThreadUtilTest.java
@@ -18,8 +18,7 @@
package cn.hippo4j.common.toolkit;
import org.junit.Test;
-
-import static org.junit.Assert.assertTrue;
+import org.junit.Assert;
public class ThreadUtilTest {
@@ -32,11 +31,11 @@ public class ThreadUtilTest {
final Thread result = ThreadUtil.newThread(runnable, "name", false);
// Verify the results
- Assert.notNull(result);
+ Assert.assertNotNull(result);
}
@Test
public void testSleep() {
- assertTrue(ThreadUtil.sleep(0L));
+ Assert.assertTrue(ThreadUtil.sleep(0L));
}
}
diff --git a/hippo4j-common/src/test/java/cn/hippo4j/common/toolkit/UserContextTest.java b/hippo4j-common/src/test/java/cn/hippo4j/common/toolkit/UserContextTest.java
index 83543573..a361d139 100644
--- a/hippo4j-common/src/test/java/cn/hippo4j/common/toolkit/UserContextTest.java
+++ b/hippo4j-common/src/test/java/cn/hippo4j/common/toolkit/UserContextTest.java
@@ -17,11 +17,8 @@
package cn.hippo4j.common.toolkit;
-import cn.hutool.core.util.ReflectUtil;
import org.junit.jupiter.api.Test;
-import java.lang.reflect.Field;
-
public class UserContextTest {
private static final String USERNAME = "test";
diff --git a/hippo4j-common/src/test/java/cn/hippo4j/common/toolkit/http/HttpUtilsTest.java b/hippo4j-common/src/test/java/cn/hippo4j/common/toolkit/http/HttpUtilsTest.java
new file mode 100644
index 00000000..105228d6
--- /dev/null
+++ b/hippo4j-common/src/test/java/cn/hippo4j/common/toolkit/http/HttpUtilsTest.java
@@ -0,0 +1,122 @@
+/*
+ * 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 cn.hippo4j.common.toolkit.http;
+
+import cn.hippo4j.common.toolkit.JSONUtil;
+import lombok.Getter;
+import lombok.Setter;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.net.SocketTimeoutException;
+import java.util.HashMap;
+import java.util.Map;
+
+public class HttpUtilsTest {
+
+ /**
+ * test post url
+ */
+ static String postUrl = "http://console.hippo4j.cn/hippo4j/v1/cs/";
+
+ /**
+ * test get url
+ */
+ static String getUrl = "https://hippo4j.cn/";
+
+ @Test
+ public void get() {
+ String s = HttpUtil.get(getUrl);
+ Assert.assertNotNull(s);
+ }
+
+ @Test
+ public void restApiPost() {
+ String loginUrl = postUrl + "auth/login";
+ LoginInfo loginInfo = new LoginInfo();
+ loginInfo.setPassword("hippo4j");
+ loginInfo.setUsername("hippo4j");
+ loginInfo.setRememberMe(1);
+ String s = HttpUtil.post(loginUrl, loginInfo);
+ Result result = JSONUtil.parseObject(s, Result.class);
+ Assert.assertNotNull(result);
+ String data = result.getData().getData();
+ Assert.assertNotNull(data);
+ }
+
+ @Test
+ public void testRestApiPost() {
+ String loginUrl = postUrl + "auth/login";
+ LoginInfo loginInfo = new LoginInfo();
+ loginInfo.setPassword("hippo4j");
+ loginInfo.setUsername("hippo4j");
+ loginInfo.setRememberMe(1);
+ Result result = HttpUtil.post(loginUrl, loginInfo, Result.class);
+ Assert.assertNotNull(result);
+ String data = result.getData().getData();
+ Assert.assertNotNull(data);
+ }
+
+ @Test
+ public void testRestApiPostTimeout() {
+ String loginUrl = postUrl + "auth/login";
+ LoginInfo loginInfo = new LoginInfo();
+ loginInfo.setPassword("hippo4j");
+ loginInfo.setUsername("hippo4j");
+ loginInfo.setRememberMe(1);
+ Assert.assertThrows(SocketTimeoutException.class, () -> HttpUtil.post(loginUrl, loginInfo, 1, Result.class));
+ }
+
+ @Test
+ public void buildUrl() {
+ Map map = new HashMap<>();
+ map.put("password", "hippo4j");
+ map.put("username", "hippo4j");
+ String s = HttpUtil.buildUrl(getUrl, map);
+ Assert.assertEquals(getUrl + "?password=hippo4j&username=hippo4j", s);
+ }
+
+ @Getter
+ @Setter
+ private static class LoginInfo {
+
+ private String username;
+
+ private String password;
+
+ private Integer rememberMe;
+ }
+
+ @Getter
+ @Setter
+ private static class Result {
+
+ private String code;
+
+ private ResultData data;
+ }
+
+ @Getter
+ @Setter
+ private static class ResultData {
+
+ private String data;
+
+ private String[] roles;
+ }
+}
\ No newline at end of file
diff --git a/hippo4j-config/pom.xml b/hippo4j-config/pom.xml
index 61cd12de..75bf417b 100644
--- a/hippo4j-config/pom.xml
+++ b/hippo4j-config/pom.xml
@@ -15,70 +15,55 @@
+
+ cn.hippo4j
+ hippo4j-common
+ ${revision}
+
org.springframework.boot
spring-boot-starter
-
org.springframework.boot
spring-boot-starter-web
-
com.baomidou
mybatis-plus-boot-starter
-
mysql
mysql-connector-java
runtime
-
com.h2database
h2
${h2.version}
runtime
-
-
- cn.hutool
- hutool-all
-
-
-
- cn.hippo4j
- hippo4j-common
- ${revision}
-
-
-
- com.github.dozermapper
- dozer-core
-
-
org.projectlombok
lombok
-
cn.hippo4j
hippo4j-adapter-base
-
+
+ cn.hippo4j
+ hippo4j-discovery
+ ${version}
+
io.netty
netty-all
-
org.hibernate.validator
hibernate-validator
-
org.springframework.boot
spring-boot-starter-test
diff --git a/hippo4j-config/src/main/java/cn/hippo4j/config/controller/ConfigController.java b/hippo4j-config/src/main/java/cn/hippo4j/config/controller/ConfigController.java
index 5c0fe84f..f4c48610 100644
--- a/hippo4j-config/src/main/java/cn/hippo4j/config/controller/ConfigController.java
+++ b/hippo4j-config/src/main/java/cn/hippo4j/config/controller/ConfigController.java
@@ -17,17 +17,22 @@
package cn.hippo4j.config.controller;
+import cn.hippo4j.common.constant.ConfigModifyTypeConstants;
import cn.hippo4j.common.constant.Constants;
import cn.hippo4j.common.model.register.DynamicThreadPoolRegisterWrapper;
+import cn.hippo4j.common.toolkit.BeanUtil;
+import cn.hippo4j.common.toolkit.StringUtil;
+import cn.hippo4j.common.toolkit.UserContext;
import cn.hippo4j.common.web.base.Result;
import cn.hippo4j.common.web.base.Results;
import cn.hippo4j.config.model.ConfigAllInfo;
import cn.hippo4j.config.model.ConfigInfoBase;
+import cn.hippo4j.config.model.biz.threadpool.ConfigModifySaveReqDTO;
import cn.hippo4j.config.service.ConfigCacheService;
import cn.hippo4j.config.service.ConfigServletInner;
import cn.hippo4j.config.service.biz.ConfigService;
import cn.hippo4j.config.toolkit.Md5ConfigUtil;
-import cn.hutool.core.util.StrUtil;
+import cn.hippo4j.config.verify.ConfigModificationVerifyServiceChoose;
import lombok.AllArgsConstructor;
import lombok.SneakyThrows;
import org.springframework.util.StringUtils;
@@ -50,6 +55,8 @@ public class ConfigController {
private final ConfigServletInner configServletInner;
+ private final ConfigModificationVerifyServiceChoose configModificationVerifyServiceChoose;
+
@GetMapping
public Result detailConfigInfo(@RequestParam("tpId") String tpId,
@RequestParam("itemId") String itemId,
@@ -62,7 +69,18 @@ public class ConfigController {
@PostMapping
public Result publishConfig(@RequestParam(value = "identify", required = false) String identify,
@RequestBody ConfigAllInfo config) {
- configService.insertOrUpdate(identify, true, config);
+ if (UserContext.getUserRole().equals("ROLE_ADMIN")) {
+ configService.insertOrUpdate(identify, true, config);
+ } else {
+ ConfigModifySaveReqDTO modifySaveReqDTO = BeanUtil.convert(config, ConfigModifySaveReqDTO.class);
+ modifySaveReqDTO.setCorePoolSize(config.getCoreSize());
+ modifySaveReqDTO.setMaximumPoolSize(config.getMaxSize());
+ modifySaveReqDTO.setModifyUser(UserContext.getUserName());
+ modifySaveReqDTO.setModifyAll(StringUtil.isEmpty(identify) ? true : false);
+ modifySaveReqDTO.setIdentify(identify);
+ modifySaveReqDTO.setType(ConfigModifyTypeConstants.THREAD_POOL_INSTANCE);
+ configModificationVerifyServiceChoose.choose(modifySaveReqDTO.getType()).saveConfigModifyApplication(modifySaveReqDTO);
+ }
return Results.success(true);
}
@@ -87,7 +105,7 @@ public class ConfigController {
@PostMapping("/remove/config/cache")
public Result removeConfigCache(@RequestBody Map bodyMap) {
String groupKey = bodyMap.get(Constants.GROUP_KEY);
- if (StrUtil.isNotBlank(groupKey)) {
+ if (StringUtil.isNotBlank(groupKey)) {
ConfigCacheService.removeConfigCache(groupKey);
}
return Results.success();
diff --git a/hippo4j-core/src/main/java/cn/hippo4j/core/executor/support/ExecutorContext.java b/hippo4j-config/src/main/java/cn/hippo4j/config/mapper/HisConfigVerifyMapper.java
similarity index 65%
rename from hippo4j-core/src/main/java/cn/hippo4j/core/executor/support/ExecutorContext.java
rename to hippo4j-config/src/main/java/cn/hippo4j/config/mapper/HisConfigVerifyMapper.java
index 7cd2db56..c7c5b53e 100644
--- a/hippo4j-core/src/main/java/cn/hippo4j/core/executor/support/ExecutorContext.java
+++ b/hippo4j-config/src/main/java/cn/hippo4j/config/mapper/HisConfigVerifyMapper.java
@@ -15,23 +15,15 @@
* limitations under the License.
*/
-package cn.hippo4j.core.executor.support;
+package cn.hippo4j.config.mapper;
-import org.slf4j.MDC;
-
-import static cn.hippo4j.common.constant.Constants.EXECUTE_TIMEOUT_TRACE;
+import cn.hippo4j.config.model.HisConfigVerifyInfo;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import org.apache.ibatis.annotations.Mapper;
/**
- * Executor context.
+ * his config verify info mapper
*/
-public class ExecutorContext {
-
- /**
- * Put execute timeout trace.
- *
- * @param executeTimeoutTrace
- */
- public static void putExecuteTimeoutTrace(String executeTimeoutTrace) {
- MDC.put(EXECUTE_TIMEOUT_TRACE, executeTimeoutTrace);
- }
+@Mapper
+public interface HisConfigVerifyMapper extends BaseMapper {
}
diff --git a/hippo4j-config/src/main/java/cn/hippo4j/config/model/HisConfigVerifyInfo.java b/hippo4j-config/src/main/java/cn/hippo4j/config/model/HisConfigVerifyInfo.java
new file mode 100644
index 00000000..4fdab92a
--- /dev/null
+++ b/hippo4j-config/src/main/java/cn/hippo4j/config/model/HisConfigVerifyInfo.java
@@ -0,0 +1,101 @@
+/*
+ * 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 cn.hippo4j.config.model;
+
+import com.baomidou.mybatisplus.annotation.*;
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import lombok.Data;
+
+import java.util.Date;
+
+/**
+ * His config verify info
+ */
+@Data
+@TableName("his_config_verify")
+public class HisConfigVerifyInfo {
+
+ @TableId(type = IdType.AUTO)
+ private Long id;
+
+ /**
+ * Change type
+ */
+ private Integer type;
+
+ /**
+ * Tenant id
+ */
+ private String tenantId;
+
+ /**
+ * Item id
+ */
+ private String itemId;
+
+ /**
+ * Thread pool id
+ */
+ private String tpId;
+
+ /**
+ * Thread pool mark
+ */
+ private String mark;
+
+ /**
+ * Thread pool instance identify
+ */
+ private String identify;
+
+ /**
+ * Config content
+ */
+ private String content;
+
+ /**
+ * Weather modify all thread pool instances
+ */
+ private Boolean modifyAll = false;
+
+ /**
+ * GmtCreate
+ */
+ @TableField(fill = FieldFill.INSERT)
+ private Date gmtCreate;
+
+ /**
+ * ModifyUserId
+ */
+ private String modifyUser;
+
+ /**
+ * Verify status
+ */
+ private Integer verifyStatus;
+
+ /**
+ * GmtVerify
+ */
+ private Date gmtVerify;
+
+ /**
+ * VerifyUser
+ */
+ private String verifyUser;
+}
diff --git a/hippo4j-config/src/main/java/cn/hippo4j/config/model/biz/adapter/ThreadPoolAdapterReqDTO.java b/hippo4j-config/src/main/java/cn/hippo4j/config/model/biz/adapter/ThreadPoolAdapterReqDTO.java
index e55b4571..55514186 100644
--- a/hippo4j-config/src/main/java/cn/hippo4j/config/model/biz/adapter/ThreadPoolAdapterReqDTO.java
+++ b/hippo4j-config/src/main/java/cn/hippo4j/config/model/biz/adapter/ThreadPoolAdapterReqDTO.java
@@ -66,4 +66,9 @@ public class ThreadPoolAdapterReqDTO {
* Client address list
*/
private List clientAddressList;
+
+ /**
+ * weather Modify all instances
+ */
+ private Boolean modifyAll;
}
diff --git a/hippo4j-config/src/main/java/cn/hippo4j/config/model/biz/threadpool/ConfigModificationQueryRespDTO.java b/hippo4j-config/src/main/java/cn/hippo4j/config/model/biz/threadpool/ConfigModificationQueryRespDTO.java
new file mode 100644
index 00000000..331db35e
--- /dev/null
+++ b/hippo4j-config/src/main/java/cn/hippo4j/config/model/biz/threadpool/ConfigModificationQueryRespDTO.java
@@ -0,0 +1,97 @@
+/*
+ * 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 cn.hippo4j.config.model.biz.threadpool;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import lombok.Data;
+
+import java.util.Date;
+
+/**
+ * Config modify query resp
+ */
+@Data
+public class ConfigModificationQueryRespDTO {
+
+ /**
+ * His_config_verify id
+ */
+ private String id;
+
+ /**
+ * Config modify type
+ */
+ private Integer type;
+
+ /**
+ * Thread pool mark
+ */
+ private String mark;
+
+ /**
+ * Tenant id
+ */
+ private String tenantId;
+
+ /**
+ * Item id
+ */
+ private String itemId;
+
+ /**
+ * Thread pool id
+ */
+ private String tpId;
+
+ /**
+ * Thread pool identify
+ */
+ private String identify;
+
+ /**
+ * Weather modify all instances
+ */
+ private Boolean modifyAll;
+
+ /**
+ * Modify user
+ */
+ private String modifyUser;
+
+ /**
+ * Verify status
+ */
+ private Integer verifyStatus;
+
+ /**
+ * GmtCreate
+ */
+ @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
+ private Date gmtCreate;
+
+ /**
+ * GmtVerify
+ */
+ @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
+ private Date gmtVerify;
+
+ /**
+ * Verify user
+ */
+ private String verifyUser;
+}
diff --git a/hippo4j-config/src/main/java/cn/hippo4j/config/model/biz/threadpool/ConfigModifySaveReqDTO.java b/hippo4j-config/src/main/java/cn/hippo4j/config/model/biz/threadpool/ConfigModifySaveReqDTO.java
new file mode 100644
index 00000000..035bd038
--- /dev/null
+++ b/hippo4j-config/src/main/java/cn/hippo4j/config/model/biz/threadpool/ConfigModifySaveReqDTO.java
@@ -0,0 +1,124 @@
+/*
+ * 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 cn.hippo4j.config.model.biz.threadpool;
+
+import lombok.Data;
+
+import javax.validation.constraints.Pattern;
+
+@Data
+public class ConfigModifySaveReqDTO {
+
+ /**
+ * Thread pool config change type.
+ */
+ private Integer type;
+
+ /**
+ * Thread pool instance id
+ */
+ private String identify;
+
+ /**
+ * Weather modify all instances
+ */
+ private Boolean modifyAll = false;
+
+ /**
+ * Tenant Id
+ */
+ @Pattern(regexp = "^((?!\\+).)*$", message = "租户、项目、线程池 ID 包含+号")
+ private String tenantId;
+
+ /**
+ * Thread pool id
+ */
+ @Pattern(regexp = "^((?!\\+).)*$", message = "租户、项目、线程池 ID 包含+号")
+ private String tpId;
+
+ /**
+ * Item id
+ */
+ @Pattern(regexp = "^((?!\\+).)*$", message = "租户、项目、线程池 ID 包含+号")
+ private String itemId;
+
+ /**
+ * Thread pool mark
+ */
+ private String mark;
+
+ /**
+ * Core pool size
+ */
+ private Integer corePoolSize;
+
+ /**
+ * Maximum pool size
+ */
+ private Integer maximumPoolSize;
+
+ /**
+ * Queue type
+ */
+ private Integer queueType;
+
+ /**
+ * Capacity
+ */
+ private Integer capacity;
+
+ /**
+ * Keep alive time
+ */
+ private Integer keepAliveTime;
+
+ /**
+ * Execute time out
+ */
+ private Long executeTimeOut;
+
+ /**
+ * Is alarm
+ */
+ private Integer isAlarm;
+
+ /**
+ * Capacity alarm
+ */
+ private Integer capacityAlarm;
+
+ /**
+ * Liveness alarm
+ */
+ private Integer livenessAlarm;
+
+ /**
+ * Rejected type
+ */
+ private Integer rejectedType;
+
+ /**
+ * Allow core thread timeout
+ */
+ private Integer allowCoreThreadTimeOut;
+
+ /**
+ * ModifyUser
+ */
+ private String modifyUser;
+}
diff --git a/hippo4j-config/src/main/java/cn/hippo4j/config/model/biz/threadpool/ConfigModifyVerifyReqDTO.java b/hippo4j-config/src/main/java/cn/hippo4j/config/model/biz/threadpool/ConfigModifyVerifyReqDTO.java
new file mode 100644
index 00000000..946e4764
--- /dev/null
+++ b/hippo4j-config/src/main/java/cn/hippo4j/config/model/biz/threadpool/ConfigModifyVerifyReqDTO.java
@@ -0,0 +1,138 @@
+/*
+ * 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 cn.hippo4j.config.model.biz.threadpool;
+
+import com.fasterxml.jackson.annotation.JsonAlias;
+import lombok.Data;
+
+import java.util.List;
+
+/**
+ * Config modify verify dto
+ */
+@Data
+public class ConfigModifyVerifyReqDTO {
+
+ /**
+ * His config verify id
+ */
+ private String id;
+
+ /**
+ * Config verify type
+ */
+ private Integer type;
+
+ /**
+ * Tenant id
+ */
+ private String tenantId;
+
+ /**
+ * Item id
+ */
+ private String itemId;
+
+ /**
+ * Instance identify
+ */
+ private String identify;
+
+ /**
+ * Adapter thread pool mark
+ */
+ private String mark;
+
+ /**
+ * Adapter thread pool key
+ */
+ private String threadPoolKey;
+
+ /**
+ * Thread pool id
+ */
+ @JsonAlias("threadPoolId")
+ private String tpId;
+
+ /**
+ * Weather modify all instances
+ */
+ private Boolean modifyAll;
+
+ /**
+ * Weather accept config modification
+ */
+ private Boolean accept;
+
+ /**
+ * Core pool size
+ */
+ private Integer corePoolSize;
+
+ /**
+ * Maximum pool size
+ */
+ private Integer maximumPoolSize;
+
+ /**
+ * Queue type
+ */
+ private Integer queueType;
+
+ /**
+ * Capacity
+ */
+ private Integer capacity;
+
+ /**
+ * Keep alive time
+ */
+ private Integer keepAliveTime;
+
+ /**
+ * Execute time out
+ */
+ private Long executeTimeOut;
+
+ /**
+ * Rejected type
+ */
+ private Integer rejectedType;
+
+ /**
+ * Is alarm
+ */
+ private Integer isAlarm;
+
+ /**
+ * Capacity alarm
+ */
+ private Integer capacityAlarm;
+
+ /**
+ * Liveness alarm
+ */
+ @JsonAlias("activeAlarm")
+ private Integer livenessAlarm;
+
+ /**
+ * Allow core thread timeout
+ */
+ private Integer allowCoreThreadTimeOut;
+
+}
diff --git a/hippo4j-config/src/main/java/cn/hippo4j/config/monitor/QueryMonitorExecuteChoose.java b/hippo4j-config/src/main/java/cn/hippo4j/config/monitor/QueryMonitorExecuteChoose.java
index 5aedb340..2dfd9a6b 100644
--- a/hippo4j-config/src/main/java/cn/hippo4j/config/monitor/QueryMonitorExecuteChoose.java
+++ b/hippo4j-config/src/main/java/cn/hippo4j/config/monitor/QueryMonitorExecuteChoose.java
@@ -20,10 +20,10 @@ package cn.hippo4j.config.monitor;
import cn.hippo4j.common.config.ApplicationContextHolder;
import cn.hippo4j.common.monitor.Message;
import cn.hippo4j.common.monitor.MessageTypeEnum;
-import com.google.common.collect.Maps;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
+import java.util.HashMap;
import java.util.Map;
/**
@@ -35,7 +35,7 @@ public class QueryMonitorExecuteChoose implements CommandLineRunner {
/**
* Storage monitoring data execution container.
*/
- private Map monitorDataExecuteStrategyChooseMap = Maps.newHashMap();
+ private Map monitorDataExecuteStrategyChooseMap = new HashMap<>();
/**
* Choose by {@link cn.hippo4j.common.monitor.MessageTypeEnum}.
diff --git a/hippo4j-config/src/main/java/cn/hippo4j/config/monitor/TimeCleanHistoryDataTask.java b/hippo4j-config/src/main/java/cn/hippo4j/config/monitor/TimeCleanHistoryDataTask.java
index 6aa4df3f..f97fe5d0 100644
--- a/hippo4j-config/src/main/java/cn/hippo4j/config/monitor/TimeCleanHistoryDataTask.java
+++ b/hippo4j-config/src/main/java/cn/hippo4j/config/monitor/TimeCleanHistoryDataTask.java
@@ -18,11 +18,10 @@
package cn.hippo4j.config.monitor;
import cn.hippo4j.common.executor.ExecutorFactory;
+import cn.hippo4j.common.toolkit.DateUtil;
import cn.hippo4j.config.config.ServerBootstrapProperties;
import cn.hippo4j.config.model.HisRunDataInfo;
import cn.hippo4j.config.service.biz.HisRunDataService;
-import cn.hutool.core.date.DateTime;
-import cn.hutool.core.date.DateUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import lombok.NonNull;
@@ -30,6 +29,7 @@ import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.stereotype.Component;
+import java.time.LocalDateTime;
import java.util.Date;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
@@ -53,10 +53,9 @@ public class TimeCleanHistoryDataTask implements Runnable, InitializingBean {
@Override
public void run() {
- Date currentDate = new Date();
- DateTime offsetMinuteDateTime = DateUtil.offsetMinute(currentDate, -properties.getCleanHistoryDataPeriod());
+ LocalDateTime offsetMinuteDateTime = LocalDateTime.now().plusMinutes(-properties.getCleanHistoryDataPeriod());
LambdaQueryWrapper queryWrapper = Wrappers.lambdaQuery(HisRunDataInfo.class)
- .le(HisRunDataInfo::getTimestamp, offsetMinuteDateTime.getTime());
+ .le(HisRunDataInfo::getTimestamp, DateUtil.getTime(offsetMinuteDateTime));
hisRunDataService.remove(queryWrapper);
}
diff --git a/hippo4j-config/src/main/java/cn/hippo4j/config/notify/DefaultPublisher.java b/hippo4j-config/src/main/java/cn/hippo4j/config/notify/DefaultPublisher.java
index 6c2860ff..7b8f67e6 100644
--- a/hippo4j-config/src/main/java/cn/hippo4j/config/notify/DefaultPublisher.java
+++ b/hippo4j-config/src/main/java/cn/hippo4j/config/notify/DefaultPublisher.java
@@ -18,11 +18,13 @@
package cn.hippo4j.config.notify;
import cn.hippo4j.config.event.AbstractEvent;
-import cn.hutool.core.collection.ConcurrentHashSet;
import cn.hippo4j.config.notify.listener.AbstractSubscriber;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.CollectionUtils;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Executor;
@@ -34,7 +36,7 @@ import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
@Slf4j
public class DefaultPublisher extends Thread implements EventPublisher {
- protected final ConcurrentHashSet subscribers = new ConcurrentHashSet();
+ protected final Set subscribers = Collections.synchronizedSet(new HashSet<>());
private BlockingQueue queue;
diff --git a/hippo4j-config/src/main/java/cn/hippo4j/config/notify/DefaultSharePublisher.java b/hippo4j-config/src/main/java/cn/hippo4j/config/notify/DefaultSharePublisher.java
index b877bfbb..185a6352 100644
--- a/hippo4j-config/src/main/java/cn/hippo4j/config/notify/DefaultSharePublisher.java
+++ b/hippo4j-config/src/main/java/cn/hippo4j/config/notify/DefaultSharePublisher.java
@@ -18,10 +18,11 @@
package cn.hippo4j.config.notify;
import cn.hippo4j.config.event.AbstractEvent;
-import cn.hutool.core.collection.ConcurrentHashSet;
import cn.hippo4j.config.notify.listener.AbstractSubscriber;
import cn.hippo4j.config.event.AbstractSlowEvent;
+import java.util.Collections;
+import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
@@ -35,7 +36,7 @@ public class DefaultSharePublisher extends DefaultPublisher {
private final Map, Set> subMappings = new ConcurrentHashMap();
- protected final ConcurrentHashSet subscribers = new ConcurrentHashSet();
+ protected final Set subscribers = Collections.synchronizedSet(new HashSet<>());
private final Lock lock = new ReentrantLock();
@@ -46,7 +47,7 @@ public class DefaultSharePublisher extends DefaultPublisher {
try {
Set sets = subMappings.get(subSlowEventType);
if (sets == null) {
- Set newSet = new ConcurrentHashSet();
+ Set newSet = Collections.synchronizedSet(new HashSet<>());
newSet.add(subscriber);
subMappings.put(subSlowEventType, newSet);
return;
diff --git a/hippo4j-config/src/main/java/cn/hippo4j/config/service/ConfigCacheService.java b/hippo4j-config/src/main/java/cn/hippo4j/config/service/ConfigCacheService.java
index 8802b6d4..e71400b6 100644
--- a/hippo4j-config/src/main/java/cn/hippo4j/config/service/ConfigCacheService.java
+++ b/hippo4j-config/src/main/java/cn/hippo4j/config/service/ConfigCacheService.java
@@ -24,18 +24,15 @@ import cn.hippo4j.common.design.observer.Observer;
import cn.hippo4j.common.design.observer.ObserverMessage;
import cn.hippo4j.common.toolkit.CollectionUtil;
import cn.hippo4j.common.toolkit.JSONUtil;
+import cn.hippo4j.common.toolkit.Joiner;
import cn.hippo4j.common.toolkit.Md5Util;
+import cn.hippo4j.common.toolkit.StringUtil;
import cn.hippo4j.config.event.LocalDataChangeEvent;
import cn.hippo4j.config.model.CacheItem;
import cn.hippo4j.config.model.ConfigAllInfo;
import cn.hippo4j.config.notify.NotifyCenter;
import cn.hippo4j.config.service.biz.ConfigService;
import cn.hippo4j.config.toolkit.MapUtil;
-import cn.hutool.core.collection.CollUtil;
-import cn.hutool.core.util.StrUtil;
-import com.google.common.base.Joiner;
-import com.google.common.collect.Lists;
-import com.google.common.collect.Maps;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.StringUtils;
@@ -96,9 +93,9 @@ public class ConfigCacheService {
* @return
*/
private synchronized static String getContentMd5IsNullPut(String groupKey, String clientIdentify) {
- Map cacheItemMap = Optional.ofNullable(CLIENT_CONFIG_CACHE.get(groupKey)).orElse(Maps.newHashMap());
+ Map cacheItemMap = Optional.ofNullable(CLIENT_CONFIG_CACHE.get(groupKey)).orElse(new HashMap<>());
CacheItem cacheItem = null;
- if (CollUtil.isNotEmpty(cacheItemMap) && (cacheItem = cacheItemMap.get(clientIdentify)) != null) {
+ if (CollectionUtil.isNotEmpty(cacheItemMap) && (cacheItem = cacheItemMap.get(clientIdentify)) != null) {
return cacheItem.md5;
}
if (CONFIG_SERVICE == null) {
@@ -106,7 +103,7 @@ public class ConfigCacheService {
}
String[] params = groupKey.split(GROUP_KEY_DELIMITER_TRANSLATION);
ConfigAllInfo config = CONFIG_SERVICE.findConfigRecentInfo(params);
- if (config != null && StrUtil.isNotBlank(config.getTpId())) {
+ if (config != null && StringUtil.isNotBlank(config.getTpId())) {
cacheItem = new CacheItem(groupKey, config);
cacheItemMap.put(clientIdentify, cacheItem);
CLIENT_CONFIG_CACHE.put(groupKey, cacheItemMap);
@@ -146,7 +143,7 @@ public class ConfigCacheService {
return item;
}
CacheItem tmp = new CacheItem(groupKey);
- Map cacheItemMap = Maps.newHashMap();
+ Map cacheItemMap = new HashMap<>();
cacheItemMap.put(ip, tmp);
CLIENT_CONFIG_CACHE.putIfAbsent(groupKey, cacheItemMap);
return tmp;
@@ -154,7 +151,7 @@ public class ConfigCacheService {
public static Map getContent(String identification) {
List identificationList = MapUtil.parseMapForFilter(CLIENT_CONFIG_CACHE, identification);
- Map returnStrCacheItemMap = Maps.newHashMap();
+ Map returnStrCacheItemMap = new HashMap<>();
identificationList.forEach(each -> returnStrCacheItemMap.putAll(CLIENT_CONFIG_CACHE.get(each)));
return returnStrCacheItemMap;
}
@@ -167,13 +164,13 @@ public class ConfigCacheService {
public static List getIdentifyList(String tenantId, String itemId, String threadPoolId) {
List identifyList = null;
- String buildKey = Joiner.on(GROUP_KEY_DELIMITER).join(Lists.newArrayList(threadPoolId, itemId, tenantId));
+ String buildKey = Joiner.on(GROUP_KEY_DELIMITER).join(CollectionUtil.newArrayList(threadPoolId, itemId, tenantId));
List keys = MapUtil.parseMapForFilter(CLIENT_CONFIG_CACHE, buildKey);
if (CollectionUtil.isNotEmpty(keys)) {
- identifyList = new ArrayList(keys.size());
+ identifyList = new ArrayList<>(keys.size());
for (String each : keys) {
String[] keyArray = each.split(GROUP_KEY_DELIMITER_TRANSLATION);
- if (keyArray != null && keyArray.length > 2) {
+ if (keyArray.length > 2) {
identifyList.add(keyArray[3]);
}
}
diff --git a/hippo4j-config/src/main/java/cn/hippo4j/config/service/ConfigServletInner.java b/hippo4j-config/src/main/java/cn/hippo4j/config/service/ConfigServletInner.java
index bbe8ee51..16eb8f4d 100644
--- a/hippo4j-config/src/main/java/cn/hippo4j/config/service/ConfigServletInner.java
+++ b/hippo4j-config/src/main/java/cn/hippo4j/config/service/ConfigServletInner.java
@@ -17,9 +17,8 @@
package cn.hippo4j.config.service;
-import com.google.common.cache.Cache;
-import com.google.common.cache.CacheBuilder;
-import lombok.NonNull;
+import com.github.benmanes.caffeine.cache.Cache;
+import com.github.benmanes.caffeine.cache.Caffeine;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
@@ -36,20 +35,21 @@ import static cn.hippo4j.common.constant.Constants.WEIGHT_CONFIGS;
@RequiredArgsConstructor
public class ConfigServletInner {
- @NonNull
private final LongPollingService longPollingService;
- private final Cache deWeightCache = CacheBuilder.newBuilder()
- .maximumSize(1024)
+ private static final int CLIENT_IDENTIFY_MAXIMUM_SIZE = 16384;
+
+ private final Cache deWeightCache = Caffeine.newBuilder()
+ .maximumSize(CLIENT_IDENTIFY_MAXIMUM_SIZE)
.build();
/**
* Poll configuration.
*
- * @param request
- * @param response
- * @param clientMd5Map
- * @param probeRequestSize
+ * @param request http servlet request
+ * @param response http servlet response
+ * @param clientMd5Map client md5 map
+ * @param probeRequestSize probe request size
* @return
*/
public String doPollingConfig(HttpServletRequest request, HttpServletResponse response, Map clientMd5Map, int probeRequestSize) {
@@ -66,7 +66,7 @@ public class ConfigServletInner {
* When a user proposes to deploy in the company environment, the same request will be called repeatedly.
* This problem belongs to an extremely individual scenario. Since it cannot be reproduced, so first solve the problem in this way.
*
- * @param request
+ * @param request http servlet request
* @return
*/
private boolean weightVerification(HttpServletRequest request) {
diff --git a/hippo4j-config/src/main/java/cn/hippo4j/config/service/LongPollingService.java b/hippo4j-config/src/main/java/cn/hippo4j/config/service/LongPollingService.java
index 918e6a3c..5e8fd0fd 100644
--- a/hippo4j-config/src/main/java/cn/hippo4j/config/service/LongPollingService.java
+++ b/hippo4j-config/src/main/java/cn/hippo4j/config/service/LongPollingService.java
@@ -17,8 +17,10 @@
package cn.hippo4j.config.service;
+import cn.hippo4j.common.toolkit.CollectionUtil;
import cn.hippo4j.common.toolkit.JSONUtil;
import cn.hippo4j.common.toolkit.Md5Util;
+import cn.hippo4j.common.toolkit.StringUtil;
import cn.hippo4j.common.web.base.Results;
import cn.hippo4j.config.event.AbstractEvent;
import cn.hippo4j.config.event.LocalDataChangeEvent;
@@ -28,9 +30,6 @@ import cn.hippo4j.config.toolkit.ConfigExecutor;
import cn.hippo4j.config.toolkit.MapUtil;
import cn.hippo4j.config.toolkit.Md5ConfigUtil;
import cn.hippo4j.config.toolkit.RequestUtil;
-import cn.hutool.core.collection.CollUtil;
-import cn.hutool.core.util.StrUtil;
-import com.google.common.collect.Lists;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
@@ -117,8 +116,8 @@ public class LongPollingService {
for (Iterator iter = allSubs.iterator(); iter.hasNext();) {
ClientLongPolling clientSub = iter.next();
String identity = groupKey + GROUP_KEY_DELIMITER + identify;
- List parseMapForFilter = Lists.newArrayList(identity);
- if (StrUtil.isBlank(identify)) {
+ List parseMapForFilter = CollectionUtil.newArrayList(identity);
+ if (StringUtil.isBlank(identify)) {
parseMapForFilter = MapUtil.parseMapForFilter(clientSub.clientMd5Map, groupKey);
}
parseMapForFilter.forEach(each -> {
@@ -274,7 +273,7 @@ public class LongPollingService {
* @param changedGroups Changed thread pool group key
*/
private void generateResponse(HttpServletResponse response, List changedGroups) {
- if (CollUtil.isNotEmpty(changedGroups)) {
+ if (CollectionUtil.isNotEmpty(changedGroups)) {
try {
String respStr = buildRespStr(changedGroups);
response.setHeader("Pragma", "no-cache");
diff --git a/hippo4j-config/src/main/java/cn/hippo4j/config/service/ThreadPoolAdapterService.java b/hippo4j-config/src/main/java/cn/hippo4j/config/service/ThreadPoolAdapterService.java
index d27c04e8..03b23bb5 100644
--- a/hippo4j-config/src/main/java/cn/hippo4j/config/service/ThreadPoolAdapterService.java
+++ b/hippo4j-config/src/main/java/cn/hippo4j/config/service/ThreadPoolAdapterService.java
@@ -25,21 +25,18 @@ import cn.hippo4j.common.design.observer.ObserverMessage;
import cn.hippo4j.common.toolkit.CollectionUtil;
import cn.hippo4j.common.toolkit.JSONUtil;
import cn.hippo4j.common.toolkit.StringUtil;
+import cn.hippo4j.common.toolkit.http.HttpUtil;
import cn.hippo4j.common.web.base.Result;
import cn.hippo4j.config.model.biz.adapter.ThreadPoolAdapterReqDTO;
import cn.hippo4j.config.model.biz.adapter.ThreadPoolAdapterRespDTO;
-import cn.hutool.core.text.StrBuilder;
-import cn.hutool.http.HttpUtil;
import com.fasterxml.jackson.core.type.TypeReference;
-import com.google.common.collect.Lists;
-import com.google.common.collect.Maps;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors;
-import static cn.hippo4j.common.constant.Constants.HTTP_EXECUTE_TIMEOUT;
import static cn.hippo4j.common.constant.Constants.IDENTIFY_SLICER_SYMBOL;
/**
@@ -50,9 +47,9 @@ import static cn.hippo4j.common.constant.Constants.IDENTIFY_SLICER_SYMBOL;
public class ThreadPoolAdapterService {
/**
- * Map>>>
+ * Map<mark, Map<tenantItem, Map<threadPoolKey, List<ThreadPoolAdapterState>>>>
*/
- private static final Map>>> THREAD_POOL_ADAPTER_MAP = Maps.newConcurrentMap();
+ private static final Map>>> THREAD_POOL_ADAPTER_MAP = new ConcurrentHashMap<>();
static {
AbstractSubjectCenter.register(AbstractSubjectCenter.SubjectType.CLEAR_CONFIG_CACHE, new ClearThreadPoolAdapterCache());
@@ -64,19 +61,19 @@ public class ThreadPoolAdapterService {
String mark = each.getMark();
Map>> actual = THREAD_POOL_ADAPTER_MAP.get(mark);
if (CollectionUtil.isEmpty(actual)) {
- actual = Maps.newHashMap();
+ actual = new HashMap<>();
THREAD_POOL_ADAPTER_MAP.put(mark, actual);
}
Map> tenantItemMap = actual.get(each.getTenantItemKey());
if (CollectionUtil.isEmpty(tenantItemMap)) {
- tenantItemMap = Maps.newHashMap();
+ tenantItemMap = new HashMap<>();
actual.put(each.getTenantItemKey(), tenantItemMap);
}
List threadPoolAdapterStates = each.getThreadPoolAdapterStates();
for (ThreadPoolAdapterState adapterState : threadPoolAdapterStates) {
List adapterStateList = tenantItemMap.get(adapterState.getThreadPoolKey());
if (CollectionUtil.isEmpty(adapterStateList)) {
- adapterStateList = Lists.newArrayList();
+ adapterStateList = new ArrayList<>();
tenantItemMap.put(adapterState.getThreadPoolKey(), adapterStateList);
}
Optional first = adapterStateList.stream().filter(state -> Objects.equals(state.getClientAddress(), each.getClientAddress())).findFirst();
@@ -95,16 +92,16 @@ public class ThreadPoolAdapterService {
List actual = Optional.ofNullable(THREAD_POOL_ADAPTER_MAP.get(requestParameter.getMark()))
.map(each -> each.get(requestParameter.getTenant() + IDENTIFY_SLICER_SYMBOL + requestParameter.getItem()))
.map(each -> each.get(requestParameter.getThreadPoolKey()))
- .orElse(Lists.newArrayList());
+ .orElse(new ArrayList<>());
List addressList = actual.stream().map(ThreadPoolAdapterState::getClientAddress).collect(Collectors.toList());
List result = new ArrayList<>(addressList.size());
addressList.forEach(each -> {
- String urlString = StrBuilder.create("http://", each, "/adapter/thread-pool/info").toString();
- Map param = Maps.newHashMap();
+ String url = StringUtil.newBuilder("http://", each, "/adapter/thread-pool/info");
+ Map param = new HashMap<>();
param.put("mark", requestParameter.getMark());
param.put("threadPoolKey", requestParameter.getThreadPoolKey());
try {
- String resultStr = HttpUtil.get(urlString, param, HTTP_EXECUTE_TIMEOUT);
+ String resultStr = HttpUtil.get(url, param);
if (StringUtil.isNotBlank(resultStr)) {
Result restResult = JSONUtil.parseObject(resultStr, new TypeReference>() {
});
@@ -126,22 +123,13 @@ public class ThreadPoolAdapterService {
return actual.keySet();
}
}
- return new HashSet();
+ return new HashSet<>();
}
public static void remove(String identify) {
synchronized (ThreadPoolAdapterService.class) {
- THREAD_POOL_ADAPTER_MAP.values().forEach(each -> each.forEach((key, val) -> {
- val.forEach((threadPoolKey, states) -> {
- Iterator iterator = states.iterator();
- while (iterator.hasNext()) {
- ThreadPoolAdapterState adapterState = iterator.next();
- if (Objects.equals(adapterState.getIdentify(), identify)) {
- iterator.remove();
- }
- }
- });
- }));
+ THREAD_POOL_ADAPTER_MAP.values()
+ .forEach(each -> each.forEach((key, val) -> val.forEach((threadPoolKey, states) -> states.removeIf(adapterState -> Objects.equals(adapterState.getIdentify(), identify)))));
}
}
diff --git a/hippo4j-config/src/main/java/cn/hippo4j/config/service/biz/ConfigModificationQueryService.java b/hippo4j-config/src/main/java/cn/hippo4j/config/service/biz/ConfigModificationQueryService.java
new file mode 100644
index 00000000..2f8d3f63
--- /dev/null
+++ b/hippo4j-config/src/main/java/cn/hippo4j/config/service/biz/ConfigModificationQueryService.java
@@ -0,0 +1,45 @@
+/*
+ * 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 cn.hippo4j.config.service.biz;
+
+import cn.hippo4j.common.model.ThreadPoolParameterInfo;
+import cn.hippo4j.config.model.biz.threadpool.ConfigModificationQueryRespDTO;
+import cn.hippo4j.config.model.biz.threadpool.ThreadPoolQueryReqDTO;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+
+/**
+ * Config modification application query service.
+ */
+public interface ConfigModificationQueryService {
+
+ /**
+ * Query config modification application page.
+ *
+ * @param reqDTO
+ * @return
+ */
+ IPage queryApplicationPage(ThreadPoolQueryReqDTO reqDTO);
+
+ /**
+ * Query config modification detail by application id.
+ *
+ * @param id
+ * @return
+ */
+ ThreadPoolParameterInfo queryApplicationDetail(Long id);
+}
diff --git a/hippo4j-config/src/main/java/cn/hippo4j/config/service/biz/ConfigModificationVerifyService.java b/hippo4j-config/src/main/java/cn/hippo4j/config/service/biz/ConfigModificationVerifyService.java
new file mode 100644
index 00000000..633df590
--- /dev/null
+++ b/hippo4j-config/src/main/java/cn/hippo4j/config/service/biz/ConfigModificationVerifyService.java
@@ -0,0 +1,55 @@
+/*
+ * 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 cn.hippo4j.config.service.biz;
+
+import cn.hippo4j.config.model.biz.threadpool.ConfigModifySaveReqDTO;
+import cn.hippo4j.config.model.biz.threadpool.ConfigModifyVerifyReqDTO;
+
+/**
+ * Config modification verify service.
+ */
+public interface ConfigModificationVerifyService {
+
+ /**
+ * Get type.
+ *
+ * @return
+ */
+ Integer type();
+
+ /**
+ * Save config change application.
+ *
+ * @param reqDTO
+ */
+ void saveConfigModifyApplication(ConfigModifySaveReqDTO reqDTO);
+
+ /**
+ * Reject config modification.
+ *
+ * @param reqDTO
+ */
+ void rejectModification(ConfigModifyVerifyReqDTO reqDTO);
+
+ /**
+ * Accept config modification.
+ *
+ * @param reqDTO
+ */
+ void acceptModification(ConfigModifyVerifyReqDTO reqDTO);
+}
diff --git a/hippo4j-config/src/main/java/cn/hippo4j/config/service/biz/impl/AbstractConfigModificationVerifyService.java b/hippo4j-config/src/main/java/cn/hippo4j/config/service/biz/impl/AbstractConfigModificationVerifyService.java
new file mode 100644
index 00000000..6648b322
--- /dev/null
+++ b/hippo4j-config/src/main/java/cn/hippo4j/config/service/biz/impl/AbstractConfigModificationVerifyService.java
@@ -0,0 +1,117 @@
+/*
+ * 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 cn.hippo4j.config.service.biz.impl;
+
+import cn.hippo4j.common.enums.VerifyEnum;
+import cn.hippo4j.common.model.InstanceInfo;
+import cn.hippo4j.common.toolkit.BeanUtil;
+import cn.hippo4j.common.toolkit.ConditionUtil;
+import cn.hippo4j.common.toolkit.JSONUtil;
+import cn.hippo4j.common.toolkit.UserContext;
+import cn.hippo4j.config.mapper.HisConfigVerifyMapper;
+import cn.hippo4j.config.model.HisConfigVerifyInfo;
+import cn.hippo4j.config.model.biz.threadpool.ConfigModifySaveReqDTO;
+import cn.hippo4j.config.model.biz.threadpool.ConfigModifyVerifyReqDTO;
+import cn.hippo4j.config.service.biz.ConfigModificationVerifyService;
+import cn.hippo4j.discovery.core.BaseInstanceRegistry;
+import cn.hippo4j.discovery.core.Lease;
+import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
+
+import javax.annotation.Resource;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+
+/**
+ * Abstract config modification verify service.
+ */
+public abstract class AbstractConfigModificationVerifyService implements ConfigModificationVerifyService {
+
+ @Resource
+ protected HisConfigVerifyMapper hisConfigVerifyMapper;
+
+ @Resource
+ private BaseInstanceRegistry baseInstanceRegistry;
+
+ @Override
+ public void saveConfigModifyApplication(ConfigModifySaveReqDTO reqDTO) {
+ HisConfigVerifyInfo hisConfigVerifyInfo = BeanUtil.convert(reqDTO, HisConfigVerifyInfo.class);
+ hisConfigVerifyInfo.setContent(JSONUtil.toJSONString(reqDTO));
+ hisConfigVerifyInfo.setVerifyStatus(VerifyEnum.TO_VERIFY.getVerifyStatus());
+ hisConfigVerifyMapper.insert(hisConfigVerifyInfo);
+ }
+
+ @Override
+ public void rejectModification(ConfigModifyVerifyReqDTO reqDTO) {
+ LambdaUpdateWrapper updateWrapper = new LambdaUpdateWrapper()
+ .eq(HisConfigVerifyInfo::getId, Long.parseLong(reqDTO.getId()))
+ .set(HisConfigVerifyInfo::getVerifyStatus, VerifyEnum.VERIFY_REJECT.getVerifyStatus())
+ .set(HisConfigVerifyInfo::getGmtVerify, new Date())
+ .set(HisConfigVerifyInfo::getVerifyUser, UserContext.getUserName());
+ hisConfigVerifyMapper.update(null, updateWrapper);
+ }
+
+ public void acceptModification(ConfigModifyVerifyReqDTO reqDTO) {
+ updateThreadPoolParameter(reqDTO);
+ LambdaUpdateWrapper updateWrapper = new LambdaUpdateWrapper()
+ .eq(HisConfigVerifyInfo::getId, Long.parseLong(reqDTO.getId()))
+ .set(HisConfigVerifyInfo::getVerifyStatus, VerifyEnum.VERIFY_ACCEPT.getVerifyStatus())
+ .set(HisConfigVerifyInfo::getGmtVerify, new Date())
+ .set(HisConfigVerifyInfo::getVerifyUser, UserContext.getUserName());
+ hisConfigVerifyMapper.update(null, updateWrapper);
+ Date gmtCreate = hisConfigVerifyMapper.selectById(reqDTO.getId()).getGmtCreate();
+ LambdaUpdateWrapper invalidUpdateWrapper = new LambdaUpdateWrapper()
+ .eq(HisConfigVerifyInfo::getType, reqDTO.getType())
+ .eq(reqDTO.getTenantId() != null, HisConfigVerifyInfo::getTenantId, reqDTO.getTenantId())
+ .eq(reqDTO.getItemId() != null, HisConfigVerifyInfo::getItemId, reqDTO.getItemId())
+ .eq(reqDTO.getTpId() != null, HisConfigVerifyInfo::getTpId, reqDTO.getTpId())
+ .and(reqDTO.getIdentify() != null, wrapper -> wrapper.eq(HisConfigVerifyInfo::getIdentify, reqDTO.getIdentify()).or().eq(HisConfigVerifyInfo::getModifyAll, true))
+ .lt(HisConfigVerifyInfo::getGmtCreate, gmtCreate)
+ .eq(HisConfigVerifyInfo::getVerifyStatus, VerifyEnum.TO_VERIFY.getVerifyStatus())
+ .set(HisConfigVerifyInfo::getVerifyStatus, VerifyEnum.VERIFY_INVALID.getVerifyStatus())
+ .set(HisConfigVerifyInfo::getVerifyUser, UserContext.getUserName())
+ .set(HisConfigVerifyInfo::getGmtVerify, new Date());
+ hisConfigVerifyMapper.update(null, invalidUpdateWrapper);
+ }
+
+ /**
+ * Get client address.
+ *
+ * @param reqDTO
+ * @return
+ */
+ protected List getClientAddress(ConfigModifyVerifyReqDTO reqDTO) {
+ List clientAddressList = new ArrayList<>();
+ List> leases = baseInstanceRegistry.listInstance(reqDTO.getItemId());
+ ConditionUtil
+ .condition(reqDTO.getModifyAll(),
+ () -> leases.forEach(lease -> clientAddressList.add(lease.getHolder().getCallBackUrl())),
+ () -> clientAddressList.add(
+ leases.stream()
+ .filter(lease -> lease.getHolder().getIdentify().equals(reqDTO.getIdentify())).findAny().orElseThrow(() -> new RuntimeException("该线程池实例不存在")).getHolder()
+ .getCallBackUrl()));
+ return clientAddressList;
+ }
+
+ /**
+ * Update thread pool parameter.
+ *
+ * @param reqDTO
+ */
+ protected abstract void updateThreadPoolParameter(ConfigModifyVerifyReqDTO reqDTO);
+}
diff --git a/hippo4j-config/src/main/java/cn/hippo4j/config/service/biz/impl/AdapterThreadPoolConfigModificationVerifyServiceImpl.java b/hippo4j-config/src/main/java/cn/hippo4j/config/service/biz/impl/AdapterThreadPoolConfigModificationVerifyServiceImpl.java
new file mode 100644
index 00000000..fb6cf00f
--- /dev/null
+++ b/hippo4j-config/src/main/java/cn/hippo4j/config/service/biz/impl/AdapterThreadPoolConfigModificationVerifyServiceImpl.java
@@ -0,0 +1,46 @@
+/*
+ * 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 cn.hippo4j.config.service.biz.impl;
+
+import cn.hippo4j.common.constant.ConfigModifyTypeConstants;
+import cn.hippo4j.common.toolkit.StringUtil;
+import cn.hippo4j.common.toolkit.http.HttpUtil;
+import cn.hippo4j.config.model.biz.threadpool.ConfigModifyVerifyReqDTO;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+
+/**
+ * Adapter thread pool config modification verify service impl.
+ */
+@Slf4j
+@Service
+public class AdapterThreadPoolConfigModificationVerifyServiceImpl extends AbstractConfigModificationVerifyService {
+
+ @Override
+ public Integer type() {
+ return ConfigModifyTypeConstants.ADAPTER_THREAD_POOL;
+ }
+
+ @Override
+ protected void updateThreadPoolParameter(ConfigModifyVerifyReqDTO reqDTO) {
+ for (String each : getClientAddress(reqDTO)) {
+ String urlString = StringUtil.newBuilder("http://", each, "/adapter/thread-pool/update");
+ HttpUtil.post(urlString, reqDTO);
+ }
+ }
+}
diff --git a/hippo4j-config/src/main/java/cn/hippo4j/config/service/biz/impl/ConfigModificationQueryServiceImpl.java b/hippo4j-config/src/main/java/cn/hippo4j/config/service/biz/impl/ConfigModificationQueryServiceImpl.java
new file mode 100644
index 00000000..c3cbcd3d
--- /dev/null
+++ b/hippo4j-config/src/main/java/cn/hippo4j/config/service/biz/impl/ConfigModificationQueryServiceImpl.java
@@ -0,0 +1,62 @@
+/*
+ * 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 cn.hippo4j.config.service.biz.impl;
+
+import cn.hippo4j.common.model.ThreadPoolParameterInfo;
+import cn.hippo4j.common.toolkit.BeanUtil;
+import cn.hippo4j.common.toolkit.JSONUtil;
+import cn.hippo4j.config.mapper.HisConfigVerifyMapper;
+import cn.hippo4j.config.model.HisConfigVerifyInfo;
+import cn.hippo4j.config.model.biz.threadpool.ConfigModificationQueryRespDTO;
+import cn.hippo4j.config.model.biz.threadpool.ThreadPoolQueryReqDTO;
+import cn.hippo4j.config.service.biz.ConfigModificationQueryService;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.core.toolkit.StringUtils;
+import com.baomidou.mybatisplus.core.toolkit.Wrappers;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.Resource;
+
+/**
+ * Config modification query service impl
+ */
+@Service
+public class ConfigModificationQueryServiceImpl implements ConfigModificationQueryService {
+
+ @Resource
+ private HisConfigVerifyMapper hisConfigVerifyMapper;
+
+ @Override
+ public IPage queryApplicationPage(ThreadPoolQueryReqDTO reqDTO) {
+ LambdaQueryWrapper wrapper = Wrappers.lambdaQuery(HisConfigVerifyInfo.class)
+ .eq(!StringUtils.isBlank(reqDTO.getTenantId()), HisConfigVerifyInfo::getTenantId, reqDTO.getTenantId())
+ .eq(!StringUtils.isBlank(reqDTO.getItemId()), HisConfigVerifyInfo::getItemId, reqDTO.getItemId())
+ .orderByDesc(HisConfigVerifyInfo::getGmtCreate);
+ return hisConfigVerifyMapper.selectPage(reqDTO, wrapper).convert(each -> BeanUtil.convert(each, ConfigModificationQueryRespDTO.class));
+ }
+
+ @Override
+ public ThreadPoolParameterInfo queryApplicationDetail(Long id) {
+ HisConfigVerifyInfo hisConfigVerifyInfo = hisConfigVerifyMapper.selectById(id);
+ ThreadPoolParameterInfo poolParameterInfo = JSONUtil.parseObject(hisConfigVerifyInfo.getContent(), ThreadPoolParameterInfo.class);
+ poolParameterInfo.setCorePoolSize(poolParameterInfo.corePoolSizeAdapt());
+ poolParameterInfo.setMaximumPoolSize(poolParameterInfo.maximumPoolSizeAdapt());
+ return poolParameterInfo;
+ }
+}
diff --git a/hippo4j-config/src/main/java/cn/hippo4j/config/service/biz/impl/ConfigServiceImpl.java b/hippo4j-config/src/main/java/cn/hippo4j/config/service/biz/impl/ConfigServiceImpl.java
index 5162b11b..bf70a5b9 100644
--- a/hippo4j-config/src/main/java/cn/hippo4j/config/service/biz/impl/ConfigServiceImpl.java
+++ b/hippo4j-config/src/main/java/cn/hippo4j/config/service/biz/impl/ConfigServiceImpl.java
@@ -27,18 +27,19 @@ import cn.hippo4j.common.web.exception.ServiceException;
import cn.hippo4j.config.event.LocalDataChangeEvent;
import cn.hippo4j.config.mapper.ConfigInfoMapper;
import cn.hippo4j.config.mapper.ConfigInstanceMapper;
-import cn.hippo4j.config.model.*;
+import cn.hippo4j.config.model.ConfigAllInfo;
+import cn.hippo4j.config.model.ConfigInfoBase;
+import cn.hippo4j.config.model.ConfigInstanceInfo;
+import cn.hippo4j.config.model.LogRecordInfo;
import cn.hippo4j.config.model.biz.notify.NotifyReqDTO;
import cn.hippo4j.config.service.ConfigCacheService;
import cn.hippo4j.config.service.ConfigChangePublisher;
import cn.hippo4j.config.service.biz.*;
-import cn.hippo4j.config.toolkit.BeanUtil;
-import cn.hutool.core.util.StrUtil;
+import cn.hippo4j.common.toolkit.BeanUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.toolkit.SqlHelper;
-import com.google.common.collect.Lists;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
@@ -70,9 +71,9 @@ public class ConfigServiceImpl implements ConfigService {
@Override
public ConfigAllInfo findConfigAllInfo(String tpId, String itemId, String tenantId) {
LambdaQueryWrapper wrapper = Wrappers.lambdaQuery(ConfigAllInfo.class)
- .eq(StrUtil.isNotBlank(tpId), ConfigAllInfo::getTpId, tpId)
- .eq(StrUtil.isNotBlank(itemId), ConfigAllInfo::getItemId, itemId)
- .eq(StrUtil.isNotBlank(tenantId), ConfigAllInfo::getTenantId, tenantId);
+ .eq(StringUtil.isNotBlank(tpId), ConfigAllInfo::getTpId, tpId)
+ .eq(StringUtil.isNotBlank(itemId), ConfigAllInfo::getItemId, itemId)
+ .eq(StringUtil.isNotBlank(tenantId), ConfigAllInfo::getTenantId, tenantId);
ConfigAllInfo configAllInfo = configInfoMapper.selectOne(wrapper);
return configAllInfo;
}
@@ -82,7 +83,7 @@ public class ConfigServiceImpl implements ConfigService {
ConfigAllInfo resultConfig;
ConfigAllInfo configInstance = null;
String instanceId = params[3];
- if (StrUtil.isNotBlank(instanceId)) {
+ if (StringUtil.isNotBlank(instanceId)) {
LambdaQueryWrapper instanceQueryWrapper = Wrappers.lambdaQuery(ConfigInstanceInfo.class)
.eq(ConfigInstanceInfo::getTpId, params[0])
.eq(ConfigInstanceInfo::getItemId, params[1])
@@ -152,7 +153,8 @@ public class ConfigServiceImpl implements ConfigService {
}
DynamicThreadPoolRegisterServerNotifyParameter serverNotifyParameter = registerWrapper.getDynamicThreadPoolRegisterServerNotifyParameter();
if (serverNotifyParameter != null) {
- ArrayList notifyTypes = Lists.newArrayList("CONFIG", "ALARM");
+ ArrayList
+ 
+ 
@@ -108,32 +122,32 @@ Hippo-4J 通过对 JDK 线程池增强，以及扩展三方框架底层线程池
+
+ 
+ 
@@ -157,13 +178,6 @@ Hippo-4J 通过对 JDK 线程池增强，以及扩展三方框架底层线程池
Null
@@ -177,7 +191,8 @@ Hippo-4J 通过对 JDK 线程池增强，以及扩展三方框架底层线程池
@@ -191,8 +206,7 @@ Hippo-4J 通过对 JDK 线程池增强，以及扩展三方框架底层线程池
@@ -207,6 +221,13 @@ Hippo-4J 通过对 JDK 线程池增强，以及扩展三方框架底层线程池
Null
+ 
@@ -234,7 +255,8 @@ Hippo-4J 通过对 JDK 线程池增强，以及扩展三方框架底层线程池
@@ -242,21 +264,13 @@ Hippo-4J 通过对 JDK 线程池增强，以及扩展三方框架底层线程池
Serenity
@@ -305,7 +319,8 @@ Hippo-4J 通过对 JDK 线程池增强，以及扩展三方框架底层线程池
@@ -313,14 +328,20 @@ Hippo-4J 通过对 JDK 线程池增强，以及扩展三方框架底层线程池
Tudo
+ 
@@ -362,7 +383,8 @@ Hippo-4J 通过对 JDK 线程池增强，以及扩展三方框架底层线程池
@@ -377,14 +399,6 @@ Hippo-4J 通过对 JDK 线程池增强，以及扩展三方框架底层线程池
Lynn
@@ -433,7 +447,8 @@ Hippo-4J 通过对 JDK 线程池增强，以及扩展三方框架底层线程池
@@ -447,8 +462,7 @@ Hippo-4J 通过对 JDK 线程池增强，以及扩展三方框架底层线程池
@@ -463,13 +477,6 @@ Hippo-4J 通过对 JDK 线程池增强，以及扩展三方框架底层线程池
Null
@@ -504,15 +511,15 @@ Hippo-4J 通过对 JDK 线程池增强，以及扩展三方框架底层线程池
@@ -568,15 +575,15 @@ Hippo-4J 通过对 JDK 线程池增强，以及扩展三方框架底层线程池
diff --git a/dev-support/hippo4j_checkstyle.xml b/dev-support/hippo4j_checkstyle.xml
new file mode 100644
index 00000000..c45a921f
--- /dev/null
+++ b/dev-support/hippo4j_checkstyle.xml
@@ -0,0 +1,130 @@
+
+
+
+
+
