神兽牛
神兽牛

Flink DataStreamAPI与DataSetAPI应用案例实战-Flink牛刀小试

版权声明：本套技术专栏是作者（秦凯新）平时工作的总结和升华，通过从真实商业环境抽取案例进行总结和分享，并给出商业应用的调优建议和集群环境容量规划等内容，请持续关注本套博客。期待加入IOT时代最具战斗力的团队。QQ邮箱地址：[email protected]，如有任何学术交流，可随时联系。
在这里插入图片描述

1 DataStreamAPI

1.1 DataStream Data Sources

  • source是程序的数据源输入，你可以通过StreamExecutionEnvironment.addSource(sourceFunction)来为你的程序添加一个source。

  • flink提供了大量的已经实现好的source方法，可以自定义source
    通过实现sourceFunction接口来自定义无并行度的source。

      1 使用并行度为1的source
  public class MyNoParalleSource implements SourceFunction{
  
      private long count = 1L;
  
      private boolean isRunning = true;
  
      /**
       * 主要的方法
       * 启动一个source
       * 大部分情况下，都需要在这个run方法中实现一个循环，这样就可以循环产生数据了
       *
       * @param ctx
       * @throws Exception
       */
      @Override
      public void run(SourceContext ctx) throws Exception {
          while(isRunning){
              ctx.collect(count);
              count++;
              //每秒产生一条数据
              Thread.sleep(1000);
          }
      }
      * 取消一个cancel的时候会调用的方法
      @Override
      public void cancel() {
          isRunning = false;
      }
  }
  
  2 Main方法执行
  public class StreamingDemoWithMyNoPralalleSource {
      public static void main(String[] args) throws Exception {
      //获取Flink的运行环境
      StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
      //获取数据源
      DataStreamSource text = env.addSource(new MyNoParalleSource()).setParallelism(1); //注意：针对此source，并行度只能设置为1
      DataStream num = text.map(new MapFunction() {
          @Override
          public Long map(Long value) throws Exception {
              System.out.println("接收到数据：" + value);
              return value;
          }
      });

  //每2秒钟处理一次数据
  DataStream sum = num.timeWindowAll(Time.seconds(2)).sum(0);
  //打印结果
  sum.print().setParallelism(1);
  String jobName = StreamingDemoWithMyNoPralalleSource.class.getSimpleName();
  env.execute(jobName);
   }
  }

版权声明：本套技术专栏是作者（秦凯新）平时工作的总结和升华，通过从真实商业环境抽取案例进行总结和分享，并给出商业应用的调优建议和集群环境容量规划等内容，请持续关注本套博客。QQ邮箱地址：[email protected]，如有任何学术交流，可随时联系。

  • 可以通过实现ParallelSourceFunction接口或者继承RichParallelSourceFunction来自定义有并行度的source。继承RichParallelSourceFunction的那些SourceFunction意味着它们都是并行执行的并且可能有一些资源需要open/close

      public class MyParalleSource implements ParallelSourceFunction {
  private long count = 1L;
  private boolean isRunning = true;

  /**
   * 主要的方法
   * 启动一个source
   * 大部分情况下，都需要在这个run方法中实现一个循环，这样就可以循环产生数据了
   *
   * @param ctx
   * @throws Exception
   */
  @Override
  public void run(SourceContext ctx) throws Exception {
      while(isRunning){
          ctx.collect(count);
          count++;
          //每秒产生一条数据
          Thread.sleep(1000);
      }
  }
  /**
   * 取消一个cancel的时候会调用的方法
   *
   */
  @Override
  public void cancel() {
      isRunning = false;
   }
}

public class StreamingDemoWithMyPralalleSource {
    public static void main(String[] args) throws Exception {
      //获取Flink的运行环境
      StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

      //获取数据源
      DataStreamSource text = env.addSource(new MyParalleSource()).setParallelism(2);

      DataStream num = text.map(new MapFunction() {
          @Override
          public Long map(Long value) throws Exception {
              System.out.println("接收到数据：" + value);
              return value;
          }
      });

      //每2秒钟处理一次数据
      DataStream sum = num.timeWindowAll(Time.seconds(2)).sum(0);

      //打印结果
      sum.print().setParallelism(1);

      String jobName = StreamingDemoWithMyPralalleSource.class.getSimpleName();
      env.execute(jobName);
      }
   }


   public class MyRichParalleSource extends RichParallelSourceFunction {
      private long count = 1L;
      private boolean isRunning = true;
      /**
       * 主要的方法
       * 启动一个source
       * 大部分情况下，都需要在这个run方法中实现一个循环，这样就可以循环产生数据了
       * @param ctx
       * @throws Exception
       */
      @Override
      public void run(SourceContext ctx) throws Exception {
          while(isRunning){
              ctx.collect(count);
              count++;
              //每秒产生一条数据
              Thread.sleep(1000);
          }
      }
      /**
       * 取消一个cancel的时候会调用的方法
       *
       */
      @Override
      public void cancel() {
          isRunning = false;
      }
      /**
       * 这个方法只会在最开始的时候被调用一次
       * 实现获取链接的代码
       * @param parameters
       * @throws Exception
       */
      @Override
      public void open(Configuration parameters) throws Exception {
          System.out.println("open.............");
          super.open(parameters);
      }
  
      /**
       * 实现关闭链接的代码
       * @throws Exception
       */
      @Override
      public void close() throws Exception {
          super.close();
      }
  }
  
   public class StreamingDemoWithMyRichPralalleSource {
   
       public static void main(String[] args) throws Exception {
          //获取Flink的运行环境
          StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
  
          //获取数据源
          DataStreamSource text = env.addSource(new MyRichParalleSource()).setParallelism(2);
  
          DataStream num = text.map(new MapFunction() {
              @Override
              public Long map(Long value) throws Exception {
                  System.out.println("接收到数据：" + value);
                  return value;
              }
          });
  
          //每2秒钟处理一次数据
          DataStream sum = num.timeWindowAll(Time.seconds(2)).sum(0);
  
          //打印结果
          sum.print().setParallelism(1);
  
          String jobName = StreamingDemoWithMyRichPralalleSource.class.getSimpleName();
          env.execute(jobName);
          }
      }

  • 基于文件
    readTextFile(path)
    读取文本文件，文件遵循TextInputFormat 读取规则，逐行读取并返回。

  • 基于socket
    socketTextStream从socker中读取数据，元素可以通过一个分隔符切开。

      public class SocketDemoFullCount {
      public static void main(String[] args) throws Exception{
          //获取需要的端口号
          int port;
          try {
              ParameterTool parameterTool = ParameterTool.fromArgs(args);
              port = parameterTool.getInt("port");
          }catch (Exception e){
              System.err.println("No port set. use default port 9010--java");
              port = 9010;
          }
          //获取flink的运行环境
          StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
          String hostname = "SparkMaster";
          String delimiter = "\n";
          //连接socket获取输入的数据
          DataStreamSource text = env.socketTextStream(hostname, port, delimiter);
  
          DataStream> intData = text.map(new MapFunction>() {
              @Override
              public Tuple2 map(String value) throws Exception {
                  return new Tuple2<>(1,Integer.parseInt(value));
              }
          });
  
          intData.keyBy(0)
                  .timeWindow(Time.seconds(5))
                  .process(new ProcessWindowFunction, String, Tuple, TimeWindow>() {
                      @Override
                      public void process(Tuple key, Context context, Iterable> elements, Collector out) throws Exception {
                          System.out.println("执行process");
                          long count = 0;
                           for(Tuple2 element: elements){
                              count++;
                          }
                          out.collect("window:"+context.window()+",count:"+count);
                      }
                  }).print();
          //这一行代码一定要实现，否则程序不执行
          env.execute("Socket window count");
      }
  }

  • 基于集合
    fromCollection(Collection)
    通过java 的collection集合创建一个数据流，集合中的所有元素必须是相同类型的。

       public class StreamingFromCollection {
      public static void main(String[] args) throws Exception {
          //获取Flink的运行环境
          StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
          ArrayList data = new ArrayList<>();
          data.add(10);
          data.add(15);
          data.add(20);
  
          //指定数据源
          DataStreamSource collectionData = env.fromCollection(data);
          //通map对数据进行处理
          DataStream num = collectionData.map(new MapFunction() {
              @Override
              public Integer map(Integer value) throws Exception {
                  return value + 1;
              }
          });
          //直接打印
          num.print().setParallelism(1);
          env.execute("StreamingFromCollection");
      }

    }

  • 自定义输入
    addSource 可以实现读取第三方数据源的数据
    系统内置提供了一批connectors，连接器会提供对应的source支持【kafka】

