Spring exemple faiblement couplé

Exemple à couplage libre avec ressort

Le concept orienté objet est une bonne conception pour diviser votre système en un groupe d'objets réutilisables. Cependant, lorsque le système s'agrandit, en particulier dans les projets Java, les énormes dépendances d'objets sont toujours étroitement couplées, ce qui rend les objets très difficiles à gérer ou à modifier. Dans ce scénario, vous pouvez utiliser le framework Spring pour agir comme un module central pour gérer toutes les dépendances d'objet facilement et efficacement.

Exemple de générateur de sortie

Voyons un exemple, supposons que votre projet possède une fonction pour sortir le contenu au format Csv ou Json. Votre code peut ressembler à l'exemple suivant:

Fichier: IOutputGenerator.java - Une interface pour le générateur de sortie

package com.example.output;

public interface IOutputGenerator
{
    public void generateOutput();
}

Fichier: CsvOutputGenerator.java - Un générateur de sortie Csv pour implémenter l'interface IOutputGenerator.

package com.example.output.impl;

import com.example.output.IOutputGenerator;

public class CsvOutputGenerator implements IOutputGenerator
{
    public void generateOutput(){
        System.out.println("Csv Output Generator");
    }
}

Fichier: JsonOutputGenerator.java - Un générateur de sortie Json pour implémenter l'interface IOutputGenerator.

package com.example.output.impl;

import com.example.output.IOutputGenerator;

public class JsonOutputGenerator implements IOutputGenerator
{
    public void generateOutput(){
        System.out.println("Json Output Generator");
    }
}

Il existe plusieurs façons d'appeler IOutputGenerator et d'utiliser Spring pour éviter que les objets ne se couplent étroitement les uns aux autres.

1. Méthode 1 - Appelez-le directement

De façon normale, appelez-le directement.

package com.example.common;

import com.example.output.IOutputGenerator;
import com.example.output.impl.CsvOutputGenerator;

public class App
{
    public static void main( String[] args )
    {
        IOutputGenerator output = new CsvOutputGenerator();
        output.generateOutput();
    }
}

Problem
De cette façon, le problème est que la «sortie» est étroitement couplée à CsvOutputGenerator, chaque changement de générateur de sortie peut impliquer un changement de code. Si ce code est dispersé dans tout votre projet, chaque changement du générateur de sortie vous fera sérieusement souffrir.

Méthode 2 - Appelez-la avec la classe d'assistance

Vous pouvez penser à créer une classe d'assistance pour déplacer toute l'implémentation de sortie à l'intérieur.

package com.example.output;

import com.example.output.IOutputGenerator;
import com.example.output.impl.CsvOutputGenerator;

public class OutputHelper
{
    IOutputGenerator outputGenerator;

    public OutputHelper(){
        outputGenerator = new CsvOutputGenerator();
    }

    public void generateOutput(){
        outputGenerator.generateOutput();
    }

}

Appelez-le via la classe d'assistance.

package com.example.common;

import com.example.output.OutputHelper;

public class App
{
    public static void main( String[] args )
    {
        OutputHelper output = new OutputHelper();
        output.generateOutput();
    }
}

Problem
Cela a l'air plus élégant, et vous n'avez besoin de gérer qu'une seule classe d'assistance, cependant la classe d'assistance est toujours étroitement couplée à CsvOutputGenerator, chaque changement de générateur de sortie implique toujours un changement de code mineur.

Méthode 3 - Printemps

Dans ce scénario, Spring Dependency Injection (DI) est un bon choix. Le ressort peut rendre votre générateur de sortie faiblement couplé au générateur de sortie.

Changement mineur dans la classe OutputHelper.

package com.example.output;

import com.example.output.IOutputGenerator;

public class OutputHelper
{
    IOutputGenerator outputGenerator;

    public void generateOutput(){
        outputGenerator.generateOutput();
    }

    public void setOutputGenerator(IOutputGenerator outputGenerator){
        this.outputGenerator = outputGenerator;
    }
}

Créez un fichier de configuration Spring Bean et déclarez toutes vos dépendances d'objet Java ici.

Appelez-le via Spring

package com.example.common;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.example.output.OutputHelper;

public class App
{
    public static void main( String[] args )
    {
        ApplicationContext context =
           new ClassPathXmlApplicationContext(new String[] {"Spring-Common.xml"});

        OutputHelper output = (OutputHelper)context.getBean("OutputHelper");
        output.generateOutput();

    }
}

Maintenant, il vous suffit de modifier le fichier XML Spring pour un générateur de sortie différent. Lorsque la sortie a été modifiée, vous devez uniquement modifier le fichier XML Spring, aucun code modifié, ce qui signifie moins d'erreur.

Conclusion

Avec Spring Framework - Dependency Injection (DI) est une fonctionnalité utile pour la gestion des dépendances d'objets, il est simplement élégant, très flexible et facilite la maintenabilité, en particulier dans les grands projets Java.

TOC