MVC-Muster auf Android

Ist es möglich, das Modell-Ansicht-Controller-Muster in Java für Android zu implementieren?

Oder ist es bereits durch Aktivitäten implementiert? Oder gibt es eine bessere Möglichkeit, das MVC-Muster für Android zu implementieren?

In Android haben Sie keine MVC, aber Sie haben die folgenden:

• Sie definieren Ihre Benutzeroberfläche in verschiedenen XML-Dateien nach Auflösung, Hardware usw.
• Sie definieren Ihre Ressourcen in verschiedenen XML-Dateien nach Gebietsschema usw.
• Sie erweitern Klassen wie ListActivity , TabActivity und nutzen die XML-Datei durch Inflater .
• Sie können beliebig viele Klassen für Ihre Geschäftslogik erstellen.
• Viele Utils wurden bereits für Sie geschrieben - DatabaseUtils, Html.

Es gibt kein universell eindeutiges MVC-Muster. MVC ist eher ein Konzept als ein solides Programmierframework. Sie können Ihre eigene MVC auf jeder Plattform implementieren. Solange Sie sich an die folgende Grundidee halten, implementieren Sie MVC:

• Modell: Was soll gerendert werden?
• Ansicht: So rendern Sie
• Controller: Ereignisse, Benutzereingaben

Denken Sie auch so darüber nach: Wenn Sie Ihr Modell programmieren, sollte sich das Modell nicht um das Rendern (oder den plattformspezifischen Code) kümmern müssen. Das Modell würde der Ansicht sagen, es ist mir egal, ob Ihr Rendering Android oder iOS oder Windows Phone ist, das ist es, was Sie zum Rendern benötigen. Die Ansicht würde nur den plattformspezifischen Rendering-Code verarbeiten.

Dies ist besonders nützlich, wenn Sie das Modell mit Mono freigeben, um plattformübergreifende Anwendungen zu entwickeln.

Die Aktionen, Ansichten und Aktivitäten unter Android sind die integrierte Arbeitsweise mit der Android-Benutzeroberfläche und eine Implementierung des MVVM-Musters (Model-View-Viewmodel) , das strukturell ähnlich ist (in derselben Familie wie) Model-View -Regler.

Nach meinem besten Wissen gibt es keine Möglichkeit, aus diesem Modell auszubrechen. Dies ist wahrscheinlich möglich, aber Sie würden wahrscheinlich den gesamten Nutzen des vorhandenen Modells verlieren und müssen Ihre eigene UI-Ebene neu schreiben, damit es funktioniert.

Nach einiger Suche ist die vernünftigste Antwort die folgende:

MVC ist bereits in Android implementiert als:

1. Ansicht = Layout, Ressourcen und integrierte Klassen wie Buttonabgeleitet von android.view.View.
2. Controller = Aktivität
3. Modell = die Klassen, die die Anwendungslogik implementieren

(Dies impliziert übrigens keine Anwendungsdomänenlogik in der Aktivität.)

Für einen kleinen Entwickler ist es am vernünftigsten, diesem Muster zu folgen und nicht zu versuchen, das zu tun, was Google nicht beschlossen hat.

PS Beachten Sie, dass die Aktivität manchmal neu gestartet wird, sodass kein Platz für Modelldaten vorhanden ist (der einfachste Weg, einen Neustart zu veranlassen, besteht darin, android:configChanges="keyboardHidden|orientation"das XML wegzulassen und das Gerät einzuschalten).

BEARBEITEN

Wir sprechen vielleicht über MVC , aber es wird sozusagen FMVC , Framework - Model - View - Controller sein . Das Framework (das Android-Betriebssystem) setzt seine Idee des Komponentenlebenszyklus und verwandter Ereignisse durch, und in der Praxis ist der Controller ( Activity/ Service/ BroadcastReceiver) zunächst für die Bewältigung dieser vom Framework auferlegten Ereignisse (wie z. B. onCreate () ) verantwortlich. Sollten Benutzereingaben separat verarbeitet werden? Selbst wenn dies der Fall sein sollte, können Sie es nicht trennen. Benutzereingabeereignisse stammen ebenfalls von Android.

Wie auch immer, je weniger Code, der nicht Android-spezifisch ist, in Ihr Activity/ Service/ eingegeben wird, desto BroadcastReceiverbesser.

