hadoop2.7.3+win10+idea环境下：MapReduce实现二度好友推荐算法

最新推荐文章于 2022-04-22 10:21:26 发布
最新推荐文章于 2022-04-22 10:21:26 发布
阅读量1.4k 收藏 11
点赞数 3
分类专栏： 云计算 文章标签： MapReduce 二度好友推荐
版权声明：本文为博主原创文章，遵循CC BY-NC-SA 4.0版权协议，禁止商用，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39564555/article/details/102690722
版权

CSDN源码下载：MapReduce实现二度好友推荐算法

一、Hadoop安装

  可参考文章：Win10下安装Hadoop2.7.3

二、问题描述

  好友推荐功能简单的说是这样一个需求：
  预测某两个人是否认识，并推荐为好友，并且某两个非好友的用户，他们的共同好友越多，那么他们越可能认识。
alt
   以QQ好友举例，顶点A、B、C到G分别是QQ用户，两顶点之间的边表示两顶点代表的用户之间相互关注。比如，B、G有共同好友A，应该推荐B、G认识，而D、F有两个共同好友C、E，那么更加应该推荐D、F认识。

三、思路分析
  1. 推荐者与被推荐者一定有一个或多个相同的好友
  2. 全局去寻找好友列表中两两关系
  3. 去除直接好友
  4. 统计两两关系出现次数
四、步骤讲解
  1. 导入数据
    alt
  2. 第一次Map，映射<(好友，好友), 0/1>键值对
    在这里插入图片描述
  3. 第一次Reduce，统计共同好友个数，去掉直接好友
    在这里插入图片描述
  4. 第一次进行job运算
    在这里插入图片描述
  5. 第二次Map，映射<(用户，hot值)，好友：hot值>
      由于在MapReduce中，key值自动能够排序，而value值往往不可以。所以为了根据每一个用户与其他用户的共同好友个数从高到低排序，不仅需要将用户名作为key，还需要将该用户与推介用户的共同好友个数作为key的一部分。
  6. 第二次Reduce，对结果进行排序拼接处理
    hello:2,hadoop:2,mr:1,world:1,
  7. 第二次Job运算，得到结果
    在这里插入图片描述
五、代码
  1. 输入数据friends_demo.txt（用户 直接好友）
tom	cat,hadoop,hello
hello	mr,tom,world,hive
cat	tom,hiv
hive	cat,hadoop,world,hello,mr
mr	hive,hello
hadoop	tom,hive,world
world	hadoop,hive,hello
  1. 类型定义
      由于A1：A2与A2：A1是同一个潜在好友列表，为了能够方便的统计，故统一按照字典排序，输出A1:A2格式。
package friends_7_demo2;

import org.apache.hadoop.io.Text;

public class FoF extends Text {

    public  FoF() {
        super();
    }

    public FoF(String friend01,String friend02) {
        set(getof(friend01,friend02));
    }

    private String getof(String friend01, String friend02) {

        int c = friend01.compareTo(friend02);
        if (c>0) {
            return friend02+"\t"+friend01;
        }
        return friend01+"\t"+friend02;
    }
}
  1. 定义Map01
package friends_7_demo2;

import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.util.StringUtils;

import java.io.IOException;

/**
 * map函数，统计好友之间的FOF关系列表（FOF关系：潜在好友关系）
 */
public class Map01 extends Mapper<LongWritable, Text, FoF, IntWritable> {

    @Override
    protected void map(LongWritable key, Text value,Context context)
            throws IOException, InterruptedException {
        String lines = value.toString(); // 用户所有的好友列表
        String userAndFriends[] = StringUtils.split(lines, '\t');
        String user = userAndFriends[0];
        String[] friends;
        if(userAndFriends.length == 1){
            return;
        }else if (userAndFriends[1].length() == 1){
            friends = new String[]{userAndFriends[1]};
        }else {
            friends= userAndFriends[1].split(",");
        }

        //好友之间的FOF关系矩阵
        for (int i = 0; i < friends.length; i++) {
            String friend = friends[i];
            context.write(new FoF(user,friend),new IntWritable(0));//输出好友列表，值为0。方便在reduce阶段去除已经是好友的FOF关系。

            for (int j = i+1; j < friends.length; j++) {
                String friend2 = friends[j];
                context.write(new FoF(friend, friend2), new IntWritable(1));//输出好友之间的FOF关系列表，值为1，方便reduce阶段累加
            }
        }
    }
}
  1. 定义Reduce01
