Hadoop的第二个核心组件:MapReduce框架第二节

这篇具有很好参考价值的文章主要介绍了Hadoop的第二个核心组件:MapReduce框架第二节。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

六、MapReduce的工作流程原理(简单版本)

1、客户端在执行MR程序时,客户端先根据设置的InputFormat实现类去对输入的数据文件进行切片(getSplits),如果没有设置InputFormat实现类,MR程序会使用默认的实现类(TextInputFormat–>FileInputFormat的子类)进行切片规划,生成一个切片规划文件

2、客户端的切片规划文件生成以后,客户端还会把整个MR程序的配置项(Configuration配置),会封装成为一个job.xml文件,同时还会把MR程序的代码包括job.xml文件、切片规划文件提交给资源调度器(YARN/windowsCPU),资源调度器会先分配资源启动MRAPPMaster的进程

3、MRAPPMaster会根据切片规划的切片个数,向资源调度器申请资源启动对应个数的MapTask任务去运行Mapper阶段的计算逻辑

4、MapTask启动成功以后会根据切片规划,借助指定的InputFormat的实现类中createRecoder方法去对应的切片中读取k-v数据,然后交给map方法做处理

5、map方法将切片的k-v数据处理完成,会k-v数据写到一个内存缓冲区中(100M),如果内存缓冲区超过容量的80%,会溢写磁盘,溢写磁盘的时候会根据map输出的key值进行排序,同时还会根据指定的Partitioner分区机制进行分区。溢写文件可能会存在多个,等map阶段执行完成,每一个MapTask对应的多个溢写文件以及缓冲区中还没有溢写的数据整体会进行一次合并,形成一个最终的大文件(分区排序)

6、紧跟着MRAPPMaster会向资源管理器申请资源启动ReduceTask,ReduceTask启动成功会从不同的MapTask的合并的大的溢写文件中去复制对应的分区的数据,ReduceTask会对所有复制过来的数据再进行一次排序。

7、ReduceTask会对排好序的数据按照key进行分组,分好组之后一组相同的key值调用一次reduce方法进行计算,计算完成的数据会借助指定的OutputFormat类(没有指定,默认使用TextOutputFormat类 - FileOutputFormat实现子类)将key-value数据写出到最终的结果文件中part-r-xxxxx

Hadoop的第二个核心组件:MapReduce框架第二节,Hadoop,hadoop,mapreduce,php

七、MapReduce中的序列化机制问题

MR程序的Map阶段和Reduce阶段都是要求输入的数据和输出的数据必须得是key-value键值对类型的数据,而且key-value必须得是序列化类型的数据。

序列化:将Java中的某种数据类型转成二进制数据

反序列化:将二进制数据转换成某种数据类型

MR程序采用序列化机制的原因:MR程序之所以要求输入和输出的数据是K-V类型的,是因为MR程序是一个分布式计算程序,MR程序可以在多个节点上同时运行的,而且多个计算程序计算出来的结果可能跨节点,跨网络进行数据传输的。如果数据要跨节点跨网络传输,要求数据必须是二进制数据。(MapReduce程序运行中,Mapper阶段和Reducer阶段的输入和输出都是以key-value的格式进行的。同时Mapper和Reducer阶段的任务中需要的数据可能会跨网络或者跨节点传输,因此我们就要求,MR程序运行过程中所有的输入和输出的数据必须都得是可以被序列化的。)

Hadoop在进行Key-Value的序列化的时候,没有采用Java的序列化机制(Serializable、Externalizable),因为Java的序列化机制非常的笨重的,因此Hadoop基于Java的序列化机制方式提供了一种全新的专门适用于MR程序的轻量级的序列化机制。

Hadoop中提供了两个接口:Writable、WritableComparable,Hadoop提供的两个序列化机制。

Writable

  • 只有序列化和反序列化的效果,如果我们自定义的一个数据类型(Java类)要想当MR程序的value使用的话,Java类必须实现Writable接口,重写两个方法(write - 序列化写、readFields - 反序列化读),通过这两个方法规定序列化和反序列化的内容。

  • Writable的使用方式类似于Java中Externalizable序列化机制

WritableComparable

  • 接口除了具备序列化和反序列化的能力以外,还具备一个比较大小关系的方法

  • 如果自定义的数据类型(Java类),想当MR程序中的key值来使用,必须实现此接口,让自定义数据类型既可以进行序列化反序列化还可以进行大小的比较判断。

  • 如果自定义的数据类型只想当作MR程序中的value来使用,只需要实现Writable接口即可,不需要比较大小。

