2015-12-24 18:25:07 axuanqq 阅读数 2440
  • 微信h5支付开发-php开发微信h5支付demo

    会员免费看,http://edu.csdn.net/lecturer/842右侧可办理会员卡。微信h5支付开发是子恒老师《子恒说微信开发》视频教程的第17部。详细讲解了微信H5支付开发,内容包含开通H5支付,实现微信h5支付,订单查询,关闭订单等等。欢迎反馈,微信号:QQ68183131

    8013 人正在学习 去看看 秦子恒
package com.rxandroid.test1;

import android.os.Bundle;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Process;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.view.View;

import java.util.concurrent.TimeUnit;

import rx.Observable;
import rx.Subscriber;
import rx.android.schedulers.AndroidSchedulers;
import rx.android.schedulers.HandlerScheduler;
import rx.exceptions.OnErrorThrowable;
import rx.functions.Func0;

public class MainActivity extends AppCompatActivity {
    private static final String TAG = "------RxAndroidSamples";

    private Handler backgroundHandler;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_main);

        //创建子线程handler
        BackgroundThread backgroundThread = new BackgroundThread();
        backgroundThread.start();
        backgroundHandler = new Handler(backgroundThread.getLooper());

        findViewById(R.id.button_run_scheduler).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                onRunSchedulerExampleButtonClicked();
            }
        });
    }

    /**
     * 整个流程就如同 取款机:
     * 先输入取款数目,(订阅,要钱的需求)
     * 然后取款机自动吐出对应数目的钱(观察输入信号)
     */
    void onRunSchedulerExampleButtonClicked() {
        sampleObservable()
                // Run on a background thread
                .subscribeOn(HandlerScheduler.from(backgroundHandler))//订阅在子线程
                // Be notified on the main thread
                .observeOn(AndroidSchedulers.mainThread())//观察在主线程,也就是结果会在主线程中执行
                .subscribe(new Subscriber<String>() {
                    @Override
                    public void onCompleted() {
                        Log.d(TAG, "onCompleted()");
                        Log.d(TAG, "SubscriberThread:" + Thread.currentThread().getName());//Main
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.e(TAG, "onError()", e);
                    }

                    @Override
                    public void onNext(String string) {//这将会在主线程中执行
                        Log.d(TAG, "onNext(" + string + ")");
                    }
                });
    }

    static Observable<String> sampleObservable() {
        return Observable.defer(new Func0<Observable<String>>() {//定义一个方法,接口中的方法返回Observable<String>
            @Override
            public Observable<String> call() {
                try {
                    // Do some long running operation
                    Thread.sleep(TimeUnit.SECONDS.toMillis(5));//睡眠5s
                    Log.d(TAG, "ObservableThread:" + Thread.currentThread().getName());
                } catch (InterruptedException e) {
                    throw OnErrorThrowable.from(e);
                }
                return Observable.just("one", "two", "three", "four", "five");//发布5个字符串,子线程中
            }
        });
    }

    /**
     * 创建子线程的handler或者说looper
     */
    static class BackgroundThread extends HandlerThread {
        BackgroundThread() {
            super("SchedulerSample-BackgroundThread", Process.THREAD_PRIORITY_BACKGROUND);
        }

    }
}

2017-05-05 17:41:25 shb2058 阅读数 593
  • 微信h5支付开发-php开发微信h5支付demo

    会员免费看,http://edu.csdn.net/lecturer/842右侧可办理会员卡。微信h5支付开发是子恒老师《子恒说微信开发》视频教程的第17部。详细讲解了微信H5支付开发,内容包含开通H5支付,实现微信h5支付,订单查询,关闭订单等等。欢迎反馈,微信号:QQ68183131

    8013 人正在学习 去看看 秦子恒

还是先来一个简单的demo,里面的泛型string即是返回的数据类型

  final List<String> allData = new ArrayList();
        allData.add("123");
        allData.add("456");
        Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<String> e) throws Exception {
                for (String s : allData) {
                    e.onNext(s);
                }

            }
        }).subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {

            }

            @Override
            public void onNext(@NonNull String s) {
                if (s.equals("123")) {
                    Log.e("收到123", "======");
                } else {
                    Log.e("收到456", "======");
                }
            }

            @Override
            public void onError(@NonNull Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });

第二个demo

private void showImage(String imageUrl) {
        Observable.create(new ObservableOnSubscribe<Bitmap>() {
            @Override
            public void subscribe(@io.reactivex.annotations.NonNull ObservableEmitter<Bitmap> e) throws Exception {
                e.onNext(BitmapFactory.decodeResource(getResources(), R.drawable.shoucang));
            }
        }).subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread()).subscribe(new Observer<Bitmap>() {
            @Override
            public void onSubscribe(@io.reactivex.annotations.NonNull Disposable d) {

            }

            @Override
            public void onNext(@io.reactivex.annotations.NonNull Bitmap s) {
                jcVideoPlayerStandard.thumbImageView.setImageBitmap(s);
            }

            @Override
            public void onError(@io.reactivex.annotations.NonNull Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });
    }



概述:被观察者-Observable;观察者-Observer/Subcriber;建立订阅关系-Observable.subscribe(Observer/Subcriber) 注:在rx2.0版本Subscriber将不能使用该方法建立订阅关系;线程-Scheduler. RxJava遵循线程不变的规则,在哪个线程产生的事件就在哪个线程消费该事件。

1.简单使用例子,在activity中根据传入的string来显示button的内容

创建被观察者(数据的传入变化):有多种创建方法,列举如下三种

 //创建被观察者,使用基本方法oncreat()
        Observable observable = Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(@NonNull ObservableEmitter e) throws Exception {
                e.onNext("stop");
                e.onNext("start");

                e.onComplete();
            }
        });
第二种:
 //创建被观察者-使用just方法,直接把需要传入的参数写入
        Observable observable1 = Observable.just("start", "stop");
        //创建被观察者-使用from方法
        String[] strings = {"start", "stop"};
        Observable observable2 = Observable.fromArray(strings);

2.观察者的创建,以及与被观察者之间建立订阅关系

 //创建观察者(因数据传入的不同而进行不同的操作):
        Observer<String> observer = new Observer<String>() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {
                //这里的disposable可以用来解除订阅
            }

            @Override
            public void onNext(@NonNull String o) {
                Log.e("收到数据", o);
                if (o.equals("stop")) {
                    Log.e("进入到判断证", "===");
                    textView.setText("收到消息");
                }
                if (o.equals("start")) {
                    textView1.setText("收到start");
                }
            }

            @Override
            public void onError(@NonNull Throwable e) {
                Log.e("onError", "发生错误");
            }

            @Override
            public void onComplete() {
                Log.e("onComplete", "事件调用完成");
            }
        };
        //建立订阅关系
        observable2.subscribe(observer);
3.刚才的demo是一个均在主线程进行操作的例子,但是rxjava主要的特点是异步,在代码中的体现就是可以选择观察者和被观察者处理所在的线程;已知线程如下:

 线程类:Scheduler
        Schedulers.immediate():直接在当前线程运行,相当于不指定线程。这是默认的 Scheduler。
        Schedulers.newThread():总是启用新线程,并在新线程执行操作。
        Schedulers.io():I / O 操作(读写文件、读写数据库、网络信息交互等)所使用的 Scheduler。行为模式和 newThread () 差不多,区别在于 io ()
        的内部实现是是用一个无数量上限的线程池,可以重用空闲的线程,因此多数情况下 io () 比 newThread () 更有效率。不要把计算工作放在 io () 中,
        可以避免创建不必要的线程。
        Schedulers.computation():计算所使用的 Scheduler。这个计算指的是 CPU 密集型计算,即不会被 I/O 等操作限制性能的操作,例如图形的计算。
        这个 Scheduler 使用的固定的线程池,大小为 CPU 核数。不要把 I/O 操作放在 computation() 中,否则 I/O 操作的等待时间会浪费 CPU。
        Android 专用 AndroidSchedulers.mainThread(),它指定的操作将在 Android 主线程运行。
        有了这几个 Scheduler ,就可以使用 subscribeOn () 和 observeOn () 两个方法来对线程进行控制了。 
        subscribeOn():
        指定 subscribe () 所发生的线程,即 Observable.OnSubscribe 被激活时所处的线程,或者叫做事件产生的线程。 
        observeOn():
        指定 Subscriber 所运行在的线程,事件消费的线程。

