Les chargeurs de classe Java sont des composants essentiels du JRE responsable du chargement des classes dans le JVM au moment de l'exécution, permettant la modularité, la sécurité et le comportement dynamique. 1. Les trois chargeurs de classe intégrés sont Bootstrap (charge les classes Java Core dans le code natif), l'extension / la plate-forme (charge des classes de JRE / LIB / EXT ou des répertoires spécifiés) et l'application (charge des classes définies par l'utilisateur à partir du chemin de classe). 2. Le modèle de délégation garantit que les demandes de chargement des classes sont d'abord transmises au chargeur parent - passant de l'application à l'extension en bootstrap - et si elle n'est pas trouvée, la demande recule, empêchant les remplacements de classe de base et garantissant que chaque classe n'est chargée qu'une seule fois. 3. Les chargeurs de classe personnalisés étendent Classloader et remplacent findClass () pour charger des classes à partir de sources non standard comme les réseaux ou les bases de données, prennent en charge le déploiement à chaud ou créent des environnements de plugin isolés, bien que la mise en place de chargement de chargement () soit évité à moins que nécessaire de rompre la délégation pour des cas d'utilisation spécifiques comme le rechargement de l'application Web. 4. Les pièges courants incluent ClassCastExceptions en raison de la charge de classe en double par différents chargeurs, des fuites de mémoire à partir de nettoyage inapproprié dans les serveurs d'applications, un chargement de ressources incorrect via des flux de fichiers au lieu de getResourceSStream () et une mauvaise utilisation du compteur de thread Classloader; Les meilleures pratiques consistent à utiliser une délégation appropriée, à nettoyer les références statiques et à tirer parti des chargeurs de classe de contexte lorsque le code système a besoin d'accès aux classes d'application. Comprendre la hiérarchie, la délégation et l'isolement des chargeurs de classe sont cruciaux pour déboguer les problèmes de chargement des classes et créer des applications Java modulaires robustes.

Java Classloaders fait partie intégrante de l'environnement d'exécution Java (JRE) qui charge dynamiquement des classes dans le JVM au moment de l'exécution. Alors que la plupart des développeurs les utilisent implicitement, comprendre comment ils fonctionnent est crucial pour le débogage, le réglage des performances et la création d'applications modulaires. Décomposons le fonctionnement des Classloaders, de leurs types, du modèle de délégation et des pièges communs.

Qu'est-ce qu'un chargeur de classe?

Un Classloader est un objet Java responsable du chargement des fichiers de classe à partir du système de fichiers, du réseau ou d'autres sources en mémoire et de les convertir en instances java.lang.Class . Sans Classloaders, le JVM ne saurait pas comment localiser ou charger les cours de votre application.

Responsabilités clés:

• Localiser les fichiers .class
• Lire Bytecode
• Définissez une classe dans le JVM
• Résoudre les dépendances entre les classes

Chaque classe de Java est chargée par un chargeur de classe. Vous pouvez vérifier celui qui utilise:

 System.out.println (string.class.getClassloader ()); // retourne généralement null (bootstrap)
System.out.println (myClass.class.getClassloader ()); // Renvoie AppClassloader ou personnalisé

Remarque: null signifie que la classe a été chargée par le coloader Bootstrap , qui est implémenté dans le code natif.

Types de chargeurs de classe

Il y a trois chargeurs de classe intégrés dans le JVM:

1. Bootstrap classloader

• Chargeur de niveau supérieur, écrit en code natif (c / c)
• Charge Core Java Classes de rt.jar ou équivalent (par exemple, java.lang.* , java.util.* )
• Parent de tous les autres chargeurs de classe
• Impossible d'être directement référencé dans le code (renvoie null lorsqu'il est interrogé)

2. Extension (plate-forme) Classloader

• Child of bootstrap classloader
• Charge les classes du répertoire jre/lib/ext java.ext.dirs
• Dans JDKS plus récent (9), cela fait partie du chargeur de classe de plate-forme

3. Application (système) Classloader

• Charge les classes de l'application ClassPath ( CLASSPATH , -cp ou Class-Path dans Manifest)
• Chargeur par défaut pour les classes définies par l'utilisateur
• Accessible via ClassLoader.getSystemClassLoader()

Vous pouvez inspecter la hiérarchie:

 Classloadher cl = myClass.class.getClassloadher ();
tandis que (cl! = null) {
    System.out.println (CL);
    cl = cl.getparent ();
}

La sortie peut ressembler:

 Sun.Misc.Launcher$AppCLASSOLODER@18B4AAC2
Sun.Misc.Launcher$ExtClassLoader@60E53B93
null // bootstrap (natif)

Modèle de délégation: comment fonctionnent ensemble

Lorsqu'une classe est demandée, le Classloader suit une hiérarchie de délégation pour éviter de recharger les classes de base et d'assurer la sécurité.

Voici le flux:

1. La demande démarre sur le chargeur de classe d'application
2. Il délègue au chargeur de classe d'extension
3. Qui à son tour délégue à la classe Bootstrap
4. Bootstrap essaie de charger la classe des bibliothèques de base
5. Si cela n'est pas trouvé, la demande redescende la cha?ne jusqu'à ce qu'un chargeur le trouve
6. Si aucun chargeur ne le trouve, une ClassNotFoundException est lancée

