feat(DevWeb): Setup du Projet avec Servlet et JPA

S2/DevWeb/Projet/src/main/java/uppa/project/EntityManagerProvider.java

@@ -0,0 +1,28 @@
+package uppa.project;
+
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.EntityManagerFactory;
+import jakarta.persistence.Persistence;
+
+public final class EntityManagerProvider {
+
+  private static EntityManager instance;
+  private static EntityManagerFactory factory;
+  private final static String PERSISTANCE_UNIT_NAME = "db";
+
+  public static EntityManager getInstance() {
+    if (factory == null) {
+      factory = Persistence.createEntityManagerFactory(PERSISTANCE_UNIT_NAME);
+    }
+
+    if (instance == null) {
+      instance = factory.createEntityManager();
+    }
+    return instance;
+  }
+
+  public static void close() {
+    if (instance.isOpen()) instance.close();
+    if (factory.isOpen()) factory.close();
+  }
+}

S2/DevWeb/Projet/src/main/java/uppa/project/Main.java

@@ -0,0 +1,50 @@
+package uppa.project;
+
+import java.util.Calendar;
+import uppa.project.dao.DAO;
+import uppa.project.dao.jpa.Game_JPA_DAO_Factory;
+import uppa.project.pojo.Game;
+import uppa.project.pojo.Player;
+import uppa.project.pojo.User;
+
+public class Main {
+
+  public static void main(String[] args) {
+    try {
+      Game_JPA_DAO_Factory jpaDaoFactory = new Game_JPA_DAO_Factory();
+      DAO<User> daoJpaUser = jpaDaoFactory.getDAOUser();
+//      DAO<Game> daoJpaGame = jpaDaoFactory.getDAOGame();
+//      DAO<Player> daoJpaPlayer = jpaDaoFactory.getDAOPlayer();
+
+      // Contenu de la BD au début
+      User[] users = daoJpaUser.findAll();
+      for (User u : users) {
+        System.out.println(u.toString());
+      }
+      System.out.println();
+
+      // Ajout d'User :
+      Calendar cal1 = Calendar.getInstance();
+      cal1.set(1996, Calendar.FEBRUARY, 20);
+      User user1 = new User("Kevin", "Mitresse", cal1.getTime(), User.Gender.MALE);
+
+      Calendar cal2 = Calendar.getInstance();
+      cal2.set(2002, Calendar.JUNE, 28);
+      User user2 = new User("Lucàs", "Vabre", cal2.getTime(), User.Gender.MALE);
+
+      daoJpaUser.create(user1);
+      daoJpaUser.create(user2);
+
+      // Contenu de la BD après ajout
+      users = daoJpaUser.findAll();
+      for (User u : users) {
+        System.out.println(u.toString());
+      }
+      System.out.println();
+
+      EntityManagerProvider.close();
+    } catch (Exception e) {
+      e.printStackTrace();
+    }
+  }
+}

S2/DevWeb/Projet/src/main/java/uppa/project/dao/AbstractDAOFactory.java

@@ -0,0 +1,20 @@
+/*
+ * AbstractDAOFactory.java, 09/02/2024
+ * UPPA M1 TI 2023-2024
+ * Pas de copyright, aucun droits
+ */
+
+package uppa.project.dao;
+
+import uppa.project.dao.jpa.Game_JPA_DAO_Factory;
+
+/**
+ * Factory renvoyant une factory de DAO en fonction du support de persistance choisi
+ */
+public class AbstractDAOFactory {
+
+  public static GameDAOFactory getDAOFactory(PersistenceKind type) {
+    if (type.equals(PersistenceKind.JPA)) return new Game_JPA_DAO_Factory();
+    return null;
+  }
+}

S2/DevWeb/Projet/src/main/java/uppa/project/dao/DAO.java

