Traduction C vers java

**asloon** · 09/07/2012, 11h28

Bonjour a tous,

Je voudrai créer un programme qui lit un log contenant du texte et qui est en écriture constante. Pour ça j'ai fait ceci ( en c++ ) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
        FILE * pFile;
        pFile = fopen(log_path.c_str(), "r");
 
        if(pFile == NULL) perror("Error opening file");
 
        setvbuf(pFile, NULL, _IONBF, 0);
        fseek(pFile , 0 , SEEK_END);
 
        while(1) {
 
            if ( (void*) fgets (line , 4192 , pFile) != NULL ) {
 
                fputs(line, stdout);
 
            }
 
        }
 
        fclose(pFile);
 
    return 0;
}

Je voudrai maintenant le faire en java, seulement je n'ai aucune idée de quelle fonction se servir. J'ai essayé le FileInputStream sans succès, quand à BufferedReader c'est impossible car j'ai besoin d'avoir un buffer de taille 0 pour pouvoir lire même quand le EOF est atteint afin de traiter les prochains évenements.

Auriez-vous une idée ?

**Népomucène** · 09/07/2012, 11h58

Et si tu nous montrais le code java que tu as essayé ?

**asloon** · 09/07/2012, 12h03

Ah oui pardon, le voici :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
    public static void main(String[] args) throws FileNotFoundException, IOException {
 
       String log_path = "C:\\Users\\Bapiste\\Desktop\\Coyote\\minigames.log" ;
 
       FileInputStream reader;
 
       try {
 
           reader = new FileInputStream(new File(log_path));
           byte[] buffer = new byte[4196];
           int n ;
 
           while(true) {
 
            while((n = reader.read(buffer)) >= 0){
 
            for(byte bit : buffer)
                System.out.print( (char)bit );
                System.out.println("");
            }
 
           }
 
       } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
 
    }

**wax78** · 09/07/2012, 12h12

Je pense que ceci t'aidera, le tutoriel Java de jmdoudou, chapitre flux.

**Népomucène** · 09/07/2012, 12h13

Ben déjà, ça compile pas. Il faut ajouter une exception :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
        String log_path = "C:\\Users\\Bapiste\\Desktop\\Coyote\\minigames.log" ;
        
        FileInputStream reader;
        
        try {
            
            reader = new FileInputStream(new File(log_path));
            byte[] buffer = new byte[4196];
            int n ;
            
            while(true) {
                
                while((n = reader.read(buffer)) >= 0){
                    
                    for(byte bit : buffer)
                        System.out.print( (char)bit );
                    System.out.println("");
                }
                
            }
            
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        
    }

**Népomucène** · 09/07/2012, 12h22

Ensuite, petit coquin, tu aurais du lire la FAQ sur la lecture des fichiers lignes à lignes

ce qui te donne :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
        String log_path = "C:\\Users\\Bapiste\\Desktop\\Coyote\\minigames.log" ;
        Scanner scanner;
        try {
            scanner = new Scanner(new File(log_path));
            while (scanner.hasNextLine()) {
                String line = scanner.nextLine();
 
                System.out.println(line);
                //faites ici votre traitement
            }
 
            scanner.close();
        } catch (FileNotFoundException ex) {
            ex.printStackTrace();
        }

**asloon** · 09/07/2012, 12h31

Certes très cher je ne l'ai point lu, mais cela ne peut marcher. Quand le scanner atteindra le EOF, le buffer ne se "rafraichira" pas et tout ce qui sera écrit plus tard ne sera donc pas lu.

C'est pour ça que je cherche un moyen de ne pas bufferiser le flux.

Peut-être me suis-je mal exprimé et je m'en excuse si vous ne m'avez pas compris.

**Népomucène** · 09/07/2012, 12h39

C'est pour ça que je cherche un moyen de ne pas bufferiser le flux.

A ma connaissance, le scanner n'est pas un buffer.
Il lit ce qui est effectivement écrit dans le fichier.

**asloon** · 09/07/2012, 13h12

Il doit le faire parce que quand il rencontre le EOF, il ne lit plus rien.

edit: il le fait => http://docs.oracle.com/javase/1.5.0/...l/Scanner.html

=> In currently latest JDK6 release/build, the Scanner has a littler buffer (1KB char buffer) as opposed to the BufferedReader (8KB byte buffer), but it's more than enough.

**Népomucène** · 09/07/2012, 13h29

Comme le problème est de récupérer toutes les lignes,

une solution simple (simpliste ?) consiste à regarder périodiquement (timer)
si la taille du fichier sur disque a changé (voir File.length)
si c'est le cas, relancer le scanner en sautant toutes les lignes déjà récupérées.

