package init

main
liu 1 year ago
parent bd7831b4bc
commit 9edb5300a9

@ -0,0 +1,91 @@
package com.supervision.nxllmcommon.config;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import cn.hutool.jwt.JWT;
import cn.hutool.jwt.JWTUtil;
import com.supervision.nxllmcommon.exception.BusinessException;
import com.supervision.nxllmcommon.util.TokenUtil;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;
import org.jetbrains.annotations.NotNull;
import org.springframework.http.HttpStatus;
import org.springframework.lang.Nullable;
import org.springframework.web.servlet.HandlerInterceptor;
import java.util.HashMap;
import java.util.Map;
@Slf4j
public class JwtInterceptor implements HandlerInterceptor {
public JwtInterceptor() {
}
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
//请求消息头获取用户ID
String token = request.getHeader("token");
if (StrUtil.isBlank(token)) {
// 如果是swagger来的接口,说明这里是测试的,会伪造一个用户
String referer = request.getHeader("Referer");
if (StrUtil.isNotBlank(referer) && StrUtil.contains(referer, "doc.html")) {
cacheAuth(JWTUtil.parseToken(devActiveUser()));
return true;
} else {
throw new BusinessException("当前用户未登录", HttpStatus.UNAUTHORIZED.value());
}
}
JWT jwt = JWTUtil.parseToken(token);
// 校验token是否过期,如果过期了,需要提示过期重新登录
checkTokenExpire(jwt);
cacheAuth(jwt);
return true;
}
@Override
public void afterCompletion(@NotNull HttpServletRequest request, @NotNull HttpServletResponse response, @NotNull Object handler,
@Nullable Exception ex) throws Exception {
// 请求结束,将用户信息从thread中移除
clearAuth();
HandlerInterceptor.super.afterCompletion(request, response, handler, ex);
}
private void checkTokenExpire(JWT jwt) {
Object expireTime = jwt.getPayload("expireTime");
long l = Long.parseLong(String.valueOf(expireTime));
// 校验是否比当前时间大
long currentTimeMillis = System.currentTimeMillis();
if (currentTimeMillis > l) {
throw new BusinessException("用户登录已过期,请重新登录", HttpStatus.UNAUTHORIZED.value());
}
}
private void cacheAuth(JWT jwt) {
try {
JSONObject claimsJson = jwt.getPayload().getClaimsJson();
ThreadCache.USER.set(claimsJson.toString());
} catch (Exception e) {
log.error("用户信息异常", e);
}
}
private String devActiveUser() {
Map<String, Object> map = new HashMap<>();
map.put("id", "1");
map.put("account", "test");
map.put("name", "测试");
return TokenUtil.creatToken(JSONUtil.toJsonStr(map));
}
private void clearAuth() {
ThreadCache.USER.remove();
}
}

@ -0,0 +1,31 @@
package com.supervision.nxllmcommon.config;
import io.minio.MinioClient;
import okhttp3.OkHttpClient;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.concurrent.TimeUnit;
@Configuration
public class MinioConfig {
/**
* JavaMinioClient
*/
@Bean
@ConditionalOnProperty(prefix = "minio", name = "url")
public MinioClient minioClient(MinioProperties minioProperties) {
OkHttpClient.Builder builder = new OkHttpClient.Builder();
builder.connectTimeout(60, TimeUnit.SECONDS);
builder.readTimeout(120, TimeUnit.SECONDS);
builder.callTimeout(120, TimeUnit.SECONDS);
return MinioClient.builder().endpoint(minioProperties.getUrl())
.httpClient(builder.build())
.credentials(minioProperties.getAccessKey(), minioProperties.getSecretKey())
.build();
}
}

@ -0,0 +1,19 @@
package com.supervision.nxllmcommon.config;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
@Data
@Component
@ConfigurationProperties(prefix = "minio")
public class MinioProperties {
private String url;
private String accessKey;
private String secretKey;
private String bucketName;
}

