Hadoop入门案例 全排序之TotalOrderPartitioner工具类+自动采样

最新推荐文章于 2018-11-09 10:12:55 发布
最新推荐文章于 2018-11-09 10:12:55 发布
阅读量2k 收藏 1
点赞数 1
分类专栏： 大数据 文章标签： mapreduce hadoop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36864672/article/details/78586367
版权

代码

package com.myhadoop.mapreduce.test;
import org.apache.hadoop.conf.Configured;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapred.lib.InputSampler;
import org.apache.hadoop.mapred.lib.TotalOrderPartitioner;
import org.apache.hadoop.mapreduce.Reducer;
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;
import org.apache.hadoop.util.Tool;
import org.apache.hadoop.util.ToolRunner;
import java.io.IOException;

/**
 * Created by kaishun on 2017/6/10.
 */
public class TotalOrderSort extends Configured implements Tool{

    public static class myMap extends org.apache.hadoop.mapreduce.Mapper<LongWritable, Text, Text, Text>{

        public void map(LongWritable key,Text value,Context context) throws IOException,InterruptedException{
            String[] split = value.toString().split("\\s+");
            for (int i = 0; i <split.length ; i++) {
                Text word = new Text(split[i]);
                context.write(word,new Text(""));
            }
        }
    }
    public static class myReduce extends Reducer<Text,Text,Text,Text>{

        public void reduce(Text key, Iterable<Text> values,Context context) throws IOException,InterruptedException
        {
            context.write(key, new Text(""));

        }
    }

    @Override
    public int run(String[] args) throws Exception {
        Job job = Job.getInstance(getConf());
        job.setJarByClass(TotalSort.class);
        job.setJobName("TotalSortTest");


        job.setInputFormatClass(KeyValueTextInputFormat.class);

        job.setNumReduceTasks(3);

        //因为map和reduce的输出是同样的类型，所以输出一个就可以了
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(Text.class);

        job.setMapperClass(myMap.class);
        job.setReducerClass(myReduce.class);

        FileInputFormat.setInputPaths(job, new Path(args[0]));
        FileOutputFormat.setOutputPath(job, new Path(args[1]));

        // 设置分区文件，即采样后放在的文件的文件名，不是完整路径
        TotalOrderPartitioner.setPartitionFile(job.getConfiguration(), new Path(args[2]));
         //采样器：三个参数
        /* 第一个参数 freq: 表示来一个样本，将其作为采样点的概率。如果样本数目很大
         *第二个参数 numSamples：表示采样点最大数目为，我这里设置10代表我的采样点最大为10，如果超过10，那么每次有新的采样点生成时
         * ，会删除原有的一个采样点,此参数大数据的时候尽量设置多一些
         * 第三个参数 maxSplitSampled：表示的是最大的分区数：我这里设置100不会起作用，因为我设置的分区只有4个而已
         */

        InputSampler.Sampler<Text, Text> sampler = new InputSampler.RandomSampler<>(0.01, 10, 100);

        //把分区文件放在hdfs上，对程序没什么效果，方便我们查看而已
        FileInputFormat.addInputPath(job, new Path("/test/sort"));
        //将采样点写入到分区文件中，这个必须要
        InputSampler.writePartitionFile(job, sampler);
        job.setPartitionerClass(TotalOrderPartitioner.class);

        boolean success = job.waitForCompletion(true);
        return success ? 0:1;
    }
    public static void main(String[] args) throws Exception {
        int ret = ToolRunner.run(new TotalSortTest(), args);
        System.exit(ret);
    }
}


 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88

注意的地方

 InputSampler.Sampler<Text, Text> sampler = new InputSampler.RandomSampler<>(0.01, 10, 100);中三个参数要注意
 
 
  • 1
InputSampler.Sampler<Text, Text> 只能是Text,Text的类型
 
 
  • 1
3. TotalOrderPartitioner.setPartitionFile(job.getConfiguration(), new Path(args[2]));用来给TotalOrderPartitioner初始化赋值，job.setPartitionerClass(TotalOrderPartitioner.class); 进行分区，就不需要自己写分区函数了  
 
 
  • 1
