Einführung in diesen Abschnitt:

Im vorherigen Abschnitt haben wir einige grundlegende Verwendungen von Intent kennengelernt, die sieben Attribute von Intent, expliziten Intent und impliziten Intent sowie das Anpassen von implizitem Intent. Zum Schluss haben wir auch einige häufig verwendete System-Intents vorgestellt! In diesem Abschnitt erklären wir das Thema der Datenübergabe per Intent~ Okay, beginnen wir mit diesem Abschnitt~


1. Intent: Übergeben einfacher Daten

Erinnerst du dich, wie wir im Activity-Abschnitt gelernt haben, einfache Daten zwischen zwei Activities zu übergeben?

Das heißt, du kannst Daten direkt speichern, indem du die Methode putExtra() des Intent aufrufst, und dann, nachdem du den Intent erhalten hast, getXxxExtra aufrufst, um Daten des entsprechenden Typs zu erhalten; wenn du mehrere Werte übergibst, kannst du das Bundle-Objekt als Container verwenden. Zuerst speicherst du die Daten, indem du putXxx des Bundle aufrufst, in das Bundle, dann rufst du die Methode putExtras() des Intent auf, um das Bundle in den Intent zu legen. Nachdem du den Intent erhalten hast, rufst du getExtras() auf, um den Bundle-Container zu erhalten, und dann rufst du dessen getXXX auf, um die entsprechenden Daten zu erhalten! Außerdem ist die Datenspeicherung ein wenig ähnlich wie bei Map <key, value>!


2. Arrays mit Intent übergeben

Hihi, gewöhnliche Typen sind in Ordnung, aber was ist mit Arrays? Die Lösung ist wie folgt:

Array schreiben:

bd.putStringArray("StringArray", new String[]{"呵呵","哈哈"});
//可把StringArray换成其他数据类型,比如int,float等等...

Array lesen:

String[] str = bd.getStringArray("StringArray")

3. Sammlungen mit Intent übergeben

Nun, Arrays sind einfach, oder? Jetzt übergeben wir Sammlungen~ Das ist etwas komplizierter, behandle es von Fall zu Fall:


1) List<primitive Datentypen oder String>

Sammlung schreiben:

intent.putStringArrayListExtra(name, value)
intent.putIntegerArrayListExtra(name, value)

Sammlung lesen:

intent.getStringArrayListExtra(name)
intent.getIntegerArrayListExtra(name)

2)List< Object>

Die Liste in den Typ Serializable umwandeln und dann übergeben (Bundle kann als Medium verwendet werden)

Sammlung schreiben:

putExtras(key, (Serializable)list)

Sammlung lesen:

(List<Object>) getIntent().getSerializable(key)

PS: Die Object-Klasse muss das Serializable-Interface implementieren


3) Map<String, Object>, oder komplexer

Die Lösung ist:Es außen mit einer List umschließen

//传递复杂些的参数 
Map<String, Object> map1 = new HashMap<String, Object>();  
map1.put("key1", "value1");  
map1.put("key2", "value2");  
List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();  
list.add(map1);  

Intent intent = new Intent();  
intent.setClass(MainActivity.this,ComplexActivity.class);  
Bundle bundle = new Bundle();  

//须定义一个list用于在budnle中传递需要传递的ArrayList<Object>,这个是必须要的  
ArrayList bundlelist = new ArrayList();   
bundlelist.add(list);   
bundle.putParcelableArrayList("list",bundlelist);  
intent.putExtras(bundle);                
startActivity(intent); 

4. Übergeben von Objekten per Intent

Es gibt zwei Möglichkeiten, Objekte zu übergeben: das Objekt in einen JSON-String umzuwandeln oder es über Serializable, Parcelable zu serialisieren. Es wird nicht empfohlen, den in Android eingebauten miserablen JSON-Parser zu verwenden; Sie können Drittanbieter-Bibliotheken wie fastjson oder Gson verwenden!


1) Objekt in einen JSON-String umwandeln

Beispiel für Gson-Parsing:

Modell:

public class Book{
    private int id;
    private String title;
    //...
}

public class Author{
    private int id;
    private String name;
    //...
}

Daten schreiben:

Book book=new Book();
book.setTitle("Java编程思想");
Author author=new Author();
author.setId(1);
author.setName("Bruce Eckel");
book.setAuthor(author);
Intent intent=new Intent(this,SecondActivity.class);
intent.putExtra("book",new Gson().toJson(book));
startActivity(intent);

Daten lesen:

String bookJson=getIntent().getStringExtra("book");
Book book=new Gson().fromJson(bookJson,Book.class);
Log.d(TAG,"book title->"+book.getTitle());
Log.d(TAG,"book author name->"+book.getAuthor().getName());

2) Serializable, Parcelable verwenden, um Objekte zu serialisieren


1. Serializable-Implementierung:

① Die Business-Bean implementiert das Serializable-Interface; schreiben Sie Getter- und Setter-Methoden
② Intent übergibt die Objektinstanz durch Aufrufen von putExtra(String name, Serializable value). Wenn mehrere Objekte vorhanden sind, können wir natürlich auch zuerst Bundle.putSerializable(x,x) aufrufen;
③ Die neue Activity ruft die Methode getSerializableExtra() auf, um die Objektinstanz zu erhalten: z. B.: Product pd = (Product) getIntent().getSerializableExtra("Product");
④ Rufen Sie die get-Methode des Objekts auf, um die entsprechenden Parameter zu erhalten


2. Parcelable-Implementierung:

Allgemeiner Ablauf:

① Die Business-Bean implementiert das Parcelable-Interface, überschreibt die Methode writeToParcel und serialisiert Ihr Objekt in ein Parcel-Objekt;
② Überschreiben Sie die Methode describeContents; für die Beschreibung der Inhaltsschnittstelle ist die standardmäßige Rückgabe von 0 in Ordnung.
③ Instanziieren Sie das statische innere Objekt CREATOR, um das Interface Parcelable.Creator zu implementieren
④ Ähnlich übergeben Sie die Objektinstanz über die Methode putExtra() des Intent. Wenn mehrere Objekte vorhanden sind, können wir sie natürlich zuerst über Bundle.putParcelable(x,x) in ein Bundle legen und dann Intent.putExtras() aufrufen.

Einige Erklärungen:

Ordnen Sie Ihr Objekt über writeToParcel einem Parcel-Objekt zu und ordnen Sie das Parcel-Objekt dann über createFromParcel wieder Ihrem Objekt zu. Sie können Parcel auch als Stream betrachten: Schreiben Sie das Objekt über writeToParcel in den Stream und lesen Sie das Objekt dann über createFromParcel aus dem Stream. Dieser Prozess muss jedoch von Ihnen implementiert werden, daher müssen die Reihenfolge des Schreibens und die Reihenfolge des Lesens übereinstimmen.

Codebeispiel für die Implementierung des Parcelable-Interface:

//Internal Description Interface,You do not need to manage  
@Override  
public int describeContents() {  
     return 0;  
}  
       
      
 
@Override  
public void writeToParcel(Parcel parcel, int flags){  
    parcel.writeString(bookName);  
    parcel.writeString(author);  
    parcel.writeInt(publishTime);  
}  
      

public static final Parcelable.Creator<Book> CREATOR = new Creator<Book>() {  
    @Override  
    public Book[] newArray(int size) {  
        return new Book[size];  
    }  
          
    @Override  
    public Book createFromParcel(Parcel source) {  
        Book mBook = new Book();    
        mBook.bookName = source.readString();   
        mBook.author = source.readString();    
        mBook.publishTime = source.readInt();   
        return mBook;  
    }  
};

Android Studio-Plugin zum Generieren von Parcelable:

Intellij/Android Studio-Plugin android-parcelable-intellij-plugin. Drücken Sie einfach ALT+Insert, um direkt Code für das Parcelable-Interface zu generieren.

Darüber hinaus: Parcelable-Objekte werden in Android häufig verwendet, und die Implementierung des Parcelable-Interface ist sehr umständlich. Sie können das Open-Source-Framework eines Drittanbieters verwenden: Parceler. Aufgrund von Maven-Problemen habe ich es noch nicht ausprobiert.

Referenzadresse:[Automatische Generierung von Parcelable in Android]

3. Vergleich der beiden Serialisierungsmethoden:

Vergleich der beiden:

  • 1) Bei der Nutzung von Speicher hat Parcelable eine höhere Leistung als Serializable, daher wird Parcelable empfohlen.
  • 2) Serializable erzeugt während der Serialisierung eine große Anzahl temporärer Variablen und verursacht dadurch häufige GC.
  • 3) Parcelable kann nicht verwendet werden, wenn Daten auf der Festplatte gespeichert werden müssen, da Parcelable die Datenpersistenz bei externen Änderungen nicht gut gewährleisten kann. Obwohl Serializable weniger effizient ist, wird in diesem Fall dennoch Serializable empfohlen.

5. Bitmap-Übergabe per Intent

Bitmap implementiert standardmäßig die Parcelable-Schnittstelle, daher können Sie es direkt übergeben.

Implementierungscode:

Bitmap bitmap = null;
Intent intent = new Intent();
Bundle bundle = new Bundle();
bundle.putParcelable("bitmap", bitmap);
intent.putExtra("bundle", bundle);

6. Das Hin- und Herreichen ist unpraktisch, definieren Sie direkt globale Daten

Wenn Sie einfache Daten übergeben müssen, zum Beispiel Activity1 -> Activity2 -> Activity3 -> Activity4, und Sie möchten einige Daten an Activity4 übergeben, wie gehen Sie damit um? Seite für Seite weiterreichen?

Offensichtlich ist das nicht sinnvoll, oder? Wenn Sie möchten, dass einige Daten überall zugänglich sind, können Sie erwägen,das globale Application-Objekt zu verwenden!

