RobinYeung
RobinYeung

RxJava 原理篇

一、框架思想

  • 观察者模式

    • 观察者自下而上注入被观察者

    • 被观察者自上而下发射事件


      RxJava 原理篇_第1张图片
      观察者模式

  • 装饰器模式

    • 自上而下，被观察者被一层层装饰

    • 自下而上，观察者被一层层装饰


      RxJava 原理篇_第2张图片
      装饰者模式

  • 策略模式

    • 函数式编程

二、最简单的订阅模型

以下是由just方法和subscribe方法组成的一个最简单的订阅模型

Observable
    .just("Hello RxJava")
    .subscribe(new Observer() {
        @Override
        public void onSubscribe(Disposable d) {
        }
        @Override
        public void onNext(String s) {
            Log.d(TAG, s);
        }
        @Override
        public void onError(Throwable e) {
        }
        @Override
        public void onComplete() {
        Log.d(TAG, "Complete");
        }
    });

对于just方法

public static  Observable just(T item) {
    // 参数合法判断，不允许传入空item
    ObjectHelper.requireNonNull(item, "The item is null");
    // hook装饰
    return RxJavaPlugins.onAssembly(
        // 返回真正的ObservableJust对象
        new ObservableJust(item));
}
public static  Observable onAssembly(@NonNull Observable source) {
    Function f = onObservableAssembly;
    if (f != null) {
        // 如果hook方法存在，则调用hook方法
        return apply(f, source);
    }
    return source;
}

public final class ObservableJust extends Observable implements ScalarCallable {
    private final T value;
    public ObservableJust(final T value) {
        // 保存原始的value
        this.value = value;
    }
    
    // 实际的订阅方法的实现
    @Override
    protected void subscribeActual(Observer downStream) {
        // 传入下游和value
        ScalarDisposable sd = new ScalarDisposable(downStream, value);
        // 订阅
        downStream.onSubscribe(sd);
        // Runnable.run()；
        sd.run();
    }
}

public static final class ScalarDisposable extends AtomicInteger implements QueueDisposable, Runnable {
    // 省略很多跟队列使用，线程安全相关的方法
    @Override
    public void run() {
        if (get() == START && compareAndSet(START, ON_NEXT)) {
            downStream.onNext(value);
            if (get() == ON_NEXT) {
                lazySet(ON_COMPLETE);
                downStream.onComplete();
            }
        }
    }
}

对于subscribe方法

public final Disposable subscribe(Consumer onNext, Consumer onError,
        Action onComplete, Consumer onSubscribe) {
    // 参数合法检查
    ObjectHelper.requireNonNull(onNext, "onNext is null");
    ObjectHelper.requireNonNull(onError, "onError is null");
    ObjectHelper.requireNonNull(onComplete, "onComplete is null");
    ObjectHelper.requireNonNull(onSubscribe, "onSubscribe is null");
    // 把4个Lambda表达式合并创建LambdaObserver
    LambdaObserver ls = new LambdaObserver(onNext, onError, onComplete, onSubscribe);
    // 执行订阅
    subscribe(ls);
    // 返回
    return ls;
}
    
@Override
public final void subscribe(Observer downStream) {
    // 检查参数合法性
    ObjectHelper.requireNonNull(downStream, "observer is null");
    try {
        // hook
        downStream = RxJavaPlugins.onSubscribe(this, downStream);
        // hook后再次检查Observer不为null
        ObjectHelper.requireNonNull(downStream, "The RxJavaPlugins.onSubscribe hook returned a null Observer. Please change the handler provided to RxJavaPlugins.setOnObservableSubscribe for invalid null returns. Further reading: https://github.com/ReactiveX/RxJava/wiki/Plugins");
        // 执行实际的subscribe，传入下游Observer
        subscribeActual(downStream);
    } catch (NullPointerException e) { // NOPMD
        throw e;
    } catch (Throwable e) {
        Exceptions.throwIfFatal(e);
        // can't call onError because no way to know if a Disposable has been set or not
        // can't call onSubscribe because the call might have set a Subscription already
        RxJavaPlugins.onError(e);
        NullPointerException npe = new NullPointerException("Actually not, but can't throw other exceptions due to RS");
        npe.initCause(e);
        throw npe;
    }
}

三、操作符的实现

最简单的操作符 map

public final  Observable map(Function mapper) {
    // 检查参数合法性
    ObjectHelper.requireNonNull(mapper, "mapper is null");
    // hook
    return RxJavaPlugins.onAssembly(
        // 返回真正的 ObservableMap，传入了上游引用和mapper方法
        new ObservableMap(this, mapper));
}

ObservableMap等操作符一般继承AbstractObservableWithUpstream，这种Observable持有了上游引用

public final class ObservableMap extends AbstractObservableWithUpstream {
    final Function function;
    public ObservableMap(ObservableSource source, Function function) {
        super(source);
        this.function = function;
    }
    
    @Override
    public void subscribeActual(Observer downStream) {
        // 合并下游和mapper，创建新的Observer：MapObserver
        source.subscribe(new MapObserver(downStream, function));
    }
    
    static final class MapObserver extends BasicFuseableObserver {
        final Function mapper;
        MapObserver(Observer downStream, Function mapper) {
            super(downStream);
            this.mapper = mapper;
        }
        
        // 重新实现onNext
        @Override
        public void onNext(T t) {
            if (done) {
                return;
            }
            if (sourceMode != NONE) {
                downStream.onNext(null);
                return;
            }
            U v;
            try {
                // 检查mapper的输出结果，合法则赋值给
                v = ObjectHelper.requireNonNull(
                    mapper.apply(t), "The mapper function returned a null value.");
            } catch (Throwable ex) {
                fail(ex);
                return;
            }
            // 下游onNext传入经过mapper的结果
            downStream.onNext(v);
        }
    }

对于操作符而言

