REPUBLIQUE DEMOCRATIQUE DU CONGO

ENSEIGNEMENT SUPERIEUR ET UNIVERSITAIRE

UNIVERSITE METHODISTE AU KATANGA
FACULTE DES SCIENCES INFORMATIQUE
MULUNGWISHI/HAUT-KATANGA

Intitulé du cours : Question Spéciale de Programmation

Promotion : Grade I Système d’Information (2016-2017)

Volume Horaire : 60 Heures

Dispensé Par : MBAY KANYIMBU Landry

Assistant d’Enseignement à l’Université
Méthodiste au Katanga.

Concepteur des Systèmes d’Information des

Entreprises.

landrymbaykanyimbu@gmail.com

Seule votre volonté vous conduira à l’Excellence. LMKanyimbu

 OBJECTIF DU COURS

a. Objectif Général

Ce cours de question spéciale de programmation est destiné aux

étudiants et étudiantes de premier grade ISI; il a pour objectif d’enrichir le
niveau de connaissance des étudiants dans le domaine de développement
avec le langage de programmation Java. Il met à leur disposition les notions
classiques et supérieures sur les technologies Java, en exploitant certains
API pour chacune des technologies.

b. Objectif Spécifique

Ce présent cours préconise qu’à la fin de ces enseignements chaque

étudiant ayant suivi avec attention sera capable:
- De renforcer la capacité dans le développement des applications
orientée objet, comme préconisée par l’approche objet ;
- De développer une application sous Java en mettant en exergue les
connaissances sur la technologie MVC ;
- De créer une application web, par l’entreprise de l’API de la technologie
AppLet ;
- De programmer des applications distribuées et parallèles en usant des
API spécifiques en l’occurrence Net et Thread.

OUTILS

- Netbeans 6 ou 7
- JDK 6 ou 7
- MySql
- Pilote MySqlConnector

Seule votre volonté vous conduira à l’Excellence. LMKanyimbu

 PLAN DU COURS
1. CHAPITRE I. RAPPELS SUR LA PROGRAMMATION ORIENTEE OBJET
a. Classe
i. Objet
ii. Méthode
iii. Propriété
iv. Niveau d’accessibilité
b. Principe d’encapsulation
c. Constructeur
d. Principe d’Héritage
e. Le Polymorphisme
f. La Collection
i. Récupérer dans une collection
ii. Supprimer dans une collection
iii. Modifier dans une collection
iv. Ajouter dans une collection
v. Collection d’objets
2. CHAPITRE II. JAVA ET LA TECHNOLOGIE MVC
a. Présentation du concept
b. La technologie MVC
i. Modèle
ii. Vue
iii. Contrôleur
c. Etude de cas
i. Description de la couche Persistance (Modèle)
ii. Description de la couche Contrôle (Couche Métier)
iii. Description de la couche Vue (Présentation)

3. CHAPITRE III. LES APPLET

a. Introduction
b. Rappel sur HTML
c. Les Applets

Seule votre volonté vous conduira à l’Excellence. LMKanyimbu

 i. Introduction
ii. La Classe Applet
iii. L’Applet dans la page HTML
iv. L’applet et IHM

4. CHAPITRE IV. LA PROGRAMMATION DISTRIBUEE

a. Introduction
b. Les adresses réseaux
c. La programmation des sockets
i. Le socket
ii. Le protocole TCP/IP
1. Le Serveur
2. Client
3. Gestion des flux d’entrées/sorties
iii. Le Protocole UDP
1. Le DatagramSocket
2. Le DatagramPacket
d. La programmation parallèle
i. Le thread
1. Introduction
2. La Classe Thread
3. Le serveur Multi-client en TCP/IP
BIBLIOGRAPHIE

Seule votre volonté vous conduira à l’Excellence. LMKanyimbu

 CHAPITRE I RAPPEL SUR LA PROGRAMMATION ORIENTEE OBJET
La programmation orientée objet est celle qui utilise la notion de la
conception orientée objet qui consiste à considérer tout comme étant objet.

I. LA CLASSE
Une classe est le support de l'encapsulation : c'est un ensemble de
données et de fonctions regroupées dans une même entité. Une classe est
une description abstraite d'un objet. Les fonctions qui opèrent sur les
données sont appelées des méthodes. Instancier une classe consiste à créer
un objet sur son modèle.
Entre classe et objet il y a, en quelque sorte, le même rapport
qu'entre type et variable. Java est un langage orienté objet : tout appartient à
une classe sauf les variables de types primitifs. Pour accéder à une classe, il
faut en déclarer une instance de classe ou objet. Une classe comporte sa
déclaration, des variables et les définitions de ses méthodes. Une classe se
compose de deux parties : un en-tête et un corps. Le corps peut être divisé en
2 sections : la déclaration des données et des constantes et la définition des
méthodes. Les méthodes et les données sont pourvues d'attributs de visibilité
qui gèrent leur accessibilité par les composants hors de la classe.
Voici la structure d’une classe sans aucune méthode ni propriété
public class Animal
{
}

a. OBJET
Un objet est une instance d’une classe; en d’autres termes un objet
représente un exemplaire utilisable de ce que représente la classe. Il est à
comparer à une variable ordinaire; il a un nom et le type sa classe dont il
découle.
Étant donné qu’il découle de la classe, l’objet a l’autorisation directe
d’accéder aux propriétés et aux méthodes de sa classe.

Seule votre volonté vous conduira à l’Excellence. LMKanyimbu

 b. PROPRIETE
La propriété ou les propriétés dans la POO sont des caractéristiques
permettant de déterminer les données ou l’état dans lequel un objet issu
d’une classe se trouve.
Sur ce, nous utilisons le type primitif en vue de créer les propriétés
au sein d’une classe.
Syntaxe :
Type propriétés;
Imaginons que nous voulons classifier les animaux par leurs modes
d’alimentation (carnivore, herbivore, insectivore, etc), nom, age. Dans ce cas
nous aurons à créer trois propriétés, donc notre classe a la structure
suivante :
public class Animal
{
String nom;
String modealimentation;
int age;
}

c. METHODE
Les méthodes représentent les opérations que mènent les objets
issus d’une classe, elles définissent l’aspect dynamique ou comportemental
d’une classe. Les animaux peuvent dormir, manger, etc.
Avant de déclarer une méthode de la classe, il faut décider si elle
prend des arguments (paramètres) et si elle peut retourner une valeur ou
non.
NiveauxVisibilité type nom(paramètre)
{

}
Exemple :
public class Animal
{
String nom;

Seule votre volonté vous conduira à l’Excellence. LMKanyimbu

 String modealimentation;
int age;

public void dormir()

{
System.out.println("L'animal est endormi");
}
}

Il existe en Java trois types de méthodes :

- Parmi les méthodes certaines ont pour rôle de retourner les valeurs des
propriétés de la classe et d’autres de les modifier. Elles sont nommées
respectivement accesseurs et mutateurs (getters and setters). Il est
possible de les insérer automatiquement en allant dans le menu
source, puis insérer du code, cliquez sur getters and setters puis cocher
la case à cocher de la classe.
public class Animal
{
String nom;
String modealimentation;
int age;
public int getAge() {
return age;
}

public void setAge(int age) {

this.age = age;
}
public String getModealimentation() {
return modealimentation;
}
public void setModealimentation(String modealimentation) {
this.modealimentation = modealimentation;
}
public String getNom() {
return nom;

Seule votre volonté vous conduira à l’Excellence. LMKanyimbu

 }
public void setNom(String nom) {
this.nom = nom;
}
public void dormir()
{
System.out.println("L'animal est endormi et son age est: "+age);
}
}

- Les méthodes qui renvoient des valeurs sont les fonctions, elles sont
précédées du mot clés décrivant le niveau ou principe de visibilité, du
type de la valeur retournée, du nom de la méthode et de la liste des
paramètres. Nous avons dit, nous allons classifier les animaux par
leurs mode d’alimentation ; implémentons une méthode leurs
permettant de détecter si l’animal est un carnivore de l’aliment.
public String manger(String nourriture)
{
if (nourriture.equals("viande"))
{
this.modealimentation="carnivore";
}

return modealimentation;
}
- Les méthodes qui ne renvoient aucune valeur sont les procédures et
elles sont précèdes du mot clé void. void manger(){}.
public void dormir()
{
System.out.println("L'animal est endormi");
}

NB.
La POO ajoute le principe d’accessibilité (visibilité) qui consiste à
contrôler les classes et leurs membres (propriétés et méthodes). Les niveaux
de visibilités sous java sont les suivantes :

Seule votre volonté vous conduira à l’Excellence. LMKanyimbu

 a. Niveau des Classes
Niveau d’accessibilité pour les classes sont les suivantes :
- public : en Java les classes sont par défauts publiques, il convient
cependant nécessaire de le préciser par mot clés public. L’omission de
cette opération rend la méthode inaccessible en dehors de leurs
package.
public class Animal
{
}

- private : ce niveau concerne les classes internes, ce sont les classes

