Android小贾
Android小贾

你可以不用RxJava，但必须得领悟它的思想！

作者：cofbro

前言

Rx 是一种响应式编程的思想，如今有很多语言都支持这种思想：RxJava，RxJs，RxSwift...。它是基于特殊的观察者模式来实现的，能够轻松的实现异步事件响应流，避免回调地狱的产生。这种思维和我们平时的编程思维不太相同，它以数据流为核心，处理数据的输入，处理以及输出，因此这个框架学习起来是有一定难度的，加之 RxJava 操作符众多，这又给初学者立了个下马威。

本篇博客会 分析其原理与思想 ，从源码层次对其进行深入分析。

✔️ 本文阅读时长约为: 10min

本篇博客适合已经会简单使用 RxJava 框架并想了解其原理与思想的同学~

RxJava的观察者模式

在 标准的观察者设计模式 中，通常都是一个被观察者，多个观察者。例如，在抖音中A，B，C，D四人都关注了一个博主 甲。那么当博主 甲 发布新视频时，甲会去通知A，B，C，D四人，告诉他们我已经发布了新的视频，你们现在可以前去观看。

你可以不用RxJava，但必须得领悟它的思想！_第1张图片

而 RxJava的观察者设计模式 与前者有些许差异，我的理解是在 RxJava 中只有一个被观察者和一个观察者，被观察者就是数据源也就是 起点 ，而观察者就是 终点 。起点 到 终点 这一段过程做什么事情由我们自己定义，像加卡片一样往里堆，但始终只有一个 起点 和一个 终点 ，这也就是俗称的卡片式编程。

你可以不用RxJava，但必须得领悟它的思想！_第2张图片

举个栗子：

我们的起点是发起网络请求得到一张图片，终点是得到一张加了 水印 和 高斯模糊 的图片。那么我们就需要在 起点 到 终点 这一过程中往里面加两张卡片。一张卡片是加水印的功能，另一张卡片是加高斯模糊的功能，最终我们会在 终点 得到我们的想要的效果，这就是 RxJava 的一个过程，大家看是不是比 标准观察者模式 的耦合度更低呢？

现在结合代码来看一下呢：

    // 示例：创建Observable
    // create方法中的参数是我们自定义的source，下文会提到
    Observable observable = Observable.create(new ObservableOnSubscribe() {
    //----------------------------------被观察者--------------------------------------
        @Override
        public void subscribe(ObservableEmitter e) throws Exception {
            // 数据源(起点)，假设我们这里得到了一张图片，开始向下传递
            e.onNext();
        }
    //-----------------------------------卡片1----------------------------------------
    }).map(new Function() {
        // 1.加水印的卡片
        @Override
        public Bitmap apply(Bitmap bitmap) throws Exception {
            // TODO 这里我们将图片加上水印
        }
    //-----------------------------------卡片2----------------------------------------
    }).map(new Function() {
        // 2.加高斯模糊的卡片
        @Override
        public Bitmap apply(Bitmap bitmap) throws Exception {
            // TODO 这里我们将图片加上高斯模糊
        }
    //-----------------------------------观察者---------------------------------------
    // 订阅被观察者
    }).subscribe(new Observer() {
        @Override
        public void onSubscribe(Disposable d) {}

        @Override
        public void onNext(Bitmap bitmap) {
            // 最终获得加了水印和高斯模糊的图片
            // do what you want...
        }

        @Override
        public void onError(Throwable e) {}

        @Override
        public void onComplete() {}
    });
 
  
我们可以看到，RxJava 链式调用后在终点能得到我们想要的结果，我们对 Bitmap 的两个操作以 卡片 形式加到了 起点 和 终点 的过程中，这就是 RxJava 的魅力之一。
 
  
了解 RxJava 大体的执行流程后，现在我们就从源码角度来解释整个框架内部逻辑是怎样运转的。
 
  
RxJava如何将事件逐步传递
 
  
首先我们先来看看这些操作符内部逻辑是什么样子的，这里以 create 和 map 为例子展示：
 
  
1️⃣. create
 
  
// Observable.java
public static  Observable create(ObservableOnSubscribe source) {
    // 常规空检查
    ObjectHelper.requireNonNull(source, "source is null");
    // 这里是个hook，其实直接放回的是 ObservableCreate
    // 返回的其实就是我们传进来的参数
    return RxJavaPlugins.onAssembly(new ObservableCreate(source));
}

 
  
2️⃣. map
 
  
// Observable.java
public final  Observable map(Function mapper) {
    // 常规空检查
    ObjectHelper.requireNonNull(mapper, "mapper is null");
    // 这里是个hook，其实直接放回的是 ObservableMap
    // 返回的其实就是我们传进来的参数
    return RxJavaPlugins.onAssembly(new ObservableMap(this, mapper));
}

 
  
从上面的例子中可以看出，这两个操作符不管是结构还是逻辑几乎是一模一样，只是 onAssembly 方法中传递的参数不同(其实也可以说是相同的，他们都是 Observable 的子类)。实际上，几乎所有的操作符都是这样的结构，会在内部 new ObservableXXX()。
 
  
为什么我们的操作符都能链式调用呢？这就跟上面说到的特点有关了，由于几乎所有操作符都是上述结构，返回值的都是 ObservableXXX，而他们都是 Observable 的子类，所以我们能一直通过 .XXXX的形式调用 Observable 中的操作符，一直往里面加 卡片 来完成我们的需求。
 
  
⚡⚡ 那么，ObservableXXX类有什么用呢？
 
  
 
  
1.ObervableXXX的整体认识
 
  
其实这些 ObservableXXX 就像工厂中的一个个流水线组装货物的机器，货物从 起点 向 终点 传输，当货物传输到不同的机器上时，这台机器会操作货物完成这一层的组装工作，最后会将其传输到下一个机器上去，完成那个机器的组装任务，直至传输到 终点 整个货物组装完毕。
 
  
回头看上面的例子，我们加入的两张卡片就像是两台机器一样，map 机器完成水印工作后，将 货物 扔给后一个 map 机器，由它完成高斯模糊工作，最后 货物组装完成，被传输到了终点，在这里我们就能拿到最终期望的结果。
 
  
接下来我会举两个例子，带着大家看看它们的内部逻辑。因为几乎所有的 ObservableXXX 的逻辑和功能都相似，因此大家在看完下面几个例子后，可以自行去源码中轻松查看你想看的部分。
 
  
2.ObservableMap内部运转逻辑
 
  
这样一说相信大家对它有了一个整体的感受，那么我们现在以 ObservableMap 为例，重点讲解一下内部逻辑吧。
 
  
⚡ 在讲解源码之前，我们需要先知道一个点：代码当中的 source 指的都是上一个操作符返回的 Observable 对象，function 指的是调用此操作符需要传递的参数，即匿名实现类，另外下文还会出现 自定义source，这个就是我们在使用 create操作符 时传递的参数，也称 顶层source ，它是货物运输的 起点 。
 
  
// ObservableMap.java


// Observable继承自AbstractObservableWithUpstream，AbstractObservableWithUpstream又继承Observable
// Observable实现了ObservableSource接口
// 因此这里会重写 subscribe 方法
public final class ObservableMap extends AbstractObservableWithUpstream {
    final Function function;