@@ -0,0 +1,55 @@
+/*
+ * DAO.java, 21/02/2024
+ * UPPA M1 TI 2023-2024
+ * Pas de copyright, aucun droits
+ */
+
+package uppa.project.dao;
+
+/**
+ * DAO abstrait et générique pour tout type de données
+ *
+ * @param <D> la classe paramétrant le DAO
+ */
+public abstract class DAO<D> {
+
+  public void DAO() throws DAOException {
+
+  }
+
+  /**
+   * Retourne à partir du support de persistance un objet en fonction de son identifiant
+   *
+   * @param id identifiant de l'objet
+   * @return l'instance de l'objet
+   * @throws DAOException en cas de problème
+   */
+  public abstract D findById(int id) throws DAOException;
+
+  public abstract D[] findAll() throws DAOException;
+
+  /**
+   * Rend persistant un objet qui n'avait pas encore de réprésentation sur le support de persistance
+   *
+   * @param data l'objet à rendre persistant
+   * @throws DAOException en cas de problème
+   */
+  public abstract void create(D data) throws DAOException;
+
+  /**
+   * Met à jour le contenu correspondant à l'objet sur le support persistant (l'objet
+   * avait déjà une représentation sur le support persistant)
+   *
+   * @param data l'objet modifié dont le contenu est à mettre à jour
+   * @throws DAOException en cas de problème
+   */
+  public abstract void update(D data) throws DAOException;
+
+  /**
+   * Efface du support persistant le contenu équivalent à l'objet
+   *
+   * @param data l'objet à supprimer
+   * @throws DAOException en cas de problème
+   */
+  public abstract void delete(D data) throws DAOException;
+}

S2/DevWeb/Projet/src/main/java/uppa/project/dao/DAOException.java

@@ -0,0 +1,21 @@
+/*
+ * DAOException.java, 09/02/2024
+ * UPPA M1 TI 2023-2024
+ * Pas de copyright, aucun droits
+ */
+
+package uppa.project.dao;
+
+/**
+ * Exception spécifique aux problèmes d'accès aux données via un DAO
+ */
+public class DAOException extends Exception {
+
+  public DAOException() {
+    super();
+  }
+
+  public DAOException(String message) {
+    super(message);
+  }
+}

S2/DevWeb/Projet/src/main/java/uppa/project/dao/GameDAOFactory.java

@@ -0,0 +1,34 @@
+/*
+ * SportsDAOFactory.java, 09/02/2024
+ * UPPA M1 TI 2023-2024
+ * Pas de copyright, aucun droits
+ */
+
+package uppa.project.dao;
+
+import uppa.project.pojo.*;
+
+/**
+ * Fabrique abstraite de DAO pour le schéma sports
+ */
+public abstract class GameDAOFactory {
+
+  /**
+   * @return le DAO pour la classe/table User
+   * @throws DAOException en cas de problème
+   */
+  public abstract DAO<User> getDAOUser() throws DAOException;
+
+  /**
+   * @return le DAO pour la classe/table Game
+   * @throws DAOException en cas de problème
+   */
+  public abstract DAO<Game> getDAOGame() throws DAOException;
+
+  /**
+   * @return le DAO pour la classe/table Player
+   * @throws DAOException en cas de problème
+   */
+  public abstract DAO<Player> getDAOPlayer() throws DAOException;
+
+}

S2/DevWeb/Projet/src/main/java/uppa/project/dao/PersistenceKind.java

@@ -0,0 +1,14 @@
+/*
+ * PersistenceKind.java, 09/02/2024
+ * UPPA M1 TI 2023-2024
+ * Pas de copyright, aucun droits
+ */
+
+package uppa.project.dao;
+
+/**
+ * Type de support de persistance pour les données
+ */
+public enum PersistenceKind {
+  JDBC, JPA, XML
+} 

S2/DevWeb/Projet/src/main/java/uppa/project/dao/jpa/DAO_JPA_Game.java

