百度统计在项目中的使用

最新推荐文章于 2024-07-01 22:14:45 发布

smileTimLi

最新推荐文章于 2024-07-01 22:14:45 发布

阅读量4.1k

点赞数 2

分类专栏： java 文章标签：百度统计

本文链接：https://blog.csdn.net/qq_35275233/article/details/81316820

版权

java 专栏收录该内容

73 篇文章 1 订阅

订阅专栏

1.百度统计统计在前端页面

该段代码建议放到页面的<head>标签中，如果因为某些特殊原因，您不方便把该段代码加在</head>标签前面，那么也可以加到<body>标签的后面（请注意：不是</body>标签），总之原则是这段代码的位置越靠前就越好。

如果您页面中存在多段百度统计的访问分析代码，那么必须使用_setAccount接口来指定由哪一段代码来响应JS-API调用，最好把它加到页头</head>标签前的代码里：

<script>  
var _hmt = _hmt || [];
_hmt.push(['_setAccount', '0123456789ABCDEF0123456789ABCDEF']);
</script>

  <script>
        var _hmt = _hmt || [];
        (function() {
            var hm = document.createElement("script");
            hm.src = "https://hm.baidu.com/hm.js?0428b0b2559e8ac32fefa9cca6005ec7";
            var s = document.getElementsByTagName("script")[0];
            s.parentNode.insertBefore(hm, s);
        })();
    </script>

2.百度统计在代码中如何调用

  @RequestMapping("/statisticsQueryPvAndUvCount")
    @ResponseBody
    public String queryPvCount(HttpServletRequest request, @RequestParam(value = "time", required = false, defaultValue = "time") String time,
                               @RequestParam("processData") String callback,
                               HttpServletResponse response) {
        String result = "";
        try {
            response.setCharacterEncoding("UTF-8");
            response.setContentType("text/html;charset=UTF-8");
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyyMMdd");
            Date endTime;
            String endYimeStr = "";
            if ("time".equalsIgnoreCase(time)) {
                endTime = new Date();
                endYimeStr = simpleDateFormat.format(endTime);
            } else {
                //类型转换，结束时间
                endTime = simpleDateFormat.parse(time);
                endYimeStr = simpleDateFormat.format(endTime);
            }
            Map<String, String> header = new LinkedHashMap<String, String>();
            header.put("username", "*******");
            header.put("password", "******");
            header.put("token", "906b6986405607******66348912a");
            header.put("account_type", "1");

            Map<String, String> body = new LinkedHashMap<String, String>();
            body.put("siteId", "*******");
            body.put("method", "overview/getTimeTrendRpt");
            body.put("start_date", "20170901");
            body.put("end_date", endYimeStr);
            body.put("metrics", "pv_count,visitor_count");

            Map<String, Object> params = new LinkedHashMap<String, Object>();
            params.put("header", header);
            params.put("body", body);

            Long pv = 0L;
            Long uv = 0L;
            String results = HttpClientUtils.doPostSSL("https://api.baidu.com/json/tongji/v1/ReportService/getData", new Gson().toJson(params));
            if (StringUtils.isNotEmpty(results)) {
                JsonObject jsonObject = jsonParser.parse(results).getAsJsonObject();
                JsonObject bodyStr = jsonObject.get("body").getAsJsonObject();
                JsonArray dataStr = bodyStr.get("data").getAsJsonArray();
                JsonObject resultStr = dataStr.get(0).getAsJsonObject();
                JsonObject resultJsonObject = resultStr.get("result").getAsJsonObject();
                JsonArray asJsonArray = resultJsonObject.get("items").getAsJsonArray();
                JsonArray jsonElement = asJsonArray.get(1).getAsJsonArray();

                for (int i = 0; i < jsonElement.size(); i++) {
                    JsonArray job = jsonElement.get(i).getAsJsonArray(); // 遍历 jsonarray 数组，把每一个对象转成 json 对象
                    for (int j = 0; j < 2; j++) {
                        JsonElement jsonElement1 = job.get(j);
                        if (!"--".equalsIgnoreCase(jsonElement1.getAsString())) {
                            if (j == 0) {
                                pv += job.get(j).getAsLong();
                            } else {
                                uv += job.get(j).getAsLong();
                            }
                        }
                    }
                }
            }
            Map<String, Object> resultMap = new HashedMap();
            resultMap.put("pv", pv);
            resultMap.put("uv", uv);
            result = callback + "(" + gson.toJson(resultMap) + ")";
        } catch (ParseException e) {
            logger.error(e);
        }
        return result;
    }