  • 自上而下
    • 装饰器模式。操作符创建了一个新的 Observable
    • 该 Observable 重写了subscribeActual方法
    • subscribeActual 的实现是让所持有的上游source调用subscribe方法去订阅 被重新装饰的下游
  • 自下而上
    • 装饰器模式。操作符使下游Observer被装饰后形成新的Observer
    • 重写了Observer的几个方法，向下传递经过操作符处理后的数值结果

自定义操作符

// compose()操作符，自上而下，封装Observable
public interface ObservableTransformer {
    ObservableSource apply(Observable upstream);
}
// lift()操作符，自下而上，封装Observer
public interface ObservableOperator {
    Observer apply(@NonNull Observer observer) throws Exception;
}
  • lift
    • 创建并返回新的Observable，即ObservableLift
    • 订阅发生在operator.apply(s)，即得到新的Observable之后
    • 意图是封装一个操作符，类似于create
  • compose
    • 意图是封装一系列操作符，方便复用

四、线程调度

举例 .subscribeOn(AndroidSchedulers.mainThread())

public final Observable subscribeOn(Scheduler scheduler) {
    ObjectHelper.requireNonNull(scheduler, "scheduler is null");
    return RxJavaPlugins.onAssembly(
        // 返回Observable，传入上游this和调度器scheduler
        new ObservableSubscribeOn(this, scheduler));
}
    
public final class ObservableSubscribeOn extends AbstractObservableWithUpstream {
    final Scheduler scheduler;
    public ObservableSubscribeOn(ObservableSource source, Scheduler scheduler) {
        super(source);
        this.scheduler = scheduler;
    }
    @Override
    public void subscribeActual(final Observer downStream) {
        final SubscribeOnObserver parent = new SubscribeOnObserver(downStream);
        // SubscribeOnObserver实现了Disposable，将其传递给下游的onSubscribe
        downStream.onSubscribe(parent);
        // 把source的订阅放在Runnable中，由scheduler调度
        parent.setDisposable(scheduler.scheduleDirect(new Runnable() {
            @Override
            public void run() {
                source.subscribe(parent);
            }
        }));
    }
}

讲解

  • subscribeOn 线程调度即发生在subscribe时
  • subscribeOn 只能生效一次
    • 因为完整的订阅过程是自下而上订阅，数据源发射事件在自上而下传递，所以真正发射事件所在的线程，是有最接近上游的一次subscribeOn来决定的，其他的都会被覆盖
    • 从代码上看，就是经历了n个线程的传递后，把source.subscribe(parent)放在了最上游的那个线程中去发射，如果没有observeOn影响，整个事件流都会在那个线程完成
    • 为什么flatMap能改变subscribeOn的这种特性？因为flatMap等操作符创建了新的Observable，而不是单纯传递上下游

对于调度器 AndroidSchedulers.mainThread()。其实际上是 new HandlerScheduler(new Handler(Looper.getMainLooper()))

从上面看出，实现线程调度的是scheduler.scheduleDirect方法

@Override
public Disposable scheduleDirect(Runnable run, long delay, TimeUnit unit) {
    if (run == null) throw new NullPointerException("run == null");
    if (unit == null) throw new NullPointerException("unit == null");

    run = RxJavaPlugins.onSchedule(run);
    // ScheduledRunnable 实现了Disposable接口
    ScheduledRunnable scheduled = new ScheduledRunnable(handler, run);
    // 大家熟悉的handler.postDelayed
    handler.postDelayed(scheduled, Math.max(0L, unit.toMillis(delay)));
    return scheduled;
}

// 一般的Schedule都是用createWorker().schedule(scheduled, delay, unit)的方式去实现线程调度
// Worker实现相应的disposable接口，便于取消订阅时停止执行尚未执行的Runnable，并装饰相应的hook。
// 这个类的实现比较有点划水，可能因为是主线程，所以不担心泄露
@Override
public Worker createWorker() {
    return new HandlerWorker(handler);
}

private static final class HandlerWorker extends Worker {
    private final Handler handler;
    private volatile boolean disposed;

    HandlerWorker(Handler handler) {
        this.handler = handler;
    }

    @Override
    public Disposable schedule(Runnable run, long delay, TimeUnit unit) {
        if (run == null) throw new NullPointerException("run == null");
        if (unit == null) throw new NullPointerException("unit == null");

        if (disposed) {
            return Disposables.disposed();
        }

        run = RxJavaPlugins.onSchedule(run);

        ScheduledRunnable scheduled = new ScheduledRunnable(handler, run);

        Message message = Message.obtain(handler, scheduled);
        message.obj = this; // Used as token for batch disposal of this worker's runnables.

        handler.sendMessageDelayed(message, Math.max(0L, unit.toMillis(delay)));

        // Re-check disposed state for removing in case we were racing a call to dispose().
        if (disposed) {
            handler.removeCallbacks(scheduled);
            return Disposables.disposed();
        }

        return scheduled;
    }

    @Override
    public void dispose() {
        disposed = true;
        handler.removeCallbacksAndMessages(this /* token */);
    }

    @Override
    public boolean isDisposed() {
        return disposed;
    }
}

举例 .observeOn(AndroidSchedulers.mainThread())

public final Observable observeOn(Scheduler scheduler) {
    return observeOn(scheduler, false, bufferSize());
}
public final Observable observeOn(Scheduler scheduler, boolean delayError, int bufferSize) {
    ObjectHelper.requireNonNull(scheduler, "scheduler is null");
    ObjectHelper.verifyPositive(bufferSize, "bufferSize");
    return RxJavaPlugins.onAssembly(
        new ObservableObserveOn(this, scheduler, delayError, bufferSize));
}
// 以上代码都很熟悉了，暂不赘述

public final class ObservableObserveOn extends AbstractObservableWithUpstream {
    final Scheduler scheduler;
    final boolean delayError;
    final int bufferSize;
    public ObservableObserveOn(ObservableSource source, Scheduler scheduler, boolean delayError, int bufferSize) {
        super(source);
        this.scheduler = scheduler; // 线程调度器
        this.delayError = delayError; // 出现错误是否立刻中断线程
        this.bufferSize = bufferSize;   //缓冲区大小，默认128
    }
    @Override
    protected void subscribeActual(Observer observer) {
        if (scheduler instanceof TrampolineScheduler) {
            // 默认线程则不做线程调度，直接在当前线程中调用
            source.subscribe(observer);
        } else {
            Scheduler.Worker w = scheduler.createWorker();
            source.subscribe(
                // 用Worker、和相关参数装饰observer，得到新的Observer注入上游
                new ObserveOnObserver(observer, w, delayError, bufferSize));
        }
    }
  
  static final class ObserveOnObserver extends BasicIntQueueDisposable implements Observer, Runnable {
    //省略部分代码
    @Override
        public void onSubscribe(Disposable s) {
            if (DisposableHelper.validate(this.s, s)) {
                this.s = s;
                //省略部分代码，创建缓冲队列
                queue = new SpscLinkedArrayQueue(bufferSize);
                actual.onSubscribe(this);
            }
    }
    
