mapreduce写文件快还是hbase快 mapreduce优缺点

转载

mob64ca14040d22 2023-09-27 20:07:45

文章标签 hadoop Text 数据 文章分类 Hbase 数据库

1：MapReduce定义

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

2：MapReduce优缺点

优点1：易于编程。用户只关心业务逻辑，实现框架的接口即可。

2：良好的扩展性。可以动态的增加服务器，解决计算资源不够的问题。

3：高容错性。任何一台机器挂掉，可以将任务转移到其他节点。

4：适合海量数据的计算。可以实现上千台服务器并行工作。

缺点1：不擅长实时计算。不能在毫秒级之内返回结果。

2：不擅长流式计算。输入的数据是静态的，放在那里基本保持不变的。反之是实时计算，实时计算就是来一条数据，进行处理，再来一条在进行处理。

3：不擅长有向无环图计算。但是能做。有向无环图计算，就类似于前一个程序的运行输出结果作为后一个程序运行的输入结果。

3：MapReduce核心思想

mapreduce写文件快还是hbase快 mapreduce优缺点_Text

4：MapReduce进程

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

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

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

5：MapReduce编程规范

分为Mapper、Reducer 和 Driver三个阶段。

1：Mapper阶段
1：用户自定义的Mapper要继承自己的父类
2：输入数据是KV对的形式，假如说进来一个单词，K为这行的偏移量，V是这行的内容
3：Mapper中的业务逻辑写在map（）方法中
4：Mapper的输出数据是KV对的形式
5：map（）方法对每一个进来的<K,V>调用一次，即使多少行执行多少次。
2：Reducer阶段
1：用户自定义的Reducer要继承自己的父类
2：Reducer的输入数据类型对应Mapper的输出数据类型，也是KV
3：Reducer的业务逻辑写在reduce（）方法中
4：ReduceTask进程对每一组相同k的<k,v>组调用一次reduce（）方法
3：Driver阶段
相当于yarn集群的客户端，用于提交我们整个程序到yarn集群，提交的是封装了MapReduce程序相关运行参数的job对象。

6：案例

1：在本地上面进行测试，即在idea里面进行运行，输入输出都为本地路径。

1：需求任务：在给定的文本文件中统计输出每一个单词出现的总次数

#输入数据
atguigu atguigu
ss ss
cls cls
jiao
banzhang
xue
hadoop
#期望输出数据
atguigu 2
banzhang 1
cls 2
hadoop 1
jiao 1
ss 2
xue 1

2：三个阶段的主要过程

mapper：1：将MapTask传给我们的文本内容先转换成String

2：根据空格将这一行切分成单词

3：将单词输出成<单词，1>

Reducer：1：汇总各个key的个数

2：输出该key的总次数

Driver：1：获取配置信息，获取job对象实例

2：指定本程序的jar包所在的本地路径

3：关联Mapper、Reducer业务类

4：指定Mapper输出数据的kv类型

5：指定最终输出数据的kv类型

6：指定job的输入原始文件所在目录

7：指定job的输出结果所在目录

8：提交作业

3：环境准备

# 新建工程，在pom.xml中添加依赖
<dependencies>
 <dependency>
 <groupId>org.apache.hadoop</groupId>
 <artifactId>hadoop-client</artifactId>
 <version>3.1.3</version>
 </dependency>
 <dependency>
 <groupId>junit</groupId>
 <artifactId>junit</artifactId>
 <version>4.12</version>
 </dependency>
 <dependency>
 <groupId>org.slf4j</groupId>
 <artifactId>slf4j-log4j12</artifactId>
 <version>1.7.30</version>
 </dependency>
</dependencies>

# resources目录下创建log4j.properties
log4j.rootLogger=INFO, stdout 
log4j.appender.stdout=org.apache.log4j.ConsoleAppender 
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 
log4j.appender.stdout.layout.ConversionPattern=%d %p [%c] - %m%n 
log4j.appender.logfile=org.apache.log4j.FileAppender 
log4j.appender.logfile.File=target/spring.log 
log4j.appender.logfile.layout=org.apache.log4j.PatternLayout 
log4j.appender.logfile.layout.ConversionPattern=%d %p [%c] - %m%n

# 编写mapper类，第一个参数为偏移量，第二个为内容，第三个内容，第四个是输出类型int
public class WordCountMapper extends Mapper<LongWritable, Text, Text, IntWritable>{
    Text k = new Text();
    IntWritable v = new IntWritable(1);
    @Override
    protected void map(LongWritable key, Text value, Context context)
    throws IOException, InterruptedException {
    // 1 获取一行
    String line = value.toString();
    // 2 切割
    String[] words = line.split(" ");
    // 3 输出
    for (String word : words) {
        k.set(word);
        context.write(k, v);
    }
}

# 编写Reducer类
public class WordCountReducer extends Reducer<Text, IntWritable, Text, IntWritable>{
    int sum;
    IntWritable v = new IntWritable();

    # 每一组key会调用一次这个方法
    @Override
    protected void reduce(Text key, Iterable<IntWritable> values,Context context) throws IOException, InterruptedException {
    // 1 累加求和
    sum = 0;
    for (IntWritable count : values) {
        sum += count.get();
    }
    // 2 输出
    v.set(sum);
    context.write(key,v);
}

#编写Driver类

public class WordCountDriver {
    public static void main(String[] args) throws IOException,                                       ClassNotFoundException,InterruptedException {

    // 1 获取配置信息以及获取 job 对象
    Configuration conf = new Configuration();
    Job job = Job.getInstance(conf);

    // 2 关联本 Driver 程序的 jar
    job.setJarByClass(WordCountDriver.class);

    // 3 关联 Mapper 和 Reducer 的 jar
    job.setMapperClass(WordCountMapper.class);
    job.setReducerClass(WordCountReducer.class);

    // 4 设置 Mapper 输出的 kv 类型
    job.setMapOutputKeyClass(Text.class);
    job.setMapOutputValueClass(IntWritable.class);

    // 5 设置最终输出 kv 类型
    job.setOutputKeyClass(Text.class);
    job.setOutputValueClass(IntWritable.class);

    // 6 设置输入和输出路径,输出路径不能存在，不然会执行出错
    FileInputFormat.setInputPaths(job, new Path(args[0]));
    FileOutputFormat.setOutputPath(job, new Path(args[1]));

    // 7 提交 job
    boolean result = job.waitForCompletion(true);
    System.exit(result ? 0 : 1);
}

2：在集群环境中运行

1：把如下打包插件导入到pom文件依赖后面（在idea右边maven然后项目名-lifecycle-package即可），尽量使用带以来的jar包，使用不带jar包依赖的话，需要集群环境中有相应jar包，打包完成之后wc.jar，拷贝到Hadoop集群的/opt/mudule/hadoop-3.1.3路径之下。

<build>
    <plugins>
        <plugin>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.6.1</version>
            <configuration>
                <source>1.8</source>
                <target>1.8</target>
            </configuration>
        </plugin>
        <plugin>
            <artifactId>maven-assembly-plugin</artifactId>
            <configuration>
                <descriptorRefs>
                    <descriptorRef>jar-with-dependencies</descriptorRef>
                </descriptorRefs>
            </configuration>
            <executions>
                <execution>
                    <id>make-assembly</id>
                    <phase>package</phase>
                    <goals>
                        <goal>single</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

2：在虚拟机上启动集群。

[atguigu@hadoop102 hadoop-3.1.3]sbin/start-dfs.sh
[atguigu@hadoop103 hadoop-3.1.3]$ sbin/start-yarn.sh

3：执行程序，这时候路径就在hdfs上面的路径了。

[atguigu@hadoop102 hadoop-3.1.3]$ hadoop jar wc.jar
com.atguigu.mapreduce.wordcount.WordCountDriver /user/atguigu/input 
/user/atguigu/output
# 输入路径这样写的话，目录里面所有文件都会被检测执行
# 例如hello.txt 里面有hello hadoop。world.txt里面有hello world
# 虽然两者不是同一文件，但都属于input目录，这样执行出来的结果就是hello 2 world 1 hadoop 1

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。