4.关于事件处理以及事件消费所在线程的切换demo

一个读取图片的例子,一种在主线程读取,一种在子线程读取:
子线程:

  public class MyAxTest extends Activity {
            List<String> allImage;
            /*
            * 被观察者
            * */
            Observable observable = Observable.create(new ObservableOnSubscribe() {
                @Override
                public void subscribe(@NonNull ObservableEmitter e) throws Exception {

                    //  List<Bitmap> allBitmap=getBitmapByRes(allImage);
                    Bitmap bitmap = getOneBitmapByRes("a1");
                    e.onNext(bitmap);
                    e.onComplete();
                }

            }).observeOn(AndroidSchedulers.mainThread()).subscribeOn(Schedulers.io());
            //.observeOn(AndroidSchedulers.mainThread()).subscribeOn(Schedulers.io())
    /*
    * 观察者者
    * */
            Observer observer = new Observer() {
                @Override
                public void onSubscribe(@NonNull Disposable d) {

                }

                @Override
                public void onNext(@NonNull Object o) {
                    Bitmap allBitmap = (Bitmap) o;
                    Log.e("收到的数据", allBitmap.toString() + "");
                }

                @Override
                public void onError(@NonNull Throwable e) {
                    e.printStackTrace();
                }

                @Override
                public void onComplete() {
                    Log.e("完成", "===");
                }
            };

            @Override
            protected void onCreate(@Nullable Bundle savedInstanceState) {
                super.onCreate(savedInstanceState);
                Log.e("系统时间", System.currentTimeMillis() + "");
                observable.subscribe(observer);
                Log.e("系统时间1", System.currentTimeMillis() + "");
                Toast.makeText(getApplicationContext(), "===", Toast.LENGTH_SHORT).show();
                Log.e("系统时间2", System.currentTimeMillis() + "");
                allImage = new ArrayList<>();
                allImage.add("a1");
                allImage.add("a2");
                allImage.add("a3");
                allImage.add("a4");
                allImage.add("a5");
            }

            /*
            * 根据图片的id查找图片
            * */
            private Bitmap getOneBitmapByRes(String path) {
                Bitmap bitmap = null;
                BitmapFactory.Options options = new BitmapFactory.Options();
                options.inSampleSize = 2;
                options.inJustDecodeBounds = false;
                if (path.equals("a1")) {
                    bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.a1, options);
                } else if (path.equals("a2")) {
                    bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.a2, options);
                } else if (path.equals("a3")) {
                    bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.a3, options);
                } else if (path.equals("a4")) {
                    bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.a4, options);
                } else {
                    bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.a5, options);
                }
                return bitmap;
            }
        }
根据logcat输出可以看到,没有阻塞主线程。


主线程:

  public class MyAxTest extends Activity {
            List<String> allImage;
            /*
            * 被观察者
            * */
            Observable observable = Observable.create(new ObservableOnSubscribe() {
                @Override
                public void subscribe(@NonNull ObservableEmitter e) throws Exception {

                    //  List<Bitmap> allBitmap=getBitmapByRes(allImage);
                    Bitmap bitmap = getOneBitmapByRes("a1");
                    e.onNext(bitmap);
                    e.onComplete();
                }

            });
            //.observeOn(AndroidSchedulers.mainThread()).subscribeOn(Schedulers.io())
    /*
    * 观察者者
    * */
            Observer observer = new Observer() {
                @Override
                public void onSubscribe(@NonNull Disposable d) {

                }

                @Override
                public void onNext(@NonNull Object o) {
                    Bitmap allBitmap = (Bitmap) o;
                    Log.e("收到的数据", allBitmap.toString() + "");
                }

                @Override
                public void onError(@NonNull Throwable e) {
                    e.printStackTrace();
                }

                @Override
                public void onComplete() {
                    Log.e("完成", "===");
                }
            };

            @Override
            protected void onCreate(@Nullable Bundle savedInstanceState) {
                super.onCreate(savedInstanceState);
                Log.e("系统时间", System.currentTimeMillis() + "");
                observable.subscribe(observer);
                Log.e("系统时间1", System.currentTimeMillis() + "");
                Toast.makeText(getApplicationContext(), "===", Toast.LENGTH_SHORT).show();
                Log.e("系统时间2", System.currentTimeMillis() + "");
                allImage = new ArrayList<>();
                allImage.add("a1");
                allImage.add("a2");
                allImage.add("a3");
                allImage.add("a4");
                allImage.add("a5");
            }

            /*
            * 根据图片的id查找图片
            * */
            private Bitmap getOneBitmapByRes(String path) {
                Bitmap bitmap = null;
                BitmapFactory.Options options = new BitmapFactory.Options();
                options.inSampleSize = 2;
                options.inJustDecodeBounds = false;
                if (path.equals("a1")) {
                    bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.a1, options);
                } else if (path.equals("a2")) {
                    bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.a2, options);
                } else if (path.equals("a3")) {
                    bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.a3, options);
                } else if (path.equals("a4")) {
                    bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.a4, options);
                } else {
                    bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.a5, options);
                }
                return bitmap;
            }

