Moduledeprogrammationclient Serveurjoska

See discussions, stats, and author profiles for this publication at: https://www.researchgate.
net/publication/371226170
Cours de programmation client/serveur Cours dispense par: Ir

KALEMA JOSUE
Book · June 2023
CITATIONS READS
0 538
1 author:
Kalema Josue
Univeriste Advenstiste de Goma
3 PUBLICATIONS 1 CITATION
SEE PROFILE
All content following this page was uploaded by Kalema Josue on 02 June 2023.
The user has requested enhancement of the downloaded file.

Cours de programmation
client/serveur
INSTITUT SUPERIEUR DE
COMMERCE/ GOMA
Module adapté aux étudiants de Deuxième Année de Licence en Science et
technologie ( Mention:Informatique de Gestion)
Cours dispense par: Ir KALEMA JOSUE

+243992565394,josuekalema@gmail.com
June 2, 2023 @joska,chef de travaux 1

OBJECTIF
L’objectif de ce document est de synthétiser les

points essentiels à connaître et à comprendre
pour pouvoir faire la programmation client-serveur
aux différentes couches du modèle OSI : UDP,

TCP/IP, présentation,.. L'objectif est de bien
comprendre ce que l'on peut faire et comment on
peut le faire au fur et à mesure qu’on evoluera dans
ce module.
OBJECTIFS
L’étudiant sera capable, à la fin de ce cours, de:
 Comprendre l’architecture client/serveur;
 Comprendre les mécanismes réseau
 Coder une application reseau utilisant les Sockets
 Faire le CRUD(Create,Read,Update,Delete) dans une application

client/seveur(2tiers) utilisant une base de données partagée
 De faire un pas sur la programmation client/serveur(3 tiers) utilisant le

framework Web JSP(java server page)

PLAN DU COURS
 GENERALITE SUR L’ARCHITECTURE
CLIENT/SERVEUR
 LES SOCKETS
 CLIENT/SERVEUR 2TIERS
 CLIENT/SERVEUR 3TIERS

COTATION ET PROGRAMME
 15% PRESENCE
 45% TP
 40% EXAMEN PRATIQUE
 60H(20h theorique , 20h TD,20 TP)
 retro-projecteur, google class room

PREREQUIS
 Programmation orientée objet en

Java(classe,object,encapsulation,heritage,
polymorphisme,surcharge)
 SQL
 HTML,CSS
 Adressage IP v4

CHAP 1:Généralités
Utilisation du modèle CLIENT/SERVEUR

S’étend de plus en plus vers tous les domaines d’activités :
 World Wide Web (web)
 Gestion de bases de données (programmation procédural)
 Systèmes transactionnels(transaction )
 Systèmes de messagerie
 Systèmes de partage de données (système distribue ,repartie ,partagé,

federé)
 etc.

 En programmation client-serveur, on a généralement à écrire deux
programmes : un programme appelé serveur et un programme appelé client.
Ces deux programmes sont amenés à établir un dialogue à travers une
connexion réseau. Cela signifie que les deux programmes peuvent être
exécutés sur des systèmes (machines) différents, et que le réseau va être
utilisépour communiquer.
 Dans le cadre des TPs de réseau, les communications se feront normalement

en utilisant le protocole TCP/IP qui est un protocole connecté et fiable. Ce
protocole est dit fiable car les données envoyées sont reçues dans l’ordre,
sans perte, ni duplication. C’est seulement pour le dernier TP que le protocole
non connecté UDP sera abordé.

 Pour pourvoir communiquer en TCP, il faut commencer par établir une connexion.
Pour cela, le programme qui a le rôle de serveur se met état d’attendre une
demande de connexion.
 Le programme client va alors demander à se connecter au serveur. Lorsque ce
dernier accepte la demande de connexion, la connexion est établie et le dialogue
peut commencer.
 Le client et le serveur dialoguent ensuite suivant un protocole qui définit la nature et
l’ordre des messages échangés. Le protocole dépend du problème à résoudre, et est
à définir avant d’écrire les programmes. Bien souvent les protocoles simples auront
la forme suivante :
1. la connexion est établie ;
2. le client envoie une requête (il pose une question), et attend le réponse du serveur ;
3. le serveur reçoit la requête du client, construit sa réponse et envoie la réponse au
client ;
4. le client reçoit la réponse du serveur ;
5. la connexion est fermée (terminée).

 Les principales caractéristiques des programmes client et serveur sont ainsi :
serveur : le programme serveur est celui qui attend les demandes de connexion.
Normalement, il n’y a qu’un seul processus serveur qui est exécuté. Le serveur est
généralement écrit pour pouvoir répondre à un nombre infini de clients. On peut
distinguer les serveurs itératifs qui répondent aux clients les uns après les autres, et les
serveurs parallèles, plus évolués, qui sont capables de répondre à plusieurs clients en
même temps.
client : le programme client est celui qui fait la demande de connexion au serveur. On
peut exécuter plusieurs processus clients pour un seul serveur.
On peut remarquer que ce fonctionnement est analogue à une conversation téléphonique. Avant de pouvoir
dialoguer, il faut établir une connexion où l’un des interlocuteurs (le client) appelle l’autre (le serveur). Lorsque le
serveur répond, la connexion est établie et elle reste active jusqu’à ce qu’un des interlocuteurs raccroche

Numéro de port. Les connexions TCP se font entre les systèmes en utilisant les
adresses IP et des numéros de port. Un numéro de port est un nombre entier sur 16
bits (1–65535) Une connexion TCP est alors identifiée de manière unique par un
quadruplet (adresse source, port source, adresse destination, port destination).

 Présentation de l'architecture d'un système client/serveur

De nombreuses applications fonctionnent selon un environnement client/serveur, cela
signifie que des machines clientes (des machines faisant partie du réseau) contactent
un serveur, une machine généralement très puissante en terme de capacités d'entrée-
sortie, qui leur fournit des services. Ces services sont des programmes fournissant des
données telles que l'heure, des fichiers, une connexion, etc
Les services sont exploités par des programmes, appelés programmes clients,
s'exécutant sur les machines clientes. On parle ainsi de client (client FTP, client de
messagerie, etc.) lorsque l'on désigne un programme tournant sur une machine cliente,
capable de traiter des informations qu'il récupère auprès d'un serveur (dans le cas du
client FTP il s'agit de fichiers, tandis que pour le client de messagerie il s'agit de courrier
électronique).
 Avantages de l'architecture client/serveur
Le modèle client/serveur est particulièrement recommandé pour des réseaux nécessitant un grand
niveau de fiabilité, ses principaux atouts sont :
des ressources centralisées : étant donné que le serveur est au centre du réseau, il peut gérer
des ressources communes à tous les utilisateurs, comme par exemple une base de données
centralisée, afin d'éviter les problèmes de redondance et de contradiction
une meilleure sécurité : car le nombre de points d'entrée permettant l'accès aux données est
moins important
une administration au niveau serveur : les clients ayant peu d'importance dans ce modèle, ils
ont moins besoin d'être administrés
un réseau évolutif : grâce à cette architecture il est possible de supprimer ou rajouter des clients
sans perturber le fonctionnement du réseau et sans modification majeure
 Inconvénients du modèle client/serveur

L'architecture client/serveur a tout de même quelques lacunes parmi lesquelles :
un coût élevé dû à la technicité du serveur
un maillon faible : le serveur est le seul maillon faible du réseau client/serveur, étant donné que
tout le réseau est architecturé autour de lui ! Heureusement, le serveur a une grande tolérance aux
pannes (notamment grâce au système RAID)
 Architecture du Peer to Peer
Dans une architecture de réseau peer-to-peer, chaque ordinateur a les mêmes
responsabilités et les mêmes capacités. Comme il n'y a pas de serveur, les ordinateurs se
connectent entre eux dans un groupe de travail pour partager des fichiers, des imprimantes et
l'accès à Internet.

 Table de comparaison(client serveur vs peer To peer)

 LES DIFFÉRENTES ARCHITECTURES CLIENT/SERVEUR
L'ARCHITECTURE 2 TIERS
Dans une architecture deux tiers, encore appelée client-serveur de première génération ou client-
serveur de données, le poste client se contente de déléguer la gestion des données à un service
spécialisé. Le cas typique de cette architecture est une application de gestion fonctionnant sous
Windows ou Linux et exploitant un SGBD centralisé.
Ce type d'application permet de tirer partie de la puissance des ordinateurs déployés en réseau
pour fournir à l'utilisateur une interface riche, tout en garantissant la cohérence des données, qui
restent gérées de façon centralisée.
La gestion des données est prise en charge par un SGBD centralisé, s'exécutant le plus souvent sur
un serveur dédié. Ce dernier est interrogé en utilisant un langage de requête qui, le plus souvent,
est SQL. Le dialogue entre client et serveur se résume donc à l'envoi de requêtes et au retour des
données correspondant aux requêtes.


Les limites de l'architecture deux tiers proviennent en grande partie de la nature du client utilisé :
 le frontal est complexe et non standard (même s'il s'agit presque toujours d'un PC sous
Windows),
 le middleware entre client et serveur n'est pas standard (dépend de la plate-forme, du SGBD
...).
La solution résiderait donc dans l'utilisation d'un poste client simple communicant avec le serveur
par le biais d'un protocole standard.
Dans ce but, l'architecture trois tiers applique les principes suivants :
 les données sont toujours gérées de façon centralisée,
 la présentation est toujours prise en charge par le poste client,
 la logique applicative est prise en charge par un serveur intermédiaire.
Cette architecture trois tiers, également appelée client-serveur de deuxième génération ou client-
serveur distribué sépare l'application en 3 niveaux de services distincts, conformes au principe
précédent :
 premier niveau : l'affichage et les traitements locaux (contrôles de saisie, mise en forme de
données...) sont pris en charge par le poste client,
 deuxième niveau : les traitements applicatifs globaux sont pris en charge par le service
applicatif,
 troisième niveau : les services de base @joska,chef
June 2, 2023
de données sont pris en charge par un SGBD.
de travaux 18


L'ARCHITECTURE N TIERS
L'architecture n-tiers a été pensée pour pallier aux limites des architectures trois tiers et concevoir
des applications puissantes et simples à maintenir. Ce type d'architecture permet de distribuer plus
librement la logique applicative, ce qui facilite la répartition de la charge entre tous les niveaux.
Cette évolution des architectures trois tiers met en oeuvre une approche objet pour offrir une plus
grande souplesse d'implémentation et faciliter la réutilisation des développements.
Cette architecture est basée sur l'utilisation de composants "métier'', spécialisés et indépendants,
introduits par les concepts orientés objets (langages de programmation et middleware). Elle
permet de tirer pleinement partie de la notion de composants métiers réutilisables.
Ces composants rendent un service si possible générique et clairement identifié. Ils sont capables
de communiquer entre eux et peuvent donc coopérer en étant implantés sur des machines
distinctes.

Un RESEAUX INFORMATQUE
Reseau informatique (en anglais : data communication network ou DCN) est un ensemble
d'équipements reliés entre eux pour échanger des informations. Par analogie avec un filet (un
réseau est un « petit rets », c'est-à-dire un petit filet1), on appelle nœud l'extrémité d'une
connexion, qui peut être une intersection de plusieurs connexions ou équipements (un ordinateur,
un routeur, un concentrateur, un commutateur).

 L'introduction aux concepts liés au réseau
