电表对接修改

common/common-entity/sql记录

@@ -1836,3 +1836,21 @@ VALUES ('808080eb80cbc1a3018114646a9c0028', NULL, 'repairMessage', 'repairMessag
--202206-13 ysj
INSERT INTO `base`.`dm_device` ( `category_code`, `photo`, `brands`, `model`, `name`, `is_multi_user`, `multi_user`, `czrq`, `del`, `service_topic`, `need_register`, `device_type`) VALUES ('21', 'group1/M00/00/06/ChIrKGKm1YeAeLJUAAFUbvcifo8051.png', 'trqjc', 'trqjc', '天然气监测', '0', NULL, '2022-06-13 13:53:55', '1', '', NULL, '1');
--2022-06-29 wsl
CREATE TABLE `base_hz_interface_dict` (
  `id` int(50) NOT NULL AUTO_INCREMENT,
  `url` varchar(100) COLLATE utf8_unicode_ci DEFAULT NULL COMMENT '接口地址',
  `code` varchar(20) COLLATE utf8_unicode_ci DEFAULT NULL COMMENT '接口code',
  `name` varchar(20) COLLATE utf8_unicode_ci DEFAULT NULL COMMENT '接口名字',
  `status` tinyint(2) DEFAULT NULL COMMENT '状态（1生效，0失效）',
  `create_time` datetime DEFAULT NULL COMMENT '创建时间',
  `app_key` varchar(50) COLLATE utf8_unicode_ci DEFAULT NULL COMMENT 'APP_KEY',
  `app_pwd` varchar(50) COLLATE utf8_unicode_ci DEFAULT NULL COMMENT 'APP秘钥',
  `refresh_secret` varchar(50) COLLATE utf8_unicode_ci DEFAULT NULL COMMENT '刷新秘钥',
  `refresh_secret_end_time` datetime DEFAULT NULL COMMENT '刷新秘钥过期时间',
  `request_secret` varchar(50) COLLATE utf8_unicode_ci DEFAULT NULL COMMENT '请求秘钥',
  `request_secret_end_time` datetime DEFAULT NULL COMMENT '请求秘钥过期时间',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci COMMENT='杭州接口';

common/common-entity/src/main/java/com/yihu/jw/entity/util/baseHzInterfaceDictEntity.java

@@ -0,0 +1,131 @@
package com.yihu.jw.entity.util;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.yihu.jw.entity.IdEntity;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.SequenceGenerator;
import javax.persistence.Table;
import java.util.Date;
/**
 * Created by wsl on 2022/6/29
 * 杭州接口
 */
@Entity
@Table(name = "base_hz_interface_dict")
@SequenceGenerator(name="id_generated", sequenceName="seq_base_hz_interface_dict")
public class baseHzInterfaceDictEntity extends IdEntity {
    private String url;//接口地址
    private String code;//接口code
    private String name;//接口名字
    private Integer status;//状态（1生效，0失效）
    private Date createTime;//创建时间
    private String appKey;//APP_KEY
    private String appPwd;//APP秘钥
    private String  refreshSecret;//刷新秘钥
    private Date refreshSecretEndTime;//刷新秘钥过期时间
    private String  requestSecret;//请求秘钥
    private Date requestSecretEndTime;//请求秘钥过期时间
    public String getUrl() {
        return url;
    }
    public void setUrl(String url) {
        this.url = url;
    }
    public String getCode() {
        return code;
    }
    public void setCode(String code) {
        this.code = code;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getStatus() {
        return status;
    }
    public void setStatus(Integer status) {
        this.status = status;
    }
    @Column(name = "create_time")
    public Date getCreateTime() {
        return createTime;
    }
    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }
    @Column(name = "app_key")
    public String getAppKey() {
        return appKey;
    }
    public void setAppKey(String appKey) {
        this.appKey = appKey;
    }
    @Column(name = "app_pwd")
    public String getAppPwd() {
        return appPwd;
    }
    public void setAppPwd(String appPwd) {
        this.appPwd = appPwd;
    }
    @Column(name = "refresh_secret")
    public String getRefreshSecret() {
        return refreshSecret;
    }
    public void setRefreshSecret(String refreshSecret) {
        this.refreshSecret = refreshSecret;
    }
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+08:00")
    @Column(name = "refresh_secret_end_time")
    public Date getRefreshSecretEndTime() {
        return refreshSecretEndTime;
    }
    public void setRefreshSecretEndTime(Date refreshSecretEndTime) {
        this.refreshSecretEndTime = refreshSecretEndTime;
    }
    @Column(name = "request_secret")
    public String getRequestSecret() {
        return requestSecret;
    }
    public void setRequestSecret(String requestSecret) {
        this.requestSecret = requestSecret;
    }
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+08:00")
    @Column(name = "request_secret_end_time")
    public Date getRequestSecretEndTime() {
        return requestSecretEndTime;
    }
    public void setRequestSecretEndTime(Date requestSecretEndTime) {
        this.requestSecretEndTime = requestSecretEndTime;
    }
}

svr/svr-cloud-care/pom.xml

@@ -276,6 +276,11 @@
            <artifactId>zwdd-sdk-java</artifactId>
            <version>1.2.0</version>
        </dependency>
        <dependency>
            <groupId>commons-httpclient</groupId>
            <artifactId>commons-httpclient</artifactId>
            <version>3.1</version>
        </dependency>
    </dependencies>
    <build>

svr/svr-cloud-care/src/main/java/com/yihu/jw/care/dao/device/BaseHzInterfaceDictDao.java

@@ -0,0 +1,13 @@
package com.yihu.jw.care.dao.device;
import com.yihu.jw.entity.util.baseHzInterfaceDictEntity;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.repository.PagingAndSortingRepository;
/**
 * Created by wsl on 2022/6/29
 */
public interface BaseHzInterfaceDictDao extends PagingAndSortingRepository<baseHzInterfaceDictEntity,Long>,
        JpaSpecificationExecutor<baseHzInterfaceDictEntity> {
}

svr/svr-cloud-care/src/main/java/com/yihu/jw/care/endpoint/statistics/OpenStatisticsEndpoint.java

@@ -4,6 +4,7 @@ import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.yihu.jw.care.service.assistance.EmergencyAssistanceService;
import com.yihu.jw.care.service.doctor.CareDoctorService;
import com.yihu.jw.care.service.hz.HzInterfaceService;
import com.yihu.jw.care.service.lifeCare.LifeCareOrderService;
import com.yihu.jw.care.service.patient.CarePatientService;
import com.yihu.jw.care.service.statistics.StatisticsService;
@@ -712,6 +713,10 @@ public class OpenStatisticsEndpoint extends EnvelopRestEndpoint {
        }
    }
    @Autowired
    HzInterfaceService hzInterfaceService;
    @GetMapping(value = "electricityTable")
    @ApiOperation(value = "获取电表信息")
    public ObjEnvelop findElectricityTable(@ApiParam(name = "queryDate",value = "查询时间",required = true)
@@ -720,17 +725,19 @@ public class OpenStatisticsEndpoint extends EnvelopRestEndpoint {
                                           @RequestParam(value = "name",required = false)String name){
        try {
            return success(statisticsService.electricityTable(queryDate, name));
            return success(hzInterfaceService.electricityTable(queryDate, name));
        } catch (Exception e) {
            e.printStackTrace();
            return failedObjEnvelopException2(e);
        }
    }
    //密钥
    @GetMapping(value = "PopBasicInfo")
    public Envelop PopBasicInfo(){
        try {
            statisticsService.PopBasicInfo();
            hzInterfaceService.PopBasicInfo();
            return success("成功");
        } catch (Exception e) {
            e.printStackTrace();

svr/svr-cloud-care/src/main/java/com/yihu/jw/care/service/hz/HzInterfaceService.java

@@ -0,0 +1,191 @@
package com.yihu.jw.care.service.hz;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.yihu.jw.care.dao.device.BaseHzInterfaceDictDao;
import com.yihu.jw.care.util.DSLUtils;
import com.yihu.jw.care.util.HttpToolUtil;
import com.yihu.jw.care.util.MD5Utils;
import com.yihu.jw.entity.util.baseHzInterfaceDictEntity;
import com.yihu.jw.util.date.DateUtil;
import com.yihu.jw.util.http.HttpClientUtil;
import org.apache.commons.httpclient.Header;
import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.methods.PostMethod;
import org.apache.commons.httpclient.methods.multipart.MultipartRequestEntity;
import org.apache.commons.httpclient.methods.multipart.Part;
import org.apache.commons.httpclient.methods.multipart.StringPart;
import org.apache.commons.httpclient.params.HttpMethodParams;
import org.apache.commons.io.IOUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpMethod;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.net.URLEncoder;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
/**
 * Created by wsl on 2022/6/29
 */
@Service
public class HzInterfaceService {
    Logger logger = LoggerFactory.getLogger(HzInterfaceService.class);
    @Autowired
    private StringRedisTemplate redisTemplate;
    @Autowired
    private BaseHzInterfaceDictDao baseHzInterfaceDictDao;
    @Autowired
    private JdbcTemplate jdbcTemplate;
    @Autowired
    private HttpClientUtil httpClientUtil;
    public JSONObject electricityTable(String name,String date) throws Exception {
        //
        String cityApi = getAreaApi(date);
        JSONObject jsonObject = JSONObject.parseObject(cityApi);
        JSONArray dataArr = jsonObject.getJSONArray("data");
        for (Object o : dataArr) {
            //JSONObject.parseObject();
        }
        return null;
    }
    private String getAreaApi(String date) throws Exception{
        baseHzInterfaceDictEntity dbkey = DBKEY();
        if(!redisTemplate.hasKey(dbkey.getCode())){
            PopBasicInfo();
        }
        String privateKey = redisTemplate.opsForValue().get(dbkey.getCode());
        //请求接口地址（政务网环境根据接口文档地址改动）
        String electricityTableSql = "SELECT url FROM base_hz_interface_dict WHERE `status` = 1 AND `code` = 'zfjddjlrdbjk'";
        String url = jdbcTemplate.queryForObject(electricityTableSql, String.class);
        String requestTime = DSLUtils.dateToLong(new Date()) + "";//时间戳
        JSONObject json = new JSONObject();
        json.put("queryDate",date);
        json.put("sign",MD5Utils.encoderByMd5(dbkey.getAppKey()+ dbkey.getRequestSecret() + requestTime));
        json.put("requestTime",date);
        json.put("appKey",privateKey);
        HttpEntity<JSONObject> response = httpClientUtil.assesTokenPostHttp(url, json, HttpMethod.POST);
        logger.info("电表接口调用结果----> "+response);
        JSONObject responseBody = response.getBody();
        logger.info("电表接口调用结果Body----> "+responseBody);
        /*String request = RSAUtils.encryptByPrivateKey(json.toJSONString(),privateKey);
        String sign = RSAUtils.sign(request,privateKey);
        Part[] parts = {
                new StringPart("request", request,"UTF-8"),
                new StringPart("sign", sign,"UTF-8")
        };
        String result = post(url,parts);*/
        return null;
    }
    //post方式
    private static String post(String url, Part[] parts){
        /**导入SSL证书 [解决PKIX path building failed错误问题]**/
        initCert(url);
        HttpClient client = new HttpClient();
        PostMethod post = new PostMethod(url);
        post.getParams().setParameter(HttpMethodParams.HTTP_CONTENT_CHARSET, "UTF-8");
        if(parts != null) post.setRequestEntity(new MultipartRequestEntity(parts, post.getParams()));
        String response="";
        try {
            //按需加载请求头参数
            post.setRequestHeader(new Header("systemDepartmentCode", URLEncoder.encode("请求部门","utf-8")));
            post.setRequestHeader(new Header("areaCode", URLEncoder.encode("所在行政区域","utf-8")));
            client.executeMethod(post);
            response = IOUtils.toString(post.getResponseBodyAsStream(),"UTF-8");
        } catch (Exception e){
            e.printStackTrace();
        }finally {
            post.releaseConnection();
        }
        return response;
    }
    private static void initCert(final String url){
        /**
         * 导入SSL证书 [解决PKIX path building failed错误问题]
         *    --使用[javax.net.ssl.trustStore]不能解决多域名证书问题
         *    --建议将生成的证书文件 copy 到$JAVA_HOME/jre/lib/security目录下
         */
        String[] c = url.replaceFirst("(http|https)://","").split("/")[0].split(":");
        String host = c[0];
        Integer port = (c.length == 1) ? 443 : Integer.parseInt(c[1]);
        if(System.getProperty(host + "ssl_cert_path") != null) return;
        try {
            String sslCertPath = InstallCert.createCert(host,port);
            System.out.println("证书文件生成路径--->" + sslCertPath);
            System.setProperty(host + "ssl_cert_path", sslCertPath);
            System.setProperty("javax.net.ssl.trustStore", sslCertPath);
        }catch (Exception e){
            e.printStackTrace();
        }
        /****证书导入成功****/
    }
    @Transactional(rollbackFor = Exception.class)
    public String PopBasicInfo() {
        Map<String, String> params = new HashMap<String, String>();
        baseHzInterfaceDictEntity dbkey = DBKEY();
        String appkey = dbkey.getAppKey();   //appKey
        String requstSecret = dbkey.getAppPwd();//app密钥
        String requestTime = DSLUtils.dateToLong(new Date()) + "";//时间戳
        String url = dbkey.getUrl();  //请求url
        //sign 格式：APP_KEY + APP秘钥+时间戳，经过MD5加密生成的串(字母小写)
        String sign = MD5Utils.encoderByMd5(appkey + requstSecret + requestTime);
        params.put("appKey", appkey);
        params.put("sign", sign);
        params.put("requestTime", requestTime);
        JSONObject resultObj = HttpToolUtil.httpURLConnection_sendPost(url, params);
        logger.info("接口返回值:"+resultObj.toString());
        System.out.println("接口返回值:"+resultObj.toString());
        JSONObject datasObj = JSONObject.parseObject(resultObj.get("datas").toString());
        dbkey.setRefreshSecret(datasObj.get("refreshSecret").toString());
        dbkey.setRefreshSecretEndTime(DateUtil.strToDateLong(datasObj.get("refreshSecretEndTime").toString()));
        dbkey.setRequestSecret(datasObj.get("requestSecret").toString());
        dbkey.setRequestSecretEndTime(DateUtil.strToDateLong(datasObj.get("requestSecretEndTime").toString()));
        baseHzInterfaceDictDao.save(dbkey);
        redisTemplate.opsForValue().set(dbkey.getCode(),datasObj.get("requestSecret").toString(),14, TimeUnit.MINUTES);
        return resultObj.toString();
    }
    public baseHzInterfaceDictEntity DBKEY(){
        String sql = "SELECT * FROM base_hz_interface_dict WHERE `status` = 1 AND `code` = 'dbmyhq'";
        return jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<>(baseHzInterfaceDictEntity.class));
    }
}

svr/svr-cloud-care/src/main/java/com/yihu/jw/care/service/hz/InstallCert.java

@@ -0,0 +1,119 @@
package com.yihu.jw.care.service.hz;
import javax.net.ssl.*;
import java.io.*;
import java.security.KeyStore;
import java.security.MessageDigest;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
public class InstallCert {
    public static void main(String[] args) throws Exception {
        String filePath = createCert("sql.hz.gov.cn",443);
    }
    public static String createCert(String host,int port) throws Exception{
        File certs = new File(System.getProperty("java.home")
                + File.separatorChar + "lib"
                + File.separatorChar + "security"
                + File.separatorChar + "cacerts");
        char[] passphrase = "changeit".toCharArray();
        System.out.println("Loading KeyStore " + certs + "...");
        InputStream in = new FileInputStream(certs);
        KeyStore ks = KeyStore.getInstance(KeyStore.getDefaultType());
        ks.load(in, passphrase);
        in.close();
        SSLContext context = SSLContext.getInstance("TLS");
        TrustManagerFactory tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
        tmf.init(ks);
        X509TrustManager defaultTrustManager = (X509TrustManager)tmf.getTrustManagers()[0];
        SavingTrustManager tm = new SavingTrustManager(defaultTrustManager);
        context.init(null, new TrustManager[] {tm}, null);
        SSLSocketFactory factory = context.getSocketFactory();
        System.out.println("Opening connection to " + host + ":" + port + "...");
        SSLSocket socket = (SSLSocket)factory.createSocket(host, port);
        socket.setSoTimeout(10000);
        try {
            System.out.println("Starting SSL handshake...");
            socket.startHandshake();
            socket.close();
            System.out.println("No errors, certificate is already trusted");
        } catch (SSLException e) {
            e.printStackTrace();
        }
        X509Certificate[] chain = tm.chain;
        if (chain == null) {
            System.out.println("Could not obtain server certificate chain");
            return null;
        }
        System.out.println("Server sent " + chain.length + " certificate(s):");
        MessageDigest sha1 = MessageDigest.getInstance("SHA1");
        MessageDigest md5 = MessageDigest.getInstance("MD5");
        for (int i = 0; i < chain.length; i++) {
            X509Certificate cert = chain[i];
            sha1.update(cert.getEncoded());
            md5.update(cert.getEncoded());
        }
        int k = 0;
        X509Certificate cert = chain[k];
        String alias = host + "-" + (k + 1);
        ks.setCertificateEntry(alias, cert);
        String filePath = System.getProperty("java.home")
                + File.separatorChar + "lib"
                + File.separatorChar + "security"
                + File.separatorChar + host + ".jssecacerts";
        File certFile = new File(filePath);
        OutputStream out = new FileOutputStream(certFile);
        ks.store(out, passphrase);
        out.close();
        System.out.println(cert);
        System.out.println("Added certificate to keystore 'jssecacerts' using alias '"+ alias + "'");
        return certFile.getAbsolutePath();
    }
    private static final char[] HEXDIGITS = "0123456789abcdef".toCharArray();
    private static String toHexString(byte[] bytes) {
        StringBuilder sb = new StringBuilder(bytes.length * 3);
        for (int b : bytes) {
            b &= 0xff;
            sb.append(HEXDIGITS[b >> 4]);
            sb.append(HEXDIGITS[b & 15]);
            sb.append(' ');
        }
        return sb.toString();
    }
    private static class SavingTrustManager implements X509TrustManager {
        private final X509TrustManager tm;
        private X509Certificate[] chain;
        SavingTrustManager(X509TrustManager tm) {
            this.tm = tm;
        }
        public X509Certificate[] getAcceptedIssuers() {
            throw new UnsupportedOperationException();
        }
        public void checkClientTrusted(X509Certificate[] chain, String authType)
                throws CertificateException {
            throw new UnsupportedOperationException();
        }
        public void checkServerTrusted(X509Certificate[] chain, String authType)
                throws CertificateException {
            this.chain = chain;
            tm.checkServerTrusted(chain, authType);
        }
    }
}

svr/svr-cloud-care/src/main/java/com/yihu/jw/care/service/hz/RSAUtils.java

@@ -0,0 +1,332 @@
package com.yihu.jw.care.service.hz;
import javax.crypto.Cipher;
import java.io.ByteArrayOutputStream;
import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;
import java.util.HashMap;
import java.util.Map;
public class RSAUtils {
    /** *//**
     * 加密算法RSA
     */
    public static final String KEY_ALGORITHM = "RSA";
    /** *//**
     * 签名算法
     */
    public static final String SIGNATURE_ALGORITHM = "MD5withRSA";
    /** *//**
     * 获取公钥的key
     */
    private static final String PUBLIC_KEY = "RSAPublicKey";
    /** *//**
     * 获取私钥的key
     */
    private static final String PRIVATE_KEY = "RSAPrivateKey";
    /** *//**
     * RSA最大加密明文大小
     */
    private static final int MAX_ENCRYPT_BLOCK = 117;
    /** *//**
     * RSA最大解密密文大小
     */
    private static final int MAX_DECRYPT_BLOCK = 128;
    /** *//**
     * <p>
     * 生成密钥对(公钥和私钥)
     * </p>
     *
     * @return
     * @throws Exception
     */
    public static Map<String, Object> genKeyPair() throws Exception {
        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
        keyPairGen.initialize(1024);
        KeyPair keyPair = keyPairGen.generateKeyPair();
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
        Map<String, Object> keyMap = new HashMap<String, Object>(2);
        keyMap.put(PUBLIC_KEY, publicKey);
        keyMap.put(PRIVATE_KEY, privateKey);
        return keyMap;
    }
    /** *//**
     * <p>
     * 用私钥对信息生成数字签名
     * </p>
     *
     * @param content 已加密数据
     * @param privateKey 私钥(BASE64编码)
     *
     * @return
     * @throws Exception
     */
    public static String sign(String content, String privateKey) throws Exception {
        byte[] keyBytes = decryptBASE64(privateKey);
        byte[] data = content.getBytes("UTF-8");
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        signature.initSign(privateK);
        signature.update(data);
        return encryptBASE64(signature.sign());
    }
    /** *//**
     * <p>
     * 校验数字签名
     * </p>
     *
     * @param content 已加密数据
     * @param publicKey 公钥(BASE64编码)
     * @param sign 数字签名
     *
     * @return
     * @throws Exception
     *
     */
    public static boolean verify(String content, String publicKey, String sign)
            throws Exception {
        byte[] keyBytes = decryptBASE64(publicKey);
        byte[] data = content.getBytes("UTF-8");
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        PublicKey publicK = keyFactory.generatePublic(keySpec);
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        signature.initVerify(publicK);
        signature.update(data);
        return signature.verify(decryptBASE64(sign));
    }
    /** *//**
     * <P>
     * 私钥解密
     * </p>
     *
     * @param content 已加密数据
     * @param privateKey 私钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static String decryptByPrivateKey(String content, String privateKey)
            throws Exception {
        byte[] keyBytes = decryptBASE64(privateKey);
        byte[] encryptedData = decryptBASE64(content);
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, privateK);
        int inputLen = encryptedData.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段解密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
                cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_DECRYPT_BLOCK;
        }
        byte[] decryptedData = out.toByteArray();
        out.close();
        return new String(decryptedData,"UTF-8");
    }
    /** *//**
     * <p>
     * 公钥解密
     * </p>
     *
     * @param content 已加密数据
     * @param publicKey 公钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static String decryptByPublicKey(String content, String publicKey)
            throws Exception {
        byte[] keyBytes = decryptBASE64(publicKey);
        byte[] encryptedData = decryptBASE64(content);
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key publicK = keyFactory.generatePublic(x509KeySpec);
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, publicK);
        int inputLen = encryptedData.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段解密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
                cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_DECRYPT_BLOCK;
        }
        byte[] decryptedData = out.toByteArray();
        out.close();
        return new String(decryptedData,"UTF-8");
    }
    /** *//**
     * <p>
     * 公钥加密
     * </p>
     *
     * @param content 源数据
     * @param publicKey 公钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static String encryptByPublicKey(String content, String publicKey)
            throws Exception {
        byte[] keyBytes = decryptBASE64(publicKey);
        byte[] data = content.getBytes("UTF-8");
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key publicK = keyFactory.generatePublic(x509KeySpec);
        // 对数据加密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, publicK);
        int inputLen = data.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段加密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
                cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(data, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_ENCRYPT_BLOCK;
        }
        byte[] encryptedData = out.toByteArray();
        out.close();
        //Base64加密
        return encryptBASE64(encryptedData);
    }
    /** *//**
     * <p>
     * 私钥加密
     * </p>
     *
     * @param content 源数据
     * @param privateKey 私钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static String encryptByPrivateKey(String content, String privateKey)
            throws Exception {
        byte[] keyBytes = decryptBASE64(privateKey);
        byte[] data = content.getBytes("UTF-8");
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, privateK);
        int inputLen = data.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段加密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
                cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(data, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_ENCRYPT_BLOCK;
        }
        byte[] encryptedData = out.toByteArray();
        out.close();
        //Base64加密
        return encryptBASE64(encryptedData);
    }
    /** *//**
     * <p>
     * 获取私钥
     * </p>
     *
     * @param keyMap 密钥对
     * @return
     * @throws Exception
     */
    public static String getPrivateKey(Map<String, Object> keyMap)
            throws Exception {
        Key key = (Key) keyMap.get(PRIVATE_KEY);
        return encryptBASE64(key.getEncoded());
    }
    /** *//**
     * <p>
     * 获取公钥
     * </p>
     *
     * @param keyMap 密钥对
     * @return
     * @throws Exception
     */
    public static String getPublicKey(Map<String, Object> keyMap)
            throws Exception {
        Key key = (Key) keyMap.get(PUBLIC_KEY);
        return encryptBASE64(key.getEncoded());
    }
    /**
     * BASE64解密
     *
     * @param key
     * @return
     * @throws Exception
     */
    public static byte[] decryptBASE64(String key) throws Exception {
        return Base64.getDecoder().decode(key);
    }
    /**
     * BASE64加密
     *
     * @param key
     * @return
     * @throws Exception
     */
    public static String encryptBASE64(byte[] key) throws Exception {
        return Base64.getEncoder().encodeToString(key);
    }
}

svr/svr-cloud-care/src/main/java/com/yihu/jw/care/service/statistics/StatisticsService.java

@@ -3,12 +3,15 @@ package com.yihu.jw.care.service.statistics;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.yihu.jw.care.dao.device.BaseHzInterfaceDictDao;
import com.yihu.jw.care.dao.device.PatientDeviceDao;
import com.yihu.jw.care.dao.message.BaseServiceNewsDao;
import com.yihu.jw.care.dao.security.EmergencyWarnDoctorResponseDao;
import com.yihu.jw.care.service.patient.CarePatientService;
import com.yihu.jw.care.service.role.RoleService;
import com.yihu.jw.care.util.*;
import com.yihu.jw.care.util.CommonUtil;
import com.yihu.jw.care.util.ConstantUtil;
import com.yihu.jw.care.util.HttpClientUtilCare;
import com.yihu.jw.care.vo.NumVo;
import com.yihu.jw.dict.dao.DictHospitalDeptDao;
import com.yihu.jw.doctor.dao.BaseDoctorDao;
@@ -29,13 +32,13 @@ import com.yihu.jw.patient.dao.BasePatientDao;
import com.yihu.jw.restmodel.web.PageEnvelop;
import com.yihu.jw.util.common.IdCardUtil;
import com.yihu.jw.util.date.DateUtil;
import com.yihu.jw.util.wechat.wxhttp.HttpUtil;
import org.apache.commons.collections.map.HashedMap;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;
@@ -94,6 +97,12 @@ public class StatisticsService {
    private BaseServiceNewsDao baseServiceNewsDao;
    @Autowired
    private EmergencyWarnDoctorResponseDao emergencyWarnDoctorResponseDao;
    @Autowired
    private HttpClientUtilCare httpClientUtil;
    @Autowired
    private StringRedisTemplate redisTemplate;
    @Autowired
    private BaseHzInterfaceDictDao baseHzInterfaceDictDao;
    private static final String defalutArea = "330100";
@@ -4019,63 +4028,4 @@ public class StatisticsService {
    public JSONObject electricityTable(String name,String date) throws Exception {
        String A =  "{\"code\":\"0\",\"msg\":\"\",\"uniqueCode\":null,\"exception\":null,\"data\":[{\"statDate\":\"2022-05-31\",\"address\":\"中山北园XX-X-701\",\"name\":\"陈一\",\"upperLimit\":\"-0.*****\",\"lowerLimit\":\"0.****915\",\"consNo\":\"3306010XXX774\",\"home\":\"正常\"}]}";
        String url = "https://sql.hz.gov.cn/ESBWeb/servlets/33.1111.zjhz.8YvIYFO4kn.SynReq@1.0";
       // Map<String, String> params = new HashMap<>();
       // params.put("queryDate",date);
        JSONObject result = new JSONObject();
        JSONObject resultObj = JSONObject.parseObject(A);
        result.put("up",null);
        result.put("down",null);
        result.put("home",null);
       /* JSONObject param = new JSONObject();
        param.put("queryDate",date);
        HttpEntity<JSONObject> response = httpClientUtil.assesTokenPostHttp(url, param, HttpMethod.POST);
        //String resultStr = HttpClientUtilCare.httpPost(url, params);
        JSONObject responseBody = response.getBody();
        System.out.println("返回参数"+responseBody);
        logger.info("请求返回参数: " + responseBody);
        JSONObject resultObj = JSONObject.parseObject(resultStr);*/
        logger.info("类型转换JsonObject:" + resultObj);
        JSONArray resultArr = (JSONArray) resultObj.get("data");
        logger.info("类型转换JsonArray: " + resultArr);
        for (Object o : resultArr) {
            JSONObject jsonObject = JSONObject.parseObject(o.toString());
            System.out.println(jsonObject);
            if (name.equals(jsonObject.get("name"))) {
                result.put("up", jsonObject.get("upperLimit"));
                result.put("down", jsonObject.get("lowerLimit"));
                result.put("home", jsonObject.get("home"));
            }
        }
        return result;
    }
    static String appkey = "ecaldyg1yghy406upowxojgbefgu4p3y";  // app key
    static String requstSecret = "l2ez31hr4ifqyb2hdrvmuku3l5s4wilw"; // app密钥
    String requestTime = DSLUtils.dateToLong(new Date()) + "";
    private HttpUtil httpUtil = new  HttpUtil();
    public String PopBasicInfo() {
        Map<String, String> params = new HashMap<String, String>();
        String url = "http://172.18.95.14:8775/interface/public/service/risen-inte/reTokenBySec.action";
        String sign = MD5Utils.encoderByMd5(appkey + requstSecret + requestTime);
        params.put("appKey", appkey);
        params.put("sign", sign);
        params.put("requestTime", requestTime);
        JSONObject resultObj = HttpToolUtil.httpURLConnection_sendPost(url, params);
        System.out.println(resultObj.toString());
        return resultObj.toString();
    }
}