weaver-sxjg/src/main/java/com/weaver/seconddev/sxjg/util/NccApiUtil2.java

package com.weaver.seconddev.sxjg.util;

import com.alibaba.fastjson.JSONObject;
import com.weaver.ebuilder.common.exception.BusinessException;
import org.apache.commons.codec.binary.Base64;
import org.apache.commons.configuration.ConfigurationException;
import org.apache.commons.configuration.PropertiesConfiguration;
import org.apache.http.HttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.spec.OAEPParameterSpec;
import javax.crypto.spec.PSource;
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLEncoder;
import java.nio.charset.Charset;
import java.security.*;
import java.security.spec.MGF1ParameterSpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;

public class NccApiUtil2 {

    private static final Logger log = LoggerFactory.getLogger(NccApiUtil2.class);

    public String getBaseUrl() {
        return baseUrl;
    }

    public void setBaseUrl(String baseUrl) {
        this.baseUrl = baseUrl;
    }

    private String baseUrl;
    // 访问的nccloud系统的账套编码，开发环境使用develop，生产环境需要使用用root账号登录，在“系统管理”节点查看账套编码（由陕西建工HR系统提供）
    private String biz_center;

    public String getClient_id() {
        return client_id;
    }

    public void setClient_id(String client_id) {
        this.client_id = client_id;
    }

    //陕煤HR系统在陕西建工HR系统中应用注册当中的app_id
    private String client_id;
    //陕煤HR系统在陕西建工HR系统中应用注册当中的app_secret（由陕西建工HR系统提供）
    private String client_secret;
    //陕西建工HR系统中应用注册当中的(公钥)pubKey（由陕西建工HR系统提供）
    private String pubKey;

    private String signature;
    public void init() {
        PropertiesConfiguration p = null;
        try {
            p = new PropertiesConfiguration();
            p.setEncoding("utf-8");
            p.setFileName("config/nccconfig.properties");
            p.load();
            this.baseUrl  = p.getString("sxjgncc.url");
            this.biz_center = p.getString("sxjgncc.biz_center");
            this.client_id = p.getString("sxjgncc.client_id");
            this.client_secret = p.getString("sxjgncc.client_secret");
            this.pubKey = p.getString("sxjgncc.public_key");
        }catch (ConfigurationException e) {
            throw new BusinessException("获取sxjg.properties配置文件失败，", e);
        }
    }

    /**
     * 获取设置的ncc用户token
     * @return@
     * @throws Exception
     */
    public String getToken() throws Exception {
        Map<String, String> paramMap = new HashMap();
        //获取token方式（固定为client_credentials）
        paramMap.put("grant_type", "client_credentials");
        //陕煤HR系统在陕西建工HR系统中应用注册当中的app_id（由陕西建工HR系统提供）
        paramMap.put("client_id", this.client_id);
        //加密陕煤HR系统在陕西建工HR系统中应用注册当中的(公钥)pubKey和app_secret（由陕西建工HR系统提供）
        String encode = URLEncoder.encode(pubEncrypt(this.pubKey, this.client_secret), "UTF-8");//需要写入报文头中
        paramMap.put("client_secret", encode);
        // 账套编码，开发环境使用develop，生产环境需要使用用root账号登录，在“系统管理”节点查看账套编码（由陕西建工HR系统提供）
        paramMap.put("biz_center", this.biz_center);
        //请求加签，其算法getSHA256(client_id + client_secret + pubKey)
        String sign = getSHA256(this.client_id + this.client_secret + this.pubKey, this.pubKey);
        paramMap.put("signature", sign);//需要写入报文头中
        this.setSignature(sign);
        //查询token的url
        String url = this.baseUrl + "nccloud/opm/accesstoken";
        String mediaType = "application/x-www-form-urlencoded";
        String token = this.doPost(url, paramMap, mediaType, (Map)null, "");
        JSONObject rs = JSONObject.parseObject(token);
        if(rs.getBoolean("success")) {
            JSONObject jsonObject = rs.getJSONObject("data");
            String token1 = jsonObject.getString("access_token");
            return token1;
        }else {
            log.error("howec::::::::::::111:"+token);
            throw new Exception("获取toaken失败！");
        }
    }

    public String doJsonPost(String url, String accessToken, String json) {
        log.error("NCC接口"+url+"，推送报文：>>>>>>>>>>>>>>>>>>>>>>"+json);
        CloseableHttpClient client = HttpClients.createDefault();
        HttpPost post = new HttpPost(url);
        post.setHeader("Content-Type", "application/json;charset=utf-8");
        post.setHeader("access_token", accessToken);
        post.setHeader("repeat_check","Y");
        post.setHeader("ucg_flag","Y");
        post.setHeader("signature",this.getSignature());
        post.setHeader("client_id",this.getClient_id());

        String result="";
        try {
            StringEntity s = new StringEntity(json,"UTF-8");
            s.setContentEncoding("utf-8");
            s.setContentType("application/json");
            post.setEntity(s);
            // 发送请求
            HttpResponse httpResponse = client.execute(post);
            // 获取响应输入流
            InputStream inStream = httpResponse.getEntity().getContent();
            BufferedReader reader = new BufferedReader(new InputStreamReader(
                    inStream,"utf-8"));
            StringBuilder strber = new StringBuilder();
            String line;
            while ((line = reader.readLine()) != null)
                strber.append(line + "\n");
            inStream.close();
            result = strber.toString();
            log.error("NCC接口"+url+"，返回值：>>>>>>>>>>>>>>>>>>>>>>"+result);
        } catch (Exception e) {
            e.printStackTrace();
            log.error("NCC接口"+url+"，返回值：>>>>>>>>>>>1>>>>>>>>>>>"+e.getMessage());
        }
        return result;
    }

