大数据项目中js中代码和java中代码（解决Tomcat打印日志中文乱码）

Idea2018中集成Tomcat9导致OutPut乱码
找到tomcat的安装目录，打开logging.properties文件，增加一行代码，覆盖默认设置，将日志编码格式修改为GBK。
java.util.logging.ConsoleHandler.encoding = GBK

js代码

(function() {
   var CookieUtil = {
      // get the cookie of the key is name
      get : function(name) {
         var cookieName = encodeURIComponent(name) + "=", cookieStart = document.cookie
               .indexOf(cookieName), cookieValue = null;
         if (cookieStart > -1) {
            var cookieEnd = document.cookie.indexOf(";", cookieStart);
            if (cookieEnd == -1) {
               cookieEnd = document.cookie.length;
            }
            cookieValue = decodeURIComponent(document.cookie.substring(
                  cookieStart + cookieName.length, cookieEnd));
         }
         return cookieValue;
      },
      // set the name/value pair to browser cookie
      set : function(name, value, expires, path, domain, secure) {
         var cookieText = encodeURIComponent(name) + "="
               + encodeURIComponent(value);

         if (expires) {
            // set the expires time
            var expiresTime = new Date();
            expiresTime.setTime(expires);
            cookieText += ";expires=" + expiresTime.toGMTString();
         }

         if (path) {
            cookieText += ";path=" + path;
         }

         if (domain) {
            cookieText += ";domain=" + domain;
         }

         if (secure) {
            cookieText += ";secure";
         }

         document.cookie = cookieText;
      },
      setExt : function(name, value) {
         this.set(name, value, new Date().getTime() + 315360000000, "/");
      }
   };

   // 主体，其实就是tracker js
   var tracker = {
      // config
      clientConfig : {
         serverUrl : "http://master/log.gif",
         sessionTimeout : 360, // 360s -> 6min
         maxWaitTime : 3600, // 3600s -> 60min -> 1h
         ver : "1"
      },

      cookieExpiresTime : 315360000000, // cookie过期时间，10年

      columns : {
         // 发送到服务器的列名称
         eventName : "en",
         version : "ver",
         platform : "pl",
         sdk : "sdk",
         uuid : "u_ud",
         memberId : "u_mid",
         sessionId : "u_sd",
         clientTime : "c_time",
         language : "l",
         userAgent : "b_iev",
         resolution : "b_rst",
         currentUrl : "p_url",
         referrerUrl : "p_ref",
         title : "tt",
         orderId : "oid",
         orderName : "on",
         currencyAmount : "cua",
         currencyType : "cut",
         paymentType : "pt",
         category : "ca",
         action : "ac",
         kv : "kv_",
         duration : "du"
      },

      keys : {
         pageView : "e_pv",
         chargeRequestEvent : "e_crt",
         launch : "e_l",
         eventDurationEvent : "e_e",
         sid : "bftrack_sid",
         uuid : "bftrack_uuid",
         mid : "bftrack_mid",
         preVisitTime : "bftrack_previsit",

      },

      /**
       * 获取会话id
       */
      getSid : function() {
         return CookieUtil.get(this.keys.sid);
      },

      /**
       * 保存会话id到cookie
       */
      setSid : function(sid) {
         if (sid) {
            CookieUtil.setExt(this.keys.sid, sid);
         }
      },

      /**
       * 获取uuid，从cookie中
       */
      getUuid : function() {
         return CookieUtil.get(this.keys.uuid);
      },

      /**
       * 保存uuid到cookie
       */
      setUuid : function(uuid) {
         if (uuid) {
            CookieUtil.setExt(this.keys.uuid, uuid);
         }
      },

      /**
       * 获取memberID
       */
      getMemberId : function() {
         return CookieUtil.get(this.keys.mid);
      },

      /**
       * 设置mid
       */
      setMemberId : function(mid) {
         if (mid) {
            CookieUtil.setExt(this.keys.mid, mid);
         }
      },

      startSession : function() {
         // 加载js就触发的方法
         if (this.getSid()) {
            // 会话id存在，表示uuid也存在
            if (this.isSessionTimeout()) {
               // 会话过期,产生新的会话
               this.createNewSession();
            } else {
               // 会话没有过期，更新最近访问时间
               this.updatePreVisitTime(new Date().getTime());
            }
         } else {
            // 会话id不存在，表示uuid也不存在
            this.createNewSession();
         }
         this.onPageView();
      },

      onLaunch : function() {
         // 触发launch事件
         var launch = {};
         launch[this.columns.eventName] = this.keys.launch; // 设置事件名称
         this.setCommonColumns(launch); // 设置公用columns
         this.sendDataToServer(this.parseParam(launch)); // 最终发送编码后的数据
      },

      onPageView : function() {
         // 触发page view事件
         if (this.preCallApi()) {
            var time = new Date().getTime();
            var pageviewEvent = {};
            pageviewEvent[this.columns.eventName] = this.keys.pageView;
            pageviewEvent[this.columns.currentUrl] = window.location.href; // 设置当前url
            pageviewEvent[this.columns.referrerUrl] = document.referrer; // 设置前一个页面的url
            pageviewEvent[this.columns.title] = document.title; // 设置title
            this.setCommonColumns(pageviewEvent); // 设置公用columns
            this.sendDataToServer(this.parseParam(pageviewEvent)); // 最终发送编码后的数据
            this.updatePreVisitTime(time);
         }
      },

      onChargeRequest : function(orderId, name, currencyAmount, currencyType, paymentType) {
         // 触发订单产生事件
         if (this.preCallApi()) {
            if (!orderId || !currencyType || !paymentType) {
               this.log("订单id、货币类型以及支付方式不能为空");
               return;
            }

            if (typeof (currencyAmount) == "number") {
               // 金额必须是数字
               var time = new Date().getTime();
               var chargeRequestEvent = {};
               chargeRequestEvent[this.columns.eventName] = this.keys.chargeRequestEvent;
               chargeRequestEvent[this.columns.orderId] = orderId;
               chargeRequestEvent[this.columns.orderName] = name;
               chargeRequestEvent[this.columns.currencyAmount] = currencyAmount;
               chargeRequestEvent[this.columns.currencyType] = currencyType;
               chargeRequestEvent[this.columns.paymentType] = paymentType;
               this.setCommonColumns(chargeRequestEvent); // 设置公用columns
               this.sendDataToServer(this.parseParam(chargeRequestEvent)); // 最终发送编码后的数据
               this.updatePreVisitTime(time);
            } else {
               this.log("订单金额必须是数字");
               return;
            }
         }
      },

      onEventDuration : function(category, action, map, duration) {
         // 触发event事件
         if (this.preCallApi()) {
            if (category && action) {
               var time = new Date().getTime();
               var event = {};
               event[this.columns.eventName] = this.keys.eventDurationEvent;
               event[this.columns.category] = category;
               event[this.columns.action] = action;
               if (map) {
                  for ( var k in map) {
                     if (k && map[k]) {
                        event[this.columns.kv + k] = map[k];
                     }
                  }
               }
               if (duration) {
                  event[this.columns.duration] = duration;
               }
               this.setCommonColumns(event); // 设置公用columns
               this.sendDataToServer(this.parseParam(event)); // 最终发送编码后的数据
               this.updatePreVisitTime(time);
            } else {
               this.log("category和action不能为空");
            }
         }
      },

      /**
       * 执行对外方法前必须执行的方法
       */
      preCallApi : function() {
         if (this.isSessionTimeout()) {
            // 如果为true，表示需要新建
            this.startSession();
         } else {
            this.updatePreVisitTime(new Date().getTime());
         }
         return true;
      },

      sendDataToServer : function(data) {

         alert(data);

         // 发送数据data到服务器，其中data是一个字符串
         var that = this;
         var i2 = new Image(1, 1);// <img src="url"></img>
         i2.onerror = function() {
            // 这里可以进行重试操作
         };
         i2.src = this.clientConfig.serverUrl + "?" + data;
      },

      /**
       * 往data中添加发送到日志收集服务器的公用部分
       */
      setCommonColumns : function(data) {
         data[this.columns.version] = this.clientConfig.ver;
         data[this.columns.platform] = "website";
         data[this.columns.sdk] = "js";
         data[this.columns.uuid] = this.getUuid(); // 设置用户id
         data[this.columns.memberId] = this.getMemberId(); // 设置会员id
         data[this.columns.sessionId] = this.getSid(); // 设置sid
         data[this.columns.clientTime] = new Date().getTime(); // 设置客户端时间
         data[this.columns.language] = window.navigator.language; // 设置浏览器语言
         data[this.columns.userAgent] = window.navigator.userAgent; // 设置浏览器类型
         data[this.columns.resolution] = screen.width + "*" + screen.height; // 设置浏览器分辨率
      },

      /**
       * 创建新的会员，并判断是否是第一次访问页面，如果是，进行launch事件的发送。
       */
      createNewSession : function() {
         var time = new Date().getTime(); // 获取当前操作时间
         // 1. 进行会话更新操作
         var sid = this.generateId(); // 产生一个session id
         this.setSid(sid);
         this.updatePreVisitTime(time); // 更新最近访问时间
         // 2. 进行uuid查看操作
         if (!this.getUuid()) {
            // uuid不存在，先创建uuid，然后保存到cookie，最后触发launch事件
            var uuid = this.generateId(); // 产品uuid
            this.setUuid(uuid);
            this.onLaunch();
         }
      },

      /**
       * 参数编码返回字符串
       */
      parseParam : function(data) {
         var params = "";
         for ( var e in data) {
            if (e && data[e]) {
               params += encodeURIComponent(e) + "="
                     + encodeURIComponent(data[e]) + "&";
            }
         }
         if (params) {
            return params.substring(0, params.length - 1);
         } else {
            return params;
         }
      },

      /**
       * 产生uuid
       */
      generateId : function() {
         var chars = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
         var tmpid = [];
         var r;
         tmpid[8] = tmpid[13] = tmpid[18] = tmpid[23] = '-';
         tmpid[14] = '4';

         for (i = 0; i < 36; i++) {
            if (!tmpid[i]) {
               r = 0 | Math.random() * 16;
               tmpid[i] = chars[(i == 19) ? (r & 0x3) | 0x8 : r];
            }
         }
         return tmpid.join('');
      },

      /**
       * 判断这个会话是否过期，查看当前时间和最近访问时间间隔时间是否小于this.clientConfig.sessionTimeout<br/>
       * 如果是小于，返回false;否则返回true。
       */
      isSessionTimeout : function() {
         var time = new Date().getTime();
         var preTime = CookieUtil.get(this.keys.preVisitTime);
         if (preTime) {
            // 最近访问时间存在,那么进行区间判断
            return time - preTime > this.clientConfig.sessionTimeout * 1000;
         }
         return true;
      },

      /**
       * 更新最近访问时间
       */
      updatePreVisitTime : function(time) {
         CookieUtil.setExt(this.keys.preVisitTime, time);
      },

      /**
       * 打印日志
       */
      log : function(msg) {
         console.log(msg);
      },

   };

   // 对外暴露的方法名称
   window.__AE__ = {
      startSession : function() {
         tracker.startSession();
      },
      onPageView : function() {
         tracker.onPageView();
      },
      onChargeRequest : function(orderId, name, currencyAmount, currencyType, paymentType) {
         tracker.onChargeRequest(orderId, name, currencyAmount, currencyType, paymentType);
      },
      onEventDuration : function(category, action, map, duration) {
         tracker.onEventDuration(category, action, map, duration);
      },
      setMemberId : function(mid) {
         tracker.setMemberId(mid);
      }
   };

   // 自动加载方法
   var autoLoad = function() {
      // 进行参数设置
      var _aelog_ = _aelog_ || window._aelog_ || [];
      var memberId = null;
      for (i = 0; i < _aelog_.length; i++) {
         _aelog_[i][0] === "memberId" && (memberId = _aelog_[i][1]);
      }
      // 根据是给定memberid，设置memberid的值
      memberId && __AE__.setMemberId(memberId);
      // 启动session
      __AE__.startSession();
   };

   autoLoad();
})();

