diff --git a/src/main/java/com/muyu/config/runner/VehicleConfigRunner.java b/src/main/java/com/muyu/config/runner/VehicleConfigRunner.java
index ba79ab1..78c9425 100644
--- a/src/main/java/com/muyu/config/runner/VehicleConfigRunner.java
+++ b/src/main/java/com/muyu/config/runner/VehicleConfigRunner.java
@@ -75,7 +75,7 @@ public class VehicleConfigRunner implements ApplicationRunner {
                             model.getKey(), model.getMessageName(), model.getMessageTemplateValueList().size(),
                             model.getMessageTemplateValueList().isEmpty() ? "不合格，已过滤" : "合格"
                     );
-                    return model.getMessageTemplateValueList().isEmpty();
+                    return !model.getMessageTemplateValueList().isEmpty();
                 })
                 .forEach(model -> messageTemplateCache.put(model.getKey(), model));
         log.info("结束初始化加载报文模板耗时：[{}MS]---------------", System.currentTimeMillis() - startTime);
diff --git a/src/main/java/com/muyu/system/enums/MessageTemplateValueType.java b/src/main/java/com/muyu/system/enums/MessageTemplateValueType.java
index 7192e58..15fb8d3 100644
--- a/src/main/java/com/muyu/system/enums/MessageTemplateValueType.java
+++ b/src/main/java/com/muyu/system/enums/MessageTemplateValueType.java
@@ -1,5 +1,7 @@
 package com.muyu.system.enums;
 
