Die Beispiele in diesem Artikel beschreiben, wie Sie Java als Windows-Dienstprogramm und einen einfachen Java-Programmcode zum geplanten Herunterfahren registrieren und ihn Ihnen als Referenz zur Verfügung stellen. Die spezifische Methode ist wie folgt:
1. Frage:
Ich wollte vor kurzem eine Software finden, mit der sich die Abschaltzeit des Computers steuern lässt, und habe im Internet einige davon gefunden. Es handelte sich dabei alles um Software mit visuellen Schnittstellen, die bestimmte Abschaltzeiten festlegen konnten. Da das Shutdown-Programm, das ich schreiben möchte, auf dem Computer einer anderen Person ausgeführt wird, kann der Computer nur von 17:00 bis 23:25 Uhr abends auf das Internet zugreifen und um 23:25 Uhr automatisch heruntergefahren werden. Um zu verhindern, dass andere die „Existenz“ dieser Software spüren (um zu verhindern, dass Benutzer die Software zum geplanten Herunterfahren selbst schließen), möchte ich die Software zum Herunterfahren als Dienst registrieren und im Hintergrund ausführen. Hier finden Sie eine Einführung in die Verwendung der javaService-Software zum Registrieren eines Java-Programms als Windows-Dienst.
2. Implementierungsmethode:
1. Verwenden Sie javaService, um das Java-Programm als Windows-Dienst zu registrieren
① Laden Sie javaService herunter
Besuchen Sie die URL http://javaservice.objectweb.org/, um die Windows-Version der javaService-Datei herunterzuladen. Die neueste Version ist „2.0.10“.
② Installieren Sie javaService
Entpacken Sie die von uns heruntergeladenen JavaServices in ein Verzeichnis. Ich habe sie in das Verzeichnis „D:/software/JavaService-2.0.10“ entpackt (Sie können sie in jedes beliebige Verzeichnis entpacken. Es ist am besten, sie nicht in ein chinesisches Verzeichnis zu entpacken, um Probleme zu vermeiden )
③ Schreiben Sie den Code für das geplante Herunterfahren
1) Der Name der Klasse lautet:
com.test.timer.TimerShutDownWindows
2) Exportieren Sie die geschriebene Java-Datei als Klasse und legen Sie die exportierte Klasse im Verzeichnis „D:/software/JavaService-2.0.10/classes/com/test/timer“ ab. Das heißt, legen Sie das exportierte COM-Paket im Verzeichnis „D:/software/JavaService-2.0.10/classes“ ab.
④ Um das Java-Programm als Windows-Dienst zu registrieren, geben Sie das Verzeichnis „D:/software/JavaService-2.0.10“ ein und führen Sie den folgenden Befehl aus:
Kopieren Sie den Code wie folgt: JavaService.exe -install MyShutDownService "%JAVA_HOME%"/jre/bin/server/jvm.dll -Djava.class.path="%JAVA_HOME%"/lib/tools.jar;D:/software / JavaService-2.0.10/classes -start com.test.timer.TimerShutDownWindows
Der Parameter nach „-install“ ist der Name des Dienstes, der Parameter nach „-start“ ist der Name der zu startenden Klasse und der Parameter nach „Djava.class.path“ ist „D:/software/JavaService“. -2.0.10/classe“ „Die Adresse ist der Pfad, in dem meine „TimerShutDownWindows“-Klasse gespeichert ist. In tatsächlichen Anwendungen ändern Sie ihn einfach in Ihren eigenen Klassenpfad.
Hier sind einige Punkte zu beachten:
1) JDK-Verzeichnis „%JAVA_HOME%“. Wenn das JDK-Verzeichnis nicht konfiguriert ist, ersetzen Sie es durch die tatsächliche absolute Adresse des JDK.
2) -Djava.class.path ist erforderlich, da beim Starten des Dienstes nicht auf die CLASSPATH-Variable des Systems zugegriffen werden kann. Wenn viele JARs vorhanden sind, können wir „-Djava“ verwenden, um das Schreiben zu langer Befehle zu vermeiden . ext.dirs=das Verzeichnis, in dem sich jars befindet“ Parameter.
3) Nachdem der Dienst hinzugefügt wurde, können Sie den Befehl „services.msc“ in der Befehlszeile eingeben, um alle Dienste anzuzeigen und den Starttyp des Dienstes zu ändern (automatischer Start oder manueller Start usw.).
⑤ Test
1) Starten Sie den Dienst
Nachdem wir den Dienst registriert haben, können wir den Dienst über den Befehl „net start MyShutDownService“ starten. Nach dem Start des Dienstes wird die Protokolldatei my_shutdown.log im Stammverzeichnis des Laufwerks D generiert.
2) Schließen Sie den Dienst
Wenn wir den Dienst herunterfahren möchten, können wir den Dienst mit dem Befehl „net stop MyShutDownService“ herunterfahren.
3) Dienst löschen
Wenn wir den Dienst löschen möchten, können wir den Befehl „sc delete MyShutDownService“ verwenden, um den Dienst zu löschen.
2. Geplanter Abschaltcode
Kopieren Sie den Code wie folgt: package com.test.timer;
java.io.File importieren;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
öffentliche Klasse TimerShutDownWindows {
/* Zeitintervall zur Erkennung, ob ein Herunterfahren erforderlich ist*/
private static long m_nDetectInterval = 5000;
/* Zeichnet die Zeit der letzten Erkennung in Millisekunden auf */
private static long m_lLastMilliSeconds = 0;
/* Mindeststunden, die der Computer verwendet werden kann */
private static int m_nUsePCMinHour = 17;
/* Die maximale Anzahl an Stunden, die der Computer verwendet werden kann */
private static int m_nUseComputerMaxHour = 23;
/* Wenn die Minuten diese Zeit überschreiten, fahren Sie den Computer herunter */
private static int m_nMinutes = 25;
/* Der Speicherort der Protokolldatei */
privater statischer String m_sLogFile = „D:“ + File.separator
+ "my_shutdown.log";
/* Aufzeichnen, ob das aktuelle System das Programm zum automatischen Herunterfahren gestartet hat*/
privater statischer boolescher Wert bHasShutDownPC = false;
/**
* @param args
*/
public static void main(String[] args) {
// 1. Starten Sie einen separaten Thread zur Erkennung
Thread aThread = new Thread(new TimerDetector());
aThread.start();
}
/**
* Innere Klasse definieren
*
* @author-Administrator
*
*/
Die statische Klasse TimerDetector implementiert Runnable {
/*
* (nicht Javadoc)
*
* @see java.lang.Runnable#run()
*/
public void run() {
// 1. Holen Sie sich die Protokolldatei
PrintWriter out = null;
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
versuchen {
out = new PrintWriter(new FileWriter(m_sLogFile, true), true);
} Catch (IOException e1) {
out = null;
e1.printStackTrace();
}
// 2. Startzeit des Dienstes aufzeichnen
appendLog(out, "Startzeit des Dienstes:" + df.format(new Date()));
while (wahr) {
// 1. Bestimmen Sie, ob die aktuelle Systemzeit geändert wurde
boolean bShoudShutDownPC = validierenShoudShutDownPC(out);
if (bShoudShutDownPC) {
// Überprüfung fehlgeschlagen, erzwungenes Herunterfahren
executeShutDown(out);
} anders {
bHasShutDownPC = false;
}
// 2. Der aktuelle Thread schläft
versuchen {
Thread.sleep(m_nDetectInterval);
} Catch (InterruptedException e) {
appendLog(out, e.getMessage());
}
}
}
/**
* Überprüfen Sie, ob die aktuelle Zeit die Zeit ist, die heruntergefahren werden muss
*
* @zurückkehren
*/
privater boolescher Wert validierenShoudShutDownPC(PrintWriter _out) {
// 1. Bestimmen Sie, ob die Systemzeit geändert wurde
boolean bHasModifySystemTime = discoverModifySytemTime(_out);
appendLog(_out, "bHasModifySystemTime:" + bHasModifySystemTime);
if (bHasModifySystemTime) {
return bHasModifySystemTime;
}
// 2. Wenn die Systemzeit nicht geändert wurde, ermitteln Sie, ob die aktuelle Zeit die angegebene Zeit überschreitet.
boolean bShoudSleep = nowIsSleepTime();
appendLog(_out, "bShoudSleep:" + bShoudSleep);
if (bShoudSleep) {
return bShoudSleep;
}
return false;
}
/**
* Bestimmen Sie, ob die aktuelle Zeit eine Ruhezeit sein soll
*
* @zurückkehren
*/
privater boolescher Wert nowIsSleepTime() {
// 1. Aktuelle Stunde und Minute abrufen
Kalender aCalendar = Calendar.getInstance();
int nHour = aCalendar.get(Calendar.HOUR_OF_DAY);
int nMinute = aCalendar.get(Calendar.MINUTE);
// 2. Bestimmen Sie, ob die aktuelle Stunde innerhalb der Zeit liegt, in der der PC verwendet werden kann. Die maximale Stunde beträgt 23
if (nHour < m_nUsePCMinHour) {
return true;
}
// 23 Uhr muss individuell beurteilt werden und nach 23:30 Uhr sollte eine Pause eingelegt werden
if ((nHour >= m_nUseComputerMaxHour) && (nMinute >= m_nMinutes)) {
return true;
}
// 3. Nicht-Ruhezeit
return false;
}
/**
* Stellen Sie fest, ob jemand die Systemzeit geändert hat. Geben Sie true zurück, <BR>
* Andernfalls wird false zurückgegeben
*
* @zurückkehren
*/
privater boolescher Wert discoverModifySytemTime(PrintWriter _out) {
// 1. Systemzeit zum ersten Mal ermitteln
if (m_lLastMilliSeconds == 0) {
m_lLastMilliSeconds = System.currentTimeMillis();
return false;
}
// 2. Ermitteln Sie den Unterschied zwischen zwei Zeiten
long lInteral = System.currentTimeMillis() - m_lLastMilliSeconds;
lInteral = Math.abs(lInteral);
// 3. Bestimmen Sie das Zeitintervall zwischen zwei Zeiten. Die beiden Ergebnisse sind möglicherweise nicht genau gleich m_nDetectInterval. Der zulässige Fehler beträgt 1 Minute.
long lMaxInterval = m_nDetectInterval + 60 * 1000;
appendLog(_out, "lInteral:::" + lInteral);
appendLog(_out, "lMaxInterval:::" + lMaxInterval);
if (lInteral > lMaxInterval) {
// Jemand hat die Systemzeit geändert und das Herunterfahren erzwungen
return true;
}
// 4. Die letzte Erkennungszeit wird nur aufgezeichnet, wenn niemand die Zeit ändert.
m_lLastMilliSeconds = System.currentTimeMillis();
return false;
}
/**
* Protokollinformationen in den angegebenen Stream schreiben
*
* @param _outWriter
* @param _sAppendContent
*/
private void appendLog(PrintWriter _outWriter, String _sAppendContent) {
if (_outWriter == null) {
zurückkehren;
}
_outWriter.println(_sAppendContent);
}
/**
* Befehl zum Herunterfahren ausführen
*/
private voidexecuteShutDown(PrintWriter _out) {
if (bHasShutDownPC) {
SimpleDateFormat df = new SimpleDateFormat(
„yyyy-MM-dd HH:mm:ss“);
appendLog(_out, „Das System steht kurz vor dem Herunterfahren, aktuelle Zeit:“ + df.format(new Date()));
zurückkehren;
}
appendLog(_out, „Jemand hat die Systemzeit geändert und das System musste heruntergefahren werden!“);
// Abschalten
versuchen {
Runtime.getRuntime().exec(
„shutdown -s -t 120 -c /“ Es ist sehr spät, es ist Zeit, ins Bett zu gehen, den Computer nach 2 Minuten herunterzufahren. /"");
} Catch (IOException e) {
appendLog(_out, e.getMessage());
}
bHasShutDownPC = true;
}
}
}
Ich hoffe, dass dieser Artikel für die Java-Programmierung aller hilfreich sein wird.