package friends_7_demo2;

import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.util.StringUtils;

import java.io.IOException;

/**
 * reduce函数，统计全部的FOF关系列表的系数
 */
public class Reduce01 extends Reducer<FoF, IntWritable, Text, NullWritable> {

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

        int sum = 0;
        boolean f = true;
        for(IntWritable i : values){
            if (0==i.get()) { //已经是好友关系
                f=false;
                break;
            }
            sum+=i.get();	//累计，统计FOF的系数
        }
        System.out.println("******************Reduce01*******************");
        if (f) {
            String msg = StringUtils.split(key.toString(), '\t')[0]+" "+StringUtils.split(key.toString(), '\t')[1]+" "+sum;
            System.out.println(msg);
            context.write(new Text(msg), NullWritable.get()); //输出key为潜在好友对，值为出现的次数
        }
    }
}
  1. 定义JobFriends类，实现jobOne
package friends_7_demo2;

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.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

public class JobFriends {

    public static void main(String[] args) {
        Boolean flag = jobOne();
        if (flag) {
            jobTwo();
        }
    }

    // MapReduce01
    private static Boolean jobOne() {
        Configuration config = new Configuration();

        boolean flag = false;
        try{
            Job job = Job.getInstance(config);

            job.setJarByClass(JobFriends.class);
            job.setJobName("fof one job");

            job.setMapperClass(Map01.class);
            job.setReducerClass(Reduce01.class);

            job.setOutputKeyClass(FoF.class);
            job.setOutputValueClass(IntWritable.class);

            Path input = new Path("……\\input\\friends_7.txt");
            FileInputFormat.addInputPath(job, input);

            Path output = new Path("……\\output\\friends_7\\f1");
            //如果文件存在,,删除文件,方便后续调试代码
            if (output.getFileSystem(config).exists(output)) {
                output.getFileSystem(config).delete(output,true);
            }

            FileOutputFormat.setOutputPath(job, output);

            flag = job.waitForCompletion(true);
            if (flag) {
                System.out.println("job1 success...");
            }
        } catch(Exception e){
            e.printStackTrace();
        }

        return flag;
    }
}

  输出结果：

cat hadoop 2
cat hello 2
cat mr 1
cat world 1
hadoop hello 3
hadoop mr 1
hive tom 3
mr tom 1
mr world 2
tom world 2
  1. 好友推荐计算，类型定义
      由于在MapReduce中，key值自动能够排序，而value值往往不可以。所以为了根据每一个用户与其他用户的共同好友个数从高到低排序，不仅需要将用户名作为key，还需要将该用户与推介用户的共同好友个数作为key的一部分，所以需要重新定义一个类。
package friends_7_demo2;

import org.apache.hadoop.io.WritableComparable;

import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;

/**
 *  FriendSort作为key和value，FriendSort：用户名+FOF系数
 *  用户名一致，FOF系数从大到小排序。 很容易得到一个用户的好友推介的列表
 */
public class FriendSort implements WritableComparable<FriendSort> {

    private String friend;
    private int hot;

    public String getFriend() {
        return friend;
    }

    public void setFriend(String friend) {
        this.friend = friend;
    }

    public int getHot() {
        return hot;
    }

    public void setHot(int hot) {
        this.hot = hot;
    }


    public FriendSort() {
        super();
    }

    public FriendSort(String friend, int hot) {
        this.friend = friend;
        this.hot = hot;
    }
    //反序列化
    @Override
    public void readFields(DataInput in) throws IOException {
        this.friend=in.readUTF();
        this.hot=in.readInt();
    }
    //序列化
    @Override
    public void write(DataOutput out) throws IOException {
        out.writeUTF(friend);
        out.writeInt(hot);
    }
    //判断是否为同一用户,并通过hot值排序
    @Override
    public int compareTo(FriendSort newFriend) {
        System.out.println(friend+"-------"+newFriend.getFriend());

        int c = friend.compareTo(newFriend.getFriend());
        int e = -Integer.compare(hot, newFriend.getHot());
        if (c==0) {
            return e;
        }
        return c;
    }
}
  1. 定义Map02
package friends_7_demo2;

import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.util.StringUtils;

import java.io.IOException;

/**
 * map函数，每个用户的推介好友列表，并按推介指数从大到小排序
 */
