MapReduce实现等值连接，左外连接，右外连接，全外连接

#测试数据：

# more user.txt(用户ID，用户名)

1	lavimer
2	liaozhongmin
3	liaozemin

#more post.txt(用户ID，帖子ID，标题)

1	1	java
1	2	c
2	3	hadoop
4	4	hive
5	5	hbase
5	6	pig
5	7	flume

#等值连接结果如下：

1	lavimer	1	1	java
1	lavimer	1	2	c
2	liaozhongmin	2	3	hadoop

#左外连接结果如下：

1	lavimer	1	1	java
1	lavimer	1	2	c
2	liaozhongmin	2	3	hadoop
3	liaozemin	NULL

#右外连接结果如下：

1	lavimer	1	1	java
1	lavimer	1	2	c
2	liaozhongmin	2	3	hadoop
NULL	4	4	hive
NULL	5	5	hbase
NULL	5	6	pig
NULL	5	7	flume

#全外连接结果如下：

1	lavimer	1	1	java
1	lavimer	1	2	c
2	liaozhongmin	2	3	hadoop
3	liaozemin	NULL
NULL	4	4	hive
NULL	5	5	hbase
NULL	5	6	pig
NULL	5	7	flume

实现代码如下：

/**
 * 
 * @author 廖钟民
 * time : 2015年1月30日下午1:23:36
 * @version
 */
public class UserPostJoin {
	// 定义输入路径
	private static final String INPUT_PATH1 = "hdfs://liaozhongmin:9000/user_post_join/user.txt";
	private static final String INPUT_PATH2 = "hdfs://liaozhongmin:9000/user_post_join/post.txt";
	// 定义输出路径
	private static final String OUT_PATH = "hdfs://liaozhongmin:9000/out";

