大数据---17.MapReduce实现共同好友（好友关系图实现）

MapReduce实现共同好友（好友关系图实现—倚天屠龙记关系）

背景
如今大多数的社交网站都有提供的共同好友的服务，可以帮助与好友之间共享图片，消息，视频

博客的好友列表数据，冒号前是一个用户，冒号后是该用户的所有好友（数据中的好友关系是单向的）
求出哪些人两两之间有共同好友，及他俩的共同好友都有谁？

使用MapReduce对这个问题进行处理的时候可以通过两个MapReduce任务完成这个需求：

1、对原始数据进行反转解析，找出都有谁的好友里面有该用户；例如对于原始 A:B,C,D,F,E,O 数据，通过在map task中解析成 < B, A>< C, A>< D,A>< F,A>…的形式，这一系列的键值对表示所有代号为key值的用户，他的好友里面都有value值代表的用户。然后对这些键值对在reduce task中对key值相同的键值对（< A, B>< A, D>< A, F>…）进行拼接，拼接成< A B,D,F, …>的形式作为第一次MapReduce任务的输出。

上图为第一次MapReduce的输出，以其中的第一行数据（A F,D,O,I,H,B,K,G,C,）为例，这一行数据的含义是：F,D,O,I,H,B,K,G,C 这些用户的好友里面都有A。即分隔符后面的所有用户的好友里面都有分隔符前面的用户。

2、根据第一次MapReduce的输出结果，我们可以很容易的想到，只要把分隔符后面的用户两两任意组合，就可以得到这两个用户的一个共同好友。以第一行数据为例，拆分之后可以得到：< F-D , A>, < F-O , A>, < F-I , A> … < D-O , A>,< D-I , A> …然后我们再在reduce task中按照相同的key值对键值对进行拼接，就得到了整个数据集中任意两个用户之间的共同好友的列表。

输出格式：

A-B:C，E
(用户-用户：共同好友…)

需求分析
分为两个job
第一次输出结果，先求出A、B、C、….等是谁的好友
Job1：
Mapper:
keyin-valuein: （A:B,C,D,F,E,O）
map(): 将valuein拆分为若干好友，作为keyout写出
将keyin作为valueout
keyout-valueout: （友:用户）
（c:A）,(C:B),(C:E)

Reducer:
keyin-valuein : （友:用户）
（c:A）,(C:B),(C:E)
reduce():
keyout-valueout ：（友：用户，用户，用户，用户）

A I,K,C,B,G,F,H,O,D,
B A,F,J,E,
C A,E,B,H,F,G,K,
D G,C,K,A,L,F,E,H,
E G,M,L,H,A,F,B,D,
F L,M,D,C,G,A,
G M,
H O,
I O,C,
J O,
K B,
L D,E,
M E,F,
O A,H,I,J,F,

第二次输出结果，输出每两个人的共同好友

Job2：
Mapper:
keyin-valuein: （友：用户，用户，用户，用户）
map()： 使用keyin作为valueout
将valuein切分后，两两拼接，作为keyout
keyout-valueout: （用户-用户，友）
(A-B,C),(A-B,E)
(A-E,C), (A-G,C), (A-F,C), (A-K,C)
(B-E,C ),(B-G,C)

	--------------------
	(B-E,C)
	(E-B,G)
	
	B-E: C,G

1
2
3
4
5
A-B E C
A-C D F
A-D E F
A-E D B C
A-F O B C D E
A-G F E C D
A-H E C D O
A-I O
A-J O B
A-K D C
A-L F E D
A-M E F
B-C A
B-D A E
B-E C
B-F E A C
B-G C E A
B-H A E C
B-I A
B-K C A
B-L E
B-M E
B-O A
C-D A F
C-E D
C-F D A
C-G D F A
C-H D A
C-I A
C-K A D
C-L D F
C-M F
C-O I A
D-E L
D-F A E
D-G E A F
D-H A E
D-I A
D-K A
D-L E F
D-M F E
D-O A
E-F D M C B
E-G C D
E-H C D
E-J B
E-K C D
E-L D
F-G D C A E
F-H A D O E C
F-I O A
F-J B O
F-K D C A
F-L E D
F-M E
F-O A
G-H D C E A
G-I A
G-K D A C
G-L D F E
G-M E F
G-O A
H-I O A
H-J O
H-K A C D
H-L D E
H-M E
H-O A
I-J O
I-K A
I-O A
K-L D
K-O A
L-M E F

Reducer:
keyin-valuein: (A-B,C),(A-B,E)
reduce():
keyout-valueout ： (A-B:C,E)

由于上面的分析分析的是：英文字母; 比较麻烦：

二 . 通过倚天屠龙记人物关系来实现

1.原始数据：

2.代码实现：
package friends;

import org.apache.commons.io.FileUtils;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
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.File;
import java.io.IOException;

public class FriendsPublic {
//map
public static class MapTask extends Mapper<LongWritable, Text,Text, Text> {

    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        //张三:李四,王五,赵丽,张无忌,灭绝师太,杨逍  ====>   李四-张三  王五-张三   赵丽-张三  .....
        String[] splits = value.toString().split(":");
        String values = splits[0];
        //再去切分另外一个数据   取到key值
        String[] friends = splits[1].split(",");
        //循环遍历  取到每一好友
        for (String friend : friends) {
            context.write(new Text(friend),new Text(values));
        }
    }
}


//reduce
public static class ReduceTask extends Reducer<Text,Text,Text,Text> {
    @Override                 //B               (张三,李四,王五,赵丽.....)
    protected void reduce(Text key, Iterable<Text> values, Context context) throws IOException, InterruptedException {
        //李四-张三  李四-王五  李四-赵丽 =====> 李四  张三,王五,赵丽,.....
        //boolean
        boolean flag=true;
        //需要一个字符串容器
        StringBuffer sb = new StringBuffer();
        for (Text value : values) {
            if(flag){
                sb.append(value);
                flag=false;
            }else{
                sb.append(",").append(value);
            }
        }
        //跳出for循环
        context.write(key,new Text(sb.toString()));
    }
}

//main
public static void main(String[] args) throws Exception {
    //我们需要一盒hadoop的对象去提交这俩个内部类  Job    本地运行
    Configuration conf = new Configuration();
    Job job = Job.getInstance(conf);

    //提交那俩个内部类
    job.setMapperClass(FriendsPublic.MapTask.class);
    job.setReducerClass(FriendsPublic.ReduceTask.class);
    job.setJarByClass(FriendsPublic.class);

    //设置四个输出参数的类型
    job.setMapOutputKeyClass(Text.class);
    job.setMapOutputValueClass(Text.class);
    job.setOutputKeyClass(Text.class);
    job.setOutputValueClass(Text.class);

    //如果输出文件  存在 就删除
    String output="E:\\BigData\\output\\friends1";
    File file = new File(output);
    if(file.exists()){
        FileUtils.deleteDirectory(file);
    }

    //设置输入  输出路径
    FileInputFormat.addInputPath(job,new Path("e:/friend.txt"));
    FileOutputFormat.setOutputPath(job,new Path(output));

    //温馨提示
    boolean b = job.waitForCompletion(true);
    System.out.println(b?"成功进行计算！！！":"哥们,出BUG了,赶快去调一下！！！");
}

}

3.结果：

注意：有的产生的结果中文乱码：

1.在处理输入文件的时候；修改他的编码格式： utf-8