xuduker
xuduker

Rxjava源码解析

前言

Rxjava可能是现在最流行的异步请求框架了。经常可以听到各种关于他的话题，具体有多好用我原来还真不知道，因为公司里面根本不用！！！。用到异步的时候直接自己手撸一个线程池就好了，如果涉及到切换线程的时候比如到主线程，直接handler。用习惯了还是有点小骄傲的，唯手顺耳。哎，还是too yanger too simple啊。直到详细了解了Rxjava，并自己敲了几个demo后，才知道tmd之前自己是多么的。。。。最重要的是，听说现在面试官都喜欢问这个，那没办法了，得好好的分析下了。


看之前注意一下三点：

1.本文前半部分源码分析是基于：

compile 'io.reactivex:rxjava:1.0.14'

2.贴出来分析的是rxjava执行的主要过程，代码都是抽取的主要代码，有些是伪代码。

3.本文分析中，旧的被观察者一般指当前生成的新的被观察者的上层被观察者。旧的观察者指的是当前生成的新的观察者的下层观察者。


几个概念

分析源码有几个对象得想搞清楚，不然，那几个对象自己读着读着就把自己绕晕了。文中有的地方直接使用中文了，英文自己绕的也晕。

观察者：Observer Subscriber    

被观察者：Observable

订阅关系：subscribe


源码分析

分析源码的时候我喜欢根据使用方式去一步一步的分析。一个简单的Rxjava实现：

        //被观察者对象
        Observable observable = Observable.create(new Observable.OnSubscribe() {
            @Override
            public void call(Subservber subservber) {
            }
        });
        //观察者对象
        Subservber subservber = new Subservber() {
            @Override
            public void onNext(Integer integer) {
            }
            @Override
            public void onError(Throwable t) {
            }
            @Override
            public void onCompleted() {
            }
        };
        //被观察者订阅观察者
        observable.subscribe(subservber);

创建被观察者对象和观察者对象然后 使用被观察者对象订阅观察者对象。

首先创建被观察者对象我们需要知道被观察者对象在这个例子里面用到的有啥，一个OnSubscribe 对象，掉了自己的create方法创建的，带着这些问题源码里面找下，去掉无用的代码后：

public class Observable {
    final OnSubscribe onSubscribe;  
    protected Observable(OnSubscribe f) {
        this.onSubscribe = f;
    }
    public final static  Observable create(OnSubscribe f) {
        return new Observable(f);
    }
    public interface OnSubscribe extends Action1> {
        // cover for generics insanity
    }}
public interface Action1 extends Action {
    void call(T t);
}

        可以发现，OnSubscribe是被观察者对象Observable内部的一个接口，这个接口继承自Action1。这个接口里面有一个call方法，有点熟悉哦，就是我们实例化后传入内部类里面的call方法。被观察者对象内部会持有一个OnSubscribe对象的引用，这个对象是在被观察者对象创建的时候传入的。也就是说，一个被观察者对象就和一个OnSubscribe对应。OnSubscribe的call方法参数也比较特殊，是一个Subscriber对象，泛型 T 对应的是Subscribe。

    接下来是观察者对象的创建，首先了解下观察者对象。Rxjava有俩个，一开始的时候我们就说过，一个是Observer,另一个是Subscriber，他们有啥区别了？先贴下相关代码：

public interface Observer {
    void onCompleted();
    void onError(Throwable e);
    void onNext(T t);
}
public abstract class Subscriber implements Observer {
    public void onStart() {
        // do nothing by default
    }
 }

可以发现，Observer是一个接口，里面只有三个方法。而Subscriber是一个抽象类，实现了Observer，并添加了个onStart方法。

接下来就是订阅方法了，执行了这个方法后，整个系统就开始执行，这像是一个钥匙一般。还是先贴出相关代码：

    public final Subscription subscribe(final Observer observer) {
        if (observer instanceof Subscriber) {
            return subscribe((Subscriber)observer);
        }
        return subscribe(new Subscriber() {
            @Override
            public void onCompleted() {
                observer.onCompleted();
            }
            @Override
            public void onError(Throwable e) {
                observer.onError(e);
            }
            @Override
            public void onNext(T t) {
                observer.onNext(t);
            }
        });
    }

subscribe会先判断是否为Subscriber对象，如果是就直接调用重载方法，如果不是会新建一个Subscriber然后在这个Subsciber对象对应的回调方法里面调用自己的，将触发的事件传递下去。而重载的subscribe最终走到了这里：

 private static  Subscription subscribe(Subscriber subscriber, Observable observable) {
        // new Subscriber so onStart it
        subscriber.onStart();
        onSubscribe.call(subscriber);
  }

