自己做了个下拉加载组件 发现在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)

前言
 
先来一道趣味测试，后面的控件讲解会比较枯燥乏味，看一看你的数学老师是谁教的？
 
小明向两位朋友各自借了50元，用借来的钱，小明花费97元买了一件格子衫。这时候还剩3元钱，小明还给两个小伙伴各1元，自己还剩下1元。
 
那么问题来了：小明此时欠两位小伙伴各49元，再加上自己剩下的1元，49+49+1=99元。剩下的1元去哪了？
 
正文
 
近日产品提出了一个新需求，在首页列表中新增可以横向滑动的卡片类型，效果类似豆瓣弹性滑动控件，看下最终效果图：
 
 
小编刚开始以为只要实现了 豆瓣弹性滑动控件 就万事大吉了，没想到这只是一个开始。滑动控件 只不过是一道开胃菜，事件冲突 才是重头戏。
 
首先分析下效果图中的布局，典型的 ViewPager + fragment + RecyclerView 布局方式，在垂直的 RecyclerView 中嵌入了 弹性滑动控件 字 item，那么会有哪些事件冲突呢？
 
弹性滑动控件 会消费左右滑动事件，内部的卡片 RecyclerView 同时也会消费左右滑动事件，左右滑动事件就会冲突。光是文字的描述，可能不大好理解，结合以下图片加以说明：手指向左滑动，是 RecyclerView 消费左滑的事件呢？还是 弹性滑动控件 消费左滑的事件？
 
垂直的 RecyclerView 会默认消费上下滑动事件， 弹性滑动控件 在左右滑动的同时，y 轴方向的偏移量不会为 0，因为手指的滑动很难保持在一条水平线上，垂直的 RecyclerView 就会消费 y 方向的事件，导致界面抖动，滑动不灵敏。那么 弹性滑动控件 在左右滑动的时候就需要拦截掉垂直的 RecyclerView 的滑动事件消费。
弹性滑动控件 滑动到左右边缘的时候，最外层的 ViewPager 会默认消费掉左右滑动事件，导致滑向上一个 tab 或下一个 tab ，无任何的弹性效果。处理方式， 在弹性滑动控件 左右滑动的时候，需要禁止掉 ViewPager 的事件消费。
 
一个滑动控件需要解决这么多事件冲突，想一想，是时候使用抽屉里的菜刀了，但让我没想到的是，我拿着菜刀急冲冲找到产品，他却很淡定的从抽屉里拿出了手枪，拿出了手枪，我内心告诉自己不能怂，嘴上却不争气的说道：没问题，so easy ，给我2天时间，我真想给自己一大嘴巴，那么接下来就开整呗。
 
豆瓣弹性滑动控件
 
需要实现 豆瓣弹性滑动控件 的效果，先调研下豆瓣的布局方式：
 
 从 uiautomatorviewer.bat 工具中可以分析出，豆瓣是通过自定义 LinearLayout 来实现的，包含了横向的 RecyclerView 与右侧的 释放查看TextView 文本子控件。那么 弹性滑动控件 实现的大概思路如下：RecyclerView 滑动到左右边缘，记录 x 轴方向的偏移量，通过方法 setTranslationX 设置 RecyclerView 的平移量，手指抬起则执行简单的平移动画，接下来会详细讲解，比较乏味，请系好安全带。
 
分解 弹性滑动 过程，新建HorizontalScrollView继承RelativeLayout，并没有继承LinearLayout，后面会讲到：
 
RecyclerView 滑动到左边缘，继续向右滑动，HorizontalScrollView 拦截事件，同时记录x方向的偏移量dx，RecyclerView 调用 setTranslationX 方法设置平移量 RecyclerView.setTranslationX(dx)，这里又分两种情况：第一种手指抬起执行平移动画；第二种向左滑动除了 RecyclerView.setTranslationX(dx) 还需要判定 RecyclerView.getTranslationX() 是否等于 0 ，如果等于 0 则不拦截事件，返回 super.dispatchTouchEvent(ev)。
RecyclerView 滑动到右边缘，继续向左滑动，处理同1，还需根据偏移量来判定右侧的文本显示状态。
RecyclerView 未滑动到左右边缘，HorizontalScrollView 不拦截事件，RecyclerView 消费左右滑动事件。
 