Ce modèle garantit:

• Les classes de base ne peuvent pas être remplacées par le code utilisateur (sécurité)
• Les classes ne sont chargées qu'une seule fois (par le premier chargeur réussi)
• Empêche les conflits de duplication et de version

Vous pouvez remplacer ce comportement dans les chargeurs de classe personnalisés, mais cela casse la sécurité et est généralement découragé.

Classloaders personnalisés: quand et pourquoi les utiliser

Vous pourriez avoir besoin d'un chargeur de classe personnalisé lorsque:

• Chargement des classes à partir de sources non standard (réseau, base de données, fichiers chiffrés)
• Implémentation d'un déploiement à chaud (par exemple, des serveurs d'applications comme Tomcat)
• Création d'environnements isolés (plugins, OSGI, applications modulaires)
• Sandboxing Code non fiable

Pour en créer un, étendez java.lang.ClassLoader et remplacez findClass() :

 classe publique CustomClassloader étend classloader {
    @Outrepasser
    Class protégé <?> findClass (String Name) lève ClassNotFoundException {
        Byte [] classData = loadClassData (name); // Logique personnalisée pour lire Bytecode
        if (classData == null) {
            Jetez une nouvelle classe ClassNotFoundException ();
        }
        return Deficlass (name, classData, 0, classData.length);
    }

    octet privé [] loadclassData (String className) {
        // Lire le fichier .class à partir de la source personnalisée
        // par exemple, fichier, réseau, base de données
        retour ...;
    }
}

IMPORTANT: Utilisez defineClass() pour convertir le tableau d'octets en Class , mais ne le remplacez pas - appelez-le.

Rappelez-vous également:

• Remplacer findClass() , pas loadClass() sauf si vous souhaitez rompre la délégation
• Si vous devez casser la délégation (par exemple, pour un rechargement chaud), remplacez soigneusement loadClass()

Exemple de délégation de rupture (rare):

 @Outrepasser
public class <?> LoadClass (nom de cha?ne) lève ClassNotFoundException {
    if (name.startswith ("com.hotreload.")) {
        return FindClass (nom); // Chargez d&#39;abord, ne déléguez pas
    } autre {
        return super.loadClass (nom); // Délégation normale
    }
}

Ceci est utile dans les conteneurs Web où les classes d'applications Web doivent remplacer celles du système.

Pièges et meilleures pratiques courantes

1. ClassCastExceptions et LinkageError

Ceux-ci se produisent souvent lorsque la même classe est chargée de deux chargeurs de classe différents. Même si le bytecode est identique, JVM les considère comme différents types.

Exemple:

 // lève ClassCastException
(MyClass) AnotherClassloader.loadClass ("myClass"). NewInstance ();

Correction : assurez-vous que les classes utilisées sur les limites sont chargées par le même chargeur de classe (généralement parent).

2. Fuites de mémoire dans les serveurs d'application

Les applications Web qui rechargement provoquent souvent des fuites si:

• Les threads contiennent des références aux classes
• Les champs statiques conservent des données
• Les pilotes ou les auditeurs JDBC ne sont pas non enregistrés

Nettoyez toujours les ressources dans contextDestroyed() (pour servletContextListener).

3. Chargement des ressources: utilisez getResourceAsStream()

Préférez getClass().getResourceAsStream() ou getClassLoader().getResourceAsStream() au lieu de new FileInputStream() .

Pourquoi?

• Fonctionne si les fichiers sont dans des pots ou des répertoires
• Respecte la portée de ClassPath et Classloader

 InputStream est = getClass (). GetClassOader ()
    .getResourCeasStream ("config.properties");

4. Tire Context Classloadher

Parfois, le chargeur de classe par défaut n'est pas suffisant. Par exemple, JNDI ou JAXB peuvent avoir besoin de charger des classes d'applications à partir du code de niveau système.

Utiliser:

 Thread.currentThread (). SetContextClassloader (myClassloader);

Cela permet au code privilégié d'utiliser temporairement un Classloader défini par l'utilisateur.

Conclusion

Les chargeurs de classe sont plus que des mécanismes en coulisses - ils permettent la modularité, la sécurité et le comportement dynamique dans les applications Java. Comprendre le modèle de délégation, la hiérarchie et comment personnaliser en toute sécurité le comportement de chargement est essentiel pour le développement avancé de Java.

Bien que la plupart des applications n'aient jamais besoin d'un chargeur de classe personnalisée, savoir comment ils fonctionnent aide à déboguer ClassNotFoundException , NoClassDefFoundError et ClassCastException , en particulier dans des environnements complexes comme les serveurs d'applications, l'OSGI ou les microservices.

Fondamentalement, si vous avez affaire à des problèmes de chargement de classe, vérifiez:

• Quel chargedeur de classe a chargé ce
• Si la délégation fonctionne comme prévu
• Si la même classe est chargée plusieurs fois

Ce n'est pas magique - juste la hiérarchie et l'isolement.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!