Java PatternLayout类代码示例

import ch.qos.logback.classic.PatternLayout; //导入依赖的package包/类
@Override
public void configure(LoggerContext lc) {
  addInfo("Setting up robot logging configuration.");

  ConsoleAppender<ILoggingEvent> ca = new ConsoleAppender<>();
  ca.setContext(lc);
  ca.setName("console");
  LayoutWrappingEncoder<ILoggingEvent> encoder = new LayoutWrappingEncoder<>();
  encoder.setContext(lc);

  PatternLayout layout = new PatternLayout();
  layout.setPattern("%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n");

  layout.setContext(lc);
  layout.start();
  encoder.setLayout(layout);

  ca.setEncoder(encoder);
  ca.start();

  Logger rootLogger = lc.getLogger(Logger.ROOT_LOGGER_NAME);
  rootLogger.addAppender(ca);
  rootLogger.setLevel(Level.DEBUG);
}
 

import ch.qos.logback.classic.PatternLayout; //导入依赖的package包/类
private static void enablePaperTrail(final String hostname, final int port, final String ident) {
    final LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory();

    final PatternLayout patternLayout = new PatternLayout();
    patternLayout.setContext(lc);
    patternLayout.setPattern(LOG_PATTERN);
    patternLayout.start();

    final SSLTCPNetSyslogConfig syslogConfig = new SSLTCPNetSyslogConfig(hostname, port);
    syslogConfig.setIdent(ident);
    syslogConfig.setMaxMessageLength(128000);
    syslogConfig.setSendLocalTimestamp(false);
    syslogConfig.setSendLocalName(false);

    final Syslog4jAppender<ILoggingEvent> syslog4jAppender = new Syslog4jAppender<>();
    syslog4jAppender.setSyslogConfig(syslogConfig);
    syslog4jAppender.setLayout(patternLayout);
    syslog4jAppender.start();

    final Logger logger = (Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);

    logger.addAppender(syslog4jAppender);
    logger.setLevel(Level.DEBUG);
    logger.setAdditive(true); /* set to true if root should log too */
}
 

import ch.qos.logback.classic.PatternLayout; //导入依赖的package包/类
@Test
public void callerData() {
  assertEquals(0, listAppender.list.size());

  PatternLayout pl = new PatternLayout();
  pl.setPattern("%-5level [%class] %logger - %msg");
  pl.setContext(lc);
  pl.start();
  listAppender.layout = pl;

  Logger logger = Logger.getLogger("basic-test");
  logger.trace("none");
  assertEquals(0, listAppender.list.size());
  
  rootLogger.setLevel(Level.TRACE);
  logger.trace(HELLO);
  assertEquals(1, listAppender.list.size());

  ILoggingEvent event = (ILoggingEvent) listAppender.list.get(0);
  assertEquals(HELLO, event.getMessage());

  assertEquals(1, listAppender.stringList.size());
  assertEquals("TRACE [" + Log4jInvocation.class.getName()
      + "] basic-test - Hello", listAppender.stringList.get(0));
}
 

import ch.qos.logback.classic.PatternLayout; //导入依赖的package包/类
@Test
public void integration() {
  PatternLayout pl = new PatternLayout();
  pl.setContext(lc);
  pl.setPattern("%m%n");
  pl.start();
  ILoggingEvent e = createLoggingEvent(new Exception("x"));
  String res = pl.doLayout(e);

  // make sure that at least some package data was output
  Pattern p = Pattern.compile("\\s*at .*?\\[.*?\\]");
  Matcher m = p.matcher(res);
  int i = 0;
  while(m.find()) {
    i++;
  }
  assertTrue(i+ " should be larger than 5", i > 5);
}
 

import ch.qos.logback.classic.PatternLayout; //导入依赖的package包/类
@Test
public void integration() {
  //given
  PatternLayout pl = new PatternLayout();
  pl.setContext(context);
  pl.setPattern("%m%rEx%n");
  pl.start();

  //when
  ILoggingEvent e = createLoggingEvent(new Exception("x"));
  String result = pl.doLayout(e);

  //then
  // make sure that at least some package data was output
  Pattern p = Pattern.compile("\\s*at .*?\\[.*?\\]");
  Matcher m = p.matcher(result);
  int i = 0;
  while(m.find()) {
    i++;
  }
  assertThat(i).isGreaterThan(5);
}
 

