hadoop----自己写的mapreduce

已于 2023-11-27 16:09:40 修改
阅读量70 收藏
点赞数
文章标签： hadoop mapreduce 大数据
于 2023-11-26 15:25:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_67466364/article/details/134535733
版权

自己写的mapreduce

mapreduce是hadoop核心

  • mapreduce进行存在于hdfs上的dd的运算（也就是这个文件必须存储在hdfs上，才可以进行mapreduce的运算

  • mapreduce是离线分布式计算框架

  • map：数据进行运算，map的阶段进行数据的不同机器上的运算

  • reduce：不同机器上map的数据进行合并

  • 离线：mapreduce是基于磁盘上的文件的运算（不是实时进行数据统计/运算的）—-》是要找一个空闲时间（用户访问量少的时候），进行统一的统计/运算—-》这是一种推荐方式

  • 还有一种推荐方式：spark—-》spark是基于内存进行的运算（是实时进行推荐的，但是对内存的要求比较大）

  • mapreduce执行流程？？？

  • mapreduce书写过程---->写一个简单的逻辑来体会---->我们来写一个自定义的wordcount(一行就看做为一个单词,然后来统计整个文件的单词数)

1.导包

  • 中央仓库添加mapreduce依赖
  • 选择和hadoop相同版本的core（3.2.1）
<!-- https://mvnrepository.com/artifact/org.apache.hadoop/hadoop-mapreduce-client-core -->
<dependency>
    <groupId>org.apache.hadoop</groupId>
    <artifactId>hadoop-mapreduce-client-core</artifactId>
    <version>3.2.1</version>
</dependency>

2.map逻辑书写

  • 先继承Mapper
    为什么要继承Mapper?
    因为我们要实现map—>就是怎么能够让这方法成为可以处理map的方法？—>继承Mapper类（extends Mapper)---->注意：还需要泛型指定
    为什么要进行泛型的指定?—>因为Mapper类的结构如下:

      // <>中是四个泛型
  public class Mapper<KEYIN, VALUEIN, KEYOUT, VALUEOUT> {...}

3.reduce逻辑书写

  • 先继承Reducer

  • 同样要写四个泛型

       public class Reducer<KEYIN, VALUEIN, KEYOUT, VALUEOUT>

4.使mapreduce能够运行的main函数书写

  • 就是给mapreduce提供一个job

5.整个代码示例

package neuedu.test;

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

import java.io.IOException;

public class Demo1 {

//    先继承Mapper
    /**
     * 四个范型
     * （1）进行每一行的位置的记录：map读取指定文件中的数据——》每一行开始的位置，数字进行的记录——》我们现在写的是大数据，所以文件会比较大——》可以定义long类型（在大数据里面自己封装的叫做longWritable类型）
     * （2）进行文件中数据的读取：map进行文件中数据的读取（按行读取），一行一行的进行数据获取—-》一行中数据为String类型（在大数据中国自己封装的类型叫做Text类型）
     * （3）进行每一行单词的获取：map进行每一行单词的获取—-》要进行映射（单词，数量1）——》这里还要继续写出给reduce—-》需要key的类型（就是单词类型）—-》也就是字符串类型（大数据中为Text）
     * （4）同（3）：map写出到reduce中value的类型（数量1）—-》数字类型（先定义为int）—-》（大数据中为IntWritable）
     * 注意：数量=1–》是因为我们现在写的简单逻辑是一行就看成是一个单词，所以读取一行，就赋值为1
     */
    public static class Map1 extends Mapper<LongWritable, Text,Text, IntWritable>{
        @Override
        protected void map(LongWritable key, Text value, Mapper<LongWritable, Text, Text, IntWritable>.Context context) throws IOException, InterruptedException {
            /**
             * value是当前一行的值,需要进行map的过程
             * 给当前的值进行数据映射,并且写出到reduce中
             * key==>每一行开始的位置,value当前一行的值
             * context 上下文对象,通过对象进行数据的写出reduce
             */
            context.write(value,new IntWritable(1));
        }
    }

//    先继承Reducer
    /**
     * 四个范型
     * （1）map写入reduce中的数据，key类型—》Text
     * （2）map写入reduce中的数据，value类型—》IntWritable
     * （3）单词的类型：reduce进行数据合并，把数据写出到磁盘上，格式是（单词，数量）—》先写出单词的类型（key类型）—》字符串—〉Text
     * （4）数量的类型：value类型—》LongWritable
     */
    public static class Reduce1 extends Reducer<Text,IntWritable,Text,LongWritable>{
        /**
         * key===>从map中接受的key的类型
         * values===>是一个集合,进行当前可以相同时,数据值的存储
         * reduce中的数据写出到hdfs上===>通过context进行的写出
         */
        @Override
        protected void reduce(Text key, Iterable<IntWritable> values, Reducer<Text, IntWritable, Text, LongWritable>.Context context) throws IOException, InterruptedException {
            int count=0;
            for (IntWritable i:values
                 ) {
                count+=i.get();
            }
            context.write(key,new LongWritable(count));
        }
    }