logcat输出:可以看到主线程已经被阻塞

5.实现一个定时器---直接在主线程做处理

   //每隔两秒调用一次onNext();
        Observable observable=Observable.interval(2, TimeUnit.SECONDS).subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread())
                ;
        Observer observer=new Observer() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {

            }

            @Override
            public void onNext(@NonNull Object o) {
                Log.e("数据传输过来","数据传输");

            }

            @Override
            public void onError(@NonNull Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        };
        observable.subscribe(observer);

定时任务-某些不能直接在主线程做的任务--引入map

 /*
    * 实现一个定时输出--模拟耗时任务
    * */
    private void timeOutPut(){
        //每隔两秒调用一次onNext();
        Observable<Bitmap> observable=Observable.interval(2, TimeUnit.SECONDS).subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread())
                .map(new Function<Long, Bitmap>() {
                    @Override
                    public Bitmap apply(@NonNull Long aLong) throws Exception {
                        BitmapFactory.Options options = new BitmapFactory.Options();
                        options.inSampleSize = 2;
                        options.inJustDecodeBounds = false;
                        Bitmap bitmap= BitmapFactory.decodeResource(getResources(),R.drawable.a1,options);
                        return bitmap;
                    }
                })
                ;
        Observer observer=new Observer() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {

            }

            @Override
            public void onNext(@NonNull Object o) {
                Log.e("数据传输过来","数据传输");
                imageView.setImageBitmap((Bitmap) o);

            }

            @Override
            public void onError(@NonNull Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        };
        observable.subscribe(observer);

    }


6.计数(伪)

 //以某个固定时间间隔按照增续调用onNext()方法,如这里会输出0-59;但是,如果写作60,0;将不会有操作
    Observable observable = Observable.range(60, 0);
    Observer observer = new Observer() {
        @Override
        public void onSubscribe(@NonNull Disposable d) {
            Log.e("start", "start");
        }

        @Override
        public void onNext(@NonNull Object o) {
            Log.e("当前数值", String.valueOf((int) o));
        }

        @Override
        public void onError(@NonNull Throwable e) {
            Log.e("异常", e.getMessage() + "=");
        }

        @Override
        public void onComplete() {
            Log.e("end", "end");
        }
    };
    observable.subscribe(observer);

7.延时操作,类似与handle.postdenly();

  /*
    * 实现一个延时调用
    * */
    private void YanShi() {
        Observable observable = Observable.timer(2, TimeUnit.SECONDS);
        Observer observer = new Observer() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {

            }

            @Override
            public void onNext(@NonNull Object o) {
                Log.e("收到延时数据了", "==" + System.currentTimeMillis());
            }

            @Override
            public void onError(@NonNull Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        };
        observable.subscribe(observer);
        Log.e("开始的时间", System.currentTimeMillis() + "");
    }

