打怪升级之小白的大数据之旅(五十)＜MapReduce框架原理二:shuffle＞

最新推荐文章于 2024-10-02 22:58:44 发布
最新推荐文章于 2024-10-02 22:58:44 发布
阅读量127 收藏
点赞数
文章标签： 大数据 hadoop mapreduce shuffle java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Li_G_yuan/article/details/116951505
版权

打怪升级之小白的大数据之旅(五十)

MapReduce框架原理二:shuffle

上次回顾

上一章。我们学习了Hadoop中MapReduce框架原理中的工作流程以及InputFormat模块，本章我为大家带来shuffle

shuffle机制

shuffle工作机制

  • 在上一章开篇MapReduce框架整体认知中，我们了解了MapReduce的模块构成，当时我只是提了一下shuffle，它的工作内容是map阶段的后半段以及reduce的前半段
  • Map方法之后，Reduce方法之前的数据处理过程称之为Shuffle
    在这里插入图片描述

shuffle的工作流程如下：

  • 上面这张图，就是shuffle的工作内容，当我们的数据通过map方法之后，数据会进入到环形缓冲区中
  • 数据中包含了key,value和分区号，分区号=hashcode(key)%reduceTask的数量
  • 环形缓冲区底层就是数组，它里面会存储数据和索引，并预留20%的位置用于写入数据，其他80%位置它会将数据进行分区，然后排序
  • 分区就是在map进入环形缓冲区之前进行，会对数据分配一个分区号，环形缓冲区通过这个分区号进行分区，排序就是对该分区中的数据进行排序，排序是按照快速排序进行的
  • 当数据写满了80%就会对数据进行排序，排序后会将数据以文件形式写入到磁盘上
  • 接着会对磁盘上的文件进行合并，然后进行归并排序，因为前面排过序，所以速度会很快
  • 归并排序后的数据会交给reduce
  • resuce会将数据进行拷贝到内存中，如果内存不够就溢出写入到磁盘上，然后对每个map来的数据进行归并排序，按照相同的key进行分组
  • 分组之后就会调用reduce方法做下一步处理

partition分区

  • 在前面我们知道，数据通过map后，进入环形缓冲区时，会为数据分配分区号，进入环形缓冲区后，对数据进行分区
  • 默认分区是根据key的hashcode值然后对reduceTask数量进行取模得到的，用户没有办法控制key存储到哪个分区
  • 所以我们需要进行自定义分区

自定义分区

