RESTful API 设计最佳实践

1
2
3
4
5
6
7
8
9
10
11
12
13

 <appender name="ORDER_LOG" class="ch.qos.logback.core.rolling.RollingFileAppender">
    <file>/data/logs/AAA/order.logfile>
    <encoder>
        <pattern>[%-5p] [%d{yyyy-MM-dd HH:mm:ss.SSS}] [%X{tracing_id}] [%C{1}:%M:%L] %m%npattern>
        <immediateFlush>falseimmediateFlush>  
    encoder>
    <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
        <level>INFOlevel>
    filter>
    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
        <fileNamePattern>/data/logs/AAA/order.log.%d{yyyy-MM-dd_HH}fileNamePattern>
    rollingPolicy>
appender>

1
2
3
4
5
6
7
8
9
10
11
12
13
14

@Override
protected void subAppend(E event) {
    // The roll-over check must precede actual writing. This is the
    // only correct behavior for time driven triggers.

    // We need to synchronize on triggeringPolicy so that only one rollover
    // occurs at a time
    synchronized (triggeringPolicy) {
      if (triggeringPolicy.isTriggeringEvent(currentlyActiveFile, event)) {
        rollover();
      }
    }
    super.subAppend(event);
}

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

/**
* All synchronization in this class is done via the lock object.
*/
protected LogbackLock lock = new LogbackLock();

protected void subAppend(E event) {
    if (!isStarted()) {
      return;
    }
    try {
      // this step avoids LBCLASSIC-139
      if (event instanceof DeferredProcessingAware) {
        ((DeferredProcessingAware) event).prepareForDeferredProcessing();
      }
      // the synchronization prevents the OutputStream from being closed while we
      // are writing. It also prevents multiple threads from entering the same
      // converter. Converters assume that they are in a synchronized block.
      synchronized (lock) {
        writeOut(event);
      }
    } catch (IOException ioe) {
      // as soon as an exception occurs, move to non-started state
      // and add a single ErrorStatus to the SM.
      this.started = false;
      addStatus(new ErrorStatus("IO failure in appender", this, ioe));
    }
}
// 通过 encode进行日志序列化，格式化写入
protected void writeOut(E event) throws IOException {
    this.encoder.doEncode(event);
}

1
2
3
4
5
6
7
8
9
10

LayoutWrappingEncoder.java
private boolean immediateFlush = true;
public void doEncode(E event) throws IOException {
    String txt = layout.doLayout(event);
    outputStream.write(convertToBytes(txt));
    //是否立即写入
    if (immediateFlush)
      outputStream.flush();
    }
}

1
2
3
4
5
6
7
8
9
10

<appender name ="ASYNC_ORDER_LOG" class= "ch.qos.logback.classic.AsyncAppender">
    // 不丢弃日志
    <discardingThreshold>0discardingThreshold>
    <queueSize>512queueSize>
    <includeCallerData>trueincludeCallerData>
    // 如果设置为true，队列满了会直接丢弃信息，而不是阻塞（其实就是使用的offer而不是put方法）
    <neverBlock>falseneverBlock>
    // 指定底层真实使用的Appender
    <appender-ref ref ="ORDER_LOG"/>
appender>

1
2
3

<configuration debug="true">
   <shutdownHook class="ch.qos.logback.core.hook.DelayingShutdownHook" />
configuration>

1
2
3
4

Runtime.addShutdownHook(new Thread (() -> {
   LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory();
    loggerContext.stop();
}));

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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

public static final int DEFAULT_QUEUE_SIZE = 256;
// 默认阻塞队列大小
int queueSize = DEFAULT_QUEUE_SIZE;
static final int UNDEFINED = -1;
// 初始值为 -1， 在启动时默认值是通过queueSize的大小计算出来的。
int discardingThreshold = UNDEFINED;

// 异步写日志的线程
Worker worker = new Worker();

@Override
public void start() {
    if (appenderCount == 0) {
      addError("No attached appenders found.");
      return;
    }
    if (queueSize < 1) {
      addError("Invalid queue size [" + queueSize + "]");
      return;
    }
    blockingQueue = new ArrayBlockingQueue(queueSize);

    if (discardingThreshold == UNDEFINED)
      discardingThreshold = queueSize / 5;
    addInfo("Setting discardingThreshold to " + discardingThreshold);
    worker.setDaemon(true);
    worker.setName("AsyncAppender-Worker-" + worker.getName());
    // make sure this instance is marked as "started" before staring the worker Thread
    super.start();
    worker.start();
}

@Override
protected void append(E eventObject) {
    // 可以的队列容量小于配置的值 并且 日志事件的级别为INFO及一下，那么就丢弃日志。
    if (isQueueBelowDiscardingThreshold() && isDiscardable(eventObject)) {
      return;
    }
    preprocess(eventObject);
    put(eventObject);
}

private boolean isQueueBelowDiscardingThreshold() {
    return (blockingQueue.remainingCapacity() < discardingThreshold);
}

protected boolean isDiscardable(ILoggingEvent event) {
    Level level = event.getLevel();
    return level.toInt() <= Level.INFO_INT;
}

protected void preprocess(ILoggingEvent eventObject) {
    eventObject.prepareForDeferredProcessing();
    // 是否需要获取调用者信息，这也是一个耗时操作，默认是false（内部通过创建异常对象，获取堆栈信息，从而计算日志发送的类，方法，行号信息）。
    if(includeCallerData)
      eventObject.getCallerData();
}

private void put(E eventObject) {
    try {
        // 阻塞操作
        blockingQueue.put(eventObject);
    } catch (InterruptedException e) {
    }
}

class Worker extends Thread {

    public void run() {
      AsyncAppenderBase parent = AsyncAppenderBase.this;
      AppenderAttachableImpl aai = parent.aai;

      // loop while the parent is started
      while (parent.isStarted()) {
        try {
          // 从队列中获取数据，其实就是消费者
          E e = parent.blockingQueue.take();
          aai.appendLoopOnAppenders(e);
        } catch (InterruptedException ie) {
          break;
        }
      }

      addInfo("Worker thread will flush remaining events before exiting. ");
      for (E e : parent.blockingQueue) {
        aai.appendLoopOnAppenders(e);
      }

      aai.detachAndStopAllAppenders();
    }
}