public class Map02 extends Mapper<LongWritable, Text, FriendSort, Text > {

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

        String lines = value.toString();
        String friend01 = StringUtils.split(lines,' ')[0];
        String friend02 = StringUtils.split(lines,' ')[1];	//推介的好友
        int hot = Integer.parseInt(StringUtils.split(lines,' ')[2]);	// 该推介好友的推介系数

        System.out.println("**************Map02******************");
        System.out.println(friend01+"  "+friend02+"  "+hot);
        System.out.println(friend02+"  "+friend01+"  "+hot);
        context.write(new FriendSort(friend01,hot),new Text(friend02+":"+hot));	 //mapkey输出用户和好友推介系数
        context.write(new FriendSort(friend02,hot),new Text(friend01+":"+hot));	//好友关系是相互的

    }
}
  1. 定义sort类
package friends_7_demo2;

import org.apache.hadoop.io.WritableComparable;
import org.apache.hadoop.io.WritableComparator;

/**
 * 将key根据用户名和次数排序
 */
public class NumSort extends WritableComparator {
    public NumSort(){
        super(FriendSort.class,true);
    }

    public int compare(WritableComparable a, WritableComparable b) {
        FriendSort o1 =(FriendSort) a;
        FriendSort o2 =(FriendSort) b;

        int r =o1.getFriend().compareTo(o2.getFriend());
        if(r==0){
            return -Integer.compare(o1.getHot(), o2.getHot());
        }
        return r;
    }
}
  1. 定义group类
package friends_7_demo2;

import org.apache.hadoop.io.WritableComparable;
import org.apache.hadoop.io.WritableComparator;

/**
 *  将同一个用户作为一个Group，同时被reduce处理
 */
public class UserGroup extends WritableComparator {
    public UserGroup(){
        super(FriendSort.class,true);
    }

    public int compare(WritableComparable a, WritableComparable b) {
        FriendSort o1 =(FriendSort) a;
        FriendSort o2 =(FriendSort) b;
        return o1.getFriend().compareTo(o2.getFriend());
    }
}
  1. 定义Reduce02
package friends_7_demo2;

import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;

import java.io.IOException;

/**
 * reduce函数
 */
public class Reduce02 extends Reducer<FriendSort, Text, Text, Text> {

    @Override
    protected void reduce(FriendSort user, Iterable<Text> friends, Context context)
            throws IOException, InterruptedException {

        String msg = "";
        //拼接推荐好友
        for(Text friend :friends){
            System.out.println("***************Reduce02*****************");
            msg += friend.toString()+",";
            System.out.println(msg);
        }
        context.write(new Text(user.getFriend()), new Text(msg));
    }
}
  1. 定义 JobTwo 类
package friends_7_demo2;

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.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

public class JobFriends {

    public static void main(String[] args) {
        Boolean flag = jobOne();
        if (flag) {
            jobTwo();
        }
    }

    // MapReduce01
    private static Boolean jobOne() {
        Configuration config = new Configuration();

        boolean flag = false;
        try{
            Job job = Job.getInstance(config);

            job.setJarByClass(JobFriends.class);
            job.setJobName("fof one job");

            job.setMapperClass(Map01.class);
            job.setReducerClass(Reduce01.class);

            job.setOutputKeyClass(FoF.class);
            job.setOutputValueClass(IntWritable.class);

            Path input = new Path("……\\input\\friends_7.txt");
            FileInputFormat.addInputPath(job, input);

            Path output = new Path("……\\output\\friends_7\\f1");
            //如果文件存在,,删除文件,方便后续调试代码
            if (output.getFileSystem(config).exists(output)) {
                output.getFileSystem(config).delete(output,true);
            }

            FileOutputFormat.setOutputPath(job, output);

            flag = job.waitForCompletion(true);
            if (flag) {
                System.out.println("job1 success...");
            }
        } catch(Exception e){
            e.printStackTrace();
        }

        return flag;
    }

