Java RollingFileAppender.setRollingPolicy方法代码示例

import ch.qos.logback.core.rolling.RollingFileAppender; //导入方法依赖的package包/类
private Appender<ILoggingEvent> fileAppender(LogbackConfigurator config,
		String logFile) {
	RollingFileAppender<ILoggingEvent> appender = new RollingFileAppender<ILoggingEvent>();
	PatternLayoutEncoder encoder = new PatternLayoutEncoder();
	String logPattern = this.patterns.getProperty("file", FILE_LOG_PATTERN);
	encoder.setPattern(OptionHelper.substVars(logPattern, config.getContext()));
	appender.setEncoder(encoder);
	config.start(encoder);

	appender.setFile(logFile);

	FixedWindowRollingPolicy rollingPolicy = new FixedWindowRollingPolicy();
	rollingPolicy.setFileNamePattern(logFile + ".%i");
	appender.setRollingPolicy(rollingPolicy);
	rollingPolicy.setParent(appender);
	config.start(rollingPolicy);

	SizeBasedTriggeringPolicy<ILoggingEvent> triggeringPolicy = new SizeBasedTriggeringPolicy<ILoggingEvent>();
	triggeringPolicy.setMaxFileSize("10MB");
	appender.setTriggeringPolicy(triggeringPolicy);
	config.start(triggeringPolicy);

	config.appender("FILE", appender);
	return appender;
}
 

import ch.qos.logback.core.rolling.RollingFileAppender; //导入方法依赖的package包/类
protected FileAppender<ILoggingEvent> createRollingFileAppender(Encoder<ILoggingEvent> encoder,
                                                                LoggerContext context,
                                                                RollingPolicyFactory rollingPolicy) {

    RollingFileAppender<ILoggingEvent> appender = new RollingFileAppender<>();
    appender.setFile(file);
    appender.setContext(context);
    appender.setEncoder(encoder);
    // Setup rolling policy
    RollingPolicy policy = rollingPolicy.createRollingPolicy(context);
    appender.setRollingPolicy(policy);
    policy.setParent(appender);
    // Setup triggering policy
    TriggeringPolicy<ILoggingEvent> triggeringPolicy = rollingPolicy.createTriggeringPolicy(context);
    if (triggeringPolicy != null) {
        appender.setTriggeringPolicy(triggeringPolicy);
        triggeringPolicy.start();
    }
    policy.start();
    appender.start();

    return appender;
}
 

import ch.qos.logback.core.rolling.RollingFileAppender; //导入方法依赖的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.setContext(loggerContext);
    rolling.setParent(appender);
    rolling.setFileNamePattern(new File(getLogPath(), fileName).getAbsolutePath() + ".%d{yyyy-MM-dd}");
    rolling.start();
    appender.setRollingPolicy(rolling);

    PatternLayoutEncoder layout = new PatternLayoutEncoder();
    layout.setContext(loggerContext);
    layout.setPattern(pattern);
    layout.setCharset(Charset.forName(getEncoding()));
    layout.start();
    appender.setEncoder(layout);
    // 启动
    appender.start();
    return appender;
}
 

import ch.qos.logback.core.rolling.RollingFileAppender; //导入方法依赖的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);

    PatternLayoutEncoder layout = new PatternLayoutEncoder();
    layout.setContext(loggerContext);
    layout.setPattern(pattern);
    layout.setCharset(Charset.forName(getEncoding()));
    layout.start();
    appender.setEncoder(layout);
    // 启动
    appender.start();
    return appender;
}
 

import ch.qos.logback.core.rolling.RollingFileAppender; //导入方法依赖的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.core.rolling.RollingFileAppender; //导入方法依赖的package包/类
private Appender buildDailyMaxRollingAppender(String name, String fileName, String pattern, int maxBackupIndex) {
    RollingFileAppender appender = new RollingFileAppender();
    appender.setName(name);
    appender.setAppend(true);
    appender.setFile(new File(getLogPath(), fileName).getAbsolutePath());

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

    PatternLayoutEncoder layout = new PatternLayoutEncoder();
    layout.setPattern(pattern);
    layout.setCharset(Charset.forName(getEncoding()));
    appender.setEncoder(layout);
    // 启动
    appender.start();
    return appender;
}
 

