Alles, was Sie über Android-Architekturkomponenten wissen müssen

Architekturkomponenten

Architektur ist ein fester Plan, der erstellt werden muss, bevor der Entwicklungsprozess beginnt. Architekturkomponenten halten die Anwendung organisiert, verbinden alle Komponenten miteinander und bieten eine Sammlung von Bibliotheken, die Ihnen helfen, robuste, überprüfbare und wartbare Anwendungen zu entwickeln. Die neue Architektur von Android schlägt einige Schlüsselprinzipien vor, um eine ideale Anwendung mit Sicherheit zu erstellen und aufgeblähte Klassen zu vermeiden, die schwer zu warten und zu testen sind.

Bausteine

Grundlegende Beispiele für Bausteine ​​sind Activity, View, Intents, Services, Fragments, Manifest File, AVD (Android Virtual Device). Diese Blöcke stellen die Komponentenarchitektur der rationalen Anwendung dar und sind auch Anzeichen für die Schwachstellen der Entwickler.

Das erste Set hilft dir dabei

• Verwalten Sie automatisch Ihre Aktivitäts- und Fragmentlebenszyklen, um Speicher- und Ressourcenlecks zu vermeiden
• Beibehalten von Java-Datenobjekten in einer SQLite-Datenbank

Komponenten:

1. Lebenszykluskomponenten

Diese Komponente wird verwendet, um das Lebenszyklusbewusstsein hinzuzufügen. Lifecycle-Komponenten umfassen Lifecycle, LifecycleOwner und LifecycleObserver

Lebenszyklus

Bisher ist der Lebenszyklus eine abstrakte Klasse, die vom System selbst verwaltet wird. Aber im aktuellen Szenario identifiziert Lifecycle den Zustand der Komponente und verhält sich und beendet die Aufgabe zum geeigneten Zeitpunkt entsprechend.

LebenszyklusEigentümer

LifecycleOwner ist eine Schnittstelle, die implementiert werden kann, um ein Lebenszyklusobjekt von der Methode getLifecycle() abzurufen. ProcessLifecycleOwner ist nützlich, wenn Sie den Lebenszyklus eines gesamten Prozesses verwalten möchten.

LifecycleObserver

LifecycleObserver beobachtet LifecycleOwner-Komponenten wie Aktivitäten und Fragmente. Es empfängt LifecycleOwner.Event und reagiert darauf durch die Annotationsmethoden.

Durch die gemeinsame Implementierung können wir eine lebenszyklusbewusste Anwendung erstellen.

• Implementieren des Lifecycle-Beobachters

 öffentliche Klasse TestObserver implementiert LifecycleObserver {

öffentlicher MyObserver (Lebenszykluslebenszyklus) {

// Startet Lebenszyklusbeobachtung

lifecycle.addObserver(this);

...

}

// Annotierte Methoden, die aufgerufen werden, wenn der zugehörige Lebenszyklus diese Ereignisse durchläuft

@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)

public void onResume() {

}

@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)

public void onPause() {

}

}

Jetzt können wir diesen Beobachter in unserer App-Komponente verwenden, indem wir die folgende Implementierung verwenden TestObserver Observer = new TestObserver(aLifecycleOwner.getLifecycle());

2. Live-Daten

Die LiveData-Komponente ist ein Datenbehälter, der einen beobachtbaren Wert enthält. Mit Livedaten werden wir jedes Mal benachrichtigt, wenn Aktivität oder Fragment aktualisiert werden, damit Ihre Benutzeroberfläche immer aktualisiert wird. Es ist ein Wrapper um Ihre typischen Modelle, der Beobachter benachrichtigt, wenn sich an diesem Modell etwas ändert. Der Hauptvorteil von Livedaten sind keine Speicherverluste und NullPointerExceptions aufgrund nicht vorhandener Ansichten mehr.

• LiveData-Objekte erstellen

 öffentliche Klasse MyViewModel erweitert ViewModel {
// Erstellen Sie ein LiveData mit einem String
private MutableLiveData<String> mData;
public MutableLiveData<String> getData() {
if (mData == null) {
mData = new MutableLiveData<String>();
}
mData zurückgeben;
}
}

• LiveData-Objekte beobachten

 Der folgende Code veranschaulicht, wie das LiveData-Objekt beobachtet wird:
öffentliche Klasse MyActivity erweitert AppCompatActivity {
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
MyViewModel model = ViewModelProviders.of(this).get(MyViewModel.class);
model.getData().observe(this, data -> {
// UI aktualisieren
});
}
}

3. Modell anzeigen

ViewModel ist nützlich, um Daten für Ihre UI-Komponenten (Aktivität oder Fragment) auf lebenszyklusbewusste Weise bereitzustellen und zu verwalten. Es ist in der Lage, die Konfigurationsänderungen zu überleben. Wenn Sie also Aktivitäten zerstören oder die Ausrichtung Ihres Telefons ändern, gehen ViewModel und Daten nicht verloren. Aufgrund der LiveData-Instanz, die unter der ViewModel-Klasse platziert ist, ist die Eingabe von unserer Seite nicht erforderlich.

Sie müssen sich nicht um den UI-Lebenszyklus der Inhaberdaten in der UI kümmern. ViewModel wird automatisch durch eine Fabrik erstellt und Sie müssen sich nicht selbst darum kümmern, es zu erstellen und zu zerstören.

