Introducción a esta sección:
En la sección anterior aprendimos algunos usos básicos de Intent, conocimos las siete propiedades de Intent, los Intent explícitos e implícitos, y cómo personalizar Intent implícitos. Finalmente, también te proporcionamos algunos Intent del sistema de uso común. En esta sección explicaremos el problema de la transmisión de datos con Intent. ¡Bien, comencemos con el contenido de esta sección!
1. Transmisión de datos simples con Intent
¿Recuerdas que en Activity aprendimos cómo pasar datos simples entre dos Activities?
Simplemente puedes guardar datos llamando al método putExtra() de Intent, y luego, después de obtener el Intent, llamar a getXxxExtra para obtener los datos del tipo correspondiente. Si se pasan varios, puedes usar el objeto Bundle como contenedor: primero almacena los datos en el Bundle llamando a putXxx del Bundle, luego llama al método putExtras() de Intent para poner el Bundle en el Intent. Después de obtener el Intent, llama a getExtras() para obtener el contenedor Bundle y luego llama a su getXXX para obtener los datos correspondientes. Además, el almacenamiento de datos es algo similar al <clave, valor> de Map.
2. Transmisión de arrays con Intent
Jeje, con los tipos normales no hay problema, pero ¿y si son arrays? La solución es la siguiente:
Escribir el array:
bd.putStringArray("StringArray", new String[]{"呵呵","哈哈"});
//可把StringArray换成其他数据类型,比如int,float等等...
Leer el array:
String[] str = bd.getStringArray("StringArray")
3. Transmisión de colecciones con Intent
Bien, los arrays son muy simples, ¿verdad? Ahora pasemos colecciones. Esto es un poco más complejo, se maneja según el caso:
1) List<Tipo de datos básico o String>
Escribir la colección:
intent.putStringArrayListExtra(name, value) intent.putIntegerArrayListExtra(name, value)
Leer la colección:
intent.getStringArrayListExtra(name) intent.getIntegerArrayListExtra(name)
2)List< Object>
Convierte la lista al tipo Serializable y luego pásala (puedes usar Bundle como medio)
Escribir la colección:
putExtras(key, (Serializable)list)
Leer la colección:
(List<Object>) getIntent().getSerializable(key)
PS: La clase Object necesita implementar la interfaz Serializable
3) Map<String, Object>, o más complejo
La solución es:Envuelve el exterior con una List
//传递复杂些的参数
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. Transmisión de objetos con Intent
Hay dos formas de pasar objetos: convertir el objeto a una cadena JSON o serializarlo mediante Serializable, Parcelable. No se recomienda usar el analizador JSON integrado de Android, que es de baja calidad; se pueden usar bibliotecas de terceros como fastjson o Gson.
1) Convertir el objeto a una cadena JSON
Ejemplo de análisis con Gson:
Model:
public class Book{
private int id;
private String title;
//...
}
public class Author{
private int id;
private String name;
//...
}
Escribir datos:
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);
Leer datos:
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) Usar Serializable, Parcelable para serializar objetos
1. Implementación con Serializable:
① El Bean de negocio implementa la interfaz Serializable, escribe los métodos getter y setter
② Intent pasa la instancia del objeto llamando a putExtra(String name, Serializable value). Por supuesto, si hay varios objetos, también podemos poner primero Bundle.putSerializable(x, x);
③ La nueva Activity llama al método getSerializableExtra() para obtener la instancia del objeto. Por ejemplo: Product pd = (Product) getIntent().getSerializableExtra("Product");
④ Llama al método get del objeto para obtener los parámetros correspondientes
2. Implementación con Parcelable:
Proceso general:
① El Bean de negocio implementa la interfaz Parcelable, sobrescribe el método writeToParcel para serializar tu objeto en un objeto Parcel;
② Sobrescribe el método describeContents, que describe el contenido de la interfaz; con devolver 0 por defecto es suficiente
③ Instancia el objeto interno estático CREATOR implementando la interfaz Parcelable.Creator
④ De la misma manera, pasa la instancia del objeto mediante el método putExtra() de Intent. Por supuesto, si hay varios objetos, podemos primero ponerlos en el Bundle con Bundle.putParcelable(x, x), y luego Intent.putExtras().
Algunas explicaciones:
Mediante writeToParcel mapeas tu objeto a un objeto Parcel, y luego mediante createFromParcel mapeas el objeto Parcel de vuelta a tu objeto. También puedes considerar Parcel como un flujo: escribes el objeto en el flujo con writeToParcel y luego lees el objeto del flujo con createFromParcel. Sin embargo, este proceso debes implementarlo tú, por lo que el orden de escritura y el orden de lectura deben ser consistentes.
Ejemplo de código para implementar la interfaz Parcelable:
//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;
}
};
Complemento de Android Studio para generar Parcelable:
El complemento android-parcelable-intellij-plugin para IntelliJ/Android Studio. Solo presiona ALT+Insert y podrás generar directamente el código de la interfaz Parcelable.
Además: en Android se utilizan muchos objetos Parcelable, e implementar la interfaz Parcelable es muy tedioso. Se puede usar el framework de código abierto de terceros: Parceler. Debido a problemas con Maven, aún no lo he probado.
Direcciones de referencia:[Generación automática de Parcelable en Android]
3. Comparación de los dos métodos de serialización:
Comparación de ambos:
- 1) En cuanto al uso de memoria, Parcelable tiene un mejor rendimiento que Serializable, por lo que se recomienda usar Parcelable.
- 2) Serializable genera una gran cantidad de variables temporales durante la serialización, lo que provoca GC frecuentes.
- 3) Parcelable no se puede usar en casos donde se necesite almacenar datos en el disco, porque Parcelable no puede garantizar bien la persistencia de los datos cuando hay cambios externos. Aunque Serializable es menos eficiente, en este caso se recomienda usar Serializable.
5. Transmisión de Bitmap con Intent
Bitmap implementa la interfaz Parcelable por defecto, solo pásalo directamente
Código de implementación:
Bitmap bitmap = null;
Intent intent = new Intent();
Bundle bundle = new Bundle();
bundle.putParcelable("bitmap", bitmap);
intent.putExtra("bundle", bundle);
6. Si es inconveniente pasar de un lado a otro, define directamente datos globales
Si se trata de pasar datos simples y tienes esta necesidad: Activity1 -> Activity2 -> Activity3 -> Activity4, y quieres pasar un dato de una Activity a Activity4, ¿cómo se resuelve? ¿Pasarlo página por página?
Obviamente no es razonable, ¿verdad? Si quieres que un dato pueda obtenerse en cualquier lugar, puedes considerar usarel objeto global Application!
El sistema Android crea un objeto Application cada vez que se ejecuta un programa, y solo crea uno, por lo que Application es una clase con el patrón singleton (singleton). Además, el ciclo de vida del objeto Application es el más largo de todo el programa; su ciclo de vida es igual al ciclo de vida del programa. Si quieres almacenar algunos valores estáticos (fijos o que no cambian, aunque también pueden cambiar), y si quieres usar Application, necesitas definir una clase personalizada que implemente la clase Application y decirle al sistema que la instancia creada es nuestra Application personalizada, no la predeterminada del sistema. Y este paso se realiza añadiendo al tag application en AndroidManifest.xml:el atributo name!
Código de la parte clave:
1) Clase Application personalizada:
class MyApp extends Application {
private String myState;
public String getState(){
return myState;
}
public void setState(String s){
myState = s;
}
}
2) Declaración en AndroidManifest.xml:
<application android:name=".MyApp" android:icon="@drawable/icon" android:label="@string/app_name">
3) Llamar donde sea necesario:
class Blah extends Activity {
@Override
public void onCreate(Bundle b){
...
MyApp appState = ((MyApp)getApplicationContext());
String state = appState.getState();
...
}
}
Una forma elegante de escribir
: es poder obtener el objeto global Application desde cualquier lugar.Application es un componente del sistema y también tiene su propio ciclo de vida. Podemos obtener este objeto Application en onCraete. ¡Aquí está el código modificado!
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;
}
}
Luego, en cualquier lugar podemos llamar directamente: MyApp.getInstance() para obtener el objeto global de Application.
Notas:
El objeto Application existe en la memoria, por lo que puede ser eliminado por el sistema, por ejemplo, en este escenario:
En Activity1 almacenamos la cuenta de usuario en application, luego en Activity2 obtenemos la cuenta de usuario y la mostramos.
Si presionamos la tecla Home y después de mucho tiempo, el sistema elimina nuestra app para recuperar memoria. En este momento, al reabrir la app, de manera sorprendente, volvemos a la página de Activity2, pero si en este momento vuelves a obtener la cuenta de usuario almacenada en Application, el programa lanzará NullPointerException y luego fallará (crash).
La razón por la que ocurre el crash anterior es porque este objeto Application se crea de nuevo; puede que pienses que la App se reinició, pero en realidad no es así. Simplemente se crea una nueva Application y luego se inicia la Activity donde el usuario estaba la última vez, creando así la ilusión de que la App no fue eliminada. Por lo tanto, si se trata de datos importantes, se recomienda almacenarlos localmente; además, al usar los datos, debes verificar que los valores de las variables no sean nulos. Otra cosa: no solo las variables de Application se comportan así, también los objetos singleton y las variables estáticas públicas.
7. Pasar parámetros con el patrón singleton
La Application anterior se basa en el patrón Singleton. La característica del patrón Singleton es que garantiza que una clase tenga una y solo una instancia en el sistema. Así es muy fácil de implementar: establecer parámetros en A y acceder directamente en B. Este es el método más eficiente entre varios.
Código de ejemplo: (el código proviene de Internet~)
① Definir unaclase singleton:
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);
}
}
② Establecer parámetros:
XclSingleton.getInstance().put("key1", "value1");
XclSingleton.getInstance().put("key2", "value2");
Resumen de esta sección:
Bien, eso es todo sobre la transmisión de datos complejos con Intent. En esta sección, además de explicar el uso de Intent para pasar datos complejos, también se enseña a usar Application y el patrón Singleton para pasar parámetros. Creo que les será conveniente en la transmisión de datos, ¡gracias~
