Получение имени класса из статического метода в Java

Как можно получить имя класса из статического метода в этом классе. Например

public class MyClass {
    public static String getClassName() {
        String name = ????; // what goes here so the string "MyClass" is returned
        return name;
    }
}

Чтобы поместить это в контекст, я на самом деле хочу вернуть имя класса как часть сообщения в исключении.

Чтобы правильно поддерживать рефакторинг (переименовать класс), вы должны использовать либо:

 MyClass.class.getName(); // full name with package

или (спасибо @James Van Huis ):

 MyClass.class.getSimpleName(); // class name and no more

Делайте то, что говорит инструментарий. Не делайте ничего подобного

return new Object() { }.getClass().getEnclosingClass();

В Java 7+ вы можете сделать это в статическом методе / полях:

MethodHandles.lookup().lookupClass()

Итак, у нас есть ситуация, когда нам нужно статически получить объект класса или полное / простое имя класса без явного использования MyClass.classсинтаксиса.

В некоторых случаях это может быть очень удобно, например, для Котлин функции верхнего уровня (в этом случае kotlin создает статический класс Java, недоступный из кода kotlin).

У нас есть несколько вариантов получения этой информации:

1. new Object(){}.getClass().getEnclosingClass();
   отметил Том Хотин - tackline

2. getClassContext()[0].getName();от SecurityManager
   отмеченного Кристоффером

3. new Throwable().getStackTrace()[0].getClassName();
   по подсчетам людвиг

4. Thread.currentThread().getStackTrace()[1].getClassName();
   из Кекси

5. и, наконец, круто
   MethodHandles.lookup().lookupClass();
   от Рейна

Я подготовил JMH Эталоном для всех вариантов и результатов являются:

# Run complete. Total time: 00:04:18

Benchmark                                                      Mode  Cnt      Score     Error  Units
StaticClassLookup.MethodHandles_lookup_lookupClass             avgt   30      3.630 ±   0.024  ns/op
StaticClassLookup.AnonymousObject_getClass_enclosingClass      avgt   30    282.486 ±   1.980  ns/op
StaticClassLookup.SecurityManager_classContext_1               avgt   30    680.385 ±  21.665  ns/op
StaticClassLookup.Thread_currentThread_stackTrace_1_className  avgt   30  11179.460 ± 286.293  ns/op
StaticClassLookup.Throwable_stackTrace_0_className             avgt   30  10221.209 ± 176.847  ns/op

Выводы

1. Лучший вариант для использования , довольно чистый и чудовищно быстрый.
   Доступно только с Java 7 и Android API 26!

 MethodHandles.lookup().lookupClass();

2. Если вам нужна эта функциональность для Android или Java 6, вы можете использовать второй лучший вариант. Это тоже довольно быстро, но создает анонимный класс в каждом месте использования :(

 new Object(){}.getClass().getEnclosingClass();

3. Если вам это нужно во многих местах и ​​вы не хотите, чтобы ваш байт-код раздулся из-за множества анонимных классов - SecurityManagerэто ваш друг (третий лучший вариант).

   Но вы не можете просто позвонить getClassContext()- он защищен в SecurityManagerклассе. Вам понадобится некоторый вспомогательный класс, подобный этому:

 // Helper class
 public final class CallerClassGetter extends SecurityManager
 {
    private static final CallerClassGetter INSTANCE = new CallerClassGetter();
    private CallerClassGetter() {}

    public static Class<?> getCallerClass() {
        return INSTANCE.getClassContext()[1];
    }
 }

 // Usage example:
 class FooBar
 {
    static final Logger LOGGER = LoggerFactory.getLogger(CallerClassGetter.getCallerClass())
 }

4. Вам, вероятно, никогда не нужно использовать последние два варианта, основанные на getStackTrace()исключении from или Thread.currentThread(). Очень неэффективно и может возвращать только имя класса как, а Stringне как Class<*>экземпляр.

PS

Если вы хотите создать экземпляр logger для статических утилит kotlin (как я :), вы можете использовать этот помощник:

import org.slf4j.Logger
import org.slf4j.LoggerFactory

// Should be inlined to get an actual class instead of the one where this helper declared
// Will work only since Java 7 and Android API 26!
@Suppress("NOTHING_TO_INLINE")
inline fun loggerFactoryStatic(): Logger
    = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass())

Пример использования:

private val LOGGER = loggerFactoryStatic()

/**
 * Returns a pseudo-random, uniformly distributed value between the
 * given least value (inclusive) and bound (exclusive).
 *
 * @param min the least value returned
 * @param max the upper bound (exclusive)
 *
 * @return the next value
 * @throws IllegalArgumentException if least greater than or equal to bound
 * @see java.util.concurrent.ThreadLocalRandom.nextDouble(double, double)
 */
fun Random.nextDouble(min: Double = .0, max: Double = 1.0): Double {
    if (min >= max) {
        if (min == max) return max
        LOGGER.warn("nextDouble: min $min > max $max")
        return min
    }
    return nextDouble() * (max - min) + min
}

Эта инструкция отлично работает:

Thread.currentThread().getStackTrace()[1].getClassName();

Вы можете сделать что-то действительно приятное, используя JNI, например:

MyObject.java:

public class MyObject
{
    static
    {
        System.loadLibrary( "classname" );
    }

    public static native String getClassName();

    public static void main( String[] args )
    {
        System.out.println( getClassName() );
    }
}

затем:

javac MyObject.java
javah -jni MyObject

затем:

MyObject.c:

#include "MyObject.h"