@@ -0,0 +1,52 @@
+package uppa.project.dao.jpa;
+
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.TypedQuery;
+import java.math.BigDecimal;
+import java.util.List;
+import uppa.project.EntityManagerProvider;
+import uppa.project.dao.DAO;
+import uppa.project.dao.DAOException;
+import uppa.project.pojo.Game;
+
+public class DAO_JPA_Game extends DAO<Game> {
+
+  private final EntityManager entityManager;
+
+  public DAO_JPA_Game() throws DAOException {
+    this.entityManager = EntityManagerProvider.getInstance();
+  }
+
+  @Override
+  public Game findById(int id) throws DAOException {
+    Game result =  entityManager.find(Game.class, new BigDecimal(id));
+    entityManager.flush();
+    return result;
+  }
+
+  @Override
+  public Game[] findAll() throws DAOException {
+    TypedQuery<Game> query = entityManager.createQuery("SELECT g FROM Game g", Game.class);
+    List<Game> results = query.getResultList();
+    return results.toArray(new Game[0]);
+  }
+
+  @Override
+  public void create(Game data) throws DAOException {
+    update(data);
+  }
+
+  @Override
+  public void update(Game data) throws DAOException {
+    entityManager.getTransaction().begin();
+    entityManager.merge(data);
+    entityManager.getTransaction().commit();
+  }
+
+  @Override
+  public void delete(Game data) throws DAOException {
+    entityManager.getTransaction().begin();
+    entityManager.remove(data);
+    entityManager.getTransaction().commit();
+  }
+}

S2/DevWeb/Projet/src/main/java/uppa/project/dao/jpa/DAO_JPA_Player.java

@@ -0,0 +1,52 @@
+package uppa.project.dao.jpa;
+
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.TypedQuery;
+import java.math.BigDecimal;
+import java.util.List;
+import uppa.project.EntityManagerProvider;
+import uppa.project.dao.DAO;
+import uppa.project.dao.DAOException;
+import uppa.project.pojo.Player;
+
+public class DAO_JPA_Player extends DAO<Player> {
+
+  private final EntityManager entityManager;
+
+  public DAO_JPA_Player() throws DAOException {
+    this.entityManager = EntityManagerProvider.getInstance();
+  }
+
+  @Override
+  public Player findById(int id) throws DAOException {
+    Player result =  entityManager.find(Player.class, new BigDecimal(id));
+    entityManager.flush();
+    return result;
+  }
+
+  @Override
+  public Player[] findAll() throws DAOException {
+    TypedQuery<Player> query = entityManager.createQuery("SELECT p FROM Player p", Player.class);
+    List<Player> results = query.getResultList();
+    return results.toArray(new Player[0]);
+  }
+
+  @Override
+  public void create(Player data) throws DAOException {
+    update(data);
+  }
+
+  @Override
+  public void update(Player data) throws DAOException {
+    entityManager.getTransaction().begin();
+    entityManager.merge(data);
+    entityManager.getTransaction().commit();
+  }
+
+  @Override
+  public void delete(Player data) throws DAOException {
+    entityManager.getTransaction().begin();
+    entityManager.remove(data);
+    entityManager.getTransaction().commit();
+  }
+}

S2/DevWeb/Projet/src/main/java/uppa/project/dao/jpa/DAO_JPA_User.java

@@ -0,0 +1,52 @@
+package uppa.project.dao.jpa;
+
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.TypedQuery;
+import java.math.BigDecimal;
+import java.util.List;
+import uppa.project.dao.DAO;
+import uppa.project.dao.DAOException;
+import uppa.project.EntityManagerProvider;
+import uppa.project.pojo.User;
+
+public class DAO_JPA_User extends DAO<User> {
+
+  private final EntityManager entityManager;
+
+  public DAO_JPA_User() throws DAOException {
+    this.entityManager = EntityManagerProvider.getInstance();
+  }
+
+  @Override
+  public User findById(int id) throws DAOException {
+    User result =  entityManager.find(User.class, new BigDecimal(id));
+    entityManager.flush();
+    return result;
+  }
+
+  @Override
+  public User[] findAll() throws DAOException {
+    TypedQuery<User> query = entityManager.createQuery("SELECT u FROM User u", User.class);
+    List<User> results = query.getResultList();
+    return results.toArray(new User[0]);
+  }
+
+  @Override
+  public void create(User data) throws DAOException {
+    update(data);
+  }
+
+  @Override
+  public void update(User data) throws DAOException {
+    entityManager.getTransaction().begin();
+    entityManager.merge(data);
+    entityManager.getTransaction().commit();
+  }
+
+  @Override
+  public void delete(User data) throws DAOException {
+    entityManager.getTransaction().begin();
+    entityManager.remove(data);
+    entityManager.getTransaction().commit();
+  }
+}