1.2 DataStream Transformations

  • map：输入一个元素，然后返回一个元素，中间可以做一些清洗转换等操作

  • flatmap：输入一个元素，可以返回零个，一个或者多个元素

  • keyBy：根据指定的key进行分组，相同key的数据会进入同一个分区

      dataStream.keyBy("someKey") // 指定对象中的 "someKey"字段作为分组key
  dataStream.keyBy(0) //指定Tuple中的第一个元素作为分组key
  
  注意：以下类型是无法作为key的
  1：一个实体类对象，没有重写hashCode方法，并且依赖object的hashCode方法
  2：一个任意形式的数组类型
  3：基本数据类型，int，long

  • filter：过滤函数，对传入的数据进行判断，符合条件的数据会被留下。

      public class StreamingDemoFilter {
      public static void main(String[] args) throws Exception {
          //获取Flink的运行环境
          StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
          //获取数据源
          DataStreamSource text = env.addSource(new MyNoParalleSource()).setParallelism(1);//注意：针对此source，并行度只能设置为1
          DataStream num = text.map(new MapFunction() {
              @Override
              public Long map(Long value) throws Exception {
                  System.out.println("原始接收到数据：" + value);
                  return value;
              }
          });
  
          //执行filter过滤，满足条件的数据会被留下
          DataStream filterData = num.filter(new FilterFunction() {
              //把所有的奇数过滤掉
              @Override
              public boolean filter(Long value) throws Exception {
                  return value % 2 == 0;
              }
          });
  
          DataStream resultData = filterData.map(new MapFunction() {
              @Override
              public Long map(Long value) throws Exception {
                  System.out.println("过滤之后的数据：" + value);
                  return value;
              }
          });
  
  
          //每2秒钟处理一次数据
          DataStream sum = resultData.timeWindowAll(Time.seconds(2)).sum(0);
  
          //打印结果
          sum.print().setParallelism(1);
  
          String jobName = StreamingDemoFilter.class.getSimpleName();
          env.execute(jobName);
      }
  }

