@Data
@EqualsAndHashCode(callSuper = true)
@Query(custom = true)
public class SysUserQueryDto extends BaseQueryDto {

    /**
     * 用户名
     */
    @QueryField(QueryField.Type.LIKE_RIGHT)
    private String username;

    /**
     * 密码
     */
    @QueryField(QueryField.Type.EQ)
    private String password;
}

@Data
public class BaseQueryDto implements Serializable {

    /**
     * 客户端自定义查询条件，需要在@Query中显式开启
     * 命名添加_后缀，避免和表字段冲突（前缀方式jackson默认解析不了）
     */
    @JsonProperty(value = Common.CONDITIONS_FIELD_NAME)
    private String conditions_;
}

/**
 * 带查询条件字段的基类
 */
@Data
@EqualsAndHashCode(callSuper = true)
@Query(custom = true)
public class ConditionBaseEntity<T extends BaseEntity<T>> extends BaseEntity<T> {

    /**
     * 客户端自定义查询条件，需要在@Query中显式开启
     * 添加@JsonProperty注解，使在接口请求时暴露该字段，响应时不返回该字段
     * 添加@TableField注解，标识该字段非表字段
     * 命名添加_后缀，避免和表字段冲突（前缀方式jackson默认解析不了）
     */
    @JsonProperty(value = Common.CONDITIONS_FIELD_NAME, access = JsonProperty.Access.WRITE_ONLY)
    @TableField(exist = false)
    private String conditions_;
}

@Data
@EqualsAndHashCode(callSuper = true)
@Query(custom = true)
public class SysUserQueryDto extends BaseQueryDto {

    /**
     * 用户名
     */
    @QueryField(QueryField.Type.LIKE_RIGHT)
    private String username;

    /**
     * 密码
     */
    @QueryField(QueryField.Type.LIKE)
    private String password;
}

/**
 * 查询类上可以不添加该注解，行为保持默认
 */
@Inherited
@Documented
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Query {

    // 是否启用，默认是
    boolean enabled() default true;

    // 是否支持客户端自定义条件查询，默认否
    boolean custom() default false;
}

@Documented
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface QueryField {

    // default
    Type value() default Type.DEFAULT;

    Type type() default Type.DEFAULT;

    // 条件生效策略
    ConditionStrategy conditionStrategy() default ConditionStrategy.NOT_BLANK;

    @Getter
    enum Type {
        // 保留DEFAULT是为了关联value()和type()
        DEFAULT("等同于EQ", "default"),
        EQ("等于", "eq"),
        NE("不等于", "ne"),
        GT("大于", "gt"),
        GE("大于等于", "ge"),
        LT("小于", "lt"),
        LE("小于等于", "le"),
        IN("包含", "in"),
        NOT_IN("非包含", "notIn"),
        IS_NULL("为null", "isNull"),
        IS_NOT_NULL("非null", "isNotNull"),
        BETWEEN("区间", "between"),
        NOT_BETWEEN("非区间", "notBetween"),
        LIKE("模糊", "like"),
        LIKE_LEFT("左模糊", "likeLeft"),
        LIKE_RIGHT("右模糊", "likeRight"),
        NOT_LIKE("非模糊", "notLike"),
        NOT_LIKE_LEFT("非左模糊", "notLikeLeft"),
        NOT_LIKE_RIGHT("非右模糊", "notLikeRight");

        private final String desc;
        private final String exp;

        Type(String desc, String exp) {
            this.desc = desc;
            this.exp = exp;
        }

        // of
        public static Type of(String value) {
            // default为非法操作符，不可从接口参数指定，只能内部注解中指定
            if (DEFAULT.name().equalsIgnoreCase(value)) {
                return null;
            }
            for (Type type : values()) {
                if (type.getExp().equalsIgnoreCase(value)) {
                    return type;
                }
            }
            return null;
        }
    }

    /**
     * 条件生效策略
     */
    @Getter
    enum ConditionStrategy {
        NOT_NULL("非null"),
        NOT_BLANK("非空串");

        private final String desc;

        ConditionStrategy(String desc) {
            this.desc = desc;
        }
    }
}