Hadoop常见的序列化类型(Hadoop把Java中包装类和String类型已经给我们封装好了对应的Hadoop序列化类型) —— 实现了WritableComparable接口

Java类型 Hadoop Writable类型
boolean BooleanWritable
byte ByteWritable
int IntWritable
float FloatWritable
long LongWritable
double DoubleWritable
string Text
map MapWritable
array ArrayWritable

【注意】
1、如果以后MR程序运行没有报错,但是输出目录没有任何的内容,一般可能是因为输入和输出的key-value的自定义类型没有实现序列化。
2、如果自定义的JavaBean充当Reducer阶段输出key-value时,最好把toString方法给重写了,否则Reducer最后输出的结果是JavaBean的地址值。

八、流量统计案例实现(序列化机制的实现)

import org.apache.hadoop.io.Writable;
import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
import java.util.Objects;

/**
 * JavaBean:是Java中一种很干净的类,类当中只具备私有化的属性、构造器、getter   setter方法 hashCode  equals方法 toString方法
 * 实体类:实体类又是一种特殊的JavaBean,当JavaBean是和数据库中数据表对应的类的时候,JavaBean称之为实体类
 *
 * JavaBean可以自己手动的生成,也可以使用Lombok技术基于注解快速创建Java类
 *      Lombok使用慎重,Lombok对代码的侵占性是非常大的
 *
 * 如果自定义的JavaBean要当MR程序的输入和输出的KV值,最好让JavaBean存在一个无参构造器(MR程序底层反射构建这个类的对象)
 * 如果自定义的JavaBean要去充当Reducer阶段KEY和Value,那也就意味着JavaBean的结果要写到最终的结果文件中,JavaBean的数据往结果文件写的格式还是按照JavaBean的toString方法去写的。
 */
public class FlowBean implements Writable {
    private Long upFlow;//上行流量
    private Long downFlow;//下行流量
    private Long sumFlow;//总流量

    public FlowBean() {
    }

    public FlowBean(Long upFlow, Long downFlow, Long sumFlow) {
        this.upFlow = upFlow;
        this.downFlow = downFlow;
        this.sumFlow = 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;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        FlowBean flowBean = (FlowBean) o;
        return Objects.equals(upFlow, flowBean.upFlow) && Objects.equals(downFlow, flowBean.downFlow) && Objects.equals(sumFlow, flowBean.sumFlow);
    }

    @Override
    public int hashCode() {
        return Objects.hash(upFlow, downFlow, sumFlow);
    }

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

    /**
     * 序列化写的方法
     * @param out <code>DataOuput</code> to serialize this object into.
     * @throws IOException
     */
    @Override
    public void write(DataOutput out) throws IOException {
        out.writeLong(upFlow);
        out.writeLong(downFlow);
        out.writeLong(sumFlow);
    }

    /**
     * 反序列化读取数据的方法
     * @param in <code>DataInput</code> to deseriablize this object from.
     * @throws IOException
     */
    @Override
    public void readFields(DataInput in) throws IOException {
        upFlow = in.readLong();
        downFlow = in.readLong();
        sumFlow = in.readLong();

    }
}
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
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;
import java.net.URI;
import java.net.URISyntaxException;

/**
 * 现在有一个文件 phone_data.txt,文件中记录着手机号消耗的流量信息
 * 文件中每一行数据代表一条手机的流量消耗,每一条数据是以\t制表符分割的多个字段组成的
 * 使用MR程序统计每一个手机号消耗的总的上行流量、总的下行流量、总流量
 */
