Comment obtenir une liste des fenêtres ouvertes/processus avec Java?
https://stackoverflow.com/questions/54686
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
Quelqu'un sais comment puis-je récupérer les fenêtres ouvertes ou le processus d'un ordinateur local à l'aide de Java?
Ce que j'essaie de faire c'est:la liste de l'actuel ouvrir une tâche, windows ou d'un processus ouvert, comme dans le gestionnaire des tâches de Windows, mais en utilisant une plate-forme multi-approche utilisant uniquement Java si c'est possible.
La solution
C'est une autre approche pour analyser la liste des processus à partir de la commande "ps -e":
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();
}
Si vous utilisez Windows, vous devez modifier la ligne:"Processus p = Runtime.getRun..." etc...(3e ligne), pour celui qui ressemble à ceci:
Process p = Runtime.getRuntime().exec
(System.getenv("windir") +"\\system32\\"+"tasklist.exe");
J'espère que l'info vous sera utile!
Autres conseils
Sur Windows il y a une alternative à l'aide 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);
}
}
Enfin, avec Java 9+, il est possible avec 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("-");
}
Sortie:
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
La seule façon que je peux penser de le faire est par l'invocation d'une application en ligne de commande qui fait le travail pour vous et puis screenscraping la sortie (comme Linux du ps et de la Fenêtre liste des tâches).
Malheureusement, ça veut dire que vous allez écrire certaines des routines d'analyse de lire les données provenant des deux.
Process proc = Runtime.getRuntime().exec ("tasklist.exe");
InputStream procOutput = proc.getInputStream ();
if (0 == proc.waitFor ()) {
// TODO scan the procOutput for your data
}
YAJSW (Encore un Autre de Java Service Wrapper) ressemble a JNA basée sur les implémentations de ses org.rzo.yajsw.os.TaskList interface pour win32, linux, bsd et solaris, et est sous licence LGPL.Je n'ai pas essayé d'appeler directement ce code, mais YAJSW fonctionne très bien lorsque je l'ai utilisé dans le passé, de sorte que vous ne devriez pas avoir trop de soucis.
Vous pouvez facilement récupérer la liste des processus en cours d'exécution à l'aide de 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("------------------");
}
Il n'existe pas de plate-forme neutre façon de le faire.Dans la version 1.6 de Java, un "Bureau"la classe a été ajouté le permet portables de navigation, d'édition, de diffusion, d'ouverture, et l'impression d'URI.Il est possible que cette classe puisse un jour être étendu pour prendre en charge les processus, mais j'en doute.
Si vous êtes seulement curieux dans les processus Java, vous pouvez utiliser le java.lang.gestion api pour obtenir thread/informations sur la mémoire de la JVM.
Pour windows j'utilise suivantes:
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");
À l'aide de code pour parser ps aux pour linux et tasklist pour windows sont vos meilleures options, jusqu'à ce que quelque chose de plus général vient le long.
Pour windows, vous pouvez faire référence à: http://www.rgagnon.com/javadetails/java-0593.html
Linux pouvez transférer les résultats de ps aux par le biais de grep trop, ce qui ferait de traitement/recherche rapide et facile.Je suis sûr que vous pouvez trouver quelque chose de similaire pour windows.
Cela peut être utile pour des applications avec un JRE groupé:Je le recherche pour le nom du dossier que je suis de l'exécution de l'application à partir de:donc, si vous êtes application est en cours d'exécution à partir de:
C:\Dev\build\SomeJavaApp\jre-9.0.1\bin\javaw.exe
ensuite, vous pouvez savoir si il est déjà en cours d'exécution dans J9, par:
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 likeTASKLIST /v /FI "STATUS eq running" /FO "CSV" /FI "nom d'utilisateur eq LHPL002\soft" /FI "MEMUSAGE gt 10000" /FI "Windowtitle ne N/A" /NH
C'est mon code pour une fonction qui récupère les tâches et reçoit leurs noms, les ajouter dans une liste pour être accessible à partir d'une liste.Il crée des fichiers temporaires avec les données, lit les fichiers et obtient le nom de la tâche avec l' .exe suffixe, et organise les fichiers à supprimer lorsque le programme s'est terminé avec le Système.exit(0), il cache également le processus utilisé pour obtenir les tâches et java.exe de sorte que l'utilisateur ne peut pas accidentellement tuer le processus qui exécute le programme, tous ensemble.
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();
}
