Los ejemplos de este artículo describen cómo registrar Java como un programa de servicio de Windows y un código simple de programa de apagado programado de Java, y lo comparten con usted para su referencia. El método específico es el siguiente:
1. Pregunta:
Recientemente quise encontrar un software para controlar el tiempo de apagado de la computadora y encontré algunos en Internet. Todos eran programas con interfaces visuales que podían establecer tiempos de apagado específicos. Dado que el programa de apagado que quiero escribir se ejecuta en la máquina de otra persona, la máquina solo puede acceder a Internet de 17:00 a 23:25 de la noche y puede apagarse automáticamente a las 23:25. Para evitar que otros sientan la "existencia" de este software (para evitar que los usuarios cierren ellos mismos el software de apagado programado), quiero registrar el software de apagado como un servicio y ejecutarlo en segundo plano. A continuación se ofrece una introducción sobre cómo utilizar el software javaService para registrar un programa Java como servicio de Windows.
2. Método de implementación:
1. Utilice javaService para registrar el programa Java como un servicio de Windows.
① Descargar javaService
Visite la URL http://javaservice.objectweb.org/ para descargar la versión de Windows del archivo javaService. Descargué JavaService-2.0.10.rar. La última versión es "2.0.10".
② Instalar javaService
Descomprima los javaServices que descargamos en un directorio. Lo descomprimí en el directorio "D:/software/JavaService-2.0.10" (puede descomprimirlo en cualquier directorio. Es mejor no descomprimirlo en un directorio chino para evitar problemas). )
③ Escriba el código de apagado programado
1) El nombre de la clase es:
com.test.timer.TimerShutDownWindows
2) Exporte el archivo Java escrito como una clase y coloque la clase exportada en el directorio "D:/software/JavaService-2.0.10/classes/com/test/timer". Es decir, coloque el paquete com exportado en el directorio "D:/software/JavaService-2.0.10/classes".
④ Para registrar el programa java como servicio de Windows, ingrese al directorio "D:/software/JavaService-2.0.10" y ejecute el siguiente comando:
Copie el código de la siguiente manera: 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
El parámetro después de "-install" es el nombre del servicio, el parámetro después de "-start" es el nombre de la clase que se iniciará y el parámetro después de "Djava.class.path" es "D:/software/JavaService -2.0.10/classe" "La dirección es la ruta donde está almacenada mi clase "TimerShutDownWindows" En aplicaciones reales, simplemente cámbiela a su propia classPath.
Hay algunos puntos a tener en cuenta aquí:
1) Directorio jdk "%JAVA_HOME%", si el directorio jdk no está configurado, reemplácelo con la dirección absoluta real del jdk.
2) -Djava.class.path es necesario porque no se puede acceder a la variable CLASSPATH del sistema cuando se inicia el servicio, por lo que debe declararse aquí si hay muchos archivos jar, para evitar escribir comandos demasiado largos, podemos usar "-Djava; .ext.dirs=el directorio donde se encuentran los archivos jar".
3) Una vez agregado el servicio, puede escribir el comando "services.msc" en la línea de comando para ver todos los servicios y modificar el tipo de inicio del servicio (inicio automático o inicio manual, etc.).
⑤ Prueba
1) Iniciar el servicio
Después de registrar el servicio, podemos iniciarlo mediante el comando "net start MyShutDownService". Una vez iniciado el servicio, se generará el archivo de registro my_shutdown.log en el directorio raíz de la unidad D.
2) Cerrar el servicio
Si queremos cerrar el servicio, podemos cerrarlo mediante el comando "net stop MyShutDownService".
3) Eliminar servicio
Cuando queramos eliminar el servicio, podemos usar el comando "sc eliminar MyShutDownService" para eliminar el servicio.
2. Código de apagado programado
Copie el código de la siguiente manera: paquete com.test.timer;
importar java.io.File;
importar java.io.FileWriter;
importar java.io.IOException;
importar java.io.PrintWriter;
importar java.text.SimpleDateFormat;
importar java.util.Calendar;
importar java.util.Fecha;
clase pública TimerShutDownWindows {
/* Intervalo de tiempo para detectar si es necesario apagar*/
privado estático largo m_nDetectInterval = 5000;
/* Registra la hora de la última detección, en milisegundos */
privado estático largo m_lLastMilliSeconds = 0;
/* Horas mínimas que se puede utilizar la computadora */
privado estático int m_nUsePCMinHour = 17;
/* El número máximo de horas que se puede utilizar la computadora */
privado estático int m_nUseComputerMaxHour = 23;
/* Si los minutos exceden este tiempo, apaga la computadora */
privado estático int m_nMinutes = 25;
/* La ubicación de almacenamiento del archivo de registro */
Cadena estática privada m_sLogFile = "D:" + Archivo.separador
+ "mi_apagado.log";
/* Registra si el sistema actual ha iniciado el programa de apagado automático*/
booleano estático privado bHasShutDownPC = false;
/**
* argumentos @param
*/
público estático vacío principal (String [] argumentos) {
// 1. Iniciar un hilo separado para detectar
Hilo aThread = nuevo hilo (nuevo TimerDetector());
un hilo.start();
}
/**
* Definir clase interna
*
* @autor Administrador
*
*/
La clase estática TimerDetector implementa Runnable {
/*
* (no Javadoc)
*
* @ver java.lang.Runnable#run()
*/
ejecución pública vacía() {
// 1. Obtener el archivo de registro
PrintWriter fuera = nulo;
SimpleDateFormat df = new SimpleDateFormat("aaaa-MM-dd HH:mm:ss");
intentar {
salida = nuevo PrintWriter (nuevo FileWriter (m_sLogFile, verdadero), verdadero);
} captura (IOException e1) {
fuera = nulo;
e1.printStackTrace();
}
// 2. Registrar el tiempo de inicio del servicio
appendLog(out, "Hora de inicio del servicio:" + df.format(new Date()));
mientras (verdadero) {
// 1. Determinar si la hora actual del sistema ha sido modificada
booleano bShoudShutDownPC = validarShoudShutDownPC(fuera);
si (bShoudShutDownPC) {
// Verificación fallida, cierre forzado
ejecutarShutDown(fuera);
} demás {
bHasShutDownPC = falso;
}
// 2. El hilo actual duerme
intentar {
Thread.sleep(m_nDetectInterval);
} captura (Excepción interrumpida e) {
appendLog(fuera, e.getMessage());
}
}
}
/**
* Verifique si la hora actual es la hora en que se debe apagar
*
* @devolver
*/
validar booleano privadoShoudShutDownPC (PrintWriter _out) {
// 1. Determinar si la hora del sistema ha sido modificada
booleano bHasModifySystemTime = detectModifySytemTime(_out);
appendLog(_out, "bHasModifySystemTime:" + bHasModifySystemTime);
si (bHasModifySystemTime) {
devolver bHasModifySystemTime;
}
// 2. Si la hora del sistema no se ha modificado, determine si la hora actual excede la hora especificada.
booleano bShoudSleep = nowIsSleepTime();
appendLog(_out, "bShoudSleep:" + bShoudSleep);
si (bShoudSleep) {
volver bShoudSleep;
}
devolver falso;
}
/**
* Determinar si la hora actual debe ser un tiempo de descanso.
*
* @devolver
*/
booleano privado nowIsSleepTime() {
// 1. Obtener la hora y los minutos actuales
Calendario aCalendar = Calendar.getInstance();
int nHora = aCalendar.get(Calendar.HOUR_OF_DAY);
int nMinuto = aCalendar.get(Calendario.MINUTO);
// 2. Determine si la hora actual está dentro del horario en el que se puede utilizar la PC, la hora máxima es 23
si (nHora < m_nUsePCMinHour) {
devolver verdadero;
}
// Las 23 en punto deben juzgarse individualmente y debes tomar un descanso después de las 23:30
if ((nHora >= m_nUseComputerMaxHour) && (nMinuto >= m_nMinutos)) {
devolver verdadero;
}
// 3. Tiempo sin descanso
devolver falso;
}
/**
* Determinar si alguien ha modificado la hora del sistema. Si alguien ha modificado la hora del sistema, devuelve verdadero, <BR>.
* De lo contrario devolverá falso
*
* @devolver
*/
detectModifySytemTime booleano privado (PrintWriter _out) {
// 1. Detecta la hora del sistema por primera vez
si (m_lLastMilliSeconds == 0) {
m_lLastMilliSeconds = System.currentTimeMillis();
devolver falso;
}
// 2. Detectar la diferencia entre dos tiempos
long lInteral = System.currentTimeMillis() - m_lLastMilliSeconds;
lInteral = Math.abs(lInteral);
// 3. Determine el intervalo de tiempo entre dos tiempos. Los dos resultados pueden no ser exactamente iguales a m_nDetectInterval. El error permitido es 1 minuto.
largo lMaxInterval = m_nDetectInterval + 60 * 1000;
appendLog(_out, "lInteral:::" + lInteral);
appendLog(_out, "lMaxInterval:::" + lMaxInterval);
si (lInteral > lMaxInterval) {
// Alguien modificó la hora del sistema y forzó el apagado
devolver verdadero;
}
// 4. La última hora de detección se registra solo si nadie modifica la hora.
m_lLastMilliSeconds = System.currentTimeMillis();
devolver falso;
}
/**
* Escribir información de registro en la secuencia especificada
*
* @param _outWriter
* @param _sAppendContent
*/
appendLog vacío privado (PrintWriter _outWriter, String _sAppendContent) {
si (_outWriter == nulo) {
devolver;
}
_outWriter.println(_sAppendContent);
}
/**
* Ejecutar comando de apagado
*/
vacío privado ejecutarShutDown (PrintWriter _out) {
si (bHasShutDownPC) {
SimpleDateFormat df = nuevo SimpleDateFormat(
"aaaa-MM-dd HH:mm:ss");
appendLog(_out, "El sistema está a punto de apagarse, hora actual: " + df.format(new Date()));
devolver;
}
appendLog(_out, "¡Alguien modificó la hora del sistema y el sistema se vio obligado a apagarse!");
// Cerrar
intentar {
Runtime.getRuntime().exec(
"shutdown -s -t 120 -c /" Es muy tarde, es hora de irse a la cama, apaga la computadora después de 2 minutos. /"");
} captura (IOException e) {
appendLog(_out, e.getMessage());
}
bHasShutDownPC = verdadero;
}
}
}
Espero que este artículo sea útil para la programación Java de todos.