Android中的IPC方式

最新推荐文章于 2020-11-08 17:21:05 发布
最新推荐文章于 2020-11-08 17:21:05 发布
阅读量240 收藏
点赞数
分类专栏： Android开发艺术探索笔记 Android 文章标签： android开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lim_dev/article/details/77277696
版权

内容和案例参考自《Android开发艺术探索》

Android中的IPC方式

  1. 通过在Intent中附加extras（Bundle）来传递信息
  2. 通过共享文件、SharedPreference的方式共享数据
  3. Messenger方式（AIDL、Binder）跨进程通信
  4. ContentProvider（Binder）实现跨进程访问
  5. Socket实现IPC

一、 Bundle

  1. 四大组件中的三大组件（Activity、Service、Receiver）均支持在Intent中传递Bundle数据
  2. Bundle实现了Parcelable接口，因此可以跨进程通信
  3. 传输的数据必须要能够被序列化：基本类型、实现了Parcelable接口的对象、实现了Serializable接口的对象及一些Android支持的特殊对象。

二、 文件共享

  1. 使用文件，通过ObjectInputStream、ObjectOutputStream输入输出数据；不适合并发场景。
  2. 使用SharedPreferences，SharedPreferences也属于文件的一种，但是系统对它的读写有一定的缓存策略，即内存中会有一份SharedPreferences文件的缓存。

三、 Binder

3.1 Messenger

  • Messenger的特点：以串行的方式处理客户端发来的消息。主要用于传递消息，不能做到跨进程调用服务端的方法。
  • 利用Messenger使得客户端与服务端能相互通信：
  • 定义或声明客户端与服务端的成员。
    1. 创建服务，在AndroidManifest.xml文件中注册服务。
    2. 客户端：声明mServiceMessenger。
    3. 客户端：创建mClientHandler（handleMessage()已重写）。
    4. 客户端：创建mClientMessenger（通过mClientHandler初始化）。
    5. 服务端：声明mClientMessenger。
    6. 服务端：创建mServiceHandler（handleMessage()已重写）。
    7. 服务端：创建mServiceMessenger（通过mClientHandler初始化）。
  • 进程通信时客户端方法的执行
    1. 客户端：利用onServiceConnected()中的参数Binder初始化mServiceMessenger。
    2. 客户端：创建Message对象，并设置what、data、replyTo（设置为mClientMessenger）参数。
    3. 客户端：通过mServiceMessenger.send(Message)将Message发送给服务端。
  • 进程通信时服务端方法的执行。
    1. 服务端：在handleMessage()中获取并输出Message中data的数据；获取Message中replyTo的Messenger并初始化mClientMessenger。
    2. 服务端：通过mClientMessenger.send(Message)回复Message给客户端。
// 客户端：MainActivity.java
public class MainActivity extends AppCompatActivity implements View.OnClickListener {
    // 创建Messenger对象
    private Messenger mService;

    private Messenger mReplyMessenger = new Messenger(new MessengerHandler());

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        // ... 省略
    }

    private void sendMessage() {
        Message msg = Message.obtain(null, MessengerService.MSG_FROM_CLIENT);
        Bundle data = new Bundle();
        data.putString("msg", mEtMsg.getText().toString());
        msg.setData(data);
        // 将信使Messenger传递给Service
        msg.replyTo = mReplyMessenger;
        try {
            mService.send(msg);
        } catch (RemoteException e) {
            e.printStackTrace();
        }
    }

    private void bind() {
        Intent intent = new Intent(this, MessengerService.class);
        bindService(intent, mConnection, BIND_AUTO_CREATE);
    }

    private void unbind() {
        unbindService(mConnection);
    }

    private ServiceConnection mConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            // 利用onBind()返回的Binder创建Messenger
            mService = new Messenger(service);
            Log.d(TAG, "onServiceConnected: 服务已绑定");
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
        }
    };

    @Override
    public void onClick(View v) {
        // ... 省略
    }

    private static class MessengerHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case MessengerService.MSG_FROM_SERVICE:
                    Log.d(TAG, "receive message from service: " + msg.getData().getString("reply"));
                    break;
                default:
                    super.handleMessage(msg);
            }
        }
    }
}
// 服务端：MessengerService.java
public class MessengerService extends Service {

    public static final String TAG = "MessengerService";

    public static final int MSG_FROM_CLIENT = 0;
    public static final int MSG_FROM_SERVICE = 1;


