lsm/hutool
1
0
Fork 0
mirror of https://gitee.com/dromara/hutool.git synced 2025-04-24 18:04:54 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

fix：避免调用方 显示调用API 触发查找树 优化；并通过内置锁，避免因并行树优化 可能造成的不可预知结果 和 无效重复的 树优化操作

Browse Source
This commit is contained in:
renyp 2023-03-17 09:55:04 +08:00
commit 2b2c0d001c
27 changed files with 643 additions and 371 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
hutool-core/src/main/java/cn/hutool/core/collection/ListUtil.java
View File

@ -8,7 +8,7 @@ import cn.hutool.core.collection.partition.RandomAccessPartition;
import cn.hutool.core.comparator.PinyinComparator;
import cn.hutool.core.comparator.PropertyComparator;
import cn.hutool.core.lang.Assert;
import cn.hutool.core.math.PageInfo;
import cn.hutool.core.lang.page.PageInfo;
import cn.hutool.core.util.ArrayUtil;
import cn.hutool.core.util.ObjUtil;

2
hutool-core/src/main/java/cn/hutool/core/convert/impl/StringConverter.java
View File

@ -35,7 +35,7 @@ public class StringConverter extends AbstractConverter {
* @param stringFunction 序列化函数
* @return this
*/
public StringConverter putStringer(Class<?> clazz, Function<Object, String> stringFunction){
public StringConverter putStringer(final Class<?> clazz, final Function<Object, String> stringFunction){
if(null == stringer){
stringer = new HashMap<>();
}

2
hutool-core/src/main/java/cn/hutool/core/io/SerializeUtil.java
View File

@ -44,7 +44,7 @@ public class SerializeUtil {
return null;
}
final FastByteArrayOutputStream byteOut = new FastByteArrayOutputStream();
IoUtil.writeObjects(byteOut, false, (Serializable) obj);
IoUtil.writeObjects(byteOut, false, obj);
return byteOut.toByteArray();
}

38
hutool-core/src/main/java/cn/hutool/core/lang/func/LambdaFactory.java
View File

@ -7,9 +7,12 @@ import cn.hutool.core.lang.mutable.MutableEntry;
import cn.hutool.core.map.WeakConcurrentMap;
import cn.hutool.core.reflect.LookupFactory;
import cn.hutool.core.reflect.MethodUtil;
import cn.hutool.core.reflect.ReflectUtil;
import java.io.Serializable;
import java.lang.invoke.*;
import java.lang.reflect.Constructor;
import java.lang.reflect.Executable;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Arrays;
@ -31,7 +34,7 @@ public class LambdaFactory {
throw new IllegalAccessException();
}
private static final Map<MutableEntry<Class<?>, Method>, Object> CACHE = new WeakConcurrentMap<>();
private static final Map<MutableEntry<Class<?>, Executable>, Object> CACHE = new WeakConcurrentMap<>();
/**
* 构建Lambda
@ -61,30 +64,37 @@ public class LambdaFactory {
* 构建Lambda
*
* @param functionInterfaceType 接受Lambda的函数式接口类型
* @param method 方法对象
* @param executable 方法对象，支持构造器
* @param <F> Function类型
* @return 接受Lambda的函数式接口对象
* @param <F> Function类型
*/
@SuppressWarnings("unchecked")
public static <F> F build(final Class<F> functionInterfaceType, final Method method) {
public static <F> F build(final Class<F> functionInterfaceType, final Executable executable) {
Assert.notNull(functionInterfaceType);
Assert.notNull(method);
final MutableEntry<Class<?>, Method> cacheKey = new MutableEntry<>(functionInterfaceType, method);
Assert.notNull(executable);
final MutableEntry<Class<?>, Executable> cacheKey = new MutableEntry<>(functionInterfaceType, executable);
return (F) CACHE.computeIfAbsent(cacheKey, key -> {
final List<Method> abstractMethods = Arrays.stream(functionInterfaceType.getMethods())
.filter(m -> Modifier.isAbstract(m.getModifiers()))
.collect(Collectors.toList());
Assert.equals(abstractMethods.size(), 1, "不支持非函数式接口");
if (!method.isAccessible()) {
method.setAccessible(true);
}
ReflectUtil.setAccessible(executable);
final Method invokeMethod = abstractMethods.get(0);
final MethodHandles.Lookup caller = LookupFactory.lookup(method.getDeclaringClass());
final MethodHandles.Lookup caller = LookupFactory.lookup(executable.getDeclaringClass());
final String invokeName = invokeMethod.getName();
final MethodType invokedType = methodType(functionInterfaceType);
final MethodType samMethodType = methodType(invokeMethod.getReturnType(), invokeMethod.getParameterTypes());
final MethodHandle implMethod = Opt.ofTry(() -> caller.unreflect(method)).get();
final MethodType insMethodType = methodType(method.getReturnType(), method.getDeclaringClass(), method.getParameterTypes());
final MethodHandle implMethod;
final MethodType instantiatedMethodType;
if (executable instanceof Method) {
final Method method = (Method) executable;
implMethod = ((SerSupplier<MethodHandle>) () -> MethodHandles.lookup().unreflect(method)).get();
instantiatedMethodType = MethodType.methodType(method.getReturnType(), method.getDeclaringClass(), method.getParameterTypes());
} else {
final Constructor<?> constructor = (Constructor<?>) executable;
implMethod = ((SerSupplier<MethodHandle>) () -> MethodHandles.lookup().unreflectConstructor(constructor)).get();
instantiatedMethodType = MethodType.methodType(constructor.getDeclaringClass(), constructor.getParameterTypes());
}
final boolean isSerializable = Serializable.class.isAssignableFrom(functionInterfaceType);
try {
final CallSite callSite = isSerializable ?
@ -94,7 +104,7 @@ public class LambdaFactory {
invokedType,
samMethodType,
implMethod,
insMethodType,
instantiatedMethodType,
FLAG_SERIALIZABLE
) :
LambdaMetafactory.metafactory(
@ -103,7 +113,7 @@ public class LambdaFactory {
invokedType,
samMethodType,
implMethod,
insMethodType
instantiatedMethodType
);
//noinspection unchecked
return (F) callSite.getTarget().invoke();

128
hutool-core/src/main/java/cn/hutool/core/lang/page/NavigatePageInfo.java Normal file
View File

@ -0,0 +1,128 @@
package cn.hutool.core.lang.page;
/**
* 导航分页信息类<br>
* 根据提供的总页数、每页记录数、导航页码数等信息，生成导航数组。
* <pre>
* [1] 2 3 4 5 >>
* << 1 [2] 3 4 5 >>
* << 1 2 3 4 [5]
* </pre>
*
* @author 莫取网名
*/
public class NavigatePageInfo extends PageInfo {
private final int navigatePageCount; //导航页码数
private int[] navigatePageNumbers; //所有导航页号
/**
* 构造
*
* @param total 总记录数
* @param pageSize 每页显示记录数
* @param navigatePageCount 导航页码数
*/
public NavigatePageInfo(final int total, final int pageSize, final int navigatePageCount) {
super(total, pageSize);
this.navigatePageCount = navigatePageCount;
//基本参数设定之后进行导航页面的计算
calcNavigatePageNumbers();
}
/**
* 得到所有导航页号
*
* @return {int[]}
*/
public int[] getNavigatePageNumbers() {
return navigatePageNumbers;
}
@Override
public NavigatePageInfo setFirstPageNo(final int firstPageNo) {
super.setFirstPageNo(firstPageNo);
return this;
}
@Override
public NavigatePageInfo setPageNo(final int pageNo) {
super.setPageNo(pageNo);
// 重新计算导航
calcNavigatePageNumbers();
return this;
}
@Override
public String toString() {
final StringBuilder str = new StringBuilder();
if (false == isFirstPage()) {
str.append("<< ");
}
if (navigatePageNumbers.length > 0) {
str.append(wrapForDisplay(navigatePageNumbers[0]));
}
for (int i = 1; i < navigatePageNumbers.length; i++) {
str.append(" ").append(wrapForDisplay(navigatePageNumbers[i]));
}
if (false == isLastPage()) {
str.append(" >>");
}
return str.toString();
}
// region ----- private methods
/**
* 用于显示的包装<br>
* 当前页显示'[pageNumber]'，否则直接显示
*
* @param pageNumber 页码
* @return 包装的页码
*/
private String wrapForDisplay(final int pageNumber) {
if (this.pageNo == pageNumber) {
return "[" + pageNumber + "]";
}
return String.valueOf(pageNumber);
}
/**
* 计算导航页
*/
private void calcNavigatePageNumbers() {
//当总页数小于或等于导航页码数时，全部显示
if (pageCount <= navigatePageCount) {
navigatePageNumbers = new int[pageCount];
for (int i = 0; i < pageCount; i++) {
navigatePageNumbers[i] = i + 1;
}
} else { //当总页数大于导航页码数时，部分显示
navigatePageNumbers = new int[navigatePageCount];
int startNum = pageNo - navigatePageCount / 2;
int endNum = pageNo + navigatePageCount / 2;
if (startNum < 1) {
startNum = 1;
//(最前navPageCount页
for (int i = 0; i < navigatePageCount; i++) {
navigatePageNumbers[i] = startNum++;
}
} else if (endNum > pageCount) {
endNum = pageCount;
//最后navPageCount页
for (int i = navigatePageCount - 1; i >= 0; i--) {
navigatePageNumbers[i] = endNum--;
}
} else {
//所有中间页
for (int i = 0; i < navigatePageCount; i++) {
navigatePageNumbers[i] = startNum++;
}
}
}
}
// endregion
}

30
hutool-core/src/main/java/cn/hutool/core/math/PageInfo.java → hutool-core/src/main/java/cn/hutool/core/lang/page/PageInfo.java
View File

@ -1,4 +1,4 @@
package cn.hutool.core.math;
package cn.hutool.core.lang.page;
import cn.hutool.core.lang.Assert;
import cn.hutool.core.lang.DefaultSegment;
@ -36,7 +36,7 @@ public class PageInfo {
/**
* 总页数
*/
int pages;
int pageCount;
/**
* 首页标识
*/
@ -74,7 +74,7 @@ public class PageInfo {
this.pageSize = pageSize;
// 因为总条数除以页大小的最大余数是页大小数-1，
// 因此加一个最大余数，保证舍弃的余数与最大余数凑1.x，就是一旦有余数则+1页
this.pages = (total + pageSize - 1) / pageSize;
this.pageCount = (total + pageSize - 1) / pageSize;
}
/**
@ -100,8 +100,8 @@ public class PageInfo {
*
* @return {int}
*/
public int getPages() {
return pages;
public int getPageCount() {
return pageCount;
}
/**
@ -129,7 +129,7 @@ public class PageInfo {
* @return 是否尾页
*/
public boolean isLastPage() {
return getPageIndexBase1() == this.pages;
return getPageIndexBase1() == this.pageCount;
}
/**
@ -147,7 +147,7 @@ public class PageInfo {
* @return 是否有下一页
*/
public boolean hasNextPage() {
return getBeginIndex() < this.pages;
return getBeginIndex() < this.pageCount;
}
/**
@ -155,7 +155,7 @@ public class PageInfo {
* @return 是否可用
*/
public boolean isValidPage(){
return this.getPageIndexBase1() <= this.pages;
return this.getPageIndexBase1() <= this.pageCount;
}
/**
@ -227,7 +227,8 @@ public class PageInfo {
/**
* 设置首页编号，即以数字几为第一页标志<br>
* 如设置0，则0表示第一页，1表示第二页
* 如设置0，则0表示第一页，1表示第二页<br>
* 设置此参数后，须调用{@link #setPageNo(int)} 重新设置当前页的页码
*
* @param firstPageNo 首页编号
* @return this
@ -238,7 +239,9 @@ public class PageInfo {
}
/**
* 设置当前页码
* 设置当前页码，具体这个页码代表实际页，取决于{@link #setFirstPageNo(int)}设置的值。
* 例如当{@link #setFirstPageNo(int)}设置为1时，1表示首页；设置为0时，0表示首页，依次类推。<br>
* 当设置页码小于{@link #getFirstPageNo()}值时，始终为{@link #getFirstPageNo()}
*
* @param pageNo 当前页码
* @return this
@ -251,7 +254,8 @@ public class PageInfo {
}
/**
* 下一页，即当前页码+1
* 下一页，即当前页码+1<br>
* 当超过末页时，此方法指向的页码值始终为{@link #getPageCount()} + 1，即最后一页后的空白页。
*
* @return this
*/
@ -264,14 +268,14 @@ public class PageInfo {
*
* @return this
*/
public PageInfo PreviousPage() {
public PageInfo previousPage() {
return setPageNo(this.pageNo - 1);
}
public String toString() {
return "{" +
"total=" + total +
",pages=" + pages +
",pages=" + pageCount +
",pageNumber=" + pageNo +
",limit=" + pageSize +
",isFirstPage=" + isFirstPage() +

10
hutool-core/src/main/java/cn/hutool/core/lang/page/package-info.java Normal file
View File

@ -0,0 +1,10 @@
/**
* 提供分页信息封装，主要包括：
* <ul>
* <li>{@link cn.hutool.core.lang.page.PageInfo}: 提供分页信息。</li>
* <li>{@link cn.hutool.core.lang.page.NavigatePageInfo}: 提供分页导航信息。</li>
* </ul>
*
* @author looly
*/
package cn.hutool.core.lang.page;

71
hutool-core/src/main/java/cn/hutool/core/math/NavigatePageInfo.java
View File

@ -1,71 +0,0 @@
package cn.hutool.core.math;
public class NavigatePageInfo extends PageInfo{
private final int navigatePages = 8; //导航页码数
private int[] navigatePageNumbers; //所有导航页号
public NavigatePageInfo(final int total, final int pageSize) {
super(total, pageSize);
//基本参数设定之后进行导航页面的计算
calcNavigatePageNumbers();
}
/**
* 得到所有导航页号
*
* @return {int[]}
*/
public int[] getNavigatePageNumbers() {
return navigatePageNumbers;
}
public String toString() {
final StringBuilder str = new StringBuilder(super.toString());
str.append(", {navigatePageNumbers=");
final int len = navigatePageNumbers.length;
if (len > 0) str.append(navigatePageNumbers[0]);
for (int i = 1; i < len; i++) {
str.append(" ").append(navigatePageNumbers[i]);
}
str.append("}");
return str.toString();
}
/**
* 计算导航页
*/
private void calcNavigatePageNumbers() {
//当总页数小于或等于导航页码数时
if (pages <= navigatePages) {
navigatePageNumbers = new int[pages];
for (int i = 0; i < pages; i++) {
navigatePageNumbers[i] = i + 1;
}
} else { //当总页数大于导航页码数时
navigatePageNumbers = new int[navigatePages];
int startNum = pageNo - navigatePages / 2;
int endNum = pageNo + navigatePages / 2;
if (startNum < 1) {
startNum = 1;
//(最前navPageCount页
for (int i = 0; i < navigatePages; i++) {
navigatePageNumbers[i] = startNum++;
}
} else if (endNum > pages) {
endNum = pages;
//最后navPageCount页
for (int i = navigatePages - 1; i >= 0; i--) {
navigatePageNumbers[i] = endNum--;
}
} else {
//所有中间页
for (int i = 0; i < navigatePages; i++) {
navigatePageNumbers[i] = startNum++;
}
}
}
}
}

49
hutool-core/src/main/java/cn/hutool/core/text/dfa/Automaton.java → hutool-core/src/main/java/cn/hutool/core/text/dfa/NFA.java
View File

@ -9,7 +9,7 @@ import java.util.*;
*
* @author renyp
*/
public class Automaton {
public class NFA {
/**
* AC树的根节点
*/
@ -17,20 +17,26 @@ public class Automaton {
/**
* 标记是否需要构建AC自动机，做树优化
*/
private volatile boolean needBuildAC;
private volatile boolean needBuildAc;
/**
* 内置锁，防止并发场景，并行建AC树，造成不可预知结果
*/
private final Object lock;
private final Object buildAcLock;
/**
* 内置锁，防止并行插入，新节点建立后，被挂载到树上前 被篡改
*/
private final Object insertTreeLock;
/**
* 默认构造
*/
public Automaton() {
public NFA() {
this.root = new Node();
this.needBuildAC = true;
this.lock = new Object();
this.needBuildAc = true;
this.buildAcLock = new Object();
this.insertTreeLock = new Object();
}
/**
@ -38,7 +44,7 @@ public class Automaton {
*
* @param words 添加的新词
*/
public Automaton(String... words) {
public NFA(String... words) {
this();
this.insert(words);
}
@ -49,17 +55,19 @@ public class Automaton {
* @param word 添加的新词
*/
public void insert(String word) {
needBuildAC = true;
Node p = root;
for (char curr : word.toCharArray()) {
int ind = curr;
if (p.next.get(ind) == null) {
p.next.put(ind, new Node());
synchronized (insertTreeLock) {
needBuildAc = true;
Node p = root;
for (char curr : word.toCharArray()) {
int ind = curr;
if (p.next.get(ind) == null) {
p.next.put(ind, new Node());
}
p = p.next.get(ind);
}
p = p.next.get(ind);
p.flag = true;
p.str = word;
}
p.flag = true;
p.str = word;
}
/**
@ -101,7 +109,7 @@ public class Automaton {
queue.offer(curr.next.get(key));
}
}
needBuildAC = false;
needBuildAc = false;
}
/**
@ -117,9 +125,9 @@ public class Automaton {
*/
public List<FoundWord> find(String text, boolean isDensityMatch) {
// double check，防止重复无用的 buildAC
if (needBuildAC) {
synchronized (lock) {
if (needBuildAC) {
if (needBuildAc) {
synchronized (buildAcLock) {
if (needBuildAc) {
this.buildAc();
}
}
@ -153,6 +161,7 @@ public class Automaton {
return ans;
}
private static class Node {
/**

2
hutool-core/src/test/java/cn/hutool/core/collection/ListUtilTest.java
View File

@ -2,7 +2,7 @@ package cn.hutool.core.collection;
import cn.hutool.core.date.StopWatch;
import cn.hutool.core.lang.Console;
import cn.hutool.core.math.PageInfo;
import cn.hutool.core.lang.page.PageInfo;
import cn.hutool.core.util.RandomUtil;
import lombok.AllArgsConstructor;
import lombok.Data;

17
hutool-core/src/test/java/cn/hutool/core/lang/func/LambdaFactoryTest.java
View File

@ -12,11 +12,8 @@ import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import java.lang.invoke.LambdaConversionException;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandleProxies;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;
import java.lang.invoke.*;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.Collection;
@ -24,6 +21,7 @@ import java.util.Comparator;
import java.util.concurrent.TimeUnit;
import java.util.function.BiConsumer;
import java.util.function.Function;
import java.util.function.Supplier;
/**
* @author nasodaengineer
@ -160,6 +158,15 @@ public class LambdaFactoryTest {
loop(count, tasks);
}
@Test
public void testConstructor() {
Constructor<Something> constructor = ((SerSupplier<Constructor<Something>>) Something.class::getConstructor).get();
Supplier<Something> constructorLambda = LambdaFactory.build(Supplier.class, constructor);
// constructorLambda can be cache or transfer
Something something = constructorLambda.get();
Assert.assertEquals(Something.class, something.getClass());
}
/**
* <p>hardCode 运行1次耗时 7600 NANOSECONDS
* <p>lambda 运行1次耗时 12400 NANOSECONDS

37
hutool-core/src/test/java/cn/hutool/core/lang/page/NavigatePageInfoTest.java Normal file
View File

@ -0,0 +1,37 @@
package cn.hutool.core.lang.page;
import org.junit.Assert;
import org.junit.Test;
public class NavigatePageInfoTest {
@Test
public void naviTest1(){
// 首页
final NavigatePageInfo navigatePageInfo = new NavigatePageInfo(10, 2, 6);
Assert.assertEquals("[1] 2 3 4 5 >>", navigatePageInfo.toString());
// 中间页
navigatePageInfo.nextPage();
Assert.assertEquals("<< 1 [2] 3 4 5 >>", navigatePageInfo.toString());
// 尾页
navigatePageInfo.setPageNo(5);
Assert.assertEquals("<< 1 2 3 4 [5]", navigatePageInfo.toString());
}
@Test
public void naviTest2(){
// 首页
final NavigatePageInfo navigatePageInfo = new NavigatePageInfo(10, 2, 4);
Assert.assertEquals("[1] 2 3 4 >>", navigatePageInfo.toString());
// 中间页
navigatePageInfo.nextPage();
Assert.assertEquals("<< 1 [2] 3 4 >>", navigatePageInfo.toString());
// 尾页
navigatePageInfo.setPageNo(5);
Assert.assertEquals("<< 2 3 4 [5]", navigatePageInfo.toString());
}
}

6
hutool-core/src/test/java/cn/hutool/core/math/PageInfoTest.java → hutool-core/src/test/java/cn/hutool/core/lang/page/PageInfoTest.java
View File

@ -1,4 +1,4 @@
package cn.hutool.core.math;
package cn.hutool.core.lang.page;
import org.junit.Assert;
import org.junit.Test;
@ -7,10 +7,10 @@ public class PageInfoTest {
@Test
public void pagesTest() {
PageInfo pageInfo = new PageInfo(20, 3);
Assert.assertEquals(7, pageInfo.getPages());
Assert.assertEquals(7, pageInfo.getPageCount());
pageInfo = new PageInfo(20, 4);
Assert.assertEquals(5, pageInfo.getPages());
Assert.assertEquals(5, pageInfo.getPageCount());
}
@Test

225
hutool-core/src/test/java/cn/hutool/core/text/dfa/AutomatonTest.java
View File

@ -1,225 +0,0 @@
package cn.hutool.core.text.dfa;
import cn.hutool.core.date.StopWatch;
import junit.framework.TestCase;
import org.junit.Assert;
import org.junit.Test;
import java.util.List;
import java.util.stream.Collectors;
public class AutomatonTest extends TestCase {
/**
* 密集匹配 测试查找结果，并与WordTree对比效率
*/
public void testFind() {
Automaton automaton = new Automaton();
WordTree wordTree = new WordTree();
automaton.insert("say", "her", "he", "she", "shr");
// automaton.buildAc();
wordTree.addWords("say", "her", "he", "she", "shr");
StopWatch stopWatch = new StopWatch();
String input = "sasherhsay";
stopWatch.start("automaton_char_find");
List<FoundWord> ans1 = automaton.find(input);
stopWatch.stop();
assertEquals("she,he,her,say", ans1.stream().map(FoundWord::getWord).collect(Collectors.joining(",")));
assertEquals(Integer.valueOf(2), ans1.get(0).getStartIndex());
assertEquals(Integer.valueOf(4), ans1.get(0).getEndIndex());
assertEquals(Integer.valueOf(3), ans1.get(1).getStartIndex());
assertEquals(Integer.valueOf(4), ans1.get(1).getEndIndex());
assertEquals(Integer.valueOf(3), ans1.get(2).getStartIndex());
assertEquals(Integer.valueOf(5), ans1.get(2).getEndIndex());
assertEquals(Integer.valueOf(7), ans1.get(3).getStartIndex());
assertEquals(Integer.valueOf(9), ans1.get(3).getEndIndex());
stopWatch.start("wordtree_char_find");
List<String> ans2 = wordTree.matchAll(input, -1, true, true);
stopWatch.stop();
assertEquals("she,he,her,say", String.join(",", ans2));
System.out.println(stopWatch.prettyPrint());
}
/**
* 非密集匹配 测试查找结果，并与WordTree对比效率
*/
public void testFindNotDensity() {
Automaton automaton = new Automaton();
WordTree wordTree = new WordTree();
automaton.insert("say", "her", "he", "she", "shr");
// automaton.buildAc();
wordTree.addWords("say", "her", "he", "she", "shr");
StopWatch stopWatch = new StopWatch();
String input = "sasherhsay";
stopWatch.start("automaton_char_find_not_density");
List<FoundWord> ans1 = automaton.find(input, false);
stopWatch.stop();
assertEquals("she,say", ans1.stream().map(FoundWord::getWord).collect(Collectors.joining(",")));
assertEquals(Integer.valueOf(2), ans1.get(0).getStartIndex());
assertEquals(Integer.valueOf(4), ans1.get(0).getEndIndex());
assertEquals(Integer.valueOf(7), ans1.get(1).getStartIndex());
assertEquals(Integer.valueOf(9), ans1.get(1).getEndIndex());
stopWatch.start("wordtree_char_find_not_density");
List<String> ans2 = wordTree.matchAll(input, -1, false, true);
stopWatch.stop();
assertEquals("she,say", String.join(",", ans2));
System.out.println(stopWatch.prettyPrint());
}
/**
* 密集匹配 测试建树和查找，并与WordTree对比效率
*/
public void testBuildAndFind() {
StopWatch stopWatch = new StopWatch();
String input = "sasherhsay";
stopWatch.start("automaton_char_buid_find");
Automaton automatonLocal = new Automaton();
automatonLocal.insert("say", "her", "he", "she", "shr");
// automatonLocal.buildAc();
List<FoundWord> ans1 = automatonLocal.find(input);
stopWatch.stop();
assertEquals("she,he,her,say", ans1.stream().map(FoundWord::getWord).collect(Collectors.joining(",")));
assertEquals(Integer.valueOf(2), ans1.get(0).getStartIndex());
assertEquals(Integer.valueOf(4), ans1.get(0).getEndIndex());
assertEquals(Integer.valueOf(3), ans1.get(1).getStartIndex());
assertEquals(Integer.valueOf(4), ans1.get(1).getEndIndex());
assertEquals(Integer.valueOf(3), ans1.get(2).getStartIndex());
assertEquals(Integer.valueOf(5), ans1.get(2).getEndIndex());
assertEquals(Integer.valueOf(7), ans1.get(3).getStartIndex());
assertEquals(Integer.valueOf(9), ans1.get(3).getEndIndex());
stopWatch.start("wordtree_char_build_find");
WordTree wordTreeLocal = new WordTree();
wordTreeLocal.addWords("say", "her", "he", "she", "shr");
List<String> ans2 = wordTreeLocal.matchAll(input, -1, true, true);
stopWatch.stop();
assertEquals("she,he,her,say", String.join(",", ans2));
System.out.println(stopWatch.prettyPrint());
}
/**
* 密集匹配 构建树和查找 测试中文字符，并与wordTree对比效率
*/
@Test
public void testBuildFindCnChar() {
StopWatch stopWatch = new StopWatch();
String input = "赵啊三在做什么";
stopWatch.start("automaton_cn_build_find");
Automaton automatonLocal = new Automaton();
automatonLocal.insert("赵", "赵啊", "赵啊三");
// automatonLocal.buildAc();
final List<FoundWord> result = automatonLocal.find(input);
stopWatch.stop();
Assert.assertEquals(3, result.size());
Assert.assertEquals("赵,赵啊,赵啊三", result.stream().map(FoundWord::getWord).collect(Collectors.joining(",")));
assertEquals(Integer.valueOf(0), result.get(0).getStartIndex());
assertEquals(Integer.valueOf(0), result.get(0).getEndIndex());
assertEquals(Integer.valueOf(0), result.get(1).getStartIndex());
assertEquals(Integer.valueOf(1), result.get(1).getEndIndex());
assertEquals(Integer.valueOf(0), result.get(2).getStartIndex());
assertEquals(Integer.valueOf(2), result.get(2).getEndIndex());
stopWatch.start("wordtree_cn_build_find");
WordTree wordTreeLocal = new WordTree();
wordTreeLocal.addWords("赵", "赵啊", "赵啊三");
final List<String> result1 = wordTreeLocal.matchAll(input, -1, true, true);
stopWatch.stop();
Assert.assertEquals(3, result1.size());
Assert.assertEquals("赵,赵啊,赵啊三", String.join(",", result1));
System.out.println(stopWatch.prettyPrint());
}
/**
* 密集匹配 测试构建树和查找 中文字符，并与wordTree对比效率
*/
@Test
public void testFindCNChar() {
StopWatch stopWatch = new StopWatch();
String input = "赵啊三在做什么";
Automaton automatonLocal = new Automaton();
automatonLocal.insert("赵", "赵啊", "赵啊三");
// automatonLocal.buildAc();
stopWatch.start("automaton_cn_find");
final List<FoundWord> result = automatonLocal.find(input);
stopWatch.stop();
Assert.assertEquals(3, result.size());
Assert.assertEquals("赵,赵啊,赵啊三", result.stream().map(FoundWord::getWord).collect(Collectors.joining(",")));
assertEquals(Integer.valueOf(0), result.get(0).getStartIndex());
assertEquals(Integer.valueOf(0), result.get(0).getEndIndex());
assertEquals(Integer.valueOf(0), result.get(1).getStartIndex());
assertEquals(Integer.valueOf(1), result.get(1).getEndIndex());
assertEquals(Integer.valueOf(0), result.get(2).getStartIndex());
assertEquals(Integer.valueOf(2), result.get(2).getEndIndex());
WordTree wordTreeLocal = new WordTree();
wordTreeLocal.addWords("赵", "赵啊", "赵啊三");
stopWatch.start("wordtree_cn_find");
final List<String> result1 = wordTreeLocal.matchAllWords(input, -1, true, true).stream().map(FoundWord::getWord)
.collect(Collectors.toList());
stopWatch.stop();
Assert.assertEquals(3, result1.size());
Assert.assertEquals("赵,赵啊,赵啊三", String.join(",", result1));
System.out.println(stopWatch.prettyPrint());
}
/**
* 非密集匹配 测试构建树和查找 中文字符，并与wordTree对比效率，
*/
@Test
public void testFindCNCharNotDensity() {
StopWatch stopWatch = new StopWatch();
String input = "赵啊三在做什么";
Automaton automatonLocal = new Automaton();
automatonLocal.insert("赵", "赵啊", "赵啊三");
// automatonLocal.buildAc();
stopWatch.start("automaton_cn_find_not_density");
final List<FoundWord> result = automatonLocal.find(input, false);
stopWatch.stop();
Assert.assertEquals(1, result.size());
Assert.assertEquals("赵", result.stream().map(FoundWord::getWord).collect(Collectors.joining(",")));
assertEquals(Integer.valueOf(0), result.get(0).getStartIndex());
assertEquals(Integer.valueOf(0), result.get(0).getEndIndex());
WordTree wordTreeLocal = new WordTree();
wordTreeLocal.addWords("赵", "赵啊", "赵啊三");
stopWatch.start("wordtree_cn_find_not_density");
final List<String> result1 =
wordTreeLocal.matchAllWords(input, -1, false, true).stream().map(FoundWord::getWord)
.collect(Collectors.toList());
stopWatch.stop();
Assert.assertEquals(1, result1.size());
Assert.assertEquals("赵", String.join(",", result1));
System.out.println(stopWatch.prettyPrint());
}
}

228
hutool-core/src/test/java/cn/hutool/core/text/dfa/NFATest.java Normal file
View File

@ -0,0 +1,228 @@
package cn.hutool.core.text.dfa;
import cn.hutool.core.date.StopWatch;
import org.junit.Assert;
import org.junit.Test;
import java.util.List;
import java.util.stream.Collectors;
public class NFATest {
/**
* 密集匹配 测试查找结果，并与WordTree对比效率
*/
@Test
public void testFind() {
final NFA NFA = new NFA();
NFA.insert("say", "her", "he", "she", "shr");
// NFA.buildAc();
final WordTree wordTree = new WordTree();
wordTree.addWords("say", "her", "he", "she", "shr");
final StopWatch stopWatch = new StopWatch();
final String input = "sasherhsay";
stopWatch.start("automaton_char_find");
final List<FoundWord> ans1 = NFA.find(input);
stopWatch.stop();
Assert.assertEquals("she,he,her,say", ans1.stream().map(FoundWord::getWord).collect(Collectors.joining(",")));
Assert.assertEquals(2, ans1.get(0).getBeginIndex().intValue());
Assert.assertEquals(4, ans1.get(0).getEndIndex().intValue());
Assert.assertEquals(3, ans1.get(1).getBeginIndex().intValue());
Assert.assertEquals(4, ans1.get(1).getEndIndex().intValue());
Assert.assertEquals(3, ans1.get(2).getBeginIndex().intValue());
Assert.assertEquals(5, ans1.get(2).getEndIndex().intValue());
Assert.assertEquals(7, ans1.get(3).getBeginIndex().intValue());
Assert.assertEquals(9, ans1.get(3).getEndIndex().intValue());
stopWatch.start("wordtree_char_find");
final List<String> ans2 = wordTree.matchAll(input, -1, true, true);
stopWatch.stop();
Assert.assertEquals("she,he,her,say", String.join(",", ans2));
//Console.log(stopWatch.prettyPrint());
}
/**
* 非密集匹配 测试查找结果，并与WordTree对比效率
*/
@Test
public void testFindNotDensity() {
final NFA NFA = new NFA();
NFA.insert("say", "her", "he", "she", "shr");
// NFA.buildAc();
final WordTree wordTree = new WordTree();
wordTree.addWords("say", "her", "he", "she", "shr");
final StopWatch stopWatch = new StopWatch();
final String input = "sasherhsay";
stopWatch.start("automaton_char_find_not_density");
final List<FoundWord> ans1 = NFA.find(input, false);
stopWatch.stop();
Assert.assertEquals("she,say", ans1.stream().map(FoundWord::getWord).collect(Collectors.joining(",")));
Assert.assertEquals(2, ans1.get(0).getBeginIndex().intValue());
Assert.assertEquals(4, ans1.get(0).getEndIndex().intValue());
Assert.assertEquals(7, ans1.get(1).getBeginIndex().intValue());
Assert.assertEquals(9, ans1.get(1).getEndIndex().intValue());
stopWatch.start("wordtree_char_find_not_density");
final List<String> ans2 = wordTree.matchAll(input, -1, false, true);
stopWatch.stop();
Assert.assertEquals("she,say", String.join(",", ans2));
//Console.log(stopWatch.prettyPrint());
}
/**
* 密集匹配 测试建树和查找，并与WordTree对比效率
*/
@Test
public void testBuildAndFind() {
final StopWatch stopWatch = new StopWatch();
final String input = "sasherhsay";
stopWatch.start("automaton_char_buid_find");
final NFA NFALocal = new NFA();
NFALocal.insert("say", "her", "he", "she", "shr");
// NFALocal.buildAc();
final List<FoundWord> ans1 = NFALocal.find(input);
stopWatch.stop();
Assert.assertEquals("she,he,her,say", ans1.stream().map(FoundWord::getWord).collect(Collectors.joining(",")));
Assert.assertEquals(2, ans1.get(0).getBeginIndex().intValue());
Assert.assertEquals(4, ans1.get(0).getEndIndex().intValue());
Assert.assertEquals(3, ans1.get(1).getBeginIndex().intValue());
Assert.assertEquals(4, ans1.get(1).getEndIndex().intValue());
Assert.assertEquals(3, ans1.get(2).getBeginIndex().intValue());
Assert.assertEquals(5, ans1.get(2).getEndIndex().intValue());
Assert.assertEquals(7, ans1.get(3).getBeginIndex().intValue());
Assert.assertEquals(9, ans1.get(3).getEndIndex().intValue());
stopWatch.start("wordtree_char_build_find");
final WordTree wordTreeLocal = new WordTree();
wordTreeLocal.addWords("say", "her", "he", "she", "shr");
final List<String> ans2 = wordTreeLocal.matchAll(input, -1, true, true);
stopWatch.stop();
Assert.assertEquals("she,he,her,say", String.join(",", ans2));
//Console.log(stopWatch.prettyPrint());
}
/**
* 密集匹配 构建树和查找 测试中文字符，并与wordTree对比效率
*/
@Test
public void buildFindCnCharTest() {
final StopWatch stopWatch = new StopWatch();
final String input = "赵啊三在做什么";
stopWatch.start("automaton_cn_build_find");
final NFA NFALocal = new NFA();
NFALocal.insert("赵", "赵啊", "赵啊三");
// NFALocal.buildAc();
final List<FoundWord> result = NFALocal.find(input);
stopWatch.stop();
Assert.assertEquals(3, result.size());
Assert.assertEquals("赵,赵啊,赵啊三", result.stream().map(FoundWord::getWord).collect(Collectors.joining(",")));
Assert.assertEquals(Integer.valueOf(0), result.get(0).getBeginIndex());
Assert.assertEquals(Integer.valueOf(0), result.get(0).getEndIndex());
Assert.assertEquals(Integer.valueOf(0), result.get(1).getBeginIndex());
Assert.assertEquals(Integer.valueOf(1), result.get(1).getEndIndex());
Assert.assertEquals(Integer.valueOf(0), result.get(2).getBeginIndex());
Assert.assertEquals(Integer.valueOf(2), result.get(2).getEndIndex());
stopWatch.start("wordtree_cn_build_find");
final WordTree wordTreeLocal = new WordTree();
wordTreeLocal.addWords("赵", "赵啊", "赵啊三");
final List<String> result1 = wordTreeLocal.matchAll(input, -1, true, true);
stopWatch.stop();
Assert.assertEquals(3, result1.size());
Assert.assertEquals("赵,赵啊,赵啊三", String.join(",", result1));
//Console.log(stopWatch.prettyPrint());
}
/**
* 密集匹配 测试构建树和查找 中文字符，并与wordTree对比效率
*/
@Test
public void testFindCNChar() {
final StopWatch stopWatch = new StopWatch();
final String input = "赵啊三在做什么";
final NFA NFALocal = new NFA();
NFALocal.insert("赵", "赵啊", "赵啊三");
// NFALocal.buildAc();
stopWatch.start("automaton_cn_find");
final List<FoundWord> result = NFALocal.find(input);
stopWatch.stop();
Assert.assertEquals(3, result.size());
Assert.assertEquals("赵,赵啊,赵啊三", result.stream().map(FoundWord::getWord).collect(Collectors.joining(",")));
Assert.assertEquals(Integer.valueOf(0), result.get(0).getBeginIndex());
Assert.assertEquals(Integer.valueOf(0), result.get(0).getEndIndex());
Assert.assertEquals(Integer.valueOf(0), result.get(1).getBeginIndex());
Assert.assertEquals(Integer.valueOf(1), result.get(1).getEndIndex());
Assert.assertEquals(Integer.valueOf(0), result.get(2).getBeginIndex());
Assert.assertEquals(Integer.valueOf(2), result.get(2).getEndIndex());
final WordTree wordTreeLocal = new WordTree();
wordTreeLocal.addWords("赵", "赵啊", "赵啊三");
stopWatch.start("wordtree_cn_find");
final List<String> result1 = wordTreeLocal.matchAllWords(input, -1, true, true).stream().map(FoundWord::getWord)
.collect(Collectors.toList());
stopWatch.stop();
Assert.assertEquals(3, result1.size());
Assert.assertEquals("赵,赵啊,赵啊三", String.join(",", result1));
//Console.log(stopWatch.prettyPrint());
}
/**
* 非密集匹配 测试构建树和查找 中文字符，并与wordTree对比效率，
*/
@Test
public void testFindCNCharNotDensity() {
final StopWatch stopWatch = new StopWatch();
final String input = "赵啊三在做什么";
final NFA NFALocal = new NFA();
NFALocal.insert("赵", "赵啊", "赵啊三");
// NFALocal.buildAc();
stopWatch.start("automaton_cn_find_not_density");
final List<FoundWord> result = NFALocal.find(input, false);
stopWatch.stop();
Assert.assertEquals(1, result.size());
Assert.assertEquals("赵", result.stream().map(FoundWord::getWord).collect(Collectors.joining(",")));
Assert.assertEquals(Integer.valueOf(0), result.get(0).getBeginIndex());
Assert.assertEquals(Integer.valueOf(0), result.get(0).getEndIndex());
final WordTree wordTreeLocal = new WordTree();
wordTreeLocal.addWords("赵", "赵啊", "赵啊三");
stopWatch.start("wordtree_cn_find_not_density");
final List<String> result1 =
wordTreeLocal.matchAllWords(input, -1, false, true).stream().map(FoundWord::getWord)
.collect(Collectors.toList());
stopWatch.stop();
Assert.assertEquals(1, result1.size());
Assert.assertEquals("赵", String.join(",", result1));
//Console.log(stopWatch.prettyPrint());
}
}

48
hutool-core/src/test/java/cn/hutool/core/tree/IssueI6NR2ZTest.java Normal file
View File

@ -0,0 +1,48 @@
package cn.hutool.core.tree;
import cn.hutool.core.lang.Assert;
import org.junit.Test;
import java.util.ArrayList;
import java.util.List;
public class IssueI6NR2ZTest {
@Test
public void getNodeTest() {
final List<TreeNode<Integer>> list = new ArrayList<>();
final TreeNode<Integer> treeNode1 = new TreeNode<>();
treeNode1.setId(1);
treeNode1.setParentId(0);
list.add(treeNode1);
final TreeNode<Integer> treeNode2 = new TreeNode<>();
treeNode2.setId(2);
treeNode2.setParentId(1);
list.add(treeNode2);
final TreeNode<Integer> treeNode3 = new TreeNode<>();
treeNode3.setId(3);
treeNode3.setParentId(1);
list.add(treeNode3);
final TreeNode<Integer> treeNode4 = new TreeNode<>();
treeNode4.setId(21);
treeNode4.setParentId(2);
list.add(treeNode4);
final TreeNode<Integer> treeNode5 = new TreeNode<>();
treeNode5.setId(31);
treeNode5.setParentId(3);
list.add(treeNode5);
final TreeNode<Integer> treeNode6 = new TreeNode<>();
treeNode6.setId(211);
treeNode6.setParentId(21);
list.add(treeNode6);
final List<MapTree<Integer>> build = TreeUtil.build(list);
final MapTree<Integer> node = TreeUtil.getNode(build.get(0), 31);
Assert.notNull(node);
}
}

40
hutool-db/README.md Normal file
View File

@ -0,0 +1,40 @@
<p align="center">
<a href="https://hutool.cn/"><img src="https://plus.hutool.cn/images/hutool.svg" width="45%"></a>
</p>
<p align="center">
<strong>🍬A set of tools that keep Java sweet.</strong>
</p>
<p align="center">
👉 <a href="https://hutool.cn">https://hutool.cn/</a> 👈
</p>
## 📚Hutool-db 模块介绍
`Hutool-db`是一个在JDBC基础上封装的数据库操作工具类。通过包装，使用ActiveRecord思想操作数据库。
在Hutool-db中，使用Entity（本质上是个Map）代替Bean来使数据库操作更加灵活，同时提供Bean和Entity的转换提供传统ORM的兼容支持。
-------------------------------------------------------------------------------
## 🛠️包含内容
### 数据库方言（dialect）
通过抽象CRUD方法，针对不同数据库，封装对应的查询、分页等SQL转换功能，入口为`DialectFactory`。
### 数据源（ds）
提供常用数据库连接池的门面支持，支持顺序为：
- Hikari > Druid > Tomcat > BeeCP > Dbcp > C3p0 > Hutool Pooled
### SQL相关工具（sql）
提供SQL相关功能，包括SQL变量替换（NamedSql），通过对象完成SQL构建（SqlBuilder）等。
`SqlSqlExecutor`提供SQL执行的静态方法。
### 数据库元信息（meta）
通过`MetaUtil`提供数据库表、字段等信息的读取操作。
### 增删改查（Db、Session）
提供增删改查的汇总方法类。
### 结果转换（handler）
通过封装`RsHandler`，提供将ResultSet转换为需要的对象的功能。

29
hutool-db/src/main/java/cn/hutool/db/AbstractDb.java
View File

@ -51,6 +51,7 @@ public abstract class AbstractDb<R extends AbstractDb<R>> extends DefaultConnect
}
// ------------------------------------------------------- Constructor end
// region ----- query
/**
* 查询
*
@ -189,7 +190,9 @@ public abstract class AbstractDb<R extends AbstractDb<R>> extends DefaultConnect
this.closeConnection(conn);
}
}
// endregion
// region ----- execute
/**
* 执行非查询语句<br>
* 语句包括 插入、更新、删除
@ -282,9 +285,11 @@ public abstract class AbstractDb<R extends AbstractDb<R>> extends DefaultConnect
this.closeConnection(conn);
}
}
// endregion
// ---------------------------------------------------------------------------- CRUD start
// region ----- insert
/**
* 插入数据
*
@ -395,7 +400,9 @@ public abstract class AbstractDb<R extends AbstractDb<R>> extends DefaultConnect
this.closeConnection(conn);
}
}
// endregion
// region ----- del
/**
* 删除数据
*
@ -425,7 +432,9 @@ public abstract class AbstractDb<R extends AbstractDb<R>> extends DefaultConnect
this.closeConnection(conn);
}
}
// endregion
// region ----- update
/**
* 更新数据<br>
* 更新条件为多个key value对表示，默认key = value，如果使用其它条件可以使用：where.put("key", " &gt; 1")，value也可以传Condition对象，key被忽略
@ -444,8 +453,9 @@ public abstract class AbstractDb<R extends AbstractDb<R>> extends DefaultConnect
this.closeConnection(conn);
}
}
// endregion
// ------------------------------------------------------------- Get start
// region ----- get
/**
* 根据某个字段（最好是唯一字段）查询单个记录<br>
@ -473,8 +483,9 @@ public abstract class AbstractDb<R extends AbstractDb<R>> extends DefaultConnect
return find(where.getFieldNames(), where, new EntityHandler(this.caseInsensitive));
}
// ------------------------------------------------------------- Get end
// endregion
// region ----- find
/**
* 查询<br>
* 查询条件为多个key value对表示，默认key = value，如果使用其它条件可以使用：where.put("key", " &gt; 1")，value也可以传Condition对象，key被忽略
@ -487,13 +498,7 @@ public abstract class AbstractDb<R extends AbstractDb<R>> extends DefaultConnect
* @throws DbRuntimeException SQL执行异常
*/
public <T> T find(final Collection<String> fields, final Entity where, final RsHandler<T> rsh) throws DbRuntimeException {
Connection conn = null;
try {
conn = this.getConnection();
return runner.find(conn, Query.of(where).setFields(fields), rsh);
} finally {
this.closeConnection(conn);
}
return find(Query.of(where).setFields(fields), rsh);
}
/**
@ -652,7 +657,9 @@ public abstract class AbstractDb<R extends AbstractDb<R>> extends DefaultConnect
public List<Entity> findLike(final String tableName, final String field, final String value, final LikeType likeType) throws DbRuntimeException {
return findAll(Entity.of(tableName).set(field, SqlUtil.buildLikeValue(value, likeType, true)));
}
// endregion
// region ----- count
/**
* 结果的条目数
*
@ -705,7 +712,9 @@ public abstract class AbstractDb<R extends AbstractDb<R>> extends DefaultConnect
this.closeConnection(conn);
}
}
// endregion
// region ----- page
/**
* 分页查询，结果为Entity列表，不计算总数<br>
* 查询条件为多个key value对表示，默认key = value，如果使用其它条件可以使用：where.put("key", " &gt; 1")，value也可以传Condition对象，key被忽略
@ -867,7 +876,7 @@ public abstract class AbstractDb<R extends AbstractDb<R>> extends DefaultConnect
public PageResult<Entity> page(final Entity where, final Page page) throws DbRuntimeException {
return this.page(where.getFieldNames(), where, page);
}
// ---------------------------------------------------------------------------- CRUD end
// endregion
// ---------------------------------------------------------------------------- Getters and Setters start

7
hutool-db/src/main/java/cn/hutool/db/DefaultConnectionHolder.java
View File

@ -13,7 +13,12 @@ public class DefaultConnectionHolder implements ConnectionHolder {
protected final DataSource ds;
public DefaultConnectionHolder(DataSource ds) {
/**
* 构造
*
* @param ds {@link DataSource}
*/
public DefaultConnectionHolder(final DataSource ds) {
this.ds = ds;
}

2
hutool-db/src/main/java/cn/hutool/db/Page.java
View File

@ -1,7 +1,7 @@
package cn.hutool.db;
import cn.hutool.core.lang.Segment;
import cn.hutool.core.math.PageInfo;
import cn.hutool.core.lang.page.PageInfo;
import cn.hutool.core.util.ArrayUtil;
import cn.hutool.db.sql.Order;

4
hutool-db/src/main/java/cn/hutool/db/PageResult.java
View File

@ -1,6 +1,6 @@
package cn.hutool.db;
import cn.hutool.core.math.PageInfo;
import cn.hutool.core.lang.page.PageInfo;
import java.util.ArrayList;
@ -65,7 +65,7 @@ public class PageResult<T> extends ArrayList<T> {
this(page, pageSize);
this.total = total;
this.totalPage = PageInfo.of(total, pageSize).getPages();
this.totalPage = PageInfo.of(total, pageSize).getPageCount();
}
//---------------------------------------------------------- Constructor end

2
hutool-db/src/main/java/cn/hutool/db/StatementUtil.java
View File

@ -118,7 +118,7 @@ public class StatementUtil {
*
* @param conn 数据库连接
* @param sql SQL语句，使用"?"做为占位符
* @param params "?"对应参数列表
* @param params "?"对应参数列表或者Map表示命名参数
* @return {@link PreparedStatement}
* @throws SQLException SQL异常
* @since 3.2.3

9
hutool-db/src/main/java/cn/hutool/db/sql/SqlBuilder.java
View File

@ -115,9 +115,18 @@ public class SqlBuilder implements Builder<String> {
private QuoteWrapper quoteWrapper;
// --------------------------------------------------------------- Constructor start
/**
* 构造
*/
public SqlBuilder() {
}
/**
* 构造
*
* @param quoteWrapper 包装器
*/
public SqlBuilder(final QuoteWrapper quoteWrapper) {
this.quoteWrapper = quoteWrapper;
}

7
hutool-db/src/test/java/cn/hutool/db/CRUDTest.java
View File

@ -99,6 +99,13 @@ public class CRUDTest {
Assert.assertEquals(2, results.size());
}
@Test
public void findInTest4() {
final List<Entity> results = db.findAll(Entity.of("user")
.set("id", new String[]{"1", "2", "3"}));
Assert.assertEquals(2, results.size());
}
@Test
public void findAllTest() {
final List<Entity> results = db.findAll("user");

13
hutool-db/src/test/java/cn/hutool/db/DbTest.java
View File

@ -55,6 +55,19 @@ public class DbTest {
Assert.assertEquals(1, page1.size());
}
@Test
public void pageBySqlWithInTest() {
// in和其他条件混用
final String sql = "select * from user where age > :age and name in (:names) order by name";
// 测试数据库中一共4条数据，第0页有3条，第1页有1条
final List<Entity> page0 = Db.of().page(
sql, Page.of(0, 3),
Entity.of().set("age", 12)
.set("names", new String[]{"张三", "王五"})
);
Assert.assertEquals(1, page0.size());
}
@Test
public void pageWithParamsTest() {
final String sql = "select * from user where name = ?";

4
hutool-http/src/main/java/cn/hutool/http/client/ClientConfig.java
View File

@ -30,7 +30,9 @@ public class ClientConfig {
* 默认读取超时
*/
private int readTimeout;
/**
* SSL相关配置
*/
private SSLInfo sslInfo;
/**
* 是否禁用缓存

2
hutool-json/src/main/java/cn/hutool/json/JSONUtil.java
View File

@ -2,6 +2,7 @@ package cn.hutool.json;
import cn.hutool.core.io.file.FileUtil;
import cn.hutool.core.io.IORuntimeException;
import cn.hutool.core.lang.Assert;
import cn.hutool.core.reflect.TypeReference;
import cn.hutool.core.text.StrUtil;
import cn.hutool.core.util.ObjUtil;
@ -364,6 +365,7 @@ public class JSONUtil {
* @since 4.6.2
*/
public static <T> T toBean(final Object json, final TypeReference<T> typeReference) {
Assert.notNull(typeReference);
return toBean(json, typeReference.getType());
}