hadoop实现pagerank

1. pagerank的介绍文章：
   PageRank算法
2. 老师给的实现代码：
   思路：
   1、定义收敛标准
   每次算出新的new_pr-old_pr=差值 ，所有页面的差值累加 ,除以pagecount(网页数)，得到avg差值 ，如果小于0.001，停止迭代。
   2、计算总页面数，并且算出每个页面的初始pr值=1/pagecount

node:

package pagerank2;

import java.io.IOException;
import java.util.Arrays;

import org.apache.commons.lang.StringUtils;

public class Node {
	
	private double pageRank=1.0;//初始pagerank值
	private String[] adjacentNodeNames;//邻接节点数组
	
	public static final char filedSeparator='\t';

	public double getPageRank() {
		return pageRank;
	}

	public Node setPageRank(double pageRank) {
		this.pageRank = pageRank;
		return this;
	}

	public String[] getAdjacentNodeNames() {
		return adjacentNodeNames;
	}

	public Node setAdjacentNodeNames(String[] adjacentNodeNames) {
		this.adjacentNodeNames = adjacentNodeNames;
		return this;
	}

	//判断是否有邻接节点
	public boolean containsAdjacentNodes() {
		return adjacentNodeNames!=null&&adjacentNodeNames.length>0;
	}
	
	@Override
	public String toString(){ //pagerank值 节点X 节点Y 形式
		StringBuilder sb=new StringBuilder();
		sb.append(pageRank);  //第一个节点前有一个pagerank值
		
		if (getAdjacentNodeNames()!=null) {
			sb.append(filedSeparator).append(StringUtils.join(getAdjacentNodeNames(),filedSeparator));
		}
		return sb.toString();
	}
	
	//value=1.0 B D 
	//fromMR将value封装成Node对象
	public static Node fromMR(String value) throws IOException{
		String[] parts=StringUtils.splitPreserveAllTokens(value,filedSeparator);
	    if (parts.length<1) {
			throw new IOException("Expected 1 or more parts but received"+parts.length);
		}
		//如果只有一个pagerank值
		Node node=new Node().setPageRank(Double.valueOf(parts[0]));
		//如果有一个pagerank值和后面的邻接节点
		if (parts.length>1) { 
			node.setAdjacentNodeNames(Arrays.copyOfRange(parts, 1, parts.length));
		}
		return node;
	}

}

注意点：

1. 在node中的toString格式是：
   pagerank值 节点X 节点Y
   且node的作用是将mapper中的value封装

   A：B D
   A页面的出链为B和D

   则第一次A的node为：
   1.0 B D

job：

package pagerank2;

import java.io.IOException;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
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.input.KeyValueTextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

public class PageRankJob {

	public  static enum MyCounter {//任意定义一个枚举类型
		my
	}
	
	public static void main(String[] args) {
		   
		Configuration config=new Configuration();
		double error=0.001;
		int i=0;
		while (true) {
			i++;
			config.setInt("runCount", i);//runCount为迭代次数
			try {
				FileSystem fs=FileSystem.get(config);
				Job job =Job.getInstance(config);
				job.setJarByClass(PageRankJob.class);
				job.setJobName("pr"+i);
				job.setMapperClass(PageRankMapper.class);
				job.setReducerClass(PageRankReducer.class);
				job.setMapOutputKeyClass(Text.class);
				job.setMapOutputValueClass(Text.class);
				job.setInputFormatClass(KeyValueTextInputFormat.class);
				Path inputPath =new Path("hdfs://hadoop1:9000/input/pagerank.txt");
				if(i>1){
					inputPath =new Path("hdfs://hadoop1:9000/output_pagerank/pagerank" + (i - 1));
				}
				FileInputFormat.addInputPath(job, inputPath);
				
				Path outpath =new Path("hdfs://hadoop1:9000/output_pagerank/pagerank"+i);
				if(fs.exists(outpath)){
					fs.delete(outpath, true);
				}
				FileOutputFormat.setOutputPath(job, outpath);
				
				boolean f= job.waitForCompletion(true);
				if(f){
					System.out.println("success.");
					long sum= job.getCounters().findCounter(MyCounter.my).getValue();
					//所有节点pagerank差值的和
					System.out.println(sum);
					double avgd= sum/4000.0;
					if(avgd<error){
						break;
					}
				}	
			} catch (IOException | ClassNotFoundException | InterruptedException e) {
				
				e.printStackTrace();
			}
						
		}
		
	}
}

