春风十里不如你、与IPC的邂逅

最新推荐文章于 2022-12-13 09:12:46 发布
最新推荐文章于 2022-12-13 09:12:46 发布
阅读量1.5k 收藏
点赞数 1
分类专栏： Android学习笔记 文章标签： android ipc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CallMeSP/article/details/57586275
版权

今天要梳理的知识是Android中的IPC机制，由于这一点难度太高又相对重要，所以笔者也是主要参考了一些书才完成了这篇文章。

  • IPC是Inter-Process Communication的缩写，含义是进程间通信或者是进程间通信，是指两个进程之间进行数据交换的过程。

先说一下进程与线程的定义吧
进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。线程，有时被称为轻量级进程(Lightweight Process，LWP），是程序执行流的最小单元。
所以多进程有什么意义呢？

好处：

  • 分担主进程的内存压力。
    当应用越做越大，内存越来越多，将一些独立的组件放到不同的进程，它就不占用主进程的内存空间了。当然还有其他好处，有心人会发现
  • 使应用常驻后台，防止主进程被杀守护进程，守护进程和主进程之间相互监视，有一方被杀就重新启动它。
    Android后台进程里有很多应用是多个进程的，因为它们要常驻后台，特别是即时通讯或者社交应用，不过现在多进程已经被用烂了。
    典型用法是在启动一个不可见的轻量级私有进程，在后台收发消息，或者做一些耗时的事情，或者开机启动这个进程，然后做监听等。

坏处：

  • 消耗用户的电量。
  • 多占用了系统的空间，若所有应用都这样占用，系统内存很容易占满而导致卡顿。
  • 应用程序架构会变得复杂，因为要处理多进程之间的通信。这里又是另外一个问题了。

其它缺陷：

  • Application的多次重建。
  • 静态成员和单例模式的完全失效。
  • 线程同步机制失效。
  • SharedPreference可靠性下降。

既然它有很多缺点，所以我们就放弃吧

（怎么可能？你在逗我？当然要学习啊！）

下面通过一些小代码来看一下吧
在Android中使用多进程只有一种方法：
就是给四大组件（Activity、Service、Receiver、ContentProvider）在AndroidManifest中指定android:process属性。

<activity  
    android:name=".MainActivity"  
    android:configChanges="orientation|screenSize"  
    android:label="@string/app_name"  
    android:launchMode="standard" >  
    <intent-filter>  
        <action android:name="android.intent.action.MAIN" />  
    </intent-filter>  
</activity>  
<activity  
    android:name=".SecondActivity"  
    android:configChanges="screenLayout"  
    android:label="@string/app_name"  
    android:process=":remote" />  
<activity  
    android:name=".ThirdActivity"  
    android:configChanges="screenLayout"  
    android:label="@string/app_name"  
    android:process="com.ryg.chapter_2.remote" />

上面的代码中，
（1）MainActivity没有指定process属性，所以它运行在默认的进程中，默认进程的进程名是包名。
（2）SecondActivity会运行在一个单独的进程中，进程名为“com.ryg.chapter_2:remote”，其中com.ryg.chapter_2是包名。在程序中的冒号“：”的含义是指要在当前的进程名前面附加上当前的包名，是一种简写的方法。而且以“：”开头的进程属于当前应用的私有进程，其他应用的组件不可以和它跑在同一个进程中。
（3）ThirdActivity会运行在另一个单独的进程中，进程名为“com.ryg.chapter_2.remote”。这是一种完整的命名方式。属于全局进程，其他应用通过ShareUID方式可以和它跑在同一个进程中。
进程也创建好了，下面就是通信的内容了
在Android中最有特色的进程间通信方式就是Binder了，通过Binder可以轻松地实现进程间通信。
当我们需要通过Intent和Binder传输数据时就需要使用Parcelable或者Serializeble。Serializable和Parcelable接口可以完成对象的序列化过程。还有时候我们需要把对象持久化到存储 设备上或者通过网络传输给其他客户端，这个时候也需要Serializable来完成对象的持久化。
http://blog.csdn.net/callmesp/article/details/54632139 在我的这篇博客里面有使用过Serializable，我们就不再讲解了。我们就说一下Parcelable吧。

  • Parcelable也是一个接口，只要实现这个接口，一个类的对象就可以实现序列化并可以通过Intent和Binder传递。

看一个小demo

public class User implements Parcelable {  

    public int userId;  
    public String userName;  
    public boolean isMale;  

    public Book book;  

    public User(int userId, String userName, boolean isMale) {  
        this.userId = userId;  
        this.userName = userName;  
        this.isMale = isMale;  
    }  

    /* 
     * 内容描述功能几乎都是直接返回0的。 
     * */  
    public int describeContents() {  
        return 0;  
    }  

    /* 
     * 序列化由writeToParcel方法来完成，最终是通过Parcel中一系列write方法来完成的。 
     * 其中flags标识有两种值：0和1（PARCELABLE_WRITE_RETURN_VALUE）。 
     * 为1时标识当前对象需要作为返回值返回，不能立即释放资源， 
     * 几乎所有情况都为0。 
     * */  
    public void writeToParcel(Parcel out, int flags) {  
        out.writeInt(userId);  
        out.writeString(userName);  
        out.writeInt(isMale? 1:0);  
        out.writeParcelable(book, 0);  
    }  

    /* 
     * 反序列化功能是由CREATOR来完成，其内部标明了如何创建序列化对象和数组， 
     * 并通过Parcel的一些了read方法来完成反序列化过程。 
     * */  
    public static final Parcelable.Creator<User> CREATOR = new Parcelable.Creator<User>() {  
        // 从序列化后的对象中创建原始对象。  
        public User createFromParcel(Parcel in) {  
            return new User(in);  
        }  

        // 创建指定长度的原始对象数组  
        public User[] newArray(int size) {  
            return new User[size];  
        }  
    };  

    /* 
     * Parcel内部包装了可序列化的数据，可以在Binder中自由传输。 
     * 从序列化后的对象中创建原始对象。 
     * */  
    private User(Parcel in) {  
        userId = in.readInt();  
        userName = in.readString();  
        isMale = in.readInt() == 1;  
        /* 
         * 由于book是另一个可序列化对象，所以它的反序列化过程需要传递当前线程的上下文类加载器， 
         * 否则会报无法找到类的错误。 
         * */  
        book = in.readParcelable(Thread.currentThread().getContextClassLoader());  
    }  
}

既然Parcelable和Serializable都能实现系列化并且都可用于Intent间的数据传递，该如何选取呢？

  • Serializable用起来简单，但开销很大，序列化和反序列化过程都需要大量的I/O操作。
  • Parcelable是Android中的序列化方式，更适合在Android平台上使用，用起来比较麻烦，效率很高，首选。主要用在内存序列化上。

接下来就到了我们的重头戏Binder：

  • Binder实现了IBinder接口

  • 从IPC角度来说，Binder是Android中的一种跨进程通信方式。Binder还可以理解为一种虚拟的物理设备，它的设备驱动是/dev/binder，这种通信方式在Linux中没有。

  • 从Android
    Framework角度来说，Binder是ServiceManager连接各种Manager（ActivityManager、WindowManager，等等）和相应ManagerService的桥梁。

  • 从Android应用层来说，Binder是客户端和服务端进行通信的媒介，当bindService的时候，服务端会返回一个包含了服务端业务调用的Binder对象，通过这个对象，客户端就可以获取服务端提供的服务或者数据，这里的服务包括普通服务和基于AIDL的服务。

  • AIDL即Android interface definition Language，即Android接口定义语言。
    在分析Binder的工作原理之前，我们先补充一下Android设计模式之Proxy模式

Proxy代理模式简介

  • 代理模式是对象的结构模式。代理模式给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。
  • 模式的使用场景：就是一个人或者机构代表另一个人或者机构采取行动。在一些情况下，一个客户不想或者不能够直接引用一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。

  • 抽象对象角色AbstarctObject：声明了目标对象和代理对象的共同接口，这样一来在任何可以使用目标对象的地方都可以使用代理对象。

    目标对象角色RealObject：定义了代理对象所代表的目标对象。

    代理对象角色ProxyObject：代理对象内部含有目标对象的引用，从而可以在任何时候操作目标对象；代理对象提供一个与目标对象相同的接口，以便可以在任何时候替代目标对象。代理对象通常在客户端调用传递给目标对象之前或之后，执行某个操作，而不是单纯地将调用传递给目标对象。
    Proxy代理模式的简单实现
    抽象对象角色：

public abstract class AbstractObject {  
    //操作  
    public abstract void operation();  
}

目标对象角色：

public class RealObject extends AbstractObject {  
    @Override  
    public void operation() {  
        //一些操作  
        System.out.println("一些操作");  
    }  
}

代理对象角色：

public class ProxyObject extends AbstractObject{  
    RealObject realObject = new RealObject();//目标对象角色  
    @Override  
    public void operation() {  
        //调用目标对象之前可以做相关操作  
        System.out.println("before");          
        realObject.operation();        //目标对象角色的操作函数  
        //调用目标对象之后可以做相关操作  
        System.out.println("after");  
    }  
}

客户端：

public class Client {  
    public static void main(String[] args) {  
        AbstractObject obj = new ProxyObject();  
        obj.operation();  
    }  
}

我们通过一个案例来分析Binder工作原理

我们需要新建一个AIDL示例，SDK会自动为我们生产AIDL所对应的Binder类。
（1）Book.java：这里面没有什么特殊之处，为了实现Parcelable，添加了几个方法，上面在Parcelable部分已经介绍过了。

package com.ryg.chapter_2.aidl;  


import android.os.Parcel;  
import android.os.Parcelable;  


/* 
 * （1）它是一个表示图示信息的类， 
 * 它实现了Parcelable接口，因为实现了Parcelable接口便可以进行序列化 
 * （2）Book.aidl是Book类在ADIL中的声明。 
 * （3）IBookManager.aidl是我们定义的一个接口，里面有两个方法：getBookList和addBook， 
 * 其中getBookList用于从远程服务端获取图书列表，而addBook用于往图书列表中添加一本书， 
 * 当然这两个方法主要是示例用，不一定要有实际意义。 
 * （4）尽管Book类和IBookManager位于相同的包中，但是在IBookManager中仍然要导入Book类， 
 * 这就是AIDL的特殊之处。 
 * */  
public class Book implements Parcelable {      
    public int bookId;  
    public String bookName;      

    /* 
     * 普通构造函数： 
     * */  
    public Book() {      
    }       
    /* 
     * 普通构造函数： 
     * */  
    public Book(int bookId, String bookName) {  
        this.bookId = bookId;  
        this.bookName = bookName;  
    }  

    public int describeContents() {  
        return 0;  
    }  


    /* 
     * 序列化： 
     * */  
    public void writeToParcel(Parcel out, int flags) {  
        out.writeInt(bookId);  
        out.writeString(bookName);  
    }      

    /* 
     * 反序列化， 
     * 这个creator就是通过一个Parcle来创建一个book对象或者数组。 
     * */  
    public static final Parcelable.Creator<Book> CREATOR = new Parcelable.Creator<Book>() {  
        public Book createFromParcel(Parcel in) {  
            return new Book(in);  
        }          
        public Book[] newArray(int size) {  
            return new Book[size];  
        }  
    };      

    /* 
     * 用于反序列化的构造函数： 
     * */  
    private Book(Parcel in) {  
        bookId = in.readInt();  
        bookName = in.readString();  
    }  
    @Override  
    public String toString() {  
        return String.format("[bookId:%s, bookName:%s]", bookId, bookName);  
    }  
}

（2）Book.aidl：它是Book在AIDL中的声明。

package com.ryg.chapter_2.aidl;  

parcelable Book;

（3）IBookManager.aidl：虽然Book类已经和IBookManager位于相同的包中，但是这里依然需要导入Book类。这是AIDL的特殊之处。
它是一个接口，里面有四个方法。

package com.ryg.chapter_2.aidl;  

import com.ryg.chapter_2.aidl.Book;  
import com.ryg.chapter_2.aidl.IOnNewBookArrivedListener;  

interface IBookManager {  
     List<Book> getBookList();  
     void addBook(in Book book);  
     void registerListener(IOnNewBookArrivedListener listener);  
     void unregisterListener(IOnNewBookArrivedListener listener);  
}

（4）下面我们要看一下系统为IBookManager.aidl生产的Binder类，在gen目录下有一个IBookManager.java的类，这就是我们要找的类。

/* 
 * This file is auto-generated.  DO NOT MODIFY. 
 */  
package com.ryg.chapter_2.aidl;  
/* 
 * IBookManager它继承了IInterface这个接口，同时它自己也还是个接口， 
 * 所有可以在Binder中传输的接口都要继承IInterface接口。 
 * 首先，它声明了两个方法getBookList和addBook，显然这就是我们在IBookManager.aidl中所声明的方法， 
 * 同时它还声明了两个整型的id分别用于标识这两个方法。 
 * 接着，它声明了一个内部类Stub，这个Stub就是一个Binder类， 
 * 当客户端和服务端都位于同一个进程时，方法调用不会走跨进程的transact过程， 
 * 而当两者位于不同进程时，方法调用需要走transact过程， 
 * 这个逻辑由Stub的内部代理类Proxy来完成。 
 * */  
public interface IBookManager extends android.os.IInterface  
{  
 /** Local-side IPC implementation stub class. */  
 /* 
  * 首先这个Stub，它是一个内部类，它继承了Binder，所以它是一个Binder， 
  * 同时Stub还实现了IBookManager中的方法。 
  * */  
 public static abstract class Stub extends android.os.Binder implements com.ryg.chapter_2.aidl.IBookManager  
 {  
  /* 
   * Binder的唯一标识符。 
   * */  
  private static final java.lang.String DESCRIPTOR = "com.ryg.chapter_2.aidl.IBookManager";  

  /** Construct the stub at attach it to the interface. */  
  public Stub()  
  {  
   this.attachInterface(this, DESCRIPTOR);  
  }  

  /** 
   * Cast an IBinder object into an com.ryg.chapter_2.aidl.IBookManager interface, 
   * generating a proxy if needed. 
   */  
  /* 
   * 用于将服务端的Binder对象转换成客户端所需的AIDL接口类型的对象， 
   * 这种转换过程是区分进程的， 
   * 如果客户端和服务端位于同一进程，那么此方法返回的就是服务端的Stub对象本身， 
   * 否则返回的是系统封装后的Stub.proxy代理对象。 
   * */  
  public static com.ryg.chapter_2.aidl.IBookManager asInterface(android.os.IBinder obj)  
  {  
   if ((obj==null)) {  
    return null;  
   }  
   android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);  
   // 同一进程  
   if (((iin!=null)&&(iin instanceof com.ryg.chapter_2.aidl.IBookManager))) {  
    return ((com.ryg.chapter_2.aidl.IBookManager)iin);  
   }  
   // 不同进程  
   return new com.ryg.chapter_2.aidl.IBookManager.Stub.Proxy(obj);  
  }  

  /* 
   * 此方法用于返回当前Binder对象，也就是内部类Stub。 
   * */  
  @Override public android.os.IBinder asBinder()  
  {  
   return this;  
  }  

  /* 
   * 这个方法运行在服务端中的Binder线程池中， 
   * 当客户端发起跨进程请求时，远程请求会通过系统底层封装后交由此方法来处理。 
   * 服务端通过code可以确定客户端所请求的目标方法是什么， 
   * 接着从data中取出目标方法所需的参数， 
   * 然后执行目标方法。 
   * 当目标方法执行完毕后，就向reply中写入返回值。 
   * 如果此方法返回false，那么客户端的请求会失败，因此我们可以利用这个特性来做权限验证。 
   * */  
  @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException  
  {  
   switch (code)  
   {  
    case INTERFACE_TRANSACTION:  
    {  
     reply.writeString(DESCRIPTOR);  
     return true;  
    }  
    case TRANSACTION_getBookList:  
    {  
     data.enforceInterface(DESCRIPTOR);  
     /* 
      * 这句才是调用了真正的执行过程呢 
      * */  
     java.util.List<com.ryg.chapter_2.aidl.Book> _result = this.getBookList();  
     reply.writeNoException();  
     reply.writeTypedList(_result);  
     return true;  
    }  
    case TRANSACTION_addBook:  
    {  
     data.enforceInterface(DESCRIPTOR);  
     com.ryg.chapter_2.aidl.Book _arg0;  
     if ((0!=data.readInt())) {  
      _arg0 = com.ryg.chapter_2.aidl.Book.CREATOR.createFromParcel(data);  
     }  
     else {  
      _arg0 = null;  
     }  
     /* 
      * 这句才是调用了真正的执行过程呢 
      * */  
     this.addBook(_arg0);  
     reply.writeNoException();  
     return true;  
    }  
    case TRANSACTION_registerListener:  
    {  
     data.enforceInterface(DESCRIPTOR);  
     com.ryg.chapter_2.aidl.IOnNewBookArrivedListener _arg0;  
     _arg0 = com.ryg.chapter_2.aidl.IOnNewBookArrivedListener.Stub.asInterface(data.readStrongBinder());  
     this.registerListener(_arg0);  
     reply.writeNoException();  
     return true;  
    }  
    case TRANSACTION_unregisterListener:  
    {  
     data.enforceInterface(DESCRIPTOR);  
     com.ryg.chapter_2.aidl.IOnNewBookArrivedListener _arg0;  
     _arg0 = com.ryg.chapter_2.aidl.IOnNewBookArrivedListener.Stub.asInterface(data.readStrongBinder());  
     this.unregisterListener(_arg0);  
     reply.writeNoException();  
     return true;  
    }  
   }  
   return super.onTransact(code, data, reply, flags);  
  }  

  /* 
   * 代理类Proxy。 
   * */  
  private static class Proxy implements com.ryg.chapter_2.aidl.IBookManager  
  {  
   /* 
    * 这个mRemote代表的就是目标对象角色， 
    * */  
   private android.os.IBinder mRemote;  

   Proxy(android.os.IBinder remote)  
   {  
    mRemote = remote;  
   }  

   @Override public android.os.IBinder asBinder()  
   {  
    return mRemote;  
   }  

   public java.lang.String getInterfaceDescriptor()  
   {  
    return DESCRIPTOR;  
   }  

   /* 
    * 这个方法运行在客户端， 
    * 因为当客户端和服务端不在同一进程时，服务端返回代理类Proxy，所以客户端会通过Proxy调用到代理类的getBookList方法， 
    * 当客户端远程调用此方法时，它的内部实现是这样的： 
    * 首先创建该方法所需要的输入型Parcel对象_data、输出型Parcel对象_reply和返回值对象List， 
    * 然后把该方法的参数信息写入_data中， 
    * 接着调用transact方法来发起RPC（远程过程调用）请求，同时当前线程挂起， 
    * 然后服务端的onTransact方法会被调用，直到RPC过程返回后，当前线程继续执行， 
    * 并从_reply中取出RPC过程的返回结果。 
    * 最后返回_reply中的数据。 
    * */  
   @Override public java.util.List<com.ryg.chapter_2.aidl.Book> getBookList() throws android.os.RemoteException  
   {  
    android.os.Parcel _data = android.os.Parcel.obtain();  
    android.os.Parcel _reply = android.os.Parcel.obtain();  
    java.util.List<com.ryg.chapter_2.aidl.Book> _result;  
    try {  
    _data.writeInterfaceToken(DESCRIPTOR);  
    mRemote.transact(Stub.TRANSACTION_getBookList, _data, _reply, 0);  
    _reply.readException();  
    _result = _reply.createTypedArrayList(com.ryg.chapter_2.aidl.Book.CREATOR);  
    }  
    finally {  
    _reply.recycle();  
    _data.recycle();  
    }  
    return _result;  
   }  

   @Override public void addBook(com.ryg.chapter_2.aidl.Book book) throws android.os.RemoteException  
   {  
    android.os.Parcel _data = android.os.Parcel.obtain();  
    android.os.Parcel _reply = android.os.Parcel.obtain();  
    try {  
     _data.writeInterfaceToken(DESCRIPTOR);  
     if ((book!=null)) {  
      _data.writeInt(1);  
      book.writeToParcel(_data, 0);  
     }  
     else {  
      _data.writeInt(0);  
     }  
     mRemote.transact(Stub.TRANSACTION_addBook, _data, _reply, 0);  
     _reply.readException();  
    }  
    finally {  
     _reply.recycle();  
     _data.recycle();  
    }  
   }  

   @Override public void registerListener(com.ryg.chapter_2.aidl.IOnNewBookArrivedListener listener) throws android.os.RemoteException  
   {  
    android.os.Parcel _data = android.os.Parcel.obtain();  
    android.os.Parcel _reply = android.os.Parcel.obtain();  
    try {  
     _data.writeInterfaceToken(DESCRIPTOR);  
     _data.writeStrongBinder((((listener!=null))?(listener.asBinder()):(null)));  
     mRemote.transact(Stub.TRANSACTION_registerListener, _data, _reply, 0);  
     _reply.readException();  
    }  
    finally {  
     _reply.recycle();  
     _data.recycle();  
    }  
   }  

   @Override public void unregisterListener(com.ryg.chapter_2.aidl.IOnNewBookArrivedListener listener) throws android.os.RemoteException  
   {  
    android.os.Parcel _data = android.os.Parcel.obtain();  
    android.os.Parcel _reply = android.os.Parcel.obtain();  
    try {  
     _data.writeInterfaceToken(DESCRIPTOR);  
     _data.writeStrongBinder((((listener!=null))?(listener.asBinder()):(null)));  
     mRemote.transact(Stub.TRANSACTION_unregisterListener, _data, _reply, 0);  
     _reply.readException();  
    }  
    finally {  
     _reply.recycle();  
     _data.recycle();  
    }  
   }  
  }  

  /* 
   * 用于标识方法的整型id。 
   * 它们用于在transact过程总客户端所请求的到底是哪个方法。 
   * */  
  static final int TRANSACTION_getBookList = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);  
  static final int TRANSACTION_addBook = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);  
  static final int TRANSACTION_registerListener = (android.os.IBinder.FIRST_CALL_TRANSACTION + 2);  
  static final int TRANSACTION_unregisterListener = (android.os.IBinder.FIRST_CALL_TRANSACTION + 3);  

 }  

 /* 
  * 声明了在IBookManager.aidl中所声明的方法。 
  * 这里才是真正的方法声明。具体实现我们仍然没有看到呢。 
  * */  
 public java.util.List<com.ryg.chapter_2.aidl.Book> getBookList() throws android.os.RemoteException;  
 public void addBook(com.ryg.chapter_2.aidl.Book book) throws android.os.RemoteException;  
 public void registerListener(com.ryg.chapter_2.aidl.IOnNewBookArrivedListener listener) throws android.os.RemoteException;  
 public void unregisterListener(com.ryg.chapter_2.aidl.IOnNewBookArrivedListener listener) throws android.os.RemoteException;  
}

