Openai聊天系统开发文档(v1.0)

<dependency>
    <groupId>com.alipay.sdk</groupId>
    <artifactId>alipay-sdk-java</artifactId>
    <version>4.10.170.ALL</version>
</dependency>

/** 创建的应用ID */
@Value("${fastboot.pay.alipay.app-id}")
private String appId;
/** 自己生成的应用私钥 */
@Value("${fastboot.pay.alipay.private-key}")
private String privateKey;
/** 支付宝提供的支付宝公钥 */
@Value("${fastboot.pay.alipay.alipay-public-key}")
private String alipayPublicKey;
/** 回调地址，需要公网且链接不需要重定向的，如：https://fastboot.shaines.cn/api/myalipay/trade-notify */
@Value("${fastboot.pay.alipay.notify-url}")
private String notifyUrl;

@RequestMapping("/trade-precreate")
@ApiOperation("当面付预下订单")
@ResponseBody
public Result<AlipayTradePrecreateResponseDTO> tradePrecreate(AlipayTradePrecreateRequestDTO requestDTO) {
    AssertUtils.notEmpty(requestDTO.getSubject(), "标题不可以为空");
    AssertUtils.notEmpty(requestDTO.getTotalAmount(), "金额不可以为空");
    AssertUtils.check(requestDTO.getSubject().length() > 50, "标题不可以超过50字");
    AssertUtils.check(requestDTO.getTotalAmount().compareTo(new BigDecimal("0")) <= 0, "金额需要大于0元");
    AssertUtils.check(requestDTO.getTotalAmount().compareTo(new BigDecimal(50)) >= 0, "金额不可以超过50元");
    // 金额保留两位小数
    requestDTO.setTotalAmount(requestDTO.getTotalAmount().setScale(2, BigDecimal.ROUND_HALF_UP));
    // 创建 AlipayClient
    AlipayClient alipayClient = new DefaultAlipayClient(
            "https://openapi.alipay.com/gateway.do",
            appId,
            privateKey,
            "json",
            "UTF-8",
            alipayPublicKey,
            "RSA2");
    AlipayTradePrecreateRequest request = new AlipayTradePrecreateRequest();
    // String outTradeNo = UUID.randomUUID().toString().replace("-", "");
    String orderNo = IDUtil.generate().toString();
    request.setBizContent(String.format("{\n"
                                                + "    \"out_trade_no\": \"%s\", \n"
                                                + "    \"total_amount\": \"%s\", \n"
                                                + "    \"subject\": \"%s\", \n"
                                                + "    \"store_id\": \"JM01\", \n"
                                                + "    \"qr_code_timeout_express\": \"30m\"\n"
                                                + "}",
                                        orderNo,
                                        requestDTO.getTotalAmount(),
                                        requestDTO.getSubject()));
    request.setNotifyUrl(notifyUrl);
    AlipayTradePrecreateResponse response;
    try {
        response = alipayClient.execute(request);
    } catch (AlipayApiException e) {
        throw new BusinessException(String.format("下单失败 错误代码:[%s], 错误信息:[%s]", e.getErrCode(), e.getErrMsg()));
    }
    log.info("AlipayTradePrecreateResponse = {}", response.getBody());
    /*
    {
        "code": "10000", 
        "msg": "Success", 
        "out_trade_no": "815259610498863104", 
        "qr_code": "https://qr.alipay.com/bax09455sq1umiufbxf4503e"
    }
    */
    if (!response.isSuccess()) {
        throw new BusinessException(String.format("下单失败 错误代码:[%s], 错误信息:[%s]", response.getCode(), response.getMsg()));
    }
    // TODO 下单记录保存入库
    // 
    // 返回结果，主要是返回 qr_code，前端根据 qr_code 进行重定向或者生成二维码引导用户支付
    AlipayTradePrecreateResponseDTO responseDTO = new AlipayTradePrecreateResponseDTO();
    responseDTO.setOrderNo(orderNo);
    responseDTO.setQrCode(response.getQrCode());
    return new Result<>(responseDTO);
}

