链接hadoop作业

最新推荐文章于 2023-01-06 21:43:59 发布
最新推荐文章于 2023-01-06 21:43:59 发布
阅读量504 收藏
点赞数 1
分类专栏： Hadoop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010660276/article/details/50982654
版权

有时候一个复杂的任务不能只用一个MapReduce作业完成，需要分解成多个子任务，每个子任务是一个单独的MapReduce作业。这个时候就需要将多个MapReduce作业连接起来

让你真正明白什么是MapReduce组合式，迭代式，链式
多个mapreduce工作相互依赖处理方法完整实例（JobControl）
Hadoop 依赖关系作业 MapReduce JobControl 错误纠正
1. 顺序式
在MapReduce的迭代思想，类似for循环，前一个 MapReduce的输出结果，作为下一个 MapReduce的输入，任务完成后中间结果都可以删除。

Configuration conf1 = new Configuration();
Job job1 = new Job(conf1,"job1");
.....
FileInputFormat.addInputPath(job1,InputPaht1);
FileOutputFromat.setOoutputPath(job1,Outpath1);
job1.waitForCompletion(true);
//sub Mapreduce
Configuration conf2 = new Configuration();
Job job2 = new Job(conf1,"job1");
.....
FileInputFormat.addInputPath(job2,Outpath1);
FileOutputFromat.setOoutputPath(job2,Outpath2);
job2.waitForCompletion(true);
//sub Mapreduce
Configuration conf3 = new Configuration();
Job job3 = new Job(conf1,"job1");
.....
FileInputFormat.addInputPath(job3,Outpath2);
FileOutputFromat.setOoutputPath(job3,Outpath3);
job3.waitForCompletion(true);
.....
  1. 具有依赖关系的MapReduce作业
    我们可以设想一下MapReduce有3个子任务job1,job2,job3构成，其中job1和job2相互独立，job3要在job1和job2完成之后才执行。这种关系就叫复杂数据依赖关系的组合时mapreduce。hadoop为这种组合关系提供了一种执行和控制机制，hadoop通过job和jobControl类提供具体的编程方法。Job除了维护子任务的配置信息，还维护子任务的依赖关系，而jobControl控制整个作业流程，把所有的子任务作业加入到JobControl中，执行JobControl的run（）方法即可运行程序。
Configuration job1conf = new Configuration();
Job job1 = new Job(job1conf,"Job1");
.........//job1 其他设置
Configuration job2conf = new Configuration();
Job job2 = new Job(job2conf,"Job2");
.........//job2 其他设置
Configuration job3conf = new Configuration();
Job job3 = new Job(job3conf,"Job3");
.........//job3 其他设置
job3.addDepending(job1);//设置job3和job1的依赖关系
job3.addDepending(job2);
JobControl JC = new JobControl("123");
JC.addJob(job1);//把三个job加入到jobcontorl中
JC.addJob(job2);
JC.addJob(job3);
JC.run();

完整示例：
输入格式为：X,Y，表示Y被X引用，现想统计，被引用次数最高的K个
第一个mapreduce作业统计每个专利被引用多少次，第二个mapreduce实现topk

package Chapter5;

import java.io.IOException;
import java.util.TreeMap;

import org.apache.hadoop.classification.InterfaceAudience.Public;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.conf.Configured;
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.lib.input.TextInputFormat;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.Reducer.Context;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.input.KeyValueTextInputFormat;
import org.apache.hadoop.mapreduce.lib.jobcontrol.ControlledJob;
import org.apache.hadoop.mapreduce.lib.jobcontrol.JobControl;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;
import org.apache.hadoop.util.Tool;
import org.apache.hadoop.util.ToolRunner;


public class DependingJoin extends Configured implements Tool {

    public static class MapClass1 extends Mapper<Text, Text, Text, IntWritable>{

        private static IntWritable one=new IntWritable(1);
        public void map(Text key,Text value,Context context)throws IOException,InterruptedException{

            context.write(value, one);
        }
    }

    public static class Reduce1 extends Reducer<Text, IntWritable, Text,IntWritable>{