版权声明：本套技术专栏是作者（秦凯新）平时工作的总结和升华，通过从真实商业环境抽取案例进行总结和分享，并给出商业应用的调优建议和集群环境容量规划等内容，请持续关注本套博客。QQ邮箱地址：[email protected]，如有任何学术交流，可随时联系。

  • reduce：对数据进行聚合操作，结合当前元素和上一次reduce返回的值进行聚合操作，然后返回一个新的值

  • aggregations：sum(),min(),max()等

  • window：在后面单独详解

  • Union：合并多个流，新的流会包含所有流中的数据，但是union是一个限制，就是所有合并的流类型必须是一致的。

      public class StreamingDemoUnion {
  public static void main(String[] args) throws Exception {
      //获取Flink的运行环境
      StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

      //获取数据源
      DataStreamSource text1 = env.addSource(new MyNoParalleSource()).setParallelism(1);//注意：针对此source，并行度只能设置为1

      DataStreamSource text2 = env.addSource(new MyNoParalleSource()).setParallelism(1);

      //把text1和text2组装到一起
      DataStream text = text1.union(text2);

      DataStream num = text.map(new MapFunction() {
          @Override
          public Long map(Long value) throws Exception {
              System.out.println("原始接收到数据：" + value);
              return value;
          }
      });
      //每2秒钟处理一次数据
      DataStream sum = num.timeWindowAll(Time.seconds(2)).sum(0);
      //打印结果
      sum.print().setParallelism(1);
      String jobName = StreamingDemoUnion.class.getSimpleName();
      env.execute(jobName);
  }

    }

  • Connect：和union类似，但是只能连接两个流，两个流的数据类型可以不同，会对两个流中的数据应用不同的处理方法。

  • CoMap, CoFlatMap：在ConnectedStreams中需要使用这种函数，类似于map和flatmap

      public class StreamingDemoConnect {
  
      public static void main(String[] args) throws Exception {
          //获取Flink的运行环境
          StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
          //获取数据源
          DataStreamSource text1 = env.addSource(new MyNoParalleSource()).setParallelism(1);//注意：针对此source，并行度只能设置为1
          DataStreamSource text2 = env.addSource(new MyNoParalleSource()).setParallelism(1);
          SingleOutputStreamOperator text2_str = text2.map(new MapFunction() {
              @Override
              public String map(Long value) throws Exception {
                  return "str_" + value;
              }
          });
  
          ConnectedStreams connectStream = text1.connect(text2_str);
  
          SingleOutputStreamOperator result = connectStream.map(new CoMapFunction() {
              @Override
              public Object map1(Long value) throws Exception {
                  return value;
              }
              @Override
              public Object map2(String value) throws Exception {
                  return value;
              }
          });
          //打印结果
          result.print().setParallelism(1);
          String jobName = StreamingDemoConnect.class.getSimpleName();
          env.execute(jobName);
      }
  }
 

  •  
    Split：根据规则把一个数据流切分为多个流：
     
    • 

  •  
    Select：和split配合使用，选择切分后的流
     
    public class StreamingDemoSplit {
      public static void main(String[] args) throws Exception {
          //获取Flink的运行环境
          StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
  
          //获取数据源
          DataStreamSource text = env.addSource(new MyNoParalleSource()).setParallelism(1);//注意：针对此source，并行度只能设置为1
  
          //对流进行切分，按照数据的奇偶性进行区分
          SplitStream splitStream = text.split(new OutputSelector() {
              @Override
              public Iterable select(Long value) {
                  ArrayList outPut = new ArrayList<>();
                  if (value % 2 == 0) {
                      outPut.add("even");//偶数
                  } else {
                      outPut.add("odd");//奇数
                  }
                  return outPut;
              }
          });
          
          //选择一个或者多个切分后的流
          DataStream evenStream = splitStream.select("even");
          DataStream oddStream = splitStream.select("odd");
  
          DataStream moreStream = splitStream.select("odd","even");
  
  
          //打印结果
          moreStream.print().setParallelism(1);
  
          String jobName = StreamingDemoSplit.class.getSimpleName();
          env.execute(jobName);
      }
  }

     
    • 


    1.3 DataStream API之partition
    

      

    •  
      Random partitioning：随机分区
       
      dataStream.shuffle()
       
      • 

    

    Flink DataStreamAPI与DataSetAPI应用案例实战-Flink牛刀小试_第1张图片
     Flink DataStreamAPI与DataSetAPI应用案例实战-Flink牛刀小试_第2张图片
    

      

    •  
      Rebalancing：对数据集进行再平衡，重分区，消除数据倾斜
       
      dataStream.rebalance()
       
      • 

    

    Flink DataStreamAPI与DataSetAPI应用案例实战-Flink牛刀小试_第3张图片
    

    Flink DataStreamAPI与DataSetAPI应用案例实战-Flink牛刀小试_第4张图片
    

      

    •  
      Rescaling：如果上游操作有2个并发，而下游操作有4个并发，那么上游的一个并发结果分配给下游的两个并发操作，另外的一个并发结果分配给了下游的另外两个并发操作。另一方面，下游有两个并发操作而上游又4个并发操作，那么上游的其中两个操作的结果分配给下游的一个并发操作而另外两个并发操作的结果则分配给另外一个并发操作。
       
      • 

    •  
      Rescaling与Rebalancing的区别：
       Rebalancing会产生全量重分区，而Rescaling不会。
       
      dataStream.rescale()
       
      • 

    

    Flink DataStreamAPI与DataSetAPI应用案例实战-Flink牛刀小试_第5张图片
    

      

    •  
      Custom partitioning：自定义分区需要实现Partitioner接口
       
      dataStream.partitionCustom(partitioner, “someKey”) 针对对象
       
      dataStream.partitionCustom(partitioner, 0) 针对Tuple
       
         public class MyPartition implements Partitioner {
      @Override
      public int partition(Long key, int numPartitions) {
          System.out.println("分区总数："+numPartitions);
          if(key % 2 == 0){
              return 0;
          }else{
              return 1;
          }
      }
  }

  public class SteamingDemoWithMyParitition {
      public static void main(String[] args) throws Exception{
          StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
          env.setParallelism(2);
          DataStreamSource text = env.addSource(new MyNoParalleSource());
  
          //对数据进行转换，把long类型转成tuple1类型
          DataStream> tupleData = text.map(new MapFunction>() {
              @Override
              public Tuple1 map(Long value) throws Exception {
                  return new Tuple1<>(value);
              }
          });
          //分区之后的数据
          DataStream> partitionData= tupleData.partitionCustom(new MyPartition(), 0);
          DataStream result = partitionData.map(new MapFunction, Long>() {
              @Override
              public Long map(Tuple1 value) throws Exception {
                  System.out.println("当前线程id：" + Thread.currentThread().getId() + ",value: " + value);
                  return value.getField(0);
              }
          });
  
          result.print().setParallelism(1);
  
          env.execute("SteamingDemoWithMyParitition");
  
      }
  }

       
      • 

    •  
      Broadcasting：在后面单独详解
       
      • 

    

    1.4 DataStream Sink
    

      

    •  
      writeAsText()：将元素以字符串形式逐行写入，这些字符串通过调用每个元素的toString()方法来获取
       
      • 

    •  
      print() / printToErr()：打印每个元素的toString()方法的值到标准输出或者标准错误输出流中
       
      • 

    •  
      自定义输出addSink【kafka、redis】
       
        
      org.apache.bahir
      flink-connector-redis_2.11
      1.0
  


 public class StreamingDemoToRedis {
      public static void main(String[] args) throws Exception{
          StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
          DataStreamSource text = env.socketTextStream("hadoop100", 9000, "\n");

          //对数据进行组装,把string转化为tuple2
          DataStream> l_wordsData = text.map(new MapFunction>() {
              @Override
              public Tuple2 map(String value) throws Exception {
                  return new Tuple2<>("l_words", value);
              }
          });
  
          //创建redis的配置
          FlinkJedisPoolConfig conf = new FlinkJedisPoolConfig.Builder().setHost("SparkMaster").setPort(6379).build();
  
          //创建redissink
          RedisSink> redisSink = new RedisSink<>(conf, new MyRedisMapper());
  
          l_wordsData.addSink(redisSink);
  
          env.execute("StreamingDemoToRedis");
      }
  
      public static class MyRedisMapper implements RedisMapper>{
          //表示从接收的数据中获取需要操作的redis key
          @Override
          public String getKeyFromData(Tuple2 data) {
              return data.f0;
          }
          //表示从接收的数据中获取需要操作的redis value
          @Override
          public String getValueFromData(Tuple2 data) {
              return data.f1;
          }
  
          @Override
          public RedisCommandDescription getCommandDescription() {
              return new RedisCommandDescription(RedisCommand.LPUSH);
          }
      }
  }

       
      • 

    

    2 DataSet API
    

    2.1 DataSet Sources
    

      

    •  
      基于文件
       readTextFile(path)
       
        public class BatchWordCountJava {
      public static void main(String[] args) throws Exception{
      
          String inputPath = "D:\\data\\file";
          String outPath = "D:\\data\\result";
  
          //获取运行环境
          ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
          //获取文件中的内容
          DataSource text = env.readTextFile(inputPath);
  
          DataSet> counts = text.flatMap(new Tokenizer()).groupBy(0).sum(1);
          counts.writeAsCsv(outPath,"\n"," ").setParallelism(1);
          env.execute("batch word count");
  
      }
      public static class Tokenizer implements FlatMapFunction>{
          public void flatMap(String value, Collector> out) throws Exception {
              String[] tokens = value.toLowerCase().split("\\W+");
              for (String token: tokens) {
                  if(token.length()>0){
                      out.collect(new Tuple2(token,1));
                  }
              }
          }
      }
  }

       
      • 

    •  
      基于集合
       fromCollection(Collection)
       
      • 

    

    2.2 DataSet Transformations
    

      

    •  
      Map：输入一个元素，然后返回一个元素，中间可以做一些清洗转换等操作
       
      • 

    •  
      FlatMap：输入一个元素，可以返回零个，一个或者多个元素
       
      • 

    •  
      MapPartition：类似map，一次处理一个分区的数据【如果在进行map处理的时候需要获取第三方资源链接，建议使用MapPartition】
       
      public class BatchDemoMapPartition {
  public static void main(String[] args) throws Exception{
      //获取运行环境
      ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();

      ArrayList data = new ArrayList<>();
      data.add("hello you");
      data.add("hello me");
      DataSource text = env.fromCollection(data);
      /*text.map(new MapFunction() {
          @Override
          public String map(String value) throws Exception {
              //获取数据库连接--注意，此时是每过来一条数据就获取一次链接
              //处理数据
              //关闭连接
              return value;
          }
      });*/

      DataSet mapPartitionData = text.mapPartition(new MapPartitionFunction() {
          @Override
          public void mapPartition(Iterable values, Collector out) throws Exception {
              //获取数据库连接--注意，此时是一个分区的数据获取一次连接【优点，每个分区获取一次链接】
              //values中保存了一个分区的数据
              //处理数据
              Iterator it = values.iterator();
              while (it.hasNext()) {
                  String next = it.next();
                  String[] split = next.split("\\W+");
                  for (String word : split) {
                      out.collect(word);
                  }
              }
              //关闭链接
          }
      });
      mapPartitionData.print();
  }
}

       
      • 

    •  
      Filter：过滤函数，对传入的数据进行判断，符合条件的数据会被留下
       
      • 

    •  
      Reduce：对数据进行聚合操作，结合当前元素和上一次reduce返回的值进行聚合操作，然后返回一个新的值
       
      • 

    •  
      Aggregate：sum、max、min等
       
      • 

    •  
      Distinct：返回一个数据集中去重之后的元素，data.distinct()
       
         public class BatchDemoDistinct {
          public static void main(String[] args) throws Exception{
              //获取运行环境
              ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
              ArrayList data = new ArrayList<>();
              data.add("hello you");
              data.add("hello me");
      
              DataSource text = env.fromCollection(data);
              FlatMapOperator flatMapData = text.flatMap(new FlatMapFunction() {
                  @Override
                  public void flatMap(String value, Collector out) throws Exception {
                      String[] split = value.toLowerCase().split("\\W+");
                      for (String word : split) {
                          System.out.println("单词："+word);
                          out.collect(word);
                      }
                  }
              });
              flatMapData.distinct()// 对数据进行整体去重
                      .print();
          }
   }

       
      • 

    •  
      Join：内连接
       
      public class BatchDemoJoin {
  public static void main(String[] args) throws Exception{
      //获取运行环境
      ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
      //tuple2<用户id，用户姓名>
      ArrayList> data1 = new ArrayList<>();
      data1.add(new Tuple2<>(1,"zs"));
      data1.add(new Tuple2<>(2,"ls"));
      data1.add(new Tuple2<>(3,"ww"));

      //tuple2<用户id，用户所在城市>
      ArrayList> data2 = new ArrayList<>();
      data2.add(new Tuple2<>(1,"beijing"));
      data2.add(new Tuple2<>(2,"shanghai"));
      data2.add(new Tuple2<>(3,"guangzhou"));


      DataSource> text1 = env.fromCollection(data1);
      DataSource> text2 = env.fromCollection(data2);
      
      text1.join(text2).where(0)//指定第一个数据集中需要进行比较的元素角标
                      .equalTo(0)//指定第二个数据集中需要进行比较的元素角标
                      .with(new JoinFunction, Tuple2, Tuple3>() {
                          @Override
                          public Tuple3 join(Tuple2 first, Tuple2 second)
                                  throws Exception {
                              return new Tuple3<>(first.f0,first.f1,second.f1);
                          }
                      }).print();

      //注意，这里用map和上面使用的with最终效果是一致的。
      /*text1.join(text2).where(0)//指定第一个数据集中需要进行比较的元素角标
              .equalTo(0)//指定第二个数据集中需要进行比较的元素角标
              .map(new MapFunction,Tuple2>, Tuple3>() {
                  @Override
                  public Tuple3 map(Tuple2, Tuple2> value) throws Exception {
                      return new Tuple3<>(value.f0.f0,value.f0.f1,value.f1.f1);
                  }
              }).print();*/
  }
}

       
      • 

    •  
      OuterJoin：外链接
       
      public class BatchDemoOuterJoin {

      public static void main(String[] args) throws Exception{
  
          //获取运行环境
          ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
  
          //tuple2<用户id，用户姓名>
          ArrayList> data1 = new ArrayList<>();
          data1.add(new Tuple2<>(1,"zs"));
          data1.add(new Tuple2<>(2,"ls"));
          data1.add(new Tuple2<>(3,"ww"));
  
  
          //tuple2<用户id，用户所在城市>
          ArrayList> data2 = new ArrayList<>();
          data2.add(new Tuple2<>(1,"beijing"));
          data2.add(new Tuple2<>(2,"shanghai"));
          data2.add(new Tuple2<>(4,"guangzhou"));
  
  
          DataSource> text1 = env.fromCollection(data1);
          DataSource> text2 = env.fromCollection(data2);
  
          /**
           * 左外连接
           *
           * 注意：second这个tuple中的元素可能为null
           *
           */
          text1.leftOuterJoin(text2)
                  .where(0)
                  .equalTo(0)
                  .with(new JoinFunction, Tuple2, Tuple3>() {
                      @Override
                      public Tuple3 join(Tuple2 first, Tuple2 second) throws Exception {
                          if(second==null){
                              return new Tuple3<>(first.f0,first.f1,"null");
                          }else{
                              return new Tuple3<>(first.f0,first.f1,second.f1);
                          }
  
                      }
                  }).print();
  
          /**
           * 右外连接
           *
           * 注意：first这个tuple中的数据可能为null
           *
           */
          text1.rightOuterJoin(text2)
                  .where(0)
                  .equalTo(0)
                  .with(new JoinFunction, Tuple2, Tuple3>() {
                      @Override
                      public Tuple3 join(Tuple2 first, Tuple2 second) throws Exception {
                          if(first==null){
                              return new Tuple3<>(second.f0,"null",second.f1);
                          }
                          return new Tuple3<>(first.f0,first.f1,second.f1);
                      }
                  }).print();
          /**
           * 全外连接
           *
           * 注意：first和second这两个tuple都有可能为null
           *
           */
          text1.fullOuterJoin(text2)
                  .where(0)
                  .equalTo(0)
                  .with(new JoinFunction, Tuple2, Tuple3>() {
                      @Override
                      public Tuple3 join(Tuple2 first, Tuple2 second) throws Exception {
                          if(first==null){
                              return new Tuple3<>(second.f0,"null",second.f1);
                          }else if(second == null){
                              return new Tuple3<>(first.f0,first.f1,"null");
                          }else{
                              return new Tuple3<>(first.f0,first.f1,second.f1);
                          }
                      }
                  }).print();
      }
  }

       
      • 

    •  
      Cross：获取两个数据集的笛卡尔积
       
      public class BatchDemoCross {
  public static void main(String[] args) throws Exception{
      //获取运行环境
      ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();

      //tuple2<用户id，用户姓名>
      ArrayList data1 = new ArrayList<>();
      data1.add("zs");
      data1.add("ww");
      //tuple2<用户id，用户所在城市>
      ArrayList data2 = new ArrayList<>();
      data2.add(1);
      data2.add(2);
      DataSource text1 = env.fromCollection(data1);
      DataSource text2 = env.fromCollection(data2);
      CrossOperator.DefaultCross cross = text1.cross(text2);
      cross.print();
  }

       
      • 

    •  
      Union：返回两个数据集的总和，数据类型需要一致
       
      • 

    •  
      First-n：获取集合中的前N个元素
       
      • 

    •  
      Sort Partition：在本地对数据集的所有分区进行排序，通过sortPartition()的链接调用来完成对多个字段的排序
       
      public class BatchDemoFirstN {
  public static void main(String[] args) throws Exception{
      //获取运行环境
      ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
      ArrayList> data = new ArrayList<>();
      data.add(new Tuple2<>(2,"zs"));
      data.add(new Tuple2<>(4,"ls"));
      data.add(new Tuple2<>(3,"ww"));
      data.add(new Tuple2<>(1,"xw"));
      data.add(new Tuple2<>(1,"aw"));
      data.add(new Tuple2<>(1,"mw"));

      DataSource> text = env.fromCollection(data);
      //获取前3条数据，按照数据插入的顺序
      text.first(3).print();
      System.out.println("==============================");

      //根据数据中的第一列进行分组，获取每组的前2个元素
      text.groupBy(0).first(2).print();
      System.out.println("==============================");

      //根据数据中的第一列分组，再根据第二列进行组内排序[升序]，获取每组的前2个元素
      text.groupBy(0).sortGroup(1, Order.ASCENDING).first(2).print();
      System.out.println("==============================");

      //不分组，全局排序获取集合中的前3个元素，针对第一个元素升序，第二个元素倒序
      text.sortPartition(0,Order.ASCENDING).sortPartition(1,Order.DESCENDING).first(3).print();
  }

       
      }
       
      • 

    

    2.3 DataSet partition
    

      

    •  
      Rebalance：对数据集进行再平衡，重分区，消除数据倾斜
       
      • 

    •  
      Hash-Partition：根据指定key的哈希值对数据集进行分区
       
      partitionByHash()
       
      • 

    

    Flink DataStreamAPI与DataSetAPI应用案例实战-Flink牛刀小试_第6张图片
    

      

    • Range-Partition：根据指定的key对数据集进行范围分区
       .partitionByRange()
      • 

    

    Flink DataStreamAPI与DataSetAPI应用案例实战-Flink牛刀小试_第7张图片
    

      

    •  
      Custom Partitioning：自定义分区规则
       
      自定义分区需要实现Partitioner接口
       
      partitionCustom(partitioner, “someKey”)
       
      partitionCustom(partitioner, 0)
       
        public class BatchDemoHashRangePartition {
      public static void main(String[] args) throws Exception{
          //获取运行环境
          ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
  
          ArrayList> data = new ArrayList<>();
          data.add(new Tuple2<>(1,"hello1"));
          data.add(new Tuple2<>(2,"hello2"));
          data.add(new Tuple2<>(2,"hello3"));
          data.add(new Tuple2<>(3,"hello4"));
          data.add(new Tuple2<>(3,"hello5"));
          data.add(new Tuple2<>(3,"hello6"));
          data.add(new Tuple2<>(4,"hello7"));
          data.add(new Tuple2<>(4,"hello8"));
          data.add(new Tuple2<>(4,"hello9"));
          data.add(new Tuple2<>(4,"hello10"));
          data.add(new Tuple2<>(5,"hello11"));
          data.add(new Tuple2<>(5,"hello12"));
          data.add(new Tuple2<>(5,"hello13"));
          data.add(new Tuple2<>(5,"hello14"));
          data.add(new Tuple2<>(5,"hello15"));
          data.add(new Tuple2<>(6,"hello16"));
          data.add(new Tuple2<>(6,"hello17"));
          data.add(new Tuple2<>(6,"hello18"));
          data.add(new Tuple2<>(6,"hello19"));
          data.add(new Tuple2<>(6,"hello20"));
          data.add(new Tuple2<>(6,"hello21"));
  
  
          DataSource> text = env.fromCollection(data);
  
          /*text.partitionByHash(0).mapPartition(new MapPartitionFunction, Tuple2>() {
              @Override
              public void mapPartition(Iterable> values, Collector> out) throws Exception {
                  Iterator> it = values.iterator();
                  while (it.hasNext()){
                      Tuple2 next = it.next();
                      System.out.println("当前线程id："+Thread.currentThread().getId()+","+next);
                  }
  
              }
          }).print();*/
  
          text.partitionByRange(0).mapPartition(new MapPartitionFunction, Tuple2>() {
              @Override
              public void mapPartition(Iterable> values, Collector> out) throws Exception {
                  Iterator> it = values.iterator();
                  while (it.hasNext()){
                      Tuple2 next = it.next();
                      System.out.println("当前线程id："+Thread.currentThread().getId()+","+next);
                  }
              }
          }).print();
      }
  }

       
      • 

    

    2.4 DataSet Sink
    

      

    • writeAsText()：将元素以字符串形式逐行写入，这些字符串通过调用每个元素的toString()方法来获取
      • 

    • writeAsCsv()：将元组以逗号分隔写入文件中，行及字段之间的分隔是可配置的。每个字段的值来自对象的toString()方法
      • 

    • print()：打印每个元素的toString()方法的值到标准输出或者标准错误输出流中
      • 

    

    3 Flink 序列化器
    

      

    •  
      Flink自带了针对诸如int，long，String等标准类型的序列化器
       
      • 

    •  
      针对Flink无法实现序列化的数据类型，我们可以交给Avro和Kryo
       
      • 

    •  
      使用方法：ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
       
        使用avro序列化：env.getConfig().enableForceAvro();
  使用kryo序列化：env.getConfig().enableForceKryo();
  使用自定义序列化：env.getConfig().addDefaultKryoSerializer(Class type, Class> serializerClass)
  https://ci.apache.org/projects/flink/flink-docs-release-1.6/dev/custom_serializers.html

       
      • 

    

    4 Flink 数据类型
    

      

    •  
      Java Tuple 和 Scala case class
       
      • 

    •  
      Java POJOs：java实体类
       
      • 

    •  
      Primitive Types
       
      默认支持java和scala基本数据类型
       
      • 

    •  
      General Class Types
       
      默认支持大多数java和scala class
       
      • 

    •  
      Hadoop Writables
       支持hadoop中实现了org.apache.hadoop.Writable的数据类型
       
      • 

    •  
      Special Types
       
      例如scala中的Either Option 和Try
       
        https://ci.apache.org/projects/flink/flink-docs-release-1.6/dev/api_concepts.html#supported-data-types

       
      • 

    

    4 总结
    


     版权声明：本套技术专栏是作者（秦凯新）平时工作的总结和升华，通过从真实商业环境抽取案例进行总结和分享，并给出商业应用的调优建议和集群环境容量规划等内容，请持续关注本套博客。QQ邮箱地址：[email protected]，如有任何学术交流，可随时联系。
    

    秦凯新 于深圳 201812022220
    







    



    


    


    




    

    你可能感兴趣的:(大数据,Flink,Flink商业环境实战)
    

    

    

      

    • 企业声誉-ESG表现与公司透明度（2009-2021年）
小王毕业啦
大数据大数据社科数据数据分析数据挖掘人工智能

      ESG表现是指公司在环境(Environment)、社会(Social)和治理(Governance)方面的表现。这些领域的表现不仅反映了公司对可持续发展的承诺，也是衡量其社会责任的重要指标。环境(Environment)：公司在减少碳足迹、保护自然资源和推动绿色能源使用方面的努力。社会(Social)：公司在员工福利、社区参与和消费者权益保护方面的贡献。治理(Governance)：公司在确保透
      

      • 

    • 2019-03-11
英娟儿

      【今日回顾】01完成求学模块第一天打卡。02认真备课。03点评战队任务报名。04浏览了老铁们的今日打卡文。05看书《有效学习》第二章，完成输出。06看书《信任的速度》，列出读书计划。07收拾屋子。08听大群一周学委关于正面管教的分享。【运营经验】01主动分享。昨天晚上北纬老铁在实战班分享自己在定位模块带领排群老铁打卡的经历，对他来说是一次复盘，也让我们学习到了很多东西。今天赛先生在群里分享了关于动
      

      • 

    • 【深度学习】【OnnxRuntime】【Python】模型转化、环境搭建以及模型部署的详细教程
牙牙要健康
深度学习onnxonnxruntime深度学习python人工智能

      【深度学习】【OnnxRuntime】【Python】模型转化、环境搭建以及模型部署的详细教程提示:博主取舍了很多大佬的博文并亲测有效,分享笔记邀大家共同学习讨论文章目录【深度学习】【OnnxRuntime】【Python】模型转化、环境搭建以及模型部署的详细教程前言模型转换--pytorch转onnxWindows平台搭建依赖环境onnxruntime调用onnx模型ONNXRuntime推理核
      

      • 

    • eclipse sdk和ide
yilaguandemei

      SDK，全称SoftwareDevelopmentKit，就是软件开发工具包；IDE，全称IntegratedDevelopment，是集成开发环境。简单的说，SDK是让你能够进行开发的一个环境。但是呢，这个环境是一个基本环境，也许随着你的开发的深入你发现它的功能不是让你那么满意，你需要一些别的功能，一些小插件能够帮你实现这些功能，于是你把你要用的插件装在了SDK上。这时，SDK变成了IDE。ec
      

      • 

    • 新手入门：SDK和IDE的区别
xiazhongzhou
编译器其他经验分享

      SDK就是SoftwareDevelopmentKit的缩写，中文意思就是“软件开发工具包”。这是一个覆盖面相当广泛的名词，可以这么说：辅助开发某一类软件的相关文档、范例和工具的集合都可以叫做“SDK”。IDE电子集成驱动器:IDE(IntegratedDevelopmentEnvironment集成开发环境)集成开发环境（简称IDE）软件是用于程序开发环境的应用程序，一般包括代码编辑器、编译器、
      

      • 

    • 【雕爷学编程】Arduino智慧农业之智能养殖系统（水质监测和自动投喂）
驴友花雕
智慧农业Arduino手册智慧农业物联网嵌入式硬件Arduinoc++单片机智能养殖系统自动投喂

      Arduino是一个开放源码的电子原型平台，它可以让你用简单的硬件和软件来创建各种互动的项目。Arduino的核心是一个微控制器板，它可以通过一系列的引脚来连接各种传感器、执行器、显示器等外部设备。Arduino的编程是基于C/C++语言的，你可以使用ArduinoIDE（集成开发环境）来编写、编译和上传代码到Arduino板上。Arduino还有一个丰富的库和社区，你可以利用它们来扩展Ardui
      

      • 

    • 致象以观物
望辰Ker

      务实与务虚，大不必如此泾渭分明。从小到大遇到的人、经历的事，实实虚虚虚虚实实，很难看出它们个中的把戏。偶然瞧出一两个，沾沾自喜，不一会儿便又遭到虚假的痛击。于是徘徊，于是怀疑，循环往复，如临大敌如履薄冰却无法摆脱这种奇怪的宿命，仿佛一个亟需突破的瓶颈。都说四十不惑，但在观察朋友亲人时，不少时候觉得他们还是“惑”的，大概是当今环境不能与当初同日而语的缘故。先于时代之声而发未来之声，往往是凤毛麟角;更
      

      • 

    • 【ShuQiHere】从插入排序到归并排序：探究经典排序算法的魅力与实战应用
ShuQiHere
排序算法算法

      【ShuQiHere】引言在计算机科学领域，排序算法是我们日常编程中经常会遇到的基本问题。无论是对数据进行排序、查找，还是优化复杂系统，排序算法都起着至关重要的作用。在这篇文章中，我们将详细探讨两种经典排序算法：插入排序和归并排序，通过对它们的原理、时间复杂度和实际应用场景的分析，帮你更好地理解并灵活应用这些算法。1.插入排序：像整理扑克牌一样排序插入排序（InsertionSort）是一种简单且
      

      • 

    • sdk和ide
earlene_wyl

      ide：集成开发环境，是一种辅助程序开发人员开发软件的应用软件。IDE通常包括编程语言编辑器、自动建立工具、通常还包括调试器。有些IDE包含编译器／解释器，如微软的MicrosoftVisualStudio，有些则不包含，如Eclipse、SharpDevelop等，这些IDE是通过调用第三方编译器来实现代码的编译工作的。有时IDE还会包含版本控制系统和一些可以设计图形用户界面的工具。许多支持面向
      

      • 

    • Java Spring Boot 全面教程
极客代码
玩转Javajavaspringboot开发语言后端

      一、SpringBoot简介与环境搭建1.1SpringBoot简介SpringBoot是一种基于Java的开源框架，由PivotalSoftware开发，旨在简化新Spring应用程序的初始化、配置和部署过程。它遵循约定优于配置的原则，通过内嵌的Tomcat、Jetty或Undertow等容器，使得开发者能够快速构建独立运行的、生产级别的基于Spring框架的应用程序。SpringBoot包含了
      

      • 

    • Matlab2024a安装教程
是阿宇呢
信息可视化开发语言

      MATLAB是一款商业数学软件，用于算法开发、数据可视化、数据分析以及数值计算的高级技术计算语言和交互式环境，主要包括MATLAB和Simulink两大部分，可以进行矩阵运算、绘制函数和数据、实现算法、创建用户界面、连接其他编程语言的程序等，主要应用于工程计算、控制设计、信号处理与通讯、图像处理、信号检测、金融建模设计与分析等领域。1.解压安装包：①鼠标右击【MATLABR2024a(64bit)
      

      • 

    • 开源模型应用落地-qwen2-7b-instruct-LoRA微调-unsloth（让微调起飞）-单机单卡-V100（十七）
开源技术探险家
开源模型-实际应用落地#深度学习语言模型自然语言处理

      一、前言本篇文章将在v100单卡服务器上，使用unsloth去高效微调QWen2系列模型，通过阅读本文，您将能够更好地掌握这些关键技术，理解其中的关键技术要点，并应用于自己的项目中。使用unsloth能够使模型的微调速度提高2-5倍。在处理大规模数据或对时间要求较高的场景下，这可以大大节省微调所需的时间，提高开发效率。其次，可减少80%的内存使用。这对于资源有限的环境或者需要同时运行多个微调任务的
      

      • 

    • 日本为什么这么干净？
老徐观世界

      前段时间我的一位朋友去日本旅游，看到他的朋友圈发的照片我很震撼，日本街道、公园、景区特别的干净，心里好奇地想‘为什么日本能这么干净呢？’带着这个疑问我专门去网上搜了下，大概有三点原因，也给大家分享下：首先是天然的自然地理环境：日本是处于亚洲东部、太平洋西北部的岛国，它的气候属于温带海洋性季风气候，因此常年多雨。虽然梅雨季节令人烦闷，但经常下雨会自动洗涤城市的各个角落、起到良好的减尘作用。雨水充足也
      

      • 

    • 氧惠App是什么？正规靠谱好用吗？怎么赚钱？副业赚钱做什么比较好？
氧惠好物

      氧惠APP是由杭州氧惠科技有限公司开发和运营，公司总部位于杭州梦想小镇，技术团队来自于阿里、网易等大厂，创始团队在电商导购领域耕耘近十年，以创新的商业模式整合流量与资源，实现整个生态布局。2023年席卷整个朋友圈的项目，氧惠APP，2023全新模式，这是一个刚刚上线的平台，0投资，63天可做到月入十万。氧惠APP是一款集成了抖音、快手、淘宝、天猫、京东、拼多多、唯品会、苏宁易购、考拉海购、美团、饿
      

      • 

    • 《昇思 25 天学习打卡营第 25 天 | 基于 MindSpore 实现 BERT 对话情绪识别 》
Sam9029
Mindscope模型学习深度学习

      《昇思25天学习打卡营第25天|基于MindSpore实现BERT对话情绪识别》活动地址：https://xihe.mindspore.cn/events/mindspore-training-camp签名：Sam9029环境配置确保安装了正确版本的MindSpore和MindNLP库。!pipuninstallmindspore-y!pipinstall-ihttps://pypi.mirror
      

      • 

    • [INSTALL] MSYS2 -- Windows下的类Linux环境
ERIC-ZI
工具类Windowswindowslinux运维

      一、安装1.从https://www.msys2.org/下载安装msys2也可以从镜像:http://mirrors.aliyun.com/msys2/distrib/x86_64/下载最新的安装包msys2-x86_64-20230718.exe2.更新下载源为阿里云sed-i"s#https\?://mirror.msys2.org/#http://mirrors.aliyun.com/ms
      

      • 

    • Eclipse SDK与 IDE 有什么区别，是什么意思？
guo_wen_qiang

      SDK：全称SoftwareDevelopmentKit,软件开发工具包。IDE：全称IntegratedDevelopment，集成开发环境。SDK是一个能够进行开发的环境，是一个基本的环境，可以添加一些其他的功能，添加插件帮助实现想要的功能。这种将想要的插件安装在SDK上的环境称为IDE
      

      • 

    • java中的ide、sdk是什么,javaee\javase\javame区别
极客Thomas
idejavaeclipse

      ide：integrateddevelopmentenvironment集成开发环境简单的来说就是提供编译代码等一系列功能的开发环境比如：eclipsesdk：servicedevelopmentpack服务开发包简单来说就是一些封装的功能代码，做成了一个包，给我们可以直接调用比如jdk1.8jdkjavase（JavaPlatform，StandardEdition）标准版本，在电脑上运行jav
      

      • 

    • 专访徐小平：AI已进入日常生活 没有泡沫只有彩虹
网易智能

      ▼点击上方蓝字关注网易智能为你解读AI领域大公司大事件，新观点新应用从共享单车到新零售，从人工智能到区块链，从直播答题到内容创业，移动互联网时代，每一次商业机遇的新风口周期在变得越来越短，无论对于创业者还是投资人，一上场就出现“留给选手的时间不多了”已成了常态。2018年春，网易科技联合起风了推出“Top中国投资人”深度访谈节目，将分别就当下热点方向，邀请国内顶级机构若干位资深合伙人共同探索未来一
      

      • 

    • 如何制作短视频拍摄
红匣子实力推荐

      短视频拍摄已经成为了当下最受欢迎的一种娱乐方式，无论是在社交媒体上分享生活点滴，还是在商业领域进行产品推广，短视频都发挥着越来越重要的作用。那么，如何制作一部吸引人的短视频呢？本文将为您介绍一些短视频拍摄的技巧和方法。联系专业拍摄公司：13642679953（微信同号）1.确定主题和目标受众在开始拍摄之前，首先要明确短视频的主题和目标受众。这将有助于您在拍摄过程中保持焦点，确保内容与受众产生共鸣。
      

      • 

    • MATLAB中的代码覆盖测试：深入指南与实践应用
2401_85812026
matlab开发语言

      在软件测试领域，代码覆盖测试是一种重要的技术，用于评估测试用例的完整性和有效性。在MATLAB环境中，代码覆盖测试可以帮助开发者确保他们的代码在各种条件下都能正常工作，并且能够发现可能被忽视的错误。本文将详细介绍如何在MATLAB中进行代码覆盖测试，包括测试的类型、工具和实践方法。1.代码覆盖测试的基本概念代码覆盖测试旨在通过测试用例执行代码中的不同部分，以确保代码的每个部分都经过了验证。在MAT
      

      • 

    • 使用vllIm部署大语言模型
添砖JAVA的小墨
机器学习

      使用vllm部署大语言模型一般需要以下步骤：一、准备工作1.系统要求-操作系统：常见的Linux发行版（如Ubuntu、CentOS）或Windows（通过WSL）。-GPU支持：NVIDIAGPU并安装了适当的驱动程序。-足够的内存和存储空间。2.安装依赖-Python3.8及以上版本。-CUDA工具包（根据GPU型号选择合适的版本）。二、安装vllm1.创建虚拟环境（推荐）-使用Conda：c
      

      • 

    • 高通量测序的数据处理与分析指北(二)--宏基因组篇
lantary

      博客原文宏基因组篇前言之前的一篇文章已经从生物实验的角度讲述了高通量测序的原理，这篇文章旨在介绍宏基因组二代测序数据的处理方式及其原理。在正文开始之前，我们先来认识一下什么是宏基因组。以我的理解，宏基因组就是某环境中所有生物的基因组的合集，这个环境可以是下水道，河流等自然环境，也可以是人体内肠道，口腔等体环境。而宏基因组中的生物往往指的是微生物，如真菌，细菌，病毒，古细菌。我们这里主要以肠道微生物
      

      • 

    • 海量数据查找最大K个值：数据结构与算法的选择
星辰@Sea
数据结构Java数据结构

      在处理大数据集时，经常需要找到数据集中最大的K个元素，这样的需求在很多领域都有广泛应用，例如推荐系统中寻找评分最高的K个商品、数据分析中找出最重要的K个特征、搜索引擎中找到排名前K的结果等等。面对海量数据，传统的排序方法可能不再适用，因为它们通常具有较高的时间复杂度。因此，选择合适的数据结构和算法对于提高效率至关重要。本文将详细介绍如何在海量数据集中查找最大的K个值，探讨不同的数据结构与算法选择，
      

      • 

    • 2019-03-01
何礼东

      相信大家已经在着手开始建立自己的7天短社群了，但在建立之前。请大家在上再次梳理一下你自己的优势和资源，让你做社群更有方向和内容…图片发自App我的优势：技能：个人定位，品牌推广，模式化调理技术指导与监控，社群运营，项目策划，PPT及教案，外汇股票，吉他，经验：30年经商与品牌运营经验，15年营养调理研究和实战经验，3年的模式化技术指导官，4年社群运营经验，2年模式化小社群＂服务＋培训＂方案实战经验
      

      • 

    • elasticsearch数据迁移之elasticdump
迷茫运维路
elasticsearch中间件elasticsearchlinux运维

      系列文章目录第一章es集群搭建第二章es集群基本操作命令第三章es基于search-guard插件实现加密认证第四章es常用插件文章目录系列文章目录前言一、elasticdump是什么？二、安装elasticdump工具1.离线安装2.在线安装三、elasticdump相关参数四、使用elasticdump进行数据备份五、使用elasticdump进行数据恢复前言在企业实际生产环境中,避免不了要对
      

      • 

    • Hadoop windows intelij 跑 MR WordCount
piziyang12138

      一、软件环境我使用的软件版本如下:IntellijIdea2017.1Maven3.3.9Hadoop分布式环境二、创建maven工程打开Idea,file->new->Project,左侧面板选择maven工程。(如果只跑MapReduce创建java工程即可，不用勾选Creatfromarchetype，如果想创建web工程或者使用骨架可以勾选)image.png设置GroupId和Artif
      

      • 

    • 基于matlab的水下航行器建模与仿真,水下自主航行器(AUV)建模仿真探究.doc
蒙眼说

      水下自主航行器(AUV)建模仿真探究水下自主航行器(AUV)建模仿真探究【摘要】本文对鱼雷形状的水下自主航行器的六自由度非线性动态模型的研制作了较为详细的介绍。该动态模型充分考虑了各方面的因素，其中包括静水力学，超重，流体力学，操舵、推进力和力矩等。此外模型还考虑了航行器动力学和环境的影响。【关键词】水下自主航行器；建模；仿真研究1.引言水下自主航行体是一种重要的用于水下勘探的机器人，同时也是用于
      

      • 

    • 为了实现梦想，舍弃世俗的一些东西，很可能会吃不上饭，该怎么办？
作家雪漠

      图片发自App人生有两种东西，一种是事业，一种是职业。事业是实现梦想的，职业是用来吃饭的。你可以在找到职业之后，仍然不要丢失梦想。这要求你要有一份警觉，时刻警惕外部环境对你的熏染和影响。有好多想在工作的同时追求梦想的人，要么非常忙碌，以至于没有了追求梦想的时间和精力，最终丢失了梦想；要么被环境同化，变得非常懒散，寻找借口，贪图享受，不思进取，终而丢了梦想。虽然一个人在追求梦想的过程中，往往要经历很
      

      • 

    • 初级练习[3]:Hive SQL子查询应用
大数据深度洞察
Hivehivesqlhadoop数据仓库大数据数据库

      目录环境准备看如下链接子查询查询所有课程成绩均小于60分的学生的学号、姓名查询没有学全所有课的学生的学号、姓名解释：没有学全所有课，也就是该学生选修的课程数<总的课程数。查询出只选修了三门课程的全部学生的学号和姓名环境准备看如下链接环境准备https://blog.csdn.net/qq_45115959/article/details/142057624?spm=1001.2014.3001.5
      

      • 

    • HttpClient 4.3与4.3版本以下版本比较
spjich
javahttpclient

      网上利用java发送http请求的代码很多，一搜一大把，有的利用的是java.net.*下的HttpURLConnection，有的用httpclient，而且发送的代码也分门别类。今天我们主要来说的是利用httpclient发送请求。
httpclient又可分为
httpclient3.x
httpclient4.x到httpclient4.3以下
httpclient4.3
      

      • 

    • Essential Studio Enterprise Edition 2015 v1新功能体验
Axiba
.net

      概述：Essential Studio已全线升级至2015 v1版本了！新版本为JavaScript和ASP.NET MVC添加了新的文件资源管理器控件，还有其他一些控件功能升级，精彩不容错过，让我们一起来看看吧！
syncfusion公司是世界领先的Windows开发组件提供商，该公司正式对外发布Essential Studio Enterprise Edition 2015 v1版本。新版本
      

      • 

    • [宇宙与天文]微波背景辐射值与地球温度
comsci
背景

      
        宇宙这个庞大,无边无际的空间是否存在某种确定的,变化的温度呢?
     如果宇宙微波背景辐射值是表示宇宙空间温度的参数之一,那么测量这些数值,并观测周围的恒星能量输出值,我们是否获得地球的长期气候变化的情况呢?
  &nbs
      

      • 

    • lvs-server
男人50
server

      #!/bin/bash
#
# LVS script for VS/DR
#
#./etc/rc.d/init.d/functions
#
VIP=10.10.6.252
RIP1=10.10.6.101
RIP2=10.10.6.13
PORT=80
case $1 in
start)
  /sbin/ifconfig eth2:0 $VIP broadca
      

      • 

    • java的WebCollector爬虫框架
