[Java] Réglez l'heure depuis le navigateur avec jsoup

Exigences

• Dans une certaine application, l'heure tourne mal immédiatement.
• Impossible de se connecter à NTP. Le NTP en interne n'est pas non plus possible.
• Les applications sont accessibles depuis un navigateur par adresse IP.
• Vous pouvez régler l'heure manuellement à partir du navigateur.
• Près de 30 serveurs exécutant l'application sont dispersés dans tout le pays.
• Les serveurs peuvent augmenter ou diminuer à l'avenir.
• Entrez le mot de passe de connexion lors de l'exécution du lot (argument ou invite)
• Java est introduit comme standard interne. Des procédures sont nécessaires pour introduire d'autres langues.

Environnement d'exécution

• Windows8.1, 10 (principalement 8, mais probablement 10 dans le futur)
• Java 1.8 et supérieur

Environnement de développement

• Windows7
• Eclipse
• Java1.8
• jsoup 1.10.2
• gradle
• Rendre le jar exécutable à partir du fichier bat avec le plugin d'application

Code source

Lot de début d'ajustement de l'heure

• Placé sous src \ dist \

TimeAdjusterMain.bat

@echo off

rem ------------------------------------------------
rem ---Lot d'ajustement de l'heure
rem ------------------------------------------------

rem --Basé sur le répertoire actuel
cd /d %~dp0

echo ****Réglage de l'heure de début: %date% %time%

rem --Vérifiez l'argument(Ajoutez xx pour éviter qu'il ne se vide)
if xx%1==xx goto confirmPw
goto setPw



:confirmPw

rem --Entrez le mot de passe administrateur si aucun argument n'est spécifié
set /P PASSWD=Veuillez saisir le mot de passe administrateur: 

goto exec



:setPw

rem --Définir comme mot de passe administrateur si l'argument est spécifié
set PASSWD=%1

goto exec



rem --Exécution du lot de traitement
:exec

rem --Lancer l'exécution du lot de traitement
call bin\TimeAdjuster.bat %PASSWD%

echo ****Ajustement de fin d'heure: %date% %time%

rem --Restez sans terminer
pause

Liste d'adresses IP à traiter tsv

• Placé sous src \ dist \

list.tsv

10.20.30.40 abc123 ABC123 A branche B étage AB # 1
10.20.50.60 def456 DEF456 C branche D étage CD # 2

Code source Java

Main

TimeAdjusterMain.java

package jp.co.sample.timeadjuster;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import jp.co.sample.timeadjuster.bean.SettingBean;
import jp.co.sample.timeadjuster.launcher.TimeAdjusterLauncher;

public class TimeAdjusterMain {

	private static Logger logger = LoggerFactory.getLogger(TimeAdjusterMain.class);

	public static void main(String[] args) {
		logger.info("TimeAdjusterMain a démarré");

		//Informations de réglage
	    SettingBean setting;
	    try {
			// args[0]:Mot de passe administrateur
			// args[1]: src/chemin absolu du dossier dist
			setting = new SettingBean(args[0], args[1], "list.tsv");
		} catch (Exception e) {
			logger.error("Erreur d'information de réglage", e);
			return;
		}

	    //Exécution du traitement
	    TimeAdjusterLauncher launcher = new TimeAdjusterLauncher(setting);
	    try {
	    	launcher.execute();
		} catch (Exception e) {
			logger.error("Erreur de traitement de l'ajustement de l'heure", e);
			return;
		}
	}
}

Informations de réglage

SettingBean.java

