（4.6.22.2）来吧，是时候撸一份自己的RxJava框架啦：代理模式实现线程调度

最新推荐文章于 2020-05-30 18:11:51 发布
最新推荐文章于 2020-05-30 18:11:51 发布
阅读量454 收藏
点赞数
分类专栏： 4.6-android进阶 文章标签： 框架 设计模式 线程 rxJava 自己rxjava
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fei20121106/article/details/53693911
版权

看了上篇（4.6.22.1）来吧，是时候撸一份自己的RxJava框架啦：观察者模式实现链式调用有木有觉得，线式调用很简单呢？

那么，重头戏来了，我们如何实现线程调度？

就是要借助代理模式，代理模式不懂的话，请转向（2.2.1）设计模式一览系列文章

线程调度的原理： 代理模式。
2.1 所有类的成员函数的调用都不是直接由对应对象实例调用，而是由代理类去调用
2.2 通用的总代理类，实现线程调度

设计思路图

在(4.6.22.1)的模式中，我们是直接调用 生产者.call()函数，和 消费者.onSuccess()函数，直接调用那么自然意味着不会有线程调度的时机了
|
不能直接调用 生产者|消费者的对应成员方法，不调用？
|
使用代理模式，做分别的代理类，代理类根据对应的函数注解，在不同的线程执行被代理类对象的成员函数
|
优化空间？ 线程的调度模型应该是一样，应该做一个统一的调度模型，实现消费者or生产者的调度是通过同一种调度模型实现
|
那就是搞一个 线程调度分发器喽

一句话：使每个对象的成员方法通过我们的调度器Invoker调用，而不是直接被调用

设计思路

  • 核心的业务控制器

  • 【发布者—被观察者 ： 事件的产生者】 的代理

    • 实现 生产者的接口—代理模式的基本需求
    • 持有 实际的生产者实例
    • 重写 生产者接口的对应函数： 注意不能直接调用被代理对象的成员函数，而是交由 线程调度器统一处理
    • 开放 返回的Future实例

  • 【观察者—消费者： 事件的消费者】 的代理

    • 实现 消费者的接口—代理模式的基本需求
    • 持有 实际的 消费者们 实例
    • 重写 消费者接口的对应函数
      注意1：不能直接调用被代理对象的成员函数，而是交由 线程调度器统一处理
      注意2：遍历消费者们，代理类是所有消费者的代理，保证生产者.call(消费者)中调用消费者时，所有函数都会被执行
    • 消费者容器的增删查

  • 两个函数注解： 标示线程调度 和 延迟

实践

1. 两个注解： 标示线程调度 和 延迟

/**
 * 延迟执行
 * Created by yhf on 16/12/18.
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Delay {
    int value()default 0;
}

**
 * 默认为当前线程
 * Created by yhf on 16/12/18.
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface RunContext {
    RunContextType value()default RunContextType.CurrentThread;
}



/**
 * 线程调度类型
 * Created by yhf on 16/12/18.
 */
public enum RunContextType {
    MainThread,
    MainLoop,
    NewThread,
    NewHandlerThread,
    CurrentThread,
    CurrentLoop,
    IO,
    Calculate,
    Dynamic,
    Custome;
}

2. 【发布者—被观察者 ： 事件的产生者】 的代理

先看看代理模式的基本实现


/**
 * 【发布者---被观察者 ： 事件的产生者】 的代理
 * 使每个目标方法通过我们的调度器Invoker调用，而不是直接被调用，OnObserver和OnPublisher必须被代理
 * 从而，实现 线程调度
 * 否则用户就可以直接调用，没法实现线程调度
 * - 实现 生产者的接口---代理模式的基本需求
 * - 持有 实际的生产者实例
 * - 重写 生产者接口的对应函数： 注意不能直接调用被代理对象的成员函数，而是交由 线程调度器统一处理
 * - 开放 返回的Future实例
 * Created by yhf on 16/12/18.
 */
public class OnPublisherProxy<T> implements OnPublisher<T> {

    private OnPublisher<T> onPublisher;
    private Invoker invoker;

    private Future future;

    public OnPublisherProxy(OnPublisher<T> onPublisher) {
        this.onPublisher = onPublisher;
    }

    public Future getFuture() {
        return future;
    }