public class FlowDriver {
    public static void main(String[] args) throws IOException, InterruptedException, ClassNotFoundException, URISyntaxException {
        Configuration configuration = new Configuration();
        configuration.set("fs.defaultFS","hdfs://192.168.31.104:9000");

        Job job = Job.getInstance(configuration);

        //设置MR程序默认使用的InputFormat类 —— 负责进行切片  负责读取数据源的数据为key value类型的
//        job.setInputFormatClass(FileInputFormat.class);//默认确实是FileInputFormat   但是是个 抽象类  MR程序默认使用的是这个抽象类的子类
        FileInputFormat.setInputPaths(job,"/phone_data.txt");

        //封装Mapper阶段
        job.setMapperClass(FlowMapper.class);
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(FlowBean.class);

        //封装Reducer阶段
        job.setReducerClass(FlowReducer.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(FlowBean.class);

        //封装输出结果路径
//        job.setOutputFormatClass(FileOutputFormat.class);
        //MR程序要求输出路径不能提前存在 如果提前存在就会报错
        Path path = new Path("/output");
        //是用来解决输出目录如果存在MR程序报错问题的
        FileSystem fileSystem = FileSystem.get(new URI("hdfs://192.168.31.104:9000"), configuration, "root");
        if (fileSystem.exists(path)){
            fileSystem.delete(path,true);
        }
        FileOutputFormat.setOutputPath(job,path);

        //最后提交程序运行即可
        boolean b = job.waitForCompletion(true);
        System.out.println(b?0:1);
    }
}
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;

import java.io.IOException;

/**
 * 读取切片数据,一行数据读取一次  而且读取的key(偏移量) value LongWritable Text
 * 输出的key(手机号) value 是 Text FlowBean
 */
public class FlowMapper extends Mapper<LongWritable, Text, Text, FlowBean> {
    @Override
    protected void map(LongWritable key, Text value, Mapper<LongWritable, Text, Text, FlowBean>.Context context) throws IOException, InterruptedException {
        String line = value.toString();
        String[] array = line.split("\t");
        String phoneNumber = array[1];
        Long downFlow = Long.parseLong(array[array.length - 2]);
        Long upFlow = Long.parseLong(array[array.length - 3]);
        FlowBean flowBean = new FlowBean(upFlow,downFlow,upFlow + downFlow);
        //需要将这一条数据以手机号为key,以flowBean为value输出给reduce
        context.write(new Text(phoneNumber),flowBean);
    }
}
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;

import java.io.IOException;

/**
 *
 */
public class FlowReducer extends Reducer<Text, FlowBean, Text, FlowBean> {
    @Override
    protected void reduce(Text key, Iterable<FlowBean> values, Reducer<Text, FlowBean, Text, FlowBean>.Context context) throws IOException, InterruptedException {
        Long upFlowSum = 0L;
        Long downFlowSum = 0L;
        Long sumFlowSum = 0L;
        for (FlowBean value : values) {
            upFlowSum += value.getUpFlow();
            downFlowSum += value.getDownFlow();
            sumFlowSum =+ value.getSumFlow();
            //需要以手机号为key,以flowBean为value将结果输出,flowBean需要将我们计算出来总流量信息封装起来
            FlowBean flowBean = new FlowBean(upFlowSum,downFlowSum,sumFlowSum);
            context.write(key,flowBean);
        }
    }
}

Hadoop的第二个核心组件:MapReduce框架第二节,Hadoop,hadoop,mapreduce,php

Hadoop的第二个核心组件:MapReduce框架第二节,Hadoop,hadoop,mapreduce,php

Hadoop的第二个核心组件:MapReduce框架第二节,Hadoop,hadoop,mapreduce,php

Hadoop的第二个核心组件:MapReduce框架第二节,Hadoop,hadoop,mapreduce,php

package com.kang.flow02;

import com.kang.flow.FlowDriver;
import jdk.nashorn.internal.runtime.regexp.joni.Config;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Partitioner;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.input.TextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;

/**
 * 基于以前统计的手机消耗流量信息的结果文件,要求对结果文件进行二次分析,得到以下结果:
 * 1、要求对数据中的手机号按照归属地不同进行分区:
 *       134开头的手机号  0号分区
 *       135开头的手机号  1号分区
 *       136开头的手机号  2号分区
 *       137开头的手机号  3号分区
 *       其余的手机号     4号分区
 * 2、同时还要求每一个分区按照消耗的总流量从高到底进行排序
 */
public class FlowDriver02 {
    public static void main(String[] args) throws IOException, InterruptedException, ClassNotFoundException, URISyntaxException {
        Configuration configuration = new Configuration();

        Job job = Job.getInstance(configuration);

        job.setJarByClass(FlowDriver02.class);

        job.setInputFormatClass(TextInputFormat.class);
        FileInputFormat.setInputPaths(job,new Path("/output/part-r-00000"));

        job.setMapperClass(FlowMapper02.class);
        job.setMapOutputKeyClass(FlowBean02.class);
        job.setMapOutputValueClass(NullWritable.class);

        job.setPartitionerClass(FlowPartitioner.class);

        job.setReducerClass(FlowReducer02.class);
        job.setOutputKeyClass(FlowBean02.class);
        job.setOutputValueClass(NullWritable.class);
        job.setNumReduceTasks(5);

        Path path =new Path("/output1");
        FileSystem fs = FileSystem.get(new URI("hdfs://192.168.31.104:9000"), configuration, "root");
        if (fs.exists(path)){
            fs.delete(path);
        }
        FileOutputFormat.setOutputPath(job,path);

        boolean flag = job.waitForCompletion(true);
        System.exit(flag?0:1);
    }
}

class FlowMapper02 extends Mapper<LongWritable, Text,FlowBean02,NullWritable> {
    @Override
    protected void map(LongWritable key, Text value, Mapper<LongWritable, Text, FlowBean02, NullWritable>.Context context) throws IOException, InterruptedException {
        String line = value.toString();
        String[] message = line.split("\t");
        String phoneNumber = message[0];
        Long upFlow = Long.parseLong(message[1]);
        Long downFlow = Long.parseLong(message[2]);
        Long sumFlow = Long.parseLong(message[3]);
        FlowBean02 flowBean02 = new FlowBean02(phoneNumber,upFlow,downFlow,sumFlow);
        context.write(flowBean02,NullWritable.get());
    }
}

oneNumber.startsWith("137")) {
            return 3;
        }else  {
            return 4;
        }
