[Problème de persistance d'un BufferedReader]

Version imprimable

Bonjour,

Le contexte :

En fait je veux ouvrir un seul flux de données et pouvoir le réutiliser plusieurs fois.

Ouverture du flux

fonction lecture 1 -> (lit un bloc de ligne)
fonction lecture 2 -> (lit une ligne)
fonction lecture 3 -> (lit une ligne)

Fermeture du flux.

J'ai pensé à la sérialisation mais c'est pareil ça ne marche qu'une seule fois.(voir ci-dessous)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
 
 
public class MainBuffered {
 
    protected static TestBufferedReader obj1 = null;
 
    protected static TestBufferedReader obj2 = null;
 
    public static void main(String args[]) {
 
        try {
            // Sauvegarde de l'objet
            sauvergardeObjet();
 
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
 
        try {
            lectureObjet().testerlecture();
        } catch (IOException e1) {
            e1.printStackTrace();
        } catch (ClassNotFoundException e1) {
            e1.printStackTrace();
        }
 
 
 
        try {
            lectureObjet().testerlecture();
        } catch (IOException e1) {
            e1.printStackTrace();
        } catch (ClassNotFoundException e1) {
            e1.printStackTrace();
        }
    }
 
    protected static void sauvergardeObjet() throws ClassNotFoundException,
            IOException {
        obj1 = new TestBufferedReader(
                "C:/eclipse/workspace/testDiverses/source.txt");
 
        //obj1.testerlecture();
 
        ObjectOutputStream out;
        out = new ObjectOutputStream(new FileOutputStream("buffered.out"));
        out.writeObject(obj1);
        out.flush();
        ObjectInputStream in = new ObjectInputStream(new FileInputStream(
                "buffered.out"));
 
        out.close();
 
        System.out.println("Sauvegarde de l'objet 1 OK");
    }
 
    protected static TestBufferedReader lectureObjet() throws IOException,
            ClassNotFoundException {
        ObjectInputStream in = new ObjectInputStream(new FileInputStream(
                "buffered.out"));
        TestBufferedReader obj2 = (TestBufferedReader) in.readObject();
        return obj2;
 
    }
}

Auriez vous idées pour y arriver ?

Cordialement,

xarius :D

30/05/2006, 11h31
iohack

Je comprends pas trop ton problème, si tu veux sauvegarder/charger 3 trois objets à la suite dans un fichier sans ouvrir - lire/ecrire - fermer à chaque fois, rien ne t'empeche de faire trois appels successifs aux méthodes writeObject/readObject.
Sinon, je pense que c'est l'architecture de ta classe qui n'est pas correct ( c'est pas très joli tous ces trucs "static" ! ).
Je te propose donc la méthode suivantes ( il y en a d'autres ) :
- ouvrir les deux flux dans le constructeur de ta classe
- créer une méthode lire qui te retourne le resultat de readObject.
- créer une méthode écrire qui prend en paramètre un objet passé à la méthode writeObject.
- créer une méthode close permettant de fermer les deux correctement.

Avec ce modèle, les flux restent ouverts et opérationnels pendant toute la durée d'existance de ton instance.

Bonjour,

Voila en code ce que je voudrai faire. Appeler plusieurs fois lire pour pouvoir relire le fichier en entier à chaque fois.

Mais ici dans le code il le fait q'une seule fois.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
 
 
package divers;
 
import java.io.BufferedReader;
import java.io.IOException;
 
spublic class GestionFichier {
 
	public static void main(String[] args) {
 
		BufferedReader reader = null;
 
		LireFichier lecture = new LireFichier();
		reader = lecture.ouvrirFlux();
 
		lireFichier(reader);
 
		lireFichier(reader);
 
		lireFichier(reader);
 
		// fermeture du flux
		lecture.fermerFlux(reader);
	}
 
	public static void lireFichier(BufferedReader reader) {
		String ligne = null;
 
		try {
			while ((ligne = reader.readLine()) != null) {
				System.out.println(ligne);
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
 
 
package divers;
 
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
 
public class LireFichier {
 
	public BufferedReader ouvrirFlux() {
		File cheminFichierData = null;
		FileReader fluxLectureTexte = null;
		BufferedReader buffer = null;
 
		try {
			cheminFichierData = new File("source.txt");
 
			fluxLectureTexte = new FileReader(cheminFichierData);
			buffer = new BufferedReader(fluxLectureTexte);
 
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}
 
		return buffer;
	}
 
	public void fermerFlux(BufferedReader buffer) {
 
		try {
			buffer.close();
 
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
 
}

Merci.

xarius :D