3.调用中使用的是post请求，相应的HttpClient方法如下所示：

public class HttpClientUtils {

    private static PoolingHttpClientConnectionManager connMgr;
    private static RequestConfig requestConfig;
    private static final int MAX_TIMEOUT = 7000;

    static {
        // 设置连接池
        connMgr = new PoolingHttpClientConnectionManager();
        // 设置连接池大小
        connMgr.setMaxTotal(100);
        connMgr.setDefaultMaxPerRoute(connMgr.getMaxTotal());

        RequestConfig.Builder configBuilder = RequestConfig.custom();
        // 设置连接超时
        configBuilder.setConnectTimeout(MAX_TIMEOUT);
        // 设置读取超时
        configBuilder.setSocketTimeout(MAX_TIMEOUT);
        // 设置从连接池获取连接实例的超时
        configBuilder.setConnectionRequestTimeout(MAX_TIMEOUT);
        // 在提交请求之前 测试连接是否可用
        configBuilder.setStaleConnectionCheckEnabled(true);
        requestConfig = configBuilder.build();
    }

    /**
     * 发送 GET 请求（HTTP），不带输入数据
     *
     * @param url
     * @return
     */
    public static String doGet(String url) {
        return doGet(url, new HashMap<String, Object>());
    }

    /**
     * 发送 GET 请求（HTTP），K-V形式
     *
     * @param url
     * @param params
     * @return
     */
    public static String doGet(String url, Map<String, Object> params) {
        String apiUrl = url;
        StringBuffer param = new StringBuffer();
        int i = 0;
        for (String key : params.keySet()) {
            if (i == 0)
                param.append("?");
            else
                param.append("&");
            param.append(key).append("=").append(params.get(key));
            i++;
        }
        apiUrl += param;
        String result = null;
        HttpClient httpclient = new DefaultHttpClient();
        try {
            HttpGet httpPost = new HttpGet(apiUrl);
            HttpResponse response = httpclient.execute(httpPost);
            int statusCode = response.getStatusLine().getStatusCode();

            System.out.println("执行状态码 : " + statusCode);

            HttpEntity entity = response.getEntity();
            if (entity != null) {
                InputStream instream = entity.getContent();
                result = IOUtils.toString(instream, "UTF-8");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 发送 POST 请求（HTTP），不带输入数据
     *
     * @param apiUrl
     * @return
     */
    public static String doPost(String apiUrl) {
        return doPost(apiUrl, new HashMap<String, Object>());
    }

    /**
     * 发送 POST 请求（HTTP），K-V形式
     *
     * @param apiUrl API接口URL
     * @param params 参数map
     * @return
     */
    public static String doPost(String apiUrl, Map<String, Object> params) {
        CloseableHttpClient httpClient = HttpClients.createDefault();
        String httpStr = null;
        HttpPost httpPost = new HttpPost(apiUrl);
        CloseableHttpResponse response = null;

        try {
            httpPost.setConfig(requestConfig);
            List<NameValuePair> pairList = new ArrayList<>(params.size());
            for (Map.Entry<String, Object> entry : params.entrySet()) {
                NameValuePair pair = new BasicNameValuePair(entry.getKey(), entry
                        .getValue().toString());
                pairList.add(pair);
            }
            httpPost.setEntity(new UrlEncodedFormEntity(pairList, Charset.forName("UTF-8")));
            response = httpClient.execute(httpPost);
            System.out.println(response.toString());
            HttpEntity entity = response.getEntity();
            httpStr = EntityUtils.toString(entity, "UTF-8");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (response != null) {
                try {
                    EntityUtils.consume(response.getEntity());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return httpStr;
    }

    /**
     * 发送 POST 请求（HTTP），JSON形式
     *
     * @param apiUrl
     * @param json   json对象
     * @return
     */
    public static String doPost(String apiUrl, Object json) {
        CloseableHttpClient httpClient = HttpClients.createDefault();
        String httpStr = null;
        HttpPost httpPost = new HttpPost(apiUrl);
        CloseableHttpResponse response = null;

        try {
            httpPost.setConfig(requestConfig);
            StringEntity stringEntity = new StringEntity(json.toString(), "UTF-8");//解决中文乱码问题
            stringEntity.setContentEncoding("UTF-8");
            stringEntity.setContentType("application/json");
            httpPost.setEntity(stringEntity);
            response = httpClient.execute(httpPost);
            HttpEntity entity = response.getEntity();
            System.out.println(response.getStatusLine().getStatusCode());
            httpStr = EntityUtils.toString(entity, "UTF-8");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (response != null) {
                try {
                    EntityUtils.consume(response.getEntity());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return httpStr;
    }

    /**
     * 发送 SSL POST 请求（HTTPS），K-V形式
     *
     * @param apiUrl API接口URL
     * @param params 参数map
     * @return
     */
    public static String doPostSSL(String apiUrl, Map<String, Object> params) {
        CloseableHttpClient httpClient = HttpClients.custom().setSSLSocketFactory(createSSLConnSocketFactory()).setConnectionManager(connMgr).setDefaultRequestConfig(requestConfig).build();
        HttpPost httpPost = new HttpPost(apiUrl);
        CloseableHttpResponse response = null;
        String httpStr = null;

        try {
            httpPost.setConfig(requestConfig);
            List<NameValuePair> pairList = new ArrayList<NameValuePair>(params.size());
            for (Map.Entry<String, Object> entry : params.entrySet()) {
                NameValuePair pair = new BasicNameValuePair(entry.getKey(), entry
                        .getValue().toString());
                pairList.add(pair);
            }
            httpPost.setEntity(new UrlEncodedFormEntity(pairList, Charset.forName("utf-8")));
            response = httpClient.execute(httpPost);
            int statusCode = response.getStatusLine().getStatusCode();
            if (statusCode != HttpStatus.SC_OK) {
                return null;
            }
            HttpEntity entity = response.getEntity();
            if (entity == null) {
                return null;
            }
            httpStr = EntityUtils.toString(entity, "utf-8");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (response != null) {
                try {
                    EntityUtils.consume(response.getEntity());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return httpStr;
    }

    /**
     * 发送 SSL POST 请求（HTTPS），JSON形式
     *
     * @param apiUrl API接口URL
     * @param json   JSON对象
     * @return
     */
    public static String doPostSSL(String apiUrl, Object json) {
        CloseableHttpClient httpClient = HttpClients.custom().setSSLSocketFactory(createSSLConnSocketFactory()).setConnectionManager(connMgr).setDefaultRequestConfig(requestConfig).build();
        HttpPost httpPost = new HttpPost(apiUrl);
        CloseableHttpResponse response = null;
        String httpStr = null;

        try {
            httpPost.setConfig(requestConfig);
            StringEntity stringEntity = new StringEntity(json.toString(), "UTF-8");//解决中文乱码问题
            stringEntity.setContentEncoding("UTF-8");
            stringEntity.setContentType("application/json");
            httpPost.setEntity(stringEntity);
            response = httpClient.execute(httpPost);
            int statusCode = response.getStatusLine().getStatusCode();
            if (statusCode != HttpStatus.SC_OK) {
                return null;
            }
            HttpEntity entity = response.getEntity();
            if (entity == null) {
                return null;
            }
            httpStr = EntityUtils.toString(entity, "utf-8");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (response != null) {
                try {
                    EntityUtils.consume(response.getEntity());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return httpStr;
    }

    /**
     * 创建SSL安全连接
     *
     * @return
     */
    private static SSLConnectionSocketFactory createSSLConnSocketFactory() {
        SSLConnectionSocketFactory sslsf = null;
        try {
            SSLContext sslContext = new SSLContextBuilder().loadTrustMaterial(null, new TrustStrategy() {

                public boolean isTrusted(X509Certificate[] chain, String authType) throws CertificateException {
                    return true;
                }
            }).build();
            sslsf = new SSLConnectionSocketFactory(sslContext, new X509HostnameVerifier() {

                @Override
                public boolean verify(String arg0, SSLSession arg1) {
                    return true;
                }

                @Override
                public void verify(String host, SSLSocket ssl) throws IOException {
                }

                @Override
                public void verify(String host, X509Certificate cert) throws SSLException {
                }

                @Override
                public void verify(String host, String[] cns, String[] subjectAlts) throws SSLException {
                }
            });
        } catch (GeneralSecurityException e) {
            e.printStackTrace();
        }
        return sslsf;
    }

}