🌐 深入浅出：基于Hadoop的分布式文件处理系统设计与实现🏅

bug菌
465 阅读20分钟

✨ 前言

  身处在这个数据爆炸的时代，让人头疼的永远是如何高效处理和存储大规模的数据！分布式文件系统则为这一难题提供了完美解决方案，而在众多技术方案中，Hadoop可谓大数据处理的开山之作。无论你是初入门的小白，还是摸爬滚打已久的老手，这篇文章都将用最通俗的语言带你搭建一个基于Hadoop的分布式文件处理系统，并且让你在其中轻松上手分布式文件读取、分布式处理、存储以及MapReduce任务的奇妙之处。准备好了吗？诸君，我要发车了！

🎯 项目概述

  首先，在这个演示项目中，我们将设计并实现一个分布式文件处理系统(谈谈大致思路，完全实现后续再完善)，让你体验大规模数据的处理与分析过程。这种系统的核心是处理超大规模的文件，并能将处理结果有效地存储回分布式文件系统HDFS。整个过程涉及文件的分布式读取、并行处理和存储。在此过程中，你将了解MapReduce的强大之处，体会分布式架构在处理海量数据时的效率和性能优势。

  通过本文的指导，你将掌握以下技能：

  • 文件的分布式读取：从HDFS中读取海量数据文件。
  • 数据的分布式处理：通过MapReduce实现高效的并行计算。
  • 处理结果的分布式存储：将处理后的数据写回HDFS。

  此外，本文将带你深入理解MapReduce任务的具体编写，解析CSV、JSON等常见数据格式，实现统计分析等基础功能，并帮助你掌握MapReduce任务的性能调优和正确性验证方法。

🧩 分布式文件处理系统的基本架构

💡 HDFS：可靠的分布式存储

  在海量数据处理中，HDFS（Hadoop分布式文件系统）是Hadoop生态系统中至关重要的一环。HDFS采用分块存储数据的方式，每个文件会被分割为若干小块，分布式存储在不同的DataNode上。

  • NameNode：负责管理文件系统的元数据（例如文件目录结构和块位置），是整个HDFS的“大脑”。一旦NameNode宕机，整个文件系统将不可用，所以必须做好备份和高可用配置。
  • DataNode：负责实际存储数据块，每个文件块在多个DataNode上复制保存，通常有3个副本，确保数据的高可用性。

HDFS架构图如下：

💾 MapReduce：并行处理的利器

  MapReduce框架将计算任务分解为Map和Reduce两个阶段。Map阶段会分布式处理数据，生成中间结果；Reduce阶段再汇总中间结果，得到最终输出。在分布式处理系统中，MapReduce特别适合处理结构化数据的批量计算工作，如日志分析、文本挖掘等。

  • Map阶段：分布式处理输入数据，提取有用信息。
  • Reduce阶段：合并并汇总Map任务的输出，形成最终结果。

MapReduce工作原理图如下：

  通过MapReduce，我们可以轻松地并行处理TB级别的数据。

💻 实现核心功能

🔍 文件的分布式读取

  分布式读取是分布式文件处理系统的第一步。在HDFS中存储的大文件将被切分成多个小块，每个DataNode负责存储一个或多个数据块，这样就可以在集群中实现并发读取。

数据读取步骤：

  1. 数据分块：在HDFS中上传大文件时，文件会被切分成多个64MB或128MB的小块存储在不同的DataNode上。
  2. Map任务并行读取：Map任务被分配到不同的节点上，并行读取文件块，提高处理效率。

示例代码：

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FSDataInputStream;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class HDFSFileReader {

    public static void main(String[] args) {
        Configuration conf = new Configuration();
        FSDataInputStream in = null;
        BufferedReader br = null;
        
        try {
            FileSystem fs = FileSystem.get(conf);
            Path filePath = new Path("hdfs://path/to/file");

            // 打开HDFS文件流
            in = fs.open(filePath);
            br = new BufferedReader(new InputStreamReader(in, "UTF-8"));
            
            String line;
            while ((line = br.readLine()) != null) {
                // 读取每一行进行处理
                processLine(line);
            }

        } catch (IOException e) {
            System.err.println("读取文件出错: " + e.getMessage());
            e.printStackTrace();
        } finally {
            // 确保资源关闭
            try {
                if (br != null) br.close();
                if (in != null) in.close();
            } catch (IOException ex) {
                System.err.println("关闭文件流时出错: " + ex.getMessage());
            }
        }
    }

    // 示例处理函数：对每行数据进行处理
    private static void processLine(String line) {
        // 添加具体的处理逻辑
        System.out.println("读取行内容: " + line);
    }
}