    private final Messenger mMessenger = new Messenger(new MessengerHandler());

    private static class MessengerHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case MSG_FROM_CLIENT:
                    // 打印客户端消息
                    Log.d(TAG, "handleMessage: receive message from Client : " + msg.getData().getString("msg"));

                    // 回复消息给客户端
                    Messenger client = msg.replyTo;
                    Message replyMsg = Message.obtain(null, MSG_FROM_SERVICE);
                    Bundle data = new Bundle();
                    data.putString("reply", "消息已收到");
                    replyMsg.setData(data);
                    try {
                        client.send(replyMsg);
                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }
                    break;
                default:
                    super.handleMessage(msg);
            }
        }
    }

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return mMessenger.getBinder();
    }
}

3.2 AIDL

  1. 服务端：
    • 创建Service来监听客户端的连接请求，然后创建一个AIDL文件，将暴露给客户端的接口在AIDL文件中声明，最后在Service实现这个AIDL。
  2. 客户端：
    • 绑定服务端的Service，绑定成功后，将服务端返回的Binder对象转成AIDL接口所属的类型，接下来就可以调用AIDL中的方法。
  3. AIDL接口中支持的数据类型：
    • 基本数据类型；
    • String和CharSequence；
    • List：只支持ArrayList，里面的每个元素必须能够被AIDL支持；
    • Map：只支持HashMap，里面的每个元素必须能够被AIDL支持，包括key和value；
    • Parcelable：所有实现了Parcelable接口的对象（需导入）；
    • AIDL：所有的AIDL接口本身也可以在AIDL文件中使用（需导入）；
    • 注意：
      • 自定义的Parcelable对象和AIDL必须要显式import进来；
      • 如果AIDL中用到了自定义Parcelable对象，必须新建一个与其同名的AIDL，并在其中声明它为Parcelable对象；
      • AIDL中除了基本数据类型，其他类型的参数必须标上方向：in、out或者inout，in表示输入型参数，out表示输出型参数，inout表示输入输出型参数，不能一概使用out或者inout，因为底层实现有开销；
      • AIDL的包结构在服务端和客户端要保持一致，哪怕客户端是另外一个应用；
  4. AIDL实现客户端与服务端通信
    • AIDL方法是在服务端的Binder线程池中执行的，因此当多个客户端同时连接会存在多线程同时访问的情况，所以需要在AIDL方法中处理线程同步；
    • 当服务端返回CopyOnWriteArrayList、ConcurrentHashMap时，Binder会按照List、Map的规范去访问数据并最终形成ArrayList、HashMap返回给客户端；
    • onNewBookArrivied方法在客户端的Binder线程池中执行，为了便于UI操作，我们需要通过Handler切换到客户端的主线程中去执行；
    • Binder会把客户端传递过来的对象重新转化并生成一个新的对象；服务端存储客户端的监听对象时，不能用普通的List，应使用RemoteCallbackList；
    • RemoteCallbackList是一个泛型，支持管理任意的AIDL接口；客户端进程终止后，它能够自动移除客户端所注册的listener，另外，其内部自动实现了线程同步的功能；
    • RemoteCallbackList的beginBroadcat、finihBroadcat必须要配对使用，哪怕仅仅是获取RemoteCallbackList中的元素个数。
    • 注意：
      • 客户端调用远程服务的方法，被调用的方法运行在客户端的Binder线程池中，同时客户端线程会被挂起，因此调用客户端调用服务端的耗时方法时，不能在客户端的UI线程；
      • 发起远程调用请求的方法需考虑ANR问题；
      • 服务端远程调用客户端的方法时，被调用的方法运行在客户端的Binder线程池中，因此被调用的方法不能操作UI线程，需要使用Handler将操作切换到UI线程；
      • 服务端的方法本身运行在服务端的Binder线程池中，服务端方法本身就可以执行大量耗时操作，此时无需在服务端方法中开线程进行异步任务，除非你明确知道自己在做什么。
  5. Binder意外死亡时重新连接服务：
    • 第一种方法是给Binder设置DeathRecipient监听，当Binder死亡时，我们会收到；binderDied方法的回调，在binderDied方法中我们可以重新连接远程服务
    • 第二种方法是在onServiceDisconnected中重新连接远程服务；
    • 区别是onServiceDisconnected在客户端的UI线程中被回调，而binderDied在客户端的Binder线程池中被回调。
// Book.aidl
package com.slim.ipcaidlobserver;

