Cours Complet : Java et les Serveurs

Introduction

Bienvenue dans ce cours complet sur Java et les serveurs. Ce guide est conçu pour
vous fournir une compréhension approfondie des concepts fondamentaux de Java, de
la programmation réseau, des serveurs web, des frameworks d'entreprise, et du
déploiement d'applications. Que vous soyez un développeur débutant souhaitant
explorer le monde de Java ou un professionnel cherchant à renforcer ses compétences
en matière de serveurs, ce cours vous fournira les connaissances et les outils
nécessaires pour maîtriser ces technologies cruciales.

Java est l'un des langages de programmation les plus populaires et les plus
polyvalents au monde. Connu pour sa portabilité ("Write Once, Run Anywhere"), sa
robustesse et sa vaste communauté, Java est la pierre angulaire de nombreuses
applications d'entreprise, de systèmes Android, de solutions Big Data et, bien sûr,
d'applications côté serveur. La capacité de Java à gérer des charges de travail
importantes et à s'intégrer facilement avec d'autres systèmes en fait un choix
privilégié pour le développement de serveurs.

Les serveurs, quant à eux, sont le cœur de l'internet moderne. Ils hébergent des sites
web, des applications, des bases de données et fournissent des services essentiels qui
permettent la communication et l'échange d'informations à l'échelle mondiale.
Comprendre comment Java interagit avec les serveurs est indispensable pour
quiconque souhaite développer des applications web robustes, évolutives et
performantes.

Ce cours est structuré pour vous guider pas à pas, des bases de Java aux concepts
avancés de déploiement sur serveur. Nous aborderons les sujets suivants :

1. Les Fondamentaux de Java : Une révision des concepts clés du langage, de la

syntaxe de base à la programmation orientée objet.

2. Concepts de Réseau et Serveurs : Comprendre comment les applications

communiquent sur un réseau et le rôle des serveurs.
 3. Serveurs Web Java (Tomcat, Jetty) : Exploration des serveurs d'applications les
plus utilisés pour héberger des applications Java.

4. Frameworks Web Java (Spring Boot) : Apprendre à construire des applications

web modernes et efficaces avec Spring Boot.

5. Bases de Données et JDBC : Interagir avec les bases de données pour stocker et
récupérer des informations.

6. Déploiement d'Applications Java sur Serveur : Les meilleures pratiques pour

déployer vos applications en production.

Chaque section sera accompagnée d'explications claires, d'exemples de code et de

conseils pratiques pour vous aider à assimiler les concepts. Notre objectif est de vous
donner une base solide et de vous permettre de développer et de déployer vos
propres applications Java côté serveur en toute confiance.

Préparez-vous à plonger dans le monde passionnant de Java et des serveurs !

1. Les Fondamentaux de Java

Pour bien comprendre le développement d'applications côté serveur avec Java, il est
essentiel de maîtriser les bases du langage. Cette section vous rafraîchira la mémoire
sur les concepts clés, de la syntaxe de base à la programmation orientée objet (POO).

1.1. Syntaxe de Base et Types de Données

Java est un langage fortement typé, ce qui signifie que chaque variable doit avoir un
type de données défini. Voici les types de données primitifs les plus courants :

Entiers : byte , short , int , long

Décimaux : float , double

Caractères : char

Booléens : boolean

Exemple de déclaration de variables :

 int age = 30;
double prix = 99.99;
char initiale = 'J';
boolean estActif = true;
String nom = "Java"; // String est une classe, pas un type primitif

