Wie erhalte ich eine Liste der aktuell geöffneten Fenster / Prozesse mit Java?

Weiß jemand, wie ich die aktuell geöffneten Fenster oder den Prozess eines lokalen Computers mit Java erhalte?

Ich versuche Folgendes: Liste der aktuell geöffneten Aufgaben, Fenster oder geöffneten Prozesse wie im Windows Taskmanager auf, jedoch mit einem plattformübergreifenden Ansatz - wenn möglich nur mit Java.

Dies ist ein weiterer Ansatz, um die Prozessliste mit dem Befehl " ps -e " zu analysieren :

try {
    String line;
    Process p = Runtime.getRuntime().exec("ps -e");
    BufferedReader input =
            new BufferedReader(new InputStreamReader(p.getInputStream()));
    while ((line = input.readLine()) != null) {
        System.out.println(line); //<-- Parse data here.
    }
    input.close();
} catch (Exception err) {
    err.printStackTrace();
}

Wenn Sie Windows verwenden, sollten Sie die Zeile "Process p = Runtime.getRun ..." etc ... (3. Zeile) für eine Zeile ändern, die folgendermaßen aussieht:

Process p = Runtime.getRuntime().exec
    (System.getenv("windir") +"\\system32\\"+"tasklist.exe");

Hoffe die Info hilft!

Schließlich ist es mit Java 9+ möglich mit ProcessHandle:

public static void main(String[] args) {
    ProcessHandle.allProcesses()
            .forEach(process -> System.out.println(processDetails(process)));
}

private static String processDetails(ProcessHandle process) {
    return String.format("%8d %8s %10s %26s %-40s",
            process.pid(),
            text(process.parent().map(ProcessHandle::pid)),
            text(process.info().user()),
            text(process.info().startInstant()),
            text(process.info().commandLine()));
}

private static String text(Optional<?> optional) {
    return optional.map(Object::toString).orElse("-");
}

Ausgabe:

    1        -       root   2017-11-19T18:01:13.100Z /sbin/init
  ...
  639     1325   www-data   2018-12-04T06:35:58.680Z /usr/sbin/apache2 -k start
  ...
23082    11054    huguesm   2018-12-04T10:24:22.100Z /.../java ProcessListDemo

Unter Windows gibt es eine Alternative mit JNA :

import com.sun.jna.Native;
import com.sun.jna.platform.win32.*;
import com.sun.jna.win32.W32APIOptions;

public class ProcessList {

    public static void main(String[] args) {
        WinNT winNT = (WinNT) Native.loadLibrary(WinNT.class, W32APIOptions.UNICODE_OPTIONS);

        WinNT.HANDLE snapshot = winNT.CreateToolhelp32Snapshot(Tlhelp32.TH32CS_SNAPPROCESS, new WinDef.DWORD(0));

        Tlhelp32.PROCESSENTRY32.ByReference processEntry = new Tlhelp32.PROCESSENTRY32.ByReference();

        while (winNT.Process32Next(snapshot, processEntry)) {
            System.out.println(processEntry.th32ProcessID + "\t" + Native.toString(processEntry.szExeFile));
        }

        winNT.CloseHandle(snapshot);
    }
}

Ich kann mir das nur vorstellen, indem ich eine Befehlszeilenanwendung aufrufe, die die Arbeit für Sie erledigt, und dann die Ausgabe auf dem Bildschirm abkratzt (wie die ps- und Windows-Aufgabenliste von Linux).

Leider bedeutet dies, dass Sie einige Parsing-Routinen schreiben müssen, um die Daten von beiden zu lesen.

Process proc = Runtime.getRuntime().exec ("tasklist.exe");
InputStream procOutput = proc.getInputStream ();
if (0 == proc.waitFor ()) {
    // TODO scan the procOutput for your data
}

YAJSW (ein weiterer Java Service Wrapper) scheint JNA-basierte Implementierungen seiner org.rzo.yajsw.os.TaskList-Schnittstelle für Win32, Linux, BSD und Solaris zu haben und unterliegt einer LGPL-Lizenz. Ich habe nicht versucht, diesen Code direkt aufzurufen, aber YAJSW funktioniert wirklich gut, wenn ich ihn in der Vergangenheit verwendet habe, sodass Sie sich nicht zu viele Sorgen machen sollten.

Mit jProcesses können Sie die Liste der ausgeführten Prozesse einfach abrufen

List<ProcessInfo> processesList = JProcesses.getProcessList();

