+{
+ private static final long serialVersionUID = -1185015143654744140L;
+
+ /**
+ * SecureRandom 鐨勫崟渚
+ *
+ */
+ private static class Holder
+ {
+ static final SecureRandom numberGenerator = getSecureRandom();
+ }
+
+ /** 姝UID鐨勬渶楂64鏈夋晥浣 */
+ private final long mostSigBits;
+
+ /** 姝UID鐨勬渶浣64鏈夋晥浣 */
+ private final long leastSigBits;
+
+ /**
+ * 绉佹湁鏋勯
+ *
+ * @param data 鏁版嵁
+ */
+ private UUID(byte[] data)
+ {
+ long msb = 0;
+ long lsb = 0;
+ assert data.length == 16 : "data must be 16 bytes in length";
+ for (int i = 0; i < 8; i++)
+ {
+ msb = (msb << 8) | (data[i] & 0xff);
+ }
+ for (int i = 8; i < 16; i++)
+ {
+ lsb = (lsb << 8) | (data[i] & 0xff);
+ }
+ this.mostSigBits = msb;
+ this.leastSigBits = lsb;
+ }
+
+ /**
+ * 浣跨敤鎸囧畾鐨勬暟鎹瀯閫犳柊鐨 UUID銆
+ *
+ * @param mostSigBits 鐢ㄤ簬 {@code UUID} 鐨勬渶楂樻湁鏁 64 浣
+ * @param leastSigBits 鐢ㄤ簬 {@code UUID} 鐨勬渶浣庢湁鏁 64 浣
+ */
+ public UUID(long mostSigBits, long leastSigBits)
+ {
+ this.mostSigBits = mostSigBits;
+ this.leastSigBits = leastSigBits;
+ }
+
+ /**
+ * 鑾峰彇绫诲瀷 4锛堜吉闅忔満鐢熸垚鐨勶級UUID 鐨勯潤鎬佸伐鍘傘 浣跨敤鍔犲瘑鐨勬湰鍦扮嚎绋嬩吉闅忔満鏁扮敓鎴愬櫒鐢熸垚璇 UUID銆
+ *
+ * @return 闅忔満鐢熸垚鐨 {@code UUID}
+ */
+ public static UUID fastUUID()
+ {
+ return randomUUID(false);
+ }
+
+ /**
+ * 鑾峰彇绫诲瀷 4锛堜吉闅忔満鐢熸垚鐨勶級UUID 鐨勯潤鎬佸伐鍘傘 浣跨敤鍔犲瘑鐨勫己浼殢鏈烘暟鐢熸垚鍣ㄧ敓鎴愯 UUID銆
+ *
+ * @return 闅忔満鐢熸垚鐨 {@code UUID}
+ */
+ public static UUID randomUUID()
+ {
+ return randomUUID(true);
+ }
+
+ /**
+ * 鑾峰彇绫诲瀷 4锛堜吉闅忔満鐢熸垚鐨勶級UUID 鐨勯潤鎬佸伐鍘傘 浣跨敤鍔犲瘑鐨勫己浼殢鏈烘暟鐢熸垚鍣ㄧ敓鎴愯 UUID銆
+ *
+ * @param isSecure 鏄惁浣跨敤{@link SecureRandom}濡傛灉鏄彲浠ヨ幏寰楁洿瀹夊叏鐨勯殢鏈虹爜锛屽惁鍒欏彲浠ュ緱鍒版洿濂界殑鎬ц兘
+ * @return 闅忔満鐢熸垚鐨 {@code UUID}
+ */
+ public static UUID randomUUID(boolean isSecure)
+ {
+ final Random ng = isSecure ? Holder.numberGenerator : getRandom();
+
+ byte[] randomBytes = new byte[16];
+ ng.nextBytes(randomBytes);
+ randomBytes[6] &= 0x0f; /* clear version */
+ randomBytes[6] |= 0x40; /* set to version 4 */
+ randomBytes[8] &= 0x3f; /* clear variant */
+ randomBytes[8] |= 0x80; /* set to IETF variant */
+ return new UUID(randomBytes);
+ }
+
+ /**
+ * 鏍规嵁鎸囧畾鐨勫瓧鑺傛暟缁勮幏鍙栫被鍨 3锛堝熀浜庡悕绉扮殑锛塙UID 鐨勯潤鎬佸伐鍘傘
+ *
+ * @param name 鐢ㄤ簬鏋勯 UUID 鐨勫瓧鑺傛暟缁勩
+ *
+ * @return 鏍规嵁鎸囧畾鏁扮粍鐢熸垚鐨 {@code UUID}
+ */
+ public static UUID nameUUIDFromBytes(byte[] name)
+ {
+ MessageDigest md;
+ try
+ {
+ md = MessageDigest.getInstance("MD5");
+ }
+ catch (NoSuchAlgorithmException nsae)
+ {
+ throw new InternalError("MD5 not supported");
+ }
+ byte[] md5Bytes = md.digest(name);
+ md5Bytes[6] &= 0x0f; /* clear version */
+ md5Bytes[6] |= 0x30; /* set to version 3 */
+ md5Bytes[8] &= 0x3f; /* clear variant */
+ md5Bytes[8] |= 0x80; /* set to IETF variant */
+ return new UUID(md5Bytes);
+ }
+
+ /**
+ * 鏍规嵁 {@link #toString()} 鏂规硶涓弿杩扮殑瀛楃涓叉爣鍑嗚〃绀哄舰寮忓垱寤簕@code UUID}銆
+ *
+ * @param name 鎸囧畾 {@code UUID} 瀛楃涓
+ * @return 鍏锋湁鎸囧畾鍊肩殑 {@code UUID}
+ * @throws IllegalArgumentException 濡傛灉 name 涓 {@link #toString} 涓弿杩扮殑瀛楃涓茶〃绀哄舰寮忎笉绗︽姏鍑烘寮傚父
+ *
+ */
+ public static UUID fromString(String name)
+ {
+ String[] components = name.split("-");
+ if (components.length != 5)
+ {
+ throw new IllegalArgumentException("Invalid UUID string: " + name);
+ }
+ for (int i = 0; i < 5; i++)
+ {
+ components[i] = "0x" + components[i];
+ }
+
+ long mostSigBits = Long.decode(components[0]).longValue();
+ mostSigBits <<= 16;
+ mostSigBits |= Long.decode(components[1]).longValue();
+ mostSigBits <<= 16;
+ mostSigBits |= Long.decode(components[2]).longValue();
+
+ long leastSigBits = Long.decode(components[3]).longValue();
+ leastSigBits <<= 48;
+ leastSigBits |= Long.decode(components[4]).longValue();
+
+ return new UUID(mostSigBits, leastSigBits);
+ }
+
+ /**
+ * 杩斿洖姝 UUID 鐨 128 浣嶅间腑鐨勬渶浣庢湁鏁 64 浣嶃
+ *
+ * @return 姝 UUID 鐨 128 浣嶅间腑鐨勬渶浣庢湁鏁 64 浣嶃
+ */
+ public long getLeastSignificantBits()
+ {
+ return leastSigBits;
+ }
+
+ /**
+ * 杩斿洖姝 UUID 鐨 128 浣嶅间腑鐨勬渶楂樻湁鏁 64 浣嶃
+ *
+ * @return 姝 UUID 鐨 128 浣嶅间腑鏈楂樻湁鏁 64 浣嶃
+ */
+ public long getMostSignificantBits()
+ {
+ return mostSigBits;
+ }
+
+ /**
+ * 涓庢 {@code UUID} 鐩稿叧鑱旂殑鐗堟湰鍙. 鐗堟湰鍙锋弿杩版 {@code UUID} 鏄浣曠敓鎴愮殑銆
+ *
+ * 鐗堟湰鍙峰叿鏈変互涓嬪惈鎰:
+ *
+ * - 1 鍩轰簬鏃堕棿鐨 UUID
+ *
- 2 DCE 瀹夊叏 UUID
+ *
- 3 鍩轰簬鍚嶇О鐨 UUID
+ *
- 4 闅忔満鐢熸垚鐨 UUID
+ *
+ *
+ * @return 姝 {@code UUID} 鐨勭増鏈彿
+ */
+ public int version()
+ {
+ // Version is bits masked by 0x000000000000F000 in MS long
+ return (int) ((mostSigBits >> 12) & 0x0f);
+ }
+
+ /**
+ * 涓庢 {@code UUID} 鐩稿叧鑱旂殑鍙樹綋鍙枫傚彉浣撳彿鎻忚堪 {@code UUID} 鐨勫竷灞銆
+ *
+ * 鍙樹綋鍙峰叿鏈変互涓嬪惈鎰忥細
+ *
+ * - 0 涓 NCS 鍚戝悗鍏煎淇濈暀
+ *
- 2 IETF RFC 4122(Leach-Salz), 鐢ㄤ簬姝ょ被
+ *
- 6 淇濈暀锛屽井杞悜鍚庡吋瀹
+ *
- 7 淇濈暀渚涗互鍚庡畾涔変娇鐢
+ *
+ *
+ * @return 姝 {@code UUID} 鐩稿叧鑱旂殑鍙樹綋鍙
+ */
+ public int variant()
+ {
+ // This field is composed of a varying number of bits.
+ // 0 - - Reserved for NCS backward compatibility
+ // 1 0 - The IETF aka Leach-Salz variant (used by this class)
+ // 1 1 0 Reserved, Microsoft backward compatibility
+ // 1 1 1 Reserved for future definition.
+ return (int) ((leastSigBits >>> (64 - (leastSigBits >>> 62))) & (leastSigBits >> 63));
+ }
+
+ /**
+ * 涓庢 UUID 鐩稿叧鑱旂殑鏃堕棿鎴冲笺
+ *
+ *
+ * 60 浣嶇殑鏃堕棿鎴冲兼牴鎹 {@code UUID} 鐨 time_low銆乼ime_mid 鍜 time_hi 瀛楁鏋勯犮
+ * 鎵寰楀埌鐨勬椂闂存埑浠 100 姣井绉掍负鍗曚綅锛屼粠 UTC锛堥氱敤鍗忚皟鏃堕棿锛 1582 骞 10 鏈 15 鏃ラ浂鏃跺紑濮嬨
+ *
+ *
+ * 鏃堕棿鎴冲间粎鍦ㄥ湪鍩轰簬鏃堕棿鐨 UUID锛堝叾 version 绫诲瀷涓 1锛変腑鎵嶆湁鎰忎箟銆
+ * 濡傛灉姝 {@code UUID} 涓嶆槸鍩轰簬鏃堕棿鐨 UUID锛屽垯姝ゆ柟娉曟姏鍑 UnsupportedOperationException銆
+ *
+ * @throws UnsupportedOperationException 濡傛灉姝 {@code UUID} 涓嶆槸 version 涓 1 鐨 UUID銆
+ */
+ public long timestamp() throws UnsupportedOperationException
+ {
+ checkTimeBase();
+ return (mostSigBits & 0x0FFFL) << 48//
+ | ((mostSigBits >> 16) & 0x0FFFFL) << 32//
+ | mostSigBits >>> 32;
+ }
+
+ /**
+ * 涓庢 UUID 鐩稿叧鑱旂殑鏃堕挓搴忓垪鍊笺
+ *
+ *
+ * 14 浣嶇殑鏃堕挓搴忓垪鍊兼牴鎹 UUID 鐨 clock_seq 瀛楁鏋勯犮俢lock_seq 瀛楁鐢ㄤ簬淇濊瘉鍦ㄥ熀浜庢椂闂寸殑 UUID 涓殑鏃堕棿鍞竴鎬с
+ *
+ * {@code clockSequence} 鍊间粎鍦ㄥ熀浜庢椂闂寸殑 UUID锛堝叾 version 绫诲瀷涓 1锛変腑鎵嶆湁鎰忎箟銆 濡傛灉姝 UUID 涓嶆槸鍩轰簬鏃堕棿鐨 UUID锛屽垯姝ゆ柟娉曟姏鍑
+ * UnsupportedOperationException銆
+ *
+ * @return 姝 {@code UUID} 鐨勬椂閽熷簭鍒
+ *
+ * @throws UnsupportedOperationException 濡傛灉姝 UUID 鐨 version 涓嶄负 1
+ */
+ public int clockSequence() throws UnsupportedOperationException
+ {
+ checkTimeBase();
+ return (int) ((leastSigBits & 0x3FFF000000000000L) >>> 48);
+ }
+
+ /**
+ * 涓庢 UUID 鐩稿叧鐨勮妭鐐瑰笺
+ *
+ *
+ * 48 浣嶇殑鑺傜偣鍊兼牴鎹 UUID 鐨 node 瀛楁鏋勯犮傛瀛楁鏃ㄥ湪鐢ㄤ簬淇濆瓨鏈哄櫒鐨 IEEE 802 鍦板潃锛岃鍦板潃鐢ㄤ簬鐢熸垚姝 UUID 浠ヤ繚璇佺┖闂村敮涓鎬с
+ *
+ * 鑺傜偣鍊间粎鍦ㄥ熀浜庢椂闂寸殑 UUID锛堝叾 version 绫诲瀷涓 1锛変腑鎵嶆湁鎰忎箟銆
+ * 濡傛灉姝 UUID 涓嶆槸鍩轰簬鏃堕棿鐨 UUID锛屽垯姝ゆ柟娉曟姏鍑 UnsupportedOperationException銆
+ *
+ * @return 姝 {@code UUID} 鐨勮妭鐐瑰
+ *
+ * @throws UnsupportedOperationException 濡傛灉姝 UUID 鐨 version 涓嶄负 1
+ */
+ public long node() throws UnsupportedOperationException
+ {
+ checkTimeBase();
+ return leastSigBits & 0x0000FFFFFFFFFFFFL;
+ }
+
+ /**
+ * 杩斿洖姝@code UUID} 鐨勫瓧绗︿覆琛ㄧ幇褰㈠紡銆
+ *
+ *
+ * UUID 鐨勫瓧绗︿覆琛ㄧず褰㈠紡鐢辨 BNF 鎻忚堪锛
+ *
+ *
+ * {@code
+ * UUID = ----
+ * time_low = 4*
+ * time_mid = 2*
+ * time_high_and_version = 2*
+ * variant_and_sequence = 2*
+ * node = 6*
+ * hexOctet =
+ * hexDigit = [0-9a-fA-F]
+ * }
+ *
+ *
+ *
+ *
+ * @return 姝@code UUID} 鐨勫瓧绗︿覆琛ㄧ幇褰㈠紡
+ * @see #toString(boolean)
+ */
+ @Override
+ public String toString()
+ {
+ return toString(false);
+ }
+
+ /**
+ * 杩斿洖姝@code UUID} 鐨勫瓧绗︿覆琛ㄧ幇褰㈠紡銆
+ *
+ *
+ * UUID 鐨勫瓧绗︿覆琛ㄧず褰㈠紡鐢辨 BNF 鎻忚堪锛
+ *
+ *
+ * {@code
+ * UUID = ----
+ * time_low = 4*
+ * time_mid = 2*
+ * time_high_and_version = 2*
+ * variant_and_sequence = 2*
+ * node = 6*
+ * hexOctet =
+ * hexDigit = [0-9a-fA-F]
+ * }
+ *
+ *
+ *
+ *
+ * @param isSimple 鏄惁绠鍗曟ā寮忥紝绠鍗曟ā寮忎负涓嶅甫'-'鐨刄UID瀛楃涓
+ * @return 姝@code UUID} 鐨勫瓧绗︿覆琛ㄧ幇褰㈠紡
+ */
+ public String toString(boolean isSimple)
+ {
+ final StringBuilder builder = new StringBuilder(isSimple ? 32 : 36);
+ // time_low
+ builder.append(digits(mostSigBits >> 32, 8));
+ if (false == isSimple)
+ {
+ builder.append('-');
+ }
+ // time_mid
+ builder.append(digits(mostSigBits >> 16, 4));
+ if (false == isSimple)
+ {
+ builder.append('-');
+ }
+ // time_high_and_version
+ builder.append(digits(mostSigBits, 4));
+ if (false == isSimple)
+ {
+ builder.append('-');
+ }
+ // variant_and_sequence
+ builder.append(digits(leastSigBits >> 48, 4));
+ if (false == isSimple)
+ {
+ builder.append('-');
+ }
+ // node
+ builder.append(digits(leastSigBits, 12));
+
+ return builder.toString();
+ }
+
+ /**
+ * 杩斿洖姝 UUID 鐨勫搱甯岀爜銆
+ *
+ * @return UUID 鐨勫搱甯岀爜鍊笺
+ */
+ @Override
+ public int hashCode()
+ {
+ long hilo = mostSigBits ^ leastSigBits;
+ return ((int) (hilo >> 32)) ^ (int) hilo;
+ }
+
+ /**
+ * 灏嗘瀵硅薄涓庢寚瀹氬璞℃瘮杈冦
+ *
+ * 褰撲笖浠呭綋鍙傛暟涓嶄负 {@code null}銆佽屾槸涓涓 UUID 瀵硅薄銆佸叿鏈変笌姝 UUID 鐩稿悓鐨 varriant銆佸寘鍚浉鍚岀殑鍊硷紙姣忎竴浣嶅潎鐩稿悓锛夋椂锛岀粨鏋滄墠涓 {@code true}銆
+ *
+ * @param obj 瑕佷笌涔嬫瘮杈冪殑瀵硅薄
+ *
+ * @return 濡傛灉瀵硅薄鐩稿悓锛屽垯杩斿洖 {@code true}锛涘惁鍒欒繑鍥 {@code false}
+ */
+ @Override
+ public boolean equals(Object obj)
+ {
+ if ((null == obj) || (obj.getClass() != UUID.class))
+ {
+ return false;
+ }
+ UUID id = (UUID) obj;
+ return (mostSigBits == id.mostSigBits && leastSigBits == id.leastSigBits);
+ }
+
+ // Comparison Operations
+
+ /**
+ * 灏嗘 UUID 涓庢寚瀹氱殑 UUID 姣旇緝銆
+ *
+ *
+ * 濡傛灉涓や釜 UUID 涓嶅悓锛屼笖绗竴涓 UUID 鐨勬渶楂樻湁鏁堝瓧娈靛ぇ浜庣浜屼釜 UUID 鐨勫搴斿瓧娈碉紝鍒欑涓涓 UUID 澶т簬绗簩涓 UUID銆
+ *
+ * @param val 涓庢 UUID 姣旇緝鐨 UUID
+ *
+ * @return 鍦ㄦ UUID 灏忎簬銆佺瓑浜庢垨澶т簬 val 鏃讹紝鍒嗗埆杩斿洖 -1銆0 鎴 1銆
+ *
+ */
+ @Override
+ public int compareTo(UUID val)
+ {
+ // The ordering is intentionally set up so that the UUIDs
+ // can simply be numerically compared as two numbers
+ return (this.mostSigBits < val.mostSigBits ? -1 : //
+ (this.mostSigBits > val.mostSigBits ? 1 : //
+ (this.leastSigBits < val.leastSigBits ? -1 : //
+ (this.leastSigBits > val.leastSigBits ? 1 : //
+ 0))));
+ }
+
+ // -------------------------------------------------------------------------------------------------------------------
+ // Private method start
+ /**
+ * 杩斿洖鎸囧畾鏁板瓧瀵瑰簲鐨刪ex鍊
+ *
+ * @param val 鍊
+ * @param digits 浣
+ * @return 鍊
+ */
+ private static String digits(long val, int digits)
+ {
+ long hi = 1L << (digits * 4);
+ return Long.toHexString(hi | (val & (hi - 1))).substring(1);
+ }
+
+ /**
+ * 妫鏌ユ槸鍚︿负time-based鐗堟湰UUID
+ */
+ private void checkTimeBase()
+ {
+ if (version() != 1)
+ {
+ throw new UnsupportedOperationException("Not a time-based UUID");
+ }
+ }
+
+ /**
+ * 鑾峰彇{@link SecureRandom}锛岀被鎻愪緵鍔犲瘑鐨勫己闅忔満鏁扮敓鎴愬櫒 (RNG)
+ *
+ * @return {@link SecureRandom}
+ */
+ public static SecureRandom getSecureRandom()
+ {
+ try
+ {
+ return SecureRandom.getInstance("SHA1PRNG");
+ }
+ catch (NoSuchAlgorithmException e)
+ {
+ throw new UtilException(e);
+ }
+ }
+
+ /**
+ * 鑾峰彇闅忔満鏁扮敓鎴愬櫒瀵硅薄
+ * ThreadLocalRandom鏄疛DK 7涔嬪悗鎻愪緵骞跺彂浜х敓闅忔満鏁帮紝鑳藉瑙ｅ喅澶氫釜绾跨▼鍙戠敓鐨勭珵浜変簤澶恒
+ *
+ * @return {@link ThreadLocalRandom}
+ */
+ public static ThreadLocalRandom getRandom()
+ {
+ return ThreadLocalRandom.current();
+ }
+}
diff --git a/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/utils/DateUtils.java b/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/utils/DateUtils.java
new file mode 100644
index 0000000..6f25dcf
--- /dev/null
+++ b/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/utils/DateUtils.java
@@ -0,0 +1,155 @@
+package com.zhentao.common.core.utils;
+
+import java.lang.management.ManagementFactory;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import org.apache.commons.lang3.time.DateFormatUtils;
+
+/**
+ * 鏃堕棿宸ュ叿绫
+ *
+ * @author ruoyi
+ */
+public class DateUtils extends org.apache.commons.lang3.time.DateUtils
+{
+ public static String YYYY = "yyyy";
+
+ public static String YYYY_MM = "yyyy-MM";
+
+ public static String YYYY_MM_DD = "yyyy-MM-dd";
+
+ public static String YYYYMMDDHHMMSS = "yyyyMMddHHmmss";
+
+ public static String YYYY_MM_DD_HH_MM_SS = "yyyy-MM-dd HH:mm:ss";
+
+ private static String[] parsePatterns = {
+ "yyyy-MM-dd", "yyyy-MM-dd HH:mm:ss", "yyyy-MM-dd HH:mm", "yyyy-MM",
+ "yyyy/MM/dd", "yyyy/MM/dd HH:mm:ss", "yyyy/MM/dd HH:mm", "yyyy/MM",
+ "yyyy.MM.dd", "yyyy.MM.dd HH:mm:ss", "yyyy.MM.dd HH:mm", "yyyy.MM"};
+
+ /**
+ * 鑾峰彇褰撳墠Date鍨嬫棩鏈
+ *
+ * @return Date() 褰撳墠鏃ユ湡
+ */
+ public static Date getNowDate()
+ {
+ return new Date();
+ }
+
+ /**
+ * 鑾峰彇褰撳墠鏃ユ湡, 榛樿鏍煎紡涓簓yyy-MM-dd
+ *
+ * @return String
+ */
+ public static String getDate()
+ {
+ return dateTimeNow(YYYY_MM_DD);
+ }
+
+ public static final String getTime()
+ {
+ return dateTimeNow(YYYY_MM_DD_HH_MM_SS);
+ }
+
+ public static final String dateTimeNow()
+ {
+ return dateTimeNow(YYYYMMDDHHMMSS);
+ }
+
+ public static final String dateTimeNow(final String format)
+ {
+ return parseDateToStr(format, new Date());
+ }
+
+ public static final String dateTime(final Date date)
+ {
+ return parseDateToStr(YYYY_MM_DD, date);
+ }
+
+ public static final String parseDateToStr(final String format, final Date date)
+ {
+ return new SimpleDateFormat(format).format(date);
+ }
+
+ public static final Date dateTime(final String format, final String ts)
+ {
+ try
+ {
+ return new SimpleDateFormat(format).parse(ts);
+ }
+ catch (ParseException e)
+ {
+ throw new RuntimeException(e);
+ }
+ }
+
+ /**
+ * 鏃ユ湡璺緞 鍗冲勾/鏈/鏃 濡2018/08/08
+ */
+ public static final String datePath()
+ {
+ Date now = new Date();
+ return DateFormatUtils.format(now, "yyyy/MM/dd");
+ }
+
+ /**
+ * 鏃ユ湡璺緞 鍗冲勾/鏈/鏃 濡20180808
+ */
+ public static final String dateTime()
+ {
+ Date now = new Date();
+ return DateFormatUtils.format(now, "yyyyMMdd");
+ }
+
+ /**
+ * 鏃ユ湡鍨嬪瓧绗︿覆杞寲涓烘棩鏈 鏍煎紡
+ */
+ public static Date parseDate(Object str)
+ {
+ if (str == null)
+ {
+ return null;
+ }
+ try
+ {
+ return parseDate(str.toString(), parsePatterns);
+ }
+ catch (ParseException e)
+ {
+ return null;
+ }
+ }
+
+ /**
+ * 鑾峰彇鏈嶅姟鍣ㄥ惎鍔ㄦ椂闂
+ */
+ public static Date getServerStartDate()
+ {
+ long time = ManagementFactory.getRuntimeMXBean().getStartTime();
+ return new Date(time);
+ }
+
+ /**
+ * 璁＄畻涓や釜鏃堕棿宸
+ */
+ public static String getDatePoor(Date endDate, Date nowDate)
+ {
+ long nd = 1000 * 24 * 60 * 60;
+ long nh = 1000 * 60 * 60;
+ long nm = 1000 * 60;
+ // long ns = 1000;
+ // 鑾峰緱涓や釜鏃堕棿鐨勬绉掓椂闂村樊寮
+ long diff = endDate.getTime() - nowDate.getTime();
+ // 璁＄畻宸灏戝ぉ
+ long day = diff / nd;
+ // 璁＄畻宸灏戝皬鏃
+ long hour = diff % nd / nh;
+ // 璁＄畻宸灏戝垎閽
+ long min = diff % nd % nh / nm;
+ // 璁＄畻宸灏戠//杈撳嚭缁撴灉
+ // long sec = diff % nd % nh % nm / ns;
+ return day + "澶" + hour + "灏忔椂" + min + "鍒嗛挓";
+ }
+}
diff --git a/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/utils/ExceptionUtil.java b/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/utils/ExceptionUtil.java
new file mode 100644
index 0000000..faff3a1
--- /dev/null
+++ b/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/utils/ExceptionUtil.java
@@ -0,0 +1,40 @@
+package com.zhentao.common.core.utils;
+
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import org.apache.commons.lang3.exception.ExceptionUtils;
+
+/**
+ * 閿欒淇℃伅澶勭悊绫汇
+ *
+ * @author ruoyi
+ */
+public class ExceptionUtil
+{
+ /**
+ * 鑾峰彇exception鐨勮缁嗛敊璇俊鎭
+ */
+ public static String getExceptionMessage(Throwable e)
+ {
+ StringWriter sw = new StringWriter();
+ e.printStackTrace(new PrintWriter(sw, true));
+ String str = sw.toString();
+ return str;
+ }
+
+ public static String getRootErrorMseeage(Exception e)
+ {
+ Throwable root = ExceptionUtils.getRootCause(e);
+ root = (root == null ? e : root);
+ if (root == null)
+ {
+ return "";
+ }
+ String msg = root.getMessage();
+ if (msg == null)
+ {
+ return "null";
+ }
+ return StringUtils.defaultString(msg);
+ }
+}
diff --git a/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/utils/IdUtils.java b/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/utils/IdUtils.java
new file mode 100644
index 0000000..1ff1c23
--- /dev/null
+++ b/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/utils/IdUtils.java
@@ -0,0 +1,51 @@
+package com.zhentao.common.core.utils;
+
+import com.zhentao.common.core.text.UUID;
+
+/**
+ * ID鐢熸垚鍣ㄥ伐鍏风被
+ *
+ * @author ruoyi
+ */
+public class IdUtils
+{
+ /**
+ * 鑾峰彇闅忔満UUID
+ *
+ * @return 闅忔満UUID
+ */
+ public static String randomUUID()
+ {
+ return UUID.randomUUID().toString();
+ }
+
+ /**
+ * 绠鍖栫殑UUID锛屽幓鎺変簡妯嚎
+ *
+ * @return 绠鍖栫殑UUID锛屽幓鎺変簡妯嚎
+ */
+ public static String simpleUUID()
+ {
+ return UUID.randomUUID().toString(true);
+ }
+
+ /**
+ * 鑾峰彇闅忔満UUID锛屼娇鐢ㄦц兘鏇村ソ鐨凾hreadLocalRandom鐢熸垚UUID
+ *
+ * @return 闅忔満UUID
+ */
+ public static String fastUUID()
+ {
+ return UUID.fastUUID().toString();
+ }
+
+ /**
+ * 绠鍖栫殑UUID锛屽幓鎺変簡妯嚎锛屼娇鐢ㄦц兘鏇村ソ鐨凾hreadLocalRandom鐢熸垚UUID
+ *
+ * @return 绠鍖栫殑UUID锛屽幓鎺変簡妯嚎
+ */
+ public static String fastSimpleUUID()
+ {
+ return UUID.fastUUID().toString(true);
+ }
+}
diff --git a/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/utils/ReUtil.java b/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/utils/ReUtil.java
new file mode 100644
index 0000000..19c9734
--- /dev/null
+++ b/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/utils/ReUtil.java
@@ -0,0 +1,163 @@
+package com.zhentao.common.core.utils;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import com.zhentao.common.core.text.Convert;
+
+public class ReUtil
+{
+ public final static Pattern GROUP_VAR = Pattern.compile("\\$(\\d+)");
+
+ /**
+ * 姝ｅ垯涓渶瑕佽杞箟鐨勫叧閿瓧
+ */
+ public final static Set RE_KEYS = new HashSet<>(
+ Arrays.asList('$', '(', ')', '*', '+', '.', '[', ']', '?', '\\', '^', '{', '}', '|'));;
+
+ /**
+ * 姝ｅ垯鏇挎崲鎸囧畾鍊
+ * 閫氳繃姝ｅ垯鏌ユ壘鍒板瓧绗︿覆锛岀劧鍚庢妸鍖归厤鍒扮殑瀛楃涓插姞鍏ュ埌replacementTemplate涓紝$1琛ㄧず鍒嗙粍1鐨勫瓧绗︿覆
+ *
+ *
+ * 渚嬪锛氬師瀛楃涓叉槸锛氫腑鏂1234锛屾垜鎯虫妸1234鎹㈡垚(1234)锛屽垯鍙互锛
+ *
+ *
+ * ReUtil.replaceAll("涓枃1234", "(\\d+)", "($1)"))
+ *
+ * 缁撴灉锛氫腑鏂(1234)
+ *
+ *
+ * @param content 鏂囨湰
+ * @param regex 姝ｅ垯
+ * @param replacementTemplate 鏇挎崲鐨勬枃鏈ā鏉匡紝鍙互浣跨敤$1绫讳技鐨勫彉閲忔彁鍙栨鍒欏尮閰嶅嚭鐨勫唴瀹
+ * @return 澶勭悊鍚庣殑鏂囨湰
+ */
+ public static String replaceAll(CharSequence content, String regex, String replacementTemplate)
+ {
+ final Pattern pattern = Pattern.compile(regex, Pattern.DOTALL);
+ return replaceAll(content, pattern, replacementTemplate);
+ }
+
+ /**
+ * 姝ｅ垯鏇挎崲鎸囧畾鍊
+ * 閫氳繃姝ｅ垯鏌ユ壘鍒板瓧绗︿覆锛岀劧鍚庢妸鍖归厤鍒扮殑瀛楃涓插姞鍏ュ埌replacementTemplate涓紝$1琛ㄧず鍒嗙粍1鐨勫瓧绗︿覆
+ *
+ * @param content 鏂囨湰
+ * @param pattern {@link Pattern}
+ * @param replacementTemplate 鏇挎崲鐨勬枃鏈ā鏉匡紝鍙互浣跨敤$1绫讳技鐨勫彉閲忔彁鍙栨鍒欏尮閰嶅嚭鐨勫唴瀹
+ * @return 澶勭悊鍚庣殑鏂囨湰
+ * @since 3.0.4
+ */
+ public static String replaceAll(CharSequence content, Pattern pattern, String replacementTemplate)
+ {
+ if (StringUtils.isEmpty(content))
+ {
+ return StringUtils.EMPTY;
+ }
+
+ final Matcher matcher = pattern.matcher(content);
+ boolean result = matcher.find();
+ if (result)
+ {
+ final Set varNums = findAll(GROUP_VAR, replacementTemplate, 1, new HashSet<>());
+ final StringBuffer sb = new StringBuffer();
+ do
+ {
+ String replacement = replacementTemplate;
+ for (String var : varNums)
+ {
+ int group = Integer.parseInt(var);
+ replacement = replacement.replace("$" + var, matcher.group(group));
+ }
+ matcher.appendReplacement(sb, escape(replacement));
+ result = matcher.find();
+ }
+ while (result);
+ matcher.appendTail(sb);
+ return sb.toString();
+ }
+ return Convert.toStr(content);
+ }
+
+ /**
+ * 鍙栧緱鍐呭涓尮閰嶇殑鎵鏈夌粨鏋
+ *
+ * @param 闆嗗悎绫诲瀷
+ * @param pattern 缂栬瘧鍚庣殑姝ｅ垯妯″紡
+ * @param content 琚煡鎵剧殑鍐呭
+ * @param group 姝ｅ垯鐨勫垎缁
+ * @param collection 杩斿洖鐨勯泦鍚堢被鍨
+ * @return 缁撴灉闆
+ */
+ public static > T findAll(Pattern pattern, CharSequence content, int group,
+ T collection)
+ {
+ if (null == pattern || null == content)
+ {
+ return null;
+ }
+
+ if (null == collection)
+ {
+ throw new NullPointerException("Null collection param provided!");
+ }
+
+ final Matcher matcher = pattern.matcher(content);
+ while (matcher.find())
+ {
+ collection.add(matcher.group(group));
+ }
+ return collection;
+ }
+
+ /**
+ * 杞箟瀛楃锛屽皢姝ｅ垯鐨勫叧閿瓧杞箟
+ *
+ * @param c 瀛楃
+ * @return 杞箟鍚庣殑鏂囨湰
+ */
+ public static String escape(char c)
+ {
+ final StringBuilder builder = new StringBuilder();
+ if (RE_KEYS.contains(c))
+ {
+ builder.append('\\');
+ }
+ builder.append(c);
+ return builder.toString();
+ }
+
+ /**
+ * 杞箟瀛楃涓诧紝灏嗘鍒欑殑鍏抽敭瀛楄浆涔
+ *
+ * @param content 鏂囨湰
+ * @return 杞箟鍚庣殑鏂囨湰
+ */
+ public static String escape(CharSequence content)
+ {
+ if (StringUtils.isBlank(content))
+ {
+ return StringUtils.EMPTY;
+ }
+
+ final StringBuilder builder = new StringBuilder();
+ int len = content.length();
+ char current;
+ for (int i = 0; i < len; i++)
+ {
+ current = content.charAt(i);
+ if (RE_KEYS.contains(current))
+ {
+ builder.append('\\');
+ }
+ builder.append(current);
+ }
+ return builder.toString();
+ }
+
+}
diff --git a/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/utils/SecurityUtils.java b/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/utils/SecurityUtils.java
new file mode 100644
index 0000000..92c8b23
--- /dev/null
+++ b/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/utils/SecurityUtils.java
@@ -0,0 +1,89 @@
+package com.zhentao.common.core.utils;
+
+import javax.servlet.http.HttpServletRequest;
+
+import com.zhentao.common.core.constant.CacheConstants;
+import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
+import com.zhentao.common.core.text.Convert;
+
+/**
+ * 鏉冮檺鑾峰彇宸ュ叿绫
+ *
+ * @author ruoyi
+ */
+public class SecurityUtils
+{
+ /**
+ * 鑾峰彇鐢ㄦ埛
+ */
+ public static String getUsername()
+ {
+ String username = ServletUtils.getRequest().getHeader(CacheConstants.DETAILS_USERNAME);
+ return ServletUtils.urlDecode(username);
+ }
+
+ /**
+ * 鑾峰彇鐢ㄦ埛ID
+ */
+ public static Long getUserId()
+ {
+ return Convert.toLong(ServletUtils.getRequest().getHeader(CacheConstants.DETAILS_USER_ID));
+ }
+
+ /**
+ * 鑾峰彇璇锋眰token
+ */
+ public static String getToken()
+ {
+ return getToken(ServletUtils.getRequest());
+ }
+
+ /**
+ * 鏍规嵁request鑾峰彇璇锋眰token
+ */
+ public static String getToken(HttpServletRequest request)
+ {
+ String token = ServletUtils.getRequest().getHeader(CacheConstants.HEADER);
+ if (StringUtils.isNotEmpty(token) && token.startsWith(CacheConstants.TOKEN_PREFIX))
+ {
+ token = token.replace(CacheConstants.TOKEN_PREFIX, "");
+ }
+ return token;
+ }
+
+ /**
+ * 鏄惁涓虹鐞嗗憳
+ *
+ * @param userId 鐢ㄦ埛ID
+ * @return 缁撴灉
+ */
+ public static boolean isAdmin(Long userId)
+ {
+ return userId != null && 1L == userId;
+ }
+
+ /**
+ * 鐢熸垚BCryptPasswordEncoder瀵嗙爜
+ *
+ * @param password 瀵嗙爜
+ * @return 鍔犲瘑瀛楃涓
+ */
+ public static String encryptPassword(String password)
+ {
+ BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder();
+ return passwordEncoder.encode(password);
+ }
+
+ /**
+ * 鍒ゆ柇瀵嗙爜鏄惁鐩稿悓
+ *
+ * @param rawPassword 鐪熷疄瀵嗙爜
+ * @param encodedPassword 鍔犲瘑鍚庡瓧绗
+ * @return 缁撴灉
+ */
+ public static boolean matchesPassword(String rawPassword, String encodedPassword)
+ {
+ BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder();
+ return passwordEncoder.matches(rawPassword, encodedPassword);
+ }
+}
diff --git a/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/utils/ServletUtils.java b/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/utils/ServletUtils.java
new file mode 100644
index 0000000..bd09a1c
--- /dev/null
+++ b/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/utils/ServletUtils.java
@@ -0,0 +1,217 @@
+package com.zhentao.common.core.utils;
+
+import java.io.IOException;
+import java.io.UnsupportedEncodingException;
+import java.net.URLDecoder;
+import java.net.URLEncoder;
+import java.util.Enumeration;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.servlet.http.HttpSession;
+
+import com.zhentao.common.core.constant.Constants;
+import org.springframework.web.context.request.RequestAttributes;
+import org.springframework.web.context.request.RequestContextHolder;
+import org.springframework.web.context.request.ServletRequestAttributes;
+import com.zhentao.common.core.text.Convert;
+
+/**
+ * 瀹㈡埛绔伐鍏风被
+ *
+ * @author ruoyi
+ */
+public class ServletUtils
+{
+ /**
+ * 鑾峰彇String鍙傛暟
+ */
+ public static String getParameter(String name)
+ {
+ return getRequest().getParameter(name);
+ }
+
+ /**
+ * 鑾峰彇String鍙傛暟
+ */
+ public static String getParameter(String name, String defaultValue)
+ {
+ return Convert.toStr(getRequest().getParameter(name), defaultValue);
+ }
+
+ /**
+ * 鑾峰彇Integer鍙傛暟
+ */
+ public static Integer getParameterToInt(String name)
+ {
+ return Convert.toInt(getRequest().getParameter(name));
+ }
+
+ /**
+ * 鑾峰彇Integer鍙傛暟
+ */
+ public static Integer getParameterToInt(String name, Integer defaultValue)
+ {
+ return Convert.toInt(getRequest().getParameter(name), defaultValue);
+ }
+
+ /**
+ * 鑾峰彇request
+ */
+ public static HttpServletRequest getRequest()
+ {
+ try
+ {
+ return getRequestAttributes().getRequest();
+ }
+ catch (Exception e)
+ {
+ return null;
+ }
+ }
+
+ /**
+ * 鑾峰彇response
+ */
+ public static HttpServletResponse getResponse()
+ {
+ try
+ {
+ return getRequestAttributes().getResponse();
+ }
+ catch (Exception e)
+ {
+ return null;
+ }
+ }
+
+ /**
+ * 鑾峰彇session
+ */
+ public static HttpSession getSession()
+ {
+ return getRequest().getSession();
+ }
+
+ public static ServletRequestAttributes getRequestAttributes()
+ {
+ try
+ {
+ RequestAttributes attributes = RequestContextHolder.getRequestAttributes();
+ return (ServletRequestAttributes) attributes;
+ }
+ catch (Exception e)
+ {
+ return null;
+ }
+ }
+
+ public static Map getHeaders(HttpServletRequest request)
+ {
+ Map map = new LinkedHashMap<>();
+ Enumeration enumeration = request.getHeaderNames();
+ if (enumeration != null)
+ {
+ while (enumeration.hasMoreElements())
+ {
+ String key = enumeration.nextElement();
+ String value = request.getHeader(key);
+ map.put(key, value);
+ }
+ }
+ return map;
+ }
+
+ /**
+ * 灏嗗瓧绗︿覆娓叉煋鍒板鎴风
+ *
+ * @param response 娓叉煋瀵硅薄
+ * @param string 寰呮覆鏌撶殑瀛楃涓
+ * @return null
+ */
+ public static String renderString(HttpServletResponse response, String string)
+ {
+ try
+ {
+ response.setStatus(200);
+ response.setContentType("application/json");
+ response.setCharacterEncoding("utf-8");
+ response.getWriter().print(string);
+ }
+ catch (IOException e)
+ {
+ e.printStackTrace();
+ }
+ return null;
+ }
+
+ /**
+ * 鏄惁鏄疉jax寮傛璇锋眰
+ *
+ * @param request
+ */
+ public static boolean isAjaxRequest(HttpServletRequest request)
+ {
+ String accept = request.getHeader("accept");
+ if (accept != null && accept.indexOf("application/json") != -1)
+ {
+ return true;
+ }
+
+ String xRequestedWith = request.getHeader("X-Requested-With");
+ if (xRequestedWith != null && xRequestedWith.indexOf("XMLHttpRequest") != -1)
+ {
+ return true;
+ }
+
+ String uri = request.getRequestURI();
+ if (StringUtils.inStringIgnoreCase(uri, ".json", ".xml"))
+ {
+ return true;
+ }
+
+ String ajax = request.getParameter("__ajax");
+ if (StringUtils.inStringIgnoreCase(ajax, "json", "xml"))
+ {
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * 鍐呭缂栫爜
+ *
+ * @param str 鍐呭
+ * @return 缂栫爜鍚庣殑鍐呭
+ */
+ public static String urlEncode(String str)
+ {
+ try
+ {
+ return URLEncoder.encode(str, Constants.UTF8);
+ }
+ catch (UnsupportedEncodingException e)
+ {
+ return "";
+ }
+ }
+
+ /**
+ * 鍐呭瑙ｇ爜
+ *
+ * @param str 鍐呭
+ * @return 瑙ｇ爜鍚庣殑鍐呭
+ */
+ public static String urlDecode(String str)
+ {
+ try
+ {
+ return URLDecoder.decode(str, Constants.UTF8);
+ }
+ catch (UnsupportedEncodingException e)
+ {
+ return "";
+ }
+ }
+}
diff --git a/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/utils/SpringUtils.java b/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/utils/SpringUtils.java
new file mode 100644
index 0000000..a9558a7
--- /dev/null
+++ b/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/utils/SpringUtils.java
@@ -0,0 +1,114 @@
+package com.zhentao.common.core.utils;
+
+import org.springframework.aop.framework.AopContext;
+import org.springframework.beans.BeansException;
+import org.springframework.beans.factory.NoSuchBeanDefinitionException;
+import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
+import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
+import org.springframework.stereotype.Component;
+
+/**
+ * spring宸ュ叿绫 鏂逛究鍦ㄩ潪spring绠＄悊鐜涓幏鍙朾ean
+ *
+ * @author ruoyi
+ */
+@Component
+public final class SpringUtils implements BeanFactoryPostProcessor
+{
+ /** Spring搴旂敤涓婁笅鏂囩幆澧 */
+ private static ConfigurableListableBeanFactory beanFactory;
+
+ @Override
+ public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException
+ {
+ SpringUtils.beanFactory = beanFactory;
+ }
+
+ /**
+ * 鑾峰彇瀵硅薄
+ *
+ * @param name
+ * @return Object 涓涓互鎵缁欏悕瀛楁敞鍐岀殑bean鐨勫疄渚
+ * @throws org.springframework.beans.BeansException
+ *
+ */
+ @SuppressWarnings("unchecked")
+ public static T getBean(String name) throws BeansException
+ {
+ return (T) beanFactory.getBean(name);
+ }
+
+ /**
+ * 鑾峰彇绫诲瀷涓簉equiredType鐨勫璞
+ *
+ * @param clz
+ * @return
+ * @throws org.springframework.beans.BeansException
+ *
+ */
+ public static T getBean(Class clz) throws BeansException
+ {
+ T result = (T) beanFactory.getBean(clz);
+ return result;
+ }
+
+ /**
+ * 濡傛灉BeanFactory鍖呭惈涓涓笌鎵缁欏悕绉板尮閰嶇殑bean瀹氫箟锛屽垯杩斿洖true
+ *
+ * @param name
+ * @return boolean
+ */
+ public static boolean containsBean(String name)
+ {
+ return beanFactory.containsBean(name);
+ }
+
+ /**
+ * 鍒ゆ柇浠ョ粰瀹氬悕瀛楁敞鍐岀殑bean瀹氫箟鏄竴涓猻ingleton杩樻槸涓涓猵rototype銆 濡傛灉涓庣粰瀹氬悕瀛楃浉搴旂殑bean瀹氫箟娌℃湁琚壘鍒帮紝灏嗕細鎶涘嚭涓涓紓甯革紙NoSuchBeanDefinitionException锛
+ *
+ * @param name
+ * @return boolean
+ * @throws org.springframework.beans.factory.NoSuchBeanDefinitionException
+ *
+ */
+ public static boolean isSingleton(String name) throws NoSuchBeanDefinitionException
+ {
+ return beanFactory.isSingleton(name);
+ }
+
+ /**
+ * @param name
+ * @return Class 娉ㄥ唽瀵硅薄鐨勭被鍨
+ * @throws org.springframework.beans.factory.NoSuchBeanDefinitionException
+ *
+ */
+ public static Class getType(String name) throws NoSuchBeanDefinitionException
+ {
+ return beanFactory.getType(name);
+ }
+
+ /**
+ * 濡傛灉缁欏畾鐨刡ean鍚嶅瓧鍦╞ean瀹氫箟涓湁鍒悕锛屽垯杩斿洖杩欎簺鍒悕
+ *
+ * @param name
+ * @return
+ * @throws org.springframework.beans.factory.NoSuchBeanDefinitionException
+ *
+ */
+ public static String[] getAliases(String name) throws NoSuchBeanDefinitionException
+ {
+ return beanFactory.getAliases(name);
+ }
+
+ /**
+ * 鑾峰彇aop浠ｇ悊瀵硅薄
+ *
+ * @param invoker
+ * @return
+ */
+ @SuppressWarnings("unchecked")
+ public static T getAopProxy(T invoker)
+ {
+ return (T) AopContext.currentProxy();
+ }
+}
diff --git a/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/utils/StringUtils.java b/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/utils/StringUtils.java
new file mode 100644
index 0000000..63a4a79
--- /dev/null
+++ b/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/utils/StringUtils.java
@@ -0,0 +1,523 @@
+package com.zhentao.common.core.utils;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import com.zhentao.common.core.text.StrFormatter;
+
+/**
+ * 瀛楃涓插伐鍏风被
+ *
+ * @author ruoyi
+ */
+public class StringUtils extends org.apache.commons.lang3.StringUtils
+{
+ /** 绌哄瓧绗︿覆 */
+ private static final String NULLSTR = "";
+
+ /** 涓嬪垝绾 */
+ private static final char SEPARATOR = '_';
+
+ /** 鏄熷彿 */
+ private static final String START = "*";
+
+ /**
+ * 鑾峰彇鍙傛暟涓嶄负绌哄
+ *
+ * @param value defaultValue 瑕佸垽鏂殑value
+ * @return value 杩斿洖鍊
+ */
+ public static T nvl(T value, T defaultValue)
+ {
+ return value != null ? value : defaultValue;
+ }
+
+ /**
+ * * 鍒ゆ柇涓涓狢ollection鏄惁涓虹┖锛 鍖呭惈List锛孲et锛孮ueue
+ *
+ * @param coll 瑕佸垽鏂殑Collection
+ * @return true锛氫负绌 false锛氶潪绌
+ */
+ public static boolean isEmpty(Collection coll)
+ {
+ return isNull(coll) || coll.isEmpty();
+ }
+
+ /**
+ * * 鍒ゆ柇涓涓狢ollection鏄惁闈炵┖锛屽寘鍚獿ist锛孲et锛孮ueue
+ *
+ * @param coll 瑕佸垽鏂殑Collection
+ * @return true锛氶潪绌 false锛氱┖
+ */
+ public static boolean isNotEmpty(Collection coll)
+ {
+ return !isEmpty(coll);
+ }
+
+ /**
+ * * 鍒ゆ柇涓涓璞℃暟缁勬槸鍚︿负绌
+ *
+ * @param objects 瑕佸垽鏂殑瀵硅薄鏁扮粍
+ ** @return true锛氫负绌 false锛氶潪绌
+ */
+ public static boolean isEmpty(Object[] objects)
+ {
+ return isNull(objects) || (objects.length == 0);
+ }
+
+ /**
+ * * 鍒ゆ柇涓涓璞℃暟缁勬槸鍚﹂潪绌
+ *
+ * @param objects 瑕佸垽鏂殑瀵硅薄鏁扮粍
+ * @return true锛氶潪绌 false锛氱┖
+ */
+ public static boolean isNotEmpty(Object[] objects)
+ {
+ return !isEmpty(objects);
+ }
+
+ /**
+ * * 鍒ゆ柇涓涓狹ap鏄惁涓虹┖
+ *
+ * @param map 瑕佸垽鏂殑Map
+ * @return true锛氫负绌 false锛氶潪绌
+ */
+ public static boolean isEmpty(Map map)
+ {
+ return isNull(map) || map.isEmpty();
+ }
+
+ /**
+ * * 鍒ゆ柇涓涓狹ap鏄惁涓虹┖
+ *
+ * @param map 瑕佸垽鏂殑Map
+ * @return true锛氶潪绌 false锛氱┖
+ */
+ public static boolean isNotEmpty(Map map)
+ {
+ return !isEmpty(map);
+ }
+
+ /**
+ * * 鍒ゆ柇涓涓瓧绗︿覆鏄惁涓虹┖涓
+ *
+ * @param str String
+ * @return true锛氫负绌 false锛氶潪绌
+ */
+ public static boolean isEmpty(String str)
+ {
+ return isNull(str) || NULLSTR.equals(str.trim());
+ }
+
+ /**
+ * * 鍒ゆ柇涓涓瓧绗︿覆鏄惁涓洪潪绌轰覆
+ *
+ * @param str String
+ * @return true锛氶潪绌轰覆 false锛氱┖涓
+ */
+ public static boolean isNotEmpty(String str)
+ {
+ return !isEmpty(str);
+ }
+
+ /**
+ * * 鍒ゆ柇涓涓璞℃槸鍚︿负绌
+ *
+ * @param object Object
+ * @return true锛氫负绌 false锛氶潪绌
+ */
+ public static boolean isNull(Object object)
+ {
+ return object == null;
+ }
+
+ /**
+ * * 鍒ゆ柇涓涓璞℃槸鍚﹂潪绌
+ *
+ * @param object Object
+ * @return true锛氶潪绌 false锛氱┖
+ */
+ public static boolean isNotNull(Object object)
+ {
+ return !isNull(object);
+ }
+
+ /**
+ * * 鍒ゆ柇涓涓璞℃槸鍚︽槸鏁扮粍绫诲瀷锛圝ava鍩烘湰鍨嬪埆鐨勬暟缁勶級
+ *
+ * @param object 瀵硅薄
+ * @return true锛氭槸鏁扮粍 false锛氫笉鏄暟缁
+ */
+ public static boolean isArray(Object object)
+ {
+ return isNotNull(object) && object.getClass().isArray();
+ }
+
+ /**
+ * 鍘荤┖鏍
+ */
+ public static String trim(String str)
+ {
+ return (str == null ? "" : str.trim());
+ }
+
+ /**
+ * 鎴彇瀛楃涓
+ *
+ * @param str 瀛楃涓
+ * @param start 寮濮
+ * @return 缁撴灉
+ */
+ public static String substring(final String str, int start)
+ {
+ if (str == null)
+ {
+ return NULLSTR;
+ }
+
+ if (start < 0)
+ {
+ start = str.length() + start;
+ }
+
+ if (start < 0)
+ {
+ start = 0;
+ }
+ if (start > str.length())
+ {
+ return NULLSTR;
+ }
+
+ return str.substring(start);
+ }
+
+ /**
+ * 鎴彇瀛楃涓
+ *
+ * @param str 瀛楃涓
+ * @param start 寮濮
+ * @param end 缁撴潫
+ * @return 缁撴灉
+ */
+ public static String substring(final String str, int start, int end)
+ {
+ if (str == null)
+ {
+ return NULLSTR;
+ }
+
+ if (end < 0)
+ {
+ end = str.length() + end;
+ }
+ if (start < 0)
+ {
+ start = str.length() + start;
+ }
+
+ if (end > str.length())
+ {
+ end = str.length();
+ }
+
+ if (start > end)
+ {
+ return NULLSTR;
+ }
+
+ if (start < 0)
+ {
+ start = 0;
+ }
+ if (end < 0)
+ {
+ end = 0;
+ }
+
+ return str.substring(start, end);
+ }
+
+ /**
+ * 鏍煎紡鍖栨枃鏈, {} 琛ㄧず鍗犱綅绗
+ * 姝ゆ柟娉曞彧鏄畝鍗曞皢鍗犱綅绗 {} 鎸夌収椤哄簭鏇挎崲涓哄弬鏁
+ * 濡傛灉鎯宠緭鍑 {} 浣跨敤 \\杞箟 { 鍗冲彲锛屽鏋滄兂杈撳嚭 {} 涔嬪墠鐨 \ 浣跨敤鍙岃浆涔夌 \\\\ 鍗冲彲
+ * 渚嬶細
+ * 閫氬父浣跨敤锛歠ormat("this is {} for {}", "a", "b") -> this is a for b
+ * 杞箟{}锛 format("this is \\{} for {}", "a", "b") -> this is \{} for a
+ * 杞箟\锛 format("this is \\\\{} for {}", "a", "b") -> this is \a for b
+ *
+ * @param template 鏂囨湰妯℃澘锛岃鏇挎崲鐨勯儴鍒嗙敤 {} 琛ㄧず
+ * @param params 鍙傛暟鍊
+ * @return 鏍煎紡鍖栧悗鐨勬枃鏈
+ */
+ public static String format(String template, Object... params)
+ {
+ if (isEmpty(params) || isEmpty(template))
+ {
+ return template;
+ }
+ return StrFormatter.format(template, params);
+ }
+
+ /**
+ * 涓嬪垝绾胯浆椹煎嘲鍛藉悕
+ */
+ public static String toUnderScoreCase(String str)
+ {
+ if (str == null)
+ {
+ return null;
+ }
+ StringBuilder sb = new StringBuilder();
+ // 鍓嶇疆瀛楃鏄惁澶у啓
+ boolean preCharIsUpperCase = true;
+ // 褰撳墠瀛楃鏄惁澶у啓
+ boolean curreCharIsUpperCase = true;
+ // 涓嬩竴瀛楃鏄惁澶у啓
+ boolean nexteCharIsUpperCase = true;
+ for (int i = 0; i < str.length(); i++)
+ {
+ char c = str.charAt(i);
+ if (i > 0)
+ {
+ preCharIsUpperCase = Character.isUpperCase(str.charAt(i - 1));
+ }
+ else
+ {
+ preCharIsUpperCase = false;
+ }
+
+ curreCharIsUpperCase = Character.isUpperCase(c);
+
+ if (i < (str.length() - 1))
+ {
+ nexteCharIsUpperCase = Character.isUpperCase(str.charAt(i + 1));
+ }
+
+ if (preCharIsUpperCase && curreCharIsUpperCase && !nexteCharIsUpperCase)
+ {
+ sb.append(SEPARATOR);
+ }
+ else if ((i != 0 && !preCharIsUpperCase) && curreCharIsUpperCase)
+ {
+ sb.append(SEPARATOR);
+ }
+ sb.append(Character.toLowerCase(c));
+ }
+
+ return sb.toString();
+ }
+
+ /**
+ * 鏄惁鍖呭惈瀛楃涓
+ *
+ * @param str 楠岃瘉瀛楃涓
+ * @param strs 瀛楃涓茬粍
+ * @return 鍖呭惈杩斿洖true
+ */
+ public static boolean inStringIgnoreCase(String str, String... strs)
+ {
+ if (str != null && strs != null)
+ {
+ for (String s : strs)
+ {
+ if (str.equalsIgnoreCase(trim(s)))
+ {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ /**
+ * 灏嗕笅鍒掔嚎澶у啓鏂瑰紡鍛藉悕鐨勫瓧绗︿覆杞崲涓洪┘宄板紡銆傚鏋滆浆鎹㈠墠鐨勪笅鍒掔嚎澶у啓鏂瑰紡鍛藉悕鐨勫瓧绗︿覆涓虹┖锛屽垯杩斿洖绌哄瓧绗︿覆銆 渚嬪锛欻ELLO_WORLD->HelloWorld
+ *
+ * @param name 杞崲鍓嶇殑涓嬪垝绾垮ぇ鍐欐柟寮忓懡鍚嶇殑瀛楃涓
+ * @return 杞崲鍚庣殑椹煎嘲寮忓懡鍚嶇殑瀛楃涓
+ */
+ public static String convertToCamelCase(String name)
+ {
+ StringBuilder result = new StringBuilder();
+ // 蹇熸鏌
+ if (name == null || name.isEmpty())
+ {
+ // 娌″繀瑕佽浆鎹
+ return "";
+ }
+ else if (!name.contains("_"))
+ {
+ // 涓嶅惈涓嬪垝绾匡紝浠呭皢棣栧瓧姣嶅ぇ鍐
+ return name.substring(0, 1).toUpperCase() + name.substring(1);
+ }
+ // 鐢ㄤ笅鍒掔嚎灏嗗師濮嬪瓧绗︿覆鍒嗗壊
+ String[] camels = name.split("_");
+ for (String camel : camels)
+ {
+ // 璺宠繃鍘熷瀛楃涓蹭腑寮澶淬佺粨灏剧殑涓嬫崲绾挎垨鍙岄噸涓嬪垝绾
+ if (camel.isEmpty())
+ {
+ continue;
+ }
+ // 棣栧瓧姣嶅ぇ鍐
+ result.append(camel.substring(0, 1).toUpperCase());
+ result.append(camel.substring(1).toLowerCase());
+ }
+ return result.toString();
+ }
+
+ /**
+ * 椹煎嘲寮忓懡鍚嶆硶 渚嬪锛歶ser_name->userName
+ */
+ public static String toCamelCase(String s)
+ {
+ if (s == null)
+ {
+ return null;
+ }
+ s = s.toLowerCase();
+ StringBuilder sb = new StringBuilder(s.length());
+ boolean upperCase = false;
+ for (int i = 0; i < s.length(); i++)
+ {
+ char c = s.charAt(i);
+
+ if (c == SEPARATOR)
+ {
+ upperCase = true;
+ }
+ else if (upperCase)
+ {
+ sb.append(Character.toUpperCase(c));
+ upperCase = false;
+ }
+ else
+ {
+ sb.append(c);
+ }
+ }
+ return sb.toString();
+ }
+
+ /**
+ * 鏌ユ壘鎸囧畾瀛楃涓叉槸鍚﹀尮閰嶆寚瀹氬瓧绗︿覆鍒楄〃涓殑浠绘剰涓涓瓧绗︿覆
+ *
+ * @param str 鎸囧畾瀛楃涓
+ * @param strs 闇瑕佹鏌ョ殑瀛楃涓叉暟缁
+ * @return 鏄惁鍖归厤
+ */
+ public static boolean matches(String str, List strs)
+ {
+ if (isEmpty(str) || isEmpty(strs))
+ {
+ return false;
+ }
+ for (String testStr : strs)
+ {
+ if (matches(str, testStr))
+ {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * 鏌ユ壘鎸囧畾瀛楃涓叉槸鍚﹀尮閰嶆寚瀹氬瓧绗︿覆鏁扮粍涓殑浠绘剰涓涓瓧绗︿覆
+ *
+ * @param str 鎸囧畾瀛楃涓
+ * @param strs 闇瑕佹鏌ョ殑瀛楃涓叉暟缁
+ * @return 鏄惁鍖归厤
+ */
+ public static boolean matches(String str, String... strs)
+ {
+ if (isEmpty(str) || isEmpty(strs))
+ {
+ return false;
+ }
+ for (String testStr : strs)
+ {
+ if (matches(str, testStr))
+ {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * 鏌ユ壘鎸囧畾瀛楃涓叉槸鍚﹀尮閰
+ *
+ * @param str 鎸囧畾瀛楃涓
+ * @param pattern 闇瑕佹鏌ョ殑瀛楃涓
+ * @return 鏄惁鍖归厤
+ */
+ public static boolean matches(String str, String pattern)
+ {
+ if (isEmpty(pattern) || isEmpty(str))
+ {
+ return false;
+ }
+
+ pattern = pattern.replaceAll("\\s*", ""); // 鏇挎崲绌烘牸
+ int beginOffset = 0; // pattern鎴彇寮濮嬩綅缃
+ int formerStarOffset = -1; // 鍓嶆槦鍙风殑鍋忕Щ浣嶇疆
+ int latterStarOffset = -1; // 鍚庢槦鍙风殑鍋忕Щ浣嶇疆
+
+ String remainingURI = str;
+ String prefixPattern = "";
+ String suffixPattern = "";
+
+ boolean result = false;
+ do
+ {
+ formerStarOffset = indexOf(pattern, START, beginOffset);
+ prefixPattern = substring(pattern, beginOffset, formerStarOffset > -1 ? formerStarOffset : pattern.length());
+
+ // 鍖归厤鍓嶇紑Pattern
+ result = remainingURI.contains(prefixPattern);
+ // 宸茬粡娌℃湁鏄熷彿锛岀洿鎺ヨ繑鍥
+ if (formerStarOffset == -1)
+ {
+ return result;
+ }
+
+ // 鍖归厤澶辫触锛岀洿鎺ヨ繑鍥
+ if (!result)
+ return false;
+
+ if (!isEmpty(prefixPattern))
+ {
+ remainingURI = substringAfter(str, prefixPattern);
+ }
+
+ // 鍖归厤鍚庣紑Pattern
+ latterStarOffset = indexOf(pattern, START, formerStarOffset + 1);
+ suffixPattern = substring(pattern, formerStarOffset + 1, latterStarOffset > -1 ? latterStarOffset : pattern.length());
+
+ result = remainingURI.contains(suffixPattern);
+ // 鍖归厤澶辫触锛岀洿鎺ヨ繑鍥
+ if (!result)
+ return false;
+
+ if (!isEmpty(suffixPattern))
+ {
+ remainingURI = substringAfter(str, suffixPattern);
+ }
+
+ // 绉诲姩鎸囬拡
+ beginOffset = latterStarOffset + 1;
+
+ }
+ while (!isEmpty(suffixPattern) && !isEmpty(remainingURI));
+
+ return true;
+ }
+
+ @SuppressWarnings("unchecked")
+ public static T cast(Object obj)
+ {
+ return (T) obj;
+ }
+}
diff --git a/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/utils/bean/BeanUtils.java b/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/utils/bean/BeanUtils.java
new file mode 100644
index 0000000..ceceff2
--- /dev/null
+++ b/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/utils/bean/BeanUtils.java
@@ -0,0 +1,110 @@
+package com.zhentao.common.core.utils.bean;
+
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Bean 宸ュ叿绫
+ *
+ * @author ruoyi
+ */
+public class BeanUtils extends org.springframework.beans.BeanUtils
+{
+ /** Bean鏂规硶鍚嶄腑灞炴у悕寮濮嬬殑涓嬫爣 */
+ private static final int BEAN_METHOD_PROP_INDEX = 3;
+
+ /** * 鍖归厤getter鏂规硶鐨勬鍒欒〃杈惧紡 */
+ private static final Pattern GET_PATTERN = Pattern.compile("get(\\p{javaUpperCase}\\w*)");
+
+ /** * 鍖归厤setter鏂规硶鐨勬鍒欒〃杈惧紡 */
+ private static final Pattern SET_PATTERN = Pattern.compile("set(\\p{javaUpperCase}\\w*)");
+
+ /**
+ * Bean灞炴у鍒跺伐鍏锋柟娉曘
+ *
+ * @param dest 鐩爣瀵硅薄
+ * @param src 婧愬璞
+ */
+ public static void copyBeanProp(Object dest, Object src)
+ {
+ try
+ {
+ copyProperties(src, dest);
+ }
+ catch (Exception e)
+ {
+ e.printStackTrace();
+ }
+ }
+
+ /**
+ * 鑾峰彇瀵硅薄鐨剆etter鏂规硶銆
+ *
+ * @param obj 瀵硅薄
+ * @return 瀵硅薄鐨剆etter鏂规硶鍒楄〃
+ */
+ public static List getSetterMethods(Object obj)
+ {
+ // setter鏂规硶鍒楄〃
+ List setterMethods = new ArrayList();
+
+ // 鑾峰彇鎵鏈夋柟娉
+ Method[] methods = obj.getClass().getMethods();
+
+ // 鏌ユ壘setter鏂规硶
+
+ for (Method method : methods)
+ {
+ Matcher m = SET_PATTERN.matcher(method.getName());
+ if (m.matches() && (method.getParameterTypes().length == 1))
+ {
+ setterMethods.add(method);
+ }
+ }
+ // 杩斿洖setter鏂规硶鍒楄〃
+ return setterMethods;
+ }
+
+ /**
+ * 鑾峰彇瀵硅薄鐨刧etter鏂规硶銆
+ *
+ * @param obj 瀵硅薄
+ * @return 瀵硅薄鐨刧etter鏂规硶鍒楄〃
+ */
+
+ public static List getGetterMethods(Object obj)
+ {
+ // getter鏂规硶鍒楄〃
+ List getterMethods = new ArrayList();
+ // 鑾峰彇鎵鏈夋柟娉
+ Method[] methods = obj.getClass().getMethods();
+ // 鏌ユ壘getter鏂规硶
+ for (Method method : methods)
+ {
+ Matcher m = GET_PATTERN.matcher(method.getName());
+ if (m.matches() && (method.getParameterTypes().length == 0))
+ {
+ getterMethods.add(method);
+ }
+ }
+ // 杩斿洖getter鏂规硶鍒楄〃
+ return getterMethods;
+ }
+
+ /**
+ * 妫鏌ean鏂规硶鍚嶄腑鐨勫睘鎬у悕鏄惁鐩哥瓑銆
+ * 濡俫etName()鍜宻etName()灞炴у悕涓鏍凤紝getName()鍜宻etAge()灞炴у悕涓嶄竴鏍枫
+ *
+ * @param m1 鏂规硶鍚1
+ * @param m2 鏂规硶鍚2
+ * @return 灞炴у悕涓鏍疯繑鍥瀟rue锛屽惁鍒欒繑鍥瀎alse
+ */
+
+ public static boolean isMethodPropEquals(String m1, String m2)
+ {
+ return m1.substring(BEAN_METHOD_PROP_INDEX).equals(m2.substring(BEAN_METHOD_PROP_INDEX));
+ }
+}
diff --git a/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/utils/file/FileTypeUtils.java b/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/utils/file/FileTypeUtils.java
new file mode 100644
index 0000000..3250bb6
--- /dev/null
+++ b/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/utils/file/FileTypeUtils.java
@@ -0,0 +1,76 @@
+package com.zhentao.common.core.utils.file;
+
+import java.io.File;
+import org.apache.commons.lang3.StringUtils;
+
+/**
+ * 鏂囦欢绫诲瀷宸ュ叿绫
+ *
+ * @author ruoyi
+ */
+public class FileTypeUtils
+{
+ /**
+ * 鑾峰彇鏂囦欢绫诲瀷
+ *
+ * 渚嬪: ruoyi.txt, 杩斿洖: txt
+ *
+ * @param file 鏂囦欢鍚
+ * @return 鍚庣紑锛堜笉鍚".")
+ */
+ public static String getFileType(File file)
+ {
+ if (null == file)
+ {
+ return StringUtils.EMPTY;
+ }
+ return getFileType(file.getName());
+ }
+
+ /**
+ * 鑾峰彇鏂囦欢绫诲瀷
+ *
+ * 渚嬪: ruoyi.txt, 杩斿洖: txt
+ *
+ * @param fileName 鏂囦欢鍚
+ * @return 鍚庣紑锛堜笉鍚".")
+ */
+ public static String getFileType(String fileName)
+ {
+ int separatorIndex = fileName.lastIndexOf(".");
+ if (separatorIndex < 0)
+ {
+ return "";
+ }
+ return fileName.substring(separatorIndex + 1).toLowerCase();
+ }
+
+ /**
+ * 鑾峰彇鏂囦欢绫诲瀷
+ *
+ * @param photoByte 鏂囦欢瀛楄妭鐮
+ * @return 鍚庣紑锛堜笉鍚".")
+ */
+ public static String getFileExtendName(byte[] photoByte)
+ {
+ String strFileExtendName = "JPG";
+ if ((photoByte[0] == 71) && (photoByte[1] == 73) && (photoByte[2] == 70) && (photoByte[3] == 56)
+ && ((photoByte[4] == 55) || (photoByte[4] == 57)) && (photoByte[5] == 97))
+ {
+ strFileExtendName = "GIF";
+ }
+ else if ((photoByte[6] == 74) && (photoByte[7] == 70) && (photoByte[8] == 73) && (photoByte[9] == 70))
+ {
+ strFileExtendName = "JPG";
+ }
+ else if ((photoByte[0] == 66) && (photoByte[1] == 77))
+ {
+ strFileExtendName = "BMP";
+ }
+ else if ((photoByte[1] == 80) && (photoByte[2] == 78) && (photoByte[3] == 71))
+ {
+ strFileExtendName = "PNG";
+ }
+ return strFileExtendName;
+ }
+}
diff --git a/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/utils/file/FileUtils.java b/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/utils/file/FileUtils.java
new file mode 100644
index 0000000..f287277
--- /dev/null
+++ b/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/utils/file/FileUtils.java
@@ -0,0 +1,260 @@
+package com.zhentao.common.core.utils.file;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.UnsupportedEncodingException;
+import java.net.URLEncoder;
+import java.nio.charset.StandardCharsets;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import org.apache.commons.lang3.ArrayUtils;
+import com.zhentao.common.core.utils.StringUtils;
+
+/**
+ * 鏂囦欢澶勭悊宸ュ叿绫
+ *
+ * @author ruoyi
+ */
+public class FileUtils extends org.apache.commons.io.FileUtils
+{
+ /** 瀛楃甯搁噺锛氭枩鏉 {@code '/'} */
+ public static final char SLASH = '/';
+
+ /** 瀛楃甯搁噺锛氬弽鏂滄潬 {@code '\\'} */
+ public static final char BACKSLASH = '\\';
+
+ public static String FILENAME_PATTERN = "[a-zA-Z0-9_\\-\\|\\.\\u4e00-\\u9fa5]+";
+
+ /**
+ * 杈撳嚭鎸囧畾鏂囦欢鐨刡yte鏁扮粍
+ *
+ * @param filePath 鏂囦欢璺緞
+ * @param os 杈撳嚭娴
+ * @return
+ */
+ public static void writeBytes(String filePath, OutputStream os) throws IOException
+ {
+ FileInputStream fis = null;
+ try
+ {
+ File file = new File(filePath);
+ if (!file.exists())
+ {
+ throw new FileNotFoundException(filePath);
+ }
+ fis = new FileInputStream(file);
+ byte[] b = new byte[1024];
+ int length;
+ while ((length = fis.read(b)) > 0)
+ {
+ os.write(b, 0, length);
+ }
+ }
+ catch (IOException e)
+ {
+ throw e;
+ }
+ finally
+ {
+ if (os != null)
+ {
+ try
+ {
+ os.close();
+ }
+ catch (IOException e1)
+ {
+ e1.printStackTrace();
+ }
+ }
+ if (fis != null)
+ {
+ try
+ {
+ fis.close();
+ }
+ catch (IOException e1)
+ {
+ e1.printStackTrace();
+ }
+ }
+ }
+ }
+
+ /**
+ * 鍒犻櫎鏂囦欢
+ *
+ * @param filePath 鏂囦欢
+ * @return
+ */
+ public static boolean deleteFile(String filePath)
+ {
+ boolean flag = false;
+ File file = new File(filePath);
+ // 璺緞涓烘枃浠朵笖涓嶄负绌哄垯杩涜鍒犻櫎
+ if (file.isFile() && file.exists())
+ {
+ file.delete();
+ flag = true;
+ }
+ return flag;
+ }
+
+ /**
+ * 鏂囦欢鍚嶇О楠岃瘉
+ *
+ * @param filename 鏂囦欢鍚嶇О
+ * @return true 姝ｅ父 false 闈炴硶
+ */
+ public static boolean isValidFilename(String filename)
+ {
+ return filename.matches(FILENAME_PATTERN);
+ }
+
+ /**
+ * 妫鏌ユ枃浠舵槸鍚﹀彲涓嬭浇
+ *
+ * @param resource 闇瑕佷笅杞界殑鏂囦欢
+ * @return true 姝ｅ父 false 闈炴硶
+ */
+ public static boolean checkAllowDownload(String resource)
+ {
+ // 绂佹鐩綍涓婅烦绾у埆
+ if (StringUtils.contains(resource, ".."))
+ {
+ return false;
+ }
+
+ // 妫鏌ュ厑璁镐笅杞界殑鏂囦欢瑙勫垯
+ if (ArrayUtils.contains(MimeTypeUtils.DEFAULT_ALLOWED_EXTENSION, FileTypeUtils.getFileType(resource)))
+ {
+ return true;
+ }
+
+ // 涓嶅湪鍏佽涓嬭浇鐨勬枃浠惰鍒
+ return false;
+ }
+
+ /**
+ * 涓嬭浇鏂囦欢鍚嶉噸鏂扮紪鐮
+ *
+ * @param request 璇锋眰瀵硅薄
+ * @param fileName 鏂囦欢鍚
+ * @return 缂栫爜鍚庣殑鏂囦欢鍚
+ */
+ public static String setFileDownloadHeader(HttpServletRequest request, String fileName) throws UnsupportedEncodingException
+ {
+ final String agent = request.getHeader("USER-AGENT");
+ String filename = fileName;
+ if (agent.contains("MSIE"))
+ {
+ // IE娴忚鍣
+ filename = URLEncoder.encode(filename, "utf-8");
+ filename = filename.replace("+", " ");
+ }
+ else if (agent.contains("Firefox"))
+ {
+ // 鐏嫄娴忚鍣
+ filename = new String(fileName.getBytes(), "ISO8859-1");
+ }
+ else if (agent.contains("Chrome"))
+ {
+ // google娴忚鍣
+ filename = URLEncoder.encode(filename, "utf-8");
+ }
+ else
+ {
+ // 鍏跺畠娴忚鍣
+ filename = URLEncoder.encode(filename, "utf-8");
+ }
+ return filename;
+ }
+
+ /**
+ * 杩斿洖鏂囦欢鍚
+ *
+ * @param filePath 鏂囦欢
+ * @return 鏂囦欢鍚
+ */
+ public static String getName(String filePath)
+ {
+ if (null == filePath)
+ {
+ return null;
+ }
+ int len = filePath.length();
+ if (0 == len)
+ {
+ return filePath;
+ }
+ if (isFileSeparator(filePath.charAt(len - 1)))
+ {
+ // 浠ュ垎闅旂缁撳熬鐨勫幓鎺夌粨灏惧垎闅旂
+ len--;
+ }
+
+ int begin = 0;
+ char c;
+ for (int i = len - 1; i > -1; i--)
+ {
+ c = filePath.charAt(i);
+ if (isFileSeparator(c))
+ {
+ // 鏌ユ壘鏈鍚庝竴涓矾寰勫垎闅旂锛/鎴栬匼锛
+ begin = i + 1;
+ break;
+ }
+ }
+
+ return filePath.substring(begin, len);
+ }
+
+ /**
+ * 鏄惁涓篧indows鎴栬匧inux锛圲nix锛夋枃浠跺垎闅旂
+ * Windows骞冲彴涓嬪垎闅旂涓篭锛孡inux锛圲nix锛変负/
+ *
+ * @param c 瀛楃
+ * @return 鏄惁涓篧indows鎴栬匧inux锛圲nix锛夋枃浠跺垎闅旂
+ */
+ public static boolean isFileSeparator(char c)
+ {
+ return SLASH == c || BACKSLASH == c;
+ }
+
+ /**
+ * 涓嬭浇鏂囦欢鍚嶉噸鏂扮紪鐮
+ *
+ * @param response 鍝嶅簲瀵硅薄
+ * @param realFileName 鐪熷疄鏂囦欢鍚
+ * @return
+ */
+ public static void setAttachmentResponseHeader(HttpServletResponse response, String realFileName) throws UnsupportedEncodingException
+ {
+ String percentEncodedFileName = percentEncode(realFileName);
+
+ StringBuilder contentDispositionValue = new StringBuilder();
+ contentDispositionValue.append("attachment; filename=")
+ .append(percentEncodedFileName)
+ .append(";")
+ .append("filename*=")
+ .append("utf-8''")
+ .append(percentEncodedFileName);
+
+ response.setHeader("Content-disposition", contentDispositionValue.toString());
+ }
+
+ /**
+ * 鐧惧垎鍙风紪鐮佸伐鍏锋柟娉
+ *
+ * @param s 闇瑕佺櫨鍒嗗彿缂栫爜鐨勫瓧绗︿覆
+ * @return 鐧惧垎鍙风紪鐮佸悗鐨勫瓧绗︿覆
+ */
+ public static String percentEncode(String s) throws UnsupportedEncodingException
+ {
+ String encode = URLEncoder.encode(s, StandardCharsets.UTF_8.toString());
+ return encode.replaceAll("\\+", "%20");
+ }
+}
diff --git a/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/utils/file/ImageUtils.java b/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/utils/file/ImageUtils.java
new file mode 100644
index 0000000..82e0adb
--- /dev/null
+++ b/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/utils/file/ImageUtils.java
@@ -0,0 +1,86 @@
+package com.zhentao.common.core.utils.file;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.InputStream;
+import java.net.URL;
+import java.net.URLConnection;
+import java.util.Arrays;
+import org.apache.poi.util.IOUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * 鍥剧墖澶勭悊宸ュ叿绫
+ *
+ * @author ruoyi
+ */
+public class ImageUtils
+{
+ private static final Logger log = LoggerFactory.getLogger(ImageUtils.class);
+
+ public static byte[] getImage(String imagePath)
+ {
+ InputStream is = getFile(imagePath);
+ try
+ {
+ return IOUtils.toByteArray(is);
+ }
+ catch (Exception e)
+ {
+ log.error("鍥剧墖鍔犺浇寮傚父 {}", e);
+ return null;
+ }
+ finally
+ {
+ IOUtils.closeQuietly(is);
+ }
+ }
+
+ public static InputStream getFile(String imagePath)
+ {
+ try
+ {
+ byte[] result = readFile(imagePath);
+ result = Arrays.copyOf(result, result.length);
+ return new ByteArrayInputStream(result);
+ }
+ catch (Exception e)
+ {
+ log.error("鑾峰彇鍥剧墖寮傚父 {}", e);
+ }
+ return null;
+ }
+
+ /**
+ * 璇诲彇鏂囦欢涓哄瓧鑺傛暟鎹
+ *
+ * @param key 鍦板潃
+ * @return 瀛楄妭鏁版嵁
+ */
+ public static byte[] readFile(String url)
+ {
+ InputStream in = null;
+ ByteArrayOutputStream baos = null;
+ try
+ {
+ // 缃戠粶鍦板潃
+ URL urlObj = new URL(url);
+ URLConnection urlConnection = urlObj.openConnection();
+ urlConnection.setConnectTimeout(30 * 1000);
+ urlConnection.setReadTimeout(60 * 1000);
+ urlConnection.setDoInput(true);
+ in = urlConnection.getInputStream();
+ return IOUtils.toByteArray(in);
+ }
+ catch (Exception e)
+ {
+ log.error("璁块棶鏂囦欢寮傚父 {}", e);
+ return null;
+ }
+ finally
+ {
+ IOUtils.closeQuietly(baos);
+ }
+ }
+}
diff --git a/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/utils/file/MimeTypeUtils.java b/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/utils/file/MimeTypeUtils.java
new file mode 100644
index 0000000..8cff3db
--- /dev/null
+++ b/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/utils/file/MimeTypeUtils.java
@@ -0,0 +1,59 @@
+package com.zhentao.common.core.utils.file;
+
+/**
+ * 濯掍綋绫诲瀷宸ュ叿绫
+ *
+ * @author ruoyi
+ */
+public class MimeTypeUtils
+{
+ public static final String IMAGE_PNG = "image/png";
+
+ public static final String IMAGE_JPG = "image/jpg";
+
+ public static final String IMAGE_JPEG = "image/jpeg";
+
+ public static final String IMAGE_BMP = "image/bmp";
+
+ public static final String IMAGE_GIF = "image/gif";
+
+ public static final String[] IMAGE_EXTENSION = { "bmp", "gif", "jpg", "jpeg", "png" };
+
+ public static final String[] FLASH_EXTENSION = { "swf", "flv" };
+
+ public static final String[] MEDIA_EXTENSION = { "swf", "flv", "mp3", "wav", "wma", "wmv", "mid", "avi", "mpg",
+ "asf", "rm", "rmvb" };
+
+ public static final String[] VIDEO_EXTENSION = { "mp4", "avi", "rmvb" };
+
+ public static final String[] DEFAULT_ALLOWED_EXTENSION = {
+ // 鍥剧墖
+ "bmp", "gif", "jpg", "jpeg", "png",
+ // word excel powerpoint
+ "doc", "docx", "xls", "xlsx", "ppt", "pptx", "html", "htm", "txt",
+ // 鍘嬬缉鏂囦欢
+ "rar", "zip", "gz", "bz2",
+ // 瑙嗛鏍煎紡
+ "mp4", "avi", "rmvb",
+ // pdf
+ "pdf" };
+
+ public static String getExtension(String prefix)
+ {
+ switch (prefix)
+ {
+ case IMAGE_PNG:
+ return "png";
+ case IMAGE_JPG:
+ return "jpg";
+ case IMAGE_JPEG:
+ return "jpeg";
+ case IMAGE_BMP:
+ return "bmp";
+ case IMAGE_GIF:
+ return "gif";
+ default:
+ return "";
+ }
+ }
+}
diff --git a/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/utils/ip/IpUtils.java b/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/utils/ip/IpUtils.java
new file mode 100644
index 0000000..431b925
--- /dev/null
+++ b/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/utils/ip/IpUtils.java
@@ -0,0 +1,204 @@
+package com.zhentao.common.core.utils.ip;
+
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+import javax.servlet.http.HttpServletRequest;
+import com.zhentao.common.core.utils.StringUtils;
+
+/**
+ * 鑾峰彇IP鏂规硶
+ *
+ * @author ruoyi
+ */
+public class IpUtils
+{
+ public static String getIpAddr(HttpServletRequest request)
+ {
+ String ip = null;
+
+ // X-Forwarded-For锛歋quid 鏈嶅姟浠ｇ悊
+ String ipAddresses = request.getHeader("X-Forwarded-For");
+ if (ipAddresses == null || ipAddresses.length() == 0 || "unknown".equalsIgnoreCase(ipAddresses))
+ {
+ // Proxy-Client-IP锛歛pache 鏈嶅姟浠ｇ悊
+ ipAddresses = request.getHeader("Proxy-Client-IP");
+ }
+ if (ipAddresses == null || ipAddresses.length() == 0 || "unknown".equalsIgnoreCase(ipAddresses))
+ {
+ // WL-Proxy-Client-IP锛歸eblogic 鏈嶅姟浠ｇ悊
+ ipAddresses = request.getHeader("WL-Proxy-Client-IP");
+ }
+ if (ipAddresses == null || ipAddresses.length() == 0 || "unknown".equalsIgnoreCase(ipAddresses))
+ {
+ // HTTP_CLIENT_IP锛氭湁浜涗唬鐞嗘湇鍔″櫒
+ ipAddresses = request.getHeader("HTTP_CLIENT_IP");
+ }
+ if (ipAddresses == null || ipAddresses.length() == 0 || "unknown".equalsIgnoreCase(ipAddresses))
+ {
+ // X-Real-IP锛歯ginx鏈嶅姟浠ｇ悊
+ ipAddresses = request.getHeader("X-Real-IP");
+ }
+
+ // 鏈変簺缃戠粶閫氳繃澶氬眰浠ｇ悊锛岄偅涔堣幏鍙栧埌鐨刬p灏变細鏈夊涓紝涓鑸兘鏄氳繃閫楀彿锛,锛夊垎鍓插紑鏉ワ紝骞朵笖绗竴涓猧p涓哄鎴风鐨勭湡瀹濱P
+ if (ipAddresses != null && ipAddresses.length() != 0)
+ {
+ ip = ipAddresses.split(",")[0];
+ }
+
+ // 杩樻槸涓嶈兘鑾峰彇鍒帮紝鏈鍚庡啀閫氳繃request.getRemoteAddr();鑾峰彇
+ if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ipAddresses))
+ {
+ ip = request.getRemoteAddr();
+ }
+ return ip.equals("0:0:0:0:0:0:0:1") ? "127.0.0.1" : ip;
+ }
+
+ public static boolean internalIp(String ip)
+ {
+ byte[] addr = textToNumericFormatV4(ip);
+ return internalIp(addr) || "127.0.0.1".equals(ip);
+ }
+
+ private static boolean internalIp(byte[] addr)
+ {
+ if (StringUtils.isNull(addr) || addr.length < 2)
+ {
+ return true;
+ }
+ final byte b0 = addr[0];
+ final byte b1 = addr[1];
+ // 10.x.x.x/8
+ final byte SECTION_1 = 0x0A;
+ // 172.16.x.x/12
+ final byte SECTION_2 = (byte) 0xAC;
+ final byte SECTION_3 = (byte) 0x10;
+ final byte SECTION_4 = (byte) 0x1F;
+ // 192.168.x.x/16
+ final byte SECTION_5 = (byte) 0xC0;
+ final byte SECTION_6 = (byte) 0xA8;
+ switch (b0)
+ {
+ case SECTION_1:
+ return true;
+ case SECTION_2:
+ if (b1 >= SECTION_3 && b1 <= SECTION_4)
+ {
+ return true;
+ }
+ case SECTION_5:
+ switch (b1)
+ {
+ case SECTION_6:
+ return true;
+ }
+ default:
+ return false;
+ }
+ }
+
+ /**
+ * 灏咺Pv4鍦板潃杞崲鎴愬瓧鑺
+ *
+ * @param text IPv4鍦板潃
+ * @return byte 瀛楄妭
+ */
+ public static byte[] textToNumericFormatV4(String text)
+ {
+ if (text.length() == 0)
+ {
+ return null;
+ }
+
+ byte[] bytes = new byte[4];
+ String[] elements = text.split("\\.", -1);
+ try
+ {
+ long l;
+ int i;
+ switch (elements.length)
+ {
+ case 1:
+ l = Long.parseLong(elements[0]);
+ if ((l < 0L) || (l > 4294967295L)){
+ return null;
+ }
+ bytes[0] = (byte) (int) (l >> 24 & 0xFF);
+ bytes[1] = (byte) (int) ((l & 0xFFFFFF) >> 16 & 0xFF);
+ bytes[2] = (byte) (int) ((l & 0xFFFF) >> 8 & 0xFF);
+ bytes[3] = (byte) (int) (l & 0xFF);
+ break;
+ case 2:
+ l = Integer.parseInt(elements[0]);
+ if ((l < 0L) || (l > 255L)) {
+ return null;
+ }
+ bytes[0] = (byte) (int) (l & 0xFF);
+ l = Integer.parseInt(elements[1]);
+ if ((l < 0L) || (l > 16777215L)) {
+ return null;
+ }
+ bytes[1] = (byte) (int) (l >> 16 & 0xFF);
+ bytes[2] = (byte) (int) ((l & 0xFFFF) >> 8 & 0xFF);
+ bytes[3] = (byte) (int) (l & 0xFF);
+ break;
+ case 3:
+ for (i = 0; i < 2; ++i)
+ {
+ l = Integer.parseInt(elements[i]);
+ if ((l < 0L) || (l > 255L)) {
+ return null;
+ }
+ bytes[i] = (byte) (int) (l & 0xFF);
+ }
+ l = Integer.parseInt(elements[2]);
+ if ((l < 0L) || (l > 65535L)) {
+ return null;
+ }
+ bytes[2] = (byte) (int) (l >> 8 & 0xFF);
+ bytes[3] = (byte) (int) (l & 0xFF);
+ break;
+ case 4:
+ for (i = 0; i < 4; ++i)
+ {
+ l = Integer.parseInt(elements[i]);
+ if ((l < 0L) || (l > 255L)) {
+ return null;
+ }
+ bytes[i] = (byte) (int) (l & 0xFF);
+ }
+ break;
+ default:
+ return null;
+ }
+ }
+ catch (NumberFormatException e)
+ {
+ return null;
+ }
+ return bytes;
+ }
+
+ public static String getHostIp()
+ {
+ try
+ {
+ return InetAddress.getLocalHost().getHostAddress();
+ }
+ catch (UnknownHostException e)
+ {
+ }
+ return "127.0.0.1";
+ }
+
+ public static String getHostName()
+ {
+ try
+ {
+ return InetAddress.getLocalHost().getHostName();
+ }
+ catch (UnknownHostException e)
+ {
+ }
+ return "鏈煡";
+ }
+}
diff --git a/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/utils/poi/ExcelUtil.java b/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/utils/poi/ExcelUtil.java
new file mode 100644
index 0000000..488200f
--- /dev/null
+++ b/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/utils/poi/ExcelUtil.java
@@ -0,0 +1,1027 @@
+package com.zhentao.common.core.utils.poi;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.lang.reflect.Field;
+import java.math.BigDecimal;
+import java.text.DecimalFormat;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+import javax.servlet.http.HttpServletResponse;
+
+import com.zhentao.common.core.annotation.Excel;
+import com.zhentao.common.core.annotation.Excels;
+import com.zhentao.common.core.utils.reflect.ReflectUtils;
+import org.apache.poi.ss.usermodel.BorderStyle;
+import org.apache.poi.ss.usermodel.Cell;
+import org.apache.poi.ss.usermodel.CellStyle;
+import org.apache.poi.ss.usermodel.CellType;
+import org.apache.poi.ss.usermodel.ClientAnchor;
+import org.apache.poi.ss.usermodel.DataValidation;
+import org.apache.poi.ss.usermodel.DataValidationConstraint;
+import org.apache.poi.ss.usermodel.DataValidationHelper;
+import org.apache.poi.ss.usermodel.DateUtil;
+import org.apache.poi.ss.usermodel.Drawing;
+import org.apache.poi.ss.usermodel.FillPatternType;
+import org.apache.poi.ss.usermodel.Font;
+import org.apache.poi.ss.usermodel.HorizontalAlignment;
+import org.apache.poi.ss.usermodel.IndexedColors;
+import org.apache.poi.ss.usermodel.Row;
+import org.apache.poi.ss.usermodel.Sheet;
+import org.apache.poi.ss.usermodel.VerticalAlignment;
+import org.apache.poi.ss.usermodel.Workbook;
+import org.apache.poi.ss.usermodel.WorkbookFactory;
+import org.apache.poi.ss.util.CellRangeAddressList;
+import org.apache.poi.xssf.streaming.SXSSFWorkbook;
+import org.apache.poi.xssf.usermodel.XSSFClientAnchor;
+import org.apache.poi.xssf.usermodel.XSSFDataValidation;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import com.zhentao.common.core.text.Convert;
+import com.zhentao.common.core.utils.DateUtils;
+import com.zhentao.common.core.utils.StringUtils;
+import com.zhentao.common.core.utils.file.FileTypeUtils;
+import com.zhentao.common.core.utils.file.ImageUtils;
+
+/**
+ * Excel鐩稿叧澶勭悊
+ *
+ * @author ruoyi
+ */
+public class ExcelUtil
+{
+ private static final Logger log = LoggerFactory.getLogger(ExcelUtil.class);
+
+ /**
+ * Excel sheet鏈澶ц鏁帮紝榛樿65536
+ */
+ public static final int sheetSize = 65536;
+
+ /**
+ * 宸ヤ綔琛ㄥ悕绉
+ */
+ private String sheetName;
+
+ /**
+ * 瀵煎嚭绫诲瀷锛圗XPORT:瀵煎嚭鏁版嵁锛汭MPORT锛氬鍏ユā鏉匡級
+ */
+ private Excel.Type type;
+
+ /**
+ * 宸ヤ綔钖勫璞
+ */
+ private Workbook wb;
+
+ /**
+ * 宸ヤ綔琛ㄥ璞
+ */
+ private Sheet sheet;
+
+ /**
+ * 鏍峰紡鍒楄〃
+ */
+ private Map styles;
+
+ /**
+ * 瀵煎叆瀵煎嚭鏁版嵁鍒楄〃
+ */
+ private List list;
+
+ /**
+ * 娉ㄨВ鍒楄〃
+ */
+ private List fields;
+
+ /**
+ * 鏈澶ч珮搴
+ */
+ private short maxHeight;
+
+ /**
+ * 缁熻鍒楄〃
+ */
+ private Map statistics = new HashMap();
+
+ /**
+ * 鏁板瓧鏍煎紡
+ */
+ private static final DecimalFormat DOUBLE_FORMAT = new DecimalFormat("######0.00");
+
+ /**
+ * 瀹炰綋瀵硅薄
+ */
+ public Class clazz;
+
+ public ExcelUtil(Class clazz)
+ {
+ this.clazz = clazz;
+ }
+
+ public void init(List list, String sheetName, Excel.Type type)
+ {
+ if (list == null)
+ {
+ list = new ArrayList();
+ }
+ this.list = list;
+ this.sheetName = sheetName;
+ this.type = type;
+ createExcelField();
+ createWorkbook();
+ }
+
+ /**
+ * 瀵筫xcel琛ㄥ崟榛樿绗竴涓储寮曞悕杞崲鎴恖ist
+ *
+ * @param is 杈撳叆娴
+ * @return 杞崲鍚庨泦鍚
+ */
+ public List importExcel(InputStream is) throws Exception
+ {
+ return importExcel(StringUtils.EMPTY, is);
+ }
+
+ /**
+ * 瀵筫xcel琛ㄥ崟鎸囧畾琛ㄦ牸绱㈠紩鍚嶈浆鎹㈡垚list
+ *
+ * @param sheetName 琛ㄦ牸绱㈠紩鍚
+ * @param is 杈撳叆娴
+ * @return 杞崲鍚庨泦鍚
+ */
+ public List importExcel(String sheetName, InputStream is) throws Exception
+ {
+ this.type = Excel.Type.IMPORT;
+ this.wb = WorkbookFactory.create(is);
+ List list = new ArrayList();
+ Sheet sheet = null;
+ if (StringUtils.isNotEmpty(sheetName))
+ {
+ // 濡傛灉鎸囧畾sheet鍚,鍒欏彇鎸囧畾sheet涓殑鍐呭.
+ sheet = wb.getSheet(sheetName);
+ }
+ else
+ {
+ // 濡傛灉浼犲叆鐨剆heet鍚嶄笉瀛樺湪鍒欓粯璁ゆ寚鍚戠1涓猻heet.
+ sheet = wb.getSheetAt(0);
+ }
+
+ if (sheet == null)
+ {
+ throw new IOException("鏂囦欢sheet涓嶅瓨鍦");
+ }
+
+ int rows = sheet.getPhysicalNumberOfRows();
+
+ if (rows > 0)
+ {
+ // 瀹氫箟涓涓猰ap鐢ㄤ簬瀛樻斁excel鍒楃殑搴忓彿鍜宖ield.
+ Map cellMap = new HashMap();
+ // 鑾峰彇琛ㄥご
+ Row heard = sheet.getRow(0);
+ for (int i = 0; i < heard.getPhysicalNumberOfCells(); i++)
+ {
+ Cell cell = heard.getCell(i);
+ if (StringUtils.isNotNull(cell))
+ {
+ String value = this.getCellValue(heard, i).toString();
+ cellMap.put(value, i);
+ }
+ else
+ {
+ cellMap.put(null, i);
+ }
+ }
+ // 鏈夋暟鎹椂鎵嶅鐞 寰楀埌绫荤殑鎵鏈塮ield.
+ Field[] allFields = clazz.getDeclaredFields();
+ // 瀹氫箟涓涓猰ap鐢ㄤ簬瀛樻斁鍒楃殑搴忓彿鍜宖ield.
+ Map fieldsMap = new HashMap();
+ for (int col = 0; col < allFields.length; col++)
+ {
+ Field field = allFields[col];
+ Excel attr = field.getAnnotation(Excel.class);
+ if (attr != null && (attr.type() == Excel.Type.ALL || attr.type() == type))
+ {
+ // 璁剧疆绫荤殑绉佹湁瀛楁灞炴у彲璁块棶.
+ field.setAccessible(true);
+ Integer column = cellMap.get(attr.name());
+ if (column != null)
+ {
+ fieldsMap.put(column, field);
+ }
+ }
+ }
+ for (int i = 1; i < rows; i++)
+ {
+ // 浠庣2琛屽紑濮嬪彇鏁版嵁,榛樿绗竴琛屾槸琛ㄥご.
+ Row row = sheet.getRow(i);
+ T entity = null;
+ for (Map.Entry entry : fieldsMap.entrySet())
+ {
+ Object val = this.getCellValue(row, entry.getKey());
+
+ // 濡傛灉涓嶅瓨鍦ㄥ疄渚嬪垯鏂板缓.
+ entity = (entity == null ? clazz.newInstance() : entity);
+ // 浠巑ap涓緱鍒板搴斿垪鐨刦ield.
+ Field field = fieldsMap.get(entry.getKey());
+ // 鍙栧緱绫诲瀷,骞舵牴鎹璞＄被鍨嬭缃.
+ Class fieldType = field.getType();
+ if (String.class == fieldType)
+ {
+ String s = Convert.toStr(val);
+ if (StringUtils.endsWith(s, ".0"))
+ {
+ val = StringUtils.substringBefore(s, ".0");
+ }
+ else
+ {
+ String dateFormat = field.getAnnotation(Excel.class).dateFormat();
+ if (StringUtils.isNotEmpty(dateFormat))
+ {
+ val = DateUtils.parseDateToStr(dateFormat, (Date) val);
+ }
+ else
+ {
+ val = Convert.toStr(val);
+ }
+ }
+ }
+ else if ((Integer.TYPE == fieldType || Integer.class == fieldType) && StringUtils.isNumeric(Convert.toStr(val)))
+ {
+ val = Convert.toInt(val);
+ }
+ else if (Long.TYPE == fieldType || Long.class == fieldType)
+ {
+ val = Convert.toLong(val);
+ }
+ else if (Double.TYPE == fieldType || Double.class == fieldType)
+ {
+ val = Convert.toDouble(val);
+ }
+ else if (Float.TYPE == fieldType || Float.class == fieldType)
+ {
+ val = Convert.toFloat(val);
+ }
+ else if (BigDecimal.class == fieldType)
+ {
+ val = Convert.toBigDecimal(val);
+ }
+ else if (Date.class == fieldType)
+ {
+ if (val instanceof String)
+ {
+ val = DateUtils.parseDate(val);
+ }
+ else if (val instanceof Double)
+ {
+ val = DateUtil.getJavaDate((Double) val);
+ }
+ }
+ else if (Boolean.TYPE == fieldType || Boolean.class == fieldType)
+ {
+ val = Convert.toBool(val, false);
+ }
+ if (StringUtils.isNotNull(fieldType))
+ {
+ Excel attr = field.getAnnotation(Excel.class);
+ String propertyName = field.getName();
+ if (StringUtils.isNotEmpty(attr.targetAttr()))
+ {
+ propertyName = field.getName() + "." + attr.targetAttr();
+ }
+ else if (StringUtils.isNotEmpty(attr.readConverterExp()))
+ {
+ val = reverseByExp(Convert.toStr(val), attr.readConverterExp(), attr.separator());
+ }
+ ReflectUtils.invokeSetter(entity, propertyName, val);
+ }
+ }
+ list.add(entity);
+ }
+ }
+ return list;
+ }
+
+ /**
+ * 瀵筶ist鏁版嵁婧愬皢鍏堕噷闈㈢殑鏁版嵁瀵煎叆鍒癳xcel琛ㄥ崟
+ *
+ * @param response 杩斿洖鏁版嵁
+ * @param list 瀵煎嚭鏁版嵁闆嗗悎
+ * @param sheetName 宸ヤ綔琛ㄧ殑鍚嶇О
+ * @return 缁撴灉
+ * @throws IOException
+ */
+ public void exportExcel(HttpServletResponse response, List list, String sheetName) throws IOException
+ {
+ response.setContentType("application/vnd.ms-excel");
+ response.setCharacterEncoding("utf-8");
+ this.init(list, sheetName, Excel.Type.EXPORT);
+ exportExcel(response.getOutputStream());
+ }
+
+ /**
+ * 瀵筶ist鏁版嵁婧愬皢鍏堕噷闈㈢殑鏁版嵁瀵煎叆鍒癳xcel琛ㄥ崟
+ *
+ * @param sheetName 宸ヤ綔琛ㄧ殑鍚嶇О
+ * @return 缁撴灉
+ */
+ public void importTemplateExcel(HttpServletResponse response, String sheetName) throws IOException
+ {
+ response.setContentType("application/vnd.ms-excel");
+ response.setCharacterEncoding("utf-8");
+ this.init(null, sheetName, Excel.Type.IMPORT);
+ exportExcel(response.getOutputStream());
+ }
+
+ /**
+ * 瀵筶ist鏁版嵁婧愬皢鍏堕噷闈㈢殑鏁版嵁瀵煎叆鍒癳xcel琛ㄥ崟
+ *
+ * @return 缁撴灉
+ */
+ public void exportExcel(OutputStream outputStream)
+ {
+ try
+ {
+ // 鍙栧嚭涓鍏辨湁澶氬皯涓猻heet.
+ double sheetNo = Math.ceil(list.size() / sheetSize);
+ for (int index = 0; index <= sheetNo; index++)
+ {
+ createSheet(sheetNo, index);
+
+ // 浜х敓涓琛
+ Row row = sheet.createRow(0);
+ int column = 0;
+ // 鍐欏叆鍚勪釜瀛楁鐨勫垪澶村悕绉
+ for (Object[] os : fields)
+ {
+ Excel excel = (Excel) os[1];
+ this.createCell(excel, row, column++);
+ }
+ if (Excel.Type.EXPORT.equals(type))
+ {
+ fillExcelData(index, row);
+ addStatisticsRow();
+ }
+ }
+ wb.write(outputStream);
+ }
+ catch (Exception e)
+ {
+ log.error("瀵煎嚭Excel寮傚父{}", e.getMessage());
+ }
+ finally
+ {
+ if (wb != null)
+ {
+ try
+ {
+ wb.close();
+ }
+ catch (IOException e1)
+ {
+ e1.printStackTrace();
+ }
+ }
+ if (outputStream != null)
+ {
+ try
+ {
+ outputStream.close();
+ }
+ catch (IOException e1)
+ {
+ e1.printStackTrace();
+ }
+ }
+ }
+ }
+
+ /**
+ * 濉厖excel鏁版嵁
+ *
+ * @param index 搴忓彿
+ * @param row 鍗曞厓鏍艰
+ */
+ public void fillExcelData(int index, Row row)
+ {
+ int startNo = index * sheetSize;
+ int endNo = Math.min(startNo + sheetSize, list.size());
+ for (int i = startNo; i < endNo; i++)
+ {
+ row = sheet.createRow(i + 1 - startNo);
+ // 寰楀埌瀵煎嚭瀵硅薄.
+ T vo = (T) list.get(i);
+ int column = 0;
+ for (Object[] os : fields)
+ {
+ Field field = (Field) os[0];
+ Excel excel = (Excel) os[1];
+ // 璁剧疆瀹炰綋绫荤鏈夊睘鎬у彲璁块棶
+ field.setAccessible(true);
+ this.addCell(excel, row, vo, field, column++);
+ }
+ }
+ }
+
+ /**
+ * 鍒涘缓琛ㄦ牸鏍峰紡
+ *
+ * @param wb 宸ヤ綔钖勫璞
+ * @return 鏍峰紡鍒楄〃
+ */
+ private Map createStyles(Workbook wb)
+ {
+ // 鍐欏叆鍚勬潯璁板綍,姣忔潯璁板綍瀵瑰簲excel琛ㄤ腑鐨勪竴琛
+ Map styles = new HashMap();
+ CellStyle style = wb.createCellStyle();
+ style.setAlignment(HorizontalAlignment.CENTER);
+ style.setVerticalAlignment(VerticalAlignment.CENTER);
+ style.setBorderRight(BorderStyle.THIN);
+ style.setRightBorderColor(IndexedColors.GREY_50_PERCENT.getIndex());
+ style.setBorderLeft(BorderStyle.THIN);
+ style.setLeftBorderColor(IndexedColors.GREY_50_PERCENT.getIndex());
+ style.setBorderTop(BorderStyle.THIN);
+ style.setTopBorderColor(IndexedColors.GREY_50_PERCENT.getIndex());
+ style.setBorderBottom(BorderStyle.THIN);
+ style.setBottomBorderColor(IndexedColors.GREY_50_PERCENT.getIndex());
+ Font dataFont = wb.createFont();
+ dataFont.setFontName("Arial");
+ dataFont.setFontHeightInPoints((short) 10);
+ style.setFont(dataFont);
+ styles.put("data", style);
+
+ style = wb.createCellStyle();
+ style.cloneStyleFrom(styles.get("data"));
+ style.setAlignment(HorizontalAlignment.CENTER);
+ style.setVerticalAlignment(VerticalAlignment.CENTER);
+ style.setFillForegroundColor(IndexedColors.GREY_50_PERCENT.getIndex());
+ style.setFillPattern(FillPatternType.SOLID_FOREGROUND);
+ Font headerFont = wb.createFont();
+ headerFont.setFontName("Arial");
+ headerFont.setFontHeightInPoints((short) 10);
+ headerFont.setBold(true);
+ headerFont.setColor(IndexedColors.WHITE.getIndex());
+ style.setFont(headerFont);
+ styles.put("header", style);
+
+ style = wb.createCellStyle();
+ style.setAlignment(HorizontalAlignment.CENTER);
+ style.setVerticalAlignment(VerticalAlignment.CENTER);
+ Font totalFont = wb.createFont();
+ totalFont.setFontName("Arial");
+ totalFont.setFontHeightInPoints((short) 10);
+ style.setFont(totalFont);
+ styles.put("total", style);
+
+ style = wb.createCellStyle();
+ style.cloneStyleFrom(styles.get("data"));
+ style.setAlignment(HorizontalAlignment.LEFT);
+ styles.put("data1", style);
+
+ style = wb.createCellStyle();
+ style.cloneStyleFrom(styles.get("data"));
+ style.setAlignment(HorizontalAlignment.CENTER);
+ styles.put("data2", style);
+
+ style = wb.createCellStyle();
+ style.cloneStyleFrom(styles.get("data"));
+ style.setAlignment(HorizontalAlignment.RIGHT);
+ styles.put("data3", style);
+
+ return styles;
+ }
+
+ /**
+ * 鍒涘缓鍗曞厓鏍
+ */
+ public Cell createCell(Excel attr, Row row, int column)
+ {
+ // 鍒涘缓鍒
+ Cell cell = row.createCell(column);
+ // 鍐欏叆鍒椾俊鎭
+ cell.setCellValue(attr.name());
+ setDataValidation(attr, row, column);
+ cell.setCellStyle(styles.get("header"));
+ return cell;
+ }
+
+ /**
+ * 璁剧疆鍗曞厓鏍间俊鎭
+ *
+ * @param value 鍗曞厓鏍煎
+ * @param attr 娉ㄨВ鐩稿叧
+ * @param cell 鍗曞厓鏍间俊鎭
+ */
+ public void setCellVo(Object value, Excel attr, Cell cell)
+ {
+ if (Excel.ColumnType.STRING == attr.cellType())
+ {
+ cell.setCellValue(StringUtils.isNull(value) ? attr.defaultValue() : value + attr.suffix());
+ }
+ else if (Excel.ColumnType.NUMERIC == attr.cellType())
+ {
+ cell.setCellValue(StringUtils.contains(Convert.toStr(value), ".") ? Convert.toDouble(value) : Convert.toInt(value));
+ }
+ else if (Excel.ColumnType.IMAGE == attr.cellType())
+ {
+ ClientAnchor anchor = new XSSFClientAnchor(0, 0, 0, 0, (short) cell.getColumnIndex(), cell.getRow().getRowNum(), (short) (cell.getColumnIndex() + 1),
+ cell.getRow().getRowNum() + 1);
+ String imagePath = Convert.toStr(value);
+ if (StringUtils.isNotEmpty(imagePath))
+ {
+ byte[] data = ImageUtils.getImage(imagePath);
+ getDrawingPatriarch(cell.getSheet()).createPicture(anchor,
+ cell.getSheet().getWorkbook().addPicture(data, getImageType(data)));
+ }
+ }
+ }
+
+ /**
+ * 鑾峰彇鐢诲竷
+ */
+ public static Drawing getDrawingPatriarch(Sheet sheet)
+ {
+ if (sheet.getDrawingPatriarch() == null)
+ {
+ sheet.createDrawingPatriarch();
+ }
+ return sheet.getDrawingPatriarch();
+ }
+
+ /**
+ * 鑾峰彇鍥剧墖绫诲瀷,璁剧疆鍥剧墖鎻掑叆绫诲瀷
+ */
+ public int getImageType(byte[] value)
+ {
+ String type = FileTypeUtils.getFileExtendName(value);
+ if ("JPG".equalsIgnoreCase(type))
+ {
+ return Workbook.PICTURE_TYPE_JPEG;
+ }
+ else if ("PNG".equalsIgnoreCase(type))
+ {
+ return Workbook.PICTURE_TYPE_PNG;
+ }
+ return Workbook.PICTURE_TYPE_JPEG;
+ }
+
+ /**
+ * 鍒涘缓琛ㄦ牸鏍峰紡
+ */
+ public void setDataValidation(Excel attr, Row row, int column)
+ {
+ if (attr.name().indexOf("娉細") >= 0)
+ {
+ sheet.setColumnWidth(column, 6000);
+ }
+ else
+ {
+ // 璁剧疆鍒楀
+ sheet.setColumnWidth(column, (int) ((attr.width() + 0.72) * 256));
+ }
+ // 濡傛灉璁剧疆浜嗘彁绀轰俊鎭垯榧犳爣鏀句笂鍘绘彁绀.
+ if (StringUtils.isNotEmpty(attr.prompt()))
+ {
+ // 杩欓噷榛樿璁句簡2-101鍒楁彁绀.
+ setXSSFPrompt(sheet, "", attr.prompt(), 1, 100, column, column);
+ }
+ // 濡傛灉璁剧疆浜哻ombo灞炴у垯鏈垪鍙兘閫夋嫨涓嶈兘杈撳叆
+ if (attr.combo().length > 0)
+ {
+ // 杩欓噷榛樿璁句簡2-101鍒楀彧鑳介夋嫨涓嶈兘杈撳叆.
+ setXSSFValidation(sheet, attr.combo(), 1, 100, column, column);
+ }
+ }
+
+ /**
+ * 娣诲姞鍗曞厓鏍
+ */
+ public Cell addCell(Excel attr, Row row, T vo, Field field, int column)
+ {
+ Cell cell = null;
+ try
+ {
+ // 璁剧疆琛岄珮
+ row.setHeight(maxHeight);
+ // 鏍规嵁Excel涓缃儏鍐靛喅瀹氭槸鍚﹀鍑,鏈変簺鎯呭喌闇瑕佷繚鎸佷负绌,甯屾湜鐢ㄦ埛濉啓杩欎竴鍒.
+ if (attr.isExport())
+ {
+ // 鍒涘缓cell
+ cell = row.createCell(column);
+ int align = attr.align().value();
+ cell.setCellStyle(styles.get("data" + (align >= 1 && align <= 3 ? align : "")));
+
+ // 鐢ㄤ簬璇诲彇瀵硅薄涓殑灞炴
+ Object value = getTargetValue(vo, field, attr);
+ String dateFormat = attr.dateFormat();
+ String readConverterExp = attr.readConverterExp();
+ String separator = attr.separator();
+ if (StringUtils.isNotEmpty(dateFormat) && StringUtils.isNotNull(value))
+ {
+ cell.setCellValue(DateUtils.parseDateToStr(dateFormat, (Date) value));
+ }
+ else if (StringUtils.isNotEmpty(readConverterExp) && StringUtils.isNotNull(value))
+ {
+ cell.setCellValue(convertByExp(Convert.toStr(value), readConverterExp, separator));
+ }
+ else if (value instanceof BigDecimal && -1 != attr.scale())
+ {
+ cell.setCellValue((((BigDecimal) value).setScale(attr.scale(), attr.roundingMode())).toString());
+ }
+ else
+ {
+ // 璁剧疆鍒楃被鍨
+ setCellVo(value, attr, cell);
+ }
+ addStatisticsData(column, Convert.toStr(value), attr);
+ }
+ }
+ catch (Exception e)
+ {
+ log.error("瀵煎嚭Excel澶辫触{}", e);
+ }
+ return cell;
+ }
+
+ /**
+ * 璁剧疆 POI XSSFSheet 鍗曞厓鏍兼彁绀
+ *
+ * @param sheet 琛ㄥ崟
+ * @param promptTitle 鎻愮ず鏍囬
+ * @param promptContent 鎻愮ず鍐呭
+ * @param firstRow 寮濮嬭
+ * @param endRow 缁撴潫琛
+ * @param firstCol 寮濮嬪垪
+ * @param endCol 缁撴潫鍒
+ */
+ public void setXSSFPrompt(Sheet sheet, String promptTitle, String promptContent, int firstRow, int endRow,
+ int firstCol, int endCol)
+ {
+ DataValidationHelper helper = sheet.getDataValidationHelper();
+ DataValidationConstraint constraint = helper.createCustomConstraint("DD1");
+ CellRangeAddressList regions = new CellRangeAddressList(firstRow, endRow, firstCol, endCol);
+ DataValidation dataValidation = helper.createValidation(constraint, regions);
+ dataValidation.createPromptBox(promptTitle, promptContent);
+ dataValidation.setShowPromptBox(true);
+ sheet.addValidationData(dataValidation);
+ }
+
+ /**
+ * 璁剧疆鏌愪簺鍒楃殑鍊煎彧鑳借緭鍏ラ鍒剁殑鏁版嵁,鏄剧ず涓嬫媺妗.
+ *
+ * @param sheet 瑕佽缃殑sheet.
+ * @param textlist 涓嬫媺妗嗘樉绀虹殑鍐呭
+ * @param firstRow 寮濮嬭
+ * @param endRow 缁撴潫琛
+ * @param firstCol 寮濮嬪垪
+ * @param endCol 缁撴潫鍒
+ * @return 璁剧疆濂界殑sheet.
+ */
+ public void setXSSFValidation(Sheet sheet, String[] textlist, int firstRow, int endRow, int firstCol, int endCol)
+ {
+ DataValidationHelper helper = sheet.getDataValidationHelper();
+ // 鍔犺浇涓嬫媺鍒楄〃鍐呭
+ DataValidationConstraint constraint = helper.createExplicitListConstraint(textlist);
+ // 璁剧疆鏁版嵁鏈夋晥鎬у姞杞藉湪鍝釜鍗曞厓鏍间笂,鍥涗釜鍙傛暟鍒嗗埆鏄細璧峰琛屻佺粓姝㈣銆佽捣濮嬪垪銆佺粓姝㈠垪
+ CellRangeAddressList regions = new CellRangeAddressList(firstRow, endRow, firstCol, endCol);
+ // 鏁版嵁鏈夋晥鎬у璞
+ DataValidation dataValidation = helper.createValidation(constraint, regions);
+ // 澶勭悊Excel鍏煎鎬ч棶棰
+ if (dataValidation instanceof XSSFDataValidation)
+ {
+ dataValidation.setSuppressDropDownArrow(true);
+ dataValidation.setShowErrorBox(true);
+ }
+ else
+ {
+ dataValidation.setSuppressDropDownArrow(false);
+ }
+
+ sheet.addValidationData(dataValidation);
+ }
+
+ /**
+ * 瑙ｆ瀽瀵煎嚭鍊 0=鐢,1=濂,2=鏈煡
+ *
+ * @param propertyValue 鍙傛暟鍊
+ * @param converterExp 缈昏瘧娉ㄨВ
+ * @param separator 鍒嗛殧绗
+ * @return 瑙ｆ瀽鍚庡
+ */
+ public static String convertByExp(String propertyValue, String converterExp, String separator)
+ {
+ StringBuilder propertyString = new StringBuilder();
+ String[] convertSource = converterExp.split(",");
+ for (String item : convertSource)
+ {
+ String[] itemArray = item.split("=");
+ if (StringUtils.containsAny(separator, propertyValue))
+ {
+ for (String value : propertyValue.split(separator))
+ {
+ if (itemArray[0].equals(value))
+ {
+ propertyString.append(itemArray[1] + separator);
+ break;
+ }
+ }
+ }
+ else
+ {
+ if (itemArray[0].equals(propertyValue))
+ {
+ return itemArray[1];
+ }
+ }
+ }
+ return StringUtils.stripEnd(propertyString.toString(), separator);
+ }
+
+ /**
+ * 鍙嶅悜瑙ｆ瀽鍊 鐢=0,濂=1,鏈煡=2
+ *
+ * @param propertyValue 鍙傛暟鍊
+ * @param converterExp 缈昏瘧娉ㄨВ
+ * @param separator 鍒嗛殧绗
+ * @return 瑙ｆ瀽鍚庡
+ */
+ public static String reverseByExp(String propertyValue, String converterExp, String separator)
+ {
+ StringBuilder propertyString = new StringBuilder();
+ String[] convertSource = converterExp.split(",");
+ for (String item : convertSource)
+ {
+ String[] itemArray = item.split("=");
+ if (StringUtils.containsAny(separator, propertyValue))
+ {
+ for (String value : propertyValue.split(separator))
+ {
+ if (itemArray[1].equals(value))
+ {
+ propertyString.append(itemArray[0] + separator);
+ break;
+ }
+ }
+ }
+ else
+ {
+ if (itemArray[1].equals(propertyValue))
+ {
+ return itemArray[0];
+ }
+ }
+ }
+ return StringUtils.stripEnd(propertyString.toString(), separator);
+ }
+
+ /**
+ * 鍚堣缁熻淇℃伅
+ */
+ private void addStatisticsData(Integer index, String text, Excel entity)
+ {
+ if (entity != null && entity.isStatistics())
+ {
+ Double temp = 0D;
+ if (!statistics.containsKey(index))
+ {
+ statistics.put(index, temp);
+ }
+ try
+ {
+ temp = Double.valueOf(text);
+ }
+ catch (NumberFormatException e)
+ {
+ }
+ statistics.put(index, statistics.get(index) + temp);
+ }
+ }
+
+ /**
+ * 鍒涘缓缁熻琛
+ */
+ public void addStatisticsRow()
+ {
+ if (statistics.size() > 0)
+ {
+ Cell cell = null;
+ Row row = sheet.createRow(sheet.getLastRowNum() + 1);
+ Set keys = statistics.keySet();
+ cell = row.createCell(0);
+ cell.setCellStyle(styles.get("total"));
+ cell.setCellValue("鍚堣");
+
+ for (Integer key : keys)
+ {
+ cell = row.createCell(key);
+ cell.setCellStyle(styles.get("total"));
+ cell.setCellValue(DOUBLE_FORMAT.format(statistics.get(key)));
+ }
+ statistics.clear();
+ }
+ }
+
+ /**
+ * 鑾峰彇bean涓殑灞炴у
+ *
+ * @param vo 瀹炰綋瀵硅薄
+ * @param field 瀛楁
+ * @param excel 娉ㄨВ
+ * @return 鏈缁堢殑灞炴у
+ * @throws Exception
+ */
+ private Object getTargetValue(T vo, Field field, Excel excel) throws Exception
+ {
+ Object o = field.get(vo);
+ if (StringUtils.isNotEmpty(excel.targetAttr()))
+ {
+ String target = excel.targetAttr();
+ if (target.indexOf(".") > -1)
+ {
+ String[] targets = target.split("[.]");
+ for (String name : targets)
+ {
+ o = getValue(o, name);
+ }
+ }
+ else
+ {
+ o = getValue(o, target);
+ }
+ }
+ return o;
+ }
+
+ /**
+ * 浠ョ被鐨勫睘鎬х殑get鏂规硶鏂规硶褰㈠紡鑾峰彇鍊
+ *
+ * @param o
+ * @param name
+ * @return value
+ * @throws Exception
+ */
+ private Object getValue(Object o, String name) throws Exception
+ {
+ if (StringUtils.isNotNull(o) && StringUtils.isNotEmpty(name))
+ {
+ Class clazz = o.getClass();
+ Field field = clazz.getDeclaredField(name);
+ field.setAccessible(true);
+ o = field.get(o);
+ }
+ return o;
+ }
+
+ /**
+ * 寰楀埌鎵鏈夊畾涔夊瓧娈
+ */
+ private void createExcelField()
+ {
+ this.fields = new ArrayList();
+ List tempFields = new ArrayList<>();
+ tempFields.addAll(Arrays.asList(clazz.getSuperclass().getDeclaredFields()));
+ tempFields.addAll(Arrays.asList(clazz.getDeclaredFields()));
+ for (Field field : tempFields)
+ {
+ // 鍗曟敞瑙
+ if (field.isAnnotationPresent(Excel.class))
+ {
+ putToField(field, field.getAnnotation(Excel.class));
+ }
+
+ // 澶氭敞瑙
+ if (field.isAnnotationPresent(Excels.class))
+ {
+ Excels attrs = field.getAnnotation(Excels.class);
+ Excel[] excels = attrs.value();
+ for (Excel excel : excels)
+ {
+ putToField(field, excel);
+ }
+ }
+ }
+ this.fields = this.fields.stream().sorted(Comparator.comparing(objects -> ((Excel) objects[1]).sort())).collect(Collectors.toList());
+ this.maxHeight = getRowHeight();
+ }
+
+ /**
+ * 鏍规嵁娉ㄨВ鑾峰彇鏈澶ц楂
+ */
+ public short getRowHeight()
+ {
+ double maxHeight = 0;
+ for (Object[] os : this.fields)
+ {
+ Excel excel = (Excel) os[1];
+ maxHeight = maxHeight > excel.height() ? maxHeight : excel.height();
+ }
+ return (short) (maxHeight * 20);
+ }
+
+ /**
+ * 鏀惧埌瀛楁闆嗗悎涓
+ */
+ private void putToField(Field field, Excel attr)
+ {
+ if (attr != null && (attr.type() == Excel.Type.ALL || attr.type() == type))
+ {
+ this.fields.add(new Object[] { field, attr });
+ }
+ }
+
+ /**
+ * 鍒涘缓涓涓伐浣滅翱
+ */
+ public void createWorkbook()
+ {
+ this.wb = new SXSSFWorkbook(500);
+ }
+
+ /**
+ * 鍒涘缓宸ヤ綔琛
+ *
+ * @param sheetNo sheet鏁伴噺
+ * @param index 搴忓彿
+ */
+ public void createSheet(double sheetNo, int index)
+ {
+ this.sheet = wb.createSheet();
+ this.styles = createStyles(wb);
+ // 璁剧疆宸ヤ綔琛ㄧ殑鍚嶇О.
+ if (sheetNo == 0)
+ {
+ wb.setSheetName(index, sheetName);
+ }
+ else
+ {
+ wb.setSheetName(index, sheetName + index);
+ }
+ }
+
+ /**
+ * 鑾峰彇鍗曞厓鏍煎
+ *
+ * @param row 鑾峰彇鐨勮
+ * @param column 鑾峰彇鍗曞厓鏍煎垪鍙
+ * @return 鍗曞厓鏍煎
+ */
+ public Object getCellValue(Row row, int column)
+ {
+ if (row == null)
+ {
+ return row;
+ }
+ Object val = "";
+ try
+ {
+ Cell cell = row.getCell(column);
+ if (StringUtils.isNotNull(cell))
+ {
+ if (cell.getCellType() == CellType.NUMERIC || cell.getCellType() == CellType.FORMULA)
+ {
+ val = cell.getNumericCellValue();
+ if (DateUtil.isCellDateFormatted(cell))
+ {
+ val = DateUtil.getJavaDate((Double) val); // POI Excel 鏃ユ湡鏍煎紡杞崲
+ }
+ else
+ {
+ if ((Double) val % 1 != 0)
+ {
+ val = new BigDecimal(val.toString());
+ }
+ else
+ {
+ val = new DecimalFormat("0").format(val);
+ }
+ }
+ }
+ else if (cell.getCellType() == CellType.STRING)
+ {
+ val = cell.getStringCellValue();
+ }
+ else if (cell.getCellType() == CellType.BOOLEAN)
+ {
+ val = cell.getBooleanCellValue();
+ }
+ else if (cell.getCellType() == CellType.ERROR)
+ {
+ val = cell.getErrorCellValue();
+ }
+
+ }
+ }
+ catch (Exception e)
+ {
+ return val;
+ }
+ return val;
+ }
+}
diff --git a/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/utils/reflect/ReflectUtils.java b/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/utils/reflect/ReflectUtils.java
new file mode 100644
index 0000000..f7704fb
--- /dev/null
+++ b/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/utils/reflect/ReflectUtils.java
@@ -0,0 +1,410 @@
+package com.zhentao.common.core.utils.reflect;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.util.Date;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.lang3.Validate;
+import org.apache.poi.ss.usermodel.DateUtil;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import com.zhentao.common.core.text.Convert;
+import com.zhentao.common.core.utils.DateUtils;
+
+/**
+ * 鍙嶅皠宸ュ叿绫. 鎻愪緵璋冪敤getter/setter鏂规硶, 璁块棶绉佹湁鍙橀噺, 璋冪敤绉佹湁鏂规硶, 鑾峰彇娉涘瀷绫诲瀷Class, 琚獳OP杩囩殑鐪熷疄绫荤瓑宸ュ叿鍑芥暟.
+ *
+ * @author ruoyi
+ */
+@SuppressWarnings("rawtypes")
+public class ReflectUtils
+{
+ private static final String SETTER_PREFIX = "set";
+
+ private static final String GETTER_PREFIX = "get";
+
+ private static final String CGLIB_CLASS_SEPARATOR = "$$";
+
+ private static Logger logger = LoggerFactory.getLogger(ReflectUtils.class);
+
+ /**
+ * 璋冪敤Getter鏂规硶.
+ * 鏀寔澶氱骇锛屽锛氬璞″悕.瀵硅薄鍚.鏂规硶
+ */
+ @SuppressWarnings("unchecked")
+ public static E invokeGetter(Object obj, String propertyName)
+ {
+ Object object = obj;
+ for (String name : StringUtils.split(propertyName, "."))
+ {
+ String getterMethodName = GETTER_PREFIX + StringUtils.capitalize(name);
+ object = invokeMethod(object, getterMethodName, new Class[] {}, new Object[] {});
+ }
+ return (E) object;
+ }
+
+ /**
+ * 璋冪敤Setter鏂规硶, 浠呭尮閰嶆柟娉曞悕銆
+ * 鏀寔澶氱骇锛屽锛氬璞″悕.瀵硅薄鍚.鏂规硶
+ */
+ public static void invokeSetter(Object obj, String propertyName, E value)
+ {
+ Object object = obj;
+ String[] names = StringUtils.split(propertyName, ".");
+ for (int i = 0; i < names.length; i++)
+ {
+ if (i < names.length - 1)
+ {
+ String getterMethodName = GETTER_PREFIX + StringUtils.capitalize(names[i]);
+ object = invokeMethod(object, getterMethodName, new Class[] {}, new Object[] {});
+ }
+ else
+ {
+ String setterMethodName = SETTER_PREFIX + StringUtils.capitalize(names[i]);
+ invokeMethodByName(object, setterMethodName, new Object[] { value });
+ }
+ }
+ }
+
+ /**
+ * 鐩存帴璇诲彇瀵硅薄灞炴у, 鏃犺private/protected淇グ绗, 涓嶇粡杩噂etter鍑芥暟.
+ */
+ @SuppressWarnings("unchecked")
+ public static E getFieldValue(final Object obj, final String fieldName)
+ {
+ Field field = getAccessibleField(obj, fieldName);
+ if (field == null)
+ {
+ logger.debug("鍦 [" + obj.getClass() + "] 涓紝娌℃湁鎵惧埌 [" + fieldName + "] 瀛楁 ");
+ return null;
+ }
+ E result = null;
+ try
+ {
+ result = (E) field.get(obj);
+ }
+ catch (IllegalAccessException e)
+ {
+ logger.error("涓嶅彲鑳芥姏鍑虹殑寮傚父{}", e.getMessage());
+ }
+ return result;
+ }
+
+ /**
+ * 鐩存帴璁剧疆瀵硅薄灞炴у, 鏃犺private/protected淇グ绗, 涓嶇粡杩噑etter鍑芥暟.
+ */
+ public static void setFieldValue(final Object obj, final String fieldName, final E value)
+ {
+ Field field = getAccessibleField(obj, fieldName);
+ if (field == null)
+ {
+ // throw new IllegalArgumentException("鍦 [" + obj.getClass() + "] 涓紝娌℃湁鎵惧埌 [" + fieldName + "] 瀛楁 ");
+ logger.debug("鍦 [" + obj.getClass() + "] 涓紝娌℃湁鎵惧埌 [" + fieldName + "] 瀛楁 ");
+ return;
+ }
+ try
+ {
+ field.set(obj, value);
+ }
+ catch (IllegalAccessException e)
+ {
+ logger.error("涓嶅彲鑳芥姏鍑虹殑寮傚父: {}", e.getMessage());
+ }
+ }
+
+ /**
+ * 鐩存帴璋冪敤瀵硅薄鏂规硶, 鏃犺private/protected淇グ绗.
+ * 鐢ㄤ簬涓娆℃ц皟鐢ㄧ殑鎯呭喌锛屽惁鍒欏簲浣跨敤getAccessibleMethod()鍑芥暟鑾峰緱Method鍚庡弽澶嶈皟鐢.
+ * 鍚屾椂鍖归厤鏂规硶鍚+鍙傛暟绫诲瀷锛
+ */
+ @SuppressWarnings("unchecked")
+ public static E invokeMethod(final Object obj, final String methodName, final Class[] parameterTypes,
+ final Object[] args)
+ {
+ if (obj == null || methodName == null)
+ {
+ return null;
+ }
+ Method method = getAccessibleMethod(obj, methodName, parameterTypes);
+ if (method == null)
+ {
+ logger.debug("鍦 [" + obj.getClass() + "] 涓紝娌℃湁鎵惧埌 [" + methodName + "] 鏂规硶 ");
+ return null;
+ }
+ try
+ {
+ return (E) method.invoke(obj, args);
+ }
+ catch (Exception e)
+ {
+ String msg = "method: " + method + ", obj: " + obj + ", args: " + args + "";
+ throw convertReflectionExceptionToUnchecked(msg, e);
+ }
+ }
+
+ /**
+ * 鐩存帴璋冪敤瀵硅薄鏂规硶, 鏃犺private/protected淇グ绗︼紝
+ * 鐢ㄤ簬涓娆℃ц皟鐢ㄧ殑鎯呭喌锛屽惁鍒欏簲浣跨敤getAccessibleMethodByName()鍑芥暟鑾峰緱Method鍚庡弽澶嶈皟鐢.
+ * 鍙尮閰嶅嚱鏁板悕锛屽鏋滄湁澶氫釜鍚屽悕鍑芥暟璋冪敤绗竴涓
+ */
+ @SuppressWarnings("unchecked")
+ public static E invokeMethodByName(final Object obj, final String methodName, final Object[] args)
+ {
+ Method method = getAccessibleMethodByName(obj, methodName, args.length);
+ if (method == null)
+ {
+ // 濡傛灉涓虹┖涓嶆姤閿欙紝鐩存帴杩斿洖绌恒
+ logger.debug("鍦 [" + obj.getClass() + "] 涓紝娌℃湁鎵惧埌 [" + methodName + "] 鏂规硶 ");
+ return null;
+ }
+ try
+ {
+ // 绫诲瀷杞崲锛堝皢鍙傛暟鏁版嵁绫诲瀷杞崲涓虹洰鏍囨柟娉曞弬鏁扮被鍨嬶級
+ Class[] cs = method.getParameterTypes();
+ for (int i = 0; i < cs.length; i++)
+ {
+ if (args[i] != null && !args[i].getClass().equals(cs[i]))
+ {
+ if (cs[i] == String.class)
+ {
+ args[i] = Convert.toStr(args[i]);
+ if (StringUtils.endsWith((String) args[i], ".0"))
+ {
+ args[i] = StringUtils.substringBefore((String) args[i], ".0");
+ }
+ }
+ else if (cs[i] == Integer.class)
+ {
+ args[i] = Convert.toInt(args[i]);
+ }
+ else if (cs[i] == Long.class)
+ {
+ args[i] = Convert.toLong(args[i]);
+ }
+ else if (cs[i] == Double.class)
+ {
+ args[i] = Convert.toDouble(args[i]);
+ }
+ else if (cs[i] == Float.class)
+ {
+ args[i] = Convert.toFloat(args[i]);
+ }
+ else if (cs[i] == Date.class)
+ {
+ if (args[i] instanceof String)
+ {
+ args[i] = DateUtils.parseDate(args[i]);
+ }
+ else
+ {
+ args[i] = DateUtil.getJavaDate((Double) args[i]);
+ }
+ }
+ else if (cs[i] == boolean.class || cs[i] == Boolean.class)
+ {
+ args[i] = Convert.toBool(args[i]);
+ }
+ }
+ }
+ return (E) method.invoke(obj, args);
+ }
+ catch (Exception e)
+ {
+ String msg = "method: " + method + ", obj: " + obj + ", args: " + args + "";
+ throw convertReflectionExceptionToUnchecked(msg, e);
+ }
+ }
+
+ /**
+ * 寰幆鍚戜笂杞瀷, 鑾峰彇瀵硅薄鐨凞eclaredField, 骞跺己鍒惰缃负鍙闂.
+ * 濡傚悜涓婅浆鍨嬪埌Object浠嶆棤娉曟壘鍒, 杩斿洖null.
+ */
+ public static Field getAccessibleField(final Object obj, final String fieldName)
+ {
+ // 涓虹┖涓嶆姤閿欍傜洿鎺ヨ繑鍥 null
+ if (obj == null)
+ {
+ return null;
+ }
+ Validate.notBlank(fieldName, "fieldName can't be blank");
+ for (Class superClass = obj.getClass(); superClass != Object.class; superClass = superClass.getSuperclass())
+ {
+ try
+ {
+ Field field = superClass.getDeclaredField(fieldName);
+ makeAccessible(field);
+ return field;
+ }
+ catch (NoSuchFieldException e)
+ {
+ continue;
+ }
+ }
+ return null;
+ }
+
+ /**
+ * 寰幆鍚戜笂杞瀷, 鑾峰彇瀵硅薄鐨凞eclaredMethod,骞跺己鍒惰缃负鍙闂.
+ * 濡傚悜涓婅浆鍨嬪埌Object浠嶆棤娉曟壘鍒, 杩斿洖null.
+ * 鍖归厤鍑芥暟鍚+鍙傛暟绫诲瀷銆
+ * 鐢ㄤ簬鏂规硶闇瑕佽澶氭璋冪敤鐨勬儏鍐. 鍏堜娇鐢ㄦ湰鍑芥暟鍏堝彇寰桵ethod,鐒跺悗璋冪敤Method.invoke(Object obj, Object... args)
+ */
+ public static Method getAccessibleMethod(final Object obj, final String methodName,
+ final Class... parameterTypes)
+ {
+ // 涓虹┖涓嶆姤閿欍傜洿鎺ヨ繑鍥 null
+ if (obj == null)
+ {
+ return null;
+ }
+ Validate.notBlank(methodName, "methodName can't be blank");
+ for (Class searchType = obj.getClass(); searchType != Object.class; searchType = searchType.getSuperclass())
+ {
+ try
+ {
+ Method method = searchType.getDeclaredMethod(methodName, parameterTypes);
+ makeAccessible(method);
+ return method;
+ }
+ catch (NoSuchMethodException e)
+ {
+ continue;
+ }
+ }
+ return null;
+ }
+
+ /**
+ * 寰幆鍚戜笂杞瀷, 鑾峰彇瀵硅薄鐨凞eclaredMethod,骞跺己鍒惰缃负鍙闂.
+ * 濡傚悜涓婅浆鍨嬪埌Object浠嶆棤娉曟壘鍒, 杩斿洖null.
+ * 鍙尮閰嶅嚱鏁板悕銆
+ * 鐢ㄤ簬鏂规硶闇瑕佽澶氭璋冪敤鐨勬儏鍐. 鍏堜娇鐢ㄦ湰鍑芥暟鍏堝彇寰桵ethod,鐒跺悗璋冪敤Method.invoke(Object obj, Object... args)
+ */
+ public static Method getAccessibleMethodByName(final Object obj, final String methodName, int argsNum)
+ {
+ // 涓虹┖涓嶆姤閿欍傜洿鎺ヨ繑鍥 null
+ if (obj == null)
+ {
+ return null;
+ }
+ Validate.notBlank(methodName, "methodName can't be blank");
+ for (Class searchType = obj.getClass(); searchType != Object.class; searchType = searchType.getSuperclass())
+ {
+ Method[] methods = searchType.getDeclaredMethods();
+ for (Method method : methods)
+ {
+ if (method.getName().equals(methodName) && method.getParameterTypes().length == argsNum)
+ {
+ makeAccessible(method);
+ return method;
+ }
+ }
+ }
+ return null;
+ }
+
+ /**
+ * 鏀瑰彉private/protected鐨勬柟娉曚负public锛屽敖閲忎笉璋冪敤瀹為檯鏀瑰姩鐨勮鍙ワ紝閬垮厤JDK鐨凷ecurityManager鎶辨ㄣ
+ */
+ public static void makeAccessible(Method method)
+ {
+ if ((!Modifier.isPublic(method.getModifiers()) || !Modifier.isPublic(method.getDeclaringClass().getModifiers()))
+ && !method.isAccessible())
+ {
+ method.setAccessible(true);
+ }
+ }
+
+ /**
+ * 鏀瑰彉private/protected鐨勬垚鍛樺彉閲忎负public锛屽敖閲忎笉璋冪敤瀹為檯鏀瑰姩鐨勮鍙ワ紝閬垮厤JDK鐨凷ecurityManager鎶辨ㄣ
+ */
+ public static void makeAccessible(Field field)
+ {
+ if ((!Modifier.isPublic(field.getModifiers()) || !Modifier.isPublic(field.getDeclaringClass().getModifiers())
+ || Modifier.isFinal(field.getModifiers())) && !field.isAccessible())
+ {
+ field.setAccessible(true);
+ }
+ }
+
+ /**
+ * 閫氳繃鍙嶅皠, 鑾峰緱Class瀹氫箟涓０鏄庣殑娉涘瀷鍙傛暟鐨勭被鍨, 娉ㄦ剰娉涘瀷蹇呴』瀹氫箟鍦ㄧ埗绫诲
+ * 濡傛棤娉曟壘鍒, 杩斿洖Object.class.
+ */
+ @SuppressWarnings("unchecked")
+ public static Class getClassGenricType(final Class clazz)
+ {
+ return getClassGenricType(clazz, 0);
+ }
+
+ /**
+ * 閫氳繃鍙嶅皠, 鑾峰緱Class瀹氫箟涓０鏄庣殑鐖剁被鐨勬硾鍨嬪弬鏁扮殑绫诲瀷.
+ * 濡傛棤娉曟壘鍒, 杩斿洖Object.class.
+ */
+ public static Class getClassGenricType(final Class clazz, final int index)
+ {
+ Type genType = clazz.getGenericSuperclass();
+
+ if (!(genType instanceof ParameterizedType))
+ {
+ logger.debug(clazz.getSimpleName() + "'s superclass not ParameterizedType");
+ return Object.class;
+ }
+
+ Type[] params = ((ParameterizedType) genType).getActualTypeArguments();
+
+ if (index >= params.length || index < 0)
+ {
+ logger.debug("Index: " + index + ", Size of " + clazz.getSimpleName() + "'s Parameterized Type: "
+ + params.length);
+ return Object.class;
+ }
+ if (!(params[index] instanceof Class))
+ {
+ logger.debug(clazz.getSimpleName() + " not set the actual class on superclass generic parameter");
+ return Object.class;
+ }
+
+ return (Class) params[index];
+ }
+
+ public static Class getUserClass(Object instance)
+ {
+ if (instance == null)
+ {
+ throw new RuntimeException("Instance must not be null");
+ }
+ Class clazz = instance.getClass();
+ if (clazz != null && clazz.getName().contains(CGLIB_CLASS_SEPARATOR))
+ {
+ Class superClass = clazz.getSuperclass();
+ if (superClass != null && !Object.class.equals(superClass))
+ {
+ return superClass;
+ }
+ }
+ return clazz;
+
+ }
+
+ /**
+ * 灏嗗弽灏勬椂鐨刢hecked exception杞崲涓簎nchecked exception.
+ */
+ public static RuntimeException convertReflectionExceptionToUnchecked(String msg, Exception e)
+ {
+ if (e instanceof IllegalAccessException || e instanceof IllegalArgumentException
+ || e instanceof NoSuchMethodException)
+ {
+ return new IllegalArgumentException(msg, e);
+ }
+ else if (e instanceof InvocationTargetException)
+ {
+ return new RuntimeException(msg, ((InvocationTargetException) e).getTargetException());
+ }
+ return new RuntimeException(msg, e);
+ }
+}
diff --git a/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/utils/sign/Base64.java b/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/utils/sign/Base64.java
new file mode 100644
index 0000000..80e9a96
--- /dev/null
+++ b/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/utils/sign/Base64.java
@@ -0,0 +1,291 @@
+package com.zhentao.common.core.utils.sign;
+
+/**
+ * Base64宸ュ叿绫
+ *
+ * @author ruoyi
+ */
+public final class Base64
+{
+ static private final int BASELENGTH = 128;
+ static private final int LOOKUPLENGTH = 64;
+ static private final int TWENTYFOURBITGROUP = 24;
+ static private final int EIGHTBIT = 8;
+ static private final int SIXTEENBIT = 16;
+ static private final int FOURBYTE = 4;
+ static private final int SIGN = -128;
+ static private final char PAD = '=';
+ static final private byte[] base64Alphabet = new byte[BASELENGTH];
+ static final private char[] lookUpBase64Alphabet = new char[LOOKUPLENGTH];
+
+ static
+ {
+ for (int i = 0; i < BASELENGTH; ++i)
+ {
+ base64Alphabet[i] = -1;
+ }
+ for (int i = 'Z'; i >= 'A'; i--)
+ {
+ base64Alphabet[i] = (byte) (i - 'A');
+ }
+ for (int i = 'z'; i >= 'a'; i--)
+ {
+ base64Alphabet[i] = (byte) (i - 'a' + 26);
+ }
+
+ for (int i = '9'; i >= '0'; i--)
+ {
+ base64Alphabet[i] = (byte) (i - '0' + 52);
+ }
+
+ base64Alphabet['+'] = 62;
+ base64Alphabet['/'] = 63;
+
+ for (int i = 0; i <= 25; i++)
+ {
+ lookUpBase64Alphabet[i] = (char) ('A' + i);
+ }
+
+ for (int i = 26, j = 0; i <= 51; i++, j++)
+ {
+ lookUpBase64Alphabet[i] = (char) ('a' + j);
+ }
+
+ for (int i = 52, j = 0; i <= 61; i++, j++)
+ {
+ lookUpBase64Alphabet[i] = (char) ('0' + j);
+ }
+ lookUpBase64Alphabet[62] = (char) '+';
+ lookUpBase64Alphabet[63] = (char) '/';
+ }
+
+ private static boolean isWhiteSpace(char octect)
+ {
+ return (octect == 0x20 || octect == 0xd || octect == 0xa || octect == 0x9);
+ }
+
+ private static boolean isPad(char octect)
+ {
+ return (octect == PAD);
+ }
+
+ private static boolean isData(char octect)
+ {
+ return (octect < BASELENGTH && base64Alphabet[octect] != -1);
+ }
+
+ /**
+ * Encodes hex octects into Base64
+ *
+ * @param binaryData Array containing binaryData
+ * @return Encoded Base64 array
+ */
+ public static String encode(byte[] binaryData)
+ {
+ if (binaryData == null)
+ {
+ return null;
+ }
+
+ int lengthDataBits = binaryData.length * EIGHTBIT;
+ if (lengthDataBits == 0)
+ {
+ return "";
+ }
+
+ int fewerThan24bits = lengthDataBits % TWENTYFOURBITGROUP;
+ int numberTriplets = lengthDataBits / TWENTYFOURBITGROUP;
+ int numberQuartet = fewerThan24bits != 0 ? numberTriplets + 1 : numberTriplets;
+ char encodedData[] = null;
+
+ encodedData = new char[numberQuartet * 4];
+
+ byte k = 0, l = 0, b1 = 0, b2 = 0, b3 = 0;
+
+ int encodedIndex = 0;
+ int dataIndex = 0;
+
+ for (int i = 0; i < numberTriplets; i++)
+ {
+ b1 = binaryData[dataIndex++];
+ b2 = binaryData[dataIndex++];
+ b3 = binaryData[dataIndex++];
+
+ l = (byte) (b2 & 0x0f);
+ k = (byte) (b1 & 0x03);
+
+ byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0);
+ byte val2 = ((b2 & SIGN) == 0) ? (byte) (b2 >> 4) : (byte) ((b2) >> 4 ^ 0xf0);
+ byte val3 = ((b3 & SIGN) == 0) ? (byte) (b3 >> 6) : (byte) ((b3) >> 6 ^ 0xfc);
+
+ encodedData[encodedIndex++] = lookUpBase64Alphabet[val1];
+ encodedData[encodedIndex++] = lookUpBase64Alphabet[val2 | (k << 4)];
+ encodedData[encodedIndex++] = lookUpBase64Alphabet[(l << 2) | val3];
+ encodedData[encodedIndex++] = lookUpBase64Alphabet[b3 & 0x3f];
+ }
+
+ // form integral number of 6-bit groups
+ if (fewerThan24bits == EIGHTBIT)
+ {
+ b1 = binaryData[dataIndex];
+ k = (byte) (b1 & 0x03);
+ byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0);
+ encodedData[encodedIndex++] = lookUpBase64Alphabet[val1];
+ encodedData[encodedIndex++] = lookUpBase64Alphabet[k << 4];
+ encodedData[encodedIndex++] = PAD;
+ encodedData[encodedIndex++] = PAD;
+ }
+ else if (fewerThan24bits == SIXTEENBIT)
+ {
+ b1 = binaryData[dataIndex];
+ b2 = binaryData[dataIndex + 1];
+ l = (byte) (b2 & 0x0f);
+ k = (byte) (b1 & 0x03);
+
+ byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0);
+ byte val2 = ((b2 & SIGN) == 0) ? (byte) (b2 >> 4) : (byte) ((b2) >> 4 ^ 0xf0);
+
+ encodedData[encodedIndex++] = lookUpBase64Alphabet[val1];
+ encodedData[encodedIndex++] = lookUpBase64Alphabet[val2 | (k << 4)];
+ encodedData[encodedIndex++] = lookUpBase64Alphabet[l << 2];
+ encodedData[encodedIndex++] = PAD;
+ }
+ return new String(encodedData);
+ }
+
+ /**
+ * Decodes Base64 data into octects
+ *
+ * @param encoded string containing Base64 data
+ * @return Array containind decoded data.
+ */
+ public static byte[] decode(String encoded)
+ {
+ if (encoded == null)
+ {
+ return null;
+ }
+
+ char[] base64Data = encoded.toCharArray();
+ // remove white spaces
+ int len = removeWhiteSpace(base64Data);
+
+ if (len % FOURBYTE != 0)
+ {
+ return null;// should be divisible by four
+ }
+
+ int numberQuadruple = (len / FOURBYTE);
+
+ if (numberQuadruple == 0)
+ {
+ return new byte[0];
+ }
+
+ byte decodedData[] = null;
+ byte b1 = 0, b2 = 0, b3 = 0, b4 = 0;
+ char d1 = 0, d2 = 0, d3 = 0, d4 = 0;
+
+ int i = 0;
+ int encodedIndex = 0;
+ int dataIndex = 0;
+ decodedData = new byte[(numberQuadruple) * 3];
+
+ for (; i < numberQuadruple - 1; i++)
+ {
+
+ if (!isData((d1 = base64Data[dataIndex++])) || !isData((d2 = base64Data[dataIndex++]))
+ || !isData((d3 = base64Data[dataIndex++])) || !isData((d4 = base64Data[dataIndex++])))
+ {
+ return null;
+ } // if found "no data" just return null
+
+ b1 = base64Alphabet[d1];
+ b2 = base64Alphabet[d2];
+ b3 = base64Alphabet[d3];
+ b4 = base64Alphabet[d4];
+
+ decodedData[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4);
+ decodedData[encodedIndex++] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));
+ decodedData[encodedIndex++] = (byte) (b3 << 6 | b4);
+ }
+
+ if (!isData((d1 = base64Data[dataIndex++])) || !isData((d2 = base64Data[dataIndex++])))
+ {
+ return null;// if found "no data" just return null
+ }
+
+ b1 = base64Alphabet[d1];
+ b2 = base64Alphabet[d2];
+
+ d3 = base64Data[dataIndex++];
+ d4 = base64Data[dataIndex++];
+ if (!isData((d3)) || !isData((d4)))
+ {// Check if they are PAD characters
+ if (isPad(d3) && isPad(d4))
+ {
+ if ((b2 & 0xf) != 0)// last 4 bits should be zero
+ {
+ return null;
+ }
+ byte[] tmp = new byte[i * 3 + 1];
+ System.arraycopy(decodedData, 0, tmp, 0, i * 3);
+ tmp[encodedIndex] = (byte) (b1 << 2 | b2 >> 4);
+ return tmp;
+ }
+ else if (!isPad(d3) && isPad(d4))
+ {
+ b3 = base64Alphabet[d3];
+ if ((b3 & 0x3) != 0)// last 2 bits should be zero
+ {
+ return null;
+ }
+ byte[] tmp = new byte[i * 3 + 2];
+ System.arraycopy(decodedData, 0, tmp, 0, i * 3);
+ tmp[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4);
+ tmp[encodedIndex] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));
+ return tmp;
+ }
+ else
+ {
+ return null;
+ }
+ }
+ else
+ { // No PAD e.g 3cQl
+ b3 = base64Alphabet[d3];
+ b4 = base64Alphabet[d4];
+ decodedData[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4);
+ decodedData[encodedIndex++] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));
+ decodedData[encodedIndex++] = (byte) (b3 << 6 | b4);
+
+ }
+ return decodedData;
+ }
+
+ /**
+ * remove WhiteSpace from MIME containing encoded Base64 data.
+ *
+ * @param data the byte array of base64 data (with WS)
+ * @return the new length
+ */
+ private static int removeWhiteSpace(char[] data)
+ {
+ if (data == null)
+ {
+ return 0;
+ }
+
+ // count characters that's not whitespace
+ int newSize = 0;
+ int len = data.length;
+ for (int i = 0; i < len; i++)
+ {
+ if (!isWhiteSpace(data[i]))
+ {
+ data[newSize++] = data[i];
+ }
+ }
+ return newSize;
+ }
+}
diff --git a/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/utils/sql/SqlUtil.java b/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/utils/sql/SqlUtil.java
new file mode 100644
index 0000000..785816a
--- /dev/null
+++ b/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/utils/sql/SqlUtil.java
@@ -0,0 +1,37 @@
+package com.zhentao.common.core.utils.sql;
+
+import com.zhentao.common.core.exception.BaseException;
+import com.zhentao.common.core.utils.StringUtils;
+
+/**
+ * sql鎿嶄綔宸ュ叿绫
+ *
+ * @author ruoyi
+ */
+public class SqlUtil
+{
+ /**
+ * 浠呮敮鎸佸瓧姣嶃佹暟瀛椼佷笅鍒掔嚎銆佺┖鏍笺侀楀彿銆佸皬鏁扮偣锛堟敮鎸佸涓瓧娈垫帓搴忥級
+ */
+ public static String SQL_PATTERN = "[a-zA-Z0-9_\\ \\,\\.]+";
+
+ /**
+ * 妫鏌ュ瓧绗︼紝闃叉娉ㄥ叆缁曡繃
+ */
+ public static String escapeOrderBySql(String value)
+ {
+ if (StringUtils.isNotEmpty(value) && !isValidOrderBySql(value))
+ {
+ throw new BaseException("鍙傛暟涓嶇鍚堣鑼冿紝涓嶈兘杩涜鏌ヨ");
+ }
+ return value;
+ }
+
+ /**
+ * 楠岃瘉 order by 璇硶鏄惁绗﹀悎瑙勮寖
+ */
+ public static boolean isValidOrderBySql(String value)
+ {
+ return value.matches(SQL_PATTERN);
+ }
+}
diff --git a/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/web/controller/BaseController.java b/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/web/controller/BaseController.java
new file mode 100644
index 0000000..51d7c21
--- /dev/null
+++ b/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/web/controller/BaseController.java
@@ -0,0 +1,88 @@
+package com.zhentao.common.core.web.controller;
+
+import java.beans.PropertyEditorSupport;
+import java.util.Date;
+import java.util.List;
+
+import com.zhentao.common.core.constant.HttpStatus;
+import com.zhentao.common.core.utils.DateUtils;
+import com.zhentao.common.core.utils.StringUtils;
+import com.zhentao.common.core.utils.sql.SqlUtil;
+import com.zhentao.common.core.web.domain.AjaxResult;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.web.bind.WebDataBinder;
+import org.springframework.web.bind.annotation.InitBinder;
+
+import com.github.pagehelper.PageHelper;
+import com.github.pagehelper.PageInfo;
+import com.zhentao.common.core.web.page.PageDomain;
+import com.zhentao.common.core.web.page.TableDataInfo;
+import com.zhentao.common.core.web.page.TableSupport;
+
+/**
+ * web灞傞氱敤鏁版嵁澶勭悊
+ *
+ * @author ruoyi
+ */
+public class BaseController
+{
+ protected final Logger logger = LoggerFactory.getLogger(BaseController.class);
+
+ /**
+ * 灏嗗墠鍙颁紶閫掕繃鏉ョ殑鏃ユ湡鏍煎紡鐨勫瓧绗︿覆锛岃嚜鍔ㄨ浆鍖栦负Date绫诲瀷
+ */
+ @InitBinder
+ public void initBinder(WebDataBinder binder)
+ {
+ // Date 绫诲瀷杞崲
+ binder.registerCustomEditor(Date.class, new PropertyEditorSupport()
+ {
+ @Override
+ public void setAsText(String text)
+ {
+ setValue(DateUtils.parseDate(text));
+ }
+ });
+ }
+
+ /**
+ * 璁剧疆璇锋眰鍒嗛〉鏁版嵁
+ */
+ protected void startPage()
+ {
+ PageDomain pageDomain = TableSupport.buildPageRequest();
+ Integer pageNum = pageDomain.getPageNum();
+ Integer pageSize = pageDomain.getPageSize();
+ if (StringUtils.isNotNull(pageNum) && StringUtils.isNotNull(pageSize))
+ {
+ String orderBy = SqlUtil.escapeOrderBySql(pageDomain.getOrderBy());
+ PageHelper.startPage(pageNum, pageSize, orderBy);
+ }
+ }
+
+ /**
+ * 鍝嶅簲璇锋眰鍒嗛〉鏁版嵁
+ */
+ @SuppressWarnings({ "rawtypes", "unchecked" })
+ protected TableDataInfo getDataTable(List list)
+ {
+ TableDataInfo rspData = new TableDataInfo();
+ rspData.setCode(HttpStatus.SUCCESS);
+ rspData.setRows(list);
+ rspData.setMsg("鏌ヨ鎴愬姛");
+ rspData.setTotal(new PageInfo(list).getTotal());
+ return rspData;
+ }
+
+ /**
+ * 鍝嶅簲杩斿洖缁撴灉
+ *
+ * @param rows 褰卞搷琛屾暟
+ * @return 鎿嶄綔缁撴灉
+ */
+ protected AjaxResult toAjax(int rows)
+ {
+ return rows > 0 ? AjaxResult.success() : AjaxResult.error();
+ }
+}
diff --git a/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/web/domain/AjaxResult.java b/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/web/domain/AjaxResult.java
new file mode 100644
index 0000000..03a0716
--- /dev/null
+++ b/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/web/domain/AjaxResult.java
@@ -0,0 +1,162 @@
+package com.zhentao.common.core.web.domain;
+
+import java.util.HashMap;
+import com.zhentao.common.core.constant.HttpStatus;
+import com.zhentao.common.core.utils.StringUtils;
+
+/**
+ * 鎿嶄綔娑堟伅鎻愰啋
+ *
+ * @author ruoyi
+ */
+public class AjaxResult extends HashMap
+{
+ private static final long serialVersionUID = 1L;
+
+ /** 鐘舵佺爜 */
+ public static final String CODE_TAG = "code";
+
+ /** 杩斿洖鍐呭 */
+ public static final String MSG_TAG = "msg";
+
+ /** 鏁版嵁瀵硅薄 */
+ public static final String DATA_TAG = "data";
+
+ /**
+ * 鍒濆鍖栦竴涓柊鍒涘缓鐨 AjaxResult 瀵硅薄锛屼娇鍏惰〃绀轰竴涓┖娑堟伅銆
+ */
+ public AjaxResult()
+ {
+ }
+
+ /**
+ * 鍒濆鍖栦竴涓柊鍒涘缓鐨 AjaxResult 瀵硅薄
+ *
+ * @param code 鐘舵佺爜
+ * @param msg 杩斿洖鍐呭
+ */
+ public AjaxResult(int code, String msg)
+ {
+ super.put(CODE_TAG, code);
+ super.put(MSG_TAG, msg);
+ }
+
+ /**
+ * 鍒濆鍖栦竴涓柊鍒涘缓鐨 AjaxResult 瀵硅薄
+ *
+ * @param code 鐘舵佺爜
+ * @param msg 杩斿洖鍐呭
+ * @param data 鏁版嵁瀵硅薄
+ */
+ public AjaxResult(int code, String msg, Object data)
+ {
+ super.put(CODE_TAG, code);
+ super.put(MSG_TAG, msg);
+ if (StringUtils.isNotNull(data))
+ {
+ super.put(DATA_TAG, data);
+ }
+ }
+
+ /**
+ * 鏂逛究閾惧紡璋冪敤
+ *
+ * @param key
+ * @param value
+ * @return
+ */
+ @Override
+ public AjaxResult put(String key, Object value)
+ {
+ super.put(key, value);
+ return this;
+ }
+
+ /**
+ * 杩斿洖鎴愬姛娑堟伅
+ *
+ * @return 鎴愬姛娑堟伅
+ */
+ public static AjaxResult success()
+ {
+ return AjaxResult.success("鎿嶄綔鎴愬姛");
+ }
+
+ /**
+ * 杩斿洖鎴愬姛鏁版嵁
+ *
+ * @return 鎴愬姛娑堟伅
+ */
+ public static AjaxResult success(Object data)
+ {
+ return AjaxResult.success("鎿嶄綔鎴愬姛", data);
+ }
+
+ /**
+ * 杩斿洖鎴愬姛娑堟伅
+ *
+ * @param msg 杩斿洖鍐呭
+ * @return 鎴愬姛娑堟伅
+ */
+ public static AjaxResult success(String msg)
+ {
+ return AjaxResult.success(msg, null);
+ }
+
+ /**
+ * 杩斿洖鎴愬姛娑堟伅
+ *
+ * @param msg 杩斿洖鍐呭
+ * @param data 鏁版嵁瀵硅薄
+ * @return 鎴愬姛娑堟伅
+ */
+ public static AjaxResult success(String msg, Object data)
+ {
+ return new AjaxResult(HttpStatus.SUCCESS, msg, data);
+ }
+
+ /**
+ * 杩斿洖閿欒娑堟伅
+ *
+ * @return
+ */
+ public static AjaxResult error()
+ {
+ return AjaxResult.error("鎿嶄綔澶辫触");
+ }
+
+ /**
+ * 杩斿洖閿欒娑堟伅
+ *
+ * @param msg 杩斿洖鍐呭
+ * @return 璀﹀憡娑堟伅
+ */
+ public static AjaxResult error(String msg)
+ {
+ return AjaxResult.error(msg, null);
+ }
+
+ /**
+ * 杩斿洖閿欒娑堟伅
+ *
+ * @param msg 杩斿洖鍐呭
+ * @param data 鏁版嵁瀵硅薄
+ * @return 璀﹀憡娑堟伅
+ */
+ public static AjaxResult error(String msg, Object data)
+ {
+ return new AjaxResult(HttpStatus.ERROR, msg, data);
+ }
+
+ /**
+ * 杩斿洖閿欒娑堟伅
+ *
+ * @param code 鐘舵佺爜
+ * @param msg 杩斿洖鍐呭
+ * @return 璀﹀憡娑堟伅
+ */
+ public static AjaxResult error(int code, String msg)
+ {
+ return new AjaxResult(code, msg, null);
+ }
+}
diff --git a/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/web/domain/BaseEntity.java b/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/web/domain/BaseEntity.java
new file mode 100644
index 0000000..3bbe0f4
--- /dev/null
+++ b/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/web/domain/BaseEntity.java
@@ -0,0 +1,114 @@
+package com.zhentao.common.core.web.domain;
+
+import java.io.Serializable;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Map;
+import com.fasterxml.jackson.annotation.JsonFormat;
+
+/**
+ * Entity鍩虹被
+ *
+ * @author ruoyi
+ */
+public class BaseEntity implements Serializable
+{
+ private static final long serialVersionUID = 1L;
+
+ /** 鎼滅储鍊 */
+ private String searchValue;
+
+ /** 鍒涘缓鑰 */
+ private String createBy;
+
+ /** 鍒涘缓鏃堕棿 */
+ @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+ private Date createTime;
+
+ /** 鏇存柊鑰 */
+ private String updateBy;
+
+ /** 鏇存柊鏃堕棿 */
+ @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+ private Date updateTime;
+
+ /** 澶囨敞 */
+ private String remark;
+
+ /** 璇锋眰鍙傛暟 */
+ private Map params;
+
+ public String getSearchValue()
+ {
+ return searchValue;
+ }
+
+ public void setSearchValue(String searchValue)
+ {
+ this.searchValue = searchValue;
+ }
+
+ public String getCreateBy()
+ {
+ return createBy;
+ }
+
+ public void setCreateBy(String createBy)
+ {
+ this.createBy = createBy;
+ }
+
+ public Date getCreateTime()
+ {
+ return createTime;
+ }
+
+ public void setCreateTime(Date createTime)
+ {
+ this.createTime = createTime;
+ }
+
+ public String getUpdateBy()
+ {
+ return updateBy;
+ }
+
+ public void setUpdateBy(String updateBy)
+ {
+ this.updateBy = updateBy;
+ }
+
+ public Date getUpdateTime()
+ {
+ return updateTime;
+ }
+
+ public void setUpdateTime(Date updateTime)
+ {
+ this.updateTime = updateTime;
+ }
+
+ public String getRemark()
+ {
+ return remark;
+ }
+
+ public void setRemark(String remark)
+ {
+ this.remark = remark;
+ }
+
+ public Map getParams()
+ {
+ if (params == null)
+ {
+ params = new HashMap<>();
+ }
+ return params;
+ }
+
+ public void setParams(Map params)
+ {
+ this.params = params;
+ }
+}
diff --git a/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/web/domain/TreeEntity.java b/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/web/domain/TreeEntity.java
new file mode 100644
index 0000000..fd0c245
--- /dev/null
+++ b/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/web/domain/TreeEntity.java
@@ -0,0 +1,79 @@
+package com.zhentao.common.core.web.domain;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Tree鍩虹被
+ *
+ * @author ruoyi
+ */
+public class TreeEntity extends BaseEntity
+{
+ private static final long serialVersionUID = 1L;
+
+ /** 鐖惰彍鍗曞悕绉 */
+ private String parentName;
+
+ /** 鐖惰彍鍗旾D */
+ private Long parentId;
+
+ /** 鏄剧ず椤哄簭 */
+ private Integer orderNum;
+
+ /** 绁栫骇鍒楄〃 */
+ private String ancestors;
+
+ /** 瀛愰儴闂 */
+ private List children = new ArrayList<>();
+
+ public String getParentName()
+ {
+ return parentName;
+ }
+
+ public void setParentName(String parentName)
+ {
+ this.parentName = parentName;
+ }
+
+ public Long getParentId()
+ {
+ return parentId;
+ }
+
+ public void setParentId(Long parentId)
+ {
+ this.parentId = parentId;
+ }
+
+ public Integer getOrderNum()
+ {
+ return orderNum;
+ }
+
+ public void setOrderNum(Integer orderNum)
+ {
+ this.orderNum = orderNum;
+ }
+
+ public String getAncestors()
+ {
+ return ancestors;
+ }
+
+ public void setAncestors(String ancestors)
+ {
+ this.ancestors = ancestors;
+ }
+
+ public List getChildren()
+ {
+ return children;
+ }
+
+ public void setChildren(List children)
+ {
+ this.children = children;
+ }
+}
diff --git a/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/web/page/PageDomain.java b/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/web/page/PageDomain.java
new file mode 100644
index 0000000..a01bac3
--- /dev/null
+++ b/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/web/page/PageDomain.java
@@ -0,0 +1,72 @@
+package com.zhentao.common.core.web.page;
+
+import com.zhentao.common.core.utils.StringUtils;
+
+/**
+ * 鍒嗛〉鏁版嵁
+ *
+ * @author ruoyi
+ */
+public class PageDomain
+{
+ /** 褰撳墠璁板綍璧峰绱㈠紩 */
+ private Integer pageNum;
+
+ /** 姣忛〉鏄剧ず璁板綍鏁 */
+ private Integer pageSize;
+
+ /** 鎺掑簭鍒 */
+ private String orderByColumn;
+
+ /** 鎺掑簭鐨勬柟鍚慸esc鎴栬卆sc */
+ private String isAsc = "asc";
+
+ public String getOrderBy()
+ {
+ if (StringUtils.isEmpty(orderByColumn))
+ {
+ return "";
+ }
+ return StringUtils.toUnderScoreCase(orderByColumn) + " " + isAsc;
+ }
+
+ public Integer getPageNum()
+ {
+ return pageNum;
+ }
+
+ public void setPageNum(Integer pageNum)
+ {
+ this.pageNum = pageNum;
+ }
+
+ public Integer getPageSize()
+ {
+ return pageSize;
+ }
+
+ public void setPageSize(Integer pageSize)
+ {
+ this.pageSize = pageSize;
+ }
+
+ public String getOrderByColumn()
+ {
+ return orderByColumn;
+ }
+
+ public void setOrderByColumn(String orderByColumn)
+ {
+ this.orderByColumn = orderByColumn;
+ }
+
+ public String getIsAsc()
+ {
+ return isAsc;
+ }
+
+ public void setIsAsc(String isAsc)
+ {
+ this.isAsc = isAsc;
+ }
+}
diff --git a/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/web/page/TableDataInfo.java b/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/web/page/TableDataInfo.java
new file mode 100644
index 0000000..0cbc3bb
--- /dev/null
+++ b/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/web/page/TableDataInfo.java
@@ -0,0 +1,85 @@
+package com.zhentao.common.core.web.page;
+
+import java.io.Serializable;
+import java.util.List;
+
+/**
+ * 琛ㄦ牸鍒嗛〉鏁版嵁瀵硅薄
+ *
+ * @author ruoyi
+ */
+public class TableDataInfo implements Serializable
+{
+ private static final long serialVersionUID = 1L;
+
+ /** 鎬昏褰曟暟 */
+ private long total;
+
+ /** 鍒楄〃鏁版嵁 */
+ private List rows;
+
+ /** 娑堟伅鐘舵佺爜 */
+ private int code;
+
+ /** 娑堟伅鍐呭 */
+ private String msg;
+
+ /**
+ * 琛ㄦ牸鏁版嵁瀵硅薄
+ */
+ public TableDataInfo()
+ {
+ }
+
+ /**
+ * 鍒嗛〉
+ *
+ * @param list 鍒楄〃鏁版嵁
+ * @param total 鎬昏褰曟暟
+ */
+ public TableDataInfo(List list, int total)
+ {
+ this.rows = list;
+ this.total = total;
+ }
+
+ public long getTotal()
+ {
+ return total;
+ }
+
+ public void setTotal(long total)
+ {
+ this.total = total;
+ }
+
+ public List getRows()
+ {
+ return rows;
+ }
+
+ public void setRows(List rows)
+ {
+ this.rows = rows;
+ }
+
+ public int getCode()
+ {
+ return code;
+ }
+
+ public void setCode(int code)
+ {
+ this.code = code;
+ }
+
+ public String getMsg()
+ {
+ return msg;
+ }
+
+ public void setMsg(String msg)
+ {
+ this.msg = msg;
+ }
+}
diff --git a/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/web/page/TableSupport.java b/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/web/page/TableSupport.java
new file mode 100644
index 0000000..c63cc6e
--- /dev/null
+++ b/smart-common/smart-common-core/src/main/java/com/zhentao/common/core/web/page/TableSupport.java
@@ -0,0 +1,49 @@
+package com.zhentao.common.core.web.page;
+
+import com.zhentao.common.core.utils.ServletUtils;
+
+/**
+ * 琛ㄦ牸鏁版嵁澶勭悊
+ *
+ * @author ruoyi
+ */
+public class TableSupport
+{
+ /**
+ * 褰撳墠璁板綍璧峰绱㈠紩
+ */
+ public static final String PAGE_NUM = "pageNum";
+
+ /**
+ * 姣忛〉鏄剧ず璁板綍鏁
+ */
+ public static final String PAGE_SIZE = "pageSize";
+
+ /**
+ * 鎺掑簭鍒
+ */
+ public static final String ORDER_BY_COLUMN = "orderByColumn";
+
+ /**
+ * 鎺掑簭鐨勬柟鍚 "desc" 鎴栬 "asc".
+ */
+ public static final String IS_ASC = "isAsc";
+
+ /**
+ * 灏佽鍒嗛〉瀵硅薄
+ */
+ public static PageDomain getPageDomain()
+ {
+ PageDomain pageDomain = new PageDomain();
+ pageDomain.setPageNum(ServletUtils.getParameterToInt(PAGE_NUM));
+ pageDomain.setPageSize(ServletUtils.getParameterToInt(PAGE_SIZE));
+ pageDomain.setOrderByColumn(ServletUtils.getParameter(ORDER_BY_COLUMN));
+ pageDomain.setIsAsc(ServletUtils.getParameter(IS_ASC));
+ return pageDomain;
+ }
+
+ public static PageDomain buildPageRequest()
+ {
+ return getPageDomain();
+ }
+}
diff --git a/smart-common/smart-common-core/src/main/resources/META-INF/spring.factories b/smart-common/smart-common-core/src/main/resources/META-INF/spring.factories
new file mode 100644
index 0000000..220da13
--- /dev/null
+++ b/smart-common/smart-common-core/src/main/resources/META-INF/spring.factories
@@ -0,0 +1,5 @@
+org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
+ com.zhentao.common.core.utils.SpringUtils,\
+ com.zhentao.common.core.config.MybatisPlusConfig
+
+
diff --git a/smart-common/smart-common-datascope/pom.xml b/smart-common/smart-common-datascope/pom.xml
new file mode 100644
index 0000000..5d13548
--- /dev/null
+++ b/smart-common/smart-common-datascope/pom.xml
@@ -0,0 +1,27 @@
+
+
+
+ com.ruoyi
+ smart-common
+ 2.5.0
+
+ 4.0.0
+
+ smart-common-datascope
+
+
+ smart-common-datascope鏉冮檺鑼冨洿
+
+
+
+
+
+
+ com.ruoyi
+ smart-common-security
+
+
+
+
diff --git a/smart-common/smart-common-datascope/src/main/java/com/zhentao/common/datascope/annotation/DataScope.java b/smart-common/smart-common-datascope/src/main/java/com/zhentao/common/datascope/annotation/DataScope.java
new file mode 100644
index 0000000..ae63a35
--- /dev/null
+++ b/smart-common/smart-common-datascope/src/main/java/com/zhentao/common/datascope/annotation/DataScope.java
@@ -0,0 +1,28 @@
+package com.zhentao.common.datascope.annotation;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * 鏁版嵁鏉冮檺杩囨护娉ㄨВ
+ *
+ * @author ruoyi
+ */
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+public @interface DataScope
+{
+ /**
+ * 閮ㄩ棬琛ㄧ殑鍒悕
+ */
+ public String deptAlias() default "";
+
+ /**
+ * 鐢ㄦ埛琛ㄧ殑鍒悕
+ */
+ public String userAlias() default "";
+}
diff --git a/smart-common/smart-common-datascope/src/main/java/com/zhentao/common/datascope/aspect/DataScopeAspect.java b/smart-common/smart-common-datascope/src/main/java/com/zhentao/common/datascope/aspect/DataScopeAspect.java
new file mode 100644
index 0000000..777ee2c
--- /dev/null
+++ b/smart-common/smart-common-datascope/src/main/java/com/zhentao/common/datascope/aspect/DataScopeAspect.java
@@ -0,0 +1,173 @@
+package com.zhentao.common.datascope.aspect;
+
+import java.lang.reflect.Method;
+
+import com.zhentao.common.datascope.annotation.DataScope;
+import org.aspectj.lang.JoinPoint;
+import org.aspectj.lang.Signature;
+import org.aspectj.lang.annotation.Aspect;
+import org.aspectj.lang.annotation.Before;
+import org.aspectj.lang.annotation.Pointcut;
+import org.aspectj.lang.reflect.MethodSignature;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+import com.zhentao.common.core.utils.StringUtils;
+import com.zhentao.common.core.web.domain.BaseEntity;
+import com.zhentao.common.security.service.TokenService;
+import com.zhentao.system.api.domain.SysRole;
+import com.zhentao.system.api.domain.SysUser;
+import com.zhentao.system.api.model.LoginUser;
+
+/**
+ * 鏁版嵁杩囨护澶勭悊
+ *
+ * @author ruoyi
+ */
+@Aspect
+@Component
+public class DataScopeAspect
+{
+ /**
+ * 鍏ㄩ儴鏁版嵁鏉冮檺
+ */
+ public static final String DATA_SCOPE_ALL = "1";
+
+ /**
+ * 鑷畾鏁版嵁鏉冮檺
+ */
+ public static final String DATA_SCOPE_CUSTOM = "2";
+
+ /**
+ * 閮ㄩ棬鏁版嵁鏉冮檺
+ */
+ public static final String DATA_SCOPE_DEPT = "3";
+
+ /**
+ * 閮ㄩ棬鍙婁互涓嬫暟鎹潈闄
+ */
+ public static final String DATA_SCOPE_DEPT_AND_CHILD = "4";
+
+ /**
+ * 浠呮湰浜烘暟鎹潈闄
+ */
+ public static final String DATA_SCOPE_SELF = "5";
+
+ /**
+ * 鏁版嵁鏉冮檺杩囨护鍏抽敭瀛
+ */
+ public static final String DATA_SCOPE = "dataScope";
+
+ @Autowired
+ private TokenService tokenService;
+
+ // 閰嶇疆缁囧叆鐐
+ @Pointcut("@annotation(com.zhentao.common.datascope.annotation.DataScope)")
+ public void dataScopePointCut()
+ {
+ }
+
+ @Before("dataScopePointCut()")
+ public void doBefore(JoinPoint point) throws Throwable
+ {
+ handleDataScope(point);
+ }
+
+ protected void handleDataScope(final JoinPoint joinPoint)
+ {
+ // 鑾峰緱娉ㄨВ
+ DataScope controllerDataScope = getAnnotationLog(joinPoint);
+ if (controllerDataScope == null)
+ {
+ return;
+ }
+ // 鑾峰彇褰撳墠鐨勭敤鎴
+ LoginUser loginUser = tokenService.getLoginUser();
+ if (StringUtils.isNotNull(loginUser))
+ {
+ SysUser currentUser = loginUser.getSysUser();
+ // 濡傛灉鏄秴绾х鐞嗗憳锛屽垯涓嶈繃婊ゆ暟鎹
+ if (StringUtils.isNotNull(currentUser) && !currentUser.isAdmin())
+ {
+ dataScopeFilter(joinPoint, currentUser, controllerDataScope.deptAlias(),
+ controllerDataScope.userAlias());
+ }
+ }
+ }
+
+ /**
+ * 鏁版嵁鑼冨洿杩囨护
+ *
+ * @param joinPoint 鍒囩偣
+ * @param user 鐢ㄦ埛
+ * @param deptAlias 閮ㄩ棬鍒悕
+ * @param userAlias 鐢ㄦ埛鍒悕
+ */
+ public static void dataScopeFilter(JoinPoint joinPoint, SysUser user, String deptAlias, String userAlias)
+ {
+ StringBuilder sqlString = new StringBuilder();
+
+ for (SysRole role : user.getRoles())
+ {
+ String dataScope = role.getDataScope();
+ if (DATA_SCOPE_ALL.equals(dataScope))
+ {
+ sqlString = new StringBuilder();
+ break;
+ }
+ else if (DATA_SCOPE_CUSTOM.equals(dataScope))
+ {
+ sqlString.append(StringUtils.format(
+ " OR {}.dept_id IN ( SELECT dept_id FROM sys_role_dept WHERE role_id = {} ) ", deptAlias,
+ role.getRoleId()));
+ }
+ else if (DATA_SCOPE_DEPT.equals(dataScope))
+ {
+ sqlString.append(StringUtils.format(" OR {}.dept_id = {} ", deptAlias, user.getDeptId()));
+ }
+ else if (DATA_SCOPE_DEPT_AND_CHILD.equals(dataScope))
+ {
+ sqlString.append(StringUtils.format(
+ " OR {}.dept_id IN ( SELECT dept_id FROM sys_dept WHERE dept_id = {} or find_in_set( {} , ancestors ) )",
+ deptAlias, user.getDeptId(), user.getDeptId()));
+ }
+ else if (DATA_SCOPE_SELF.equals(dataScope))
+ {
+ if (StringUtils.isNotBlank(userAlias))
+ {
+ sqlString.append(StringUtils.format(" OR {}.user_id = {} ", userAlias, user.getUserId()));
+ }
+ else
+ {
+ // 鏁版嵁鏉冮檺涓轰粎鏈汉涓旀病鏈塽serAlias鍒悕涓嶆煡璇换浣曟暟鎹
+ sqlString.append(" OR 1=0 ");
+ }
+ }
+ }
+
+ if (StringUtils.isNotBlank(sqlString.toString()))
+ {
+ Object params = joinPoint.getArgs()[0];
+ if (StringUtils.isNotNull(params) && params instanceof BaseEntity)
+ {
+ BaseEntity baseEntity = (BaseEntity) params;
+ baseEntity.getParams().put(DATA_SCOPE, " AND (" + sqlString.substring(4) + ")");
+ }
+ }
+ }
+
+ /**
+ * 鏄惁瀛樺湪娉ㄨВ锛屽鏋滃瓨鍦ㄥ氨鑾峰彇
+ */
+ private DataScope getAnnotationLog(JoinPoint joinPoint)
+ {
+ Signature signature = joinPoint.getSignature();
+ MethodSignature methodSignature = (MethodSignature) signature;
+ Method method = methodSignature.getMethod();
+
+ if (method != null)
+ {
+ return method.getAnnotation(DataScope.class);
+ }
+ return null;
+ }
+}
diff --git a/smart-common/smart-common-datascope/src/main/resources/META-INF/spring.factories b/smart-common/smart-common-datascope/src/main/resources/META-INF/spring.factories
new file mode 100644
index 0000000..4ac8a25
--- /dev/null
+++ b/smart-common/smart-common-datascope/src/main/resources/META-INF/spring.factories
@@ -0,0 +1,4 @@
+org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
+ com.zhentao.common.datascope.aspect.DataScopeAspect
+
+
diff --git a/smart-common/smart-common-datasource/pom.xml b/smart-common/smart-common-datasource/pom.xml
new file mode 100644
index 0000000..0e2e9e8
--- /dev/null
+++ b/smart-common/smart-common-datasource/pom.xml
@@ -0,0 +1,41 @@
+
+
+
+ com.ruoyi
+ smart-common
+ 2.5.0
+
+ 4.0.0
+
+ smart-common-datasource
+
+
+ smart-common-datasource澶氭暟鎹簮
+
+
+
+
+
+
+ com.alibaba
+ druid-spring-boot-starter
+ ${druid.version}
+
+
+
+
+ com.baomidou
+ dynamic-datasource-spring-boot-starter
+ ${dynamic-ds.version}
+
+
+
+
+ io.seata
+ seata-spring-boot-starter
+
+
+
+
diff --git a/smart-common/smart-common-datasource/src/main/java/com/zhentao/common/datasource/annotation/Master.java b/smart-common/smart-common-datasource/src/main/java/com/zhentao/common/datasource/annotation/Master.java
new file mode 100644
index 0000000..9d6e97a
--- /dev/null
+++ b/smart-common/smart-common-datasource/src/main/java/com/zhentao/common/datasource/annotation/Master.java
@@ -0,0 +1,22 @@
+package com.zhentao.common.datasource.annotation;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import com.baomidou.dynamic.datasource.annotation.DS;
+
+/**
+ * 涓诲簱鏁版嵁婧
+ *
+ * @author ruoyi
+ */
+@Target({ ElementType.TYPE, ElementType.METHOD })
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@DS("master")
+public @interface Master
+{
+
+}
diff --git a/smart-common/smart-common-datasource/src/main/java/com/zhentao/common/datasource/annotation/Slave.java b/smart-common/smart-common-datasource/src/main/java/com/zhentao/common/datasource/annotation/Slave.java
new file mode 100644
index 0000000..162d6ac
--- /dev/null
+++ b/smart-common/smart-common-datasource/src/main/java/com/zhentao/common/datasource/annotation/Slave.java
@@ -0,0 +1,22 @@
+package com.zhentao.common.datasource.annotation;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import com.baomidou.dynamic.datasource.annotation.DS;
+
+/**
+ * 浠庡簱鏁版嵁婧
+ *
+ * @author ruoyi
+ */
+@Target({ ElementType.TYPE, ElementType.METHOD })
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@DS("slave")
+public @interface Slave
+{
+
+}
diff --git a/smart-common/smart-common-log/pom.xml b/smart-common/smart-common-log/pom.xml
new file mode 100644
index 0000000..51495ca
--- /dev/null
+++ b/smart-common/smart-common-log/pom.xml
@@ -0,0 +1,27 @@
+
+
+
+ com.ruoyi
+ smart-common
+ 2.5.0
+
+ 4.0.0
+
+ smart-common-log
+
+
+ smart-common-log鏃ュ織璁板綍
+
+
+
+
+
+
+ com.ruoyi
+ smart-common-security
+
+
+
+
diff --git a/smart-common/smart-common-log/src/main/java/com/zhentao/common/log/annotation/Log.java b/smart-common/smart-common-log/src/main/java/com/zhentao/common/log/annotation/Log.java
new file mode 100644
index 0000000..0b92ad6
--- /dev/null
+++ b/smart-common/smart-common-log/src/main/java/com/zhentao/common/log/annotation/Log.java
@@ -0,0 +1,41 @@
+package com.zhentao.common.log.annotation;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import com.zhentao.common.log.enums.BusinessType;
+import com.zhentao.common.log.enums.OperatorType;
+
+/**
+ * 鑷畾涔夋搷浣滄棩蹇楄褰曟敞瑙
+ *
+ * @author ruoyi
+ *
+ */
+@Target({ ElementType.PARAMETER, ElementType.METHOD })
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+public @interface Log
+{
+ /**
+ * 妯″潡
+ */
+ public String title() default "";
+
+ /**
+ * 鍔熻兘
+ */
+ public BusinessType businessType() default BusinessType.OTHER;
+
+ /**
+ * 鎿嶄綔浜虹被鍒
+ */
+ public OperatorType operatorType() default OperatorType.MANAGE;
+
+ /**
+ * 鏄惁淇濆瓨璇锋眰鐨勫弬鏁
+ */
+ public boolean isSaveRequestData() default true;
+}
diff --git a/smart-common/smart-common-log/src/main/java/com/zhentao/common/log/aspect/LogAspect.java b/smart-common/smart-common-log/src/main/java/com/zhentao/common/log/aspect/LogAspect.java
new file mode 100644
index 0000000..34d4498
--- /dev/null
+++ b/smart-common/smart-common-log/src/main/java/com/zhentao/common/log/aspect/LogAspect.java
@@ -0,0 +1,242 @@
+package com.zhentao.common.log.aspect;
+
+import java.lang.reflect.Method;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Map;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import com.zhentao.common.log.annotation.Log;
+import com.zhentao.common.log.service.AsyncLogService;
+import org.aspectj.lang.JoinPoint;
+import org.aspectj.lang.Signature;
+import org.aspectj.lang.annotation.AfterReturning;
+import org.aspectj.lang.annotation.AfterThrowing;
+import org.aspectj.lang.annotation.Aspect;
+import org.aspectj.lang.annotation.Pointcut;
+import org.aspectj.lang.reflect.MethodSignature;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpMethod;
+import org.springframework.stereotype.Component;
+import org.springframework.web.multipart.MultipartFile;
+import com.alibaba.fastjson.JSON;
+import com.zhentao.common.core.utils.SecurityUtils;
+import com.zhentao.common.core.utils.ServletUtils;
+import com.zhentao.common.core.utils.StringUtils;
+import com.zhentao.common.core.utils.ip.IpUtils;
+import com.zhentao.common.log.enums.BusinessStatus;
+import com.zhentao.system.api.domain.SysOperLog;
+
+/**
+ * 鎿嶄綔鏃ュ織璁板綍澶勭悊
+ *
+ * @author ruoyi
+ */
+@Aspect
+@Component
+public class LogAspect
+{
+ private static final Logger log = LoggerFactory.getLogger(LogAspect.class);
+
+ @Autowired
+ private AsyncLogService asyncLogService;
+
+ // 閰嶇疆缁囧叆鐐
+ @Pointcut("@annotation(com.zhentao.common.log.annotation.Log)")
+ public void logPointCut()
+ {
+ }
+
+ /**
+ * 澶勭悊瀹岃姹傚悗鎵ц
+ *
+ * @param joinPoint 鍒囩偣
+ */
+ @AfterReturning(pointcut = "logPointCut()", returning = "jsonResult")
+ public void doAfterReturning(JoinPoint joinPoint, Object jsonResult)
+ {
+ handleLog(joinPoint, null, jsonResult);
+ }
+
+ /**
+ * 鎷︽埅寮傚父鎿嶄綔
+ *
+ * @param joinPoint 鍒囩偣
+ * @param e 寮傚父
+ */
+ @AfterThrowing(value = "logPointCut()", throwing = "e")
+ public void doAfterThrowing(JoinPoint joinPoint, Exception e)
+ {
+ handleLog(joinPoint, e, null);
+ }
+
+ protected void handleLog(final JoinPoint joinPoint, final Exception e, Object jsonResult)
+ {
+ try
+ {
+ // 鑾峰緱娉ㄨВ
+ Log controllerLog = getAnnotationLog(joinPoint);
+ if (controllerLog == null)
+ {
+ return;
+ }
+
+ // *========鏁版嵁搴撴棩蹇=========*//
+ SysOperLog operLog = new SysOperLog();
+ operLog.setStatus(BusinessStatus.SUCCESS.ordinal());
+ // 璇锋眰鐨勫湴鍧
+ String ip = IpUtils.getIpAddr(ServletUtils.getRequest());
+ operLog.setOperIp(ip);
+ // 杩斿洖鍙傛暟
+ operLog.setJsonResult(JSON.toJSONString(jsonResult));
+
+ operLog.setOperUrl(ServletUtils.getRequest().getRequestURI());
+ String username = SecurityUtils.getUsername();
+ if (StringUtils.isNotBlank(username))
+ {
+ operLog.setOperName(username);
+ }
+
+ if (e != null)
+ {
+ operLog.setStatus(BusinessStatus.FAIL.ordinal());
+ operLog.setErrorMsg(StringUtils.substring(e.getMessage(), 0, 2000));
+ }
+ // 璁剧疆鏂规硶鍚嶇О
+ String className = joinPoint.getTarget().getClass().getName();
+ String methodName = joinPoint.getSignature().getName();
+ operLog.setMethod(className + "." + methodName + "()");
+ // 璁剧疆璇锋眰鏂瑰紡
+ operLog.setRequestMethod(ServletUtils.getRequest().getMethod());
+ // 澶勭悊璁剧疆娉ㄨВ涓婄殑鍙傛暟
+ getControllerMethodDescription(joinPoint, controllerLog, operLog);
+ // 淇濆瓨鏁版嵁搴
+ asyncLogService.saveSysLog(operLog);
+ }
+ catch (Exception exp)
+ {
+ // 璁板綍鏈湴寮傚父鏃ュ織
+ log.error("==鍓嶇疆閫氱煡寮傚父==");
+ log.error("寮傚父淇℃伅:{}", exp.getMessage());
+ exp.printStackTrace();
+ }
+ }
+
+ /**
+ * 鑾峰彇娉ㄨВ涓鏂规硶鐨勬弿杩颁俊鎭 鐢ㄤ簬Controller灞傛敞瑙
+ *
+ * @param log 鏃ュ織
+ * @param operLog 鎿嶄綔鏃ュ織
+ * @throws Exception
+ */
+ public void getControllerMethodDescription(JoinPoint joinPoint, Log log, SysOperLog operLog) throws Exception
+ {
+ // 璁剧疆action鍔ㄤ綔
+ operLog.setBusinessType(log.businessType().ordinal());
+ // 璁剧疆鏍囬
+ operLog.setTitle(log.title());
+ // 璁剧疆鎿嶄綔浜虹被鍒
+ operLog.setOperatorType(log.operatorType().ordinal());
+ // 鏄惁闇瑕佷繚瀛榬equest锛屽弬鏁板拰鍊
+ if (log.isSaveRequestData())
+ {
+ // 鑾峰彇鍙傛暟鐨勪俊鎭紝浼犲叆鍒版暟鎹簱涓
+ setRequestValue(joinPoint, operLog);
+ }
+ }
+
+ /**
+ * 鑾峰彇璇锋眰鐨勫弬鏁帮紝鏀惧埌log涓
+ *
+ * @param operLog 鎿嶄綔鏃ュ織
+ * @throws Exception 寮傚父
+ */
+ private void setRequestValue(JoinPoint joinPoint, SysOperLog operLog) throws Exception
+ {
+ String requestMethod = operLog.getRequestMethod();
+ if (HttpMethod.PUT.name().equals(requestMethod) || HttpMethod.POST.name().equals(requestMethod))
+ {
+ String params = argsArrayToString(joinPoint.getArgs());
+ operLog.setOperParam(StringUtils.substring(params, 0, 2000));
+ }
+ }
+
+ /**
+ * 鏄惁瀛樺湪娉ㄨВ锛屽鏋滃瓨鍦ㄥ氨鑾峰彇
+ */
+ private Log getAnnotationLog(JoinPoint joinPoint) throws Exception
+ {
+ Signature signature = joinPoint.getSignature();
+ MethodSignature methodSignature = (MethodSignature) signature;
+ Method method = methodSignature.getMethod();
+
+ if (method != null)
+ {
+ return method.getAnnotation(Log.class);
+ }
+ return null;
+ }
+
+ /**
+ * 鍙傛暟鎷艰
+ */
+ private String argsArrayToString(Object[] paramsArray)
+ {
+ String params = "";
+ if (paramsArray != null && paramsArray.length > 0)
+ {
+ for (int i = 0; i < paramsArray.length; i++)
+ {
+ if (!isFilterObject(paramsArray[i]))
+ {
+ try
+ {
+ Object jsonObj = JSON.toJSON(paramsArray[i]);
+ params += jsonObj.toString() + " ";
+ }
+ catch (Exception e)
+ {
+ }
+ }
+ }
+ }
+ return params.trim();
+ }
+
+ /**
+ * 鍒ゆ柇鏄惁闇瑕佽繃婊ょ殑瀵硅薄銆
+ *
+ * @param o 瀵硅薄淇℃伅銆
+ * @return 濡傛灉鏄渶瑕佽繃婊ょ殑瀵硅薄锛屽垯杩斿洖true锛涘惁鍒欒繑鍥瀎alse銆
+ */
+ @SuppressWarnings("rawtypes")
+ public boolean isFilterObject(final Object o)
+ {
+ Class clazz = o.getClass();
+ if (clazz.isArray())
+ {
+ return clazz.getComponentType().isAssignableFrom(MultipartFile.class);
+ }
+ else if (Collection.class.isAssignableFrom(clazz))
+ {
+ Collection collection = (Collection) o;
+ for (Iterator iter = collection.iterator(); iter.hasNext();)
+ {
+ return iter.next() instanceof MultipartFile;
+ }
+ }
+ else if (Map.class.isAssignableFrom(clazz))
+ {
+ Map map = (Map) o;
+ for (Iterator iter = map.entrySet().iterator(); iter.hasNext();)
+ {
+ Map.Entry entry = (Map.Entry) iter.next();
+ return entry.getValue() instanceof MultipartFile;
+ }
+ }
+ return o instanceof MultipartFile || o instanceof HttpServletRequest || o instanceof HttpServletResponse;
+ }
+}
diff --git a/smart-common/smart-common-log/src/main/java/com/zhentao/common/log/enums/BusinessStatus.java b/smart-common/smart-common-log/src/main/java/com/zhentao/common/log/enums/BusinessStatus.java
new file mode 100644
index 0000000..a7a0a87
--- /dev/null
+++ b/smart-common/smart-common-log/src/main/java/com/zhentao/common/log/enums/BusinessStatus.java
@@ -0,0 +1,20 @@
+package com.zhentao.common.log.enums;
+
+/**
+ * 鎿嶄綔鐘舵
+ *
+ * @author ruoyi
+ *
+ */
+public enum BusinessStatus
+{
+ /**
+ * 鎴愬姛
+ */
+ SUCCESS,
+
+ /**
+ * 澶辫触
+ */
+ FAIL,
+}
diff --git a/smart-common/smart-common-log/src/main/java/com/zhentao/common/log/enums/BusinessType.java b/smart-common/smart-common-log/src/main/java/com/zhentao/common/log/enums/BusinessType.java
new file mode 100644
index 0000000..47e802d
--- /dev/null
+++ b/smart-common/smart-common-log/src/main/java/com/zhentao/common/log/enums/BusinessType.java
@@ -0,0 +1,59 @@
+package com.zhentao.common.log.enums;
+
+/**
+ * 涓氬姟鎿嶄綔绫诲瀷
+ *
+ * @author ruoyi
+ */
+public enum BusinessType
+{
+ /**
+ * 鍏跺畠
+ */
+ OTHER,
+
+ /**
+ * 鏂板
+ */
+ INSERT,
+
+ /**
+ * 淇敼
+ */
+ UPDATE,
+
+ /**
+ * 鍒犻櫎
+ */
+ DELETE,
+
+ /**
+ * 鎺堟潈
+ */
+ GRANT,
+
+ /**
+ * 瀵煎嚭
+ */
+ EXPORT,
+
+ /**
+ * 瀵煎叆
+ */
+ IMPORT,
+
+ /**
+ * 寮洪
+ */
+ FORCE,
+
+ /**
+ * 鐢熸垚浠ｇ爜
+ */
+ GENCODE,
+
+ /**
+ * 娓呯┖鏁版嵁
+ */
+ CLEAN,
+}
diff --git a/smart-common/smart-common-log/src/main/java/com/zhentao/common/log/enums/OperatorType.java b/smart-common/smart-common-log/src/main/java/com/zhentao/common/log/enums/OperatorType.java
new file mode 100644
index 0000000..2f16b5c
--- /dev/null
+++ b/smart-common/smart-common-log/src/main/java/com/zhentao/common/log/enums/OperatorType.java
@@ -0,0 +1,24 @@
+package com.zhentao.common.log.enums;
+
+/**
+ * 鎿嶄綔浜虹被鍒
+ *
+ * @author ruoyi
+ */
+public enum OperatorType
+{
+ /**
+ * 鍏跺畠
+ */
+ OTHER,
+
+ /**
+ * 鍚庡彴鐢ㄦ埛
+ */
+ MANAGE,
+
+ /**
+ * 鎵嬫満绔敤鎴
+ */
+ MOBILE
+}
diff --git a/smart-common/smart-common-log/src/main/java/com/zhentao/common/log/service/AsyncLogService.java b/smart-common/smart-common-log/src/main/java/com/zhentao/common/log/service/AsyncLogService.java
new file mode 100644
index 0000000..65e0299
--- /dev/null
+++ b/smart-common/smart-common-log/src/main/java/com/zhentao/common/log/service/AsyncLogService.java
@@ -0,0 +1,28 @@
+package com.zhentao.common.log.service;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.scheduling.annotation.Async;
+import org.springframework.stereotype.Service;
+import com.zhentao.system.api.RemoteLogService;
+import com.zhentao.system.api.domain.SysOperLog;
+
+/**
+ * 寮傛璋冪敤鏃ュ織鏈嶅姟
+ *
+ * @author ruoyi
+ */
+@Service
+public class AsyncLogService
+{
+ @Autowired
+ private RemoteLogService remoteLogService;
+
+ /**
+ * 淇濆瓨绯荤粺鏃ュ織璁板綍
+ */
+ @Async
+ public void saveSysLog(SysOperLog sysOperLog)
+ {
+ remoteLogService.saveLog(sysOperLog);
+ }
+}
diff --git a/smart-common/smart-common-log/src/main/resources/META-INF/spring.factories b/smart-common/smart-common-log/src/main/resources/META-INF/spring.factories
new file mode 100644
index 0000000..cddb85a
--- /dev/null
+++ b/smart-common/smart-common-log/src/main/resources/META-INF/spring.factories
@@ -0,0 +1,3 @@
+org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
+ com.zhentao.common.log.service.AsyncLogService,\
+ com.zhentao.common.log.aspect.LogAspect
diff --git a/smart-common/smart-common-redis/pom.xml b/smart-common/smart-common-redis/pom.xml
new file mode 100644
index 0000000..01ea17d
--- /dev/null
+++ b/smart-common/smart-common-redis/pom.xml
@@ -0,0 +1,33 @@
+
+
+
+ com.ruoyi
+ smart-common
+ 2.5.0
+
+ 4.0.0
+
+ smart-common-redis
+
+
+ smart-common-redis缂撳瓨鏈嶅姟
+
+
+
+
+
+
+ org.springframework.boot
+ spring-boot-starter-data-redis
+
+
+
+
+ com.ruoyi
+ smart-common-core
+
+
+
+
diff --git a/smart-common/smart-common-redis/src/main/java/com/zhentao/common/redis/configure/FastJson2JsonRedisSerializer.java b/smart-common/smart-common-redis/src/main/java/com/zhentao/common/redis/configure/FastJson2JsonRedisSerializer.java
new file mode 100644
index 0000000..39cb58b
--- /dev/null
+++ b/smart-common/smart-common-redis/src/main/java/com/zhentao/common/redis/configure/FastJson2JsonRedisSerializer.java
@@ -0,0 +1,71 @@
+package com.zhentao.common.redis.configure;
+
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.serializer.SerializerFeature;
+import com.fasterxml.jackson.databind.JavaType;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.type.TypeFactory;
+import org.springframework.data.redis.serializer.RedisSerializer;
+import org.springframework.data.redis.serializer.SerializationException;
+import com.alibaba.fastjson.parser.ParserConfig;
+import org.springframework.util.Assert;
+import java.nio.charset.Charset;
+
+/**
+ * Redis浣跨敤FastJson搴忓垪鍖
+ *
+ * @author ruoyi
+ */
+public class FastJson2JsonRedisSerializer implements RedisSerializer
+{
+ @SuppressWarnings("unused")
+ private ObjectMapper objectMapper = new ObjectMapper();
+
+ public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");
+
+ private Class clazz;
+
+ static
+ {
+ ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
+ }
+
+ public FastJson2JsonRedisSerializer(Class clazz)
+ {
+ super();
+ this.clazz = clazz;
+ }
+
+ @Override
+ public byte[] serialize(T t) throws SerializationException
+ {
+ if (t == null)
+ {
+ return new byte[0];
+ }
+ return JSON.toJSONString(t, SerializerFeature.WriteClassName).getBytes(DEFAULT_CHARSET);
+ }
+
+ @Override
+ public T deserialize(byte[] bytes) throws SerializationException
+ {
+ if (bytes == null || bytes.length <= 0)
+ {
+ return null;
+ }
+ String str = new String(bytes, DEFAULT_CHARSET);
+
+ return JSON.parseObject(str, clazz);
+ }
+
+ public void setObjectMapper(ObjectMapper objectMapper)
+ {
+ Assert.notNull(objectMapper, "'objectMapper' must not be null");
+ this.objectMapper = objectMapper;
+ }
+
+ protected JavaType getJavaType(Class clazz)
+ {
+ return TypeFactory.defaultInstance().constructType(clazz);
+ }
+}
diff --git a/smart-common/smart-common-redis/src/main/java/com/zhentao/common/redis/configure/RedisConfig.java b/smart-common/smart-common-redis/src/main/java/com/zhentao/common/redis/configure/RedisConfig.java
new file mode 100644
index 0000000..0e6cf55
--- /dev/null
+++ b/smart-common/smart-common-redis/src/main/java/com/zhentao/common/redis/configure/RedisConfig.java
@@ -0,0 +1,43 @@
+package com.zhentao.common.redis.configure;
+
+import org.springframework.cache.annotation.CachingConfigurerSupport;
+import org.springframework.cache.annotation.EnableCaching;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.redis.connection.RedisConnectionFactory;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.data.redis.serializer.StringRedisSerializer;
+import com.fasterxml.jackson.annotation.JsonAutoDetect;
+import com.fasterxml.jackson.annotation.PropertyAccessor;
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+/**
+ * redis閰嶇疆
+ *
+ * @author ruoyi
+ */
+@Configuration
+@EnableCaching
+public class RedisConfig extends CachingConfigurerSupport
+{
+ @Bean
+ @SuppressWarnings(value = { "unchecked", "rawtypes", "deprecation" })
+ public RedisTemplate redisTemplate(RedisConnectionFactory connectionFactory)
+ {
+ RedisTemplate template = new RedisTemplate<>();
+ template.setConnectionFactory(connectionFactory);
+
+ FastJson2JsonRedisSerializer serializer = new FastJson2JsonRedisSerializer(Object.class);
+
+ ObjectMapper mapper = new ObjectMapper();
+ mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
+ mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
+ serializer.setObjectMapper(mapper);
+
+ template.setValueSerializer(serializer);
+ // 浣跨敤StringRedisSerializer鏉ュ簭鍒楀寲鍜屽弽搴忓垪鍖杛edis鐨刱ey鍊
+ template.setKeySerializer(new StringRedisSerializer());
+ template.afterPropertiesSet();
+ return template;
+ }
+}
diff --git a/smart-common/smart-common-redis/src/main/java/com/zhentao/common/redis/service/RedisService.java b/smart-common/smart-common-redis/src/main/java/com/zhentao/common/redis/service/RedisService.java
new file mode 100644
index 0000000..3f49318
--- /dev/null
+++ b/smart-common/smart-common-redis/src/main/java/com/zhentao/common/redis/service/RedisService.java
@@ -0,0 +1,234 @@
+package com.zhentao.common.redis.service;
+
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.TimeUnit;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.redis.core.BoundSetOperations;
+import org.springframework.data.redis.core.HashOperations;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.data.redis.core.ValueOperations;
+import org.springframework.stereotype.Component;
+
+/**
+ * spring redis 宸ュ叿绫
+ *
+ * @author ruoyi
+ **/
+@SuppressWarnings(value = { "unchecked", "rawtypes" })
+@Component
+public class RedisService
+{
+ @Autowired
+ public RedisTemplate redisTemplate;
+
+ /**
+ * 缂撳瓨鍩烘湰鐨勫璞★紝Integer銆丼tring銆佸疄浣撶被绛
+ *
+ * @param key 缂撳瓨鐨勯敭鍊
+ * @param value 缂撳瓨鐨勫
+ */
+ public void setCacheObject(final String key, final T value)
+ {
+ redisTemplate.opsForValue().set(key, value);
+ }
+
+ /**
+ * 缂撳瓨鍩烘湰鐨勫璞★紝Integer銆丼tring銆佸疄浣撶被绛
+ *
+ * @param key 缂撳瓨鐨勯敭鍊
+ * @param value 缂撳瓨鐨勫
+ * @param timeout 鏃堕棿
+ * @param timeUnit 鏃堕棿棰楃矑搴
+ */
+ public void setCacheObject(final String key, final T value, final Long timeout, final TimeUnit timeUnit)
+ {
+ redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
+ }
+
+ /**
+ * 璁剧疆鏈夋晥鏃堕棿
+ *
+ * @param key Redis閿
+ * @param timeout 瓒呮椂鏃堕棿
+ * @return true=璁剧疆鎴愬姛锛沠alse=璁剧疆澶辫触
+ */
+ public boolean expire(final String key, final long timeout)
+ {
+ return expire(key, timeout, TimeUnit.SECONDS);
+ }
+
+ /**
+ * 璁剧疆鏈夋晥鏃堕棿
+ *
+ * @param key Redis閿
+ * @param timeout 瓒呮椂鏃堕棿
+ * @param unit 鏃堕棿鍗曚綅
+ * @return true=璁剧疆鎴愬姛锛沠alse=璁剧疆澶辫触
+ */
+ public boolean expire(final String key, final long timeout, final TimeUnit unit)
+ {
+ return redisTemplate.expire(key, timeout, unit);
+ }
+
+ /**
+ * 鑾峰緱缂撳瓨鐨勫熀鏈璞°
+ *
+ * @param key 缂撳瓨閿
+ * @return 缂撳瓨閿煎搴旂殑鏁版嵁
+ */
+ public T getCacheObject(final String key)
+ {
+ ValueOperations operation = redisTemplate.opsForValue();
+ return operation.get(key);
+ }
+
+ /**
+ * 鍒犻櫎鍗曚釜瀵硅薄
+ *
+ * @param key
+ */
+ public boolean deleteObject(final String key)
+ {
+ return redisTemplate.delete(key);
+ }
+
+ /**
+ * 鍒犻櫎闆嗗悎瀵硅薄
+ *
+ * @param collection 澶氫釜瀵硅薄
+ * @return
+ */
+ public long deleteObject(final Collection collection)
+ {
+ return redisTemplate.delete(collection);
+ }
+
+ /**
+ * 缂撳瓨List鏁版嵁
+ *
+ * @param key 缂撳瓨鐨勯敭鍊
+ * @param dataList 寰呯紦瀛樼殑List鏁版嵁
+ * @return 缂撳瓨鐨勫璞
+ */
+ public long setCacheList(final String key, final List dataList)
+ {
+ Long count = redisTemplate.opsForList().rightPushAll(key, dataList);
+ return count == null ? 0 : count;
+ }
+
+ /**
+ * 鑾峰緱缂撳瓨鐨刲ist瀵硅薄
+ *
+ * @param key 缂撳瓨鐨勯敭鍊
+ * @return 缂撳瓨閿煎搴旂殑鏁版嵁
+ */
+ public List getCacheList(final String key)
+ {
+ return redisTemplate.opsForList().range(key, 0, -1);
+ }
+
+ /**
+ * 缂撳瓨Set
+ *
+ * @param key 缂撳瓨閿
+ * @param dataSet 缂撳瓨鐨勬暟鎹
+ * @return 缂撳瓨鏁版嵁鐨勫璞
+ */
+ public BoundSetOperations setCacheSet(final String key, final Set dataSet)
+ {
+ BoundSetOperations setOperation = redisTemplate.boundSetOps(key);
+ Iterator it = dataSet.iterator();
+ while (it.hasNext())
+ {
+ setOperation.add(it.next());
+ }
+ return setOperation;
+ }
+
+ /**
+ * 鑾峰緱缂撳瓨鐨剆et
+ *
+ * @param key
+ * @return
+ */
+ public Set getCacheSet(final String key)
+ {
+ return redisTemplate.opsForSet().members(key);
+ }
+
+ /**
+ * 缂撳瓨Map
+ *
+ * @param key
+ * @param dataMap
+ */
+ public void setCacheMap(final String key, final Map dataMap)
+ {
+ if (dataMap != null) {
+ redisTemplate.opsForHash().putAll(key, dataMap);
+ }
+ }
+
+ /**
+ * 鑾峰緱缂撳瓨鐨凪ap
+ *
+ * @param key
+ * @return
+ */
+ public Map getCacheMap(final String key)
+ {
+ return redisTemplate.opsForHash().entries(key);
+ }
+
+ /**
+ * 寰Hash涓瓨鍏ユ暟鎹
+ *
+ * @param key Redis閿
+ * @param hKey Hash閿
+ * @param value 鍊
+ */
+ public void setCacheMapValue(final String key, final String hKey, final T value)
+ {
+ redisTemplate.opsForHash().put(key, hKey, value);
+ }
+
+ /**
+ * 鑾峰彇Hash涓殑鏁版嵁
+ *
+ * @param key Redis閿
+ * @param hKey Hash閿
+ * @return Hash涓殑瀵硅薄
+ */
+ public T getCacheMapValue(final String key, final String hKey)
+ {
+ HashOperations opsForHash = redisTemplate.opsForHash();
+ return opsForHash.get(key, hKey);
+ }
+
+ /**
+ * 鑾峰彇澶氫釜Hash涓殑鏁版嵁
+ *
+ * @param key Redis閿
+ * @param hKeys Hash閿泦鍚
+ * @return Hash瀵硅薄闆嗗悎
+ */
+ public List getMultiCacheMapValue(final String key, final Collection