Inserire .txt in .jar

[capo93]

Buon pomeriggio a tutti sto cercando una soluzione al mio problema (ammetto che sono un po' niubbo del java).
Sto creando un programma che legge e scrive su un file .txt per non perdere i dati dopo l'utilizzo (uso lo Scanner e il PrintWriter) ma questo mi costringe ad avere il file .txt nella stessa directory del file .jar e può essere facilmente manipolato.. posso inserire il txt nel jar in modo tale da tenerlo "nascosto"?

[Andrea1979]

Sì, se n'è parlato anche qui sul forum (getResourceAsStream e similari) ed in internet (trovi decine di pagine)
Google

[LeleFT]

Originariamente inviato da Andrea1979
Sì, se n'è parlato anche qui sul forum (getResourceAsStream e similari) ed in internet (trovi decine di pagine)
Google

Questo per quanto riguarda la lettura... per la scrittura è un problema, in quanto un file JAR è un archivio (che può essere anche compresso) ZIP, per cui il file non è più un "file", ma una sequenza di byte incastrata in mezzo ad altra roba.

Per poter scrivere dovresti prima ri-creare il file di testo come file su disco e poi aggiungerlo al JAR utilizzando una libreria per la manipolazione del file compressi.


Ciao.

[capo93]

Potresti essere un po' più dettagliato? Non ci ho capito niente Sono abbastanza alle prime armi con Java

[LeleFT]

Un file JAR è nientemeno che un file ZIP con estensione modificata.
Un file ZIP/JAR è un file unico di dati. I dati all'interno sono organizzati secondo gli standard forniti dal formato ZIP.

Non è una semplice directory di file sciolti, è un file unico con dentro dei dati illeggibili "ad occhio nudo" (sono scritti secondo un preciso formato e spesso sono "compressi").

Per questo non è adatto a contenere file che devono essere modificati. Va benissimo per contenere file da leggere, poichè l'operazione di lettura consiste solamente nel prendere i dati che ci sono e trasformarli al volo in dati non compressi, ma non altrettanto per scriverli, poichè la scrittura comporta il cambiamento di tutto l'archivio (quindi, si vanno ad intaccare anche zone che riguardano gli altri file dell'archivio, non solo quella del file che si è modificato).

Di conseguenza, l'unico modo per poter "modificare" un file presente in un JAR consiste in 3 operazioni:

1) Estrazione del file dall'archivio (decompressione e creazione del file fisico su disco)
2) Modifica del file (nel formato leggibile del TXT)
3) Re-inserimento del file nell'archivio JAR (con eventuale compressione e re-indicizzazione).

In pratica, non esiste nulla di pre-confezionato che faccia queste tre cose in modo trasparente (e non è nemmeno detto che sia possibile farle: che succede se sul disco non c'è sufficiente spazio per l'estrazione/decompressione del file?).


Ciao.

[John360]

Scusate se mi intrometto [cit. Pieraccioni], siccome mi interessa l'argomento, Lele hai detto che ci sono librerie per la riscrittura di un file in un jar, potresti dire quali sono e se conosci una procedura facile?

[LeleFT]

Originariamente inviato da John360
Scusate se mi intrometto [cit. Pieraccioni], siccome mi interessa l'argomento, Lele hai detto che ci sono librerie per la riscrittura di un file in un jar, potresti dire quali sono e se conosci una procedura facile?

Veramente ho detto che NON ne conosco (e non so se ce ne siano).
Esistono certamente librerie (o anche semplici classi, che si trovano con ricerche su Google) per la creazione/aggiunta di file ad archivi ZIP (anche compressi).

Io, ad esempio, avevo trovato e proficuamente utilizzato questa classe:
http://svn2.assembla.com/svn/jfblib/...utputFile.java

Poichè le classi del core standard di Java aderiscono solo allo standard PKZIP, ma non ai più comuni e diffusi formati ZIP supportati dalla maggior parte degli standard (come WinZip).

Poi, è sufficiente rinominare il file ZIP in JAR.

Ciao.

[capo93]

Originariamente inviato da LeleFT
Un file JAR è nientemeno che un file ZIP con estensione modificata.
Un file ZIP/JAR è un file unico di dati. I dati all'interno sono organizzati secondo gli standard forniti dal formato ZIP.

Non è una semplice directory di file sciolti, è un file unico con dentro dei dati illeggibili "ad occhio nudo" (sono scritti secondo un preciso formato e spesso sono "compressi").