parcelable Book;
// IOnNewBookArrivedListener.aidl
package com.slim.ipcaidlobserver;

import com.slim.ipcaidlobserver.Book;

interface IOnNewBookArrivedListener {
    void onNewBookArrived(in Book newBook);
}
// IBookManager.aidl
package com.slim.ipcaidlobserver;

import com.slim.ipcaidlobserver.Book;
import com.slim.ipcaidlobserver.IOnNewBookArrivedListener;

interface IBookManager {
    List<Book> getBookList();
    void addBook(in Book book);
    void registerListener(IOnNewBookArrivedListener listener);
    void unregisterListener(IOnNewBookArrivedListener listener);
}
// Book.java
public class Book implements Parcelable {
    public int bookId;
    public String bookName;

    public Book(int bookId, String bookName) {
        this.bookId = bookId;
        this.bookName = bookName;
    }

    @Override
    public int describeContents() {
        return 0;
    }

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeInt(bookId);
        dest.writeString(bookName);
    }

    public static final Creator<Book> CREATOR = new Creator<Book>(){
        @Override
        public Book createFromParcel(Parcel source) {
            return new Book(source);
        }

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

    private Book(Parcel source) {
        bookId = source.readInt();
        bookName = source.readString();
    }

    @Override
    public String toString() {
        return "Book{" +
                "bookId=" + bookId +
                ", bookName='" + bookName + '\'' +
                '}';
    }
}
// BookManagerService.java
public class BookManagerService extends Service {
    private static final String TAG = "BookManagerService";

    private CopyOnWriteArrayList<Book> mBookList = new CopyOnWriteArrayList<>();

    private RemoteCallbackList<IOnNewBookArrivedListener> mListenerList = new RemoteCallbackList<>();

    private Binder mBinder = new IBookManager.Stub() {
        @Override
        public List<Book> getBookList() throws RemoteException {
            return mBookList;
        }

        @Override
        public void addBook(Book book) throws RemoteException {
            mBookList.add(book);
            Log.d(TAG, "书籍添加成功");
            onNewBookArrived(book);
        }

        @Override
        public void registerListener(IOnNewBookArrivedListener listener) throws RemoteException {
            mListenerList.register(listener);
        }

        @Override
        public void unregisterListener(IOnNewBookArrivedListener listener) throws RemoteException {
            mListenerList.unregister(listener);
        }
    };

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return mBinder;
    }

    public void onNewBookArrived(Book book) {
        final int N = mListenerList.beginBroadcast();
        for (int i = 0; i < N; i++) {
            try {
                IOnNewBookArrivedListener listener = mListenerList.getBroadcastItem(i);
                if (listener != null) {
                    listener.onNewBookArrived(book);
                }
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }
        mListenerList.finishBroadcast();
    }
}
// MainActivity.java
public class MainActivity extends AppCompatActivity implements View.OnClickListener{
    private static final String TAG = "MainActivity";

    private static final int MESSAGE_BOOK_ARRIVED = 1;

    private EditText mEtBookId;
    private EditText mEtBookName;
    private Button mBtBookAdd;
    private Button mBtBookList;
    private Button mBtBind;
    private Button mBtUnbind;
    private Button mBtRegister;
    private Button mBtUnregister;

    private IBookManager mBookManager;

