如何确定线程java应用程序运行时的主类？

Question

我想在运行时确定应用程序启动的类名（使用main（）方法的类），但是我在另一个线程中，并且我的堆栈跟踪没有回到原始类。

我已经搜索了系统属性和ClassLoader所提供的一切，并且什么也没有提供。这些信息是否不可用？

谢谢。

Answer 1

我想通了。任何人都可以告诉我这个环境变量是否会一直存在于跨操作系统的其他Java实现中？这在Oracle JVM产生像“org.x.y.ClassName”

public static String getMainClassName() { 
    for (final Map.Entry<String, String> entry : System.getenv().entrySet()) 
    if (entry.getKey().startsWith("JAVA_MAIN_CLASS")) // like JAVA_MAIN_CLASS_13328 
     return entry.getValue(); 
    throw new IllegalStateException("Cannot determine main class."); 
} 

Answer 2

尝试使用Thread.getAllStackTraces()。它从所有正在运行的线程中返回一个堆栈跟踪的Map，而不仅仅是当前的线程。

Answer 3

如何像：

Map<Thread,StackTraceElement[]> stackTraceMap = Thread.getAllStackTraces(); 
for (Thread t : stackTraceMap.keySet()) 
{ 
    if ("main".equals(t.getName())) 
    { 
     StackTraceElement[] mainStackTrace = stackTraceMap.get(t); 
     for (StackTraceElement element : mainStackTrace) 
     { 
      System.out.println(element); 
     } 
    } 
} 

这会给你像

java.lang.Object.wait(Native Method) 
java.lang.Object.wait(Object.java:231) 
java.lang.Thread.join(Thread.java:680) 
com.mypackage.Runner.main(Runner.java:10) 

