Os exemplos neste artigo descrevem como registrar o Java como um programa de serviço do Windows e um código simples de programa de desligamento agendado do Java e compartilhá-lo com você para sua referência. O método específico é o seguinte:
1. Pergunta:
Recentemente, quis encontrar um software para controlar o tempo de desligamento do computador e encontrei alguns na Internet. Todos eram softwares com interfaces visuais que podiam definir tempos de desligamento específicos. Como o programa de desligamento que desejo escrever é executado na máquina de outra pessoa, a máquina só pode acessar a Internet das 17h00 às 23h25 da noite e pode desligar automaticamente às 23h25. Para evitar que outras pessoas sintam a "existência" deste software (para evitar que os próprios usuários fechem o software de desligamento programado), desejo registrar o software de desligamento como um serviço e executá-lo em segundo plano. Aqui está uma introdução sobre como usar o software javaService para registrar um programa java como um serviço do Windows.
2. Método de implementação:
1. Use javaService para registrar o programa java como um serviço do Windows
① Baixar javaService
Visite o URL http://javaservice.objectweb.org/ para baixar a versão Windows do arquivo javaService. Baixei JavaService-2.0.10.rar.
② Instale javaService
Descompacte os javaServices que baixamos em um diretório. Descompactei-os no diretório "D:/software/JavaService-2.0.10" (você pode descompactá-los em qualquer diretório. É melhor não descompactá-los em um diretório chinês para evitar problemas). )
③ Escreva o código de desligamento programado
1) O nome da turma é:
com.test.timer.TimerShutDownWindows
2) Exporte o arquivo java escrito como uma classe e coloque a classe exportada no diretório "D:/software/JavaService-2.0.10/classes/com/test/timer". Ou seja, coloque o pacote com exportado no diretório "D:/software/JavaService-2.0.10/classes".
④ Para registrar o programa java como um serviço do Windows, entre no diretório "D:/software/JavaService-2.0.10" e execute o seguinte comando:
Copie o código da seguinte forma: 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
O parâmetro após "-install" é o nome do serviço, o parâmetro após "-start" é o nome da classe a ser iniciada e o parâmetro após "Djava.class.path" é "D:/software/JavaService -2.0.10/classe" "O endereço é o caminho onde minha classe "TimerShutDownWindows" está armazenada. Em aplicativos reais, basta alterá-lo para seu próprio classPath.
Existem alguns pontos a serem observados aqui:
1) Diretório jdk "%JAVA_HOME%", se o diretório jdk não estiver configurado, substitua-o pelo endereço absoluto real do jdk.
2) -Djava.class.path é necessário porque a variável CLASSPATH do sistema não pode ser acessada quando o serviço é iniciado, portanto deve ser declarada aqui se houver muitos jars, para evitar escrever comandos muito longos, podemos usar "-Djava; .ext.dirs=o diretório onde os jars estão localizados".
3) Após a adição do serviço, você pode digitar o comando "services.msc" na linha de comando para visualizar todos os serviços e modificar o tipo de inicialização do serviço (inicialização automática ou inicialização manual, etc.).
⑤ Teste
1) Inicie o serviço
Após registrar o serviço, podemos iniciá-lo através do comando "net start MyShutDownService". Após o serviço ser iniciado, o arquivo de log my_shutdown.log será gerado no diretório raiz da unidade D.
2) Feche o serviço
Se quisermos encerrar o serviço, podemos encerrar o serviço pelo comando "net stop MyShutDownService".
3) Excluir serviço
Quando quisermos excluir o serviço, podemos usar o comando “sc delete MyShutDownService” para excluir o serviço.
2. Código de desligamento programado
Copie o código da seguinte forma: package 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.Date;
classe pública TimerShutDownWindows {
/* Intervalo de tempo para detectar se o desligamento é necessário*/
privado estático longo m_nDetectInterval = 5000;
/* Registra o tempo da última detecção, em milissegundos */
privado estático longo m_lLastMilliSeconds = 0;
/* Mínimo de horas que o computador pode ser usado */
privado estático int m_nUsePCMinHour = 17;
/* O número máximo de horas que o computador pode ser usado */
private static int m_nUseComputerMaxHour = 23;
/* Se os minutos excederem esse tempo, desligue o computador */
private static int m_nMinutes = 25;
/* O local de armazenamento do arquivo de log */
String estática privada m_sLogFile = "D:" + File.separator
+ "meu_desligamento.log";
/* Registra se o sistema atual iniciou o programa de desligamento automático*/
privado estático booleano bHasShutDownPC = false;
/**
* @param argumentos
*/
public static void main(String[] args) {
// 1. Inicie um thread separado para detectar
Thread aThread = new Thread(new TimerDetector());
aThread.start();
}
/**
* Definir classe interna
*
* @autor Administrador
*
*/
classe estática TimerDetector implementa Runnable {
/*
* (não Javadoc)
*
* @veja java.lang.Runnable#run()
*/
execução void pública() {
// 1. Obtenha o arquivo de log
PrintWriter fora = null;
SimpleDateFormat df = new SimpleDateFormat("aaaa-MM-dd HH:mm:ss");
tentar {
out = new PrintWriter(new FileWriter(m_sLogFile, true), true);
} catch (IOException e1) {
fora = nulo;
e1.printStackTrace();
}
// 2. Registrar o tempo de inicialização do serviço
appendLog(out, "Tempo de inicialização do serviço:" + df.format(new Date()));
enquanto (verdadeiro) {
// 1. Determine se a hora atual do sistema foi modificada
booleano bShoudShutDownPC = validarShoudShutDownPC(out);
if (bShoudShutDownPC) {
//Falha na verificação, desligamento forçado
executeShutDown(fora);
} outro {
bHasShutDownPC = falso;
}
// 2. O thread atual dorme
tentar {
Thread.sleep(m_nDetectInterval);
} catch (InterruptedException e) {
anexarLog(out, e.getMessage());
}
}
}
/**
* Verifique se a hora atual é a hora que precisa ser desligada
*
* @retornar
*/
private booleano validarShoudShutDownPC(PrintWriter _out) {
// 1. Determine se a hora do sistema foi modificada
booleano bHasModifySystemTime = detectModifySytemTime(_out);
appendLog(_out, "bHasModifySystemTime:" + bHasModifySystemTime);
if (bHasModifySystemTime) {
retornar bHasModifySystemTime;
}
// 2. Se a hora do sistema não tiver sido modificada, determine se a hora atual excede a hora especificada.
booleano bShoudSleep = nowIsSleepTime();
appendLog(_out, "bShoudSleep:" + bShoudSleep);
if (bShoudSleep) {
retornar bShoudSleep;
}
retornar falso;
}
/**
* Determine se o horário atual deve ser um horário de descanso
*
* @retornar
*/
privado booleano nowIsSleepTime() {
// 1. Obtenha a hora e os minutos atuais
Calendário aCalendar = Calendar.getInstance();
int nHour = aCalendar.get(Calendar.HOUR_OF_DAY);
int nMinuto = aCalendário.get(Calendário.MINUTE);
// 2. Determine se a hora atual está dentro do horário em que o PC pode ser usado, a hora máxima é 23
if (nHora < m_nUsePCMinHour) {
retornar verdadeiro;
}
// 23h precisa ser julgado individualmente, e você deve fazer uma pausa depois das 23h30
if ((nHour >= m_nUseComputerMaxHour) && (nMinute >= m_nMinutes)) {
retornar verdadeiro;
}
// 3. Tempo sem descanso
retornar falso;
}
/**
* Determine se alguém modificou a hora do sistema. Se alguém modificou a hora do sistema, retorne verdadeiro, <BR>.
* Caso contrário retorne falso
*
* @retornar
*/
privado booleano detectModifySytemTime(PrintWriter _out) {
// 1. Detecta a hora do sistema pela primeira vez
if (m_lÚltimosMiliSeconds == 0) {
m_lLastMilliSeconds = System.currentTimeMillis();
retornar falso;
}
// 2. Detecte a diferença entre dois tempos
longo lInteral = System.currentTimeMillis() - m_lLastMilliSeconds;
lInteral = Math.abs(lInteral);
// 3. Determine o intervalo de tempo entre dois tempos. Os dois resultados podem não ser exatamente iguais a m_nDetectInterval. O erro permitido é de 1 minuto.
longo lMaxInterval = m_nDetectInterval + 60 * 1000;
appendLog(_out, "lInteral:::" + lInteral);
appendLog(_out, "lMaxInterval:::" + lMaxInterval);
if (lInteral > lMaxInterval) {
//Alguém modificou a hora do sistema e forçou o desligamento
retornar verdadeiro;
}
// 4. O último horário de detecção é registrado somente se ninguém modificar o horário.
m_lLastMilliSeconds = System.currentTimeMillis();
retornar falso;
}
/**
* Escreva informações de log no fluxo especificado
*
* @param _outWriter
* @param _sAppendContent
*/
private void appendLog(PrintWriter _outWriter, String _sAppendContent) {
if (_outWriter == nulo) {
retornar;
}
_outWriter.println(_sAppendContent);
}
/**
* Executar comando de desligamento
*/
private void executeShutDown(PrintWriter _out) {
if (bHasShutDownPC) {
SimpleDateFormat df = new SimpleDateFormat(
"aaaa-MM-dd HH:mm:ss");
appendLog(_out, "O sistema está prestes a desligar, hora atual: " + df.format(new Date()));
retornar;
}
appendLog(_out, "Alguém modificou a hora do sistema e o sistema foi forçado a desligar!");
// Desligar
tentar {
Runtime.getRuntime().exec(
"shutdown -s -t 120 -c /" É muito tarde, é hora de ir para a cama, desligue o computador depois de 2 minutos. /"");
} catch (IOException e) {
anexarLog(_out, e.getMessage());
}
bHasShutDownPC = verdadeiro;
}
}
}
Espero que este artigo seja útil para a programação Java de todos.