LogThreadContext日志上下文，存放了方法相关的日志信息

@XSlf4j
public final class LogThreadContext {
  public final static ThreadLocal<LogThreadContext> LOG_THREAD_CONTEXT = new InheritableThreadLocal<>();
  private final static String TRACEID = "X-B3-TraceId";
   * 当前方法的日志上下文
  private LogContext currentLogContext;
  //瞬间统计器  通过LogsUtil.startProfiler 产生的Profiler
  private Profiler instantProfiler;
   * 方法调用时日志上下文存放的一个栈
  private Stack<LogContext> logContexts = new Stack<>();
   * 方法调用时MDC相关信息存放的一个栈
  private Stack<Map<String, String>> callStack = new Stack<>();
   * 方法耗时统计器存放
  private Map<String, Profiler> profilerMap = new HashMap<String, Profiler>();
   * 设置当前方法内的耗时统计器  每调用一次 {@link LogUtil#startProfiler}就会设置方法内的耗时统计器
   * @param instantProfiler
   * @author gongliangjun 2020-06-08 1:31 PM
   * @return void
  public void setInstantProfiler(Profiler instantProfiler) {
    this.instantProfiler = instantProfiler;
   * 停止当前方法内的耗时统计器
   * @author gongliangjun 2020-06-08 1:31 PM
   * @return void
  public void stopInstantProfiler() {
    if (null != instantProfiler) {
      instantProfiler.stop();
   * 获取当前线程的日志上下文
   * @author gongliangjun 2020-06-08 1:33 PM
   * @return com.enhance.aspect.LogThreadContext
  public final static LogThreadContext getLogThreadContext() {
    LogThreadContext logThreadContext = LOG_THREAD_CONTEXT.get();
    if (logThreadContext == null) {
      logThreadContext = new LogThreadContext();
      LOG_THREAD_CONTEXT.set(logThreadContext);
    return logThreadContext;
   * 存放方法耗时统计器到profilerMap
   * @param profiler
   * @author gongliangjun 2020-06-08 1:34 PM
   * @return void
  protected void putProfiler(Profiler profiler) {
    put(profiler.getName(), profiler);
   * 移除当前方法耗时统计器
   * @author gongliangjun 2020-06-08 1:36 PM
   * @return void
  protected void removeCurrentProfiler() {
    if (profilerMap.size() < 2) {
      profilerMap.clear();
    } else {
      String profilerName = currentLogContext.getProfilerName();
      profilerMap.remove(




    
profilerName);
   * 指定名称存放方法耗时统计器到profilerMap
   * @param profiler
   * @author gongliangjun 2020-06-08 1:34 PM
   * @return void
  protected void put(String name, Profiler profiler) {
    if (profilerMap.isEmpty()) {
      String key = MDC.get(TRACEID);
      if (StringUtils.isBlank(key)) {
        key = "parent";
      //===============================================================================
      //  设置耗时统计器名称
      //===============================================================================
      this.currentLogContext.setProfilerName(key);
      profilerMap.put(key, profiler);
    } else {
      //===============================================================================
      //  设置耗时统计器名称
      //===============================================================================
      this.currentLogContext.setProfilerName(name);
      profilerMap.put(name, profiler);
   * 从profilerMap获取指定名称的耗时统计器
   * @param name
   * @author gongliangjun 2020-06-08 1:34 PM
   * @return void
  public Profiler get(String name) {
    return profilerMap.get(name);
   * 获取第一个方法的方法耗时统计器
   * 第一个方法耗时统计器名称为标记一次请求的唯一traceID
   * @author gongliangjun 2020-06-08 1:34 PM
   * @return void
  public Profiler getFirstProfiler() {
    String key = MDC.get(TRACEID);
    if (StringUtils.isBlank(key)) {
      key = "parent";
    return profilerMap.get(key);
   * 获取上一个方法的耗时统计器
   * @author gongliangjun 2020-06-08 1:40 PM
   * @return org.slf4j.profiler.Profiler
  public Profiler getPrevProfiler() {
    LogContext currentContext = logContexts.pop();
    LogContext prevContext = logContexts.peek();
    logContexts.push(currentContext);
    return profilerMap.get(prevContext.getProfilerName());
   * 判断是否为第一个耗时统计器
   * @author gongliangjun 2020-06-08 1:40 PM
   * @return org.slf4j.profiler.Profiler
  public boolean isFirstProfiler() {
    return profilerMap.isEmpty();
   * 判断是否为第一个方法调用
   * @author gongliangjun 2020-06-08 1:40 PM
   * @return org.slf4j.profiler.Profiler
  public boolean isFirstMethod() {
    return profilerMap.size() == 1;
  protected void clear() {
    //防止内存泄漏  改成在AddTraceIdFilter 进行删除
    LOG_THREAD_CONTEXT.remove();
  public Stack<Map<String, String>> getCallStack() {
    return callStack;
   * 保存方法调用上下文到栈
   * @param logContext
   * @author gongliangjun 2020-06-08 1:42 PM
   * @return java.util.Stack<com.enhance.aspect.LogThreadContext.LogContext>
  protected Stack<LogContext> putContext(LogContext logContext) {
    logContexts.push(logContext);
    return logContexts;
  protected LogContext peekContext() {
    return logContexts.peek();
  public LogContext getCurrentLogContext() {
    return currentLogContext;
  protected void setCurrentLogContext(LogContext currentLogContext) {
    this.currentLogContext = currentLogContext;
  protected LogContext changeCurrentLogContext() {
    if (!logContexts.isEmpty()) {
      //拿到栈顶元素
      LogContext peek = logContexts.peek();
      String currentLogContextProfilerName = currentLogContext.getProfilerName();
      String profilerName = peek.getProfilerName();
      //对比当前log上下文是否为同一个
      if (currentLogContextProfilerName.equals(profilerName)) {
        //===============================================================================
        //  移除栈顶元素，并且修改当前log上下文
        //===============================================================================
        logContexts.pop();
        this.currentLogContext = logContexts.peek();
    return currentLogContext;
  protected void removeCurrentLogContext() {
    if (logContexts.empty()) {
      return;
    } else {
      logContexts.pop();
  protected Stack<Map<String, String>> putCallStack(Map<String, String> callStackMap) {
    callStack.push(callStackMap);
    return callStack;
  protected Map<String, String> popCallStack() {
    return callStack.pop();
  public boolean




    
 isEmptyCallStack() {
    return callStack.isEmpty();
  public boolean isEnableLog() {
    if (null != currentLogContext) {
      return currentLogContext.isEnableLog();
    } else {
      return false;
  public boolean isEnableProfiler() {
    if (null != currentLogContext) {
      return currentLogContext.isEnableProfiler();
    } else {
      return false;
  public Map<String, String> peekCallStack() {
    return callStack.peek();
  @Getter
  public static class LogContext {
    private LogConst.Action action;
    // 对象类型
    private String itemType;
    // 对象ID
    private String[] itemIds;
    // 对象类型
    private boolean printInfoLog;
    // 开启方法调用耗时统计
    private boolean enableProfiler;
    //分线器名称，不传默认为方法名称
    private String profilerName;
    // 如果是数组 是否打印出参大小，不打印对象值
    private boolean printOutParamSize;
    // 需要排除不打印的入参
    private String[] excludeInParam;
    //需要打印的入参
    private String[] includeInParam;
    // （其他）参数
    private String[] param;
    private boolean enableLog;
    protected boolean isEnableLog() {
      return enableLog;
    protected void setEnableLog(boolean enableLog) {
      this.enableLog = enableLog;
    protected Action action() {
      return action;
    protected String itemType() {
      return itemType;
    protected String[] itemIds() {
      return itemIds;
    protected boolean printInfoLog() {
      return printInfoLog;
    protected boolean enableProfiler() {
      return enableProfiler;
    protected String profilerName() {
      return profilerName;
    protected boolean printOutParamSize() {
      return printOutParamSize;
    protected String[] excludeInParam() {
      return excludeInParam;
    protected String[] includeInParam() {
      return includeInParam;
    protected String[] param() {
      return param;
    protected void setAction(Action action) {
      this.action = action;
    protected void setItemType(String itemType) {
      this.itemType = itemType;
    protected void setItemIds(String[] itemIds) {
      this.itemIds = itemIds;
    protected void setPrintInfoLog(boolean printInfoLog) {
      this.printInfoLog = printInfoLog;
    protected void setEnableProfiler(boolean enableProfiler) {
      this.enableProfiler = enableProfiler;
    protected void setProfilerName(String profilerName) {
      this.profilerName = profilerName;
    protected void setPrintOutParamSize(boolean printOutParamSize) {
      this.printOutParamSize = printOutParamSize;
    protected void setExcludeInParam(String[] excludeInParam) {
      this.excludeInParam = excludeInParam;
    protected void setIncludeValue(String[] includeInParam) {
      this.includeInParam = includeInParam;
    protected void setParam(String[] param) {
      this.param = param;

LogAop

@Aspect
@Component
@Order(1)  //order最小最先执行  保证ProfilerAOP 后于LogAop执行
public class LogAOP implements ApplicationContextAware {
   * logger
  private static final Logger LOG = XLoggerFactory.getXLogger(LogAOP.class);
  private static final String LOG_JSON = "logjson";
  private static final String USER = "user";
  private static final String CODE = "code";
  private static final String DOT_NOTATION = "."




    
;
  @Autowired
  private List<FilterResultService> filterResultServices;
  private LogService logService;
  @Pointcut("@annotation(com.enhance.annotations.Log) || @annotation(com.enhance.annotations.LogProfiler)")
  public void logPoint() {
  @SneakyThrows
  @Around("logPoint()")
  public Object handlerLogMethod(ProceedingJoinPoint joinPoint) {
    //  得到方法上的注解
    // ------------------------------------------------------------------------------
    MethodSignature signature = (MethodSignature) joinPoint.getSignature();
    Method method = signature.getMethod();
    LogProfiler logProfiler = method.getAnnotation(LogProfiler.class);
    Log logAnnotation = method.getAnnotation(Log.class);
    Object result = null;
    if (logAnnotation != null && null != logProfiler) {
      LOG.warn("@LogProfiler 和 @Log 不允许一起使用");
      result = joinPoint.proceed();
    } else {
      LogThreadContext ltc = LogThreadContext.getLogThreadContext();
      try {
        try {
          initLogContext(method, ltc);
          this.handBeforeMethodLog(joinPoint, ltc);
        } catch (Exception e) {
          LOG.warn("handlerLogMethod before:{}", e);
        result = joinPoint.proceed();
      } finally {
        try {
          if (null != logProfiler) {
            ProfilerAOP.printProfiler(ltc);
          this.handAfterMethodLog(joinPoint, ltc, result);
          this.handleMDCValue();
        } catch (Exception e) {
          LOG.warn("handlerLogMethod finally:{}", e);
    return result;
   * 初始化日志上下文
   * @return void
   * @author gongliangjun 2020-06-04 2:30 PM
  private void initLogContext(Method method, LogThreadContext ltc) {
    LogContext logContext = new LogContext();
    LogProfiler logProfiler = method.getAnnotation(LogProfiler.class);
    Log logAnnotation = method.getAnnotation(Log.class);
    if (logProfiler != null) {
      logContext.setEnableLog(true);
      logContext.setAction(logProfiler.action());
      logContext.setEnableProfiler(true);
      logContext.setExcludeInParam(logProfiler.excludeInParam());
      logContext.setIncludeValue(logProfiler.includeInParam());
      logContext.setItemIds(logProfiler.itemIds());
      logContext.setItemType(logProfiler.itemType());
      logContext.setParam(logProfiler.param());
      logContext.setPrintInfoLog(logProfiler.printInfoLog());
      logContext.setPrintOutParamSize(logProfiler.printOutParamSize());
      logContext.setProfilerName(logProfiler.profilerName());
    } else if (logAnnotation != null) {
      logContext.setEnableLog(true);
      logContext.setAction(logAnnotation.action());
      logContext.setExcludeInParam(logAnnotation.excludeInParam());
      logContext.setIncludeValue(logAnnotation.includeInParam());
      logContext.setItemIds(logAnnotation.itemIds());
      logContext.setItemType(logAnnotation.itemType());
      logContext.setParam(logAnnotation.param());
      logContext.setPrintInfoLog(logAnnotation.printInfoLog());
      logContext.setPrintOutParamSize(logAnnotation.printOutParamSize());
    ltc.putContext(




    
logContext);
    ltc.setCurrentLogContext(logContext);
   * 方法执行完成后 处理MDC里的值
   * @return void
   * @author gongliangjun 2020-06-04 2:25 PM
  private void handleMDCValue() {
    LogThreadContext ltc = LogThreadContext.getLogThreadContext();
    try {
      //===============================================================================
      //  先对自己的code出栈 并且清除MDC
      //===============================================================================
      Map<String, String> popCallStack = ltc.popCallStack();
      clearMDC(popCallStack.keySet());
      if (!ltc.isEmptyCallStack()) {
        Map<String, String> currentMethodStack = ltc.peekCallStack();
        //===============================================================================
        //  把之前方法的数据存入MDC
        //===============================================================================
        for (Entry<String, String> entry : currentMethodStack.entrySet()) {
          String key = entry.getKey();
          String value = entry.getValue();
          MDC.put(key, value);
      } else {
        // 因为Tomcat线程重用
        clearMDC(new String[]{CODE, USER, LOG_JSON});
    } catch (Exception e) {
      LOG.warn("handleMDCValue error: {} ", e);
   * 打印调用方法后的日志
   * @return void
   * @author 龚梁钧 2019-06-28 13:15
  private void handAfterMethodLog(ProceedingJoinPoint joinPoint, LogThreadContext ltc,
      Object result) {
    LogContext logContext = ltc.getCurrentLogContext();
    // 是否需要打印日志
    boolean printLog = logContext.printInfoLog();
    // 如果是数组 是否打印出参大小，不打印对象值
    boolean printOutParamSize = logContext.printOutParamSize();
    MethodSignature signature = (MethodSignature) joinPoint.getSignature();
    StringBuffer endString = new StringBuffer();
    Object target = joinPoint.getTarget();
    Logger logger = LoggerFactory.getLogger(target.getClass());
    if (target instanceof Proxy) {
      endString.append(signature.getDeclaringTypeName())
          .append(".")
          .append(signature.getName());
    endString.append(signature.getName());
    endString.append(" end ");
    if (logger.isDebugEnabled() || printLog) {
      if (result instanceof Collection && printOutParamSize) {
        logger.info(endString.append(" output parameters size:{}").toString(),
            Collection.class.cast(result).size());
        return;
      String responseStr = null;
      try {
        if (CollectionUtils.isNotEmpty(filterResultServices)) {
          for (FilterResultService filterResultService : filterResultServices) {
            Optional filterResult = filterResultService.filterResult(result);
            // 返回null，说明不需要处理  返回Optional.empty(),说明处理了，处理结果为null
            if (filterResult != null) {
              LOG.debug("返回结果处理成功");
              if (filterResult.isPresent()) {
                Object fr = filterResult.get();
                if (fr instanceof Collection && printOutParamSize) {
                  logger.info(endString.append(" output parameters size:{}").toString(),
                      Collection.class.cast(fr).size());
                  return;
                } else {
                  responseStr = JSON.toJSONString(filterResult);
                break;
              } else {
                LOG.debug("处理结果为空");
      } catch (




    
Exception e) {
        LOG.warn("handAfterMethodLog error:{}", e);
      if (StringUtils.isEmpty(responseStr)) {
        responseStr = result == null ? "void" : JSON.toJSONString(result);
      endString.append("output parameters:").append(responseStr);
      if (printLog) {
        logger.info(endString.toString());
      } else {
        logger.debug(endString.toString());
    } else {
      logger.info(endString.toString());
   * 打印调用方法前的日志
   * @return org.slf4j.Logger
   * @author 龚梁钧 2019-06-28 13:13
  private Logger handBeforeMethodLog(ProceedingJoinPoint joinPoint, LogThreadContext ltc) {
    LogContext logContext = ltc.getCurrentLogContext();
    String[] params = logContext.param();
    Object target = joinPoint.getTarget();
    Class<?> targetClass = target.getClass();
    // 是否需要打印日志
    boolean printLog = logContext.printInfoLog();
    MethodSignature signature = (MethodSignature) joinPoint.getSignature();
    Logger logger = LoggerFactory.getLogger(targetClass);
    if (logger.isDebugEnabled() || printLog) {
      //===============================================================================
      //  保存action、itemType、itemId到MDC
      //===============================================================================
      saveLogInfo2MDC(joinPoint, ltc);
      StringBuilder mesInfo = new StringBuilder();
      if (target instanceof Proxy) {
        mesInfo.append(signature.getDeclaringTypeName())
            .append(".");
      mesInfo.append(signature.getName());
      String profilerName = new StringBuilder(targetClass.getSimpleName()).append("#")
          .append(mesInfo.toString()).toString();
      //===============================================================================
      //  方法调用耗时统计
      //===============================================================================
      if (Boolean.TRUE.equals(logContext.enableProfiler())) {
        ProfilerAOP.handleProfiler(logger, ltc, logContext, profilerName);
      mesInfo.append(" start parameters:{}");
      // 如果params大于0，说明存在用户想打印的参数
      // ------------------------------------------------------------------------------
      if (params.length > 0) {
        SPELUtil spel = new SPELUtil(joinPoint);
        JSONObject json = new JSONObject();
        for (String param : params) {
          // 其他参数，spel表达式
          json.put(param, spel.cacl(param));
        if (printLog) {
          logger.info(mesInfo.toString(), json.toJSONString());
        } else {
          logger.debug(mesInfo.toString(), json.toJSONString());
      } else {
        // 所在的类.方法
        String methodStr = this.getMethodParam(joinPoint, logContext);
//        String methodStr = this.getMethodParam(joinPoint, excludeInParam);
        if (printLog) {
          logger.info(mesInfo.toString(), methodStr);
        } else {
          logger.debug(mesInfo.toString(), methodStr);
    return logger;
  private void saveLogInfo2MDC(ProceedingJoinPoint pjp, LogThreadContext ltc) {
    //===============================================================================
    //  保存用户信息到MDC
    //===============================================================================
    if (this.logService != null) {
      String userInfo = logService.getUserInfo();
      if (StringUtils.




    
isNotEmpty(userInfo)) {
        MDC.put(USER, userInfo);
    JSONObject json = this.getLogJson(pjp, ltc);
    if (!json.isEmpty()) {
      String jsonString = json.toJSONString();
      MDC.put(LOG_JSON, jsonString);
      ltc.putCallStack(new HashMap(3) {{
        put(LOG_JSON, jsonString);
      }});
    } else {
      ltc.putCallStack(new HashMap(1));
   * 获取注解Log的值,构造成json，供sf4j使用
   * @return com.alibaba.fastjson.JSONObject
   * @author 龚梁钧 2019-06-28 11:24
  private JSONObject getLogJson(ProceedingJoinPoint pjp, LogThreadContext ltc) {
    LogContext logContext = ltc.getCurrentLogContext();
    LogConst.Action action = logContext.action();
    String itemType = logContext.itemType();
    String[] itemIds = logContext.itemIds();
    SPELUtil spel = new SPELUtil(pjp);
    JSONObject json = new JSONObject();
    // 操作
    if (!LogConst.Action.NULL.equals(action)) {
      json.put("A", action.toString());
    // 对象类型
    if (StringUtils.isNotEmpty(itemType)) {
      json.put("T", itemType);
    // 对象类型
    if (itemIds.length > 0) {
      for (String itemId : itemIds) {
        if (itemId.contains(DOT_NOTATION)) {
          String substring = itemId.substring(itemId.indexOf(DOT_NOTATION) + 1);
          json.put(substring, spel.cacl(itemId));
        } else {
          json.put(itemId, spel.cacl(itemId));
    return json;
  private void clearMDC(String[] clears) {
    for (String clear : clears) {
      MDC.remove(clear);
  private void clearMDC(Set<String> clears) {
    for (String clear : clears) {
      MDC.remove(clear);
   * 获取方法入参
   * @return java.lang.String
   * @author 龚梁钧 2019-06-28 13:35
  private String getMethodParam(ProceedingJoinPoint point, LogContext logContext) {
    Object[] methodArgs = point.getArgs();
    Parameter[] parameters = ((MethodSignature) point.getSignature()).getMethod().getParameters();
    String requestStr;
    try {
      requestStr = logParam(parameters, methodArgs, logContext);
    } catch (Exception e) {
      LOG.warn("failed to get parameters: {}", e);
      requestStr = "failed to get parameters";
    return requestStr;
   * 拼接入参
   * @param paramsArgsName
   * @param paramsArgsValue
   * @param logContext
   * @author gongliangjun 2020-06-05 3:16 PM
   * @return java.lang.String
  private String logParam(Parameter[] paramsArgsName, Object[] paramsArgsValue,
      LogContext logContext) {
    if (ArrayUtils.isEmpty(paramsArgsName) || ArrayUtils.isEmpty(paramsArgsValue)) {
      return "";
    String[] excludeInParam = logContext.getExcludeInParam();
    String[] includeInParam = logContext.getIncludeInParam();
    Map<String, List<String>> excludeCollect = null;
    Map<String, List<String>> includeCollect = null;
    if (ArrayUtils




    
.isNotEmpty(includeInParam)) {
      includeCollect = Arrays.stream(includeInParam)
          .filter(a -> a.startsWith("arg") && a.contains("."))
          .collect(Collectors.groupingBy(e -> {
            String substring = e.substring(0, 4);
            return substring;
          }));
    if (ArrayUtils.isNotEmpty(excludeInParam)) {
      excludeCollect = Arrays.stream(excludeInParam)
          .filter(a -> a.startsWith("arg") && a.contains("."))
          .collect(Collectors.groupingBy(e -> {
            String substring = e.substring(0, 4);
            return substring;
          }));
    StringBuffer buffer = new StringBuffer();
    Flag:
    for (int i = 0; i < paramsArgsValue.length; i++) {
      //参数名
      String name = paramsArgsName[i].getName();
      //参数值
      Object value = paramsArgsValue[i];
      // 判断当前参数值是否属于excludeInParam，如果属于，则跳过不进行拼接
      // ------------------------------------------------------------------------------
      for (String exclude : excludeInParam) {
        if (name.equals(exclude)) {
          continue Flag;
        Class<?> aClass = value.getClass();
        if (exclude.equals(aClass.getSimpleName()) || exclude.equals(aClass.getName())) {
          continue Flag;
      buffer.append(name + "=");
      if (value instanceof String) {
        buffer.append(value + ",");
      } else {
        PropertyPreFilters filter = new PropertyPreFilters();
        if (null != includeCollect) {
          List<String> list = includeCollect.get(name);
          if (null != list) {
            for (String e : list) {
              filter.addFilter(e.substring(e.indexOf(".")+1));
        if (null != excludeCollect) {
          List<String> list = excludeCollect.get(name);
          if (null != list) {
            for (String e : list) {
              filter.addFilter().addExcludes(e.substring(e.indexOf(".")+1));
        List<MySimplePropertyPreFilter> filters = filter.getFilters();
        if (null != filters && filters.size() > 0) {
          SimplePropertyPreFilter[] simplePropertyPreFilters = new SimplePropertyPreFilter[filters
              .size()];
          for (int i1 = 0; i1 < filters.size(); i1++) {
            simplePropertyPreFilters[i1] = filters.get(i1);
          buffer.append(JSON.toJSONString(value, simplePropertyPreFilters) + ",");
        }else {
          buffer.append(JSON.toJSONString(value) + ",");
    return buffer.toString();
  @Override
  public void setApplicationContext(ApplicationContext applicationContext) {
    try {
      this.




    
logService = applicationContext.getBean(LogService.class);
    } catch (BeansException e) {
      LOG.info("logService is null");

ProfilerAOP，方法执行耗时统计切面

@Aspect
@Component
@XSlf4j
@Order(10) //order最小最先执行  保证ProfilerAOP 后于LogAop执行
public class ProfilerAOP {
   * 打印方法执行耗时统计
   * @param ltc
   * @author gongliangjun 2020-06-04 2:28 PM
   * @return void
  static void printProfiler(LogThreadContext ltc) {
    Profiler parent = ltc.getFirstProfiler();
    //===============================================================================
    //  当第一个方法是
    //===============================================================================
    if (ltc.isFirstMethod() && null != parent) {
      TimeInstrument timeInstrument = parent.stop();
      timeInstrument.print();
      ProfilerRegistry profilerRegistry = ProfilerRegistry.getThreadContextInstance();
      profilerRegistry.clear();
      ltc.removeCurrentProfiler();
      ltc.removeCurrentLogContext();
    } else {
      ltc.removeCurrentProfiler();
      try {
        ltc.changeCurrentLogContext();
      } catch (Exception e) {
        log.warn("changeCurrentLogContext error:{}", e);
   * 处理方法执行耗时统计
   * @param logger
   * @param ltc
   * @param logContext
   * @param profilerName
   * @author gongliangjun 2020-06-04 2:28 PM
   * @return void
  static void handleProfiler(Logger logger, LogThreadContext ltc, LogContext logContext,
      String profilerName) {
    // 在线程上下文的探查器注册表中注册此探查器
    ProfilerRegistry profilerRegistry = ProfilerRegistry.getThreadContextInstance();
    if (ltc.isFirstProfiler()) {
      Profiler parent = new Profiler(profilerName);
      ltc.put(profilerName, parent);
      parent.registerWith(profilerRegistry);
      parent.setLogger(logger);
      parent.start(profilerName);
    } else {
      String name = logContext.profilerName();
      if (StringUtils.isNotBlank(name)) {
        profilerName = name;
      Profiler parent = ltc.getPrevProfiler();
      parent.setLogger(logger);
      Profiler childProfiler = parent.startNested(profilerName);
      // 获取注册的分析器
      childProfiler.start(profilerName);
      //===============================================================================
      //  将childProfiler放入log上下文中
      //===============================================================================
      ltc.putProfiler(childProfiler);
  @Pointcut("@annotation(com.enhance.annotations.EnableProfiler)")
  public void profilerPoint() {
  @SneakyThrows
  @Around("profilerPoint()")
  public Object handlerProfilerMethod(ProceedingJoinPoint joinPoint) {
    MethodSignature signature = (MethodSignature) joinPoint.getSignature();
    Method method = signature.getMethod();
    LogProfiler logProfiler = method.getAnnotation(LogProfiler.class);
    if (logProfiler != null) {
      return joinPoint.proceed();
    } else {
      Object target = joinPoint.getTarget();
      Class<?> targetClass = target.getClass();
      Logger logger = LoggerFactory.getLogger(targetClass);
      StringBuilder methodName = new StringBuilder();
      if (target instanceof Proxy) {
        methodName.append(signature.getDeclaringTypeName())
            .append(".");
      methodName.append(signature.getName());
      LogThreadContext ltc = LogThreadContext.getLogThreadContext();
      initLogContext(method, ltc);
      LogContext logContext = ltc.getCurrentLogContext();
      String profilerName = methodName.toString();
      Object result = null;
      try {
        try {
          handleProfiler




    
(logger, ltc, logContext, profilerName);
        } catch (Exception e) {
          log.warn("handlerProfilerMethod error:{}", e);
        result = joinPoint.proceed();
      } finally {
        printProfiler(ltc);
      return result;
  private void initLogContext(Method method, LogThreadContext ltc) {
    EnableProfiler enableProfiler = method.getAnnotation(EnableProfiler.class);
    Log logAnnotation = method.getAnnotation(Log.class);
    LogContext logContext;
    if (logAnnotation != null) {
      //===============================================================================
      //  说明该方法已经在LogThreadContext 的logContexts里存过值了，这里只需取出来setProfilerName、setEnableProfiler
      //===============================================================================
      logContext = ltc.peekContext();
      logContext.setEnableLog(true);
    } else {
      logContext = new LogContext();
      ltc.putContext(logContext);
    logContext.setEnableProfiler(true);
    String profilerName = enableProfiler.profilerName();
    logContext.setProfilerName(profilerName);
    ltc.setCurrentLogContext(logContext);