oloz
爬虫

      WebCollector主页：
https://github.com/CrawlScript/WebCollector
下载：webcollector-版本号-bin.zip将解压后文件夹中的所有jar包添加到工程既可。
接下来看demo
package org.spider.myspider;
import cn.edu.hfut.dmic.webcollector.cra
      

      • 

    • jQuery append 与 after 的区别
小猪猪08

      1、after函数
定义和用法：
after() 方法在被选元素后插入指定的内容。
语法：
$(selector).after(content)
实例：
<html>
<head>
<script type="text/javascript" src="/jquery/jquery.js"></scr
      

      • 

    • mysql知识充电
香水浓
mysql

      索引
索引是在存储引擎中实现的，因此每种存储引擎的索引都不一定完全相同，并且每种存储引擎也不一定支持所有索引类型。
根据存储引擎定义每个表的最大索引数和最大索引长度。所有存储引擎支持每个表至少16个索引，总索引长度至少为256字节。
大多数存储引擎有更高的限制。MYSQL中索引的存储类型有两种：BTREE和HASH，具体和表的存储引擎相关；
MYISAM和InnoDB存储引擎
      

      • 

    • 我的架构经验系列文章索引
agevs
架构

      下面是一些个人架构上的总结，本来想只在公司内部进行共享的，因此内容写的口语化一点，也没什么图示，所有内容没有查任何资料是脑子里面的东西吐出来的因此可能会不准确不全，希望抛砖引玉，大家互相讨论。
