2022-07-13 MapReduce应用

最新推荐文章于 2024-07-26 12:28:02 发布
最新推荐文章于 2024-07-26 12:28:02 发布
阅读量71 收藏
点赞数
分类专栏： 大数据学习 文章标签： mapreduce java 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/d___h/article/details/125763541
版权

一、表连接操作(Join)

  1. Reduce Join
    (1) 缺点：容易造成数据倾斜。当造成数据倾斜以后，需要根据具体的业务场景进行更加细致的分区。
    (2) 案例：
                场景：order.txt中已经存储多条订单信息，product.txt存储了产品信息，现在要求将两个文件中的信息连接起来。

    # 每个文件中的各字段都用制表符分割

# order.txt文件中的内容
orderId	pid	amount
1001	01	2

# product.txt文件中的内容
pid	pname
01	小米

# order.txt和product.txt连接后生成的文件中的信息
orderId	pname amount
1001	小米   2

                代码实现如下：
                引入依赖：

        <dependencies>
        <!-- junit测试依赖坐标 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <!-- 日志依赖坐标 -->
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-slf4j-impl</artifactId>
            <version>2.12.0</version>
        </dependency>
        <!-- hadoop依赖坐标 -->
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-client</artifactId>
            <version>3.1.3</version>
        </dependency>
    </dependencies>

                在resources下写配置文件：

    <!-- 配置文件名为：log4j2.xml -->
<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="error" strict="true" name="XMLConfig">
    <Appenders>
        <!-- 类型名为Console，名称为必须属性 -->
        <Appender type="Console" name="STDOUT">
            <!-- 布局为PatternLayout的方式，
            输出样式为[INFO] [2018-01-22 17:34:01][org.test.Console]I'm here -->
            <Layout type="PatternLayout"
                    pattern="[%p] [%d{yyyy-MM-dd HH:mm:ss}][%c{10}]%m%n" />
        </Appender>

    </Appenders>

    <Loggers>
        <!-- 可加性为false -->
        <Logger name="test" level="info" additivity="false">
            <AppenderRef ref="STDOUT" />
        </Logger>

        <!-- root loggerConfig设置 -->
        <Root level="info">
            <AppenderRef ref="STDOUT" />
        </Root>
    </Loggers>
</Configuration>

                封装ComplexItem

    import org.apache.hadoop.io.Writable;

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

/**
 * 该类用于封装order.txt和product.txt中的各字段
 */
public class ComplexItem implements Writable {
    // 该对象中的数据来自于哪一个文件
    private String from = "";

    private Integer orderId = 0;
    private String pid = "";
    private String pname = "";
    private Integer amount = 0;

    // 空参构造方法，必须存在
    public ComplexItem() {
    }

    public Integer getOrderId() {
        return orderId;
    }

    public String getPid() {
        return pid;
    }

    public String getPname() {
        return pname;
    }

    public Integer getAmount() {
        return amount;
    }

    /**
     * 为该对象中来自order.txt的数据赋值，并且标识该对象存储了来自order的数据
     * @param orderId orderId
     * @param pid pid
     * @param amount amount
     */
    public void setOrderFields(Integer orderId, String pid, Integer amount){
        this.from = "order";
        this.orderId = orderId;
        this.pid = pid;
        this.amount = amount;
    }

    /**
     * 为该对象中来自product.txt的数据赋值，并且标识该对象存储了来自product的数据
     * @param pid pid
     * @param pname pname
     */
    public void setProductFields(String pid, String pname){
        this.from = "product";
        this.pid = pid;
        this.pname = pname;
    }

    /**
     * 判断该对象中的数据是否来自order.txt
     * @return 来自order.txt => true、否则 => false
     */
    public boolean isFromOrder(){
        return "order".equalsIgnoreCase(from);
    }

    @Override
    public void write(DataOutput out) throws IOException {
        out.writeUTF(this.from);
        out.writeInt(this.orderId);
        out.writeUTF(this.pid);
        out.writeUTF(this.pname);
        out.writeInt(this.amount);
    }

    @Override
    public void readFields(DataInput in) throws IOException {
        this.from = in.readUTF();
        this.orderId = in.readInt();
        this.pid = in.readUTF();
        this.pname = in.readUTF();
        this.amount = in.readInt();
    }

    @Override
    public String toString() {
        return this.orderId + "\t" + this.pname + "\t" + this.amount;
    }
}

    Mapper

    import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.InputSplit;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.lib.input.FileSplit;