请结合以下代码加以理解：
 
    @Override
    public boolean dispatchTouchEvent(MotionEvent ev) {
        if (mHorizontalRecyclerView == null) {
            return super.dispatchTouchEvent(ev);
        }
        switch (ev.getAction()) {
            case MotionEvent.ACTION_DOWN:
               // 重置变量
                mHintLeftMargin = 0;
                mMoveIndex = 0;
                mConsumeMoveEvent = false;
                mLastX = ev.getRawX();
                mLastY = ev.getRawY();
                break;
            case MotionEvent.ACTION_MOVE:
                // 释放动画
                if (ReboundAnim != null && ReboundAnim.isRunning()) {
                    break;
                }
                float mDeltaX = (ev.getRawX() - mLastX);
                float mDeltaY = ev.getRawY() - mLastY;
                
                mLastX = ev.getRawX();
                mLastY = ev.getRawY();
                mDeltaX = mDeltaX * RATIO;

                // 右滑
                if (mDeltaX > 0) {
                    //  canScrollHorizontally 判定是否滑动到边缘
                    if (!mHorizontalRecyclerView.canScrollHorizontally(-1) || mHorizontalRecyclerView.getTranslationX() < 0) {
                        float transX = mDeltaX + mHorizontalRecyclerView.getTranslationX();
                        if (mHorizontalRecyclerView.canScrollHorizontally(-1) && transX >= 0) {
                            transX = 0;
                        }
                        mHorizontalRecyclerView.setTranslationX(transX);
                        setHintTextTranslationX(mDeltaX);
                    }
                } else if (mDeltaX < 0) { // 左滑
                    if (!mHorizontalRecyclerView.canScrollHorizontally(1) || mHorizontalRecyclerView.getTranslationX() > 0) {
                        float transX = mDeltaX + mHorizontalRecyclerView.getTranslationX();
                        if (transX <= 0 && mHorizontalRecyclerView.canScrollHorizontally(1)) {
                            transX = 0;
                        }
                        mHorizontalRecyclerView.setTranslationX(transX);
                        setHintTextTranslationX(mDeltaX);
                    }
                }
                break;
            case MotionEvent.ACTION_CANCEL:
            case MotionEvent.ACTION_UP:
                // 释放动画
                if (ReboundAnim != null && ReboundAnim.isRunning()) {
                    break;
                }

                if (mHintLeftMargin <= mOffsetWidth && mListener != null) {
                   // 松手看更多的事件监听
                    mListener.onRelease();
                }
                // 手指抬起动画
                ReboundAnim = ValueAnimator.ofFloat(1.0f, 0);
                ReboundAnim.setDuration(300);
                ReboundAnim.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
                    @Override
                    public void onAnimationUpdate(ValueAnimator animation) {
                        float value = (float) animation.getAnimatedValue();
                        mHorizontalRecyclerView.setTranslationX(value * mHorizontalRecyclerView.getTranslationX());
                        mMoreTextView.setTranslationX(value * mMoreTextView.getTranslationX());
                    }
                });
                ReboundAnim.start();
                break;
        }
        return mHorizontalRecyclerView.getTranslationX() != 0 ? true : super.dispatchTouchEvent(ev);
    }
 
代码逻辑很清晰，有不理解的童鞋，请留言。弹性效果实现了，但右侧还有一个竖直的文本控件，ui 需要的效果如下图，需要实现的功能如下：
 
 
内容垂直排版
文字间的间距需要可控
可以设置图标
贝塞尔曲线阴影，根据手指偏移量来动态改变贝塞尔曲线的控制点
 
很遗憾，原生的 TextView 并不支持内容垂直排版，间距也不可控，但欣慰的是支持设置图标，那么重写 onDraw 方法，自己绘制垂直文本，可谓是一个不错的方案。
 
VerticalTextView 继承 AppCompatTextView ，重写以下方法：
 
    @Override
    public void setText(CharSequence text, BufferType type) {
        // super.setText(text, type);  // 注意  这里必须要注释掉，不然绘制出来会多横向的文本，加个标记控制的话更好
        setVerticalText(text); 
    }
 
    public void setVerticalText(CharSequence text) {
        mDefaultText = text;
        invalidate();
    }
 
通过获取基线 baseline 坐标，以及整个字符的高度，来调整文本居中对齐，然后根据每个字符的高度，累加绘制文本：
 
    @Override
    protected void onDraw(Canvas canvas) {
        mPaint.setTextSize(getTextSize());
        mPaint.setColor(getCurrentTextColor());
        mPaint.setTypeface(getTypeface());
        CharSequence text = mDefaultText;
        if (getText() != null && !text.toString().trim().equals("")) {
            Rect bounds = new Rect();
            mPaint.getTextBounds(text.toString(), 0, text.length(), bounds);

            // 最开始就忘记 + getPaddingLeft 导致绘制的文本偏左
            float startX = getLayout().getLineLeft(0) + getPaddingLeft();

            if (getCompoundDrawables()[0] != null) {
                Rect drawRect = getCompoundDrawables()[0].getBounds();
                // 减去图标的宽度
                startX += (drawRect.right - drawRect.left);
            }

            startX += getCompoundDrawablePadding();

            float startY = getBaseline();

            int cHeight = (bounds.bottom - bounds.top + mCharSpacing);

            // 居中对齐
            startY -= (text.length() - 1) * cHeight / 2;

            for (int i = 0; i < text.length(); i++) {
                String c = String.valueOf(text.charAt(i));

                canvas.drawText(c, startX, startY + i * cHeight, mPaint);
            }
        }
        super.onDraw(canvas);
        // 绘制贝塞尔阴影
        if (mIsDrawShadow) {
            mShadowPath.reset();
            mShadowPath.moveTo(getWidth(), getHeight() / 4);
            mShadowPath.quadTo(mShadowOffset, getHeight() / 2, getWidth(), getHeight() / 4 * 3);
            canvas.drawPath(mShadowPath, mShadowPaint);
        }
    }
 
