工具类个人整理
1、JsonUtils
package com.qbb.springdataredis.utils;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.extern.slf4j.Slf4j;
import java.util.List;
/**
* @author QiuQiu&LL (个人博客:https://www.cnblogs.com/qbbit)
* @version 1.0
* @date 2022-07-17 12:52
* @Description:
*/
@Slf4j
public class JsonUtils {
// 定义jackson对象
private static final ObjectMapper MAPPER = new ObjectMapper();
/**
* 将对象转换成json字符串。
*
* @param data
* @return
*/
public static String objectToJson(Object data) {
try {
String string = MAPPER.writeValueAsString(data);
return string;
} catch (JsonProcessingException e) {
e.printStackTrace();
}
return null;
}
/**
* 将json结果集转化为对象
*
* @param jsonData json数据
* @param beanType 对象中的object类型
* @return
*/
public static <T> T jsonToPojo(String jsonData, Class<T> beanType) {
try {
T t = MAPPER.readValue(jsonData, beanType);
return t;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/**
* 将json数据转换成pojo对象list
*
* @param jsonData
* @param beanType
* @return
*/
public static <T> List<T> jsonToList(String jsonData, Class<T> beanType) {
JavaType javaType = MAPPER.getTypeFactory().constructParametricType(List.class, beanType);
try {
List<T> list = MAPPER.readValue(jsonData, javaType);
return list;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/**
* 把对象转为Json字符串
*
* @param obj
* @return
*/
public static String toStr(Object obj) {
try {
return MAPPER.writeValueAsString(obj);
} catch (JsonProcessingException e) {
log.error("对象转换JSON的String异常:{}", obj);
}
return null;
}
/**
* Json字符串转为传入类型的对象
*
* @param json
* @param typeReference
* @param <T>
* @return
*/
public static <T> T strToObj(String json, TypeReference<T> typeReference) {
T t = null;
try {
t = MAPPER.readValue(json, typeReference);
} catch (JsonProcessingException e) {
e.printStackTrace();
}
return t;
}
/**
* 初始化一个空实例
* 对象:{}
* 数组:[]
*
* @param typeReference
* @param <T>
* @return
*/
public static <T extends Object> T nullInstance(TypeReference<T> typeReference) {
String json = "[]"; //Person
T t = null;
try {
t = MAPPER.readValue(json, typeReference);
//泛型套泛型 List<Map<String,Hello>>
//aaa
} catch (JsonProcessingException e) {
log.error("准备空示例异常：{}", e);
try {
t = MAPPER.readValue("{}", typeReference);
} catch (JsonProcessingException ex) {
log.error("你这不是json");
}
}
return t;
}
}
2、DateUtils
import org.apache.commons.lang.time.DateUtils;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
/**
* @author QiuQiu&LL (个人博客:https://www.cnblogs.com/qbbit)
* @version 1.0
* @date 2022-07-17 12:52
* @Description:日期操作工具类
*/
public class DateUtil {
private static final String dateFormat = "yyyy-MM-dd";
/**
* 获取两个时间差 单位：秒
*
* @param date1
* @param date2
* @return
*/
public Long getTimeSubtract(Date date1, Date date2) {
return (date1.getTime() - date2.getTime()) / 1000;
}
/**
* 格式化日期
*
* @param date
* @return
*/
public static String formatDate(Date date) {
SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);
return sdf.format(date);
}
/**
* 按照指定格式,格式化日期
*
* @param date
* @return
*/
public static String formatDate(Date date, String pattern) {
SimpleDateFormat sdf = new SimpleDateFormat(pattern);
return sdf.format(date);
}
/**
* 截取比较断两个日期对象的field处的值 。
* 如果第一个日期小于、等于、大于第二个，则对应返回负整数、0、正整数
*
* @param date1 第一个日期对象，非null
* @param date2 第二个日期对象，非null
* @param field Calendar中的阈值
* <p>
* date1 > date2 返回：1
* date1 = date2 返回：0
* date1 < date2 返回：-1
*/
public static int truncatedCompareTo(final Date date1, final Date date2, final int field) {
return DateUtils.truncatedCompareTo(date1, date2, field);
}
/**
* 比对时间大小
*
* @param beginDate
* @param endDate
* @return
*/
public static boolean dateCompare(Date beginDate, Date endDate) {
// endDate > beginDate
if (DateUtil.truncatedCompareTo(beginDate, endDate, Calendar.SECOND) == 1) {
return false;
}
// beginDate <= endDate
return true;
}
/**
* 获取指定天的开始时间
* @return
*/
public static Date getStartTimeOfCurrentDay(Date date){
Calendar calendar = Calendar.getInstance();
calendar.clear();
calendar.setTime(date);
setMinTimeOfDay(calendar);
return calendar.getTime();
}
/**
* 获取指定天的结束时间
* @return
*/
public static Date getEndTimeOfCurrentDay(Date date){
Calendar calendar = Calendar.getInstance();
calendar.clear();
calendar.setTime(date);
setMaxTimeOfDay(calendar);
return calendar.getTime();
}
/**
* 获取指定周的开始时间
* @return
*/
public static Date getStartTimeOfCurrentWeek(Date date){
Calendar calendar = Calendar.getInstance();
calendar.clear();
calendar.setTime(date);
calendar.setFirstDayOfWeek(Calendar.MONDAY);
calendar.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
setMinTimeOfDay(calendar);
return calendar.getTime();
}
/**
* 获取指定月的结束时间
* @return
*/
public static Date getEndTimeOfCurrentWeek(Date date){
Calendar calendar = Calendar.getInstance();
calendar.clear();
calendar.setTime(date);
calendar.setFirstDayOfWeek(Calendar.MONDAY);
calendar.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY);
setMaxTimeOfDay(calendar);
return calendar.getTime();
}
/**
* 获取指定月的开始时间
* @return
*/
public static Date getStartTimeOfCurrentMonth(Date date){
Calendar calendar = Calendar.getInstance();
calendar.clear();
calendar.setTime(date);
calendar.set(calendar.get(Calendar.YEAR),calendar.get(Calendar.MONTH),1);
setMinTimeOfDay(calendar);
return calendar.getTime();
}
/**
* 获取指定月的结束时间
* @return
*/
public static Date getEndTimeOfCurrentMonth(Date date){
Calendar calendar = Calendar.getInstance();
calendar.clear();
calendar.setTime(date);
int maxMonthDay = calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
calendar.set(calendar.get(Calendar.YEAR),calendar.get(Calendar.MONTH),maxMonthDay);
setMaxTimeOfDay(calendar);
return calendar.getTime();
}
/**
* 获取指定年的开始时间 注意月份要减1
* @return
*/
public static Date getStartTimeOfCurrentYear(Date date){
Calendar calendar = Calendar.getInstance();
calendar.clear();
calendar.setTime(date);
calendar.set(calendar.get(Calendar.YEAR),0,1);
setMinTimeOfDay(calendar);
return calendar.getTime();
}
/**
* 获取指定年的结束时间 注意月份要减1
* @return
*/
public static Date getEndTimeOfCurrentYear(Date date){
Calendar calendar = Calendar.getInstance();
calendar.clear();
calendar.setTime(date);
calendar.set(calendar.get(Calendar.YEAR),11,31);
setMaxTimeOfDay(calendar);
return calendar.getTime();
}
/**
* 设置当天的开始时间
* @param calendar
*/
private static void setMinTimeOfDay(Calendar calendar) {
calendar.set(Calendar.HOUR_OF_DAY, 0);
calendar.set(Calendar.SECOND, 0);
calendar.set(Calendar.MINUTE, 0);
calendar.set(Calendar.MILLISECOND, 0);
}
/**
* 设置当天的结束时间
* @param calendar
*/
private static void setMaxTimeOfDay(Calendar calendar) {
calendar.set(Calendar.HOUR_OF_DAY, 23);
calendar.set(Calendar.SECOND, 59);
calendar.set(Calendar.MINUTE, 59);
calendar.set(Calendar.MILLISECOND, 999);
}
}
3、MinioUtil
package com.qbb.minio.util;
import com.qbb.minio.config.MinioConfig;
import io.minio.*;
import io.minio.http.Method;
import io.minio.messages.Bucket;
import io.minio.messages.DeleteObject;
import io.minio.messages.Item;
import lombok.extern.slf4j.Slf4j;
import org.junit.platform.commons.util.StringUtils;
import org.springframework.stereotype.Component;
import org.springframework.util.FastByteArrayOutputStream;
import org.springframework.web.multipart.MultipartFile;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.UUID;
/**
* @author QIUQIU&LL (个人博客:https://www.cnblogs.com/qbbit)
* @version 1.0
* @date 2022-09-19 16:44
* @Description:
*/
@Component
@Slf4j
public class MinioUtil {
private final MinioConfig minioConfig;
private final MinioClient minioClient;
public MinioUtil(MinioConfig minioConfig, MinioClient minioClient) {
this.minioConfig = minioConfig;
this.minioClient = minioClient;
}
/**
* 查看存储bucket是否存在
*
* @return boolean
*/
public Boolean bucketExists(String bucketName) {
boolean found;
try {
found = minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
} catch (Exception e) {
e.printStackTrace();
return false;
}
return found;
}
/**
* 创建存储bucket
*/
public void makeBucket(String bucketName) {
try {
minioClient.makeBucket(MakeBucketArgs.builder()
.bucket(bucketName)
.build());
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 删除存储bucket
*
* @return Boolean
*/
public Boolean removeBucket(String bucketName) {
try {
minioClient.removeBucket(RemoveBucketArgs.builder()
.bucket(bucketName)
.build());
} catch (Exception e) {
e.printStackTrace();
return false;
}
return true;
}
/**
* 获取全部bucket
*/
public List<Bucket> getAllBuckets() {
try {
return minioClient.listBuckets();
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/**
* 文件上传
*
* @param file 上传的文件
* @return
*/
public String upload(MultipartFile file) {
String originalFilename = file.getOriginalFilename();
if (StringUtils.isBlank(originalFilename)) {
throw new RuntimeException();
}
String fileName = UUID.randomUUID().toString().replace("-", "") + "_" + originalFilename;
// 日期目录
// SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd");
// String datePath = dateFormat.format(new Date());// 日期目录：2021/10/27
// 也可以使用JDK1.8的新时间类LocalDate/LocalDateTime
LocalDate now = LocalDate.now();
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy/MM/dd");
String formatDatePath = formatter.format(now);
// 加一个时间戳
long timeMillis = System.currentTimeMillis();
String objectName = formatDatePath + "/" + timeMillis + fileName;
try {
PutObjectArgs objectArgs = PutObjectArgs.builder()
.bucket(minioConfig.getBucket())
.object(objectName)
.stream(file.getInputStream(), file.getSize(), -1)
.contentType(file.getContentType())
.build();
minioClient.putObject(objectArgs);
} catch (Exception e) {
e.printStackTrace();
return null;
}
return objectName;
}
/**
* 预览图片
*
* @param fileName 文件名称
* @return 图片地址
*/
public String preview(String fileName) {
// 查看文件地址
GetPresignedObjectUrlArgs build = GetPresignedObjectUrlArgs.builder()
.bucket(minioConfig.getBucket())
.object(fileName)
.method(Method.GET)
.build();
try {
return minioClient.getPresignedObjectUrl(build);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/**
* 文件下载
*
* @param fileName 文件名称
* @param res response
*/
public void download(String fileName, HttpServletResponse res) {
GetObjectArgs objectArgs = GetObjectArgs.builder().bucket(minioConfig.getBucket())
.object(fileName).build();
try (GetObjectResponse response = minioClient.getObject(objectArgs)) {
byte[] buf = new byte[1024];
int len;
try (FastByteArrayOutputStream os = new FastByteArrayOutputStream()) {
while ((len = response.read(buf)) != -1) {
os.write(buf, 0, len);
}
os.flush();
byte[] bytes = os.toByteArray();
res.setCharacterEncoding("utf-8");
// 设置强制下载不打开
// res.setContentType("application/force-download");
res.addHeader("Content-Disposition", "attachment;fileName=" + fileName);
try (ServletOutputStream stream = res.getOutputStream()) {
stream.write(bytes);
stream.flush();
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 查看文件对象
*
* @return 存储bucket内文件对象信息
*/
public List<Item> listObjects(String bucketName) {
if (StringUtils.isBlank(bucketName) || !bucketExists(bucketName)) {
return null;
}
Iterable<Result<Item>> results = minioClient.listObjects(
ListObjectsArgs.builder().bucket(bucketName).build());
List<Item> items = new ArrayList<>();
try {
for (Result<Item> result : results) {
items.add(result.get());
}
} catch (Exception e) {
e.printStackTrace();
return null;
}
return items;
}
/**
* 获取单个桶中的所有文件对象名称
*
* @param bucket 桶名称
* @return {@link List}<{@link String}>
*/
public List<String> getBucketObjectName(String bucket) {
boolean exsit = bucketExists(bucket);
if (exsit) {
List<String> listObjetcName = new ArrayList<>();
try {
Iterable<Result<Item>> myObjects = minioClient.listObjects(ListObjectsArgs.builder().bucket(bucket).build());
for (Result<Item> result : myObjects) {
Item item = result.get();
listObjetcName.add(item.objectName());
}
return listObjetcName;
} catch (Exception e) {
e.printStackTrace();
}
}
return null;
}
/**
* 删除
*
* @param fileName 文件名称
* @return true|false
*/
public boolean remove(String fileName) {
try {
minioClient.removeObject(RemoveObjectArgs.builder().bucket(minioConfig.getBucket()).object(fileName).build());
} catch (Exception e) {
return false;
}
return true;
}
/**
* 批量删除文件
*
* @param bucket 桶名称
* @param objectNames 对象名称
* @return boolean
*/
public boolean removeObjects(String bucket, List<String> objectNames) {
boolean exsit = bucketExists(bucket);
if (exsit) {
try {
List<DeleteObject> objects = new LinkedList<>();
for (String str : objectNames) {
objects.add(new DeleteObject(str));
}
minioClient.removeObjects(RemoveObjectsArgs.builder().bucket(bucket).objects(objects).build());
return true;
} catch (Exception e) {
log.error("removeObjects", e);
}
}
return false;
}
}
4、列表转树
/**
* stream流列表转树
*
* @param parentId
* @param dataList
* @return
*/
public static List<RightsEntity> streamTree(Integer parentId, List<RightsEntity> dataList) {
return Optional.ofNullable(dataList).orElse(Lists.newArrayList())
.stream()
.filter(root -> Objects.equals(root.getParentId(), parentId))
.peek(tree -> {
List<RightsEntity> children = streamTree(tree.getId(), dataList);
tree.setChildren(children);
}).collect(Collectors.toList());
}
/**
* for循环列表转树
*
* @param rightsEntities
* @return
*/
private static List<RightsEntity> forTree(List<RightsEntity> rightsEntities) {
List<RightsEntity> rootTree = new ArrayList<>();
for (RightsEntity tree : rightsEntities) {
if (tree.getParentId() == 0) {
rootTree.add(tree);
}
for (RightsEntity node : rightsEntities) {
if (Objects.equals(tree.getId(), node.getParentId())) {
if (CollectionUtil.isEmpty(tree.getChildren())) {
tree.setChildren(Lists.newArrayList());
}
tree.getChildren().add(node);
}
}
}
return rootTree;
}
浙公网安备 33010602011771号