    @Override
    public void call(OnObserver<T> observer) {
        String MethodName = "call";
        Class parType = OnObserver.class;
        if (invoker == null)
            invoker = Invoker.getInstance();
        try {
            Method method = onPublisher.getClass().getMethod(MethodName,parType);
            //1. 获取 method对应注解
            //2. 在对应线程上，调用onPublisher.method(observer)
            future = invoker.invoke(method,onPublisher, observer);
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
    }
}

3.【观察者—消费者： 事件的消费者】 的代理

/**
 * 【观察者---消费者： 事件的消费者】 的代理
 * 使每个目标方法通过我们的调度器Invoker调用，而不是直接被调用，OnObserver和OnPublisher必须被代理
 * 从而，实现 线程调度
 * 否则用户就可以直接调用，没法实现线程调度
 *  - 实现 消费者的接口---代理模式的基本需求
 *  - 持有 实际的 <font color= red>消费者们 </font> 实例
 *  - 重写 消费者接口的对应函数
 *    注意1：不能直接调用被代理对象的成员函数，而是交由 线程调度器统一处理
 *    注意2：遍历消费者们，代理类是所有消费者的代理，保证生产者.call(消费者)中调用消费者时，所有函数都会被执行
 *  - 消费者容器的增删查
 * Created by yhf on 16/12/18.
 */
public class ObserverProxy<T> implements OnObserver<T>,IObserverProxy<T> {

    private Vector<OnObserver<T>> observers;
    private Invoker invoker;

    public ObserverProxy() {
        observers = new Vector<OnObserver<T>>();
        invoker = Invoker.getInstance();
    }

    @Override
    public void onSuccess(T t) {
        String methodName = "onSuccess";
        for (OnObserver<T> observer:observers){
            try {
                Method method = observer.getClass().getMethod(methodName,Object.class);
                invoker.invoke(method,observer,t);
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
            }
        }
    }

    @Override
    public void onError(Throwable throwable) {
        String methodName = "onError";
        Class type = Throwable.class;
        for (OnObserver<T> observer:observers){
            try {
                Method method = observer.getClass().getMethod(methodName,type);
                invoker.invoke(method,observer,throwable);
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
            }
        }
    }

    @Override
    public void onFinished() {
        String methodName = "onFinished";
        for (OnObserver<T> observer:observers){
            try {
                Method method = observer.getClass().getMethod(methodName);
                invoker.invoke(method,observer);
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
            }
        }
    }

    @Override
    public void addObserver(OnObserver<T> observer) {
        observers.add(observer);
    }

    @Override
    public void rmObserver(OnObserver<T> observer) {
        observers.remove(observer);
    }

    @Override
    public void clear() {
        observers.clear();
    }

    @Override
    public Vector<OnObserver<T>> getObservers() {
        return observers;
    }
}

4. 线程调度分发器

线程调度模型，是一个比较核心的模块，首先，先放大招：
这里写图片描述

4.1 线程调度方法

线程调度模型的总入口，注释很详细了，不多赘述了

    /**
     * 根据函数的注解，在不同线程 调用 object执行对应的函数（参数）
     * @param method 对应生产者|消费者|变换器 传递过来的 即将被调用的 函数
     * @param object 对应生产者|消费者|变换器 实例
     * @param values 对应函数的参数
     * @return
     */
    public Future invoke(Method method, Object object, Object... values){
        RunContext runContext = method.getAnnotation(RunContext.class);
        RunContextType type;
        int delay = 0;
        if (runContext == null)
            type = RunContextType.CurrentThread;
        else
            type = runContext.value();
        Delay delayAnno = method.getAnnotation(Delay.class);
        if (delayAnno!=null)
            delay = delayAnno.value();
        Future future = null;
        switch (type){
            case CurrentThread:
               invoke_current_thread(method,object,delay,values);
                break;
            case CurrentLoop:
                invoke_current_loop(method,object,delay,values);
                break;
            case NewThread:
                invoke_new_thread(method,object,delay,values);
                break;
            case MainThread:
                invoke_main_thread(method,object,delay,values);
                break;
            case MainLoop:
                invoke_main_loop(method,object,delay,values);
                break;
            case Calculate:
                future = invoke_calculate(method,object,delay,values);
                break;
            case IO:
                invoke_io(method,object,delay,values);
                break;
            case NewHandlerThread:
                invoke_new_handler_thread(method,object,delay,values);
                break;
            case Dynamic:
                invoke_dynamic(method, object, values);
                break;
        }
        return future;
    }

4.2 一种线程调度：NewThread 创建新线程