    @Override
    public void onNext(T t) {
      if (done) {
        return;
      }
      if (sourceMode != QueueDisposable.ASYNC) {
        queue.offer(t); //上游的数据全部先入队列
      }
      //执行调度
      schedule();
    }
    
    void schedule() {
      if (getAndIncrement() == 0) {
        // 队列如果已经空了，则再次调度
        worker.schedule(this);
      }
    }
    
    @Override
    public void run() {
        // Fused 熔断机制，默认false
        if (outputFused) {
            drainFused();
        } else {
            drainNormal();
        }
    }
    
    //该函数在Runnable所在的线程执行，从缓冲队列里拿出事件，向下游发射
    void drainNormal() {
        int missed = 1;
        final SimpleQueue q = queue;
        final Observer a = actual;
        for (;;) {
            // 如果设置了errorDelay，则不管队列是否为空，发生了错误都会中断发射，并调用observer的onError
            if (checkTerminated(done, q.isEmpty(), a)) {
                return;
            }
            for (;;) {
                boolean d = done;
                T v;
                try {
                    v = q.poll();   //队列中取数据
                } catch (Throwable ex) {
                    Exceptions.throwIfFatal(ex);
                    s.dispose();
                    q.clear();
                    a.onError(ex);
                    worker.dispose();
                    return;
                }
                boolean empty = v == null;
                if (checkTerminated(d, empty, a)) {
                    return;
                }
                if (empty) {
                    break;
                }
                // 向下游发射数据
                a.onNext(v);
            }
            missed = addAndGet(-missed);
            if (missed == 0) {
                break;
            }
        }
    }
  }
}

讲解

  • 订阅发生在调度前，说明线程调度不影响订阅过程
  • ObserveOnObserver持有下游observer和调度器，并实现Runnable接口
  • 订阅时（onSubscribe）会创建一个缓冲队列，当上游数据到来先放在队列，接着在调度线程中取出并发射到下游
  • 由上看observeOn可以多次生效

五、背压

  • 默认策略判断是否触发背压的因素：
    • 同步场景中，有发射数是否超出响应式拉取值 request 决定
    • 异步场景中，由是否超出缓冲池 queue 的承受能力决定。需要下游的request方法拉取queue的数据
    • observeOn允许我们设置缓冲队列的容量大小
    • 在onSubscribe(Subscription s)回调提供的s可以调用request方法来增加拉取数；如果不重写，默认执行s.request(Long.MAX_VALUE)
  • 背压策略
    • ERROR 触发背压直接抛异常 MissingBackpressureException
    • BUFFER: queue无限大，知道OOM
    • DROP: 超载则抛弃之后的数据，不抛异常
    • LATEST：超载后抛弃之后数据，且是专用有一个额外空间保留当前最新一次数据

举例 onBackpressureDrop 方法

public final class FlowableOnBackpressureDrop extends AbstractFlowableWithUpstream implements Consumer {
    final Consumer onDrop;
  
    @Override
    protected void subscribeActual(Subscriber s) {
        this.source.subscribe(new BackpressureDropSubscriber(s, onDrop));
    }
  
    static final class BackpressureDropSubscriber extends AtomicLong implements FlowableSubscriber, Subscription {
      @Override
        public void onNext(T t) {
            if (done) {
                return;
            }
            long r = get();
            if (r != 0L) {
                actual.onNext(t);
                BackpressureHelper.produced(this, 1);
            } else {
                try {
                    onDrop.accept(t);
                } catch (Throwable e) {
                    Exceptions.throwIfFatal(e);
                    cancel();
                    onError(e);
                }
            }
        }
      
      @Override
        public void request(long n) {
            if (SubscriptionHelper.validate(n)) {
                BackpressureHelper.add(this, n);
            }
        }
    }
}

BackpressureDropSubscriber继承了AtomicLong，实现了Subscriber。只有判断自身不为0时才会向下游发射元素，否则将被抛弃。这个数值的计算在BackpressureHelper中计算

// 每执行一次onNext，当前值减一
public static long produced(AtomicLong requested, long n) {
    for (;;) {
        long current = requested.get();
        if (current == Long.MAX_VALUE) {
            return Long.MAX_VALUE;
        }
        long update = current - n;
        if (update < 0L) {
            RxJavaPlugins.onError(new IllegalStateException("More produced than requested: " + update));
            update = 0L;
        }
        if (requested.compareAndSet(current, update)) {
            return update;
        }
    }
}

// request调用时，值会加到当前值上。
public static long add(AtomicLong requested, long n) {
    for (;;) {
        long r = requested.get();
        if (r == Long.MAX_VALUE) {
            return Long.MAX_VALUE;
        }
        long u = addCap(r, n);
        if (requested.compareAndSet(r, u)) {
            return r;
        }
    }
}

这样，就实现了发生背压则抛弃新的值

onBackpressureLatest的实现和前者类似，只是多了一个对象来存储最新一次的值：

final AtomicReference current = new AtomicReference();
@Override
public void onNext(T t) {
     current.lazySet(t);
     drain();
}

六、Subject

Subject 继承Observable，实现Observer。具有自攻自受的特性，相当于是一个中间层

一般Observable观察的对象往往是静态的，如一个常量、一个文件。有确定的开头和结尾

Subject是动态的，监听没有被中断的时候，可以有不确定的事件传来

