Inhoudsopgave

In software engineering is een ontwerppatroon een vaak voorkomend probleem in softwareontwerp. Een ontwerppatroon is geen definitief ontwerp dat direct kan worden omgezet in opgeloste code.

Een groot probleem bij de ontwikkeling van software is de nauwe koppeling van code, d.w.z. zelfs een kleine wijziging in een deel van de code leidt tot wijzigingen of bugs in een ander deel van de code. Code is niet unit test vriendelijk, en code is niet herbruikbaar.

Inleiding

Momenteel zijn er veel architectonische benaderingen beschikbaar zoals MVP, FLUX, MVI, MVVM die de bovenstaande problemen oplossen. We kunnen elke aanpak gebruiken om onze code correct te onderhouden zodat alles goed werkt, kortom een gelukkig ontwikkelaarsleven. Dit artikel bespreekt het MVVM-ontwerppatroon in Android en hoe we bestaande problemen kunnen oplossen met het MVVM-ontwerppatroon.

De belangrijkste componenten in het MVVM ontwerppatroon zijn :

  1. Bekijken - Informeert het ViewModel over de acties van de gebruiker
  2. ViewModel - Toont gegevensstromen die relevant zijn voor de View
  3. DataModel - Vat de gegevensbron samen. Het ViewModel werkt met het DataModel om de gegevens te verkrijgen en op te slaan.

Korte uitleg van het MVVM-ontwerppatroon

Google introduceerde Android Architecture Components, met ViewModel in plaats van Presenter en daarmee het bewijs dat zelfs Google MVVM ondersteunt.

ViewModel

ViewModels zijn eenvoudige klassen die interageren met de logica/modellaag en toestanden/gegevens blootleggen, en geen idee hebben door wie of hoe die gegevens zullen worden geconsumeerd. Alleen View(Activity) verwijst naar ViewModel en niet omgekeerd; dit lost ons probleem van nauwe koppeling op. Een enkele view kan een verwijzing hebben naar meerdere ViewModels.

➡️
public class MainViewModel extends ViewModel {public MainViewModel() {}public String getText() {return new DataModel().getText();}}View

In Android vertegenwoordigt de activiteit een view in het MVVM-ontwerppatroon. De View is verantwoordelijk voor de visuele weergave van toepassingen en gegevensinvoer door gebruikers. Dit deel mag in geen geval de gegevens verwerken. Zijn functie is alleen het detecteren van invoer zoals aanraken of vegen en visualisatie.

Het ModelView-ViewModel architectuurpatroon werd geïntroduceerd in Android met de geboorte van de DataBinding bibliotheek. U kunt data-binding inschakelen vanuit de app.gradle.

➡️
dataBinding{enabled = true}

Add these lines in-app.Gradle inside android{} tag. Then put your XML layout code under tag. This will generate a binding class, and you can access this class from the activity. You can see we can directly access the getText() method from XML.

➡️
<?xml version="1.0" encoding="utf-8"?><layout><data><variablename="mainViewModel"type="com.g.mvvmproject.MainViewModel" /></data><RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"xmlns:app="http://schemas.android.com/apk/res-auto"xmlns:tools="http://schemas.android.com/tools"android:layout_width="match_parent"android:layout_height="match_parent"tools:context=".MainActivity"><TextViewandroid:layout_width="wrap_content"android:layout_height="wrap_content"android:text="@{mainViewModel.text}"app:layout_constraintBottom_toBottomOf="parent"app:layout_constraintLeft_toLeftOf="parent"app:layout_constraintRight_toRightOf="parent"app:layout_constraintTop_toTopOf="parent" /></RelativeLayout></layout>

Na setContentView stelt u een referentie in van het viewmodel.

➡️
public class MainActivity extends AppCompatActivity {private ActivityMainBinding mActivityMainBinding;private MainViewModel mainViewModel;@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);mActivityMainBinding = DataBindingUtil.setContentView(this, R.layout.activity_main);mainViewModel = new MainViewModel();mActivityMainBinding.setMainViewModel(mainViewModel);}}

DataModel

Het DataModel bevat de gegevens van de toepassing. Het kan niet rechtstreeks met de View praten. In het algemeen wordt aanbevolen de gegevens aan het ViewModel bloot te stellen via Observables.

➡️
public class DataModel {String text="Hello World ";public String getText() {return text + text;}}

Voordelen van het gebruik van het MVVM ontwerppatroon

  • De testbaarheid van uw code wordt vergroot.

In het onderstaande codefragment testen we de getText() methode in ViewModel. U kunt uw gegevens namaken en het verwachte resultaat controleren.

➡️
@RunWith(AndroidJUnit4.class)public class ExampleInstrumentedTest {@Testpublic void emailValidator_CorrectEmailSimple_ReturnsTrue() {String expected = "Hello World Hello World ";assertEquals(expected, new MainViewModel().getText());}}
  • Je code is ontkoppeld.
  • De pakketstructuur is nog overzichtelijker.
  • Het project is nog gemakkelijker te onderhouden.
  • Uw team kan nog sneller nieuwe functies toevoegen.

Conclusie

MVVM combineert de voordelen van separation of concerns van MVP met de voordelen van data bindings. Het resultaat is een patroon waarbij het model zo veel mogelijk operaties aanstuurt, zodat de logica in het view geminimaliseerd wordt.

➡️
Een eenvoudig voorbeeld van de MVVM-implementatie vindt u hier.

‍

Srinivasa Sainath

Srinivasa Sainath