Vorrei implementare un'applicazione java (applicazione server) in grado di scaricare una nuova versione (file .jar) da un determinato URL e quindi aggiornarsi in fase di esecuzione.
Qual è il modo migliore per farlo ed è possibile?
Immagino che l'applicazione possa scaricare un nuovo file .jar e avviarlo. Ma come devo eseguire la consegna, ad esempio sapere quando viene avviata la nuova applicazione e quindi uscire. O c'è un modo migliore per farlo?
Risposte:
La struttura di base di una soluzione è la seguente:
C'è un ciclo principale responsabile del caricamento ripetuto dell'ultima versione dell'app (se richiesta) e del suo avvio.
L'applicazione fa il suo dovere, ma controlla periodicamente l'URL di download. Se rileva una nuova versione, torna al programma di avvio.
Ci sono diversi modi per implementarlo. Per esempio:
Il programma di avvio potrebbe essere uno script wrapper o un'applicazione binaria che avvia una nuova JVM per eseguire l'applicazione da un file JAR che viene sostituito.
Il launcher potrebbe essere un'applicazione Java che crea un classloader per il nuovo JAR, carica una classe entrypoint e chiama un metodo su di essa. Se lo fai in questo modo, devi controllare le perdite di archiviazione del classloader, ma non è difficile. (Devi solo assicurarti che nessun oggetto con classi caricate dal JAR sia raggiungibile dopo il riavvio.)
I vantaggi dell'approccio del wrapper esterno sono:
Il secondo approccio richiede due JAR, ma presenta i seguenti vantaggi:
Il modo "migliore" dipende dalle tue esigenze specifiche.
Va inoltre notato che:
Esistono rischi per la sicurezza con l'aggiornamento automatico. In generale, se il server che fornisce gli aggiornamenti è compromesso o se i meccanismi per fornire gli aggiornamenti sono suscettibili di attacchi, l'aggiornamento automatico può portare a una compromissione dei client.
Inviare un aggiornamento a un cliente che causa danni al cliente potrebbe comportare rischi legali e rischi per la reputazione della tua azienda.
Se riesci a trovare un modo per evitare di reinventare la ruota, sarebbe un bene. Vedi le altre risposte per suggerimenti.
Attualmente sto sviluppando un demone Linux JAVA e avevo anche la necessità di implementare un meccanismo di aggiornamento automatico. Volevo limitare la mia applicazione a un file jar e ho trovato una soluzione semplice:
Comprimere l'applicazione di aggiornamento nell'aggiornamento stesso.
Applicazione : quando l'applicazione rileva una versione più recente, fa quanto segue:
ApplicationUpdater : quando viene eseguito, il programma di aggiornamento esegue le seguenti operazioni:
Spero che aiuti qualcuno.
Questo è un problema noto e sconsiglio di reinventare una ruota: non scrivere il tuo hack, usa solo ciò che altre persone hanno già fatto.
Due situazioni che devi considerare:
L'app deve essere autoaggiornabile e continuare a funzionare anche durante l'aggiornamento (app server, app incorporate). Vai con OSGi: Bundles o Equinox p2 .
L'app è un'app desktop e ha un programma di installazione. Ci sono molti programmi di installazione con l'opzione di aggiornamento. Controlla l' elenco degli installatori .
Di recente ho creato update4j che è completamente compatibile con il sistema di moduli di Java 9.
Avvierà senza problemi la nuova versione senza un riavvio.
Ho scritto un'applicazione Java in grado di caricare plug-in in fase di esecuzione e iniziare a utilizzarli immediatamente, ispirata a un meccanismo simile in jEdit. jEdit è open source quindi hai la possibilità di vedere come funziona.
La soluzione utilizza un ClassLoader personalizzato per caricare i file dal jar. Una volta caricati, puoi richiamare un metodo dal nuovo jar che fungerà da mainmetodo. Quindi la parte difficile è assicurarsi di eliminare tutti i riferimenti al vecchio codice in modo che possa essere raccolto in modo spazzatura. Non sono proprio un esperto in quella parte, l'ho fatto funzionare ma non è stato facile.
NetworkClassLoadersu JavaDoc per ClassLoader
Questo non è necessariamente il modo migliore , ma potrebbe funzionare per te.
Puoi scrivere un'applicazione bootstrap (come il launcher di World of Warcraft, se hai giocato a WoW). Quel bootstrap è responsabile del controllo degli aggiornamenti.
In questo modo non devi preoccuparti di forzare l'uscita dalla tua applicazione.
Se l'applicazione è basata sul Web ed è importante che disponga di un client aggiornato, è anche possibile eseguire i controlli della versione mentre l'applicazione è in esecuzione. È possibile eseguirle a intervalli, durante la normale comunicazione con il server (alcune o tutte le chiamate) o entrambe.
Per un prodotto su cui ho lavorato di recente, abbiamo eseguito i controlli della versione all'avvio (senza un'app boot strapper, ma prima che apparisse la finestra principale) e durante le chiamate al server. Quando il client non era aggiornato, ci affidavamo all'utente per uscire manualmente, ma proibivamo qualsiasi azione contro il server.
Tieni presente che non so se Java può richiamare il codice dell'interfaccia utente prima di aprire la finestra principale. Stavamo usando C # / WPF.
Se crei la tua applicazione utilizzando i plug-in di Equinox , puoi utilizzare il P2 Provisioning System per ottenere una soluzione pronta per questo problema. Ciò richiederà il riavvio del server dopo un aggiornamento.
Vedo un problema di sicurezza durante il download di un nuovo jar (ecc.), Ad esempio un attacco man in the middle. Devi sempre firmare il tuo aggiornamento scaricabile.
Su JAX2015, Adam Bien ha parlato dell'utilizzo di JGit per l'aggiornamento dei binari. Purtroppo non sono riuscito a trovare alcun tutorial.
Adam Bien ha creato il programma di aggiornamento vedi qui
L'ho biforcato qui con un frontend javaFX. Sto anche lavorando a una firma automatica.