突然有个想法，如果以路径 Path 来绘制文本，岂不更棒，有兴趣的小伙伴可以下来试一试。弹性滑动控件 到这里就告一段落了，接下来主要处理集成到项目中的滑动事件冲突。
 
垂直RecyclerView滑动冲突
 
垂直 RecyclerView 会消费上下滑动事件，导致 弹性滑动控件 在水平方向滑动的时候，y 轴方向产生的偏移量被垂直 RecyclerView 消费，请看下图：
 
 
那么怎么来处理与垂直 RecyclerView 产生的事件冲突呢？处理事件冲突的方式有两种：
 
子 View 禁止父 View 拦截 Touch 事件，在分析 ViewGroup 的 dispatchTouchEvent() 源码时，我们知道：Touch 事件是由父 View 分发的。如果一个 Touch 事件是子 View 需要的，但是被其父 View 拦截了，子 View 就无法处理该 Touch 事件了。在此情形下，子 View 可以调用 requestDisallowInterceptTouchEvent( ) 禁止父 View 对 Touch 的拦截
在父 View 中准确地进行事件分发和拦截 ，我们可以重写父 View 中与 Touch 事件分发相关的方法，比如onInterceptTouchEvent( )。这些方法中摒弃系统默认的流程，结合自身的业务逻辑重写该部分代码，从而使父View 放行子 View 需要的 Touch
 
这里以第一种的方式解决与垂直方向的 RecyclerView 滑动冲突，第二种方式解决与 ViewPager 的滑动冲突。原理非常的简单，判定 x 方向的偏移量是否大于 y 方向的偏移量，大于则禁止父 View 拦截 Touch 事件，反之则不拦截，具体代码如下：
 
    float mDeltaX = (ev.getRawX() - mLastX);
    float mDeltaY = ev.getRawY() - mLastY;
    if (!mConsumeMoveEvent) {
        // 处理事件冲突
        if (Math.abs(mDeltaX) > Math.abs(mDeltaY)) {
            getParent().requestDisallowInterceptTouchEvent(true);
        } else {
            getParent().requestDisallowInterceptTouchEvent(false);
        }
    }
    mMoveIndex++;
    if (mMoveIndex > 2) {
        mConsumeMoveEvent = true;
    }
    mLastX = ev.getRawX();
    mLastY = ev.getRawY();
 
很多时候触摸屏幕会导致第一次 ACTION_MOVE 获取的 mDeltaX 与 mDeltaY 都为 0，导致父 View 拦截了 Touch 事件，弹性效果失效，为了解决这个问题，这里用到了一个小技巧，多判定一次拦截条件。大家发现没有，代码中还有一处优化的地方，getParent() 方法获取的父控件不一定是列表控件，比较合理的方式使用递归去获取，相关代码如下：
 
    private ViewParent getParentListView(ViewParent viewParent) {
        if (viewParent == null) return null;
        if (viewParent instanceof RecyclerView || viewParent instanceof ListView) {
            return viewParent;
        } else {
            getParentListView(viewParent.getParent());
        }
        return null;
    }
 
ViewPager滑动冲突
 
ViewPager 会默认消费左右滑动事件，当 弹性控件 滑动到左右边缘时，继续滑动会触发 ViewPager 的滑动，请看下图：
 
 
这里采用第二种方式处理滑动冲突，在父 View 中准确地进行事件分发和拦截，那么我们什么时候分发？又什么时候拦截呢？如果我们左右滑动的是非 弹性控件 区域，那么 ViewPager 应该拦截事件，反之则分发事件。
 