@ -0,0 +1,159 @@
package com.supervision.nxllmcommon.config;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONUtil;
import jakarta.servlet.ServletRequest;
import jakarta.servlet.ServletResponse;
import jakarta.servlet.http.HttpServletRequest;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;
import org.springframework.util.ObjectUtils;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import org.springframework.web.multipart.MultipartFile;
import java.util.HashMap;
import java.util.Map;
/**
*
*
* @author :liu
* create :2020-11-16 10:50
**/
@Component
@Aspect
@Slf4j
public class RequestLogConfig {
@SuppressWarnings("all")
@Around("within(com..*..controller..*) && @within(org.springframework.web.bind.annotation.RestController)")
public Object doAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
long start = System.currentTimeMillis();
ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
HttpServletRequest request = attributes.getRequest();
Object result = proceedingJoinPoint.proceed();
RequestInfo requestInfo = new RequestInfo();
requestInfo.setUrl(request.getRequestURL().toString());
requestInfo.setHttpMethod(request.getMethod());
requestInfo.setClassMethod(String.format("%s.%s", proceedingJoinPoint.getSignature().getDeclaringTypeName(),
proceedingJoinPoint.getSignature().getName()));
requestInfo.setRequestParams(getRequestParamsByProceedingJoinPoint(proceedingJoinPoint));
requestInfo.setResult(proceedResult(result));
requestInfo.setTimeCost(System.currentTimeMillis() - start);
log.info("Request Info: {}", JSONUtil.toJsonStr(requestInfo));
return result;
}
private Object proceedResult(Object result) {
String value = null;
try {
value = JSONUtil.toJsonStr(result);
} catch (Exception e) {
value = result.toString();
}
if (StrUtil.isNotBlank(value) && value.length() > 10240){
value = value.substring(0, 1024) + "......" + value.substring(value.length() - 1024);
return value;
}
return result;
}
@SuppressWarnings("all")
@AfterThrowing(pointcut = "@within(org.springframework.web.bind.annotation.RestController)", throwing = "e")
public void doAfterThrow(JoinPoint joinPoint, RuntimeException e) {
ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
HttpServletRequest request = attributes.getRequest();
RequestErrorInfo requestErrorInfo = new RequestErrorInfo();
requestErrorInfo.setUrl(request.getRequestURL().toString());
requestErrorInfo.setHttpMethod(request.getMethod());
requestErrorInfo.setClassMethod(String.format("%s.%s", joinPoint.getSignature().getDeclaringTypeName(),
joinPoint.getSignature().getName()));
requestErrorInfo.setRequestParams(getRequestParamsByJoinPoint(joinPoint));
requestErrorInfo.setException(e);
log.info("Error Request Info : {}", JSONUtil.toJsonStr(requestErrorInfo));
}
/**
*
*
* @param proceedingJoinPoint
* @return
*/
private Map<String, Object> getRequestParamsByProceedingJoinPoint(ProceedingJoinPoint proceedingJoinPoint) {
//参数名
String[] paramNames = ((MethodSignature) proceedingJoinPoint.getSignature()).getParameterNames();
//参数值
Object[] paramValues = proceedingJoinPoint.getArgs();
return buildRequestParam(paramNames, paramValues);
}
private Map<String, Object> getRequestParamsByJoinPoint(JoinPoint joinPoint) {
//参数名
String[] paramNames = ((MethodSignature) joinPoint.getSignature()).getParameterNames();
//参数值
Object[] paramValues = joinPoint.getArgs();
return buildRequestParam(paramNames, paramValues);
}
private Map<String, Object> buildRequestParam(String[] paramNames, Object[] paramValues) {
Map<String, Object> requestParams = new HashMap<>();
if (paramNames == null){
return requestParams;
}
for (int i = 0; i < paramNames.length; i++) {
Object value = paramValues[i];
if (value instanceof ServletRequest || value instanceof ServletResponse) {
//ServletRequest不能序列化从入参里排除否则报异常java.lang.IllegalStateException: It is illegal to call this method if the current request is not in asynchronous mode (i.e. isAsyncStarted() returns false)
//ServletResponse不能序列化 从入参里排除否则报异常java.lang.IllegalStateException: getOutputStream() has already been called for this response
continue;
}
//如果是文件对象
if (value instanceof MultipartFile) {
MultipartFile file = (MultipartFile) value;
//获取文件名
value = file.getOriginalFilename();
} else if (value instanceof String) {
// 如果参数很长,就对参数进行修剪
String temp = (String) value;
if (!ObjectUtils.isEmpty(temp) && temp.length() > 1024) {
value = temp.substring(0, 10) + "......" + temp.substring(temp.length() - 10);
}
}
requestParams.put(paramNames[i], value);
}
return requestParams;
}
@Data
public static class RequestInfo {
private String url;
private String httpMethod;
private String classMethod;
private Object requestParams;
private Object result;
private Long timeCost;
}
@Data
public static class RequestErrorInfo {
private String url;
private String httpMethod;
private String classMethod;
private Object requestParams;
private RuntimeException exception;
}
}

