在大多数成熟的Kotlin代码中，您将在下面找到这些模式之一。使用属性委托的方法利用了Kotlin的功能来生成最小的代码。
注意：这里的代码是针对的，java.util.Logging但是相同的理论适用于任何日志记录库
类似静态的（常见的，等同于问题中的Java代码）
如果您不信任日志记录系统中该哈希查找的性能，则可以通过使用一个伴侣对象来获得与Java代码类似的行为，该伴侣对象可以容纳一个实例并且对您来说像是静态的。
class MyClass {
companion object {
val LOG = Logger.getLogger(MyClass::class.java.name)
}
fun foo() {
LOG.warning("Hello from MyClass")
}
}
创建输出：
2015年12月26日上午11:28:32 org.stackoverflow.kotlin.test.MyClassfoo信息：MyClass的您好
有关随播对象的更多信息，请参见：随播对象 ...还应注意，在上面的示例中，它MyClass::class.java获取Class<MyClass>记录器的类型实例，而this.javaClass将获取type的实例Class<MyClass.Companion>。
每个类别的实例（常见）
但是，实际上没有理由避免在实例级别调用和获取记录器。您提到的惯用Java方式已经过时，并且出于对性能的担心，而该类中的每个记录器已经被地球上几乎所有合理的记录系统缓存。只需创建一个成员来保存记录器对象即可。
class MyClass {
val LOG = Logger.getLogger(this.javaClass.name)
fun foo() {
LOG.warning("Hello from MyClass")
}
}
创建输出：
2015年12月26日11:28:44 org.stackoverflow.kotlin.test.MyClass foo信息：您好，来自MyClass
您可以对每个实例和每个类的变体进行性能测试，并查看大多数应用程序是否存在实际差异。
财产代表（普通，最优雅）
@Jire在另一个答案中建议的另一种方法是创建一个属性委托，然后您可以使用它在所需的任何其他类中统一执行逻辑。由于Kotlin Lazy已经提供了委托，因此有一种更简单的方法，我们可以将其包装在函数中。这里的一个技巧是，如果我们想知道当前使用委托的类的类型，可以将其设为任何类的扩展函数：
fun <R : Any> R.logger(): Lazy<Logger> {
return lazy { Logger.getLogger(unwrapCompanionClass(this.javaClass).name) }
}
// see code for unwrapCompanionClass() below in "Putting it all Together section"
此代码还确保如果在Companion Object中使用它，则记录器名称将与在类本身上使用的记录器名称相同。现在您可以简单地：
class Something {
val LOG by logger()
fun foo() {
LOG.info("Hello from Something")
}
}
每个类实例，或者如果您希望每个类一个实例更静态：
class SomethingElse {
companion object {
val LOG by logger()
}
fun foo() {
LOG.info("Hello from SomethingElse")
}
}
通过调用foo()这两个类的输出将是：
2015年12月26日，上午11:30:55 org.stackoverflow.kotlin.test.foo信息：您好！
2015年12月26日，上午11:30:55 org.stackoverflow.kotlin.test.SomethingElse foo信息：SomethingElse的问好
扩展功能（在这种情况下不常见，因为任何名称空间的“污染”）
Kotlin有一些隐藏的技巧，可以使您使这些代码变得更小。您可以在类上创建扩展函数，从而为它们提供其他功能。上面评论中的一个建议是Any使用记录器功能进行扩展。每当有人在任何类的IDE中使用代码完成功能时，这都会产生噪音。但是扩展Any或其他一些标记接口有一个秘密好处：您可以暗示您正在扩展自己的类，因此可以检测您所在的类。?？为了减少混乱，下面是代码：
// extend any class with the ability to get a logger
fun <T: Any> T.logger(): Logger {
return Logger.getLogger(unwrapCompanionClass(this.javaClass).name)
}
现在在一个类（或同伴对象）中，我可以在自己的类中简单地调用此扩展名：
class SomethingDifferent {
val LOG = logger()
fun foo() {
LOG.info("Hello from SomethingDifferent")
}
}
产生输出：
2015年12月26日，上午11:29:12 org.stackoverflow.kotlin.test.SomethingDifferent foo INFO：Hello from SomethingDifferent
基本上，该代码被视为对extension的调用Something.logger()。问题在于，在其他类上创建“污染”也可能是以下情况：
val LOG1 = "".logger()
val LOG2 = Date().logger()
val LOG3 = 123.logger()
标记接口上的扩展功能（不确定通用性，但是“特征”的通用模型）
为了使扩展程序的使用更干净并减少“污染”，可以使用标记器接口来扩展：
interface Loggable {}
fun Loggable.logger(): Logger {
return Logger.getLogger(unwrapCompanionClass(this.javaClass).name)
}
甚至使用默认实现使方法成为接口的一部分：
interface Loggable {
public fun logger(): Logger {
return Logger.getLogger(unwrapCompanionClass(this.javaClass).name)
}
}
并在您的课程中使用以下任一变体：
class MarkedClass: Loggable {
val LOG = logger()
}
产生输出：
2015年12月26日，上午11:41:01 org.stackoverflow.kotlin.test.MarkedClass foo信息：MarkedClass您好
如果您想强制创建一个统一的字段来保存记录器，那么在使用此接口时，您可以轻松地要求实现者拥有一个字段，例如LOG：
interface Loggable {
val LOG: Logger // abstract required field
public fun logger(): Logger {
return Logger.getLogger(unwrapCompanionClass(this.javaClass).name)
}
}
现在，接口的实现者必须如下所示：
class MarkedClass: Loggable {
override val LOG: Logger = logger()
}
当然，抽象基类可以做到这一点，可以同时选择接口和实现该接口的抽象类，从而实现灵活性和统一性：
abstract class WithLogging: Loggable {
override val LOG: Logger = logger()
}
// using the logging from the base class
class MyClass1: WithLogging() {
// ... already has logging!
}
// providing own logging compatible with marker interface
class MyClass2: ImportantBaseClass(), Loggable {
// ... has logging that we can understand, but doesn't change my hierarchy
override val LOG: Logger = logger()
}
// providing logging from the base class via a companion object so our class hierarchy is not affected
class MyClass3: ImportantBaseClass() {
companion object : WithLogging() {
// we have the LOG property now!
}
}
放在一起（一个小的帮助程序库）
这是一个小的帮助程序库，使上面的任何选项都易于使用。在Kotlin中，通常会扩展API以使其更符合您的喜好。扩展功能或顶级功能。以下是为您提供有关如何创建记录器的选项的混合以及显示所有变化的示例：
// Return logger for Java class, if companion object fix the name
fun <T: Any> logger(forClass: Class<T>): Logger {
return Logger.getLogger(unwrapCompanionClass(forClass).name)
}
// unwrap companion class to enclosing class given a Java Class
fun <T : Any> unwrapCompanionClass(ofClass: Class<T>): Class<*> {
return ofClass.enclosingClass?.takeIf {
ofClass.enclosingClass.kotlin.companionObject?.java == ofClass
} ?: ofClass
}
// unwrap companion class to enclosing class given a Kotlin Class
fun <T: Any> unwrapCompanionClass(ofClass: KClass<T>): KClass<*> {
return unwrapCompanionClass(ofClass.java).kotlin
}
// Return logger for Kotlin class
fun <T: Any> logger(forClass: KClass<T>): Logger {
return logger(forClass.java)
}
// return logger from extended class (or the enclosing class)
fun <T: Any> T.logger(): Logger {
return logger(this.javaClass)
}
// return a lazy logger property delegate for enclosing class
fun <R : Any> R.lazyLogger(): Lazy<Logger> {
return lazy { logger(this.javaClass) }
}
// return a logger property delegate for enclosing class
fun <R : Any> R.injectLogger(): Lazy<Logger> {
return lazyOf(logger(this.javaClass))
}
// marker interface and related extension (remove extension for Any.logger() in favour of this)
interface Loggable {}
fun Loggable.logger(): Logger = logger(this.javaClass)
// abstract base class to provide logging, intended for companion objects more than classes but works for either
abstract class WithLogging: Loggable {
val LOG = logger()
}
选择您想要保留的任何一个，以下是所有正在使用的选项：
class MixedBagOfTricks {
companion object {
val LOG1 by lazyLogger() // lazy delegate, 1 instance per class
val LOG2 by injectLogger() // immediate, 1 instance per class
val LOG3 = logger() // immediate, 1 instance per class
val LOG4 = logger(this.javaClass) // immediate, 1 instance per class
}
val LOG5 by lazyLogger() // lazy delegate, 1 per instance of class
val LOG6 by injectLogger() // immediate, 1 per instance of class
val LOG7 = logger() // immediate, 1 per instance of class
val LOG8 = logger(this.javaClass) // immediate, 1 instance per class
}
val LOG9 = logger(MixedBagOfTricks::class) // top level variable in package
// or alternative for marker interface in class
class MixedBagOfTricks : Loggable {
val LOG10 = logger()
}
// or alternative for marker interface in companion object of class
class MixedBagOfTricks {
companion object : Loggable {
val LOG11 = logger()
}
}
// or alternative for abstract base class for companion object of class
class MixedBagOfTricks {
companion object: WithLogging() {} // instance 12
fun foo() {
LOG.info("Hello from MixedBagOfTricks")
}
}
// or alternative for abstract base class for our actual class
class MixedBagOfTricks : WithLogging() { // instance 13
fun foo() {
LOG.info("Hello from MixedBagOfTricks")
}
}
在此示例中创建的所有13个记录器实例将产生相同的记录器名称，并输出：
2015年12月26日上午11:39:00 org.stackoverflow.kotlin.test.MixedBagOfTricks foo信息：您好，来自MixedBagOfTricks
注意： 该unwrapCompanionClass()方法确保我们不会生成以伴随对象命名的记录器，而是生成封闭的类。这是当前推荐的查找包含伴随对象的类的方法。从名称中删除“ $ Companion ” removeSuffix()不起作用，因为可以为伴随对象指定自定义名称。