    public static String pubEncrypt(String pubKey, String src) throws Exception {
        String target = null;
        ByteArrayOutputStream out = null;

        try {
            Key key = getPublicKey(pubKey);
            Cipher cipher = Cipher.getInstance("RSA/ECB/OAEPWithSHA-256AndMGF1Padding");
            cipher.init(1, key, new OAEPParameterSpec("SHA-256", "MGF1", new MGF1ParameterSpec("SHA-256"), PSource.PSpecified.DEFAULT));
            byte[] data = src.getBytes();
            int inputLen = data.length;
            out = new ByteArrayOutputStream();
            int offSet = 0;

            for(int i = 0; inputLen - offSet > 0; offSet = i * 117) {
                byte[] cache;
                if (inputLen - offSet > 117) {
                    cache = cipher.doFinal(data, offSet, 117);
                } else {
                    cache = cipher.doFinal(data, offSet, inputLen - offSet);
                }

                out.write(cache, 0, cache.length);
                ++i;
            }

            target = (new Base64()).encodeToString(out.toByteArray());
        } catch (NoSuchPaddingException | InvalidKeyException | IllegalBlockSizeException | BadPaddingException | NoSuchAlgorithmException var14) {
            throw new Exception("加密失败", var14);
        } finally {
            if (out != null) {
                out.close();
            }

        }
        return target;
    }
    public static Key getPublicKey(String pubKey) throws Exception {
        PublicKey key = null;

        try {
            byte[] keyBytes = (new Base64()).decode(pubKey);;
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
            key = keyFactory.generatePublic(x509KeySpec);
            return key;
        } catch (Exception var5) {
            throw new Exception("无效的密钥  ", var5);
        }
    }

    public static String getSHA256(String str, String key) throws Exception {
        byte[] salt = new byte[16];
        SecureRandom random = SecureRandom.getInstance("SHA1PRNG");
        random.setSeed(key.getBytes());
        random.nextBytes(salt);
        String salt_value = (new Base64()).encodeToString(salt);
        return getSHA256(str + salt_value.replaceAll("\r|\n", ""));
    }
    private static String getSHA256(String str) throws Exception {
        String encodestr = "";
        MessageDigest messageDigest = MessageDigest.getInstance("SHA-256");
        messageDigest.update(str.getBytes("UTF-8"));
        encodestr = byte2Hex(messageDigest.digest());
        return encodestr;
    }
    private static String byte2Hex(byte[] bytes) {
        StringBuffer stringBuffer = new StringBuffer();
        String temp = null;

        for(int i = 0; i < bytes.length; ++i) {
            temp = Integer.toHexString(bytes[i] & 255);
            if (temp.length() == 1) {
                stringBuffer.append("0");
            }

            stringBuffer.append(temp);
        }

        return stringBuffer.toString();
    }




    /**
     * 发送post请求
     *
     * @param baseUrl
     * @param paramMap
     * @param mediaType
     * @param headers
     * @param json
     * @return
     */
    private static String doPost(String baseUrl, Map<String, String> paramMap, String mediaType, Map<String, String> headers, String json) {

        HttpURLConnection urlConnection = null;
        InputStream in = null;
        OutputStream out = null;
        BufferedReader bufferedReader = null;
        String result = null;
        try {
            StringBuffer sb = new StringBuffer();
            sb.append(baseUrl);
            if (paramMap != null) {
                sb.append("?");
                for (Map.Entry<String, String> entry : paramMap.entrySet()) {
                    String key = entry.getKey();
                    String value = entry.getValue();
                    sb.append(key + "=" + value).append("&");
                }
                baseUrl = sb.toString().substring(0, sb.toString().length() - 1);
            }

            URL urlObj = new URL(baseUrl);
            urlConnection = (HttpURLConnection) urlObj.openConnection();
            urlConnection.setConnectTimeout(50000);
            urlConnection.setRequestMethod("POST");
            urlConnection.setDoOutput(true);
            urlConnection.setDoInput(true);
            urlConnection.setUseCaches(false);
            urlConnection.addRequestProperty("content-type", mediaType);
            if (headers != null) {
                for (String key : headers.keySet()) {
                    urlConnection.addRequestProperty(key, headers.get(key));
                }
            }
            out = urlConnection.getOutputStream();
            out.write(json.getBytes("utf-8"));
            out.flush();
            int resCode = urlConnection.getResponseCode();
            if (resCode == HttpURLConnection.HTTP_OK || resCode == HttpURLConnection.HTTP_CREATED || resCode == HttpURLConnection.HTTP_ACCEPTED) {
                in = urlConnection.getInputStream();
            } else {
                in = urlConnection.getErrorStream();
            }
            bufferedReader = new BufferedReader(new InputStreamReader(in, "utf-8"));
            StringBuffer temp = new StringBuffer();
            String line = bufferedReader.readLine();
            while (line != null) {
                temp.append(line).append("\r\n");
                line = bufferedReader.readLine();
            }
            String ecod = urlConnection.getContentEncoding();
            if (ecod == null) {
                ecod = Charset.forName("utf-8").name();
            }
            result = new String(temp.toString().getBytes("utf-8"), ecod);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (null != bufferedReader) {
                try {
                    bufferedReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (null != out) {
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (null != in) {
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            urlConnection.disconnect();
        }
        return result;
    }


    public String getSignature() {
        return signature;
    }

    public void setSignature(String signature) {
        this.signature = signature;
    }
}