@ -0,0 +1,125 @@
package com.supervision.nxllmcommon.config;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONUtil;
import com.supervision.nxllmcommon.domain.GlobalResult;
import com.supervision.nxllmcommon.exception.BusinessException;
import lombok.extern.slf4j.Slf4j;
import org.springframework.core.MethodParameter;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
import org.springframework.lang.Nullable;
import org.springframework.validation.BindException;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;
import java.util.Objects;
import java.util.stream.Collectors;
/**
*
*
* @author wb
* @date 2022/3/10 13:24
*/
@Slf4j
@RestControllerAdvice(annotations = RestController.class, basePackages = {"com.supervision.**.controller"})
public class ResponseConfig implements ResponseBodyAdvice<Object> {
@Override
public boolean supports(@Nullable MethodParameter methodParameter,
@Nullable Class<? extends HttpMessageConverter<?>> aClass) {
assert methodParameter != null;
String lowerCase = methodParameter.getDeclaringClass().getName().toLowerCase();
log.info(lowerCase);
if (lowerCase.contains("swagger") || lowerCase.contains("springdoc")) {
return false;
} else {
log.info("--------{}---------", lowerCase);
return true;
}
}
@Override
@SuppressWarnings("all")
public Object beforeBodyWrite(Object o, @Nullable MethodParameter methodParameter, @Nullable MediaType mediaType,
@Nullable Class<? extends HttpMessageConverter<?>> aClass, @Nullable ServerHttpRequest serverHttpRequest,
@Nullable ServerHttpResponse serverHttpResponse) {
serverHttpResponse.getHeaders().set("Content-Type", "application/json");
if (Objects.isNull(o)) {
return GlobalResult.ok(null, "success");
}
if (o instanceof GlobalResult) {
return o;
}
// 对于String类型的返回值需要进行特殊处理
if (o instanceof String) {
return JSONUtil.toJsonStr(GlobalResult.ok(o, "success"));
}
return GlobalResult.ok(o, "success");
}
/**
*
*
* @param exception
* @return
*/
@ExceptionHandler(BusinessException.class)
public GlobalResult<?> businessExceptionResponse(BusinessException exception) {
log.error(exception.getMessage(), exception);
Integer code = null == exception.getCode() ? HttpStatus.INTERNAL_SERVER_ERROR.value(): exception.getCode();
String message = StrUtil.isNotEmpty(exception.getMessage()) ? exception.getMessage() : "业务异常";
return GlobalResult.error( code, exception.getMessage(), message);
}
/**
*
*
* @param exception
* @return
*/
@ExceptionHandler({MethodArgumentNotValidException.class, BindException.class})
public GlobalResult<?> validationExceptionResponse(MethodArgumentNotValidException exception) {
log.error(exception.getMessage(), exception);
// 格式化错误信息
String errorMsg = exception.getBindingResult().getFieldErrors().stream()
.map(e -> e.getField() + ":" + e.getDefaultMessage()).collect(Collectors.joining("、"));
return GlobalResult.error(HttpStatus.INTERNAL_SERVER_ERROR.value(), errorMsg, "参数验证异常");
}
/**
*
* @param exception
* @return
*/
@ExceptionHandler(IllegalArgumentException.class)
public GlobalResult<?> manualValidationExceptionResponse(IllegalArgumentException exception) {
log.error(exception.getMessage(), exception);
return GlobalResult.error(HttpStatus.INTERNAL_SERVER_ERROR.value(), exception.getMessage(), "参数验证异常");
}
/**
*
*
* @param exception
* @return
*/
@ExceptionHandler(Exception.class)
public GlobalResult<?> validationExceptionResponse(Exception exception) {
log.error(exception.getMessage(), exception);
return GlobalResult.error(HttpStatus.INTERNAL_SERVER_ERROR.value(), "未知错误", "未知错误");
}
}