那么我们才能知道触摸的是 弹性控件 区域呢？可能在屏幕中的任何位置，我们知道 view 的层级是树形结构，那么针对 ViewPager 的子 view 进行遍历，拿到设有 弹性控件 的 tag 标记，来进行事件的分发和拦截，具体代码如下，不知道小伙伴又没更好的方案：
 
    @Override
    public boolean onInterceptTouchEvent(MotionEvent ev) {
        int action = ev.getAction() & MotionEventCompat.ACTION_MASK;
        switch (action) {
            case MotionEvent.ACTION_DOWN:
                mInterceptEvent = !childInterceptEvent(this, (int) ev.getRawX(), (int) ev.getRawY());
                break;
        }
        // 拦截与分发
        return mInterceptEvent ? super.onInterceptTouchEvent(ev) : false;
    }

    // 遍历树
    private boolean childInterceptEvent(ViewGroup parentView, int touchX, int touchY) {
        boolean isConsume = false;
        for (int i = parentView.getChildCount() - 1; i >= 0; i--) {
            View childView = parentView.getChildAt(i);
            if (!childView.isShown()) {
                continue;
            }
            boolean isTouchView = isTouchView(touchX, touchY, childView);
            if (isTouchView && childView.getTag() != null && TAG_DISPATCH.equals(childView.getTag().toString())) {
                isConsume = true;
                break;
            }
            if (childView instanceof ViewGroup) {
                ViewGroup itemView = (ViewGroup) childView;
                if (!isTouchView) {
                    continue;
                } else {
                    isConsume |= childInterceptEvent(itemView, touchX, touchY);
                    if (isConsume) {
                        break;
                    }
                }
            }
        }
        return isConsume;
    }
    // 是否在触摸区域内
    private boolean isTouchView(int touchX, int touchY, View view) {
        Rect rect = new Rect();
        view.getGlobalVisibleRect(rect);
        return rect.contains(touchX, touchY);
    }
 
感兴趣的小伙伴的可以以第一种方式来解决滑动冲突。文中涉及的知识点都是个人的看法，如果你觉得有什么地方不妥，欢迎指出？每个人在开发当中的场景可能都不一样，但是处理冲突的基本原理和方式是相同的。
 
结语
 
源码小编整理后会上传到 MeiWidgetView ，同时非常希望各位小伙伴能够动手点颗 star ，你的鼓励与支持才是让小编继续创作的源泉。

什么是事件分发，分开解释即可，MotionEvent事件，当点击了，怎样处理，就是分发。
 
下面3个方法来共同完成，
 
 
dispatchTouchEvent：用来进行事件的分发，如果事件能够传递给当前View，那么此方法一定会被调用，返回结果受当前View的onTouchEvent和View的dispatchTouchEvent方法的影响，表示是否当消耗当前事件
 

  
 
public boolean dispatchTouchEvent(MotionEvent ev){
    boolean consume = false;
    if(onInterceptTouchEvent(ev)){
        consume = onTouchEvent(ev);
    }else{
        consume = child.dispatchTouchEvent(ev);
    }

    return consume;

}
 
 
onInterceptTouchEvent：用来判断是否拦截某个事件，如果当前View拦截了某个事件，那么在同一个事件序列当中，此方法不会被再次调用，返回结果表示是否拦截当前事件；
onTouchEvent：在dispatchTouchEvent方法中调用，用来处理点击事件，返回结果表示是否消耗当前事件，如果不消耗，则在同一个事件序列中，当前View无法再次接收到事件。
 

 
 
 

 
 
 
 1。弹性滑动的实现
 

  
 
 使用Scroller
 
 
 
 典型代码如下
 
Scroller scroller = new Scroller(mContext);

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

