Serializzazione, quale usare?

[assmazz]

Salve mi trovo a dover implementare metodi che gestiscano insert/select/update/delete di oggetti in file.
esempio: un file che contiene oggetti di tipo Articolo, un file che contiene oggetti di tipo Anagrafe e cosi via ed io devo scrivere dei metodi standard che poi tramite reflection eseguano le operazioni corrette.

Avevo pensato di usare serializable ma mi sembra di aver capito che sfrutta file ad accesso sequenziali e non ad accesso diretto e questo potrebbe essere sconveniente per cercare un oggetto X. Pero' serializable è molto utile a livello di codice perchè è estremamente facile tramite readObject e writeObject.
Serializable non sfrutta i file ad accesso diretto?

Avete qualche soluzione da suggerirmi?

[Pastore12]

Non sono sicuro di aver capito bene, ma provo comunque a proporre qualche alternativa..

Se la conosci già la struttura degli oggetti che intendi inserire nei file, e se questa struttura è abbastanza semplice puoi usare java.util.Properties

In questo caso si immagina che un oggetto abbia un nome, e che tutti gli altri suoi campi possano essere salvati facilmente in una stringa.

Quindi con il comando getProperty (nome) ottieni la stringa associata all'oggetto identificato dalla stringa nome e da questa stringa ti calcoli i campi che valorizzano l'oggetto.
In questo modo effettuare update, select, insert è banale.

In alternativa puoi usare dei file xml, che si adattano a memorizzare (credo) qualunque tipo di oggetti. In questo caso potrebbe facilitarti la vita una libreria come http://xstream.codehaus.org/
Con questo secondo modo, quando fai un select, xstream converte automaticamente il contenuto del file xml (relativo all'oggetto selezionato) in un bean. Il che è talmente comodo che spesso se devi scrivere codice che faccia accesso a un database, spesso in fase di test (quando il database non è disponibile) l'accesso viene effettuato sui file xml.

Ciao

[@DI3GO@]

Scritto da assmazz
...Serializable non sfrutta i file ad accesso diretto?

Purtroppo no....
Leggi bene questa proposta...
Se per forza devi usare quei file allora potresti precaricali.
Ovvero crei un metodo load che ti legge tutti gli oggetti nel/nei file e li salva in una Collection qualsiasi ( quella che ti aiuta maggiormente ) e da lì li puoi gestire....
Ovvio che se sono parecchi oggetti all'interno del file ( parlo di > 500 ) allora dovresti pensare ad un metodo di swap.
Ovvero istanzi la List di una dimensione fissa, assieme a due variabili start ed end, dove verranno salvati il numero dell'object letto ( il primo e l'ultimo ).
Quando lavoro sulla List e non trovo l'oggetto allora vado a recuperare dallo swap ( il mio file su disco ) gli oggetti che non sono compresi tra i due indici.

Sembra una soluzione strana, ma non sono impazzito :berto:

[assmazz]

grazie per le risposte.

io in pratica sto scrivendo un software, diciamo stile hibernate, capace di memorizzare qualsiasi tipo di oggetto indipendentemente da come è formato.

Mi spiego...arriva uno che vuol utilizzare il mio software che ha oggetti di tipo Articolo e lui deve poter fare le operazioni descritte nel post precedente su file.

un altro potrebbe voler memorizzare/caricare/aggiornare oggetti di tipo Anagrafe.

[assmazz]

Originariamente inviato da Pastore12

