Sınıf adını Java'da statik bir yöntemden alma

Bu sınıftaki statik yöntemden sınıfın adı nasıl alınabilir. Örneğin

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

Bağlam koymak için, aslında bir istisna bir mesajın bir parçası olarak sınıf adını döndürmek istiyorum.

Yeniden düzenlemeyi doğru bir şekilde desteklemek için (sınıfı yeniden adlandırın), aşağıdakilerden birini kullanmalısınız:

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

veya ( @James Van Huis sayesinde ):

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

Araç setinin söylediklerini yapın. Böyle bir şey yapmayın:

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

Java 7 ve sonraki sürümlerinde bunu statik yöntem / alanlarda yapabilirsiniz:

MethodHandles.lookup().lookupClass()

Dolayısıyla, açık bir MyClass.classsözdizimi kullanımı olmadan sınıf nesnesini veya sınıf tam / basit adını statik olarak almamız gerektiğinde bir durumumuz vardır .

Bazı durumlarda gerçekten kullanışlı olabilir, örn. KOTLIN üst düzey işlevler (bu durumda kotlin, kotlin kodundan erişilemeyen statik bir Java sınıfı oluşturur).

Bu bilgiyi almak için birkaç farklı varyantımız var:

1. new Object(){}.getClass().getEnclosingClass();
   Tom Hawtin tarafından not edildi - tackline

2. getClassContext()[0].getName();dan SecurityManager
   tarafından belirtildiği Christoffer

3. new Throwable().getStackTrace()[0].getClassName();
   tarafından count ludwig

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

5. ve son
   MethodHandles.lookup().lookupClass();
   olarak Rein'den harika

Hazırladım JMH tüm değişkenler ve sonuçlar için temel ölçüt:

# 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

Sonuçlar

1. Kullanmak için en iyi varyant , oldukça temiz ve canavarca hızlı.
   Yalnızca Java 7 ve Android API 26'dan beri kullanılabilir!

 MethodHandles.lookup().lookupClass();

2. Android veya Java 6 için bu işlevselliğe ihtiyacınız varsa, ikinci en iyi varyantı kullanabilirsiniz. Oldukça hızlıdır, ancak her kullanım yerinde anonim bir sınıf oluşturur :(

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

3. Birçok yerde ihtiyacınız varsa ve tonlarca anonim ders nedeniyle bayt kodunuzun şişmesini istemiyorsanız SecurityManager, arkadaşınızdır (üçüncü en iyi seçenek).

   Ama sadece arayamazsınız getClassContext()- SecurityManagersınıfta korunur . Bunun gibi bir yardımcı sınıfa ihtiyacınız olacak:

 // 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. Muhtemelen getStackTrace(), istisnayı temel alan veya Thread.currentThread(). Çok verimsizdir ve yalnızca sınıf adını örnek olarak Stringdeğil, a olarak döndürebilir Class<*>.

PS

Statik kotlin araçları (benim gibi :) için bir günlükçü örneği oluşturmak istiyorsanız, bu yardımcıyı kullanabilirsiniz:

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

Kullanım örneği:

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
}

Bu talimat iyi çalışıyor:

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

Bunun gibi JNI kullanarak gerçekten tatlı bir şey yapabilirsiniz:

MyObject.java:

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

    public static native String getClassName();

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

sonra:

javac MyObject.java
javah -jni MyObject

sonra:

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

Sonra C denilen paylaşılan bir kütüphane içine derlemek libclassname.sove java çalıştırın!

*kıkırdama

Sınıflarımın üstündeki Log4j Logger'ı başlatmak (veya açıklama eklemek) için bunu kullanıyorum.

PRO: Fırlatılabilir zaten yüklü ve "IO heavy" SecurityManager'ı kullanmadan kaynakları kaydedebilirsiniz.

CON: Bunun tüm JVM'ler için işe yarayıp yaramayacağı hakkında bazı sorular.

// 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'ı Kötüye Kullanma

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

Veya ayarlanmadıysa, onu genişleten bir iç sınıf kullanın (aşağıdaki örnek Real'in HowTo'sundan utanarak kopyalanmıştır ):

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

Tüm paket adının yanında olmasını istiyorsanız, şunu arayın:

String name = MyClass.class.getCanonicalName();

Yalnızca son öğeyi istiyorsanız şu numarayı arayın:

String name = MyClass.class.getSimpleName();

Arayanın sınıfının MyClass.class.getName()kelimesi kelimesine kullanımı aslında işi yapar, ancak bu kodu bu sınıf adına ihtiyacınız olan çok sayıda sınıfa / alt sınıfa yaymanız durumunda hataları kopyalamaya / yapıştırmaya eğilimlidir.

Ve Tom Hawtin'in tarifi aslında kötü değil, sadece doğru şekilde pişirmek gerekiyor :)

Alt sınıflardan çağrılabilecek statik yöntemi olan bir temel sınıfınız varsa ve bu statik yöntemin gerçek arayanın sınıfını bilmesi gerekiyorsa, bu aşağıdaki gibi yapılabilir:

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

Aşağıdaki geçici sınıfların tanımını önleyen yeniden düzenleme-güvenli, kes ve yapıştır-güvenli çözüm.

Sınıf adını yöntem adına eklemeye özen göstererek sınıf adını kurtaran statik bir yöntem yazın:

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

ardından statik yönteminizde hatırlayın:

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

Yeniden düzenleme güvenliği, dizelerin kullanımından kaçınarak verilir, kesme ve yapıştırma güvenliği sağlanır, çünkü arayan yöntemini kesip yapıştırırsanız getMyClassName () öğesini "MyClass2" hedefinde bulamazsınız, bu nedenle yeniden tanımlamak ve güncellemek zorunda kalırsınız.

Sorudan beri ClassName.class yerine "this.class" gibi bir şey? (Bu soru sınıf adı yerine sınıfla ilgili olduğu için tartışılabilir) için bu bir kopya olarak işaretlenir, ben cevap burada gönderiyorum:

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

Tanımlanması önemlidir thisClassolarak özel çünkü:
türetilmiş sınıfları ya kendi tanımlamak gerekir: 1) miras olmamalıdır thisClassya da bir hata mesajı üretir
olarak yapılmalıdır 2) diğer sınıflardan referanslar ClassName.classyerine ClassName.thisClass.

İle thisClasstanımlanan, sınıfının adıyla erişim haline gelir:

thisClass.getName()

Birden fazla sınıfın statik yöntemlerinde sınıf adını gerekiyordu, bu yüzden aşağıdaki yöntemle bir JavaUtil Sınıfı uyguladım:

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

Umarım yardımcı olur!

Her ikisine de bu iki yaklaşım kullandık staticvenon static senaryo:

Ana sınıf:

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

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

Sınıf adı nasıl verilir:

statik olmayan yol:

private AndroidLogger mLogger = new AndroidLogger(this);

Statik yolu:

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

Yansıma kullanıyorsanız, Method nesnesini alabilir ve ardından:

method.getDeclaringClass().getName()

Yöntemin kendisini almak için muhtemelen şunları kullanabilirsiniz:

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