包裹数据通过远程调用接口接入，体温统计接口修改

Administrator

2021-03-10 5c595590ddbcbf6d121810c03f08f5c43730d645

包裹数据通过远程调用接口接入，体温统计接口修改

 blade-service/blade-jfpts/src/main/java/org/springblade/jfpt/animalheat/mapper/AnimalHeatMapper.java

@@ -39,4 +39,10 @@
     * @return
     */
    List<Map<String, Integer>> selWeekDayAnimalStatis();

    /**
     * 获取体温数据统计  --本月
     * @return
     */
    List<Map<String, Object>> getAnimalStatisMonth();
}

 blade-service/blade-jfpts/src/main/java/org/springblade/jfpt/animalheat/mapper/AnimalHeatMapper.xml

@@ -20,6 +20,16 @@
            YEARWEEK(date_format(create_time,'%Y-%m-%d')) = YEARWEEK(now()) and `status`=0
    </select>

    <!--获取本月的体温统计数据-->
    <select id="getAnimalStatisMonth" resultType="java.util.HashMap">
        SELECT 1 `name`,count(`status`) value FROM `blade_animal_heat` where
            date_format(create_time,'%Y%m') = date_format(now(),'%Y%m') and `status`=1
        UNION
        SELECT 0 `name`,count(`status`) value FROM `blade_animal_heat` where
            date_format(create_time,'%Y%m') = date_format(now(),'%Y%m') and `status`=0
    </select>

    <!--查询体温数据的分页数据-->
    <select id="selectAnimalHeatPageList" resultType="org.springblade.jfpt.animalheat.entity.BladeAnimalHeat">
        SELECT * FROM blade_animal_heat
        <if test="animalHeatVo.begTime!=null and animalHeatVo.begTime!=''">

 blade-service/blade-jfpts/src/main/java/org/springblade/jfpt/animalheat/service/impl/AnimalHeatServiceImpl.java

@@ -81,7 +81,7 @@
            bladeAnimalHeat.setStatus(compare1>0 ?0:1);
        }
        String person_rects = data.get("person_rect").toString();
        bladeAnimalHeat.setPersonRect(person_rects.substring(2,person_rects.length()-2));
        bladeAnimalHeat.setPersonRect(person_rects.substring(1,person_rects.length()-1));
        bladeAnimalHeat.setCreateTime(now());
        //7.插入数据
        int idata = baseMapper.insert(bladeAnimalHeat);
@@ -104,6 +104,10 @@
            if (animalHeatVo.getStatus()==1){
                return baseMapper.getAnimalStatisWeek();
            }
            //查询本月的统计数据
            if (animalHeatVo.getStatus()==2){
                return baseMapper.getAnimalStatisMonth();
            }
        }
        return null;
    }

 blade-service/blade-jfpts/src/main/java/org/springblade/jfpt/parcel/controller/ParcelController.java

New file
@@ -0,0 +1,43 @@
package org.springblade.jfpt.parcel.controller;

import lombok.AllArgsConstructor;
import org.springblade.core.tool.api.R;
import org.springblade.jfpt.animalheat.vo.AnimalHeatVo;
import org.springblade.jfpt.parcel.service.ParcelService;
import org.springblade.jfpt.parcel.vo.ConditionVo;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletResponse;

/**
 * @title 包裹控制层
 * @author arsn
 * @time 2021-03-10
 */

@RestController
@AllArgsConstructor
@RequestMapping("parcel/parcel")
public class ParcelController {

    private final ParcelService parcelService;

    /**
     * 获取查询条件
     * @param conditionVo 查询条件对象
     * @param response 返回作用域
     * @return
     */
    @PostMapping("/parcelKindStatis")
    public R parcelKindStatis(@RequestBody ConditionVo conditionVo, HttpServletResponse response){
        response.setHeader("Access-Control-Allow-Origin", "*");
        response.setHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS, DELETE");
        response.setHeader("Access-Control-Allow-Credentials","true");
        return R.data(parcelService.parcelKindStatis(conditionVo));
    }


}

 blade-service/blade-jfpts/src/main/java/org/springblade/jfpt/parcel/service/ParcelService.java

New file
@@ -0,0 +1,18 @@
package org.springblade.jfpt.parcel.service;

import org.springblade.jfpt.parcel.vo.ConditionVo;

import java.util.List;
import java.util.Map;

/**
 * 包裹服务接口层
 */