  • Observable特性
    • 订阅：如果下游可用，则加入到订阅队列中
@Override
public void subscribeActual(Observer t) {
    PublishDisposable ps = new PublishDisposable(t, this);
    t.onSubscribe(ps);
    if (add(ps)) {
        // if cancellation happened while a successful add, the remove() didn't work
        // so we need to do it again
        if (ps.isDisposed()) {
            remove(ps);
        }
    } else {
        Throwable ex = error;
        if (ex != null) {
            t.onError(ex);
        } else {
            t.onComplete();
        }
    }
}

boolean add(PublishDisposable ps) {
    for (;;) {
        PublishDisposable[] a = subscribers.get();
        if (a == TERMINATED) {
            return false;
        }

        int n = a.length;
        @SuppressWarnings("unchecked")
        PublishDisposable[] b = new PublishDisposable[n + 1];
        System.arraycopy(a, 0, b, 0, n);
        b[n] = ps;

        if (subscribers.compareAndSet(a, b)) {
            return true;
        }
    }
}
  • Observer 特性
    • 如果本身可用，切存在可用的观察者，则向下传递事件
// 但举例onNext方法
@Override
public void onNext(T t) {
    if (subscribers.get() == TERMINATED) {
        return;
    }
    if (t == null) {
        onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources."));
        return;
    }
    // 遍历下游观察者队列，并逐个调用onNext
    for (PublishDisposable s : subscribers.get()) {
        s.onNext(t);
    }
}

七、性能问题

.map(x -> x + 1) 和 .flatMap(x -> Observable.just(x + 1))有什么区别
  • map和flatMap的区别
    • map没有创建新的Observable，flatMap创建了新的Observable，相当于创建了新的流
    • map在上游和下游之间仍是线性的。flatMap已经上升了一个阶，即每一个元素进来，都会变成一个新的source，而下游也会变成一个新的observer

循环的静态Observable和动态的Subject之间的区别

void callback(int item) {
    Observable
        .create(emitter -> {
            emitter.onNext(item);
        })
        .map(i -> i + 1)
        .subscribe(i -> Log.d(TAG, "i = " + i));
}

Subject mSubject = PublishSubject.create();

void init() {
    mSuject
        .map(i -> i + 1)
        .subscribe(i -> Log.d(TAG, "i = " + i));
}

void callback(int item) {
    mSuject.onNext(item);
}
  • 循环创建的事件流，所有操作符都涉及了new对象，如果callback被频繁调用，则会产生十分多的临时对象造成内存抖动

八、Rx扩展

RxBinding

final class ViewClickObservable extends Observable {
    private final View view;
    ViewClickObservable(View view) {
        this.view = view;
    }
    @Override protected void subscribeActual(Observer observer) {
        if (!checkMainThread(observer)) {
            return;
        }
        //订阅阶段执行的逻辑，创建listener绑定view
        Listener listener = new Listener(view, observer);
        observer.onSubscribe(listener);
        view.setOnClickListener(listener);
    }
    static final class Listener extends MainThreadDisposable implements OnClickListener {
        private final View view;
        private final Observer observer;
        Listener(View view, Observer observer) {
            this.view = view;
            this.observer = observer;
        }
        @Override public void onClick(View v) {
            if (!isDisposed()) {
                //发生点击时传递事件给下游
                observer.onNext(Notification.INSTANCE);
            }
        }
        @Override protected void onDispose() {
            view.setOnClickListener(null);
        }
    }
}
 
 
RxPermissions
 
 
public  ObservableTransformer ensure(final String... permissions) {
    return new ObservableTransformer() {
        @Override
        public ObservableSource apply(Observable o) {
            return request(o, permissions)
                    // 转换 Observable 为 Observable
                    .buffer(permissions.length)
                    .flatMap(new Function, ObservableSource>() {
                        @Override
                        public ObservableSource apply(List permissions) {
                            if (permissions.isEmpty()) {
                                // Occurs during orientation change, when the subject receives onComplete.
                                // In that case we don't want to propagate that empty list to the
                                // subscriber, only the onComplete.
                                return Observable.empty();
                            }
                            // Return true if all permissions are granted.
                            for (Permission p : permissions) {
                                if (!p.granted) {
                                    return Observable.just(false);
                                }
                            }
                            return Observable.just(true);
                        }
                    });
        }
    };
}

 
 
注：本文为了节省篇幅，对源码进行了一定程度的删减，仅供参考。
 
 
参考文章
 
 
 
  
     
   
  • RxJava github
    •  
   
  • RxAndroid github
    •  
   
  • RxJava2 源码分析
    •  
   
  • RxJava2.x 分析源码,理解操作符FlatMap
    •  
  
 
 
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(RxJava 原理篇)

        

            

                
    
                    
  • Android JetPack架构——结合记事本Demo一篇打通对Sqlite的增删改查结合常用jetpack架构应用
                        erhtre
程序员androidjetpack架构sqlite
                        
    为什么要用Jetpack?========================================================================关于为什么要用Jetpack，我参考了许多的博客和官方文档，开阔了我对Android生态圈的理解和认识，在Jetpack推出前出现的许许多多强大的第三方框架与语言，典型代表无疑是强大的RxJava在Jetpack仍然有许多粉丝在一
    
                    
    • 
                    
  • Rxjava2你应该懂的源码，其实并不难（二）
                        kwbsky

                        
    接上篇继续。一、线程切换observeOnObservable.just("1").subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread()).subscribe(observer)我们知道，当调用observeOn之后，后面执行的代码都将切换到他指定的线程，除非再次调用observeOn切换其他线程。上源码：@Ch
    
                    
    • 
                    
  • Android视频开发进阶-关于视频的那些术语，android软件开发计算器
                        wa32saa
程序员架构移动开发android
                        
    原文出处：jianshu正文说到安卓的视频开发，大多数朋友们都是用着开源的播放器，或者安卓自带的nativemediaplayer，拿来主义居多，我曾经也是。。。最近这半年因为开始着手重构公司的播放器,也开始学习了很多视频音频开发的相关知识，抱着独乐乐不如众乐乐的想法，开始写一些值得分享的东西。这次的连载和之前的RxJava分享一样，会分开不容的章节。第一次我打算分享一下视频开发中常见的一些知识点
    
                    
    • 
                    
  • 2024最新Android大厂面试真题大全（附答案）
                        imtokenmax合约众筹
2024年程序员面试android面试职场和发展
                        
    五、架构设计和设计模式1.谈谈你对Android设计模式的理解2.MVCMVPMVVM原理和区别3.你所知道的设计模式有哪些？4.项目中常用的设计模式5.手写生产者/消费者模式6.写出观察者模式的代码7.适配器模式，装饰者模式，外观模式的异同？8.用到的一些开源框架，介绍一个看过源码的，内部实现过程。9.谈谈对RxJava的理解10.Rxjava发送事件步骤11.RxJava的作用，与平时使用的异
    
                    
    • 
                    
  • zookeeper原理篇-Zookeeper的数据存储与恢复原理
                        逐梦々少年

                        
    前言经过前面的一些文章的学习和了解，我们对Zookeeper有了一定的理解，但是无论是节点持久化，还是启动流程中的数据恢复等，我们都没有详细的去了解内部的数据存储和恢复的机制，本篇文章就开始学习Zookeeper的数据存储相关。内存存储zookeeper刚开始的时候，我们就已经知道其结构就像一个内存数据库一样，按照树的结构，能把节点的路径、节点数据以及ACL和节点的数据存储，其核心就是依靠Data
    
                    
    • 
                    
  • Android从零开始搭建MVVM架构（6）
                        m0_66070459
