Hadoop学习5

已于 2022-07-24 13:14:10 修改
阅读量403 收藏 2
点赞数 1
文章标签： hadoop 学习 mapreduce
于 2022-07-24 12:01:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56660665/article/details/125957677
版权
本文详细解读了MapReduce的核心概念、优缺点、编程模型，以及如何编写WordCount示例，还介绍了序列化在Hadoop中的重要性和自定义对象的实现。深入探讨了InputFormat切片机制，以及如何利用CombineTextInputFormat优化小文件处理。
摘要由CSDN通过智能技术生成

Hadoop学习(五)

1.什么是MapReduce

定义：

MapReduce 是一个分布式运算程序的编程框架，是用户开发“基于 Hadoop 的数据分析 应用”的核心框架。

核心功能：

MapReduce 核心功能是将用户编写的业务逻辑代码和自带默认组件整合成一个完整的 分布式运算程序，并发运行在一个 Hadoop 集群上。

2.MapReduce优缺点

1.优点:

（1）易于编程

它简单的实现一些接口，就可以完成一个分布式程序，这个分布式程序可以分布到大量 廉价的 PC 机器上运行。也就是说你写一个分布式程序，跟写一个简单的串行程序是一模一 样的。就是因为这个特点使得 MapReduce 编程变得非常流行。

（2）良好的拓展性

当你的计算资源不能得到满足的时候，你可以通过简单的增加机器来扩展它的计算能力。

（3）高容错性

MapReduce 设计的初衷就是使程序能够部署在廉价的 PC 机器上，这就要求它具有很高 的容错性。比如其中一台机器挂了，它可以把上面的计算任务转移到另外一个节点上运行， 不至于这个任务运行失败，而且这个过程不需要人工参与，而完全是由 Hadoop 内部完成的。

（4）适合PB级以上的海量数据离线处理

可以实现上千台服务器集群并发工作，提供数据处理能力。

2.缺点

（1）不擅长实时计算

MapReduce 无法像 MySQL 一样，在毫秒或者秒级内返回结果。

（2）不擅长流式计算

流式计算的输入数据是动态的，而 MapReduce 的输入数据集是静态的，不能动态变化。 这是因为 MapReduce 自身的设计特点决定了数据源必须是静态的。

（3）不擅长 DAG（有向无环图）计算

多个应用程序存在依赖关系，后一个应用程序的输入为前一个的输出。在这种情况下， MapReduce 并不是不能做，而是使用后，每个 MapReduce 作业的输出结果都会写入到磁盘， 会造成大量的磁盘 IO，导致性能非常的低下。

3.MapReduce核心思想

（1）分布式的运算程序往往需要分成至少 2 个阶段。

（2）第一个阶段的 MapTask 并发实例，完全并行运行，互不相干。

（3）第二个阶段的 ReduceTask 并发实例互不相干，但是他们的数据依赖于上一个阶段 的所有 MapTask 并发实例的输出。

（4）MapReduce 编程模型只能包含一个 Map 阶段和一个 Reduce 阶段，如果用户的业 务逻辑非常复杂，那就只能多个 MapReduce 程序，串行运行。
在这里插入图片描述

4.MapReduce进程

一个完整的 MapReduce 程序在分布式运行时有三类实例进程：

（1）MrAppMaster：负责整个程序的过程调度及状态协调。

（2）MapTask：负责 Map 阶段的整个数据处理流程。

（3）ReduceTask：负责 Reduce 阶段的整个数据处理流程。

5.常用数据序列化类型

Java 类型 Hadoop Writable 类型

Boolean BooleanWritable

Byte ByteWritable

Int IntWritable

Float FloatWritable

Long LongWritable

Double DoubleWritable

String Text

Map MapWritable

Array ArrayWritable

Null NullWritable

6.MapReduce编写规范

用户编写的程序分成三个部分：Mapper、Reducer 和 Driver。

1．Mapper阶段

（1）用户自定义的Mapper要继承自己的父类

（2）Mapper的输入数据是KV对的形式（KV的类型可自定义）