🛠 文件的分布式处理

  在数据分布式处理阶段，我们将编写MapReduce任务来对数据进行解析和分析。每个Map任务负责读取和解析一部分文件，将所需的数据转化为“键值对”（Key-Value Pair）的形式，这种形式在Reduce阶段能够轻松完成数据的统计和聚合。

数据解析：编写Map任务解析文件中的每一行数据，根据数据格式进行处理，例如将CSV文件分列、提取JSON数据字段等。

实现思路：具体要如何实现文件的分布式处理？思路梳理如下：

  1. 任务划分与数据并行处理

    • 在分布式系统中，文件会被分割成多个块，并分配到不同节点上，以便进行并行处理。
    • Hadoop框架通过MapReduce任务实现数据处理的并行化，每个Map任务负责处理文件的不同部分（行、块等），提升整体处理速度。

  2. 编写Map任务进行数据解析

    • Map任务：编写一个Mapper类（如CsvMapper）来处理文件中的每行数据。
    • Map任务会读取每一行并解析其内容，将所需数据字段转化为<Key, Value>形式，为后续的统计分析提供基础。
    • 在这个示例中，Map任务将CSV文件中的第二列作为Key，将每行的数据值视为一个统计对象。

  3. 实现数据解析和条件检查

    • 去空处理：在解析行数据之前，通过line.trim()去掉行首尾空格，并检查是否为空行，以提高解析准确性。
    • 字段检查：使用fields.length > 1确保行数据包含至少两列，防止因数据不完整而引发数组越界错误。
    • 输出键值对：一旦提取出指定字段（例如，CSV文件的第二列），将其作为Key，输出<Key, 1>对用于统计。

  4. MapReduce流程总结

    • Map阶段：每个Map任务并行处理一部分数据，将指定字段的值作为Key并输出<Key, 1>对。
    • Reduce阶段：Reducer对相同Key的所有值进行聚合，计算出每个字段值的总数量，实现数据统计功能。

总而言之： 整体思路归纳如下三步：

  • 并行化处理：利用分布式系统将文件分块处理，Map任务独立解析各个数据块，提升效率。
  • 数据解析与清洗：在Map任务中完成数据行解析、字段提取、空值检查等预处理工作。
  • 键值对输出：将数据转化为<Key, Value>形式，并通过MapReduce的聚合能力完成分布式统计分析。

如下是具体的代码演示，仅供参考：

Map任务示例：

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

import java.io.IOException;

public class CsvMapper extends Mapper<LongWritable, Text, Text, IntWritable> {

    private static final IntWritable ONE = new IntWritable(1);
    private Text outputKey = new Text();

    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        String line = value.toString().trim();  // 去掉行首尾的空格
        if (line.isEmpty()) {
            return;  // 跳过空行
        }

        String[] fields = line.split(",");
        if (fields.length > 1) {  // 检查行是否包含至少两列
            String keyField = fields[1].trim();  // 假设第二列为统计字段
            outputKey.set(keyField);
            context.write(outputKey, ONE);
        }
    }
}

