AIDL的真相-Android中的代理(Proxy)模式

Author Avatar
Jerey_Jobs 8月 19, 2016

设计模式

简介

我在公司负责的模块,是以本地代理模式的形式提供给其他人使用的, so, 总结了一下关于代理模式的概念.

代理两个字我们平时接触的还是很多的, 比如我们经常使用http代理, 我们的人事代理, 我们的法务代理, 其实都是我们不想做一件事情, 让另一个对象帮我来做这个事情. 那么我们的代理模式定义就出来了:

为其他对象提供一种代理,以控制对这个对象的访问.

官方定义

代理模式是对象的结构型模式。代理模式给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。

使用场景

当无法或者不想直接访问某个对象, 或者访问某个对象存在困难时, 可以通过一个代理对象来间接访问, 为了保证客户端使用的透明性, 委托对象与代理对象需要实现相同的接口.

使用方法

我们通过一个简单的demo来说明代理模式这一结构型设计模式是如何架构的.

假设,我们现在要去上班写代码, 那当然需要打卡了 , 我希望找到一个人代理帮我打卡上下班…

1
2
3
4
public interface Worker {
    void clockIn(); //上班打卡
    void clockOff(); //下班打卡
}

我就是这个需要被人给我打卡的人. 我们实现一下我的卡:

1
2
3
4
5
6
7
8
9
10
11
12
13
class Xiamin implements Worker{
    private static final String TAG = "Xiamin";
    @Override
    public void clockIn() {
        Log.d(TAG, "哔!上班!");
    }
    @Override
    public void clockOff() {
        Log.d(TAG, "哔!下班!");
    }
}

公司有个人专门代理打卡. 当然, 他会持有代理人的卡, 也就是我的卡在他那.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class ClockProxy implements Worker{
    private Worker mWorker;
    public ClockProxy(Worker worker) {
        this.mWorker = worker;
    }
    @Override
    public void clockIn() {
        mWorker.clockIn();
    }
    @Override
    public void clockOff() {
        mWorker.clockOff();
    }
}

这个代理人可以代理任何人打卡, 以后打卡,都是代理人去打卡,仿佛这个卡已经与我没什么关系了. 打卡处的人也见不到我了,因为一直是代理人帮我打卡.这就是代理模式的运用-不想直接访问某个对象

Android中代理模式的应用

最大的应用还是AIDL, 当然, 我们先看一下系统中的那些著名应用.

  • AMS与WMS,两大Framework框架

    案例文件为: /frameworks/base/core/java/android/app/ActivityManagerNative.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public abstract class ActivityManagerNative extends Binder implements IActivityManager{
	static public IActivityManager asInterface(IBinder obj) {
        if (obj == null) {
            return null;
        }
        IActivityManager in =
            (IActivityManager)obj.queryLocalInterface(descriptor);
        if (in != null) {
            return in;
        }
        return new ActivityManagerProxy(obj);
    }
}
class ActivityManagerProxy implements IActivityManager
{
    public ActivityManagerProxy(IBinder remote) {
        mRemote = remote;
    }
	...
}

从上面的代码中,我们可以看到ActivityManagerProxy代理了ActivityManagerNative的实现类.

那么它的实现类是谁呢, 我们看下面这个代码.

1
public final class ActivityManagerService extends ActivityManagerNative

我们看一下整个类的结构图：

ActivityManagerNative

没错,我们的AMS就是继承于ActivityManagerNative的, 而我们正常使用的AMS都是代理类,

说实话,不拿代理类,直接给应用拿到我们核心的AMS, 那Android岂不危矣.

  • AIDL

    其实通过上面的Demo,我们就应该能发现, 这种模式与我们写的AIDL进程间通信很像. ,

    好了,二话不说,我们写一个AIDL文件,看看生成的java文件是什么吧.,

    定义的AIDL文件.

1
2
3
4
5
6
7
8
9
10
11
12
13
// IMyAidlInterface.aidl
package com.jerey.learning;
// Declare any non-default types here with import statements
interface IMyAidlInterface {
    /**
     * Demonstrates some basic types that you can use as parameters
     * and return values in AIDL.
     */
    int getBookCount();
    void addBook(String book , int price);
}

