MapReduce设计模式之概要设计模式

gougouzhang 2019-11-05

什么是概要设计模式

概要分析师将相似数据分组到一起并执行类似统计计算、索引生成或简单计数等后续的分析操作。

概要设计模式有哪些分类？

(1)数值概要 (2)倒排索引概要 (3)计数器计数等等。

数值概要

包括最大值、最小值、平均数、方差和中位数等等。

注意：MapReduce的内容结果输出，如果父文件夹已经存在，会报文件已存在错误，每次重新输出文件，如果都手动删除，会比较麻烦，可以自己写一个删除文件的工具类。或者hadoop中有一个FileUtil.fullyDelete()方法可以删除文件;以下是自己写的删除文件夹的代码：

import java.io.File;

/**
 * @Author bluesnail95
 * @Date 2019/7/14 23:31
 * @Description
 */
public class FileUtil {

    /**
     * 删除文件
     * @param fileName 文件名称
     */
    public static void deleteFile(String fileName) {
        File file = new File(fileName);
        if(!file.exists()) {
            return;
        }
        if(file.isFile()) {
            file.delete();
        }else if(file.isDirectory()) {
            File[] fileList = file.listFiles();
            for (int i = 0; i < fileList.length; i++) {
                fileList[i].delete();
            }
            file.delete();
        }
    }
}

最大值/最小值/计数

import org.apache.hadoop.io.Writable;

import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * @Author bluesnail95
 * @Date 2019/7/14 9:57
 * @Description
 */
public class MinMaxCountData implements Writable {

    //日期
    private Date createDate;
    //用户标识
    private String userId;

    private final static SimpleDateFormat frmt = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS");

    public MinMaxCountData() {
    }

    public MinMaxCountData(Date createDate, String userId) {
        this.createDate = createDate;
        this.userId = userId;
    }

    public Date getCreateDate() {
        return createDate;
    }

    public void setCreateDate(Date createDate) {
        this.createDate = createDate;
    }

    public String getUserId() {
        return userId;
    }

    public void setUserId(String userId) {
        this.userId = userId;
    }

    public void write(DataOutput dataOutput) throws IOException {
        dataOutput.writeLong(createDate.getTime());
        dataOutput.writeBytes(userId);
    }

    public void readFields(DataInput dataInput) throws IOException {
        createDate = new Date(dataInput.readLong());
        userId = dataInput.readLine();
    }

    @Override
    public String toString() {
        return "MinMaxCountData{" +
                "createDate=" + createDate +
                ", userId='" + userId + '\'' +
                '}';
    }
}
import org.apache.hadoop.io.Writable;

import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * @Author bluesnail95
 * @Date 2019/7/14 9:36
 * @Description
 */
public class MinMaxCountTuple implements Writable {
    //最小日期
    private Date min = null;
    //最大日期
    private Date max = null;
    //计数
    private long count = 0;

    private final static SimpleDateFormat frmt = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS");

    public Date getMin() {
        return min;
    }

    public void setMin(Date min) {
        this.min = min;
    }

    public Date getMax() {
        return max;
    }

    public void setMax(Date max) {
        this.max = max;
    }

    public long getCount() {
        return count;
    }

    public void setCount(long count) {
        this.count = count;
    }

    public void write(DataOutput dataOutput) throws IOException {
        dataOutput.writeLong(min.getTime());
        dataOutput.writeLong(max.getTime());
        dataOutput.writeLong(count);
    }

    public void readFields(DataInput dataInput) throws IOException {
        min = new Date(dataInput.readLong());
        max = new Date(dataInput.readLong());
        count  = dataInput.readLong();
    }

    public String toString() {
        return frmt.format(min) + "\t" + frmt.format(max) + "\t" + count;
    }
}
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.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.codehaus.jackson.map.ObjectMapper;

import java.io.File;
import java.text.SimpleDateFormat;

/**
 * @Author bluesnail95
 * @Date 2019/7/14 10:02
 * @Description
 */
public class MinMaxCountMain {

    public static class MinMaxCountMapper extends Mapper<Object,Text,Text,MinMaxCountTuple> {

        private Text userId = new Text();
        private MinMaxCountTuple minMaxCountTuple = new MinMaxCountTuple();
        private final static SimpleDateFormat frmt = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS");