JNIEXPORT jstring JNICALL Java_MyObject_getClassName( JNIEnv *env, jclass cls )
{
    jclass javaLangClass = (*env)->FindClass( env, "java/lang/Class" );
    jmethodID getName = (*env)->GetMethodID( env, javaLangClass, "getName",
        "()Ljava/lang/String;" );
    return (*env)->CallObjectMethod( env, cls, getName );
}

Затем скомпилируйте C в общую библиотеку с именем libclassname.soи запустите Java!

* смешок

Я использую это, чтобы инициировать Log4j Logger в верхней части моих классов (или аннотировать).

PRO: Throwable уже загружен, и вы можете сэкономить ресурсы, не используя «IO heavy» SecurityManager.

CON: Некоторые вопросы относительно того, будет ли это работать для всех JVM.

// Log4j . Logger --- Get class name in static context by creating an anonymous Throwable and 
// getting the top of its stack-trace. 
// NOTE you must use: getClassName() because getClass() just returns StackTraceElement.class 
static final Logger logger = Logger.getLogger(new Throwable() .getStackTrace()[0].getClassName()); 

Злоупотребление SecurityManager

System.getSecurityManager().getClassContext()[0].getName();

Или, если не установлен, используйте внутренний класс, который расширяет его (пример ниже постыдно скопирован из HowTo Real ):

public static class CurrentClassGetter extends SecurityManager {
    public String getClassName() {
        return getClassContext()[1].getName(); 
    }
}

Если вам нужно полное имя пакета с ним, позвоните:

String name = MyClass.class.getCanonicalName();

Если вы хотите только последний элемент, позвоните:

String name = MyClass.class.getSimpleName();

Дословное использование класса вызывающего, как на MyClass.class.getName()самом деле, делает свою работу, но склонен к ошибкам копирования / вставки, если вы распространяете этот код среди многочисленных классов / подклассов, где вам нужно это имя класса.

И рецепт Тома Хоутина на самом деле неплохой, нужно просто правильно его приготовить :)

Если у вас есть базовый класс со статическим методом, который можно вызывать из подклассов, и этот статический метод должен знать фактический класс вызывающего, это может быть достигнуто следующим образом:

class BaseClass {
  static sharedStaticMethod (String callerClassName, Object... otherArgs) {
    useCallerClassNameAsYouWish (callerClassName);
    // and direct use of 'new Object() { }.getClass().getEnclosingClass().getName()'
    // instead of 'callerClassName' is not going to help here,
    // as it returns "BaseClass"
  }
}

class SubClass1 extends BaseClass {
  static someSubclassStaticMethod () {
    // this call of the shared method is prone to copy/paste errors
    sharedStaticMethod (SubClass1.class.getName(),
                        other_arguments);
    // and this call is safe to copy/paste
    sharedStaticMethod (new Object() { }.getClass().getEnclosingClass().getName(),
                        other_arguments);
  }
}

Безопасное для рефакторинга, вырезанное и вставленное решение, которое позволяет избежать определения специальных классов ниже.

Напишите статический метод, который восстанавливает имя класса, стараясь включить имя класса в имя метода:

private static String getMyClassName(){
  return MyClass.class.getName();
}

затем вспомните это в вашем статическом методе:

public static void myMethod(){
  Tracer.debug(getMyClassName(), "message");
}

Безопасность рефакторинга обеспечивается за счет исключения использования строк, безопасность «вырезать и вставить» предоставляется, потому что если вы вырезаете и вставляете метод вызывающей стороны, вы не найдете getMyClassName () в целевом классе «MyClass2», поэтому вам придется переопределить и обновить его.

Поскольку вопрос Что-то вроде `this.class` вместо` ClassName.class`? помечен как дубликат для этого (что спорно , потому что речь идет о классе , а не имя класса), я отправляю ответ здесь:

class MyService {
    private static Class thisClass = MyService.class;
    // or:
    //private static Class thisClass = new Object() { }.getClass().getEnclosingClass();
    ...
    static void startService(Context context) {
        Intent i = new Intent(context, thisClass);
        context.startService(i);
    }
}

Важно определить thisClassкак частное, потому что:
1) оно не должно быть унаследовано: производные классы должны либо определять свои собственные, thisClassлибо выдавать сообщение об ошибке
2) ссылки на другие классы должны быть сделаны, ClassName.classа не ClassName.thisClass.

С thisClassопределением, доступ к имени класса становится:

thisClass.getName()

Мне нужно было имя класса в статических методах нескольких классов, поэтому я реализовал JavaUtil Class следующим методом:

public static String getClassName() {
    String className = Thread.currentThread().getStackTrace()[2].getClassName();
    int lastIndex = className.lastIndexOf('.');
    return className.substring(lastIndex + 1);
}

Надеюсь, это поможет!

Я использовал эти два подхода для обоих static и non staticсценария:

Основной класс:

//For non static approach
public AndroidLogger(Object classObject) {
    mClassName = classObject.getClass().getSimpleName();
}

//For static approach
public AndroidLogger(String className) {
    mClassName = className;
}

Как предоставить имя класса:

нестатический способ:

private AndroidLogger mLogger = new AndroidLogger(this);

Статический способ:

private static AndroidLogger mLogger = new AndroidLogger(Myclass.class.getSimpleName());

Если вы используете отражение, вы можете получить объект Method и затем:

method.getDeclaringClass().getName()

Чтобы получить сам метод, вы, вероятно, можете использовать:

Class<?> c = Class.forName("class name");
Method  method = c.getDeclaredMethod ("method name", parameterTypes)