Skip to content

G
gf_back
Commit 372b9739 authored by ZWT's avatar ZWT
Browse files
Options

feat(零碳): 长庆演示系统新增功能 

1.新建油田配置表同时生成相关代码及mapper文件,修改部分第三方数据抽取定时任务,增加针对不同井场开关控制逻辑,同时修改首页页面展示逻辑,通过油田配置功能区分不同首页展示功能;
2.新建定时任务配置表同时生成相关代码及mapper文件,定时任务模块增加mybatis配置,用以操作数据库,修改部分第三方数据抽取定时任务,修改使用方式使其脱离框架方便动态控制;

BREAKING CHANGE: 无

Closes 无

[skip ci]
parent efd7bba6
Show whitespace changes
Inline Side-by-side
Showing with 5 additions and 3912 deletions
C00-common/pps-common/src/main/java/pps/core/common/job/CounterJob5S.java deleted 100644 → 0
View file @ efd7bba6
package pps.core.common.job;
import cn.hutool.core.text.CharSequenceUtil;
import pps.core.common.utils.*;
import xstartup.base.XStartup;
import xstartup.base.util.XJsonUtils;
import java.util.Set;
import java.util.concurrent.atomic.AtomicBoolean;
public class CounterJob5S {
public static final String CLUSTER_GLOBAL_COUNTER = "counter.cluster_global_counter";
public static final String CLUSTER_GLOBAL_COUNTER_LOCK = "counter.cluster_global_counter_lock";
public static final TimeSpanChecker publishChecker = new TimeSpanChecker(15, true);
public static boolean EnableJob = false;
private static AtomicBoolean master = new AtomicBoolean(false);
public static void executeJob() {
if (!EnableJob) {
return;
}
if (!publishChecker.checkNow()) {
return;
}
CounterBuilder.globalCounterBuilder.addCounter("CounterJob-Timer");
CounterBuilder.globalCounterBuilder.setFieldValue("CounterJob-Timer-LatestTime", DateUtil.getCurrentDateTime());
CounterBuilder.globalCounterBuilder.setFieldValue("__IPS__", IpUtils.getHostIPs(true));
CounterBuilder.globalCounterBuilder.setFieldValue("__TASKS_RUNNING__", GlobalExecutorService.INSTANCE.getRunningTasksCount() + "");
CounterBuilder.globalCounterBuilder.setFieldValue("__TASKS_DONE__", GlobalExecutorService.INSTANCE.getTasksCount() + "");
CounterBuilder.globalCounterBuilder.setFieldValue("__TASKS_RUNNING(SCADA)___", ScadaExecutorService.INSTANCE.getRunningTasksCount() + "");
CounterBuilder.globalCounterBuilder.setFieldValue("__TASKS_DONE(SCADA)__", ScadaExecutorService.INSTANCE.getTasksCount() + "");
CounterBuilder.globalCounterBuilder.setFieldValue("__TRACEBUILDERS__", TraceHelper.getTraceBuildersCount() + "");
DynObj dynObj = CounterBuilder.globalCounterBuilder.toDynObj();
dynObj.put(CounterBuilder.COUNTER_NAME_INSTANCE, CounterBuilder.globalCounterBuilder.counterId);
dynObj.put("__LATEST_TIMER_TIME__", DateUtil.getCurrentDateTime());
dynObj.put("__PUBLISH_TIME__", DateUtil.getCurrentDateTime());
dynObj.put("__THREADS__", ThreadHelper.buildThreadsSimpleInfos(null));
long publishStart = System.currentTimeMillis();
publish(dynObj);
long publishEnd = System.currentTimeMillis();
CounterBuilder.globalCounterBuilder.setFieldValue("CounterJob-Publish-UsedSecnods", (publishEnd - publishStart) / 1000 + "");
}
public static String getAppClusterName() {
String appName = XStartup.getApplication().getName();
String env = XStartup.getApplication().getEnv().name();
String appClusterName = CLUSTER_GLOBAL_COUNTER + "_" + env + "_" + appName;
return appClusterName;
}
public static String getAppClusterLockName() {
String appName = XStartup.getApplication().getName();
String env = XStartup.getApplication().getEnv().name();
String appClusterLockName = CLUSTER_GLOBAL_COUNTER_LOCK + "_" + env + "_" + appName;
return appClusterLockName;
}
private static void publish(DynObj dynObj) {
CounterBuilder.globalCounterBuilder.addCounter("CounterJob-publish-begin");
try {
String myNodeKey = String.format("counter.%s.%s", dynObj.getString(CounterBuilder.DEPLOY_KEY, "UnknownDeploy"), CounterBuilder.globalCounterBuilder.counterId);
dynObj.put(CounterBuilder.COUNTER_NAME_OWNER, myNodeKey);
String cacheType = XStartup.getCurrent().getProperty("x.cache.type");
String appClusterName = getAppClusterName();
String appClusterLockName = getAppClusterLockName();
if ("redis-cluster".equals(cacheType)) {
JedisHelper.consumeDefalutJedisCluster((jedis) -> {
// 记录到集群中
jedis.sadd(appClusterName, myNodeKey);
// 集群3分钟过期
jedis.expire(appClusterName, 3 * 20);
boolean isMaster = false;
long success = jedis.setnx(appClusterLockName, myNodeKey);
if (success != 0) {
jedis.expire(appClusterLockName, 40);
isMaster = true;
}
String lockKey = jedis.get(appClusterLockName);
if (myNodeKey.equals(lockKey)) {
jedis.expire(appClusterLockName, 40);
isMaster = true;
}
master.set(isMaster);
CounterBuilder.globalCounterBuilder.setFieldValue("__MASTER__", isMaster + "");
if (isMaster) {
if (CharSequenceUtil.isBlank(CounterBuilder.globalCounterBuilder.getFieldValue("__MASTER-TIME__"))) {
CounterBuilder.globalCounterBuilder.setFieldValue("__MASTER-TIME__", DateUtil.getCurrentDateTime());
CounterBuilder.globalCounterBuilder.addCounter("__MASTER-TIMES__");
}
} else {
if (CharSequenceUtil.isNotBlank(CounterBuilder.globalCounterBuilder.getFieldValue("__MASTER-TIME__"))) {
CounterBuilder.globalCounterBuilder.setFieldValue("__MASTER-TIME__", "");
}
// onlineNodes.clear();
}
CounterBuilder.globalCounterBuilder.addCounter("CounterJob-PublishToRedis");
CounterBuilder.globalCounterBuilder.setFieldValue("CounterJob-PublishToRedis-TIME", DateUtil.getCurrentDateTime());
// 记录到redis ,3 * 30s过期
jedis.setex(myNodeKey, 3 * 20, XJsonUtils.toJson(dynObj));
if (isMaster) {
CounterBuilder.globalCounterBuilder.addCounter("CounterJob-Timer-MASTER");
Set<String> nodeKeys = jedis.smembers(appClusterName);
nodeKeys.forEach(k -> {
if (!jedis.exists(k)) {
jedis.srem(appClusterName, k);
CounterBuilder.globalCounterBuilder.addCounter("Remove-Node");
} else {
}
});
} else {
CounterBuilder.globalCounterBuilder.addCounter("CounterJob-Timer-NOTMASTER");
}
});
} else {
JedisHelper.consumeDefalutJedis((jedis) -> {
// 记录到集群中
jedis.sadd(appClusterName, myNodeKey);
// 集群3分钟过期
jedis.expire(appClusterName, 3 * 20);
boolean isMaster = false;
long success = jedis.setnx(appClusterLockName, myNodeKey);
if (success != 0) {
jedis.expire(appClusterLockName, 40);
isMaster = true;
}
String lockKey = jedis.get(appClusterLockName);
if (myNodeKey.equals(lockKey)) {
jedis.expire(appClusterLockName, 40);
isMaster = true;
}
master.set(isMaster);
CounterBuilder.globalCounterBuilder.setFieldValue("__MASTER__", isMaster + "");
if (isMaster) {
if (CharSequenceUtil.isBlank(CounterBuilder.globalCounterBuilder.getFieldValue("__MASTER-TIME__"))) {
CounterBuilder.globalCounterBuilder.setFieldValue("__MASTER-TIME__", DateUtil.getCurrentDateTime());
CounterBuilder.globalCounterBuilder.addCounter("__MASTER-TIMES__");
}
} else {
if (CharSequenceUtil.isNotBlank(CounterBuilder.globalCounterBuilder.getFieldValue("__MASTER-TIME__"))) {
CounterBuilder.globalCounterBuilder.setFieldValue("__MASTER-TIME__", "");
}
}
CounterBuilder.globalCounterBuilder.addCounter("CounterJob-PublishToRedis");
CounterBuilder.globalCounterBuilder.setFieldValue("CounterJob-PublishToRedis-TIME", DateUtil.getCurrentDateTime());
// 记录到redis ,3 * 30s过期
jedis.setex(myNodeKey, 3 * 20, XJsonUtils.toJson(dynObj));
if (isMaster) {
CounterBuilder.globalCounterBuilder.addCounter("CounterJob-Timer-MASTER");
Set<String> nodeKeys = jedis.smembers(appClusterName);
nodeKeys.forEach(k -> {
if (!jedis.exists(k)) {
jedis.srem(appClusterName, k);
CounterBuilder.globalCounterBuilder.addCounter("Remove-Node");
} else {
}
});
} else {
CounterBuilder.globalCounterBuilder.addCounter("CounterJob-Timer-NOTMASTER");
}
});
}
} catch (Exception ex) {
CounterBuilder.globalCounterBuilder.addCounter(ex, CounterJob5S.class);
}
}
}
C00-common/pps-common/src/main/java/pps/core/common/job/TempCleanJob5S.java deleted 100644 → 0
View file @ efd7bba6
package pps.core.common.job;
import pps.core.common.utils.CounterBuilder;
import pps.core.common.utils.TimeSpanChecker;
import pps.core.common.utils.TraceHelper;
import xstartup.base.XContext;
import xstartup.base.tool.XStorageTool;
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.attribute.BasicFileAttributes;
import java.util.concurrent.ConcurrentHashMap;
import java.util.regex.Pattern;
public class TempCleanJob5S {
public static final TimeSpanChecker jobChecker = new TimeSpanChecker(60 * 60, true);
public static final ConcurrentHashMap<String, String[]> tempFilePatttern = new ConcurrentHashMap<>();
public static boolean EnableJob = true;
static {
tempFilePatttern.put("/var/tmp/", new String[]{"^tracelog-\\d+.txt$"});
}
public static void executeTimerJob(XContext context) {
if (!EnableJob) {
return;
}
if (!jobChecker.checkNow()) {
return;
}
executeJob(context);
}
public static void executeJob(XContext context) {
tempFilePatttern.forEach((k, v) -> {
checkAndCleanTempFile(context, k, v);
});
}
private static void checkAndCleanTempFile(XContext context, String folder, String[] filePatterns) {
try {
String absoluteFolderPath = XStorageTool.getAbsolutePath(folder);
TraceHelper.appendTraceLog(context, "absolutePath", absoluteFolderPath);
File absoluteFolderPathFile = new File(absoluteFolderPath);
if (!absoluteFolderPathFile.exists()) {
TraceHelper.appendTraceLog(context, "ERROR", absoluteFolderPath + " not exists");
return;
}
String[] files = absoluteFolderPathFile.list();
for (String file : files) {
TraceHelper.appendTraceLog(context, "", file);
for (String pattern : filePatterns) {
if (Pattern.compile(pattern).matcher(file).find()) {
TraceHelper.appendTraceLog(context, "FOUND", file);
File f = new File(absoluteFolderPath, file);
try {
if (checkTimeAndDeleteFile(f)) {
TraceHelper.appendTraceLog(context, "Removed", absoluteFolderPathFile.getAbsolutePath());
}
} catch (Exception ex2) {
TraceHelper.appendTraceLog(context, ex2);
}
break;
}
}
}
} catch (Exception ex) {
CounterBuilder.globalCounterBuilder.addCounter(ex);
CounterBuilder.globalCounterBuilder.addCounter("checkAndCleanTempFile-ERROR-" + folder);
}
}
private static boolean checkTimeAndDeleteFile(File file) throws IOException {
Path path = file.toPath();
BasicFileAttributes file_att = Files.readAttributes(
path, BasicFileAttributes.class);
long createTime = file_att.creationTime().toMillis();
long now = System.currentTimeMillis();
if (now - createTime < TimeSpanChecker.TIMESPAN_MS_1d) {
return false;
}
file.delete();
return true;
}
}
\ No newline at end of file
C00-common/pps-common/src/main/java/pps/core/common/provider/impl/PpsConfigProviderCommonImpl.java deleted 100644 → 0
View file @ efd7bba6
package pps.core.common.provider.impl;
import cn.hutool.core.text.CharSequenceUtil;
import pps.core.common.cache.ConfigCache;
import pps.core.common.utils.CounterBuilder;
import xstartup.annotation.XImplement;
import xstartup.base.XContext;
import xstartup.kernel.system.provider.spec.XConfigProvider;
/**
* @author lixueyan
* @date 2022/8/5 0005 17:11
*/
@XImplement
public class PpsConfigProviderCommonImpl implements XConfigProvider {
@Override
public String findValue(XContext context, String config, String app, String key) {
// 实现自定义配置逻辑， 优先级 从低到高 数据库->properties文件
//从Properties文件中加载配置值
String configKey = config + "." + key;
String configKeyWithAppName = config + "." + app + "." + key;
String configValue = context.getProperty(configKeyWithAppName);
if (CharSequenceUtil.isBlank(configValue)) {
configValue = context.getProperty(configKey);
}
//加载缓存
final String configValue_ = configValue;
ConfigCache configCache = ConfigCache.get(context, configKey, false, () -> {
try {
CounterBuilder.globalCounterBuilder.addCounter("getConfig-Failed-" + configKey);
// 使用Properties配置文件配置
return configValue_;
} catch (Exception ex) {
CounterBuilder.globalCounterBuilder.addCounter(ex, this.getClass());
return configValue_;
}
});
//返回缓存缺省值
return configCache == null ? configValue_ : configCache.getConfigValue();
}
}
C00-common/pps-common/src/main/java/pps/core/common/service/data/CounterOutput.java deleted 100644 → 0
View file @ efd7bba6
package pps.core.common.service.data;
import pps.core.common.utils.DynObj;
public class CounterOutput extends DynObj {
}
C00-common/pps-common/src/main/java/pps/core/common/utils/ConvertUtils.java deleted 100644 → 0
View file @ efd7bba6
package pps.core.common.utils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeanUtils;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
/**
* 转换工具类
*
* @author lixueyan
*/
public class ConvertUtils {
private static Logger logger = LoggerFactory.getLogger(ConvertUtils.class);
public static <T> T sourceToTarget(Object source, Class<T> target) {
if (source == null) {
return null;
}
T targetObject = null;
try {
targetObject = target.newInstance();
BeanUtils.copyProperties(source, targetObject);
} catch (Exception e) {
logger.error("convert error ", e);
}
return targetObject;
}
public static <T> List<T> sourceToTarget(Collection<?> sourceList, Class<T> target) {
if (sourceList == null) {
return null;
}
List targetList = new ArrayList<>(sourceList.size());
try {
for (Object source : sourceList) {
T targetObject = target.newInstance();
BeanUtils.copyProperties(source, targetObject);
targetList.add(targetObject);
}
} catch (Exception e) {
logger.error("convert error ", e);
}
return targetList;
}
}
C00-common/pps-common/src/main/java/pps/core/common/utils/CounterBuilder.java
View file @ 372b9739
package pps.core.common.utils; package pps.core.common.utils;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.text.CharSequenceUtil; import cn.hutool.core.text.CharSequenceUtil;
import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableList;
...@@ -21,15 +22,14 @@ public class CounterBuilder { ...@@ -21,15 +22,14 @@ public class CounterBuilder {
public static final String COUNTER_NAME_BUILDTIME = "__BUILDTIME__"; public static final String COUNTER_NAME_BUILDTIME = "__BUILDTIME__";
private final static ConcurrentHashMap<String, CounterBuilder> counterBuilders = new ConcurrentHashMap<>(); private final static ConcurrentHashMap<String, CounterBuilder> counterBuilders = new ConcurrentHashMap<>();
public final String counterId = UUID.randomUUID().toString(); public final String counterId = UUID.randomUUID().toString();
// private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); private final ConcurrentHashMap<String, String> fieldValueMap = new ConcurrentHashMap<>();
private final ConcurrentHashMap<String, String> fieldValueMap = new ConcurrentHashMap<String, String>();
private final ConcurrentHashMap<String, AtomicLong> counterMap = new ConcurrentHashMap<>(); private final ConcurrentHashMap<String, AtomicLong> counterMap = new ConcurrentHashMap<>();
private final ConcurrentHashMap<String, CounterBuildItemInfoType> fileInfoTypeMap = new ConcurrentHashMap<>(); private final ConcurrentHashMap<String, CounterBuildItemInfoType> fileInfoTypeMap = new ConcurrentHashMap<>();
private String groupName; private String groupName;
public CounterBuilder() { public CounterBuilder() {
this.setFieldValue("__COUNTERID__", counterId); this.setFieldValue("__COUNTERID__", counterId);
this.setFieldValue("__CREATETIME__", DateUtil.getCurrentDateTime()); this.setFieldValue("__CREATETIME__", DateUtil.date().toString());
} }
public CounterBuilder(String groupName) { public CounterBuilder(String groupName) {
...@@ -210,7 +210,7 @@ public class CounterBuilder { ...@@ -210,7 +210,7 @@ public class CounterBuilder {
@Override @Override
public String toString() { public String toString() {
ArrayList<String> lines = new ArrayList<String>(this.fieldValueMap.size() + this.counterMap.size()); ArrayList<String> lines = new ArrayList<>(this.fieldValueMap.size() + this.counterMap.size());
StringBuilder stringBuilder = new StringBuilder(); StringBuilder stringBuilder = new StringBuilder();
......
C00-common/pps-common/src/main/java/pps/core/common/utils/DateUtil.java deleted 100644 → 0
View file @ efd7bba6
package pps.core.common.utils;
import cn.hutool.core.text.CharSequenceUtil;
import xstartup.base.util.XDateUtils;
import java.sql.Timestamp;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.Calendar;
import java.util.Date;
import java.util.Objects;
import java.util.function.Function;
import java.util.regex.Pattern;
public class DateUtil {
/**
* 年的时间格式
* <br/>
* 返回 "yyyy" 字符串
*/
public static final String YEAR_FORMAT = "yyyy";
/**
* 月的时间格式
* <br/>
* 返回 "MM" 字符串
*/
public static final String MONTH_FORMAT = "MM";
/**
* 日的时间格式
* <br/>
* 返回 "dd" 字符串
*/
public static final String DAY_FORMAT = "dd";
/**
* 时的时间格式
* <br/>
* 返回 "HH" 字符串
*/
public static final String HOUR_FORMAT = "HH";
/**
* 分的时间格式
* <br/>
* 返回 "mm" 字符串
*/
public static final String MINUTE_FORMAT = "mm";
/**
* 秒的时间格式
* <br/>
* 返回 "ss" 字符串
*/
public static final String SECOND_FORMAT = "ss";
// private static final ThreadLocal<DateTimeFormatter> dateTimeFormatter =
// ThreadLocal.withInitial(()-> DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss") );
// private static final ThreadLocal<DateTimeFormatter> dateTimeNoSymbolFormatter =
// ThreadLocal.withInitial(()-> DateTimeFormatter.ofPattern("yyyyMMddHHmmss") );
// private static final ThreadLocal<DateTimeFormatter> dateTimeShortFormatter =
// ThreadLocal.withInitial(()-> DateTimeFormatter.ofPattern("yyyy-MM-dd") );
// private static final ThreadLocal<DateTimeFormatter> dateTimeShortTimeFormatter =
// ThreadLocal.withInitial(()-> DateTimeFormatter.ofPattern("HH:mm:ss") );
/**
* <span color='red'>年月日时分秒</span>的时间格式（无符号）
* <br/>
* 返回 "yyyyMMddHHmmss" 字符串
*/
public static final String DATETIME_FORMAT = YEAR_FORMAT + MONTH_FORMAT + DAY_FORMAT + HOUR_FORMAT + MINUTE_FORMAT + SECOND_FORMAT;
private static final String HYPHEN = "-";
/**
* <span color='red'>年-月-日</span>的时间格式
* <br/>
* 返回 "yyyy-MM-dd" 字符串
*/
public static final String DATE_FORMAT = YEAR_FORMAT + HYPHEN + MONTH_FORMAT + HYPHEN + DAY_FORMAT;
private static final String COLON = ":";
/**
* <span color='red'>时:分:秒</span>的时间格式
* <br/>
* 返回 "HH:mm:ss" 字符串
*/
public static final String TIME_FORMAT = HOUR_FORMAT + COLON + MINUTE_FORMAT + COLON + SECOND_FORMAT;
/**
* <span color='red'>年-月-日 时:分:秒</span>的时间格式
* <br/>
* 返回 "yyyy-MM-dd HH:mm:ss" 字符串
*/
public static final String DATE_TIME_FORMAT = DATE_FORMAT + " " + TIME_FORMAT;
private static final Pattern DATETIMEPATTERN = Pattern.compile("\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}");
private static final ThreadLocal<SimpleDateFormat> simpleDateFormat =
ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
/*↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑ 时间格式 DateTimeFormatter (Java8) ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑*/
/*↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ 时间格式 字符串 ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓*/
private static final ThreadLocal<SimpleDateFormat> simpleDateFormatWithMS =
ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS"));
private static final ThreadLocal<SimpleDateFormat> simpleDateFormatShort =
ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-MM-dd"));
public static SimpleDateFormat getSimpleDateFormat() {
return simpleDateFormat.get();
}
public static SimpleDateFormat getSimpleDateFormatWithMS() {
return simpleDateFormatWithMS.get();
}
public static SimpleDateFormat getSimpleDateFormatShort() {
return simpleDateFormatShort.get();
}
public static DateTimeFormatter getDateTimeFormatter() {
return FormatEnum.FORMAT_DATA_TIME.value;
}
public static DateTimeFormatter getDateTimeFormatterNoSymbol() {
return FormatEnum.FORMAT_DATA_TIME_NO_SYMBOL.value;
}
public static DateTimeFormatter getDateTimeFormatterDateOnly() {
return FormatEnum.FORMAT_DATE.value;
}
public static DateTimeFormatter getDateTimeFormatterTimeOnly() {
return FormatEnum.FORMAT_TIME.value;
}
/**
* 获取秒级时间戳
*/
public static Long epochSecond() {
return localDateTime().toEpochSecond(ZoneOffset.of("+8"));
}
/*↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑ 时间格式 字符串 ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑*/
/*↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ 时间戳 ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓*/
/**
* 获取毫秒级时间戳
*/
public static Long epochMilli() {
return localDateTime().toInstant(ZoneOffset.of("+8")).toEpochMilli();
}
/**
* 获取当前详细时间，like 2018-08-27 17:20:06
*/
public static String dateTime() {
return localDateTime().format(FormatEnum.FORMAT_DATA_TIME.value);
}
/*↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑ 时间戳 ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑*/
/*↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ 当前时间相关 ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓*/
/**
* 获取当前详细时间，like 20180827172006
*/
public static String dateTimeNoSymbol() {
return localDateTime().format(FormatEnum.FORMAT_DATA_TIME_NO_SYMBOL.value);
}
/**
* 获取当前日期，like 2018-08-27
*/
public static String date() {
return localDate() + "";
}
/**
* 获取当前时间，like 17:20:06
*/
public static String time() {
return localTime().format(FormatEnum.FORMAT_TIME.value);
}
/**
* 获取当前年
*/
public static Integer year() {
return localDate().getYear();
}
/**
* 获取当前月
*/
public static int month() {
return localDate().getMonthValue();
}
/**
* 获取当前年中的日
*/
public static Integer dayOfYear() {
return localDate().getDayOfYear();
}
/**
* 获取当前月中的日
*/
public static Integer dayOfMonth() {
return localDate().getDayOfMonth();
}
/**
* 获取当前星期中的日
*/
public static Integer dayOfWeek() {
return localDate().getDayOfWeek().getValue();
}
/**
* 获取当前小时
*/
public static Integer hour() {
return localTime().getHour();
}
/**
* 获取当前分钟
*/
public static Integer minute() {
return localTime().getMinute();
}
/**
* 获取当前秒
*/
public static Integer second() {
return localTime().getSecond();
}
/**
* 获取当前年的 前几年 的日期
* <p>
*
* @param years 前几年 正整数
* @param formatEnum 格式
* @return 当前年的 前几年 的 对应 格式 日期
*/
public static String minusYears(Long years, FormatEnum formatEnum) {
return minusOrPlusYears(-years, formatEnum);
}
/*↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑ 当前时间相关 ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑*/
/*↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ 未来、历史时间相关 ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓*/
/**
* 获取当前年的 后几年 的日期
* <p>
*
* @param years 后几年 正整数
* @param formatEnum 格式
* @return 当前年的 后几年 的 对应 格式 日期
*/
public static String plusYears(Long years, FormatEnum formatEnum) {
return minusOrPlusYears(years, formatEnum);
}
/**
* 获取当前月的 前几月 日期
*
* @param months 前几月 正整数
* @param formatEnum 格式
* @return 当前月的 前几月 的 对应 格式 日期
*/
public static String minusMonths(Long months, FormatEnum formatEnum) {
return minusOrPlusMonths(-months, formatEnum);
}
/**
* 获取当前月的 后几月 的日期
*
* @param months 后几月 正整数
* @param formatEnum 格式
* @return 当前月的 后几月 的 对应 格式 日期
*/
public static String plusMonths(Long months, FormatEnum formatEnum) {
return minusOrPlusMonths(months, formatEnum);
}
/**
* 获取当前日的 前几日 的日期
*
* @param days 前几日 正整数
* @param formatEnum 格式
* @return 当前日的 前几日 的 对应 格式 日期
*/
public static String minusDays(Long days, FormatEnum formatEnum) {
return minusOrPlusDays(-days, formatEnum);
}
/**
* 获取当前日的 后几日 的日期
*
* @param days 后几日 正整数
* @param formatEnum 格式
* @return 当前日的 后几日 的 对应 格式 日期
*/
public static String plusDays(Long days, FormatEnum formatEnum) {
return minusOrPlusDays(days, formatEnum);
}
/**
* 获取当前星期的 前几星期 的日期
*
* @param weeks 前几星期 正整数
* @param formatEnum 格式
* @return 当前星期的 前几星期 的 对应 格式 日期
*/
public static String minusWeeks(Long weeks, FormatEnum formatEnum) {
return minusOrPlusWeeks(-weeks, formatEnum);
}
/**
* 获取当前星期的 后几星期 的日期
*
* @param weeks 后几星期 正整数
* @param formatEnum 格式
* @return 当前星期的 后几星期 的 对应 格式 日期
*/
public static String plusWeeks(Long weeks, FormatEnum formatEnum) {
return minusOrPlusWeeks(weeks, formatEnum);
}
/**
* 获取当前小时的 前几小时 的日期
*
* @param hours 前几小时 正整数
* @param formatEnum 格式
* @return 当前小时的 前几小时 的 对应 格式 日期
*/
public static String minusHours(Long hours, FormatEnum formatEnum) {
return minusOrPlusHours(-hours, formatEnum);
}
/**
* 获取当前小时的 后几小时 的日期
*
* @param hours 后几小时 正整数
* @param formatEnum 格式
* @return 当前小时的 后几小时 的 对应 格式 日期
*/
public static String plusHours(Long hours, FormatEnum formatEnum) {
return minusOrPlusHours(hours, formatEnum);
}
/**
* 获取当前分钟的 前几分钟 的日期
*
* @param minutes 前几分钟 正整数
* @param formatEnum 格式
* @return 当前分钟的 前几分钟 的 对应 格式 日期
*/
public static String minusMinutes(Long minutes, FormatEnum formatEnum) {
return minusOrPlusMinutes(-minutes, formatEnum);
}
/**
* 获取当前分钟的 后几分钟 的日期
*
* @param minutes 后几分钟 正整数
* @param formatEnum 格式
* @return 当前分钟的 后几分钟 的 对应 格式 日期
*/
public static String plusMinutes(Long minutes, FormatEnum formatEnum) {
return minusOrPlusMinutes(minutes, formatEnum);
}
/**
* 获取当前秒的 前几秒 的日期
*
* @param seconds 前几秒 正整数
* @param formatEnum 格式
* @return 当前秒的 前几秒 的 对应 格式 日期
*/
public static String minusSeconds(Long seconds, FormatEnum formatEnum) {
return minusOrPlusSeconds(-seconds, formatEnum);
}
/**
* 获取当前秒的 前几秒/后几秒 的日期
*
* @param seconds 后几秒 正整数
* @param formatEnum 格式
* @return 当前秒的 后几秒 的 对应 格式 日期
*/
public static String plusSeconds(Long seconds, FormatEnum formatEnum) {
return minusOrPlusSeconds(seconds, formatEnum);
}
public static String toDateStr(Date date) {
return getSimpleDateFormatShort().format(date);
}
/*↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑ 未来、历史时间相关 ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑*/
public static String toDateTimeStr(Date date) {
return getSimpleDateFormat().format(date);
}
/**
* Date类型转LocalDateTime
* <p>
*
* @param date date类型时间
* @return LocalDateTime
*/
public static LocalDateTime toLocalDateTime(Date date) {
return LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault());
}
/*↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ 时间转换相关 ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓*/
/**
* Date类型转LocalDate
* <p>
*
* @param date date类型时间
* @return LocalDate
*/
public static LocalDate toLocalDate(Date date) {
return toLocalDateTime(date).toLocalDate();
}
/**
* Date类型转LocalTime
* <p>
*
* @param date date类型时间
* @return LocalTime
*/
public static LocalTime toLocalTime(Date date) {
return toLocalDateTime(date).toLocalTime();
}
/**
* LocalDateTime 类型转 Date
*
* @param localDateTime localDateTime
* @return 转换后的Date类型日期
*/
public static Date toDate(LocalDateTime localDateTime) {
return Date.from(localDateTime.atZone(ZoneId.systemDefault()).toInstant());
}
/**
* LocalDate类型转Date
*
* @param localDate localDate
* @return 转换后的Date类型日期
*/
public static Date toDate(LocalDate localDate) {
return toDate(localDate.atStartOfDay());
}
/**
* LocalTime类型转Date
*
* @param localTime localTime
* @return 转换后的Date类型日期
*/
public static Date toDate(LocalTime localTime) {
return toDate(LocalDateTime.of(localDate(), localTime));
}
/**
* 获取 endDate-startDate 时间间隔天数
* <br>创建人： leigq
* <br>创建时间： 2018-11-07 09:55
* <br>
*
* @param startDate 开始时间
* @param endDate 结束时间
* @return 时间间隔天数
*/
public static Long daysInterval(LocalDate startDate, LocalDate endDate) {
return endDate.toEpochDay() - startDate.toEpochDay();
}
/*↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑ 时间转换相关 ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑*/
/*↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ 时间间隔相关 ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓*/
/**
* 获取 endDate-startDate 时间间隔天数
* <br>创建人： leigq
* <br>创建时间： 2018-11-07 09:55
* <br>
*
* @param startDate 开始时间
* @param endDate 结束时间
* @return 时间间隔天数
*/
public static Long daysInterval(String startDate, String endDate) {
return daysInterval(Objects.requireNonNull(parseLocalDateTime(endDate)).toLocalDate(),//LocalDateTime.parse(endDate, FormatEnum.FORMAT_DATA_TIME.value)
Objects.requireNonNull(parseLocalDateTime(startDate)).toLocalDate());
}
/**
* 获取 endDate-startDate 时间间隔天数
* <br>创建人： leigq
* <br>创建时间： 2018-11-07 09:55
* <br>
*
* @param startDate 开始时间
* @param endDate 结束时间
* @return 时间间隔天数
*/
public static Long daysInterval(LocalDateTime startDate, LocalDateTime endDate) {
return daysInterval(startDate.toLocalDate(), endDate.toLocalDate());
}
/**
* 获取 当前年 的前几年/后几年的日期
* <p>
*
* @param yearsToAddOrSubtract 后几年传正整数，前几年传负数
* @param formatEnum 格式
* @return 当前年的前几年/后几年的对应 格式 日期
*/
private static String minusOrPlusYears(Long yearsToAddOrSubtract, FormatEnum formatEnum) {
return localDateTime().plusYears(yearsToAddOrSubtract).format(formatEnum.value);
}
/*↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑ 时间间隔相关 ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑*/
/*↓↓↓只允许此类调用↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓*/
/**
* 获取 当前月 的前几月/后几月的日期
*
* @param monthsToAddOrSubtract 后几月传正整数，前几月传负数
* @param formatEnum 格式
* @return 当前月的前几月/后几月的对应 格式 日期
*/
private static String minusOrPlusMonths(Long monthsToAddOrSubtract, FormatEnum formatEnum) {
return localDateTime().plusMonths(monthsToAddOrSubtract).format(formatEnum.value);
}
/**
* 获取 当前日 的前几日/后几日的日期
*
* @param daysToAddOrSubtract 后几日传正整数，前几日传负数
* @param formatEnum 格式
* @return 当前日的前几日/后几日的 对应 格式 日期
*/
private static String minusOrPlusDays(Long daysToAddOrSubtract, FormatEnum formatEnum) {
return localDateTime().plusDays(daysToAddOrSubtract).format(formatEnum.value);
}
/**
* 获取当前星期的前几星期/后几星期的日期
*
* @param weeksToAddOrSubtract 后几星期传正整数，前几星期传负数
* @param formatEnum 格式
* @return 当前星期的前几星期/后几星期的 对应 格式 日期
*/
private static String minusOrPlusWeeks(Long weeksToAddOrSubtract, FormatEnum formatEnum) {
return localDateTime().plusWeeks(weeksToAddOrSubtract).format(formatEnum.value);
}
/**
* 获取当前小时的前几小时/后几小时的日期
*
* @param hoursToAddOrSubtract 后几小时传正整数，前几小时传负数
* @param formatEnum 格式
* @return 当前小时的前几小时/后几小时的 对应 格式 日期
*/
private static String minusOrPlusHours(Long hoursToAddOrSubtract, FormatEnum formatEnum) {
return localDateTime().plusHours(hoursToAddOrSubtract).format(formatEnum.value);
}
/**
* 获取当前分钟的前几分钟/后几分钟的日期
*
* @param minutesToAddOrSubtract 后几分钟传正整数，前几分钟传负数
* @param formatEnum 格式
* @return 当前分钟的前几分钟/后几分钟的 对应 格式 日期
*/
private static String minusOrPlusMinutes(Long minutesToAddOrSubtract, FormatEnum formatEnum) {
return localDateTime().plusMinutes(minutesToAddOrSubtract).format(formatEnum.value);
}
/**
* 获取当前秒的前几秒/后几秒的日期
*
* @param secondsToAddOrSubtract 后几秒传正整数，前几秒传负数
* @param formatEnum 格式
* @return 当前秒的前几秒/后几秒的 对应 格式 日期
*/
private static String minusOrPlusSeconds(Long secondsToAddOrSubtract, FormatEnum formatEnum) {
return localDateTime().plusSeconds(secondsToAddOrSubtract).format(formatEnum.value);
}
/**
* 获取 LocalDate
*/
private static LocalDate localDate() {
return localDateTime().toLocalDate();
}
/**
* 获取 LocalTime
*/
private static LocalTime localTime() {
return localDateTime().toLocalTime();
}
/**
* 获取 LocalDateTime
*/
private static LocalDateTime localDateTime() {
return LocalDateTime.now();
}
/**
* 返回unix时间戳 (1970年至今的秒数)
*
* @return
*/
public static long getUnixStamp() {
return System.currentTimeMillis() / 1000;
}
/**
* 得到昨天的日期
*
* @return
*/
public static String getYestoryDate() {
Calendar calendar = Calendar.getInstance();
calendar.add(Calendar.DATE, -1);
// SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
String yestoday = getSimpleDateFormat().format(calendar.getTime());
return yestoday;
}
public static String getPreDay(int days) {
Calendar calendar = Calendar.getInstance();
calendar.add(Calendar.DATE, -days);
// SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
String yestoday = getSimpleDateFormat().format(calendar.getTime());
return yestoday;
}
public static String getCurrentDateTime() {
return getSimpleDateFormat().format(new Date());
}
public static String getCurrentDateTimeWithMs() {
return getSimpleDateFormatWithMS().format(new Date());
}
/**
* 得到今天的日期
*
* @return
*/
public static String getTodayDate() {
// SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
String date = getSimpleDateFormatShort().format(new Date());
return date;
}
/**
* 时间戳转化为时间格式
*
* @param timeStamp
* @return
*/
public static String timeStampToStr(long timeStamp) {
// SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String date = getSimpleDateFormat().format(timeStamp * 1000);
return date;
}
/**
* 时间戳转化为时间格式
*
* @param datetime
* @return
*/
public static String datetimeToStr(long datetime) {
// SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String date = getSimpleDateFormat().format(datetime);
return date;
}
/**
* 得到日期 yyyy-MM-dd
*
* @param timeStamp 时间戳
* @return
*/
public static String timeStampToDate(long timeStamp) {
// SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
String date = getSimpleDateFormat().format(timeStamp * 1000);
return date;
}
/**
* 得到时间 HH:mm:ss
*
* @param timeStamp 时间戳
* @return
*/
public static String getTimeOfTimeStamp(long timeStamp) {
String time = null;
// SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String date = getSimpleDateFormat().format(timeStamp * 1000);
String[] split = date.split("\\s");
if (split.length > 1) {
time = split[1];
}
return time;
}
/**
* 将一个时间戳转换成提示性时间字符串，如刚刚，1秒前
*
* @param timeStamp
* @return
*/
public static String convertTimeToFormat(long timeStamp) {
long curTime = System.currentTimeMillis() / (long) 1000;
long time = curTime - timeStamp;
if (time < 60 && time >= 0) {
return "刚刚";
} else if (time >= 60 && time < 3600) {
return time / 60 + "分钟前";
} else if (time >= 3600 && time < 3600 * 24) {
return time / 3600 + "小时前";
} else if (time >= 3600 * 24 && time < 3600 * 24 * 30) {
return time / 3600 / 24 + "天前";
} else if (time >= 3600 * 24 * 30 && time < 3600 * 24 * 30 * 12) {
return time / 3600 / 24 / 30 + "个月前";
} else if (time >= 3600 * 24 * 30 * 12) {
return time / 3600 / 24 / 30 / 12 + "年前";
} else {
return "刚刚";
}
}
/**
* 将一个时间戳转换成提示性时间字符串，(多少分钟)
*
* @param timeStamp
* @return
*/
public static String timeStampToFormat(long timeStamp) {
long curTime = System.currentTimeMillis() / (long) 1000;
long time = curTime - timeStamp;
return time / 60 + "";
}
public static LocalDateTime parseLocalDateTime(String dateTime) {
if (CharSequenceUtil.isBlank(dateTime)) {
return null;
}
if (DATETIMEPATTERN.matcher(dateTime).matches()) {
return LocalDateTime.parse(dateTime);
}
boolean hasTime = dateTime.contains(":");
String[] items = dateTime.trim().replace(" ", "-").replace(":", "-").split("-");
if (items.length == 6) {
return LocalDateTime.of(Integer.parseInt(items[0]), Integer.parseInt(items[1]), Integer.parseInt(items[2]),
Integer.parseInt(items[3]), Integer.parseInt(items[4]), Integer.parseInt(items[5]));
} else if (items.length == 3 && !hasTime) {
return LocalDateTime.of(Integer.parseInt(items[0]), Integer.parseInt(items[1]), Integer.parseInt(items[2]), 0, 0, 0);
} else {
return null;
}
}
public static Integer getWeekNumber(Date date) {
synchronized (DateUtil.class) {
Calendar calendar = Calendar.getInstance();
calendar.setFirstDayOfWeek(Calendar.MONDAY);//设置星期一为一周开始的第一天
calendar.setMinimalDaysInFirstWeek(4);//可以不用设置
calendar.setTimeInMillis(date.getTime());//获得当前的时间戳
//int weekYear = calendar.get(Calendar.YEAR);//获得当前的年
return calendar.get(Calendar.WEEK_OF_YEAR);//获得当前日期属于今年的第几周
}
}
public static Integer getWeekNumber(String strDate) throws ParseException {
return getWeekNumber(getSimpleDateFormatShort().parse(strDate));
}
public static Integer getQuarterNumber(Date dt) {
if (dt.getMonth() >= 1 && dt.getMonth() <= 3) {
return 1;
} else if (dt.getMonth() >= 4 && dt.getMonth() <= 6) {
return 2;
} else if (dt.getMonth() >= 7 && dt.getMonth() <= 9) {
return 3;
} else {
return 4;
}
}
public static String calcTimeSpan(String begin, String end) {
if (CharSequenceUtil.isBlank(begin) || CharSequenceUtil.isBlank(end)) {
return "";
}
try {
long start = getSimpleDateFormat().parse(begin).getTime();
long stop = getSimpleDateFormat().parse(end).getTime();
return String.format("%.3fs", (stop - start) / 1000.0);
} catch (Exception ex) {
throw new RuntimeException(ex);
}
}
public static String calcTimeSpanWithMs(String begin, String end) {
if (CharSequenceUtil.isBlank(begin) || CharSequenceUtil.isBlank(end)) {
return "";
}
try {
long start = getSimpleDateFormatWithMS().parse(begin).getTime();
long stop = getSimpleDateFormatWithMS().parse(end).getTime();
return String.format("%.3fs", (stop - start) / 1000.0);
} catch (Exception ex) {
throw new RuntimeException(ex);
}
}
public static void main(String[] args) {
System.out.println(getWeekNumber(new Date()));
LocalDateTime dt = parseLocalDateTime("2000-1-1 1:1:1");
System.out.println(dt);
dt = parseLocalDateTime("2000-1-1");
System.out.println(dt);
dt = parseLocalDateTime("1:1:1");
System.out.println(dt);
try {
String date1String = "2015-12-31";
String date2String = "2021-01-01";
SimpleDateFormat sdf = getSimpleDateFormatShort();// new SimpleDateFormat("yyyy-MM-dd");
Date date1 = sdf.parse(date1String);
Date date2 = sdf.parse(date2String);
System.out.println("day of weak:" + getWeekNumber(date2));
Calendar calendar = Calendar.getInstance();
calendar.setFirstDayOfWeek(Calendar.MONDAY);
calendar.setTime(date1);
int week1 = calendar.get(Calendar.WEEK_OF_YEAR);
System.out.println(date1String + " week of year:" + week1);
calendar.setTime(date2);
int week2 = calendar.get(Calendar.WEEK_OF_YEAR);
System.out.println(date2String + " week of year:" + week2);
} catch (ParseException e) {
e.printStackTrace();
}
}
/**
* 获取指定日期最后一天日期
*
* @param date 当前日期
* @return
*/
public static Date getThisYearLastDate(Date date) {
Calendar cal = Calendar.getInstance();
cal.setTime(date);
int currentYear = cal.get(Calendar.YEAR);
cal.clear();
cal.set(Calendar.YEAR, currentYear);
cal.roll(Calendar.DAY_OF_YEAR, -1);
Date sunDate = new Date(cal.getTimeInMillis());
return sunDate;
}
/* 获取指定日期第一天日期
* @return
*/
public static Date getThisYearFirstDate(Date date) {
Calendar cal = Calendar.getInstance();
cal.setTime(date);
cal.set(Calendar.DAY_OF_YEAR, 1);
Date sunDate = new Date(cal.getTimeInMillis());
return sunDate;
}
//根据日期获取该天所在周的开始与结束日期(周跨年周，只计算本年内那部分天数)
public static String[] getStartAndEndDayByDate(Date date) {
SimpleDateFormat sm = new SimpleDateFormat("yyyy-MM-dd");
String format = sm.format(date);
String[] dateZone = new String[3];
Calendar cal = getCalendarByDateStr(date);
int year = XDateUtils.getYear(date);
Function<Integer, String> add0 = (i -> i < 10 ? "0" + i : String.valueOf(i));//补0
dateZone[0] = cal.get(Calendar.YEAR) + "-" + add0.apply(cal.get(Calendar.MONTH) + 1) + "-" + add0.apply(cal.get(Calendar.DAY_OF_MONTH));
if (cal.get(Calendar.YEAR) < year) dateZone[0] = year + "-01-01";
cal.add(Calendar.DATE, 6);
dateZone[1] = cal.get(Calendar.YEAR) + "-" + add0.apply(cal.get(Calendar.MONTH) + 1) + "-" + add0.apply(cal.get(Calendar.DAY_OF_MONTH));
if (cal.get(Calendar.YEAR) > year) dateZone[1] = year + "-12-31";
dateZone[2] = String.valueOf(cal.get(Calendar.WEEK_OF_YEAR));
return dateZone;
}
private static Calendar getCalendarByDateStr(Date date) {
Calendar cal = Calendar.getInstance();
cal.setTime(date);
//判断要计算的日期是否是周日，如果是，则减一天计算周六的，否则会出问题，计算到下一周去了
int dayWeek = cal.get(Calendar.DAY_OF_WEEK);//获得当前日期是一个星期的第几天
if (1 == dayWeek) cal.add(Calendar.DAY_OF_MONTH, -1);
cal.setFirstDayOfWeek(Calendar.MONDAY);//设置一个星期的第一天，按中国的习惯一个星期的第一天是星期一
int day = cal.get(Calendar.DAY_OF_WEEK);//获得当前日期是一个星期的第几天
cal.add(Calendar.DATE, cal.getFirstDayOfWeek() - day);//根据日历的规则，给当前日期减去星期几与一个星期第一天的差值
return cal;
}
public static Date asDate(LocalDate localDate) {
return Date.from(localDate.atStartOfDay().atZone(ZoneId.systemDefault()).toInstant());
}
public static Date asDate(LocalDateTime localDateTime) {
return Date.from(localDateTime.atZone(ZoneId.systemDefault()).toInstant());
}
public static LocalDate asLocalDate(Date date) {
return Instant.ofEpochMilli(date.getTime()).atZone(ZoneId.systemDefault()).toLocalDate();
}
public static LocalDateTime asLocalDateTime(Date date) {
return Instant.ofEpochMilli(date.getTime()).atZone(ZoneId.systemDefault()).toLocalDateTime();
}
/**
* 秒 转 时分
*
* @param second
* @return
*/
public static String secondToTime(Long second) {
if (second == null || second < 0) {
return "00:00";
}
long h = second / 3600;
long m = (second % 3600) / 60;
String str = "";
if (h > 0) {
str = (h < 10 ? ("0" + h) : h) + ":";
}
str += (m < 10 ? ("0" + m) : m) + ":";
return str;
}
public static Date getBeginDayOfMonth(Date date) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
calendar.add(Calendar.MONTH, 0);
calendar.set(Calendar.DAY_OF_MONTH, 1);
return getDayStartTime(calendar.getTime());
}
public static Date getEndDayOfMonth(Date date) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
calendar.add(Calendar.MONTH, 1);
calendar.set(Calendar.DAY_OF_MONTH, 0);
return getDayEndTime(calendar.getTime());
}
public static Date getBeginDayOfWeek(Date date) {
Calendar cal = Calendar.getInstance();
cal.setTime(date);
int dayofweek = cal.get(Calendar.DAY_OF_WEEK);
if (dayofweek == 1) {
dayofweek += 7;
}
cal.add(Calendar.DATE, 2 - dayofweek);
return getDayStartTime(cal.getTime());
}
public static Date getEndDayOfWeek(Date date) {
Calendar cal = Calendar.getInstance();
cal.setTime(getBeginDayOfWeek(date));
cal.add(Calendar.DAY_OF_WEEK, 6);
Date weekEndSta = cal.getTime();
return getDayEndTime(weekEndSta);
}
//获取某个日期的开始时间
public static Timestamp getDayStartTime(Date d) {
Calendar calendar = Calendar.getInstance();
if (null != d) calendar.setTime(d);
calendar.set(calendar.get(Calendar.YEAR), calendar.get(Calendar.MONTH), calendar.get(Calendar.DAY_OF_MONTH), 0, 0, 0);
calendar.set(Calendar.MILLISECOND, 0);
return new Timestamp(calendar.getTimeInMillis());
}
//获取某个日期的结束时间
public static Timestamp getDayEndTime(Date d) {
Calendar calendar = Calendar.getInstance();
if (null != d) calendar.setTime(d);
calendar.set(calendar.get(Calendar.YEAR), calendar.get(Calendar.MONTH), calendar.get(Calendar.DAY_OF_MONTH), 23, 59, 59);
calendar.set(Calendar.MILLISECOND, 999);
return new Timestamp(calendar.getTimeInMillis());
}
/*↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ 时间格式 DateTimeFormatter (Java8) ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓*/
public enum FormatEnum {
/**
* 返回 DateTimeFormatter "yyyy-MM-dd HH:mm:ss" 时间格式
*/
FORMAT_DATA_TIME(DateTimeFormatter.ofPattern(DATE_TIME_FORMAT)),
/**
* 返回 DateTimeFormatter "yyyyMMddHHmmss"的时间格式
*/
FORMAT_DATA_TIME_NO_SYMBOL(DateTimeFormatter.ofPattern(DATETIME_FORMAT)),
/**
* 返回 DateTimeFormatter "yyyy-MM-dd"的时间格式
*/
FORMAT_DATE(DateTimeFormatter.ofPattern(DATE_FORMAT)),
/**
* 返回 DateTimeFormatter "HH:mm:ss"的时间格式
*/
FORMAT_TIME(DateTimeFormatter.ofPattern(TIME_FORMAT));
private DateTimeFormatter value;
FormatEnum(DateTimeFormatter format) {
this.value = format;
}
}
}
C00-common/pps-common/src/main/java/pps/core/common/utils/DynamicPwd.java deleted 100644 → 0
View file @ efd7bba6
package pps.core.common.utils;
import java.text.SimpleDateFormat;
import java.util.Date;
public class DynamicPwd {
public static String buildDynPwd() {
String str = new SimpleDateFormat("dd:HH:mm").format(new Date());
String[] items = str.split(":");
String pwd = String.format("%02d%02d%02d", Integer.parseInt(items[2]), Integer.parseInt(items[1]) + 1, Integer.parseInt(items[0]));
return pwd;
}
public static void main(String[] args) throws Exception {
String pwd = buildDynPwd();
System.out.println(pwd);
}
}
C00-common/pps-common/src/main/java/pps/core/common/utils/ExcelTemplateUtils.java deleted 100644 → 0
View file @ efd7bba6
package pps.core.common.utils;
/**
* @author lixueyan
* @date 2023/2/3 0003 17:36
*/
import org.apache.commons.lang3.StringUtils;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.ss.util.CellRangeAddressList;
import org.apache.poi.xssf.usermodel.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.util.ArrayList;
import java.util.List;
/**
* 动态excel模板 工具类
*/
public class ExcelTemplateUtils {
/**
* @param @param filePath Excel文件路径
* @param @param handers Excel列标题(数组)
* @param @param downData 下拉框数据(数组)
* @param @param downRows 下拉列的序号(数组,序号从0开始)
* @param templateInputStream
* @return void
* @throws
* @Title: createExcelTemplate
* @Description: 生成Excel导入模板
*/
public static void createExcelTemplate(String filePath, //String[] handers,
InputStream templateInputStream, List<String[]> downData, String[] downRows) throws IOException {
//HSSFWorkbook wb = new HSSFWorkbook(templateInputStream);//创建工作薄
XSSFWorkbook wb = new XSSFWorkbook(templateInputStream);
//表头样式
XSSFCellStyle style = wb.createCellStyle();
style.setAlignment(HorizontalAlignment.CENTER); // 创建一个居中格式
//字体样式
XSSFFont fontStyle = wb.createFont();
fontStyle.setFontName("微软雅黑");
fontStyle.setFontHeightInPoints((short) 12);
fontStyle.setBold(true);
style.setFont(fontStyle);
//获取sheet
XSSFSheet sheet1 = wb.getSheetAt(0);
XSSFSheet sheet2 = wb.getSheetAt(1);
//新建sheet
//XSSFSheet sheet1 = wb.createSheet("Sheet1");
//XSSFSheet sheet2 = wb.createSheet("Sheet2");
//XSSFSheet sheet3 = wb.createSheet("Sheet3");
//生成sheet1内容
//XSSFRow rowFirst = sheet1.createRow(0);//第一个sheet的第一行为标题
//写标题
/*for(int i=0;i<handers.length;i++){
HSSFCell cell = rowFirst.createCell(i); //获取第一行的每个单元格
sheet1.setColumnWidth(i, 4000); //设置每列的列宽
cell.setCellStyle(style); //加样式
cell.setCellValue(handers[i]); //往单元格里写数据
}*/
//设置下拉框数据
String[] arr = {"A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "AA", "AB", "AC", "AD", "AE", "AF", "AG", "AH", "AI", "AJ", "AK"};
int index = 30; //下拉数据从25列开始
XSSFRow row = null;
for (int r = 0; r < downRows.length; r++) {
String[] dlData = downData.get(r);//获取下拉对象
int rownum = Integer.parseInt(downRows[r]);
if (StringUtils.join(dlData).length() < 250) { //255以内的下拉
//255以内的下拉,参数分别是：作用的sheet、下拉内容数组、起始行、终止行、起始列、终止列
sheet1.addValidationData(setDataValidation(sheet1, dlData, 1, 32767, rownum, rownum)); //超过255个报错
} else { //255以上的下拉，即下拉列表元素很多的情况
//1、设置有效性
//String strFormula = "Sheet2!$A$1:$A$5000" ; //Sheet2第A1到A5000作为下拉列表来源数据
String strFormula = "导入说明!$" + arr[index] + "$1:$" + arr[index] + "$5000"; //Sheet2第A1到A5000作为下拉列表来源数据
sheet2.setColumnWidth(r, 4000); //设置每列的列宽
//设置数据有效性加载在哪个单元格上,参数分别是：从sheet2获取A1到A5000作为一个下拉的数据、起始行、终止行、起始列、终止列
sheet1.addValidationData(SetDataValidation(sheet2, strFormula, 1, 32767, rownum, rownum)); //下拉列表元素很多的情况
sheet2.setColumnHidden(index, true);
//2、生成sheet2内容
for (int j = 0; j < dlData.length; j++) {
if (index == 0) { //第1个下拉选项，直接创建行、列
row = sheet2.createRow(j); //创建数据行
sheet2.setColumnWidth(j, 4000); //设置每列的列宽
row.createCell(0).setCellValue(dlData[j]); //设置对应单元格的值
} else { //非第1个下拉选项
int rowCount = sheet2.getLastRowNum();
//System.out.println("========== LastRowNum =========" + rowCount);
if (j <= rowCount) { //前面创建过的行，直接获取行，创建列
//获取行，创建列
sheet2.getRow(j).createCell(index).setCellValue(dlData[j]); //设置对应单元格的值
} else { //未创建过的行，直接创建行、创建列
sheet2.setColumnWidth(j, 4000); //设置每列的列宽
//创建行、创建列
sheet2.createRow(j).createCell(index).setCellValue(dlData[j]); //设置对应单元格的值
}
}
}
index++;
}
}
try {
File f = new File(filePath); //写文件
//不存在则新增
if (!f.getParentFile().exists()) {
f.getParentFile().mkdirs();
}
if (!f.exists()) {
f.createNewFile();
}
FileOutputStream out = new FileOutputStream(f);
out.flush();
wb.write(out);
out.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* @param @param strFormula
* @param @param firstRow 起始行
* @param @param endRow 终止行
* @param @param firstCol 起始列
* @param @param endCol 终止列
* @param @return
* @return HSSFDataValidation
* @throws
* @Title: SetDataValidation
* @Description: 下拉列表元素很多的情况 (255以上的下拉)
*/
private static XSSFDataValidation SetDataValidation(XSSFSheet sheet, String strFormula,
int firstRow, int endRow, int firstCol, int endCol) {
XSSFDataValidationHelper dvHelper = new XSSFDataValidationHelper(sheet);
// 设置数据有效性加载在哪个单元格上。四个参数分别是：起始行、终止行、起始列、终止列
CellRangeAddressList regions = new CellRangeAddressList(firstRow, endRow, firstCol, endCol);
XSSFDataValidationConstraint constraint = (XSSFDataValidationConstraint) dvHelper.createFormulaListConstraint(strFormula);
XSSFDataValidation dataValidation = (XSSFDataValidation) dvHelper.createValidation(constraint, regions);
;//new XSSFDataValidation(regions,constraint);
dataValidation.createErrorBox("Error", "Error");
dataValidation.createPromptBox("", null);
return dataValidation;
}
/**
* @param @param sheet
* @param @param textList
* @param @param firstRow
* @param @param endRow
* @param @param firstCol
* @param @param endCol
* @param @return
* @return DataValidation
* @throws
* @Title: setDataValidation
* @Description: 下拉列表元素不多的情况(255以内的下拉)
*/
private static DataValidation setDataValidation(Sheet sheet, String[] textList, int firstRow, int endRow, int firstCol, int endCol) {
DataValidationHelper helper = sheet.getDataValidationHelper();
//加载下拉列表内容
DataValidationConstraint constraint = helper.createExplicitListConstraint(textList);
//DVConstraint constraint = new DVConstraint();
constraint.setExplicitListValues(textList);
//设置数据有效性加载在哪个单元格上。四个参数分别是：起始行、终止行、起始列、终止列
CellRangeAddressList regions = new CellRangeAddressList((short) firstRow, (short) endRow, (short) firstCol, (short) endCol);
//数据有效性对象
DataValidation data_validation = helper.createValidation(constraint, regions);
//DataValidation data_validation = new DataValidation(regions, constraint);
return data_validation;
}
/**
* @param @param url 文件路径
* @param @param fileName 文件名
* @param @param response
* @return void
* @throws
* @Title: getExcel
* @Description: 下载指定路径的Excel文件
*/
public static void getExcel(String url, String fileName, HttpServletResponse response, HttpServletRequest request) {
try {
//1.设置文件ContentType类型，这样设置，会自动判断下载文件类型
response.setContentType("multipart/form-data");
//2.设置文件头：最后一个参数是设置下载文件名
response.setHeader("Content-disposition", "attachment; filename=\""
+ encodeChineseDownloadFileName(request, fileName + ".xls") + "\"");
// response.setHeader("Content-Disposition", "attachment;filename="
// + new String(fileName.getBytes("UTF-8"), "ISO-8859-1") + ".xls"); //中文文件名
//通过文件路径获得File对象
File file = new File(url);
FileInputStream in = new FileInputStream(file);
//3.通过response获取OutputStream对象(out)
OutputStream out = new BufferedOutputStream(response.getOutputStream());
int b = 0;
byte[] buffer = new byte[2048];
while ((b = in.read(buffer)) != -1) {
out.write(buffer, 0, b); //4.写到输出流(out)中
}
in.close();
out.flush();
out.close();
} catch (IOException e) {
System.out.println("下载Excel模板异常");
}
}
/**
* @param @param request
* @param @param pFileName
* @param @return
* @param @throws UnsupportedEncodingException
* @return String
* @throws
* @Title: encodeChineseDownloadFileName
* @Description: TODO(这里用一句话描述这个方法的作用)
*/
private static String encodeChineseDownloadFileName(HttpServletRequest request, String pFileName)
throws UnsupportedEncodingException {
String filename = null;
String agent = request.getHeader("USER-AGENT");
//System.out.println("agent==========》"+agent);
if (null != agent) {
if (-1 != agent.indexOf("Firefox")) {//Firefox
filename = "=?UTF-8?B?" + (new String(org.apache.commons.codec.binary.Base64.encodeBase64(pFileName.getBytes("UTF-8")))) + "?=";
} else if (-1 != agent.indexOf("Chrome")) {//Chrome
filename = new String(pFileName.getBytes(), "ISO8859-1");
} else {//IE7+
filename = java.net.URLEncoder.encode(pFileName, "UTF-8");
filename = StringUtils.replace(filename, "+", "%20");//替换空格
}
} else {
filename = pFileName;
}
return filename;
}
public static void main(String[] args) {
String fileName = "C:\\Users\\Administrator\\Desktop\\员工信息表.xlsx"; //模板名称
String[] handers = {"姓名", "性别", "证件类型", "证件号码", "服务结束时间", "参保地", "民族"}; //列标题
//下拉框数据
List<String[]> downData = new ArrayList();
String[] str1 = {"男", "女", "未知"};
String[] str2 = {"北京", "上海", "广州", "深圳", "武汉", "长沙", "湘潭"};
String[] str3 = {"01-汉族", "02-蒙古族", "03-回族", "04-藏族", "05-维吾尔族", "06-苗族", "07-彝族", "08-壮族", "09-布依族",
"10-朝鲜族", "11-满族", "12-侗族", "13-瑶族", "14-白族", "15-土家族", "16-哈尼族", "17-哈萨克族", "18-傣族", "19-黎族", "20-傈僳族",
"21-佤族", "22-畲族", "23-高山族", "24-拉祜族", "25-水族", "26-东乡族", "27-纳西族", "28-景颇族", "29-柯尔克孜族", "30-土族",
"31-达斡尔族", "32-仫佬族", "33-羌族", "34-布朗族", "35-撒拉族", "36-毛难族", "37-仡佬族", "38-锡伯族", "39-阿昌族", "40-普米族",
"41-塔吉克族", "42-怒族", "43-乌孜别克族", "44-俄罗斯族", "45-鄂温克族", "46-德昂族", "47-保安族", "48-裕固族", "49-京族", "50-塔塔尔族",
"51-独龙族", "52-鄂伦春族", "53-赫哲族", "54-门巴族", "55-珞巴族", "56-基诺族", "98-外国血统", "99-其他"};
downData.add(str1);
downData.add(str2);
downData.add(str3);
String[] downRows = {"1", "5", "6"}; //下拉的列序号数组(序号从0开始)
try {
ExcelTemplateUtils.createExcelTemplate(fileName, null, downData, downRows);
} catch (Exception e) {
e.printStackTrace();
System.out.println("批量导入信息异常：");
}
}
}
C00-common/pps-common/src/main/java/pps/core/common/utils/ExcelUtils.java
View file @ 372b9739
...@@ -389,7 +389,7 @@ public class ExcelUtils { ...@@ -389,7 +389,7 @@ public class ExcelUtils {
String returnValue = null; String returnValue = null;
switch (cell.getCellType()) { switch (cell.getCellType()) {
case NUMERIC: //数字 case NUMERIC: //数字
if (XSSFDateUtil.isCellDateFormatted(cell)) { if (DateUtil.isCellDateFormatted(cell)) {
Date d = cell.getDateCellValue(); Date d = cell.getDateCellValue();
returnValue = XDateUtils.getDateTimeString(d); returnValue = XDateUtils.getDateTimeString(d);
} else { } else {
......
C00-common/pps-common/src/main/java/pps/core/common/utils/ExceptionHelper.java deleted 100644 → 0
View file @ efd7bba6
package pps.core.common.utils;
import java.io.PrintWriter;
import java.io.StringWriter;
public class ExceptionHelper {
public static final String LINE_SEPERTOR = System.getProperty("line.separator");
public static String getExceptionLogDetail(Throwable e) {
StringWriter writer = new StringWriter();
PrintWriter printWriter = new PrintWriter(writer);
try {
e.printStackTrace(printWriter);
printWriter.flush();
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.append("EXCEPTION:").append(e.getClass().getName()).append(LINE_SEPERTOR)
.append(" Message:").append(e.getMessage()).append(LINE_SEPERTOR)
.append(" Stack:").append(writer.toString());
return stringBuilder.toString();
// return "EXCEPTION:" + e.getClass().getName() + lineSepertor
// + " Message:" + e.getMessage() + lineSepertor
// + " StackTrack:" + writer.toString();
} finally {
printWriter.close();
}
}
}
C00-common/pps-common/src/main/java/pps/core/common/utils/FiveSecondsTimerJobHelper.java deleted 100644 → 0
View file @ efd7bba6
package pps.core.common.utils;
import cn.hutool.core.date.DateUtil;
import xstartup.base.XContext;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.locks.ReentrantLock;
public enum FiveSecondsTimerJobHelper implements Runnable {
INSTANCE;
private ReentrantLock lock = new ReentrantLock();
private Thread timerThread;
private List<Runnable> tasks = new ArrayList<>();
private XContext context;
public XContext getContext() {
return context;
}
public void setContext(XContext context) {
this.context = context;
}
public void register(Runnable runnable) {
lock.lock();
try {
this.tasks.add(runnable);
CounterBuilder.globalCounterBuilder.setFieldValue("FiveSecondsTimer-Tasks", this.tasks.size() + "");
if (timerThread == null) {
// 启动线程
timerThread = new Thread(this);
timerThread.setName("FiveSecondsTimerJobThread");
timerThread.start();
}
} finally {
lock.unlock();
}
}
@Override
public void run() {
try {
while (true) {
this.tasks.forEach(task -> {
try {
task.run();
} catch (Exception ex) {
CounterBuilder.globalCounterBuilder.addCounter("FiveSecondsTimerTaskException");
CounterBuilder.globalCounterBuilder.addCounter(ex, this.getClass());
}
});
Thread.sleep(5000);
CounterBuilder.globalCounterBuilder.addCounter("FiveSecondsTimer");
CounterBuilder.globalCounterBuilder.setFieldValue("FiveSecondsTimer-LastTime", DateUtil.date().toString());
}
} catch (Exception ex) {
CounterBuilder.globalCounterBuilder.addCounter(ex, this.getClass());
}
}
}
C00-common/pps-common/src/main/java/pps/core/common/utils/GlobalExecutorService.java deleted 100644 → 0
View file @ efd7bba6
package pps.core.common.utils;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;
public enum GlobalExecutorService {
INSTANCE;
private final ExecutorService executor = new ThreadPoolExecutor(10, 100, 100, TimeUnit.SECONDS, new LinkedBlockingQueue<>());
private AtomicLong runningTaskCounter = new AtomicLong(0);
private AtomicLong taskCounter = new AtomicLong(0);
public void execute(Runnable runnable) {
this.executor.execute(runnable);
runningTaskCounter.getAndAdd(1);
taskCounter.getAndAdd(1);
}
public void executeDone(int count) {
runningTaskCounter.addAndGet(-count);
}
public long getRunningTasksCount() {
return runningTaskCounter.get();
}
public long getTasksCount() {
return taskCounter.get();
}
}
C00-common/pps-common/src/main/java/pps/core/common/utils/HttpTookit.java deleted 100644 → 0
View file @ efd7bba6
package pps.core.common.utils;
import org.apache.commons.lang3.StringUtils;
import org.apache.http.HttpEntity;
import org.apache.http.NameValuePair;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.net.ssl.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.URLEncoder;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
/**
* @author lixueyan
* @date 2022/9/29 0029 21:34
*/
public class HttpTookit {
public static final String CHARSET = "UTF-8";
public static final int DEF_CONN_TIMEOUT = 30000;
public static final int DEF_READ_TIMEOUT = 30000;
private static final CloseableHttpClient httpClient;
/**
* 忽视证书HostName
*/
public static HostnameVerifier ignoreHostnameVerifier = new HostnameVerifier() {
public boolean verify(String s, SSLSession sslsession) {
System.out.println("WARNING: Hostname is not matched for cert.");
return true;
}
};
/**
* Ignore Certification
*/
public static TrustManager ignoreCertificationTrustManger = new X509TrustManager() {
private X509Certificate[] certificates;
public void checkClientTrusted(X509Certificate certificates[],
String authType) throws CertificateException {
if (this.certificates == null) {
this.certificates = certificates;
}
}
public void checkServerTrusted(X509Certificate[] ax509certificate,
String s) throws CertificateException {
if (this.certificates == null) {
this.certificates = ax509certificate;
}
}
public X509Certificate[] getAcceptedIssuers() {
return new java.security.cert.X509Certificate[0];
}
};
private static Logger logger = LoggerFactory.getLogger(HttpTookit.class);
static {
RequestConfig config = RequestConfig.custom().setConnectTimeout(300000).setSocketTimeout(300000).build();
httpClient = HttpClientBuilder.create().setDefaultRequestConfig(config).build();
}
public static String doGet(String url, Map<String, Object> params) {
if (isHttps(url)) {
return sendSSLPostMethod(url, params);
} else {
return doGet(url, params, CHARSET);
}
}
public static String doPost(String url, Map<String, Object> params) {
return doPost(url, params, CHARSET);
}
/**
* HTTP Get 获取内容
*
* @param url 请求的url地址 ?之前的地�?
* @param params 请求的参数
* @param charset 编码格式
* @return 页面内容
*/
public static String doGet(String url, Map<String, Object> params, String charset) {
if (StringUtils.isBlank(url)) {
return null;
}
HttpGet httpGet = null;
try {
if (params != null && !params.isEmpty()) {
List<NameValuePair> pairs = new ArrayList<NameValuePair>(params.size());
for (Map.Entry<String, Object> entry : params.entrySet()) {
if (entry.getValue() != null) {
pairs.add(new BasicNameValuePair(entry.getKey(), entry.getValue().toString()));
}
}
url += "?" + EntityUtils.toString(new UrlEncodedFormEntity(pairs, charset));
}
logger.info("=======HttpTookit 请求url地址： " + url + "==========");
httpGet = new HttpGet(url);
CloseableHttpResponse response = httpClient.execute(httpGet);
int statusCode = response.getStatusLine().getStatusCode();
if (statusCode != 200) {
httpGet.abort();
throw new RuntimeException("HttpClient,error status code :" + statusCode);
}
HttpEntity entity = response.getEntity();
String result = null;
if (entity != null) {
result = EntityUtils.toString(entity, "utf-8");
}
EntityUtils.consume(entity);
response.close();
return result;
} catch (IOException e) {
e.printStackTrace();
throw new RuntimeException("httpclient请求失败");
} finally {
if (httpGet != null) httpGet.releaseConnection();
}
}
/**
* HTTP Post 获取内容
*
* @param url 请求的url地址 ?之前的地�?
* @param params 请求的参�?
* @param charset 编码格式
* @return 页面内容
*/
public static String doPost(String url, Map<String, Object> params, String charset) {
if (StringUtils.isBlank(url)) {
return null;
}
HttpPost httpPost = null;
CloseableHttpResponse response = null;
try {
List<NameValuePair> pairs = null;
if (params != null && !params.isEmpty()) {
pairs = new ArrayList<NameValuePair>(params.size());
for (Map.Entry<String, Object> entry : params.entrySet()) {
if (entry.getValue() != null) {
pairs.add(new BasicNameValuePair(entry.getKey(), entry.getValue().toString()));
}
}
}
httpPost = new HttpPost(url);
httpPost.setHeader("serialSeq", "1212121");
httpPost.setHeader("verChl", "0.0.1");
httpPost.setHeader("sendChl", "hzsmk.test");
httpPost.setHeader("sendClient", "hellohzsmk");
httpPost.setHeader("sendDev", "121aqweq");
if (pairs != null && pairs.size() > 0) {
httpPost.setEntity(new UrlEncodedFormEntity(pairs, CHARSET));
}
response = httpClient.execute(httpPost);
int statusCode = response.getStatusLine().getStatusCode();
if (statusCode != 200) {
httpPost.abort();
throw new RuntimeException("HttpClient,error status code :" + statusCode);
}
HttpEntity entity = response.getEntity();
String result = null;
if (entity != null) {
result = EntityUtils.toString(entity, "utf-8");
}
EntityUtils.consume(entity);
response.close();
return result;
} catch (IOException e) {
e.printStackTrace();
throw new RuntimeException("httpclient请求失败");
} finally {
if (httpPost != null) httpPost.releaseConnection();
}
}
/**
* 初始化http请求参数
*
* @param url
* @param method
* @return
* @throws Exception
*/
protected static HttpsURLConnection initHttps(String url, String method,
Map<String, String> headers) throws Exception {
TrustManager[] tm = {new MyX509TrustManager()};
System.setProperty("https.protocols", "TLSv1");
SSLContext sslContext = SSLContext.getInstance("TLS");
sslContext.init(null, tm, new java.security.SecureRandom());
//sslContext.init(null, tm, null);
// 从上述SSLContext对象中得到SSLSocketFactory对象
SSLSocketFactory ssf = sslContext.getSocketFactory();
URL _url = new URL(url);
HttpsURLConnection http = (HttpsURLConnection) _url.openConnection();
// 设置域名校验
http.setHostnameVerifier(new TrustAnyHostnameVerifier());
// 连接超时
http.setConnectTimeout(DEF_CONN_TIMEOUT);
// 读取超时 --服务器响应比较慢，增大时间
http.setReadTimeout(DEF_READ_TIMEOUT);
http.setUseCaches(false);
http.setRequestMethod(method);
/* http.setRequestProperty("Content-Type",
"application/x-www-form-urlencoded");
http.setRequestProperty(
"User-Agent",
"Mozilla/5.0 (Windows NT 6.3; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/33.0.1750.146 Safari/537.36");*/
if (null != headers && !headers.isEmpty()) {
for (Entry<String, String> entry : headers.entrySet()) {
http.setRequestProperty(entry.getKey(), entry.getValue());
}
}
http.setSSLSocketFactory(ssf);
http.setDoOutput(true);
http.setDoInput(true);
try {
http.connect();
} catch (Exception ex) {
logger.info(ex.getMessage());
}
return http;
}
/**
* 功能描述: 构造请求参数
*
* @return 返回类型:
* @throws Exception
*/
public static String initParams(String url, Map<String, Object> params)
throws Exception {
if (null == params || params.isEmpty()) {
return url;
}
StringBuilder sb = new StringBuilder(url);
if (url.indexOf("?") == -1) {
sb.append("?");
}
sb.append(map2Url(params));
return sb.toString();
}
/**
* map构造url
*
* @return 返回类型:
* @throws Exception
*/
public static String map2Url(Map<String, Object> paramToMap)
throws Exception {
if (null == paramToMap || paramToMap.isEmpty()) {
return null;
}
StringBuffer url = new StringBuffer();
boolean isfist = true;
for (Entry<String, Object> entry : paramToMap.entrySet()) {
if (isfist) {
isfist = false;
} else {
url.append("&");
}
url.append(entry.getKey()).append("=");
String value = entry.getValue().toString();
if (!StringUtils.isEmpty(value)) {
url.append(URLEncoder.encode(value, CHARSET));
}
}
return url.toString();
}
/**
* 检测是否https
*
* @param url
*/
protected static boolean isHttps(String url) {
return url.startsWith("https");
}
public static String sendSSLGetMethod(String urlString) throws Exception {
String repString = null;
InputStream is = null;
HttpsURLConnection connection = null;
try {
URL url = new URL(urlString);
/*
* use ignore host name verifier
*/
HttpsURLConnection.setDefaultHostnameVerifier(ignoreHostnameVerifier);
connection = (HttpsURLConnection) url.openConnection();
// Prepare SSL Context
TrustManager[] tm = {ignoreCertificationTrustManger};
SSLContext sslContext = SSLContext.getInstance("SSL", "SunJSSE");
sslContext.init(null, tm, new java.security.SecureRandom());
// 从上述SSLContext对象中得到SSLSocketFactory对象
SSLSocketFactory ssf = sslContext.getSocketFactory();
connection.setSSLSocketFactory(ssf);
if (connection.getResponseCode() != 200) {
}
is = connection.getInputStream();
BufferedReader read = new BufferedReader(new InputStreamReader(is, "UTF-8"));
String valueString = null;
StringBuffer bufferRes = new StringBuffer();
while ((valueString = read.readLine()) != null) {
bufferRes.append(valueString);
}
return bufferRes.toString();
} catch (Exception ex) {
logger.error(ex.getMessage());
ex.printStackTrace();
} finally {
if (null != is) {
is.close();
is = null;
}
if (null != connection) {
connection.disconnect();
}
}
return repString;
}
public static String sendSSLPostMethod(String urlString, String postData) throws Exception {
String repString = null;
InputStream is = null;
HttpsURLConnection connection = null;
try {
URL url = new URL(urlString);
/*
* use ignore host name verifier
*/
HttpsURLConnection.setDefaultHostnameVerifier(ignoreHostnameVerifier);
// Prepare SSL Context
TrustManager[] tm = {ignoreCertificationTrustManger};
SSLContext sslContext = SSLContext.getInstance("SSL", "SunJSSE");
sslContext.init(null, tm, new java.security.SecureRandom());
// 从上述SSLContext对象中得到SSLSocketFactory对象
SSLSocketFactory ssf = sslContext.getSocketFactory();
connection = (HttpsURLConnection) url.openConnection();
connection.setSSLSocketFactory(ssf);
connection.setDoInput(true);
connection.setDoOutput(true);
connection.setRequestMethod("POST");
connection.setRequestProperty("content-type", "text/json");
connection.setRequestProperty("content-length", String.valueOf(postData.getBytes().length));
connection.getOutputStream().write(postData.getBytes("utf-8"));
connection.getOutputStream().flush();
connection.getOutputStream().close();
if (connection.getResponseCode() != 200) {
}
is = connection.getInputStream();
BufferedReader read = new BufferedReader(new InputStreamReader(is, "UTF-8"));
String valueString = null;
StringBuffer bufferRes = new StringBuffer();
while ((valueString = read.readLine()) != null) {
bufferRes.append(valueString);
}
return bufferRes.toString();
} catch (Exception ex) {
logger.error(ex.getMessage());
ex.printStackTrace();
} finally {
if (null != is) {
is.close();
is = null;
}
if (null != connection) {
connection.disconnect();
}
}
return repString;
}
public static String sendSSLPostMethod(String urlString, Map<String, Object> params) {
String repString = null;
InputStream is = null;
HttpsURLConnection connection = null;
try {
URL url = new URL(initParams(urlString, params));
/*
* use ignore host name verifier
*/
HttpsURLConnection.setDefaultHostnameVerifier(ignoreHostnameVerifier);
// Prepare SSL Context
TrustManager[] tm = {ignoreCertificationTrustManger};
SSLContext sslContext = SSLContext.getInstance("SSL", "SunJSSE");
sslContext.init(null, tm, new java.security.SecureRandom());
// 从上述SSLContext对象中得到SSLSocketFactory对象
SSLSocketFactory ssf = sslContext.getSocketFactory();
connection = (HttpsURLConnection) url.openConnection();
connection.setSSLSocketFactory(ssf);
connection.setDoInput(true);
connection.setDoOutput(true);
connection.setRequestMethod("POST");
connection.setRequestProperty("content-type", "text/json");
//connection.setRequestProperty("content-length",String.valueOf(postData.getBytes().length));
//connection.getOutputStream().write(postData.getBytes("utf-8"));
connection.getOutputStream().flush();
connection.getOutputStream().close();
if (connection.getResponseCode() != 200) {
}
is = connection.getInputStream();
} catch (Exception ex) {
logger.error(ex.getMessage());
ex.printStackTrace();
} finally {
if (null != is) {
try {
is.close();
} catch (IOException ex) {
ex.printStackTrace();
}
is = null;
}
if (null != connection) {
connection.disconnect();
}
}
return repString;
}
/**
* https 域名校验
*/
public static class TrustAnyHostnameVerifier implements HostnameVerifier {
public boolean verify(String hostname, SSLSession session) {
return true;// 直接返回true
}
}
public static class MyX509TrustManager implements X509TrustManager {
public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
}
public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
}
public X509Certificate[] getAcceptedIssuers() {
return null;
}
}
}
C00-common/pps-common/src/main/java/pps/core/common/utils/IdWorker.java deleted 100644 → 0
View file @ efd7bba6
package pps.core.common.utils;
/**
* @Description 雪花算法
*/
public class IdWorker {
private final long twepoch = 1288834974657L;
private final long workerIdBits = 5L;
private final long datacenterIdBits = 5L;
private final long maxWorkerId = -1L ^ (-1L << workerIdBits);
private final long maxDatacenterId = -1L ^ (-1L << datacenterIdBits);
private final long sequenceBits = 12L;
private final long workerIdShift = sequenceBits;
private final long datacenterIdShift = sequenceBits + workerIdBits;
private final long timestampLeftShift = sequenceBits + workerIdBits + datacenterIdBits;
private final long sequenceMask = -1L ^ (-1L << sequenceBits);
private long workerId;
private long datacenterId;
private long sequence = 0L;
private long lastTimestamp = -1L;
public IdWorker(long workerId, long datacenterId) {
if (workerId > maxWorkerId || workerId < 0) {
throw new IllegalArgumentException(String.format("worker Id can't be greater than %d or less than 0", maxWorkerId));
}
if (datacenterId > maxDatacenterId || datacenterId < 0) {
throw new IllegalArgumentException(String.format("datacenter Id can't be greater than %d or less than 0", maxDatacenterId));
}
this.workerId = workerId;
this.datacenterId = datacenterId;
}
public static void main(String[] args) {
IdWorker idWorker = new IdWorker(0, 0);
for (int i = 0; i < 100; i++) {
long id = idWorker.nextId();
System.out.println(id);
}
}
/**
* 获得下一个ID (该方法是线程安全的)
*
* @return SnowflakeId
*/
public synchronized long nextId() {
long timestamp = timeGen();
//如果当前时间小于上一次ID生成的时间戳，说明系统时钟回退过这个时候应当抛出异常
if (timestamp < lastTimestamp) {
throw new RuntimeException(
String.format("Clock moved backwards. Refusing to generate id for %d milliseconds", lastTimestamp - timestamp));
}
//如果是同一时间生成的，则进行毫秒内序列
if (lastTimestamp == timestamp) {
//如果毫秒相同，则从0递增生成序列号
sequence = (sequence + 1) & sequenceMask;
//毫秒内序列溢出
if (sequence == 0) {
//阻塞到下一个毫秒,获得新的时间戳
timestamp = tilNextMillis(lastTimestamp);
}
}
//时间戳改变，毫秒内序列重置
else {
sequence = 0L;
}
//上次生成ID的时间截
lastTimestamp = timestamp;
//移位并通过或运算拼到一起组成64位的ID
return ((timestamp - twepoch) << timestampLeftShift) //
| (workerId << workerIdShift) //
| sequence;
}
protected long tilNextMillis(long lastTimestamp) {
long timestamp = timeGen();
while (timestamp <= lastTimestamp) {
timestamp = timeGen();
}
return timestamp;
}
protected long timeGen() {
return System.currentTimeMillis();
}
}
\ No newline at end of file
C00-common/pps-common/src/main/java/pps/core/common/utils/ImportExcelUtils.java deleted 100644 → 0
View file @ efd7bba6
package pps.core.common.utils;
import org.apache.commons.lang3.StringUtils;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.DataFormatter;
import org.apache.poi.ss.usermodel.Row;
import java.util.List;
public class ImportExcelUtils {
/**
* 判断Excel当前行是否为空
*
* @param row
* @return
*/
public static boolean isRowEmpty(Row row) {
for (int c = row.getFirstCellNum(); c < row.getLastCellNum(); c++) {
Cell cell = row.getCell(c);
if (cell != null && cell.getCellType() != CellType.BLANK)
return false;
}
return true;
}
/**
* 数据非空校验
* 规则：titles 中 含有 * 的 会进行非空校验
*
* @param row
* @param titles
* @return
*/
public static String checkData(Row row, List<String> titles) {
DataFormatter formatter = new DataFormatter();
for (int i = 0; i < titles.size(); i++) {
Cell cell = row.getCell(i);
if (titles.get(i).startsWith("*") && StringUtils.isBlank(formatter.formatCellValue(cell))) {
String msg = String.format("第%s行 %s 不能为空", (i + 1), titles.get(i).replace("*", ""));
return msg;
}
}
return null;
}
}
C00-common/pps-common/src/main/java/pps/core/common/utils/IpUtils.java deleted 100644 → 0
View file @ efd7bba6
package pps.core.common.utils;
import cn.hutool.core.text.CharSequenceUtil;
import com.google.common.base.Joiner;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.servlet.http.HttpServletRequest;
import java.net.InterfaceAddress;
import java.net.NetworkInterface;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
/**
* IP地址
*
* @author lixueyan
*/
public class IpUtils {
private static Logger logger = LoggerFactory.getLogger(IpUtils.class);
private volatile static String ips;
/**
* 获取IP地址
* <p>
* 使用Nginx等反向代理软件， 则不能通过request.getRemoteAddr()获取IP地址
* 如果使用了多级反向代理的话，X-Forwarded-For的值并不止一个，而是一串IP地址，X-Forwarded-For中第一个非unknown的有效IP字符串，则为真实IP地址
*/
public static String getIpAddr(HttpServletRequest request) {
String unknown = "unknown";
String ip = null;
try {
ip = request.getHeader("x-forwarded-for");
if (StringUtils.isEmpty(ip) || unknown.equalsIgnoreCase(ip)) {
ip = request.getHeader("Proxy-Client-IP");
}
if (StringUtils.isEmpty(ip) || ip.isEmpty() || unknown.equalsIgnoreCase(ip)) {
ip = request.getHeader("WL-Proxy-Client-IP");
}
if (StringUtils.isEmpty(ip) || unknown.equalsIgnoreCase(ip)) {
ip = request.getHeader("HTTP_CLIENT_IP");
}
if (StringUtils.isEmpty(ip) || unknown.equalsIgnoreCase(ip)) {
ip = request.getHeader("HTTP_X_FORWARDED_FOR");
}
if (StringUtils.isEmpty(ip) || unknown.equalsIgnoreCase(ip)) {
ip = request.getRemoteAddr();
}
} catch (Exception e) {
logger.error("IPUtils ERROR ", e);
}
return ip;
}
public synchronized static String getHostIPs() {
return getHostIPs(false);
}
public static String getHostIPs(boolean refresh) {
if (!refresh && CharSequenceUtil.isNotBlank(ips)) {
return ips;
}
List<String> list = new ArrayList<>();
try {
Enumeration<NetworkInterface> en = NetworkInterface.getNetworkInterfaces();
while (en.hasMoreElements()) {
NetworkInterface nint = en.nextElement();
if (nint.isLoopback()) {
continue;
}
if (nint.isPointToPoint()) {
continue;
}
if (nint.isVirtual()) {
continue;
}
if (!nint.isUp()) {
continue;
}
List<InterfaceAddress> interfaceAddresses = nint.getInterfaceAddresses();
if (interfaceAddresses == null) {
continue;
}
interfaceAddresses.forEach(item -> {
String addr = item.getAddress().getHostAddress();
if (CharSequenceUtil.isNotBlank(addr)) {
list.add(addr.trim());
}
});
}
} catch (java.net.SocketException e) {
// fine, let's take is as signal of not having any interfaces
}
list.sort((x, y) -> {
return x.compareTo(y);
});
ips = Joiner.on(",").join(list);
return ips;
}
}
C00-common/pps-common/src/main/java/pps/core/common/utils/JedisHelper.java deleted 100644 → 0
View file @ efd7bba6
package pps.core.common.utils;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import redis.clients.jedis.*;
import xstartup.base.XServiceContext;
import xstartup.base.XStartup;
import xstartup.base.exception.XServiceException;
import xstartup.base.util.XConvertUtils;
import xstartup.base.util.XEncryptUtils;
import xstartup.base.util.XStringUtils;
import xstartup.cache.redis.XRedisCacheProvider;
import xstartup.config.XConfProperties;
import xstartup.config.XConfPropertiesHelper;
import xstartup.error.XError;
import java.time.Duration;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Consumer;
/**
* @author xcd
* @version V1.0
* @Description: Jedis工具类
* @date 2022/10/27
*/
public class JedisHelper {
public static void consumeDefalutJedis(Consumer<Jedis> consumer) {
consumeJedis("", "", "", consumer);
}
public static void consumeJedis(String product, String scope, String module, Consumer<Jedis> consumer) {
JedisPool jedisPool = JedisPoolTool.getJedisPoolWrap(product, scope, module).jedisPool;
Jedis jedis = jedisPool.getResource();
try {
consumer.accept(jedis);
} finally {
if (jedis.isBroken()) {
jedisPool.returnBrokenResource(jedis);
} else {
jedisPool.returnResource(jedis);
}
}
}
public static void consumeDefalutJedisCluster(Consumer<JedisCluster> consumer) {
consumeJedisCluster("", "", "", consumer);
}
public static void consumeJedisCluster(String product, String scope, String module, Consumer<JedisCluster> consumer) {
JedisCluster resource = JedisPoolTool.getJedisClusterPoolWrap(product, scope, module).getResource();
consumer.accept(resource);
}
static class JedisPoolTool {
private static final ConcurrentHashMap<String, JedisPoolWrapper> jedisPoolMapByScope = new ConcurrentHashMap();
private static final ConcurrentHashMap<String, JedisPoolWrapper> jedisPoolMapByHostDB = new ConcurrentHashMap();
private static final ConcurrentHashMap<String, JedisClusterPoolWrapper> jedisClusterPoolMapByScope = new ConcurrentHashMap();
private static final ConcurrentHashMap<String, JedisClusterPoolWrapper> jedisClusterPoolMapByHostDB = new ConcurrentHashMap();
JedisPoolTool() {
}
static JedisPoolWrapper getGlobalJedisPoolWrap() {
return getJedisPoolWrap("", "", "");
}
static JedisPoolWrapper getJedisPoolWrap(String product, String scope, String module) {
String productScopeModule = product + "." + scope + "." + module;
JedisPoolWrapper existed = jedisPoolMapByScope.get(productScopeModule);
if (existed != null) {
return existed;
}
XServiceContext serviceContext = XServiceContext.build(XRedisCacheProvider.class.getName());
XConfProperties xConfProperties = XConfPropertiesHelper.find(serviceContext, "x.cache", "type"
, new String[]{"host", "port", "auth", "db"}, productScopeModule);
if (xConfProperties == null) {
throw new XServiceException(XError.NotFound, "缓存配置信息未找到");
}
String host = xConfProperties.getProperty("host");
String auth = xConfProperties.getProperty("auth");
try {
auth = XEncryptUtils.decrypt(auth);
} catch (XServiceException var19) {
serviceContext.getLogger().warn("redis密码解密失败:" + var19.getMessage() + ",直接使用原文:" + auth);
}
Integer port = xConfProperties.getInteger("port", 6379);
Integer db = xConfProperties.getInteger("db", 0);
if (XStringUtils.isEmpty(host)) {
throw new XServiceException(XError.NotFound, "缓存配置信息未找到(type,host)");
}
synchronized (jedisPoolMapByScope) {
//再次检查
existed = jedisPoolMapByScope.get(productScopeModule);
if (existed != null) {
return existed;
}
String hostPortDb = host + ":" + port + ":" + db;
JedisPoolWrapper poolWrapperByHostPortDB = jedisPoolMapByHostDB.get(hostPortDb);
if (poolWrapperByHostPortDB == null) {
XStartup xstartup = XStartup.getCurrent();
JedisPoolConfig poolConfig = new JedisPoolConfig();
poolConfig.setMaxTotal(XConvertUtils.tryToInteger(xstartup.getProperty("x.cache.jedis.max-total"), 10));
poolConfig.setMaxIdle(XConvertUtils.tryToInteger(xstartup.getProperty("x.cache.jedis.max-idle"), 10));
poolConfig.setMinIdle(XConvertUtils.tryToInteger(xstartup.getProperty("x.cache.jedis.min-idle"), 0));
poolConfig.setMaxWait(Duration.ofMillis((long) XConvertUtils.tryToInteger(xstartup.getProperty("x.cache.jedis.max-wait-millis"), 5000)));
poolConfig.setTestOnBorrow(false);
poolConfig.setTestOnReturn(false);
poolConfig.setTestWhileIdle(true);
poolConfig.setTimeBetweenEvictionRuns(Duration.ofMillis(10000L));
poolConfig.setMinEvictableIdleTime(Duration.ofMillis(60000L));
poolConfig.setNumTestsPerEvictionRun(2);
JedisPool jedisPool = new JedisPool(poolConfig, host, port, 3000, auth, db);
poolWrapperByHostPortDB = new JedisPoolWrapper(jedisPool, db, auth);
jedisPoolMapByHostDB.put(hostPortDb, poolWrapperByHostPortDB);
}
jedisPoolMapByScope.put(productScopeModule, poolWrapperByHostPortDB);
return poolWrapperByHostPortDB;
}
}
static JedisClusterPoolWrapper getGlobalJedisClusterPoolWrap() {
return getJedisClusterPoolWrap("", "", "");
}
static JedisClusterPoolWrapper getJedisClusterPoolWrap(String product, String scope, String module) {
String productScopeModule = product + "." + scope + "." + module;
CounterBuilder.globalCounterBuilder.setFieldValue("jedisClusterPoolMapByScope", jedisClusterPoolMapByScope.size() + "");
JedisClusterPoolWrapper existed = jedisClusterPoolMapByScope.get(productScopeModule);
if (existed != null) {
return existed;
}
XServiceContext serviceContext = XServiceContext.build(XRedisCacheProvider.class.getName());
XConfProperties xConfProperties = XConfPropertiesHelper.find(serviceContext, "x.cache", "type"
, new String[]{"host", "port", "auth"}, productScopeModule);
if (xConfProperties == null) {
throw new XServiceException(XError.NotFound, "缓存配置信息未找到");
}
String type = xConfProperties.getProperty("type");
String host = xConfProperties.getProperty("host");
String auth = xConfProperties.getProperty("auth");
try {
auth = XEncryptUtils.decrypt(auth);
} catch (XServiceException var22) {
serviceContext.getLogger().warn("redis密码解密失败:" + var22.getMessage() + ",直接使用原文:" + auth);
}
String port = xConfProperties.getProperty("port");
if (XStringUtils.isEmpty(type) || XStringUtils.isEmpty(host)) {
throw new XServiceException(XError.NotFound.getCode(), "缓存配置信息未找到");
}
String[] hostArr = host.split(",");
String[] portArr = port.split(",");
if (hostArr.length != portArr.length) {
throw new XServiceException(XError.InvalidParameterValue.getCode(), "配置信息不正确");
}
synchronized (jedisClusterPoolMapByHostDB) {
CounterBuilder.globalCounterBuilder.addCounter("JedisCluster-begin");
productScopeModule = product + "." + scope + "." + module;
JedisClusterPoolWrapper existed2 = jedisClusterPoolMapByScope.get(productScopeModule);
if (existed2 != null) {
return existed2;
}
List<String> hostPortKeyList = new ArrayList();
Set<HostAndPort> jedisClusterNode = new HashSet();
for (int index = 0; index < hostArr.length; ++index) {
hostArr[index] = hostArr[index].trim();
portArr[index] = portArr[index].trim();
jedisClusterNode.add(new HostAndPort(hostArr[index], XConvertUtils.toInteger(portArr[index])));
hostPortKeyList.add(hostArr[index] + ":" + portArr[index]);
}
hostPortKeyList.sort(String::compareTo);
String jedisPoolAddressKey = String.join(".", hostPortKeyList);
JedisClusterPoolWrapper jedisPoolByAddress = jedisClusterPoolMapByHostDB.get(jedisPoolAddressKey);
if (jedisPoolByAddress == null) {
CounterBuilder.globalCounterBuilder.addCounter("JedisCluster-build-JedisClusterPoolWrapper");
XStartup xstartup = XStartup.getCurrent();
GenericObjectPoolConfig<Connection> poolConfig = new GenericObjectPoolConfig();
poolConfig.setMaxTotal(XConvertUtils.tryToInteger(xstartup.getProperty("x.cache.jedis.max-total"), 10));
poolConfig.setMaxIdle(XConvertUtils.tryToInteger(xstartup.getProperty("x.cache.jedis.max-idle"), 10));
poolConfig.setMinIdle(XConvertUtils.tryToInteger(xstartup.getProperty("x.cache.jedis.min-idle"), 2));
poolConfig.setMaxWait(Duration.ofMillis((long) XConvertUtils.tryToInteger(xstartup.getProperty("x.cache.jedis.max-wait-millis"), 5000)));
poolConfig.setTestOnBorrow(false);
poolConfig.setTestOnReturn(false);
poolConfig.setTestWhileIdle(true);
poolConfig.setTimeBetweenEvictionRuns(Duration.ofMillis(10000L));
poolConfig.setMinEvictableIdleTime(Duration.ofMillis(60000L));
poolConfig.setNumTestsPerEvictionRun(2);
JedisClusterPoolWrapper jedisPoolWrapper = new JedisClusterPoolWrapper(jedisClusterNode, poolConfig, auth);
jedisClusterPoolMapByHostDB.put(jedisPoolAddressKey, jedisPoolWrapper);
jedisPoolByAddress = jedisPoolWrapper;
}
jedisClusterPoolMapByScope.put(productScopeModule, jedisPoolByAddress);
CounterBuilder.globalCounterBuilder.addCounter("JedisCluster-end");
return jedisPoolByAddress;
}
}
}
static class JedisPoolWrapper {
final JedisPool jedisPool;
final int db;
final String auth;
public JedisPoolWrapper(JedisPool jedisPool, int db, String auth) {
this.jedisPool = jedisPool;
this.db = db;
this.auth = auth;
}
}
static class JedisClusterPoolWrapper {
private final JedisCluster cluster;
String auth;
private Set<HostAndPort> jedisClusterNode;
private GenericObjectPoolConfig<Connection> poolConfig;
public JedisClusterPoolWrapper(Set<HostAndPort> jedisClusterNode, GenericObjectPoolConfig<Connection> poolConfig, String auth) {
this.jedisClusterNode = jedisClusterNode;
this.poolConfig = poolConfig;
this.auth = auth;
cluster = new JedisCluster(this.jedisClusterNode, 6000, 5000, 10, this.auth, this.poolConfig);
}
public JedisCluster getResource() {
return cluster;
}
}
}
C00-common/pps-common/src/main/java/pps/core/common/utils/MD5Util.java deleted 100644 → 0
View file @ efd7bba6
package pps.core.common.utils;
import java.security.MessageDigest;
/**
* @author lixueyan
* @date 2022/11/11 0011 16:11
*/
public class MD5Util {
private static byte[] md5(String s) {
MessageDigest algorithm;
try {
algorithm = MessageDigest.getInstance("MD5");
algorithm.reset();
algorithm.update(s.getBytes("UTF-8"));
byte[] messageDigest = algorithm.digest();
return messageDigest;
} catch (Exception e) {
System.out.println("MD5 Error..." + e.getMessage());
}
return null;
}
private static final String toHex(byte hash[]) {
if (hash == null) {
return null;
}
StringBuffer buf = new StringBuffer(hash.length * 2);
int i;
for (i = 0; i < hash.length; i++) {
if ((hash[i] & 0xff) < 0x10) {
buf.append("0");
}
buf.append(Long.toString(hash[i] & 0xff, 16));
}
return buf.toString();
}
public static String hash(String s) {
try {
return new String(toHex(md5(s)).getBytes("UTF-8"), "UTF-8");
} catch (Exception e) {
System.out.println("not supported charset..." + e.getMessage());
return s;
}
}
/**
* 对密码按照用户名，密码，盐进行加密
*
* @param username 用户名
* @param password 密码
* @param salt 盐
* @return
*/
public static String encryptPassword(String username, String password, String salt) {
return MD5Util.hash(username + password + salt);
}
/**
* 对密码按照密码，盐进行加密
*
* @param password 密码
* @param salt 盐
* @return
*/
public static String encryptPassword(String password, String salt) {
return MD5Util.hash(password + salt);
}
/**
* 对密码按照密码，盐进行加密
*
* @param password 密码
* @return
*/
public static String encryptPassword(String password) {
return MD5Util.hash(password);
}
}
C00-common/pps-common/src/main/java/pps/core/common/utils/NumUtils.java deleted 100644 → 0
View file @ efd7bba6
package pps.core.common.utils;
public class NumUtils {
public static void main(String[] args) {
System.out.println(digitUppercase(11120.1));
}
/**
* 数字金额大写转换
*
* @param n 数字
* @return 中文大写数字
*/
public static String digitUppercase(double n) {
//String[] fraction = {"角", "分"};
String[] digit = {"零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"};
String[][] unit = {{"", "万", "亿"}, {"", "拾", "佰", "仟"}};
String head = n < 0 ? "负" : "";
n = Math.abs(n);
String s = "";
// for (int i = 0; i < fraction.length; i++) {
// s += (digit[(int) (Math.floor(n * 10 * Math.pow(10, i)) % 10)] + fraction[i]).replaceAll("(零.)+", "");
// }
if (s.length() < 1) {
//s = "整";
}
int integerPart = (int) Math.floor(n);
for (int i = 0; i < unit[0].length && integerPart > 0; i++) {
String p = "";
for (int j = 0; j < unit[1].length && n > 0; j++) {
p = digit[integerPart % 10] + unit[1][j] + p;
integerPart = integerPart / 10;
}
s = p.replaceAll("(零.)*零$", "").replaceAll("^$", "零") + unit[0][i] + s;
}
return head + s.replaceAll("(零.)*零", "").replaceFirst("(零.)+", "").replaceAll("(零.)+", "零").replaceAll("^整$", "零整");
}
public static String getCode() {
return String.valueOf((int) ((Math.random() * 9 + 1) * 100000));
}
}
C00-common/pps-common/src/main/java/pps/core/common/utils/ScadaExecutorService.java deleted 100644 → 0
View file @ efd7bba6
package pps.core.common.utils;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;
public enum ScadaExecutorService {
INSTANCE;
private final ExecutorService executor = new ThreadPoolExecutor(1, 50, 100, TimeUnit.SECONDS, new LinkedBlockingQueue<>());
private AtomicLong runningTaskCounter = new AtomicLong(0);
private AtomicLong taskCounter = new AtomicLong(0);
public void execute(Runnable runnable) {
this.executor.execute(runnable);
runningTaskCounter.getAndAdd(1);
taskCounter.getAndAdd(1);
}
public void executeDone(int count) {
runningTaskCounter.addAndGet(-count);
}
public long getRunningTasksCount() {
return runningTaskCounter.get();
}
public long getTasksCount() {
return taskCounter.get();
}
}
C00-common/pps-common/src/main/java/pps/core/common/utils/SmartRecord.java deleted 100644 → 0
View file @ efd7bba6
package pps.core.common.utils;
import cn.hutool.core.text.CharSequenceUtil;
import xstartup.base.util.XJsonUtils;
import xstartup.base.util.XStringUtils;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
public class SmartRecord extends LinkedHashMap<String, Object> {
public SmartRecord() {
}
public SmartRecord(LinkedHashMap r) {
if (r != null) {
this.putAll(r);
}
}
public static <T> List<T> toList(List<SmartRecord> queryResult, Class<T> clz) {
final List<T> list = new ArrayList<T>();
queryResult.forEach(r -> {
list.add(r.toObj(clz));
});
return list;
}
public static List<SmartRecord> buildSmartRecords(List<LinkedHashMap<String, Object>> queryResult) {
final List<SmartRecord> list = new ArrayList<SmartRecord>();
queryResult.forEach(r -> {
list.add(new SmartRecord(r));
});
return list;
}
public Boolean boolValue(String fieldName) {
return boolValue(fieldName, Boolean.FALSE);
}
public Boolean boolValue(String fieldName, Boolean defaultValue) {
if (!this.containsKey(fieldName)) {
return defaultValue;
}
Object v = this.get(fieldName);
if (v == null) {
return Boolean.FALSE;
}
String strV = v.toString();
if (strV.equals("0") || strV.equals("false") || strV.equals("False")) {
return Boolean.FALSE;
}
return Boolean.TRUE;
}
public String strValue(String fieldName) {
return strValue(fieldName, "");
}
public String strValue(String fieldName, String defaultValue) {
if (!this.containsKey(fieldName)) {
return defaultValue;
}
Object v = this.get(fieldName);
if (v == null) {
return null;
}
return v.toString();
}
public Integer intValue(String fieldName) {
return intValue(fieldName, null);
}
public Integer intValue(String fieldName, Integer defaultValue) {
String strValue = strValue(fieldName, null);
if (CharSequenceUtil.isBlank(strValue)) {
return defaultValue;
} else {
return Integer.parseInt(strValue);
}
}
public Double doubleValue(String fieldName) {
return doubleValue(fieldName, null);
}
public Double doubleValue(String fieldName, Double defaultValue) {
String strValue = strValue(fieldName, null);
if (CharSequenceUtil.isBlank(strValue)) {
return defaultValue;
} else {
return Double.parseDouble(strValue);
}
}
public <T> T parseFromJson(String fieldName, Class<T> clz) {
String json = strValue(fieldName);
if (json == null || CharSequenceUtil.isBlank(json)) {
return null;
}
return XJsonUtils.toObject(json, clz);
}
public <T> T toObj(Class<T> clz) {
String json = XJsonUtils.toJson(this.columnOrPathToClass());
if (json == null || CharSequenceUtil.isBlank(json)) {
return null;
}
return XJsonUtils.toObject(json, clz);
}
public SmartRecord columnOrPathToClass() {
SmartRecord r = new SmartRecord();
this.keySet().forEach(k -> {
r.put(XStringUtils.columnToCamel(k), this.get(k));
});
return r;
}
public String valueJoin(String... fieldNames) {
StringBuilder sb = new StringBuilder();
for (String fieldName : fieldNames) {
String strValue = strValue(fieldName, "");
if (sb.length() > 0) {
sb.append(",");
}
sb.append(strValue);
}
return sb.toString();
}
}
C00-common/pps-common/src/main/java/pps/core/common/utils/SqlFilter.java deleted 100644 → 0
View file @ efd7bba6
package pps.core.common.utils;
import cn.hutool.core.text.CharSequenceUtil;
import com.google.common.base.Joiner;
import com.google.common.base.Splitter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class SqlFilter {
public static final List<String> BAD_KEYWORDS = Arrays.asList(
"select", "update", "delete", "insert", "truncate"
, "and", "or", "char", "into", "substr"
, "ascii", "declare", "exec", "count", "master"
, "drop", "execute", "table", "sitename", "xp_cmdshell"
, "like", "from", "grant", "use", "group_concat"
, "column_name", "information_schema.columns", "table_schema"
, "union", "where", "order", "by", "add"
, "all", "alter", "any", "as", "create"
, "in", "join", "inner", "not", "set"
, "--", "--;", ";--");
public static final Pattern PATTERN_WHITESPACE = Pattern.compile("\\s+");
public static final Splitter SPLITTER_WHITESPACE = Splitter.on(PATTERN_WHITESPACE);
public static final Joiner JOINER_WHITESPACE = Joiner.on(" ");
public static final Pattern BAD_FORM_PATTERN_KEYWORDS = Pattern.compile("^(" + String.join("|", BAD_KEYWORDS) + ")$", Pattern.CASE_INSENSITIVE);
public static final String BAD_FORM_PATTERN_STR = "'|\\*|/|\\\\|--.*";//过滤掉的sql关键字，特殊字符前面需要加\\进行转义
public static final Pattern BAD_FORM_PATTERN = Pattern.compile(BAD_FORM_PATTERN_STR, Pattern.CASE_INSENSITIVE);
public static final String filterValue(String original) {
if (CharSequenceUtil.isBlank(original)) {
return original;
}
original = original.trim();
if (CharSequenceUtil.isBlank(original)) {
return original;
}
if (!PATTERN_WHITESPACE.matcher(original).find()) {
//没有空格
return filterValueNoSpace(original);
}
List<String> keywords = SPLITTER_WHITESPACE.splitToList(original);
List<String> fixedKeywords = new ArrayList<String>(keywords.size());
keywords.forEach(keyword -> {
String fixed = filterValueNoSpace(keyword);
if (CharSequenceUtil.isNotBlank(fixed)) {
fixedKeywords.add(fixed);
}
});
if (fixedKeywords.isEmpty()) {
return "";
}
return JOINER_WHITESPACE.join(fixedKeywords);
}
private static String filterValueNoSpace(String original) {
//关键字查询
Matcher matcher = BAD_FORM_PATTERN_KEYWORDS.matcher(original);
if (matcher.find()) {
return "";
}
Matcher matcher1 = BAD_FORM_PATTERN.matcher(original);
if (matcher1.find()) {
original = matcher1.replaceAll("");
}
return original;
}
}
C00-common/pps-common/src/main/java/pps/core/common/utils/StringAlignHelper.java deleted 100644 → 0
View file @ efd7bba6
package pps.core.common.utils;
public class StringAlignHelper {
/**
* 复制字符
*
* @param c 字符
* @param num 数量
* @return 新字符串
*/
public static String dup(char c, int num) {
if (c == 0 || num < 1) {
return "";
}
if (num == 1) {
return c + "";
}
StringBuilder sb = new StringBuilder(num);
for (int i = 0; i < num; i++) {
sb.append(c);
}
return sb.toString();
}
public static void dup(char c, int num, StringBuilder sb) {
if (c == 0 || num < 1) {
return;
}
for (int i = 0; i < num; i++) {
sb.append(c);
}
return;
}
/**
* 在字符串左侧填充一定数量的特殊字符
*
* @param o 可被 toString 的对象
* @param width 字符数量
* @param c 字符
* @return 新字符串
*/
public static String alignRight(Object o, int width, char c) {
if (null == o) {
return null;
}
String s = o.toString();
int len = charLength(s);
if (len >= width) {
return s;
}
return new StringBuilder(width).append(dup(c, width - len)).append(s).toString();
}
/**
* 在字符串右侧填充一定数量的特殊字符
*
* @param o 可被 toString 的对象
* @param width 字符数量
* @param c 字符
* @return 新字符串
*/
public static String alignLeft(Object o, int width, char c) {
if (null == o) {
return null;
}
String s = o.toString();
int length = charLength(s);
if (length >= width) {
return s;
}
return new StringBuilder(width).append(s).append(dup(c, width - length)).toString();
}
public static String alignCenter(Object o, int width, char c) {
if (null == o) {
return null;
}
String s = o.toString();
int length = charLength(s);
if (length >= width) {
return s;
}
int half = (width - length) / 2;
StringBuilder stringBuilder = new StringBuilder(width);
dup(c, half, stringBuilder);
stringBuilder.append(s);
dup(c, width - length - half, stringBuilder);
return stringBuilder.toString();
}
public static boolean isFullWidthCharacter(char c) {
// 全角空格为12288，半角空格为32
// 其他字符半角(33-126)与全角(65281-65374)的对应关系是：均相差65248
// 全角空格 || 其他全角字符
if (c == 12288 || (c > 65280 && c < 65375)) {
return true;
}
// 中文全部是全角
if (isChineseCharacter(c)) {
return true;
}
// 日文判断
// 全角平假名 u3040 - u309F
// 全角片假名 u30A0 - u30FF
if (c >= '\u3040' && c <= '\u30FF') {
return true;
}
return false;
}
/**
* 是中文字符吗?
*
* @param c 待判定字符
* @return 判断结果
*/
public static boolean isChineseCharacter(char c) {
Character.UnicodeBlock ub = Character.UnicodeBlock.of(c);
if (ub == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS
|| ub == Character.UnicodeBlock.CJK_COMPATIBILITY_IDEOGRAPHS
|| ub == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A
|| ub == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B
|| ub == Character.UnicodeBlock.CJK_SYMBOLS_AND_PUNCTUATION
|| ub == Character.UnicodeBlock.HALFWIDTH_AND_FULLWIDTH_FORMS
|| ub == Character.UnicodeBlock.GENERAL_PUNCTUATION) {
return true;
}
return false;
}
/**
* 计算字符串的字符长度(全角算2, 半角算1)
*
* @param str 被计算的字符串
* @return 字符串的字符长度
*/
public static int charLength(CharSequence str) {
int clength = 0;
for (int i = 0; i < str.length(); i++) {
clength += isFullWidthCharacter(str.charAt(i)) ? 2 : 1;
}
return clength;
}
}
C00-common/pps-common/src/main/java/pps/core/common/utils/ThreadHelper.java deleted 100644 → 0
View file @ efd7bba6
package pps.core.common.utils;
import cn.hutool.core.text.CharSequenceUtil;
import java.util.ArrayList;
import java.util.Set;
public class ThreadHelper {
public static final String LINE_SEPERATOR = System.getProperty("line.separator");
public static String buildThreadsSimpleInfos(StringBuilder sb) {
if (sb == null) {
sb = new StringBuilder();
}
try {
Set<Thread> threadSet = Thread.getAllStackTraces().keySet();
ArrayList<Thread> threads = new ArrayList<>(threadSet.size());
threads.addAll(threadSet);
threads.sort((x, y) -> x.getName().compareTo(y.getName()));
//int i = 0;
for (Thread t : threads) {
//i++;
sb.append(t.getName());
sb.append("(");
sb.append(t.getId());
sb.append("),");
}
sb.append("TOTAL : ").append(threadSet.size());
} catch (Exception ex) {
}
return sb.toString();
}
public static void buildThreadsInfos(StringBuilder sb) {
if (sb == null) {
sb = new StringBuilder();
}
Set<Thread> threadSet = Thread.getAllStackTraces().keySet();
ArrayList<Thread> threads = new ArrayList<>(threadSet.size());
threads.addAll(threadSet);
threads.sort((x, y) -> x.getName().compareTo(y.getName()));
//int i = 0;
for (Thread t : threads) {
//i++;
sb.append("[");
sb.append(t.getName());
sb.append("] ID:");
sb.append(t.getId());
sb.append(LINE_SEPERATOR);
sb.append(arrayToString(t.getStackTrace(), LINE_SEPERATOR));
sb.append(LINE_SEPERATOR);
sb.append(LINE_SEPERATOR);
}
sb.append("TOTAL : ").append(threadSet.size()).append(LINE_SEPERATOR);
for (Thread item : threads) {
sb.append(item.getName()).append(LINE_SEPERATOR);
}
}
public static String arrayToString(Object[] a, String seperator) {
if (a == null)
return "null";
int iMax = a.length - 1;
if (iMax == -1)
return "[]";
if (CharSequenceUtil.isBlank(seperator))
seperator = ", ";
StringBuilder b = new StringBuilder();
b.append('[');
for (int i = 0; ; i++) {
b.append(a[i]);
if (i == iMax) {
return b.append(']').toString();
}
b.append(seperator);
}
}
}
C00-common/pps-common/src/main/java/pps/core/common/utils/TimeSpanChecker.java deleted 100644 → 0
View file @ efd7bba6
package pps.core.common.utils;
import cn.hutool.core.text.CharSequenceUtil;
import java.util.concurrent.ConcurrentHashMap;
public class TimeSpanChecker {
public final static int TIMESPAN_MS_5s = 5 * 1000;
public final static int TIMESPAN_MS_10s = 10 * 1000;
public final static int TIMESPAN_MS_15s = 15 * 1000;
public final static int TIMESPAN_MS_30s = 30 * 1000;
public final static int TIMESPAN_MS_1m = 60 * 1000;
public final static int TIMESPAN_MS_5m = 5 * 60 * 1000;
public final static int TIMESPAN_MS_10m = 10 * 60 * 1000;
public final static int TIMESPAN_MS_30m = 30 * 60 * 1000;
public final static int TIMESPAN_MS_1h = 60 * 60 * 1000;
public final static int TIMESPAN_MS_1d = 24 * 60 * 60 * 1000;
private static final ConcurrentHashMap<String, TimeSpanChecker> checkers = new ConcurrentHashMap<>();
private final boolean skipFirstCheck;
private long preCheckTimeMs = 0;
private int seconds = 5;
public TimeSpanChecker(int _seconds) {
this.seconds = _seconds;
this.skipFirstCheck = true;
}
// public Date getPreCheckTimeMs() {
// return preCheckTimeMs;
// }
public TimeSpanChecker(int _seconds, boolean _skipFirstCheck) {
this.seconds = _seconds;
this.skipFirstCheck = _skipFirstCheck;
}
public static int getChecksSize() {
return checkers.size();
}
public static boolean checkNow(String checkerName, int seconds) {
return checkNow(checkerName, seconds, true);
}
public static boolean checkNow(String checkerName, int seconds, boolean skipFirstCheck) {
if (CharSequenceUtil.isBlank(checkerName) || seconds <= 0) {
return false;
}
if (checkers.containsKey(checkerName)) {
checkers.put(checkerName, new TimeSpanChecker(seconds, skipFirstCheck));
}
return checkers.get(checkerName).checkNow();
}
public static double timeUsed(Runnable runnable) {
long start = System.currentTimeMillis();
runnable.run();
long end = System.currentTimeMillis();
return (end - start) / 1000.0;
}
public boolean isSkipFirstCheck() {
return skipFirstCheck;
}
public int getSeconds() {
return seconds;
}
public void setSeconds(int seconds) {
this.seconds = seconds;
}
public boolean checkNow() {
if (preCheckTimeMs == 0) {
if (skipFirstCheck) {
preCheckTimeMs = System.currentTimeMillis();
return false;
} else {
preCheckTimeMs = System.currentTimeMillis();
return true;
}
}
double ms = System.currentTimeMillis() - this.preCheckTimeMs;
if (ms >= this.seconds * 1000) {
preCheckTimeMs = System.currentTimeMillis();
return true;
}
return false;
}
}
C00-common/pps-common/src/main/java/pps/core/common/utils/TraceHelper.java deleted 100644 → 0
View file @ efd7bba6
package pps.core.common.utils;
import cn.hutool.core.text.CharSequenceUtil;
import org.joor.Reflect;
import xstartup.base.XContext;
import xstartup.base.util.XJsonUtils;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicLong;
public class TraceHelper {
public static final String FORM_DATA_TRACE_BUILDER = "TRACE_LOG_BUILDER";
public static final int TITLE_LENGTH = 30;
private static final ConcurrentHashMap<String, TraceBuilder> traceBuilders = new ConcurrentHashMap<>();
private static TimeSpanChecker timeSpanChecker = new TimeSpanChecker(300, true);
private static AtomicLong builtTraceTotalCount = new AtomicLong(0);
private static AtomicLong removedTraceTotalCount = new AtomicLong(0);
public static long getTraceBuildersCount() {
return traceBuilders.size();
}
public static long getBuiltTraceTotalCount() {
return builtTraceTotalCount.get();
}
public static long getRemovedTotalCount() {
return removedTraceTotalCount.get();
}
public static int getTraceCount() {
return traceBuilders.size();
}
public static TraceBuilder buildTraceBuilder(XContext context) {
return buildTraceBuilder(context.getTraceId(), context);
}
public static TraceBuilder buildTraceBuilder(String traceId, XContext context) {
if (timeSpanChecker.checkNow()) {
cleanTraceBuilder();
}
if (CharSequenceUtil.isNotBlank(traceId) && traceBuilders.contains(traceId)) {
return traceBuilders.get(traceId);
}
if (CharSequenceUtil.isBlank(traceId)) {
traceId = UUID.randomUUID().toString().replace("-", "");
}
CounterBuilder.globalCounterBuilder.addCounter("TraceBuilder-New");
String userName = context != null && context.getUser() != null ? (context.getUser().getName() + ",") : "无，";
TraceBuilder builder = new TraceBuilder(traceId);
builder.getItems().add("[" + DateUtil.getCurrentDateTimeWithMs() + "]" + StringAlignHelper.alignRight(userName + "BUILT", TITLE_LENGTH, '=') + "|" + (context == null || context.getLogTag() == null ? "" : context.getLogTag()));
appendTraceLog(builder, "IPs", IpUtils.getHostIPs());
appendTraceLog(builder, "Thread", Thread.currentThread().getName());
appendTraceLog(builder, "ComponentBuildTime", ManifestComponentInfoHelper.getManifestComponentInfo("pps", "pps-common").getBuildTime());
if (context != null) {
context.setAdditionalData(TraceHelper.FORM_DATA_TRACE_BUILDER, builder);
}
traceBuilders.put(traceId, builder);
builtTraceTotalCount.incrementAndGet();
CounterBuilder.globalCounterBuilder.addCounter("TraceHelper-builtTraceTotalCount");
return builder;
}
public static TraceBuilder getTraceBuilder(String traceId) {
try {
if (CharSequenceUtil.isBlank(traceId)) {
return null;
}
if (timeSpanChecker.checkNow()) {
cleanTraceBuilder();
}
return traceBuilders.get(traceId);
} catch (Exception e) {
return null;
}
}
private static void cleanTraceBuilder() {
synchronized (timeSpanChecker) {
Iterator<Map.Entry<String, TraceBuilder>> it = traceBuilders.entrySet().iterator();
while (it.hasNext()) {
Map.Entry<String, TraceBuilder> item = it.next();
double seconds = (System.currentTimeMillis() - item.getValue().getTraceTime()) / 1000.0;
if (seconds > 300) {
it.remove();
removedTraceTotalCount.incrementAndGet();
CounterBuilder.globalCounterBuilder.addCounter("TraceHelper-removedTraceTotalCount");
}
}
}
}
public static TraceHelper.TraceBuilder getTraceBuilder(XContext context) {
if (context == null) {
return null;
}
TraceBuilder traceBuilder = (TraceBuilder) context.getAdditionalData(FORM_DATA_TRACE_BUILDER);
if (traceBuilder != null) {
return traceBuilder;
}
return getTraceBuilder(context.getTraceId());
}
public static void appendTraceLog(XContext context, String title) {
appendTraceLog(context, title, null);
}
public static void appendTraceLog(TraceBuilder builder, String title) {
appendTraceLog(builder, title, null);
}
public static void appendTraceLog(XContext context, Throwable e) {
appendTraceLog(context, "EXCEPTION", e.getMessage());
appendTraceLog(context, "EXCEPTION", ExceptionHelper.getExceptionLogDetail(e));
}
public static void appendTraceLog(TraceBuilder builder, Throwable e) {
appendTraceLog(builder, "EXCEPTION", e.getMessage());
appendTraceLog(builder, "EXCEPTION", ExceptionHelper.getExceptionLogDetail(e));
}
public static void appendTraceLog(XContext context, String title, Object detail) {
if (context == null) {
return;
}
TraceHelper.TraceBuilder traceBuilder = getTraceBuilder(context);
if (traceBuilder == null) {
return;
}
appendTraceLog(traceBuilder, title, detail);
}
public static void appendTraceLog(TraceBuilder traceBuilder, String title, Object detail) {
if (traceBuilder == null) {
return;
}
String detailStr = detail == null ? "" : ("====> " + detail);
long latestTime = System.currentTimeMillis();
traceBuilder.getItems().add("[" + DateUtil.getCurrentDateTimeWithMs() + "]" + StringAlignHelper.alignRight(title, TITLE_LENGTH, '=') + "|" + detailStr);
traceBuilder.setLatestTime(latestTime);
}
public static void appendTraceLogLineSeperator(XContext context) {
TraceHelper.TraceBuilder traceBuilder = getTraceBuilder(context);
if (traceBuilder == null) {
return;
}
appendTraceLogLineSeperator(traceBuilder);
}
public static void appendTraceLogLineSeperator(TraceBuilder traceBuilder) {
if (traceBuilder == null) {
return;
}
long latestTime = System.currentTimeMillis();
traceBuilder.getItems().add("-----------------------------------------------------------------------------------------------------------------------------------");
traceBuilder.setLatestTime(latestTime);
}
public static void appendTraceLogWithSpan(XContext context, String title) {
appendTraceLogWithSpan(context, title, null);
}
public static void appendTraceLogWithSpan(TraceBuilder traceBuilder, String title) {
appendTraceLogWithSpan(traceBuilder, title, null);
}
public static void appendTraceLogWithSpan(XContext context, String title, Object detail) {
TraceHelper.TraceBuilder traceBuilder = getTraceBuilder(context);
appendTraceLogWithSpan(traceBuilder, title, detail);
}
public static void appendTraceLogWithSpan(TraceBuilder traceBuilder, String title, Object detail) {
if (traceBuilder == null) {
return;
}
long latestTime = System.currentTimeMillis();
String detailStr = detail == null ? "" : ("====> " + detail.toString());
// detailStr = detailStr.replace("\\\"","\"");
detailStr += "====> USED: " + String.format("%.3fs", (latestTime - traceBuilder.getLatestTime()) / 1000.0);
traceBuilder.getItems().add("[" + DateUtil.getCurrentDateTimeWithMs() + "]" + StringAlignHelper.alignRight(title, TITLE_LENGTH, '=') + "|" + detailStr);
traceBuilder.setLatestTime(latestTime);
}
public static void appendTraceLogUsed(XContext context) {
TraceHelper.TraceBuilder traceBuilder = getTraceBuilder(context);
appendTraceLogUsed(traceBuilder);
}
public static void appendTraceLogUsed(TraceHelper.TraceBuilder traceBuilder) {
if (traceBuilder == null) {
return;
}
long latestTime = System.currentTimeMillis();
traceBuilder.setLatestTime(latestTime);
appendTraceLog(traceBuilder, StringAlignHelper.alignRight("USED", TITLE_LENGTH, '='), " " + String.format("%.3fs", (latestTime - traceBuilder.getLatestTime()) / 1000.0));
}
public static void appendTraceLogTotalTime(XContext context) {
TraceHelper.TraceBuilder traceBuilder = getTraceBuilder(context);
if (traceBuilder == null) {
return;
}
appendTraceLogTotalTime(traceBuilder);
}
public static void appendTraceLogTotalTime(TraceHelper.TraceBuilder traceBuilder) {
if (traceBuilder == null) {
return;
}
double totalTime = (System.currentTimeMillis() - traceBuilder.traceTime) / 1000.0;
appendTraceLog(traceBuilder, "TOTAL-USED", String.format(" %.3fs", totalTime));
}
public static void appendObjFields(XContext context, Object obj) {
Reflect.on(obj).fields().forEach((f, r) -> {
appendTraceLog(context, f, traceReadable(r.get()));
});
}
public static void appendObjFields(TraceHelper.TraceBuilder traceBuilder, Object obj) {
Reflect.on(obj).fields().forEach((f, r) -> {
appendTraceLog(traceBuilder, f, traceReadable(r.get()));
});
}
public static Object traceReadable(Object v) {
if (v == null) {
return v;
}
if (v instanceof String) {
return v;
}
if (v instanceof Number) {
return v;
}
if (v instanceof Boolean) {
return v;
}
if (v instanceof Collections) {
return XJsonUtils.toJson(v);
}
return v.toString();
}
public static void removeTraceBuilder(XContext context) {
if (context == null) {
return;
}
TraceHelper.TraceBuilder traceBuilder = getTraceBuilder(context);
if (traceBuilder != null) {
context.removeAdditionalData(TraceHelper.FORM_DATA_TRACE_BUILDER);
if (traceBuilders.contains(traceBuilder.getTraceId())) {
traceBuilders.remove(traceBuilder.getTraceId());
}
}
}
public static class TraceBuilder {
private static final String NEW_LINE = System.getProperty("line.separator");
private final String traceId;
private final Long traceTime = System.currentTimeMillis();
private final List<Object> items = new ArrayList<>();
private long latestTime = 0;
public TraceBuilder(String traceId) {
this.traceId = traceId;
}
public String getTraceId() {
return traceId;
}
public Long getTraceTime() {
return traceTime;
}
public List<Object> getItems() {
return items;
}
public String buildTraceLog() {
final StringBuilder builder = new StringBuilder();
items.forEach(item -> {
builder.append(item).append(NEW_LINE);
});
return builder.toString();
}
public long getLatestTime() {
return latestTime;
}
public void setLatestTime(long latestTime) {
this.latestTime = latestTime;
}
public void clear() {
items.clear();
}
}
}
C00-common/pps-common/src/main/java/pps/core/common/utils/XSSFDateUtil.java deleted 100644 → 0
View file @ efd7bba6
package pps.core.common.utils;
import org.apache.poi.ss.usermodel.DateUtil;
import java.util.Calendar;
/**
* @author lixueyan
* @date 2023/2/9 0009 13:41
*/
public class XSSFDateUtil extends DateUtil {
protected static int absoluteDay(Calendar cal, boolean use1904windowing) {
return DateUtil.absoluteDay(cal, use1904windowing);
}
}
C02-system/pps-core-system/src/main/java/pps/core/system/service/SysDictionaryService.java
View file @ 372b9739
...@@ -130,11 +130,6 @@ public class SysDictionaryService { ...@@ -130,11 +130,6 @@ public class SysDictionaryService {
if (entity.getEndTime() != null) { if (entity.getEndTime() != null) {
long l = entity.getEndTime().getTime() - System.currentTimeMillis(); long l = entity.getEndTime().getTime() - System.currentTimeMillis();
if (l > 0) { if (l > 0) {
/*List<SysDictionaryCache> list = SysDictionaryCache.list(context, alias);
SysDictionaryCache sysDictionaryCache = new SysDictionaryCache();
XCopyUtils.copyObject(entity, sysDictionaryCache);
list.add(sysDictionaryCache);
SysDictionaryCache.set(context, alias, list);*/
SysDictionaryCache.deleteCache(context, alias); SysDictionaryCache.deleteCache(context, alias);
QueryWrapper<SysDictionaryEnt> queryAlias = new QueryWrapper<>(); QueryWrapper<SysDictionaryEnt> queryAlias = new QueryWrapper<>();
queryAlias.lambda().eq(SysDictionaryEnt::getAlias, alias).gt(SysDictionaryEnt::getEndTime, new Date()); queryAlias.lambda().eq(SysDictionaryEnt::getAlias, alias).gt(SysDictionaryEnt::getEndTime, new Date());
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment