Einführung

Ich verwende Datenbindung in einem Entwicklungsprojekt und werde einen Artikel über das, was ich gelernt habe, schreiben.

Dieses Mal habe ich gelernt, wie Sie mit DataBinding Änderungen an den Eigenschaften von Datenklassenobjekten überwachen und in der Ansichtsanzeige wiedergeben.

Lern-App erstellt diesmal

Die Textanzeige von ① und ② wird bei jedem Drücken der Taste "Ändern" dynamisch hin und her geschaltet. "Doraemon" ⇄ "Erweitert"

①

②

Implementierungsdatei

build.gradle(:app)
activity_main.xml -- Character.java (Modellklasse) -- EventHandlers.java (Schnittstelle)
MainActivity.java

Ich werde umsetzen

1. Einführung von DataBinding

DataBinding {enabled = true} zu build.gradle (: app) hinzugefügt

`build.gradle`


apply plugin: 'com.android.application'

android {
    compileSdkVersion 30
    buildToolsVersion "30.0.2"

    defaultConfig {
        applicationId "com.android.databindingjava"
        minSdkVersion 24
        targetSdkVersion 30
        versionCode 1
        versionName "1.0"

        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
    }

    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
        }
    }

    //Beschreibung hinzufügen
    dataBinding {
        enabled = true
    }
}

dependencies {
    implementation fileTree(dir: "libs", include: ["*.jar"])
    implementation 'androidx.appcompat:appcompat:1.2.0'
    implementation 'androidx.constraintlayout:constraintlayout:2.0.4'
    testImplementation 'junit:junit:4.12'
    androidTestImplementation 'androidx.test.ext:junit:1.1.2'
    androidTestImplementation 'androidx.test.espresso:espresso-core:3.3.0'

}

2. Definieren Sie eine Modellklasse, um Änderungen zu überwachen

`Character.java`


//BaseObservable erben
public class Character extends BaseObservable {
    private String name;

    public Character(String name) {
        this.name = name;
    }

    //um Namen zu bekommen@Konstante BR zur Überwachung durch Angabe von Bindable.Name wird generiert
    @Bindable
    public String getName() {
        return name;
    }

    //notifyPropertyChanged in setName(BR.name)Durch Gewährung
    //BR von der Layoutseite.getName entspricht dem Namen()Wird aufgerufen (getName wird von der Layoutseite aufgerufen, wenn setName fertig ist)
    public void setName(String name) {
        this.name = name;

        notifyPropertyChanged(BR.name);
    }
}

Um die Änderungen in der Ansicht widerzuspiegeln

BaseObservable erben
Fügen Sie @ Bindable zu getName hinzu, um BR.name zu generieren, eine Überwachungskonstante. --Schreibe notifyPropertyChanged (BR.name); in setName

Auf diese Weise wird "getName" von der Layoutseite aufgerufen, wenn "setName" ausgeführt wird, und wenn der Wert von "name" geändert wird, wird die Änderung in der Ansicht wiedergegeben.

3. Definieren Sie eine Schnittstelle zum Ändern von Daten

`EventHandlers.java`


public interface EventHandlers {
    //Ich möchte dem Klickereignis entsprechen, daher lautet das Argument Ansicht.Machen Sie es dasselbe wie onClick von OnClickListener (Ansichtsansicht)
    void onChangeClick(View view);
}

Definieren Sie den Ereignishandler, der im Layout als Schnittstelle festgelegt werden soll

4. Erstellen Sie eine Layoutdatei, um die Änderungen widerzuspiegeln

`activity_main.xml`


<?xml version="1.0" encoding="utf-8"?>

<!--Wenn Sie die Route zum Layout festlegen, wird sie als Layout entsprechend der Datenbindung erkannt.-->
<!-- activity_main.xml =>ActivityMainBinding Auf diese Weise wird automatisch eine Binding-Klasse gemäß dem XML-Dateinamen erstellt.-->
<layout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto">

    <!--Bindungsobjekt-->
    <data>
        <!--Benanntes Zeichen durch diese Beschreibung(Irgendein)Ist dem Benutzerklassenobjekt zugeordnet-->
        <variable name="character" type="com.android.databindingjava.Character" />
        <!--Von dieser Beschreibung eventHandlers genannt(Irgendein)Handler (Schnittstelle) ist eingestellt-->
        <variable name="eventHandlers" type="com.android.databindingjava.EventHandlers" />
    </data>

    <!-- Views-->
    <androidx.constraintlayout.widget.ConstraintLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical">

        <TextView
            android:id="@+id/text_view_user_name"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:textSize="30dp"
            app:layout_constraintTop_toTopOf="parent"
            app:layout_constraintBottom_toBottomOf="parent"
            app:layout_constraintEnd_toEndOf="parent"
            app:layout_constraintStart_toStartOf="parent"
            android:text="@{character.name}" />

        <Button
            android:id="@+id/button_change"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:textSize="30dp"
            android:text="Veränderung"
            android:onClick="@{eventHandlers.onChangeClick}"
            app:layout_constraintBottom_toTopOf="@id/text_view_user_name"
            app:layout_constraintBottom_toBottomOf="parent"
            app:layout_constraintEnd_toEndOf="parent"
            app:layout_constraintStart_toStartOf="parent" />

    </androidx.constraintlayout.widget.ConstraintLayout>