语法步骤:

  1. 自定义类继承自Partitioner,重写Partition方法

    public class CustomPartitioner extends Partitioner<key,value>{
	@Override
	public int getPartition(Text text, FlowBean flowBean, int i) {
        String phone = text.toString();
}

  2. 在Job驱动中，设置自定义的Partitioner

    job.setPartitionerClass(MyFlowPartition.class);

  3. 自定义Partition后，还需要根据自定的分区逻辑设置相应数量的ReduceTask

     job.setNumReduceTasks(5);

Partition分区案例实操

  • 需求

    • 还是前面序列化的需求，统计下面数据中的上行、下行总流量
    • 然后将下面测试数据中的手机号按照136、137、138、139开头都分别放到一个独立的4个文件中，其他开头的放到一个文件中

  • 测试数据

    1	13736230513	192.196.100.1	www.company.com	2481	24681	200
2	13846544121	192.196.100.2			264	0	200
3 	13956435636	192.196.100.3			132	1512	200
4 	13966251146	192.168.100.1			240	0	404
5 	18271575951	192.168.100.2	www.company.com	1527	2106	200
6 	84188413	192.168.100.3	www.atguigu.com	4116	1432	200
7 	13590439668	192.168.100.4			1116	954	200
8 	15910133277	192.168.100.5	www.hao123.com	3156	2936	200
9 	13729199489	192.168.100.6			240	0	200
10 	13630577991	192.168.100.7	www.shouhu.com	6960	690	200
11 	15043685818	192.168.100.8	www.baidu.com	3659	3538	200
12 	15959002129	192.168.100.9	www.company.com	1938	180	500
13 	13560439638	192.168.100.10			918	4938	200
14 	13470253144	192.168.100.11			180	180	200
15 	13682846555	192.168.100.12	www.qq.com	1938	2910	200
16 	13992314666	192.168.100.13	www.gaga.com	3008	3720	200
17 	13509468723	192.168.100.14	www.qinghua.com	7335	110349	404
18 	18390173782	192.168.100.15	www.sogou.com	9531	2412	200
19 	13975057813	192.168.100.16	www.baidu.com	11058	48243	200
20 	13768778790	192.168.100.17			120	120	200
21 	13568436656	192.168.100.18	www.alibaba.com	2481	24681	200
22 	13568436656	192.168.100.19			1116	954	200

  • 编写思路

    • 还是上一章中序列化的案例实操，统计流量，这个流程就不再赘述了，这个案例多了一个按手机号的分区，我们直接定义一个Paritioner类，然后在Driver中注册一下，并定义好ReduceTask数量就好了

编写代码如下：

  • FlowBean.java

    package com.company.partition1;

import org.apache.hadoop.io.Writable;

import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;

/*
    自定义一个类并实现Hadoop的序列化框架

    步骤：
        1.自定义类并实现Writable接口
        2.重写wrtie和readFileds方法
        3.注意：读取数据时必须和写的顺序保持一致
 */
public class FlowBean implements Writable {
    private long upFlow;
    private long downFlow;
    private long sumFlow;

    public FlowBean() {
    }

    public FlowBean(long upFlow, long downFlow) {
        this.upFlow = upFlow;
        this.downFlow = downFlow;
        this.sumFlow = upFlow + downFlow;
    }

    /*
            序列化时调用的方法
         */
    public void write(DataOutput out) throws IOException {
        out.writeLong(upFlow);
        out.writeLong(downFlow);
        out.writeLong(sumFlow);
    }

    /*
        反序列化时调用的方法
     */
    public void readFields(DataInput in) throws IOException {
        //注意：读取数据时必须和写的顺序保持一致
        upFlow = in.readLong();
        downFlow = in.readLong();
        sumFlow = in.readLong();
    }

    @Override
    public String toString() {
        return upFlow + " " + downFlow + " " + sumFlow;
    }

    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;
    }
}

  • FlowDriver.java

    package com.company.partition;

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 {
        Job job = Job.getInstance(new Configuration());

        /*
            默认情况下 ：  分区数量 = ReduceTask的数量 （正常情况下）
                        分区数量 < ReduceTask的数量 : 会浪费资源--多出来的ReduceTask没有数据可以处理
                        分区数量 > ReduceTask的数量 ：会报错
         */
        //设置ReduceTask的数量
        job.setNumReduceTasks(5);
        //设置使用自定义的分区类
        job.setPartitionerClass(MyPartitioner.class);

        job.setMapperClass(FlowMapper.class);
        job.setReducerClass(FlowReducer.class);
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(FlowBean.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(FlowBean.class);
        FileInputFormat.setInputPaths(job,new Path("D:\\io\\input2"));
        FileOutputFormat.setOutputPath(job,new Path("D:\\io\\output2"));
        job.waitForCompletion(true);
    }
}

  • FlowMapper.java

    package com.company.partition;

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

import java.io.IOException;

/*
    作用 ：用来实现需要在MapTask中实现的功能

    Mapper<KEYIN, VALUEIN, KEYOUT, VALUEOUT>:
        两组：
            第一组：
                KEYIN ：读取数据的偏移量的类型
                VALUEIN ： 读取的一行一行的内容的类型
            第二组：
                 KEYOUT ： 写出的Key的类型（在这指的是手机号）
                 VALUEOUT ：写出的Value的类型（在这指的是存储流量数据的对象）
 */
