生活不易，且行且珍惜
过年从家回到工作的地方，突然感觉到自己身上的担子重了许多
父母的白头发越来越多，身体也大不如从前，看着他们，我还有什么理由不努力
Bloom过滤器简介
Bloom过滤器：Bloom Filter 是用一个 位数组(数组的每个元素不是1就是0) 来表示一个大的元素集合, 而且通过这个数组就可以判断某个元素是不是属于这个集合（具体的介绍内容可以自行到网上查询）
本文主要介绍的基于hadoop实现的一个简单的Bloom过滤器的实验过程：
本文的过程的思路是：
1.先构建相应的相应的Bloom的二进制文件
2.读取相应的二进制文件进行和输入的数据进行比较的过程
3.MapReduce的处理过程比较Bloom二进制文件产生的结果，如果一致的话就输出相应的结果到Map的输出文件中，由reduce过程处理
程序目录结构
Bloom二进制文件产生
BloomObject函数：
其中的main函数执行可以产生相应的二进制文件；
package Bloom;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FSDataOutputStream;
import org.apache.hadoop.fs.FileStatus;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.util.bloom.BloomFilter;
import org.apache.hadoop.util.bloom.Key;
import org.apache.hadoop.util.hash.Hash;
import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.net.URI;
/*
* bloom的过滤模式，例子是通过筛选出相应的选择地址在候选列表中的交集的集合
* bloom过滤必须要生成一个二进制数据，作为候选选择和处理的数据部分，定义候选的二进制数据结构：
* 哈希函数个数k、二进制数组大小m、字符串数据n 之间存在着相关性，对于给定的m、n,当k=ln(2)*m/n时出错的概率是最小的。本文后面引用网上的数据证明。
* */
public class BloomObject {
//对数据进行转换的函数
public static double k =2.0; //调节二进制数组的相应的参数变量
public static int getBloomSize(int numbersize ,float falsePosError){
int bloomsize = (int)(((-numbersize*(float)Math.log(falsePosError)/(float)Math.pow(Math.log(2),2)))*k);
return bloomsize;
}
//获取hash函数的个数
public static int getBloomHash(float numbersize,float longsize){
int hashsize = (int)(numbersize/longsize*Math.log(2)*k);
return hashsize;
}
/**
* 创建bloom过滤器的数据文件，生成相应的二进制数据文件
* @param fileinput 输入路径
* @param fileoutput 输出路径
* @param errorrate 错误率
* @param numberlong 输入字段长度
* @throws Exception
*/
public static void CreateBloomFile(String fileinput,String fileoutput,float errorrate,int numberlong) throws Exception{
Configuration configuration = new Configuration();
Path inputpath = new Path(fileinput);
Path outputpath = new Path(fileoutput);
FileSystem fileSystem = FileSystem.get(new URI(outputpath.toString()),configuration);
if(fileSystem.exists(outputpath)){
fileSystem.delete(outputpath);
}
//使用hadoop自带的bloom过滤函数
int BloomSize = getBloomSize(numberlong,errorrate);
int BloomHash = getBloomHash(BloomSize,numberlong);
System.out.println("二进制数据的位数-----"+BloomSize);
System.out.println("哈希函数的个数-----"+BloomHash);
BloomFilter bloomFilter = new BloomFilter(BloomSize,BloomHash, Hash.MURMUR_HASH);//定义相应的bloom函数
//把相应的结果存入到相应的输出文件中，正常情况下是hdfs的路径中，也可以是本地路径
//利用hadoop的filesystem的系统的命令把相应的数据存储到hdfs的目录中
FileSystem fileInput = FileSystem.get(new URI(inputpath.toString()),configuration);
String line =null;
for (FileStatus fileStatus:fileInput.listStatus(inputpath)){
//System.out.println(fileStatus.getPath());
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(fileInput.open(fileStatus.getPath())));
while((line=bufferedReader.readLine())!=null){
bloomFilter.add(new Key(line.getBytes("UTF-8"))); //存入到相应的bloom的API的变量中,bloom存放的是二进制的数据因此需要进行转换
System.out.println(line.getBytes("UTF-8"));
}
bufferedReader.close();
}
FSDataOutputStream fsDataOutputStream = fileInput.create(new Path(outputpath+"/bloomtestlog"));
bloomFilter.write(fsDataOutputStream);
//fsDataOutputStream.flush(); //写入到缓存中的数据
fsDataOutputStream.close();
}
public static void main(String[] args) throws Exception {
BloomObject.CreateBloomFile("BloomFile/","BloomFile/outputBloomFile",0.01f,2);
DataInputStream dataInputStream = new DataInputStream(new FileInputStream("BloomFile/outputBloomFile/bloomtestlog"));
BloomFilter filter = new BloomFilter();
filter.readFields(dataInputStream);
dataInputStream.close();
//System.out.println();
//hash函数过多导致即使是不同的数据多次的覆盖之后就会变成0
String str = "/wp-content/uploads/2013/08/ws4.png HTTP/1.1";
if(filter.membershipTest(new Key(str.getBytes("UTF-8")))){
System.out.println(str.getBytes("UTF-8"));
System.out.println("成功匹配二进制文件数据内容，Bloom二进制文件构造成功！");
}
}
}
输出的结果如图：
注意相应的输入文件在相应的目录下只能存在一份数据
结果图.png
BloomMapper函数：
package Bloom;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.util.bloom.BloomFilter;
import org.apache.hadoop.util.bloom.Key;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.StringTokenizer;
public class BloomMapper {
//bloom过滤器的生成方法，使用mapreduce的方法生成这个过程
//直接读取二进制文件进行存储的过程，设置setup函数获取bloom产生的热点二进制文件的数据进行处理
private static String inputpath;
public static String getInputpath() {
return inputpath;
}
public static void setInputpath(String inputpath) {
BloomMapper.inputpath = inputpath;
}
private static int num=0;
protected static class BloomMapping extends Mapper<Object,Text,Text,NullWritable>{
private BloomFilter bloomFilter = new BloomFilter();
//在执行setup函数的时候把相应的产生bloom二进制数据的过程
@Override
public void setup(Context context){
//初始化bloom二进制文件的过程
try{
//调节二进制的数据位数，可以提高过滤的准确性
BloomObject.CreateBloomFile("BloomFile/","BloomFile/outputBloomFile",0.01f,2);
DataInputStream dataInputStream = new DataInputStream(new FileInputStream(BloomMapper.getInputpath()));
bloomFilter.readFields(dataInputStream);
dataInputStream.close();
}catch (Exception e){
e.printStackTrace();
}
}
private Text keyvalue = new Text();
public void map(Object key,Text value,Context context) throws IOException,InterruptedException{
//进行map处理的过程,value为要进行判断的数据结果，如果在value中有对应的选择列表中的数据的话，则提取出结果即可
//对value的每一行的特定位置进行判别，提取数据，以空格区分数据在下标为6的位置上是要进行比较的内容
String[] str = value.toString().split("/");
if(str.length>=4 && str[3]!=" " ){
Key key1= new Key(str[3].getBytes("utf-8"));
keyvalue.set(str[3]);
if(key1.getBytes().length>0) {
if (bloomFilter.membershipTest(key1)) {
context.write(keyvalue, NullWritable.get());
}
}
}
}
}
}
BloomReducer函数没有书写内容，只是使用map函数进行了相应的简单的举例，如果需要reduce的过程可以继续书写相应的过程；
BloomMain函数：
package Bloom;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
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.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import java.net.URI;
public class BloomMain {
public static void main(String[] args) throws Exception{
Configuration configuration = new Configuration();
//需要比对的原始文件的相应的输入路径
Path inputpath = new Path("BloomInputFile/inputfile");
//输出数据文件的路径，这个不需要提前
Path outputpath = new Path("BloomInputFile/outputfile/");
//对bloom的相应的路径进行赋值操作
BloomMapper.setInputpath("BloomFile/outputBloomFile/bloomtestlog");
//做鲁棒性检查
FileSystem fileSystem = FileSystem.get(new URI(outputpath.toString()),configuration);
if(fileSystem.exists(outputpath)){
fileSystem.delete(outputpath,true);
}
Job job = Job.getInstance(configuration,"Bloom");
job.setJarByClass(BloomMain.class);
//把输入和输出路径的相关信息写入到hadoop的相应的变量中
FileInputFormat.setInputPaths(job,inputpath);
FileOutputFormat.setOutputPath(job,outputpath);
//设置map的类
job.setMapperClass(BloomMapper.BloomMapping.class);
//设置map的输出数据类型
job.setMapOutputKeyClass(Text.class);
job.setMapOutputValueClass(NullWritable.class);
//设置reduce输出类型
job.setOutputKeyClass(Text.class);
job.setOutputValueClass(NullWritable.class);
//提交job
job.waitForCompletion(true);
}
}
结果如下：
结果
PS：本人才疏学浅，大家一起进步，需要代码的直接留下邮箱，OK