4. job.setInputFormatClass(KeyValueTextInputFormat.class); 注意里面是KeyValueTextInputFormat.class，而不是TextInputFormat.class。
 
 
  • 1
5. 在集群上，次程序才能体现出来
 
 
  • 1

6.由于我这里，map的输入和输出都是用的(Text,Text),所以我只需要设置

job.setOutputKeyClass(Text.class); 
job.setOutputValueClass(Text.class);
 
 
  • 1
  • 2

如果不一样，那么 应该设置4个,前两个为map的输出类型，后两个为reduce的输出类型

job.setMapOutputKeyClass(Text.class);
job.setMapOutputValueClass(IntWritable.class);
job.setOutputKeyClass(IntWritable.class);
job.setOutputValueClass(NullWritable.class);

MapReduce全排序的方法1:

　　每个map任务对自己的输入数据进行排序，但是无法做到全局排序，需要将数据传递到reduce，然后通过reduce进行一次总的排序，但是这样做的要求是只能有一个reduce任务来完成。

　　并行程度不高，无法发挥分布式计算的特点。

 

MapReduce全排序的方法2：

　　针对方法1的问题，现在介绍方法2来进行改进；

　　使用多个partition对map的结果进行分区，且分区后的结果是有区间的，将多个分区结果拼接起来，就是一个连续的全局排序文件。

　　　　

 

　　Hadoop自带的Partitioner的实现有两种，一种为HashPartitioner, 默认的分区方式，计算公式 hash(key)%reducernum，另一种为TotalOrderPartitioner, 为排序作业创建分区，分区中数据的范围需要通过分区文件来指定。

　　分区文件可以人为创建，如采用等距区间，如果数据分布不均匀导致作业完成时间受限于个别reduce任务完成时间的影响。

　　也可以通过抽样器，先对数据进行抽样，根据数据分布生成分区文件，避免数据倾斜。

　　

这里实现一个通过随机抽样来生成分区文件，然后对数据进行全排序，根据分区文件的范围分配到不同的reducer中。

示例代码：

复制代码 
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.input.KeyValueTextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.mapreduce.lib.partition.InputSampler;
import org.apache.hadoop.mapreduce.lib.partition.TotalOrderPartitioner;

import java.io.IOException;

/**
 * Created by Edward on 2016/10/4.
 */
public class TotalSort {

    public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {

        //access hdfs's user
        System.setProperty("HADOOP_USER_NAME","root");

        Configuration conf = new Configuration();
        conf.set("mapred.jar", "D:\\MyDemo\\MapReduce\\Sort\\out\\artifacts\\TotalSort\\TotalSort.jar");

        FileSystem fs = FileSystem.get(conf);

        /*RandomSampler 参数说明
        * @param freq Probability with which a key will be chosen.
        * @param numSamples Total number of samples to obtain from all selected splits.
        * @param maxSplitsSampled The maximum number of splits to examine.
        */
        InputSampler.RandomSampler<Text, Text> sampler = new InputSampler.RandomSampler<>(0.1, 10, 10);

        //设置分区文件, TotalOrderPartitioner必须指定分区文件
        Path partitionFile = new Path( "_partitions");
        TotalOrderPartitioner.setPartitionFile(conf, partitionFile);

        Job job = Job.getInstance(conf);
        job.setJarByClass(TotalSort.class);
        job.setInputFormatClass(KeyValueTextInputFormat.class); //数据文件默认以\t分割
        job.setMapperClass(Mapper.class);
        job.setReducerClass(Reducer.class);
        job.setNumReduceTasks(4);  //设置reduce任务个数，分区文件以reduce个数为基准，拆分成n段

        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(Text.class);

        job.setPartitionerClass(TotalOrderPartitioner.class);

        FileInputFormat.addInputPath(job, new Path("/test/sort"));

        Path path = new Path("/test/wc/output");

        if(fs.exists(path))//如果目录存在，则删除目录
        {
            fs.delete(path,true);
        }
        FileOutputFormat.setOutputPath(job, path);

        //将随机抽样数据写入分区文件
        InputSampler.writePartitionFile(job, sampler);

        boolean b = job.waitForCompletion(true);
        if(b)
        {
            System.out.println("OK");
        }

    }
}
复制代码

 

