[POI][Excel] Plantage lors de la génération de gros fichiers

**yas2006** · 20/03/2006, 15h10

Bonjour, voilà mon problème, avec POI j'arrive à partir d'un fichier excel à lire certaines cellules et les ecrire dans un nouveau fichier excel.
Mais quand le fichier excel est très volumineux(24 Mo), mon serveur d'appli plante et rien n'est ecrit.

Y a t-il un moyen de permettre de lire un fichier excel volumineux, de récupérer certaines de ses cellules pour les ecrire dans un nouveau fichier excel?

Merci

**noOneIsInnocent** · 20/03/2006, 15h12

Salut

pourquoi tu n'utilises pas le format csv ...je pense que ça doit etre mieux ... non ? et même au nivau du temps de traitement ...enfin je crois ...

mais bon vu que ton titre est "suite POI excel" et que je ne connais pas le debut de l'histoire ...

**yas2006** · 20/03/2006, 15h16

Le début de l'histoire etait comment ecrire un nouveau fichier excel à partir d'un fichier excel en excluant certaines colonnes avec POI. ça c'est fait.

Mais je pense que le problème n'est pas dû au format mais à la lecture d'un fichier excel volumineux avec l'API POI.
Et je dois de toute façon créer un fichier excel, c'est ma contrainte. Je ne peux pas créer un fichier csv.
Je n'ai vu aucune info la dessus sur le site de POI.

Quelqu'un aurait une idée?

**yas2006** · 20/03/2006, 15h55

Voic le message que j'obtiens sur mon serveur d'application :

Code :

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

1
2
3
 
JVMDG217: Dump Handler is Processing a Signal - Please Wait.
JVMDG315: JVM Requesting Heap dump file

A quoi cela correspond?

**yas2006** · 22/03/2006, 10h14

Quelqu'un pourrait me dire ce quz sont ces deux messages?

JVMDG217: Dump Handler is Processing a Signal - Please Wait.
JVMDG315: JVM Requesting Heap dump file

**Scorpyosis** · 22/03/2006, 11h23

Est ce que tu charges tout ce que tu as lu en memoire et après modifis puis tu l'ecris ?, ou tu fais ça au fur et a mesure. tu lis -> modifies -> ecris, tu lis ..... Parce que là ca sent le probleme de mémoire, donc verifis ton algo car a priori il a pas de raison que ca ne marche pas

**yas2006** · 22/03/2006, 14h36

Je charge tout en mémoire et après j'ecris au fur et à mesure, en utilisant POI pour les fichiers Excel. Je dois rapatrier dans un nouveau fichier, certaines colonnes avec les données correspondantes. Voici mon code :

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
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
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
 
HashMap files = null;
String sFile = null;
String nomFileDest = null;
String sPath = null;
String nomXLS = null;
String repertoire = null;
String inFilename = null;
String outFilename = null;
 
repertoire = "C:\\datas\\;
 
POIFSFileSystem fs = null;
FileOutputStream file = null;
FileOutputStream fileOut = null;
HSSFWorkbook workbook = null;
HSSFSheet sheet = null;
HSSFSheet newSheet = null;
 
inFilename = "test.xls";
outFilename = repertoire + "Donnees_param_" + inFilename;
fs = new POIFSFileSystem(new FileInputStream(new File(inFilename)));
 
fileOut = new FileOutputStream(new File(outFilename));
workbook = new HSSFWorkbook(fs);
sheet = workbook.getSheetAt(0);
 
workbook = new HSSFWorkbook();
newSheet = workbook.createSheet("Feuille1");
 
int nbRow = sheet.getPhysicalNumberOfRows();	
 