for (final ProcessInfo processInfo : processesList) {
    System.out.println("Process PID: " + processInfo.getPid());
    System.out.println("Process Name: " + processInfo.getName());
    System.out.println("Process Used Time: " + processInfo.getTime());
    System.out.println("Full command: " + processInfo.getCommand());
    System.out.println("------------------");
}

Es gibt keine plattformneutrale Möglichkeit, dies zu tun. In der Version 1.6 von Java wurde eine " Desktop " -Klasse hinzugefügt, die tragbare Möglichkeiten zum Durchsuchen, Bearbeiten, Versenden, Öffnen und Drucken von URIs ermöglicht. Es ist möglich, dass diese Klasse eines Tages erweitert wird, um Prozesse zu unterstützen, aber ich bezweifle es.

Wenn Sie nur neugierig auf Java-Prozesse sind, können Sie die API java.lang.management verwenden, um Thread- / Speicherinformationen in der JVM abzurufen.

Für Windows verwende ich Folgendes:

Process process = new ProcessBuilder("tasklist.exe", "/fo", "csv", "/nh").start();
new Thread(() -> {
    Scanner sc = new Scanner(process.getInputStream());
    if (sc.hasNextLine()) sc.nextLine();
    while (sc.hasNextLine()) {
        String line = sc.nextLine();
        String[] parts = line.split(",");
        String unq = parts[0].substring(1).replaceFirst(".$", "");
        String pid = parts[1].substring(1).replaceFirst(".$", "");
        System.out.println(unq + " " + pid);
    }
}).start();
process.waitFor();
System.out.println("Done");

Dies kann für Apps mit einer gebündelten JRE nützlich sein: Ich suche nach dem Ordnernamen, von dem aus ich die Anwendung ausführe: Wenn Ihre Anwendung also ausgeführt wird von:

C:\Dev\build\SomeJavaApp\jre-9.0.1\bin\javaw.exe

Dann können Sie feststellen, ob es bereits in J9 ausgeführt wird, indem Sie:

public static void main(String[] args) {
    AtomicBoolean isRunning = new AtomicBoolean(false);
    ProcessHandle.allProcesses()
            .filter(ph -> ph.info().command().isPresent() && ph.info().command().get().contains("SomeJavaApp"))
            .forEach((process) -> {
                isRunning.set(true);
            });
    if (isRunning.get()) System.out.println("SomeJavaApp is running already");
}

Das Parsen von Code ps auxfür Linux und tasklistWindows ist die beste Option, bis etwas Allgemeineres hinzukommt.

Für Windows können Sie auf Folgendes verweisen: http://www.rgagnon.com/javadetails/java-0593.html

Linux kann die Ergebisse der ps auxdurch grepAuch die Verarbeitung machen würde / schnelle und einfache Suche. Ich bin sicher, dass Sie auch für Windows etwas Ähnliches finden können.

Das folgende Programm ist nur mit der Java 9+ Version kompatibel ...

Um die CurrentProcess-Informationen abzurufen,

public class CurrentProcess {
    public static void main(String[] args) {
        ProcessHandle handle = ProcessHandle.current();
        System.out.println("Current Running Process Id: "+handle.pid());
        ProcessHandle.Info info = handle.info();
        System.out.println("ProcessHandle.Info : "+info);
    }
}

Für alle laufenden Prozesse

import java.util.List;
import java.util.stream.Collectors;

public class AllProcesses {
    public static void main(String[] args) {
        ProcessHandle.allProcesses().forEach(processHandle -> {
            System.out.println(processHandle.pid()+" "+processHandle.info());
        });
    }
}

    String line;
    Process process = Runtime.getRuntime().exec("ps -e");
    process.getOutputStream().close();
    BufferedReader input =
            new BufferedReader(new InputStreamReader(process.getInputStream()));
    while ((line = input.readLine()) != null) {
        System.out.println(line); //<-- Parse data here.
    }
    input.close();

Wir müssen verwenden, process.getOutputStream.close()sonst wird es in while-Schleife gesperrt.

package com.vipul;

import java.applet.Applet;
import java.awt.Checkbox;
import java.awt.Choice;
import java.awt.Font;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;

public class BatchExecuteService extends Applet {
    public Choice choice;

    public void init() 
    {
        setFont(new Font("Helvetica", Font.BOLD, 36));
        choice = new Choice();
    }

