找到合适的方案记录服务端日志

╰+攻爆jí腚メ 2022-03-19 04:28 124阅读 0赞

做过服务端开发的同学都清楚日志是多么的重要,你要分析应用当天的 PV/UV,你需要对日志进行统计分析; 你需要排查程序 BUG, 你需要寻找日志中的异常信息等等, 所以, 建立一套合适的日志体系是非常有必要的.  
　　  
　　日志体系一般都会遵循这么几个原则 :

*  根据应用的需要记录对应的信息
 *  用于后期离线统计的日志信息与记录程序运行问题的日志分开存放
 *  选择合适的日志结构和日志记录工具

本文介绍的日志记录环境 :

*  Spring/Rose Web 框架
 *  SLF4J 日志类
 *  JSON格式的日志
    
    　　后端开发的时候往往在系统中都存在不只一套日志体系,这篇文章介绍的日志方案用于后期离线统计分析, 对于其他不同的情况需要根据服务的需求而定.  
    　　Json格式的信息易于存储和分析,对于规模不是很大的应用服务而言,使用Json格式用于日志记录是个非常不错的选择,由于日志一般都是按行存储,后期根据需要利用普通的Java程序或者Hadoop MapReduce 工具处理都特别的方便;而且Json格式其内部存储类似于map结构,以Key/Value的形式表达信息,基本能够满足实际的需求.

### 1. 日志示例 ###

本文介绍的日志记录方法存储的日志信息就类似与下面这样 :

{
        "Url":"http://localhost:8081/RoseStudy/hello/showHowToRecordLog","Uri":"/RoseStudy/hello/showHowToRecordLog","RemoteIp":"127.0.0.1","HostIp":"127.0.0.1","ActionName":"showHowToRecordLog","Time":1452233120220,"LogSource":1,"JsonResult":{
        "errorCode":0,"reason":null,"result":"test show how to record log success...","status":"success"}}
      
       
        1 
        2

可以看到,一行日志包含8个信息(只是测试使用,实际应用中需要根据自己的需求加入不同的类别信息), 分别记录着我们以后统计需要用到的信息.  
　　那么,我们首先需要定义的就是这8个类型信息的常量字符串,以方便后期使用 :

/** * 日志常量 * Created by zhanghu on 12/24/15. */public class Constants_ {
             /**     *  日志中包含的属性字段     * */    public static final String Url = "Url";    public static final String Uri = "Uri";    public static final String RemoteIp = "RemoteIp";    public static final String HostIp = "HostIp";    public static final String ActionName = "ActionName";    public static final String Time = "Time";    public static final String LogSource = "LogSource";    public static final String JsonResult = "JsonResult";}
      
       
        1 
        2 
        3 
        4 
        5 
        6 
        7 
        8 
        9 
        10 
        11 
        12 
        13 
        14 
        15 
        16 
        17 
        18 
        19

### 2. 服务端记录日志的过程 ###

服务端在处理任务的时候(Rose中的Action,或者 Servlet中的service)就需要把处理的结果,过程之类的信息记录在日志里.即外部的一个HTTP请求过来,服务端就需要打一/多条日志,就好像这样 :

/**     *  url : http://localhost:8081/RoseStudy/hello/showHowToRecordLog     * */    @Get("showHowToRecordLog")    @Post("showHowToRecordLog")    public String showHowToRecordLog(Invocation inv) {        try {            JSonResult jSonResult = JSonResult.newInstance();            jSonResult.errorCode(0L).reason(null).result("test show how to record log success...").status("success");            String logStr = LogGenerator_.getJsonLog(inv.getRequest().getRequestURL().toString(), inv.getRequest().getRequestURI(),                    inv.getRequest().getRemoteAddr(), inv.getRequest().getLocalAddr(), "showHowToRecordLog",                    LogSource_.ServerSide, jSonResult.toString());            LogOutputer.Instance.outputLogFromServer(logStr);        inv.getResponse().setContentType("application/json;charset=utf-8");        inv.getResponse().setStatus(HttpServletResponse.SC_OK);            inv.addModel("resultJsonString", jSonResult.toString());        } catch (Exception ex) {            System.out.println(ex.getMessage());        }        return "resultJson";    }
      
       
        1 
        2 
        3 
        4 
        5 
        6 
        7 
        8 
        9 
        10 
        11 
        12 
        13 
        14 
        15 
        16 
        17 
        18 
        19 
        20 
        21 
        22 
        23 
        24 
        25