package jp.co.sample.timeadjuster.bean;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.commons.csv.CSVFormat;
import org.apache.commons.csv.CSVRecord;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class SettingBean {

	public static Logger logger = LoggerFactory.getLogger(SettingBean.class);

	/**
	 *Mot de passe administrateur
	 */
	String passwd;

	/**
	 *Répertoire de référence du chemin d'exécution
	 */
	String basePath;

	/**
	 *nom de fichier tsv
	 */
	String tsvName;

	/**
	 *Liste d'informations sur le serveur
	 */
	ArrayList<ServerBean> serverList = new ArrayList<>();


	public SettingBean(String passwd, String basePath, String tsvName) throws IOException {
		this.passwd = passwd;

		this.basePath = basePath;

		logger.debug("this.basePath: "+ this.basePath);

		this.tsvName = tsvName;

		logger.debug("this.tsvName: "+ this.tsvName);

		File targetFile = new File(this.basePath, this.tsvName);
		if (!targetFile.isFile()) {
			logger.error("Veuillez spécifier un chemin de fichier existant.: "+ path);
			return;
		}

		//Lisez le dossier
		try (BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(targetFile),"UTF-8"));) {
			//Fichier séparé par TAB avec en-tête. Exclure les blancs
			Iterable<CSVRecord> records = CSVFormat.TDF.withIgnoreEmptyLines().withIgnoreSurroundingSpaces().parse(reader);
				for (CSVRecord record : records) {

					logger.debug(record.get(0));

					//Vérifiez le type d'adresse IP pour l'adresse IP du serveur.
					//Lorsque vous créez un fichier tsv avec le Bloc-notes, il commence au début?Parce qu'il entrera
					Pattern p = Pattern.compile("\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}");
					Matcher m = p.matcher(record.get(0));

					if (!m.find()) {
						throw new RuntimeException("La méthode de spécification de l'adresse IP est incorrecte. adresse IP:"+ record.get(0));
					}

					//Obtenez des informations sur le serveur et ajoutez-les à la liste
					ServerBean server = new ServerBean(m.group(), record.get(1), record.get(2), record.get(3), record.get(4), record.get(5));
					serverList.add(server);

					logger.debug("server: "+ server.getIpaddress() + " / "+ server.getSerial_no() + " / "+ server.getDevice_name());
				}
		} catch (FileNotFoundException e) {
			logger.error("Erreur de lecture du fichier TSV", e);
			throw e;
		} catch (IOException e) {
			logger.error("Erreur de lecture du fichier TSV", e);
			throw e;
		}

	}


	public String getPasswd() {
		return passwd;
	}


	public void setPasswd(String passwd) {
		this.passwd = passwd;
	}


	public String getBasePath() {
		return basePath;
	}


	public void setBasePath(String basePath) {
		this.basePath = basePath;
	}


	public String getTsvName() {
		return tsvName;
	}


	public void setTsvName(String tsvName) {
		this.tsvName = tsvName;
	}


	public ArrayList<ServerBean> getServerList() {
		return serverList;
	}


	public void setServerList(ArrayList<ServerBean> serverList) {
		this.serverList = serverList;
	}

}

Informations sur le serveur (informations lues depuis tsv)

ServerBean.java

package jp.co.sample.timeadjuster.bean;

public class ServerBean {
	/**
	 *adresse IP
	 */
	String ipaddress;

	/**
	 *nom d'hôte
	 */
	String host_name;

	/**
	 *Numéro de série
	 */
	String serial_no;

	/**
	 *Nom de base
	 */
	String base_name;


	/**
	 *Emplacement d'installation
	 */
	String installation_location;

	/**
	 *Nom de l'équipement
	 */
	String device_name;

	public ServerBean(String ipaddress, String host_name, String serial_no, String base_name,
			String installation_location, String device_name) {
		super();
		this.ipaddress = ipaddress;
		this.host_name = host_name;
		this.serial_no = serial_no;
		this.base_name = base_name;
		this.installation_location = installation_location;
		this.device_name = device_name;
	}

	public String getIpaddress() {
		return ipaddress;
	}

	public void setIpaddress(String ipaddress) {
		this.ipaddress = ipaddress;
	}

	public String getHost_name() {
		return host_name;
	}

	public void setHost_name(String host_name) {
		this.host_name = host_name;
	}

	public String getSerial_no() {
		return serial_no;
	}

	public void setSerial_no(String serial_no) {
		this.serial_no = serial_no;
	}

	public String getBase_name() {
		return base_name;
	}

	public void setBase_name(String base_name) {
		this.base_name = base_name;
	}

	public String getInstallation_location() {
		return installation_location;
	}

	public void setInstallation_location(String installation_location) {
		this.installation_location = installation_location;
	}

	public String getDevice_name() {
		return device_name;
	}

	public void setDevice_name(String device_name) {
		this.device_name = device_name;
	}

}

Processus d'ajustement du temps

TimeAdjusterLauncher.java

package jp.co.sample.timeadjuster.launcher;

import java.io.IOException;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;

import org.apache.commons.lang3.StringUtils;
import org.jsoup.Connection.Method;
import org.jsoup.Connection.Response;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import jp.co.sample.timeadjuster.bean.ServerBean;
import jp.co.sample.timeadjuster.bean.SettingBean;

public class TimeAdjusterLauncher {

	public static Logger logger = LoggerFactory.getLogger(TimeAdjusterLauncher.class);

