序列化概述
-
什么是序列化
序列化就是把内存中的对象,转换成字节序列(或其他数据传输协议)以便于存储到磁盘(持久化)和网络传输。
反序列化就是将收到字节序列(或其他数据传输协议)或者是磁盘的持久化数据,转换成内存中的对象。
为什么要序列化
一般来说,“活的” 对象只生存在内存里,关机断电就没有了。而且 “活的” 对象只能由本地的进程使用,不能被发送到网络上的另外一台计算机。然而序列化可以存储 “活的” 对象,可以将 “活的”对象发送到远程计算机。
为什么不用 Java 的序列化
Java 的序列化是一个重量级序列化框架(Serializable),一个对象被序列化后,会附带很多额外的信息(各种校验信息,Header,继承体系等),不便于在网络中高效传输。所以,
Hadoop序列化特点:结构紧凑,存储空间少;传输速度快速;互操作性,支持多语言的交互。
自定义 bean 对象实现序列化接口(Writable)
在企业开发中往往常用的基本序列化类型不能满足所有需求,比如在 Hadoop 框架内部传递一个 bean 对象,那么该对象就需要实现序列化接口。
具体实现 bean 对象序列化步骤如下7步。
1、必须实现 Writable 接口;
2、重写序列化方法;
3、重写反序列化方法;
4、反序列化时,需要反射调用空参构造函数,所以必须有空参构造;
5、注意反序列化的顺序和序列化的顺序完全一致;
6、要想把结果显示在文件中,需要重写 toString() ,可以用 “\t” 分开,方便后续用;
7、如果需要将自定义的 bean 放在 key 中传输, 则还需要实现 Comparable 接口,因为 MapReduce 框中的 Shuffle 过程要求对 key 必须能排序。
序列化案例实操
1、需求:统计每一个手机号耗费的总上行流量、总下行流量、总流量
# 创建一个 phone_data.txt 输入数据(模拟数据,注意数据之间不是空格,是tab)
1 13736230510 192.196.100.1 www.baidu.com 2480 24570 200
2 13736230511 192.196.100.2 286 0 200
3 13736230512 192.196.100.3 132 18206 200
4 13736230513 192.196.100.4 www.taobao.com 3258 0 404
5 13736230514 192.196.100.5 1914 9 200
6 13736230515 192.196.100.6 7 24570 200
7 13736230516 192.196.100.7 96 0 200
8 13736230517 192.196.100.8 www.jingdong.com 25 12670 200
9 13736230518 192.196.100.9 www.baidu.com 125 180 500
10 13736230519 192.196.100.0 www.baidu.com 3524 13 200
11 13736230519 192.196.100.9 1724 261 200
# 输入手机格式
id 手机号码 网络ip 上行流量 下行流量 网络状态码
1 13736230510 192.196.100.1 2480 24570 200
# 期望输出数据格式
手机号码 上行流量 下行流量 总流量
13736230510 2480 24570 27050
2、需求分析
Map 阶段:
a、读取一行数,切分字段
b、抽取手机号、上行流量、下行流量
c、以手机号为 key,bean 对象为 value 输出,即 context.write(手机号,bean)
d、bean 对象要想能够传输,必须实现序列化接口
Reduce 阶段:
a、累加上行流量和下行流量得到总流量
package com.kane.mapreduce.writable;
import org.apache.hadoop.io.Writable;
import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
/**
* 1.定义类实现 writable 接口
* 2.重写序列化和反序列化方法
* 3.重写空参构造
* 4.toString 方法
*/
public class FlowBean implements Writable {
private long upFlow; //上行流量
private long downFlow; //下行流量
private long sumFlow; //总流量
// 空参构造
public FlowBean() {
}
public long getUpFlow() {
return upFlow;
}
public void setUpFlow(long upFlow) {
this.upFlow = upFlow;
}
public long getDownFlow() {
return downFlow;
}
public void setDownFlow(long downFlow) {
this.downFlow = downFlow;
}
public long getSumFlow() {
return sumFlow;
}
public void setSumFlow(long sumFlow) {
this.sumFlow = sumFlow;
}
// 重载
public void setSumFlow() {
this.sumFlow = this.upFlow + this.downFlow;
}
@Override
public void write(DataOutput out) throws IOException {
out.writeLong(upFlow);
out.writeLong(downFlow);
out.writeLong(sumFlow);
}
@Override
public void readFields(DataInput in) throws IOException {
// 要与序列化保持一致
this.upFlow = in.readLong();
this.downFlow = in.readLong();
this.sumFlow = in.readLong();
}
@Override
public String toString() {
return upFlow + "\t" + downFlow + "\t" + sumFlow;
}
}
package com.kane.mapreduce.writable;
import org.apache.hadoop.conf.Configuration;
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.output.FileOutputFormat;
import java.io.IOException;
public class FlowDriver {
public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
// 1.获取 job
Configuration conf = new Configuration();
Job job = Job.getInstance(conf);
// 2.设置 jar 包
job.setJarByClass(FlowDriver.class);
// 3.关联 mapper 和 reduce
job.setMapperClass(FlowMapper.class);
job.setReducerClass(FlowReducer.class);
// 4.设置 mapper 输出的 kv 类型
job.setMapOutputKeyClass(Text.class);
job.setMapOutputValueClass(FlowBean.class);
// 5.设置最终输出的 kv 类型
job.setOutputKeyClass(Text.class);
job.setOutputValueClass(FlowBean.class);
// 6.设置输入路径和输出路径
FileInputFormat.setInputPaths(job, new Path("E:\\input\\phone_data.txt"));
FileOutputFormat.setOutputPath(job, new Path("E:\\output"));
// 7.提交 job
boolean result = job.waitForCompletion(true);
System.exit(result ? 0 : 1);
}
}
package com.kane.mapreduce.writable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;
import java.io.IOException;
public class FlowMapper extends Mapper<LongWritable, Text, Text, FlowBean> {
private Text outK = new Text();
private FlowBean outV = new FlowBean();
@Override
protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
// 1.获取一行信息
// 1 13736230510 192.196.100.1 www.baidu.com 2480 24570 200
String line = value.toString();
// 2.切割
// 1,13736230510,192.196.100.1,www.baidu.com,2480,24570,200
String[] split = line.split("\t");
// 3.抓取想要的数据
String phone = split[1];
String up = split[split.length - 3];
String down = split[split.length - 2];
// 4.封装
outK.set(phone);
outV.setUpFlow(Long.parseLong(up));
outV.setDownFlow(Long.parseLong(down));
outV.setSumFlow();
// 5.写出
context.write(outK, outV);
}
}
package com.kane.mapreduce.writable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;
import java.io.IOException;
public class FlowReducer extends Reducer<Text, FlowBean, Text, FlowBean> {
private FlowBean outV = new FlowBean();
@Override
protected void reduce(Text key, Iterable<FlowBean> values, Context context) throws IOException, InterruptedException {
// 1.遍历集合累加值
long totalUp = 0;
long totalDown = 0;
for (FlowBean value : values) {
totalUp += value.getUpFlow();
totalDown += value.getDownFlow();
}
// 2.封装 outK, outV
outV.setUpFlow(totalUp);
outV.setDownFlow(totalDown);
outV.setSumFlow();
// 3.写出
context.write(key, outV);
}
}