@ -0,0 +1,50 @@
package com.supervision.nxllmcommon.config;
import cn.hutool.core.util.RandomUtil;
import io.swagger.v3.oas.models.OpenAPI;
import io.swagger.v3.oas.models.info.Info;
import io.swagger.v3.oas.models.info.License;
import org.springdoc.core.customizers.GlobalOpenApiCustomizer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.HashMap;
import java.util.Map;
@Configuration
public class SwaggerConfiguration {
/**
* @Tag x-order
*
* @return the global open api customizer
*/
@Bean
public GlobalOpenApiCustomizer orderGlobalOpenApiCustomizer() {
return openApi -> {
if (openApi.getTags() != null) {
openApi.getTags().forEach(tag -> {
Map<String, Object> map = new HashMap<>();
map.put("x-order", RandomUtil.randomInt(0, 100));
tag.setExtensions(map);
});
}
if (openApi.getPaths() != null) {
openApi.addExtension("x-test123", "333");
openApi.getPaths().addExtension("x-abb", RandomUtil.randomInt(1, 100));
}
};
}
@Bean
public OpenAPI customOpenAPI() {
return new OpenAPI()
.info(new Info()
.title("XXX用户系统API")
.version("1.0")
.description("Knife4j集成springdoc-openapi示例")
.termsOfService("http://doc.xiaominfo.com")
.license(new License().name("Apache 2.0")
.url("http://doc.xiaominfo.com")));
}
}

@ -0,0 +1,30 @@
/*
* : ThreadCache
* :
* : <>
* : RedName
* : 2023/9/4
* : <>
* : <>
* : <>
*/
package com.supervision.nxllmcommon.config;
/**
* <>
*
* @author ljt
* @version [, 2023/9/4]
* @see [/]
* @since [/]
*/
public class ThreadCache {
/**
* ID
*/
public static final ThreadLocal<String> USER = new ThreadLocal<>();
}