<%@ page contentType="text/html; charset=utf-8" pageEncoding="utf-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>测试页面1</title>
<script type="text/javascript" src="./js/analytics.js"></script>
</head>
<body>
   测试页面1<br/>
   跳转到:
   <a href="demo.jsp">demo</a>
   <a href="demo2.jsp">demo2</a>
   <a href="demo3.jsp">demo3</a>
   <a href="demo4.jsp">demo4</a>
</body>
</html>

<%@ page contentType="text/html; charset=utf-8" pageEncoding="utf-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>测试页面2</title>
<script type="text/javascript" src="./js/analytics.js"></script>
</head>
<body>
   测试页面2
   <br/>
   <label>orderid: 123456</label><br>
   <label>orderName: 测试订单123456</label><br/>
   <label>currencyAmount: 524.01</label><br/>
   <label>currencyType: RMB</label><br/>
   <label>paymentType: alipay</label><br/>
   <button onclick="__AE__.onChargeRequest('123456','测试订单123456',524.01,'RMB','alipay')">触发chargeRequest事件</button><br/>
   跳转到:
   <a href="demo.jsp">demo</a>
   <a href="demo2.jsp">demo2</a>
   <a href="demo3.jsp">demo3</a>
   <a href="demo4.jsp">demo4</a>