Depuis son origine, Java fournit plusieurs classes et interfaces destinées à faciliter l'utilisation du
réseau par programmation.
Le modèle OSI (Open System Interconnection) propose un découpage en sept couches des
différents composants qui permettent la communication sur un réseau.


 L'introduction aux concepts liés au réseau
Le protocole IP est un protocole de niveau réseau qui permet d'échanger des paquets d'octets
appelés datagrammes. Ce protocole ne garantit pas l'arrivée à bon port des messages. Cette
fonctionnalité peut être implémentée par la couche supérieure, comme par exemple avec TCP. Un
datagramme IP est l'unité de transfert à ce niveau. Cette série d'octets contient les informations du
message, un en tête (adresse source de destination, ...) mais aussi des informations de contrôle.
Ces informations permettent aux routeurs de faire transiter les paquets sur l'internet.
La couche de transport est implémentée dans les protocoles UDP ou TCP. Ils permettent la
communication entre des applications sur des machines distantes.
La notion de service permet à une même machine d'assurer plusieurs communications

simultanément.
Le système des sockets est le moyen de communication interprocessus développé pour l'Unix
Berkeley (BSD). Il est actuellement implémenté sur tous les systèmes d'exploitation utilisant
TCP/IP. Une socket est le point de communication
par lequel un thread peut émettre ou recevoir des informations et ainsi elle permet la
communication entre deux applications à travers le réseau.
 La communication se fait sur un port particulier de la machine. Le port est une entité logique
qui permet d'associer un service particulier à une connexion. Un port est identifié par un entier
de 1 à 65535. Par convention les 1024 premiers sont réservés pour des services standard (80 :
HTTP, 21 : FTP, 25: SMTP, ...)
 Java prend en charge deux protocoles : TCP et UDP.
Les classes et interfaces utiles au développement réseau sont regroupés dans le package java.net.

Les adresses internet
 Une adresse internet permet d'identifier de façon unique une machine sur un réseau. Cette adresse pour le
protocole I.P. est sous la forme de quatre octets séparés chacun par un point. Chacun de ces octets
appartient à une classe selon l'étendue du réseau.
Pour faciliter la compréhension humaine, un serveur particulier appelé DNS (Domaine Name Service) est capable
d'associer un nom à une adresse I.P.
La classe InetAddress
Une adresse internet est composée de quatre octets séparés chacun par un point.
Un objet de la classe InetAddress représente une adresse Internet. Elle contient des méthodes pour lire une
adresse, la comparer avec une autre ou la convertir en chaîne de caractères. Elle ne possède pas de constructeur
: il faut utiliser certaines méthodes statiques de la classe pour obtenir une instance de cette classe.
La classe InetAdress encapsule des fonctionnalités pour utiliser les adresses internet. Elle ne possède pas de
constructeur mais propose trois méthodes statiques :


 import java.net.*;
public class TestNet1 {

public static void main(String[] args) {
try {
InetAddress adrLocale = InetAddress.getLocalHost();
System.out.println("Adresse locale = "+adrLocale.getHostAddress());
InetAddress adrServeur = InetAddress.getByName("java.sun.com");
System.out.println("Adresse Sun = "+adrServeur.getHostAddress());
InetAddress[] adrServeurs = InetAddress.getAllByName("www.microsoft.com");
System.out.println("Adresses Microsoft : ");
for (int i = 0; i > adrServeurs.length; i++) {
System.out.println(" "+adrServeurs[i].getHostAddress());
}
} catch (Exception e) {
e.printStackTrace();
}
}
}

resultat

La classe URLConnection
Cette classe abstraite encapsule une connexion vers une ressource désignée par une URL pour
obtenir un flux de données ou des informations sur la ressource.
import java.net.*;
import java.io.*;
public class TestURLConnection {
String donnees;
try {
URL monURL = new URL("http://localhost/fichiers/test.txt");
URLConnection connexion = monURL.openConnection();
InputStream flux = connexion.getInputStream();
int donneesALire = connexion.getContentLength();
for(;donneesALire != 0; donneesALire--)
System.out.print((char)flux.read());
// Fermeture de la connexion
flux.close();
}}}2, 2023
June @joska,chef de travaux 31
Activite
 INSTALLATION DE NETBEANS

CHAP 2:les Sockets
Definition
Les sockets sont une interface de programmation de bas niveau pour la communication
réseau. Une Socket est une liaison point à point entre un serveur et un client (le code des
programmes est légèrement différent). La communication est full-duplex (en fait, les
communications sont probablement bufférisées avant d'être envoyées, doù l'apparence du
full-duplex là où TCP/IP ne sait faire que du half-duplex), le protocole d'échange
d'informations est laissé à la charge du programmeur.

CHAP 2:les Sockets
Le client
Le client est un logiciel installé sur l'ordinateur local qui permet d'une part une utilisation
optimisée des ressources locales (souris, écran, etc), et d'autre part une communication
avec un serveur du réseau. C'est lui qui fait le premier pas lors d'une connexion avec un
serveur en établissant une Socket. Pour créer une socket dans un programme Java, le
programmeur doit spécifier le nom de machine où se trouve le serveur et le port où l'ondoit se

connecter.
 ma-socket = new Socket ("machine.dz", 1999);

CHAP 2:les Sockets
Le Serveur
Un serveur est un logiciel exécuté sur un certain ordinateur du réseau, 24 heures sur 24.
Il accepte commandes, questions, demandes et envoie une réponse automatiquement. 11
attend la connexion d'un client sur un port de l'ordinateur sur lequel il est installé et
renvoie des données demandées. Dans un programme Java, le serveur doit créer une
ServerSocket en indiquant son numéro de port puis attendre qu'un client demande une
connexion qui peut alors être acceptée. Des flux d'entrées sont ensuite définis et les
échanges peuvent commencer selon le protocole choisi. En fin de programme, toutes les
sockets doivent être libérées.

CHAP 2:les Sockets
Le Serveur

CHAP 2:les Sockets

CHAP 2:les Sockets

CHAP 2:les Sockets
La classe SocketServer
La classe ServerSocket est utilisée côté serveur : elle attend simplement les appels du ou des
clients. C'est un objet du type Socket qui prend en charge la transmission des données.
Cette classe représente la partie serveur du socket. Un objet de cette classe est associé à un port
sur lequel il va attendre les connexions d'un client. Généralement, à l'arrivée d'une demande de
connexion, un thread est lancé pour assurer le dialogue avec le client sans bloquer les connexions
des autres clients.
La classe SocketServer possède plusieurs constructeurs dont les principaux sont :

CHAP 2:les Sockets
La classe SocketServer
Tous ces constructeurs peuvent lever une exception de type IOException.
La classe SocketServer possède plusieurs méthodes :
Si un client tente de communiquer avec le serveur, la méthode accept() renvoie une socket qui
encapsule la
communication avec ce client.
Le mise en oeuvre de la classe SocketServer suit toujours la même logique :
 · créer une instance de la classe SocketServer en précisant le port en paramètre
 · définir une boucle sans fin contenant les actions ci dessous
 · appelle de la méthode accept() qui renvoie une socket lors d'une nouvelle connexion
 · obtenir un flux en entrée et en sortie à partir de la socket
 · écrire les traitements à réaliser

CHAP 2:les Sockets
La classe Socket
Les sockets implémentent le protocole TCP (Transmission Control Protocol). La classe contient les
méthodes de création des flux d'entrée et de sortie correspondants. Les sockets constituent la base
des communications par le réseau.
Comme les flux Java sont transformés en format TCP/IP, il est possible de communiquer avec
l'ensemble des ordinateurs qui utilisent ce même protocole. La seule chose importante au niveau
du système d'exploitation est qu'il soit capable de gérer ce protocole.
Cette classe encapsule la connexion à une machine distante via le réseau. Cette classe gère la
connexion, l'envoi de données, la réception de données et la déconnexion.
 La classe Socket possède plusieurs constructeurs dont les principaux sont :

CHAP 2:les Sockets
La classe Socket possède de nombreuses méthodes :
Le mise en œuvre de la classe Socket suit toujours la même logique :
· créer une instance de la classe Socket en précisant la machine et le port en paramètre

· obtenir un flux en entrée et en sortie
· écrire les traitements à réaliser

CHAP 2:les Sockets
Serveur
package isc;
import java.io.* r;
import java.net.*;

try {
ServerSocket ss=new ServerSocket(1234);
System.out.println("j'attends la connection");
Socket s=ss.accept();
InputStream is=s.getInputStream();
OutputStream os=s.getOutputStream();
System.out.println("j'attends que le client envoie un octet");
//ce que le client envoie
int nb=is.read();
System.out.println("j'ai recu un nombre"+nb);
int rs=nb *5;
System.out.println("j'envoie la reponse"+rs);
os.write(rs);
s.close();
}
catch(Exception e){
}
}
}
CHAP 2:les Sockets
Client
import java.io.*;
import java.net.Socket;
import java.util.Scanner;
public class ClientISC {

try {
System.out.println("je me connecte au serveur");
Socket socket=new Socket("localhost",1234);
InputStream is=socket.getInputStream();
OutputStream os=socket.getOutputStream();
Scanner scanner=new Scanner(System.in);
System.out.println("Donner un nombre:");
int nb=scanner.nextInt();
System.out.println("jenvoie le nomre "+nb+"au serveur");
os.write(nb);
//reponse
System.out.println("j attends reponse du serveur");
int rep= is.read();
System.out.println("la reponse du serveur"+rep);
} catch (Exception ex) {

//ex.printStackTrace();
}}}
CHAP 2:les Sockets
Client
import java.io.*;
import java.net.Socket;
import java.util.Scanner;
public class ClientISC {

try {
System.out.println("je me connecte au serveur");
Socket socket=new Socket("localhost",1234);
InputStream is=socket.getInputStream();
OutputStream os=socket.getOutputStream();
Scanner scanner=new Scanner(System.in);
System.out.println("Donner un nombre:");
int nb=scanner.nextInt();
System.out.println("jenvoie le nomre "+nb+"au serveur");
os.write(nb);
//reponse
System.out.println("j attends reponse du serveur");
int rep= is.read();
System.out.println("la reponse du serveur"+rep);
} catch (Exception ex) {

//ex.printStackTrace();
}}}
CHAP 2:les Sockets
ACTIVITE
 Creer une application de chat sur un reseau(envoie et reception des messages)

CHAP 2:les Sockets
 PARTIE SERVEUR:
package serveurchat;
import java.io.*;
import java.net.*;
public class chat_Serveur extends javax.swing.JFrame {
static ServerSocket ss;
static Socket s;
static DataInputStream din;
static DataOutput dout;
 ///BUTON ENVOYER////
try{ String msgou="";
msgou=msg_text.getText().trim();
dout.writeUTF(msgou);
}
catch(Exception e){
}
///////////DANS LE CONTRUCTEUR ////////////////////////
String msgin="";
try {
ss=new ServerSocket(1200);
s=ss.accept();
din=new DataInputStream(s.getInputStream());
dout=new DataOutputStream(s.getOutputStream());
while(!msgin.equals("exit")){
msgin=din.readUTF();
msg_area.setText(msg_area.getText().trim()+"\n"+msgin); }
} catch (Exception e) { }
CHAP 2:les Sockets
 PARTIE CLIENT:
package serveurchat;
import java.io.*;
import java.net.*;
public class Client_chat extends javax.swing.JFrame {
static Socket s;
static DataInputStream din;
static DataOutput dout;
 ///BUTON ENVOYER////
try{
String msgout="";
msgout=jTextField1.getText().trim();
dout.writeUTF(msgout);}
catch(Exception e){}
///////////DANS LE CONTRUCTEUR ////////////////////////
try{
s=new Socket("127.0.0.1", 1200);
din=new DataInputStream(s.getInputStream());
dout=new DataOutputStream(s.getOutputStream());
String msgin="";
while(!msgin.equals("exit")){
msgin=din.readUTF();
jTextArea1.setText(jTextArea1.getText().trim()+"\n Serveur:\t"+msgin );
}}
catch(Exception e){
}

CHAP 2:les Sockets
 Exercice: Créer une application client/serveur dans laquelle le client fourni 2
nombres entrer au clavier par l’utilisateur puis le serveur additionne ces 2 nombres
puis envoie la réponse au client

CHAP 3:Programmation
client/serveur: 2tiers
L'architecture à deux niveaux (aussi appelée architecture 2-tier, tier signifiant rangée en anglais)
caractérise les systèmes clients/serveurs pour lesquels le client demande une ressource et le
serveur la lui fournit directement, en utilisant ses propres ressources. Cela signifie que le serveur
ne fait pas appel à une autre application afin de fournir une partie du service.

Interactions avec les bases de données
JDBC : la porte d'accès aux bases de données
Dans ce chapitre, nous ferons nos premiers pas avec Java DataBase Connectivity, communément appelé JDBC. Il s'agit en fait
de classes Java permettant de se connecter et d'interagir avec des bases de données. Mais avant toute chose, il nous faut une
base de données ! Nous allons donc nous pencher sur l'utilité d'une base de données et verrons comment en installer une que
nous utiliserons afin d'illustrer la suite de cette partie.
Pour commencer, je pense qu'un petit rappel sur le fonctionnement des bases de données s'impose.
 Rappels sur les bases de données
Lorsque vous réalisez un logiciel, un site web ou quelque chose d'autre, vous êtes confrontés tôt ou tard à cette question : «
Comment vais-je procéder pour sauvegarder mes données ? Pourquoi ne pas tout stocker dans des fichiers ? »
Les bases de données (BDD) permettent de stocker des données. Mais concrètement, comment cela fonctionne-t-il ? En
quelques mots, il s'agit d'un système de fichiers contenant les données de votre application. Cependant, ces fichiers sont
totalement transparents pour l'utilisateur d'une base de données, donc totalement transparents pour vous ! La différence avec
les fichiers classiques se trouve dans le fait que ce n'est pas vous qui les gérez : c'est votre BDD qui les organise, les range et, le
cas échéant, vous retourne les informations qui y sont stockées. De plus, plusieurs utilisateurs peuvent accéder simultanément
aux données dont ils ont besoin, sans compter que de nos jours, les applications sont amenées à traiter une grande quantité de
données, le tout en réseau. Imaginez-vous gérer tout cela manuellement alors que les BDD le font automatiquement…
Quelle base de données utiliser
Il existe plusieurs bases de données et toutes sont utilisées par beaucoup de développeurs. Voici une liste non exhaustive
recensant les principales bases :
PostgreSQL ;
MySQL ;
SQL Server ;
Oracle ;
Access.
Toutes ces bases de données permettent d'effectuer les actions que je vous ai expliquées plus haut. Chacune possède des
spécificités : certaines sont payantes (Oracle), d'autres sont plutôt permissives avec les données qu'elles contiennent (MySQL),
d'autres encore sont dotées d'un système de gestion très simple à utiliser (MySQL), etc. C'est à vous de faire votre choix en
regardant par exemple sur Internet ce qu'en disent les utilisateurs. Pour cette partie traitant des bases de données, mon choix
s'est porté sur PostgreSQL qui est gratuit et complet.

Recherche des pilotes JDBC pour votre base de donnees
Ceux d'entre vous qui ont déjà installé une imprimante savent que leur machine a besoin d'un driver (appelé aussi pilote, c'est
une sorte de mode d'emploi utilisé par l'ordinateur) pour que la communication puisse s'effectuer entre les deux acteurs. Ici, c'est
la même chose : pgAdmin utilise un driver pour se connecter à la base de données. Étant donné que les personnes qui ont
développé les deux logiciels travaillent main dans la main, il n'y aura pas de problème de communication ; mais qu'en sera-t-il
pour Java ?
En fait, avec Java, vous aurez besoin de drivers, mais pas sous n'importe quelle forme : pour vous connecter à une base de
données, il vous faut un fichier .jar qui correspond au fameux pilote et qui contient tout ce dont vous aurez besoin pour vous
connecter à une base PostgreSQL.
Cela signifie-t-il qu'il existe un fichier .jar par SGBD ?
Tout à fait, il existe un fichier .jar pour se connecter à :
 MySQL ;
 SQL Server ;
 Oracle ;
 d'autres bases.

 Connexion
La base de données est prête, les tables sont créées, remplies et nous possédons le driver
nécessaire ! Il ne nous reste plus qu'à nous connecter. Créons un nouveau projet dans Eclipse avec
une classe contenant une méthode public static void main(String[] args). Voici le code source
permettant la connexion :
public class Connect {
try {
Class.forName("org.postgresql.Driver");
System.out.println("Driver O.K.");
String url = "jdbc:postgresql://localhost:5432/Ecole";
String user = "postgres";
String passwd = "postgres";
Connection conn = DriverManager.getConnection(url, user,passwd);
System.out.println("Connexion effective !");
e.printStackTrace(); }}}
 Connexion
À ce stade, il existe comme un pont entre votre programme Java et votre BDD, mais le trafic
routier n'y est pas encore autorisé : il faut qu'une connexion soit effective afin que le programme
et la base de données puissent communiquer. Cela se réalise grâce à cette ligne de code :
 Code : Java
Connection conn = DriverManager.getConnection(url, user, passwd);
Nous avons défini au préalable trois String contenant respectivement :

 l'URL de connexion ;
 le nom de l'utilisateur ;
 le mot de passe utilisateur.

 Connexion: Configuration du serveur de base de données
Dans le cas de partage de la base de données, il faut modifier l’adresse IP au niveau de l’URL de
connexion et ajouter les règles au niveau de Pare-feu en autorisant le Port d’entre et de sortie .
String url = "jdbc:192.168.10.2://localhost:5432/Ecole";




