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,安卓,业界资讯)






    

  • Android和IOS应用开发-Flutter应用让屏幕在 app 运行期间保持常亮的方法
江上清风山间明月
FlutterandroidiosflutterKeepAlive屏幕常亮wakelock熄屏

    文章目录Flutter应用让屏幕在app运行期间保持常亮的方法方法一：使用系统插件方法二：使用Widgets注意事项Flutter应用让屏幕在app运行期间保持常亮的方法在Flutter开发中，可以使用以下两种方法让屏幕在app运行期间保持常亮：方法一：使用系统插件Flutter社区中已经有很多相关插件可供使用，比如wakelock:https://pub.dev/packages/wakeloc
    

    • 

  • android 自定义曲线图,Android自定义View——贝赛尔曲线
weixin_39767513
android自定义曲线图

    个人博客：haichenyi.com。感谢关注本文针对有一定自定义View的童鞋，最好对贝赛尔曲线有辣么一丢丢了解，不了解也没关系。花5分钟看一下GcsSloop的安卓自定义View进阶-Path之贝塞尔曲线。本文的最终效果图：最终效果图.gif思路首先他是一个只有上半部分的正弦形状的水波纹，很规则。其次，他这个正弦图左右在移动。然后，就是它这个自定义View，上下也在移动，是慢慢增加的最后，优化
    

    • 

  • Mac命令行查找SDK/JDK安装位置
iblade
Linuxmacosjava开发语言

    要在命令行中查询AndroidSDKPlatformTools的安装位置，可以使用以下步骤：使用which命令：在命令行中执行以下命令：whichadb这将输出adb命令的安装路径，通常情况下，它会在AndroidSDK的platform-tools目录下。手动查找：如果whichadb没有输出，可以手动查找AndroidSDK的安装位置。通常情况下，AndroidSDK的默认安装路径是在用户的h
    

    • 

  • 下载Android源码
赛非斯

    repoinit-uhttps://mirrors.tuna.tsinghua.edu.cn/git/AOSP/platform/manifest-bandroid-10.0.0_r411.首先下载repo：a）终端运行gitclonegit://codeaurora.org/tools/repo.gitb）mkdir~/binc）拷贝repo到~/bin下面，修改repo权限，chmoda+x~
    

    • 

  • 1.计算机处理器架构+嵌入式处理器架构及知识
vv 啊
arm-linux学习linux系统架构

    目录一：x86-64处理器架构二：Intel80386处理器（i386）1.i3862.i686三：嵌入式Linux知识：1.MinGW2.GNU计划2.1GNU工具链概述此次只分享英特尔和ADM处理器有关于x86的架构，至于嵌入式处理器架构请查看https://en.wikipedia.org/wiki/List_of_ARM_processors一：x86-64处理器架构x86-64，也称为x
    

    • 

  • 使用多线程的方式模拟高并发请求接口，用于自测接口的稳定性【项目】
还算善良_
私有代码库工具类javalist数据结构

    packagecom.gitee.taven.test;importcom.gitee.taven.ApiResult;importcom.gitee.taven.aop.RepeatSubmitAspect;importorg.slf4j.Logger;importorg.slf4j.LoggerFactory;importorg.springframework.beans.factory.an
    

    • 

  • 通俗易懂：什么是Java虚拟机（JVM）？它的主要作用是什么？
大龄下岗程序员
mysqljavamysqlspring

    Java虚拟机（JavaVirtualMachine,JVM）是一种软件实现的抽象计算机，它负责执行Java字节码（Bytecode）。Java程序并不是直接在物理计算机上运行，而是先由Java编译器将源代码编译成与平台无关的字节码，然后由JVM负责读取字节码并在实际硬件架构上运行。JVM的主要作用包括以下几个方面：1.跨平台性-JVM是Java语言“一次编写，到处运行”（WriteOnce,Ru
    

    • 

  • flutter 修改app名字和图标
