J2EE struts import d'un grand nombre de données

Bonjour,

Je suis en train de developper un outil d'alimentation et je me retrouve confronter à un problème.

L'application prend en parametre un fichier formaté ainsi :

champs1|champs2|champs3 etc
Je parse ligne par ligne et j insère dans la base de données les champs. Jusqu'ici il n'y aucun problème sur des petits fichiers. Le problème se pose lorsque le fichier contient des milliers de lignes. Vers le 5000 enregistrement (environs) j'obtiens lerreur suivante :
java.sql.SQLException: Exception d'E/S: The Network Adapter could not establish the connection

Quelqu un aurait une idée car je me retrouve bloquer

Merci par avance

Sûrement un problème de cache ou de mémoire : ferme tu la connection à chaque écriture ? Comment insère-tu dans la base de données ? Montre nous le code que tu utilise ce sera plus simple.

Lecture du fichier
Code :
            BufferedReader reader = new BufferedReader(new FileReader(file[0]));
                while ((currentLine = reader.readLine()) != null) {
                   TraitementDonnees(ligneBuffer, NomdeLaTable, ListeChamps, idAlim);
                }

TraitementDonnees appelle :

    public String alimentationTest(String[] Data, MyUser user, int idAlim)
            throws AlimentationServiceException {
        Connection connection = null;
        String result = "";
        try {
            DataSource dataSource = getDataSource();
            connection = dataSource.getConnection();
            AlimentationImportOM alimentationOM = new AlimentationImportOMImpl();
            alimentationOM.setConnection(connection);
            alimentationOM.setLogger(log);
            if (alimentationOM.checkExistant(Data[0]))
                result = alimentationOM.alimUpdate(Data, user, idAlim);
            else
                result = alimentationOM.alimInsert(Data, user, idAlim);

        } catch (SQLException e) {
            log.error(e.getMessage(), e);
            throw new AlimentationServiceException(e.getMessage(), e);
        } catch (LookupException e) {
            log.error(e.getMessage(), e);
            throw new AlimentationServiceException(e.getMessage(), e);
        } finally {
            try {
                connection.close();
            } catch (Throwable t) {
                log.error(t.getMessage(), t);
            }
        }
        return result;
    }

    private static final String DB_REQUEST_ALIM_EXIST = "SELECT COUNT(CUR) FROM TABLE WHERE CUR=?";

    private static final String DB_UPDATE_ALIM = "UPDATE TABLE "
            + "SET DATA=?  WHERE CUR=?";

    private static final String DB_INSERT_ALIM= "INSERT INTO TABLE (DATA) "
            + " VALUES (?) ";

    public boolean checkExistant(String cur) throws LookupException {
        PreparedStatement pStmt = null;
        ResultSet rs = null;
        boolean isExist = false;

        try {
            pStmt = connection.prepareStatement(DB_REQUEST_ALIM);

            pStmt.setString(1, cur);
            rs = pStmt.executeQuery();
            while (rs.next()) {
                isExist = true;
            }

        } catch (SQLException sqlException) {
            getLogger().error(DB_REQUEST_ALIM_EXIST_PORTEE, sqlException);
            throw new LookupException(sqlException.getMessage(), sqlException);
        } catch (Throwable throwable) {
            getLogger().error(DB_REQUEST_ALIM_EXIST_PORTEE, throwable);
            throw new LookupException(throwable.getMessage(), throwable);
        } finally {
            try {
                rs.close();
                pStmt.clearParameters();
                pStmt.close();
            } catch (Throwable throwable) {
                getLogger().error(throwable.getMessage(), throwable);
            }
        }
        return isExist;
    }

    public String alimUpdate(String[] data, int idAlim)
            throws LookupException {
        PreparedStatement pStmt = null;
        ResultSet rs = null;
        try {
            pStmt.setString(4, data[0]);
            rs = pStmt.executeQuery();
        } catch (SQLException sqlException) {
            getLogger().error(DB_UPDATE_ALIM, sqlException);
            throw new LookupException(sqlException.getMessage(), sqlException);
        } catch (Throwable throwable) {
            getLogger().error(DB_UPDATE_ALIM, throwable);
            throw new LookupException(throwable.getMessage(), throwable);
        } finally {
            try {
                if (rs != null)
                    rs.close();
                pStmt.clearParameters();
                pStmt.close();
            } catch (Throwable throwable) {
                getLogger().error(throwable.getMessage(), throwable);
            }
        }
        return "OK";
    }

    public String alimInsert(String[] data, MyUser user, int idAlim)
            throws LookupException {
        PreparedStatement pStmt = null;
        ResultSet rs = null;

        try {
            pStmt = connection.prepareStatement(DB_INSERT_ALIM);
            pStmt.setString(1, data[0]);

            rs = pStmt.executeQuery();
        } catch (SQLException sqlException) {
            getLogger().error(DB_INSERT_ALIM, sqlException);
            throw new LookupException(sqlException.getMessage(), sqlException);
        } catch (Throwable throwable) {
            getLogger().error(DB_INSERT_ALIM, throwable);
            throw new LookupException(throwable.getMessage(), throwable);
        } finally {
            try {
                if (rs != null)
                    rs.close();
                pStmt.clearParameters();
                pStmt.close();
            } catch (Throwable throwable) {
                getLogger().error(throwable.getMessage(), throwable);
            }
        }
        return INSERT;
    }

A première vue, je dirais que ca vient de cette fonction :
public boolean checkExistant(String cur) throws LookupException {
        PreparedStatement pStmt = null;
        ResultSet rs = null;
        boolean isExist = false;

        try {
            pStmt = connection.prepareStatement(DB_REQUEST_ALIM);

            pStmt.setString(1, cur);
            rs = pStmt.executeQuery();
            while (rs.next()) {
                isExist = true;
            }

        } catch (SQLException sqlException) {
            getLogger().error(DB_REQUEST_ALIM_EXIST_PORTEE, sqlException);
            throw new LookupException(sqlException.getMessage(), sqlException);
        } catch (Throwable throwable) {
            getLogger().error(DB_REQUEST_ALIM_EXIST_PORTEE, throwable);
            throw new LookupException(throwable.getMessage(), throwable);
        } finally {
            try {
                rs.close();
                pStmt.clearParameters();
                pStmt.close();
            } catch (Throwable throwable) {
                getLogger().error(throwable.getMessage(), throwable);
            }
        }
        return isExist;
    }

Euh je comprend pas je fais bien
finally {
            try {
                rs.close();
                pStmt.clearParameters();
                pStmt.close();
            } catch (Throwable throwable) {
                getLogger().error(throwable.getMessage(), throwable);
            }

Donc pour moi quoiqu'il se passe le resultatset et le statement sont fermés non ?

Au temps pour moi, j'ai pas fait gâffe au bloc finally !

Hum non c'est jsute que j'ai simplifié le code et donc supprimé quelques lignes supperflues (ou pas !) Il y a bien une initialisation

Je me demandai si le fait de réduire le nombre de connection (une connection est ouverte à chaque ligne sur des fichiers de 20000 lignes ca fait en fait autant)  ne pouvait pas régler ce problème ?