@RequestMapping("/trade-notify")
@ResponseBody
public String tradeNotify(HttpServletRequest request) {
    Map<String, String[]> parameterMap = request.getParameterMap();
    Map<String, String> params = new HashMap<>(32);
    parameterMap.forEach((key, val) -> params.put(key, String.join(",", val)));
    /*
     {
        "gmt_create": "2021-02-24 09:12:57",
        "charset": "UTF-8",
        "seller_email": "272694308@qq.com",
        "subject": "测试",
        "sign": "XyrF+MU+zPIAVKdBGcrpgwpYYaG3uAqk7Y34LDQJ+BHXyBTfRvkq8wEm6MOz2np4GoJ1pkoV1ZzZGKdhoTHrxFAxk2hFvTXs9UoBpyrzV/kuLmC436IHWOe2koTWqTZCWhm+6w3NJWCNwq+nmUjzvLvmQWgSruBBJ/ZLR3cWGwMQleoj1clkc7smVdBKiFpY1oxc8nCOSIgKsyxZZ3Iza0rJKYResR7BRNFhmSI7sOYQyQEr0c8LPTPnyhAWVypQcAhHEkpZIyMbRjG9ayOdhtmI3VLh7Kh5AD9c1/VVT1grHrcucXhkhwBvJndQPDmXxcl/nSwhuSlMttAd9HPL2A==",
        "buyer_id": "2088112022569596",
        "invoice_amount": "0.01",
        "notify_id": "2021022400222091303069591445812598",
        "fund_bill_list": "[{\"amount\":\"0.01\",\"fundChannel\":\"ALIPAYACCOUNT\"}]",
        "notify_type": "trade_status_sync",
        "trade_status": "TRADE_SUCCESS",
        "receipt_amount": "0.01",
        "app_id": "2021002107650269",
        "buyer_pay_amount": "0.01",
        "sign_type": "RSA2",
        "seller_id": "2088122717972675",
        "gmt_payment": "2021-02-24 09:13:03",
        "notify_time": "2021-02-24 09:13:03",
        "version": "1.0",
        "out_trade_no": "def55f2d4076451c948eba010dfc1255",
        "total_amount": "0.01",
        "trade_no": "2021022422001469591437625740",
        "auth_app_id": "2021002107650269",
        "buyer_logon_id": "143***@qq.com",
        "point_amount": "0.00"
    }
    */
    log.info("============>>> /trade-notifyparams:{}", JSON.toJSONString(params));
    // 
    boolean check;
    try {
        // 必须要验签
        check = AlipaySignature.rsaCheckV1(params, alipayPublicKey, "UTF-8", "RSA2");
        log.info("============>>> check: [{}]", check);
    } catch (Exception e) {
        log.warn("tradeNotify exception", e);
        return "failure";
    }
    if (!check) {
        return "rsaCheckV1 = false";
    }
    // TODO 修改下单的订单信息为已支付
    //
    return "success";
}

go get github.com/smartwalle/alipay/v3 

	client, err := alipay.New(alipayConfig.Appid, alipayConfig.PrivateKey, true)
	if err != nil {
		panic(err)
	}
	err = client.LoadAliPayPublicKey(alipayConfig.PublicKey)
	if err != nil {
		panic(err)
	}

<!--cloud-stream-rabbitmq-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-stream-binder-rabbit</artifactId>
    <version>4.0.2</version>
</dependency>