程序员面试移动开发android
                        
    //加载项目build.gradle的anroid标签下dataBinding{enabled=true}添加相关依赖//okhttp、retrofit、rxjavaimplementation‘com.squareup.okhttp3:okhttp:3.8.0’implementation‘com.squareup.retrofit2:retrofit:2.3.0’implementation‘
    
                    
    • 
                    
  • okhttp，retrofit,rxjava 是如何配合工作的 作用分别是什么
                        追梦的鱼儿
okhttpretrofitrxjava
                        
    目录OkHttp作用基本使用Retrofit作用基本使用RxJava作用优势基本使用三者的配合工作OkHttp、Retrofit和RxJava是Android开发中常用的三种库，它们各自有不同的作用，并且可以很好地配合工作来实现网络请求和响应的处理。OkHttp作用OkHttp是一个高效的HTTP客户端，用于发起网络请求和处理响应。它支持同步和异步请求、连接池、缓存、重定向、超时设置等功能。基本使
    
                    
    • 
                    
  • 内网穿透技术原理篇
                        无聊的一个人啊
pythonjavaphpc#算法mysqljson
                        
    内网穿透技术是实现从外部网络访问内网服务的重要手段，尤其在云计算和物联网快速发展的今天愈发显得重要。以下是几种常见的内网穿透技术实现原理：1.端口映射（PortForwarding）端口映射通常在路由器级别进行配置。通过在路由器上设置将外部某个端口的请求转发到内网某个设备上的特定端口，实现从外网访问内网服务。例如，如果你的家用路由器的公网IP是203.0.113.1，你可以将外部的80端口映射到内
    
                    
    • 
                    
  • Retrofit+Rxjava-以自己的方式重头开始-入门篇
                        MonkeyLei

                        
    之前小萌新直接上项目，然后立马就用上了Rretrofit和Rxjava来做，没有特别去学习，然后直接就干了。看了看别人的用法。后面也根据个人请求数据结果进行了封装，总共封装了两两次，基本实现了通用请求，一个请求方法就搞定所有请求，返回不同的对象或者对象列表MonkeyLei：Android-Retrofit2+Rxjava2之网络通用请求-初步封装-相关关键类MonkeyLei：Android-R
    
                    
    • 
                    
  • SpringBoot原理篇-bean的加载方式
                        Maiko Star
SpringBootsql数据库java
                        
    一、bean的加载方式关于bean的加载方式，spring提供了各种各样的形式。因为spring管理bean整体上来说就是由spring维护对象的生命周期，所以bean的加载可以从大的方面划分成2种形式。已知类并交给spring管理，和已知类名并交给spring管理。有什么区别？一个给.class，一个给类名字符串。内部其实都一样，都是通过spring的BeanDefinition对象初始化spr
    
                    
    • 
                    
  • idea: 基于 http 的双向通信
                        weixin_33939380
开发工具java前端ViewUI
                        
    纯http上的双向通信最近大概看了下rxJava的订阅者模式，然后突发奇想有没有可能用类似的思路实现纯http上的双向通信A是传统的http服务器B是普通的客户端，假设我们能够在B上启动一个简易的httpserver并且有办法实现公网访问然后通过类似事件订阅的方式实现双向通信。例：要实现的功能：B是美团外卖商家端，当有用户下单时，B能够收到推送A是美团服务器，当用户下单时，给B发请求通知B实现思路
    
                    
    • 
                    
  • 全栈笔记_浏览器工作原理篇（浏览器架构）
                        weiweivita
全栈笔记笔记
                        
    浏览器架构用户界面浏览器引擎网络模块浏览器主要由用户界面、浏览器引擎、渲染引擎、JavaScript解释器、网络模块组成，这些组件共同协作，使浏览器能够呈现网页内容、处理用户操作、与服务器通信，并实现丰富的交互功能，共同构成了现代浏览器的核心功能。用户界面提供操作界面，是用户与浏览器进行交互的界面，提供了用户操作浏览器的各种控件和功能按钮，使用户可以方便地导航网页、管理标签、收藏网页、执行浏览器操
    
                    
    • 
                    
  • RxJava2+Retrofit2+RxLifecycle3+OkHttp3网络请求封装（动态演示）
                        2301_82241819
程序员网络php开发语言
                        
    ArrayMapmap=newArrayMap{NbaService.getInstance().getNBAInfo(“6949e822e6844ae6453fca0cf83379d3”).subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread()).compose(this.bindToLifecycle()).s
    
                    
    • 
                    
  • JavaWeb学习——事务管理&AOP&原理篇
                        Ustinian.488
JavaWeb学习数据库
                        
    目录1.事务管理1.1事务回顾--spring事务管理1.2事务进阶--rollbackFor属性1.3事务进阶--propagation属性2.AOP（面向切面编程）2.1AOP基础--快速入门2.2AOP基础--核心概念2.3AOP进阶--通知类型2.4AOP进阶--通知顺序2.5AOP进阶--切入点表达式--execution2.6AOP进阶--切入点表达式[email protected]
    
                    
    • 
                    
  • Android卡顿掉帧问题分析之原理篇
                        Android技术之家
androidjavawebglaclepoll
                        
    当用户抱怨手机在使用过程中存在卡顿问题的时候，会严重影响用户对手机品牌的好感和应用APP的体验，从而导致用户对手机品牌的忠诚度降低或应用APP的装机留存率下降。所以无论是手机设备厂商还是应用APP开发者，又或是Android系统的维护者Google都会对界面卡顿问题非常重视，会将界面的流畅度作为核心性能体验指标进行持续的优化。说到流畅度，本质上就是要解决用户操作手机过程中的界面丢帧问题，本来一秒钟
    
                    
    • 
                    
  • Unity ScrollRect控件，将Content中任意元素定位到viewport中心的方法
                        猪皮香蕉
Unity游戏开发之路游戏开发unityugui
                        
    参考：uguimaxminauchor解释localPosition与anchoredPosition的转化关系UnityUGUI原理篇(三)：RectTransformRectTransform中localPosition与anchoredPosition的区别UGUI在两个UI间坐标转换这个需求是做一个小游戏项目中，需要将玩家退出游戏时的关卡保存，在重新加载的过程中，在选关界面的中心自动定位到
    
                    
    • 
                    
  • JVM（4）原理篇
                        梵高Coding