• Implementieren eines ViewModels

 Es wird durch den folgenden Beispielcode veranschaulicht:
öffentliche Klasse MyViewModel erweitert ViewModel {
private MutableLiveData<List<Students>> Studenten;
public LiveData<List<Students>> getStudents () {
if (Studenten == null) {
Studenten = new MutableLiveData<List<Students>>();
loadStudents();
}
Rückkehrstudenten;
}
private void loadStudents () {
// Führen Sie einen asynchronen Vorgang durch, um Schüler abzurufen.
}
}

Sie können auf diese Liste von einer Aktivität aus wie folgt zugreifen:

 öffentliche Klasse MyActivity erweitert AppCompatActivity {
public void onCreate(Bundle savedInstanceState) {
// Erstellen Sie ein ViewModel, wenn das System zum ersten Mal die Methode onCreate() einer Aktivität aufruft.
// Neu erstellte Aktivitäten erhalten dieselbe MyViewModel-Instanz, die von der ersten Aktivität erstellt wurde.
MyViewModel model = ViewModelProviders.of(this).get(MyViewModel.class);
model.getStudents ().observe(this, Students -> {
// UI aktualisieren
});
}
}

4. Zimmer

Room ist eine Datenbankbibliothek und eine großartige Alternative für die SQLite-Datenbank. Um die SQLite-Datenbank zu verwenden, ist es immer notwendig, viele Boilerplates zu schreiben. Wir können die Datenbank definieren, indem wir Anmerkungen in der Model-Klasse hinzufügen. Die Bibliothek hilft dabei, einen Cache mit App-Daten auf einem Gerät zu erstellen. Es ist OrmLite sehr ähnlich.

Es gibt 3 Hauptkomponenten in Room:

A. Datenbank

Da Ihre App persistent ist, relationale Daten enthält und den Datenbankhalter enthält, sollte sie als Hauptzugriffspunkt für die zugrunde liegende Verbindung zu der Klasse dienen, die mit @Database annotiert ist, die folgenden Bedingungen erfüllen:

Seien Sie eine abstrakte Klasse, die RoomDatabase erweitert.

Fügen Sie die Liste der Entitäten hinzu, die mit der Datenbank verbunden sind, die die Anmerkung enthält.

Es gibt die Klasse zurück, die mit @Dao annotiert ist und eine abstrakte Methode enthält, die 0 Argumente hat.

Während der Laufzeit können Sie eine Datenbankinstanz durch Aufrufen von Room.inMemoryDatabaseBuilder() oder Room.databaseBuilder() abrufen.

B. Entität

Stellt eine Tabelle innerhalb der Datenbank dar.

C. DAO

Enthält die Methoden, die für den Zugriff auf die Datenbank verwendet werden.

• Entität erstellen

 @Entität
Benutzer der öffentlichen Klasse {
@Primärschlüssel
private Int uid;
@ColumnInfo(name = "vorname")
private Zeichenfolge Vorname;
@ColumnInfo(name = "nachname")
private Zeichenfolge nachname;

// Getter und Setter werden der Kürze halber ignoriert,
// aber sie werden benötigt, damit Room funktioniert.
}

• Datenbank erstellen

 @Datenbank(entities = {User.class}, version = 1)
öffentliche abstrakte Klasse AppDatabase erweitert RoomDatabase {
private statische AppDatabase INSTANCE;
öffentliche statische AppDatabase getDatabase(Kontextkontext) {
if (INSTANZ == null) {
INSTANCE = Room.databaseBuilder(context.getApplicationContext(), AppDatabase.class, "my_db").build();
}
INSTANZ zurückgeben;
}
}

Diese Klasse wird verwendet, um die Datenbank zu erstellen und eine Instanz davon abzurufen. Wir erstellen die Datenbank mit folgendem Code.

Room.databaseBuilder(context.getApplicationContext(), AppDatabase.class, „my_db“).build();

• Erstellen Sie das Datenzugriffsobjekt

Kommentieren Sie die Klasse mit der Annotation @Dao. Anschließend wird von Room eine Klassenimplementierung generiert, die die im Interface definierten Methoden implementiert (sehr ähnlich wie Retrofit).

 @Dao
öffentliche Schnittstelle UserDao {
@Query("SELECT * FROM user")
Liste<Benutzer> getAll();
@Query("SELECT * FROM user WHERE uid IN (:userIds)")
Liste<Benutzer> loadAllByIds(int[] userIds);

@Query("SELECT * FROM user WHERE Vorname LIKE :first AND "
+ "nachname LIKE :letztes LIMIT 1")
Benutzer findByName(String zuerst, String zuletzt);

@Einfügung
void insertAll(Benutzer... Benutzer);

@Löschen
void delete(Benutzerbenutzer);
}

Fazit

Dieser Artikel vermittelt Ihnen grundlegende Kenntnisse über Android-Architekturkomponenten. Wir haben versucht, alle Themen im Zusammenhang mit der neu vorgeschlagenen Android-Architektur einzubeziehen, die alle relevanten Probleme lösen, mit denen der Entwickler während der Anwendungsentwicklung konfrontiert ist. Wenn Sie dennoch Probleme feststellen, sollten Sie einen Android-Entwickler von Elsner Technology einstellen .