        public void reduce(Text key,Iterable<IntWritable> values,Context context)throws IOException,InterruptedException{

            int sum=0;
            for(IntWritable x : values){
                sum+=x.get();
            }
            context.write(key, new IntWritable(sum));
        }
    }
    private static Integer K=10;
    public static class MapClass2 extends Mapper<Text, Text, IntWritable, Text>{

        TreeMap<Integer, String> map=new TreeMap<Integer,String>();
        public void map(Text key,Text value,Context context) throws IOException,InterruptedException{
            if(key!=null&&value!=null){
                String patent=key.toString();
                Integer num=Integer.parseInt(value.toString());
                map.put(num, patent);
                if(map.size()>K){
                    map.remove(map.firstKey());
                }
            }
        }
        @Override
        protected void cleanup(Mapper<Text, Text, IntWritable, Text>.Context context)throws IOException,InterruptedException{

            for(Integer num:map.keySet()){
                context.write(new IntWritable(num) ,new Text(map.get(num)));
            }
        }
    }

    public static class Reduce2  extends Reducer<IntWritable, Text, Text, IntWritable>{

        TreeMap<Integer, String> map=new TreeMap<Integer,String>();
        public void reduce(IntWritable key,Iterable<Text> value,Context context)throws IOException,InterruptedException{

            for(Text text : value){
                map.put(key.get(), text.toString());
                if(map.size()>K){
                    map.remove(map.firstKey());
                }
            }
        }
        @Override
        protected void cleanup(Reducer<IntWritable, Text, Text, IntWritable>.Context context)throws IOException,InterruptedException{

            for(Integer num:map.keySet()){
                context.write(new Text(map.get(num)),new IntWritable(num));
            }

        }
    }

    @Override
    public int run(String[] arg0) throws Exception {
        // TODO Auto-generated method stub
        //job1
        Configuration configuration1=getConf();
        configuration1.set("key.value.separator.in.input.line", ",");
        configuration1.set("mapred.textoutputformat.separator", "\t");

        Job job1=new Job(configuration1, "citenum");
        FileInputFormat.addInputPath(job1, new Path(arg0[0]));
        FileOutputFormat.setOutputPath(job1, new Path(arg0[1]));

        job1.setJarByClass(DependingJoin.class);
        job1.setMapperClass(MapClass1.class);
        job1.setReducerClass(Reduce1.class);
        job1.setOutputKeyClass(Text.class);
        job1.setOutputValueClass(IntWritable.class);
        job1.setInputFormatClass(KeyValueTextInputFormat.class);
        job1.setOutputFormatClass(TextOutputFormat.class);
        ControlledJob ctrjob1=new ControlledJob(configuration1);
        ctrjob1.setJob(job1);

        //job2
        Configuration configuration2=getConf();
        configuration2.set("key.value.separator.in.input.line", "\t");
        Job job2=new Job(configuration2, "citenum2");
        FileInputFormat.addInputPath(job2, new Path(arg0[1]));
        FileOutputFormat.setOutputPath(job2, new Path(arg0[2]));

        job2.setJarByClass(DependingJoin.class);
        job2.setMapperClass(MapClass2.class);
        job2.setReducerClass(Reduce2.class);
        job2.setOutputKeyClass(Text.class);
        job2.setOutputValueClass(IntWritable.class);
        job2.setMapOutputKeyClass(IntWritable.class);
        job2.setMapOutputValueClass(Text.class);
        job2.setInputFormatClass(KeyValueTextInputFormat.class);
        job2.setOutputFormatClass(TextOutputFormat.class);
        ControlledJob ctrjob2=new ControlledJob(configuration2);
        ctrjob2.setJob(job2);

        //depend
        ctrjob2.addDependingJob(ctrjob1);

        JobControl jobControl=new JobControl("myjob");

        jobControl.addJob(ctrjob1);
        jobControl.addJob(ctrjob2);

        Thread thread=new Thread(jobControl);
        thread.start();
        while(true){
            if(jobControl.allFinished()){
                System.out.println(jobControl.getSuccessfulJobList());
                jobControl.stop();
                break;
            }
        }
        return 0;
    }

