源码中出现throw new RuntimeException("Stub!")的理解

在阅读源码的过程中，发现有些类只定义了方法名和参数列表，里面具体的实现就一句话：throw new RuntimeException("Stub!")；

比如BaseDexClassLoader这个类：

[java]  view plain  copy

1. //  
2. // Source code recreated from a .class file by IntelliJ IDEA  
3. // (powered by Fernflower decompiler)  
4. //  
5.   
6. package dalvik.system;  
7.   
8. import java.io.File;  
9. import java.net.URL;  
10. import java.util.Enumeration;  
11.   
12. public class BaseDexClassLoader extends ClassLoader {  
13.     public BaseDexClassLoader(String dexPath, File optimizedDirectory, String librarySearchPath, ClassLoader parent) {  
14.         throw new RuntimeException("Stub!");  
15.     }  
16.   
17.     protected Class<?> findClass(String name) throws ClassNotFoundException {  
18.         throw new RuntimeException("Stub!");  
19.     }  
20.   
21.     protected URL findResource(String name) {  
22.         throw new RuntimeException("Stub!");  
23.     }  
24.   
25.     protected Enumeration<URL> findResources(String name) {  
26.         throw new RuntimeException("Stub!");  
27.     }  
28.   
29.     public String findLibrary(String name) {  
30.         throw new RuntimeException("Stub!");  
31.     }  
32.   
33.     protected synchronized Package getPackage(String name) {  
34.         throw new RuntimeException("Stub!");  
35.     }  
36.   
37.     public String toString() {  
38.         throw new RuntimeException("Stub!");  
39.     }  
40. }  

这样定义的方法，表示在程序执行的时候，实际由android rom里面相同的类来执行。

为什么会出现这样的定义？我猜想可能是，这个类实际只在rom里面提供，而我们有时候要用到这个类的一些方法，那么就以这种方式来提供，因为在编译期间，我们的程序要使用这个类，那必然要提供这个类的定义，不然就引用不了。

就比如在看滴滴的插件化开源软件 VirtualAPK 的时候，在hack AMS服务的时候，需要用到ActivityManagerNative这个类，而这个类我们知道在api里面没有提供，是在framework里面提供的。那么要想引入这个类，要么就是编译一个framework.jar包，工程引用这个jar包，但是这样有个问题，我们的应用要安装在各种版本的系统里面，每个版本的framework都是有差异的，兼容性就低了。所以这里使用了另外一种方法，在我们的工程中声明一个和framework一模一样的类，在运行的时候就能自动运行rom里面的类了。

看PluginManager的hookSystemServices

[java]  view plain  copy

1. private void hookSystemServices() {  
2.         try {  
3.             Singleton<IActivityManager> defaultSingleton = (Singleton<IActivityManager>) ReflectUtil.getField(ActivityManagerNative.class, null, "gDefault");  
4.             IActivityManager activityManagerProxy = ActivityManagerProxy.newInstance(this, defaultSingleton.get());  
5.   
6.             // Hook IActivityManager from ActivityManagerNative  
7.             ReflectUtil.setField(defaultSingleton.getClass().getSuperclass(), defaultSingleton, "mInstance", activityManagerProxy);  
8.   
9.             if (defaultSingleton.get() == activityManagerProxy) {  
10.                 this.mActivityManager = activityManagerProxy;  
11.             }  
12.         } catch (Exception e) {  
13.             e.printStackTrace();  
14.         }  
15.     }  

ActivityManagerNative：

[java]  view plain  copy

1. package android.app;  
2.   
3. import android.content.Intent;  
4. import android.os.Binder;  
5. import android.os.IBinder;  
6.   
7. /** 
8.  * @author johnsonlee 
9.  */  
10. public abstract class ActivityManagerNative extends Binder implements IActivityManager {  
11.   
12.     public static IActivityManager getDefault() {  
13.         throw new RuntimeException("Stub!");  
14.     }  
15.   
16.     public static boolean isSystemReady() {  
17.         throw new RuntimeException("Stub!");  
18.     }  
19.   
20.     public static void broadcastStickyIntent(final Intent intent, final String permission, final int userId) {  
21.         throw new RuntimeException("Stub!");  
22.     }  
23.   
24.     static public IActivityManager asInterface(IBinder obj) {  
25.         throw new RuntimeException("Stub!");  
26.     }  
27.   
28.     public ActivityManagerNative() {  
29.         throw new RuntimeException("Stub!");  
30.     }  
31. }  

可以看到，这里面只声明了几个方法，这几个方可以在我们的工程中直接调用（为了能通过编译），然后运行的时候，自动转换为rom里面的类来执行。

另外还有ActivityMangerNative的内部类Singleton

[java]  view plain  copy

1. package android.util;  
2.   
3. /** 
4.  * @author johnsonlee 
5.  */  
6. public abstract class Singleton<T> {  
7.     public Singleton() {  
8.         throw new RuntimeException("Stub!");  
9.     }  
10.   
11.     protected abstract T create();  
12.   
13.     public T get() {  
14.         throw new RuntimeException("Stub!");  
15.     }  
16. }  

这样定义的类我们是不能直接实例化的，理由很简单，因为在构造函数里面就抛出异常了。只能通过反射的方式拿到该类的实例，比如这个：

[java]  view plain  copy

1. Singleton<IActivityManager> defaultSingleton = (Singleton<IActivityManager>) ReflectUtil.getField(ActivityManagerNative.class, null, "gDefault");  

另外我们在定义和系统一样的类的时候，必须包名路径是一致的，否则就有问题了。

最后，附上鸿洋的VirtualApk的分析： http://blog.csdn.net/lmj623565791/article/details/75000580