Obtener el nombre de la clase de un método estático en Java

¿Cómo se puede obtener el nombre de la clase de un método estático en esa clase? Por ejemplo

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

Para ponerlo en contexto, en realidad quiero devolver el nombre de la clase como parte de un mensaje en una excepción.

Para admitir la refactorización correctamente (cambiar el nombre de la clase), debe usar:

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

o (gracias a @James Van Huis ):

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

Haz lo que dice el juego de herramientas. No hagas nada como esto:

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

En Java 7+ puede hacer esto en métodos / campos estáticos:

MethodHandles.lookup().lookupClass()

Entonces, tenemos una situación en la que necesitamos obtener estáticamente un objeto de clase o un nombre completo / simple de clase sin un uso explícito de MyClass.classsintaxis.

Puede ser realmente útil en algunos casos, por ejemplo, la instancia del registrador para Kotlin funciones de nivel superior (en este caso, kotlin crea una clase Java estática no accesible desde el código de kotlin).

Tenemos algunas variantes diferentes para obtener esta información:

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

2. getClassContext()[0].getName();de lo SecurityManager
   señalado por Christoffer

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

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

5. y finalmente impresionante
   MethodHandles.lookup().lookupClass();
   de Rein

He preparado un jmh Los puntos de referencia para todas las variantes y resultados son:

# 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

Conclusiones

1. La mejor variante para usar , bastante limpia y monstruosamente rápida.
   ¡Disponible solo desde Java 7 y Android API 26!

 MethodHandles.lookup().lookupClass();

2. En caso de que necesite esta funcionalidad para Android o Java 6, puede usar la segunda mejor variante. También es bastante rápido, pero crea una clase anónima en cada lugar de uso :(

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

3. Si lo necesita en muchos lugares y no quiere que su código de bytes se hinche debido a toneladas de clases anónimas, SecurityManageres su amigo (la tercera mejor opción).

   Pero no puedes simplemente llamar getClassContext(), está protegido en la SecurityManagerclase. Necesitarás una clase 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. Probablemente no necesite usar las dos últimas variantes en función de la getStackTrace()excepción from o de Thread.currentThread(). Muy ineficiente y puede devolver solo el nombre de la clase como a String, no la Class<*>instancia.

PD

Si desea crear una instancia de registrador para utilidades estáticas de kotlin (como yo :), puede usar este ayudante:

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

Ejemplo 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 instrucción funciona bien:

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

Podrías hacer algo realmente dulce usando JNI como este:

MyObject.java:

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

    public static native String getClassName();

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

luego:

javac MyObject.java
javah -jni MyObject

luego:

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

Luego compile el C en una biblioteca compartida llamada libclassname.so y ejecute Java.

*risita

Lo uso para iniciar el Log4j Logger en la parte superior de mis clases (o anotar).

PRO: Throwable ya está cargado y puede ahorrar recursos al no usar el SecurityManager "IO heavy".

CON: Algunas preguntas sobre si esto funcionará para todas las 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()); 

Abusar del SecurityManager

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

O, si no está configurado, use una clase interna que lo extienda (ejemplo a continuación, copiado vergonzosamente de Real's HowTo ):

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

Si desea el nombre completo del paquete, llame al:

String name = MyClass.class.getCanonicalName();

Si solo desea el último elemento, llame a:

String name = MyClass.class.getSimpleName();

El uso literal de la clase de la persona que llama como MyClass.class.getName()realmente hace el trabajo, pero es propenso a copiar / pegar errores si propaga este código a numerosas clases / subclases donde necesita este nombre de clase.

Y la receta de Tom Hawtin, de hecho, no está mal, solo hay que cocinarla de la manera correcta :)

En caso de que tenga una clase base con un método estático al que se pueda llamar desde subclases, y este método estático necesita conocer la clase real del llamante, esto se puede lograr de la siguiente manera:

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

Una solución segura para refactorizar, cortar y pegar que evita la definición de clases ad-hoc a continuación.

Escriba un método estático que recupere el nombre de la clase teniendo cuidado de incluir el nombre de la clase en el nombre del método:

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

luego recuérdalo en tu método estático:

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

La seguridad de refactorización se proporciona evitando el uso de cadenas, se garantiza la seguridad de cortar y pegar porque si corta y pega el método de llamada no encontrará el getMyClassName () en la clase de destino "MyClass2", por lo que se verá obligado a redefinirlo y actualizarlo.

¿Desde la pregunta Algo como `this.class` en lugar de` ClassName.class`? está marcado como un duplicado para este (lo cual es discutible porque esa pregunta es sobre la clase en lugar del nombre de la clase), estoy publicando la respuesta aquí:

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

Es importante definirlo thisClasscomo privado porque:
1) no debe heredarse: las clases derivadas deben definir las suyas propias thisClasso generar un mensaje de error
2) las referencias de otras clases deben hacerse en ClassName.classlugar de hacerlo ClassName.thisClass.

Con thisClassdefinido, el acceso al nombre de la clase se convierte en:

thisClass.getName()

Necesitaba el nombre de la clase en los métodos estáticos de varias clases, así que implementé una clase JavaUtil con el siguiente método:

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

¡Espero que ayude!

He usado estos dos enfoques para ambos staticynon static escenario:

Clase principal:

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

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

Cómo proporcionar el nombre de la clase:

forma no estática:

private AndroidLogger mLogger = new AndroidLogger(this);

Manera estática:

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

Si está utilizando la reflexión, puede obtener el objeto Método y luego:

method.getDeclaringClass().getName()

Para obtener el Método en sí, probablemente pueda usar:

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