Ottenere il nome della classe da un metodo statico in Java

Come si può ottenere il nome della classe da un metodo statico in quella classe. Per esempio

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

Per metterlo nel contesto, in realtà voglio restituire il nome della classe come parte di un messaggio in un'eccezione.

Per supportare correttamente il refactoring (rinomina classe), è necessario utilizzare:

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

o (grazie a @James Van Huis ):

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

Fai quello che dice il toolkit. Non fare nulla del genere:

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

In Java 7+ puoi farlo in metodi / campi statici:

MethodHandles.lookup().lookupClass()

Quindi, abbiamo una situazione in cui dobbiamo ottenere staticamente un oggetto classe o un nome completo / semplice di classe senza un uso esplicito della MyClass.classsintassi.

Può essere davvero utile in alcuni casi, ad esempio l'istanza del logger per Kotlin funzioni di livello superiore (in questo caso kotlin crea una classe Java statica non accessibile dal codice kotlin).

Abbiamo alcune varianti per ottenere queste informazioni:

1. new Object(){}.getClass().getEnclosingClass();
   notato da Tom Hawtin - tackline

2. getClassContext()[0].getName();dal SecurityManager
   noto di Christoffer

3. new Throwable().getStackTrace()[0].getClassName();
   dal conte Ludwig

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

5. e finalmente fantastico
   MethodHandles.lookup().lookupClass();
   da Rein

Ho preparato un JMH benchmark per tutte le varianti e risultati sono:

# 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

conclusioni

1. La migliore variante da usare , piuttosto pulita e mostruosamente veloce.
   Disponibile solo da Java 7 e Android API 26!

 MethodHandles.lookup().lookupClass();

2. Nel caso in cui sia necessaria questa funzionalità per Android o Java 6, è possibile utilizzare la seconda variante migliore. È anche piuttosto veloce, ma crea una classe anonima in ogni luogo di utilizzo :(

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

3. Se ne hai bisogno in molti luoghi e non vuoi che il tuo bytecode si gonfi a causa di tonnellate di classi anonime, SecurityManagerè il tuo amico (terza opzione migliore).

   Ma non puoi semplicemente chiamare getClassContext(): è protetto in SecurityManagerclasse. Avrai bisogno di una classe di supporto come questa:

 // 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. Probabilmente non avrai mai bisogno di usare le ultime due varianti in base getStackTrace()all'eccezione from o alla Thread.currentThread(). Molto inefficiente e può restituire solo il nome della classe come a String, non l' Class<*>istanza.

PS

Se vuoi creare un'istanza del logger per utility kotlin statiche (come me :), puoi usare questo helper:

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

Esempio di utilizzo:

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
}

Questa istruzione funziona bene:

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

Puoi fare qualcosa di veramente dolce usando JNI in questo modo:

MyObject.java:

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

    public static native String getClassName();

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

poi:

javac MyObject.java
javah -jni MyObject

poi:

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

Quindi compila il C in una libreria condivisa chiamata libclassname.soed esegui java!

* risatina

Lo uso per avviare Log4j Logger nella parte superiore delle mie lezioni (o annotare).

PRO: Throwable è già caricato e potresti risparmiare risorse non usando il SecurityManager "IO pesante".

CON: Qualche domanda sul funzionamento di tutte le 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()); 

Abusa di SecurityManager

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

Oppure, se non impostato, utilizzare una classe interna che la estende (esempio riportato di seguito vergognosamente copiato dal HowTo di Real ):

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

Se si desidera l'intero nome del pacchetto con esso, chiamare:

String name = MyClass.class.getCanonicalName();

Se vuoi solo l'ultimo elemento, chiama:

String name = MyClass.class.getSimpleName();

L'uso verbale della classe del chiamante come MyClass.class.getName()effettivamente fa il lavoro, ma è incline a copiare / incollare errori se si propaga questo codice a numerose classi / sottoclassi in cui è necessario questo nome di classe.

E la ricetta di Tom Hawtin non è male, bisogna solo cucinarla nel modo giusto :)

Nel caso in cui si abbia una classe base con un metodo statico che può essere chiamato da sottoclassi e questo metodo statico deve conoscere la classe del chiamante effettiva, ciò può essere ottenuto come il seguente:

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 soluzione sicura per refactoring, taglia e incolla che evita la definizione delle classi ad hoc di seguito.

Scrivi un metodo statico che ripristini il nome della classe avendo cura di includere il nome della classe nel nome del metodo:

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

quindi richiamalo nel tuo metodo statico:

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

La sicurezza del refactoring viene data evitando l'uso di stringhe, la sicurezza taglia e incolla è garantita perché se si taglia e incolla il metodo del chiamante non si troverà getMyClassName () nella classe "MyClass2" di destinazione, quindi si sarà costretti a ridefinire e aggiornarlo.

Dalla domanda Qualcosa come `this.class` invece di` ClassName.class`? è contrassegnato come duplicato per questo (il che è discutibile perché quella domanda riguarda la classe piuttosto che il nome della classe), sto postando la risposta qui:

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 definire thisClasscome privato perché:
1) non deve essere ereditato: le classi derivate devono definirsi proprie thisClasso produrre un messaggio di errore
2) i riferimenti da altre classi devono essere fatti come ClassName.classanziché ClassName.thisClass.

Con thisClassdefinito, l'accesso al nome della classe diventa:

thisClass.getName()

Avevo bisogno del nome della classe nei metodi statici di più classi, quindi ho implementato una classe JavaUtil con il seguente metodo:

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

Spero che possa aiutare!

Ho usato questi due approcci per entrambi statice per lo non staticscenario:

Classe principale:

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

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

Come fornire il nome della classe:

modo non statico:

private AndroidLogger mLogger = new AndroidLogger(this);

Modo statico:

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

Se si utilizza la riflessione, è possibile ottenere l'oggetto Metodo e quindi:

method.getDeclaringClass().getName()

Per ottenere il metodo stesso, puoi probabilmente usare:

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