JSP JavaServer Pages

JSP
JavaServer
Pages
Duane Fields
Éditions Eyrolles
ISBN : 2-212-09228-8
2000

7
Intégration aux bases
de données
Dans ce chapitre :
• Lien entre l’API JDBC et JSP
• Stockage et extraction des composants JSP avec un SGBD relationnel
•Affichage des résultats d’une requête dans des pages JSP
• Établissement des connexions persistantes
Autrefois réservées aux entreprises les plus nanties, les bases de données sont aujourd’hui
intégrées à la plupart des sites web, qu’elles alimentent dynamiquement en données. On peut
citer comme exemple d’utilisation de bases de données sur le web la gestion des bandeaux
publicitaires, des informations utilisateur, des listes de contacts, etc.
Pour de tels besoins, les bases de données et les pages JSP forment une bonne combinaison :
les bases de données relationnelles prennent en charge l’organisation à moindre coût de
grands ensembles de données dynamiques, tandis que les pages JSP offrent un moyen simple
de présenter ces données. On obtient ainsi des applications web dynamiques bénéficiant à la
fois de la puissance des bases de données relationnelles et de la souplesse de présentation des
JSP.
1. JSP et JDBC
À la différence d’autres langages de script tels que ColdFusion, JavaScript côté serveur ou
encore PHP, JSP ne propose pas de balises prédéfinies pour la connectivité à des bases de
données. Les concepteurs des JSP ont en effet préféré tirer avantage de JDBC, une norme
d’interface Java puissante et populaire pour les bases de données.

JSP – Java Server Pages
2
La communication avec une base de données depuis une application JSP nécessite la présence
d’un pilote ( driver ) propriétaire écrit pour l’API JDBC. Dès lors il s’agit donc du même
moyen d’accès éprouvé et efficace mis au point par Sun. Nous verrons au Chapitre 8 qu’en
pratique, on masque l’accès à la base de données dans une servlet ou un composant Java pour
l’isoler des détails de présentation de la page JSP. Deux approches différentes sont donc possi-
bles, qui sont illustrées Figure 7-1.
L’étude de l’API JDBC n’entre pas dans le cadre de ce livre, sans compter que bien des
ouvrages traitent du sujet qui compte par ailleurs une documentation fournie. Vous trouverez
en particulier des didacticiels en ligne sur le site de Sun à l’adresse http://java.sun.com/products/
jdbc . Nous ne décrivons ici que l’utilisation de JDBC dans des applications JSP.
Les classes JDBC font partie du paquetage java.sql . Celui-ci doit être importé dans toute classe Java
censée utiliser JDBC, en l’occurrence vos pages JSP. Des extensions supplémentaires peuvent être ajou-
tées à la version 2.0 de l’API JDBC à partir du paquetage
javax.sql , si celui-ci est installé sur votre
système. Si votre pilote JDBC ne se trouve pas dans le dossier de votre moteur de JSP, il faut soit l’importer
dans la page, soit y faire référence par son nom de classe complet.
1.1. JNDI et les autres sources de données
Dans certains systèmes de script utilisant des modèles, tel ColdFusion, l’accès à une base de
données se fait à l’aide d’un identifiant unique représentant une connexion prédéfinie ou un
pool de connexions fourni par l’administrateur système. On fait ainsi l’économie des détails
de connectivité au niveau du code, puisque l’on fait référence aux sources des données par un
identifiant logique tel que DBEmployes ou DBVentes . De cette manière, si un nouveau pilote doit
être utilisé, ou si le serveur de la base est déplacé, ou que les informations de session changent,
il suffit de mettre à jour la description de la ressource; les composants et les instructions qui
font référence à la ressource nommée ne nécessitent aucun changement.
JSP ne définit pas de système de gestion de ressources particulier. Il faut recourir à l’interface
Datasource de JDBC 2.0 et à l’API JNDI ( Java’s Naming and Directory Interface ) pour
Figure 7-1
Types d’accès possibles
à des bases de données
avec JSP
Requête
Accès direct
à partir
d’une page JSP
Accès à la base
gérée par une servlet ;
les résultats sont passés
à une page JSP
JSP JSP
Servlet
Pilote JDBC
API JDBC
Base de données
REMARQUE