（3）Mapper中的业务逻辑写在map()方法中

（4）Mapper的输出数据是KV对的形式（KV的类型可自定义）

（5）map()方法（MapTask进程）对每一个KV调用一次

2．Reducer阶段

（1）用户自定义的Reducer要继承自己的父类

（2）Reducer的输入数据类型对应Mapper的输出数据类型，也是KV

（3）Reducer的业务逻辑写在reduce()方法中

（4）ReduceTask进程对每一组相同k的组调用一次reduce()方法

3．Driver阶段

相当于YARN集群的客户端，用于提交我们整个程序到YARN集群，提交的是 封装了MapReduce程序相关运行参数的job对象。

7.编写案例

1.WordCount

Mapper类

package com.simon.mapreduce.wordcount2;

import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;

import java.io.IOException;

/**
 * KEYIN map阶段输入的key的类型（偏移量） LongWritable
 * VALUEIN map阶段输入的value的类型(Text)
 * KEYOUT map阶段输出的key类型 Text
 * VALUEOUT map阶段输出的value类型 IntWritable
 * */
public class WordCountMapper extends Mapper<LongWritable, Text,Text, IntWritable> {
    private Text outK = new Text();
    private IntWritable outV = new IntWritable(1);
    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        //1.获取一行 atguigu atguigu
        String line = value.toString();
        String[] words = line.split(" "); //[atguigu,atguigu]
        //循环写出
        for (String word : words) {
            outK.set(word);
            context.write(outK,outV);
            //3.写出
        }

    }
}

Reducer类

package com.simon.mapreduce.wordcount2;

import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;

import java.io.IOException;

public class WordCountReducer extends Reducer<Text, IntWritable,Text,IntWritable> {
    protected IntWritable outV = new IntWritable();
    @Override
    protected void reduce(Text key, Iterable<IntWritable> values, Context context) throws IOException, InterruptedException {
        int sum = 0;
        for (IntWritable value : values) {
            sum+=value.get();
        }
        outV.set(sum);
        context.write(key,outV);
    }
}

Driver类

package com.simon.mapreduce.wordcount2;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

import java.io.IOException;

public class WordCountDriver {
    public static void main(String[] args) throws IOException, InterruptedException, ClassNotFoundException {
        //1.获取job对象
        Configuration conf = new Configuration();
        Job job = Job.getInstance(conf);
        //2.设置jar包路径
        job.setJarByClass(WordCountDriver.class);
        //3.关联mapper和reducer
        job.setMapperClass(WordCountMapper.class);
        job.setReducerClass(WordCountReducer.class);
        //4.设置map输出的k-v类型
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(IntWritable.class);
        //5.设置最终输出的k-v类型
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(IntWritable.class);
        //6.设置输入和输出路径
        FileInputFormat.setInputPaths(job,new Path(args[0]));
        FileOutputFormat.setOutputPath(job,new Path(args[1]));
        //7.提交作业
        boolean result = job.waitForCompletion(true);
        System.exit(result?0:1);
    }

}

2.序列化

（1）什么是序列化：

序列化就是把内存中的对象，转换成字节序列（或其他数据传输协议）以便于存储到磁 盘（持久化）和网络传输。

反序列化:

反序列化就是将收到字节序列（或其他数据传输协议）或者是磁盘的持久化数据，转换 成内存中的对象。

（2）为什么要序列化

一般来说，“活的”对象只生存在内存里，关机断电就没有了。而且“活的”对象只能 由本地的进程使用，不能被发送到网络上的另外一台计算机。 然而序列化可以存储“活的” 对象，可以将“活的”对象发送到远程计算机。

（3）为什么不用java的序列化

Java 的序列化是一个重量级序列化框架（Serializable），一个对象被序列化后，会附带 很多额外的信息（各种校验信息，Header，继承体系等），不便于在网络中高效传输。所以， Hadoop 自己开发了一套序列化机制（Writable）。

（4）hadoop的序列化特点

​ 1.紧凑 ：高效使用存储空间。