@ -0,0 +1,68 @@
package com.supervision.nxllmcommon.config;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.List;
@Configuration
public class WebConfig implements WebMvcConfigurer {
@Override
public void addInterceptors(InterceptorRegistry registry) {
// 添加权限拦截器
registry.addInterceptor(new JwtInterceptor())
.addPathPatterns("/**")
.excludePathPatterns(ignorePathPatterns());
}
public List<String> ignorePathPatterns() {
List<String> paths = new ArrayList<>();
paths.add("/swagger-resources/**");
paths.add("/webjars/**");
paths.add("/v3/**");
paths.add("/swagger-ui.html/**");
paths.add("/swagger-ui/**");
paths.add("/webjars/");
paths.add("/doc.html/**");
paths.add("/error");
paths.add("/favicon.ico");
paths.add("/user/login");
paths.add("/webSocket/**");
paths.add("/ask/downloadTalkVideo");
paths.add("/fileManage/downloadFile");
paths.add("/aqLibrary/downloadQuestionLibraryTemplate");
paths.add("/medicalRecManage/downloadMedicalAnswerTemplate");
paths.add("/qaKnowledge/**");
// 开发环境,放开不校验token.每次修改这里需要重启(热部署不行)
// paths.add("/**");
return paths;
}
@Bean
public ObjectMapper objectMapper() {
ObjectMapper objectMapper = new ObjectMapper();
objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
JavaTimeModule javaTimeModule = new JavaTimeModule();
javaTimeModule.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
javaTimeModule.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
objectMapper.registerModule(javaTimeModule);
objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
return objectMapper;
}
}

@ -0,0 +1,45 @@
package com.supervision.nxllmcommon.domain;
import lombok.Data;
import org.springframework.http.HttpStatus;
@Data
public class GlobalResult<T> {
private int code = 200;
private String msg = "success";
private T data;
public static <T> GlobalResult<T> ok() {
return ok(null);
}
public static <T> GlobalResult<T> ok(T data) {
GlobalResult<T> globalResult = new GlobalResult<>();
globalResult.setData(data);
return globalResult;
}
public static <T> GlobalResult<T> ok(T data, String message) {
GlobalResult<T> globalResult = new GlobalResult<>();
globalResult.setMsg(message);
globalResult.setData(data);
return globalResult;
}
public static <T> GlobalResult<T> error(String msg) {
return error(HttpStatus.INTERNAL_SERVER_ERROR.value(), null, msg);
}
public static <T> GlobalResult<T> error(int code, T data, String msg) {
GlobalResult<T> globalResult = new GlobalResult<>();
globalResult.setCode(code);
globalResult.setData(data);
globalResult.setMsg(msg);
return globalResult;
}
}

@ -0,0 +1,76 @@
/*
* : CustomException
* :
* : <>
* : RedName
* : 2022/8/5
* : <>
* : <>
* : <>
*/
package com.supervision.nxllmcommon.exception;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpStatus;
/**
* <>
*
*
* @author ljt
* @version [, 2022/8/5]
* @see [/]
* @since [/]
*/
@Slf4j
public class BusinessException extends RuntimeException {
/**
*
*/
private final Integer code;
/**
*
*/
private final String message;
public BusinessException(Throwable cause) {
super(cause);
this.code = HttpStatus.INTERNAL_SERVER_ERROR.value();
this.message = null;
}
public BusinessException(Throwable cause, String message) {
super(cause);
this.code = HttpStatus.INTERNAL_SERVER_ERROR.value();
this.message = message;
}
public BusinessException(String message) {
this.code = HttpStatus.INTERNAL_SERVER_ERROR.value();
this.message = message;
}
public BusinessException(String message, Integer code) {
this.message = message;
this.code = code;
}
public BusinessException(String message, Throwable e) {
super(message, e);
log.error(message, e);
this.code = HttpStatus.INTERNAL_SERVER_ERROR.value();
this.message = message;
}
@Override
public String getMessage() {
return message;
}
public Integer getCode() {
return code;
}
}