import ch.qos.logback.core.rolling.RollingFileAppender; //导入方法依赖的package包/类
private Appender buildAppender(String name, String fileName, String pattern) {
    RollingFileAppender appender = new RollingFileAppender();
    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}");
    appender.setRollingPolicy(rolling);

    PatternLayoutEncoder layout = new PatternLayoutEncoder();
    layout.setPattern(pattern);
    layout.setCharset(Charset.forName(getEncoding()));
    appender.setEncoder(layout);
    // 启动
    appender.start();
    return appender;
}
 

import ch.qos.logback.core.rolling.RollingFileAppender; //导入方法依赖的package包/类
public static void addFileAppender(String name, String logPattern, String filePath, int maxHistory) {
	RollingFileAppender<ILoggingEvent> fileAppender = new RollingFileAppender<ILoggingEvent>();
       fileAppender.setFile(filePath);
       fileAppender.setEncoder(getPatternLayoutEncoder(logPattern));
       fileAppender.setContext(loggerContext);
       fileAppender.setName(name);
       fileAppender.setAppend(true);
       
       // time based rolling policy
       TimeBasedRollingPolicy<ILoggingEvent> logFilePolicy = new TimeBasedRollingPolicy<>();
    logFilePolicy.setContext(loggerContext);
    logFilePolicy.setParent(fileAppender);
    logFilePolicy.setFileNamePattern(getDateBasedFileName(filePath));
    logFilePolicy.setMaxHistory(50);
    logFilePolicy.start();
    
    fileAppender.setRollingPolicy(logFilePolicy);
       fileAppender.start();

       registeredAppenders.put(name, fileAppender);
}
 

import ch.qos.logback.core.rolling.RollingFileAppender; //导入方法依赖的package包/类
private static OutputStreamAppender<ILoggingEvent> configureFileLogging(File logFile, LoggerContext loggerContext) {
    RollingFileAppender<ILoggingEvent> rollingFileAppender = new RollingFileAppender<ILoggingEvent>();
    rollingFileAppender.setFile(logFile.getAbsolutePath());
    rollingFileAppender.setName("com.documents4j.logger.client.file");
    rollingFileAppender.setContext(loggerContext);
    FixedWindowRollingPolicy fixedWindowRollingPolicy = new FixedWindowRollingPolicy();
    fixedWindowRollingPolicy.setFileNamePattern(logFile.getAbsolutePath() + ".%i.gz");
    fixedWindowRollingPolicy.setMaxIndex(LogDescription.MAXIMUM_LOG_HISTORY_INDEX);
    fixedWindowRollingPolicy.setContext(loggerContext);
    fixedWindowRollingPolicy.setParent(rollingFileAppender);
    SizeBasedTriggeringPolicy<ILoggingEvent> sizeBasedTriggeringPolicy = new SizeBasedTriggeringPolicy<ILoggingEvent>();
    sizeBasedTriggeringPolicy.setMaxFileSize(LogDescription.MAXIMUM_LOG_FILE_SIZE);
    sizeBasedTriggeringPolicy.setContext(loggerContext);
    rollingFileAppender.setRollingPolicy(fixedWindowRollingPolicy);
    rollingFileAppender.setTriggeringPolicy(sizeBasedTriggeringPolicy);
    sizeBasedTriggeringPolicy.start();
    fixedWindowRollingPolicy.start();
    System.out.println("Logging: The log is written to " + logFile);
    return rollingFileAppender;
}
 