生成的代码.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
public interface IMyAidlInterface extends android.os.IInterface
{
    /** Local-side IPC implementation stub class. */
    public static abstract class Stub extends android.os.Binder implements com.jerey.learning.IMyAidlInterface
    {
        private static final java.lang.String DESCRIPTOR = "com.jerey.learning.IMyAidlInterface";
        /** Construct the stub at attach it to the interface. */
        public Stub()
        {
            this.attachInterface(this, DESCRIPTOR);
        }
        /**
         * Cast an IBinder object into an com.jerey.learning.IMyAidlInterface interface,
         * generating a proxy if needed.
         */
        public static com.jerey.learning.IMyAidlInterface asInterface(android.os.IBinder obj)
        {
            if ((obj==null)) {
                return null;
            }
            android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
            if (((iin!=null)&&(iin instanceof com.jerey.learning.IMyAidlInterface))) {
                return ((com.jerey.learning.IMyAidlInterface)iin);
            }
            return new com.jerey.learning.IMyAidlInterface.Stub.Proxy(obj);
        }
        @Override public android.os.IBinder asBinder()
        {
            return this;
        }
        @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_getBookCount:
                {
                    data.enforceInterface(DESCRIPTOR);
					//-----------------------------我们好像是会实现这个的哦
                    int _result = this.getBookCount();
                    reply.writeNoException();
                    reply.writeInt(_result);
                    return true;
                }
                case TRANSACTION_addBook:
                {
                    data.enforceInterface(DESCRIPTOR);
                    java.lang.String _arg0;
                    _arg0 = data.readString();
                    int _arg1;
                    _arg1 = data.readInt();
                    this.addBook(_arg0, _arg1);
                    reply.writeNoException();
                    return true;
                }
            }
            return super.onTransact(code, data, reply, flags);
        }
		/*多么熟悉的Proxy*/
        private static class Proxy implements com.jerey.learning.IMyAidlInterface
        {
            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;
            }
            @Override public int getBookCount() throws android.os.RemoteException
            {
                android.os.Parcel _data = android.os.Parcel.obtain();
                android.os.Parcel _reply = android.os.Parcel.obtain();
                int _result;
                try {
                    _data.writeInterfaceToken(DESCRIPTOR);
                    mRemote.transact(Stub.TRANSACTION_getBookCount, _data, _reply, 0);
                    _reply.readException();
                    _result = _reply.readInt();
                }
                finally {
                    _reply.recycle();
                    _data.recycle();
                }
                return _result;
            }
            @Override public void addBook(java.lang.String book, int price) 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.writeString(book);
                    _data.writeInt(price);
                    mRemote.transact(Stub.TRANSACTION_addBook, _data, _reply, 0);
                    _reply.readException();
                }
                finally {
                    _reply.recycle();
                    _data.recycle();
                }
            }
        }
        static final int TRANSACTION_getBookCount = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
        static final int TRANSACTION_addBook = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);
    }
    public int getBookCount() throws android.os.RemoteException;
    public void addBook(java.lang.String book, int price) throws android.os.RemoteException;
}

而我们在自己的Service中会定义这个

1
2
3
4
5
6
7
8
9
10
11
private IMyAidlInterface.Stub myAidlInterface = new IMyAidlInterface.Stub() {
        @Override
        public int getBookCount() throws RemoteException {
            return 0;
        }
        @Override
        public void addBook(String book, int price) throws RemoteException {
            Log.d("xiamin","service addBook  " + book +" "+ price);
        }
    };

然而使用的时候,我们会这样:

1
myAidlInterface = IMyAidlInterface.Stub.asInterface(iBinder);

而asInterface中,返回的是这个

return new com.jerey.learning.IMyAidlInterface.Stub.Proxy(obj);

因此,我们拿到的是AIDL的java文件中的proxy对象.

所以:myAidlInterface.addBook(“nihao”,123);

其实调用的是AIDL生成的java文件中的代理的这段代码.

其实到这边,是一个binder进程间通信.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
      @Override
public void addBook(java.lang.String book, int price) 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.writeString(book);
                _data.writeInt(price);
                mRemote.transact(Stub.TRANSACTION_addBook, _data, _reply, 0);
                _reply.readException();
            }
            finally {
                _reply.recycle();
                _data.recycle();
            }
        }

谢谢大家阅读，如有帮助，来个喜欢或者关注吧！

本文作者：Anderson/Jerey_Jobs

博客地址 ： 夏敏的博客/Anderson大码渣/Jerey_Jobs

简书地址 : Anderson大码渣

CSDN地址 : Jerey_Jobs的专栏

github地址 : Jerey_Jobs

expand_less