Das Android-System erstellt bei jedem Programmlauf ein Application-Objekt, und es erstellt nur eines, daher ist Application eine Klasse im Singleton-Modus. Der Lebenszyklus des Application-Objekts ist der längste im gesamten Programm; sein Lebenszyklus entspricht dem Lebenszyklus des Programms. Wenn Sie einige Werte speichern möchten, die mehr als statisch sind (fest und unveränderlich oder veränderbar), und wenn Sie Application verwenden möchten, müssen Sie eine benutzerdefinierte Klasse definieren, die die Application-Klasse implementiert, und dem System mitteilen, dass die instanziierte unsere benutzerdefinierte Application und nicht die Systemstandard ist. Dieser Schritt erfolgt, indem wir in unserem application-Tag in AndroidManifest.xml Folgendes hinzufügen:das name-Attribut!

Wichtiger Teil des Codes:

1) Benutzerdefinierte Application-Klasse:

class MyApp extends Application {
    private String myState;
    public String getState(){
        return myState;
    }
    public void setState(String s){
        myState = s;
    }
}

2) In AndroidManifest.xml deklarieren:

<application android:name=".MyApp" android:icon="@drawable/icon" 
  android:label="@string/app_name">

3) Bei Bedarf aufrufen:

class Blah extends Activity {
    @Override
    public void onCreate(Bundle b){
        ...
    MyApp appState = ((MyApp)getApplicationContext());
    String state = appState.getState();
        ...
    }
}

Fortgeschrittener Ansatz

: Kann das globale Application-Objekt überall abrufen.

Application ist eine Komponente des Systems; sie hat auch ihren eigenen Lebenszyklus. Wir können dieses Application-Objekt in onCraete erhalten. Hier ist der geänderte Code!

class MyApp extends Application {
    private String myState;
    private static MyApp instance;
    
    public static MyApp getInstance(){
        return instance;
    }
    
    
    public String getState(){
        return myState;
    }
    public void setState(String s){
        myState = s;
    }
    
    @Override
    public void onCreate(){
        onCreate();
        instance = this;
    }
 
}

Dann können wir überall direkt aufrufen: MyApp.getInstance(), um das globale Application-Objekt zu erhalten!


Notizen:

Das Application-Objekt existiert im Speicher, daher kann es vom System beendet werden. Zum Beispiel in diesem Szenario:

Wir speichern das Benutzerkonto in Activity1 in der Application, rufen es dann in Activity2 ab und zeigen es an!

Wenn wir die Home-Taste drücken und das System nach langer Zeit unsere App beendet, um Speicher zurückzugewinnen. Zu diesem Zeitpunkt, wenn wir die App erneut öffnen, kehrt sie überraschenderweise zur Activity2-Seite zurück. Aber wenn Sie in diesem Moment versuchen, das Benutzerkonto erneut aus der Application abzurufen, wird das Programm eine NullPointerException auslösen und dann abstürzen~

Der Grund für den oben genannten Absturz ist, dass dieses Application-Objekt brandneu ist. Sie denken vielleicht, die App wurde neu gestartet, aber tatsächlich ist dem nicht so; sie erstellt lediglich eine neue Application und startet dann die Activity, die der Benutzer zuletzt verlassen hat, was die Illusion erzeugt, dass die App nicht beendet wurde! Wenn es sich also um wichtige Daten handelt, wird empfohlen, sie lokal zu speichern. Außerdem sollten Sie bei der Verwendung der Daten eine Nicht-Null-Prüfung der Variablenwerte durchführen! Noch etwas: Nicht nur Application-Variablen verhalten sich so; auch Singleton-Objekte und öffentliche statische Variablen tun das~


7. Singleton-Muster zur Parameterübergabe

Die oben erwähnte Application basiert auf dem Singleton-Muster. Die Eigenschaft des Singleton-Musters ist, dass es gewährleistet, dass eine Klasse genau eine einzige Instanz im System hat. Dadurch ist es sehr einfach zu erreichen: Parameter in A setzen und in B direkt darauf zugreifen. Dies ist die effizienteste unter den mehreren Methoden.

Beispielcode: (Code aus dem Internet~)

① Definieren Sie eineSingleton-Klasse:

public class XclSingleton  
{  
    //单例模式实例  
    private static XclSingleton instance = null;  
      
    //synchronized 用于线程安全,防止多线程同时创建实例  
    public synchronized static XclSingleton getInstance(){  
        if(instance == null){  
            instance = new XclSingleton();  
        }     
        return instance;  
    }     
      
    final HashMap<String, Object> mMap;  
    private XclSingleton()  
    {  
        mMap = new HashMap<String,Object>();  
    }  
      
    public void put(String key,Object value){  
        mMap.put(key,value);  
    }  
      
    public Object get(String key)  
    {  
        return mMap.get(key);  
    }  
      
} 

② Parameter setzen:

XclSingleton.getInstance().put("key1", "value1");  
XclSingleton.getInstance().put("key2", "value2");  

Zusammenfassung des Abschnitts:

Okay, das war alles zur komplexen Datenübertragung mit Intent. In diesem Abschnitt haben wir neben der Erklärung, wie man Intent verwendet, um komplexe Daten zu übergeben, auch gezeigt, wie man Application und das Singleton-Muster verwendet, um Parameter zu übergeben! Ich glaube, das wird allen die Datenübertragung erleichtern. Danke~