 Fouiller dans sa base de données
Nous continuons notre voyage initiatique au pays de JDBC en abordant la manière d'interroger notre BDD. Eh oui, une base de
données n'est utile que si nous pouvons consulter, ajouter, modifier et supprimer les données qu'elle contient. Pour y parvenir, il
était impératif de se connecter au préalable. Maintenant que c'est chose faite, nous allons voir comment fouiner dans notre BDD.
Le couple Statement - ResultSet
Voici deux objets que vous utiliserez sûrement beaucoup ! En fait, ce sont ces deux objets qui permettent de récupérer des
données de la BDD et de travailler avec celles-ci. Afin de vous faire comprendre tout cela de façon simple, voici un exemple assez
complet (mais tout de même pas exhaustif) affichant le contenu de la table classe :

public class Connect {
try {
Class.forName("org.postgresql.Driver");
String url = "jdbc:postgresql://localhost:5432/Ecole";
String user = "postgres";
String passwd = "postgres";
Connection conn = DriverManager.getConnection(url, user,
passwd);
//Création d'un objet Statement
Statement state = conn.createStatement();
//L'objet ResultSet contient le résultat de la requête SQL
ResultSet result = state.executeQuery("SELECT * FROM classe");
//On récupère les MetaData
ResultSetMetaData resultMeta = result.getMetaData();
System.out.println("\n**********************************");

//On affiche le nom des colonnes
for(int i = 1; i <= resultMeta.getColumnCount(); i++)
System.out.print("\t" +
resultMeta.getColumnName(i).toUpperCase() + "\t *");
System.out.println("\n**********************************");
while(result.next()){
for(int i = 1; i <= resultMeta.getColumnCount(); i++)
System.out.print("\t" + result.getObject(i).toString() +
"\t |");
System.out.println("\n---------------------------------");
result.close();
state.close(); } catch (Exception e) {
e.printStackTrace(); }}}

J'ai simplement exécuté une requête SQL et récupéré les lignes retournées. Mais détaillons un peu plus ce qu'il s'est passé. Déjà,
vous avez pu remarquer que j'ai spécifié l'URL complète pour la connexion : sinon, comment savoir à quelle BDD se connecter ?
Ce dernier point mis à part, les choses se sont déroulées en quatre étapes distinctes :
création de l'objet Statement ; exécution de la requête SQL ; récupération et affichage des données via l'objet ResultSet ;
fermeture des objets utilisés (bien que non obligatoire, c'est recommandé).
L'objet Statement permet d'exécuter des instructions SQL, il interroge la base de données et retourne les résultats. Ensuite,
ces résultats sont stockés dans l'objet ResultSet, grâce auquel on peut parcourir les lignes de résultats et les afficher.
Comme je vous l'ai mentionné, l'objet Statement permet d'exécuter des requêtes SQL. Ces dernières peuvent être de différents
types :
CREATE ;
INSERT ;
UPDATE ;
SELECT ;
DELETE.

L'objet Statement est fourni par l'objet Connection grâce à l'instruction conn.createStatement(). Ce que j'ai fait,
ensuite, c'est demander à mon objet Statement d'exécuter une requête SQL de type SELECT : SELECT * FROM classe.
Elle demande à la BDD de nous envoyer toutes les classes.
Puisque cette requête retourne un résultat contenant beaucoup de lignes, contenant elles-mêmes plusieurs colonnes, j'ai stocké
ce résultat dans un objet ResultSet, qui permet d'effectuer diverses actions sur des résultats de requêtes SQL.
Ici, j'ai utilisé un objet de type ResultSetMetaData afin de récupérer les métadonnées de ma requête, c'est-à-dire ses
informations globales. J'ai ensuite utilisé cet objet afin de récupérer le nombre de colonnes renvoyé par la requête SQL ainsi que
leur nom. Cet objet de métadonnées permet de récupérer des informations très utiles, comme :
le nombre de colonnes d'un résultat ;
le nom des colonnes d'un résultat ;
le type de données stocké dans chaque colonne ;
le nom de la table à laquelle appartient la colonne (dans le cas d'une jointure de tables) ;
etc.

 Statement
Vous avez vu comment obtenir un objet Statement. Mais je ne vous ai pas tout dit… Vous savez déjà que pour récupérer un objet
Statement, vous devez le demander gentiment à un objet Connection en invoquant la méthode
createStatement(). Ce que vous ne savez pas, c'est que vous pouvez spécifier des paramètres pour la création de l'objet Statement.
Ces paramètres permettent différentes actions lors du parcours des résultats via l'objet ResultSet.
Le premier paramètre est utile pour la lecture du jeu d'enregistrements :
 TYPE_FORWARD_ONLY : le résultat n'est consultable qu'en avançant dans les données renvoyées, il est donc impossible de
revenir en arrière lors de la lecture ;
 TYPE_SCROLL_SENSITIVE : le parcours peut se faire vers l'avant ou vers l'arrière et le curseur peut se positionner n'importe
où, mais si des changements surviennent dans la base pendant la lecture, il ne seront pas visibles ;
 TYPE_SCROLL_INSENSITIVE : à la différence du précédent, les changements sont directement visibles lors du parcours des
résultats.
Le second concerne la possibilité de mise à jour du jeu d'enregistrements :
 CONCUR_READONLY : les données sont consultables en lecture seule, c'est-à-dire que l'on ne peut modifier des valeurs
pour mettre la base à jour ;
 CONCUR_UPDATABLE : les données sont modifiables ; lors d'une modification, la base est mise à jour.

 Les requêtes préparées
Il va falloir vous accrocher un tout petit peu… De tels objets sont créés exactement de la même façon que des Statement
classiques, sauf qu'au lieu de cette instruction :
Code : Java
 Statement stm = conn.createStatement();

… nous devons écrire ceci :
Code : Java
 PreparedStatement stm = conn.prepareStatement("SELECT * FROM classe");
Jusqu'ici, rien de spécial. Cependant, une différence est déjà effective à ce stade : la requête SQL est
précompilée ! Cela a pour effet de réduire le temps d'exécution dans le moteur SQL de la BDD. C'est normal,
étant donné qu'il n'aura pas à compiler la requête. En règle générale, on utilise ce genre d'objet pour des
requêtes contenant beaucoup de paramètres ou pouvant être exécutées plusieurs fois. Il existe une autre
différence de taille entre les objets PreparedStatement et Statement : dans le premier, on peut utiliser des
paramètres à trous !

 PATRON D’ACHITECTURE: MVC

 Le modèle de programmation MVC.
MVC est une architecture permettant de créer des applications à l'aide d'une
conception MVC (Model View Controller):
 Le modèle représente le cœur de l'application (par exemple une liste
d'enregistrements de base de données).
 La vue affiche les données (les enregistrements de la base de données).
 Le contrôleur gère l'entrée (dans les enregistrements de la base de données).
Le modèle MVC définit

les applications avec 3 couches logiques
:
La couche métier (logique du modèle)

La couche d'affichage (logique de vue)
Le contrôle d'entrée (logique du
contrôleur)

 Le modèle est la partie de l'application qui gère la logique des données
d'application.
Souvent, les objets de modèle récupèrent des données (et stockent des
données) à partir d'une base de données.
 La vue est la partie de l'application qui gère l'affichage des données.
Le plus souvent, les vues sont créées à partir des données du modèle.
 Le contrôleur est la partie de l'application qui gère l'interaction de
l'utilisateur.
En règle générale, les contrôleurs lisent les données d'une vue, contrôlent
l'entrée de l'utilisateur et envoient les données d'entrée au modèle.
La séparation MVC vous aide à gérer des applications complexes, car vous
pouvez vous concentrer sur un aspect à la fois. Par exemple, vous pouvez vous
concentrer sur la vue sans dépendre de la logique métier. Cela facilite également
le test d'une application.
La séparation MVC simplifie également le développement de groupe. Différents
développeurs peuvent travailler sur la vue, la logique du contrôleur et la logique
métier en parallèle.

 Le paradigm Procedural(code behind) vs MVC
Le modèle de programmation MVC est une alternative plus légère au traditionnel

(code behind). Il s'agit d'une architecture léger et hautement testable
CODE BEHIND

 ACTIVITE
Créons une application client/serveur de gestion des utilisateurs base sur L’
ARCHITECURE MVC

 ACTIVITE:modele
import javax.swing.table.TableModel;
public class Utilisateur {

private int id;
private String nom;
private String postnom;
private String password;
private String sexe;
public TableModel getModel() {

return model;
}
public void setModel(TableModel model) {
this.model = model;
}
private TableModel model;
public Utilisateur() {}
public Utilisateur(int id, String nom, String postnom, String password, String sexe) {
this.id = id;
this.nom = nom;
this.postnom = postnom;
this.password = password;
this.sexe = sexe;}
 ACTIVITE:modele
public int getId() {
return id;
}
public String getNom() {
return nom;
}
public String getPostnom() {
return postnom;
}
public String getPassword() {
return password;
}
public String getSexe() {
return sexe;
}
public void setId(int id) {
this.id = id;
}
public void setNom(String nom) {
this.nom = nom; }
public void setPostnom(String postnom) {
this.postnom = postnom;}
public void setPassword(String password) {
this.password = password;}
public void setSexe(String sexe) {
this.sexe = sexe;}
}
 ACTIVITE:modele
return id;
}
return nom;
}
public String getPostnom() {
return postnom;
}
public String getPassword() {
return password;
}
public String getSexe() {
return sexe;
}
this.id = id;
}
this.nom = nom; }
public void setPostnom(String postnom) {
this.postnom = postnom;}
public void setPassword(String password) {
this.password = password;}
public void setSexe(String sexe) {
this.sexe = sexe;}
}
 ACTIVITE:ControlleurUtilisateur
