L'injection de dépendance (DI) atteint le découplage à travers les dépendances des objets de contr?le externes, améliorant la testabilité du code, la maintenabilité et la flexibilité. 1. DI est un modèle de conception, et le noyau est de le créer par des dépendances entrantes externes plut?t que par des objets eux-mêmes; 2. Les méthodes d'injection courantes comprennent l'injection de constructeur (le plus couramment utilisée), l'injection de setter (applicable aux dépendances facultatives) et l'injection de champ (non recommandée); 3. DI peut être mis en ?uvre manuellement, comme les dépendances de passage à travers les constructeurs; 4. Utilisez le framework Spring pour simplifier la gestion des dépendances et gérer automatiquement les dépendances via @Component et @Autowired Annotations; 5. Faites attention à éviter les constructeurs complexes et les conflits de haricots, toutes les classes nécessitent la gestion du cadre. La ma?trise de ces points clés peut vous aider à appliquer DI dans Java plus efficacement.

La mise en ?uvre de l'injection de dépendance (DI) dans les applications Java est le c?ur de découplage des dépendances entre les composants et de séparer la création et l'utilisation d'objets. L'avantage de cela est d'améliorer la testabilité, la maintenabilité et la flexibilité du code. Si vous commencez tout juste à vous impliquer dans DI, vous pouvez le trouver un peu abstrait, mais en fait, vous pouvez facilement commencer en ma?trisant simplement quelques points clés.

Qu'est-ce que l'injection de dépendance? Pourquoi en avez-vous besoin?

L'injection de dépendance est un modèle de conception. Son idée principale est de contr?ler les dépendances de l'objet de l'extérieur, plut?t que de créer ou de trouver des dépendances par l'objet lui-même . Cela peut sembler un peu déroutant, pour un exemple simple:

Par exemple, vous disposez d'une classe EmailService utilisée par UserService . Si vous n'utilisez pas de DI, UserService peut directement nouveau une instance EmailService . Le problème avec cela est que si vous souhaitez modifier le service envoyé par SMS à l'avenir, vous devez modifier UserService .

Grace à l'injection de dépendance, vous pouvez transmettre EmailService en tant que paramètre au UserService , ou le cadre l'injectera automatiquement pour vous, réalisant ainsi un couplage lache.

Il existe trois méthodes d'injection de dépendance courantes:

• Injection de constructeur
• Injection de setter
• Injection de champ (non recommandée)

L'injection de constructeur est le plus souvent utilisée et est la plus facile à tester; L'injection de setter convient aux dépendances facultatives; L'injection de terrain est simple à écrire, mais elle n'est pas propice aux tests et à l'entretien, il est donc recommandé de l'utiliser moins.

Comment implémenter un DI simple manuellement?

Si vous ne souhaitez pas introduire des cadres comme Spring ou Dagger dès le début, vous pouvez également implémenter manuellement une logique d'injection de dépendance simple. Prenez l'injection de constructeur à titre d'exemple:

 Class EmailService {
    public void SendEmail (String to, String Message) {
        System.out.println ("Envoyer un e-mail à" à ":" Message);
    }
}

class userservice {
    EmailService privé EmailService;

    Public UserService (EmailService EmailService) {
        this.emailService = EmailService;
    }

    public void registerUser (cha?ne e-mail) {
        // faire quelque chose
        EmailService.Sendemail (e-mail, "Bienvenue!");
    }
}

Puis dans le programme principal:

 EmailService EmailService = nouveau e-mailservice ();
UserService userService = new UserService (e-mail);
userService.registerUser ("user@example.com");

Bien que "manuel", cette approche démontre clairement la nature des dépendances DI: ne sont pas créées en interne, mais passent de l'extérieur . Ceci est utile pour comprendre les principes de di.

Injection de dépendance à l'aide de Spring Framework

Une fois que le projet est devenu plus important, la gestion manuelle des dépendances deviendra lourde, et c'est le moment de simplifier ce processus à l'aide du framework Spring. Le printemps est l'un des conteneurs DI les plus traditionnels de l'écosystème Java.

Pour implémenter DI en utilisant le printemps, il y a deux étapes principales:

1. Ajoutez des annotations sur la classe pour indiquer quelles classes doivent être gérées par printemps
2. Injecter automatiquement les dépendances à l'aide de l'annotation @autowired

Continuez avec l'exemple ci-dessus:

 @Composant
Class EmailService {
    public void SendEmail (String to, String Message) {
        System.out.println ("Envoyer un e-mail à" à ":" Message);
    }
}

@Composant
class userservice {
    @Autowired
    EmailService privé EmailService;

    public void registerUser (cha?ne e-mail) {
        EmailService.Sendemail (e-mail, "Bienvenue!");
    }
}

Après le début du printemps, ces classes seront automatiquement analysées et les dépendances entre elles seront gérées. Il vous suffit de vous concentrer sur la logique métier.

Quelques points à noter:

• Ne faites pas trop d'opérations compliquées dans le constructeur, car elle peut facilement entra?ner une défaillance d'initialisation.
• Essayez d'éviter plusieurs conflits de haricots, qui peuvent être spécifiés explicitement via @primary ou @qualifier
• Si vous essayez de l'injecter dans une classe non gérée par le ressort, cela ne prendra pas en vigueur

Conseils: ne comptez pas trop sur les cadres

Bien que les cadres comme Spring soient très utiles, les cadres DI ne sont pas nécessairement requis dans certains petits projets ou classes d'outils. La mise en ?uvre manuelle de l'injection de dépendance est parfois plus intuitive et plus facile à déboguer.

De plus, certains développeurs sont habitués à ajouter @Component ou @Service à chaque classe, mais en fait, toutes les classes ne doivent pas être gérées par des conteneurs. Seules les classes qui doivent être utilisées par d'autres composants doivent être remises au printemps.

Pour résumer:

• Identifiez les classes à injecter et quelles ne sont que des classes auxiliaires ordinaires
• L'injection de constructeur est le moyen le plus clair
• Le framework est un outil, ne l'utilisez pas pour le plaisir

Fondamentalement, c'est tout. Si vous ma?trisez bien ces points, il ne sera pas trop difficile d'appliquer DI dans Java.

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!