​ 2.快速：读写数据的额外开销小。

​ 3.互操作：支持多语言的交互

思考：如果我想要在K,V里面使用我自定义的对象，那么就要实现序列化，否则在集群的不同服务器不能互相传输

自定义bean对象实现序列化接口（7大步骤）

（1）必须实现 Writable 接口

（2）反序列化时，需要反射调用空参构造函数，所以必须有空参构造

（3）重写序列化方法

（4）重写反序列化方法

（5）注意反序列化的顺序和序列化的顺序完全一致

（6）要想把结果显示在文件中，需要重写 toString()，可用"\t"分开，方便后续用。

（7）如果需要将自定义的 bean 放在 key 中传输，则还需要实现 Comparable 接口，因为 MapReduce 框中的 Shuffle 过程要求对 key 必须能排序。（自定义排序）

序列化对象实操

统计每一个手机号耗费的总上行流量、总下行流量、总流量

输入数据格式：

id 手机号码 网络 ip 上行流量 下行流量 网络状态码

7 13560436666 120.196.100.99 1116 954 200

期望输出数据格式：

手机号码 上行流量 下行流量 总流量

13560436666 1116 954 2070

代码实现：

Mapper类

package com.simon.mapreduce.writablecomparable;

import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;

import java.io.IOException;

public class FlowMapper extends Mapper<LongWritable, Text, FlowBean, Text>
{
    private FlowBean outK = new FlowBean();
    private Text outV = new Text();
    @Override
    protected void map(LongWritable key, Text value, Context context)
            throws IOException, InterruptedException {
        //1 获取一行数据
        String line = value.toString();
        //2 按照"\t",切割数据
        String[] split = line.split("\t");
        //3 封装 outK outV
        outK.setUpFlow(Long.parseLong(split[1]));
        outK.setDownFlow(Long.parseLong(split[2]));
        outK.setSumFlow();
        outV.set(split[0]);
        //4 写出 outK outV
        context.write(outK,outV);
    }
}

Reducer类

package com.simon.mapreduce.writablecomparable;

import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;

import java.io.IOException;


public class FlowReducer extends Reducer<FlowBean, Text, Text, FlowBean>
{
    @Override
    protected void reduce(FlowBean key, Iterable<Text> values, Context
            context) throws IOException, InterruptedException {
        //遍历 values 集合,循环写出,避免总流量相同的情况
        for (Text value : values) {
            //调换 KV 位置,反向写出
            context.write(value,key);
        }
    }
}

Driver类

package com.simon.mapreduce.writablecomparable;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

import java.io.IOException;

public class FlowDriver {
    public static void main(String[] args) throws IOException,
            ClassNotFoundException, InterruptedException {
        //1 获取 job 对象
        Configuration conf = new Configuration();
        Job job = Job.getInstance(conf);
        //2 关联本 Driver 类
        job.setJarByClass(FlowDriver.class);
        //3 关联 Mapper 和 Reducer
        job.setMapperClass(FlowMapper.class);
        job.setReducerClass(FlowReducer.class);
        //4 设置 Map 端输出数据的 KV 类型
        job.setMapOutputKeyClass(FlowBean.class);
        job.setMapOutputValueClass(Text.class);
        //5 设置程序最终输出的 KV 类型
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(FlowBean.class);
        //6 设置输入输出路径
        FileInputFormat.setInputPaths(job, new Path("D:\\output\\output2"));
        FileOutputFormat.setOutputPath(job, new Path("D:\\output\\comparout"));
        //7 提交 Job
        boolean b = job.waitForCompletion(true);
        System.exit(b ? 0 : 1);
    }
}

Bean类

package com.simon.mapreduce.wirtable;

import org.apache.hadoop.io.Writable;

import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;

/**
 * 序列化过程
 * 定义类实现writable接口
 * 重写序列化和反序列化方法
 * 重写空参构造
 * 重写toSrting用于打印输出
 * */
public class FlowBean implements Writable {
    private long upFlow;//上行流量
    private long downFlow;//下行流量
    private long sumFlow;//总流量