这里使用的是Rose框架,我们不用过多的关注,在各种框架或者技术中我们只需要关注怎样记录日志就可以了.  
　　所以,我们分析 **try catch** 中的日志记录过程 :

*  ***JsonResult***  
    　　这个类当然不是JDK中提供的,它是为了我们在给客户端返回结果的时候简化一些步骤而构造的,其内部实现仅仅就是一个 JSONObject, 包含了 errorCode, result 这样的几个 key ,实现代码如下 :

import net.sf.json.JSONObject;public class JSonResult {
             private long errorCode;    private Object reason;    private Object result;    private Object status;    public static JSonResult newInstance() {        return new JSonResult();    }    public JSonResult() {        errorCode = -1;    }    public long getErrorCode() {        return errorCode;    }    public JSonResult errorCode(long errorCode) {        this.errorCode = errorCode;        return this;    }    public Object getReason() {        return reason;    }    public JSonResult reason(Object reason) {        this.reason = reason;        return this;    }    public Object getStatus() {        return status;    }    public JSonResult status(Object status) {        this.status = status;        return this;    }    public Object getResult() {        return result;    }    public JSonResult result(Object result) {        this.result = result;        return this;    }    @Override    public String toString() {        return toJson().toString();    }    public JSONObject toJson() {        return JSONObject.fromObject(this);    }}
      
       
        1 
        2 
        3 
        4 
        5 
        6 
        7 
        8 
        9 
        10 
        11 
        12 
        13 
        14 
        15 
        16 
        17 
        18 
        19 
        20 
        21 
        22 
        23 
        24 
        25 
        26 
        27 
        28 
        29 
        30 
        31 
        32 
        33 
        34 
        35 
        36 
        37 
        38 
        39 
        40 
        41 
        42 
        43 
        44 
        45 
        46 
        47 
        48 
        49 
        50 
        51 
        52 
        53 
        54 
        55 
        56 
        57 
        58 
        59 
        60 
        61 
        62

*  ***LogGenerator\_.getJsonLog(…)***  
    　　根据名字我们可以看出我们用到这个接口获取一条日志信息, 而这个日志信息我们可以猜出它就是一个JSONObject, 其中包含了上面 Constants\_ 类中列出的那8个日志类别, 那么, 我们只需要把这些传入接口的信息 put 到JSONObject 中就OK了,实现代码如下 :

import net.sf.json.JSONObject;/** * 生成日志的服务 * Created by zhanghu on 12/24/15. */public class LogGenerator_ {
             /**     *  可解析日志包含这样几个点 :     *      - Url           客户端请求的地址     *      - Uri           服务器资源的地址     *      - RemoteIp      客户端的IP地址     *      - HostIp        服务端的IP地址     *      - ActionName    请求函数的名字     *      - source_       日志源     *      - JsonResult    服务器返回的结果     * */    public static String getJsonLog(String Url, String Uri,                                    String RemoteIp, String HostIp,                                    String ActionName,                                    LogSource_ source_, String JsonResult) {        JSONObject object = new JSONObject();        object.put(Constants_.Url, Url);        object.put(Constants_.Uri, Uri);        object.put(Constants_.RemoteIp, RemoteIp);        object.put(Constants_.HostIp, HostIp);        object.put(Constants_.ActionName, ActionName);        object.put(Constants_.Time, System.currentTimeMillis());        object.put(Constants_.LogSource, LogSource_.getValue(source_));        object.put(Constants_.JsonResult, JsonResult);        return object.toString();    }}
      
       
        1 
        2 
        3 
        4 
        5 
        6 
        7 
        8 
        9 
        10 
        11 
        12 
        13 
        14 
        15 
        16 
        17 
        18 
        19 
        20 
        21 
        22 
        23 
        24 
        25 
        26 
        27 
        28 
        29 
        30 
        31 
        32 
        33 
        34 
        35 
        36 
        37

