जावा में हेक्सागोनल वास्तुकला का एक उदाहरण

हेक्सागोनल वास्तुकला का परिचय

• डोमेन । परत में मुख्य व्यावसायिक तर्क होता है। उसे बाहरी परतों के कार्यान्वयन के विवरण को जानने की आवश्यकता नहीं है।
• आवेदन । एक परत एक डोमेन और बुनियादी ढांचे की परतों के बीच एक सेतु का काम करती है।
• अवसंरचना । बाहरी दुनिया के साथ डोमेन की बातचीत का कार्यान्वयन। भीतर की परतें उसे एक ब्लैक बॉक्स की तरह लगती हैं।

उदाहरण

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

डोमेन

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

पोर्ट एडेप्टर को नियंत्रित करें

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

आवेदन

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

}

क्या सुधार, बदला जा सकता है

• हमारे कार्यान्वयन में, आप आसानी से एक डेटा स्टोर से दूसरे में स्विच कर सकते हैं। स्टोरेज कार्यान्वयन को व्यावसायिक तर्क को बदले बिना कोड में इंजेक्ट किया जा सकता है। उदाहरण के लिए, आप डेटाबेस एडेप्टर लिखकर मेमोरी से डेटा को डेटाबेस में स्थानांतरित कर सकते हैं।
• कंसोल के आउटपुट के बजाय, आप "प्रिंटर" लागू कर सकते हैं, जो फ़ाइल में डेटा लिखेगा। ऐसे बहु-परत अनुप्रयोग में, कार्यक्षमता जोड़ना और बग को ठीक करना आसान हो जाता है।
• व्यावसायिक तर्क का परीक्षण करने के लिए, आप जटिल परीक्षण लिख सकते हैं। एडाप्टरों का अलगाव में परीक्षण किया जा सकता है। इस प्रकार, समग्र परीक्षण कवरेज को बढ़ाना संभव है।

निष्कर्ष

• Accompaniment - शिथिल युग्मित और स्वतंत्र परतें। अन्य परतों को प्रभावित किए बिना एक परत में नई सुविधाओं को जोड़ना आसान हो जाता है।
• परीक्षण क्षमता - इकाई परीक्षण सरल और शीघ्रता से लिखे गए हैं। आप स्टब ऑब्जेक्ट्स का उपयोग करके प्रत्येक परत के लिए परीक्षण लिख सकते हैं जो निर्भरता का अनुकरण करते हैं। उदाहरण के लिए, हम मेमोरी में डेटा वेयरहाउस बनाकर डेटाबेस पर निर्भरता को हटा सकते हैं।
• अनुकूलनशीलता - मुख्य व्यावसायिक तर्क बाहरी वस्तुओं में परिवर्तन से स्वतंत्र हो जाता है। उदाहरण के लिए, यदि आपको किसी अन्य डेटाबेस में माइग्रेट करने की आवश्यकता है, तो हमें डोमेन में परिवर्तन करने की आवश्यकता नहीं है। हम डेटाबेस के लिए एक उपयुक्त एडाप्टर बना सकते हैं।

संदर्भ

• हेक्सागोनल आर्किटेक्चर (एलिस्टेयर कॉकबर्न)
• हेक्सागोनल आर्किटेक्चर-विकी
• पोर्ट्स एंड एडेप्टर आर्किटेक्चर
• Giphy