index int64 | repo_id string | file_path string | content string |
|---|---|---|---|
0 | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/util/AgeUtils.java | package ai.yue.library.base.util;
import java.util.Calendar;
/**
* @author ylyue
* @version 创建时间：2018年4月19日
*/
public class AgeUtils {
/**
* 根据年月日计算年龄
* @param birthDate 出生日期（格式：yyyy-MM-dd）
* @return 年龄
*/
public static int getAgeFromBirthDate(String birthDate) {
// 先截取到字符串中的年、月、日
String strs[] = birthDate.trim().split("-");
int selectYear = Integer.parseInt(strs[0]);
int selectMonth = Integer.parseInt(strs[1]);
int selectDay = Integer.parseInt(strs[2]);
// 得到当前时间的年、月、日
Calendar cal = Calendar.getInstance();
int yearNow = cal.get(Calendar.YEAR);
int monthNow = cal.get(Calendar.MONTH) + 1;
int dayNow = cal.get(Calendar.DATE);
// 用当前年月日减去生日年月日
int yearMinus = yearNow - selectYear;
int monthMinus = monthNow - selectMonth;
int dayMinus = dayNow - selectDay;
int age = 0;// 年龄初始值
if (yearMinus > 0) {
if (monthMinus <= 0 && dayMinus < 0) {// 今年未过生日
age = yearMinus - 1;
}else {// 今年已过生日
age = yearMinus;
}
}
return age;
}
/**
* 根据年龄获得生日（默认月份日期-01-01）
* @param age 年龄
* @return 生日（日期格式）
*/
public static String getBirthDateFromAge(int age) {
// 得到当前时间的年、月、日
Calendar cal = Calendar.getInstance();
int yearNow = cal.get(Calendar.YEAR);
int birthdayYear = yearNow - age;
String birthday = birthdayYear + "-01-01";
return birthday;
}
}
|
0 | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/util/ApplicationContextUtils.java | package ai.yue.library.base.util;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;
import lombok.extern.slf4j.Slf4j;
/**
* 应用上下文工具类，用于在普通类中获取Spring IOC容器中的bean对象
*
* @author ylyue
* @since 2019年8月9日
*/
@Slf4j
@Component
public class ApplicationContextUtils implements ApplicationContextAware {
private static ApplicationContext applicationContext;
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
if (ApplicationContextUtils.applicationContext == null) {
ApplicationContextUtils.applicationContext = applicationContext;
log.info("【初始化工具-ApplicationContextUtils】用于普通类中获取Spring IOC容器中的Bean对象，ApplicationContextUtils.getBean(Class<T>)");
}
}
/**
* 获得 {@linkplain #applicationContext}
*
* @return applicationContext
*/
public static ApplicationContext getApplicationContext() {
return applicationContext;
}
/**
* 获取Spring容器中的Bean - 通过Bean名称
*
* @param name Bean名称
* @return Object，需要做强制类型转换
*/
public static Object getBean(String name) {
return applicationContext.getBean(name);
}
/**
* 获取Spring容器中的Bean - 通过Bean类型
*
* @param <T> Bean类型
* @param clazz 泛型类型，可以是接口或超类
* @return 返回指定类型的单个bean实例
*/
public static <T> T getBean(Class<T> clazz) {
return applicationContext.getBean(clazz);
}
/**
* 获取Spring容器中的Bean - 通过Bean名称与Bean类型精准获取
*
* @param <T> Bean类型
* @param name Bean名称
* @param clazz 泛型类型，可以是接口或超类
* @return Bean的实例
*/
public static <T> T getBean(String name, Class<T> clazz) {
return applicationContext.getBean(name, clazz);
}
}
|
0 | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/util/ArithCompute.java | package ai.yue.library.base.util;
import java.math.BigDecimal;
import java.math.RoundingMode;
/**
* <b>数学计算</b>
* <p>
* 由于Java的简单类型不能够精确的对浮点数进行运算，这个工具类提供精确的浮点数运算，包括加减乘除和四舍五入。
*
* @author ylyue
* @since 2017年9月27日
*/
public class ArithCompute {
private static final int DEF_DIV_SCALE = 10;
/**
* 提供精确的加法运算。
*
* @param augend 被加数
* @param addends 加数
* @return 参数的和
*/
public static double add(double augend, double ... addends) {
BigDecimal bd_augend = new BigDecimal(Double.toString(augend));
for(double addend : addends) {
BigDecimal bd_addend= new BigDecimal(Double.toString(addend));
bd_augend = bd_augend.add(bd_addend);
}
return bd_augend.doubleValue();
}
/**
* 提供精确的减法运算。
*
* @param minuend 被减数
* @param subtrahends 减数
* @return 参数的差
*/
public static double sub(double minuend, double ... subtrahends) {
BigDecimal bd_minuend = new BigDecimal(Double.toString(minuend));
for(double subtrahend : subtrahends) {
BigDecimal bd_subtrahend = new BigDecimal(Double.toString(subtrahend));
bd_minuend = bd_minuend.subtract(bd_subtrahend);
}
return bd_minuend.doubleValue();
}
/**
* 提供精确的乘法运算。
*
* @param v1 被乘数
* @param v2 乘数
* @return 两个参数的积
*/
public static double mul(double v1, double v2) {
BigDecimal b1 = new BigDecimal(Double.toString(v1));
BigDecimal b2 = new BigDecimal(Double.toString(v2));
return b1.multiply(b2).doubleValue();
}
/**
* 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到小数点后10位，其余的数字四舍五入。
*
* @param v1 被除数
* @param v2 除数
* @return 两个参数的商
*/
public static double div(double v1, double v2) {
return div(v1, v2, DEF_DIV_SCALE);
}
/**
* 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指定精度，其余的数字四舍五入。
*
* @param v1 被除数
* @param v2 除数（除数不能为零）
* @param scale 表示表示需要精确到小数点以后几位（如果精确范围小于0，将抛出异常信息）
* @return 两个参数的商
*/
public static double div(double v1, double v2, int scale) {
if (scale < 0) {
throw new IllegalArgumentException("精确度不能小于0");
}
BigDecimal b1 = new BigDecimal(Double.toString(v1));
BigDecimal b2 = new BigDecimal(Double.toString(v2));
return b1.divide(b2, scale, RoundingMode.HALF_UP).doubleValue();
}
/**
* 提供精确的小数位 <b>四舍五入</b> 处理。
*
* @param v 需要四舍五入的数字
* @param scale 小数点后保留几位
* @return 四舍五入后的结果
*/
public static double round(double v, int scale) {
return roundingMode(v, scale, RoundingMode.HALF_UP);
}
/**
* <b>舍入模式</b>
*
* @param v 需要舍入的数字
* @param scale 小数点后保留几位
* @param roundingMode 舍入模式
* @return 舍入后的结果
*/
public static double roundingMode(double v, int scale, RoundingMode roundingMode) {
if (scale < 0) {
throw new IllegalArgumentException("精确度不能小于0");
}
BigDecimal b = new BigDecimal(Double.toString(v));
BigDecimal one = new BigDecimal("1");
return b.divide(one, scale, roundingMode).doubleValue();
}
/**
* 分转元
* @param moneySumCent 金额（单位：分）
* @return 金额（单位：元）
*/
public static double centToYuan(int moneySumCent) {
return div(moneySumCent, 100);
}
/**
* 元转分
* @param moneySum 金额（单位：元）
* @return 金额（单位：分）
*/
public static int yuanToCent(double moneySum) {
return Integer.parseInt(Double.toString(mul(moneySum, 100)));
}
}
|
0 | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/util/AutoIncrementZerofillUtils.java | package ai.yue.library.base.util;
import ai.yue.library.base.exception.ParamException;
import cn.hutool.core.util.CharUtil;
import cn.hutool.core.util.StrUtil;
/**
* 自动递增填充零
*
* @author ylyue
* @version 创建时间：2018年12月10日
*/
public class AutoIncrementZerofillUtils {
/**
* 获得初始化值，自动填充零
* @param length 初始化长度
* @return 如：0001
*/
public static String getInitValue(int length) {
return StrUtil.padPre("1", length, '0');
}
/**
* 字符串尾部值自动递增
* @param str 尾部值是 {@linkplain Integer} 类型
* @return 自动递增后的值
* @throws ParamException 如：("999", "str999")
*/
public static String autoIncrement(String str) {
int maxIndex = str.length() - 1;
Integer autoIncrementValue = Integer.parseInt(CharUtil.toString(str.charAt(maxIndex))) + 1;
if (autoIncrementValue == 10) {
int cycleIndex = 0;
for (int i = maxIndex - 1; i >= 0; i--) {
Integer autoIncrementValueI = Integer.parseInt(CharUtil.toString(str.charAt(i))) + 1;
cycleIndex++;
if (autoIncrementValueI != 10) {
String pad = StrUtil.padPre("0", cycleIndex, '0');
String replaceValue = autoIncrementValueI.toString() + pad;
return StringUtils.replace(str, replaceValue, i, i + 1 + replaceValue.length());
}
}
throw new ParamException("无法自动递增，此参数已是最大值：" + str);
}
return str.substring(0, maxIndex) + autoIncrementValue;
}
/**
* 字符串尾部值自动递减
* @param str 尾部值是 {@linkplain Integer} 类型
* @return 自动递减后的值
*/
public static String autoDecr(String str) {
int maxIndex = str.length() - 1;
Integer autoDecrValue = Integer.parseInt(CharUtil.toString(str.charAt(maxIndex))) - 1;
if (autoDecrValue == -1) {
int cycleIndex = 0;
for (int i = maxIndex - 1; i >= 0; i--) {
Integer autoDecrValueI = Integer.parseInt(CharUtil.toString(str.charAt(i))) - 1;
cycleIndex++;
if (autoDecrValueI != -1) {
String pad = StrUtil.padPre("9", cycleIndex, '9');
String replaceValue = autoDecrValueI.toString() + pad;
return StringUtils.replace(str, replaceValue, i, i + 1 + replaceValue.length());
}
}
throw new ParamException("无法自动递减，此参数已是最小值：" + str);
}
return str.substring(0, maxIndex) + autoDecrValue;
}
}
|
0 | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/util/ClassUtils.java | package ai.yue.library.base.util;
import cn.hutool.core.util.ClassUtil;
/**
* 类工具类
*
* @author ylyue
* @since 2018年1月19日
*/
public class ClassUtils extends ClassUtil {
/**
* {@linkplain Class} 数组中是否包含此 {@linkplain Class} 或是其子类与子接口
* @param clazzs Class数组
* @param clazz Class
* @return 是否包含
*/
public static boolean isContains(Class<?>[] clazzs, Class<?> clazz) {
for (Class<?> thisClazz : clazzs) {
// 是否类或接口相同，或是否为该类或接口的超类或超接口。
if (clazz.isAssignableFrom(thisClazz)) {
return true;
}
}
return false;
}
}
|
0 | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/util/CurrentLineInfo.java | package ai.yue.library.base.util;
/**
* 线程信息获取工具类
*
* @author ylyue
* @since 2017年10月24日
*/
public class CurrentLineInfo {
private static int originStackIndex = 2;
public static String getFileName() {
return Thread.currentThread().getStackTrace()[originStackIndex].getFileName();
}
/**
* 得到当前线程所在的类名称
* @return 类名称
*/
public static String getClassName() {
return Thread.currentThread().getStackTrace()[originStackIndex].getClassName();
}
/**
* 得到当前线程所在的方法名称
* @return 方法名称
*/
public static String getMethodName() {
return Thread.currentThread().getStackTrace()[originStackIndex].getMethodName();
}
/**
* 得到当前线程在第几行
* @return 第几行
*/
public static int getLineNumber() {
return Thread.currentThread().getStackTrace()[originStackIndex].getLineNumber();
}
}
|
0 | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/util/DateUtils.java | package ai.yue.library.base.util;
import java.sql.Timestamp;
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.time.temporal.TemporalAccessor;
import java.util.Calendar;
import java.util.Date;
import cn.hutool.core.date.DateUtil;
/**
* 时间工具类（JDK1.8）
*
* @author ylyue
* @since 2017年10月25日（JDK1.8）
*/
public class DateUtils extends DateUtil {
// ~ 格式化字符串
// ================================================================================================
/**
* DateTime 格式化字符串
* <p>年-月-日 时:分:秒（标准北京时间）
*/
public static final String DATE_TIME_FORMAT = "yyyy-MM-dd HH:mm:ss";
/**
* Date 格式化字符串
* <p>年-月-日
*/
public static final String DATE_FORMAT = "yyyy-MM-dd";
/**
* Time 格式化字符串
* <p>时:分:秒
*/
public static final String TIME_FORMAT = "HH:mm:ss";
// ~ 格式化 DateTimeFormatter 对象
// ================================================================================================
/**
* DateTime 格式化
* <p>年-月-日 时:分:秒（标准北京时间）
*/
public static final DateTimeFormatter DATE_TIME_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
/**
* Date 格式化
* <p>年-月-日
*/
public static final DateTimeFormatter DATE_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd");
/**
* Time 格式化
* <p>时:分:秒
*/
public static final DateTimeFormatter TIME_FORMATTER = DateTimeFormatter.ofPattern("HH:mm:ss");
/** 年-月-日T时:分:秒 */
public static final DateTimeFormatter FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss");
/**
* DateTime 保留毫秒格式化
* <p>年-月-日 时:分:秒:毫秒
*/
public static final DateTimeFormatter DATE_TIME_KEEP_MS_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss:SSS");
/**
* 当天起始时间
* <p>年-月-日 00:00:00
*/
public static final DateTimeFormatter TODAY_START_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd 00:00:00");
/**
* 当天结束时间
* <p>年-月-日 23:59:59
*/
public static final DateTimeFormatter TODAY_END_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd 23:59:59");
/**
* 当月起始时间
* <p>年-月-01 00:00:00
*/
public static final DateTimeFormatter MONTH_START_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-01 00:00:00");
// ~ 工具方法
// ================================================================================================
/**
* 判断某个时间是否在某个时间段
* <p>{@linkplain String} 类型值应该是一个按照 yyyy-MM-dd HH:mm:ss 规则格式化后的字符串
* <p>若类型不确定请使用 {@link #isBetween(LocalDateTime, LocalDateTime, LocalDateTime)}
*
* @param startTime 起始时间
* @param dateTime 比较时间
* @param endTime 结束时间
* @return 是否在…之间
*/
public static boolean isBetween(String startTime, String dateTime, String endTime) {
LocalDateTime start = Timestamp.valueOf(startTime).toLocalDateTime();
LocalDateTime time = Timestamp.valueOf(dateTime).toLocalDateTime();
LocalDateTime end = Timestamp.valueOf(endTime).toLocalDateTime();
if (time.isBefore(end) && time.isAfter(start)) {
return true;
}
return false;
}
/**
* 判断某个时间是否在某个时间段
*
* @param startTime 起始时间
* @param dateTime 比较时间
* @param endTime 结束时间
* @return 是否在…之间
*/
public static boolean isBetween(LocalDateTime startTime, LocalDateTime dateTime, LocalDateTime endTime) {
if (dateTime.isBefore(endTime) && dateTime.isAfter(startTime)) {
return true;
}
return false;
}
/**
* 判断某个时间是否在某个时间段
*
* @param startTime 起始时间
* @param dateTime 比较时间
* @param endTime 结束时间
* @return 是否在…之间
*/
public static boolean isBetween(Date startTime, Date dateTime, Date endTime) {
if (dateTime.before(endTime) && dateTime.after(startTime)) {
return true;
}
return false;
}
/**
* 获得当前时间戳
*
* @return 时间戳
*/
public static Long getTimestamp() {
return System.currentTimeMillis();
}
/**
* 获得当前日期的标准字符串格式
*
* @return 年-月-日
*/
public static String getDateFormatter() {
return DATE_FORMATTER.format(LocalDate.now());
}
/**
* 获得当前日期时间的标准字符串格式
*
* @return 年-月-日 时:分:秒（标准北京时间）
*/
public static String getDatetimeFormatter() {
return DATE_TIME_FORMATTER.format(LocalDateTime.now());
}
/**
* 获得当天起始时间的标准字符串格式
*
* @return 年-月-日 00:00:00
*/
public static String getTodayStartFormatter() {
return TODAY_START_FORMATTER.format(LocalDateTime.now());
}
/**
* 获得当天结束时间的标准字符串格式
*
* @return 年-月-日 23:59:59
*/
public static String getTodayEndFormatter() {
return TODAY_END_FORMATTER.format(LocalDateTime.now());
}
/**
* 获得本周开始时间的标准字符串格式
*
* @return 年-月-日 00:00:00
*/
public static String getWeekmorningFormatter() {
Calendar cal = Calendar.getInstance();
// 设置年月日时分秒
cal.set(cal.get(Calendar.YEAR), cal.get(Calendar.MONTH), cal.get(Calendar.DAY_OF_MONTH), 0, 0, 0);
// 判断要计算的日期是否是周日，如果是则减一天计算周六的，否则会出问题，计算到下一周去了
int dayWeek = cal.get(Calendar.DAY_OF_WEEK);// 获得当前日期是一个星期的第几天
if (1 == dayWeek) {
cal.add(Calendar.DAY_OF_MONTH, -1);
}
cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
return toDateTimeFormatter(cal.getTimeInMillis());
}
/**
* 获得本周日结束时间的标准字符串格式
*
* @return 年-月-日 23:59:59
*/
public static String getWeeknight() {
Calendar cal = Calendar.getInstance();
cal.set(cal.get(Calendar.YEAR), cal.get(Calendar.MONDAY), cal.get(Calendar.DAY_OF_MONTH), 23, 59, 59);
// 判断要计算的日期是否是周日，如果是则减一天计算周六的，否则会出问题，计算到下一周去了
int dayWeek = cal.get(Calendar.DAY_OF_WEEK);// 获得当前日期是一个星期的第几天
if (1 == dayWeek) {
cal.add(Calendar.DAY_OF_MONTH, -1);
}
cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
cal.add(Calendar.DAY_OF_WEEK, 6);
return toDateTimeFormatter(cal.getTimeInMillis());
}
/**
* 将日期时间转换成时间戳
*
* @param dateTime 日期时间
* @return 时间戳
*/
public static Long toTimestamp(String dateTime) {
return Timestamp.valueOf(dateTime).getTime();
}
/**
* 将 {@linkplain Date} 转 {@linkplain LocalDateTime}
* <p>默认使用系统时区转换
*
* @param date 日期
* @return 本地日期时间
*/
public static LocalDateTime toLocalDateTime(Date date) {
Instant instant = date.toInstant();// 时间线上的一个瞬时点
ZoneId zoneId = ZoneId.systemDefault();// 时区
return instant.atZone(zoneId).toLocalDateTime();
}
/**
* 将毫秒时间（时间戳）转化为标准日期字符串格式
*
* @param timestamp 毫秒（时间戳）
* @return 年-月-日
*/
public static String toDateFormatter(long timestamp) {
return DATE_FORMATTER.format(LocalDate.ofEpochDay(timestamp));
}
/**
* 将 {@link Date} 类型进行标准日期字符串格式化
*
* @param date 日期
* @return 年-月-日
*/
public static String toDateFormatter(Date date) {
return DATE_FORMATTER.format(toLocalDateTime(date));
}
/**
* 将 {@link TemporalAccessor} 类型进行标准日期字符串格式化
*
* @param date 日期
* @return 年-月-日
*/
public static String toDateFormatter(TemporalAccessor date) {
return DATE_FORMATTER.format(date);
}
/**
* 将毫秒时间（时间戳）转化为标准日期时间字符串格式
*
* @param timestamp 毫秒（时间戳）
* @return 年-月-日 时:分:秒
*/
public static String toDateTimeFormatter(long timestamp) {
LocalDateTime localDateTime = toLocalDateTime(new Date(timestamp));
return DATE_TIME_FORMATTER.format(localDateTime);
}
/**
* 将 {@link Date} 类型进行标准日期时间字符串格式化
*
* @param date 日期
* @return 年-月-日 时:分:秒
*/
public static String toDateTimeFormatter(Date date) {
return DATE_TIME_FORMATTER.format(toLocalDateTime(date));
}
/**
* 将 {@link TemporalAccessor} 类型进行标准日期时间字符串格式化
*
* @param date 日期
* @return 年-月-日 时:分:秒
*/
public static String to_y_M_d_H_m_s(TemporalAccessor date) {
return DATE_TIME_FORMATTER.format(date);
}
/**
* 计算日期相差天数
*
* @param startTime 开始时间
* @param endTime 结束时间
* @return 相差天数
*/
public static long dateDaysDifference(LocalDateTime startTime, LocalDateTime endTime) {
return startTime.toLocalDate().toEpochDay() - endTime.toLocalDate().toEpochDay();
}
/**
* 计算日期相差天数
*
* @param startDate 开始日期
* @param endDate 结束日期
* @return 相差天数
*/
public static long dateDaysDifference(LocalDate startDate, LocalDate endDate) {
return startDate.toEpochDay() - endDate.toEpochDay();
}
}
|
0 | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/util/ExceptionUtils.java | package ai.yue.library.base.util;
/**
* 异常打印工具类
*
* @author ylyue
* @since 2018年9月9日
*/
public class ExceptionUtils {
public synchronized static void printException(Exception e) {
System.err.println(e);
StackTraceElement[] stackTraceElementArray = e.getStackTrace();
for (int i = 0; i < 4; i++) {
StackTraceElement stackTraceElement = stackTraceElementArray[i];
String fileName = stackTraceElement.getFileName();
String className = stackTraceElement.getClassName();
String methodName = stackTraceElement.getMethodName();
int lineNumber = stackTraceElement.getLineNumber();
System.err.println(" at " + className + "." + methodName + "(" + fileName + ":" + lineNumber + ")");
}
}
}
|
0 | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/util/ListUtils.java | package ai.yue.library.base.util;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import ai.yue.library.base.constant.MaxOrMinEnum;
import ai.yue.library.base.constant.SortEnum;
import ai.yue.library.base.convert.Convert;
import cn.hutool.core.collection.ListUtil;
import cn.hutool.core.comparator.CompareUtil;
import cn.hutool.core.util.ArrayUtil;
/**
* List工具类
*
* @author ylyue
* @since 2017年10月27日
*/
public class ListUtils extends ListUtil {
/**
* List数组是否为空
* @param list list
* @return 是否为空
*/
public static boolean isEmpty(List<?> list) {
return null == list || list.isEmpty();
}
/**
* List数组是否不为空
* @param list list
* @return 是否不为空
*/
public static boolean isNotEmpty(List<?> list) {
return !isEmpty(list);
}
/**
* 获得List数组中对应类型的第一个值
*
* @param <T> 想要的类型
* @param list List数组
* @param clazz 想要的类型Class
* @return 找到的第一个值或null
*/
@SuppressWarnings("unchecked")
public static <T> T get(List<?> list, Class<T> clazz) {
for (Object value : list) {
if (value != null && value.getClass() == clazz) {
return (T) value;
}
}
return null;
}
/**
* 数据分组
* <p>将拥有相同的 key 值的JSON数据归为一组</p>
* @param list 要处理的集合
* @param key 分组依据
* @return 分组后的list
*/
public static List<List<JSONObject>> grouping(List<JSONObject> list, String key) {
List<List<JSONObject>> result = new ArrayList<>();
toListAndDistinct(list, key).forEach(str -> {
List<JSONObject> jsonList = new ArrayList<>();
list.forEach(json -> {
if (str.equals(json.getString(key))) {
jsonList.add(json);
}
});
result.add(jsonList);
});
return result;
}
/**
* 保留相同值
* @param list 循环第一层
* @param list2 循环第二层
* @return 处理后的list
*/
public static List<String> keepSameValue(List<String> list, List<String> list2) {
List<String> result = new ArrayList<>();
list.forEach(str -> {
list2.forEach(str2 -> {
if (str.equals(str2)) {
result.add(str);
}
});
});
return result;
}
/**
* 将JSON集合，合并到数组的JSON集合
* <p>
* 以条件key获得JSONObject数组中每个对象的value作为JSON对象的key，然后进行合并。<br>
* JSON对象key获得的值，应该是一个JSONObject对象<br>
* </p>
* <blockquote>示例：
* <pre>
* JSONArray array = [
* {
* "id": 1,
* "name": "name"
* }
* ]
* JSONObject json = {
* 1: {
* "sex": "男",
* "age": 18
* }
* }
*
* String key = "id";
*
* JSONArray mergeResult = merge(array, json, key);
* System.out.println(mergeResult);
* </pre>
* 结果：
* [{"id": 1, "name": "name", "sex": "男", "age": 18}]
* </blockquote>
* @param array JSONObject数组
* @param json JSON对象
* @param key 条件
* @return 合并后的JSONArray
*/
public static JSONArray merge(JSONArray array, JSONObject json, String key) {
array.forEach(arrayObj -> {
JSONObject temp = Convert.toJSONObject(arrayObj);
String value = temp.getString(key);
temp.putAll(json.getJSONObject(value));
});
return array;
}
/**
* List合并
* <p>将<b> list2 </b>合并到<b> list1 </b>里面
*
* @param list1 需要合并的列表
* @param list2 被合并的列表
* @param key1 list1中JSON所使用的key
* @param key2 list2中JSON所使用的key
*/
public static void merge(List<JSONObject> list1, List<JSONObject> list2, String key1, String key2) {
list1.forEach(json1 -> {
Object value1 = json1.get(key1);
for (JSONObject json2 : list2) {
Object value2 = json2.get(key2);
if (ObjectUtils.equals(value1, value2)) {
json2.remove(key2);
json1.putAll(json2);
break;
}
}
});
}
/**
* List-JSONObject集合排序
*
* @param list 需要处理的集合
* @param sortKey 排序依据（JSONObject的key）
* @param sortEnum 排序方式
* @return 处理后的List集合
*/
public static List<JSONObject> sort(List<JSONObject> list, String sortKey, SortEnum sortEnum) {
Collections.sort(list, new Comparator<JSONObject>() {
public int compare(JSONObject json1, JSONObject json2) {
var json1value = json1.get(sortKey);
var json2value = json2.get(sortKey);
if (sortEnum == SortEnum.升序) {
return CompareUtil.compare(json1value, json2value, false);
} else {
return CompareUtil.compare(json2value, json1value, false);
}
}
});
return list;
}
/**
* List-T集合排序
*
* @param <T> 泛型
* @param list 需要处理的集合
* @param sortField 排序字段
* @param sortEnum 排序方式
* @return 处理后的List集合
*/
public static <T> List<T> sortT(List<T> list, String sortField, SortEnum sortEnum) {
Collections.sort(list, new Comparator<T>() {
public int compare(T o1, T o2) {
JSONObject json1 = Convert.toJSONObject(o1);
JSONObject json2 = Convert.toJSONObject(o2);
var json1value = json1.get(sortField);
var json2value = json2.get(sortField);
if (sortEnum == SortEnum.升序) {
return CompareUtil.compare(json1value, json2value, false);
} else {
return CompareUtil.compare(json2value, json1value, false);
}
}
});
return list;
}
/**
* 反转集合
* @param <T> 泛型
* @param list 需要处理的集合
* @param clazz 集合元素类型
* @return 反转后的List集合
*/
public static <T> List<T> reverse(List<T> list, Class<T> clazz) {
return ListUtils.toList(ArrayUtil.reverse(ArrayUtil.toArray(list, clazz)));
}
/**
* HashSet去重
* @param <T> 泛型
* @param list 需要去重的list
* @return 去重后的list
*/
public static <T> List<T> distinct(List<T> list) {
HashSet<T> h = new HashSet<T>(list);
list.clear();
list.addAll(h);
return list;
}
/**
* {@linkplain List} - {@linkplain JSONObject} value去重
* <p>根据参数distinctKey去重。
* @param list 需要处理的集合
* @param distinctKey 去重的依据（JSON的key）
* @return 处理后的List集合
*/
public static List<JSONObject> distinct(List<JSONObject> list, String distinctKey) {
for (int i = 0; i < list.size(); i++) {
JSONObject jsoni = list.get(i);
for (int j = list.size() - 1; j > i; j--) {
JSONObject jsonj = list.get(j);
if (jsoni.get(distinctKey).equals(jsonj.get(distinctKey))) {
list.remove(j);
}
}
}
return list;
}
/**
* {@linkplain List}-{@linkplain JSONObject}集合去重统计与排序
* <p>根据参数distinctKey（JSONObject的key）计算元素重复次数，并为每个JSONObject添加一个 <b>frequency</b>（频率元素），value的值是从整数1开始计数。
* <p>示例：<code>json.put("frequency", frequency)</code>
* <p><b>根据frequency（重复频率）排序</b>
*
* @param list 需要处理的集合
* @param distinctKey 去重的依据（JSONObject的key）
* @param sortEnum 排序方式
* @return 处理后的List集合
*/
public static List<JSONObject> distinctCount(List<JSONObject> list, String distinctKey, SortEnum sortEnum) {
for (int i = 0; i < list.size(); i++) {
int frequency = 1;
JSONObject jsoni = list.get(i);
for (int j = list.size() - 1; j > i; j--) {
JSONObject jsonj = list.get(j);
if (jsoni.get(distinctKey).equals(jsonj.get(distinctKey))) {
list.remove(j);
frequency++;
}
}
jsoni.put("frequency", frequency);
}
return sort(list, "frequency", sortEnum);
}
/**
* {@linkplain List}-{@linkplain JSONObject}集合——去重、统计、排序与元素选择性保留
* <p>根据参数distinctKey（JSONObject的key），计算元素重复次数。并为每个JSONObject添加一个<b>frequency</b>（频率元素），value的值是从整数1开始计数。
* <p>示例：<code>json.put("frequency", frequency)</code>
* <p><b>根据frequency（重复频率）排序</b>
* @param list 需要处理的集合
* @param distinctKey 去重的依据（JSONObject的key）
* @param sortEnum 排序方式
* @param keepKey 需要保留的重复元素（此参数必须为可判断的Number类型：根据maxOrMinEnum选择保留最大值 <i>或</i> 最小值）<b><i>如：</i></b>根据id去重，保留age为最大或最小的JSONObject
* @param maxOrMinEnum 保留的值：最大值 <i>或</i> 最小值
* @return 处理后的List集合
*/
public static List<JSONObject> distinctCountSortSelectKeep(List<JSONObject> list, String distinctKey, SortEnum sortEnum, String keepKey, MaxOrMinEnum maxOrMinEnum) {
for (int i = 0; i < list.size(); i++) {
int frequency = 1;
JSONObject jsoni = list.get(i);
for (int j = list.size() - 1; j > i; j--) {
JSONObject jsonj = list.get(j);
if (jsoni.get(distinctKey).equals(jsonj.get(distinctKey))) {
// i > j
if (CompareUtil.compare(jsoni.get(keepKey), jsonj.get(keepKey), false) > 0) {
if (maxOrMinEnum == MaxOrMinEnum.最小值) {
jsoni.replace(keepKey, jsonj.get(keepKey));
}
list.remove(j);
frequency++;
} else {
if (maxOrMinEnum == MaxOrMinEnum.最大值) {
jsoni.replace(keepKey, jsonj.get(keepKey));
}
list.remove(j);
frequency++;
}
}
}
jsoni.put("frequency", frequency);
}
return sort(list, "frequency", sortEnum);
}
/**
* 数组转List
* <p>此方法为 {@linkplain Arrays#asList(Object...)} 的安全实现</p>
*
* @param <T> 数组中的对象类
* @param array 将被转换的数组
* @return 被转换数组的列表视图
*/
public static <T> ArrayList<T> toList(T[] array) {
ArrayList<T> toList = new ArrayList<>(Arrays.asList(array));
return toList;
}
/**
* {@linkplain List}-{@linkplain JSONObject} 转 {@linkplain List}-{@linkplain Class}
*
* @param <T> 泛型
* @param list 需要转换的List
* @param clazz json转换的POJO类型
* @return 转换后的List
*/
public static <T> List<T> toList(List<JSONObject> list, Class<T> clazz) {
List<T> toList = new ArrayList<> ();
for(JSONObject json : list) {
toList.add(Convert.toJavaBean(json, clazz));
}
return toList;
}
/**
* {@linkplain List}-{@linkplain JSONObject} 转 {@linkplain List}-{@linkplain String}
*
* @param list 需要转换的List
* @param keepKey 保留值的key
* @return 转换后的List
*/
public static List<String> toList(List<JSONObject> list, String keepKey) {
List<String> toList = new ArrayList<> ();
for(JSONObject json : list) {
String value = json.getString(keepKey);
toList.add(value);
}
return toList;
}
/**
* {@linkplain List}-{@linkplain JSONObject} 转 {@linkplain List}-{@linkplain Class}
*
* @param <T> 泛型
* @param list 需要转换的List
* @param keepKey 保留值的key
* @param clazz 类型
* @return 转换后的List
*/
public static <T> List<T> toList(List<JSONObject> list, String keepKey, Class<T> clazz) {
List<T> toList = new ArrayList<> ();
for(JSONObject json : list) {
toList.add(Convert.toObject(json.get(keepKey), clazz));
}
return toList;
}
/**
* {@linkplain List} - {@linkplain JSONObject} 转 {@linkplain List} - {@linkplain String} 并去除重复元素
*
* @param list 需要转换的List
* @param keepKey 保留值的key
* @return 处理后的List
*/
public static List<String> toListAndDistinct(List<JSONObject> list, String keepKey) {
List<String> toList = new ArrayList<> ();
for(JSONObject json : list) {
String value = json.getString(keepKey);
toList.add(value);
}
return distinct(toList);
}
/**
* {@linkplain List}-{@linkplain JSONObject} 转 {@linkplain List}-{@linkplain Class} 并去除重复元素
*
* @param <T> 泛型
* @param list 需要转换的List
* @param keepKey 保留值的key
* @param clazz 类型
* @return 处理后的List
*/
public static <T> List<T> toListAndDistinct(List<JSONObject> list, String keepKey, Class<T> clazz) {
return distinct(toList(list, keepKey, clazz));
}
/**
* {@linkplain List} - {@linkplain Map} 转 {@linkplain List} - {@linkplain JSONObject}
* <p>
* <b><i>性能测试说明：</i></b><br>
* <i>测试CPU：</i>i7-4710MQ<br>
* <i>测试结果：</i>百万级数据平均200ms（毫秒）<br>
* </p>
*
* @param list 需要转换的List
* @return 转换后的List
*/
public static List<JSONObject> toJsonList(List<Map<String, Object>> list) {
List<JSONObject> jsonList = new ArrayList<>();
for (int i = 0; i < list.size(); i++) {
jsonList.add(new JSONObject(list.get(i)));
}
return jsonList;
}
/**
* {@linkplain JSONArray} 转 {@linkplain List} - {@linkplain JSONObject}
* <p>
* <b><i>性能测试报告：</i></b><br>
* <i>无类型转换（类型推断）：</i>见 {@linkplain #toJsonList(List)}<br>
* <i>安全模式强制类型转换：</i>暂未测试<br>
* </p>
*
* @param jsonArray 需要转换的JSONArray
* @return 转换后的jsonList
*/
public static List<JSONObject> toJsonList(JSONArray jsonArray) {
List<JSONObject> jsonList = new ArrayList<>();
for (int i = 0; i < jsonArray.size(); i++) {
jsonList.add(jsonArray.getJSONObject(i));
}
return jsonList;
}
/**
* {@linkplain List} - {@linkplain Class} 转 {@linkplain List} - {@linkplain JSONObject}
* <p>
* <b><i>性能测试报告：</i></b><br>
* <i>安全模式强制类型转换：</i>暂未测试<br>
* </p>
*
* @param <T> 泛型
* @param list 需要转换的List
* @return 转换后的jsonList
*/
public static <T> List<JSONObject> toJsonListT(List<T> list) {
List<JSONObject> jsonList = new ArrayList<>();
for (T obj : list) {
jsonList.add(Convert.toJSONObject(obj));
}
return jsonList;
}
/**
* {@linkplain JSONArray} 转 {@linkplain JSONObject}[]
* <p>对象引用转换，内存指针依旧指向元数据
*
* @param jsonArray 需要转换的JSONArray
* @return 转换后的jsons
*/
public static JSONObject[] toJsons(JSONArray jsonArray) {
int size = jsonArray.size();
JSONObject[] jsons = new JSONObject[size];
for (int i = 0; i < size; i++) {
jsons[i] = jsonArray.getJSONObject(i);
}
return jsons;
}
/**
* {@linkplain List}-{@linkplain JSONObject} 转 {@linkplain JSONObject}[]
* <p>对象引用转换，内存指针依旧指向元数据
*
* @param list 需要转换的List
* @return 转换后的jsons
*/
public static JSONObject[] toJsons(List<JSONObject> list) {
JSONObject[] jsons = new JSONObject[list.size()];
int index = 0;
for (JSONObject json : list) {
jsons[index] = json;
index++;
}
return jsons;
}
/**
* {@linkplain List} - {@linkplain Class} 转 {@linkplain JSONObject}[]
* <p>
* <b><i>性能测试报告：</i></b><br>
* <i>安全模式强制类型转换：</i>暂未测试<br>
* </p>
*
* @param <T> 泛型
* @param list 需要转换的List
* @return 转换后的jsons
*/
public static <T> JSONObject[] toJsonsT(List<T> list) {
JSONObject[] jsons = new JSONObject[list.size()];
int index = 0;
for (T obj : list) {
jsons[index] = Convert.toJSONObject(obj);
index++;
}
return jsons;
}
/**
* {@linkplain List} - {@linkplain Class} 转 {@linkplain JSONObject}[] 并移除空对象
* <p>
* <b><i>性能测试报告：</i></b><br>
* <i>安全模式强制类型转换：</i>暂未测试<br>
* </p>
*
* @param <T> 泛型
* @param list 需要转换的List
* @return 转换后的jsons
*/
public static <T> JSONObject[] toJsonsTAndRemoveEmpty(List<T> list) {
JSONObject[] jsons = new JSONObject[list.size()];
int index = 0;
for (T obj : list) {
JSONObject json = Convert.toJSONObject(obj);
MapUtils.removeEmpty(json);
jsons[index] = json;
index++;
}
return jsons;
}
/**
* {@linkplain String} 转 {@linkplain JSONObject}[]
*
* @param jsonString 需要转换的JSON字符串
* @return JSON数组
*/
public static JSONObject[] toJsons(String jsonString) {
return toJsons(JSONArray.parseArray(jsonString));
}
/**
* {@linkplain String} 转 {@linkplain JSONObject}[]
* <blockquote>示例：
* <pre>
* {@code
* String text = "1,3,5,9";
* JSONObject[] jsons = toJsons(text, ",", "id");
* System.out.println(Arrays.toString(jsons));
* }
* </pre>
* 结果：
* [{"id":"1"}, {"id":"3"}, {"id":"5"}, {"id":"9"}]
* </blockquote>
*
* @param text 需要转换的文本
* @param regex 文本分割表达式，同{@linkplain String}类的split()方法
* @param key JSON的key名称
* @return 转换后的jsons
*/
public static JSONObject[] toJsons(String text, String regex, String key) {
String[] texts = text.split(regex);
JSONObject[] jsons = new JSONObject[texts.length];
for (int i = 0; i < texts.length; i++) {
JSONObject paramJson = new JSONObject();
paramJson.put(key, texts[i]);
jsons[i] = paramJson;
}
return jsons;
}
}
|
0 | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/util/LocationUtils.java | package ai.yue.library.base.util;
import java.util.ArrayList;
import java.util.List;
import ai.yue.library.base.ipo.LocationIPO;
/**
* 位置工具类，用于处理经纬度等问题
*
* @author ylyue
* @since 2018年8月1日
*/
public class LocationUtils {
private static final double EARTH_RADIUS = 6378.137;
private static double rad(double d) {
return d * Math.PI / 180.0;
}
/**
* 通过经纬度获取距离(单位：米)
* <p>
* 说明（如：高德地图，重庆市政府坐标）<br>
* <code>106.550464,29.563761</code><br>
* 106.550464 经度<br>
* 29.563761 纬度<br>
* 注：lng 经度<br>
* 注：lat 纬度
* @param locationIPO1 位置1
* @param locationIPO2 位置1
* @return 距离
*/
public static double getDistance(LocationIPO locationIPO1, LocationIPO locationIPO2) {
double lng1 = locationIPO1.getLng();
double lat1 = locationIPO1.getLat();
double lng2 = locationIPO2.getLng();
double lat2 = locationIPO2.getLat();
double radLat1 = rad(lat1);
double radLat2 = rad(lat2);
double a = radLat1 - radLat2;
double b = rad(lng1) - rad(lng2);
double s = 2 * Math.asin(Math.sqrt(
Math.pow(Math.sin(a / 2), 2) + Math.cos(radLat1) * Math.cos(radLat2) * Math.pow(Math.sin(b / 2), 2)));
s = s * EARTH_RADIUS;
s = Math.round(s * 10000d) / 10000d;
s = s * 1000;
return s;
}
/**
* 通过经纬度获取距离(单位：米)
* @param locationIPO 位置
* @param locationIPOList 位置数组
* @return 距离数组
*/
public static List<Double> getDistance(LocationIPO locationIPO, List<LocationIPO> locationIPOList) {
List<Double> list = new ArrayList<>();
for (LocationIPO location : locationIPOList) {
list.add(getDistance(locationIPO, location));
}
return list;
}
/**
* 获得距离当前位置最近的经纬度
* <p>
* 返回locations数组中最小值的下标
* @param locationIPO 位置
* @param locationIPOList 位置数组
* @return minIndex
*/
public static int getNearestLngAndLat(LocationIPO locationIPO, List<LocationIPO> locationIPOList) {
int minIndex = 0;
var list = getDistance(locationIPO, locationIPOList);
for (int i = 0; i < list.size(); i++) {
if (list.get(i) < list.get(minIndex)) {
minIndex = i;
}
}
return minIndex;
}
}
|
0 | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/util/MapUtils.java | package ai.yue.library.base.util;
import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.text.NumberFormat;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.PropertyNamingStrategy;
import com.alibaba.fastjson.serializer.SerializeConfig;
import ai.yue.library.base.convert.Convert;
import cn.hutool.core.map.MapUtil;
import cn.hutool.core.util.StrUtil;
import lombok.extern.slf4j.Slf4j;
/**
* Map工具类
*
* @author ylyue
* @since 2018年1月26日
*/
@Slf4j
public class MapUtils extends MapUtil {
/** 不可变的空Json常量 */
public final static JSONObject FINAL_EMPTY_JSON = new JSONObject();
/**
* 判断Map数据结构key的一致性
* @param paramMap 参数
* @param mustContainKeys 必须包含的key（必传）
* @param canContainKeys 可包含的key（非必传）
* @return 是否满足条件
*/
public static boolean isKeys(Map<String, Object> paramMap, String[] mustContainKeys, String... canContainKeys) {
// 1. 必传参数校验
for (String key : mustContainKeys) {
if (!paramMap.containsKey(key)) {
return false;
}
}
// 2. 无可选参数
if (StringUtils.isEmptys(canContainKeys)) {
return true;
}
// 3. 可选参数校验-确认paramMap大小
int keySize = mustContainKeys.length + canContainKeys.length;
if (paramMap.size() > keySize) {
return false;
}
// 4. 获得paramMap中包含可包含key的大小
int paramMapCanContainKeysLength = 0;
for (String key : canContainKeys) {
if (paramMap.containsKey(key)) {
paramMapCanContainKeysLength++;
}
}
// 5. 确认paramMap中包含的可包含key大小 + 必须包含key大小 是否等于 paramMap大小
if (paramMapCanContainKeysLength + mustContainKeys.length != paramMap.size()) {
return false;
}
// 6. 通过所有校验，返回最终结果
return true;
}
/**
* 判断Map数据结构所有的key是否与数组完全匹配
* @param paramMap 需要确认的Map
* @param keys 条件
* @return 匹配所有的key且大小一致（true）
*/
public static boolean isKeysEqual(Map<String, Object> paramMap, String[] keys) {
if (paramMap.size() != keys.length) {
return false;
}
for(String key : keys) {
if(!paramMap.containsKey(key)) {
return false;
}
}
return true;
}
/**
* 判断Map数据结构是否包含 <b>keys</b> 之一
* @param paramMap 需要确认的Map
* @param keys 条件
* @return 只要包含一个key（true）
*/
public static boolean isContainsOneOfKey(Map<String, Object> paramMap, String[] keys) {
for(String key : keys) {
if(paramMap.containsKey(key)) {
return true;
}
}
return false;
}
/**
* 判断Map数组第一个元素，是否包含所有的key<br>
* <p>弱比较，只判断数组中第一个元素是否包含所有的key</p>
* @param paramMaps 需要确认的Map数组
* @param keys 条件数组
* @return Map数组元素0包含所有的key（true）
*/
public static boolean isMapsKeys(Map<String, Object>[] paramMaps, String[] keys) {
return isKeys(paramMaps[0], keys);
}
/**
* 判断Map数组是否为空<br>
* <p>弱判断，只确定数组中第一个元素是否为空</p>
* @param paramMaps 要判断的Map[]数组
* @return Map数组==null或长度==0或第一个元素为空（true）
*/
public static boolean isEmptys(Map<String, Object>[] paramMaps) {
return (null == paramMaps || paramMaps.length == 0 || paramMaps[0].isEmpty()) ? true : false;
}
/**
* 判断Map是否为空，或者Map中String类型的value值是否为空<br>
* @param paramMap 要判断的Map
* @return value值是否为空
*/
public static boolean isStringValueEmpty(Map<String, Object> paramMap) {
if (paramMap.isEmpty()) {
return true;
}
for (Object value : paramMap.values()) {
if (null == value || "".equals(value)) {
return true;
}
}
return false;
}
/**
* 删除Value字符串前后空格
* @param paramMap 需要处理的map
*/
public static void trimStringValues(Map<String, Object> paramMap) {
for (String key : paramMap.keySet()) {
String str = getString(paramMap, key);
String value = str.trim();
if (!str.equals(value)) {
paramMap.replace(key, value);
}
}
}
/**
* 批量移除
* @param paramMap 要操作的Map
* @param keys 被移除的key数组
*/
public static void remove(Map<String, Object> paramMap, String[] keys) {
for (String key : keys) {
paramMap.remove(key);
}
}
/**
* 移除空对象
* @param paramMap 要操作的Map
*/
public static void removeEmpty(Map<String, Object> paramMap) {
Iterator<Entry<String, Object>> iter = paramMap.entrySet().iterator();
while (iter.hasNext()) {
Entry<String, Object> entry = iter.next();
Object value = entry.getValue();
if (ObjectUtils.isNull(value)) {
iter.remove();
}
}
}
/**
* 移除空白字符串
* <p>空白的定义如下： <br>
* 1、为null <br>
* 2、为不可见字符（如空格）<br>
* 3、""<br>
*
* @param paramMap 要操作的Map
*/
public static void removeBlankStr(Map<String, Object> paramMap) {
Iterator<Entry<String, Object>> iter = paramMap.entrySet().iterator();
while (iter.hasNext()) {
Entry<String, Object> entry = iter.next();
Object value = entry.getValue();
if (StrUtil.isBlankIfStr(value)) {
iter.remove();
}
}
}
/**
* 替换key
* @param paramMap 要操作的Map
* @param key 被替换的key
* @param replaceKey 替换的key
*/
public static void replaceKey(Map<String, Object> paramMap, String key, String replaceKey) {
var value = paramMap.get(key);
paramMap.put(replaceKey, value);
paramMap.remove(key);
}
/**
* 获取所有的key
* @param paramMap 需要获取keys的map
* @return keyList
*/
public static List<String> keyList(Map<String, Object> paramMap) {
List<String> list = new ArrayList<>();
paramMap.keySet().forEach(action -> {
list.add(action);
});
return list;
}
/**
* 以安全的方式从Map中获取一组数据，组合成一个新的JSONObject
* @param paramMap 需要从中获取数据的map
* @param keys 获取的keys
* @return 结果
*/
public static JSONObject getJSONObject(Map<String, Object> paramMap, String... keys) {
JSONObject paramJson = new JSONObject(paramMap);
if (!isContainsOneOfKey(paramJson, keys)) {
return null;
}
JSONObject resultJson = new JSONObject();
for (String key : keys) {
Object value = paramJson.get(key);
if (value != null) {
resultJson.put(key, value);
}
}
return resultJson;
}
/**
* 以安全的方式从Map中获取对象
* @param <T> 泛型
* @param paramMap 参数map
* @param key key
* @param clazz 泛型类型
* @return 结果
*/
public static <T> T getObject(final Map<?, ?> paramMap, final Object key, Class<T> clazz) {
if (paramMap != null) {
Object answer = paramMap.get(key);
if (answer != null) {
return Convert.toObject(answer, clazz);
}
}
return null;
}
/**
* 以安全的方式从Map中获取Number
* @param paramMap 参数map
* @param key key
* @return 结果
*/
public static Number getNumber(final Map<?, ?> paramMap, final Object key) {
if (paramMap != null) {
Object answer = paramMap.get(key);
if (answer != null) {
if (answer instanceof Number) {
return (Number) answer;
} else if (answer instanceof String) {
try {
String text = (String) answer;
return NumberFormat.getInstance().parse(text);
} catch (ParseException e) {
// failure means null is returned
}
}
}
}
return null;
}
/**
* 以安全的方式从Map中获取字符串
* @param paramMap 参数map
* @param key key
* @return 结果
*/
public static String getString(final Map<?, ?> paramMap, final Object key) {
if (paramMap != null) {
Object answer = paramMap.get(key);
if (answer != null) {
return answer.toString();
}
}
return null;
}
/**
* 以安全的方式从Map中获取Boolean
* @param paramMap 参数map
* @param key key
* @return 结果
*/
public static Boolean getBoolean(final Map<?, ?> paramMap, final Object key) {
if (paramMap != null) {
Object answer = paramMap.get(key);
if (answer != null) {
if (answer instanceof Boolean) {
return (Boolean) answer;
} else if (answer instanceof String) {
return Boolean.valueOf((String) answer);
} else if (answer instanceof Number) {
Number n = (Number) answer;
return (n.intValue() != 0) ? Boolean.TRUE : Boolean.FALSE;
}
}
}
return null;
}
/**
* 以安全的方式从Map中获取Integer
* @param paramMap 参数map
* @param key key
* @return 结果
*/
public static Integer getInteger(final Map<?, ?> paramMap, final Object key) {
Number answer = getNumber(paramMap, key);
if (answer == null) {
return null;
} else if (answer instanceof Integer) {
return (Integer) answer;
}
return answer.intValue();
}
/**
* 以安全的方式从Map中获取Long
* @param paramMap 参数map
* @param key key
* @return 结果
*/
public static Long getLong(final Map<?, ?> paramMap, final Object key) {
Number answer = getNumber(paramMap, key);
if (answer == null) {
return null;
} else if (answer instanceof Long) {
return (Long) answer;
}
return answer.longValue();
}
/**
* 以安全的方式从Map中获取Double
* @param paramMap 参数map
* @param key key
* @return 结果
*/
public static Double getDouble(final Map<?, ?> paramMap, final Object key) {
Number answer = getNumber(paramMap, key);
if (answer == null) {
return null;
} else if (answer instanceof Double) {
return (Double) answer;
}
return answer.doubleValue();
}
/**
* 以安全的方式从Map中获取BigDecimal
* @param paramMap 参数map
* @param key key
* @return 结果
*/
public static BigDecimal getBigDecimal(final Map<?, ?> paramMap, final Object key) {
Number answer = getNumber(paramMap, key);
if (answer == null) {
return null;
} else if (answer instanceof Double) {
return new BigDecimal((Double) answer);
}
return new BigDecimal(answer.doubleValue());
}
/**
* 以安全的方式从Map中获取JSONObject
* @param paramMap 参数map
* @param key key
* @return 结果
*/
public static JSONObject getJSONObject(final Map<?, ?> paramMap, String key) {
Object value = paramMap.get(key);
return Convert.toJSONObject(value);
}
/**
* 以安全的方式从Map中获取JSONArray
* @param paramMap 参数map
* @param key key
* @return 结果
*/
public static JSONArray getJSONArray(final Map<?, ?> paramMap, String key) {
Object value = paramMap.get(key);
return Convert.toJSONArray(value);
}
/**
* 属性命名策略转换-驼峰命名法
*
* @param param Json参数 或 POJO对象
* @return 经过属性命名策略转换后的 JSONObject
*/
public static JSONObject toCamelCase(Object param) {
return toPropertyNamingStrategy(param, PropertyNamingStrategy.CamelCase);
}
/**
* 属性命名策略转换-下划线命名法
*
* @param param Json参数 或 POJO对象
* @return 经过属性命名策略转换后的 JSONObject
*/
public static JSONObject toUnderlineCase(Object param) {
return toPropertyNamingStrategy(param, PropertyNamingStrategy.SnakeCase);
}
/**
* 属性命名策略转换-下划线命名法
*
* @param param Json参数 或 POJO对象
* @return 经过属性命名策略转换后的 JSONObject
*/
public static JSONObject toSnakeCase(Object param) {
return toPropertyNamingStrategy(param, PropertyNamingStrategy.SnakeCase);
}
/**
* 属性命名策略转换
*
* @param param Json参数 或 POJO对象
* @param propertyNamingStrategy 属性命名策略
* @return 经过属性命名策略转换后的 JSONObject
*/
public static JSONObject toPropertyNamingStrategy(Object param, PropertyNamingStrategy propertyNamingStrategy) {
// Json参数
if (param instanceof Map) {
JSONObject jsonObject = Convert.toJSONObject(param);
if (MapUtils.isEmpty(jsonObject)) {
return jsonObject;
}
JSONObject paramJson = new JSONObject(true);
jsonObject.forEach((key, value) -> {
paramJson.put(propertyNamingStrategy.translate(key), value);
});
return paramJson;
}
// POJO对象
SerializeConfig serializeConfig = new SerializeConfig();
serializeConfig.setPropertyNamingStrategy(propertyNamingStrategy);
JSONObject paramJson = (JSONObject) JSONObject.toJSON(param, serializeConfig);
return paramJson;
}
/**
* <b>将指定值提取出来作为map key,map的值为相同key值的list<b>
* <p>
* 例：一个用户集合中的对象有key、name、sex
* <p>
* 数据1：key：1，name：张三，sex：man
* <p>
* 数据2：key：2，name：李四，sex:woman
* <p>
* 数据3：key：3，name：王五，sex：man
* <p>
* 方法调用：ListPOJOExtractKeyToList(list,"sex");
* <p>
* 处理后返回结果为一个map，值为一个list,json表示为：
* <p>
* {"man":[{"key":"1","name":"张三","sex":"man"},{"key":"3","name":"王五","sex":"man"}],
* <p>
* "woman":[{"key":"2","name":"李四","sex":"woman"}]}
*
* @param objectList 对象list
* @return key为map key的键值对
*/
public static <T> Map<String, List<T>> listPOJOExtractKeyToList(List<T> objectList, String key) {
// 声明一个返回的map集合
Map<String, List<T>> map = new LinkedHashMap<>();
// 如果需要转换的值是空的，直接返回一个空的集合
if (ListUtils.isEmpty(objectList)) {
return map;
}
// 循环集合，转换为map
for (T item : objectList) {
// 声明一个object对象接收key 的值
Object valueKey = null;
try {
// 通过对象和属性值获取对应的值
valueKey = getValue(item, key);
} catch (Exception e) {
// 未找到方法值时不处理，采用默认的null
log.error("未找到方法值", e);
}
// 获取需要返回的map中是否已有该值的集合
List<T> list = map.get(valueKey == null ? null : valueKey.toString());
// 如果没有该值的集合，创建一个新的集合插入map中
if (list == null) {
list = new ArrayList<T>();
map.put(valueKey == null ? null : valueKey.toString(), list);
}
// 将该对象插入对应的集合中去
list.add(item);
}
return map;
}
/**
* <p>
* 将list对象中数据提取为单个map键值对
* <p>
* 注：如果有相同的key时，后面的值会覆盖第一次出现的key对应的值
* <p>
* 例：一个用户集合中的对象有key、name、sex
* <p>
* 数据1：key：1，name：张三，sex：man
* <p>
* 数据2：key：2，name：李四，sex:woman
* <p>
* 数据3：key：3，name：王五，sex：man
* <p>
* 方法调用：ListPOJOExtractKeyToList(list,"key");
* <p>
* 处理后返回结果为一个map，值为一个对象,json表示为：
* <p>
* {"1":{"key":"1","name":"张三","sex":"man"},"2":{"key":"2","name":"李四","sex":"woman"},"3":{"key":"3","name":"王五","sex":"man"}}
*
* @param objectList list数据
* @param key 需要提取的key
* @param <T> 泛型对象
* @return Map<String, T>
*/
public static <T> Map<String, T> listPOJOExtractKeyToPOJO(List<T> objectList, String key) {
// 声明一个返回的map集合
Map<String, T> map = new LinkedHashMap<>();
// 如果需要转换的值是空的，直接返回一个空的集合
if (objectList == null || objectList.isEmpty()) {
return map;
}
// 循环集合，转换为map
for (T item : objectList) {
// 声明一个object对象接收key 的值
Object mapKey = null;
try {
// 通过对象和属性值获取对应的值
mapKey = getValue(item, key);
} catch (Exception e) {
// 未找到方法值时不处理，采用默认的null
log.error("未找到方法值", e);
}
// 将取到的值作为key，当前对象作为值，插入map中，如果有相同的key会覆盖之前的值
map.put(mapKey == null ? null : mapKey.toString(), item);
}
return map;
}
/**
* 获取
*
* @param obj
* @param name
* @return
* @throws Exception
*/
private static Object getValue(Object obj, String name) {
BeanInfo beanInfo;
try {
beanInfo = Introspector.getBeanInfo(obj.getClass());
} catch (IntrospectionException e) {
log.info("获取实体信息错误", e);
return null;
}
//获取所有属性
PropertyDescriptor[] descriptors = beanInfo.getPropertyDescriptors();
for (PropertyDescriptor descriptor : descriptors) {
//获取get方法
Method readMethod = descriptor.getReadMethod();
//判断是否是需要的属性的get方法
if (!name.equals(descriptor.getName())) {
continue;
}
try {
//执行get方法拿到值
Object value = readMethod.invoke(obj);
return value;
} catch (IllegalAccessException | InvocationTargetException e) {
log.info("获取值发生错误", e);
return null;
}
}
return null;
}
}
|
0 | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/util/ObjectUtils.java | package ai.yue.library.base.util;
import java.math.BigDecimal;
import java.math.BigInteger;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import ai.yue.library.base.convert.Convert;
import cn.hutool.core.util.ObjectUtil;
/**
* 对象工具类，包括对象比较与转换等问题
*
* @author ylyue
* @since 2018年7月27日
*/
public class ObjectUtils extends ObjectUtil {
/**
* 对象比较
* @param obj1 对象1
* @param obj2 对象2
* @return 是否相等
*/
public static boolean equals(Object obj1, Object obj2) {
if (obj1 == obj2 || obj1.equals(obj2)) {
return true;
}
Class<? extends Object> clazz = obj1.getClass();
try {
if (clazz == byte.class || clazz == Byte.class) {
byte value1 = Byte.parseByte(obj1.toString());
byte value2 = Byte.parseByte(obj2.toString());
return value1 == value2;
}
if (clazz == short.class || clazz == Short.class || clazz == int.class || clazz == Integer.class) {
int value1 = Integer.parseInt(obj1.toString());
int value2 = Integer.parseInt(obj2.toString());
return value1 == value2;
}
if (clazz == long.class || clazz == Long.class || clazz == BigInteger.class) {
long value1 = Long.parseLong(obj1.toString());
long value2 = Long.parseLong(obj2.toString());
return value1 == value2;
}
if (clazz == float.class || clazz == Float.class || clazz == double.class || clazz == Double.class
|| clazz == BigDecimal.class) {
double value1 = Double.parseDouble(obj1.toString());
double value2 = Double.parseDouble(obj2.toString());
return value1 == value2;
}
if (clazz == char.class || clazz == Character.class || clazz == String.class) {
return obj1.toString().equals(obj2);
}
} catch (Exception e) {
return false;
}
return false;
}
/**
* 转换值为指定类型
*
* @param <T> 泛型
* @param value 被转换的值
* @param clazz 泛型类型
* @return 转换后的对象
* @see Convert#toObject(Object, Class)
*/
public static <T> T toObject(Object value, Class<T> clazz) {
return Convert.toObject(value, clazz);
}
/**
* 对象类型转换
* <h1>{@linkplain Object} 转 {@linkplain Class}</h1>
*
* @deprecated 请使用 {@link #toJavaBean(Object, Class)}
* @param <T> 泛型
* @param obj 需要转换的对象
* @param clazz 泛型类型
* @return 转换后的POJO
*/
@Deprecated
@SuppressWarnings("unchecked")
public static <T> T toJavaObject(Object obj, Class<T> clazz) {
if (clazz == obj.getClass() || clazz.isInstance(obj)) {
return (T) obj;
}
return JSONObject.toJavaObject(toJSONObject(obj), clazz);
}
/**
* 转换值为指定 POJO 类型
*
* @param <T> 泛型
* @param value 被转换的值
* @param clazz 泛型类型
* @return 转换后的POJO
* @see Convert#toJavaBean(Object, Class)
*/
public static <T> T toJavaBean(Object value, Class<T> clazz) {
return Convert.toJavaBean(value, clazz);
}
/**
* 转换为 {@linkplain JSONObject}
*
* @param value 被转换的值
* @return JSON
* @see Convert#toJSONObject(Object)
*/
public static JSONObject toJSONObject(Object value) {
return Convert.toJSONObject(value);
}
/**
* 转换为 {@linkplain JSONArray}
*
* @param value 被转换的值
* @return JSON数组
* @see Convert#toJSONArray(Object)
*/
public static JSONArray toJSONArray(Object value) {
return Convert.toJSONArray(value);
}
}
|
0 | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/util/ParamUtils.java | package ai.yue.library.base.util;
import java.util.Arrays;
import java.util.List;
import com.alibaba.fastjson.JSONObject;
import ai.yue.library.base.convert.Convert;
import ai.yue.library.base.exception.ParamException;
import ai.yue.library.base.exception.ParamVoidException;
import ai.yue.library.base.exception.ResultException;
import ai.yue.library.base.ipo.ParamFormatIPO;
import ai.yue.library.base.validation.Validator;
import ai.yue.library.base.view.ResultInfo;
import ai.yue.library.base.webenv.WebEnv;
/**
* 参数处理工具类
* <p>1. 用于获取 Request 中的请求参数
* <p>2. 用于参数确认与类型美化
* <p>参数校验与类型转换参考：{@linkplain Convert}、{@linkplain Validator}
*
* @author ylyue
* @since 2018年6月16日
*/
public class ParamUtils {
// Validate
/** 必传参数 */
private static final String PARAM_PREFIX_MUST = "【必传参数】：";
/** 可选参数 */
private static final String PARAM_PREFIX_CAN = "【可选参数】：";
/** 收到传参 */
private static final String PARAM_PREFIX_RECEIVED = "【收到传参】：";
// RequestParam
/**
* 获取 Request 中的请求参数
* <p>不区分Query或Body传参，只要传参便可获取到
* <p>Query Body 1 + 1，参数整合接收，从根源去除SpringMVC固定方式传参取参带来的烦恼
* <p>此方法逻辑具体由当前 {@link WebEnv} 环境实现
*
* @return JSON对象
*/
public static JSONObject getParam() {
WebEnv webEnv = SpringUtils.getBean(WebEnv.class);
return webEnv.getParam();
}
/**
* 获取 Request 中的请求参数
* <p>不区分Query或Body传参，只要传参便可获取到
* <p>Query Body 1 + 1，参数整合接收，从根源去除SpringMVC固定方式传参取参带来的烦恼
* <p>此方法逻辑具体由当前 {@link WebEnv} 环境实现
*
* @param <T> 泛型
* @param clazz 想要的参数类型
* @return 想要的对象实例
*/
public static <T> T getParam(Class<T> clazz) {
WebEnv webEnv = SpringUtils.getBean(WebEnv.class);
return webEnv.getParam(clazz);
}
// Format
/**
* 参数美化-Boolean强类型转换
* @param paramJson 需要向强类型转换的参数
* @param keys 可多个boolean值的key
*/
public static void paramFormatBoolean(JSONObject paramJson, String... keys) {
for (String key : keys) {
paramJson.replace(key, paramJson.getBoolean(key));
}
}
/**
* 参数美化-BigDecimal强类型转换
* @param paramJson 需要向强类型转换的参数
* @param keys 可多个BigDecimal值的key
*/
public static void paramFormatBigDecimal(JSONObject paramJson, String... keys) {
for (String key : keys) {
paramJson.replace(key, paramJson.getBigDecimal(key));
}
}
/**
* 参数美化-JSONObject强类型转换
* @param paramJson 需要向强类型转换的参数
* @param keys 可多个JSONObject值的key
*/
public static void paramFormatJSONObject(JSONObject paramJson, String... keys) {
for (String key : keys) {
paramJson.replace(key, paramJson.getJSONObject(key));
}
}
/**
* 参数美化-JSONArray强类型转换
* @param paramJson 需要向强类型转换的参数
* @param keys 可多个JSONArray值的key
*/
public static void paramFormatJSONArray(JSONObject paramJson, String... keys) {
for (String key : keys) {
paramJson.replace(key, paramJson.getJSONArray(key));
}
}
/**
* 参数美化-Object强类型转换
* @param paramJson 需要向强类型转换的参数
* @param paramFormatIPOList 多个参数美化IPO
*/
public static void paramFormatObject(JSONObject paramJson, List<ParamFormatIPO> paramFormatIPOList) {
for (ParamFormatIPO paramFormatIPO : paramFormatIPOList) {
String key = paramFormatIPO.getKey();
Class<?> clazz = paramFormatIPO.getClazz();
paramJson.replace(key, paramJson.getObject(key, clazz));
}
}
/**
* 参数美化--弱类型转强类型
*
* @param paramJson 需要向强类型转换的参数
* @param booleanKeys 多个boolean值的key（可以为null）
* @param decimalKeys 多个BigDecimal值的key（可以为null）
* @param jsonObjectKeys 多个JSONObject值的key（可以为null）
* @param jsonArrayKeys 多个JSONArray值的key（可以为null）
*/
public static void paramFormat(JSONObject paramJson, String[] booleanKeys, String[] decimalKeys
, String[] jsonObjectKeys, String[] jsonArrayKeys) {
if (!StringUtils.isEmptys(booleanKeys)) {
paramFormatBoolean(paramJson, booleanKeys);
}
if (!StringUtils.isEmptys(decimalKeys)) {
paramFormatBigDecimal(paramJson, decimalKeys);
}
if (!StringUtils.isEmptys(jsonObjectKeys)) {
paramFormatJSONObject(paramJson, jsonObjectKeys);
}
if (!StringUtils.isEmptys(jsonArrayKeys)) {
paramFormatJSONArray(paramJson, jsonArrayKeys);
}
}
// Validate
/**
* 空对象校验
* @param objects 对象数组
* @throws ResultException 有空对象将抛出异常
*/
public static void paramValidate(Object ...objects) {
for (int i = 0; i < objects.length; i++) {
Object object = objects[i];
if (ObjectUtils.isNull(object)) {
throw new ResultException(ResultInfo.paramCheckNotPass());
}
}
}
/**
* param参数校验
* <p>1. 判断Map数据结构key的一致性
* <p>2. 必传参数是否为空字符串
*
* @param paramJson 参数
* @param mustContainKeys 必须包含的key（必传）
* @param canContainKeys 可包含的key（非必传）
* @throws ParamException 不满足条件抛出此异常及其提示信息
*/
public static void paramValidate(JSONObject paramJson, String[] mustContainKeys, String... canContainKeys) {
// 1. 判断Map数据结构key的一致性
boolean isHint = false;
if (!MapUtils.isKeys(paramJson, mustContainKeys, canContainKeys)) {
isHint = true;
}
// 2. 必传参数是否为空字符串
for (String key : mustContainKeys) {
if (StringUtils.isEmptyIfStr(paramJson.get(key))) {
isHint = true;
break;
}
}
// 3. 提示
if (isHint) {
StringBuffer paramHint = new StringBuffer();
paramHint.append(PARAM_PREFIX_MUST + Arrays.toString(mustContainKeys));
paramHint.append("，");
paramHint.append(PARAM_PREFIX_CAN + Arrays.toString(canContainKeys));
paramHint.append("，");
paramHint.append(PARAM_PREFIX_RECEIVED + paramJson.keySet());
throw new ParamException(paramHint.toString());
}
}
/**
* param参数校验
* <p>1. 判断Map数组数据结构key的一致性
* <p>2. 必传参数是否为空字符串
*
* @param paramList 参数数组
* @param mustContainKeys 必须包含的key（必传）
* @param canContainKeys 可包含的key（非必传）
* @throws ParamVoidException 参数是否为空抛出此异常
* @throws ParamException 不满足条件抛出此异常及其提示信息
*/
public static void paramValidate(List<JSONObject> paramList, String[] mustContainKeys, String... canContainKeys) {
// 1. 校验参数是否为空
if (paramList.isEmpty()) {
throw new ParamVoidException();
}
// 2. 确认参数key
for (JSONObject paramJson : paramList) {
paramValidate(paramJson, mustContainKeys, canContainKeys);
}
}
/**
* 11位手机号码隐藏加密
* @param cellphone 手机号
* @return 隐藏加密后的手机号
*/
public static String cellphoneEncrypt(String cellphone) {
if (cellphone.length() == 11) {
return cellphone.replaceAll("(\\d{3})\\d{4}(\\d{4})", "$1****$2");
}
if (cellphone.length() > 4) {
return cellphone.replaceAll("(\\d{2})\\d+(\\d{2})", "$1****$2");
}
return cellphone.replaceAll("(\\d{1})\\d+(\\d{1})", "$1**$2");
}
}
|
0 | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/util/SpringUtils.java | package ai.yue.library.base.util;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;
import lombok.extern.slf4j.Slf4j;
/**
* Spring(Spring boot)工具封装，包括：
*
* <pre>
* 1、Spring IOC容器中的bean对象获取
* </pre>
*
* @author ylyue
* @since 2020年4月6日
*/
@Slf4j
@Component
public class SpringUtils implements ApplicationContextAware {
private static ApplicationContext applicationContext;
@Override
public void setApplicationContext(ApplicationContext applicationContext) {
if (SpringUtils.applicationContext == null) {
SpringUtils.applicationContext = applicationContext;
log.info("【初始化工具-SpringUtils】用于普通类中获取Spring IOC容器中的Bean对象，SpringUtils.getBean(Class<T>)");
}
}
/**
* 获取applicationContext
*
* @return ApplicationContext
*/
public static ApplicationContext getApplicationContext() {
return applicationContext;
}
// 通过name获取 Bean.
/**
* 通过name获取 Bean
*
* @param name Bean名称
* @return Bean
*/
public static Object getBean(String name) {
return applicationContext.getBean(name);
}
/**
* 通过class获取Bean
*
* @param <T> Bean类型
* @param clazz Bean类
* @return Bean对象
*/
public static <T> T getBean(Class<T> clazz) {
return applicationContext.getBean(clazz);
}
/**
* 通过name,以及Clazz返回指定的Bean
*
* @param <T> bean类型
* @param name Bean名称
* @param clazz bean类型
* @return Bean对象
*/
public static <T> T getBean(String name, Class<T> clazz) {
return applicationContext.getBean(name, clazz);
}
} |
0 | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/util/StringUtils.java | package ai.yue.library.base.util;
import cn.hutool.core.util.StrUtil;
/**
* String工具类
*
* @author ylyue
* @since 2017年10月28日
*/
public class StringUtils extends StrUtil {
/**
* 判断String数组是否为空<br>
* <p>弱判断，只确定数组中第一个元素是否为空</p>
* @param array 要判断的String[]数组
* @return String数组长度==0或者第一个元素为空（true）
*/
public static boolean isEmptys(String[] array) {
return (null == array || array.length == 0 || isEmpty(array[0])) ? true : false;
}
/**
* 确认String数组不为空<br>
* <p>弱判断，只确定数组中第一个元素是否为空</p>
* @param array 要判断的String[]数组
* @return String数组长度==0或者第一个元素为空（true）
*/
public static boolean isNotEmptys(String[] array) {
return !isEmptys(array);
}
/**
* 替换字符串-根据索引
* @param str 原始字符串
* @param replacedStr 替换字符串
* @param start 开始索引，包括此索引
* @param end 结束索引，不包括此索引（结束索引==开始索引：将在开始索引处插入替换字符串）
* @return 替换后的字符串
*/
public static String replace(String str, String replacedStr, int start, int end) {
StringBuffer stringBuffer = new StringBuffer();
stringBuffer.append(str);
stringBuffer.replace(start, end, replacedStr);
return stringBuffer.toString();
}
/**
* 删除开始相等的字符串
* @param sb 需要处理的字符串
* @param condition 条件
* @return 删除后的StringBuffer
*/
public static String deleteFirstEqualString(CharSequence str, CharSequence prefix) {
return removePrefix(str, prefix);
}
/**
* 删除尾部相等的字符串
*
* @param str 需要处理的字符串
* @param suffix 条件
* @return 删除后的字符串
*/
public static String deleteLastEqualString(CharSequence str, CharSequence suffix) {
StringBuffer sb = new StringBuffer(str);
int end = sb.length();
int start = end - suffix.length();
String condition = sb.substring(start, end);
if (suffix.equals(condition)) {
return sb.delete(start, end).toString();
}
return sb.toString();
}
/**
* 删除前后相等字符串
* @param str 需要处理的字符串
* @param firstStr 开始字符串
* @param lastStr 末尾字符串
* @return 删除后的字符串
*/
public static String deleteFirstLastEqualString(String str, String firstStr, String lastStr) {
str = deleteFirstEqualString(str, firstStr);
str = deleteLastEqualString(str, lastStr);
return str;
}
/**
* 删除前后字符串
* @param str 需要处理的字符串
* @param length 删除长度
* @return 删除后的字符串
*/
public static String deleteFirstLastString(String str, int length) {
return str.substring(length, str.length() - length);
}
}
|
0 | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/util/URIUtils.java | package ai.yue.library.base.util;
import org.springframework.web.util.UriUtils;
/**
* URI处理
*
* @author ylyue
* @since 2018年4月24日
*/
public class URIUtils {
/**
* The default encoding for URI encode/decode: <kbd>UTF-8</kbd>.
*/
public static final String DEFAULT_ENCODING = "UTF-8";
/**
* URI前缀或后缀通配符匹配（只能同时存在一种通配）
* @param array 包含通配符的URI的数组
* @param uri 实际的URI
* @return 是否匹配
*/
public static boolean isUriArraySuffixOrPrefixWildcard(String[] array, String uri) {
for (String url : array) {
// 1. 前通配
if (!url.endsWith("**")) {
if (uri.startsWith("/")) {
url = url.substring(2);
} else {
url = url.substring(3);
}
if (uri.endsWith(url)) {
return true;
}
} else {
// 2. 后通配
url = url.substring(0, url.length() - 3);
if (uri.startsWith(url)) {
return true;
}
}
}
return false;
}
/**
* URI编码
* @param source 要编码的字符串
* @return 编码后的字符串
*/
public static String encode(String source) {
return UriUtils.encode(source, DEFAULT_ENCODING);
}
/**
* URI解码
* @param source 要解码的字符串
* @return 解码后的字符串
*/
public static String decode(String source) {
return UriUtils.decode(source, DEFAULT_ENCODING);
}
}
|
0 | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/util/UUIDUtils.java | package ai.yue.library.base.util;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Random;
import java.util.UUID;
import cn.hutool.core.util.IdUtil;
/**
* UUID工具类
*
* @author ylyue
* @since 2018年1月19日
*/
public class UUIDUtils extends IdUtil {
/**
* 大写32位UUID
* @return 大写32位UUID
*/
public static String upperCaseUUID() {
return UUID.randomUUID().toString().replace("-", "").toUpperCase();
}
/**
* 小写32位UUID
* @return 小写32位UUID
*/
public static String lowerCaseUUID() {
return UUID.randomUUID().toString().replace("-", "");
}
/**
* 生成19纯数字随机单号
* @return 19纯数字随机单号
*/
public static String getOrderNo_19() {
String orderNo = new SimpleDateFormat("yyyyMMddHHmmss").format(new Date());
String trandNo = String.valueOf((Math.random() * 9 + 1));
orderNo += trandNo.substring(5, 10);
return orderNo;
}
/**
* 生成16纯数字随机单号
* @return 16纯数字随机单号
*/
public static String getOrderNo_16() {
Random random = new Random();
StringBuilder sb = new StringBuilder();
sb.append(System.currentTimeMillis());
sb.append(random.nextInt(10));
sb.append(random.nextInt(10));
sb.append(random.nextInt(10));
return sb.toString();
}
/**
* 随机生成n位数字编码（纯数字）
* @param length 长度
* @return 对应长度的数字编码（纯数字）
*/
public static String randomNumberCode(int length) {
//字符源，可以根据需要删减
String randomCodeSource = "0123456789";
StringBuilder code = new StringBuilder();
for (int i = 0; i < length; i++) {
//循环随机获得当次字符
code.append(String.valueOf(randomCodeSource.charAt((int) Math.floor(Math.random() * randomCodeSource.length()))));
}
return code.toString();
}
/**
* 随机生成n位大写字母编码（数字+大写字母）
* @param length 长度
* @return 对应长度的大写字母编码（数字+大写字母）
*/
public static String randomCapitalCode(int length) {
//字符源，可以根据需要删减
String randomCodeSource = "23456789ABCDEFGHGKLMNPQRSTUVWXYZ";//去掉1和i ，0和o
StringBuilder code = new StringBuilder();
for (int i = 0; i < length; i++) {
//循环随机获得当次字符
code.append(String.valueOf(randomCodeSource.charAt((int) Math.floor(Math.random() * randomCodeSource.length()))));
}
return code.toString();
}
/**
* 随机生成n位字符编码（数字+字母）
* @param length 长度
* @return 对应长度的字符编码（数字+字母）
*/
public static String randomCode(int length) {
//字符源，可以根据需要删减
String randomCodeSource = "23456789abcdefghgklmnpqrstuvwxyzABCDEFGHGKLMNPQRSTUVWXYZ";//去掉1和i ，0和o
StringBuilder code = new StringBuilder();
for (int i = 0; i < length; i++) {
//循环随机获得当次字符
code.append(String.valueOf(randomCodeSource.charAt((int) Math.floor(Math.random() * randomCodeSource.length()))));
}
return code.toString();
}
}
|
0 | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/util/package-info.java | /**
* 提供各种工具方法，按照归类入口为XXXUtils，如字符串工具StringUtils等
*
* @author ylyue
* @since 2019年10月13日
*/
package ai.yue.library.base.util; |
0 | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/validation/Validator.java | package ai.yue.library.base.validation;
import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.Date;
import java.util.Set;
import javax.validation.ConstraintViolation;
import org.springframework.beans.factory.annotation.Autowired;
import com.alibaba.fastjson.JSONObject;
import ai.yue.library.base.exception.ResultException;
import ai.yue.library.base.util.DateUtils;
import ai.yue.library.base.view.ResultInfo;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.exceptions.ValidateException;
import cn.hutool.core.lang.Console;
import cn.hutool.core.util.NumberUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import lombok.NoArgsConstructor;
import lombok.extern.slf4j.Slf4j;
/**
* <b>参数校验器</b>
* <p>全面简单的校验框架，更适合国内校验场景，支持多种校验方式，配合全局异常处理，只为更好的Restful
*
* @author ylyue
* @since 2019年6月25日
*/
@Slf4j
@NoArgsConstructor
public class Validator {
private Object param;
@Autowired
private javax.validation.Validator validator;
// 提示
private static final String NOT_NULL_HINT_MSG = "参数 {} 必须不为 null";
private static final String NOT_EMPTY_HINT_MSG = "参数 {} 必须不为empty(null 或 \"\")";
private static final String ASSERT_TRUE_HINT_MSG = "参数 {} 必须为 true";
private static final String ASSERT_FALSE_HINT_MSG = "参数 {} 必须为 false";
private static final String DIGITS_HINT_MSG = "参数 {} 必须是一个数字，其值必须在 {} - {} 之间（包含）";
private static final String MAX_HINT_MSG = "参数 {} 不能超过最大值：{}";
private static final String MIN_HINT_MSG = "参数 {} 不能低于最小值：{}";
private static final String LENGTH_HINT_MSG = "参数 {} 长度必须在 {} - {} 之间（包含）";
private static final String CHINESE_HINT_MSG = "参数 {} 中文校验不通过";
private static final String ENGLISH_HINT_MSG = "参数 {} 英文校验不通过";
private static final String BIRTHDAY_HINT_MSG = "参数 {} 生日校验不通过";
private static final String CELLPHONE_HINT_MSG = "参数 {} 不是一个合法的手机号码";
private static final String EMAIL_HINT_MSG = "参数 {} 不是一个合法的邮箱格式";
private static final String ID_CARD_HINT_MSG = "参数 {} 不是一个合法的身份证号码";
private static final String PLATE_NUMBER_HINT_MSG = "参数 {} 不是一个合法的中国车牌号码";
private static final String UUID_HINT_MSG = "参数 {} 不是一个合法的UUID";
private static final String URL_HINT_MSG = "参数 {} 不是一个合法的URL";
private static final String IPV4_HINT_MSG = "参数 {} 不是一个合法的IPV4地址";
private static final String IPV6_HINT_MSG = "参数 {} 不是一个合法的IPV6地址";
private static final String MAC_ADDRESS_HINT_MSG = "参数 {} 不是一个合法的MAC地址";
private static final String REGEX_HINT_MSG = "参数 {} 不满足正则表达式：{}";
/**
* 切换校验对象
*
* @param param 校验对象
* @return Validator
*/
public Validator param(Object param) {
this.param = param;
return this;
}
/**
* 必须不为 {@code null}
*
* @param paramName 参数名
* @return Validator
*/
public Validator notNull(String paramName) {
cn.hutool.core.lang.Validator.validateNotNull(param, StrUtil.format(NOT_NULL_HINT_MSG, paramName));
return this;
}
/**
* 必须不为empty(null 或 "")
*
* @param paramName 参数名
* @return Validator
*/
public Validator notEmpty(String paramName) {
cn.hutool.core.lang.Validator.validateNotEmpty(param, StrUtil.format(NOT_EMPTY_HINT_MSG, paramName));
return this;
}
/**
* 必须为 true
*
* @param paramName 参数名
* @return Validator
*/
public Validator assertTrue(String paramName) {
cn.hutool.core.lang.Validator.validateTrue((boolean) param, StrUtil.format(ASSERT_TRUE_HINT_MSG, paramName));
return this;
}
/**
* 必须为 false
*
* @param paramName 参数名
* @return Validator
*/
public Validator assertFalse(String paramName) {
cn.hutool.core.lang.Validator.validateFalse((boolean) param, StrUtil.format(ASSERT_FALSE_HINT_MSG, paramName));
return this;
}
/**
* 必须是一个数字，其值必须在可接受的范围内（包含）
*
* @param min 最小值
* @param max 最大值
* @param paramName 参数名
* @return Validator
*/
public Validator digits(Number min, Number max, String paramName) {
cn.hutool.core.lang.Validator.validateBetween((Number) param, min, max, StrUtil.format(DIGITS_HINT_MSG, paramName, min, max));
return this;
}
/**
* 最大值校验
*
* @param max 最大值
* @param paramName 参数名
* @return Validator
*/
public Validator max(Number max, String paramName) {
BigDecimal bigNum1 = NumberUtil.toBigDecimal((Number) param);
BigDecimal bigNum2 = NumberUtil.toBigDecimal(max);
if (!NumberUtil.isLessOrEqual(bigNum1, bigNum2)) {
throw new ValidateException(StrUtil.format(MAX_HINT_MSG, paramName, max));
}
return this;
}
/**
* 最小值校验
*
* @param min 最小值
* @param paramName 参数名
* @return Validator
*/
public Validator min(Number min, String paramName) {
BigDecimal bigNum1 = NumberUtil.toBigDecimal((Number) param);
BigDecimal bigNum2 = NumberUtil.toBigDecimal(min);
if (!NumberUtil.isGreaterOrEqual(bigNum1, bigNum2)) {
throw new ValidateException(StrUtil.format(MIN_HINT_MSG, paramName, min));
}
return this;
}
/**
* 长度校验
*
* @param min 最小长度
* @param max 最大长度
* @param paramName 参数名
* @return Validator
*/
public Validator length(int min, int max, String paramName) {
int length = ObjectUtil.length(param);
if (false == (length >= min && length <= max)) {
throw new ValidateException(StrUtil.format(LENGTH_HINT_MSG, paramName, min, max));
}
return this;
}
/**
* 中文校验
*
* @param paramName 参数名
* @return Validator
*/
public Validator chinese(String paramName) {
cn.hutool.core.lang.Validator.validateChinese((CharSequence) param, StrUtil.format(CHINESE_HINT_MSG, paramName));
return this;
}
/**
* 英文校验
*
* @param paramName 参数名
* @return Validator
*/
public Validator english(String paramName) {
cn.hutool.core.lang.Validator.validateWord((CharSequence) param, StrUtil.format(ENGLISH_HINT_MSG, paramName));
return this;
}
/**
* 生日校验
*
* @param paramName 参数名
* @return Validator
*/
public Validator birthday(String paramName) {
String date = null;
if (param instanceof String) {
date = (String) param;
} else if (param instanceof Date) {
date = DateUtil.formatDate((Date) param);
} else if (param instanceof LocalDate || param instanceof LocalDateTime) {
date = DateUtils.DATE_FORMATTER.format((LocalDate) param);
} else {
throw new ResultException(ResultInfo.error(StrUtil.format("参数 {} 未知类型，不支持生日校验", paramName)));
}
cn.hutool.core.lang.Validator.validateBirthday(date, StrUtil.format(BIRTHDAY_HINT_MSG, paramName));
return this;
}
/**
* 手机号校验
*
* @param paramName 参数名
* @return Validator
*/
public Validator cellphone(String paramName) {
cn.hutool.core.lang.Validator.validateMobile((CharSequence) param, StrUtil.format(CELLPHONE_HINT_MSG, paramName));
return this;
}
/**
* 邮箱校验
*
* @param paramName 参数名
* @return Validator
*/
public Validator email(String paramName) {
cn.hutool.core.lang.Validator.validateEmail((CharSequence) param, StrUtil.format(EMAIL_HINT_MSG, paramName));
return this;
}
/**
* 身份证校验
*
* @param paramName 参数名
* @return Validator
*/
public Validator idCard(String paramName) {
cn.hutool.core.lang.Validator.validateCitizenIdNumber((CharSequence) param, StrUtil.format(ID_CARD_HINT_MSG, paramName));
return this;
}
/**
* 中国车牌号校验
*
* @param paramName 参数名
* @return Validator
*/
public Validator plateNumber(String paramName) {
cn.hutool.core.lang.Validator.validatePlateNumber((CharSequence) param, StrUtil.format(PLATE_NUMBER_HINT_MSG, paramName));
return this;
}
/**
* UUID校验
*
* @param paramName 参数名
* @return Validator
*/
public Validator uuid(String paramName) {
cn.hutool.core.lang.Validator.validateUUID((CharSequence) param, StrUtil.format(UUID_HINT_MSG, paramName));
return this;
}
/**
* URL校验
*
* @param paramName 参数名
* @return Validator
*/
public Validator url(String paramName) {
cn.hutool.core.lang.Validator.validateUrl((CharSequence) param, StrUtil.format(URL_HINT_MSG, paramName));
return this;
}
/**
* IPV4地址校验
*
* @param paramName 参数名
* @return Validator
*/
public Validator ipv4(String paramName) {
cn.hutool.core.lang.Validator.validateIpv4((CharSequence) param, StrUtil.format(IPV4_HINT_MSG, paramName));
return this;
}
/**
* IPV6地址校验
*
* @param paramName 参数名
* @return Validator
*/
public Validator ipv6(String paramName) {
cn.hutool.core.lang.Validator.validateIpv6((CharSequence) param, StrUtil.format(IPV6_HINT_MSG, paramName));
return this;
}
/**
* MAC地址校验
*
* @param paramName 参数名
* @return Validator
*/
public Validator macAddress(String paramName) {
cn.hutool.core.lang.Validator.validateMac((CharSequence) param, StrUtil.format(MAC_ADDRESS_HINT_MSG, paramName));
return this;
}
/**
* 正则校验
*
* @param regex 正则表达式
* @param paramName 参数名
* @return Validator
*/
public Validator regex(String regex, String paramName) {
cn.hutool.core.lang.Validator.validateMatchRegex(regex, (CharSequence) param, StrUtil.format(REGEX_HINT_MSG, paramName, regex));
return this;
}
/**
* POJO对象校验（通过注解）
*
* @param param 校验对象
* @return Validator
*/
public Validator valid(Object param) {
Set<ConstraintViolation<Object>> violations = validator.validate(param);
if (violations.size() > 0) {
log.warn("{} violations.", violations.size());
Console.log("校验对象：{}", param);
JSONObject paramHint = new JSONObject();
violations.forEach(violation -> {
String key = violation.getPropertyPath().toString();
String msg = violation.getMessage();
paramHint.put(key, msg);
System.out.println(key + " " + msg);
});
throw new ValidateException(paramHint.toJSONString());
}
return this;
}
}
|
0 | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/validation/package-info.java | /**
* 字段校验器
*
* @author ylyue
* @since 2019年10月13日
*/
package ai.yue.library.base.validation; |
0 | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/validation | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/validation/annotation/Birthday.java | package ai.yue.library.base.validation.annotation;
import static java.lang.annotation.ElementType.ANNOTATION_TYPE;
import static java.lang.annotation.ElementType.CONSTRUCTOR;
import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.ElementType.PARAMETER;
import static java.lang.annotation.ElementType.TYPE_USE;
import static java.lang.annotation.RetentionPolicy.RUNTIME;
import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import javax.validation.Constraint;
import javax.validation.Payload;
import javax.validation.constraints.NotNull;
/**
* 验证是否为生日<br>
* 只支持以下几种格式：
* <ul>
* <li>yyyyMMdd</li>
* <li>yyyy-MM-dd</li>
* <li>yyyy/MM/dd</li>
* <li>yyyyMMdd</li>
* <li>yyyy年MM月dd日</li>
* </ul>
*
* @author ylyue
* @since 2019年5月8日
*/
@Documented
@Retention(RUNTIME)
@Target({ METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER, TYPE_USE })
@Constraint(validatedBy = { BirthdayValidator.class })
public @interface Birthday {
/**
* 是否不允许为空 {@linkplain NotNull}
* @return 默认：true
*/
boolean notNull() default true;
String message() default "不是一个合法的生日日期格式";
Class<?>[] groups() default {};
Class<? extends Payload>[] payload() default {};
}
|
0 | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/validation | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/validation/annotation/BirthdayValidator.java | package ai.yue.library.base.validation.annotation;
import java.time.temporal.TemporalAccessor;
import java.util.Date;
import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;
import ai.yue.library.base.util.DateUtils;
import ai.yue.library.base.util.StringUtils;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.lang.Validator;
/**
* @author ylyue
* @since 2019年5月8日
*/
public class BirthdayValidator implements ConstraintValidator<Birthday, Object> {
private boolean notNull;
@Override
public void initialize(Birthday constraintAnnotation) {
this.notNull = constraintAnnotation.notNull();
}
@Override
public boolean isValid(Object value, ConstraintValidatorContext context) {
String validValue = null;
if (value instanceof String) {
validValue = (String) value;
} else if (value instanceof Date) {
validValue = DateUtil.formatDate((Date) value);
} else if (value instanceof TemporalAccessor) {
validValue = DateUtils.toDateFormatter((TemporalAccessor) value);
}
if (StringUtils.isNotBlank(validValue)) {
return Validator.isBirthday(validValue);
}
if (notNull) {
return false;
}
return true;
}
}
|
0 | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/validation | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/validation/annotation/Cellphone.java | package ai.yue.library.base.validation.annotation;
import static java.lang.annotation.ElementType.ANNOTATION_TYPE;
import static java.lang.annotation.ElementType.CONSTRUCTOR;
import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.ElementType.PARAMETER;
import static java.lang.annotation.ElementType.TYPE_USE;
import static java.lang.annotation.RetentionPolicy.RUNTIME;
import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import javax.validation.Constraint;
import javax.validation.Payload;
import javax.validation.constraints.NotNull;
/**
* 验证是否为手机号码（中国）
*
* @author ylyue
* @since 2019年5月8日
*/
@Documented
@Retention(RUNTIME)
@Target({ METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER, TYPE_USE })
@Constraint(validatedBy = { CellphoneValidator.class })
public @interface Cellphone {
/**
* 是否不允许为空 {@linkplain NotNull}
* @return 默认：true
*/
boolean notNull() default true;
String message() default "不是一个合法的手机号码";
Class<?>[] groups() default {};
Class<? extends Payload>[] payload() default {};
}
|
0 | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/validation | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/validation/annotation/CellphoneValidator.java | package ai.yue.library.base.validation.annotation;
import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;
import ai.yue.library.base.util.StringUtils;
import cn.hutool.core.lang.Validator;
/**
* @author ylyue
* @since 2019年5月8日
*/
public class CellphoneValidator implements ConstraintValidator<Cellphone, String> {
private boolean notNull;
@Override
public void initialize(Cellphone constraintAnnotation) {
this.notNull = constraintAnnotation.notNull();
}
@Override
public boolean isValid(String value, ConstraintValidatorContext context) {
if (StringUtils.isNotBlank(value)) {
return Validator.isMobile(value);
}
if (notNull) {
return false;
}
return true;
}
}
|
0 | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/validation | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/validation/annotation/Chinese.java | package ai.yue.library.base.validation.annotation;
import static java.lang.annotation.ElementType.ANNOTATION_TYPE;
import static java.lang.annotation.ElementType.CONSTRUCTOR;
import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.ElementType.PARAMETER;
import static java.lang.annotation.ElementType.TYPE_USE;
import static java.lang.annotation.RetentionPolicy.RUNTIME;
import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import javax.validation.Constraint;
import javax.validation.Payload;
import javax.validation.constraints.NotNull;
/**
* 验证是否为汉字
*
* @author ylyue
* @since 2019年5月8日
*/
@Documented
@Retention(RUNTIME)
@Target({ METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER, TYPE_USE })
@Constraint(validatedBy = { ChineseValidator.class })
public @interface Chinese {
/**
* 是否不允许为空 {@linkplain NotNull}
* @return 默认：true
*/
boolean notNull() default true;
String message() default "必须是中文汉字";
Class<?>[] groups() default {};
Class<? extends Payload>[] payload() default {};
}
|
0 | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/validation | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/validation/annotation/ChineseValidator.java | package ai.yue.library.base.validation.annotation;
import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;
import ai.yue.library.base.util.StringUtils;
import cn.hutool.core.lang.Validator;
import cn.hutool.core.util.CharUtil;
import cn.hutool.core.util.StrUtil;
/**
* @author ylyue
* @since 2019年5月8日
*/
public class ChineseValidator implements ConstraintValidator<Chinese, Object> {
private boolean notNull;
@Override
public void initialize(Chinese constraintAnnotation) {
this.notNull = constraintAnnotation.notNull();
}
@Override
public boolean isValid(Object value, ConstraintValidatorContext context) {
String validValue = null;
if ((CharUtil.isChar(value) && !CharUtil.isBlankChar((char) value))
|| (value instanceof String && StrUtil.isNotBlank((String) value))) {
validValue = StrUtil.toString(value);
}
if (StringUtils.isNotBlank(validValue)) {
return Validator.isChinese(validValue);
}
if (notNull) {
return false;
}
return true;
}
}
|
0 | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/validation | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/validation/annotation/English.java | package ai.yue.library.base.validation.annotation;
import static java.lang.annotation.ElementType.ANNOTATION_TYPE;
import static java.lang.annotation.ElementType.CONSTRUCTOR;
import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.ElementType.PARAMETER;
import static java.lang.annotation.ElementType.TYPE_USE;
import static java.lang.annotation.RetentionPolicy.RUNTIME;
import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import javax.validation.Constraint;
import javax.validation.Payload;
import javax.validation.constraints.NotNull;
/**
* 验证该字符串是否是字母（包括大写和小写字母）
*
* @author ylyue
* @since 2019年5月8日
*/
@Documented
@Retention(RUNTIME)
@Target({ METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER, TYPE_USE })
@Constraint(validatedBy = { EnglishValidator.class })
public @interface English {
/**
* 是否不允许为空 {@linkplain NotNull}
* @return 默认：true
*/
boolean notNull() default true;
String message() default "必须是英语";
Class<?>[] groups() default {};
Class<? extends Payload>[] payload() default {};
}
|
0 | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/validation | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/validation/annotation/EnglishValidator.java | package ai.yue.library.base.validation.annotation;
import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;
import ai.yue.library.base.util.StringUtils;
import cn.hutool.core.lang.Validator;
/**
* @author ylyue
* @since 2019年5月8日
*/
public class EnglishValidator implements ConstraintValidator<English, String> {
private boolean notNull;
@Override
public void initialize(English constraintAnnotation) {
this.notNull = constraintAnnotation.notNull();
}
@Override
public boolean isValid(String value, ConstraintValidatorContext context) {
if (StringUtils.isNotBlank(value)) {
return Validator.isWord(value);
}
if (notNull) {
return false;
}
return true;
}
}
|
0 | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/validation | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/validation/annotation/IPV4.java | package ai.yue.library.base.validation.annotation;
import static java.lang.annotation.ElementType.ANNOTATION_TYPE;
import static java.lang.annotation.ElementType.CONSTRUCTOR;
import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.ElementType.PARAMETER;
import static java.lang.annotation.ElementType.TYPE_USE;
import static java.lang.annotation.RetentionPolicy.RUNTIME;
import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import javax.validation.Constraint;
import javax.validation.Payload;
import javax.validation.constraints.NotNull;
/**
* 验证是否为IPV4地址
*
* @author ylyue
* @since 2019年5月8日
*/
@Documented
@Retention(RUNTIME)
@Target({ METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER, TYPE_USE })
@Constraint(validatedBy = { IPV4Validator.class })
public @interface IPV4 {
/**
* 是否不允许为空 {@linkplain NotNull}
* @return 默认：true
*/
boolean notNull() default true;
String message() default "不是一个合法的IPV4地址";
Class<?>[] groups() default {};
Class<? extends Payload>[] payload() default {};
}
|
0 | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/validation | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/validation/annotation/IPV4Validator.java | package ai.yue.library.base.validation.annotation;
import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;
import ai.yue.library.base.util.StringUtils;
import cn.hutool.core.lang.Validator;
/**
* @author ylyue
* @since 2019年5月8日
*/
public class IPV4Validator implements ConstraintValidator<IPV4, String> {
private boolean notNull;
@Override
public void initialize(IPV4 constraintAnnotation) {
this.notNull = constraintAnnotation.notNull();
}
@Override
public boolean isValid(String value, ConstraintValidatorContext context) {
if (StringUtils.isNotBlank(value)) {
return Validator.isIpv4(value);
}
if (notNull) {
return false;
}
return true;
}
}
|
0 | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/validation | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/validation/annotation/IPV6.java | package ai.yue.library.base.validation.annotation;
import static java.lang.annotation.ElementType.ANNOTATION_TYPE;
import static java.lang.annotation.ElementType.CONSTRUCTOR;
import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.ElementType.PARAMETER;
import static java.lang.annotation.ElementType.TYPE_USE;
import static java.lang.annotation.RetentionPolicy.RUNTIME;
import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import javax.validation.Constraint;
import javax.validation.Payload;
import javax.validation.constraints.NotNull;
/**
* 验证是否为IPV6地址
*
* @author ylyue
* @since 2019年5月8日
*/
@Documented
@Retention(RUNTIME)
@Target({ METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER, TYPE_USE })
@Constraint(validatedBy = { IPV6Validator.class })
public @interface IPV6 {
/**
* 是否不允许为空 {@linkplain NotNull}
* @return 默认：true
*/
boolean notNull() default true;
String message() default "不是一个合法的IPV6地址";
Class<?>[] groups() default {};
Class<? extends Payload>[] payload() default {};
}
|
0 | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/validation | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/validation/annotation/IPV6Validator.java | package ai.yue.library.base.validation.annotation;
import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;
import ai.yue.library.base.util.StringUtils;
import cn.hutool.core.lang.Validator;
/**
* @author ylyue
* @since 2019年5月8日
*/
public class IPV6Validator implements ConstraintValidator<IPV6, String> {
private boolean notNull;
@Override
public void initialize(IPV6 constraintAnnotation) {
this.notNull = constraintAnnotation.notNull();
}
@Override
public boolean isValid(String value, ConstraintValidatorContext context) {
if (StringUtils.isNotBlank(value)) {
return Validator.isIpv6(value);
}
if (notNull) {
return false;
}
return true;
}
}
|
0 | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/validation | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/validation/annotation/IdCard.java | package ai.yue.library.base.validation.annotation;
import static java.lang.annotation.ElementType.ANNOTATION_TYPE;
import static java.lang.annotation.ElementType.CONSTRUCTOR;
import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.ElementType.PARAMETER;
import static java.lang.annotation.ElementType.TYPE_USE;
import static java.lang.annotation.RetentionPolicy.RUNTIME;
import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import javax.validation.Constraint;
import javax.validation.Payload;
import javax.validation.constraints.NotNull;
/**
* 验证是否为身份证号码（18位中国）<br>
* 出生日期只支持到到2999年
*
* @author ylyue
* @since 2019年5月8日
*/
@Documented
@Retention(RUNTIME)
@Target({ METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER, TYPE_USE })
@Constraint(validatedBy = { IdCardValidator.class })
public @interface IdCard {
/**
* 是否不允许为空 {@linkplain NotNull}
* @return 默认：true
*/
boolean notNull() default true;
String message() default "不是一个合法的身份证号码";
Class<?>[] groups() default {};
Class<? extends Payload>[] payload() default {};
}
|
0 | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/validation | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/validation/annotation/IdCardValidator.java | package ai.yue.library.base.validation.annotation;
import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;
import ai.yue.library.base.util.StringUtils;
import cn.hutool.core.lang.Validator;
/**
* @author ylyue
* @since 2019年5月8日
*/
public class IdCardValidator implements ConstraintValidator<IdCard, String> {
private boolean notNull;
@Override
public void initialize(IdCard constraintAnnotation) {
this.notNull = constraintAnnotation.notNull();
}
@Override
public boolean isValid(String value, ConstraintValidatorContext context) {
if (StringUtils.isNotBlank(value)) {
return Validator.isCitizenId(value);
}
if (notNull) {
return false;
}
return true;
}
}
|
0 | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/validation | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/validation/annotation/MacAddress.java | package ai.yue.library.base.validation.annotation;
import static java.lang.annotation.ElementType.ANNOTATION_TYPE;
import static java.lang.annotation.ElementType.CONSTRUCTOR;
import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.ElementType.PARAMETER;
import static java.lang.annotation.ElementType.TYPE_USE;
import static java.lang.annotation.RetentionPolicy.RUNTIME;
import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import javax.validation.Constraint;
import javax.validation.Payload;
import javax.validation.constraints.NotNull;
/**
* 验证是否为MAC地址
*
* @author ylyue
* @since 2019年5月8日
*/
@Documented
@Retention(RUNTIME)
@Target({ METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER, TYPE_USE })
@Constraint(validatedBy = { MacAddressValidator.class })
public @interface MacAddress {
/**
* 是否不允许为空 {@linkplain NotNull}
* @return 默认：true
*/
boolean notNull() default true;
String message() default "不是一个合法的MAC地址";
Class<?>[] groups() default {};
Class<? extends Payload>[] payload() default {};
}
|
0 | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/validation | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/validation/annotation/MacAddressValidator.java | package ai.yue.library.base.validation.annotation;
import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;
import ai.yue.library.base.util.StringUtils;
import cn.hutool.core.lang.Validator;
/**
* @author ylyue
* @since 2019年5月8日
*/
public class MacAddressValidator implements ConstraintValidator<MacAddress, String> {
private boolean notNull;
@Override
public void initialize(MacAddress constraintAnnotation) {
this.notNull = constraintAnnotation.notNull();
}
@Override
public boolean isValid(String value, ConstraintValidatorContext context) {
if (StringUtils.isNotBlank(value)) {
return Validator.isMac(value);
}
if (notNull) {
return false;
}
return true;
}
}
|
0 | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/validation | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/validation/annotation/PlateNumber.java | package ai.yue.library.base.validation.annotation;
import static java.lang.annotation.ElementType.ANNOTATION_TYPE;
import static java.lang.annotation.ElementType.CONSTRUCTOR;
import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.ElementType.PARAMETER;
import static java.lang.annotation.ElementType.TYPE_USE;
import static java.lang.annotation.RetentionPolicy.RUNTIME;
import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import javax.validation.Constraint;
import javax.validation.Payload;
import javax.validation.constraints.NotNull;
/**
* 验证是否为中国车牌号
*
* @author ylyue
* @since 2019年5月8日
*/
@Documented
@Retention(RUNTIME)
@Target({ METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER, TYPE_USE })
@Constraint(validatedBy = { PlateNumberValidator.class })
public @interface PlateNumber {
/**
* 是否不允许为空 {@linkplain NotNull}
* @return 默认：true
*/
boolean notNull() default true;
String message() default "不是一个合法的中国车牌号";
Class<?>[] groups() default {};
Class<? extends Payload>[] payload() default {};
}
|
0 | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/validation | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/validation/annotation/PlateNumberValidator.java | package ai.yue.library.base.validation.annotation;
import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;
import ai.yue.library.base.util.StringUtils;
import cn.hutool.core.lang.Validator;
/**
* @author ylyue
* @since 2019年5月8日
*/
public class PlateNumberValidator implements ConstraintValidator<PlateNumber, String> {
private boolean notNull;
@Override
public void initialize(PlateNumber constraintAnnotation) {
this.notNull = constraintAnnotation.notNull();
}
@Override
public boolean isValid(String value, ConstraintValidatorContext context) {
if (StringUtils.isNotBlank(value)) {
return Validator.isPlateNumber(value);
}
if (notNull) {
return false;
}
return true;
}
}
|
0 | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/validation | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/validation/annotation/UUID.java | package ai.yue.library.base.validation.annotation;
import static java.lang.annotation.ElementType.ANNOTATION_TYPE;
import static java.lang.annotation.ElementType.CONSTRUCTOR;
import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.ElementType.PARAMETER;
import static java.lang.annotation.ElementType.TYPE_USE;
import static java.lang.annotation.RetentionPolicy.RUNTIME;
import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import javax.validation.Constraint;
import javax.validation.Payload;
import javax.validation.constraints.NotNull;
/**
* 验证是否为UUID<br>
* 包括带横线标准格式和不带横线的简单模式
*
* @author ylyue
* @since 2019年5月8日
*/
@Documented
@Retention(RUNTIME)
@Target({ METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER, TYPE_USE })
@Constraint(validatedBy = { UUIDValidator.class })
public @interface UUID {
/**
* 是否不允许为空 {@linkplain NotNull}
* @return 默认：true
*/
boolean notNull() default true;
String message() default "不是一个合法的UUID";
Class<?>[] groups() default {};
Class<? extends Payload>[] payload() default {};
}
|
0 | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/validation | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/validation/annotation/UUIDValidator.java | package ai.yue.library.base.validation.annotation;
import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;
import ai.yue.library.base.util.StringUtils;
import cn.hutool.core.lang.Validator;
/**
* @author ylyue
* @since 2019年5月8日
*/
public class UUIDValidator implements ConstraintValidator<UUID, String> {
private boolean notNull;
@Override
public void initialize(UUID constraintAnnotation) {
this.notNull = constraintAnnotation.notNull();
}
@Override
public boolean isValid(String value, ConstraintValidatorContext context) {
if (StringUtils.isNotBlank(value)) {
return Validator.isUUID(value);
}
if (notNull) {
return false;
}
return true;
}
}
|
0 | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/validation | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/validation/annotation/package-info.java | /**
* 定义yue默认所提供的字段校验注解
*
* @author ylyue
* @since 2019年10月18日
*/
package ai.yue.library.base.validation.annotation; |
0 | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/view/Result.java | package ai.yue.library.base.view;
import static com.alibaba.fastjson.util.TypeUtils.castToBigDecimal;
import static com.alibaba.fastjson.util.TypeUtils.castToBigInteger;
import static com.alibaba.fastjson.util.TypeUtils.castToBoolean;
import static com.alibaba.fastjson.util.TypeUtils.castToDate;
import static com.alibaba.fastjson.util.TypeUtils.castToDouble;
import static com.alibaba.fastjson.util.TypeUtils.castToInt;
import static com.alibaba.fastjson.util.TypeUtils.castToLong;
import static com.alibaba.fastjson.util.TypeUtils.castToSqlDate;
import static com.alibaba.fastjson.util.TypeUtils.castToTimestamp;
import java.io.Serializable;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Date;
import java.util.List;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.annotation.JSONField;
import ai.yue.library.base.convert.Convert;
import ai.yue.library.base.exception.ResultException;
import ai.yue.library.base.util.ListUtils;
import ai.yue.library.base.util.SpringUtils;
import ai.yue.library.base.webenv.WebEnv;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* HTTP请求最外层响应对象，更适应Restful风格API
*
* @author ylyue
* @since 2017年10月8日
*/
@Data
@Builder(toBuilder = true)
@NoArgsConstructor
@AllArgsConstructor
public class Result<T> implements Serializable {
private static final long serialVersionUID = -3830508963654505583L;
/** 状态码 */
@JSONField(ordinal = 1)
private Integer code;
/** 提示信息 */
@JSONField(ordinal = 2)
private String msg;
/** 状态 */
@JSONField(ordinal = 3)
private boolean flag;
/** count */
@JSONField(ordinal = 4)
private Long count;
/** 数据 */
@JSONField(ordinal = 5)
private T data;
/**
* <b>成功校验</b>
* <p>如果此处获得的Result是一个错误提示结果，那么便会抛出一个 {@linkplain ResultException} 异常，以便于数据回滚并进行异常统一处理。
*
* @throws ResultException 返回的请求异常结果
*/
public void successValidate() {
if (!flag) {
throw new ResultException(this);
}
}
public <D> D getData(Class<D> clazz) {
return Convert.convert(data, clazz);
}
public <D> D dataToObject(Class<D> clazz) {
return getData(clazz);
}
public <D> D dataToJavaBean(Class<D> clazz) {
return Convert.toJavaBean(data, clazz);
}
public JSONObject dataToJSONObject() {
return Convert.toJSONObject(data);
}
public JSONArray dataToJSONArray() {
return Convert.toJSONArray(data);
}
public <D> List<D> dataToList(Class<D> clazz) {
return Convert.toList(clazz, data);
}
@SuppressWarnings("unchecked")
public List<JSONObject> dataToJsonList() {
if (data instanceof List) {
var dataTemp = (List<?>) data;
if (ListUtils.isNotEmpty(dataTemp)) {
if (dataTemp.get(0) instanceof JSONObject) {
return (List<JSONObject>) data;
}
}
}
return ListUtils.toJsonList(dataToJSONArray());
}
public Boolean dataToBoolean() {
if (data == null) {
return null;
}
return castToBoolean(data);
}
public Integer dataToInteger() {
return castToInt(data);
}
public Long dataToLong() {
return castToLong(data);
}
public Double dataToDouble() {
return castToDouble(data);
}
public BigDecimal dataToBigDecimal() {
return castToBigDecimal(data);
}
public BigInteger dataToBigInteger() {
return castToBigInteger(data);
}
public String dataToString() {
if (data == null) {
return null;
}
return data.toString();
}
public String dataToJSONString() {
if (data == null) {
return null;
}
return JSONObject.toJSONString(data);
}
public Date dataToDate() {
return castToDate(data);
}
public java.sql.Date dataToSqlDate() {
return castToSqlDate(data);
}
public java.sql.Timestamp dataToTimestamp() {
return castToTimestamp(data);
}
/**
* 将Result写入当前请求上下文的响应结果中，如：HttpServletResponse等。具体由当前 {@link WebEnv} 环境实现
*/
public void response() {
WebEnv webEnv = SpringUtils.getBean(WebEnv.class);
webEnv.resultResponse(this);
}
}
|
0 | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/view/ResultEnum.java | package ai.yue.library.base.view;
import org.springframework.http.HttpStatus;
import lombok.AllArgsConstructor;
import lombok.Getter;
/**
* Result默认枚举值定义
* <p>参考{@linkplain HttpStatus}
*
* @author ylyue
* @since 2017年10月8日
*/
@Getter
@AllArgsConstructor
public enum ResultEnum {
// 200 - 正确结果
SUCCESS(200, "成功"),
LOGGED_IN(210, "会话未注销，无需登录"),
// 300 - 资源、重定向、定位等提示
RESOURCE_ALREADY_INVALID(300, "资源已失效"),
FILE_EMPTY(310, "文件上传请求错误，获得文件信息为空，求先使用测试工具（如：postman）校验，同时文件必须有明确的匹配类型（如文本类型：.txt）"),
// 400 - 客户端错误
BAD_REQUEST(400, "错误的请求，参数校验未通过，请参照API核对后重试"),
UNAUTHORIZED(401, "未登录或登录已失效（Unauthorized）"),
ATTACK(402, "非法访问"),
FORBIDDEN(403, "无权限（Forbidden）"),
NOT_FOUND(404, "Not Found"),
METHOD_NOT_ALLOWED(405, "方法不允许（Method Not Allowed）"),
/**
* {@code 410 Gone}.
* @see <a href="https://tools.ietf.org/html/rfc7231#section-6.5.9">
* HTTP/1.1: Semantics and Content, section 6.5.9</a>
*/
GONE(410, "当前API接口版本已弃用，请客户端更新接口调用方式"),
UNSUPPORTED_MEDIA_TYPE(415, "Unsupported Media Type"),
TOO_MANY_REQUESTS(429, "频繁请求限流，请稍后重试（Too Many Requests）"),
PARAM_VOID(432, "参数为空"),
PARAM_CHECK_NOT_PASS(433, "参数校验未通过，请参照API核对后重试"),
PARAM_VALUE_INVALID(434, "参数校验未通过，无效的value"),
PARAM_DECRYPT_ERROR(435, "参数解密错误"),
// 500 - 服务器错误
INTERNAL_SERVER_ERROR(500, "服务器内部错误（Internal Server Error）"),
ERROR(501, "请求错误"),
BAD_GATEWAY(502, "Bad Gateway"),
/**
* {@code 503 Service Unavailable}.
* @see <a href="https://tools.ietf.org/html/rfc7231#section-6.6.4">HTTP/1.1: Semantics and Content, section 6.6.4</a>
*/
SERVICE_UNAVAILABLE(503, "Service Unavailable"),
/**
* {@code 504 Gateway Timeout}.
* @see <a href="https://tools.ietf.org/html/rfc7231#section-6.6.5">HTTP/1.1: Semantics and Content, section 6.6.5</a>
*/
GATEWAY_TIMEOUT(504, "Gateway Timeout"),
DATA_STRUCTURE(505, "数据结构异常"),
DB_ERROR(506, "数据结构异常，请检查相应数据结构一致性"),
CLIENT_FALLBACK(507, "哎哟喂！网络开小差了，请稍后重试..."),
CLIENT_FALLBACK_ERROR(508, "哎哟喂！服务都被您挤爆了..."),
TYPE_CONVERT_ERROR(509, "类型转换错误"),
// 600 - 自定义错误提示
/**
* 开发者自定义类型提示，请覆盖： {@linkplain #msg}
*/
DEV_CUSTOM_TYPE_PROMPT(600, "开发者自定义类型提示，请覆盖。");
private Integer code;
private String msg;
}
|
0 | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/view/ResultInfo.java | package ai.yue.library.base.view;
/**
* 便捷返回 - {@code Restful} 风格API结果
*
* @author ylyue
* @since 2017年7月31日
*/
public class ResultInfo {
// ------ Result error builder ------
/**
* 失败后调用
*
* @param code 状态码
* @param msg 提示消息
* @return
*/
private static Result<?> error(Integer code, String msg) {
return Result.builder().code(code).msg(msg).flag(false).build();
}
/**
* 失败后调用
*
* @param <T>
* @param code 状态码
* @param msg 提示消息
* @param data 异常数据
* @return
*/
private static <T> Result<T> error(Integer code, String msg, T data) {
return new Result<T>().toBuilder().code(code).msg(msg).flag(false).data(data).build();
}
// 200 - 正确结果
/**
* 成功后调用，返回的data为null
* @return HTTP请求，最外层响应对象
*/
private static Result<?> success(Integer code, String msg) {
return Result.builder()
.code(code)
.msg(msg)
.flag(true)
.build();
}
/**
* 成功后调用，返回的data为null
* @return HTTP请求，最外层响应对象
*/
public static Result<?> success() {
return success(ResultEnum.SUCCESS.getCode(), ResultEnum.SUCCESS.getMsg());
}
/**
* 成功后调用，返回的data为一个对象
* @param <T> 泛型
* @param data 数据
* @return HTTP请求，最外层响应对象
*/
public static <T> Result<T> success(T data) {
return new Result<T>().toBuilder()
.code(ResultEnum.SUCCESS.getCode())
.msg(ResultEnum.SUCCESS.getMsg())
.flag(true)
.data(data)
.build();
}
/**
* 成功后调用，分页查询
* @param <T> 泛型
* @param count 总数
* @param data 数据
* @return HTTP请求，最外层响应对象
*/
public static <T> Result<T> success(Long count, T data) {
Result<T> result = new Result<T>(ResultEnum.SUCCESS.getCode(), ResultEnum.SUCCESS.getMsg(), true, count, data);
return result;
}
/**
* 成功后调用，分页查询
* @param <T> 泛型
* @param code 自定义code（默认200）
* @param count 总数
* @param data 数据
* @return HTTP请求，最外层响应对象
*/
public static <T> Result<T> success(Integer code, Long count, T data) {
Result<T> result = new Result<T>(code, ResultEnum.SUCCESS.getMsg(), true, count, data);
return result;
}
/**
* 会话未注销，无需登录-210
* @return HTTP请求，最外层响应对象
*/
public static Result<?> loggedIn() {
return success(ResultEnum.LOGGED_IN.getCode(), ResultEnum.LOGGED_IN.getMsg());
}
// 300 - 资源、重定向、定位等提示
/**
* 资源已失效-300
* @return HTTP请求，最外层响应对象
*/
public static Result<?> resourceAlreadyInvalid() {
return error(ResultEnum.RESOURCE_ALREADY_INVALID.getCode(), ResultEnum.RESOURCE_ALREADY_INVALID.getMsg());
}
/**
* 文件上传请求错误，获得文件信息为空，同时文件必须有明确的匹配类型（如文本类型：.txt）-301
* @return HTTP请求，最外层响应对象
*/
public static Result<?> fileEmpty() {
return error(ResultEnum.FILE_EMPTY.getCode(), ResultEnum.FILE_EMPTY.getMsg());
}
// 400 - 客户端错误
/**
* 未登录或登录已失效-401
* @return HTTP请求，最外层响应对象
*/
public static Result<?> unauthorized() {
return error(ResultEnum.UNAUTHORIZED.getCode(), ResultEnum.UNAUTHORIZED.getMsg());
}
/**
* 非法访问-402
* @return HTTP请求，最外层响应对象
*/
public static Result<?> attack() {
return error(ResultEnum.ATTACK.getCode(), ResultEnum.ATTACK.getMsg());
}
/**
* 非法访问-402
* @param <T> 泛型
* @param data 异常数据
* @return HTTP请求，最外层响应对象
*/
public static <T> Result<T> attack(T data) {
return error(ResultEnum.ATTACK.getCode(), ResultEnum.ATTACK.getMsg(), data);
}
/**
* 无权限-403
*
* @return HTTP请求，最外层响应对象
*/
public static Result<?> forbidden() {
return error(ResultEnum.FORBIDDEN.getCode(), ResultEnum.FORBIDDEN.getMsg());
}
/**
* API接口版本弃用-410
*
* @return HTTP请求，最外层响应对象
*/
public static Result<?> gone() {
return error(ResultEnum.GONE.getCode(), ResultEnum.GONE.getMsg());
}
/**
* 频繁请求限流-429
*
* @return HTTP请求，最外层响应对象
*/
public static Result<?> tooManyRequests() {
return error(ResultEnum.TOO_MANY_REQUESTS.getCode(), ResultEnum.TOO_MANY_REQUESTS.getMsg());
}
/**
* 参数为空-432
*
* @return HTTP请求，最外层响应对象
*/
public static Result<?> paramVoid() {
return error(ResultEnum.PARAM_VOID.getCode(), ResultEnum.PARAM_VOID.getMsg());
}
/**
* 参数校验未通过，请参照API核对后重试-433
*
* @return HTTP请求，最外层响应对象
*/
public static Result<?> paramCheckNotPass() {
return error(ResultEnum.PARAM_CHECK_NOT_PASS.getCode(), ResultEnum.PARAM_CHECK_NOT_PASS.getMsg());
}
/**
* 参数校验未通过，请参照API核对后重试-433
* @param data {@link Result#setData(Object)} 提示信息
* @return HTTP请求，最外层响应对象
*/
public static Result<String> paramCheckNotPass(String data) {
return error(ResultEnum.PARAM_CHECK_NOT_PASS.getCode(), ResultEnum.PARAM_CHECK_NOT_PASS.getMsg(), data);
}
/**
* 参数校验未通过，无效的value-434
* @return HTTP请求，最外层响应对象
*/
public static Result<?> paramValueInvalid() {
return error(ResultEnum.PARAM_VALUE_INVALID.getCode(), ResultEnum.PARAM_VALUE_INVALID.getMsg());
}
/**
* 参数校验未通过，无效的value-434
* @param data {@link Result#setData(Object)} 提示信息
* @return HTTP请求，最外层响应对象
*/
public static Result<String> paramValueInvalid(String data) {
return error(ResultEnum.PARAM_VALUE_INVALID.getCode(), ResultEnum.PARAM_VALUE_INVALID.getMsg(), data);
}
/**
* 参数解密错误-435
* @return HTTP请求，最外层响应对象
*/
public static Result<?> paramDecryptError() {
return error(ResultEnum.PARAM_DECRYPT_ERROR.getCode(), ResultEnum.PARAM_DECRYPT_ERROR.getMsg());
}
// 500 - 服务器错误
/**
* 服务器内部错误-500
* @return HTTP请求，最外层响应对象
*/
public static Result<?> internalServerError() {
return error(ResultEnum.INTERNAL_SERVER_ERROR.getCode(), ResultEnum.INTERNAL_SERVER_ERROR.getMsg());
}
/**
* 服务器内部错误-500
* @param <T> 泛型
* @param data 异常数据
* @return HTTP请求，最外层响应对象
*/
public static <T> Result<T> internalServerError(T data) {
return error(ResultEnum.INTERNAL_SERVER_ERROR.getCode(), ResultEnum.INTERNAL_SERVER_ERROR.getMsg(), data);
}
/**
* 请求错误-501
* @return HTTP请求，最外层响应对象
*/
public static Result<?> error() {
return error(ResultEnum.ERROR.getCode(), ResultEnum.ERROR.getMsg());
}
/**
* 请求错误-501
* @param <T> 泛型
* @param data 异常数据
* @return HTTP请求，最外层响应对象
*/
public static <T> Result<T> error(T data) {
return error(ResultEnum.ERROR.getCode(), ResultEnum.ERROR.getMsg(), data);
}
/**
* 数据结构异常-505
* @return HTTP请求，最外层响应对象
*/
public static Result<?> dataStructure() {
return error(ResultEnum.DATA_STRUCTURE.getCode(), ResultEnum.DATA_STRUCTURE.getMsg());
}
/**
* 数据结构异常-505
* <p><i>不正确的结果大小</i>
*
* @param expected 预期值
* @param actual 实际值
* @return HTTP请求，最外层响应对象
*/
public static Result<?> dataStructure(int expected, int actual) {
String data = "Incorrect result size: expected " + expected + ", actual " + actual;
return error(ResultEnum.DATA_STRUCTURE.getCode(), ResultEnum.DATA_STRUCTURE.getMsg(), data);
}
/**
* 数据结构异常，请检查相应数据结构一致性-506
* @return HTTP请求，最外层响应对象
*/
public static Result<?> dbError() {
return error(ResultEnum.DB_ERROR.getCode(), ResultEnum.DB_ERROR.getMsg());
}
/**
* 数据结构异常，请检查相应数据结构一致性-506
*
* @param data {@link Result#setData(Object)} 提示信息
* @return HTTP请求，最外层响应对象
*/
public static Result<String> dbError(String data) {
return error(ResultEnum.DB_ERROR.getCode(), ResultEnum.DB_ERROR.getMsg(), data);
}
/**
* 哎哟喂！网络开小差了，请稍后重试...-507
* @return HTTP请求，最外层响应对象
*/
public static Result<?> clientFallback() {
return error(ResultEnum.CLIENT_FALLBACK.getCode(), ResultEnum.CLIENT_FALLBACK.getMsg());
}
/**
* 哎哟喂！服务都被您挤爆了...-508
* @return HTTP请求，最外层响应对象
*/
public static Result<?> clientFallbackError() {
return error(ResultEnum.CLIENT_FALLBACK_ERROR.getCode(), ResultEnum.CLIENT_FALLBACK_ERROR.getMsg());
}
/**
* 类型转换错误-509
*
* @param data {@link Result#setData(Object)} 提示信息
* @return HTTP请求，最外层响应对象
*/
public static Result<String> typeConvertError(String data) {
return error(ResultEnum.TYPE_CONVERT_ERROR.getCode(), ResultEnum.TYPE_CONVERT_ERROR.getMsg(), data);
}
// 600 - 自定义错误提示
/**
* 开发者自定义类型提示，请覆盖： {@linkplain Result#setMsg(String)}
*
* @param msg 提示消息
* @return HTTP请求，最外层响应对象
*/
public static Result<?> devCustomTypePrompt(String msg) {
return error(ResultEnum.DEV_CUSTOM_TYPE_PROMPT.getCode(), msg);
}
}
|
0 | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/view/ResultPrompt.java | package ai.yue.library.base.view;
/**
* String类型异常处理提示信息-常量类
*
* @author ylyue
* @since 2018年7月19日
*/
public class ResultPrompt {
//---------------------预定义结果提示---------------------
public static final String USER_EXIST = "用户已存在";
public static final String USER_NO_EXIST = "用户不存在";
public static final String USER_STOP = "用户已停用";
public static final String USER_INVALID = "无效的用户";
public static final String USERNAME_OR_PASSWORD_ERROR = "用户名或密码错误";
public static final String ORIGINAL_PASSWORD_ERROR = "原密码错误";
public static final String PHONE_EXIST = "手机号已被注册";
public static final String PASSWORD_INVALID = "无效的口令";
public static final String CAPTCHA_ERROR = "验证码错误";
public static final String INVITE_CODE_INVALID = "邀请码无效";
public static final String ACCOUNT_EXIST_BINDING = "此帐户已被绑定";
public static final String ACCOUNT_EXIST_BUSINESS_NOT_ALLOW_CHANGE = "帐户存在业务，暂时不允许改变状态";
public static final String ACCOUNT_BALANCE_NOT_ENOUGH = "帐户余额不足";
//---------------------直接定义异常---------------------
/** 超出最大limit限制 */
public static final String MAX_LIMIT = "超出最大limit限制";
/** 分布式锁 */
public static final String DISTRIBUTED_LOCK = "分布式锁...";
/** 多行插入错误 */
public static final String INSERT_BATCH_ERROR = "执行多行插入命令失败，可能原因是：数据结构异常或无ID主键。请立即检查数据的一致性、唯一性。";
/** 单行删除错误 */
public static final String DELETE_ERROR = "执行单行删除命令失败，可能原因是：数据结构异常或无ID主键。请立即检查数据的一致性、唯一性。";
/** 批次删除错误 */
public static final String DELETE_BATCH_ERROR = "执行批次删除命令失败，可能原因是：数据结构异常或无ID主键。请立即检查数据的一致性、唯一性。";
/** 批次更新错误 */
public static final String UPDATE_BATCH_ERROR = "执行批次更新命令失败，可能原因是：数据结构异常或无ID主键。请立即检查数据的一致性、唯一性。";
//---------------------引用定义异常---------------------
/**
* 数据结构异常-不正确的结果
* @param expected 预期内容
* @param actual 实际内容
* @return 提示信息
*/
public static String dataStructure(Object expected, Object actual) {
return ResultEnum.DATA_STRUCTURE.getMsg() + " Incorrect result size: expected " + expected + ", actual " + actual;
}
}
|
0 | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/view/package-info.java | /**
* Restful风格的最外层对象
*
* @author ylyue
* @since 2019年10月13日
*/
package ai.yue.library.base.view; |
0 | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base | java-sources/ai/ylyue/yue-library-base/2.1.0/ai/yue/library/base/webenv/WebEnv.java | package ai.yue.library.base.webenv;
import com.alibaba.fastjson.JSONObject;
import ai.yue.library.base.util.ParamUtils;
import ai.yue.library.base.view.Result;
/**
* <b>Web环境实现</b>
* <p>如：WebMvc、WebFlux
*
* @author ylyue
* @since 2020年4月16日
*/
public interface WebEnv {
// Result
/**
* {@link Result#response()}
* @param result
*/
public void resultResponse(Result<?> result);
// ParamUtils
/**
* {@link ParamUtils#getParam()}
*
* @return JSON对象
*/
public JSONObject getParam();
/**
* {@link ParamUtils#getParam(Class)}
*
* @param <T> 泛型
* @param clazz 想要获取的参数类型
* @return 想要的对象实例
*/
public <T> T getParam(Class<T> clazz);
}
|
0 | java-sources/ai/ylyue/yue-library-base-crypto/2.1.0/ai/yue/library/base | java-sources/ai/ylyue/yue-library-base-crypto/2.1.0/ai/yue/library/base/crypto/package-info.java | /**
* base-crypto库基于 hutool-crypto 进行二次封装，提供单例加解密与yml配置。
*
* @author ylyue
* @since 2019年10月13日
*/
package ai.yue.library.base.crypto; |
0 | java-sources/ai/ylyue/yue-library-base-crypto/2.1.0/ai/yue/library/base/crypto | java-sources/ai/ylyue/yue-library-base-crypto/2.1.0/ai/yue/library/base/crypto/client/SecureCommon.java | package ai.yue.library.base.crypto.client;
import cn.hutool.core.codec.Base64;
import cn.hutool.core.util.URLUtil;
import cn.hutool.crypto.SecureUtil;
import cn.hutool.crypto.digest.HmacAlgorithm;
/**
* 加解密-常用业务
*
* @author ylyue
* @since 2019年8月9日
*/
public class SecureCommon {
/**
* 钉钉机器人签名
*
* @param dingtalkRobotWebhook 钉钉机器人Webhook
* @param dingtalkRobotSignSecret 钉钉机器人密钥，机器人安全设置页面，加签一栏下面显示的SEC开头的字符串
* @return 钉钉机器人签名后的Webhook
*/
public static String dingtalkRobotSign(String dingtalkRobotWebhook, String dingtalkRobotSignSecret) {
Long timestamp = System.currentTimeMillis();
String signContent = timestamp + "\n" + dingtalkRobotSignSecret;
byte[] signByte = SecureUtil.hmac(HmacAlgorithm.HmacSHA256, dingtalkRobotSignSecret).digest(signContent);
String sign = URLUtil.encode(Base64.encode(signByte));
return dingtalkRobotWebhook + "×tamp=" + timestamp + "&sign=" + sign;
}
}
|
0 | java-sources/ai/ylyue/yue-library-base-crypto/2.1.0/ai/yue/library/base/crypto | java-sources/ai/ylyue/yue-library-base-crypto/2.1.0/ai/yue/library/base/crypto/client/SecureSingleton.java | package ai.yue.library.base.crypto.client;
import com.alibaba.fastjson.JSONObject;
import ai.yue.library.base.util.URIUtils;
import cn.hutool.core.convert.ConvertException;
import cn.hutool.core.lang.Singleton;
import cn.hutool.crypto.asymmetric.KeyType;
import cn.hutool.crypto.asymmetric.RSA;
import cn.hutool.crypto.symmetric.AES;
/**
* 加解密单例
*
* @author ylyue
* @since 2019年8月9日
*/
public class SecureSingleton {
/**
* 获取自动配置单例 - AES
*
* @return AES 单例
*/
public static AES getAES() {
return Singleton.get(AES.class);
}
/**
* 获取自动配置单例 - RSA
*
* @return RSA 单例
*/
public static RSA getRSA() {
return Singleton.get(RSA.class);
}
/**
* 1. 将URI转义内容进行解码<br>
* 2. 将RSA分段加密内容，进行分段解密
*
* @param messageBody URI转义后的消息体
* @return 解密后的JSON
*/
public static JSONObject rsaUriDecodingAndDecrypt(String messageBody) {
String content = URIUtils.decode(messageBody);
String jsonString = getRSA().decryptStrFromBcd(content, KeyType.PrivateKey);
JSONObject json = null;
try {
json = JSONObject.parseObject(jsonString);
}catch (Exception e) {
throw new ConvertException(e.getMessage());
}
return json;
}
}
|
0 | java-sources/ai/ylyue/yue-library-base-crypto/2.1.0/ai/yue/library/base/crypto | java-sources/ai/ylyue/yue-library-base-crypto/2.1.0/ai/yue/library/base/crypto/client/package-info.java | /**
* 加解密单例
*
* @author ylyue
* @since 2019年10月13日
*/
package ai.yue.library.base.crypto.client; |
0 | java-sources/ai/ylyue/yue-library-base-crypto/2.1.0/ai/yue/library/base/crypto | java-sources/ai/ylyue/yue-library-base-crypto/2.1.0/ai/yue/library/base/crypto/config/BaseCryptoAutoConfig.java | package ai.yue.library.base.crypto.config;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Configuration;
import ai.yue.library.base.crypto.config.properties.CryptoProperties;
import ai.yue.library.base.util.StringUtils;
import cn.hutool.core.lang.Singleton;
import cn.hutool.crypto.SecureUtil;
import lombok.extern.slf4j.Slf4j;
/**
* base-crypto配置，提供自动配置项支持与增强
*
* @author ylyue
* @since 2018年6月11日
*/
@Slf4j
@Configuration
@EnableConfigurationProperties({ CryptoProperties.class })
public class BaseCryptoAutoConfig {
@Autowired
private void init(CryptoProperties cryptoProperties) {
// AES
String aes_keyt = cryptoProperties.getAesKeyt();
if (StringUtils.isNotEmpty(aes_keyt)) {
Singleton.put(SecureUtil.aes(aes_keyt.getBytes()));
log.info("【初始化工具-SecureSingleton】AES单例配置 ... 已初始化完毕。");
}
// RSA
String rsa_public_keyt = cryptoProperties.getRsaPublicKeyt();
String rsa_private_keyt = cryptoProperties.getRsaPrivateKeyt();
if (StringUtils.isNotEmpty(rsa_public_keyt) || StringUtils.isNotEmpty(rsa_private_keyt)) {
Singleton.put(SecureUtil.rsa(rsa_private_keyt, rsa_public_keyt));
log.info("【初始化工具-SecureSingleton】RSA单例配置 ... 已初始化完毕。");
}
}
}
|
0 | java-sources/ai/ylyue/yue-library-base-crypto/2.1.0/ai/yue/library/base/crypto | java-sources/ai/ylyue/yue-library-base-crypto/2.1.0/ai/yue/library/base/crypto/config/package-info.java | /**
* base-crypto配置包，提供自动配置项支持与增强
*
* @author ylyue
* @since 2019年10月13日
*/
package ai.yue.library.base.crypto.config; |
0 | java-sources/ai/ylyue/yue-library-base-crypto/2.1.0/ai/yue/library/base/crypto/config | java-sources/ai/ylyue/yue-library-base-crypto/2.1.0/ai/yue/library/base/crypto/config/properties/CryptoProperties.java | package ai.yue.library.base.crypto.config.properties;
import org.springframework.boot.context.properties.ConfigurationProperties;
import lombok.Data;
/**
* 加解密自动配置属性
*
* @author ylyue
* @since 2018年11月6日
*/
@Data
@ConfigurationProperties("yue.crypto")
public class CryptoProperties {
/**
* AES密钥
*/
private String aesKeyt;
/**
* RSA公钥
*/
private String rsaPublicKeyt;
/**
* RSA私钥
*/
private String rsaPrivateKeyt;
}
|
0 | java-sources/ai/ylyue/yue-library-base-crypto/2.1.0/ai/yue/library/base/crypto/config | java-sources/ai/ylyue/yue-library-base-crypto/2.1.0/ai/yue/library/base/crypto/config/properties/package-info.java | /**
* 加解密自动配置属性
*
* @author ylyue
* @since 2019年10月13日
*/
package ai.yue.library.base.crypto.config.properties; |
0 | java-sources/ai/ylyue/yue-library-data-es/j11.2.6.2/ai/yue/library/data | java-sources/ai/ylyue/yue-library-data-es/j11.2.6.2/ai/yue/library/data/es/package-info.java | /**
* data-es库简化es sql操作，提供默认配置项。支持更常见的安全配置化
*
* @author ylyue
* @since 2020年9月7日
*/
package ai.yue.library.data.es; |
0 | java-sources/ai/ylyue/yue-library-data-es/j11.2.6.2/ai/yue/library/data/es | java-sources/ai/ylyue/yue-library-data-es/j11.2.6.2/ai/yue/library/data/es/config/ElasticsearchAutoConfig.java | //package ai.yue.library.data.es.config;
//
//import org.springframework.context.annotation.Configuration;
//import org.springframework.context.annotation.Import;
//
//import ai.yue.library.data.es.config.rest.EsRestConfig;
//import ai.yue.library.data.es.config.sql.EsSqlConfig;
//
///**
// * ES配置
// *
// * @author ylyue
// * @since 2020年8月3日
// */
//@Configuration
//@Import({ EsRestConfig.class, EsSqlConfig.class })
//public class ElasticsearchAutoConfig {
//
//}
|
0 | java-sources/ai/ylyue/yue-library-data-es/j11.2.6.2/ai/yue/library/data/es | java-sources/ai/ylyue/yue-library-data-es/j11.2.6.2/ai/yue/library/data/es/config/package-info.java | /**
* es自动配置
*
* @author ylyue
* @since 2020年9月7日
*/
package ai.yue.library.data.es.config; |
0 | java-sources/ai/ylyue/yue-library-data-es/j11.2.6.2/ai/yue/library/data/es/config | java-sources/ai/ylyue/yue-library-data-es/j11.2.6.2/ai/yue/library/data/es/config/rest/EsRestConfig.java | package ai.yue.library.data.es.config.rest;
import ai.yue.library.base.config.net.http.SkipHostnameVerifier;
import ai.yue.library.base.config.net.http.SkipSslVerificationHttpRequestFactory;
import cn.hutool.core.util.ArrayUtil;
import cn.hutool.core.util.StrUtil;
import org.elasticsearch.client.RestHighLevelClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.data.elasticsearch.client.ClientConfiguration;
import org.springframework.data.elasticsearch.client.ClientConfiguration.MaybeSecureClientConfigurationBuilder;
import org.springframework.data.elasticsearch.client.RestClients;
import org.springframework.data.elasticsearch.config.AbstractElasticsearchConfiguration;
/**
* ES REST 配置
*
* @author ylyue
* @since 2020年8月3日
*/
@Configuration
@EnableConfigurationProperties(EsRestProperties.class)
@ConditionalOnProperty(prefix = "yue.es.rest", name = "enabled", havingValue = "true")
public class EsRestConfig extends AbstractElasticsearchConfiguration {
@Autowired
private EsRestProperties esRestProperties;
@Bean
@Primary
@Override
public RestHighLevelClient elasticsearchClient() {
MaybeSecureClientConfigurationBuilder clientConfigurationBuilder = ClientConfiguration.builder()
.connectedTo(ArrayUtil.toArray(esRestProperties.getHostAndPort(), String.class));
if (esRestProperties.isUseSsl()) {
boolean trustSelfSigned = esRestProperties.isTrustSelfSigned();
boolean hostnameVerification = esRestProperties.isHostnameVerification();
if (trustSelfSigned && !hostnameVerification) {
clientConfigurationBuilder.usingSsl(SkipSslVerificationHttpRequestFactory.getSSLContext(), new SkipHostnameVerifier());
} else if (trustSelfSigned) {
clientConfigurationBuilder.usingSsl(SkipSslVerificationHttpRequestFactory.getSSLContext());
} else {
clientConfigurationBuilder.usingSsl();
}
}
String username = esRestProperties.getUsername();
String password = esRestProperties.getPassword();
if (StrUtil.isNotEmpty(username) && StrUtil.isNotEmpty(password)) {
clientConfigurationBuilder.withBasicAuth(username, password);
}
clientConfigurationBuilder.withConnectTimeout(esRestProperties.getConnectionTimeout());
clientConfigurationBuilder.withSocketTimeout(esRestProperties.getReadTimeout());
return RestClients.create(clientConfigurationBuilder.build()).rest();
}
}
|
0 | java-sources/ai/ylyue/yue-library-data-es/j11.2.6.2/ai/yue/library/data/es/config | java-sources/ai/ylyue/yue-library-data-es/j11.2.6.2/ai/yue/library/data/es/config/rest/EsRestProperties.java | package ai.yue.library.data.es.config.rest;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import java.time.Duration;
import java.util.List;
/**
* ES REST 可配置属性定义
*
* @author ylyue
* @since 2020年8月28日
*/
@Data
@ConfigurationProperties(EsRestProperties.PREFIX)
public class EsRestProperties {
/**
* Prefix of {@link EsRestProperties}.
*/
public static final String PREFIX = "yue.es.rest";
/**
* 是否启用 <code style="color:red">Elasticsearch RestHighLevelClient</code> 自动配置
* <p>默认：false
*/
private boolean enabled = false;
/**
* localhost:80
*/
private List<String> hostAndPort;
/**
* 开启HTTPS协议进行通信
* <p>默认：false
*/
private boolean useSsl = false;
/**
* 信任自签证书
* <p>默认：true
*/
private boolean trustSelfSigned = true;
/**
* hostname验证
* <p>默认：false
*/
private boolean hostnameVerification = false;
private String username;
private String password;
/**
* 连接超时
* <p>默认：3s（3秒），支持携带时间单位</p>
*/
private Duration connectionTimeout = Duration.ofSeconds(3);
/**
* 读取超时
* <p>默认：30s（30秒），支持携带时间单位</p>
*/
private Duration readTimeout = Duration.ofSeconds(30);
}
|
0 | java-sources/ai/ylyue/yue-library-data-es/j11.2.6.2/ai/yue/library/data/es/config | java-sources/ai/ylyue/yue-library-data-es/j11.2.6.2/ai/yue/library/data/es/config/rest/package-info.java | /**
* ES REST 客户端配置
*
* @author ylyue
* @since 2020年9月8日
*/
package ai.yue.library.data.es.config.rest; |
0 | java-sources/ai/ylyue/yue-library-data-es/j11.2.6.2/ai/yue/library/data/es/config | java-sources/ai/ylyue/yue-library-data-es/j11.2.6.2/ai/yue/library/data/es/config/sql/EsSqlConfig.java | //package ai.yue.library.data.es.config.sql;
//
//import java.sql.SQLException;
//import java.util.Properties;
//
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
//import org.springframework.boot.context.properties.EnableConfigurationProperties;
//import org.springframework.context.annotation.Bean;
//import org.springframework.context.annotation.Configuration;
//
//import com.amazon.opendistroforelasticsearch.jdbc.ElasticsearchDataSource;
//import com.amazon.opendistroforelasticsearch.jdbc.config.HostnameVerificationConnectionProperty;
//import com.amazon.opendistroforelasticsearch.jdbc.config.PasswordConnectionProperty;
//import com.amazon.opendistroforelasticsearch.jdbc.config.TrustSelfSignedConnectionProperty;
//import com.amazon.opendistroforelasticsearch.jdbc.config.UserConnectionProperty;
//
//import ai.yue.library.data.jdbc.client.Db;
//import cn.hutool.core.util.StrUtil;
//
///**
// * ES SQL 配置
// *
// * @author ylyue
// * @since 2020年8月3日
// */
//@Configuration
//@EnableConfigurationProperties(EsSqlProperties.class)
//@ConditionalOnProperty(prefix = "yue.es.sql", name = "enabled", havingValue = "true")
//public class EsSqlConfig {
//
// @Autowired
// EsSqlProperties esSqlProperties;
//
// @Bean
// public Db esDb() throws SQLException {
// String url = "jdbc:elasticsearch://" + esSqlProperties.getUrl();
//
// ElasticsearchDataSource ds = new ElasticsearchDataSource();
// ds.setUrl(url);
//
// Properties properties = new Properties();
// properties.setProperty(TrustSelfSignedConnectionProperty.KEY, String.valueOf(esSqlProperties.isTrustSelfSigned()));
// properties.setProperty(HostnameVerificationConnectionProperty.KEY, String.valueOf(esSqlProperties.isHostnameVerification()));
// String username = esSqlProperties.getUsername();
// String password = esSqlProperties.getPassword();
// if (StrUtil.isAllNotEmpty(username, password)) {
// properties.setProperty(UserConnectionProperty.KEY, username);
// properties.setProperty(PasswordConnectionProperty.KEY, password);
// }
// ds.setProperties(properties);
//
// return new Db(ds);
// }
//
//}
|
0 | java-sources/ai/ylyue/yue-library-data-es/j11.2.6.2/ai/yue/library/data/es/config | java-sources/ai/ylyue/yue-library-data-es/j11.2.6.2/ai/yue/library/data/es/config/sql/EsSqlProperties.java | //package ai.yue.library.data.es.config.sql;
//
//import org.springframework.boot.context.properties.ConfigurationProperties;
//
//import lombok.Data;
//
///**
// * ES SQL 可配置属性定义
// *
// * @author ylyue
// * @since 2020年8月28日
// */
//@Data
//@ConfigurationProperties(EsSqlProperties.PREFIX)
//public class EsSqlProperties {
//
// /**
// * Prefix of {@link EsSqlProperties}.
// */
// public static final String PREFIX = "yue.es.sql";
//
// /**
// * 是否启用 <code style="color:red">Elasticsearch Db</code> 自动配置
// * <p>提供Bean esDb
// * <p>默认：false
// */
// private boolean enabled = false;
// /**
// * https://localhost:80
// */
// private String url;
// /**
// * 信任自签证书
// */
// private boolean trustSelfSigned = true;
// /**
// * hostname验证
// */
// private boolean hostnameVerification = false;
// private String username;
// private String password;
//
//}
|
0 | java-sources/ai/ylyue/yue-library-data-es/j11.2.6.2/ai/yue/library/data/es/config | java-sources/ai/ylyue/yue-library-data-es/j11.2.6.2/ai/yue/library/data/es/config/sql/package-info.java | /**
* ES SQL Db配置
*
* @author ylyue
* @since 2020年9月8日
*/
package ai.yue.library.data.es.config.sql; |
0 | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc/package-info.java | /**
* data-jdbc库基于SpringJDBC进行二次封装，拥有着强大性能的同时又不失简单、灵活
*
* @author ylyue
* @since 2019年10月14日
*/
package ai.yue.library.data.jdbc; |
0 | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc/client/Db.java | package ai.yue.library.data.jdbc.client;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
import ai.yue.library.data.jdbc.client.dialect.Dialect;
/**
* <h2>SQL优化型数据库操作</h2>
* Created by sunJinChuan on 2016/6/6
* @since 0.0.1
*/
public class Db extends DbInsert {
public Db(JdbcTemplate jdbcTemplate, NamedParameterJdbcTemplate namedParameterJdbcTemplate, Dialect dialect) {
super.jdbcTemplate = jdbcTemplate;
super.namedParameterJdbcTemplate = namedParameterJdbcTemplate;
super.dialect = dialect;
}
}
|
0 | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc/client/DbBase.java | package ai.yue.library.data.jdbc.client;
import java.util.Collection;
import java.util.List;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
import com.alibaba.fastjson.JSONObject;
import ai.yue.library.base.constant.FieldNamingStrategyEnum;
import ai.yue.library.base.exception.DbException;
import ai.yue.library.base.util.MapUtils;
import ai.yue.library.base.util.StringUtils;
import ai.yue.library.base.view.ResultPrompt;
import ai.yue.library.data.jdbc.client.dialect.Dialect;
import ai.yue.library.data.jdbc.constant.DbConstant;
import cn.hutool.core.util.ArrayUtil;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
/**
* <h2>SQL优化型数据库操作</h2>
* Created by sunJinChuan on 2016/6/6
* @since 0.0.1
*/
@Slf4j
@Data
public class DbBase {
// 必须初始化变量
protected JdbcTemplate jdbcTemplate;
protected NamedParameterJdbcTemplate namedParameterJdbcTemplate;
protected Dialect dialect;
// 默认变量
/** 业务唯一键 */
String businessUk = "key";
/**
* 数据库字段命名策略
* <p>默认：SNAKE_CASE
*/
FieldNamingStrategyEnum databaseFieldNamingStrategy = FieldNamingStrategyEnum.SNAKE_CASE;
/**
* 数据库字段命名策略识别-是否开启
* <p>默认：true
*/
boolean databaseFieldNamingStrategyRecognitionEnabled = true;
/** 启用删除查询过滤 */
boolean enableDeleteQueryFilter = false;
// 方法
/**
* 是否有数据
*
* @param dataSize 数据大小
* @return 是否 <b><=</b> 0
*/
public boolean isDataSize(long dataSize) {
if (dataSize <= 0) {
return false;
}
return true;
}
/**
* 判断更新所影响的行数是否 <b>等于</b> 预期值
* <p>若不是预期值，同时 updateRowsNumber > 0 那么将会抛出一个 {@linkplain DbException}
*
* @param updateRowsNumber 更新所影响的行数
* @param expectedValue 预期值
* @return 是否 <b>等于</b> 预期值
*/
public boolean isUpdateAndExpectedEqual(long updateRowsNumber, int expectedValue) {
if (updateRowsNumber == expectedValue) {
return true;
}
if (updateRowsNumber == 0) {
return false;
}
String msg = ResultPrompt.dataStructure(expectedValue, updateRowsNumber);
throw new DbException(msg);
}
/**
* 判断更新所影响的行数是否 <b>大于等于</b> 预期值
* <p>
* 若不是预期结果，同时 updateRowsNumber < expectedValue 那么将会抛出一个{@linkplain DbException}
* @param updateRowsNumber 更新所影响的行数
* @param expectedValue 预期值
* @return 是否 <b>大于等于</b> 预期值
*/
public boolean isUpdateAndExpectedGreaterThanEqual(long updateRowsNumber, int expectedValue) {
if (updateRowsNumber >= expectedValue) {
return true;
}
if (updateRowsNumber == 0) {
return false;
}
String msg = ResultPrompt.dataStructure(">= " + expectedValue, updateRowsNumber);
throw new DbException(msg);
}
/**
* 判断更新所影响的行数是否 <b>等于</b> 预期值
* <p>
* 若不是预期值，那么将会抛出一个{@linkplain DbException}
* @param updateRowsNumber 更新所影响的行数
* @param expectedValue 预期值
*/
public void updateAndExpectedEqual(long updateRowsNumber, int expectedValue) {
if (updateRowsNumber != expectedValue) {
String msg = ResultPrompt.dataStructure(expectedValue, updateRowsNumber);
throw new DbException(msg);
}
}
/**
* 判断更新所影响的行数是否 <b>大于等于</b> 预期值
* <p>
* 若不是预期结果，那么将会抛出一个{@linkplain DbException}
* @param updateRowsNumber 更新所影响的行数
* @param expectedValue 预期值
*/
public void updateAndExpectedGreaterThanEqual(long updateRowsNumber, int expectedValue) {
if (!(updateRowsNumber >= expectedValue)) {
String msg = ResultPrompt.dataStructure(">= " + expectedValue, updateRowsNumber);
throw new DbException(msg);
}
}
/**
* 确认批量更新每组参数所影响的行数，是否 <b>全部都等于</b> 同一个预期值
* <p>
* 若不是预期值，那么将会抛出一个{@linkplain DbException}
* @param updateRowsNumberArray 每组参数更新所影响的行数数组
* @param expectedValue 预期值
*/
public void updateBatchAndExpectedEqual(int[] updateRowsNumberArray, int expectedValue) {
for (int updateRowsNumber : updateRowsNumberArray) {
if (updateRowsNumber != expectedValue) {
String msg = ResultPrompt.UPDATE_BATCH_ERROR;
msg += ResultPrompt.dataStructure(expectedValue, updateRowsNumber);
throw new DbException(msg);
}
}
}
/**
* 同 {@linkplain DbQuery#queryForJson(String, JSONObject)} 的安全查询结果获取
* @param list {@linkplain DbQuery#queryForList(String, JSONObject)} 查询结果
* @return JSON数据
*/
public JSONObject resultToJson(List<JSONObject> list) {
int size = list.size();
int expectedValue = 1;
if (size != expectedValue) {
if (size > expectedValue) {
String msg = ResultPrompt.dataStructure(expectedValue, size);
log.warn(msg);
}
return null;
}
return list.get(0);
}
/**
* 同 {@linkplain DbQuery#queryForObject(String, JSONObject, Class)} 的安全查询结果获取
* @param <T> 泛型
* @param list {@linkplain DbQuery#queryForList(String, JSONObject, Class)} 查询结果
* @return POJO对象
*/
public <T> T resultToObject(List<T> list) {
int size = list.size();
int expectedValue = 1;
if (size != expectedValue) {
if (size > expectedValue) {
String msg = ResultPrompt.dataStructure(expectedValue, size);
log.warn(msg);
}
return null;
}
return list.get(0);
}
// WHERE SQL
private synchronized void paramToWhereSql(StringBuffer whereSql, final JSONObject paramJson, final String condition) {
whereSql.append(" AND ");
whereSql.append(dialect.getWrapper().wrap(condition));
var value = paramJson.get(condition);
if (null == value) {
whereSql.append(" IS :");
whereSql.append(condition);
} else if (value instanceof Collection) {
whereSql.append(" IN (:");
whereSql.append(condition);
whereSql.append(") ");
} else {
whereSql.append(" = :");
whereSql.append(condition);
}
}
/**
* <b>绝对条件查询参数whereSql化</b>
* <p>
* <i>已对 NULL 值进行特殊处理（IS NULL）</i><br><br>
* <i>已对 {@linkplain List} 类型值进行特殊处理（IN (?, ?)）</i><br><br>
*
* <b>结果示例：</b><br>
* <blockquote>
* <pre>
* <code>WHERE 1 = 1</code><br>
* <code>AND</code><br>
* <code>param1 = :param1</code><br>
* <code>AND</code><br>
* <code>param2 IS NULL :param2</code><br>
* <code>AND</code><br>
* <code>param3 IN :param3</code><br>
* <code>AND ...</code>
* </pre>
* </blockquote>
*
* @param paramJson 参数
* @param conditions where条件（对应paramJson key）
* @return whereSql
*/
protected String paramToWhereSql(JSONObject paramJson, String... conditions) {
StringBuffer whereSql = new StringBuffer();
whereSql.append(" WHERE 1 = 1 ");
if (ArrayUtil.isNotEmpty(conditions)) {
for (String condition : conditions) {
paramToWhereSql(whereSql, paramJson, condition);
}
}
return whereSql.toString();
}
/**
* <b>绝对条件查询参数whereSql化</b>
* <p>
* <i>已对 NULL 值进行特殊处理（IS NULL）</i><br><br>
* <i>已对 {@linkplain List} 类型值进行特殊处理（IN (?, ?)）</i><br><br>
*
* <b>结果示例：</b><br>
* <blockquote>
* <pre>
* <code>WHERE 1 = 1</code><br>
* <code>AND</code><br>
* <code>param1 = :param1</code><br>
* <code>AND</code><br>
* <code>param2 IS NULL :param2</code><br>
* <code>AND</code><br>
* <code>param3 IN :param3</code><br>
* <code>AND ...</code>
* </pre>
* </blockquote>
*
* @param paramJson 参数
* @return whereSql
*/
public String paramToWhereSql(JSONObject paramJson) {
StringBuffer whereSql = new StringBuffer();
if (enableDeleteQueryFilter) {
whereSql.append(" WHERE ").append(DbConstant.FIELD_DEFINITION_DELETE_TIME)
.append(" = ").append(DbConstant.FIELD_DEFAULT_VALUE_DELETE_TIME);
} else {
whereSql.append(" WHERE 1 = 1 ");
}
paramJson.keySet().forEach(condition -> {
paramToWhereSql(whereSql, paramJson, condition);
});
return whereSql.toString();
}
// ParamValidate
/**
* 参数验证
* @param tableName 表名
*/
protected void paramValidate(String tableName) {
if (StringUtils.isEmpty(tableName)) {
throw new DbException("表名不能为空");
}
}
/**
* 参数验证
* @param tableName 表名
* @param whereSql 条件sql
*/
protected void paramValidate(String tableName, String whereSql) {
if (StringUtils.isEmpty(tableName)) {
throw new DbException("表名不能为空");
}
if (StringUtils.isEmpty(tableName)) {
throw new DbException("whereSql不能为空");
}
}
/**
* 参数验证
*
* @param tableName 表名
* @param id 主键ID
*/
protected void paramValidate(String tableName, Long id) {
if (StringUtils.isEmpty(tableName)) {
throw new DbException("表名不能为空");
}
if (null == id) {
throw new DbException("参数id不能为空");
}
}
/**
* 参数验证
*
* @param tableName 表名
* @param columnNames 列名
*/
protected void paramValidate(String tableName, String... columnNames) {
if (StringUtils.isEmpty(tableName)) {
throw new DbException("表名不能为空");
}
if (StringUtils.isEmptys(columnNames)) {
throw new DbException("条件列名不能为空");
}
}
/**
* 参数验证
* @param tableName 表名
* @param id 主键ID
* @param fieldName 字段名称
*/
protected void paramValidate(String tableName, Long id, String[] fieldName) {
if (StringUtils.isEmpty(tableName)) {
throw new DbException("表名不能为空");
}
if (null == id) {
throw new DbException("参数id不能为空");
}
if (StringUtils.isEmptys(fieldName)) {
throw new DbException("fieldName不能为空");
}
}
/**
* 参数验证
* @param tableName 表名
* @param paramJson 参数
*/
protected void paramValidate(String tableName, JSONObject paramJson) {
if (StringUtils.isEmpty(tableName)) {
throw new DbException("表名不能为空");
}
if (MapUtils.isEmpty(paramJson)) {
throw new DbException("参数不能为空");
}
}
/**
* 参数验证
* @param tableName 表名
* @param paramJsons 参数数组
*/
protected void paramValidate(String tableName, JSONObject[] paramJsons) {
if (StringUtils.isEmpty(tableName)) {
throw new DbException("表名不能为空");
}
if (MapUtils.isEmptys(paramJsons)) {
throw new DbException("参数不能为空");
}
}
/**
* 参数验证
* @param tableName 表名
* @param paramJson 参数
* @param conditions 条件（对应paramJson key）
*/
protected void paramValidate(String tableName, JSONObject paramJson, String[] conditions) {
if (StringUtils.isEmpty(tableName)) {
throw new DbException("表名不能为空");
}
if (MapUtils.isEmpty(paramJson)) {
throw new DbException("参数不能为空");
}
if (StringUtils.isEmptys(conditions) || !MapUtils.isKeys(paramJson, conditions)) {
throw new DbException("更新条件不能为空");
}
}
}
|
0 | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc/client/DbDelete.java | package ai.yue.library.data.jdbc.client;
import java.util.Map;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
import org.springframework.transaction.annotation.Transactional;
import com.alibaba.fastjson.JSONObject;
import ai.yue.library.base.exception.DbException;
import ai.yue.library.base.util.MapUtils;
import ai.yue.library.base.view.ResultPrompt;
import ai.yue.library.data.jdbc.constant.DbConstant;
import ai.yue.library.data.jdbc.constant.DbUpdateEnum;
/**
* <h2>SQL优化型数据库操作</h2>
* Created by sunJinChuan on 2016/6/6
* @since 0.0.1
*/
class DbDelete extends DbUpdate {
// Delete
private String deleteSqlBuild(String tableName, JSONObject paramJson) {
// 1. 参数验证
paramValidate(tableName, paramJson);
// 2. 生成SQL
StringBuffer sql = new StringBuffer();
sql.append("DELETE FROM ");
sql.append(dialect.getWrapper().wrap(tableName));
sql.append(paramToWhereSql(paramJson));
// 3. 返回结果
return sql.toString();
}
/**
* 删除
*
* @param tableName 表名
* @param id 主键id
*/
@Transactional
public void delete(String tableName, Long id) {
// 1. 参数验证
paramValidate(tableName, id);
// 2. 获得SQL
JSONObject paramJson = new JSONObject();
paramJson.put(DbConstant.PRIMARY_KEY, id);
String sql = deleteSqlBuild(tableName, paramJson);
// 3. 执行删除
int updateRowsNumber = namedParameterJdbcTemplate.update(sql, paramJson);
// 4. 确认影响的数据条数
if (updateRowsNumber != 1) {
throw new DbException(ResultPrompt.DELETE_ERROR);
}
}
/**
* 删除-安全的
* <p>数据删除前会先进行条数确认
*
* @param tableName 表名
* @param id 主键id
*/
public void deleteSafe(String tableName, Long id) {
// 1. 确认数据
JSONObject data = getById(tableName, id);
if (data == null || data.isEmpty()) {
throw new DbException("执行单行删除命令失败，数据结构异常，可能原因是：数据不存在或存在多条数据", true);
}
// 2. 删除数据
delete(tableName, id);
}
/**
* 删除
*
* @param tableName 表名
* @param paramJson 条件
* @return 删除所影响的行数
*/
@Transactional
public long delete(String tableName, JSONObject paramJson) {
String sql = deleteSqlBuild(tableName, paramJson);
return (long) namedParameterJdbcTemplate.update(sql, paramJson);
}
/**
* 删除-批量
* <p>一组条件对应一条数据，并且每组条件都采用相同的key
*
* @param tableName 表名
* @param paramJsons 条件数组
*/
@Transactional
public void deleteBatch(String tableName, JSONObject[] paramJsons) {
// 1. 获得SQL
String sql = deleteSqlBuild(tableName, paramJsons[0]);
// 2. 执行
int[] updateRowsNumberArray = namedParameterJdbcTemplate.batchUpdate(sql, paramJsons);
// 3. 确认影响行数
for (int updateRowsNumber : updateRowsNumberArray) {
if (updateRowsNumber > 1) {
throw new DbException(ResultPrompt.DELETE_BATCH_ERROR);
}
}
}
/**
* 同 {@linkplain NamedParameterJdbcTemplate#batchUpdate(String, Map[])}<br>
* <p>指定SQL语句以创建预编译执行SQL和绑定删除参数
* <p>示例：<code>DELETE FROM table WHERE id = :id</code><br>
* @param sql 要执行的删除SQL
* @param paramJsons 删除所用到的条件数组
* @return 一个数组，其中包含受批处理中每个更新影响的行数
*/
@Transactional
public int[] deleteBatch2(String sql, JSONObject[] paramJsons) {
return namedParameterJdbcTemplate.batchUpdate(sql, paramJsons);
}
// Delete Logic
private String deleteLogicSqlBuild(String tableName, JSONObject paramJson) {
// 1. 参数验证
paramValidate(tableName, paramJson);
// 2. 生成SQL
String[] conditions = new String[paramJson.size()];
conditions = MapUtils.keyList(paramJson).toArray(conditions);
paramJson.put(DbConstant.FIELD_DEFINITION_DELETE_TIME, System.currentTimeMillis());
// 3. 返回结果
return dialect.updateSqlBuild(tableName, paramJson, conditions, DbUpdateEnum.NORMAL);
}
/**
* 删除-逻辑的
* <p>数据非真实删除，而是更改 {@value DbConstant#FIELD_DEFINITION_DELETE_TIME} 字段值为 true，代表数据已删除
*
* @param tableName 表名
* @param id 主键id
*/
@Transactional
public void deleteLogic(String tableName, Long id) {
// 1. 参数验证
paramValidate(tableName, id);
// 2. 获得SQL
JSONObject paramJson = new JSONObject();
paramJson.put(DbConstant.PRIMARY_KEY, id);
String sql = deleteLogicSqlBuild(tableName, paramJson);
// 3. 执行删除
int updateRowsNumber = namedParameterJdbcTemplate.update(sql, paramJson);
// 4. 确认影响的数据条数
if (updateRowsNumber != 1) {
throw new DbException(ResultPrompt.DELETE_ERROR);
}
}
/**
* 删除-逻辑的
* <p>数据非真实删除，而是更改 {@value DbConstant#FIELD_DEFINITION_DELETE_TIME} 字段值为 true，代表数据已删除
*
* @param tableName 表名
* @param paramJson 条件
* @return 删除所影响的行数
*/
@Transactional
public long deleteLogic(String tableName, JSONObject paramJson) {
String sql = deleteLogicSqlBuild(tableName, paramJson);
return (long) namedParameterJdbcTemplate.update(sql, paramJson);
}
/**
* 删除-批量-逻辑的
* <p>数据非真实删除，而是更改 {@value DbConstant#FIELD_DEFINITION_DELETE_TIME} 字段值为 true，代表数据已删除
* <p>一组条件对应一条数据，并且每组条件都采用相同的key
*
* @param tableName 表名
* @param paramJsons 条件数组
*/
@Transactional
public void deleteBatchLogic(String tableName, JSONObject[] paramJsons) {
// 1. 获得SQL
String sql = deleteLogicSqlBuild(tableName, paramJsons[0]);
// 2. 执行
int[] updateRowsNumberArray = namedParameterJdbcTemplate.batchUpdate(sql, paramJsons);
// 3. 确认影响行数
for (int updateRowsNumber : updateRowsNumberArray) {
if (updateRowsNumber > 1) {
throw new DbException(ResultPrompt.DELETE_BATCH_ERROR);
}
}
}
}
|
0 | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc/client/DbInsert.java | package ai.yue.library.data.jdbc.client;
import java.util.List;
import org.springframework.jdbc.core.simple.SimpleJdbcInsert;
import org.springframework.lang.Nullable;
import org.springframework.transaction.annotation.Transactional;
import com.alibaba.fastjson.JSONObject;
import ai.yue.library.base.exception.DbException;
import ai.yue.library.base.util.ListUtils;
import ai.yue.library.base.util.MapUtils;
import ai.yue.library.base.view.ResultPrompt;
import ai.yue.library.data.jdbc.constant.DbConstant;
import ai.yue.library.data.jdbc.constant.DbUpdateEnum;
/**
* <h2>SQL优化型数据库操作</h2>
* Created by sunJinChuan on 2016/6/6
* @since 0.0.1
*/
class DbInsert extends DbDelete {
// Insert
/**
* 插入源初始化
*
* @param tableName
* @param paramJson
* @return
*/
private SimpleJdbcInsert insertInit(String tableName, JSONObject paramJson) {
// 1. 参数验证
paramValidate(tableName, paramJson);
// 2. 创建JdbcInsert实例
SimpleJdbcInsert simpleJdbcInsert = new SimpleJdbcInsert(jdbcTemplate);
simpleJdbcInsert.setTableName(tableName); // 设置表名
simpleJdbcInsert.setGeneratedKeyName(DbConstant.PRIMARY_KEY); // 设置主键名，添加成功后返回主键的值
// 3. 设置ColumnNames
List<String> keys = MapUtils.keyList(paramJson);
List<String> columnNames = ListUtils.toList(getMetaData(tableName).getColumnNames());
List<String> insertColumn = ListUtils.keepSameValue(keys, (List<String>) dialect.getWrapper().wrap(columnNames));
simpleJdbcInsert.setColumnNames(insertColumn);
// 4. 返回结果
return simpleJdbcInsert;
}
/**
* 向表中插入一条数据，主键默认为id时使用。
*
* @param tableName 表名
* @param paramJson 参数
* @return 返回主键值
*/
@Transactional
public Long insert(String tableName, JSONObject paramJson) {
// 1. 移除空对象
MapUtils.removeEmpty(paramJson);
// 2. 插入源初始化
tableName = dialect.getWrapper().wrap(tableName);
paramJson = dialect.getWrapper().wrap(paramJson);
SimpleJdbcInsert simpleJdbcInsert = insertInit(tableName, paramJson);
// 3. 执行
return simpleJdbcInsert.executeAndReturnKey(paramJson).longValue();
}
/**
* 向表中插入一条数据
*
* @param tableName 表名
* @param paramJson 参数
*/
@Transactional
public void insertNotReturn(String tableName, JSONObject paramJson) {
// 1. 移除空对象
MapUtils.removeEmpty(paramJson);
// 2. 插入源初始化
tableName = dialect.getWrapper().wrap(tableName);
paramJson = dialect.getWrapper().wrap(paramJson);
SimpleJdbcInsert simpleJdbcInsert = insertInit(tableName, paramJson);
// 3. 执行
simpleJdbcInsert.execute(paramJson);
}
/**
* <h1>向表中插入一条数据，并自动递增 <i>sort_idx</i></h1>
*
* <blockquote>
* <b>使用条件：</b>
* <pre>1. id 默认为主键</pre>
* <pre>2. sort_idx 默认为排序字段，类型为 int unsigned 。DDL示例：<code>`sort_idx` tinyint(2) UNSIGNED NOT NULL COMMENT '排序-索引'</code></pre>
* </blockquote>
*
* @param tableName 表名
* @param paramJson 插入数据
* @param uniqueKeys 同sort_idx字段组合的唯一约束keys（表中不建议建立sort_idx字段的唯一约束，但可以建立普通索引，以便于提高查询性能），<b>可选参数</b>
* @return 返回主键值
*/
@Transactional
public Long insertWithSortIdxAutoIncrement(String tableName, JSONObject paramJson, @Nullable String... uniqueKeys) {
// 1. 参数验证
paramValidate(tableName, paramJson);
tableName = dialect.getWrapper().wrap(tableName);
String sortFieldName = "sort_idx";
String sortFieldNameWrapped = dialect.getWrapper().wrap(sortFieldName);
// 2. 组装最大sort_idx值查询SQL
int sort_idx = 1;
StringBuffer sql = new StringBuffer();
sql.append("SELECT " + sortFieldNameWrapped + " FROM ");
sql.append(tableName);
String whereSql = paramToWhereSql(paramJson, uniqueKeys);
sql.append(whereSql);
sql.append(" ORDER BY " + sortFieldNameWrapped + " DESC LIMIT 1");
// 3. 查询最大sort_idx值
paramJson = dialect.getWrapper().wrap(paramJson);
JSONObject result = queryForJson(sql.toString(), paramJson);
if (result != null) {
sort_idx = result.getInteger(sortFieldName) + 1;
}
// 4. put sort_idx值
paramJson.put(sortFieldNameWrapped, sort_idx);
// 5. 执行
return insert(tableName, paramJson);
}
/**
* 向表中批量插入数据，主键默认为id时使用。
*
* @param tableName 表名
* @param paramJsons 参数
*/
@Transactional
public void insertBatch(String tableName, JSONObject[] paramJsons) {
// 1. 参数验证
paramValidate(tableName, paramJsons);
// 2. 插入源初始化
tableName = dialect.getWrapper().wrap(tableName);
paramJsons = dialect.getWrapper().wrap(paramJsons);
SimpleJdbcInsert simpleJdbcInsert = insertInit(tableName, paramJsons[0]);
// 3. 执行
int updateRowsNumber = simpleJdbcInsert.executeBatch(paramJsons).length;
// 4. 确认插入条数
if (updateRowsNumber != paramJsons.length) {
throw new DbException(ResultPrompt.INSERT_BATCH_ERROR);
}
}
// InsertOrUpdate
/**
* <h2>插入或更新</h2>
* <i>表中必须存在数据唯一性约束</i>
* <p>更新触发条件：此数据若存在唯一性约束则更新，否则便执行插入数据
* <p><b>MySQL执行示例：</b><br>
* <code>INSERT INTO table (param1, param2, ...)</code><br>
* <code>VALUES</code><br>
* <code>(:param1, :param2, ...)</code><br>
* <code>ON DUPLICATE KEY UPDATE</code><br>
* <code>condition = condition + :condition, ...</code>
* @param tableName 表名
* @param paramJson 插入或更新所用到的参数
* @param conditions 更新条件（对应paramJson内的key值）
* @param dBUpdateEnum 更新类型 {@linkplain DbUpdateEnum}
* @return 受影响的行数
*/
@Transactional
public Long insertOrUpdate(String tableName, JSONObject paramJson, String[] conditions, DbUpdateEnum dBUpdateEnum) {
return dialect.insertOrUpdate(tableName, paramJson, conditions, dBUpdateEnum);
}
}
|
0 | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc/client/DbQuery.java | package ai.yue.library.data.jdbc.client;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
import org.springframework.jdbc.support.rowset.SqlRowSet;
import org.springframework.jdbc.support.rowset.SqlRowSetMetaData;
import org.springframework.lang.Nullable;
import com.alibaba.fastjson.JSONObject;
import ai.yue.library.base.exception.DbException;
import ai.yue.library.base.util.ListUtils;
import ai.yue.library.base.util.MapUtils;
import ai.yue.library.base.util.StringUtils;
import ai.yue.library.data.jdbc.constant.DbConstant;
import ai.yue.library.data.jdbc.constant.DbSortEnum;
import ai.yue.library.data.jdbc.dto.PageDTO;
import ai.yue.library.data.jdbc.ipo.Page;
import ai.yue.library.data.jdbc.ipo.PageIPO;
import ai.yue.library.data.jdbc.support.BeanPropertyRowMapper;
import ai.yue.library.data.jdbc.vo.PageBeforeAndAfterVO;
import ai.yue.library.data.jdbc.vo.PageTVO;
import ai.yue.library.data.jdbc.vo.PageVO;
import lombok.extern.slf4j.Slf4j;
/**
* <h2>SQL优化型数据库操作</h2>
* Created by sunJinChuan on 2016/6/6
* @since 0.0.1
*/
@Slf4j
class DbQuery extends DbBase {
// queryFor
/**
* {@linkplain NamedParameterJdbcTemplate#queryForMap(String, Map)} 的安全查询方式<br><br>
* 指定SQL语句以创建预编译执行SQL和绑定查询参数，结果映射应该是一个单行查询否则结果为null。
* @param sql 要执行的SQL查询
* @param paramJson 要绑定到查询的参数映射
* @return JSON对象
*/
public JSONObject queryForJson(String sql, JSONObject paramJson) {
var list = queryForList(sql, paramJson);
return resultToJson(list);
}
/**
* 同 {@linkplain NamedParameterJdbcTemplate#queryForObject(String, Map, Class)}
* <p>指定SQL语句以创建预编译执行SQL和绑定查询参数，结果映射应该是一个单行查询否则结果为null。
*
* @param <T> 泛型
* @param sql 要执行的SQL查询
* @param paramJson 要绑定到查询的参数映射
* @param mappedClass 映射类
* @return POJO对象
*/
public <T> T queryForObject(String sql, JSONObject paramJson, Class<T> mappedClass) {
try {
return namedParameterJdbcTemplate.queryForObject(sql, paramJson, BeanPropertyRowMapper.newInstance(mappedClass));
}catch (Exception e) {
log.warn(e.getMessage());
return null;
}
}
/**
* 同 {@linkplain NamedParameterJdbcTemplate#queryForRowSet(String, Map)}
* <p>指定SQL语句以创建预编译执行SQL和绑定查询参数，结果集可用于方便的获取各种类型的数据。
*
* @param sql 要执行的SQL查询
* @param paramJson 要绑定到查询的参数映射
* @return 结果集可用于方便的获取各种类型的数据
*/
public SqlRowSet queryForRowSet(String sql, JSONObject paramJson) {
return namedParameterJdbcTemplate.queryForRowSet(sql, paramJson);
}
/**
* 同 {@link NamedParameterJdbcTemplate#queryForList(String, Map)}<br><br>
* 指定SQL语句以创建预编译执行SQL和绑定查询参数，结果映射应该是一个多行查询。
* @param sql 要执行的查询SQL
* @param paramJson 要绑定到查询的参数映射
* @return 列表数据
*/
public List<JSONObject> queryForList(String sql, JSONObject paramJson) {
return ListUtils.toJsonList(namedParameterJdbcTemplate.queryForList(sql, paramJson));
}
/**
* 同 {@linkplain NamedParameterJdbcTemplate#queryForList(String, Map, Class)}<br>
* 指定SQL语句以创建预编译执行SQL和绑定查询参数，结果映射应该是一个多行查询。
* @param <T> 泛型
* @param sql 要执行的查询SQL
* @param paramJson 要绑定到查询的参数映射
* @param mappedClass 映射类
* @return 列表数据
*/
public <T> List<T> queryForList(String sql, JSONObject paramJson, Class<T> mappedClass) {
return namedParameterJdbcTemplate.query(sql, paramJson, BeanPropertyRowMapper.newInstance(mappedClass));
}
// is
/**
* 是否有数据
*
* @param tableName 表名
* @param paramJson 查询参数
* @return 是否有数据
*/
public boolean isDataSize(String tableName, JSONObject paramJson) {
return MapUtils.isNotEmpty(get(tableName, paramJson));
}
// get
/**
* 获得表的元数据
* <p>检索元数据，即此行集合的列的数字、类型和属性。
*
* @param tableName
* @return
*/
public SqlRowSetMetaData getMetaData(String tableName) {
tableName = dialect.getWrapper().wrap(tableName);
StringBuffer sql = new StringBuffer("SELECT * FROM ").append(tableName).append(dialect.getPageJoinSql());
return queryForRowSet(sql.toString(), Page.builder().page(0L).limit(0).build().toParamJson()).getMetaData();
}
private String getByColumnNameSqlBuild(String tableName, String columnName) {
paramValidate(tableName);
if (StringUtils.isEmpty(columnName)) {
throw new DbException("条件列名不能为空");
}
tableName = dialect.getWrapper().wrap(tableName);
columnName = dialect.getWrapper().wrap(columnName);
StringBuffer sql = new StringBuffer("SELECT * FROM ");
sql.append(tableName);
sql.append(" WHERE ").append(columnName).append(" = :").append(columnName);
if (enableDeleteQueryFilter) {
sql.append(" AND ").append(DbConstant.FIELD_DEFINITION_DELETE_TIME)
.append(" = ").append(DbConstant.FIELD_DEFAULT_VALUE_DELETE_TIME);
}
return sql.toString();
}
/**
* 通过表主键ID查询
*
* @param tableName 表名
* @param id 表自增ID
* @return JSON数据
*/
public JSONObject getById(String tableName, long id) {
paramValidate(tableName, id);
String sql = getByColumnNameSqlBuild(tableName, DbConstant.PRIMARY_KEY);
JSONObject paramJson = new JSONObject();
paramJson.put(dialect.getWrapper().wrap(DbConstant.PRIMARY_KEY), id);
return queryForJson(sql, paramJson);
}
/**
* 通过表ID查询（字段名=id，一般为表自增ID-主键）
*
* @param <T> 泛型
* @param tableName 表名
* @param id 主键ID
* @param mappedClass 映射类
* @return POJO对象
*/
public <T> T getById(String tableName, Long id, Class<T> mappedClass) {
paramValidate(tableName, id);
String sql = getByColumnNameSqlBuild(tableName, DbConstant.PRIMARY_KEY);
JSONObject paramJson = new JSONObject();
paramJson.put(dialect.getWrapper().wrap(DbConstant.PRIMARY_KEY), id);
return queryForObject(sql, paramJson, mappedClass);
}
/**
* 通过表业务键查询
* <p>默认业务键为key
* <p>业务键值推荐使用UUID5
*
* @param tableName 表名
* @param businessUkValue 业务键的唯一值
* @return JSON数据
*/
public JSONObject getByBusinessUk(String tableName, Object businessUkValue) {
String sql = getByColumnNameSqlBuild(tableName, businessUk);
JSONObject paramJson = new JSONObject();
paramJson.put(dialect.getWrapper().wrap(businessUk), businessUkValue);
return queryForJson(sql, paramJson);
}
/**
* 通过表业务键查询
* <p>默认业务键为key
* <p>业务键值推荐使用UUID5
*
* @param <T> 泛型
* @param tableName 表名
* @param businessUkValue 业务键的唯一值
* @param mappedClass 映射类
* @return POJO对象
*/
public <T> T getByBusinessUk(String tableName, Object businessUkValue, Class<T> mappedClass) {
String sql = getByColumnNameSqlBuild(tableName, businessUk);
JSONObject paramJson = new JSONObject();
paramJson.put(dialect.getWrapper().wrap(businessUk), businessUkValue);
return queryForObject(sql, paramJson, mappedClass);
}
/**
* 绝对条件查询
*
* @param tableName 表名
* @param paramJson 查询参数
* @return JSON数据
*/
public JSONObject get(String tableName, JSONObject paramJson) {
String sql = listSqlBuild(tableName, paramJson, null);
return queryForJson(sql, paramJson);
}
/**
* 绝对条件查询
*
* @param <T> 泛型
* @param tableName 表名
* @param paramJson 查询参数
* @param mappedClass 映射类
* @return POJO对象
*/
public <T> T get(String tableName, JSONObject paramJson, Class<T> mappedClass) {
String sql = listSqlBuild(tableName, paramJson, null);
return queryForObject(sql, paramJson, mappedClass);
}
// list
private String listSqlBuild(String tableName, JSONObject paramJson, DbSortEnum dBSortEnum) {
paramValidate(tableName, paramJson);
StringBuffer sql = new StringBuffer();
sql.append("SELECT * FROM ");
sql.append(dialect.getWrapper().wrap(tableName));
String whereSql = paramToWhereSql(paramJson);
sql.append(whereSql);
if (dBSortEnum == DbSortEnum.ASC) {// 升序
sql.append(" ORDER BY id");
} else if (dBSortEnum == DbSortEnum.DESC) {// 降序
sql.append(" ORDER BY id DESC");
}
return sql.toString();
}
/**
* 绝对条件查询
* @param tableName 表名
* @param paramJson 查询参数
* @return 列表数据
*/
public List<JSONObject> list(String tableName, JSONObject paramJson) {
String sql = listSqlBuild(tableName, paramJson, null);
return ListUtils.toJsonList(namedParameterJdbcTemplate.queryForList(sql, paramJson));
}
/**
* 绝对条件查询
* @param <T> 泛型
* @param tableName 表名
* @param paramJson 查询参数
* @param mappedClass 映射类
* @return 列表数据
*/
public <T> List<T> list(String tableName, JSONObject paramJson, Class<T> mappedClass) {
String sql = listSqlBuild(tableName, paramJson, null);
return namedParameterJdbcTemplate.query(sql, paramJson, BeanPropertyRowMapper.newInstance(mappedClass));
}
/**
* 绝对条件查询
* @param tableName 表名
* @param paramJson 查询参数
* @param dBSortEnum 排序方式
* @return 列表数据
*/
public List<JSONObject> list(String tableName, JSONObject paramJson, DbSortEnum dBSortEnum) {
String sql = listSqlBuild(tableName, paramJson, dBSortEnum);
return ListUtils.toJsonList(namedParameterJdbcTemplate.queryForList(sql, paramJson));
}
/**
* 绝对条件查询
* @param <T> 泛型
* @param tableName 表名
* @param paramJson 查询参数
* @param mappedClass 映射类
* @param dBSortEnum 排序方式
* @return 列表数据
*/
public <T> List<T> list(String tableName, JSONObject paramJson, Class<T> mappedClass, DbSortEnum dBSortEnum) {
String sql = listSqlBuild(tableName, paramJson, dBSortEnum);
return namedParameterJdbcTemplate.query(sql, paramJson, BeanPropertyRowMapper.newInstance(mappedClass));
}
private String listAllSqlBuild(String tableName) {
paramValidate(tableName);
StringBuffer sql = new StringBuffer();
sql.append("SELECT * FROM ");
sql.append(dialect.getWrapper().wrap(tableName));
return sql.toString();
}
/**
* 查询表中所有数据
* @param tableName 表名
* @return 列表数据
*/
public List<JSONObject> listAll(String tableName) {
String sql = listAllSqlBuild(tableName);
return queryForList(sql, MapUtils.FINAL_EMPTY_JSON);
}
/**
* 查询表中所有数据
* @param <T> 泛型
* @param tableName 表名
* @param mappedClass 映射类
* @return 列表数据
*/
public <T> List<T> listAll(String tableName, Class<T> mappedClass) {
String sql = listAllSqlBuild(tableName);
return namedParameterJdbcTemplate.query(sql, BeanPropertyRowMapper.newInstance(mappedClass));
}
// Page
protected PageVO toPageVO(PageDTO pageDTO) {
// 1. 处理PageDTO
Long count = pageDTO.getCount();
String querySql = pageDTO.getQuerySql();
JSONObject paramJson = pageDTO.getParamJson();
// 2. 查询数据
List<JSONObject> data = new ArrayList<>();
if (count == null || count != 0) {
data = ListUtils.toJsonList(namedParameterJdbcTemplate.queryForList(querySql, paramJson));
}
// 3. 分页
return PageVO.builder().count(count).data(data).build();
}
protected <T> PageTVO<T> toPageTVO(PageDTO pageDTO, Class<T> mappedClass) {
// 1. 处理PageDTO
Long count = pageDTO.getCount();
String querySql = pageDTO.getQuerySql();
JSONObject paramJson = pageDTO.getParamJson();
// 2. 查询数据
List<T> data = new ArrayList<>();
if (count != 0) {
data = namedParameterJdbcTemplate.query(querySql, paramJson, BeanPropertyRowMapper.newInstance(mappedClass));
}
// 3. 分页
PageTVO<T> pageTVO = new PageTVO<>();
return pageTVO.toBuilder().count(count).data(data).build();
}
/**
* <b>单表分页查询</b><br><br>
* <p>阿里最优SQL示例：</p>
* <code>SELECT a.* FROM 表 1 a, (select id from 表 1 where 条件 LIMIT 100000,20 ) b where a.id=b.id</code><br><br>
* @param tableName 表名
* @param pageIPO 分页查询参数 {@linkplain PageIPO}，所有的条件参数，都将以等于的形式进行SQL拼接
* @return count（总数），data（分页列表数据）
*/
public PageVO page(String tableName, PageIPO pageIPO) {
PageDTO pageDTO = dialect.pageDTOBuild(tableName, pageIPO, null);
return toPageVO(pageDTO);
}
/**
* <b>单表分页查询</b><br><br>
* <p>阿里最优SQL示例：</p>
* <code>SELECT a.* FROM 表 1 a, (select id from 表 1 where 条件 LIMIT 100000,20 ) b where a.id=b.id</code><br><br>
* @param <T> 泛型
* @param tableName 表名
* @param pageIPO 分页查询参数 {@linkplain PageIPO}，所有的条件参数，都将以等于的形式进行SQL拼接
* @param mappedClass 映射类
* @return count（总数），data（分页列表数据）
*/
public <T> PageTVO<T> page(String tableName, PageIPO pageIPO, Class<T> mappedClass) {
// 1. 获得PageDTO
PageDTO pageDTO = dialect.pageDTOBuild(tableName, pageIPO, null);
return toPageTVO(pageDTO, mappedClass);
}
/**
* <b>单表分页查询</b><br><br>
* <p>阿里最优SQL示例：</p>
* <code>SELECT a.* FROM 表 1 a, (select id from 表 1 where 条件 ORDER BY id LIMIT 100000,20 ) b where a.id=b.id</code><br><br>
* @param tableName 表名
* @param pageIPO 分页查询参数 {@linkplain PageIPO}，所有的条件参数，都将以等于的形式进行SQL拼接
* @param dBSortEnum 排序方式 {@linkplain DbSortEnum}
* @return count（总数），data（分页列表数据）
*/
public PageVO page(String tableName, PageIPO pageIPO, DbSortEnum dBSortEnum) {
PageDTO pageDTO = dialect.pageDTOBuild(tableName, pageIPO, dBSortEnum);
return toPageVO(pageDTO);
}
/**
* <b>单表分页查询</b><br><br>
* <p>阿里最优SQL示例：</p>
* <code>SELECT a.* FROM 表 1 a, (select id from 表 1 where 条件 ORDER BY id LIMIT 100000,20 ) b where a.id=b.id</code><br><br>
* @param <T> 泛型
* @param tableName 表名
* @param pageIPO 分页查询参数 {@linkplain PageIPO}，所有的条件参数，都将以等于的形式进行SQL拼接
* @param mappedClass 映射类
* @param dBSortEnum 排序方式 {@linkplain DbSortEnum}
* @return count（总数），data（分页列表数据）
*/
public <T> PageTVO<T> page(String tableName, PageIPO pageIPO, Class<T> mappedClass, DbSortEnum dBSortEnum) {
// 1. 获得PageDTO
PageDTO pageDTO = dialect.pageDTOBuild(tableName, pageIPO, dBSortEnum);
return toPageTVO(pageDTO, mappedClass);
}
/**
* <b>单表分页查询</b><br><br>
* <p>阿里最优SQL示例：</p>
* <code>SELECT a.* FROM 表 1 a, (select id from 表 1 where 条件 LIMIT 100000,20 ) b where a.id=b.id</code><br><br>
* @param tableName 表名
* @param whereSql 自定义WHERE语句，若此参数为空，那么所有的条件参数，都将以等于的形式进行SQL拼接。<br><i>SQL示例：</i>
* <code> WHERE 条件</code>
* @param pageIPO 分页查询参数 {@linkplain PageIPO}
* @return count（总数），data（分页列表数据）
*/
public PageVO pageWhere(String tableName, String whereSql, PageIPO pageIPO) {
PageDTO pageDTO = dialect.pageDTOBuild(tableName, whereSql, pageIPO);
return toPageVO(pageDTO);
}
/**
* <b>单表分页查询</b><br><br>
* <p>阿里最优SQL示例：</p>
* <code>SELECT a.* FROM 表 1 a, (select id from 表 1 where 条件 LIMIT 100000,20 ) b where a.id=b.id</code><br><br>
* @param <T> 泛型
* @param tableName 表名
* @param whereSql 自定义WHERE语句，若此参数为空，那么所有的条件参数，都将以等于的形式进行SQL拼接。<br><i>SQL示例：</i>
* <code> WHERE 条件</code>
* @param pageIPO 分页查询参数 {@linkplain PageIPO}
* @param mappedClass 映射类
* @return count（总数），data（分页列表数据）
*/
public <T> PageTVO<T> pageWhere(String tableName, String whereSql, PageIPO pageIPO, Class<T> mappedClass) {
PageDTO pageDTO = dialect.pageDTOBuild(tableName, whereSql, pageIPO);
return toPageTVO(pageDTO, mappedClass);
}
private PageDTO pageDTOBuild(String countSql, String querySql, PageIPO pageIPO) {
// 1. 参数校验
if (StringUtils.isEmpty(querySql)) {
throw new DbException("querySql不能为空");
}
// 2. 处理分页参数
JSONObject paramJson = dialect.toParamJson(pageIPO);
JSONObject conditions = pageIPO.getConditions();
// 3. 统计
Long count = null;
if (!StringUtils.isEmpty(countSql)) {
count = (Long) namedParameterJdbcTemplate.queryForMap(countSql, conditions).get("count");
}
// 4. 返回结果
return PageDTO.builder().count(count).querySql(querySql.toString()).paramJson(paramJson).build();
}
/**
* <b>复杂SQL分页查询</b><br><br>
* <p>阿里最优查询SQL示例：</p>
* <code>SELECT a.* FROM 表 1 a, (select id from 表 1 where 条件 LIMIT :page, :limit) b where a.id=b.id</code><br><br>
*
* @param querySql 用于查询数据的sql语句
* @param pageIPO 分页查询参数 {@linkplain PageIPO}
* @return count（总数），data（分页列表数据）
*/
public PageVO pageSql(String querySql, PageIPO pageIPO) {
PageDTO pageDTO = dialect.pageDTOBuild(querySql, pageIPO);
return toPageVO(pageDTO);
}
/**
* <b>复杂SQL分页查询</b><br><br>
* <p>阿里最优查询SQL示例：</p>
* <code>SELECT a.* FROM 表 1 a, (select id from 表 1 where 条件 LIMIT :page, :limit) b where a.id=b.id</code><br><br>
* @param <T> 泛型
* @param querySql 用于查询数据的sql语句
* @param pageIPO 分页查询参数 {@linkplain PageIPO}
* @param mappedClass 映射类
* @return count（总数），data（分页列表数据）
*/
public <T> PageTVO<T> pageSql(String querySql, PageIPO pageIPO, Class<T> mappedClass) {
PageDTO pageDTO = dialect.pageDTOBuild(querySql, pageIPO);
return toPageTVO(pageDTO, mappedClass);
}
/**
* <b>复杂SQL分页查询</b><br><br>
* <p>统计SQL示例：</p>
* <code>SELECT count(*) count FROM 表 1 a, (select id from 表 1 where 条件) b where a.id=b.id</code><br>
* <p>阿里最优查询SQL示例：</p>
* <code>SELECT a.* FROM 表 1 a, (select id from 表 1 where 条件 LIMIT :page, :limit) b where a.id=b.id</code><br><br>
*
* @param countSql 用于统计总数的sql语句 <i>（注意：count(*)必须拥有count别名）</i> 同时countSql可以为null表示不统计 <b>可选参数</b>
* @param querySql 用于查询数据的sql语句
* @param pageIPO 分页查询参数 {@linkplain PageIPO}
* @return count（总数），data（分页列表数据）
*/
public PageVO pageSql(@Nullable String countSql, String querySql, PageIPO pageIPO) {
PageDTO pageDTO = pageDTOBuild(countSql, querySql, pageIPO);
return toPageVO(pageDTO);
}
/**
* <b>复杂SQL分页查询</b><br><br>
* <p>统计SQL示例：</p>
* <code>SELECT count(*) count FROM 表 1 a, (select id from 表 1 where 条件) b where a.id=b.id</code><br>
* <p>阿里最优查询SQL示例：</p>
* <code>SELECT a.* FROM 表 1 a, (select id from 表 1 where 条件 LIMIT :page, :limit) b where a.id=b.id</code><br><br>
*
* @param <T> 泛型
* @param countSql 用于统计总数的sql语句 <i>（注意：count(*)必须拥有count别名）</i> 同时countSql可以为null表示不统计 <b>可选参数</b>
* @param querySql 用于查询数据的sql语句
* @param pageIPO 分页查询参数 {@linkplain PageIPO}
* @param mappedClass 映射类
* @return count（总数），data（分页列表数据）
*/
public <T> PageTVO<T> pageSql(@Nullable String countSql, String querySql, PageIPO pageIPO, Class<T> mappedClass) {
PageDTO pageDTO = pageDTOBuild(countSql, querySql, pageIPO);
return toPageTVO(pageDTO, mappedClass);
}
/**
* <b>根据相同的列表条件，获得上一条与下一条数据</b>
*
* @param querySql 用于查询数据的sql语句
* @param pageIPO 分页查询参数 {@linkplain PageIPO}
* @param equalsId 做比较的条件ID（将与查询结果的主键ID做比较）
* @return {@linkplain PageBeforeAndAfterVO}
*/
public PageBeforeAndAfterVO pageBeforeAndAfter(String querySql, PageIPO pageIPO, Long equalsId) {
return dialect.pageBeforeAndAfter(querySql, pageIPO, equalsId);
}
}
|
0 | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc/client/DbUpdate.java | package ai.yue.library.data.jdbc.client;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import org.springframework.jdbc.core.namedparam.BeanPropertySqlParameterSource;
import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
import org.springframework.jdbc.core.namedparam.SqlParameterSource;
import org.springframework.jdbc.support.GeneratedKeyHolder;
import org.springframework.jdbc.support.KeyHolder;
import org.springframework.lang.Nullable;
import org.springframework.transaction.annotation.Transactional;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import ai.yue.library.base.exception.DbException;
import ai.yue.library.base.util.ListUtils;
import ai.yue.library.data.jdbc.constant.DbConstant;
import ai.yue.library.data.jdbc.constant.DbExpectedValueModeEnum;
import ai.yue.library.data.jdbc.constant.DbUpdateEnum;
import cn.hutool.core.util.ArrayUtil;
/**
* <h2>SQL优化型数据库操作</h2>
* Created by sunJinChuan on 2016/6/6
* @since 0.0.1
*/
class DbUpdate extends DbQuery {
// Spring Update
/**
* 同 {@linkplain NamedParameterJdbcTemplate#update(String, SqlParameterSource, KeyHolder)}<br>
* 指定SQL语句以创建预编译执行SQL和绑定更新参数
*
* @param sql 要执行的更新SQL
* @param paramSource 更新所用到的参数：{@linkplain MapSqlParameterSource}，{@linkplain BeanPropertySqlParameterSource}
* @return 自动生成的键(可能由JDBC insert语句返回)。
*/
@Transactional
public KeyHolder update(String sql, SqlParameterSource paramSource, KeyHolder generatedKeyHolder) {
namedParameterJdbcTemplate.update(sql, paramSource, generatedKeyHolder);
return generatedKeyHolder;
}
/**
* 更新或插入一条数据，主键默认为id时使用。
*
* @param sql 更新或插入SQL
* @param paramSource 更新所用到的参数：{@linkplain MapSqlParameterSource}，{@linkplain BeanPropertySqlParameterSource}
* @return 更新的主键id值
*/
@Transactional
public Long update(String sql, SqlParameterSource paramSource) {
GeneratedKeyHolder generatedKeyHolder = new GeneratedKeyHolder();
long updateRowsNumber = namedParameterJdbcTemplate.update(sql.toString(), paramSource, generatedKeyHolder);
int expectedValue = 1;
updateAndExpectedEqual(updateRowsNumber, expectedValue);
return generatedKeyHolder.getKey().longValue();
}
/**
* 同 {@linkplain NamedParameterJdbcTemplate#update(String, Map)}<br>
* 指定SQL语句以创建预编译执行SQL和绑定更新参数
*
* @param sql 要执行的更新SQL
* @param paramJson 更新所用到的参数
* @return 受影响的行数
*/
@Transactional
public long update(String sql, JSONObject paramJson) {
return namedParameterJdbcTemplate.update(sql, paramJson);
}
/**
* 同 {@linkplain NamedParameterJdbcTemplate#update(String, Map)}<br>
* 指定SQL语句以创建预编译执行SQL和绑定更新参数
* <blockquote>
* <p>
* 将会对更新所影响的行数进行预期判断，若结果不符合预期值：<b>expectedValue</b>，那么此处便会抛出一个 {@linkplain DbException}
* </p>
* </blockquote>
* @param sql 要执行的更新SQL
* @param paramJson 更新所用到的参数
* @param expectedValue 更新所影响的行数预期值
* @param dBExpectedValueModeEnum 预期值确认方式
*/
@Transactional
public void update(String sql, JSONObject paramJson, int expectedValue, DbExpectedValueModeEnum dBExpectedValueModeEnum) {
int updateRowsNumber = namedParameterJdbcTemplate.update(sql, paramJson);
if (DbExpectedValueModeEnum.EQUAL == dBExpectedValueModeEnum) {
updateAndExpectedEqual(updateRowsNumber, expectedValue);
} else if (DbExpectedValueModeEnum.GREATER_THAN_EQUAL == dBExpectedValueModeEnum) {
updateAndExpectedGreaterThanEqual(updateRowsNumber, expectedValue);
}
}
/**
* 同 {@linkplain NamedParameterJdbcTemplate#batchUpdate(String, Map[])}<br>
* 指定SQL语句以创建预编译执行SQL和绑定更新参数
* @param sql 要执行的更新SQL
* @param paramJsons 更新所用到的参数数组
* @return 一个数组，其中包含受批处理中每个更新影响的行数
*/
@Transactional
public int[] updateBatch(String sql, JSONObject[] paramJsons) {
return namedParameterJdbcTemplate.batchUpdate(sql, paramJsons);
}
// Update
private String updateSqlBuild(String tableName, JSONObject paramJson, String[] conditions, DbUpdateEnum dBUpdateEnum) {
return dialect.updateSqlBuild(tableName, paramJson, conditions, dBUpdateEnum);
}
/**
* <b>绝对</b>条件更新优化SQL<br><br>
* <b>相对</b>条件更新优化SQL可参照如下编写：<br>
* <code>UPDATE table</code><br>
* <code>SET paramNumber1 = paramNumber1 - 1, ...</code><br>
* <code>WHERE</code><br>
* <code>id = :id</code><br>
* <code>AND</code><br>
* <code>paramNumber1 > 0</code><br>
* <code>AND ...</code>
* @param tableName 表名
* @param paramJson 更新所用到的参数（where条件参数不会用于set值的更新）
* @param conditions 作为更新条件的参数名，对应paramJson内的key（注意：作为条件的参数，将不会用于字段值的更新）
* @return 受影响的行数
*/
@Transactional
public Long update(String tableName, JSONObject paramJson, String[] conditions) {
String sql = updateSqlBuild(tableName, paramJson, conditions, DbUpdateEnum.NORMAL);
return (long) namedParameterJdbcTemplate.update(sql, paramJson);
}
/**
* <b>绝对</b>条件更新优化SQL<br><br>
* @param tableName 表名
* @param paramJson 更新所用到的参数
* @param conditions 作为更新条件的参数名，对应paramJson内的key（注意：作为条件的参数，将不会用于字段值的更新）
* @param dBUpdateEnum 更新类型 {@linkplain DbUpdateEnum}
* @return 受影响的行数
*/
@Transactional
public Long update(String tableName, JSONObject paramJson, String[] conditions, DbUpdateEnum dBUpdateEnum) {
String sql = updateSqlBuild(tableName, paramJson, conditions, dBUpdateEnum);
return (long) namedParameterJdbcTemplate.update(sql, paramJson);
}
/**
* <b>绝对</b>条件更新优化SQL<br><br>
* @param tableName 表名
* @param paramJson 更新所用到的参数
* @param conditions 作为更新条件的参数名，对应paramJson内的key（注意：作为条件的参数，将不会用于字段值的更新）
* @param dBUpdateEnum 更新类型 {@linkplain DbUpdateEnum}
* @param expectedValue 更新所影响的行数预期值
* @param dBExpectedValueModeEnum 预期值确认方式
*/
@Transactional
public void update(String tableName, JSONObject paramJson, String[] conditions, DbUpdateEnum dBUpdateEnum
, int expectedValue, DbExpectedValueModeEnum dBExpectedValueModeEnum) {
String sql = updateSqlBuild(tableName, paramJson, conditions, dBUpdateEnum);
int updateRowsNumber = namedParameterJdbcTemplate.update(sql, paramJson);
if (DbExpectedValueModeEnum.EQUAL == dBExpectedValueModeEnum) {
updateAndExpectedEqual(updateRowsNumber, expectedValue);
} else if (DbExpectedValueModeEnum.GREATER_THAN_EQUAL == dBExpectedValueModeEnum) {
updateAndExpectedGreaterThanEqual(updateRowsNumber, expectedValue);
}
}
/**
* 更新-ById
* <p>根据表中主键ID进行更新
* @param tableName 表名
* @param paramJson 更新所用到的参数（包含主键ID字段）
*/
@Transactional
public void updateById(String tableName, JSONObject paramJson) {
updateById(tableName, paramJson, DbUpdateEnum.NORMAL);
}
/**
* 更新-ById
* <p>根据表中主键ID进行更新
* @param tableName 表名
* @param paramJson 更新所用到的参数（包含主键ID字段）
* @param dBUpdateEnum 更新类型 {@linkplain DbUpdateEnum}
*/
@Transactional
public void updateById(String tableName, JSONObject paramJson, DbUpdateEnum dBUpdateEnum) {
String[] conditions = { DbConstant.PRIMARY_KEY };
String sql = updateSqlBuild(tableName, paramJson, conditions, dBUpdateEnum);
int updateRowsNumber = namedParameterJdbcTemplate.update(sql, paramJson);
int expectedValue = 1;
updateAndExpectedEqual(updateRowsNumber, expectedValue);
}
/**
* 批量更新-ById
* <p>根据表中主键ID进行批量更新
* @param tableName 表名
* @param paramJsons 更新所用到的参数数组（包含主键ID字段）
* @param dBUpdateEnum 更新类型 {@linkplain DbUpdateEnum}
*/
@Transactional
public void updateById(String tableName, JSONObject[] paramJsons, DbUpdateEnum dBUpdateEnum) {
String[] conditions = { DbConstant.PRIMARY_KEY };
String sql = updateSqlBuild(tableName, paramJsons[0], conditions, dBUpdateEnum);
int[] updateRowsNumberArray = namedParameterJdbcTemplate.batchUpdate(sql, paramJsons);
int expectedValue = 1;
updateBatchAndExpectedEqual(updateRowsNumberArray, expectedValue);
}
/**
* 更新-By业务键
* <p>根据表中业务键进行更新
* <p>默认业务键为key
* <p>业务键值推荐使用UUID5
*
* @param tableName 表名
* @param paramJson 更新所用到的参数（包含业务键字段）
*/
@Transactional
public void updateByBusinessUk(String tableName, JSONObject paramJson) {
updateByBusinessUk(tableName, paramJson, DbUpdateEnum.NORMAL);
}
/**
* 更新-By业务键
* <p>根据表中业务键进行更新
* <p>默认业务键为key
* <p>业务键值推荐使用UUID5
*
* @param tableName 表名
* @param paramJson 更新所用到的参数（包含业务键字段）
* @param dBUpdateEnum 更新类型 {@linkplain DbUpdateEnum}
*/
@Transactional
public void updateByBusinessUk(String tableName, JSONObject paramJson, DbUpdateEnum dBUpdateEnum) {
String[] conditions = { businessUk };
String sql = updateSqlBuild(tableName, paramJson, conditions, dBUpdateEnum);
int updateRowsNumber = namedParameterJdbcTemplate.update(sql, paramJson);
int expectedValue = 1;
updateAndExpectedEqual(updateRowsNumber, expectedValue);
}
/**
* 批量更新-By业务键
* <p>根据表中业务键进行批量更新
* <p>默认业务键为key
* <p>业务键值推荐使用UUID5
*
* @param tableName 表名
* @param paramJsons 更新所用到的参数数组（包含业务键字段）
* @param dBUpdateEnum 更新类型 {@linkplain DbUpdateEnum}
*/
@Transactional
public void updateByBusinessUk(String tableName, JSONObject[] paramJsons, DbUpdateEnum dBUpdateEnum) {
String[] conditions = { businessUk };
String sql = updateSqlBuild(tableName, paramJsons[0], conditions, dBUpdateEnum);
int[] updateRowsNumberArray = namedParameterJdbcTemplate.batchUpdate(sql, paramJsons);
int expectedValue = 1;
updateBatchAndExpectedEqual(updateRowsNumberArray, expectedValue);
}
/**
* <h1>更新-排序</h1><br>
* <i>使用限制：见</i> {@linkplain DbInsert#insertWithSortIdxAutoIncrement(String, JSONObject, String...)}
* <p>
* @param tableName 表名
* @param id 主键ID
* @param move sort_idx移动位数（值不可等于零，正整数表示：向后移动几位，负整数表示：向前移动几位）
* @param uniqueKeys 同sort_idx字段组合的唯一约束keys（表中不建议建立sort_idx字段的唯一约束，但可以建立普通索引，以便于提高查询性能），<b>可选参数</b>
*/
@Transactional
public void updateSort(String tableName, Long id, Integer move, @Nullable String... uniqueKeys) {
// 1. 参数验证
paramValidate(tableName);
if (move == 0) {
throw new DbException("move <= 0");
}
// 2. 获得当前排序索引
String id_key = "id";
String sort_idx_key = "sort_idx";
JSONObject sortJson = getById(tableName, id);
int sortIdx = sortJson.getInteger(sort_idx_key);
int updateSortIdx = sortIdx + move;
if (updateSortIdx < 1) {
throw new DbException("排序后的索引值不能小于1");
}
// 3. 确认排序方式
List<Integer> updateSortList = new ArrayList<>();
boolean isASC = false;
if (updateSortIdx > sortIdx) {// 升序
isASC = true;
for (int i = updateSortIdx; i > sortIdx; i--) {
updateSortList.add(i);
}
} else {// 降序
for (int i = updateSortIdx; i < sortIdx; i++) {
updateSortList.add(i);
}
}
// 4. 查询需要跟随移动的数据ID
JSONObject paramJson = new JSONObject();
if (ArrayUtil.isNotEmpty(uniqueKeys)) {
for (String uniqueKey : uniqueKeys) {
var uniqueValue = sortJson.get(uniqueKey);
paramJson.put(uniqueKey, uniqueValue);
}
}
paramJson.put(sort_idx_key, updateSortList);
List<JSONObject> list = list(tableName, paramJson);
// 5. 组装跟随移动参数到参数列表
JSONArray paramJsonArray = new JSONArray();
for (JSONObject actionJSON : list) {
Long actionId = actionJSON.getLong(id_key);
Integer actionSort = actionJSON.getInteger(sort_idx_key);
if (isASC) {
actionSort -= 1;
} else {
actionSort += 1;
}
JSONObject actionParamJSON = new JSONObject();
actionParamJSON.put(id_key, actionId);
actionParamJSON.put(sort_idx_key, actionSort);
paramJsonArray.add(actionParamJSON);
}
// 6. 添加排序更新参数到参数列表
JSONObject updateSortParam = new JSONObject();
updateSortParam.put(id_key, id);
updateSortParam.put(sort_idx_key, updateSortIdx);
paramJsonArray.add(updateSortParam);
// 7. 排序更新
updateById(tableName, ListUtils.toJsons(paramJsonArray), DbUpdateEnum.NORMAL);
}
/**
* 更新-批量
* <p>一组条件对应一条数据，并且每组条件都采用相同的key
*
* @param tableName 表名
* @param paramJsons 更新所用到的参数数组
* @param conditions 作为更新条件的参数名，对应paramJson内的key（注意：作为条件的参数，将不会用于字段值的更新）
* @param dBUpdateEnum 更新类型 {@linkplain DbUpdateEnum}
*/
@Transactional
public void updateBatch(String tableName, JSONObject[] paramJsons, String[] conditions, DbUpdateEnum dBUpdateEnum) {
// 1. 获得SQL
String sql = updateSqlBuild(tableName, paramJsons[0], conditions, dBUpdateEnum);
// 2. 执行
int[] updateRowsNumberArray = namedParameterJdbcTemplate.batchUpdate(sql, paramJsons);
// 3. 确认影响行数
int expectedValue = 1;
updateBatchAndExpectedEqual(updateRowsNumberArray, expectedValue);
}
}
|
0 | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc/client/package-info.java | /**
* JDBC客户端Db
*
* @author ylyue
* @since 2019年10月14日
*/
package ai.yue.library.data.jdbc.client; |
0 | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc/client | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc/client/dialect/AnsiSqlDialect.java | package ai.yue.library.data.jdbc.client.dialect;
import com.alibaba.fastjson.JSONObject;
import ai.yue.library.base.util.ArithCompute;
import ai.yue.library.data.jdbc.client.DbBase;
import ai.yue.library.data.jdbc.ipo.Page;
import ai.yue.library.data.jdbc.ipo.PageIPO;
/**
* ANSI SQL
*
* @author ylyue
* @since 2020年6月13日
*/
public abstract class AnsiSqlDialect extends DbBase implements Dialect {
private static final long serialVersionUID = 1841162445914907750L;
protected Wrapper wrapper = new Wrapper();
@Override
public Wrapper getWrapper() {
return this.wrapper;
}
@Override
public void setWrapper(Wrapper wrapper) {
this.wrapper = wrapper;
}
@Override
public String getPageJoinSql() {
// limit A offset B 表示：A就是你需要多少行，B就是查询的起点位置。
StringBuffer pageJoinSql = new StringBuffer(" ");
return pageJoinSql.append(Page.LIMIT_KEYWORD).append(" ").append(Page.LIMIT_NAMED_PARAMETER).append(" ")
.append(Page.PAGE_NAMED_PARAMETER).append(" ").toString();
}
@Override
public DialectName dialectName() {
return DialectName.ANSI;
}
// ---------------------------------------------------------------------------- ANSI SQL Dialect implements start
// Page
@Override
public Page toPage(PageIPO pageIPO) {
// 1. 处理分页参数
long page = pageIPO.getPage();
int limit = pageIPO.getLimit();
JSONObject conditions = pageIPO.getConditions();
page--;
if (page >= 1) {
page = (long) ArithCompute.mul(page, limit);
}
// 2. 返回结果
return Page.builder()
.page(page)
.limit(limit)
.conditions(conditions)
.build();
}
@Override
public JSONObject toParamJson(PageIPO pageIPO) {
return toPage(pageIPO).toParamJson();
}
// ---------------------------------------------------------------------------- ANSI SQL Dialect implements end
// ---------------------------------------------------------------------------- ANSI SQL method start
// ---------------------------------------------------------------------------- ANSI SQL method end
}
|
0 | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc/client | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc/client/dialect/Dialect.java | package ai.yue.library.data.jdbc.client.dialect;
import java.io.Serializable;
import com.alibaba.fastjson.JSONObject;
import ai.yue.library.data.jdbc.constant.DbSortEnum;
import ai.yue.library.data.jdbc.constant.DbUpdateEnum;
import ai.yue.library.data.jdbc.dto.PageDTO;
import ai.yue.library.data.jdbc.ipo.Page;
import ai.yue.library.data.jdbc.ipo.PageIPO;
import ai.yue.library.data.jdbc.vo.PageBeforeAndAfterVO;
/**
* SQL方言
* <p>由于不同数据库间SQL语句的差异，导致无法统一拼接SQL，Dialect接口旨在根据不同的数据库，使用不同的方言实现类，来拼接对应的SQL。
* <p>设计模式借鉴于hutool-db
*
* @author ylyue
* @since 2020年6月13日
*/
public interface Dialect extends Serializable {
// Dialect
/**
* @return 包装器
*/
Wrapper getWrapper();
/**
* 设置包装器
*
* @param wrapper 包装器
*/
void setWrapper(Wrapper wrapper);
/**
* 方言名
*
* @return 方言名
*/
DialectName dialectName();
// insert
/**
* <h2>插入或更新</h2>
* <i>表中必须存在数据唯一性约束</i>
* <p>更新触发条件：此数据若存在唯一性约束则更新，否则便执行插入数据
* <p><b>MySQL执行示例：</b><br>
* <code>INSERT INTO table (param1, param2, ...)</code><br>
* <code>VALUES</code><br>
* <code>(:param1, :param2, ...)</code><br>
* <code>ON DUPLICATE KEY UPDATE</code><br>
* <code>condition = condition + :condition, ...</code>
* @param tableName 表名
* @param paramJson 插入或更新所用到的参数
* @param conditions 更新条件（对应paramJson内的key值）
* @param dBUpdateEnum 更新类型 {@linkplain DbUpdateEnum}
* @return 受影响的行数
*/
Long insertOrUpdate(String tableName, JSONObject paramJson, String[] conditions, DbUpdateEnum dBUpdateEnum);
// Page
/**
* 获得用于SQL字符串拼接的SQL分页字符串
*
* @return 用于SQL字符串拼接的SQL分页字符串（带具名参数的SQL字符串，非SQL拼接）
*/
String getPageJoinSql();
/**
* 转换为分页查询对象
*
* @param pageIPO
* @return 分页查询对象
*/
Page toPage(PageIPO pageIPO);
/**
* 转换为Db参数Json
*
* @param pageIPO 分页请求对象
* @return paramJson
*/
JSONObject toParamJson(PageIPO pageIPO);
PageDTO pageDTOBuild(String tableName, PageIPO pageIPO, DbSortEnum dBSortEnum);
PageDTO pageDTOBuild(String tableName, String whereSql, PageIPO pageIPO);
PageDTO pageDTOBuild(String querySql, PageIPO pageIPO);
/**
* <b>根据相同的列表条件，获得上一条与下一条数据</b>
*
* @param querySql 用于查询数据的sql语句
* @param pageIPO 分页查询参数 {@linkplain PageIPO}
* @param equalsId 做比较的条件ID（将与查询结果的主键ID做比较）
* @return {@linkplain PageBeforeAndAfterVO}
*/
PageBeforeAndAfterVO pageBeforeAndAfter(String querySql, PageIPO pageIPO, Long equalsId);
// Update
String updateSqlBuild(String tableName, JSONObject paramJson, String[] conditions, DbUpdateEnum dBUpdateEnum);
}
|
0 | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc/client | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc/client/dialect/DialectName.java | package ai.yue.library.data.jdbc.client.dialect;
/**
* 方言名
* <p>定义yue-library支持的所有数据库方言
*
* @author ylyue
* @since 2020年6月13日
*/
public enum DialectName {
ANSI, MYSQL, POSTGREESQL;
}
|
0 | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc/client | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc/client/dialect/Wrapper.java | package ai.yue.library.data.jdbc.client.dialect;
import java.util.Arrays;
import java.util.Collection;
import com.alibaba.fastjson.JSONObject;
import ai.yue.library.base.util.MapUtils;
import ai.yue.library.base.util.StringUtils;
import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.lang.Editor;
import cn.hutool.core.util.ArrayUtil;
import cn.hutool.core.util.CharUtil;
import cn.hutool.core.util.StrUtil;
/**
* <b>包装器</b>
* <p>主要用于字段名的包装（在字段名的前后加字符，例如反引号来避免与数据库的关键字冲突）
* <p>源自 hutool-db 进行增强扩展
*
* @author Looly
* @since 2020年6月15日
*/
public class Wrapper {
/** 前置包装符号 */
private Character preWrapQuote;
/** 后置包装符号 */
private Character sufWrapQuote;
public Wrapper() {
}
/**
* 构造
* @param wrapQuote 单包装字符
*/
public Wrapper(Character wrapQuote) {
this.preWrapQuote = wrapQuote;
this.sufWrapQuote = wrapQuote;
}
/**
* 包装符号
* @param preWrapQuote 前置包装符号
* @param sufWrapQuote 后置包装符号
*/
public Wrapper(Character preWrapQuote, Character sufWrapQuote) {
this.preWrapQuote = preWrapQuote;
this.sufWrapQuote = sufWrapQuote;
}
//--------------------------------------------------------------- Getters and Setters start
/**
* @return 前置包装符号
*/
public char getPreWrapQuote() {
return preWrapQuote;
}
/**
* 设置前置包装的符号
* @param preWrapQuote 前置包装符号
*/
public void setPreWrapQuote(Character preWrapQuote) {
this.preWrapQuote = preWrapQuote;
}
/**
* @return 后置包装符号
*/
public char getSufWrapQuote() {
return sufWrapQuote;
}
/**
* 设置后置包装的符号
* @param sufWrapQuote 后置包装符号
*/
public void setSufWrapQuote(Character sufWrapQuote) {
this.sufWrapQuote = sufWrapQuote;
}
//--------------------------------------------------------------- Getters and Setters end
/**
* 包装字段名<br>
* 有时字段与SQL的某些关键字冲突，导致SQL出错，因此需要将字段名用单引号或者反引号包装起来，避免冲突
* @param field 字段名
* @return 包装后的字段名
*/
public String wrap(String field){
if(preWrapQuote == null || sufWrapQuote == null || StrUtil.isBlank(field)) {
return field;
}
//如果已经包含包装的引号，返回原字符
if(StrUtil.isSurround(field, preWrapQuote, sufWrapQuote)){
return field;
}
//如果字段中包含通配符或者括号（字段通配符或者函数），不做包装
if(StrUtil.containsAnyIgnoreCase(field, "*", "(", " ", " as ")) {
return field;
}
//对于Oracle这类数据库，表名中包含用户名需要单独拆分包装
if(field.contains(StrUtil.DOT)){
final Collection<String> target = CollectionUtil.filter(StrUtil.split(field, StrUtil.C_DOT), (Editor<String>) t -> StrUtil.format("{}{}{}", preWrapQuote, t, sufWrapQuote));
return CollectionUtil.join(target, StrUtil.DOT);
}
return StrUtil.format("{}{}{}", preWrapQuote, field, sufWrapQuote);
}
/**
* 包装字段名<br>
* 有时字段与SQL的某些关键字冲突，导致SQL出错，因此需要将字段名用单引号或者反引号包装起来，避免冲突
* @param fields 字段名
* @return 包装后的字段名
*/
public String[] wrap(String... fields){
if(ArrayUtil.isEmpty(fields)) {
return fields;
}
String[] wrappedFields = new String[fields.length];
for(int i = 0; i < fields.length; i++) {
wrappedFields[i] = wrap(fields[i]);
}
return wrappedFields;
}
/**
* 包装字段名<br>
* 有时字段与SQL的某些关键字冲突，导致SQL出错，因此需要将字段名用单引号或者反引号包装起来，避免冲突
* @param fields 字段名
* @return 包装后的字段名
*/
public Collection<String> wrap(Collection<String> fields){
if(CollectionUtil.isEmpty(fields)) {
return fields;
}
return Arrays.asList(wrap(fields.toArray(new String[0])));
}
/**
* 包装字段名<br>
* 有时字段与SQL的某些关键字冲突，导致SQL出错，因此需要将字段名用单引号或者反引号包装起来，避免冲突
*
* @param paramJson 被包装的paramJson
* @return 包装后的字段名
*/
public JSONObject wrap(JSONObject paramJson) {
if (MapUtils.isEmpty(paramJson)) {
return paramJson;
}
// wrap fields
JSONObject paramJsonWrapped = new JSONObject();
paramJson.forEach((key, value) -> {
paramJsonWrapped.put(wrap(key), value);
});
return paramJsonWrapped;
}
/**
* 包装字段名<br>
* 有时字段与SQL的某些关键字冲突，导致SQL出错，因此需要将字段名用单引号或者反引号包装起来，避免冲突
*
* @param paramJsons 被包装的paramJson数组
* @return 包装后的字段名
*/
public JSONObject[] wrap(JSONObject[] paramJsons) {
if (MapUtils.isEmptys(paramJsons)) {
return paramJsons;
}
for (int i = 0; i < paramJsons.length; i++) {
JSONObject paramJson = paramJsons[i];
paramJsons[i] = wrap(paramJson);
}
return paramJsons;
}
// /**
// * 包装字段名<br>
// * 有时字段与SQL的某些关键字冲突，导致SQL出错，因此需要将字段名用单引号或者反引号包装起来，避免冲突
// * @param conditions 被包装的实体
// * @return 包装后的字段名
// */
// public Condition[] wrap(Condition... conditions){
// final Condition[] clonedConditions = new Condition[conditions.length];
// if(ArrayUtil.isNotEmpty(conditions)) {
// Condition clonedCondition;
// for(int i = 0; i < conditions.length; i++) {
// clonedCondition = conditions[i].clone();
// clonedCondition.setField(wrap(clonedCondition.getField()));
// clonedConditions[i] = clonedCondition;
// }
// }
//
// return clonedConditions;
// }
/**
* 去除字段包装
*
* @param field 字段
* @return 去除包装后的字段
*/
public String unwrap(String field) {
if (StringUtils.isEmpty(field)) {
return field;
}
return StringUtils.deleteFirstLastEqualString(field, CharUtil.toString(getPreWrapQuote()),
CharUtil.toString(getSufWrapQuote()));
}
}
|
0 | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc/client | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc/client/dialect/package-info.java | /**
* SQL方言
*
* @author ylyue
* @since 2020年6月13日
*/
package ai.yue.library.data.jdbc.client.dialect; |
0 | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc/client/dialect | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc/client/dialect/impl/MysqlDialect.java | package ai.yue.library.data.jdbc.client.dialect.impl;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import ai.yue.library.base.exception.DbException;
import ai.yue.library.base.util.MapUtils;
import ai.yue.library.base.util.StringUtils;
import ai.yue.library.data.jdbc.client.dialect.AnsiSqlDialect;
import ai.yue.library.data.jdbc.client.dialect.DialectName;
import ai.yue.library.data.jdbc.client.dialect.Wrapper;
import ai.yue.library.data.jdbc.constant.DbConstant;
import ai.yue.library.data.jdbc.constant.DbSortEnum;
import ai.yue.library.data.jdbc.constant.DbUpdateEnum;
import ai.yue.library.data.jdbc.dto.PageDTO;
import ai.yue.library.data.jdbc.ipo.Page;
import ai.yue.library.data.jdbc.ipo.PageIPO;
import ai.yue.library.data.jdbc.vo.PageBeforeAndAfterVO;
import cn.hutool.core.util.ArrayUtil;
/**
* MySQL方言
*
* @author ylyue
* @since 2020年6月13日
*/
public class MysqlDialect extends AnsiSqlDialect {
private static final long serialVersionUID = -3734718212043823636L;
public MysqlDialect(NamedParameterJdbcTemplate namedParameterJdbcTemplate) {
super.wrapper = new Wrapper('`');
super.dialect = this;
super.namedParameterJdbcTemplate = namedParameterJdbcTemplate;
}
@Override
public String getPageJoinSql() {
StringBuffer pageJoinSql = new StringBuffer(" ");
return pageJoinSql.append(Page.LIMIT_KEYWORD).append(" ").append(Page.PAGE_NAMED_PARAMETER).append(" , ")
.append(Page.LIMIT_NAMED_PARAMETER).append(" ").toString();
}
@Override
public DialectName dialectName() {
return DialectName.MYSQL;
}
// insert
@Override
public Long insertOrUpdate(String tableName, JSONObject paramJson, String[] conditions, DbUpdateEnum dBUpdateEnum) {
paramValidate(tableName, paramJson, conditions);
tableName = wrapper.wrap(tableName);
paramJson = wrapper.wrap(paramJson);
conditions = wrapper.wrap(conditions);
StringBuffer sql = new StringBuffer();
sql.append("INSERT INTO ");
sql.append(tableName);
sql.append(" (");
Set<String> keys = paramJson.keySet();
Iterator<String> it = keys.iterator();
Iterator<String> iterator = keys.iterator();
while (it.hasNext()) {
String key = it.next();
sql.append(key);
if(it.hasNext()) {
sql.append(", ");
}
}
sql.append(") VALUES (");
while (iterator.hasNext()) {
String key = iterator.next();
sql.append(":");
sql.append(key);
if(iterator.hasNext()) {
sql.append(", ");
}
}
sql.append(") ON DUPLICATE KEY UPDATE ");
for (String condition : conditions) {
sql.append(condition);
sql.append(" = ");
if (dBUpdateEnum == DbUpdateEnum.NORMAL) {// 正常更新
sql.append(":" + condition);
} else {
sql.append(condition);
if (dBUpdateEnum == DbUpdateEnum.INCREMENT) {// 递增更新
sql.append(" + :");
} else {// 递减更新
sql.append(" - :");
}
sql.append(condition);
}
sql.append(", ");
}
sql = new StringBuffer(StringUtils.deleteLastEqualString(sql, ", "));
return (long) namedParameterJdbcTemplate.update(sql.toString(), paramJson);
}
// Page
@Override
public PageDTO pageDTOBuild(String tableName, PageIPO pageIPO, DbSortEnum dBSortEnum) {
// 1. 参数验证
paramValidate(tableName);
// 2. 处理分页参数
JSONObject paramJson = toParamJson(pageIPO);
JSONObject conditions = pageIPO.getConditions();
// 3. 预编译SQL拼接
StringBuffer querySql = new StringBuffer();
querySql.append("SELECT a.* FROM ");
querySql.append(tableName + " a, ");
querySql.append("(SELECT id FROM ");
querySql.append(tableName);
// 添加查询条件
String whereSql = "";
if (conditions != null) {
whereSql = paramToWhereSql(conditions);
}
querySql.append(whereSql);
// 排序
if (dBSortEnum == null) {// 默认（不排序）
querySql.append(getPageJoinSql()).append(") b WHERE a.id = b.id");
} else {
if (DbSortEnum.ASC == dBSortEnum) {// 升序
querySql.append(" ORDER BY ").append(DbConstant.PRIMARY_KEY).append(getPageJoinSql()).append(") b WHERE a.id = b.id");
} else {// 降序
querySql.append(" ORDER BY ").append(DbConstant.PRIMARY_KEY).append(" DESC ").append(getPageJoinSql()).append(") b WHERE a.id = b.id");
}
}
// 4. 统计总数
StringBuffer countSql = new StringBuffer();
countSql.append("SELECT COUNT(*) count FROM ");
countSql.append(tableName);
countSql.append(whereSql);
Long count = (Long) namedParameterJdbcTemplate.queryForMap(countSql.toString(), paramJson).get("count");
// 5. 返回结果
return PageDTO.builder().count(count).querySql(querySql.toString()).paramJson(paramJson).build();
}
@Override
public PageDTO pageDTOBuild(String tableName, String whereSql, PageIPO pageIPO) {
// 1. 参数验证
paramValidate(tableName, whereSql);
// 2. 处理分页参数
JSONObject paramJson = toParamJson(pageIPO);
// 3. 预编译SQL拼接
StringBuffer querySql = new StringBuffer();
querySql.append("SELECT a.* FROM ");
querySql.append(tableName + " a, ");
querySql.append(" (select id from ");
querySql.append(tableName);
querySql.append(" ");
querySql.append(whereSql);
querySql.append(getPageJoinSql()).append(") b WHERE a.id = b.id");
// 4. 统计总数
StringBuffer countSql = new StringBuffer();
countSql.append("SELECT COUNT(*) count FROM ");
countSql.append(tableName);
countSql.append(" ");
countSql.append(whereSql);
Long count = (Long) namedParameterJdbcTemplate.queryForMap(countSql.toString(), paramJson).get("count");
// 5. 返回结果
return PageDTO.builder().count(count).querySql(querySql.toString()).paramJson(paramJson).build();
}
@Override
public PageDTO pageDTOBuild(String querySql, PageIPO pageIPO) {
// 1. 参数校验
if (StringUtils.isEmpty(querySql)) {
throw new DbException("querySql不能为空");
}
// 2. 处理分页参数
JSONObject paramJson = toParamJson(pageIPO);
JSONObject conditions = pageIPO.getConditions();
// 3. 统计
int fromIndex = querySql.toUpperCase().indexOf("FROM");
String countStr = DbConstant.PAGE_COUNT_SQL_PREFIX + querySql.substring(fromIndex);
int limitIndex = countStr.toUpperCase().indexOf("LIMIT");
if (-1 == limitIndex) {
throw new DbException("querySql不能没有LIMIT");
}
int EndIndex = countStr.indexOf(")", limitIndex);
if (-1 == EndIndex) {
System.err.println("错误的querySql：\n");
System.err.println(querySql);
throw new DbException("querySql应当是一个优化后的语句，其中LIMIT必须放在子查询内，详细请参照示例语句编写。");
}
StringBuffer countSql = new StringBuffer(countStr);
countSql = countSql.delete(limitIndex, EndIndex);
Long count = (Long) namedParameterJdbcTemplate.queryForMap(countSql.toString(), conditions).get("count");
// 4. 返回结果
return PageDTO.builder().count(count).querySql(querySql.toString()).paramJson(paramJson).build();
}
@Override
public PageBeforeAndAfterVO pageBeforeAndAfter(String querySql, PageIPO pageIPO, Long equalsId) {
// 1. 参数校验
if (StringUtils.isEmpty(querySql)) {
throw new DbException("querySql不能为空");
}
// 2. 查询数据
JSONArray array = new JSONArray();
array.addAll(namedParameterJdbcTemplate.queryForList(querySql, toParamJson(pageIPO)));
int size = array.size();
// 3. 获得前后值
Long beforeId = null;
Long afterId = null;
String key = DbConstant.PRIMARY_KEY;
for (int i = 0; i < size; i++) {
JSONObject json = array.getJSONObject(i);
// 比较列表中相等的值，然后获取前一条与后一条数据
if (equalsId.equals(json.getLong(key))) {
if (i != 0) {// 不是列表中第一条数据
beforeId = array.getJSONObject(i - 1).getLong(key);
}
if (i != size - 1) {// 不是列表中最后一条数据
afterId = array.getJSONObject(i + 1).getLong(key);
}
break;
}
}
// 4. 返回结果
return PageBeforeAndAfterVO.builder()
.beforeId(beforeId)
.afterId(afterId)
.build();
}
// Update
@Override
public String updateSqlBuild(String tableName, JSONObject paramJson, String[] conditions, DbUpdateEnum dBUpdateEnum) {
paramValidate(tableName, paramJson, conditions);
StringBuffer sql = new StringBuffer();
sql.append("UPDATE ");
sql.append(wrapper.wrap(tableName));
sql.append(" SET ");
Set<String> keys = paramJson.keySet();
Iterator<String> it = keys.iterator();
while (it.hasNext()) {
String key = it.next();
// 排除更新条件
if (!ArrayUtil.contains(conditions, key)) {
sql.append(wrapper.wrap(key));
sql.append(" = ");
if (dBUpdateEnum == DbUpdateEnum.INCREMENT) {// 递增更新
sql.append(wrapper.wrap(key));
sql.append(" + :");
} else if (dBUpdateEnum == DbUpdateEnum.DECR // 递减更新
|| dBUpdateEnum == DbUpdateEnum.DECR_UNSIGNED) {// 递减-无符号更新
sql.append(wrapper.wrap(key));
sql.append(" - :");
} else {// 正常更新
sql.append(":");
}
sql.append(key);
sql.append(", ");
}
}
sql = new StringBuffer(StringUtils.deleteLastEqualString(sql, ", "));
String whereSql = paramToWhereSql(paramJson, conditions);
sql.append(whereSql);
if (dBUpdateEnum == DbUpdateEnum.DECR_UNSIGNED) {// 递减-无符号更新
List<String> updateKeys = MapUtils.keyList(paramJson);
for (String key : updateKeys) {
// 排除更新条件
if (!ArrayUtil.contains(conditions, key)) {
sql.append(" AND ");
sql.append(wrapper.wrap(key));
sql.append(" >= :");
sql.append(key);
}
}
}
return sql.toString();
}
}
|
0 | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc/client/dialect | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc/client/dialect/impl/PostgresqlDialect.java | package ai.yue.library.data.jdbc.client.dialect.impl;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
import ai.yue.library.data.jdbc.client.dialect.AnsiSqlDialect;
import ai.yue.library.data.jdbc.client.dialect.DialectName;
import ai.yue.library.data.jdbc.client.dialect.Wrapper;
/**
* Postgree方言
* <p>TODO 暂未实现
*
* @author ylyue
* @since 2020年6月13日
*/
public abstract class PostgresqlDialect extends AnsiSqlDialect {
private static final long serialVersionUID = 3889210427543389642L;
public PostgresqlDialect(NamedParameterJdbcTemplate namedParameterJdbcTemplate) {
super.wrapper = new Wrapper('"');
super.dialect = this;
super.namedParameterJdbcTemplate = namedParameterJdbcTemplate;
}
@Override
public DialectName dialectName() {
return DialectName.POSTGREESQL;
}
}
|
0 | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc/client/dialect | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc/client/dialect/impl/package-info.java | /**
* SQL方言实现
*
* @author ylyue
* @since 2020年6月13日
*/
package ai.yue.library.data.jdbc.client.dialect.impl; |
0 | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc/config/JdbcAutoConfig.java | package ai.yue.library.data.jdbc.config;
import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.boot.autoconfigure.jdbc.JdbcTemplateAutoConfiguration;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
import ai.yue.library.data.jdbc.client.Db;
import ai.yue.library.data.jdbc.client.dialect.impl.MysqlDialect;
import ai.yue.library.data.jdbc.config.properties.JdbcProperties;
/**
* data-jdbc配置，提供自动配置项支持与增强
*
* @author ylyue
* @since 2018年6月11日
*/
@Configuration
@AutoConfigureAfter(JdbcTemplateAutoConfiguration.class)
@EnableConfigurationProperties({ JdbcProperties.class })
public class JdbcAutoConfig {
@Bean
@Primary
@ConditionalOnBean({JdbcTemplate.class, NamedParameterJdbcTemplate.class})
public Db db(JdbcTemplate jdbcTemplate, NamedParameterJdbcTemplate namedParameterJdbcTemplate) {
return new Db(jdbcTemplate, namedParameterJdbcTemplate, new MysqlDialect(namedParameterJdbcTemplate));
}
}
|
0 | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc/config/package-info.java | /**
* data-jdbc自动配置项
*
* @author ylyue
* @since 2019年10月14日
*/
package ai.yue.library.data.jdbc.config; |
0 | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc/config | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc/config/properties/JdbcProperties.java | package ai.yue.library.data.jdbc.config.properties;
import org.springframework.boot.context.properties.ConfigurationProperties;
import ai.yue.library.base.constant.FieldNamingStrategyEnum;
import lombok.Data;
/**
* jdbc可配置属性
*
* @author ylyue
* @since 2018年11月6日
*/
@Data
@ConfigurationProperties("yue.jdbc")
public class JdbcProperties {
/**
* 数据库字段命名策略
* <p>默认：SNAKE_CASE
*/
private FieldNamingStrategyEnum databaseFieldNamingStrategy = FieldNamingStrategyEnum.SNAKE_CASE;
/**
* 启用数据库字段命名策略识别
* <p>默认：true
*/
private boolean enableFieldNamingStrategyRecognition = true;
}
|
0 | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc/constant/DbConstant.java | package ai.yue.library.data.jdbc.constant;
import ai.yue.library.data.jdbc.client.Db;
/**
* {@linkplain Db} 常量类
*
* @author ylyue
* @since 2018年7月18日
*/
public interface DbConstant {
// 关键字段
/**
* 关键字段定义-delete_time
* <p>数据删除标识
*/
String FIELD_DEFINITION_DELETE_TIME = "delete_time";
// 关键字段-默认值定义
/**
* 关键字段默认值定义-delete_time
* <p>删除时间戳默认值 0 == 未删除
*/
Long FIELD_DEFAULT_VALUE_DELETE_TIME = 0L;
// 命名占位符（具名参数）
/** 命名占位符-主键 **/
// String NAMED_PARAMETER_PRIMARY_KEY = ":id";
/** 命名占位符-数据删除标识字段 */
String NAMED_PARAMETER_DELETE_TIME = ":delete_time";
// 字段
/** 主键 */
String PRIMARY_KEY = "id";
// SQL
/** 分页统计SQL前缀 */
String PAGE_COUNT_SQL_PREFIX = "SELECT count(*) count ";
}
|
0 | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc/constant/DbExpectedValueModeEnum.java | package ai.yue.library.data.jdbc.constant;
/**
* 预期值方式枚举
*
* @author ylyue
* @since 2018年9月18日
*/
public enum DbExpectedValueModeEnum {
/** 等于 */
EQUAL,
/** 大于等于 */
GREATER_THAN_EQUAL;
}
|
0 | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc/constant/DbSortEnum.java | package ai.yue.library.data.jdbc.constant;
/**
* 排序方式
*
* @author ylyue
* @since 2018年8月29日
*/
public enum DbSortEnum {
/** 升序 */
ASC,
/** 降序 */
DESC;
}
|
0 | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc/constant/DbUpdateEnum.java | package ai.yue.library.data.jdbc.constant;
/**
* 更新类型
*
* @author ylyue
* @since 2018年8月29日
*/
public enum DbUpdateEnum {
/** 正常 */
NORMAL,
/** 递增 */
INCREMENT,
/** 递减 */
DECR,
/** 递减_无符号 */
DECR_UNSIGNED;
}
|
0 | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc/constant/FieldNamingStrategyEnum.java | package ai.yue.library.data.jdbc.constant;
import com.alibaba.fastjson.PropertyNamingStrategy;
import lombok.AllArgsConstructor;
import lombok.Getter;
/**
* 数据库字段命名策略
*
* @deprecated {@linkplain ai.yue.library.base.constant.FieldNamingStrategyEnum}
* @author ylyue
* @since 2020年2月20日
*/
@Getter
@AllArgsConstructor
@Deprecated
public enum FieldNamingStrategyEnum {
/**
* 驼峰命名法，即：小驼峰命名法
* <p>CAMEL_CASE策略，Java对象属性：personId，序列化后属性：persionId
*/
CAMEL_CASE(PropertyNamingStrategy.CamelCase),
/**
* 小驼峰命名法
* <p>{@link #CAMEL_CASE}
*/
LOWER_CAMEL_CASE(PropertyNamingStrategy.CamelCase),
/**
* 大驼峰命名法
* <p>{@link #PASCAL_CASE}
*/
UPPER_CAMEL_CASE(PropertyNamingStrategy.PascalCase),
/**
* 帕斯卡命名法，即：大驼峰命名法
* <p>PASCAL_CASE策略，Java对象属性：personId，序列化后属性：PersonId
*/
PASCAL_CASE(PropertyNamingStrategy.PascalCase),
/**
* 下划线命名法
* <p>SNAKE_CASE策略，Java对象属性：personId，序列化后属性：person_id
*/
SNAKE_CASE(PropertyNamingStrategy.SnakeCase),
/**
* 中划线命名法
* <p>KEBAB_CASE策略，Java对象属性：personId，序列化后属性：person-id
*/
KEBAB_CASE(PropertyNamingStrategy.KebabCase);
private PropertyNamingStrategy propertyNamingStrategy;
}
|
0 | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc/constant/package-info.java | /**
* 常量定义
*
* @author ylyue
* @since 2019年10月14日
*/
package ai.yue.library.data.jdbc.constant; |
0 | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc/dao/AbstractDAO.java | package ai.yue.library.data.jdbc.dao;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import com.alibaba.fastjson.JSONObject;
import ai.yue.library.data.jdbc.client.Db;
import ai.yue.library.data.jdbc.constant.DbSortEnum;
import ai.yue.library.data.jdbc.ipo.PageIPO;
import ai.yue.library.data.jdbc.vo.PageVO;
/**
* AbstractDAO 为 JSON 对象提供服务
*
* @author ylyue
* @since 2019年4月30日
*/
public abstract class AbstractDAO {
@Autowired
protected Db db;
protected String tableName = tableName();
protected abstract String tableName();
/**
* 插入数据
* @param paramJson 参数
* @return 返回主键值
*/
public Long insert(JSONObject paramJson) {
return db.insert(tableName(), paramJson);
}
/**
* 插入数据-批量
* @param paramJsons 参数
*/
public void insertBatch(JSONObject[] paramJsons) {
db.insertBatch(tableName(), paramJsons);
}
/**
* 删除
* @param id 主键id
*/
public void delete(Long id) {
db.delete(tableName(), id);
}
/**
* 删除-安全的
* <p>数据删除前会先进行条数确认
*
* @param id 主键id
*/
public void deleteSafe(Long id) {
db.deleteSafe(tableName(), id);
}
/**
* 更新-ById
* @param paramJson 更新所用到的参数（包含主键ID字段）
*/
public void updateById(JSONObject paramJson) {
db.updateById(tableName(), paramJson);
}
/**
* 单个
* @param id 主键id
* @return JSON数据
*/
public JSONObject get(Long id) {
return db.getById(tableName(), id);
}
/**
* 列表-全部
* @return 列表数据
*/
public List<JSONObject> listAll() {
return db.listAll(tableName());
}
/**
* 分页
* @param pageIPO 分页查询参数 {@linkplain PageIPO}，所有的条件参数，都将以等于的形式进行SQL拼接
* @return count（总数），data（分页列表数据）
*/
public PageVO page(PageIPO pageIPO) {
return db.page(tableName(), pageIPO);
}
/**
* 分页-降序
* @param pageIPO 分页查询参数 {@linkplain PageIPO}，所有的条件参数，都将以等于的形式进行SQL拼接
* @return count（总数），data（分页列表数据）
*/
public PageVO pageDESC(PageIPO pageIPO) {
return db.page(tableName(), pageIPO, DbSortEnum.DESC);
}
}
|
0 | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc/dao/AbstractRepository.java | package ai.yue.library.data.jdbc.dao;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.PropertyNamingStrategy;
import com.alibaba.fastjson.serializer.SerializeConfig;
import ai.yue.library.base.constant.FieldNamingStrategyEnum;
import ai.yue.library.base.convert.Convert;
import ai.yue.library.data.jdbc.client.Db;
import ai.yue.library.data.jdbc.config.properties.JdbcProperties;
import ai.yue.library.data.jdbc.constant.DbSortEnum;
import ai.yue.library.data.jdbc.ipo.PageIPO;
import ai.yue.library.data.jdbc.vo.PageTVO;
import cn.hutool.core.util.ClassUtil;
/**
* AbstractRepository 为 DO 对象提供服务，字段映射支持下划线与驼峰自动识别转换
*
* @author ylyue
* @since 2019年4月30日
* @param <T> 映射类
*/
public abstract class AbstractRepository<T> {
@Autowired
protected Db db;
@Autowired
private JdbcProperties jdbcProperties;
@SuppressWarnings("unchecked")
protected Class<T> mappedClass = (Class<T>) ClassUtil.getTypeArgument(getClass());
protected String tableName = tableName();
protected abstract String tableName();
/**
* 插入数据
*
* @param paramJson 参数
* @return 返回主键值
*/
public Long insert(JSONObject paramJson) {
return db.insert(tableName(), paramJson);
}
/**
* 插入数据-实体
* <p>默认进行 {@link FieldNamingStrategyEnum#SNAKE_CASE} 数据库字段命名策略转换
*
* @param paramIPO 参数IPO（POJO-IPO对象）
* @return 返回主键值
*/
public Long insert(Object paramIPO) {
if (jdbcProperties.isEnableFieldNamingStrategyRecognition()) {
return insert(paramIPO, jdbcProperties.getDatabaseFieldNamingStrategy());
}
return insert(Convert.toJSONObject(paramIPO));
}
/**
* 插入数据-实体
*
* @param paramIPO 参数IPO（POJO-IPO对象）
* @param databaseFieldNamingStrategyEnum 数据库字段命名策略
* @return 返回主键值
*/
public Long insert(Object paramIPO, FieldNamingStrategyEnum databaseFieldNamingStrategyEnum) {
PropertyNamingStrategy propertyNamingStrategy = databaseFieldNamingStrategyEnum.getPropertyNamingStrategy();
SerializeConfig serializeConfig = new SerializeConfig();
serializeConfig.setPropertyNamingStrategy(propertyNamingStrategy);
JSONObject paramJson = (JSONObject) JSONObject.toJSON(paramIPO, serializeConfig);
return insert(paramJson);
}
/**
* 插入数据-批量
* @param paramJsons 参数
*/
public void insertBatch(JSONObject[] paramJsons) {
db.insertBatch(tableName(), paramJsons);
}
/**
* 删除
* @param id 主键id
*/
public void delete(Long id) {
db.delete(tableName(), id);
}
/**
* 删除-安全的
* <p>数据删除前会先进行条数确认
*
* @param id 主键id
*/
public void deleteSafe(Long id) {
db.deleteSafe(tableName(), id);
}
/**
* 更新-ById
* @param paramJson 更新所用到的参数（包含主键ID字段）
*/
public void updateById(JSONObject paramJson) {
db.updateById(tableName(), paramJson);
}
/**
* 单个
* @param id 主键ID
* @return POJO对象
*/
public T get(Long id) {
return db.getById(tableName(), id, mappedClass);
}
/**
* 列表-全部
* @return 列表数据
*/
public List<T> listAll() {
return db.listAll(tableName(), mappedClass);
}
/**
* 分页
* @param pageIPO 分页查询参数 {@linkplain PageIPO}，所有的条件参数，都将以等于的形式进行SQL拼接
* @return count（总数），data（分页列表数据）
*/
public PageTVO<T> page(PageIPO pageIPO) {
return db.page(tableName(), pageIPO, mappedClass);
}
/**
* 分页-降序
* @param pageIPO 分页查询参数 {@linkplain PageIPO}，所有的条件参数，都将以等于的形式进行SQL拼接
* @return count（总数），data（分页列表数据）
*/
public PageTVO<T> pageDESC(PageIPO pageIPO) {
return db.page(tableName(), pageIPO, mappedClass, DbSortEnum.DESC);
}
}
|
0 | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc/dao/package-info.java | /**
* DAO默认实现
*
* @author ylyue
* @since 2019年10月14日
*/
package ai.yue.library.data.jdbc.dao; |
0 | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc/dataobject/BaseLowerCamelCaseDO.java | package ai.yue.library.data.jdbc.dataobject;
import java.io.Serializable;
import java.time.LocalDateTime;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
/**
* 小驼峰命名法DO基类
*
* <p><b><code style="color:red">注意：继承 {@link BaseLowerCamelCaseDO} get set ... 采用 @{@link Data} 注解生成时，需加上：</code></b>
* <blockquote>
* <p>@ToString(callSuper = true)
* <p>@EqualsAndHashCode(callSuper = true)
* </blockquote>
*
* @author ylyue
* @since 2018年7月26日
*/
@Data
@NoArgsConstructor
@SuperBuilder(toBuilder = true)
public abstract class BaseLowerCamelCaseDO implements Serializable {
private static final long serialVersionUID = 2241197545628586478L;
protected Long id;// 主键ID，单表时自增
protected Integer sortIdx;// 排序索引
/**
* 删除时间戳
* <p>默认值为0 == 未删除
* <p>一般不作查询展示
*/
protected Long deleteTime;
protected LocalDateTime createTime;// 数据插入时间
protected LocalDateTime updateTime;// 数据更新时间
}
|
0 | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc/dataobject/BaseSnakeCaseDO.java | package ai.yue.library.data.jdbc.dataobject;
import java.io.Serializable;
import java.time.LocalDateTime;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
/**
* 下划线命名法DO基类
*
* <p><b><code style="color:red">注意：继承 {@link BaseSnakeCaseDO} get set ... 采用 @{@link Data} 注解生成时，需加上：</code></b>
* <blockquote>
* <p>@ToString(callSuper = true)
* <p>@EqualsAndHashCode(callSuper = true)
* </blockquote>
*
* @author ylyue
* @since 2018年7月26日
*/
@Data
@NoArgsConstructor
@SuperBuilder(toBuilder = true)
public abstract class BaseSnakeCaseDO implements Serializable {
private static final long serialVersionUID = 3601450189220851200L;
protected Long id;// 表自增ID
protected Integer sort_idx;// 排序索引
/**
* 删除时间戳
* <p>默认值为0 == 未删除
* <p>一般不作查询展示
*/
protected Long delete_time;
protected LocalDateTime create_time;// 数据插入时间
protected LocalDateTime update_time;// 数据更新时间
}
|
0 | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc/dataobject/package-info.java | /**
* DO默认实现
*
* @author ylyue
* @since 2019年10月14日
*/
package ai.yue.library.data.jdbc.dataobject; |
0 | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc/dto/PageDTO.java | package ai.yue.library.data.jdbc.dto;
import com.alibaba.fastjson.JSONObject;
import lombok.Builder;
import lombok.Getter;
/**
* 分页处理传输对象
*
* @author ylyue
* @since 2018年7月24日
*/
@Getter
@Builder
public class PageDTO {
Long count;
String querySql;
JSONObject paramJson;
}
|
0 | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc/dto/package-info.java | /**
* DTO定义
*
* @author ylyue
* @since 2019年10月14日
*/
package ai.yue.library.data.jdbc.dto; |
0 | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc/ipo/Page.java | package ai.yue.library.data.jdbc.ipo;
import com.alibaba.fastjson.JSONObject;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.NonNull;
/**
* 分页查询对象，用于SQL分页查询
*
* @author ylyue
* @since 2018年4月13日
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class Page {
/** LIMIT关键字 */
public static final String LIMIT_KEYWORD = "LIMIT";
/** 分页查询起始行命名占位符 **/
public static final String PAGE_NAMED_PARAMETER = ":page";
/** 分页查询限制数量命名占位符 */
public static final String LIMIT_NAMED_PARAMETER = ":limit";
/** page参数名 **/
public static final String PAGE_PARAM_NAME = "page";
/** limit参数名 */
public static final String LIMIT_PARAM_NAME = "limit";
/**
* 查询起始行，从0开始计数，包含关系
* <p>当前条件下，从第几行开始查询
*/
@NonNull
Long page;
/**
* 查询限制数量
* <p>你想要查询多少条数据
*/
@NonNull
Integer limit;
/**
* 查询条件（null表示无条件）
*/
JSONObject conditions;
/**
* 转换为Db参数Json
*
* @return paramJson
*/
public JSONObject toParamJson() {
JSONObject paramJson = new JSONObject();
paramJson.put(PAGE_PARAM_NAME, this.page);
paramJson.put(LIMIT_PARAM_NAME, this.limit);
if (null != conditions && !conditions.isEmpty()) {
paramJson.putAll(conditions);
}
return paramJson;
}
}
|
0 | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc/ipo/PageIPO.java | package ai.yue.library.data.jdbc.ipo;
import com.alibaba.fastjson.JSONObject;
import ai.yue.library.base.exception.ParamException;
import ai.yue.library.base.view.ResultPrompt;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.NonNull;
/**
* 分页请求对象，用于SQL分页查询请求
*
* @author ylyue
* @since 2018年4月13日
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class PageIPO {
@NonNull
Integer page;// 当前页
@NonNull
Integer limit;// 每页显示的条数
JSONObject conditions;// 查询条件（null表示无条件）
/**
* 将分页参数转换为分页对象
* <p>{@linkplain JSONObject} - {@linkplain PageIPO}
*
* @param paramJson 最大limit值 = 200
* @return pageIPO
*/
public static PageIPO parsePageIPO(JSONObject paramJson) {
return parsePageIPO(paramJson, 200);
}
/**
* 将分页参数转换为分页对象
* <p>{@linkplain JSONObject} - {@linkplain PageIPO}
*
* @param paramJson 参数
* @param maxLimit 最大限制
* @return pageIPO
*/
public static PageIPO parsePageIPO(JSONObject paramJson, int maxLimit) {
Integer page = paramJson.getInteger("page");
Integer limit = paramJson.getInteger("limit");
if (null == page || null == limit) {
throw new ParamException("null == page || null == limit");
}
paramJson.remove("page");
paramJson.remove("limit");
if (limit > maxLimit) {
throw new ParamException(ResultPrompt.MAX_LIMIT);
}
return PageIPO.builder().page(page).limit(limit).conditions(paramJson).build();
}
}
|
0 | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc | java-sources/ai/ylyue/yue-library-data-jdbc/2.1.0/ai/yue/library/data/jdbc/ipo/package-info.java | /**
* IPO定义
*
* @author ylyue
* @since 2019年10月14日
*/
package ai.yue.library.data.jdbc.ipo; |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.