L'injection de dépendance (DI) est un modèle de conception où les objets re?oivent des dépendances à l'extérieur, favorisant un couplage lache et des tests plus faciles via le constructeur, le secteur ou l'injection de champ. 2. Spring Framework utilise des annotations comme @Component, @Service et @Autowired avec une configuration basée sur Java via @configuration et @bean, prend en charge la numérisation des composants et met l'accent sur l'injection de constructeurs, les profils et la configuration modulaire pour les applications d'entreprise. 3. Google Guice s'appuie sur les modules étendant l'abstractmodule pour définir les liaisons, utilise l'injecteur pour la création d'objets, prend en charge l'injection de constructeur avec @inject et propose des liaisons du fournisseur, des portées, une injection assistée et une résolution juste en temps pour des applications légères et haute performance. 4. Choisissez Spring pour le développement de l'entreprise complète avec des intégrations étendues et une prise en charge des écosystèmes, ou Guice pour les frais généraux minimaux, la configuration explicite et le démarrage rapide dans les microservices ou les outils CLI. 5. Les meilleures pratiques incluent la faveur des interfaces, d'éviter les dépendances circulaires à l'aide de @lazy ou de fournisseur , d'écriture de tests unitaires avec des dépendances moquées, de comprendre les portées de bean et d'organiser les configurations dans des modules logiques pour améliorer la maintenabilité, l'évolutivité et la testabilité dans les applications Java.

L'injection de dépendance (DI) est un concept de base dans le développement de Java moderne, permettant un code plus propre, plus modulaire et testable. Deux des cadres les plus populaires qui implémentent DI sont Spring et Google Guice . Bien qu'ils servent des fins similaires, leurs approches, configurations et écosystèmes diffèrent. Explorons comment ma?triser l'injection de dépendance en utilisant les deux, en mettant en évidence les modèles clés, les meilleures pratiques et les exemples pratiques.

1. Comprendre les bases de l'injection de dépendance

Avant de plonger dans des cadres, il est important de comprendre ce qu'est DI:

• L'injection de dépendance est un modèle de conception où les objets re?oivent leurs dépendances d'une source externe plut?t que de les créer en interne.
• Il favorise le couplage lache , la réutilisabilité et les tests plus faciles .
• Les trois principaux types sont:
  • Injection de constructeur
  • Injection de setter
  • Injection de champ (non recommandée pour la production)

Exemple sans DI:

 classe publique OrderService {
    PAYS PAYSGATEWAYAY GATEWAY = NOUVEAU STREPAYPAYMENTGATEWAY (); // couplage serré
}

Avec di:

 classe publique OrderService {
    PAYAGE PAYS PAYS PAYAGE PRIVéE;

    ORDERSERVICE PUBLIQUE (PAYSGATEWAY GATEWAY) {
        this.gateway = gateway; // injecté
    }
}

Maintenant, voyons comment Spring et Guice gèrent cela.

2. Mastering di with printemps framework

Spring est le cadre Java le plus utilisé pour les applications d'entreprise. Son conteneur DI fait partie du module de noyau de ressort.

Concepts clés du printemps di

• Beans : objets gérés par le conteneur Spring IOC.
• @Component, @Service, @Repository : Annotations de stéréotype pour marquer les classes sous forme de beans.
• @Autowired : Injecte les dépendances automatiquement (peut être utilisée sur les constructeurs, les setters ou les champs).
• @Configuration et @Bean : Alternative de configuration basée sur Java à XML.

Exemple: Spring Di avec annotations

 @Composant
classe publique EmailService implémente NotificationsService {
    public void Send (message de cha?ne) {
        System.out.println ("Email envoyé:" Message);
    }
}

@Service
classe publique UserService {
    notifications finales privées notifications pourvice;

    // injection de constructeur (recommandé)
    Public UserService (NotificationsVice NotificationsService) {
        this.notificationsservice = notificationsservice;
    }

    Registre publique de void (courriel de cha?ne) {
        // Logique commerciale
        notificationsservice.send ("Bienvenue!");
    }
}