JVMjvmjava
                        
    1栈上的数据存储在Java中有8大基本数据类型：这里的内存占用，指的是堆上或者数组中内存分配的空间大小，栈上的实现更加复杂。以基础篇的这段代码为例：Java中的8大数据类型在虚拟机中的实现：boolean、byte、char、short在栈上是不是存在空间浪费？是的，Java虚拟机采用的是空间换时间方案，在栈上不存储具体的类型，只根据slot槽进行数据的处理，浪费了一些内存空间但是避免不同数据类型
    
                    
    • 
                    
  • RxJava学习笔记
                        ztzt123

                        
    之前有过一次学习笔记，发现长时间不经常用Rx的一些操作已经忘得差不多了，经常的复习是多么的重要啊，这次会在上一次不足的部分补充一下。上一次的学习笔记：http://wiki.sankuai.com/pages/viewpage.action?pageId=405485429Rx操作符补充flatMap使用flatMap时将原本发送的数据进行转换，再返回转换后数据的Observable，flatMa
    
                    
    • 
                    
  • Rxjava Transtorming Observables
                        shiyuzhe

                        
    OperatorsthattransformitemsthatareemittedbyanObservable.Buffer—periodicallygatheritemsfromanObservableintobundlesandemitthesebundlesratherthanemittingtheitemsoneatatimeFlatMap—transformtheitemsemitted
    
                    
    • 
                    
  • LiveData 迁移到 Kotlin Flow详解
                        
kotlin
                        
    LiveData，是Android2017推出的一个东西，配合MVVM使用。观察者模式，的确简化了我们的工作方式，但RxJava等选项，对于当时的初学者来说实在是太复杂了。因此ArchitectureComponents团队创建了LiveData：这是个非常“有主见的”可观察数据持有者类，并且是专门为Android设计的。它保持简单明了，这让它易于上手，建议是将RxJava用于更复杂的响应流案例，
    
                    
    • 
                    
  • retrofit+rxjava+okhttp网络框架之二次封装
                        nade_s

                        
    retrofit+rxjava的是这几年很流行的一种网络框架，开发者也提供了丰富的方法。之所以进行二次封装，就是因为retrofit+rxjava的链式调用太方便了，不符合单一性原则，管理起来比较麻烦。主要目的是二次封装后，和项目有很高的契合度更高。说一下封装思路，由于其本身调用方便，具体方法就不做封装了。第一retrofit对象封装。第二封装okhttp拦截器，用于添加头参数，拦截错误日志。第三
    
                    
    • 
                    
  • RxJava常用的操作符
                        emmmmsuperdan
rxjavaandroidjava
                        
    ZipZip:把两个流返回结果一起调用；Zip(a,b,newFunction(b的类型，结合结果的返回类型));
    
                    
    • 
                    
  • 【ARM自学笔记】ARM Cortex -A中断系统（原理篇）
                        ORI2333
