VUE2中文文档：进入、离开和列表过度

进入、离开和列表的过渡

概述

当从 DOM 中插入、更新或移除项目时，Vue 提供多种应用过渡效果的方式。包括以下工具：

  • 在 CSS 过渡和动画中自动处理 class
  • 可以配合使用第三方 CSS 动画库，如 Animate.css
  • 在过渡钩子函数中使用 JavaScript 直接操作 DOM
  • 可以配合使用第三方 JavaScript 动画库，如 Velocity.js

单元素/组件的过渡

Vue 提供了 transition 外层包裹容器组件(wrapper component)，可以给下列情形中的任何元素和组件添加进入/离开(enter/leave)过渡

  • 条件渲染（使用 v-if）
  • 条件展示（使用 v-show）
  • 动态组件
  • 组件根节点
//这是一个简单的示例<div id="demo">
  <button v-on:click="show = !show">//每次点击改变data中show的布尔值
    Toggle
  </button>
  <transition name="fade">
    <p v-if="show">hello</p> 　//通过show的值判断是否展示该元素　　　
  </transition>
</div>
new Vue({
  el: ‘#demo‘,
  data: {
    show: true
  }
})
.fade-enter-active, .fade-leave-active { 　　//设定进入和离开过程中的效果，改变属性opacity和时间0.5s
  transition: opacity .5s;
}
.fade-enter, .fade-leave-to /* .fade-leave-active 在低于版本 2.1.8 中 */ {  //设定进入前和离开后的效果
  opacity: 0;
}

过渡类名(Transition Classes)

  1. v-enter：进入式过渡(entering transition)的开始状态。在插入元素之前添加，在插入元素之后一帧移除。
  2. v-enter-active：进入式过渡的激活状态。应用于整个进入式过渡时期。在插入元素之前添加，过渡/动画(transition/animation)完成之后移除。此 class 可用于定义进入式过渡的 duration, delay 和 easing 曲线。
  3. v-enter-to：仅适用于版本 2.1.8+。进入式过渡的结束状态。在插入元素之后一帧添加（同时，移除 v-enter），在过渡/动画完成之后移除。
  4. v-leave：离开式过渡(leaving transition)的开始状态。在触发离开式过渡时立即添加，在一帧之后移除。
  5. v-leave-active：离开式过渡的激活状态。应用于整个离开式过渡时期。在触发离开式过渡时立即添加，在过渡/动画(transition/animation)完成之后移除。此 class 可用于定义离开式过渡的 duration, delay 和 easing 曲线。
  6. v-leave-to：仅适用于版本 2.1.8+。离开式过渡的结束状态。在触发离开式过渡之后一帧添加（同时，移除 v-leave），在过渡/动画完成之后移除。

CSS 过渡(CSS Transitions)

<div id="example-1">
  <button @click="show = !show">
    Toggle render
  </button>
  <transition name="slide-fade">
    <p v-if="show">hello</p>
  </transition>
</div>

new Vue({
  el: ‘#example-1‘,
  data: {
    show: true
  }
})
/* 进入和离开动画可以分别 */
/* 设置不同的持续时间(duration)和动画函数(timing function) */
.slide-fade-enter-active {   //进入过程
  transition: all .3s ease;
}
.slide-fade-leave-active {   //离开过程
  transition: all .8s cubic-bezier(1.0, 0.5, 0.8, 1.0);
}
.slide-fade-enter, .slide-fade-leave-to   //进入开始和离开结束的状态
/* .slide-fade-leave-active 在低于 2.1.8 版本中 */ {
  transform: translateX(10px);
  opacity: 0;
}

CSS 动画(CSS Animations)

<div id="example-2">
  <button @click="show = !show">Toggle show</button>
  <transition name="bounce">
    <p v-if="show">Lorem ipsum dolor sit amet, consectetur adipiscing elit. Mauris facilisis enim libero, at lacinia diam fermentum id. Pellentesque habitant morbi tristique senectus et netus.</p>
  </transition>
</div>

new Vue({
  el: ‘#example-2‘,
  data: {
    show: true
  }
})