public interface ParcelService {
    /**
     * 获取查询条件
     * @param conditionVo 查询条件对象
     * @return
     */
    List<Map<String,Object>> parcelKindStatis(ConditionVo conditionVo);
}

 blade-service/blade-jfpts/src/main/java/org/springblade/jfpt/parcel/service/impl/ParcelServiceImpl.java

New file
@@ -0,0 +1,63 @@
package org.springblade.jfpt.parcel.service.impl;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.nacos.common.utils.JacksonUtils;
import org.springblade.jfpt.parcel.service.ParcelService;
import org.springblade.jfpt.parcel.util.HttpClientUtils;
import org.springblade.jfpt.parcel.util.JacksonUtil;
import org.springblade.jfpt.parcel.vo.ConditionVo;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import springfox.documentation.spring.web.json.Json;

import java.util.*;

/**
 * 包裹服务实现层
 */
@Service
public class ParcelServiceImpl implements ParcelService {
    @Value("${PARCEL_KEY}")
    private String PARCEL_KEY;

    @Value("${PARCEL_SECRET}")
    private String PARCEL_SECRET;

    @Value("${PARCEL_CONTRABAND_URL}")
    private String PARCEL_CONTRABAND_URL;



    /**
     * 获取查询条件
     * @param conditionVo 查询条件对象
     * @return
     */
    @Override
    public List<Map<String, Object>> parcelKindStatis(ConditionVo conditionVo) {
        //1.创建map对象，用于存储请求接口的秘钥
        Map<String, String> map = new HashMap<>();
         //2.时间不为空
        if (null!=conditionVo.getStartDate() && null!=conditionVo.getEndDate()) {
            map.put("startDate", conditionVo.getStartDate());
            map.put("endDate", conditionVo.getEndDate());
        }
        //3.调用远程接口获取数据
        String params = HttpClientUtils.httpPost(PARCEL_CONTRABAND_URL, PARCEL_KEY, PARCEL_SECRET, map);
        //4.数据转换
        Map<String,Object> data = (Map<String, Object>) JSONObject.parse(params);
        List<Object> objectList = JSON.parseArray(data.get("result").toString());
        //5.遍历，分别取出数据
        for (Object object:objectList) {
            Map <String,Object> objectMap = (Map<String, Object>) object;//取出list里面的值转为map
            System.out.println("liMap.get(\"objCode\") = " + objectMap.get("objCode"));
            System.out.println("liMap.get(\"objCode\") = " + objectMap.get("objCount"));
            System.out.println("liMap.get(\"objCode\") = " + objectMap.get("dateStr"));
            System.out.println("liMap.get(\"objCode\") = " + objectMap.get("objName"));
        }

        return null;
    }
}

 blade-service/blade-jfpts/src/main/java/org/springblade/jfpt/parcel/util/HttpClientUtils.java

New file
@@ -0,0 +1,399 @@
package org.springblade.jfpt.parcel.util;

import java.io.*;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.security.KeyManagementException;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.*;

import com.alibaba.fastjson.JSON;
import org.apache.http.HttpEntity;
import org.apache.http.NameValuePair;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.config.Registry;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.conn.socket.ConnectionSocketFactory;
import org.apache.http.conn.socket.PlainConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.conn.ssl.TrustStrategy;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.client.LaxRedirectStrategy;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.message.BasicHeader;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.ssl.SSLContextBuilder;
import org.apache.http.util.EntityUtils;

import javax.net.ssl.SSLContext;


