Un ejemplo de arquitectura hexagonal en Java

Introducción a la arquitectura hexagonal

• Dominio . La capa contiene la lógica empresarial central. No necesita conocer los detalles de la implementación de las capas externas.
• Aplicación . Una capa actúa como un puente entre las capas de un dominio y la infraestructura.
• Infraestructura . La implementación de la interacción del dominio con el mundo exterior. Las capas internas le parecen una caja negra.

Ejemplo

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")));
    }
}

Dominio

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;
    }
}

Adaptadores de puerto de control

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);
    }
}

solicitud

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);
    }

}

Lo que se puede mejorar, cambiar

• En nuestra implementación, puede cambiar fácilmente de un almacén de datos a otro. La implementación de almacenamiento se puede inyectar en el código sin cambiar la lógica empresarial. Por ejemplo, puede transferir datos de la memoria a una base de datos escribiendo un adaptador de base de datos.
• En lugar de enviarlo a la consola, puede implementar una "impresora", que escribirá datos en un archivo. En una aplicación de múltiples capas de este tipo, resulta más fácil agregar funcionalidad y corregir errores.
• Para probar la lógica empresarial, puede escribir pruebas complejas. Los adaptadores se pueden probar de forma aislada. Por lo tanto, es posible aumentar la cobertura general de la prueba.

Conclusión

• Acompañamiento : capas sueltas e independientes. Se vuelve fácil agregar nuevas características a una capa sin afectar a otras capas.
• Testabilidad : las pruebas unitarias se escriben de forma simple y rápida. Puede escribir pruebas para cada capa utilizando objetos de código auxiliar que simulan dependencias. Por ejemplo, podemos eliminar la dependencia de la base de datos haciendo un almacén de datos en la memoria.
• Adaptabilidad : la lógica empresarial principal se vuelve independiente de los cambios en los objetos externos. Por ejemplo, si necesita migrar a otra base de datos, no es necesario que realicemos cambios en el dominio. Podemos hacer un adaptador apropiado para la base de datos.

Referencias

• Arquitectura Hexagonal (Alistair Cockburn)
• Arquitectura Hexagonal-Wiki
• Arquitectura de puertos y adaptadores
• Giphy