    public long getUpFlow() {
        return upFlow;
    }

    public void setUpFlow(long upFlow) {
        this.upFlow = upFlow;
    }

    public long getDownFlow() {
        return downFlow;
    }

    public void setDownFlow(long downFlow) {
        this.downFlow = downFlow;
    }

    public long getSumFlow() {
        return sumFlow;
    }

    public void setSumFlow(long sumFlow) {
        this.sumFlow = sumFlow;
    }
    public void setSumFlow() {
        this.sumFlow = this.downFlow+this.upFlow;
    }

    @Override
    public void write(DataOutput dataOutput) throws IOException {
        dataOutput.writeLong(upFlow);
        dataOutput.writeLong(downFlow);
        dataOutput.writeLong(sumFlow);
    }

    @Override
    public void readFields(DataInput dataInput) throws IOException {
        this.upFlow = dataInput.readLong();
        this.downFlow = dataInput.readLong();
        this.sumFlow = dataInput.readLong();
    }
    //空参构造
    public FlowBean() {
    }
    //重写toString

    @Override
    public String toString() {
        return  upFlow + "\t" + downFlow + "\t" + sumFlow ;
    }
}

MapReduce框架原理

在这里插入图片描述

1.InputFormat 数据输入
1. 切片与 MapTask 并行度决定机制

（1）问题引入：

MapTask 的并行度决定 Map 阶段的任务处理并发度，进而影响到整个 Job 的处理速度。 思考：1G 的数据，启动 8 个 MapTask，可以提高集群的并发处理能力。那么 1K 的数 据，也启动 8 个 MapTask，会提高集群性能吗？MapTask 并行任务是否越多越好呢？哪些因 素影响了 MapTask 并行度？

（2）MapTask 并行度决定机制：

数据块：Block 是 HDFS 物理上把数据分成一块一块。数据块是 HDFS 存储数据单位。

数据切片：数据切片只是在逻辑上对输入进行分片，并不会在磁盘上将其切分成片进行 存储。数据切片是 MapReduce 程序计算输入数据的单位，一个切片会对应启动一个 MapTask。

在这里插入图片描述

2. Job 提交流程源码和切片源码详解

①Job 提交流程源码详解

waitForCompletion()
submit();
// 1 建立连接
connect();
// 1）创建提交 Job 的代理
new Cluster(getConfiguration());
// （1）判断是本地运行环境还是 yarn 集群运行环境
initialize(jobTrackAddr, conf); 
// 2 提交 job
submitter.submitJobInternal(Job.this, cluster)
// 1）创建给集群提交数据的 Stag 路径
Path jobStagingArea = JobSubmissionFiles.getStagingDir(cluster, conf);
// 2）获取 jobid ，并创建 Job 路径
JobID jobId = submitClient.getNewJobID();
// 3）拷贝 jar 包到集群
copyAndConfigureFiles(job, submitJobDir);
rUploader.uploadFiles(job, jobSubmitDir);
// 4）计算切片，生成切片规划文件
writeSplits(job, submitJobDir);
maps = writeNewSplits(job, jobSubmitDir);
input.getSplits(job);
// 5）向 Stag 路径写 XML 配置文件
writeConf(conf, submitJobFile);
conf.writeXml(out);
// 6）提交 Job,返回提交状态
status = submitClient.submitJob(jobId, submitJobDir.toString(),job.getCredentials());

在这里插入图片描述

②FileInputFormat 切片源码解析（input.getSplits(job)）

（1）程序先找到你数据存储的目录。

（2）开始遍历处理（规划切片）目录下的每一个文件

（3）遍历第一个文件ss.txt

​ （a）获取文件大小fs.sizeOf(ss.txt)

​ （b）计算切片大小 computeSplitSize(Math.max(minSize,Math.min(maxSize,blocksize)))=blocksize=128M

​ （c）默认情况下，切片大小=blocksize

