Are you the publisher? Claim or contact us about this channel


Embed this content in your HTML

Search

Report adult content:

click to rate:

Account: (login)

More Channels


Channel Catalog


Channel Description:

http://www.easy518.com
    0 0

    最近 在做一个项目中,遇见ftp的问题。在网页中上传大文件。网页中嵌套ftp。
    很多都是需要付费的。一怒之下,自己下班之后,在家钻研。
    发现jftp很好,支持多线程和单线程。但是有个bug ,是不认识中文文件夹和中文文件名的文件。
    经过一晚上的研究,终于解决了。
    速度超快。
    截图展示下。 

    已有 0 人发表留言,猛击->>这里<<-参与讨论


    ITeye推荐





    0 0
  • 09/14/17--00:59: 跟我学hadoop学习1
  • 不说话,直接上代码

    package oldapi;
    
    
    
    
    import java.io.IOException;
    
    import org.apache.hadoop.io.IntWritable;
    import org.apache.hadoop.io.LongWritable;
    import org.apache.hadoop.io.Text;
    import org.apache.hadoop.mapred.MapReduceBase;
    import org.apache.hadoop.mapred.Mapper;
    import org.apache.hadoop.mapred.OutputCollector;
    import org.apache.hadoop.mapred.Reporter;
    
    public class MaxTemperatureMapper extends MapReduceBase
      implements Mapper<LongWritable, Text, Text, IntWritable> {
    
      private static final int MISSING = 9999;
      
      public void map(LongWritable key, Text value,
          OutputCollector<Text, IntWritable> output, Reporter reporter)
          throws IOException {
        
        String line = value.toString();
        String year = line.substring(15, 19);
        int airTemperature;
        if (line.charAt(87) == '+') { // parseInt doesn't like leading plus signs
          airTemperature = Integer.parseInt(line.substring(88, 92));
        } else {
          airTemperature = Integer.parseInt(line.substring(87, 92));
        }
        String quality = line.substring(92, 93);
        if (airTemperature != MISSING && quality.matches("[01459]")) {
          output.collect(new Text(year), new IntWritable(airTemperature));
        }
      }
    }
    
    
    package oldapi;
    
    import java.io.IOException;
    import java.util.Iterator;
    
    import org.apache.hadoop.io.IntWritable;
    import org.apache.hadoop.io.Text;
    import org.apache.hadoop.mapred.MapReduceBase;
    import org.apache.hadoop.mapred.OutputCollector;
    import org.apache.hadoop.mapred.Reducer;
    import org.apache.hadoop.mapred.Reporter;
    
    public class MaxTemperatureReducer extends MapReduceBase
      implements Reducer<Text, IntWritable, Text, IntWritable> {
    
      public void reduce(Text key, Iterator<IntWritable> values,
          OutputCollector<Text, IntWritable> output, Reporter reporter)
          throws IOException {
        
        int maxValue = Integer.MIN_VALUE;
        while (values.hasNext()) {
          maxValue = Math.max(maxValue, values.next().get());
        }
        output.collect(key, new IntWritable(maxValue));
      }
    }
    
    
    
    
    
    package oldapi;
    
    import java.io.IOException;
    
    import org.apache.hadoop.fs.Path;
    import org.apache.hadoop.io.IntWritable;
    import org.apache.hadoop.io.Text;
    import org.apache.hadoop.mapred.FileInputFormat;
    import org.apache.hadoop.mapred.FileOutputFormat;
    import org.apache.hadoop.mapred.JobClient;
    import org.apache.hadoop.mapred.JobConf;
    
    public class MaxTemperature {
    
      public static void main(String[] args) throws IOException {
        if (args.length != 2) {
          System.err.println("Usage: MaxTemperature <input path> <output path>");
          System.exit(-1);
        }
        
        JobConf conf = new JobConf(MaxTemperature.class);
        conf.setJobName("Max temperature");
    
        FileInputFormat.addInputPath(conf, new Path(args[0]));
        FileOutputFormat.setOutputPath(conf, new Path(args[1]));
        
        conf.setMapperClass(MaxTemperatureMapper.class);
        conf.setReducerClass(MaxTemperatureReducer.class);
    
        conf.setOutputKeyClass(Text.class);
        conf.setOutputValueClass(IntWritable.class);
    
        JobClient.runJob(conf);
      }
    }
    
    
    
    
    package oldapi;
    
    import java.io.IOException;
    
    import org.apache.hadoop.fs.Path;
    import org.apache.hadoop.io.IntWritable;
    import org.apache.hadoop.io.Text;
    import org.apache.hadoop.mapred.FileInputFormat;
    import org.apache.hadoop.mapred.FileOutputFormat;
    import org.apache.hadoop.mapred.JobClient;
    import org.apache.hadoop.mapred.JobConf;
    
    public class MaxTemperatureWithCombiner {
    
      public static void main(String[] args) throws IOException {
        if (args.length != 2) {
          System.err.println("Usage: MaxTemperatureWithCombiner <input path> " +
          		"<output path>");
          System.exit(-1);
        }
        
        JobConf conf = new JobConf(MaxTemperatureWithCombiner.class);
        conf.setJobName("Max temperature");
    
        FileInputFormat.addInputPath(conf, new Path(args[0]));
        FileOutputFormat.setOutputPath(conf, new Path(args[1]));
        
        conf.setMapperClass(MaxTemperatureMapper.class);
        /*[*/conf.setCombinerClass(MaxTemperatureReducer.class)/*]*/;
        conf.setReducerClass(MaxTemperatureReducer.class);
    
        conf.setOutputKeyClass(Text.class);
        conf.setOutputValueClass(IntWritable.class);
    
        JobClient.runJob(conf);
      }
    }
    
    
    
    


    已有 0 人发表留言,猛击->>这里<<-参与讨论


    ITeye推荐




    0 0
  • 09/21/17--02:25: 跟我学hadoop学习2
  • import java.text.DateFormat;
    import java.text.ParseException;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    import org.apache.hadoop.fs.Path;
    import org.apache.hadoop.fs.PathFilter;
    
    public class DateRangePathFilter implements PathFilter {
      
      private final Pattern PATTERN = Pattern.compile("^.*/(\\d\\d\\d\\d/\\d\\d/\\d\\d).*$");
      
      private final Date start, end;
    
      public DateRangePathFilter(Date start, Date end) {
        this.start = new Date(start.getTime());
        this.end = new Date(end.getTime());
      }
      
      public boolean accept(Path path) {
        Matcher matcher = PATTERN.matcher(path.toString());
        if (matcher.matches()) {
          DateFormat format = new SimpleDateFormat("yyyy/MM/dd");
          try {
            return inInterval(format.parse(matcher.group(1)));
          } catch (ParseException e) {
            return false;
          }
        }
        return false;
      }
    
      private boolean inInterval(Date date) {
        return !date.before(start) && !date.after(end);
      }
    
    }
    
    // cc FileCopyWithProgress Copies a local file to a Hadoop filesystem, and shows progress
    import java.io.BufferedInputStream;
    import java.io.FileInputStream;
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.net.URI;
    
    import org.apache.hadoop.conf.Configuration;
    import org.apache.hadoop.fs.FileSystem;
    import org.apache.hadoop.fs.Path;
    import org.apache.hadoop.io.IOUtils;
    import org.apache.hadoop.util.Progressable;
    
    // vv FileCopyWithProgress
    public class FileCopyWithProgress {
      public static void main(String[] args) throws Exception {
        String localSrc = args[0];
        String dst = args[1];
        
        InputStream in = new BufferedInputStream(new FileInputStream(localSrc));
        
        Configuration conf = new Configuration();
        FileSystem fs = FileSystem.get(URI.create(dst), conf);
        OutputStream out = fs.create(new Path(dst), new Progressable() {
          public void progress() {
            System.out.print(".");
          }
        });
        
        IOUtils.copyBytes(in, out, 4096, true);
      }
    }
    // ^^ FileCopyWithProgress
    
    
    
    // cc FileSystemCat Displays files from a Hadoop filesystem on standard output by using the FileSystem directly
    import java.io.InputStream;
    import java.net.URI;
    
    import org.apache.hadoop.conf.Configuration;
    import org.apache.hadoop.fs.FileSystem;
    import org.apache.hadoop.fs.Path;
    import org.apache.hadoop.io.IOUtils;
    
    // vv FileSystemCat
    public class FileSystemCat {
    
      public static void main(String[] args) throws Exception {
        String uri = args[0];
        Configuration conf = new Configuration();
        FileSystem fs = FileSystem.get(URI.create(uri), conf);
        InputStream in = null;
        try {
          in = fs.open(new Path(uri));
          IOUtils.copyBytes(in, System.out, 4096, false);
        } finally {
          IOUtils.closeStream(in);
        }
      }
    }
    // ^^ FileSystemCat
    
    
    // cc FileSystemDoubleCat Displays files from a Hadoop filesystem on standard output twice, by using seek
    import java.net.URI;
    
    import org.apache.hadoop.conf.Configuration;
    import org.apache.hadoop.fs.FSDataInputStream;
    import org.apache.hadoop.fs.FileSystem;
    import org.apache.hadoop.fs.Path;
    import org.apache.hadoop.io.IOUtils;
    
    // vv FileSystemDoubleCat
    public class FileSystemDoubleCat {
    
      public static void main(String[] args) throws Exception {
        String uri = args[0];
        Configuration conf = new Configuration();
        FileSystem fs = FileSystem.get(URI.create(uri), conf);
        FSDataInputStream in = null;
        try {
          in = fs.open(new Path(uri));
          IOUtils.copyBytes(in, System.out, 4096, false);
          in.seek(0); // go back to the start of the file
          IOUtils.copyBytes(in, System.out, 4096, false);
        } finally {
          IOUtils.closeStream(in);
        }
      }
    }
    // ^^ FileSystemDoubleCat
    
    
    // cc ListStatus Shows the file statuses for a collection of paths in a Hadoop filesystem 
    import java.net.URI;
    
    import org.apache.hadoop.conf.Configuration;
    import org.apache.hadoop.fs.FileStatus;
    import org.apache.hadoop.fs.FileSystem;
    import org.apache.hadoop.fs.FileUtil;
    import org.apache.hadoop.fs.Path;
    
    // vv ListStatus
    public class ListStatus {
    
      public static void main(String[] args) throws Exception {
        String uri = args[0];
        Configuration conf = new Configuration();
        FileSystem fs = FileSystem.get(URI.create(uri), conf);
        
        Path[] paths = new Path[args.length];
        for (int i = 0; i < paths.length; i++) {
          paths[i] = new Path(args[i]);
        }
        
        FileStatus[] status = fs.listStatus(paths);
        Path[] listedPaths = FileUtil.stat2Paths(status);
        for (Path p : listedPaths) {
          System.out.println(p);
        }
      }
    }
    // ^^ ListStatus
    
    
    // cc RegexExcludePathFilter A PathFilter for excluding paths that match a regular expression
    import org.apache.hadoop.fs.Path;
    import org.apache.hadoop.fs.PathFilter;
    
    // vv RegexExcludePathFilter
    public class RegexExcludePathFilter implements PathFilter {
      
      private final String regex;
    
      public RegexExcludePathFilter(String regex) {
        this.regex = regex;
      }
    
      public boolean accept(Path path) {
        return !path.toString().matches(regex);
      }
    }
    // ^^ RegexExcludePathFilter
    
    import org.apache.hadoop.fs.Path;
    import org.apache.hadoop.fs.PathFilter;
    
    public class RegexPathFilter implements PathFilter {
      
      private final String regex;
      private final boolean include;
    
      public RegexPathFilter(String regex) {
        this(regex, true);
      }
      
      public RegexPathFilter(String regex, boolean include) {
        this.regex = regex;
        this.include = include;
      }
    
      public boolean accept(Path path) {
        return (path.toString().matches(regex)) ? include : !include;
      }
    
    }
    
    // cc URLCat Displays files from a Hadoop filesystem on standard output using a URLStreamHandler
    import java.io.InputStream;
    import java.net.URL;
    
    import org.apache.hadoop.fs.FsUrlStreamHandlerFactory;
    import org.apache.hadoop.io.IOUtils;
    
    // vv URLCat
    public class URLCat {
    
      static {
        URL.setURLStreamHandlerFactory(new FsUrlStreamHandlerFactory());
      }
      
      public static void main(String[] args) throws Exception {
        InputStream in = null;
        try {
          in = new URL(args[0]).openStream();
          IOUtils.copyBytes(in, System.out, 4096, false);
        } finally {
          IOUtils.closeStream(in);
        }
      }
    }
    // ^^ URLCat
    
    
    


    已有 0 人发表留言,猛击->>这里<<-参与讨论


    ITeye推荐




    0 0
  • 09/21/17--02:34: 跟我学spark1
  • 科普Spark,Spark是什么,如何使用Spark




    1.Spark基于什么算法的分布式计算(很简单)

    2.Spark与MapReduce不同在什么地方

    3.Spark为什么比Hadoop灵活

    4.Spark局限是什么

    5.什么情况下适合使用Spark




    什么是Spark

    Spark是UC Berkeley AMP lab所开源的类Hadoop MapReduce的通用的并行计算框架,Spark基于map reduce算法实现的分布式计算,拥有Hadoop MapReduce所具有的优点;但不同于MapReduce的是Job中间输出和结果可以保存在内存中,从而不再需要读写HDFS,因此Spark能更好地适用于数据挖掘与机器学习等需要迭代的map reduce的算法。其架构如下图所示:




    Spark与Hadoop的对比

    Spark的中间数据放到内存中,对于迭代运算效率更高。

    Spark更适合于迭代运算比较多的ML和DM运算。因为在Spark里面,有RDD的抽象概念。

    Spark比Hadoop更通用

    Spark提供的数据集操作类型有很多种,不像Hadoop只提供了Map和Reduce两种操作。比如map, filter, flatMap, sample, groupByKey, reduceByKey, union, join, cogroup, mapValues, sort,partionBy等多种操作类型,Spark把这些操作称为Transformations。同时还提供Count, collect, reduce, lookup, save等多种actions操作。

    这些多种多样的数据集操作类型,给给开发上层应用的用户提供了方便。各个处理节点之间的通信模型不再像Hadoop那样就是唯一的Data Shuffle一种模式。用户可以命名,物化,控制中间结果的存储、分区等。可以说编程模型比Hadoop更灵活。

    不过由于RDD的特性,Spark不适用那种异步细粒度更新状态的应用,例如web服务的存储或者是增量的web爬虫和索引。就是对于那种增量修改的应用模型不适合。

    容错性

    在分布式数据集计算时通过checkpoint来实现容错,而checkpoint有两种方式,一个是checkpoint data,一个是logging the updates。用户可以控制采用哪种方式来实现容错。

    可用性

    Spark通过提供丰富的Scala, Java,Python API及交互式Shell来提高可用性。

    Spark与Hadoop的结合

    Spark可以直接对HDFS进行数据的读写,同样支持Spark on YARN。Spark可以与MapReduce运行于同集群中,共享存储资源与计算,数据仓库Shark实现上借用Hive,几乎与Hive完全兼容。

    Spark的适用场景

    Spark是基于内存的迭代计算框架,适用于需要多次操作特定数据集的应用场合。需要反复操作的次数越多,所需读取的数据量越大,受益越大,数据量小但是计算密集度较大的场合,受益就相对较小(大数据库架构中这是是否考虑使用Spark的重要因素)

    由于RDD的特性,Spark不适用那种异步细粒度更新状态的应用,例如web服务的存储或者是增量的web爬虫和索引。就是对于那种增量修改的应用模型不适合。总的来说Spark的适用面比较广泛且比较通用。

    运行模式

    本地模式

    Standalone模式

    Mesoes模式

    yarn模式

    Spark生态系统

    Shark ( Hive on Spark): Shark基本上就是在Spark的框架基础上提供和Hive一样的H iveQL命令接口,为了最大程度的保持和Hive的兼容性,Shark使用了Hive的API来实现query Parsing和 Logic Plan generation,最后的PhysicalPlan execution阶段用Spark代替Hadoop MapReduce。通过配置Shark参数,Shark可以自动在内存中缓存特定的RDD,实现数据重用,进而加快特定数据集的检索。同时,Shark通过UDF用户自定义函数实现特定的数据分析学习算法,使得SQL数据查询和运算分析能结合在一起,最大化RDD的重复使用。

    Spark streaming: 构建在Spark上处理Stream数据的框架,基本的原理是将Stream数据分成小的时间片断(几秒),以类似batch批量处理的方式来处理这小部分数据。Spark Streaming构建在Spark上,一方面是因为Spark的低延迟执行引擎(100ms+)可以用于实时计算,另一方面相比基于Record的其它处理框架(如Storm),RDD数据集更容易做高效的容错处理。此外小批量处理的方式使得它可以同时兼容批量和实时数据处理的逻辑和算法。方便了一些需要历史数据和实时数据联合分析的特定应用场合。

    Bagel: Pregel on Spark,可以用Spark进行图计算,这是个非常有用的小项目。Bagel自带了一个例子,实现了Google的PageRank算法。

    End.


    已有 0 人发表留言,猛击->>这里<<-参与讨论


    ITeye推荐





    0 0
  • 09/25/17--22:12: 跟我学hadoop学习3
  • // cc FileDecompressor A program to decompress a compressed file using a codec inferred from the file's extension
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.net.URI;
    
    import org.apache.hadoop.conf.Configuration;
    import org.apache.hadoop.fs.FileSystem;
    import org.apache.hadoop.fs.Path;
    import org.apache.hadoop.io.IOUtils;
    import org.apache.hadoop.io.compress.CompressionCodec;
    import org.apache.hadoop.io.compress.CompressionCodecFactory;
    
    // vv FileDecompressor
    public class FileDecompressor {
    
      public static void main(String[] args) throws Exception {
        String uri = args[0];
        Configuration conf = new Configuration();
        FileSystem fs = FileSystem.get(URI.create(uri), conf);
        
        Path inputPath = new Path(uri);
        CompressionCodecFactory factory = new CompressionCodecFactory(conf);
        CompressionCodec codec = factory.getCodec(inputPath);
        if (codec == null) {
          System.err.println("No codec found for " + uri);
          System.exit(1);
        }
    
        String outputUri =
          CompressionCodecFactory.removeSuffix(uri, codec.getDefaultExtension());
    
        InputStream in = null;
        OutputStream out = null;
        try {
          in = codec.createInputStream(fs.open(inputPath));
          out = fs.create(new Path(outputUri));
          IOUtils.copyBytes(in, out, conf);
        } finally {
          IOUtils.closeStream(in);
          IOUtils.closeStream(out);
        }
      }
    }
    // ^^ FileDecompressor
    
    
    import java.io.*;
    
    import org.apache.hadoop.io.*;
    
    public class IntPair implements WritableComparable<IntPair> {
    
      private int first;
      private int second;
      
      public IntPair() {
      }
      
      public IntPair(int first, int second) {
        set(first, second);
      }
      
      public void set(int first, int second) {
        this.first = first;
        this.second = second;
      }
      
      public int getFirst() {
        return first;
      }
    
      public int getSecond() {
        return second;
      }
    
      @Override
      public void write(DataOutput out) throws IOException {
        out.writeInt(first);
        out.writeInt(second);
      }
    
      @Override
      public void readFields(DataInput in) throws IOException {
        first = in.readInt();
        second = in.readInt();
      }
      
      @Override
      public int hashCode() {
        return first * 163 + second;
      }
      
      @Override
      public boolean equals(Object o) {
        if (o instanceof IntPair) {
          IntPair ip = (IntPair) o;
          return first == ip.first && second == ip.second;
        }
        return false;
      }
    
      @Override
      public String toString() {
        return first + "\t" + second;
      }
      
      @Override
      public int compareTo(IntPair ip) {
        int cmp = compare(first, ip.first);
        if (cmp != 0) {
          return cmp;
        }
        return compare(second, ip.second);
      }
      
      /**
       * Convenience method for comparing two ints.
       */
      public static int compare(int a, int b) {
        return (a < b ? -1 : (a == b ? 0 : 1));
      }
      
    }
    
    
    
    // cc MapFileFixer Re-creates the index for a MapFile
    import java.net.URI;
    
    import org.apache.hadoop.conf.Configuration;
    import org.apache.hadoop.fs.FileSystem;
    import org.apache.hadoop.fs.Path;
    import org.apache.hadoop.io.MapFile;
    import org.apache.hadoop.io.SequenceFile;
    
    // vv MapFileFixer
    public class MapFileFixer {
    
      public static void main(String[] args) throws Exception {
        String mapUri = args[0];
        
        Configuration conf = new Configuration();
        
        FileSystem fs = FileSystem.get(URI.create(mapUri), conf);
        Path map = new Path(mapUri);
        Path mapData = new Path(map, MapFile.DATA_FILE_NAME);
        
        // Get key and value types from data sequence file
        SequenceFile.Reader reader = new SequenceFile.Reader(fs, mapData, conf);
        Class keyClass = reader.getKeyClass();
        Class valueClass = reader.getValueClass();
        reader.close();
        
        // Create the map file index file
        long entries = MapFile.fix(fs, map, keyClass, valueClass, false, conf);
        System.out.printf("Created MapFile %s with %d entries\n", map, entries);
      }
    }
    // ^^ MapFileFixer
    
    
    
    // cc MapFileWriteDemo Writing a MapFile
    import java.io.IOException;
    import java.net.URI;
    
    import org.apache.hadoop.conf.Configuration;
    import org.apache.hadoop.fs.FileSystem;
    import org.apache.hadoop.io.IOUtils;
    import org.apache.hadoop.io.IntWritable;
    import org.apache.hadoop.io.MapFile;
    import org.apache.hadoop.io.Text;
    
    // vv MapFileWriteDemo
    public class MapFileWriteDemo {
      
      private static final String[] DATA = {
        "One, two, buckle my shoe",
        "Three, four, shut the door",
        "Five, six, pick up sticks",
        "Seven, eight, lay them straight",
        "Nine, ten, a big fat hen"
      };
      
      public static void main(String[] args) throws IOException {
        String uri = args[0];
        Configuration conf = new Configuration();
        FileSystem fs = FileSystem.get(URI.create(uri), conf);
    
        IntWritable key = new IntWritable();
        Text value = new Text();
        MapFile.Writer writer = null;
        try {
          writer = new MapFile.Writer(conf, fs, uri,
              key.getClass(), value.getClass());
          
          for (int i = 0; i < 1024; i++) {
            key.set(i + 1);
            value.set(DATA[i % DATA.length]);
            writer.append(key, value);
          }
        } finally {
          IOUtils.closeStream(writer);
        }
      }
    }
    // ^^ MapFileWriteDemo
    
    
    // cc MaxTemperatureWithCompression Application to run the maximum temperature job producing compressed output
    import org.apache.hadoop.fs.Path;
    import org.apache.hadoop.io.IntWritable;
    import org.apache.hadoop.io.Text;
    import org.apache.hadoop.io.compress.GzipCodec;
    import org.apache.hadoop.mapreduce.Job;
    import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
    import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
    
    //vv MaxTemperatureWithCompression
    public class MaxTemperatureWithCompression {
    
      public static void main(String[] args) throws Exception {
        if (args.length != 2) {
          System.err.println("Usage: MaxTemperatureWithCompression <input path> " +
            "<output path>");
          System.exit(-1);
        }
    
        Job job = new Job();
        job.setJarByClass(MaxTemperature.class);
    
        FileInputFormat.addInputPath(job, new Path(args[0]));
        FileOutputFormat.setOutputPath(job, new Path(args[1]));
        
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(IntWritable.class);
        
        /*[*/FileOutputFormat.setCompressOutput(job, true);
        FileOutputFormat.setOutputCompressorClass(job, GzipCodec.class);/*]*/
        
        job.setMapperClass(MaxTemperatureMapper.class);
        job.setCombinerClass(MaxTemperatureReducer.class);
        job.setReducerClass(MaxTemperatureReducer.class);
        
        System.exit(job.waitForCompletion(true) ? 0 : 1);
      }
    }
    //^^ MaxTemperatureWithCompression
    
    
    
    // == MaxTemperatureWithMapOutputCompression
    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.io.compress.CompressionCodec;
    import org.apache.hadoop.io.compress.GzipCodec;
    import org.apache.hadoop.mapreduce.Job;
    import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
    import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
    
    public class MaxTemperatureWithMapOutputCompression {
    
      public static void main(String[] args) throws Exception {
        if (args.length != 2) {
          System.err.println("Usage: MaxTemperatureWithMapOutputCompression " +
            "<input path> <output path>");
          System.exit(-1);
        }
    
        // vv MaxTemperatureWithMapOutputCompression
        Configuration conf = new Configuration();
        conf.setBoolean("mapred.compress.map.output", true);
        conf.setClass("mapred.map.output.compression.codec", GzipCodec.class,
            CompressionCodec.class);
        Job job = new Job(conf);
        // ^^ MaxTemperatureWithMapOutputCompression
        job.setJarByClass(MaxTemperature.class);
    
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(IntWritable.class);
    
        FileInputFormat.addInputPath(job, new Path(args[0]));
        FileOutputFormat.setOutputPath(job, new Path(args[1]));
        
        job.setMapperClass(MaxTemperatureMapper.class);
        job.setCombinerClass(MaxTemperatureReducer.class);
        job.setReducerClass(MaxTemperatureReducer.class);
        
        System.exit(job.waitForCompletion(true) ? 0 : 1);
      }
    }
    
    
    
    // cc PooledStreamCompressor A program to compress data read from standard input and write it to standard output using a pooled compressor
    import org.apache.hadoop.conf.Configuration;
    import org.apache.hadoop.io.IOUtils;
    import org.apache.hadoop.io.compress.*;
    import org.apache.hadoop.util.ReflectionUtils;
    
    // vv PooledStreamCompressor
    public class PooledStreamCompressor {
    
      public static void main(String[] args) throws Exception {
        String codecClassname = args[0];
        Class<?> codecClass = Class.forName(codecClassname);
        Configuration conf = new Configuration();
        CompressionCodec codec = (CompressionCodec)
          ReflectionUtils.newInstance(codecClass, conf);
        /*[*/Compressor compressor = null;
        try {
          compressor = CodecPool.getCompressor(codec);/*]*/
          CompressionOutputStream out =
            codec.createOutputStream(System.out, /*[*/compressor/*]*/);
          IOUtils.copyBytes(System.in, out, 4096, false);
          out.finish();
        /*[*/} finally {
          CodecPool.returnCompressor(compressor);
        }/*]*/
      }
    }
    // ^^ PooledStreamCompressor
    
    
    
    // cc SequenceFileReadDemo Reading a SequenceFile
    import java.io.IOException;
    import java.net.URI;
    
    import org.apache.hadoop.conf.Configuration;
    import org.apache.hadoop.fs.FileSystem;
    import org.apache.hadoop.fs.Path;
    import org.apache.hadoop.io.IOUtils;
    import org.apache.hadoop.io.SequenceFile;
    import org.apache.hadoop.io.Writable;
    import org.apache.hadoop.util.ReflectionUtils;
    
    // vv SequenceFileReadDemo
    public class SequenceFileReadDemo {
      
      public static void main(String[] args) throws IOException {
        String uri = args[0];
        Configuration conf = new Configuration();
        FileSystem fs = FileSystem.get(URI.create(uri), conf);
        Path path = new Path(uri);
    
        SequenceFile.Reader reader = null;
        try {
          reader = new SequenceFile.Reader(fs, path, conf);
          Writable key = (Writable)
            ReflectionUtils.newInstance(reader.getKeyClass(), conf);
          Writable value = (Writable)
            ReflectionUtils.newInstance(reader.getValueClass(), conf);
          long position = reader.getPosition();
          while (reader.next(key, value)) {
            String syncSeen = reader.syncSeen() ? "*" : "";
            System.out.printf("[%s%s]\t%s\t%s\n", position, syncSeen, key, value);
            position = reader.getPosition(); // beginning of next record
          }
        } finally {
          IOUtils.closeStream(reader);
        }
      }
    }
    // ^^ SequenceFileReadDemo
    
    
    // cc SequenceFileWriteDemo Writing a SequenceFile
    import java.io.IOException;
    import java.net.URI;
    
    import org.apache.hadoop.conf.Configuration;
    import org.apache.hadoop.fs.FileSystem;
    import org.apache.hadoop.fs.Path;
    import org.apache.hadoop.io.IOUtils;
    import org.apache.hadoop.io.IntWritable;
    import org.apache.hadoop.io.SequenceFile;
    import org.apache.hadoop.io.Text;
    
    // vv SequenceFileWriteDemo
    public class SequenceFileWriteDemo {
      
      private static final String[] DATA = {
        "One, two, buckle my shoe",
        "Three, four, shut the door",
        "Five, six, pick up sticks",
        "Seven, eight, lay them straight",
        "Nine, ten, a big fat hen"
      };
      
      public static void main(String[] args) throws IOException {
        String uri = args[0];
        Configuration conf = new Configuration();
        FileSystem fs = FileSystem.get(URI.create(uri), conf);
        Path path = new Path(uri);
    
        IntWritable key = new IntWritable();
        Text value = new Text();
        SequenceFile.Writer writer = null;
        try {
          writer = SequenceFile.createWriter(fs, conf, path,
              key.getClass(), value.getClass());
          
          for (int i = 0; i < 100; i++) {
            key.set(100 - i);
            value.set(DATA[i % DATA.length]);
            System.out.printf("[%s]\t%s\t%s\n", writer.getLength(), key, value);
            writer.append(key, value);
          }
        } finally {
          IOUtils.closeStream(writer);
        }
      }
    }
    // ^^ SequenceFileWriteDemo
    
    
    
    
    // cc StreamCompressor A program to compress data read from standard input and write it to standard output
    import org.apache.hadoop.conf.Configuration;
    import org.apache.hadoop.io.IOUtils;
    import org.apache.hadoop.io.compress.CompressionCodec;
    import org.apache.hadoop.io.compress.CompressionOutputStream;
    import org.apache.hadoop.util.ReflectionUtils;
    
    // vv StreamCompressor
    public class StreamCompressor {
    
      public static void main(String[] args) throws Exception {
        String codecClassname = args[0];
        Class<?> codecClass = Class.forName(codecClassname);
        Configuration conf = new Configuration();
        CompressionCodec codec = (CompressionCodec)
          ReflectionUtils.newInstance(codecClass, conf);
        
        CompressionOutputStream out = codec.createOutputStream(System.out);
        IOUtils.copyBytes(System.in, out, 4096, false);
        out.finish();
      }
    }
    // ^^ StreamCompressor
    
    
    
    // == TextArrayWritable
    import org.apache.hadoop.io.ArrayWritable;
    import org.apache.hadoop.io.Text;
    
    // vv TextArrayWritable
    public class TextArrayWritable extends ArrayWritable {
      public TextArrayWritable() {
        super(Text.class);
      }
    }
    // ^^ TextArrayWritable
    
    
    // cc TextIterator Iterating over the characters in a Text object
    import java.nio.ByteBuffer;
    
    import org.apache.hadoop.io.Text;
    
    // vv TextIterator
    public class TextIterator {
      
      public static void main(String[] args) {    
        Text t = new Text("\u0041\u00DF\u6771\uD801\uDC00");
        
        ByteBuffer buf = ByteBuffer.wrap(t.getBytes(), 0, t.getLength());
        int cp;
        while (buf.hasRemaining() && (cp = Text.bytesToCodePoint(buf)) != -1) {
          System.out.println(Integer.toHexString(cp));
        }
      }  
    }
    // ^^ TextIterator
    
    
    // cc TextPair A Writable implementation that stores a pair of Text objects
    // cc TextPairComparator A RawComparator for comparing TextPair byte representations
    // cc TextPairFirstComparator A custom RawComparator for comparing the first field of TextPair byte representations
    // vv TextPair
    import java.io.*;
    
    import org.apache.hadoop.io.*;
    
    public class TextPair implements WritableComparable<TextPair> {
    
      private Text first;
      private Text second;
      
      public TextPair() {
        set(new Text(), new Text());
      }
      
      public TextPair(String first, String second) {
        set(new Text(first), new Text(second));
      }
      
      public TextPair(Text first, Text second) {
        set(first, second);
      }
      
      public void set(Text first, Text second) {
        this.first = first;
        this.second = second;
      }
      
      public Text getFirst() {
        return first;
      }
    
      public Text getSecond() {
        return second;
      }
    
      @Override
      public void write(DataOutput out) throws IOException {
        first.write(out);
        second.write(out);
      }
    
      @Override
      public void readFields(DataInput in) throws IOException {
        first.readFields(in);
        second.readFields(in);
      }
      
      @Override
      public int hashCode() {
        return first.hashCode() * 163 + second.hashCode();
      }
      
      @Override
      public boolean equals(Object o) {
        if (o instanceof TextPair) {
          TextPair tp = (TextPair) o;
          return first.equals(tp.first) && second.equals(tp.second);
        }
        return false;
      }
    
      @Override
      public String toString() {
        return first + "\t" + second;
      }
      
      @Override
      public int compareTo(TextPair tp) {
        int cmp = first.compareTo(tp.first);
        if (cmp != 0) {
          return cmp;
        }
        return second.compareTo(tp.second);
      }
      // ^^ TextPair
      
      // vv TextPairComparator
      public static class Comparator extends WritableComparator {
        
        private static final Text.Comparator TEXT_COMPARATOR = new Text.Comparator();
        
        public Comparator() {
          super(TextPair.class);
        }
    
        @Override
        public int compare(byte[] b1, int s1, int l1,
                           byte[] b2, int s2, int l2) {
          
          try {
            int firstL1 = WritableUtils.decodeVIntSize(b1[s1]) + readVInt(b1, s1);
            int firstL2 = WritableUtils.decodeVIntSize(b2[s2]) + readVInt(b2, s2);
            int cmp = TEXT_COMPARATOR.compare(b1, s1, firstL1, b2, s2, firstL2);
            if (cmp != 0) {
              return cmp;
            }
            return TEXT_COMPARATOR.compare(b1, s1 + firstL1, l1 - firstL1,
                                           b2, s2 + firstL2, l2 - firstL2);
          } catch (IOException e) {
            throw new IllegalArgumentException(e);
          }
        }
      }
    
      static {
        WritableComparator.define(TextPair.class, new Comparator());
      }
      // ^^ TextPairComparator
      
      // vv TextPairFirstComparator
      public static class FirstComparator extends WritableComparator {
        
        private static final Text.Comparator TEXT_COMPARATOR = new Text.Comparator();
        
        public FirstComparator() {
          super(TextPair.class);
        }
    
        @Override
        public int compare(byte[] b1, int s1, int l1,
                           byte[] b2, int s2, int l2) {
          
          try {
            int firstL1 = WritableUtils.decodeVIntSize(b1[s1]) + readVInt(b1, s1);
            int firstL2 = WritableUtils.decodeVIntSize(b2[s2]) + readVInt(b2, s2);
            return TEXT_COMPARATOR.compare(b1, s1, firstL1, b2, s2, firstL2);
          } catch (IOException e) {
            throw new IllegalArgumentException(e);
          }
        }
        
        @Override
        public int compare(WritableComparable a, WritableComparable b) {
          if (a instanceof TextPair && b instanceof TextPair) {
            return ((TextPair) a).first.compareTo(((TextPair) b).first);
          }
          return super.compare(a, b);
        }
      }
      // ^^ TextPairFirstComparator
      
    // vv TextPair
    }
    // ^^ TextPair
    
    
    


    已有 0 人发表留言,猛击->>这里<<-参与讨论


    ITeye推荐




    0 0
  • 09/25/17--22:16: 跟我学hadoop学习5
  • 
    package v1;
    // cc MaxTemperatureMapperV1 First version of a Mapper that passes MaxTemperatureMapperTest
    import java.io.IOException;
    import org.apache.hadoop.io.*;
    import org.apache.hadoop.mapreduce.*;
    //vv MaxTemperatureMapperV1
    public class MaxTemperatureMapper
      extends Mapper<LongWritable, Text, Text, IntWritable> {
      
      @Override
      public void map(LongWritable key, Text value, Context context)
          throws IOException, InterruptedException {
        
        String line = value.toString();
        String year = line.substring(15, 19);
        int airTemperature = Integer.parseInt(line.substring(87, 92));
        context.write(new Text(year), new IntWritable(airTemperature));
      }
    }
    //^^ MaxTemperatureMapperV1
    
    
    
    package v1;
    //cc MaxTemperatureReducerV1 Reducer for maximum temperature example
    import java.io.IOException;
    
    import org.apache.hadoop.io.IntWritable;
    import org.apache.hadoop.io.Text;
    import org.apache.hadoop.mapreduce.Reducer;
    
    // vv MaxTemperatureReducerV1
    public class MaxTemperatureReducer
      extends Reducer<Text, IntWritable, Text, IntWritable> {
    
      @Override
      public void reduce(Text key, Iterable<IntWritable> values,
          Context context)
          throws IOException, InterruptedException {
        
        int maxValue = Integer.MIN_VALUE;
        for (IntWritable value : values) {
          maxValue = Math.max(maxValue, value.get());
        }
        context.write(key, new IntWritable(maxValue));
      }
    }
    // ^^ MaxTemperatureReducerV1
    
    
    


    已有 0 人发表留言,猛击->>这里<<-参与讨论


    ITeye推荐




    0 0
  • 09/25/17--22:21: 跟我学hadoop学习4
  • // cc AvroGenericMaxTemperature MapReduce program to find the maximum temperature, creating Avro output
    
    import java.io.IOException;
    
    import org.apache.avro.Schema;
    import org.apache.avro.generic.GenericData;
    import org.apache.avro.generic.GenericRecord;
    import org.apache.avro.mapred.AvroCollector;
    import org.apache.avro.mapred.AvroJob;
    import org.apache.avro.mapred.AvroMapper;
    import org.apache.avro.mapred.AvroReducer;
    import org.apache.avro.mapred.AvroUtf8InputFormat;
    import org.apache.avro.mapred.Pair;
    import org.apache.avro.util.Utf8;
    import org.apache.hadoop.conf.Configured;
    import org.apache.hadoop.fs.Path;
    import org.apache.hadoop.mapred.FileInputFormat;
    import org.apache.hadoop.mapred.FileOutputFormat;
    import org.apache.hadoop.mapred.JobClient;
    import org.apache.hadoop.mapred.JobConf;
    import org.apache.hadoop.mapred.Reporter;
    import org.apache.hadoop.util.Tool;
    import org.apache.hadoop.util.ToolRunner;
    
    //vv AvroGenericMaxTemperature
    public class AvroGenericMaxTemperature extends Configured implements Tool {
      
      private static final Schema SCHEMA = new Schema.Parser().parse(
          "{" +
          "  \"type\": \"record\"," +
          "  \"name\": \"WeatherRecord\"," +
          "  \"doc\": \"A weather reading.\"," +
          "  \"fields\": [" +
          "    {\"name\": \"year\", \"type\": \"int\"}," +
          "    {\"name\": \"temperature\", \"type\": \"int\"}," +
          "    {\"name\": \"stationId\", \"type\": \"string\"}" +
          "  ]" +
          "}"
      );
    
      public static class MaxTemperatureMapper
          extends AvroMapper<Utf8, Pair<Integer, GenericRecord>> {
        private NcdcRecordParser parser = new NcdcRecordParser();
        private GenericRecord record = new GenericData.Record(SCHEMA);
        @Override
        public void map(Utf8 line,
            AvroCollector<Pair<Integer, GenericRecord>> collector,
            Reporter reporter) throws IOException {
          parser.parse(line.toString());
          if (parser.isValidTemperature()) {
            record.put("year", parser.getYearInt());
            record.put("temperature", parser.getAirTemperature());
            record.put("stationId", parser.getStationId());
            collector.collect(
                new Pair<Integer, GenericRecord>(parser.getYearInt(), record));
          }
        }
      }
      
      public static class MaxTemperatureReducer
          extends AvroReducer<Integer, GenericRecord, GenericRecord> {
    
        @Override
        public void reduce(Integer key, Iterable<GenericRecord> values,
            AvroCollector<GenericRecord> collector, Reporter reporter)
            throws IOException {
          GenericRecord max = null;
          for (GenericRecord value : values) {
            if (max == null || 
                (Integer) value.get("temperature") > (Integer) max.get("temperature")) {
              max = newWeatherRecord(value);
            }
          }
          collector.collect(max);
        }
        private GenericRecord newWeatherRecord(GenericRecord value) {
          GenericRecord record = new GenericData.Record(SCHEMA);
          record.put("year", value.get("year"));
          record.put("temperature", value.get("temperature"));
          record.put("stationId", value.get("stationId"));
          return record;
        }
      }
    
      @Override
      public int run(String[] args) throws Exception {
        if (args.length != 2) {
          System.err.printf("Usage: %s [generic options] <input> <output>\n",
              getClass().getSimpleName());
          ToolRunner.printGenericCommandUsage(System.err);
          return -1;
        }
        
        JobConf conf = new JobConf(getConf(), getClass());
        conf.setJobName("Max temperature");
        
        FileInputFormat.addInputPath(conf, new Path(args[0]));
        FileOutputFormat.setOutputPath(conf, new Path(args[1]));
        
        AvroJob.setInputSchema(conf, Schema.create(Schema.Type.STRING));
        AvroJob.setMapOutputSchema(conf,
            Pair.getPairSchema(Schema.create(Schema.Type.INT), SCHEMA));
        AvroJob.setOutputSchema(conf, SCHEMA);
        
        conf.setInputFormat(AvroUtf8InputFormat.class);
    
        AvroJob.setMapperClass(conf, MaxTemperatureMapper.class);
        AvroJob.setReducerClass(conf, MaxTemperatureReducer.class);
    
        JobClient.runJob(conf);
        return 0;
      }
      
      public static void main(String[] args) throws Exception {
        int exitCode = ToolRunner.run(new AvroGenericMaxTemperature(), args);
        System.exit(exitCode);
      }
    }
    // ^^ AvroGenericMaxTemperature
    
    
    
    import java.io.IOException;
    
    import org.apache.avro.Schema;
    import org.apache.avro.mapred.AvroCollector;
    import org.apache.avro.mapred.AvroJob;
    import org.apache.avro.mapred.AvroMapper;
    import org.apache.avro.mapred.AvroReducer;
    import org.apache.avro.mapred.AvroUtf8InputFormat;
    import org.apache.avro.mapred.Pair;
    import org.apache.avro.util.Utf8;
    import org.apache.hadoop.conf.Configured;
    import org.apache.hadoop.fs.Path;
    import org.apache.hadoop.mapred.FileInputFormat;
    import org.apache.hadoop.mapred.FileOutputFormat;
    import org.apache.hadoop.mapred.JobClient;
    import org.apache.hadoop.mapred.JobConf;
    import org.apache.hadoop.mapred.Reporter;
    import org.apache.hadoop.util.Tool;
    import org.apache.hadoop.util.ToolRunner;
    
    import specific.WeatherRecord;
    
    public class AvroSpecificMaxTemperature extends Configured implements Tool {
      
      public static class MaxTemperatureMapper
          extends AvroMapper<Utf8, Pair<Integer, WeatherRecord>> {
        private NcdcRecordParser parser = new NcdcRecordParser();
        private WeatherRecord record = new WeatherRecord();
        @Override
        public void map(Utf8 line,
            AvroCollector<Pair<Integer, WeatherRecord>> collector,
            Reporter reporter) throws IOException {
          parser.parse(line.toString());
          if (parser.isValidTemperature()) {
            record.year = parser.getYearInt();
            record.temperature = parser.getAirTemperature();
            record.stationId = new Utf8(parser.getStationId());
            collector.collect(
                new Pair<Integer, WeatherRecord>(parser.getYearInt(), record));
          }
        }
      }
      
      public static class MaxTemperatureReducer extends
          AvroReducer<Integer, WeatherRecord, WeatherRecord> {
    
        @Override
        public void reduce(Integer key, Iterable<WeatherRecord> values,
            AvroCollector<WeatherRecord> collector,
            Reporter reporter) throws IOException {
          WeatherRecord max = null;
          for (WeatherRecord value : values) {
            if (max == null || value.temperature > max.temperature) {
              max = newWeatherRecord(value);
            }
          }
          collector.collect(max);
        }
      }
    
      public static class MaxTemperatureCombiner extends
          AvroReducer<Integer, WeatherRecord, Pair<Integer, WeatherRecord>> {
        
        @Override
        public void reduce(Integer key, Iterable<WeatherRecord> values,
            AvroCollector<Pair<Integer, WeatherRecord>> collector,
            Reporter reporter) throws IOException {
          WeatherRecord max = null;
          for (WeatherRecord value : values) {
            if (max == null || value.temperature > max.temperature) {
              max = newWeatherRecord(value);
            }
          }
          collector.collect(new Pair<Integer, WeatherRecord>(key, max));
        }
      }
    
      private static WeatherRecord newWeatherRecord(WeatherRecord value) {
        WeatherRecord record = new WeatherRecord();
        record.year = value.year;
        record.temperature = value.temperature;
        record.stationId = value.stationId;
        return record;
      }
      
      @Override
      public int run(String[] args) throws Exception {
        if (args.length != 2) {
          System.err.printf("Usage: %s [generic options] <input> <output>\n",
              getClass().getSimpleName());
          ToolRunner.printGenericCommandUsage(System.err);
          return -1;
        }
        
        JobConf conf = new JobConf(getConf(), getClass());
        conf.setJobName("Max temperature");
        
        FileInputFormat.addInputPath(conf, new Path(args[0]));
        FileOutputFormat.setOutputPath(conf, new Path(args[1]));
        
        AvroJob.setInputSchema(conf, Schema.create(Schema.Type.STRING));
        AvroJob.setMapOutputSchema(conf, Pair.getPairSchema(
            Schema.create(Schema.Type.INT), WeatherRecord.SCHEMA$));
        AvroJob.setOutputSchema(conf, WeatherRecord.SCHEMA$);
        
        conf.setInputFormat(AvroUtf8InputFormat.class);
    
        AvroJob.setMapperClass(conf, MaxTemperatureMapper.class);
        AvroJob.setCombinerClass(conf, MaxTemperatureCombiner.class);
        AvroJob.setReducerClass(conf, MaxTemperatureReducer.class);
    
        JobClient.runJob(conf);
        return 0;
      }
      
      public static void main(String[] args) throws Exception {
        int exitCode = ToolRunner.run(new AvroSpecificMaxTemperature(), args);
        System.exit(exitCode);
      }
    }
    
    
    import java.text.*;
    import java.util.Date;
    
    import org.apache.hadoop.io.Text;
    
    public class NcdcRecordParser {
      
      private static final int MISSING_TEMPERATURE = 9999;
      
      private static final DateFormat DATE_FORMAT =
        new SimpleDateFormat("yyyyMMddHHmm");
      
      private String stationId;
      private String observationDateString;
      private String year;
      private String airTemperatureString;
      private int airTemperature;
      private boolean airTemperatureMalformed;
      private String quality;
      
      public void parse(String record) {
        stationId = record.substring(4, 10) + "-" + record.substring(10, 15);
        observationDateString = record.substring(15, 27);
        year = record.substring(15, 19);
        airTemperatureMalformed = false;
        // Remove leading plus sign as parseInt doesn't like them
        if (record.charAt(87) == '+') {
          airTemperatureString = record.substring(88, 92);
          airTemperature = Integer.parseInt(airTemperatureString);
        } else if (record.charAt(87) == '-') {
          airTemperatureString = record.substring(87, 92);
          airTemperature = Integer.parseInt(airTemperatureString);
        } else {
          airTemperatureMalformed = true;
        }
        airTemperature = Integer.parseInt(airTemperatureString);
        quality = record.substring(92, 93);
      }
      
      public void parse(Text record) {
        parse(record.toString());
      }
      
      public boolean isValidTemperature() {
        return !airTemperatureMalformed && airTemperature != MISSING_TEMPERATURE
            && quality.matches("[01459]");
      }
      
      public boolean isMalformedTemperature() {
        return airTemperatureMalformed;
      }
      
      public boolean isMissingTemperature() {
        return airTemperature == MISSING_TEMPERATURE;
      }
      
      public String getStationId() {
        return stationId;
      }
      
      public Date getObservationDate() {
        try {
          System.out.println(observationDateString);
          return DATE_FORMAT.parse(observationDateString);
        } catch (ParseException e) {
          throw new IllegalArgumentException(e);
        }
      }
    
      public String getYear() {
        return year;
      }
    
      public int getYearInt() {
        return Integer.parseInt(year);
      }
    
      public int getAirTemperature() {
        return airTemperature;
      }
      
      public String getAirTemperatureString() {
        return airTemperatureString;
      }
    
      public String getQuality() {
        return quality;
      }
    
    }
    
    
    
    import java.io.File;
    
    import org.apache.avro.Schema;
    import org.apache.avro.mapred.AvroJob;
    import org.apache.hadoop.conf.Configured;
    import org.apache.hadoop.fs.Path;
    import org.apache.hadoop.mapred.FileInputFormat;
    import org.apache.hadoop.mapred.FileOutputFormat;
    import org.apache.hadoop.mapred.JobClient;
    import org.apache.hadoop.mapred.JobConf;
    import org.apache.hadoop.util.Tool;
    import org.apache.hadoop.util.ToolRunner;
    
    public class AvroProjection extends Configured implements Tool {
    
      @Override
      public int run(String[] args) throws Exception {
        
        if (args.length != 3) {
          System.err.printf("Usage: %s [generic options] <input> <output> <schema-file>\n",
              getClass().getSimpleName());
          ToolRunner.printGenericCommandUsage(System.err);
          return -1;
        }
        
        String input = args[0];
        String output = args[1];
        String schemaFile = args[2];
    
        JobConf conf = new JobConf(getConf(), getClass());
        conf.setJobName("Avro projection");
        
        FileInputFormat.addInputPath(conf, new Path(input));
        FileOutputFormat.setOutputPath(conf, new Path(output));
        
        Schema schema = new Schema.Parser().parse(new File(schemaFile));
        AvroJob.setInputSchema(conf, schema);
        AvroJob.setMapOutputSchema(conf, schema);
        AvroJob.setOutputSchema(conf, schema);
        conf.setNumReduceTasks(0);
    
        JobClient.runJob(conf); 
        return 0;
      }
      
      public static void main(String[] args) throws Exception {
        int exitCode = ToolRunner.run(new AvroProjection(), args);
        System.exit(exitCode);
      }
    
    }
    
    
    // cc AvroSort A MapReduce program to sort an Avro data file
    
    import java.io.File;
    import java.io.IOException;
    
    import org.apache.avro.Schema;
    import org.apache.avro.mapred.AvroCollector;
    import org.apache.avro.mapred.AvroJob;
    import org.apache.avro.mapred.AvroMapper;
    import org.apache.avro.mapred.AvroReducer;
    import org.apache.avro.mapred.Pair;
    import org.apache.hadoop.conf.Configured;
    import org.apache.hadoop.fs.Path;
    import org.apache.hadoop.mapred.FileInputFormat;
    import org.apache.hadoop.mapred.FileOutputFormat;
    import org.apache.hadoop.mapred.JobClient;
    import org.apache.hadoop.mapred.JobConf;
    import org.apache.hadoop.mapred.Reporter;
    import org.apache.hadoop.util.Tool;
    import org.apache.hadoop.util.ToolRunner;
    
    //vv AvroSort
    public class AvroSort extends Configured implements Tool {
    
      static class SortMapper<K> extends AvroMapper<K, Pair<K, K>> {
        public void map(K datum, AvroCollector<Pair<K, K>> collector,
            Reporter reporter) throws IOException {
          collector.collect(new Pair<K, K>(datum, null, datum, null));
        }
      }
    
      static class SortReducer<K> extends AvroReducer<K, K, K> {
        public void reduce(K key, Iterable<K> values,
            AvroCollector<K> collector,
            Reporter reporter) throws IOException {
          for (K value : values) {
            collector.collect(value);
          }
        }
      }
    
      @Override
      public int run(String[] args) throws Exception {
        
        if (args.length != 3) {
          System.err.printf(
            "Usage: %s [generic options] <input> <output> <schema-file>\n",
            getClass().getSimpleName());
          ToolRunner.printGenericCommandUsage(System.err);
          return -1;
        }
        
        String input = args[0];
        String output = args[1];
        String schemaFile = args[2];
    
        JobConf conf = new JobConf(getConf(), getClass());
        conf.setJobName("Avro sort");
        
        FileInputFormat.addInputPath(conf, new Path(input));
        FileOutputFormat.setOutputPath(conf, new Path(output));
        
        Schema schema = new Schema.Parser().parse(new File(schemaFile));
        AvroJob.setInputSchema(conf, schema);
        Schema intermediateSchema = Pair.getPairSchema(schema, schema);
        AvroJob.setMapOutputSchema(conf, intermediateSchema);
        AvroJob.setOutputSchema(conf, schema);
        
        AvroJob.setMapperClass(conf, SortMapper.class);
        AvroJob.setReducerClass(conf, SortReducer.class);
      
        JobClient.runJob(conf); 
        return 0;
      }
      
      public static void main(String[] args) throws Exception {
        int exitCode = ToolRunner.run(new AvroSort(), args);
        System.exit(exitCode);
      }
    }
    // ^^ AvroSort
    
    
    
    
    


    已有 0 人发表留言,猛击->>这里<<-参与讨论


    ITeye推荐




    0 0

    Mycat多租户方案
    
    1、需求
    1、1 需求图
    这里写图片描述
    
    1、2 环境说明
    环境说明:
    这里写图片描述
    
    2 每租户一逻辑库方案
    2.1实现思想
    用户在用用户名登陆时,首先,需要根据用户名,查询到该用户所在的逻辑库,然后登陆成功后,将和会话信息存放在一起,方便在访问其他业务的时候,能够很方便的得到该逻辑库。与此同时,利用Mybatis 提供的 SQL拦截器机制与Mycat提供的注解,改写SQL语句为 sql = “/!mycat:schema=” + tenant + ” /” + sql; 这样Mycat在解析时,会自动路由到tenat逻辑库上执行SQL语句。
    
    2.2 具体实现关键点
    Mycat 模拟配置如下:
    这里写图片描述
    
    2.2.1、登陆接口申明
    public Map login( String account, String password ); 根据用户名与密码登陆
    返回值说明:
    {
    “code” : 0,
    “data”: {
    “userId” : 1,
    “tenant” : “h_xsgjzx”
    }
    }
    接口中的返回 tenant 参数,作为其他业务接口的第一参数。
    
    现在有个关键点,就是根据用户名account 怎么知道用户存在哪个逻辑库呢?我给出用思路是,提供一个表来记录所有数据库中表的结合,global_user,字段基本如下:
    ID account db_pos
    
    然后提供一个接口,根据用户名查询出db_pos的值
    
    然后再去实现该接口
    实现1:查询刚才global_user表,获取tenent;也可以用redis缓存等。该处可以扩展。
    
    2.2.2、控制层方法
    通过成功登录系统后,就能得到 逻辑scheme : tenant。业务action的声明如下:
    public Map findDepts( String tenant, 其他业务参数 ) ;
    
    为了避免 tenant 参数污染业务层,DAO层的方法声明,,故在控制器层(Control)将 tenant
    参数存入到 ThreadLocal 变量中。
    现在提供 Tenant工具类,申明如下:
    
    package persistent.prestige.modules.common.tenant;
    public class TenantContextHolder {
    
        private static ThreadLocal<String> tenanThreadLocal = new ThreadLocal<String>();
    
        public static final void setTenant(String scheme) {
            tenanThreadLocal.set(scheme);
        }
    
        public static final String getTenant() {
            String scheme = tenanThreadLocal.get();
            if (scheme == null) {
                scheme = "";
            }
            return scheme;
        }
    
        public static final void remove() {
            tenanThreadLocal.remove();
        }
    
    }
    
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
        21
        22
        23
    
    那控制器层代码的伪代码如下:
    public Map findDepts( String tenant, String businessP1 ) {
    Map result = new HashMap();
    try {
    TenantContextHolder.setTenant(tenant);
    //调用service层代码
    } catch(Throw e) {
    e.printStackTrace();
    result.put(“msg”, “系统异常”);
    result.put(“code”, 1);
    } finally {
    TenantContextHolder.remove();
    System.out.println(“控制器层面,,移除tenant。。。”);
    }
    
    }
    
    如果每个控制器层代码,都需要用上面的模板来做,未免有点。。。
    所以为了统一处理 Tenant ,目前提供一个给予Spring AOP 的拦截器。
    代码如下:
    
    package persistent.prestige.modules.common.tenant;
    import org.aopalliance.intercept.MethodInterceptor;
    import org.aopalliance.intercept.MethodInvocation;
    import org.springframework.beans.factory.annotation.Autowired;
    import persistent.prestige.modules.edu.service.UserSchemeService;
    public class TenantControlInteceper implements MethodInterceptor {
        @Autowired
        private UserSchemeService userScemeService;
        @Override
        public Object invoke(MethodInvocation invocation) throws Throwable {
            try {
                if("login".equals(invocation.getMethod().getName())) {
                    return invocation.proceed();
                }
    
                System.out.println("控制器层面,,计算 tenant。。。");
                Object[] args = invocation.getArguments();
                String tenant = "";
                if( args != null && args.length > 0) {
                    tenant = (String)args[0];
                }
                TenantContextHolder.setTenant(tenant);
                return invocation.proceed();
            }finally {
                TenantContextHolder.remove();
                System.out.println("控制器层面,,移除tenant。。。");
            }
    
        }
    
    }
    
        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
    
    统一处理Tenant 的设置为移除;此处与代码中的有点差别,是因为,,根据用户登录名获取tenant的逻辑放在了上面登录接口中。
    只要遵循这样一种编码规范,action方法的第一个参数的值为 tenant 就好。
    配置一下拦截器【基于Spring AOP】
    这里写图片描述
    
    2.2.3、业务承载方法
    业务方法无需改变;但是要利用Mybatis 拦截器改写SQL。代码和配置如下:
    1)工具类
    
    package persistent.prestige.platform.mybatis.Interceptor;
    
    import java.lang.reflect.Field;
    
    import org.apache.commons.lang.reflect.FieldUtils;
    
    public class ReflectHelper {
    
        public static Object getFieldValue(Object obj , String fieldName ){  
    
            if(obj == null){  
                return null ;  
            }  
    
            Field targetField = getTargetField(obj.getClass(), fieldName);  
    
            try {  
                return FieldUtils.readField(targetField, obj, true ) ;  
            } catch (IllegalAccessException e) {  
                e.printStackTrace();  
            }   
            return null ;  
        }  
    
        public static Field getTargetField(Class<?> targetClass, String fieldName) {  
            Field field = null;  
    
            try {  
                if (targetClass == null) {  
                    return field;  
                }  
    
                if (Object.class.equals(targetClass)) {  
                    return field;  
                }  
    
                field = FieldUtils.getDeclaredField(targetClass, fieldName, true);  
                if (field == null) {  
                    field = getTargetField(targetClass.getSuperclass(), fieldName);  
                }  
            } catch (Exception e) {  
            }  
    
            return field;  
        }  
    
        public static void setFieldValue(Object obj , String fieldName , Object value ){  
            if(null == obj){return;}  
            Field targetField = getTargetField(obj.getClass(), fieldName);    
            try {  
                 FieldUtils.writeField(targetField, obj, value) ;  
            } catch (IllegalAccessException e) {  
                e.printStackTrace();  
            }   
        }   
    
    }
    
        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
    
    SQL拦截类
    
    package persistent.prestige.platform.mybatis.Interceptor;
    
    import java.sql.Connection;
    import java.util.Properties;
    
    import org.apache.ibatis.executor.statement.RoutingStatementHandler;
    import org.apache.ibatis.executor.statement.StatementHandler;
    import org.apache.ibatis.mapping.BoundSql;
    import org.apache.ibatis.mapping.MappedStatement;
    import org.apache.ibatis.plugin.Interceptor;
    import org.apache.ibatis.plugin.Intercepts;
    import org.apache.ibatis.plugin.Invocation;
    import org.apache.ibatis.plugin.Plugin;
    import org.apache.ibatis.plugin.Signature;
    import org.apache.kahadb.page.Page;
    import org.springframework.beans.factory.annotation.Autowired;
    
    import persistent.prestige.modules.common.tenant.TenantContextHolder;
    import persistent.prestige.modules.edu.dao.TeacherUserDao;
    
    @Intercepts({ @Signature(type = StatementHandler.class, method = "prepare", args = { Connection.class }) })
    public class TenantInterceptor implements Interceptor {
    
        @Override
        public Object intercept(Invocation invocation) throws Throwable {
    
            String tenant = TenantContextHolder.getTenant();
    
            if(tenant == null || tenant == "") {
                System.out.println("tenant 为空,不需要改写sql语句");
                return invocation.proceed();
            }
    
            if (invocation.getTarget() instanceof RoutingStatementHandler) {
    
                System.out.println("aaaaaaa");
                RoutingStatementHandler statementHandler = (RoutingStatementHandler) invocation
                        .getTarget();
                StatementHandler delegate = (StatementHandler) ReflectHelper
                        .getFieldValue(statementHandler, "delegate");
                BoundSql boundSql = delegate.getBoundSql();
                Object obj = boundSql.getParameterObject();
    
    
                // 通过反射获取delegate父类BaseStatementHandler的mappedStatement属性
                MappedStatement mappedStatement = (MappedStatement) ReflectHelper
                        .getFieldValue(delegate, "mappedStatement");
                // 拦截到的prepare方法参数是一个Connection对象
                Connection connection = (Connection) invocation.getArgs()[0];
                // 获取当前要执行的Sql语句,也就是我们直接在Mapper映射语句中写的Sql语句
                String sql = boundSql.getSql();
                // 给当前的page参数对象设置总记录数
                System.out.println("处理之前" + sql);
                //对 sql 增加 mycat 注解
    
    
                sql = "/*!mycat:schema=" + tenant + " */" + sql;
    
                System.out.println("加入处理后:" + sql);
    
    
    
                ReflectHelper.setFieldValue(boundSql, "sql", sql);
    
            }
            return invocation.proceed();
        }
    
        @Override
        public Object plugin(Object target) {
            // TODO Auto-generated method stub
            if (target instanceof StatementHandler) {
                return Plugin.wrap(target, this);
            } else {
                return target;
            }
        }
    
        @Override
        public void setProperties(Properties properties) {
            // TODO Auto-generated method stub
    
        }
    
    }
    
        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
    
    3)配置如下:
    
    这里写图片描述
    
    2.2.4、方案优缺点
    优点:
    对业务代码侵入少,开发人员无需关注数据在哪个逻辑库上,隔离性好。
    缺点
    如果需要对所有租户的数据进行汇聚的话,需要业务上去实现。
    
    该方案代码:请关注如下代码:
    控制层 persistent.prestige.modules.edu.action. EduControl
    里面有login的模拟实现,业务方法的实现。
    拦截器
    persistent.prestige.modules.common.tenant. TenantControlInteceper
    persistent.prestige.platform.mybatis.Interceptor. TenantInterceptor
    
    相关代码我已上传到:
    https://github.com/dingwpmz/Mycat-Demo
    
    3 多租户同一逻辑库方案
    3.1实现思想
    每个分片对应一个集团,每个业务表中增加一个分片字段 db_pos,,类型为int型,比如制定如下字段:
    0 h_xsgizx
    20 h_xsyz
    40 m_fhzx
    60 m_mzzx
    Mycat 提供一个逻辑库,其中每个分片代表一个集团,,由于集团数量是固定的,故可以采用 分片枚举 进行分片。
     
    这种方案,不是传统意义上的多租户,而是用mycat枚举分片规则。配置分片就好。
    
    3.2.4、方案优缺点
    优点:
    实现简单,不需要增加额外的拦截器等。并且多库汇聚非常方便。
    缺点:
    在业务开发中,需要在方法参数列表中,特别是DAO层,增加 分片字段参数。


    已有 0 人发表留言,猛击->>这里<<-参与讨论


    ITeye推荐




    0 0

    一致性问题可以算是分布式领域的一个圣殿级问题了,关于它的研究可以回溯到几十年前。
    
    拜占庭将军问题
    
    Leslie Lamport 在三十多年前发表的论文《拜占庭将军问题》(参考[1])。
    
    拜占庭位于如今的土耳其的伊斯坦布尔,是东罗马帝国的首都。由于当时拜占庭罗马帝国国土辽阔,为了防御目的,因此每个军队都分隔很远,将军与将军之间只能靠信差传消息。在战争的时候,拜占庭军队内所有将军必需达成 一致的共识,决定是否有赢的机会才去攻打敌人的阵营。但是,在军队内有可能存有叛徒和敌军的间谍,左右将军们的决定又扰乱整体军队的秩序,在进行共识时,结果并不代表大多数人的意见。这时候,在已知有成员不可靠的情况下,其余忠诚的将军在不受叛徒或间谍的影响下如何达成一致的协议,拜占庭问题就此形成。拜占庭假设是对现实世界的模型化,由于硬件错误、网络拥塞或断开以及遭到恶意攻击,计算机和网络可能出现不可预料的行为。
    
    Lamport 一直研究这类问题,发表了一系列论文。但综合总结一下就是回答下面三个问题:
    1.类似拜占庭将军这样的分布式一致性问题是否有解?
    2.如果有解的话需要满足什么样的条件?
    3.在特定前提条件的基础上,提出一种解法。
    
    前两个问题 Lamport 在论文《拜占庭将军问题》已经回答,而第三个问题在后来的论文 《The Part-Time Parliament》中提出了一种算法并命名为 Paxos。这篇论文使用了大量的数学证明,而我基本就看不懂了(数学符号都认不全-。-;),考虑到大家理解起来都比较困难,后来 Lamport 又写了另外一篇论文 《Paxos Made Simple》完全放弃了所有数学符号的证明,使用纯英文的逻辑推导。我勉强逐字看了一遍,然后感觉若有所悟,但你问我搞懂了吗,我的标准应该还是没懂。对我来说理解一个算法有个明确的标准,就是真的懂了会在头脑里能将算法映射为代码,而看完后面一篇论文仅仅是若有所悟还达不到能映射为代码的清晰度。
    
    虽然 Lamport 认为 Paxos 很 simple,但也许只是针对他的头脑而言。事实是大家理解起来都还是很困难,所以 Raft 就是建立在希望得到一个更易于理解的 Paxos 算法的替代品。把可理解性作为算法的主要目标之一,从论文题目就可看出来《In Search of an Understandable Consensus Algorithm》。
    
    在进入正题前,我想起一个旧故事可以很直观的感受对一个问题不同的思维视角在可理解性上的差异。
    
    不同视角的可理解性
    
    依稀记得大约在二十年前,我还在读初中时在一本可能大概叫《数学中的发散思维》(不能很清晰记得书名了)的书中看到这么一个有趣的问题。
    
    
    甲乙两人轮流在一张圆桌上平放黑白围棋子,每次放一子,棋子不许重叠,谁先没有地方放就输。
     请问怎样放才能赢?
    
    这个问题有两层意思,第一,有没有一种放法保证必赢?第二,如果有怎么证明?这里先停顿下,思考十秒钟。
    
    
    
    上面的图回答了这个问题,就是先行者必胜,这里使用了三种不同的思维方式。
    1.假如桌子只有一个围棋子那么大。
    2.假如桌子无限大,先行者先占住圆心,由于圆是对称图形,所以只要对手还能找到位置放,你总能在对称的另一面找到位置放。
    3.一个圆中可画单数个直径相等且互切的小圆。
    
    三种不同的思维方式在可理解性难度上逐渐加深。第一种是极简化思维,但数学上是不严谨的。第二种是极限思维,和第一种结合起来就是数学归纳法了,在数学上是严谨的。第三种是形象思维,使用了几何学概念,但对于没有几何学基础知识的人就很难理解了。
    
    Raft 协议的易理解性描述
    
    虽然 Raft 的论文比 Paxos 简单版论文还容易读了,但论文依然发散的比较多,相对冗长。读完后掩卷沉思觉得还是整理一下才会更牢靠,变成真正属于自己的。这里我就借助前面黑白棋落子里第一种极简思维来描述和概念验证下 Raft 协议的工作方式。
    
    在一个由 Raft 协议组织的集群中有三类角色:
    1.Leader(领袖)
    2.Follower(群众)
    3.Candidate(候选人)
    
    就像一个民主社会,领袖由民众投票选出。刚开始没有领袖,所有集群中的参与者都是群众,那么首先开启一轮大选,在大选期间所有群众都能参与竞选,这时所有群众的角色就变成了候选人,民主投票选出领袖后就开始了这届领袖的任期,然后选举结束,所有除领袖的候选人又变回群众角色服从领袖领导。这里提到一个概念「任期」,用术语 Term 表达。关于 Raft 协议的核心概念和术语就这么多而且和现实民主制度非常匹配,所以很容易理解。三类角色的变迁图如下,结合后面的选举过程来看很容易理解。
    
    
    
    Leader 选举过程
    
    在极简的思维下,一个最小的 Raft 民主集群需要三个参与者(如下图:A、B、C),这样才可能投出多数票。初始状态 ABC 都是 Follower,然后发起选举这时有三种可能情形发生。下图中前二种都能选出 Leader,第三种则表明本轮投票无效(Split Votes),每方都投给了自己,结果没有任何一方获得多数票。之后每个参与方随机休息一阵(Election Timeout)重新发起投票直到一方获得多数票。这里的关键就是随机 timeout,最先从 timeout 中恢复发起投票的一方向还在 timeout 中的另外两方请求投票,这时它们就只能投给对方了,很快达成一致。
    
    
    
    选出 Leader 后,Leader 通过定期向所有 Follower 发送心跳信息维持其统治。若 Follower 一段时间未收到 Leader 的心跳则认为 Leader 可能已经挂了再次发起选主过程。
    
    Leader 节点对一致性的影响
    
    Raft 协议强依赖 Leader 节点的可用性来确保集群数据的一致性。数据的流向只能从 Leader 节点向 Follower 节点转移。当 Client 向集群 Leader 节点提交数据后,Leader 节点接收到的数据处于未提交状态(Uncommitted),接着 Leader 节点会并发向所有 Follower 节点复制数据并等待接收响应,确保至少集群中超过半数节点已接收到数据后再向 Client 确认数据已接收。一旦向 Client 发出数据接收 Ack 响应后,表明此时数据状态进入已提交(Committed),Leader 节点再向 Follower 节点发通知告知该数据状态已提交。
    
    
    
    在这个过程中,主节点可能在任意阶段挂掉,看下 Raft 协议如何针对不同阶段保障数据一致性的。
    
    1. 数据到达 Leader 节点前
    
    这个阶段 Leader 挂掉不影响一致性,不多说。
    
    
    
    2. 数据到达 Leader 节点,但未复制到 Follower 节点
    
    这个阶段 Leader 挂掉,数据属于未提交状态,Client 不会收到 Ack 会认为超时失败可安全发起重试。Follower 节点上没有该数据,重新选主后 Client 重试重新提交可成功。原来的 Leader 节点恢复后作为 Follower 加入集群重新从当前任期的新 Leader 处同步数据,强制保持和 Leader 数据一致。
    
    
    
    3. 数据到达 Leader 节点,成功复制到 Follower 所有节点,但还未向 Leader 响应接收
    
    这个阶段 Leader 挂掉,虽然数据在 Follower 节点处于未提交状态(Uncommitted)但保持一致,重新选出 Leader 后可完成数据提交,此时 Client 由于不知到底提交成功没有,可重试提交。针对这种情况 Raft 要求 RPC 请求实现幂等性,也就是要实现内部去重机制。
    
    
    
    4. 数据到达 Leader 节点,成功复制到 Follower 部分节点,但还未向 Leader 响应接收
    
    这个阶段 Leader 挂掉,数据在 Follower 节点处于未提交状态(Uncommitted)且不一致,Raft 协议要求投票只能投给拥有最新数据的节点。所以拥有最新数据的节点会被选为 Leader 再强制同步数据到 Follower,数据不会丢失并最终一致。
    
    
    
    5. 数据到达 Leader 节点,成功复制到 Follower 所有或多数节点,数据在 Leader 处于已提交状态,但在 Follower 处于未提交状态
    
    这个阶段 Leader 挂掉,重新选出新 Leader 后的处理流程和阶段 3 一样。
    
    
    
    6. 数据到达 Leader 节点,成功复制到 Follower 所有或多数节点,数据在所有节点都处于已提交状态,但还未响应 Client
    
    这个阶段 Leader 挂掉,Cluster 内部数据其实已经是一致的,Client 重复重试基于幂等策略对一致性无影响。
    
    
    
    7. 网络分区导致的脑裂情况,出现双 Leader
    
    网络分区将原先的 Leader 节点和 Follower 节点分隔开,Follower 收不到 Leader 的心跳将发起选举产生新的 Leader。这时就产生了双 Leader,原先的 Leader 独自在一个区,向它提交数据不可能复制到多数节点所以永远提交不成功。向新的 Leader 提交数据可以提交成功,网络恢复后旧的 Leader 发现集群中有更新任期(Term)的新 Leader 则自动降级为 Follower 并从新 Leader 处同步数据达成集群数据一致。
    
    
    
    综上穷举分析了最小集群(3 节点)面临的所有情况,可以看出 Raft 协议都能很好的应对一致性问题,并且很容易理解。
    
    总结
    
    就引用 Raft 论文最后的一节的综述来总结本文吧。
    
    
    算法以正确性、高效性、简洁性作为主要设计目标。
     虽然这些都是很有价值的目标,但这些目标都不会达成直到开发者写出一个可用的实现。
     所以我们相信可理解性同样重要。
    
    深以为然,想想 Paxos 算法是 Leslie Lamport 在 1990 年就公开发表在了自己的网站上,想想我们是什么时候才听说的?什么时候才有一个可用的实现?而 Raft 算法是 2013 年发表的,大家在参考[5]上面可以看到有多少个不同语言开源的实现库了,这就是可理解性的重要性。
    
    参考
    
    [1]. LESLIE LAMPORT, ROBERT SHOSTAK, MARSHALL PEASE. The Byzantine General Problem. 1982
     [2]. Leslie Lamport. The Part-Time Parliament. 1998
     [3]. Leslie Lamport. Paxos Made Simple. 2001
     [4]. Diego Ongaro and John Ousterhout. Raft Paper. 2013
     [5]. Raft Website. The Raft Consensus Algorithm
     [6]. Raft Demo. Raft Animate Demo
    


    已有 0 人发表留言,猛击->>这里<<-参与讨论


    ITeye推荐




    0 0
  • 11/14/17--18:40: 工作10多年的感想
  • 如今,在it行业摸爬滚打10多年了。
    从传统行业软件  到   互联网的软件,
    从互联网 到 移动互联网;
    从移动互联网 到 大数据,云计算;
    现在 还得学习AI。
    一刻都没停息过,难道真的要活到老,学到老。
    本人酷爱技术,虽然同事从70后,到80后
    又从80后 到90后
    又从90后 到95后,
    再过几年,我的小侄女 00后 就过来和我做同事了。
    再过几年,我的孩子,10后,就来当同事了,甚至可以做你的领导。
    技术 就这样。身边的同事 一直再变的越来越年轻。
    咱们是继续做技术呢?  还是做管理呢?还是创业?  还是换行?
    其实 很多人 选择了 做管理,在一个公司耗着。
    软件公司的管理 都很扁平化,还是技术说了算,管理太虚了。
    做技术也是其乐无穷,安静的写个代码,不用天天开会,开会真烦人,自己一无所获,各个部门的pk,纯属 浪费生命。
    创业呢? 确实很累,还得有好想法,有融资,也是水很深啊
    换行也行,回去种地,养猪,承包大片地,走低端路线。也许挣钱不少。
    总之,摆在面前的n条路,看你怎么看,怎么选择?
    不知道大家有什么想法,可以留言,我也是一脸迷茫。

    已有 2 人发表留言,猛击->>这里<<-参与讨论


    ITeye推荐