    private static Boolean jobTwo() {
        Configuration config =new Configuration();

        Boolean flag = false;
        try {
            Job job = Job.getInstance(config);

            job.setJarByClass(JobFriends.class);
            job.setJobName("fof two job");

            job.setMapperClass(Map02.class);
            job.setReducerClass(Reduce02.class);
            job.setSortComparatorClass(NumSort.class); //sort类
            job.setGroupingComparatorClass(UserGroup.class); //group类
            job.setMapOutputKeyClass(FriendSort.class);
            job.setMapOutputValueClass(Text.class);

            Path input = new Path("……\\output\\friends_7\\f1");
            FileInputFormat.addInputPath(job, input);

            Path output = new Path("……\\output\\friends_7\\f2");
            //如果文件存在,,删除文件,方便后续调试代码
            if (output.getFileSystem(config).exists(output)) {
                output.getFileSystem(config).delete(output,true);
            }

            FileOutputFormat.setOutputPath(job, output);

            flag = job.waitForCompletion(true);
            if (flag) {
                System.out.println("job2 success...");
            }

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

  输出最终结果：

cat	hello:2,hadoop:2,mr:1,world:1,
hadoop	hello:3,cat:2,mr:1,
hello	hadoop:3,cat:2,
hive	tom:3,
mr	world:2,hadoop:1,tom:1,cat:1,
tom	hive:3,world:2,mr:1,
world	mr:2,tom:2,cat:1,

参考文章：【1】MapReduce实例——好友推荐 - sinat_34045444的博客
     【2】hadoop学习笔记–8.MapReduce案例一：简单好友推介实现 - 云计算技术频道 - 红黑联盟
     【3】mapreduce实现——腾讯大数据QQ共同好友推荐系统_码神岛
     【4】MR — 好友推荐算法 - ImCoder博客’s 文章
     【5】Hadoop实例：二度人脉与好友推荐 - 程序园
     【6】推荐算法之好友推荐 - - ITeye博客
     【7】Hadoop实例：二度人脉与好友推荐 - intergret的个人空间 - OSCHINA
     【8】MapReduce 社交好友推荐算法 - 夏延 - 博客园
     【9】MapReduce模拟小型推荐系统 - ThisisWilli - CSDN博客
     【10】MapReduce模拟实现好友推荐系统 - 张不帅 - CSDN博客

渣渣的夏天
关注
  • 3
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
基于hadoop的好友推荐系统
04-07
基于hadoop的好友推荐系统 使用 MapReduce 内含系统说明文件
推荐系统从入门到入门（3）——基于MapReuduce与Spark的分布式推荐系统构建
转载请标明出处，完整项目/代码详见github：https://github.com/yiru1225
02-23 1702
本系列博客总结了不同框架（无框架、Tensorflow、Hadoop、Spark）、不同算法（各种协同过滤、基于内容推荐、深度学习推荐）、不同界面（APP、Web、Uni-app）的推荐系统，搞懂推荐系统不是梦！！！
MapReduce-recomend:二度人脉好友推荐mapreduce算法
05-16
MapReduce-recomend 二度人脉好友推荐运用非常广泛，比如在一些主流的社交产品中就有可能认识的人这样的功能，一般来说可能认识的人是通过二度人脉搜索得到的，在传统的关系型数据库中，可以通过图的广度优先遍历算法实现，而且深度限定为2，然而在海量的数据中，这样的遍历成本太大，所以有必要利用MapReduce编程模型来并行化，本篇文章是二度好友推荐的mapreduce简单实现，难免会有不足和缺陷，希望大家能够指出，共同进步。 假如A和B是好友关系，B和C是好友关系，然而C和A不是好友关系，那么A和C是二度好友关系，他们可以通过B认识，B是中间人。我们定义一个符号“>”来代表follow，上面的例子可以这样表示 A>B B>C 在社交网络任何一个活跃的用户U都存在对应的两个集合，一个是粉丝集合，一个是关注集合，以用户U作为中间联系的2度人脉对，是粉丝集合和关注集合的笛卡尔积。 于是在M
MapReduce应用案例6：二度好友发现
机器熊的技术大杂烩
04-06 1089
1.应用场景 二度好友发现在社交网络中大量使用，QQ、微博、微信、社交网站等经常会推荐添加好友，其依据就是用户之间的好友关系。 几个概念： 一度好友是你的好友 二度好友是好友的好友，二度好友发现是社交网络关系发现中的重要问题。 从数据库设计的角度出发，即所谓的第三范式，尽量避免冗余，好友关系的表结构一般被设计为“用户-好友”，且一般用id来描述关系。如 user friend A ...
Hadoop实例：二度人脉与好友推荐
逐梦科学
05-10 1468
Hadoop实例：二度人脉与好友推荐 ［来源］ 达内    ［编辑］ 达内   ［时间］2013-01-07 在新浪微博、人人网等社交网站上，为了使用户在网络上认识更多的朋友，社交网站往往提供类似“你可能感兴趣的人”、“间接关注推荐”等好友推荐的功能。一直很好奇这个功能是怎么实现的。 在新浪微博、人人网等社交网站上，为了使用户在网络上认识更多的朋友，社交网站往往提
大数据---17.MapReduce实现共同好友（好友关系图实现）
u014579001的博客
04-22 2068
MapReduce实现共同好友（好友关系图实现—倚天屠龙记关系）
MapReduce实现二度好友推荐算法
10-22
hadoop之MapReduce实现二度好友算法，包含输入数据demo，完整运算代码，在windows10下成功运行，输出结果为cat hello:2,hadoop:2,mr:1,world:1类似。
hadoop 2.7.3 + Windows安装替换bin目录文件
06-26
hadoop 2.7.3 + Windows安装替换bin目录文件
Hadoop2.7.3+HBase1.2.5+ZooKeeper3.4.6搭建分布式集群环境详解
11-10
本文档详细介绍了如何用ZooKeeper和Hadoop、HBase搭建分布式大数据分析平台。
mapreduce编程 好友推荐
11-01
在qq 微博等众多社交平台中，用户a有n位好友，在这n位好友里面的好友中有m位不是a的直接好友（例如用户b）。但是通过朋友的朋友，a与b之间有多位共同好友，换而言之，a是b可能认识的人。
大数据学习（八）：mapreduce编程案例-求两人之间的共同好友
01-20
现有如下数据: A:B,C,D,F,E,O B:A,C,E,K C:F,A,D,I D:A,E,F,L E:B,C,D,M,L F:A,B,C,D,E,O,M G:A,C,D,E,F H:A,C,D,E,O I:A,O J:B,O K:A,C,D L:D,E,F M:E,F,G O:A,H,I,J 求哪些人两两之间有共同好友，及共同好友有哪些人？ 思路: 第一步:只求哪些人两两之间有某个共同好友 A:B,C,D,F,E,O for(好友列表){ context.write(“好友”,“用户”)； } A-B C A-B E A-C F … package com.bigdata.map
hadoop2.7.3 for win10 64位 bin目录
02-19
在Windows下面使用Hadoop Java API进行开发的时候需要编译Windows版本的Hadoop，然后把下载的Hadoop/bin目录替换掉。这个资源是Windows10 64位系统下编译的hadoop 2.7.3的bin目录。下载后即可替换使用。
Hadoop2.7.3+HBase1.2.5+ZooKeeper3.4.6 搭建分布式集群环境详解
11-10
Hadoop2.7.3+HBase1.2.5+ZooKeeper3.4.6 搭建分布式集群环境详解。 详细介绍了如何搭建分布式集群环境。
Win10下安装Hadoop2.7.3
渣渣的夏天
10-22 2613
windows10下安装配置 hadoop2.7.3，主要包括软件安装、配置步骤、运行。
CentOS 7.6 下利用 Hadoop2.6.0 运行 MapReduce 案例 WordCount
渣渣的夏天
11-04 2453
本文主要讲解在 CentOS 7 下如何利用 Hadoop 运行 MapReduce 案例——wordcount，包含Hadoop启动、创建测试文件、运行程序、查看结果、自定义 WordCount 的代码再编译运行。
CentOS 7.6 安装 Hadoop2.6.0
渣渣的夏天
11-04 2168
本文主要讲解如何在 CentOS 7 上安装 Hadoop2.6.0 ，包含Hadoop简介、安装环境、软件下载、文件配置和 Hadoop 简单运行测试。
win10 + hadoop2.7.3 + idea 运行第一个MapReduce项目：WordCount
渣渣的夏天
10-23 1453
win10 + hadoop2.7.3 + idea 运行第一个MapReduce项目：WordCount，主要详细讲解如何利用 idea 新建 maven 项目，导入必要依赖包以及运行 wordcount 的demo演示。
windows10下安装hadoop2.7.3
最新发布
03-16
1. 下载Hadoop2.7.3压缩包，解压到指定目录下。 2. 配置环境变量，将Hadoop的bin目录添加到系统的PATH环境变量中。 3. 修改Hadoop的配置文件，主要包括core-site.xml、hdfs-site.xml、mapred-site.xml和yarn-site....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值