import ch.qos.logback.classic.PatternLayout; //导入依赖的package包/类
private void doFailSafeConfiguration() {
    // Not really fail-safe, just less likely to fail
    final LoggerContext context = (LoggerContext) LoggerFactory.getILoggerFactory();
    context.reset();
    Logger rootLogger = context.getLogger(Logger.ROOT_LOGGER_NAME);
    rootLogger.setLevel(Level.INFO);

    ConsoleAppender<ILoggingEvent> appender = new ConsoleAppender<ILoggingEvent>();
    rootLogger.addAppender(appender);
    appender.setContext(context);
    appender.setTarget("System.err");

    PatternLayout layout = new PatternLayout();
    appender.setLayout(layout);
    layout.setPattern("%msg%n%ex");
    layout.setContext(context);

    layout.start();
    appender.start();
}
 

import ch.qos.logback.classic.PatternLayout; //导入依赖的package包/类
@Override
public void start()
{
    if (isStarted()) {
        return;
    }

    PatternLayout patternLayout = new PatternLayout();
    patternLayout.setContext(context);
    patternLayout.setPattern(PATTERN);
    patternLayout.setOutputPatternAsHeader(false);
    patternLayout.start();
    this.layout = patternLayout;

    super.start();
}
 

import ch.qos.logback.classic.PatternLayout; //导入依赖的package包/类
protected Appender buildAppender(String name, String fileName, String pattern) {
    RollingFileAppender appender = new RollingFileAppender();
    appender.setContext(loggerContext);
    appender.setName(name);
    appender.setAppend(true);
    appender.setFile(new File(getLogPath(), fileName).getAbsolutePath());

    TimeBasedRollingPolicy rolling = new TimeBasedRollingPolicy();
    rolling.setParent(appender);
    rolling.setFileNamePattern(new File(getLogPath(), fileName).getAbsolutePath() + ".%d{yyyy-MM-dd}");
    rolling.setContext(loggerContext);
    rolling.start();
    appender.setRollingPolicy(rolling);

    PatternLayout layout = new PatternLayout();
    layout.setPattern(pattern);
    layout.setContext(loggerContext);
    layout.start();
    appender.setLayout(layout);
    // 启动
    appender.start();
    return appender;
}
 

import ch.qos.logback.classic.PatternLayout; //导入依赖的package包/类
protected Appender buildDailyMaxRollingAppender(String name, String fileName, String pattern, int maxBackupIndex) {
    RollingFileAppender appender = new RollingFileAppender();
    appender.setContext(loggerContext);
    appender.setName(name);
    appender.setAppend(true);
    appender.setFile(new File(getLogPath(), fileName).getAbsolutePath());

    TimeBasedRollingPolicy rolling = new TimeBasedRollingPolicy();
    rolling.setContext(loggerContext);
    rolling.setFileNamePattern(new File(getLogPath(), fileName).getAbsolutePath() + ".%d{yyyy-MM-dd-HH}");
    rolling.setMaxHistory(maxBackupIndex);
    rolling.setParent(appender);
    rolling.start();
    appender.setRollingPolicy(rolling);

    PatternLayout layout = new PatternLayout();
    layout.setContext(loggerContext);
    layout.setPattern(pattern);
    layout.start();
    appender.setLayout(layout);
    // 启动
    appender.start();
    return appender;
}
 

import ch.qos.logback.classic.PatternLayout; //导入依赖的package包/类
private ConsoleAppender<ILoggingEvent> getConsoleAppender(final LoggingSettings.Console settings,
                                                                final LoggerContext context) {
    final PatternLayout formatter = getPatternLayout(context);
    formatter.setPattern(settings.getLogFormat());
    formatter.start();

    final ConsoleAppender<ILoggingEvent> appender = new ConsoleAppender<ILoggingEvent>();
    appender.setContext(context);
    appender.setLayout(formatter);

    addThresholdFilter(appender, settings.getThreshold());

    appender.start();

    return appender;
}
 

