private static void bugRecur(){
     // 模拟实际情况中的utf8字节数组
     byte[] bugBytes=new String("\r\n\r\n公司123\r\n").getBytes(StandardCharsets.UTF_8);
     byte[] normalBytes=new String("\r\n\r\n普通字符123\r\n").getBytes(StandardCharsets.UTF_8);

     // 模拟业务需要，以iso8859-1编码将字节数组转回字符串（实际上上面和下面在实际业务的不同系统做的）
     String bugStr=new String(bugBytes,StandardCharsets.ISO_8859_1);
     String normalStr=new String(normalBytes,StandardCharsets.ISO_8859_1);

     // 进行正则匹配
     String patternStr = "\\r\\n\\r\\n(.*?)\\r\\n";
     Pattern pattern = Pattern.compile(patternStr);
     Matcher bugMatcher = pattern.matcher(bugStr);
     Matcher normalMatcher = pattern.matcher(normalStr);

     System.out.println("问题字符匹配结果: " + bugMatcher.find());
     System.out.println("普通字符匹配结果: " + normalMatcher.find());
 }

private static void deepReason(){
    // 模拟实际情况中的utf8字节数组
    byte[] bugBytes=new String("\r\n\r\n好公司123\r\n").getBytes(StandardCharsets.UTF_8);
    byte[] normalBytes=new String("\r\n\r\n普通字符123\r\n").getBytes(StandardCharsets.UTF_8);

    // 模拟业务需要，以iso8859-1编码将字节数组转回字符串（实际上上面和下面在实际业务的不同系统做的）
    String bugStr=new String(bugBytes,StandardCharsets.ISO_8859_1);
    String normalStr=new String(normalBytes,StandardCharsets.ISO_8859_1);


    System.out.println("错误编码后的问题字符串字节数组: "+ Arrays.toString(bugStr.getBytes(StandardCharsets.ISO_8859_1)));
    System.out.println("错误编码后的问题字符串字节数组: "+ Arrays.toString(normalStr.getBytes(StandardCharsets.ISO_8859_1)));
    // 这里是往控制台输出的结果，一般流会通过utf8编码传输，对分析函数内部行为没什么意义
    // System.out.println("错误编码后的问题字符串: "+bugStr);

    // 更关键的是看字符串在java内存中的utf16编码后的结果
    // System.out.println("错误编码后的问题字符串在java内存中的utf16编码字符数组: "+ Arrays.toString(bugStr.toCharArray())); // 这一行会输出失败
    System.out.println("错误编码后的问题字符串在java内存中的utf16编码字节数组: "+ Arrays.toString(bugStr.getBytes(StandardCharsets.UTF_16)));
    // System.out.println("错误编码后的普通字符串在java内存中的utf16编码字符数组: "+ Arrays.toString(normalStr.toCharArray())); // 这一行会输出失败
    System.out.println("错误编码后的普通字符串在java内存中的utf16编码字节数组: "+ Arrays.toString(normalStr.getBytes(StandardCharsets.UTF_16)));

    String patternStr = "\\r\\n\\r\\n(.*?)\\r\\n";
    Pattern pattern = Pattern.compile(patternStr);
    Matcher bugMatcher = pattern.matcher(bugStr);
    Matcher normalMatcher = pattern.matcher(normalStr);

    System.out.println("问题字符匹配结果: " + bugMatcher.find());
    System.out.println("普通字符匹配结果: " + normalMatcher.find());

}

public static void wordWith0x75(){
        int count=0;
        // CJK统一汉字基本区：U+4E00 ~ U+9FFF
        for (int codePoint = 0x4E00; codePoint <= 0x9FFF; codePoint++) {
            char ch = (char) codePoint;
            String s = String.valueOf(ch);

            byte[] bytes = s.getBytes(StandardCharsets.UTF_8);

            // UTF-8 编码的汉字应该是 3 字节
            if (bytes.length == 3) {
                boolean has85 = false;
                for (byte b : bytes) {
                    // Java byte 范围是 -128~127，需要转成无符号
                    int unsigned = b & 0xFF;
                    if (unsigned == 0x85) {
                        has85 = true;
                        break;
                    }
                }
                if (has85) {
                    // 打印字符 + UTF-8字节的十六进制表示
                    System.out.printf("U+%04X %s -> %s%n", codePoint, ch, bytesToHex(bytes));
                    count++;
                }
            }
        }
        System.out.printf("基本中文共有%d个符合要求",count);
    }

    private static String bytesToHex(byte[] bytes) {
        StringBuilder sb = new StringBuilder("[");
        for (int i = 0; i < bytes.length; i++) {
            if (i > 0) sb.append(" ");
            sb.append(String.format("0x%02X", bytes[i] & 0xFF));
        }
        sb.append("]");
        return sb.toString();
    }