@Override
public void computeScroll(){
    if(mScroller.computeScrollOffset()){
        scrollTo(mScroller.getCurrX(),mScroller.getCurrY());
        postInvalidate();
    }
}
 
 
 computeScrollOffset方法判主要是断滚动是否还在继续，Scroller类中的mFinished属性与之对应。如果滚动完成了，那么computeScrollOffset方法返回false，mFinished为true；如果滚动没有完成那么computeScrollOffset方法返回true，mFinished为false。
 
 
 

 startScroll主要是用来开启滚动，startX和startY是滑动的起点，dx和dy是滑动的距离，duration是滑动时间。并且必须注意的是，仅仅调用startScroll方法是无法让View开始滑动的，因为它内部并没有做相关的滑动，仅仅是保存了我们传递的几个参数。那么View到底要怎么滑动呢？其实就是在调用该方法时，应该再调用invalidate方法，即重绘。重绘的时候则会导致View中的draw方法执行，draw方法中又会去调用computeScroll方法。遗憾的是computeScroll方法是一个空实现，因此需要我们自己去实现该方法。但是应该注意的是，在computeScroll方法中，我们应该调用View的postInvalidate方法来进行第二次重绘，和第一次重绘一样，也是为了导致computeScroll方法被调用，如此反复，知道滑动结束。
 

 computeScroll方法也比较容易理解，它的代码格式一般都是固定的，主要是判断滑动是否完成，如果没有完成就去向Scroller获取当前的scrollX和scrollY，然后通过scrollTo实现滑动。最后再调用postInvalidate来让滑动持续进行。
 
 

 
 
 

 首先startScroll开启滑动，并调用invalidate方法进行重绘。当View重绘后会在draw方法中调用computeScroll，而computeScroll又去向Scroller获取当前的scrollX和scrollY，然后通过scrollTo实现滑动。接着又调用postInvalidate进行第二次重绘，和第一次重绘一样，也是为了导致computeScroll方法被调用。然后继续向Scroller获取当前的scrollX和scrollY，并通过scrollTo滑动到最新的位置，如此反复，知道整个滑动结束。
 
 
 

 
 
 

 弹性滑动的另外一种实现，
 

 动画本身就是一种弹性滑动，所以对于动画实现的滑动不去专门讨论瞬间滑动和弹性滑动。通过动画让View进行滑动，其实质就是让View进行平移，其主要是操作translationX和translationY属性
 
 

 R.anim.translate :
 
 

 <?xml version="1.0" encoding="utf-8"?><set xmlns:android="http://schemas.android.com/apk/res/android" android:fillAfter="true" android:zAdjustment="normal"> <translate android:duration="2000" android:fromXDelta="0" android:fromYDelta="0" android:interpolator="@android:anim/linear_interpolator" android:toXDelta="200" android:toYDelta="200" /></set>
 
 

 
 
 

 //加载动画 animation = AnimationUtils.loadAnimation(this, R.anim.translate);
 
 

 mImageView.startAnimation(animation); 
 
 
 2。View的滑动冲突
 
 
 产生：界面中存在内外两层同时可以滑动的View
 
 外部拦截法和内部拦截法
 
 
 外部拦截法：事件都先经过父容器的拦截处理，如果父容器需要此事件就拦截，如果不需要就不拦截。外部拦截法需要重写父容器的onInterceptTouchEvent方法
 
//分别记录上次滑动的坐标（onInterceptTouchEvent）
private int mLastXIntercept = 0;
private int mLastYIntercept = 0;

public boolean onInterceptTouchEvent(MotionEvent event){

    boolean intercepted = false;
    int x = (int)event.getX();
    int y = (int)event.getY();
    switch(event.getAction()){
        case MotionEvent.ACTION_DOWN:
            intercepted = false;
            break;
        case MotionEvent.ACTION_MOVE:

            int deltaX = x - mLastXIntercept;
            int deltaY = y - mLastYIntercept;

            if(父容器需要当前点击事件){
                intercepted = true;
            }else{
                intercepted = false;
            }
            break;
        case MotionEvent.ACTION_UP:
            intercepted = false;
            break;
        default:
            break;
    }

    mLastXIntercept = x;
    mLastYIntercept = y;

    return intercepted;

}
 
 上述代码是外部拦截法的典型逻辑，针对不同的滑动冲突只需修改“父容器需要当前点击事件”这个条件即可
 
 
 内部拦截法：指父容器不拦截任何事件，所有的事件都传递给子元素，如果子元素需要此事件就消费，否则就交由父容器进行处理。这种方法需要配合requestDisallowInterceptTouchEvent方法才能正常工作
 
//分别记录上次滑动的坐标
private int mLastX = 0;
private int mLastY = 0;

public boolean dispatchTouchEvent(MotionEvent event){

    int x = (int)event.getX();
    int y = (int)event.getY();

    switch(event.getAction()){
        case MotionEvent.ACTION_DOWN:
            parent.requestDisallowInterceptTouchEvent(true);
            break;
        case MotionEvent.ACTION_MOVE:
            int deltaX = x - mLastX;
            int deltaY = y - mLastY;
            if(父容器需要此类点击事件){
                parent.requestDisallowInterceptTouchEvent(false);
            }
            break;
        case MotionEvent.ACTION_UP:
            break;
        default:
            break;
    }

    mLastX = x;
    mLastY = y;

    return super.dispatchTouchEvent(event);

}
 
 上述代码是内部拦截法的典型代码，面对不同的滑动策略时只需要更改“父容器需要此类点击事件”这个条件即可
 
 父元素所做的修改如下
 
public boolean onInterceptTouchEvent(MotionEvent event){
    int action = event.getAction();
    if(action == MotionEvent.ACTION_DOWN){
        return false;
    }else{
        return true;
    }
}
 
 

 
购买弹性ip aws
 

  

  

 
 
To understand the use of AWS Elastic IP, please read our post on Amazon EC2 to get an idea of an elastic compute cloud.
 
 要了解AWS Elastic IP的用法，请阅读我们在Amazon EC2上的帖子，以了解弹性计算云。 
 
 
