Tot ce trebuie să știți despre componentele arhitecturii Android

Componente de arhitectură

Arhitectura este un plan constant care trebuie făcut înainte de începerea procesului de dezvoltare. Componentele arhitecturii mențin aplicația organizată, leagă toate componentele împreună și oferă o colecție de biblioteci care vă ajută să proiectați aplicații robuste, verificabile și care pot fi întreținute. Noua arhitectură Android sugerează câteva principii cheie pentru a crea o aplicație ideală cu securitate și pentru a evita clasele umflate care sunt greu de întreținut și testat.

Blocuri de construcție

Exemple de bază pentru blocuri sunt Activitate, Vizualizare, Intenții, Servicii, Fragmente, Fișier Manifest, AVD (Dispozitiv Virtual Android). Aceste blocuri sunt reprezentarea arhitecturii componentelor aplicației raționale și, de asemenea, sunt semne ale punctelor dureroase ale dezvoltatorului.

Primul set te ajută

• Gestionați-vă automat activitatea și fragmentați ciclurile de viață pentru a evita scurgerile de memorie și resurse
• Persistați obiectele de date Java într-o bază de date SQLite

Componente:

1. Componentele ciclului de viață

Această componentă este utilizată pentru a adăuga conștientizarea ciclului de viață. Componentele ciclului de viață includ Lifecycle, LifecycleOwner și LifecycleObserver

Ciclu de viață

Până acum, ciclul de viață este o clasă abstractă gestionată de sistemul însuși. Dar, în scenariul actual, Ciclul de viață identifică starea componentei și se comportă și încheie sarcina în consecință, la momentul potrivit.

LifecycleOwner

LifecycleOwner este o interfață care poate implementa pentru a obține un obiect de ciclu de viață din metoda getLifecycle(). ProcessLifecycleOwner este util atunci când doriți să gestionați ciclul de viață al unui întreg proces.

LifecycleObserver

LifecycleObserver observă componentele LifecycleOwner precum Activities and Fragments. Primește LifecycleOwner.Event și reacționează la ele prin metodele de adnotare.

Implementând toate acestea împreună, putem crea o aplicație conștientă de ciclul de viață.

• Implementarea Lifecycle observator

 clasa publică TestObserver implementează LifecycleObserver {

MyObserver public (ciclul de viață al ciclului de viață) {

// Începe observarea ciclului de viață

lifecycle.addObserver(this);

...

}

// Metode adnotate apelate atunci când ciclul de viață asociat trece prin aceste evenimente

@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)

public void onResume() {

}

@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)

public void onPause() {

}

}

Acum putem folosi acest observator în componenta aplicației noastre, folosind următoarea implementare TestObserver observer = new TestObserver(aLifecycleOwner.getLifecycle());

2. LiveData

Componenta LiveData este un deținător de date care conține o valoare care poate fi observată. Cu datele live ori de câte ori Activitatea sau Fragmentul este actualizat, vom primi notificare, astfel încât interfața dvs. de utilizare să fie mereu actualizată. Este un înveliș în jurul modelelor dvs. tipice care anunță observatorii când ceva se schimbă în acel model. Principalul avantaj al datelor live este că nu mai există scurgeri de memorie și NullPointerExceptions din cauza vizualizărilor inexistente.

• Creați obiecte LiveData

 clasa publică MyViewModel extinde ViewModel {
// Creați un LiveData cu un șir
private MutableLiveData<String> mData;
public MutableLiveData<String> getData() {
if ( mData == null) {
mData = new MutableLiveData<String>();
}
returnează mData;
}
}

• Observați obiectele LiveData

 Următorul cod ilustrează cum să observați obiectul LiveData:
clasa publică MyActivity extinde AppCompatActivity {
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
Modelul MyViewModel = ViewModelProviders.of(this).get(MyViewModel .class);
model.getData().observe(this, data -> {
// actualizați interfața de utilizare
});
}
}

3. Vezi modelul

ViewModel util pentru a furniza și menține date pentru componentele UI (Activitate sau Fragment) într-un mod conștient de ciclul de viață. Este capabil să supraviețuiască prin modificările de configurare. Deci, dacă distrugeți activitatea sau schimbați orientarea telefonului, nu veți pierde ViewModel și datele. Datorită instanței LiveData care este plasată în clasa ViewModel, intrarea de la finalul nostru nu este necesară.

Nu trebuie să vă faceți griji cu privire la ciclul de viață al datelor deținătorului în UI. ViewModel va fi construit automat printr-o fabrică și nu trebuie să vă ocupați de crearea și demolarea acestuia pe cont propriu.