import ch.qos.logback.core.rolling.RollingFileAppender; //导入方法依赖的package包/类
private static OutputStreamAppender<ILoggingEvent> configureFileLogging(File logFile, LoggerContext loggerContext) {
    RollingFileAppender<ILoggingEvent> rollingFileAppender = new RollingFileAppender<ILoggingEvent>();
    rollingFileAppender.setFile(logFile.getAbsolutePath());
    rollingFileAppender.setName("com.documents4j.logger.server.file");
    rollingFileAppender.setContext(loggerContext);
    FixedWindowRollingPolicy fixedWindowRollingPolicy = new FixedWindowRollingPolicy();
    fixedWindowRollingPolicy.setFileNamePattern(logFile.getAbsolutePath() + ".%i.gz");
    fixedWindowRollingPolicy.setMaxIndex(LogDescription.MAXIMUM_LOG_HISTORY_INDEX);
    fixedWindowRollingPolicy.setContext(loggerContext);
    fixedWindowRollingPolicy.setParent(rollingFileAppender);
    SizeBasedTriggeringPolicy<ILoggingEvent> sizeBasedTriggeringPolicy = new SizeBasedTriggeringPolicy<ILoggingEvent>();
    sizeBasedTriggeringPolicy.setMaxFileSize(LogDescription.MAXIMUM_LOG_FILE_SIZE);
    sizeBasedTriggeringPolicy.setContext(loggerContext);
    rollingFileAppender.setRollingPolicy(fixedWindowRollingPolicy);
    rollingFileAppender.setTriggeringPolicy(sizeBasedTriggeringPolicy);
    sizeBasedTriggeringPolicy.start();
    fixedWindowRollingPolicy.start();
    System.out.println("Logging: The log is written to " + logFile);
    return rollingFileAppender;
}
 

import ch.qos.logback.core.rolling.RollingFileAppender; //导入方法依赖的package包/类
/**
 * Initializer logback
 * 
 * @param file
 * @param level
 * @param maxHistory
 */
private void doInitializer(String file, String level, int maxHistory) {
	LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory();
	Logger rootLogger = loggerContext.getLogger(Logger.ROOT_LOGGER_NAME);
	rootLogger.detachAndStopAllAppenders();

	// appender
	RollingFileAppender<ILoggingEvent> fileAppender = new RollingFileAppender<ILoggingEvent>();
	fileAppender.setContext(loggerContext);
	fileAppender.setName("application");
	fileAppender.setFile(file);
	fileAppender.setAppend(true);

	// policy
	TimeBasedRollingPolicy<ILoggingEvent> policy = new TimeBasedRollingPolicy<ILoggingEvent>();
	policy.setContext(loggerContext);
	policy.setMaxHistory(maxHistory);
	policy.setFileNamePattern(file + ".%d{yyyy-MM-dd}");
	policy.setParent(fileAppender);
	policy.start();
	fileAppender.setRollingPolicy(policy);

	// encoder
	PatternLayoutEncoder encoder = new PatternLayoutEncoder();
	encoder.setContext(loggerContext);
	encoder.setPattern("%date [%thread] %-5level %logger (%file:%line\\) - %msg%n");
	encoder.start();
	fileAppender.setEncoder(encoder);
	
	fileAppender.start();

	rootLogger.addAppender(fileAppender);
	rootLogger.setLevel(Level.toLevel(level));
	rootLogger.setAdditive(false);
}
 

import ch.qos.logback.core.rolling.RollingFileAppender; //导入方法依赖的package包/类
@Override
public void setupLogger() {
    String file = checkFile();
       LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory();
       Logger newLogger =loggerContext.getLogger("ROOT");
       //Remove all previously added appenders from this logger instance.
       newLogger.detachAndStopAllAppenders();
       //define appender
       RollingFileAppender<ILoggingEvent> appender = new RollingFileAppender<ILoggingEvent>();
       //policy
       TimeBasedRollingPolicy<ILoggingEvent> policy = new TimeBasedRollingPolicy<ILoggingEvent>();
       policy.setContext(loggerContext);
       policy.setMaxHistory(day);
       policy.setFileNamePattern(formateLogFile(file));
       policy.setParent(appender);
       policy.start();
       //encoder
       PatternLayoutEncoder encoder = new PatternLayoutEncoder();
       encoder.setContext(loggerContext);
       encoder.setPattern(formatePattern);
       encoder.start();
       //start appender
       appender.setRollingPolicy(policy);
       appender.setContext(loggerContext);
       appender.setEncoder(encoder);
       appender.setPrudent(true); //support that multiple JVMs can safely write to the same file.
       appender.start();
       newLogger.addAppender(appender);
       //setup level
       setLevel(newLogger);
       //remove the appenders that inherited 'ROOT'.
       newLogger.setAdditive(false);
}
 

import ch.qos.logback.core.rolling.RollingFileAppender; //导入方法依赖的package包/类
/**
 * Initializer logback
 *
 * @param file       log file
 * @param level      log level
 * @param maxHistory max history
 */
