神兽牛
神兽牛

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商业环境实战)
    
        
    
            
    
                
      
                    
    • 店群合一模式下的社区团购新发展——结合链动 2+1 模式、AI 智能名片与 S2B2C 商城小程序源码
                        说私域
人工智能小程序
                        
      摘要：本文探讨了店群合一的社区团购平台在当今商业环境中的重要性和优势。通过分析店群合一模式如何将互联网社群与线下终端紧密结合，阐述了链动2+1模式、AI智能名片和S2B2C商城小程序源码在这一模式中的应用价值。这些创新元素的结合为社区团购带来了新的机遇，提升了用户信任感、拓展了营销渠道，并实现了线上线下的完美融合。一、引言随着互联网技术的不断发展，社区团购作为一种新兴的商业模式，在满足消费者日常需
      
                    
      • 
                    
    • Python数据分析与可视化实战指南
                        William数据分析
pythonpython数据
                        
      在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
      
                    
      • 
                    
    • Python中os.environ基本介绍及使用方法
                        鹤冲天Pro
#Pythonpython服务器开发语言
                        
      文章目录python中os.environos.environ简介os.environ进行环境变量的增删改查python中os.environ的使用详解1.简介2.key字段详解2.1常见key字段3.os.environ.get()用法4.环境变量的增删改查和判断是否存在4.1新增环境变量4.2更新环境变量4.3获取环境变量4.4删除环境变量4.5判断环境变量是否存在python中os.envi
      
                    
      • 
                    
    • 腾讯云技术深度探索：构建高效云原生微服务架构
                        我的运维人生
云原生架构腾讯云运维开发技术共享
                        
      腾讯云技术深度探索：构建高效云原生微服务架构在当今快速发展的技术环境中，云原生技术已成为企业数字化转型的关键驱动力。腾讯云作为行业领先的云服务提供商，不断推出创新的产品和技术，助力企业构建高效、可扩展的云原生微服务架构。本文将深入探讨腾讯云在微服务领域的最新进展，并通过一个实际案例展示如何在腾讯云平台上构建云原生应用。腾讯云微服务架构概览腾讯云微服务架构基于云原生理念，旨在帮助企业快速实现应用的容
      
                    
      • 
                    
    • Python教程：一文了解使用Python处理XPath
                        旦莫
Python进阶python开发语言
                        
      目录1.环境准备1.1安装lxml1.2验证安装2.XPath基础2.1什么是XPath？2.2XPath语法2.3示例XML文档3.使用lxml解析XML3.1解析XML文档3.2查看解析结果4.XPath查询4.1基本路径查询4.2使用属性查询4.3查询多个节点5.XPath的高级用法5.1使用逻辑运算符5.2使用函数6.实战案例6.1从网页抓取数据6.1.1安装Requests库6.1.2代
      
                    
      • 
                    
    • python os.environ_python os.environ 读取和设置环境变量
                        weixin_39605414
