Java 类org.slf4j.ext.XLogger.Level 实例源码

@SuppressWarnings("unchecked")
private <C extends IRequestablePage> C tryPageFactoryCache(final C newPage) {
    if (newPage instanceof Page) {
        final Page cNewPage = (Page) newPage;
        final Object modelObject = cNewPage.getDefaultModelObject();
        if (modelObject != null) {
            try {
                final Page page = PageFactory.get().getRegisteredPage(modelObject);
                if (page != null) {
                    return (C) page;
                }
            } catch (final Throwable t) {
                LOG.catching(Level.WARN,
                        new RuntimeException(
                                "Not a generated model page or no suitable constructor available, falling back to default created page.",
                                t));
                return newPage;
            }
        }
    }
    return newPage;
}

@Override
public UserDetails loadUserByUsername(final String username) throws UsernameNotFoundException {

    logger.info("Load username {} details", username);
    final User user = userDao.findByUsername(username);
    if (null == user) {
        final UsernameNotFoundException usernameNotFoundException = new UsernameNotFoundException(username);
        logger.throwing(Level.TRACE, usernameNotFoundException);
        throw usernameNotFoundException;
    }

    return new org.springframework.security.core.userdetails.User(username, user.getPassword(), true, true, true, true, toAuthorities(user.getRoles()));
}

@When("I log one message $message for $times times at level $level")
public void whenILogAMessageAtLevel(@Named("message") String message
        , @Named("times") int times
        , @Named("level") Level level) {
    switch (level) {
    case TRACE:
        for (int i=0; i<times; i++) {
            logger.trace(message);
        }
        break;
    case DEBUG:
        for (int i=0; i<times; i++) {
            logger.debug(message);
        }
        break;
    case INFO:
        for (int i=0; i<times; i++) {
            logger.info(message);
        }
        break;
    case WARN:
        for (int i=0; i<times; i++) {
            logger.warn(message);
        }
        break;
    case ERROR:
        for (int i=0; i<times; i++) {
            logger.error(message);
        }
        break;
    default:
        break;
    }
}

@When("I log $several different messages made from $message for $times times at level $level")
public void whenILogSeveralMessageAtLevel(@Named("message") String message
        , @Named("times") int times
        , @Named("level") Level level
        , @Named("several") int several) {
    for (int i=0; i < times; i++) {
        for (int j=0; j < several; j++) {
            whenILogAMessageAtLevel(message + j, 1, level);
        }
    }
}

@When(value="I log a formatted message $message with one parameter $parameter for $times times at level $level")
// make when unambiguous to avoid brittle use of , priority = 1)
public void whenILogMessageWithOneParameter(@Named("message") String message,
        @Named("parameter") String parameter,
        @Named("times") int times,
        @Named("level") Level level
        ) {
    switch (level) {
    case TRACE:
        for (int i=0; i<times; i++) {
            logger.trace(message, parameter);
        }
        break;
    case DEBUG:
        for (int i=0; i<times; i++) {
            logger.debug(message, parameter);
        }
        break;
    case INFO:
        for (int i=0; i<times; i++) {
            logger.info(message, parameter);
        }
        break;
    case WARN:
        for (int i=0; i<times; i++) {
            logger.warn(message, parameter);
        }
        break;
    case ERROR:
        for (int i=0; i<times; i++) {
            logger.error(message, parameter);
        }
        break;
    default:
        break;
    }
}

@When(value="I log a formatted message $message with two parameters $parameterOne and $parameterTwo for $times times at level $level")
// make when unambiguous to avoid brittle use of , priority = 1)
public void whenILogMessageWithTwoParameters(@Named("message") String message,
        @Named("parameterOne") String parameterOne,
        @Named("parameterTwo") String parameterTwo,
        @Named("times") int times,
        @Named("level") Level level
        ) {
    switch (level) {
    case TRACE:
        for (int i=0; i<times; i++) {
            logger.trace(message, parameterOne, parameterTwo);
        }
        break;
    case DEBUG:
        for (int i=0; i<times; i++) {
            logger.debug(message, parameterOne, parameterTwo);
        }
        break;
    case INFO:
        for (int i=0; i<times; i++) {
            logger.info(message, parameterOne, parameterTwo);
        }
        break;
    case WARN:
        for (int i=0; i<times; i++) {
            logger.warn(message, parameterOne, parameterTwo);
        }
        break;
    case ERROR:
        for (int i=0; i<times; i++) {
            logger.error(message, parameterOne, parameterTwo);
        }
        break;
    default:
        break;
    }
}

@When(value="I log a formatted message with three parameters for $message and $parameterOne and $parameterTwo and $parameterThree for $times times at level $level")
// make when unambiguous to avoid brittle use of , priority = 1)
public void whenILogMessageWithThreeParameters(@Named("message") String message,
        @Named("parameterOne") String parameterOne,
        @Named("parameterTwo") String parameterTwo,
        @Named("parameterThree") String parameterThree,
        @Named("times") int times,
        @Named("level") Level level
        ) {
    switch (level) {
    case TRACE:
        for (int i=0; i<times; i++) {
            logger.trace(message, new Object[] {parameterOne, parameterTwo, parameterThree});
        }
        break;
    case DEBUG:
        for (int i=0; i<times; i++) {
            logger.debug(message, new Object[] {parameterOne, parameterTwo, parameterThree});
        }
        break;
    case INFO:
        for (int i=0; i<times; i++) {
            logger.info(message, new Object[] {parameterOne, parameterTwo, parameterThree});
        }
        break;
    case WARN:
        for (int i=0; i<times; i++) {
            logger.warn(message, new Object[] {parameterOne, parameterTwo, parameterThree});
        }
        break;
    case ERROR:
        for (int i=0; i<times; i++) {
            logger.error(message, new Object[] {parameterOne, parameterTwo, parameterThree});
        }
        break;
    default:
        break;
    }
}

@When(value="I log a formatted message with a throwable for $message for $times times at level $level")
public void whenILogMessageWithAThrowable(@Named("message") String message,
        @Named("times") int times,
        @Named("level") Level level
        ) {
    switch (level) {
    case TRACE:
        for (int i=0; i<times; i++) {
            logger.trace(message, new Throwable());
        }
        break;
    case DEBUG:
        for (int i=0; i<times; i++) {
            logger.debug(message, new Throwable());
        }
        break;
    case INFO:
        for (int i=0; i<times; i++) {
            logger.info(message, new Throwable());
        }
        break;
    case WARN:
        for (int i=0; i<times; i++) {
            logger.warn(message, new Throwable());
        }
        break;
    case ERROR:
        for (int i=0; i<times; i++) {
            logger.error(message, new Throwable());
        }
        break;
    default:
        break;
    }
}

public static void logSqlException(final Throwable t) {
    LOG.catching(Level.WARN, t);
}