Wzór MVC na Androida

Nie ma uniwersalnie unikalnego wzorca MVC. MVC jest koncepcją, a nie solidnym frameworkiem programistycznym. Możesz zaimplementować swój własny MVC na dowolnej platformie. Tak długo, jak trzymasz się następującego podstawowego pomysłu, implementujesz MVC:

• Model: Co renderować
• widok: Jak renderować
• Controller: Events, user input

Pomyśl też o tym w ten sposób: gdy zaprogramujesz swój model, model nie powinien martwić się o renderowanie (lub kod specyficzny dla platformy). Model powiedziałby do widoku, nie obchodzi mnie, Czy twój rendering to Android, iOS lub Windows Phone, to jest to, czego potrzebuję do renderowania. Widok obsługiwałby tylko kod renderujący specyficzny dla platformy.

Jest to szczególnie przydatne, gdy używa się Mono do współdzielenia modelu w celu tworzenia aplikacji wieloplatformowych.

Akcje, widoki i działania na Androidzie są pieczonym sposobem pracy z interfejsem użytkownika Androida i są implementacją wzorca model–view–viewmodel (MVVM) , który jest strukturalnie podobny (w tej samej rodzinie co) Model–view–controller.

Z tego, co wiem, nie ma sposobu, aby wyrwać się z tego modelu. Prawdopodobnie można to zrobić, ale prawdopodobnie stracisz wszystkie korzyści, jakie ma istniejący model i będziesz musiał przepisać własną warstwę interfejsu, aby to zrobić praca.

Po kilku poszukiwaniach, najbardziej rozsądną odpowiedzią jest:

MVC jest już zaimplementowany w Androidzie jako:

1. View = layout, zasoby i wbudowane klasy, takie jak Button pochodzące z android.view.View.
2. Controller = Activity
3. Model = klasy implementujące logikę aplikacji

(to przy okazji oznacza brak logiki domeny aplikacji w aktywności.)

Najbardziej rozsądną rzeczą dla małego dewelopera jest podążanie za tym wzorzec i nie próbować robić tego, czego Google postanowiło nie robić.

PS zauważ, że aktywność jest czasami restartowana, więc nie ma miejsca na dane modelu (najprostszym sposobem na ponowne uruchomienie jest pominięcie android:configChanges="keyboardHidden|orientation" z XML i włączenie urządzenia).

EDIT

Możemy mówić o MVC , Ale tak będzie FMVC, Framework--Model--View--Controller . Framework (Android OS) narzuca swoją ideę cyklu życia komponentów i pokrewnych zdarzenia, a w praktyce Kontroler (Activity/Service/BroadcastReceiver) jest przede wszystkim odpowiedzialny za radzenie sobie z tymi Framework-narzuconymi zdarzeniami (takimi jak onCreate()). Czy dane wejściowe użytkownika powinny być przetwarzane oddzielnie? Nawet jeśli tak, nie można go oddzielić, zdarzenia wprowadzania danych użytkownika pochodzą również z Androida.

W każdym razie, mniej kodu, który nie jest specyficzny dla Androida, włożysz do swojego Activity/Service/BroadcastReceiver, tym lepiej.

Nie ma jednego wzorca MVC, który mógłby być posłuszny. MVC po prostu stwierdza mniej więcej, że nie należy mieszać danych i widoku, tak że np. widoki są odpowiedzialne za przechowywanie danych lub klasy, które przetwarzają dane, mają bezpośredni wpływ na widok.

Niemniej jednak, sposób w jaki Android radzi sobie z klasami i zasobami, czasami jesteś nawet zmuszony do podążania za wzorcem MVC. Bardziej skomplikowane moim zdaniem są działania, które są odpowiedzialne czasami za pogląd, ale mimo to w tym samym czasie działać jako administrator danych.

Jeśli definiujesz widoki i układy w plikach XML, ładujesz zasoby z folderu res, a jeśli unikasz mniej więcej mieszania tych rzeczy w kodzie, to i tak postępujesz zgodnie ze wzorem MVC.

Najlepszy zasób znalazłem zaimplementować MVC na Androida jest Ten post :

