Merge branch 'feature/test'

# Conflicts:
#	kmall-manager/src/main/resources/conf/db.properties

kmall-admin/src/main/java/com/kmall/admin/config/datasource/DataSourceConfig.java

@@ -0,0 +1,122 @@
+package com.kmall.admin.config.datasource;
+
+import com.alibaba.druid.filter.Filter;
+import com.alibaba.druid.filter.stat.StatFilter;
+import com.alibaba.druid.pool.DruidDataSource;
+import com.alibaba.druid.wall.WallConfig;
+import com.alibaba.druid.wall.WallFilter;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.PropertySource;
+import org.springframework.core.env.Environment;
+import org.springframework.util.StringUtils;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * @author lhm
+ * @createDate 2021-12-15
+ */
+@Configuration
+@PropertySource(value = {"classpath:conf/db.properties"})
+public class DataSourceConfig {
+
+    @Autowired
+    private Environment environment;
+
+    @Bean
+    public DataSourceProperties dataSourceProperties() {
+        DataSourceProperties dataSourceProperties = new DataSourceProperties();
+        String env = environment.getProperty("jdbc.env");
+        String url = environment.getProperty(String.format("jdbc.%s.url", env));
+        String username = environment.getProperty(String.format("jdbc.%s.username", env));
+        String password = environment.getProperty(String.format("jdbc.%s.password", env));
+        String initialSize = environment.getProperty("jdbc.initialSize");
+        String maxActive = environment.getProperty("jdbc.maxActive");
+        String minPoolSize = environment.getProperty("jdbc.minPoolSize");
+        String maxIdleTime = environment.getProperty("jdbc.maxIdleTime");
+        String idleConnectionTestPeriod = environment.getProperty("jdbc.idleConnectionTestPeriod");
+        String driver = environment.getProperty("jdbc.driver");
+        String idleTimeout = environment.getProperty("jdbc.idleTimeout");
+        String maxLifetime = environment.getProperty("jdbc.maxLifetime");
+        String connectionTimeout = environment.getProperty("jdbc.connectionTimeout");
+        String maximumPoolSize = environment.getProperty("jdbc.maximumPoolSize");
+        String validationTimeout = environment.getProperty("jdbc.validationTimeout");
+
+        dataSourceProperties.setEnv(env);
+        dataSourceProperties.setUrl(url);
+        dataSourceProperties.setUsername(username);
+        dataSourceProperties.setPassword(password);
+        // 通用配置
+        dataSourceProperties.setInitialSize(StringUtils.isEmpty(initialSize) ? 5 : Integer.parseInt(initialSize));
+        dataSourceProperties.setMaxActive(StringUtils.isEmpty(maxActive) ? 30 : Integer.parseInt(maxActive));
+        dataSourceProperties.setMinPoolSize(StringUtils.isEmpty(minPoolSize) ? 2 : Integer.parseInt(minPoolSize));
+        dataSourceProperties.setMaxIdleTime(StringUtils.isEmpty(maxIdleTime) ? 30000 : Integer.parseInt(maxIdleTime));
+        dataSourceProperties.setIdleConnectionTestPeriod(StringUtils.isEmpty(idleConnectionTestPeriod) ? 100 : Integer.parseInt(idleConnectionTestPeriod));
+        dataSourceProperties.setDriver(driver);
+        dataSourceProperties.setIdleTimeout(StringUtils.isEmpty(idleTimeout) ? 400000L : Long.parseLong(idleTimeout));
+        dataSourceProperties.setMaxLifetime(StringUtils.isEmpty(maxLifetime) ? 500000L : Long.parseLong(maxLifetime));
+        dataSourceProperties.setConnectionTimeout(StringUtils.isEmpty(connectionTimeout) ? 5000L : Long.parseLong(connectionTimeout));
+        dataSourceProperties.setMaximumPoolSize(StringUtils.isEmpty(maximumPoolSize) ? 5 : Integer.parseInt(maximumPoolSize));
+        dataSourceProperties.setValidationTimeout(StringUtils.isEmpty(validationTimeout) ? 30L : Long.parseLong(validationTimeout));
+
+        return dataSourceProperties;
+    }
+
+    @Bean(initMethod = "init", destroyMethod = "close")
+    public DruidDataSource dataSource(DataSourceProperties dataSourceProperties,
+                                      StatFilter statFilter,
+                                      WallFilter wallFilter) {
+        DruidDataSource druidDataSource = new DruidDataSource();
+        druidDataSource.setUrl(dataSourceProperties.getUrl());
+        druidDataSource.setUsername(dataSourceProperties.getUsername());
+        druidDataSource.setPassword(dataSourceProperties.getPassword());
+        druidDataSource.setInitialSize(dataSourceProperties.getInitialSize());
+        druidDataSource.setMaxActive(dataSourceProperties.getMaxActive());
+        List<Filter> filters = new ArrayList<>();
+        filters.add(statFilter);
+        filters.add(wallFilter);
+        druidDataSource.setProxyFilters(filters);
+        druidDataSource.setConnectionInitSqls(Collections.singleton("set names utf8mb4;"));
+        // 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
+        druidDataSource.setTimeBetweenEvictionRunsMillis(60000);
+        // 配置一个连接在池中最小生存的时间，单位是毫秒
+        druidDataSource.setMinEvictableIdleTimeMillis(300000);
+        // 建议配置为true，不影响性能，并且保证安全性。申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效
+        druidDataSource.setTestWhileIdle(true);
+        // 指定每个连接上PSCache的大小
+        druidDataSource.setMaxPoolPreparedStatementPerConnectionSize(20);
+        return druidDataSource;
+    }
+
+    @Bean
+    public StatFilter statFilter() {
+        StatFilter statFilter = new StatFilter();
+        statFilter.setSlowSqlMillis(1000);
+        statFilter.setLogSlowSql(true);
+        statFilter.setMergeSql(true);
+        return statFilter;
+    }
+
+    @Bean
+    public WallFilter wallFilter(WallConfig wallConfig) {
+        WallFilter wallFilter = new WallFilter();
+        wallFilter.setDbType("mysql");
+        wallFilter.setConfig(wallConfig);
+        return wallFilter;
+    }
+
+    /**
+     * 过滤永真条件 防止注入
+     */
+    @Bean
+    public WallConfig wallConfig() {
+        WallConfig wallConfig = new WallConfig();
+        wallConfig.setMultiStatementAllow(true);
+        return wallConfig;
+    }
+
+}