public class HttpClientUtils {
    /**
     * 执行有参GET请求
     *
     * @param url
     * @param params
     * @return
     */
    public static String doGet(String url, Map<String, String> params) {

        //获取httpclient客户端
        CloseableHttpClient httpclient = HttpClients.createDefault();

        String resultString = "";

        CloseableHttpResponse response = null;

        try {
            URIBuilder builder = new URIBuilder(url);

            if (null != params) {
                for (String key : params.keySet()) {
                    builder.setParameter(key, params.get(key));
                }
            }

            HttpGet get = new HttpGet(builder.build());


            response = httpclient.execute(get);

            System.out.println(response.getStatusLine());

            if (200 == response.getStatusLine().getStatusCode()) {
                HttpEntity entity = response.getEntity();
                System.out.println(entity.toString());
                resultString = EntityUtils.toString(entity, "utf-8");
                System.out.println(resultString.toString());
            }

        } catch (Exception e) {

            e.printStackTrace();
        } finally {
            if (null != response) {
                try {
                    response.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (null != httpclient) {
                try {
                    httpclient.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        return resultString;
    }

    /**
     * 执行无参GET请求
     *
     * @param url
     * @return
     */
    public static String doGet(String url) {
        return doGet(url, null);
    }

    /**
     * 执行有参POST请求
     *
     * @param url
     * @param params
     * @return
     */
    public static String doPost(String url, Map<String, String> params) {
        /**
         * 在4.0及以上httpclient版本中，post需要指定重定向的策略，如果不指定则按默认的重定向策略。
         *
         * 获取httpclient客户端
         */
        CloseableHttpClient httpclient = HttpClientBuilder.create().setRedirectStrategy(new LaxRedirectStrategy()).build();

        String resultString = "";

        CloseableHttpResponse response = null;

        try {


            HttpPost post = new HttpPost(url);

            List<NameValuePair> paramaters = new ArrayList<>();

            if (null != params) {
                for (String key : params.keySet()) {
                    paramaters.add(new BasicNameValuePair(key, params.get(key)));
                }
                // 构造一个form表单式的实体
                UrlEncodedFormEntity formEntity = new UrlEncodedFormEntity(paramaters);
                // 将请求实体设置到httpPost对象中
                post.setEntity(formEntity);
            }


            /**
             * HTTP/1.1 403 Forbidden
             *   原因：
             *      有些网站，设置了反爬虫机制
             *   解决的办法：
             *      设置请求头，伪装浏览器
             */
            post.addHeader("user-agent", "Mozilla/5.0 (Windows NT 6.3; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36");

            response = httpclient.execute(post);

            System.out.println(response.getStatusLine());

            if (200 == response.getStatusLine().getStatusCode()) {
                HttpEntity entity = response.getEntity();
                resultString = EntityUtils.toString(entity, "utf-8");
            }

        } catch (Exception e) {

            e.printStackTrace();
        } finally {
            if (null != response) {
                try {
                    response.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (null != httpclient) {
                try {
                    httpclient.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return resultString;
    }

    public static String doPost(String url) {
        return doPost(url, null);
    }


    public static void main(String[] args) {

        Map<String, String> params = new HashMap<>();
        params.put("scope", "project");
        params.put("q", "数据库");
//
//        System.out.println(doGet("http://www.baidu.com/s",params));

        /**
         * 有一部分网站，禁止爬虫技术访问网站。
         *
         * 解决方案：
         *    伪装浏览器
         *    post.addHeader("user-agent", "Mozilla/5.0 (Windows NT 6.3; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36");
         */
        System.out.println(doPost("http://www.oschina.net/search", params));
    }

    /**
     * post 请求 header 带 秘钥
     * @param url
     * @param appKey
     * @param appKeyValue
     * @param map
     * @return
     */
    public static String httpPost(String url, String appKey, String appKeyValue, Map<String, String> map) {
        // 返回body
        String body = null;
        // 获取连接客户端工具
        CloseableHttpClient httpClient = HttpClients.createDefault();
        CloseableHttpResponse httpResponse = null;
        // 2、创建一个HttpPost请求
        HttpPost post = new HttpPost(url);
        // 5、设置header信息
        /**header中通用属性*/
//        post.setHeader("Accept", "*/*");
//        post.setHeader("Accept-Encoding", "gzip, deflate");
//        post.setHeader("Cache-Control", "no-cache");
//        post.setHeader("Connection", "keep-alive");
        post.setHeader("Content-Type", "application/json;charset=UTF-8");
        /**业务参数*/
        post.setHeader(appKey, appKeyValue);
        // 设置参数
        if (map != null) {
            try {
                StringEntity entity1 = new StringEntity(JSON.toJSONString(map), "UTF-8");
                entity1.setContentEncoding("UTF-8");
                entity1.setContentType("json/form-data");
                post.setEntity(entity1);

                // 7、执行post请求操作，并拿到结果
                httpResponse = httpClient.execute(post);
                // 获取结果实体
                HttpEntity entity = httpResponse.getEntity();
                if (entity != null) {
                    // 按指定编码转换结果实体为String类型
                    body = EntityUtils.toString(entity, "UTF-8");
                }
                try {
                    httpResponse.close();
                    httpClient.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return body;
    }

    public static SSLContext createIgnoreVerifySSL() throws KeyManagementException, NoSuchAlgorithmException, KeyStoreException {

        SSLContext sc = new SSLContextBuilder().loadTrustMaterial(null, new TrustStrategy() {

            public boolean isTrusted(X509Certificate[] arg0, String arg1) throws CertificateException {
                return true;
            }

        }).build();

        return sc;
    }

    //适用于post请求并传送form-data数据（同样适用于post的Raw类型的application-json格式）
    public static String postParams(String url, String appKey, String appKeyValue, Map<String, String> map) {
        SSLContext sslcontext = null;
        try {
            sslcontext = createIgnoreVerifySSL();
        } catch (KeyManagementException e) {
            e.printStackTrace();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (KeyStoreException e) {
            e.printStackTrace();
        }
        // 设置协议http和https对应的处理socket链接工厂的对象
        Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create()
                .register("http", PlainConnectionSocketFactory.INSTANCE)
                .register("https", new SSLConnectionSocketFactory(sslcontext))
                .build();
        PoolingHttpClientConnectionManager connManager = new PoolingHttpClientConnectionManager(socketFactoryRegistry);

        //创建自定义的httpclient对象
        CloseableHttpClient client = HttpClients.custom().setConnectionManager(connManager).build();
        HttpPost post = new HttpPost(url);
        post.setHeader(appKey, appKeyValue);
        CloseableHttpResponse res = null;
        try {
            List<NameValuePair> nvps = new ArrayList<NameValuePair>();
            Set<String> keySet = map.keySet();
            for (String key : keySet) {
                nvps.add(new BasicNameValuePair(key, map.get(key)));
            }
            post.setEntity(new UrlEncodedFormEntity(nvps, "utf-8"));
            res = client.execute(post);
            HttpEntity entity = res.getEntity();
            return EntityUtils.toString(entity, "utf-8");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                res.close();
                client.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return "";
    }

    /**
     * 向指定 URL 发送POST方法的请求
     *
     * @param url    发送请求的 URL
     * @param params 请求的参数集合
     * @return 远程资源的响应结果
     */
    @SuppressWarnings("unused")
    public static String sendPost(String url, Map<String, String> params) {
        OutputStreamWriter out = null;
        BufferedReader in = null;
        StringBuilder result = new StringBuilder();
        try {
            URL realUrl = new URL(url);
            HttpURLConnection conn = (HttpURLConnection) realUrl.openConnection();
            // 发送POST请求必须设置如下两行
            conn.setDoOutput(true);
            conn.setDoInput(true);
            // POST方法
            conn.setRequestMethod("POST");
            // 设置通用的请求属性
            conn.setRequestProperty("accept", "*/*");
            conn.setRequestProperty("connection", "Keep-Alive");
            conn.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
            conn.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
            conn.connect();
            // 获取URLConnection对象对应的输出流
            out = new OutputStreamWriter(conn.getOutputStream(), "UTF-8");
            // 发送请求参数
            if (params != null) {
                StringBuilder param = new StringBuilder();
                for (Map.Entry<String, String> entry : params.entrySet()) {
                    if (param.length() > 0) {
                        param.append("&");
                    }
                    param.append(entry.getKey());
                    param.append("=");
                    param.append(entry.getValue());
                    // System.out.println(entry.getKey()+":"+entry.getValue());
                }
                // System.out.println("param:"+param.toString());
                out.write(param.toString());
            }
            // flush输出流的缓冲
            out.flush();
            // 定义BufferedReader输入流来读取URL的响应
            in = new BufferedReader(new InputStreamReader(conn.getInputStream(), "UTF-8"));
            String line;
            while ((line = in.readLine()) != null) {
                result.append(line);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        // 使用finally块来关闭输出流、输入流
        finally {
            try {
                if (out != null) {
                    out.close();
                }
                if (in != null) {
                    in.close();
                }
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
        return result.toString();
    }

}

 blade-service/blade-jfpts/src/main/java/org/springblade/jfpt/parcel/util/JacksonUtil.java

New file
@@ -0,0 +1,186 @@
package org.springblade.jfpt.parcel.util;

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

import java.io.IOException;
import java.util.List;

/**
 * @author Administrator
 */
public class JacksonUtil {
    public static String parseString(String body, String field) {
        ObjectMapper mapper = new ObjectMapper();
        JsonNode node = null;
        try {
            node = mapper.readTree(body);
            JsonNode leaf = node.get(field);
            if (leaf != null) {
                return leaf.asText();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    public static List<String> parseStringList(String body, String field) {
        ObjectMapper mapper = new ObjectMapper();
        JsonNode node = null;
        try {
            node = mapper.readTree(body);
            JsonNode leaf = node.get(field);

            if (leaf != null) {
                return mapper.convertValue(leaf, new TypeReference<List<String>>() {
                });
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    public static Double parseDouble(String body,String field){
        ObjectMapper mapper = new ObjectMapper();
        JsonNode node = null;
        try {
            node = mapper.readTree(body);
            JsonNode leaf = node.get(field);
            if (leaf != null) {
                return leaf.asDouble();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    public static List<Double> parseDoubleList(String body, String field) {
        ObjectMapper mapper = new ObjectMapper();
        JsonNode node = null;
        try {
            node = mapper.readTree(body);
            JsonNode leaf = node.get(field);

            if (leaf != null) {
                return mapper.convertValue(leaf, new TypeReference<List<Double>>() {
                });
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    public static Integer parseInteger(String body, String field) {
        ObjectMapper mapper = new ObjectMapper();
        JsonNode node = null;
        try {
            node = mapper.readTree(body);
            JsonNode leaf = node.get(field);
            if (leaf != null) {
                return leaf.asInt();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    public static List<Integer> parseIntegerList(String body, String field) {
        ObjectMapper mapper = new ObjectMapper();
        JsonNode node = null;
        try {
            node = mapper.readTree(body);
            JsonNode leaf = node.get(field);

            if (leaf != null) {
                return mapper.convertValue(leaf, new TypeReference<List<Integer>>() {
                });
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    public static Boolean parseBoolean(String body, String field) {
        ObjectMapper mapper = new ObjectMapper();
        JsonNode node = null;
        try {
            node = mapper.readTree(body);
            JsonNode leaf = node.get(field);
            if (leaf != null) {
                return leaf.asBoolean();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    public static Short parseShort(String body, String field) {
        ObjectMapper mapper = new ObjectMapper();
        JsonNode node = null;
        try {
            node = mapper.readTree(body);
            JsonNode leaf = node.get(field);
            if (leaf != null) {
                Integer value = leaf.asInt();
                return value.shortValue();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    public static Byte parseByte(String body, String field) {
        ObjectMapper mapper = new ObjectMapper();
        JsonNode node = null;
        try {
            node = mapper.readTree(body);
            JsonNode leaf = node.get(field);
            if (leaf != null) {
                Integer value = leaf.asInt();
                return value.byteValue();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    public static <T> T parseObject(String body, String field, Class<T> clazz) {
        ObjectMapper mapper = new ObjectMapper();
        JsonNode node = null;
        try {
            node = mapper.readTree(body);
            node = node.get(field);
            return mapper.treeToValue(node, clazz);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    public static Object toNode(String json) {
        if (json == null) {
            return null;
        }
        ObjectMapper mapper = new ObjectMapper();
        try {
            JsonNode jsonNode = mapper.readTree(json);
            return jsonNode;
        } catch (IOException e) {
            e.printStackTrace();
        }

        return null;
    }


}

 blade-service/blade-jfpts/src/main/java/org/springblade/jfpt/parcel/vo/ConditionVo.java

New file
@@ -0,0 +1,17 @@
package org.springblade.jfpt.parcel.vo;

import lombok.Data;

import java.io.Serializable;

@Data
public class ConditionVo implements Serializable {
    /**
     * 开始时间
     */
    private String startDate;
    /**
     * 结束时间
     */
    private String endDate;
}

 blade-service/blade-jfpts/src/main/resources/application.properties

@@ -1,2 +1,14 @@
#ͼƬ±£´æµ½´ÅÅÌ·¾¶
picture.addUrl= http://36.134.81.48:9000/
picture.pre= software/minio/data/jfpt/animalHeat/


#°ü¹ü½Ó¿ÚÃØÔ¿³£Á¿²ÎÊý
PARCEL_KEY=X-AISP-T
PARCEL_SECRET=A3_2f718467f64b82e7a3cb38bf77702c2a1615339643687

#²éѯijÆÚ¼äµÄÎ¥½ûÎïƷͳ¼Æ URL
PARCEL_CONTRABAND_URL=http://113.105.119.25:90/backstage-temporary-api/machineStat/queryMachineDayContrabandStat

#²éѯijÆÚ¼äµÄ°ü¹üͳ¼Æ URL
PARCEL_URL=http://113.105.119.25:90/backstage-temporary-api/machineStat/queryMachineDayStat