public class FlowMapper extends Mapper<LongWritable,Text, Text, FlowBean> {
    /**
     * 在map方法中去实现需要在MapTask中实现的功能
     * 注意：map方法在被循环调用（MR框架-MapTask程序）
     *      每调用一次就会传入一行内容
     * @param key ：读取数据的偏移量
     * @param value ：读取的一行一行的内容
     * @param context ：上下文（在这用来通过上下文将K,V写出）
     * @throws IOException
     * @throws InterruptedException
     */
    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        //1.将内容进行切割
        String[] line = value.toString().split("\t");
        //2.封装K,V
        Text outKey = new Text(line[1]);
        FlowBean outValue = new FlowBean(Long.parseLong(line[line.length - 3]),
                Long.parseLong(line[line.length - 2]));
        //3.写出K,V
        context.write(outKey,outValue);
    }
}

  • FlowReducer.java

    package com.company.partition;

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

import java.io.IOException;

/*
    作用 ：用来实现需要在RedcueTask中实现的功能

    Reducer<KEYIN, VALUEIN, KEYOUT, VALUEOUT>
        两组：
            第一组：
                KEYIN ：读取的Key的类型（Mapper输出的Key的类型）
                VALUEIN ：读取的Value的类型（Mapper输出的Value的类型）
            第二组：
                KEYOUT ：输出的Key的类型（在这指的是单词）
                VALUEOUT ：输出的Value的类型（在这指的是单词的数量）

 */
public class FlowReducer extends Reducer<Text, FlowBean,Text, FlowBean> {

    /**
     * 在reduce方法中去实现需要在ReduceTask中实现的功能
     * 注意：：reduce方法在被循环调用（MR框架-ReduceTask程序）
     *      每调用一次就会传入一组数据（key值相同为一组）
     * @param key ：读取的key值
     * @param values ：一组数据中所有的value
     * @param context : 上下文（在这用来将K,V写出去）
     * @throws IOException
     * @throws InterruptedException
     *
     * key                 value
     * 153211111111     100 200 300
     * 153211111111     80  20  100
     * 153211111111     80  20  100
     */
    @Override
    protected void reduce(Text key, Iterable<FlowBean> values, Context context) throws IOException, InterruptedException {
        long sumUpFlow = 0;//总上行流量
        long sumDowFlow = 0;//总下行流量
        //遍历所有的value
        for (FlowBean value : values) {
            sumUpFlow += value.getUpFlow();
            sumDowFlow += value.getDownFlow();
        }
        //2.封装K,V
        FlowBean outValue = new FlowBean(sumUpFlow, sumDowFlow);
        //3.写出K,V
        context.write(key,outValue);
    }
}

  • MyPartitioner.java

    package com.company.partition;

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

/*

    Partitioner<KEY, VALUE>
        KEY : map输出的key的类型
        VALUE : map输出的value的类型
 */
public class MyPartitioner extends Partitioner<Text,FlowBean> {
    /**
     * 返回分区号
     * @param text  map输出的key
     * @param flowBean map输出的value
     * @param numPartitions ReduceTask的数量
     * @return
     */
    public int getPartition(Text text, FlowBean flowBean, int numPartitions) {

        String phoneNumber = text.toString();
        //判断手机号
        if (phoneNumber.startsWith("136")){
            return 0;
        }else if (phoneNumber.startsWith("137")){
            return 1;
        }else if (phoneNumber.startsWith("138")){
            return 2;
        }else if (phoneNumber.startsWith("139")){
            return 3;
        }else{
            return 4;
        }


    }
}

WritableComparable排序

  • 排序是MapReduce中最重要的操作之一
  • 具体的排序流程我在本章的开篇讲过了，MapTask和ReduceTask都会对数据按照key进行排序，默认的排序是按照字典的顺序进行排序，且实现排序的方法是快排
  • 排序的思想就是在Java学习map集合时，我们学习的comparable和comparator，忘了的小伙伴可以回看前面集合的内容哈
  • 在我们的实际需求中，同样需要自定义排序，自定义排序需要实现WritableComparable接口，下面我们再次根据手机流量的案例进行排序的使用

WritableComparable案例实操

在前面Partition分区的基础上，对数据按照手机的总流量进行排序，我们只需要修改一下我们的FlowBean即可

  • FlowBean.java
    package com.company.comparable;

import org.apache.hadoop.io.WritableComparable;

import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;

/*
    自定义类的对象可以作为key进行排序：

    要求：
        1.自定义的类实现WritableComparable
        2.WritableComparable<T> 继承了 Writable接口和Comparable接口
        3.重写compareTo方法，readFileds方法，write方法

 */
