รับชื่อคลาสจากวิธีการคงที่ใน Java

เราจะได้ชื่อของคลาสจากวิธีสแตติกในคลาสนั้นได้อย่างไร ตัวอย่างเช่น

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

เพื่อให้เป็นบริบทฉันต้องการคืนชื่อคลาสเป็นส่วนหนึ่งของข้อความโดยมีข้อยกเว้น

เพื่อรองรับการเปลี่ยนโครงสร้างใหม่อย่างถูกต้อง (เปลี่ยนชื่อคลาส) คุณควรใช้อย่างใดอย่างหนึ่ง:

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

หรือ (ขอบคุณ@James Van Huis ):

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

ทำในสิ่งที่ชุดเครื่องมือพูด อย่าทำอะไรแบบนี้:

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

ใน Java 7+ คุณสามารถทำได้ในเมธอด / ฟิลด์แบบสแตติก:

MethodHandles.lookup().lookupClass()

ดังนั้นเราจึงมีสถานการณ์เมื่อเราจำเป็นต้องรับคลาสอ็อบเจ็กต์หรือชื่อเต็ม / คลาสแบบง่ายโดยไม่มีการใช้MyClass.classไวยากรณ์อย่างชัดเจน

มันมีประโยชน์จริงๆในบางกรณีเช่นอินสแตนซ์คนตัดไม้ของ Kotlin ฟังก์ชั่นระดับบน (ในกรณีนี้ kotlin สร้างคลาส Java แบบคงที่ไม่สามารถเข้าถึงได้จากรหัส kotlin)

เรามีตัวแปรที่แตกต่างกันเล็กน้อยในการรับข้อมูลนี้:

1. new Object(){}.getClass().getEnclosingClass();
   บันทึกโดยTom Hawtin - tackline

2. getClassContext()[0].getName();จากSecurityManager
   บันทึกของChristoffer

3. new Throwable().getStackTrace()[0].getClassName();
   โดยนับลุดวิก

4. Thread.currentThread().getStackTrace()[1].getClassName();
   จากKeksi

5. และในที่สุดก็ยอดเยี่ยม
   MethodHandles.lookup().lookupClass();
   จากRein

ฉันได้เตรียม JMH มาตรฐานสำหรับตัวแปรและผลลัพธ์ทั้งหมดคือ:

# 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

สรุปผลการวิจัย

1. ตัวแปรที่ดีที่สุดที่จะใช้ค่อนข้างสะอาดและเร็วอย่างน่ากลัว
   มีให้ตั้งแต่ Java 7 และ Android API 26 เท่านั้น!

 MethodHandles.lookup().lookupClass();

2. ในกรณีที่คุณต้องการฟังก์ชันนี้สำหรับ Android หรือ Java 6 คุณสามารถใช้ตัวแปรที่ดีที่สุดอันดับสอง มันค่อนข้างเร็วเช่นกันแต่สร้างคลาสที่ไม่ระบุชื่อในการใช้งานแต่ละแห่ง :(

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

3. ถ้าคุณต้องการมันในหลาย ๆ ที่และไม่ต้องการให้ bytecode ของคุณขยายตัวเนื่องจากมีคลาสนิรนามมากมาย - SecurityManagerคือเพื่อนของคุณ (ตัวเลือกที่ดีที่สุดอันดับสาม)

   แต่คุณไม่สามารถโทรออกgetClassContext()- มันได้รับการคุ้มครองในSecurityManagerชั้น คุณจะต้องมีคลาสผู้ช่วยเช่นนี้:

 // 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. คุณอาจจะไม่เคยต้องใช้ช่วงสองสายพันธุ์ขึ้นอยู่กับจากข้อยกเว้นหรือgetStackTrace() ไม่มีประสิทธิภาพมากและสามารถส่งกลับเฉพาะชื่อคลาสเป็น a ไม่ใช่อินสแตนซ์Thread.currentThread()StringClass<*>

PS

หากคุณต้องการสร้างอินสแตนซ์คนตัดไม้สำหรับ utlet kotlin แบบสแตติก (เช่นฉัน :) คุณสามารถใช้ตัวช่วยนี้:

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

ตัวอย่างการใช้งาน:

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
}

คำสั่งนี้ใช้งานได้ดี:

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

คุณสามารถทำสิ่งที่หวานจริงๆโดยใช้ JNI เช่นนี้:

MyObject.java:

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

    public static native String getClassName();

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

แล้ว:

javac MyObject.java
javah -jni MyObject

แล้ว:

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

จากนั้นคอมไพล์ C ขึ้นในไลบรารีที่แบ่งใช้ที่เรียกว่า libclassname.soและเรียกใช้จาวา!