ARM嵌入式arma单片机
                        
    文章目录前言简述中断向量表GIC架构中断IDGIC逻辑分块CP15协处理器中断使能中断优先级设置程序编写最后前言本文所描述的为Cortex-A7中断系统简述中断是什么？中断（Interrupt）是指处理器接收到来自硬件或软件的信号，提示发生了某个事件，应该被注意，这种情况就称为中断。通常，在接收到来自外围硬件（相对于中央处理器和内存）的异步信号，或来自软件的同步信号之后，处理器将会进行相应的硬件／
    
                    
    • 
                    
  • Android混淆-基本混淆模板+自定义混淆类NotProguard
                        MonkeyLei

                        
    proguard-rules.pro-第三方就增加了一个glide+rxjava+retrofit，别的按需添加即可#AddprojectspecificProGuardruleshere.#Youcancontrolthesetofappliedconfigurationfilesusingthe#proguardFilessettinginbuild.gradle.##Formoredetai
    
                    
    • 
                    
  • RxJava-使用详解与背压原理2
                        Laughing_G

                        
    一、RxJava1与RxJava2的区别前提：RxJava是响应式编程，基于事件流开发。区别：1.RxJava2不再支持null值，如果传入一个null会抛出NullPointerException；2.Observable.just(null)不支持；3.RxJava2所有的函数接口（Function、Action、Consumer）均设计为可抛出Exception，同时支持自己去解决编译异常需
    
                    
    • 
                    
  • MVP步骤
                        I_Am_Legend

                        
    T-MVP步骤：1.添加依赖implementation'com.squareup.okhttp3:okhttp:3.8.1'implementation'com.squareup.okhttp3:logging-interceptor:3.4.1'implementation'io.reactivex:rxjava:1.1.6'//Retrofit的rx解析库implementation'com
    
                    
    • 
                    
  • 手把手带你入门神秘的RxJava
                        可以写但没有必要

                        
    近两年来国内的技术圈子中越来越多的开始提及RxJava，越来越多的应用和面试中都会有RxJava，而就目前的情况，Android的网络库基本被Retrofit+OkHttp一统天下了，而配合上响应式编程RxJava可谓如鱼得水。什么是RxJava•Rx是ReactiveExtensions的简写，翻译为响应的扩展。也就是通过由一方发出信息，另一方响应信息并作出处理的核心框架代码。•该框架由微软的架
    
                    
    • 
                    
  • Hystrix系列之执行原理分析
                        美团Java

                        
    上文中介绍了Hystrix的由来，本文会深入分析Hystrix的执行过程。Hystrix的大部分逻辑基于RxJava，其实现让很热多人望而却步，停留在了仅仅使用的地步，从一个简单的HelloWorld开始。publicclassCommandHelloWorldextendsHystrixCommand{privatefinalStringname;publicCommandHelloWorld(
    
                    
    • 
                    
  • RxJava之concatMap系列转换操作符源码介绍
                        103style

                        
    转载请以链接形式标明出处：本文出自:103style的博客转换相关的操作符以及官方介绍RxJava之concatMap系列转换操作符官方介绍：TransformingObservablesconcatMapconcatMapCompletableconcatMapCompletableDelayErrorconcatMapDelayErrorconcatMapEagerconcatMapEager
    
                    
    • 
                    
  • Docker基础(1) 原理篇
                        zhixin9001

                        
    Docker是什么Docker的构成Docker的分层和写时拷贝策略Docker与主流虚拟机的区别Docker镜像与容器的关系镜像的变更管理Docker是什么Docker是一个开源的应用容器引擎。它的理念是“Buildonce,Runanywhere,Configureonce,Runanything”，这与Java提出的“WriteOnce,RunAnywhere”有异曲同工之妙。Java与Do
    
                    
    • 
                                
  • 多线程编程之理财
                                    周凡杨
java多线程生产者消费者理财
                                    
          现实生活中，我们一边工作，一边消费，正常情况下会把多余的钱存起来，比如存到余额宝，还可以多挣点钱，现在就有这个情况：我每月可以发工资20000万元 （暂定每月的1号），每月消费5000（租房+生活费）元（暂定每月的1号），其中租金是大头占90%，交房租的方式可以选择（一月一交，两月一交、三月一交），理财：1万元存余额宝一天可以赚1元钱，
    
                                
    • 
                                
  • [Zookeeper学习笔记之三]Zookeeper会话超时机制
                                    bit1129
zookeeper
                                    
    首先，会话超时是由Zookeeper服务端通知客户端会话已经超时，客户端不能自行决定会话已经超时，不过客户端可以通过调用Zookeeper.close()主动的发起会话结束请求，如下的代码输出内容 
Created /zoo-739160015 
CONNECTEDCONNECTED 
.............CONNECTEDCONNECTED 
CONNECTEDCLOSEDCLOSED 

    
                                
    • 
                                
  • SecureCRT快捷键
                                    daizj
secureCRT快捷键
                                    
    ctrl + a : 移动光标到行首ctrl + e ：移动光标到行尾crtl + b: 光标前移1个字符crtl + f: 光标后移1个字符crtl + h : 删除光标之前的一个字符ctrl + d ：删除光标之后的一个字符crtl + k ：删除光标到行尾所有字符crtl + u : 删除光标至行首所有字符crtl + w:  删除光标至行首
    
                                
    • 
                                
  • Java 子类与父类这间的转换
                                    周凡杨
java 父类与子类的转换
                                    
        最近同事调的一个服务报错，查看后是日期之间转换出的问题。代码里是把 java.sql.Date 类型的对象 强制转换为 java.sql.Timestamp 类型的对象。报java.lang.ClassCastException。 
  
    代码： 
            
    
                                
    • 
                                
  • 可视化swing界面编辑
                                    朱辉辉33
eclipseswing
                                    
          今天发现了一个WindowBuilder插件，功能好强大，啊哈哈，从此告别手动编辑swing界面代码，直接像VB那样编辑界面，代码会自动生成。 
      首先在Eclipse中点击help，选择Install New Software,然后在Work with中输入WindowBui
    
                                
    • 
                                
  • web报表工具FineReport常用函数的用法总结（文本函数）
                                    老A不折腾
finereportweb报表工具报表软件java报表
                                    
    文本函数 
CHAR 
CHAR(number):根据指定数字返回对应的字符。CHAR函数可将计算机其他类型的数字代码转换为字符。 
Number:用于指定字符的数字，介于1Number:用于指定字符的数字，介于165535之间（包括1和65535）。 
示例: 
CHAR(88)等于“X”。 
CHAR(45)等于“-”。 
  
CODE 
CODE(text):计算文本串中第一个字
    
                                
    • 
                                
  • mysql安装出错
                                    林鹤霄
mysql安装
                                    
    [root@localhost ~]# rpm -ivh MySQL-server-5.5.24-1.linux2.6.x86_64.rpm Preparing...                #####################
    
                                
    • 
                                
  • linux下编译libuv
                                    aigo
libuv
                                    
    下载最新版本的libuv源码，解压后执行： 
./autogen.sh 
  
这时会提醒找不到automake命令，通过一下命令执行安装（redhat系用yum，Debian系用apt-get）： 
# yum -y install automake 
# yum -y install libtool 
  
  
如果提示错误：make: *** No targe
    
                                
    • 
                                
  • 中国行政区数据及三级联动菜单
                                    alxw4616

                                    
    近期做项目需要三级联动菜单,上网查了半天竟然没有发现一个能直接用的! 
呵呵,都要自己填数据....我了个去这东西麻烦就麻烦的数据上. 
哎,自己没办法动手写吧. 
现将这些数据共享出了,以方便大家.嗯,代码也可以直接使用 
  文件说明 
 
 lib\area.sql -- 县及县以上行政区划分代码（截止2013年8月31日)来源：国家统计局 发布时间：2014-01-17 15:0
    
                                
    • 
                                
  • 哈夫曼加密文件
                                    百合不是茶
哈夫曼压缩哈夫曼加密二叉树
                                    
     在上一篇介绍过哈夫曼编码的基础知识,下面就直接介绍使用哈夫曼编码怎么来做文件加密或者压缩与解压的软件,对于新手来是有点难度的,主要还是要理清楚步骤; 
  
加密步骤: 
 1,统计文件中字节出现的次数,作为权值 
  
2,创建节点和哈夫曼树 
  
3,得到每个子节点01串 
  
4,使用哈夫曼编码表示每个字节 
  

    
                                
    • 
                                
  • JDK1.5 Cyclicbarrier实例
                                    bijian1013
javathreadjava多线程Cyclicbarrier
                                    
    CyclicBarrier类 
一个同步辅助类，它允许一组线程互相等待，直到到达某个公共屏障点 (common barrier point)。在涉及一组固定大小的线程的程序中，这些线程必须不时地互相等待，此时 CyclicBarrier 很有用。因为该 barrier 在释放等待线程后可以重用，所以称它为循环的 barrier。 
CyclicBarrier支持一个可选的 Runnable 命令，
    
                                
    • 
                                
  • 九项重要的职业规划
                                    bijian1013
工作学习
                                    
    一. 学习的步伐不停止        古人说，活到老，学到老。终身学习应该是您的座右铭。        世界在不断变化，每个人都在寻找各自的事业途径。        您只有保证了足够的技能储
    
                                
    • 
                                
  • 【Java范型四】范型方法
                                    bit1129
java
                                    
    范型参数不仅仅可以用于类型的声明上，例如 
  
package com.tom.lang.generics;

import java.util.List;

public class Generics<T> {
    private T value;
    public Generics(T  value) {
        this.value = 
    
                                
    • 
                                
  • 【Hadoop十三】HDFS Java API基本操作
                                    bit1129
hadoop
                                    
      
package com.examples.hadoop;

import org.apache.hadoop.conf.Configuration;

import org.apache.hadoop.fs.FSDataInputStream;
import org.apache.hadoop.fs.FileStatus;
import org.apache.hadoo
    
                                
    • 
                                
  • ua实现split字符串分隔
                                    ronin47
lua split
                                    
    LUA并不象其它许多"大而全"的语言那样，包括很多功能，比如网络通讯、图形界面等。但是LUA可以很容易地被扩展：由宿主语言(通常是C或 C++)提供这些功能，LUA可以使用它们，就像是本来就内置的功能一样。LUA只包括一个精简的核心和最基本的库。这使得LUA体积小、启动速度快，从 而适合嵌入在别的程序里。因此在lua中并没有其他语言那样多的系统函数。习惯了其他语言的字符串分割函
    
                                
    • 
                                
  • java-从先序遍历和中序遍历重建二叉树
                                    bylijinnan
java
                                    
    

public class BuildTreePreOrderInOrder {

	/**
	 * Build Binary Tree from PreOrder and InOrder
	 *  _______7______
       /              \
    __10__          ___2
   /      \        /
   4
    
                                
    • 
                                
  • openfire开发指南《连接和登陆》
                                    开窍的石头
openfire开发指南smack
                                    
    第一步 
    官网下载smack.jar包 
    下载地址：http://www.igniterealtime.org/downloads/index.jsp#smack 
第二步 
    把smack里边的jar导入你新建的java项目中 
 
开始编写smack连接openfire代码 
 
p
    
                                
    • 
                                
  • [移动通讯]手机后盖应该按需要能够随时开启
                                    comsci
移动
                                    
        看到新的手机，很多由金属材质做的外壳，内存和闪存容量越来越大，CPU速度越来越快，对于这些改进，我们非常高兴，也非常欢迎 
 
     但是，对于手机的新设计，有几点我们也要注意 
 
     第一：手机的后盖应该能够被用户自行取下来，手机的电池的可更换性应该是必须保留的设计,
    
                                
    • 
                                
  • 20款国外知名的php开源cms系统
                                    cuiyadll
cms
                                    
    内容管理系统，简称CMS，是一种简易的发布和管理新闻的程序。用户可以在后端管理系统中发布，编辑和删除文章，即使您不需要懂得HTML和其他脚本语言，这就是CMS的优点。 
在这里我决定介绍20款目前国外市面上最流行的开源的PHP内容管理系统，以便没有PHP知识的读者也可以通过国外内容管理系统建立自己的网站。 
1. Wordpress 
WordPress的是一个功能强大且易于使用的内容管
    
                                
    • 
                                
  • Java生成全局唯一标识符
                                    darrenzhu
javauuiduniqueidentifierid
                                    
    How to generate a globally unique identifier in Java 
 
 
 
http://stackoverflow.com/questions/21536572/generate-unique-id-in-java-to-label-groups-of-related-entries-in-a-log 
 
 
http://stackoverflow
    
                                
    • 
                                
  • php安装模块检测是否已安装过, 使用的SQL语句
                                    dcj3sjt126com
sql
                                    
           
SHOW [FULL] TABLES [FROM db_name] [LIKE 'pattern'] 
SHOW TABLES列举了给定数据库中的非TEMPORARY表。您也可以使用mysqlshow db_name命令得到此清单。 
本命令也列举数据库中的其它视图。支持FULL修改符，这样SHOW FULL TABLES就可以显示第二个输出列。对于一个表，第二列的值为BASE T
    
                                
    • 
                                
  • 5天学会一种 web 开发框架
                                    dcj3sjt126com
Web框架framework
                                    
    web framework层出不穷，特别是ruby/python,各有10+个,php/java也是一大堆 根据我自己的经验写了一个to do list,按照这个清单，一条一条的学习，事半功倍，很快就能掌握 一共25条，即便很磨蹭，2小时也能搞定一条，25*2=50。只需要50小时就能掌握任意一种web框架 
各类web框架大同小异:现代web开发框架的6大元素，把握主线，就不会迷路 
建议把本文
    
                                
    • 
                                
  • Gson使用三(Map集合的处理,一对多处理)
                                    eksliang
jsongsonGson mapGson 集合处理
                                    
    转载请出自出处：http://eksliang.iteye.com/blog/2175532 一、概述 
       Map保存的是键值对的形式，Json的格式也是键值对的，所以正常情况下，map跟json之间的转换应当是理所当然的事情。 二、Map参考实例 
package com.ickes.json;

import java.lang.refl
    
                                
    • 
                                
  • cordova实现“再点击一次退出”效果
                                    gundumw100
android
                                    
    基本的写法如下： 
 


document.addEventListener("deviceready", onDeviceReady, false);
			
function onDeviceReady() {
	//navigator.splashscreen.hide();
        document.addEventListener("b
    
                                
    • 
                                
  • openldap configuration leaning note
                                    iwindyforest
configuration
                                    
    hostname // to display the computer name 
hostname <changed name> // to change 
go to: /etc/sysconfig/network, add/modify HOSTNAME=NEWNAME to change permenately 
dont forget to change /etc/hosts
    
                                
    • 
                                
  • Nullability and Objective-C
                                    啸笑天
Objective-C
                                    
    https://developer.apple.com/swift/blog/?id=25 
  
http://www.cocoachina.com/ios/20150601/11989.html 
  
http://blog.csdn.net/zhangao0086/article/details/44409913 
  
http://blog.sunnyxx
    
                                
    • 
                                
  • jsp中实现参数隐藏的两种方法
                                    macroli
JavaScriptjsp
                                    
    在一个JSP页面有一个链接，//确定是一个链接?点击弹出一个页面，需要传给这个页面一些参数。//正常的方法是设置弹出页面的src="***.do?p1=aaa&p2=bbb&p3=ccc"//确定目标URL是Action来处理?但是这样会在页面上看到传过来的参数，可能会不安全。要求实现src="***.do"，参数通过其他方法传！//////
    
                                
    • 
                                
  • Bootstrap A标签关闭modal并打开新的链接解决方案
                                    qiaolevip
每天进步一点点学习永无止境bootstrap纵观千象
                                    
    Bootstrap里面的js modal控件使用起来很方便，关闭也很简单。只需添加标签 data-dismiss="modal" 即可。 
可是偏偏有时候需要a标签既要关闭modal，有要打开新的链接，尝试多种方法未果。只好使用原始js来控制。 
  
<a href="#/group-buy" class="btn bt
    
                                
    • 
                                
  • 二维数组在Java和C中的区别
                                    流淚的芥末
javac二维数组数组
                                    
    Java代码： 
  
public class test03 {
	public static void main(String[] args) {
		int[][] a = {{1},{2,3},{4,5,6}};
		System.out.println(a[0][1]);
	}
} 
 运行结果： 
Exception in thread "mai
    
                                
    • 
                                
  • systemctl命令用法
                                    wmlJava
linuxsystemctl
                                    
    对比表，以 apache / httpd 为例   任务 旧指令 新指令   使某服务自动启动 chkconfig --level 3 httpd on systemctl enable httpd.service   使某服务不自动启动 chkconfig --level 3 httpd off systemctl disable httpd.service   检查服务状态 service h
    
                                
    •