kmall-admin/src/main/java/com/kmall/admin/config/datasource/DataSourceProperties.java

@@ -0,0 +1,158 @@
+package com.kmall.admin.config.datasource;
+
+/**
+ * @author lhm
+ * @createDate 2021-12-15
+ */
+public class DataSourceProperties {
+
+    private String env;
+
+    private String url;
+
+    private String username;
+
+    private String password;
+
+    private Integer initialSize;
+
+    private Integer maxActive;
+
+    private Integer minPoolSize;
+
+    private Integer maxIdleTime;
+
+    private Integer idleConnectionTestPeriod;
+
+    private String driver;
+
+    private Long idleTimeout;
+
+    private Long maxLifetime;
+
+    private Long connectionTimeout;
+
+    private Integer maximumPoolSize;
+
+    private Long validationTimeout;
+
+    public String getEnv() {
+        return env;
+    }
+
+    public void setEnv(String env) {
+        this.env = env;
+    }
+
+    public String getUrl() {
+        return url;
+    }
+
+    public void setUrl(String url) {
+        this.url = url;
+    }
+
+    public String getUsername() {
+        return username;
+    }
+
+    public void setUsername(String username) {
+        this.username = username;
+    }
+
+    public String getPassword() {
+        return password;
+    }
+
+    public void setPassword(String password) {
+        this.password = password;
+    }
+
+    public Integer getInitialSize() {
+        return initialSize;
+    }
+
+    public void setInitialSize(Integer initialSize) {
+        this.initialSize = initialSize;
+    }
+
+    public Integer getMaxActive() {
+        return maxActive;
+    }
+
+    public void setMaxActive(Integer maxActive) {
+        this.maxActive = maxActive;
+    }
+
+    public Integer getMinPoolSize() {
+        return minPoolSize;
+    }
+
+    public void setMinPoolSize(Integer minPoolSize) {
+        this.minPoolSize = minPoolSize;
+    }
+
+    public Integer getMaxIdleTime() {
+        return maxIdleTime;
+    }
+
+    public void setMaxIdleTime(Integer maxIdleTime) {
+        this.maxIdleTime = maxIdleTime;
+    }
+
+    public Integer getIdleConnectionTestPeriod() {
+        return idleConnectionTestPeriod;
+    }
+
+    public void setIdleConnectionTestPeriod(Integer idleConnectionTestPeriod) {
+        this.idleConnectionTestPeriod = idleConnectionTestPeriod;
+    }
+
+    public String getDriver() {
+        return driver;
+    }
+
+    public void setDriver(String driver) {
+        this.driver = driver;
+    }
+
+    public Long getIdleTimeout() {
+        return idleTimeout;
+    }
+
+    public void setIdleTimeout(Long idleTimeout) {
+        this.idleTimeout = idleTimeout;
+    }
+
+    public Long getMaxLifetime() {
+        return maxLifetime;
+    }
+
+    public void setMaxLifetime(Long maxLifetime) {
+        this.maxLifetime = maxLifetime;
+    }
+
+    public Long getConnectionTimeout() {
+        return connectionTimeout;
+    }
+
+    public void setConnectionTimeout(Long connectionTimeout) {
+        this.connectionTimeout = connectionTimeout;
+    }
+
+    public Integer getMaximumPoolSize() {
+        return maximumPoolSize;
+    }
+
+    public void setMaximumPoolSize(Integer maximumPoolSize) {
+        this.maximumPoolSize = maximumPoolSize;
+    }
+
+    public Long getValidationTimeout() {
+        return validationTimeout;
+    }
+
+    public void setValidationTimeout(Long validationTimeout) {
+        this.validationTimeout = validationTimeout;
+    }
+}