for(int i = 0 ; i < nbRow ; i++) {
    HSSFRow newRow = newSheet.createRow(i);
    HSSFRow row = sheet.getRow(i);
    // cell
    for(short j = (short) 0 ; j < (short) 64 ; j++) {
        HSSFCell cel = row.getCell(j);
        if ( j < (short) 1){					
            HSSFCell newCell = newRow.createCell(j);
            if ( !cel.equals(null) ) {
                switch(cel.getCellType()) {
                    case HSSFCell.CELL_TYPE_FORMULA:
                     newCell.setCellType(HSSFCell.CELL_TYPE_STRING);
                     newCell.setCellValue(cel.getStringCellValue());
                     break;
                    case HSSFCell.CELL_TYPE_NUMERIC:
                     newCell.setCellType(HSSFCell.CELL_TYPE_NUMERIC);
                     newCell.setCellValue(cel.getNumericCellValue());
                     break;
                    case HSSFCell.CELL_TYPE_STRING:
                     newCell.setCellType(HSSFCell.CELL_TYPE_STRING);
                     newCell.setCellValue(cel.getStringCellValue());
                     break;
                    case HSSFCell.CELL_TYPE_BOOLEAN:
                     newCell.setCellType(HSSFCell.CELL_TYPE_BOOLEAN);
                     newCell.setCellValue(cel.getBooleanCellValue());
                     break;
                    case HSSFCell.CELL_TYPE_BLANK:
                     newCell.setCellType(HSSFCell.CELL_TYPE_BLANK);
                     newCell.setCellValue("");
                     break;
                    default :
                }//switch
            }
        }
        else if ( j > (short) 10 && j < (short) 63) {
            HSSFCell newCell = newRow.createCell((short) (j-10));					
            if ( !cel.equals(null) ) {
                switch(cel.getCellType()) {
                    case HSSFCell.CELL_TYPE_FORMULA:
                     newCell.setCellType(HSSFCell.CELL_TYPE_STRING);
                     newCell.setCellValue(cel.getStringCellValue());
                     break;
                    case HSSFCell.CELL_TYPE_NUMERIC:
                     newCell.setCellType(HSSFCell.CELL_TYPE_NUMERIC);
                     newCell.setCellValue(cel.getNumericCellValue());
                     break;
		    case HSSFCell.CELL_TYPE_STRING:
		     newCell.setCellType(HSSFCell.CELL_TYPE_STRING);
		     newCell.setCellValue(cel.getStringCellValue());
		     break;
		    case HSSFCell.CELL_TYPE_BOOLEAN:
		     newCell.setCellType(HSSFCell.CELL_TYPE_BOOLEAN);
		     newCell.setCellValue(cel.getBooleanCellValue());
		     break;
		    case HSSFCell.CELL_TYPE_BLANK:
		     newCell.setCellType(HSSFCell.CELL_TYPE_BLANK);
		     newCell.setCellValue("");
		     break;
		    default :
		}//switch
            }
        }					
    }
}
 
workbook.write(fileOut);
fileOut.close();

Pourrais tu me dire ce qui ne vas pas et me corriger cela?

Merci d'avance

**yas2006** · 23/03/2006, 12h10

J'aurais une question, mon probleme de mémoire est-il lié au fait que mon FileInputStream n'est jamais fermé? Ou bien il n'est pas nécessaire de faire un close car je n'ai pas fait d'open. Merci de votre aide

**Scorpyosis** · 23/03/2006, 15h56

Une fois que tu as terminé c'est toujours mieux de faire un close() au moins tu es sur que ça sera fermé, meme si ca ne chagera rien a ton probleme de mémoire a priori. Vu ton source, il n'y a pas l'air d'avoir d'erreur le probleme vient trés probablement que la lib met tout le fichier en RAM, donc la pas grand chose a faire a part essayer de jouer avec le option de Java -Xmx (taille maximum du tas) et -Xms (taille initiale du tas).

**yas2006** · 23/03/2006, 17h30

C'est bien ce que je pensais, POI met le fichier en RAM, tout le fichier.
Meme en jouant avec la mémoire de la jVM avec :

Code :

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

Java -Xmx64 et -Xms1152

ça ne marche pas. Je ne sais vraiment pas quoi faire. Y aurait-il pas un autre moyen? Vraiment?[/code]

**Scorpyosis** · 23/03/2006, 18h05

Juste une question comme ça est-ce que tu as essayé avec des fichiers plus petit, (1Mo, 3Mo, ....) ? et si tu enleves toute ta partie traitement, que tu ne laisse que : ouverture du fichier excel, puis fermeture, est ce que ca marche ?

**yas2006** · 24/03/2006, 10h02

ça marche bien avec des fichiers ne depassant pas 2Mo.
ça marche, mais c'est long, même avec des fichiers de 10-12 Mo.
Mais ça rame quand le fichier est trop gros.

Je pense qu'il faudrait peut etre découper la lecture du fichiers quand il est gros, ou faire autre chose. je sais juste que c'est la lecture du fichier excel qui pose problème quand le fichier est volumineux.

Si quelqu'un a une idée pour résoudre ce problème, ça m'aiderait beaucoup.