        public void map(Object key,Text value,Context context){
            try {
                ObjectMapper objectMapper = new ObjectMapper();
                objectMapper.setDateFormat(frmt);
                MinMaxCountData minMaxCountData = objectMapper.readValue(value.toString(), MinMaxCountData.class);
                minMaxCountTuple.setCount(1);
                minMaxCountTuple.setMin(minMaxCountData.getCreateDate());
                minMaxCountTuple.setMax(minMaxCountData.getCreateDate());
                userId.set(minMaxCountData.getUserId());
                context.write(userId, minMaxCountTuple);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public static class MinMaxCountReducer extends Reducer<Text, MinMaxCountTuple, Text, MinMaxCountTuple> {
        private MinMaxCountTuple minMaxCountTuple = new MinMaxCountTuple();

        public void reduce(Text key,Iterable<MinMaxCountTuple> values,Context context) {
            try {
                long sum = 0;
                for (MinMaxCountTuple value : values) {
                    if(minMaxCountTuple.getMin() == null || value.getMin().compareTo(minMaxCountTuple.getMin()) < 0 ) {
                        minMaxCountTuple.setMin(value.getMin());
                    }
                    if(minMaxCountTuple.getMax() == null || value.getMax().compareTo(minMaxCountTuple.getMax()) > 0 ) {
                        minMaxCountTuple.setMax(value.getMax());
                    }
                    sum += value.getCount();
                }
                minMaxCountTuple.setCount(sum);
                context.write(key, minMaxCountTuple);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        Configuration conf = new Configuration();
        try {
            Job job = Job.getInstance(conf, "NumericalSummarization：MinMaxCount");
            job.setOutputKeyClass(Text.class);
            job.setOutputValueClass(MinMaxCountTuple.class);
            job.setJarByClass(MinMaxCountMain.class);
            job.setMapperClass(MinMaxCountMapper.class);
            job.setCombinerClass(MinMaxCountReducer.class);
            job.setReducerClass(MinMaxCountReducer.class);
            FileInputFormat.addInputPath(job, new Path(args[0]));
            File outputFile = new File(args[1]);
            if(outputFile.exists()){
                outputFile.delete();
            }
            FileOutputFormat.setOutputPath(job, new Path(args[1]));
            System.exit(job.waitForCompletion(true) ? 0 : 1);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

MapReduce设计模式之概要设计模式

MapReduce设计模式之概要设计模式

MapReduce设计模式之概要设计模式

平均值

import org.apache.hadoop.io.Writable;

import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * @Author bluesnail95
 * @Date 2019/7/14 21:51
 * @Description
 */
public class CountAverageData implements Writable {

    //日期
    private Date creationDate;

    //文本
    private String text;

    private final static SimpleDateFormat frmt = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS");

    public CountAverageData() {
    }

    public CountAverageData(Date creationDate, String text) {
        this.creationDate = creationDate;
        this.text = text;
    }

    public Date getCreationDate() {
        return creationDate;
    }

    public void setCreationDate(Date creationDate) {
        this.creationDate = creationDate;
    }

    public String getText() {
        return text;
    }

    public void setText(String text) {
        this.text = text;
    }

    public void write(DataOutput dataOutput) throws IOException {
        dataOutput.writeBytes(frmt.format(creationDate));
        dataOutput.writeBytes(text);
    }

    public void readFields(DataInput dataInput) throws IOException {
        try {
            System.out.println(dataInput);
            creationDate = frmt.parse(dataInput.toString());
            text = dataInput.readLine();
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }

    @Override
    public String toString() {
        return "{" +
                "creationDate=" + creationDate +
                ", text='" + text + '\'' +
                '}';
    }
}
import org.apache.hadoop.io.Writable;

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

/**
 * @Author bluesnail95
 * @Date 2019/7/14 21:36
 * @Description
 */
public class CountAverageTuple implements Writable {

    //计数
    private long count;

    //平均值
    private float average;

    public long getCount() {
        return count;
    }

    public void setCount(long count) {
        this.count = count;
    }

    public float getAverage() {
        return average;
    }

    public void setAverage(float average) {
        this.average = average;
    }

    public void write(DataOutput dataOutput) throws IOException {
        dataOutput.writeLong(count);
        dataOutput.writeFloat(average);
    }

    public void readFields(DataInput dataInput) throws IOException {
        count = dataInput.readLong();
        average = dataInput.readFloat();
    }

    @Override
    public String toString() {
        return "{" +
                "count=" + count +
                ", average=" + average +
                '}';
    }
}
import file.FileUtil;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
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.output.FileOutputFormat;
import org.codehaus.jackson.map.ObjectMapper;

import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

/**
 * @Author bluesnail95
 * @Date 2019/7/14 21:40
 * @Description
 */
public class CountAverageMain {

    public static class CountAverageMapper extends Mapper<Object, Text, IntWritable, CountAverageTuple> {

        private IntWritable outHour = new IntWritable();
        private CountAverageTuple countAverageTuple = new CountAverageTuple();
        private final static SimpleDateFormat frmt = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS");

        public void map(Object key,Text value,Context context) {
            ObjectMapper objectMapper = new ObjectMapper();
            objectMapper.setDateFormat(frmt);
            try {
                CountAverageData countAverageData = objectMapper.readValue(value.toString(), CountAverageData.class);
                Calendar calendar = Calendar.getInstance();
                Date creationDate = countAverageData.getCreationDate();
                calendar.setTime(creationDate);
                int hour = calendar.get(Calendar.HOUR_OF_DAY);
                outHour.set(hour);
                countAverageTuple.setAverage(countAverageData.getText().length());
                countAverageTuple.setCount(1);
                context.write(outHour, countAverageTuple);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public static class CountAverageReducer extends Reducer<IntWritable, CountAverageTuple,IntWritable, CountAverageTuple> {

        private CountAverageTuple result = new CountAverageTuple();

        public void reduce(IntWritable key, Iterable<CountAverageTuple> values,Context context) {
            float sum = 0;
            long count = 0;
            for(CountAverageTuple countAverageTuple : values) {
                count += countAverageTuple.getCount();
                sum += countAverageTuple.getCount() * countAverageTuple.getAverage();
            }
            result.setAverage(sum / count);
            result.setCount(count);
            try {
                context.write(key, result);
            } catch (IOException e) {
                e.printStackTrace();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }


    public static void main(String[] args) {

        Configuration configuration = new Configuration();
        try {
            Job job = Job.getInstance(configuration, "CountAverage");
            job.setJarByClass(CountAverageMain.class);
            job.setMapperClass(CountAverageMapper.class);
            job.setCombinerClass(CountAverageReducer.class);
            job.setReducerClass(CountAverageReducer.class);
            job.setOutputKeyClass(IntWritable.class);
            job.setOutputValueClass(CountAverageTuple.class);
            FileInputFormat.addInputPath(job, new Path(args[0]));
            FileUtil.deleteFile(args[1]);
            FileOutputFormat.setOutputPath(job, new Path(args[1]));
            System.exit(job.waitForCompletion(true )? 0 : 1);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

MapReduce设计模式之概要设计模式

MapReduce设计模式之概要设计模式

MapReduce设计模式之概要设计模式

中位数和方差

import org.apache.hadoop.io.Writable;

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

/**
 * @Author bluesnail95
 * @Date 2019/7/16 6:33
 * @Description
 */
public class MedianStdDevTuple implements Writable {

    private float median;

    private float stdDev;

    public float getMedian() {
        return median;
    }

    public void setMedian(float median) {
        this.median = median;
    }

    public float getStdDev() {
        return stdDev;
    }

    public void setStdDev(float stdDev) {
        this.stdDev = stdDev;
    }

    public void write(DataOutput dataOutput) throws IOException {
        dataOutput.writeFloat(median);
        dataOutput.writeFloat(stdDev);
    }

    public void readFields(DataInput dataInput) throws IOException {
        median = dataInput.readFloat();
        stdDev = dataInput.readFloat();
    }

    @Override
    public String toString() {
        return "{" +
                "median=" + median +
                ", stdDev=" + stdDev +
                '}';
    }
}
import file.FileUtil;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
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.output.FileOutputFormat;
import org.codehaus.jackson.map.ObjectMapper;

import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collections;
import java.util.Date;

/**
 * @Author bluesnail95
 * @Date 2019/7/16 6:18
 * @Description
 */
public class MedianStdDevMain {

    private final static SimpleDateFormat frmt = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS");

    public static class MedianStdDevMapper extends Mapper<Object, Text,IntWritable, IntWritable> {

        private IntWritable outhour = new IntWritable();
        private IntWritable outlength = new IntWritable();

        public void map(Object key,Text value,Context context) {
            ObjectMapper objectMapper = new ObjectMapper();
            objectMapper.setDateFormat(frmt);
            try {
                CountAverageData countAverageData = objectMapper.readValue(value.toString(), CountAverageData.class);
                Date creationDate = countAverageData.getCreationDate();
                Calendar calendar = Calendar.getInstance();
                calendar.setTime(creationDate);
                int hour = calendar.get(Calendar.HOUR_OF_DAY);
                int length = countAverageData.getText().length();
                outhour.set(hour);
                outlength.set(length);
                context.write(outhour, outlength);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public static class MadianStdDevReducer extends Reducer<IntWritable, IntWritable, IntWritable, MedianStdDevTuple> {

        private ArrayList<Float> lengths = new ArrayList<Float>();
        private MedianStdDevTuple medianStdDevTuple = new MedianStdDevTuple();

        public void reduce(IntWritable key, Iterable<IntWritable> values, Context context) {
            int sum = 0;
            int count = 0;
            try {
                for (IntWritable value : values) {
                    sum += value.get();
                    count++;
                    lengths.add((float) value.get());
                }

                //进行排序
                Collections.sort(lengths);
                //求中位数
                if(count == 1 || count % 2 == 0) {
                    medianStdDevTuple.setMedian(lengths.get(count/2));
                }else {
                    medianStdDevTuple.setMedian((lengths.get(count / 2 - 1) + lengths.get(count / 2)) / 2.0f);
                }
                //求平均值
                float mean = sum / count;
                float sumOfSquare = 0.0f;
                //求标准差
                for(Float value: lengths) {
                    sumOfSquare += (value - mean) * (value - mean);
                }
                if(count == 1) {
                    medianStdDevTuple.setStdDev(0);
                }else{
                    medianStdDevTuple.setStdDev((float)Math.sqrt(sumOfSquare / (count - 1)));
                }

                context.write(key, medianStdDevTuple);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        Configuration configuration = new Configuration();
        try {
            Job job = Job.getInstance(configuration, "CountAverage");
            job.setJarByClass(MedianStdDevMain.class);
            job.setMapperClass(MedianStdDevMapper.class);
            job.setReducerClass(MadianStdDevReducer.class);
            job.setOutputKeyClass(IntWritable.class);
            job.setOutputValueClass(IntWritable.class);
            FileInputFormat.addInputPath(job, new Path(args[0]));
            FileUtil.deleteFile(args[1]);
            FileOutputFormat.setOutputPath(job, new Path(args[1]));
            System.exit(job.waitForCompletion(true )? 0 : 1);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

中位数方差升级版

import file.FileUtil;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.*;
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.output.FileOutputFormat;
import org.codehaus.jackson.map.ObjectMapper;


import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 * @Author bluesnail95
 * @Date 2019/7/16 21:28
 * @Description
 */
public class MedianStdDevUpgradeMain {

    private final static SimpleDateFormat frmt = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS");

    public static class MedianStdDevUpgradeMapper extends Mapper<Object, Text, IntWritable, SortedMapWritable> {
        private IntWritable outHour = new IntWritable();
        private LongWritable one = new LongWritable(1);
        private IntWritable lengths = new IntWritable();

        public void map(Object key,Text value,Context context) {
            ObjectMapper objectMapper = new ObjectMapper();
            objectMapper.setDateFormat(frmt);
            try {
                CountAverageData countAverageData = objectMapper.readValue(value.toString(), CountAverageData.class);
                Date creationDate = countAverageData.getCreationDate();
                Calendar calendar = Calendar.getInstance();
                calendar.setTime(creationDate);
                outHour.set(calendar.get(Calendar.HOUR_OF_DAY));
                lengths.set(countAverageData.getText().length());
                SortedMapWritable sortedMapWritable = new SortedMapWritable();
                sortedMapWritable.put(lengths,one);
                context.write(outHour, sortedMapWritable);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public static class MedianStdDevUpgradeCombiner extends Reducer<IntWritable,SortedMapWritable,IntWritable,SortedMapWritable> {

        protected void reduce(IntWritable key,Iterable<SortedMapWritable> values,Context context) {
            SortedMapWritable outValue = new SortedMapWritable();

            try {
                for (SortedMapWritable sortedMapWritable : values) {
                    Set<Map.Entry<WritableComparable,Writable>> set = sortedMapWritable.entrySet();
                    Iterator<Map.Entry<WritableComparable,Writable>> iterator = set.iterator();
                    while(iterator.hasNext()) {
                        Map.Entry<WritableComparable,Writable> entry = iterator.next();

                       LongWritable count = (LongWritable) outValue.get(entry.getKey());
                       if(count != null) {
                            count.set(count.get() + ((LongWritable)entry.getValue()).get());
                            outValue.put(entry.getKey(), count);
                       }else{
                           outValue.put(entry.getKey(),new LongWritable(((LongWritable)entry.getValue()).get()));
                       }

                    }
                }
                context.write(key, outValue);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public static class MedianStdDevUpgradeReducer extends Reducer<IntWritable,SortedMapWritable,IntWritable,MedianStdDevTuple> {
        private MedianStdDevTuple medianStdDevTuple = new MedianStdDevTuple();
        private TreeMap<Integer, Long> lengthCounts = new TreeMap<Integer, Long>();

        public void reduce(IntWritable key,Iterable<SortedMapWritable> values,Context context) {
            float sum = 0;
            long total = 0;
           lengthCounts.clear();
            medianStdDevTuple.setStdDev(0);
            medianStdDevTuple.setMedian(0);

            for(SortedMapWritable sortedMapWritable : values) {
                Set<Map.Entry<WritableComparable,Writable>> set = sortedMapWritable.entrySet();
                Iterator<Map.Entry<WritableComparable,Writable>> iterator =  set.iterator();
               while (iterator.hasNext()) {
                   Map.Entry<WritableComparable,Writable> writableEntry = iterator.next();
                   int length = ((IntWritable)writableEntry.getKey()).get();
                   long count = ((LongWritable)writableEntry.getValue()).get();

                   total += count;
                   sum += count * length;
                   Long sortedCount = lengthCounts.get(length);
                   if(sortedCount == null) {
                       lengthCounts.put(length, count);
                   }else{
                       lengthCounts.put(length, count + sortedCount);
                   }
               }
            }

            long medianIndex = total / 2;
            long previousCount = 0;
            long count = 0;
            long prevKey = 0;
            for(Map.Entry<Integer, Long> entry:lengthCounts.entrySet()) {
                count = previousCount + entry.getValue();
                if(previousCount <= medianIndex && medianIndex < count) {
                    if(total % 2 == 0 && previousCount == medianIndex) {
                        medianStdDevTuple.setMedian((entry.getKey() + prevKey) / 2.0f);
                    }else{
                        medianStdDevTuple.setMedian(entry.getKey());
                    }
                    break;
                }
                previousCount = count;
                prevKey = entry.getKey();
            }

            float mean = sum / total;
            float sumOfSquares = 0.0f;
            for(Map.Entry<Integer, Long> entry:lengthCounts.entrySet()) {
                sumOfSquares += (entry.getKey() - mean) * (entry.getKey() - mean) * entry.getValue();
            }
            if(total == 1) {
                medianStdDevTuple.setStdDev(0);
            }else{
                medianStdDevTuple.setStdDev((float)Math.sqrt((sumOfSquares / (total - 1))));
            }
            try {
                context.write(key, medianStdDevTuple);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        Configuration configuration = new Configuration();
        try {
            Job job = Job.getInstance(configuration, "MedianStdDevUpgrade");
            job.setJarByClass(MedianStdDevUpgradeMain.class);
            job.setMapperClass(MedianStdDevUpgradeMapper.class);
            job.setCombinerClass(MedianStdDevUpgradeCombiner.class);
            job.setReducerClass(MedianStdDevUpgradeReducer.class);
            job.setOutputKeyClass(IntWritable.class);
            job.setOutputValueClass(SortedMapWritable.class);
            FileInputFormat.addInputPath(job, new Path(args[0]));
            FileUtil.deleteFile(args[1]);
            FileOutputFormat.setOutputPath(job, new Path(args[1]));
            System.exit(job.waitForCompletion(true )? 0 : 1);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

MapReduce设计模式之概要设计模式

MapReduce设计模式之概要设计模式

MapReduce设计模式之概要设计模式

倒排索引概要

import java.io.Serializable;

/**
 * @Author bluesnail95
 * @Date 2019/7/18 23:22
 * @Description
 */
public class ExtractorData implements Serializable {

    private String link;

    private String id;

    public String getLink() {
        return link;
    }

    public void setLink(String link) {
        this.link = link;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
}
import file.FileUtil;
import numericalSummarization.MedianStdDevMain;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
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.output.FileOutputFormat;
import org.codehaus.jackson.map.ObjectMapper;

import java.io.IOException;
import java.util.Iterator;

/**
 * @Author bluesnail95
 * @Date 2019/7/18 23:18
 * @Description
 */
public class ExtractorMain  {

    public static class ExtractorMapper extends Mapper<Object, Text,Text,Text> {

        private Text link = new Text();
        private Text id = new Text();

        public void map(Object key,Text value,Context context) {
            ObjectMapper objectMapper = new ObjectMapper();
            try {
                ExtractorData extractorData = objectMapper.readValue(value.toString(), ExtractorData.class);
                link.set(extractorData.getLink());
                id.set(extractorData.getId());
                context.write(link,id);
            } catch (Exception e) {
                e.printStackTrace();
            }

        }
    }

    public static class ExtractorReducer extends Reducer<Text,Text,Text,Text> {
        private Text link = new Text();
        private Text ids = new Text();

        public void reduce(Text key, Iterable<Text> values,Context context) {
            StringBuilder buffer = new StringBuilder("");
            for(Text value:values) {
                buffer.append(value.toString());
                buffer.append(",");
            }
            ids.set(buffer.toString().substring(0, buffer.length() - 1));
            link.set(key.toString());
            try {
                context.write(link,ids);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        Configuration configuration = new Configuration();
        try {
            Job job = Job.getInstance(configuration, "ExtractorMain");
            job.setJarByClass(ExtractorMain.class);
            job.setMapperClass(ExtractorMapper.class);
            job.setCombinerClass(ExtractorReducer.class);
            job.setReducerClass(ExtractorReducer.class);
            job.setOutputKeyClass(Text.class);
            job.setOutputValueClass(Text.class);
            FileInputFormat.addInputPath(job, new Path(args[0]));
            FileUtil.deleteFile(args[1]);
            FileOutputFormat.setOutputPath(job, new Path(args[1]));
            System.exit(job.waitForCompletion(true )? 0 : 1);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

MapReduce设计模式之概要设计模式

MapReduce设计模式之概要设计模式

计数器技术

import file.FileUtil;
import invertedIndex.ExtractorMain;
import org.apache.commons.lang3.StringUtils;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Counter;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

import java.util.Arrays;
import java.util.HashSet;

/**
 * @Author bluesnail95
 * @Date 2019/7/19 6:31
 * @Description
 */
public class CountNumUsersByStateMain {

    public static class CountNumUsersByStateMapper extends Mapper<Object, Text, NullWritable,NullWritable> {
        public static final String STATE_COUNTER_GROUP = "State";
        public static final String UNKNOWN_COUNTER = "Unknown";
        public static final String NULL_OR_EMPTY_COUNTER = "Null or Empty";

        private String stateArray[] = {"BeiJing","ShangHai","ShenZhen","GuangZhou"};

        private HashSet<String> stateSet = new HashSet<String>(Arrays.asList(stateArray));

        public void map(Object key,Text value,Context context) {
            String state = value.toString();
            if(state != null && StringUtils.isNoneBlank(state)) {
                if(stateSet.contains(state)) {
                    context.getCounter(STATE_COUNTER_GROUP,state).increment(1);
                }else{
                    context.getCounter(STATE_COUNTER_GROUP,UNKNOWN_COUNTER).increment(1);
                }
            }else {
                context.getCounter(STATE_COUNTER_GROUP,NULL_OR_EMPTY_COUNTER).increment(1);
            }
        }
    }

    public static void main(String[] args) {
        Configuration configuration = new Configuration();
        try {
            Job job = Job.getInstance(configuration, "CountNumUsersByState");
            job.setJarByClass(CountNumUsersByStateMain.class);
            job.setMapperClass(CountNumUsersByStateMapper.class);
            job.setOutputKeyClass(NullWritable.class);
            job.setOutputValueClass(NullWritable.class);
            FileInputFormat.addInputPath(job, new Path(args[0]));
            FileUtil.deleteFile(args[1]);
            FileOutputFormat.setOutputPath(job, new Path(args[1]));
            int code = job.waitForCompletion(true )? 0 : 1;
            if(code == 0) {
                for(Counter counter:job.getCounters().getGroup(CountNumUsersByStateMapper.STATE_COUNTER_GROUP)) {
                    System.out.println(counter.getDisplayName() + "\t" + counter.getValue());
                }
            }
            FileSystem.get(configuration).delete(new Path(args[1]),true);
            System.exit(code);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

MapReduce设计模式之概要设计模式

参考资料

《MapReduce设计模式》

gougouzhang

gougouzhang

相关推荐

工程文档编写

现在很多企业业务开展都离不开项目管理，项目文档管理，是指在一个项目运行过程中将提交的各类文档进行收集管理控制的过程。工程项目保存的文档要涵盖项目可研、总体设计、基础设计、详细设计等整个项目周期，其中包括项目系统管理、文档版本控制、文档质量管理等管理内容。项

myblogdhy / 0评论 2020-07-08

数据库应用系统功能设计与实施

可采用层次结构图表示软件总体结构，体现自顶向下、逐步求精的设计思想。将每个子系统进一步划分为功能模块，定义各功能模块的数据结构、相互间交互关系。

jameszgw / 0评论 2020-06-14

『互联网架构』软件架构-软件系统设计（一）

按照正常的互联网玩法，产品经理原型画好进行需求评审，评审完后，需要把需求丢给技术经理，或者技术负责人，进行一整套的概要设计，然后针对概要设计评审，概要评审后进行开发。这次咱们一起说说概要设计的体系结构。软件系统设计在很多人眼里就是写文档，写文档是一种负担，

THEEYE / 0评论 2020-06-06

理顺软件开发各个环节-13（开发管理-概要设计和详细设计）

　　概要设计，用于子系统或模块设计，也可用新增业务需求的跨子系统设计。　　由于软件总体设计从宏观上架构软件，距离开发实现，还有许多需要细化之处。　　另外，概要设计与代码实现的联系更紧密一些，如代码分层、核心的对象类及关系等。软件需求规格书；　　详细设计，能

chvnetcom / 0评论 2020-05-29

第五弹——概要设计和详细设计说明书的诞生

在之前的需求规格说明书完美告一段落之后，我们又将面临着完成概要设计和详细设计说明书的任务。我们通过小组内分工的方式有条有理的在五一假期前各自完成了自己的部分并由小组中的负责人负责将所有内容整合到一起。就这样，既有分工又有讨论和监督，我们狮子山街一号的概要设

jameszgw / 0评论 2020-05-07

第四章、数据库应用系统功能设计与实施

DBAS功能设计包括应用软件设中数据库事务设计和应用程序设计。规划分析阶段提出系统功能、性能及时向的约束对软件做了评估和选择建议，需求对系统功能性能提出了具体，为保证DBAS功能性能顺利实现，总体设计阶段需要对软硬件设备做出合理选择，并举行初步配置设计。

chvnetcom / 0评论 2020-02-18

软件生存周期模型之V模型

RAD模型是软件开发过程中的一个重要模型，通过开发和测试同时进行的方式来缩短开发周期，提高开发效率。其形状像一个字母V，故称为V模型。又称软件测试的V模型。V模型是一个著名的、以测试为驱动的开发模型，该模型强调开发过程中测试贯穿始终，是瀑布模型的一个变体。

Henryztong / 0评论 2020-02-02

软件工程---常用总结

软件工程的框架可概括为：目标、过程和原则。瀑布模型产生的历史背景是20世界70年代出现的软件危机，该模型将软件开发分为若干阶段，由于其类似于瀑布从上到下的过程，故称其为“瀑布模型”。开始需要把需求做到最全，惧怕用户测试中的反馈,惧怕需求变更。V模型是在瀑布

VanTYS / 0评论 2020-01-12

如何评测软件工程知识技能水平？

编程语言是软件工程师的必备节能，不同方向的开发需要使用到不同的编程语言，因此软件工程师应该对各种编程语言都有一定的了解，同时要有至少两门能够熟练掌握的语言，并且 能深入理解各种编程思想，从而为以后的软件开发奠定坚实基础。软件开发往往是一个团队协作。耦合性，

嵌入式移动开发 / 0评论 2020-01-06

如何评测软件工程知识技能水平？

您认为一个软件工程师的软件工程知识技能水平高低主要体现在哪些方面，请您简要总结一下。软件生存周期模型确立了软件开发和演绎中各阶段的次序限制以及各阶段或机动的准则，确立开发过程所遵守的规定和限制，便于各种活动的协调，便于各种人员的有效通信，有利于活动重用，有

嵌入式移动开发 / 0评论 2020-01-05

软件设计---软件开发新手应该需要了解的内容

要养成职业化能力的意识。软件开发阶段一般是包括需求分析、总体分析、概要和详细设计、编码、测试、安装及维护。每一个人对每一个阶段的理解不同以及做法不同。一定要理解三阶段、五视图，尽管在实际开发中并不会全部使用到，也要有对应的概念。技术观点上来看软件设计应该包

随心而作 / 0评论 2019-12-29

架构设计文档模板--概要设计

分解软件模块，定义模块描述，模块交互关系（尽量使用数据耦合，少使用控制耦合，限制使用公共环境耦合，完全不用内容耦合。）--调用深度，宽度---控制好

水龙吟的备忘录 / 0评论 2019-11-14

软件开发流程（转载）

产品需求定义的目标是：“清楚地描述要做的产品是什么样的？不涉及具体实现方法。”，其定义过程如下图所示。按照需求，将软件逐级细化，分解为不必再分解的的模块，每个模块完成一定的功能，为一个或多个父模块服务，也接受一个或多个子模块的服务。模块的概念，和编程语言中

uileader / 0评论 2017-08-08

网上商城-概要设计

根据需求文档，界面原型整理出主要功能点。主要是画图，包括功能架构，系统架构，包图，类图，流程图，E-R图，时序图。常用工具包括visio，powerdesigner，rose。

zjxbjh / 0评论 2015-09-06

北京985院校，毕业3年，2.5年银行支付项目经理，求升级！

现为公司支付产品线项目经理、支付产品线骨干技术成员，现场、远程负责参与的银行项目7个。由于自我追求等原因，现恳请高人推荐，求升级，非常感谢！

zjxbjh / 0评论 2013-03-21

概要设计与详细设计的区别

概要设计、详细设计(二)设计的内容

李晨璐十五期 / 0评论 2015-04-21

在大学中的学习和思考

在学校的学习中，学习软件的开发流程，并且知道软件开发过程中的产生文档，对软件开发队伍的管理等。对自己提出问题，仔细思考这些问题，完善自己的软件开发链，建立起完善的软件开发概念模型。如果以后忘了，还能及时的进行复习。产生的文档有系统用例图、系统序列流程图、用

laj0 / 0评论 2014-03-04

软件设计说明书

不涉及具体实现方法。用户能看得明白，开发人员也可据此进行下面的工作。并且需要指出关键技术难点等。

laj0 / 0评论 2012-10-19

详解软件项目管理流程的每一步

了解项目干系人及其利害关系。所有项目组成员是否到位，如到位则拿到项目开发人员的简历，详细了解每个开发人员的情况。根据项目需求规格列出项目功能列表，并根据开发人员技术等情况创建WBS。根据项目时间、资源等情况规划项目初步开发计划。确定各种软硬件需求，如：版本

yanglin / 0评论 2012-05-16

概要设计说明

做软件到一定层次了，就要考虑到设计了，设计了很久，就是不系统，系统的设计需要一个记录，记录就用文档，那么对项目所有包括技术上的设计都记录下来，我们就可以理解为软件的概要设计了。这是项目小组今后共同作战的基础，有了开发规范和程序模块之间和项目成员彼此之间的接

agjllxchjy / 0评论 2011-10-28

软件开发流程

软件开发流程即软件设计思路和方法的一般过程，包括设计软件的功能和实现的算法和方法、软件的总体结构设计和模块设计、编程和调试、程序联调和测试以及编写、提交程序。　　3 系统分析员向用户再次确认需求。

李晨璐十五期 / 0评论 2011-10-27

PM项目管理流程

了解项目干系人及其利害关系。所有项目组成员是否到位，如到位则拿到项目开发人员的简历，详细了解每个开发人员的情况。根据项目需求规格列出项目功能列表，并根据开发人员技术等情况创建WBS。根据项目时间、资源等情况规划项目初步开发计划。建议对机构高层管理人员进行必

laj0 / 0评论 2011-04-23

概说概要设计怎么做

本文是在概要设计实践和学习中的一些心得与学习笔记，希望与大家分享，如有不妥之处欢迎指正。这是项目小组今后共同作战的基础，有了开发规范和程序模块之间和项目成员彼此之间的接口规则、方式方法，大家就有了共同的工作语言、共同的工作平台，使整个软件开发工作可以协调有

laj0 / 0评论 2011-04-09

个人项目管理计划及实施建议

了解项目干系人及其利害关系。所有项目组成员是否到位，如到位则拿到项目开发人员的简历，详细了解每个开发人员的情况。根据项目需求规格列出项目功能列表，并根据开发人员技术等情况创建WBS。根据项目时间、资源等情况规划项目初步开发计划。建议对机构高层管理人员进行必

upzhai / 0评论 2010-03-30

什么是需求，什么事设计？

需求是业务的描述，设计是业务的实现。而这样就又扯出来一个概念，什么是“业务”？我们很常见的业务比如电子政务的业务，公文传输、电子签章，这都是业务；那么当我们面对软件开发这个领域的时候，什么是“业务”？编写代码、提取构建就是业务；当我们面临中间件领域的时候，

upzhai / 0评论 2010-01-19

B/S入门指南---软件开发与SEO技术

大多数人都认为软件开发等于编写程序，在我看来，编写程序仅仅只是开发软件所应完成的工作的一部分。一个软件的质量体现在满足用户的需要和质量的合格。在我们进行软件设计过程中，错误的做法将会导致软件危机的产生。软件危机主要体现在以下几个方面：。首先，我们要明确有效

codekong / 0评论 2010-06-30

个人项目管理计划及实施建议

了解项目干系人及其利害关系。所有项目组成员是否到位，如到位则拿到项目开发人员的简历，详细了解每个开发人员的情况。根据项目需求规格列出项目功能列表，并根据开发人员技术等情况创建WBS。根据项目时间、资源等情况规划项目初步开发计划。建议对机构高层管理人员进行必

laj0 / 0评论 2009-09-17

关于需求分析、系统设计的一个问题

需求分析进行到什么程度就可以开始概要设计了？事无巨细，统统都管，甚至是点击一个按钮提示的文字内容，也要包括。

yanglin / 0评论 2008-06-18

软件工程 概要设计例子

编写此需求分析报告，实现商场、中小企业或个人在互联网上进行新产品展示，网上通信留言功能，重点实现网上商品的查找、在线购买功能。实现普通用户只能浏览，注册用户可以在线定购，后台管理人员可以进行产品上传更新、注册用户的管理等功能。在信息填写与提交中，要实现“返

upzhai / 0评论 2007-05-04

尴尬的概要设计文档

一般软件开发可分为如下阶段。而所谓概要设计，就是要把到达详细设计中间缺少的信息补全。而后文列举的一些原因将导致概要设计文档内容更加混乱。注意：GB8567-88概要设计模板是过时的。这时，概要设计的作用就是给用户一个大体的方案介绍。需求的表达有专业的表示工

THEEYE / 0评论 2016-01-27

软件测试的流程

还有一个开发流属于连接规范流和测试流两个中间的桥梁。规范流规范流分为用户需求，需求分析与需求设计，概要设计，详细设计。测试流测试流属于单元测试，集成测试，安装软件，运营软件，绩效等内容。W模型W模型是对V模型的发展和总结强调规范流和测试流同步进行。

冰晶云梦 / 0评论 2019-06-28

什么是概要设计（转）

为什么要进行概要设计，原因也浮出水面了，进一步的描述系统功能组成，方式是面向对象（类），工具是uml的一些图，通过对象模型（静态），动态模型（交互），功能模型，完成系统的功能划分和过程状态描述。完成系统需要的相关其他uml图。用uml的图来表示建模。

wangcaipang / 0评论 2012-07-27

面向对象的软件分析设计过程备忘

整理和发现业务流程中的涉众以及他们的业务目标和系统目标，显式目标以及隐式目标；B、实体建模时，即使需求方没有提出有关需求，但仍需要维护某些关系。

wangcaipang / 0评论 2012-05-21

（转） 软件设计 --- 概要设计与详细设计

概要设计就是设计软件的结构，包括组成模块，模块的层次结构，模块的调用关系，每个模块的功能等等。同时，还要设计该项目的应用系统的总体数据结构和数据库结构，即应用系统要存储什么数据，这些数据是什么样的结构，它们之间有什么关系。详细设计阶段就是为每个模块完成的功

zhounan00 / 0评论 2012-04-13

需求分析、概要设计、详细设计析义

<一> 需求分析 需求分析是当前软件工程中的关键问题。需求分析阶段的任务是：在可行性分析的基础上，进一步了解、确定用户需求，准确地回答“系统必须做什么”的问题。需求分析的基本任务包括： 抽取需求: 分析现行系统存在需要解决的问题。模拟和分析需

呼呼ozZ / 0评论 2012-01-01

概要设计与详细设计的区别

概要设计就是设计软件的结构，包括组成模块，模块的层次结构，模块的调用关系，每个模块的功能等等。同时，还要设计该项目的应用系统的总体数据结构和数据库结构，即应用系统要存储什么数据，这些数据是什么样的结构，它们之间有什么关系。详细设计阶段就是为每个模块完成的功

CherrylinORC / 0评论 2011-10-31

概要设计内容

每个模块“做什么”、简要说明“怎么做”，处在什么逻辑位置、物理位置；运行设计：。同时，对于非功能性的需求例如性能、可用性等，亦需提及。描述系统设计中最主要的约束，这些是由客户强制要求并在需求说明书写明的。对每个对象的每个方法详细说明：方法名，返回类型，返回

dream00csdn / 0评论 2011-08-22

软件项目开发流程

一个软件项目研发的设计流程是怎样的呢？以通常标准的设计方法为例，。第一个步骤是市场调研，技术和市场要结合才能体现最大价值。作为快速原型设计方法，完成概要设计就可以进入编码阶段了，通常采用这种方法是因为涉及的研发任务属于新领域，技术主管人员一上来无法给出明确

CherrylinORC / 0评论 2011-08-01

前端性能优化概要设计

随着页面的越来越大，功能越来越复杂，我们需要一套准则和规范用语指导优化我们的开发。如果值为max-age,则在过期之前不会重

ChinaGuanq / 0评论 2019-06-27

软件工程的需求分析、概要设计、详细设计的区别

不涉及具体实现方法。用户能看得明白，开发人员也可据此进行下面的工作。并且需要指出关键技术难点等。理论上要求可以照此编码。

燃烧的梦 / 0评论 2014-08-15

需求分析 概要设计 详细设计文档区别

不涉及具体实现方法。用户能看得明白，开发人员也可据此进行下面的工作。并且需要指出关键技术难点等。理论上要求可以照此编码

dream00csdn / 0评论 2010-10-21

《软件工程》选择题

18.把一组具有相似特性的对象组合在一起，称之为。

titans / 0评论 2010-08-12

《软件工程》填空题

7.子类自动共享父类的属性和操作的机制称为继承。

chvnetcom / 0评论 2010-08-12

软件工程简答题

它目标和内容是什么？软件开发中常见的软件过程模型有瀑布模型、原型模型、螺旋模型、喷泉模型、统一软件过程等。称为概要设计或结构设计。

特 / 0评论 2010-08-12

练习项目备选清单

练习项目备选清单Utilities1. 文件下载器功能概要设计：实现新建下载功能。给出下载链接可以启动下载任务。以单线程下载方式实现。以类Windows任务管理器的方式显示出CPU使用情况。针对聊天记录的显示以及存储时限进行设计。自动领取普通红包、口令红包

lizhiyong / 0评论 2019-06-21

关于系统设计中架构、概要、详细设计的使用说明

在软件系统的设计阶段，架构设计、概要设计和详细设计阐述了一个系统的设计和实现过程。从系统分解为层次、层次内的模块以及相互的接口、模块分解为对象以及对象的接口、实现这些对象接口的方法。但每个阶段都有自己独特的一部分。概括的说，架构解决系统核心用例以及关键性需

CherrylinORC / 0评论 2008-05-16

需求分析和概要设计怎样区分

当公司发给我一份几百页的需求分析文档时，头脑发热的同时，心更加纠结，整个文档中没有很多具体的客户实际业务流程的描述，更多的是技术结构的描述，页面功能的描述，需求不相需求，概要设计不相概要设计，是我水平太低？？请高手指点，怎么做需求设计，怎样做概要设计

菜鸟进化史 / 0评论 2011-07-25

详解软件项目管理流程的每一步

了解项目干系人及其利害关系。所有项目组成员是否到位，如到位则拿到项目开发人员的简历，详细了解每个开发人员的情况。根据项目需求规格列出项目功能列表，并根据开发人员技术等情况创建WBS。根据项目时间、资源等情况规划项目初步开发计划。对需求开发过程域产生的所有有

joyopod / 0评论 2011-06-17

树屋 -- 软件概要设计说明书

开发一个包含推送用户感兴趣内容,评论文章,好友聊天和社团讨论于一体的多客户端软件.·登录与注册界面:该界面负责读入已注册用户名和密码,以及未注册用户进行注册.

前端外刊评论 / 0评论 2018-04-08