package cc.mrbird.febs.common.core.utils;
|
|
import cc.mrbird.febs.common.core.annotation.FieldInfo;
|
import cc.mrbird.febs.common.core.entity.CurrentUser;
|
import cc.mrbird.febs.common.core.entity.FebsAuthUser;
|
import cc.mrbird.febs.common.core.entity.constant.PageConstant;
|
import cc.mrbird.febs.common.core.entity.constant.RegexpConstant;
|
import cc.mrbird.febs.common.core.entity.constant.StringConstant;
|
import cn.hutool.core.annotation.AnnotationUtil;
|
import cn.hutool.core.util.ReflectUtil;
|
import com.alibaba.fastjson.JSONObject;
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.fasterxml.jackson.databind.ObjectMapper;
|
import lombok.extern.slf4j.Slf4j;
|
import org.apache.commons.lang3.StringUtils;
|
import org.springframework.core.env.Environment;
|
import org.springframework.core.io.buffer.DataBuffer;
|
import org.springframework.http.HttpHeaders;
|
import org.springframework.http.HttpStatus;
|
import org.springframework.http.MediaType;
|
import org.springframework.http.server.reactive.ServerHttpRequest;
|
import org.springframework.http.server.reactive.ServerHttpResponse;
|
import org.springframework.security.core.Authentication;
|
import org.springframework.security.core.GrantedAuthority;
|
import org.springframework.security.core.context.SecurityContextHolder;
|
import org.springframework.security.oauth2.provider.OAuth2Authentication;
|
import org.springframework.security.oauth2.provider.authentication.OAuth2AuthenticationDetails;
|
import org.springframework.web.context.request.RequestContextHolder;
|
import org.springframework.web.context.request.ServletRequestAttributes;
|
import reactor.core.publisher.Mono;
|
|
import javax.servlet.http.HttpServletRequest;
|
import javax.servlet.http.HttpServletResponse;
|
import java.io.IOException;
|
import java.lang.reflect.Field;
|
import java.time.LocalDateTime;
|
import java.util.*;
|
import java.util.regex.Matcher;
|
import java.util.regex.Pattern;
|
import java.util.stream.Collectors;
|
import java.util.stream.IntStream;
|
|
/**
|
* FEBS工具类
|
*
|
* @author MrBird
|
*/
|
@Slf4j
|
public abstract class FebsUtil {
|
|
private static final String UNKNOW = "unknown";
|
|
/**
|
* 驼峰转下划线
|
*
|
* @param value 待转换值
|
* @return 结果
|
*/
|
public static String camelToUnderscore(String value) {
|
if (StringUtils.isBlank(value)) {
|
return value;
|
}
|
String[] arr = StringUtils.splitByCharacterTypeCamelCase(value);
|
if (arr.length == 0) {
|
return value;
|
}
|
StringBuilder result = new StringBuilder();
|
IntStream.range(0, arr.length).forEach(i -> {
|
if (i != arr.length - 1) {
|
result.append(arr[i]).append("_");
|
} else {
|
result.append(arr[i]);
|
}
|
});
|
return StringUtils.lowerCase(result.toString());
|
}
|
|
/**
|
* 下划线转驼峰
|
*
|
* @param value 待转换值
|
* @return 结果
|
*/
|
public static String underscoreToCamel(String value) {
|
StringBuilder result = new StringBuilder();
|
String[] arr = value.split(StringConstant.UNDER_LINE);
|
for (String s : arr) {
|
result.append((String.valueOf(s.charAt(0))).toUpperCase()).append(s.substring(1));
|
}
|
return result.toString();
|
}
|
|
/**
|
* 判断是否为 ajax请求
|
*
|
* @param request HttpServletRequest
|
* @return boolean
|
*/
|
public static boolean isAjaxRequest(HttpServletRequest request) {
|
return (request.getHeader("X-Requested-With") != null
|
&& "XMLHttpRequest".equals(request.getHeader("X-Requested-With")));
|
}
|
|
/**
|
* 正则校验
|
*
|
* @param regex 正则表达式字符串
|
* @param value 要匹配的字符串
|
* @return 正则校验结果
|
*/
|
public static boolean match(String regex, String value) {
|
Pattern pattern = Pattern.compile(regex);
|
Matcher matcher = pattern.matcher(value);
|
return matcher.matches();
|
}
|
|
/**
|
* 设置响应
|
*
|
* @param response HttpServletResponse
|
* @param contentType content-type
|
* @param status http状态码
|
* @param value 响应内容
|
* @throws IOException IOException
|
*/
|
public static void makeResponse(HttpServletResponse response, String contentType,
|
int status, Object value) throws IOException {
|
response.setContentType(contentType);
|
response.setStatus(status);
|
response.getOutputStream().write(JSONObject.toJSONString(value).getBytes());
|
}
|
|
/**
|
* 设置成功响应
|
*
|
* @param response HttpServletResponse
|
* @param value 响应内容
|
* @throws IOException IOException
|
*/
|
public static void makeSuccessResponse(HttpServletResponse response, Object value) throws IOException {
|
makeResponse(response, MediaType.APPLICATION_JSON_VALUE, HttpServletResponse.SC_OK, value);
|
}
|
|
/**
|
* 设置失败响应
|
*
|
* @param response HttpServletResponse
|
* @param value 响应内容
|
* @throws IOException IOException
|
*/
|
public static void makeFailureResponse(HttpServletResponse response, Object value) throws IOException {
|
makeResponse(response, MediaType.APPLICATION_JSON_VALUE, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, value);
|
}
|
|
/**
|
* 设置JSON类型响应
|
*
|
* @param response HttpServletResponse
|
* @param status http状态码
|
* @param value 响应内容
|
* @throws IOException IOException
|
*/
|
public static void makeJsonResponse(HttpServletResponse response, int status, Object value) throws IOException {
|
makeResponse(response, MediaType.APPLICATION_JSON_VALUE, status, value);
|
}
|
|
/**
|
* 设置webflux模型响应
|
*
|
* @param response ServerHttpResponse
|
* @param contentType content-type
|
* @param status http状态码
|
* @param value 响应内容
|
* @return Mono<Void>
|
*/
|
public static Mono<Void> makeWebFluxResponse(ServerHttpResponse response, String contentType,
|
HttpStatus status, Object value) {
|
response.setStatusCode(status);
|
response.getHeaders().add(HttpHeaders.CONTENT_TYPE, contentType);
|
DataBuffer dataBuffer = response.bufferFactory().wrap(JSONObject.toJSONString(value).getBytes());
|
return response.writeWith(Mono.just(dataBuffer));
|
}
|
|
/**
|
* 封装前端分页表格所需数据
|
*
|
* @param pageInfo pageInfo
|
* @return Map<String, Object>
|
*/
|
public static Map<String, Object> getDataTable(IPage<?> pageInfo) {
|
Map<String, Object> data = new HashMap<>(2);
|
data.put(PageConstant.ROWS, pageInfo.getRecords());
|
data.put(PageConstant.TOTAL, pageInfo.getTotal());
|
return data;
|
}
|
|
/**
|
* 获取HttpServletRequest
|
*
|
* @return HttpServletRequest
|
*/
|
public static HttpServletRequest getHttpServletRequest() {
|
return ((ServletRequestAttributes) Objects.requireNonNull(RequestContextHolder.getRequestAttributes())).getRequest();
|
}
|
|
/**
|
* 获取请求IP
|
*
|
* @return String IP
|
*/
|
public static String getHttpServletRequestIpAddress() {
|
HttpServletRequest request = getHttpServletRequest();
|
String ip = request.getHeader("x-forwarded-for");
|
if (ip == null || ip.length() == 0 || UNKNOW.equalsIgnoreCase(ip)) {
|
ip = request.getHeader("Proxy-Client-IP");
|
}
|
if (ip == null || ip.length() == 0 || UNKNOW.equalsIgnoreCase(ip)) {
|
ip = request.getHeader("WL-Proxy-Client-IP");
|
}
|
if (ip == null || ip.length() == 0 || UNKNOW.equalsIgnoreCase(ip)) {
|
ip = request.getRemoteAddr();
|
}
|
return "0:0:0:0:0:0:0:1".equals(ip) ? "127.0.0.1" : ip;
|
}
|
|
/**
|
* 获取请求IP
|
*
|
* @param request ServerHttpRequest
|
* @return String IP
|
*/
|
public static String getServerHttpRequestIpAddress(ServerHttpRequest request) {
|
HttpHeaders headers = request.getHeaders();
|
String ip = headers.getFirst("x-forwarded-for");
|
if (ip != null && ip.length() != 0 && !UNKNOW.equalsIgnoreCase(ip)) {
|
if (ip.contains(StringConstant.COMMA)) {
|
ip = ip.split(StringConstant.COMMA)[0];
|
}
|
}
|
if (ip == null || ip.length() == 0 || UNKNOW.equalsIgnoreCase(ip)) {
|
ip = headers.getFirst("Proxy-Client-IP");
|
}
|
if (ip == null || ip.length() == 0 || UNKNOW.equalsIgnoreCase(ip)) {
|
ip = headers.getFirst("WL-Proxy-Client-IP");
|
}
|
if (ip == null || ip.length() == 0 || UNKNOW.equalsIgnoreCase(ip)) {
|
ip = headers.getFirst("HTTP_CLIENT_IP");
|
}
|
if (ip == null || ip.length() == 0 || UNKNOW.equalsIgnoreCase(ip)) {
|
ip = headers.getFirst("HTTP_X_FORWARDED_FOR");
|
}
|
if (ip == null || ip.length() == 0 || UNKNOW.equalsIgnoreCase(ip)) {
|
ip = headers.getFirst("X-Real-IP");
|
}
|
if (ip == null || ip.length() == 0 || UNKNOW.equalsIgnoreCase(ip)) {
|
ip = Objects.requireNonNull(request.getRemoteAddress()).getAddress().getHostAddress();
|
}
|
return "0:0:0:0:0:0:0:1".equals(ip) ? "127.0.0.1" : ip;
|
}
|
|
/**
|
* 判断是否包含中文
|
*
|
* @param value 内容
|
* @return 结果
|
*/
|
public static boolean containChinese(String value) {
|
if (StringUtils.isBlank(value)) {
|
return Boolean.FALSE;
|
}
|
Matcher matcher = RegexpConstant.CHINESE.matcher(value);
|
return matcher.find();
|
}
|
|
/**
|
* 获取在线用户信息
|
*
|
* @return CurrentUser 当前用户信息
|
*/
|
public static CurrentUser getCurrentUser() {
|
try {
|
LinkedHashMap<String, Object> authenticationDetails = getAuthenticationDetails();
|
Object principal = authenticationDetails.get("principal");
|
ObjectMapper mapper = new ObjectMapper();
|
return mapper.readValue(mapper.writeValueAsString(principal), CurrentUser.class);
|
} catch (Exception e) {
|
log.error("获取当前用户信息失败", e);
|
return null;
|
}
|
}
|
|
public static String getUserId() {
|
return Optional.ofNullable(getCurrentUser())
|
.map(u -> u.getUserId().toString())
|
.orElse("1");
|
}
|
|
/**
|
* 获取当前用户名称
|
*
|
* @return String 用户名
|
*/
|
public static String getCurrentUsername() {
|
Object principal = getOauth2Authentication().getPrincipal();
|
if (principal instanceof FebsAuthUser) {
|
return ((FebsAuthUser) principal).getUsername();
|
}
|
return (String) getOauth2Authentication().getPrincipal();
|
}
|
|
/**
|
* 获取当前用户权限集
|
*
|
* @return Collection<GrantedAuthority>权限集
|
*/
|
public static Collection<GrantedAuthority> getCurrentUserAuthority() {
|
return getOauth2Authentication().getAuthorities();
|
}
|
|
/**
|
* 获取当前令牌内容
|
*
|
* @return String 令牌内容
|
*/
|
public static String getCurrentTokenValue() {
|
try {
|
OAuth2AuthenticationDetails details = (OAuth2AuthenticationDetails) getOauth2Authentication().getDetails();
|
return details.getTokenValue();
|
} catch (Exception ignore) {
|
return null;
|
}
|
}
|
|
public static void printSystemUpBanner(Environment environment) {
|
String banner = "-----------------------------------------\n" +
|
"服务启动成功，时间：" + DateUtil.formatFullTime(LocalDateTime.now(), DateUtil.FULL_TIME_SPLIT_PATTERN) + "\n" +
|
"服务名称：" + environment.getProperty("spring.application.name") + "\n" +
|
"端口号：" + environment.getProperty("server.port") + "\n" +
|
"-----------------------------------------";
|
System.out.println(banner);
|
}
|
|
|
private static OAuth2Authentication getOauth2Authentication() {
|
Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
|
return (OAuth2Authentication) authentication;
|
}
|
|
@SuppressWarnings("all")
|
private static LinkedHashMap<String, Object> getAuthenticationDetails() {
|
return (LinkedHashMap<String, Object>) getOauth2Authentication().getUserAuthentication().getDetails();
|
}
|
|
/**
|
* 通过反射拿到注解
|
*
|
* @param beanClass
|
* @return java.lang.String
|
* @description
|
* @author yz
|
* @date 2021/3/7 2:25 下午
|
* @method reflectAnnotation
|
*/
|
public static String reflectAnnotation(Class<?> beanClass) {
|
Field[] fields = ReflectUtil.getFields(beanClass);
|
List<String> list = new ArrayList<>();
|
for (Field field : fields) {
|
FieldInfo fieldInfo = field.getAnnotation(FieldInfo.class);
|
if (null != fieldInfo) {
|
list.add(field.getName());
|
}
|
}
|
return list.stream().collect(Collectors.joining(StringConstant.COMMA));
|
}
|
}
|