Wykonałem ten sam projekt dla jednego z moich projektów i zadziałał świetnie. Jestem początkującym na Androidzie, więc nie mogę powiedzieć, że jest to najlepsze rozwiązanie.

Dokonałem jednej modyfikacji: stworzyłem instancję modelu i kontrolera dla każdej aktywności w klasie aplikacji, aby nie były one odtwarzane, gdy zmieni się tryb poziomo-pionowy.

Możesz zaimplementować MVC w Androidzie, ale nie jest to "natywnie obsługiwane" i wymaga trochę wysiłku.

To powiedziawszy, osobiście skłaniam się w stronę MVP jako znacznie czystszy wzór architektoniczny dla rozwoju Androida. A mówiąc MVP mam na myśli to:

Zamieściłem również bardziej szczegółową odpowiedź tutaj .

Po zabawie z różnymi podejściami do implementacji MVC/MVP w Androidzie, wymyśliłem rozsądny wzór architektoniczny, który opisane w tym poście: wzorce architektoniczne MVP i MVC w Androidzie .

Zgadzam się z JDPeckham i uważam, że sam XML nie jest wystarczający do implementacji części UI aplikacji.

Jeśli jednak uznasz działanie za część widoku, implementacja MVC jest dość prosta. Możesz nadpisać aplikację (zwracaną przez getApplication () w Activity) i to tutaj możesz utworzyć kontroler, który przetrwa cały czas życia twojej aplikacji.

(Alternatywnie można użyć wzoru Singletona zgodnie z sugestią dokumentacja aplikacji)

Tworzenie interfejsu użytkownika Androida przy użyciu układów, zasobów, działań i intencji jest implementacją wzorca MVC. Zobacz poniższy link, aby uzyskać więcej informacji na ten temat - http://www.cs.otago.ac.nz/cosc346/labs/COSC346-lab2.2up.pdf

Lustro do pdf

MVC-Architektura na Androida Its Better to Follow Any MVP zamiast MVC w Androidzie. Ale nadal zgodnie z odpowiedzią na pytanie może to być rozwiązanie

Opis i wytyczne

     Controller -
        Activity can play the role.
        Use an application class to write the
        global methods and define, and avoid
        static variables in the controller label
    Model -
        Entity like - user, Product, and Customer class.
    View -
        XML layout files.
    ViewModel -
        Class with like CartItem and owner
        models with multiple class properties
    Service -
        DataService- All the tables which have logic
        to get the data to bind the models - UserTable,
        CustomerTable
        NetworkService - Service logic binds the
        logic with network call - Login Service
Helpers -
        StringHelper, ValidationHelper static
        methods for helping format and validation code.
SharedView - fragmets or shared views from the code
        can be separated here

AppConstant -
        Use the Values folder XML files
        for constant app level

Uwaga 1:

Oto kawałek magii, który możesz zrobić. Po zaklasyfikowaniu fragmentu kodu, napisz podstawową klasę interfejsu, np. Zadeklarować wspólne metody. Teraz Utwórz klasa abstrakcyjna BaseService I declare własny zestaw metod i mają oddzielenie kodu.

Uwaga 2: Jeśli Twoja aktywność przedstawia wiele modeli, to zamiast pisać kod/logikę w aktywności, lepiej jest podzielić widoki na fragmenty. Więc jest lepiej. Tak więc w przyszłości, jeśli potrzebny będzie jakiś więcej modeli, aby pokazać się w widoku, dodaj jeszcze jeden fragment.

Uwaga 3: separacja kodu jest bardzo ważna. Każdy element architektury powinien być niezależne nie posiadające logiki zależnej. Jeśli przypadkiem masz coś zależnego od logiki, napisz klasę logiki mapowania pomiędzy. To ci pomoże w przyszłości.

Chociaż ten post wydaje się być Stary, chciałbym dodać dwa poniższe, aby poinformować o niedawnym rozwoju w tej dziedzinie dla Androida:

Android-Wiązanie - zapewnienie ramy, która umożliwia powiązanie widżetów widoku Androida z modelem danych. Pomaga zaimplementować wzorce MVC lub MVVM w aplikacjach na Androida.

Roboguice - RoboGuice nie wymaga zgadywania w rozwoju. Wstrzyknąć swój Widok, zasób, usługę systemową lub jakikolwiek inny obiekt, a pozwól RoboGuice zadbać o szczegóły.