package com.yeshimin.unknown.common.config.mybatis;

import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.yeshimin.unknown.common.consts.Common;
import com.yeshimin.unknown.domain.base.BaseQueryDto;
import com.yeshimin.unknown.domain.base.ConditionBaseEntity;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;

import java.lang.reflect.Field;
import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

@Slf4j
public class QueryHelper<T> {

    public static <T> QueryWrapper<T> getQueryWrapper(Object query) {
        return getQueryWrapper(query, Wrappers.query());
    }

    /**
     * 生成QueryWrapper
     *
     * @param clazz 实体类Class，用于设置按实体类查询
     */
    public static <T> QueryWrapper<T> getQueryWrapper(Object query, Class<T> clazz) {
        QueryWrapper<T> wrapper = new QueryWrapper<>();
        if (clazz.isInstance(query)) {
            wrapper.setEntity(clazz.cast(query));
        }
        return getQueryWrapper(query, wrapper);
    }

    public static <T> QueryWrapper<T> getQueryWrapper(Object query, QueryWrapper<T> wrapper) {
        // 获取@Query注解
        Query queryAnno = query.getClass().getAnnotation(Query.class);
        // 是否启用查询
        boolean queryEnabled = queryAnno != null && queryAnno.enabled();
        // 是否启用自定义查询
        boolean queryCustom = queryAnno != null && queryAnno.custom();
        if (!queryEnabled) {
            log.debug("class: [{}], @Query is not enabled, skip", query.getClass().getName());
            return wrapper;
        }

        // 解析自定义查询条件
        List<Condition> listCondition = parseConditions(queryCustom, query);

        // 解析类字段定义的查询条件
        Field[] fields = query.getClass().getDeclaredFields();
        for (Field field : fields) {
            // 跳过conditions字段
            if (field.getName().equals(Common.CONDITIONS_FIELD_NAME)) {
                log.debug("skip 'conditions' field");
                continue;
            }

            // 判断是否有 @QueryField 注解
            QueryField queryField = field.getAnnotation(QueryField.class);
            if (queryField == null) {
                log.debug("{} is not annotated with @QueryField, skip", field.getName());
                continue;
            }

            // 获取原访问标识，用于复原
            boolean isAccessible = field.isAccessible();
            // 允许访问私有字段
            field.setAccessible(true);
            try {
                Object value = field.get(query);

                // 获取条件生效策略
                QueryField.ConditionStrategy conditionStrategy = queryField.conditionStrategy();
                if (conditionStrategy == QueryField.ConditionStrategy.NOT_BLANK) {
                    if (value == null) {
                        log.debug("{} is null, skip", field.getName());
                        continue;
                    }
                    if (value instanceof String && StrUtil.isBlank((String) value)) {
                        log.debug("{} is blank, skip", field.getName());
                        continue;
                    }
                } else if (conditionStrategy == QueryField.ConditionStrategy.NOT_NULL) {
                    if (value == null) {
                        log.debug("{} is null, skip", field.getName());
                        continue;
                    }
                } else {
                    log.warn("conditionStrategy is not supported, skip");
                    continue;
                }

                // 获取查询类型
                QueryField.Type type = queryField.value() == QueryField.Type.DEFAULT ?
                        (queryField.type() == QueryField.Type.DEFAULT ? (QueryField.Type.EQ) : (queryField.type())) :
                        queryField.value();

                listCondition.add(new Condition(field.getName(), type, value));
            } catch (IllegalAccessException e) {
                log.error("{}", e.getMessage());
                e.printStackTrace();
            } finally {
                field.setAccessible(isAccessible);
            }
        }

        for (Condition condition : listCondition) {
            String fieldName = condition.getProperty();
            // 实体类字段命名转为表字段命名（小驼峰转下划线）
            String columnName = StrUtil.toUnderlineCase(fieldName);
            QueryField.Type operator = condition.getOperator();
            Object value = condition.getValue();

            switch (operator) {
                // equal
                case EQ:
                    wrapper.eq(columnName, value);
                    break;
                // not equal
                case NE:
                    wrapper.ne(columnName, value);
                    break;
                // greater than
                case GT:
                    wrapper.gt(columnName, value);
                    break;
                // greater and equal
                case GE:
                    wrapper.ge(columnName, value);
                    break;
                // less than
                case LT:
                    wrapper.lt(columnName, value);
                    break;
                // less and equal
                case LE:
                    wrapper.le(columnName, value);
                    break;
                // in
                case IN:
                    if (value instanceof Object[]) {
                        if (((Object[]) value).length > 0) {
                            wrapper.in(columnName, (Object[]) value);
                        } else {
                            log.warn("{} is empty, skip", fieldName);
                        }
                    } else if (value instanceof Collection) {
                        if (!((Collection<?>) value).isEmpty()) {
                            wrapper.in(columnName, (Collection<?>) value);
                        } else {
                            log.warn("{} is empty, skip", fieldName);
                        }
                    }
                    break;
                // not in
                case NOT_IN:
                    if (value instanceof Object[]) {
                        if (((Object[]) value).length > 0) {
                            wrapper.notIn(columnName, (Object[]) value);
                        } else {
                            log.warn("{} is empty, skip", fieldName);
                        }
                    } else if (value instanceof Collection) {
                        if (!((Collection<?>) value).isEmpty()) {
                            wrapper.notIn(columnName, (Collection<?>) value);
                        } else {
                            log.warn("{} is empty, skip", fieldName);
                        }
                    }
                    break;
                // is null
                case IS_NULL:
                    wrapper.isNull(columnName);
                    break;
                // is not null
                case IS_NOT_NULL:
                    wrapper.isNotNull(columnName);
                    break;
                // between
                case BETWEEN:
                    if (value instanceof Object[]) {
                        Object[] arr = (Object[]) value;
                        if (arr.length == 2) {
                            wrapper.between(columnName, arr[0], arr[1]);
                        } else {
                            log.warn("{} is invalid, skip", fieldName);
                        }
                    } else if (value instanceof Collection) {
                        Collection<?> col = (Collection<?>) value;
                        if (col.size() == 2) {
                            Iterator<?> iterator = col.iterator();
                            wrapper.between(columnName, iterator.next(), iterator.next());
                        } else {
                            log.warn("{} is invalid, skip", fieldName);
                        }
                    } else {
                        log.warn("{} is invalid, skip", fieldName);
                    }
                    break;
                // not between
                case NOT_BETWEEN:
                    if (value instanceof Object[]) {
                        Object[] arr = (Object[]) value;
                        if (arr.length == 2) {
                            wrapper.notBetween(columnName, arr[0], arr[1]);
                        } else {
                            log.warn("{} is invalid, skip", fieldName);
                        }
                    } else if (value instanceof Collection) {
                        Collection<?> col = (Collection<?>) value;
                        if (col.size() == 2) {
                            Iterator<?> iterator = col.iterator();
                            wrapper.notBetween(columnName, iterator.next(), iterator.next());
                        } else {
                            log.warn("{} is invalid, skip", fieldName);
                        }
                    } else {
                        log.warn("{} is invalid, skip", fieldName);
                    }
                    break;
                // like
                case LIKE:
                    wrapper.like(columnName, value);
                    break;
                // like left
                case LIKE_LEFT:
                    wrapper.likeLeft(columnName, value);
                    break;
                // like right
                case LIKE_RIGHT:
                    wrapper.likeRight(columnName, value);
                    break;
                // not like
                case NOT_LIKE:
                    wrapper.notLike(columnName, value);
                    break;
                // not like left
                case NOT_LIKE_LEFT:
                    wrapper.notLikeLeft(columnName, value);
                    break;
                // not like right
                case NOT_LIKE_RIGHT:
                    wrapper.notLikeRight(columnName, value);
                    break;
                default:
                    break;
            }
        }

        return wrapper;
    }