肥肥呀呀呀
flutter

    一、修改名字在Android中修改应用程序名称：在AndroidManifest.xml文件中修改应用程序名称：打开Flutter项目中的android/app/src/main/AndroidManifest.xml文件。找到标签，然后在android:label属性中修改应用程序的名称，例如：android:label="YourNewAppName"。在strings.xml文件中修改应用程
    

    • 

  • eclipse导入项目 warning报错 org.springframework.ide.eclipse.core.springnature
zhangfeng1133
ideeclipsejava

    报错org.springframework.ide.eclipse.core.springnature报错信息"org.springframework.ide.eclipse.core.springnature"通常表示EclipseIDE中与Spring框架集成的插件出现了问题。这个错误可能是因为SpringIDE插件没有正确安装或配置，或者Eclipse的更新过程中出现了问题。解决方法：确认S
    

    • 

  • 安卓笔记本 - Handler Message MessageQueue Looper
SocialException

    不爱写字，一张图解决。Handler,Message,MessageQueue,Looper工作原理
    

    • 

  • Apache Kafka的伸缩性探究：实现高性能、弹性扩展的关键
i289292951
kafkakafka

    引言ApacheKafka作为当今最流行的消息中间件之一，以其强大的伸缩性著称。在大数据处理、流处理和实时数据集成等领域，Kafka的伸缩性为其在面临急剧增长的数据流量和多样化业务需求时提供了无与伦比的扩展能力。本文将深入探讨Kafka如何通过其独特的架构设计实现高水平的伸缩性，以及在实际部署中如何优化和利用这一特性。一、Kafka伸缩性的核心设计分区（Partitioning）与水平扩展Kafk
    

    • 

  • Android 系统应用 pk8签名文件转jks或keystore教程
蜗牛、Z
AOSPandroidFrameworkandroidaosp系统应用开发

    一、介绍签名文件对于我们在做应用开发中，经常遇到，且签名文件不仅仅是保护应用安全，还会涉及到应用与底层之间的数据共享和API文件等问题。在Android中，签名文件同样也存在这个问题。但是android中又区分系统应用和普通应用。系统应用可以通过android:sharedUserId="android.uid.system"同享系统uid，可以获取更高的权限。所以在做系统应用开发的时候，经常需要
    

    • 

  • Nginx服务
老伙子53
nginx运维

    Nginx服务一、什么是Nginx1、概念Nginx是一个高性能的开源的HTTP和反向代理服务器，以及邮件（IMAP/POP3）代理服务器。它最初由IgorSysoev创建，并于2004年首次公开发布。Nginx的主要特点包括高性能、低内存占用、高并发处理能力以及高度的可靠性。2、特点高性能Nginx被设计成高性能的服务器软件，能够处理大量并发连接和高流量的请求。它采用了事件驱动的架构，使用异步I
    

    • 

  • ReactNative应用打包后无网络解决方案
程序猿也会飞
最佳实践reactnativeandroidreact.js

    ReactNative打包应用后，应用没有网络解决方案：在android\app\src\main\res下创建xml文件夹在xml文件夹中创建network_security_config.xml文件network_security_config.xml内容：在android\app\src\main文件夹AndroidManifest.xml文件内的Application标签中添加属性andr
    

    • 

  • Kafka、ActiveMQ、RabbitMQ 及 RocketMQ区别比较
木西爷
kafkaactivemqrabbitmq阿里云rocketmq

    消息队列中间件是分布式系统中重要的组件，主要解决应用耦合、异步消息、流量削锋等问题。它可以实现高性能、高可用、可伸缩和最终一致性架构，是大型分布式系统不可缺少的中间件。消息队列在电商系统、消息通讯、日志收集等应用中扮演着关键作用，以阿里为例，其研发的消息队列（RocketMQ）在历次天猫“双十一”活动中支撑了万亿级的数据洪峰，为大规模交易提供了有力保障。常见消息中间件对比特性ActiveMQRab
    

    • 

  • git使用代理解决无法clone的问题及git代理设置
yaningli

    在使用git的时候,经常需要去国外的一些网站clone,由于众所周知的原因,clone失败例如:$gitclonehttps://android.googlesource.com/platform/packages/apps/MessagingCloninginto‘Messaging’…fatal:unabletoaccess‘https://android.googlesource.com/p
    

    • 

  • 程序员开发技术整理
