苏火火丶
苏火火丶

RxJava2最全面、最详细的讲解（三）

前言：不要在该奋斗的年纪去选择安逸享乐，不是每个人都能成为自己想要的样子，但是每个人都能努力成为自己想要的样子，相信自己，你能作茧自缚，最终也能破茧成蝶。                                                              —— 致正在努力奋斗打拼的人

一、概述

RxJava如此受欢迎，是因为提供了丰富且功能强大的操作符，几乎能完成所有的功能需求。下面我们会继续学习其他操作符。RxJava2在第一篇文章作了详细的介绍，是一个基于事件流的异步操作库。第二篇文章中讲解了RxJava的变换操作符，组合操作符，合并操作符（链接和源码在文章最后给出）；如果不了解Rxjava2可以参考下RxJava2最全面、最详细的讲解(一)，如果英文比较好而且有兴趣的可以到官网学习：ReactiveX的官方网站。下面开始继续讲解RxJava2的其他用法。

二、延迟操作符

1.delay()

延迟一定时间Observable(被观察者)再发送事件，delay()有个多个重载的方法：

delay()的构造方法：

delay(long delay, TimeUnit unit)
delay(long delay, TimeUnit unit, boolean delayError)
delay(long delay, TimeUnit unit, Scheduler scheduler)
delay(long delay, TimeUnit unit, Scheduler scheduler, boolean delayError)

  • delay：        延迟的时间，Long类型；
  • unit：           事件单位，TimeUnit.SECONDS等类型；
  • delayError：是否开启错误延迟，boolean类型；
  • scheduler： 调度器，用于切换线程。

如果存在错误或异常事件，则正常执行，执行后再抛出异常，error事件后的其他事件不会再被执行。

Observable.create(new ObservableOnSubscribe() {
        @Override
        public void subscribe(ObservableEmitter e) {
            e.onNext(1);
            e.onNext(2);
            e.onError(new Exception("抛出异常"));
            e.onNext(3);
            e.onComplete();
        }
    })
            //延时2秒，时间单位为秒，开启错误回调延时
            .delay(2, TimeUnit.SECONDS, true)
            .subscribe(new Observer() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "delay：onSubscribe == 订阅");
        }

        @Override
        public void onNext(Integer integer) {
            Log.e(TAG, "delay：onNext == " + integer);

        }

        @Override
        public void onError(Throwable e) {
            Log.e(TAG, "delay：onError == " + e.getMessage());
        }

        @Override
        public void onComplete() {
            Log.e(TAG, "delay：onComplete == ");
        }
    });

上面例子中，发送1，2，抛出异常，3共四个事件，设置2秒延时，同时开启delayError错误延时，打印数据如下：

RxJava2最全面、最详细的讲解（三）_第1张图片

三、do操作符

1.doOnNext()与doOnEach()与doAfterNext()

  • doOnNext()：     每个事件都会执行，执行next()事件前执行；
  • doOnEach()：    每个事件都会执行，当Observable每次发送一个数据事件都会调用(onNext()前回调)；
  • doAfterNext()：  每个事件都会执行，执行next()事件后执行。
 Observable.just(1, 2, 3)
         //执行next()事件前执行
         .doOnNext(new Consumer() {
        @Override
        public void accept(Integer integer) throws Exception {
            Log.e(TAG, "doOnNext 事件前执行== " + integer);
        }
    })
            //当Observable每次发送一个数据事件都会调用(onNext()前回调)
            .doOnEach(new Consumer>() {
        @Override
        public void accept(Notification integerNotification) {
            Log.e(TAG, "doOnEach 每次都执行== " + integerNotification.getValue());
        }
    })
            //执行next()事件后执行
            .doAfterNext(new Consumer() {
        @Override
        public void accept(Integer integer) {
            Log.e(TAG, "doAfterNext 事件后执行== " + integer);
        }
    })
            .subscribe(new Observer() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "doNext：onSubscribe == 订阅");
        }

        @Override
        public void onNext(Integer integer) {
            Log.e(TAG, "doNext：onNext == " + integer);
        }

        @Override
        public void onError(Throwable e) {
            Log.e(TAG, "doNext：onError == " + e.getMessage());
        }

        @Override
        public void onComplete() {
            Log.e(TAG, "doNext：onComplete == ");
        }
    });

这里发送了1,2,3共三个事件，分别测试了doOnNext()与doOnEach()与doAfterNext()，打印log如下：

RxJava2最全面、最详细的讲解（三）_第2张图片

2.doOnError()与doAfterTerminate()

  • doOnError()：           Observable发送错误事件时调用；
  • doAfterTerminate()：Observable发送事件完毕后，无论是正常发送还是异常终止都会执行。
Observable.create(new ObservableOnSubscribe() {
        @Override
        public void subscribe(ObservableEmitter e) {
            e.onNext(1);
            e.onError(new Exception("抛出异常"));
            e.onNext(2);
            e.onComplete();
        }
    })
            //Observable发送错误事件时调用
            .doOnError(new Consumer() {
        @Override
        public void accept(Throwable throwable) throws Exception {
            Log.e(TAG, "doOnError 发送错误事件== " + throwable.getMessage());
        }
    })
            //Observable发送事件完毕后，无论是正常发送还是异常终止都会执行
            .doAfterTerminate(new Action() {
        @Override
        public void run() throws Exception {
            Log.e(TAG, "doAfterTerminate == 事件结束");
        }
    })
            .subscribe(new Observer() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "doOnError：onSubscribe == 订阅");
        }

        @Override
        public void onNext(Integer integer) {
            Log.e(TAG, "doOnError：onNext == " + integer);
        }

        @Override
        public void onError(Throwable e) {
            Log.e(TAG, "doOnError：onError == " + e.getMessage());
        }

        @Override
        public void onComplete() {
            Log.e(TAG, "doOnError：onComplete == ");
        }
    });

上面例子中，发送事件中途抛出异常，调用doOnError()与doAfterTerminate()方法，打印数据如下：

3.doOnSubscribe()与doOnComplete()与doFinally()

  • doOnSubscribe()：观察者订阅时调用；
  • doOnComplete()：Observable正常发送事件完成后调用；
  • doFinally()：          最后执行。
Observable.just(1, 2, 3)
             //观察者订阅时调用
             .doOnSubscribe(new Consumer() {
        @Override
        public void accept(Disposable disposable) {
            Log.e(TAG, "doOnSubscribe == 订阅时执行");
        }
    })
            //Observable正常发送事件完成后调用
            .doOnComplete(new Action() {
        @Override
        public void run() {
            Log.e(TAG, "doOnComplete == 事件完成执行");
        }
    })
            //最后执行
            .doFinally(new Action() {
        @Override
        public void run() {
            Log.e(TAG, "doFinally == 最后执行");
        }
    })
            .subscribe(new Observer() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "concat：onSubscribe == 订阅");
        }

        @Override
        public void onNext(Integer integer) {
            Log.e(TAG, "concat：onNext ==" + integer);
        }

        @Override
        public void onError(Throwable e) {
            Log.e(TAG, "concat：onError == " + e.getMessage());
        }

        @Override
        public void onComplete() {
            Log.e(TAG, "concat：onComplete == ");
        }
    });