8.实现一个重复操作

    /**
     * 实现一个重复操作
     */
    private void repeatDo() {
        Observable observable = Observable.just("hello").repeat();
        Observer<String> observer = new Observer<String>() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {

            }

            @Override
            public void onNext(@NonNull String s) {
                if (s.equals("hello")) {
                    Log.e("收到", "收到");
                } else {
                    Log.e("收到其他数据", s);
                }
            }

            @Override
            public void onError(@NonNull Throwable e) {
                Log.e("出错", e.getMessage() + "=");
            }

            @Override
            public void onComplete() {
                Log.e("end", "end");
            }
        };
        observable.subscribe(observer);
    }

9.操作符map-对传入的数据进行处理

 /*
    * AX中操作符-map
    * */
    private void doOperator() {
        //前面Observable后面的string表示我需要的数据类型,而ObservableOnSubscribe后面的integer表示我传入的数据类型
        Observable<String> observable = Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<Integer> e) throws Exception {
                e.onNext(1);
                e.onNext(2);
                e.onComplete();
            }
        }).map(new Function<Integer, String>() {
            @Override
            public String apply(@NonNull Integer integer) throws Exception {
                if (integer == 1) {
                    return "OK";
                } else {
                    return "are you ok";
                }
            }
        });
        Observer<String> observer = new Observer<String>() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {

            }

            @Override
            public void onNext(@NonNull String integer) {
                Log.e("收到的数据", integer);
            }

            @Override
            public void onError(@NonNull Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        };
        observable.subscribe(observer);
    }

10.操作符filter,过滤作用

 /*
    * AX操作符-filter--过滤作用,内部的test方法返回ture表示这个传入的参数可用,会被传递到observer中,否则就丢弃
    * */
    private void doFlaMap() {
        Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<String> e) throws Exception {
                e.onNext("1");
                e.onNext("2");
                e.onComplete();
            }
        }).filter(new Predicate<String>() {
            @Override
            public boolean test(@NonNull String s) throws Exception {
                if (s.equals("1")) {
                    return true;
                } else {
                    return false;
                }

            }
        }).subscribe(new Subject<String>() {
            @Override
            public boolean hasObservers() {
                return false;
            }

            @Override
            public boolean hasThrowable() {
                return false;
            }

            @Override
            public boolean hasComplete() {
                return false;
            }

            @Override
            public Throwable getThrowable() {
                return null;
            }

            @Override
            protected void subscribeActual(Observer<? super String> observer) {

            }

            @Override
            public void onSubscribe(@NonNull Disposable d) {

            }

            @Override
            public void onNext(@NonNull String s) {
                Log.e("拿到的数据", s);
            }

            @Override
            public void onError(@NonNull Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });
    }
11.take操作符--限制传入的个数

/*
    * AX操作符-take--限制传入observer中的数据个数,如下例子,只能输出1、2
    * */
    private void doTake() {
        Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<String> e) throws Exception {
                e.onNext("1");
                e.onNext("2");
                e.onNext("3");
                e.onNext("4");
            }
        }).take(2).subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {

            }

            @Override
            public void onNext(@NonNull String s) {
                Log.e("收到的数据", s);
            }

            @Override
            public void onError(@NonNull Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });
    }

12.操作符-doOnNext--在数据传递给observer之前做一些操作,网上的一个例子:从服务器拿到数据,然后更改本地数据库,然后显示数据(这里的显示数据是从数据库拿到的,否则没意义)

/*
    * 操作符-doOnNext
    * */
    private void doOnNext() {
        Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<String> e) throws Exception {
                e.onNext("1");
                e.onComplete();
            }
        }).doOnNext(new Consumer<String>() {
            @Override
            public void accept(@NonNull String s) throws Exception {
                Log.e("第一次的数据", s);
                s = "1111111111";
            }
        }).subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {

            }

            @Override
            public void onNext(@NonNull String s) {
                Log.e("最终的数据", s);
            }

            @Override
            public void onError(@NonNull Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });
    }





待续。。。。。。










































                                
2016-07-27 15:42:19 ning_gg 阅读数 295
  • 微信h5支付开发-php开发微信h5支付demo

    会员免费看,http://edu.csdn.net/lecturer/842右侧可办理会员卡。微信h5支付开发是子恒老师《子恒说微信开发》视频教程的第17部。详细讲解了微信H5支付开发,内容包含开通H5支付,实现微信h5支付,订单查询,关闭订单等等。欢迎反馈,微信号:QQ68183131

    8013 人正在学习 去看看 秦子恒