public Builder withEmbeddingDimension(int newEmbeddingDimension) {
                Assert.isTrue(newEmbeddingDimension >= 1 && newEmbeddingDimension <= 2048, "Dimension has to be withing the boundaries 1 and 2048 (inclusively)");
                this.embeddingDimension = newEmbeddingDimension;
                return this;
            }

return queryResponse.getMatchesList()
	.stream()
	.filter(scoredVector -> scoredVector.getScore() >= request.getSimilarityThreshold()) // here my socres are negative numbers
	.map(scoredVector -> {
		var id = scoredVector.getId();
		Struct metadataStruct = scoredVector.getMetadata();
		var content = metadataStruct.getFieldsOrThrow(CONTENT_FIELD_NAME).getStringValue();
		Map<String, Object> metadata = extractMetadata(metadataStruct);
		metadata.put(DISTANCE_METADATA_FIELD_NAME, 1 - scoredVector.getScore());
		return new Document(id, content, metadata);
	})
	.toList();

/**
 * 下单报文接口
 * @author: east
 * @date: 2023/11/23
 */
public interface OrderRequest<T extends OrderInfo> {
    /**
     * 将不同渠道报文转为T的统一格式数据（比如转为落表所需数据）
     * 通过T extends OrderInfo限制模板类型为OrderInfo及其子类
     *
     * @return T 统一数据
     */
    public T generateOrderInfo();
}

/**
 * 账单通用数据
 */
public class OrderInfo {
    protected BigDecimal amt;
    protected String serial;
    protected String rcvNo;

    public OrderInfo(BigDecimal amt, String serial, String rcvNo) {
        this.amt = amt;
        this.serial = serial;
        this.rcvNo = rcvNo;
    }

    public OrderInfo() {
    }

    @Override
    public String toString() {
        return "OrderInfo{" +
                "amt=" + amt +
                ", serial='" + serial + '\'' +
                ", rcvNo='" + rcvNo + '\'' +
                '}';
    }
}

/**
 * 下单要落表的最基本信息，如果除了账单信息，其他渠道需要落特别的数据表，则基础本类并重写Save接口即可，满足开闭原则
 * 账单信息
 * 其他信息自行继承本类实现
 *
 * @author: east
 * @date: 2023/11/25
 */
public class BaseSavedInfo {
    protected OrderInfo orderInfo;

    public BaseSavedInfo(OrderInfo orderInfo) {
        this.orderInfo = orderInfo;
    }

    @Override
    public String toString() {
        return "SavedInfo{" +
                "orderInfo=" + orderInfo +
                '}';
    }
}

/**
 * 保存下单相关信息， 使用模板方法
 *
 * @author: east
 * @date: 2023/11/23
 */
public interface Save {
    /**
     * 保存下单数据
     *
     * @param savedInfo 相关信息:账单表，统计表
     */
    public <T extends BaseSavedInfo> void save(T savedInfo);
}

/**
 * 保存下单相关信息, 模板类
 *
 * @author: east
 * @date: 2023/11/23
 */
public interface SaveT<T extends BaseSavedInfo> {
    /**
     * 保存下单数据
     *
     * @param savedInfo 相关信息:账单表，统计表
     */
    public void save(T savedInfo);
}

public abstract class AbstractOrder<T extends OrderRequest<?>> {
    // 使用Save接口作为其依赖
    protected Save save;

    public AbstractOrder(Save save) {
        this.save = save;
    }

    /**
     * 下单接口；T为实现了OrderRequest接口的请求报文
     */
    public abstract void order(T orderRequest);
}

public abstract class AbstractOrderTR<T extends OrderRequest<?>, R extends BaseSavedInfo> {
    // 使用SaveT接口作为其依赖
    // 用模板指定了参数的类型为R
    protected SaveT<R> save;

    public AbstractOrderTR(SaveT<R> save) {
        this.save = save;
    }

    /**
     * 下单
     */
    public abstract void order(T orderRequest);
}

