package com.demo.test;

import com.alibaba.fastjson.JSONObject;
import com.demo.utils.OkHttpUtils;
import org.springframework.beans.factory.annotation.Autowired;

import java.util.HashMap;
import java.util.Map;

/**
 * @Author zf
 * @ClassName QueryPhoneInfo.java
 * @ProjectName demo
 */
public class QueryPhoneInfo {

    @Autowired
    private static OkHttpUtils okHttpUtils;

    public static final String DATA = "data";
    public static final String URL = "https://cx.shouji.360.cn/phonearea.php?number=";

    public static final Map<String, String> PhoneConstants;
    static {
        // 手机号码信息常量
        PhoneConstants = new HashMap<>();
        PhoneConstants.put("省份", "province");
        PhoneConstants.put("城市", "city");
        PhoneConstants.put("运营商", "sp");
    }

    /**
     * @Description //TODO 查询手机号码归属地和运营商信息
     * @param phone 手机号码
     * @return JSONObject
    */
    public static JSONObject queryPhone(String phone){
        //用get方式将组装好的参数向接口发起请求。
        String result = okHttpUtils.getInstance().doGet(URL+phone);
        //用json对象接收接口返回的数据。
        JSONObject jsonObject = JSONObject.parseObject(result);
        //判断json对象中是否包含键名data。
        if (!jsonObject.containsKey(DATA)){
        return null;
        }
        //将键名为data的json对象引入`ResultTransToJson`方法，返回格式化后的json对象。
        return ResultTransToJson(jsonObject.getJSONObject(DATA));
    }

    /**
     * @Description //TODO 接收接口返回的信息并格式化（英文变量替换为中文）。
     * @param data
     * @return JSONObject
    */
    private static JSONObject ResultTransToJson(JSONObject data){
        //引入自定义常量。
        Map<String, String> keyMap = PhoneConstants;
        //创建一个新的json对象。
        JSONObject jsonObject = new JSONObject();
        //取出keyMap中所有的key（以set集合的形式返回），然后遍历set集合，取出每一个key。
        keyMap.keySet().forEach(e -> {
            //判断data对象中是否包含keyMap中的value值。
            if (data.containsKey(keyMap.get(e))){
            //用从keyMap中取出的key给jsonObject对象的key赋值，并根据keyMap中的key对应的value值从data对象中取值。
            jsonObject.put(e, data.getString(keyMap.get(e)));
            }
        });
        //返回格式化后的json对象。
        return jsonObject;
    }

    public static void main(String[] args) {
        //用于测试的手机号码。
        System.out.println(queryPhone("17625999999"));
    }
}

package com.demo.utils;

import lombok.extern.slf4j.Slf4j;
import okhttp3.*;
import org.apache.commons.lang3.StringUtils;

import javax.net.ssl.*;
import java.net.URLEncoder;
import java.security.SecureRandom;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;

/**
 * okhttp网络工具类
 */
@Slf4j
public class OkHttpUtils {
    private static final byte[] LOCKER = new byte[0];
    private static OkHttpUtils mInstance;
    private OkHttpClient okHttpClient;
    private static final MediaType MEDIA_TYPE_JSON = MediaType.parse("application/json; charset=utf-8");
    private static final MediaType MEDIA_TYPE_XML = MediaType.parse("application/xml; charset=utf-8");

    private OkHttpUtils() {

        okhttp3.OkHttpClient.Builder ClientBuilder=new okhttp3.OkHttpClient.Builder();
        ClientBuilder.readTimeout(20, TimeUnit.SECONDS);//读取超时
        ClientBuilder.connectTimeout(6, TimeUnit.SECONDS);//连接超时
        ClientBuilder.writeTimeout(60, TimeUnit.SECONDS);//写入超时
        //支持HTTPS请求，跳过证书验证
        ClientBuilder.sslSocketFactory(createSSLSocketFactory());
        ClientBuilder.hostnameVerifier(new HostnameVerifier() {
            @Override
            public boolean verify(String hostname, SSLSession session) {
                return true;
            }
        });
        okHttpClient=ClientBuilder.build();
    }

    /**
     * 单例模式获取NetUtils
     * @return
     */
    public static OkHttpUtils getInstance() {
        if (mInstance == null) {
            synchronized (LOCKER) {
                if (mInstance == null) {
                    mInstance = new OkHttpUtils();
                }
            }
        }
        return mInstance;
    }

    /**get请求
     * @param url
     * @return String
     * */
    public String doGet(String url){
        if (isBlankUrl(url)){
            return null;
        }
        Request request = getRequestForGet(url);
        return commonRequest(request);
    }