In alternativa puoi usare dei file xml, che si adattano a memorizzare (credo) qualunque tipo di oggetti. In questo caso potrebbe facilitarti la vita una libreria come http://xstream.codehaus.org/
Con questo secondo modo, quando fai un select, xstream converte automaticamente il contenuto del file xml (relativo all'oggetto selezionato) in un bean.

Mi sembra interessante ma una cosa non mi è chiara...ogni oggetto viene messo in un file xml oppure posso mettere 50 oggetti dello stesso tipo in 1 solo file?

[Pastore12]

tutti gli oggetti che vuoi in un unico file xml

ogni oggetto puo' contenere altri oggetti, anche un vettore di oggetti.

Credo che non ci siano limiti...

[assmazz]

public static LinkedList ReadInFile(String nomefile) {
		Object O = null;
		LinkedList l;
		l = new LinkedList();
		ObjectInputStream ois = null;
		try 
                {
			FileInputStream fis = new FileInputStream(nomefile);
			ois = new ObjectInputStream(fis);
		}
                catch (FileNotFoundException e)
                {
			System.out.println("file non found");
		}
                catch (IOException e1) 
                {
			System.out.println("IO problem 1");
		}
		try 
		{
		O = ois.readObject();
		l.addFirst(O);	
		while (O !=null)	
		O = ois.readObject();
		l.addFirst(O);
		} 
		catch (IOException e2) 
		{
			System.out.println("IO problem 2");
		} 
                catch (ClassNotFoundException e3)
		{
			System.out.println("class problem");
		}
		
		return l;
	}

qual è l'errore in questo metodo? mi va in IOException e2. credo l'errore sia while (O !=null), ma come leggere il file fino alla fine?

[@DI3GO@]

Non è nel while....infatti lui tenta la lettura, ma poi si trova a non aver più niente da leggere ed entra in eccezione....

per la lettura di file esiste un ciclo molto ultilizzato

while( ( numByteLetti = iStream.read( buffer ) ) > 0 ) ...

potresti invece fare una cosa simile :

//Ho rinominato le variabili perchè siano comprensibili a tutti
...
int availableByte = objInputStream.available();
while( objInputStream.available() > 0 ){
   objReaded = objInputStream.readObject();
....
}

available ( mai usata ) se non ho interpretato male nella classe ObjectInputStream ritorna i byte disponibili alla prossima chiamata ( l'ovveride di InputStream - per chia andasse alle API Sun - API SUN ).

Quindi prova...

[assmazz]

molto interessante quello che mi hai detto, ma ho provato a leggere aldilà del while e mi son accorto che lui in realta' trova sempre e un solo oggetto nel file...in pratica credo che non li appena ma che li sovrascriva ti linko il codice del metodo di inserimento.
ho provato ad eseguire 3 inserimenti e la lettura nella classe di lancio...mi termina correttamente i 3 inserimenti ma poi la linkedlist della read ha 1 solo elemento...l'ultimo.

public static int InsertInFile(String nomefile, Object O)
{
		int oggettiInseriti = -1;
		ObjectOutputStream oos = null;
		try 
                {
			FileOutputStream fos = new FileOutputStream(nomefile,true);
			oos = new ObjectOutputStream(fos);
		} 
                catch (FileNotFoundException e) 
                {
			System.out.println("file non found");
		}
                catch (IOException e1) 
                {
			System.out.println("IO problem 1");
		}
		try 
		{
			oos.writeObject(O);
			
		} 
                catch (IOException e2) 
                {
			System.out.println("IO problem 2");
		}
		try 
                {
			oos.close();
			oggettiInseriti = 1;
		} 
                catch (IOException e3) 
                {
			System.out.println("IO problem 3");
		}

	return oggettiInseriti;
}

[Pastore12]

Questa roba qua...

O = ois.readObject();
l.addFirst(O);
while (O !=null)
O = ois.readObject();
l.addFirst(O);

E' come scrivere questo...

O = ois.readObject();
l.addFirst(O);
while (O !=null)
{
  O = ois.readObject();
}
l.addFirst(O);

E mi sembra chiaro non ha senso...
Scusa, sarà:

while ((O = ois.readObject()) !=null)
  l.addFirst(O);

così sei sicuro di non aggiungere oggetti nulli
Eppoi.. come sarebbe a dire

credo l'errore sia while (O !=null)

?

Le eccezioni non vanno ammazzate in questo modo! Servono apposta per dirti dov'è l'errore!
Aleno in fase di debug...

catch (Exception e)
{
  e.printStackTrace();
}

fanne tesoro... ciao!