💾 文件的分布式存储

  在MapReduce的Reduce阶段完成统计和聚合之后，最终的结果会写回HDFS中，确保所有的处理数据都以分布式的形式进行存储。这样不仅能够提高数据存储的容错性，还可以让下游任务并行读取和分析结果。

  在分布式存储阶段，将MapReduce处理结果写回到HDFS，主要步骤和思路梳理如下：

  1. 配置HDFS环境：

    • 创建Configuration对象，用于获取HDFS配置项。Hadoop通过Configuration类连接并配置HDFS文件系统。

  2. 创建输出路径：

    • 设置目标路径Path outputPath，指定数据写入的文件路径。
    • 利用FileSystem fs = FileSystem.get(conf)获取FileSystem实例，确保能够通过HDFS的API访问和操作HDFS文件系统。

  3. 创建输出流：

    • 使用fs.create(outputPath, true)创建文件输出流FSDataOutputStream，并将其包装为BufferedWriter以便高效写入。
    • OutputStreamWriter可以指定编码格式（如UTF-8），确保数据的字符编码一致性。

  4. 写入数据：

    • 使用bw.write("Result data...")将结果数据写入文件。
    • 可以根据需要使用bw.newLine()写入换行符，确保数据格式的整齐和可读性。

  5. 异常处理：

    • 捕获并处理IOException，输出详细的错误信息，便于调试。
    • 使用System.err打印错误信息可以帮助识别写入和关闭文件过程中可能出现的问题。

  6. 关闭资源：

    • 在finally代码块中，确保在操作完成后关闭BufferedWriter和FSDataOutputStream，释放系统资源，防止内存泄漏。

具体示例代码演示如下，仅供参考：

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FSDataOutputStream;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;

import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;

public class HDFSFileWriter {

    public static void main(String[] args) {
        Configuration conf = new Configuration();
        FSDataOutputStream out = null;
        BufferedWriter bw = null;
        
        try {
            FileSystem fs = FileSystem.get(conf);
            Path outputPath = new Path("hdfs://path/to/output");

            // 创建HDFS输出流
            out = fs.create(outputPath, true);
            bw = new BufferedWriter(new OutputStreamWriter(out, "UTF-8"));

            // 写入数据
            bw.write("Result data...");
            bw.newLine();  // 写入换行符

        } catch (IOException e) {
            System.err.println("写入文件时出错: " + e.getMessage());
            e.printStackTrace();
        } finally {
            // 关闭资源
            try {
                if (bw != null) bw.close();
                if (out != null) out.close();
            } catch (IOException ex) {
                System.err.println("关闭文件流时出错: " + ex.getMessage());
            }
        }
    }
}

🗂 MapReduce任务：解析与分析

📊 CSV文件解析与统计

  以CSV文件为例，Map任务会逐行解析CSV文件，将指定的列作为Key，进行聚合统计。在此示例中，我们将CSV文件的第二列作为统计字段，执行计数操作。大概实现思路：通过解析CSV文件，并以第二列的值作为Key来输出计数。在该任务中，每当找到一个特定的字段值（在此示例中为CSV文件的第二列），就向Reducer输出<字段值, 1>对，从而实现对每个字段值的计数汇总。

  那么具体要如何解析CSV文件并对指定字段的值进行统计？整体实现思路如下：

  1. 数据预处理：

    • Map任务逐行读取CSV文件，每一行会被当作一个Text对象传入。
    • 去除行首尾的空格，以避免因格式问题导致的解析错误。
    • 检查行是否为空，以跳过空行，确保数据处理的效率和准确性。

  2. 字段解析与检查：

    • 使用逗号分隔符（,）将行内容拆分为多个字段，存入String[]数组中。
    • 检查数组长度，确保至少有两列存在。通过这种简单的数据验证，可以避免在缺少字段时的数组越界错误。

  3. 指定字段为Key，输出计数：

    • 从解析出的字段中提取目标列（此例中为第二列），并将其作为Map任务的Key。
    • 使用context.write(outputKey, ONE)将<Key, 1>输出对发送到Reducer阶段，表示找到了一个匹配的字段值。
    • ONE定义为常量IntWritable，表示每次匹配到该字段值时给它的计数值为1。

  4. 错误处理：

    • 若行格式不符合预期（例如，字段数小于两列），在控制台打印错误信息，帮助追踪数据源问题和调试。

  光说不练假把式，具体示例代码演示如下，仅供参考：

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

import java.io.IOException;

public class CsvMapper extends Mapper<LongWritable, Text, Text, IntWritable> {