    /**get请求
     * @param url
     *  @param params
     * @return String
     * */
    public String doGet(String url, HashMap<String, String> params){
        if (isBlankUrl(url)){
            return null;
        }
        Request request = getRequestForGet(url, params);
        return commonRequest(request);
    }

    /**post请求
     * @param url
     * @param json
     * @return String
     * */
    public String doPostJson(String url, String json){
        if (isBlankUrl(url)){
            return null;
        }
        Request request = getRequestForPostJson(url, json);
        return commonRequest(request);
    }

    /**post form请求
     * @param url
     * @param params
     * @return String
     * */
    public String doPostForm(String url, Map<String, String> params){
        if (isBlankUrl(url)) {
            return null;
        }
        Request request = getRequestForPostForm(url, params);
        return commonRequest(request);
    }

    /**
     * post请求
     * @param url   接口地址
     * @param xmlStr   xml格式请求参数体
     * @return String
     */
    public String doPostXml(String url,String xmlStr){
        if (isBlankUrl(url)){
            return null;
        }
        RequestBody body=RequestBody.create(MEDIA_TYPE_XML,xmlStr);
        Request request = new Request.Builder()
                .url(url)
                .post(body)
                .build();
        return commonRequest(request);
    }

    private Boolean isBlankUrl(String url){
        if (StringUtils.isBlank(url)){
            //log.info("url is not blank");
            return true;
        }else{
            return false;
        }
    }

    private String commonRequest(Request request){
        String re = "";
        try {
            Call call = okHttpClient.newCall(request);
            Response response = call.execute();
            if (response.isSuccessful()){
                re = response.body().string();
                log.info("request url:{};response:{}", request.url().toString(), re);
            }else {
                log.info("request failure url:{};message:{}", request.url().toString(), response.message());
            }
        }catch (Exception e){
            //log.error("request execute failure", e);
        }
        return re;
    }

    private Request getRequestForPostJson(String url, String json) {
        RequestBody body = RequestBody.create(MEDIA_TYPE_JSON, json);
        Request request = new Request.Builder()
                .url(url)
                .post(body)
                .build();
        return request;
    }


    private Request getRequestForPostForm(String url, Map<String, String> params) {
        if (params == null) {
            params = new HashMap<>();
        }
        FormBody.Builder builder = new FormBody.Builder();
        if (params != null && params.size() > 0) {
            for (Map.Entry<String, String> entry : params.entrySet()) {
                //builder.addEncoded(entry.getKey(), entry.getValue());
                builder.add(entry.getKey(), entry.getValue());
            }
        }
        RequestBody requestBody = builder.build();
        Request request = new Request.Builder()
                .url(url)
                .post(requestBody)
                .build();
        return request;
    }

    private Request getRequestForGet(String url, HashMap<String, String> params) {
        Request request = new Request.Builder()
                .url(getUrlStringForGet(url, params))
                .build();
        return request;
    }

    private Request getRequestForGet(String url) {
        Request request = new Request.Builder()
                .url(url)
                .build();
        return request;
    }

    private String getUrlStringForGet(String url, HashMap<String, String> params) {
        StringBuilder urlBuilder = new StringBuilder();
        urlBuilder.append(url);
        urlBuilder.append("?");
        if (params != null && params.size() > 0) {
            for (Map.Entry<String, String> entry : params.entrySet()) {
                try {
                    urlBuilder.append("&").append(entry.getKey()).append("=").append(URLEncoder.encode(entry.getValue(), "UTF-8"));
                } catch (Exception e) {
                    urlBuilder.append("&").append(entry.getKey()).append("=").append(entry.getValue());
                }
            }
        }
        return urlBuilder.toString();
    }


    /**
     * 生成安全套接字工厂，用于https请求的证书跳过
     *
     * @return
     */
    public SSLSocketFactory createSSLSocketFactory() {
        SSLSocketFactory ssfFactory = null;
        try {
            SSLContext sc = SSLContext.getInstance("TLS");
            sc.init(null, new TrustManager[]{new TrustAllCerts()}, new SecureRandom());
            ssfFactory = sc.getSocketFactory();
        } catch (Exception e) {
        }
        return ssfFactory;
    }

    /**
     * 用于信任所有证书
     */
    class TrustAllCerts implements X509TrustManager {
        @Override
        public void checkClientTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {
        }

        @Override
        public void checkServerTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {

        }

        @Override
        public X509Certificate[] getAcceptedIssuers() {
            return new X509Certificate[0];
        }
    }
}