Les commentaires en Java peuvent être sur une seule ligne ( // ) ou sur plusieurs
lignes ( /* ... */ ).

1.2. Opérateurs

Java supporte une gamme complète d'opérateurs :

Arithmétiques : + , - , * , / , %

Comparaison : == , != , < , > , <= , >=

Logiques : && (ET), || (OU), ! (NON)

Affectation : = , += , -= , *= etc.

1.3. Structures de Contrôle

Les structures de contrôle permettent de diriger le flux d'exécution du programme.

Conditions ( if , else if , else ) :

java if (age >= 18) { [Link]("Majeur"); } else {

[Link]("Mineur"); }

Boucles ( for , while , do-while , for-each ) :

```java for (int i = 0; i < 5; i++) { [Link](i); }

int count = 0; while (count < 3) { [Link]("Compteur : " + count);

count++; } ```

Switch :

java int jour = 3; switch (jour) { case 1:

[Link]("Lundi"); break; case 2:
[Link]("Mardi"); break; default:
[Link]("Autre jour"); }
1.4. Méthodes

Les méthodes sont des blocs de code qui effectuent une tâche spécifique. Elles
peuvent prendre des paramètres et retourner une valeur.

public class Calculatrice {

public int additionner(int a, int b) {
return a + b;
}

public static void main(String[] args) {

Calculatrice calc = new Calculatrice();
int resultat = [Link](5, 3);
[Link]("Le résultat est : " + resultat);
}
}

1.5. Programmation Orientée Objet (POO)

La POO est un paradigme de programmation basé sur le concept d'"objets", qui

peuvent contenir des données (attributs) et du code (méthodes). Les quatre piliers de
la POO sont :

Encapsulation : Regrouper les données et les méthodes qui les manipulent au

sein d'une même unité (classe) et masquer les détails d'implémentation.
Utilisation de modificateurs d'accès ( public , private , protected ).

```java public class Personne { private String nom; private int age;
 public Personne(String nom, int age) {
[Link] = nom;
[Link] = age;
}

public String getNom() {

return nom;
}

public void setNom(String nom) {

[Link] = nom;
}

public int getAge() {

return age;
}

public void setAge(int age) {

if (age > 0) {
[Link] = age;
}
}

} ```

Héritage : Permettre à une classe (sous-classe) d'hériter des propriétés et des

comportements d'une autre classe (super-classe), favorisant la réutilisation du
code. Le mot-clé extends est utilisé.

```java public class Etudiant extends Personne { private String numeroEtudiant;

public Etudiant(String nom, int age, String numeroEtudiant) {

super(nom, age);
[Link] = numeroEtudiant;
}

public String getNumeroEtudiant() {

return numeroEtudiant;
}

} ```

Polymorphisme : La capacité d'un objet à prendre plusieurs formes. Cela se

manifeste par la surcharge (méthodes avec le même nom mais des signatures
différentes) et la redéfinition (méthodes de la super-classe redéfinies dans la
sous-classe).

```java public class Animal { public void son() { [Link]("L'animal fait

un son"); } }
public class Chien extends Animal { @Override public void son() {
[Link]("Le chien aboie"); } }

public class Chat extends Animal { @Override public void son() {

[Link]("Le chat miaule"); } }

// Utilisation du polymorphisme Animal monAnimal = new Chien();

[Link](); // Affiche "Le chien aboie" monAnimal = new Chat();
[Link](); // Affiche "Le chat miaule" ```

Abstraction : Masquer les détails d'implémentation et montrer uniquement les

fonctionnalités essentielles. Réalisée via les classes abstraites et les interfaces.

Classes Abstraites : Ne peuvent pas être instanciées directement et

peuvent contenir des méthodes abstraites (sans implémentation) et non
abstraites.

```java public abstract class Forme { public abstract double

calculerSurface(); public void afficherMessage() { [Link]("Ceci
est une forme."); } }

public class Cercle extends Forme { private double rayon;

public Cercle(double rayon) {

[Link] = rayon;
}

@Override
public double calculerSurface() {
return [Link] * rayon * rayon;
}

} ```

Interfaces : Un contrat qui spécifie un ensemble de méthodes que les

classes implémentant cette interface doivent fournir. Elles ne peuvent
contenir que des signatures de méthodes (avant Java 8) ou des méthodes
par défaut et statiques (depuis Java 8).

```java public interface Dessinable { void dessiner(); default void

messageParDefaut() { [Link]("Objet dessinable."); } }

public class Carre implements Dessinable { @Override public void

dessiner() { [Link]("Dessine un carré"); } } ```
1.6. Gestion des Exceptions

Les exceptions sont des événements qui interrompent le flux normal d'un programme.
Java utilise les blocs try-catch-finally pour les gérer.

try {
int[] nombres = {1, 2, 3};
[Link](nombres[10]); // Accès hors limites
} catch (ArrayIndexOutOfBoundsException e) {
[Link]("Erreur : Index hors limites ! " + [Link]());
} finally {
[Link]("Ce bloc s'exécute toujours.");
}

1.7. Collections Framework

Le Java Collections Framework fournit une architecture unifiée pour représenter et

manipuler des collections. Les interfaces principales sont List , Set , et Map .

List (ordonnée, permet les doublons) : ArrayList , LinkedList

Set (non ordonnée, pas de doublons) : HashSet , TreeSet

Map (clé-valeur, clés uniques) : HashMap , TreeMap

import [Link];
import [Link];
import [Link];
import [Link];

public class CollectionsExemple {

public static void main(String[] args) {
// List
List<String> noms = new ArrayList<>();
[Link]("Alice");
[Link]("Bob");
[Link]("Liste de noms : " + noms);

// Map
Map<String, Integer> ages = new HashMap<>();
[Link]("Alice", 30);
[Link]("Bob", 25);
[Link]("Map d'âges : " + ages);
}
}

Cette section a couvert les bases essentielles de Java. Une bonne maîtrise de ces
concepts est cruciale avant de plonger dans le développement côté serveur.
2. Concepts de Réseau et Serveurs

Pour comprendre comment les applications Java interagissent avec les serveurs, il est
fondamental de saisir les concepts de base du réseau et le rôle des serveurs dans
l'écosystème web. Cette section vous fournira les connaissances nécessaires pour
appréhender la communication client-serveur.

2.1. Principes Fondamentaux du Réseau

Le réseau est un ensemble d'ordinateurs et de périphériques connectés entre eux pour

partager des ressources et des informations. La communication sur Internet repose sur
un modèle en couches appelé modèle TCP/IP (Transmission Control Protocol/Internet
Protocol), qui est une implémentation pratique du modèle OSI (Open Systems
Interconnection).

Les couches principales du modèle TCP/IP sont :

Couche Application : Gère les protocoles de haut niveau comme HTTP, FTP,
SMTP, DNS. C'est à ce niveau que les applications interagissent avec le réseau.

Couche Transport : Assure la communication de bout en bout entre les

applications. Les protocoles clés sont TCP (Transmission Control Protocol) pour
une communication fiable et orientée connexion, et UDP (User Datagram
Protocol) pour une communication rapide et sans connexion.

Couche Internet : Gère l'adressage logique et le routage des paquets de

données. Le protocole principal est IP (Internet Protocol).

Couche Accès Réseau : Gère l'accès physique au support de transmission

(Ethernet, Wi-Fi, etc.) et l'adressage physique (adresses MAC).

Adresses IP et Ports

Chaque appareil connecté à un réseau TCP/IP possède une adresse IP unique (par
exemple, [Link] pour IPv4 ou 2001:0db8::1 pour IPv6). Cette adresse permet
d'identifier l'appareil sur le réseau.

Les ports sont des numéros logiques (de 0 à 65535) qui identifient des applications ou
des services spécifiques sur un appareil. Par exemple, le port 80 est généralement
utilisé pour le trafic HTTP, le port 443 pour HTTPS, et le port 8080 est souvent utilisé
pour les serveurs d'applications Java comme Tomcat.
La combinaison d'une adresse IP et d'un numéro de port ( IP:Port ) forme une socket,
qui est un point de terminaison pour la communication réseau.

2.2. Le Modèle Client-Serveur

Le modèle client-serveur est une architecture de communication distribuée où les

tâches sont réparties entre des fournisseurs de services (serveurs) et des demandeurs
de services (clients).

Client : Une application ou un programme qui demande un service à un serveur.

Par exemple, un navigateur web est un client qui demande des pages web à un
serveur web.

Serveur : Un programme ou un ordinateur qui fournit un service à un client. Il

écoute les requêtes des clients sur un port spécifique, traite ces requêtes et
renvoie une réponse.

Processus de communication client-serveur (simplifié) :

1. Le client établit une connexion avec le serveur sur une adresse IP et un port
spécifiques.

2. Le client envoie une requête au serveur.

3. Le serveur reçoit la requête, la traite (par exemple, récupère des données,

exécute une logique métier).

4. Le serveur envoie une réponse au client.

5. Le client reçoit la réponse et la traite (par exemple, affiche la page web).

6. La connexion peut être maintenue pour d'autres échanges ou fermée.

2.3. Protocoles Clés pour le Web

Plusieurs protocoles sont essentiels pour la communication web :

HTTP (Hypertext Transfer Protocol) : Le protocole fondamental pour la

transmission de documents hypermédia (pages web) sur le World Wide Web. Il
est sans état (stateless), ce qui signifie que chaque requête est traitée
indépendamment des précédentes.
Méthodes HTTP courantes : GET (récupérer des données), POST (envoyer
des données pour créer une ressource), PUT (envoyer des données pour
 mettre à jour une ressource), DELETE (supprimer une ressource).

Codes de statut HTTP : Indiquent le résultat d'une requête (par exemple,

200 OK , 404 Not Found , 500 Internal Server Error ).

