Les exemples de cet article décrivent comment enregistrer Java en tant que programme de service Windows et un simple code de programme d'arrêt programmé Java, et le partager avec vous pour votre référence. La méthode spécifique est la suivante :
1. Question :
J'ai récemment voulu trouver un logiciel pour contrôler l'heure d'arrêt de l'ordinateur, et j'en ai trouvé quelques-uns sur Internet. Il s'agissait tous de logiciels dotés d'interfaces visuelles permettant de définir des heures d'arrêt spécifiques. Étant donné que le programme d'arrêt que je souhaite écrire s'exécute sur la machine de quelqu'un d'autre, la machine ne peut accéder à Internet que de 17h00 à 23h25 le soir et elle peut s'arrêter automatiquement à 23h25. Afin d'empêcher les autres de ressentir "l'existence" de ce logiciel (pour empêcher les utilisateurs de fermer eux-mêmes le logiciel d'arrêt programmé), je souhaite enregistrer le logiciel d'arrêt en tant que service et l'exécuter en arrière-plan. Voici une introduction à l'utilisation du logiciel javaService pour enregistrer un programme Java en tant que service Windows.
2. Modalités de mise en œuvre :
1. Utilisez javaService pour enregistrer le programme Java en tant que service Windows
① Téléchargez javaService
Visitez l'URL http://javaservice.objectweb.org/ pour télécharger la version Windows du fichier javaService. J'ai téléchargé JavaService-2.0.10.rar. La dernière version est "2.0.10".
② Installez javaService
Décompressez les javaServices que nous avons téléchargés dans un répertoire. Je l'ai décompressé dans le répertoire "D:/software/JavaService-2.0.10" (vous pouvez le décompresser dans n'importe quel répertoire. Il est préférable de ne pas le décompresser dans un répertoire chinois pour éviter les problèmes. )
③ Écrivez le code d'arrêt programmé
1) Le nom de la classe est :
com.test.timer.TimerShutDownWindows
2) Exportez le fichier Java écrit en tant que classe et placez la classe exportée dans le répertoire "D:/software/JavaService-2.0.10/classes/com/test/timer". Autrement dit, placez le package com exporté dans le répertoire "D:/software/JavaService-2.0.10/classes".
④ Pour enregistrer le programme Java en tant que service Windows, entrez dans le répertoire « D:/software/JavaService-2.0.10 » et exécutez la commande suivante :
Copiez le code comme suit : 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
Le paramètre après "-install" est le nom du service, le paramètre après "-start" est le nom de la classe à démarrer et le paramètre après "Djava.class.path" est "D:/software/JavaService -2.0.10/classe" "L'adresse est le chemin où ma classe "TimerShutDownWindows" est stockée. Dans les applications réelles, remplacez-la simplement par votre propre classPath.
Il y a quelques points à noter ici :
1) Répertoire jdk "%JAVA_HOME%", si le répertoire jdk n'est pas configuré, remplacez-le par l'adresse absolue réelle du jdk.
2) -Djava.class.path est nécessaire car la variable CLASSPATH du système n'est pas accessible au démarrage du service, il faut donc la déclarer ici s'il y a beaucoup de jars, pour éviter d'écrire des commandes trop longues, on peut utiliser "-Djava ; . ext.dirs=le répertoire où se trouve le paramètre jars".
3) Une fois le service ajouté, vous pouvez taper la commande "services.msc" sur la ligne de commande pour afficher tous les services et modifier le type de démarrage du service (démarrage automatique ou démarrage manuel, etc.).
⑤Test
1) Démarrez le service
Après avoir enregistré le service, nous pouvons démarrer le service via la commande "net start MyShutDownService". Une fois le service démarré, le fichier journal my_shutdown.log sera généré dans le répertoire racine du lecteur D.
2) Fermez le service
Si nous voulons arrêter le service, nous pouvons arrêter le service par la commande "net stop MyShutDownService".
3) Supprimer le service
Lorsque nous voulons supprimer le service, nous pouvons utiliser la commande "sc delete MyShutDownService" pour supprimer le service.
2. Code d'arrêt programmé
Copiez le code comme suit : package com.test.timer ;
importer java.io.File ;
importer java.io.FileWriter ;
importer java.io.IOException ;
importer java.io.PrintWriter ;
importer java.text.SimpleDateFormat ;
importer java.util.Calendar ;
importer java.util.Date ;
classe publique TimerShutDownWindows {
/* Intervalle de temps pour détecter si un arrêt est requis*/
privé statique long m_nDetectInterval = 5000 ;
/* Enregistre l'heure de la dernière détection, en millisecondes */
privé statique long m_lLastMilliSeconds = 0 ;
/* Heures minimales d'utilisation de l'ordinateur */
private static int m_nUsePCMinHour = 17;
/* Le nombre maximum d'heures pendant lesquelles l'ordinateur peut être utilisé */
private static int m_nUseComputerMaxHour = 23;
/* Si les minutes dépassent ce temps, éteignez l'ordinateur */
private static int m_nMinutes = 25 ;
/* L'emplacement de stockage du fichier journal */
chaîne statique privée m_sLogFile = "D:" + File.separator
+ "mon_shutdown.log" ;
/* Enregistre si le système actuel a démarré le programme d'arrêt automatique*/
booléen statique privé bHasShutDownPC = false ;
/**
* @param arguments
*/
public static void main (String[] arguments) {
// 1. Démarrez un thread séparé pour détecter
Thread aThread = new Thread(new TimerDetector());
aThread.start();
}
/**
* Définir la classe interne
*
* @auteur Administrateur
*
*/
la classe statique TimerDetector implémente Runnable {
/*
* (non Javadoc)
*
* @voir java.lang.Runnable#run()
*/
public void run() {
// 1. Récupère le fichier journal
PrintWriter sortie = null ;
SimpleDateFormat df = new SimpleDateFormat("aaaa-MM-jj HH:mm:ss");
essayer {
out = new PrintWriter(new FileWriter(m_sLogFile, true), true);
} catch (IOException e1) {
sortie = nul ;
e1.printStackTrace();
}
// 2. Enregistrer l'heure de démarrage du service
appendLog(out, "Heure de démarrage du service :" + df.format(new Date()));
tandis que (vrai) {
// 1. Déterminer si l'heure système actuelle a été modifiée
booléen bShoudShutDownPC = validateShoudShutDownPC(out);
si (bShoudShutDownPC) {
// Échec de la vérification, arrêt forcé
exécuterShutDown(out);
} autre {
bHasShutDownPC = faux ;
}
// 2. Le thread actuel dort
essayer {
Thread.sleep(m_nDetectInterval);
} catch (InterruptedException e) {
appendLog(out, e.getMessage());
}
}
}
/**
* Vérifiez si l'heure actuelle est l'heure qui doit être arrêtée
*
* @retour
*/
booléen privé validateShoudShutDownPC (PrintWriter _out) {
// 1. Déterminer si l'heure système a été modifiée
booléen bHasModifySystemTime = detectModifySytemTime(_out);
appendLog(_out, "bHasModifySystemTime:" + bHasModifySystemTime);
si (bHasModifySystemTime) {
renvoie bHasModifySystemTime ;
}
// 2. Si l'heure système n'a pas été modifiée, déterminez si l'heure actuelle dépasse l'heure spécifiée.
booléen bShoudSleep = nowIsSleepTime();
appendLog(_out, "bShoudSleep :" + bShoudSleep);
si (bShoudSleep) {
retourner bShoudSleep ;
}
renvoie faux ;
}
/**
* Déterminer si l'heure actuelle doit être un temps de repos
*
* @retour
*/
booléen privé nowIsSleepTime() {
// 1. Obtenez l'heure et les minutes actuelles
Calendrier aCalendar = Calendar.getInstance();
int nHour = aCalendar.get(Calendar.HOUR_OF_DAY);
int nMinute = aCalendar.get(Calendar.MINUTE);
// 2. Déterminez si l'heure actuelle se situe dans l'heure à laquelle le PC peut être utilisé, l'heure maximale est de 23
si (nHour < m_nUsePCMinHour) {
renvoie vrai ;
}
// 23 heures doivent être jugées individuellement et vous devez faire une pause après 23h30
if ((nHour >= m_nUseComputerMaxHour) && (nMinute >= m_nMinutes)) {
renvoie vrai ;
}
// 3. Temps sans repos
renvoie faux ;
}
/**
* Déterminez si quelqu'un a modifié l'heure du système. Si quelqu'un a modifié l'heure du système, retournez vrai, <BR>
* Sinon, retourne faux
*
* @retour
*/
booléen privé detectModifySytemTime (PrintWriter _out) {
// 1. Détecter l'heure du système pour la première fois
si (m_lLastMilliSeconds == 0) {
m_lLastMilliSeconds = System.currentTimeMillis();
renvoie faux ;
}
// 2. Détecter la différence entre deux heures
long lInteral = System.currentTimeMillis() - m_lLastMilliSeconds;
lInteral = Math.abs(lInteral);
// 3. Déterminez l'intervalle de temps entre deux fois. Les deux résultats peuvent ne pas être exactement égaux à m_nDetectInterval L'erreur autorisée est de 1 minute.
long lMaxInterval = m_nDetectInterval + 60 * 1000 ;
appendLog(_out, "lInteral:::" + lInteral);
appendLog(_out, "lMaxInterval:::" + lMaxInterval);
si (lInteral > lMaxInterval) {
// Quelqu'un a modifié l'heure du système et forcé l'arrêt
renvoie vrai ;
}
// 4. La dernière heure de détection n'est enregistrée que si personne ne modifie l'heure.
m_lLastMilliSeconds = System.currentTimeMillis();
renvoie faux ;
}
/**
* Écrire les informations du journal dans le flux spécifié
*
* @param _outWriter
* @param _sAppendContent
*/
private void appendLog (PrintWriter _outWriter, String _sAppendContent) {
si (_outWriter == null) {
retour;
}
_outWriter.println(_sAppendContent);
}
/**
* Exécuter la commande d'arrêt
*/
private void executeShutDown (PrintWriter _out) {
si (bHasShutDownPC) {
SimpleDateFormat df = nouveau SimpleDateFormat(
"aaaa-MM-jj HH:mm:ss");
appendLog(_out, "Le système est sur le point de s'arrêter, heure actuelle : " + df.format(new Date()));
retour;
}
appendLog(_out, "Quelqu'un a modifié l'heure du système et le système a été forcé de s'arrêter !");
// Fermer
essayer {
Runtime.getRuntime().exec(
"shutdown -s -t 120 -c /" Il est très tard, il est temps d'aller au lit, éteignez l'ordinateur au bout de 2 minutes. /"");
} catch (IOException e) {
appendLog(_out, e.getMessage());
}
bHasShutDownPC = vrai ;
}
}
}
J'espère que cet article sera utile à la programmation Java de chacun.