上面例子中，发送了1,2,3共三个事件，分别调用doOnSubscribe()与doOnComplete()与doFinally()方法，打印log如下:

RxJava2最全面、最详细的讲解（三）_第3张图片

关于do相关的操作符总结一下：

创建类型 作用 使用场景
do相关操作符 doOnNext() 执行onNext()事件前调用

在事件生命周期伴随事件

回调执行其他的相关逻辑
doOnEach() 当Observable每发送一次数据就调用一次
doAfterNext() 执行onNext()事件后调用
doOnError() 发送错误事件时调用
doAfterTerminate() 无论是正常发送事件完毕/异常终止都回调
doOnSubscribe() 观察者订阅时回调
doOnComplete() 正常发送事件完毕后
doFinally() 最后执行

四、错误处理操作符

1.onErrorReturn()

在被观察者Observable发生错误或者异常的时候，拦截错误并执行指定逻辑，返回一个与源Observable相同类型的结果（onNext()），最后回调onComplete()方法。简单来说，Observable发生错误或异常时发送一个相同类型的特殊事件，并且终止事件发送。

Observable.create(new ObservableOnSubscribe() {
        @Override
        public void subscribe(ObservableEmitter e) throws Exception {
            //发送1~10共10个事件
            for (int i = 0; i < 10; i++) {
                if (i == 5) {//i==5抛出异常
                    e.onError(new Exception("抛出异常"));
                }
                e.onNext(i);
            }
        }
    })
            //在Observable发生错误或者异常的时候，拦截错误并执行指定逻辑，
            //返回一个与源Observable相同类型的结果（onNext()），最后回调onConplete()方法。
            .onErrorReturn(new Function() {
        @Override
        public Integer apply(Throwable throwable) throws Exception {
            return 404;
        }
    })
            .subscribe(new Observer() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "concat：onSubscribe == 订阅");
        }

        @Override
        public void onNext(Integer integer) {
            Log.e(TAG, "concat：onNext ==" + integer);
        }

        @Override
        public void onError(Throwable e) {
            Log.e(TAG, "concat：onError == " + e.getMessage());
        }

        @Override
        public void onComplete() {
            Log.e(TAG, "concat：onComplete == ");
        }
    });

上面例子中，发送1~10共10个事件，当发送第五个事件时，抛出异常，onErrorReturn()回调的方法就会执行发送同类型的数据onNext(404)给订阅者，订阅者Observer接收404并且回调onComplete()方法，打印log如下：

RxJava2最全面、最详细的讲解（三）_第4张图片

2.onErrorResumeNext()

在被观察者Observable发生错误或者异常的时候，拦截错误并执行指定逻辑，返回一个与源Observable相同类型的新的Observable被观察者，最后回调onComplete()方法。

onErrorResumeNext()与onErrorReturn()类似，区别在于：

  • onErrorReturn()：          返回的是一个与源Observable相同类型的结果（onNext()）
  • onErrorResumeNext()：返回的是与源Observable相同类型的新的Observable，也就是说可以返回多个相同类型的Observable。
Observable.create(new ObservableOnSubscribe() {
        @Override
        public void subscribe(ObservableEmitter e) throws Exception {
            //发送2个事件
            e.onNext("一");
            e.onNext("二");
            //抛出异常
            e.onError(new Exception("抛出异常"));
        }
    })
            //拦截错误并执行指定逻辑，返回Observable
            .onErrorResumeNext(new Function>() {
        @Override
        public ObservableSource apply(Throwable throwable) {
            return Observable.just("404", "405", "406");
        }
    })
            .subscribe(new Observer() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "onErrorResumeNext：onSubscribe == 订阅");
        }

        @Override
        public void onNext(String s) {
            Log.e(TAG, "onErrorResumeNext：onNext ==" + s);
        }

        @Override
        public void onError(Throwable e) {
            Log.e(TAG, "onErrorResumeNext：onError == " + e.getMessage());
        }

        @Override
        public void onComplete() {
            Log.e(TAG, "onErrorResumeNext：onComplete == ");
        }
    });

这里发送了“一”，“二”两个事件后，抛出异常，在onErrorResumeNext()回调方法中返回3个相同类型的Observable：“404”，“405”，“406”，打印结果如下：

RxJava2最全面、最详细的讲解（三）_第5张图片

3.onExceptionResumeNext()

在被观察者Observable发生异常的时候，返回一个与源Observable相同类型的新的Observable被观察者，拦截异常并执行指定逻辑，终止事件发送。

onErrorResumeNext()与onErrorReturn()类似，区别在于：

  • onErrorResumeNext()：          拦截的是错误Error和异常Exception，回调onConplete()
  • onExceptionResumeNext()：  只能拦截异常Exception，不回调onConplete()

注意：这里仅仅是发生异常Exception的时候回调，发送错误Error并不会回调。

这里普及一个知识，如果熟悉的可以跳过，Java的异常分为错误(Error)和异常(Exception)两种，他们都继承自Throwable。

错误(Error)：一般是比较严重的系统问题，比如我们经常遇到的OutOfMemoryError、StackOverflowError等错误。错误一般继承与Error，Error继承与Throwable，如果需要捕获错误则需要使用try…catch(Error e)或者try…catch(Throwable t)，使用try…catch(Exception e)句式无法捕获异常。

异常(Exception)：一般是根据实际处理业务抛出的异常，分为运行时异常(RuntimeException)和普通异常，普通异常直接继承Exception类，如果内部方法没有try…catch(Exception e)句式，就必须通过throws关键字将异常抛出外部处理(即checked异常)，而运行时异常继承RuntimeException类，如果内部没有设置try…catch(Exception e)处理，不需要显示通过throws关键字抛出外部，如NullPointerException、IndexOutOfBoundsException等运行时异常，当然RuntimeException继承自Exception，异常(Exception)继承自Throwable，可以通过try…catch(Exception e)捕获异常。

Observable.create(new ObservableOnSubscribe() {
        @Override
        public void subscribe(ObservableEmitter e) throws Exception {
            //发送2个事件
            e.onNext("事件1");
            e.onNext("事件2");
            //抛出异常
            e.onError(new Exception("抛出异常"));
        }
    })
            //拦截异常并执行指定逻辑,返回多个Observable执行的事件
            .onExceptionResumeNext(new ObservableSource() {
        @Override
        public void subscribe(Observer observer) {
            observer.onNext("404");
            observer.onNext("405");
            observer.onNext("406");
        }
    })
            .subscribe(new Observer() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "onExceptionResumeNext：onSubscribe == 订阅");
        }

        @Override
        public void onNext(String s) {
            Log.e(TAG, "onExceptionResumeNext：onNext ==" + s);
        }

        @Override
        public void onError(Throwable e) {
            Log.e(TAG, "onExceptionResumeNext：onError == " + e.getMessage());
        }

        @Override
        public void onComplete() {
            Log.e(TAG, "onExceptionResumeNext：onComplete == ");
        }
    });