HTTPS (Hypertext Transfer Protocol Secure) : La version sécurisée de HTTP, qui

utilise SSL/TLS pour chiffrer la communication entre le client et le serveur,
garantissant la confidentialité et l'intégrité des données.

DNS (Domain Name System) : Un système distribué qui traduit les noms de
domaine lisibles par l'homme (par exemple, [Link] ) en adresses IP
numériques, que les ordinateurs utilisent pour s'identifier sur le réseau.

2.4. Types de Serveurs

Dans le contexte du développement Java, nous rencontrons principalement les types

de serveurs suivants :

Serveurs Web : Servent du contenu statique (fichiers HTML, CSS, JavaScript,

images) et peuvent déléguer les requêtes dynamiques à des serveurs
d'applications. Exemples : Apache HTTP Server, Nginx.

Serveurs d'Applications (Application Servers) : Exécutent la logique métier des

applications dynamiques. Pour Java, ce sont des conteneurs de servlets/JSP ou
des serveurs Java EE/Jakarta EE. Ils fournissent un environnement d'exécution
pour les composants Java (Servlets, JSP, EJB, etc.). Exemples : Apache Tomcat,
Jetty, WildFly, GlassFish.

Serveurs de Bases de Données : Stockent et gèrent les données. Ils répondent

aux requêtes des applications pour stocker, récupérer, mettre à jour ou
supprimer des données. Exemples : MySQL, PostgreSQL, Oracle, SQL Server.

2.5. Sockets en Java

Java fournit des API pour la programmation réseau de bas niveau via les sockets. Cela
permet de créer des applications client-serveur personnalisées.

Exemple de Serveur Socket simple en Java :

 import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

public class SimpleSocketServer {

public static void main(String[] args) {
int port = 12345;
try (ServerSocket serverSocket = new ServerSocket(port)) {
[Link]("Serveur démarré sur le port " + port);
while (true) {
Socket clientSocket = [Link](); // Attend une
connexion client
[Link]("Client connecté : " +
[Link]().getHostAddress());

// Flux d'entrée/sortie pour communiquer avec le client

BufferedReader in = new BufferedReader(new
InputStreamReader([Link]()));
PrintWriter out = new
PrintWriter([Link](), true);

String inputLine;
while ((inputLine = [Link]()) != null) {
[Link]("Reçu du client : " + inputLine);
[Link]("Serveur : Vous avez dit \"" + inputLine +
"\"");
if ([Link]("bye")) {
break;
}
}
[Link]();
[Link]("Client déconnecté.");
}
} catch (IOException e) {
[Link]("Erreur serveur : " + [Link]());
}
}
}

Exemple de Client Socket simple en Java :

 import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

public class SimpleSocketClient {

public static void main(String[] args) {
String host = "localhost";
int port = 12345;
try (Socket socket = new Socket(host, port)) {
// Flux d'entrée/sortie pour communiquer avec le serveur
PrintWriter out = new PrintWriter([Link](), true);
BufferedReader in = new BufferedReader(new
InputStreamReader([Link]()));
BufferedReader stdIn = new BufferedReader(new
InputStreamReader([Link]));

String userInput;
[Link]("Connecté au serveur. Tapez 'bye' pour
quitter.");
while ((userInput = [Link]()) != null) {
[Link](userInput); // Envoie la saisie de l'utilisateur au
serveur
[Link]([Link]()); // Affiche la réponse du
serveur
if ([Link]("bye")) {
break;
}
}
} catch (IOException e) {
[Link]("Erreur client : " + [Link]());
}
}
}

Ces exemples illustrent la communication de base via les sockets. Cependant, pour le
développement web moderne, nous utilisons généralement des abstractions de plus
haut niveau fournies par les serveurs d'applications et les frameworks, ce que nous
verrons dans les sections suivantes.

3. Serveurs Web Java (Tomcat, Jetty)

Les serveurs web Java, plus précisément les conteneurs de servlets, sont des
composants essentiels pour exécuter des applications web basées sur Java. Ils
fournissent un environnement d'exécution pour les Servlets et les JavaServer Pages
(JSP), qui sont les technologies fondamentales pour le développement web en Java.
Les plus populaires sont Apache Tomcat et Eclipse Jetty.
3.1. Qu'est-ce qu'un Conteneur de Servlets ?

Un conteneur de servlets est un programme qui gère le cycle de vie des servlets,
mappe les URL aux servlets, et gère les requêtes et les réponses HTTP. Il implémente la
spécification Java Servlet API et JSP. En d'autres termes, c'est l'environnement qui
permet à votre code Java web de s'exécuter et de répondre aux requêtes des
navigateurs.

3.2. Apache Tomcat

Apache Tomcat est un serveur web open source et un conteneur de servlets développé
par la Fondation Apache. C'est l'un des serveurs d'applications Java les plus utilisés
pour les applications web légères et de taille moyenne. Il est léger, facile à configurer
et très performant.

Installation et Démarrage de Tomcat

1. Téléchargement : Téléchargez la dernière version stable de Tomcat depuis le site

officiel d'Apache Tomcat ([Link]). Choisissez la version binaire (zip
ou [Link]).

