Mendapatkan nama kelas dari metode statis di Jawa

Bagaimana seseorang bisa mendapatkan nama kelas dari metode statis di kelas itu. Sebagai contoh

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

Singkatnya, saya sebenarnya ingin mengembalikan nama kelas sebagai bagian dari pesan dalam pengecualian.

Untuk mendukung refactoring dengan benar (ganti nama kelas), maka Anda harus menggunakan:

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

atau (terima kasih kepada @James Van Huis ):

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

Lakukan apa yang dikatakan toolkit. Jangan melakukan hal seperti ini:

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

Di Java 7+ Anda dapat melakukan ini dalam metode / bidang statis:

MethodHandles.lookup().lookupClass()

Jadi, kita memiliki situasi ketika kita perlu secara statis mendapatkan objek kelas atau nama lengkap / kelas sederhana tanpa penggunaan MyClass.classsintaks yang eksplisit .

Ini bisa sangat berguna dalam beberapa kasus, misalnya contoh logger untuk kotlin fungsi tingkat atas (dalam hal ini kotlin membuat kelas Java statis yang tidak dapat diakses dari kode kotlin).

Kami memiliki beberapa varian berbeda untuk mendapatkan informasi ini:

1. new Object(){}.getClass().getEnclosingClass();
   dicatat oleh Tom Hawtin - tackline

2. getClassContext()[0].getName();dari yang SecurityManager
   dicatat oleh Christoffer

3. new Throwable().getStackTrace()[0].getClassName();
   menurut hitungan ludwig

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

5. dan akhirnya dahsyat
   MethodHandles.lookup().lookupClass();
   dari Rein

Saya sudah menyiapkan jmh tolok ukur untuk semua varian dan hasil adalah:

# 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

Kesimpulan

1. Varian terbaik untuk digunakan , agak bersih dan sangat cepat.
   Hanya tersedia sejak Java 7 dan Android API 26!

 MethodHandles.lookup().lookupClass();

2. Jika Anda membutuhkan fungsi ini untuk Android atau Java 6, Anda dapat menggunakan varian terbaik kedua. Ini agak cepat juga, tetapi menciptakan kelas anonim di setiap tempat penggunaan :(

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

3. Jika Anda membutuhkannya di banyak tempat dan tidak ingin kode byte Anda kembung karena banyak kelas anonim - SecurityManageradalah teman Anda (opsi terbaik ketiga).

   Tapi Anda tidak bisa begitu saja menelepon getClassContext()- itu dilindungi di SecurityManagerkelas. Anda membutuhkan beberapa kelas pembantu seperti ini:

 // 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. Anda mungkin tidak perlu menggunakan dua varian terakhir berdasarkan getStackTrace()dari atau dari Thread.currentThread(). Sangat tidak efisien dan hanya dapat mengembalikan nama kelas sebagai String, bukan Class<*>turunannya.

PS

Jika Anda ingin membuat instance logger untuk utilitas kotlin statis (seperti saya :), Anda dapat menggunakan bantuan ini:

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

Contoh penggunaan:

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
}

Instruksi ini berfungsi dengan baik:

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

Anda dapat melakukan sesuatu yang sangat manis dengan menggunakan JNI seperti ini:

MyObject.java:

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

    public static native String getClassName();

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

kemudian:

javac MyObject.java
javah -jni MyObject

kemudian:

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

Kemudian kompilasi C menjadi perpustakaan bersama yang disebut libclassname.sodan jalankan java!

*tertawa kecil

Saya menggunakan ini untuk init Log4j Logger di bagian atas kelas saya (atau membubuhi keterangan).

PRO: Throwable sudah dimuat dan Anda dapat menghemat sumber daya dengan tidak menggunakan SecurityManager "IO heavy".

CON: Beberapa pertanyaan apakah ini akan bekerja untuk semua 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()); 

Pelanggaran Manajer Keamanan

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

Atau, jika tidak disetel, gunakan kelas dalam yang memperluasnya (contoh di bawah ini disalin secara memalukan dari Real's HowTo ):

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

Jika Anda ingin seluruh nama paket bersamanya, hubungi:

String name = MyClass.class.getCanonicalName();

Jika Anda hanya menginginkan elemen terakhir, hubungi:

String name = MyClass.class.getSimpleName();

Penggunaan kelas penelepon secara verbal seperti yang MyClass.class.getName()sebenarnya dilakukan, tetapi cenderung untuk menyalin / menempel kesalahan jika Anda menyebarkan kode ini ke banyak kelas / subkelas di mana Anda memerlukan nama kelas ini.

Dan resep Tom Hawtin sebenarnya tidak buruk, kita hanya perlu memasaknya dengan cara yang benar :)

Jika Anda memiliki kelas dasar dengan metode statis yang dapat dipanggil dari subclass, dan metode statis ini perlu mengetahui kelas penelepon yang sebenarnya, ini dapat dicapai seperti berikut:

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

Solusi yang aman untuk refactoring, cut & paste-safe yang menghindari definisi kelas ad-hoc di bawah ini.

Tulis metode statis yang memulihkan nama kelas dengan hati-hati untuk memasukkan nama kelas dalam nama metode:

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

lalu ingat dalam metode statis Anda:

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

Keamanan refactoring diberikan dengan menghindari penggunaan string, keamanan cut & paste diberikan karena jika Anda memotong & menempelkan metode pemanggil Anda tidak akan menemukan getMyClassName () di kelas "MyClass2" target, sehingga Anda akan dipaksa untuk mendefinisikan ulang dan memperbaruinya.

Karena pertanyaannya Sesuatu seperti `this.class` bukan` ClassName.class`? ditandai sebagai duplikat untuk yang ini (yang dapat diperdebatkan karena pertanyaan itu adalah tentang kelas daripada nama kelas), saya memposting jawabannya di sini:

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

Penting untuk didefinisikan thisClasssebagai pribadi karena:
1) itu tidak boleh diwarisi: kelas turunan harus mendefinisikan sendiri thisClassatau menghasilkan pesan kesalahan
2) referensi dari kelas lain harus dilakukan ClassName.classdaripada ClassName.thisClass.

Dengan thisClassditentukan, akses ke nama kelas menjadi:

thisClass.getName()

Saya membutuhkan nama kelas dalam metode statis beberapa kelas jadi saya menerapkan JavaUtil Class dengan metode berikut:

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

Semoga ini bisa membantu!

Saya telah menggunakan dua pendekatan ini untuk keduanya staticdan non staticskenario:

Kelas utama:

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

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

Cara memberikan nama kelas:

cara non statis:

private AndroidLogger mLogger = new AndroidLogger(this);

Cara statis:

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

Jika Anda menggunakan refleksi, Anda bisa mendapatkan objek Metode dan kemudian:

method.getDeclaringClass().getName()

Untuk mendapatkan Metode itu sendiri, Anda mungkin dapat menggunakan:

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