    public static void main(String[] args) {
        BatchExecuteService batchExecuteService = new BatchExecuteService();
        batchExecuteService.run();
    }

    List<String> processList = new ArrayList<String>();

    public void run() {
        try {
            Runtime runtime = Runtime.getRuntime();
            Process process = runtime.exec("D:\\server.bat");
            process.getOutputStream().close();
            InputStream inputStream = process.getInputStream();
            InputStreamReader inputstreamreader = new InputStreamReader(
                    inputStream);
            BufferedReader bufferedrReader = new BufferedReader(
                    inputstreamreader);
            BufferedReader bufferedrReader1 = new BufferedReader(
                    inputstreamreader);

            String strLine = "";
            String x[]=new String[100];
            int i=0;
            int t=0;
            while ((strLine = bufferedrReader.readLine()) != null) 
            {
        //      System.out.println(strLine);
                String[] a=strLine.split(",");
                x[i++]=a[0];
            }
    //      System.out.println("Length : "+i);

            for(int j=2;j<i;j++)
            {
                System.out.println(x[j]);
            }
        }
        catch (IOException ioException) 
        {
            ioException.printStackTrace();
        }

    }
}

   You can create batch file like 

AUFGABENLISTE / v / FI "STATUS eq läuft" / FO "CSV" / FI "Benutzername eq LHPL002 \ soft" / FI "MEMUSAGE gt 10000" / FI "Fenstertitel ne N / A" / NH

Dies ist mein Code für eine Funktion, die die Aufgaben und ihre Namen abruft und sie auch zu einer Liste hinzufügt, auf die über eine Liste zugegriffen werden kann. Es erstellt temporäre Dateien mit den Daten, liest die Dateien und erhält den Aufgabennamen mit dem Suffix .exe und ordnet die zu löschenden Dateien an, wenn das Programm mit System.exit (0) beendet wurde. Außerdem werden die verwendeten Prozesse ausgeblendet Holen Sie sich die Aufgaben und auch java.exe, damit der Benutzer den Prozess, der das Programm insgesamt ausführt, nicht versehentlich beenden kann.

private static final DefaultListModel tasks = new DefaultListModel();

public static void getTasks()
{
    new Thread()
    {
        @Override
        public void run()
        {
            try 
            {
                File batchFile = File.createTempFile("batchFile", ".bat");
                File logFile = File.createTempFile("log", ".txt");
                String logFilePath = logFile.getAbsolutePath();
                try (PrintWriter fileCreator = new PrintWriter(batchFile)) 
                {
                    String[] linesToPrint = {"@echo off", "tasklist.exe >>" + logFilePath, "exit"};
                    for(String string:linesToPrint)
                    {
                        fileCreator.println(string);
                    }
                    fileCreator.close();
                }
                int task = Runtime.getRuntime().exec(batchFile.getAbsolutePath()).waitFor();
                if(task == 0)
                {
                    FileReader fileOpener = new FileReader(logFile);
                    try (BufferedReader reader = new BufferedReader(fileOpener))
                    {
                        String line;
                        while(true)
                        {
                            line = reader.readLine();
                            if(line != null)
                            {
                                if(line.endsWith("K"))
                                {
                                    if(line.contains(".exe"))
                                    {
                                        int index = line.lastIndexOf(".exe", line.length());
                                        String taskName = line.substring(0, index + 4);
                                        if(! taskName.equals("tasklist.exe") && ! taskName.equals("cmd.exe") && ! taskName.equals("java.exe"))
                                        {
                                            tasks.addElement(taskName);
                                        }
                                    }
                                }
                            }
                            else
                            {
                                reader.close();
                                break;
                            }
                        }
                    }
                }
                batchFile.deleteOnExit();
                logFile.deleteOnExit();
            } 
            catch (FileNotFoundException ex) 
            {
                Logger.getLogger(Functions.class.getName()).log(Level.SEVERE, null, ex);
            } 
            catch (IOException | InterruptedException ex) 
            {
                Logger.getLogger(Functions.class.getName()).log(Level.SEVERE, null, ex);
            }
            catch (NullPointerException ex)
            {
                // This stops errors from being thrown on an empty line
            }
        }
    }.start();
}

public static void killTask(String taskName)
{
    new Thread()
    {
        @Override
        public void run()
        {
            try 
            {
                Runtime.getRuntime().exec("taskkill.exe /IM " + taskName);
            } 
            catch (IOException ex) 
            {
                Logger.getLogger(Functions.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    }.start();
}