要注意，我这些文章是一个总体的架构经验不针对具体的语言和平台，因此也不一定是适用所有的语言和平台的。
（内容是前几天写的，现附上索引）
 
前端架构 http://www.
      

      • 

    • Android so lib库远程http下载和动态注册
aijuans
andorid

      一、背景
 
   在开发Android应用程序的实现，有时候需要引入第三方so lib库，但第三方so库比较大，例如开源第三方播放组件ffmpeg库, 如果直接打包的apk包里面, 整个应用程序会大很多.经过查阅资料和实验，发现通过远程下载so文件，然后再动态注册so文件时可行的。主要需要解决下载so文件存放位置以及文件读写权限问题。
 
二、主要
      

      • 

    • linux中svn配置出错 conf/svnserve.conf:12: Option expected 解决方法
baalwolf
option

      在客户端访问subversion版本库时出现这个错误：
svnserve.conf:12: Option expected
为什么会出现这个错误呢，就是因为subversion读取配置文件svnserve.conf时，无法识别有前置空格的配置文件，如### This file controls the configuration of the svnserve daemon, if you##
      

      • 

    • MongoDB的连接池和连接管理
BigCat2013
mongodb

      在关系型数据库中，我们总是需要关闭使用的数据库连接，不然大量的创建连接会导致资源的浪费甚至于数据库宕机。这篇文章主要想解释一下mongoDB的连接池以及连接管理机制，如果正对此有疑惑的朋友可以看一下。