//        String message = flowBean02.toString();
//        String[] array = message.split("\t");
//        String phoneNumber = array[0];
//        char w1 = phoneNumber.charAt(0);
//        char w2 = phoneNumber.charAt(1);
//        char w3 = phoneNumber.charAt(2);
//        if (w1 == '1' && w2 == '3') {
//            if (w3 == '4') return 0;
//            if (w3 == '5') return 1;
//            if (w3 == '6') return 2;
//            if (w3 == '7') return 3;
//        }
//        return 4;
    }
}

class FlowReducer02 extends Reducer<FlowBean02,NullWritable,FlowBean02, NullWritable>{
    @Override
    protected void reduce(FlowBean02 key, Iterable<NullWritable> values, Reducer<FlowBean02, NullWritable, FlowBean02, NullWritable>.Context context) throws IOException, InterruptedException {
        context.write(key,NullWritable.get());
    }
}

package com.kang.flow02;

import org.apache.hadoop.io.WritableComparable;

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

public class FlowBean02 implements WritableComparable<FlowBean02> {
    private String phoneNumber;
    private Long upFlow;
    private Long downFlow;
    private Long sumFlow;

    public FlowBean02() {
    }

    public FlowBean02(String phoneNumber, Long upFlow, Long downFlow, Long sumFlow) {
        this.phoneNumber = phoneNumber;
        this.upFlow = upFlow;
        this.downFlow = downFlow;
        this.sumFlow = sumFlow;
    }

    public String getPhoneNumber() {
        return phoneNumber;
    }

    public void setPhoneNumber(String phoneNumber) {
        this.phoneNumber = phoneNumber;
    }

    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;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        FlowBean02 that = (FlowBean02) o;
        return Objects.equals(phoneNumber, that.phoneNumber) && Objects.equals(upFlow, that.upFlow) && Objects.equals(downFlow, that.downFlow) && Objects.equals(sumFlow, that.sumFlow);
    }

    @Override
    public int hashCode() {
        return Objects.hash(phoneNumber, upFlow, downFlow, sumFlow);
    }

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

    @Override
    public int compareTo(FlowBean02 o) {
        if (this.sumFlow > o.sumFlow){
            return 1;
        } else if (this.sumFlow < o.sumFlow) {
            return -1;
        }else {
            return 0;
        }
    }

    @Override
    public void write(DataOutput out) throws IOException {
        out.writeUTF(phoneNumber);
        out.writeLong(upFlow);
        out.writeLong(downFlow);
        out.writeLong(sumFlow);

    }

    @Override
    public void readFields(DataInput in) throws IOException {
        phoneNumber = in.readUTF();
        upFlow = in.readLong();
        downFlow = in.readLong();
        sumFlow = in.readLong();

    }
}

Hadoop的第二个核心组件:MapReduce框架第二节,Hadoop,hadoop,mapreduce,php

Hadoop的第二个核心组件:MapReduce框架第二节,Hadoop,hadoop,mapreduce,php文章来源地址https://www.toymoban.com/news/detail-697554.html