Es gibt kein einzelnes MVC-Muster, dem Sie folgen könnten. MVC gibt lediglich mehr oder weniger an, dass Sie Daten und Ansicht nicht mischen sollten, sodass z. B. Ansichten für das Speichern von Daten verantwortlich sind oder Klassen, die Daten verarbeiten, die Ansicht direkt beeinflussen.

Bei der Art und Weise, wie Android mit Klassen und Ressourcen umgeht, sind Sie manchmal sogar gezwungen, dem MVC-Muster zu folgen. Komplizierter sind meiner Meinung nach die Aktivitäten, die manchmal für die Ansicht verantwortlich sind, aber gleichzeitig als Controller fungieren.

Wenn Sie Ihre Ansichten und Layouts in den XML-Dateien definieren, Ihre Ressourcen aus dem Ordner res laden und vermeiden, dass diese Dinge mehr oder weniger in Ihrem Code gemischt werden, folgen Sie trotzdem einem MVC-Muster.

Sie können MVC in Android implementieren, es wird jedoch nicht "nativ unterstützt" und erfordert einige Anstrengungen.

Trotzdem tendiere ich persönlich zu MVP als einem viel saubereren Architekturmuster für die Android-Entwicklung. Und mit MVP meine ich Folgendes:

Ich habe auch eine ausführlichere Antwort gepostet hier .

Nachdem ich mit den verschiedenen Ansätzen zur MVC / MVP-Implementierung in Android gespielt hatte, kam ich auf ein vernünftiges Architekturmuster, das ich in diesem Beitrag beschrieben habe: MVP- und MVC-Architekturmuster in Android .

Die beste Ressource, die ich gefunden habe, um MVC auf Android zu implementieren, ist dieser Beitrag :

Ich habe das gleiche Design für eines meiner Projekte verfolgt und es hat großartig funktioniert. Ich bin ein Anfänger auf Android, daher kann ich nicht sagen, dass dies die beste Lösung ist.

Ich habe eine Änderung vorgenommen: Ich habe das Modell und den Controller für jede Aktivität in der Anwendungsklasse instanziiert, damit diese nicht neu erstellt werden, wenn sich der Querformatmodus ändert.

Ich stimme JDPeckham zu und glaube, dass XML allein nicht ausreicht, um den UI-Teil einer Anwendung zu implementieren.

Wenn Sie die Aktivität jedoch als Teil der Ansicht betrachten, ist die Implementierung von MVC recht einfach. Sie können Application (wie von getApplication () in Activity zurückgegeben) überschreiben und hier einen Controller erstellen, der für die Lebensdauer Ihrer Anwendung überlebt.

(Alternativ können Sie das Singleton-Muster verwenden, wie in der Anwendungsdokumentation vorgeschlagen.)

MVC-Architektur auf Android Es ist besser, jedem MVP statt MVC in Android zu folgen. Nach der Antwort auf die Frage kann dies jedoch eine Lösung sein

Beschreibung und Richtlinien

     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

ANMERKUNG 1:

Hier ist das Stück Magie, das du tun kannst. Wenn Sie den Code klassifiziert haben, schreiben Sie eine Basisschnittstellenklasse wie IEntity und IService. Deklarieren Sie gängige Methoden. Erstellen Sie nun die abstrakte Klasse BaseService, deklarieren Sie Ihre eigenen Methoden und trennen Sie den Code.

HINWEIS 2: Wenn in Ihrer Aktivität mehrere Modelle dargestellt werden, ist es besser, die Ansichten in Fragmente zu unterteilen, als den Code / die Logik in die Aktivität zu schreiben. Dann ist es besser. Wenn in Zukunft mehr Modelle benötigt werden, um in der Ansicht angezeigt zu werden, fügen Sie ein weiteres Fragment hinzu.

HINWEIS 3: Die Trennung von Code ist sehr wichtig. Jede Komponente in der Architektur sollte unabhängig sein und keine abhängige Logik haben. Wenn Sie zufällig eine abhängige Logik haben, schreiben Sie dazwischen eine Mapping-Logikklasse. Dies wird Ihnen in Zukunft helfen.