mapper:

package pagerank2;

import java.io.IOException;

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

public class PageRankMapper extends Mapper<Text, Text, Text, Text>{
	//map输入形式：key=第一个节点 value=第一个节点的pagerank值和后面的邻接节点
	//map输出形式分两种情况：
	//若节点为第一个节点则为：key->第一个节点 value->第一个节点的pagerank值和后面的邻接节点
	//若节点为第一个节点的邻接节点则为：key=每个节点 value=每个节点的pagerank值
	@Override
	protected void map(Text key, Text value, Context context)
			throws IOException, InterruptedException {
		int runCount=context.getConfiguration().getInt("runCount", 1);
		//取runCount的值，没取到就默认为1
		String page=key.toString();//key为每行的第一个节点
		//每行第一个字符串为Key如A，后面为A的pagerank+agjacentNodeNames组成value值
		Node node=null;
		//初始value为1.0 B D形式
		if (runCount==1) {
			node=Node.fromMR("1.0"+"\t"+value.toString());
		}else {//后面value为1.2 B D形式，1.2为后面计算的A的pagerank值
			node=Node.fromMR(value.toString());
		}
		
		//输出每行第一个节点和其pagerank值及该节点的邻接节点
		//即key=A，value=1.2 B C
		context.write(new Text(page), new Text(node.toString()));
		//如果第一个节点有邻接节点，继续输出
		//对
		if (node.containsAdjacentNodes()) {
			double outVlaue=node.getPageRank()/node.getAdjacentNodeNames().length;
			for(int i=0;i<node.getAdjacentNodeNames().length;i++){//遍历邻接节点
				String outPage=node.getAdjacentNodeNames()[i];
				context.write(new Text(outPage), new Text(outVlaue+""));
				//如：B:0.5  D:0.5形式
			}
		}		
	}	

}

reducer:

package pagerank2;

import java.io.IOException;

import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.xerces.dom3.as.NodeEditAS;

public class PageRankReducer extends Reducer<Text, Text, Text, Text>{
	@Override
	protected void reduce(Text arg0, Iterable<Text> arg1, Context arg2)
			throws IOException, InterruptedException {
		double sum=0.0;
		Node sourceNode=null;
		//这里分组是相同节点为一组
		for (Text i:arg1) {
			Node node=Node.fromMR(i.toString());//将mapper输出的两种类型的value转为node类型
			if (node.containsAdjacentNodes()) {
				sourceNode=node; //sourceNode有上一次计算时的每行第一个节点的pagerank值
			}else{ //就是B:0.5的形式，i就是0.5
				sum=sum+node.getPageRank(); //相同节点pagerank值的加权和
			}
		}
		
		// 这个是修正后的公式
		double newPR=(0.15/4)+(0.85*sum);
		System.out.println("*********** new pageRank value is "+newPR);
		//把新的pr值和计算之前的pr比较
		double d=newPR-sourceNode.getPageRank(); //计算一个节点的PageRank差值
		int j=(int)(d*1000.0); //差值j变成整数，因为increment要求参数为long型整数
		//乘1000是因为精度为0.001
		j=Math.abs(j); 
		//System.out.println(j+"___________");
		arg2.getCounter(MyCounter.my).increment(j); //mapreduce计数器
		sourceNode.setPageRank(newPR); //将上一次计算节点的pagerank值更新
		arg2.write(arg0, new Text(sourceNode.toString()));
		//Reducer输出形式为 节点 pagerank值 邻接节点
		}
}

老师参考的应该是这篇：
一个PageRank算法的MapReduce实现案例