主线程可能是不保证的广告被称为"main"虽然 - 也许是更好地检查堆栈微量元素含有(main

编辑如果主thr ead退出了，这不好！

Answer 4

鉴于澄清，我建议用成语“从上面参数化”的字符串。你有信息开始，保持它。

我确实在一个RFE 4827318（六年前！）为此类测试跑步者使用。

Answer 5

我建议把这些信息放到一个系统属性中。从脚本启动应用程序时，这通常很简单。

如果你不能这样做，我建议在每个应用程序的main（）方法中设置属性。这里最简单的方法是让每个应用程序都从一个公共基类中派生出它的“主类”，然后在那里运行一个init步骤。我经常这样做的命令行处理：

public class Demo extends Main { 
    main(String[] args) { 
     Main._main(new Demo(), args); 
    } 

    // This gets called by Main._main() 
    public void run (String[] args) { 
    } 
} 

Answer 6

请参阅Tom Hawtin给出的链接评论。一个解决办法是这些天（甲骨文JVM只）：

public static String getMainClassAndArgs() { 
    return System.getProperty("sun.java.command"); // like "org.x.y.Main arg1 arg2" 
} 

只支持Oracle的Java测试有关特殊情况7的更多信息：http://bugs.java.com/view_bug.do?bug_id=4827318

Answer 7

的JAVA_MAIN_CLASS环境价值并不总是存在取决于平台。如果你只是想获得的是开始您的Java进程的“主”类的名字，你可以这样做：

public static String getMainClassName() 
    { 
    StackTraceElement trace[] = Thread.currentThread().getStackTrace(); 
    if (trace.length > 0) { 
     return trace[trace.length - 1].getClassName(); 
    } 
    return "Unknown"; 
    } 

Answer 8

即使与main（）方法的线程终止，而您没有使用Oracle JVM仍然可以尝试从操作系统获取信息。下面的代码获得了用于在Linux下启动JVM的命令行，但您可以为Windows编写一个版本等。然后，您可以查看JVM的参数以查找应用程序入口点。它可能直接在命令行中，或者您可能在指定jar的清单中查找Main-Class：classname。我会首先使用System.getProperty（“sun.java.command”）和朋友，如果有必要的话只能回到这个机制。

public final static long getSelfPid() { 
    // Java 9 only 
    // return ProcessHandle.current().getPid(); 
    try { 
     return Long.parseLong(new File("/proc/self").getCanonicalFile().getName()); 
    } catch(Exception e) { 
     return -1; 
    } 
} 

public final static String getJVMCommandLine() { 
    try { 
     // Java 9 only 
     // long pid = ProcessHandle.current().getPid(); 
     long pid = getSelfPid(); 
     byte[] encoded = Files.readAllBytes(Paths.get("/proc/"+pid+"/cmdline")); 
     // assume ISO_8859_1, but could look in /proc/<pid>/environ for LANG or something I suppose 
     String commandLine = new String(encoded, StandardCharsets.ISO_8859_1); 
     String modifiedCommandLine = commandLine.replace((char)0, ' ').trim(); 
     return modifiedCommandLine; 
    } catch(Exception e) { 
     return null; 
    } 
}` 

Answer 9

下面是我使用的是什么，对于有些情况下你不控制主：

public static Class<?> getMainClass() { 
    // find the class that called us, and use their "target/classes" 
    final Map<Thread, StackTraceElement[]> traces = Thread.getAllStackTraces(); 
    for (Entry<Thread, StackTraceElement[]> trace : traces.entrySet()) { 
    if ("main".equals(trace.getKey().getName())) { 
     // Using a thread named main is best... 
     final StackTraceElement[] els = trace.getValue(); 
     int i = els.length - 1; 
     StackTraceElement best = els[--i]; 
     String cls = best.getClassName(); 
     while (i > 0 && isSystemClass(cls)) { 
     // if the main class is likely an ide, 
     // then we should look higher... 
     while (i-- > 0) { 
      if ("main".equals(els[i].getMethodName())) { 
      best = els[i]; 
      cls = best.getClassName(); 
      break; 
      } 
     } 
     } 
     if (isSystemClass(cls)) { 
     i = els.length - 1; 
     best = els[i]; 
     while (isSystemClass(cls) && i --> 0) { 
      best = els[i]; 
      cls = best.getClassName(); 
     } 
     } 
     try { 
     Class mainClass = Class.forName(best.getClassName()); 
     return mainClass; 
     } catch (ClassNotFoundException e) { 
     throw X_Util.rethrow(e); 
     } 
    } 
    } 
    return null; 
} 

private static boolean isSystemClass(String cls) { 
    return cls.startsWith("java.") || 
     cls.startsWith("sun.") || 
     cls.startsWith("org.apache.maven.") || 
     cls.contains(".intellij.") || 
     cls.startsWith("org.junit") || 
     cls.startsWith("junit.") || 
     cls.contains(".eclipse") || 
     cls.contains("netbeans"); 
} 

Answer 10

另一种方式来获得主类是寻找在Thread.getAllStackTraces该类，所以你能找到它甚至罐子里面，它适用于任何SDK（开放，甲骨文...）：

private static Class<?> mainClass = null; 

public static Class<?> getMainClass() 
{ 
    if (mainClass == null) 
    { 
     Map<Thread, StackTraceElement[]> threadSet = Thread.getAllStackTraces(); 
     for (Map.Entry<Thread, StackTraceElement[]> entry : threadSet.entrySet()) 
     { 
      for (StackTraceElement stack : entry.getValue()) 
      { 
       try 
       { 
        String stackClass = stack.getClassName(); 
        if (stackClass != null && stackClass.indexOf("$") > 0) 
        { 
         stackClass = stackClass.substring(0, stackClass.lastIndexOf("$")); 
        } 
        Class<?> instance = Class.forName(stackClass); 
        Method method = instance.getDeclaredMethod("main", new Class[] 
        { 
         String[].class 
        }); 
        if (Modifier.isStatic(method.getModifiers())) 
        { 
         mainClass = instance; 
         break; 
        } 
       } 
       catch (Exception ex) 
       { 
       } 
      } 
     } 
     return mainClass; 
    } 
}