private void doInitializer(String file, String level, int maxHistory) {
    LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory();
    Logger rootLogger = loggerContext.getLogger(Logger.ROOT_LOGGER_NAME);
    rootLogger.detachAndStopAllAppenders();

    // appender
    RollingFileAppender<ILoggingEvent> fileAppender = new RollingFileAppender<>();
    fileAppender.setContext(loggerContext);
    fileAppender.setName("application");
    fileAppender.setFile(file);
    fileAppender.setAppend(true);

    // policy
    TimeBasedRollingPolicy<ILoggingEvent> policy = new TimeBasedRollingPolicy<>();
    policy.setContext(loggerContext);
    policy.setMaxHistory(maxHistory);
    policy.setFileNamePattern(file + ".%d{yyyy-MM-dd}");
    policy.setParent(fileAppender);
    policy.start();
    fileAppender.setRollingPolicy(policy);

    // encoder
    PatternLayoutEncoder encoder = new PatternLayoutEncoder();
    encoder.setContext(loggerContext);
    encoder.setPattern("%date [%thread] %-5level %logger (%file:%line\\) - %msg%n");
    encoder.start();
    fileAppender.setEncoder(encoder);

    fileAppender.start();

    rootLogger.addAppender(fileAppender);
    rootLogger.setLevel(Level.toLevel(level));
    rootLogger.setAdditive(false);
}
 

import ch.qos.logback.core.rolling.RollingFileAppender; //导入方法依赖的package包/类
public static Flusher createFlusher(String name, String dir, String file) {
        Preconditions.checkArgument(new File(dir).exists(), String.format("dir[%s] not exist", dir));

//        LoggerContext context = (LoggerContext) LoggerFactory.getILoggerFactory();
        LoggerContext context = new LoggerContext();
        Logger logger = context.getLogger(name);
        logger.setAdditive(false);

        RollingFileAppender rollingFileAppender = new RollingFileAppender();
        rollingFileAppender.setContext(context);
        rollingFileAppender.setName(name + "_appender");

        rollingFileAppender.setFile(dir + File.separator + file + ".dat");
        rollingFileAppender.setAppend(true);

        TimeBasedRollingPolicy rollingPolicy = new TimeBasedRollingPolicy();
        rollingPolicy.setFileNamePattern(dir + File.separator + file + ".%d{yyyy-MM-dd_HH}.dat");
        rollingPolicy.setParent(rollingFileAppender);
        rollingPolicy.setContext(context);
        rollingPolicy.start();

        PatternLayoutEncoder encoder = new PatternLayoutEncoder();
        encoder.setContext(context);
        encoder.setPattern("%msg%n");
        encoder.start();

        rollingFileAppender.setRollingPolicy(rollingPolicy);
        rollingFileAppender.setEncoder(encoder);
        rollingFileAppender.start();


        logger.addAppender(rollingFileAppender);

        return new Flusher(logger);
    }
 

import ch.qos.logback.core.rolling.RollingFileAppender; //导入方法依赖的package包/类
static LoggerContext buildLoggerContext(String stamp, String filename,
    boolean safetyMode) {
  LoggerContext loggerContext = new LoggerContext();

  RollingFileAppender<ILoggingEvent> rfa = new RollingFileAppender<ILoggingEvent>();
  PatternLayoutEncoder patternLayout = new PatternLayoutEncoder();
  patternLayout.setPattern(stamp + " %5p - %-50m%n");
  patternLayout.setContext(loggerContext);
  patternLayout.start();

  rfa.setEncoder(patternLayout);
  
  rfa.setAppend(true);
  rfa.setPrudent(safetyMode);
  rfa.setContext(loggerContext);

  TimeBasedRollingPolicy tbrp = new TimeBasedRollingPolicy();
  
  tbrp.setContext(loggerContext);
  tbrp.setFileNamePattern(filename+"-%d{"+DATE_PATTERN+"}.log");
  tbrp.setParent(rfa);
  tbrp.start();

  rfa.setRollingPolicy(tbrp);

  
  rfa.start();

  ch.qos.logback.classic.Logger root = loggerContext
      .getLogger(Logger.ROOT_LOGGER_NAME);
  root.addAppender(rfa);

  return loggerContext;
}