risposta-alla-domanda-sullo-sviluppo-web-bd.com

Pattern MVC su Android

È possibile implementare il pattern model-view-controller in Java per Android?

O è già implementato attraverso le attività? O c'è un modo migliore per implementare il pattern MVC per Android?

488
Mohit Deshpande

In Android non hai MVC, ma hai il seguente:

  • Definisci la tua interfaccia utente in vari file XML per risoluzione, hardware, ecc.
  • Definisci le tue risorse in vari file XML per locale, ecc.
  • Estendi clases come ListActivity , TabActivity e fai uso del file XML da inflaters .
  • Puoi creare tutte le classi che desideri per la tua logica aziendale.
  • Un sacco di Utils sono già stati scritti per te - DatabaseUtils, Html.
235
Pentium10

Non esiste un pattern MVC universalmente unico. MVC è un concetto piuttosto che un solido quadro di programmazione. Puoi implementare il tuo MVC su qualsiasi piattaforma. Fintanto che rispetti la seguente idea di base, stai implementando MVC:

  • Modello: Cosa renderizzare
  • Visualizza: Come eseguire il rendering
  • Controller: Eventi, input dell'utente

Pensaci anche in questo modo: quando si programma il modello, il modello non dovrebbe preoccuparsi del rendering (o del codice specifico della piattaforma). Il modello direbbe alla vista, non mi importa se il tuo rendering è Android o iOS o Windows Phone, questo è quello che mi serve per renderizzare. La vista gestiva solo il codice di rendering specifico della piattaforma.

Ciò è particolarmente utile quando si utilizza Mono per condividere il modello al fine di sviluppare applicazioni multipiattaforma.

223
Ramon Chan

Le azioni, le visualizzazioni e le attività su Android sono il modo migliore per lavorare con l'interfaccia utente di Android e sono un'implementazione del modello model-view-viewmodel (MVVM) , che è strutturalmente simile (nella stessa famiglia di) model-view-controller.

Per quanto ne so, non c'è modo di uscire da questo modello. Probabilmente si può fare, ma probabilmente si perderebbero tutti i benefici del modello esistente e si dovrà riscrivere il proprio livello di interfaccia utente per farlo funzionare.

47
Derick Bailey

Dopo alcune ricerche, la risposta più ragionevole è la seguente:

MVC è già implementato in Android come:

  1. Visualizza = layout, risorse e classi built-in come Buttonderivate da Android.view.View.
  2. Controller = Attività
  3. Modello = le classi che implementano la logica dell'applicazione

(Questo, a proposito, non implica alcuna logica di dominio dell'applicazione nell'attività.)

La cosa più ragionevole per un piccolo sviluppatore è seguire questo schema e non provare a fare ciò che Google ha deciso di non fare.