• Implementați un ViewModel

 Este ilustrat de următorul cod exemplu:
clasa publică MyViewModel extinde ViewModel {
studenți privați MutableLiveData<List<Students>>;
public LiveData<List<Students>> getStudents () {
dacă ( studenți == nul) {
elevi = new MutableLiveData<List<Students>>();
incarcaStudenti();
}
studenți returnați;
}
private void loadStudenti () {
// Faceți o operație asincronă pentru a prelua studenții.
}
}

Puteți accesa această listă dintr-o activitate după cum urmează:

 clasa publică MyActivity extinde AppCompatActivity {
public void onCreate(Bundle savedInstanceState) {
// Creați un ViewModel prima dată când sistemul apelează metoda onCreate() a unei activități.
// Activitățile recreate primesc aceeași instanță MyViewModel creată de prima activitate.
Modelul MyViewModel = ViewModelProviders.of(this).get(MyViewModel.class);
model.getStudents ().observe(this, elevi -> {
// actualizați interfața de utilizare
});
}
}

4. Cameră

Room este o bibliotecă de baze de date și o alternativă excelentă pentru baza de date SQLite. Pentru a utiliza baza de date SQLite este întotdeauna necesar să scrieți o mulțime de boilerplate. Putem defini baza de date adăugând adnotări în clasa Model. Biblioteca ajută la crearea unui cache cu datele aplicației pe un dispozitiv. Este mult similar cu OrmLite.

Există 3 componente majore în cameră:

A. Bază de date

Pe măsură ce aplicația dvs. este persistentă, datele relaționale și conțin deținătorul bazei de date, Servește ca punct de acces principal pentru conexiunea subiacentă la clasa adnotată cu @Database ar trebui să îndeplinească următoarele condiții:

Fii o clasă abstractă care extinde RoomDatabase.

Includeți lista de entități conectate cu baza de date care încorporează adnotarea.

Returnează clasa care este adnotată cu @Dao și conține o metodă abstractă care are 0 argumente.

În timpul rulării, puteți obține o instanță a bazei de date apelând Room.inMemoryDatabaseBuilder() sau altfel Room.databaseBuilder().

b. Entitate

Reprezintă un tabel în baza de date.

c. DAO

Conține metodele utilizate pentru accesarea bazei de date.

• Entitate creatoare

 @Entitate
utilizator de clasă publică {
@Cheia principala
int uid privat;
@ColumnInfo(nume = "prenume")
private String prenume;
@ColumnInfo(nume = "nume")
private String nume;

// Getters și setters sunt ignorați din motive de concizie,
// dar sunt necesare pentru ca Room să funcționeze.
}

• Creați o bază de date

 @Database(entities = {User.class}, versiunea = 1)
clasă abstractă publică AppDatabase extinde RoomDatabase {
INSTANȚĂ AppDatabase statică privată;
public static AppDatabase getDatabase(Context context) {
dacă (INSTANȚĂ == nul) {
INSTANȚĂ = Room.databaseBuilder(context.getApplicationContext(), AppDatabase.class, "my_db").build();
}
returnează INSTANȚĂ;
}
}

Această clasă este folosită pentru a crea baza de date și pentru a obține o instanță a acesteia. Creăm baza de date folosind următorul cod.

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

• Creați obiectul de acces la date

Adnotați clasa cu adnotarea @Dao. O implementare de clasă va fi apoi generată de Room care implementează metodele definite în interfață (foarte similar cu modul în care funcționează Retrofit).

 @Dao
interfață publică UserDao {
@Query ("SELECT * FROM user")
List<Utilizator> getAll();
@Query ("SELECT * FROM user WHERE uid IN (:userIds)")
List<User> loadAllByIds(int[] userIds);

@Query("SELECT * FROM user WHERE prenume LIKE :primul SI "
+ „nume LIKE :ultima LIMIT 1”)
Utilizatorul findByName(String primul, String ultimul);

@Introduce
void insertAll(Utilizator... utilizatori);

@Șterge
void delete (Utilizator utilizator);
}

Concluzie

Acest articol vă oferă cunoștințe de bază despre componentele arhitecturii Android. Am încercat să includem toate subiectele legate de noua arhitectură Android propusă, care rezolvă toate problemele relevante cu care se confruntă dezvoltatorul în timpul dezvoltării aplicației. Totuși, dacă găsiți probleme, luați în considerare Angajați un dezvoltator Android al tehnologiei Elsner .