package Controlleur;
import Modele.Utilisateur;
import com.sun.org.apache.bcel.internal.generic.RETURN;
import java.sql.*;
import javax.swing.table.DefaultTableModel;
public class ControlleurUtilisateur {
DefaultTableModel model;
//fonction de connexion
public static Connection getConnection(){
Connection con=null;
try {
Class.forName("com.mysql.jdbc.Driver");
con=DriverManager.getConnection("jdbc:mysql://192.168.10.3:3306/gestion_userisc","root","");
}
return con;

//FONCTION D INSERTION DES UTILISATEUR

public static int saveUtilisateur(Utilisateur user){
int status=0;
try {
Connection con=getConnection();
PreparedStatement ps=con.prepareStatement("INSERT INTO UTILISATEUR
(ID,NOM,POSTNOM,PASSWORDD,SEXE) VALUES(?,?,?,?,?)");
ps.setInt(1,user.getId());
ps.setString(2,user.getNom());
ps.setString(3,user.getPostnom());
ps.setString(4,user.getPassword());
ps.setString(5,user.getSexe());
status= ps.executeUpdate();
}
return status;
}

//FONCTION D modifier DES UTILISATEUR

public static int updateUtilisateur(Utilisateur user){
int status=0;
try {
PreparedStatement ps=con.prepareStatement("UPDATE UTILISATEUR SET
NOM=?,POSTNOM=?,PASSWORDD=?,SEXE=? WHERE ID=?");
ps.setInt(1,user.getId());
ps.setString(2,user.getNom());
ps.setString(3,user.getPostnom());
ps.setString(4,user.getPassword());
ps.setString(5,user.getSexe());
}
return status;
}

//FONCTION DE SUPPRIMER DES UTILISATEUR

public static int deleteUtilisateur(int id){
int status=0;
try {
PreparedStatement ps=con.prepareStatement("DELETE FROM UTILISATEUR WHERE ID=?");
ps.setInt(1,id);
}
return status;
}

public void chagertable(Utilisateur user) {

//pour le paremetre de seuil de commande
model=new DefaultTableModel();
ResultSetMetaData resultData;
ResultSet rs;
try {
PreparedStatement ps=con.prepareStatement("select * from utilisateur");
rs=ps.executeQuery();
resultData=rs.getMetaData();
int j=0;
do
{
model.addColumn(resultData.getColumnLabel(j+1).toUpperCase());
j+=1;
}
while(j<resultData.getColumnCount());
while(rs.next())
{
model.addRow(new
Object[]{rs.getInt(1),rs.getString(2),rs.getString(3),rs.getString(4),rs.getString(5)});
}
user.setModel(model);
} catch (SQLException e) {
}
//faire la recherche dans la base de donnees
public void recherchertable(Utilisateur user,JTextField one) {
model=new DefaultTableModel();
ResultSetMetaData resultData;
ResultSet rs;
try {
PreparedStatement ps=con.prepareStatement("select * from utilisateur where nom or postnom like
?");
ps.setString(1,one.toString());
rs=ps.executeQuery();
resultData=rs.getMetaData();
int j=0;
do
{
model.addColumn(resultData.getColumnLabel(j+1).toUpperCase());
j+=1;
}
while(j<resultData.getColumnCount());
while(rs.next())
{
model.addRow(new
Object[]{rs.getInt(1),rs.getString(2),rs.getString(3),rs.getString(4),rs.getString(5)});
}
user.setModel(model);
} catch (SQLException e) {
}}
 ACTIVITE:Vue

 ACTIVITE:Vue
//la function qui chagera le “Jtable”
Utilisateur user=new Utilisateur();

ControlleurUtilisateur joska=new ControlleurUtilisateur();
void charger(){
joska.chagertable(user);
jTable1.setModel(user.getModel());
}

 ACTIVITE:Vue (button Enregistrer)
try {
if(!jTextField1.getText().equals("") && !jTextField2.getText().equals("") &&
!jTextField3.getText().equals("")
&& !jComboBox1.getSelectedItem().toString().equals("")){
user.setId(Integer.parseInt(jTextField1.getText()));
user.setNom(jTextField2.getText());
user.setPostnom(jTextField3.getText());
user.setPassword(jPasswordField1.getText().toString());
user.setSexe(jComboBox1.getSelectedItem().toString());
if(ControlleurUtilisateur.saveUtilisateur(user) > 0){
JOptionPane.showMessageDialog(null,"insertion reussi");
charger();
jTextField1.setText("");
} }
else{
JOptionPane.showMessageDialog(null,"veillez completer tous les champs");
}
}

 ACTIVITE:Vue (button Modifier)
try {
if(!jTextField1.getText().equals("") && !jTextField2.getText().equals("") &&
!jTextField3.getText().equals("")
&& !jComboBox1.getSelectedItem().toString().equals("")){
user.setId(Integer.parseInt(jTextField1.getText()));
user.setNom(jTextField2.getText());
user.setPostnom(jTextField3.getText());
user.setPassword(jPasswordField1.getText().toString());
user.setSexe(jComboBox1.getSelectedItem().toString());
if(ControlleurUtilisateur.updateUtilisateur(user) > 0){
JOptionPane.showMessageDialog(null,"modification reussi");
charger();
}
}
else{
JOptionPane.showMessageDialog(null,"veillez completer tous les champs");
}
}

 ACTIVITE:Vue (button Supprmer)
if(!jTextField1.getText().equals("")){
if(joska.deleteUtilisateur(Integer.parseInt(jTextField1.getText()))>0)
{
JOptionPane.showMessageDialog(null,"suppression reussi");
charger();
}}else{
JOptionPane.showMessageDialog(null,"Veuillez completer le champ !");
}

 ACTIVITE:Vue (avant de modifier ,en cliquant dans le Jtable,les
donnees doivent s’afficher dans les differents champs,avec
l’evenement “MouseClicked”)
private void jTable1MouseClicked(java.awt.event.MouseEvent evt) {

try {
jTextField1.setText(jTable1.getValueAt(jTable1.getSelectedRow(),0).toString());
jPasswordField1.setText(jTable1.getValueAt(jTable1.getSelectedRow(),3).toStri
ng());
jComboBox1.setSelectedItem(jTable1.getValueAt(jTable1.getSelectedRow(),4).t
oString());
}
 ACTIVITE:Vue (Pour rechecher ,nous allons creer un evenement avec
le JTextFiel “ CaretUpdat”)
private void jTextField3CaretUpdate(javax.swing.event.CaretEvent evt)

{
joska.complete(user, jTextField5.getText());
jTable1.setModel(user.getModel());

 ACTIVITE:

CHAP 3:Client/serveur:
3tiers(JSP)
 Rappel Sur architecture 3Tiers

3tiers (JSP)
 Dans ce cours,nous allons Utiliser le Framework JSP de Java EE

3tiers (JSP)
 Java Server Pages (JSP) est une technologie qui permet aux développeurs de créer des
pages Web dynamiques en utilisant une combinaison de code HTML, XML et Java. Les
pages JSP sont exécutées sur un serveur Web et la sortie résultante est envoyée au
navigateur Web du client. JSP permet d'accéder facilement au code et aux objets Java à
partir d'une page Web, ce qui simplifie la création de pages Web dynamiques. Les pages
JSP sont généralement utilisées conjointement avec des servlets Java, qui gèrent le
traitement des données et les demandes des clients. JSP fait partie de la plate-forme
Java EE et est pris en charge par la plupart des serveurs Web et des conteneurs de
servlets.

3tiers (JSP)
Voici quelques faits sur JSP (JavaServer Pages):
•JSP signifie Java Server Pages.
•JSP est une technologie permettant de créer des applications Web dynamiques.
•JSP fait partie de Java Enterprise Edition (Java EE).
•JSP est similaire aux pages HTML, mais elles contiennent également du code
Java exécuté côté serveur.
•Les scripts côté serveur signifient que le code JSP est traité sur le serveur Web
plutôt que sur la machine cliente.
•Une page JSP est un fichier avec une extension « .jsp » qui peut contenir
une combinaison de balises HTML et de codes JSP.
•Pour créer une page Web, JSP utilise une combinaison de balisage HTML ou XML,
•de balises JSP, d'expressions et de code Java.
•Les balises JSP commencent <%et se terminent par %>.
•Les expressions JSP sont utilisées pour insérer du contenu dynamique
dans la page et commencent par <%=et se terminent par %>.
•JSP peut utiliser JavaBeans pour stocker et récupérer des données.
•JSP nécessite un environnement de développement Java et un conteneur
de servlet Java tel qu'Apache Tomcat ou Jetty.
•JSP est largement utilisé dans l'industrie pour créer des applications Web d'entreprise.
•JSP est une version étendue améliorée de la technologie Servlet.

3tiers (JSP)
AVANTAGE DE JSP:
 Certains avantages de JSP (JavaServer Pages) incluent les éléments suivants :
 JSP offre une approche efficace et plus simple pour coder des pages Web
dynamiques.
 JSP fournit une grande variété de balises prédéfinies et de balises personnalisées, qui
peuvent être utilisées pour ajouter des fonctionnalités aux pages Web
 JSP permet aux développeurs de séparer la présentation de la page Web de la
logique et du traitement, ce qui facilite la maintenance de l'application Web.
 Le conteneur Web (ou le serveur d'applications comme Tomcat) gère les
modifications lorsque des modifications sont apportées au code JSP et ne nécessite
pas de recompilation.
 JSP permet aux développeurs de suivre le modèle de conception Modèle-Vue-
Contrôleur (MVC), qui sépare la présentation, la logique et les données d'une
application Web. Cela facilite la création d'applications Web évolutives et
maintenables.
 JSP est couramment utilisé avec d'autres technologies Java, telles que JavaServer
Faces (JSF), qui fournit un cadre pour la création d'applications Web, ce qui simplifie
le processus de développement.
 Fournit de bonnes fonctionnalités de sécurité telles que le suivi de session,
l'authentification des utilisateurs et la restriction d'accès.
 JSP peut utiliser du code et des bibliothèques Java standard, ce qui augmente le
potentiel de réutilisation du code.

3tiers (JSP)
AVANTAGE DE JSP PAR RAPPORT AUX SERVLETS:
 JSP est considéré comme meilleur que servlet ; JSP est plus avantageux que servlet
pour de nombreuses raisons :
 Les pages JSP permettent aux concepteurs Web de travailler avec le balisage HTML
ou XML, tandis que les servlets nécessitent une compréhension plus approfondie de
Java.
 JSP n'a pas besoin de fichiers supplémentaires tels que des fichiers de classe Java,
web.xml, etc.
 Les JSP sont compilées en servlets par le moteur JSP, ce qui améliore les
performances par rapport à l'interprétation des servlets lors de l'exécution.
 De nombreux IDE et outils sont disponibles pour développer des JSP, ce qui peut
rendre le développement plus rapide et plus facile par rapport aux servlets.
 Les JSP sont plus accessibles pour le débogage et le dépannage que les servlets car
ils disposent de meilleures fonctions de rapport d'erreurs et de débogage.
 JSP est considéré comme plus facile à apprendre que servlet.

3tiers (JSP)
JSP ,ENVIRONNMENT:
L'environnement JSP est un ensemble d'outils et de technologies utilisés pour créer des
pages Web dynamiques à l'aide de la technologie JavaServer Pages (JSP). Il comprend
les composants suivants :
 Moteur JSP : Un composant logiciel qui lit et exécute les fichiers JSP. Il convertit le
code JSP en servlets, qui sont ensuite exécutés sur le serveur et génèrent le HTML
final.
 Serveur Web : Un logiciel qui reçoit les requêtes des clients et envoie les réponses.
Il est responsable du traitement des requêtes et des réponses HTTP.
 Java Runtime Environment (JRE) : Ce logiciel fournit l'environnement nécessaire
à l'exécution des applications Java, y compris les pages JSP.
 Bibliothèques et frameworks supplémentaires : des outils et bibliothèques
supplémentaires, tels que JavaBeans, JavaServer Faces et le framework Spring,
peuvent être utilisés pour développer des applications JSP.
 Outils de développement : Les environnements de développement intégrés (IDE),
tels qu'Eclipse, IntelliJ IDEA et NetBeans, sont utilisés pour écrire, tester et déboguer
le code JSP.

3tiers (JSP)
SERVEUR APACHE TOMCAT:
 Apache Tomcat, également connu simplement sous le nom de Tomcat, est un
serveur Web open source et un logiciel de conteneur de servlet développé par
Apache Software Foundation. Il est utilisé pour exécuter des servlets Java et des
pages JavaServer (JSP) pour servir du contenu Web dynamique. Tomcat est un
composant de la plate-forme Java, Enterprise Edition (Java EE) et est utilisé pour
déployer et exécuter des applications Web Java. Il fournit un environnement de
serveur Web HTTP "pur Java" dans lequel le code Java peut s'exécuter, ainsi que
plusieurs fonctionnalités supplémentaires telles que la prise en charge de plusieurs
protocoles (y compris HTTP, AJP et JMX), des outils de sécurité et de gestion.
Tomcat est largement utilisé dans les environnements de production car il est léger,
facile à configurer et hautement personnalisable.

3tiers (JSP)
INSTALLATION APACHE TOMCAT:
 Accédez au site Web d'Apache Tomcat ( https://tomcat.apache.org/ ) et accédez à la
page "Télécharger".
 Dans la section "Core", recherchez la dernière version du programme d'installation de
Tomcat pour Windows et cliquez sur le lien pour la télécharger.
 Une fois le téléchargement terminé, ouvrez le fichier d'installation et suivez les
instructions pour installer Tomcat sur votre ordinateur.
 Au cours du processus d'installation, vous serez invité à sélectionner un emplacement
pour l'installation de Tomcat. Choisissez un emplacement sur votre disque dur et
cliquez sur "Suivant".
 Le programme d'installation vous demandera alors de choisir les composants que
vous souhaitez installer. Il est recommandé d'installer le "Serveur Web Tomcat" et la
"Documentation Tomcat" pour une installation de base.
 Une fois l'installation terminée, cliquez sur "Terminer".
 Vérifiez que l'installation a réussi en démarrant le serveur Tomcat. Vous pouvez le
faire en accédant au dossier bin de Tomcat et en exécutant le fichier startup.bat .
 Une fois le serveur démarré, ouvrez un navigateur Web et entrez l'URL
"http://localhost:8080" pour accéder à la page d'accueil de Tomcat, qui confirme que
le serveur Tomcat fonctionne correctement.

3tiers (JSP)
INSTALLATION APACHE TOMCAT:
En conclusion, la configuration d'un environnement JSP peut sembler intimidante au
départ, mais en installans Netbeans,vous demarez automatiquement le serveur web et
cela rend le processus beaucoup plus simple. Avoir une configuration appropriée est
crucial pour développer et exécuter des applications JSP. Il est essentiel de s'assurer que
tous les logiciels et configurations nécessaires sont en place avant de commencer tout
développement. La création de pages Web dynamiques avec JSP peut être une
expérience agréable avec les bons outils et les bonnes connaissances

3tiers (JSP)
Overview:
 Une compréhension claire du moteur JSP et de son architecture est essentielle pour
comprendre le fonctionnement interne des pages JSP. Ce didacticiel explore la
structure de JSP et explique comment les serveurs Web gèrent les pages JSP.

3tiers (JSP)
Architecture:
 L'architecture JSP est une architecture à 3 niveaux qui sépare les couches de
présentation , de logique et de données d'une application Web . La couche de
présentation, ou côté client, est chargée d'afficher l'interface utilisateur et de gérer
l'interaction de l'utilisateur. La couche logique, ou côté serveur, est responsable du
traitement des demandes des utilisateurs et de la gestion de la logique métier. La
couche de données est responsable du stockage et de la récupération des données
d'une base de données ou d'un autre système de stockage. Cette séparation des
préoccupations permet une meilleure maintenabilité et évolutivité de l'application.

3tiers (JSP)
Conteneur web?
 Une application Web basée sur JSP nécessite un moteur JSP, également appelé
conteneur Web , pour traiter et exécuter les pages JSP. Le conteneur Web est un
composant de serveur Web qui gère l'exécution de programmes Web tels que les
servlets, les JSP et les ASP.
 Lorsqu'un client envoie une requête pour une page JSP, le conteneur Web l'intercepte
et la dirige vers le moteur JSP. Le moteur JSP convertit ensuite la page JSP en une
classe de servlet, la compile et crée une instance de la classe. La méthode de service
de la classe servlet est alors appelée, ce qui génère le contenu dynamique de la page
JSP.
 Le conteneur Web gère également le cycle de vie des pages JSP et des servlets, en
gérant des tâches telles que leur instanciation, leur initialisation et leur destruction.
En outre, il fournit des services de sécurité, de regroupement de connexions et de
gestion de session à l'application Web basée sur JSP
June 2,. 2023 @joska,chef de travaux 101

3tiers (JSP)
FLUX d’architecture JSP?
 Le flux d'architecture JSP fait référence à la séquence d'étapes suivies par une application
Web basée sur JSP pour traiter et exécuter des pages JSP. Le flux général d'une
architecture JSP peut être décrit comme suit :
 Un client (tel qu'un navigateur Web) envoie une demande de page JSP à un serveur Web.
 Le serveur Web transmet la demande au moteur JSP responsable du traitement des pages
JSP.
 Le moteur JSP vérifie si la page JSP demandée a été compilée dans un servlet. Sinon, il
compile la page JSP dans une classe servlet. Cela se fait en analysant la page JSP et en
convertissant ses éléments (tels que les scriptlets, les expressions et les directives) en code
Java.
 Le moteur JSP compile ensuite la classe servlet, qui crée un fichier de classe Java pouvant
être exécuté par la machine virtuelle Java (JVM).
 Le moteur JSP crée ensuite une instance de la classe servlet et appelle la méthode
service(), qui génère le contenu dynamique de la page JSP. Dans la méthode service(), le
moteur JSP génère le code HTML de la réponse en combinant le modèle statique de la
page JSP avec le contenu dynamique généré par le code Java.
 Le moteur JSP renvoie le code HTML généré au serveur Web, qui le renvoie ensuite au
client en réponse.
 Le moteur JSP maintient également un cache des classes de servlet compilées afin que les
demandes ultérieures.
3tiers (JSP)
Cycle de vie JSP?
 Un cycle de vie d'une page JSP est défini comme un processus allant de sa phase de
traduction à la phase de destruction. Cette leçon décrit les différentes étapes du cycle
de vie d'une page JSP.
Le cycle de vie d'une page JSP peut être divisé en la phase suivante :
 Phase de traduction
 Compilation
 Phase d'initialisation
 Phase d'exécution
 Phase de destruction (nettoyage)

3tiers (JSP)
Base JSP
 Java fournit divers éléments de script qui vous permettent d'insérer du code Java à
partir de votre code JSP dans le servlet. Les éléments de script ont différents
composants autorisés par JSP. Comprendre chacun de ces composants est essentiel
pour écrire du code dans JSP. Discutons en détail de chacun des composants

3tiers (JSP)
Base JSP
 Les éléments de script dans JSP doivent être écrits dans les balises <% %> . Le
moteur JSP traitera tout code que vous écrivez dans la paire de balises <% et %> ,
et tout autre texte de la page JSP sera traité comme du code HTML ou du texte brut
lors de la traduction de la page JSP
<%@ page import="java.util.Date"%>

<!DOCTYPE html>
<html> <head> <title>Comments in JSP Page</title> </head>
<body> <%-- A JSP comment --%>

<!—The current date is <%= new Date() %> -->
</body>
</html>

3tiers (JSP)
Directive JSP
Ces balises sont utilisées pour fournir des instructions spécifiques au conteneur Web
lorsque la page est traduite. Il comporte trois sous-catégories :
 Page : <%@page... %>
 Inclure : <%@ inclure ... %>
 Taglib : <%@ taglib ... %>
 Nous les détaillerons dans le prochain chapitre.

3tiers (JSP)
Declaration JSP
Comme son nom l'indique, il est utilisé pour déclarer des méthodes et des variables que
vous utiliserez dans votre code Java au sein d'un fichier JSP. Selon les règles de JSP,
toute variable doit être déclarée avant de pouvoir être utilisée
<!DOCTYPE html>
<html>
<body>
<%! int variable_value=62; %>
<%= " Your integer data is :"+ variable_value %>
</body>
</html>

3tiers (JSP)
Balise script JSP
Comme son nom l'indique, il est utilisé pour déclarer des méthodes et des variables que
vous utiliserez dans votre code Java au sein d'un fichier JSP. Selon les règles de JSP,
toute variable doit être déclarée avant de pouvoir être utilisée
<% JAVA CODE %>
Synthaxe:
<!DOCTYPE html>
<html>
<head> <title>Scriptlet Tag</title> </head>
<% int count = 2; %>
<body>
Calculated page count <% out.println(cnt); %>
</body>
</html>
3tiers (JSP)
Balise script JSP
Un autre extrait de code qui montre comment écrire et mélanger des balises de scriptlet
avec du HTML
Synthaxe:
<table border="1">
<% for ( int g = 1; g <= cnt; g++ ) { %>
<tr>
<td>Number</td>
<td><% = g+1 %></td>
</tr> <% } %>
</table>

3tiers (JSP)
Expression JSP
Les éléments d'expressions sont chargés de contenir l'expression de langage de script,
qui est évaluée et convertie en chaînes par le moteur JSP et est destinée au flux de sortie
de la réponse. Par conséquent, vous n'êtes pas obligé d'écrire out.print() pour écrire
vos données. Ceci est principalement utilisé pour imprimer les valeurs des variables ou
des méthodes sous forme de sortieSynthaxe:
<!DOCTYPE html>
<html>
<body> <%= "A JSP based string" %>
</body>
</html>

3tiers (JSP)
Expression JSP
Les éléments d'expressions sont chargés de contenir l'expression de langage de script,
qui est évaluée et convertie en chaînes par le moteur JSP et est destinée au flux de sortie
de la réponse. Par conséquent, vous n'êtes pas obligé d'écrire out.print() pour écrire
vos données. Ceci est principalement utilisé pour imprimer les valeurs des variables ou
des méthodes sous forme de sortieSynthaxe:
<!DOCTYPE html>
<html>
<body> <%= "A JSP based string" %>
</body>
</html>

3tiers (JSP)
Directive JSP

3tiers (JSP)
Directive JSP
 Les directives fournissent des instructions et des messages à un conteneur JSP. Les
directives fournissent des informations globales sur la page entière de JSP. Par
conséquent, ils constituent une partie essentielle du code JSP. Ces instructions
spéciales sont utilisées pour traduire JSP en code de servlet. Dans ce chapitre, vous
découvrirez en détail les différents composants des directives.
 Dans la phase du cycle de vie des JSP, le code doit être converti en un servlet qui
s'occupe de la phase de traduction. Ils fournissent des commandes ou des
instructions au conteneur sur la façon de traiter et de gérer certaines parties de
traitement JSP. Les directives peuvent contenir plusieurs attributs séparés par une
virgule et agir comme des paires clé-valeur. Dans JSP, les directives sont décrites
avec une paire de balises <%@ .... %>.
 La syntaxe des directives ressemble à : <%@ directive attribute="" %>
Il existe 3 types de directives :

 Directive de page
 Inclure la directive
 Directive Taglib

3tiers (JSP)
Directive JSP
 La directive de page est utilisée pour définir des attributs qui peuvent être appliqués
à une page JSP complète. Vous pouvez placer votre code pour les directives de page
n'importe où dans votre page JSP. Cependant, en général, les directives de page sont
implicites en haut de votre page JSP.
 La syntaxe de base de la directive page est : <%@ page attribute = "attribute_value" %>
 Les attributs utilisés par les directives Page sont :
•buffer : l'attribut Buffer définit la taille du tampon en Ko pour contrôler la sortie de
la page JSP.
•contentType : L'attribut ContentType définit le MIME (Multipurpose Internet Mail Extension)
du document dans l'en-tête de réponse HTTP.
•autoFlush : L'attribut autofill contrôle le comportement du tampon de sortie du servlet.
Il surveille la sortie du tampon et spécifie si la sortie du tampon rempli doit être vidée
automatiquement ou si une exception doit être déclenchée pour indiquer un débordement
de tampon.
•errorPage : La définition de l'attribut "ErrorPage" est la bonne façon de gérer les erreurs
JSP.
June Si une
2, 2023 exception se produit sur la page en cours,
@joska,chef elle sera redirigée vers la page d'erreur. 114
de travaux
3tiers (JSP)
Directive JSP
 extend : attribut d'extension utilisé pour spécifier une superclasse qui indique si la
servlet générée doit s'étendre ou non.
 import : L'attribut import est utilisé pour spécifier une liste de packages ou de
classes utilisés dans le code JSP, tout comme l'instruction import de Java le fait dans
un code Java.
 isErrorPage : Cet attribut "isErrorPage" de la directive Page est utilisé pour

spécifier que la page courante peut être affichée comme une page d'erreur.
 info : cet attribut "info" définit les informations de la page JSP, qui sont ensuite
obtenues à l'aide de la méthode getServletInfo() de l'interface servlet.
 isThreadSafe : la servlet et la JSP sont multithread. Si vous souhaitez contrôler le

comportement de la page JSP et définir le modèle de threading, vous pouvez utiliser
l'attribut "isThreadSafe" de la directive page.

3tiers (JSP)
Directive JSP
 Language : L'attribut language spécifie le langage de programmation utilisé dans la page
JSP. La valeur par défaut de l'attribut de langue est "Java".
 Session : dans JSP, l'attribut de session de la directive de page spécifie si la page JSP actuelle
participe à la session HTTP actuelle.
 isELIgnored : Cet attribut isELIgnored est utilisé pour spécifier si le langage d'expression
(EL) impliqué par la page JSP sera ignoré.
 isScriptingEnabled : cet attribut "isScriptingEnabled" détermine si les éléments de script

sont autorisés ou non à être utilisés

3tiers (JSP)
Directive JSP
 JSP extends:Pour heritage d’une classe fille de la classe mere
<%@ page language = “java” contentType = “text/html” pageEncoding = “ISO-8859-1” %>

<%@ extends = “pack.firstclass”%>

3tiers (JSP)
Directive JSP
 JSP import:Pour l’ importation d’une bibliotheque ou d’un package ou d’une classe
<%@ page import="java.io.*" %>

<%@ page import="java.sql.*" %>
<%@ page import="java.util.*" %>
<%@ page import=“value” %>

<%@ page import="java.io.*,java.sql.*,java.util.*" %>

3tiers (JSP)
Directive JSP
 JSP session:Pourla gestion des sessions utilisateurs(true,false)
<%@ page session= “true/false” %>
<%@ page language=“java” contentType = “text/html;

charset=ISO-8859-1” pageEncoding = “ISO-8859-1” session=
“false”%>

3tiers (JSP)
Inclure la directive
 La "directive include" JSP est utilisée pour inclure un fichier dans un autre fichier JSP.
Cela inclut les fichiers HTML, JSP, texte et autres. Cette directive est également
utilisée pour créer des modèles selon les exigences du développeur et sépare les
pages dans l'en-tête, le pied de page et la barre latérale.
 Pour utiliser cette directive Include, vous devez l'écrire comme suit : <%@ include file = "relative url" >
<%@ page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding =

"ISO-8859-1"%>
<%@ include file="directive_header_code.jsp" %>
<!DOCTYPE html>
<html>
<head> <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
<title>Include Directive Example</title> </head>
<body>
<p>This file includes a header file named directive_header_code.jsp</p>
</body>
</html>

3tiers (JSP)
TagLib
 La directive JSP taglib est implémentée pour définir une bibliothèque de balises avec
"taglib" comme préfixe. Les sections de balises personnalisées de JSP utilisent taglib.
La directive taglib de JSP est utilisée comme bibliothèque de balises standard.
 Pour implémenter taglib, vous devez l'écrire comme ceci :
<%@ taglib uri="uri" prefix="value"%>

3tiers (JSP)
LES ACTIONS EN JSP
 Il est nécessaire de contrôler le comportement du moteur de servlet, qui peut être
contrôlé dynamiquement en insérant le fichier en réutilisant les composants
JavaBeans ou en redirigeant ou renvoyant l'utilisateur vers une autre page, c'est-à-
dire en renvoyant la requête vers une autre ressource, qui sera éventuellement un
JSP, HTML ou autres ressources. Dans ce chapitre, vous découvrirez le concept
d'action et les balises d'action qui permettent cette transmission pour le
traitement.

3tiers (JSP)
BALISE D’ACTION
 La spécification JSP fournit une balise standard appelée balise d'action utilisée dans le
code JSP et est utilisée pour supprimer ou éliminer le code Scriptlet de votre code
JSP car les Scriptlets JSP sont obsolètes et ne sont pas pris en compte de nos jours.
Il existe de nombreuses balises ou éléments d'action JSP, et chacun d'eux a ses
propres utilisations et caractéristiques. Chaque balise d'action JSP est implémentée
pour effectuer des tâches précises. La balise d'action est également implémentée
pour rationaliser le flux entre les pages et pour utiliser un bean Java. Comme il
coïncide avec le standard XML, la syntaxe de l'élément action est :

3tiers (JSP)
BALISE D’ACTION
 jsp:forward : est utilisé pour transmettre la requête et la réponse à d'autres ressources.
 jsp:include : est utilisé pour inclure une autre ressource.
 jsp:body : est utilisé pour définir le corps de l'élément XML défini dynamiquement.
 jsp:useBean : est utilisé pour créer ou localiser des objets bean.
 jsp:setProperty : est utilisé pour définir la valeur de la propriété dans l'objet bean.
 jsp:getProperty : est utilisé pour afficher la valeur de la propriété du bean.
 jsp:element : est utilisé pour définir dynamiquement des éléments XML.
 jsp:plugin : est utilisé pour intégrer d'autres composants (applets).
 jsp:param : est utilisé pour définir le paramètre pour la valeur (forward ou include).
 jsp:text : est utilisé pour écrire du texte de modèle dans les pages et les documents JSP.
 jsp:fallback : est utilisé pour afficher le message si les plugins fonctionnent.
 jsp:attribute : est utilisé pour définir les attributs d'un élément XML défini dynamiquement.

3tiers (JSP)
LES ATTRIBUTS DE BASE DE BALISE D’ACTION
Deux attributs de base sont couramment utilisés pour toutes les balises d'action. Ceux-ci sont:
 id : l'attribut id définit des éléments d'action uniques et permet de référencer des actions dans
la page JSP. Lorsque l'action crée l'instance d'un objet, l'attribut id est utilisé pour s'y référer.
 Scope : L'attribut scope est utilisé pour identifier le cycle de vie d'une action. Il est en
corrélation avec l'attribut id car l'attribut scope est utilisé pour établir la durée de vie de cet
objet particulier associé à l'ID.
Ici, la syntaxe et la mise en œuvre de certaines actions sont décrites ci-dessous :

3tiers (JSP)
LES ATTRIBUTS DE BASE DE BALISE D’ACTION
Deux attributs de base sont couramment utilisés pour toutes les balises d'action. Ceux-ci sont:
 id : l'attribut id définit des éléments d'action uniques et permet de référencer des actions dans
la page JSP. Lorsque l'action crée l'instance d'un objet, l'attribut id est utilisé pour s'y référer.
 Scope : L'attribut scope est utilisé pour identifier le cycle de vie d'une action. Il est en
corrélation avec l'attribut id car l'attribut scope est utilisé pour établir la durée de vie de cet
objet particulier associé à l'ID.
Ici, la syntaxe et la mise en œuvre de certaines actions sont décrites ci-dessous :

3tiers (JSP)
JSP:inclure l’action
Cette "action d'inclusion" vous permet d'inclure une autre ressource dans la page en cours de
génération
Synthaxe: <jsp:include page="page URL" flush="true/false">
Example:
main.jsp
<html>
<head> <title>JSP Actions</title> </head>
<body>
<h3>--DataFlair--</h3>
<jsp:include page="date.jsp" flush="true" />
</body> </html>
date.jsp
<html>
<head> <title>JSP Actions</title> </head>
<body> <p> Today's date: <%= (new java.util.Date()).toLocaleString()%>
</p> </body>
</html>
3tiers (JSP)
JSP:inclure de transfert
Cette "action de transfert" termine la page en cours et vous permet de transférer la demande à
d'autres ressources.
Synthaxe: <jsp:forward page = "URL of another static, JSP, OR Servlet page" />
Forward.jsp
<html>
<head> <title>JSP Forward</title> </head>
<body> <a>I was the requested page but forwarded the request to other</a>
<jsp:forward page="other.jsp" />
</body>
</html>
Other.jsp
<html>
<title>JSP Forward 2</title>
<h3>DataFlair</h3> </head>
<body> <a>I am the other page where request is forwarded
.</a> </body>
</html>
Il est à noter que ce fichier JSP et le fichier forward_eg.jsp
doivent résider dans le même répertoire pour
June 2, 2023
le faire fonctionner.
@joska,chef de travaux 128
3tiers (JSP)
JSP:param Action
Cette "action param" est utilisée pour définir le paramètre pour la valeur (forward ou include).
Synthaxe: <jsp: param name = "param_name" value = "value_of_parameter" />
<!DOCTYPE html>
<html>
<head> <title>Example of param Action</title> </head>
<body>
<h2>JSP page: Param with forward</h2>
<jsp:forward page="forward_eg.jsp">
<jsp:param name="date" value="06-09-2019" />
<jsp:param name="time" value="10:30PM" />
<jsp:param name="data" value="GKR" />
</jsp:forward> </body>
</html>

3tiers (JSP)
JSP: Action UseBean
Cette "action useBean": est utilisée pour créer ou localiser des objets beanSynthaxe:
<jsp: useBean id="unique_name_to_identify_bean" class="package_name.class_name" />
package samplePackageName; <!DOCTYPE html>

public class Teacher <html>
{ <head> <title>JSP Page for showing use of useBean
public Teacher() {} action</title> </head>
private String t_name; private int deptno; <body>
public void setName(String t_name) <h2>UseBean Action</h2>
{ this.t_name = t_name; } <jsp:useBean id="teacher"
public String getName() class="packageName.Teacher" />
{ return t_name; } <jsp:setProperty name="teacher" property="*" />
public void setDept(int deptno) <h2> name:<jsp:getProperty name="teacher"
{ this.deptno = deptno; } property="t_name" />
public int getDept() <br /> empno:<jsp:getProperty name="teacher"
{ return deptno; } property="dept" />
} <br /> </h2>
</body> </html>
3tiers (JSP)
 ACTIVITE: Créons une application avec JSP
permettant d’enregistrer des informations dans
la base de données Mysql utilisant
l’architecture mvc

3tiers (JSP)
 ACTIVITE: bd
CREATE TABLE utilisateur (
id int(11) NOT NULL,
nom` varchar(20) NOT NULL,
passwor varchar(20) NOT NULL,
genre varchar(20) NOT NULL,
pays varchar(20) NOT NULL)

3tiers (JSP)
 ACTIVITE: creation projet dans Netbeans

3tiers (JSP)
 ACTIVITE: architecture projet

3tiers (JSP)
 ACTIVITE: modele Utilisateur
public class Utilisateur {
private int id;
private String nom,passwor,genre,pays;
public Utilisateur() {
}
public Utilisateur(int id, String nom, String passwor, String genre, String pays) {
this.id = id;
this.nom = nom;
this.passwor = passwor;
this.genre = genre;
this.pays = pays;
}
return id;
}

return nom;
}
public String getPasswor() {

return passwor;
}
3tiers (JSP)
 ACTIVITE: modele Utilisateur(suite)
public String getGenre() {
return genre;
}
public String getPays() {
return pays;
}
this.id = id;
}

this.nom = nom;
}
public void setPasswor(String passwor) {
this.passwor = passwor;
}
public void setGenre(String genre) {
this.genre = genre;
}
public void setPays(String pays) {
this.pays = pays; }
}
3tiers (JSP)
 ACTIVITE: Controlleur Utilisateur(connexion)
import java.sql.*;
import java.util.ArrayList;
import static java.util.Collections.list;
import java.util.List;
import model.Utilisateur;
public class Controlleur_utilisateur {
// la fonction de connectyion a la base de donnee
public static Connection getConnection(){
Connection con=null;
try {
Class.forName("com.mysql.jdbc.Driver");
con=DriverManager.getConnection("jdbc:mysql://localhost:3306/gestion_user","root","");
System.out.print(e);
}
return con;
}

3tiers (JSP)
 ACTIVITE: Controlleur Utilisateur(fonction d’insertion)
public static int save(Utilisateur u){
int status=0;
try {
PreparedStatement ps=con.prepareStatement("INSERT INTO utilisateur (nom,passwor,genre,pays)
VALUES (?,?,?,?)");
ps.setString(1,u.getNom());
ps.setString(2,u.getPasswor());
ps.setString(3,u.getGenre());
ps.setString(4,u.getPays());
status=ps.executeUpdate();
}catch(Exception e){
System.out.println(e);}
return status;
}

3tiers (JSP)
 ACTIVITE: Controlleur Utilisateur(fonction de modification)
public static int update(Utilisateur u){

int status=0;
try {
PreparedStatement ps=con.prepareStatement("update utilisateur set
nom=?,passwor=?,genre=?,pays=? where id=?");
ps.setString(1,u.getNom());
ps.setString(2,u.getPasswor());
ps.setString(3,u.getGenre());
ps.setString(4,u.getPays());
ps.setInt(5,u.getId());
return status;
}

3tiers (JSP)
 ACTIVITE: Controlleur Utilisateur(fonction de supression)
public static int delete(int id){

int status=0;
try {
PreparedStatement ps=con.prepareStatement("delete utilisateur where id=?");
ps.setInt(1,id);
return status;
}

3tiers (JSP)
 ACTIVITE: Controlleur Utilisateur(fonction de selection des utilisateurs)
///selectionnons tous les utilisateurs

public static List <Utilisateur> tufurayi(){
List<Utilisateur> list=new ArrayList<Utilisateur>();
try{
PreparedStatement ps=con.prepareStatement("SELECT * FROM UTILISATEUR");
ResultSet rs=ps.executeQuery();
while(rs.next()){
Utilisateur u=new Utilisateur();
u.setId(rs.getInt("id"));
u.setNom(rs.getString("nom"));
u.setPasswor(rs.getString("passwor"));
u.setGenre(rs.getString("genre"));
u.setPays(rs.getString("pays"));
list.add(u);
} }
catch(Exception e){
System.out.print(e);
}
return list;
}
}
3tiers (JSP)
 ACTIVITE: Vue Utilisateur(la page Utilisateur.JSP)
<html>
<head>
<title>TODO supply a title</title>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
</head>
<body> <form action="ajouterUtilisateur.jsp" method="post" >
<table>
<tr><td>NOM</td> <td><input type="text" name="nom"/></td> </tr>
<tr><td>PASSWORD</td> <td><input type="password" name="passwor"/></td> </tr>
<tr><td>GENRE</td> <td><input type="radio" value="genre" name="genre"/>MASCULIN
<input type="radio" value="genre" name="genre"/>FEMININ
</td> </tr>
<tr><td>PAYS</td> <td>
<select name="pays"> <option>INDE</option> <option>PAKISTAN</option>
<option>TURQUIE</option> <option>RDC</option> </select>
</td> </tr> <tr><td colspan="2"><input type="submit" value="Add User"/></td></tr>
</table>
</form
</body>
</html>

3tiers (JSP)
 ACTIVITE: Vue Utilisateur(la page AjouterUtilisateur.JSP)
<%--
Document : ajouterUtilisateur
Created on : 22 févr. 2023, 11:19:09
Author : josue
--%>
<%@page import="controlleur.Controlleur_utilisateur"%>
<jsp:useBean id="u" class="model.Utilisateur"></jsp:useBean>
<jsp:setProperty property="*" name="u"/>
<%
int i=Controlleur_utilisateur.save(u);
if(i>0){
response.sendRedirect("ajouterUtilisateur_reussi.jsp");
}
else{
response.sendRedirect("ajouterUtilisateur_echouer.jsp");
}
%>

3tiers (JSP)
 ACTIVITE: Vue Utilisateur(la page UpdateUtilisateur.JSP)
<%--
Created on : 22 févr. 2023, 11:19:09
Author : josue
--%>
<%
int j=Controlleur_utilisateur.update(u);
if(i>0){
response.sendRedirect(“modifierUtilisateur_reussi.jsp");
}
else{
response.sendRedirect("modifierUtilisateur_echouer.jsp");
}
%>

3tiers (JSP)
 ACTIVITE: Vue Utilisateur(la page DeleteUtilisateur.JSP)
<%--
Created on : 22 févr. 2023, 11:19:09
Author : josue
--%>
<%
int j=Controlleur_utilisateur.delete(u.getId);
if(i>0){
response.sendRedirect(“modifierUtilisateur_reussi.jsp");
}
else{
response.sendRedirect("modifierUtilisateur_echouer.jsp");
}
%>

3tiers (JSP)
 ACTIVITE: Vue Utilisateur(la page VisualiserUtilisateur.JSP)
<html>
<head>
<title>View Users</title>
</head>
<body>
<%@page import="controlleur.Controlleur_utilisateur,model.Utilisateur,java.util.*"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
<h1>Users List</h1>
<%
List<Utilisateur> list=Controlleur_utilisateur.tufurayi();
request.setAttribute("list",list);
%>
<table border="1" width="90%">
<tr><th>Id</th><th>Nom</th><th>Password</th><th>Genre</th>
<th>Pays</th><th>Edit</th><th>Delete</th></tr>
<c:forEach items="${list}" var="u">
<tr><td>${u.getId()}</td><td>${u.getNom()}</td><td>${u.getPasswor()}</td>
<td>${u.getGenre()}</td><td>${u.getPays()}</td>
<td><a href="editform.jsp?id=${u.getId()}">Edit</a></td>
<td><a href="deleteuser.jsp?id=${u.getId()}">Delete</a></td></tr>
</c:forEach>
</table>
<br/><a href="adduserform.jsp">Add New User</a>
</body>
</html>

3tiers (JSP)
 ACTIVITE: Vue Utilisateur(la page ajouterUtilisateur_echouer.JSP)
<%@page contentType="text/html" pageEncoding="UTF-8"%>

<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>JSP Page</title>
</head>
<body>
<p>enregistrement echouer</p>
<jsp:include page="Utilisateur.html" ></jsp:include>

</body>
</html>

3tiers (JSP)
 ACTIVITE: Vue Utilisateur(la page ajouterUtilisateur_reussi.JSP)
<%--
Document : ajouterUtilisateur_reussi
Created on : 22 févr. 2023, 11:29:02
Author : josue
--%>
<%@page contentType="text/html" pageEncoding="UTF-8"%>

<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>JSP Page</title>
</head>
<body>
<p>enregistrement reusi</p>
<jsp:include page="Utilisateur.html" ></jsp:include>

</body>
</html>

3tiers (JSP)
 ACTIVITE:Capture lors du deployement

3tiers (JSP)
 ACTIVITE:Capture

3tiers (JSP)

3tiers (JSP)

conclusion
Nous voilà au terme de notre cours de programmation client/serveur, lequel nous a

permis de retracer un certain nombre des concepts utiles à rendre le futur étudiant en
Informatique un bon développeur en assimilant les bases et les rudiments de la logique
de programmation réseau utilisant les sockets ,une base de données partagée et une
application client/serveur (3 tiers ) utilisant un serveur d’application.
C’est ainsi que nous avons eu à parcourir 3 chapitres, lesquels, estimons être à même de
rendre le lecteur de ce cours habile quant à la programmation orientée objet utilisant
l’aspect réseau, et lui permettre de l’implémenter facilement dans un quelconque type
d’application (console,desktop,web) même si les webservices n’ ont pas été aborder
dans cet ouvrage.
C’est cette raison qui nous pousse à encourager les futurs développeurs de demain, de
passer du temps à s’exercer, et résoudre les différents exercices proposés dans ce cours
(Et pourquoi pas se documenter ailleurs) pour enrichir leurs connaissances.

l’auteur
KALEMA JOSUE DJAMBA,
 Je suis développeur depuis 2015, avec une excellente expérience
sur des projets web et mobile en environnement Java/JEE,.Net,
PhP ,Cartographie.
 Assistant depuis 2017 puis chef de travaux aux Universités
depuis 2022.
Diplômé d'un master 2 de l’Université libre de Kigali et d'un diplôme

d’ingénieur en Informatique de BAC+5 a l’institut supérieur
d’informatique et de Gestion.

l’auteur
Compétences techniques et fonctionnelles:
-LANGAGES:
Java, J2EE, Android, C, C++, Java script, HTML, CSS3, PL/SQL, Script Shell sousUnix, Secure Shell ,
WebService REST/SOAP, VBA, Assembleur8088 , PHP,
-LOGICIELS ET OUTILS:
NetBeans,Visual Studio ,Intellij idea, Eclipse, Docker, ArcGis, Android Studio, Code Blocks, WampServer, Mongo
Management Studio, DevCPP, Wireshark, Packet Tracer, Excel,,PostgreSQL
-SYSTEMES D’EXPLOITATION:
Windows 7/8.1/10, Mac OS X, GNU/Linux: Ubuntu, Android, IOS,Windows Serveur
-METHODOLOGIE:
Conception objet, UML 2.0, Design pattern, Modèle MVC, architecture client server ,Merise, Cycle en V, Agile,.
-BASES DE DONNEES:
PostgreSQL,Oracle Database 10g, MySQL, MongoDB,
-Framework:
Spring MVC, Spring Data JPA, Spring BOOT, JSP, Bootstrap,Jasperreport,Flask,Laravel,Ajax

Source
 http://www.info.uqam.ca/~obaid/INF4481/A01/Plan.htm
 http://bat710.univ-lyon1.fr/~exco/COURS/clientserveur.html
 man 2 socket
 http://www.developerweb.net/sock-faq/ FAQ socket
 RFC 791 (IP), RFC 793 (TCP), RFC 768 (UDP)
 Richard Stevens, UNIX Network Programming
 Programmation client-serveur Python, TCP/IP, services,Manuel Munier 11/2022
 "The Java Tutorial : Object Oriented Programming for the Internet"
 M. Campione, K. Walrath 1977
 http ://java.sun.com/nav/read/Tutorial
 https://www-w3schools-
in.translate.goog/jsp/directives?_x_tr_sl=en&_x_tr_tl=fr&_x_tr_hl=fr&_x_tr_pto=
sc
 https://data-flair.training/blogs/jsp-action-tags/
 https://data-flair.training/blogs/jsp-page-directives/
June 2, 2023
View publication stats @joska,chef de travaux 156

Moduledeprogrammationclient Serveurjoska

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Moduledeprogrammationclient Serveurjoska

Transféré par

Droits d'auteur :

Formats disponibles

See discussions, stats, and author profiles for this publication at: https://www.researchgate.

Cours de programmation client/serveur Cours dispense par: Ir

Book · June 2023

The user has requested enhancement of the downloaded file.

Cours dispense par: Ir KALEMA JOSUE

June 2, 2023 @joska,chef de travaux 1

L’objectif de ce document est de synthétiser les

pour pouvoir faire la programmation client-serveur

aux différentes couches du modèle OSI : UDP,

L’étudiant sera capable, à la fin de ce cours, de:

 Comprendre l’architecture client/serveur;

 Comprendre les mécanismes réseau

 Coder une application reseau utilisant les Sockets

 Faire le CRUD(Create,Read,Update,Delete) dans une application

 De faire un pas sur la programmation client/serveur(3 tiers) utilisant le

June 2, 2023 @joska,chef de travaux 3

 GENERALITE SUR L’ARCHITECTURE

June 2, 2023 @joska,chef de travaux 4

 60H(20h theorique , 20h TD,20 TP)

 retro-projecteur, google class room

June 2, 2023 @joska,chef de travaux 5

 Programmation orientée objet en

June 2, 2023 @joska,chef de travaux 6

Utilisation du modèle CLIENT/SERVEUR

 World Wide Web (web)

 Gestion de bases de données (programmation procédural)

 Systèmes de partage de données (système distribue ,repartie ,partagé,

June 2, 2023 @joska,chef de travaux 7

 Dans le cadre des TPs de réseau, les communications se feront normalement

June 2, 2023 @joska,chef de travaux 8

June 2, 2023 @joska,chef de travaux 9

June 2, 2023 @joska,chef de travaux 10

June 2, 2023 @joska,chef de travaux 11

 Présentation de l'architecture d'un système client/serveur

 Inconvénients du modèle client/serveur

June 2, 2023 @joska,chef de travaux 14

June 2, 2023 @joska,chef de travaux 15

June 2, 2023 @joska,chef de travaux 16

June 2, 2023 @joska,chef de travaux 17

June 2, 2023 @joska,chef de travaux 19

June 2, 2023 @joska,chef de travaux 20

June 2, 2023 @joska,chef de travaux 21

June 2, 2023 @joska,chef de travaux 22

June 2, 2023 @joska,chef de travaux 23

June 2, 2023 @joska,chef de travaux 24

La notion de service permet à une même machine d'assurer plusieurs communications

 Java prend en charge deux protocoles : TCP et UDP.

June 2, 2023 @joska,chef de travaux 26

d'associer un nom à une adresse I.P.

June 2, 2023 @joska,chef de travaux 27

June 2, 2023 @joska,chef de travaux 28

public class TestNet1 {

June 2, 2023 @joska,chef de travaux 29

June 2, 2023 @joska,chef de travaux 30

June 2, 2023 @joska,chef de travaux 32

communications sont probablement bufférisées avant d'être envoyées, doù l'apparence du

full-duplex là où TCP/IP ne sait faire que du half-duplex), le protocole d'échange

d'informations est laissé à la charge du programmeur.

June 2, 2023 @joska,chef de travaux 33

programmeur doit spécifier le nom de machine où se trouve le serveur et le port où l'ondoit se

 ma-socket = new Socket ("machine.dz", 1999);

June 2, 2023 @joska,chef de travaux 34

Il accepte commandes, questions, demandes et envoie une réponse automatiquement. 11