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"));
    // }

}

@Component
@Slf4j
public class RequestModifyFilter implements GlobalFilter, Ordered {
    @Autowired
    private ModifyRequestBodyGatewayFilterFactory modifyRequestBodyFilter;
    @Autowired
    private JsonRequestBodyRewriteService jsonRequestBodyRewriteService;

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        MediaType mediaType = exchange.getRequest().getHeaders().getContentType();
        if (MediaType.APPLICATION_json.isCompatibleWith(mediaType)) {
            // 纯json报文处理逻辑
            return modifyRequestBodyFilter
                    .apply(
                            new ModifyRequestBodyGatewayFilterFactory.Config()
                                    .setRewriteFunction(byte[].class, byte[].class, jsonRequestBodyRewriteService))
                    .filter(exchange, chain);
        } else {
            return filter(exchange, chain);
        }

    }

    @Override
    public int getOrder() {
        return OrderConstant.REQUEST_MODIFY_FILTER.getOrder();
    }
}

@Service
@Slf4j
public class JsonRequestBodyRewriteService implements RewriteFunction<byte[], byte[]> {
    @Override
    public Publisher<byte[]> apply(ServerWebExchange exchange, byte[] body) {
        jsonObject request = jsonUtil.parseObj(body);
        log.info("原始报文:{}", request.toString());
        try {
            request.set("empId", "2345");
            request.set("department", "Engineering");

            log.info("修改后报文:{}", request);
            return Mono.just(request.toString().getBytes());
        } catch (Exception e) {
            log.error("修改报文时出错",e);
            throw e;
        }
    }
}

@Component
@Slf4j
public class RequestModifyFilter implements GlobalFilter, Ordered {
    @Autowired
    private ModifyRequestBodyGatewayFilterFactory modifyRequestBodyFilter;
    @Autowired
    private JsonRequestBodyRewriteService jsonRequestBodyRewriteService;
    @Autowired
    private FormDataRequestBodyRewriteService formDataRequestBodyRewriteService;

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        MediaType mediaType = exchange.getRequest().getHeaders().getContentType();
        if (MediaType.APPLICATION_JSON.isCompatibleWith(mediaType)) {
            // 纯json报文处理逻辑
            return modifyRequestBodyFilter
                    .apply(
                            new ModifyRequestBodyGatewayFilterFactory.Config()
                                    .setRewriteFunction(byte[].class, byte[].class, jsonRequestBodyRewriteService))
                    .filter(exchange, chain);
        } else if (MediaType.MULTIPART_FORM_DATA.isCompatibleWith(mediaType)) {
            // form表单数据处理
            return modifyRequestBodyFilter
                    .apply(
                            new ModifyRequestBodyGatewayFilterFactory.Config()
                                    .setRewriteFunction(byte[].class, byte[].class, formDataRequestBodyRewriteService))
                    .filter(exchange, chain);
        } else {
            return filter(exchange, chain);
        }

    }

    @Override
    public int getOrder() {
        return OrderConstant.REQUEST_MODIFY_FILTER.getOrder();
    }
}

@Service
@Slf4j
public class FormDataRequestBodyRewriteService implements RewriteFunction<byte[], byte[]> {
    private final String BOUNDARY_PREFIX_IN_CONTENT_TYPE = "----WebKitFormBoundary";
    private final String BOUNDARY_PREFIX_IN_FORM_DATA = "------WebKitFormBoundary";
    private final String BOUNDARY_SUFFIX = "--\r\n";

    @Override
    public Publisher<byte[]> apply(ServerWebExchange exchange, byte[] body) {
        String finalResultString = "";

        // 将表单转为字符串格式从而根据boundary分割表单数据。注意这里不能用默认编码
        String request = StrUtil.str(body, StandardCharsets.ISO_8859_1);

        // 获取boundary的随机字符信息
        String contentType = exchange.getRequest().getHeaders().getContentType().toString();
        String randomStr = contentType.substring(contentType.indexOf(BOUNDARY_PREFIX_IN_CONTENT_TYPE) + BOUNDARY_PREFIX_IN_CONTENT_TYPE.length());

        // 这里和前端约定json数据的表单key为json
        String keyPart = "^\r\nContent-Disposition: form-data; name=\"json\"";
        Pattern r = Pattern.compile(keyPart);

        // 根据表单内分割线进行分割。并通过关键段落keyPart来找到目标json数据
        String[] split = request.split(BOUNDARY_PREFIX_IN_FORM_DATA + randomStr);
        for (int x = 0; x < split.length - 1; x++) {
            Matcher m = r.matcher(split[x]);
            if (m.find()) {
                // 找到了json报文部分数据
                String originalJsonString = split[x];

                // 找到 JSON 数据的起始和结束位置
                int startIndex = originalJsonString.indexOf("{\"");
                int endIndex = originalJsonString.indexOf("\"}") + 2;
                // 提取 JSON 数据
                String jsonData = originalJsonString.substring(startIndex, endIndex);
                log.info("原始报文为：{}", jsonData);

                JSONObject jsonObject = JSONUtil.parseObj(jsonData);
                jsonObject.set("empId", "2345");
                jsonObject.set("department", "Engineering");
                String modifiedString = originalJsonString.substring(0, startIndex) + jsonObject + originalJsonString.substring(endIndex);
                log.info("修改后报文为：{}", modifiedString);

                // 重新组装split数组
                finalResultString = finalResultString + modifiedString + BOUNDARY_PREFIX_IN_FORM_DATA + randomStr;
            } else {
                // 重组表单数据
                finalResultString = finalResultString + split[x] + BOUNDARY_PREFIX_IN_FORM_DATA + randomStr;
            }
        }

        // 补上最后一截数据
        finalResultString = finalResultString + BOUNDARY_SUFFIX;

        return Mono.just(finalResultString.getBytes(StandardCharsets.ISO_8859_1));
    }
}