Wzór MVC Androida jest (tak jakby) zaimplementowany z ich klasami Adapter. Zastępują one kontroler "adapterem"."Opis adaptera stwierdza:

Obiekt adaptera działa jako mostek między widokiem adaptera a podstawowe dane dla tego widoku.

Właśnie sprawdzam to dla aplikacji na Androida, która czyta z bazy danych, więc nie wiem, jak dobrze to działa. Jednak wydaje się to trochę podobne do Qt Model-View-Delegate architektura, która według nich jest krokiem w górę od tradycyjnego wzorca MVC. Przynajmniej na PC, wzór Qt działa dość dobrze.

Model View Controller (MVC)

Opis:

• gdy mamy do głównych dużych projektów w rozwoju oprogramowania, MVC jest powszechnie stosowany, ponieważ jest to uniwersalny sposób organizacji projekty.
• nowi programiści mogą szybko dostosować się do projektu
• pomaga w rozwoju dużych projektów i cross platform zbyt.

Wzór MVC jest zasadniczo taki:

• Model: Co wyświetlać. Może to być źródło danych (np. serwer, Raw dane w aplikacji)
• widok: Jak to jest wyświetlane. Może to być xml. Działa więc jako filtr prezentacji. Widok jest dołączony do jego modelu (lub części modelu) i pobiera dane niezbędne do prezentacji.
• Kontroler: Obsługa zdarzeń takich jak wprowadzanie danych przez użytkownika. To jest aktywność

Ważna cecha MVC: możemy modyfikować Model lub widok lub kontroler nadal nie wpływający Pozostałe

• powiedzmy, że zmieniamy kolor w widoku, rozmiar widoku lub pozycję widok. W ten sposób nie wpłynie to na model ani kontroler
• powiedzmy, że zmieniamy model (zamiast danych pobieranych z serwera pobieranie danych z zasobów) nadal nie wpłynie to na widok i controller
• powiedzmy, że zmienimy Kontroler (logikę w aktywności), który nie wpłynie model i widok

Myślę, że najbardziej przydatne uproszczone wyjaśnienie jest tutaj: http://www.cs.otago.ac.nz/cosc346/labs/COSC346-lab2.2up.pdf

Z wszystkiego, co tu widziałem i czytałem, implementacja tych wszystkich rzeczy utrudnia i nie pasuje dobrze do innych części Androida.

Wykonywanie aktywności przez innych słuchaczy jest już standardowym sposobem na Androida. Najbardziej nieszkodliwym sposobem byłoby dodanie Java Observer jak slajdy opisują i grupują onClick i inne rodzaje działań na funkcje, które są nadal w aktywności.

Android sposób jest, że aktywność robi oba. Walka z nim tak naprawdę nie ułatwia rozszerzania lub robienia przyszłego kodowania.

Zgadzam się z drugim postem . To już jest zaimplementowane, ale nie tak, jak ludzie są przyzwyczajeni. Niezależnie od tego, czy znajduje się w tym samym pliku, czy nie, istnieje już separacja. Nie ma potrzeby tworzenia dodatkowej separacji, aby pasowała do innych języków i systemów operacyjnych.

Będąc zmęczony katastrofą MVx na Androida, niedawno zrobiłem małą bibliotekę, która zapewnia jednokierunkowy przepływ danych i jest podobna do koncepcji MVC: https://github.com/zserge/anvil

Zasadniczo masz komponent (aktywność, fragment i viewgroup). Wewnątrz definiujesz strukturę i styl warstwy widoku. Możesz również określić, w jaki sposób dane mają być powiązane z widokami. Wreszcie, można powiązać słuchaczy w tym samym miejscu.

Następnie, po zmianie danych - zostanie wywołana globalna metoda "render ()", a twoje widoki zostaną inteligentnie zaktualizowane o Najnowsze dane.

Oto przykład komponentu, który ma wszystko w środku dla zwartości kodu(oczywiście Model i kontroler można łatwo rozdzielić). Tutaj " count "jest modelem, metoda view() jest widokiem, A" v -> count++ " jest kontrolerem, który nasłuchuje kliknięć przycisku i aktualizuje model.