这里发送了"事件1"，"事件2"后抛出异常，执行onExceptionResumeNext()回调方法，观察者Observer重新发送“404”，“405”，“406”三个事件的结果，打印log如下：

4.retry()

当被观察者Observable发生错误或者异常时，重新尝试执行Observable的逻辑，如果经过n次重试后仍然出现错误或者异常，最后回调onError()方法，如果没有错误或者异常，则按照正常的流程走。简单来说就是出现错误或者异常的时候，让被观察者重新发送数据，回调onError方法。

注意：如果没有指定重试次数，则retry()会一直无限重试。

retry()的相关构造方法：

//无限次重试
retry();
//指定重试次数
retry(long times);
//无限重试，返回当前重试的次数和异常信息
retry(BiPredicate predicate);
//指定重试次数，返回异常信息
retry(long times, Predicate predicate);
//无限重试，返回异常信息
retry(Predicate predicate);

相关参数解析：

  • times：                                                                                     设置的重试次数，Long类型；
  • Predicate predicate：                             存放的错误或者异常信息；
  • BiPredicate predicate：错误异常信息，Integer表示当前重试的次数为第几次。
Observable.create(new ObservableOnSubscribe() {
        @Override
        public void subscribe(ObservableEmitter e) {
            e.onNext(1);
            e.onNext(2);
            e.onError(new Exception("抛出异常"));
        }
    })
            //重新发送数据，这里重发2次，带有异常信息回调
            .retry(2, new Predicate() {
        @Override
        public boolean test(Throwable throwable) {
            //false: 不重新发送数据，回调Observer的onError()方法结束
            //true: 重新发送请求（最多发送2次）
            return true;
        }
    })
            .subscribe(new Observer() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "retry：onSubscribe == 订阅");
        }

        @Override
        public void onNext(Integer integer) {
            Log.e(TAG, "retry：onNext ==" + integer);
        }

        @Override
        public void onError(Throwable e) {
            Log.e(TAG, "retry：onError == " + e.getMessage());
        }

        @Override
        public void onComplete() {
            Log.e(TAG, "retry：onComplete == ");
        }
    });

这里发送事件1,2后“抛出异常”事件，retry()重写方法中返回的boolean值表示是否发送重试请求，那么这里会重试2次后回调onError()方法，打印数据如下：

RxJava2最全面、最详细的讲解（三）_第6张图片

5.retryWhen()

在源被观察者Observable出现错误或者异常时，通过回调新的Observable来判断是否重新尝试执行源Observable的逻辑， 如果第二个Observable没有出现错误或者异常，就会重新尝试执行源Observable的逻辑，否则会直接回调订阅者的onError()方法。

retryWhen()与retry()类似，简单来说，遇到错误或异常时，将错误发送给新的Observable被观察者，并决定是否需要原来的Observable重新订阅并且发送事件。

 Observable.create(new ObservableOnSubscribe() {
        @Override
        public void subscribe(ObservableEmitter e) {
            e.onNext(66);
            e.onNext(88);
            e.onError(new Exception("抛出异常"));
        }
    })
            //发生错误或者异常时，重试，将原来Observable的错误或者异常事件，转换成新的Observable
            //如果新的Observable返回了onError()事件，则不再重新发送原来Observable的数据
            //如果新的Observable返回onNext事件，则会重新发送原来Observable的数据
            .retryWhen(new Function, ObservableSource>() {
        @Override
        public ObservableSource apply(Observable throwableObservable){
            return throwableObservable.flatMap(new Function>() {
                @Override
                public ObservableSource apply(Throwable throwable) throws Exception {
                    //新观察者Observable发送onNext()事件，则源Observable重新发送数据。如果持续遇到错误则持续重试。
                    //return Observable.just(1);

                    //回调onError()事件，并且接收传过去的错误信息
                    return Observable.error(new Exception("抛出异常2"));
                }
            });
        }
    })
            .subscribe(new Observer() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "retryWhen：onSubscribe == 订阅");
        }

        @Override
        public void onNext(Integer integer) {
            Log.e(TAG, "retryWhen：onNext ==" + integer);
        }

        @Override
        public void onError(Throwable e) {
            Log.e(TAG, "retryWhen：onError == " + e.getMessage());
        }

        @Override
        public void onComplete() {
            Log.e(TAG, "retryWhen：onComplete == ");
        }
    });

（1）新的被观察者Observable发送onError()事件，打印log如下：

（2）新的被观察者Observable发送其他事件，发送的数据不重要，只是新的Observable通知原来的Observable重新发数据，打印log如下：

6.repeat()

repeat()表示重复发送被观察者事件。可设置重复的次数，如果不设置参数则会无限次重复发送。注意：如果中途抛出错误或者异常，则无法重复发送。

Observable.just(1,2)
        //重复2次
        .repeat(2)
               .subscribe(new Observer() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "repeat：onSubscribe == 订阅");
        }

        @Override
        public void onNext(Integer integer) {
            Log.e(TAG, "repeat：onNext ==" + integer);
        }

        @Override
        public void onError(Throwable e) {
            Log.e(TAG, "repeat：onError == " + e.getMessage());
        }

        @Override
        public void onComplete() {
            Log.e(TAG, "repeat：onComplete == ");
        }
    });

这里重复发送事件队列1,2，重复两次，打印log如下：

RxJava2最全面、最详细的讲解（三）_第7张图片

6.repeatWhen()

repeatWhen()是指有条件，重复性发送原来的被观察者Observable事件；在回调方法中创建新的Observable，通过新的observable是否重新订阅和发送事件。

注意：如果新的Observable被观察者返回onComplete()或onError()事件，则不重新订阅、发送源Observable的事件；如果新的Observable被观察者返回其他事件，则重新订阅、发送源Observable的事件。

Observable.just(1004,1005)
            .repeatWhen(new Function, ObservableSource>() {
        //如果新的Observable被观察者返回onComplete()或onError()事件，则不重新订阅、发送源Observable的事件
        //如果新的Observable被观察者返回其他事件，则重新订阅、发送源Observable的事件
        @Override
        public ObservableSource apply(Observable objectObservable) throws Exception {
            //flatMap用于接收上面的数据
            return objectObservable.flatMap(new Function>() {
                @Override
                public ObservableSource apply(Object o) throws Exception {
                    //通知原来的Observable，重新订阅和发送事件（发送什么数据不重要，这里仅做通知使用）
                    //return Observable.just(1);

                    //等于发送onComplete()方法，但是不会回调Observer的onComplete()
                    //return Observable.empty();

                    //回调onError()事件，并且接收传过去的错误信息
                    return Observable.error(new Exception("抛出异常"));
                }
            });
        }
    }).subscribe(new Observer() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "repeatWhen：onSubscribe == 订阅");
        }

        @Override
        public void onNext(Integer integer) {
            Log.e(TAG, "repeatWhen：onNext ==" + integer);
        }

        @Override
        public void onError(Throwable e) {
            Log.e(TAG, "repeatWhen：onError == " + e.getMessage());
        }

        @Override
        public void onComplete() {
            Log.e(TAG, "repeatWhen：onComplete == ");
        }
    });
 
  