    private Handler mHandler = new Handler(){
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case MESSAGE_BOOK_ARRIVED:
                    Log.d(TAG, "receive new book: " + msg.obj);
                    break;
                default:
                    break;
            }
        }
    };

    private IOnNewBookArrivedListener mListener = new IOnNewBookArrivedListener.Stub() {
        @Override
        public void onNewBookArrived(Book newBook) throws RemoteException {
            mHandler.obtainMessage(MESSAGE_BOOK_ARRIVED, newBook).sendToTarget();
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mEtBookId = (EditText) findViewById(R.id.et_book_id);
        mEtBookName = (EditText) findViewById(R.id.et_book_name);
        mBtBookAdd = (Button) findViewById(R.id.bt_book_add);
        mBtBookList = (Button) findViewById(R.id.bt_book_list);
        mBtBind = (Button) findViewById(R.id.bt_bind);
        mBtUnbind = (Button) findViewById(R.id.bt_unbind);
        mBtRegister = (Button) findViewById(R.id.bt_register);
        mBtUnregister = (Button) findViewById(R.id.bt_unregister);

        mBtBookAdd.setOnClickListener(this);
        mBtBookList.setOnClickListener(this);
        mBtBind.setOnClickListener(this);
        mBtUnbind.setOnClickListener(this);
        mBtRegister.setOnClickListener(this);
        mBtUnregister.setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.bt_book_add:
                addBook();
                break;
            case R.id.bt_book_list:
                printBookList();
                break;
            case R.id.bt_bind:
                bind();
                break;
            case R.id.bt_unbind:
                unbind();
                break;
            case R.id.bt_register:
                register();
                break;
            case R.id.bt_unregister:
                unregister();
                break;
            default:
                break;
        }
    }

    public void addBook() {
        if (mBookManager == null) { return; }
        try {
            int bookId = Integer.parseInt(mEtBookId.getText().toString());
            String bookName = mEtBookName.getText().toString();
            mBookManager.addBook(new Book(bookId, bookName));
        } catch (RemoteException | NumberFormatException e) {
            e.printStackTrace();
        }
    }

    public void printBookList(){
        if (mBookManager == null) { return; }
        List<Book> bookList;
        try {
            bookList = mBookManager.getBookList();
            Log.d(TAG, "query book list: " + bookList.toString());
        } catch (RemoteException e) {
            e.printStackTrace();
        }
    }

    private ServiceConnection mConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            Log.d(TAG, "onServiceConnected: 服务已绑定");
            mBookManager = IBookManager.Stub.asInterface(service);
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            mBookManager = null;
            // 服务意外死亡时执行此方法，在此处设置重新连接至服务
        }
    };

    public void bind() {
        Intent intent = new Intent(this, BookManagerService.class);
        bindService(intent, mConnection, BIND_AUTO_CREATE);
    }

    public void unbind() {
        unbindService(mConnection);
    }

    public void register(){
        try {
            mBookManager.registerListener(mListener);
        } catch (RemoteException e) {
            e.printStackTrace();
        }
    }

    public void unregister(){
        try {
            mBookManager.unregisterListener(mListener);
        } catch (RemoteException e) {
            e.printStackTrace();
        }
    }
}

IPC方式的优缺点和适用场景