public class FlowBean implements WritableComparable<FlowBean> {
    private long upFlow;
    private long downFlow;
    private long sumFlow;

    public FlowBean() {
    }

    public FlowBean(long upFlow, long downFlow,long sumFlow) {
        this.upFlow = upFlow;
        this.downFlow = downFlow;
        this.sumFlow = sumFlow;
    }

    /*
        指定按照哪个字段进行排序
     */
    public int compareTo(FlowBean o) {
        //按照sumFlow排序
        return Long.compare(this.sumFlow,o.sumFlow);
    }

    /*
            序列化时调用的方法
         */
    public void write(DataOutput out) throws IOException {
        out.writeLong(upFlow);
        out.writeLong(downFlow);
        out.writeLong(sumFlow);
    }

    /*
        反序列化时调用的方法
     */
    public void readFields(DataInput in) throws IOException {
        //注意：读取数据时必须和写的顺序保持一致
        upFlow = in.readLong();
        downFlow = in.readLong();
        sumFlow = in.readLong();
    }

    @Override
    public String toString() {
        return upFlow + " " + downFlow + " " + sumFlow;
    }

    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;
    }


}

Combiner合并

  • Combiner是MR程序中Mapper和Reducer之外的一个组件

  • Combiner的父类就是Reduce

  • 它的作用就是在Reduce之前进行数据的合并，它会对每一个MapTask的输出进行局部汇总，这样就可以减小网络传输的量

  • 举个栗子
    在这里插入图片描述

  • 还是以我们前面的分芝麻案例举例，假设我们的芝麻有上千个分区，即

    黑芝麻：
1
2
100
200
1000
50
60
.....
一千个

  • 此时我们的Reduce工作量就会比较大，它会将每一个分区进行挨个的合并，如果我们使用Combiner在MapTask输出时就对数据进行合并，那么Reduce的工作量就会少很多

  • 当然了，我们要注意，不是所有的地方都可以使用Combiner，它的应用场景就是用在不会对最终结果产生变化的场景下使用，这个很好理解，因为Combiner是在Reduce之前调用的，如果Combiner对数据进行了局部汇总，那么Reduce再次进行数据汇总时就有可能出现数据的偏差，举个栗子：
    在这里插入图片描述

Combiner合并实例

以前面我们的写的wordcount举例

Combiner的实现有两种方式：

  • 第一种

    • 增加一个自定义的Combiner类，继承自Reducer
    • 在自定义Combiner类中进行数据的汇总，然后输出统计结果
      // 指定需要使用combiner，以及用哪个类作为combiner的逻辑
job.setCombinerClass(WordcountCombiner.class);

  • 第二种将Reducer类作为Combiner在Driver驱动类中指定

    //设置Combiner的类
job.setCombinerClass(WordcountReducer.class);

我们继续通过一个实例来说明Combiner的用法，第二种直接就是将Reducer传入到job驱动中，我就不演示了，我就演示第一种，自定义的方法

编码步骤：
前面wordcount的代码基础上，修改一下Driver类，添加一个WcCombiner自定义合并类

  • WCCombiner.java

    package com.company.combiner;

import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;

import java.io.IOException;


public class WCCombiner extends Reducer<Text, LongWritable,Text,LongWritable> {
    //输出的value在这用来设置单词的数量
    private LongWritable outValue = new LongWritable();
    /**
     * 在reduce方法中去实现需要在ReduceTask中实现的功能
     * 注意：：reduce方法在被循环调用（MR框架-ReduceTask程序）
     *      每调用一次就会传入一组数据（key值相同为一组）
     * @param key ：读取的key值
     * @param values ：一组数据中所有的value
     * @param context : 上下文（在这用来将K,V写出去）
     * @throws IOException
     * @throws InterruptedException
     */
    @Override
    protected void reduce(Text key, Iterable<LongWritable> values, Context context) throws IOException, InterruptedException {
        long sum = 0;
        //1.累加所有的value
        for (LongWritable value : values) {
            //将LongWritable转换成long
            long v = value.get();
            sum += v;
        }
        //2.封装K,V
        //设置单词的数量
        outValue.set(sum);
        //3.写出K,V
        context.write(key,outValue);
    }
}

  • WCDriver.java

    package com.company.combiner;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.LongWritable;
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 WCDriver {
    public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
        Job job = Job.getInstance(new Configuration());

        //设置Combiner的类
        job.setCombinerClass(WCCombiner.class);

        job.setJarByClass(WCDriver.class);
        job.setMapperClass(WCMapper.class);
        job.setReducerClass(WCReducer.class);
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(LongWritable.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(LongWritable.class);
        FileInputFormat.setInputPaths(job,new Path("D:\\io\\input"));
        FileOutputFormat.setOutputPath(job,new Path("D:\\io\\output22"));


        boolean result = job.waitForCompletion(true);
        System.exit(result ? 0 : 1);
    }
}

  • WCMapper.java

    package com.company.combiner;

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