2. Extraction : Extrayez l'archive dans un répertoire de votre choix (par exemple,

/opt/tomcat ou C:\tomcat ). Ce répertoire sera votre CATALINA_HOME .

3. Variables d'environnement : Assurez-vous que JAVA_HOME est configuré et

pointe vers votre installation JDK.

4. Démarrage :
Linux/macOS : Ouvrez un terminal, naviguez vers le répertoire bin de
Tomcat ( cd /opt/tomcat/bin ) et exécutez ./[Link] .

Windows : Ouvrez l'invite de commande, naviguez vers le répertoire bin

de Tomcat ( cd C:\tomcat\bin ) et exécutez [Link] .

Après le démarrage, vous devriez pouvoir accéder à l'interface par défaut de Tomcat
via votre navigateur à l'adresse [Link] .

Structure des Répertoires de Tomcat

bin : Scripts de démarrage et d'arrêt ( [Link] , [Link] ,

[Link] ).
 conf : Fichiers de configuration (par exemple, [Link] pour la configuration
du serveur, [Link] pour la configuration globale des applications web,
[Link] ).

lib : Bibliothèques partagées par toutes les applications déployées sur Tomcat.

logs : Fichiers journaux de Tomcat.

webapps : Répertoire où vous déployez vos applications web (fichiers .war ).

Chaque sous-répertoire représente une application.

work : Répertoire temporaire utilisé par Tomcat pour les fichiers compilés (par
exemple, les JSP compilées).

Déploiement d'une Application Web (WAR)

Une application web Java est généralement packagée dans un fichier .war (Web
Application Archive). Pour déployer un .war sur Tomcat :

1. Copiez votre fichier .war (par exemple, [Link] ) dans le répertoire

webapps de Tomcat.

2. Tomcat détectera automatiquement le nouveau fichier .war , le décompressera

et le déploiera. L'application sera alors accessible à
[Link] .

Configuration de Base ( [Link] )

Le fichier conf/[Link] est le fichier de configuration principal de Tomcat. Vous

pouvez y modifier le port HTTP (par défaut 8080), configurer des hôtes virtuels, ou
ajouter des connecteurs. Voici un extrait typique :

<Connector port="8080" protocol="HTTP/1.1"

connectionTimeout="20000"
redirectPort="8443" />

Pour changer le port HTTP de 8080 à 80, il suffit de modifier l'attribut port du
connecteur.
3.3. Eclipse Jetty

Eclipse Jetty est un autre conteneur de servlets open source, souvent utilisé pour les
applications embarquées ou les microservices en raison de sa légèreté et de sa
flexibilité. Contrairement à Tomcat qui est un serveur d'applications autonome, Jetty
peut être facilement intégré dans une application Java.

Avantages de Jetty

Légèreté : Moins de consommation de ressources que Tomcat.

Embarquable : Peut être démarré directement à partir du code Java, ce qui est
idéal pour les microservices ou les applications auto-exécutables.

Flexibilité : Permet de choisir précisément les composants à inclure.

Exemple d'Utilisation de Jetty Embarqué

Pour utiliser Jetty de manière embarquée, vous devez ajouter les dépendances Maven
(ou Gradle) à votre projet :

<dependency>
<groupId>[Link]</groupId>
<artifactId>jetty-server</artifactId>
<version>9.4.51.v20230914</version>
</dependency>
<dependency>
<groupId>[Link]</groupId>
<artifactId>jetty-servlet</artifactId>
<version>9.4.51.v20230914</version>
</dependency>

Ensuite, vous pouvez démarrer un serveur Jetty directement depuis votre code Java :
 import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

public class EmbeddedJettyExample {

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

Server server = new Server(8080);

ServletContextHandler context = new

ServletContextHandler([Link]);
[Link]("/");
[Link](context);

[Link](new ServletHolder(new HelloServlet()), "/hello");

[Link]();
[Link]();
}

public static class HelloServlet extends HttpServlet {

@Override
protected void doGet(HttpServletRequest request, HttpServletResponse
response) throws ServletException, IOException {
[Link]("text/html");
[Link](HttpServletResponse.SC_OK);
[Link]().println("<h1>Bonjour depuis Jetty !</h1>");
}
}
}

Cet exemple crée un serveur Jetty sur le port 8080 et expose une servlet simple à l'URL
/hello . L'approche embarquée est particulièrement utile pour les applications qui
n'ont pas besoin d'un serveur d'applications complet ou pour les tests
unitaires/d'intégration.

3.4. Servlets et JSP (JavaServer Pages)

Servlets : Classes Java qui étendent HttpServlet et traitent les requêtes HTTP.
Elles sont le cœur de la logique métier côté serveur.

```java import [Link]; import

[Link]; import [Link];
import [Link]; import
[Link]; import [Link]; import
[Link];
 @WebServlet("/bonjour") public class BonjourServlet extends HttpServlet {
protected void doGet(HttpServletRequest request, HttpServletResponse
response) throws ServletException, IOException {
[Link]("text/html"); PrintWriter out = [Link]();
[Link](""); [Link]("

Bonjour, " +
[Link]("nom") + "!
"); [Link](""); } } ```

