RxAndroid 进行封装实现替代Handler的方案

概述.在android中如果我们开启了一个新的线程,但是执行完毕之后需要更新UI我们一般使用Handler来操作,这样就出现了2个问题:

1.只要需要在ui线程中执行ui更新 我们就需要在Activity中创建一个Handler对象，同时我们还需要创建Message来发送,同时还需要在Handler中进行判断,这样代码的可阅读性就降低很多了,而且代码编写起来也很烦。

2.需要异步执行任务时如果我们简单的就直接创建一个新的线程的话，很浪费资源，如果使用一个统一管理的线程池的话，也很容易出现问题。

于是,我便开始寻找能够解决这2个问题的方法，最后我找到了RxAndroid,有兴趣的可以去看看别人写的RxJava或者RxAndroid的介绍。使用了一次后,我感觉RxAndroid实在是太好用了，我仅仅是使用了其中的一小点功能就给我的代码编写带来了很多的 ，因此有时间我还会继续学习RxAndroid更多的内容，把其中方便的东西拿出来使用到实际开发中。

别的东西不多说了，上关键代码:

1.首先是任务的封装:

   我封装了3种任务: IO任务-在耗时线程中执行的任务 ,UI任务-在UI线程中执行的任务,通用任务-先执行耗时任务,耗时任务执行完成后再执行UI任务。

  IO任务:

package bluetooth.Util.rxjava.bean;

/**
 * 在IO线程中执行的任务
 * Created by z2wenfa on 2016/3/31.
 */
public abstract class IOTask<T> {
    private T t;

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }


    public IOTask(T t) {
        setT(t);
    }


    public abstract void doInIOThread();
}

UI任务:

package bluetooth.Util.rxjava.bean;

/**
 * 在主线程中执行的任务
 */
public abstract class UITask<T> {
    
    public abstract void doInUIThread();

    public UITask(T t) {
        setT(t);
    }

    public UITask() {

    }

    private T t;

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
}

通用任务:

package bluetooth.Util.rxjava.bean;

import com.baidu.platform.comapi.map.C;

import rx.Observable;

/**
 * 通用的Rx执行任务
 * Created by z2wenfa on 2016/3/30.
 */
public abstract class CommonRxTask<T> {
    public CommonRxTask(T t) {
        setT(t);
    }

    public CommonRxTask() {

    }

    private T t;

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }

    public abstract void doInIOThread();

    public abstract void doInUIThread();


    public abstract class MyOnSubscribe implements Observable.OnSubscribe<C> {
        private C t;

        public MyOnSubscribe(C c) {
            setT(t);
        }

        public C getT() {
            return t;
        }

        public void setT(C c) {
            this.t = c;
        }

    }

}

 简单介绍下泛型的作用吧，大家可以看到有一个泛型为T的变量,通用任务中我为了区分执行时的泛型所以改成了C其实都是一样的效果，就是存储在任务执行中需要执行的结果的变量。

2.一个自定义的OnSubsribe对象：

public abstract class MyOnSubscribe<C> implements Observable.OnSubscribe<C> {
    private C c;

    public MyOnSubscribe(C c) {
        setT(c);
    }

    public C getT() {
        return c;
    }

    public void setT(C c) {
        this.c = c;
    }


}

这个泛型的变量其实是用来存放CommonTask的。

3.最关键的执行代码如下:

<pre name="code" class="java">/**
 * Rxjava封装工具类
 * Created by z2wenfa on 2016/3/30.
 */
public class RxjavaUtil {

    /**
     * 在ui线程中工作
     *
     * @param uiTask
     */
    public static <T> void doInUIThread(UITask<T> uiTask) {
		Observable.just(uiTask)
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Action1<UITask<T>>() {
                    @Override
                    public void call(UITask<T> uitask) {
                        uitask.doInUIThread();
                    }
                }, new Action1<Throwable>() {
                    @Override
                    public void call(Throwable throwable) {
                        throwable.printStackTrace();
                    }
                });
}

 /*** 在IO线程中执行任务 * * @param <T> */
 public static <T> void doInIOThread(IOTask<T> ioTask) { 
       Observable.just(ioTask)
                .observeOn(Schedulers.io())
                .subscribe(new Action1<IOTask<T>>() {
                    @Override
                    public void call(IOTask<T> ioTask) {
                        ioTask.doInIOThread();
                    }
                }, new Action1<Throwable>() {
                    @Override
                    public void call(Throwable throwable) {
                        throwable.printStackTrace();
                    }
                });
}
 
/** * 执行Rx通用任务 (IO线程中执行耗时操作 执行完成调用UI线程中的方法) * * @param t * @param <T> */ 
public static <T> void executeRxTask(CommonRxTask<T> t) {
        MyOnSubscribe<CommonRxTask<T>> onsubscribe = new MyOnSubscribe<CommonRxTask<T>>(t) {
            @Override
            public void call(Subscriber<? super CommonRxTask<T>> subscriber) {
                getT().doInIOThread();
                subscriber.onNext(getT());
                subscriber.onCompleted();
            }
        };
        Observable.create(onsubscribe)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Action1<CommonRxTask<T>>() {
                    @Override
                    public void call(CommonRxTask<T> t) {
                        t.doInUIThread();
                    }
                }, new Action1<Throwable>() {
                    @Override
                    public void call(Throwable throwable) {
                        throwable.printStackTrace();
                    }
                });
}

最后写几个简单的使用方法吧:

 private void test(){
        String str="test1";
        RxjavaUtil.doInIOThread(new IOTask<String>(str) {
            @Override
            public void doInIOThread() {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                Log.v("test",getT());
            }
        });




        new Thread(new Runnable() {
            @Override
            public void run() {
                String str2="test2";
                RxjavaUtil.doInUIThread(new UITask<String>(str2) {
                    @Override
                    public void doInUIThread() {
                        TextView tv=findViewByid(R.id.tv);
                        tv.setText(getT());
                    }
                });
            }
        }).start();

        
        String str3="test3";
        RxjavaUtil.executeRxTask(new CommonRxTask<String>(str3) {
            @Override
            public void doInIOThread() {
                try {
                    Thread.sleep(10000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                setT(getT()+"小尾巴");

            }

            @Override
            public void doInUIThread() {
                TextView tv=findViewByid(R.id.tv);
                tv.setText(getT());
            }
        });

    }

使用起来感觉还是比较方便的,随时随地想使用IO线程就IO线程,想在新线程中使用UI操作就进行UI操作,先执行耗时操作,再操作UI组件也是随时随地。

 希望能够给大家带来方便。

Demo代码地址

附上 RxAndroid库:

compile 'io.reactivex:rxandroid:1.1.0'
compile 'io.reactivex:rxjava:1.1.0'