.bounce-enter-active {
  animation: bounce-in .5s;        //设定进入过程中执行animation动画bounce-in，时间0.5s
}
.bounce-leave-active { 　　　　　　　　//设定离开过程中逆向（reverse）执行animation： bounce-in 时间0.5s
  animation: bounce-in .5s reverse;
}
@keyframes bounce-in {
  0% {
    transform: scale(0);             //0%时期状态  规模0
  }
  50% {
    transform: scale(1.5); 　　　　　　//50%时期状态 规模1.5
  }
  100% {
    transform: scale(1); 　　　　　　　　//同上
  }
}

自定义过渡的 class 类名(Custom Transition Classes)

你也可以通过提供一下属性来指定自定义过渡类名

  • enter-class
  • enter-active-class
  • enter-to-class (2.1.8+)
  • leave-class
  • leave-active-class
  • leave-to-class (2.1.8+)

它们将覆盖默认约定的类名，这对于将 Vue 的过渡系统和其他现有的第三方 CSS 动画库（如 Animate.css）集成使用会非常有用。

<link href="https://cdn.jsdelivr.net/npm/[email protected]" rel="stylesheet" type="text/css">  //引用animate.css

<div id="example-3">
  <button @click="show = !show">
    Toggle render
  </button>
  <transition
    name="custom-classes-transition"
    enter-active-class="animated tada"              //使用animate.css中的动画，会覆盖本身的v-enter-active类名
    leave-active-class="animated bounceOutRight"  　　//同上
  >
    <p v-if="show">hello</p>
  </transition>
</div>
new Vue({
  el: ‘#example-3‘,
  data: {
    show: true
  }
})

同时使用过渡和动画(Using Transitions and Animations Together)  （不懂，如果使用第三方，类名覆盖了还怎么过度？）

Vue 为了知道过渡何时完成，必须附加相应的事件监听器。它可以是 transitionend 或 animationend，这取决于给元素应用的 CSS 规则。如果你使用其中任何一种，Vue 能自动识别正确的类型并设置相应的事件监听器。

但是，在一些情况下，你可能需要给同一个元素同时设置过渡和动画，比如由 Vue 触发 CSS 动画，同时在鼠标悬停时触发 CSS 过渡。在这种情况下，你可能需要通过 type 属性，来显式声明需要 Vue 监听的类型，值可以是 animation 或 transition。

显式过渡持续时间(Explicit Transition Durations)

你可以使用 <transition> 组件上的 duration 属性 ，来指定一个显式的过渡持续时间（以毫秒为单位）：

<transition :duration="1000">...</transition> //过度持续时间

<transition :duration="{ enter: 500, leave: 800 }">...</transition> //进入和离开分别的持续时间

JavaScript 钩子函数

可以在属性中声明 JavaScript 钩子

<transition
  v-on:before-enter="beforeEnter"
  v-on:enter="enter"
  v-on:after-enter="afterEnter"
  v-on:enter-cancelled="enterCancelled"

  v-on:before-leave="beforeLeave"
  v-on:leave="leave"
  v-on:after-leave="afterLeave"
  v-on:leave-cancelled="leaveCancelled"
>
  <!-- ... -->
</transition>
// ...
methods: {
  // --------
  // 进入时
  // --------

  beforeEnter: function (el) {
    // ...
  },
  // 在与 CSS 结合使用时
  // 此回调函数 done 是可选项
  enter: function (el, done) {
    // ...
    done()
  },
  afterEnter: function (el) {
    // ...
  },
  enterCancelled: function (el) {
    // ...
  },

  // --------
  // 离开时
  // --------

  beforeLeave: function (el) {
    // ...
  },
  // 在与 CSS 结合使用时
  // 此回调函数 done 是可选项
  leave: function (el, done) {
    // ...
    done()
  },
  afterLeave: function (el) {
    // ...
  },
  // leaveCancelled 只能配合 v-show 使用
  leaveCancelled: function (el) {
    // ...
  }
}

这些钩子函数可以结合 CSS 过渡/动画使用，也可以单独使用。