JSP (JavaServer Pages) : Technologie qui permet d'intégrer du code Java

directement dans des pages HTML. Elles sont compilées en servlets par le
conteneur. Les JSP sont souvent utilisées pour la couche de présentation.

jsp <%@ page language="java" contentType="text/html; charset=UTF-8"

pageEncoding="UTF-8"%> <!DOCTYPE html> <html> <head> <title>Ma Page
JSP</title> </head> <body> <h1>Bienvenue sur ma page JSP !</h1> <%
String message = "Ceci est un message de la JSP."; %> <p><%= message
%></p> <p>La date actuelle est : <%= new [Link]() %></p>
</body> </html>

Bien que les Servlets et JSP soient les fondations, les frameworks modernes comme
Spring Boot (que nous verrons ensuite) offrent des approches plus structurées et
productives pour le développement d'applications web Java.

4. Frameworks Web Java (Spring Boot)

Alors que les Servlets et JSP fournissent les fondations du développement web Java,
les frameworks modernes comme Spring Boot simplifient grandement la création
d'applications robustes et évolutives. Spring Boot est devenu le standard de facto pour
le développement d'applications Java d'entreprise, grâce à sa philosophie de
"convention plutôt que configuration" et à son écosystème riche.
4.1. Introduction à Spring et Spring Boot

Spring Framework est un framework open source complet pour le développement

d'applications Java. Il fournit une infrastructure pour le développement d'applications
d'entreprise, en se concentrant sur l'inversion de contrôle (IoC) et l'injection de
dépendances (DI).

Spring Boot est une extension de Spring Framework qui vise à simplifier le processus
de démarrage et de développement d'applications Spring. Il offre :

Configuration automatique : Spring Boot configure automatiquement votre

application en fonction des dépendances que vous ajoutez.

Serveur embarqué : Il inclut des serveurs comme Tomcat, Jetty ou Undertow, ce

qui permet de créer des applications auto-exécutables (fichiers JAR exécutables).

Dépendances de démarrage (Starters) : Des ensembles de dépendances

préconfigurées pour des fonctionnalités courantes (web, données, sécurité, etc.).

Actuator : Des fonctionnalités prêtes à l'emploi pour la surveillance et la gestion

de votre application en production.

4.2. Création d'une Application Spring Boot Simple

La manière la plus simple de créer un projet Spring Boot est d'utiliser Spring Initializr
([Link]). C'est un outil web qui génère la structure de base de votre projet avec
les dépendances nécessaires.

Étapes pour créer une application web RESTful simple :

1. Allez sur [Link].

2. Configurez votre projet :

Project : Maven Project

Language : Java

Spring Boot : Choisissez la dernière version stable.

Project Metadata : Remplissez les champs Group , Artifact , Name ,

Package name .

Dependencies : Ajoutez Spring Web (pour créer des applications web et

RESTful) et Spring Boot DevTools (pour le rechargement à chaud).
 3. Cliquez sur Generate pour télécharger le projet (un fichier .zip ).

4. Décompressez le fichier et importez le projet dans votre IDE (IntelliJ IDEA,

Eclipse, VS Code).

Structure de Projet Typique

Après l'importation, vous verrez une structure similaire à celle-ci :

monprojetspringboot/
├── src/
│ ├── main/
│ │ ├── java/
│ │ │ └── com/
│ │ │ └── example/
│ │ │ └── monprojetspringboot/
│ │ │ └── [Link]
│ │ └── resources/
│ │ ├── [Link]
│ │ ├── static/
│ │ └── templates/
│ └── test/
│ └── java/
│ └── com/
│ └── example/
│ └── monprojetspringboot/
│ └── [Link]
├── [Link]
└── .gitignore

[Link] : La classe principale qui lance

l'application Spring Boot.

[Link] (ou [Link] ) : Fichier de configuration pour

l'application.

static : Pour les ressources statiques (HTML, CSS, JS, images).

templates : Pour les templates de vues (Thymeleaf, FreeMarker, JSP).

[Link] : Fichier de configuration Maven pour les dépendances et le build.

Création d'un Contrôleur REST

Un contrôleur (Controller) dans Spring gère les requêtes HTTP. Pour créer une API
REST simple, nous utilisons l'annotation @RestController .
 package [Link];

import [Link];
import [Link];
import [Link];

@RestController
public class HelloController {

@GetMapping("/hello")
public String hello(@RequestParam(value = "name", defaultValue = "World")
String name) {
return [Link]("Hello, %s!", name);
}
}

@RestController : Combine @Controller et @ResponseBody , indiquant que la

classe est un contrôleur et que les valeurs de retour des méthodes doivent être
directement liées au corps de la réponse HTTP.

@GetMapping("/hello") : Mappe la méthode hello aux requêtes HTTP GET sur

le chemin /hello .

@RequestParam : Permet de lier un paramètre de requête URL ( ?name=... ) à un

argument de méthode. defaultValue fournit une valeur par défaut si le
paramètre n'est pas présent.

Exécution de l'Application

Vous pouvez exécuter l'application de plusieurs manières :

1. Depuis l'IDE : Exécutez la méthode main de la classe

[Link] .

2. Depuis le terminal (Maven) : Naviguez vers le répertoire racine du projet et

exécutez mvn spring-boot:run .

Une fois l'application démarrée (généralement sur le port 8080), vous pouvez accéder
à votre API via [Link] ou [Link]
name=Manus .

4.3. Concepts Clés de Spring Boot

Inversion de Contrôle (IoC) et Injection de Dépendances (DI) : Le conteneur

Spring gère la création et la liaison des objets (beans), au lieu que l'application
les crée directement. Cela réduit le couplage et facilite les tests.

```java // Exemple simple d'injection de dépendances @Service public class

MonService { public String getMessage() { return "Message du service"; } }

@RestController public class MonController { private final MonService

monService; // Dépendance

public MonController(MonService monService) { // Injection via le

constructeur
[Link] = monService;
}

@GetMapping("/message")
public String getServiceMessage() {
return [Link]();
}

} ```