PS Notate che a volte l'attività viene riavviata, quindi non c'è posto per i dati del modello (il modo più semplice per causare un riavvio è quello di omettere Android:configChanges="keyboardHidden|orientation" dall'XML e accendere il dispositivo).

MODIFICARE

Potremmo parlare di MVC, ma sarà così per dire FMVC, Framework - Model - View - Controller . Il Framework (il sistema operativo Android) impone la sua idea del ciclo di vita dei componenti e degli eventi correlati, e in pratica il controller (Activityname __/Servicename __/BroadcastReceivername__) è il primo responsabile per far fronte a questi Framework - eventi imposti (come onCreate () ). L'input dell'utente deve essere elaborato separatamente? Anche se dovrebbe, non puoi separarlo, gli eventi di input dell'utente provengono anche da Android.

Ad ogni modo, meno codice specifico per Android viene inserito in Activityname __/Servicename __/BroadcastReceivername__, meglio è.

26

Non esiste un unico pattern MVC a cui si possa obbedire. MVC afferma solo più o meno che non dovresti mischiare dati e visualizzare, così ad es. le viste sono responsabili del mantenimento di dati o classi che stanno elaborando i dati che stanno influenzando direttamente la vista.

Tuttavia, il modo in cui Android si occupa di classi e risorse, a volte sei anche costretto a seguire lo schema MVC. Più complicato, secondo me, sono le attività che a volte sono responsabili della vista, ma che agiscono allo stesso tempo come controllori.

Se si definiscono viste e layout nei file XML, caricare le risorse dalla cartella res e, se si evita più o meno di mescolare queste cose nel codice, si segue comunque un modello MVC.

18

È possibile implementare MVC in Android, ma non è "supportato nativamente" e richiede un certo sforzo.

Detto questo, personalmente tendo verso MVP come un modello architettonico molto più pulito per lo sviluppo Android. E dicendo MVP intendo questo:

enter image description here

Ho anche pubblicato una risposta più dettagliata qui .

Dopo aver giocato con i vari approcci all'implementazione di MVC/MVP in Android, ho trovato uno schema architettonico ragionevole, che ho descritto in questo post: MVP e MVC Architectural Patterns in Android .

14
Vasiliy

La migliore risorsa che ho trovato per implementare MVC su Android è questo post :

Ho seguito lo stesso design per uno dei miei progetti, e ha funzionato alla grande. Sono un principiante su Android, quindi non posso dire che questa sia la soluzione migliore.

Ho apportato una modifica: ho istanziato il modello e il controller per ogni attività nella classe dell'applicazione in modo che non vengano ricreati quando cambia la modalità ritratto orizzontale.

14
Hervé Donner

Sono d'accordo con JDPeckham e credo che l'XML da solo non sia sufficiente per implementare la parte UI di un'applicazione.

Tuttavia, se si considera l'attività come parte della vista, l'implementazione di MVC è piuttosto semplice. Puoi sovrascrivere Application (come restituito da getApplication () in Activity) ed è qui che puoi creare un controller che sopravvive per tutta la durata della tua applicazione.

(In alternativa puoi usare il modello singleton come suggerito dalla documentazione dell'applicazione)

12
typingduck

La creazione dell'interfaccia utente Android che utilizza layout, risorse, attività e intenti è un'implementazione del modello MVC. Si prega di vedere il seguente link per ulteriori informazioni su questo - http://www.cs.otago.ac.nz/cosc346/labs/COSC346-lab2.2up.pdf

mirror per il pdf

11
Arunabh Das

MVC- Architecture su Android È meglio seguire qualsiasi MVP invece MVC in Android. Ma ancora secondo la risposta alla domanda questa può essere la soluzione

Enter image description here

Descrizione e linee guida

     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

NOTA 1:

Ora ecco il pezzo di magia che puoi fare. Una volta classificato il codice, scrivi una classe di interfaccia di base come IEntity e IService. Dichiarare metodi comuni. Ora crea la classe astratta BaseService e dichiara il tuo insieme di metodi e disponi della separazione del codice.

NOTA 2: Se la tua attività presenta più modelli, invece di scrivere il codice/la logica in attività, è meglio dividere le viste in frammenti. Quindi è meglio. Quindi, in futuro, se è necessario un modello in più da mostrare nella vista, aggiungere un altro frammento.

NOTA 3: La separazione del codice è molto importante. Ogni componente nell'architettura dovrebbe essere indipendente e non avere una logica dipendente. Se per caso hai una logica dipendente, scrivi una classe logica di mappatura in mezzo. Questo ti aiuterà in futuro.

10
DropAndTrap

Anche se questo post sembra essere vecchio, mi piacerebbe aggiungere i seguenti due per informare sullo sviluppo recente in questa area per Android:

Android-binding - Fornisce un framework che consente il binding dei widget di visualizzazione Android al modello di dati. Aiuta ad implementare pattern MVC o MVVM nelle applicazioni Android.

roboguice - RoboGuice elimina le congetture dallo sviluppo. Iniettare la vista, la risorsa, il servizio di sistema o qualsiasi altro oggetto e lasciare che RoboGuice si prenda cura dei dettagli.

9
Mahendra Liya

Il pattern MVC di Android è (tipo) implementato con le rispettive classi Adapter . Sostituiscono un controller con un "adattatore". La descrizione per gli stati della scheda:

Un oggetto Adapter funge da ponte tra un AdapterView e i dati sottostanti per quella vista.

Sto solo esaminando questo per un'applicazione Android che legge da un database, quindi non so quanto bene funzioni ancora. Tuttavia, sembra un po 'come l'architettura Model-View-Delegate di Qt, che affermano essere un passaggio da un modello MVC tradizionale. Almeno sul PC, il modello di Qt funziona abbastanza bene.

9
Ben

Model View Controller (MVC)

enter image description here


Descrizione:

  • Quando dobbiamo gestire grandi progetti nello sviluppo del software, MVC viene generalmente utilizzato perché è un modo universale di organizzare i progetti.
  • I nuovi sviluppatori possono adattarsi rapidamente al progetto
  • Aiuta nello sviluppo di grandi progetti e anche in più piattaforme.

Il pattern MVC è essenzialmente questo:

  • Modello: cosa visualizzare. Questa può essere l'origine dati (Es: Server, Dati grezzi nell'app)
  • Visualizza: come viene visualizzato. Questo può essere l'xml. Funziona quindi come un filtro di presentazione. Una vista è allegata al suo modello (o parte del modello) e ottiene i dati necessari per la presentazione.
  • Controller: gestione di eventi come input dell'utente. Questa è l'attività

Funzionalità importante di MVC: Siamo in grado di modificare Sia il modello che la vista o il controller non influenzano ancora gli altri

  • Diciamo che cambiamo il colore nella vista, la dimensione della vista o la posizione della vista. In questo modo non influirà sul modello o sul controller
  • Diciamo che modifichiamo il modello (anziché i dati recuperati dal server recuperano i dati dalle risorse), tuttavia non influenzerà la vista e il controller
  • Diciamo che cambiamo il Controller (Logico nell'attività) non influenzerà il modello e la vista
9
Devrath

Penso che la spiegazione semplificata più utile sia qui: http://www.cs.otago.ac.nz/cosc346/labs/COSC346-lab2.2up.pdf

Da tutto ciò che ho visto e letto qui, l'implementazione di tutte queste cose lo rende più difficile e non si adatta bene ad altre parti di Android.

Avere un'attività implementare altri ascoltatori è già il modo standard di Android. Il modo più innocuo sarebbe aggiungere Java Observer come le diapositive descrivono e raggruppano onClick e altri tipi di azioni in funzioni che sono ancora nell'Attività.

Il modo Android è che l'attività fa entrambe le cose. Combatterlo non rende davvero più facile estendere o programmare in futuro.

Sono d'accordo con il 2 ° post . È una specie di già implementato, ma non il modo in cui le persone sono abituate. Se è o non è nello stesso file o no, c'è già separazione. Non è necessario creare ulteriore separazione per adattarla ad altri linguaggi e sistemi operativi.

7
Edmund Chang

Essendo stanco del disastro di MVx su Android, recentemente ho creato una piccola libreria che fornisce un flusso di dati unidirezionale ed è simile al concetto di MVC: https://github.com/zserge/anvil

Fondamentalmente, hai un componente (attività, frammento e gruppo di vista). All'interno si definisce la struttura e lo stile del livello di vista. Inoltre, si definisce come i dati devono essere associati alle viste. Infine, puoi legare gli ascoltatori nello stesso posto.

Quindi, una volta modificati i dati, verrà chiamato il metodo globale "rendering ()" e le tue visualizzazioni verranno aggiornate in modo intelligente con i dati più recenti.

Ecco un esempio del componente che ha tutto dentro per la compattezza del codice (ovviamente Modello e Controller possono essere facilmente separati). Qui "contare" è un modello, view () metodo è una vista e "v -> count ++" è un controller che ascolta il pulsante fa clic e aggiorna il modello.

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

Con il modello e il controller separati, sarebbe simile a:

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

Qui su ciascun pulsante, il numero verrà aumentato, quindi verrà chiamato "rendering ()" e il testo del pulsante verrà aggiornato.

La sintassi diventa più piacevole se usi Kotlin: http://zserge.com/blog/anvil-kotlin.html . Inoltre, esiste una sintassi alternativa per Java senza lambdas.

La libreria stessa è molto leggera, non ha dipendenze, non usa riflessi, ecc.

(Disclaimer: sono l'autore di questa libreria)

5
zserge

È stato sorprendente vedere che nessuno dei post qui ha risposto alla domanda. Sono troppo generici, vaghi, errati o non affrontano l'implementazione in Android.

In MVC, il layer View sa solo come mostrare l'interfaccia utente (UI). Se sono necessari dati per questo, lo ottiene dal livello Model . Ma la View NON chiede direttamente al modello di trovare i dati, lo fa attraverso il controller . Quindi il controller chiama il modello per fornire i dati richiesti per View . Una volta che i dati sono pronti, il controller informa il View che i dati sono pronti per essere acquisiti dal modello . Ora la View può ottenere i dati dal Model .

Questo flusso può essere riassunto come segue:

enter image description here

Vale la pena notare che la View può conoscere la disponibilità dei dati nel modello tramite Controller - noto anche come passivo MVC - o osservando i dati nel modello registrando ad esso osservabili, che è MVC attivo .

Nella parte relativa all'implementazione, una delle prime cose che viene in mente è che cosa dovrebbe essere usato il componente Android per View ? Activity o Fragment?

La risposta è che non ha importanza ed entrambi possono essere utilizzati. La View dovrebbe essere in grado di presentare l'interfaccia utente (UI) sul dispositivo e rispondere all'interazione dell'utente con l'interfaccia utente. Sia Activity che Fragment forniscono i metodi richiesti per questo.

Nell'app di esempio utilizzata in questo articolo ho usato Activity per il livello View , ma Fragment può anche essere Usato.

L'app di esempio completa può essere trovata nel ramo 'mvc' del mio repository GitHub qui .

Ho anche affrontato i pro e i contro dell'architettura MVC in Android attraverso un esempio qui .

Per gli interessati, ho avviato una serie di articoli sull'architettura delle app Android qui in cui confronto le diverse architetture, ad esempio MVC, MVP, MVVM, per Sviluppo di app Android attraverso un'app funzionante completa.

5
Ali Nem

Non esiste un'architettura MVC implementata, ma esiste un set di librerie/esempi per implementare un'architettura MVP (model-view-presenter).

Per favore, controlla questi link:

Google ha aggiunto un esempio di MVP per l'architettura Android:

4
carlos.baez

Ho visto che molte persone dicono che MVC è già implementato in Android, ma non è vero. Di default Android non segue MVC.

Perché io non Google imporrà mai forzatamente le restrizioni di un'implementazione MVC come iPhone, ma è fino agli sviluppatori quali patteren o tecnica vogliono nel loro progetto, In applicazioni piccole o semplici l'uso di MVC non è richiesto, ma come l'applicazione cresce e si complica e richiede la modifica del suo codice negli anni successivi, quindi arriva la necessità del pattern MVC in Android.

Fornisce un modo semplice per modificare il codice e aiuta anche a ridurre i problemi. Se desideri implementare MVC su Android, segui questo link qui sotto e goditi l'implementazione MVC nel tuo progetto.

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

Ma oggigiorno penso che MVP insieme a Android Architectural Pattern sia una delle migliori opzioni che gli sviluppatori dovrebbero usare per applicazioni Android pulite e robuste.

3
Lucky Rana

Secondo la spiegazione che il team di Xamarin ha spiegato (su iOS MVC "So che sembra strano, ma aspetta un secondo"):

  • Il modello (dati o logica dell'applicazione),
  • La vista (interfaccia utente) e
  • Il controller (codice dietro).

Posso dire questo:

Il modello su Android è semplicemente l'oggetto parcelable. La vista è il layout XML e il controller è (l'attività + il suo frammento).

* Questa è solo la mia opinione, non da alcuna risorsa o libro.

3
zaPlayer

Quando applichiamo MVC, MVVM o Presentation Model ad un App per Android, ciò che vogliamo veramente è avere un progetto chiaro e strutturato e, soprattutto, più facile per i test unitari.

Al momento, senza un framework di terze parti, di solito hai un sacco di codice (come addXXListener (), findViewById (), ecc.), Che non aggiunge alcun valore commerciale.

Inoltre, devi eseguire i test delle unità Android anziché i normali test JUnit, che impiegano anni per essere eseguiti e rendono i test unitari un po 'poco pratici. Per questi motivi, alcuni anni fa abbiamo avviato un progetto open source, RoboBinding - Un framework di Presentation Model vincolante con i dati per la piattaforma Android.

RoboBinding ti aiuta a scrivere codice UI che è più facile da leggere, testare e mantenere. RoboBinding rimuove la necessità di codice non necessario come addXXListener o così e sposta la logica dell'interfaccia utente in Presentation Model, che è un POJO e può essere testato tramite normale JUnit test . RoboBinding viene fornito con oltre 300 test JUnit per garantire la sua qualità.

2
Cheng

A mio parere, il modo in cui Android gestisce il pattern MVC è simile a:

Hai un'attività, che funge da controller. Hai una classe che è la responsabilità di ottenere i dati - il modello, e quindi hai la classe View che è la vista.

Quando si parla della vista, la maggior parte delle persone pensa solo alla sua parte visiva definita nell'xml. Non dimentichiamo che la vista ha anche una parte di programma con i suoi costruttori, metodi ed ecc, definiti nella classe Java.

0
Rados