Activer la numérisation des composants en configuration:

 @Configuration
@Componentscan (basepackages = "com.example")
classe publique AppConfig {
}

Bootstrap (méthode principale):

 classe publique Main {
    public static void main (String [] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext (AppConfig.class);
        UserService userservice = context.getBean (userService.class);
        userservice.register ("user@example.com");
    }
}

Meilleures pratiques au printemps

• Préférez l'injection du constructeur à l'injection de champ.
• Utilisez @Primary ou @qualifier lorsque plusieurs haricots du même type existent.
• Profiles de levier ( @Profile ) pour les haricots spécifiques à l'environnement.
• Gardez la configuration propre avec les classes @Configuration modulaires.

3. Master DI avec Google Guice

Guice est un cadre DI léger et rapide de Google. Il utilise le code Java (pas de XML) et met l'accent sur la simplicité et les performances.

Concepts clés de Guice

• Module : une classe étendant AbstractModule où les liaisons sont définies.
• Injecteur : crée et injecte des dépendances.
• Liaison : définit quelle implémentation doit être utilisée pour une interface.

Exemple: Configuration de Guice di

Définissez une interface et une implémentation:

 Notifications Interface Cervice {
    void Send (message de cha?ne);
}

classe publique SMSService implémente NotificationsService {
    public void Send (message de cha?ne) {
        System.out.println ("SMS envoyé:" Message);
    }
}

Créez un module pour lier les dépendances:

 La classe publique Appmodule étend AbstractModule {
    @Outrepasser
    Protected void configure () {
        lier (notificationsservice.class) .to (smsService.class);
    }
}

Injecter et utiliser:

 classe publique UserService {
    notifications finales privées notifications pourvice;

    @Injecter
    Public UserService (NotificationsVice NotificationsService) {
        this.notificationsservice = notificationsservice;
    }

    Registre public void (téléphone de cha?ne) {
        notificationsservice.send ("Bienvenue!");
    }
}

Méthode principale avec l'injecteur de Guice:

 classe publique Main {
    public static void main (String [] args) {
        Injecteur injecteur = Guice.CreateInjector (new AppModule ());
        UserService userService = injector.getInstance (userService.class);
        userService.Register ("123456789");
    }
}

Caractéristiques de Guice avancées

• Beau des fournisseurs : pour une instanciation paresseuse ou complexe.
• Scopes : @Singleton , Scopes personnalisées.
• Injection assistée : pour les objets nécessitant des paramètres d'exécution.
• Régales juste à temps : Guice peut se résoudre automatiquement les liaisons si sans ambigu?té.

4. Spring vs Guice: Quand utiliser lequel?

Utilisez le printemps si:

• Vous créez une application Web complète (Spring Boot).
• Vous avez besoin d'intégration avec les bases de données, la sécurité, la messagerie, etc.
• Votre équipe conna?t déjà le printemps.

Utilisez Guice si:

• Vous voulez des frais généraux minimaux (par exemple, microservices, outils CLI).
• Vous préférez la configuration propre et explicite.
• Vous appréciez le démarrage rapide et le co?t d'exécution faible.

Conseils finaux pour ma?triser DI

• Favoriser les interfaces par rapport aux classes de béton - facilite l'échange d'implémentations.
• évitez les dépendances circulaires - refacteur ou utilisez @Lazy (printemps) ou Provider<t></t> (les deux).
• écrivez des tests unitaires - DI rend les dépendances moqueuses simples.
• Comprendre Scopes : Singleton vs Prototype vs Beans Scoped Beans.
• Gardez les modules / configurations organisés - liaisons liées au groupe.

DI n'est pas seulement une fonction de framework - c'est un état d'esprit. Que vous choisissiez le ressort pour sa puissance ou son guice pour sa simplicité, la ma?trise de l'injection de dépendance rendra vos applications Java plus maintenables, évolutives et testables.

Fondamentalement, commencez petit, injectez de manière responsable et laissez le récipient faire le cablage.

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!