**注意点一：上面的Book类，就是一个可以Parcelable序列化的简单的Book类，它里面没有任何的方法，就是定义了一个简单的Book类结构。
注意点二：Book.aidl的存在是因为在IBookManager.aidl中出现的对象也必须有aidl声明。
注意点三：在IBookManager.aidl中，对于自动生成的IBookManager.java文件，它是服务器端的代码。当客户端向服务端发送连接请求时，如果客户端和服务端在同一进程中，那么服务端就向客户端返回Stub这个Binder对象，如果客户端和服务端在不同进程中，那么服务端就向客户端返回内部类Stub的内部代理类Proxy，然后客户端根据这个Proxy来调用Proxy内部的方法，这个Proxy内部含有服务端真正的Binder对象也就是那个内部类Stub，在客户端调用Proxy内部的方法也就会导致调用Stub的transact方法，而Stub的transact方法又会回调它自己的onTransact方法，onTransact方法是在服务端运行的，而transact方法是在客户端调用的，这样就实现了客户端调用服务端的方法了。当然这所有的传递过程也少不了Parcel这个数据包的协助。**

CallMeSP
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Can‘t locate IPC/Cmd.pm in @INC (@INC contains:解决方案
weixin_43178406的博客
12-30 3万+
本文主要介绍了Can’t locate IPC/Cmd.pm in @INC (@INC contains:解决方案，希望能对使用Linux的同学们有所帮助。 文章目录 1. 问题描述 2. 解决方案
Android学习笔记（十）--OKHttp持久化cookies实现模拟登陆
CallMeSP的博客
01-20 2673
最近打算写一个实现登陆学校的网站，实现查询成绩选课等等功能的app。于是就要用到OKHttp持久化cookie的相关知识，没有使用retrofit，所以打算认真写一篇博客来和大家分享一下我的学习心得。 GITHUB的地址是：https://github.com/CallMeSp/University_in_Hand.git 添加依赖什么的就不多说了，直接进入正文吧。 学校教务处的网站是：htt
ipc$入侵与防范（超详细）
weixin_63400287的博客
12-13 2637
就像上面所说的,即使你建立了一个空的连接,你也可以获得不少的信息(而这些信息往往是入侵中必不可少的),访问部分共享,如果你能够以某一个具有一定权限的用户身份登陆的话,那么你就会得到相应的权限,显然,如果你以管理员身份登陆,嘿嘿,就不用我在多说了吧,what u want,u can do!不过你也不要高兴的太早,因为管理员的密码不是那么好搞到的,虽然会有一些傻傻的管理员用空口令或者弱智密码,但这毕竟是少数,而且现在不比从前了,随着人们安全意识的提高,管理员们也愈加小心了,得到管理员密码会越来越难的。
开源项目mini-ipc简介
程序猿Ricky的日常干货
12-15 2180
简介 mini-ipc是一个进程间通信使用的开源库，由本猿独自开发的，可用于支持POSIX标准的类unix系统上。它的目标是为了更快速的实现用户空间的系统设计和应用设计。本库采用MIT-License开源协议，开发者可以使用这个开源库用于商业或者开源的项目中。 基于mini-ipc可以实现一个消息驱动的应用系统，每个应用都会创建自己的消息队列，并且等待消息的处理，这样可以让一个复杂的系统分解为各个...
Windows系统IPC$共享与勒索病毒
abraham76的博客
03-31 7197
  不同的进程各自有着不同的地址空间，每个进程的全局变量对其它进程是透明的。因此进程间要进行数据交互就要通过内核，在内核中开辟一块缓冲区，每个进程只需把要共享的数据拷贝到缓冲区即可，内核提供的这种机制称为进程间通信（IPC） 共享命名管道   关于进程间通信（InterProcess Communication），管道和共享内存为大家所熟知，包括匿名管道和命名管道。Windows系统的IPC$其实就命名管道的一种应用，考虑到它用于不同设备间通信，所以可以翻译为Internet Process Connect
渗透之——内网IPC$入侵
冰河的专栏
01-07 2560
转载请注明出处：https://blog.csdn.net/l1028386804/article/details/85995503 一、域操作相关的命令 1.查看域用户 net user/domain 2.查看有几个域 net view/domain 3.查看域内的主机 net view/domain: XXX 4.查看域里面的组 net group/domain 5...
PCC与PLC、IPC的区别
08-20
PCC与PLC、IPC的区别 在工业控制领域，PCC（Programmable Computer Controller）、PLC（Programmable Logic Controller）和IPC（Industrial Personal Computer）是三种常见的控制器。但是，它们之间有什么区别呢？...
安防与监控中的安防IPC怎么选芯片方案？
10-16
安防人都知道，询问视频监控产品时一般都会问上这么一句：“你家这产品用的是谁家的方案？”  由此，芯片方案对产品市场的影响可见一斑，尤其是IPC。  可眼下，很多企业在选择芯片方案时，却容易犯尴尬症。目前...
PLC与IPC的区别是什么？.doc
10-20
PLC与IPC的区别是什么？ 在工业控制领域中，PLC（Programmable Logic Controller）和IPC（Industrial PC）两种设备都是广泛应用于自动化控制系统的重要组成部分。但是，两者在硬件结构、软件资源、实时性、可靠性等...
IPC国际专利分类表-A部
最新发布
01-17
IPC国际专利分类表-A部 IPC国际专利分类表-A部是国际专利分类（IPC）的A部，涵盖人类生活必需品的制造、处理和应用。该分类表涉及农业、林业、畜牧业、狩猎、捕鱼、园艺、乳制品加工、食品加工、烟草加工等领域。 ...
ipc_最新中文标准目录_2022
03-08
IPC/WHMA-A-620D 是线缆及线束组件的要求与验收的唯一行业共识标准，描述了用于压接、机械紧固或焊接互连的材料、方法、测试和可接受性标准以及其他线缆线束组件组装活动的相关标准。 IPC/WHMA-A-620D-S 航天应用...
Android学习笔记（四）--RecyclerView扩展下拉刷新与左滑删除
CallMeSP的博客
10-24 1470
今天在使用QQ的时候就想到制作一个消息列表的类似效果，可以实现下拉刷新和左滑删除效果，于是就抽空试了试。先上效果图。 这是正在刷新的时候。然后就会增添一个item（那个刷新的圈是会转的然后还可以变颜色我不会截动图）。见下图。 RecyclerView的adpter使用的还是我上篇博客里的那个http://blog.csdn.net/callmesp/article/details/528
Android学习笔记（八）--CoordinatorLayout的应用-仿支付宝界面
CallMeSP的博客
11-04 1342
哈哈，差不多有一个礼拜没有更新，去广东那边旅游了四五天所以就没有更新，接下来就要恢复正常了，又要开始学习了。今天带来的是关于CoordinatorLayout的应用，模仿着支付宝做了一个界面，先看一下效果图吧。 实现了和支付宝一样的上滑收缩和变化的功能。核心使用的就是今天要说的coordinatorLayout。CoordinatorLayout作为“super-powered FrameLa
Android学习笔记（三）--ListView与RecyclerView
CallMeSP的博客
10-22 1258
在学习了几天Android之后，打算写个简单的app来试试手，于是就想写一个“便签”。在写列表的时候自然的想到了用一个ListView然后配置一个adpter来显示信息，但是呢，在逛论坛的时候发现现在使用RecyclerView的比较多，于是就看了几个demo，晚上也自己动手写了写。 使用完的感受是RecyclerView确实强大，有它流行起来的道理，毕竟长江后浪推前浪，前浪倒在沙滩上。让人感受明
Rxjava2源码浅析（一）
CallMeSP的博客
03-16 1205
面试的时候被问道各种框架的原理架构，也是很尴尬，自以为写的代码不少，用过的框架也不少，深入的去研究源码的还真是不多，也是给自己敲了一个警钟，今天就来尝试剖析一下Rxjava2的源码，水平有限，就先看一下基础的用法相关,一些难度更高的操作符就慢慢来分析吧。 就按照平时使用的顺序来分析：一、初始化Observerble基本使用实例：Observable<String> observable= Obse
Rxjava2源码浅析（二）
CallMeSP的博客
03-18 1105
上一篇文章：Rxjava2源码浅析（一） 分析了最基础的一套流程，今天呢就略加一些常用的操作吧。使用范例 上次我们在建立关系的时候就是这样光秃秃的一句话observable.subscribe(observer);这在平时使用的时候显然是不够用的，Rxjava的优势是什么？切换线程肯定要算一个啊，所以我们看一下下面这种使用方法。observable.subscribeOn(Schedulers
百步者半九十、关于Activity也许还能知道的更多
CallMeSP的博客
02-25 825
上一篇博客我们分析了Activity的生命周期，工作模式相关的内容。这篇博客我们将来一起探讨Activity的启动过程。 先看一张总的流程图（该图应该是5.0的，我们分析的是6.0的源码，一些细节不太一样，但并不重要） 然后让我们走进源码（基于api24）@Override public void startActivity(Intent intent, @Nullable Bund
Android学习笔记（七）--滑动选项卡TabLayout
CallMeSP的博客
10-27 753
今天想做一个类似腾讯体育那样的滑动选项卡，一开始的想法是选项卡是可以滑动扩展的就用个scrollview里面放button，下面用一个ViewPager，觉得实现起来也不复杂，然后发现官方为我们提供了一个TabLayout,使用起来也比较方便，先上一下效果图。 看一下主活动的布局<?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值