в большинстве зрелого кода Котлина вы найдете один из этих шаблонов ниже. Подход с использованием Делегаты Собственность использует силу Котлина для создания наименьшего кода.

Примечание: вот код java.util.Logging но та же теория применима к любой библиотеке журналов

статичные-как (общий, эквивалент вашего кода Java в вопросе)

если вы не можете доверять в производительность этого хэш-поиска внутри системы ведения журнала вы можете получить аналогичное поведение с вашим Java-кодом, используя сопутствующий объект, который может содержать экземпляр и чувствовать себя статическим для вас.

class MyClass {
    companion object {
        val LOG = Logger.getLogger(MyClass::class.java.name) 
    }

    fun foo() {
        LOG.warning("Hello from MyClass")
    }
}  

создание выход:

Дек 26, 2015 11:28: 32 AM org.stackoverflow.kotlin.test.MyClass foo INFO: привет от MyClass

подробнее о сопутствующих объектах здесь:Объектов Спутник ... Также обратите внимание, что в примере выше MyClass::class.java получает экземпляр типа Class<MyClass> для лесоруба, тогда как this.javaClass получит экземпляр типа Class<MyClass.Companion>.

на экземпляр класса (common)

но на самом деле нет причин избегать вызова и получения регистратора на уровне экземпляра. Идиоматический способ Java, который вы упомянули, устарел и основан на страхе перед производительностью, тогда как регистратор на класс уже кэшируется почти любой разумной системой регистрации на планете. Просто создайте члены удерживайте объект logger.

class MyClass {
  val LOG = Logger.getLogger(this.javaClass.name)

  fun foo() {
        LOG.warning("Hello from MyClass")
  }
} 

создание выход:

Dec 26, 2015 11:28: 44 am org.сайте StackOverflow.Котлин.тест.Класса MyClass ФОО INFO: привет от MyClass

вы можете проверить производительность как на экземпляр, так и на класс и посмотреть, есть ли реалистичная разница для большинства приложений.

Делегаты Собственность (общей, самый элегантный)

другой подход, который предлагается @Jire в другом ответе-создать делегат свойства, который затем можно использовать для равномерного выполнения логики в любом другом классе. Существует более простой способ сделать это, так как Котлин предоставляет 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"

этот код также гарантирует, что если вы используете его в компаньоны объекта что имя регистратора будет таким же, как если бы вы использовали его в самом классе. Теперь вы можете просто:

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() на обоих этих классах будет:

Dec 26, 2015 11:30: 55 am org.сайте StackOverflow.Котлин.тест.Что-то foo INFO: привет от чего-то

Дек 26, 2015 11: 30: 55 орг.сайте StackOverflow.Котлин.тест.SomethingElse фу INFO: привет от SomethingElse

Функции Расширения (редкость в этом случае из-за "загрязнения" любого пространства имен)

Котлин имеет несколько скрытых трюков, которые позволяют сделать некоторые из этого кода еще меньше. Вы можете создавать функции расширения для классов и, следовательно, предоставлять им дополнительные функции. Одно из предложений в комментариях выше заключалось в расширении 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")
    }
}

производить вывод:

Dec 26, 2015 11:29: 12 am org.сайте StackOverflow.Котлин.тест.Что-то другое фу INFO: привет от SomethingDifferent

в основном, код рассматривается как вызов расширения 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()
}

производить выход:

Dec 26, 2015 11:41: 01 am org.сайте StackOverflow.Котлин.тест.MarkedClass foo INFO: привет от 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!
    }
}

все это вместе (небольшая вспомогательная библиотека)

вот небольшая вспомогательная библиотека, чтобы сделать любой из вышеперечисленных вариантов простым в использовании. В Котлине принято расширять 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 экземпляров регистраторов, созданных в этом примере, будут производить одно и то же имя регистратора и выводить:

Dec 26, 2015 11:39: 00 am org.сайте StackOverflow.Котлин.тест.MixedBagOfTricks foo INFO: привет от MixedBagOfTricks

Примечание: на unwrapCompanionClass() метод гарантирует, что мы не генерировали регистратор имени объект а включающий класс. Это текущий рекомендуемый способ поиска класса, содержащего сопутствующий объект. Раздевание"$Companion" от имени с помощью removeSuffix() не работает, так как сопутствующим объектам могут быть заданы пользовательские имена.