Obtendo o nome da classe de um método estático em Java

Como se pode obter o nome da classe a partir de um método estático nessa classe. Por exemplo

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

Para contextualizar, na verdade, quero retornar o nome da classe como parte de uma mensagem em uma exceção.

Para oferecer suporte à refatoração corretamente (renomear classe), você deve usar:

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

ou (graças a @James Van Huis ):

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

Faça o que o kit de ferramentas diz. Não faça nada parecido com isto:

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

No Java 7+, você pode fazer isso nos métodos / campos estáticos:

MethodHandles.lookup().lookupClass()

Portanto, temos uma situação em que precisamos obter estaticamente um objeto de classe ou um nome completo / simples de classe sem um uso explícito de MyClass.classsintaxe.

Pode ser realmente útil em alguns casos, por exemplo, instância de logger para o kotlin funções de nível superior (neste caso, o kotlin cria uma classe Java estática não acessível a partir do código kotlin).

Temos algumas variantes diferentes para obter essas informações:

1. new Object(){}.getClass().getEnclosingClass();
   observado por Tom Hawtin - tackline

2. getClassContext()[0].getName();do SecurityManager
   observado por Christoffer

3. new Throwable().getStackTrace()[0].getClassName();
   por count ludwig

4. Thread.currentThread().getStackTrace()[1].getClassName();
   de Keksi

5. e finalmente incrível
   MethodHandles.lookup().lookupClass();
   de Rein

Eu preparei um jmh referência para todas as variantes e resultados são:

# 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

Conclusões

1. Melhor variante de usar , bastante limpa e monstruosamente rápida.
   Disponível apenas desde Java 7 e Android API 26!

 MethodHandles.lookup().lookupClass();

2. Caso você precise dessa funcionalidade para Android ou Java 6, poderá usar a segunda melhor variante. Também é rápido, mas cria uma classe anônima em cada local de uso :(

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

3. Se você precisar dele em muitos lugares e não quiser que seu bytecode inche devido a inúmeras classes anônimas - SecurityManageré seu amigo (terceira melhor opção).

   Mas você não pode simplesmente ligar getClassContext()- está protegido na SecurityManagerclasse. Você precisará de alguma classe auxiliar como esta:

 // 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. Você provavelmente nunca precisará usar as duas últimas variantes com base na getStackTrace()exceção from ou no Thread.currentThread(). Muito ineficiente e pode retornar apenas o nome da classe como a String, não a Class<*>instância.

PS

Se você deseja criar uma instância do logger para utilitários estáticos do kotlin (como eu :), você pode usar este auxiliar:

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())

Exemplo de uso:

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
}

Esta instrução funciona bem:

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

Você poderia fazer algo realmente agradável usando JNI assim:

MyObject.java:

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

    public static native String getClassName();

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

então:

javac MyObject.java
javah -jni MyObject

então:

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 );
}

Em seguida, compile o C em uma biblioteca compartilhada chamada libclassname.so e execute o java!

* risada

Eu uso isso para iniciar o Log4j Logger na parte superior das minhas classes (ou fazer anotações).

PRO: Throwable já está carregado e você pode economizar recursos ao não usar o SecurityManager "IO pesado".

CON: Alguma pergunta sobre se isso funcionará para todas as JVMs.

// 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()); 

Abuse o SecurityManager

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

Ou, se não estiver definido, use uma classe interna que a estenda (exemplo abaixo vergonhosamente copiado do HowTo do Real ):

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

Se você quiser o nome completo do pacote, chame:

String name = MyClass.class.getCanonicalName();

Se você deseja apenas o último elemento, chame:

String name = MyClass.class.getSimpleName();

O uso verboso da classe de quem chama MyClass.class.getName()realmente faz o trabalho, mas é propenso a copiar / colar erros se você propagar esse código para várias classes / subclasses onde você precisa desse nome de classe.

E a receita de Tom Hawtin na verdade não é ruim, basta cozinhá-lo da maneira certa :)

Caso você tenha uma classe base com um método estático que pode ser chamado de subclasses e esse método estático precise conhecer a classe do chamador real, isso pode ser alcançado da seguinte maneira:

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);
  }
}

Uma solução segura para refatoração, recortar e colar que evita a definição de classes ad-hoc abaixo.

Escreva um método estático que recupere o nome da classe, tendo o cuidado de incluir o nome da classe no nome do método:

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

depois, lembre-o no seu método estático:

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

A segurança da refatoração é dada ao evitar o uso de strings, a segurança de recortar e colar é concedida porque, se você recortar e colar o método de chamada, não encontrará o getMyClassName () na classe "MyClass2" de destino, sendo forçado a redefini-lo e atualizá-lo.

Desde a pergunta Algo como `this.class` em vez de` ClassName.class`? está marcado como duplicado para este (que é discutível porque essa pergunta é sobre a classe e não o nome da classe), estou postando a resposta aqui:

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);
    }
}

É importante definir thisClasscomo privado porque:
1) não deve ser herdado: as classes derivadas devem definir suas próprias thisClassou produzir uma mensagem de erro
2) as referências de outras classes devem ser feitas como ClassName.classantes ClassName.thisClass.

Com thisClassdefinido, o acesso ao nome da classe se torna:

thisClass.getName()

Eu precisava do nome da classe nos métodos estáticos de várias classes, então implementei uma Classe JavaUtil com o seguinte método:

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

Espero que ajude!

Eu usei essas duas abordagens para ambos statice o non staticcenário:

Classe principal:

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

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

Como fornecer o nome da classe:

maneira não estática:

private AndroidLogger mLogger = new AndroidLogger(this);

Maneira estática:

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

Se você estiver usando reflexão, poderá obter o objeto Method e, em seguida:

method.getDeclaringClass().getName()

Para obter o próprio método, você provavelmente pode usar:

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