Annotations : Spring Boot utilise intensivement les annotations pour la

configuration et la définition des composants ( @Component , @Service ,
@Repository , @Controller , @Autowired , etc.).

Profils (Profiles) : Permettent de définir des configurations spécifiques pour

différents environnements (développement, test, production). Par exemple, vous
pouvez avoir [Link] et [Link] .

Gestion des Données : Spring Data simplifie l'accès aux bases de données
(JPA/Hibernate pour les bases de données relationnelles, Spring Data MongoDB,
etc.).

```java import [Link]; import

[Link];

// Une entité JPA simple @Entity public class Produit { @Id

@GeneratedValue(strategy = [Link]) private Long id; private
String nom; private double prix; // Getters et Setters }

// Un repository Spring Data JPA @Repository public interface ProduitRepository

extends JpaRepository { // Spring Data génère automatiquement les méthodes
CRUD et de requête List findByNomContaining(String nom); } ```
Spring Boot est un outil puissant qui permet de construire rapidement des
applications Java robustes et prêtes pour la production. Il gère une grande partie de la
complexité sous-jacente, permettant aux développeurs de se concentrer sur la logique
métier. Dans la prochaine section, nous verrons comment interagir avec les bases de
données depuis Java.

5. Bases de Données et JDBC

La plupart des applications web interagissent avec des bases de données pour stocker
et récupérer des informations. Java fournit une API standard pour la connectivité aux
bases de données appelée JDBC (Java Database Connectivity). Cette section couvrira
les bases de JDBC et comment l'utiliser pour interagir avec une base de données.

5.1. Introduction à JDBC

JDBC est une API Java qui permet aux applications Java de se connecter à divers
systèmes de gestion de bases de données (SGBD) tels que MySQL, PostgreSQL, Oracle,
SQL Server, etc. Elle fournit un ensemble d'interfaces et de classes pour :

Établir une connexion avec une base de données.

Envoyer des requêtes SQL (Structured Query Language).

Traiter les résultats retournés par la base de données.

Le fonctionnement de JDBC repose sur des pilotes JDBC (JDBC drivers), qui sont des
implémentations spécifiques à chaque SGBD. Par exemple, pour se connecter à une
base de données MySQL, vous aurez besoin du pilote JDBC pour MySQL (Connector/J).

5.2. Étapes de Base pour Utiliser JDBC

L'utilisation de JDBC suit généralement ces étapes :

1. Charger le pilote JDBC : Le pilote doit être chargé en mémoire pour que
l'application puisse l'utiliser. Pour les versions modernes de Java (Java 6 et plus),
cela se fait automatiquement si le pilote est dans le classpath.

2. Établir une connexion : Utiliser la classe DriverManager pour obtenir une

connexion à la base de données en fournissant l'URL de la base de données, le
nom d'utilisateur et le mot de passe.
 3. Créer une instruction (Statement) : Une fois la connexion établie, vous pouvez
créer un objet Statement ou PreparedStatement pour exécuter des requêtes
SQL.

4. Exécuter la requête : Exécuter la requête SQL (par exemple, SELECT , INSERT ,

UPDATE , DELETE ).

5. Traiter les résultats (ResultSet) : Pour les requêtes SELECT , les résultats sont
retournés dans un objet ResultSet , que vous pouvez parcourir pour récupérer
les données.

6. Fermer les ressources : Il est crucial de fermer la ResultSet , le Statement et la

Connection pour libérer les ressources de la base de données.

5.3. Exemple JDBC : Connexion et Requête SELECT

Pour cet exemple, nous allons supposer que vous avez une base de données MySQL
nommée ma_base_de_donnees avec une table produits :

CREATE TABLE produits (

id INT AUTO_INCREMENT PRIMARY KEY,
nom VARCHAR(255) NOT NULL,
prix DOUBLE NOT NULL
);

INSERT INTO produits (nom, prix) VALUES ("Ordinateur portable", 1200.00);

INSERT INTO produits (nom, prix) VALUES ("Souris", 25.50);

Dépendance Maven pour MySQL Connector/J :

<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.28</version> <!-- Utilisez la version appropriée -->
</dependency>

Code Java :
 import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

public class JdbcExample {

// Informations de connexion à la base de données
static final String DB_URL =
"jdbc:mysql://localhost:3306/ma_base_de_donnees";
static final String USER = "root";
static final String PASS = "votre_mot_de_passe";

public static void main(String[] args) {

Connection conn = null;
Statement stmt = null;
ResultSet rs = null;

try {
// Étape 1: Établir la connexion
[Link]("Connexion à la base de données...");
conn = [Link](DB_URL, USER, PASS);
[Link]("Connexion établie.");

// Étape 2: Créer une instruction

[Link]("Création de l'instruction...");
stmt = [Link]();

// Étape 3: Exécuter la requête SQL

String sql = "SELECT id, nom, prix FROM produits";
rs = [Link](sql);

// Étape 4: Traiter les résultats

[Link]("\nListe des produits:");
while ([Link]()) {
int id = [Link]("id");
String nom = [Link]("nom");
double prix = [Link]("prix");

[Link]("ID: %d, Nom: %s, Prix: %.2f\n", id, nom,

prix);
}
} catch (SQLException e) {
[Link]();
} finally {
// Étape 5: Fermer les ressources dans le bloc finally
try {
if (rs != null) [Link]();
} catch (SQLException se2) {
} // rien à faire
try {
if (stmt != null) [Link]();
} catch (SQLException se2) {
} // rien à faire
try {
if (conn != null) [Link]();
} catch (SQLException se) {
[Link]();
}
}
[Link]("\nOpération terminée.");
 }
}

5.4. PreparedStatement pour des Requêtes Sécurisées

