MapReduce -- 好友推荐

MapReduce实现好友推荐：

张三的好友有王五、小红、赵六; 同样王五、小红、赵六的共同好友是张三;

在王五和小红不认识的前提下，可以通过张三互相认识，给王五推荐的好友为小红，

给小红推荐的好友是王五，就是王五、小红、赵六互为推荐关系。

根据分析就是有相同好友的人物之间为推荐关系，但要排除本来两人就是好友的情况。

计算一个人的好友推荐关系，推荐关系值为1，然后计算所有人的好友推荐关系，最终将推荐关系值相加，计算出最值得推荐的几个好友。

简单的说就是两个非好友的人，存在共同好友的人数越多，说明这两个人越值得互相推荐。

数据：

王五    李四    小丽    小玲
小丽    王五    赵六
李四    王五    张三    赵六    小红
小玲    王五    张三    赵六
张三    小玲    李四    赵六
赵六    小丽    小玲    张三    李四    小红
小红    李四    赵六

实现代码：

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.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;

/**
 *  好友推荐：
 *  计算两个非好友的推荐值，就是两个非好友的共同好友数
 *
 * Created by Edward on 2016/7/12.
 */
public class RunJob {


    public static void main(String[] args){

        System.setProperty("HADOOP_USER_NAME", "root");

        Configuration conf = new Configuration();

        conf.set("fs.defaultFS", "hdfs://node1:8020");

        try {
            FileSystem fs = FileSystem.get(conf);

            Job job = Job.getInstance(conf);
            job.setJarByClass(RunJob.class);
            job.setMapperClass(MyMapper.class);
            job.setReducerClass(MyReducer.class);

            //需要指定 map out 的 key 和 value
            job.setOutputKeyClass(Text.class);
            job.setOutputValueClass(IntWritable.class);

            FileInputFormat.addInputPath(job, new Path("/test/friend/input"));

            Path path = new Path("/test/friend/output");
            if(fs.exists(path))//如果目录存在，则删除目录
            {
                fs.delete(path,true);
            }
            FileOutputFormat.setOutputPath(job, path);

            boolean b = job.waitForCompletion(true);
            if(b)
            {
                System.out.println("OK");
            }

        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    public static class MyMapper extends Mapper<LongWritable, Text, Text, IntWritable> {

        @Override
        protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {

            String[] str = value.toString().split("	");

            for(int i=1; i<str.length; i++) {
                //a 的好友是 b
                context.write(new Text(str[0] + ":" + str[i]), new IntWritable(0));
                //b 的好友是 a
                context.write(new Text(str[i] + ":" + str[0]), new IntWritable(0));
                for (int j = i + 1; j < str.length; j++) {
                    // A 的推荐好友是 B
                    context.write(new Text(str[i] + ":" + str[j]), new IntWritable(1));
                    // B 的推荐好友是 A
                    context.write(new Text(str[j] + ":" + str[i]), new IntWritable(1));
                }
            }
        }
    }

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

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

            int sum = 0;
            for(IntWritable i: values)
            {
                if(i.get() == 0) {//两个人已经是好朋友的，排除在外
                    sum = 0;
                    //break;
                    return;
                }
                sum += i.get();
            }
            context.write(key, new IntWritable(sum));
        }
    }
}

计算结果：

小丽:小玲       2
小丽:小红       1
小丽:张三       1
小丽:李四       2
小玲:小丽       2
小玲:小红       1
小玲:李四       3
小红:小丽       1
小红:小玲       1
小红:张三       2
小红:王五       1
张三:小丽       1
张三:小红       2
张三:王五       2
李四:小丽       2
李四:小玲       3
王五:小红       1
王五:张三       2
王五:赵六       3
赵六:王五       3

对结果进行简单的核对，比对图

小丽:小玲       2

小丽和小玲的共同好友数为2，分别为：王五,赵六