public MyView extends RenderableView {
  public MyView(Context c) {
      super(c);
  }

  private int count = 0;

  public void view() {
    frameLayout(() -> {              // Define your view hierarchy
      size(FILL, WRAP);
      button(() -> {
          textColor(Color.RED);      // Define view style
          text("Clicked " + count);  // Bind data
          onClick(v -> count++);     // Bind listeners
      });
    });
  }

Z oddzielonym modelem i kontrolerem wyglądałoby like:

button(() -> {
   textColor(Color.RED);
   text("Clicked " + mModel.getClickCount());
   onClick(mController::onButtonClicked);
});

Tutaj przy każdym kliknięciu przycisku liczba zostanie zwiększona, następnie zostanie wywołana "render ()", a tekst przycisku zostanie zaktualizowany.

Składnia staje się przyjemniejsza jeśli używasz Kotlina: http://zserge.com/blog/anvil-kotlin.html . Istnieje również alternatywna składnia dla Javy bez lambda.

Sama Biblioteka jest bardzo lekka, nie ma zależności, nie używa odbicia, itp.

(Zastrzeżenie: jestem autorem tej biblioteki)

Nie ma zaimplementowanej architektury MVC, ale istnieje zestaw bibliotek / przykładów do implementacji architektury MVP (model-view-presenter).

Proszę sprawdzić te linki:

• Https://github.com/sockeqwe/mosby

• Https://github.com/android10/Android-CleanArchitecture

• Https://github.com/antoniolg/androidmvp

Google dodał przykład architektury Androida MVP:

• https://github.com/googlesamples/android-architecture

Widziałem, że wiele osób twierdzi, że MVC jest już zaimplementowany w Androidzie, ale to nieprawda. Android domyślnie nie śledzi MVC.

Ponieważ Google nie lubią narzucać na siłę ograniczeń implementacji MVC, takiej jak iPhone, ale pozostawili tę decyzję użytkownikowi do korzystania z techniki MVC, ponieważ w małych lub prostych aplikacjach nie mamy potrzeby korzystania z MVC, ale ponieważ aplikacja staje się skomplikowana i będzie musiała zmodyfikować swój kod po opracowaniu kończy, potem pojawia się potrzeba wzorca MVC w Androidzie.

Zapewnia łatwy sposób modyfikacji kodu, a także pomoc w niechcianych problemach. Są one dostępne w prostych wzorcach projektowych Androida. Jeśli chcesz zaimplementować MVC na Androidzie, postępuj zgodnie z poniższym linkiem i ciesz się technikami implementacji MVC w swoim projekcie.

Http://www.therealjoshua.com/2011/11/android-architecture-part-1-intro/

Zgodnie z wyjaśnieniem , które wyjaśnił zespół Xamarin (na iOS MVC "wiem, że wydaje się to dziwne, ale poczekaj chwilę"):

• model (dane lub logika aplikacji),
• widok (interfejs użytkownika), oraz
• kontroler (kod z tyłu).

Mogę to powiedzieć:

Model na Androida jest po prostu obiektem parcelowalnym. Widok jest układem XML, a kontrolerem (activity + jego fragment).

* to tylko moje zdanie, nie z dowolnego zasobu lub książki.

Kiedy zastosujemy MVC, MVVM lub Model prezentacji do aplikacji na Androida, tak naprawdę chcemy mieć przejrzysty, zorganizowany projekt i, co ważniejsze, łatwiejszy do testów jednostkowych.

W tej chwili, bez zewnętrznego frameworka, zwykle masz dużo kodu (jak addXXListener (), findViewById (), itp.), co nie wnosi żadnej wartości biznesowej.

Co więcej, musisz uruchomić testy jednostkowe Androida zamiast normalnych testów JUnit, które zajmują wieki, aby uruchomić i utworzyć jednostkę testy nieco niepraktyczne. Z tych powodów kilka lat temu rozpoczęliśmy projekt open source, RoboBinding - ramowy Model prezentacji wiążącej dane dla Platformy Android.

RoboBinding pomaga w pisaniu kodu interfejsu użytkownika, który jest łatwiejszy do odczytania, przetestowania i utrzymania. RoboBinding usuwa potrzebę niepotrzebnego kodu, takiego jak addXXListener lub tak, i przenosi logikę interfejsu do modelu prezentacji, który jest POJO i może być testowany za pomocą normalnych testów JUnit. RoboBinding sam pochodzi z ponad 300 testów JUnit, aby zapewnić jego jakość.

To było zaskakujące, że żaden z postów tutaj odpowiedział na pytanie. Są one albo zbyt ogólne, niejasne, nieprawidłowe lub nie odnoszą się do implementacji w Androidzie.

W MVC, Widok warstwa wie tylko jak pokazać interfejs użytkownika (UI). Jeśli potrzebne są do tego jakieś dane, pobiera je z warstwy modelu. Ale widok nie prosi bezpośrednio modelu o znalezienie danych, robi to za pomocą kontrolera . Więc Kontroler wywołuje Model {[10] } zapewniający wymagane dane dla widoku . Gdy dane są gotowe, Kontroler informuje widok , że dane są gotowe do pobrania z modelu . Teraz widok może pobrać dane z modelu .

Przepływ ten można podsumować następująco:

Warto zauważyć, że Widok może wiedzieć o dostępności danych w modelu albo poprzez Kontroler -- znany również jakopasywny MVC -- lub obserwując dane w modelu rejestrując do niego obserwable, czyliaktywny MVC .

Jeśli chodzi o implementację, jedną z pierwszych rzeczy, które przychodzą na myśl, jest to, jaki komponent Androida powinien być użyty w widoku ? Activity Czy Fragment ?

Odpowiedź jest taka, że to nie ma znaczenia i oba mogą być używane. Widok powinien być w stanie przedstawić interfejs użytkownika (UI) na urządzenia i reagować na interakcję użytkownika z interfejsem użytkownika. Zarówno Activity, jak i Fragment zapewniają wymagane do tego metody.

W przykładowej aplikacji użytej w ten artykuł {[37] } użyłem Activity dla warstwyView , ale Fragment można również użyć.

Pełna przykładowa aplikacja znajduje się w gałęzi' mvc ' mojego GitHub repo tutaj.

Omówiłem również zalety i wady architektury MVC w Androidzie na przykładzie tutaj .

Dla zainteresowanych rozpocząłem serię artykułów na temat architektury aplikacji na Androida tutaj , w których porównuję różne architektury, tj. MVC, MVP, MVVM, do tworzenia aplikacji na Androida poprzez kompletną działającą aplikację.

Model-widok-kontroler w Androidzie Około 2011 roku, kiedy Android zaczął być coraz bardziej popularny, pojawiły się pytania o architekturę. Ponieważ MVC był jednym z najpopularniejszych wzorców interfejsu użytkownika w tym czasie, programiści próbowali zastosować go również do Androida.

Model Model reprezentuje zestaw klas, które opisują logikę biznesową, tj. model biznesowy, a także operacje dostępu do danych, tj. model danych. Określa również reguły biznesowe dla danych oznacza, w jaki sposób dane mogą być zmieniane i manipulowane.

Widok Widok przedstawia komponenty interfejsu użytkownika. Odpowiada tylko za wyświetlenie danych, które w wyniku tego zostaną odebrane ze sterownika. To również przekształca model(y) w interfejs użytkownika.

Controller Administrator jest odpowiedzialny za przetwarzanie przychodzących żądań. Otrzymuje dane wejściowe od użytkowników za pośrednictwem widoku, a następnie przetwarza dane Użytkownika za pomocą modelu i przekazuje wyniki z powrotem do widoku. Typowo, pełni rolę koordynatora między widokiem a modelem.

Innymi słowy

Modele: Dostawcy Treści. Menedżery danych, które są zalecaną formą wymiany danych między aplikacjami.

Odsłon: 0 Jest to podstawowy komponent interfejsu użytkownika aplikacji. Każdy ekran aplikacji na Androida pochodzi z klasy Activity Java (android.app.Aktywność). Są to kontenery dla widoków (android.widok.Widok).

Controllers: Services. Te są komponentami tła, które zachowują się jak demony UNIX i usługi Windows. Działają niewidocznie i wykonują bieżące przetwarzanie bez nadzoru.