</body>
</html>

<%@ page contentType="text/html; charset=utf-8" pageEncoding="utf-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>测试页面3</title>
<script type="text/javascript" src="./js/analytics.js"></script>
</head>
<body>
   测试页面3<br/>
   <label>category: event的category名称</label><br/>
   <label>action: event的action名称</label><br/>
   <label>map: {"key1":"value1", "key2":"value2"}</label><br/>
   <label>duration: 1245</label><br/>
   <button onclick="__AE__.onEventDuration('event的category名称','event的action名称', {'key1':'value1','key2':'value2'}, 1245)">触发带map和duration的事件</button><br/>
   <button onclick="__AE__.onEventDuration('event的category名称','event的action名称')">触发不带map和duration的事件</button><br/>
   跳转到:
   <a href="demo.jsp">demo</a>
   <a href="demo2.jsp">demo2</a>
   <a href="demo3.jsp">demo3</a>
   <a href="demo4.jsp">demo4</a>
</body>
</html>

<%@ page contentType="text/html; charset=utf-8" pageEncoding="utf-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>测试页面4</title>
<script type="text/javascript">
(function(){
   var _aelog_ = _aelog_ || window._aelog_ || [];
   // 设置_aelog_相关属性
   _aelog_.push(["memberId","zhangsan"]);
   window._aelog_ = _aelog_;
   (function(){
       var aejs = document.createElement('script');
       aejs.type = 'text/javascript';
       aejs.async = true;
       aejs.src = './js/analytics.js';
       var script = document.getElementsByTagName('script')[0];
       script.parentNode.insertBefore(aejs, script);
   })();
})();
</script>
</head>
<body>
   测试页面4<br/>
   在本页面设置memberid为zhangsan<br/>
   跳转到:

   <a href="demo.jsp">demo</a>
   <a href="demo2.jsp">demo2</a>
   <a href="demo3.jsp">demo3</a>
   <a href="demo4.jsp">demo4</a>