	/**
	 *Informations de réglage
	 */
	SettingBean setting;

	/**
	 *Résultat d'affichage de l'écran de connexion
	 *Tenez les cookies, etc.
	 */
	Response loginRes;

	/**
	 *constructeur
	 *
	 * @informations de réglage de paramètre
	 */
	public TimeAdjusterLauncher(SettingBean setting) {
		super();

		//Paramètres de mise en attente
		this.setting = setting;
	}

	/**
	 *Exécuter le traitement d'ajustement du temps
	 * @throws RuntimeException
	 * @throws IOException
	 */
	public void execute() throws RuntimeException, IOException {

		//Traitement en boucle pour chaque serveur
		for (ServerBean server : setting.getServerList()) {
			logger.info("Réglage de l'heure de début****************** ");
			logger.info("Serveur cible: "+ server.getIpaddress() + " / "+ server.getDevice_name());

			//S'identifier
			login(server);

			//Vérifiez l'heure actuellement réglée
			String zone = getTimer(server);

			//Nouveau réglage de l'heure
			adjustTimer(server, zone);
		}

	}

	/**
	 *Processus de connexion
	 * @throws RuntimeException
	 * @throws IOException
	 */
	private void login(ServerBean server) throws RuntimeException, IOException {
		//Exécution du processus de connexion
		String loginUrl = "http://"+ server.getIpaddress() + "/logon.cgi";
		try {
			loginRes = Jsoup.connect(loginUrl)
				    .data("Password", setting.getPasswd())
				    .data("Mode", "Admin")
				    .data("Lang", "Japanese")
				    .method(Method.POST)
				    .execute();
		} catch (IOException e) {
			logger.error("Erreur de connexion à l'écran initial", e);
			throw e;
		}

//		logger.debug(loginRes.parse().outerHtml());

		//Correspondance d'état HTTP
		checkStatusCode(loginRes, loginUrl);


		if (StringUtils.contains(loginRes.parse().outerHtml(), "/pages/_top2.htm") ) {
			//Si l'écran d'erreur de connexion est redirigé
			//Cela signifie que la connexion de l'administrateur a échoué, donc elle s'est terminée par une erreur
			throw new RuntimeException("La connexion de l'administrateur a échoué. Il suspend le traitement.");
		}


		//Redirection après une connexion réussie
		//Traitement qui n'est pas vraiment nécessaire. Je suis juste allé pour confirmation.
		String redirectUrl = "http://"+ server.getIpaddress() + "/pages/_devadm.htm";
		Response redirectRes;
		try {
			redirectRes = Jsoup.connect(redirectUrl)
				//Définir le cookie obtenu lors de la connexion
			    .cookies(loginRes.cookies())
			    .method(Method.GET)
			    .execute();
		} catch (IOException e) {
			logger.error("Erreur de redirection de connexion à l'écran initial", e);
			throw e;
		}

//		logger.debug(redirectRes.parse().outerHtml());

		//Correspondance d'état HTTP
		checkStatusCode(redirectRes, redirectUrl);

	}

	/**
	 *Obtient l'heure actuellement définie sur le serveur
	 *
	 * @param server
	 * @throws RuntimeException
	 * @zone de retour
	 * @throws IOException
	 */
	private String getTimer(ServerBean server) throws RuntimeException, IOException {

		//Obtenez l'écran de réglage de l'heure du serveur
		String timerUrl = "http://"+ server.getIpaddress() + "/pages/ed_time.htm";
		Response timerRes;
		try {
			timerRes = Jsoup.connect(timerUrl)
					//Définir le cookie obtenu lors de la connexion
				    .cookies(loginRes.cookies())
				    .method(Method.GET)
				    .execute();
		} catch (IOException e) {
			logger.error("Erreur d'acquisition de l'écran de réglage de l'heure", e);
			throw e;
		}

		//Correspondance d'état HTTP
		checkStatusCode(timerRes, timerUrl);

//		logger.debug(timerRes.parse().outerHtml());

		Document doc = timerRes.parse();

		//Obtient l'heure actuellement définie sur le serveur.
		String year = doc.getElementsByAttributeValue("name", "DateYYYY").get(0).val();
		String month = doc.getElementsByAttributeValue("name", "DateMM").get(0).val();
		String day = doc.getElementsByAttributeValue("name", "DateDD").get(0).val();
		String hour = doc.getElementsByAttributeValue("name", "TimeHH").get(0).val();
		String minutes = doc.getElementsByAttributeValue("name", "TimeMM").get(0).val();
		String zone = doc.select("select option[selected]").get(0).val();

		logger.info("Heure actuelle du serveur: "+ year + "/"+ month + "/"+ day + " "+ hour +":"+ minutes + " ("+ zone + ")");

		//Seule la zone utilise la valeur existante, elle est donc renvoyée.
		return zone;
	}