测试数据：

复制代码 
1    1
2    1
3    1
4    1
5    1
6    1
7    1
8    1
9    1
10    2
11    2
12    2
13    2
14    2
15    2
16    2
17    2
18    2
19    2
20    2
...
5999    4
6000    4
6001    4
6002    4
6003    4
6004    4
6005    4
6006    4
6007    4
6008    4
6009    4
6010    4
复制代码

抽样生成的分区文件为：

# hadoop fs -text  /user/root/_partitions

　2673 (null)
　4441 (null)
　5546 (null)

生成的抽样文件为sequence file通过 -text打开查看

生成的排序结果文件：

文件内容：

 hadoop fs -cat /test/wc/output/part-r-00000

复制代码 
...
2668    4
2669    4
267     3
2670    4
2671    4
2672    4
复制代码

hadoop fs -cat /test/wc/output/part-r-00001

复制代码 
...
4431    4
4432    4
4433    4
4434    4
4435    4
4436    4
4437    4
4438    4
4439    4
444     3
4440    4
复制代码

hadoop fs -cat /test/wc/output/part-r-00002

复制代码 
...
554     3
5540    4
5541    4
5542    4
5543    4
5544    4
5545    4
复制代码

hadoop fs -cat /test/wc/output/part-r-00003

复制代码 
...
99      2
990     3
991     3
992     3
993     3
994     3
995     3
996     3
997     3
998     3
999     3
复制代码

测试文本

ba bac
df gh hgg dft dfa dfga df fdaf qqq we fsf aa bb ab
rr
ty ioo zks huawei mingtong jyzt beijing shanghai shenzhen wuhan nanning guilin 
zhejiang hanzhou anhui hefei xiaoshan xiaohao anqian zheli guiyang
 
 
  • 1
  • 2
  • 3
  • 4
  • 5

原理分析

利用mapReduce中map到reduce端的shuffle进行排序，MapReduce只能保证各个分区内部有序，但不能保证全局有序，于是我还自定义了分区，在map后、shuffle之前，我先将小于c的放在0分区，c-f的放在1分区，其余的放在2分区，这样，首先保证了分区与分区之间是整体有序，然后各个分区进行各自的shuffle，使其分区内部有序。

代码

package com.myhadoop.mapreduce.test;

import org.apache.hadoop.conf.Configured;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapred.Mapper;
import org.apache.hadoop.mapred.OutputCollector;
import org.apache.hadoop.mapreduce.Partitioner;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapred.Reporter;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.util.Tool;
import org.apache.hadoop.util.ToolRunner;
import java.io.IOException;

/**
 * Created by kaishun on 2017/6/10.
 */
public class TotalSortTest extends Configured implements Tool{

    public static class myMap extends org.apache.hadoop.mapreduce.Mapper<LongWritable, Text, Text, Text>{

        public void map(LongWritable key,Text value,Context context) throws IOException,InterruptedException{
            String[] split = value.toString().split("\\s+");
            for (int i = 0; i <split.length ; i++) {
                Text word = new Text(split[i]);
                context.write(word,new Text(""));
            }
        }
    }
    public static class myReduce extends Reducer<Text,Text,Text,Text>{

        public void reduce(Text key, Iterable<Text> values,Context context) throws IOException,InterruptedException
        {
                context.write(key, new Text(""));

        }
    }
    public static class Partition extends Partitioner<Text,Text>{
        @Override
        public int getPartition(Text value1, Text value2, int i) {

            if(value1.toString().compareTo("c")<0){
                return 0;
            }else if(value1.toString().compareTo("f")<0){
                return 1;
            }
            return 2;
        }
    }



    @Override
    public int run(String[] args) throws Exception {
        Job job = Job.getInstance(getConf());
        job.setJarByClass(TotalSort.class);
        job.setJobName("TotalSortTest");
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(Text.class);

        job.setPartitionerClass(Partition.class);
        job.setMapperClass(myMap.class);
        job.setReducerClass(myReduce.class);
        job.setNumReduceTasks(3);

        FileInputFormat.setInputPaths(job, new Path(args[0]));
        FileOutputFormat.setOutputPath(job, new Path(args[1]));

        boolean success = job.waitForCompletion(true);
        return success ? 0:1;
    }
    public static void main(String[] args) throws Exception {
        int ret = ToolRunner.run(new TotalSortTest(), args);
        System.exit(ret);
    }
}

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83

