Android六大进程间通信方式总结之一：基本知识

因为不同进程都是享有独立资源的，所以全局变量这些都是无效的，必须有其他的进程间通信方式。

一、基本知识

1：怎样使用多进程

Android正常使用的多进程的办法只有一种，就是在Service或Activity的属性里面设置remote属性

这样，我们打开Main2Activty的时候，该活动或服务就会以一个新的进程来创建

2：查看进程信息

通过adb shell连接上我们的手机，输入ps命令，查看所有的进程

可以使用ps|grep命令 + 包名 直接查看我们的app的进程信息   这里的grep是查询文本的命令

可以看到，有两个不同的进程。第一个是我们的MainActivity，没有指定属性，默认进程名是包名。第二是Main2Activity，默认是包名+：remote

3：对象的序列化

3.1：什么是序列化？

简单点来说，序列化就是把我们包含了数据的对象，转化成一堆数据，保存在文件中。

3.2：序列化的作用？

（1）.永久的保存对象数据(将对象数据保存在文件当中,或者是磁盘中

（2）.通过序列化操作将对象数据在网络上进行传输(由于网络传输是以字节流的方式对数据进行传输的.因此序列化的目的是将对象数据转换成字节流的形式)

（3）.将对象数据在进程之间进行传递(Activity之间传递对象数据时,需要在当前的Activity中对对象数据进行序列化操作.在另一个Activity中需要进行反序列化操作讲数据取出)

（4）.Java平台允许我们在内存中创建可复用的Java对象，但一般情况下，只有当JVM处于运行时，这些对象才可能存在，即，这些对象的生命周期不会比JVM的生命周期更长（即每个对象都在JVM中）但在现实应用中，就可能要停止JVM运行，但有要保存某些指定的对象，并在将来重新读取被保存的对象。这是Java对象序列化就能够实现该功能。（可选择入数据库、或文件的形式保存）

（5）.序列化对象的时候只是针对变量进行序列化,不针对方法进行序列化.

（6）.在Intent之间,基本的数据类型直接进行相关传递即可,但是一旦数据类型比较复杂的时候,就需要进行序列化操作了.

可以简单的理解为，转化为数据流之后，方便计算机直接传数据或保存数据。

3.3：怎么序列化

自定义的类必须实现 Serializable 或者 Parcelable 接口

3.3.1：Serializable

这是Java提供的一个序列化的接口，非常简单，只需自行声明一个版本ID即可，其他的都已经封装好了。

//自定义类

public class SerialUser implements Serializable {

    //版本号
    private static final long serialVersionUID = 2016L;

    //成员
    String name;
    int age;

    //构造函数
    public SerialUser(String name,int age){

        this.name = name;
        this.age = age;

    }
}

//序列化过程 MainActivity

public class MainActivity extends AppCompatActivity {

    Button button;

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

        button = (Button)findViewById(R.id.button);

        //使用序列化的类
        //序列化过程
        SerialUser user = new SerialUser("小明",20);
        try {

            File file = new File(Environment.getExternalStorageDirectory()
                     + "/my.txt");

            ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(file));
            out.writeObject(user);
            out.close();

        } catch (IOException e) {
            Log.d("TAG",e.toString());
        }

        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {

                Intent intent = new Intent(MainActivity.this,Main2Activity.class);
                startActivity(intent);

            }
        });

    }
}

//反序列化过程 Main2Activity

public class Main2Activity extends AppCompatActivity {

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

        Log.d("TAG","new process");

        //反序列化的过程
        try {

            File file = new File(Environment.getExternalStorageDirectory()
                    + "/my.txt");

            ObjectInputStream in = new ObjectInputStream(new FileInputStream(file));
            SerialUser user = (SerialUser)in.readObject();
            in.close();
            Log.d("TAG","ok");
            Log.d("TAG",user.name+user.age);

        } catch (IOException e) {
            Log.d("TAG",e.toString());
        } catch (ClassNotFoundException e) {
            Log.d("TAG",e.toString());
        }

    }
}

效果图

顺便看看中间文件my.txt里面到底存了什么数据

3.3.2：Parcelable

Parcelable不像Serialable那样，可以直接指定中间文件。所以反序列化时不能够通过打开文件读取的方式来进行。

我们要实现完整Parcelable接口就行了。Parcelable一般是通过Intent使用的，放进Intent里面来传递数据。

public class ParcelUser implements Parcelable {

    //成员
    String name;
    String sex;
    int age;

    //构造
    public  ParcelUser(String name,String sex,int age){

        this.name = name;

        this.sex = sex;

        this.age = age;

    }

    //一般都是返回0，不用管
    @Override
    public int describeContents() {
        return 0;
    }

    //必须实现的
    //其实只是针对成员变量保存一下就好
    @Override
    public void writeToParcel(Parcel dest, int flags) {

        dest.writeString(name);
        dest.writeString(sex);
        dest.writeInt(age);

    }

    //反序列化，这个地方系统没有提供来实现，自己要补上
    //该实现的地方都实现就对了
    public static final Parcelable.Creator<ParcelUser> CREATOR = new Creator<ParcelUser>() {
        @Override
        public ParcelUser createFromParcel(Parcel source) {
            return new ParcelUser(source

            );
        }

        @Override
        public ParcelUser[] newArray(int size) {
            return new ParcelUser[size];
        }
    };

    //反序列化的构造函数
    private ParcelUser(Parcel in){

        this.name = in.readString();
        this.sex = in.readString();
        this.age = in.readInt();

    }

}

MainActivity：

public class MainActivity extends AppCompatActivity {

    Button button;

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

        button = (Button)findViewById(R.id.button);

        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {

                Intent intent = new Intent(MainActivity.this,Main2Activity.class);

                ParcelUser user = new ParcelUser("小红","女",16);

                intent.putExtra("user",user);

                startActivity(intent);

            }
        });

    }
}

Main2Activity：

public class Main2Activity extends AppCompatActivity {

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

        Log.d("TAG", "new process");

        //反序列化的过程
        Intent intent = getIntent();

        ParcelUser user = intent.getParcelableExtra("user");

        Log.d("TAG",user.name);
        Log.d("TAG",user.sex);
        Log.d("TAG",user.age+"");

    }

}