Documentation - MateZone

📚 Ressources documentaires

Toute la documentation nécessaire pour comprendre, utiliser et étendre MateZone

📖

Javadoc API

Documentation complète du code source généré automatiquement avec toutes les classes, méthodes et interfaces.

Consulter la Javadoc

🏗️

Guide architectural

Comprenez l'architecture hexagonale de MateZone et les patterns utilisés pour une maintenance efficace.

Voir l'architecture

🗄️

Documentation BDD

Structure complète de la base de données MySQL avec schémas, relations et exemples de requêtes.

Base de données

🔌 Documentation de l'API

Interfaces et classes principales de MateZone

📦 Packages principaux

Package	Description	Javadoc
client	Application cliente MVC	📖
client.controleur	Contrôleurs de l'interface	📖
client.ihm	Interface utilisateur Swing	📖
client.metier	Logique métier client	📖
server	Serveur WebSocket	📖
server.metier	Services métier serveur	📖
server.bd	Accès aux données	📖
common	Éléments partagés	📖

🔑 Classes principales

Classe	Responsabilité	Documentation
MainClient	Point d'entrée client	📖
MainServer	Point d'entrée serveur	📖
Controleur	Contrôleur principal client	📖
WebSocketMateZone	Serveur WebSocket	📖
ConnexionBD	Connexion base de données	📖
ChatEventDTO	Objet de transfert messages	📖

Navigation : La Javadoc inclut un système de navigation complet avec index, recherche et arbre des classes. Utilisez la fonction de recherche pour trouver rapidement une classe ou méthode spécifique.

📡 Protocole de communication

Format des messages échangés entre client et serveur

📋 Types d'événements

Énumération des différents types de messages supportés par le protocole WebSocket :

Type	Direction	Description	Exemple d'usage
LOGIN	Client → Serveur	Demande d'authentification	Connexion utilisateur
SIGNUP	Client → Serveur	Demande d'inscription	Création nouveau compte
NEW_MESSAGE	Bidirectionnel	Envoi/réception de message	Message de chat
NEW_CHANNEL	Client → Serveur	Création d'un canal	Nouveau canal de discussion
JOIN_CHANNEL	Client → Serveur	Rejoindre un canal	Adhésion à un canal
USER_CONNECTED	Serveur → Client	Notification de connexion	Utilisateur en ligne
USER_DISCONNECTED	Serveur → Client	Notification de déconnexion	Utilisateur hors ligne

📨 Structure des messages

Format JSON standard pour tous les échanges :

{
  "type": "NEW_MESSAGE",
  "pseudo": "nom_utilisateur",
  "contenu": "Contenu du message",
  "channel": 1,
  "timestamp": "2024-11-11T10:30:00.000Z"
}

Champs obligatoires :

type : Type d'événement (enum)
timestamp : Horodatage ISO 8601

Champs optionnels :

pseudo : Nom d'utilisateur
contenu : Contenu textuel
channel : ID du canal
metadata : Données additionnelles

🔒 Authentification

Processus de connexion sécurisé :

1. Demande de connexion

{
  "type": "LOGIN",
  "pseudo": "utilisateur",
  "motDePasse": "hash_password",
  "timestamp": "2024-11-11T10:30:00.000Z"
}

2. Réponse du serveur

// Succès
{
  "type": "LOGIN_SUCCESS",
  "pseudo": "utilisateur",
  "sessionId": "abc123",
  "timestamp": "2024-11-11T10:30:01.000Z"
}

// Échec
{
  "type": "LOGIN_FAILED",
  "error": "Identifiants incorrects",
  "timestamp": "2024-11-11T10:30:01.000Z"
}

💻 Exemples de code

Extraits de code illustrant les fonctionnalités principales

📤 Envoi de message côté client

public class WebSocketChatAdapter implements IEnvoyeur {
    private WebSocketContainer container;
    private Session session;
    
    @Override
    public void envoyerMessage(String contenu, int canalId) {
        ChatEventDTO event = new ChatEventDTO();
        event.setType(EventEnum.NEW_MESSAGE);
        event.setContenu(contenu);
        event.setChannel(canalId);
        event.setTimestamp(LocalDateTime.now());
        
        String json = gson.toJson(event);
        
        try {
            session.getBasicRemote().sendText(json);
        } catch (IOException e) {
            logger.error("Erreur envoi message", e);
        }
    }
}

📥 Réception côté serveur

@ServerEndpoint("/websocket")
public class WebSocketMateZone {
    
    @OnMessage
    public void onMessage(String message, Session session) {
        ChatEventDTO event = gson.fromJson(message, ChatEventDTO.class);
        
        switch (event.getType()) {
            case NEW_MESSAGE:
                traiterNouveauMessage(event, session);
                break;
            case LOGIN:
                traiterConnexion(event, session);
                break;
            default:
                logger.warn("Type d'événement non géré: " + event.getType());
        }
    }
    
    private void traiterNouveauMessage(ChatEventDTO event, Session session) {
        // Sauvegarder en base
        messageRepository.save(event);
        
        // Diffuser aux clients connectés
        diffuserMessage(event);
    }
}

🗄️ Accès aux données

public class MessageRepository implements IMessageRepository {
    private ConnexionBD connexionBD;
    