pythonos.environ
                        
      >>>importos>>>os.environ.keys()['LC_NUMERIC','GOPATH','GOROOT','GOBIN','LESSOPEN','SSH_CLIENT','LOGNAME','USER','HOME','LC_PAPER','PATH','DISPLAY','LANG','TERM','SHELL','J2REDIR','LC_MONETARY','QT_QPA
      
                    
      • 
                    
    • PHP环境搭建详细教程
                        好看资源平台
前端php
                        
      PHP是一个流行的服务器端脚本语言，广泛用于Web开发。为了使PHP能够在本地或服务器上运行，我们需要搭建一个合适的PHP环境。本教程将结合最新资料，介绍在不同操作系统上搭建PHP开发环境的多种方法，包括Windows、macOS和Linux系统的安装步骤，以及本地和Docker环境的配置。1.PHP环境搭建概述PHP环境的搭建主要分为以下几类：集成开发环境：例如XAMPP、WAMP、MAMP，这
      
                    
      • 
                    
    • 直返最高等级与直返APP：无需邀请码的返利新体验
                        古楼

                        
      随着互联网的普及和电商的兴起，直返模式逐渐成为一种流行的商业模式。在这种模式下，消费者通过购买产品或服务，获得一定的返利，并可以分享给更多的人。其中，直返最高等级和直返APP是直返模式中的重要概念和工具。本文将详细介绍直返最高等级的概念、直返APP的使用以及与邀请码的关系。【高省】APP（高佣金领导者）是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几百万篇报道，运行三年，稳定可靠。高省APP，
      
                    
      • 
                    
    • 使用LLaVa和Ollama实现多模态RAG示例
                        llzwxh888
python人工智能开发语言
                        
      本文将详细介绍如何使用LLaVa和Ollama实现多模态RAG（检索增强生成），通过提取图像中的结构化数据、生成图像字幕等功能来展示这一技术的强大之处。安装环境首先，您需要安装以下依赖包：!pipinstallllama-index-multi-modal-llms-ollama!pipinstallllama-index-readers-file!pipinstallunstructured!p
      
                    
      • 
                    
    • 人工智能时代，程序员如何保持核心竞争力？
                        jmoych
人工智能
                        
      随着AIGC（如chatgpt、midjourney、claude等）大语言模型接二连三的涌现，AI辅助编程工具日益普及，程序员的工作方式正在发生深刻变革。有人担心AI可能取代部分编程工作，也有人认为AI是提高效率的得力助手。面对这一趋势,程序员应该如何应对?是专注于某个领域深耕细作，还是广泛学习以适应快速变化的技术环境?又或者，我们是否应该将重点转向AI无法轻易替代的软技能？让我们一起探讨程序员
      
                    
      • 
                    
    • Python 实现图片裁剪（附代码） | Python工具
                        剑客阿良_ALiang

                        
      前言本文提供将图片按照自定义尺寸进行裁剪的工具方法，一如既往的实用主义。环境依赖ffmpeg环境安装，可以参考我的另一篇文章：windowsffmpeg安装部署_阿良的博客-CSDN博客本文主要使用到的不是ffmpeg，而是ffprobe也在上面这篇文章中的zip包中。ffmpy安装：pipinstallffmpy-ihttps://pypi.douban.com/simple代码不废话了，上代码
      
                    
      • 
                    
    • 【华为OD技术面试真题 - 技术面】-测试八股文真题题库（1）
                        算法大师
华为od面试python算法前端
                        
      华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.黑盒测试和白盒测试的区别2.假设我们公司现在开发一个类似于微信的软件1.0版本，现在要你测试这个功能：打开聊天窗口，输入文本，限制字数在200字以内。问你怎么提取测试点。功能测试性能测试安全性测试可用性测试跨平台兼容性测试网络环境测试3.接口测试的工具你了解哪些
      
                    
      • 
                    
    • python os 环境变量
                        CV矿工
python开发语言numpy
                        
      环境变量：环境变量是程序和操作系统之间的通信方式。有些字符不宜明文写进代码里，比如数据库密码，个人账户密码，如果写进自己本机的环境变量里，程序用的时候通过os.environ.get（）取出来就行了。os.environ是一个环境变量的字典。环境变量的相关操作importos"""设置/修改环境变量：os.environ[‘环境变量名称’]=‘环境变量值’#其中key和value均为string类
      
                    
      • 
                    
    • Python爬虫解析工具之xpath使用详解
                        eqa11
python爬虫开发语言
                        
      文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
      
                    
      • 
                    
    • 2019-05-13
                        王健_100a

                        
      【撒下18:2】大卫打发军兵出战，分为三队：一队在约押手下，一队在洗鲁雅的儿子约押兄弟亚比筛手下，一队在迦特人以太手下。大卫对军兵说：“我必与你们一同出战。”解释：大卫检阅部队，将它分成三队，每队由一位元帅统领；约押与兄弟亚比筛，并迦特人以太共同指挥。大卫想与他们一同出战！应用：作为领袖与军兵一起出战是很重要。领袖在事奉中与信徒一起，领袖在任何的环境里与信徒一起走过。我们要同心协力为主而战。祷告：
      
                    
      • 
                    
    • nosql数据库技术与应用知识点
                        皆过客，揽星河
NoSQLnosql数据库大数据数据分析数据结构非关系型数据库
                        
      Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
      
                    
      • 
                    
    • 读《人间鲁迅》有感
                        琳语读书

                        
      上周读完《闻一多传》后，我对中国近代知识分子产生了兴趣，这周继续读了《人间鲁迅》。厚厚的两本书，记录了一个人的一生，苦痛，彷徨和挣扎，虽然只读了一小部分，却也心潮澎湃。闻一多和鲁迅是完全不同的。鲁迅是沉郁的，现实的，寂寞的，抗争的。除了天生性格的不同外，环境的塑造也是非常之大。鲁迅少年经历了家庭的变故，看尽了人间冷暖，世态炎凉。这种经历促使他很早就观察思考人生，立志用文学来改变中国国民的劣根。闻一
      
                    
      • 
                    
    • 《Python数据分析实战终极指南》
                        xjt921122
python数据分析开发语言
                        
      对于分析师来说，大家在学习Python数据分析的路上，多多少少都遇到过很多大坑**，有关于技能和思维的**：Excel已经没办法处理现有的数据量了，应该学Python吗？找了一大堆Python和Pandas的资料来学习，为什么自己动手就懵了？跟着比赛类公开数据分析案例练了很久，为什么当自己面对数据需求还是只会数据处理而没有分析思路？学了对比、细分、聚类分析，也会用PEST、波特五力这类分析法，为啥
      
                    
      • 
                    
    • Xinference如何注册自定义模型
                        玩人工智能的辣条哥
人工智能AI大模型Xinference
                        
      环境：Xinference问题描述：Xinference如何注册自定义模型解决方案：1.写个model_config.json，内容如下{"version":1,"context_length":2048,"model_name":"custom-llama-3","model_lang":["en","ch"],"model_ability":["generate","chat"],"model
      
                    
      • 
                    
    • 【六】阿伟开始搭建Kafka学习环境
                        能源恒观
中间件学习kafkaspring
                        
      阿伟开始搭建Kafka学习环境概述上一篇文章阿伟学习了Kafka的核心概念，并且把市面上流行的消息中间件特性进行了梳理和对比，方便大家在学习过程中进行对比学习，最后梳理了一些Kafka使用中经常遇到的Kafka难题以及解决思路，经过上一篇的学习我相信大家对Kafka有了初步的认识，本篇将继续学习Kafka。一、安装和配置学习一项技术首先要搭建一套服务，而Kafka的运行主要需要部署jdk、zook
      
                    
      • 
                    
    • ES聚合分析原理与代码实例讲解
                        光剑书架上的书
大厂Offer收割机面试题简历程序员读书硅基计算碳基计算认知计算生物计算深度学习神经网络大数据AIGCAGILLMJavaPython架构设计Agent程序员实现财富自由
                        
      ES聚合分析原理与代码实例讲解1.背景介绍1.1问题的由来在大规模数据分析场景中，特别是在使用Elasticsearch（ES）进行数据存储和检索时，聚合分析成为了一个至关重要的功能。聚合分析允许用户对数据集进行细分和分组，以便深入探索数据的结构和模式。这在诸如实时监控、日志分析、业务洞察等领域具有广泛的应用。1.2研究现状目前，ES聚合分析已经成为现代大数据平台的核心组件之一。它支持多种类型的聚
      
                    
      • 
                    
    • 简单了解 JVM
                        记得开心一点啊
jvm
                        
      目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
      
                    
      • 
                    
    • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven
                        Energet!c
开发语言
                        
      1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
      
                    
      • 
                    
    • 「豆包Marscode体验官」 | 云端 IDE 启动 & Rust 体验
                        张风捷特烈
iderust开发语言后端
                        
      theme:cyanosis我正在参加「豆包MarsCode初体验」征文活动MarsCode可以看作一个运行在服务端的远程VSCode开发环境。对于我这种想要学习体验某些语言，但不想在电脑里装环境的人来说非常友好。本文就来介绍一下在MarsCode里，我的体验rust开发体验。一、MarsCode是什么它的本质是:提供代码助手和云端IDE服务的web网站，可通过下面的链接访问https://www
      
                    
      • 
                    
    • Python实现简单的机器学习算法
                        master_chenchengg
pythonpython办公效率python开发IT
                        
      Python实现简单的机器学习算法开篇：初探机器学习的奇妙之旅搭建环境：一切从安装开始必备工具箱第一步：安装Anaconda和JupyterNotebook小贴士：如何配置Python环境变量算法初体验：从零开始的Python机器学习线性回归：让数据说话数据准备：从哪里找数据编码实战：Python实现线性回归模型评估：如何判断模型好坏逻辑回归：从分类开始理论入门：什么是逻辑回归代码实现：使用skl
      
                    
      • 
                    
    • 快节奏
                        地方天圆

                        
      现在生活都是快节奏，使人来不及品味生活中的酸甜苦辣。交通、通讯、办公条件的高度发达，缩短了距离，节省了时间，提高了效率，但同时也使人成为缺少思考的动物，成为流水线上的一道工序。人人都有干不完的活、接不完的电话、参加不完的应酬。工作，急匆匆；办事，急匆匆；走路，急匆匆；吃饭，急匆匆；走亲串友，急匆匆；就连说话、甚至睡觉也都是急匆匆。快节奏的环境，使我们养成了快节奏的思维、习惯、心态，很难静下心来，认
      
                    
      • 
                    
    • 178 坚守自律
                        花儿迎风飞扬

                        
      如果错过了太阳时你流了泪，那么你也要错过群星了。如果你错过了早上而懊悔，那么你也要错过一整天了。白俊庭老师说，如果没有外部环境的咄咄逼人和自己逼自己，我们一般都不会自己走出舒适区，就像那只温水里的青蛙。百炼成钢，就是要锻造，就是锤打，给自己压力才有动力。咄咄逼人的外部环境是他律，是外力，走出舒适区是觉醒，是顿悟；而自己逼自己，是自律，是意志，是恒心，是内驱力。女儿的中学生活开始，开学整整一个月，也
      
                    
      • 
                    
    • JVM、JRE和 JDK：理解Java开发的三大核心组件
                        Y雨何时停T
Javajava
                        
      Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
      
                    
      • 
                    
    • 父母教育孩子的方式，将影响孩子一生
                        树英教育

                        
      为什么有些孩子总是充满自信与快乐？独立、有主见又坚强？而有些孩子却自卑、胆怯，软弱又过度依赖父母？为什么有些孩子总是健康、阳光又富于创造力？而有些孩子却悲观、孤僻又思想空乏？一个孩子的行为取决于孩子的思想，思想取决于环境和自己的认知，认知取决于教育。父母是孩子人生中的第一位教育者，父母养育孩子的方式，将决定他们人生的高度，影响他们的一生。网络图，侵权即删优秀的父母就像园丁，既要浇水施肥，又要修剪杂
      
                    
      • 
                    
    • 人生自信的灯塔
                        QQQ否极泰董宝珍

                        
      不论你的背景如何或是面临怎样的环境,你都可以具有和我一样的态度。如果困难成为你的拦路虎,你要坚信自己的重要性,坚信自己能够战胜困难,而且更重要的一点就在于,你要相信赢得胜利是很多人对你的期望。如果你具备这种态度,你甚至都不敢相信自己的能量有那么大。这不仅是你能不能活下去的问题,这不仅是成不成功的问题,这是你的责任。竭尽所能去追求圆满的责任感能帮助你在生活和事业上乘风破浪。我所经历的最困难的财务危机
      
                    
      • 
                                
    • 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
      
                                
      •