Per questo non è adatto a contenere file che devono essere modificati. Va benissimo per contenere file da leggere, poichè l'operazione di lettura consiste solamente nel prendere i dati che ci sono e trasformarli al volo in dati non compressi, ma non altrettanto per scriverli, poichè la scrittura comporta il cambiamento di tutto l'archivio (quindi, si vanno ad intaccare anche zone che riguardano gli altri file dell'archivio, non solo quella del file che si è modificato).

Di conseguenza, l'unico modo per poter "modificare" un file presente in un JAR consiste in 3 operazioni:

1) Estrazione del file dall'archivio (decompressione e creazione del file fisico su disco)
2) Modifica del file (nel formato leggibile del TXT)
3) Re-inserimento del file nell'archivio JAR (con eventuale compressione e re-indicizzazione).

In pratica, non esiste nulla di pre-confezionato che faccia queste tre cose in modo trasparente (e non è nemmeno detto che sia possibile farle: che succede se sul disco non c'è sufficiente spazio per l'estrazione/decompressione del file?).


Ciao.

Ora sei stato più che dettagliato, grazie mille

[Andrea1979]

Ispirato da:
StackOverflow - JarUpdate

modificando unicamente la modalità di creazione del File per il FileInputStream (ovvero dichiarandolo tramite il costruttore che prende un File, e dichiarando il File come percorso + nome_file (percorso intero della jar-entry), si ottiene il risultato voluto.

package html.file;

import java.io.*;
import java.util.*;
import java.util.zip.*;
import java.util.jar.*;

public class JarUpdate {
   /**
    * main()
    */
   public static void main(String[] args) throws IOException {
      
      String jarName = "C:/Users/Andrea/Desktop/tmp/XMLGenerator.jar";
      String filePath = "C:/Users/Andrea/Desktop/tmp/";
      String fileName = "text/testo.txt";

      // Create file descriptors for the jar and a temp jar.

      File jarFile = new File(jarName);
      File tempJarFile = new File(jarName + ".tmp");

      // Open the jar file.

      JarFile jar = new JarFile(jarFile);
      System.out.println(jarName + " opened.");

      // Initialize a flag that will indicate that the jar was updated.

      boolean jarUpdated = false;

      try {
         // Create a temp jar file with no manifest. (The manifest will
         // be copied when the entries are copied.)

         Manifest jarManifest = jar.getManifest();
         JarOutputStream tempJar =
            new JarOutputStream(new FileOutputStream(tempJarFile));

         // Allocate a buffer for reading entry data.

         byte[] buffer = new byte[1024];
         int bytesRead;

         try {
            // Open the given file.

            FileInputStream file = new FileInputStream(new File(filePath,fileName));

            try {
               // Create a jar entry and add it to the temp jar.

               JarEntry entry = new JarEntry(fileName);
               tempJar.putNextEntry(entry);

               // Read the file and write it to the jar.

               while ((bytesRead = file.read(buffer)) != -1) {
                  tempJar.write(buffer, 0, bytesRead);
               }

               System.out.println(entry.getName() + " added.");
            }
            finally {
               file.close();
            }

            // Loop through the jar entries and add them to the temp jar,
            // skipping the entry that was added to the temp jar already.

            for (Enumeration entries = jar.entries(); entries.hasMoreElements(); ) {
               // Get the next entry.

               JarEntry entry = (JarEntry) entries.nextElement();

               // If the entry has not been added already, add it.

               if (! entry.getName().equals(fileName)) {
                  // Get an input stream for the entry.

                  InputStream entryStream = jar.getInputStream(entry);

                  // Read the entry and write it to the temp jar.

                  tempJar.putNextEntry(entry);

                  while ((bytesRead = entryStream.read(buffer)) != -1) {
                     tempJar.write(buffer, 0, bytesRead);
                  }
               }
            }

            jarUpdated = true;
         }
         catch (Exception ex) {
            System.out.println(ex);

            // Add a stub entry here, so that the jar will close without an
            // exception.

            tempJar.putNextEntry(new JarEntry("stub"));
         }
         finally {
            tempJar.close();
         }
      }
      finally {
         jar.close();
         System.out.println(jarName + " closed.");

         // If the jar was not updated, delete the temp jar file.

         if (! jarUpdated) {
            tempJarFile.delete();
         }
      }

      // If the jar was updated, delete the original jar file and rename the
      // temp jar file to the original name.

      if (jarUpdated) {
         jarFile.delete();
         tempJarFile.renameTo(jarFile);
         System.out.println(jarName + " updated.");
      }
   }
}

[John360]

Grazie Lele e Andrea!