    @Override
    public void sauvegarderMessage(Message message) {
        String sql = "INSERT INTO messages (auteur_id, canal_id, contenu, timestamp) VALUES (?, ?, ?, ?)";
        
        try (Connection conn = connexionBD.getConnection();
             PreparedStatement stmt = conn.prepareStatement(sql)) {
            
            stmt.setInt(1, message.getAuteurId());
            stmt.setInt(2, message.getCanalId());
            stmt.setString(3, message.getContenu());
            stmt.setTimestamp(4, Timestamp.valueOf(message.getTimestamp()));
            
            stmt.executeUpdate();
            
        } catch (SQLException e) {
            logger.error("Erreur sauvegarde message", e);
            throw new RepositoryException("Impossible de sauvegarder le message", e);
        }
    }
}

🖥️ Interface utilisateur

public class MateZoneFrame extends JFrame {
    private JTextArea messageArea;
    private JTextField inputField;
    private JList channelList;
    private Controleur controleur;
    
    public void afficherNouveauMessage(Message message) {
        SwingUtilities.invokeLater(() -> {
            String formatted = String.format("[%s] %s: %s%n",
                message.getTimestamp().format(DateTimeFormatter.ofPattern("HH:mm")),
                message.getAuteur(),
                message.getContenu()
            );
            
            messageArea.append(formatted);
            messageArea.setCaretPosition(messageArea.getDocument().getLength());
        });
    }
    
    private void setupEventHandlers() {
        inputField.addActionListener(e -> {
            String text = inputField.getText().trim();
            if (!text.isEmpty()) {
                controleur.envoyerMessage(text);
                inputField.setText("");
            }
        });
    }
}

⚙️ Configuration et déploiement

Guides techniques pour la mise en production

🔧 Fichiers de configuration

config.properties

# Base de données
db.url=jdbc:mysql://localhost:3306/matezone
db.username=${DB_USER}
db.password=${DB_PASSWORD}
db.driver=com.mysql.cj.jdbc.Driver

# Serveur
server.port=8080
server.host=0.0.0.0
server.maxConnections=100

# Logging
log.level=INFO
log.file=logs/matezone.log

Variables d'environnement : Utilisez des variables pour les données sensibles.

🐳 Docker

Dockerfile

FROM openjdk:21-jre-slim

WORKDIR /app

COPY bin/ bin/
COPY lib/ lib/
COPY config/ config/

EXPOSE 8080

ENTRYPOINT ["java", "-cp", "bin:lib/*", "server.MainServer"]

docker-compose.yml

version: '3.8'
services:
  matezone:
    build: .
    ports:
      - "8080:8080"
    environment:
      - DB_HOST=db
      - DB_USER=matezone
      - DB_PASSWORD=password
    depends_on:
      - db
      
  db:
    image: mysql:8.0
    environment:
      MYSQL_ROOT_PASSWORD: rootpass
      MYSQL_DATABASE: matezone
      MYSQL_USER: matezone
      MYSQL_PASSWORD: password

🚀 Scripts de déploiement

deploy.sh

#!/bin/bash
set -e

echo "🚀 Déploiement MateZone"

# Arrêt du service existant
sudo systemctl stop matezone || true

# Sauvegarde
sudo -u mysql mysqldump matezone > backup_$(date +%Y%m%d_%H%M%S).sql

# Compilation
./run.sh

# Copie des fichiers
sudo cp -r bin lib /opt/matezone/

# Redémarrage
sudo systemctl start matezone
sudo systemctl status matezone

echo "✅ Déploiement terminé"

Service systemd

# /etc/systemd/system/matezone.service
[Unit]
Description=MateZone Chat Server
After=mysql.service
Requires=mysql.service

[Service]
Type=simple
User=matezone
WorkingDirectory=/opt/matezone
ExecStart=/usr/bin/java -cp "bin:lib/*" server.MainServer
Restart=on-failure
RestartSec=10

[Install]
WantedBy=multi-user.target

🤝 Contribution au projet

Guide pour les développeurs souhaitant contribuer à MateZone

📋 Processus de contribution

Fork du repository sur GitHub
Clone votre fork localement
Branche pour votre fonctionnalité : git checkout -b feature/ma-feature
Développement avec tests unitaires
Commit avec messages clairs
Push vers votre fork
Pull Request vers le repository principal

Convention : Utilisez des messages de commit descriptifs au format "type: description courte".

🧪 Tests et qualité

Tests unitaires obligatoires pour nouvelles fonctionnalités
Couverture minimale de 80%
Documentation Javadoc pour toutes les méthodes publiques
Style respecter les conventions Java

# Exécuter les tests
./gradlew test

# Générer le rapport de couverture
./gradlew jacocoTestReport

# Vérifier le style de code
./gradlew checkstyleMain

📝 Standards de documentation

Javadoc obligatoire pour :

Toutes les classes publiques
Toutes les méthodes publiques
Tous les champs publics
Toutes les interfaces

Exemple de documentation :

/**
 * Envoie un message à tous les clients connectés au canal spécifié.
 * 
 * @param message le message à diffuser
 * @param canalId l'identifiant du canal cible
 * @throws IllegalArgumentException si le message est null ou vide
 * @throws RepositoryException si erreur d'accès aux données
 * @since 1.0
 */
public void diffuserMessage(String message, int canalId) {
    // Implémentation
}

Documentation MateZone