    public ObservableMap(ObservableSource source, Function function) {
        // source 是上一层操作符返回的Observable对象
        // function 是我们使用此操作符传递的那个匿名实现类，<可以称其为这一个机器需要做的操作>
        // 在本类中其实就是实现了Function接口的匿名类，里边有个方法叫作apply
        // <本层机器处理货物时>，会看到apply方法
        super(source);
        this.function = function;
    }

    // 此方法是 subscribe 的具体实现方法
    // 我们进行订阅时，即调用subscribe时，最终会调用此方法，<最终通知起点开始传输货物>
    @Override
    public void subscribeActual(Observer t) {
        // t代表我们调用subscribe时传递的参数，即匿名实现类，<我们可以称其为后一台机器要执行的操作>
        // 将t和function包装一下，再调用 source 的 subscribe，<也就是前面那台机器的subscribe>
        // 这里的subscribe可以理解为通知上层机器开始运输货物
        source.subscribe(new MapObserver(t, function));
    }

    // 内部类，<将后一台机器执行的操作和上一个机器绑定起来>
    // 就是将后一个机器的操作做了层封装，包裹了一层
    static final class MapObserver extends BasicFuseableObserver {
        final Function mapper;

        MapObserver(Observer actual, Function mapper) {
            super(actual);
            this.mapper = mapper;
        }

        // <此方法是货物到达本机器时，本机器的相应操作>
        @Override
        public void onNext(T t) {
            // 这些判空直接不看
            if (done) {
                return;
            }

            if (sourceMode != NONE) {
                actual.onNext(null);
                return;
            }

            U v;
            // 这里会执行apply方法，是我们使用map操作符传递的实现了Function接口的匿名内部类中的方法
            // <本层机器开始处理上层机器传递过来的货物>
            try {
                v = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper function returned a null value.");
            } catch (Throwable ex) {
                fail(ex);
                return;
            }
            // 本层机器的货物处理完毕，扔给下层机器继续处理
            // 
            actual.onNext(v);
        }
    }

 
  
总的来说 ObservableMap 做了两件事，第一就是调用 subscribeActual 通知上层机器让其开始传递货物，第二就是调用 onNext 处理传递到本层的货物，最后再扔给下一个机器去处理。
 
  
其实 ObservableXXX 结构和逻辑都差不太多，我将最开始给的例子用图表示了出来：
 
  
你可以不用RxJava，但必须得领悟它的思想！_第3张图片
 
  
相信大家可以从这张图中看出，整个运转逻辑是一个 U型结构，当我们调用 subscribe 时，就会通知 起点 运输货物，其实也就是设置了观察者。然后，货物就会一层一层往下传递，最终流到我们的终点。如果我们中途想继续添加需求，直接往中间那个过程添加机器(或者说是卡片)就行了，非常方便，而且整个链式调用下来，代码会比不用 RxJava 显得更加干净整洁易读。
 
  
3.ObservableCreate内部运转逻辑
 
  
那么起点是怎么接收下面的 机器 传递上来的运输货物的信号并开始运输货物的呢？
 
  
public final class ObservableCreate extends Observable {
    // 我们自己写的source
    final ObservableOnSubscribe source;

    public ObservableCreate(ObservableOnSubscribe source) {
        // 这个source是我们自定义的，也就是使用create操作符时传递的那个参数
        // 这就是我们的所说的起点、源头
        this.source = source;
    }

    // 这个就是起点触发传送任务的方法
    @Override
    protected void subscribeActual(Observer observer) {
        CreateEmitter parent = new CreateEmitter(observer);
        // 这个observer是从下面机器经过一层层包装后传递过来的observer
        // 实际上调用的是我们使用subscribe传递参数当中的onSubscribe方法，即终点的onSubscribe方法
        observer.onSubscribe(parent);

        // 开始传输任务，将货物往下传递
        try {
            // 这里的source就是顶层的自定义source
            source.subscribe(parent);
        } catch (Throwable ex) {
            Exceptions.throwIfFatal(ex);
            parent.onError(ex);
        }
    }

    // 这个就是发射器，用于将货物从起点往下传递的工具
    // 通常情况下，我们在自定义source中都会调用此类的onNext方法开始向下传输货物
    static final class CreateEmitter
    extends AtomicReference
    implements ObservableEmitter, Disposable {
        private static final long serialVersionUID = -3434801548987643227L;

        final Observer observer;

        CreateEmitter(Observer observer) {
            this.observer = observer;
        }

        // 向下传输货物的方法
        @Override
        public void onNext(T t) {
            ...
            if (!isDisposed()) {
                // 将货物扔给下一层机器去处理
                observer.onNext(t);
            }
        }
        ...
    }
    ...
}

 
  
至此，两个典型的 ObservableXXX 讲解完毕，可能大家对源码当中的 source 和 subscribeActual 中的参数 observer/t 傻傻分不清楚，不知道这些是指 前一个机器 ，还是 后一个机器 ，那么接下来请看下面这幅图。
 
  
你可以不用RxJava，但必须得领悟它的思想！_第4张图片
 
  
source 是前一个操作符返回的 Observable 对象，这个相信大家都容易理解。这里着重说一下上述图的下半部分，大家还记得终点是怎么通知起点开始传输 货物 的吗？没错，是通过每一个 Observable.subscribeActual 方法 （机器）中的参数不断向起点传递，每个 subscribeActual 方法中都会调用 source.subscribe()，也就是通知前面机器传输包裹，每向前传递一次就 封一层包裹 ，最后触发 起点 传输货物，之后就开始一层层 拆包裹 ，最终拆到终点(subscribe)中我们自己实现的 ObservableOnSubscribe 中。
 
  
小结
 
  
为了便于大家理解前面所讲述的知识点，这里我们用文章开头的那个例子继续深入讲解，我们来看上述代码是如何执行的，再贴一遍代码：
 
  
Observable observable = Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter e) throws Exception {
                e.onNext();
            }
        }).map(new Function() {
            @Override
            public Object apply(Bitmap bitmap) throws Exception {
                // todo
            }
        }).map(new Function() {
            @Override
            public ObservableSource apply(Bitmap bitmap) throws Exception {
                // todo
            }
        }).subscribe(new Observer() {
            @Override
            public void onSubscribe(Disposable d) {}

            @Override
            public void onNext(Bitmap bitmap) {}

            @Override
            public void onError(Throwable e) {}

            @Override
            public void onComplete() {}
    });
 
  
1️⃣ 我们通过 .subscribe()，发起了订阅，开始观察被观察者，结合我们之前讲的，我们实际上调用的是map 返回对象中的 subscribe 方法，即 ObservableMap 。
 
  
// ObservableMap.java

//它会继续调用上层机器的subscribe，通知上层机器传输货物
public void subscribeActual(Observer t) {
    // 封包裹，传递给上层机器
    source.subscribe(new MapObserver(t, function));
}

 
  
2️⃣ 这里它会继续调用上层机器的 subscribe，由于上个操作符仍是 map，所以我们直接跳过，看 create 操作符。
 
  
// ObservableCreate.java