@ -0,0 +1,106 @@
package com.supervision.nxllmcommon.util;
import cn.hutool.core.thread.ThreadUtil;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.ai.chat.ChatResponse;
import org.springframework.ai.chat.messages.Message;
import org.springframework.ai.chat.messages.UserMessage;
import org.springframework.ai.chat.prompt.Prompt;
import org.springframework.ai.ollama.OllamaChatClient;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.*;
@Slf4j
public class AiChatUtil {
private static final ExecutorService chatExecutor = ThreadUtil.newFixedExecutor(5, 5, "chat", new ThreadPoolExecutor.CallerRunsPolicy());
private static final OllamaChatClient chatClient = SpringBeanUtil.getBean(OllamaChatClient.class);
/**
*
*
* @param chat
* @return jsonObject
*/
public static Optional<JSONObject> chat(String chat) {
Prompt prompt = new Prompt(List.of(new UserMessage(chat)));
Future<String> submit = chatExecutor.submit(new ChatTask(chatClient, prompt));
try {
return Optional.of(JSONUtil.parseObj(submit.get()));
} catch (ExecutionException | InterruptedException e) {
log.error("调用大模型生成失败");
}
return Optional.empty();
}
/**
* ,
*
* @param messageList
* @return jsonObject
*/
public static Optional<JSONObject> chat(List<Message> messageList) {
Prompt prompt = new Prompt(messageList);
Future<String> submit = chatExecutor.submit(new ChatTask(chatClient, prompt));
try {
return Optional.of(JSONUtil.parseObj(submit.get()));
} catch (ExecutionException | InterruptedException e) {
log.error("调用大模型生成失败");
}
return Optional.empty();
}
/**
*
*
* @param messageList
* @param clazz
* @param <T>
* @return ,
*/
public static <T> Optional<T> chat(List<Message> messageList, Class<T> clazz) {
Prompt prompt = new Prompt(messageList);
Future<String> submit = chatExecutor.submit(new ChatTask(chatClient, prompt));
try {
String s = submit.get();
return Optional.ofNullable(JSONUtil.toBean(s, clazz));
} catch (ExecutionException | InterruptedException e) {
log.error("调用大模型生成失败", e);
}
return Optional.empty();
}
/**
*
*
* @param chat
* @param clazz
* @param <T>
* @return ,
*/
public static <T> Optional<T> chat(String chat, Class<T> clazz) {
Prompt prompt = new Prompt(List.of(new UserMessage(chat)));
Future<String> submit = chatExecutor.submit(new ChatTask(chatClient, prompt));
try {
String s = submit.get();
return Optional.ofNullable(JSONUtil.toBean(s, clazz));
} catch (ExecutionException | InterruptedException e) {
log.error("调用大模型生成失败");
}
return Optional.empty();
}
private record ChatTask(OllamaChatClient chatClient, Prompt prompt) implements Callable<String> {
@Override
public String call() {
ChatResponse call = chatClient.call(prompt);
return call.getResult().getOutput().getContent();
}
}
}

@ -0,0 +1,94 @@
package com.supervision.nxllmcommon.util;
import io.minio.*;
import io.minio.http.Method;
import lombok.extern.slf4j.Slf4j;
import java.io.InputStream;
import java.util.UUID;
@Slf4j
public class MinioUtil {
private static final MinioClient minioClient = SpringBeanUtil.getBean(MinioClient.class);
private static final String bucketName = SpringBeanUtil.getBean(MinioProperties.class).getBucketName();
static {
try {
if (!minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build())) {
log.info("未找到bucket,自动建立");
minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
}
} catch (Exception e) {
e.printStackTrace();
}
}
/**
*
*/
public static String uploadFile(InputStream stream) throws Exception {
ObjectWriteResponse objectWriteResponse = minioClient.putObject(PutObjectArgs.builder().bucket(bucketName).object(UUID.randomUUID().toString())
.stream(stream, stream.available(), -1).build());
return objectWriteResponse.object();
}
/**
*
* @param stream
* @param contentType
* @return id
* @throws Exception
*/
public static String uploadFile(InputStream stream,String contentType) throws Exception {
ObjectWriteResponse objectWriteResponse = minioClient.putObject(PutObjectArgs.builder().bucket(bucketName).object(UUID.randomUUID().toString())
.stream(stream, stream.available(), -1).contentType(contentType).build());
return objectWriteResponse.object();
}
/**
*
*/
public static InputStream download(String fileId) throws Exception {
return minioClient.getObject(GetObjectArgs.builder().bucket(bucketName).object(fileId).build());
}
/**
*
*/
public static void deleteObject(String fileId) throws Exception {
minioClient.removeObject(RemoveObjectArgs.builder().bucket(bucketName).object(fileId).build());
}
/**
*
*
* @Param: [bucket, objectName]
* @return: java.lang.String
* @Author: MrFugui
* @Date: 2021/11/15
*/
public static String getObjectInfo(String fileId) throws Exception {
return minioClient.statObject(StatObjectArgs.builder().bucket(bucketName).object(fileId).build()).toString();
}
/**
* HTTP GETpresigned URL/URL使
*
* @Param: [bucketName, objectName, expires]
* @return: java.lang.String
* @Author: MrFugui
* @Date: 2021/11/15
*/
public static String getPresignedObjectUrl(String bucketName, String objectName, Integer expires) throws Exception {
GetPresignedObjectUrlArgs build = GetPresignedObjectUrlArgs
.builder().bucket(bucketName).object(objectName).expiry(expires).method(Method.GET).build();
return minioClient.getPresignedObjectUrl(build);
}
}