当仅使用 JavaScript 式过渡的时候， 在 enter 和 leave 钩子函数中，必须有 done 回调函数。否则，这两个钩子函数会被同步调用，过渡会立即完成。

推荐对于仅使用 JavaScript 的过渡显式添加 v-bind:css="false"，以便 Vue 可以跳过 CSS 侦测。这也可以防止 CSS 规则意外干涉到过渡。

现在我们深入来看一个示例。这里是一个使用 Velocity.js 的 JavaScript 式过渡：

<!--
Velocity works very much like jQuery.animate and is
a great option for JavaScript animations
-->
<script src="https://lib.baomitu.com/velocity/1.2.3/velocity.min.js"></script> //引用velocity.js

<div id="example-4">
  <button @click="show = !show">
    Toggle
  </button>
  <transition
    v-on:before-enter="beforeEnter"  //监听三个钩子函数，稍后在methods中定义
    v-on:enter="enter"
    v-on:leave="leave"
    v-bind:css="false"  　　　　　　//纯js实现动画，跳过css检测
  >
    <p v-if="show">
      Demo
    </p>
  </transition>
</div>
new Vue({
  el: ‘#example-4‘,
  data: {
    show: false
  },
  methods: {
    beforeEnter: function (el) {    //设定进入开始状态函数
      el.style.opacity = 0
    },
    enter: function (el, done) {     //设定进入过程函数
      Velocity(el, { opacity: 1, fontSize: ‘1.4em‘ }, { duration: 300 })
      Velocity(el, { fontSize: ‘1em‘ }, { complete: done })
    },
    leave: function (el, done) { 　　　　//设定离开过程函数
      Velocity(el, { translateX: ‘15px‘, rotateZ: ‘50deg‘ }, { duration: 600 })
      Velocity(el, { rotateZ: ‘100deg‘ }, { loop: 2 })
      Velocity(el, {
        rotateZ: ‘45deg‘,
        translateY: ‘30px‘,
        translateX: ‘30px‘,
        opacity: 0
      }, { complete: done })
    }
  }
})

在初始渲染时过渡

如果你还想在节点初始渲染时应用过渡，可以添加 appear 属性：

<transition appear>
  <!-- ... -->
</transition>

默认情况下，对于进入和离开，会使用特定过渡。但是，如果你有需要，也可以指定自定义 CSS 类名：

<transition
  appear
  appear-class="custom-appear-class"
  appear-to-class="custom-appear-to-class"（仅 >= 2.1.8 支持）
  appear-active-class="custom-appear-active-class"
>
  <!-- ... -->
</transition>

以及指定自定义 JavaScript 钩子函数：

<transition
  appear
  v-on:before-appear="customBeforeAppearHook"
  v-on:appear="customAppearHook"
  v-on:after-appear="customAfterAppearHook"
  v-on:appear-cancelled="customAppearCancelledHook"
>
  <!-- ... -->
</transition>

多个元素之间切换过渡

我们将在下面讨论多个元素之间切换过渡，但是还是可以使用 v-if/v-else，来对初始元素之间进行切换过渡。最常见的是，一个列表容器和描述列表为空的消息，这两个元素间的切换过渡：

<transition>
  <table v-if="items.length > 0">
    <!-- ... -->
  </table>
  <p v-else>Sorry, no items found.</p>
</transition>

当在具有相同标签名称的元素之间切换时，需要通过给它们分配唯一的 key 属性，以使 Vue 感知它们是不同的元素。否则 Vue 的编译器将因为效率，只会替换元素内部的内容。即使在技术上没有必要，但是，给 <transition> 组件中的多个元素设置 key，被认为是一个最佳实践。

通过给同一元素的 key 属性，设置不同的状态来进行过渡。而无需使用 v-if 和 v-else。

实际上，使用 v-if 的多个元素之间的过渡，还可以改为在单个元素上绑定动态属性的方式，来在任意数量的元素之间进行转换。

<transition>
  <button v-if="docState === ‘saved‘" key="saved">
    Edit
  </button>
  <button v-if="docState === ‘edited‘" key="edited">
    Save
  </button>
  <button v-if="docState === ‘editing‘" key="editing">
    Cancel
  </button>