​ （d）开始切，形成第1个切片：ss.txt—0:128M 第2个切片ss.txt—128:256M 第3个切片ss.txt—256M:300M （每次切片时，都要判断切完剩下的部分是否大于块的1.1倍，不大于1.1倍就划分一块切片）

​ （e）将切片信息写到一个切片规划文件中

​ （f）整个切片的核心过程在getSplit()方法中完成

​ （g）InputSplit只记录了切片的元数据信息，比如起始位置、长度以及所在的节点列表等。

（4）提交切片规划文件到YARN上，YARN上的MrAppMaster就可以根据切片规划文件计算开启MapTask个数。

3. FileInputFormat 切片机制

切片机制：

（1）简单地按照文件的内容长度进行切片

（2）切片大小，默认等于Block大小

（3）切片时不考虑数据集整体，而是逐个针对每一个文件单独切片

切片大小计算公式：

ath.max(minSize, Math.min(maxSize, blockSize));

mapreduce.input.fileinputformat.split.minsize=1 默认值为1

mapreduce.input.fileinputformat.split.maxsize= Long.MAXValue 默认值Long.MAXValue

因此，默认情况下，切片大小=blocksize。

4.FileInputFormat实现类

①思考：在运行 MapReduce 程序时，输入的文件格式包括：基于行的日志文件、二进制 格式文件、数据库表等。那么，针对不同的数据类型，MapReduce 是如何读取这些数据的呢？

FileInputFormat 常见的接口实现类包括：TextInputFormat、KeyValueTextInputFormat、 NLineInputFormat、CombineTextInputFormat 和自定义 InputFormat 等。

②TextInputFormat

TextInputFormat 是默认的 FileInputFormat 实现类。按行读取每条记录。键是存储该行在整个文件中的起始字节偏移量， LongWritable 类型。值是这行的内容，不包括任何行终止 符（换行符和回车符），Text 类型。

示例：

Rich learning form
Intelligent learning engine
Learning more convenient
From the real demand for more close to the enterprise

每条记录表示为以下键/值对：

(0,Rich learning form)
(20,Intelligent learning engine)
(49,Learning more convenient)
(74,From the real demand for more close to the enterprise)

③ CombineTextInputFormat

应用场景：CombineTextInputFormat 用于小文件过多的场景，它可以将多个小文件从逻辑上规划到 一个切片中，这样，多个小文件就可以交给一个 MapTask 处理。

虚拟切片最大值设置

CombineTextInputFormat.setMaxInputSplitSize(job, 4194304);// 4m

注意：虚拟存储切片最大值设置最好根据实际的小文件大小情况来设置具体的值。

示例过程 ：
在这里插入图片描述
虚拟存储过程：

​ 将输入目录下所有文件大小，依次和设置的 setMaxInputSplitSize 值比较，如果不 大于设置的最大值，逻辑上划分一个块。如果输入文件大于设置的最大值且大于两倍， 那么以最大值切割一块；当剩余数据大小超过设置的最大值且不大于最大值 2 倍，此时 将文件均分成 2 个虚拟存储块（防止出现太小切片）。

​ 将文件均分成 2 个虚拟存储块（防止出现太小切片）。 例如 setMaxInputSplitSize 值为 4M，输入文件大小为 8.02M，则先逻辑上分成一个 4M。剩余的大小为 4.02M，如果按照 4M 逻辑划分，就会出现 0.02M 的小的虚拟存储 文件，所以将剩余的 4.02M 文件切分成（2.01M 和 2.01M）两个文件。

切片过程：

（a）判断虚拟存储的文件大小是否大于 setMaxInputSplitSize 值，大于等于则单独 形成一个切片。

（b）如果不大于则跟下一个虚拟存储文件进行合并，共同形成一个切片。

（c）测试举例：有 4 个小文件大小分别为 1.7M、5.1M、3.4M 以及 6.8M 这四个小 文件，则虚拟存储之后形成 6 个文件块，大小分别为： 1.7M，（2.55M、2.55M），3.4M 以及（3.4M、3.4M） 最终会形成 3 个切片，大小分别为： （1.7+2.55）M，（2.55+3.4）M，（3.4+3.4）M