@ -0,0 +1,129 @@
package com.supervision.nxllmcommon.util;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.date.DateUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.ApplicationContext;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import java.util.Date;
import java.util.Map;
import java.util.Objects;
import java.util.function.Supplier;
@Slf4j
public class RedisSequenceUtil {
/**
* redisTemplate:使redisTemplategetRedisTemplate()
*/
private volatile static RedisTemplate<String, String> redisTemplate = null;
/**
*
* @return a000001-a999999 b000001-b999999 ...
*/
public static String getProcessNo(){
// 从零开始计算
long processNoSeq = getIncrement("process_no_seq") -1;
char prefix = (char) ('a' + processNoSeq / 1000000);
Long suffix = processNoSeq % 1000000;
return prefix + String.format("%06d", suffix);
}
/**
* YYYMMDD+320240104001
* @return
*/
public static String getComplexDiseaseNo(){
String nowDay = DateUtil.format(new Date(), "YYMMdd");
return "mp"+nowDay + String.format("%03d", getIncrement("complex_disease_no_seq_"+nowDay));
}
/**
* Q0000001
* @param supplier
* @return Q0000001
*/
public static String getQuestionLibraryCode(Supplier<Long> supplier){
RedisTemplate<String,String> redisTemplate = getRedisTemplate();
if (Objects.nonNull(supplier) &&
Boolean.FALSE.equals(redisTemplate.hasKey("question_library_code_seq"))){
Long code = supplier.get();
if (Objects.nonNull(code)){
redisTemplate.opsForValue().set("question_library_code_seq",code.toString());
}
}
Long increment = getIncrement("question_library_code_seq");
return "Q" + String.format("%07d", increment);
}
/**
* A0000029
* @param supplier
* @return A0000029
*/
public static String getQuestionLibraryDefaultAnswerCode(Supplier<Long> supplier){
RedisTemplate<String,String> redisTemplate = getRedisTemplate();
if (Objects.nonNull(supplier) &&
Boolean.FALSE.equals(redisTemplate.hasKey("question_library_default_answer_code_seq"))){
Long code = supplier.get();
if (Objects.nonNull(code)){
redisTemplate.opsForValue().set("question_library_default_answer_code_seq",code.toString());
}
}
Long increment = getIncrement("question_library_default_answer_code_seq");
return "A" + String.format("%07d", increment);
}
/**
* 1
* @param key redis key
* @return
*/
public static Long getIncrement(String key){
ValueOperations<String, String> operations = getRedisTemplate().opsForValue();
return operations.increment( key,1L);
}
/**
* redisTemplate
* @return redisTemplate
*/
public static RedisTemplate getRedisTemplate() {
if (redisTemplate == null) {
synchronized (RedisSequenceUtil.class){
if (null == redisTemplate){
redisTemplate = getRedisTemplateInContext();
}
}
}
return redisTemplate;
}
private static RedisTemplate<String, String> getRedisTemplateInContext() {
ApplicationContext applicationContext = SpringBeanUtil.getApplicationContext();
if (null == applicationContext){
return null;
}
// 优先选择stringRedisTemplate
if (applicationContext.containsBean("stringRedisTemplate")){
return applicationContext.getBean("stringRedisTemplate",StringRedisTemplate.class);
}
Map<String, RedisTemplate> redisTemplateMap = applicationContext.getBeansOfType(RedisTemplate.class);
if (CollUtil.isNotEmpty(redisTemplateMap)){
return CollUtil.getFirst(redisTemplateMap.values());
}
return null;
}
}