</transition>

可以重写为：

<transition>
  <button v-bind:key="docState">
    {{ buttonMessage }}
  </button>
</transition>
// ...
computed: {
  buttonMessage: function () {
    switch (this.docState) {
      case ‘saved‘: return ‘Edit‘
      case ‘edited‘: return ‘Save‘
      case ‘editing‘: return ‘Cancel‘
    }
  }
}

过渡模式

当一个过渡进入时，另一个过渡离开。这是 <transition> 的默认行为 - 进入和离开同时发生。

同时生效的进入式和离开式过渡不能满足所有要求，所以 Vue 提供了可选的过渡模式：

  • in-out：新元素先过渡进入(transition in)，过渡完成之后，当前元素过渡离开(transition out)。
  • out-in：当前元素先过渡离开(transition out)，过渡完成之后，新元素过渡进入(transition in)。

多个组件之间过渡

多个组件之间的过渡甚至更简单 - 我们不需要使用 key 属性。相反，我们需要使用动态组件:

<transition name="component-fade" mode="out-in">
  <component v-bind:is="view"></component>
</transition>

new Vue({
  el: ‘#transition-components-demo‘,
  data: {
    view: ‘v-a‘
  },
  components: {
    ‘v-a‘: {
      template: ‘<div>Component A</div>‘
    },
    ‘v-b‘: {
      template: ‘<div>Component B</div>‘
    }
  }
})
.component-fade-enter-active, .component-fade-leave-active {
  transition: opacity .3s ease;
}
.component-fade-enter, .component-fade-leave-to
/* .component-fade-leave-active 在低于 2.1.8 版本中 */ {
  opacity: 0;
}

列表过渡

当我们整个列表的每一项（例如使用 v-for）都需要同时进行渲染呢？在这种情况下，我们将使用 <transition-group> 组件。在我们深入示例之前，先来了解关于这个组件的一些要点：

  • 不同于 <transition>，它会以一个真实元素渲染：默认为 <span>。你也可以通过 tag 属性更换为其他渲染元素
  • 它内部的元素必须具有唯一的 key 属性

进入式/离开式列表过渡

现在让我们来深入一个示例，进入式过渡和离开式过渡都使用与之前相同的 CSS 类名：

<div id="list-demo">
  <button v-on:click="add">Add</button>
  <button v-on:click="remove">Remove</button>
  <transition-group name="list" tag="p">   //列表渲染过度用transition-group标签
    <span v-for="item in items" v-bind:key="item" class="list-item">
      {{ item }}
    </span>
  </transition-group>
</div>
new Vue({
  el: ‘#list-demo‘,
  data: {
    items: [1,2,3,4,5,6,7,8,9],
    nextNum: 10
  },
  methods: {
    randomIndex: function () {
      return Math.floor(Math.random() * this.items.length)   //选取一个随机索引（0.x和当前数组长度乘）
    },
    add: function () {
      this.items.splice(this.randomIndex(), 0, this.nextNum++)     //num++然后加入数组中随机索引位置
    },
    remove: function () {
      this.items.splice(this.randomIndex(), 1)  　　　　　　　　　　　　//随机删除
    },
  }
})
.list-item {
  display: inline-block;
  margin-right: 10px;
}
.list-enter-active, .list-leave-active {
  transition: all 1s;
}
.list-enter, .list-leave-to /* .list-leave-active 在低于 2.1.8 版本中 */ {
  opacity: 0;
  transform: translateY(30px);
}

列表的位移过渡

<transition-group> 组件还有一个暗藏玄机之处。不仅可以在进入和离开时进行动画，还可以在位置改变时进行动画。使用此功能所需要知道的唯一新的概念是，在项目位置改变时添加额外的 v-move 类名。与其他类名相同，它的前缀也和设置的 name 属性的值相匹配，你也可以通过 move-class 属性来手动指定类名。

此类名对于指定过渡时间和 easing 过渡曲线非常有用，如下所示：

<script src="https://lib.baomitu.com/lodash.js/4.14.1/lodash.min.js"></script>  //引用lodash.js