发送其他事件Observable.just(1)，会重复通知原来的Observable被观察者重新订阅和发送是事件，打印数据如下：
 
  
RxJava2最全面、最详细的讲解（三）_第8张图片
 
  
发送Observable.empty()，不会回调onComplete()方法；
 
  
 
  
发送Observable.error(new Exception("抛出异常"))，回调onError()事件，并且接收传过去的错误信息，打印log如下：
 
  
 
  
错误处理操作符总结一下：
 
  
 
    
    
 
     创建类型 
     作用 
     使用场景 
    
 
    
 
     错误处理操作符 
     onErrorReturn() 
     Observable发生错误或异常时发送一个相同类型的特殊事件，并且终止事件发送。 
      
遇到错误异常时的解决机制
 		 
    
 
    
 
     onErrorResumeNext() 
     Observable发生错误或异常时产生新的Observable发送一个特殊事件，并且终止事件发送。 
    
 
    
 
     onExceptionResumeNext() 
     同上，不同点：这里只能拦截异常不能拦截错误 
    
 
    
 
     retry() 
     发生异常或错误时重试源Observable的请求 
    
 
    
 
     retryWhen() 
     同上，不同点：将错误异常传递给新的Observable通知源Observable 
    
 
    
 
     repeat() 
     重复源Observable发送事件（抛出异常错误不能重复发送） 
    
 
    
 
     repeatWhen() 
     在回调方法中创建新的Observable，通过新的observable是否重复订阅和发送事件。 
    
 
    
  
 
  
至此，本文结束！其他相关用法请留意下一篇文章！
 
  
 
   
源码地址：https://github.com/FollowExcellence/Rxjava_Retrofit
 
  
 
  
点关注，不迷路
 
  
 
  
好了各位，以上就是这篇文章的全部内容了，能看到这里的人呀，都是人才。
 
  
我是suming，感谢各位的支持和认可，您的点赞、评论、收藏【一键三连】就是我创作的最大动力，我们下篇文章见！
 
  
如果本篇博客有任何错误，请批评指教，不胜感激 ！
 
  
要想成为一个优秀的安卓开发者，这里有必须要掌握的知识架构，一步一步朝着自己的梦想前进！Keep Moving!
 
  
 
   
相关文章：
 
   
Retrofit2详解和使用（一）
 
   
     
    
  • Retrofit2的介绍和简单使用
    •  
   
 
   
OKHttp3的使用和详解
 
   
     
    
  • OKHttp3的用法介绍和解析
    •  
   
 
   
OKHttp3源码详解
 
   
     
    
  • 从源码角度解释OKHttp3的关键流程和重要操作
    •  
   
 
   
RxJava2详解（一）
 
   
     
    
  • 详细介绍了RxJava的使用（基本创建、快速创建、延迟创建等操作符）
    •  
   
 
   
RxJava2详解（二）
 
   
     
    
  • RxJava转换、组合、合并等操作符的使用
    •  
   
 
   
RxJava2详解（三）
 
   
     
    
  • RxJava延迟、do相关、错误处理等操作符的使用
    •  
   
 
   
RxJava2详解（四）
 
   
     
    
  • RxJava过滤、其他操作符的使用
    •  
   
 
   
上述几篇都是android开发必须掌握的，后续会完善其他部分！
 
  
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Android网络请求相关,rxjava使用,rxjava详解,android,rxjava)

        

            

                
    
                    
  • golang - context包使用示例 以及 底层实现
                        切尔诺贝尔
golanggo上下文context并发
                        
    文章目录1.context常用方法，以及各种适用于什么场景1.1context含有的方法1.2方法适用场景和伪代码示例1.2.1值传递：比如gin框架中用来传递key,value的值，自己简单示例如下1.2.2超时控制-timeout:http请求设置超时时间1.2.3,超时控制-deadline:比如文件io或者网络io等耗时操作，可以查看剩余的时间是否充足，决定是否进行下一步操作1.2.4.取
    
                    
    • 
                    
  • 简述java垃圾回收过程_浅析 java 垃圾回收（一）—— 以 HotSpot 为例
                        Patchouli Exarch
简述java垃圾回收过程
                        
    java的垃圾回收也就是我们常说的gc(garbagecollector)。这是一个老生常谈的问题。之所以这么经常被提及，是因为它对java性能有很大影响。在c/c++中考虑到效率，内存的分配和销毁是由程序员来控制的。程序员使用内存必须手动分配，在使用结束后，在手动释放掉已经不用的内存空间。如果忘记释放内存空间，那么这块内存区域就是一直被占用的状态。其他急需内存的程序将无法使用这块内存，导致内存泄
    
                    
    • 
                    
  • 用java实现etcd分布式锁_etcd分布式锁及事务
                        程序员必修课
用java实现etcd分布式锁
                        
    前言分布式锁是控制分布式系统之间同步访问共享资源的一种方式。在分布式系统中，常常需要协调他们的动作。如果不同的系统或是同一个系统的不同主机之间共享了一个或一组资源，那么访问这些资源的时候，往往需要互斥来防止彼此干扰来保证一致性，在这种情况下，便需要使用到分布式锁。etcd分布式锁设计排他性：任意时刻，只能有一个机器的一个线程能获取到锁。通过在etcd中存入key值来实现上锁，删除key实现解锁，参
    
                    
    • 
                    
  • DeepSeek 部署中的常见问题及解决方案：Mac 场景实践指南
                        轻口味
大模型实战macosdeepseek
                        
    DeepSeek部署中的常见问题及解决方案：Mac场景实践指南随着大模型技术的快速发展，DeepSeek作为开源领域的优秀代表，在本地化部署过程中常会遇到各类技术挑战。本文基于实际部署经验，梳理了五大高频问题及对应解决方案，助您快速完成部署并实现稳定运行。一、环境配置问题1.依赖库安装失败现象：pipinstall-rrequirements.txt报错或部分库版本冲突解决方案：使用虚拟环境隔离依
    
                    
    • 
                    
  • golang-context包学习分享
                        徐先森胆大心细颜值高
golanggolang
                        
    上下文Contextcontext.Context是Go语言中独特的设计，在其他编程语言中我们很少见到类似的概念。上下文与Goroutine有比较密切的关系。上下文context.Context是用来设置截止日期、同步信号，传递请求相关值的结构体。context.Context是Go语言在1.7版本中引入标准库的接口，该接口定义了四个需要实现的方法，其中包括：Deadline—返回context.
    
                    
    • 
                    
  • Vue 前端开发中的路由知识：从入门到精通
                        chenNorth。