    public static void main(String[] args){
//        进行java程序的运行
//        hdfs的配置
        Configuration conf=new Configuration();
        conf.set("fs.defaultFS","hdfs://192.168.246.177:9000");
        try {
            Job job = Job.getInstance(conf);
//            job相关信息
//            设置job的名字
            job.setJobName("javawordcount");
//            job运行类
            job.setJarByClass(Demo1.class);

//            job执行map相关信息的配置
            job.setMapperClass(Demo1.Map1.class);
//                向reduce输出key的类型
            job.setMapOutputKeyClass(Text.class);
//                向rudece输出value的类型
            job.setMapOutputValueClass(IntWritable.class);

//            job执行reduce的配置
            job.setReducerClass(Demo1.Reduce1.class);
            job.setOutputKeyClass(Text.class);
            job.setOutputValueClass(LongWritable.class);

//            注意导包import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
            FileInputFormat.setInputPaths(job,new Path("/datas.txt"));
            FileOutputFormat.setOutputPath(job,new Path("/java1"));

//            提交执行
            job.waitForCompletion(true);

        } catch (IOException e) {
            throw new RuntimeException(e);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        }
    }
}

6.报错解决

  • 至此代码会报一个错误,如下:

      Caused by: java.io.IOException: Cannot initialize Cluster. Please check your configuration for mapreduce.framework.name and the correspond server addresses.

  • 我们需要到中央仓库中找一个依赖添加到pom.xml中

<!-- https://mvnrepository.com/artifact/org.apache.hadoop/hadoop-mapreduce-client-jobclient -->
<dependency>
    <groupId>org.apache.hadoop</groupId>
    <artifactId>hadoop-mapreduce-client-jobclient</artifactId>
    <version>3.2.1</version>
    //删掉scope(作用域)这一行
//    <scope>test</scope>
</dependency>

7.报错的日志显示

log4j.properties
此文件夹加在 \src\main\resources 下

------------------------------------------

8.代码变形(逻辑优化)

(1) 优化1---->按照空格统计单词个数

  • 现在我们所写的代码只能按行统计单词个数
  • 但是现在 我们想按照空格来统计单词个数
  • 优化部分 : Map(利用split函数,按照空格进行单词的切割–>然后再进行单词统计)
    public static class Map1 extends Mapper<LongWritable, Text,Text, IntWritable> {
        @Override
        protected void map(LongWritable key, Text value, Mapper<LongWritable, Text, Text, IntWritable>.Context context) throws IOException, InterruptedException {
            /**
             * value是当前一行的值,需要进行map的过程
             * 给当前的值进行数据映射,并且写出到reduce中
             * key==>每一行开始的位置,value当前一行的值
             * context 上下文对象,通过对象进行数据的写出reduce
             */
//            进行每行数据的读取,每读一行数据-->进行数据的切割(通过空格进行数据的切割-->利用split函数)
            String[] s=value.toString().split(" ");
            for (String a:s
                 ) {
                context.write(new Text(a),new IntWritable(1));
            }

        }
    }
  • 全部代码
package neuedu.test;

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

import java.io.IOException;