    private void invoke_new_thread(Method method, Object object,int delay,Object... values) {
        ProxyEntity entity = new ProxyEntity(method,object,values);
        entity.setDelay(delay);
        new Thread(entity).start();
    }

其中 ProxyEntity 类为封装了数据的Runnable接口，其实invoke_new_thread函数就是 new了一个Runnable，然后start(),这其实就是一个常规线程操作

/**
 * 封装了数据的Runnable接口
 * 一个runnable的简单封装，用于调用产生事件
 * Created by yhf on 16/12/18.
 */
public class ProxyEntity implements Runnable{

    private Method method; // 动作函数
    private Object object;// 动作执行对象
    private Object[] args;;//动作函数的参数
    private Object ret;
    private int delay = 0;// 动作的延迟

    public ProxyEntity(Method method, Object object, Object... args) {
        this.method = method;
        this.object = object;
        this.args = args;
    }

    //设置延迟事件
    public void setDelay(int delay) {
        this.delay = delay;
    }

    //执行事件
    @Override
    public void run() {
        if (delay!=0){
            try {
                Thread.currentThread().sleep(delay);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        Invoker.invoke_direct(method,object,args);
    }
}

到目前为止，我们已经拿到了 对象+函数+参数，如何实现动态调用 Object的对应Method，并传入参数呢？

4.3 动态调用 对象+函数+参数

  • 思路
    • 根据 Method对象，拿到 函数名
    • 再次做一次 函数 代理模式，根据对应的函数名，switch调用对应的函数方法
    public static <T> T invoke_direct(Method method, Object object, Object... values){
        //1. 根据 Method对象，拿到 函数名
        String name = method.getName();
        //2. 再次做一次代理模式，根据对应的函数名，switch调用对应的函数方法
        IInvokeDirect invoke = null;
        if (object instanceof OnObserver){
            // 创建对应的代理
            // 代理实例持有 实际被代理对象
            invoke = new ObserverInvoker();
            invoke.setProxy(object);
        }else if (object instanceof OnPublisher){
            invoke = new PublisherInvoker();
            invoke.setProxy(object);
        }else if (object instanceof Func1){
            invoke = new Function1Invoker();
            invoke.setProxy(object);
        }
        if (invoke == null)
            return null;

        // 调用代理类的 执行函数
        Object ret = invoke.<T>invoke(name,values);
        if (ret == null)
            return null;
        return (T) ret;
    }
4.3.1 函数代理模式–函数分发模型

这里写图片描述

函数代理
/**
 * 函数代理类
 * Created by yhf on 16/12/18.
 */
public abstract class IInvokeDirect<T>{

    protected T proxy;// 被代理的对象

    /**
     * 设置被代理对象
     * @param t
     */
    public void setProxy(T t){
        proxy = t;
    }

    /**
     * 根据methodname， 调用被代理类的对应方法
     * 函数分发
     * @param methodname
     * @param pars
     * @param <V>
     * @return
     */
    public abstract <V> V invoke(String methodname,Object... pars);
}
【发布者—被观察者 ： 事件的产生者】的函数代理
/**
 * 【发布者---被观察者 ： 事件的产生者】的函数代理
 * Created by yhf on 16/12/18.
 */
public class PublisherInvoker extends IInvokeDirect<OnPublisher>{

    /**
     * //调用被代理对象的 call方法产生事件
     * 就一个不需要分发
     * @param methodname
     * @param pars
     * @param <V>
     * @return
     */
    @Override
    public <V> V invoke(String methodname, Object... pars) {
        proxy.call((OnObserver) pars[0]);
        return null;
    }
}
【观察者—消费者： 事件的消费者】的函数代理
/**
 * 【观察者---消费者： 事件的消费者】的函数代理
 * Created by yhf on 16/12/18.
 */
public class ObserverInvoker extends IInvokeDirect<OnObserver>{

    /**
     * //调用被代理对象的 onSuccess|Error|finish方法产生事件
     * @param methodname
     * @param pars
     * @param <V>
     * @return
     */
    @Override
    public <V> V invoke(String methodname, Object... pars) {
        V res = null;
        switch (methodname){
            case "onFinished":
                proxy.onFinished();
                break;
            case "onSuccess":
                proxy.onSuccess(pars[0]);
                break;
            case "onError":
                proxy.onError((Throwable) pars[0]);
                break;
        }
        return res;
    }
}

5. Test

Publisher.<String>getInstance()  
                 .create(new OnPublisher<String>() {  
                     @Delay(3*1000)  
                     @RunContext(RunContextType.IO)  
                     @Override  
                     public void call(OnObserver<String> observer) {  
                         String res = null;  
                         res = httpmodel.dohttp();  
                         if (res!=null)  
                             observer.onSuccess(res);  
                         else  
                             observer.onError(new Throwable("error"));  
                     }  
                 })  
                 .bind(new OnObserver<String>() {  
                     @RunContext(RunContextType.MainThread)  
                     @Override  
                     public void onSuccess(String s) {  
                         resTextView.setText(s);  
                     }  
                     @RunContext(RunContextType.MainThread)  
                     @Override  
                     public void onError(Throwable throwable) {  
                         Toast.makeText(MainActivity.this,throwable.getMessage(),Toast.LENGTH_LONG).show();  
                     }  

                     @Override  
                     public void onFinished() {  

                     }  
                 })  
                 .post();

6. 线程调度的自行实现

一般而言，各自的项目里边应该已经有了自己的线程模型，可以自行设置，在此给出，线程调度器的全部源码：

package test.com.yu.utils.Reactive.impl;

import android.os.Handler;
import android.os.HandlerThread;
import android.os.Looper;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.concurrent.Future;

import test.com.yu.utils.Reactive.OnObserver;
import test.com.yu.utils.Reactive.OnPublisher;
import test.com.yu.utils.Reactive.annotation.Delay;
import test.com.yu.utils.Reactive.annotation.RunContext;
import test.com.yu.utils.Reactive.entity.Function1Invoker;
import test.com.yu.utils.Reactive.entity.IInvokeDirect;
import test.com.yu.utils.Reactive.entity.ObserverInvoker;
import test.com.yu.utils.Reactive.entity.ProxyEntity;
import test.com.yu.utils.Reactive.entity.PublisherInvoker;
import test.com.yu.utils.Reactive.entity.RunContextType;
import test.com.yu.utils.Reactive.entity.actions.Func1;

/**
 * Created by yhf on 16/12/18.
 */
public class Invoker {

    private static Invoker invoker;
    private Handler mainHandler;

    public final static String DynamicFlagname = "runcontext";
    public final static String DynamicFlagDelay = "delay";

    public static Invoker getInstance(){
        synchronized (Invoker.class){
            if (invoker == null)
                invoker = new Invoker();
        }
        return invoker;
    }

    public Invoker() {
        mainHandler = new Handler(Looper.getMainLooper());
    }

    /**
     * 根据函数的注解，在不同线程 调用 object执行对应的函数（参数）
     * @param method 对应生产者|消费者|变换器 传递过来的 即将被调用的 函数
     * @param object 对应生产者|消费者|变换器 实例
     * @param values 对应函数的参数
     * @return
     */
    public Future invoke(Method method, Object object, Object... values){
        RunContext runContext = method.getAnnotation(RunContext.class);
        RunContextType type;
        int delay = 0;
        if (runContext == null)
            type = RunContextType.CurrentThread;
        else
            type = runContext.value();
        Delay delayAnno = method.getAnnotation(Delay.class);
        if (delayAnno!=null)
            delay = delayAnno.value();
        Future future = null;
        switch (type){
            case CurrentThread:
                invoke_current_thread(method,object,delay,values);
                break;
            case CurrentLoop:
                invoke_current_loop(method,object,delay,values);
                break;
            case NewThread:
                invoke_new_thread(method,object,delay,values);
                break;
            case MainThread:
                invoke_main_thread(method,object,delay,values);
                break;
            case MainLoop:
                invoke_main_loop(method,object,delay,values);
                break;
            case Calculate:
                future = invoke_calculate(method,object,delay,values);
                break;
            case IO:
                invoke_io(method,object,delay,values);
                break;
            case NewHandlerThread:
                invoke_new_handler_thread(method,object,delay,values);
                break;
            case Dynamic:
                invoke_dynamic(method, object, values);
                break;
        }
        return future;
    }

    private Future invoke_dynamic(Method method, Object object, Object... values) {
        RunContextType type = null;
        int delay = 0;
        try {
            Field field = object.getClass().getField(DynamicFlagname);
            type = (RunContextType) field.get(object);
            Field field1 = object.getClass().getField(DynamicFlagDelay);
            delay = field1.getInt(object);
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        if (type == null)
            return null;
        Future future = null;
        switch (type){
            case CurrentThread:
                invoke_current_thread(method,object,delay,values);
                break;
            case CurrentLoop:
                invoke_current_loop(method,object,delay,values);
                break;
            case NewThread:
                invoke_new_thread(method,object,delay,values);
                break;
            case MainThread:
                invoke_main_thread(method,object,delay,values);
                break;
            case MainLoop:
                invoke_main_loop(method,object,delay,values);
                break;
            case Calculate:
                invoke_calculate(method,object,delay,values);
                break;
            case IO:
                invoke_io(method,object,delay,values);
                break;
            case NewHandlerThread:
                invoke_new_handler_thread(method,object,delay,values);
                break;
            case Dynamic:
                invoke_dynamic(method, object, values);
                break;
        }
        return future;
    }

    private void invoke_new_handler_thread(Method method, Object object,int delay,Object... values) {
        ProxyEntity entity = new ProxyEntity(method,object,values);
        HandlerThread thread = new HandlerThread(object.getClass().getName()+method.getName());
        thread.start();
        Handler handler = new Handler(thread.getLooper());
        if (delay == 0)
            handler.post(entity);
        else
            handler.postDelayed(entity,delay);
    }

    private void invoke_io(Method method, Object object,int delay,Object... values) {
        ProxyEntity entity = new ProxyEntity(method,object,values);
        entity.setDelay(delay);
        //MySigleThreadQueue.AddTask(entity);
    }

    private Future invoke_calculate(Method method, Object object,int delay,Object... values) {
        ProxyEntity entity = new ProxyEntity(method,object,values);
        entity.setDelay(delay);
        //return MyWorkThreadQueue.AddTask(entity);
        return null;
    }

    private void invoke_new_thread(Method method, Object object,int delay,Object... values) {
        ProxyEntity entity = new ProxyEntity(method,object,values);
        entity.setDelay(delay);
        new Thread(entity).start();
    }

    private void invoke_main_thread(Method method, Object object,int delay,Object... values) {
        Looper mianLoop = Looper.getMainLooper();
        ProxyEntity entity = new ProxyEntity(method,object,values);
        if (Looper.myLooper() != Looper.getMainLooper()){
            invoke_main_loop(method, object,delay,values);
        }else {
            invoke_current_thread(method, object, delay, values);
        }
    }

    private void invoke_main_loop(Method method, Object object,int delay,Object... values) {
        ProxyEntity entity = new ProxyEntity(method,object,values);
        if (delay == 0)
            mainHandler.post(entity);
        else
            mainHandler.postDelayed(entity,delay);
    }

    private void invoke_current_loop(Method method, Object object,int delay, Object... values) {
        Looper looper = Looper.myLooper();
        if (looper == null)
            throw new RuntimeException(Thread.currentThread().getName()+"不是HandlerThread");
        Handler handler = new Handler(looper);
        ProxyEntity entity = new ProxyEntity(method,object,values);
        if (delay == 0)
            handler.post(entity);
        else
            handler.postDelayed(entity,delay);
    }

    private <T> T invoke_current_thread(Method method, Object object,int delay,Object... values) {
        if (delay!=0) {
            try {
                Thread.currentThread().sleep(delay);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        return invoke_direct(method, object, values);
    }

    public static <T> T invoke_direct(Method method, Object object, Object... values){
        //1. 根据 Method对象，拿到 函数名
        String name = method.getName();
        //2. 再次做一次代理模式，根据对应的函数名，switch调用对应的函数方法
        IInvokeDirect invoke = null;
        if (object instanceof OnObserver){
            // 创建对应的代理
            // 代理实例持有 实际被代理对象
            invoke = new ObserverInvoker();
            invoke.setProxy(object);
        }else if (object instanceof OnPublisher){
            // 创建对应的代理
            // 代理实例持有 实际被代理对象
            invoke = new PublisherInvoker();
            invoke.setProxy(object);
        }else if (object instanceof Func1){
            // 创建对应的代理
            // 代理实例持有 实际被代理对象
            invoke = new Function1Invoker();
            invoke.setProxy(object);
        }
        if (invoke == null)
            return null;

        Object ret = invoke.<T>invoke(name,values);
        if (ret == null)
            return null;
        return (T) ret;
    }

}
fei20121106
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Retrofit 分析 - 经典设计模式案例
...
08-31 765
原文链接：http://www.jianshu.com/p/fb8d21978e38 本篇是 retrofit 番外篇。只讲 retrofit 中的设计模式以及我个人的理解与延伸。 —— 由 Stay 分享 如果你还不知道Retrofit，没关系，okhttp你总知道吧。retrofit就是对okhttp再做了一层封装。你只需要通过简单的配置就能顺利使用retrofit来做
netcdfAll-4.6.15.jar
09-23
netcdfAll-4.6.15.jar用于读取网络上的气象数据，解析经纬度，能够通过代码读取MERRA2数据库及后缀nc4的文件
opencv_contrib_python-4.6.0.66 whl下载
08-04
opencv_contrib_python-4.6.0.66-cp36-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl
关于RxJava的简单用法(四)
QQNKW的博客
01-11 416
关于Subject 关于Subject，官方文档的解释是这样的：Subject可以看成是一个桥梁或者代理，在某些ReactiveX实现中（如RxJava），它同时充当了Observer和Observable的角色。因为它是一个Observer，它可以订阅一个或多个Observable；又因为它是一个Observable，它可以转发它收到(Observe)的数据，也可以发射新的数据。从官方解释中，
Retrofit动态代理机制与Rxjava适配器模式分析
wei_ai_n的博客
03-29 1355
代理模式 代理模式的作用是：为其他对象提供一种代理以控制对这个对象的访问。对于代理模式可以分为两大类，分别是静态代理和动态代理。下面就开始对这两种类型的代理模式进行详细介绍。 静态代理在这里通过一个场景来展开描述代理模式。现在我想按照自己想要的配置来组装一台电脑。于是我将主板，内存条，显卡，机箱，显示器等所有的配件都买回来了。可是这个时候遇到了一个难题，我不会组装呀。于是我带着这些配件去找专业人士为
汇川PLC编程软件AutoShop V4.6.5.0版本.zip
12-07
汇川PLC编程软件AutoShop V4.6.5.0版本.
opencv_python-4.6.0.66-cp36-abi3-win32.whl
最新发布
03-01
该资源为opencv_python-4.6.0.66-cp36-abi3-win32.whl，欢迎下载使用哦！
phpMyAdmin v4.6.5.2
12-03
phpMyAdmin是一个以PHP为基础，以Web-Base方式架构在网站主机上的MySQL的资料库管理工具。phpMyAdmin 可以管理整个MySQL服务器...为了实现后一种，你将需要合理设置MySQL用户，他只能对允许的数据库进行读/写。那要等到
《Android源码设计模式解析》读书笔记——Android中你应该知道的设计模式
热门推荐
赵凯强
12-13 1万+
断断续续的，《Android源码设计模式解析》也看了一遍，书中提到了很多的设计模式，但是有部分在开发中见到的几率很小，所以掌握不了也没有太大影响。 我觉得这本书的最大价值有两点，一个是从设计模式的角度去理解Android源码，结合着日常开发中的常用类，对设计模式的理解会更加的深刻；另外一个好处就是了解常用模式，再看其他人写的代码的时候，更容易理解代码思路。下面是我的读书笔记和一些思考，设计
（4.6.22）来吧，是时候撸一份自己的RxJava框架啦
JAVA成长之路
12-16 747
RxJava是什么，在这里就不多做赘述了，如果不太懂，请出门google 简单提一下它的优点： 1. 链式调用—不再出现一缕缕的callback，实现代码整洁和良好可读 2. 线程调度—简单一行代码，实现不同函数运行在不同线程 3. 各种操作符-，链式转换-保持链式结构的同时，在传递过程中对数据进行转换，且转换安装顺序 实现策略 考虑到一些场景的易读性，本文在描述中混淆了
（4.6.14）android 插桩基本概念plugging or Swap
JAVA成长之路
07-11 5484
前言： 1、本篇内容选自网络，仅介绍插桩的基本概念 2、要实现插桩需要一系列的反编译和打包工具，将在另一篇文章中介绍插桩的概念：插桩就是在代码中插入一段我们自定义的代码。插桩的目的：将程序中插入我们自定义的代码编译到可执行文件中， 该程序的运行过程中就会执行我们自定义的代码，实现我们想要增加的功能需求。安卓插桩简介：在安卓方面，插桩通常是指在某手机的官方原厂ROM中通过反编译的方式
（4.6.12）AndroidManifest.xml常用属性大全[进行中]
JAVA成长之路
05-24 4256
1-manifest 属性和节点 1-1 package 1-2 xmlnsandroidhttpschemasandroidcomapkresandroid 1-3 xmlnstoolshttpschemasandroidcomtools 1-4 androidversionCode1000 1-5 androidversionName9999 2-uses-sdk 3-uses-permissi
（4.6.23.1）Android之面向切面编程：AOP 与 Aspect简介
JAVA成长之路
04-20 3611
一OOP的困境 1 OOP 2 从打印日志来看AOP 和 OOP 二适用AOP的场景 三工具和库 四AspectJ简介 五AOP概念介绍 1 Join Points 何处支持注入 2 Pointcuts定位想要注入的具体连接点 21 Pointcuts基本结构 22 Joinpoint类型的直接选择 221 Joinpoint类型一览 222 定位正则 2221 Method Signatur
（4.6.10.2）Android LoadedApk详解
JAVA成长之路
05-30 3580
文章目录一、LoadedApk的构建函数和成员变量二、LoadedApk的在ActivityThread中的获取三、LoadedApk的mApplication创建Application实例四、LoadedApk的mResources创建Resources实例 是ActivityThread中进行四大组件等启动过程中的重要中间变量 LoadedApk对象是APK文件在内存中的表示。 Apk文件的相关信息，诸如Apk文件的代码和资源，甚至代码里面的Activity，Service等组件的信息我们都可以通过此
（4.6.17.6）进程保活（Android的5.0分界线）：Android5.0以上版本的force close到底发生了什么改变？
JAVA成长之路
07-29 2680
在阅读本篇之前，你首先需要大概清楚一点，无论是系统杀（android机型上长按home键中清除），或者是他杀（第三方管理软件，如360，腾讯等）。其实现方法，基本都是借助ActivityManagerService的removeLruProcessLocked，改变主要也是在这里 一、 先看代码有啥不同 5.0以下 我们先来看看Android4.4的源码，ActivityManagerService
（4.6.29.4）插件化之资源加载：使用插件中的R资源
JAVA成长之路
06-22 2130
一、主app中使用插件中资源 1.1 创建新的Resource对象方式 1.1.1 背景知识 资源链 Resources对象 1.1.3 实现思路 addAssetPath的反射调用 1.1.4 具体实现 1.1.5 加载离线apk中的字符串和Drawable资源 1.1.6 加载离线apk中的layout资源 直接替换当前context的mResources私有成员变量 ...
（4.6.28）关于Android 64K引发的MultiDex你想知道的都在这里：一场由启动黑屏引发的惨案
JAVA成长之路
02-05 1573
如果你的应用不支持5.0以下的Dalvik VM 那么你没有必要看这篇文章 本文内容由个人按照个人理解，汇总自《参考文献》所示文章，有兴趣者可自行查看相关参考文献 Android分包方案Multidex的相关个人理解，不正之处欢迎指正。 口袋助理是一款移动办公OA，支持手机APP和网页版。目前超过200万家企业正在使用。手机考勤、销售人员外勤管理、客户CRM、销售项目管理、移动日志、流
（4.6.25）Android动态更换应用Icon之玩转桌面图标
JAVA成长之路
10-24 1426
一原理解析 1 原理1activity-alias 2 原理2PMsetComponentEnabledSetting 二动态更换桌面icon 三远程控制图标的实现方式 四多入口实现方式 快捷方式入口 五其他 参考文档时不时的我们就会发现，一些我们常见的应用，比如某宝，某东，在一些特殊的日子中，比如双十一、元旦，为了迎合这样一个日子的气氛，在桌面的应用图标就会发生改变，再譬如一些理财产品在举办一些
（4.6.29.3）插件化之代码加载：启动Activity等四大组件之hook方式
JAVA成长之路
06-29 1376
我们上文提到了，必须在Manifest中注册后才能以标准Intent的方式启动的，这一部分的实现其实是通过 framework层的java代码进行实现的 那么这是否就意味着，我们通过hook一些关键的代码，就可以实现让PlugActivity看上去就和注册过的Activity一样，从而正常的启动？ 这里需要的就是 动态代理的hook机制 代理模式和Hook原理 Hook 原理 整...
librpm-4.6.so: cannot open shared object file: No such file or directory
08-16
出现 "librpm-4.6.so: cannot open shared object file: No such file or directory" 的错误提示意味着程序无法找到所需的共享库文件。这通常是由于缺少或损坏的库文件引起的。根据引用和引用，可以看出缺少的库文件...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值