名称优点缺点适用场景
Bundle简单易用只能传输Bundle支持的数据类型四大组件间的进程间通信
文件共享简单易用不适合高并发场景，并且无法做到进程间的即时通信无并发访问情形，交换简单的数据实时性不高的场景
AIDL功能强大，支持一对多并发通信，支持实时通信使用稍复杂，需要处理好线程同步一对多通信且有RPC需求
Messenger功能一般，支持一对多串行通信，支持实时通讯不能很好的处理高并发情况，不支持RPC，数据通过Messenger进行传输，因此只能传输Bundle支持的数据类型低并发的一对多即时通信，无RPC需求，或无需要返回结果的RPC需求
ContentProvider在数据访问方面功能强大，支持一对多并发数据共享，可通过Call方法扩展其他操作可以理解为受约束的AIDL，主要提供数据源的CRUD操作一对多的进程间的数据共享
Socket功能强大，可以通过网络传输字节流，支持一对多并发实时通讯实现细节稍微有点繁琐，不支持直接的RPC网络数据交换
lim_dev
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android IPC机制总结（png图）
04-21
Android IPC机制总结,概念,使用场景,开启多进程模式,运行机制,优缺点以及场景等等
IPC机制的AIDL进阶,结合观察者模式
mengxin1995的博客
03-06 702
好久没写博客了,最近确实挺忙的,感情也不顺利,一直萎靡着,就这样吧,进入主题了.在半年前写过篇AIDL的入门Demo,< IPC机制第二篇,AIDL实现> 这边的案例实现是,客户端只有去请求服务器,服务器才会返回结果,那假设有这样一个需求:用户不想时不时地去访问,而是希望当服务器有最新咨询的时候能够主动推送到客户端上来,这就是一种典型的观察者模式了,当然里面还有一些问题需要注意的我们等下来总结.1
2020-11-05 DAY8 面向对象（二）
qq_42119837的博客
11-08 117
面向对象进阶 面向对象三大特性：继承、封装（隐藏）、多态。 封装（隐藏） 继承 多态
Android进程间通信——AIDL
zoujin6649的博客
03-27 342
使用Messenger来进行进程间通信的方法，可以发现，Messenger是以串行的方式处理客户端发来的消息，如果大量的消息同时发送到服务端，服务断仍然只能一个个处理，如果有大量的并发请求，那么用Messenger就不太合适了。同时，Messenger的作用主要是为了传递消息，很多时候我们可能需要跨进程调用服务端的方法，这种情形用Messenger就无法做到了，但是我们可以使用AIDL来实现跨进程...
IPC机制之AIDL实现客户端回调（四）
不死就继续
07-06 787
IPC机制之AIDL传递基础类型数据 IPC机制之AIDL传递Parcelable IPC机制之Messenger示例序言前面的3篇文章文章实现了多进程的通讯，但是都只完成了客户端调用服务端的方法或者客户端发送消息和服务端通信，下面我们介绍下AIDL中的观察者模式，客户端绑定服务端成功狗，回调客户端的方法。以上代码都在在 IPC机制之AIDL传递Parcelable 文章的基础上实现的，所以只
Android使用文件进行IPC
08-31
总结，使用文件进行IPC在Android中是一种简单但可能效率较低的方式。它适合处理小型数据和简单的文本信息，但对于大型数据或复杂的对象结构，推荐使用更高级的IPC机制，如AIDL（Android Interface Definition ...
Android 基于Socket 的IPC通信
05-25
Android 基于Socket 的IPC通信
AndroidIPC_apk
06-11
Android端实现的基于Onvif的IPC，https://www.jianshu.com/p/e241fc0e23f2
Android IPC机制demo
05-21
Android IPC机制demo，ContentProvider、Socket进行跨进程通信例子，本人博客内有详述。
300ssm_jsp_mysql 记账管理系统.zip（可运行源码+sql文件+文档）
06-28
管理员需要配置的功能模块如下： （1）系统用户管理，管理员能够对系统中存在的用户的信息进行合理的维护操作，可以查看用户的信息以及在线进行密码的更换； （2）用户管理，管理员可以对该系统中用户进行管理，这个模块主要针对企业中的员工用户，管理员能够对这类的用户信息进行线上化的维护管理； （3）财务管理，该模块是整个系统的核心模块内容，在该模块的设计上，是通过对用户输入的收入、支出情况进行完整的内容查看，并且能够在线新增财务信息。 （4）财务统计，在财务统计的功能模块中，管理员可以看到当前所有用户累计的财务支出以及收入的情况，可以实现有效的数据统计工作。 本次的系统业务设计上是通过B/S结构来进行相应的管理系统搭建的。通过MVC三层框架结构来对整个系统中的不同功能模块实现分层的开发。在整个开发的过程中通过对不同的角色用户进行不同的功能权限的分配来对整个系统进行完整的设计。通过对不同的记账管理系统进行研究分析，了解到当下的记账管理系统普遍在收入、支出的统计上作为系统的核心要素来进行设计，在收支的系统自动统计上也需要进行有效的合理的内容设计。并且不同人员输入的信
一个简单的计数器，带有 2 个多路复用 SSD 和 2 个推送 btns 以递增或复位，使用分层架构在基于 stm32 ARM
06-28
一个简单的计数器，带有 2 个多路复用 SSD 和 2 个推送 btns 以递增或复位，使用分层架构在基于 stm32 ARM 的微控制器上运行
yolov8算法火焰和烟雾识别训练权重+数据集
06-28
yolov8算法火焰和烟雾识别训练权重， 包含15000多火焰和烟雾识别数据集（有网盘链接），数据集目录已经配置好，划分好 train，val, test，并附有data.yaml文件，yolov5、yolov7、yolov8，yolov9等算法可以直接进行训练模型，txt格式标签， 数据集和检测结果参考：https://blog.csdn.net/zhiqingAI/article/details/124230743 数据集配置目录结构data.yaml： nc: 2 names: - fire - smoke
docker python3:10版本 镜像
06-28
docker python3:10 版本 镜像
代码，源代码，购物网站，电子商务，电子商务网站，.net代码，源代
06-28
代码，源代码，购物网站，电子商务，电子商务网站，.net代码，源代码，网站源代码，购物网站源代码，asp.net，asp.net的购物网站，sql2000数据库，vs2010平台，网站制作，网站制作源代码，c#，C#网站，C#购物网站，C#电子商务网站，全套的购物网，电子商务源代码，asp.net购物网站源码，简单的源代码，基本实现购物，实现购物的源代码，适用。1
精通YOLOv5训练：关键技巧与实战指南
最新发布
06-28
YOLOv5是YOLO（You Only Look Once）系列目标检测算法的第五个版本，由 Ultralytics 公司开发。YOLO是一种流行的实时目标检测系统，以其快速和准确的目标检测性能而闻名。YOLOv5是该系列算法中较新的版本，它在速度和准确性上都进行了优化和改进。 YOLOv5的主要特点包括： 1. **速度快**：YOLOv5能够实现快速的目标检测，适用于需要实时处理的应用场景。 2. **准确性高**：与之前的版本相比，YOLOv5在保持高速度的同时，也提高了检测的准确性。 3. **易于使用**：YOLOv5提供了简单的API和配置，使得开发者可以轻松地将其集成到自己的项目中。 4. **多尺度检测**：YOLOv5能够检测不同尺寸的目标，适用于从小型到大型目标的检测。 5. **多任务能力**：除了目标检测，YOLOv5还可以用于其他任务，如图像分类、分割等。 6. **模型泛化能力强**：YOLOv5在多种数据集上都表现出良好的性能，具有很好的泛化能力。 YOLOv5的开发团队提供了预训练模型和训练脚本，使得用户可以快速地在自己的数据集上进行训练和部署。
281ssm_mysql_jsp 企业人事管理系统.zip（可运行源码+sql文件+文档）
06-28
人事管理是现代企业管理中不可忽视的一个重要组成部分，竞争对于企业管理者提出了更多的挑战，人事的管理另一种意义，就是对企业生命和前途的管理，人事是最宝贵的资源，一个企业没有了可用之才，那么这个企业会变得岌岌可危，实现办公自动化已经得到了企业的重视，企业要想在当今激烈的竞争中生存下来，就必须要引入信息化管理，做好人才的管理工作。 本系统在设计方面采用B/S模式，本系统前台设计主要采用了JSP作为开发语言，并且成功整合了SSH高级框架，后台设计主要采用了mysql作为数据库管理系统，开发环境采用了MyEclipse，服务器采用tomcat。本网站的开发为企业的发展奠定了基础。 系统包括：1登陆页面；2部门管理页面；3加班页面；4考勤页面；5请假页面；6工资页面；7业绩页面；8用户页面。 关键词：协同分析算法,mysql，jsp， B/S结构
基于卷积神经网络(CNN)的车牌自动识别系统车牌数据集和字符数据集
06-28
1、车牌数据集 2、字符卷积神经网络训练网络 3、字符数据
后端：springboot3+mybatis-plus+shiro 前端：layui 模板引擎：freemarker 数据库：p
06-28
后端：springboot3+mybatis-plus+shiro 前端：layui 模板引擎：freemarker 数据库：postgresql/mysql 基础后台管理架子
293ssm_mysql_jsp 大创项目申报管理系统.zip（可运行源码+sql文件+文档）
06-28
本文借助WEB端开发设计一款针对项目申报管理的大创项目申报管理系统，通过系统平台实现了项目模板下载、项目信息管理、项目在线审批以及往届项目数据查询等功能，开发过程中主要借助SSM框架结构以及Java编程语言来实现页面的呈现及数据信息的调取，结合Mysql数据库的应用实现项目信息内容的管理及逻辑关系的构建，通过系统的应用进一步提升项目申报和内容审批的效率。 管理员用户登录进入大创项目申报管理系统后通过左侧的导航栏可以实现以下功能模块的应用：用户信息管理、工作人员管理、项目模板管理、项目申报管理，通过以上主要功能模块可以实现系统项目模板内容及项目申报内容的查看和维护，同时可以通过往届项目管理以及我的项目申报管理实现在线的审批及历史记录的查看。系统管理员用户借助后台的工作人员管理模块可以实现项目申报工作人员信息的添加，包括了工作人员的工号姓名以及手机身份证号等个人信息，对应的工作人员可以通过管理员用户提供的工号和密码实现大创项目申报管理系统平台的登录，管理员可以通过工作人员查询模块实现系统 关键词：SSM框架；Java编程语言；项目信息；项目申报模板下载；
Android IPC
09-17
Android IPC（Inter-process Communication）是指在 Android 应用程序中不同进程之间进行通信的机制。Android 提供了多种 IPC 机制，包括：Intent、Binder、ContentProvider、Messenger 等。 其中最常用的是 Binder 机制，它是一种高效的进程间通信方式。Binder 通过提供跨进程的方法调用，使得不同进程之间可以像调用本地方法一样进行通信。在 Binder 机制中，包含服务端、客户端、Binder 驱动和 Binder 运行时四个主要组件。服务端在一个独立的进程中创建并提供服务，客户端通过 Binder 接口与服务端进行通信。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值