public class Demo2 {
    //    先继承Mapper
    /**
     * 四个范型
     * （1）进行每一行的位置的记录：map读取指定文件中的数据——》每一行开始的位置，数字进行的记录——》我们现在写的是大数据，所以文件会比较大——》可以定义long类型（在大数据里面自己封装的叫做longWritable类型）
     * （2）进行文件中数据的读取：map进行文件中数据的读取（按行读取），一行一行的进行数据获取—-》一行中数据为String类型（在大数据中国自己封装的类型叫做Text类型）
     * （3）进行每一行单词的获取：map进行每一行单词的获取—-》要进行映射（单词，数量1）——》这里还要继续写出给reduce—-》需要key的类型（就是单词类型）—-》也就是字符串类型（大数据中为Text）
     * （4）同（3）：map写出到reduce中value的类型（数量1）—-》数字类型（先定义为int）—-》（大数据中为IntWritable）
     * 注意：数量=1–》是因为我们现在写的简单逻辑是一行就看成是一个单词，所以读取一行，就赋值为1
     */
    public static class Map1 extends Mapper<LongWritable, Text,Text, IntWritable> {
        @Override
        protected void map(LongWritable key, Text value, Mapper<LongWritable, Text, Text, IntWritable>.Context context) throws IOException, InterruptedException {
            /**
             * value是当前一行的值,需要进行map的过程
             * 给当前的值进行数据映射,并且写出到reduce中
             * key==>每一行开始的位置,value当前一行的值
             * context 上下文对象,通过对象进行数据的写出reduce
             */
//            进行每行数据的读取,每读一行数据-->进行数据的切割(通过空格进行数据的切割-->利用split函数)
            String[] s=value.toString().split(" ");
            for (String a:s
                 ) {
                context.write(new Text(a),new IntWritable(1));
            }

        }
    }

//    先继承Reducer
    /**
     * 四个范型
     * （1）map写入reduce中的数据，key类型—》Text
     * （2）map写入reduce中的数据，value类型—》IntWritable
     * （3）单词的类型：reduce进行数据合并，把数据写出到磁盘上，格式是（单词，数量）—》先写出单词的类型（key类型）—》字符串—〉Text
     * （4）数量的类型：value类型—》LongWritable
     */
    public static class Reduce1 extends Reducer<Text,IntWritable,Text,LongWritable> {
        /**
         * key===>从map中接受的key的类型
         * values===>是一个集合,进行当前可以相同时,数据值的存储
         * reduce中的数据写出到hdfs上===>通过context进行的写出
         */
        @Override
        protected void reduce(Text key, Iterable<IntWritable> values, Reducer<Text, IntWritable, Text, LongWritable>.Context context) throws IOException, InterruptedException {
            int count=0;
            for (IntWritable i:values
            ) {
                count+=i.get();
            }
            context.write(key,new LongWritable(count));
        }
    }

    public static void main(String[] args){
//        进行java程序的运行
//        hdfs的配置
        Configuration conf=new Configuration();
        conf.set("fs.defaultFS","hdfs://192.168.246.177:9000");
        try {
            Job job = Job.getInstance(conf);
//            job相关信息
//            设置job的名字
            job.setJobName("javawordcount");
//            job运行类
            job.setJarByClass(Demo2.class);

//            job执行map相关信息的配置
            job.setMapperClass(Demo2.Map1.class);
//                向reduce输出key的类型
            job.setMapOutputKeyClass(Text.class);
//                向rudece输出value的类型
            job.setMapOutputValueClass(IntWritable.class);

//            job执行reduce的配置
            job.setReducerClass(Demo2.Reduce1.class);
            job.setOutputKeyClass(Text.class);
            job.setOutputValueClass(LongWritable.class);

//            注意导包import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
            FileInputFormat.setInputPaths(job,new Path("/dat.txt"));
            FileOutputFormat.setOutputPath(job,new Path("/java2"));

//            提交执行
            job.waitForCompletion(true);

        } catch (IOException e) {
            throw new RuntimeException(e);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        }
    }
}
  • 执行结果
    在这里插入图片描述

(2) 再次优化(正则表达式)---->按照空白统计单词个数

  • 修改部分----Map逻辑部分
//运用了正则表达式 \\s+
String[] s=value.toString().split("\\s+");

(3) 只统计第一个单词的个数

在这里插入图片描述

  • 方法一 : 利用数组,只取第一个单词

  • 修改部分(Map)

      String[] s=value.toString().split("\\s+");
  //取每一行的第一个单词,进行这个单词的数量统计
  context.write(new Text(s[0]),new IntWritable(1));

  • 完整代码

package neuedu.test;

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

import java.io.IOException;

public class Demo3 {
    //    先继承Mapper
    /**
     * 四个范型
     * （1）进行每一行的位置的记录：map读取指定文件中的数据——》每一行开始的位置，数字进行的记录——》我们现在写的是大数据，所以文件会比较大——》可以定义long类型（在大数据里面自己封装的叫做longWritable类型）
     * （2）进行文件中数据的读取：map进行文件中数据的读取（按行读取），一行一行的进行数据获取—-》一行中数据为String类型（在大数据中国自己封装的类型叫做Text类型）
     * （3）进行每一行单词的获取：map进行每一行单词的获取—-》要进行映射（单词，数量1）——》这里还要继续写出给reduce—-》需要key的类型（就是单词类型）—-》也就是字符串类型（大数据中为Text）
     * （4）同（3）：map写出到reduce中value的类型（数量1）—-》数字类型（先定义为int）—-》（大数据中为IntWritable）
     * 注意：数量=1–》是因为我们现在写的简单逻辑是一行就看成是一个单词，所以读取一行，就赋值为1
     */
    public static class Map1 extends Mapper<LongWritable, Text,Text, IntWritable> {
        @Override
        protected void map(LongWritable key, Text value, Mapper<LongWritable, Text, Text, IntWritable>.Context context) throws IOException, InterruptedException {
            /**
             * value是当前一行的值,需要进行map的过程
             * 给当前的值进行数据映射,并且写出到reduce中
             * key==>每一行开始的位置,value当前一行的值
             * context 上下文对象,通过对象进行数据的写出reduce
             */
//            进行每行数据的读取,每读一行数据-->进行数据的切割(通过空格进行数据的切割-->利用split函数)
            String[] s=value.toString().split("\\s+");
//            取每一行的第一个单词,进行这个单词的数量统计
            context.write(new Text(s[0]),new IntWritable(1));
        }
    }

//    先继承Reducer
    /**
     * 四个范型
     * （1）map写入reduce中的数据，key类型—》Text
     * （2）map写入reduce中的数据，value类型—》IntWritable
     * （3）单词的类型：reduce进行数据合并，把数据写出到磁盘上，格式是（单词，数量）—》先写出单词的类型（key类型）—》字符串—〉Text
     * （4）数量的类型：value类型—》LongWritable
     */
    public static class Reduce1 extends Reducer<Text,IntWritable,Text,LongWritable> {
        /**
         * key===>从map中接受的key的类型
         * values===>是一个集合,进行当前可以相同时,数据值的存储
         * reduce中的数据写出到hdfs上===>通过context进行的写出
         */
        @Override
        protected void reduce(Text key, Iterable<IntWritable> values, Reducer<Text, IntWritable, Text, LongWritable>.Context context) throws IOException, InterruptedException {
            int count=0;
            for (IntWritable i:values
            ) {
                count+=i.get();
            }
            context.write(key,new LongWritable(count));
        }
    }

    public static void main(String[] args){
//        进行java程序的运行
//        hdfs的配置
        Configuration conf=new Configuration();
        conf.set("fs.defaultFS","hdfs://192.168.246.177:9000");
        try {
            Job job = Job.getInstance(conf);
//            job相关信息
//            设置job的名字
            job.setJobName("javawordcount");
//            job运行类
            job.setJarByClass(Demo3.class);

//            job执行map相关信息的配置
            job.setMapperClass(Demo3.Map1.class);
//                向reduce输出key的类型
            job.setMapOutputKeyClass(Text.class);
//                向rudece输出value的类型
            job.setMapOutputValueClass(IntWritable.class);

//            job执行reduce的配置
            job.setReducerClass(Demo3.Reduce1.class);
            job.setOutputKeyClass(Text.class);
            job.setOutputValueClass(LongWritable.class);

//            注意导包import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
            FileInputFormat.setInputPaths(job,new Path("/dat2.txt"));
            FileOutputFormat.setOutputPath(job,new Path("/java4"));

//            提交执行
            job.waitForCompletion(true);

        } catch (IOException e) {
            throw new RuntimeException(e);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        }
    }
}
  • 方法2 : 就是把第一个单词单独提出来–>也就是所谓的key值
  • 修改部分:

// main

//用空格进行key 和 value的区分(注意KeyValueLineRecordReader的导包--->lib下的)
        conf.set(KeyValueLineRecordReader.KEY_VALUE_SEPARATOR," ");

//            以文本文件的方式进行读取,map的第一个泛型是位置,第二个泛型是当前一行的数据
//            job.setInputFormatClass(TextInputFormat.class);//这个是默认的

//            以keyvalue的方式进行数据的读取-->解读 : 以文件每一行开始的单词作为key,后面的单词作为value
            job.setInputFormatClass(KeyValueTextInputFormat.class);

//Map

    public static class Map1 extends Mapper<Text, Text,Text, IntWritable> {
        @Override
        protected void map(Text key, Text value,Context context) throws IOException, InterruptedException {
            /**
             * value是当前一行的值,需要进行map的过程
             * 给当前的值进行数据映射,并且写出到reduce中
             * key==>每一行开始的位置,value当前一行的值
             * context 上下文对象,通过对象进行数据的写出reduce
             */
            System.out.println(key);//key是第一个单词-->所以key的类型要改为Text
            System.out.println(value);//value是除了第一个单词的后面所有单词
            context.write(key,new IntWritable(1));//只输出第一个单词,也就是key
            进行每行数据的读取,每读一行数据-->进行数据的切割(通过空格进行数据的切割-->利用split函数)
//            String[] s=value.toString().split("\\s+");
            取每一行的第一个单词,进行这个单词的数量统计
//            context.write(new Text(s[0]),new IntWritable(1));
        }
    }
  • 完整代码
package neuedu.test;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.input.KeyValueLineRecordReader;
import org.apache.hadoop.mapreduce.lib.input.KeyValueTextInputFormat;
import org.apache.hadoop.mapreduce.lib.input.TextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

import java.io.IOException;

public class Demo4 {
    //    先继承Mapper
    /**
     * 四个范型
     * （1）进行每一行的位置的记录：map读取指定文件中的数据——》每一行开始的位置，数字进行的记录——》我们现在写的是大数据，所以文件会比较大——》可以定义long类型（在大数据里面自己封装的叫做longWritable类型）
     * （2）进行文件中数据的读取：map进行文件中数据的读取（按行读取），一行一行的进行数据获取—-》一行中数据为String类型（在大数据中国自己封装的类型叫做Text类型）
     * （3）进行每一行单词的获取：map进行每一行单词的获取—-》要进行映射（单词，数量1）——》这里还要继续写出给reduce—-》需要key的类型（就是单词类型）—-》也就是字符串类型（大数据中为Text）
     * （4）同（3）：map写出到reduce中value的类型（数量1）—-》数字类型（先定义为int）—-》（大数据中为IntWritable）
     * 注意：数量=1–》是因为我们现在写的简单逻辑是一行就看成是一个单词，所以读取一行，就赋值为1
     */
    public static class Map1 extends Mapper<Text, Text,Text, IntWritable> {
        @Override
        protected void map(Text key, Text value,Context context) throws IOException, InterruptedException {
            /**
             * value是当前一行的值,需要进行map的过程
             * 给当前的值进行数据映射,并且写出到reduce中
             * key==>每一行开始的位置,value当前一行的值
             * context 上下文对象,通过对象进行数据的写出reduce
             */
            System.out.println(key);//key是第一个单词-->所以key的类型要改为Text
            System.out.println(value);//value是除了第一个单词的后面所有单词
            context.write(key,new IntWritable(1));//只输出第一个单词,也就是key
            进行每行数据的读取,每读一行数据-->进行数据的切割(通过空格进行数据的切割-->利用split函数)
//            String[] s=value.toString().split("\\s+");
            取每一行的第一个单词,进行这个单词的数量统计
//            context.write(new Text(s[0]),new IntWritable(1));
        }
    }

//    先继承Reducer
    /**
     * 四个范型
     * （1）map写入reduce中的数据，key类型—》Text
     * （2）map写入reduce中的数据，value类型—》IntWritable
     * （3）单词的类型：reduce进行数据合并，把数据写出到磁盘上，格式是（单词，数量）—》先写出单词的类型（key类型）—》字符串—〉Text
     * （4）数量的类型：value类型—》LongWritable
     */
    public static class Reduce1 extends Reducer<Text,IntWritable,Text,LongWritable> {
        /**
         * key===>从map中接受的key的类型
         * values===>是一个集合,进行当前可以相同时,数据值的存储
         * reduce中的数据写出到hdfs上===>通过context进行的写出
         */
        @Override
        protected void reduce(Text key, Iterable<IntWritable> values, Reducer<Text, IntWritable, Text, LongWritable>.Context context) throws IOException, InterruptedException {
            int count=0;
            for (IntWritable i:values
            ) {
                count+=i.get();
            }
            context.write(key,new LongWritable(count));
        }
    }

    public static void main(String[] args){
//        进行java程序的运行
//        hdfs的配置
        Configuration conf=new Configuration();
        conf.set("fs.defaultFS","hdfs://192.168.246.177:9000");
        //用空格进行key 和 value的区分(注意KeyValueLineRecordReader的导包--->lib下的)
        conf.set(KeyValueLineRecordReader.KEY_VALUE_SEPARATOR," ");
        try {
            Job job = Job.getInstance(conf);
//            job相关信息
//            设置job的名字
            job.setJobName("javawordcount");
//            job运行类
            job.setJarByClass(Demo4.class);

//            job执行map相关信息的配置
            job.setMapperClass(Demo4.Map1.class);
//                向reduce输出key的类型
            job.setMapOutputKeyClass(Text.class);
//                向rudece输出value的类型
            job.setMapOutputValueClass(IntWritable.class);

//            job执行reduce的配置
            job.setReducerClass(Demo4.Reduce1.class);
            job.setOutputKeyClass(Text.class);
            job.setOutputValueClass(LongWritable.class);

//            以文本文件的方式进行读取,map的第一个泛型是位置,第二个泛型是当前一行的数据
//            job.setInputFormatClass(TextInputFormat.class);//这个是默认的

//            以keyvalue的方式进行数据的读取-->解读 : 以文件每一行开始的单词作为key,后面的单词作为value
            //注意KeyValueTextInputFormat的导包-->lib里的
            job.setInputFormatClass(KeyValueTextInputFormat.class);

//            注意导包import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
            FileInputFormat.setInputPaths(job,new Path("/dat2.txt"));
            FileOutputFormat.setOutputPath(job,new Path("/java5"));

//            提交执行
            job.waitForCompletion(true);

        } catch (IOException e) {
            throw new RuntimeException(e);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        }
    }
}
_小杜小杜_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
hadoop-mapreduce-client-core-2.5.1-API文档-中文版.zip
04-23
赠送jar包：hadoop-mapreduce-client-core-2.5.1.jar； 赠送原API文档：hadoop-mapreduce-client-core-2.5.1-javadoc.jar； 赠送源代码：hadoop-mapreduce-client-core-2.5.1-sources.jar； 赠送Maven依赖信息文件：hadoop-mapreduce-client-core-2.5.1.pom； 包含翻译后的API文档：hadoop-mapreduce-client-core-2.5.1-javadoc-API文档-中文(简体)版.zip； Maven坐标：org.apache.hadoop:hadoop-mapreduce-client-core:2.5.1； 标签：core、apache、mapreduce、client、hadoop、jar包、java、API文档、中文版； 使用方法：解压翻译后的API文档，用浏览器打开“index.html”文件，即可纵览文档内容。 人性化翻译，文档中的代码和结构保持不变，注释和说明精准翻译，请放心使用。
Hadoop系列（七）Hadoop三大核心之MapReduce-程序编写
南山饱虎的博客
03-27 299
文章目录1. 准备部分2. jar包依赖3. Map部分4.Reduce部分5.提交部分6.打包提交 接下来以一个简单的WordCount为例子，介绍Java版本的MapReduce的程序编写。 mapreduce程序主要分三部分：1.map部分，2.reduce部分，3.提交部分。 1. 准备部分 hadoop中，针对数据类型自成一体，与java的数据类型对应。封装在hadoop.io包中，主要...
【Hadoop】MapReduce详解
小哲的博客
07-26 4906
MapReduce详解MapReduce介绍MapReduce的基本编程模型MapReduce的计算过程1. Map阶段可以概括为5个步骤：2. Reduce节点也可以分为5个步骤：设置ReduceTask并行度（个数）关于分片（Split）关于ShuffleMap端的shuffleReduce端的ShuffleShuffle流程详解补充问题：MapReduce分区相关问题理解1.Partition的原理和作用2.Partition的使用3.分组的概念和使用分组排序的步骤4.Combiner的使用概念实现步
【大数据】Hadoop_MapReduce➕实操（附详细代码）
YG15165的博客
07-30 1888
MapReduce是hadoop的核心组件之一，hadoop要分布式包括两部分，一是分布式文件系统hdfs，一是分布式计算框，就是mapreduce，二者缺一不可，也就是说，可以通过mapreduce很容易在hadoop平台上进行分布式的计算编程sftp命令：Windows下登录Hadoop102lcd切换Windows路径，cd切换Linux路径，get下载，put上传🧮MapReduce是一个分布式运算程序的编程框架，是用户开发“基于Hadoop 的数据分析应用”的核心框架。
MapReduce程序编写
unhurried人生——冕临的博客
09-17 2565
Hadoop支持多种语言开发MapReduce程序，但是对JAVA语言的支持最好。编写一个MapReduce程序需要新建三个类：Mapper类、Reduce类、驱动类。Mapper类何Reduce类也可以作为内部类放在程序执行主类中。
如何在Hadoop上编写MapReduce程序
lu_123456的专栏
11-16 875
1. 概述 1970年，IBM的研究员E.F.Codd博士在刊物《Communication of the ACM》上发表了一篇名为“A Relational Model of Data for Large Shared Data Banks”的论文，提出了关系模型的概念，标志着关系数据库的诞生，随后几十年，关系数据库及其结构化查询语言SQL成为程序员必须掌握的基本技能之一。 2005年4月，
Hadoop 之 MapReduce 编写
CodeFlight
09-01 589
文章目录Hadoop 之 MapReduce 编写Configruation API 要点合并资源（Combining Resources）变量扩展（Variable Expansion）配置开发环境管理配置GenericOptionsParser，Tool，and ToolRunner路径以及依赖客户端路径作业路径打包依赖 Hadoop 之 MapReduce 编写 写 MapReduce 的套路，首先写 map 和 reduce 函数，在 IDE 中拿一小部分的数据集进行调试，编写单元测试（MRUnit
Hadoop之MapReduce编程
donger__chen的博客
12-13 1266
MapReduce编程基础 0. MR与Java的数据类型对比 MR Java boolean BooleanWritable byte ByteWritable int IntWritable float FloatWritable long LongWritable double DoubleWritable String Text map MapWritable array ArrayWritable //数据类型所在java包 import org
Hadoop之MapReduce
qq_35599414的博客
01-03 946
多个应用程序存在依赖关系，后一个应用程序的输入为前一个的输出。也就是说你写一个分布式程序，跟写一个简单的串行程序是一模一。其中一台机器挂了，它可以把上面的计算任务转移到另外一个节点上运行，并发实例互不相干，但是他们的数据依赖于上一个阶段。它简单的实现一些接口，就可以完成一个分布式程序，当你的计算资源不能得到满足的时候，你可以通过。设计的初衷就是使程序能够部署在廉价的。并发实例，完全并行运行，互不相干。集群的客户端，用于提交我们整个程序到。流式计算的输入数据是动态的，而。作业的输出结果都会写入到磁盘，
【Hadoop-MapReduce】MapReduce编程步骤及工作原理
weixin_53543905的博客
12-25 1087
思想分而治之map：负责分的过程reduce：负责合的过程。【Hadoop-MapReduce】MapReduce编程步骤及工作原理
hadoop-mapreduce-client-jobclient-2.6.5-API文档-中文版.zip
05-01
赠送jar包：hadoop-mapreduce-client-jobclient-2.6.5.jar； 赠送原API文档：hadoop-mapreduce-client-jobclient-2.6.5-javadoc.jar； 赠送源代码：hadoop-mapreduce-client-jobclient-2.6.5-sources.jar； 赠送...
hadoop-3.3.4 版本（最新版）
12-14
Hadoop 架构有两个主要的组件：分布式文件系统 HDFS 和 MapReduce 引擎。 在 Hadoop 中，MapReduce 底层的分布式文件系统是独文模块，用户可按照约定 的一套接口实现自己的分布式文件系统，然后经过简单的配置后，...
hadoop-mapreduce-examples-2.6.5.jar
10-23
hadoop-mapreduce-examples-2.6.5.jar 官方案例源码
hadoop-mapreduce-examples-2.7.1.jar
06-03
hadoop-mapreduce-examples-2.7.1.jar
hadoop-mapreduce:hadoop MapReduce
05-02
hadoop-mapreduce Hadoop MapReduce示例。 使用HDFS中存储的access.log文件，实现MapReduce以查找每个IP访问该网站的次数。先决条件： 已安装Hadoop。 将access.log文件复制到hdfs中。 假设它在hdfs：/// logs下用法...
【Hadoop】--基于hadoop和hive实现聊天数据统计分析，构建聊天数据分析报表[17]
weixin_63106307的博客
05-04 855
BI：Business Intelligence，商业智能。指用现代数据仓库技术、线上分析处理技术、数据挖掘和数据展现技术进行分析以实现商业价值。简单来说，就是借助BI工具，可以完成复杂的数据分析、数据统计等需求，为公司决策带来巨大的价值。所以，一般提到BI，我们指代的就是工具软件。FineBISuperSetPowerBITableAu详细的finebi的介绍与安装可跳转到【Hadoop】-FineBI的介绍及安装[16]阅读。
hadoop学习---基于Hive的教育平台数据仓库分析案例（一）
最新发布
weixin_46164667的博客
05-04 844
基于hive的数据仓库搭建项目，主题是关于在线教育平台数据仓库搭建。
Hadoop+Spark大数据技术（微课版）曾国荪、曹洁版思维导图第五次作业 第五章 Scala基础与编程
qq_64684039的博客
04-28 2270
1. 面向对象：Scala是一种完全面向对象的语言。其每一种数据类型都是一个对象，这使得它具有非常统一的模型。2. 函数式编程：Scala同时支持函数式编程，它拥有高阶函数、闭包、不可变数据结构、递归等函数式编程的关键特性。3. 扩展性：Scala的语法非常灵活，允许开发者自定义运算符和语法糖。也支持模式匹配、类型推断和匿名函数等高级特性，这些都为编写简洁、高效的代码提供了可能。此外，Scala的语法允许在单个文件中定义类、对象、函数等，使得代码组织更加灵活。
wpf线程中更新UI的4种方式
故里2130
05-04 231
总结：通过案例，可以了解到，上面4种方式，对于此案例来说都可以达到最终的效果，但是那一种效果最好，并没有体现出来。博主认为：第三种最好，原因是从这个需求上考虑的，因为需求需要更新的就是txtUsername上面的数据，那么直接作用于它，对于资源的耗损，将是最少得。在wpf中，更新UI上面的数据，那是必经之路，搞不好，就是死锁，或者没反应，很多时候，都是嵌套的非常深导致的。但是更新UI的方式，有很多的种，不同的方式，表示的意思不一样，但是眼睛看到的，似乎是一回事。点击确定后，和前面的效果是一样的。
hadoop-mapreduce-client-core
11-18
hadoop-mapreduce-client-core是Hadoop分布式计算框架中的核心模块之一。它主要包含了Hadoop MapReduce的核心功能和API接口，是实现MapReduce编程模型的必备组件。 Hadoop MapReduce是一种用于大规模数据处理的编程...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值