Java Logger类代码示例

import com.github.czyzby.kiwi.log.Logger; //导入依赖的package包/类
@Override
public void create() {
    // Changing logger factory:
    MyLogger.setLoggerFactory();

    // Preparing Autumn context:
    final ContextInitializer initializer = new ContextInitializer();

    // Manual component registration example - you can both let the Autumn find annotated classes for you or add
    // some components manually:
    final MyManualComponent manualComponent = new MyManualComponent();
    initializer.addComponent(manualComponent);

    // Registering platform-specific scanner. Starting to scan classes from Root:
    initializer.scan(Root.class, scanner);

    // Creating context:
    destroyer = initializer.initiate();

    // Getting a utility logger:
    final Logger logger = LoggerService.forClass(Core.class);

    // Testing events API (see com.github.czyzby.context.event package):
    logger.info("Posting 'myMessage'.");
    manualComponent.getMessageDispatcher().postMessage("myMessage");
    logger.info("Posting MyEvent.");
    manualComponent.getEventDispatcher().postEvent(new MyEvent("Core#create"));

    // Final note, adding input listener:
    logger.info("Autumn context is created. "
            + "Click to close the application and watch the console to see the destruction process.");
    addInputProcessor();

    // Getting utility assets injected into manualComponent by Autumn:
    batch = manualComponent.getAssets().getBatch();
    label = manualComponent.getLabel();
    label.setText(message);
}
 

import com.github.czyzby.kiwi.log.Logger; //导入依赖的package包/类
/** Changes the default Kiwi logger factory to provide {@link MyLogger} instances. After invoking this method,
 * all created loggers will not only flood the console on info logs, but also update the message displayed on
 * the main application screen. */
public static void setLoggerFactory() {
    LoggerService.simpleClassNames(true); // We don't want to flood the logs with packages!
    LoggerService.INSTANCE.setFactory(new LoggerFactory() {
        @Override
        public Logger newLogger(final LoggerService service, final Class<?> forClass) {
            return new MyLogger(service, forClass);
        }
    });
}
 

import com.github.czyzby.kiwi.log.Logger; //导入依赖的package包/类
@Override
public Logger provide(final Object target, final Member member) {
    if (target != null) {
        return getLogger(target.getClass());
    } else if (member instanceof ConstructorMember) { // Extracting component class from constructor:
        final ConstructorMember constructor = (ConstructorMember) member;
        return getLogger(constructor.getConstructor().getDeclaringClass());
    }
    return getGlobalLogger();
}
 

import com.github.czyzby.kiwi.log.Logger; //导入依赖的package包/类
@Override
public Logger newLogger(final LoggerService service, final Class<?> forClass) {
    return new DefaultLogger(service, forClass);
}
 

import com.github.czyzby.kiwi.log.Logger; //导入依赖的package包/类
@Override
public Logger newLogger(final LoggerService service, final Class<?> forClass) {
    return new AsynchronousLogger(service, forClass);
}
 

import com.github.czyzby.kiwi.log.Logger; //导入依赖的package包/类
@Override
public Class<? extends Logger> getType() {
    return Logger.class;
}
 

import com.github.czyzby.kiwi.log.Logger; //导入依赖的package包/类
/** @return {@link Logger} assigned to the current application listener implementation. Can be treated as global
 *         logger. */
public Logger getGlobalLogger() {
    return getLogger(Gdx.app.getApplicationListener().getClass());
}
 

import com.github.czyzby.kiwi.log.Logger; //导入依赖的package包/类
/** @param forClass will be included in the logs.
 * @return a {@link Logger} instance unique to the selected class. */
public Logger getLogger(final Class<?> forClass) {
    return LoggerService.forClass(forClass);
}