Die Erstellung der Android-Benutzeroberfläche mithilfe von Layouts, Ressourcen, Aktivitäten und Absichten ist eine Implementierung des MVC-Musters. Weitere Informationen hierzu finden Sie unter folgendem Link: http://www.cs.otago.ac.nz/cosc346/labs/COSC346-lab2.2up.pdf

Spiegel für das PDF

Das MVC-Muster von Android wird (irgendwie) mit den Adapterklassen implementiert . Sie ersetzen einen Controller durch einen "Adapter". Die Beschreibung für den Adapter lautet:

Ein Adapterobjekt fungiert als Brücke zwischen einer Adapteransicht und den zugrunde liegenden Daten für diese Ansicht.

Ich suche nur nach einer Android-Anwendung, die aus einer Datenbank liest, daher weiß ich noch nicht, wie gut sie funktioniert. Es scheint jedoch ein wenig wie die Model-View-Delegate-Architektur von Qt zu sein, von der sie behaupten, sie sei ein Schritt weiter als ein traditionelles MVC-Muster. Zumindest auf dem PC funktioniert das Muster von Qt ziemlich gut.

Obwohl dieser Beitrag alt zu sein scheint, möchte ich die folgenden zwei hinzufügen, um über die jüngste Entwicklung in diesem Bereich für Android zu informieren:

Android-Bindung - Bereitstellung eines Frameworks, das die Bindung von Android-Ansichts-Widgets an das Datenmodell ermöglicht. Es hilft, MVC- oder MVVM-Muster in Android-Anwendungen zu implementieren.

roboguice - RoboGuice nimmt das Rätselraten aus der Entwicklung. Fügen Sie Ihre Ansicht, Ressource, Ihren Systemdienst oder ein anderes Objekt ein und lassen Sie RoboGuice sich um die Details kümmern.

Model View Controller (MVC)

Beschreibung:

• Wenn wir große Projekte in der Softwareentwicklung vorantreiben müssen, wird MVC im Allgemeinen verwendet, da dies eine universelle Methode zur Organisation der Projekte ist.
• Neue Entwickler können sich schnell an das Projekt anpassen
• Hilft bei der Entwicklung großer Projekte und auch plattformübergreifend.

Das MVC-Muster ist im Wesentlichen das Folgende:

• Modell: Was angezeigt werden soll. Dies kann die Datenquelle sein (Beispiel: Server, Rohdaten in der App)
• Ansicht: Wie es angezeigt wird. Dies kann die XML sein. Es fungiert somit als Präsentationsfilter. Eine Ansicht wird an ihr Modell (oder Modellteil) angehängt und erhält die für die Präsentation erforderlichen Daten.
• Controller: Behandlung von Ereignissen wie Benutzereingaben. Dies ist die Aktivität

Wichtiges Merkmal von MVC: Wir können entweder das Modell oder die Ansicht oder den Controller ändern, ohne die anderen zu beeinflussen

• Angenommen, wir ändern die Farbe in der Ansicht, die Größe der Ansicht oder die Position der Ansicht. Auf diese Weise wird weder das Modell noch die Steuerung beeinflusst
• Angenommen, wir ändern das Modell (anstelle von Daten, die vom Server abgerufen werden, werden Daten von Assets abgerufen). Dies hat jedoch keine Auswirkungen auf die Ansicht und den Controller
• Angenommen, wir ändern den Controller (Logik in der Aktivität), dies hat keine Auswirkungen auf das Modell und die Ansicht

Ich denke, die nützlichste vereinfachte Erklärung ist hier: http://www.cs.otago.ac.nz/cosc346/labs/COSC346-lab2.2up.pdf

Nach allem, was ich hier gesehen und gelesen habe, macht es die Implementierung all dieser Dinge schwieriger und passt nicht gut zu anderen Teilen von Android.

Eine Aktivität andere Hörer implementieren zu lassen, ist bereits die Standardmethode für Android. Am harmlosesten wäre es, den Java Observer wie in den Folien beschrieben hinzuzufügen und den onClick und andere Arten von Aktionen in Funktionen zu gruppieren, die sich noch in der Aktivität befinden.

Der Android-Weg ist, dass die Aktivität beides macht. Der Kampf dagegen macht das Erweitern oder zukünftige Codieren nicht wirklich einfacher.