**Baldur_s** · 24/03/2006, 10h25

J'ai été interpellé par ce topic car une de mes futures appli devra généré du XLS...on m'avait parlé de POI mais pas encore expérimenté l'API...

http://www.opensubscriber.com/messag...g/3551148.html
Il semblerait que ca vienne d'une limitation dans l'API Cocoon :s

**yas2006** · 24/03/2006, 10h40

D'après ce que j'ai compris sur le site, la limitation est pour la génération de feuilles excel. Or à priori, mon problème est dans la lecture d'un gros fichier pour en extraire certaines données vers un nouveau fichier XLS.

A moins que je n'ai pas compris ce qu'il disait dans le site precedent.

**Baldur_s** · 24/03/2006, 10h46

Effectivement il parle de génération de fichier mais j'imagine que la lecture se base sur Cocoon aussi...

**Scorpyosis** · 24/03/2006, 22h42

Il te faut combien de temps pour juste ouvrir le fichier et le fermer sans faire aucun traitement, juste l'ouvrir et le fermer ?

**jowo** · 25/03/2006, 08h32

Envoyé par Baldur_s

Effectivement il parle de génération de fichier mais j'imagine que la lecture se base sur Cocoon aussi...

[COMMENTAIRE TYPE="HORS SUJET"]
Pas forcément, il se peut que les données proviennet d'une autre source que d'un fichier XLS.

Imagine une application, utilisant COCOON, qui est censée générer un fichier XSL à partir des données d'une banque de données ou toute autre source de données .
[/COMMENTAIRE]

**yas2006** · 27/03/2006, 13h54

J'ai vu que certaines personnes pronaient le fait de rapatrier dans un premier temps mes données dans un tableau, puis à partir du tableau, de les réécrire dans un nouveau fichier excel. ça me parait pas forcément etre une meilleur solution car mes fichiers de départ sont composé d'environ 80 colonnes et 30000 lignes.

Je n'ai pas testé juste l'ouverture et la fermeture de mon fichier en lecture. Mais je peux juste dire qu'au bout de 20 à 30 minutes de traitement, mon serveur plante et aucun fichier n'est créé. De plus disposant d'1 Go de RAM, mon CPU utilise presque jusqu'à 2 Go de RAM, et ça me pose pas mal de problemes de mémoire.

Y aurait-il vraiment aucune autre solution pour résoudre ce problème? Est ce que mon code est correct? Aurais-je les mêmes problemes en utilisant une autre API pour la manipulation de fichiers Excel?

Aidez moi SVP.

**jowo** · 27/03/2006, 14h33

Ta question soulève plusieurs interrogations.

1) POI est-il prévu pour lire de fichier important?

2) Tu écris que le traitement est effectué sur le serveur. Quel type d'application est éxecutée pour le traitement du fichier?

Si c'est une WEB-Application (HTTP-Serveur + WEB-Container), est-il justicieux d'utilisier une telle application pour un "job" qui ressemble plus à un batch-job qu'à une application interactive (temps de réponse rapide).

3) Peux-tu déterminer si le problème provient de la lecture ou de l'écriture?

Une solution serait de pré-traiter ton fichier (ex: format CSV) pour alléger sa lecture.

**yas2006** · 27/03/2006, 15h04

En fait pour le paramétrage de certaines bases de données je dois les charger via un fichier Excel, c'est pour ça qu'il est gros. Mon appli est une appli swing avec serveur d'appli WebSphere. L'archi est comme elle est, je n'ai aucune prise dessus pour modifier quelque chose. Par contre au niveau traitement et interface, j'ai une certaine libérté.

Je suis sur que c'est la lecture du fichier qui pose probleme, car mon traitement fonctionne pour des fichiers de 10 Mo environ; ça met 8 minutes environ. la lecture est une des premieres choses executée.

Pou des fichiers de 30 Mo ça marche pas, et ça rame puis ça plante au bout de 30 minutes.

Si je passe par un fichier csv, est ce que POI peut lire et ecrire dans des fichiers csv? Ou bien, alors tu me dis de laisser tomber POI, de transformer mes fichiers en fichiers csv, et de faire les traitements avec un printWriter, comme si j'ecrivais un fichier texte?

Comment faire pour copier un fichier xls en csv?

[POI][Excel] Plantage lors de la génération de gros fichiers

Documents Java

Discussions similaires

Partager

Partager