自己做了个下拉加载组件  发现在ios弹性情况下不会出现预期的效果，在网上找了很久，自己也思考了很久总结了三个方法，来实现ios的兼容。
首先思考：ios为什么会出现情况？

发现：在ios弹性触发的情况下   微信的监听页面滑动事件（onPageScroll）的 e.scrollTop会出现负数，且 ios弹性会遮挡住隐藏view的出现
1.利用catch

判断下拉事件需要用到的三个事件， touchstart（触摸开始），touchend（触摸结束），touchmove （触摸时）。当它们都使用catch时，发现ios是可以实现与安卓一样的效果（猜测：因为catch事件阻止了冒泡，所以iOS的弹性情况被catch遮挡住，阻止掉了）
缺点：此事件会存在在catch事件包含内的事件无法点击
catchtouchstart="start_fn" catchtouchend="end_fn" catchtouchmove="move_fn"

2.在微信的.json配置"disableScroll": true

在需要用到的文件下的.json文件中配置"disableScroll": true   （猜测：因为"disableScroll": true 的配置是定义了此页面不允许上下滑动，而阻止了ios的弹性）
缺点：该页面将不能进行上下滑动
3.运用微信的animation  运用动画效果将被隐藏的view显示出来
  onPageScroll: function (e) {
    if(e.scrollTop<-10){
      this.data.index_scrollTop = false
    }
  },

const animation = wx.createAnimation({
  duration: 10,
  timingFunction: 'step-start',
})
 this.animation = animation
 animation.translateY(-46).step()
 this.setData({
   animation: animation.export()
 })
 setTimeout(function () {
   animation.translateY(0).step()
   that.setData({
     animation: animation.export()
   })
 }, 1000)

背景

在容器技术普及之前，事件驱动在数据库领域中被广泛使用。这个概念模型很简单：每当添加、更改或删除数据时，会触发一个事件来执行各种操作。事件驱动的方式可以在非常短的时间内，完成后续动作的执行。事件驱动架构的核心是对系统上的各种事件做出反应并执行相应的动作。弹性伸缩已成为几乎所有云平台中不可或缺的组成部分。Kubernetes中，容器水平伸缩器HPA（Horizontal Pod Autoscaler）是最常用的应用弹性方案。容器水平伸缩的核心是基于资源利用率与预设的阈值水位之间的关系，来确认伸缩的计划。容器水平伸缩的方式具有使用简单、资源指标丰富等特点，但是它对于需要即时弹性的场景，尤其是对基于事件源进行离线作业支撑不足。ACK提供了ack-keda来提供事件驱动弹性能力，事件驱动弹性适用于音视频离线转码、事件驱动作业、流式数据处理等场景。

事件驱动弹性原理

ACK通过增强版本的ack-keda来提供事件驱动弹性能力，下图是ack-keda的基本原理。



ack-keda会从事件源中进行数据的周期性消费。当消息出现堆积，即可秒级触发一个批次的离线任务伸缩。下一个周期到来时，会异步进行下一个批次的作业伸缩。ack-keda具有以下特性：

丰富的事件源

	ack-keda内置支持Kafka、MySQL、PostgreSQL、Rabbitmq、Redis等多种内置数据源。同时支持从客户自定义的事件源获取事件并进行Job或者pod维度的弹性缩放。
	
离线任务的并发控制

	对于大规模的离线作业而言，底层管控的稳定性会面临比较大的挑战，需要提供资源、额度、API请求的整体控制。ack-keda提供了单批次、总批次的任务并发控 制，保障系统的稳定性。
	
结束任务后自动清理元数据&&支持任务回溯

	大规模离线作业执行完毕后，会留存大量的元数据信息。元数据信息的堆积会造成APIServer的稳定性下降，造成集群的性能下降、稳定性不足，甚至可能影响其 他的业务。ack-keda会在任务执行结束后自动清理元数据，降低元数据的量级。同时，ack-keda也支持保留一些执行失败的Job，便于回溯，定位原因。
事件驱动弹性转码案例