Amazon EC2 – Elastic Compute Cloud and Amazon VPC – Virtual Private Cloud both supports IP4 and IPv6 addressing protocols. When you create a VPC, you must specify the IPv4 CIDR block (a range of IP addresses). By default Amazon EC2 and VPC use the IPv4 addressing protocols, You can not override or change this behavior.
 
 Amazon EC2 –弹性计算云和Amazon VPC –虚拟私有云均支持IP4和IPv6寻址协议。 创建VPC时，必须指定IPv4 CIDR块（IP地址范围）。 默认情况下，Amazon EC2和VPC使用IPv4寻址协议，您无法覆盖或更改此行为。 
 
 

 
 
 
Let’s discuss the default behavior of IP addresses to understand the need for AWS Elastic IP:
 
 让我们讨论IP地址的默认行为，以了解对AWS Elastic IP的需求： 
 
 
 专用IPv4地址 (Private IPv4 Address)
 
 
Private IPv4 addresses are used to communicate between instances within the same VPC. You cannot connect to another VPC and so the Internet. A private IPv4 is not reachable over the internet.
 
 专用IPv4地址用于在同一VPC内的实例之间进行通信。 您无法连接到另一个VPC，因此无法连接到Internet。 私有IPv4无法通过Internet访问。 
 
 
When we launch an EC2 instance, AWS gives and assign a private IPv4 address for the instance. Each instance is also assigned a DNS that resolves the primary IPv4 address.
 
 当我们启动EC2实例时，AWS为该实例提供并分配一个私有IPv4地址。 每个实例还分配了一个DNS，用于解析主IPv4地址。 
 
 
For more, please read our detailed post on Amazon VPC.
 
 有关更多信息，请阅读我们有关Amazon VPC的详细文章。 
 
 

  

  

 
 
 公用IPv4地址 (Public IPv4 Address)
 
 
Using the public IP address of the instance, you can communicate to the internet. A public IPv4 address is an address which is reachable from the internet.
 
 使用实例的公共IP地址，您可以与Internet通信。 公用IPv4地址是可以从Internet访问的地址。 
 
 
When we launch an instance in a default VPC, AWS allocate a public IPv4 address and DNS associated with the public IP address; for example, ec2-112-34-123-22.compute-2.amazonaws.com can be the DNS for your public IP address which resolves the public IPv4 address.
 
 当我们在默认VPC中启动实例时，AWS会分配一个公共IPv4地址和与该公共IP地址关联的DNS。 例如，ec2-112-34-123-22.compute-2.amazonaws.com可以是您的公共IP地址的DNS，用于解析公共IPv4地址。 
 
 
 什么是AWS弹性IP地址？ (What is AWS Elastic IP Address?)
 
 
AWS Elastic IP is a public IPv4 address that you can allocate to your instance. You can associate an elastic IP address to your instance and it will be associated until you will remove it manually.
 
 AWS Elastic IP是一个公共IPv4地址，您可以分配给您的实例。 您可以将弹性IP地址关联到您的实例，并且它将被关联，直到您手动将其删除为止。 
 
 
AWS elastic IP address is static IP address and designed for dynamic compute cloud. As it is a public IPv4 address so it’s reachable to the internet as well. By associated this IP address to your instance, you can enable access to the instance from your local machine.
 
 AWS弹性IP地址是静态IP地址，专为动态计算云而设计。 由于它是公共IPv4地址，因此也可以访问Internet。 通过将此IP地址与您的实例相关联，可以启用从本地计算机对该实例的访问。 
 
 
 为什么使用AWS弹性IP地址？ (Why AWS Elastic IP Address?)
 
 
The question is when AWS allocate a public IPv4 address for each instance by default then what is the need for an additional IPv4 address. Let’s discuss this:
 
 问题是，当AWS默认情况下为每个实例分配一个公共IPv4地址时，又需要一个额外的IPv4地址。 让我们讨论一下： 
 
 
A public IP address is assigned to your instance from Amazon’s pool of IPv4 addresses. Public IPv4 address is not associated with your AWS account. It goes back to Amazon’s pool once released or disassociated from the instance.
 
 从Amazon的IPv4地址池为您的实例分配了一个公共IP地址。 公用IPv4地址未与您的AWS账户关联。 一旦释放或与实例解除关联，它就会回到亚马逊的池中。 
 
 
You cannot manually associate or disassociate the public IP address to your instance. AWS does it on behalf of you. There are certain events when your public IP address releases from your instance:
 
 您不能手动将公共IP地址与实例关联或取消关联。 AWS代表您执行此操作。 从实例释放公共IP地址时，会发生某些事件： 
 
 
When your instance is stopped or terminated, the public IP address gets released. AWS assigns a new public IP address when it is restarted
 当您的实例停止或终止时，公共IP地址将被释放。 AWS重新启动后会为其分配一个新的公共IP地址 
Public IP address is released when you assign an Elastic IP address. When you disassociate the Elastic IP address, AWS assigns a public IPv4 address from its pool
 分配弹性IP地址时，将释放公共IP地址。 取消关联弹性IP地址时，AWS从其池中分配一个公共IPv4地址 
 