</body>
</html>

package com.yjsj.client;

import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.util.HashMap;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * 分析引擎sdk java服务器端数据收集
 * 
 * @author root
 * @version 1.0
 *
 */
public class AnalyticsEngineSDK {
   // 日志打印对象
   private static final Logger log = Logger.getGlobal();
   // 请求url的主体部分
   public static final String accessUrl = "http://master/log.gif";
   private static final String platformName = "java_server";
   private static final String sdkName = "jdk";
   private static final String version = "1";

   /**
    * 触发订单支付成功事件，发送事件数据到服务器
    * 
    * @param orderId
    *            订单支付id
    * @param memberId
    *            订单支付会员id
    * @return 如果发送数据成功(加入到发送队列中)，那么返回true；否则返回false(参数异常&添加到发送队列失败).
    */
   public static boolean onChargeSuccess(String orderId, String memberId) {
      try {
         if (isEmpty(orderId) || isEmpty(memberId)) {
            // 订单id或者memberid为空
            log.log(Level.WARNING, "订单id和会员id不能为空");
            return false;
         }
         // 代码执行到这儿，表示订单id和会员id都不为空。
         Map<String, String> data = new HashMap<String, String>();
         data.put("u_mid", memberId);
         data.put("oid", orderId);
         data.put("c_time", String.valueOf(System.currentTimeMillis()));
         data.put("ver", version);
         data.put("en", "e_cs");
         data.put("pl", platformName);
         data.put("sdk", sdkName);
         // 创建url
         String url = buildUrl(data);
         // 发送url&将url加入到队列
         SendDataMonitor.addSendUrl(url);
         return true;
      } catch (Throwable e) {
         log.log(Level.WARNING, "发送数据异常", e);
      }
      return false;
   }

   /**
    * 触发订单退款事件，发送退款数据到服务器
    * 
    * @param orderId
    *            退款订单id
    * @param memberId
    *            退款会员id
    * @return 如果发送数据成功，返回true。否则返回false。
    */
   public static boolean onChargeRefund(String orderId, String memberId) {
      try {
         if (isEmpty(orderId) || isEmpty(memberId)) {
            // 订单id或者memberid为空
            log.log(Level.WARNING, "订单id和会员id不能为空");
            return false;
         }
         // 代码执行到这儿，表示订单id和会员id都不为空。
         Map<String, String> data = new HashMap<String, String>();
         data.put("u_mid", memberId);
         data.put("oid", orderId);
         data.put("c_time", String.valueOf(System.currentTimeMillis()));
         data.put("ver", version);
         data.put("en", "e_cr");
         data.put("pl", platformName);
         data.put("sdk", sdkName);
         // 构建url
         String url = buildUrl(data);
         // 发送url&将url添加到队列中
         SendDataMonitor.addSendUrl(url);
         return true;
      } catch (Throwable e) {
         log.log(Level.WARNING, "发送数据异常", e);
      }
      return false;
   }