S2/DevWeb/Projet/src/main/java/uppa/project/dao/jpa/Game_JPA_DAO_Factory.java

@@ -0,0 +1,41 @@
+/*
+ * Sports_JDBC_DAOFactory.java, 09/02/2024
+ * UPPA M1 TI 2023-2024
+ * Pas de copyright, aucun droits
+ */
+
+package uppa.project.dao.jpa;
+
+import uppa.project.dao.DAO;
+import uppa.project.pojo.*;
+import uppa.project.dao.DAOException;
+import uppa.project.dao.GameDAOFactory;
+
+/**
+ * Fabrique concrète de DAO pour le schéma relationnel sports avec une implémentation en JDBC.
+ */
+public class Game_JPA_DAO_Factory extends GameDAOFactory {
+
+  private DAO_JPA_User daoUser = null;
+
+  private DAO_JPA_Game daoGame = null;
+
+  private DAO_JPA_Player daoPlayer = null;
+
+  @Override
+  public DAO<User> getDAOUser() throws DAOException {
+    if (daoUser == null) daoUser = new DAO_JPA_User();
+    return daoUser;
+  }
+
+  @Override
+  public DAO<Game> getDAOGame() throws DAOException {
+    if (daoGame == null) daoGame = new DAO_JPA_Game();
+    return daoGame;
+  }
+  @Override
+  public DAO<Player> getDAOPlayer() throws DAOException {
+    if (daoPlayer == null) daoPlayer = new DAO_JPA_Player();
+    return daoPlayer;
+  }
+}

S2/DevWeb/Projet/src/main/java/uppa/project/pojo/Card.java

@@ -0,0 +1,24 @@
+package uppa.project.pojo;
+
+public class Card {
+
+  public enum Color{coeur, carreau, pique, trefle}
+
+  public enum Value{un, deux, trois, quatre, cinq, six, sept, huit, neuf, dix, valet, dame, roi}
+  private final Color color;
+
+  private final Value value;
+
+  public Card(Color color, Value value) {
+    this.color = color;
+    this.value = value;
+  }
+
+  public Color getColor() {
+    return color;
+  }
+
+  public Value getValue() {
+    return value;
+  }
+}

S2/DevWeb/Projet/src/main/java/uppa/project/pojo/Deck.java

@@ -0,0 +1,31 @@
+package uppa.project.pojo;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class Deck {
+  private Set<Card> cards;
+
+  public Deck(){
+    cards = new HashSet<>();
+    initializeDeck();
+    shuffleDeck();
+  }
+
+  private void initializeDeck() {
+    for (Card.Color color : Card.Color.values()){
+      for (Card.Value value : Card.Value.values()) {
+        cards.add(new Card(color, value));
+      }
+    }
+  }
+
+  private void shuffleDeck() {
+    List<Card> cardList = new ArrayList<>(cards);
+    Collections.shuffle(cardList);
+    cards = new HashSet<>(cardList);
+  }
+}

S2/DevWeb/Projet/src/main/java/uppa/project/pojo/Game.java

