动态代理机制

动态代理说白了就是实现拦截功能。可以利用该机制重写一个类,覆盖android系统中的类,这样可以实现一些特殊的功能。

2,动态代理机制

1,定义接口和实现

public interface UserService {  
    public String getName(int id);  
    public Integer getAge(int id);  
}  

实现类

public class UserServiceImpl implements UserService {  
    @Override  
    public String getName(int id) {  
        System.out.println("------getName------");  
        return "Tom";  
    }  
    @Override  
    public Integer getAge(int id) {  
        System.out.println("------getAge------");  
        return 10;  
    }  
}  

2,动态代理实现

import java.lang.reflect.InvocationHandler;  
import java.lang.reflect.Method;  
  
  
public class MyInvocationHandler implements InvocationHandler {  
    private Object target;  
  
    MyInvocationHandler() {  
        super();  
    }  
  
    MyInvocationHandler(Object target) {  
        super();  
        this.target = target;  
    }  
  
    @Override  
    public Object invoke(Object o, Method method, Object[] args) throws Throwable {  
        if("getName".equals(method.getName())){  
            System.out.println("++++++before " + method.getName() + "++++++");  
            Object result = method.invoke(target, args);  
            System.out.println("++++++after " + method.getName() + "++++++");  
            return result;  
        }else{  
            Object result = method.invoke(target, args);  
            return result;  
        }  
  
    }  
}  

import java.lang.reflect.InvocationHandler;  
import java.lang.reflect.Proxy;  

public class Main1 {  
    public static void main(String[] args) {  
        UserService userService = new UserServiceImpl();  
        InvocationHandler invocationHandler = new MyInvocationHandler(userService);  
        UserService userServiceProxy = (UserService)Proxy.newProxyInstance(userService.getClass().getClassLoader(),  
                userService.getClass().getInterfaces(), invocationHandler);  
        System.out.println(userServiceProxy.getName(1));  
        System.out.println(userServiceProxy.getAge(1));  
    }  
}  

运行结果

++++++before getName++++++
------getName------
++++++after getName++++++
Tom
------getAge------
10

稍微总结一下,动态代理有三个要素,

1,被代理的类.(通常是android 系统中需要被代理的类,比如四大组件等等)

2,代理类。代理类必须实现InvocationHandler接口的invoke方法。

3,桥梁,将被代理类和代理类联系起来的纽带。通常格式如下,

(+++)Proxy.newProxyInstance(被代理对象.getClassLoader(),  
                +++.getClass().getInterfaces(), 代理对象); 

如果自己创建代理对象，然后把原始对象替换为的代理对象，那么就可以在这个代理对象为所欲为了。

 

插件化的实质就是在宿主程序来运行一些未安装的apk。插件化有哪些好处呢？

1,宿主和插件分开编译

2,并发开发

3,动态更新插件

4,按需下载模块

5,方法数或变量数爆棚

 

需要解决2个问题,代码加载以及资源加载。

其中代码加载并不是仅仅使用ClassLoder机制加载代码就可以了,因为android中大量的类都是完成特定功能的,

四大组件都是有生命的,因此还需要对这些特殊的类进行插件化,使之符合要求。