import java.io.IOException;

public class ComplexItemMapper extends Mapper<Object, Text, Text, ComplexItem> {
    // 当前Mapper处理的该切片所属的文件名称
    private String from;

    private Text keyOut = new Text();
    private ComplexItem valueOut = new ComplexItem();


    /**
     * 该方法只会在每一个切片的Mapper阶段的最开始运行一次
     * @param context 上下文对象
     * @throws IOException
     * @throws InterruptedException
     */
    @Override
    protected void setup(Context context) throws IOException, InterruptedException {
    	// 获取切片对象
        InputSplit split = context.getInputSplit();
        // 获取该切片所属文件的文件名称
        from = ((FileSplit)split).getPath().getName();
    }

    @Override
    protected void map(Object key, Text value, Context context) throws IOException, InterruptedException {
        String[] fields = value.toString().split("\t");
        if (from.contains("order")){
            valueOut.setOrderFields(Integer.parseInt(fields[0]), fields[1], Integer.parseInt(fields[2]));
        }else {
            valueOut.setProductFields(fields[0], fields[1]);
        }
        keyOut.set(valueOut.getPid());
        context.write(keyOut, valueOut);
    }
}

    Reducer

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

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class ComplexItemReducer extends Reducer<Text, ComplexItem, ComplexItem, NullWritable> {
    // 缓存每一组key-values中来自order.txt的封装对象
    private List<ComplexItem> orderList = new ArrayList<>();

    private NullWritable valueOut = NullWritable.get();

    @Override
    protected void reduce(Text key, Iterable<ComplexItem> values, Context context) throws IOException, InterruptedException {
        ComplexItem product = new ComplexItem();
        for (ComplexItem value : values) {
            if (value.isFromOrder()){
                ComplexItem order = new ComplexItem();
                order.setOrderFields(value.getOrderId(), value.getPid(), value.getAmount());
                orderList.add(order);
            }else {
                product.setProductFields(value.getPid(), value.getPname());
            }
        }

        for (ComplexItem order : orderList) {
            order.setProductFields(product.getPid(), product.getPname());
            context.write(order, valueOut);
        }

        orderList.clear();
    }
}

    Driver

    import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.NullWritable;
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;
import java.util.Arrays;

public class ComplexItemDriver {
    public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
        Configuration conf = new Configuration();
        Job job = Job.getInstance(conf);
        job.setJarByClass(ComplexItemDriver.class);
        job.setMapperClass(ComplexItemMapper.class);
        job.setReducerClass(ComplexItemReducer.class);
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(ComplexItem.class);
        job.setOutputKeyClass(ComplexItem.class);
        job.setOutputValueClass(NullWritable.class);
        FileInputFormat.setInputPaths(job, Arrays.stream(args).limit(args.length - 1).map(Path::new).toArray(Path[]::new));
        FileOutputFormat.setOutputPath(job, new Path(args[args.length - 1]));
        System.exit(job.waitForCompletion(true) ? 0 : 1);
    }
}

    # 运行方式1：Idea直接运行
# 运行方式2：在集群上运行
hadoop.sh jar xxx.jar xxx.xxx.ComplexItemDriver input-path output-path

  2. Map Join
    (1) 使用场景：适合一张表十分小、另一张表十分大的情况
    (2) 案例：
                场景：同Reduce Join
                引入依赖：

        <dependencies>
        <!-- junit测试依赖坐标 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <!-- 日志依赖坐标 -->
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-slf4j-impl</artifactId>
            <version>2.12.0</version>
        </dependency>
        <!-- hadoop依赖坐标 -->
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-client</artifactId>
            <version>3.1.3</version>
        </dependency>
    </dependencies>

                在resources下写配置文件：

    <!-- 配置文件名为：log4j2.xml -->
<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="error" strict="true" name="XMLConfig">
    <Appenders>
        <!-- 类型名为Console，名称为必须属性 -->
        <Appender type="Console" name="STDOUT">
            <!-- 布局为PatternLayout的方式，
            输出样式为[INFO] [2018-01-22 17:34:01][org.test.Console]I'm here -->
            <Layout type="PatternLayout"
                    pattern="[%p] [%d{yyyy-MM-dd HH:mm:ss}][%c{10}]%m%n" />
        </Appender>

    </Appenders>

    <Loggers>
        <!-- 可加性为false -->
        <Logger name="test" level="info" additivity="false">
            <AppenderRef ref="STDOUT" />
        </Logger>

        <!-- root loggerConfig设置 -->
        <Root level="info">
            <AppenderRef ref="STDOUT" />
        </Root>
    </Loggers>