protected void subscribeActual(Observer observer) {
    CreateEmitter parent = new CreateEmitter(observer);
    // 这里是调用下一层机器的onSubscribe方法
    observer.onSubscribe(parent);

    try {
        // 调用我们自定义的soruce，开始传输货物
        // 例子中我们自定义soruce中写的代码是emitter.onNext，开始传输货物
        source.subscribe(parent);
    } catch (Throwable ex) {
        Exceptions.throwIfFatal(ex);
        parent.onError(ex);
    }
}

 
  
3️⃣ 到这里，我们已经通知 起点 发起传送任务，那么接下来就是传输货物的过程，逐步 拆包 的过程。随着货物的运输，代码会不断调用最外层包裹中的 observable 对象的 onNext 方法，看起来就像在拆包裹一样，这其实也是前面说的运输包裹的过程，如此反复，最后到达我们的终点的 onNext 方法，我们拿到最终期望的货物，至此，整个过程基本完毕。
 
  
✔️ 现在是不是脑海里面又出现了前面所说的 U型结构 呢？
 
  
RxJava是如何完成线程切换的？
 
  
RxJava 能完成线程切换是通过 subscribeOn，observeOn。正常情况下我们都是这么用的：
 
  
observable.subscribeOn(Schedulers.io())
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe(...)

 
  
前面反复强调整个框架的执行过程是一个 U型结构，请大家思考一下，subscribeOn 和observeOn 切换线程的核心代码是在 subscribeActual 中还是 onNext 中？
 
  
回忆一下，我们通知 起点 开始传输货物时，是通过 subscribeActual 逐层往上传递的，紧接着就开始运输货物处理货物了，就比如 map 机器中的 apply 方法就是处理货物的具体方法。因此，这一段任务都应该在 子线程 中完成，所以 subscribeOn的切换线程的核心代码是在subscribeActual中的。
 
  
observeOn 的作用就是让终点的 onNext 方法中的代码在主线程中执行，那么理应只需要在 observeOn操作符中的onNext中切换线程即可。
 
  
有了上述猜想，我们现在进入源码验证一下。
 
  
1.subscribeOn的线程切换
 
  
// 不仅有io线程，还有以下这些线程

SINGLE = RxJavaPlugins.initSingleScheduler(new SingleTask());

COMPUTATION = RxJavaPlugins.initComputationScheduler(new ComputationTask());

IO = RxJavaPlugins.initIoScheduler(new IOTask());

TRAMPOLINE = TrampolineScheduler.instance();

NEW_THREAD = RxJavaPlugins.initNewThreadScheduler(new NewThreadTask());

 
  
我们首先来看看使用该操作符时传递的参数 Schedulers.io() 到底是个什么东西。我们一层层点进去最后会发现它其实就是 new了一个线程池 :
 
  
// 一路点进去，会发现其实就是new了一个线程池
CachedWorkerPool update = new CachedWorkerPool(KEEP_ALIVE_TIME, KEEP_ALIVE_UNIT, threadFactory);

 
  
其中的 CacheWorkerPool 的源码如下：
 
  
// IoSchedule.java，这个类将线程池中的创建、调度、执行等方法做了一下封装

...

// 这个方法就是得到线程池
public Worker createWorker() {
    // EventLoopWorker继承自Worker，是对线程池做了一下封装，包裹了一层
    return new EventLoopWorker(pool.get());
}

// 实际调用线程池的方法
public Disposable schedule(@NonNull Runnable action, long delayTime, @NonNull TimeUnit unit) {
    if (tasks.isDisposed()) {
        // don't schedule, we are unsubscribed
        return EmptyDisposable.INSTANCE;
    }
    // 里面就是调用线程池的submit等方法
    return threadWorker.scheduleActual(action, delayTime, unit, tasks);
}

...

// CacheWorkerPool是IoSchedule中的内部类
CachedWorkerPool(long keepAliveTime, TimeUnit unit, ThreadFactory threadFactory) {
    this.keepAliveTime = unit != null ? unit.toNanos(keepAliveTime) : 0L;
    this.expiringWorkerQueue = new ConcurrentLinkedQueue();
    this.allWorkers = new CompositeDisposable();
    this.threadFactory = threadFactory;

    ScheduledExecutorService evictor = null;
    Future task = null;
    if (unit != null) {
        // 这里的核心线程数是1就足够了，因为我们子线程中的任务都是链式调用的
        evictor = Executors.newScheduledThreadPool(1, EVICTOR_THREAD_FACTORY);
        task = evictor.scheduleWithFixedDelay(this, this.keepAliveTime, 
            this.keepAliveTime, TimeUnit.NANOSECONDS);
    }
    evictorService = evictor;
    evictorTask = task;
}
...

 
  
所以，其实 .io() 就是传了一个核心线程数为1的线程池，当然我们还可以传入 .computation()，.newThread()等方法，这些其实都是创建了一个特殊的线程池。
 
  
我们知道，这些操作符都是在内部 new ObservableXXX类，所以源码我们直接看ObservableSubscirbeOn 。
 
  
// ObservableSubscribeOn.java

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 s) {
        final SubscribeOnObserver parent = new SubscribeOnObserver(s);
        // onSubscribe的回调
        s.onSubscribe(parent);
        // subscribeTask实际上是一个runnable
        // 调用scheduler.scheduleDirect(runnable)，将runnable放入线程池中去执行
        // 这里是重中之重，具体细节我们稍后讲解
        parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));
    }

    ...

    final class SubscribeTask implements Runnable {
        private final SubscribeOnObserver parent;

        SubscribeTask(SubscribeOnObserver parent) {
            this.parent = parent;
        }

        @Override
        public void run() {
            // 上面那个runnable其实就是这个
            // 这里是调用上层机器的subscirbe，通知起点开始传输货物
            source.subscribe(parent);
        }
    }
}

 
  
从上面我们可以知道，我们将 source.subscribe() 扔进了线程池中，那么就做到了在其之后的所有代码都是在子线程中执行了，直到代码走到 observeOn，在 ObservableObserveOn 中的 onNext() 方法将线程切回主线程。
 
  
接下来我们讲讲具体细节，看看 scheduleDirect 里面的逻辑。
 
  
public Disposable scheduleDirect(@NonNull Runnable run, long delay, @NonNull TimeUnit unit) {
    // createWorker()方法眼熟吗？这就是在IoSchedule当中的方法
    // Worker类本质上就是线程池，只是对其做了一层封装
    final Worker w = createWorker();

    final Runnable decoratedRun = RxJavaPlugins.onSchedule(run);
    // 将传进来的runnable再做一层封装，这里的runnable对应上面的例子就是source.subscribe
    DisposeTask task = new DisposeTask(decoratedRun, w);
    // 这个方法也眼熟吧？
    // 在线程池中执行此任务
    w.schedule(task, delay, unit);

    return task;
}

 
  
由上面这一过程我们可以知道，当通知到 本层的机器 传输货物时，这一层机器会将 subscribeActual 方法扔进线程池中去执行，即后续的代码都是运行在子线程中了。
 
  
那么它又是如何将线程切回来的呢？
 
  
2.observeOn的线程切换
 
  
理解了上面线程切换后，我们很容易能理解下面切换主线程的代码，现在直接进入 ObservableObserveOn 源码。
 
  
// ObservableObserveOn.java