<div id="flip-list-demo" class="demo">
  <button v-on:click="shuffle">Shuffle</button>　　　　　　　　
  <transition-group name="flip-list" tag="ul">               //此标签真实渲染，通过tag设定为ul，下面可用li，不设定默认span标签
    <li v-for="item in items" v-bind:key="item"> 　　　　　　　　//‘一定带唯一的key
      {{ item }}
    </li>
  </transition-group>
</div>
new Vue({
  el: ‘#flip-list-demo‘,
  data: {
    items: [1,2,3,4,5,6,7,8,9]
  },
  methods: {
    shuffle: function () {
      this.items = _.shuffle(this.items)                  //调用loadsh.js中的_.shuffle
    }
  }
})
.flip-list-move { 　　　　　　　　　　　　　　　　　　　　　　　　//列表过度，项目发生改变时会添加额外的v-modle属性，通过设置此属性就可以实现变动的项目的过渡效果
  transition: transform 1s;
}

需要注意的是，使用 FLIP 过渡的元素，在设置为 display: inline 时，无法正常运行。作为替代方案，可以将元素设置为 display: inline-block，或者将元素放置于 flex 上下文(flex context)中。

FLIP 动画不局限于单个轴线方向(single axis)，多个维度网格(multidimensional grid)也同样可以过渡：

列表的渐进过渡

通过 data 属性与 JavaScript 式过渡的通信，就可以实现列表的逐项渐进过渡：

<script src="https://lib.baomitu.com/velocity/1.2.3/velocity.min.js"></script>     //引用velocity.js

<div id="staggered-list-demo">
  <input v-model="query">         //和data中的query对象实现双向绑定，query实时接受input的value
  <transition-group
    name="staggered-fade"
    tag="ul"
    v-bind:css="false"                     //跳过css检测
    v-on:before-enter="beforeEnter"  　　　　//监听js钩子函数
    v-on:enter="enter"
    v-on:leave="leave"
  >
    <li
      v-for="(item, index) in computedList"       //取computedList中的数组成员
      v-bind:key="item.msg"
      v-bind:data-index="index"　　　　　　　　　　　　//？？ 用此属性作为渐进过度的延迟时间计算
    >{{ item.msg }}</li>
  </transition-group>
</div>
new Vue({
  el: ‘#staggered-list-demo‘,
  data: {
    query: ‘‘,
    list: [
      { msg: ‘Bruce Lee‘ },
      { msg: ‘Jackie Chan‘ },
      { msg: ‘Chuck Norris‘ },
      { msg: ‘Jet Li‘ },
      { msg: ‘Kung Fury‘ }
    ]
  },
  computed: {
    computedList: function () {
      var vm = this
      return this.list.filter(function (item) {　　　　　　　　　　　//返回匹配成功的对象数组
        return item.msg.toLowerCase().indexOf(vm.query.toLowerCase()) !== -1      //字母小写=》匹配query   ？？！==-1
      })
    }
  },
  methods: {
    beforeEnter: function (el) {
      el.style.opacity = 0
      el.style.height = 0
    },
    enter: function (el, done) {
      var delay = el.dataset.index * 150 　　　　　　　　//dataset可以读取自定义数据属性，这里dataset.index读取data-index　　　　
      setTimeout(function () { 　　　　　　　　　　　　　　//设定延迟执行时间，这样data-index越大的过度延迟越久，视觉上就实现了逐步渲染
        Velocity(
          el,
          { opacity: 1, height: ‘1.6em‘ },
          { complete: done }
        )
      }, delay)
    },
    leave: function (el, done) {
      var delay = el.dataset.index * 150
      setTimeout(function () {
        Velocity(
          el,
          { opacity: 0, height: 0 },
          { complete: done }
        )
      }, delay)
    }
  }
})

可复用的过渡

通过 Vue 的组件系统可以实现复用过渡。要创建一个可复用过渡，你需要做的就是将 <transition> 或者 <transition-group> 作为组件根节点，然后将全部子内容放置在 transition 组件中就可以了。

