zhouxy108/hutool
1
0
Fork 0
mirror of https://gitee.com/chinabugotech/hutool.git synced 2025-08-18 20:38:02 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'upstream/v5-dev' into v5-dev

Browse Source
This commit is contained in:
lzpeng723
2020-11-29 01:00:21 +08:00
parent 211413f789 9857ac4484
commit 6e8cd83c3b
26 changed files with 3929 additions and 3267 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
CHANGELOG.md
View File

@@ -3,7 +3,7 @@
-------------------------------------------------------------------------------------------------------------
# 5.5.2 (2020-11-25)
# 5.5.2 (2020-11-26)
### 新特性
* 【crypto 】 KeyUtil增加重载，AES构造增加重载（issue#I25NNZ@Gitee）
@@ -13,9 +13,17 @@
* 【crypto 】 增加判空（issue#1230@Github）
* 【core 】 xml.setXmlStandalone(true)格式优化（pr#1234@Github）
* 【core 】 AnnotationUtil增加setValue方法（pr#1250@Github）
* 【core 】 ZipUtil增加get方法
* 【core 】 ZipUtil增加get方法（issue#I27CUF@Gitee）
* 【cache 】 对CacheObj等变量使用volatile关键字
* 【core 】 Base64增加encodeWithoutPadding方法（issue#I26J16@Gitee）
* 【core 】 ExceptionUtil增加message消息包装为运行时异常的方法（pr#1253@Gitee）
* 【core 】 DatePattern增加年月格式化常量（pr#220@Gitee）
* 【core 】 ArrayUtil增加shuffle方法（pr#1255@Github）
* 【core 】 ArrayUtil部分方法分离至PrimitiveArrayUtil
* 【crypto 】 opt改为otp包（issue#1257@Github）
* 【cache 】 增加CacheListener（issue#1257@Github）
* 【core 】 TimeInterval支持分组（issue#1238@Github）
* 【core 】 增加compile包（pr#1243@Github）
### Bug修复
* 【cron 】 修复CronTimer可能死循环的问题（issue#1224@Github）
@@ -23,6 +31,7 @@
* 【poi 】 修复ExcelUtil.getSaxReader使用非MarkSupport流报错问题（issue#1225@Github）
* 【core 】 修复HexUtil.format问题（issue#I268XT@Gitee）
* 【core 】 修复ZipUtil判断压缩文件是否位于压缩目录内的逻辑有误的问题（issue#1251@Github）
* 【json 】 修复JSONObject.accumulate问题
-------------------------------------------------------------------------------------------------------------

12
hutool-cache/src/main/java/cn/hutool/cache/Cache.java vendored
View File