    private static List<Condition> parseConditions(boolean queryCustom, Object query) {
        String conditions = null;
        if (queryCustom) {
            if (query instanceof BaseQueryDto) {
                conditions = ((BaseQueryDto) query).getConditions_();
            } else if (query instanceof ConditionBaseEntity) {
                conditions = ((ConditionBaseEntity<?>) query).getConditions_();
            }
        }
        return conditions == null ? new LinkedList<>() : parseConditions(conditions);
    }

    /**
     * 解析自定义查询条件
     *
     * @param conditions 自定义查询条件（可能多个） 示例：username:likeLeft:yeshi;password:eq:123456
     * @return List<Condition>
     */
    private static List<Condition> parseConditions(String conditions) {
        List<Condition> list = new LinkedList<>();
        if (StrUtil.isBlank(conditions)) {
            log.debug("conditions is blank, ignore");
            return list;
        }
        String[] arr = conditions.split(";");
        for (String s : arr) {
            String[] arr2 = s.split(":");
            if (arr2.length != 3) {
                log.warn("condition [{}] is invalid, ignore", s);
                continue;
            }
            if (StrUtil.isBlank(arr2[0])) {
                log.warn("condition [{}] -> fieldName is blank, ignore", s);
                continue;
            }
            QueryField.Type operator = QueryField.Type.of(arr2[1]);
            if (operator == null) {
                log.warn("condition [{}] -> operator is invalid, ignore", s);
                continue;
            }

            list.add(new Condition(arr2[0], operator, arr2[2]));
        }
        return list;
    }

