标签: 工具类

源码

package cn.doblue.assetsana.utils.data;

import java.security.SecureRandom;

/**
 * 随机工具类
 */
public class RandomUtil {
    public static String ALPHANUMERIC = "QWERTYUIOPASDFGHJKLZXCVBNM1234567890qwertyuiopasdfghjklzxcvbnm";
    private final static SecureRandom random = new SecureRandom();

    /**
     * 生成随机字母数字
     * @param length 长度
     * @return 随机字母字符串
     */
    public static String randomAlphanumeric(int length){
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < length; i++) {
            sb.append(ALPHANUMERIC.charAt(random.nextInt(ALPHANUMERIC.length())));
        }
        return sb.toString();
    }

    /**
     * 随机 0 - size 的整数
     */
    public static Integer randomInt(int size) {
        return random.nextInt(size);
    }
}

NEPENE小于 1 分钟

Java 树形工具类

Tree 接口

children（子集）的 get、set 方法

import java.util.List;

public interface Tree<T> {

    List<T> getChildren();

    void setChildren(List<T> children);
}

NEPENE大约 1 分钟

Java MinIO工具类

工具类

@Slf4j
public class MinioService {
    private final MinioConfig config;
    private MinioClient client;
    private final SimpleDateFormat format = new SimpleDateFormat("yyyyMMdd");
    public MinioService(com.doblue.smlt.config.MinioConfig config) {
        this.config = config;
        try{
            client = MinioClient.builder()
                    .endpoint(config.getHost())
                    .credentials(config.getAccessKey(), config.getSecretKey())
                    .build();
        }catch (Exception ex){
            log.error("Minio 初始化失败！Trace：");
            ex.printStackTrace();
        }
    }

    /**
     * 文件上传
     * @param file 文件
     * @param path minio 远程路径
     * @return 公网访问 url
     */
    public String upload(MultipartFile file, String path){
        try{
            return upload(file, path, file.getContentType());
        }catch (Exception ex){
            log.error("文件上传失败！Trace：");
            ex.printStackTrace();
            throw new UnknownException(ex.getMessage());
        }
    }

    /**
     * 文件上传
     * @param file 文件
     * @param path minio 远程路径
     * @param contentType 文件类型
     * @return 公网访问 url
     */
    public String upload(MultipartFile file, String path, String contentType)
            throws Exception {
        String filename = genPath(path, getExtension(file));
        PutObjectArgs args = PutObjectArgs.builder()
                .contentType(contentType)
                .object(filename)
                .bucket(config.getBucket())
                .stream(file.getInputStream(), file.getSize(), ObjectWriteArgs.MIN_MULTIPART_SIZE)
                .build();
        client.putObject(args);
        return minioPublicURL(filename);
    }

    /**
     * 根据完整 URL 来移除 minio 服务器中的对象
     * @param url 例：http://127.0.0.1:9000/furniture/materials/20230315/7375e567-d771-46a7-bccf-bb48886ab3d2.png
     */
    public void removeObjectByURL(String url){
        removeObject(extractObjectName(url));
    }

    /**
     * 根据对象名移除 minio 服务器中的对象
     * @param name 例：materials/20230315/7375e567-d771-46a7-bccf-bb48886ab3d2.png
     */
    public void removeObject(String name){
        try{
            RemoveObjectArgs args = RemoveObjectArgs.builder()
                    .bucket(config.getBucket())
                    .object(name)
                    .build();
            client.removeObject(args);
        }catch (Exception e){
            log.error("MinIO 文件删除错误：{}", e.getMessage());
            e.printStackTrace();
            throw new UnknownException(e.getMessage());
        }
    }

    /**
     * 获取对象文件公网访问 url
     * @param filename 对象名称
     * @return 公网访问 url
     */
    private String minioPublicURL(String filename) {
        return config.getHost() + '/' + config.getBucket() + "/" + filename;
    }

    /**
     * 生成对象路径
     * @param basicPath 根路径
     * @param extension 文件扩展名
     * @return basicPath/yyyyMMdd/uuid.extension
     */
    public String genPath(String basicPath, String extension){
        return basicPath + "/" + format.format(new Date()) + "/" + UUID.randomUUID() + extension;
    }

    /**
     * 获取文件的扩展名
     * @param file 文件
     * @return 例：.jpg
     */
    public String getExtension(MultipartFile file){
        return getExtension(file.getOriginalFilename());
    }
    /**
     * 获取文件的扩展名
     * @param name 文件名称
     * @return 例：.jpg
     */
    public String getExtension(String name){
        return name.substring(name.lastIndexOf('.'));
    }