这是一个简单的demo(登陆返回),保存下来,以后时不时的看看而已
MVP分为M层 V层 P层
M->biz,登陆逻辑,登陆返回
V->一个接口,反馈给MainActivity
P->连接biz与View的纽带,请求biz获取数据,使用V更改界面

先写实体User
User.class

public class User {

    public String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

登陆成功失败的接口
OnGetDataListener

/**
 * 登陆成功失败的回调
 */
public interface OnGetDataListener<T> {
    void success(T response); // 网络操作成功
    void fail(T response, String msg); // 网络操作失败
}

登陆逻辑
LoginBiz

public class LoginBiz {
    public void doLogin(final OnGetDataListener<User> listener,final User user ){
        Observable.create(new Observable.OnSubscribe<User>() {
            @Override
            public void call(Subscriber<? super User> subscriber) {
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                subscriber.onNext(user);

            }
        }).subscribeOn(Schedulers.newThread())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Subscriber<User>() {
                    @Override
                    public void onCompleted() {

                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onNext(User user) {
                        if (user!=null)
                            listener.success(user);
                        else
                            listener.fail(user,"error");
                    }
                });
    }
}

View层
ILoginView

/**
 * 登录界面,是一个接口,如:展示进度条、隐藏进度条、展示数据等
 */
public interface ILoginView {
    void showView(String userName);
    void showLoadding();
    void hideLoadding();
}

P层
LoginPresenter

/**
 * Created by pailiao on 2016/7/27.
 * 连接view与biz的纽带
 * 请求logbiz获取数据,使用ILoginView层更新数据
 */
public class LoginPresenter {

    private ILoginView loginView;
    private LoginBiz loginBiz;

    public LoginPresenter(ILoginView loginView) {
        this.loginView = loginView;
        this.loginBiz = new LoginBiz();
    }

    public void doLogin(String userName){
        loginView.showLoadding(); // 展示加载条
        User user = new User();
        user.name = userName;
        loginBiz.doLogin(new OnGetDataListener<User>() {
            @Override
            public void success(User response) {
                loginView.hideLoadding(); // 隐藏加载条
                loginView.showView(response.name); // 展示数据
            }

            @Override
            public void fail(User response, String msg) {
                loginView.hideLoadding();
                loginView.showView(msg);
            }
        },user);
    }
}

MainActivity的xml文件

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:paddingBottom="@dimen/activity_vertical_margin"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin">

    <TextView
        android:id="@+id/textView"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="用户名" />

    <EditText
        android:id="@+id/editText"
        android:layout_width="match_parent"
        android:layout_height="wrap_content" />

    <Button
        android:id="@+id/button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="DO" />

    <ProgressBar
        android:id="@+id/progressBar"
        style="?android:attr/progressBarStyleLarge"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_gravity="center_horizontal"
        android:visibility="gone" />

</LinearLayout>

MainActivity.class

public class MainActivity extends Activity implements ILoginView {

    private String TAG = MainActivity.class.getSimpleName();
    private EditText editText;
    private TextView textView;
    private Button button;
    private ProgressBar progressBar;

    private LoginPresenter loginPresenter;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        initUI();
        loginPresenter=new LoginPresenter(this);
        button=(Button) findViewById(R.id.button);
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                String userName = editText.getText().toString();
                loginPresenter.doLogin(userName);
            }
        });

    }

    private void initUI() {
        editText = (EditText) findViewById(R.id.editText);
        textView = (TextView) findViewById(R.id.textView);
        progressBar = (ProgressBar) findViewById(R.id.progressBar);
    }

    @Override
    public void showView(String userName) {
        textView.setText(userName);
    }

    @Override
    public void showLoadding() {
        progressBar.setVisibility(View.VISIBLE);
    }

    @Override
    public void hideLoadding() {
        progressBar.setVisibility(View.GONE);
    }
}

记性不好,特此记录