</Configuration>

                封装OrderDetail

    /**
 * 用来封装order.txt和product.txt进行Join操作后的字段的类
 */
public class OrderDetail {
    private Integer orderId = 0;
    private String pname = "";
    private Integer ammount = 0;

    public OrderDetail() {
    }

    public OrderDetail(Integer orderId, String pname, Integer ammount) {
        this.orderId = orderId;
        this.pname = pname;
        this.ammount = ammount;
    }

    public Integer getOrderId() {
        return orderId;
    }

    public void setOrderId(Integer orderId) {
        this.orderId = orderId;
    }

    public String getPname() {
        return pname;
    }

    public void setPname(String pname) {
        this.pname = pname;
    }

    public Integer getAmmount() {
        return ammount;
    }

    public void setAmmount(Integer ammount) {
        this.ammount = ammount;
    }

    public void setAll(Integer orderId, String pname, Integer ammount){
        setOrderId(orderId);
        setPname(pname);
        setAmmount(ammount);
    }

    @Override
    public String toString() {
        return orderId + "\t" + pname + "\t" + ammount;
    }
}

                Mapper

    import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IOUtils;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URI;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Map;

public class OrderDetailMapper extends Mapper<Object, Text, OrderDetail, NullWritable> {
    // 存储pid和pname的映射
    private Map<String, String> productMapper = new HashMap<>();

    private OrderDetail keyOut = new OrderDetail();
    private NullWritable valueOut = NullWritable.get();

    @Override
    protected void setup(Context context) throws IOException, InterruptedException {
        // 获取缓冲在内存中的文件
        URI[] cacheFiles = context.getCacheFiles();
        if (cacheFiles.length > 0){
            URI productURI = cacheFiles[0];
            FileSystem fs = FileSystem.get(context.getConfiguration());
            BufferedReader reader = new BufferedReader(new InputStreamReader(fs.open(new Path(productURI)), StandardCharsets.UTF_8));
            // 读取product.txt中的数据，并将其放入到mapper中
            String line = null;
            while ((line = reader.readLine()) != null){
                String[] fields = line.split("\t");
                productMapper.put(fields[0], fields[1]);
            }
            // 释放资源
            IOUtils.closeStreams(reader, fs);
        }
    }

    @Override
    protected void map(Object key, Text value, Context context) throws IOException, InterruptedException {
        String[] fields = value.toString().split("\t");
        keyOut.setAll(Integer.parseInt(fields[0]), productMapper.get(fields[1]), Integer.parseInt(fields[2]));
        context.write(keyOut, valueOut);
    }
}

    Driver

    import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.NullWritable;
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;
import java.net.URI;
import java.util.Arrays;

public class OrderDetailDriver {
    public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
        Configuration conf = new Configuration();
        Job job = Job.getInstance(conf);
        job.setJarByClass(OrderDetailDriver.class);
        // 把order.txt文件加载到内存中使用，使用本地文件系统协议：file:///；如果想用集群上的文件，使用：hdfs://
        job.addCacheFile(URI.create("file:///D:/moudle/hadoop_results/mapred/in/reducejoin/pd.txt"));
        job.setMapperClass(OrderDetailMapper.class);
        // 没有Reducer
        job.setNumReduceTasks(0);
        job.setMapOutputKeyClass(OrderDetail.class);
        job.setMapOutputValueClass(NullWritable.class);
        job.setOutputKeyClass(OrderDetail.class);
        job.setOutputValueClass(NullWritable.class);
        FileInputFormat.setInputPaths(job, Arrays.stream(args).limit(args.length -1).map(Path::new).toArray(Path[]::new));
        FileOutputFormat.setOutputPath(job, new Path(args[args.length - 1]));
        System.exit(job.waitForCompletion(true) ? 0 : 1);

    }
}

二、计数器

案例：记录调用map方法的总次数
解决方案：在map方法中添加如下代码

// context.getCounter(组名称, 计数器名称).increment(增加的值)
// 记录会在输出日志中显示
context.getCounter("mapjoin", "mapCount").increment(1);

三、ETL清洗