Si tu es en Java 7, il y a le nouveau package java.nio.file
qui permet de détecter les changements sur les fichiers (WatchService) mais je ne l'ai pas testé.

**asloon** · 09/07/2012, 13h54

Le problème avec ta solution c'est que je dois fermer/ouvrir pour actualiser le buffer s'il trouve un changement, ce qui est un peu lourd je trouve.

J'ai vu que bufferedreader pouvais prendre en 2e argument la taille du buffer. Je me suis dis chouette je vais le mettre à 0. A la compilation ça foirre.

Exception in thread "main" java.lang.IllegalArgumentException: Buffer size <= 0

J'ai alors essayé à 1 :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
String log_path = "C:\\Users\\Bapiste\\Desktop\\Coyote\\C++\\minigames.log" ;
 
       BufferedReader reader = new BufferedReader(new FileReader(log_path),1);
 
       while(true) {
 
           Thread.sleep(500);
 
         while ((line = reader.readLine()) != null)
         {
            System.out.println(line);
         }
 
       }

Ca à l'air de marcher mais je doute de la fiabilité. J'ai rajouté une temporisation pour pas griller le CPU

J'ai aussi trouvé ça sur un site anglais :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
File f = new File(log_path);
        FileReader fr = new FileReader(f);
        BufferedReader br = new BufferedReader(fr);
 
        String s = null;
 
        while(true) {
 
        while ((s=br.readLine())!=null)
            {
                System.out.println(s);
            }
        }

Ca m'a l'air bizarre mais ça marche plus ou moins aussi.

Qu'en penses tu ? ça fait un peu bricolage non ?

**Népomucène** · 09/07/2012, 14h14

Les deux exemples sont fonctionnellement identiques !
pourquoi mettre la taille à 1 ? il ne va lire qu'un seul caractère !

**asloon** · 09/07/2012, 14h28

Ah ben oui en effet tu as raison, je pensais qu'en mettant une valeur proche de 0 il n'utiliserait pas le buffer vu que mes lignes sont grandes.

J'ai mis à 4196 la taille, ça marche aussi. Je comprends plus rien la.

**Népomucène** · 09/07/2012, 14h33

Comme c'est un fichier log, je suppose que chaque ajout est écrit sur une nouvelle ligne.
Comme tu utilises la méthode readLine qui est censée récupérer une ligne entière, je pense que tu n'as pas intérêt à spécifier une taille de buffer.

**asloon** · 09/07/2012, 14h59

En effet, c'est mieux ainsi. Je vais laisser ça comme c'est je verrai bien quand le traitement des events sera fait pour voir si c'est pas trop lourd.

Je te remercie chef

**asloon** · 09/07/2012, 15h44

Ah juste une autre chose si tu connais, j'aimerai placer le curseur à la fin du fichier afin de ne pas traiter les anciens evènements. Sais tu comment je peux le placer ?

Est ce qu'un truc genre seekg() existe en java ? La doc du bufferedreader ne dis rien a propos de pointeur ni de curseur.

Edit : Fonction faite à l'arrache :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
public static long countCharsSimple(File f) throws IOException {
    BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(f)));
    long charCount = 0;
    while(reader.read() > -1) {
        charCount++;
    }
    reader.close();
    return charCount;
}

retourné dans ceci :

long length = countCharsSimple(f); // Save EOF position

Puis placement avec ceci :

reader.skip(length); // Go to EOF

Vu que j'ai pas du tout besoin d'un temps de calcul monstre pour calculer la position du EOF je me suis permis ceci.

**wax78** · 09/07/2012, 16h28

Oulalala, je me demandes pourquoi tu tiens tant à ton BufferedReader mais bon passons ....

Demande au fichier sa size plutot que de faire une boucle de lecture char/char parce que la c'est pas top top.

Sinon, Je me demande si tu n'aurais pas eu plus facile avec http://java.sun.com/j2se/1.4.2/docs/...ccessFile.html

**asloon** · 13/07/2012, 14h24

Bonjour wax78,

en effet plus j'avance dans mon traitement de l'information, plus je m'aperçois que la lecture est completement pourrie.

Comment aurais-tu procéder avec cette classe ?

**wax78** · 13/07/2012, 14h40

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
String line;
String log_path = "e:\\mini.log";
File f = new File(log_path);
BufferedReader reader = new BufferedReader(new FileReader(log_path));
reader.skip(f.length());
while (true)
while ((line = reader.readLine()) != null)
System.out.println(line);