import java.io.IOException;

/*
    作用 ：用来实现需要在MapTask中实现的功能

    Mapper<KEYIN, VALUEIN, KEYOUT, VALUEOUT>:
        两组：
            第一组：
                KEYIN ：读取数据的偏移量的类型
                VALUEIN ： 读取的一行一行的内容的类型
            第二组：
                 KEYOUT ： 写出的Key的类型（在这指的是单词）
                 VALUEOUT ：写出的Value的类型（在这指的是单词的数量）
 */
//自定义的类想要实现MapTask中实现的功能必须继承Mapper
public class WCMapper extends Mapper<LongWritable, Text,Text,LongWritable> {
    //key中存放的就是单词
    private Text outKey = new Text();
    //value中存放的是单词的数量
    private LongWritable outValue = new LongWritable();
    /**
     * 在map方法中去实现需要在MapTask中实现的功能
     * 注意：map方法在被循环调用（MR框架-MapTask程序）
     *      每调用一次就会传入一行内容
     * @param key ：读取数据的偏移量
     * @param value ：读取的一行一行的内容
     * @param context ：上下文（在这用来通过上下文将K,V写出）
     * @throws IOException
     * @throws InterruptedException
     */
    @Override
    protected void map(LongWritable key, Text value, Context context)
            throws IOException, InterruptedException {
        //1.将内容进行分割
        //1.1将Text转成字符串为了方便操作
        String line = value.toString();
        String[] words = line.split(" ");
        //2.封装K,V
        for (String word : words) {
            //设置key的值
            outKey.set(word);
            //设置value的值
            outValue.set(1);
            //3.将K,V写出去
            context.write(outKey,outValue);
        }

    }
}

  • WCReducer.java

    package com.company.combiner;

import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;

import java.io.IOException;


public class WCReducer extends Reducer<Text, LongWritable,Text,LongWritable> {
    //输出的value在这用来设置单词的数量
    private LongWritable outValue = new LongWritable();
    /**
     * 在reduce方法中去实现需要在ReduceTask中实现的功能
     * 注意：：reduce方法在被循环调用（MR框架-ReduceTask程序）
     *      每调用一次就会传入一组数据（key值相同为一组）
     * @param key ：读取的key值
     * @param values ：一组数据中所有的value
     * @param context : 上下文（在这用来将K,V写出去）
     * @throws IOException
     * @throws InterruptedException
     */
    @Override
    protected void reduce(Text key, Iterable<LongWritable> values, Context context) throws IOException, InterruptedException {
        long sum = 0;
        //1.累加所有的value
        for (LongWritable value : values) {
            //将LongWritable转换成long
            long v = value.get();
            sum += v;
        }
        //2.封装K,V
        //设置单词的数量
        outValue.set(sum);
        //3.写出K,V
        context.write(key,outValue);
    }
}

总结

好了，shuffle的内容就是这些，案例是为了辅助我们理解shuffle机制的原理，通过案例可以更好的理解MapReduce框架的哈，大家不用太纠结代码的具体实现，重要是理解代码编写的思想下一章，我会为大家带来MapReduce剩下的模块OutputFormat