    public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub
        int res=ToolRunner.run(new Configuration(), new DependingJoin(), args);
        System.exit(res);
    }
}
  1. 预处理和后处理阶段的链接
    首先看一下例子，来说明为什么要有链式MapReduce，假设在统计单词是，会出现这样的词，make，made，making等，他们都属于一个词，在单词累加的时候，都归于一个词。解决的方法为用一个单独的Mapreduce任务可以实现，单增加了多个Mapreduce作业，将增加整个作业处理的周期，还增加了I/O操作，因而处理效率不高。一个较好的办法就是在核心的MapReduce之外，增加一个辅助的Map过程，然后将这个辅助的Map过程和核心的Mapreudce过程合并为一个链式的Mapreduce，从而完成整个作业。hadoop提供了专门的链式ChainMapper和ChainReducer来处理链式任务，ChainMapper允许一个Map任务中添加多个Map的子任务，ChainReducer可以在Reducer执行之后，在加入多个Map的子任务。
package Chapter5;

import java.io.IOException;
import java.util.TreeMap;
import java.util.regex.Pattern;

import org.apache.hadoop.classification.InterfaceAudience.Public;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.conf.Configured;
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.mapred.JobConf;
import org.apache.hadoop.mapreduce.lib.input.TextInputFormat;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.Reducer.Context;
import org.apache.hadoop.mapreduce.lib.chain.ChainMapper;
import org.apache.hadoop.mapreduce.lib.chain.ChainReducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.input.KeyValueTextInputFormat;
import org.apache.hadoop.mapreduce.lib.jobcontrol.ControlledJob;
import org.apache.hadoop.mapreduce.lib.jobcontrol.JobControl;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;
import org.apache.hadoop.util.Tool;
import org.apache.hadoop.util.ToolRunner;
import org.apache.hadoop.util.bloom.BloomFilter;

import com.sun.jersey.server.impl.model.method.dispatch.VoidVoidDispatchProvider;
import com.sun.scenario.effect.Bloom;
import com.sun.security.auth.callback.TextCallbackHandler;


public class ChainJob extends Configured implements Tool {

    public static class MapClass1 extends Mapper<Text, Text, Text, Text>{

        public void map(Text key,Text value,Context context)throws IOException,InterruptedException{

            if (key!=null&&Pattern.matches("\\d+", key.toString())) {
                //System.out.println(key+"&&&"+value);
                context.write(key, value);
            }
        }
    }
    public static class MapClass2 extends Mapper<Text, Text, Text, Text>{
        public void map(Text key,Text value,Context context)throws IOException,InterruptedException{

            context.write(value, key);
        }
    }

    public static class Reduce extends Reducer<Text, Text, Text,Text>{

        public void reduce(Text key,Iterable<Text> values,Context context)throws IOException,InterruptedException{

            String res="";
            for(Text x : values){
                if(res.length()>0)res+=",";
                res+=x.toString();
            }
            context.write(key, new Text(res));
        }
    }
    public static class MapClass3 extends Mapper<Text, Text, Text, IntWritable>{
        public void map(Text key,Text value,Context context)throws IOException,InterruptedException{

            String tokens []=value.toString().split(",");
            int sum=tokens.length;
            context.write(key, new IntWritable(sum));
        }
    }

    @Override
    public int run(String[] arg0) throws Exception {
        // TODO Auto-generated method stub

        Configuration configuration=getConf();
        configuration.set("key.value.separator.in.input.line", ",");
        Job job=new Job(configuration,"chainjob");
        job.setJarByClass(ChainJob.class);
        job.setInputFormatClass(KeyValueTextInputFormat.class);
        job.setOutputFormatClass(TextOutputFormat.class);
        FileInputFormat.setInputPaths(job, new Path(arg0[0]));
        FileOutputFormat.setOutputPath(job, new Path(arg0[1]));

        ChainMapper.addMapper(job, MapClass1.class, Text.class, Text.class, Text.class, Text.class, new Configuration());
        ChainMapper.addMapper(job, MapClass2.class, Text.class, Text.class, Text.class, Text.class, new Configuration());
        ChainReducer.setReducer(job, Reduce.class, Text.class, Text.class, Text.class, Text.class, new Configuration());
        ChainReducer.addMapper(job, MapClass3.class, Text.class, Text.class, Text.class, IntWritable.class, new Configuration());
        System.exit(job.waitForCompletion(true)?0:1);
        return 0;
    }

    public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub
        int res=ToolRunner.run(new Configuration(), new ChainJob(), args);
        System.exit(res);
    }
}
u010660276
关注
专栏目录
拿好！你们的大数据云计算作业之hadoop搭建
weixin_43845044的博客
01-02 1032
hadoop搭建一条龙写在前面用到的工具&安装包详细步骤配置Host文件及修改主机名修改主机名检查or安装jdk将jdk加入到环境变量检查jdk是否安装成功安装hadoop1 下载hadoop2 解压至/usr/local目录下3 加入环境变量4 修改hadoop配置文件SSH免密远程登录1 实现master免密登录2 各节点间的免密登录（这个放在克隆后再做！）关闭防火墙格式化nameno...
hadoop-2.6.0
07-24
它是Hadoop在Windows操作系统上的一个动态链接库，用于支持Hadoop在非Linux环境下的运行。安装和配置Hadoop在Windows上时，`winutils.exe`也是一个必不可少的工具，它提供了包括设置Hadoop环境变量、启动HDFS和YARN...
Hadoop 学习链接
从菜鸟到菜菜鸟
09-15 352
https://amplab.cs.berkeley.edu/software/
【Hadoop】29-连接
通往神秘的道路的专栏
08-26 626
MapReduce能够执行大型数据集间的“连接”(join）操作，但是，自己从头写相关代码来执行连接的确非常棘手。除了写MapReduce程序，还可以考虑采用更高级的框架，如Pig、Hive、Cascading、Cruc或Spark等，它们都将连接操作视为整个实现的核心部分。 先简要地描述待解决的问题。假设有两个数据集：气象站数据库和天气记录数据集并考虑如何合二为一。一个典型的查询是：输出各气象站...
大数据-Hadoop学习链接
RuiKe的博客
07-03 237
1.HDFS介绍：https://blog.csdn.net/RuiKe1400360107/article/details/107080084 2.MapReduce介绍：https://blog.csdn.net/RuiKe1400360107/article/details/107088881 3.MapReduce案例分析：https://blog.csdn.net/RuiKe1400360107/article/details/107098766
第07章 连接Hadoop集群
a1234556667的博客
08-21 1390
​ 本章介绍了Hadoop的综合概述、连接Hadoop集群的基本条件以及具体连接的实现步骤。Hadoop分布式文件系统是一种文件系统实现，类似于NTFS、EXT3、EXT4等。名称节点（Name Node)第二名称节点（Secondary Name Node）数据节点（Data Node）定义SQL允许使用复杂SQL表达式作为Tableau中连接的基础。通过在自定义SQL中使用LIMIT子句，可以减小数据集以加快浏览新数据集和建立视图的速度。
hadoop实验——Java连接hadoop，对hadoop进行管理教程
m0_59799878的博客
09-23 2964
（5）导入hdfs所需的jar包，jar包在在安装hadoop目录下的share目录下的hadoop目录下的四个目录，这里我导入jar包的方法是将share目录下的hadoop目录复制粘贴到eclipse的java项目中再将jar包解析。接下来是FileSystem，这是一个抽象类，这个类是非常重要的类，通常就是用该类来对hadoop中存储的文件进行增删改查，它有很多方法，可查看hadoop API帮助文档进行了解与使用，文档网址如下。也就几行代码，对hadoop的管理步骤就。
最简xshell链接hadoop.docx
03-14
在本场景中，我们提到的"最简xshell链接hadoop"是指使用xshell工具远程连接到运行Hadoop的Linux服务器。Xshell是一款强大的终端模拟器，它支持SSH、telnet等多种协议，方便用户在Windows操作系统下与远程Linux服务器...
hadoop的hadoop.dll和winutils.exe下载
04-07
如果你在Windows上尝试运行Hadoop作业或设置Hadoop开发环境，`hadoop.dll`将是必须的。 接着，我们讨论`winutils.exe`。这个工具集包含了多种命令，如创建HDFS目录、设置HDFS权限、管理Hadoop守护进程等。在Linux上...
java大数据作业_1云计算、大数据、hadoop
01-23
标题中的“java大数据作业_1云计算、大数据、hadoop”表明了本次作业的主题，涵盖了Java编程、大数据处理以及云计算领域的核心概念。以下是针对作业问题的详细解答： 1. SAAS（Software as a Service）：软件即服务...
Hadoop学习六：Hadoop-Hdfs源码 classification包
zy19982004的专栏
05-20 282
一.org.apache.hadoop.classification.*   二.解释  InterfaceAudience类包含三个注解类，用来说明被注解类的使用范围。 InterfaceAudience.Public：所有工程可以使用被注解类。 InterfaceAudience.LimitedPrivate：指定的某些工程可以使用被注解类。For example, "C...
【Hadoop】11-序列化
通往神秘的道路的专栏
05-13 875
序列化(serialization）是指将结构化对象转化为字节流以便在网络上传输或写到磁盘进行永久存储的过程。反序列化（deserialiion）是指将字节流转回结构化对象的逆过程。序列化用于分布式数据处理的两大领域：进程间通信和永久存储。在Hadoop中，系统中多个节点上进程间的通信是通过“远程过程调用”(RPC，remote procedure call)实现的。RPC协议将消息序列化成二进制...
hadoop Yarn 编程API
weixin_34178244的博客
04-02 697
客户端编程库： 所在jar包： org.apache.hadoop.yarn.client.YarnClient 使用方法： 1 定义一个YarnClient实例： private YarnClient client； 2 构造一个Yarn客户端句柄并初始化 this.client = YarnClient.createYarnClient(); client.in...
hadoop连接外网及内网
最新发布
weixin_65195823的博客
01-06 2959
随着“互联网+”时代的到来，互联网的发展又到了一个新的高度，本文就介绍了hadoop的基础内容。
Hadoop集群（第7期）_Eclipse开发环境设置
weixin_34365635的博客
05-20 384
1、Hadoop开发环境简介 1.1 Hadoop集群简介 　　Java版本：jdk-6u31-linux-i586.bin 　　Linux系统：CentOS6.0 　　Hadoop版本：hadoop-1.0.0.tar.gz 1.2 Windows开发简介 　　Java版本：jdk-6u31-windows-i586.exe 　　Win系统：Windows 7 旗舰版 　　Ec...
GitChat·大数据 | 史上最详细的Hadoop环境搭建
热门推荐
技术杂谈
09-05 4万+
GitChat 作者：鸣宇淳 Hadoop在大数据技术体系中的地位至关重要，Hadoop是大数据技术的基础，对Hadoop基础知识的掌握的扎实程度，会决定在大数据技术道路上走多远。这是一篇入门文章，Hadoop的学习方法很多，网上也有很多学习路线图。
HDFS客户端操作（通过API操作HDFS）
now
11-03 451
package com.zhangxy.hdfs; import java.io.IOException; import java.net.URI; import java.net.URISyntaxException; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.fs.FileSystem; import org.apache.hadoop.fs.Path; public class HDFSCli.
hadoop的外部访问连接问题
young_so_nice的博客
05-15 3546
一，问题： Connection refused: no further information Exception in thread “main” java.net.ConnectException: Call From WIN-20140221JLA/192.168.111.1 to master:8020 failed on connection exception: java.
Hadoop作业的一生
lizhe10177的专栏
04-07 1150
一个简单的Hadoop作业主要实现两个类，map和reduce，然后进行配置之后就可以使用JobClient提交给JobTracker了，JobClient提交之前会先把该作业映射成几个任务，JobTracker会把这些任务分发到请求任务的TaskTracker上，每个TaskTracker属于不同主机，从而实现并行计算。     以下代码分为几个部分，作业提交，作业初始化为多个任务，请求与分发
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值