laizhixue
学习前端框架

    前端技术：vue-前端框架element-前端框架bootstrap-前端框架echarts-图标组件C#后端技术：webservice：soap架构：简单的通信协议，用于服务通信ORM框架：对象关系映射，如EF：对象实体模型，是ado.net中的应用技术soap服务通讯：xml通讯ado.net：OAuth2:登录授权认证：Token认证：JWT：jsonwebtokenJava后端技术：便捷工
    

    • 

  • 日精进
石淑萍

    【早上好#淑萍#20230605日精进335】分享嘉宾：海明教练社群运营架构专家全域流量孵化教练个人品牌超千万利润打造高手基本的创业者，对于商业模式的设计都是有漏洞的。股权架构今天我们讲的商业模式主要是盈利模式。很多社群运营会做裂变，不会做转化，因为没有后端的设计。不断的去积累，思考有哪些模式，需要去如何设计。政策领域：政府补贴➕大学生技术/大学生创业团队盈利模型——赋能板块核心一：长期锁客—资格
    

    • 

  • Websocket服务监听收发消息
beiback
Java服务器问题websocket网络协议网络

    目录1.pom依赖坐标2.项目配置端口和项目包名2.创建处理器3.注册处理器4.前端页面1.pom依赖坐标org.springframework.bootspring-boot-starter-websocket2.项目配置端口和项目包名application.propertiesserver.port=8088//路径规范：为应用的所有servlet提供一个统一的前缀，使URL结构更加清晰和一致
    

    • 

  • Mysql数据库MariaDB数据库MHA高可用程序
yichen_china

    声明：本次实验使用的是MariaDB数据库，所以本文中所出现的MariaDB与MySQL都是指的是MariaDB！！！MHA（MasterHA）是一款开源的MySQL的高可用程序，它为MySQL主从复制架构提供了automatingmasterfailover功能。MHA在监控到master节点故障时，会提升其中拥有最新数据的slave节点成为新的master节点，在此期间，MHA会通过于其它从节
    

    • 

  • “异步”是什么意思？
小林想被监督学习
系统架构设计师面试计算机基础java开发语言

    含义“异步”在计算机科学中，指的是一种操作模式，其中操作被发起后，不必等待该操作完成，可以继续执行其他任务。也就是说异步操作不会去阻塞后续代码的执行，当操作完成时，通常会通过回调函数、事件或其他机制来通知应用程序。例子例如在事件驱动架构风格中，异步通信是核心特性之一。事件的生产者（发布者）发布了事件以后，不会等待任何消费者（订阅者）的响应，继续执行后续的任务。消费者感知到事件触发了以后，就自己安排
    

    • 

  • 基于SSM+Vue企业销售培训系统 企业人才培训系统 企业课程培训管理系统 企业文化培训班系统Java
计算机程序老哥

    作者主页：计算机毕业设计老哥有问题可以主页问我一、开发介绍1.1开发环境开发语言：Java数据库：MySQL系统架构：B/S后端：SSM(Spring+SpringMVC+Mybatis)前端：Vue工具：IDEA或者Eclipse，JDK1.8，Maven二、系统介绍2.1图片展示注册登录页面：登陆.png前端页面功能：首页、培训班、在线学习、企业文化、交流论坛、试卷列表、系统公告、留言反馈、个
    

    • 

  • Vue 发送Ajax请求多种方式