There are more cases but these two are common and important for us to understand. The first case is important for the application running on EC2 and you are accessing through IP address.
 
 还有更多的情况，但是这两种情况对于我们来说很常见且很重要。 第一种情况对于在EC2上运行的应用程序很重要，并且您正在通过IP地址进行访问。 
 
 

  

  

 
 
Each time your instance restarts, stopped or terminated the public IP address will change. If you have configured the IP address in your hosting account then it makes difficult to change the IP address on each event.
 
 每次您的实例重新启动，停止或终止时，公共IP地址都会更改。 如果您在托管帐户中配置了IP地址，则很难在每次事件中更改IP地址。 
 
 
An elastic IP address is a solution to this problem. AWS Elastic IP addresses are associated with your AWS account and it doesn’t change.
 
 弹性IP地址是解决此问题的方法。 AWS Elastic IP地址与您的AWS账户关联，并且不会更改。 
 
 
 分配弹性IP地址 (Allocate an Elastic IP Address)
 
 
You can allocate an IPv4 address to your AWS account from Amazon’s pool of IPv4 addresses. Let’s use the AWS Management console to allocate an Elastic IP address:
 
 您可以从Amazon的IPv4地址池为您的AWS账户分配一个IPv4地址。 让我们使用AWS管理控制台分配弹性IP地址： 
 
 
Sign in to the AWS management console https://aws.amazon.com/console/
 登录到AWS管理控制台https://aws.amazon.com/console/ 
Open the Amazon EC2 console at https://console.aws.amazon.com/ec2/
 通过以下网址打开Amazon EC2控制台： https：//console.aws.amazon.com/ec2/ 
In left navigation, go to “NETWORK & SECURITY” and “Elastic IPs”.

   

    
    
Elastic Ips Option
   
 在左侧导航中，转到“网络和安全性”和“弹性IP”。 

   
 
    
 弹性IP选项 
 
   
 
Choose Allocate new Address – See the below screenshot for your reference. Elastic IP address are region specific.
   

    
    
Allocate New Address Panel
   
 选择“ 分配新地址” –请参见下面的屏幕快照以供参考。 弹性IP地址是特定于区域的。 
   
 
    
 分配新的地址面板 
 
   
 
For IPv4 address pool, choose Amazon pool
   

    
    
Allocate New Address
   
You can choose “Owned by me” if you have an IP address in your own pool. We are going to choose the “Amazon Pool” as we do not have our own IPv4 pool.
   
 
    
 分配新地址 
 
   
 
 如果您自己的池中有IP地址，则可以选择“我拥有”。 我们将选择“亚马逊池”，因为我们没有自己的IPv4池。 
 
 Choose Allocate, and close the confirmation screen – AWS will take few seconds to allocate the public IPv4 address from its pool as Elastic IP.
   

    
    
Allocated Ip Address
   
 选择“分配”，然后关闭确认屏幕– AWS将花费几秒钟的时间从其池中将公共IPv4地址分配为Elastic IP。 
   
 
    
 分配的IP地址 
 
   
 
 
 标记弹性IP地址 (Tagging an Elastic IP Address)
 
 
Tagging is used to identify your Elastic IP address. You can assign custom tags(a key, value) pair to categorize them. Categorization is completely depended on how you want to use them, for example, environment, purpose or owner.
 
 标记用于标识您的弹性IP地址。 您可以分配自定义标签（键，值）对以对其进行分类。 分类完全取决于您要如何使用它们，例如，环境，用途或所有者。 
 
 
Sign in to the AWS management console https://aws.amazon.com/console/
 登录到AWS管理控制台https://aws.amazon.com/console/ 
Open the Amazon EC2 console at https://console.aws.amazon.com/ec2/
 通过以下网址打开Amazon EC2控制台： https：//console.aws.amazon.com/ec2/ 
In left navigation, go to “NETWORK & SECURITY” and “Elastic IPs”.
 在左侧导航中，转到“网络和安全性”和“弹性IP”。 
Go to the actions and choose “Add/Edit Tags”
 转到操作并选择“添加/编辑标签” 
In the Add/Edit Tags dialog box, choose Create Tag, and then specify the key and value for the tag.
 在“添加/编辑标签”对话框中，选择“创建标签”，然后指定标签的键和值。 
 
 将AWS Static IP与EC2实例关联 (Associating AWS Static IP with EC2 instance)
 
 
Now, you can associate the Elastic IP address to your running instance. AWS will release the public IPv4 address which is currently associated with EC2 instance and associate the Elastic IP address.
 
 现在，您可以将弹性IP地址关联到正在运行的实例。 AWS将释放当前与EC2实例关联的公共IPv4地址，并关联弹性IP地址。 
 
 