Ich stimme dem 2. Beitrag zu . Es ist irgendwie bereits implementiert, nur nicht so, wie es die Leute gewohnt sind. Unabhängig davon, ob es sich in derselben Datei befindet oder nicht, gibt es bereits eine Trennung. Es ist nicht erforderlich, eine zusätzliche Trennung zu erstellen, um sie an andere Sprachen und Betriebssysteme anzupassen.

Es war überraschend zu sehen, dass keiner der Beiträge hier die Frage beantwortete. Sie sind entweder zu allgemein, vage, falsch oder sprechen die Implementierung in Android nicht an.

In MVC weiß die Ansichtsebene nur, wie die Benutzeroberfläche angezeigt wird. Wenn hierfür Daten benötigt werden, werden diese von der Modellebene abgerufen. Die Ansicht fordert das Modell jedoch NICHT direkt auf, die Daten zu finden, sondern über den Controller . Daher  ruft der Controller das Modell auf, um die erforderlichen Daten für die Ansicht bereitzustellen . Sobald die Daten bereit sind, informiert der Controller die Ansicht darüber, dass die Daten bereit sind, vom Modell erfasst zu werden . Jetzt kann die Ansicht die Daten aus dem Modell abrufen .

Dieser Fluss kann wie folgt zusammengefasst werden:

Es ist anzumerken, dass die Ansicht über die Verfügbarkeit der Daten im  Modell  entweder über den Controller - auch als  passive MVC bezeichnet - oder durch Beobachtung der Daten im Modell durch Registrierung von Observablen, die Active MVC sind, informiert werden kann .

Beim Implementierungsteil fällt als erstes ein, welche Android-Komponente für die Ansicht verwendet werden sollte . Activity  oder Fragment ?

Die Antwort ist, dass es keine Rolle spielt und beide verwendet werden können. Die Ansicht sollte in der Lage sein, die Benutzeroberfläche (UI) auf dem Gerät darzustellen und auf die Interaktion des Benutzers mit der Benutzeroberfläche zu reagieren. Beides Activity  und Fragment  stellen die dafür erforderlichen Methoden zur Verfügung.

In der in diesem Artikel verwendeten Beispiel-App habe ich Activity für die Ansichtsebene verwendet, Fragment  kann aber auch verwendet werden.

Die komplette Beispielanwendung kann in dem ‚mvc‘ Zweig gefunden wird meine GitHub Repo hier .

Ich habe auch mit der Vor - und Nachteilen von MVC - Architektur in android durch ein Beispiel behandelt hier .

Für Interessierte habe ich hier eine Reihe von Artikeln zur Android-App-Architektur gestartet , in denen ich die verschiedenen Architekturen, dh MVC, MVP, MVVM, für die Entwicklung von Android-Apps über eine vollständig funktionierende App vergleiche.

Da ich die MVx-Katastrophe unter Android satt habe, habe ich kürzlich eine winzige Bibliothek erstellt, die einen unidirektionalen Datenfluss bietet und dem Konzept von MVC ähnelt: https://github.com/zserge/anvil

Grundsätzlich haben Sie eine Komponente (Aktivität, Fragment und Ansichtsgruppe). Im Inneren definieren Sie die Struktur und den Stil der Ansichtsebene. Außerdem definieren Sie, wie Daten an die Ansichten gebunden werden sollen. Schließlich können Sie Listener an derselben Stelle binden.

Sobald Ihre Daten geändert wurden, wird die globale "render ()" - Methode aufgerufen und Ihre Ansichten werden intelligent mit den neuesten Daten aktualisiert.

Hier ist ein Beispiel für die Komponente, die aus Gründen der Codekompaktheit alles enthält (natürlich können Modell und Controller leicht getrennt werden). Hier ist "count" ein Modell, die view () -Methode eine Ansicht und "v -> count ++" ein Controller, der auf die Tastenklicks hört und das Modell aktualisiert.

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

Mit dem getrennten Modell und Controller würde es so aussehen:

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

Hier wird bei jedem Klick auf die Schaltfläche die Zahl erhöht, dann wird "render ()" aufgerufen und der Schaltflächentext aktualisiert.

Die Syntax wird angenehmer, wenn Sie Kotlin verwenden: http://zserge.com/blog/anvil-kotlin.html . Es gibt auch eine alternative Syntax für Java ohne Lambdas.