2017-05-24 18:25:39 u012811342 阅读数 185
  • 微信h5支付开发-php开发微信h5支付demo

    会员免费看,http://edu.csdn.net/lecturer/842右侧可办理会员卡。微信h5支付开发是子恒老师《子恒说微信开发》视频教程的第17部。详细讲解了微信H5支付开发,内容包含开通H5支付,实现微信h5支付,订单查询,关闭订单等等。欢迎反馈,微信号:QQ68183131

    8013 人正在学习 去看看 秦子恒

Androidstudio使用RXjava/RxAndroid需要在build.gradle添加引用

compile 'io.reactivex:rxjava:1.3.0'
compile 'io.reactivex:rxandroid:1.2.1'
两种写法:
普通写法:
Observable.just(getList()).subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers
        .mainThread()).subscribe(new Action1<List<String>>() {
    @Override
    public void call(List<String> list) {
        sayHello(list);
    }
});
配合jdk1.8的lambdas语法:

Observable.just(getList()).subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers
        .mainThread()).subscribe(list -> {
    sayHello(list);
});
github地址:https://github.com/hushendian/Rxjava-lambdas.git



2017-02-23 12:54:43 zhang___yong 阅读数 1071
  • 微信h5支付开发-php开发微信h5支付demo

    会员免费看,http://edu.csdn.net/lecturer/842右侧可办理会员卡。微信h5支付开发是子恒老师《子恒说微信开发》视频教程的第17部。详细讲解了微信H5支付开发,内容包含开通H5支付,实现微信h5支付,订单查询,关闭订单等等。欢迎反馈,微信号:QQ68183131

    8013 人正在学习 去看看 秦子恒

思考从网络请求数据的异步任务,通常使用AsyncTask或其他方式将异步任务与当前活动绑定在一起。这样做有很多风险,活动的负担太重,线程也不能及时的关闭。或者把异步任务封装在工具类里,利用接口回调得到数据,但是这样也不是很好。下面看看rx怎么实现从网上下载一张图片并赋值给UI:

别忘了添加网络权限

1.首先创建一个工具类并写一个方法,返回值为一个观察者,泛型是想要的数据(字节数组):

public class DownLoadUtil {
    private OkHttpClient client;

    public DownLoadUtil(){
        client=new OkHttpClient();
    }

    public Observable<byte []> download(String path){
        return Observable.create(new Observable.OnSubscribe<byte[]>() {
            @Override
            public void call(Subscriber<? super byte[]> subscriber) {
                if (!subscriber.isUnsubscribed()){
                    //在这里访问网络并发送数据
                    Request request=new Request.Builder().url(path).build();
                    client.newCall(request).enqueue(new Callback() {
                        @Override
                        public void onFailure(Call call, IOException e) {
                        }
                        @Override
                        public void onResponse(Call call, Response response) throws IOException {
                            if (response.isSuccessful()){
                                subscriber.onNext(response.body().bytes());
                                subscriber.onCompleted();
                            }
                        }
                    });
                }
            }
        });
    }
}

使用OkHttp进行网络请求,拿到字节数组后调用观察者的onNext进行发送。


2.在活动中创建这个被观察者并订阅自定义的观察者,在onNext中处理数据:

DownLoadUtil util=new DownLoadUtil();
                util.download(path).observeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread())
                        .subscribe(new Subscriber<byte[]>() {
                            @Override
                            public void onCompleted() {
                            }
                            @Override
                            public void onError(Throwable e) {
                            }
                            @Override
                            public void onNext(byte[] bytes) {
                                Bitmap bitmap=BitmapFactory.decodeByteArray(bytes,0,bytes.length);
                                iv.setImageBitmap(bitmap);
                            }
                        });

被观察者调用的两个observeOn第一个是指任务在网络请求中执行涉及io,第二个表示任务在主线程执行。我的这段代码是写在一个点击事件中,虽然涉及UI操作,但是因为指定在主线程执行所以没有任何问题。


可以看到整个结构非常清晰,异步网络任务在被观察者中进行,拿到数据后发送给观察者,观察者进行UI赋值等操作。首先活动的负担大大减少,其次异步线程也很好控制。

RxAndroid学习:初探

阅读数 457

没有更多推荐了,返回首页