Please follow below steps:
 
 请按照以下步骤操作： 
 
 
Sign in to the AWS management console https://aws.amazon.com/console/
 登录到AWS管理控制台https://aws.amazon.com/console/ 
Open the Amazon EC2 console at https://console.aws.amazon.com/ec2/
 通过以下网址打开Amazon EC2控制台： https：//console.aws.amazon.com/ec2/ 
In left navigation, go to “NETWORK & SECURITY” and “Elastic IPs”.
 在左侧导航中，转到“网络和安全性”和“弹性IP”。 
Select an Elastic IP address and choose Actions, Associate address
 选择一个弹性IP地址，然后选择“操作”，“关联地址” 
 You will see the below dialog:
   

    
    
Associate Elastic Ip
   
Choose the instance from the running instances. AWS will automatically select the private IP address for your instance.
If your Elastic IP address is associated with any other instance then select to reassociate check box. Now click associate address.
   
 
    
 关联弹性IP 
 
   
 
 从正在运行的实例中选择实例。 AWS会自动为您的实例选择私有IP地址。 
 
 如果您的弹性IP地址与任何其他实例相关联，则选择重新关联复选框。 现在单击关联地址。 
 
 
AWS will take a few seconds/minutes to associate the Elastic IP address to your running instance. You would be able to see the Elastic IP address association in EC2 properties.
 
 AWS将需要几秒钟/几分钟的时间来将弹性IP地址关联到您正在运行的实例。 您将能够在EC2属性中看到弹性IP地址关联。 
 
 
 与EC2实例解除关联 (Disassociating from EC2 instance)
 
 
You can disassociate an Elastic IP address which is currently assigned to an EC2 instance. You can do it by assigning to any other EC2 instance, in this case, you just need to follow the steps above.
 
 您可以取消关联当前分配给EC2实例的弹性IP地址。 您可以通过将其分配给任何其他EC2实例来完成此操作，在这种情况下，您只需按照上述步骤操作即可。 
 
 
If you just want to disassociate not reassociate then follow the below steps:
 
 如果您只想取消关联而不是重新关联，请按照以下步骤操作： 
 
 
Sign in to the AWS management console https://aws.amazon.com/console/
 登录到AWS管理控制台https://aws.amazon.com/console/ 
Open the Amazon EC2 console at https://console.aws.amazon.com/ec2/
 通过以下网址打开Amazon EC2控制台： https：//console.aws.amazon.com/ec2/ 
In left navigation, go to “NETWORK & SECURITY” and “Elastic IPs”.
 在左侧导航中，转到“网络和安全性”和“弹性IP”。 
Select an Elastic IP address and choose Actions, Diassociate address
 选择一个弹性IP地址，然后选择“操作”，“关联地址” 
You will see a dialog, click on the “Disasscociate address” button
 您将看到一个对话框，单击“取消关联地址”按钮 
 
AWS will take few seconds to disassociate the Elastic address from your running EC2 instance.
 
 AWS将需要几秒钟的时间来将弹性地址与正在运行的EC2实例解除关联。 
 
 
 释放弹性IP地址 (Release Elastic IP Address)
 
 
If you no longer need the Elastic IP address then you can release it from your account. Please make sure that you have disassociated the Elastic IP address from your EC2 instance.
 
 如果您不再需要弹性IP地址，则可以从帐户中释放它。 请确保已从EC2实例取消关联弹性IP地址。 
 
 
Please follow the below steps:
 
 请按照以下步骤操作： 
 
 
Sign in to the AWS management console https://aws.amazon.com/console/
 登录到AWS管理控制台https://aws.amazon.com/console/ 
Open the Amazon EC2 console at https://console.aws.amazon.com/ec2/
 通过以下网址打开Amazon EC2控制台： https：//console.aws.amazon.com/ec2/ 
In left navigation, go to “NETWORK & SECURITY” and “Elastic IPs”.
 在左侧导航中，转到“网络和安全性”和“弹性IP”。 
Select the Elastic IP address, choose Actions, and then select Release addresses. Choose Release when prompted.
   

    
    
Release Elastic Ip Address
   
 选择弹性IP地址，选择“操作”，然后选择“释放地址”。 出现提示时选择下达。 
   
 
    
 释放弹性IP地址 
 
   
 
 
AWS will take a few seconds and your Elastic IP address will be released.
 
 AWS将花费几秒钟，您的弹性IP地址将被释放。 
 
 
AWS does not support Elastic IP address with IPv6. The limit of Elastic IPv4 address per account is limited to 5 per region.
 
 AWS不支持IPv6的弹性IP地址。 每个帐户的弹性IPv4地址限制为每个区域5个。 
 
 

  
翻译自: https://www.journaldev.com/29277/aws-elastic-ip
 
 
购买弹性ip aws