测试结果

生成了三个文件part-r-00000，part-r-00001，part-r-00002 
各个分区之间有顺序，分区内部也有顺序，分别为

aa  
ab  
anhui   
anqian  
ba  
bac 
bb  
beijing 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
df  
dfa 
dfga    
dft 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
fdaf    
fsf 
gh  
guilin  
guiyang 
hanzhou 
hefei   
hgg 
huawei  
ioo 
jyzt    
mingtong    
nanning 
qqq 
rr  
shanghai    
shenzhen    
ty  
we  
wuhan   
xiaohao 
xiaoshan    
zhejiang    
zheli   
zks 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26

总结

mapreduce的shuffle是对key值得hashcode进行排序的，所以单词的全排序也是一样的，类似于数据库中的order by 一样， 利用自定义分区，保证整体有序，利用mapreduce内部的shuffle，对key进行排序，保证了局部有序，从而实现了全排序


首席撩妹指导官
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Hadoop全局排序(TotalOrderPartitioner)的若干坑点
KylnMonkey的博客
09-09 1455
罗列一些在使用全局排序中的一些坑点，以及解决办法。 1、因错误分区数量而无法读取分区文件 Error: java.lang.IllegalArgumentException: Can't read partitions file at org.apache.hadoop.mapreduce.lib.partition.TotalOrderPartitioner.setConf(Tot...
Hadoop 的 TotalOrderPartitioner
weixin_33872566的博客
06-27 136
http://blog.oddfoo.net/2011/04/17/mapreduce-partition%E5%88%86%E6%9E%90-2/ Partition所处的位置Partition位置Partition主要作用就是将map的结果发送到相应的reduce。这就对partition有两个要求：1）均衡负载，尽量的将工作均匀的分配给不同的reduce。2）效率，分配速度一定要快。Mapr...
（hadoop学习－3）Total Order Partitioner
06-15 1389
总结mapreduce的TotalOrderPartition方法，提供具体流程和关键代码实现。
大数据工具资料收集之hadoop.pdf
最新发布
11-16
大数据工具资料收集之hadoop.pdf
网站案例分析及Hadoop分布式集群环境（全套视频+课件+代码+讲义+工具）
02-20
04_案例：网站基本指标分析（一） 05_案例：网站基本指标分析（二） 06_分布式安装部署：克隆虚拟机及配置网络 07_分布式安装部署：集群基本配置及服务运行规划 08_分布式安装部署：集群机器时间同步 09_分布式安装...
hadoop自动化运维工具Ambari应用实践
07-01
Apache Ambari是一种基于Web的运维工具，支持Apache Hadoop集群的自动化部署、管理和监控。Ambari目前已支持大多数Hadoop组件，包括HDFS、MapReduce、Hive、Pig、 Hbase、Zookeeper、Sqoop和Hcatalog等。     ...
Hadoop简单应用案例
06-04
这个"**Hadoop简单应用案例**"涵盖了Hadoop生态系统中的多个关键组件，包括MapReduce、HDFS、Zookeeper以及Hive，这些都是大数据处理的核心工具。下面将详细讲解这些知识点。 1. **MapReduce**：MapReduce是Hadoop...
Hadoop对文本文件的快速全局排序实现方法及分析
01-10
一、背景 Hadoop中实现了用于全局排序的InputSampler类和TotalOrderPartitioner类，调用示例是org.apache.hadoop.examples.Sort。 但是当我们以Text文件作为输入时，结果并非按Text中的string列排序，而且输出结果是SequenceFile。 原因： 1） hadoop在处理Text文件时，key是行号LongWritable类型，InputSampler抽样的是key，TotalOrderPartitioner也是用key去查找分区。这样，抽样得到的partition文件是对行号的抽样，结果自然是根据行号来排序。
MapReduce TotalOrderPartitioner 全局排序
yukangkk的技术博客
07-01 8798
我们知道Mapreduce框架在feed数据给reducer之前会对map output key排序，这种排序机制保证了每一个reducer局部有序，hadoop 默认的partitioner是HashPartitioner，它依赖于output key的hashcode，使得相同key会去相同reducer，但是不保证全局有序，如果想要获得全局排序结果（比如获取top N, bottom N），
hdfs使用随机采样器进行分区划分实现全排序，totalOrderPartitioner,sampler
fantasticqiang的博客
06-07 645
问题描述现在有个sequenceFile文件里面记录着年份和温度，key是年份value是温度，找出每年的最高气温然后按照年份递增排序。因为reducer默认会对key进行排序，解决办法有两种：第一种使用一个reducer，第二种是使用分区函数对年份进行分段，在每一个段是递增排序，几个reducer处理后的文件拼接后在整体上也是有序的。自定义的Mapper只需要把key-value发往Reduce...
(转载)Hadoop常用SDK系列五 TotalOrderPartitioner
weixin_33915554的博客
12-06 62
在0.19.0以前的版本中，Hadoop自身并没有提供全排序的solution，如果使用缺省的partitioner（HashPartitioner)每个reducer的输出自身是有序的，但是多个reducer的输出文件之间不存在全序的关系；如果想实现全排序，需要自己实现Partitioner，比如针对key为Mac地址的Partitioner，如假定Mac地址的分布是均匀的，可以根据Mac地址的...
hadoop编程小技巧（4）---全局key排序类TotalOrderPartitioner
fansy1990的专栏
07-18 4241
Hadoop代码测试版本：Hadoop2.4原理：在进行MR程序之前对输入数据进行随机提取样本，把样本排序，然后在MR的中间过程Partition的时候使用这个样本排序的值进行分组数据，这样就可以达到全局排序的目的了。难点：如果使用Hadoop提供的方法来实现全局排序，那么要求Mapper的输入、输出的key不变才可以，因为在源码InputSampler中提供的随机抽取的数据是输入数据最原始的ke
MapReduce TotalOrderPartitioner 全局排序<转>
yongjian_luo的专栏
03-04 640
我们知道Mapreduce框架在feed数据给reducer之前会对map output key排序，这种排序机制保证了每一个reducer局部有序，Hadoop 默认的partitioner是HashPartitioner，它依赖于output key的hashcode，使得相同key会去相同reducer，但是不保证全局有序，如果想要获得全局排序结果（比如获取top N, bottom N
Hadoop深入学习：Hadoop全排序中的Sampler采样器
飞翔的荷兰人
05-28 247
在[url=http://flyingdutchman.iteye.com/blog/1876582]Partitioner组件的设计与实现[/url]中，我们已经了解过Partitioner组件的其中一个和全排序相关的实现类——TotalOrderPartitioner。 我们知道，在Hadoop中，最终的处理结果集中的数据，除非就由一个Reduce Task处...
hadoop实现全局排序的思路
zongquanliu的专栏
05-19 743
排序思路 借鉴快速排序的思路：假设为升序排序，那么每完成一次partition，pivot左边所有元素的值都小于等于pivot，而pivot右边的所有元素的值都大于等于pivot，如果现在有N个pivot，那么数据就被map成了N+1个区间，让reducer个数等于N+1，将不同区间的数据发送到相应区间的reducer；hadoop利用shuffle操作将这N+1份数据自动排序，reduce操作
MR 使用自带TotalOrderPartitioner类进行全排序的时候输出的out文件没有东西
weixin_43548589的博客
11-09 252
主要是因为job设置没有设置好先后顺序 Configuration conf = new Configuration(); Job job = Job.getInstance(conf); job.setJobName(&amp;quot;app&amp;quot;); job.setJarByClass(app.class); job.setInputFormatClass(SequenceFileInpu...
Hadoop开发者入门：开启2010年技术探索之旅
《Hadoop开发者入门》专刊于2010年1月首次发行，由Hadoop技术论坛主办，旨在为Hadoop领域的初学者提供指导和支持。本文档的背景是Hadoop技术的兴起和迅速发展，由开源精神推动，特别是大师级人物Doug Cutting的贡献...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值