	/**
	 *Régler l'heure.
	 *
	 * @param server
	 * @param zone
	 * @throws RuntimeException
	 * @throws IOException
	 */
	private void adjustTimer(ServerBean server, String zone) throws RuntimeException, IOException {
		//Obtient l'heure actuelle de l'environnement d'exécution.
		LocalDateTime now = LocalDateTime.now();

		logger.info("Heure actuelle: "+ now.format(DateTimeFormatter.ISO_LOCAL_DATE_TIME));

		//Obtient la synchronisation pour le prochain ajustement de l'heure pour correspondre à 0 seconde après 1 minute.
		LocalDateTime nextLdt =
		        LocalDateTime.now()
		        .plusMinutes(1)
		        .truncatedTo(ChronoUnit.MINUTES);

		logger.debug("Temps de match: "+ nextLdt.format(DateTimeFormatter.ISO_LOCAL_DATE_TIME));

		//Attendez une milliseconde
		long localDiffMsec = ChronoUnit.MILLIS.between(now, nextLdt);

		logger.debug("Attendez milliseconde jusqu'à ce que le temps corresponde: "+ localDiffMsec);

		try {
			//Attendez une milliseconde, attendez
			Thread.sleep(localDiffMsec);
		} catch (InterruptedException e) {
			logger.error("Échec de l'attente en millisecondes d'ajustement de l'heure du serveur");
		}

		logger.info("Exécution du réglage de l'heure");

		//Exécution du traitement de l'ajustement de l'heure du serveur(POST)
		//Pour une raison quelconque, cela a fonctionné sans le cookie, donc je lance juste POST
		String timerUrl = "http://"+ server.getIpaddress() + "/settime.cgi";
		Response timerRes;
		try {
			timerRes = Jsoup.connect(timerUrl)
				    .data("DateYYYY", ""+ nextLdt.getYear())
				    .data("DateMM", ""+ nextLdt.getMonthValue())
				    .data("DateDD", ""+ nextLdt.getDayOfMonth())
				    .data("TimeHH", ""+ nextLdt.getHour())
				    .data("TimeMM", ""+ nextLdt.getMinute())
				    .data("TimeZone", ""+ zone)
				    .method(Method.POST)
				    .execute();
		} catch (IOException e) {
			logger.error("Erreur de publication de l'ajustement de l'heure du serveur", e);
			throw e;
		}

//		logger.debug(timerRes.parse().outerHtml());

		//Correspondance d'état HTTP
		checkStatusCode(timerRes, timerUrl);

		logger.info("Réglage de l'heure terminé: "+ server.getIpaddress() + " / "+ server.getDevice_name() + " / " + nextLdt.format(DateTimeFormatter.ISO_LOCAL_DATE_TIME));

	}

	/**
	 *Vérification de l'état HTTP
	 *
	 * @param res
	 * @param url
	 * @throws RuntimeException
	 */
	private void checkStatusCode(Response res, String url) throws RuntimeException {

		if (res.statusCode() != 200) {
			//L'état HTTP est 200(Ordinaire)Sinon, une erreur
			throw new RuntimeException("Échec d'accès à l'URL: url="+ url + " status="+ res.statusCode());
		}
	}

}

Impressions

• Le grattage revient souvent lorsque vous dites jsoup, mais il y a aussi un tel usage.
• Le code jsoup du traitement de login-> cookie retention-> post-login n'était pas tellement en japonais, j'ai donc profité de l'occasion pour le résumer.
• La partie la plus difficile de jsoup est de découvrir quelle est l'URL lorsque le processus est réellement exécuté. Spécifié dans le formulaire, redirigé ...
• Quand j'ai touché tsv avec Notepad, un phénomène mystérieux s'est produit qui a été inséré au début, donc j'utilise une expression régulière pour obtenir l'adresse IP. Je ne peux pas spécifier d'éditeur ...
• C'est une vieille coutume de faire des haricots et de les emballer, mais de nos jours ce n'est pas comme ça ... Je dois étudier de nouvelles méthodes ^^;

J'aimerais aussi faire de mon mieux cette année. Merci beaucoup.