vue前端vue.js前端javascript
                        
    文章目录引言1.VueRouter简介1.1安装VueRouter1.2配置VueRouter1.3在Vue实例中使用VueRouter2.路由的基本用法2.1路由映射2.2路由视图2.3路由链接3.动态路由3.1动态路径参数3.2访问动态参数3.3响应路由参数的变化4.嵌套路由4.1定义嵌套路由4.2渲染嵌套路由5.路由守卫5.1全局守卫5.2路由独享守卫5.3组件内守卫6.路由懒加载6.1使用
    
                    
    • 
                    
  • darts框架使用
                        ME_Seraph
机器学习darts
                        
    文|Seraph高版本Pytorch问题运行test.py报错IndexError:invalidindexofa0-dimtensor.Usetensor.item()toconverta0-dimtensortoaPythonnumber解决：update函数的参数loss.data[0]，prec1.data[0]，prec5.data[0]等修改为loss.item()，prec1.ite
    
                    
    • 
                    
  • vue3 reactive丢失响应式
                        想不到耶
vue3前端vue.js
                        
    问题使用reactive构造响应式对象时，当对其进行重新赋值后，会导致原有变量失去响应式，页面不会发生联动更新例如：1、使用reactive定义一个响应式的对象变量letdata1=reactive({name:'小李',date:'2024-03-18',address:'xx地址'})2、将属性渲染到页面上点击更新{{data1.name}}constchange=()=>{letdata2=
    
                    
    • 
                    
  • python面试题
                        阿芯爱编程
面试python开发语言
                        
    以下是一些Python面试题：一、基础语法Python中的列表（list）和元组（tuple）有什么区别？答案：可变性：列表是可变的，可以修改列表中的元素、添加或删除元素；元组是不可变的，一旦创建就不能修改。语法：列表使用方括号[]定义，元组使用圆括号()定义（单个元素的元组需要在元素后面加逗号，如(1,)）。性能：由于元组的不可变性，在某些情况下元组的性能比列表略高，例如在用作字典的键时（字典的
    
                    
    • 
                    
  • 状态机fsm
                        dajunzhi
状态机
                        
    一.三段式状态机跳转（alwayscur_state<=next_state）判断next_state是啥（alwayscase(cur_state)根据输入值，判断next_state是啥，记得default）输出结果（always块中，根据cur_state来输出结果，case(cur_state),使用时序电路，可以消解毛刺）二.两段式就是将2和3合并在一起，使用逻辑电路，不用时序电路，即将
    
                    
    • 
                    
  • raspberry pi_书评：“ Raspberry Pi for Secret Agents”的使用效果不佳
                        cuml0912
游戏java人工智能pythonlinux
                        
    raspberrypi许多父母在Opensource.com上看到我女儿的文章，并经常问我：“您是如何使您的女儿开始使用RaspberryPi的？”一切都从RaspberryPi作为圣诞节礼物开始，而我们以RaspberryPi教育手册作为指南开始。作为免费下载，这是一个很好的入门入门。然后我们转到其他书籍，例如《RaspberryPi入门》，我开始注意到一些模式。这些书经常一遍又一遍地涉及相同的
    
                    
    • 
                    
  • go-Context包详解
                        Zerore
gogolang开发语言后端
                        
    在go语言中，上下文context.Context用来设置截止日期、同步信号、传递请求相关值得结构体。上下文与Goroutine得关系比较密切，是go语言中独特得设计，在其他编程语言中很少见到类似的概念。context.Context是一个接口，定义了如下四个方法：//AContextcarriesadeadline,acancellationsignal,andothervaluesacross
    
                    
    • 
                    
  • Etcd教程 — 第二章 Etcd集群静态发现_etcd 双节点集群
                        2401_87361150
etcd数据库
                        
    监听用于和节点之间通信的url，可监听多个，集群内部将通过这些url进行数据交互(如选举，数据同步等)–initial-advertise-peer-urls建议用于和节点之间通信的url，节点间将以该值进行通信。–listen-client-urls监听的用于和客户端通信的url,同样可以监听多个。–advertise-client-urls建议使用的和客户端通信url,该值用于etcd代理或e
    
                    
    • 
                    
  • 蓝桥杯篇---IAP15F2K61S2串口
                        Ronin-Lotus
上位机知识篇嵌入式硬件篇蓝桥杯单片机职场和发展嵌入式硬件cIAP15F2K61S2
                        
    文章目录前言简介串口通信的基本参数1.波特率2.数据位3.停止位4.校验位串口相关寄存器1.SCON2.SBUF3.PCON4.TMOD5.TH1/TL1串口使用步骤1.配置波特率2.配置串口模式3.使能串口中断4.发送数据5.接收数据6.处理中断示例代码：串口发送与接收示例代码：串口接收数据并回显注意事项1.波特率设置2.中断优先级3.数据缓冲区4.错误处理总结前言本文仅仅简单介绍了IAP15F
    
                    
    • 
                    
  • 机器学习：k均值
                        golemon.
ML机器学习均值算法人工智能
                        
    所有代码和文档均在golitter/Decoding-ML-Top10:使用Python优雅地实现机器学习十大经典算法。(github.com)，欢迎查看。在“无监督学习”中，训练样本的标记信息是未知的，目标是通过对无标记训练样本的学习来揭示数据的内在性质及规律，为进一步的数据分析提供基础，较为经典的是聚类。**聚类试图将数据集中的样本划分为若干个通常是不相交的子集，每个子集称为一个“簇”。**聚
    
                    
    • 
                    
  • 急停信号的含义
                        c#上位机
运动控制
                        
    前言：大家好，我是上位机马工，硕士毕业4年年入40万，目前在一家自动化公司担任软件经理，从事C#上位机软件开发8年以上！我们在开发C#的运动控制程序的时候，一个必要的步骤就是确认设备按钮的急停信号是否生效，下面进行详细介绍如何实现这一需求！1、急停含义急停信号一般与急停按钮相关联，当我们的设备发生异常的时候，按下急停按钮，设备会停止动作，急停信号一般称为emg信号。2、雷赛运动控制卡的急停信号对于
    
                    
    • 
                    
  • 关于go-context包
                        敖光 SRE
go基础知识golang数据库开发语言
                        
    思维导图目的为了在不同的goroutine之间或跨API边界传递超时、取消信号和其他请求范围内的值（与该请求相关的值。这些值可能包括用户身份信息、请求处理日志、跟踪信息等等）。常用场景数据操作网络请求RPC操作context接口context包在提供了一个用于跨API边界传递超时、取消信号和其他请求范围值的通用数据结构。用于在多个Goroutine和函数之间传递请求范围内的信息。核心方法：Dead
    
                    
    • 
                    
  • 【设计模式】【行为型模式】迭代器模式（Iterator）
                        FLZJ_KL
设计模式设计模式迭代器模式java
                        
    hi，我不是一名外包公司的员工，也不会偷吃茶水间的零食，我的梦想是能写高端CRUD2025本人正在沉淀中…博客更新速度++欢迎点赞、收藏、关注，跟上我的更新节奏当你的天空突然下了大雨，那是我在为你炸乌云文章目录一、入门什么是迭代器模式？为什么要迭代器模式？怎么实现迭代器模式？二、迭代器模式在源码中的运用Java集合框架（JavaCollectionsFramework）Java集合框架迭代器的使用
    
                    
    • 
                    
  • 前端高级面试题
                        阿芯爱编程
面试前端
                        
    以下是一些高级前端面试题及答案：一、性能优化如何对大型前端项目进行性能剖析（profiling）？答案：使用ChromeDevTools中的Performance面板。可以记录页面加载和交互过程中的各种性能指标，如脚本执行时间、渲染时间、重绘和回流次数等。利用Lighthouse工具，它可以对网页进行全面的性能评估，包括加载性能、可访问性、最佳实践等方面，并给出优化建议。在代码中手动插入性能测量点
    
                    
    • 
                    
  • Linux使用chrony让局域网内的服务器时间同步_chrony同步间隔，走进Linux运维架构
                        2401_87298546
服务器运维linux
                        
    在所有节点上执行chrony服务安装命令，将主节点设置时间服务器，其他的节点都从主节点同步时间。#安装服务yum-yinstallchrony#查看状态systemctlstatuschronyd#重启chronydsystemctlrestartchronyd二、检查设置时区在所有节点上设置统一的时间区域，本文中将其设置为亚洲时区，用户可自行定义。#查看时区[root@x~]#timedatec
    
                    
    • 
                    
  • Python常见面试题的详解4
                        ylfhpy
Python基础python开发语言面试
                        
    1.单例模式的实现方式要点：Python有多种实现单例模式的方法。模块由于其特性天然支持单例，首次导入生成对象，后续导入直接复用。通过装饰器可以控制实例的创建，元类能借助__call__方法管理实例化过程，重写类的__new__方法也能保证实例的唯一性。示例：pythondefsingleton(cls):instances={}defget_instance(*args,**kwargs):#如
    
                    
    • 
                    
  • OpenVAS 工具使用全攻略
                        垚垚 Securify 前沿站
网络
                        
    目录一、引言二、安装OpenVAS2.1准备工作2.2Ubuntu系统安装步骤2.3CentOS系统安装步骤三、配置OpenVAS3.1初始化OpenVAS3.2设置管理员密码3.3启动服务四、使用OpenVAS进行扫描4.1登录Web界面4.2创建扫描任务4.3启动扫描4.4查看扫描结果五、结果分析与处理5.1风险等级评估5.2漏洞修复建议六、总结一、引言OpenVAS（OpenVulnerab
    
                    
    • 
                    
  • unity中的双击按钮检测和长按按钮的检测
                        头号理想
游戏效果unity
                        
    之前我写过关于UGUI的接口的几篇博客地址1地址2之后今天使用上边的知识来实现一下按钮的双击和按钮长按的检测其实我们的思路就是每次按下检测按下时间如果长按时间超过某一特定的值那么我们判定长按至于双击的检测我们是当第一次按下之后抬起开始计时在特定值之前我们如果检测到按下第二次我们判定双击按钮usingUnityEngine;usingUnityEngine.Events;usingUnityEngi
    
                    
    • 
                    
  • 多线程异步执行，等待执行全部执行完成后，返回全部结果 CompletableFuture和Future以及CountDownLatch 使用
                        知道的越多越难受
javajavajvmservlet
                        
    需求：需要异步执行多个任务，获取每个任务的结果。根据任务结果判断是否继续后面的操作//存储全部任务返回结果集合publicstaticvoidmain(String[]args){Listobjects=Collections.synchronizedList(newArrayList{try{Thread.sleep(1000);}catch(InterruptedExceptione){e.p
    
                    
    • 
                    
  • lua mysql 事务_Lua 数据库访问
                        weixin_39998906
luamysql事务
                        
    Lua数据库访问本文主要为大家介绍Lua数据库的操作库：LuaSQL。他是开源的，支持的数据库有：ODBC,ADO,Oracle,MySQL,SQLite和PostgreSQL。本文为大家介绍MySQL的数据库连接。LuaSQL可以使用LuaRocks来安装可以根据需要安装你需要的数据库驱动。LuaRocks安装方法：$wgethttp://luarocks.org/releases/luaroc
    
                    
    • 
                    
  • lua可以调用mysql数据库吗_Lua 数据库访问
                        女王丁丁

                        
    Lua数据库访问作者：杨梦鸽校对：翟舒青本文主要为大家介绍Lua数据库的操作库：LuaSQL。他是开源的，支持的数据库有：ODBC,ADO,Oracle,MySQL,SQLite和PostgreSQL。本文为大家介绍MySQL的数据库连接。LuaSQL可以使用LuaRocks来安装可以根据需要安装你需要的数据库驱动。LuaRocks安装方法：$wgethttp://luarocks.org/rel
    
                    
    • 
                    
  • 使用 Qt 插件和 SQLCipher 实现 SQLite 数据库加密与解密
                        web_15534274656
面试学习路线阿里巴巴数据库qtsqlite
                        
    SQLite作为一种轻量级的数据库，被广泛应用于各种桌面和移动应用中。然而，SQLite本身并不支持数据加密，这时SQLCipher成为一个理想的解决方案。本文将详细介绍如何在Qt项目中集成SQLCipher，实现SQLite数据库的加密与解密，包括创建加密数据库、插入数据以及查询数据的完整流程。目录简介前置条件项目配置代码实现创建加密数据库并插入数据读取加密数据库并查询数据常见问题与解决总结简介
    
                    
    • 
                    
  • Linux下使用poll函数编写UDP客户端、服务器程序
                        崔杰城
linuxudp网络协议网络
                        
    一、UDP服务器与客户端的区别对于UDP服务器与客户端，两者都可以通过sendto和recvfrom函数收发数据，它们的主要区别是：1.服务器一般是等待并响应来自客户端的请求，客户端则是主动发送请求并且等待服务器的响应。2.服务器端要将地址和端口号绑定，如果不绑定就无法使用recvfrom函数接受数据（也就是说服务器需要调用bind函数将一个套接字与一个地址绑定，而客户端不需要）。所以对于UDP，
    
                    
    • 
                    
  • AMBA-CHI协议详解（十一）
                        数字硬鉴
AMBA-CHI协议AMBA协议CHI协议总线设计ARM架构CPU设计
                        
    AMBA-CHI协议详解（一）-IntroductionAMBA-CHI协议详解（二）-Channelfields/ReadtransactionsAMBA-CHI协议详解（三）-WritetransactionsAMBA-CHI协议详解（四）-OthertransactionsAMBA-CHI协议详解（五）-TransactionidentifierfieldsAMBA-CHI协议详解（六）-T
    
                    
    • 
                    
  • AMBA-CHI协议详解（八）
                        数字硬鉴
AMBA-CHI协议AMBA协议CHI协议CPU总线设计CPU设计总线设计
                        
    AMBA-CHI协议详解（一）-IntroductionAMBA-CHI协议详解（二）-Channelfields/ReadtransactionsAMBA-CHI协议详解（三）-WritetransactionsAMBA-CHI协议详解（四）-OthertransactionsAMBA-CHI协议详解（五）-TransactionidentifierfieldsAMBA-CHI协议详解（六）-T
    
                    
    • 
                                
  • ztree异步加载
                                    3213213333332132
JavaScriptAjaxjsonWebztree
                                    
    相信新手用ztree的时候,对异步加载会有些困惑，我开始的时候也是看了API花了些时间才搞定了异步加载，在这里分享给大家。 
我后台代码生成的是json格式的数据，数据大家按各自的需求生成，这里只给出前端的代码。 
 
设置setting，这里只关注async属性的配置 
 

            var setting = {
            	//异步加载配置	
      
    
                                
    • 
                                
  • thirft rpc 具体调用流程
                                    BlueSkator
中间件rpcthrift
                                    
    Thrift调用过程中，Thrift客户端和服务器之间主要用到传输层类、协议层类和处理类三个主要的核心类，这三个类的相互协作共同完成rpc的整个调用过程。在调用过程中将按照以下顺序进行协同工作： 
        （1）     将客户端程序调用的函数名和参数传递给协议层（TProtocol），协议
    
                                
    • 
                                
  • 异或运算推导, 交换数据
                                    dcj3sjt126com
PHP异或^
                                    
    /*
 * 5 0101
 * 9 1010
 *
 * 5 ^ 5
 * 0101
 * 0101
 * -----
 * 0000
 * 得出第一个规律: 相同的数进行异或, 结果是0
 *
 * 9 ^ 5 ^ 6
 * 1010
 * 0101
 * ----
 * 1111
 *
 * 1111
 * 0110
 * ----
 * 1001
 
    
                                
    • 
                                
  • 事件源对象
                                    周华华
JavaScript
                                    
    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> 
<html xmlns="http://www.w3.org/1999/xhtml&q
    
                                
    • 
                                
  • MySql配置及相关命令
                                    g21121
mysql
                                    
            MySQL安装完毕后我们需要对它进行一些设置及性能优化，主要包括字符集设置，启动设置，连接优化，表优化，分区优化等等。 
  
        一 修改MySQL密码及用户 
     
    
                                
    • 
                                
  • [简单]poi删除excel 2007超链接
                                    53873039oycg
Excel
                                    
          采用解析sheet.xml方式删除超链接，缺点是要打开文件2次,代码如下: 
     
public void removeExcel2007AllHyperLink(String filePath) throws Exception {
		OPCPackage ocPkg = OPCPac
    
                                
    • 
                                
  • Struts2添加 open flash chart
                                    云端月影

                                    
    准备以下开源项目： 
1. Struts 2.1.6 
2. Open Flash Chart 2 Version 2 Lug Wyrm Charmer (28th, July 2009) 
3. jofc2，这东西不知道是没做好还是什么意思，好像和ofc2不怎么匹配，最好下源码，有什么问题直接改。 
4. log4j 
 
用eclipse新建动态网站，取名OFC2Demo，将Struts2 l
    
                                
    • 
                                
  • spring包详解
                                    aijuans
spring
                                    
      
下载的spring包中文件及各种包众多，在项目中往往只有部分是我们必须的，如果不清楚什么时候需要什么包的话，看看下面就知道了。 aspectj目录下是在Spring框架下使用aspectj的源代码和测试程序文件。Aspectj是java最早的提供AOP的应用框架。 dist 目录下是Spring 的发布包，关于发布包下面会详细进行说明。 docs&nb
    
                                
    • 
                                
  • 网站推广之seo概念
                                    antonyup_2006
算法Web应用服务器搜索引擎Google
                                    
       持续开发一年多的b2c网站终于在08年10月23日上线了。作为开发人员的我在修改bug的同时，准备了解下网站的推广分析策略。 
    所谓网站推广，目的在于让尽可能多的潜在用户了解并访问网站，通过网站获得有关产品和服务等信息，为最终形成购买决策提供支持。 
    网站推广策略有很多，seo，email，adv
    
                                
    • 
                                
  • 单例模式,sql注入,序列
                                    百合不是茶
单例模式序列sql注入预编译
                                    
      
序列在前面写过有关的博客,也有过总结,但是今天在做一个JDBC操作数据库的相关内容时 需要使用序列创建一个自增长的字段  居然不会了,所以将序列写在本篇的前面 
  
 1,序列是一个保存数据连续的增长的一种方式; 
序列的创建; 
 CREATE SEQUENCE seq_pro
  2  INCREMENT BY 1 -- 每次加几个
  3 
    
                                
    • 
                                
  • Mockito单元测试实例
                                    bijian1013
单元测试mockito
                                    
    Mockito单元测试实例： 
public class SettingServiceTest {
    
    private List<PersonDTO> personList = new ArrayList<PersonDTO>();
    
    @InjectMocks
    private SettingPojoService settin
    
                                
    • 
                                
  • 精通Oracle10编程SQL(9)使用游标
                                    bijian1013
oracle数据库plsql
                                    
    /*
 *使用游标
 */
--显示游标
--在显式游标中使用FETCH...INTO语句
DECLARE
   CURSOR emp_cursor is 
      select ename,sal from emp where deptno=1;
   v_ename emp.ename%TYPE;
   v_sal emp.sal%TYPE;
begin
   ope
    
                                
    • 
                                
  • 【Java语言】动态代理
                                    bit1129
java语言
                                    
      JDK接口动态代理 
JDK自带的动态代理通过动态的根据接口生成字节码(实现接口的一个具体类)的方式，为接口的实现类提供代理。被代理的对象和代理对象通过InvocationHandler建立关联 
  
package com.tom;

import com.tom.model.User;
import com.tom.service.IUserService;

    
                                
    • 
                                
  • Java通信之URL通信基础
                                    白糖_
javajdkwebservice网络协议ITeye
                                    
    java对网络通信以及提供了比较全面的jdk支持，java.net包能让程序员直接在程序中实现网络通信。 
在技术日新月异的现在，我们能通过很多方式实现数据通信，比如webservice、url通信、socket通信等等，今天简单介绍下URL通信。 
学习准备：建议首先学习java的IO基础知识 
  
URL是统一资源定位器的简写，URL可以访问Internet和www，可以通过url
    
                                
    • 
                                
  • 博弈Java讲义 - Java线程同步 (1)
                                    boyitech
java多线程同步锁
                                    
      
在并发编程中经常会碰到多个执行线程共享资源的问题。例如多个线程同时读写文件，共用数据库连接，全局的计数器等。如果不处理好多线程之间的同步问题很容易引起状态不一致或者其他的错误。 
   同步不仅可以阻止一个线程看到对象处于不一致的状态，它还可以保证进入同步方法或者块的每个线程，都看到由同一锁保护的之前所有的修改结果。处理同步的关键就是要正确的识别临界条件（cri
    
                                
    • 
                                
  • java-给定字符串，删除开始和结尾处的空格，并将中间的多个连续的空格合并成一个。
                                    bylijinnan
java
                                    
    

public class DeleteExtraSpace {

	/**
	 * 题目：给定字符串，删除开始和结尾处的空格，并将中间的多个连续的空格合并成一个。
	 * 方法1.用已有的String类的trim和replaceAll方法
	 * 方法2.全部用正则表达式，这个我不熟
	 * 方法3.“重新发明轮子”，从头遍历一次
	 */
	public static v
    
                                
    • 
                                
  • An error has occurred.See the log file错误解决！
                                    Kai_Ge
MyEclipse
                                    
    今天早上打开MyEclipse时，自动关闭！弹出An error has occurred.See the log file错误提示！ 
很郁闷昨天启动和关闭还好着！！！打开几次依然报此错误，确定不是眼花了！ 
打开日志文件！找到当日错误文件内容： 
--------------------------------------------------------------------------
    
                                
    • 
                                
  • [矿业与工业]修建一个空间矿床开采站要多少钱?
                                    comsci

                                    
     
       地球上的钛金属矿藏已经接近枯竭........... 
 
       我们在冥王星的一颗卫星上面发现一些具有开采价值的矿床..... 
 
       那么,现在要编制一个预算,提交给财政部门..
    
                                
    • 
                                
  • 解析Google Map Routes
                                    dai_lm
google api
                                    
    为了获得从A点到B点的路劲，经常会使用Google提供的API，例如 
[url] 
http://maps.googleapis.com/maps/api/directions/json?origin=40.7144,-74.0060&destination=47.6063,-122.3204&sensor=false 
[/url] 
从返回的结果上，大致可以了解应该怎么走，但
    
                                
    • 
                                
  • SQL还有多少“理所应当”？
                                    datamachine
sql
                                    
    转贴存档，原帖地址：http://blog.chinaunix.net/uid-29242841-id-3968998.html、http://blog.chinaunix.net/uid-29242841-id-3971046.html！ 
 
------------------------------------华丽的分割线-------------------------------- 

    
                                
    • 
                                
  • Yii使用Ajax验证时，如何设置某些字段不需要验证
                                    dcj3sjt126com
Ajaxyii
                                    
    经常像你注册页面,你可能非常希望只需要Ajax去验证用户名和Email,而不需要使用Ajax再去验证密码,默认如果你使用Yii 内置的ajax验证Form,例如: 
$form=$this->beginWidget('CActiveForm', array(        'id'=>'usuario-form',&
    
                                
    • 
                                
  • 使用git同步网站代码
                                    dcj3sjt126com
crontabgit
                                    
    转自:http://ued.ctrip.com/blog/?p=3646?tn=gongxinjun.com 
  
管理一网站，最开始使用的虚拟空间，采用提供商支持的ftp上传网站文件，后换用vps，vps可以自己搭建ftp的，但是懒得搞，直接使用scp传输文件到服务器，现在需要更新文件到服务器，使用scp真的很烦。发现本人就职的公司，采用的git+rsync的方式来管理、同步代码，遂
    
                                
    • 
                                
  • sql基本操作
                                    蕃薯耀
sqlsql基本操作sql常用操作
                                    
    sql基本操作 
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 
蕃薯耀 2015年6月1日 17:30:33 星期一 
  
  
&
    
                                
    • 
                                
  • Spring4+Hibernate4+Atomikos3.3多数据源事务管理
                                    hanqunfeng
Hibernate4
                                    
    Spring3+后不再对JTOM提供支持，所以可以改用Atomikos管理多数据源事务。Spring2.5+Hibernate3+JTOM参考：http://hanqunfeng.iteye.com/blog/1554251Atomikos官网网站：http://www.atomikos.com/   一.pom.xml 
<dependency>
			<
    
                                
    • 
                                
  • jquery中两个值得注意的方法one()和trigger()方法
                                    jackyrong
trigger
                                    
      在jquery中，有两个值得注意但容易忽视的方法，分别是one()方法和trigger()方法,这是从国内作者<<jquery权威指南》一书中看到不错的介绍 
 
 
1） one方法 
    one方法的功能是让所选定的元素绑定一个仅触发一次的处理函数，格式为 
   one(type,${data},fn) 
&nb
    
                                
    • 
                                
  • 拿工资不仅仅是让你写代码的
                                    lampcy
工作面试咨询
                                    
    这是我对团队每个新进员工说的第一件事情。这句话的意思是，我并不关心你是如何快速完成任务的，哪怕代码很差，只要它像救生艇通气门一样管用就行。这句话也是我最喜欢的座右铭之一。 
这个说法其实很合理：我们的工作是思考客户提出的问题，然后制定解决方案。思考第一，代码第二，公司请我们的最终目的不是写代码，而是想出解决方案。 
话粗理不粗。 
付你薪水不是让你来思考的，也不是让你来写代码的，你的目的是交付产品
    
                                
    • 
                                
  • 架构师之对象操作----------对象的效率复制和判断是否全为空
                                    nannan408
架构师
                                    
    1.前言。 
  如题。 
2.代码。 
 (1)对象的复制，比spring的beanCopier在大并发下效率要高，利用net.sf.cglib.beans.BeanCopier 
 

Src src=new Src();
BeanCopier beanCopier = BeanCopier.create(Src.class, Des.class, false);
      
    
                                
    • 
                                
  • ajax 被缓存的解决方案
                                    Rainbow702
JavaScriptjqueryAjaxcache缓存
                                    
    使用jquery的ajax来发送请求进行局部刷新画面，各位可能都做过。 
今天碰到一个奇怪的现象，就是，同一个ajax请求，在chrome中，不论发送多少次，都可以发送至服务器端，而不会被缓存。但是，换成在IE下的时候，发现，同一个ajax请求，会发生被缓存的情况，只有第一次才会被发送至服务器端，之后的不会再被发送。郁闷。 
解决方法如下： 
① 直接使用 JQuery提供的 “cache”参数，
    
                                
    • 
                                
  • 修改date.toLocaleString()的警告
                                    tntxia
String
                                    
      
我们在写程序的时候，经常要查看时间，所以我们经常会用到date.toLocaleString()，但是date.toLocaleString()是一个过时 的API，代替的方法如下： 
  
package com.tntxia.htmlmaker.util;

import java.text.SimpleDateFormat;
import java.util.
    
                                
    • 
                                
  • 项目完成后的小总结
                                    xiaomiya
js总结项目
                                    
    项目完成了，突然想做个总结但是有点无从下手了。 
做之前对于客户端给的接口很模式。然而定义好了格式要求就如此的愉快了。 
先说说项目主要实现的功能吧 
1，按键精灵 
2，获取行情数据 
3，各种input输入条件判断 
4，发送数据（有json格式和string格式） 
5，获取预警条件列表和预警结果列表， 
6，排序， 
7，预警结果分页获取 
8，导出文件（excel，text等） 
9，修
    
                                
    •