    /**
     * 递归移除目录下所有文件
     * @param folder 目录
     */
    public void removeFolder(String folder){
        try{
            if (!folder.endsWith("/")){
                folder+="/";
            }
            Iterable<Result<Item>> results = client.listObjects(
                    ListObjectsArgs.builder()
                            .bucket(config.getBucket())
                            .prefix(folder)
                            .build());
            for (Result<Item> r : results) {
                Item item = r.get();
                if (item.isDir()){
                    removeFolder(item.objectName());
                }else {
                    removeObject(item.objectName());
                }
            }
        }catch (Exception ex){
            log.error("文件上传失败：");
            ex.printStackTrace();
            throw new UnknownException(ex.getMessage());
        }
    }

    /**
     * 下载文件，用于受保护的 minio 服务器
     * 此方法未测试
     */
    public GetObjectResponse download(String object){
        GetObjectArgs args = GetObjectArgs.builder()
                .bucket(config.getBucket())
                .object(object)
                .build();
        try{
            return client.getObject(args);
        }catch (Exception ex){
            log.error("MinIO 文件下载错误：");
            ex.printStackTrace();
            throw new UnknownException(ex.getMessage());
        }
    }

    /**
     * 根据url下载文件
     * 此方法未测试
     */
    public GetObjectResponse downloadByUrl(String url){
        return download(extractObjectName(url));
    }

    /**
     * 提取 url 中的 minio 对象路径
     * @param url 例：http://127.0.0.1:9000/furniture/materials/20230315/7375e567-d771-46a7-bccf-bb48886ab3d2.png
     * @return 例：/materials/20230315/7375e567-d771-46a7-bccf-bb48886ab3d2.png
     */
    public String extractObjectName(String url) {
        return url.substring(minioPublicURL("").length());
    }

    /**
     * 将一个对象拷贝到指定路径
     * @param objectName minio 中需要拷贝的对象
     * @param path minio 要拷贝到的路径
     * @return 拷贝后路径的公网访问 url
     */
    public String copy(String objectName, String path){
        String extension = getExtension(objectName);
        String targetObject = genPath(path, extension);
        CopyObjectArgs args = CopyObjectArgs.builder()
                .bucket(config.getBucket())
                .object(targetObject)
                .source(CopySource.builder()
                        .bucket(config.getBucket())
                        .object(objectName)
                        .build())
                .build();
        try{
            client.copyObject(args);
        }catch (Exception e){
            log.error("minIO 文件拷贝失败：");
            e.printStackTrace();
            throw new UnknownException(e.getMessage());
        }
        return minioPublicURL(targetObject);
    }

    /**
     * 通过 url 拷贝
     * @see MinioService#copy(String, String)
     */
    public String copyByUrl(String url, String path){
        return copy(extractObjectName(url), path);
    }
}

NEPENE大约 3 分钟

Json 响应对象

封装响应对象，携带额外信息

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class R<T> implements Serializable {
    static final long serialVersionUID = 422344123L;
    /**
     * 操作是否成功
     */
    private boolean success = false;
    /**
     * 响应码
     */
    private int code = -1;
    /**
     * 消息
     */
    private String message;
    /**
     * 数据体
     */
    private T data;
    public static <T> R<T> success(T data){
        return new R<>(true, 200, "操作成功", data);
    }
    public static <T> R<T> success(String message, T data){
        return new R<>(true, 200, message, data);
    }
    @Deprecated
    public static R<Object> failure(int code, String message){
        return new R<>(false, code, message, null);
    }
    public static R<Object> failure(Code code){
        return new R<>(false, code.code, code.message, null);
    }
    public static R<Object> failure(Code code, String message){
        return new R<>(false, code.code, String.format("%s: %s", code.message, message), null);
    }
    public static <T> R<T> failure(Code code, String message, T data){
        return new R<>(false, code.code, String.format("%s: %s", code.message, message), data);
    }
    public enum Code{
        //操作成功请使用success
        //OK(200, "成功"),
        HEADER_REQUIRED(10000, "请提供请求头"),
        DATA_NOT_EXISTS(10001, "数据不存在"),
        DATA_ALREADY_EXISTS(10002, "数据重复"),
        DATA_HAS_BEEN_REFERENCE(10003, "引用约束"),
        INVALID_PARAMS(20001, "无效参数"),
        ILLEGAL_PARAMS(20002, "非法参数"),
        ILLEGAL_STATE(20003, "非法状态"),
        TOKEN_REQUIRED(40001, "未提供Token"),
        HAS_NO_PERMISSION(40003, "无权访问"),
        FLOW_LIMITED(40010, "接口限流"),
        INVALID_TOKEN(44001, "Token无效或已过期"),
        SYSTEM_ERROR(50000, "系统错误"),
        UNKNOWN_ERROR(-1, "异常");
        final int code;
        final String message;
        Code(int code, String message){
            this.code = code;
            this.message = message;
        }
    }
}