不需要Reducer阶段

  1. 案例：有一日志文件，每一行都是用空白符(制表符或者空格)分割的众多字段，要求过滤该文件，将字段数大于11的记录过滤出来；

  2. 代码如下：
    引入依赖：

        <dependencies>
        <!-- junit测试依赖坐标 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <!-- 日志依赖坐标 -->
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-slf4j-impl</artifactId>
            <version>2.12.0</version>
        </dependency>
        <!-- hadoop依赖坐标 -->
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-client</artifactId>
            <version>3.1.3</version>
        </dependency>
    </dependencies>

    在resources下写配置文件：

    <!-- 配置文件名为：log4j2.xml -->
<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="error" strict="true" name="XMLConfig">
    <Appenders>
        <!-- 类型名为Console，名称为必须属性 -->
        <Appender type="Console" name="STDOUT">
            <!-- 布局为PatternLayout的方式，
            输出样式为[INFO] [2018-01-22 17:34:01][org.test.Console]I'm here -->
            <Layout type="PatternLayout"
                    pattern="[%p] [%d{yyyy-MM-dd HH:mm:ss}][%c{10}]%m%n" />
        </Appender>

    </Appenders>

    <Loggers>
        <!-- 可加性为false -->
        <Logger name="test" level="info" additivity="false">
            <AppenderRef ref="STDOUT" />
        </Logger>

        <!-- root loggerConfig设置 -->
        <Root level="info">
            <AppenderRef ref="STDOUT" />
        </Root>
    </Loggers>
</Configuration>

    Mapper

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

import java.io.IOException;

public class ETLMapper extends Mapper<Object, Text, Text, NullWritable> {
    private Text keyOut = new Text();
    private NullWritable valueOut = NullWritable.get();

    @Override
    protected void map(Object key, Text value, Context context) throws IOException, InterruptedException {
        String[] fields = value.toString().split("\\s");
        if (fields.length > 11){
            keyOut.set(value);
            context.write(keyOut, valueOut);
        }
    }
}

    Driver

    import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.NullWritable;
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;
import java.util.Arrays;