案例实操：

将输入的大量小文件合并成一个切片统一处理。

（1）输入数据 准备 4 个小文件分别叫a,b,c,d.txt

（2）期望 期望一个切片处理 4 个文件

过程：

在驱动类添加代码如下：

// 如果不设置 InputFormat，它默认用的是 TextInputFormat.class
job.setInputFormatClass(CombineTextInputFormat.class);
//虚拟存储切片最大值设置 4m
CombineTextInputFormat.setMaxInputSplitSize(job, 4194304);

发现原本切片数为4，现在变为3

如果想要弄成一个切片

在驱动类添加代码如下：

// 如果不设置 InputFormat，它默认用的是 TextInputFormat.class
job.setInputFormatClass(CombineTextInputFormat.class);
//虚拟存储切片最大值设置 20m
CombineTextInputFormat.setMaxInputSplitSize(job, 20971520);
StopM
关注
Hadoop学习资料
12-28
以上总结的知识点均来自给定文件的内容，涵盖了Hadoop的学习资料、版本历史、生态圈、安装、HDFS、MapReduce、Zookeeper、HBase、Hive、Storm以及数据挖掘和推荐系统等多个方面，为学习和使用Hadoop提供了全面的理论...
Hadoop学习笔记
02-26
Hadoop学习笔记，自己总结的一些Hadoop学习笔记，比较简单。
MapReduce框架学习（3）——Job的创建及配置
xiaozhou的博客
10-27 3004
参考：JeffreyZhou的博客园 《Hadoop权威指南》第四版 0 一个MR作业，包括三点： 输入数据 MR程序 配置信息 前面两篇学习了数据格式和MR过程（map函数和reduce函数），那么今天再讲一下配置信息，是怎么把 数据 和 程序结合起来的。 3.1 代码 打算对照代码来讲解，这样可能要有逻辑一点，不至于讲到最后都不知道自己的线索在哪。先贴上WordCount中的Job...
2021-07-15
weixin_44798044的博客
07-15 521
publicstaticclassdoMapperextendsMapper<Object,Text,Text,IntWritable>{ //第一个Object表示输入key的类型；第二个Text表示输入value的类型； //第三个Text表示表示输出键的类型；第四个IntWritable表示输出值的类型 publicstaticfinalIntWritableone=newIntWritable(1); publi...
MapReduce基础原理及应用
妖精小狗的博客
04-07 6095
MapReduce基础原理： MapReduce（起源于Google）： MapReduce是一种计算模型，它将大型数据操作作业分解为可以跨服务器集群并行执行的单个任务。用于管理DataNode 用于大规模数据处理：每个节点处理存储在该节点上的数据 每个MapReduce工作由两个阶段组成：Map；Reduce 自动MapReduce计算： MapReduce计算是并行和自动分布的 ...
大数据（十一）：Shuffle机制（Combiner合并、辅助排序(分组)GroupingComparator）与小文件处理实战（自定义InputFormat）
敲代码的旺财的博客
09-10 781
这章主要是大数据（九）和大数据（十）的补充 如果是学习大数据的请仔细阅读之前的文章 大数据（九）：https://blog.csdn.net/qq_34886352/article/details/82461919 大数据（十）：https://blog.csdn.net/qq_34886352/article/details/82498134 一、Combiner合并 1.Combin...
Hadoop学习心得
a2516531763的博客
05-06 1796
自从我开始接触Hadoop，这个大数据处理的开源框架，我的学习之路就充满了挑战与收获。Hadoop以其强大的数据处理能力和高度的可扩展性，成为了大数据领域的一颗璀璨明星。以下是我对Hadoop学习的一些心得和体会。在开始学习Hadoop之前，我对大数据和分布式计算的概念还相对模糊。但随着对Hadoop的深入了解，我逐渐认识到它的重要性。Hadoop不仅仅是一个技术框架，更是一种处理大数据的思维方式。它通过将数据划分为多个小块，并在集群中的多个节点上并行处理，从而实现了对海量数据的快速处理。
Hadoop学习5-3：HDFS回收站
qq_43967413的博客
12-10 2157
1 回收站配置2 启回收站功能参数说明3 删除内容查看4 回收站内容恢复5 删除数据不经过回收站6 回收站清空7 客户端操作 开启回收站功能,可以将删除的文件在不超时的情况下,恢复原数据,起到防止误删除、备份等作用 1 回收站配置 在core-site.xml文件中添加如下内容，数字单位为分钟 <property> <name>fs.trash.interval</name> <value>1</value> </propert.
hadoop 学习心得
liyamg的专栏
04-18 4565
Hbase 即 Hadoopbase 类似 database的叫法，虽然已经有HDFS了(Hadoop Distributed File System)，但是还需要删除 和 修改，所以，又有了Hbase： 分布式的，非结构化数据存储的，面向列的，关系数据库。
前期Hadoop学习总结
2301_77836489的博客
04-23 1836
前期Hadoop学习总结
hadoop学习路线图
程序员日常
12-03 5808
Hadoop是一个由Apache基金会所开发的分布式系统基础架构。用户可以在不了解分布式底层细节的情况下，开发分布式程序。充分利用集群的威力进行高速运算和存储。而对于hadoop的学习是大数据学习中的重要一个环节，于是乎有很多人想要知道hadoop学习路线图。 大致的思路是：以安装部署Apache Hadoop2.x版本为主线，来介绍Hadoop2.x的架构组成、各模块协同工作原理、技术细节。安...
hadoop学习
热门推荐
言之。
07-04 1万+
安装 下载hadoop2.10.1(清华源) 解压 tar -zxvf hadoop.tar.gz 配置环境变量 vim /etc/profile export JAVA_HOME=... export HADOOP_HOME=... export PATH=$PATH:$JAVA_HOME/bin:$HADOOP_HOME/bin:$HADOOP_HOME/sbin source /etc/profile 如果是yum安装的java, 查看JAVA_HOME https://www.cnblogs.
大数据之Hadoop学习教程+笔记合计_超详细完整.zip
01-07
大数据之Hadoop学习教程+笔记合计_超详细完整.zip
WPF 特性------Binding
Nick_H 的专栏
11-01 234
【代码】WPF 特性------Binding。
Hadoop期末复习（完整版）
m0_74922316的博客
11-01 566
复习之前我们要有目的性，明确考什么，不考什么。对于hadoop来说，首先理论方面是跑不掉的，而且还是重中之重。例如：hdfs的读写流程，hdfs副本机制等等。其次是hadoop命令,如果学习了hadoop不了解hadoop dfs …和hdfs dfs …那么你可以重修了。最后要明确那一部分会出什么题。下面背景色或者字体改变的背过就完了。
Hadoop简介及单点伪分布式安装
最新发布
qq_51180928的博客
11-04 267
Hadoop是一个由Apache软件基金会开发的分布式系统基础架构，它实现了一个分布式文件系统HDFS。HDFS具有高容错性，可以部署在价格低廉的硬件上，能提供高吞吐量来访问应用程序的数据。Hadoop的另一个核心设计就是MapReduce，MapReduce为海量的数据提供了计算。
嵌入式通信协议：UART简明学习笔记
weixin_73867577的博客
10-31 800
学习UART串口的简明学习笔记
ORB-SLAM2源码学习：ORBextractor.cc：IC_Angle 利用灰度质心法求解关键点方向角
2301_76831056的博客
11-01 679
IC_Angle 利用灰度质心法求解关键点方向角并在computeOrientation函数中被调用计算图像中所有特征点的方向。
Hadoop课程学习资源压缩包
文件列表中的‘文档.pdf’很可能是一个详细的Hadoop学习手册或指南，这可能包括了安装、配置、使用Hadoop集群的基本指南，以及对Hadoop的核心组件，比如HDFS（Hadoop分布式文件系统）、YARN（Yet Another Resource ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值