@@ -45,7 +45,6 @@ public interface Cache<K, V> extends Iterable<V>, Serializable {
* @param key 键
* @param object 缓存的对象
* @param timeout 失效时长，单位毫秒
* @see Cache#put(Object, Object, long)
*/
void put(K key, V object, long timeout);
@@ -159,4 +158,15 @@ public interface Cache<K, V> extends Iterable<V>, Serializable {
* @return 是否包含key
*/
boolean containsKey(K key);
/**
* 设置监听
*
* @param listener 监听
* @return this
* @since 5.5.2
*/
default Cache<K, V> setListener(CacheListener<K, V> listener){
return this;
}
}

20
hutool-cache/src/main/java/cn/hutool/cache/CacheListener.java vendored Normal file
View File

@@ -0,0 +1,20 @@
package cn.hutool.cache;
/**
* 缓存监听，用于实现缓存操作时的回调监听，例如缓存对象的移除事件等
*
* @param <K> 缓存键
* @param <V> 缓存值
* @author looly
* @since 5.5.2
*/
public interface CacheListener<K, V> {
/**
* 对象移除回调
*
* @param key 键
* @param cachedObject 被缓存的对象
*/
void onRemove(K key, V cachedObject);
}

32
hutool-cache/src/main/java/cn/hutool/cache/impl/AbstractCache.java vendored
View File

@@ -1,6 +1,7 @@
package cn.hutool.cache.impl;
import cn.hutool.cache.Cache;
import cn.hutool.cache.CacheListener;
import cn.hutool.core.collection.CopiedIter;
import cn.hutool.core.lang.func.Func0;
@@ -45,11 +46,16 @@ public abstract class AbstractCache<K, V> implements Cache<K, V> {
/**
* 命中数
*/
protected AtomicLong hitCount;
protected AtomicLong hitCount = new AtomicLong();
/**
* 丢失数
*/
protected AtomicLong missCount;
protected AtomicLong missCount = new AtomicLong();
/**
* 缓存监听
*/
protected CacheListener<K, V> listener;
// ---------------------------------------------------------------- put start
@Override
@@ -164,7 +170,7 @@ public abstract class AbstractCache<K, V> implements Cache<K, V> {
if (co.isExpired()) {
missCount.getAndIncrement();
} else{
} else {
// 命中
hitCount.getAndIncrement();
return co.get(isUpdateLastAccess);
@@ -280,13 +286,29 @@ public abstract class AbstractCache<K, V> implements Cache<K, V> {
// ---------------------------------------------------------------- common end
/**
* 对象移除回调。默认无动作
* 设置监听
*
* @param listener 监听
* @return this
* @since 5.5.2
*/
public AbstractCache<K, V> setListener(CacheListener<K, V> listener) {
this.listener = listener;
return this;
}
/**
* 对象移除回调。默认无动作<br>
* 子类可重写此方法用于监听移除事件，如果重写，listener将无效
*
* @param key 键
* @param cachedObject 被缓存的对象
*/
protected void onRemove(K key, V cachedObject) {
// ignore
final CacheListener<K, V> listener = this.listener;
if (null != listener) {
listener.onRemove(key, cachedObject);
}
}
/**

2
hutool-cache/src/main/java/cn/hutool/cache/impl/CacheObj.java vendored
View File

@@ -19,7 +19,7 @@ public class CacheObj<K, V> implements Serializable{
/** 上次访问时间 */
private volatile long lastAccess;
/** 访问次数 */
protected AtomicLong accessCount;
protected AtomicLong accessCount = new AtomicLong();
/** 对象存活时长，0表示永久存活*/
private final long ttl;

6
hutool-cache/src/test/java/cn/hutool/cache/test/CacheTest.java vendored
View File

@@ -18,6 +18,12 @@ public class CacheTest {
@Test
public void fifoCacheTest(){
Cache<String,String> fifoCache = CacheUtil.newFIFOCache(3);
fifoCache.setListener((key, value)->{
// 监听测试，此测试中只有key1被移除，测试是否监听成功
Assert.assertEquals("key1", key);
Assert.assertEquals("value1", value);
});
fifoCache.put("key1", "value1", DateUnit.SECOND.getMillis() * 3);
fifoCache.put("key2", "value2", DateUnit.SECOND.getMillis() * 3);
fifoCache.put("key3", "value3", DateUnit.SECOND.getMillis() * 3);

146
hutool-core/src/main/java/cn/hutool/core/compiler/JavaClassFileManager.java
View File

@@ -1,12 +1,16 @@
package cn.hutool.core.compiler;
import cn.hutool.core.io.IORuntimeException;
import cn.hutool.core.io.IoUtil;
import cn.hutool.core.util.ClassLoaderUtil;
import cn.hutool.core.util.ObjectUtil;
import javax.tools.FileObject;
import javax.tools.ForwardingJavaFileManager;
import javax.tools.JavaFileManager;
import javax.tools.JavaFileObject;
import javax.tools.JavaFileObject.Kind;
import java.io.IOException;
import java.io.InputStream;
import java.security.SecureClassLoader;
import java.util.HashMap;
@@ -18,88 +22,78 @@ import java.util.Map;
* 我们采取此对象来管理运行时动态编译类生成的字节码
*
* @author lzpeng
* @see JavaSourceCompilerBak#compile()
* @see com.sun.tools.javac.api.ClientCodeWrapper.WrappedJavaFileManager#getJavaFileForOutput(javax.tools.JavaFileManager.Location, java.lang.String, javax.tools.JavaFileObject.Kind, javax.tools.FileObject)
* @since 5.5.2
*/
final class JavaClassFileManager extends ForwardingJavaFileManager<JavaFileManager> {
class JavaClassFileManager extends ForwardingJavaFileManager<JavaFileManager> {
/**
* 存储java字节码文件对象映射
*/
private final Map<String, JavaFileObject> javaFileObjectMap = new HashMap<>();
/**
* 存储java字节码文件对象映射
*/
private final Map<String, JavaFileObject> javaFileObjectMap = new HashMap<>();
/**
* 加载动态编译生成类的父类加载器
*/
private final ClassLoader parent;
/**
* 加载动态编译生成类的父类加载器
*/
private final ClassLoader parent;
/**
* 构造
*
* @param parent 父类加载器
* @param fileManager 字节码文件管理器
* @see JavaSourceCompilerBak#compile()
*/
protected JavaClassFileManager(final ClassLoader parent, final JavaFileManager fileManager) {
super(fileManager);
if (parent == null) {
this.parent = Thread.currentThread().getContextClassLoader();
} else {
this.parent = parent;
}
}
/**
* 构造
*
* @param parent 父类加载器
* @param fileManager 字节码文件管理器
*/
protected JavaClassFileManager(ClassLoader parent, JavaFileManager fileManager) {
super(fileManager);
this.parent = ObjectUtil.defaultIfNull(parent, ClassLoaderUtil.getClassLoader());
}
/**
* 获得动态编译生成的类的类加载器
*
* @param location 源码位置
* @return 动态编译生成的类的类加载器
* @see JavaSourceCompilerBak#compile()
*/
@Override
public ClassLoader getClassLoader(final Location location) {
return new SecureClassLoader(parent) {
/**
* 获得动态编译生成的类的类加载器
*
* @param location 源码位置
* @return 动态编译生成的类的类加载器
*/
@Override
public ClassLoader getClassLoader(final Location location) {
return new SecureClassLoader(parent) {
/**
* 查找类
* @param name 类名
* @return 类的class对象
* @throws ClassNotFoundException 未找到类异常
*/
@Override
protected Class<?> findClass(final String name) throws ClassNotFoundException {
final JavaFileObject javaFileObject = javaFileObjectMap.get(name);
if (javaFileObject != null) {
try {
final InputStream inputStream = javaFileObject.openInputStream();
final byte[] bytes = IoUtil.readBytes(inputStream);
final Class<?> c = defineClass(name, bytes, 0, bytes.length);
return c;
} catch (Exception e) {
e.printStackTrace();
}
}
throw new ClassNotFoundException(name);
}
};
}
/**
* 查找类
* @param name 类名
* @return 类的class对象
* @throws ClassNotFoundException 未找到类异常
*/
@Override
protected Class<?> findClass(final String name) throws ClassNotFoundException {
final JavaFileObject javaFileObject = javaFileObjectMap.get(name);
if (null != javaFileObject) {
try(final InputStream inputStream = javaFileObject.openInputStream()){
final byte[] bytes = IoUtil.readBytes(inputStream);
return defineClass(name, bytes, 0, bytes.length);
} catch (IOException e) {
throw new IORuntimeException(e);
}
}
throw new ClassNotFoundException(name);
}
};
}
/**
* 获得Java字节码文件对象
* 编译器编译源码时会将Java源码对象编译转为Java字节码对象
*
* @param location 源码位置
* @param className 类名
* @param kind 文件类型
* @param sibling 将Java源码对象
* @return Java字节码文件对象
* @see com.sun.tools.javac.api.lientCodeWrapper.WrappedJavaFileManager#getJavaFileForOutput(javax.tools.JavaFileManager.Location, java.lang.String, javax.tools.JavaFileObject.Kind, javax.tools.FileObject)
*/
@Override
public JavaFileObject getJavaFileForOutput(final Location location, final String className, final Kind kind, final FileObject sibling) {
final JavaFileObject javaFileObject = new JavaClassFileObject(className, kind);
javaFileObjectMap.put(className, javaFileObject);
return javaFileObject;
}
/**
* 获得Java字节码文件对象
* 编译器编译源码时会将Java源码对象编译转为Java字节码对象
*
* @param location 源码位置
* @param className 类名
* @param kind 文件类型
* @param sibling 将Java源码对象
* @return Java字节码文件对象
*/
@Override
public JavaFileObject getJavaFileForOutput(final Location location, final String className, final Kind kind, final FileObject sibling) {
final JavaFileObject javaFileObject = new JavaClassFileObject(className, kind);
javaFileObjectMap.put(className, javaFileObject);
return javaFileObject;
}
}

76
hutool-core/src/main/java/cn/hutool/core/compiler/JavaClassFileObject.java
View File

@@ -14,50 +14,48 @@ import java.net.URI;
* @author lzpeng
* @see JavaClassFileManager#getClassLoader(javax.tools.JavaFileManager.Location
* @see JavaClassFileManager#getJavaFileForOutput(javax.tools.JavaFileManager.Location, java.lang.String, javax.tools.JavaFileObject.Kind, javax.tools.FileObject)
* @see com.sun.tools.javac.jvm.ClassWriter.ClassWriter#writeClass(com.sun.tools.javac.code.Symbol.ClassSymbol)
* @since 5.5.2
*/
final class JavaClassFileObject extends SimpleJavaFileObject {
/**
* 字节码输出流
*/
private final ByteArrayOutputStream byteArrayOutputStream;
/**
* 字节码输出流
*/
private final ByteArrayOutputStream byteArrayOutputStream;
/**
* 构造
*
* @param className 需要编译的类名
* @param kind 需要编译的文件类型
* @see JavaClassFileManager#getJavaFileForOutput(javax.tools.JavaFileManager.Location, java.lang.String, javax.tools.JavaFileObject.Kind, javax.tools.FileObject)
*/
protected JavaClassFileObject(final String className, final Kind kind) {
super(URI.create("string:///" + className.replaceAll("\\.", "/") + kind.extension), kind);
this.byteArrayOutputStream = new ByteArrayOutputStream();
}
/**
* 构造
*
* @param className 需要编译的类名
* @param kind 需要编译的文件类型
* @see JavaClassFileManager#getJavaFileForOutput(javax.tools.JavaFileManager.Location, java.lang.String, javax.tools.JavaFileObject.Kind, javax.tools.FileObject)
*/
protected JavaClassFileObject(final String className, final Kind kind) {
super(URI.create("string:///" + className.replaceAll("\\.", "/") + kind.extension), kind);
this.byteArrayOutputStream = new ByteArrayOutputStream();
}
/**
* 获得字节码输入流
* 编译器编辑源码后，我们将通过此输出流获得编译后的字节码，以便运行时加载类
*
* @return 字节码输入流
* @see JavaClassFileManager#getClassLoader(javax.tools.JavaFileManager.Location)
*/
@Override
public InputStream openInputStream() {
final byte[] bytes = byteArrayOutputStream.toByteArray();
return new ByteArrayInputStream(bytes);
}
/**
* 获得字节码输入流
* 编译器编辑源码后，我们将通过此输出流获得编译后的字节码，以便运行时加载类
*
* @return 字节码输入流
* @see JavaClassFileManager#getClassLoader(javax.tools.JavaFileManager.Location)
*/
@Override
public InputStream openInputStream() {
return new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
}
/**
* 获得字节码输出流
* 编译器编辑源码时，会将编译结果输出到本输出流中
*
* @return 字节码输出流
* @see com.sun.tools.javac.jvm.ClassWriter.ClassWriter#writeClass(com.sun.tools.javac.code.Symbol.ClassSymbol)
*/
@Override
public OutputStream openOutputStream() {
return this.byteArrayOutputStream;
}
/**
* 获得字节码输出流
* 编译器编辑源码时，会将编译结果输出到本输出流中
*
* @return 字节码输出流
*/
@Override
public OutputStream openOutputStream() {
return this.byteArrayOutputStream;
}
}

503
hutool-core/src/main/java/cn/hutool/core/compiler/JavaSourceCompiler.java
View File

@@ -3,17 +3,31 @@ package cn.hutool.core.compiler;
import cn.hutool.core.io.FileUtil;
import cn.hutool.core.map.MapUtil;
import cn.hutool.core.util.ArrayUtil;
import cn.hutool.core.util.CharsetUtil;
import cn.hutool.core.util.ClassLoaderUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.URLUtil;
import javax.tools.*;
import javax.tools.DiagnosticCollector;
import javax.tools.JavaCompiler;
import javax.tools.JavaCompiler.CompilationTask;
import javax.tools.JavaFileObject.Kind;
import javax.tools.JavaFileManager;
import javax.tools.JavaFileObject;
import javax.tools.StandardLocation;
import javax.tools.ToolProvider;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Enumeration;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
@@ -23,270 +37,269 @@ import java.util.zip.ZipFile;
*
* @author lzpeng
*/
public final class JavaSourceCompiler {
public class JavaSourceCompiler {
/**
* java 编译器
*/
private static final JavaCompiler JAVA_COMPILER = ToolProvider.getSystemJavaCompiler();
/**
* java 编译器
*/
private static final JavaCompiler JAVA_COMPILER = ToolProvider.getSystemJavaCompiler();
/**
* 待编译的文件 可以是 .java文件 压缩文件 文件夹 递归搜索文件夹内的zip包和jar包
*/
private final List<File> sourceFileList = new ArrayList<>();
/**
* 待编译的文件 可以是 .java文件 压缩文件 文件夹 递归搜索文件夹内的zip包和jar包
*/
private final List<File> sourceFileList = new ArrayList<>();
/**
* 编译时需要加入classpath中的文件 可以是 压缩文件 文件夹递归搜索文件夹内的zip包和jar包
*/
private final List<File> libraryFileList = new ArrayList<>();
/**
* 编译时需要加入classpath中的文件 可以是 压缩文件 文件夹递归搜索文件夹内的zip包和jar包
*/
private final List<File> libraryFileList = new ArrayList<>();
/**
* 源码映射 key: 类名 value: 类源码
*/
private final Map<String, String> sourceCodeMap = new LinkedHashMap<>();
/**
* 源码映射 key: 类名 value: 类源码
*/
private final Map<String, String> sourceCodeMap = new LinkedHashMap<>();
/**
* 编译类时使用的父类加载器
*/
private final ClassLoader parentClassLoader;
/**
* 编译类时使用的父类加载器
*/
private final ClassLoader parentClassLoader;
/**
* 构造
*
* @param parent 父类加载器
*/
private JavaSourceCompiler(ClassLoader parent) {
this.parentClassLoader = parent;
}
/**
* 构造
*
* @param parent 父类加载器
*/
private JavaSourceCompiler(ClassLoader parent) {
this.parentClassLoader = parent;
}
/**
* 创建Java源码编译器
*
* @param parent 父类加载器
* @return Java源码编译器
*/
public static JavaSourceCompiler create(ClassLoader parent) {
return new JavaSourceCompiler(parent);
}
/**
* 创建Java源码编译器
*
* @param parent 父类加载器
* @return Java源码编译器
*/
public static JavaSourceCompiler create(ClassLoader parent) {
return new JavaSourceCompiler(parent);
}
/**
* 向编译器中加入待编译的文件 支持 .java, 文件夹, 压缩文件 递归搜索文件夹内的压缩文件和jar包
*
* @param files 待编译的文件 支持 .java, 文件夹, 压缩文件 递归搜索文件夹内的压缩文件和jar包
* @return Java源码编译器
*/
public JavaSourceCompiler addSource(final File... files) {
if (ArrayUtil.isNotEmpty(files)) {
this.sourceFileList.addAll(Arrays.asList(files));
}
return this;
}
/**
* 向编译器中加入待编译的文件 支持 .java, 文件夹, 压缩文件 递归搜索文件夹内的压缩文件和jar包
*
* @param files 待编译的文件 支持 .java, 文件夹, 压缩文件 递归搜索文件夹内的压缩文件和jar包
* @return Java源码编译器
*/
public JavaSourceCompiler addSource(final File... files) {
if (ArrayUtil.isNotEmpty(files)) {
this.sourceFileList.addAll(Arrays.asList(files));
}
return this;
}
/**
* 向编译器中加入待编译的源码Map
*
* @param sourceCodeMap 源码Map key: 类名 value 源码
* @return Java源码编译器
*/
public JavaSourceCompiler addSource(final Map<String, String> sourceCodeMap) {
if (MapUtil.isNotEmpty(sourceCodeMap)) {
this.sourceCodeMap.putAll(sourceCodeMap);
}
return this;
}
/**
* 向编译器中加入待编译的源码Map
*
* @param sourceCodeMap 源码Map key: 类名 value 源码
* @return Java源码编译器
*/
public JavaSourceCompiler addSource(final Map<String, String> sourceCodeMap) {
if (MapUtil.isNotEmpty(sourceCodeMap)) {
this.sourceCodeMap.putAll(sourceCodeMap);
}
return this;
}
/**
* 加入编译Java源码时所需要的jar包
*
* @param files 编译Java源码时所需要的jar包
* @return Java源码编译器
*/
public JavaSourceCompiler addLibrary(final File... files) {
if (ArrayUtil.isNotEmpty(files)) {
this.libraryFileList.addAll(Arrays.asList(files));
}
return this;
}
/**
* 加入编译Java源码时所需要的jar包
*
* @param files 编译Java源码时所需要的jar包
* @return Java源码编译器
*/
public JavaSourceCompiler addLibrary(final File... files) {
if (ArrayUtil.isNotEmpty(files)) {
this.libraryFileList.addAll(Arrays.asList(files));
}
return this;
}
/**
* 向编译器中加入待编译的源码Map
*
* @param className 类名
* @param sourceCode 源码
* @return Java文件编译器
*/
public JavaSourceCompiler addSource(final String className, final String sourceCode) {
if (className != null && sourceCode != null) {
this.sourceCodeMap.put(className, sourceCode);
}
return this;
}
/**
* 向编译器中加入待编译的源码Map
*
* @param className 类名
* @param sourceCode 源码
* @return Java文件编译器
*/
public JavaSourceCompiler addSource(final String className, final String sourceCode) {
if (className != null && sourceCode != null) {
this.sourceCodeMap.put(className, sourceCode);
}
return this;
}
/**
* 编译所有文件并返回类加载器
*
* @return 类加载器
*/
public ClassLoader compile() {
final ClassLoader parent;
if (this.parentClassLoader == null) {
parent = Thread.currentThread().getContextClassLoader();
} else {
parent = this.parentClassLoader;
}
// 获得classPath
final List<File> classPath = getClassPath();
final URL[] urLs = URLUtil.getURLs(classPath.toArray(new File[0]));
final URLClassLoader ucl = URLClassLoader.newInstance(urLs, parent);
if (sourceCodeMap.isEmpty() && sourceFileList.isEmpty()) {
// 没有需要编译的源码
return ucl;
}
// 没有需要编译的源码文件返回加载zip或jar包的类加载器
final Iterable<JavaFileObject> javaFileObjectList = getJavaFileObject();
// 创建编译器
final JavaFileManager standardJavaFileManager = JAVA_COMPILER.getStandardFileManager(null, null, null);
final JavaFileManager javaFileManager = new JavaClassFileManager(ucl, standardJavaFileManager);
final DiagnosticCollector<? super JavaFileObject> diagnosticCollector = new DiagnosticCollector<>();
final List<String> options = new ArrayList<>();
if (!classPath.isEmpty()) {
final List<String> cp = classPath.stream().map(File::getAbsolutePath).collect(Collectors.toList());
options.add("-cp");
options.addAll(cp);
}
// 编译文件
final CompilationTask task = JAVA_COMPILER.getTask(null, javaFileManager, diagnosticCollector,
options, null, javaFileObjectList);
final Boolean result = task.call();
if (Boolean.TRUE.equals(result)) {
return javaFileManager.getClassLoader(StandardLocation.CLASS_OUTPUT);
} else {
// 编译失败,收集错误信息
final List<?> diagnostics = diagnosticCollector.getDiagnostics();
final String errorMsg = diagnostics.stream().map(String::valueOf)
.collect(Collectors.joining(System.lineSeparator()));
// CompileException
throw new RuntimeException(errorMsg);
}
}
/**
* 编译所有文件并返回类加载器
*
* @return 类加载器
*/
public ClassLoader compile() {
final ClassLoader parent = ObjectUtil.defaultIfNull(this.parentClassLoader, ClassLoaderUtil.getClassLoader());
/**
* 获得编译源码时需要的classpath
*
* @return 编译源码时需要的classpath
*/
private List<File> getClassPath() {
List<File> classPathFileList = new ArrayList<>();
for (File file : libraryFileList) {
List<File> jarOrZipFile = FileUtil.loopFiles(file, this::isJarOrZipFile);
classPathFileList.addAll(jarOrZipFile);
if (file.isDirectory()) {
classPathFileList.add(file);
}
}
return classPathFileList;
}
// 获得classPath
final List<File> classPath = getClassPath();
final URL[] urLs = URLUtil.getURLs(classPath.toArray(new File[0]));
final URLClassLoader ucl = URLClassLoader.newInstance(urLs, parent);
if (sourceCodeMap.isEmpty() && sourceFileList.isEmpty()) {
// 没有需要编译的源码
return ucl;
}
// 没有需要编译的源码文件返回加载zip或jar包的类加载器
final Iterable<JavaFileObject> javaFileObjectList = getJavaFileObject();
/**
* 获得待编译的Java文件对象
*
* @return 待编译的Java文件对象
*/
private Iterable<JavaFileObject> getJavaFileObject() {
final Collection<JavaFileObject> collection = new ArrayList<>();
for (File file : sourceFileList) {
// .java 文件
final List<File> javaFileList = FileUtil.loopFiles(file, this::isJavaFile);
for (File javaFile : javaFileList) {
collection.add(getJavaFileObjectByJavaFile(javaFile));
}
// 压缩包
final List<File> jarOrZipFileList = FileUtil.loopFiles(file, this::isJarOrZipFile);
for (File jarOrZipFile : jarOrZipFileList) {
collection.addAll(getJavaFileObjectByZipOrJarFile(jarOrZipFile));
}
}
// 源码Map
collection.addAll(getJavaFileObjectByMap(this.sourceCodeMap));
return collection;
}
// 创建编译器
final JavaFileManager standardJavaFileManager = JAVA_COMPILER.getStandardFileManager(null, null, null);
final JavaFileManager javaFileManager = new JavaClassFileManager(ucl, standardJavaFileManager);
/**
* 通过源码Map获得Java文件对象
*
* @param sourceCodeMap 源码Map
* @return Java文件对象集合
*/
private Collection<JavaFileObject> getJavaFileObjectByMap(final Map<String, String> sourceCodeMap) {
if (MapUtil.isNotEmpty(sourceCodeMap)) {
return sourceCodeMap.entrySet().stream()
.map(entry -> new JavaSourceFileObject(entry.getKey(), entry.getValue(), Kind.SOURCE))
.collect(Collectors.toList());
}
return Collections.emptySet();
}
// classpath
final List<String> options = new ArrayList<>();
if (false == classPath.isEmpty()) {
final List<String> cp = classPath.stream().map(File::getAbsolutePath).collect(Collectors.toList());
options.add("-cp");
options.addAll(cp);
}
/**
* 通过.java文件创建Java文件对象
*
* @param file .java文件
* @return Java文件对象
*/
private JavaFileObject getJavaFileObjectByJavaFile(final File file) {
return new JavaSourceFileObject(file.toURI(), Kind.SOURCE);
}
// 编译文件
final DiagnosticCollector<? super JavaFileObject> diagnosticCollector = new DiagnosticCollector<>();
final CompilationTask task = JAVA_COMPILER.getTask(null, javaFileManager, diagnosticCollector,
options, null, javaFileObjectList);
if (task.call()) {
return javaFileManager.getClassLoader(StandardLocation.CLASS_OUTPUT);
} else {
// 编译失败,收集错误信息
final List<?> diagnostics = diagnosticCollector.getDiagnostics();
final String errorMsg = diagnostics.stream().map(String::valueOf)
.collect(Collectors.joining(System.lineSeparator()));
// CompileException
throw new RuntimeException(errorMsg);
}
}
/**
* 通过zip包或jar包创建Java文件对象
*
* @param file 压缩文件
* @return Java文件对象
*/
private Collection<JavaFileObject> getJavaFileObjectByZipOrJarFile(final File file) {
final Collection<JavaFileObject> collection = new ArrayList<>();
try {
final ZipFile zipFile = new ZipFile(file);
final Enumeration<? extends ZipEntry> entries = zipFile.entries();
while (entries.hasMoreElements()) {
final ZipEntry zipEntry = entries.nextElement();
final String name = zipEntry.getName();
if (name.endsWith(".java")) {
final InputStream inputStream = zipFile.getInputStream(zipEntry);
final JavaSourceFileObject fileObject = new JavaSourceFileObject(name, inputStream, Kind.SOURCE);
collection.add(fileObject);
}
}
return collection;
} catch (IOException e) {
e.printStackTrace();
}
return Collections.emptyList();
}
/**
* 获得编译源码时需要的classpath
*
* @return 编译源码时需要的classpath
*/
private List<File> getClassPath() {
List<File> classPathFileList = new ArrayList<>();
for (File file : libraryFileList) {
List<File> jarOrZipFile = FileUtil.loopFiles(file, this::isJarOrZipFile);
classPathFileList.addAll(jarOrZipFile);
if (file.isDirectory()) {
classPathFileList.add(file);
}
}
return classPathFileList;
}
/**
* 获得待编译的Java文件对象
*
* @return 待编译的Java文件对象
*/
private Iterable<JavaFileObject> getJavaFileObject() {
final Collection<JavaFileObject> collection = new ArrayList<>();
for (File file : sourceFileList) {
// .java 文件
final List<File> javaFileList = FileUtil.loopFiles(file, this::isJavaFile);
for (File javaFile : javaFileList) {
collection.add(getJavaFileObjectByJavaFile(javaFile));
}
// 压缩包
final List<File> jarOrZipFileList = FileUtil.loopFiles(file, this::isJarOrZipFile);
for (File jarOrZipFile : jarOrZipFileList) {
collection.addAll(getJavaFileObjectByZipOrJarFile(jarOrZipFile));
}
}
// 源码Map
collection.addAll(getJavaFileObjectByMap(this.sourceCodeMap));
return collection;
}
/**
* 通过源码Map获得Java文件对象
*
* @param sourceCodeMap 源码Map
* @return Java文件对象集合
*/
private Collection<JavaFileObject> getJavaFileObjectByMap(final Map<String, String> sourceCodeMap) {
if (MapUtil.isNotEmpty(sourceCodeMap)) {
return sourceCodeMap.entrySet().stream()
.map(entry -> new JavaSourceFileObject(entry.getKey(), entry.getValue(), CharsetUtil.CHARSET_UTF_8))
.collect(Collectors.toList());
}
return Collections.emptySet();
}
/**
* 通过.java文件创建Java文件对象
*
* @param file .java文件
* @return Java文件对象
*/
private JavaFileObject getJavaFileObjectByJavaFile(final File file) {
return new JavaSourceFileObject(file.toURI());
}
/**
* 通过zip包或jar包创建Java文件对象
*
* @param file 压缩文件
* @return Java文件对象
*/
private Collection<JavaFileObject> getJavaFileObjectByZipOrJarFile(final File file) {
final Collection<JavaFileObject> collection = new ArrayList<>();
try {
final ZipFile zipFile = new ZipFile(file);
final Enumeration<? extends ZipEntry> entries = zipFile.entries();
while (entries.hasMoreElements()) {
final ZipEntry zipEntry = entries.nextElement();
final String name = zipEntry.getName();
if (name.endsWith(".java")) {
final InputStream inputStream = zipFile.getInputStream(zipEntry);
final JavaSourceFileObject fileObject = new JavaSourceFileObject(name, inputStream);
collection.add(fileObject);
}
}
return collection;
} catch (IOException e) {
e.printStackTrace();
}
return Collections.emptyList();
}
/**
* 是否是jar 或 zip 文件
*
* @param file 文件
* @return 是否是jar 或 zip 文件
*/
private boolean isJarOrZipFile(final File file) {
final String fileName = file.getName();
return fileName.endsWith(".jar") || fileName.endsWith(".zip");
}
/**
* 是否是jar 或 zip 文件
*
* @param file 文件
* @return 是否是jar 或 zip 文件
*/
private boolean isJarOrZipFile(final File file) {
final String fileName = file.getName();
return fileName.endsWith(".jar") || fileName.endsWith(".zip");
}
/**
* 是否是.java文件
*
* @param file 文件
* @return 是否是.java文件
*/
private boolean isJavaFile(final File file) {
final String fileName = file.getName();
return fileName.endsWith(".java");
}
/**
* 是否是.java文件
*
* @param file 文件
* @return 是否是.java文件
*/
private boolean isJavaFile(final File file) {
final String fileName = file.getName();
return fileName.endsWith(".java");
}
}

141
hutool-core/src/main/java/cn/hutool/core/compiler/JavaSourceFileObject.java
View File

@@ -1,98 +1,85 @@
package cn.hutool.core.compiler;
import cn.hutool.core.io.IoUtil;
import javax.tools.SimpleJavaFileObject;
import java.io.BufferedInputStream;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URI;
import java.nio.charset.Charset;
import javax.tools.SimpleJavaFileObject;
import cn.hutool.core.io.IoUtil;
/**
* Java 源码文件对象
*
* @author lzpeng
* @see JavaSourceCompilerBak#getJavaFileObjectByJavaFile(java.io.File)
* @see JavaSourceCompilerBak#getJavaFileObjectByZipOrJarFile(java.io.File)
* @see JavaSourceCompilerBak#getJavaFileObject(java.util.Map)
* @see com.sun.tools.javac.api.ClientCodeWrapper.WrappedFileObject#getCharContent(boolean)
* @since 5.5.2
*/
final class JavaSourceFileObject extends SimpleJavaFileObject {
class JavaSourceFileObject extends SimpleJavaFileObject {
/**
* 输入流
*/
private InputStream inputStream;
/**
* 输入流
*/
private InputStream inputStream;
/**
* 构造
*
* @param uri 需要编译的文件uri
* @param kind 需要编译的文件类型
* @see JavaSourceCompilerBak#getJavaFileObjectByJavaFile(java.io.File)
*/
protected JavaSourceFileObject(URI uri, Kind kind) {
super(uri, kind);
}
/**
* 构造
*
* @param uri 需要编译的文件uri
*/
protected JavaSourceFileObject(URI uri) {
super(uri, Kind.SOURCE);
}
/**
* 构造
*
* @param name 需要编译的文件名
* @param inputStream 输入流
* @param kind 需要编译的文件类型
* @see JavaSourceCompilerBak#getJavaFileObjectByZipOrJarFile(java.io.File)
*/
protected JavaSourceFileObject(final String name, final InputStream inputStream, final Kind kind) {
super(URI.create("string:///" + name), kind);
this.inputStream = inputStream;
}
/**
* 构造
*
* @param name 需要编译的文件名
* @param inputStream 输入流
*/
protected JavaSourceFileObject(String name, InputStream inputStream) {
this(URI.create("string:///" + name));
this.inputStream = inputStream;
}
/**
* 构造
*
* @param className 需要编译的类名
* @param code 需要编译的类源码
* @param kind 需要编译的文件类型
* @see JavaSourceCompilerBak#getJavaFileObject(java.util.Map)
*/
protected JavaSourceFileObject(final String className, final String code, final Kind kind) {
super(URI.create("string:///" + className.replaceAll("\\.", "/") + kind.extension), kind);
this.inputStream = new ByteArrayInputStream(code.getBytes());
}
/**
* 构造
*
* @param className 需要编译的类名
* @param code 需要编译的类源码
*/
protected JavaSourceFileObject(String className, String code, Charset charset) {
this(URI.create("string:///" + className.replace('.', '/') + Kind.SOURCE.extension));
this.inputStream = IoUtil.toStream(code, charset);
}
/**
* 获得类源码的输入流
*
* @return 类源码的输入流
* @throws IOException IO 异常
*/
@Override
public InputStream openInputStream() throws IOException {
if (inputStream == null) {
inputStream = toUri().toURL().openStream();
}
return new BufferedInputStream(inputStream);
}
/**
* 获得类源码的输入流
*
* @return 类源码的输入流
* @throws IOException IO 异常
*/
@Override
public InputStream openInputStream() throws IOException {
if (inputStream == null) {
inputStream = toUri().toURL().openStream();
}
return new BufferedInputStream(inputStream);
}
/**
* 获得类源码
* 编译器编辑源码前，会通过此方法获取类的源码
*
* @param ignoreEncodingErrors 是否忽略编码错误
* @return 需要编译的类的源码
* @throws IOException IO异常
* @see com.sun.tools.javac.api.ClientCodeWrapper.WrappedFileObject#getCharContent(boolean)
*/
@Override
public CharSequence getCharContent(final boolean ignoreEncodingErrors) throws IOException {
final InputStream in = openInputStream();
final String code = IoUtil.read(in, Charset.defaultCharset());
IoUtil.close(in);
return code;
}
/**
* 获得类源码
* 编译器编辑源码前，会通过此方法获取类的源码
*
* @param ignoreEncodingErrors 是否忽略编码错误
* @return 需要编译的类的源码
* @throws IOException IO异常
*/
@Override
public CharSequence getCharContent(boolean ignoreEncodingErrors) throws IOException {
try(final InputStream in = openInputStream()){
return IoUtil.readUtf8(in);
}
}
}

26
hutool-core/src/main/java/cn/hutool/core/date/DatePattern.java
View File

@@ -28,6 +28,32 @@ public class DatePattern {
public static final Pattern REGEX_NORM = Pattern.compile("\\d{4}-\\d{1,2}-\\d{1,2}(\\s\\d{1,2}:\\d{1,2}(:\\d{1,2})?)?(.\\d{1,3})?");
//-------------------------------------------------------------------------------------------------------------------------------- Normal
/**
* 年月格式：yyyy-MM
*/
public static final String NORM_MONTH_PATTERN = "yyyy-MM";
/**
* 年月格式 {@link FastDateFormat}：yyyy-MM
*/
public static final FastDateFormat NORM_MONTH_FORMAT = FastDateFormat.getInstance(NORM_MONTH_PATTERN);
/**
* 年月格式 {@link FastDateFormat}：yyyy-MM
*/
public static final DateTimeFormatter NORM_MONTH_FORMATTER = DateTimeFormatter.ofPattern(NORM_MONTH_PATTERN);
/**
* 简单年月格式：yyyyMM
*/
public static final String SIMPLE_MONTH_PATTERN = "yyyyMM";
/**
* 简单年月格式 {@link FastDateFormat}：yyyyMM
*/
public static final FastDateFormat SIMPLE_MONTH_FORMAT = FastDateFormat.getInstance(SIMPLE_MONTH_PATTERN);
/**
* 简单年月格式 {@link FastDateFormat}：yyyyMM
*/
public static final DateTimeFormatter SIMPLE_MONTH_FORMATTER = DateTimeFormatter.ofPattern(SIMPLE_MONTH_PATTERN);
/**
* 标准日期格式：yyyy-MM-dd
*/

177
hutool-core/src/main/java/cn/hutool/core/date/GroupTimeInterval.java Normal file
View File

@@ -0,0 +1,177 @@
package cn.hutool.core.date;
import cn.hutool.core.util.ObjectUtil;
import java.io.Serializable;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
/**
* 分组计时器<br>
* 计算某几个过程花费的时间，精确到毫秒或纳秒
*
* @author Looly
* @since 5.5.2
*/
public class GroupTimeInterval implements Serializable {
private static final long serialVersionUID = 1L;
private final boolean isNano;
protected final Map<String, Long> groupMap;
/**
* 构造
*
* @param isNano 是否使用纳秒计数，false则使用毫秒
*/
public GroupTimeInterval(boolean isNano) {
this.isNano = isNano;
groupMap = new ConcurrentHashMap<>();
}
/**
* 清空所有定时记录
*
* @return this
*/
public GroupTimeInterval clear(){
this.groupMap.clear();
return this;
}
/**
* 开始计时并返回当前时间
*
* @param id 分组ID
* @return 开始计时并返回当前时间
*/
public long start(String id) {
final long time = getTime();
this.groupMap.put(id, time);
return time;
}
/**
* 重新计时并返回从开始到当前的持续时间秒<br>
* 如果此分组下没有记录，则返回0;
*
* @param id 分组ID
* @return 重新计时并返回从开始到当前的持续时间
*/
public long intervalRestart(String id) {
final long now = getTime();
return now - ObjectUtil.defaultIfNull(this.groupMap.put(id, now), now);
}
//----------------------------------------------------------- Interval
/**
* 从开始到当前的间隔时间（毫秒数）<br>
* 如果使用纳秒计时，返回纳秒差，否则返回毫秒差<br>
* 如果分组下没有开始时间，返回{@code null}
*
* @param id 分组ID
* @return 从开始到当前的间隔时间（毫秒数）
*/
public long interval(String id) {
final Long lastTime = this.groupMap.get(id);
if (null == lastTime) {
return 0;
}
return getTime() - lastTime;
}
/**
* 从开始到当前的间隔时间
*
* @param id 分组ID
* @param dateUnit 时间单位
* @return 从开始到当前的间隔时间（毫秒数）
*/
public long interval(String id, DateUnit dateUnit) {
final long intervalMs = isNano ? interval(id) / 1000000L : interval(id);
if (DateUnit.MS == dateUnit) {
return intervalMs;
}
return intervalMs / dateUnit.getMillis();
}
/**
* 从开始到当前的间隔时间（毫秒数）
*
* @param id 分组ID
* @return 从开始到当前的间隔时间（毫秒数）
*/
public long intervalMs(String id) {
return interval(id, DateUnit.MS);
}
/**
* 从开始到当前的间隔秒数，取绝对值
*
* @param id 分组ID
* @return 从开始到当前的间隔秒数，取绝对值
*/
public long intervalSecond(String id) {
return interval(id, DateUnit.SECOND);
}
/**
* 从开始到当前的间隔分钟数，取绝对值
*
* @param id 分组ID
* @return 从开始到当前的间隔分钟数，取绝对值
*/
public long intervalMinute(String id) {
return interval(id, DateUnit.MINUTE);
}
/**
* 从开始到当前的间隔小时数，取绝对值
*
* @param id 分组ID
* @return 从开始到当前的间隔小时数，取绝对值
*/
public long intervalHour(String id) {
return interval(id, DateUnit.HOUR);
}
/**
* 从开始到当前的间隔天数，取绝对值
*
* @param id 分组ID
* @return 从开始到当前的间隔天数，取绝对值
*/
public long intervalDay(String id) {
return interval(id, DateUnit.DAY);
}
/**
* 从开始到当前的间隔周数，取绝对值
*
* @param id 分组ID
* @return 从开始到当前的间隔周数，取绝对值
*/
public long intervalWeek(String id) {
return interval(id, DateUnit.WEEK);
}
/**
* 从开始到当前的间隔时间（毫秒数），返回XX天XX小时XX分XX秒XX毫秒
*
* @param id 分组ID
* @return 从开始到当前的间隔时间（毫秒数）
*/
public String intervalPretty(String id) {
return DateUtil.formatBetween(intervalMs(id));
}
/**
* 获取时间的毫秒或纳秒数，纳秒非时间戳
*
* @return 时间
*/
private long getTime() {
return this.isNano ? System.nanoTime() : System.currentTimeMillis();
}
}

13
hutool-core/src/main/java/cn/hutool/core/date/StopWatch.java
View File

@@ -41,6 +41,17 @@ import java.util.List;
*/
public class StopWatch {
/**
* 创建计时任务（秒表）
*
* @param id 用于标识秒表的唯一ID
* @return StopWatch
* @since 5.5.2
*/
public static StopWatch create(String id){
return new StopWatch(id);
}
/**
* 秒表唯一标识，用于多个秒表对象的区分
*/
@@ -101,7 +112,7 @@ public class StopWatch {
// ------------------------------------------------------------------------------------------- Constructor end
/**
* 获取{@link StopWatch} 的ID，用于多个秒表对象的区分
* 获取StopWatch 的ID，用于多个秒表对象的区分
*
* @return the ID 空字符串为
* @see #StopWatch(String)

48
hutool-core/src/main/java/cn/hutool/core/date/TimeInterval.java
View File

@@ -1,6 +1,6 @@
package cn.hutool.core.date;
import java.io.Serializable;
import cn.hutool.core.util.StrUtil;
/**
* 计时器<br>
@@ -8,11 +8,9 @@ import java.io.Serializable;
*
* @author Looly
*/
public class TimeInterval implements Serializable {
public class TimeInterval extends GroupTimeInterval {
private static final long serialVersionUID = 1L;
private long time;
private final boolean isNano;
private static final String DEFAULT_ID = StrUtil.EMPTY;
/**
* 构造，默认使用毫秒计数
@@ -23,10 +21,11 @@ public class TimeInterval implements Serializable {
/**
* 构造
*
* @param isNano 是否使用纳秒计数，false则使用毫秒
*/
public TimeInterval(boolean isNano) {
this.isNano = isNano;
super(isNano);
start();
}
@@ -34,28 +33,25 @@ public class TimeInterval implements Serializable {
* @return 开始计时并返回当前时间
*/
public long start() {
time = getTime(isNano);
return time;
return start(DEFAULT_ID);
}
/**
* @return 重新计时并返回从开始到当前的持续时间
*/
public long intervalRestart() {
long now = getTime(isNano);
long d = now - time;
time = now;
return d;
return intervalRestart(DEFAULT_ID);
}
/**
* 重新开始计算时间（重置开始时间）
*
* @return this
* @see #start()
* @since 3.0.1
*/
public TimeInterval restart() {
time = getTime(isNano);
start(DEFAULT_ID);
return this;
}
@@ -68,7 +64,7 @@ public class TimeInterval implements Serializable {
* @return 从开始到当前的间隔时间（毫秒数）
*/
public long interval() {
return getTime(isNano) - time;
return interval(DEFAULT_ID);
}
/**
@@ -78,7 +74,7 @@ public class TimeInterval implements Serializable {
* @since 4.6.7
*/
public String intervalPretty() {
return DateUtil.formatBetween(intervalMs());
return intervalPretty(DEFAULT_ID);
}
/**
@@ -87,7 +83,7 @@ public class TimeInterval implements Serializable {
* @return 从开始到当前的间隔时间（毫秒数）
*/
public long intervalMs() {
return isNano ? interval() / 1000000L : interval();
return intervalMs(DEFAULT_ID);
}
/**
@@ -96,7 +92,7 @@ public class TimeInterval implements Serializable {
* @return 从开始到当前的间隔秒数，取绝对值
*/
public long intervalSecond() {
return intervalMs() / DateUnit.SECOND.getMillis();
return intervalSecond(DEFAULT_ID);
}
/**
@@ -105,7 +101,7 @@ public class TimeInterval implements Serializable {
* @return 从开始到当前的间隔分钟数，取绝对值
*/
public long intervalMinute() {
return intervalMs() / DateUnit.MINUTE.getMillis();
return intervalMinute(DEFAULT_ID);
}
/**
@@ -114,7 +110,7 @@ public class TimeInterval implements Serializable {
* @return 从开始到当前的间隔小时数，取绝对值
*/
public long intervalHour() {
return intervalMs() / DateUnit.HOUR.getMillis();
return intervalHour(DEFAULT_ID);
}
/**
@@ -123,7 +119,7 @@ public class TimeInterval implements Serializable {
* @return 从开始到当前的间隔天数，取绝对值
*/
public long intervalDay() {
return intervalMs() / DateUnit.DAY.getMillis();
return intervalDay(DEFAULT_ID);
}
/**
@@ -132,16 +128,6 @@ public class TimeInterval implements Serializable {
* @return 从开始到当前的间隔周数，取绝对值
*/
public long intervalWeek() {
return intervalMs() / DateUnit.WEEK.getMillis();
}
/**
* 获取时间的毫秒或纳秒数，纳秒非时间戳
*
* @param isNano 是否为高精度时间
* @return 时间
*/
private static long getTime(boolean isNano) {
return isNano ? System.nanoTime() : System.currentTimeMillis();
return intervalWeek(DEFAULT_ID);
}
}

98
hutool-core/src/main/java/cn/hutool/core/exceptions/ExceptionUtil.java
View File

@@ -16,15 +16,14 @@ import java.util.Map;
/**
* 异常工具类
*
* @author Looly
*
* @author Looly
*/
public class ExceptionUtil {
/**
* 获得完整消息，包括异常名，消息格式为：{SimpleClassName}: {ThrowableMessage}
*
*
* @param e 异常
* @return 完整消息
*/
@@ -37,7 +36,7 @@ public class ExceptionUtil {
/**
* 获得消息，调用异常类的getMessage方法
*
*
* @param e 异常
* @return 消息
*/
@@ -47,9 +46,9 @@ public class ExceptionUtil {
/**
* 使用运行时异常包装编译异常<br>
*
* 如果
*
* <p>
* 如果传入参数已经是运行时异常，则直接返回，不再额外包装
*
* @param throwable 异常
* @return 运行时异常
*/
@@ -60,11 +59,22 @@ public class ExceptionUtil {
return new RuntimeException(throwable);
}
/**
* 将指定的消息包装为运行时异常
*
* @param message 异常消息
* @return 运行时异常
* @since 5.5.2
*/
public static RuntimeException wrapRuntime(String message) {
return new RuntimeException(message);
}
/**
* 包装一个异常
*
* @param <T> 被包装的异常类型
* @param throwable 异常
* @param <T> 被包装的异常类型
* @param throwable 异常
* @param wrapThrowable 包装后的异常类
* @return 包装后的异常
* @since 3.3.0
@@ -80,7 +90,7 @@ public class ExceptionUtil {
/**
* 包装异常并重新抛出此异常<br>
* {@link RuntimeException} 和{@link Error} 直接抛出，其它检查异常包装为{@link UndeclaredThrowableException} 后抛出
*
*
* @param throwable 异常
*/
public static void wrapAndThrow(Throwable throwable) {
@@ -93,9 +103,19 @@ public class ExceptionUtil {
throw new UndeclaredThrowableException(throwable);
}
/**
* 将消息包装为运行时异常并抛出
*
* @param message 异常消息
* @since 5.5.2
*/
public static void wrapRuntimeAndThrow(String message) {
throw new RuntimeException(message);
}
/**
* 剥离反射引发的InvocationTargetException、UndeclaredThrowableException中间异常，返回业务本身的异常
*
*
* @param wrapped 包装的异常
* @return 剥离后的异常
*/
@@ -114,7 +134,7 @@ public class ExceptionUtil {
/**
* 获取当前栈信息
*
*
* @return 当前栈信息
*/
public static StackTraceElement[] getStackElements() {
@@ -135,7 +155,7 @@ public class ExceptionUtil {
/**
* 获取入口堆栈信息
*
*
* @return 入口堆栈信息
* @since 4.1.4
*/
@@ -146,7 +166,7 @@ public class ExceptionUtil {
/**
* 堆栈转为单行完整字符串
*
*
* @param throwable 异常对象
* @return 堆栈转为的字符串
*/
@@ -156,9 +176,9 @@ public class ExceptionUtil {
/**
* 堆栈转为单行完整字符串
*
*
* @param throwable 异常对象
* @param limit 限制最大长度
* @param limit 限制最大长度
* @return 堆栈转为的字符串
*/
public static String stacktraceToOneLineString(Throwable throwable, int limit) {
@@ -172,7 +192,7 @@ public class ExceptionUtil {
/**
* 堆栈转为完整字符串
*
*
* @param throwable 异常对象
* @return 堆栈转为的字符串
*/
@@ -182,9 +202,9 @@ public class ExceptionUtil {
/**
* 堆栈转为完整字符串
*
*
* @param throwable 异常对象
* @param limit 限制最大长度
* @param limit 限制最大长度
* @return 堆栈转为的字符串
*/
public static String stacktraceToString(Throwable throwable, int limit) {
@@ -193,9 +213,9 @@ public class ExceptionUtil {
/**
* 堆栈转为完整字符串
*
* @param throwable 异常对象
* @param limit 限制最大长度
*
* @param throwable 异常对象
* @param limit 限制最大长度
* @param replaceCharToStrMap 替换字符为指定字符串
* @return 堆栈转为的字符串
*/
@@ -229,8 +249,8 @@ public class ExceptionUtil {
/**
* 判断是否由指定异常类引起
*
* @param throwable 异常
*
* @param throwable 异常
* @param causeClasses 定义的引起异常的类
* @return 是否由指定异常类引起
* @since 4.1.13
@@ -242,8 +262,8 @@ public class ExceptionUtil {
/**
* 获取由指定异常类引起的异常
*
* @param throwable 异常
*
* @param throwable 异常
* @param causeClasses 定义的引起异常的类
* @return 是否由指定异常类引起
* @since 4.1.13
@@ -265,7 +285,7 @@ public class ExceptionUtil {
/**
* 判断指定异常是否来自或者包含指定异常
*
* @param throwable 异常
* @param throwable 异常
* @param exceptionClass 定义的引起异常的类
* @return true 来自或者包含
* @since 4.3.2
@@ -277,9 +297,9 @@ public class ExceptionUtil {
/**
* 判断指定异常是否来自或者包含指定异常
*
* @param throwable 异常
* @param throwable 异常
* @param exceptionClass 定义的引起异常的类
* @param checkCause 判断cause
* @param checkCause 判断cause
* @return true 来自或者包含
* @since 4.4.1
*/
@@ -290,8 +310,8 @@ public class ExceptionUtil {
/**
* 转化指定异常为来自或者包含指定异常
*
* @param <T> 异常类型
* @param throwable 异常
* @param <T> 异常类型
* @param throwable 异常
* @param exceptionClass 定义的引起异常的类
* @return 结果为null 不是来自或者包含
* @since 4.3.2
@@ -303,10 +323,10 @@ public class ExceptionUtil {
/**
* 转化指定异常为来自或者包含指定异常
*
* @param <T> 异常类型
* @param throwable 异常
* @param <T> 异常类型
* @param throwable 异常
* @param exceptionClass 定义的引起异常的类
* @param checkCause 判断cause
* @param checkCause 判断cause
* @return 结果为null 不是来自或者包含
* @since 4.4.1
*/
@@ -338,11 +358,11 @@ public class ExceptionUtil {
/**
* 获取异常链上所有异常的集合，如果{@link Throwable} 对象没有cause，返回只有一个节点的List<br>
* 如果传入null，返回空集合
*
*
* <p>
* 此方法来自Apache-Commons-Lang3
* </p>
*
*
* @param throwable 异常对象，可以为null
* @return 异常链中所有异常集合
* @since 4.6.2
@@ -360,11 +380,11 @@ public class ExceptionUtil {
* 获取异常链中最尾端的异常，即异常最早发生的异常对象。<br>
* 此方法通过调用{@link Throwable#getCause()} 直到没有cause为止，如果异常本身没有cause，返回异常本身<br>
* 传入null返回也为null
*
*
* <p>
* 此方法来自Apache-Commons-Lang3
* </p>
*
*
* @param throwable 异常对象，可能为null
* @return 最尾端异常，传入null参数返回也为null
*/
@@ -375,7 +395,7 @@ public class ExceptionUtil {
/**
* 获取异常链中最尾端的异常的消息，消息格式为：{SimpleClassName}: {ThrowableMessage}
*
*
* @param th 异常
* @return 消息
* @since 4.6.2

4
hutool-core/src/main/java/cn/hutool/core/thread/ConcurrencyTester.java
View File

@@ -21,6 +21,10 @@ public class ConcurrencyTester {
private final TimeInterval timeInterval;
private long interval;
/**
* 构造
* @param threadSize 线程数
*/
public ConcurrencyTester(int threadSize) {
this.sf = new SyncFinisher(threadSize);
this.timeInterval = new TimeInterval();

2758
hutool-core/src/main/java/cn/hutool/core/util/ArrayUtil.java
View File

File diff suppressed because it is too large Load Diff

3022
hutool-core/src/main/java/cn/hutool/core/util/PrimitiveArrayUtil.java Normal file
View File

File diff suppressed because it is too large Load Diff

44
hutool-core/src/test/java/cn/hutool/core/compiler/JavaSourceCompilerTest.java
View File

@@ -16,27 +16,27 @@ import java.io.InputStream;
*/
public class JavaSourceCompilerTest {
/**
* 测试编译Java源码
*/
@Test
public void testCompile() throws ClassNotFoundException {
final File libFile = ZipUtil.zip(FileUtil.file("lib.jar"),
new String[]{"a/A.class", "a/A$1.class", "a/A$InnerClass.class"},
new InputStream[]{
FileUtil.getInputStream("test-compile/a/A.class"),
FileUtil.getInputStream("test-compile/a/A$1.class"),
FileUtil.getInputStream("test-compile/a/A$InnerClass.class")
});
final ClassLoader classLoader = JavaSourceCompiler.create(null)
.addSource(FileUtil.file("test-compile/b/B.java"))
.addSource("c.C", FileUtil.readUtf8String("test-compile/c/C.java"))
.addLibrary(libFile)
.compile();
final Class<?> clazz = classLoader.loadClass("c.C");
Object obj = ReflectUtil.newInstance(clazz);
Assert.assertTrue(String.valueOf(obj).startsWith("c.C@"));
FileUtil.del(libFile);
}
/**
* 测试编译Java源码
*/
@Test
public void testCompile() throws ClassNotFoundException {
final File libFile = ZipUtil.zip(FileUtil.file("lib.jar"),
new String[]{"a/A.class", "a/A$1.class", "a/A$InnerClass.class"},
new InputStream[]{
FileUtil.getInputStream("test-compile/a/A.class"),
FileUtil.getInputStream("test-compile/a/A$1.class"),
FileUtil.getInputStream("test-compile/a/A$InnerClass.class")
});
final ClassLoader classLoader = JavaSourceCompiler.create(null)
.addSource(FileUtil.file("test-compile/b/B.java"))
.addSource("c.C", FileUtil.readUtf8String("test-compile/c/C.java"))
.addLibrary(libFile)
.compile();
final Class<?> clazz = classLoader.loadClass("c.C");
Object obj = ReflectUtil.newInstance(clazz);
Assert.assertTrue(String.valueOf(obj).startsWith("c.C@"));
FileUtil.del(libFile);
}
}

20
hutool-core/src/test/java/cn/hutool/core/date/TimeIntervalTest.java Normal file
View File

@@ -0,0 +1,20 @@
package cn.hutool.core.date;
import cn.hutool.core.lang.Console;
import cn.hutool.core.thread.ThreadUtil;
import org.junit.Test;
public class TimeIntervalTest {
@Test
public void intervalGroupTest(){
final TimeInterval timer = new TimeInterval();
timer.start("1");
ThreadUtil.sleep(800);
timer.start("2");
ThreadUtil.sleep(900);
Console.log("Timer 1 took {} ms", timer.intervalMs("1"));
Console.log("Timer 2 took {} ms", timer.intervalMs("2"));
}
}

2
hutool-crypto/src/main/java/cn/hutool/crypto/digest/opt/HOTP.java → hutool-crypto/src/main/java/cn/hutool/crypto/digest/otp/HOTP.java
View File

@@ -1,4 +1,4 @@
package cn.hutool.crypto.digest.opt;
package cn.hutool.crypto.digest.otp;
import cn.hutool.crypto.digest.HMac;
import cn.hutool.crypto.digest.HmacAlgorithm;

12
hutool-crypto/src/main/java/cn/hutool/crypto/digest/opt/TOPT.java → hutool-crypto/src/main/java/cn/hutool/crypto/digest/otp/TOTP.java
View File

@@ -1,4 +1,4 @@
package cn.hutool.crypto.digest.opt;
package cn.hutool.crypto.digest.otp;
import cn.hutool.crypto.digest.HmacAlgorithm;
@@ -13,7 +13,7 @@ import java.time.Instant;
*
* @author Looly
*/
public class TOPT extends HOTP {
public class TOTP extends HOTP {
/**
* 默认步进 (30秒).
@@ -27,7 +27,7 @@ public class TOPT extends HOTP {
*
* @param key 共享密码，RFC 4226要求最少128位
*/
public TOPT(byte[] key) {
public TOTP(byte[] key) {
this(DEFAULT_TIME_STEP, key);
}
@@ -37,7 +37,7 @@ public class TOPT extends HOTP {
* @param timeStep 日期步进，用于生成移动因子（moving factor）
* @param key 共享密码，RFC 4226要求最少128位
*/
public TOPT(Duration timeStep, byte[] key) {
public TOTP(Duration timeStep, byte[] key) {
this(timeStep, DEFAULT_PASSWORD_LENGTH, key);
}
@@ -48,7 +48,7 @@ public class TOPT extends HOTP {
* @param passwordLength 密码长度，可以是6,7,8
* @param key 共享密码，RFC 4226要求最少128位
*/
public TOPT(Duration timeStep, int passwordLength, byte[] key) {
public TOTP(Duration timeStep, int passwordLength, byte[] key) {
this(timeStep, passwordLength, HOTP_HMAC_ALGORITHM, key);
}
@@ -60,7 +60,7 @@ public class TOPT extends HOTP {
* @param algorithm HMAC算法枚举
* @param key 共享密码，RFC 4226要求最少128位
*/
public TOPT(Duration timeStep, int passwordLength, HmacAlgorithm algorithm, byte[] key) {
public TOTP(Duration timeStep, int passwordLength, HmacAlgorithm algorithm, byte[] key) {
super(passwordLength, algorithm, key);
this.timeStep = timeStep;
}

2
hutool-crypto/src/main/java/cn/hutool/crypto/digest/opt/package-info.java → hutool-crypto/src/main/java/cn/hutool/crypto/digest/otp/package-info.java
View File

@@ -11,4 +11,4 @@
*
* @author looly
*/
package cn.hutool.crypto.digest.opt;
package cn.hutool.crypto.digest.otp;

6
hutool-json/src/main/java/cn/hutool/json/JSONObject.java
View File

@@ -420,7 +420,7 @@ public class JSONObject implements JSON, JSONGetter<String>, Map<String, Object>
}
/**
* 积累值。类似于put，当key对应value已经存在时，与value组成新的JSONArray. <br>
* 积累值。类似于set，当key对应value已经存在时，与value组成新的JSONArray. <br>
* 如果只有一个值，此值就是value，如果多个值，则是添加到新的JSONArray中
*
* @param key 键
@@ -432,11 +432,11 @@ public class JSONObject implements JSON, JSONGetter<String>, Map<String, Object>
InternalJSONUtil.testValidity(value);
Object object = this.getObj(key);
if (object == null) {
this.set(key, value instanceof JSONArray ? new JSONArray(this.config).set(value) : value);
this.set(key, value);
} else if (object instanceof JSONArray) {
((JSONArray) object).set(value);
} else {
this.set(key, new JSONArray(this.config).set(object).set(value));
this.set(key, JSONUtil.createArray(this.config).set(object).set(value));
}
return this;
}

12
hutool-json/src/test/java/cn/hutool/json/JSONObjectTest.java
View File

@@ -535,4 +535,16 @@ public class JSONObjectTest {
final String s = JSONUtil.toJsonStr(map);
Console.log(s);
}
@Test
public void accumulateTest(){
final JSONObject jsonObject = JSONUtil.createObj().accumulate("key1", "value1");
Assert.assertEquals("{\"key1\":\"value1\"}", jsonObject.toString());
jsonObject.accumulate("key1", "value2");
Assert.assertEquals("{\"key1\":[\"value1\",\"value2\"]}", jsonObject.toString());
jsonObject.accumulate("key1", "value3");
Assert.assertEquals("{\"key1\":[\"value1\",\"value2\",\"value3\"]}", jsonObject.toString());
}
}

1
hutool-json/src/test/java/cn/hutool/json/JSONUtilTest.java
View File

@@ -165,6 +165,7 @@ public class JSONUtilTest {
@Test
public void parseObjTest() {
// 测试转义
final JSONObject jsonObject = JSONUtil.parseObj("{\n" +
" \"test\": \"\\\\地库地库\",\n" +
"}");