import ch.qos.logback.classic.PatternLayout; //导入依赖的package包/类
@Before
public void setUp() throws Exception {
    MockitoAnnotations.initMocks(this);
    _context = new LoggerContext();
    _context.start();
    _baos = new ByteArrayOutputStream();
    _encoder = new KeyValueEncoder();
    _encoder.setImmediateFlush(true);

    final PatternLayout layout = new PatternLayout();
    layout.setPattern("[%d{dd MMM yyyy HH:mm:ss.SSS,UTC}] %t - %m%n");
    layout.setContext(_context);
    layout.start();
    _encoder.setLayout(layout);
    _encoder.setContext(_context);
    Mockito.doThrow(new RuntimeException("Mocked Failure")).when(_throwingLayout).doLayout(Mockito.any(ILoggingEvent.class));
}
 

import ch.qos.logback.classic.PatternLayout; //导入依赖的package包/类
public static void initLogback() {
    LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory();

    StatusManager statusManager = loggerContext.getStatusManager();
    if (statusManager != null) {
        statusManager.add(new InfoStatus("Setting up logger configuration.", loggerContext));
    }

    final PatternLayout layout = new PatternLayout();
    layout.setContext(loggerContext);
    layout.setPattern("%msg%n");
    layout.start();

    AppenderBase<ILoggingEvent> appender = new AppenderBase<ILoggingEvent>() {
        @Override
        protected void append(ILoggingEvent event) {
            String message = layout.doLayout(event);
            LogHelper.appendLogEntry(event.getTimeStamp(), convertLevel(event.getLevel()),
                    event.getLoggerName(), event.getThreadName(), message);
        }
    };
    appender.setContext(loggerContext);
    appender.setName(LOGBACK_APPENDER_NAME);
    appender.start();

    Logger rootLogger = loggerContext.getLogger(Logger.ROOT_LOGGER_NAME);
    rootLogger.addAppender(appender);
}
 

import ch.qos.logback.classic.PatternLayout; //导入依赖的package包/类
@Before
public void setUp() {
	PatternLayout.defaultConverterMap.put("crlf",
			CRLFConverter.class.getName());
	// layout = new PatternLayout();

	encoder = new PatternLayoutEncoder();
	encoder.setContext(loggerContext);
	encoder.setPattern("%-4relative [%thread] %-5level %logger{35} - %crlf(%msg)%n");
	encoder.start();

	// Layout layout = new PatternLayout();
	// layout.setEncoder(encoder);

	mockAppender.setContext(loggerContext);
	mockAppender.setEncoder(encoder);
	mockAppender.start();

	LOGGER = (Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
	LOGGER.addAppender(mockAppender);
}
 

import ch.qos.logback.classic.PatternLayout; //导入依赖的package包/类
@Before
public void setUp() {
	PatternLayout.defaultConverterMap.put("mask",
			MaskingConverter.class.getName());

	encoder = new PatternLayoutEncoder();
	encoder.setContext(loggerContext);
	encoder.setPattern("%-4relative [%thread] %-5level %logger{35} - %mask%n");
	encoder.start();

	mockAppender.setContext(loggerContext);
	mockAppender.setEncoder(encoder);
	mockAppender.start();

	LOGGER.addAppender(mockAppender);
}
 

import ch.qos.logback.classic.PatternLayout; //导入依赖的package包/类
/**
 * Check whether ConsoleAppender was already added
 * @param logger
 * @return true   if it was already added
 *         false  if it does not contain ConsoleAppender
 */
public static void addConsoleAppenderIfNotPresent(Logger logger) {
  boolean isConsoleAppenderAdded = false;
  PatternLayout layout = null;
  Iterator<Appender<ILoggingEvent>> appenderSeries = logger.iteratorForAppenders();
  while (appenderSeries.hasNext()) {
    Appender<ILoggingEvent> appender = (Appender<ILoggingEvent>) appenderSeries.next();
    if (appender instanceof ConsoleAppender) {
      isConsoleAppenderAdded = true;
      break;
    }
  }
  if (!isConsoleAppenderAdded) {
    if (layout == null) {
      layout = LoggerUtil.getPatternLayout(logger.getLoggerContext());
    }
    if (logger.getLevel() == null) {
      logger.setLevel(Level.DEBUG);
    }
    ConsoleAppender<ILoggingEvent> consoleAppender = LoggerUtil.getConsoleAppender(layout,
      logger.getLoggerContext());
    logger.addAppender(consoleAppender);
  }
}