目录
项目依赖配置
Maven依赖 (pom.xml)
<dependencies>
<!-- SpringBoot基础依赖 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- Redis -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!-- 邮件发送 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-mail</artifactId>
</dependency>
<!-- JSON处理 -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
</dependency>
<!-- JWT -->
<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt</artifactId>
<version>0.9.1</version>
</dependency>
<!-- 二维码生成 -->
<dependency>
<groupId>com.google.zxing</groupId>
<artifactId>core</artifactId>
<version>3.5.1</version>
</dependency>
<dependency>
<groupId>com.google.zxing</groupId>
<artifactId>javase</artifactId>
<version>3.5.1</version>
</dependency>
<!-- Excel处理 -->
<dependency>
<groupId>org.apache.poi</groupId>
<artifactId>poi</artifactId>
<version>5.2.3</version>
</dependency>
<dependency>
<groupId>org.apache.poi</groupId>
<artifactId>poi-ooxml</artifactId>
<version>5.2.3</version>
</dependency>
<!-- HTTP客户端 -->
<dependency>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpclient</artifactId>
</dependency>
<!-- 常用工具 -->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
</dependency>
<!-- 邮箱验证 -->
<dependency>
<groupId>commons-validator</groupId>
<artifactId>commons-validator</artifactId>
<version>1.7</version>
</dependency>
</dependencies>
字符串工具类 StringUtils
package com.example.utils;
import java.util.*;
import java.util.regex.Pattern;
/**
* 字符串工具类
* 提供常用的字符串操作方法
*/
public class StringUtils {
// 常用正则表达式
private static final Pattern EMAIL_PATTERN = Pattern.compile(
"^[A-Za-z0-9+_.-]+@([A-Za-z0-9.-]+\\.[A-Za-z]{2,})$");
private static final Pattern PHONE_PATTERN = Pattern.compile("^1[3-9]\\d{9}$");
private static final Pattern ID_CARD_PATTERN = Pattern.compile(
"^[1-9]\\d{5}(18|19|20)\\d{2}((0[1-9])|(1[0-2]))(([0-2][1-9])|10|20|30|31)\\d{3}[0-9Xx]$");
/**
* 判断字符串是否为空（null、空字符串、只包含空白字符）
* @param str 待检查的字符串
* @return 为空返回true，否则返回false
*/
public static boolean isEmpty(String str) {
return str == null || str.trim().isEmpty();
}
/**
* 判断字符串是否不为空
* @param str 待检查的字符串
* @return 不为空返回true，否则返回false
*/
public static boolean isNotEmpty(String str) {
return !isEmpty(str);
}
/**
* 判断多个字符串是否都不为空
* @param strings 字符串数组
* @return 都不为空返回true，否则返回false
*/
public static boolean isAllNotEmpty(String... strings) {
if (strings == null || strings.length == 0) {
return false;
}
for (String str : strings) {
if (isEmpty(str)) {
return false;
}
}
return true;
}
/**
* 字符串首字母大写
* @param str 原字符串
* @return 首字母大写的字符串
*/
public static String capitalize(String str) {
if (isEmpty(str)) {
return str;
}
return str.substring(0, 1).toUpperCase() + str.substring(1);
}
/**
* 字符串首字母小写
* @param str 原字符串
* @return 首字母小写的字符串
*/
public static String uncapitalize(String str) {
if (isEmpty(str)) {
return str;
}
return str.substring(0, 1).toLowerCase() + str.substring(1);
}
/**
* 驼峰转下划线
* @param camelCase 驼峰字符串
* @return 下划线字符串
*/
public static String camelToUnderscore(String camelCase) {
if (isEmpty(camelCase)) {
return camelCase;
}
return camelCase.replaceAll("([a-z])([A-Z])", "$1_$2").toLowerCase();
}
/**
* 下划线转驼峰
* @param underscore 下划线字符串
* @return 驼峰字符串
*/
public static String underscoreToCamel(String underscore) {
if (isEmpty(underscore)) {
return underscore;
}
StringBuilder result = new StringBuilder();
String[] parts = underscore.split("_");
for (int i = 0; i < parts.length; i++) {
if (i == 0) {
result.append(parts[i].toLowerCase());
} else {
result.append(capitalize(parts[i].toLowerCase()));
}
}
return result.toString();
}
/**
* 隐藏手机号中间4位
* @param phone 手机号
* @return 隐藏后的手机号（如：137****8888）
*/
public static String hidePhone(String phone) {
if (isEmpty(phone) || phone.length() != 11) {
return phone;
}
return phone.substring(0, 3) + "****" + phone.substring(7);
}
/**
* 隐藏邮箱地址
* @param email 邮箱地址
* @return 隐藏后的邮箱（如：ab***@gmail.com）
*/
public static String hideEmail(String email) {
if (isEmpty(email) || !email.contains("@")) {
return email;
}
String[] parts = email.split("@");
String username = parts[0];
if (username.length() <= 2) {
return email;
}
String hiddenUsername = username.substring(0, 2) + "***";
return hiddenUsername + "@" + parts[1];
}
/**
* 隐藏身份证号
* @param idCard 身份证号
* @return 隐藏后的身份证号（如：320***********1234）
*/
public static String hideIdCard(String idCard) {
if (isEmpty(idCard) || idCard.length() != 18) {
return idCard;
}
return idCard.substring(0, 3) + "***********" + idCard.substring(14);
}
/**
* 生成随机字符串
* @param length 长度
* @return 随机字符串
*/
public static String randomString(int length) {
String characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
Random random = new Random();
StringBuilder sb = new StringBuilder();
for (int i = 0; i < length; i++) {
sb.append(characters.charAt(random.nextInt(characters.length())));
}
return sb.toString();
}
/**
* 生成随机数字字符串
* @param length 长度
* @return 随机数字字符串
*/
public static String randomNumbers(int length) {
Random random = new Random();
StringBuilder sb = new StringBuilder();
for (int i = 0; i < length; i++) {
sb.append(random.nextInt(10));
}
return sb.toString();
}
/**
* 验证邮箱格式
* @param email 邮箱地址
* @return 格式正确返回true
*/
public static boolean isValidEmail(String email) {
return isNotEmpty(email) && EMAIL_PATTERN.matcher(email).matches();
}
/**
* 验证手机号格式
* @param phone 手机号
* @return 格式正确返回true
*/
public static boolean isValidPhone(String phone) {
return isNotEmpty(phone) && PHONE_PATTERN.matcher(phone).matches();
}
/**
* 验证身份证号格式
* @param idCard 身份证号
* @return 格式正确返回true
*/
public static boolean isValidIdCard(String idCard) {
return isNotEmpty(idCard) && ID_CARD_PATTERN.matcher(idCard).matches();
}
/**
* 字符串重复
* @param str 原字符串
* @param times 重复次数
* @return 重复后的字符串
*/
public static String repeat(String str, int times) {
if (isEmpty(str) || times <= 0) {
return "";
}
StringBuilder sb = new StringBuilder();
for (int i = 0; i < times; i++) {
sb.append(str);
}
return sb.toString();
}
/**
* 计算字符串相似度（编辑距离算法）
* @param str1 字符串1
* @param str2 字符串2
* @return 相似度（0-1之间）
*/
public static double similarity(String str1, String str2) {
if (str1 == null || str2 == null) {
return 0;
}
if (str1.equals(str2)) {
return 1;
}
int distance = editDistance(str1, str2);
int maxLength = Math.max(str1.length(), str2.length());
return 1.0 - (double) distance / maxLength;
}
/**
* 计算编辑距离
*/
private static int editDistance(String str1, String str2) {
int m = str1.length();
int n = str2.length();
int[][] dp = new int[m + 1][n + 1];
for (int i = 0; i <= m; i++) {
dp[i][0] = i;
}
for (int j = 0; j <= n; j++) {
dp[0][j] = j;
}
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
if (str1.charAt(i - 1) == str2.charAt(j - 1)) {
dp[i][j] = dp[i - 1][j - 1];
} else {
dp[i][j] = Math.min(Math.min(dp[i - 1][j], dp[i][j - 1]), dp[i - 1][j - 1]) + 1;
}
}
}
return dp[m][n];
}
}
日期时间工具类 DateUtils
package com.example.utils;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.util.Date;
/**
* 日期时间工具类
* 基于Java 8的时间API，提供常用的日期时间操作
*/
public class DateUtils {
// 常用日期格式
public static final String DEFAULT_DATE_FORMAT = "yyyy-MM-dd";
public static final String DEFAULT_TIME_FORMAT = "HH:mm:ss";
public static final String DEFAULT_DATETIME_FORMAT = "yyyy-MM-dd HH:mm:ss";
public static final String COMPACT_DATETIME_FORMAT = "yyyyMMddHHmmss";
public static final String CHINESE_DATE_FORMAT = "yyyy年MM月dd日";
// 预定义格式化器
private static final DateTimeFormatter DATE_FORMATTER = DateTimeFormatter.ofPattern(DEFAULT_DATE_FORMAT);
private static final DateTimeFormatter TIME_FORMATTER = DateTimeFormatter.ofPattern(DEFAULT_TIME_FORMAT);
private static final DateTimeFormatter DATETIME_FORMATTER = DateTimeFormatter.ofPattern(DEFAULT_DATETIME_FORMAT);
/**
* 获取当前日期字符串
* @return 当前日期（yyyy-MM-dd）
*/
public static String getCurrentDate() {
return LocalDate.now().format(DATE_FORMATTER);
}
/**
* 获取当前时间字符串
* @return 当前时间（HH:mm:ss）
*/
public static String getCurrentTime() {
return LocalTime.now().format(TIME_FORMATTER);
}
/**
* 获取当前日期时间字符串
* @return 当前日期时间（yyyy-MM-dd HH:mm:ss）
*/
public static String getCurrentDateTime() {
return LocalDateTime.now().format(DATETIME_FORMATTER);
}
/**
* 获取当前时间戳（毫秒）
* @return 时间戳
*/
public static long getCurrentTimestamp() {
return System.currentTimeMillis();
}
/**
* 日期格式化
* @param date 日期
* @param pattern 格式模式
* @return 格式化后的字符串
*/
public static String format(LocalDate date, String pattern) {
if (date == null) {
return null;
}
return date.format(DateTimeFormatter.ofPattern(pattern));
}
/**
* 日期时间格式化
* @param dateTime 日期时间
* @param pattern 格式模式
* @return 格式化后的字符串
*/
public static String format(LocalDateTime dateTime, String pattern) {
if (dateTime == null) {
return null;
}
return dateTime.format(DateTimeFormatter.ofPattern(pattern));
}
/**
* 字符串转日期
* @param dateStr 日期字符串
* @param pattern 格式模式
* @return 日期对象
*/
public static LocalDate parseDate(String dateStr, String pattern) {
if (StringUtils.isEmpty(dateStr)) {
return null;
}
return LocalDate.parse(dateStr, DateTimeFormatter.ofPattern(pattern));
}
/**
* 字符串转日期时间
* @param dateTimeStr 日期时间字符串
* @param pattern 格式模式
* @return 日期时间对象
*/
public static LocalDateTime parseDateTime(String dateTimeStr, String pattern) {
if (StringUtils.isEmpty(dateTimeStr)) {
return null;
}
return LocalDateTime.parse(dateTimeStr, DateTimeFormatter.ofPattern(pattern));
}
/**
* 时间戳转日期时间
* @param timestamp 时间戳（毫秒）
* @return 日期时间对象
*/
public static LocalDateTime timestampToDateTime(long timestamp) {
return LocalDateTime.ofInstant(Instant.ofEpochMilli(timestamp), ZoneId.systemDefault());
}
/**
* 日期时间转时间戳
* @param dateTime 日期时间
* @return 时间戳（毫秒）
*/
public static long dateTimeToTimestamp(LocalDateTime dateTime) {
return dateTime.atZone(ZoneId.systemDefault()).toInstant().toEpochMilli();
}
/**
* Date转LocalDateTime
* @param date Date对象
* @return LocalDateTime对象
*/
public static LocalDateTime dateToLocalDateTime(Date date) {
if (date == null) {
return null;
}
return date.toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime();
}
/**
* LocalDateTime转Date
* @param dateTime LocalDateTime对象
* @return Date对象
*/
public static Date localDateTimeToDate(LocalDateTime dateTime) {
if (dateTime == null) {
return null;
}
return Date.from(dateTime.atZone(ZoneId.systemDefault()).toInstant());
}
/**
* 日期加减天数
* @param date 原日期
* @param days 天数（正数为加，负数为减）
* @return 计算后的日期
*/
public static LocalDate addDays(LocalDate date, long days) {
return date == null ? null : date.plusDays(days);
}
/**
* 日期时间加减小时
* @param dateTime 原日期时间
* @param hours 小时数
* @return 计算后的日期时间
*/
public static LocalDateTime addHours(LocalDateTime dateTime, long hours) {
return dateTime == null ? null : dateTime.plusHours(hours);
}
/**
* 日期时间加减分钟
* @param dateTime 原日期时间
* @param minutes 分钟数
* @return 计算后的日期时间
*/
public static LocalDateTime addMinutes(LocalDateTime dateTime, long minutes) {
return dateTime == null ? null : dateTime.plusMinutes(minutes);
}
/**
* 计算两个日期之间的天数差
* @param startDate 开始日期
* @param endDate 结束日期
* @return 天数差（正数表示endDate在startDate之后）
*/
public static long daysBetween(LocalDate startDate, LocalDate endDate) {
return ChronoUnit.DAYS.between(startDate, endDate);
}
/**
* 计算两个日期时间之间的小时差
* @param startDateTime 开始日期时间
* @param endDateTime 结束日期时间
* @return 小时差
*/
public static long hoursBetween(LocalDateTime startDateTime, LocalDateTime endDateTime) {
return ChronoUnit.HOURS.between(startDateTime, endDateTime);
}
/**
* 计算两个日期时间之间的分钟差
* @param startDateTime 开始日期时间
* @param endDateTime 结束日期时间
* @return 分钟差
*/
public static long minutesBetween(LocalDateTime startDateTime, LocalDateTime endDateTime) {
return ChronoUnit.MINUTES.between(startDateTime, endDateTime);
}
/**
* 获取本周第一天（周一）
* @return 本周第一天
*/
public static LocalDate getFirstDayOfWeek() {
return LocalDate.now().with(DayOfWeek.MONDAY);
}
/**
* 获取本周最后一天（周日）
* @return 本周最后一天
*/
public static LocalDate getLastDayOfWeek() {
return LocalDate.now().with(DayOfWeek.SUNDAY);
}
/**
* 获取本月第一天
* @return 本月第一天
*/
public static LocalDate getFirstDayOfMonth() {
return LocalDate.now().withDayOfMonth(1);
}
/**
* 获取本月最后一天
* @return 本月最后一天
*/
public static LocalDate getLastDayOfMonth() {
LocalDate now = LocalDate.now();
return now.withDayOfMonth(now.lengthOfMonth());
}
/**
* 获取本年第一天
* @return 本年第一天
*/
public static LocalDate getFirstDayOfYear() {
return LocalDate.now().withDayOfYear(1);
}
/**
* 获取本年最后一天
* @return 本年最后一天
*/
public static LocalDate getLastDayOfYear() {
LocalDate now = LocalDate.now();
return now.withDayOfYear(now.lengthOfYear());
}
/**
* 判断是否为同一天
* @param date1 日期1
* @param date2 日期2
* @return 是否为同一天
*/
public static boolean isSameDay(LocalDate date1, LocalDate date2) {
return date1 != null && date2 != null && date1.equals(date2);
}
/**
* 判断日期是否在指定范围内
* @param date 待检查的日期
* @param startDate 开始日期
* @param endDate 结束日期
* @return 是否在范围内
*/
public static boolean isInRange(LocalDate date, LocalDate startDate, LocalDate endDate) {
return date != null && startDate != null && endDate != null &&
!date.isBefore(startDate) && !date.isAfter(endDate);
}
/**
* 判断是否为今天
* @param date 日期
* @return 是否为今天
*/
public static boolean isToday(LocalDate date) {
return isSameDay(date, LocalDate.now());
}
/**
* 判断是否为昨天
* @param date 日期
* @return 是否为昨天
*/
public static boolean isYesterday(LocalDate date) {
return isSameDay(date, LocalDate.now().minusDays(1));
}
/**
* 判断是否为明天
* @param date 日期
* @return 是否为明天
*/
public static boolean isTomorrow(LocalDate date) {
return isSameDay(date, LocalDate.now().plusDays(1));
}
/**
* 判断是否为闰年
* @param year 年份
* @return 是否为闰年
*/
public static boolean isLeapYear(int year) {
return Year.of(year).isLeap();
}
/**
* 获取年龄
* @param birthDate 出生日期
* @return 年龄
*/
public static int getAge(LocalDate birthDate) {
return birthDate == null ? 0 : Period.between(birthDate, LocalDate.now()).getYears();
}
}
JSON工具类 JsonUtils
package com.example.utils;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.type.CollectionType;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import java.util.List;
import java.util.Map;
/**
* JSON工具类
* 基于Jackson实现JSON的序列化和反序列化
*/
public class JsonUtils {
private static final ObjectMapper objectMapper = new ObjectMapper();
static {
// 注册Java 8时间模块
objectMapper.registerModule(new JavaTimeModule());
// 忽略未知属性
objectMapper.configure(com.fasterxml.jackson.databind.DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
}
/**
* 对象转JSON字符串
* @param obj 对象
* @return JSON字符串
*/
public static String toJsonString(Object obj) {
if (obj == null) {
return null;
}
try {
return objectMapper.writeValueAsString(obj);
} catch (JsonProcessingException e) {
throw new RuntimeException("对象转JSON失败", e);
}
}
/**
* 对象转格式化的JSON字符串（美化输出）
* @param obj 对象
* @return 格式化的JSON字符串
*/
public static String toPrettyJsonString(Object obj) {
if (obj == null) {
return null;
}
try {
return objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(obj);
} catch (JsonProcessingException e) {
throw new RuntimeException("对象转JSON失败", e);
}
}
/**
* JSON字符串转对象
* @param jsonString JSON字符串
* @param clazz 目标类型
* @param <T> 泛型
* @return 对象
*/
public static <T> T parseObject(String jsonString, Class<T> clazz) {
if (StringUtils.isEmpty(jsonString)) {
return null;
}
try {
return objectMapper.readValue(jsonString, clazz);
} catch (JsonProcessingException e) {
throw new RuntimeException("JSON转对象失败", e);
}
}
/**
* JSON字符串转对象（复杂类型）
* @param jsonString JSON字符串
* @param typeReference 类型引用
* @param <T> 泛型
* @return 对象
*/
public static <T> T parseObject(String jsonString, TypeReference<T> typeReference) {
if (StringUtils.isEmpty(jsonString)) {
return null;
}
try {
return objectMapper.readValue(jsonString, typeReference);
} catch (JsonProcessingException e) {
throw new RuntimeException("JSON转对象失败", e);
}
}
/**
* JSON字符串转List
* @param jsonString JSON字符串
* @param clazz 列表元素类型
* @param <T> 泛型
* @return List对象
*/
public static <T> List<T> parseList(String jsonString, Class<T> clazz) {
if (StringUtils.isEmpty(jsonString)) {
return null;
}
try {
CollectionType listType = objectMapper.getTypeFactory().constructCollectionType(List.class, clazz);
return objectMapper.readValue(jsonString, listType);
} catch (JsonProcessingException e) {
throw new RuntimeException("JSON转List失败", e);
}
}
/**
* JSON字符串转Map
* @param jsonString JSON字符串
* @return Map对象
*/
public static Map<String, Object> parseMap(String jsonString) {
if (StringUtils.isEmpty(jsonString)) {
return null;
}
try {
return objectMapper.readValue(jsonString, new TypeReference<Map<String, Object>>() {});
} catch (JsonProcessingException e) {
throw new RuntimeException("JSON转Map失败", e);
}
}
/**
* 对象转Map
* @param obj 对象
* @return Map
*/
public static Map<String, Object> objectToMap(Object obj) {
if (obj == null) {
return null;
}
return objectMapper.convertValue(obj, new TypeReference<Map<String, Object>>() {});
}
/**
* Map转对象
* @param map Map
* @param clazz 目标类型
* @param <T> 泛型
* @return 对象
*/
public static <T> T mapToObject(Map<String, Object> map, Class<T> clazz) {
if (map == null) {
return null;
}
return objectMapper.convertValue(map, clazz);
}
/**
* 获取JSON节点
* @param jsonString JSON字符串
* @return JsonNode
*/
public static JsonNode getJsonNode(String jsonString) {
if (StringUtils.isEmpty(jsonString)) {
return null;
}
try {
return objectMapper.readTree(jsonString);
} catch (JsonProcessingException e) {
throw new RuntimeException("解析JSON节点失败", e);
}
}
/**
* 获取JSON中指定路径的值
* @param jsonString JSON字符串
* @param path 路径（如：user.name）
* @return 值
*/
public static String getValueByPath(String jsonString, String path) {
JsonNode jsonNode = getJsonNode(jsonString);
if (jsonNode == null) {
return null;
}
String[] pathArray = path.split("\\.");
JsonNode currentNode = jsonNode;
for (String pathSegment : pathArray) {
currentNode = currentNode.get(pathSegment);
if (currentNode == null) {
return null;
}
}
return currentNode.isTextual() ? currentNode.textValue() : currentNode.toString();
}
/**
* 判断字符串是否为有效的JSON
* @param jsonString 字符串
* @return 是否为有效JSON
*/
public static boolean isValidJson(String jsonString) {
if (StringUtils.isEmpty(jsonString)) {
return false;
}
try {
objectMapper.readTree(jsonString);
return true;
} catch (JsonProcessingException e) {
return false;
}
}
/**
* 深度复制对象（通过JSON序列化实现）
* @param obj 原对象
* @param clazz 目标类型
* @param <T> 泛型
* @return 复制的对象
*/
public static <T> T deepCopy(Object obj, Class<T> clazz) {
if (obj == null) {
return null;
}
String jsonString = toJsonString(obj);
return parseObject(jsonString, clazz);
}
}
HTTP请求工具类 HttpUtils
package com.example.utils;
import org.apache.http.HttpEntity;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.Map;
/**
* HTTP请求工具类
* 基于Apache HttpClient实现HTTP请求
*/
public class HttpUtils {
// 默认超时时间（毫秒）
private static final int DEFAULT_TIMEOUT = 10000;
// 默认编码
private static final String DEFAULT_CHARSET = "UTF-8";
/**
* 发送GET请求
* @param url 请求地址
* @return 响应内容
*/
public static String get(String url) {
return get(url, null, DEFAULT_TIMEOUT);
}
/**
* 发送GET请求（带请求头）
* @param url 请求地址
* @param headers 请求头
* @return 响应内容
*/
public static String get(String url, Map<String, String> headers) {
return get(url, headers, DEFAULT_TIMEOUT);
}
/**
* 发送GET请求（完整参数）
* @param url 请求地址
* @param headers 请求头
* @param timeout 超时时间
* @return 响应内容
*/
public static String get(String url, Map<String, String> headers, int timeout) {
CloseableHttpClient httpClient = HttpClients.createDefault();
CloseableHttpResponse response = null;
try {
HttpGet httpGet = new HttpGet(url);
// 设置请求配置
RequestConfig requestConfig = RequestConfig.custom()
.setConnectTimeout(timeout)
.setSocketTimeout(timeout)
.build();
httpGet.setConfig(requestConfig);
// 设置请求头
if (headers != null && !headers.isEmpty()) {
for (Map.Entry<String, String> entry : headers.entrySet()) {
httpGet.setHeader(entry.getKey(), entry.getValue());
}
}
response = httpClient.execute(httpGet);
HttpEntity entity = response.getEntity();
if (entity != null) {
return EntityUtils.toString(entity, DEFAULT_CHARSET);
}
} catch (IOException e) {
throw new RuntimeException("GET请求失败: " + e.getMessage(), e);
} finally {
closeResources(response, httpClient);
}
return null;
}
/**
* 发送POST请求（JSON数据）
* @param url 请求地址
* @param jsonData JSON数据
* @return 响应内容
*/
public static String postJson(String url, String jsonData) {
return postJson(url, jsonData, null, DEFAULT_TIMEOUT);
}
/**
* 发送POST请求（JSON数据，带请求头）
* @param url 请求地址
* @param jsonData JSON数据
* @param headers 请求头
* @return 响应内容
*/
public static String postJson(String url, String jsonData, Map<Strin