@Override
protected void subscribeActual(Observer observer) {
   // 同样可以理解为对线程的封装，只不过这里内部是handler
   Scheduler.Worker w = scheduler.createWorker();
   // 同样是封包裹，把自己封装一层，扔给前面的机器
   source.subscribe(new ObserveOnObserver(observer, w, delayError, bufferSize));

}

static final class ObserveOnObserver extends BasicIntQueueDisposable
implements Observer, Runnable {

   ...

    // 重点关注onNext方法，切回主线程的代码都在这里面
    @Override
    public void onNext(T t) {
        if (done) {
            return;
        }
        ...
        
        // 切换线程的方法在这里面，内部调用的是HandlerWorker的schedule
        // 里面又调用的是HandlerSchedule的schedule
        schedule();
    }

 
  
当 起点 开始传输货物时，即开始逐层拆包裹，这时候会逐层调用 onNext，最后就会在 ObservableObserveOn 中的 onNext 方法中切换线程。而在 onNext 中又调用的是 HandlerSchedule 中的 schedule 方法进行最终的线程切换。
 
  
// HandlerSchedule.java

public Disposable schedule(Runnable run, long delay, TimeUnit unit) {
    ...
    // 这里的run就是下一层机器的onNext方法，例子中就是终点的onNext
    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，实现最终的线程切换
    handler.sendMessageDelayed(message, Math.max(0L, unit.toMillis(delay)));

    // 如果dispose，就停止RxJava后续流程，整个运输带不会再工作了
    if (disposed) {
        handler.removeCallbacks(scheduled);
        return Disposables.disposed();
    }

    return scheduled;
}

 
  
画个图做个总结，让大家理解更清晰一点：
 
  
你可以不用RxJava，但必须得领悟它的思想！_第5张图片
 
  
Android 学习笔录
 
  
Android 性能优化篇：https://qr18.cn/FVlo89
 Android 车载篇：https://qr18.cn/F05ZCM
 Android 逆向安全学习笔记：https://qr18.cn/CQ5TcL
 Android Framework底层原理篇：https://qr18.cn/AQpN4J
 Android 音视频篇：https://qr18.cn/Ei3VPD
 Jetpack全家桶篇（内含Compose）：https://qr18.cn/A0gajp
 Kotlin 篇：https://qr18.cn/CdjtAF
 Gradle 篇：https://qr18.cn/DzrmMB
 OkHttp 源码解析笔记：https://qr18.cn/Cw0pBD
 Flutter 篇：https://qr18.cn/DIvKma
 Android 八大知识体：https://qr18.cn/CyxarU
 Android 核心笔记：https://qr21.cn/CaZQLo
 Android 往年面试题锦：https://qr18.cn/CKV8OZ
 2023年最新Android 面试题集https://qr18.cn/CgxrRy
 Android 车载开发岗位面试习题：https://qr18.cn/FTlyCJ
 音视频面试题锦：https://qr18.cn/AcV6Ap
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(移动开发,Android,架构,rxjava,android,移动开发,Framework,安卓,业界资讯)

        

            

                
    
                    
  • java架构设计-COLA
                        芸尚非
java开发语言
                        
    参考：https://github.com/alibaba/COLA架构要素：组成架构的重要元素结构：要素直接的关系意义：定义良好的结构，治理应用复杂度，降低系统熵值，改善混乱状态创建COLA应用：mvnarchetype:generate\-DgroupId=com.alibaba.cola.demo.web\-DartifactId=demo-web\-Dversion=1.0.0-SNAPS
    
                    
    • 
                    
  • 领域驱动新实践：COLA框架全解析——架构设计与实战案例解析
                        Java进阶八股文
后端
                        
    1.引言：为什么选择COLA实现DDD？——从“代码泥潭”到“领域清晰”的架构跃迁传统分层架构的痛点：当代码沦为“数据库操作说明书”在典型的MVC或三层架构中，业务逻辑常常被“撕碎”成零散的片段，散落在Service层的各个角落。以电商系统的订单管理为例，开发者可能会遇到这样的场景：java代码解读复制代码//传统Service层：贫血模型的典型代码publicclassOrderService{
    
                    
    • 
                    
  • 深入浅出JVM性能优化：从理论到实践
                        rider189
javajvm
                        
    一、JVM架构与内存模型深度解析1.1JVM运行时数据区全景图方法区（元空间）：存储类信息、常量池等元数据堆内存：对象实例存储核心区域YoungGeneration（新生代）Eden区（对象诞生地）Survivor区（S0/S1，存活对象过渡区）OldGeneration（老年代）虚拟机栈：线程私有，存储栈帧本地方法栈：Native方法调用程序计数器：线程执行位置指示器1.2对象生命周期管理对象创
    
                    
    • 
                    
  • 安心联车辆管理系统二次开发方向全分析
                        安心联-车辆监控管理系统
人工智能大数据
                        
    安心联车辆动态监控管理系统作为基于北斗/GPS的综合性车辆管理平台，其二次开发方向可从功能扩展、技术优化、行业适配等多个维度展开。结合搜索结果中的技术架构、功能模块及行业需求，以下是主要的二次开发方向及相关技术实现建议：1.协议兼容性与硬件集成扩展方向：支持更多行业协议与传感器类型。当前系统已兼容JT/T808、JT/T809等交通行业协议，可扩展至其他领域（如物流、冷链运输）的专用协议（如GB/
    
                    
    • 
                    
  • OpenCV 基础模块 Python 版
                        ice_junjun
OpenCVopencvpython计算机视觉
                        
    OpenCV基础模块权威指南（Python版）一、模块全景图plaintextOpenCV架构(v4.x+)├─核心层│├─core：基础数据结构与操作（Mat/Scalar/Point）│└─imgproc：图像处理流水线（滤波→变换→检测）├─交互层│├─highgui：GUI与媒体I/O（显示/捕获/交互）│└─video：视频分析（运动检测/目标跟踪）├─3D视觉层│└─calib3d：相
    
                    
    • 
                    
  • 云智慧：拥抱AI算法驱动的智能运维服务创新引擎
                        

                        
    随着信息化、数字化、智能化的加码，企业对人工智能、大数据等技术应用呈现出明显兴趣，海笔研究对国内中型规模企业调研表明，在2020年，54.1%的企业选择购买人工智能类应用，41.9%的企业选择购买大数据及BI类应用，各类产品软件的应用大幅提升了企业信息系统复杂度，以及运维管理难度。业务发展催生服务需求从系统管理者角度出发，信息系统从“单机Excel表格”到“集中式单系统”再到“微服务、云架构”等，
    
                    
    • 
                    
  • 云智慧发布对象关系型数据库CloudPanguDB，打破传统技术壁垒
                        

                        
    近日，云智慧推出关系型数据库CloudPanguDB（中文名称：盘古数据库），旨在通过高兼容性能和创新技术架构，降低企业项目整体运营成本。无论是处理海量复杂数据，还是构建清晰有序的数据结构关系，CloudPanguDB都具有强大的应用价值。随着各产业数字化转型的迅速发展，企业对国产化数据库需求与日俱增。CloudPanguDB以云智慧自身产品技术为基础，统一优化技术架构，功能覆盖关系型数据库、全文
    
                    
    • 
                    
  • 数据权限访问控制（Apache Sentry）
                        deepdata_cn
权限管理apachesentry
                        
    ApacheSentry最初由Cloudera公司内部开发，针对Hadoop系统中的数据（主要是HDFS、Hive的数据）进行细粒度控制，对HDFS、Hive以及Impala有着良好的支持性。2013年Sentry成为Apache的孵化项目，为Hadoop集群元数据和数据存储提供集中、细粒度的访问控制。其架构包括DataEngine、Plugin、Policymetadata等部分，Plugin负
    
                    
    • 
                    
  • React Native：跨平台移动应用开发的强大框架
                        冬冬小圆帽
reactnativereact.jsjavascript
                        
    ReactNative介绍ReactNative是由Facebook开发并开源的一款基于JavaScript和React的跨平台移动应用开发框架。它允许开发者使用React的语法和组件模型来构建原生移动应用（iOS和Android）。ReactNative的核心思想是“LearnOnce,WriteAnywhere”，即学习一次，编写多端应用。1.核心特点跨平台开发：使用JavaScript和Re
    
                    
    • 
                    
  • 《Astro 3.0 岛屿架构实战：用「零JS」打造百万PV内容网站》
                        前端极客探险家
架构javascript开发语言
                        
    文章目录一、传统内容站点的性能困局1.1企业级项目性能调研（N=200+）1.2Astro核心优势矩阵二、十分钟构建高性能内容站点2.1项目初始化2.2核心配置文件三、六大企业级场景实战3.1场景一：多框架组件混用3.2场景二：交互增强型Markdown四、性能优化深度解析4.1优化前后数据对比4.2关键优化策略五、企业级架构方案5.1内容站点技术栈5.2流量突增应对方案六、调试与监控体系6.1性
    
                    
    • 
                    
  • 【监控系列】open-falcon
                        yunqi1215
Monitor自动化
                        
    Open-Falcon是一款由小米开源的分布式监控系统，具备高性能、高可用性和易扩展的特点。以下从多个维度对其进行详细解析：1.核心特点分布式架构：模块化设计，各组件独立部署，支持水平扩展。高性能：单实例可处理百万级监控指标，采用RPC通信和数据分片优化。灵活的数据模型：支持Tag（标签）标记数据，便于多维查询。实时告警：支持多条件策略、表达式告警及依赖管理。可视化：提供Dashboard和图表，
    
                    
    • 
                    
  • 百度Android最新150道面试题及参考答案 （上）
                        大模型大数据攻城狮
android大厂面经手撕时间复杂度空间复杂度启动模式四大组件
                        
    Java的多态如何实现？在Java中，多态主要通过以下两种方式来实现：一、方法重写（Override）实现运行时多态概念基础方法重写发生在子类和父类之间。当子类定义了一个与父类中方法签名（方法名、参数列表、返回类型）完全相同的方法时，就实现了方法重写。例如，有一个父类Animal，其中有一个叫makeSound的方法，然后有一个子类Dog，Dog类重写了makeSound方法来实现狗特有的叫声。代
    
                    
    • 
                    
  • spring +kotlin 配置redis 和redis的常用方法
                        LCY133
spring后端springjava后端
                        
    在SpringBoot+Kotlin项目中，可以同时使用RedissonClient（提供分布式对象和高级功能）和RedisTemplate（SpringDataRedis的标准操作）。以下是完整配置和用法示例：1.添加依赖在build.gradle.kts中引入依赖：dependencies{//SpringDataRedisimplementation("org.springframework
    
                    
    • 
                    
  • 卫星网络仿真平台：IPLOOK赋能空天地一体化通信新生态
                        爱浦路 IPLOOK
运维
                        
    卫星仿真平台在6G技术加速演进与天地一体化网络建设的大背景下，卫星通信作为地面网络的重要补充，正成为全球通信覆盖的关键支撑。IPLOOK凭借其深厚的技术积累与创新实践，推出的卫星网络仿真平台（SCEPS），不仅填补了行业技术空白，更通过多维度功能设计与产学研深度合作，为构建空天地一体化网络提供了全栈式解决方案。一、卫星仿真平台：技术架构与核心功能IPLOOK卫星仿真平台基于“分层式、组件化、插件化
    
                    
    • 
                    
  • 4G核心网的演变与创新：从传统到虚拟化的跨越
                        爱浦路 IPLOOK
4G核心网核心网
                        
    4G核心网随着移动通信技术的不断发展，4G核心网已经经历了从传统的硬件密集型架构到现代化、虚拟化网络架构的重大转型。这一演变不仅提升了网络的灵活性和可扩展性，也为未来的5G、物联网（LOT）和边缘计算等技术的发展奠定了基础。本文将探讨4G核心网的演变过程，重点分析虚拟化技术在其中的作用，并结合我们公司IPLOOK的创新产品和解决方案，展望未来核心网的发展趋势。传统4G核心网：硬件依赖与功能分离在4
    
                    
    • 
                    
  • 数据结构：交换排序的实现
                        z_鑫
数据结构数据结构排序算法算法c语言
                        
    概要交换排序是一类通过比较和交换元素位置来实现排序的算法。其核心思想是在序列中进行两两比较，若元素顺序不符合排序要求，则交换它们的位置。常见的交换排序算法包括冒泡排序和快速排序，它们在不同场景下各有优劣。整体架构流程冒泡排序从数组的第一个元素开始，依次比较相邻的两个元素；如果前一个元素大于后一个元素（假设为升序排序），则交换这两个元素的位置；对数组中的每一对相邻元素都执行上述操作，经过一轮比较后，
    
                    
    • 
                    
  • 10初识Spring MVC框架
                        TechLens
JAVAEE笔记servletspringjava
                        
    学习内容一、回顾1.JSPModel2架构模型采用JSP+Servlet+JavaBean技术实现了页面显示、流程控制和业务逻辑的分离Jsp负责生成动态网页，只用做显示页面；Servlet负责流程控制，用来处理各种请求的分派；JavaBeans负责业务逻辑，对数据库的操作流程控制等通用逻辑以硬编码的方式实现，每次开发新的Web应用程序均需重新编写流程控制、通用逻辑代码2.WebMVC应用框架Spr
    
                    
    • 
                    
  • SGP.31/.32 规范以及它将如何影响物联网
                        SofterICer
eSIM物联网
                        
    去年，GSMA发布了适用于物联网设备的新eSIM远程配置标准的架构和要求、SGP.31eSIM物联网架构和网络受限和/或用户界面(UI)受限物联网设备中eUICC远程配置的要求。自SGP.31获得批准以来，业界一直在等待GSMA发布SGP.31的技术实施规范SGP.32。5月26日，GSMASGP.32eSIM物联网技术规范发布，为设备制造商开始受益于新标准并扩展其物联网项目铺平了道路。据物联网专
    
                    
    • 
                    
  • 【操作系统】Operating System Conceptions第二章知识整理总结
                        guozhirourou
OperatingSystemConceptions阅读OperatingSystemConceptions
                        
    小结：这几天我看了《OperatingSystemConceptions》的第二章。第二章先从用户、开发者以及计算机系统的角度开始，展示操作系统所提供的服务，继而讲解了操作系统是如何通过系统调用来为系统提供服务的，阐述一段程序是如何在系统中装入链接以及执行的。同时通过比较和对比整体、分层、微核、模块化和混合策略操作系统的不同设计，向我们展示了macOS、Android、Windows三种不同的操作
    
                    
    • 
                    
  • Transformer 架构对比：Dense、MoE 与 Hybrid-MoE 的优劣分析
                        m0_74825656
面试学习路线阿里巴巴transformer架构深度学习
                        
    1.LLM基础架构类型DenseTransformerMoE(MixtureofExperts)TransformerHybrid-MoETransformer2.Transformer按照编码方式分类单向自回归模型(如早期GPT系列)双向模型(如BERT)编码器-解码器模型(如BART,T5)DenseTransformerDenseTransformer的优势是什么DenseTransform
    
                    
    • 
                    
  • 在Mac M1/M2芯片上完美安装DeepCTR库：避坑指南与实战验证
                        ku_code_ku
机器学习macos推荐算法推荐系统
                        
    让推荐算法在AppleSilicon上全速运行概述作为推荐系统领域的最经常用的明星库，DeepCTR集成了CTR预估、多任务学习等前沿模型实现。但在AppleSilicon架构的Mac设备上，安装过程常因ARM架构适配、依赖库版本冲突等问题受阻。本文通过20+次环境搭建实测，总结出最稳定的安装方案。关键版本说明（2024年验证）组件推荐版本注意事项Python3.10.x向下兼容至3.7，但3.1
    
                    
    • 
                    
  • 软件架构设计艺术（从一个案例出发，成为优秀的软件架构师）
                        编码时空的诗意行者
软件架构设计开发语言系统架构软件设计设计模式
                        
    架构（建模）本质上是一种抽象，其目的是通过归类来减轻认知负担，避免重复思考和工作，提升计算能力。“通用”是建模的第一步，而“复用”则是确保建模有效性的关键。通过将共享属性或行为提取成独立模型，可以提高系统的灵活性和扩展性，同时也减少了错误的可能性。案例假设一家汽车经销商销售新车，并提供售后服务。客户可以在经销商处购买新车，如果车辆出现问题，可以返回经销商进行维修。我们准备为这家公司业务提供线上管理
    
                    
    • 
                    
  • OpenSSH详解：构建安全远程管理的核心技术
                        ScilogyHunter
常见软件库安全OpenSSH
                        
    OpenSSH详解：构建安全远程管理的核心技术引言在数字化时代，远程管理服务器和数据传输的安全性至关重要。OpenSSH（OpenSecureShell）作为SSH协议的开源实现，通过加密通信、身份验证和数据完整性保护，彻底解决了传统工具（如Telnet、FTP）的明文传输风险。本文将从核心原理、配置实践到高级功能，全面解析OpenSSH的技术细节与应用场景。一、OpenSSH的核心架构与工作原理
    
                    
    • 
                    
  • 构建 Python 插件架构：打造灵活可扩展的模块化应用
                        全栈探索者chen
pythonpython架构开发语言学习机器学习程序人生插件
                        
    构建Python插件架构：打造灵活可扩展的模块化应用前言在现代软件开发中，单一的代码库往往难以满足不断变化的业务需求和多样化的扩展场景。如何设计一个应用，使其既能保持核心功能的稳定，又能轻松集成第三方功能、模块或定制化扩展？答案就是——插件架构。通过插件架构，你可以让应用具备极高的灵活性，支持动态加载、无缝扩展以及解耦维护。本文将深入探讨如何在Python中设计和构建一个插件架构。从核心概念、模块
    
                    
    • 
                    
  • [Android] NFC卡模拟 9.05 模拟NFC门禁卡 电梯卡等 手机代替卡片
                        私人珍藏库
智能手机
                        
    [Android]NFC卡模拟链接：https://pan.xunlei.com/s/VOM4VZZGlLh_SLa9m6Mwh4YBA1?pwd=aeqp#【应用名称】NFC卡模拟【应用版本】9.05【软件大小】2.7mb【适用型号】安卓【应用说明】功能强大且的NFC卡模拟器，可模拟各类门禁卡、电梯卡、部分公司（工厂）工卡或饭卡、部分学校饭卡、部分图书馆借书卡等各类IC卡，用手机替代卡片去刷门禁
    
                    
    • 
                    
  • 基于WebAssembly的浏览器密码套件
                        闲人编程
wasm服务器易于集成跨平台性密码套件浏览器WebAssembly
                        
    目录一、前言二、WebAssembly与浏览器密码套件2.1WebAssembly技术概述2.2浏览器密码套件的需求三、系统设计思路与架构3.1核心模块3.2系统整体架构图四、核心数学公式与算法证明4.1AES-GCM加解密公式4.2SHA-256哈希函数五、异步任务调度与GPU加速设计5.1异步任务调度5.2GPU加速六、GUI设计与功能模块七、完整代码实现九、代码自查与总结十、总结与展望一、前
    
                    
    • 
                    
  • 基于 C++ 类的程序设计模式与应用研究
                        饼干帅成渣
c++开发语言
                        
    摘要C++语言凭借其强大的功能在软件开发领域占据重要地位，类作为C++面向对象编程的核心，承载着数据封装、代码复用等关键使命。本文深入剖析C++类的基础概念、核心特性及其在实际编程中的应用。通过详细阐述类的定义、成员构成、访问控制以及封装、继承、多态等特性，结合具体代码示例展示其在构建软件架构中的作用。同时，探讨C++类在应用中面临的常见问题及解决方案，为开发者高效运用C++类进行程序设计提供有力
    
                    
    • 
                    
  • 庖丁解java(一篇文章学java)
                        庖丁解java
java开发语言springboot后端
                        
    (大家不用收藏这篇文章,因为这篇文章会经常更新,也就是删除后重发)一篇文章学java,这是我滴一个执念...当然,真一篇文章就写完java基础,java架构,java业务实现,java业务扩展,根本不可能.所以,这篇文章,就是一个索引,索什么呢?请看下文...关于决定开始写博文的介绍(一切故事的起点源于这一次反省)中小技术公司的软扩展(微服务扩展是否有必要?)-CSDN博客SpringCloud(
    
                    
    • 
                    
  • 我与DeepSeek读《大型网站技术架构》- 总结
                        诺亚凹凸曼
架构
                        
    文章目录读后感一、总结二、反思三、创新四、展望当代大型网站架构一、架构分层模型二、关键组件与技术选型三、架构演进策略四、架构突破口读后感一、总结架构演化优先于设计大型网站架构不是预先设计的产物，而是通过反复迭代和试错演化形成的。技术选型的核心动机是对业务需求的深刻理解，而非盲目模仿。典型案例包括淘宝架构因业务爆发力被迫转型为分布式系统。开放与协作的价值互联网的开放生态通过API经济（如淘宝Open
    
                    
    • 
                    
  • 深入探讨Spring MVC：原理、架构与实践
                        luckilyil
开发框架springmvc架构
                        
    SpringMVC原理与架构解析1.SpringMVC概述SpringMVC是Spring框架中的一个模块，专注于实现Web应用的MVC设计模式。它通过将应用逻辑分为模型（Model）、视图（View）和控制器（Controller），使得开发人员能够清晰地组织代码，提高开发效率和可维护性。2.SpringMVC的核心组件SpringMVC的核心组件包括：DispatcherServlet：作为前
    
                    
    • 
                                
  • Spring中@Value注解，需要注意的地方
                                    无量
springbean@Valuexml
                                    
    Spring 3以后,支持@Value注解的方式获取properties文件中的配置值，简化了读取配置文件的复杂操作 
 
 
1、在applicationContext.xml文件(或引用文件中)中配置properties文件 
 
<bean id="appProperty"
    class="org.springframework.beans.fac
    
                                
    • 
                                
  • mongoDB 分片
                                    开窍的石头
mongodb
                                    
        mongoDB的分片。要mongos查询数据时候 先查询configsvr看数据在那台shard上，configsvr上边放的是metar信息，指的是那条数据在那个片上。由此可以看出mongo在做分片的时候咱们至少要有一个configsvr,和两个以上的shard（片）信息。 
    第一步启动两台以上的mongo服务 
&nb
    
                                
    • 
                                
  • OVER(PARTITION BY)函数用法
                                    0624chenhong
oracle
                                    
    这篇写得很好，引自 
http://www.cnblogs.com/lanzi/archive/2010/10/26/1861338.html 
 
 
OVER(PARTITION BY)函数用法 
 
 2010年10月26日 
 
OVER(PARTITION BY)函数介绍 
 
开窗函数        &nb
    
                                
    • 
                                
  • Android开发中，ADB server didn't ACK 解决方法
                                    一炮送你回车库
Android开发
                                    
    首先通知：凡是安装360、豌豆荚、腾讯管家的全部卸载，然后再尝试。 
  
一直没搞明白这个问题咋出现的，但今天看到一个方法，搞定了！原来是豌豆荚占用了 5037 端口导致。 
参见原文章：一个豌豆荚引发的血案——关于ADB server didn't ACK的问题 
简单来讲，首先将Windows任务进程中的豌豆荚干掉，如果还是不行，再继续按下列步骤排查。 
&nb
    
                                
    • 
                                
  • canvas中的像素绘制问题
                                    换个号韩国红果果
JavaScriptcanvas
                                    
    pixl的绘制，1.如果绘制点正处于相邻像素交叉线，绘制x像素的线宽，则从交叉线分别向前向后绘制x/2个像素，如果x/2是整数，则刚好填满x个像素，如果是小数，则先把整数格填满，再去绘制剩下的小数部分，绘制时，是将小数部分的颜色用来除以一个像素的宽度，颜色会变淡。所以要用整数坐标来画的话（即绘制点正处于相邻像素交叉线时），线宽必须是2的整数倍。否则会出现不饱满的像素。 
2.如果绘制点为一个像素的
    
                                
    • 
                                
  • 编码乱码问题
                                    灵静志远
javajvmjsp编码
                                    
    1、JVM中单个字符占用的字节长度跟编码方式有关，而默认编码方式又跟平台是一一对应的或说平台决定了默认字符编码方式；2、对于单个字符：ISO-8859-1单字节编码，GBK双字节编码，UTF-8三字节编码；因此中文平台(中文平台默认字符集编码GBK)下一个中文字符占2个字节，而英文平台(英文平台默认字符集编码Cp1252(类似于ISO-8859-1))。 
3、getBytes()、getByte
    
                                
    • 
                                
  • java 求几个月后的日期
                                    darkranger
calendargetinstance
                                    
    Date plandate = planDate.toDate();
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
Calendar cal = Calendar.getInstance();
cal.setTime(plandate);
// 取得三个月后时间
cal.add(Calendar.M
    
                                
    • 
                                
  • 数据库设计的三大范式（通俗易懂）
                                    aijuans
数据库复习
                                    
    关系数据库中的关系必须满足一定的要求。满足不同程度要求的为不同范式。数据库的设计范式是数据库设计所需要满足的规范。只有理解数据库的设计范式，才能设计出高效率、优雅的数据库，否则可能会设计出错误的数据库. 
目前，主要有六种范式：第一范式、第二范式、第三范式、BC范式、第四范式和第五范式。满足最低要求的叫第一范式，简称1NF。在第一范式基础上进一步满足一些要求的为第二范式，简称2NF。其余依此类推。
    
                                
    • 
                                
  • 想学工作流怎么入手
                                    atongyeye
jbpm
                                    
    工作流在工作中变得越来越重要，很多朋友想学工作流却不知如何入手。 很多朋友习惯性的这看一点，那了解一点，既不系统，也容易半途而废。好比学武功，最好的办法是有一本武功秘籍。研究明白，则犹如打通任督二脉。 
 
 
系统学习工作流，很重要的一本书《JBPM工作流开发指南》。 
 
本人苦苦学习两个月，基本上可以解决大部分流程问题。整理一下学习思路，有兴趣的朋友可以参考下。 
 
1  首先要
    
                                
    • 
                                
  • Context和SQLiteOpenHelper创建数据库
                                    百合不是茶
androidContext创建数据库
                                    
           一直以为安卓数据库的创建就是使用SQLiteOpenHelper创建,但是最近在android的一本书上看到了Context也可以创建数据库,下面我们一起分析这两种方式创建数据库的方式和区别,重点在SQLiteOpenHelper 
  
  
一:SQLiteOpenHelper创建数据库: 
  
1,SQLi
    
                                
    • 
                                
  • 浅谈group by和distinct
                                    bijian1013
oracle数据库group bydistinct
                                    
            group by和distinct只了去重意义一样，但是group by应用范围更广泛些，如分组汇总或者从聚合函数里筛选数据等。 
        譬如：统计每id数并且只显示数大于3 
select id ,count(id) from ta
    
                                
    • 
                                
  • vi opertion
                                    征客丶
macoprationvi
                                    
    进入 command mode （命令行模式） 
按 esc 键 
再按 shift + 冒号 
 
注：以下命令中 带 $ 【在命令行模式下进行】，不带 $ 【在非命令行模式下进行】 
 
一、文件操作 
1.1、强制退出不保存 
$ q! 
1.2、保存 
$ w 
1.3、保存并退出 
$ wq 
1.4、刷新或重新加载已打开的文件 
$ e 
 
二、光标移动 
2.1、跳到指定行 
数字
    
                                
    • 
                                
  • 【Spark十四】深入Spark RDD第三部分RDD基本API
                                    bit1129
spark
                                    
      
对于K/V类型的RDD,如下操作是什么含义？ 
  
val rdd = sc.parallelize(List(("A",3),("C",6),("A",1),("B",5))
rdd.reduceByKey(_+_).collect 
 reduceByKey在这里的操作，是把
    
                                
    • 
                                
  • java类加载机制
                                    BlueSkator
java虚拟机
                                    
    java类加载机制 
1.java类加载器的树状结构 
引导类加载器 
^ 
| 
扩展类加载器 
^ 
| 
系统类加载器 
java使用代理模式来完成类加载，java的类加载器也有类似于继承的关系，引导类是最顶层的加载器，它是所有类的根加载器，它负责加载java核心库。当一个类加载器接到装载类到虚拟机的请求时，通常会代理给父类加载器，若已经是根加载器了，就自己完成加载。 
虚拟机区分一个Cla
    
                                
    • 
                                
  • 动态添加文本框
                                    BreakingBad
文本框
                                    
      <script>     var num=1; function AddInput() {      var str="";     str+="<input 
    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-单例模式
                                    bylijinnan
java设计模式
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 



public class Singleton {
}

/*
 * 懒汉模式。注意，getInstance如果在多线程环境中调用，需要加上synchronized，否则存在线程不安全问题
 */
class LazySingleton
    
                                
    • 
                                
  • iOS应用打包发布常见问题
                                    chenhbc
iosiOS发布iOS上传iOS打包
                                    
    这个月公司安排我一个人做iOS客户端开发，由于急着用，我先发布一个版本，由于第一次发布iOS应用，期间出了不少问题，记录于此。 
  
1、使用Application Loader 发布时报错：Communication error.please use diagnostic mode to check connectivity.you need to have outbound acc
    
                                
    • 
                                
  • 工作流复杂拓扑结构处理新思路
                                    comsci
设计模式工作算法企业应用OO
                                    
     我们走的设计路线和国外的产品不太一样，不一样在哪里呢？  国外的流程的设计思路是通过事先定义一整套规则(类似XPDL)来约束和控制流程图的复杂度(我对国外的产品了解不够多，仅仅是在有限的了解程度上面提出这样的看法)，从而避免在流程引擎中处理这些复杂的图的问题，而我们却没有通过事先定义这样的复杂的规则来约束和降低用户自定义流程图的灵活性，这样一来，在引擎和流程流转控制这一个层面就会遇到很
    
                                
    • 
                                
  • oracle 11g新特性Flashback data archive
                                    daizj
oracle
                                    
    1. 什么是flashback data archive 
 
Flashback data archive是oracle 11g中引入的一个新特性。Flashback archive是一个新的数据库对象，用于存储一个或多表的历史数据。Flashback archive是一个逻辑对象，概念上类似于表空间。实际上flashback archive可以看作是存储一个或多个表的所有事务变化的逻辑空间。 
    
                                
    • 
                                
  • 多叉树:2-3-4树
                                    dieslrae
树
                                    
        平衡树多叉树,每个节点最多有4个子节点和3个数据项,2,3,4的含义是指一个节点可能含有的子节点的个数,效率比红黑树稍差.一般不允许出现重复关键字值.2-3-4树有以下特征: 
    1、有一个数据项的节点总是有2个子节点(称为2-节点) 
    2、有两个数据项的节点总是有3个子节点(称为3-节
    
                                
    • 
                                
  • C语言学习七动态分配 malloc的使用
                                    dcj3sjt126com
clanguagemalloc
                                    
    /*
	2013年3月15日15:16:24
	malloc 就memory(内存) allocate(分配)的缩写
	本程序没有实际含义，只是理解使用	
 */
# include <stdio.h>
# include <malloc.h>

int main(void)
{
	int i = 5;	//分配了4个字节 静态分配
	int * p 
    
                                
    • 
                                
  • Objective-C编码规范[译]
                                    dcj3sjt126com
代码规范
                                    
         
 
  
  原文链接 : The official raywenderlich.com Objective-C style guide  
  原文作者 : raywenderlich.com Team  
  译文出自 : raywenderlich.com Objective-C编码规范  
  译者 : Sam Lau  
  
    
                                
    • 
                                
  • 0.性能优化-目录
                                    frank1234
性能优化
                                    
    从今天开始笔者陆续发表一些性能测试相关的文章，主要是对自己前段时间学习的总结，由于水平有限，性能测试领域很深，本人理解的也比较浅，欢迎各位大咖批评指正。 
主要内容包括： 
一、性能测试指标 
吞吐量、TPS、响应时间、负载、可扩展性、PV、思考时间 
http://frank1234.iteye.com/blog/2180305 
 
二、性能测试策略 
生产环境相同 基准测试 预热等 
htt
    
                                
    • 
                                
  • Java父类取得子类传递的泛型参数Class类型
                                    happyqing
java泛型父类子类Class
                                    
      
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

import org.junit.Test;

abstract class BaseDao<T> {
	public void getType() {
		//Class<E> clazz =
    
                                
    • 
                                
  • 跟我学SpringMVC目录汇总贴、PDF下载、源码下载
                                    jinnianshilongnian
springMVC
                                    
      
----广告-------------------------------------------------------------- 
网站核心商详页开发 
掌握Java技术，掌握并发/异步工具使用，熟悉spring、ibatis框架； 
掌握数据库技术，表设计和索引优化，分库分表/读写分离； 
了解缓存技术，熟练使用如Redis/Memcached等主流技术； 
了解Ngin
    
                                
    • 
                                
  • the HTTP rewrite module requires the PCRE library
                                    流浪鱼
rewrite
                                    
    ./configure: error: the HTTP rewrite module requires the PCRE library. 
模块依赖性Nginx需要依赖下面3个包 
1. gzip 模块需要 zlib 库 ( 下载: http://www.zlib.net/ ) 
2. rewrite 模块需要 pcre 库 ( 下载: http://www.pcre.org/ ) 
3. s
    
                                
    • 
                                
  • 第12章 Ajax（中）
                                    onestopweb
Ajax
                                    
    index.html 
<!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/
    
                                
    • 
                                
  • Optimize query with Query Stripping in Web Intelligence
                                    blueoxygen
BO
                                    
    http://wiki.sdn.sap.com/wiki/display/BOBJ/Optimize+query+with+Query+Stripping+in+Web+Intelligence 
and a very straightfoward video 
http://www.sdn.sap.com/irj/scn/events?rid=/library/uuid/40ec3a0c-936
    
                                
    • 
                                
  • Java开发者写SQL时常犯的10个错误
                                    tomcat_oracle
javasql
                                    
    1、不用PreparedStatements   　　有意思的是，在JDBC出现了许多年后的今天，这个错误依然出现在博客、论坛和邮件列表中，即便要记住和理解它是一件很简单的事。开发者不使用PreparedStatements的原因可能有如下几个：   　　他们对PreparedStatements不了解   　　他们认为使用PreparedStatements太慢了   　　他们认为写Prepar
    
                                
    • 
                                
  • 世纪互联与结盟有感
                                    阿尔萨斯

                                    
     10月10日，世纪互联与（Foxcon）签约成立合资公司，有感。 
 全球电子制造业巨头（全球500强企业）与世纪互联共同看好IDC、云计算等业务在中国的增长空间，双方迅速果断出手，在资本层面上达成合作，此举体现了全球电子制造业巨头对世纪互联IDC业务的欣赏与信任，另一方面反映出世纪互联目前良好的运营状况与广阔的发展前景。 
 众所周知，精于电子产品制造（世界第一），对于世纪互联而言，能够与结盟
    
                                
    •