在本案例中，我们准备一个简单的转码作业，当有一个新任务到来的时候会向mongoDB插入一条类似下面的数据{"type":"mp4","state":"waiting","createTimeStamp":"1610332940","fileName":"World and peace","endTimeStamp":"","uuid":"1fae72ff-3239-42f5-af97-04711d8007e8"}，此时，容器服务的事件驱动控制器会从数据库中查询到状态为"state":"waiting"的作业，弹出与任务数目匹配的Job Pod来承载转码作业，完成转码业务并将数据中的state字段从之前的waiting修改成finished。同时Job完成后，自动清理，降低元数据对APIServer带来的压力，极大的减轻开发者的负担。

1.安装事件驱动弹性控制器 - ack-keda

登录阿里云容器服务kubernetes控制台，点击左侧边栏的应用市场，搜索ack-keda
	
选择对应集群，点击部署，部署到该集群
	
选择左侧边栏的工作负载，选择无状态服务，选择kube-system 命名空间，确认ack-keda部署成功
2.部署基于mongoDB事件源驱动弹性示例

1.部署mongoDB

创建mongoDB.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: mongodb
spec:
  replicas: 1
  selector:
    matchLabels:
      name: mongodb
  template:
    metadata:
      labels:
        name: mongodb
    spec:
      containers:
      - name: mongodb
        image: mongo:4.2.1
        imagePullPolicy: IfNotPresent
        ports:
        - containerPort: 27017
          name: mongodb
          protocol: TCP
---
kind: Service
apiVersion: v1
metadata:
  name: mongodb-svc
spec:
  type: ClusterIP
  ports:
  - name: mongodb
    port: 27017
    targetPort: 27017
    protocol: TCP
  selector:
    name: mongodb

执行kubectl apply -f mongoDB.yaml -n mongodb部署到集群。
2.mongoDB新建User

// 新建用户
kubectl exec -n mongodb mongodb-xxxxx -- mongo --eval 'db.createUser({ user:"test_user",pwd:"test_password",roles:[{ role:"readWrite", db: "test"}]})'
// 登陆认证
kubectl exec -n mongodb mongodb-xxxxx -- mongo --eval  'db.auth("test_user","test_password")'
// 新建collection
kubectl exec -n mongodb mongodb-xxxxx -- mongo --eval  'db.createCollection("test_collection")'

3.部署TriggerAuthentication和ScaledJob

创建TriggerAuthentication
TriggerAuthentication是用来登录mongoDB查询数据时认证使用，TriggerAuthentication中的secretTargetRef字段会将指定Secret中的数据读取到ack-keda中，完成对Mongo的登录认证。

apiVersion: keda.sh/v1alpha1
kind: TriggerAuthentication
metadata:
  name: mongodb-trigger
spec:
  secretTargetRef:
    - parameter: connectionString
      name: mongodb-secret
      key: connect
---
apiVersion: v1
kind: Secret
metadata:
  name: mongodb-secret
type: Opaque
data:
  connect: bW9uZ29kYjovL3Rlc3RfdXNlcjp0ZXN0X3Bhc3N3b3JkQG1vbmdvZGItc3ZjLm1vbmdvZGIuc3ZjLmNsdXN0ZXIubG9jYWw6MjcwMTcvdGVzdA==

执行kubectl apply -f auth.yaml -n mongodb-test到集群。
	
创建ScaledJob
ScaledJob主要用来配置Job模板以及指定查询的数据库及查询表达式等，这里我们配置的是从test数据库中的test_collection中，查询满足{"type":"mp4","state":"waiting"}的待转码数据。

apiVersion: keda.sh/v1alpha1
kind: ScaledJob
metadata:
  name: mongodb-job
spec:
  jobTargetRef:
    // Job模板配置
    template:
      spec:
        containers:
          - name: mongo-update
            image: registry.cn-hangzhou.aliyuncs.com/carsnow/mongo-update:v6
            args:
              - --connectStr=mongodb://test_user:test_password@mongodb-svc.mongodb.svc.cluster.local:27017/test
              - --dataBase=test
              - --collection=test_collection
            imagePullPolicy: IfNotPresent
        restartPolicy: Never
    backoffLimit: 1
  pollingInterval: 15
  maxReplicaCount: 5
  successfulJobsHistoryLimit: 0
  failedJobsHistoryLimit: 10
  triggers:
    - type: mongodb
      metadata:
        dbName: test                                        //要查询的数据库
        collection: test_collection                //要查询的collection
        query: '{"type":"mp4","state":"waiting"}'  //会对查询转码类型为mp4且状态是waiting的数据拉起job进行处理
        queryValue: "1"
      authenticationRef:
        name: mongodb-trigger

