MapReduce的统计和排序功能

实验材料及说明
现有某电商网站用户对商品的收藏数据，记录了用户收藏的商品id以及收藏日期，文件名为buyer_favorite。buyer_favorite包含：买家id，商品id，收藏日期这三个字段，数据以“\t”分割，样本数据及格式如下：
买家ID 商品ID 收藏日期
10181 1000481 2010-04-04 16:54:31
20001 1001597 2010-04-07 15:07:52
20001 1001560 2010-04-07 15:08:27
20042 1001368 2010-04-08 08:20:30
20067 1002061 2010-04-08 16:45:33
20056 1003289 2010-04-12 10:50:55
20056 1003290 2010-04-12 11:57:35
20056 1003292 2010-04-12 12:05:29
20054 1002420 2010-04-14 15:24:12
20055 1001679 2010-04-14 19:46:04
20054 1010675 2010-04-14 15:23:53
20054 1002429 2010-04-14 17:52:45
20076 1002427 2010-04-14 19:35:39
20054 1003326 2010-04-20 12:54:44
20056 1002420 2010-04-15 11:24:49
20064 1002422 2010-04-15 11:35:54
20056 1003066 2010-04-15 11:43:01
20056 1003055 2010-04-15 11:43:06
20056 1010183 2010-04-15 11:45:24
20056 1002422 2010-04-15 11:45:49
20056 1003100 2010-04-15 11:45:54
20056 1003094 2010-04-15 11:45:57
20056 1003064 2010-04-15 11:46:04
20056 1010178 2010-04-15 16:15:20
20076 1003101 2010-04-15 16:37:27
20076 1003103 2010-04-15 16:37:05
20076 1003100 2010-04-15 16:37:18
20076 1003066 2010-04-15 16:37:31

实验目的

掌握MapReduce的统计排序功能。即要求根据所给材料统计每个买家收藏的商品数量，并按照收藏的商品数从大到小排列。

处理算法流程图

①MapReduce实现统计

package  shiyan;
import java.io.IOException;
import java.util.StringTokenizer;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
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.Reducer.Context;
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 org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;
public class shangpin {
	 public static class doMapper extends Mapper<Object, Text, Text, IntWritable> {
	//第一个Object表示输入key的类型；第二个Text表示输入value的类型；第三个Text表示表示输出键的类型；第四个IntWritable表示输出值的类型  
	  public static final IntWritable one = new IntWritable(1);
	  public static Text word = new Text();
	  @Override
	  protected void map(Object key, Text value, Context context) throws IOException, InterruptedException {//抛出异常 
	   StringTokenizer tokenizer = new StringTokenizer(value.toString(), " ");//以空格分割
	//StringTokenizer是Java工具包中的一个类，用于将字符串进行拆分 
	   word.set(tokenizer.nextToken());
	//返回当前位置到下一个分隔符之间的字符串
	  context.write(word, one);
	//将word存到容器中，记一个数
	  }
	 }
	 public static class doReducer extends Reducer<Text, IntWritable, Text, IntWritable> {
	  private IntWritable result = new IntWritable();
	  protected void reduce(Text key, Iterable<IntWritable> values, Context context)
	    throws IOException, InterruptedException {
	   int sum = 0;
	   for (IntWritable value : values) {
	    sum += value.get();
	   }
	   result.set(sum);
	   context.write(key, result);
	  }
	 }
	 
	 public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
		  Job job = Job.getInstance();
		  job.setJobName("shangpin");
		  job.setJarByClass(shangpin.class);
		  job.setMapperClass(doMapper.class);
		  job.setReducerClass(doReducer.class);
		  job.setOutputKeyClass(Text.class);
		  job.setOutputValueClass(IntWritable.class);
	      Path in=new Path("hdfs://localhost:9000/shiyan/in/shangpin11.txt");
		  Path out=new Path("hdfs://localhost:9000/shiyan/out");
		  FileInputFormat.addInputPath(job, in);
		  FileOutputFormat.setOutputPath(job, out);
		  boolean flag = job.waitForCompletion(true);
		  System.out.println(flag);
		  System.exit(flag? 0 : 1);
		 }
	}

②MapReduce实现降序排列

package shiyan;
import java.io.IOException;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
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.Mapper.Context;
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 org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;
public class paixu {
	  public static class Map extends Mapper<Object , Text , IntWritable,Text >{
	    	private static Text goods=new Text();
	    	private static IntWritable num=new IntWritable();
	    	public void map(Object key,Text value,Context context)throws IOException,InterruptedException{
	    		String line=value.toString();
	    		String arr[]=line.split("\t");
	    		num.set(Integer.parseInt(arr[1]));
	    		goods.set(arr[0]);
	    		context.write(num, goods);
	    	}
	    }
	    public static class Reduce extends Reducer< IntWritable, Text, IntWritable, Text>
	  //input is temperature (IntWritable) and data (Text)
	  {
	  	//private static IntWritable result= new IntWritable();
	  	
	  	public void reduce(IntWritable key,Iterable<Text> values,Context context) 
	  			throws IOException, InterruptedException{
	  		//reduce端接收到<key,value-list>之后，
	  		//将输入的key直接复制给输出的key,用for循环遍历value-list并将里面的元素设置为输出的value，
	  		//然后将<key,value>逐一输出，根据value-list中元素的个数决定输出的次数。
	  		
	  		for(Text val:values){
	  			System.out.println("-------"+val);
	  			context.write(key,val);  //output data of the same temperature
	  			}
	  		}
	  	}
	  //使Sort阶段的Key降序排列的比较器
		  public static class IntWritableDecreasingComparator extends
			IntWritable.Comparator {
		           public int compare(byte[] b1, int s1, int l1, byte[] b2, int s2, int l2) {
			       return -super.compare(b1, s1, l1, b2, s2, l2);
		}
		}
		    
		        public static void main(String[] args) throws IOException,ClassNotFoundException,InterruptedException{
		            Configuration conf=new Configuration();
		             Job job =new Job(conf,"sort");
		             job.setJarByClass(paixu.class);
		             job.setMapperClass(Map.class);
		             job.setReducerClass(Reduce.class);
		             job.setOutputKeyClass(IntWritable.class);
		             job.setOutputValueClass(Text.class);
		             job.setInputFormatClass(TextInputFormat.class);
		             job.setOutputFormatClass(TextOutputFormat.class);
		             Path in=new Path("hdfs://localhost:9000/shiyan/out/part-r-00000");
		   		     Path out=new Path("hdfs://localhost:9000/shiyan/out2");
		             FileInputFormat.addInputPath(job,in);
		             FileOutputFormat.setOutputPath(job,out);
		             job.setSortComparatorClass(IntWritableDecreasingComparator.class);
		             System.exit(job.waitForCompletion(true)?0:1);

		       }
}