Pour les requêtes qui incluent des paramètres (par exemple, des valeurs saisies par
l'utilisateur), il est fortement recommandé d'utiliser PreparedStatement pour
prévenir les attaques par injection SQL et améliorer les performances.
 import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

public class PreparedStatementExample {

static final String DB_URL =
"jdbc:mysql://localhost:3306/ma_base_de_donnees";
static final String USER = "root";
static final String PASS = "votre_mot_de_passe";

public static void main(String[] args) {

try (Connection conn = [Link](DB_URL, USER, PASS);
PreparedStatement pstmt = [Link]("SELECT id, nom,
prix FROM produits WHERE prix > ?")) {

double prixMin = 100.00;

[Link](1, prixMin); // Définir le premier paramètre (index
1)

try (ResultSet rs = [Link]()) {

[Link]("\nProduits avec un prix supérieur à " +
prixMin + ":");
while ([Link]()) {
int id = [Link]("id");
String nom = [Link]("nom");
double prix = [Link]("prix");
[Link]("ID: %d, Nom: %s, Prix: %.2f\n", id, nom,
prix);
}
}

// Exemple d'INSERT avec PreparedStatement

String insertSql = "INSERT INTO produits (nom, prix) VALUES (?,
?)";
try (PreparedStatement insertPstmt =
[Link](insertSql)) {
[Link](1, "Clavier mécanique");
[Link](2, 80.00);
int rowsAffected = [Link]();
[Link]("\n" + rowsAffected + " ligne(s)
insérée(s).");
}

} catch (SQLException e) {
[Link]();
}
}
}

L'utilisation de try-with-resources (introduit en Java 7) est une bonne pratique

pour s'assurer que les ressources (Connection, Statement, ResultSet) sont
automatiquement fermées, même en cas d'exception.
5.5. Frameworks ORM (Object-Relational Mapping)

Bien que JDBC soit puissant, il peut être verbeux pour des applications complexes. Les
frameworks ORM comme Hibernate et JPA (Java Persistence API) simplifient
l'interaction avec les bases de données en mappant les objets Java aux tables de la
base de données. Spring Data JPA, basé sur Hibernate, est très populaire dans
l'écosystème Spring Boot et réduit considérablement la quantité de code JDBC
manuel à écrire.

L'apprentissage de JDBC est une base solide, mais pour le développement

d'applications modernes, l'utilisation d'un ORM est presque toujours préférable pour
la productivité et la maintenabilité.

6. Déploiement d'Applications Java sur Serveur

Le déploiement est l'étape finale du cycle de vie du développement logiciel, où votre

application est rendue disponible pour les utilisateurs. Pour les applications Java, le
processus de déploiement peut varier en fonction du type d'application (web,
microservice) et de l'environnement cible. Cette section couvrira les méthodes de
déploiement courantes.

6.1. Déploiement d'Applications Web (WAR) sur un Serveur

d'Applications

Pour les applications web traditionnelles basées sur Servlets/JSP ou des frameworks
comme Spring MVC (sans Spring Boot embarqué), le format de déploiement standard
est le fichier .war (Web Application Archive).

Étapes de Déploiement sur Tomcat (ou Jetty autonome) :

1. Construction du WAR : Utilisez Maven ou Gradle pour packager votre application

en un fichier .war . Par exemple, avec Maven, exécutez mvn clean package
dans le répertoire racine de votre projet. Cela créera un fichier .war dans le
répertoire target/ .

```bash cd mon-projet-web-java mvn clean package

 Le fichier WAR sera généré dans
target/[Link]
```

2. Copie du WAR : Copiez le fichier .war généré dans le répertoire webapps de

votre installation Tomcat (ou Jetty autonome).

bash cp target/[Link] /opt/tomcat/webapps/

3. Démarrage/Redémarrage du Serveur : Si Tomcat est déjà en cours d'exécution,

il détectera généralement le nouveau fichier .war et le déploiera
automatiquement. Si ce n'est pas le cas, ou si vous rencontrez des problèmes,
redémarrez Tomcat.

bash /opt/tomcat/bin/[Link] /opt/tomcat/bin/[Link]

4. Accès à l'Application : Votre application sera accessible via l'URL