Intégration aux bases de données
CHAPITRE 7 3
fournir les services de nommage et de localisation. JNDI permet de séparer le code de l’appli-
cation des détails concernant la base de données, tels que le pilote, le nom d’utilisateur, le mot
de passe et l’URI de la connexion. Pour créer une connexion à une base de données en utili-
sant l’interface JNDI, on spécifie un nom de ressource qui correspond à une entrée dans une
base de données ou un service de nommage, pour recevoir les informations nécessaires à
l’établissement de la connexion. Cela protège le code JSP et ses composants des modifications
pouvant être apportées à la configuration de la base. Pour en savoir plus sur l’utilisation de
JNDI, reportez-vous au site de Sun à l’adresse http://java.sun.com/products.jndi . Voici un exemple
de création d’une connexion à partir d’une source de données définie dans le registre JNDI :
Context ctx = new InitialContext();
DataSource ds = (DataSource)ctx.lookup("jdbc/DBVentes");
Connection con = ds.getConnection("username", "password");
Pour dissocier davantage le code JSP de l’accès à la base et rendre l’accès encore plus simple,
il est possible d’utiliser des balises personnalisées, qui utilisent JNDI pour l’accès à des
ressources nommées – comme ce qui se fait dans ColdFusion et d’autres langages à balises.
1.2. Les instructions préparées ( PreparedStatement )
Les instructions préparées, très similaires à des procédures stockées, sont des modèles de
requêtes SQL réutilisables avec des paramètres différents à chaque exécution. La procédure
consiste pour l’essentiel à créer la requête, qui peut être tout type d’instruction SQL, sans
définir les valeurs de certaines variables. Les valeurs manquantes sont spécifiées avant
l’exécution de la requête, qui peut être réexécutée autant de fois que nécessaire. Les instruc-
tions préparées sont créées à partir d’un objet Connection , comme des objets Statement
normaux. En SQL, les valeurs des variables à spécifier lors de l’exécution sont représentées
par un point d’interrogation ( ? ) :
String query = "SELECT * FROM GAME_RECORDS WHERE SCORE > ? AND TEAM = ?";
PreparedStatement statement = connection.prepareStatement(query);
L’objet PreparedStatement prend en charge des méthodes d’affectation de valeur de para-
mètre, correspondant chacune à un type de données particulier, int , long , String , etc. Elles
prennent deux paramètres, d’une part l’indice du paramètre à spécifier et, d’autre part, la
valeur à lui affecter. Les valeurs d’indice commencent à 1 et non à 0. Dans notre cas, pour
obtenir tous les scores supérieurs à 10 000 dans l’équipe «Gold», on initialisera les valeurs
de paramètres de la requête avec les instructions suivantes, avant de l’exécuter :
statement.setInt(1, 10000); // Score
statement.setString(2, "Gold"); // Nom de l’équipe
ResultSet results = statement.executeQuery();
Une fois créée, l’instruction préparée peut être exécutée plusieurs fois avec différentes valeurs
de paramètres. Il n’est pas nécessaire de créer d’instance nouvelle de la procédure stockée tant
que la requête reste analogue. Plusieurs requêtes peuvent ainsi être exécutées sans créer
d’objet Statement . Une instruction préparée peut même être utilisée par différents composants
d’une application ou par différents utilisateurs d’une servlet. En outre, le moteur de la base de
données n’analyse l’instruction SQL qu’une seule fois.
En outre, les instructions préparées permettent le passage de paramètres via un composant
Java plutôt que par un codage littéral. Dans l’exemple suivant, le composant Java userBean ,

JSP – Java Server Pages
4
initialisé à partir d’un formulaire de saisie, passe des paramètres de requête, d’où une simpli-
fication du code et une meilleure lisibilité :
statement.setInt(1, userBean.getScore()); // Score
statement.setString(2, userBean.getTeam()); // Nom de l’équipe
ResultSet results = statement.execute();
Pour obtenir le même résultat sans recourir au passage de paramètres, il faudrait jongler avec
des chaînes SQL, chose difficile dans le cas de requêtes complexes, comme le montre
l’exemple suivant, qui reprend le précédent mais sans faire appel à une instruction préparée :
Statement statement = connection.getStatement();
String query = "SELECT * FROM GAME_RECORDS WHERE SCORE > " +
userBean.getScore() + " AND TEAM = ‘" + user.getTeam() +
userBean.getTeam() + "’";
ResultSet results = Statement.executeQuery(query);
Ce dernier exemple met en évidence un autre avantage décisif de l’utilisation des instructions
préparées, à savoir l’économie des détails de mise en forme. En effet, lorsqu’une valeur de
paramètre est spécifiée dans une instruction préparée à l’aide d’une méthode d’affectation, nul
besoin de se soucier des guillemets nécessaires à l’identification des chaînes de caractères, ni
des caractères d’échappement, des conversions de dates et autres exigences de formats parti-
culiers à la base de données. C’est un avantage stratégique dans le cas de pages JSP destinées
à récolter des paramètres de requête directement à partir de formulaires remplis par les utili-
sateurs, et de ce fait exposées à d’imprévisibles erreurs de saisie et toutes sortes de caractères
spéciaux. Chaque base de données étant généralement soumise à des contraintes de format
particulières, notamment de date, l’utilisation d’instructions préparées contribue à affranchir
encore votre code des spécificités propres à chaque base.
2. Les pages JSP orientées base de données
Bien des moyens permettent de développer des applications bases de données avec les JSP.
Dans ce chapitre, nous n’allons étudier que l’interaction entre JSP et une base de données,
sans nous attarder sur l’architecture du programme. La conception d’applications JSP sera
traitée au Chapitre 8 et illustrée au Chapitre 9 par un exemple de projet web utilisant une base
de données.
2.1. Intégration des données d’une table dans une page JSP
L’intégration d’une base de données à une application JSP repose principalement sur l’utilisa-
tion de composants JavaBeans, servant à faire le lien entre la base et les pages JSP. Chaque
composant permet de récupérer ligne par ligne des données contenues dans une table, grâce à
l’analogie qui peut être établie entre une table de base de données et un composant : la struc-
ture d’une table, telle la classe d’un composant, spécifie le type et le nom des données qu’elle
contient; les colonnes d’une table, telles les propriétés d’un composant, permettent de stocker
les valeurs de chaque instance du type contenu. Enfin, les tables et les classes sont des
modèles de stockage d’informations et, à ce titre, n’ont d’utilité pratique que par les données
qu’elles permettent de stocker (bons d’achat, détails d’inventaire, etc.); une table vide n’a pas
d’utilité pratique, tout comme une classe qui n’a pas été instanciée.