NEPENE大约 1 分钟

Java Map工具类

Java Map 常用操作工具类

Arrays 有 asList，Maps 为什么没有 asMap？，这就是我为什么写这个工具类

Dict 类

public final class Dict<K, V>{
    private K key;
    private V value;

    public Dict() {

    }

    public Dict(K key, V value) {
        this.key = key;
        this.value = value;
    }

    public K getKey() {
        return key;
    }

    public V getValue() {
        return value;
    }

    public void setKey(K key) {
        this.key = key;
    }

    public void setValue(V value) {
        this.value = value;
    }
}

NEPENE大约 2 分钟

Java 二维码工具类

将字符串转化为 QrCode 图像流

Maven 依赖

<dependency>
    <groupId>com.google.zxing</groupId>
    <artifactId>core</artifactId>
    <version>3.5.1</version>
</dependency>

NEPENE小于 1 分钟

Java 反射工具类

关于反射的一些常用操作。除了使用 cglib 生成新的 bean部分，大部分操作均为暴力访问取值()。

Maps

请查看这篇 Map工具类

Collections

getOne 方法只是对 list.stream.filter(fn).getOne().orElse(null) 的简单封装

import java.util.Arrays;
import java.util.Collection;
import java.util.function.Predicate;
import org.springframework.lang.Nullable;

public final class Collections {
    public static boolean isEmpty(Collection<?> c){
        return c == null || c.size() == 0;
    }

    /**
     * 如果有空值
     */
    public static boolean isNull(Object... objects){
        for (Object o : objects) {
            if (o==null){
                return true;
            }
        }
        return false;
    }
    @SafeVarargs
    public static <T> T getNotNull(T... arr){
        for (T t : arr) {
            if (t != null){
                return t;
            }
        }
        return null;
    }
    @Nullable
    public static <T> T getOne(Collection<T> list, Predicate<T> predicate){
        if (list==null){
            return null;
        }
        return list.stream().filter(predicate).findFirst().orElse(null);
    }
    @Nullable
    public static <T> T getOne(T[] list, Predicate<T> predicate){
        if (list==null){
            return null;
        }
        return Arrays.stream(list).filter(predicate).findFirst().orElse(null);
    }

}

NEPENE大约 3 分钟

Java 字段映射工具类

映射一个对象的字段的值到另一个对象。

原理

首先获取源对象所有的字段（包括父类字段）参考反射工具类然后将字段转换成字段名与字段类型的 map Map工具类然后遍历字段，根据字段名获取 get/set 方法，如果没有该方法则进入下一次循环通过 get 方法获取源对象的值，然后通过 set 方法注入到目标对象

NEPENE大约 1 分钟

Java 日期工具类

获取两日期之间的差，日期格式化，日期偏移

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * 日期工具类
 * @author sa@linkot.cn
 */
public class DateUtils {
    public static final Long MILLIS = 1L;
    public static final Long SECONDS = MILLIS * 1000;
    public static final Long MINUTES = SECONDS * 60;
    public static final Long HOURS = MINUTES * 60;
    public static final Long DAYS = HOURS * 24;
    // 两时间的差（毫秒）
    public static Long between(Date start, Date end){
        return end.getTime() - start.getTime();
    }
    // 两时间的差（秒）
    public static Long betweenSeconds(Date start, Date end){
        return between(start, end) / SECONDS;
    }
    // 两时间的差（分）
    public static Long betweenMinutes(Date start, Date end){
        return between(start, end) / MINUTES;
    }
    // 两时间的差（时）
    public static Long betweenHours(Date start, Date end){
        return between(start, end) / HOURS;
    }
    // 两时间的差（日）
    public static Long betweenDays(Date start, Date end){
        return between(start, end) / DAYS;
    }

    public static Date parseDate(String src, String fmt){
        SimpleDateFormat format = new SimpleDateFormat(fmt);
        try {
            return format.parse(src);
        } catch (ParseException e) {
            throw new RuntimeException(e);
        }
    }

