public static Logger getLogger() {
final Throwable t = new Throwable();
final StackTraceElement methodCaller = t.getStackTrace()[1];
final Logger logger = Logger.getLogger(methodCaller.getClassName());
logger.setLevel(ResourceManager.LOGLEVEL);
return logger;
}
このメソッドは、ログを記録しているクラスを認識しているロガーを返します。それに反対するアイデアはありますか？
何年も後: https://github.com/yanchenko/droidparts/blob/master/droidparts/src/org/droidparts/util/L.java
スタックトレースの作成は、比較的遅い操作です。呼び出し元は、それがどのクラスとメソッドにあるかをすでに知っているため、労力が無駄になります。ソリューションのこの側面は非効率的です。
静的クラス情報を使用する場合でも、メッセージごとにロガーを再度フェッチしないでください。Log4jの作者から、 CekiGülcü：
ラッパークラスで最も一般的なエラーは、各ログリクエストでのLogger.getLoggerメソッドの呼び出しです。これは、アプリケーションのパフォーマンスに大きな打撃を与えることが保証されています。本当に！！！
これは、クラスの初期化中にロガーを取得するための従来の効率的なイディオムです。
private static final Logger log = Logger.getLogger(MyClass.class);
これにより、階層内のタイプごとに個別のロガーが提供されることに注意してください。インスタンスを呼び出すメソッドを思いついた場合getClass()、サブタイプのロガーの下に表示される基本タイプによってログに記録されたメッセージが表示されます。場合によってはこれが望ましいこともありますが、混乱を招きます（とにかく、継承よりもコンポジションを好む傾向があります）。
明らかに、動的型viaを使用するには、getClass()静的型情報を使用する推奨イディオムのようにクラスごとに1回ではなく、インスタンスごとに少なくとも1回ロガーを取得する必要があります。
すべてのクラスに多くのオーバーヘッドが追加されると思います。すべてのクラスは「検索」する必要があります。それを行うには、新しい Throwable オブジェクトを作成します... これらの throwable は無料では提供されません。
実際、LogUtils クラスには非常によく似たものがあります。はい、ちょっと厄介ですが、私に関する限り、利点はそれだけの価値があります. ただし、繰り返し呼び出されることによるオーバーヘッドがないことを確認したかったので、(ややハッキリと) 静的初期化子コンテキストからのみ呼び出すことができるようにします。
private static final Logger LOG = LogUtils.loggerForThisClass();
通常のメソッドから呼び出された場合、またはインスタンス初期化子から呼び出された場合 (つまり、上記の「静的」が省略されている場合) は、パフォーマンスのオーバーヘッドのリスクを軽減するために失敗します。メソッドは次のとおりです。
public static Logger loggerForThisClass() {
// We use the third stack element; second is this method, first is .getStackTrace()
StackTraceElement myCaller = Thread.currentThread().getStackTrace()[2];
Assert.equal("<clinit>", myCaller.getMethodName());
return Logger.getLogger(myCaller.getClassName());
}
これにはどのような利点があるのかと尋ねる人は誰でも
= Logger.getLogger(MyClass.class);
他の場所からその行をコピーして貼り付け、クラス名を変更するのを忘れて、そのすべてのものを別のロガーに送信するクラスを処理することを忘れる誰かに対処する必要はおそらくないでしょう。
これを使用するすべてのクラスについて、とにかく Logger を検索する必要があるため、これらのクラスで静的 Logger を使用することもできます。
private static final Logger logger = Logger.getLogger(MyClass.class.getName());
次に、ログ メッセージを実行する必要があるときに、そのロガーを参照するだけです。あなたのメソッドは、静的な Log4J Logger が既に行っているのと同じことを行うのに、なぜ車輪を再発明するのでしょうか?
それから最高のものは2つのミックスです。
public class LoggerUtil {
public static Level level=Level.ALL;
public static java.util.logging.Logger getLogger() {
final Throwable t = new Throwable();
final StackTraceElement methodCaller = t.getStackTrace()[1];
final java.util.logging.Logger logger = java.util.logging.Logger.getLogger(methodCaller.getClassName());
logger.setLevel(level);
return logger;
}
}
そして、すべてのクラスで：
private static final Logger LOG = LoggerUtil.getLogger();
コードで：
LOG.fine("debug that !...");
すべてのクラスでオーバーヘッドなしでコピー＆ペーストできる静的ロガーを取得します...
アラー
このサイトの他のすべてのフィードバックを読んで、Log4j で使用するために以下を作成しました。
package com.edsdev.testapp.util;
import java.util.concurrent.ConcurrentHashMap;
import org.apache.log4j.Level;
import org.apache.log4j.Priority;
public class Logger extends SecurityManager {
private static ConcurrentHashMap<String, org.apache.log4j.Logger> loggerMap = new ConcurrentHashMap<String, org.apache.log4j.Logger>();
public static org.apache.log4j.Logger getLog() {
String className = new Logger().getClassName();
if (!loggerMap.containsKey(className)) {
loggerMap.put(className, org.apache.log4j.Logger.getLogger(className));
}
return loggerMap.get(className);
}
public String getClassName() {
return getClassContext()[3].getName();
}
public static void trace(Object message) {
getLog().trace(message);
}
public static void trace(Object message, Throwable t) {
getLog().trace(message, t);
}
public static boolean isTraceEnabled() {
return getLog().isTraceEnabled();
}
public static void debug(Object message) {
getLog().debug(message);
}
public static void debug(Object message, Throwable t) {
getLog().debug(message, t);
}
public static void error(Object message) {
getLog().error(message);
}
public static void error(Object message, Throwable t) {
getLog().error(message, t);
}
public static void fatal(Object message) {
getLog().fatal(message);
}
public static void fatal(Object message, Throwable t) {
getLog().fatal(message, t);
}
public static void info(Object message) {
getLog().info(message);
}
public static void info(Object message, Throwable t) {
getLog().info(message, t);
}
public static boolean isDebugEnabled() {
return getLog().isDebugEnabled();
}
public static boolean isEnabledFor(Priority level) {
return getLog().isEnabledFor(level);
}
public static boolean isInfoEnabled() {
return getLog().isInfoEnabled();
}
public static void setLevel(Level level) {
getLog().setLevel(level);
}
public static void warn(Object message) {
getLog().warn(message);
}
public static void warn(Object message, Throwable t) {
getLog().warn(message, t);
}
}
今あなたのコードで必要なのは
Logger.debug("This is a test");
また
Logger.error("Look what happened Ma!", e);
log4j メソッドをさらに公開する必要がある場合は、上記の Logger クラスから委任してください。
クラスごとに（静的な）ロガーを作成することを好みます（明示的なクラス名を使用）。私はロガーをそのまま使用します。
もちろん、適切なパターン レイアウトで Log4J を使用することもできます。
たとえば、クラス名が「org.apache.xyz.SomeClass」の場合、パターン %C{1} は「SomeClass」を出力します。
http://logging.apache.org/log4j/1.2/apidocs/org/apache/log4j/PatternLayout.html
新しい Throwable オブジェクトを作成する必要はありません。あなたはただ電話することができます
Thread.currentThread().getStackTrace()[1]
ほとんどのクラスの冒頭に次の行があります。
private static final Logger log =
LoggerFactory.getLogger(new Throwable().getStackTrace()[0].getClassName());
はい、そのクラスのオブジェクトが初めて作成されるときにオーバーヘッドが発生しますが、私は主に webapps で作業しているため、20 秒の起動にマイクロ秒を追加することは実際には問題ではありません。
なぜだめですか？
public static Logger getLogger(Object o) {
final Logger logger = Logger.getLogger(o.getClass());
logger.setLevel(ResourceManager.LOGLEVEL);
return logger;
}
そして、クラスにロガーが必要な場合：
getLogger(this).debug("Some log message")
ロガーを静的にする必要が本当にない限り、使用できます
final Logger logger = LoggerFactory.getLogger(getClass());
私の静的 getLogger() 実装を参照してください (JDK 7 でデフォルトの Java Logger doit と同じ "sun.*" マジックを使用)
醜いログプロパティのない静的ロギングメソッド（静的インポートを使用）に注意してください...
import static my.pakg.Logger.*;
そして、それらの速度はネイティブ Java 実装と同等です (100 万件のログ トレースで確認済み)。
package my.pkg;
import java.text.MessageFormat;
import java.util.Arrays;
import java.util.IllegalFormatException;
import java.util.logging.Level;
import java.util.logging.LogRecord;
import sun.misc.JavaLangAccess;
import sun.misc.SharedSecrets;
public class Logger {
static final int CLASS_NAME = 0;
static final int METHOD_NAME = 1;
// Private method to infer the caller's class and method names
protected static String[] getClassName() {
JavaLangAccess access = SharedSecrets.getJavaLangAccess();
Throwable throwable = new Throwable();
int depth = access.getStackTraceDepth(throwable);
boolean lookingForLogger = true;
for (int i = 0; i < depth; i++) {
// Calling getStackTraceElement directly prevents the VM
// from paying the cost of building the entire stack frame.
StackTraceElement frame = access.getStackTraceElement(throwable, i);
String cname = frame.getClassName();
boolean isLoggerImpl = isLoggerImplFrame(cname);
if (lookingForLogger) {
// Skip all frames until we have found the first logger frame.
if (isLoggerImpl) {
lookingForLogger = false;
}
} else {
if (!isLoggerImpl) {
// skip reflection call
if (!cname.startsWith("java.lang.reflect.") && !cname.startsWith("sun.reflect.")) {
// We've found the relevant frame.
return new String[] {cname, frame.getMethodName()};
}
}
}
}
return new String[] {};
// We haven't found a suitable frame, so just punt. This is
// OK as we are only committed to making a "best effort" here.
}
protected static String[] getClassNameJDK5() {
// Get the stack trace.
StackTraceElement stack[] = (new Throwable()).getStackTrace();
// First, search back to a method in the Logger class.
int ix = 0;
while (ix < stack.length) {
StackTraceElement frame = stack[ix];
String cname = frame.getClassName();
if (isLoggerImplFrame(cname)) {
break;
}
ix++;
}
// Now search for the first frame before the "Logger" class.
while (ix < stack.length) {
StackTraceElement frame = stack[ix];
String cname = frame.getClassName();
if (isLoggerImplFrame(cname)) {
// We've found the relevant frame.
return new String[] {cname, frame.getMethodName()};
}
ix++;
}
return new String[] {};
// We haven't found a suitable frame, so just punt. This is
// OK as we are only committed to making a "best effort" here.
}
private static boolean isLoggerImplFrame(String cname) {
// the log record could be created for a platform logger
return (
cname.equals("my.package.Logger") ||
cname.equals("java.util.logging.Logger") ||
cname.startsWith("java.util.logging.LoggingProxyImpl") ||
cname.startsWith("sun.util.logging."));
}
protected static java.util.logging.Logger getLogger(String name) {
return java.util.logging.Logger.getLogger(name);
}
protected static boolean log(Level level, String msg, Object... args) {
return log(level, null, msg, args);
}
protected static boolean log(Level level, Throwable thrown, String msg, Object... args) {
String[] values = getClassName();
java.util.logging.Logger log = getLogger(values[CLASS_NAME]);
if (level != null && log.isLoggable(level)) {
if (msg != null) {
log.log(getRecord(level, thrown, values[CLASS_NAME], values[METHOD_NAME], msg, args));
}
return true;
}
return false;
}
protected static LogRecord getRecord(Level level, Throwable thrown, String className, String methodName, String msg, Object... args) {
LogRecord record = new LogRecord(level, format(msg, args));
record.setSourceClassName(className);
record.setSourceMethodName(methodName);
if (thrown != null) {
record.setThrown(thrown);
}
return record;
}
private static String format(String msg, Object... args) {
if (msg == null || args == null || args.length == 0) {
return msg;
} else if (msg.indexOf('%') >= 0) {
try {
return String.format(msg, args);
} catch (IllegalFormatException esc) {
// none
}
} else if (msg.indexOf('{') >= 0) {
try {
return MessageFormat.format(msg, args);
} catch (IllegalArgumentException exc) {
// none
}
}
if (args.length == 1) {
Object param = args[0];
if (param != null && param.getClass().isArray()) {
return msg + Arrays.toString((Object[]) param);
} else if (param instanceof Throwable){
return msg;
} else {
return msg + param;
}
} else {
return msg + Arrays.toString(args);
}
}
public static void severe(String msg, Object... args) {
log(Level.SEVERE, msg, args);
}
public static void warning(String msg, Object... args) {
log(Level.WARNING, msg, args);
}
public static void info(Throwable thrown, String format, Object... args) {
log(Level.INFO, thrown, format, args);
}
public static void warning(Throwable thrown, String format, Object... args) {
log(Level.WARNING, thrown, format, args);
}
public static void warning(Throwable thrown) {
log(Level.WARNING, thrown, thrown.getMessage());
}
public static void severe(Throwable thrown, String format, Object... args) {
log(Level.SEVERE, thrown, format, args);
}
public static void severe(Throwable thrown) {
log(Level.SEVERE, thrown, thrown.getMessage());
}
public static void info(String msg, Object... args) {
log(Level.INFO, msg, args);
}
public static void fine(String msg, Object... args) {
log(Level.FINE, msg, args);
}
public static void finer(String msg, Object... args) {
log(Level.FINER, msg, args);
}
public static void finest(String msg, Object... args) {
log(Level.FINEST, msg, args);
}
public static boolean isLoggableFinest() {
return isLoggable(Level.FINEST);
}
public static boolean isLoggableFiner() {
return isLoggable(Level.FINER);
}
public static boolean isLoggableFine() {
return isLoggable(Level.FINE);
}
public static boolean isLoggableInfo() {
return isLoggable(Level.INFO);
}
public static boolean isLoggableWarning() {
return isLoggable(Level.WARNING);
}
public static boolean isLoggableSevere() {
return isLoggable(Level.SEVERE);
}
private static boolean isLoggable(Level level) {
return log(level, null);
}
}
このメカニズムは、実行時に多くの余分な労力を費やします。
Eclipse を IDE として使用する場合は、Log4eの使用を検討してください。この便利なプラグインは、お気に入りのロギング フレームワークを使用してロガー宣言を生成します。コーディング時の労力はわずかに増えますが、実行時の作業ははるかに少なくなります。
jcabi-log のLoggerクラスを見てください。静的メソッドのコレクションを提供して、まさにあなたが探していることを行います。ロガーをクラスに埋め込む必要はもうありません。
import com.jcabi.log.Logger;
class Foo {
public void bar() {
Logger.info(this, "doing something...");
}
}
Loggerすべてのログを SLF4J に送信し、実行時に他のログ機能にリダイレクトできます。