GaryLea
关注
打怪升级之小白的大数据之旅--hive测试数据
06-03
"打怪升级之小白的大数据之旅--hive测试数据"这个标题，暗示了我们将通过实际操作Hive来学习和探索大数据的奥秘。Hive作为一个基于Hadoop的数据仓库工具，可以将结构化的数据文件映射为一张数据库表，并提供SQL查询...
17_尚硅谷大数据之MapReduce框架原理1
08-03
在Hadoop中，MapReduce实现了一个高效、可扩展的框架，使得开发者可以专注于编写map和reduce函数，而框架负责任务调度、数据分发和结果整合。 **3.1 MapReduce工作流程** 1. **提交阶段**：客户端将应用程序（包括...
大数据管理与监控：Ambari：MapReduce原理与实践.docx
09-02
大数据管理与监控：Ambari：MapReduce原理与实践.docx
大数据技术原理及应用课实验5 :MapReduce初级编程实践
01-16
**大数据技术原理及应用——MapReduce初级编程实践** MapReduce是一种分布式计算模型，由Google提出，主要用于处理和生成大规模数据集。在这个实验中，我们将学习如何利用MapReduce编程解决实际问题，包括数据去重...
Kafka快速实战与基本原理详解
xajh_czbk的博客
09-29 487
消费消息：但是迟迟没有消费（因为kafka默认是从消费者启动之后开始消费，也就是说刚才发的那条消费不到，原因是那个时候消费者还没有启动。）我们现在启动了消费者了，可以尝试发消息了。另一种消费方式：指定从哪里消费。刚才第一次消费的时候没有消费test1，原因上面有写。这里的这个命令就可以消费到全部了,因为指定了从哪里消费。说白了，队列里的消息只能被同一个消费者组里面的一个消费者消费。关键他还可以重复消费。启动好了kafka之后，我们再去看ZK中的节点多了这些。创建一个主题并看一下：有了主题后就可以发消息了。
基于Hive和Hadoop的哔哩哔哩网站分析系统
图南的博客
09-27 682
本项目是一个基于大数据技术的哔哩哔哩平台分析系统，旨在为用户提供全面的哔哩哔哩视频数据和深入的用户行为分析。系统采用 Hadoop 平台进行大规模数据存储和处理，利用 MapReduce 进行数据分析和处理，通过 Sqoop 实现数据的导入导出，以 Spark 为核心进行高效的数据处理。整个系统结合了大数据处理技术，为用户提供精准的内容推荐和深入的用户兴趣分析，帮助平台更好地了解视频趋势和用户需求。
如何实现全行业证照一站式结构化识别？Textln企业资质证照识别上线！
b_qixin的博客
09-26 413
对于无Key的Value信息，例如下图中的证照名称“药品经营许可证”，模型也可基于强大的语义理解能力与所具备的专项领域知识，实现准确完整的关键信息抽取。，并理解信息间的对应关系，以“K-V对”的形式自动实现证照中全部关键信息的结构化抽取，提升信息数据的提取和录入效率。除抽取证照中的文本信息外，模型集成了印章检测能力，可以捕捉资质证照中的印章信息，并输出印章的类型、颜色、形状及内容。自动识别录入企业经营资质信息，可应用于机构开户、经营性贷款审批等金融服务场景，提升信息录入效率，控制业务风险。
【从0开始搭建微服务并进行部署】SpringBoot+dubbo+zookeeper
高朗的博客
09-29 1141
从0开始搭建微服务并进行部署：Springboot+dubbo+zookeeper
实时湖仓架构演变
pointer_future的专栏
09-26 485
缺点是 CDC 入离线数仓产生的文件不好控制，而且由于那个时候 iceberg 还不能支持 upsert (有就update,没有就insert),所以使用 flink CDC(Change Data Capture) 入仓所采用的“前天的一个全量表，合并今天的增量表，产生今天的全量表“的存储方式。而且基于LSM数据结构的特点，只要增量数据不大，两个 TAG 之间是可以复用大量文件的，某些场景有上百倍的节省！缺点是不够灵活，只能查询计算好的聚合数据，想查其他维度或条件的数据，要从头开发一套完整的流程。
当微服务中调度返回大数据量时如何处理
ZDFXN的博客
09-27 610
总之，当需要返回大数据量时，可以根据具体的需求和技术特点选择合适的方案。同时，通过限制每页显示的数据条数，可以减少网络传输的负担。同时，通过分布式计算，可以实现数据的并行处理，提高处理效率。同时，通过异步处理，可以避免阻塞主线程，提高系统的并发能力。适用场景：适用于需要实时处理大量数据的场景，如电商网站的实时交易监控、物联网设备的数据采集等。适用场景：适用于需要展示大量数据列表的场景，如电商平台的商品列表、社交媒体的动态列表等。适用场景：适用于需要频繁读取同一份数据的场景，如用户信息查询、热点数据统计等。
微服务--SpringAMQP
weixin_51933701的博客
09-27 1342
高级消息队列协议，是应用程序之间传递业务消息的开放标准，与语言和平台无关，更符合微服务架构中独立性的要求。：基于AMQP协议定义的一套API规范，提供了模板来发送和接收消息。是基础抽象，是底层的默认实现。SpringAMQP利用SpringBoot实现了自动装配，使用非常方便。
hive/impala/mysql几种数据库的sql常用写法和函数说明
biqidaoer的专栏
09-27 419
做大数据开发的时候，会在几种库中来回跳，同一个需求，不同库函数和写法会有出入，在此做汇总沉淀。
Hive数仓操作（三）
m0_58076578的博客
09-29 3813
在 Hive 中，有多种类型的表，主要包括：内部表（Managed Table）：默认的表类型。创建时，Hive 会在默认的 warehouse 目录中创建一个以表名命名的目录，并将数据存储在该目录下。 当删除内部表时，表结构和数据都将被删除。 外部表（External Table）： 创建时，Hive 不会管理数据的存储位置。数据可以存储在 HDFS 中的任何位置。 删除外部表时，只删除表结构，而不会删除数据。
【大数据】大数据运维方案浅析总结
wnm23的专栏
09-27 966
流行的大数据运维管理，包括Cloudera的CDH和CDP、Hortonworks的HDP、Apache的Ambari、国产开源平台Datasophon，以及自动化运维工具Ansible和SaltStack。
Python/大数据/机器识别毕业设计选题题目推荐
初尘屿风的博客
09-27 1010
基于Python和Diango在线购物商城系统+报告文档+指导搭建视频基于深度学习的人脸识别与管理系统，Python实现基于Python/机器学习链家网新房数据可视化及预测系统Python豆瓣电影情感分析推荐系统+爬虫+可视化，过滤算法基于python的django框架生鲜商城管理系统设计与实现基于Python的Flask微博话题舆情分析可视化系统设计基于Python豆瓣电影数据可视化分析系统+毕业论文+指导搭建视频基于Python天气预报数据可视化分析系统+毕业论文基于Python的深度学习音乐推荐系统+
Elasticsearch基础_5.ES聚合功能
qq_43563660的博客
10-02 323
ES聚合学习记录
消息队列RabbitMQ
最新发布
weixin_43364551的博客
10-02 798
RabbitMQ是基于Erlang语言开发的开源消息通信中间件，支持AMQP，XMPP，SMTP，STOMP协议，消息延迟时微秒级别的。Ubuntu系统RabbitMQ的安装。
Elasticsearch学习笔记(2）
m0_74293254的博客
09-28 1130
创建索引: 使用 PUT 请求来定义索引及其映射。创建文档: 使用 POST 请求将数据添加到索引。读取文档: 使用 GET 请求获取特定文档。更新文档: 使用 POST 加上 _update 操作来修改现有文档。删除文档: 使用 DELETE 请求删除指定文档。删除索引: 使用 DELETE 请求删除整个索引。请求方式：POST请求格式：/{索引库名}/_doc/文档id示例：POST /my_index/_doc/1 { "field": "value" }
"MapReduce原理和应用：大数据存储与处理技术解析
一份共24页的pptx文件深入介绍了Hadoop技术的原理及应用，主要包括MapReduce概述及原理、InputFormat、OutputFormat、MapReduce切片解析、MapReduce的shuffle原理、MapReduce的序列化、MapReduce的优化等内容。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值