+import java.util.Arrays;
+
 /**
  * @Author: DongZeLiang
  * @date: 2024/9/20
@@ -33,4 +35,10 @@ public enum MessageTemplateValueType {
     public String label () {
         return label;
     }
+
+    public static MessageTemplateValueType get(String code){
+        return Arrays.stream(MessageTemplateValueType.values())
+                .filter(valueType -> valueType.code.equals(code))
+                .findFirst().orElse(null);
+    }
 }
diff --git a/src/main/java/com/muyu/utils/Constants.java b/src/main/java/com/muyu/utils/Constants.java
new file mode 100644
index 0000000..54f4b8d
--- /dev/null
+++ b/src/main/java/com/muyu/utils/Constants.java
@@ -0,0 +1,134 @@
+package com.muyu.utils;
+
+/**
+ * 通用常量信息
+ *
+ * @author muyu
+ */
+public class Constants {
+    /**
+     * UTF-8 字符集
+     */
+    public static final String UTF8 = "UTF-8";
+
+    /**
+     * GBK 字符集
+     */
+    public static final String GBK = "GBK";
+
+    /**
+     * www主域
+     */
+    public static final String WWW = "www.";
+
+    /**
+     * RMI 远程方法调用
+     */
+    public static final String LOOKUP_RMI = "rmi:";
+
+    /**
+     * LDAP 远程方法调用
+     */
+    public static final String LOOKUP_LDAP = "ldap:";
+
+    /**
+     * LDAPS 远程方法调用
+     */
+    public static final String LOOKUP_LDAPS = "ldaps:";
+
+    /**
+     * http请求
+     */
+    public static final String HTTP = "http://";
+
+    /**
+     * https请求
+     */
+    public static final String HTTPS = "https://";
+
+    /**
+     * 成功标记
+     */
+    public static final Integer SUCCESS = 200;
+
+    /**
+     * 失败标记
+     */
+    public static final Integer FAIL = 500;
+
+    /**
+     * 登录成功状态
+     */
+    public static final String LOGIN_SUCCESS_STATUS = "0";
+
+    /**
+     * 登录失败状态
+     */
+    public static final String LOGIN_FAIL_STATUS = "1";
+
+    /**
+     * 登录成功
+     */
+    public static final String LOGIN_SUCCESS = "Success";
+
+    /**
+     * 注销
+     */
+    public static final String LOGOUT = "Logout";
+
+    /**
+     * 注册
+     */
+    public static final String REGISTER = "Register";
+
+    /**
+     * 登录失败
+     */
+    public static final String LOGIN_FAIL = "Error";
+
+    /**
+     * 当前记录起始索引
+     */
+    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 final long CAPTCHA_EXPIRATION = 2;
+
+    /**
+     * 资源映射路径 前缀
+     */
+    public static final String RESOURCE_PREFIX = "/profile";
+
+    /**
+     * 自动识别json对象白名单配置（仅允许解析的包名，范围越小越安全）
+     */
+    public static final String[] JSON_WHITELIST_STR = {"org.springframework", "com.muyu"};
+
+    /**
+     * 定时任务白名单配置（仅允许访问的包名，如其他需要可以自行添加）
+     */
+    public static final String[] JOB_WHITELIST_STR = {"com.muyu"};
+
+    /**
+     * 定时任务违规的字符
+     */
+    public static final String[] JOB_ERROR_STR = {"java.net.URL", "javax.naming.InitialContext", "org.yaml.snakeyaml",
+            "org.springframework", "org.apache", "com.muyu.common.core.utils.file"};
+}
diff --git a/src/main/java/com/muyu/utils/StringUtils.java b/src/main/java/com/muyu/utils/StringUtils.java
new file mode 100644
index 0000000..ef1ca21
--- /dev/null
+++ b/src/main/java/com/muyu/utils/StringUtils.java
@@ -0,0 +1,503 @@
+package com.muyu.utils;
+
+import com.muyu.utils.text.StrFormatter;
+import org.springframework.util.AntPathMatcher;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 字符串工具类
+ *
+ * @author muyu
+ */
+public class StringUtils extends org.apache.commons.lang3.StringUtils {
+    /**
+     * 空字符串
+     */
+    private static final String NULLSTR = "";
+
+    /**
+     * 下划线
+     */
+    private static final char SEPARATOR = '_';
+
+    /**
+     * 获取参数不为空值
+     *
+     * @param value defaultValue 要判断的value
+     *
+     * @return value 返回值
+     */
+    public static <T> T nvl (T value, T defaultValue) {
+        return value != null ? value : defaultValue;
+    }
+
+    /**
+     * * 判断一个Collection是否为空， 包含List，Set，Queue
+     *
+     * @param coll 要判断的Collection
+     *
+     * @return true：为空 false：非空
+     */
+    public static boolean isEmpty (Collection<?> coll) {
+        return isNull(coll) || coll.isEmpty();
+    }
+
+    /**
+     * * 判断一个Collection是否非空，包含List，Set，Queue
+     *
+     * @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);
+    }
+
+    /**
+     * * 判断一个Map是否为空
+     *
+     * @param map 要判断的Map
+     *
+     * @return true：为空 false：非空
+     */
+    public static boolean isEmpty (Map<?, ?> map) {
+        return isNull(map) || map.isEmpty();
+    }
+
+    /**
+     * * 判断一个Map是否为空
+     *
+     * @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);
+    }
+
+    /**
+     * * 判断一个对象是否是数组类型（Java基本型别的数组）
+     *
+     * @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);
+    }
+
+    /**
+     * 判断是否为空，并且不是空白字符
+     *
+     * @param str 要判断的value
+     *
+     * @return 结果
+     */
+    public static boolean hasText (String str) {
+        return (str != null && !str.isEmpty() && containsText(str));
+    }
+
+    private static boolean containsText (CharSequence str) {
+        int strLen = str.length();
+        for (int i = 0 ; i < strLen ; i++) {
+            if (!Character.isWhitespace(str.charAt(i))) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * 格式化文本, {} 表示占位符<br>
+     * 此方法只是简单将占位符 {} 按照顺序替换为参数<br>
+     * 如果想输出 {} 使用 \\转义 { 即可，如果想输出 {} 之前的 \ 使用双转义符 \\\\ 即可<br>
+     * 例：<br>
+     * 通常使用：format("this is {} for {}", "a", "b") -> this is a for b<br>
+     * 转义{}： format("this is \\{} for {}", "a", "b") -> this is \{} for a<br>
+     * 转义\： format("this is \\\\{} for {}", "a", "b") -> this is \a for b<br>
+     *
+     * @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);
+    }
+
+    /**
+     * 是否为http(s)://开头
+     *
+     * @param link 链接
+     *
+     * @return 结果
+     */
+    public static boolean ishttp (String link) {
+        return StringUtils.startsWithAny(link, Constants.HTTP, Constants.HTTPS);
+    }
+
+    /**
+     * 判断给定的collection列表中是否包含数组array 判断给定的数组array中是否包含给定的元素value
+     *
+     * @param collection 给定的集合
+     * @param array      给定的数组
+     *
+     * @return boolean 结果
+     */
+    public static boolean containsAny (Collection<String> collection, String... array) {
+        if (isEmpty(collection) || isEmpty(array)) {
+            return false;
+        } else {
+            for (String str : array) {
+                if (collection.contains(str)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+    }
+
+    /**
+     * 驼峰转下划线命名
+     */
+    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;
+    }
+
+    /**
+     * 将下划线大写方式命名的字符串转换为驼峰式。如果转换前的下划线大写方式命名的字符串为空，则返回空字符串。 例如：HELLO_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();
+    }
+
+    /**
+     * 驼峰式命名法
+     * 例如：user_name->userName
+     */
+    public static String toCamelCase (String s) {
+        if (s == null) {
+            return null;
+        }
+        if (s.indexOf(SEPARATOR) == -1) {
+            return s;
+        }
+        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<String> strs) {
+        if (isEmpty(str) || isEmpty(strs)) {
+            return false;
+        }
+        for (String pattern : strs) {
+            if (isMatch(pattern, str)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * 判断url是否与规则配置:
+     * ? 表示单个字符;
+     * * 表示一层路径内的任意字符串，不可跨层级;
+     * ** 表示任意层路径;
+     *
+     * @param pattern 匹配规则
+     * @param url     需要匹配的url
+     *
+     * @return
+     */
+    public static boolean isMatch (String pattern, String url) {
+        AntPathMatcher matcher = new AntPathMatcher();
+        return matcher.match(pattern, url);
+    }
+
+    @SuppressWarnings("unchecked")
+    public static <T> T cast (Object obj) {
+        return (T) obj;
+    }
+
+    /**
+     * 数字左边补齐0，使之达到指定长度。注意，如果数字转换为字符串后，长度大于size，则只保留 最后size个字符。
+     *
+     * @param num  数字对象
+     * @param size 字符串指定长度
+     *
+     * @return 返回数字的字符串格式，该字符串为指定长度。
+     */
+    public static final String padl (final Number num, final int size) {
+        return padl(num.toString(), size, '0');
+    }
+
+    /**
+     * 字符串左补齐。如果原始字符串s长度大于size，则只保留最后size个字符。
+     *
+     * @param s    原始字符串
+     * @param size 字符串指定长度
+     * @param c    用于补齐的字符
+     *
+     * @return 返回指定长度的字符串，由原字符串左补齐或截取得到。
+     */
+    public static final String padl (final String s, final int size, final char c) {
+        final StringBuilder sb = new StringBuilder(size);
+        if (s != null) {
+            final int len = s.length();
+            if (s.length() <= size) {
+                for (int i = size - len ; i > 0 ; i--) {
+                    sb.append(c);
+                }
+                sb.append(s);
+            } else {
+                return s.substring(len - size, len);
+            }
+        } else {
+            for (int i = size ; i > 0 ; i--) {
+                sb.append(c);
+            }
+        }
+        return sb.toString();
+    }
+}
diff --git a/src/main/java/com/muyu/utils/text/CharsetKit.java b/src/main/java/com/muyu/utils/text/CharsetKit.java
new file mode 100644
index 0000000..1c75b15
--- /dev/null
+++ b/src/main/java/com/muyu/utils/text/CharsetKit.java
@@ -0,0 +1,95 @@
+package com.muyu.utils.text;
+
+
+import com.muyu.utils.StringUtils;
+
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+
+/**
+ * 字符集工具类
+ *
+ * @author muyu
+ */
+public class CharsetKit {
+    /**
+     * ISO-8859-1
+     */
+    public static final String ISO_8859_1 = "ISO-8859-1";
+    /**
+     * UTF-8
+     */
+    public static final String UTF_8 = "UTF-8";
+    /**
+     * GBK
+     */
+    public static final String GBK = "GBK";
+
+    /**
+     * ISO-8859-1
+     */
+    public static final Charset CHARSET_ISO_8859_1 = Charset.forName(ISO_8859_1);
+    /**
+     * UTF-8
+     */
+    public static final Charset CHARSET_UTF_8 = Charset.forName(UTF_8);
+    /**
+     * GBK
+     */
+    public static final Charset CHARSET_GBK = Charset.forName(GBK);
+
+    /**
+     * 转换为Charset对象
+     *
+     * @param charset 字符集，为空则返回默认字符集
+     *
+     * @return Charset
+     */
+    public static Charset charset (String charset) {
+        return StringUtils.isEmpty(charset) ? Charset.defaultCharset() : Charset.forName(charset);
+    }
+
+    /**
+     * 转换字符串的字符集编码
+     *
+     * @param source      字符串
+     * @param srcCharset  源字符集，默认ISO-8859-1
+     * @param destCharset 目标字符集，默认UTF-8
+     *
+     * @return 转换后的字符集
+     */
+    public static String convert (String source, String srcCharset, String destCharset) {
+        return convert(source, Charset.forName(srcCharset), Charset.forName(destCharset));
+    }
+
+    /**
+     * 转换字符串的字符集编码
+     *
+     * @param source      字符串
+     * @param srcCharset  源字符集，默认ISO-8859-1
+     * @param destCharset 目标字符集，默认UTF-8
+     *
+     * @return 转换后的字符集
+     */
+    public static String convert (String source, Charset srcCharset, Charset destCharset) {
+        if (null == srcCharset) {
+            srcCharset = StandardCharsets.ISO_8859_1;
+        }
+
+        if (null == destCharset) {
+            destCharset = StandardCharsets.UTF_8;
+        }
+
+        if (StringUtils.isEmpty(source) || srcCharset.equals(destCharset)) {
+            return source;
+        }
+        return new String(source.getBytes(srcCharset), destCharset);
+    }
+
+    /**
+     * @return 系统字符集编码
+     */
+    public static String systemCharset () {
+        return Charset.defaultCharset().name();
+    }
+}
diff --git a/src/main/java/com/muyu/utils/text/Convert.java b/src/main/java/com/muyu/utils/text/Convert.java
new file mode 100644
index 0000000..d6f26c8
--- /dev/null
+++ b/src/main/java/com/muyu/utils/text/Convert.java
@@ -0,0 +1,904 @@
+package com.muyu.utils.text;
+
+
+import com.muyu.utils.StringUtils;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.math.RoundingMode;
+import java.nio.ByteBuffer;
+import java.nio.charset.Charset;
+import java.text.NumberFormat;
+import java.util.Set;
+
+/**
+ * 类型转换器
+ *
+ * @author muyu
+ */
+public class Convert {
+    /**
+     * 转换为字符串<br>
+     * 如果给定的值为null，或者转换失败，返回默认值<br>
+     * 转换失败不会报错
+     *
+     * @param value        被转换的值
+     * @param defaultValue 转换错误时的默认值
+     *
+     * @return 结果
+     */
+    public static String toStr (Object value, String defaultValue) {
+        if (null == value) {
+            return defaultValue;
+        }
+        if (value instanceof String) {
+            return (String) value;
+        }
+        return value.toString();
+    }
+
+    /**
+     * 转换为字符串<br>
+     * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>
+     * 转换失败不会报错
+     *
+     * @param value 被转换的值
+     *
+     * @return 结果
+     */
+    public static String toStr (Object value) {
+        return toStr(value, null);
+    }
+
+    /**
+     * 转换为字符<br>
+     * 如果给定的值为null，或者转换失败，返回默认值<br>
+     * 转换失败不会报错
+     *
+     * @param value        被转换的值
+     * @param defaultValue 转换错误时的默认值
+     *
+     * @return 结果
+     */
+    public static Character toChar (Object value, Character defaultValue) {
+        if (null == value) {
+            return defaultValue;
+        }
+        if (value instanceof Character) {
+            return (Character) value;
+        }
+
+        final String valueStr = toStr(value, null);
+        return StringUtils.isEmpty(valueStr) ? defaultValue : valueStr.charAt(0);
+    }
+
+    /**
+     * 转换为字符<br>
+     * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>
+     * 转换失败不会报错
+     *
+     * @param value 被转换的值
+     *
+     * @return 结果
+     */
+    public static Character toChar (Object value) {
+        return toChar(value, null);
+    }
+
+    /**
+     * 转换为byte<br>
+     * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<br>
+     * 转换失败不会报错
+     *
+     * @param value        被转换的值
+     * @param defaultValue 转换错误时的默认值
+     *
+     * @return 结果
+     */
+    public static Byte toByte (Object value, Byte defaultValue) {
+        if (value == null) {
+            return defaultValue;
+        }
+        if (value instanceof Byte) {
+            return (Byte) value;
+        }
+        if (value instanceof Number) {
+            return ((Number) value).byteValue();
+        }
+        final String valueStr = toStr(value, null);
+        if (StringUtils.isEmpty(valueStr)) {
+            return defaultValue;
+        }
+        try {
+            return Byte.parseByte(valueStr);
+        } catch (Exception e) {
+            return defaultValue;
+        }
+    }
+
+    /**
+     * 转换为byte<br>
+     * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>
+     * 转换失败不会报错
+     *
+     * @param value 被转换的值
+     *
+     * @return 结果
+     */
+    public static Byte toByte (Object value) {
+        return toByte(value, null);
+    }
+
+    /**
+     * 转换为Short<br>
+     * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<br>
+     * 转换失败不会报错
+     *
+     * @param value        被转换的值
+     * @param defaultValue 转换错误时的默认值
+     *
+     * @return 结果
+     */
+    public static Short toShort (Object value, Short defaultValue) {
+        if (value == null) {
+            return defaultValue;
+        }
+        if (value instanceof Short) {
+            return (Short) value;
+        }
+        if (value instanceof Number) {
+            return ((Number) value).shortValue();
+        }
+        final String valueStr = toStr(value, null);
+        if (StringUtils.isEmpty(valueStr)) {
+            return defaultValue;
+        }
+        try {
+            return Short.parseShort(valueStr.trim());
+        } catch (Exception e) {
+            return defaultValue;
+        }
+    }
+
+    /**
+     * 转换为Short<br>
+     * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>
+     * 转换失败不会报错
+     *
+     * @param value 被转换的值
+     *
+     * @return 结果
+     */
+    public static Short toShort (Object value) {
+        return toShort(value, null);
+    }
+
+    /**
+     * 转换为Number<br>
+     * 如果给定的值为空，或者转换失败，返回默认值<br>
+     * 转换失败不会报错
+     *
+     * @param value        被转换的值
+     * @param defaultValue 转换错误时的默认值
+     *
+     * @return 结果
+     */
+    public static Number toNumber (Object value, Number defaultValue) {
+        if (value == null) {
+            return defaultValue;
+        }
+        if (value instanceof Number) {
+            return (Number) value;
+        }
+        final String valueStr = toStr(value, null);
+        if (StringUtils.isEmpty(valueStr)) {
+            return defaultValue;
+        }
+        try {
+            return NumberFormat.getInstance().parse(valueStr);
+        } catch (Exception e) {
+            return defaultValue;
+        }
+    }
+
+    /**
+     * 转换为Number<br>
+     * 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>
+     * 转换失败不会报错
+     *
+     * @param value 被转换的值
+     *
+     * @return 结果
+     */
+    public static Number toNumber (Object value) {
+        return toNumber(value, null);
+    }
+
+    /**
+     * 转换为int<br>
+     * 如果给定的值为空，或者转换失败，返回默认值<br>
+     * 转换失败不会报错
+     *
+     * @param value        被转换的值
+     * @param defaultValue 转换错误时的默认值
+     *
+     * @return 结果
+     */
+    public static Integer toInt (Object value, Integer defaultValue) {
+        if (value == null) {
+            return defaultValue;
+        }
+        if (value instanceof Integer) {
+            return (Integer) value;
+        }
+        if (value instanceof Number) {
+            return ((Number) value).intValue();
+        }
+        final String valueStr = toStr(value, null);
+        if (StringUtils.isEmpty(valueStr)) {
+            return defaultValue;
+        }
+        try {
+            return Integer.parseInt(valueStr.trim());
+        } catch (Exception e) {
+            return defaultValue;
+        }
+    }
+
+    /**
+     * 转换为int<br>
+     * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>
+     * 转换失败不会报错
+     *
+     * @param value 被转换的值
+     *
+     * @return 结果
+     */
+    public static Integer toInt (Object value) {
+        return toInt(value, null);
+    }
+
+    /**
+     * 转换为Integer数组<br>
+     *
+     * @param str 被转换的值
+     *
+     * @return 结果
+     */
+    public static Integer[] toIntArray (String str) {
+        return toIntArray(",", str);
+    }
+
+    /**
+     * 转换为Long数组<br>
+     *
+     * @param str 被转换的值
+     *
+     * @return 结果
+     */
+    public static Long[] toLongArray (String str) {
+        return toLongArray(",", str);
+    }
+
+    /**
+     * 转换为Integer数组<br>
+     *
+     * @param split 分隔符
+     * @param str   被转换的值
+     *
+     * @return 结果
+     */
+    public static Integer[] toIntArray (String split, String str) {
+        if (StringUtils.isEmpty(str)) {
+            return new Integer[]{};
+        }
+        String[] arr = str.split(split);
+        final Integer[] ints = new Integer[arr.length];
+        for (int i = 0 ; i < arr.length ; i++) {
+            final Integer v = toInt(arr[i], 0);
+            ints[i] = v;
+        }
+        return ints;
+    }
+
+    /**
+     * 转换为Long数组<br>
+     *
+     * @param split 分隔符
+     * @param str   被转换的值
+     *
+     * @return 结果
+     */
+    public static Long[] toLongArray (String split, String str) {
+        if (StringUtils.isEmpty(str)) {
+            return new Long[]{};
+        }
+        String[] arr = str.split(split);
+        final Long[] longs = new Long[arr.length];
+        for (int i = 0 ; i < arr.length ; i++) {
+            final Long v = toLong(arr[i], null);
+            longs[i] = v;
+        }
+        return longs;
+    }
+
+    /**
+     * 转换为String数组<br>
+     *
+     * @param str 被转换的值
+     *
+     * @return 结果
+     */
+    public static String[] toStrArray (String str) {
+        return toStrArray(",", str);
+    }
+
+    /**
+     * 转换为String数组<br>
+     *
+     * @param split 分隔符
+     * @param str   被转换的值
+     *
+     * @return 结果
+     */
+    public static String[] toStrArray (String split, String str) {
+        return str.split(split);
+    }
+
+    /**
+     * 转换为long<br>
+     * 如果给定的值为空，或者转换失败，返回默认值<br>
+     * 转换失败不会报错
+     *
+     * @param value        被转换的值
+     * @param defaultValue 转换错误时的默认值
+     *
+     * @return 结果
+     */
+    public static Long toLong (Object value, Long defaultValue) {
+        if (value == null) {
+            return defaultValue;
+        }
+        if (value instanceof Long) {
+            return (Long) value;
+        }
+        if (value instanceof Number) {
+            return ((Number) value).longValue();
+        }
+        final String valueStr = toStr(value, null);
+        if (StringUtils.isEmpty(valueStr)) {
+            return defaultValue;
+        }
+        try {
+            // 支持科学计数法
+            return new BigDecimal(valueStr.trim()).longValue();
+        } catch (Exception e) {
+            return defaultValue;
+        }
+    }
+
+    /**
+     * 转换为long<br>
+     * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>
+     * 转换失败不会报错
+     *
+     * @param value 被转换的值
+     *
+     * @return 结果
+     */
+    public static Long toLong (Object value) {
+        return toLong(value, null);
+    }
+
+    /**
+     * 转换为double<br>
+     * 如果给定的值为空，或者转换失败，返回默认值<br>
+     * 转换失败不会报错
+     *
+     * @param value        被转换的值
+     * @param defaultValue 转换错误时的默认值
+     *
+     * @return 结果
+     */
+    public static Double toDouble (Object value, Double defaultValue) {
+        if (value == null) {
+            return defaultValue;
+        }
+        if (value instanceof Double) {
+            return (Double) value;
+        }
+        if (value instanceof Number) {
+            return ((Number) value).doubleValue();
+        }
+        final String valueStr = toStr(value, null);
+        if (StringUtils.isEmpty(valueStr)) {
+            return defaultValue;
+        }
+        try {
+            // 支持科学计数法
+            return new BigDecimal(valueStr.trim()).doubleValue();
+        } catch (Exception e) {
+            return defaultValue;
+        }
+    }
+
+    /**
+     * 转换为double<br>
+     * 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>
+     * 转换失败不会报错
+     *
+     * @param value 被转换的值
+     *
+     * @return 结果
+     */
+    public static Double toDouble (Object value) {
+        return toDouble(value, null);
+    }
+
+    /**
+     * 转换为Float<br>
+     * 如果给定的值为空，或者转换失败，返回默认值<br>
+     * 转换失败不会报错
+     *
+     * @param value        被转换的值
+     * @param defaultValue 转换错误时的默认值
+     *
+     * @return 结果
+     */
+    public static Float toFloat (Object value, Float defaultValue) {
+        if (value == null) {
+            return defaultValue;
+        }
+        if (value instanceof Float) {
+            return (Float) value;
+        }
+        if (value instanceof Number) {
+            return ((Number) value).floatValue();
+        }
+        final String valueStr = toStr(value, null);
+        if (StringUtils.isEmpty(valueStr)) {
+            return defaultValue;
+        }
+        try {
+            return Float.parseFloat(valueStr.trim());
+        } catch (Exception e) {
+            return defaultValue;
+        }
+    }
+
+    /**
+     * 转换为Float<br>
+     * 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>
+     * 转换失败不会报错
+     *
+     * @param value 被转换的值
+     *
+     * @return 结果
+     */
+    public static Float toFloat (Object value) {
+        return toFloat(value, null);
+    }
+
+    /**
+     * 转换为boolean<br>
+     * String支持的值为：true、false、yes、ok、no，1,0 如果给定的值为空，或者转换失败，返回默认值<br>
+     * 转换失败不会报错
+     *
+     * @param value        被转换的值
+     * @param defaultValue 转换错误时的默认值
+     *
+     * @return 结果
+     */
+    public static Boolean toBool (Object value, Boolean defaultValue) {
+        if (value == null) {
+            return defaultValue;
+        }
+        if (value instanceof Boolean) {
+            return (Boolean) value;
+        }
+        String valueStr = toStr(value, null);
+        if (StringUtils.isEmpty(valueStr)) {
+            return defaultValue;
+        }
+        valueStr = valueStr.trim().toLowerCase();
+        switch (valueStr) {
+            case "true":
+            case "yes":
+            case "ok":
+            case "1":
+                return true;
+            case "false":
+            case "no":
+            case "0":
+                return false;
+            default:
+                return defaultValue;
+        }
+    }
+
+    /**
+     * 转换为boolean<br>
+     * 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>
+     * 转换失败不会报错
+     *
+     * @param value 被转换的值
+     *
+     * @return 结果
+     */
+    public static Boolean toBool (Object value) {
+        return toBool(value, null);
+    }
+
+    /**
+     * 转换为Enum对象<br>
+     * 如果给定的值为空，或者转换失败，返回默认值<br>
+     *
+     * @param clazz        Enum的Class
+     * @param value        值
+     * @param defaultValue 默认值
+     *
+     * @return Enum
+     */
+    public static <E extends Enum<E>> E toEnum (Class<E> clazz, Object value, E defaultValue) {
+        if (value == null) {
+            return defaultValue;
+        }
+        if (clazz.isAssignableFrom(value.getClass())) {
+            @SuppressWarnings("unchecked")
+            E myE = (E) value;
+            return myE;
+        }
+        final String valueStr = toStr(value, null);
+        if (StringUtils.isEmpty(valueStr)) {
+            return defaultValue;
+        }
+        try {
+            return Enum.valueOf(clazz, valueStr);
+        } catch (Exception e) {
+            return defaultValue;
+        }
+    }
+
+    /**
+     * 转换为Enum对象<br>
+     * 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>
+     *
+     * @param clazz Enum的Class
+     * @param value 值
+     *
+     * @return Enum
+     */
+    public static <E extends Enum<E>> E toEnum (Class<E> clazz, Object value) {
+        return toEnum(clazz, value, null);
+    }
+
+    /**
+     * 转换为BigInteger<br>
+     * 如果给定的值为空，或者转换失败，返回默认值<br>
+     * 转换失败不会报错
+     *
+     * @param value        被转换的值
+     * @param defaultValue 转换错误时的默认值
+     *
+     * @return 结果
+     */
+    public static BigInteger toBigInteger (Object value, BigInteger defaultValue) {
+        if (value == null) {
+            return defaultValue;
+        }
+        if (value instanceof BigInteger) {
+            return (BigInteger) value;
+        }
+        if (value instanceof Long) {
+            return BigInteger.valueOf((Long) value);
+        }
+        final String valueStr = toStr(value, null);
+        if (StringUtils.isEmpty(valueStr)) {
+            return defaultValue;
+        }
+        try {
+            return new BigInteger(valueStr);
+        } catch (Exception e) {
+            return defaultValue;
+        }
+    }
+
+    /**
+     * 转换为BigInteger<br>
+     * 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>
+     * 转换失败不会报错
+     *
+     * @param value 被转换的值
+     *
+     * @return 结果
+     */
+    public static BigInteger toBigInteger (Object value) {
+        return toBigInteger(value, null);
+    }
+
+    /**
+     * 转换为BigDecimal<br>
+     * 如果给定的值为空，或者转换失败，返回默认值<br>
+     * 转换失败不会报错
+     *
+     * @param value        被转换的值
+     * @param defaultValue 转换错误时的默认值
+     *
+     * @return 结果
+     */
+    public static BigDecimal toBigDecimal (Object value, BigDecimal defaultValue) {
+        if (value == null) {
+            return defaultValue;
+        }
+        if (value instanceof BigDecimal) {
+            return (BigDecimal) value;
+        }
+        if (value instanceof Long) {
+            return new BigDecimal((Long) value);
+        }
+        if (value instanceof Double) {
+            return BigDecimal.valueOf((Double) value);
+        }
+        if (value instanceof Integer) {
+            return new BigDecimal((Integer) value);
+        }
+        final String valueStr = toStr(value, null);
+        if (StringUtils.isEmpty(valueStr)) {
+            return defaultValue;
+        }
+        try {
+            return new BigDecimal(valueStr);
+        } catch (Exception e) {
+            return defaultValue;
+        }
+    }
+
+    /**
+     * 转换为BigDecimal<br>
+     * 如果给定的值为空，或者转换失败，返回默认值<br>
+     * 转换失败不会报错
+     *
+     * @param value 被转换的值
+     *
+     * @return 结果
+     */
+    public static BigDecimal toBigDecimal (Object value) {
+        return toBigDecimal(value, null);
+    }
+
+    /**
+     * 将对象转为字符串<br>
+     * 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法
+     *
+     * @param obj 对象
+     *
+     * @return 字符串
+     */
+    public static String utf8Str (Object obj) {
+        return str(obj, CharsetKit.CHARSET_UTF_8);
+    }
+
+    /**
+     * 将对象转为字符串<br>
+     * 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法
+     *
+     * @param obj         对象
+     * @param charsetName 字符集
+     *
+     * @return 字符串
+     */
+    public static String str (Object obj, String charsetName) {
+        return str(obj, Charset.forName(charsetName));
+    }
+
+    /**
+     * 将对象转为字符串<br>
+     * 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法
+     *
+     * @param obj     对象
+     * @param charset 字符集
+     *
+     * @return 字符串
+     */
+    public static String str (Object obj, Charset charset) {
+        if (null == obj) {
+            return null;
+        }
+
+        if (obj instanceof String) {
+            return (String) obj;
+        } else if (obj instanceof byte[] || obj instanceof Byte[]) {
+            if (obj instanceof byte[]) {
+                return str((byte[]) obj, charset);
+            } else {
+                Byte[] bytes = (Byte[]) obj;
+                int length = bytes.length;
+                byte[] dest = new byte[length];
+                for (int i = 0 ; i < length ; i++) {
+                    dest[i] = bytes[i];
+                }
+                return str(dest, charset);
+            }
+        } else if (obj instanceof ByteBuffer) {
+            return str((ByteBuffer) obj, charset);
+        }
+        return obj.toString();
+    }
+
+    /**
+     * 将byte数组转为字符串
+     *
+     * @param bytes   byte数组
+     * @param charset 字符集
+     *
+     * @return 字符串
+     */
+    public static String str (byte[] bytes, String charset) {
+        return str(bytes, StringUtils.isEmpty(charset) ? Charset.defaultCharset() : Charset.forName(charset));
+    }
+
+    /**
+     * 解码字节码
+     *
+     * @param data    字符串
+     * @param charset 字符集，如果此字段为空，则解码的结果取决于平台
+     *
+     * @return 解码后的字符串
+     */
+    public static String str (byte[] data, Charset charset) {
+        if (data == null) {
+            return null;
+        }
+
+        if (null == charset) {
+            return new String(data);
+        }
+        return new String(data, charset);
+    }
+
+    /**
+     * 将编码的byteBuffer数据转换为字符串
+     *
+     * @param data    数据
+     * @param charset 字符集，如果为空使用当前系统字符集
+     *
+     * @return 字符串
+     */
+    public static String str (ByteBuffer data, String charset) {
+        if (data == null) {
+            return null;
+        }
+
+        return str(data, Charset.forName(charset));
+    }
+
+    /**
+     * 将编码的byteBuffer数据转换为字符串
+     *
+     * @param data    数据
+     * @param charset 字符集，如果为空使用当前系统字符集
+     *
+     * @return 字符串
+     */
+    public static String str (ByteBuffer data, Charset charset) {
+        if (null == charset) {
+            charset = Charset.defaultCharset();
+        }
+        return charset.decode(data).toString();
+    }
+
+    // ----------------------------------------------------------------------- 全角半角转换
+
+    /**
+     * 半角转全角
+     *
+     * @param input String.
+     *
+     * @return 全角字符串.
+     */
+    public static String toSBC (String input) {
+        return toSBC(input, null);
+    }
+
+    /**
+     * 半角转全角
+     *
+     * @param input         String
+     * @param notConvertSet 不替换的字符集合
+     *
+     * @return 全角字符串.
+     */
+    public static String toSBC (String input, Set<Character> notConvertSet) {
+        char[] c = input.toCharArray();
+        for (int i = 0 ; i < c.length ; i++) {
+            if (null != notConvertSet && notConvertSet.contains(c[i])) {
+                // 跳过不替换的字符
+                continue;
+            }
+
+            if (c[i] == ' ') {
+                c[i] = '\u3000';
+            } else if (c[i] < '\177') {
+                c[i] = (char) (c[i] + 65248);
+
+            }
+        }
+        return new String(c);
+    }
+
+    /**
+     * 全角转半角
+     *
+     * @param input String.
+     *
+     * @return 半角字符串
+     */
+    public static String toDBC (String input) {
+        return toDBC(input, null);
+    }
+
+    /**
+     * 替换全角为半角
+     *
+     * @param text          文本
+     * @param notConvertSet 不替换的字符集合
+     *
+     * @return 替换后的字符
+     */
+    public static String toDBC (String text, Set<Character> notConvertSet) {
+        char[] c = text.toCharArray();
+        for (int i = 0 ; i < c.length ; i++) {
+            if (null != notConvertSet && notConvertSet.contains(c[i])) {
+                // 跳过不替换的字符
+                continue;
+            }
+
+            if (c[i] == '\u3000') {
+                c[i] = ' ';
+            } else if (c[i] > '\uFF00' && c[i] < '\uFF5F') {
+                c[i] = (char) (c[i] - 65248);
+            }
+        }
+        return new String(c);
+    }
+
+    /**
+     * 数字金额大写转换 先写个完整的然后将如零拾替换成零
+     *
+     * @param n 数字
+     *
+     * @return 中文大写数字
+     */
+    public static String digitUppercase (double n) {
+        String[] fraction = {"角", "分"};
+        String[] digit = {"零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"};
+        String[][] unit = {{"元", "万", "亿"}, {"", "拾", "佰", "仟"}};
+
+        String head = n < 0 ? "负" : "";
+        n = Math.abs(n);
+
+        String s = "";
+        for (int i = 0 ; i < fraction.length ; i++) {
+            // 优化double计算精度丢失问题
+            BigDecimal nNum = new BigDecimal(n);
+            BigDecimal decimal = new BigDecimal(10);
+            BigDecimal scale = nNum.multiply(decimal).setScale(2, RoundingMode.HALF_EVEN);
+            double d = scale.doubleValue();
+            s += (digit[(int) (Math.floor(d * Math.pow(10, i)) % 10)] + fraction[i]).replaceAll("(零.)+", "");
+        }
+        if (s.length() < 1) {
+            s = "整";
+        }
+        int integerPart = (int) Math.floor(n);
+
+        for (int i = 0 ; i < unit[0].length && integerPart > 0 ; i++) {
+            String p = "";
+            for (int j = 0 ; j < unit[1].length && n > 0 ; j++) {
+                p = digit[integerPart % 10] + unit[1][j] + p;
+                integerPart = integerPart / 10;
+            }
+            s = p.replaceAll("(零.)*零$", "").replaceAll("^$", "零") + unit[0][i] + s;
+        }
+        return head + s.replaceAll("(零.)*零元", "元").replaceFirst("(零.)+", "").replaceAll("(零.)+", "零").replaceAll("^整$", "零元整");
+    }
+}
diff --git a/src/main/java/com/muyu/utils/text/StrFormatter.java b/src/main/java/com/muyu/utils/text/StrFormatter.java
new file mode 100644
index 0000000..5d3c29e
--- /dev/null
+++ b/src/main/java/com/muyu/utils/text/StrFormatter.java
@@ -0,0 +1,78 @@
+package com.muyu.utils.text;
+
+
+import com.muyu.utils.StringUtils;
+
+/**
+ * 字符串格式化
+ *
+ * @author muyu
+ */
+public class StrFormatter {
+    public static final String EMPTY_JSON = "{}";
+    public static final char C_BACKSLASH = '\\';
+    public static final char C_DELIM_START = '{';
+    public static final char C_DELIM_END = '}';
+
+    /**
+     * 格式化字符串<br>
+     * 此方法只是简单将占位符 {} 按照顺序替换为参数<br>
+     * 如果想输出 {} 使用 \\转义 { 即可，如果想输出 {} 之前的 \ 使用双转义符 \\\\ 即可<br>
+     * 例：<br>
+     * 通常使用：format("this is {} for {}", "a", "b") -> this is a for b<br>
+     * 转义{}： format("this is \\{} for {}", "a", "b") -> this is \{} for a<br>
+     * 转义\： format("this is \\\\{} for {}", "a", "b") -> this is \a for b<br>
+     *
+     * @param strPattern 字符串模板
+     * @param argArray   参数列表
+     *
+     * @return 结果
+     */
+    public static String format (final String strPattern, final Object... argArray) {
+        if (StringUtils.isEmpty(strPattern) || StringUtils.isEmpty(argArray)) {
+            return strPattern;
+        }
+        final int strPatternLength = strPattern.length();
+
+        // 初始化定义好的长度以获得更好的性能
+        StringBuilder sbuf = new StringBuilder(strPatternLength + 50);
+
+        int handledPosition = 0;
+        int delimIndex;// 占位符所在位置
+        for (int argIndex = 0 ; argIndex < argArray.length ; argIndex++) {
+            delimIndex = strPattern.indexOf(EMPTY_JSON, handledPosition);
+            if (delimIndex == -1) {
+                if (handledPosition == 0) {
+                    return strPattern;
+                } else { // 字符串模板剩余部分不再包含占位符，加入剩余部分后返回结果
+                    sbuf.append(strPattern, handledPosition, strPatternLength);
+                    return sbuf.toString();
+                }
+            } else {
+                if (delimIndex > 0 && strPattern.charAt(delimIndex - 1) == C_BACKSLASH) {
+                    if (delimIndex > 1 && strPattern.charAt(delimIndex - 2) == C_BACKSLASH) {
+                        // 转义符之前还有一个转义符，占位符依旧有效
+                        sbuf.append(strPattern, handledPosition, delimIndex - 1);
+                        sbuf.append(Convert.utf8Str(argArray[argIndex]));
+                        handledPosition = delimIndex + 2;
+                    } else {
+                        // 占位符被转义
+                        argIndex--;
+                        sbuf.append(strPattern, handledPosition, delimIndex - 1);
+                        sbuf.append(C_DELIM_START);
+                        handledPosition = delimIndex + 1;
+                    }
+                } else {
+                    // 正常占位符
+                    sbuf.append(strPattern, handledPosition, delimIndex);
+                    sbuf.append(Convert.utf8Str(argArray[argIndex]));
+                    handledPosition = delimIndex + 2;
+                }
+            }
+        }
+        // 加入最后一个占位符后所有的字符
+        sbuf.append(strPattern, handledPosition, strPattern.length());
+
+        return sbuf.toString();
+    }
+}
diff --git a/src/main/java/com/muyu/vehicle/VehicleInstance.java b/src/main/java/com/muyu/vehicle/VehicleInstance.java
index 9c7dead..5064dff 100644
--- a/src/main/java/com/muyu/vehicle/VehicleInstance.java
+++ b/src/main/java/com/muyu/vehicle/VehicleInstance.java
@@ -3,6 +3,7 @@ package com.muyu.vehicle;
 import com.alibaba.fastjson2.JSONObject;
 import com.muyu.cache.model.MessageTemplateCacheModel;
 import com.muyu.system.enums.MessageTemplateValueType;
+import com.muyu.utils.StringUtils;
 import com.muyu.vehicle.model.VehicleData;
 import com.muyu.vehicle.model.properties.MqttProperties;
 import com.muyu.vehicle.thread.VehicleThread;
@@ -205,6 +206,9 @@ public class VehicleInstance {
                 log.error("车辆：[{}] 客户端关闭异常：[{}]",getVin(), e.getMessage(), e);
             }
         }
+        if (this.vehicleThread != null){
+            this.vehicleThread.stop();
+        }
     }
 
     /**
@@ -250,6 +254,9 @@ public class VehicleInstance {
                     .latitude(this.vehicleInfo.getLastLatitude())
                     .longitude(this.vehicleInfo.getLastLongitude())
                     .build();
+        }else {
+            this.vehicleInfo.setLastLatitude(currentPositionModel.getLatitude());
+            this.vehicleInfo.setLastLongitude(currentPositionModel.getLongitude());
         }
         if (lastPositionModel == null){
             lastPositionModel = currentPositionModel;
@@ -303,7 +310,7 @@ public class VehicleInstance {
             for (MessageTemplateValue messageTemplateValue : messageTemplateValueList) {
                 String valueType = messageTemplateValue.getValueType();
                 MessageTemplateValueType messageTemplateValueType
-                        = MessageTemplateValueType.valueOf(valueType);
+                        = MessageTemplateValueType.get(valueType);
                 switch (messageTemplateValueType){
                     // 固定值
                     case FIXED -> {
@@ -347,23 +354,28 @@ public class VehicleInstance {
                 .sorted(Comparator.comparing(MessageTemplateValue::getStartLocation))
                 .forEach(value -> {
                     String elValue = value.getElValue();
-                    // TODO 获取EL报文
+                    switch (elValue){
+                        case "this.vin" -> elBuilder.append(this.vehicleData.getVin());
+                        case "this.latitude" -> elBuilder.append(this.vehicleData.getLatitude());
+                        case "this.longitude" -> elBuilder.append(this.vehicleData.getLongitude());
+                        case "this.timeMillis" -> elBuilder.append(System.currentTimeMillis());
+                    }
                 });
         StringBuilder fixedBuilder = new StringBuilder();
         messageTemplateValueList.stream()
                 .filter(MessageTemplateValue::isFixed)
                 .sorted(Comparator.comparing(MessageTemplateValue::getStartLocation))
-                .forEach(value -> {
-                    // TODO 获取固定报文
-                });
+                .forEach(value -> fixedBuilder.append(this.vehicleData.getData(value.getCode())));
 
         StringBuilder intervalBuilder = new StringBuilder();
         messageTemplateValueList.stream()
                 .filter(MessageTemplateValue::isInterval)
                 .sorted(Comparator.comparing(MessageTemplateValue::getStartLocation))
-                .forEach(value -> {
-                    // TODO 获取随机报文
-                });
-        return null;
+                .forEach(value -> intervalBuilder.append(this.vehicleData.getData(value.getCode())));
+        return StringUtils.format(
+                "{}#{}#{}~{}{}{}",
+                elBuilder.length(), fixedBuilder.length(), intervalBuilder.length(),
+                elBuilder.toString(), fixedBuilder.toString(), intervalBuilder.toString()
+        );
     }
 }
diff --git a/src/main/java/com/muyu/vehicle/model/VehicleData.java b/src/main/java/com/muyu/vehicle/model/VehicleData.java
index e8cbe86..4cd6d87 100644
--- a/src/main/java/com/muyu/vehicle/model/VehicleData.java
+++ b/src/main/java/com/muyu/vehicle/model/VehicleData.java
@@ -69,6 +69,7 @@ public class VehicleData {
      */
     private String fuelConsumptionRate;
 
+    @Builder.Default
     private Map<String, String> dataMap = new HashMap<String, String>();
 
     /**
diff --git a/src/main/java/com/muyu/vehicle/thread/VehicleThread.java b/src/main/java/com/muyu/vehicle/thread/VehicleThread.java
index 3cd7488..0a164d9 100644
--- a/src/main/java/com/muyu/vehicle/thread/VehicleThread.java
+++ b/src/main/java/com/muyu/vehicle/thread/VehicleThread.java
@@ -22,8 +22,9 @@ public class VehicleThread implements Runnable {
     public void run() {
         try {
             if (!isStop){
-                log.info("{} - 上报数据", this.vehicleInstance.getVin());
-                this.vehicleInstance.sendMsg( this.vehicleInstance.imitateDataAndMsg());
+                String msg = this.vehicleInstance.imitateDataAndMsg();
+                log.info("{} - 上报数据: [{}]", this.vehicleInstance.getVin(), msg);
+                this.vehicleInstance.sendMsg( msg );
             }else {
                 log.info("终止模拟和上报：[{}]", this.vehicleInstance.getVin());
                 vehicleInstance.cancelExecution();
diff --git a/src/main/java/com/muyu/web/controller/VehicleInstanceController.java b/src/main/java/com/muyu/web/controller/VehicleInstanceController.java
index 1a6c48a..ae4e815 100644
--- a/src/main/java/com/muyu/web/controller/VehicleInstanceController.java
+++ b/src/main/java/com/muyu/web/controller/VehicleInstanceController.java
@@ -28,70 +28,83 @@ public class VehicleInstanceController {
 
     /**
      * 查询车辆集合
+     *
      * @param vehicleInstanceListReq 车辆列表查询对象
      * @return 结果
      */
     @PostMapping("/list")
-    public Result<PageList<VehicleInstanceResp>> list(@RequestBody VehicleInstanceListReq vehicleInstanceListReq){
+    public Result<PageList<VehicleInstanceResp>> list(@RequestBody VehicleInstanceListReq vehicleInstanceListReq) {
         PageList<VehicleInstanceResp> pageList = vehicleInstanceService.queryList(vehicleInstanceListReq);
         return Result.success(pageList);
     }
 
     /**
      * 根据车辆VIN获取车辆数据
+     *
      * @param vin VIN
      * @return 车辆数据
      */
     @GetMapping("/data/{vin}")
-    public Result<VehicleData> getVehicleData(@PathVariable("vin") String vin){
+    public Result<VehicleData> getVehicleData(@PathVariable("vin") String vin) {
         return Result.success(LocalContainer.getVehicleInstance(vin).getVehicleData());
     }
 
     /**
      * 车辆连接初始化
+     *
      * @param vin vin
      * @return 初始化
      */
     @PostMapping("/client/start/{vin}")
-    public Result<String> vehicleClientInit(@PathVariable("vin") String vin){
+    public Result<String> vehicleClientInit(@PathVariable("vin") String vin) {
         this.vehicleInstanceService.vehicleClientStart(vin);
+        this.vehicleInstanceService.checkPosition(
+                CheckPositionReq.builder()
+                        .vin(vin)
+                        .positionCode("路径1")
+                        .build()
+        );
         return Result.success();
     }
 
     /**
      * 关闭车辆连接
+     *
      * @param vin vin
      * @return 初始化
      */
     @PostMapping("/client/close/{vin}")
-    public Result<String> vehicleClientClose(@PathVariable("vin") String vin){
+    public Result<String> vehicleClientClose(@PathVariable("vin") String vin) {
         this.vehicleInstanceService.vehicleClientClose(vin);
         return Result.success();
     }
 
     /**
      * 选择车辆轨迹
+     *
      * @param checkPositionReq 轨迹选择
      * @return 操作提示
      */
     @PostMapping("/position/check")
-    public Result<String> checkPosition(@RequestBody CheckPositionReq checkPositionReq){
+    public Result<String> checkPosition(@RequestBody CheckPositionReq checkPositionReq) {
         this.vehicleInstanceService.checkPosition(checkPositionReq);
         return Result.success();
     }
 
     /**
      * 车辆档位操作
+     *
      * @return 操作提示
      */
     @PostMapping("/gear")
-    public Result<String> gear(@RequestBody GearReq gearReq){
+    public Result<String> gear(@RequestBody GearReq gearReq) {
         this.vehicleInstanceService.gear(gearReq);
         return Result.success();
     }
 
     /**
      * 设置车辆故障状态
+     *
      * @param statusKey
      * @param vin
      * @param statusValue
@@ -100,7 +113,7 @@ public class VehicleInstanceController {
     @PutMapping("/status/{vin}/{statusKey}/{statusValue}")
     public Result<String> editStatus(@PathVariable("statusKey") String statusKey,
                                      @PathVariable("vin") String vin,
-                                     @PathVariable("statusValue") Integer statusValue){
+                                     @PathVariable("statusValue") Integer statusValue) {
         this.vehicleInstanceService.editStatus(vin, statusKey, statusValue);
         return Result.success();
     }