Die Bibliothek selbst ist sehr leicht, hat keine Abhängigkeiten, verwendet keine Reflexion usw.

(Haftungsausschluss: Ich bin der Autor dieser Bibliothek)

Laut der Erklärung , die das Xamarin-Team erklärt hat (auf der iOS-MVC "Ich weiß, es scheint seltsam, aber warte eine Sekunde"):

• Das Modell (Daten- oder Anwendungslogik),
• Die Ansicht (Benutzeroberfläche) und
• Der Controller (Code dahinter).

Ich kann das sagen:

Das Modell auf Android ist einfach das Paketobjekt. Die Ansicht ist das XML-Layout und der Controller ist das (Aktivität + sein Fragment).

* Dies ist nur meine Meinung, nicht aus einer Ressource oder einem Buch.

Es gibt keine implementierte MVC-Architektur, aber es gibt eine Reihe von Bibliotheken / Beispielen, um eine MVP-Architektur (Model-View-Presenter) zu implementieren.

Bitte überprüfen Sie diese Links:

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

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

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

Google hat ein Beispiel für ein MVP mit Android-Architektur hinzugefügt:

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

Ich habe gesehen, dass viele Leute sagen, MVC sei bereits in Android implementiert, aber es ist nicht wahr. Android folgt standardmäßig keiner MVC.

Da ich es nicht tue, wird Google die Einschränkungen einer MVC-Implementierung wie dem iPhone jemals mit Nachdruck auferlegen, aber es liegt an den Entwicklern, welche Muster oder Techniken sie in ihrem Projekt wünschen. In kleinen oder einfachen Anwendungen ist die Verwendung von MVC nicht erforderlich, sondern als Anwendung wächst und wird kompliziert und erfordert in späteren Jahren Änderungen am Code. Dann wird das MVC-Muster in Android benötigt.

Es bietet eine einfache Möglichkeit, Code zu ändern, und hilft auch bei der Reduzierung von Problemen. Wenn Sie MVC auf Android implementieren möchten, folgen Sie diesem unten angegebenen Link und genießen Sie die MVC-Implementierung in Ihrem Projekt.

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

Aber heutzutage denke ich, dass MVP zusammen mit Android Architectural Pattern eine der besten Optionen ist, die Entwickler für saubere und robuste Android-Anwendungen verwenden sollten.

Wenn wir MVC, MVVM oder Presentation Model auf eine Android-App anwenden, möchten wir wirklich ein klar strukturiertes Projekt und vor allem einfacher für Unit-Tests.

Im Moment haben Sie ohne ein Framework eines Drittanbieters normalerweise viel Code (wie addXXListener (), findViewById () usw.), der keinen geschäftlichen Wert hinzufügt.

Darüber hinaus müssen Sie Android-Unit-Tests anstelle von normalen JUnit-Tests ausführen, deren Ausführung ewig dauert und Unit-Tests etwas unpraktisch macht. Aus diesen Gründen haben wir vor einigen Jahren ein Open-Source-Projekt gestartet, RoboBinding - Ein datenbindendes Präsentationsmodell-Framework für die Android-Plattform.

Mit RoboBinding können Sie UI-Code schreiben, der einfacher zu lesen, zu testen und zu warten ist. RoboBinding macht unnötigen Code wie addXXListener oder so überflüssig und verschiebt die UI-Logik auf das Präsentationsmodell, das ein POJO ist und über normale JUnit-Tests getestet werden kann . RoboBinding selbst wird mit mehr als 300 JUnit-Tests geliefert, um seine Qualität sicherzustellen.

Nach meinem Verständnis ist die Art und Weise, wie Android mit dem MVC-Muster umgeht, wie folgt:

Sie haben eine Aktivität, die als Controller dient. Sie haben eine Klasse, deren Aufgabe es ist, die Daten abzurufen - das Modell, und dann haben Sie die View-Klasse, die die Ansicht ist.

Wenn man über die Ansicht spricht, denken die meisten Leute nur an ihren visuellen Teil, der in der XML definiert ist. Vergessen wir nicht, dass die Ansicht auch einen Programmteil mit Konstruktoren, Methoden usw. enthält, der in der Java-Klasse definiert ist.