• 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+"");
    
    
        }
    
    }
    

  • 相关阅读:
    征战蓝桥 —— 2015年第六届 —— C/C++A组第3题——奇妙的数字
    征战蓝桥 —— 2015年第六届 —— C/C++A组第3题——奇妙的数字
    征战蓝桥 —— 2013年第四届 —— C/C++A组第6题——逆波兰表达式
    征战蓝桥 —— 2013年第四届 —— C/C++A组第6题——逆波兰表达式
    征战蓝桥 —— 2013年第四届 —— C/C++A组第6题——逆波兰表达式
    信息学奥赛一本通(C++)在线评测系统——基础(三)数据结构 —— 1354:括弧匹配检验
    信息学奥赛一本通(C++)在线评测系统——基础(三)数据结构 —— 1354:括弧匹配检验
    C#通过反射对可空类型动态赋值的问题
    网段
    C#通过反射对可空类型动态赋值的问题
  • 原文地址:https://www.cnblogs.com/wzben/p/6096585.html
Copyright © 2020-2023  润新知