spring:
	  cloud:
      function:
        definition: chat-order-source;chat-order-sink; # 函数名称，对应服务中的注入的Bean  定义消费者，多个用分号分隔，当存在大于1个的消费者时，不定义不会生效
      stream:
        function:
          bindings:
            chat-order-source-out-0: chat-order-dlq-output
            chat-order-sink-in-0: chat-order-dlq-input
        binders: # 需要绑定的rabbitmq的服务信息
          default-binder: # 定义的名称，用于bidding整合    v
            type: rabbit # 消息组件类型
            environment: # 配置rabbitmq连接环境
              spring:
                rabbitmq:
                  addresses: ${RABBIT_ADDRESSES:127.0.0.1:5672} #服务器的地址和端口
                  username: ${RABBIT_USERNAME:root}
                  password: ${RABBIT_PASSWORD:123456}
                  virtual-host: /
                  connection-timeout: 16000
        bindings:
          # 死信队列
          chat-order-dlq-output: # 自定义消息通道的名称
            destination: chat-order-dlq-topic # exchange名称,交换模式默认是topic，创建时同时会创建队列
            content-type: application/json
            group: dlq-group # 消息组
            binder: default-binder # 绑定的binder名称
          chat-order-dlq-input:
            destination: chat-order-dlq-topic  # exchange名称,交换模式默认是topic，创建时同时会创建}队列
            content-type: application/json
            group: dlq-group # 消息组
            binder: default-binder
            consumer:
              max-attempts: 3 # 次数等于1，相当于不重试
              acknowledge-mode: manual  # manual手动确认 ，auto 自动确认
        rabbit:
          bindings:
            # 死信队列
            chat-order-dlq-output:
              producer:
                auto-bind-dlq: true # 为true是开启死信队列
                delayed-exchange: true # 开启延时
            chat-order-dlq-input:
              consumer:
                auto-bind-dlq: true  #是否自动声明DLQ并将其绑定到绑定器DLX
                delayed-exchange: true  #是否将交换声明为Delayed Message Exchange - 需要经纪人上的延迟消息交换插件。x-delayed-type参数设置为exchangeType
                republish-to-dlq: true  # 默认情况下，尝试重试后失败的消息将被拒绝。如果配置了死信队列（DLQ），则RabbitMQ将将失败的消息（未更改）路由到DLQ。如果设置为true，则绑定器将重新发布具有附加头的DLQ的失败消息，包括最终失败的原因的异常消息和堆栈跟踪
                prefetch: 10 # 限制consumer在消费消息时，一次能同时获取的消息数量，默认：1。
                max-concurrency: 20 # 最大并发度
                # requeue-rejected: true   # 消费失败后重写放回队列 可能会导致无线循环
                acknowledge-mode: manual  # manual手动确认 ，auto 自动确认
	

@Component
public record StreamProducer(StreamBridge streamBridge) {
    /**
     * 发送消息
     */
    public boolean sendMessage(String msgText, String bindingName) {
        // 构建消息对象
        StreamMessage messaging = new StreamMessage();
        messaging.setMessageId(UUID.randomUUID().toString());
        messaging.setMessageText(msgText);
        Message<StreamMessage> message = MessageBuilder.withPayload(messaging).build();
        return streamBridge.send(bindingName, message);
    }

    /**
     * 发送延迟消息
     */
    public boolean sendDelayMessage(String msgText, String bindingName, Integer seconds) {
        // 构建消息对象
        StreamMessage messaging = new StreamMessage();
        messaging.setMessageId(UUID.randomUUID().toString());
        messaging.setMessageText(msgText);
        Message<StreamMessage> message = MessageBuilder.withPayload(messaging)
                .setHeader("x-delay", seconds * 1000)
                .build();
        return streamBridge.send(bindingName, message);
    }
}

public interface StreamConsumer {
    Consumer<Message<StreamMessage>> consume();
}

@Configuration
@Slf4j
public class ChatOrderStreamConsumer implements StreamConsumer {
    /**
     * mq接收ackMessage消息/手动ack确认
     */
    @Bean("chat-order-sink")
    public Consumer<Message<StreamMessage>> consume() {
    	// TODO: 逻辑处理
    }
}