执行kubectl apply -f scaledJob.yaml -n mongodb-test到集群。
4.插入待转码业务数据

// 插入5条待转码数据
kubectl exec -n mongodb mongodb-xxxxx -- mongo --eval 'db.test_collection.insert([
  {"type":"mp4","state":"waiting","createTimeStamp":"1610352740","fileName":"My Love","endTimeStamp":"","uuid":"1gae72ff-3239-42f5-af97-04711d8007e8"},
  {"type":"mp4","state":"waiting","createTimeStamp":"1610350740","fileName":"Harker","endTimeStamp":"","uuid":"1gae72ff-3239-42f5-af97-04711d8007e8"},
  {"type":"mp4","state":"waiting","createTimeStamp":"1610152940","fileName":"The World","endTimeStamp":"","uuid":"1gae72ff-3239-42f5-af97-04711d87767e8"},
  {"type":"mp4","state":"waiting","createTimeStamp":"1610390740","fileName":"Mother","endTimeStamp":"","uuid":"1gae72ff-3239-42f5-af97-04799d8007e8"},
  {"type":"mp4","state":"waiting","createTimeStamp":"1610344740","fileName":"Jagger","endTimeStamp":"","uuid":"1gae72ff-3239-42f5-af97-04711d80099e8"},
  ])'

5.查看Job动态

// watch job
watch -n 1 kubectl get job -n mongodb-test



可以看到成功扩展出5个Job。此时再登录数据库，观察转码业务状态，可以看到数据状态已经从waiting变成了finished。



写在最后

本文介绍的转码业务实际也是我们在日常场景经常会遇到的一个需求，看得出来ack-keda的使用，相对来说还是比较容易的，而且实际效果也能满足我们日常的需求。我们最近在keda社区的基础上，新增了对于mongoDB事件源的支持，并已PR到社区，至此，内置的事件源已经能够满足我们绝大部分事件驱动场景。

原文链接

本文为阿里云原创内容，未经允许不得转载。

知道了View的滑动，我们还要知道如何实现View的弹性滑动，比较生硬的滑动过去，这种方式的用户体验太差了，因此我们要实现渐进式滑动。那么如何实现弹性滑动呢？其实实现方法有很多，但它们都有一个共同思想：将一次大的滑动分成若干次小的滑动，并在一个事件内完成，弹性滑动的具体实现方式有很多，比如通过Scroller、Handler#postDelayed以及Thread#Sleep等，下面一一进行介绍。
1.使用Scroller
Scroller在前面已经进行了介绍，下面我们来分析以下它的源码，从而探究为什么它能实现View的弹性滑动。

    Scroller scroller = new Scroller(mContext);

    //缓慢滑动到指定位置
    private void smoothScrollTo(int destX,int destY){
        int scrollX = getScrollX();
        int deltaX = destX - scrollX;
        //1000ms内滑向destX,效果就是慢慢滑动
        scroller.startScroll(scrollX,0,deltaX, 0,1000);
        invalidate();
    }

    @Override
    public void computeScroll() {
        if (scroller.computeScrollOffset()) {
            scrollTo(scroller.getCurrX(), scroller.getCurrY());
            postInvalidate();
        }
    }
上面是Scroller的典型的使用方法，这里先描述它的工作原理：当我们构造一个Scroller对象并且调用它的startScroll方法时，Scroller内部其实什么也没有做，它只是保存了我们传递的几个参数，这几个参数从startScroll的原型上就可以看出来，如下所示。

    public void startScroll(int startX, int startY, int dx, int dy, int duration) {
        mMode = SCROLL_MODE;
        mFinished = false;
        mDuration = duration;
        mStartTime = AnimationUtils.currentAnimationTimeMillis();
        mStartX = startX;
        mStartY = startY;
        mFinalX = startX + dx;
        mFinalY = startY + dy;
        mDeltaX = dx;
        mDeltaY = dy;
        mDurationReciprocal = 1.0f / (float) mDuration;
    }