kmall-admin/src/main/java/com/kmall/admin/haikong/config/HaiKongConfig.java

@@ -5,6 +5,7 @@ import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.PropertySource;
 import org.springframework.core.env.Environment;
+import org.springframework.util.StringUtils;
 
 /**
  * 海控配置类
@@ -22,14 +23,59 @@ public class HaiKongConfig {
     public HaiKongProperties haiKongProperties() {
         HaiKongProperties haiKongProperties = new HaiKongProperties();
 
-        haiKongProperties.setMemberUrl(environment.getProperty("haikong.member.url"));
-        haiKongProperties.setMemberAppId(environment.getProperty("haikong.member.appId"));
-        haiKongProperties.setMemberAppSecret(environment.getProperty("haikong.member.appSecret"));
+        String env = environment.getProperty("haikong.env");
         haiKongProperties.setRetry(Integer.parseInt(environment.getProperty("haikong.retry")));
-        haiKongProperties.setVmcconnectUrl(environment.getProperty("haikong.vmcconnect.url"));
-        haiKongProperties.setVmcconnectAppId(environment.getProperty("haikong.vmcconnect.appId"));
-        haiKongProperties.setVmcconnectSecretKey(environment.getProperty("haikong.vmcconnect.secretKey"));
-        haiKongProperties.setRequestRetry(Integer.parseInt(environment.getProperty("haikong.vmcconnect.requestRetry")));
+
+        haiKongProperties.setMemberUrl(environment.getProperty(String.format("haikong.%s.member.url", env)));
+        haiKongProperties.setMemberAppId(environment.getProperty(String.format("haikong.%s.member.appId", env)));
+        haiKongProperties.setMemberAppSecret(environment.getProperty(String.format("haikong.%s.member.appSecret", env)));
+
+        haiKongProperties.setVmcconnectUrl(environment.getProperty(String.format("haikong.%s.vmcconnect.url", env)));
+        haiKongProperties.setVmcconnectAppId(environment.getProperty(String.format("haikong.%s.vmcconnect.appId", env)));
+        haiKongProperties.setVmcconnectSecretKey(environment.getProperty(String.format("haikong.%s.vmcconnect.secretKey", env)));
+        haiKongProperties.setRequestRetry(Integer.parseInt(environment.getProperty(String.format("haikong.%s.vmcconnect.requestRetry", env))));
+
+        String wareAppId = environment.getProperty(String.format("haikong.%s.ware.appId", env));
+        String wareAppSecret = environment.getProperty(String.format("haikong.%s.ware.appSecret", env));
+        String wareCode = environment.getProperty(String.format("haikong.%s.ware.code", env));
+        String companyCode = environment.getProperty(String.format("haikong.%s.ware.companyCode", env));
+        String wareCustomerId = environment.getProperty(String.format("haikong.%s.ware.customerId", env));
+        String wareShopCode = environment.getProperty(String.format("haikong.%s.ware.shopCode", env));
+        String wareSignMethod = environment.getProperty(String.format("haikong.%s.ware.signMethod", env));
+        String wareUrl = environment.getProperty(String.format("haikong.%s.ware.url", env));
+
+        if (!StringUtils.isEmpty(wareAppId)) {
+            haiKongProperties.setWareAppId(wareAppId);
+        }
+
+        if (!StringUtils.isEmpty(wareAppSecret)) {
+            haiKongProperties.setWareAppSecret(wareAppSecret);
+        }
+
+        if (!StringUtils.isEmpty(wareCode)) {
+            haiKongProperties.setWareCode(wareCode);
+        }
+
+        if (!StringUtils.isEmpty(companyCode)) {
+            haiKongProperties.setWareCompanyCode(companyCode);
+        }
+
+        if (!StringUtils.isEmpty(wareCustomerId)) {
+            haiKongProperties.setWareCustomerId(wareCustomerId);
+        }
+
+        if (!StringUtils.isEmpty(wareShopCode)) {
+            haiKongProperties.setWareShopCode(wareShopCode);
+        }
+
+        if (!StringUtils.isEmpty(wareSignMethod)) {
+            haiKongProperties.setWareSignMethod(wareSignMethod);
+        }
+
+        if (!StringUtils.isEmpty(wareUrl)) {
+            haiKongProperties.setWareUrl(wareUrl);
+        }
+
         return haiKongProperties;
     }
 

kmall-admin/src/main/java/com/kmall/admin/haikong/constant/Constants.java

@@ -27,6 +27,17 @@ public class Constants {
 
     /* --------------------------------------------------系统常量----------------------------------------------- */
 