    @Data
    @AllArgsConstructor
    private static class Condition {
        private String property;
        QueryField.Type operator;
        Object value;
    }
}

/**
 * 提供基础的CRUD接口
 *
 * @param <E> 实体类
 * @param <M> BaseMapper
 * @param <S> ServiceImpl
 */
@Slf4j
@RequiredArgsConstructor
public class CrudController<E extends BaseEntity<E>, M extends BaseMapper<E>, S extends ServiceImpl<M, E>>
        extends BaseController {

    private final S service;

    /**
     * CRUD-查询
     */
    @GetMapping("/crud/query")
    public R<Page<E>> crudQuery(Page<E> page, E query) {
        @SuppressWarnings("unchecked")
        Class<E> clazz = (Class<E>) query.getClass();
        return R.ok(service.page(page, QueryHelper.getQueryWrapper(query, clazz)));
    }
}

public Page<SysUserEntity> query(Page<SysUserEntity> page, SysUserQueryDto dto) {
    return super.page(page, QueryHelper.getQueryWrapper(dto));
}

public BufferedImage generateImage(String url) {
    log.info("generateImage...url: {}", url);

    URL url0;
    try {
        url0 = new URL(url);
    } catch (MalformedURLException e) {
        throw new RuntimeException(e);
    }
    BufferedImage bufferedImage;
    try {
        bufferedImage = ImageIO.read(url0);
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
    return bufferedImage;
}

/**
 * 生成二维码
 */
public BufferedImage generateQrCode(String text, int width, int height) {
    log.info("generateQrCode...text: {}, width: {}, height: {}", text, width, height);

    // 生成二维码BitMatrix
    BitMatrix bitMatrix;
    try {
        // 不能按指定大小生成，先按自动大小生成，在convertToDotMatrixImage方法中缩放
        bitMatrix = new QRCodeWriter().encode(text, BarcodeFormat.QR_CODE, 0, 0, this.hints);
    } catch (WriterException e) {
        throw new RuntimeException(e);
    }
    // 转换为点阵图像
    return this.convertToDotMatrixImage(bitMatrix, width, height);
}

/**
 * 生成条形码
 */
public BufferedImage generateBarCode(String text, int width, int height) {
    log.info("drawBarCode...text: {}, width: {}, height: {}", text, width, height);

    // 生成条形码BitMatrix
    BitMatrix bitMatrix = new Code128Writer().encode(text, BarcodeFormat.CODE_128, 0, 0);
    // 转换为点阵图像
    return this.convertToDotMatrixImage(bitMatrix, width, height);
}

/**
 * 将BitMatrix转换为点阵图像BufferedImage
 * 生成二维码场景，当指定90x90，会生成49x49（bitMatrix尺寸是90x90但是内容是49x49居中）的二维码，需要进行缩放
 */
private BufferedImage convertToDotMatrixImage(BitMatrix bitMatrix, int desiredWidth, int desiredHeight) {
    // 缩放二维码
    BufferedImage qrImage = MatrixToImageWriter.toBufferedImage(bitMatrix);
    BufferedImage scaledImage = new BufferedImage(desiredWidth, desiredHeight, BufferedImage.TYPE_BYTE_BINARY);
    Graphics2D g = scaledImage.createGraphics();
    g.drawImage(qrImage, 0, 0, desiredWidth, desiredHeight, null);
    g.dispose();

    return scaledImage;
}

    /**
     * 生成文本图像
     */
    private BufferedImage generateTextImage(String text) throws IOException {
        // 获取字体文件对象
//        RandomAccessFile fontFile = this.getFontFile(this.fontFileName);

        int fontWidth = this.fontWidth;
        int fontHeight = this.fontHeight;
        int byteCount = this.byteCount;

        int textLength = text.length();

        // list of char[][] 存放每个字符的点阵数据
        ArrayList<char[][]> dotMatList = new ArrayList<>(textLength);

        // 绘制每个字符
        for (int i = 0; i < textLength; i++) {
            char word = text.charAt(i);

            // 获取字符码点
            int codePoint = this.getCodePoint(String.valueOf(word));
            // 修正24宽度字体的码点 ; 原因未知，copy自php版逻辑
            codePoint = this.fixCodePointWhenFontWidth24(codePoint);
            // 计算在字体文件中的位置
            int position = codePoint * byteCount;
            // 获取字体数据
//            byte[] fontData = this.getFontData(fontFile, position, byteCount);
            // fix: resources下的文件在打成jar后使用(RandomAccess)File读取失败，改为直接加载byte[]缓存到内存
            byte[] fontData = this.readFontData(this.fontFileName, position, byteCount);
            // convert to mat
            char[][] dotMat = this.convertBytesToDotMat(fontData, fontHeight, fontWidth);

            // 获取字符实际宽度
            int realWidth = codePoint < 700 ? this.fontEn : this.fontZh;
            // 按实际宽度切割重组
            for (int j = 0; j < fontHeight; j++) {
                // 自动宽度逻辑
                realWidth = this.autoWidth ? this.getCharWidth(dotMat, this.fontZh, this.fontWidth) : realWidth;
                // 空格间距逻辑
                realWidth = codePoint == this.SPACE_CODE_POINT ? this.SPACE_WIDTH : realWidth;
                // 按实际宽度切割
                char[] row = dotMat[j];
                char[] newRow = new char[realWidth];
                System.arraycopy(row, 0, newRow, 0, realWidth);
                // 加粗逻辑
                newRow = this.setBold(newRow, this.bold);
                // 字间距逻辑
                newRow = this.setSpacing(newRow, this.fontSpace);

                dotMat[j] = newRow;
            }
            // dotMat根据最长的长度补齐尾部
            this.padDotMat(dotMat);

            // 打印
//            this.printDotMat(dotMat);
            // 加入集合
            dotMatList.add(dotMat);
        }

        // 整合所有dotMat from dotMatList
        char[][] finalDotMat = this.mergeDotMat(dotMatList);

        // 保存文本点阵宽度和高度
        this.textBitWidth = finalDotMat[0].length;
        this.textBitHeight = finalDotMat.length;

        // 将所有dotMat绘制到图像
        BufferedImage textImage = new BufferedImage(finalDotMat[0].length, fontHeight, BufferedImage.TYPE_BYTE_BINARY);
        this.renderDotMatToImage(finalDotMat, textImage, 0, 0);

//        fontFile.close();

        return textImage;
    }

    /**
     * 获取码点
     */
    private int getCodePoint(String str) {
        int codePoint = 0;
        try {
            // 获取字符串的代码点
            codePoint = str.codePointAt(0);
        } catch (IndexOutOfBoundsException e) {
            // 处理字符串为空或其他异常情况
            e.printStackTrace();
        }
        // 字符越界处理
        if (codePoint > 65535) {
            codePoint = 0;
        }
        return codePoint;
    }

    /**
     * 修正24宽度字体的码点
     * 将超出范围的码点修正为空格码点
     */
    private int fixCodePointWhenFontWidth24(int codePoint) {
        if (this.fontWidth == 24) {
            if (codePoint <= this.SPACE_CODE_POINT || codePoint > this.fontMaxPosition) {
                codePoint = this.SPACE_CODE_POINT;
            }
        }
        return codePoint;
    }

    /**
     * 转换字节数组为点阵多维数组
     */
    private char[][] convertBytesToDotMat(byte[] fontData, int fontHeight, int fontWidth) {
        // fontData bit -> char[]
        char[] dots = new char[fontHeight * fontWidth];
        for (int i = 0; i < fontData.length; i++) {
            byte b = fontData[i];
            for (int bit = 7; bit >= 0; bit--) {
                int bitValue = (b >> bit) & 1;
                dots[i * 8 + (7 - bit)] = bitValue == 1 ? '1' : '0';
            }
        }
        // char[] -> char[][] by fontWidth
        char[][] dotMat = new char[fontHeight][fontWidth];
        for (int i = 0; i < fontHeight; i++) {
            System.arraycopy(dots, i * fontWidth, dotMat[i], 0, fontWidth);
        }
        return dotMat;
    }

    /**
     * 加粗逻辑
     */
    private char[] setBold(char[] dot, boolean fontBold) {
        if (!fontBold) {
            return dot;
        }

        char[] result = new char[dot.length];
        for (int i = 0; i < dot.length; i++) {
            char current = dot[i];
            char shifted = i == 0 ? '0' : dot[i - 1]; // 前一个字符，用'0'补齐
            result[i] = (current == '1' || shifted == '1') ? '1' : '0';
        }

        return result;
    }

    /**
     * 字间距逻辑
     */
    private char[] setSpacing(char[] dotArray, int spacing) {
        if (spacing <= 0) {
            return dotArray; // 如果 spacing <= 0，直接返回原数组
        }

        char[] result = new char[dotArray.length + spacing];
        int index = 0;

        for (char c : dotArray) {
            result[index++] = c;
        }

        // 添加字间距
        for (int i = 0; i < spacing; i++) {
            result[index++] = '0';
        }

        return result;
    }

    /**
     * 对齐点阵尾部
     */
    private void padDotMat(char[][] dotMat) {
        // 先获取最长的长度
        int maxRowLength = 0;
        for (char[] row : dotMat) {
            maxRowLength = Math.max(maxRowLength, row.length);
        }
        // dotMat根据最长的长度补齐尾部
        for (int k = 0; k < dotMat.length; k++) {
            char[] row = dotMat[k];
            char[] newRow = new char[maxRowLength];
            System.arraycopy(row, 0, newRow, 0, row.length);
            for (int j = row.length; j < maxRowLength; j++) {
                newRow[j] = '0';
            }
            dotMat[k] = newRow;
        }
    }

    /**
     * 合并多个点阵
     */
    private char[][] mergeDotMat(ArrayList<char[][]> dotMatList) {
        // 计算最终宽度
        int finalWidth = this.calcFinalWidth(dotMatList);
        int fontHeight = this.fontHeight;
        char[][] finalDotMat = new char[fontHeight][finalWidth];
        int columnIndex = 0;
        for (char[][] chars : dotMatList) {
            int rowIndex = 0;
            for (char[] aChar : chars) {
                System.arraycopy(aChar, 0, finalDotMat[rowIndex++], columnIndex, aChar.length);
            }
            columnIndex += chars[0].length;
        }
        return finalDotMat;
    }

    /**
     * 计算最终宽度
     */
    private int calcFinalWidth(ArrayList<char[][]> dotMatList) {
        int finalWidth = 0;
        for (char[][] dotMat : dotMatList) {
            finalWidth += dotMat[0].length;
        }
        return finalWidth;
    }

    /**
     * 将dotMat绘制到图像
     */
    private void renderDotMatToImage(char[][] dotMat, BufferedImage image, int x, int y) {
        for (int j = 0; j < dotMat.length; j++) {
            char[] row = dotMat[j];
            for (int k = 0; k < row.length; k++) {
                char bitValue = dotMat[j][k];
                image.setRGB(x + k, y + j, bitValue == '1' ? Color.BLACK.getRGB() : Color.WHITE.getRGB());
            }
        }
    }

private final Map<String, byte[]> fontFileDataMap = new ConcurrentHashMap<>();

private byte[] readFontData(String fontFileName, int position, int byteCount) throws IOException {
    byte[] fontFileData = fontFileDataMap.get(fontFileName);
    if (fontFileData == null) {
        fontFileData = this.loadFontFileData(fontFileName);
    }

    byte[] fontData = new byte[byteCount];
    System.arraycopy(fontFileData, position, fontData, 0, byteCount);
    return fontData;
}

private synchronized byte[] loadFontFileData(String resourcePath) throws IOException {
    // 检查并发场景下其他线程是否已加载，避免重复加载
    byte[] fontFileData = fontFileDataMap.get(fontFileName);
    if (fontFileData != null) {
        return fontFileData;
    }

    try (InputStream inputStream = LatticeText.class.getClassLoader().getResourceAsStream(resourcePath);
         ByteArrayOutputStream buffer = new ByteArrayOutputStream()) {
        if (inputStream == null) {
            throw new IOException("Resource not found: " + resourcePath);
        }

        byte[] data = new byte[1024];
        int bytesRead;

        // Read the input stream into the byte array output stream
        while ((bytesRead = inputStream.read(data, 0, data.length)) != -1) {
            buffer.write(data, 0, bytesRead);
        }

        // Return the byte array
        fontFileData = buffer.toByteArray();
        fontFileDataMap.put(fontFileName, fontFileData);
        return fontFileData;
    }
}

/**
 * 转码并返回音频时长
 */
public Double transcoding(String ffmpegPath, String input, String output) {
    String info = output + ".info";
    FileUtil.touch(info);
    String[] ffmpegCommand = {
            ffmpegPath,
            "-hide_banner",
            "-y",
            // ... 其他参数
            "-i", input, output,
            "2>&1 | cat >", info
    };
    List<String> listCommand = CollUtil.newArrayList(ffmpegCommand);

    String finalCommandStr = StrUtil.join(" ", listCommand);
    log.info("finalCommandStr: {}", finalCommandStr);

    int exitCode = -1;
    try {
//        ProcessBuilder pb = new ProcessBuilder(listCommand);
        // 如果有重定向的逻辑，一定要这样调用！！！
        ProcessBuilder pb = new ProcessBuilder("/bin/sh", "-c", String.join(" ", listCommand));
        Process process = pb.inheritIO().start();
        exitCode = process.waitFor();
        process.destroy();
    } catch (Exception e) {
        e.printStackTrace();
    }

    log.info("exitCode: {}", exitCode);

    // 获取音频时长
    Double length = this.getAudioLength(info);
    FileUtil.del(info);

    return length;
}

/**
 * 获取音频时长
 */
private Double getAudioLength(String infoFile) {
    Double durationInSeconds = null;  // 初始化为 null

    // 读取infoFile，提取音频时长信息
    List<String> lines = FileUtil.readLines(infoFile, "UTF-8");
    for (String line : lines) {
        if (line.contains("Duration:")) {
            // 提取包含 "Duration:" 的行
            String durationLine = line.trim();
            String durationPart = durationLine.split("Duration:")[1].trim().split(",")[0].trim();

            // 解析时长信息，转换为 Double，精确到毫秒
            String[] timeParts = durationPart.split(":");
            double hours = Double.parseDouble(timeParts[0]);
            double minutes = Double.parseDouble(timeParts[1]);
            double seconds = Double.parseDouble(timeParts[2]);
            double milliseconds = (hours * 3600 + minutes * 60 + seconds) * 1000;

            durationInSeconds = milliseconds / 1000.0;  // 转换为秒
        }
    }
    return durationInSeconds;
}

package com.yeshimin.test.jni;

import java.lang.reflect.Field;
import java.util.Arrays;

public class JniTest {

    // 设置dll加载路径
    static {
        try {
            String path = "C:\\Users\\ysd\\IdeaProjects\\test\\dll";
            // 无效
//            System.setProperty("java.library.path", path);
            // 需要使用这种方式
            // 参考：https://fahdshariff.blogspot.com/2011/08/changing-java-library-path-at-runtime.html
            addLibraryPath(path);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }

        System.loadLibrary("jnitest");
    }

    /**
     * Adds the specified path to the java library path
     *
     * @param pathToAdd the path to add
     * @throws Exception
     */
    public static void addLibraryPath(String pathToAdd) throws Exception {
        final Field usrPathsField = ClassLoader.class.getDeclaredField("usr_paths");
        usrPathsField.setAccessible(true);

        // get array of paths
        final String[] paths = (String[]) usrPathsField.get(null);

        // check if the path to add is already present
        for (String path : paths) {
            if (path.equals(pathToAdd)) {
                return;
            }
        }

        //add the new path
        final String[] newPaths = Arrays.copyOf(paths, paths.length + 1);
        newPaths[newPaths.length - 1] = pathToAdd;
        usrPathsField.set(null, newPaths);
    }

    // ================================================================================

    // 本地方法
    private static native String sayHello(String name);

    public static void main(String[] args) {
        String result = sayHello("ysm");
        System.out.println("result: " + result);
    }
}

package com.yeshimin.test.jni;

import java.lang.reflect.Field;
import java.util.Arrays;

public class JniTest {

    // 设置dll加载路径
    static {
        // 略...

        System.loadLibrary("jnitestinternal");
    }

    // 本地方法
    private static native String sayHelloInternal(String name);

    public static void main(String[] args) {
        String result = sayHelloInternal("ysm");
        System.out.println("result: " + result);
    }
}

package com.yeshimin.test.jni;

import java.lang.reflect.Field;
import java.util.Arrays;

public class JniTest {

    // 设置dll加载路径
    static {
        // 略...

        System.loadLibrary("jnitest");
        System.loadLibrary("jnitestinternal"); // 依赖的dll也要加载
    }

    private static native String sayHello(String name);

    private static native String sayHelloByProxy(String name);

    private static native String sayHelloInternal(String name);

    public static void main(String[] args) {

        // 调用同包名下的本地方法；执行成功
        String result = sayHello("ysm");
        System.out.println("result: " + result);

        // “代理”方式下，调用不同包名下的本地方法；执行成功
        String result2 = sayHelloByProxy("ysm");
        System.out.println("result2: " + result2);

        // 调用不同包名下的本地方法；执行报错
        String result3 = sayHelloInternal("ysm");
        System.out.println("result3: " + result3);
    }
}