Vue.component(‘my-special-transition‘, {
  template: ‘    <transition      name="very-special-transition"      mode="out-in"      v-on:before-enter="beforeEnter"      v-on:after-enter="afterEnter"    >      <slot></slot>    </transition>  ‘,
  methods: {
    beforeEnter: function (el) {
      // ...
    },
    afterEnter: function (el) {
      // ...
    }
  }
})

函数组件更适合完成这个任务：

Vue.component(‘my-special-transition‘, {
  functional: true,
  render: function (createElement, context) {
    var data = {
      props: {
        name: ‘very-special-transition‘,
        mode: ‘out-in‘
      },
      on: {
        beforeEnter: function (el) {
          // ...
        },
        afterEnter: function (el) {
          // ...
        }
      }
    }
    return createElement(‘transition‘, data, context.children)
  }
})

动态过渡

其实，在 Vue 中即使是过渡也是由数据驱动的！动态过渡最基本的例子是，将 name 属性(attribute)和动态属性(dynamic property)绑定在一起。

当你使用多个 Vue 过渡类名约定，来定义 CSS 过渡/动画，并在不同的类名约定之间切换时，动态过渡会非常有用。

所有的过渡属性都可以动态绑定。并且不仅是属性，由于事件钩子函数都是 Vue 的方法(methods)，所以可以从 this 上下文访问到所有数据。这意味着，根据组件的状态，JavaScript 式过渡的表现可能会有所不同。

<script src="https://lib.baomitu.com/velocity/1.2.3/velocity.min.js"></script>

<div id="dynamic-fade-demo" class="demo">
  Fade In: <input type="range" v-model="fadeInDuration" min="0" v-bind:max="maxFadeDuration">     //动态绑定max属性到data，但是有何意义?
  Fade Out: <input type="range" v-model="fadeOutDuration" min="0" v-bind:max="maxFadeDuration">
  <transition
    v-bind:css="false"
    v-on:before-enter="beforeEnter"
    v-on:enter="enter"
    v-on:leave="leave"
  >
    <p v-if="show">hello</p>
  </transition>
  <button
    v-if="stop"
    v-on:click="stop = false; show = false"
  >Start animating</button>
  <button
    v-else
    v-on:click="stop = true"
  >Stop it!</button>
</div>
new Vue({
  el: ‘#dynamic-fade-demo‘,
  data: {
    show: true,
    fadeInDuration: 1000,
    fadeOutDuration: 1000,
    maxFadeDuration: 1500,
    stop: true
  },
  mounted: function () {
    this.show = false
  },
  methods: {
    beforeEnter: function (el) {
      el.style.opacity = 0
    },
    enter: function (el, done) {
      var vm = this
      Velocity(el,
        { opacity: 1 },
        {
          duration: this.fadeInDuration,
          complete: function () {
            done()
            if (!vm.stop) vm.show = false
          }
        }
      )
    },
    leave: function (el, done) {
      var vm = this
      Velocity(el,
        { opacity: 0 },
        {
          duration: this.fadeOutDuration,
          complete: function () {
            done()
            vm.show = true
          }
        }
      )
    }
  }
})

原文地址：https://www.cnblogs.com/FunkyEric/p/9028161.html

时间： 2024-10-07 19:12:16

VUE2中文文档：进入、离开和列表过度的相关文章

VUE2中文文档：组件基础篇