+    /* --------------------------------------------------环境常量----------------------------------------------- */
+
+    public static final String DEV = "dev";
+
+    public static final String TEST = "test";
+
+    public static final String PRE = "pre";
+
+    public static final String PROD = "prod";
+
+    /* --------------------------------------------------环境常量----------------------------------------------- */
 
     /* --------------------------------------------------支付宝常量----------------------------------------------- */
 

kmall-admin/src/main/java/com/kmall/admin/service/impl/GoodsServiceImpl.java

@@ -39,6 +39,7 @@ import com.kmall.manager.manager.redis.JedisUtil;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.core.env.Environment;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
@@ -135,6 +136,8 @@ public class GoodsServiceImpl implements GoodsService {
 
     @Autowired
     private HaiKongWarehouseTemplate haiKongWarehouseTemplate;
+    @Autowired
+    private Environment environment;
 
     @Override
     public GoodsEntity queryObject(Integer id) {
@@ -1554,6 +1557,8 @@ public class GoodsServiceImpl implements GoodsService {
             return null;
         }
 
+        String env = environment.getProperty("haikong.env");
+
         /*
         * 2. 查询海仓仓库系统，判断库存是否足够
         * */
@@ -1566,50 +1571,49 @@ public class GoodsServiceImpl implements GoodsService {
         String stockNum = goods.getStockNum();
         Integer sellVolume = Objects.isNull(goods.getSellVolume()) ? 1 : goods.getSellVolume();
         if (org.springframework.util.StringUtils.isEmpty(redisCacheWareQuantity)) {
-
-            /* -----------------↓--------------生产请打开注释-------------------↓------------ */
-//            WareQueryStockParamDTO wareQueryStockParamDTO = new WareQueryStockParamDTO();
-//            List<Criteria> criteriaList = new ArrayList<>();
-//            Criteria criteria = new Criteria();
-//            criteria.setItemId(goods.getWarehouseSysGoodId());
-//            criteria.setItemCode(goods.getSku());
-//            criteria.setOwnerCode(goods.getConsignorSn());
-//            criteria.setInventoryType(Constants.InventoryType.ZP.getType());
-//            criteria.setWarehouseCode(goods.getWarehouseSn());
-//            criteriaList.add(criteria);
-//            wareQueryStockParamDTO.setCriteriaList(criteriaList);
-//            String queryWarehouseStockResponse = null;
-//            try {
-//                queryWarehouseStockResponse = haiKongWarehouseTemplate.queryWarehouseStock(wareQueryStockParamDTO);
-//            } catch (Exception e) {
-//                log.error("sku：【{}】，调用海控仓库系统查询库存出现异常！", sku, e);
-//                throw new ServiceException(String.format("sku：【%s】，调用海控仓库系统查询库存出现异常！", sku));
-//            }
-//            log.info("调用海控仓库系统，请求参数，门店：{}、商品条码：{}、商品编码：{}，响应数据：{}", storeId, prodBarcode, sku, queryWarehouseStockResponse);
-//            if (org.springframework.util.StringUtils.isEmpty(queryWarehouseStockResponse)) {
-//                log.error("调用库存系统接口出现错误！返回结果为空！");
-//                throw new ServiceException("调用库存系统接口出现错误！");
-//            }
-//            WareQueryStockResponseDTO wareQueryStockResponseDTO = JacksonUtil.fromStringJson(queryWarehouseStockResponse, WareQueryStockResponseDTO.class);
-            /* -----------------↑--------------生产请打开注释------------------↑------------- */
-
-            /* -----------------↓--------------测试数据，生产请注释-------------------↓------------ */
-            WareQueryStockResponseDTO wareQueryStockResponseDTO = new WareQueryStockResponseDTO();
-            wareQueryStockResponseDTO.setCode("0");
-            wareQueryStockResponseDTO.setFlag("success");
-            wareQueryStockResponseDTO.setMessage("");
-            WareQueryStockResponseDTO.WareQueryStockResponseItemDTO wareQueryStockResponseItemDTO = new WareQueryStockResponseDTO.WareQueryStockResponseItemDTO();
-            wareQueryStockResponseItemDTO.setQuantity(3);
-            wareQueryStockResponseItemDTO.setItemCode(sku);
-            wareQueryStockResponseItemDTO.setProduceCode(prodBarcode);
-            List<WareQueryStockResponseDTO.WareQueryStockResponseItemDTO> wareQueryStockResponseItemDTOS = new ArrayList<>();
-            wareQueryStockResponseItemDTOS.add(wareQueryStockResponseItemDTO);
-            wareQueryStockResponseDTO.setItems(wareQueryStockResponseItemDTOS);
-            /* -----------------↑--------------测试数据，生产请注释------------------↑------------- */
+            WareQueryStockResponseDTO wareQueryStockResponseDTO = null;
+            String queryWarehouseStockResponse = null;
+            // 环境配置
+            if (!org.springframework.util.StringUtils.isEmpty(env) && Constants.PROD.equals(env)) {
+                WareQueryStockParamDTO wareQueryStockParamDTO = new WareQueryStockParamDTO();
+                List<Criteria> criteriaList = new ArrayList<>();
+                Criteria criteria = new Criteria();
+                criteria.setItemId(goods.getWarehouseSysGoodId());
+                criteria.setItemCode(goods.getSku());
+                criteria.setOwnerCode(goods.getConsignorSn());
+                criteria.setInventoryType(Constants.InventoryType.ZP.getType());
+                criteria.setWarehouseCode(goods.getWarehouseSn());
+                criteriaList.add(criteria);
+                wareQueryStockParamDTO.setCriteriaList(criteriaList);
+                try {
+                    queryWarehouseStockResponse = haiKongWarehouseTemplate.queryWarehouseStock(wareQueryStockParamDTO);
+                } catch (Exception e) {
+                    log.error("sku：【{}】，调用海控仓库系统查询库存出现异常！", sku, e);
+                    throw new ServiceException(String.format("sku：【%s】，调用海控仓库系统查询库存出现异常！", sku));
+                }
+                log.info("调用海控仓库系统，请求参数，门店：{}、商品条码：{}、商品编码：{}，响应数据：{}", storeId, prodBarcode, sku, queryWarehouseStockResponse);
+                if (org.springframework.util.StringUtils.isEmpty(queryWarehouseStockResponse)) {
+                    log.error("调用库存系统接口出现错误！返回结果为空！");
+                    throw new ServiceException("调用库存系统接口出现错误！");
+                }
+                wareQueryStockResponseDTO = JacksonUtil.fromStringJson(queryWarehouseStockResponse, WareQueryStockResponseDTO.class);
+            } else {
+                wareQueryStockResponseDTO = new WareQueryStockResponseDTO();
+                wareQueryStockResponseDTO.setCode("0");
+                wareQueryStockResponseDTO.setFlag("success");
+                wareQueryStockResponseDTO.setMessage("");
+                WareQueryStockResponseDTO.WareQueryStockResponseItemDTO wareQueryStockResponseItemDTO = new WareQueryStockResponseDTO.WareQueryStockResponseItemDTO();
+                wareQueryStockResponseItemDTO.setQuantity(3);
+                wareQueryStockResponseItemDTO.setItemCode(sku);
+                wareQueryStockResponseItemDTO.setProduceCode(prodBarcode);
+                List<WareQueryStockResponseDTO.WareQueryStockResponseItemDTO> wareQueryStockResponseItemDTOS = new ArrayList<>();
+                wareQueryStockResponseItemDTOS.add(wareQueryStockResponseItemDTO);
+                wareQueryStockResponseDTO.setItems(wareQueryStockResponseItemDTOS);
+            }
 
 
             if (Objects.isNull(wareQueryStockResponseDTO)) {
-//            log.error("解析一步达库存系统响应数据出现错误！请求响应结果：{}", queryWarehouseStockResponse);
+                log.error("解析一步达库存系统响应数据出现错误！请求响应结果：{}", queryWarehouseStockResponse);
                 throw new ServiceException("解析一步达库存系统响应数据出现错误！");
             }
 

kmall-admin/src/main/java/com/kmall/admin/service/impl/OrderServiceImpl.java

@@ -91,6 +91,7 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.BeanUtils;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.core.env.Environment;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 import org.springframework.util.CollectionUtils;
@@ -307,6 +308,9 @@ public class OrderServiceImpl implements OrderService {
     private AliCusDeclareBiz aliCusDeclareBiz;
 
     @Autowired
+    private Environment environment;
+
+    @Autowired
     private HaiKongSendOrderInfoRecordService haiKongSendOrderInfoRecordService;
 
     @Autowired
@@ -2500,36 +2504,37 @@ public class OrderServiceImpl implements OrderService {
             StoreEntity store = storeService.queryObject(order.getStore_id().intValue());
 
             processRecordEntity.setPaymentStartTime(new Date());
+
+            String env = environment.getProperty("haikong.env");
             // 判断是微信的支付码还是支付宝的支付码
-            if (parCode.startsWith("28")) {
-                // 支付宝支付
-                try {
-                    AliPay(user, parCode, order, processRecordEntity, orderWXPayRecordCurrent, store);
-                } catch (Exception e) {
-                    LOGGER.error("支付宝支付出现异常！订单号：【{}】", order.getOrder_sn(), e);
-                    throw e;
+            if (!org.springframework.util.StringUtils.isEmpty(env) && Constants.PROD.equals(env)) {
+                if (parCode.startsWith("28")) {
+                    // 支付宝支付
+                    try {
+                        AliPay(user, parCode, order, processRecordEntity, orderWXPayRecordCurrent, store);
+                    } catch (Exception e) {
+                        LOGGER.error("支付宝支付出现异常！订单号：【{}】", order.getOrder_sn(), e);
+                        throw e;
+                    }
+                } else {
+                    // 微信支付
+                    try {
+                        wxPay(user, parCode, resultObj, order, processRecordEntity, orderWXPayRecordCurrent, store);
+                    } catch (Exception e) {
+                        e.printStackTrace();
+                        throw e;
+                    }
                 }
             } else {
-                // 微信支付
-                try {
-                    wxPay(user, parCode, resultObj, order, processRecordEntity, orderWXPayRecordCurrent, store);
-                } catch (Exception e) {
-                    e.printStackTrace();
-                    throw e;
-                }
+                OrderEntity orderEntity = queryObject(order.getId());
+                orderEntity.setOrderStatus(Integer.parseInt(Dict.orderStatus.item_201.getItem()));
+                orderEntity.setPayStatus(Integer.parseInt(Dict.payStatus.item_2.getItem()));
+                orderEntity.setPayTime(new Date());
+                orderDao.update(orderEntity);
             }
 
             processRecordEntity.setPaymentStartTime(new Date());
 
-
-            // TODO 到时候要注释掉，测试用而已
-            OrderEntity orderEntity = queryObject(order.getId());
-            orderEntity.setOrderStatus(Integer.parseInt(Dict.orderStatus.item_201.getItem()));
-            orderEntity.setPayStatus(Integer.parseInt(Dict.payStatus.item_2.getItem()));
-            orderEntity.setPayTime(new Date());
-            orderDao.update(orderEntity);
-
-
             resultObj.put("shopName", store.getStoreName()); // 根据门店编号查询
             resultObj.put("userName", user.getUsername());
 
@@ -2749,10 +2754,13 @@ public class OrderServiceImpl implements OrderService {
 
             JedisUtil.del(Constants.WAREHOUSE_STOCK_MAP_KEY + "_" + storeId);
 
-            // TODO 推单测试用
-//            order.setPayApp("wxpay");
-//            order.setRequest("1111111111111111111");
-//            order.setResponse("2222222222222222222");
+
+            if (org.springframework.util.StringUtils.isEmpty(env) && Constants.TEST.equals(env)) {
+                order.setPayApp("wxpay");
+                order.setRequest("1111111111111111111");
+                order.setResponse("2222222222222222222");
+            }
+
             // 推单
             sendOrderInfoToVmcShop(order, orderGoodsVoList);
 

kmall-framework/src/test/resources/applicationContext-test.xml

@@ -87,7 +87,8 @@
         &lt;!&ndash;<property name="transactionIsolation" value="TRANSACTION_REPEATABLE_READ"/>&ndash;&gt;
     </bean>-->
 
-    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
+    <!-- 2021-12-15改为配置类：com.kmall.admin.config.datasource.DataSourceConfig-->
+    <!--<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
           init-method="init" destroy-method="close">
         <property name="url">
             <value>${jdbc.url}</value>
@@ -107,35 +108,35 @@
         <property name="proxyFilters">
             <list>
                 <ref bean="stat-filter"/>
-                <!--过滤永真条件 防止注入-->
+                &lt;!&ndash;过滤永真条件 防止注入&ndash;&gt;
                 <ref bean="wall-filter"/>
             </list>
         </property>
         <property name="connectionInitSqls" value="set names utf8mb4;"/>
-        <!--&lt;!&ndash; 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 &ndash;&gt;-->
+        &lt;!&ndash;&lt;!&ndash; 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 &ndash;&gt;&ndash;&gt;
         <property name="timeBetweenEvictionRunsMillis" value="60000" />
-        <!-- 配置一个连接在池中最小生存的时间，单位是毫秒 -->
+        &lt;!&ndash; 配置一个连接在池中最小生存的时间，单位是毫秒 &ndash;&gt;
         <property name="minEvictableIdleTimeMillis" value="300000" />
-        <!-- 建议配置为true，不影响性能，并且保证安全性。申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效 -->
+        &lt;!&ndash; 建议配置为true，不影响性能，并且保证安全性。申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效 &ndash;&gt;
         <property name="testWhileIdle" value="true" />
-        <!-- 指定每个连接上PSCache的大小   -->
+        &lt;!&ndash; 指定每个连接上PSCache的大小   &ndash;&gt;
         <property name="maxPoolPreparedStatementPerConnectionSize" value="20" />
-    </bean>
+    </bean>-->
 
-    <bean id="stat-filter" class="com.alibaba.druid.filter.stat.StatFilter">
+    <!--<bean id="stat-filter" class="com.alibaba.druid.filter.stat.StatFilter">
         <property name="slowSqlMillis" value="1000"/>
         <property name="logSlowSql" value="true"/>
         <property name="mergeSql" value="true"/>
-    </bean>
+    </bean>-->
 
-    <bean id="wall-filter" class="com.alibaba.druid.wall.WallFilter">
+    <!--<bean id="wall-filter" class="com.alibaba.druid.wall.WallFilter">
         <property name="dbType" value="mysql"/>
         <property name="config" ref="wall-filter-config"/>
-    </bean>
+    </bean>-->
 
-    <bean id="wall-filter-config" class="com.alibaba.druid.wall.WallConfig">
+    <!--<bean id="wall-filter-config" class="com.alibaba.druid.wall.WallConfig">
         <property name="multiStatementAllow" value="true"/>
-    </bean>
+    </bean>-->
 
     <bean id="druid-stat-interceptor" class="com.alibaba.druid.support.spring.stat.DruidStatInterceptor"></bean>
     <bean id="druid-stat-pointcut" class="org.springframework.aop.support.JdkRegexpMethodPointcut" scope="prototype">

kmall-manager/src/main/resources/conf/db.properties

@@ -1,22 +1,23 @@
-########## \u6570\u636E\u5E93\u914D\u7F6E ##########1
-
-####========== \u5F00\u53D1\u73AF\u5883 ==========
-#jdbc.url=jdbc:mysql://14.29.226.8:3306/kmall-haikong?allowMultiQueries=true&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
-#jdbc.username=root
-#jdbc.password=G$Debpk^pn
+########## \u6570\u636E\u5E93\u914D\u7F6E ##########
+# \u73AF\u5883\u914D\u7F6E\uFF1A[dev, prod, pre, test]
+jdbc.env=dev
 ####========== \u6D4B\u8BD5\u73AF\u5883 ==========
-#jdbc.url=jdbc:mysql://192.168.1.202:3306/kmall-haikong?allowMultiQueries=true&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
-#jdbc.username=root
-#jdbc.password=t2GlpD6z
+jdbc.test.url=jdbc:mysql://14.29.226.8:3306/kmall-haikong?allowMultiQueries=true&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
+jdbc.test.username=root
+jdbc.test.password=G$Debpk^pn
+####========== \u5F00\u53D1\u73AF\u5883 ==========
+jdbc.dev.url=jdbc:mysql://192.168.1.202:3306/kmall-haikong?allowMultiQueries=true&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
+jdbc.dev.username=root
+jdbc.dev.password=t2GlpD6z
 ####========== \u751F\u4EA7\u73AF\u5883 ==========
 # \u5F85\u5B9A
-jdbc.url=jdbc:mysql://120.76.84.45:3306/kmall-haikong?allowMultiQueries=true&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
-jdbc.username=root
-jdbc.password=Qq123!..
-#\u672C\u5730\u6D4B\u8BD5\u5E93
-#jdbc.url=jdbc:mysql://192.168.1.202:3306/kmall-haikong?allowMultiQueries=true&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
-#jdbc.username=root
-#jdbc.password=t2GlpD6z
+jdbc.prod.url=jdbc:mysql://:3306/kmall-haikong?allowMultiQueries=true&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
+jdbc.prod.username=kmall_cw
+jdbc.prod.password=eb6zHJg%x3
+# \u9884\u53D1\u5E03\u5E93
+jdbc.pre.url=jdbc:mysql://120.76.84.45:3306/kmall-haikong?allowMultiQueries=true&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
+jdbc.pre.username=root
+jdbc.pre.password=Qq123!..
 
 
 # \u901A\u7528\u914D\u7F6E

kmall-manager/src/main/resources/conf/haikong.properties

@@ -1,26 +1,37 @@
 # \u683C\u529B\u5730\u4EA7\u4F1A\u5458\u7CFB\u7EDF
-#### \u6D4B\u8BD5\u73AF\u5883
-haikong.member.url=https://test-ump.greedc.com
-haikong.member.appId=mianshuitestzhanxiao
-haikong.member.appSecret=mianshuitestzhanxiao1029
+
+# \u73AF\u5883\uFF1A[test, prod]
+haikong.env=test
 haikong.retry=3
-haikong.ware.url=http://yjapi.highstore.cn:8202/esbcenter/api/esb
-haikong.ware.appId=GREE
-haikong.ware.appSecret=GREE1001
-haikong.ware.customerId=GREE1001
-haikong.ware.shopCode=wxe186e23f5a8f0dbf
-haikong.ware.companyCode=44048600Y8
-haikong.ware.code=20
-haikong.ware.signMethod=md5
 
-#\u514D\u7A0Emall\u7CFB\u7EDF
-haikong.vmcconnect.url=https://testmall.greedc.com/openapi/vmcconnect/json
-haikong.vmcconnect.appId=5
-haikong.vmcconnect.secretKey=GXfc6ZtDlnxHxmmAHvfRfqvrqgfwRiJX
-haikong.vmcconnect.requestRetry=2
-#### \u751F\u4EA7\u73AF\u5883
-#haikong.member.url=https://ump.greedc.com
-#haikong.member.appId=
-#haikong.member.appSecret=
-#haikong.ware.url=
+#### \u4F1A\u5458\u7CFB\u7EDF\u6D4B\u8BD5\u73AF\u5883
+haikong.test.member.url=https://test-ump.greedc.com
+haikong.test.member.appId=mianshuitestzhanxiao
+haikong.test.member.appSecret=mianshuitestzhanxiao1029
+
+#### \u4F1A\u5458\u7CFB\u7EDF\u751F\u4EA7\u73AF\u5883
+haikong.prod.member.url=https://ump.greedc.com
+haikong.prod.member.appId=
+haikong.prod.member.appSecret=
+
+#### \u4ED3\u5E93\u751F\u4EA7\u7CFB\u7EDF\uFF0C\u53EA\u6709\u751F\u4EA7
+haikong.prod.ware.url=http://yjapi.highstore.cn:8202/esbcenter/api/esb
+haikong.prod.ware.appId=GREE
+haikong.prod.ware.appSecret=GREE1001
+haikong.prod.ware.customerId=GREE1001
+haikong.prod.ware.shopCode=wxe186e23f5a8f0dbf
+haikong.prod.ware.companyCode=44048600Y8
+haikong.prod.ware.code=20
+haikong.prod.ware.signMethod=md5
+
+#### \u514D\u7A0Emall\u6D4B\u8BD5\u73AF\u5883
+haikong.test.vmcconnect.url=https://testmall.greedc.com/openapi/vmcconnect/json
+haikong.test.vmcconnect.appId=5
+haikong.test.vmcconnect.secretKey=GXfc6ZtDlnxHxmmAHvfRfqvrqgfwRiJX
+haikong.test.vmcconnect.requestRetry=2
 
+#### \u514D\u7A0Emall\u751F\u4EA7\u73AF\u5883
+haikong.prod.vmcconnect.url=https://mall.greedc.com/openapi/vmcconnect/json
+haikong.prod.vmcconnect.appId=5
+haikong.prod.vmcconnect.secretKey=GXfc6ZtDlnxHxmmAHvfRfqvrqgfwRiJX
+haikong.prod.vmcconnect.requestRetry=2

kmall-manager/src/main/resources/spring/spring-jdbc.xml

@@ -37,7 +37,7 @@
         &lt;!&ndash;<property name="transactionIsolation" value="TRANSACTION_REPEATABLE_READ"/>&ndash;&gt;
     </bean>-->
 
-    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
+    <!--<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
           init-method="init" destroy-method="close">
         <property name="url" value="${jdbc.url}"/>
         <property name="username" value="${jdbc.username}"/>
@@ -50,31 +50,31 @@
                 <ref bean="wall-filter"/>
             </list>
         </property>
-        <!--&lt;!&ndash; 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 &ndash;&gt;-->
+        &lt;!&ndash;&lt;!&ndash; 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 &ndash;&gt;&ndash;&gt;
         <property name="timeBetweenEvictionRunsMillis" value="60000" />
-        <!-- 配置一个连接在池中最小生存的时间，单位是毫秒 -->
+        &lt;!&ndash; 配置一个连接在池中最小生存的时间，单位是毫秒 &ndash;&gt;
         <property name="minEvictableIdleTimeMillis" value="300000" />
-        <!-- 建议配置为true，不影响性能，并且保证安全性。申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效 -->
+        &lt;!&ndash; 建议配置为true，不影响性能，并且保证安全性。申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效 &ndash;&gt;
         <property name="testWhileIdle" value="true" />
-        <!-- 指定每个连接上PSCache的大小   -->
+        &lt;!&ndash; 指定每个连接上PSCache的大小   &ndash;&gt;
         <property name="maxPoolPreparedStatementPerConnectionSize" value="20" />
-    </bean>
+    </bean>-->
 
     <!-- 慢sql日志 -->
-    <bean id="stat-filter" class="com.alibaba.druid.filter.stat.StatFilter">
+    <!--<bean id="stat-filter" class="com.alibaba.druid.filter.stat.StatFilter">
         <property name="slowSqlMillis" value="1000"/>
         <property name="logSlowSql" value="true"/>
         <property name="mergeSql" value="true"/>
-    </bean>
+    </bean>-->
 
-    <bean id="wall-filter" class="com.alibaba.druid.wall.WallFilter">
+    <!--<bean id="wall-filter" class="com.alibaba.druid.wall.WallFilter">
         <property name="dbType" value="mysql"/>
         <property name="config" ref="wall-filter-config"/>
-    </bean>
+    </bean>-->
 
-    <bean id="wall-filter-config" class="com.alibaba.druid.wall.WallConfig">
+    <!--<bean id="wall-filter-config" class="com.alibaba.druid.wall.WallConfig">
         <property name="multiStatementAllow" value="true"/>
-    </bean>
+    </bean>-->
 
     <bean id="druid-stat-interceptor" class="com.alibaba.druid.support.spring.stat.DruidStatInterceptor"></bean>
     <bean id="druid-stat-pointcut" class="org.springframework.aop.support.JdkRegexpMethodPointcut" scope="prototype">