添加售后接口 和 回调接口

pom.xml

@@ -65,7 +65,11 @@
             <artifactId>spring-boot-starter-validation</artifactId>
         </dependency>
 
-
+        <!-- mongodb -->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-data-mongodb</artifactId>
+        </dependency>
 
         <!--redis-->
         <dependency>
@@ -96,18 +100,7 @@
             <artifactId>spring-cloud-starter-config</artifactId>
         </dependency>
 
-        <dependency>
-            <groupId>com.mysql</groupId>
-            <artifactId>mysql-connector-j</artifactId>
-            <version>${mysql.version}</version>
-            <scope>runtime</scope>
-        </dependency>
 
-        <dependency>
-            <groupId>com.baomidou</groupId>
-            <artifactId>mybatis-plus-boot-starter</artifactId>
-            <version>${mybatis.version}</version>
-        </dependency>
 
 
     </dependencies>
@@ -127,21 +120,6 @@
 
     <!-- 环境配置 -->
     <profiles>
-        <!-- 开发环境 -->
-        <!--        <profile>-->
-        <!--            <id>dev</id>-->
-        <!--            <activation>-->
-        <!--                <activeByDefault>true</activeByDefault>-->
-        <!--            </activation>-->
-        <!--            <properties>-->
-        <!--                <env>dev</env>-->
-        <!--                <spring.profiles.active>dev</spring.profiles.active>-->
-        <!--            </properties>-->
-        <!--            <build>-->
-        <!--                <finalName>${project.artifactId}-${project.version}-dev</finalName>-->
-        <!--            </build>-->
-        <!--        </profile>-->
-
         <!-- 生产环境 -->
         <profile>
             <id>pro</id>

src/main/java/zs/payment/config/MongoConfig.java

@@ -0,0 +1,32 @@
+package zs.payment.config;
+
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.mongodb.core.MongoTemplate;
+import org.springframework.data.mongodb.core.SimpleMongoClientDatabaseFactory;
+import org.springframework.data.mongodb.core.convert.DefaultDbRefResolver;
+import org.springframework.data.mongodb.core.convert.DefaultMongoTypeMapper;
+import org.springframework.data.mongodb.core.convert.MappingMongoConverter;
+import org.springframework.data.mongodb.core.mapping.MongoMappingContext;
+
+/**
+ * mongodb的配置
+ */
+@Configuration
+public class MongoConfig {
+    @Value("${spring.data.mongodb.uri}")
+    private String uri;
+
+    @Bean(name = "newTemplate")
+    public MongoTemplate newTemplate() {
+        SimpleMongoClientDatabaseFactory factory = new SimpleMongoClientDatabaseFactory(uri);
+        MappingMongoConverter converter = new MappingMongoConverter(new DefaultDbRefResolver(factory), new MongoMappingContext());
+        // Don't save _class to mongo 删除_class 属性的配置
+        converter.setTypeMapper(new DefaultMongoTypeMapper(null));
+        MongoTemplate template = new MongoTemplate(factory, converter);
+        return template;
+    }
+
+
+}

src/main/java/zs/payment/controller/YxSupplyChannelManualController.java

@@ -1,5 +1,6 @@
 package zs.payment.controller;
 
+import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.web.bind.annotation.PostMapping;
@@ -7,12 +8,13 @@ import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
 import com.alibaba.fastjson.JSONObject;
-import zs.payment.req.OrderCheckReq;
-import zs.payment.req.OrderReq;
-import zs.payment.req.ProductDetailReq;
-import zs.payment.dto.OrdersDTO;
-import zs.payment.req.ProductPageReq;
+import zs.payment.dao.OrderCallbackDao;
+import zs.payment.entity.OrderCallback;
+import zs.payment.req.*;
+import zs.payment.entity.Orders;
+import zs.payment.req.aftersales.AfterSalesOrderReq;
 import zs.payment.resp.Result;
+import zs.payment.service.OrdersService;
 import zs.payment.utils.HttpUtil;
 import zs.payment.utils.RedisUtils;
 
@@ -24,7 +26,7 @@ import java.util.Map;
 /**
  * 芸信 供应链平台
  */