这个方法的参数含义很清楚，startX和startY表示的是滑动的起点，dx和dy表示的是滑动的距离，而duration表示的是滑动的时间，即整个滑动过程完成所需要的时间，注意这里的滑动式指View内容的滑动而非View本身位置的改变。可以看到，仅仅调用startScroll方法式无法让View滑动的，因为它内部并没有做滑动的相关的事，那么Scroller到底事如何让View弹性滑动的呢？答案就是startScroll方法下面的invalidate方法，虽然有点不可思议，但是的确是这样的。invalidate方法导致View重绘，在View的draw方法中又会去调用computeScroll方法，computeScroll在View中是一个空实现，因此需要我们自己去实现，上面的代码已经实现了computeScroll方法。正是因为这个computeScroll方法，View才能实现弹性滑动。这看起来还是很抽象的，其实这样的：当View重绘后会在draw方法中调用computeScroll，而computeScroll又回去向Scroller获取当前的scrollX和scrollY；然后通过scrollTo方法实现滑动；接着又调用postInvalidate方法来进行第二次重绘，这一次的重绘过程和第一次重绘一样，还是会导致computeScroll方法被调用；然后继续向Scroller获取当前的scrollX和scrollY，并通过scrollTo方法滑动到新的位置，如此反复，直到整个滑动过程结束。
我们再看以下Scroller的computeScrollOffset方法的实现，如下所示。
    public boolean computeScrollOffset() {
        if (mFinished) {
            return false;
        }

        int timePassed = (int)(AnimationUtils.currentAnimationTimeMillis() - mStartTime);
    
        if (timePassed < mDuration) {
            switch (mMode) {
            case SCROLL_MODE:
                final float x = mInterpolator.getInterpolation(timePassed * mDurationReciprocal);
                mCurrX = mStartX + Math.round(x * mDeltaX);
                mCurrY = mStartY + Math.round(x * mDeltaY);
                break;
            case FLING_MODE:
                final float t = (float) timePassed / mDuration;
                final int index = (int) (NB_SAMPLES * t);
                float distanceCoef = 1.f;
                float velocityCoef = 0.f;
                if (index < NB_SAMPLES) {
                    final float t_inf = (float) index / NB_SAMPLES;
                    final float t_sup = (float) (index + 1) / NB_SAMPLES;
                    final float d_inf = SPLINE_POSITION[index];
                    final float d_sup = SPLINE_POSITION[index + 1];
                    velocityCoef = (d_sup - d_inf) / (t_sup - t_inf);
                    distanceCoef = d_inf + (t - t_inf) * velocityCoef;
                }

                mCurrVelocity = velocityCoef * mDistance / mDuration * 1000.0f;
                
                mCurrX = mStartX + Math.round(distanceCoef * (mFinalX - mStartX));
                // Pin to mMinX <= mCurrX <= mMaxX
                mCurrX = Math.min(mCurrX, mMaxX);
                mCurrX = Math.max(mCurrX, mMinX);
                
                mCurrY = mStartY + Math.round(distanceCoef * (mFinalY - mStartY));
                // Pin to mMinY <= mCurrY <= mMaxY
                mCurrY = Math.min(mCurrY, mMaxY);
                mCurrY = Math.max(mCurrY, mMinY);

                if (mCurrX == mFinalX && mCurrY == mFinalY) {
                    mFinished = true;
                }

                break;
            }
        }
        else {
            mCurrX = mFinalX;
            mCurrY = mFinalY;
            mFinished = true;
        }
        return true;
    }