</layout>

Zugriff auf die Modellklasse über das Layout

<variable name = "character" type = "com.android.databindingjava.Character" /> definiert ein Zeichenklassenobjekt mit dem Namenszeichen in der Layoutdatei und verwendet das Objekt in der Layoutdatei. in der Lage werden.

@ {Zeichenname} Mit dieser Beschreibung können Sie auf die Eigenschaft name der Zeichenklasse zugreifen, und android: text = "@ {Zeichen.name}" setzt den Wert der Eigenschaft auf Text.

Der Inhalt von @ {} ist so konzipiert, dass er null zulässt. Selbst wenn er null ist, tritt keine NullPointerException auf.

Legen Sie den Ereignishandler für das Layoutelement fest

<variable name = "eventHandlers" type = "com.android.databindingjava.EventHandlers" /> definiert die EventHandlers-Schnittstelle in der Layoutdatei mit dem Namen eventHandlers, und Sie können auf die Schnittstelle in der Layoutdatei zugreifen. Wird sein.

@ {eventHandlers.onChangeClick} Mit dieser Beschreibung können Sie auf onChangeClick der EventHandlers-Oberfläche zugreifen. Wenn Sie darauf klicken, schreiben Sie android: onClick = "@ {eventHandlers.onChangeClick}" in das Button-Element OnChangeClick wird aufgerufen. (* Eine Beschreibung in MainActivity.java, die später beschrieben wird, ist ebenfalls erforderlich.)

5. Definieren Sie den DataBinding-Prozess in MainActivity

`MainActivity.java`


//EventHandler implementieren (Schnittstelle)
public class MainActivity extends AppCompatActivity implements EventHandlers {

    private Character chara = new Character("Doraemon");

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // activity_main.Erstellen Sie eine Bindungsinstanz der Klasse, die xml entspricht
        ActivityMainBinding binding = DataBindingUtil.setContentView(this, R.layout.activity_main);
        // activity_main.Setze chara auf Zeichen in XML
        binding.setCharacter(chara);
        // activity_main.Setzen Sie MainActivity in xml auf eventHandlers
        binding.setEventHandlers(this);
    }

    // button_Klicken Sie auf Ereignisverarbeitung der Änderung (Schnittstelle)
    @Override
    public void onChangeClick(View view) {

        //Ändern Sie die einzustellende Zeichenfolge abhängig von der Zeichenfolge des Chara-Namens
        if (chara.getName().equals("Doraemon")) {
            chara.setName("Gestreckt");
        } else {
            chara.setName("Doraemon");
        }
    }
}

Durch Erstellen einer Layoutdatei mit dem Stammverzeichnis "" wird automatisch eine Bindungsklasse erstellt, die dem XML-Dateinamen entspricht. In diesem Fall ist activity_main.xml => ActivityMainBinding (.java)

Die folgende Verarbeitung wird in onCreate durchgeführt

--Erstellen Sie eine Instanz mit ActivityMainBinding binding = DataBindingUtil.setContentView (this, R.layout.activity_main);

Setzen Sie chara mit binding.setCharacter (chara); auf ein Zeichen in der Layoutdatei
Setzen Sie MainActivity auf eventHandlers in der Layoutdatei mit binding.setEventHandlers (this);

Anschließend wird die Schnittstelle onChangeClick implementiert und der Prozess zum Ändern der Daten gemäß dem TextView-Zeichenfolgenwert ohne Methode geschrieben.

Referenzseite

Dieser Artikel von mir ist ein Durcheinander von Verweisen auf diesen Artikel. Es war wirklich leicht zu verstehen! Vielen Dank!

Android Databinding ~ Super Introduction ~

Schließlich

Diesmal ist es eine einfache App, aber das eigentliche Projekt ist groß und es ist schwierig, den Code zu lesen. Ich werde weiter lernen.

Wir würden uns freuen, wenn Sie Fehler oder Vorschläge kommentieren könnten.

[Android / Java] Erfahren Sie mehr über DataBinding