Un exemple d'architecture hexagonale en Java

Introduction à l'architecture hexagonale

• Domaine . La couche contient la logique métier principale. Il n'a pas besoin de connaître les détails de la mise en œuvre des couches extérieures.
• Application . Une couche agit comme un pont entre les couches d'un domaine et de l'infrastructure.
• Infrastructure . La mise en œuvre de l'interaction du domaine avec le monde extérieur. Les couches intérieures lui ressemblent comme une boîte noire.

Exemple

public interface IUserInput {
    public void handleUserInput(Object userCommand);
}

public interface IFetchMovieReviews {
    public List<MovieReview> fetchMovieReviews(MovieSearchRequest movieSearchRequest);
}

public interface IPrintMovieReviews {
    public void writeMovieReviews(List<MovieReview> movieReviewList);
}

public class ConsolePrinter implements IPrintMovieReviews {
    @Override
    public void writeMovieReviews(List<MovieReview> movieReviewList) {
        movieReviewList.forEach(movieReview -> {
            System.out.println(movieReview.toString());
        });
    }
}

public class MovieReviewsRepo implements IFetchMovieReviews {
    private Map<String, List<MovieReview>> movieReviewMap;

    public MovieReviewsRepo() {
        initialize();
    }

    public List<MovieReview> fetchMovieReviews(MovieSearchRequest movieSearchRequest) {

        return Optional.ofNullable(movieReviewMap.get(movieSearchRequest.getMovieName()))
            .orElse(new ArrayList<>());
    }

    private void initialize() {
        this.movieReviewMap = new HashMap<>();
        movieReviewMap.put("StarWars", Collections.singletonList(new MovieReview("1", 7.5, "Good")));
        movieReviewMap.put("StarTreck", Arrays.asList(new MovieReview("1", 9.5, "Excellent"), new MovieReview("1", 8.5, "Good")));
    }
}

Domaine

public class MovieApp implements Consumer<MovieSearchRequest> {
    private IFetchMovieReviews fetchMovieReviews;
    private IPrintMovieReviews printMovieReviews;
    private static Random rand = new Random();

    public MovieApp(IFetchMovieReviews fetchMovieReviews, IPrintMovieReviews printMovieReviews) {
        this.fetchMovieReviews = fetchMovieReviews;
        this.printMovieReviews = printMovieReviews;
    }

    private List<MovieReview> filterRandomReviews(List<MovieReview> movieReviewList) {
        List<MovieReview> result = new ArrayList<MovieReview>();
        // logic to return random reviews
        for (int index = 0; index < 5; ++index) {
            if (movieReviewList.size() < 1)
                break;
            int randomIndex = getRandomElement(movieReviewList.size());
            MovieReview movieReview = movieReviewList.get(randomIndex);
            movieReviewList.remove(movieReview);
            result.add(movieReview);
        }
        return result;
    }

    private int getRandomElement(int size) {
        return rand.nextInt(size);
    }

    public void accept(MovieSearchRequest movieSearchRequest) {
        List<MovieReview> movieReviewList = fetchMovieReviews.fetchMovieReviews(movieSearchRequest);
        List<MovieReview> randomReviews = filterRandomReviews(new ArrayList<>(movieReviewList));
        printMovieReviews.writeMovieReviews(randomReviews);
    }
}

public class CommandMapperModel {
    private static final Class<MovieSearchRequest> searchMovies = MovieSearchRequest.class;

    public static Model build(Consumer<MovieSearchRequest> displayMovies) {
        Model model = Model.builder()
            .user(searchMovies)
            .system(displayMovies)
            .build();

        return model;
    }
}

Adaptateurs de port de contrôle

public class UserCommandBoundary implements IUserInput {
    private Model model;

    public UserCommandBoundary(IFetchMovieReviews fetchMovieReviews, IPrintMovieReviews printMovieReviews) {
        MovieApp movieApp = new MovieApp(fetchMovieReviews, printMovieReviews);
        model = CommandMapperModel.build(movieApp);
    }

    public void handleUserInput(Object userCommand) {
        new ModelRunner().run(model)
            .reactTo(userCommand);
    }
}

public class MovieUser {
    private IUserInput userInputDriverPort;

    public MovieUser(IUserInput userInputDriverPort) {
        this.userInputDriverPort = userInputDriverPort;
    }

    public void processInput(MovieSearchRequest movieSearchRequest) {
        userInputDriverPort.handleUserInput(movieSearchRequest);
    }
}

application

public class Main {

    public static void main(String[] args) {
        IFetchMovieReviews fetchMovieReviews = new MovieReviewsRepo();
        IPrintMovieReviews printMovieReviews = new ConsolePrinter();
        IUserInput userCommandBoundary = new UserCommandBoundary(fetchMovieReviews, printMovieReviews);
        MovieUser movieUser = new MovieUser(userCommandBoundary);
        MovieSearchRequest starWarsRequest = new MovieSearchRequest("StarWars");
        MovieSearchRequest starTreckRequest = new MovieSearchRequest("StarTreck");

        System.out.println("Displaying reviews for movie " + starTreckRequest.getMovieName());
        movieUser.processInput(starTreckRequest);
        System.out.println("Displaying reviews for movie " + starWarsRequest.getMovieName());
        movieUser.processInput(starWarsRequest);
    }

}

Ce qui peut être amélioré, changé

• Dans notre implémentation, vous pouvez facilement passer d'un magasin de données à un autre. L'implémentation du stockage peut être injectée dans le code sans changer la logique métier. Par exemple, vous pouvez transférer des données de la mémoire vers une base de données en écrivant un adaptateur de base de données.
• Au lieu de sortir sur la console, vous pouvez implémenter une «imprimante», qui écrira des données dans un fichier. Dans une telle application multicouche, il devient plus facile d'ajouter des fonctionnalités et de corriger des bogues.
• Pour tester la logique métier, vous pouvez écrire des tests complexes. Les adaptateurs peuvent être testés isolément. Ainsi, il est possible d'augmenter la couverture globale des tests.

Conclusion

• Accompagnement - Couches à couplage lâche et indépendantes. Il devient facile d'ajouter de nouvelles fonctionnalités à une couche sans affecter les autres couches.
• Testabilité - les tests unitaires sont écrits de manière simple et rapide. Vous pouvez écrire des tests pour chaque couche à l'aide d'objets de stub qui simulent des dépendances. Par exemple, nous pouvons supprimer la dépendance à la base de données en créant un entrepôt de données en mémoire.
• Adaptabilité - la logique métier principale devient indépendante des changements dans les objets externes. Par exemple, si vous devez migrer vers une autre base de données, nous n'avons pas besoin de modifier le domaine. Nous pouvons créer un adaptateur approprié pour la base de données.

Références

• Architecture hexagonale (Alistair Cockburn)
• Architecture hexagonale-Wiki
• Architecture des ports et adaptateurs
• Giphy