是不是突然就明白了？这个方法会根据时间的流逝来计算出当前的scrollX和scrollY的值。计算方法也很简单，大意就是根据时间流逝的百分比来算出scrollX和scrollY改变的百分比并计算出当前的值，这个过程类似与动画中的插值器的概念，这里我们先不去探究这个过程这个具体过程。这个方法的返回值也很重要，它返回true表示滑动未结束，false表示滑动已经结束，因此当这个方法返回tue时，我们要继续进行View的滑动。
通过上面的分析，我们继续明白Scroller的工作原理，这里做一下概括：Scroller本身并不能实现View的滑动，它需要配合View的computeScroll方法才能完成弹性滑动的效果，它不断地让View重绘，而每一次重绘滑动其实时间会有一个时间间隔，通过这个时间间隔Scroller就可以得出View当前地滑动位置，知道了滑动位置就可以通过scrollTo方法来完成View滑动。就这样，View的每一次重绘都会导致View进行小幅度的滑动，而多次的小幅度滑动就组成了弹性滑动，这就是Scroller的工作机制。因此可见，Scroller的设计思想时多么值得称赞，这个过程中它对View没有丝毫的引用，甚至在它内部连计时器都没有。
2.通过动画
动画本身就是一个渐近的过程，因此通过它来实现的滑动天然就具有弹性效果，比如以下代码可以让一个View的内容在100ms内向左移动100像素。
ObjectAnimator.ofFloat(targetView,"translationX", 0,100).setDuration(100).start();
不过这里想说的并不是这个问题，我们可以利用动画的特性来实现一些动画不能实现的效果。还拿scrollTo来说，我们也想模仿Scroller来实现View的弹性滑动，那么利用动画的特性，我们可以采用如下方式来实现：

final int startX = 0;
        final int deltaX = 100;
        ValueAnimator animator = ValueAnimator.ofInt(0,1).setDuration(1000);
        animator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
                float fraction = animation.getAnimatedFraction();
                targetView.scrollTo(startX+(int)(deltaX*fraction),0);
            }
        });
        animator.start();
在上述代码中，我们的公话本质上没有作用于任何对象上，他只是在1000ms内完成了整个动画过程。利用这个特性，我们就可以在动画的每一帧到来时获取动画完成的比例，然后再根据这个比例计算出当前View所要滑动的距离。注意，这里的滑动针对的是View的内容而非View本身。可以发现，这个方法的思想其实和Scroller比较类似，都是通过改变一个百分比配合scrollTo方法来完成View的滑动。需要说明的一点，采用这种方式除了能够完成滑动以外，还可以实现其他动画效果，我们完全可以再onAnimationUpdate方法中加上我们想要的其他操作。

3.使用延时策略
本节介绍另外一种实现弹性滑动的方法，那就是延时策略。它的核心思想是通过发生一系列延时消息从而达到一种渐进式的效果，具体来说可以使用Handler或者View的postDelayed方法，也可以使用线程Sleep方法。对于postDelayed方法来说，我们可以通过它来延迟发送一个消息，然后再消息中来进行View的滑动，如果接连不断地发送这种延时消息，那么就可以实现弹性滑动的效果。对于sleep方法来说，通过在while循环中不断地滑动View和sleep，就可以实现弹性滑动的效果。
下面采用Handler来左个示例，其他方法请自行去尝试，思想都是类似的。下面的代码大约1000ms内将View的内容向左移动了100像素代码比较简单，就不再详细介绍了。之所以说大约1000ms，是因为采用这种方式无法精确地定时，原因是系统的消息调度也是需要时间的，并且所需时间不定。
    private static final int MESSAGE_SCROLL_TO = 1;
    private static final int FRAME_COUNT = 30;
    private static final int DELAYED_TIME = 33;

    private int mCount = 0;

    private Handler mHandler = new Handler(){
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what){
                case MESSAGE_SCROLL_TO: {
                    mCount++;
                    if (mCount <= FRAME_COUNT) {
                        float fraction = mCount / (float)FRAME_COUNT;
                        int scrollX = (int)(fraction*100);
                        targetView.scrollTo(scrollX,0);
                        mHandler.sendEmptyMessageDelayed(MESSAGE_SCROLL_TO,DELAYED_TIME);
                    }
                    break;
                }
                default:
                    break;
            }
        }
    };
上面几种弹性滑动的实现方式，在介绍中侧重更多的是实现思想，在实际使用中可以对其灵活地进行扩展从而实现更多复杂地效果。

function addLoadEvent(func){

var oldοnlοad=window.onload;//用变量存储现有的事件处理函数

if(typeof window.onload!="function"){

window.οnlοad=func;

}else{

window.οnlοad=function(){

oldonload();

func();

}

}