*  ***LogSource\_***  
    　　这个类的作用是区分日志源的, 日志源也是后期统计分析的一个重要的组成部分, 比如,这条日志是来自服务端, 客户端, 还是 未知属性, 我们用一个枚举来实现 :

/** * 日志源枚举类 * Created by zhanghu on 12/24/15. */public enum LogSource_ {    ServerSide(1, "服务端"),    Unknown(2, "未知");    private int value;    private String description;    LogSource_(int value, String description) {        this.value = value;        this.description = description;    }    public int getValue() {        return value;    }    public String getDescription() {        return description;    }    public static int getValue(LogSource_ source_) {        if (source_ == null) {            return Unknown.getValue();        }        return source_.getValue();    }    public static String getDescription(LogSource_ source_) {        if (source_ == null) {            return Unknown.getDescription();        }        return source_.getDescription();    }}
      
       
        1 
        2 
        3 
        4 
        5 
        6 
        7 
        8 
        9 
        10 
        11 
        12 
        13 
        14 
        15 
        16 
        17 
        18 
        19 
        20 
        21 
        22 
        23 
        24 
        25 
        26 
        27 
        28 
        29 
        30 
        31 
        32 
        33 
        34 
        35 
        36 
        37 
        38 
        39 
        40 
        41

*  ***LogOutputer.Instance.outputLogFromServer(logStr)***  
    　　这个接口用于序列化日志到某一个存储位置, 从 Instance 这个词可以猜到,这是一个单例的实现, 由于,接口比较简单,不做过多的解释了,直接给出实现代码 :

/** * 日志输出类 * Created by zhanghu on 12/24/15. */public class LogOutputer {
             public static LogOutputer Instance = new LogOutputer();    private ILogSerializer logSerializer = null;    private LogOutputer() {        this.logSerializer = new LogSerializerImpl();    }    /**     *  这个是真正写日志的接口     * */    public void outputLogFromServer(String jsonObjStr) {        logSerializer.serializerLog(jsonObjStr);    }}
      
       
        1 
        2 
        3 
        4 
        5 
        6 
        7 
        8 
        9 
        10 
        11 
        12 
        13 
        14 
        15 
        16 
        17 
        18 
        19 
        20 
        21

/** * 序列化日志接口 * Created by zhanghu on 12/24/15. */public interface ILogSerializer {
             void serializerLog(String logStr);}
      
       
        1 
        2 
        3 
        4 
        5 
        6 
        7 
        8

import net.sf.json.JSONObject;import org.slf4j.Logger;import org.slf4j.LoggerFactory;/** * 序列化日志的实现类 * Created by zhanghu on 12/24/15. */public class LogSerializerImpl implements ILogSerializer {
             /**     *  这里需要定义两套日志系统 :     *      一类是定义用作统计的日志系统  logger     *      另一类是记录性的日志系统,一般不用做解析    allLogger     * */    private static final Logger logger = LoggerFactory.getLogger("roseLog");    private static final Logger allLogger = LoggerFactory.getLogger(LogSerializerImpl.class);    @Override    public void serializerLog(String logStr) {        try {            JSONObject object = JSONObject.fromObject(logStr);            object.put(Constants_.Time, System.currentTimeMillis());            logger.info(object.toString());        } catch (Exception e) {            allLogger.error("Write Rose Log Error : {}", e.getMessage());        }    }}
      
       
        1 
        2 
        3 
        4 
        5 
        6 
        7 
        8 
        9 
        10 
        11 
        12 
        13 
        14 
        15 
        16 
        17 
        18 
        19 
        20 
        21 
        22 
        23 
        24 
        25 
        26 
        27 
        28 
        29 
        30

好了, 到这里, 我们已经在我们的系统中构造了一套方便解析的日志系统, 接下来, 埋到我们的应用系统中然后进行统计分析吧 !

再分享一下我老师大神的人工智能教程吧。零基础！通俗易懂！风趣幽默！还带黄段子！希望你也加入到我们人工智能的队伍中来！[https://blog.csdn.net/jiangjunshow][https_blog.csdn.net_jiangjunshow]

[https_blog.csdn.net_jiangjunshow]: https://blog.csdn.net/jiangjunshow/article/details/77338485