[Link] (le nom du
contexte est généralement le nom du fichier .war sans l'extension).

6.2. Déploiement d'Applications Spring Boot (JAR exécutable)

L'un des grands avantages de Spring Boot est sa capacité à créer des fichiers JAR
exécutables qui contiennent un serveur web embarqué (Tomcat, Jetty ou Undertow).
Cela simplifie considérablement le déploiement, car vous n'avez pas besoin d'un
serveur d'applications externe.

Étapes de Déploiement d'un JAR exécutable :

1. Construction du JAR : Utilisez Maven ou Gradle pour packager votre application

Spring Boot en un fichier JAR exécutable. Avec Maven, la commande est la même
: mvn clean package . Le fichier JAR sera généré dans target/ et aura un nom
comme [Link] .

```bash cd mon-projet-spring-boot mvn clean package

 Le fichier JAR exécutable sera généré
dans target/monprojetspringboot-
[Link]
```

2. Copie du JAR sur le Serveur : Transférez le fichier JAR sur votre serveur cible
(par exemple, via scp ou FTP).

bash scp target/[Link]

user@your_server_ip:/home/user/apps/

3. Exécution de l'Application : Connectez-vous à votre serveur via SSH et exécutez

le fichier JAR comme une application Java normale.

bash java -jar /home/user/apps/monprojetspringboot-0.0.1-

[Link]

Pour que l'application continue de s'exécuter même après la déconnexion de

votre session SSH, utilisez un outil comme nohup ou screen / tmux :

bash nohup java -jar /home/user/apps/monprojetspringboot-0.0.1-

[Link] > [Link] 2>&1 &

4. Accès à l'Application : L'application sera accessible sur le port configuré dans

[Link] (par défaut 8080) :
[Link] .

6.3. Déploiement avec Docker

Docker est devenu une méthode de déploiement très populaire pour les applications
Java, en particulier les microservices. Il permet d'empaqueter votre application et
toutes ses dépendances dans un conteneur léger et portable, garantissant que
l'application s'exécutera de manière cohérente dans n'importe quel environnement.
Étapes de Déploiement avec Docker :

1. Création d'un Dockerfile : Créez un fichier nommé Dockerfile à la racine de

votre projet Spring Boot (ou de votre application WAR).

Exemple de Dockerfile pour une application Spring Boot :

```dockerfile

Utilise une image OpenJDK comme

base
FROM openjdk:17-jdk-slim

Définit le répertoire de travail dans le

conteneur
WORKDIR /app
 Copie le fichier JAR exécutable de
votre application dans le conteneur

Assurez-vous que le nom du JAR

correspond à celui généré par votre
build
COPY target/[Link] [Link]

Expose le port sur lequel l'application

écoute (par défaut 8080 pour Spring
Boot)
EXPOSE 8080

Commande pour exécuter

l'application lorsque le conteneur
démarre
ENTRYPOINT ["java", "-jar", "[Link]"] ```

2. Construction de l'Image Docker : Naviguez vers le répertoire de votre projet et

construisez l'image Docker.
 bash docker build -t mon-app-java .

3. Exécution du Conteneur Docker : Exécutez un conteneur à partir de votre

image. Le paramètre -p mappe le port du conteneur au port de votre machine
hôte.

bash docker run -p 8080:8080 mon-app-java

Votre application sera accessible via [Link] (ou l'adresse IP de

votre machine Docker).

6.4. Déploiement sur le Cloud (PaaS, Conteneurs)

Pour les déploiements en production, les plateformes cloud offrent des solutions
robustes et évolutives :

PaaS (Platform as a Service) : Des services comme Heroku, Google App Engine,
AWS Elastic Beanstalk, ou Azure App Service simplifient le déploiement en gérant
l'infrastructure sous-jacente. Vous poussez votre code, et la plateforme s'occupe
du reste.

Services de Conteneurs : Des services comme Kubernetes (via GKE, EKS, AKS),
AWS Fargate, ou Azure Container Instances permettent de déployer et de gérer
des applications conteneurisées à grande échelle.

Le choix de la méthode de déploiement dépendra de la taille de votre application, de

vos exigences en matière de scalabilité, de la complexité de votre infrastructure et de
votre budget.

Cette section conclut la partie technique du cours. Dans la section suivante, nous
résumerons les points clés et vous donnerons des pistes pour continuer votre
apprentissage.

Conclusion

Félicitations ! Vous avez parcouru ce cours complet sur Java et les serveurs. Nous
avons exploré ensemble les fondations du langage Java, les principes de la
communication réseau, le fonctionnement des serveurs web Java comme Tomcat et
Jetty, la puissance des frameworks modernes tels que Spring Boot, l'interaction avec
les bases de données via JDBC, et les différentes stratégies de déploiement
d'applications Java.

Récapitulatif des Points Clés :

Java Core : Maîtrise des types de données, opérateurs, structures de contrôle,

méthodes et des piliers de la POO (Encapsulation, Héritage, Polymorphisme,
Abstraction) est essentielle.

Réseau et Serveurs : Compréhension du modèle TCP/IP, des adresses IP, des

ports, du modèle client-serveur et des protocoles HTTP/HTTPS est fondamentale
pour le développement web.

Conteneurs de Servlets : Des outils comme Apache Tomcat et Eclipse Jetty

fournissent l'environnement d'exécution pour vos applications web Java, gérant
le cycle de vie des Servlets et JSP.

Spring Boot : Simplifie considérablement le développement d'applications Java

d'entreprise grâce à l'auto-configuration, aux serveurs embarqués et à un
écosystème riche, permettant de se concentrer sur la logique métier.

JDBC et Bases de Données : JDBC est l'API standard pour interagir avec les
bases de données, et l'utilisation de PreparedStatement est cruciale pour la
sécurité et la performance. Les ORM comme Spring Data JPA simplifient
davantage cette interaction.

Déploiement : Que ce soit via des fichiers WAR, des JAR exécutables Spring Boot,
ou des conteneurs Docker, le déploiement est une étape clé pour rendre vos
applications accessibles. Les plateformes cloud offrent des solutions de
déploiement et de gestion avancées.

Prochaines Étapes et Ressources Supplémentaires :

Ce cours vous a fourni une base solide. Pour approfondir vos connaissances et
continuer à progresser, voici quelques pistes :

1. Pratiquez, pratiquez, pratiquez ! : La meilleure façon d'apprendre est de coder.

Lancez vos propres projets, expérimentez avec les concepts appris, et n'hésitez
pas à faire des erreurs pour mieux comprendre.

2. Explorez l'écosystème Spring : Spring est vaste. Plongez dans Spring Security
pour la sécurité, Spring Data REST pour des APIs REST rapides, Spring Cloud pour
 les microservices, etc.

3. Apprenez d'autres technologies : Intéressez-vous aux technologies frontend

(React, Angular, [Link]) pour construire des applications full-stack, ou aux bases
de données NoSQL (MongoDB, Cassandra) pour des cas d'utilisation spécifiques.

4. Contribuez à l'open source : Participer à des projets open source est un

excellent moyen d'apprendre des développeurs expérimentés et de contribuer à
la communauté.

5. Restez informé : Le monde de la technologie évolue rapidement. Suivez les

blogs, les conférences et les communautés pour rester à jour sur les dernières
tendances et innovations.

Nous espérons que ce cours vous a été utile et vous a donné la confiance nécessaire
pour construire des applications Java robustes et performantes. Le chemin de
l'apprentissage est continu, et chaque ligne de code écrite est une étape vers la
maîtrise. Bonne chance dans vos futurs projets !

Auteur : Manus AI