MapReduce设计模式之过滤模式

最新推荐文章于 2022-09-01 16:01:57 发布
最新推荐文章于 2022-09-01 16:01:57 发布
阅读量472 收藏 2
点赞数 1
分类专栏： 大数据(Spark/Hive/Map Reduce) 文章标签： 大数据 mapreduce
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012734723/article/details/107467742
版权

过滤模式

过滤(正则过滤和随机抽样）

应用场景

可以从一个大的数据集中筛选出具有某些特征的小的数据集。

代码实现

在Mapper阶段，用正则表达式对值进行过滤。在Ruducer阶段，生成double类型的随机数，判断是否小于给定的数进行模拟简单的随机取样。

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileUtil;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.NullWritable;
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.util.Random;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @Author bluesnail95
 * @Date 2019/7/20 7:46
 * @Description
 */
public class GrepMain {

    public static class GrepMapper extends Mapper<Object, Text, NullWritable,Text> {
        private String matchGrep = null;

        public void map(Object key,Text value,Context context) {
            matchGrep = context.getConfiguration().get("matchGrep");
            Pattern pattern = Pattern.compile(matchGrep);
            Matcher matcher = pattern.matcher(value.toString());
            if(matcher.matches()) {
                try {
                    context.write(NullWritable.get(), value);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static class GrepReducer extends Reducer<NullWritable,Text,NullWritable,Text> {
        private Random random = new Random();
        private Double percentage;

        public void reduce(NullWritable key,Iterable<Text> values,Context context) {
            String strPercentage = context.getConfiguration().get("filter_percentage");
            percentage = Double.valueOf(strPercentage);

            for(Text value:values) {
                double rand = random.nextDouble();
                if(rand < percentage) {
                    try {
                        context.write(NullWritable.get(), value);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

    public static void main(String[] args) {
        try {
            Configuration conf = new Configuration();
            //设置正则表达式：匹配全是字母的字符串
            conf.set("matchGrep","^[a-zA-Z]+$");
            conf.setDouble("filter_percentage",0.5);
            Job job = Job.getInstance(conf, "Grep");
            //与自己定义的类名保持一致
            job.setJarByClass(GrepMain.class);
            //与自己定义的Mapper类和Reducer类保持一致
            job.setMapperClass(GrepMapper.class);
            job.setCombinerClass(GrepReducer.class);
            job.setReducerClass(GrepReducer.class);
            //设置的输出键和输出值和mapper定义的需要保持一致。
            job.setOutputKeyClass(NullWritable.class);
            job.setOutputValueClass(Text.class);
            //输入输出路径
            FileInputFormat.addInputPath(job, new Path(args[0]));
            FileUtil.fullyDelete(new File(args[1]));
            FileOutputFormat.setOutputPath(job, new Path(args[1]));
            System.exit(job.waitForCompletion(true)?0:1);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

入参出参

过滤入参出参

运行结果

过滤输出结果

布隆过滤

应用场景

判断某个记录是否存在于某个预判的集合中，存在失误。

代码实现

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileUtil;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.util.bloom.BloomFilter;
import org.apache.hadoop.util.bloom.Key;
import org.apache.hadoop.util.hash.Hash;

import java.io.File;
import java.net.URI;

/**
 * @Author bluesnail95
 * @Date 2019/7/20 15:35
 * @Description
 */
public class BloomFilterMain {

    public static class BloomFilterMapper extends Mapper<Object, Text,Text, NullWritable> {
        int vectorSize = BloomFilterUtil.getOptimalBloomFilterSize(10,0.1f);
        int nbHash = BloomFilterUtil.getOptimalK(10,vectorSize);
        BloomFilter bloomFilter = new BloomFilter(vectorSize, nbHash, Hash.MURMUR_HASH);

        //建立预定义集合
        protected void setup(Context context) {
            try {
                bloomFilter.add(new Key("BeiJing".getBytes()));
                bloomFilter.add(new Key("ShangHai".getBytes()));
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        public void map(Object key,Text value,Context context) {
            String word = value.toString();
            //判断值是否在预判的集合中
            if(bloomFilter.membershipTest(new Key(word.getBytes()))) {
                try {
                    context.write(value,NullWritable.get());
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) {
        try {
            Configuration conf = new Configuration();
            Job job = Job.getInstance(conf, "Grep");
            //与自己定义的类名保持一致
            job.setJarByClass(BloomFilterMain.class);
            //与自己定义的Mapper类和Reducer类保持一致
            job.setMapperClass(BloomFilterMapper.class);
            //设置的输出键和输出值和mapper定义的需要保持一致。
            job.setOutputKeyClass(Text.class);
            job.setOutputValueClass(NullWritable.class);
            //输入输出路径
            FileInputFormat.addInputPath(job, new Path(args[0]));
            FileUtil.fullyDelete(new File(args[1]));
            FileOutputFormat.setOutputPath(job, new Path(args[1]));
            System.exit(job.waitForCompletion(true)?0:1);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

出参入参

clipboard.png

运行结果

clipboard.png

top K问题

应用场景

查找出最热门的K条记录等等。

代码实现

/**
 * @Author bluesnail95
 * @Date 2019/7/20 17:09
 * @Description
 */
public class Top10Data {

    private String userId;

    private Integer reputation;

    public String getUserId() {
        return userId;
    }

    public void setUserId(String userId) {
        this.userId = userId;
    }

    public Integer getReputation() {
        return reputation;
    }

    public void setReputation(Integer reputation) {
        this.reputation = reputation;
    }
}

/**
 * @Author bluesnail95
 * @Date 2019/7/20 17:09
 * @Description
 */
public class Top10Main {

    public static class Top10Mapper extends Mapper<Object, Text, NullWritable,Text> {

        private TreeMap<Integer,Text> sortedMap = new TreeMap<Integer,Text>();

        public void map(Object key,Text value,Context context) {
            ObjectMapper objectMapper = new ObjectMapper();
            try {
                Top10Data top10Data = objectMapper.readValue(value.toString(),Top10Data.class);
                Integer reputation = top10Data.getReputation();
                String userId = top10Data.getUserId();
                sortedMap.put(reputation,new Text(value));
                if(sortedMap.size() > 10) {
                    sortedMap.remove(sortedMap.firstKey());
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        protected void cleanup(Context context) {
            for(Text t:sortedMap.values()) {
                try {
                    context.write(NullWritable.get(),t);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static class Top10Reducer extends Reducer<NullWritable,Text,NullWritable,Text> {

        private TreeMap<Integer,Text> sortedMap = new TreeMap<Integer,Text>();

        public void reduce(NullWritable key,Iterable<Text> values,Context context) {
            for(Text value:values) {
                System.out.println(value.toString());
                ObjectMapper objectMapper = new ObjectMapper();
                try {
                    Top10Data top10Data = objectMapper.readValue(value.toString(), Top10Data.class);
                    int reputation = top10Data.getReputation();
                    String userId = top10Data.getUserId();
                    sortedMap.put(reputation,new Text(value));

                    if(sortedMap.size() > 10) {
                        sortedMap.remove(sortedMap.firstKey());
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            for (Text t:sortedMap.values()) {
                try {
                    context.write(NullWritable.get(), t);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) {
        try {
            Configuration conf = new Configuration();
            Job job = Job.getInstance(conf, "Top 10");
            //与自己定义的类名保持一致
            job.setJarByClass(Top10Main.class);
            //与自己定义的Mapper类和Reducer类保持一致
            job.setMapperClass(Top10Mapper.class);
            job.setReducerClass(Top10Reducer.class);
            //设置的输出键和输出值和mapper定义的需要保持一致。
            job.setOutputKeyClass(NullWritable.class);
            job.setOutputValueClass(Text.class);
            //输入输出路径
            FileInputFormat.addInputPath(job, new Path(args[0]));
            FileUtil.fullyDelete(new File(args[1]));
            FileOutputFormat.setOutputPath(job, new Path(args[1]));
            System.exit(job.waitForCompletion(true)?0:1);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

注意输出的时候是new Text(value)重新建立了一个对象。

只找出K条记录，不进行全排序。每次在TreeMap集合中加入新的元素后，判断Map的大小是否大于K，如果是就移除第一个元素。

入参出参

clipboard.png

运行结果

clipboard.png

去重

应用场景

集合中存在重复的数据需要剔除，以简化统计统计等。

代码实现

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileUtil;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.NullWritable;
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;

/**
 * @Author bluesnail95
 * @Date 2019/7/20 17:09
 * @Description
 */
public class DistinctMain {

    public static class DistinctMapper extends Mapper<Object, Text,Text, NullWritable> {

        public void map(Object key,Text value,Context context) {
            try {
                context.write(value, NullWritable.get());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public static class DistinctReducer extends Reducer<Text, NullWritable,Text, NullWritable> {

        public void reduce(Text key,Iterable<NullWritable> values,Context context) {
            try {
                context.write(key,NullWritable.get());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        try {
            Configuration conf = new Configuration();
            Job job = Job.getInstance(conf, "Distinct");
            //与自己定义的类名保持一致
            job.setJarByClass(DistinctMapper.class);
            //与自己定义的Mapper类和Reducer类保持一致
            job.setMapperClass(DistinctMapper.class);
            job.setReducerClass(DistinctReducer.class);
            //设置的输出键和输出值和mapper定义的需要保持一致。
            job.setOutputKeyClass(Text.class);
            job.setOutputValueClass(NullWritable.class);
            //输入输出路径
            FileInputFormat.addInputPath(job, new Path(args[0]));
            FileUtil.fullyDelete(new File(args[1]));
            FileOutputFormat.setOutputPath(job, new Path(args[1]));
            System.exit(job.waitForCompletion(true)?0:1);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

出参入参

clipboard.png

运行结果

clipboard.png

参考资料

《MapReduce设计模式》

bluesnail95
关注
专栏目录
mapreduce编程(一）：输入文件的过滤
苏格拉底的毒堇汁
01-18 3198
描述：dir/目录下存储了系统每一天的出现的cookie，各天的cookie分别存放在各自的dir/time目录下，如2012-12-21日的cookie存放在dir/2012-12-21目录下。    dir/2012-12-21下的各个文件存储的是出现的cookie，一个cookie的多次出现会记录多次（也就是有重复），dir/2012-12-21下的文件名为prefix-tag-suffix
MapReduce系列之过滤模式
twj0823的博客
11-26 984
过滤模式基本有四种：过滤，布隆过滤，Top 10 和去重 过滤：将不感兴趣的记录过滤掉并将需要的数据保留下来 类似用法：select * from table where 条件 示例：map{     if（条件true）    {        context.write();   } }   布隆过滤：与过滤类似 ，只是他使用了一个独特的评估函数来作用于每一条记录。 与普...
MapReduce之过滤模式
xuehuagongzi000的博客
11-15 660
job、context、setup()和cleanup()的使用 1、在main中job配置参数 job.getConfiguration().set("num","3"); 2、在setup()使用context取得参数值 public void setup(Context context){ number= Integer.parseInt(context.getConfi...
MapReduce的编程开发——过滤和保存
Comet_sgf的程序员之路
01-31 683
文章目录前言一、启动Hadoop二、环境搭配三、过滤与保存实验总结 前言 本文主要是学习MapReduce的学习笔记，对所学内容进行记录。 实验环境： 1.Linux Ubuntu 16.04 2.hadoop3.0.0 3.eclipse4.5.1 一、启动Hadoop 进入Hadoop启动目录cd /apps/hadoop/sbin 启动Hadoop./start-all.sh 输入‘jps’，启动后显示如下信息 二、环境搭配 打开eclipse->Window->Prefer
MapReduce之过滤（二）
zhangdy12307的博客
04-17 571
MapReduce之简单随机抽样 这篇博客和上一篇有点类似，模式描述和应用场景都和MapReduce之过滤（一）类似 简单随机抽样 从一个较大的数据集中以一定概率抓取一个数据集，其中每条记录均有相同的抽取概率 问题描述 一个较大的数据集中以一定概率抓取一个数据集 样例输入 与MapReduce之过滤（一）数据类似 样例输出 数据集随机生成，可能存在不同 map阶段任务 在map函数中，简单的生成一...
MapReduce 设计模式
03-19
MapReduce设计模式是对MapReduce编程范式的进一步深化，通过多种不同的算法和策略来解决数据处理中的常见问题。 本文档中提到了《MapReduce设计模式》这本书，由Donald Miner和Adam Shook所著。书籍的标题说明了其...
MapReduce设计模式介绍.ppt
09-15
MapReduce 设计模式知识点总结 MapReduce 设计模式是大数据处理的核心组件，负责将大规模数据处理和分析任务分解为可并行处理的任务。MapReduce 设计模式主要由两个阶段组成：Map 阶段和 Reduce 阶段。 Map 阶段 ...
MapReduce设计模式
06-28
在本段落中，我们集中讨论了与MapReduce设计模式相关的知识点。MapReduce是一种编程模型，用于处理和生成大数据集，常用于大规模数据处理。它的设计模式是MapReduce编程中实现高效数据处理的核心方法和策略。我们将...
通过mapReduce实现基于项目的协同过滤推荐
pardy原创
11-05 3593
通过mapReduce实现基于项目的协同过滤推荐 需求介绍 协同过滤推荐网上有很多种介绍，我这里主要介绍的是基于项目的协同过滤。基于项目的协同过滤推荐基于这样的假设：一个用户会喜欢他之前喜欢的项目相似的项目。因此，基于项目的协同过滤推荐关键在于计算物品之间的相似度。 数据介绍 我选用的数据集合如下： 1,101,5.0 1,102,3.0 1,103,2.5 2,101,2.0 2,1
MapReduce之过滤（一）
zhangdy12307的博客
04-17 1704
MapReduce之过滤 模式描述 过滤作为一个抽象模式为其他模式服务，过滤简单的对每一条记录进行评估，并基于某个条件作出判断，以确定当前的这条记录是否保留。 目的 过滤掉不感兴趣的记录并将需要的记录保留下来 适用场景 使用过滤的唯一必要条件就是数据可以被解析为“记录”，并通过特定的准则判断他们是否可以被保留 近距离观察数据 跟踪某个事件的线索 数据清洗 简单随机抽样 移除低分值数据 问题描述...
【Hive】MapReduce 如何实现 Hive SQL 的基本操作-过滤
每天更新大数据面经和技术
09-01 652
过滤
大数据处理-mapreduce 代码入门实例-多表连接、对单词排序、对数据过滤、统计单词数量并排序、分区统计等
weixin_43327597的博客
12-15 2724
多表连接 思路为，通过map阶段将数据按<key，value>进行map，key为id，则shuffle阶段会自动进行组合，但同时对两个表的内容进行标记，进行笛卡尔积时可以进行区分。 代码如下 package org.apache.hadoop.examples; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.fs.Path; import org.apache.hadoop.io.LongWr.
（hadoop学习－1）mapreduce实现数据过滤、聚合与排序
06-13 3888
利用mapreduce实现数据过滤、聚合与排序。文章翻译自http://blog.ditullio.fr，并提供源代码。
MapReduce 框架原理（三）
prefect_start的博客
11-30 1718
1、MapTask工作机制 Read阶段：MapTask通过InputFormat获得的RecordReader，从输入InputSplit中解析出一个个key/value。 Map阶段：该节点主要是将解析出的key/value交给用户编写map()函数处理，并产生一系列新的key/value。 Collect收集阶段：在用户编写map()函数中，当数据处理完成后，一般会调用OutputCollector.collect()输出结果。在该函数内部，它会将生成的key/value分区（调用Partitio
Hadoop学习笔记—12.MapReduce中的常见算法
weixin_34248487的博客
11-18 521
Hadoop学习笔记—12.MapReduce中的常见算法 一、MapReduce中有哪些常见算法 　　（1）经典之王：单词计数 　　　　这个是MapReduce的经典案例，经典的不能再经典了！ 　　（2）数据去重 　　　　"数据去重"主要是为了掌握和利用并行化思想来对数据进行有意义的筛选。统计大数据集上的数据种类个数、从网站日志中计算访问地等这些看似庞杂的任务都会涉及数据去重。...
Hadoop2.6.0 mapreduce 例子
Rocky
10-17 2557
Hadoop2.6.0 mapreduce 例子
设计模式之——策略(Strategy)模式
热门推荐
技匠而已
02-13 1万+
设计模式： 前辈们对代码开发经验的总结，是解决特定问题的一系列套路。它不是语法规定。而是一套用来提高代码可复用性、可维护性、可读性、稳健性、以及安全性的解决方案 设计模式的本质是面向对象设计原则的实际运用，是对类的封装性、继承性和多态性以及类的关联关系和组合关系的充分理解。 正确使用设计模式具有以下优点: 可以提高程序员的思维能力、编程能力和设计能力。 使程序设计更加标准化、代码编制更加I程化，使软件开发效率大大提高，从而缩短软件的开发周期。 使设计的代码可重用性高、可读性强、可靠性高、灵活性.
设计模式-过滤模式
不侠居
11-16 1014
设计模式-过滤模式定义结构图用途代码实现 定义 过滤器模式（Filter）也叫条件模式（Criteria），这种模式允许开发人员使用不同的标准来过滤一组对象，通过逻辑运算以解耦的方式把它们连接起来。当我们想要选择满足一个或多个条件的对象子集时，此设计模式非常有用。它属于结构模式。 结构图 用途 用于过滤数据，得到自己想要的数据 代码实现 需要过滤的实体类 在这里插入代码片 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值