Red丶哞
前端vue.jsajax前端

    1.发送ajax请求的方式方案一：jq的ajax（在vue中不推荐同时使用）方案二：js原始官方fetch方法方案三：axios第三方2.方案一后端视图函数fromrest_framework.viewsetsimportViewSetfromrest_framework.responseimportResponseclassIndex(ViewSet):defindex(self,request
    

    • 

  • 华为广告打包报错，问题思考
学知识拯救世界
android华为

    华为广告打包时报错fata日志不一样能反映出完整的错误日志信息，仅看fata日志具有误导性，有可能指向错误的方向。通过看完整的日志可见，错误的原因为Causedby:java.lang.ClassNotFoundException:com.huawei.hms.ads.base.R$dimenfata日志2024-03-2520:24:27.6743737-3737AndroidRuntimeus
    

    • 

  • c#IQueryable和IEnumberable的区别
彭小彭~
c#基础c#

    IQueryable和IEnumerable是C#中处理集合的两个重要接口，常用于LINQ查询。它们有一些关键区别，适用于不同的场景：1.执行查询的位置IEnumerable:当你对一个IEnumerable序列使用LINQ操作时，这些操作是在本地内存中执行的。如果IEnumerable表示数据库中的数据（例如，使用EntityFramework时），那么整个数据集首先会被加载到内存中，然后再应用
    

    • 

  • Linux系统及操作 (04)
3s不会飞
Linux基础常识linux运维服务器

    Linux系统及操作(03)RPM软件包网络下载对应软件包光盘镜像文件，具备软件包Windows系统软件包的管理可以指定安装位置安装是集中安装到一个目录Linux系统与Windows系统相反。常见的软件包（生态）类型电脑入侵99%都是通过软件包的漏洞进行的。window生态Android生态ios生态rpm软件包：扩展名为.rpm,适用于RedHat系统。deb软件包：扩展名为.deb适用于Deb
    

    • 

  • Nagios安装部署全攻略
weixin_34109408
memcachedphp操作系统

    概述：公司的生产机器一共有12台，2台LVS(主备)、2台nginx、2台tomcat、1台后台服务器(nginx_tomcat)、3台mysql(主+备+异地灾备)、1台图片服务器、2台memcached.可以看出网站的架构就是基于高可用的原理的，每个层面都做了主备、系统的PV不高，对于并发布，高性能没有那么苛求，对于系统安全、稳定有较高要求，前期已经对系统做了各种日志分析，WAF配置，漏洞扫面
    

    • 

  • 谈谈我对微服务架构的理解&微服务架构有什么作用
Layla_c
webjave架构微服务云原生

    一、谈谈我对微服务架构的理解微服务架构，一种在现代化软件开发中广泛应用的架构模式，其核心理念在于将大型的、复杂的应用程序拆分为一系列小型的、松耦合的服务。每个服务都围绕着特定的业务功能或领域组件进行构建，并独立地运行在自己的进程中。这些服务通过轻量级的通信机制进行交互，通常使用HTTP/RESTfulAPI，以完成业务逻辑和数据的协同工作。微服务架构的优势主要体现在以下几个方面：首先，它提高了系统
    

    • 

  • haproxy的无缝热重启的实现原理
码农心语
高性能c++开发LINUXhaproxyseamlessreload无缝热重启

    目录1.引言2.HAPROXY的准无缝热加载方案3.支持零宕机时间、零延迟的热加载方案3.1multibinder的实现3.2HAProxy启动脚本包装器的实现1.引言  在构建高可用的负载均衡架构时，HAProxy（HighAvailabilityProxy）作为一种可靠而强大的解决方案，被广泛应用于各种网络服务负载均衡环境中。HAProxy通过分发请求到多个后端服务器，实现了负载均衡和故障恢复
    

    • 

  • gdb、mdb、docx、xlsx、pdf、图片、txt多格式文件集成预览
开源GIS地图与信创

    近期闭关研究了新成果，实现了gdb、mdb、docx、xlsx、pdf、图片、txt多格式文件集成预览。软件采用B/S架构，可代替ArcGISServer、GeoServer、MapServer等多种GIS引擎。软件只有20M大小，可运行于多种老旧Windows电脑以及国产化电脑桌面软件，免安装，双击即启动，叉掉即关闭支持gdb、mdb、docx、xlsx、pdf、txt、png、jpg、gif、
    

    • 

  • 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业务的欣赏与信任，另一方面反映出世纪互联目前良好的运营状况与广阔的发展前景。
众所周知，精于电子产品制造（世界第一），对于世纪互联而言，能够与结盟
    

    •