définies à l’intérieur d’une classe et ne sont utilisées que par celle -ci.
public class Chat
{
private Class alvine;
{

b. Niveau des membres (propriétés et méthodes)

- public : les membres d’une classe (propriétés et méthodes) sont
publique, c’est-à-dire cela les rendent visibles à l’extérieur de la classe.
- private : c’est le niveau de restriction le plus élevés, cela rend les
membres de la classe accessible que depuis la classe elle -même. Mais
pour les propriétés elles peuvent être accessibles que par le biais des
accesseurs et mutateurs déclarés publiques.
- protected : les membres sont alors accessibles par les classes du
même package (java) et aussi accessible par les sous classes qui
découlent de la super classe (principe d’héritage).
- Static : les membres de la classe sont alors accessibles depuis la
classe et ne peuvent pas être héritées par les sous classe (classes
filles).

Seule votre volonté vous conduira à l’Excellence. LMKanyimbu

 II. PRINCIPE D’ENCAPSULATION
Le fait de regrouper dans une même classe les méthodes et les
propriétés ainsi que de définir le niveau d’accessibilité constitue
l’encapsulation ; en d’autres termes il s’agit de cacher les codes sources et
présenter l’interface à l’utilisateur. Seules sont visibles les membres
publiques de la classe. Des plus l’implémentation des classes est masquée ;
finalement avec le concept d’encapsulation, la classe représente l’interface
composée des méthodes publiques et leurs éventuelles arguments ou
paramètres.
Dans ce cas pour modifier l’Age d’un chat nous n’avons qu’à faire
appel à la méthode setAge(). Avec cette manière de faire les erreurs sont ainsi
réduites et la sécurité accrue.

III. CONSTRUCTEUR
Pour qu’une classe puisse instancier les objets, il lui faut un
constructeur. Il s’agit alors d’une méthode permettant de créer des objets. Si
vous omettez d’insérer un constructeur, java le créera pour vous au moment
de la compilation. Le constructeur porte le même nom que la classe et il est
souvent déclaré public.
public class Animal
{
private String nom;
private String modealimentation;
private int age;
public Animal(String nom, String modealimentation, int age)
{
this.age=age;
this.modealimentation=modealimentation;
this.nom=nom;
}
Dans ce cas au sein de la méthode principale, nous pouvons créer
un objet A1 qui permettra de passer en paramètres le nom, le mode
alimentation ainsi que l’âge de l’animal. Donc nous aurons du code ci-après :
Animal A1=new Animal("Chat","Carnivore",2);

Seule votre volonté vous conduira à l’Excellence. LMKanyimbu

System.out.println("Le premier animal est: " + A1.getNom()+ "Son mode alimentation: "+
A1.getModealimentation()+"Son age est: "+A1.getAge());

IV. PRINCIPE D’HERITAGE

Le principe d’héritage en POO a été tiré du monde réel. Comme on
dit souvent tel père tel fils ; une classe hérite d’une autre cela revient à avoir
une super classe (classe mère) et une sous classe (fille) qui prend en charge
tous les membres de la super classe. Il est à noter que pour accéder au
constructeur de la super classe nous utilisons le mot clé : super(argument).
Grâce à l'héritage, les objets d'une classe fille ont accès aux
données et aux méthodes de la classe parente et peuvent les étendre. Les
sous classes peuvent redéfinir les variables et les méthodes héritées. Pour les
variables, il suffit de les redéclarer’’ sous le même nom avec un type différent.
Les méthodes sont redéfinies avec le même nom, les mêmes types et le même
nombre d'arguments, sinon il s'agit d'une surcharge.
Nous avons créé une classe appelée Animal, créons ensuite une
classe Chat qui doit hériter des membres de la classe Animal.
Classe Animal
public class Animal
{
private String nom;
private String modealimentation;
private int age;
public Animal(String nom, String modealimentation, int age){
this.age=age;
this.modealimentation=modealimentation;
this.nom=nom;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getModealimentation() {

Seule votre volonté vous conduira à l’Excellence. LMKanyimbu

 return modealimentation;
}

public void setModealimentation(String modealimentation) {

this.modealimentation = modealimentation;
}
public String getNom() {
return nom;
}
public void setNom(String nom) {
this.nom = nom;
}
private void dormir()
{
System.out.println("L'animal est endormi et son age est: "+age);
}
public String manger(String nourriture)
{
if (nourriture.equals("viande"))
{
this.modealimentation="carnivore";
}
return modealimentation;
}
}

Classe Chat
public class Chat extends Animal {
private String couleur;
public Chat(String nom, String modealimentation, int age, String couleur)
{
super(nom, modealimentation, age);
this.couleur=couleur;
}
public String getCouleur() {
return couleur;

Seule votre volonté vous conduira à l’Excellence. LMKanyimbu

 }
public void setCouleur(String couleur) {
this.couleur = couleur; }}
N.B : La Redéfinition des Méthodes
La redéfinition des méthodes est une opération qui consiste à
recréer les méthodes de la super classe avec la même signature au sein de la
sous classe; cette manière de faire est taxée de la spécialisation. S’il on arrive
à créer la spécialisation, la méthode de la super ne sera plus visible mais
celle de la sous classe le sera.

V. LE POLYMORPHISME
Le polymorphisme correspond à la capacité d’un objet à choisir son
type (sa classe) au moment de l’exécution (dynamique) la méthode qui
correspond le mieux à ses besoins parmi ses propres méthodes ou celle des
méthodes mère. Une autre particularité du polymorphisme est que toutes les
méthodes portent le même nom. Au sein d’une classe elle se distingue par le
nombre de paramètres ou le type de ces derniers.
Le polymorphisme correspond à la manipulation des objets sans
pour autant connaître leurs types.
Exemple :
package javaapplication5;

public class fellin {

public void manger(){
System.out.println("je mange quelque chose");
}
}

public class chat extends fellin {

public void manger(){

System.out.print("je mange des croquettes");
}
public void manger(String nour){
System.out.println("je mange "+nour);
}
}

public class titre extends fellin{

public void manger(){
System.out.println("je chasse pour manger");
}

Seule votre volonté vous conduira à l’Excellence. LMKanyimbu

}
Au sein de la classe principale nous aurons ce qui suit :

public class JavaApplication5 {

public static void main(String[] args) {

fellin f1=new chat();

fellin f2=new titre();
f1.manger();
System.out.println("");
f2.manger();
}
}

VI. COLLECTION
Une collection est une particularité des tableaux, elle permet de
stocker les objets de même type ou nature. Java comporte plusieurs types de
collection le plus utilisées sont ArrayList.
Exemple :
import java.util.ArrayList;
public class JavaApplication5 {
public static void main(String[] args) {
String kolo="soso";
ArrayList<String> titre=new ArrayList<String>();
titre.add("ciel");
titre.add(kolo);
}
}
Une erreur survient si vous essayer d’insérer un entier dans une
collection du type chaine de caractères. La taille de la collection est calculable
à la taille d’un tableau (taille-1), pour dire que le premier élément est à
l’indice 0 et le dernier objet à l’indice taille -1.

a. Récupérer un Objet de la collection

Pour récupérer un objet de la collection nous utilisons la méthode
get(indexe) ; ici la méthode get() doit être utilisée avec le paramètre indexe qui
montre la position de l’objet à récupérer.

Seule votre volonté vous conduira à l’Excellence. LMKanyimbu

Exemple :

String res=titre.get(0);
System.out.println(res);

b. Supprimer un Objet de la collection

Pour supprimer un objet de la collection nous usons de la méthode
remove(indexe).

Exemple :
ArrayList<String> titre=new ArrayList<String>();
titre.add("ciel");
titre.add(kolo);
titre.add("sisoko");
titre.remove(0);//là on supprime l’objet à la position 0 de la collection
titre()
Toujours dans ce même chapitre s’il faut tout effacer nous utilisons
la méthode clear().

c. Modifier un Objet d’une collection

Pour effectuer cette tâche nous avons besoins de la méthode
set(index, valeur). Cette méthode a besoin de deux paramètres dont le premier
c’est pour spécifier la position de l’objet à modifier et le se cond le nouveau
objet qui prend place de l’ancien.
Exemple :
String kolo="soso";
ArrayList<String> titre=new ArrayList<String>();
titre.add("ciel");
titre.add(kolo);
titre.add("sisoko");
titre.set(1, "landrymbay");
Ceci revient à spécifier que l’objet 1 de la collection titre sera
remplacé par landrymbay.

Seule votre volonté vous conduira à l’Excellence. LMKanyimbu

 Une instance d’une collection est considérée comme instance d’une
classe.

Exemple :
chat chat1=new chat("solo", "kolo");
chat chat2=new chat("sila", "kola");
ArrayList<chat> titre=new ArrayList<chat>();
titre.add(chat1);
titre.add(chat2);

Cela nous permet de dire qu’il existe déjà la classe chat dont voici
son architecture.
public class chat extends fellin {
String nom;
String postnom;
public chat(String lenom, String lepostnom){
nom=lenom;
postnom=lepostnom;
}
}

NB : Il est à préciser ici que dès que vous créez votre collection, elle n’est peux pas être utilisée
dans le même bloc d’instruction ; il faut soit l’utiliser dans une méthode, constructeur, accesseur
ou autre classe.

d. Création d’une collection d’objets

Il est possible de créer une collection à objet, c’est-à-dire qu’une
collection qui a la capacité de sauvegarder les différents objets issus d’une
classe. Dans ce cas, il faut songer à créer la collection avec comme type la
classe. Voici comment cela doit se faire.

public class personne {

String nom;

int age;

Seule votre volonté vous conduira à l’Excellence. LMKanyimbu

 public ArrayList<personne> p=new ArrayList<personne>();}

Ces lignes d’instructions créent la classe personne, les propriétés

nom, et age ainsi que la collection p qui est elle -même du type personne (la
classe dans laquelle est créée la collection).
Pour permettre à ce que la collection puisse créer les objets, il faut
définir le constructeur qui permettra à chaque fois qu’on devra ajouter un
objet dans la collection, qu’on fournisse les valeurs à ses membres (age et
nom dans le cas de cet exemple).
public personne(String n, int a)
{
this.age=a;
this.nom=n;
}

Pour ajouter les objets (personne) créés dans la collection, nous

implémentons la méthode créée qui va commencer à chaque fois qu’on
l’appellera, qu’on puisse ajouter un objet avec deux propriétés au sein de
cette collection.
public void Creer(String n, int a)
{
p.add(new personne(n,a));
}
Alors l’architecture de la classe devient la suivante :
public class personne {
String nom;
int age;
public ArrayList<personne> p=new ArrayList<personne>();

public personne(String n, int a)

{
this.age=a;
this.nom=n;
}

public personne()

Seule votre volonté vous conduira à l’Excellence. LMKanyimbu

 { }
public void Creer(String n, int a)
{
p.add(new personne(n,a));
}
}

e. UTILISATION DE LA COLLECTION DANS LA CLASSE PRINCIPALE

Juste après avoir créé la collection, il faut maintenant l’utilisée.
Dans ce cas, nous l’utilisons dans la classe principale où nous créons un
objet de la classe personne, pour accéder à la collection.

personne k=new personne();

k.Creer("lolo", 10);
k.Creer("Popo", 20);

Comme nous l’avions vu précèdement, pour récupérer une valeur

de la collection, nous utilisons la méthode get(). Ce qui essaie d’amener la
complexité. Dans le sens qu’une collection simple utilise la méthode get ainsi
que l’indice qui définit la position de la valeur seulement ; tandis qu’une
collection d’objet doit d’abord préciser la position, ainsi que le nom de la
propriété qui doit envoyer sa valeur.
int t= k.p.get(1).age;
System.out.print(""+t);

Le programme présente alors les codes suivants

public class NewMain {
public static void main(String[] args) {
personne k=new personne();
k.Creer("lolo", 10);
k.Creer("Popo", 20);
int t= k.p.get(1).age;
System.out.print(""+t);

}
}

Seule votre volonté vous conduira à l’Excellence. LMKanyimbu

 CHAPITRE II. JAVA ET LA TECHNOLOGIE MVC
I. PRESENTATION DU CONCEPT
Le modèle ou la technologie MVC (Modèle-Vue-Contrôleur) formalise
la séparation des objets métiers (données) de leurs présentation ainsi que de
leur analyse (qui est une couche intermédiaire la couche contrôle).
Dans un modèle MVC, les données constituent le modèle, les
classes graphiques la vue. Le modèle et la vue sont totalement différents l’un
de l’autre. Nous dirons qu’ils ne se connaissent pas. Comment alors les
actions de l’utilisateur via les vues peuvent-elles modifier le modèle et,
inversement, comment les données attendues peuvent-elles être affichées ?
C’est justement les contrôleurs qui vont établir le lien.

Ce qu’il voit

Ce qu’il fait

Utilisateur
Vue

Contrôleur

Modèle

Le schéma nous montre que l’utilisateur n’a aucune connaissance

du contrôleur. C’est pourtant lui qui transmet de manière transparente pour
l’utilisateur les demandes aux modèles pour traitement. Les vues sont mises
à jour soit par le contrôleur soit par le modèle par un système de notification
basé sur la notion d’évènements et d’écouteurs d’évènements.
Quant à ce, nous allons proposer un petit projet avec deux fenêtres
(IHM) ; lequel de ce projet nous permettra de mettre en œuvre la notion de la
technologie MVC.

Seule votre volonté vous conduira à l’Excellence. LMKanyimbu

 II. LA TECHNOLOGIE MVC
a. Le Modèle
Le modèle représente le cœur (algorithmique) de l'application :
traitements des données, interactions avec la base de données, etc. Il décrit
les données manipulées par l'application. Il regroupe la gestion de ces
données et est responsable de leur intégrité. La base de données sera l'un de
ses composants. Le modèle comporte des méthodes standards pour mettre à
jour ces données (insertion, suppression, changement de valeur). Il offre
aussi des méthodes pour récupérer ces données. Les résultats renvoyés par
le modèle ne s'occupent pas de la présentation.

b. La Vue
C’est avec quoi l'utilisateur interagit se nomme précisément la vue.
Sa première tâche est de présenter les résultats renvoyés par le modèle. Sa
seconde tâche est de recevoir toute action de l'utilisateur (hover, clic de
souris, sélection d'un bouton radio, cochage d'une case, entrée de texte, de
mouvements, de voix, etc.). Ces différents événements sont envoyés au
contrôleur. La vue n'effectue pas de traitement, elle se contente d'afficher les
résultats des traitements effectués par le modèle et d'interagir avec
l'utilisateur.
Plusieurs vues peuvent afficher des informations partielles ou non
d'un même modèle. Par exemple si une application de conversion de base a
un entier comme unique donnée, ce même entier peut être affiché de
multiples façons (en texte dans différentes bases, bit par bit avec des boutons
à cocher, avec des curseurs). La vue peut aussi offrir à l'utilisateur la
possibilité de changer de vue. Ceci permet une certaine récursivité du
modèle.

c. Le Contrôle
Le contrôleur prend en charge la gestion des événements de
synchronisation pour mettre à jour la vue ou le modèle et les synchroniser. Il

Seule votre volonté vous conduira à l’Excellence. LMKanyimbu

reçoit tous les événements de la vue et enclenche les actions à effectuer. Si
une action nécessite un changement des données, le contrôleur demande la
modification des données au modèle afin que les données affich ées se
mettent à jour.
D'après le patron de conception observateur/observable, la vue est
un « observateur » du modèle qui est lui « observable ». Certains événements
de l'utilisateur ne concernent pas les données mais la vue. Dans ce cas, le
contrôleur demande à la vue de se modifier. Le contrôleur n'effectue aucun
traitement, ne modifie aucune donnée. Il analyse la requête du client et se
contente d'appeler le modèle adéquat et de renvoyer la vue correspondant à
la demande.

III. ETUDE DE CAS

Dans ce point de notre cas, nous menons un projet informatique
dans lequel, nous utilisons premièrement le SGBD MySql comme système de
gestion de bases de données. Certes pour se connecter à une base de
données MySql, il nous faut utiliser le pilote odbc (MiddleWare) pour ce
système de gestion de base de données.

a. Installation de Mysql Connector ODBC

Cette petite application permet d’installer le pilote ODBC pour
permettre à l’application java d’accéder d’une manière transparente à la base
de données. Il est à noter que le pilote ODBC (Open DataBase Connectivity)
est une couche logicielle permettant à une application Windows d’accéder de
façon transparente à une base de données.

b. Connection à la base de données

Telle que nous l’avions fait pour le MS Access, il suffit tout
simplement d’aller dans le control panel, ODBC Data Sources, ajouter une
source de données pour le pilote chercher le pilote Mysql ODBC 5.2w Driver,
cela vous donne la fenêtre suivante :

Seule votre volonté vous conduira à l’Excellence. LMKanyimbu

 Fournissez le nom de votre source de données, l’adresse IP du
serveur (localhost comme nous travaillons sur la même machine), root est de
l’utilisateur par défaut que nous devons utiliser. Une fois toutes ces
informations fournies, vous verrez toutes les bases de données liées à cet
utilisateur.
Connectez-vous à la base de données de votre choix et vous
pouvez tester la connectivité en cliquant sur le bouton Test.

c. Implémentation de l’application
i. Introduction
L’application que nous développons dans ce chapitre, constitue la
séparation stricte de l’implémentation de la classe persistance, contrôle pour
mettre en œuvre les règles de gestion ainsi que la présentation pour la
visualisation des résultats.
Sur ce, nous commençons d’abord par implémenter la couche
Modèle avec la classe (entité) article. Sachant que notre application se
connectera à la base de données, celle-ci permet de gérer les données sur les
articles. En guise d’enseignement, nous créons une seule table (article) que
nous utiliserons dans la suite de ce cours.

Seule votre volonté vous conduira à l’Excellence. LMKanyimbu

 ii. La couche Modèle (Persistance)
La couche modèle implémente une classe article, au sein de
laquelle nous avons deux propriétés qui sont NumArt et Désignation dont
toutes sont privées pour question de la sécurité des informations.
public class ARTICLE
{
private String Code;
private String Designation;
}
Étant donné que les données sont privées, implémentons les
accesseurs (setters) et les mutateurs (getters) qui vont nous permettre
respectivement l’accès et la modification de données membres.
public class ARTICLE {
private String Code;
private String Designation;
public String getCode() {
return Code;
}
public void setCode(String Code) {
this.Code = Code;
}
public String getDesignation() {
return Designation;
}

Étant donné que nous sommes dans la séparation stricte des

différentes couches logicielles, il est impératif que nous puissions créer une
solution qui devra manipuler les données en dehors de cette couche (modèle).
Après le balayage des solutions existantes, ce que nous avions utilisé comme
solution, sont les collections (ArrayList).
C’est ainsi, nous créons une collection donnee du type article
(classe) qui permettra le parcours des données de la base en dehors de cette
couche.
private ArrayList<ARTICLE> donnee=new ArrayList<ARTICLE>();

Seule votre volonté vous conduira à l’Excellence. LMKanyimbu

N.B :
La collection donnee qui est elle-même du type article, devra
stocker les objets issus de celle-ci. Pour se faire, il faut que la classe puisse
implémenter un constructeur avec les propriétés susceptible d’être stockées
dans la collection. C’est pourquoi, nous avons la présence de notre
constructeur ci-dessous, ainsi que son accesseur pour y accéder.

public ARTICLE(String c, String d)

{
Code=c;
Designation=d;
}
public ArrayList<ARTICLE> getDonnee()
{
return donnee;
}

LES METHODES IMPLEMENTEES

La couche modèle qui permet de gérer la persistance, c’est-à-dire
gérer l’accès aux données, doit obligatoirement nous permettre de manipuler
toutes les opérations du cycle informationnel CRUD.
Quant à ce, notre classe article devra permettre à d’autres couches
d’insérer, modifier, supprimer et même lire les données de la base sans
toucher directement la BDD, mais sans passer par elle. Ainsi donc, nous
implémentons pour question pédagogique deux méthodes (Enregistrer et
Lire).

a. La Méthode Enregistrer
La méthode enregistrer que nous implémentons ici, permet
d’insérer un nouveau objet (tuple) dans la base de données. Une fois l’appeler
nous devons lui fournir les données différentes susceptible d’être stockées
dans la table. Comme la classe n’a implémentée que deux proprié tés (Code &
Designation), l’appel de cette méthode devra exiger aussi deux valeurs qui
devront représentées ces deux propriétés. Voici implementation.

Seule votre volonté vous conduira à l’Excellence. LMKanyimbu

protected void Enregistrer(String ECode, String EDesignation ){
try{
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
String ben="jdbc:odbc:LAND";
con=DriverManager.getConnection(ben);
st=con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
res=st.executeQuery("SELECT * FROM ARTICLE");
res.last();
res.moveToInsertRow();
res.updateString("Code", ECode);
res.updateString("Designation", EDesignation);
res.insertRow();
res.moveToCurrentRow();
}catch(Exception e){JOptionPane.showConfirmDialog(null, "Une Erreur s'est
lévée");
}
}

b. La Méthode Lire
La méthode Lire quant à elle, implémente la lecture ou le
parcourt de données seulement. Comme la lecture ne doit pas se faire
directement dans la base données en dehors de cette couche, les données
que nous lisons seront automatiquement gérées dans la collection créée
précèdement pour question de sécurité. L’implémentation est la suivante :

protected void Lire(){

try{
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
String ben="jdbc:odbc:LAND";
con=DriverManager.getConnection(ben);
st=con.createStatement();
res=st.executeQuery("SELECT * FROM ARTICLE ORDER BY Designation");
while(res.next())
{

Seule votre volonté vous conduira à l’Excellence. LMKanyimbu

 this.Code=res.getString("Code");
this.Designation=res.getString("Designation");
donnee.add(new ARTICLE(Code,Designation));
}
}catch(Exception e){
JOptionPane.showConfirmDialog(null, "il y erreur veuillez revoir " + e);
}
}

NB : L’ensemble de codes est le suivant :

package E;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.*;
import javax.swing.JOptionPane;

public class ARTICLE {

private String Code;
private String Designation;
private ArrayList<ARTICLE> donnee=new ArrayList<ARTICLE>();
private Connection con;private Statement st; private ResultSet res;
public ARTICLE(String c, String d)
{
Code=c;
Designation=d;
}
public ARTICLE()
{
}
public String getCode()
{ return Code; }

public void setCode(String Code)

{ this.Code = Code;}

Seule votre volonté vous conduira à l’Excellence. LMKanyimbu

 public String getDesignation()
{ return Designation; }

public void setDesignation(String Designation) {

this.Designation = Designation;
}

public ArrayList<ARTICLE> getDonnee() {

return donnee;
}

protected void Lire(){

try{
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
String ben="jdbc:odbc:LAND";
con=DriverManager.getConnection(ben);
st=con.createStatement();
res=st.executeQuery("SELECT * FROM ARTICLE ORDER BY Designation");
while(res.next())
{
this.Code=res.getString("Code");
this.Designation=res.getString("Designation");
donnee.add(new ARTICLE(Code,Designation));
}
}catch(Exception e){
JOptionPane.showConfirmDialog(null, "il y erreur veuillez revoir " + e);
}
}
protected void Enregistrer(String Ecode, String Edesignation, int qte){
try{
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
String ben="jdbc:odbc:LAND";
con=DriverManager.getConnection(ben);
st=con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
res=st.executeQuery("SELECT * FROM ARTICLE");

Seule votre volonté vous conduira à l’Excellence. LMKanyimbu

 res.last();
res.moveToInsertRow();
res.updateString("Code", Ecode);
res.updateString("Designation", Edesignation);
res.updateInt("QteStock", qte);
res.insertRow();
res.moveToCurrentRow();
}catch(Exception e){JOptionPane.showConfirmDialog(null, "Une Erreur s'est
lévée");
}
}

iii. la Couche Contrôle

La couche contrôle permet de créer l’intermédiaire entre la couche
contrôle et la couche persistance et dont la théorie est éclairée dans les pages
précédentes. Encore cette couche a pour objectif de pouvoir implémenter les
règles de gestion d’une entreprise ou de l’organisation pour laquelle l’on
conçoit le système d’information.
Au sein de cette couche, nous implémentons une classe modart qui
hérite de la classe ARTICLE afin de pouvoir accéder méthodes implémentées.
Il visiblement claire que toutes les méthodes implémentées au sein de cette
couche sont protégées. Cela signifie qu’en dehors du package qui implémente
cette classe, ces méthodes ne seront pas visible. Ce pourquoi cette classe
hérite ARTICLE pour accéder facilement.

public class modart extends ARTICLE

{

La classe implémente aussi les mêmes propriétés pour la manipulation

de données; en dehors des propriétés, nous avons la présence de la collection
permettant de parcourir toutes les données qui sont au sein de notre base de
données. Ainsi, voici l’implémentation :

Seule votre volonté vous conduira à l’Excellence. LMKanyimbu

public class modart extends ARTICLE
{
private String Code;
private String Designation;
public ArrayList<ARTICLE> lect;
}

LES METHODES IMPLEMENTEES

Nous décrivons ci-dessous les différentes méthodes implémentées
au sein de notre couche.
a. La méthode Parcourir
La méthode parcourir, permet de faire le lien entre l’affichage de
données et la persistance. Nous affectons les données trouvées dans la
collection au niveau de la couche modèle au sein de la collection qui se
trouve au sein contrôle.
Alors à chaque fois qu’on devra appeler la méthode parcourir, ça
sera pour lire les données qui se trouvent dans la table quelconque (article).
Voici son implémentation.
public void Parcourir()
{
this.Lire();
lect=this.getDonnee();
}

b. La méthode Save
Celle-ci permet lors de son appel d’enregistrer, les données au sein
de la base de données. Notons que dans sa signature, vous verrez qu’il y a les
différents arguments. Cela signifie qu’avant que celle s’exécute, il faut fournir
les données sur lesquelles on devra travailler. Notons que ces données
représentent les informations à enregistrer.
Voici son code.
public void Save(String Code, String Designation)
{
this.Enregistrer(Code, Designation);
}

Seule votre volonté vous conduira à l’Excellence. LMKanyimbu

NB : Le code complet de cette couche est la suivante :
package C;
import E.ARTICLE;
import java.util.ArrayList;

public class modart extends ARTICLE {

private String Code;
private String Designation;

public ArrayList<ARTICLE> lect;

public void Save(String Code, String Designation)
{
this.Enregistrer(Code, Designation);
}
public void Parcourir()
{
this.Lire();
lect=this.getDonnee();
}

iv. LA COUCHE INTERFACE

Elle est aussi une couche importante dans le sens que c’est elle qui
permet visualiser toutes les activités applicatives aux yeux des utilisateurs.
En d’autres termes, elle permet de créer l’intermédiaire entre l’application et
les utilisateurs.
Pour répondre à l’étude de cas que nous avons, nous implémentons
une interface, qui permet en cliquant sur un bouton, on enregistre les
données dans la base en passant par les différentes classes. Nous présentons
ici la recherche ainsi que l’enregistrement.
a. La Recherche
private void jButton3ActionPerformed(java.awt.event.ActionEvent evt)
{
m.Parcourir(); this.TCode.setText(m.lect.get(2).getCode());
this.TDesignation.setText(m.lect.get(2).getDesignation()); }

Seule votre volonté vous conduira à l’Excellence. LMKanyimbu

 b. L’enregistrement
private void jButton1ActionPerformed(java.awt.event.ActionEvent evt)
{
m.Save(this.TCode.getText(), this.TDesignation.getText());
this.TCode.setText("");
this.TDesignation.setText("");
}

Remarque: Il peut arriver nous voulions charger tous les codes dans un combobox, la solution sera
celle d’utiliser les codes suivants :
private void formComponentShown(java.awt.event.ComponentEvent evt) {
int i=0;
m.Parcourir();
while (i<= m.lect.size()-1)
{
this.list.addItem(m.lect.get(i).getDesignation());
i++;
}
}

Seule votre volonté vous conduira à l’Excellence. LMKanyimbu

 CHAPITRE III. LES APPLETS
I. INTRODUCTION

Aux commencements de Java, l'un des avantages critiques des

applets par rapport aux applications Java classiques est qu'elles pouvaient
être facilement déployées par Internet alors que les applications classiques
nécessitent plus de programmation.
Ceci implique que l'avantage majeur restant aux applets est qu'elles
peuvent s'exécuter dans un navigateur Internet, alors qu'une application
classique s'exécute en dehors d'un navigateur.
Ainsi les applets peuvent fournir des services complets qui ne sont
pas habituellement réalisables avec HTML ou Javacript : jeux graphiques,
édition complexe, interactions.
Quant à ce, on définit l’applet comme étant Applet = Application
Internet écrite en Java intégrée à une page HTML ne pouvant être
qu'exécutée par un navigateur et s'affichant dans la page HTML.

II. RAPPEL SUR LES NOTIONS DE HTML

Jusqu'à présent tous les programmes Java qui ont été écrits dans
les autres chapitres sont des applications autonomes pouvant fonctionner
directement sur une plateforme Windows, Unix, Linux, MacOs...
Une des raisons initiales, du succès de Java peut être la raison
majeure, réside dans la capacité de ce langage à créer des applications
directement exécutables dans un navigateur contenant une machine virtuelle
java. Ces applications doivent être insérées dans le code interne d'une page
HTML (Hyper Text M arkup Language) entre deux balises spécifiques.
Ces applications insérées dans une page HTML, peuvent être
exécutées en local sur la machine hôte, le navigateur jouant le rôle
d'environnement d'exécution. Elles peuvent aussi être exécutées en local par
votre navigateur pendant une connexion à internet par téléchargement de
l'application en même temps que le code HTML de la page se charge. Ces
applications Java non autonomes sont dénommées des applets.

Seule votre volonté vous conduira à l’Excellence. LMKanyimbu

 Une page HTML est un fichier texte contenant des descriptions de
la mise en page du texte et des images. Ces descriptions sont destinées au
navigateur afin qu'il assure l'affichage de la page, elles s'effectuent par
l'intermédiaire de balises (parenthèses de description contextuelles). Un
fichier HTML commence toujours par la balise <HTML> et termine par la
balise </HTML>.
Une page HTML minimale contient deux sections :
L'en-tête de la page balisée par <HEAD> ...</HEAD>
Le corps de la page balisé par <BODY> ... </BODY>

Voici un fichier texte minimal pour une page HTML :

<HTML>
<HEAD> Titre de la barre de titre
</HEAD>
<BODY>
Le corps de votre programme
</BODY>
</HTML>

III. LES APPLETS

a. Introduction

Une applet Java est invoquée grâce à deux balises spéciales

insérées au sein du corps de la page HTML :
<APPLET CODE =.......>
</APPLET>
Nous reverrons plus loin la signification des paramètres internes à
la balise <APPLET>. Terminons cette introduction en signalant qu'une applet,
pour des raisons de sécurité, est soumise à certaines restrictions notamment
en matière d'accès aux disques durs de la machine hôte.

Seule votre volonté vous conduira à l’Excellence. LMKanyimbu

 b. La Classe Applet

Cette classe joue un rôle semblable à celui de la classe Frame dans

le cas d'une application. Une Applet est un Panel spécial qui se dessinera sur
le fond de la page HTML dans laquelle elle est insérée.
Si vous voulez écrire des applets, il faut posséder un navigateur
pour exécuter les applets et un éditeur de texte permettant d'écrire le code
source Java.
Tout environnement de développement java doit contenir un moyen
de visionner le résultat de la programmation de votre applet, cet
environnement fera appel à une visionneuse d'applet (dénommée
AppletViewer dans le JDK).

i. Création de l’Applet

Pour créer une applet, il faut que votre classe contenant les codes
puisse hériter de la classe Applet de la manière suivante :
package lmkapplet;
import java.applet.*;

public class LMKAPPLET extends Applet{

ii. Fonctionnement de l’Applet

Nous allons examiner quelques-unes des 23 méthodes de la classe

Applet, essentielles à la construction et à l'utilisation d'une applet.

© La Méthode init()
Lorsqu'une applet s'exécute la méthode principale qui s'appelait
main( ) dans le cas d'une application Java se dénomme ici init( ). Il nous
appartient donc de surcharger dynamiquement, (redéfinir) la méthode init
de la classe Applet afin que notre applet fonctionne selon nos attentes.

Seule votre volonté vous conduira à l’Excellence. LMKanyimbu

 La méthode init( ) est appelée une seule fois, lors du chargement
de l'applet avant que celui-ci ne soit affiché. Exemple d'applet vide :
import java.applet.*;
public class LMKAPPLET extends Applet{

}
Dans ce cas vous avez créé un applet qui n’implémente rien. Une
fois fini vous pouvez lancer l’exécution de votre applet tout en étant dans java
(l’application java appletviewer va s’encharger). Avec l’Environnement de
développement intégré pour lancé l’exécution de l’applet, il ne faut pas le faire
comme si c’était l’application java classique, par contre il faut aller dans le
menu « Exécuter », et sur l’option « Exécuter le Fichier » (soit combiné les
touches MAJ + F).
Vous aurez la page suivante : *

NB :
Avec cette même méthode vous pouvez changer la couleur d’arrière-
plan de votre page web de la manière suivante
import java.applet.Applet;
import java.awt.Color;
public class kan extends Applet {
public void init() {
this.setBackground(Color.CY AN);//changement de couleur dans l’applet
}
}

Seule votre volonté vous conduira à l’Excellence. LMKanyimbu

 © La Méthode Start()
La méthode Start() est une méthode qui est appelée soit :
 Après la méthode init()
 Après chaque modification de la taille de l'applet (minimisation,...).
Si nous voulons que notre applet effectue une action spécifique au
redémarrage, il suffit de surcharger dynamiquement (redéfinir) la méthode
start().
Exemple :
Soit à compter et afficher dans une Label, le nombre d'appels à la
méthode start() :
import java.applet.Applet;
import java.awt.*;
public class kan extends Applet {
Label ben=new Label("Démarrage numero: ");
int bk=0;
public void init() {
this.setBackground(Color.CYAN);
this.add(ben);
}
public void start(){
bk++;
ben.setText("Démarrage numéro: " + bk);
}
}

Seule votre volonté vous conduira à l’Excellence. LMKanyimbu

 © La Méthode paint()
Cette méthode est chargée de l'affichage de tout ce qui est
graphique, vous mettrez dans le corps de cette méthode votre code d'affichage
de vos éléments graphiques afin qu'ils soient redessinés systématiquement.
La méthode paint( Graphics x ) est appelée à chaque fois, soit :
 Après que l'applet a été masquée, déplacée, retaillée,...
 A chaque réaffichage de l'applet (après minimisation,...).
Exemple :
En considérant l’applet précèdent, l’on demande de dessiner une
ellipse pain de la couleur bleu ; les codes sources deviennent les suivants :
import java.applet.Applet;
import java.awt.*;
public class kan extends Applet {
Label ben=new Label("Démarrage numero: "); int bk=0;
public void init() {
this.setBackground(Color.CYAN); this.add(ben);
}
public void start(){
bk++; ben.setText("Démarrage numéro: " + bk);
}
public void paint(Graphics x){
this.setForeground(Color.blue);
x.fillOval(110, 60, 100, 50);
}}

Seule votre volonté vous conduira à l’Excellence. LMKanyimbu

 © Les Méthodes Stop() et Destroy()
La méthode stop( ) est appelée à chaque fois, soit :
Que l'applet a été masquée dans la page du navigateur (défilement vertical
ou horizontal dans le navigateur), déplacée, retaillée,...
Lors de l'abandon et du changement de la page dans le navigateur.
Elle permet d’arrêter toutes les actions en cours de l’applet.

c. L’APPLET DANS LA PAGE HTML

Nous avons déjà indiqué au premier paragraphe de ce chapitre que

le code d'appel d'une applet est intégré au texte source de la page dans
laquelle l'applet va être affichée. Ce sont les balises <APPLET CODE =.......>
et </APPLET> qui précisent les modalités de fonctionnement de l'applet. En
outre, l'applet s'affichera dans la page exactement à l'emplacement de la
balise dans le code HTML. Donc si l'on veut déplacer la position d'une applet
dans une page HTML, il suffit de déplacer le code compris entre les deux
balises <APPLET CODE =.......> et </APPLET>.
Voici une page HTML dont le titre est "Simple Applet " et ne
contenant qu'une applet :
<HTML>
<HEAD>
<TITLE> Simple Applet </TITLE>
</HEAD>
<BODY>
<APPLET CODE="kan.class" WIDTH=200 HEIGHT=100>
</APPLET>
</BODY></HTML>

Seule votre volonté vous conduira à l’Excellence. LMKanyimbu

N.B :
Il y a donc des paramètres obligatoires à transmettre à une applet,
ce sont les paramètres CODE, WIDTH et HEIGHT :
Paramètres Significations
CODE Le nom du fichier contenant l’applet à afficher
WIDTH La largeur de l'applet au démarrage dans la page HTML (en
pixels)
HEIGHT la hauteur de l'applet au démarrage dans la page HTML (en
pixels)

A côté de ces paramètres obligatoires existent des paramètres

facultatifs relatifs au positionnement et à l'agencement de l'applet à
l'intérieur de la page HTML (align, alt, hspace, vspace, codebase, name).

d. L’APLLET ET LES INTERFACES GRAPHIQUES

Le travail est plus complexe avec Swing, en effet le JApplet comme

le JFrame, est un conteneur de composants visuels qui dispose de 4 niveaux
de superposition d'objets à qui est déléguée la gestion du contenu du
JApplet.

Pour ce qui est de l’interface graphique à ce niveau nous allons

concevoir une interface graphique ayant quatre objets le label, la zone de
texte et les deux boutons. Une fois saisir le nom dans la zone de texte et
cliquer sur le bouton afficher l’on doit afficher le message « Votre nom est +
nom. Le bouton Close nous servira juste pour fermer l’application ; l’interface
graphique se présente de la manière suivante :

Seule votre volonté vous conduira à l’Excellence. LMKanyimbu

Pour cette interface, s’il faut introduire cette interface dans les codes java de
l’applet nous aurons ce qui suit :
import java.applet.Applet;
import java.awt.*;import javax.swing.*;import java.awt.event.*;
public class kan extends Applet {
int bk=0;
GridLayout g=new GridLayout(2,2,5,5);JPanel p=new JPanel();
JLabel lmk=new JLabel("Nom:"); JTextField T1=new JTextField(15);
JButton b1=new JButton("Afficher");JButton b2=new JButton("Close");

public void init() {

this.setBackground(Color.CYAN);
p.setLayout(g);p.setBackground(Color.MAGENTA);
p.add(lmk);p.add(T1);
p.add(b1);
p.add(b2);
this.add(p);
}
public void start(){
b1.addMouseListener(new MouseAdapter(){
public void mouseClicked(MouseEvent l){
T1.setText("Votre Nom est :" +T1.getText());
}
});
b2.addMouseListener(new MouseAdapter(){
public void mouseClicked(MouseEvent kan){
int kb=JOptionPane.showConfirmDialog(null, "Voulez-vous Quitter
l'application?", "QUESTION", JOptionPane.YES_NO_OPTION);
if (kb==JOptionPane.YES_OPTION)
{
System.exit(0);
}
}
});
}
}

Seule votre volonté vous conduira à l’Excellence. LMKanyimbu

 CHAPITRE IV. LA PROGRAMMATION DISTRIBUEE

I. INTRODUCTION

Dans certaines mesures, les applications sont conçues pour

échanger (envoie et réception) des informations entre elles. Dans la
programmation, la solution existante ce sont les sockets que nous trouvons
dans la plus part des langages de programmation.
Depuis la sortie de java, une API permettant de gérer le réseau est
disponible dans le JDK, elle permet de gérer les adresses, les sockets clients,
les sockets serveurs, les URL,…

II. LES ADRESSES RESEAUX

Une adresse IP consiste en un identifiant machine permettant son
identification sur un réseau. Sous la programmation, l’adresse IP est
représentée par les instances de la classe InetAddress ou par les sous-
classes :
- Inet4Address pour le protocole IPv4 (32 bits) ;
- Inet6Address pour le protocole IPv6 (128 bits)
Chaque machine de l'Internet est identifiée par une adresse ou un
nom unique. Ces deux entités sont gérées sous Java par la classe
InetAddress. C’est une classe qui permet d’identifier une autre machine et
ressortir toutes les propriétés ou informations y afférentes.
Voici quelques méthodes de cette classe :
getHostName() : Elle retourne le nom de l’hôte (ordinateur)
getHostAddress() : Elle retourne l’adresse IP de la machine locale()
public class client {
public static void main(String[] args) throws Exception {
// TODO code application logic here
InetAddress ord=InetAddress.getLocal Host();
System.out.print("L'adresse IP de votre machine est: " + ord.getHostAddress());
}
}

Seule votre volonté vous conduira à l’Excellence. LMKanyimbu

NB :
- Les mêmes méthodes peuvent être utilisées pour avoir l’adresse et le
nom de la machine distante. Sur ce, nous pouvons changer le code ci-
haut de la manière suivante.
public class ben {
public static void main(String[] args) {
try {
InetAddress Machine=InetAddress.getByName("BEN");
System.out.println(Machine.getHostAddress());
System.out.println(Machine.getHostName());
}catch(Exception e){System.out.println("Il y a erreur car " + e);}
}
}

- En dehors des méthodes getHostAddress() & getHostName(), nous pouvons

aussi utilisé ToString() pour nous afficher et l’adresse IP ainsi que le nom
de la machine.

III. PROGRAMMATION RESEAU

a. LA SOCKET

Une porte à travers laquelle l’application peut à la fois envoyer et

recevoir des messages d’une autre application. Outil de communication pour
échanger des données entre un client et un serveur et ce sont des Canaux de
communication (descripteur d’entrée sortie dans lesquels on écrit et sur
lesquels on lit).
Deux types de transports doivent être utilisés pour construire des
applications Client/serveur via socket :
- Datagramme (protocole UDP)
- Orienté flux d’octets (protocole TCP/IP)

Seule votre volonté vous conduira à l’Excellence. LMKanyimbu

 b. PROTOCOLE TCP/IP

De manière assez sommaire, le protocole TCP a été créé pour

permettre d'envoyer des données de manière fiable par le réseau, notamment
en :
- S'assurant que les données arrivent au destinataire, en cas d'échec de
transmission, l'ordinateur émetteur doit être mis au courant
- S'assurant que les données arrivent dans le bon ordre
- Définissant une connexion entre les machines

Remarque : Dans la programmation des sockets, nous sommes dans

l’architecture client/serveur. Il faut commencer par programmer le serveur et
le client suit après. De ce fait, nous allons programmer le serveur à travers la
classe ServerSocket.

i. Serveur

Dans ce premier point, il vous suffit de créer la classe Serveur

auquel le client doit se connecter, ainsi qu’un objet serveur socket ; à travers
le port, nous pourrions lui mettre à l’écoute et accepter la demande de la
connexion s’il y en a.
import java.net.*;
public class client {
public static void main(String[] args) throws Exception {
ServerSocket server=new ServerSocket(6000);
}
}

Nous créons par la suite un objet socket, qui permettra dès qu’il y a
une demande de connexion, qu’on puisse se connecter. Ensuite, nous
insérons aussi une boucle pour permettre dès qu’il y a une demande qu’on
établisse la connexion directement avec le client.

import java.net.*;
public class ben {

Seule votre volonté vous conduira à l’Excellence. LMKanyimbu

 public static void main(String[] args)throws Exception
{
ServerSocket serveur=new ServerSocket(6000);
Socket client;
System.out.println("Demarrage du Serveur ...");
while(true)
{
client=serveur.accept();
System.out.println("Connexion réussi l'adresse du client est: " +
client.getInetAddress());
}}}

Après il ait été programmé (Serveur) il est temps de le démarrer

pour le mettre à l’écoute de toutes les demandes client. S’il le client doit
s’exécuter sur une autre machine que celle du serveur, dans ce cas, assurez-
vous qu’il a la connexion réseau entre ces deux machines.

ii. Client

La programmation du client consiste à programmer une application

qui va demander la connexion à l’application serveur à travers d’un socket ;
qui doit récupérer le nom de la machine sur laquelle s’exécute le serveur
ainsi que le numéro du port permettant au serveur d’être à l’écoute.

import java.net.*;
public class CLIENT {
public static void main(String[] args){
try
{
Socket client=new Socket(“BENENLAND-PC”,6000);
System.out.println(“Le serveur a accepté votre demande”);
}catch(Exception e) {System.out.printl(“Pas de connexion car ” +e)}

}
}

S’il faut expliquer ces codes; nous commençons par créer une
classe client toutes en gérant les exceptions (ou les erreurs) avec try, nous
créons ensuite un objet socket doit prendre deux paramètre (le nom de la
machine où se loge le serveur ainsi que son port) en suite imprimer un
message de connexion dès que la connexion est établie avec le serveur.

Seule votre volonté vous conduira à l’Excellence. LMKanyimbu

 iii. Gestion des Flux d’Entrées/Sortie

Les flux sont des informations qui peuvent être émises ou reçues
d’une part par le client et de l’autre part par le serveur. Il s’agit du flux in
pour les entrées et du flux out pour les sorties.

1. Le Flux d’Entrée

Au niveau d’entrée nous avons, la classe BufferedReader et la

classe InputStreamReader qui nous permettent de récupérer les informations
envoyées soit par le serveur soit client. Voici comment se
présente l’architecture (syntaxe);
BufferedReader nomObjet=new BufferedReader(new
InputStreamReader(nomSocket.getInputStream())) ;

import java.net.*;
import java.io.*;
public class client {
public static void main(String[] args) {
// TODO Auto-generated method stub
String rec;
try
{
Socket client=new Socket("BLESSING",6000);
BufferedReader land=new BufferedReader(new
InputStreamReader(client.getInputStream()));
rec=land.readLine();
System.out.println("Serveur dit: " + rec);
System.out.println("Ta Réaction Client: ");
}catch(Exception e){System.out.println("pas de connexion");}
}
}

1. Le Flux de Sortie

Nous avons vu la classe BufferedReader pour les entrées ; dans

cette rubrique nous allons voir le flux qui nous permet à envoyer les
informations à travers de la classe PrintStream ainsi que la méthode
getOutputStream(), dont voici comment notre serveur qui envoie le message se
présente :
import java.net.*;
import java.io.*;

Seule votre volonté vous conduira à l’Excellence. LMKanyimbu

public class serveur {
public static void main(String[] args)throws Exception {
// TODO Auto-generated method stub
ServerSocket serv=new ServerSocket(6000);
Socket client;
System.out.println("Le serveur demarrage...");
while(true)
{
client=serv.accept();
System.out.println("son addresse est " +
client.getInetAddress() );
PrintStream sortie= new
PrintStream(client.getOutputStream());
sortie.println("Bonjour client");
}
}
}

a. Combinaison des Flux(Entrée/Sortie)

Il s’agit ici de programmer de telle manière que la classe (serveur ou
client) soit à mesure d’envoyer et de recevoir les messages ; dans ce contexte
d’idées, il faut combiner tous les flux (d’entrée et de sortie). Dans ce cas voici
l’architecture de toutes les deux classes (client/serveur) :

i. Client :
Ces codes permettent au client de demander une connexion, une
fois connecté, d’échanger avec le serveur aussi longtemps qu’il y a la
connexion c'est-à-dire aussi longtemps que le serveur le voudra.
import java.net.*;//importer la librairie net pour le socket
import java.io.*;//import la io pour les entrees/sortie à l'écran
public class client {
public static void main(String[] args) {
// TODO Auto-generated method stub
String rec,mes;
try
{
//Création du socket client
Socket client=new Socket("BLESSING",6000);
//Création du flot d'entrée pour les messages serveur
BufferedReader land=new BufferedReader(new
InputStreamReader(client.getInputStream()));
//création du flot d'entrée pour les message à envoyer
par le client
BufferedReader lmk=new BufferedReader(new
InputStreamReader(System.in));
//création du flot de sortie

Seule votre volonté vous conduira à l’Excellence. LMKanyimbu

 PrintStream env=new
PrintStream(client.getOutputStream());
//tant qu'il y a la connexion
while(true)
{
//lire le messsage du serveur
rec=land.readLine();
//afficher les messages du serveur
System.out.println("Serveur dit: " + rec);
//Demander un message au client
System.out.println("Réaction Client: ");
mes=lmk.readLine();
env.println(mes);
}

}catch(Exception e){System.out.println("pas de connexion");}

}
}

ii. Serveur
Ces codes sources nous permettent premièrement de créer un
socket du serveur, le mettre à l’écoute du port 3500 ; une fois la connexion
arrivé on doit l’accepter et récupérer l’adresse IP de la machine demandant la
connexion ; en fin commencer le chat.
import java.net.*;
import java.io.*;
public class serveur {
public static void main(String[] args)throws Exception {
// les variables pour les messages d'envoie et de reception
String mesenv,mesrec;
boolean vrai=false;
ServerSocket serv=new ServerSocket(6000);
Socket client;
System.out.println("PROCESSUS DE DEMARRAGE DU
SERVEUR...");

System.out.println("=================================================
====================");
while(!vrai)
{
//accepter la connexion demandé par le client
client=serv.accept();
//afficher l'adresse IP du client
System.out.println("son addresse est " +
client.getInetAddress() );
//création du flot de sortie
PrintStream sortie= new
PrintStream(client.getOutputStream());
//création du flot d'entree pour les messages
du client

Seule votre volonté vous conduira à l’Excellence. LMKanyimbu

 BufferedReader entree=new BufferedReader(new
InputStreamReader(client.getInputStream()));
//création du flot d'entree pour les messages
à envoyer par le serveur
BufferedReader mes=new BufferedReader(new
InputStreamReader(System.in));
while(!vrai)
{
//réaction du serveur
System.out.println("Serveur Réaction:
");
mesenv=mes.readLine();
sortie.println(mesenv);
mesrec=entree.readLine();
System.out.println("Client dit: " + mesrec);
}
}
}
}

iii. Etude des cas : Serveur de calcul

Proposez une application réseau permettant à un client d’envoyer
10 cotes d’un étudiant au serveur, le serveur calcul le pourcentage et lui
envoie le résultat ainsi que la mention.

c. PROGRAMMATION RESEAU AVEC LE PROTOCOLE UDP

UDP est un protocole qui permet l’émission des paquets de données
d’une manière rapide, mais peu fiable. Il définit un paquet à envoyer ou à
recevoir par la classe DatagramPacket.
Le paquet de données émit ou reçu, contient l’adresse de
destination ainsi que la longueur du paquet en question. Etant dans la
manipulation des sockets, la classe nous permettant de manipuler les
sockets en UDP est DatagramSocket.

i. Création du Socket Serveur

Dans la création du socket serveur en UDP, il est impératif de

spécifier le port sur lequel le serveur devra commencer être à l’écoute.
DatagramSocket ser=new DatagramSocket(5000);

Seule votre volonté vous conduira à l’Excellence. LMKanyimbu

 ii. Création du Paquet

Il s’agit de créer un environnement devant stocker les données qui

devront transiter sur le réseau. La classe qui permet de créer ces
datagrammes est DatagramPacket.
Cette classe permet de manipuler des datagrammes UDP. Ils
peuvent être crées par des constructeurs utilisant un tableau d'octets (byte[])
soit pour recevoir des données, soit pour en envoyer. Pour recevoir des
données, le tableau d'octets communiqué doit être de taille suffisante pour
recevoir les données (sinon le paquet est tronqué !). Le tableau d’octets en
question est souvent du type byte.
Les données sont échangées sur le réseau par séquence d'octets
Pour transmettre une chaîne de caractères de A vers B :
1. Codage de la chaîne en octets par A
2. Transmission d'un paquet avec le tableau d'octets
3. Réception du paquet avec tableau d'octets par B
4. Décodage des octets en chaîne par B
M

La syntaxe suivante nous permet de créer un paquet de

datagrammes du serveur :
DatagramPacket y=new DatagramPacket(donneEn,0,donneEn.length);

Cette ligne d’instruction permet de créer un paquet de datagramme,

puis le premier paramètre précise le tableau d’octet qui devra stocker les
données qui doivent venir, le deuxième(0) précise que les éléments seront
prise à partir de la position zéro et enfin jusqu’à la taille du tableau lui-
même.
NB : Mais si l’on veut créer un paquet des datagrammes à envoyer, les
paramètres devront changer. Voici la syntaxe : DatagramPacket y =new
DatagramPacket(donne,donne.length,InetAddress.getLocalHost(),port);

La description des paramètres est la suivante :

1. donne : répresente le tableau d’octets (byte) ;
2. donne.length : la taille du tableau d’octets à envoyer

Seule votre volonté vous conduira à l’Excellence. LMKanyimbu

 3. InetAddress.getLocalHost() : l’adresse IP de la machine qui doit
récevoir le paquet envoyé ;
4. Port : le port sur lequel écoute l’application qui devra recevoir la
valeur envoyée.
Voici ci-dessous, l’exemple de deux applications, qui sont en train
de s’échanger les données simultanément.

a. Application I.
Jg package UDP;

import java.net.*; import java.io.*; import java.net.DatagramS ocket; import java.util.Scanner;

public class serveur {

public static void main(String[] args) throws Exception {

Scanner k=new Scanner(System.in);

DatagramSocket ser=new DatagramSocket(5000);

while(true)

System.out.print("Saisir la valeur à envoyer: "); String msgenv=k.nextLine();

byte[] valenv=msgenv.getBytes();

DatagramPacket pace=new
DatagramPacket(valenv, valenv.length,InetAddress.getLocalHost(),700);

ser.send(pace); byte[] valrec=new byte[1024];

DatagramPacket pac=new DatagramPacket(valrec, valrec.length); ser.receive(pac);

String msgrec=new String(valrec,0,valrec.length);

System.out.print("Le Message recu est: " + msgrec );

} } }

b. Application II.
public class client {

public static void main(String[] args) throws Exception {

DatagramSocket ser=new DatagramSocket(700);

Scanner k=new Scanner(System.in);

Seule votre volonté vous conduira à l’Excellence. LMKanyimbu

 while(true)

byte[] valrec=new byte[1024];

DatagramPacket pac=new DatagramPacket(valrec, valrec.length);

ser.receive(pac); String msgrec=new String(valrec,0,valrec.length);

System.out.println("Le Message recu est: " + msgrec );

System.out.print("Client réaction: "); String msgenv=k.nextLine();

byte[] valenv=msgenv.getBytes();

DatagramPacket pace=new
DatagramPacket(valenv, valenv.length,InetAddress.getLocalHost(),5000);

ser.send(pace);

} } }

IV. PROGRAMMATION PARALLELE

a. LE THREAD

i. Introduction

Un thread est une unité d'exécution faisant partie d'un programme.

Cette unité fonctionne de façon autonome et parallèlement à d'autres
threads. En fait, sur une machine mono processeur, chaque unité se voit
attribuer des intervalles de temps au cours desquels elles ont le droit
d'utiliser le processeur pour accomplir leurs traitements.
L’intérêt avantage des threads est de pouvoir répartir différents
traitements d'un même programme en plusieurs unités distinctes pour
permettre leur exécution "simultanée".
Lorsqu'on lance une application, elle s'exécute dans un flux
d'exécution appelé un thread. La classe modélisant un thread est la classe
java.lang.Thread. Il est possible d'avoir des applications où des morceaux de
code s'exécutent de façon "simultanée" dans différents threads d'exécution.
Lorsqu'on dit que des threads s'exécutent de façon simultanée, on
commet souvent un abus de langage. Si la machine n'a qu'un processeur
comme c'est encore souvent le cas, les threads se partagent ce processeur :

Seule votre volonté vous conduira à l’Excellence. LMKanyimbu

ils en disposent, chacun leur tour, pendant un court instant (quelques
millisecondes). C'est ce qui donne l'illusion du parallélisme d'exécution. La
portion de temps accordée à un thread dépend de divers facteurs dont sa
priorité qui a une valeur par défaut mais qui peut être fixée également par
programmation.

1. Les méthodes d’un Thread

Les méthodes du thread ici, consistent en différentes opérations
que l’on peut effectuer sur un thread ; nous trouvons ici :
- setName() : donne le nom à un Thread ;
- getName() : récupère le nom d’un Thread ;
- start() : lance l’exécution d’un Thread;
- run() : méthode exécutée automatiquement après que la méthode start
précédente ait été exécute;
- currentThread(): donne le thread courant
- sleep(n) : arrête l’exécution d’un Thread pendant n milliseconds
Exemple:
Regardons une première application mettant en évidence l'existence
d'un thread principal d'exécution, celui dans lequel s'exécute la fonction main
d'une classe ; permet d’afficher l’heure système.
import java.util.Calendar;
public class HORLOGE {
public static void main(String[] args) throws Exception{
// TODO Auto-generated method stub
//création du tread lmk qui prend le tread courant
Thread lmk=Thread.currentThread();
//affichage du nom du thread
System.out.println("le Thread courant s'appel: " + lmk.getName());
//changer le nom du thread (main) en beneland
lmk.setName("BENELAND");
//affichage du nom du thread
System.out.println("le thread a changé de nom, il devient: " +
lmk.getName());
//Tant que vrai
while(true){
//on crée une variable chaine de caractères "Heure"
String heure;
//creation d'un objet Calendrier, permet de prendre les
différents instances de celui-ci
Calendar heur=Calendar.getInstance();
//la variable heure prendre l'heure, les minutes et les
sécondes les tous concaténer

Seule votre volonté vous conduira à l’Excellence. LMKanyimbu

 heure=heur.get(Calendar.HOUR_OF_DAY) + ":" +
heur.get(Calendar.MINUTE) + ":" + heur.get(Calendar.SECOND);
//affichage de l'heure
System.out.println(heure);
//arret de momentané du thread pendant 1000 millisecondes
Thread.sleep(1000);
}}}

A. SERVEUR M ULTI-CLIENT EN TCP

L’objectif dans cette partie du cours est de pouvoir programmer un
serveur capable d’être à l’écoute et de servir plusieurs clients à la fois. Dans
la section précédente, nous avons programmé un serveur mono-client client
ce qui implique que le serveur ne pouvez pas servir plusieurs clients.
Pour que cela soit possible, nous devrions inclure le thread en vue
d’avoir deux tâches qui s’exécute en parallèle ; l’une qui doit se charger à être
à l’écoute des demandes de connexion de clients, et l’autre qui doit servir les
clients ; l’architecture devient alors la suivante :

Client 1
SERVEUR Requête client
Tâche1

GESTION DES
CONNEXIONS CLIENTS Requête client Client 2

Requête client
Tâche2

GESTION DES Client 3

PARTAGES
D’INFORMATIONS

Dans ce cas le thread doit intervenir ; donc nous aurons une classe
qui doit s’occuper des demandes de connexion et l’autre qui s’occupera des
échanges des informations entre le serveur et les clients.
L’architecture du serveur pour toutes les deux classes devient alors
la suivante :

Seule votre volonté vous conduira à l’Excellence. LMKanyimbu

Tache1 :
Cette classe se charge tout simplement d’être à l’écoute de
demandes de connexion et d’accepter les connexions et de transmettre les
connexions à la classe service qui s’occupe de la tâche 2.

import java.net.*;
public class serveurb {
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
//creation du socket du serveur
ServerSocket serveur=new ServerSocket(3000);
//creation du socket du client
Socket client;
//affichage du message de lancement
System.out.println("Lancement du serveur....." );
//tantqu’il les demandes
while(true){
//accepter les connexions
client=serveur.accept();
//Transmettre les socket à la classe service
service ben=new service(client);
//lancer
ben.start();
}}}

Tâche 2 :
Cette dernière classe se base sur l’échange d’information entre le
client et le serveur ; elle échange les informations sur base du socket du
client qu’on a accepté la demande de connexion. Son architecture est la
suivante :
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.*;
import java.util.Scanner;
public class service extends Thread {
//creation des variables des variables de classes
Socket ben; String mesrec,mesenv;
//creation d’un constructeur
public service(Socket client){
//recuperation du socket client
this.ben = client;
}
//construction de la méthode run() pour l’exécution des tâches
public void run(){
try{
//creation de l’objet d’entrée

Seule votre volonté vous conduira à l’Excellence. LMKanyimbu

 BufferedReader in=new BufferedReader(new
InputStreamReader(ben.getInputStream()));
//creation de l’objet de sortie
PrintStream out=new PrintStream(ben.getOutputStream()); Scanner
mes=new Scanner(System.in);
//afficher l’adresse IP du c lient récemment connecté
System.out.println("Le client est à l'adresse: "
+ben.getInetAddress());
//tant qu’il y a la connexion
while(true){
//demander le message au serveur
System.out.print("Serveur Ton MSG: ");
mesenv=mes.nextLine();
//envoyer le message du serveur
out.println(mesenv);
//recevoir le message du client
mesrec=in.readLine();
//afficher le message du client
System.out.println("Client dit : " + mesrec);
}
}catch(Exception e){
System.out.println("Erreur: " + e);
}
}

Seule votre volonté vous conduira à l’Excellence. LMKanyimbu

 BIBLIOGRAPHIE

1. Michel Chilowicz, Programmation réseau en Java, 2014

2. Etienne Duris, Ip UDP TCP, 2009
3. Arnaud Labourel, Programmation Parallèle et distribuée,2012
4. Apprentissage du langage JAVA par Serge Tahé
5. Thinking in JAVA, 2nd Edition, Revision 11 par Bruce Eckel
6. Jean Michel DOUDOUX, Développons JAVA, 2013
7. Programmer en Java de Claude Delannoy aux éditions Eyrolles
8. Java pour les enfants, les parents et les grands parents par Yakov FAIN
9. Landry KANYIMBU, Cours de langage de programmation III,
UCSV,2013 ;
10. www.developpez.com;
11. www.btsig.com

Seule votre volonté vous conduira à l’Excellence. LMKanyimbu