---
title: Cycle de Vie du Plugin
type: docs
weight: 4
---

Comprendre le cycle de vie du plugin est essentiel pour initialiser et nettoyer correctement les ressources de votre plugin.

## États du Cycle de Vie

Un plugin passe par plusieurs états durant sa vie :

```
NONE → SETUP → START → ENABLED → SHUTDOWN → DISABLED
```

| État | Description |
|------|-------------|
| `NONE` | État initial avant toute initialisation |
| `SETUP` | Le plugin est en phase de configuration |
| `START` | Le plugin démarre |
| `ENABLED` | Le plugin est pleinement opérationnel |
| `SHUTDOWN` | Le plugin s'arrête |
| `DISABLED` | Le plugin a été désactivé |

## Méthodes du Cycle de Vie

### Constructeur

Le constructeur est appelé lorsque le plugin est instancié. Utilisez ceci pour :

- Enregistrer les fichiers de configuration avec `withConfig()` (recommandé)
- Stocker la référence init si nécessaire

```java
import com.hypixel.hytale.server.core.util.Config;

private Config<MyConfig> config;

public MyPlugin(JavaPluginInit init) {
    super(init);
    // Enregistrer la config dans le constructeur - chargée de façon asynchrone pendant preLoad()
    config = withConfig(MyConfig.CODEC);
}
```

{{< callout type="info" >}}
Enregistrer les configs dans le constructeur garantit qu'elles sont chargées de façon asynchrone pendant `preLoad()`, avant que `setup()` ne soit appelé. C'est l'approche recommandée.
{{< /callout >}}

### setup()

Appelé pendant la phase initiale de configuration, après le chargement des configs. Utilisez ceci pour :

- Préparer les ressources qui ne dépendent pas d'autres plugins
- Logique d'initialisation précoce
- Accéder aux valeurs de configuration chargées

```java
import java.util.logging.Level;

@Override
public void setup() {
    // La config est déjà chargée et disponible
    getLogger().at(Level.INFO).log("Configuration terminée !");
}
```

{{< callout type="info" >}}
Pour créer des classes de configuration avec `CODEC`, voir la [documentation des Codecs]({{< ref "core-concepts/codecs#buildercodec" >}}).
{{< /callout >}}

{{< callout type="warning" >}}
N'enregistrez pas de commandes ou d'événements dans `setup()`. D'autres plugins peuvent ne pas être encore chargés.
{{< /callout >}}

### start()

Appelé après que tous les plugins aient terminé leur configuration. Utilisez ceci pour :

- Enregistrer les commandes
- Enregistrer les écouteurs d'événements
- Enregistrer les entités
- Interagir avec d'autres plugins

```java
import com.hypixel.hytale.server.core.event.events.player.PlayerConnectEvent;
import com.hypixel.hytale.server.core.universe.PlayerRef;
import java.util.logging.Level;

@Override
public void start() {
    // Enregistrer les commandes
    getCommandRegistry().registerCommand(new MyCommand());

    // Enregistrer les événements
    getEventRegistry().register(PlayerConnectEvent.class, this::onPlayerConnect);

    getLogger().at(Level.INFO).log("Plugin démarré !");
}

private void onPlayerConnect(PlayerConnectEvent event) {
    // Voir la documentation PlayerRef pour les références thread-safe aux joueurs
    PlayerRef playerRef = event.getPlayerRef();
    getLogger().at(Level.INFO).log("Joueur en connexion : " + playerRef.getUsername());
}
```

{{< callout type="info" >}}
Voir la [documentation des Registres]({{< ref "core-concepts/registries" >}}) pour une liste complète des registres disponibles et leur utilisation.
{{< /callout >}}

### shutdown()

Appelé quand le plugin est désactivé ou le serveur s'arrête. Utilisez ceci pour :

- Sauvegarder les données
- Nettoyer les ressources
- Annuler les tâches planifiées

```java
import java.util.logging.Level;

@Override
public void shutdown() {
    // Sauvegarder les données en attente
    savePlayerData();

    getLogger().at(Level.INFO).log("Arrêt du plugin terminé !");
}
```

{{< callout type="info" >}}
Les registres sont automatiquement nettoyés après `shutdown()`. Vous n'avez pas besoin de désinscrire manuellement les commandes ou événements.
{{< /callout >}}

## Diagramme du Flux de Vie

{{< steps >}}

### Chargement du Plugin
Le serveur découvre votre JAR de plugin et lit `manifest.json`

### Appel du Constructeur
`MyPlugin(JavaPluginInit init)` est instancié

### preLoad()
Les fichiers de configuration enregistrés avec `withConfig()` sont chargés de façon asynchrone

### setup()
Votre méthode `setup()` est appelée

### start()
Votre méthode `start()` est appelée après que tous les plugins soient configurés

### En Cours d'Exécution
Le plugin est maintenant en état `ENABLED` et pleinement opérationnel

### shutdown()
Appelé quand le serveur s'arrête ou le plugin est désactivé

### Nettoyage
Tous les registres sont automatiquement nettoyés

{{< /steps >}}

## Vérifier l'État du Plugin

Vous pouvez vérifier si votre plugin est activé :

```java
if (isEnabled()) {
    // Le plugin fonctionne
}

if (isDisabled()) {
    // Le plugin ne fonctionne pas
}

// Obtenir l'état actuel
PluginState state = getState();
```

## Étapes Suivantes

Apprenez à [Compiler et Exécuter](../building-and-running) votre plugin.