*ซิกซี้

ฉันใช้สิ่งนี้เพื่อเริ่ม Log4j Logger ที่ด้านบนของชั้นเรียนของฉัน (หรือคำอธิบายประกอบ)

PRO: Throwable ได้ถูกโหลดแล้วและคุณอาจบันทึกทรัพยากรโดยไม่ใช้ SecurityManager "IO หนา"

CON: คำถามบางอย่างเกี่ยวกับว่าสิ่งนี้จะใช้ได้กับ 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()); 

ใช้ SecurityManager ในทางที่ผิด

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

หรือหากไม่ได้ตั้งไว้ให้ใช้คลาสภายในที่ขยายออกมา (ตัวอย่างด้านล่างคัดลอกอย่างน่าอับอายจากHowTo ของ Real ):

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

หากคุณต้องการชื่อแพ็กเกจทั้งหมดพร้อมใช้งานโทร:

String name = MyClass.class.getCanonicalName();

หากคุณต้องการเพียงองค์ประกอบสุดท้ายโทร:

String name = MyClass.class.getSimpleName();

การใช้คำต่อคำของคลาสของผู้โทรเช่นทำงานMyClass.class.getName()จริง แต่มีแนวโน้มที่จะคัดลอก / วางข้อผิดพลาดหากคุณเผยแพร่รหัสนี้ไปยังคลาส / คลาสย่อยจำนวนมากที่คุณต้องการชื่อคลาสนี้

และสูตรของ Tom Hawtinนั้นไม่เลวเลยจริง ๆ เราต้องปรุงมันอย่างถูกวิธี :)

ในกรณีที่คุณมีคลาสฐานที่มีวิธีการแบบคงที่ที่อาจถูกเรียกจากคลาสย่อยและวิธีการแบบคงที่นี้จำเป็นต้องรู้คลาสของผู้โทรจริงสิ่งนี้อาจทำได้ดังนี้:

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

โซลูชันการปรับโครงสร้างที่ปลอดภัยตัดและวางที่หลีกเลี่ยงคำจำกัดความของคลาส ad-hoc ด้านล่าง

เขียนวิธีสแตติกที่กู้คืนชื่อคลาสที่มีความระมัดระวังเพื่อรวมชื่อคลาสในชื่อเมธอด:

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

จากนั้นเรียกคืนด้วยวิธีการคงที่ของคุณ:

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

ความปลอดภัย Refactoring จะได้รับจากการหลีกเลี่ยงการใช้สตริงการตัดและวางเพื่อความปลอดภัยจะได้รับเพราะถ้าคุณตัดและวางเมธอดผู้โทรคุณจะไม่พบ getMyClassName () ในคลาส "MyClass2" เป้าหมายดังนั้นคุณจะถูกบังคับให้กำหนดใหม่และอัปเดต

ตั้งแต่คำถามบางสิ่งเช่น `this.class` แทนที่จะเป็น 'ClassName.class`? ถูกทำเครื่องหมายว่าซ้ำซ้อนสำหรับอันนี้ (ซึ่งพิสูจน์ได้เนื่องจากคำถามนั้นเกี่ยวกับคลาสมากกว่าชื่อคลาส) ฉันโพสต์คำตอบที่นี่:

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

มันเป็นสิ่งสำคัญที่จะกำหนดthisClassเป็นส่วนตัวเนื่องจาก:
1) จะต้องไม่ได้รับมรดก: คลาสที่ได้รับอย่างใดอย่างหนึ่งจะต้องกำหนดตัวเองthisClassหรือผลิตข้อความผิดพลาด
2) อ้างอิงจากชั้นเรียนอื่น ๆ ควรจะทำมากกว่าClassName.classClassName.thisClass

ด้วยการthisClassกำหนดสิทธิ์การเข้าถึงชื่อคลาสจะกลายเป็น:

thisClass.getName()

ฉันต้องการชื่อคลาสในวิธีสแตติกของหลายคลาสดังนั้นฉันจึงใช้ JavaUtil Class ด้วยวิธีการต่อไปนี้:

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

หวังว่ามันจะช่วย!

ฉันใช้ทั้งสองวิธีนี้สำหรับทั้งสถานการณ์staticและnon static:

ชั้นหลัก:

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

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

วิธีระบุชื่อคลาส:

ไม่ใช่วิธีที่คงที่:

private AndroidLogger mLogger = new AndroidLogger(this);

วิธีคงที่:

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

หากคุณกำลังใช้การสะท้อนคุณสามารถรับวัตถุวิธีแล้ว:

method.getDeclaringClass().getName()

เพื่อให้ได้เมธอดเองคุณสามารถใช้:

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