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

StackOverflow https://stackoverflow.com/questions/54686

  •  09-06-2019
  •  | 
  •  

Frage

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

Was ich versuche ist:Listen Sie die aktuell geöffneten Aufgaben, Fenster oder geöffneten Prozesse auf, wie im Windows-Taskmanager, verwenden Sie jedoch einen plattformübergreifenden Ansatz und verwenden Sie nach Möglichkeit nur Java.

War es hilfreich?

Lösung

Dies ist ein weiterer Ansatz, die die Prozessliste aus 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, dann sollten Sie die Zeile: "Process p = Runtime.getRun ..." etc ... (3. Zeile), für eine, die wie folgt aussieht: 

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

Hoffe, dass die Info hilft!

Andere Tipps

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

Schließlich mit Java 9+ es möglich ist, 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

Die einzige Möglichkeit, die ich denken kann, es zu tun ist durch eine Kommandozeilen-Anwendung aufgerufen wird, die die Arbeit für Sie erledigen und dann Screenscraping die Ausgabe (wie Linux ps und Fenster der Taskliste).

Leider bedeutet, dass werden Sie einige Parsing-Routinen schreiben, 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 (Yet Another Java Service Wrapper) sieht aus wie es JNA-basierte Implementierungen seiner org.rzo hat .yajsw.os.TaskList Schnittstelle für win32, linux, BSD und Solaris und ist unter LGPL Lizenz. Ich habe nicht versucht, diesen Code direkt anrufen, aber YAJSW funktioniert wirklich gut, wenn ich es in der Vergangenheit verwendet haben, so sollten Sie nicht zu viele Sorgen.

Sie können ganz einfach die Liste der laufenden Prozesse abrufen mit jProcesses 

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 Art und Weise, dies zu tun. In der Version 1.6 von Java, ein „ Desktop-“wurde hinzugefügt die tragbare Möglichkeiten des Browsing, Editing, Mailing, Öffnen und Drucken von URIs ermöglicht. Es ist möglich, diese Klasse kann ein Tag erweitert werden, um Prozesse zu unterstützen, aber ich bezweifle es.

Wenn Sie in Java-Prozesse nur neugierig sind, können Sie die java.lang.management api für immer Thread / Speicher Informationen über die JVM.

Für Fenster 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");

Code ps aux für Linux und tasklist für Fenster zu analysieren sind die besten Optionen, bis etwas allgemeinere kommt.

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

Linux können Sie die Ergebisse von ps aux durch grep Auch die Verarbeitung machen würde / die Suche schnell und einfach. Ich bin sicher, dass Sie etwas ähnliches für Fenster finden.

Dies könnte für Anwendungen mit einem gebündelten JRE nützlich sein: ich für die Ordnernamen suchen, die ich von der Anwendung renne: also, wenn Sie Anwendung ausgeführt von: 

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

, dann können Sie feststellen, ob es bereits in J9 läuft durch: 

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

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
     

TASKLIST / v / FI "STATUS eq Lauf" / FO "CSV" / FI "Benutzername eq LHPL002 \ soft" / FI "MEMUSAGE gt 10000" / FI "Window ne N / A" / NH

Dies ist mein Code für eine Funktion, die die Aufgaben und bekommt ihre Namen bekommt, auch sie in eine Liste Hinzufügen von einer Liste zugegriffen werden. Es erzeugt temporäre Dateien mit den Daten, liest die Dateien und bekommt den Namen der Aufgabe mit dem Exe-Suffix, und ordnet die Dateien gelöscht werden, wenn das Programm mit System.exit (0) verlassen hat, es verbirgt sich auch die Prozesse verwendet wird, um erhält die Aufgaben und auch java.exe, so dass der Benutzer den Prozess nicht versehentlich töten kann, die das Programm alle zusammen läuft. 

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();
}
Lizenziert unter: CC-BY-SA mit Zuschreibung
Nicht verbunden mit StackOverflow
scroll top