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. 编码与解码操作工具类
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. 集合操作工具类
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 操作工具类
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. 映射操作工具类
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. 对象操作工具类
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. 属性文件操作工具类
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. 流操作工具类
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");
}
}
原文地址：https://www.cnblogs.com/ice-line/p/9965881.html
时间： 2024-10-09 09:02:28