@ -0,0 +1,127 @@
package com.supervision.nxllmcommon.util;
import cn.hutool.core.util.ArrayUtil;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;
import java.util.Map;
/***
* @author ljt
* @since 2020/8/4 17:37
*
*/
@Component
@Lazy(false)
public class SpringBeanUtil implements ApplicationContextAware {
private static ApplicationContext applicationContext;
/**
* applicationContext
*
* @return ApplicationContext
*/
public static ApplicationContext getApplicationContext() {
return applicationContext;
}
@Override
public void setApplicationContext(ApplicationContext applicationContext) {
SpringBeanUtil.applicationContext = applicationContext;
}
//通过name获取 Bean.
/**
* name Bean
*
* @param <T> Bean
* @param name Bean
* @return Bean
*/
@SuppressWarnings("unchecked")
public static <T> T getBean(String name) {
return (T) applicationContext.getBean(name);
}
/**
* classBean
*
* @param <T> Bean
* @param clazz Bean
* @return Bean
*/
public static <T> T getBean(Class<T> clazz) {
return applicationContext.getBean(clazz);
}
/**
* name,ClazzBean
*
* @param <T> bean
* @param name Bean
* @param clazz bean
* @return Bean
*/
public static <T> T getBean(String name, Class<T> clazz) {
return applicationContext.getBean(name, clazz);
}
/**
* Bean
*
* @param <T> Bean
* @param type nullbean
* @return beankeybeannamevalueBean
* @since 5.3.3
*/
public static <T> Map<String, T> getBeansOfType(Class<T> type) {
return applicationContext.getBeansOfType(type);
}
/**
* Bean
*
* @param type nullbean
* @return bean
* @since 5.3.3
*/
public static String[] getBeanNamesForType(Class<?> type) {
return applicationContext.getBeanNamesForType(type);
}
/**
*
*
* @param key key
* @return
* @since 5.3.3
*/
public static String getProperty(String key) {
return applicationContext.getEnvironment().getProperty(key);
}
/**
* null
*
* @return
* @since 5.3.3
*/
public static String[] getActiveProfiles() {
return applicationContext.getEnvironment().getActiveProfiles();
}
/**
*
*
* @return
* @since 5.3.3
*/
public static String getActiveProfile() {
final String[] activeProfiles = getActiveProfiles();
return ArrayUtil.isNotEmpty(activeProfiles) ? activeProfiles[0] : null;
}
}

@ -0,0 +1,19 @@
package com.supervision.nxllmcommon.util;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import cn.hutool.jwt.JWTUtil;
import cn.hutool.jwt.signers.JWTSigner;
import cn.hutool.jwt.signers.JWTSignerUtil;
public class TokenUtil {
public static String creatToken(String userInfo){
final JWTSigner signer = JWTSignerUtil.hs256("123456".getBytes());
JSONObject info = JSONUtil.parseObj(userInfo);
// 过期时间一天,同时这个字段也作为单点登录使用
info.putOnce("expireTime",System.currentTimeMillis() + 1000 * 60 * 60 * 24);
info.putOnce("issueTime",System.currentTimeMillis());
return JWTUtil.createToken(info, signer);
}
}
Loading…
Cancel
Save