	public static void main(String[] args) {

		try {
			// 创建配置信息
			Configuration conf = new Configuration();

			// 创建文件系统
			FileSystem fileSystem = FileSystem.get(new URI(OUT_PATH), conf);
			// 如果输出目录存在，我们就删除
			if (fileSystem.exists(new Path(OUT_PATH))) {
				fileSystem.delete(new Path(OUT_PATH), true);
			}

			// 创建任务
			Job job = new Job(conf, UserPostJoin.class.getName());

			// 设置连接类型
			job.getConfiguration().set("joinType", "allOuter");
			// 设置多路径输入
			MultipleInputs.addInputPath(job, new Path(INPUT_PATH1), TextInputFormat.class, UserMapper.class);
			MultipleInputs.addInputPath(job, new Path(INPUT_PATH2), TextInputFormat.class, PostMapper.class);

			//1.2 设置自定义Mapper类和设置map函数输出数据的key和value的类型
			job.setMapOutputKeyClass(Text.class);
			job.setMapOutputValueClass(UserPost.class);

			//1.3 设置分区和reduce数量(reduce的数量，和分区的数量对应，因为分区为一个，所以reduce的数量也是一个)
			job.setPartitionerClass(HashPartitioner.class);
			job.setNumReduceTasks(1);

			//1.4 排序
			//1.5 归约
			//2.1 Shuffle把数据从Map端拷贝到Reduce端。
			//2.2 指定Reducer类和输出key和value的类型
			job.setReducerClass(UserPostReducer.class);
			job.setOutputKeyClass(Text.class);
			job.setOutputValueClass(Text.class);

			//2.3 指定输出的路径和设置输出的格式化类
			FileOutputFormat.setOutputPath(job, new Path(OUT_PATH));
			job.setOutputFormatClass(TextOutputFormat.class);

			// 提交作业 退出
			System.exit(job.waitForCompletion(true) ? 0 : 1);

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

	/**
	 * 自定义Mapper类用于处理来自user.txt文件的数据
	 * @author 廖钟民
	 * time : 2015年1月30日下午1:22:12
	 * @version
	 */
	public static class UserMapper extends Mapper<LongWritable, Text, Text, UserPost> {
		@Override
		protected void map(LongWritable key, Text value, Mapper<LongWritable, Text, Text, UserPost>.Context context) throws IOException, InterruptedException {
			// 对字符串进行切分
			String[] arr = value.toString().split("\t");
			// 创建UserId
			Text userId = new Text(arr[0]);
			// 把结果写出去
			context.write(userId, new UserPost("U", value.toString()));
		}
	}
	/**
	 * 自定义Mapper类用于处理来自post.txt文件的数据
	 * @author 廖钟民
	 * time : 2015年1月30日下午1:22:16
	 * @version
	 */
	public static class PostMapper extends Mapper<LongWritable, Text, Text, UserPost> {
		@Override
		protected void map(LongWritable key, Text value, Mapper<LongWritable, Text, Text, UserPost>.Context context) throws IOException, InterruptedException {
			// 对数据进行切分
			String[] arr = value.toString().split("\t");
			// 创建用户ID
			Text userId = new Text(arr[0]);
			context.write(userId, new UserPost("P", value.toString()));

		}
	}
	/**
	 * 自定义Reducer类用于处理不同Mapper类的输出
	 * @author 廖钟民
	 * time : 2015年1月30日下午1:23:05
	 * @version
	 */
	public static class UserPostReducer extends Reducer<Text, UserPost, Text, Text> {
		// 定义List集合用于存放用户
		private List<Text> users = new ArrayList<Text>();
		private List<Text> posts = new ArrayList<Text>();

		// 定义连接类型
		private String joinType;

		@Override
		protected void setup(Reducer<Text, UserPost, Text, Text>.Context context) throws IOException, InterruptedException {

			this.joinType = context.getConfiguration().get("joinType");

			System.out.println(joinType);

		}
		/**
		 * 经过Shuffle后数据会分组，每一组数据都会调用一次reduce()函数
		 *第一组数据：
		 *1	lavimer
		 *1	1	java
		 *1	2	c
		 *
		 *第二组数据：
		 *2	3	hadoop
		 *2	liaozhongmin
		 *
		 *第三组数据：
		 *3	liaozemin
		 *
		 *第四组数据：
		 *4	4	hive
		 *
		 *第五组数据：
		 *5	5	hbase
		 *5	6	pig
		 *5	7	flume
		 *
		 *每一组数据都会调用一次reduce()函数，我们以第一组数据为例进行讲解：
		 *
		 *进入reduce函数后，<1,lavimer>会被添加到users集合中 
		 *<1	1	java>和<1	2	c>会被添加到posts集合中
		 *
		 *然后是判断当前操作是什么类型的连接，我们以等值连接为例：
		 *遍历两个集合得到的数据为：
		 *【1	lavimer	   1         1    java】
		 *【1	lavimer	   1		 2    c】
		 *
		 *这是第一组数据的执行轨迹，其他依次类推就可以得到相关的操作
		 */
		protected void reduce(Text key, Iterable<UserPost> values, Reducer<Text, UserPost, Text, Text>.Context context) throws IOException,
				InterruptedException {
			// 清空集合
			users.clear();
			posts.clear();

			// 迭代values集合把当前穿进来的某个组中的数据分别添加到对应的集合中
			for (UserPost val : values) {
				System.out.println("实际值：" + key + "===>" + values.toString());
				if (val.getType().equals("U")) {
					users.add(new Text(val.getData()));
				} else {
					posts.add(new Text(val.getData()));
				}
			}

			// 根据joinType关键字做对应的连接操作
			if (joinType.equals("innerJoin")) {// 内连接
				if (users.size() > 0 && posts.size() > 0) {

					for (Text user : users) {
						for (Text post : posts) {
							context.write(new Text(user), new Text(post));
						}
					}
				}
			} else if (joinType.equals("leftOuter")) {// 左外连接

				for (Text user : users) {
					if (posts.size() > 0) {
						for (Text post : posts) {
							context.write(new Text(user), new Text(post));
						}
					} else {
						context.write(new Text(user), createEmptyPost());
					}
				}

			} else if (joinType.equals("rightOuter")) {// 右外连接
				for (Text post : posts) {
					if (users.size() > 0) {
						for (Text user : users) {
							context.write(new Text(user), new Text(post));
						}
					} else {
						context.write(createEmptyUser(), post);
					}
				}
			} else if (joinType.equals("allOuter")) {// 全外连接
				if (users.size() > 0) {
					for (Text user : users) {
						if (posts.size() > 0) {
							for (Text post : posts) {
								context.write(new Text(user), new Text(post));
							}
						} else {
							context.write(new Text(user), createEmptyPost());
						}
					}
				} else {
					for (Text post : posts) {
						if (users.size() > 0) {
							for (Text user : users) {
								context.write(new Text(user), new Text(post));
							}
						} else {
							context.write(createEmptyUser(), post);
						}
					}
				}
			}

		}

		/**
		 * 用户为空时用制表符代替
		 * 
		 * @return
		 */
		private Text createEmptyUser() {
			return new Text("NULL");
		}

		/**
		 * 帖子为空时用制表符代替
		 * 
		 * @return
		 */
		private Text createEmptyPost() {
			return new Text("NULL");
		}
	}
}
/**
 * 自定义实体类封装两个表的数据
 * @author 廖钟民
 * time : 2015年1月30日下午1:23:50
 * @version
 */
class UserPost implements Writable {

	// 类型(U表示用户，P表示帖子)
	private String type;
	private String data;

	public UserPost() {
	}

	public UserPost(String type, String data) {
		this.type = type;
		this.data = data;
	}

	public String getType() {
		return type;
	}

	public void setType(String type) {
		this.type = type;
	}

	public String getData() {
		return data;
	}

	public void setData(String data) {
		this.data = data;
	}

	public void write(DataOutput out) throws IOException {
		out.writeUTF(this.type);
		out.writeUTF(this.data);

	}

	public void readFields(DataInput in) throws IOException {
		this.type = in.readUTF();
		this.data = in.readUTF();
	}

}