    public static String parseString(Date src, String fmt){
        SimpleDateFormat format = new SimpleDateFormat(fmt);
        return format.format(src);
    }

    public static Date later(Long l) {
        return new Date(System.currentTimeMillis() + l);
    }
}

NEPENE小于 1 分钟

Java 日期范围工具类

获取上月，本月，今日的时间范围，用于查询的 between ... and ...

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Calendar;
import java.util.Date;
import java.util.Locale;

/**
 * 日期范围工具类
 * @author sa@linkot.cn
 */
public final class Calendars {
    private static final DateTimeFormatter DATE_FORMAT = DateTimeFormatter.ofPattern("yyyy-MM-dd");
    private static final DateTimeFormatter DATE_FORMAT_FLAT = DateTimeFormatter.ofPattern("yyyyMMddHHmmss");

    public static String currentTimeString(){
        return DATE_FORMAT_FLAT.format(LocalDateTime.now());
    }

    /**
     * 本月时间域
     */
    public static String[] getMonthArea(){
        int year = getYear();
        int month = getMonth();
        Area area = getArea(year, month);
        return concatYear(year, area.start, area.end);
    }

    public static String[] concatYear(int year, String area, String area1) {
        return new String[]{year + "-" + area, year + "-" + area1};
    }
    public static String[] concatYear(int year, String area, int year2, String area1) {
        return new String[]{year + "-" + area, year2 + "-" + area1};
    }

    public static LocalDate parseDate(String str){
        try{
            return LocalDate.from(DATE_FORMAT.parse(str));
        }catch (Exception ex){
            throw new RuntimeException(ex);
        }
    }
    public static LocalDate parseFlatDate(String str){
        try{
            return LocalDate.from(DATE_FORMAT.parse(str));
        }catch (Exception ex){
            throw new RuntimeException(ex);
        }
    }

    /**
     * 上个月的时间域
     */
    public static String[] getPreventMonthArea(){
        Calendar i = Calendar.getInstance(Locale.SIMPLIFIED_CHINESE);
        int year = i.get(Calendar.YEAR);
        int month = i.get(Calendar.MONTH);
        if (month == 0){
            month = 11;
            year--;
        }else {
            month--;
        }
        Area area = getArea(year, month);
        return concatYear(year, area.start, area.end);
    }
    /**
     * 例：["2023-01-01 00:00:00","2023-01-01 23:59:59"]
     */
    public static String[] today(){
        String date = DATE_FORMAT.format(LocalDate.now());
        return new String[]{date + " 00:00:00", date + " 23:59:59"};
    }

    public static Area getArea(int year, int month){
        if (month == -1){
            month = 11;
        }
        if (month == 12){
            month = 0;
        }
        if (year %4 == 0 && month == 2){
            return Area.FEB_LARGE;
        }
        return Area.values()[month];
    }
    /**
     * 例：["2023-01-01","2023-12-31"]
     */
    public static String[] thisYear() {
        int year = getYear();
        return concatYear(year, "01-01", "12-31");
    }

    public static int getYear() {
        return Calendar.getInstance().get(Calendar.YEAR);
    }
    private static int getMonth() {
        return Calendar.getInstance().get(Calendar.MONTH);
    }

    /**
     * 例：["2022-04-01","2023-03-31"]
     */
    public static String[] getYearArea(){
        int year = getYear();
        int month = getMonth();
        Area end = getArea(year, month);
        Area start = getArea(year - 1, month + 1);
        return concatYear(year -1, start.start, year, end.end);
    }

    public enum Area {
        JAN("01-01", "01-31"),
        FEB("02-01", "02-28"),
        MAR("03-01", "03-31"),
        APR("04-01", "04-30"),
        MAY("05-01", "05-31"),
        JUN("06-01", "06-30"),
        JUL("07-01", "07-31"),
        AUG("08-01", "08-31"),
        SEP("09-01", "09-30"),
        OCT("10-01", "10-31"),
        NOV("11-01", "11-30"),
        DEC("12-01", "12-31"),
        FEB_LARGE("02-01", "02-29");

        public final String start;
        public final String end;
        Area(String start, String end) {
            this.start = start;
            this.end = end;
        }
    }

    /**
     * 以当前时间为基本进行偏移（加减）
     * @param field 日期单位
     * @param period 数量（可以为负数）
     */
    public static Date add(int field, int period){
        Calendar ins = Calendar.getInstance();
        ins.add(field, period);
        return ins.getTime();
    }
}

NEPENE大约 2 分钟