    private static final IntWritable ONE = new IntWritable(1);
    private Text outputKey = new Text();

    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        // 去除行首尾空格，检查是否为空行
        String line = value.toString().trim();
        if (line.isEmpty()) {
            return;  // 跳过空行
        }

        // 以逗号分隔字段
        String[] fields = line.split(",");
        if (fields.length > 1) {  // 确保至少包含两列
            String keyField = fields[1].trim();  // 假设第二列为统计字段
            outputKey.set(keyField);
            context.write(outputKey, ONE);  // 计数
        } else {
            System.err.println("解析错误：行格式不正确 - " + line);
        }
    }
}

📈 JSON文件解析与统计

  对于JSON格式的文件，Map任务可以借助第三方JSON解析库，例如Jackson或Gson来解析数据字段。以下代码示例展示了如何从JSON中提取字段并计数。

  然后实现这个JSON文件解析与统计的思路可以分为以下几个步骤：

  1. 选择解析库

    • 选择合适的JSON解析库（如org.json、Jackson或Gson），便于快速提取JSON数据中的指定字段。本示例使用org.json库，直接将每行数据解析成JSONObject对象，以便提取字段。

  2. 实现Map类

    • 创建一个Hadoop的Mapper类（如JsonMapper），实现MapReduce的Map阶段。此类的map方法将处理输入的每行数据。
    • 在Hadoop的MapReduce框架中，Map阶段主要负责将数据格式转换为<Key, Value>对，供Reducer阶段进行统计聚合。

  3. 解析JSON对象

    • 在map方法中，将传入的Text类型的value转换为String并解析为JSONObject对象。
    • 使用json.has("fieldName")检查目标字段是否存在，避免因字段缺失而引发的错误。

  4. 输出 <Key, Value> 对

    • 获取指定字段的值，将其作为Map输出的Key，并将计数值1作为Value输出<Key, 1>。
    • 使用outputKey.set(fieldValue)来设置当前字段值为输出Key，使用静态常量ONE表示每个Key的出现次数。

  5. 异常处理

    • 包裹JSON解析逻辑，以捕获和处理解析过程中可能出现的异常（例如，格式错误、字段缺失等）。
    • 将任何异常输出到System.err，以便在日志中查看具体错误信息，有助于排查和调试问题。

  6. 执行MapReduce流程

    • Map阶段：每行记录都会经过Map阶段，解析并提取指定字段的值，输出<fieldValue, 1>对。
    • Reduce阶段：在Reducer中，对于每个相同的Key（fieldValue），聚合计数，计算该字段值的总出现次数。

总而言之： 通过MapReduce框架：

  • 利用Map阶段的JSON解析，将目标字段值提取并计数。
  • 通过Reduce阶段对相同Key（字段值）进行聚合，得出每个字段值的总计数。

具体代码示例演示如下：

import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;
import org.json.JSONObject;

import java.io.IOException;

public class JsonMapper extends Mapper<LongWritable, Text, Text, IntWritable> {