组件基础 组件(component),是具有 name 名称的可复用 Vue 实例:当前示例中是 <button-counter>.我们可以使用 new Vue 创建出一个 Vue 根实例,然后将这个组件作为其中的一个自定义元素(custom element). 由于组件是可复用的 Vue 实例,它们接收的选项,和在 new Vue 时候的选项相同,例如 data, computed, watch, methods 和生命周期钩子.唯一的例外是,类似 el 这样,根实例上特有(root-spe

Oracle metalink 中文文档列表 - Oracle EBS

中文文档列表 - Oracle EBS (Enterprise Business Suite) (文档 ID 1553829.1) https://support.oracle.com/epmos/faces/DocumentDisplay?parent=DOCUMENT&id=1553829.1 原文地址:http://blog.51cto.com/baser/2323327

Bottle 中文文档

译者: smallfish ([email protected]) 更新日期: 2009-09-25 原文地址: http://bottle.paws.de/page/docs (已失效) 译文地址: http://pynotes.appspot.com/static/bottle/docs.htm (需翻墙) 这份文档会不断更新. 如果在文档里没有找到答案,请在版本跟踪中提出 issue. 基本映射 映射使用在根据不同 URLs 请求来产生相对应的返回内容. Bottle 使用 route()

OkHttp 官方中文文档

OkHttp官方中文文档 本文结构 Calls Connections Recipes Interceptors HTTPS 本文翻译来自 官方OkHttp Wiki OkHttp官方中文文档 一Calls 1 请求 2 响应 3重写请求 4重写响应 5后续请求 6请求重试 7 呼叫 8调度 二Connections 1URLs URLs摘要 2 Addresses 3 Routes 4Connections 三Recipes 1同步获取 2异步获取 3访问头 4Posting a String

Hadoop-2.2.0中文文档—— Common - CLI MiniCluster

目的 使用 CLI MiniCluster, 用户可以简单地只用一个命令就启动或关闭一个单一节点的Hadoop集群,不需要设置任何环境变量或管理配置文件. CLI MiniCluster 同时启动一个 YARN/MapReduce 和 HDFS 集群. 这对那些想要快速体验一个真实的Hadoop集群或是测试依赖明显的Hadoop函数的非Java程序 的用户很有用. Hadoop Tarball 你需要从发布页获取tar包.或者,你可以从源码中自己编译. $ mvn clean install -

Hadoop-2.2.0中文文档——MapReduce 下一代 -——集群配置

目的 这份文档描写叙述了怎样安装.配置和管理从几个节点到有数千个节点的Hadoop集群. 玩的话,你可能想先在单机上安装.(看单节点配置). 准备 从Apache镜像上下载一个Hadoop的稳定版本号. 安装 安装一个Hadoop集群,一般包含分发软件到全部集群中的机器上或者是安装RPMs. 一般地,集群中的一台机器被唯一地设计成NameNode,还有一台机器被设置成ResourceManager.这是master(主). 集群中剩下的机器作为DataNode 和 NodeManager.这些是

MyBatis Generator中文文档

MyBatis Generator中文文档 MyBatis Generator中文文档地址: http://mbg.cndocs.tk/ 该中文文档由于尽可能和原文内容一致,所以有些地方如果不熟悉,看中文版的文档的也会有一定的障碍,所以本章根据该中文文档以及实际应用,使用通俗的语言来讲解详细的配置. 本文中所有节点的链接都是对应的中文文档地址,可以点击查看详细信息. 下载本文档的PDF版本 注:本文后面提到的MBG全部指代MyBatis Generator. 运行MyBatis Generato

Hadoop-2.2.0中文文档—— Common - 超级用户模拟别的用户

pcDuino3下支持mmc启动,官方的Uboot是采用SPL框架实现的,因为内部的SRAM空间达到32K,我们完全可以在这32K空间内编写一个完整可用小巧的bootloader来完成引导Linux kernel的目的. 我们首先介绍下SPL框架,可以先看下<GNU ARM汇编--(十八)u-boot-采用nand_spl方式的启动方法>和<GNU ARM汇编--(十九)u-boot-nand-spl启动过程分析>,NAND_SPL也算是SPL框架下的一种模式. 当使用Nand f

Hadoop-2.2.0中文文档—— 从Hadoop 1.x 迁移至 Hadoop 2.x

简介 本文档对从 Apache Hadoop 1.x 迁移他们的Apache Hadoop MapReduce 应用到 Apache Hadoop 2.x 的用户提供了一些信息. 在 Apache Hadoop 2.x 中,我们已经把资源管理功能放入 分布式应用管理框架 的Apache Hadoop YARN,而 Apache Hadoop MapReduce (亦称 MRv2) 保持为一个纯分布式计算框架. 总之,之前的 MapReduce 运行时 (亦称 MRv1) 已经被重用并且不会有重大