1.数组操作工具类
package org.smart4j.framework.util; import org.apache.commons.lang.ArrayUtils; /** * 数组操作工具类 * * @author huangyong * @since 1.0 */ public class ArrayUtil { /** * 判断数组是否非空 */ public static boolean isNotEmpty(Object[] array) { return !ArrayUtils.isEmpty(array); } /** * 判断数组是否为空 */ public static boolean isEmpty(Object[] array) { return ArrayUtils.isEmpty(array); } /** * 连接数组 */ public static Object[] concat(Object[] array1, Object[] array2) { return ArrayUtils.addAll(array1, array2); } /** * 判断对象是否在数组中 */ public static <T> boolean contains(T[] array, T obj) { return ArrayUtils.contains(array, obj); } }
2. 转型操作工具类
package org.smart4j.framework.util; /** * 转型操作工具类 * * @author huangyong * @since 1.0 */ public class CastUtil { /** * 转为 String 型 */ public static String castString(Object obj) { return CastUtil.castString(obj, ""); } /** * 转为 String 型(提供默认值) */ public static String castString(Object obj, String defaultValue) { return obj != null ? String.valueOf(obj) : defaultValue; } /** * 转为 double 型 */ public static double castDouble(Object obj) { return CastUtil.castDouble(obj, 0); } /** * 转为 double 型(提供默认值) */ public static double castDouble(Object obj, double defaultValue) { double doubleValue = defaultValue; if (obj != null) { String strValue = castString(obj); if (StringUtil.isNotEmpty(strValue)) { try { doubleValue = Double.parseDouble(strValue); } catch (NumberFormatException e) { doubleValue = defaultValue; } } } return doubleValue; } /** * 转为 long 型 */ public static long castLong(Object obj) { return CastUtil.castLong(obj, 0); } /** * 转为 long 型(提供默认值) */ public static long castLong(Object obj, long defaultValue) { long longValue = defaultValue; if (obj != null) { String strValue = castString(obj); if (StringUtil.isNotEmpty(strValue)) { try { longValue = Long.parseLong(strValue); } catch (NumberFormatException e) { longValue = defaultValue; } } } return longValue; } /** * 转为 int 型 */ public static int castInt(Object obj) { return CastUtil.castInt(obj, 0); } /** * 转为 int 型(提供默认值) */ public static int castInt(Object obj, int defaultValue) { int intValue = defaultValue; if (obj != null) { String strValue = castString(obj); if (StringUtil.isNotEmpty(strValue)) { try { intValue = Integer.parseInt(strValue); } catch (NumberFormatException e) { intValue = defaultValue; } } } return intValue; } /** * 转为 boolean 型 */ public static boolean castBoolean(Object obj) { return CastUtil.castBoolean(obj, false); } /** * 转为 boolean 型(提供默认值) */ public static boolean castBoolean(Object obj, boolean defaultValue) { boolean booleanValue = defaultValue; if (obj != null) { booleanValue = Boolean.parseBoolean(castString(obj)); } return booleanValue; } /** * 转为 String[] 型 */ public static String[] castStringArray(Object[] objArray) { if (objArray == null) { objArray = new Object[0]; } String[] strArray = new String[objArray.length]; if (ArrayUtil.isNotEmpty(objArray)) { for (int i = 0; i < objArray.length; i++) { strArray[i] = castString(objArray[i]); } } return strArray; } /** * 转为 double[] 型 */ public static double[] castDoubleArray(Object[] objArray) { if (objArray == null) { objArray = new Object[0]; } double[] doubleArray = new double[objArray.length]; if (!ArrayUtil.isEmpty(objArray)) { for (int i = 0; i < objArray.length; i++) { doubleArray[i] = castDouble(objArray[i]); } } return doubleArray; } /** * 转为 long[] 型 */ public static long[] castLongArray(Object[] objArray) { if (objArray == null) { objArray = new Object[0]; } long[] longArray = new long[objArray.length]; if (!ArrayUtil.isEmpty(objArray)) { for (int i = 0; i < objArray.length; i++) { longArray[i] = castLong(objArray[i]); } } return longArray; } /** * 转为 int[] 型 */ public static int[] castIntArray(Object[] objArray) { if (objArray == null) { objArray = new Object[0]; } int[] intArray = new int[objArray.length]; if (!ArrayUtil.isEmpty(objArray)) { for (int i = 0; i < objArray.length; i++) { intArray[i] = castInt(objArray[i]); } } return intArray; } /** * 转为 boolean[] 型 */ public static boolean[] castBooleanArray(Object[] objArray) { if (objArray == null) { objArray = new Object[0]; } boolean[] booleanArray = new boolean[objArray.length]; if (!ArrayUtil.isEmpty(objArray)) { for (int i = 0; i < objArray.length; i++) { booleanArray[i] = castBoolean(objArray[i]); } } return booleanArray; } }
3. 类操作工具类
package org.smart4j.framework.util; import java.net.URL; import org.slf4j.Logger; import org.slf4j.LoggerFactory; /** * 类操作工具类 * * @author huangyong * @since 1.0 */ public class ClassUtil { private static final Logger logger = LoggerFactory.getLogger(ClassUtil.class); /** * 获取类加载器 */ public static ClassLoader getClassLoader() { return Thread.currentThread().getContextClassLoader(); } /** * 获取类路径 */ public static String getClassPath() { String classpath = ""; URL resource = getClassLoader().getResource(""); if (resource != null) { classpath = resource.getPath(); } return classpath; } /** * 加载类(将自动初始化) */ public static Class<?> loadClass(String className) { return loadClass(className, true); } /** * 加载类 */ public static Class<?> loadClass(String className, boolean isInitialized) { Class<?> cls; try { cls = Class.forName(className, isInitialized, getClassLoader()); } catch (ClassNotFoundException e) { logger.error("加载类出错!", e); throw new RuntimeException(e); } return cls; } /** * 是否为 int 类型(包括 Integer 类型) */ public static boolean isInt(Class<?> type) { return type.equals(int.class) || type.equals(Integer.class); } /** * 是否为 long 类型(包括 Long 类型) */ public static boolean isLong(Class<?> type) { return type.equals(long.class) || type.equals(Long.class); } /** * 是否为 double 类型(包括 Double 类型) */ public static boolean isDouble(Class<?> type) { return type.equals(double.class) || type.equals(Double.class); } /** * 是否为 String 类型 */ public static boolean isString(Class<?> type) { return type.equals(String.class); } }
4. 编码与解码操作工具类
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
package org.smart4j.framework.util; import java.io.UnsupportedEncodingException; import java.net.URLDecoder; import java.net.URLEncoder; import java.util.UUID; import org.apache.commons.codec.binary.Base64; import org.apache.commons.codec.digest.DigestUtils; import org.apache.commons.lang.RandomStringUtils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.smart4j.framework.FrameworkConstant; /** * 编码与解码操作工具类 * * @author huangyong * @since 1.0 */ public class CodecUtil { private static final Logger logger = LoggerFactory.getLogger(CodecUtil.class); /** * 将 URL 编码 */ public static String encodeURL(String str) { String target; try { target = URLEncoder.encode(str, FrameworkConstant.UTF_8); } catch (Exception e) { logger.error("编码出错!", e); throw new RuntimeException(e); } return target; } /** * 将 URL 解码 */ public static String decodeURL(String str) { String target; try { target = URLDecoder.decode(str, FrameworkConstant.UTF_8); } catch (Exception e) { logger.error("解码出错!", e); throw new RuntimeException(e); } return target; } /** * 将字符串 Base64 编码 */ public static String encodeBASE64(String str) { String target; try { target = Base64.encodeBase64URLSafeString(str.getBytes(FrameworkConstant.UTF_8)); } catch (UnsupportedEncodingException e) { logger.error("编码出错!", e); throw new RuntimeException(e); } return target; } /** * 将字符串 Base64 解码 */ public static String decodeBASE64(String str) { String target; try { target = new String(Base64.decodeBase64(str), FrameworkConstant.UTF_8); } catch (UnsupportedEncodingException e) { logger.error("解码出错!", e); throw new RuntimeException(e); } return target; } /** * 将字符串 MD5 加密 */ public static String encryptMD5(String str) { return DigestUtils.md5Hex(str); } /** * 将字符串 SHA 加密 */ public static String encryptSHA(String str) { return DigestUtils.sha1Hex(str); } /** * 创建随机数 */ public static String createRandom(int count) { return RandomStringUtils.randomNumeric(count); } /** * 获取 UUID(32位) */ public static String createUUID() { return UUID.randomUUID().toString().replaceAll("-", ""); } }
5. 集合操作工具类
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
package org.smart4j.framework.util; import java.util.Collection; import org.apache.commons.collections.CollectionUtils; /** * 集合操作工具类 * * @author huangyong * @since 1.0 */ public class CollectionUtil { /** * 判断集合是否非空 */ public static boolean isNotEmpty(Collection<?> collection) { return CollectionUtils.isNotEmpty(collection); } /** * 判断集合是否为空 */ public static boolean isEmpty(Collection<?> collection) { return CollectionUtils.isEmpty(collection); } }
6. 日期操作工具类
package org.smart4j.framework.util; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date; import org.slf4j.Logger; import org.slf4j.LoggerFactory; /** * 日期操作工具类 * * @author huangyong * @since 1.0 */ public class DateUtil { private static final Logger logger = LoggerFactory.getLogger(DateUtil.class); private static final SimpleDateFormat datetimeFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); private static final SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd"); private static final SimpleDateFormat timeFormat = new SimpleDateFormat("HH:mm:ss"); /** * 格式化日期与时间 */ public static String formatDatetime(long timestamp) { return datetimeFormat.format(new Date(timestamp)); } /** * 格式化日期 */ public static String formatDate(long timestamp) { return dateFormat.format(new Date(timestamp)); } /** * 格式化时间 */ public static String formatTime(long timestamp) { return timeFormat.format(new Date(timestamp)); } /** * 获取当前日期与时间 */ public static String getCurrentDatetime() { return datetimeFormat.format(new Date()); } /** * 获取当前日期 */ public static String getCurrentDate() { return dateFormat.format(new Date()); } /** * 获取当前时间 */ public static String getCurrentTime() { return timeFormat.format(new Date()); } /** * 解析日期与时间 */ public static Date parseDatetime(String str) { Date date = null; try { date = datetimeFormat.parse(str); } catch (ParseException e) { logger.error("解析日期字符串出错!格式:yyyy-MM-dd HH:mm:ss", e); } return date; } /** * 解析日期 */ public static Date parseDate(String str) { Date date = null; try { date = dateFormat.parse(str); } catch (ParseException e) { logger.error("解析日期字符串出错!格式:yyyy-MM-dd", e); } return date; } /** * 解析时间 */ public static Date parseTime(String str) { Date date = null; try { date = timeFormat.parse(str); } catch (ParseException e) { logger.error("解析日期字符串出错!格式:HH:mm:ss", e); } return date; } }
7. 文件操作工具类
package org.smart4j.framework.util; import java.io.BufferedOutputStream; import java.io.File; import java.io.FileOutputStream; import java.io.OutputStream; import java.io.OutputStreamWriter; import java.io.Writer; import org.apache.commons.io.FileUtils; import org.apache.commons.io.FilenameUtils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.smart4j.framework.FrameworkConstant; /** * 文件操作工具类 * * @author huangyong * @since 1.0 */ public class FileUtil { private static final Logger logger = LoggerFactory.getLogger(FileUtil.class); /** * 创建目录 */ public static File createDir(String dirPath) { File dir; try { dir = new File(dirPath); if (!dir.exists()) { FileUtils.forceMkdir(dir); } } catch (Exception e) { logger.error("创建目录出错!", e); throw new RuntimeException(e); } return dir; } /** * 创建文件 */ public static File createFile(String filePath) { File file; try { file = new File(filePath); File parentDir = file.getParentFile(); if (!parentDir.exists()) { FileUtils.forceMkdir(parentDir); } } catch (Exception e) { logger.error("创建文件出错!", e); throw new RuntimeException(e); } return file; } /** * 复制目录(不会复制空目录) */ public static void copyDir(String srcPath, String destPath) { try { File srcDir = new File(srcPath); File destDir = new File(destPath); if (srcDir.exists() && srcDir.isDirectory()) { FileUtils.copyDirectoryToDirectory(srcDir, destDir); } } catch (Exception e) { logger.error("复制目录出错!", e); throw new RuntimeException(e); } } /** * 复制文件 */ public static void copyFile(String srcPath, String destPath) { try { File srcFile = new File(srcPath); File destDir = new File(destPath); if (srcFile.exists() && srcFile.isFile()) { FileUtils.copyFileToDirectory(srcFile, destDir); } } catch (Exception e) { logger.error("复制文件出错!", e); throw new RuntimeException(e); } } /** * 删除目录 */ public static void deleteDir(String dirPath) { try { File dir = new File(dirPath); if (dir.exists() && dir.isDirectory()) { FileUtils.deleteDirectory(dir); } } catch (Exception e) { logger.error("删除目录出错!", e); throw new RuntimeException(e); } } /** * 删除文件 */ public static void deleteFile(String filePath) { try { File file = new File(filePath); if (file.exists() && file.isFile()) { FileUtils.forceDelete(file); } } catch (Exception e) { logger.error("删除文件出错!", e); throw new RuntimeException(e); } } /** * 重命名文件 */ public static void renameFile(String srcPath, String destPath) { File srcFile = new File(srcPath); if (srcFile.exists()) { File newFile = new File(destPath); boolean result = srcFile.renameTo(newFile); if (!result) { throw new RuntimeException("重命名文件出错!" + newFile); } } } /** * 将字符串写入文件 */ public static void writeFile(String filePath, String fileContent) { OutputStream os = null; Writer w = null; try { FileUtil.createFile(filePath); os = new BufferedOutputStream(new FileOutputStream(filePath)); w = new OutputStreamWriter(os, FrameworkConstant.UTF_8); w.write(fileContent); w.flush(); } catch (Exception e) { logger.error("写入文件出错!", e); throw new RuntimeException(e); } finally { try { if (os != null) { os.close(); } if (w != null) { w.close(); } } catch (Exception e) { logger.error("释放资源出错!", e); } } } /** * 获取真实文件名(去掉文件路径) */ public static String getRealFileName(String fileName) { return FilenameUtils.getName(fileName); } /** * 判断文件是否存在 */ public static boolean checkFileExists(String filePath) { return new File(filePath).exists(); } }
8. JSON 操作工具类
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
package org.smart4j.framework.util; import org.codehaus.jackson.map.ObjectMapper; import org.slf4j.Logger; import org.slf4j.LoggerFactory; /** * JSON 操作工具类 * * @author huangyong * @since 1.0 */ public class JsonUtil { private static final Logger logger = LoggerFactory.getLogger(JsonUtil.class); private static final ObjectMapper objectMapper = new ObjectMapper(); /** * 将 Java 对象转为 JSON 字符串 */ public static <T> String toJSON(T obj) { String jsonStr; try { jsonStr = objectMapper.writeValueAsString(obj); } catch (Exception e) { logger.error("Java 转 JSON 出错!", e); throw new RuntimeException(e); } return jsonStr; } /** * 将 JSON 字符串转为 Java 对象 */ public static <T> T fromJSON(String json, Class<T> type) { T obj; try { obj = objectMapper.readValue(json, type); } catch (Exception e) { logger.error("JSON 转 Java 出错!", e); throw new RuntimeException(e); } return obj; } }
9. 映射操作工具类
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
package org.smart4j.framework.util; import java.util.LinkedHashMap; import java.util.Map; import org.apache.commons.collections.MapUtils; /** * 映射操作工具类 * * @author huangyong * @since 1.0 */ public class MapUtil { /** * 判断 Map 是否非空 */ public static boolean isNotEmpty(Map<?, ?> map) { return MapUtils.isNotEmpty(map); } /** * 判断 Map 是否为空 */ public static boolean isEmpty(Map<?, ?> map) { return MapUtils.isEmpty(map); } /** * 转置 Map */ public static <K, V> Map<V, K> invert(Map<K, V> source) { Map<V, K> target = null; if (isNotEmpty(source)) { target = new LinkedHashMap<V, K>(source.size()); for (Map.Entry<K, V> entry : source.entrySet()) { target.put(entry.getValue(), entry.getKey()); } } return target; } }
10. 对象操作工具类
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
package org.smart4j.framework.util; import java.lang.reflect.Field; import java.lang.reflect.Modifier; import java.util.LinkedHashMap; import java.util.Map; import org.apache.commons.beanutils.PropertyUtils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; /** * 对象操作工具类 * * @author huangyong * @since 1.0 */ public class ObjectUtil { private static final Logger logger = LoggerFactory.getLogger(ObjectUtil.class); /** * 设置成员变量 */ public static void setField(Object obj, String fieldName, Object fieldValue) { try { if (PropertyUtils.isWriteable(obj, fieldName)) { PropertyUtils.setProperty(obj, fieldName, fieldValue); } } catch (Exception e) { logger.error("设置成员变量出错!", e); throw new RuntimeException(e); } } /** * 获取成员变量 */ public static Object getFieldValue(Object obj, String fieldName) { Object propertyValue = null; try { if (PropertyUtils.isReadable(obj, fieldName)) { propertyValue = PropertyUtils.getProperty(obj, fieldName); } } catch (Exception e) { logger.error("获取成员变量出错!", e); throw new RuntimeException(e); } return propertyValue; } /** * 复制所有成员变量 */ public static void copyFields(Object source, Object target) { try { for (Field field : source.getClass().getDeclaredFields()) { // 若不为 static 成员变量,则进行复制操作 if (!Modifier.isStatic(field.getModifiers())) { field.setAccessible(true); // 可操作私有成员变量 field.set(target, field.get(source)); } } } catch (Exception e) { logger.error("复制成员变量出错!", e); throw new RuntimeException(e); } } /** * 通过反射创建实例 */ @SuppressWarnings("unchecked") public static <T> T newInstance(String className) { T instance; try { Class<?> commandClass = ClassUtil.loadClass(className); instance = (T) commandClass.newInstance(); } catch (Exception e) { logger.error("创建实例出错!", e); throw new RuntimeException(e); } return instance; } /** * 获取对象的字段映射(字段名 => 字段值),忽略 static 字段 */ public static Map<String, Object> getFieldMap(Object obj) { return getFieldMap(obj, true); } /** * 获取对象的字段映射(字段名 => 字段值) */ public static Map<String, Object> getFieldMap(Object obj, boolean isStaticIgnored) { Map<String, Object> fieldMap = new LinkedHashMap<String, Object>(); Field[] fields = obj.getClass().getDeclaredFields(); for (Field field : fields) { if (isStaticIgnored && Modifier.isStatic(field.getModifiers())) { continue; } String fieldName = field.getName(); Object fieldValue = ObjectUtil.getFieldValue(obj, fieldName); fieldMap.put(fieldName, fieldValue); } return fieldMap; } }
11. 属性文件操作工具类
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
package org.smart4j.framework.util; import java.io.IOException; import java.io.InputStream; import java.util.HashMap; import java.util.LinkedHashMap; import java.util.Map; import java.util.Properties; import java.util.Set; import org.slf4j.Logger; import org.slf4j.LoggerFactory; /** * 属性文件操作工具类 * * @author huangyong * @since 1.0 */ public class PropsUtil { private static final Logger logger = LoggerFactory.getLogger(PropsUtil.class); /** * 加载属性文件 */ public static Properties loadProps(String propsPath) { Properties props = new Properties(); InputStream is = null; try { if (StringUtil.isEmpty(propsPath)) { throw new IllegalArgumentException(); } String suffix = ".properties"; if (propsPath.lastIndexOf(suffix) == -1) { propsPath += suffix; } is = ClassUtil.getClassLoader().getResourceAsStream(propsPath); if (is != null) { props.load(is); } } catch (Exception e) { logger.error("加载属性文件出错!", e); throw new RuntimeException(e); } finally { try { if (is != null) { is.close(); } } catch (IOException e) { logger.error("释放资源出错!", e); } } return props; } /** * 加载属性文件,并转为 Map */ public static Map<String, String> loadPropsToMap(String propsPath) { Map<String, String> map = new HashMap<String, String>(); Properties props = loadProps(propsPath); for (String key : props.stringPropertyNames()) { map.put(key, props.getProperty(key)); } return map; } /** * 获取字符型属性 */ public static String getString(Properties props, String key) { String value = ""; if (props.containsKey(key)) { value = props.getProperty(key); } return value; } /** * 获取字符型属性(带有默认值) */ public static String getString(Properties props, String key, String defalutValue) { String value = defalutValue; if (props.containsKey(key)) { value = props.getProperty(key); } return value; } /** * 获取数值型属性 */ public static int getNumber(Properties props, String key) { int value = 0; if (props.containsKey(key)) { value = CastUtil.castInt(props.getProperty(key)); } return value; } // 获取数值型属性(带有默认值) public static int getNumber(Properties props, String key, int defaultValue) { int value = defaultValue; if (props.containsKey(key)) { value = CastUtil.castInt(props.getProperty(key)); } return value; } /** * 获取布尔型属性 */ public static boolean getBoolean(Properties props, String key) { return getBoolean(props, key, false); } /** * 获取布尔型属性(带有默认值) */ public static boolean getBoolean(Properties props, String key, boolean defalutValue) { boolean value = defalutValue; if (props.containsKey(key)) { value = CastUtil.castBoolean(props.getProperty(key)); } return value; } /** * 获取指定前缀的相关属性 */ public static Map<String, Object> getMap(Properties props, String prefix) { Map<String, Object> kvMap = new LinkedHashMap<String, Object>(); Set<String> keySet = props.stringPropertyNames(); if (CollectionUtil.isNotEmpty(keySet)) { for (String key : keySet) { if (key.startsWith(prefix)) { String value = props.getProperty(key); kvMap.put(key, value); } } } return kvMap; } }
12. 流操作工具类
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
package org.smart4j.framework.util; import java.io.BufferedReader; import java.io.InputStream; import java.io.InputStreamReader; import java.io.OutputStream; import org.slf4j.Logger; import org.slf4j.LoggerFactory; /** * 流操作工具类 * * @author huangyong * @since 1.0 */ public class StreamUtil { private static final Logger logger = LoggerFactory.getLogger(StreamUtil.class); /** * 将输入流复制到输出流 */ public static void copyStream(InputStream inputStream, OutputStream outputStream) { try { int length; byte[] buffer = new byte[4 * 1024]; while ((length = inputStream.read(buffer, 0, buffer.length)) != -1) { outputStream.write(buffer, 0, length); } outputStream.flush(); } catch (Exception e) { logger.error("复制流出错!", e); throw new RuntimeException(e); } finally { try { inputStream.close(); outputStream.close(); } catch (Exception e) { logger.error("释放资源出错!", e); } } } /** * 从输入流中获取字符串 */ public static String getString(InputStream is) { StringBuilder sb = new StringBuilder(); try { BufferedReader reader = new BufferedReader(new InputStreamReader(is)); String line; while ((line = reader.readLine()) != null) { sb.append(line); } } catch (Exception e) { logger.error("Stream 转 String 出错!", e); throw new RuntimeException(e); } return sb.toString(); } }
13. 字符串操作工具类
package org.smart4j.framework.util; import java.util.regex.Matcher; import java.util.regex.Pattern; import org.apache.commons.lang.StringUtils; import org.apache.commons.lang.math.NumberUtils; /** * 字符串操作工具类 * * @author huangyong * @since 1.0 */ public class StringUtil { /** * 字符串分隔符 */ public static final String SEPARATOR = String.valueOf((char) 29); /** * 判断字符串是否非空 */ public static boolean isNotEmpty(String str) { return StringUtils.isNotEmpty(str); } /** * 判断字符串是否为空 */ public static boolean isEmpty(String str) { return StringUtils.isEmpty(str); } /** * 若字符串为空,则取默认值 */ public static String defaultIfEmpty(String str, String defaultValue) { return StringUtils.defaultIfEmpty(str, defaultValue); } /** * 替换固定格式的字符串(支持正则表达式) */ public static String replaceAll(String str, String regex, String replacement) { Pattern p = Pattern.compile(regex); Matcher m = p.matcher(str); StringBuffer sb = new StringBuffer(); while (m.find()) { m.appendReplacement(sb, replacement); } m.appendTail(sb); return sb.toString(); } /** * 是否为数字(整数或小数) */ public static boolean isNumber(String str) { return NumberUtils.isNumber(str); } /** * 是否为十进制数(整数) */ public static boolean isDigits(String str) { return NumberUtils.isDigits(str); } /** * 将驼峰风格替换为下划线风格 */ public static String camelhumpToUnderline(String str) { Matcher matcher = Pattern.compile("[A-Z]").matcher(str); StringBuilder builder = new StringBuilder(str); for (int i = 0; matcher.find(); i++) { builder.replace(matcher.start() + i, matcher.end() + i, "_" + matcher.group().toLowerCase()); } if (builder.charAt(0) == '_') { builder.deleteCharAt(0); } return builder.toString(); } /** * 将下划线风格替换为驼峰风格 */ public static String underlineToCamelhump(String str) { Matcher matcher = Pattern.compile("_[a-z]").matcher(str); StringBuilder builder = new StringBuilder(str); for (int i = 0; matcher.find(); i++) { builder.replace(matcher.start() - i, matcher.end() - i, matcher.group().substring(1).toUpperCase()); } if (Character.isUpperCase(builder.charAt(0))) { builder.replace(0, 1, String.valueOf(Character.toLowerCase(builder.charAt(0)))); } return builder.toString(); } /** * 分割固定格式的字符串 */ public static String[] splitString(String str, String separator) { return StringUtils.splitByWholeSeparator(str, separator); } /** * 将字符串首字母大写 */ public static String firstToUpper(String str) { return Character.toUpperCase(str.charAt(0)) + str.substring(1); } /** * 将字符串首字母小写 */ public static String firstToLower(String str) { return Character.toLowerCase(str.charAt(0)) + str.substring(1); } /** * 转为帕斯卡命名方式(如:FooBar) */ public static String toPascalStyle(String str, String seperator) { return StringUtil.firstToUpper(toCamelhumpStyle(str, seperator)); } /** * 转为驼峰命令方式(如:fooBar) */ public static String toCamelhumpStyle(String str, String seperator) { return StringUtil.underlineToCamelhump(toUnderlineStyle(str, seperator)); } /** * 转为下划线命名方式(如:foo_bar) */ public static String toUnderlineStyle(String str, String seperator) { str = str.trim().toLowerCase(); if (str.contains(seperator)) { str = str.replace(seperator, "_"); } return str; } /** * 转为显示命名方式(如:Foo Bar) */ public static String toDisplayStyle(String str, String seperator) { String displayName = ""; str = str.trim().toLowerCase(); if (str.contains(seperator)) { String[] words = StringUtil.splitString(str, seperator); for (String word : words) { displayName += StringUtil.firstToUpper(word) + " "; } displayName = displayName.trim(); } else { displayName = StringUtil.firstToUpper(str); } return displayName; } }
14. Web 操作工具类
package org.smart4j.framework.util; import java.awt.Color; import java.awt.Font; import java.awt.Graphics2D; import java.awt.image.BufferedImage; import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.FileInputStream; import java.io.InputStream; import java.io.OutputStream; import java.io.PrintWriter; import java.util.Enumeration; import java.util.LinkedHashMap; import java.util.Map; import java.util.Random; import javax.imageio.ImageIO; import javax.servlet.ServletOutputStream; import javax.servlet.http.Cookie; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import org.apache.commons.io.FilenameUtils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.smart4j.framework.FrameworkConstant; /** * Web 操作工具类 * * @author huangyong * @since 1.0 */ public class WebUtil { private static final Logger logger = LoggerFactory.getLogger(WebUtil.class); /** * 将数据以 JSON 格式写入响应中 */ public static void writeJSON(HttpServletResponse response, Object data) { try { // 设置响应头 response.setContentType("application/json"); // 指定内容类型为 JSON 格式 response.setCharacterEncoding(FrameworkConstant.UTF_8); // 防止中文乱码 // 向响应中写入数据 PrintWriter writer = response.getWriter(); writer.write(JsonUtil.toJSON(data)); // 转为 JSON 字符串 writer.flush(); writer.close(); } catch (Exception e) { logger.error("在响应中写数据出错!", e); throw new RuntimeException(e); } } /** * 将数据以 HTML 格式写入响应中(在 JS 中获取的是 JSON 字符串,而不是 JSON 对象) */ public static void writeHTML(HttpServletResponse response, Object data) { try { // 设置响应头 response.setContentType("text/html"); // 指定内容类型为 HTML 格式 response.setCharacterEncoding(FrameworkConstant.UTF_8); // 防止中文乱码 // 向响应中写入数据 PrintWriter writer = response.getWriter(); writer.write(JsonUtil.toJSON(data)); // 转为 JSON 字符串 writer.flush(); writer.close(); } catch (Exception e) { logger.error("在响应中写数据出错!", e); throw new RuntimeException(e); } } /** * 从请求中获取所有参数(当参数名重复时,用后者覆盖前者) */ public static Map<String, Object> getRequestParamMap(HttpServletRequest request) { Map<String, Object> paramMap = new LinkedHashMap<String, Object>(); try { String method = request.getMethod(); if (method.equalsIgnoreCase("put") || method.equalsIgnoreCase("delete")) { String queryString = CodecUtil.decodeURL(StreamUtil.getString(request.getInputStream())); if (StringUtil.isNotEmpty(queryString)) { String[] qsArray = StringUtil.splitString(queryString, "&"); if (ArrayUtil.isNotEmpty(qsArray)) { for (String qs : qsArray) { String[] array = StringUtil.splitString(qs, "="); if (ArrayUtil.isNotEmpty(array) && array.length == 2) { String paramName = array[0]; String paramValue = array[1]; if (checkParamName(paramName)) { if (paramMap.containsKey(paramName)) { paramValue = paramMap.get(paramName) + StringUtil.SEPARATOR + paramValue; } paramMap.put(paramName, paramValue); } } } } } } else { Enumeration<String> paramNames = request.getParameterNames(); while (paramNames.hasMoreElements()) { String paramName = paramNames.nextElement(); if (checkParamName(paramName)) { String[] paramValues = request.getParameterValues(paramName); if (ArrayUtil.isNotEmpty(paramValues)) { if (paramValues.length == 1) { paramMap.put(paramName, paramValues[0]); } else { StringBuilder paramValue = new StringBuilder(""); for (int i = 0; i < paramValues.length; i++) { paramValue.append(paramValues[i]); if (i != paramValues.length - 1) { paramValue.append(StringUtil.SEPARATOR); } } paramMap.put(paramName, paramValue.toString()); } } } } } } catch (Exception e) { logger.error("获取请求参数出错!", e); throw new RuntimeException(e); } return paramMap; } private static boolean checkParamName(String paramName) { return !paramName.equals("_"); // 忽略 jQuery 缓存参数 } /** * 转发请求 */ public static void forwardRequest(String path, HttpServletRequest request, HttpServletResponse response) { try { request.getRequestDispatcher(path).forward(request, response); } catch (Exception e) { logger.error("转发请求出错!", e); throw new RuntimeException(e); } } /** * 重定向请求 */ public static void redirectRequest(String path, HttpServletRequest request, HttpServletResponse response) { try { response.sendRedirect(request.getContextPath() + path); } catch (Exception e) { logger.error("重定向请求出错!", e); throw new RuntimeException(e); } } /** * 发送错误代码 */ public static void sendError(int code, String message, HttpServletResponse response) { try { response.sendError(code, message); } catch (Exception e) { logger.error("发送错误代码出错!", e); throw new RuntimeException(e); } } /** * 判断是否为 AJAX 请求 */ public static boolean isAJAX(HttpServletRequest request) { return request.getHeader("X-Requested-With") != null; } /** * 获取请求路径 */ public static String getRequestPath(HttpServletRequest request) { String servletPath = request.getServletPath(); String pathInfo = StringUtil.defaultIfEmpty(request.getPathInfo(), ""); return servletPath + pathInfo; } /** * 从 Cookie 中获取数据 */ public static String getCookie(HttpServletRequest request, String name) { String value = ""; try { Cookie[] cookieArray = request.getCookies(); if (cookieArray != null) { for (Cookie cookie : cookieArray) { if (StringUtil.isNotEmpty(name) && name.equals(cookie.getName())) { value = CodecUtil.decodeURL(cookie.getValue()); break; } } } } catch (Exception e) { logger.error("获取 Cookie 出错!", e); throw new RuntimeException(e); } return value; } /** * 下载文件 */ public static void downloadFile(HttpServletResponse response, String filePath) { try { String originalFileName = FilenameUtils.getName(filePath); String downloadedFileName = new String(originalFileName.getBytes("GBK"), "ISO8859_1"); // 防止中文乱码 response.setContentType("application/octet-stream"); response.addHeader("Content-Disposition", "attachment;filename=\"" + downloadedFileName + "\""); InputStream inputStream = new BufferedInputStream(new FileInputStream(filePath)); OutputStream outputStream = new BufferedOutputStream(response.getOutputStream()); StreamUtil.copyStream(inputStream, outputStream); } catch (Exception e) { logger.error("下载文件出错!", e); throw new RuntimeException(e); } } /** * 设置 Redirect URL 到 Session 中 */ public static void setRedirectUrl(HttpServletRequest request, String sessionKey) { if (!isAJAX(request)) { String requestPath = getRequestPath(request); request.getSession().setAttribute(sessionKey, requestPath); } } /** * 创建验证码 */ public static String createCaptcha(HttpServletResponse response) { StringBuilder captcha = new StringBuilder(); try { // 参数初始化 int width = 60; // 验证码图片的宽度 int height = 25; // 验证码图片的高度 int codeCount = 4; // 验证码字符个数 int codeX = width / (codeCount + 1); // 字符横向间距 int codeY = height - 4; // 字符纵向间距 int fontHeight = height - 2; // 字体高度 int randomSeed = 10; // 随机数种子 char[] codeSequence = { // 验证码中可出现的字符 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' }; // 创建图像 BufferedImage bi = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB); Graphics2D g = bi.createGraphics(); // 将图像填充为白色 g.setColor(Color.WHITE); g.fillRect(0, 0, width, height); // 设置字体 g.setFont(new Font("Courier New", Font.BOLD, fontHeight)); // 绘制边框 g.setColor(Color.BLACK); g.drawRect(0, 0, width - 1, height - 1); // 产生随机干扰线(160条) g.setColor(Color.WHITE); // 创建随机数生成器 Random random = new Random(); for (int i = 0; i < 160; i++) { int x = random.nextInt(width); int y = random.nextInt(height); int xl = random.nextInt(12); int yl = random.nextInt(12); g.drawLine(x, y, x + xl, y + yl); } // 生成随机验证码 int red, green, blue; for (int i = 0; i < codeCount; i++) { // 获取随机验证码 String validateCode = String.valueOf(codeSequence[random.nextInt(randomSeed)]); // 随机构造颜色值 red = random.nextInt(255); green = random.nextInt(255); blue = random.nextInt(255); // 将带有颜色的验证码绘制到图像中 g.setColor(new Color(red, green, blue)); g.drawString(validateCode, (i + 1) * codeX - 6, codeY); // 将产生的随机数拼接起来 captcha.append(validateCode); } // 禁止图像缓存 response.setHeader("Cache-Control", "no-store"); response.setHeader("Pragma", "no-cache"); response.setDateHeader("Expires", 0); // 设置响应类型为 JPEG 图片 response.setContentType("image/jpeg"); // 将缓冲图像写到 Servlet 输出流中 ServletOutputStream sos = response.getOutputStream(); ImageIO.write(bi, "jpeg", sos); sos.close(); } catch (Exception e) { logger.error("创建验证码出错!", e); throw new RuntimeException(e); } return captcha.toString(); } /** * 是否为 IE 浏览器 */ public boolean isIE(HttpServletRequest request) { String agent = request.getHeader("User-Agent"); return agent != null && agent.contains("MSIE"); } }