, M> finisher = intermediate -> {
intermediate.replaceAll((k, v) -> downstreamFinisher.apply(v));
@SuppressWarnings("unchecked")
diff --git a/hutool-core/src/main/java/cn/hutool/core/text/AntPathMatcher.java b/hutool-core/src/main/java/cn/hutool/core/text/AntPathMatcher.java
new file mode 100755
index 000000000..aabc3e97b
--- /dev/null
+++ b/hutool-core/src/main/java/cn/hutool/core/text/AntPathMatcher.java
@@ -0,0 +1,942 @@
+package cn.hutool.core.text;
+
+
+import cn.hutool.core.util.StrUtil;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Ant风格的路径匹配器。
+ * 来自Spring-core和Ant
+ *
+ * 匹配URL的规则如下：
+ *
+ * - {@code ?} 匹配单个字符
+ * - {@code *} 匹配0个或多个字符
+ * - {@code **} 0个或多个路径中的目录节点
+ * - {@code {hutool:[a-z]+}} 匹配以"hutool"命名的正则 {@code [a-z]+}
+ *
+ *
+ * 例子:
+ *
+ * - {@code com/t?st.jsp} — 匹配 {@code com/test.jsp} 或 {@code com/tast.jsp} 或 {@code com/txst.jsp}
+ * - {@code com/*.jsp} — 匹配{@code com}目录下全部 {@code .jsp}文件
+ * - {@code com/**/test.jsp} — 匹配{@code com}目录下全部 {@code test.jsp}文件
+ * - {@code cn/hutool/**/*.jsp} — 匹配{@code cn/hutool}路径下全部{@code .jsp} 文件
+ * - {@code org/**/servlet/bla.jsp} — 匹配{@code cn/hutool/servlet/bla.jsp} 或{@code cn/hutool/testing/servlet/bla.jsp} 或 {@code org/servlet/bla.jsp}
+ * - {@code com/{filename:\\w+}.jsp} 匹配 {@code com/test.jsp} 并将 {@code test} 关联到 {@code filename} 变量
+ *
+ *
+ * 注意: 表达式和路径必须都为绝对路径或都为相对路径。
+ *
+ * @author Alef Arendsen, Juergen Hoeller, Rob Harrop, Arjen Poutsma, Rossen Stoyanchev, Sam Brannen, Vladislav Kisel
+ * @since 5.7.22
+ */
+public class AntPathMatcher {
+
+ /**
+ * Default path separator: "/".
+ */
+ public static final String DEFAULT_PATH_SEPARATOR = StrUtil.SLASH;
+
+ private static final int CACHE_TURNOFF_THRESHOLD = 65536;
+
+ private static final Pattern VARIABLE_PATTERN = Pattern.compile("\\{[^/]+?}");
+
+ private static final char[] WILDCARD_CHARS = {'*', '?', '{'};
+
+ private String pathSeparator;
+
+ private PathSeparatorPatternCache pathSeparatorPatternCache;
+
+ private boolean caseSensitive = true;
+
+ private boolean trimTokens = false;
+
+ private volatile Boolean cachePatterns;
+
+ private final Map tokenizedPatternCache = new ConcurrentHashMap<>(256);
+
+ private final Map stringMatcherCache = new ConcurrentHashMap<>(256);
+
+
+ /**
+ * 使用 {@link #DEFAULT_PATH_SEPARATOR} 作为分隔符构造
+ */
+ public AntPathMatcher() {
+ this(DEFAULT_PATH_SEPARATOR);
+ }
+
+ /**
+ * 使用自定义的分隔符构造
+ *
+ * @param pathSeparator the path separator to use, must not be {@code null}.
+ * @since 4.1
+ */
+ public AntPathMatcher(String pathSeparator) {
+ if (null == pathSeparator) {
+ pathSeparator = DEFAULT_PATH_SEPARATOR;
+ }
+ setPathSeparator(pathSeparator);
+ }
+
+
+ /**
+ * 设置路径分隔符
+ *
+ * @param pathSeparator 分隔符，{@code null}表示使用默认分隔符{@link #DEFAULT_PATH_SEPARATOR}
+ * @return this
+ */
+ public AntPathMatcher setPathSeparator(String pathSeparator) {
+ if (null == pathSeparator) {
+ pathSeparator = DEFAULT_PATH_SEPARATOR;
+ }
+ this.pathSeparator = pathSeparator;
+ this.pathSeparatorPatternCache = new PathSeparatorPatternCache(this.pathSeparator);
+ return this;
+ }
+
+ /**
+ * 设置是否大小写敏感，默认为{@code true}
+ *
+ * @param caseSensitive 是否大小写敏感
+ * @return this
+ */
+ public AntPathMatcher setCaseSensitive(boolean caseSensitive) {
+ this.caseSensitive = caseSensitive;
+ return this;
+ }
+
+ /**
+ * 设置是否去除路径节点两边的空白符，默认为{@code false}
+ *
+ * @param trimTokens 是否去除路径节点两边的空白符
+ * @return this
+ */
+ public AntPathMatcher setTrimTokens(boolean trimTokens) {
+ this.trimTokens = trimTokens;
+ return this;
+ }
+
+ /**
+ * Specify whether to cache parsed pattern metadata for patterns passed
+ * into this matcher's {@link #match} method. A value of {@code true}
+ * activates an unlimited pattern cache; a value of {@code false} turns
+ * the pattern cache off completely.
+ * Default is for the cache to be on, but with the variant to automatically
+ * turn it off when encountering too many patterns to cache at runtime
+ * (the threshold is 65536), assuming that arbitrary permutations of patterns
+ * are coming in, with little chance for encountering a recurring pattern.
+ *
+ * @param cachePatterns 是否缓存表达式
+ * @see #getStringMatcher(String)
+ */
+ public AntPathMatcher setCachePatterns(boolean cachePatterns) {
+ this.cachePatterns = cachePatterns;
+ return this;
+ }
+
+ /**
+ * 判断给定路径是否是表达式
+ *
+ * @param path 路径
+ * @return 是否为表达式
+ */
+ public boolean isPattern(String path) {
+ if (path == null) {
+ return false;
+ }
+ boolean uriVar = false;
+ final int length = path.length();
+ char c;
+ for (int i = 0; i < length; i++) {
+ c = path.charAt(i);
+ // 含有通配符
+ if (c == '*' || c == '?') {
+ return true;
+ }
+ if (c == CharPool.DELIM_START) {
+ uriVar = true;
+ continue;
+ }
+ if (c == CharPool.DELIM_END && uriVar) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * 给定路径是否匹配表达式
+ *
+ * @param pattern 表达式
+ * @param path 路径
+ * @return 是否匹配
+ */
+ public boolean match(String pattern, String path) {
+ return doMatch(pattern, path, true, null);
+ }
+
+ /**
+ * 前置部分匹配
+ *
+ * @param pattern 表达式
+ * @param path 路径
+ * @return 是否匹配
+ */
+ public boolean matchStart(String pattern, String path) {
+ return doMatch(pattern, path, false, null);
+ }
+
+ /**
+ * 执行匹配，判断给定的{@code path}是否匹配{@code pattern}
+ *
+ * @param pattern 表达式
+ * @param path 路径
+ * @param fullMatch 是否全匹配。{@code true} 表示全路径匹配，{@code false}表示只匹配开始
+ * @param uriTemplateVariables 变量映射
+ * @return {@code true} 表示提供的 {@code path} 匹配, {@code false} 表示不匹配
+ */
+ protected boolean doMatch(String pattern, String path, boolean fullMatch, Map uriTemplateVariables) {
+ if (path == null || path.startsWith(this.pathSeparator) != pattern.startsWith(this.pathSeparator)) {
+ return false;
+ }
+
+ final String[] pattDirs = tokenizePattern(pattern);
+ if (fullMatch && this.caseSensitive && false == isPotentialMatch(path, pattDirs)) {
+ return false;
+ }
+
+ final String[] pathDirs = tokenizePath(path);
+ int pattIdxStart = 0;
+ int pattIdxEnd = pattDirs.length - 1;
+ int pathIdxStart = 0;
+ int pathIdxEnd = pathDirs.length - 1;
+
+ // Match all elements up to the first **
+ while (pattIdxStart <= pattIdxEnd && pathIdxStart <= pathIdxEnd) {
+ String pattDir = pattDirs[pattIdxStart];
+ if ("**".equals(pattDir)) {
+ break;
+ }
+ if (notMatchStrings(pattDir, pathDirs[pathIdxStart], uriTemplateVariables)) {
+ return false;
+ }
+ pattIdxStart++;
+ pathIdxStart++;
+ }
+
+ if (pathIdxStart > pathIdxEnd) {
+ // Path is exhausted, only match if rest of pattern is * or **'s
+ if (pattIdxStart > pattIdxEnd) {
+ return (pattern.endsWith(this.pathSeparator) == path.endsWith(this.pathSeparator));
+ }
+ if (false == fullMatch) {
+ return true;
+ }
+ if (pattIdxStart == pattIdxEnd && pattDirs[pattIdxStart].equals("*") && path.endsWith(this.pathSeparator)) {
+ return true;
+ }
+ for (int i = pattIdxStart; i <= pattIdxEnd; i++) {
+ if (false == pattDirs[i].equals("**")) {
+ return false;
+ }
+ }
+ return true;
+ } else if (pattIdxStart > pattIdxEnd) {
+ // String not exhausted, but pattern is. Failure.
+ return false;
+ } else if (false == fullMatch && "**".equals(pattDirs[pattIdxStart])) {
+ // Path start definitely matches due to "**" part in pattern.
+ return true;
+ }
+
+ // up to last '**'
+ while (pattIdxStart <= pattIdxEnd && pathIdxStart <= pathIdxEnd) {
+ String pattDir = pattDirs[pattIdxEnd];
+ if (pattDir.equals("**")) {
+ break;
+ }
+ if (notMatchStrings(pattDir, pathDirs[pathIdxEnd], uriTemplateVariables)) {
+ return false;
+ }
+ pattIdxEnd--;
+ pathIdxEnd--;
+ }
+ if (pathIdxStart > pathIdxEnd) {
+ // String is exhausted
+ for (int i = pattIdxStart; i <= pattIdxEnd; i++) {
+ if (false == pattDirs[i].equals("**")) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ while (pattIdxStart != pattIdxEnd && pathIdxStart <= pathIdxEnd) {
+ int patIdxTmp = -1;
+ for (int i = pattIdxStart + 1; i <= pattIdxEnd; i++) {
+ if (pattDirs[i].equals("**")) {
+ patIdxTmp = i;
+ break;
+ }
+ }
+ if (patIdxTmp == pattIdxStart + 1) {
+ // '**/**' situation, so skip one
+ pattIdxStart++;
+ continue;
+ }
+ // Find the pattern between padIdxStart & padIdxTmp in str between
+ // strIdxStart & strIdxEnd
+ int patLength = (patIdxTmp - pattIdxStart - 1);
+ int strLength = (pathIdxEnd - pathIdxStart + 1);
+ int foundIdx = -1;
+
+ strLoop:
+ for (int i = 0; i <= strLength - patLength; i++) {
+ for (int j = 0; j < patLength; j++) {
+ String subPat = pattDirs[pattIdxStart + j + 1];
+ String subStr = pathDirs[pathIdxStart + i + j];
+ if (notMatchStrings(subPat, subStr, uriTemplateVariables)) {
+ continue strLoop;
+ }
+ }
+ foundIdx = pathIdxStart + i;
+ break;
+ }
+
+ if (foundIdx == -1) {
+ return false;
+ }
+
+ pattIdxStart = patIdxTmp;
+ pathIdxStart = foundIdx + patLength;
+ }
+
+ for (int i = pattIdxStart; i <= pattIdxEnd; i++) {
+ if (false == pattDirs[i].equals("**")) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ private boolean isPotentialMatch(String path, String[] pattDirs) {
+ if (!this.trimTokens) {
+ int pos = 0;
+ for (String pattDir : pattDirs) {
+ int skipped = skipSeparator(path, pos, this.pathSeparator);
+ pos += skipped;
+ skipped = skipSegment(path, pos, pattDir);
+ if (skipped < pattDir.length()) {
+ return (skipped > 0 || (pattDir.length() > 0 && isWildcardChar(pattDir.charAt(0))));
+ }
+ pos += skipped;
+ }
+ }
+ return true;
+ }
+
+ private int skipSegment(String path, int pos, String prefix) {
+ int skipped = 0;
+ for (int i = 0; i < prefix.length(); i++) {
+ char c = prefix.charAt(i);
+ if (isWildcardChar(c)) {
+ return skipped;
+ }
+ int currPos = pos + skipped;
+ if (currPos >= path.length()) {
+ return 0;
+ }
+ if (c == path.charAt(currPos)) {
+ skipped++;
+ }
+ }
+ return skipped;
+ }
+
+ private int skipSeparator(String path, int pos, String separator) {
+ int skipped = 0;
+ while (path.startsWith(separator, pos + skipped)) {
+ skipped += separator.length();
+ }
+ return skipped;
+ }
+
+ private boolean isWildcardChar(char c) {
+ for (char candidate : WILDCARD_CHARS) {
+ if (c == candidate) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Tokenize the given path pattern into parts, based on this matcher's settings.
+ * Performs caching based on {@link #setCachePatterns}, delegating to
+ * {@link #tokenizePath(String)} for the actual tokenization algorithm.
+ *
+ * @param pattern the pattern to tokenize
+ * @return the tokenized pattern parts
+ */
+ protected String[] tokenizePattern(String pattern) {
+ String[] tokenized = null;
+ Boolean cachePatterns = this.cachePatterns;
+ if (cachePatterns == null || cachePatterns) {
+ tokenized = this.tokenizedPatternCache.get(pattern);
+ }
+ if (tokenized == null) {
+ tokenized = tokenizePath(pattern);
+ if (cachePatterns == null && this.tokenizedPatternCache.size() >= CACHE_TURNOFF_THRESHOLD) {
+ // Try to adapt to the runtime situation that we're encountering:
+ // There are obviously too many different patterns coming in here...
+ // So let's turn off the cache since the patterns are unlikely to be reoccurring.
+ deactivatePatternCache();
+ return tokenized;
+ }
+ if (cachePatterns == null || cachePatterns) {
+ this.tokenizedPatternCache.put(pattern, tokenized);
+ }
+ }
+ return tokenized;
+ }
+
+ private void deactivatePatternCache() {
+ this.cachePatterns = false;
+ this.tokenizedPatternCache.clear();
+ this.stringMatcherCache.clear();
+ }
+
+ /**
+ * Tokenize the given path into parts, based on this matcher's settings.
+ *
+ * @param path the path to tokenize
+ * @return the tokenized path parts
+ */
+ protected String[] tokenizePath(String path) {
+ return StrSplitter.splitToArray(path, this.pathSeparator, 0, this.trimTokens, true);
+ }
+
+ /**
+ * Test whether or not a string matches against a pattern.
+ *
+ * @param pattern the pattern to match against (never {@code null})
+ * @param str the String which must be matched against the pattern (never {@code null})
+ * @return {@code true} if the string matches against the pattern, or {@code false} otherwise
+ */
+ private boolean notMatchStrings(String pattern, String str, Map uriTemplateVariables) {
+ return false == getStringMatcher(pattern).matchStrings(str, uriTemplateVariables);
+ }
+
+ /**
+ * Build or retrieve an {@link AntPathStringMatcher} for the given pattern.
+ * The default implementation checks this AntPathMatcher's internal cache
+ * (see {@link #setCachePatterns}), creating a new AntPathStringMatcher instance
+ * if no cached copy is found.
+ *
When encountering too many patterns to cache at runtime (the threshold is 65536),
+ * it turns the default cache off, assuming that arbitrary permutations of patterns
+ * are coming in, with little chance for encountering a recurring pattern.
+ *
This method may be overridden to implement a custom cache strategy.
+ *
+ * @param pattern the pattern to match against (never {@code null})
+ * @return a corresponding AntPathStringMatcher (never {@code null})
+ * @see #setCachePatterns
+ */
+ protected AntPathStringMatcher getStringMatcher(String pattern) {
+ AntPathStringMatcher matcher = null;
+ Boolean cachePatterns = this.cachePatterns;
+ if (cachePatterns == null || cachePatterns) {
+ matcher = this.stringMatcherCache.get(pattern);
+ }
+ if (matcher == null) {
+ matcher = new AntPathStringMatcher(pattern, this.caseSensitive);
+ if (cachePatterns == null && this.stringMatcherCache.size() >= CACHE_TURNOFF_THRESHOLD) {
+ // Try to adapt to the runtime situation that we're encountering:
+ // There are obviously too many different patterns coming in here...
+ // So let's turn off the cache since the patterns are unlikely to be reoccurring.
+ deactivatePatternCache();
+ return matcher;
+ }
+ if (cachePatterns == null || cachePatterns) {
+ this.stringMatcherCache.put(pattern, matcher);
+ }
+ }
+ return matcher;
+ }
+
+ /**
+ * Given a pattern and a full path, determine the pattern-mapped part.
For example:
+ * - '{@code /docs/cvs/commit.html}' and '{@code /docs/cvs/commit.html} → ''
+ * - '{@code /docs/*}' and '{@code /docs/cvs/commit} → '{@code cvs/commit}'
+ * - '{@code /docs/cvs/*.html}' and '{@code /docs/cvs/commit.html} → '{@code commit.html}'
+ * - '{@code /docs/**}' and '{@code /docs/cvs/commit} → '{@code cvs/commit}'
+ * - '{@code /docs/**\/*.html}' and '{@code /docs/cvs/commit.html} → '{@code cvs/commit.html}'
+ * - '{@code /*.html}' and '{@code /docs/cvs/commit.html} → '{@code docs/cvs/commit.html}'
+ * - '{@code *.html}' and '{@code /docs/cvs/commit.html} → '{@code /docs/cvs/commit.html}'
+ * - '{@code *}' and '{@code /docs/cvs/commit.html} → '{@code /docs/cvs/commit.html}'
+ * Assumes that {@link #match} returns {@code true} for '{@code pattern}' and '{@code path}', but
+ * does not enforce this.
+ *
+ * @param pattern 表达式
+ * @param path 路径
+ * @return 表达式匹配到的部分
+ */
+ public String extractPathWithinPattern(String pattern, String path) {
+ String[] patternParts = tokenizePath(pattern);
+ String[] pathParts = tokenizePath(path);
+ StringBuilder builder = new StringBuilder();
+ boolean pathStarted = false;
+
+ for (int segment = 0; segment < patternParts.length; segment++) {
+ String patternPart = patternParts[segment];
+ if (patternPart.indexOf('*') > -1 || patternPart.indexOf('?') > -1) {
+ for (; segment < pathParts.length; segment++) {
+ if (pathStarted || (segment == 0 && !pattern.startsWith(this.pathSeparator))) {
+ builder.append(this.pathSeparator);
+ }
+ builder.append(pathParts[segment]);
+ pathStarted = true;
+ }
+ }
+ }
+
+ return builder.toString();
+ }
+
+ public Map extractUriTemplateVariables(String pattern, String path) {
+ Map variables = new LinkedHashMap<>();
+ boolean result = doMatch(pattern, path, true, variables);
+ if (!result) {
+ throw new IllegalStateException("Pattern \"" + pattern + "\" is not a match for \"" + path + "\"");
+ }
+ return variables;
+ }
+
+ /**
+ * Combine two patterns into a new pattern.
+ * This implementation simply concatenates the two patterns, unless
+ * the first pattern contains a file extension match (e.g., {@code *.html}).
+ * In that case, the second pattern will be merged into the first. Otherwise,
+ * an {@code IllegalArgumentException} will be thrown.
+ *
Examples
+ *
+ * | Pattern 1 | Pattern 2 | Result |
|---|
+ * | {@code null} | {@code null} | |
+ * | /hotels | {@code null} | /hotels |
+ * | {@code null} | /hotels | /hotels |
+ * | /hotels | /bookings | /hotels/bookings |
+ * | /hotels | bookings | /hotels/bookings |
+ * | /hotels/* | /bookings | /hotels/bookings |
+ * | /hotels/** | /bookings | /hotels/**/bookings |
+ * | /hotels | {hotel} | /hotels/{hotel} |
+ * | /hotels/* | {hotel} | /hotels/{hotel} |
+ * | /hotels/** | {hotel} | /hotels/**/{hotel} |
+ * | /*.html | /hotels.html | /hotels.html |
+ * | /*.html | /hotels | /hotels.html |
+ * | /*.html | /*.txt | {@code IllegalArgumentException} |
+ *
+ *
+ * @param pattern1 the first pattern
+ * @param pattern2 the second pattern
+ * @return the combination of the two patterns
+ * @throws IllegalArgumentException if the two patterns cannot be combined
+ */
+ public String combine(String pattern1, String pattern2) {
+ if (StrUtil.isEmpty(pattern1) && StrUtil.isEmpty(pattern2)) {
+ return StrUtil.EMPTY;
+ }
+ if (StrUtil.isEmpty(pattern1)) {
+ return pattern2;
+ }
+ if (StrUtil.isEmpty(pattern2)) {
+ return pattern1;
+ }
+
+ boolean pattern1ContainsUriVar = (pattern1.indexOf('{') != -1);
+ if (!pattern1.equals(pattern2) && !pattern1ContainsUriVar && match(pattern1, pattern2)) {
+ // /* + /hotel -> /hotel ; "/*.*" + "/*.html" -> /*.html
+ // However /user + /user -> /usr/user ; /{foo} + /bar -> /{foo}/bar
+ return pattern2;
+ }
+
+ // /hotels/* + /booking -> /hotels/booking
+ // /hotels/* + booking -> /hotels/booking
+ if (pattern1.endsWith(this.pathSeparatorPatternCache.getEndsOnWildCard())) {
+ return concat(pattern1.substring(0, pattern1.length() - 2), pattern2);
+ }
+
+ // /hotels/** + /booking -> /hotels/**/booking
+ // /hotels/** + booking -> /hotels/**/booking
+ if (pattern1.endsWith(this.pathSeparatorPatternCache.getEndsOnDoubleWildCard())) {
+ return concat(pattern1, pattern2);
+ }
+
+ int starDotPos1 = pattern1.indexOf("*.");
+ if (pattern1ContainsUriVar || starDotPos1 == -1 || this.pathSeparator.equals(".")) {
+ // simply concatenate the two patterns
+ return concat(pattern1, pattern2);
+ }
+
+ String ext1 = pattern1.substring(starDotPos1 + 1);
+ int dotPos2 = pattern2.indexOf('.');
+ String file2 = (dotPos2 == -1 ? pattern2 : pattern2.substring(0, dotPos2));
+ String ext2 = (dotPos2 == -1 ? "" : pattern2.substring(dotPos2));
+ boolean ext1All = (ext1.equals(".*") || ext1.isEmpty());
+ boolean ext2All = (ext2.equals(".*") || ext2.isEmpty());
+ if (!ext1All && !ext2All) {
+ throw new IllegalArgumentException("Cannot combine patterns: " + pattern1 + " vs " + pattern2);
+ }
+ String ext = (ext1All ? ext2 : ext1);
+ return file2 + ext;
+ }
+
+ private String concat(String path1, String path2) {
+ boolean path1EndsWithSeparator = path1.endsWith(this.pathSeparator);
+ boolean path2StartsWithSeparator = path2.startsWith(this.pathSeparator);
+
+ if (path1EndsWithSeparator && path2StartsWithSeparator) {
+ return path1 + path2.substring(1);
+ } else if (path1EndsWithSeparator || path2StartsWithSeparator) {
+ return path1 + path2;
+ } else {
+ return path1 + this.pathSeparator + path2;
+ }
+ }
+
+ /**
+ * Given a full path, returns a {@link Comparator} suitable for sorting patterns in order of
+ * explicitness.
+ * This {@code Comparator} will {@linkplain List#sort(Comparator) sort}
+ * a list so that more specific patterns (without URI templates or wild cards) come before
+ * generic patterns. So given a list with the following patterns, the returned comparator
+ * will sort this list so that the order will be as indicated.
+ *
+ * - {@code /hotels/new}
+ * - {@code /hotels/{hotel}}
+ * - {@code /hotels/*}
+ *
+ * The full path given as parameter is used to test for exact matches. So when the given path
+ * is {@code /hotels/2}, the pattern {@code /hotels/2} will be sorted before {@code /hotels/1}.
+ *
+ * @param path the full path to use for comparison
+ * @return a comparator capable of sorting patterns in order of explicitness
+ */
+ public Comparator getPatternComparator(String path) {
+ return new AntPatternComparator(path);
+ }
+
+
+ /**
+ * Tests whether or not a string matches against a pattern via a {@link Pattern}.
+ * The pattern may contain special characters: '*' means zero or more characters; '?' means one and
+ * only one character; '{' and '}' indicate a URI template pattern. For example /users/{user}.
+ */
+ protected static class AntPathStringMatcher {
+
+ private static final Pattern GLOB_PATTERN = Pattern.compile("\\?|\\*|\\{((?:\\{[^/]+?}|[^/{}]|\\\\[{}])+?)}");
+
+ private static final String DEFAULT_VARIABLE_PATTERN = "((?s).*)";
+
+ private final String rawPattern;
+
+ private final boolean caseSensitive;
+
+ private final boolean exactMatch;
+
+ private final Pattern pattern;
+
+ private final List variableNames = new ArrayList<>();
+
+ public AntPathStringMatcher(String pattern, boolean caseSensitive) {
+ this.rawPattern = pattern;
+ this.caseSensitive = caseSensitive;
+ StringBuilder patternBuilder = new StringBuilder();
+ Matcher matcher = GLOB_PATTERN.matcher(pattern);
+ int end = 0;
+ while (matcher.find()) {
+ patternBuilder.append(quote(pattern, end, matcher.start()));
+ String match = matcher.group();
+ if ("?".equals(match)) {
+ patternBuilder.append('.');
+ } else if ("*".equals(match)) {
+ patternBuilder.append(".*");
+ } else if (match.startsWith("{") && match.endsWith("}")) {
+ int colonIdx = match.indexOf(':');
+ if (colonIdx == -1) {
+ patternBuilder.append(DEFAULT_VARIABLE_PATTERN);
+ this.variableNames.add(matcher.group(1));
+ } else {
+ String variablePattern = match.substring(colonIdx + 1, match.length() - 1);
+ patternBuilder.append('(');
+ patternBuilder.append(variablePattern);
+ patternBuilder.append(')');
+ String variableName = match.substring(1, colonIdx);
+ this.variableNames.add(variableName);
+ }
+ }
+ end = matcher.end();
+ }
+ // No glob pattern was found, this is an exact String match
+ if (end == 0) {
+ this.exactMatch = true;
+ this.pattern = null;
+ } else {
+ this.exactMatch = false;
+ patternBuilder.append(quote(pattern, end, pattern.length()));
+ this.pattern = (this.caseSensitive ? Pattern.compile(patternBuilder.toString()) :
+ Pattern.compile(patternBuilder.toString(), Pattern.CASE_INSENSITIVE));
+ }
+ }
+
+ private String quote(String s, int start, int end) {
+ if (start == end) {
+ return "";
+ }
+ return Pattern.quote(s.substring(start, end));
+ }
+
+ /**
+ * Main entry point.
+ *
+ * @return {@code true} if the string matches against the pattern, or {@code false} otherwise.
+ */
+ public boolean matchStrings(String str, Map uriTemplateVariables) {
+ if (this.exactMatch) {
+ return this.caseSensitive ? this.rawPattern.equals(str) : this.rawPattern.equalsIgnoreCase(str);
+ } else if (this.pattern != null) {
+ Matcher matcher = this.pattern.matcher(str);
+ if (matcher.matches()) {
+ if (uriTemplateVariables != null) {
+ if (this.variableNames.size() != matcher.groupCount()) {
+ throw new IllegalArgumentException("The number of capturing groups in the pattern segment " +
+ this.pattern + " does not match the number of URI template variables it defines, " +
+ "which can occur if capturing groups are used in a URI template regex. " +
+ "Use non-capturing groups instead.");
+ }
+ for (int i = 1; i <= matcher.groupCount(); i++) {
+ String name = this.variableNames.get(i - 1);
+ if (name.startsWith("*")) {
+ throw new IllegalArgumentException("Capturing patterns (" + name + ") are not " +
+ "supported by the AntPathMatcher. Use the PathPatternParser instead.");
+ }
+ String value = matcher.group(i);
+ uriTemplateVariables.put(name, value);
+ }
+ }
+ return true;
+ }
+ }
+ return false;
+ }
+
+ }
+
+
+ /**
+ * The default {@link Comparator} implementation returned by
+ * {@link #getPatternComparator(String)}.
+ * In order, the most "generic" pattern is determined by the following:
+ *
+ * - if it's null or a capture all pattern (i.e. it is equal to "/**")
+ * - if the other pattern is an actual match
+ * - if it's a catch-all pattern (i.e. it ends with "**"
+ * - if it's got more "*" than the other pattern
+ * - if it's got more "{foo}" than the other pattern
+ * - if it's shorter than the other pattern
+ *
+ */
+ protected static class AntPatternComparator implements Comparator {
+
+ private final String path;
+
+ public AntPatternComparator(String path) {
+ this.path = path;
+ }
+
+ /**
+ * Compare two patterns to determine which should match first, i.e. which
+ * is the most specific regarding the current path.
+ *
+ * @param pattern1 表达式1
+ * @param pattern2 表达式2
+ * @return a negative integer, zero, or a positive integer as pattern1 is
+ * more specific, equally specific, or less specific than pattern2.
+ */
+ @Override
+ public int compare(String pattern1, String pattern2) {
+ PatternInfo info1 = new PatternInfo(pattern1);
+ PatternInfo info2 = new PatternInfo(pattern2);
+
+ if (info1.isLeastSpecific() && info2.isLeastSpecific()) {
+ return 0;
+ } else if (info1.isLeastSpecific()) {
+ return 1;
+ } else if (info2.isLeastSpecific()) {
+ return -1;
+ }
+
+ boolean pattern1EqualsPath = pattern1.equals(this.path);
+ boolean pattern2EqualsPath = pattern2.equals(this.path);
+ if (pattern1EqualsPath && pattern2EqualsPath) {
+ return 0;
+ } else if (pattern1EqualsPath) {
+ return -1;
+ } else if (pattern2EqualsPath) {
+ return 1;
+ }
+
+ if (info1.isPrefixPattern() && info2.isPrefixPattern()) {
+ return info2.getLength() - info1.getLength();
+ } else if (info1.isPrefixPattern() && info2.getDoubleWildcards() == 0) {
+ return 1;
+ } else if (info2.isPrefixPattern() && info1.getDoubleWildcards() == 0) {
+ return -1;
+ }
+
+ if (info1.getTotalCount() != info2.getTotalCount()) {
+ return info1.getTotalCount() - info2.getTotalCount();
+ }
+
+ if (info1.getLength() != info2.getLength()) {
+ return info2.getLength() - info1.getLength();
+ }
+
+ if (info1.getSingleWildcards() < info2.getSingleWildcards()) {
+ return -1;
+ } else if (info2.getSingleWildcards() < info1.getSingleWildcards()) {
+ return 1;
+ }
+
+ if (info1.getUriVars() < info2.getUriVars()) {
+ return -1;
+ } else if (info2.getUriVars() < info1.getUriVars()) {
+ return 1;
+ }
+
+ return 0;
+ }
+
+
+ /**
+ * Value class that holds information about the pattern, e.g. number of
+ * occurrences of "*", "**", and "{" pattern elements.
+ */
+ private static class PatternInfo {
+
+ private final String pattern;
+ private int uriVars;
+ private int singleWildcards;
+ private int doubleWildcards;
+ private boolean catchAllPattern;
+ private boolean prefixPattern;
+ private Integer length;
+
+ public PatternInfo(String pattern) {
+ this.pattern = pattern;
+ if (this.pattern != null) {
+ initCounters();
+ this.catchAllPattern = this.pattern.equals("/**");
+ this.prefixPattern = !this.catchAllPattern && this.pattern.endsWith("/**");
+ }
+ if (this.uriVars == 0) {
+ this.length = (this.pattern != null ? this.pattern.length() : 0);
+ }
+ }
+
+ protected void initCounters() {
+ int pos = 0;
+ if (this.pattern != null) {
+ while (pos < this.pattern.length()) {
+ if (this.pattern.charAt(pos) == '{') {
+ this.uriVars++;
+ pos++;
+ } else if (this.pattern.charAt(pos) == '*') {
+ if (pos + 1 < this.pattern.length() && this.pattern.charAt(pos + 1) == '*') {
+ this.doubleWildcards++;
+ pos += 2;
+ } else if (pos > 0 && !this.pattern.substring(pos - 1).equals(".*")) {
+ this.singleWildcards++;
+ pos++;
+ } else {
+ pos++;
+ }
+ } else {
+ pos++;
+ }
+ }
+ }
+ }
+
+ public int getUriVars() {
+ return this.uriVars;
+ }
+
+ public int getSingleWildcards() {
+ return this.singleWildcards;
+ }
+
+ public int getDoubleWildcards() {
+ return this.doubleWildcards;
+ }
+
+ public boolean isLeastSpecific() {
+ return (this.pattern == null || this.catchAllPattern);
+ }
+
+ public boolean isPrefixPattern() {
+ return this.prefixPattern;
+ }
+
+ public int getTotalCount() {
+ return this.uriVars + this.singleWildcards + (2 * this.doubleWildcards);
+ }
+
+ /**
+ * Returns the length of the given pattern, where template variables are considered to be 1 long.
+ *
+ * @return 长度
+ */
+ public int getLength() {
+ if (this.length == null) {
+ this.length = (this.pattern != null ?
+ VARIABLE_PATTERN.matcher(this.pattern).replaceAll("#").length() : 0);
+ }
+ return this.length;
+ }
+ }
+ }
+
+
+ /**
+ * A simple cache for patterns that depend on the configured path separator.
+ */
+ private static class PathSeparatorPatternCache {
+
+ private final String endsOnWildCard;
+
+ private final String endsOnDoubleWildCard;
+
+ public PathSeparatorPatternCache(String pathSeparator) {
+ this.endsOnWildCard = pathSeparator + "*";
+ this.endsOnDoubleWildCard = pathSeparator + "**";
+ }
+
+ public String getEndsOnWildCard() {
+ return this.endsOnWildCard;
+ }
+
+ public String getEndsOnDoubleWildCard() {
+ return this.endsOnDoubleWildCard;
+ }
+ }
+
+}
diff --git a/hutool-core/src/main/java/cn/hutool/core/text/StrJoiner.java b/hutool-core/src/main/java/cn/hutool/core/text/StrJoiner.java
index bfebd8703..e2a8a5387 100644
--- a/hutool-core/src/main/java/cn/hutool/core/text/StrJoiner.java
+++ b/hutool-core/src/main/java/cn/hutool/core/text/StrJoiner.java
@@ -12,7 +12,14 @@ import java.util.Iterator;
import java.util.function.Function;
/**
- * 字符串连接器（拼接器），通过给定的字符串和多个元素，拼接为一个字符串
+ * 字符串连接器（拼接器），通过给定的字符串和多个元素，拼接为一个字符串
+ * 相较于{@link java.util.StringJoiner}提供更加灵活的配置，包括：
+ *
+ * - 支持任意Appendable接口实现
+ * - 支持每个元素单独wrap
+ * - 支持自定义null的处理逻辑
+ * - 支持自定义默认结果
+ *
*
* @author looly
* @since 5.7.2
@@ -282,6 +289,11 @@ public class StrJoiner implements Appendable, Serializable {
@Override
public StrJoiner append(CharSequence csq) {
+ return append(csq, 0, csq.length());
+ }
+
+ @Override
+ public StrJoiner append(CharSequence csq, int startInclude, int endExclude) {
if (null == csq) {
switch (this.nullMode) {
case IGNORE:
@@ -298,7 +310,7 @@ public class StrJoiner implements Appendable, Serializable {
if (wrapElement && StrUtil.isNotEmpty(this.prefix)) {
appendable.append(prefix);
}
- appendable.append(csq);
+ appendable.append(csq, startInclude, endExclude);
if (wrapElement && StrUtil.isNotEmpty(this.suffix)) {
appendable.append(suffix);
}
@@ -308,29 +320,55 @@ public class StrJoiner implements Appendable, Serializable {
return this;
}
- @Override
- public StrJoiner append(CharSequence csq, int startInclude, int endExclude) {
- return append(StrUtil.sub(csq, startInclude, endExclude));
- }
-
@Override
public StrJoiner append(char c) {
return append(String.valueOf(c));
}
+ /**
+ * 合并一个StrJoiner 到当前的StrJoiner
+ * 合并规则为，在尾部直接追加，当存在{@link #prefix}时，如果{@link #wrapElement}为{@code false}，则去除之。
+ *
+ * @param strJoiner 其他的StrJoiner
+ * @return this
+ * @since 5.7.22
+ */
+ public StrJoiner merge(StrJoiner strJoiner){
+ if(null != strJoiner && null != strJoiner.appendable){
+ final String otherStr = strJoiner.toString();
+ if(strJoiner.wrapElement){
+ this.append(otherStr);
+ }else{
+ this.append(otherStr, this.prefix.length(), otherStr.length());
+ }
+ }
+ return this;
+ }
+
+ /**
+ * 长度
+ * 长度计算方式为prefix + suffix + content
+ * 此方法结果与toString().length()一致。
+ *
+ * @return 长度，如果结果为{@code null}，返回-1
+ * @since 5.7.22
+ */
+ public int length() {
+ return (this.appendable != null ? this.appendable.toString().length() + suffix.length() :
+ null == this.emptyResult ? -1 : emptyResult.length());
+ }
+
@Override
public String toString() {
if (null == this.appendable) {
return emptyResult;
}
+
+ String result = this.appendable.toString();
if (false == wrapElement && StrUtil.isNotEmpty(this.suffix)) {
- try {
- this.appendable.append(this.suffix);
- } catch (IOException e) {
- throw new IORuntimeException(e);
- }
+ result += this.suffix;
}
- return this.appendable.toString();
+ return result;
}
/**
diff --git a/hutool-core/src/main/java/cn/hutool/core/text/csv/package-info.java b/hutool-core/src/main/java/cn/hutool/core/text/csv/package-info.java
index bc6af864b..7863d5c06 100644
--- a/hutool-core/src/main/java/cn/hutool/core/text/csv/package-info.java
+++ b/hutool-core/src/main/java/cn/hutool/core/text/csv/package-info.java
@@ -1,7 +1,8 @@
/**
- * 提供CSV文件读写的封装，入口为CsvUtil
+ * 提供CSV文件读写的封装，入口为CsvUtil
+ * 规范见：https://datatracker.ietf.org/doc/html/rfc4180
*
* @author looly
*
*/
-package cn.hutool.core.text.csv;
\ No newline at end of file
+package cn.hutool.core.text.csv;
diff --git a/hutool-core/src/main/java/cn/hutool/core/util/ByteUtil.java b/hutool-core/src/main/java/cn/hutool/core/util/ByteUtil.java
index f20d26914..d2517a855 100644
--- a/hutool-core/src/main/java/cn/hutool/core/util/ByteUtil.java
+++ b/hutool-core/src/main/java/cn/hutool/core/util/ByteUtil.java
@@ -27,7 +27,11 @@ import java.util.concurrent.atomic.LongAdder;
*/
public class ByteUtil {
- public static ByteOrder DEFAULT_ORDER = ByteOrder.LITTLE_ENDIAN;
+ public static final ByteOrder DEFAULT_ORDER = ByteOrder.LITTLE_ENDIAN;
+ /**
+ * CPU的字节序
+ */
+ public static final ByteOrder CPU_ENDIAN = "little".equals(System.getProperty("sun.cpu.endian")) ? ByteOrder.LITTLE_ENDIAN : ByteOrder.BIG_ENDIAN;
/**
* int转byte
@@ -130,16 +134,30 @@ public class ByteUtil {
* @return int值
*/
public static int bytesToInt(byte[] bytes, ByteOrder byteOrder) {
+ return bytesToInt(bytes, 0, byteOrder);
+ }
+
+ /**
+ * byte[]转int值
+ * 自定义端序
+ *
+ * @param bytes byte数组
+ * @param start 开始位置（包含）
+ * @param byteOrder 端序
+ * @return int值
+ * @since 5.7.21
+ */
+ public static int bytesToInt(byte[] bytes, int start, ByteOrder byteOrder) {
if (ByteOrder.LITTLE_ENDIAN == byteOrder) {
- return bytes[0] & 0xFF | //
- (bytes[1] & 0xFF) << 8 | //
- (bytes[2] & 0xFF) << 16 | //
- (bytes[3] & 0xFF) << 24; //
+ return bytes[start] & 0xFF | //
+ (bytes[1 + start] & 0xFF) << 8 | //
+ (bytes[2 + start] & 0xFF) << 16 | //
+ (bytes[3 + start] & 0xFF) << 24; //
} else {
- return bytes[3] & 0xFF | //
- (bytes[2] & 0xFF) << 8 | //
- (bytes[1] & 0xFF) << 16 | //
- (bytes[0] & 0xFF) << 24; //
+ return bytes[3 + start] & 0xFF | //
+ (bytes[2 + start] & 0xFF) << 8 | //
+ (bytes[1 + start] & 0xFF) << 16 | //
+ (bytes[start] & 0xFF) << 24; //
}
}
@@ -243,16 +261,31 @@ public class ByteUtil {
* @return long值
*/
public static long bytesToLong(byte[] bytes, ByteOrder byteOrder) {
+ return bytesToLong(bytes, 0, byteOrder);
+ }
+
+ /**
+ * byte数组转long
+ * 自定义端序
+ * from: https://stackoverflow.com/questions/4485128/how-do-i-convert-long-to-byte-and-back-in-java
+ *
+ * @param bytes byte数组
+ * @param start 计算数组开始位置
+ * @param byteOrder 端序
+ * @return long值
+ * @since 5.7.21
+ */
+ public static long bytesToLong(byte[] bytes, int start, ByteOrder byteOrder) {
long values = 0;
if (ByteOrder.LITTLE_ENDIAN == byteOrder) {
for (int i = (Long.BYTES - 1); i >= 0; i--) {
values <<= Byte.SIZE;
- values |= (bytes[i] & 0xff);
+ values |= (bytes[i + start] & 0xff);
}
} else {
for (int i = 0; i < Long.BYTES; i++) {
values <<= Byte.SIZE;
- values |= (bytes[i] & 0xff);
+ values |= (bytes[i + start] & 0xff);
}
}
diff --git a/hutool-core/src/main/java/cn/hutool/core/util/CoordinateUtil.java b/hutool-core/src/main/java/cn/hutool/core/util/CoordinateUtil.java
index 826d711eb..f915358ad 100644
--- a/hutool-core/src/main/java/cn/hutool/core/util/CoordinateUtil.java
+++ b/hutool-core/src/main/java/cn/hutool/core/util/CoordinateUtil.java
@@ -22,12 +22,12 @@ public class CoordinateUtil {
/**
* 坐标转换参数：(火星坐标系与百度坐标系转换的中间量)
*/
- public static final double X_PI = 3.14159265358979324 * 3000.0 / 180.0;
+ public static final double X_PI = 3.1415926535897932384626433832795 * 3000.0 / 180.0;
/**
* 坐标转换参数：π
*/
- public static final double PI = 3.1415926535897932384626D;
+ public static final double PI = 3.1415926535897932384626433832795D;
/**
* 地球半径（Krasovsky 1940）
@@ -280,7 +280,7 @@ public class CoordinateUtil {
*/
public Coordinate offset(Coordinate offset){
this.lng += offset.lng;
- this.lat += offset.lng;
+ this.lat += offset.lat;
return this;
}
diff --git a/hutool-core/src/main/java/cn/hutool/core/util/CreditCodeUtil.java b/hutool-core/src/main/java/cn/hutool/core/util/CreditCodeUtil.java
index 2cdbe7ef9..e1ee0bf26 100644
--- a/hutool-core/src/main/java/cn/hutool/core/util/CreditCodeUtil.java
+++ b/hutool-core/src/main/java/cn/hutool/core/util/CreditCodeUtil.java
@@ -7,7 +7,8 @@ import java.util.concurrent.ConcurrentHashMap;
import java.util.regex.Pattern;
/**
- * 统一社会信用代码工具类
+ * 统一社会信用代码（GB32100-2015）工具类
+ * 标准见：https://www.cods.org.cn/c/2020-10-29/12575.html
*
*
* 第一部分：登记管理部门代码1位 (数字或大写英文字母)
@@ -24,7 +25,13 @@ public class CreditCodeUtil {
public static final Pattern CREDIT_CODE_PATTERN = PatternPool.CREDIT_CODE;
+ /**
+ * 加权因子
+ */
private static final int[] WEIGHT = {1, 3, 9, 27, 19, 26, 16, 17, 20, 29, 25, 13, 8, 24, 10, 30, 28};
+ /**
+ * 代码字符集
+ */
private static final char[] BASE_CODE_ARRAY = "0123456789ABCDEFGHJKLMNPQRTUWXY".toCharArray();
private static final Map CODE_INDEX_MAP;
@@ -110,10 +117,10 @@ public class CreditCodeUtil {
}
/**
- * 获取校验码
+ * 获取校验位的值
*
* @param creditCode 统一社会信息代码
- * @return 获取较验位的值
+ * @return 获取校验位的值，-1表示获取错误
*/
private static int getParityBit(CharSequence creditCode) {
int sum = 0;
diff --git a/hutool-core/src/main/java/cn/hutool/core/util/HashUtil.java b/hutool-core/src/main/java/cn/hutool/core/util/HashUtil.java
index 97ee1537b..bafe37995 100644
--- a/hutool-core/src/main/java/cn/hutool/core/util/HashUtil.java
+++ b/hutool-core/src/main/java/cn/hutool/core/util/HashUtil.java
@@ -1,6 +1,7 @@
package cn.hutool.core.util;
import cn.hutool.core.lang.hash.CityHash;
+import cn.hutool.core.lang.hash.MetroHash;
import cn.hutool.core.lang.hash.MurmurHash;
import cn.hutool.core.lang.hash.Number128;
@@ -386,7 +387,7 @@ public class HashUtil {
if (ucChar <= 'Z' && ucChar >= 'A') {
ucChar = (char) (ucChar + 32);
}
- hash += (3 * i * ucChar * ucChar + 5 * i * ucChar + 7 * i + 11 * ucChar) % 16777216;
+ hash += (3L * i * ucChar * ucChar + 5L * i * ucChar + 7L * i + 11 * ucChar) % 16777216;
}
} else {
for (i = 1; i <= 96; i++) {
@@ -394,7 +395,7 @@ public class HashUtil {
if (ucChar <= 'Z' && ucChar >= 'A') {
ucChar = (char) (ucChar + 32);
}
- hash += (3 * i * ucChar * ucChar + 5 * i * ucChar + 7 * i + 11 * ucChar) % 16777216;
+ hash += (3L * i * ucChar * ucChar + 5L * i * ucChar + 7L * i + 11 * ucChar) % 16777216;
}
}
if (hash < 0) {
@@ -545,4 +546,46 @@ public class HashUtil {
public static long[] cityHash128(byte[] data, Number128 seed) {
return CityHash.hash128(data, seed).getLongArray();
}
+
+ /**
+ * MetroHash 算法64-bit实现
+ *
+ * @param data 数据
+ * @param seed 种子
+ * @return hash值
+ */
+ public static long metroHash64(byte[] data, long seed) {
+ return MetroHash.hash64(data, seed);
+ }
+
+ /**
+ * MetroHash 算法64-bit实现
+ *
+ * @param data 数据
+ * @return hash值
+ */
+ public static long metroHash64(byte[] data) {
+ return MetroHash.hash64(data);
+ }
+
+ /**
+ * MetroHash 算法128-bit实现
+ *
+ * @param data 数据
+ * @param seed 种子
+ * @return hash值，long[0]：低位，long[1]：高位
+ */
+ public static long[] metroHash128(byte[] data, long seed) {
+ return MetroHash.hash128(data,seed).getLongArray();
+ }
+
+ /**
+ * MetroHash 算法128-bit实现
+ *
+ * @param data 数据
+ * @return hash值，long[0]：低位，long[1]：高位
+ */
+ public static long[] metroHash128(byte[] data) {
+ return MetroHash.hash128(data).getLongArray();
+ }
}
diff --git a/hutool-core/src/main/java/cn/hutool/core/util/ReUtil.java b/hutool-core/src/main/java/cn/hutool/core/util/ReUtil.java
index e9212367f..3336445bb 100644
--- a/hutool-core/src/main/java/cn/hutool/core/util/ReUtil.java
+++ b/hutool-core/src/main/java/cn/hutool/core/util/ReUtil.java
@@ -105,7 +105,7 @@ public class ReUtil {
}
/**
- * 获得匹配的字符串，，获得正则中分组0的内容
+ * 获得匹配的字符串，获得正则中分组0的内容
*
* @param pattern 编译后的正则模式
* @param content 被匹配的内容
diff --git a/hutool-core/src/main/java/cn/hutool/core/util/RuntimeUtil.java b/hutool-core/src/main/java/cn/hutool/core/util/RuntimeUtil.java
index d5fc4c9f5..b1b030c28 100644
--- a/hutool-core/src/main/java/cn/hutool/core/util/RuntimeUtil.java
+++ b/hutool-core/src/main/java/cn/hutool/core/util/RuntimeUtil.java
@@ -34,7 +34,7 @@ public class RuntimeUtil {
}
/**
- * 执行系统命令，使用系统默认编码
+ * 执行系统命令，使用传入的 {@link Charset charset} 编码
*
* @param charset 编码
* @param cmds 命令列表，每个元素代表一条命令
@@ -58,7 +58,7 @@ public class RuntimeUtil {
}
/**
- * 执行系统命令，使用系统默认编码
+ * 执行系统命令，使用传入的 {@link Charset charset} 编码
*
* @param charset 编码
* @param cmds 命令列表，每个元素代表一条命令
@@ -131,7 +131,7 @@ public class RuntimeUtil {
}
/**
- * 获取命令执行结果，使用系统默认编码，获取后销毁进程
+ * 获取命令执行结果，使用传入的 {@link Charset charset} 编码，获取后销毁进程
*
* @param process {@link Process} 进程
* @param charset 编码
@@ -150,7 +150,7 @@ public class RuntimeUtil {
}
/**
- * 获取命令执行结果，使用系统默认编码，，获取后销毁进程
+ * 获取命令执行结果，使用系统默认编码，获取后销毁进程
*
* @param process {@link Process} 进程
* @return 命令执行结果列表
@@ -180,7 +180,7 @@ public class RuntimeUtil {
}
/**
- * 获取命令执行异常结果，使用系统默认编码，，获取后销毁进程
+ * 获取命令执行异常结果，使用系统默认编码，获取后销毁进程
*
* @param process {@link Process} 进程
* @return 命令执行结果列表
diff --git a/hutool-core/src/main/java/cn/hutool/core/util/SystemPropsUtil.java b/hutool-core/src/main/java/cn/hutool/core/util/SystemPropsUtil.java
index d22679567..83d9d1cf7 100644
--- a/hutool-core/src/main/java/cn/hutool/core/util/SystemPropsUtil.java
+++ b/hutool-core/src/main/java/cn/hutool/core/util/SystemPropsUtil.java
@@ -108,7 +108,7 @@ public class SystemPropsUtil {
* @param defaultValue 默认值
* @return 值
*/
- public static long getInt(String key, int defaultValue) {
+ public static int getInt(String key, int defaultValue) {
return Convert.toInt(get(key), defaultValue);
}
diff --git a/hutool-core/src/main/java/cn/hutool/core/util/URLUtil.java b/hutool-core/src/main/java/cn/hutool/core/util/URLUtil.java
index 724312695..fde460ff2 100644
--- a/hutool-core/src/main/java/cn/hutool/core/util/URLUtil.java
+++ b/hutool-core/src/main/java/cn/hutool/core/util/URLUtil.java
@@ -95,6 +95,26 @@ public class URLUtil extends URLEncodeUtil {
*/
public static final String WAR_URL_SEPARATOR = "*/";
+ /**
+ * 将{@link URI}转换为{@link URL}
+ *
+ * @param uri {@link URI}
+ * @return URL对象
+ * @see URI#toURL()
+ * @throws UtilException {@link MalformedURLException}包装，URI格式有问题时抛出
+ * @since 5.7.21
+ */
+ public static URL url(URI uri) throws UtilException{
+ if(null == uri){
+ return null;
+ }
+ try {
+ return uri.toURL();
+ } catch (MalformedURLException e) {
+ throw new UtilException(e);
+ }
+ }
+
/**
* 通过一个字符串形式的URL地址创建URL对象
*
@@ -114,7 +134,9 @@ public class URLUtil extends URLEncodeUtil {
* @since 4.1.1
*/
public static URL url(String url, URLStreamHandler handler) {
- Assert.notNull(url, "URL must not be null");
+ if(null == url){
+ return null;
+ }
// 兼容Spring的ClassPath路径
if (url.startsWith(CLASSPATH_URL_PREFIX)) {
@@ -142,6 +164,9 @@ public class URLUtil extends URLEncodeUtil {
* @since 5.5.2
*/
public static URI getStringURI(CharSequence content) {
+ if(null == content){
+ return null;
+ }
final String contentStr = StrUtil.addPrefixIfNot(content, "string:///");
return URI.create(contentStr);
}
@@ -461,6 +486,7 @@ public class URLUtil extends URLEncodeUtil {
* @since 3.0.9
*/
public static boolean isFileURL(URL url) {
+ Assert.notNull(url, "URL must be not null");
String protocol = url.getProtocol();
return (URL_PROTOCOL_FILE.equals(protocol) || //
URL_PROTOCOL_VFSFILE.equals(protocol) || //
@@ -474,6 +500,7 @@ public class URLUtil extends URLEncodeUtil {
* @return 是否为jar包URL
*/
public static boolean isJarURL(URL url) {
+ Assert.notNull(url, "URL must be not null");
final String protocol = url.getProtocol();
return (URL_PROTOCOL_JAR.equals(protocol) || //
URL_PROTOCOL_ZIP.equals(protocol) || //
@@ -489,6 +516,7 @@ public class URLUtil extends URLEncodeUtil {
* @since 4.1
*/
public static boolean isJarFileURL(URL url) {
+ Assert.notNull(url, "URL must be not null");
return (URL_PROTOCOL_FILE.equals(url.getProtocol()) && //
url.getPath().toLowerCase().endsWith(FileUtil.JAR_FILE_EXT));
}
@@ -501,7 +529,7 @@ public class URLUtil extends URLEncodeUtil {
* @since 3.2.1
*/
public static InputStream getStream(URL url) {
- Assert.notNull(url);
+ Assert.notNull(url, "URL must be not null");
try {
return url.openStream();
} catch (IOException e) {
diff --git a/hutool-core/src/main/java/cn/hutool/core/util/ZipUtil.java b/hutool-core/src/main/java/cn/hutool/core/util/ZipUtil.java
index 3b1ac5655..84657cfd1 100644
--- a/hutool-core/src/main/java/cn/hutool/core/util/ZipUtil.java
+++ b/hutool-core/src/main/java/cn/hutool/core/util/ZipUtil.java
@@ -1,5 +1,6 @@
package cn.hutool.core.util;
+import cn.hutool.core.collection.EnumerationIter;
import cn.hutool.core.compress.Deflate;
import cn.hutool.core.compress.Gzip;
import cn.hutool.core.compress.ZipCopyVisitor;
@@ -29,7 +30,6 @@ import java.nio.file.FileSystem;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
-import java.util.Collections;
import java.util.List;
import java.util.function.Consumer;
import java.util.zip.ZipEntry;
@@ -953,7 +953,8 @@ public class ZipUtil {
}
/**
- * 获取Zip文件中指定目录下的所有文件，只显示文件，不显示目录
+ * 获取Zip文件中指定目录下的所有文件，只显示文件，不显示目录
+ * 此方法并不会关闭{@link ZipFile}。
*
* @param zipFile Zip文件
* @param dir 目录前缀（目录前缀不包含开头的/）
@@ -968,7 +969,7 @@ public class ZipUtil {
final List fileNames = new ArrayList<>();
String name;
- for (ZipEntry entry : Collections.list(zipFile.entries())) {
+ for (ZipEntry entry : new EnumerationIter<>(zipFile.entries())) {
name = entry.getName();
if (StrUtil.isEmpty(dir) || name.startsWith(dir)) {
final String nameSuffix = StrUtil.removePrefix(name, dir);
diff --git a/hutool-core/src/test/java/cn/hutool/core/builder/GenericBuilderTest.java b/hutool-core/src/test/java/cn/hutool/core/builder/GenericBuilderTest.java
index 84f6d4581..e74a985ac 100644
--- a/hutool-core/src/test/java/cn/hutool/core/builder/GenericBuilderTest.java
+++ b/hutool-core/src/test/java/cn/hutool/core/builder/GenericBuilderTest.java
@@ -8,6 +8,9 @@ import lombok.experimental.Accessors;
import org.junit.Assert;
import org.junit.Test;
+import java.util.HashMap;
+import java.util.Map;
+
/**
* {@link GenericBuilder} 单元测试类
*
@@ -58,6 +61,21 @@ public class GenericBuilderTest {
Assert.assertEquals(222, box1.getLength().intValue());
Assert.assertEquals(333, box1.getWidth().intValue());
Assert.assertEquals(444, box1.getHeight().intValue());
+ Assert.assertEquals("TomXin:\"Hello Partner!\"", box1.getTitleAlias());
+ }
+
+ @Test
+ public void buildMapTest(){
+ //Map创建
+ HashMap colorMap = GenericBuilder
+ .of(HashMap::new)
+ .with(Map::put, "red", "#FF0000")
+ .with(Map::put, "yellow", "#FFFF00")
+ .with(Map::put, "blue", "#0000FF")
+ .build();
+ Assert.assertEquals("#FF0000", colorMap.get("red"));
+ Assert.assertEquals("#FFFF00", colorMap.get("yellow"));
+ Assert.assertEquals("#0000FF", colorMap.get("blue"));
}
@Getter
diff --git a/hutool-core/src/test/java/cn/hutool/core/codec/Base58Test.java b/hutool-core/src/test/java/cn/hutool/core/codec/Base58Test.java
new file mode 100644
index 000000000..0dab5faf2
--- /dev/null
+++ b/hutool-core/src/test/java/cn/hutool/core/codec/Base58Test.java
@@ -0,0 +1,40 @@
+package cn.hutool.core.codec;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.nio.charset.StandardCharsets;
+
+public class Base58Test {
+
+ @Test
+ public void encodeCheckedTest() {
+ String a = "hello world";
+ String encode = Base58.encodeChecked(0, a.getBytes());
+ Assert.assertEquals(1 + "3vQB7B6MrGQZaxCuFg4oh", encode);
+
+ // 无版本位
+ encode = Base58.encodeChecked(null, a.getBytes());
+ Assert.assertEquals("3vQB7B6MrGQZaxCuFg4oh", encode);
+ }
+ @Test
+ public void encodeTest() {
+ String a = "hello world";
+ String encode = Base58.encode(a.getBytes(StandardCharsets.UTF_8));
+ Assert.assertEquals("StV1DL6CwTryKyV", encode);
+ }
+ @Test
+ public void decodeCheckedTest() {
+ String a = "3vQB7B6MrGQZaxCuFg4oh";
+ byte[] decode = Base58.decodeChecked(1 + a);
+ Assert.assertArrayEquals("hello world".getBytes(StandardCharsets.UTF_8),decode);
+ decode = Base58.decodeChecked(a);
+ Assert.assertArrayEquals("hello world".getBytes(StandardCharsets.UTF_8),decode);
+ }
+ @Test
+ public void testDecode() {
+ String a = "StV1DL6CwTryKyV";
+ byte[] decode = Base58.decode(a);
+ Assert.assertArrayEquals("hello world".getBytes(StandardCharsets.UTF_8),decode);
+ }
+}
diff --git a/hutool-core/src/test/java/cn/hutool/core/collection/ListUtilTest.java b/hutool-core/src/test/java/cn/hutool/core/collection/ListUtilTest.java
index 5cecd5de3..937fb5917 100644
--- a/hutool-core/src/test/java/cn/hutool/core/collection/ListUtilTest.java
+++ b/hutool-core/src/test/java/cn/hutool/core/collection/ListUtilTest.java
@@ -227,5 +227,9 @@ public class ListUtilTest {
ListUtil.swapElement(list, map2, map3);
Map map = list.get(2);
Assert.assertEquals("李四", map.get("2"));
+
+ ListUtil.swapElement(list, map2, map1);
+ map = list.get(0);
+ Assert.assertEquals("李四", map.get("2"));
}
}
diff --git a/hutool-core/src/test/java/cn/hutool/core/date/ChineseDateTest.java b/hutool-core/src/test/java/cn/hutool/core/date/ChineseDateTest.java
index e2d86d1e9..20914552c 100644
--- a/hutool-core/src/test/java/cn/hutool/core/date/ChineseDateTest.java
+++ b/hutool-core/src/test/java/cn/hutool/core/date/ChineseDateTest.java
@@ -4,6 +4,8 @@ import cn.hutool.core.util.StrUtil;
import org.junit.Assert;
import org.junit.Test;
+import java.util.Date;
+
public class ChineseDateTest {
@Test
@@ -113,4 +115,28 @@ public class ChineseDateTest {
final String chineseMonth = springFestival.getChineseMonth();
Assert.assertEquals("一月", chineseMonth);
}
+
+ @Test
+ public void day19700101Test(){
+ // https://gitee.com/dromara/hutool/issues/I4UTPK
+ Date date = DateUtil.parse("1970-01-01");
+ ChineseDate chineseDate = new ChineseDate(date);
+ Assert.assertEquals("己酉鸡年 冬月廿四", chineseDate.toString());
+
+ date = DateUtil.parse("1970-01-02");
+ chineseDate = new ChineseDate(date);
+ Assert.assertEquals("己酉鸡年 冬月廿五", chineseDate.toString());
+
+ date = DateUtil.parse("1970-01-03");
+ chineseDate = new ChineseDate(date);
+ Assert.assertEquals("己酉鸡年 冬月廿六", chineseDate.toString());
+ }
+
+ @Test
+ public void day19000101Test(){
+ // 1900-01-31之前不支持
+ Date date = DateUtil.parse("1900-01-31");
+ ChineseDate chineseDate = new ChineseDate(date);
+ Assert.assertEquals("庚子鼠年 正月初一", chineseDate.toString());
+ }
}
diff --git a/hutool-core/src/test/java/cn/hutool/core/date/DateUtilTest.java b/hutool-core/src/test/java/cn/hutool/core/date/DateUtilTest.java
index b75ed7737..fc7e6d8e7 100644
--- a/hutool-core/src/test/java/cn/hutool/core/date/DateUtilTest.java
+++ b/hutool-core/src/test/java/cn/hutool/core/date/DateUtilTest.java
@@ -692,7 +692,6 @@ public class DateUtilTest {
@Test
public void parseCSTTest() {
String dateStr = "Wed Sep 16 11:26:23 CST 2009";
- Console.log(TimeZone.getDefault().getDisplayName());
SimpleDateFormat sdf = new SimpleDateFormat(DatePattern.JDK_DATETIME_PATTERN, Locale.US);
// Asia/Shanghai是以地区命名的地区标准时，在中国叫CST，因此如果解析CST时不使用"Asia/Shanghai"而使用"GMT+08:00"，会导致相差一个小时
@@ -995,11 +994,13 @@ public class DateUtilTest {
@Test
public void parseSingleMonthAndDayTest() {
- final DateTime parse = DateUtil.parse("2021-1-1");
+ DateTime parse = DateUtil.parse("2021-1-1");
Assert.assertNotNull(parse);
Assert.assertEquals("2021-01-01 00:00:00", parse.toString());
- Console.log(DateUtil.parse("2021-1-22 00:00:00"));
+ parse = DateUtil.parse("2021-1-22 00:00:00");
+ Assert.assertNotNull(parse);
+ Assert.assertEquals("2021-01-22 00:00:00", parse.toString());
}
@Test
@@ -1022,22 +1023,8 @@ public class DateUtilTest {
}
@Test
- public void isOverlapTest() {
- DateTime oneStartTime = DateTime.of("2022-01-01 10:10:10", DatePattern.NORM_DATETIME_PATTERN);
- DateTime oneEndTime = DateTime.of("2022-01-01 11:10:10", DatePattern.NORM_DATETIME_PATTERN);
-
- DateTime oneStartTime2 = DateTime.of("2022-01-01 11:20:10", DatePattern.NORM_DATETIME_PATTERN);
- DateTime oneEndTime2 = DateTime.of("2022-01-01 11:30:10", DatePattern.NORM_DATETIME_PATTERN);
-
- DateTime oneStartTime3 = DateTime.of("2022-01-01 11:40:10", DatePattern.NORM_DATETIME_PATTERN);
- DateTime oneEndTime3 = DateTime.of("2022-01-01 11:50:10", DatePattern.NORM_DATETIME_PATTERN);
-
- //真实请假数据
- DateTime realStartTime = DateTime.of("2022-01-01 11:49:10", DatePattern.NORM_DATETIME_PATTERN);
- DateTime realEndTime = DateTime.of("2022-01-01 12:00:10", DatePattern.NORM_DATETIME_PATTERN);
-
- Assert.assertTrue(DateUtil.isOverlap(oneStartTime, oneEndTime, realStartTime, realEndTime));
- Assert.assertTrue(DateUtil.isOverlap(oneStartTime2, oneEndTime2, realStartTime, realEndTime));
- Assert.assertFalse(DateUtil.isOverlap(oneStartTime3, oneEndTime3, realStartTime, realEndTime));
+ public void parseTimeTest(){
+ final DateTime dateTime = DateUtil.parse("12:23:34");
+ Console.log(dateTime);
}
}
diff --git a/hutool-core/src/test/java/cn/hutool/core/date/LocalDateTimeUtilTest.java b/hutool-core/src/test/java/cn/hutool/core/date/LocalDateTimeUtilTest.java
index 57d6eb717..1d9df253e 100644
--- a/hutool-core/src/test/java/cn/hutool/core/date/LocalDateTimeUtilTest.java
+++ b/hutool-core/src/test/java/cn/hutool/core/date/LocalDateTimeUtilTest.java
@@ -1,13 +1,16 @@
package cn.hutool.core.date;
+import cn.hutool.core.lang.Console;
import org.junit.Assert;
import org.junit.Test;
import java.time.Duration;
+import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
+import java.time.temporal.TemporalAccessor;
public class LocalDateTimeUtilTest {
@@ -217,4 +220,11 @@ public class LocalDateTimeUtilTest {
final int weekOfYear2 = LocalDateTimeUtil.weekOfYear(date1.atStartOfDay());
Assert.assertEquals(5, weekOfYear2);
}
+
+ @Test
+ public void ofTest2(){
+ final Instant instant = DateUtil.parse("2022-02-22").toInstant();
+ final LocalDateTime of = LocalDateTimeUtil.of((TemporalAccessor) instant);
+ Console.log(of);
+ }
}
diff --git a/hutool-core/src/test/java/cn/hutool/core/exceptions/CheckedUtilTest.java b/hutool-core/src/test/java/cn/hutool/core/exceptions/CheckedUtilTest.java
index 35be0f241..5790f24fa 100644
--- a/hutool-core/src/test/java/cn/hutool/core/exceptions/CheckedUtilTest.java
+++ b/hutool-core/src/test/java/cn/hutool/core/exceptions/CheckedUtilTest.java
@@ -38,7 +38,6 @@ public class CheckedUtilTest {
}
}
- @SuppressWarnings("ConstantConditions")
@Test
public void functionTest() {
Func1 afunc = (funcParam) -> {
diff --git a/hutool-core/src/test/java/cn/hutool/core/io/FileUtilTest.java b/hutool-core/src/test/java/cn/hutool/core/io/FileUtilTest.java
index 13bf3382f..d70490e8b 100644
--- a/hutool-core/src/test/java/cn/hutool/core/io/FileUtilTest.java
+++ b/hutool-core/src/test/java/cn/hutool/core/io/FileUtilTest.java
@@ -452,4 +452,26 @@ public class FileUtilTest {
List list = ListUtil.toList("a", "b", "c");
FileUtil.appendLines(list, FileUtil.file("d:/test/appendLines.txt"), CharsetUtil.CHARSET_UTF_8);
}
+
+ @Test
+ @Ignore
+ public void createTempFileTest(){
+ File nullDirTempFile = FileUtil.createTempFile();
+ Assert.assertTrue(nullDirTempFile.exists());
+
+ File suffixDirTempFile = FileUtil.createTempFile(".xlsx",true);
+ Assert.assertEquals("xlsx", FileUtil.getSuffix(suffixDirTempFile));
+
+ File prefixDirTempFile = FileUtil.createTempFile("prefix",".xlsx",true);
+ Assert.assertTrue(FileUtil.getPrefix(prefixDirTempFile).startsWith("prefix"));
+ }
+
+ @Test
+ @Ignore
+ public void getTotalLinesTest() {
+ // 千万行秒级内返回
+ final int totalLines = FileUtil.getTotalLines(FileUtil.file(""));
+ Assert.assertEquals(10000000, totalLines);
+ }
+
}
diff --git a/hutool-core/src/test/java/cn/hutool/core/lang/RangeTest.java b/hutool-core/src/test/java/cn/hutool/core/lang/RangeTest.java
index 9feb53927..b10b115eb 100644
--- a/hutool-core/src/test/java/cn/hutool/core/lang/RangeTest.java
+++ b/hutool-core/src/test/java/cn/hutool/core/lang/RangeTest.java
@@ -4,6 +4,7 @@ import cn.hutool.core.date.DateField;
import cn.hutool.core.date.DateRange;
import cn.hutool.core.date.DateTime;
import cn.hutool.core.date.DateUtil;
+import cn.hutool.core.util.StrUtil;
import org.junit.Assert;
import org.junit.Test;
@@ -12,8 +13,8 @@ import java.util.NoSuchElementException;
/**
* {@link Range} 单元测试
- * @author Looly
*
+ * @author Looly
*/
public class RangeTest {
@@ -58,8 +59,8 @@ public class RangeTest {
Assert.assertEquals(sb.toString(), "1#2#3#");
StringBuilder sb2 = new StringBuilder();
- DateUtil.rangeConsume(null, null, DateField.DAY_OF_YEAR, a -> sb.append(DateTime.of(a).dayOfMonth()).append("#"));
- Assert.assertEquals(sb2.toString(), "");
+ DateUtil.rangeConsume(null, null, DateField.DAY_OF_YEAR, a -> sb2.append(DateTime.of(a).dayOfMonth()).append("#"));
+ Assert.assertEquals(sb2.toString(), StrUtil.EMPTY);
}
@Test
@@ -110,7 +111,7 @@ public class RangeTest {
}
@Test
- public void rangeDayOfYearTest(){
+ public void rangeDayOfYearTest() {
DateTime start = DateUtil.parse("2017-01-01");
DateTime end = DateUtil.parse("2017-01-05");
@@ -135,4 +136,39 @@ public class RangeTest {
Assert.assertEquals(DateUtil.parse("2017-01-01"), rangeToList.get(0));
Assert.assertEquals(DateUtil.parse("2017-01-02"), rangeToList.get(1));
}
+
+
+ @Test
+ public void rangeContains() {
+ // 开始区间
+ DateTime start = DateUtil.parse("2017-01-01");
+ DateTime end = DateUtil.parse("2017-01-31");
+ DateRange startRange = DateUtil.range(start, end, DateField.DAY_OF_YEAR);
+ // 结束区间
+ DateTime start1 = DateUtil.parse("2017-01-31");
+ DateTime end1 = DateUtil.parse("2017-02-02");
+ DateRange endRange = DateUtil.range(start1, end1, DateField.DAY_OF_YEAR);
+ // 交集
+ List dateTimes = DateUtil.rangeContains(startRange, endRange);
+ Assert.assertEquals(1, dateTimes.size());
+ Assert.assertEquals(DateUtil.parse("2017-01-31"), dateTimes.get(0));
+ }
+
+ @Test
+ public void rangeNotContains() {
+ // 开始区间
+ DateTime start = DateUtil.parse("2017-01-01");
+ DateTime end = DateUtil.parse("2017-01-30");
+ DateRange startRange = DateUtil.range(start, end, DateField.DAY_OF_YEAR);
+ // 结束区间
+ DateTime start1 = DateUtil.parse("2017-01-01");
+ DateTime end1 = DateUtil.parse("2017-01-31");
+ DateRange endRange = DateUtil.range(start1, end1, DateField.DAY_OF_YEAR);
+ // 差集
+ List dateTimes1 = DateUtil.rangeNotContains(startRange, endRange);
+
+ Assert.assertEquals(1, dateTimes1.size());
+ Assert.assertEquals(DateUtil.parse("2017-01-31"), dateTimes1.get(0));
+ }
+
}
diff --git a/hutool-core/src/test/java/cn/hutool/core/lang/hash/CityHashTest.java b/hutool-core/src/test/java/cn/hutool/core/lang/hash/CityHashTest.java
new file mode 100755
index 000000000..d253ffa2e
--- /dev/null
+++ b/hutool-core/src/test/java/cn/hutool/core/lang/hash/CityHashTest.java
@@ -0,0 +1,36 @@
+package cn.hutool.core.lang.hash;
+
+import cn.hutool.core.util.StrUtil;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class CityHashTest {
+
+ @Test
+ public void hash32Test() {
+ int hv = CityHash.hash32(StrUtil.utf8Bytes("你"));
+ Assert.assertEquals(1290029860, hv);
+
+ hv = CityHash.hash32(StrUtil.utf8Bytes("你好"));
+ Assert.assertEquals(1374181357, hv);
+
+ hv = CityHash.hash32(StrUtil.utf8Bytes("见到你很高兴"));
+ Assert.assertEquals(1475516842, hv);
+ hv = CityHash.hash32(StrUtil.utf8Bytes("我们将通过生成一个大的文件的方式来检验各种方法的执行效率因为这种方式在结束的时候需要执行文件"));
+ Assert.assertEquals(0x51020cae, hv);
+ }
+
+ @Test
+ public void hash64Test() {
+ long hv = CityHash.hash64(StrUtil.utf8Bytes("你"));
+ Assert.assertEquals(-4296898700418225525L, hv);
+
+ hv = CityHash.hash64(StrUtil.utf8Bytes("你好"));
+ Assert.assertEquals(-4294276205456761303L, hv);
+
+ hv = CityHash.hash64(StrUtil.utf8Bytes("见到你很高兴"));
+ Assert.assertEquals(272351505337503793L, hv);
+ hv = CityHash.hash64(StrUtil.utf8Bytes("我们将通过生成一个大的文件的方式来检验各种方法的执行效率因为这种方式在结束的时候需要执行文件"));
+ Assert.assertEquals(-8234735310919228703L, hv);
+ }
+}
diff --git a/hutool-core/src/test/java/cn/hutool/core/lang/hash/MetroHashTest.java b/hutool-core/src/test/java/cn/hutool/core/lang/hash/MetroHashTest.java
new file mode 100644
index 000000000..5577a1bb5
--- /dev/null
+++ b/hutool-core/src/test/java/cn/hutool/core/lang/hash/MetroHashTest.java
@@ -0,0 +1,93 @@
+package cn.hutool.core.lang.hash;
+
+
+import cn.hutool.core.util.CharsetUtil;
+import cn.hutool.core.util.HexUtil;
+import cn.hutool.core.util.RandomUtil;
+import cn.hutool.core.util.StrUtil;
+import org.junit.Assert;
+import org.junit.Ignore;
+import org.junit.Test;
+
+/**
+ * https://gitee.com/dromara/hutool/pulls/532
+ */
+public class MetroHashTest {
+
+ @Test
+ public void testEmpty() {
+ Assert.assertEquals("31290877cceaea29", HexUtil.toHex(MetroHash.hash64(StrUtil.utf8Bytes(""), 0)));
+ }
+
+ @Test
+ public void metroHash64Test() {
+ byte[] str = "我是一段测试123".getBytes(CharsetUtil.CHARSET_UTF_8);
+ final long hash64 = MetroHash.hash64(str);
+ Assert.assertEquals(62920234463891865L, hash64);
+ }
+
+ @Test
+ public void metroHash128Test() {
+ byte[] str = "我是一段测试123".getBytes(CharsetUtil.CHARSET_UTF_8);
+ final long[] hash128 = MetroHash.hash128(str).getLongArray();
+ Assert.assertEquals(4956592424592439349L, hash128[0]);
+ Assert.assertEquals(6301214698325086246L, hash128[1]);
+ }
+
+ /**
+ * 数据量越大 MetroHash 优势越明显，
+ */
+ @Test
+ @Ignore
+ public void bulkHashing64Test() {
+ String[] strArray = getRandomStringArray();
+ long startCity = System.currentTimeMillis();
+ for (String s : strArray) {
+ CityHash.hash64(s.getBytes());
+ }
+ long endCity = System.currentTimeMillis();
+
+ long startMetro = System.currentTimeMillis();
+ for (String s : strArray) {
+ MetroHash.hash64(StrUtil.utf8Bytes(s));
+ }
+ long endMetro = System.currentTimeMillis();
+
+ System.out.println("metroHash =============" + (endMetro - startMetro));
+ System.out.println("cityHash =============" + (endCity - startCity));
+ }
+
+
+ /**
+ * 数据量越大 MetroHash 优势越明显，
+ */
+ @Test
+ @Ignore
+ public void bulkHashing128Test() {
+ String[] strArray = getRandomStringArray();
+ long startCity = System.currentTimeMillis();
+ for (String s : strArray) {
+ CityHash.hash128(s.getBytes());
+ }
+ long endCity = System.currentTimeMillis();
+
+ long startMetro = System.currentTimeMillis();
+ for (String s : strArray) {
+ MetroHash.hash128(StrUtil.utf8Bytes(s));
+ }
+ long endMetro = System.currentTimeMillis();
+
+ System.out.println("metroHash =============" + (endMetro - startMetro));
+ System.out.println("cityHash =============" + (endCity - startCity));
+ }
+
+
+ private static String[] getRandomStringArray() {
+ String[] result = new String[10000000];
+ int index = 0;
+ while (index < 10000000) {
+ result[index++] = RandomUtil.randomString(RandomUtil.randomInt(64));
+ }
+ return result;
+ }
+}
diff --git a/hutool-core/src/test/java/cn/hutool/core/lang/hash/MurMurHashTest.java b/hutool-core/src/test/java/cn/hutool/core/lang/hash/MurMurHashTest.java
new file mode 100755
index 000000000..fcf946b5e
--- /dev/null
+++ b/hutool-core/src/test/java/cn/hutool/core/lang/hash/MurMurHashTest.java
@@ -0,0 +1,36 @@
+package cn.hutool.core.lang.hash;
+
+import cn.hutool.core.util.StrUtil;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class MurMurHashTest {
+
+ @Test
+ public void hash32Test() {
+ int hv = MurmurHash.hash32(StrUtil.utf8Bytes("你"));
+ Assert.assertEquals(222142701, hv);
+
+ hv = MurmurHash.hash32(StrUtil.utf8Bytes("你好"));
+ Assert.assertEquals(1188098267, hv);
+
+ hv = MurmurHash.hash32(StrUtil.utf8Bytes("见到你很高兴"));
+ Assert.assertEquals(-1898490321, hv);
+ hv = MurmurHash.hash32(StrUtil.utf8Bytes("我们将通过生成一个大的文件的方式来检验各种方法的执行效率因为这种方式在结束的时候需要执行文件"));
+ Assert.assertEquals(-1713131054, hv);
+ }
+
+ @Test
+ public void hash64Test() {
+ long hv = MurmurHash.hash64(StrUtil.utf8Bytes("你"));
+ Assert.assertEquals(-1349759534971957051L, hv);
+
+ hv = MurmurHash.hash64(StrUtil.utf8Bytes("你好"));
+ Assert.assertEquals(-7563732748897304996L, hv);
+
+ hv = MurmurHash.hash64(StrUtil.utf8Bytes("见到你很高兴"));
+ Assert.assertEquals(-766658210119995316L, hv);
+ hv = MurmurHash.hash64(StrUtil.utf8Bytes("我们将通过生成一个大的文件的方式来检验各种方法的执行效率因为这种方式在结束的时候需要执行文件"));
+ Assert.assertEquals(-7469283059271653317L, hv);
+ }
+}
diff --git a/hutool-core/src/test/java/cn/hutool/core/net/UrlQueryTest.java b/hutool-core/src/test/java/cn/hutool/core/net/UrlQueryTest.java
index 9338662a5..c50b3c11b 100644
--- a/hutool-core/src/test/java/cn/hutool/core/net/UrlQueryTest.java
+++ b/hutool-core/src/test/java/cn/hutool/core/net/UrlQueryTest.java
@@ -137,4 +137,11 @@ public class UrlQueryTest {
final UrlQuery query = UrlQuery.of(queryStr, null);
Assert.assertEquals(queryStr, query.toString());
}
+
+ @Test
+ public void parsePercentTest2(){
+ String queryStr = "signature=%2Br1ekUCGjXiu50Y%2Bk0MO4ovulK8%3D";
+ final UrlQuery query = UrlQuery.of(queryStr, null);
+ Assert.assertEquals(queryStr, query.toString());
+ }
}
diff --git a/hutool-core/src/test/java/cn/hutool/core/text/AntPathMatcherTest.java b/hutool-core/src/test/java/cn/hutool/core/text/AntPathMatcherTest.java
new file mode 100755
index 000000000..3b1db3b67
--- /dev/null
+++ b/hutool-core/src/test/java/cn/hutool/core/text/AntPathMatcherTest.java
@@ -0,0 +1,115 @@
+package cn.hutool.core.text;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.HashMap;
+
+public class AntPathMatcherTest {
+
+ @Test
+ public void matchesTest() {
+ AntPathMatcher antPathMatcher = new AntPathMatcher();
+ boolean matched = antPathMatcher.match("/api/org/organization/{orgId}", "/api/org/organization/999");
+ Assert.assertTrue(matched);
+ }
+
+ @Test
+ public void matchesTest2() {
+ AntPathMatcher antPathMatcher = new AntPathMatcher();
+
+ String pattern = "/**/*.xml*";
+ String path = "/WEB-INF/web.xml";
+ boolean isMatched = antPathMatcher.match(pattern, path);
+ Assert.assertTrue(isMatched);
+
+ pattern = "org/codelabor/*/**/*Service";
+ path = "org/codelabor/example/HelloWorldService";
+ isMatched = antPathMatcher.match(pattern, path);
+ Assert.assertTrue(isMatched);
+
+ pattern = "org/codelabor/*/**/*Service?";
+ path = "org/codelabor/example/HelloWorldServices";
+ isMatched = antPathMatcher.match(pattern, path);
+ Assert.assertTrue(isMatched);
+ }
+
+ @Test
+ public void matchesTest3(){
+ AntPathMatcher pathMatcher = new AntPathMatcher();
+ pathMatcher.setCachePatterns(true);
+ pathMatcher.setCaseSensitive(true);
+ pathMatcher.setPathSeparator("/");
+ pathMatcher.setTrimTokens(true);
+
+ Assert.assertTrue(pathMatcher.match("a", "a"));
+ Assert.assertTrue(pathMatcher.match("a*", "ab"));
+ Assert.assertTrue(pathMatcher.match("a*/**/a", "ab/asdsa/a"));
+ Assert.assertTrue(pathMatcher.match("a*/**/a", "ab/asdsa/asdasd/a"));
+
+ Assert.assertTrue(pathMatcher.match("*", "a"));
+ Assert.assertTrue(pathMatcher.match("*/*", "a/a"));
+ }
+
+ /**
+ * AntPathMatcher默认路径分隔符为“/”，而在匹配文件路径时，需要注意Windows下路径分隔符为“\”，Linux下为“/”。靠谱写法如下两种方式：
+ * AntPathMatcher matcher = new AntPathMatcher(File.separator);
+ * AntPathMatcher matcher = new AntPathMatcher(System.getProperty("file.separator"));
+ */
+ @Test
+ public void matchesTest4() {
+ AntPathMatcher pathMatcher = new AntPathMatcher();
+
+ // 精确匹配
+ Assert.assertTrue(pathMatcher.match("/test", "/test"));
+ Assert.assertFalse(pathMatcher.match("test", "/test"));
+
+ //测试通配符?
+ Assert.assertTrue(pathMatcher.match("t?st", "test"));
+ Assert.assertTrue(pathMatcher.match("te??", "test"));
+ Assert.assertFalse(pathMatcher.match("tes?", "tes"));
+ Assert.assertFalse(pathMatcher.match("tes?", "testt"));
+
+ //测试通配符*
+ Assert.assertTrue(pathMatcher.match("*", "test"));
+ Assert.assertTrue(pathMatcher.match("test*", "test"));
+ Assert.assertTrue(pathMatcher.match("test/*", "test/Test"));
+ Assert.assertTrue(pathMatcher.match("*.*", "test."));
+ Assert.assertTrue(pathMatcher.match("*.*", "test.test.test"));
+ Assert.assertFalse(pathMatcher.match("test*", "test/")); //注意这里是false 因为路径不能用*匹配
+ Assert.assertFalse(pathMatcher.match("test*", "test/t")); //这同理
+ Assert.assertFalse(pathMatcher.match("test*aaa", "testblaaab")); //这个是false 因为最后一个b无法匹配了 前面都是能匹配成功的
+
+ //测试通配符** 匹配多级URL
+ Assert.assertTrue(pathMatcher.match("/*/**", "/testing/testing"));
+ Assert.assertTrue(pathMatcher.match("/**/*", "/testing/testing"));
+ Assert.assertTrue(pathMatcher.match("/bla/**/bla", "/bla/testing/testing/bla/bla")); //这里也是true哦
+ Assert.assertFalse(pathMatcher.match("/bla*bla/test", "/blaXXXbl/test"));
+
+ Assert.assertFalse(pathMatcher.match("/????", "/bala/bla"));
+ Assert.assertFalse(pathMatcher.match("/**/*bla", "/bla/bla/bla/bbb"));
+
+ Assert.assertTrue(pathMatcher.match("/*bla*/**/bla/**", "/XXXblaXXXX/testing/testing/bla/testing/testing/"));
+ Assert.assertTrue(pathMatcher.match("/*bla*/**/bla/*", "/XXXblaXXXX/testing/testing/bla/testing"));
+ Assert.assertTrue(pathMatcher.match("/*bla*/**/bla/**", "/XXXblaXXXX/testing/testing/bla/testing/testing"));
+ Assert.assertTrue(pathMatcher.match("/*bla*/**/bla/**", "/XXXblaXXXX/testing/testing/bla/testing/testing.jpg"));
+ Assert.assertTrue(pathMatcher.match("/foo/bar/**", "/foo/bar"));
+
+ //这个需要特别注意：{}里面的相当于Spring MVC里接受一个参数一样，所以任何东西都会匹配的
+ Assert.assertTrue(pathMatcher.match("/{bla}.*", "/testing.html"));
+ Assert.assertFalse(pathMatcher.match("/{bla}.htm", "/testing.html")); //这样就是false了
+ }
+
+ /**
+ * 测试 URI 模板变量提取
+ */
+ @Test
+ public void testExtractUriTemplateVariables() {
+ AntPathMatcher antPathMatcher = new AntPathMatcher();
+ HashMap map = (HashMap) antPathMatcher.extractUriTemplateVariables("/api/org/organization/{orgId}",
+ "/api/org" +
+ "/organization" +
+ "/999");
+ Assert.assertEquals(1, map.size());
+ }
+}
diff --git a/hutool-core/src/test/java/cn/hutool/core/text/StrJoinerTest.java b/hutool-core/src/test/java/cn/hutool/core/text/StrJoinerTest.java
index 2ce2eee8c..f9a2d4c30 100644
--- a/hutool-core/src/test/java/cn/hutool/core/text/StrJoinerTest.java
+++ b/hutool-core/src/test/java/cn/hutool/core/text/StrJoinerTest.java
@@ -78,4 +78,25 @@ public class StrJoinerTest {
.append("3");
Assert.assertEquals("[1],[2],[3]", append.toString());
}
+
+ @Test
+ public void lengthTest(){
+ StrJoiner joiner = StrJoiner.of(",", "[", "]");
+ Assert.assertEquals(joiner.toString().length(), joiner.length());
+
+ joiner.append("123");
+ Assert.assertEquals(joiner.toString().length(), joiner.length());
+ }
+
+ @Test
+ public void mergeTest(){
+ StrJoiner joiner1 = StrJoiner.of(",", "[", "]");
+ joiner1.append("123");
+ StrJoiner joiner2 = StrJoiner.of(",", "[", "]");
+ joiner1.append("456");
+ joiner1.append("789");
+
+ final StrJoiner merge = joiner1.merge(joiner2);
+ Assert.assertEquals("[123,456,789]", merge.toString());
+ }
}
diff --git a/hutool-core/src/test/java/cn/hutool/core/text/csv/CsvParserTest.java b/hutool-core/src/test/java/cn/hutool/core/text/csv/CsvParserTest.java
index e1a27b206..e8fc851e8 100644
--- a/hutool-core/src/test/java/cn/hutool/core/text/csv/CsvParserTest.java
+++ b/hutool-core/src/test/java/cn/hutool/core/text/csv/CsvParserTest.java
@@ -8,7 +8,7 @@ import org.junit.Test;
import java.io.StringReader;
public class CsvParserTest {
-
+
@Test
public void parseTest1() {
StringReader reader = StrUtil.getReader("aaa,b\"bba\",ccc");
@@ -18,7 +18,7 @@ public class CsvParserTest {
Assert.assertEquals("b\"bba\"", row.getRawList().get(1));
IoUtil.close(parser);
}
-
+
@Test
public void parseTest2() {
StringReader reader = StrUtil.getReader("aaa,\"bba\"bbb,ccc");
@@ -28,7 +28,7 @@ public class CsvParserTest {
Assert.assertEquals("\"bba\"bbb", row.getRawList().get(1));
IoUtil.close(parser);
}
-
+
@Test
public void parseTest3() {
StringReader reader = StrUtil.getReader("aaa,\"bba\",ccc");
@@ -38,7 +38,7 @@ public class CsvParserTest {
Assert.assertEquals("bba", row.getRawList().get(1));
IoUtil.close(parser);
}
-
+
@Test
public void parseTest4() {
StringReader reader = StrUtil.getReader("aaa,\"\",ccc");
@@ -48,4 +48,16 @@ public class CsvParserTest {
Assert.assertEquals("", row.getRawList().get(1));
IoUtil.close(parser);
}
+
+ @Test
+ public void parseEscapeTest(){
+ // https://datatracker.ietf.org/doc/html/rfc4180#section-2
+ // 第七条规则
+ StringReader reader = StrUtil.getReader("\"b\"\"bb\"");
+ CsvParser parser = new CsvParser(reader, null);
+ CsvRow row = parser.nextRow();
+ Assert.assertNotNull(row);
+ Assert.assertEquals(1, row.size());
+ Assert.assertEquals("b\"bb", row.get(0));
+ }
}
diff --git a/hutool-core/src/test/java/cn/hutool/core/util/ArrayUtilTest.java b/hutool-core/src/test/java/cn/hutool/core/util/ArrayUtilTest.java
index 5a0d71ca8..3ba18becf 100644
--- a/hutool-core/src/test/java/cn/hutool/core/util/ArrayUtilTest.java
+++ b/hutool-core/src/test/java/cn/hutool/core/util/ArrayUtilTest.java
@@ -459,4 +459,11 @@ public class ArrayUtilTest {
Assert.assertEquals(3, arrayAfterSplit.length);
Assert.assertEquals(24, arrayAfterSplit[2].length);
}
+
+ @Test
+ public void getTest(){
+ String[] a = {"a", "b", "c"};
+ final Object o = ArrayUtil.get(a, -1);
+ Assert.assertEquals("c", o);
+ }
}
diff --git a/hutool-core/src/test/java/cn/hutool/core/util/ByteUtilTest.java b/hutool-core/src/test/java/cn/hutool/core/util/ByteUtilTest.java
index b68b95ce9..ba7121f53 100644
--- a/hutool-core/src/test/java/cn/hutool/core/util/ByteUtilTest.java
+++ b/hutool-core/src/test/java/cn/hutool/core/util/ByteUtilTest.java
@@ -10,9 +10,16 @@ public class ByteUtilTest {
@Test
public void intAndBytesLittleEndianTest() {
// 测试 int 转小端序 byte 数组
- int int1 = RandomUtil.randomInt();
+ int int1 = RandomUtil.randomInt((Integer.MAX_VALUE));
+
+ ByteBuffer buffer = ByteBuffer.allocate(Integer.BYTES);
+ buffer.order(ByteOrder.LITTLE_ENDIAN);
+ buffer.putInt(int1);
+ byte[] bytesIntFromBuffer = buffer.array();
byte[] bytesInt = ByteUtil.intToBytes(int1, ByteOrder.LITTLE_ENDIAN);
+ Assert.assertArrayEquals(bytesIntFromBuffer, bytesInt);
+
int int2 = ByteUtil.bytesToInt(bytesInt, ByteOrder.LITTLE_ENDIAN);
Assert.assertEquals(int1, int2);
@@ -28,8 +35,14 @@ public class ByteUtilTest {
@Test
public void intAndBytesBigEndianTest() {
// 测试 int 转大端序 byte 数组
- int int2 = RandomUtil.randomInt();
+ int int2 = RandomUtil.randomInt(Integer.MAX_VALUE);
+
+ ByteBuffer buffer = ByteBuffer.allocate(Integer.BYTES);
+ buffer.putInt(int2);
+ byte[] bytesIntFromBuffer = buffer.array();
+
byte[] bytesInt = ByteUtil.intToBytes(int2, ByteOrder.BIG_ENDIAN);
+ Assert.assertArrayEquals(bytesIntFromBuffer, bytesInt);
// 测试大端序 byte 数组转 int
int int3 = ByteUtil.bytesToInt(bytesInt, ByteOrder.BIG_ENDIAN);
@@ -39,9 +52,16 @@ public class ByteUtilTest {
@Test
public void longAndBytesLittleEndianTest() {
// 测试 long 转 byte 数组
- long long1 = 2223;
+ long long1 = RandomUtil.randomLong(Long.MAX_VALUE);
+
+ ByteBuffer buffer = ByteBuffer.allocate(Long.BYTES);
+ buffer.order(ByteOrder.LITTLE_ENDIAN);
+ buffer.putLong(long1);
+ byte[] bytesLongFromBuffer = buffer.array();
byte[] bytesLong = ByteUtil.longToBytes(long1, ByteOrder.LITTLE_ENDIAN);
+ Assert.assertArrayEquals(bytesLongFromBuffer, bytesLong);
+
long long2 = ByteUtil.bytesToLong(bytesLong, ByteOrder.LITTLE_ENDIAN);
Assert.assertEquals(long1, long2);
@@ -57,11 +77,16 @@ public class ByteUtilTest {
@Test
public void longAndBytesBigEndianTest() {
// 测试大端序 long 转 byte 数组
- long long1 = 2223;
+ long long1 = RandomUtil.randomLong(Long.MAX_VALUE);
+
+ ByteBuffer buffer = ByteBuffer.allocate(Long.BYTES);
+ buffer.putLong(long1);
+ byte[] bytesLongFromBuffer = buffer.array();
byte[] bytesLong = ByteUtil.longToBytes(long1, ByteOrder.BIG_ENDIAN);
- long long2 = ByteUtil.bytesToLong(bytesLong, ByteOrder.BIG_ENDIAN);
+ Assert.assertArrayEquals(bytesLongFromBuffer, bytesLong);
+ long long2 = ByteUtil.bytesToLong(bytesLong, ByteOrder.BIG_ENDIAN);
Assert.assertEquals(long1, long2);
}
diff --git a/hutool-core/src/test/java/cn/hutool/core/util/CoordinateUtilTest.java b/hutool-core/src/test/java/cn/hutool/core/util/CoordinateUtilTest.java
index a2f141e39..b3c081546 100644
--- a/hutool-core/src/test/java/cn/hutool/core/util/CoordinateUtilTest.java
+++ b/hutool-core/src/test/java/cn/hutool/core/util/CoordinateUtilTest.java
@@ -11,37 +11,46 @@ import org.junit.Test;
*/
public class CoordinateUtilTest {
+ @Test
+ public void wgs84ToGcj02Test(){
+ final CoordinateUtil.Coordinate coordinate = CoordinateUtil.wgs84ToGcj02(116.404, 39.915);
+ Assert.assertEquals(116.41033392216508D, coordinate.getLng(), 15);
+ Assert.assertEquals(39.91640428150164D, coordinate.getLat(), 15);
+ }
+
+ @Test
+ public void gcj02ToWgs84Test(){
+ final CoordinateUtil.Coordinate coordinate = CoordinateUtil.gcj02ToWgs84(116.404, 39.915);
+ Assert.assertEquals(116.39766607783491D, coordinate.getLng(), 15);
+ Assert.assertEquals(39.91359571849836D, coordinate.getLat(), 15);
+ }
+
+ @Test
+ public void wgs84toBd09Test(){
+ final CoordinateUtil.Coordinate coordinate = CoordinateUtil.wgs84ToBd09(116.404, 39.915);
+ Assert.assertEquals(116.41671695444782D, coordinate.getLng(), 15);
+ Assert.assertEquals(39.922698713521726D, coordinate.getLat(), 15);
+ }
+
+ @Test
+ public void bd09toWgs84Test(){
+ final CoordinateUtil.Coordinate coordinate = CoordinateUtil.bd09toWgs84(116.404, 39.915);
+ Assert.assertEquals(116.39129143419822D, coordinate.getLng(), 15);
+ Assert.assertEquals(39.907253214522164D, coordinate.getLat(), 15);
+ }
+
@Test
public void gcj02ToBd09Test() {
- final CoordinateUtil.Coordinate gcj02 = CoordinateUtil.gcj02ToBd09(116.404, 39.915);
- Assert.assertEquals(116.41036949371029D, gcj02.getLng(), 15);
- Assert.assertEquals(39.92133699351021D, gcj02.getLat(), 15);
+ final CoordinateUtil.Coordinate coordinate = CoordinateUtil.gcj02ToBd09(116.404, 39.915);
+ Assert.assertEquals(116.41036949371029D, coordinate.getLng(), 15);
+ Assert.assertEquals(39.92133699351022D, coordinate.getLat(), 15);
}
@Test
public void bd09toGcj02Test(){
- final CoordinateUtil.Coordinate gcj02 = CoordinateUtil.bd09ToGcj02(116.404, 39.915);
- Assert.assertEquals(116.39762729119315D, gcj02.getLng(), 15);
- Assert.assertEquals(39.90865673957631D, gcj02.getLat(), 15);
- }
-
- @Test
- public void gcj02ToWgs84(){
- final CoordinateUtil.Coordinate gcj02 = CoordinateUtil.wgs84ToGcj02(116.404, 39.915);
- Assert.assertEquals(116.39775550083061D, gcj02.getLng(), 15);
- Assert.assertEquals(39.91359571849836D, gcj02.getLat(), 15);
- }
-
- @Test
- public void wgs84ToGcj02Test(){
- final CoordinateUtil.Coordinate gcj02 = CoordinateUtil.wgs84ToGcj02(116.404, 39.915);
- Assert.assertEquals(116.41024449916938D, gcj02.getLng(), 15);
- Assert.assertEquals(39.91640428150164D, gcj02.getLat(), 15);
- }
-
- @Test
- public void wgs84toBd09(){
-
+ final CoordinateUtil.Coordinate coordinate = CoordinateUtil.bd09ToGcj02(116.404, 39.915);
+ Assert.assertEquals(116.39762729119315D, coordinate.getLng(), 15);
+ Assert.assertEquals(39.90865673957631D, coordinate.getLat(), 15);
}
}
diff --git a/hutool-core/src/test/java/cn/hutool/core/util/CreditCodeUtilTest.java b/hutool-core/src/test/java/cn/hutool/core/util/CreditCodeUtilTest.java
index 0d5dcd378..9263feb66 100644
--- a/hutool-core/src/test/java/cn/hutool/core/util/CreditCodeUtilTest.java
+++ b/hutool-core/src/test/java/cn/hutool/core/util/CreditCodeUtilTest.java
@@ -17,9 +17,17 @@ public class CreditCodeUtilTest {
Assert.assertTrue(CreditCodeUtil.isCreditCode(testCreditCode));
}
+ @Test
+ public void isCreditCode2() {
+ // 由于早期部分试点地区推行 法人和其他组织统一社会信用代码 较早，会存在部分代码不符合国家标准的情况。
+ // 见：https://github.com/bluesky335/IDCheck
+ String testCreditCode = "91350211M00013FA1N";
+ Assert.assertFalse(CreditCodeUtil.isCreditCode(testCreditCode));
+ }
+
@Test
public void randomCreditCode() {
final String s = CreditCodeUtil.randomCreditCode();
Assert.assertTrue(CreditCodeUtil.isCreditCode(s));
}
-}
\ No newline at end of file
+}
diff --git a/hutool-core/src/test/java/cn/hutool/core/util/ReflectUtilTest.java b/hutool-core/src/test/java/cn/hutool/core/util/ReflectUtilTest.java
index 70f6dd6e2..9a90c8fe3 100644
--- a/hutool-core/src/test/java/cn/hutool/core/util/ReflectUtilTest.java
+++ b/hutool-core/src/test/java/cn/hutool/core/util/ReflectUtilTest.java
@@ -1,8 +1,13 @@
package cn.hutool.core.util;
+import cn.hutool.core.date.DateUtil;
+import cn.hutool.core.date.TimeInterval;
+import cn.hutool.core.lang.Console;
import cn.hutool.core.lang.test.bean.ExamInfoDict;
import cn.hutool.core.util.ClassUtilTest.TestSubClass;
+import lombok.Data;
import org.junit.Assert;
+import org.junit.Ignore;
import org.junit.Test;
import java.lang.reflect.Field;
@@ -91,33 +96,77 @@ public class ReflectUtilTest {
@Test
public void noneStaticInnerClassTest() {
- final TestAClass testAClass = ReflectUtil.newInstanceIfPossible(TestAClass.class);
+ final NoneStaticClass testAClass = ReflectUtil.newInstanceIfPossible(NoneStaticClass.class);
Assert.assertNotNull(testAClass);
Assert.assertEquals(2, testAClass.getA());
}
+ @Data
static class TestClass {
private int a;
-
- public int getA() {
- return a;
- }
-
- public void setA(int a) {
- this.a = a;
- }
}
+ @Data
@SuppressWarnings("InnerClassMayBeStatic")
- class TestAClass {
+ class NoneStaticClass {
private int a = 2;
+ }
- public int getA() {
- return a;
+ @Test
+ @Ignore
+ public void getMethodBenchTest(){
+ // 预热
+ getMethod(TestBenchClass.class, false, "getH");
+
+ final TimeInterval timer = DateUtil.timer();
+ timer.start();
+ for (int i = 0; i < 100000000; i++) {
+ ReflectUtil.getMethod(TestBenchClass.class, false, "getH");
+ }
+ Console.log(timer.interval());
+
+ timer.restart();
+ for (int i = 0; i < 100000000; i++) {
+ getMethod(TestBenchClass.class, false, "getH");
+ }
+ Console.log(timer.interval());
+ }
+
+ @Data
+ static class TestBenchClass {
+ private int a;
+ private String b;
+ private String c;
+ private String d;
+ private String e;
+ private String f;
+ private String g;
+ private String h;
+ private String i;
+ private String j;
+ private String k;
+ private String l;
+ private String m;
+ private String n;
+ }
+
+ public static Method getMethod(Class clazz, boolean ignoreCase, String methodName, Class... paramTypes) throws SecurityException {
+ if (null == clazz || StrUtil.isBlank(methodName)) {
+ return null;
}
- public void setA(int a) {
- this.a = a;
+ Method res = null;
+ final Method[] methods = ReflectUtil.getMethods(clazz);
+ if (ArrayUtil.isNotEmpty(methods)) {
+ for (Method method : methods) {
+ if (StrUtil.equals(methodName, method.getName(), ignoreCase)
+ && ClassUtil.isAllAssignableFrom(method.getParameterTypes(), paramTypes)
+ && (res == null
+ || res.getReturnType().isAssignableFrom(method.getReturnType()))) {
+ res = method;
+ }
+ }
}
+ return res;
}
}
diff --git a/hutool-core/src/test/java/cn/hutool/core/util/ZipUtilTest.java b/hutool-core/src/test/java/cn/hutool/core/util/ZipUtilTest.java
index 309baddf7..afbc21754 100644
--- a/hutool-core/src/test/java/cn/hutool/core/util/ZipUtilTest.java
+++ b/hutool-core/src/test/java/cn/hutool/core/util/ZipUtilTest.java
@@ -186,4 +186,13 @@ public class ZipUtilTest {
ZipUtil.zip(out, new String[]{"sm1_alias.txt"},
new InputStream[]{FileUtil.getInputStream("d:/test/sm4_1.txt")});
}
+
+ @Test
+ @Ignore
+ public void zipMultiFileTest(){
+ File[] dd={FileUtil.file("d:\\test\\qr_a.jpg")
+ ,FileUtil.file("d:\\test\\qr_b.jpg")};
+
+ ZipUtil.zip(FileUtil.file("d:\\test\\qr.zip"),false,dd);
+ }
}
diff --git a/hutool-cron/pom.xml b/hutool-cron/pom.xml
index 7f6b31ad6..7e88dc48d 100644
--- a/hutool-cron/pom.xml
+++ b/hutool-cron/pom.xml
@@ -9,7 +9,7 @@
cn.hutool
hutool-parent
- 5.7.21-SNAPSHOT
+ 5.7.22-SNAPSHOT
hutool-cron
diff --git a/hutool-cron/src/main/java/cn/hutool/cron/pattern/matcher/DayOfMonthValueMatcher.java b/hutool-cron/src/main/java/cn/hutool/cron/pattern/matcher/DayOfMonthValueMatcher.java
index 865838c25..d92a436df 100644
--- a/hutool-cron/src/main/java/cn/hutool/cron/pattern/matcher/DayOfMonthValueMatcher.java
+++ b/hutool-cron/src/main/java/cn/hutool/cron/pattern/matcher/DayOfMonthValueMatcher.java
@@ -12,8 +12,6 @@ import java.util.List;
*/
public class DayOfMonthValueMatcher extends BoolArrayValueMatcher {
- private static final int[] LAST_DAYS = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
-
/**
* 构造
*
diff --git a/hutool-crypto/pom.xml b/hutool-crypto/pom.xml
index 2249e5391..15a2bdca3 100644
--- a/hutool-crypto/pom.xml
+++ b/hutool-crypto/pom.xml
@@ -9,7 +9,7 @@
cn.hutool
hutool-parent
- 5.7.21-SNAPSHOT
+ 5.7.22-SNAPSHOT
hutool-crypto
diff --git a/hutool-crypto/src/main/java/cn/hutool/crypto/KeyUtil.java b/hutool-crypto/src/main/java/cn/hutool/crypto/KeyUtil.java
index 90ef70540..518f09917 100644
--- a/hutool-crypto/src/main/java/cn/hutool/crypto/KeyUtil.java
+++ b/hutool-crypto/src/main/java/cn/hutool/crypto/KeyUtil.java
@@ -1,5 +1,6 @@
package cn.hutool.crypto;
+import cn.hutool.core.codec.Base64;
import cn.hutool.core.io.FileUtil;
import cn.hutool.core.io.IoUtil;
import cn.hutool.core.lang.Assert;
@@ -22,6 +23,7 @@ import java.io.InputStream;
import java.math.BigInteger;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
+import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
@@ -988,4 +990,14 @@ public class KeyUtil {
throw new CryptoException(e);
}
}
+
+ /**
+ * 将密钥编码为Base64格式
+ * @param key 密钥
+ * @return Base64格式密钥
+ * @since 5.7.22
+ */
+ public static String toBase64(Key key){
+ return Base64.encode(key.getEncoded());
+ }
}
diff --git a/hutool-crypto/src/main/java/cn/hutool/crypto/asymmetric/SM2.java b/hutool-crypto/src/main/java/cn/hutool/crypto/asymmetric/SM2.java
index 553b9dfdb..d84f99d5a 100644
--- a/hutool-crypto/src/main/java/cn/hutool/crypto/asymmetric/SM2.java
+++ b/hutool-crypto/src/main/java/cn/hutool/crypto/asymmetric/SM2.java
@@ -20,6 +20,7 @@ import org.bouncycastle.crypto.signers.PlainDSAEncoding;
import org.bouncycastle.crypto.signers.SM2Signer;
import org.bouncycastle.crypto.signers.StandardDSAEncoding;
import org.bouncycastle.util.BigIntegers;
+import org.bouncycastle.util.encoders.Hex;
import java.math.BigInteger;
import java.security.PrivateKey;
@@ -521,7 +522,7 @@ public class SM2 extends AbstractAsymmetricCrypto {
* @since 5.5.9
*/
public byte[] getD() {
- return BigIntegers.asUnsignedByteArray(getDBigInteger());
+ return BigIntegers.asUnsignedByteArray(32,getDBigInteger());
}
/**
@@ -531,7 +532,7 @@ public class SM2 extends AbstractAsymmetricCrypto {
* @since 5.7.17
*/
public String getDHex() {
- return String.format("%064x", new BigInteger(1, getD()));
+ return new String(Hex.encode(getD()));
}
/**
diff --git a/hutool-crypto/src/test/java/cn/hutool/crypto/test/KeyUtilTest.java b/hutool-crypto/src/test/java/cn/hutool/crypto/test/KeyUtilTest.java
index 2cd71e794..576a85cf8 100644
--- a/hutool-crypto/src/test/java/cn/hutool/crypto/test/KeyUtilTest.java
+++ b/hutool-crypto/src/test/java/cn/hutool/crypto/test/KeyUtilTest.java
@@ -58,4 +58,11 @@ public class KeyUtilTest {
final PrivateKey privateKey = KeyUtil.generatePrivateKey("DH", privateKeyBytes);
Assert.assertEquals(dh.getPrivate(), privateKey);
}
+
+ @Test
+ public void generateSm4KeyTest(){
+ // https://github.com/dromara/hutool/issues/2150
+ Assert.assertEquals(16, KeyUtil.generateKey("sm4").getEncoded().length);
+ Assert.assertEquals(32, KeyUtil.generateKey("sm4", 256).getEncoded().length);
+ }
}
diff --git a/hutool-db/pom.xml b/hutool-db/pom.xml
index 4785e323b..fdffcbe3a 100644
--- a/hutool-db/pom.xml
+++ b/hutool-db/pom.xml
@@ -9,7 +9,7 @@
cn.hutool
hutool-parent
- 5.7.21-SNAPSHOT
+ 5.7.22-SNAPSHOT
hutool-db
@@ -103,6 +103,14 @@
${mongo.version}
true
+
redis.clients
@@ -149,19 +157,19 @@
org.postgresql
postgresql
- 42.3.2
+ 42.3.3
test
com.microsoft.sqlserver
mssql-jdbc
- 9.4.1.jre8
+ 10.2.0.jre8
test
org.slf4j
slf4j-simple
- 1.7.32
+ 1.7.36
test
diff --git a/hutool-db/src/main/java/cn/hutool/db/SqlConnRunner.java b/hutool-db/src/main/java/cn/hutool/db/SqlConnRunner.java
index 28f1bfc2b..886984e1f 100644
--- a/hutool-db/src/main/java/cn/hutool/db/SqlConnRunner.java
+++ b/hutool-db/src/main/java/cn/hutool/db/SqlConnRunner.java
@@ -73,7 +73,7 @@ public class SqlConnRunner extends DialectRunner {
/**
* 构造
*
- * @param driverClassName 驱动类名，，用于识别方言
+ * @param driverClassName 驱动类名，用于识别方言
*/
public SqlConnRunner(String driverClassName) {
super(driverClassName);
diff --git a/hutool-db/src/main/java/cn/hutool/db/ds/c3p0/C3p0DSFactory.java b/hutool-db/src/main/java/cn/hutool/db/ds/c3p0/C3p0DSFactory.java
index ecc7a4371..4f11a56bc 100644
--- a/hutool-db/src/main/java/cn/hutool/db/ds/c3p0/C3p0DSFactory.java
+++ b/hutool-db/src/main/java/cn/hutool/db/ds/c3p0/C3p0DSFactory.java
@@ -1,5 +1,6 @@
package cn.hutool.db.ds.c3p0;
+import cn.hutool.core.map.MapUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.db.DbRuntimeException;
import cn.hutool.db.ds.AbstractDSFactory;
@@ -12,13 +13,13 @@ import java.beans.PropertyVetoException;
/**
* Druid数据源工厂类
- *
+ *
* @author Looly
*
*/
public class C3p0DSFactory extends AbstractDSFactory {
private static final long serialVersionUID = -6090788225842047281L;
-
+
public static final String DS_NAME = "C3P0";
/**
@@ -30,24 +31,16 @@ public class C3p0DSFactory extends AbstractDSFactory {
/**
* 构造
- *
+ *
* @param setting 配置
*/
public C3p0DSFactory(Setting setting) {
super(DS_NAME, ComboPooledDataSource.class, setting);
}
-
+
@Override
protected DataSource createDataSource(String jdbcUrl, String driver, String user, String pass, Setting poolSetting) {
final ComboPooledDataSource ds = new ComboPooledDataSource();
- ds.setJdbcUrl(jdbcUrl);
- try {
- ds.setDriverClass(driver);
- } catch (PropertyVetoException e) {
- throw new DbRuntimeException(e);
- }
- ds.setUser(user);
- ds.setPassword(pass);
// remarks等特殊配置，since 5.3.8
final Props connProps = new Props();
@@ -58,7 +51,18 @@ public class C3p0DSFactory extends AbstractDSFactory {
connProps.setProperty(key, connValue);
}
}
- ds.setProperties(connProps);
+ if(MapUtil.isNotEmpty(connProps)){
+ ds.setProperties(connProps);
+ }
+
+ ds.setJdbcUrl(jdbcUrl);
+ try {
+ ds.setDriverClass(driver);
+ } catch (PropertyVetoException e) {
+ throw new DbRuntimeException(e);
+ }
+ ds.setUser(user);
+ ds.setPassword(pass);
// 注入属性
poolSetting.toBean(ds);
diff --git a/hutool-db/src/main/java/cn/hutool/db/meta/MetaUtil.java b/hutool-db/src/main/java/cn/hutool/db/meta/MetaUtil.java
index 04854a10e..caea07f65 100644
--- a/hutool-db/src/main/java/cn/hutool/db/meta/MetaUtil.java
+++ b/hutool-db/src/main/java/cn/hutool/db/meta/MetaUtil.java
@@ -185,15 +185,38 @@ public class MetaUtil {
* @return Table对象
*/
public static Table getTableMeta(DataSource ds, String tableName) {
+ return getTableMeta(ds, null, null, tableName);
+ }
+
+ /**
+ * 获得表的元信息
+ * 注意如果需要获取注释，某些数据库如MySQL，需要在配置中添加:
+ *
+ * remarks = true
+ * useInformationSchema = true
+ *
+ *
+ * @param ds 数据源
+ * @param tableName 表名
+ * @param catalog catalog name，{@code null}表示自动获取，见：{@link #getCataLog(Connection)}
+ * @param schema a schema name pattern，{@code null}表示自动获取，见：{@link #getSchema(Connection)}
+ * @return Table对象
+ * @since 5.7.22
+ */
+ public static Table getTableMeta(DataSource ds, String catalog, String schema, String tableName) {
final Table table = Table.create(tableName);
Connection conn = null;
try {
conn = ds.getConnection();
// catalog和schema获取失败默认使用null代替
- final String catalog = getCataLog(conn);
+ if(null == catalog){
+ catalog = getCataLog(conn);
+ }
table.setCatalog(catalog);
- final String schema = getSchema(conn);
+ if(null == schema){
+ schema = getSchema(conn);
+ }
table.setSchema(schema);
final DatabaseMetaData metaData = conn.getMetaData();
diff --git a/hutool-db/src/test/java/cn/hutool/db/DsTest.java b/hutool-db/src/test/java/cn/hutool/db/DsTest.java
index 1d89ca6b1..cec55a376 100644
--- a/hutool-db/src/test/java/cn/hutool/db/DsTest.java
+++ b/hutool-db/src/test/java/cn/hutool/db/DsTest.java
@@ -2,6 +2,7 @@ package cn.hutool.db;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.db.ds.DSFactory;
+import cn.hutool.db.ds.DataSourceWrapper;
import cn.hutool.db.ds.bee.BeeDSFactory;
import cn.hutool.db.ds.c3p0.C3p0DSFactory;
import cn.hutool.db.ds.dbcp.DbcpDSFactory;
@@ -9,6 +10,7 @@ import cn.hutool.db.ds.druid.DruidDSFactory;
import cn.hutool.db.ds.hikari.HikariDSFactory;
import cn.hutool.db.ds.pooled.PooledDSFactory;
import cn.hutool.db.ds.tomcat.TomcatDSFactory;
+import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.junit.Assert;
import org.junit.Test;
@@ -87,6 +89,15 @@ public class DsTest {
Assert.assertTrue(CollUtil.isNotEmpty(all));
}
+ @Test
+ public void c3p0DsUserAndPassTest() {
+ // https://gitee.com/dromara/hutool/issues/I4T7XZ
+ DSFactory.setCurrentDSFactory(new C3p0DSFactory());
+ ComboPooledDataSource ds = (ComboPooledDataSource) ((DataSourceWrapper) DSFactory.get("mysql")).getRaw();
+ Assert.assertEquals("root", ds.getUser());
+ Assert.assertEquals("123456", ds.getPassword());
+ }
+
@Test
public void hutoolPoolTest() throws SQLException {
DSFactory.setCurrentDSFactory(new PooledDSFactory());
diff --git a/hutool-dfa/pom.xml b/hutool-dfa/pom.xml
index 3e05431b2..a5a11cadd 100644
--- a/hutool-dfa/pom.xml
+++ b/hutool-dfa/pom.xml
@@ -9,7 +9,7 @@
cn.hutool
hutool-parent
- 5.7.21-SNAPSHOT
+ 5.7.22-SNAPSHOT
hutool-dfa
diff --git a/hutool-extra/pom.xml b/hutool-extra/pom.xml
index 2f4de10b6..2b7542c34 100644
--- a/hutool-extra/pom.xml
+++ b/hutool-extra/pom.xml
@@ -9,7 +9,7 @@
cn.hutool
hutool-parent
- 5.7.21-SNAPSHOT
+ 5.7.22-SNAPSHOT
hutool-extra
@@ -19,7 +19,7 @@
2.3
- 3.9.3.RELEASE
+ 3.10.0.RELEASE
1.4.1
2.3.31
4.9.16
diff --git a/hutool-extra/src/main/java/cn/hutool/extra/expression/engine/ExpressionFactory.java b/hutool-extra/src/main/java/cn/hutool/extra/expression/engine/ExpressionFactory.java
index 89d0b5249..de805450d 100644
--- a/hutool-extra/src/main/java/cn/hutool/extra/expression/engine/ExpressionFactory.java
+++ b/hutool-extra/src/main/java/cn/hutool/extra/expression/engine/ExpressionFactory.java
@@ -9,7 +9,7 @@ import cn.hutool.extra.expression.ExpressionEngine;
import cn.hutool.extra.expression.ExpressionException;
/**
- * 表达式语言引擎工厂类，，用于根据用户引入的表达式jar，自动创建对应的引擎对象
+ * 表达式语言引擎工厂类，用于根据用户引入的表达式jar，自动创建对应的引擎对象
*
* @since 5.5.0
* @author looly
diff --git a/hutool-extra/src/main/java/cn/hutool/extra/ftp/Ftp.java b/hutool-extra/src/main/java/cn/hutool/extra/ftp/Ftp.java
index f5b336527..607dd2c14 100644
--- a/hutool-extra/src/main/java/cn/hutool/extra/ftp/Ftp.java
+++ b/hutool-extra/src/main/java/cn/hutool/extra/ftp/Ftp.java
@@ -134,6 +134,17 @@ public class Ftp extends AbstractFtp {
this.init();
}
+ /**
+ * 构造
+ *
+ * @param client 自定义实例化好的{@link FTPClient}
+ * @since 5.7.22
+ */
+ public Ftp(FTPClient client) {
+ super(FtpConfig.create());
+ this.client = client;
+ }
+
/**
* 初始化连接
*
diff --git a/hutool-extra/src/main/java/cn/hutool/extra/spring/SpringUtil.java b/hutool-extra/src/main/java/cn/hutool/extra/spring/SpringUtil.java
index c12071a73..ea08f0921 100644
--- a/hutool-extra/src/main/java/cn/hutool/extra/spring/SpringUtil.java
+++ b/hutool-extra/src/main/java/cn/hutool/extra/spring/SpringUtil.java
@@ -259,7 +259,7 @@ public class SpringUtil implements BeanFactoryPostProcessor, ApplicationContextA
/**
* 发布事件
*
- * @param event the event to publish
+ * @param event 待发布的事件，事件必须是{@link ApplicationEvent}的子类
* @since 5.7.12
*/
public static void publishEvent(ApplicationEvent event) {
@@ -267,6 +267,19 @@ public class SpringUtil implements BeanFactoryPostProcessor, ApplicationContextA
applicationContext.publishEvent(event);
}
}
+
+ /**
+ * 发布事件
+ * Spring 4.2+ 版本事件可以不再是{@link ApplicationEvent}的子类
+ *
+ * @param event 待发布的事件
+ * @since 5.7.21
+ */
+ public static void publishEvent(Object event) {
+ if (null != applicationContext) {
+ applicationContext.publishEvent(event);
+ }
+ }
}
diff --git a/hutool-extra/src/main/java/cn/hutool/extra/ssh/GanymedUtil.java b/hutool-extra/src/main/java/cn/hutool/extra/ssh/GanymedUtil.java
index a681eea14..cbe3313a7 100644
--- a/hutool-extra/src/main/java/cn/hutool/extra/ssh/GanymedUtil.java
+++ b/hutool-extra/src/main/java/cn/hutool/extra/ssh/GanymedUtil.java
@@ -79,7 +79,7 @@ public class GanymedUtil {
result = IoUtil.read(new StreamGobbler(session.getStdout()), charset);
// 错误输出
- IoUtil.copy(new StreamGobbler(session.getStdout()), errStream);
+ IoUtil.copy(new StreamGobbler(session.getStderr()), errStream);
} catch (IOException e) {
throw new IORuntimeException(e);
} finally {
@@ -91,7 +91,7 @@ public class GanymedUtil {
/**
* 执行Shell命令
*
- * 此方法单次发送一个命令到服务端，自动读取环境变量，执行结束后自动关闭Session，不会产生阻塞。
+ * 此方法单次发送一个命令到服务端，自动读取环境变量，执行结束后自动关闭Session，可能产生阻塞。
*
*
* @param session Session会话
@@ -109,7 +109,7 @@ public class GanymedUtil {
result = IoUtil.read(new StreamGobbler(session.getStdout()), charset);
if(null != errStream){
// 错误输出
- IoUtil.copy(new StreamGobbler(session.getStdout()), errStream);
+ IoUtil.copy(new StreamGobbler(session.getStderr()), errStream);
}
} catch (IOException e) {
throw new IORuntimeException(e);
diff --git a/hutool-http/pom.xml b/hutool-http/pom.xml
index 0cff463c3..284c72dfb 100644
--- a/hutool-http/pom.xml
+++ b/hutool-http/pom.xml
@@ -9,7 +9,7 @@
cn.hutool
hutool-parent
- 5.7.21-SNAPSHOT
+ 5.7.22-SNAPSHOT
hutool-http
diff --git a/hutool-http/src/main/java/cn/hutool/http/HttpBase.java b/hutool-http/src/main/java/cn/hutool/http/HttpBase.java
index b39c6e8ad..8b3ebe441 100644
--- a/hutool-http/src/main/java/cn/hutool/http/HttpBase.java
+++ b/hutool-http/src/main/java/cn/hutool/http/HttpBase.java
@@ -24,6 +24,11 @@ import java.util.Map.Entry;
@SuppressWarnings("unchecked")
public abstract class HttpBase {
+ /**
+ * 默认的请求编码、URL的encode、decode编码
+ */
+ protected static final Charset DEFAULT_CHARSET = CharsetUtil.CHARSET_UTF_8;
+
/**
* HTTP/1.0
*/
@@ -40,7 +45,7 @@ public abstract class HttpBase {
/**
* 编码
*/
- protected Charset charset = CharsetUtil.CHARSET_UTF_8;
+ protected Charset charset = DEFAULT_CHARSET;
/**
* http版本
*/
diff --git a/hutool-http/src/main/java/cn/hutool/http/HttpGlobalConfig.java b/hutool-http/src/main/java/cn/hutool/http/HttpGlobalConfig.java
index 99f28b1e1..2015bdc77 100755
--- a/hutool-http/src/main/java/cn/hutool/http/HttpGlobalConfig.java
+++ b/hutool-http/src/main/java/cn/hutool/http/HttpGlobalConfig.java
@@ -33,6 +33,7 @@ public class HttpGlobalConfig implements Serializable {
private static String boundary = "--------------------Hutool_" + RandomUtil.randomString(16);
private static int maxRedirectCount = 0;
private static boolean ignoreEOFError = true;
+ private static boolean decodeUrl = false;
/**
* 获取全局默认的超时时长
@@ -124,12 +125,36 @@ public class HttpGlobalConfig implements Serializable {
ignoreEOFError = customIgnoreEOFError;
}
+ /**
+ * 获取是否忽略解码URL，包括URL中的Path部分和Param部分。
+ * 在构建Http请求时，用户传入的URL可能有编码后和未编码的内容混合在一起，如果此参数为{@code true}，则会统一解码编码后的参数，
+ * 按照RFC3986规范，在发送请求时，全部编码之。如果为{@code false}，则不会解码已经编码的内容，在请求时只编码需要编码的部分。
+ *
+ * @return 是否忽略解码URL
+ * @since 5.7.22
+ */
+ public static boolean isDecodeUrl() {
+ return decodeUrl;
+ }
+
+ /**
+ * 设置是否忽略解码URL，包括URL中的Path部分和Param部分。
+ * 在构建Http请求时，用户传入的URL可能有编码后和未编码的内容混合在一起，如果此参数为{@code true}，则会统一解码编码后的参数，
+ * 按照RFC3986规范，在发送请求时，全部编码之。如果为{@code false}，则不会解码已经编码的内容，在请求时只编码需要编码的部分。
+ *
+ * @param customDecodeUrl 是否忽略解码URL
+ * @since 5.7.22
+ */
+ synchronized public static void setDecodeUrl(boolean customDecodeUrl) {
+ decodeUrl = customDecodeUrl;
+ }
+
/**
* 获取Cookie管理器，用于自定义Cookie管理
*
* @return {@link CookieManager}
- * @since 4.1.0
* @see GlobalCookieManager#getCookieManager()
+ * @since 4.1.0
*/
public static CookieManager getCookieManager() {
return GlobalCookieManager.getCookieManager();
@@ -139,8 +164,8 @@ public class HttpGlobalConfig implements Serializable {
* 自定义{@link CookieManager}
*
* @param customCookieManager 自定义的{@link CookieManager}
- * @since 4.5.14
* @see GlobalCookieManager#setCookieManager(CookieManager)
+ * @since 4.5.14
*/
synchronized public static void setCookieManager(CookieManager customCookieManager) {
GlobalCookieManager.setCookieManager(customCookieManager);
@@ -149,8 +174,8 @@ public class HttpGlobalConfig implements Serializable {
/**
* 关闭Cookie
*
- * @since 4.1.9
* @see GlobalCookieManager#setCookieManager(CookieManager)
+ * @since 4.1.9
*/
synchronized public static void closeCookie() {
GlobalCookieManager.setCookieManager(null);
@@ -164,7 +189,7 @@ public class HttpGlobalConfig implements Serializable {
* @since 5.7.4
*/
synchronized public static void allowPatch() {
- if(isAllowPatch){
+ if (isAllowPatch) {
return;
}
final Field methodsField = ReflectUtil.getField(HttpURLConnection.class, "methods");
@@ -181,7 +206,7 @@ public class HttpGlobalConfig implements Serializable {
// 检查注入是否成功
final Object staticFieldValue = ReflectUtil.getStaticFieldValue(methodsField);
- if(false == ArrayUtil.equals(methods, staticFieldValue)){
+ if (false == ArrayUtil.equals(methods, staticFieldValue)) {
throw new HttpException("Inject value to field [methods] failed!");
}
diff --git a/hutool-http/src/main/java/cn/hutool/http/HttpRequest.java b/hutool-http/src/main/java/cn/hutool/http/HttpRequest.java
index 7c7a68e35..864363e19 100644
--- a/hutool-http/src/main/java/cn/hutool/http/HttpRequest.java
+++ b/hutool-http/src/main/java/cn/hutool/http/HttpRequest.java
@@ -12,7 +12,6 @@ import cn.hutool.core.map.MapUtil;
import cn.hutool.core.net.SSLUtil;
import cn.hutool.core.net.url.UrlBuilder;
import cn.hutool.core.util.ArrayUtil;
-import cn.hutool.core.util.CharsetUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.http.body.BytesBody;
@@ -129,18 +128,24 @@ public class HttpRequest extends HttpBase {
}
/**
- * 构建一个HTTP请求
+ * 构建一个HTTP请求
+ * 对于传入的URL，可以自定义是否解码已经编码的内容，设置见{@link HttpGlobalConfig#setDecodeUrl(boolean)}
+ * 在构建Http请求时，用户传入的URL可能有编码后和未编码的内容混合在一起，如果{@link HttpGlobalConfig#isDecodeUrl()}为{@code true}，则会统一解码编码后的参数，
+ * 按照RFC3986规范，在发送请求时，全部编码之。如果为{@code false}，则不会解码已经编码的内容，在请求时只编码需要编码的部分。
*
* @param url URL链接，默认自动编码URL中的参数等信息
* @return HttpRequest
* @since 5.7.18
*/
public static HttpRequest of(String url) {
- return of(url, CharsetUtil.CHARSET_UTF_8);
+ return of(url, HttpGlobalConfig.isDecodeUrl() ? DEFAULT_CHARSET : null);
}
/**
- * 构建一个HTTP请求
+ * 构建一个HTTP请求
+ * 对于传入的URL，可以自定义是否解码已经编码的内容。
+ * 在构建Http请求时，用户传入的URL可能有编码后和未编码的内容混合在一起，如果charset参数不为{@code null}，则会统一解码编码后的参数，
+ * 按照RFC3986规范，在发送请求时，全部编码之。如果为{@code false}，则不会解码已经编码的内容，在请求时只编码需要编码的部分。
*
* @param url URL链接
* @param charset 编码，如果为{@code null}不自动解码编码URL
@@ -266,7 +271,9 @@ public class HttpRequest extends HttpBase {
* 构造，URL编码默认使用UTF-8
*
* @param url URL
+ * @deprecated 请使用 {@link #of(String)}
*/
+ @Deprecated
public HttpRequest(String url) {
this(UrlBuilder.ofHttp(url));
}
diff --git a/hutool-http/src/main/java/cn/hutool/http/HttpUtil.java b/hutool-http/src/main/java/cn/hutool/http/HttpUtil.java
index a6904f6f4..2ed832948 100644
--- a/hutool-http/src/main/java/cn/hutool/http/HttpUtil.java
+++ b/hutool-http/src/main/java/cn/hutool/http/HttpUtil.java
@@ -75,7 +75,7 @@ public class HttpUtil {
* @since 3.0.9
*/
public static HttpRequest createRequest(Method method, String url) {
- return new HttpRequest(url).method(method);
+ return HttpRequest.of(url).method(method);
}
/**
diff --git a/hutool-http/src/main/java/cn/hutool/http/ssl/SSLSocketFactoryBuilder.java b/hutool-http/src/main/java/cn/hutool/http/ssl/SSLSocketFactoryBuilder.java
index bc94c8a1e..a52462e4a 100644
--- a/hutool-http/src/main/java/cn/hutool/http/ssl/SSLSocketFactoryBuilder.java
+++ b/hutool-http/src/main/java/cn/hutool/http/ssl/SSLSocketFactoryBuilder.java
@@ -90,6 +90,6 @@ public class SSLSocketFactoryBuilder implements SSLProtocols {
* @throws KeyManagementException Key管理异常
*/
public SSLSocketFactory build() throws NoSuchAlgorithmException, KeyManagementException {
- return this.sslContextBuilder.build().getSocketFactory();
+ return this.sslContextBuilder.buildChecked().getSocketFactory();
}
}
diff --git a/hutool-http/src/test/java/cn/hutool/http/HttpUtilTest.java b/hutool-http/src/test/java/cn/hutool/http/HttpUtilTest.java
index 00ad46b87..18dbb9682 100644
--- a/hutool-http/src/test/java/cn/hutool/http/HttpUtilTest.java
+++ b/hutool-http/src/test/java/cn/hutool/http/HttpUtilTest.java
@@ -352,4 +352,14 @@ public class HttpUtilTest {
.execute().body();
Console.log(body);
}
+
+ @Test
+ @Ignore
+ public void getPicTest(){
+ HttpGlobalConfig.setDecodeUrl(false);
+ String url = "https://p3-sign.douyinpic.com/tos-cn-i-0813/f41afb2e79a94dcf80970affb9a69415~noop.webp?x-expires=1647738000&x-signature=%2Br1ekUCGjXiu50Y%2Bk0MO4ovulK8%3D&from=4257465056&s=PackSourceEnum_DOUYIN_REFLOW&se=false&sh=&sc=&l=2022021809224601020810013524310DD3&biz_tag=aweme_images";
+
+ final HttpRequest request = HttpRequest.of(url).method(Method.GET);
+ Console.log(request.execute().body());
+ }
}
diff --git a/hutool-http/src/test/java/cn/hutool/http/RestTest.java b/hutool-http/src/test/java/cn/hutool/http/RestTest.java
index 9371c6039..a4c9f92da 100644
--- a/hutool-http/src/test/java/cn/hutool/http/RestTest.java
+++ b/hutool-http/src/test/java/cn/hutool/http/RestTest.java
@@ -63,6 +63,7 @@ public class RestTest {
.body(JSONUtil.createObj()
.set("advertiser_ids", new Long[] {1690657248243790L})
.set("fields", new String[] {"id", "name", "status"}).toString());
+ Console.log(request);
Console.log(request.execute().body());
}
}
diff --git a/hutool-json/pom.xml b/hutool-json/pom.xml
index 03cbd5837..f3f427fdf 100644
--- a/hutool-json/pom.xml
+++ b/hutool-json/pom.xml
@@ -9,7 +9,7 @@
cn.hutool
hutool-parent
- 5.7.21-SNAPSHOT
+ 5.7.22-SNAPSHOT
hutool-json
diff --git a/hutool-json/src/main/java/cn/hutool/json/JSONArray.java b/hutool-json/src/main/java/cn/hutool/json/JSONArray.java
index c1d9e2492..d3973d55e 100644
--- a/hutool-json/src/main/java/cn/hutool/json/JSONArray.java
+++ b/hutool-json/src/main/java/cn/hutool/json/JSONArray.java
@@ -23,8 +23,6 @@ import java.util.List;
import java.util.ListIterator;
import java.util.RandomAccess;
-import static cn.hutool.json.JSONConverter.jsonConvert;
-
/**
* JSON数组
* JSON数组是表示中括号括住的数据表现形式
@@ -246,7 +244,7 @@ public class JSONArray implements JSON, JSONGetter, List