   /**
    * 根据传入的参数构建url
    * 
    * @param data
    * @return
    * @throws UnsupportedEncodingException
    */
   private static String buildUrl(Map<String, String> data)
         throws UnsupportedEncodingException {
      StringBuilder sb = new StringBuilder();
      sb.append(accessUrl).append("?");
      for (Map.Entry<String, String> entry : data.entrySet()) {
         if (isNotEmpty(entry.getKey()) && isNotEmpty(entry.getValue())) {
            sb.append(entry.getKey().trim())
                  .append("=")
                  .append(URLEncoder.encode(entry.getValue().trim(), "utf-8"))
                  .append("&");
         }
      }
      return sb.substring(0, sb.length() - 1);// 去掉最后&
   }

   /**
    * 判断字符串是否为空，如果为空，返回true。否则返回false。
    * 
    * @param value
    * @return
    */
   private static boolean isEmpty(String value) {
      return value == null || value.trim().isEmpty();
   }

   /**
    * 判断字符串是否非空，如果不是空，返回true。如果是空，返回false。
    * 
    * @param value
    * @return
    */
   private static boolean isNotEmpty(String value) {
      return !isEmpty(value);
   }
}

package com.yjsj.client;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * 发送url数据的监控者，用于启动一个单独的线程来发送数据
 * 
 * @author root
 *
 */
public class SendDataMonitor {
   // 日志记录对象
   private static final Logger log = Logger.getGlobal();
   // 队列，用户存储发送url
   private BlockingQueue<String> queue = new LinkedBlockingQueue<String>();
   // 用于单列的一个类对象
   private static SendDataMonitor monitor = null;

   private SendDataMonitor() {
      // 私有构造方法，进行单列模式的创建
   }

   /**
    * 获取单列的monitor对象实例
    * 
    * @return
    */
   public static SendDataMonitor getSendDataMonitor() {
      if (monitor == null) {
         synchronized (SendDataMonitor.class) {
            if (monitor == null) {
               monitor = new SendDataMonitor();

               Thread thread = new Thread(new Runnable() {

                  @Override
                  public void run() {
                     // 线程中调用具体的处理方法
                     SendDataMonitor.monitor.run();
                  }
               });
               // 测试的时候，不设置为守护模式
               // thread.setDaemon(true);
               thread.start();
            }
         }
      }
      return monitor;
   }

   /**
    * 添加一个url到队列中去
    * 
    * @param url
    * @throws InterruptedException
    */
   public static void addSendUrl(String url) throws InterruptedException {
      getSendDataMonitor().queue.put(url);
   }

   /**
    * 具体执行发送url的方法
    * 
    */
   private void run() {
      while (true) {
         try {
            String url = this.queue.take();
            // 正式的发送url
            HttpRequestUtil.sendData(url);
         } catch (Throwable e) {
            log.log(Level.WARNING, "发送url异常", e);
         }
      }
   }

   /**
    * 内部类，用户发送数据的http工具类
    * 
    * @author root
    *
    */
   public static class HttpRequestUtil {
      /**
       * 具体发送url的方法
       * 
       * @param url
       * @throws IOException
       */
      public static void sendData(String url) throws IOException {
         HttpURLConnection con = null;
         BufferedReader in = null;

         try {
            URL obj = new URL(url); // 创建url对象
            con = (HttpURLConnection) obj.openConnection(); // 打开url连接
            // 设置连接参数
            con.setConnectTimeout(5000); // 连接过期时间
            con.setReadTimeout(5000); // 读取数据过期时间
            con.setRequestMethod("GET"); // 设置请求类型为get

            System.out.println("发送url:" + url);
            // 发送连接请求
            in = new BufferedReader(new InputStreamReader(con.getInputStream()));
            // TODO: 这里考虑是否可以
         } finally {
            try {
               if (in != null) {
                  in.close();
               }
            } catch (Throwable e) {
               // nothing
            }
            try {
               con.disconnect();
            } catch (Throwable e) {
               // nothing
            }
         }
      }
   }
}