public class ETLDriver {
    public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
        Configuration conf = new Configuration();
        Job job = Job.getInstance(conf);
        job.setJarByClass(ETLDriver.class);
        job.setMapperClass(ETLMapper.class);
        job.setNumReduceTasks(0);
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(NullWritable.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(NullWritable.class);
        FileInputFormat.setInputPaths(job, Arrays.stream(args).limit(args.length -1).map(Path::new).toArray(Path[]::new));
        FileOutputFormat.setOutputPath(job, new Path(args[args.length - 1]));
        System.exit(job.waitForCompletion(true) ? 0 : 1);
    }
}
D___H
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
MapReduce编程入门--用eclipse创建MapReduce工程
m0_58945994的博客
10-22 4824
这里我用的事eclipse对MapReduce进行编程，首先需要下载相关的eclipse，eclipse可以用于多种语言的开发，这里我们需要用到的是Eclipse IDE for Java EE Developers，不难看出是针对Java开发的安装包。 在eclipse的安装目录中，需要讲插件hadoop-eclipse-plugin-2.6.0（这是我的插件版本）复制到Eclipse安装目录下的dropins这个目录下。 之后在Eclipse中需...
Cosine-Similarity-with-MapReduce:MapReduce 的余弦相似度
06-14
说明 CSMR 算法的论文已在 2014 年人工智能应用和创新 (AIAI 2014) 会议上发表，标题为“CSMR: A Scalable Algorithm for Text Clustering with Cosine Similarity and MapReduce”。纸链接： : 指示安装 Mahout ...
《Hadoop篇》------HDFS与MapReduce
m0_60964321的博客
02-18 2623
Namenode：接受客户端的请求，维护整个HDFS集群目录树，元数据信息的存储由namenode负责Datanode：主要是负责数据块的存储，定期向namenode汇报block：SecondaryNamenode不是第二个namenode，当namenode宕机时，不能由SecondaryNamenode顶替每个切片都是由一个mapTask处理。
大数据技术原理与应用（林子雨）------MapReduce单元测验
m0_46674511的博客
03-30 1957
大数据从入门到实战 - 第3章 MapReduce基础实战
热门推荐
小啊呜的博客
01-13 4万+
大数据从入门到实战 - 第3章 MapReduce基础实战 一、关于此次实践 1、实战简介 2、全部任务 二、实践详解 1、第 1 关：成绩统计 2、第 2 关：文件内容合并去重 3、第 3 关：信息挖掘 - 挖掘父子关系 叮嘟！这里是小啊呜的学习课程资料整理。好记性不如烂笔头，今天也是努力进步的一天。一起加油进阶吧！
Hadoop-分布式并行编程模型MapReduce
wulj666的博客
06-21 2085
MapReduce是一种分布式并行编程模型，用于大规模数据集(大于1 TB)的并行运算，它将复杂的、运行于大规模集群上的并行计算过程高度地抽象到了两个函数Map和Reduce上，并且允许用户在不了解分布式系统底层细节的情况下开发并行应用程序，并将其运行于廉价计算机集群上，完成海量数据的处理。通俗地说，MapReduce的核心思想就是“分而治之”，它把输入的数据集切分为若干独立的数据块，分发给一个主节点管理下的各个分节点来共同并行完成;最后，通过整合各个节点的中间结果得到最终结果。...
Hadoop (十二) --------- MapReduce 概述
在森林里麋了鹿
07-16 970
MapReduce 概述
Hadoop 3.x（MapReduce）----【MapReduce 概述】
在人间负债^
10-09 1112
MapReduce 是一个分布式运算程序的编程框架，是用户开发“基于 Hadoop 的数据分析应用”的核心框架。MapReduce 核心功能是将用户编写的业务逻辑代码和自带默认组件整合成一个完整的分布式运算程序，并发运行在一个 Hadoop 集群上。
【大数据学习-实验-5】MapReduce应用
计忆芳华的博客
04-21 7111
1．编程实现WordCount实例。 package mapreduce; import java.io.IOException; import java.util.StringTokenizer; import org.apache.hadoop.fs.Path; import org.apache.hadoop.io.IntWritable; import org.apache.hadoop....
大数据--- 14.MapReduce的本地操作和集群计算与打包到hadoop运行
u014579001的博客
04-19 3352
MapReduce实现手机销量统计
什么是E-MapReduce
荒野求生的博客
10-25 2140
什么是E-MapReduce 更新时间：2020-04-20 13:54:01 编辑我的收藏 本页目录 简介 E-MapReduce的用途 E-MapReduce的组成 阿里云E-MapReduce（Elastic MapReduce），是运行在阿里云平台上的一种大数据处理的系统解决方案。 简介 E-MapReduce构建于云服务器ECS上，基于开源的Apache Hadoop和Apache Spark，让您可以方便地使用Hadoop和Spark生态系统中的其他周边系统（例如，Apache
MapReduce-Programming.rar_mapReduce
09-22
《MapReduce编程模型与实践》是Jerry Zhao撰写的一本关于MapReduce的重要著作，它深入浅出地阐述了MapReduce的核心概念、设计原理以及在实际应用中的最佳实践。MapReduce是Google提出的一种分布式计算模型，主要用于...
eclipse-linux软件包-包含mapreduce的jar包
06-06
这对于开发Hadoop应用来说是一个巨大的便利，因为这样可以利用Eclipse的强大功能，如代码自动完成、错误检查以及调试工具等。 在Linux环境下使用Eclipse进行MapReduce开发，需要确保系统已经安装了Java Development...
mapreducewordcounter-master_wordcount_mapReduce_
10-01
在大数据处理领域，MapReduce是一种分布式计算模型，由Google提出并广泛应用。本项目"mapreducewordcounter-master"是针对word count任务的一个实现，利用Python语言进行编程，这为我们提供了理解和实践MapReduce...
MapReduce综合应用案例 - 招聘数据清洗-结果
04-02
MapReduce综合应用案例 - 招聘数据清洗-结果
MongoDB教程（十八）：MongoDB MapReduce
菜鸟小码的博客
07-22 948
MongoDB 的 MapReduce 是一种强大的工具，用于处理大规模数据集并从中提取有价值的信息。MapReduce 的概念源自 Google 的论文，后来被 Hadoop 和其他大数据处理框架所采纳。在 MongoDB 中，MapReduce 提供了一种灵活的方式对集合中的数据进行聚合和分析。本文将深入探讨 MapReduce 的工作原理，并通过具体的案例代码来演示其使用方法。
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1258
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
golang 接口
m0_70982551的博客
07-24 805
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
最新发布
a1058926697的博客
07-26 364
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值