到了这里,关于Hadoop的第二个核心组件:MapReduce框架第二节的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 面向对象的第二个基本特征:继承011026

    生活中:         继承 --- 延续                 --- 扩展 代码中:         继承 --- 重复使用已有的类的代码(复用)                 --- 扩展已有类的代码(扩展) ① 代码的复用和扩展 ② 满足is - a 的关系 事物的分类来说,子类别的关系 Student is a Person. Teacher is a Pe

    2024年02月05日
    浏览(50)
  • 分布式计算框架Hadoop核心组件

    Hadoop作为成熟的分布式计算框架在大数据生态领域已经使用多年,本文简要介绍Hadoop的核心组件MapReduce、YARN和HDFS,以加深了解。 1、Hadoop基本介绍 Hadoop是分布式计算框架,主要解决海量数据的存储和计算问题。Hadoop主要组件包括分布式文件系统HDFS、分布式离线并行计算框架

    2024年02月06日
    浏览(43)
  • 【JavaEE进阶】——第二节.Spring核心和设计思想

    文章目录 前言 一、Spring是什么? 二、什么是容器? 三、什么是IoC? 3.1 初始loC 3.2 举例解释loC 3.3 Spring IoC思想的体现 四、什么是DI? 4.1DI的概念 4.2 Ioc和DI的区别 总结 今天我们将进入到有关spring的认识当中,要使用它的前提就是要认识并熟悉它,上一节我们介绍了有关mave

    2023年04月18日
    浏览(42)
  • 大数据框架之Hadoop:MapReduce(三)MapReduce框架原理——MapTask工作机制

    MapTask工作机制如下图所示。 (1)Read阶段:MapTask通过用户编写的RecordReader,从输入InputSplit中解析出一个个key/value。 (2)Map阶段:该节点主要是将解析出的key/value交给用户编写map()函数处理,并产生一系列新的key/value。 (3)Collect收集阶段:在用户编写map()函数中,当数据处

    2023年04月08日
    浏览(66)
  • Hadoop三大框架之MapReduce工作流程

    MapReduce的思想核心是“分而治之”,适用于大量复杂的任务处理场景(大规模数据处理场景)。 Map负责“分”,把复杂的任务分解为若干个“简单的任务”来并行处理。可以进行拆分的前提是这些小任务可以并行计算,彼此间几乎没有依赖关系。 Reduce负责“合”,即对map阶

    2024年02月02日
    浏览(45)
  • Hadoop的第三大组成:YARN框架

    YARN是一个分布式资源调度系统,专门用来给分布式计算程序提供计算资源的,而且YARN只负责进行资源的提供,不管计算程序的逻辑,因此YARN这个软件非常的成功,因为YARN不关注程序计算逻辑,因此只要是分布式计算程序,只要满足YARN的运行要求,那么就可以在YARN上进行运

    2024年02月09日
    浏览(43)
  • Hadoop入门学习笔记——四、MapReduce的框架配置和YARN的部署

    视频课程地址:https://www.bilibili.com/video/BV1WY4y197g7 课程资料链接:https://pan.baidu.com/s/15KpnWeKpvExpKmOC8xjmtQ?pwd=5ay8 Hadoop入门学习笔记(汇总) 本次YARN的部署结构如下图所示: 当前,共有三台服务器(虚拟机)构成集群,集群规划如下所示: 主机 部署的服务 node1 ResourceManager、N

    2024年02月04日
    浏览(46)
  • Hadoop核心组件及组件介绍

    1、Hadoop通用组件 -  Hadoop Common 包含了其他hadoop模块要用到的库文件和工具 2、分布式文件系统 - Hadoop Distributed File System (HDFS) 运行于通用硬件上的分布式文件系统,高吞吐,高可靠 3、资源管理组件 - Hadoop YARN 于2012年引入的组件,用于管理集群中的计算资源并在这些资源上

    2024年02月05日
    浏览(50)
  • 基于Hadoop的MapReduce网站日志大数据分析(含预处理MapReduce程序、hdfs、flume、sqoop、hive、mysql、hbase组件、echarts)

    需要本项目的可以私信博主!!! 本项目包含:PPT,可视化代码,项目源码,配套Hadoop环境(解压可视化),shell脚本,MapReduce代码,文档以及相关说明教程,大数据集! 本文介绍了一种基于Hadoop的网站日志大数据分析方法。本项目首先将网站日志上传到HDFS分布式文件系统

    2024年02月16日
    浏览(65)
  • Hadoop 生态圈及核心组件简介Hadoop|MapRedece|Yarn

    大家好,我是北山啦,好久不见,Nice to meet you,本文将记录学习Hadoop生态圈相关知识。 大数据是指无法在一定时间范围内通过常用软件工具进行捕捉、管理和处理的数据集合,是需要新处理模式才具有更强的决策力、洞察发现力和流程优化能力的海量、高增长率和多样化的

    2023年04月19日
    浏览(34)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包