上文说过一个Observable对象内部有一个OnSubscribe，这样Observable通过onSubscribe将他和Subscriber联系起来，也就是将被观察者和观察者进行了绑定。我们在call方法里面调用onNext这些方法的时候，实际上是调用的是观察者对象Subscriber的方法。可以看到这个方法里面会先执行subscriber的onStart方法。也就是说，在哪个线程执行的subscribe,这个onStart方法就会在哪个`线程执行。然后使用onSubscribe执行call方法，参数传观察者对象。call的方法执行，整个系统就运行开始，我们在call方法里面设置的观察者的回调也会开始执行。其实OnSubscribe(被观察者)的call方法里面的Subscriber(观察者)就是方法subscribe(订阅)里面的Subscriber(观察者)，这点对后面的内容很重要，一定要记得。


操作符map

Rxjava一个强大的地方就是支持map操作，就是可以将一个对象变为另一个对象。首先看下map需要的参数Func1的源码：

public interface Func1 extends Function {
    R call(T t);
}

Func1里面只有一个call方法。这个call方法的作用是将 T 类型 转换成 R 类型。也就是map的作用，将一个对象变为另一个对象。具体怎么做了？跟着源码向下走：

 public final  Observable map(Func1 func) {
        return lift(new OperatorMap(func));
    }

map方法里面会执行一个lift方法，参数为OperatorMap。而这个OperatorMap实例化的时候需要func1作为参数，这个就是转换的关键，我们后边再详说这个。然后lift方法先不看，这个OperatorMap是个啥了？

public final class OperatorMap implements Operator {
    private final Func1 transformer;
    public OperatorMap(Func1 transformer) {
        this.transformer = transformer;
    }
    @Override
    public Subscriber call(final Subscriber o) {
        return new Subscriber(o) {
            @Override
            public void onCompleted() {
                o.onCompleted();
            }
            @Override
            public void onError(Throwable e) {
                o.onError(e);
            }
            @Override
            public void onNext(T t) {
                o.onNext(transformer.call(t));
      }};}}

 public interface Operator extends Func1, Subscriber> {
        // cover for generics insanity
    }

可以看到，OperatorMap 实现了Operator。Operator继承自Func1，只不过Func1的俩个参数是俩个观察者Subscriber对象。也就是说，他也有call方法，只不过call方法会将一个Subscriber作为参数，然后返回值为另一个Subscriber对象。回到OperatorMap的call方法里面，我们看到他新建了一个观察者对象，然后在对应的回调方法里面调用了方法参数里面的观察者对象o的对应的回调，做到了一个回调的传递。也就是新的观察者对象会将对应的事件传递回o这个旧的观察者对象里面去。重点看下回调的onNext方法，这个方法在调用o的onNext的时候回西安调用transformer，这个对象是创建OperatorMap的时候传入的Func1，然后通过他的call做的转换。我们在使用map的时候要在Func1的call方法里面自己实现转换的过程。这个也是Rxjava的优点，将变化用接口隔离。

然后我们看下lift方法的实现：

    public final  Observable lift(final Operator operator) {
        return new Observable(new OnSubscribe() {
            @Override
            public void call(Subscriber oldSubscriber) {
                    Subscriber newSubscriber= operator.call(oldSubscriber);
                    newSubscriber.onStart();
                    onSubscribe.call(newSubscriber);}}});}

lift方法会先返回一个新建的被观察者Observable对象，然后在其call方法里面使用opertor的call方法，参数为观察者对象oldSubscriber，返回值为一个观察者对象newSubscriber。在上面的分析的时候我们看到：

lift(new OperatorMap(func))

所以，这个Operator具体实例化的是OperatorMap对象。刚刚我们分析了，OperatorMap对象的call方法会新建一个观察者Subscriber对象返回，并在新的观察者对象的事件传递回旧的观察者对象。然后new调用他的onStart方法，然后使用lift方法所在的被观察者对象Observable的onSubscribe去调用call，参数为newSubscriber。

Rxjava源码解析_第1张图片

        好了整个过程分析完了，我们将这个完整的流程串一下。map会新生成一个被观察者对象和一个观察者对象，然后新的被观察者对线订阅旧的观察者对象(subscribe方法)，旧的被观察者对象订阅新的观察者对象(onSubscribe.call(newSubscriber))。也就是新的被观察者会执行call，然后参数是旧的观察者(subscribe方法)。在新的被观察者的call方法里面调用旧观察者的onSubscribe.call，实现了从底层往上传递call的调用。然后在旧观察者call方法里，新观察者对象(new)的对应回调里面调用旧的观察者对象(old)的回调，向下去传递回调方法。在onNext在传递的时候要通过Func1的call转换下类型。其本质是在旧的被观察者和旧的观察者之间接入了个新的被观察者和新的观察者来做的转换。

如果为了理解这个过程我们可以简化为如下代码：

    public  Observable map(final Func func) {
        return create(new OnSubscribe() {  //返回了新的被观察者去订阅旧的观察者(他去执行subscribe方法)
            @Override
            public void call(final Subservber old) {//旧的观察者对象
                //onSubscribe代表着旧的被观察者
                onSubscribe.call(new Subservber() { //我们new了新的观察者出来
                    @Override
                    public void onNext(T t) {
                        old.onNext(func.call(t));  //在传递回调的同时通过func的call进行转换
                    }
                    @Override
                    public void onError(Throwable t) {
                        old.onError(t);   //新的观察者会调用旧的观察者对象的方法
                    }
                    @Override
                    public void onCompleted() {
                        old.onCompleted();
                    }
                });}); }

线程调度

这部分源码使用的是：

compile 'com.squareup.retrofit2:adapter-rxjava:2.1.0'
因为1.0的源码看晕了 T.T

        rxjava线程调度也是非常强大的功能。我们可以指定Observable执行的线程和Subscribe执行的线程。在一些场景下非常有用。比如我们经常做的，异步加载数据，然后去显示在控件里面，加载是在子线程里面做的，显示是ui线程。原来我们的实现一般都是AsyncTask + handler结合使用。在Rxjava里面直接指定俩个调度器就行了，但是rxjava内部是怎么去做的呢？我们先看Scheduler然后在看subscribeOn 和observeOn。

Scheduler
public abstract class Scheduler {
    public abstract Worker createWorker();
    public abstract static class Worker implements Subscription {  //真正做事的是Worker
        public abstract Subscription schedule(Action0 action);  //主要的执行方法
        public abstract Subscription schedule(final Action0 action, final long delayTime, final TimeUnit unit);
   }}

        scheduler是一个抽象方法，里面有个内部类Worker。其实线程调度是由这个Worker方法完成的，这个类有schedule方法，这个是调度器执行的方法，他的参数有Action0，这个类有个方法call。我们具体的看一个scheduler实现类：

NewThreadScheduler 

public final class NewThreadScheduler extends Scheduler {
    private final ThreadFactory threadFactory;

    public NewThreadScheduler(ThreadFactory threadFactory) {
        this.threadFactory = threadFactory;
    }
    @Override
    public Worker createWorker() {
        return new NewThreadWorker(threadFactory);  //创建newThreadWorker
    }
}

        我们发现他主要是新建了一个NewThreadWorke，哪newThreadWorke是什么呢？

public class NewThreadWorker extends Scheduler.Worker implements Subscription {
    private final ScheduledExecutorService executor;
    /* package */
    public NewThreadWorker(ThreadFactory threadFactory) {
        ScheduledExecutorService exec = Executors.newScheduledThreadPool(1, threadFactory);  //新建一个线程池
        executor = exec;
    }
    @Override
    public Subscription schedule(final Action0 action) {
        return schedule(action, 0, null);
    }
    @Override
    public Subscription schedule(final Action0 action, long delayTime, TimeUnit unit) {
        return scheduleActual(action, delayTime, unit);
    }
    public ScheduledAction scheduleActual(final Action0 action, long delayTime, TimeUnit unit) {
        Action0 decoratedAction = schedulersHook.onSchedule(action);  //直接返回了action0
        ScheduledAction run = new ScheduledAction(decoratedAction);  //传入了action 返回了一个runnable的实现类
        Future f;
        if (delayTime <= 0) {
            f = executor.submit(run);   //让线程池执行这个runnable
        } else {
            f = executor.schedule(run, delayTime, unit);  //有延时的时候执行这个
        }
        run.add(f);
        return run;
    }
}

        在NewThreadWorker的构造函数里面创建了一个线程池对象。他的schedule方法最后都是执行的scheduleActual方法。这个方法里面会使用Action0对象，Action0类只有一个call方法。然后，使用这个这个action0对象生成一个ScheduledAction对象，这个对象实现了Runnable。然后在使用早已创建好的线程池对象executor去执行他。我们来看看ScheduledAction对象内部做了什么吧。

public final class ScheduledAction extends AtomicReference implements Runnable, Subscription {
    final Action0 action;
    public ScheduledAction(Action0 action) {
        this.action = action;
    }
    @Override
    public void run() {
        action.call();  //run方法里面执行了actioin的call方法
    }
}

        我们可以看到，他是Runnable的子类，然后在自己的run方法里面会执行action的call，所以action对象的call是运行在设置的线程里面的。


        我们把整个newThreadScheduler的逻辑顺一遍。newThreadScheduler类里面主要是新建了一个NewThreadWorker去干活。NewThreadWorker里面有一个线程池对象，然后他的scheduleActual方法里面会将一个action0对象的call方法放到线程池里执行。

subscribeOn

        开始subscribeOn的源码分析。首先看下这个方法里面做了什么：

public final Observable subscribeOn(Scheduler scheduler) {
        return create(new OperatorSubscribeOn(this, scheduler));
}

        新建了一个Observable对象，使用的参数是一个OperatorSubscribeOn对象，这个对象应该是OnSubscribe的子类。创建的时候会将当前的被观察者对象Observable和设置的调度器传进去。我们来看下OperatorSubscribeOn的源码：


public final class OperatorSubscribeOn implements Observable.OnSubscribe {
    final Scheduler scheduler;  //调度器对象
    final Observable source;  //原被观察者对象
    public OperatorSubscribeOn(Observable source, Scheduler scheduler) {
        this.scheduler = scheduler;
        this.source = source;
    }
    @Override
    public void call(final Subscriber subscriber) {
        final Scheduler.Worker inner = scheduler.createWorker();  //拿到调度器干活的Worker对象
        inner.schedule(new Action0() {   //调用worker的schedule方法，方法是action0
            @Override
            public void call() {        //这个方法运行在我们设置的调度器的线程中，详情看NewThreadWorker分析。
                Subscriber s = new Subscriber(subscriber) {
                    @Override
                    public void onNext(T t) {
                        subscriber.onNext(t);   //回调的传递
                    }
                    @Override
                    public void onError(Throwable e) {
                        subscriber.onError(e);
                    }
                    @Override
                    public void onCompleted() {
                        subscriber.onCompleted();
                    }
                };
                source.unsafeSubscribe(s);  //原被观察者对象订阅了新的观察者对象
            }});}}

        这个类继承自OnSubscribe，所以他有call方法，并且call方法的Subscriber是他下级的Subscriber。这个类里面有俩个属性，一个是当前被观察者对象，另一个是设置的调度器对象。主要来看下call方法的实现。首先，拿到调度器的worker，然后执行worker的schedule方法，并新建一个action0的对象。通过上面分析NewThreadWorker我们知道了，这个方法的作用就是将action0的call方法放到调度器的线程中去执行。哪action0的call方法里面有啥了？接着往下看，call方法里面会新建一个Subscriber对象，在之前的subscribeOn方法里面新建了一个Observable，记住这俩个对象。接着看，发现新建的观察者对象对应的回调方法里面都会调用参数里面的观察者，也就是旧的观察者对应的回调，这就是一个事件的传递。接下来，原被观察者对象source会订阅新观察者对象。

        这块儿涉及到了4个对象，新的被观察者对象，新的观察者对象，原观察者对象，原(旧)观察者对象(就是OnSubscribe的call方法的参数，他是由接下来的代码可能是subscribe方法产生的)。他们的关系是，原观察者对象被新的被观察者对象订阅(比如接下来调用了subscribe)，新的观察者对象的call方法被执行，在这里，原被观察者对象订阅了新的观察者对象。注意这部分的执行在调度器的线程里面，之后的调用都在调度器的线程里面执行了，然后原被观察者对象的call方法执行，在里面调用新观察者对应的回调，比如onNext。然后新观察者的onNext回调会调用原观察者对应的onNext,完成回调过程，下图就是上述过程。

Rxjava源码解析_第2张图片

自己写的简化后的代码：

   public Observable subscribeOn(final Scheduler scheduler){
        return create(new onSubscribe() {   //创建新的被观察者对象
            @Override
            public void call(final Subscriber subscriber) {
                Scheduler.Worker worker = scheduler.createWorker();  //拿到调度器的worker
                worker.schedule(new Runnable() {                      //worker执行schedule方法，这里我们直接放runnable，让线程池去执行
                    @Override
                    public void run() {
                        Subscriber s = new Subscriber(){        //新的观察者对象
                            @Override
                            public void onNext(T t) {
                                subscriber.onNext(t);                   //新旧观察者传递事件
                            }
                            @Override
                            public void onError(Throwable t) {
                                subscriber.onError(t);
                            }
                            @Override
                            public void onCompleted() {
                                subscriber.onCompleted();
                            }
                        };
                        onSubscribe.call(s);                            //在新的被观察者对象call里调用原被观察者对象call,完成call调用。并且调用过程再线程里面执行
                    }
                });
            }
        });
    }

observeOn

observeOn的源码比较复杂，在我们设置了observeOn后会走到这里：

   public final Observable observeOn(Scheduler scheduler, boolean delayError, int bufferSize) {
        return lift(new OperatorObserveOn(scheduler, delayError, bufferSize));
    }

        发现其最终是借助lift方法实现的。在上面我们已经分析了lift方法，其本质就是生成了一个新的被观察者和旧的观察者对象，然后和旧的被观察者和新的观察者相互订阅。并且lift方法的参数是一个Operator对象，他有call方法，这个方法会接收旧的观察者对象生成新观察者对象，并传递对应的回调事件。

了解了lift后，接下来看看OperatorObserveOn的实现：

public final class OperatorObserveOn implements Operator {

    private final Scheduler scheduler;
    private final boolean delayError;
    private final int bufferSize;

    public OperatorObserveOn(Scheduler scheduler, boolean delayError) {
        this(scheduler, delayError, RxRingBuffer.SIZE);
    }
    public OperatorObserveOn(Scheduler scheduler, boolean delayError, int bufferSize) {
        this.scheduler = scheduler;
        this.delayError = delayError;
        this.bufferSize = (bufferSize > 0) ? bufferSize : RxRingBuffer.SIZE;
    }

    @Override
    public Subscriber call(Subscriber child) {
        ObserveOnSubscriber parent = new ObserveOnSubscriber(scheduler, child, delayError, bufferSize);  //生成新的Subscriber对象，参数里面包含就的Subscriber对象child
        return parent;
    }

    /** Observe through individual queue per observer. */
    private static final class ObserveOnSubscriber extends Subscriber implements Action0 {      //继承Subscriber 并实现了Action0
        final Subscriber child;
        final Scheduler.Worker recursiveScheduler;
        public ObserveOnSubscriber(Scheduler scheduler, Subscriber child, boolean delayError, int bufferSize) {
            this.child = child;
            this.recursiveScheduler = scheduler.createWorker();   //直接返回调度器的worker对象
        }

        @Override
        public void onNext(final T t) {
            schedule();                 //回调方法都会执行这个方法schedule
        }

        @Override
        public void onCompleted() {
            schedule();
        }

        @Override
        public void onError(final Throwable e) {
            schedule();
        }

        protected void schedule() {
            recursiveScheduler.schedule(this);     //使用worker执行schedule，那么，对应的call就运行在了指定调度器的线程中。
        }
        // only execute this from schedule()
        @Override
        public void call() {
            //这里面的代码都是运行在指定线程中的
            final Subscriber localChild = this.child;   //旧的观察者对象
            for (;;) {
                while (requestAmount != currentEmission) {
                    if (checkTerminated(done, empty, localChild, q)) {
                        return;
                    }
                    localChild.onNext(localOn.getValue(v));  //这里调用了旧的观察者对象的回调方法，就相当于新的观察者对象对应的回调里面会调用旧的观察者的回调
                }
            }
        }

        boolean checkTerminated(boolean done, boolean isEmpty, Subscriber a, Queue q) {
            if (done) {
                if (delayError) {
                    Throwable e = error;
                    if (e != null) {
                        a.onError(e);       //这里调用了旧的观察者对象的回调方法，就相当于新的观察者对象对应的回调里面会调用旧的观察者的回调
                    } else {
                        a.onCompleted();
                    }
                } else {
                    a.onCompleted();
                    return true;
                }
            }
            return false;
        }}} 
  
        可以看到，OperatorObserveOn实现了Operator，所以他有一个call方法，并且会返回新的观察者对象。这个新观察者对象是还实现了action0，所以他也有一个call方法。新观察者并且对应的回调方法都执行了一个方法schedule。这个方法会使用调度器的worker执行schedule，参数是将当前类(实现了action0)。所以当前类的call执行了调度器的线程中，这个方法里面会按照不同的情况(具体实现不去分析)去调用旧的观察者对应的回调。因为执行的发起是在新的观察者的回调中，最终执行的是旧的观察者的回调。所以，做到了将事件传递到新线程中旧的观察者的回调方法里，完成线程的切换。 
  
 
  
        这块儿还有一个注意的，切换的线程里面跑的是回调的传递，而call的传递是在lift方法所在的线程中。
 
  
自己简化后的代码:
 
  
    public Observable observeOn(final Scheduler scheduler){
        return create(new onSubscribe() {
            @Override
            public void call(final Subscriber subscriber) {                                     //新的观察者对象
                final Scheduler.Worker worker = scheduler.createWorker();  //拿到调度器的worker
                onSubscribe.call(new Subscriber() {                      //旧的被观察者对象call新的观察者对象，这个时候还在当前线程中
                    @Override
                    public void onNext(final T o) {
                        worker.schedule(new Runnable() {
                            @Override
                            public void run() {                             //当有事件传递过来的时候，就切换到worker去调用旧的观察者的回调，完成线程切换。但是仅限于回调的传递
                                subscriber.onNext(o);           
                            }
                        });
                    }

                    @Override
                    public void onError(final Throwable t) {
                        worker.schedule(new Runnable() {
                            @Override
                            public void run() {
                                subscriber.onError(t);
                            }
                        });
                    }

                    @Override
                    public void onCompleted() {
                        worker.schedule(new Runnable() {
                            @Override
                            public void run() {
                                subscriber.onCompleted();
                            }
                        });
                    }
                });
            }
        });
    }
 
  
 
  

 
  
 
  
参考：
 
  
一起来造一个RxJava，揭秘RxJava的实现原理
 
  
给 Android 开发者的 RxJava 详解
 
  
 
  

 
  
 
  
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(android开源库学习)

        

            

                
    
                    
  • android系统selinux中添加新属性property
                        辉色投像

                        
    1.定位/android/system/sepolicy/private/property_contexts声明属性开头：persist.charge声明属性类型：u:object_r:system_prop:s0图12.定位到android/system/sepolicy/public/domain.te删除neverallow{domain-init}default_prop:property
    
                    
    • 
                    
  • 2.2.6 通知类控件 Toast、Menu
                        常思行

                        
    本文例程下载：WillFlow_Toast、WillFlowMenu一、什么是Toast？Toast也被叫做吐司，是Android系统提供的一种非常好的提醒方式，在程序中可以使用它将一些短小的信息通知给用户，它有如下两个特点：Toast是没有焦点的Toast显示的时间有限过一定的时间就会自动消失所以一般来讲Toast的使用并不会影响我们的正常操作，并且它通常不会占用太大的屏幕空间，有着良好的用户体
    
                    
    • 
                    
  • mac 备份android 手机通讯录导入iphone,iphone如何导出通讯录（轻松教你iPhone备份通讯录的方法）...
                        weixin_39762838
mac备份android手机通讯录导入iphone
                        
    在日新月异的手机更替中，换手机已经成为一个非常稀松平常的事情，但将旧手机上面的通讯录导入到新手机还是让不少小伙伴为难，本篇将给大家详细讲解这方面的知识：“苹果手机通讯录怎么导入到新手机”及“安卓手机通讯录导入到新手机”的方法。一、苹果手机通讯录导入到新手机常用方法(SIM卡导入)在苹果手机主频幕上找到“设置”，单击进入设置菜单，下拉菜单列表，点击“邮件、通讯录、日历”，然后找到“导入SIM卡通讯录
    
                    
    • 
                    
  • android 更改窗口的层次,浮窗开发之窗口层级
                        Ms.Bu
android更改窗口的层次
                        
    最近在项目中遇到了这样的需求：需要在特定的其他应用之上悬浮自己的UI交互(拖动、输入等复杂的UI交互)，和九游的浮窗类似，不过我们的比九游的体验更好，我们越过了很多授权的限制。浮窗效果很多人都知道如何去实现一个简单的浮窗，但是却很少有人去深入的研究背后的流程机制，由于项目中浮窗交互比较复杂，遇到了些坑查看了很多资料，故总结浮窗涉及到的知识点：窗口层级关系(浮窗是如何“浮”的)？浮窗有哪些限制，如何
    
                    
    • 
                    
  • Android应用性能优化
                        轻口味
Android
                        
    Android手机由于其本身的后台机制和硬件特点，性能上一直被诟病，所以软件开发者对软件本身的性能优化就显得尤为重要；本文将对Android开发过程中性能优化的各个方面做一个回顾与总结。Cache优化ListView缓存：ListView中有一个回收器，Item滑出界面的时候View会回收到这里，需要显示新的Item的时候，就尽量重用回收器里面的View；每次在getView函数中inflate新
    
                    
    • 
                    
  • Android实现监听事件的方法
                        Amy木婉清

                        
    1.通过内部类实现2.通过匿名内部类实现3.通过事件源所在类实现4.通过外部类实现5.布局文件中onclick属性(针对点击事件)1.通过内部类实现代码:privateButtonmBtnEvent;//oncreate中mBtnEvent.setOnClickListener(newOnClick());//内部类实现监听classOnClickimplementsView.OnClickLis
    
                    
    • 
                    
  • 高级UI<第二十四篇>：Android中用到的矩阵常识
                        NoBugException

                        
    （1）定义在数学中，矩阵（Matrix）是一个按照长方阵列排列的复数或实数集合。由m×n个数aij排成的m行n列的数表称为m行n列的矩阵，简称m×n矩阵。记作：图片.png这m×n个数称为矩阵A的元素，简称为元，数aij位于矩阵A的第i行第j列，称为矩阵A的(i,j)元，以数aij为(i,j)元的矩阵可记为(aij)或(aij)m×n，m×n矩阵A也记作Amn。元素是实数的矩阵称为实矩阵，元素是复
    
                    
    • 
                    
  • RK3229_Android9.0_Box 4G模块EC200A调试
                        suifen_
网络
                        
    0、kernel修改这部分完全可以参考Linux的移植：RK3588EC200A-CN【4G模块】调试_rkec200a-cn-CSDN博客1、修改device/rockchip/rk322xdiff--gita/device.mkb/device.mkindexec6bfaa..e7c32d1100755---a/device.mk+++b/device.mk@@-105,6+105,8@@en
    
                    
    • 
                    
  • kt文件和java文件_Java与Kotlin之间怎样进行互操作
                        铭空间
kt文件和java文件
                        
    Java与Kotlin之间怎样进行互操作发布时间：2021-02-0210:50:43来源：亿速云阅读：98作者：小新这篇文章主要介绍了Java与Kotlin之间怎样进行互操作，具有一定借鉴价值，感兴趣的朋友可以参考下，希望大家阅读完这篇文章之后大有收获，下面让小编带着大家一起了解一下。前言目前kotlin是谷歌首推的开发Android的语言，但由于历史原因，我们绝大部分项目依旧还是以Java为主
    
                    
    • 
                    
  • Android shell 常用 debug 命令
                        晨春计
Audiodebugandroidlinux
                        
    目录1、查看版本2、am命令3、pm命令4、dumpsys命令5、sed命令6、log定位查看APK进程号7、log定位使用场景1、查看版本1.1、Android串口终端执行getpropro.build.version.release#获取Android版本uname-a#查看linux内核版本信息uname-r#单独查看内核版本1.2、linux服务器执行lsb_release-a#查看Lin
    
                    
    • 
                    
  • 2024年最全Flutter如何和Native通信-Android视角，Electron开发Android界面
                        2401_84544531
程序员android面试学习
                        
    总结【Android详细知识点思维脑图（技能树）】其实Android开发的知识点就那么多，面试问来问去还是那么点东西。所以面试没有其他的诀窍，只看你对这些知识点准备的充分程度。so，出去面试时先看看自己复习到了哪个阶段就好。虽然Android没有前几年火热了，已经过去了会四大组件就能找到高薪职位的时代了。这只能说明Android中级以下的岗位饱和了，现在高级工程师还是比较缺少的，很多高级职位给的薪
    
                    
    • 
                    
  • 分享一个基于python的电子书数据采集与可视化分析 hadoop电子书数据分析与推荐系统 spark大数据毕设项目（源码、调试、LW、开题、PPT)
                        计算机源码社
Python项目大数据大数据pythonhadoop计算机毕业设计选题计算机毕业设计源码数据分析spark毕设
                        
    作者：计算机源码社个人简介：本人八年开发经验，擅长Java、Python、PHP、.NET、Node.js、Android、微信小程序、爬虫、大数据、机器学习等，大家有这一块的问题可以一起交流！学习资料、程序开发、技术解答、文档报告如需要源码，可以扫取文章下方二维码联系咨询Java项目微信小程序项目Android项目Python项目PHP项目ASP.NET项目Node.js项目选题推荐项目实战|p
    
                    
    • 
                    
  • android ndk 开发jni调用对象方法，数组参数
                        wulongkou
开发问题安卓的事ndkandroidstudiojni
                        
    一、JNI和NDK关系JNI是Java语言提供的Java和C/C++相互沟通的机制，Java可以通过JNI调用本地的C/C++代码，本地的C/C++的代码也可以调用java代码。JNI是本地编程接口，Java和C/C++互相通过的接口。Java通过C/C++使用本地的代码的一个关键性原因在于C/C++代码的高效性。NDK是一系列工具的集合。它提供了一系列的工具，帮助开发者快速开发C（或C++）的动
    
                    
    • 
                    
  • Android jni中数组参数的传递方式
                        lokeyme
Andriodandroid开发JNINDKjavac语言
                        
    1、背景今天调试了一下Androidjni关于Java中调用C代码的程序，发现我的数组参数传递方式不对，导致值传递不正确，我的方法是：C代码，入口函数#include#includejintJava_sony_MedicalRecordDemo_MainActivity_decryptionSuccess(JNIEnv*env,jobjectthiz,jintAttr[]){returnAttr[
    
                    
    • 
                    
  • 1-1.Jetpack 之 Navigation 简单编码模板
                        我命由我12345
Android-Jetpack简化编程javajava-eeandroid-studioandroidstudio安卓androidjetpack
                        
    一、Navigation1、Navigation概述Navigation是Jetpack中的一个重要成员，它主要是结合导航图（NavigationGraph）来控制和简化Fragment之间的导航，即往哪里走，该怎么走2、Navigate引入在模块级build.gradle中引入相关依赖implementation'androidx.navigation:navigation-fragment:2
    
                    
    • 
                    
  • Android JetPack架构——结合记事本Demo一篇打通对Sqlite的增删改查结合常用jetpack架构应用
                        erhtre
程序员androidjetpack架构sqlite
                        
    为什么要用Jetpack?========================================================================关于为什么要用Jetpack，我参考了许多的博客和官方文档，开阔了我对Android生态圈的理解和认识，在Jetpack推出前出现的许许多多强大的第三方框架与语言，典型代表无疑是强大的RxJava在Jetpack仍然有许多粉丝在一
    
                    
    • 
                    
  • Android干净架构MVI模板使用指南
                        井美婵Toby

                        
    Android干净架构MVI模板使用指南android-clean-architecture-mvi-boilerplateAforkofourcleanarchitectureboilerplateusingtheModel-View-Intentpattern项目地址:https://gitcode.com/gh_mirrors/an/android-clean-architecture-mv
    
                    
    • 
                    
  • ⭐Unity 安卓环境中正确地读取和处理 XML 文件
                        惊鸿醉
Unityunityandroidxml
                        
    写了一个选择题Demo，电脑包和编辑器内无问题，但是打包安卓手机之后题目无法正常使用，想到的是安卓环境中正确地读取文件的问题改进方案：1.由于XmlDocument.Load方法在Android上的路径问题（由于文件位于APK内部，无法像在文件系统中那样直接访问），需要先使用UnityWebRequest来异步加载文件内容，然后再解析XML。2.异步处理：修改你的代码，以支持异步文件加载和处理，这
    
                    
    • 
                    
  • 《Android进阶之光》读书笔记
                        soleil雪寂
读书笔记#Android进阶之光
                        
    文章目录第1章Android新特性1.1.Android5.0新特性1.2.RecyclerView1.1.4.3种Notification1.1.5.Toolbar与Palette1.1.6.Palette1.2.Android6.0新特性1.2.2.运行时权限机制1.3.Android7.0新特性第2章MaterialDesign2.2.DesignSupportLibrary常用控件详解第3
    
                    
    • 
                    
  • 《Android进阶之光》— Android 书籍
                        王睿丶
Android永无止境《Android进阶之光》Android书籍Androidphoenix移动开发
                        
    文章目录第1章Android新特性1第2章MaterialDesign48第3章View体系与自定义View87第4章多线程编程165第5章网络编程与网络框架204第6章设计模式271第7章事件总线308第8章函数响应式编程333第9章注解与依赖注入框架382第10章应用架构设计422第11章系统架构与MediaPlayer框架460出版年:2017-7简介：《Android进阶之光》是一本And
    
                    
    • 
                    
  • 《android进阶之光》——多线程编程（上）
                        TAING要一直努力
读书笔记
                        
    今天了解了下多线程编程，知识点如下：进程与线程：进程是什么？线程是什么？进程可以看作是程序的实体，是线程的容器，是受操作系统管理的基本运行单元，例如exe文件就是一个进程。线程是进程运行的一些子任务，是操作系统调度的最小单元，各线程拥有自己的计数器，堆栈，局部变量等，也可以访问线程间共享的内存。线程的状态有哪些？新创建，可运行，等待，超时等待，阻塞，终止怎么创建一个线程？-三种方法第一种，MyTr
    
                    
    • 
                    
  • android进阶之光！Android面试必备的集合源码详解，系列篇
                        程序员Sunbu
程序员Android
                        
    前言面试：如果不准备充分的面试，完全是浪费时间，更是对自己的不负责。文末会给大家分享下我整理的Android面试专题及答案其中大部分都是大企业面试常问的面试题，可以对照这查漏补缺，当然了，这里所列的肯定不可能覆盖全部方式，不过对大家找工作肯定是有帮助！本月飞机到达上海，到今天第6天了，四家大公司华为，小米，映客，抖音，还有二家中小型公司。有几家已经面了几轮，下周还要面，挂了几家，不过目前已经选择了
    
                    
    • 
                    
  • Android-悬浮窗功能的实现（附Java、KT实现源码）(1)
                        egrhef
程序员androidjava开发语言
                        
    //获取服务的操作对象valbinder=serviceasFloatWinfowServices.MyBinderbinder.service}overridefunonServiceDisconnected(name:ComponentName){}}overridefunonActivityResult(requestCode:Int,resultCode:Int,data:Intent){
    
                    
    • 
                    
  • Visual Studio中的Android模拟器使用详解
                        wurui8
androidandroidstudioandroidandroid应用
                        
    关注微信号：javalearns随时随地学Java或扫一扫随时随地学JavaMicrosoft本周发布了VisualStudio2015预览版,里面包含Android开发工具.安装的时候,如果选Android开发,VisualStudio会把调试Android应用程序用的VisualStudio模拟器也装上.在介绍这个新模拟器之前,我们先来聊一聊,为什么需要一个新的Android模拟器–当然,你也
    
                    
    • 
                    
  • Unity 热更 之 【HybirdCLR】+【YooAsset】 [安卓 Android端] [代码 + 资源热更] 功能的 简单实现演示
                        仙魁XAN
Unity进阶unityHybirdCLRYooAssetHotUpdate热更新
                        
    Unity热更之【HybirdCLR】+【YooAsset】[安卓Android端][代码+资源热更]功能的简单实现演示目录Unity热更之【HybirdCLR】+【YooAsset】[安卓Android端][代码+资源热更]功能的简单实现演示一、简单介绍二、HybridCLR三、YooAsset四、HybirdCLR引入工程五、YooAsset引入工程六、Python服务器简单构建七、Hybir
    
                    
    • 
                    
  • Android 用线程池实现一个简单的任务队列(Kotlin)
                        深海呐
Android#Android进阶#Kotlinandroidkotlin线程池延时任务队列线程池延时任务
                        
    关于线程池,Kotlin和java的使用方式一样在Android中,很多人喜欢用Handler的postDelayed()去实现延时任务.要使用postDelayed(),去实现延时任务队列,就不可避免要使用递归.但是这样做,代码的简洁性,和书写的简易,就远不如使用线程池.使用线程池的简单程度:privatevalmThreadPool=Executors.newSingleThreadSched
    
                    
    • 
                    
  • （小白入门）Windows环境下搭建React Native Android开发环境
                        码农老黑
前端ReactNative移动开发Androidstudio
                        
    ReactNative(简称RN)是Facebook于2015年4月开源的跨平台移动应用开发框架，是Facebook早先开源的UI框架React在原生移动应用平台的衍生产物，目前支持iOS和Android两大平台。RN的环境搭建在RN的中文社区有所介绍，但是对于小白来说还是有些太过简略了。RN中文社区详见参考，本文不涉及的问题也许在其中能够有所解答。ReactNative思想底层引擎是JavaSc
    
                    
    • 
                    
  • Android Dialog圆角设置无效的问题
                        ly969434341
android
                        
    一，参考AndroidDialog圆角设置无效的问题https://blog.csdn.net/woshi_awei/article/details/99664527Android自定义Dialog实现通用圆角对话框https://cloud.tencent.com/developer/article/1740956二，原因Diallog的默认背景是白色（直角背景），我自定义的Dialog背景也是
    
                    
    • 
                    
  • MultiSnapRecyclerView：让Android RecyclerView的滚动停靠更灵活
                        技术无疆
Androidandroiduiandroidstudioandroid-studiojavaandroidx
                        
    在Android应用开发中，RecyclerView是一个强大且灵活的组件，用于展示大量数据集合。然而，标准的RecyclerView只支持单一的滚动停靠点，这在某些场景下可能不够灵活。为了解决这个问题，TakuSemba开发了一个名为MultiSnapRecyclerView的库，它允许开发者在RecyclerView中实现多个滚动停靠点。文章目录什么是MultiSnapRecyclerView
    
                    
    • 
                    
  • Android界面特效全汇总
                        小飞鹤
Android开发详解android
                        
    （一）Activity页面切换的效果Android2.0之后有了overridePendingTransition（），其中里面两个参数，一个是前一个activity的退出两一个activity的进入，Java代码1.@OverridepublicvoidonCreate(BundlesavedInstanceState){2.super.onCreate(savedInstanceState);
    
                    
    • 
                                
  • 分享100个最新免费的高匿HTTP代理IP
                                    mcj8089
代理IP代理服务器匿名代理免费代理IP最新代理IP
                                    
      
推荐两个代理IP网站： 
  
1. 全网代理IP：http://proxy.goubanjia.com/ 
  
2. 敲代码免费IP：http://ip.qiaodm.com/ 
  
  
120.198.243.130:80,中国/广东省
58.251.78.71:8088,中国/广东省
183.207.228.22:83,中国/
    
                                
    • 
                                
  • mysql高级特性之数据分区
                                    annan211
java数据结构mongodb分区mysql
                                    
    


mysql高级特性
  1 以存储引擎的角度分析，分区表和物理表没有区别。是按照一定的规则将数据分别存储的逻辑设计。器底层是由多个物理字表组成。
  
  2 分区的原理
     分区表由多个相关的底层表实现，这些底层表也是由句柄对象表示，所以我们可以直接访问各个分区。存储引擎管理分区的各个底层
	 表和管理普通表一样(所有底层表都必须使用相同的存储引擎)，分区表的索引只是
    
                                
    • 
                                
  • JS采用正则表达式简单获取URL地址栏参数
                                    chiangfai
js地址栏参数获取
                                    
    GetUrlParam:function GetUrlParam(param){
		var reg = new RegExp("(^|&)"+ param +"=([^&]*)(&|$)");
		var r = window.location.search.substr(1).match(reg);
		if(r!=null
    
                                
    • 
                                
  • 怎样将数据表拷贝到powerdesigner (本地数据库表)
                                    Array_06
powerDesigner
                                    
    ================================================== 
 
1、打开PowerDesigner12，在菜单中按照如下方式进行操作 
file->Reverse Engineer->DataBase 
点击后，弹出 New Physical Data Model 的对话框 
2、在General选项卡中 
Model name:模板名字，自
    
                                
    • 
                                
  • logbackのhelloworld
                                    飞翔的马甲
日志logback
                                    
    一、概述 
 
1.日志是啥？ 
当我是个逗比的时候我是这么理解的：log.debug()代替了system.out.print(); 
当我项目工作时，以为是一堆得.log文件。 
这两天项目发布新版本，比较轻松，决定好好地研究下日志以及logback。 
传送门1：日志的作用与方法： 
http://www.infoq.com/cn/articles/why-and-how-log 
上面的作
    
                                
    • 
                                
  • 新浪微博爬虫模拟登陆
                                    随意而生
新浪微博
                                    
    转载自：http://hi.baidu.com/erliang20088/item/251db4b040b8ce58ba0e1235 
  
  
近来由于毕设需要，重新修改了新浪微博爬虫废了不少劲，希望下边的总结能够帮助后来的同学们。 
     现行版的模拟登陆与以前相比，最大的改动在于cookie获取时候的模拟url的请求
    
                                
    • 
                                
  • synchronized
                                    香水浓
javathread
                                    
        Java语言的关键字，可用来给对象和方法或者代码块加锁，当它锁定一个方法或者一个代码块的时候，同一时刻最多只有一个线程执行这段代码。当两个并发线程访问同一个对象object中的这个加锁同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。然而，当一个线程访问object的一个加锁代码块时，另一个线程仍然
    
                                
    • 
                                
  • maven 简单实用教程
                                    AdyZhang
maven
                                    
    1. Maven介绍  1.1. 简介 java编写的用于构建系统的自动化工具。目前版本是2.0.9，注意maven2和maven1有很大区别，阅读第三方文档时需要区分版本。 1.2. Maven资源 见官方网站；The 5 minute test，官方简易入门文档；Getting Started Tutorial，官方入门文档；Build Coo
    
                                
    • 
                                
  • Android 通过 intent传值获得null
                                    aijuans
android
                                    
    我在通过intent 获得传递兑现过的时候报错，空指针,我是getMap方法进行传值，代码如下        1   2   3   4   5   6   7   8   9      
public 
void 
getMap(View view){       
         
Intent i =
    
                                
    • 
                                
  • apache 做代理 报如下错误：The proxy server received an invalid response from an upstream
                                    baalwolf
response
                                    
    网站配置是apache＋tomcat,tomcat没有报错，apache报错是： 
The proxy server received an invalid response from an upstream server. The proxy server could not handle the request GET /. Reason: Error reading fr
    
                                
    • 
                                
  • Tomcat6 内存和线程配置
                                    BigBird2012
tomcat6
                                    
    1、修改启动时内存参数、并指定JVM时区 （在windows server 2008 下时间少了8个小时） 
在Tomcat上运行j2ee项目代码时，经常会出现内存溢出的情况，解决办法是在系统参数中增加系统参数：  
window下， 在catalina.bat最前面 
  set JAVA_OPTS=-XX:PermSize=64M -XX:MaxPermSize=128m -Xms5
    
                                
    • 
                                
  • Karam与TDD
                                    bijian1013
KaramTDD
                                    
    一.TDD 
        测试驱动开发（Test-Driven Development,TDD）是一种敏捷（AGILE）开发方法论，它把开发流程倒转了过来，在进行代码实现之前，首先保证编写测试用例，从而用测试来驱动开发（而不是把测试作为一项验证工具来使用）。 
        TDD的原则很简单： 
a.只有当某个
    
                                
    • 
                                
  • [Zookeeper学习笔记之七]Zookeeper源代码分析之Zookeeper.States
                                    bit1129
zookeeper
                                    
        public enum States {
        CONNECTING, //Zookeeper服务器不可用，客户端处于尝试链接状态
        ASSOCIATING, //？？？
        CONNECTED, //链接建立，可以与Zookeeper服务器正常通信
        CONNECTEDREADONLY, //处于只读状态的链接状态，只读模式可以在
    
                                
    • 
                                
  • 【Scala十四】Scala核心八：闭包
                                    bit1129
scala
                                    
    Free variable A free variable of an expression is a variable that’s used inside the expression but not defined inside the expression. For instance, in the function literal expression (x: Int) => (x
    
                                
    • 
                                
  • android发送json并解析返回json
                                    ronin47
android
                                    
    package com.http.test; 
 
 
import org.apache.http.HttpResponse; 
import org.apache.http.HttpStatus; 
import org.apache.http.client.HttpClient; 
import org.apache.http.client.methods.HttpGet; 
import 
    
                                
    • 
                                
  • 一份IT实习生的总结
                                    brotherlamp
PHPphp资料php教程php培训php视频
                                    
    今天突然发现在不知不觉中自己已经实习了 3 个月了，现在可能不算是真正意义上的实习吧，因为现在自己才大三，在这边撸代码的同时还要考虑到学校的功课跟期末考试。让我震惊的是，我完全想不到在这 3 个月里我到底学到了什么，这是一件多么悲催的事情啊。同时我对我应该 get 到什么新技能也很迷茫。所以今晚还是总结下把，让自己在接下来的实习生活有更加明确的方向。最后感谢工作室给我们几个人这个机会让我们提前出来
    
                                
    • 
                                
  • 据说是2012年10月人人网校招的一道笔试题-给出一个重物重量为X,另外提供的小砝码重量分别为1，3，9。。。3^N。 将重物放到天平左侧，问在两边如何添加砝码
                                    bylijinnan
java
                                    
    
public class ScalesBalance {

	/**
	 * 题目：
	 * 给出一个重物重量为X,另外提供的小砝码重量分别为1，3，9。。。3^N。 （假设N无限大，但一种重量的砝码只有一个）
	 * 将重物放到天平左侧，问在两边如何添加砝码使两边平衡
	 * 
	 * 分析：
	 * 三进制
	 * 我们约定括号表示里面的数是三进制，例如 47=(1202
    
                                
    • 
                                
  • dom4j最常用最简单的方法
                                    chiangfai
dom4j
                                    
    要使用dom4j读写XML文档,需要先下载dom4j包,dom4j官方网站在 http://www.dom4j.org/目前最新dom4j包下载地址:http://nchc.dl.sourceforge.net/sourceforge/dom4j/dom4j-1.6.1.zip 
解开后有两个包,仅操作XML文档的话把dom4j-1.6.1.jar加入工程就可以了,如果需要使用XPath的话还需要
    
                                
    • 
                                
  • 简单HBase笔记
                                    chenchao051
hbase
                                    
     一、Client-side write buffer 客户端缓存请求   描述：可以缓存客户端的请求，以此来减少RPC的次数，但是缓存只是被存在一个ArrayList中，所以多线程访问时不安全的。   可以使用getWriteBuffer()方法来取得客户端缓存中的数据。 默认关闭。      二、Scan的Caching   描述： next( )方法请求一行就要使用一次RPC,即使
    
                                
    • 
                                
  • mysqldump导出时出现when doing LOCK TABLES
                                    daizj
mysqlmysqdump导数据
                                    
    　　执行　mysqldump -uxxx -pxxx -hxxx -Pxxxx database tablename > tablename.sql　 
导出表时，会报 
 
mysqldump: Got error: 1044: Access denied for user 'xxx'@'xxx' to database 'xxx' when doing LOCK TABLES 
 
解决
    
                                
    • 
                                
  • CSS渲染原理
                                    dcj3sjt126com
Web
                                    
       从事Web前端开发的人都与CSS打交道很多，有的人也许不知道css是怎么去工作的，写出来的css浏览器是怎么样去解析的呢？当这个成为我们提高css水平的一个瓶颈时，是否应该多了解一下呢？   
  
       一、浏览器的发展与CSS      
  
   
    
                                
    • 
                                
  • 《阿甘正传》台词
                                    dcj3sjt126com

                                    
    Part Ⅰ: 
《阿甘正传》Forrest Gump经典中英文对白 
Forrest: Hello! My names Forrest. Forrest Gump. You wanna Chocolate? I could eat about a million and a half othese. My momma always said life was like a box ochocol
    
                                
    • 
                                
  • Java处理JSON
                                    dyy_gusi
json
                                    
    Json在数据传输中很好用，原因是JSON 比 XML 更小、更快，更易解析。 
在Java程序中，如何使用处理JSON，现在有很多工具可以处理，比较流行常用的是google的gson和alibaba的fastjson，具体使用如下： 
1、读取json然后处理 
class ReadJSON
{
    public static void main(String[] args)
    
    
                                
    • 
                                
  • win7下nginx和php的配置
                                    geeksun
nginx
                                    
    1.  安装包准备 
nginx :  从nginx.org下载nginx-1.8.0.zip 
php： 从php.net下载php-5.6.10-Win32-VC11-x64.zip， php是免安装文件。 
RunHiddenConsole: 用于隐藏命令行窗口 
  
2. 配置 
# java用8080端口做应用服务器，nginx反向代理到这个端口即可 
p
    
                                
    • 
                                
  • 基于2.8版本redis配置文件中文解释
                                    hongtoushizi
redis
                                    
    转载自： http://wangwei007.blog.51cto.com/68019/1548167 
       在Redis中直接启动redis-server服务时, 采用的是默认的配置文件。采用redis-server   xxx.conf 这样的方式可以按照指定的配置文件来运行Redis服务。下面是Redis2.8.9的配置文
    
                                
    • 
                                
  • 第五章 常用Lua开发库3-模板渲染
                                    jinnianshilongnian
nginxlua
                                    
    动态web网页开发是Web开发中一个常见的场景，比如像京东商品详情页，其页面逻辑是非常复杂的，需要使用模板技术来实现。而Lua中也有许多模板引擎，如目前我在使用的lua-resty-template，可以渲染很复杂的页面，借助LuaJIT其性能也是可以接受的。 
  
如果学习过JavaEE中的servlet和JSP的话，应该知道JSP模板最终会被翻译成Servlet来执行；而lua-r
    
                                
    • 
                                
  • JZSearch大数据搜索引擎
                                    颠覆者
JavaScript
                                    
    系统简介： 
 
 大数据的特点有四个层面：第一，数据体量巨大。从TB级别，跃升到PB级别；第二，数据类型繁多。网络日志、视频、图片、地理位置信息等等。第三，价值密度低。以视频为例，连续不间断监控过程中，可能有用的数据仅仅有一两秒。第四，处理速度快。最后这一点也是和传统的数据挖掘技术有着本质的不同。业界将其归纳为4个“V”——Volume，Variety，Value，Velocity。大数据搜索引
    
                                
    • 
                                
  • 10招让你成为杰出的Java程序员
                                    pda158
java编程框架
                                    
    如果你是一个热衷于技术的  
Java 程序员， 那么下面的 10 个要点可以让你在众多 Java 开发人员中脱颖而出。   　　 
1. 拥有扎实的基础和深刻理解 OO 原则   　　对于 Java 程序员，深刻理解 Object Oriented Programming（面向对象编程）这一概念是必须的。没有 OOPS 的坚实基础，就领会不了像 Java 这些面向对象编程语言
    
                                
    • 
                                
  • tomcat之oracle连接池配置
                                    小网客
oracle
                                    
    tomcat版本7.0 
配置oracle连接池方式： 
修改tomcat的server.xml配置文件： 
 <GlobalNamingResources>
 
			  <Resource name="utermdatasource" auth="Container"  
 type="javax.sql.DataSou
    
                                
    • 
                                
  • Oracle 分页算法汇总
                                    vipbooks
oraclesql算法.net
                                    
        这是我找到的一些关于Oracle分页的算法，大家那里还有没有其他好的算法没？我们大家一起分享一下！ 
 
 

-- Oracle 分页算法一
select * from (
       select page.*,rownum rn from (select * from help) page 
       -- 20 = (currentPag
    
                                
    •