@@ -0,0 +1,70 @@
+package uppa.project.pojo;
+
+import jakarta.persistence.CascadeType;
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.FetchType;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.OneToMany;
+import jakarta.persistence.Table;
+import jakarta.persistence.Temporal;
+import jakarta.persistence.TemporalType;
+import java.io.Serializable;
+import java.math.BigDecimal;
+import java.sql.Timestamp;
+import java.util.Date;
+import java.util.Objects;
+import java.util.Set;
+
+@Entity
+@Table(name = "game")
+public class Game implements Serializable {
+
+  @Id
+  @Column(name = "id")
+  @GeneratedValue(strategy = GenerationType.IDENTITY)
+  private BigDecimal id;
+
+  @Temporal(TemporalType.TIMESTAMP)
+  @Column(name="created_at")
+  private Date createdAt;
+
+  @OneToMany(mappedBy = "game", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
+  private Set<Player> players;
+
+  public Game() {
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(id, createdAt, players);
+  }
+  public BigDecimal getId() {
+    return id;
+  }
+
+  public Date getCreatedAt() {
+    return createdAt;
+  }
+
+  public Set<Player> getPlayers() {
+    return players;
+  }
+
+  public void setPlayers(Set<Player> players) {
+    this.players = players;
+  }
+
+  public void addPlayers(Player player) {
+    this.players.add(player);
+  }
+
+
+
+  @Override
+  public String toString() {
+    return String.format("Game{id=%s, createdAt=%s, players=%s}", id.toString(), createdAt, players);
+  }
+}

S2/DevWeb/Projet/src/main/java/uppa/project/pojo/Player.java

@@ -0,0 +1,149 @@
+package uppa.project.pojo;
+
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.ManyToOne;
+import jakarta.persistence.Table;
+import java.io.Serializable;
+import java.math.BigDecimal;
+import java.util.Objects;
+
+@Entity
+@Table(name = "player")
+public class Player implements Serializable {
+
+  @Id
+  @Column(name = "id")
+  @GeneratedValue(strategy = GenerationType.IDENTITY)
+  private BigDecimal id;
+
+  @ManyToOne
+  @JoinColumn(name = "game_id", nullable = false)
+  private Game game;
+
+  @ManyToOne
+  @JoinColumn(name = "user_id", nullable = false)
+  private User user;
+
+  @Column(name = "score")
+  private int score;
+
+  @Column(name = "winner")
+  private boolean winner;
+
+  @Column(name = "click_count")
+  private int clickCount;
+
+  @Column(name = "right_click_count")
+  private int rightClickCount;
+
+  @Column(name = "rapid_click_count")
+  private int rapidClickCount;
+
+  public Player() {
+
+  }
+
+  public Player(Game game, User user) {
+    this.game = game;
+    this.user = user;
+    this.score = 0;
+    this.winner = false;
+    this.clickCount = 0;
+    this.rightClickCount = 0;
+    this.rapidClickCount = 0;
+  }
+
+  public Player(Game game, User user, int score, boolean winner, int clickCount, int rightClickCount, int rapidClickCount) {
+    this.game = game;
+    this.user = user;
+    this.score = score;
+    this.winner = winner;
+    this.clickCount = clickCount;
+    this.rightClickCount = rightClickCount;
+    this.rapidClickCount = rapidClickCount;
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(game, user, score, winner, clickCount, rightClickCount, rapidClickCount);
+  }
+
+  public Game getGame() {
+    return game;
+  }
+
+  public void setGame(Game game) {
+    this.game = game;
+  }
+
+  public User getUser() {
+    return user;
+  }
+
+  public void setUser(User user) {
+    this.user = user;
+  }
+
+  public int getScore() {
+    return score;
+  }
+
+  public void setScore(int score) {
+    this.score = score;
+  }
+
+  public void updateScore(int points) { this.score += points; }
+
+  public boolean isWinner() {
+    return winner;
+  }
+
+  public void setWinner() {
+    this.winner = true;
+  }
+
+  public int getClickCount() {
+    return clickCount;
+  }
+
+  public void setClickCount(int clickCount) {
+    this.clickCount = clickCount;
+  }
+
+  public void incrementClickCount() {
+    clickCount++;
+  }
+
+  public int getRightClickCount() {
+    return rightClickCount;
+  }
+
+  public void setRightClickCount(int rightClickCount) {
+    this.rightClickCount = rightClickCount;
+  }
+
+  public void incrementRightClickCount() {
+    rightClickCount++;
+  }
+  public int getRapidClickCount() {
+    return rapidClickCount;
+  }
+
+  public void setRapidClickCount(int rapidClickCount) {
+    this.rapidClickCount = rapidClickCount;
+  }
+
+  public void incrementRapidClickCount() {
+    rapidClickCount++;
+  }
+
+  @Override
+  public String toString() {
+    return String.format("Player{id=%s, game=%s, user=%s, score=%d, winner=%b, clickCount=%d, rightClickCount=%d, rapidClickCount=%d}", id.toString(), game.toString(), user.toString(), score, winner, clickCount, rightClickCount, rapidClickCount);
+  }
+}

S2/DevWeb/Projet/src/main/java/uppa/project/pojo/User.java

@@ -0,0 +1,140 @@
+package uppa.project.pojo;
+
+import jakarta.persistence.CascadeType;
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.EnumType;
+import jakarta.persistence.Enumerated;
+import jakarta.persistence.FetchType;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.OneToMany;
+import jakarta.persistence.Table;
+import jakarta.persistence.Temporal;
+import jakarta.persistence.TemporalType;
+import java.io.Serializable;
+import java.math.BigDecimal;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.Date;
+import java.util.Objects;
+import java.util.Set;
+
+@Entity
+@Table(name = "user")
+public class User implements Serializable {
+
+  @Id
+  @Column(name = "id")
+  @GeneratedValue(strategy = GenerationType.IDENTITY)
+  private BigDecimal id;
+
+  @Column(name = "username")
+  private String username;
+  @Column(name = "password")
+  private String password;
+  @Temporal(TemporalType.DATE)
+  @Column(name = "birth")
+  private Date birth;
+  @Column(name = "gender")
+  @Enumerated(EnumType.STRING)
+  private Gender gender;
+  @OneToMany(mappedBy = "user", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
+  private Set<Player> playedGame;
+  public User() {
+  }
+
+  public User(String username, String password, Date birth, Gender gender) {
+    this.username = username;
+    this.password = hashPassword(password);
+    this.birth = birth;
+    this.gender = gender;
+  }
+
+  public User(BigDecimal id, String username, String password) {
+    this.id = id;
+    this.username = username;
+    this.password = password;
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(id, username, password, birth, gender);
+  }
+
+  public BigDecimal getId() {
+    return id;
+  }
+
+  public String getUsername() {
+    return username;
+  }
+
+  public void setUsername(String username) {
+    this.username = username;
+  }
+
+  public String getPassword() {
+    return password;
+  }
+
+  public void setPassword(String password) {
+    this.password = hashPassword(password);
+  }
+
+  public Date getBirth() {
+    return birth;
+  }
+
+  public void setBirth(Date birth) {
+    this.birth = birth;
+  }
+
+  public Gender getGender() {
+    return gender;
+  }
+
+  public void setGender(Gender gender) {
+    this.gender = gender;
+  }
+
+  public int getAge() {
+    Date currentDate = new Date();
+    long diff = currentDate.getTime() - birth.getTime();
+    long diffDays = diff / (24 * 60 * 60 * 1000);
+    return (int) (diffDays / 365);
+  }
+
+  private String hashPassword(String password) {
+    try {
+      MessageDigest digest = MessageDigest.getInstance("SHA-256");
+
+      byte[] encodedhash = digest.digest(password.getBytes());
+
+      StringBuilder hexString = new StringBuilder();
+      for (byte b : encodedhash) {
+        String hex = Integer.toHexString(0xff & b);
+        if (hex.length() == 1) hexString.append('0');
+        hexString.append(hex);
+      }
+
+      return hexString.toString();
+    } catch (NoSuchAlgorithmException e) {
+      e.printStackTrace();
+      return null;
+    }
+  }
+
+  public boolean verifyPassword(String password) {
+    String hashedPassword = hashPassword(password);
+    return hashedPassword != null && hashedPassword.equals(this.password);
+  }
+
+  @Override
+  public String toString() {
+    return String.format("User{id=%s, username='%s', birth=%s, gender=%s}", id.toString(), username, birth.toString(), gender.toString());
+  }
+
+  public enum Gender {MALE, FEMALE, OTHER}
+}

S2/DevWeb/Projet/src/main/java/uppa/project/servlet/HelloServlet.java

@@ -0,0 +1,27 @@
+package uppa.project.servlet;
+
+import java.io.*;
+import jakarta.servlet.http.*;
+import jakarta.servlet.annotation.*;
+
+@WebServlet(name = "helloServlet", value = "/hello-servlet")
+public class HelloServlet extends HttpServlet {
+    private String message;
+
+    public void init() {
+        message = "Hello World!";
+    }
+
+    public void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {
+        response.setContentType("text/html");
+
+        // Hello
+        PrintWriter out = response.getWriter();
+        out.println("<html><body>");
+        out.println("<h1>" + message + "</h1>");
+        out.println("</body></html>");
+    }
+
+    public void destroy() {
+    }
+}