public abstract class AbstractOrderT<T extends OrderRequest<?>> {
    // 使用SaveT接口作为其依赖
    // 不通过了类模板指定，仅用通配符参数限定，
    protected SaveT<? extends BaseSavedInfo> save; // note 如果实现类中不指定SaveT的类型，则save接口无法使用
    // 原因： 编译器没那么聪明根据子类传入的saveT子对象推断出SaveT模板具体对应哪一个类，只能在这里明确指定或者子类重写

    // 也可以为SaveT<?> 仅通配符不做限制
    // protected SaveT<?> save;

    // 也可以不限制，仅使用SaveT
    // protected SaveT save;

    public AbstractOrderT(SaveT<? extends BaseSavedInfo> save) {
        this.save = save;
    }

    /**
     * 下单
     */
    public abstract void order(T orderRequest);
}

/**
 * 内部下单实现类
 *
 * @author: east
 * @date: 2023/11/24
 */
public class InnerOrder extends AbstractOrder<InnerOrderRequest> {

    // InnerSaveOrder为Save接口实现类
    public InnerOrder(InnerSaveOrder save) {
        super(save);
    }

    //InnerOrderRequest为OrderRequest实现类
    @Override
    public void order(InnerOrderRequest innerOrderRequest) {
        try {

            // 校验等接口调用....

            // InnerBaseSavedInfo为内部渠道需要落表的数据，是BaseSavedInfo的子类
            // 落表  这里save为模板方法
            save.save(new InnerBaseSavedInfo(innerOrderRequest.generateOrderInfo(), "this is inner special message"));

        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    // public static void main(String[] args) {
    //     InnerSaveOrder innerSaveOrder = new InnerSaveOrder();
    //     InnerOrder innerOrder = new InnerOrder(innerSaveOrder);
    //     innerOrder.order(new InnerOrderRequest(BigDecimal.ONE, "innerSerial", "rcvNo"));
    // }

}

/**
 * 内部渠道保存账单
 * Save接口的实现类
 *
 * @author: east
 * @date: 2023/11/24
 */
public class InnerSaveOrder implements Save {

    /**
     * 保存下单数据
     *
     * @param savedInfo 相关信息:账单表，统计表
     */
    @Override
    public <T extends BaseSavedInfo> void save(T savedInfo) {

        // 落表
        System.out.println("内部渠道下单信息开始落表");

        // todo 这里有个很大的问题就是如果不通过强制类型转换无法拿到特定种类的数据
        //        InnerSavedInfo innerSavedInfo=(InnerSavedInfo) savedInfo;
//        System.out.println("内部渠道特有数据获取: "+innerSavedInfo.getSpecialMsg());

        System.out.println(savedInfo.toString());
    }
}

public class OuterOrderTR extends AbstractOrderTR<OuterOrderRequest, OuterBaseSavedInfo> {

    public OuterOrderTR(OuterSaveOrderImp save) {
        super(save);
    }

    @Override
    public void order(OuterOrderRequest outerOrderRequest) {
        try {

            // 校验等逻辑....

            // 落表
            // note 这里通过模板类全量指定
            save.save(new OuterBaseSavedInfo(outerOrderRequest.generateOrderInfo()));

        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    // public static void main(String[] args) {
    //     OuterSaveOrderImp saveOrderAction = new OuterSaveOrderImp();
    //     OuterOrderTR orderAction = new OuterOrderTR(saveOrderAction);
    //     orderAction.order(new OuterOrderRequest(BigDecimal.ONE, "outSerialTR", "rcvNo"));
    // }

}

protected SaveT<OuterBaseSavedInfo> save;

public class OuterOrderT extends AbstractOrderT<OuterOrderRequest> {

    protected SaveT<OuterBaseSavedInfo> save; // note 通配符如果不在模板指定，则只有在这里明确指定，save的方法才能正常调用, 可以将这行去掉试试

    public OuterOrderT(OuterSaveOrderImp save) {
        super(save);
        this.save = save;
    }

    @Override
    public void order(OuterOrderRequest outerOrderRequest) {
        try {

            // 校验等逻辑....

            // 落表
            // 通过父类调用  note: 这里没有通过模板指定（如果也不在成员函数指定的话则会报错，? extends通配只是占位，不指定类型则无法操作
            save.save(new OuterBaseSavedInfo(outerOrderRequest.generateOrderInfo()));

        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    // public static void main(String[] args) {
    //     OuterSaveOrderImp saveOrderAction = new OuterSaveOrderImp();
    //     OuterOrderT orderAction = new OuterOrderT(saveOrderAction);
    //     orderAction.order(new OuterOrderRequest(BigDecimal.ONE, "outSerialT", "rcvNo"));
    // }

}