通常我们习惯于new 一个connection并且通常在finally语句中调用connection的close()方法将其关闭。正巧，mongoDB中当我们new一个Mongo的时候，会发现它也
      

      • 

    • AngularJS使用Socket.IO
bijian1013
JavaScriptAngularJSSocket.IO

              目前，web应用普遍被要求是实时web应用，即服务端的数据更新之后，应用能立即更新。以前使用的技术（例如polling）存在一些局限性，而且有时我们需要在客户端打开一个socket，然后进行通信。
        Socket.IO(http://socket.io/)是一个非常优秀的库，它可以帮你实
      

      • 

    • [Maven学习笔记四]Maven依赖特性
bit1129
maven

      三个模块
为了说明问题，以用户登陆小web应用为例。通常一个web应用分为三个模块，模型和数据持久化层user-core, 业务逻辑层user-service以及web展现层user-web，
user-service依赖于user-core
user-web依赖于user-core和user-service
 
依赖作用范围
 Maven的dependency定义
      

      • 

    • 【Akka一】Akka入门
bit1129
akka

      什么是Akka
Message-Driven Runtime is the Foundation to Reactive Applications
In Akka, your business logic is driven through message-based communication patterns that are independent of physical locatio
      

      • 

    • zabbix_api之perl语言写法
ronin47
zabbix_api之perl

      zabbix_api网上比较多的写法是python或curl。上次我用java－－http://bossr.iteye.com/blog/2195679，这次用perl。for example: #!/usr/bin/perl
use 5.010 ;
use strict ;
use warnings ;
use JSON :: RPC :: Client ;
use 
      

      • 

    • 比优衣库跟牛掰的视频流出了，兄弟连Linux运维工程师课堂实录，更加刺激，更加实在！
brotherlamp
linux运维工程师linux运维工程师教程linux运维工程师视频linux运维工程师资料linux运维工程师自学

      比优衣库跟牛掰的视频流出了，兄弟连Linux运维工程师课堂实录，更加刺激，更加实在！
 
-----------------------------------------------------
兄弟连Linux运维工程师课堂实录-计算机基础-1-课程体系介绍1
链接：http://pan.baidu.com/s/1i3GQtGL 密码：bl65
 
兄弟连Lin
      

      • 

    • bitmap求哈密顿距离-给定N（1<=N<=100000）个五维的点A(x1,x2,x3,x4,x5)，求两个点X(x1,x2,x3,x4,x5)和Y(
bylijinnan
java

      
import java.util.Random;
/**
* 题目：
* 给定N（1<=N<=100000）个五维的点A(x1,x2,x3,x4,x5)，求两个点X(x1,x2,x3,x4,x5)和Y(y1,y2,y3,y4,y5)，
* 使得他们的哈密顿距离（d=|x1-y1| + |x2-y2| + |x3-y3| + |x4-y4| + |x5-y5|）最大
      

      • 

    • map的三种遍历方法
chicony
map

      
package com.test;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class TestMap {
public static v
      

      • 

    • Linux安装mysql的一些坑
chenchao051
linux

      1、mysql不建议在root用户下运行
 
2、出现服务启动不了，111错误，注意要用chown来赋予权限， 我在root用户下装的mysql，我就把usr/share/mysql/mysql.server复制到/etc/init.d/mysqld, (同时把my-huge.cnf复制/etc/my.cnf) 
chown -R cc /etc/init.d/mysql
      

      • 

    • Sublime Text 3 配置
daizj
配置Sublime Text

      Sublime Text 3 配置解释(默认){// 设置主题文件“color_scheme”: “Packages/Color Scheme – Default/Monokai.tmTheme”,// 设置字体和大小“font_face”: “Consolas”,“font_size”: 12,// 字体选项：no_bold不显示粗体字，no_italic不显示斜体字，no_antialias和
      

      • 

    • MySQL server has gone away 问题的解决方法
dcj3sjt126com
SQL Server

      MySQL server has gone away 问题解决方法，需要的朋友可以参考下。
应用程序（比如PHP）长时间的执行批量的MYSQL语句。执行一个SQL，但SQL语句过大或者语句中含有BLOB或者longblob字段。比如，图片数据的处理。都容易引起MySQL server has gone away。 今天遇到类似的情景，MySQL只是冷冷的说：MySQL server h
      

      • 

    • javascript/dom:固定居中效果
dcj3sjt126com
JavaScript

      <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml&
      

      • 

    • 使用 Spring 2.5 注释驱动的 IoC 功能
e200702084
springbean配置管理IOCOffice

      使用 Spring 2.5 注释驱动的 IoC 功能
developerWorks
文档选项
将打印机的版面设置成横向打印模式
打印本页
将此页作为电子邮件发送
将此页作为电子邮件发送
级别： 初级
陈 雄华 ([email protected]), 技术总监, 宝宝淘网络科技有限公司
2008 年 2 月 28 日
 &nb
      

      • 

    • MongoDB常用操作命令
geeksun
mongodb

      1.   基本操作
db.AddUser(username,password)               添加用户
db.auth(usrename,password)      设置数据库连接验证
db.cloneDataBase(fromhost)     
      

      • 

    • php写守护进程（Daemon）
hongtoushizi
PHP

      转载自： http://blog.csdn.net/tengzhaorong/article/details/9764655
 
守护进程（Daemon）是运行在后台的一种特殊进程。它独立于控制终端并且周期性地执行某种任务或等待处理某些发生的事件。守护进程是一种很有用的进程。php也可以实现守护进程的功能。
 
1、基本概念
  &nbs
      

      • 

    • spring整合mybatis,关于注入Dao对象出错问题
jonsvien
DAOspringbeanmybatisprototype

      今天在公司测试功能时发现一问题：
先进行代码说明：
1，controller配置了Scope="prototype"（表明每一次请求都是原子型）
   @resource/@autowired service对象都可以（两种注解都可以）。
2，service 配置了Scope="prototype"（表明每一次请求都是原子型）

      

      • 

    • 对象关系行为模式之标识映射
home198979
PHP架构企业应用对象关系标识映射

      HELLO!架构
 
一、概念
identity Map:通过在映射中保存每个已经加载的对象，确保每个对象只加载一次，当要访问对象的时候，通过映射来查找它们。其实在数据源架构模式之数据映射器代码中有提及到标识映射，Mapper类的getFromMap方法就是实现标识映射的实现。
 
 
二、为什么要使用标识映射？
在数据源架构模式之数据映射器中
//c
      

      • 

    • Linux下hosts文件详解
pda158
linux

      　1、主机名： 　　无论在局域网还是INTERNET上，每台主机都有一个IP地址，是为了区分此台主机和彼台主机，也就是说IP地址就是主机的门牌号。 　　公网：IP地址不方便记忆，所以又有了域名。域名只是在公网（INtERNET)中存在，每个域名都对应一个IP地址，但一个IP地址可有对应多个域名。 　　局域网：每台机器都有一个主机名，用于主机与主机之间的便于区分，就可以为每台机器设置主机
      

      • 

    • nginx配置文件粗解
spjich
javanginx

      #运行用户#user  nobody;#启动进程,通常设置成和cpu的数量相等worker_processes  2;#全局错误日志及PID文件#error_log  logs/error.log;#error_log  logs/error.log  notice;#error_log  logs/error.log  inf
      

      • 

    • 数学函数
w54653520
java

      public 
class 
S {  
    
// 传入两个整数，进行比较，返回两个数中的最大值的方法。
    
public 
int 
get(
int 
num1,
int 
nu
      

      •