ZhouXY108
/
plusone-commons
forked from plusone/plusone-commons
1
0
Fork 0
Code Pull Requests Activity

优化代码 

Reviewed-on: plusone/plusone-commons#2
1.x.x
ZhouXY108 2024-12-24 17:58:17 +08:00
parent f93eec6d08 9f7eda47fe
commit 4559636e7d
11 changed files with 180 additions and 96 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

48
src/main/java/xyz/zhouxy/plusone/commons/exception/ParsingFailureException.java
View File

@ -18,6 +18,9 @@ package xyz.zhouxy.plusone.commons.exception;
import java.time.format.DateTimeParseException;
import javax.annotation.Nonnull;
import xyz.zhouxy.plusone.commons.base.IWithCode;
import xyz.zhouxy.plusone.commons.exception.business.RequestParamsException;
/**
@ -26,7 +29,10 @@ import xyz.zhouxy.plusone.commons.exception.business.RequestParamsException;
* <p>
* 解析失败的不一定是客户传的参数，也可能是其它来源的数据解析失败。
* 如果表示用户传参造成的解析失败，可使用 {@link RequestParamsException#RequestParamsException(Throwable)}，
* 将 ParsingFailureException 包装成 {@link RequestParamsException} 再抛出
* 将 ParsingFailureException 包装成 {@link RequestParamsException} 再抛出。
* <pre>
* throw new RequestParamsException(ParsingFailureException.of(ParsingFailureException.Type.NUMBER_PARSING_FAILURE));
* </pre>
* </p>
*
* @author <a href="http://zhouxy.xyz:3000/ZhouXY108">ZhouXY</a>
@ -56,6 +62,22 @@ public final class ParsingFailureException extends RuntimeException {
this.type = type;
}
public ParsingFailureException() {
this(Type.DEFAULT);
}
public ParsingFailureException(String msg) {
this(Type.DEFAULT, msg);
}
public ParsingFailureException(Throwable e) {
this(Type.DEFAULT, e);
}
public ParsingFailureException(String msg, Throwable e) {
this(Type.DEFAULT, msg, e);
}
public static ParsingFailureException of(Type type) {
return new ParsingFailureException(type);
}
@ -80,19 +102,29 @@ public final class ParsingFailureException extends RuntimeException {
return new ParsingFailureException(Type.DATE_TIME_PARSING_FAILURE, msg, e);
}
public static ParsingFailureException of(NumberFormatException e) {
return new ParsingFailureException(Type.NUMBER_PARSING_FAILURE, e.getMessage(), e);
}
public static ParsingFailureException of(String msg, NumberFormatException e) {
return new ParsingFailureException(Type.NUMBER_PARSING_FAILURE, msg, e);
}
public Type getType() {
return type;
}
public enum Type {
DEFAULT("4010500", "解析失败"),
NUMBER_PARSING_FAILURE("4010501", "数字转换失败"),
DATE_TIME_PARSING_FAILURE("4010502", "时间解析失败"),
JSON_PARSING_FAILURE("4010503", "JSON 解析失败"),
XML_PARSING_FAILURE("4010504", "XML 解析失败"),
public enum Type implements IWithCode<String> {
DEFAULT("00", "解析失败"),
NUMBER_PARSING_FAILURE("10", "数字转换失败"),
DATE_TIME_PARSING_FAILURE("20", "时间解析失败"),
JSON_PARSING_FAILURE("30", "JSON 解析失败"),
XML_PARSING_FAILURE("40", "XML 解析失败"),
;
@Nonnull
final String code;
@Nonnull
final String defaultMsg;
Type(String code, String defaultMsg) {
@ -100,6 +132,8 @@ public final class ParsingFailureException extends RuntimeException {
this.defaultMsg = defaultMsg;
}
@Override
@Nonnull
public String getCode() {
return code;
}

24
src/main/java/xyz/zhouxy/plusone/commons/exception/business/InvalidInputException.java
View File

@ -16,6 +16,10 @@
package xyz.zhouxy.plusone.commons.exception.business;
import javax.annotation.Nonnull;
import xyz.zhouxy.plusone.commons.base.IWithCode;
/**
* InvalidInputException
*
@ -53,6 +57,22 @@ public final class InvalidInputException extends RequestParamsException {
this.type = type;
}
public InvalidInputException() {
this(Type.DEFAULT);
}
public InvalidInputException(String msg) {
this(Type.DEFAULT, msg);
}
public InvalidInputException(Throwable e) {
this(Type.DEFAULT, e);
}
public InvalidInputException(String msg, Throwable e) {
this(Type.DEFAULT, msg, e);
}
public static InvalidInputException of(Type type) {
return new InvalidInputException(type);
}
@ -81,7 +101,7 @@ public final class InvalidInputException extends RequestParamsException {
return type;
}
public enum Type {
public enum Type implements IWithCode<String> {
DEFAULT("00", "用户输入内容非法"),
CONTAINS_ILLEGAL_AND_MALICIOUS_LINKS("01", "包含非法恶意跳转链接"),
CONTAINS_ILLEGAL_WORDS("02", "包含违禁敏感词"),
@ -97,6 +117,8 @@ public final class InvalidInputException extends RequestParamsException {
this.defaultMsg = defaultMsg;
}
@Override
@Nonnull
public String getCode() {
return code;
}

8
src/main/java/xyz/zhouxy/plusone/commons/model/Gender.java
View File

@ -16,6 +16,7 @@
package xyz.zhouxy.plusone.commons.model;
import xyz.zhouxy.plusone.commons.base.IWithIntCode;
import xyz.zhouxy.plusone.commons.util.AssertTools;
/**
@ -23,7 +24,7 @@ import xyz.zhouxy.plusone.commons.util.AssertTools;
*
* @author <a href="http://zhouxy.xyz:3000/ZhouXY108">ZhouXY</a>
*/
public enum Gender {
public enum Gender implements IWithIntCode {
UNKNOWN(0, "Unknown", "未知"),
MALE(1, "Male", "男"),
FEMALE(2, "Female", "女"),
@ -60,4 +61,9 @@ public enum Gender {
return displayNameZh;
}
@Override
public int getCode() {
return getValue();
}
}

5
src/main/java/xyz/zhouxy/plusone/commons/model/dto/PageResult.java
View File

@ -18,9 +18,8 @@ package xyz.zhouxy.plusone.commons.model.dto;
import java.util.List;
import com.google.common.base.Preconditions;
import xyz.zhouxy.plusone.commons.annotation.StaticFactoryMethod;
import xyz.zhouxy.plusone.commons.util.AssertTools;
/**
* 返回分页查询的结果
@ -37,7 +36,7 @@ public class PageResult<T> {
private final List<T> content;
private PageResult(List<T> content, long total) {
Preconditions.checkNotNull(content, "Content must not be null.");
AssertTools.checkNotNull(content, "Content must not be null.");
this.content = content;
this.total = total;
}

21
src/main/java/xyz/zhouxy/plusone/commons/model/dto/PagingAndSortingQueryParams.java
View File

@ -21,12 +21,15 @@ import java.util.Map;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableMap;
import xyz.zhouxy.plusone.commons.annotation.Virtual;
import xyz.zhouxy.plusone.commons.collection.CollectionTools;
import xyz.zhouxy.plusone.commons.util.AssertTools;
import xyz.zhouxy.plusone.commons.util.RegexTools;
import xyz.zhouxy.plusone.commons.util.StringTools;
/**
@ -48,15 +51,15 @@ public class PagingAndSortingQueryParams {
private Long pageNum;
private List<String> orderBy;
private static final Pattern sortStrPattern = Pattern.compile("^[a-zA-Z]\\w+-(desc|asc|DESC|ASC)$");
private static final Pattern SORT_STR_PATTERN = Pattern.compile("^[a-zA-Z]\\w+-(desc|asc|DESC|ASC)$");
private final Map<String, String> sortableProperties;
public PagingAndSortingQueryParams(Map<String, String> sortableProperties) {
Preconditions.checkArgument(sortableProperties != null && !sortableProperties.isEmpty(),
public PagingAndSortingQueryParams(@Nonnull Map<String, String> sortableProperties) {
AssertTools.checkArgument(CollectionTools.isNotEmpty(sortableProperties),
"Sortable properties can not be empty.");
sortableProperties.forEach((k, v) ->
Preconditions.checkArgument(StringTools.isNotBlank(k) && StringTools.isNotBlank(v),
AssertTools.checkArgument(StringTools.isNotBlank(k) && StringTools.isNotBlank(v),
"Property name must not be blank."));
this.sortableProperties = ImmutableMap.copyOf(sortableProperties);
}
@ -101,12 +104,12 @@ public class PagingAndSortingQueryParams {
}
private SortableProperty generateSortableProperty(String orderByStr) {
Preconditions.checkArgument(PagingAndSortingQueryParams.sortStrPattern.matcher(orderByStr).matches());
AssertTools.checkArgument(RegexTools.matches(orderByStr, SORT_STR_PATTERN));
String[] propertyNameAndOrderType = orderByStr.split("-");
Preconditions.checkArgument(propertyNameAndOrderType.length == 2);
AssertTools.checkArgument(propertyNameAndOrderType.length == 2);
String propertyName = propertyNameAndOrderType[0];
Preconditions.checkArgument(sortableProperties.containsKey(propertyName),
AssertTools.checkArgument(sortableProperties.containsKey(propertyName),
"The property name must be in the set of sortable properties.");
String columnName = sortableProperties.get(propertyName);
String orderType = propertyNameAndOrderType[1];
@ -123,7 +126,7 @@ public class PagingAndSortingQueryParams {
SortableProperty(String propertyName, String columnName, String orderType) {
this.propertyName = propertyName;
this.columnName = columnName;
Preconditions.checkArgument("ASC".equalsIgnoreCase(orderType) || "DESC".equalsIgnoreCase(orderType));
AssertTools.checkArgument("ASC".equalsIgnoreCase(orderType) || "DESC".equalsIgnoreCase(orderType));
this.orderType = orderType.toUpperCase();
this.sqlSnippet = this.propertyName + " " + this.orderType;

19
src/main/java/xyz/zhouxy/plusone/commons/time/Quarter.java
View File

@ -23,13 +23,15 @@ import java.time.temporal.ChronoField;
import com.google.common.collect.Range;
import xyz.zhouxy.plusone.commons.annotation.StaticFactoryMethod;
import xyz.zhouxy.plusone.commons.base.IWithIntCode;
import xyz.zhouxy.plusone.commons.util.AssertTools;
/**
* 季度
*
* @author <a href="http://zhouxy.xyz:3000/ZhouXY108">ZhouXY</a>
*/
public enum Quarter {
public enum Quarter implements IWithIntCode {
/** 第一季度 */
Q1(1),
/** 第二季度 */
@ -107,10 +109,7 @@ public enum Quarter {
*/
@StaticFactoryMethod(Quarter.class)
public static Quarter of(int value) {
if (value < 1 || value > 4) {
throw new IllegalArgumentException("Invalid value for Quarter: " + value);
}
return ENUMS[value - 1];
return ENUMS[checkValidIntValue(value) - 1];
}
// StaticFactoryMethods end
@ -134,6 +133,11 @@ public enum Quarter {
return value;
}
@Override
public int getCode() {
return getValue();
}
public Month firstMonth() {
return Month.of(firstMonthValue());
}
@ -166,6 +170,11 @@ public enum Quarter {
// Getters end
public static int checkValidIntValue(int value) {
AssertTools.checkArgument(value >= 1 && value <= 4, () -> "Invalid value for Quarter: " + value);
return value;
}
// Internal
/**

32
src/main/java/xyz/zhouxy/plusone/commons/time/YearQuarter.java
View File

@ -59,7 +59,7 @@ public final class YearQuarter implements Comparable<YearQuarter>, Serializable
this.lastDate = quarter.lastMonthDay().atYear(year);
}
// #region - StaticFactoryMethod
// #region - StaticFactory
/**
* 根据指定年份与季度，创建 {@link YearQuarter} 实例
@ -186,7 +186,7 @@ public final class YearQuarter implements Comparable<YearQuarter>, Serializable
// #region - computes
public YearQuarter plusQuarters(long quartersToAdd) { // TODO 单元测试
if (quartersToAdd == 0) {
if (quartersToAdd == 0L) {
return this;
}
long quarterCount = this.year * 4L + (this.quarter.getValue() - 1);
@ -200,8 +200,16 @@ public final class YearQuarter implements Comparable<YearQuarter>, Serializable
return plusQuarters(-quartersToAdd);
}
public YearQuarter nextQuarter() { // TODO 单元测试
return plusQuarters(1L);
}
public YearQuarter lastQuarter() { // TODO 单元测试
return minusQuarters(1L);
}
public YearQuarter plusYears(long yearsToAdd) { // TODO 单元测试
if (yearsToAdd == 0) {
if (yearsToAdd == 0L) {
return this;
}
int newYear = YEAR.checkValidIntValue(this.year + yearsToAdd); // safe overflow
@ -212,6 +220,14 @@ public final class YearQuarter implements Comparable<YearQuarter>, Serializable
return plusYears(-yearsToAdd);
}
public YearQuarter nextYear() {
return plusYears(1L);
}
public YearQuarter lastYear() {
return minusYears(1L);
}
// #endregion
// #region - hashCode & equals
@ -235,7 +251,7 @@ public final class YearQuarter implements Comparable<YearQuarter>, Serializable
// #endregion
// #region - compareTo
// #region - compare
@Override
public int compareTo(YearQuarter other) {
@ -254,6 +270,14 @@ public final class YearQuarter implements Comparable<YearQuarter>, Serializable
return this.compareTo(other) > 0;
}
public static YearQuarter min(YearQuarter yearQuarter1, YearQuarter yearQuarter2) { // TODO 单元测试
return yearQuarter1.compareTo(yearQuarter2) <= 0 ? yearQuarter1 : yearQuarter2;
}
public static YearQuarter max(YearQuarter yearQuarter1, YearQuarter yearQuarter2) { // TODO 单元测试
return yearQuarter1.compareTo(yearQuarter2) >= 0 ? yearQuarter1 : yearQuarter2;
}
// #endregion
// #region - toString

107
src/main/java/xyz/zhouxy/plusone/commons/util/EnumTools.java
View File

@ -20,8 +20,6 @@ import java.util.function.Supplier;
import javax.annotation.Nullable;
import com.google.common.base.Preconditions;
/**
* 枚举工具类
*
@ -36,18 +34,18 @@ public final class EnumTools {
/**
* 通过 ordinal 获取枚举实例
*
* @param <E> 枚举的类型
* @param clazz 枚举的类型信息
* @param ordinal 序号
* @param <E> 枚举的类型
* @param enumType 枚举的类型信息
* @param ordinal 序号
* @return 枚举对象
* @deprecated 不推荐使用枚举的 ordinal。
*/
@Deprecated
public static <E extends Enum<?>> E valueOf(Class<E> clazz, int ordinal) { // NOSONAR 该方法弃用，但不删掉
Preconditions.checkNotNull(clazz, "Clazz must not be null.");
E[] values = clazz.getEnumConstants();
public static <E extends Enum<?>> E valueOf(Class<E> enumType, int ordinal) { // NOSONAR 该方法弃用，但不删掉
AssertTools.checkNotNull(enumType, "Enum type must not be null.");
E[] values = enumType.getEnumConstants();
AssertTools.checkCondition((ordinal >= 0 && ordinal < values.length),
() -> new EnumConstantNotPresentException(clazz, Integer.toString(ordinal)));
() -> new EnumConstantNotPresentException(enumType, Integer.toString(ordinal)));
return values[ordinal];
}
@ -55,25 +53,23 @@ public final class EnumTools {
* 通过 ordinal 获取枚举实例
*
* @param <E> 枚举的类型
* @param clazz 枚举的类型信息
* @param enumType 枚举的类型信息
* @param ordinal 序号
* @param defaultValue 默认值
* @return 枚举对象
* @deprecated 不推荐使用枚举的 ordinal。
*/
@Deprecated
public static <E extends Enum<?>> E valueOf(Class<E> clazz, @Nullable Integer ordinal, E defaultValue) { // NOSONAR 该方法弃用，但不删掉
if (null == ordinal) {
return defaultValue;
}
return valueOf(clazz, ordinal);
public static <E extends Enum<?>> E valueOf(Class<E> enumType, // NOSONAR 该方法弃用，但不删掉
@Nullable Integer ordinal, E defaultValue) {
return null == ordinal ? defaultValue : valueOf(enumType, ordinal);
}
/**
* 通过 ordinal 获取枚举实例
*
* @param <E> 枚举的类型
* @param clazz 枚举的类型信息
* @param enumType 枚举的类型信息
* @param ordinal 序号
* @param defaultValue 默认值
* @return 枚举对象
@ -81,29 +77,26 @@ public final class EnumTools {
*/
@Deprecated
public static <E extends Enum<?>> E getValueOrDefault( // NOSONAR 该方法弃用，但不删掉
Class<E> clazz,
Class<E> enumType,
@Nullable Integer ordinal,
Supplier<E> defaultValue) {
if (null == ordinal) {
return defaultValue.get();
}
return valueOf(clazz, ordinal);
return null == ordinal ? defaultValue.get() : valueOf(enumType, ordinal);
}
/**
* 通过 ordinal 获取枚举实例
*
* @param <E> 枚举的类型
* @param clazz 枚举的类型信息
* @param ordinal 序号
* @param <E> 枚举的类型
* @param enumType 枚举的类型信息
* @param ordinal 序号
* @return 枚举对象
* @deprecated 不推荐使用枚举的 ordinal。
*/
@Deprecated
public static <E extends Enum<?>> E getValueOrDefault(Class<E> clazz, @Nullable Integer ordinal) { // NOSONAR 该方法弃用，但不删掉
return getValueOrDefault(clazz, ordinal, () -> {
Preconditions.checkNotNull(clazz, "Clazz must not be null.");
E[] values = clazz.getEnumConstants();
public static <E extends Enum<?>> E getValueOrDefault(Class<E> enumType, @Nullable Integer ordinal) { // NOSONAR 该方法弃用，但不删掉
return getValueOrDefault(enumType, ordinal, () -> {
AssertTools.checkNotNull(enumType, "Enum type must not be null.");
E[] values = enumType.getEnumConstants();
return values[0];
});
}
@ -111,69 +104,65 @@ public final class EnumTools {
/**
* 通过 ordinal 获取枚举实例
*
* @param <E> 枚举的类型
* @param clazz 枚举的类型信息
* @param ordinal 序号
* @param <E> 枚举的类型
* @param enumType 枚举的类型信息
* @param ordinal 序号
* @return 枚举对象
* @deprecated 不推荐使用枚举的 ordinal。
*/
@Deprecated
public static <E extends Enum<?>> E getValueNullable(Class<E> clazz, @Nullable Integer ordinal) { // NOSONAR 该方法弃用，但不删掉
return valueOf(clazz, ordinal, null);
public static <E extends Enum<?>> E getValueNullable(Class<E> enumType, @Nullable Integer ordinal) { // NOSONAR 该方法弃用，但不删掉
return valueOf(enumType, ordinal, null);
}
public static <E extends Enum<?>> Integer checkOrdinal(Class<E> clazz, Integer ordinal) {
Preconditions.checkNotNull(clazz, "Clazz must not be null.");
Preconditions.checkNotNull(ordinal, "Ordinal must not be null.");
E[] values = clazz.getEnumConstants();
if (ordinal >= 0 && ordinal < values.length) {
return ordinal;
}
throw new EnumConstantNotPresentException(clazz, Integer.toString(ordinal));
public static <E extends Enum<?>> Integer checkOrdinal(Class<E> enumType, Integer ordinal) {
AssertTools.checkNotNull(enumType, "Enum type must not be null.");
AssertTools.checkNotNull(ordinal, "Ordinal must not be null.");
E[] values = enumType.getEnumConstants();
AssertTools.checkCondition(ordinal >= 0 && ordinal < values.length,
() -> new EnumConstantNotPresentException(enumType, Integer.toString(ordinal)));
return ordinal;
}
/**
* 校验枚举的 ordinal。
*
* @param <E> 枚举类型
* @param clazz 枚举类型
* @param ordinal The ordinal
* @param <E> 枚举类型
* @param enumType 枚举类型
* @param ordinal The ordinal
* @return The ordinal
*/
@Nullable
public static <E extends Enum<?>> Integer checkOrdinalNullable(Class<E> clazz, @Nullable Integer ordinal) {
return checkOrdinalOrDefault(clazz, ordinal, null);
public static <E extends Enum<?>> Integer checkOrdinalNullable(Class<E> enumType, @Nullable Integer ordinal) {
return checkOrdinalOrDefault(enumType, ordinal, null);
}
/**
* 校验枚举的 ordinal，如果 ordinal 为 {@code null}，则返回 {@code 0}。
*
* @param <E> 枚举类型
* @param clazz 枚举类型
* @param ordinal The ordinal
* @param <E> 枚举类型
* @param enumType 枚举类型
* @param ordinal The ordinal
* @return The ordinal
*/
@Nullable
public static <E extends Enum<?>> Integer checkOrdinalOrDefault(Class<E> clazz, @Nullable Integer ordinal) {
return checkOrdinalOrDefault(clazz, ordinal, 0);
public static <E extends Enum<?>> Integer checkOrdinalOrDefault(Class<E> enumType, @Nullable Integer ordinal) {
return checkOrdinalOrDefault(enumType, ordinal, 0);
}
/**
* 校验枚举的 ordinal，如果 ordinal 为 {@code null}，则返回 {@code defaultValue}。
*
* @param <E> 枚举类型
* @param clazz 枚举类型
* @param ordinal The ordinal
* @param <E> 枚举类型
* @param enumType 枚举类型
* @param ordinal The ordinal
* @return The ordinal
*/
@Nullable
public static <E extends Enum<?>> Integer checkOrdinalOrDefault(
Class<E> clazz,
Class<E> enumType,
@Nullable Integer ordinal,
@Nullable Integer defaultValue) {
if (ordinal != null) {
return checkOrdinal(clazz, ordinal);
}
return defaultValue;
return ordinal != null ? checkOrdinal(enumType, ordinal) : defaultValue;
}
}

6
src/main/java/xyz/zhouxy/plusone/commons/util/Enumeration.java
View File

@ -24,8 +24,6 @@ import java.util.Objects;
import java.util.function.Function;
import java.util.stream.Collectors;
import com.google.common.base.Preconditions;
import xyz.zhouxy.plusone.commons.annotation.StaticFactoryMethod;
/**
@ -43,7 +41,7 @@ public abstract class Enumeration<T extends Enumeration<T>> // NOSONAR 暂不移
protected final String name;
protected Enumeration(final int id, final String name) {
Preconditions.checkArgument(StringTools.isNotBlank(name), "Name of enumeration must has text.");
AssertTools.checkArgument(StringTools.isNotBlank(name), "Name of enumeration must has text.");
this.id = id;
this.name = name;
}
@ -98,7 +96,7 @@ public abstract class Enumeration<T extends Enumeration<T>> // NOSONAR 暂不移
}
public T get(int id) {
Preconditions.checkArgument(this.valueMap.containsKey(id), "[%s] 对应的值不存在", id);
AssertTools.checkArgument(this.valueMap.containsKey(id), "[%s] 对应的值不存在", id);
return this.valueMap.get(id);
}

2
src/test/java/xyz/zhouxy/plusone/commons/queryparams/test/PagingAndSortingQueryParamsTests.java → src/test/java/xyz/zhouxy/plusone/commons/model/dto/test/PagingAndSortingQueryParamsTests.java
View File

@ -14,7 +14,7 @@
* limitations under the License.
*/
package xyz.zhouxy.plusone.commons.queryparams.test;
package xyz.zhouxy.plusone.commons.model.dto.test;
import java.io.IOException;
import java.time.LocalDate;

4
src/test/java/xyz/zhouxy/plusone/commons/time/YearQuarterTests.java
View File

@ -59,8 +59,8 @@ public class YearQuarterTests {
void of_ValidYearQuarter_GetsCorrectStartAndEndDate() {
for (int year = 1990; year <= 2024; year++) {
for (int qrtr = 1; qrtr <= 4; qrtr++) {
Quarter quarter = Quarter.of(qrtr);
for (int quarterValue = 1; quarterValue <= 4; quarterValue++) {
Quarter quarter = Quarter.of(quarterValue);
YearQuarter yearQuarter = YearQuarter.of(year, quarter);
LocalDate expectedStartDate = quarter.firstMonthDay().atYear(year);