    private static final IntWritable ONE = new IntWritable(1);
    private Text outputKey = new Text();

    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        try {
            // 解析JSON对象
            JSONObject json = new JSONObject(value.toString());

            // 获取指定的统计字段
            if (json.has("fieldName")) {  // 检查字段是否存在
                String fieldValue = json.getString("fieldName").trim();
                outputKey.set(fieldValue);
                context.write(outputKey, ONE);  // 输出 <Key, 1> 对
            } else {
                System.err.println("字段缺失: " + value.toString());
            }

        } catch (Exception e) {
            System.err.println("JSON解析错误: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

📈 性能优化与正确性验证

  MapReduce的性能调优是分布式计算的关键一环。以下是几种常见的优化策略：

  1. 任务数量控制：将小文件合并处理，减少Map任务开销。
  2. 合理配置Reduce任务：增大Reduce任务数，可以减小单个任务的处理量，从而提高整体性能。
  3. 数据本地化调度：通过将任务分配至数据所在节点，减少网络传输，进一步提升处理速度。
  4. 缓存优化：在Map和Reduce任务中减少对象创建次数，尽量使用缓存存储中间结果，减少内存开销。

🧩 进一步深入：MapReduce任务的优化&扩展

  我们都知道MapReduce是分布式处理的核心，它的实现与调优直接影响系统的性能与稳定性。对于一个基于Hadoop的分布式文件处理系统，合理的MapReduce优化可以有效提升系统效率。接下来，我们进一步探讨一些更深入的优化技巧和高级配置，以应对大规模数据的需求。

🚀 高级MapReduce优化技巧

  1. 合并小文件优化：小文件过多会导致大量Map任务，增加Job的启动和调度开销。我们可以使用CombineFileInputFormat或SequenceFile将小文件合并成大文件，从而减少Map任务数量。
   job.setInputFormatClass(CombineFileInputFormat.class);
  1. 数据倾斜处理：在一些分布式计算场景中，数据分布不均衡会导致部分Reduce任务过载。我们可以采用自定义分区器（Partitioner）来根据数据特征重新分区，确保每个Reduce任务负载均衡。
   public class CustomPartitioner extends Partitioner<Text, IntWritable> {
       @Override
       public int getPartition(Text key, IntWritable value, int numPartitions) {
           return key.hashCode() % numPartitions;
       }
   }
   job.setPartitionerClass(CustomPartitioner.class);

  1. 本地化数据处理：在MapReduce任务分配时，尽量将任务调度到数据所在的DataNode上，减少网络I/O的消耗。Hadoop的YARN框架会尽量选择“本地化数据”的节点执行任务，但也可以通过配置提高本地化优先级。

  2. 中间数据压缩：在Map到Reduce的过程中，中间数据会产生大量的网络传输。通过对中间数据进行压缩可以减少传输量。Hadoop支持多种压缩格式，如Snappy、Gzip等。

   conf.set("mapreduce.map.output.compress", "true");
   conf.set("mapreduce.map.output.compress.codec", "org.apache.hadoop.io.compress.SnappyCodec");

🌐 资源调度与容错处理

  在分布式环境中，资源调度与容错机制至关重要。Hadoop的YARN（Yet Another Resource Negotiator）是其资源管理核心，负责分配CPU、内存等资源。了解YARN的调度机制可以帮助我们更高效地利用资源。

  1. 动态资源分配：YARN支持多种调度策略，如FIFO调度器、Capacity调度器和Fair调度器。对于不同的业务需求，可以选择合适的调度策略，以提高集群的资源利用率。

  2. 任务失败重试：Hadoop在任务失败时会自动进行重试，且可以通过配置文件设置重试次数。重试机制对于大规模集群中偶发的节点故障尤为重要。

  3. 检查点机制：在一些长时间运行的任务中，可以配置Hadoop的checkpoint机制。这样即使任务中断，也可以从上次的checkpoint继续执行，避免重新计算全部数据。

💾 HDFS的高级配置与调优

  HDFS作为底层存储系统，为分布式文件处理提供了可靠的数据持久化支持。以下是几个常见的HDFS调优技巧：

  1. 副本数配置：HDFS默认会将每个数据块存储3个副本。根据数据的重要性和节点稳定性，可以适当调整副本数量，以在存储空间与容错性之间取得平衡。

  2. NameNode的高可用性：在生产环境中，NameNode的可用性至关重要。Hadoop 2.0引入了NameNode HA（High Availability），通过ZooKeeper实现NameNode的主备切换，确保NameNode出现故障时可以快速恢复。

  3. 数据块大小调整：HDFS的默认数据块大小为128MB，但对于某些应用场景，可以将块大小调整到256MB或512MB，这样可以减少Map任务数量，提高文件处理效率。

  4. 存储策略优化：在一些冷数据或归档数据的存储中，可以采用HDFS的Erasure Coding（纠删码）功能。相比于3个副本的存储方式，纠删码在大数据量场景中可以大大减少存储开销。

🛠 项目案例演示：销售数据的分布式分析系统

  为了帮助大家更好地理解Hadoop分布式文件处理的工作原理，我们以一个销售数据分析系统为例进行实际演示。假设我们有一个销售记录的大型CSV文件，包含每个销售订单的时间、商品、金额、地区等字段。目标是统计出各地区的销售总额。

🎃 1. 设计Map任务

Map任务负责逐行解析CSV文件，提取每条订单的销售额和地区信息，将其转换为<地区, 销售额>的键值对格式。

public class SalesMapper extends Mapper<LongWritable, Text, Text, DoubleWritable> {
    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        String[] fields = value.toString().split(",");
        String region = fields[3]; // 假设第四列为地区
        double amount = Double.parseDouble(fields[2]); // 假设第三列为销售金额
        context.write(new Text(region), new DoubleWritable(amount));
    }
}

🎈 2. 设计Reduce任务

Reduce任务接收同一地区的所有销售额，并求和，得到每个地区的销售总额。

public class SalesReducer extends Reducer<Text, DoubleWritable, Text, DoubleWritable> {
    @Override
    protected void reduce(Text key, Iterable<DoubleWritable> values, Context context) throws IOException, InterruptedException {
        double totalSales = 0.0;
        for (DoubleWritable value : values) {
            totalSales += value.get();
        }
        context.write(key, new DoubleWritable(totalSales));
    }
}

🧨 3. 执行任务并输出结果

  在HDFS中存储销售数据文件，并提交MapReduce任务，执行完成后，即可在指定的HDFS输出路径中查看各地区的销售总额。此任务可以帮助企业按地区分析销售情况，制定相应的营销策略。

hadoop jar SalesAnalysis.jar SalesAnalysis /input/sales_data.csv /output/sales_summary

🎁 4. 结果验证与调试

  在分布式文件系统中运行MapReduce任务，需要针对每一步进行结果验证和调试，以确保程序的正确性。

  • 日志查看：在Hadoop中，每个Map和Reduce任务都会生成详细的日志信息。我们可以通过YARN的ResourceManager界面查看任务的执行状态和错误日志，以定位问题。
  • 数据检查：将输出结果下载到本地，使用脚本或手动检查数据，确保统计结果的正确性。
  • 中间结果检查：在开发阶段可以添加一些调试信息，或直接输出部分中间结果，以便在调试过程中逐步排查错误。

🚀 总结与展望

  OK，讲到这里，我们本期的内容即将要接近尾声了，老规矩，在结束之前，我先对本期内容进行一个全面的总结，以便于大家能更直白的回味。

  本期内容我大致探讨了基于Hadoop的分布式文件处理系统的设计和实现过程：从HDFS的文件读取、MapReduce任务的分布式处理，到性能优化和正确性验证，完整地展示了大数据处理的全链路。通过这样的实践，你不仅能掌握Hadoop的使用，还能体会到分布式处理在应对海量数据时的效率和优势。

  未来，如果你有兴趣，可以进一步了解Apache Spark、Flink等内存计算框架，它们在处理速度和实时性上各具特色，适合不同场景的数据处理需求。同时，基于Hadoop的技术内容比较广，毕竟它已经是一个比较完善的生态，学习难度也比较大，很难单凭一篇文就把它讲透，但不得不说设计Hadoop的思维很棒，值得我们花时间去学习深究。当然，如果你也是热爱技术且擅于分享，那么我的分享这篇文的目的就达到了，借此希望通过我抛砖引玉，激发更多大佬写出更多相关领域的优秀文章，把技术讲透，学透！引领更多同行产生共鸣。

📣 关于我

我是bug菌，CSDN | 掘金 | InfoQ | 51CTO | 华为云 | 阿里云 | 腾讯云 等社区博客专家，C站博客之星Top30，华为云2023年度十佳博主，掘金多年度人气作者Top40，掘金等各大社区平台签约作者，51CTO年度博主Top12，掘金/InfoQ/51CTO等社区优质创作者；全网粉丝合计 30w+；硬核微信公众号「猿圈奇妙屋」，欢迎你的加入！免费白嫖最新BAT互联网公司面试真题、4000G PDF电子书籍、简历模板等海量资料，你想要的我都有，关键是你不来拿哇。

-End-

avatar
文章
阅读
粉丝