-
+@Slf4j
 @RestController
 @RequestMapping("/supply")
 public class YxSupplyChannelManualController {
@@ -40,6 +42,12 @@ public class YxSupplyChannelManualController {
     @Autowired
     private RedisUtils redisUtils;
 
+    @Autowired
+    private OrdersService ordersService;
+
+    @Autowired
+    private OrderCallbackDao callbackDao;
+
     public static final String SUPPLY_TOKEN = "supply:token";
 
     /**
@@ -170,8 +178,77 @@ public class YxSupplyChannelManualController {
 
         return Result.success(respJson.getJSONObject("data"));
     }
+    //仅下单
+    @PostMapping("/orderConfirmOnly")
+    public Result orderConfirmOnly(@Valid @RequestBody OrderReq req){
+        String token = redisUtils.get(SUPPLY_TOKEN);
+        if (token == null || token.isEmpty()) {
+            Result tokenResult = fetchAndCacheToken();
+            if (!tokenResult.isSuccess()) {
+                return tokenResult;
+            }
+            token = (String) tokenResult.getBody().get("token");
+        }
+
+        Map<String, Object> params = new HashMap<>();
+        params.put("spu", req.getSpu());
+        params.put("address", req.getAddress());
+        params.put("order_sn", req.getOrderSn());
+
+        Map<String, String> headers = new HashMap<>();
+        headers.put("x-token", token);
+
+        String resp = HttpUtil.restTemplatePost(prefixUrl + "/supplyapi/app/order/orderConfirmOnly", params, headers);
+
+        JSONObject respJson = JSONObject.parseObject(resp);
+        if (respJson.getIntValue("code") != 0) {
+            return Result.fail(respJson.getString("msg"));
+        }
+
+        List<Orders> orders = JSONObject.parseArray(
+            respJson.getJSONObject("data").getJSONArray("Orders").toJSONString(),
+            Orders.class
+        );
+        log.info("仅下单，存储订单");
+        ordersService.addBatchOrder(orders);
+
+        return Result.success(orders);
+    }
 
-    // 下单
+    //订单支付（单独下单之后使用这个支付）
+    @PostMapping("/orderPayOnly")
+    public Result orderPayOnly(@Valid @RequestBody OrderPayReq req){
+        String token = redisUtils.get(SUPPLY_TOKEN);
+        if (token == null || token.isEmpty()) {
+            Result tokenResult = fetchAndCacheToken();
+            if (!tokenResult.isSuccess()) {
+                return tokenResult;
+            }
+            token = (String) tokenResult.getBody().get("token");
+        }
+
+        Map<String, Object> params = new HashMap<>();
+        params.put("order_sn", req.getOrderSn());
+
+        Map<String, String> headers = new HashMap<>();
+        headers.put("x-token", token);
+
+        String resp = HttpUtil.restTemplatePost(prefixUrl + "/supplyapi/app/order/orderPayOnly", params, headers);
+
+        JSONObject respJson = JSONObject.parseObject(resp);
+        if (respJson.getIntValue("code") != 0) {
+            return Result.fail(respJson.getString("msg"));
+        }
+
+        List<Orders> orders = JSONObject.parseArray(
+            respJson.getJSONObject("data").getJSONArray("Orders").toJSONString(),
+            Orders.class
+        );
+        return Result.success(orders);
+    }
+
+
+    // 生成订单同时支付，如果已生成订单则是直接支付
     @PostMapping("/order")
     public Result order(@Valid @RequestBody OrderReq req) {
         String token = redisUtils.get(SUPPLY_TOKEN);
@@ -186,7 +263,7 @@ public class YxSupplyChannelManualController {
         Map<String, Object> params = new HashMap<>();
         params.put("spu", req.getSpu());
         params.put("address", req.getAddress());
-        params.put("order_sn", req.getOrder_sn());
+        params.put("order_sn", req.getOrderSn());
 
         Map<String, String> headers = new HashMap<>();
         headers.put("x-token", token);
@@ -198,12 +275,131 @@ public class YxSupplyChannelManualController {
             return Result.fail(respJson.getString("msg"));
         }
 
-        List<OrdersDTO> orders = JSONObject.parseArray(
+        List<Orders> orders = JSONObject.parseArray(
                 respJson.getJSONObject("data").getJSONArray("Orders").toJSONString(),
-                OrdersDTO.class
+                Orders.class
         );
-
+        log.info("下单并支付，存储订单");
+        ordersService.addBatchOrder(orders);
         return Result.success(orders);
     }
 
+    // 取消订单
+    @PostMapping("/appCloseOrder")
+    public Result appCloseOrder(@Valid @RequestBody CloseOrderReq req){
+
+        String token = redisUtils.get(SUPPLY_TOKEN);
+        if (token == null || token.isEmpty()) {
+            Result tokenResult = fetchAndCacheToken();
+            if (!tokenResult.isSuccess()) {
+                return tokenResult;
+            }
+            token = (String) tokenResult.getBody().get("token");
+        }
+
+        Map<String, Object> params = new HashMap<>();
+        params.put("order_id", req.getOrderId());
+
+        Map<String, String> headers = new HashMap<>();
+        headers.put("x-token", token);
+
+        String resp = HttpUtil.restTemplatePost(prefixUrl + "/supplyapi/app/order/appCloseOrder", params, headers);
+        JSONObject respJson = JSONObject.parseObject(resp);
+        if (respJson.getIntValue("code") != 0) {
+            return Result.fail(respJson.getString("msg"));
+        }
+        //{
+        //    "body": {
+        //        "MSG": "SUCCESS",
+        //        "CODE": 200,
+        //        "data": {
+        //            "errorOrdersSNs": null,
+        //            "successOrdersSNs": [
+        //                195319850638
+        //            ]
+        //        }
+        //    },
+        //    "success": true
+        //}
+        return Result.success(respJson.getJSONObject("data"));
+    }
+
+    // =======================售后==========================================
+
+    /**
+     * 获取订单支持的售后方式
+     * @param req
+     * @return
+     */
+    @PostMapping("/getAfterSalesTypeNameMap")
+    public Result getAfterSalesTypeNameMap(@Valid @RequestBody AfterSalesOrderReq req){
+
+        String token = redisUtils.get(SUPPLY_TOKEN);
+        if (token == null || token.isEmpty()) {
+            Result tokenResult = fetchAndCacheToken();
+            if (!tokenResult.isSuccess()) {
+                return tokenResult;
+            }
+            token = (String) tokenResult.getBody().get("token");
+        }
+
+        Map<String, Object> params = new HashMap<>();
+        params.put("order_id", req.getOrderId());
+
+        Map<String, String> headers = new HashMap<>();
+        headers.put("x-token", token);
+
+        String resp = HttpUtil.restTemplateGet(prefixUrl + "/supplyapi/app/afterSales/getAfterSalesTypeNameMap", params, headers);
+        JSONObject respJson = JSONObject.parseObject(resp);
+        if (respJson.getIntValue("code") != 0) {
+            return Result.fail(respJson.getString("msg"));
+        }
+
+        return Result.success(respJson.getJSONObject("data"));
+    }
+
+
+    //申请售后
+    @PostMapping("/afterSalesCreate")
+    public Result afterSalesCreate(@Valid @RequestBody AfterSalesOrderReq req){
+        String token = redisUtils.get(SUPPLY_TOKEN);
+        if (token == null || token.isEmpty()) {
+            Result tokenResult = fetchAndCacheToken();
+            if (!tokenResult.isSuccess()) {
+                return tokenResult;
+            }
+            token = (String) tokenResult.getBody().get("token");
+        }
+
+        Map<String, Object> params = new HashMap<>();
+        params.put("order_id", req.getOrderId());
+        params.put("is_received",req.getIsReceived());
+        params.put("order_item_id",req.getOrderItemId());
+
+        Map<String, String> headers = new HashMap<>();
+        headers.put("x-token", token);
+
+        String resp = HttpUtil.restTemplatePost(prefixUrl + "/supplyapi/app/afterSales/create", params, headers);
+        JSONObject respJson = JSONObject.parseObject(resp);
+        if (respJson.getIntValue("code") != 0) {
+            return Result.fail(respJson.getString("msg"));
+        }
+
+        return Result.success(respJson.getJSONObject("data"));
+    }
+
+
+    //回调接口，拿到回调数据后，再对数据做处理
+    @PostMapping("/callback")
+    public Map<String, Object> callback(@Valid @RequestBody Object req) {
+        Map<String, Object> result = new HashMap<>();
+        result.put("code", 0);
+
+        OrderCallback callback=new OrderCallback();
+        callback.setMessage(req);
+        callbackDao.save(callback);
+        return result;
+    }
+
+
 }

src/main/java/zs/payment/dao/MongoDBDao.java

@@ -0,0 +1,199 @@
+package zs.payment.dao;
+
+import com.alibaba.fastjson.JSONObject;
+import com.mongodb.client.result.DeleteResult;
+import com.mongodb.client.result.UpdateResult;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.data.geo.GeoResults;
+import org.springframework.data.mongodb.core.MongoTemplate;
+import org.springframework.data.mongodb.core.aggregation.Aggregation;
+import org.springframework.data.mongodb.core.aggregation.AggregationResults;
+import org.springframework.data.mongodb.core.query.Criteria;
+import org.springframework.data.mongodb.core.query.NearQuery;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.data.mongodb.core.query.Update;
+
+import javax.annotation.Resource;
+import java.util.List;
+
+@Slf4j
+public abstract class MongoDBDao<T> {
+    @Resource(name = "newTemplate")
+    private MongoTemplate mongoTemplate;
+
+    /***
+     * 保存一个对象
+     * @param t
+     */
+    public T save(T t) {
+        return this.mongoTemplate.save(t);
+    }
+
+    /**
+     * 批量插入
+     *
+     * @param t
+     */
+    public List<T> insertBatch(List<T> t) {
+        return (List<T>) mongoTemplate.insert(t, getEntityClass());
+    }
+
+    /**
+     * 反射获取泛型类型
+     *
+     * @return
+     */
+    protected abstract Class<T> getEntityClass();
+
+    /***
+     * 根据id从几何中查询对象
+     * @param id
+     * @return
+     */
+    public T queryById(String id) {
+        Query query = new Query(Criteria.where("_id").is(id));
+        return this.mongoTemplate.findOne(query, this.getEntityClass());
+    }
+
+    /***
+     * 删除对象
+     * @param t
+     * @return
+     */
+    public int delete(T t) {
+        return (int) this.mongoTemplate.remove(t).getDeletedCount();
+    }
+
+    /**
+     * 根据id删除
+     *
+     * @param id
+     */
+    public void deleteById(String id) {
+        Criteria criteria = Criteria.where("_id").is(id);
+        if (null != criteria) {
+            Query query = new Query(criteria);
+            T obj = this.mongoTemplate.findOne(query, this.getEntityClass());
+            log.info("-------------->MongoDB deleteById start");
+            if (obj != null) {
+                this.delete(obj);
+            }
+        }
+    }
+
+    public int delete(Query query) {
+        return (int) mongoTemplate.remove(query, getEntityClass()).getDeletedCount();
+    }
+
+
+    /**
+     * 根据条件查询对象
+     *
+     * @param query
+     * @return
+     */
+    public T queryOne(Query query) {
+        return mongoTemplate.findOne(query, getEntityClass());
+    }
+
+
+    /**
+     * 根据mongo条件查询列表
+     *
+     * @param query
+     * @return
+     */
+    public List<T> queryList(Query query) {
+        return mongoTemplate.find(query, this.getEntityClass());
+    }
+
+    /**
+     * 更新
+     *
+     * @param query  查询条件
+     * @param update 要更新的数据
+     */
+    public long updateFirst(Query query, Update update) {
+        UpdateResult result = mongoTemplate.updateFirst(query, update, getEntityClass());
+        return result.getModifiedCount();
+    }
+
+    /**
+     * 如果查询到符合的文档就更新，如果没有就根据查询条件创建一个新的文档，就像findAndModifyElseCreate()
+     *
+     * @param query  查询条件
+     * @param update 更新
+     * @return
+     */
+    public long upsert(Query query, Update update) {
+        UpdateResult result = mongoTemplate.upsert(query, update, getEntityClass());
+
+        return result.getModifiedCount();
+    }
+
+    /**
+     * 批量更新
+     *
+     * @param query
+     * @param update
+     * @return
+     */
+    public long batchUpdate(Query query, Update update) {
+        UpdateResult result = mongoTemplate.updateMulti(query, update, getEntityClass());
+        return result.getModifiedCount();
+    }
+
+    /**
+     * 查询数量
+     *
+     * @param query
+     * @return
+     */
+    public long count(Query query) {
+        return mongoTemplate.count(query, this.getEntityClass());
+    }
+
+    /**
+     * 批量删除
+     *
+     * @param query
+     * @return
+     */
+    public long deleteBatch(Query query) {
+        DeleteResult result = mongoTemplate.remove(query, this.getEntityClass());
+        return result.getDeletedCount();
+    }
+
+    /**
+     * 管道查询
+     * @param agg
+     * @return
+     */
+    public AggregationResults<JSONObject> aggregate(Aggregation agg) {
+        return mongoTemplate.aggregate(agg, getEntityClass(), JSONObject.class);
+    }
+
+    /**
+     * 管道查询
+     * @param aggregation 条件参数
+     * @param resultClass 返回类对象
+     * @param <U> 返回类型
+     * @return
+     */
+    public <U> List<U> aggregate(Aggregation aggregation,Class<U> resultClass){
+        AggregationResults<U> results = mongoTemplate.aggregate(aggregation, this.getEntityClass(), resultClass);
+        return results.getMappedResults();
+    }
+
+    /**
+     * 管道查询，返回原始 Document（用于需要手动处理 _id 类型转换的场景）
+     */
+    public AggregationResults<org.bson.Document> aggregateRaw(Aggregation agg) {
+        return mongoTemplate.aggregate(agg, getEntityClass(), org.bson.Document.class);
+    }
+
+    public GeoResults<T> geoNear(NearQuery nearQuery) {
+        return mongoTemplate.geoNear(nearQuery, this.getEntityClass());
+    }
+
+}

src/main/java/zs/payment/dao/OrderCallbackDao.java

@@ -0,0 +1,12 @@
+package zs.payment.dao;
+
+import org.springframework.stereotype.Repository;
+import zs.payment.entity.OrderCallback;
+
+@Repository
+public class OrderCallbackDao extends MongoDBDao<OrderCallback>{
+    @Override
+    protected Class<OrderCallback> getEntityClass() {
+        return null;
+    }
+}

src/main/java/zs/payment/dao/OrderDao.java

@@ -0,0 +1,12 @@
+package zs.payment.dao;
+
+import org.springframework.stereotype.Repository;
+import zs.payment.entity.Orders;
+
+@Repository
+public class OrderDao extends MongoDBDao<Orders> {
+    @Override
+    protected Class<Orders> getEntityClass() {
+        return Orders.class;
+    }
+}

src/main/java/zs/payment/dto/OrderItemDTO.java

@@ -11,7 +11,7 @@ import java.util.List;
 @NoArgsConstructor
 public class OrderItemDTO {
 
-    // 子订单id
+    // 子订单id，用于售后退款
     private Integer id;
     // 创建时间
     private Long created_at;

src/main/java/zs/payment/entity/OrderCallback.java

@@ -0,0 +1,29 @@
+package zs.payment.entity;
+
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import org.springframework.data.mongodb.core.mapping.Document;
+
+
+@Document(collection = "order_call_back")
+@Setter
+@Getter
+@NoArgsConstructor
+public class OrderCallback {
+
+    private String id;
+    // 消息类型
+    private String message_type;
+
+    // 订单编号
+//    @NotBlank(message = "order_sn不能为空")
+    private String order_sn;
+
+    // 签名
+//    @NotBlank(message = "member_sign不能为空")
+    private String member_sign;
+
+    private Object message;
+
+}

src/main/java/zs/payment/dto/OrdersDTO.java

@@ -1,15 +1,16 @@
-package zs.payment.dto;
+package zs.payment.entity;
 
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 import lombok.Setter;
+import zs.payment.dto.*;
 
 import java.util.List;
 
 @Setter
 @Getter
 @NoArgsConstructor
-public class OrdersDTO {
+public class Orders {
 
     // 订单id
     private Integer id;
@@ -17,7 +18,7 @@ public class OrdersDTO {
     private Long created_at;
     // 修改时间
     private Long updated_at;
-    // 订单编号
+    // 订单编号（主要的）
     private Long order_sn;
     // 第三方订单号
     private String third_order_sn;
@@ -31,7 +32,7 @@ public class OrdersDTO {
     private String key;
     // 标题
     private String title;
-    // 订单状态
+    // 订单状态  0待支付  1待发货 2已发货 3完成
     private Integer status;
     // 订单总金额(分)
     private Integer amount;

src/main/java/zs/payment/req/CallbackReq.java

@@ -0,0 +1,25 @@
+package zs.payment.req;
+
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+import javax.validation.constraints.NotBlank;
+
+@Setter
+@Getter
+@NoArgsConstructor
+public class CallbackReq {
+
+    // 消息类型
+    @NotBlank(message = "message_type不能为空")
+    private String message_type;
+
+    // 订单编号
+//    @NotBlank(message = "order_sn不能为空")
+    private String order_sn;
+
+    // 签名
+//    @NotBlank(message = "member_sign不能为空")
+    private String member_sign;
+}

src/main/java/zs/payment/req/CloseOrderReq.java

@@ -0,0 +1,16 @@
+package zs.payment.req;
+
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Setter
+@Getter
+@NoArgsConstructor
+public class CloseOrderReq {
+    //中台订单id（建议使用这个） ,两个参数二选一
+    private Integer orderId;
+
+    //第三方订单号（提交订单使用的订单号）,两个参数二选一
+    private String thirdOrderSn;
+}

src/main/java/zs/payment/req/OrderPayReq.java

@@ -0,0 +1,15 @@
+package zs.payment.req;
+
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+import javax.validation.constraints.NotBlank;
+
+@Setter
+@Getter
+@NoArgsConstructor
+public class OrderPayReq {
+    @NotBlank(message = "第三方订单编号不能为空")
+    private String orderSn;
+}

src/main/java/zs/payment/req/OrderReq.java

@@ -12,5 +12,5 @@ import javax.validation.constraints.NotBlank;
 public class OrderReq extends OrderCheckReq {
 
     @NotBlank(message = "第三方单号不能为空")
-    private String order_sn;
-}
+    private String orderSn;
+}

src/main/java/zs/payment/req/aftersales/AfterSalesOrderReq.java

@@ -0,0 +1,22 @@
+package zs.payment.req.aftersales;
+
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+import javax.validation.constraints.NotNull;
+
+@Setter
+@Getter
+@NoArgsConstructor
+public class AfterSalesOrderReq {
+    //中台订单id（建议使用这个）
+    @NotNull(message = "id不能为空")
+    private Integer orderId;
+    //是否收到货 1是0否
+    @NotNull(message = "填写收货")
+    private Integer isReceived;
+    //订单详情的order_items中的id
+    @NotNull(message = "子订单id不能为空")
+    private Integer orderItemId;
+}

src/main/java/zs/payment/service/OrdersService.java

@@ -0,0 +1,12 @@
+package zs.payment.service;
+
+import zs.payment.entity.Orders;
+
+import java.util.List;
+
+public interface OrdersService {
+
+    void addOrder(Orders order) ;
+
+    void addBatchOrder(List<Orders> ordersList);
+}

src/main/java/zs/payment/service/impl/OrdersServiceImpl.java

@@ -0,0 +1,28 @@
+package zs.payment.service.impl;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import zs.payment.dao.OrderDao;
+import zs.payment.entity.Orders;
+import zs.payment.service.OrdersService;
+
+import java.util.List;
+
+@Service
+public class OrdersServiceImpl implements OrdersService {
+
+    @Autowired
+    private  OrderDao orderDao;
+
+
+
+    @Override
+    public void addOrder(Orders order) {
+        orderDao.save(order);
+    }
+
+    @Override
+    public void addBatchOrder(List<Orders> ordersList) {
+        orderDao.insertBatch(ordersList);
+    }
+}

src/main/java/zs/payment/utils/HttpUtil.java

@@ -69,48 +69,59 @@ public class HttpUtil {
         }
     }
 
-
     /**
-     * post 请求，请求头=application/json
+     * get请求带token，参数入body，json
      * @param url
      * @param params
+     * @param extraHeaders
      * @return
      */
-    public static String restTemplatePost(String url, Map<String, Object> params) {
+    public static String restTemplateGet(String url, Map<String, Object> params, Map<String, String> extraHeaders) {
         try {
             // 创建忽略SSL验证的RestTemplate
-            TrustStrategy acceptingTrustStrategy = (chain, authType) -> true;
+            TrustStrategy acceptingTrustStrategy = new TrustStrategy() {
+                @Override
+                public boolean isTrusted(java.security.cert.X509Certificate[] chain, String authType) {
+                    return true;
+                }
+            };
             SSLContext sslContext = SSLContexts.custom().loadTrustMaterial(null, acceptingTrustStrategy).build();
             SSLConnectionSocketFactory connectionSocketFactory = new SSLConnectionSocketFactory(sslContext, NoopHostnameVerifier.INSTANCE);
             HttpClient httpClient = HttpClients.custom().setSSLSocketFactory(connectionSocketFactory).build();
             HttpComponentsClientHttpRequestFactory factory = new HttpComponentsClientHttpRequestFactory(httpClient);
             RestTemplate restTemplate = new RestTemplate(factory);
+            // 构建URL
+            UriComponentsBuilder uriBuilder = UriComponentsBuilder.fromHttpUrl(url);
+            if (params != null) {
+                for (Map.Entry<String, Object> entry : params.entrySet()) {
+                    String key = entry.getKey();
+                    Object value = entry.getValue();
+                    if (key != null && value != null) {
+                        uriBuilder.queryParam(key, value.toString());
+                    }
+                }
+            }
 
-            // 配置UTF-8编码的消息转换器
-            restTemplate.getMessageConverters().removeIf(converter -> converter instanceof StringHttpMessageConverter);
-            restTemplate.getMessageConverters().add(0, new StringHttpMessageConverter(StandardCharsets.UTF_8));
+            String finalUrl = uriBuilder.toUriString();
 
-            // 设置请求头
             HttpHeaders headers = new HttpHeaders();
             headers.setContentType(MediaType.APPLICATION_JSON);
-            headers.setAcceptCharset(Collections.singletonList(StandardCharsets.UTF_8)); // 添加Accept-Charset，解决中文乱码问题
-
-            // 将参数转换为JSON字符串
-            String jsonBody = new JSONObject(params).toJSONString();
-            log.info("POST_URL====>{}, body====>{}", url, jsonBody);
-
-            HttpEntity<String> request = new HttpEntity<>(jsonBody, headers);
+            headers.setAcceptCharset(Collections.singletonList(StandardCharsets.UTF_8));
+            if (extraHeaders != null) {
+                extraHeaders.forEach(headers::set);
+            }
+            HttpEntity<String> request = new HttpEntity<>(headers);
 
             ResponseEntity<String> rsp = restTemplate.exchange(
-                url,
-                HttpMethod.POST,
+                finalUrl,
+                HttpMethod.GET,
                 request,
                 String.class
             );
             return rsp.getBody();
 
         } catch (Exception e) {
-            log.error("HTTP POST请求失败: {}", e.getMessage());
+            log.error("HTTP请求失败: {}", e.getMessage());
             throw new RuntimeException("网络请求异常", e);
         }
     }
@@ -154,4 +165,51 @@ public class HttpUtil {
             throw new RuntimeException("网络请求异常", e);
         }
     }
+
+
+
+    /**
+     * post 请求，请求头=application/json
+     * @param url
+     * @param params
+     * @return
+     */
+    public static String restTemplatePost(String url, Map<String, Object> params) {
+        try {
+            // 创建忽略SSL验证的RestTemplate
+            TrustStrategy acceptingTrustStrategy = (chain, authType) -> true;
+            SSLContext sslContext = SSLContexts.custom().loadTrustMaterial(null, acceptingTrustStrategy).build();
+            SSLConnectionSocketFactory connectionSocketFactory = new SSLConnectionSocketFactory(sslContext, NoopHostnameVerifier.INSTANCE);
+            HttpClient httpClient = HttpClients.custom().setSSLSocketFactory(connectionSocketFactory).build();
+            HttpComponentsClientHttpRequestFactory factory = new HttpComponentsClientHttpRequestFactory(httpClient);
+            RestTemplate restTemplate = new RestTemplate(factory);
+
+            // 配置UTF-8编码的消息转换器
+            restTemplate.getMessageConverters().removeIf(converter -> converter instanceof StringHttpMessageConverter);
+            restTemplate.getMessageConverters().add(0, new StringHttpMessageConverter(StandardCharsets.UTF_8));
+
+            // 设置请求头
+            HttpHeaders headers = new HttpHeaders();
+            headers.setContentType(MediaType.APPLICATION_JSON);
+            headers.setAcceptCharset(Collections.singletonList(StandardCharsets.UTF_8)); // 添加Accept-Charset，解决中文乱码问题
+
+            // 将参数转换为JSON字符串
+            String jsonBody = new JSONObject(params).toJSONString();
+            log.info("POST_URL====>{}, body====>{}", url, jsonBody);
+
+            HttpEntity<String> request = new HttpEntity<>(jsonBody, headers);
+
+            ResponseEntity<String> rsp = restTemplate.exchange(
+                url,
+                HttpMethod.POST,
+                request,
+                String.class
+            );
+            return rsp.getBody();
+
+        } catch (Exception e) {
+            log.error("HTTP POST请求失败: {}", e.getMessage());
+            throw new RuntimeException("网络请求异常", e);
+        }
+    }
 }

src/main/resources/application-pro.yml

@@ -1,49 +1,8 @@
 spring:
-    kafka:
-        # ============== 生产者配置 ==============
-        producer:
-            bootstrap-servers: 172.17.240.140:9092,172.17.240.141:9092  # Kafka 3.1.2 KRaft地址
-            key-serializer: org.apache.kafka.common.serialization.StringSerializer
-            value-serializer: org.apache.kafka.common.serialization.StringSerializer
-            # 可选：提高可靠性
-            acks: all
-            retries: 3
-
-        # ============== 消费者配置 ==============
-        #172.17.240.132:9092,172.17.240.140:9092,172.17.240.141:9092
-        consumer:
-            bootstrap-servers: 172.17.240.140:9092,172.17.240.141:9092  # 同上
-            key-deserializer: org.apache.kafka.common.serialization.StringDeserializer
-            value-deserializer: org.apache.kafka.common.serialization.StringDeserializer
-            #            group-id: store-group  # 消费者组，同一组内负载均衡
-            auto-offset-reset: earliest  # 无偏移量时从最早开始
-            enable-auto-commit: true  # 自动提交偏移量
-
-        # ============== 监听器容器配置 ==============
-        listener:
-            # 当使用批量消费时改为 BATCH
-            type: single
-
     data:
         mongodb:
-            uri: mongodb://moblie_cloud:123456@dds-2ze39a292a3addd41.mongodb.rds.aliyuncs.com:3717,dds-2ze39a292a3addd42.mongodb.rds.aliyuncs.com:3717,dds-2ze39a292a3addd43.mongodb.rds.aliyuncs.com:3717/moblie_cloud?replicaSet=mgset-32910145&minPoolSize=2&maxPoolSize=10
-
-    datasource:
-        driver-class-name: com.mysql.cj.jdbc.Driver #数据源配置
-        url: jdbc:mysql://rm-2zelpi3n5442058bq.mysql.rds.aliyuncs.com:3306/moblie_cloud_online?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true&failOverReadOnly=false
-        username: mob_on
-        password: Mo11@BL7i!@
-        hikari:
-            maximum-pool-size: 20      # 适合中等并发量的应用，既保证了响应速度，又不会过度占用数据库资源
-            minimum-idle: 10            # 通常设置为maximum-pool-size的一半
-            connection-timeout: 30000   # 30秒等待时间足够
-            idle-timeout: 600000        # 10分钟空闲可接受
-            max-lifetime: 1800000       # 30分钟防止连接泄露
-
+            uri: mongodb://pay:pay2026@dds-2zedd8d70bde6e541.mongodb.rds.aliyuncs.com:3717,dds-2zedd8d70bde6e542.mongodb.rds.aliyuncs.com:3717/pay_supply
 
-kafka:
-    topic:
-        name: batch-store
 
 pay:
     redis: