Creating a Hadoop-2.x project in Eclipse

Creating a Hadoop-2.x project in Eclipse

hortonworks:MapReduce Ports

http://docs.hortonworks.com/HDPDocuments/HDP1/HDP-1.2.0/bk_reference/content/reference_chap2_2.html

hadoop-1.x 集群默认配置和常用配置

 http://www.cnblogs.com/ggjucheng/archive/2012/04/17/2454590.html

Eclipse下搭建Hadoop-2.x开发环境{good}

http://blog.csdn.net/twlkyao/article/details/17578541

Location name和Host填写localhost，

DFS Master填写HDFS的端口号必须和core-site.xml中的HDFS配置端口一致，这里填写9000，

Map/Reduce Master的端口号必须和Mapred-site.xml中的HDFS配置端口号一致（Hadoop2.x.0版本中没有配置，建议按照 Hadoop1.x配置），这里填写9001；

貌似这一端口号是9000累加的。

User name为Hadoop的所有者用户名，即安装Hadoop的Linux用户，这里为Hduser。

注意：hadoop 2.x 各种端口很复杂，也没有正式的文档。

这里是沿袭 hadoop 1.x的设置, 但幸运的是仍然可以工作。

=======================

 

December 7, 2013

Running Hadoop-1.2.1 MapReduce App from Eclipse Kepler

http://letsdobigdata.wordpress.com/2013/12/07/running-hadoop-mapreduce-application-from-eclipse-kepler/

 ===========================

Eclipse上运行hadoop应用总的来说有2种模式，
第一种就是Local模式，也叫本地模式，第二种就是我们正式的线上集群模式。

当运行Local模式的时候，程序并不会被提交到Hadoop集群上，而是基于单机的模式跑的，
但是单机的模式，运行的结果仍在是存储在HDFS上的，只不过没有利用hadoop集群的资源，
单机的模式不提交jar包到hadoop集群上，因此使用local来测试MR程序是否能够正常运行。


1.安装环境
   系统:centos6.4 x64
   hadoop版本:2.2.0
   eclipse版本：kepler

2. 下载eclipse hadoop2.2插件,hadoop2x-eclipse-plugin-master.zip,解压放到eclipse的plugin目录下，重启eclipse.

3. 配置hadoop installation directory。
  如果安装插件成功，打开Window-->Preferens，你会发现Hadoop Map/Reduce选项，
  在这个选项里你需要配置Hadoop installation  directory。配置完成后退出。

4.配置Map/Reduce Locations。 在Window-->open persperctive->other...，
  在MapReduce Tools中选择Map/Reduce Locations。

   在Map/Reduce Locations（Eclipse界面的正下方）中新建一个Hadoop Location。在这个View中，点击鼠标右键-->New Hadoop Location。
   在弹出的对话框中你需要配置Location name，可任意填，如Hadoop，  
   DFS Master填写HDFS的端口号必须和core-site.xml中的HDFS配置端口一致，这里填写9000，
   Map/Reduce Master的端口号必须和Mapred-site.xml中的HDFS配置端口号一致（Hadoop2.x.0版本中没有配置，建议按照 Hadoop1.x配置），这里填写9001；
  貌似这一端口号是9000累加的。
  User name为Hadoop的所有者用户名，即安装Hadoop的Linux用户，这里为Hduser。

  注意：hadoop 2.x 各种端口很复杂，也没有正式的文档。

    这里是沿袭 hadoop 1.x的设置, 但幸运的是仍然可以工作。

5.新建一个hadoop项目测试.
   新建项目:File-->New-->Other-->Map/Reduce Project 项目名可以随便取，如Test001。
   新建测试类，WordCountTest,代码如下:
  准备输入： HDFS下创建input目录，并把统计文本put到目录下面。

6.Run

 选择run -》java application ，

  检查输出：

   如果执行成功刷新下hdfs的目录会出现 /output目录 结果就在part-r-00000文件

7.到此为止，只是利用Local模式运行并测试了hadoop  MR Application,并没有部署到实际集群上。

8.分布式运行:

  Eclispe Hadoop插件支持导出可执行jar文件。

 例如：本项目,在Eclipse中Export jar, 导出~/Test.jar, 然后提交到shell运行:

  $ bin/hadoop jar  ~/Test.jar   TestPkg.WordCountTest

  再例如 hadoop2.x自带的wordcount,提交到shell运行

  $ bin/hadoop jar  hadoop-mapreduce-examples-2.3.0.jar  wordcount   /input   /output

Q：java.lang.IllegalArgumentException: Wrong FS:  hdfs:/ expected file:///

A:需要把集群上的core-site.xml和hdfs-site.xml放到Eclipse当前工程下的bin文件夹下面.

package TestPkg;

import java.io.IOException;
import java.util.StringTokenizer;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapred.JobConf;
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 org.apache.hadoop.util.GenericOptionsParser;

public class WordCountTest {
    
    
    public static class TokenizerMapper extends
            Mapper<Object, Text, Text, IntWritable> {

        /**
         * LongWritable, IntWritable, Text Hadoop Java WritableComparable
         * long,int,String
         */
        private final static IntWritable one = new IntWritable(1);
        private Text word = new Text();// Text BinaryComparablekey

        /**
         * Mappermap void map(K1 key, V1 value, OutputCollector<K2,V2> output,
         * Reporter reporter) k/vk/v 0 OutputCollectorMapperReducer<k,v>
         * OutputCollectorcollect(k, v):(k,v)output
         */

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

            /**
             * 
             * c++ java hello world java hello you me too mapmapkey 0 c++ java
             * hello 16 world java hello 34 you me too
             */

            /**
             * 
             * 
             * 
             * c++ 1 java 1 hello 1 world 1 java 1 hello 1 you 1 me 1 too 1
             * reduce
             */
            StringTokenizer itr = new StringTokenizer(value.toString());//
            System.out.println("value  " + value.toString());
            System.out.println("key  " + key.toString());

            while (itr.hasMoreTokens()) {
                word.set(itr.nextToken());

                context.write(word, one);
            }
        }
    }

    public static class IntSumReducer extends
            Reducer<Text, IntWritable, Text, IntWritable> {
        private IntWritable result = new IntWritable();

        /**
         * reduce (c++ [1]) (java [1,1]) (hello [1,1]) (world [1]) (you [1]) (me
         * [1]) (you [1]) reduce
         * 
         */
        public void reduce(Text key, Iterable<IntWritable> values,
                Context context) throws IOException, InterruptedException {
            int sum = 0;
            /**
             * reduce
             * 
             * c++ 1 hello 2 java 2 me 1 too 1 world 1 you 1
             * 
             */
            for (IntWritable val : values) {
                sum += val.get();
            }

            result.set(sum);
            context.write(key, result);
        }
    }

    public static void main(String[] args) throws Exception {

        
        args = new String[2];
        args[0] = "hdfs://n0:9000/input";
        args[1] = "hdfs://n0:9000/output";

        System.out.println("========input,output=============");
        Configuration conf = new Configuration();
        String[] otherArgs = new GenericOptionsParser(conf, args)
                .getRemainingArgs();
        
        for (String s : otherArgs) {
            System.out.println(s);
        }

        // HDFS
        if (otherArgs.length != 2) {
            System.err.println("Usage: wordcount <in> <out>");
            System.exit(2);
        }
                    
        //check output dir: if exist,delete. 
        FileSystem  fs=FileSystem.get(conf);        
        Path pout=new Path(otherArgs[1]);  
        if(fs.exists(pout)){  
            fs.delete(pout, true);  
            System.out.printf("output path [%s]exist,delete....
",otherArgs[1]);    
        }           
        //
        
        // JobConf conf1 = new JobConf(WordCount.class);
        Job job = new Job(conf, "Word Count Test");
        
        job.setJarByClass(WordCountTest.class);
        
        job.setMapperClass(TokenizerMapper.class);  
        job.setCombinerClass(IntSumReducer.class);  
        job.setReducerClass(IntSumReducer.class);  
        
        job.setOutputKeyClass(Text.class);         // key
        job.setOutputValueClass(IntWritable.class);// value
        
        FileInputFormat.addInputPath(job, new Path(otherArgs[0]));   
        FileOutputFormat.setOutputPath(job, new Path(otherArgs[1])); 
        
        System.exit(job.waitForCompletion(true) ? 0 : 1);
    }

}