任错错
任错错

JavaFlink原理、实战、源码分析（二）原理部分

目录

JavaFlink原理、实战、源码分析（一）https://blog.csdn.net/qq_36250202/article/details/112978869

JavaFlink原理、实战、源码分析（三）https://blog.csdn.net/qq_36250202/article/details/115732840

第五章 Flink 流处理 API

5.1 Environment

 5.1.2 createLocalEnvironment

5.1.3 createRemoteEnvironment

5.2 Source

5.2.1 从集合读取数据

5.3 Transform

5.3.1

map

5.3.2 KeyBy 

5.3.3 滚动聚合算子（Rolling Aggregation）

 5.3.4Reduce

5.3.5Split 和 Select（Select只能搭配Split使用）

 5.3.6 Connect 和 CoMap（只能是两条流）

5.3.7 Union（联合多条流）

 5.4 支持的数据类型

5.4.1 基础数据类型

5.4.2 Java 和 Scala 元组（Tuples）

 5.4.3 Scala 样例类（case classes）

5.4.4 Java 简单对象（POJOs）  

5.4.5 其它（Arrays, Lists, Maps, Enums, 等等）  

5.5 实现 UDF 函数——更细粒度的控制流

5.5.1 函数类（Function Classes）

5.5.2 匿名函数（Lambda Functions）

5.5.3 富函数（Rich Functions）

5.5.4数据的重分区 

 5.6 Sink  

5.6.1 Kafka 

 5.6.2 Redis（略）

5.6.3 Elasticsearch  （略）

 5.6.4 JDBC 自定义 sink

第六章 Flink 中的 Window

6.1 Window

6.1.1 Window 概述

6.1.2 Window 类型

6.2 Window API 

6.2.1 窗口分配器（window assigner）

6.2.2创建不同类型的窗口

6.2.3 window function

6.2.4 其它可选 API

第七章 时间语义与 Wartermark

7.1 Flink 中的时间语义

 7.2 EventTime 的引入

7.3 Watermark

watermark 的特点 

watermark 的传递

 7.3.2 Watermark 的引入

watermark 的设定

MyAssigner 有两种类型

JavaFlink原理、实战、源码分析（一）JavaFlink原理、实战、源码分析（一）原理部分_任错错的博客-CSDN博客

JavaFlink原理、实战、源码分析（三）JavaFlink原理、实战、源码分析（三）原理部分_任错错的博客-CSDN博客

第五章 Flink 流处理 API

JavaFlink原理、实战、源码分析（二）原理部分_第1张图片

5.1 Environment

创建一个执行环境，表示当前执行程序的上下文。 如果程序是独立调用的，则此方法返回本地执行环境；如果从命令行客户端调用程序以提交到集群，则此方法返回此集群的执行环境，也就是说，getExecutionEnvironment 会根据查询运行的方式决定返回什么样的运行环境，是最常用的一种创建执行环境的方式。

ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
StreamExecutionEnvironment env =StreamExecutionEnvironment.getExecutionEnvironment();

如果没有设置并行度，会以 flink-conf.yaml 中的配置为准，默认是 1。

 5.1.2 createLocalEnvironment

返回本地执行环境，需要在调用时指定默认的并行度。

LocalStreamEnvironment env = StreamExecutionEnvironment.createLocalEnvironment(1);

5.1.3 createRemoteEnvironment 

StreamExecutionEnvironment env = 
StreamExecutionEnvironment.createRemoteEnvironment("jobmanage-hostname", 6123,"YOURPATH//WordCount.jar");

5.2 Source

5.2.1 从集合读取数据

 // 创建执行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);

        // 从集合中读取数据
        DataStream dataStream = env.fromCollection(Arrays.asList(
                new SensorReading("sensor_1", 1547718199L, 35.8),
                new SensorReading("sensor_6", 1547718201L, 15.4),
                new SensorReading("sensor_7", 1547718202L, 6.7),
                new SensorReading("sensor_10", 1547718205L, 38.1)
        ));

        DataStream integerDataStream = env.fromElements(1, 2, 4, 67, 189);

        // 打印输出
        dataStream.print("data");
        integerDataStream.print("int");

        // 执行
        env.execute();

5.2.2 从文件读取数据 

 public static void main(String[] args) throws Exception {
        ExecutionEnvironment env =ExecutionEnvironment.getExecutionEnvironment();

        // 从文件中读取数据
        String inputPath = "D:\\javaFlink\\src\\main\\resources\\hello.txt";
        DataSet inputDataSet = env.readTextFile(inputPath);
        DataSet> wordCountDataSet = inputDataSet.flatMap(new MyFlatMapper())
                .groupBy(0)
                .sum(1);
        wordCountDataSet.print();
        
    }

5.2.3 以 kafka 消息队列的数据作为来源

需要引入 kafka 连接器的依赖：

pom.xml


   org.apache.flink
   flink-connector-kafka-0.11_2.12
   1.10.1

具体代码如下：

 public static void main(String[] args) throws Exception{
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);

        Properties properties = new Properties();
        //Kafka服务端的主机名和端口号
        properties.setProperty("bootstrap.servers", "locahost:9092");
        // 制定consumer group
        properties.setProperty("group.id", "consumer-group");
        // key序列化
        properties.setProperty("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        // value序列化
        properties.setProperty("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        //latest 表示从最新的数据消费，也就是新产生的数据.
        properties.setProperty("auto.offset.reset", "latest");

        // 从文件读取数据
        DataStream dataStream = env.addSource( new FlinkKafkaConsumer011("sensor", new SimpleStringSchema(), properties));

        // 打印输出
        dataStream.print();

        env.execute();
    }

 5.2.4 自定义 Source

除了以上的 source 数据来源，我们还可以自定义 source。需要做的，只是传入一个 SourceFunction 就可以。具体调用如下：

DataStream dataStream = env.addSource( new MySensor());

我们希望可以随机生成传感器数据，MySensorSource 具体的代码实现如下：

// 实现自定义的SourceFunction
    public static class MySensorSource implements SourceFunction{
        // 定义一个标识位，用来控制数据的产生
        private boolean running = true;

        @Override
        public void run(SourceContext ctx) throws Exception {
            // 定义一个随机数发生器
            Random random = new Random();

            // 设置10个传感器的初始温度
            HashMap sensorTempMap = new HashMap<>();
            for( int i = 0; i < 10; i++ ){
                sensorTempMap.put("sensor_" + (i+1), 60 + random.nextGaussian() * 20);
            }

            while (running){
                for( String sensorId: sensorTempMap.keySet() ){
                    // 在当前温度基础上随机波动
                    Double newtemp = sensorTempMap.get(sensorId) + random.nextGaussian();
                    sensorTempMap.put(sensorId, newtemp);
                    ctx.collect(new SensorReading(sensorId, System.currentTimeMillis(), newtemp));
                }
                // 控制输出频率
                Thread.sleep(1000L);
            }
        }

        @Override
        public void cancel() {
            running = false;
        }
    }

5.3 Transform

转换算子

5.3.1

map、flatMap、filter基本转换算子（简单算子）

map

JavaFlink原理、实战、源码分析（二）原理部分_第2张图片

 flatMap（打散，来一条数据打散成多条数据）

Filter（过滤）

JavaFlink原理、实战、源码分析（二）原理部分_第3张图片

    public static void main(String[] args) throws Exception{
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);

        // 从文件读取数据
        DataStream inputStream = env.readTextFile("E:\\尚硅谷\\Flink课程\\尚硅谷大数据技术之Flink（Java版）\\4.代码\\FlinkTutorial\\src\\main\\resources\\sensor.txt");

        // 1. map，把String转换成长度输出
        DataStream mapStream = inputStream.map(new MapFunction() {
            @Override
            public Integer map(String value) throws Exception {
                return value.length();
            }
        });

        // 2. flatmap，按逗号分字段
        DataStream flatMapStream = inputStream.flatMap(new FlatMapFunction() {
            @Override
            public void flatMap(String value, Collector out) throws Exception {
                String[] fields = value.split(",");
                for( String field: fields )
                    out.collect(field);
            }
        });

        // 3. filter, 筛选sensor_1开头的id对应的数据
        DataStream filterStream = inputStream.filter(new FilterFunction() {
            @Override
            public boolean filter(String value) throws Exception {
                return value.startsWith("sensor_1");
            }
        });

        // 打印输出
        mapStream.print("map");
        flatMapStream.print("flatMap");
        filterStream.print("filter");

        env.execute();
    }

打印输出

JavaFlink原理、实战、源码分析（二）原理部分_第4张图片

5.3.2 KeyBy 

JavaFlink原理、实战、源码分析（二）原理部分_第5张图片

DataStream → KeyedStream：逻辑地将一个流拆分成不相交的分区，每个分区包含具有相同 key 的元素，在内部以 hash 的形式实现的。（hashCode重分区）

所有相同的key一定会分到对应的分区里

5.3.3 滚动聚合算子（Rolling Aggregation）

这些算子可以针对 KeyedStream 的每一个支流做聚合。

⚫ sum()

⚫ min()

⚫ max()

⚫ minBy()

⚫ maxBy()

注：max、min只会变化当前比较字段值，其他字段值没有变化不是最新对应的，minby、maxby则都会获取比较最新值的对应字段值

public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(4);

        // 从文件读取数据
        DataStream inputStream = env.readTextFile("E:\\尚硅谷\\Flink课程\\尚硅谷大数据技术之Flink（Java版）\\4.代码\\FlinkTutorial\\src\\main\\resources\\sensor.txt");

        // 转换成SensorReading类型
//        DataStream dataStream = inputStream.map(new MapFunction() {
//            @Override
//            public SensorReading map(String value) throws Exception {
//                String[] fields = value.split(",");
//                return new SensorReading(fields[0], new Long(fields[1]), new Double(fields[2]));
//            }
//        });

        DataStream dataStream = inputStream.map( line -> {
            String[] fields = line.split(",");
            return new SensorReading(fields[0], new Long(fields[1]), new Double(fields[2]));
        } );

        // 分组
        KeyedStream keyedStream = dataStream.keyBy("id");
        KeyedStream keyedStream1 = dataStream.keyBy(data -> data.getId());

        // KeyedStream keyedStream1 = dataStream.keyBy(SensorReading::getId);

        // 滚动聚合，取当前最大的温度值
        DataStream resultStreamMax = keyedStream.max("temperature");
        DataStream resultStreamMaxBy = keyedStream.maxBy("temperature");

        resultStreamMax.print("resultMax");
        resultStreamMaxBy.print("resultMaxBy");
        env.execute();
    }

控制台打印

JavaFlink原理、实战、源码分析（二）原理部分_第6张图片

 5.3.4Reduce

KeyedStream → DataStream：一个分组数据流的聚合操作，合并当前的元素和上次聚合的结果，产生一个新的值，返回的流中包含每一次聚合的结果，而不是只返回最后一次聚合的最终结果。

​ Reduce适用于更加一般化的聚合操作场景。复杂场景，除了获取最大温度的整个传感器信息以外，还要求时间戳更新成最新的

  public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);

        // 从文件读取数据
        DataStream inputStream = env.readTextFile("E:\\尚硅谷\\Flink课程\\尚硅谷大数据技术之Flink（Java版）\\4.代码\\FlinkTutorial\\src\\main\\resources\\sensor.txt");

        // 转换成SensorReading类型
        DataStream dataStream = inputStream.map(line -> {
            String[] fields = line.split(",");
            return new SensorReading(fields[0], new Long(fields[1]), new Double(fields[2]));
        });

        // 分组
        KeyedStream keyedStream = dataStream.keyBy("id");

        // reduce聚合，取最大的温度值，以及当前最新的时间戳
        SingleOutputStreamOperator resultStream = keyedStream.reduce(new ReduceFunction() {
            @Override
            public SensorReading reduce(SensorReading value1, SensorReading value2) throws Exception {
                return new SensorReading(value1.getId(), value2.getTimestamp(), Math.max(value1.getTemperature(), value2.getTemperature()));
            }
        });

        keyedStream.reduce( (curState, newData) -> {
            return new SensorReading(curState.getId(), newData.getTimestamp(), Math.max(curState.getTemperature(), newData.getTemperature()));
        });

        resultStream.print();
        env.execute();
    }

txt

sensor_1,1547718199,35.8
sensor_6,1547718201,15.4
sensor_7,1547718202,6.7
sensor_10,1547718205,38.1
sensor_1,1547718207,36.3
sensor_1,1547718209,32.8
sensor_1,1547718211,37.2
sensor_1,1547718212,37.1

控制台打印输出

JavaFlink原理、实战、源码分析（二）原理部分_第7张图片

5.3.5Split 和 Select（Select只能搭配Split使用）

Split

JavaFlink原理、实战、源码分析（二）原理部分_第8张图片

DataStream → SplitStream：根据某些特征把一个 DataStream 拆分成两个或者多个 DataStream。

Select

JavaFlink原理、实战、源码分析（二）原理部分_第9张图片

SplitStream→DataStream：从一个 SplitStream 中获取一个或者多个DataStream。

需求：传感器数据按照温度高低（以 30 度为界），拆分成两个流。

   public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);

        // 从文件读取数据
        DataStream inputStream = env.readTextFile("E:\\尚硅谷\\Flink课程\\尚硅谷大数据技术之Flink（Java版）\\4.代码\\FlinkTutorial\\src\\main\\resources\\sensor.txt");

        // 转换成SensorReading
        DataStream dataStream = inputStream.map(line -> {
            String[] fields = line.split(",");
            return new SensorReading(fields[0], new Long(fields[1]), new Double(fields[2]));
        } );

        // 1. 分流，按照温度值30度为界分为两条流
        SplitStream splitStream = dataStream.split(new OutputSelector() {
            @Override
            public Iterable select(SensorReading value) {
                //Collections.singletonList()返回的是不可变的集合，但是这个长度的集合只有1，可以减少内存空间。但是返回的值依然是Collections的内部实现类，同样没有add的方法，调用add，set方法会报错
                return (value.getTemperature() > 30) ? Collections.singletonList("high") : Collections.singletonList("low");
                //Lists.newArrayList()其实和new ArrayList()几乎一模一样, 唯一它帮你做的(其实是javac帮你做的), 就是自动推导(不是"倒")尖括号里的数据类型.
                //return (value.getTemperature() > 30) ? Lists.newArrayList("high"):Lists.newArrayList("low");
            }
        });

        DataStream highTempStream = splitStream.select("high");
        DataStream lowTempStream = splitStream.select("low");
        DataStream allTempStream = splitStream.select("high", "low");

        highTempStream.print("high");
        lowTempStream.print("low");
        allTempStream.print("all");

        env.execute();
    }

控制台打印

JavaFlink原理、实战、源码分析（二）原理部分_第10张图片

 5.3.6 Connect 和 CoMap（只能是两条流）

JavaFlink原理、实战、源码分析（二）原理部分_第11张图片

DataStream,DataStream → ConnectedStreams：连接两个保持他们类型的数据流，两个数据流被 Connect 之后，只是被放在了一个同一个流中，内部依然保持各自的数据和形式不发生任何变化，两个流相互独立。

 CoMap,CoFlatMap

JavaFlink原理、实战、源码分析（二）原理部分_第12张图片

ConnectedStreams → DataStream：作用于 ConnectedStreams 上，功能与 map和 flatMap 一样，对 ConnectedStreams 中的每一个 Stream 分别进行 map 和 flatMap处理。

public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);

        // 从文件读取数据
        DataStream inputStream = env.readTextFile("E:\\尚硅谷\\Flink课程\\尚硅谷大数据技术之Flink（Java版）\\4.代码\\FlinkTutorial\\src\\main\\resources\\sensor.txt");

        // 转换成SensorReading
        DataStream dataStream = inputStream.map(line -> {
            String[] fields = line.split(",");
            return new SensorReading(fields[0], new Long(fields[1]), new Double(fields[2]));
        } );

        // 1. 分流，按照温度值30度为界分为两条流
        SplitStream splitStream = dataStream.split(new OutputSelector() {
            @Override
            public Iterable select(SensorReading value) {
                //Collections.singletonList()返回的是不可变的集合，但是这个长度的集合只有1，可以减少内存空间。但是返回的值依然是Collections的内部实现类，同样没有add的方法，调用add，set方法会报错
                return (value.getTemperature() > 30) ? Collections.singletonList("high") : Collections.singletonList("low");
                //Lists.newArrayList()其实和new ArrayList()几乎一模一样, 唯一它帮你做的(其实是javac帮你做的), 就是自动推导(不是"倒")尖括号里的数据类型.
                //return (value.getTemperature() > 30) ? Lists.newArrayList("high"):Lists.newArrayList("low");
            }
        });

        DataStream highTempStream = splitStream.select("high");
        DataStream lowTempStream = splitStream.select("low");
        DataStream allTempStream = splitStream.select("high", "low");

        // 2. 合流 connect，将高温流转换成二元组类型，与低温流连接合并之后，输出状态信息
        DataStream> warningStream = highTempStream.map(new MapFunction>() {
            @Override
            public Tuple2 map(SensorReading value) throws Exception {
                return new Tuple2<>(value.getId(), value.getTemperature());
            }
        });

        ConnectedStreams, SensorReading> connectedStreams = warningStream.connect(lowTempStream);

        DataStream resultStream = connectedStreams.map(new CoMapFunction, SensorReading, Object>() {
            @Override
            public Object map1(Tuple2 value) throws Exception {
                return new Tuple3<>(value.f0, value.f1, "high temp warning");
            }

            @Override
            public Object map2(SensorReading value) throws Exception {
                return new Tuple2<>(value.getId(), "normal");
            }
        });

        resultStream.print();

        env.execute();
    } 
  
控制台打印
 
  
JavaFlink原理、实战、源码分析（二）原理部分_第13张图片
 
  
5.3.7 Union（联合多条流）
 
  
JavaFlink原理、实战、源码分析（二）原理部分_第14张图片
 
  
  
 
  
DataStream → DataStream：对两个或者两个以上的 DataStream 进行 union 操作，产生一个包含所有 DataStream 元素的新 DataStream。
 
  
  public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);

        // 从文件读取数据
        DataStream inputStream = env.readTextFile("E:\\尚硅谷\\Flink课程\\尚硅谷大数据技术之Flink（Java版）\\4.代码\\FlinkTutorial\\src\\main\\resources\\sensor.txt");

        // 转换成SensorReading
        DataStream dataStream = inputStream.map(line -> {
            String[] fields = line.split(",");
            return new SensorReading(fields[0], new Long(fields[1]), new Double(fields[2]));
        } );

        // 1. 分流，按照温度值30度为界分为两条流
        SplitStream splitStream = dataStream.split(new OutputSelector() {
            @Override
            public Iterable select(SensorReading value) {
                //Collections.singletonList()返回的是不可变的集合，但是这个长度的集合只有1，可以减少内存空间。但是返回的值依然是Collections的内部实现类，同样没有add的方法，调用add，set方法会报错
                return (value.getTemperature() > 30) ? Collections.singletonList("high") : Collections.singletonList("low");
                //Lists.newArrayList()其实和new ArrayList()几乎一模一样, 唯一它帮你做的(其实是javac帮你做的), 就是自动推导(不是"倒")尖括号里的数据类型.
                //return (value.getTemperature() > 30) ? Lists.newArrayList("high"):Lists.newArrayList("low");
            }
        });

        DataStream highTempStream = splitStream.select("high");
        DataStream lowTempStream = splitStream.select("low");
        DataStream allTempStream = splitStream.select("high", "low");

        // 3. union联合多条流
//        warningStream.union(lowTempStream);
        DataStream unionAll = highTempStream.union(lowTempStream, allTempStream);
        unionAll.print("unionAll");
        env.execute();
    }
 
  
控制台打印
 
  
JavaFlink原理、实战、源码分析（二）原理部分_第15张图片
 
  
Connect 与 Union 区别：
 
  
1． Union 之前两个流的类型必须是一样，Connect 可以不一样，在之后的 coMap中再去调整成为一样的。
 
  
2. Connect 只能操作两个流，Union 可以操作多个。
 
  
 5.4 支持的数据类型
 
  
        Flink 流应用程序处理的是以数据对象表示的事件流。所以在 Flink 内部，我们需要能够处理这些对象。它们需要被序列化和反序列化，以便通过网络传送它们；或者从状态后端、检查点和保存点读取它们。为了有效地做到这一点，Flink 需要明确知道应用程序所处理的数据类型。Flink 使用类型信息的概念来表示数据类型，并为每个数据类型生成特定的序列化器、反序列化器和比较器。
 
  
        Flink 还具有一个类型提取系统，该系统分析函数的输入和返回类型，以自动获取类型信息，从而获得序列化器和反序列化器。但是，在某些情况下，例如 lambda函数或泛型类型，需要显式地提供类型信息，才能使应用程序正常工作或提高其性能。
 
  
        Flink 支持 Java 和 Scala 中所有常见数据类型。使用最广泛的类型有以下几种。
 
  
5.4.1 基础数据类型 
 
  
Flink 支持所有的 Java 和 Scala 基础数据类型，Int, Double, Long, String, …
 
  
DataStream numberStream = env.fromElements(1, 2, 3, 4);
numberStream.map(data -> data * 2);
 
  
5.4.2 Java 和 Scala 元组（Tuples） 
 
  
DataStream> personStream = env.fromElements(
 new Tuple2("Adam", 17),
 new Tuple2("Sarah", 23) );
personStream.filter(p -> p.f1 > 18);
 
  
 5.4.3 Scala 样例类（case classes） 
 
  
case class Person(name: String, age: Int)
val persons: DataStream[Person] = env.fromElements(
Person("Adam", 17),
Person("Sarah", 23) )
persons.filter(p => p.age > 18)
 
  
5.4.4 Java 简单对象（POJOs）  
 
  
public class Person {
public String name;
public int age;
 public Person() {}
 public Person(String name, int age) { 
this.name = name; 
this.age = age; 
} }
DataStream persons = env.fromElements( 
new Person("Alex", 42), 
new Person("Wendy", 23));
 
  
5.4.5 其它（Arrays, Lists, Maps, Enums, 等等）  
 
  
Flink 对 Java 和 Scala 中的一些特殊目的的类型也都是支持的，比如 Java 的ArrayList，HashMap，Enum 等等。
 
  
5.5 实现 UDF 函数——更细粒度的控制流
 
  
5.5.1 函数类（Function Classes）
 
  
Flink 暴露了所有 udf 函数的接口(实现方式为接口或者抽象类)。例如MapFunction, FilterFunction, ProcessFunction 等等。
 
  
下面例子实现了 FilterFunction 接口：
 
  
DataStream flinkTweets = tweets.filter(new FlinkFilter());
public static class FlinkFilter implements FilterFunction {
 @Override
 public boolean filter(String value) throws Exception {
 return value.contains("flink");
}
}
 
  
还可以将函数实现成匿名类
 
  
DataStream flinkTweets = tweets.filter(new FilterFunction() {
 @Override
 public boolean filter(String value) throws Exception {
 return value.contains("flink");
 }
});
 
  
我们 filter 的字符串"flink"还可以当作参数传进去。
 
  
DataStream tweets = env.readTextFile("INPUT_FILE ");
DataStream flinkTweets = tweets.filter(new KeyWordFilter("flink"));
public static class KeyWordFilter implements FilterFunction {
 private String keyWord;
 KeyWordFilter(String keyWord) { this.keyWord = keyWord; }
 @Override
 public boolean filter(String value) throws Exception {
 return value.contains(this.keyWord);
 } }
 
  
5.5.2 匿名函数（Lambda Functions）
 
  
DataStream tweets = env.readTextFile("INPUT_FILE");
DataStream flinkTweets = tweets.filter( tweet -> tweet.contains("flink") );
 
  
5.5.3 富函数（Rich Functions） 
 
  
        “富函数”是 DataStream API 提供的一个函数类的接口，所有 Flink 函数类都有其 Rich 版本。它与常规函数的不同在于，可以获取运行环境的上下文，并拥有一些生命周期方法，所以可以实现更复杂的功能。
 
  
⚫ RichMapFunction
 
  
⚫ RichFlatMapFunction
 
  
⚫ RichFilterFunction
 
  
⚫ …
 
  
Rich Function 有一个生命周期的概念。典型的生命周期方法有：
 
  
⚫ open()方法是 rich function 的初始化方法，当一个算子例如 map 或者 filter被调用之前 open()会被调用。
 
  
⚫ close()方法是生命周期中的最后一个调用的方法，做一些清理工作。
 
  
⚫ getRuntimeContext()方法提供了函数的 RuntimeContext 的一些信息，例如函数执行的并行度，任务的名字，以及 state 状态
 
  
  public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(4);

        // 从文件读取数据
        DataStream inputStream = env.readTextFile("E:\\尚硅谷\\Flink课程\\尚硅谷大数据技术之Flink（Java版）\\4.代码\\FlinkTutorial\\src\\main\\resources\\sensor.txt");

        // 转换成SensorReading类型
        DataStream dataStream = inputStream.map(line -> {
            String[] fields = line.split(",");
            return new SensorReading(fields[0], new Long(fields[1]), new Double(fields[2]));
        });

        DataStream> resultStream = dataStream.map( new MyMapper() );

        resultStream.print();

        env.execute();
    }

    public static class MyMapper0 implements MapFunction>{
        @Override
        public Tuple2 map(SensorReading value) throws Exception {
            return new Tuple2<>(value.getId(), value.getId().length());
        }
    }

    // 实现自定义富函数类
    public static class MyMapper extends RichMapFunction>{
        @Override
        public Tuple2 map(SensorReading value) throws Exception {
//            getRuntimeContext().getState();
            return new Tuple2<>(value.getId(), getRuntimeContext().getIndexOfThisSubtask());
        }

        @Override
        public void open(Configuration parameters) throws Exception {
            // 初始化工作，一般是定义状态，或者建立数据库连接
            System.out.println("open");
        }

        @Override
        public void close() throws Exception {
            // 一般是关闭连接和清空状态的收尾操作
            System.out.println("close");
        }
    }
 
  
控制台打印
 
  
JavaFlink原理、实战、源码分析（二）原理部分_第16张图片
 
  
5.5.4数据的重分区 
 
  
 public static void main(String[] args) throws Exception{
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(4);

        // 从文件读取数据
        DataStream inputStream = env.readTextFile("E:\\尚硅谷\\Flink课程\\尚硅谷大数据技术之Flink（Java版）\\4.代码\\FlinkTutorial\\src\\main\\resources\\sensor.txt");

        // 转换成SensorReading类型
        DataStream dataStream = inputStream.map(line -> {
            String[] fields = line.split(",");
            return new SensorReading(fields[0], new Long(fields[1]), new Double(fields[2]));
        });

        dataStream.print("input");

        // 1. shuffle随机打散，轮询的分配到分区中
        DataStream shuffleStream = inputStream.shuffle();

        shuffleStream.print("shuffle");

        // 2. keyBy根据hashCode重分区，把相同的key分到一个分区中，但是一个分区不一定只会有一个key的数据

        dataStream.keyBy("id").print("keyBy");

        // 3. global把所有的分区全部发送到下游的第一个分区
        dataStream.global().print("global");

        env.execute();
    }
 
  
 控制台打印
 
  
JavaFlink原理、实战、源码分析（二）原理部分_第17张图片
 
  
 5.6 Sink  
 
  
          Flink 没有类似于 spark 中 foreach 方法，让用户进行迭代的操作。虽有对外的输出操作都要利用 Sink 完成。最后通过类似如下方式完成整个任务最终输出操作。
 
  
stream.addSink(new MySink(xxxx))
 
  
 官方提供了一部分的框架的 sink。除此以外，需要用户自定义实现 sink。
 
  
JavaFlink原理、实战、源码分析（二）原理部分_第18张图片
 
  
 JavaFlink原理、实战、源码分析（二）原理部分_第19张图片
 
  
5.6.1 Kafka 
 
  
pom.xml
 
  

 org.apache.flink
 flink-connector-kafka-0.11_2.12
 1.10.1

 
  
主函数中添加 sink：
 
  
    public static void main(String[] args) throws Exception{
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);

//        // 从文件读取数据
//        DataStream inputStream = env.readTextFile("D:\\Projects\\BigData\\FlinkTutorial\\src\\main\\resources\\sensor.txt");

        Properties properties = new Properties();
        properties.setProperty("bootstrap.servers", "localhost:9092");
        properties.setProperty("group.id", "consumer-group");
        properties.setProperty("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        properties.setProperty("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        properties.setProperty("auto.offset.reset", "latest");

        // 从文件读取数据
        DataStream inputStream = env.addSource( new FlinkKafkaConsumer011("sensor", new SimpleStringSchema(), properties));

        // 转换成SensorReading类型
        DataStream dataStream = inputStream.map(line -> {
            String[] fields = line.split(",");
            return new SensorReading(fields[0], new Long(fields[1]), new Double(fields[2])).toString();
        });

        dataStream.addSink( new FlinkKafkaProducer011("localhost:9092", "sinktest", new SimpleStringSchema()));

        env.execute();
    }
 
  
启动kafka
 
  
JavaFlink原理、实战、源码分析（二）原理部分_第20张图片
 
  
启动producer
 
  
 JavaFlink原理、实战、源码分析（二）原理部分_第21张图片
 
  
 启动idea
 
  
启动consumer
 
  
 
  
 5.6.2 Redis（略）
 
  
pom.xml
 
  

 org.apache.bahir
 flink-connector-redis_2.11
 1.0

 
  
5.6.3 Elasticsearch  （略）
 
  

 org.apache.flink
 flink-connector-elasticsearch6_2.12
 1.10.1

 
  
 5.6.4 JDBC 自定义 sink 
 
  
pom.xml
 
  

 mysql
 mysql-connector-java
 5.1.44

 
  
   public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);

        DataStream dataStream = env.addSource(new SourceTest4_UDF.MySensorSource());
//在 main 方法中增加，把明细保存到 mysql 中
        dataStream.addSink(new MyJdbcSink());

        env.execute();
    }

    // 实现自定义的SinkFunction
    public static class MyJdbcSink extends RichSinkFunction {
        // 声明连接和预编译语句
        Connection connection = null;
        PreparedStatement insertStmt = null;
        PreparedStatement updateStmt = null;

        @Override
        public void open(Configuration parameters) throws Exception {
            connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "root");
            insertStmt = connection.prepareStatement("insert into sensor_temp (id, temp) values (?, ?)");
            updateStmt = connection.prepareStatement("update sensor_temp set temp = ? where id = ?");
        }

        // 每来一条数据，调用连接，执行sql
        @Override
        public void invoke(SensorReading value, Context context) throws Exception {
            // 直接执行更新语句，如果没有更新那么就插入
            updateStmt.setDouble(1, value.getTemperature());
            updateStmt.setString(2, value.getId());
            updateStmt.execute();
            if( updateStmt.getUpdateCount() == 0 ){
                insertStmt.setString(1, value.getId());
                insertStmt.setDouble(2, value.getTemperature());
                insertStmt.execute();
            }
        }

        @Override
        public void close() throws Exception {
            insertStmt.close();
            updateStmt.close();
            connection.close();
        }
    }
 
  
 
  
 // 实现自定义的SourceFunction
    public static class MySensorSource implements SourceFunction{
        // 定义一个标识位，用来控制数据的产生
        private boolean running = true;

        @Override
        public void run(SourceContext ctx) throws Exception {
            // 定义一个随机数发生器
            Random random = new Random();

            // 设置10个传感器的初始温度
            HashMap sensorTempMap = new HashMap<>();
            for( int i = 0; i < 10; i++ ){
                sensorTempMap.put("sensor_" + (i+1), 60 + random.nextGaussian() * 20);
            }

            while (running){
                for( String sensorId: sensorTempMap.keySet() ){
                    // 在当前温度基础上随机波动
                    Double newtemp = sensorTempMap.get(sensorId) + random.nextGaussian();
                    sensorTempMap.put(sensorId, newtemp);
                    ctx.collect(new SensorReading(sensorId, System.currentTimeMillis(), newtemp));
                }
                // 控制输出频率
                Thread.sleep(1000L);
            }
        }

        @Override
        public void cancel() {
            running = false;
        }
    }
 
  
启动查询mysql表
 
  
JavaFlink原理、实战、源码分析（二）原理部分_第22张图片
 
  
第六章 Flink 中的 Window
 
  
主要内容
 
  
• window 概念
 
  
• window 类型
 
  
• window API
 
  
6.1 Window
 
  
6.1.1 Window 概述 
 
  
streaming 流式计算是一种被设计用于处理无限数据集的数据处理引擎，而无限数据集是指一种不断增长的本质上无限的数据集，而 window 是一种切割无限数据为有限块进行处理的手段。
 
  
Window 是无限数据流处理的核心，Window 将一个无限的 stream 拆分成有限大 小的”buckets”桶，我们可以在这些桶上做计算操作。
 
  
JavaFlink原理、实战、源码分析（二）原理部分_第23张图片
 
  
• 一般真实的流都是无界的，怎样处理无界的数据？
 
  
• 可以把无限的数据流进行切分，得到有限的数据集进行处理 —— 也就是得到有界流
 
  
• 窗口（window）就是将无限流切割为有限流的一种方式，它会将流数据分发到有限大小的桶（bucket）中进行分析
 
  
6.1.2 Window 类型
 
  
Window 可以分成两类：
 
  
• 时间窗口（Time Window）：按照时间生成 Window。
 
  
➢ 滚动时间窗口
 
  
➢ 滑动时间窗口
 
  
➢ 会话窗口
 
  
• 计数窗口（Count Window）：按照指定的数据条数生成一个 Window，与时间无关。
 
  
➢ 滚动计数窗口
 
  
➢ 滑动计数窗口
 
  
 
  
1. 滚动窗口（Tumbling Windows） 
 
  
        滚动窗口分配器将每个元素分配到一个指定窗口大小的窗口中，滚动窗口有一个固定的大小，并且不会出现重叠。例如：如果你指定了一个 5 分钟大小的滚动窗 口，窗口的创建如下图所示：
 
  
JavaFlink原理、实战、源码分析（二）原理部分_第24张图片
 
  
将数据依据固定的窗口长度对数据进行切片。
 
  
特点：时间对齐，窗口长度固定，没有重叠。
 
  
适用场景：适合做 BI 统计等（做每个时间段的聚合计算）。
 
  
 
  
2. 滑动窗口（Sliding Windows） 
 
  
滑动窗口是固定窗口的更广义的一种形式，滑动窗口由固定的窗口长度和滑动 间隔组成。
 
  
特点：时间对齐，窗口长度固定，可以有重叠。 
 
  
        滑动窗口分配器将元素分配到固定长度的窗口中，与滚动窗口类似，窗口的大小由窗口大小参数来配置，另一个窗口滑动参数控制滑动窗口开始的频率。因此，滑动窗口如果滑动参数小于窗口大小的话，窗口是可以重叠的，在这种情况下元素会被分配到多个窗口中。
 
  
例如，你有 10 分钟的窗口和 5 分钟的滑动，那么每个窗口中 5 分钟的窗口里包含着上个 10 分钟产生的数据，如下图所示：
 
  
JavaFlink原理、实战、源码分析（二）原理部分_第25张图片
 
  
适用场景：对最近一个时间段内的统计（求某接口最近 5min 的失败率来决定是否要报警）。
 
  
 3. 会话窗口（Session Windows）
 
  
由一系列事件组合一个指定时间长度的 timeout 间隙组成，类似于 web 应用的session，也就是一段时间没有接收到新数据就会生成新的窗口。
 
  
特点：时间无对齐。
 
  
        session 窗口分配器通过 session 活动来对元素进行分组，session 窗口跟滚动窗口和滑动窗口相比，不会有重叠和固定的开始时间和结束时间的情况，相反，当它在一个固定的时间周期内不再收到元素，即非活动间隔产生，那个这个窗口就会关闭。一个 session 窗口通过一个 session 间隔来配置，这个 session 间隔定义了非活跃周期的长度，当这个非活跃周期产生，那么当前的 session 将关闭并且后续的元素将被分配到新的 session 窗口中去。
 
  
JavaFlink原理、实战、源码分析（二）原理部分_第26张图片
 
  
6.2 Window API 
 
  
• 窗口分配器 —— window() 方法
 
  
➢ 我们可以用 .window() 来定义一个窗口，然后基于这个 window 去做一些聚 合或者其它处理操作。
 
  
    注意： window () 方法必须在 keyBy 之后才能用。
 
  
➢ Flink 提供了更加简单的 .timeWindow 和 .countWindow 方法，用于定义时间窗口和计数窗口。
 
  
6.2.1 窗口分配器（window assigner）
 
  
• window() 方法接收的输入参数是一个 WindowAssigner
 
  
• WindowAssigner 负责将每条输入的数据分发到正确的 window 中
 
  
• Flink 提供了通用的 WindowAssigner
 
  
➢ 滚动窗口（tumbling window）
 
  
➢ 滑动窗口（sliding window）
 
  
➢ 会话窗口（session window）
 
  
➢ 全局窗口（global window）
 
  
6.2.2创建不同类型的窗口
 
  
6.2.2.1 TimeWindow 
 
  
      TimeWindow 是将指定时间范围内的所有数据组成一个 window，一次对一个window 里面的所有数据进行计算。
 
  
1. 滚动时间窗口 （tumbling time window）
 
  
       Flink 默认的时间窗口根据 Processing Time 进行窗口的划分，将 Flink 获取到的数据根据进入 Flink 的时间划分到不同的窗口中。
 
  
.timeWindow( Time.seconds(15) )
 
  
时间间隔可以通过 Time.milliseconds(x)，Time.seconds(x)，Time.minutes(x)等其中的一个来指定。
 
  
 
  
2. 滑动窗口（SlidingEventTimeWindows）
 
  
        滑动窗口和滚动窗口的函数名是完全一致的，只是在传参数时需要传入两个参数，一个是 window_size，一个是 sliding_size。
 
  
        下面代码中的 sliding_size 设置为了 5s，也就是说，每 5s 就计算输出结果一次，每一次计算的 window 范围是 15s 内的所有元素。
 
  
.timeWindow( Time.seconds(15), Time.seconds(5) )
 
  
时间间隔可以通过 Time.milliseconds(x)，Time.seconds(x)，Time.minutes(x)等其中的一个来指定。
 
  
6.2.2.2 CountWindow 
 
  
CountWindow 根据窗口中相同 key 元素的数量来触发执行，执行时只计算元素数量达到窗口大小的 key 对应的结果。
 
  
注意：CountWindow 的 window_size 指的是相同 Key 的元素的个数，不是输入的所有元素的总数。已验证
 
  
1 滚动计数窗口 （tumbling count window）
 
  
默认的 CountWindow 是一个滚动窗口，只需要指定窗口大小即可，当元素数量达到窗口大小时，就会触发窗口的执行。
 
  
.countWindow( 5 )
 
  
2 滑动计数窗口（sliding count window） 
 
  
下面代码中的 sliding_size 设置为了 2，也就是说，每收到两个相同 key 的数据就计算一次，每一次计算的 window 范围是 10 个元素。
 
  
.countWindow( 10, 2 )
 
  
 
  
   public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);


        // socket文本流
        DataStream inputStream = env.socketTextStream("localhost", 7777);

        // 转换成SensorReading类型
        DataStream dataStream = inputStream.map(line -> {
            String[] fields = line.split(",");
            return new SensorReading(fields[0], new Long(fields[1]), new Double(fields[2]));
        });

        // 开计数窗口测试
        SingleOutputStreamOperator avgTempResultStream = dataStream.keyBy("id")
                .countWindow(10, 2)
                .aggregate(new MyAvgTemp());

        avgTempResultStream.print();

        env.execute();
    }

    public static class MyAvgTemp implements AggregateFunction, Double>{
        @Override
        public Tuple2 createAccumulator() {
            return new Tuple2<>(0.0, 0);
        }

        @Override
        public Tuple2 add(SensorReading value, Tuple2 accumulator) {
            return new Tuple2<>(accumulator.f0 + value.getTemperature(), accumulator.f1 + 1);
        }

        @Override
        public Double getResult(Tuple2 accumulator) {
            return accumulator.f0 / accumulator.f1;
        }

        @Override
        public Tuple2 merge(Tuple2 a, Tuple2 b) {
            return new Tuple2<>(a.f0 + b.f0, a.f1 + b.f1);
        }
    }
 
  
6.2.2.3SessionWindow
 
  
 .window(EventTimeSessionWindows.withGap(Time.minutes(1)));
 
  
6.2.3 window function
 
  
window function 定义了要对窗口中收集的数据做的计算操作，主要可以分为两类：
 
  
⚫ 增量聚合函数（incremental aggregation functions）
 
  
每条数据到来就进行计算，保持一个简单的状态。典型的增量聚合函数有ReduceFunction, AggregateFunction。
 
  
 public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);

        // socket文本流
        DataStream inputStream = env.socketTextStream("locahost", 7777);

        // 转换成SensorReading类型
        DataStream dataStream = inputStream.map(line -> {
            String[] fields = line.split(",");
            return new SensorReading(fields[0], new Long(fields[1]), new Double(fields[2]));
        });

        // 开窗测试

        // 1. 增量聚合函数
        DataStream resultStream = dataStream.keyBy("id")
//                .countWindow(10, 2);
//                .window(EventTimeSessionWindows.withGap(Time.minutes(1)));
//                .window(TumblingProcessingTimeWindows.of(Time.seconds(15)))
                .timeWindow(Time.seconds(15))
                .aggregate(new AggregateFunction() {
                    @Override
                    public Integer createAccumulator() {
                        return 0;
                    }

                    @Override
                    public Integer add(SensorReading value, Integer accumulator) {
                        return accumulator + 1;
                    }

                    @Override
                    public Integer getResult(Integer accumulator) {
                        return accumulator;
                    }

                    @Override
                    public Integer merge(Integer a, Integer b) {
                        return a + b;
                    }
                });

        resultStream.print();


        env.execute();
    }
 
  
控制台输出（每隔15输出一次聚合结果）
 
  
 
  
⚫ 全窗口函数（full window functions）
 
  
先把窗口所有数据收集起来，等到计算的时候会遍历所有数据。ProcessWindowFunction 就是一个全窗口函数。
 
  
 public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);

        // socket文本流
        DataStream inputStream = env.socketTextStream("localhost", 7777);

        // 转换成SensorReading类型
        DataStream dataStream = inputStream.map(line -> {
            String[] fields = line.split(",");
            return new SensorReading(fields[0], new Long(fields[1]), new Double(fields[2]));
        });

        // 开窗测试
        // 2. 全窗口函数
        SingleOutputStreamOperator> resultStream2 = dataStream.keyBy("id")
                .timeWindow(Time.seconds(15))
//                .process(new ProcessWindowFunction() {
//                })
                .apply(new WindowFunction, Tuple, TimeWindow>() {
                    @Override
                    public void apply(Tuple tuple, TimeWindow window, Iterable input, Collector> out) throws Exception {
                        String id = tuple.getField(0);
                        Long windowEnd = window.getEnd();
                        Integer count = IteratorUtils.toList(input.iterator()).size();
                        out.collect(new Tuple3<>(id, windowEnd, count));
                    }
                });

        resultStream2.print();


        env.execute();
    }
 
  
6.2.4 其它可选 API
 
  
⚫ .trigger() —— 触发器
 
  
定义 window 什么时候关闭，触发计算并输出结果
 
  
⚫ .evitor() —— 移除器
 
  
定义移除某些数据的逻辑
 
  
⚫ .allowedLateness() —— 允许处理迟到的数据
 
  
⚫ .sideOutputLateData() —— 将迟到的数据放入侧输出流
 
  
⚫ .getSideOutput() —— 获取侧输出流
 
  
 
  
   public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);

        // socket文本流
        DataStream inputStream = env.socketTextStream("localhost", 7777);

        // 转换成SensorReading类型
        DataStream dataStream = inputStream.map(line -> {
            String[] fields = line.split(",");
            return new SensorReading(fields[0], new Long(fields[1]), new Double(fields[2]));
        });

        // 开窗测试
   

        // 3. 其它可选API
//实例化
        OutputTag outputTag = new OutputTag("late") {
        };

        SingleOutputStreamOperator sumStream = dataStream.keyBy("id")
                .timeWindow(Time.seconds(15))
//                .trigger()
//                .evictor()
//允许处理迟到的数据
                .allowedLateness(Time.minutes(1))
//将迟到的数据放入侧输出流
                .sideOutputLateData(outputTag)
                .sum("temperature");
//获取侧输出流
        sumStream.getSideOutput(outputTag).print("late");

        resultStream2.print();

        env.execute();
    }
 
  
JavaFlink原理、实战、源码分析（二）原理部分_第27张图片
 
  
第七章 时间语义与 Wartermark
 
  
7.1 Flink 中的时间语义
 
  
在 Flink 的流式处理中，会涉及到时间的不同概念，如下图所示：
 
  
JavaFlink原理、实战、源码分析（二）原理部分_第28张图片
 
  
 
  
Event Time：是事件创建的时间。它通常由事件中的时间戳描述，例如采集的日志数据中，每一条日志都会记录自己的生成时间，Flink 通过时间戳分配器访问事件时间戳。
 
  
Ingestion Time：是数据进入 Flink 的时间。
 
  
Processing Time：是每一个执行基于时间操作的算子的本地系统时间，与机器相关，默认的时间属性就是 Processing Time。
 
  
一个例子——电影《星球大战》：
 
  
JavaFlink原理、实战、源码分析（二）原理部分_第29张图片
 
  
• 不同的时间语义有不同的应用场合
 
  
• 我们往往更关心事件时间（Event Time）
 
  
JavaFlink原理、实战、源码分析（二）原理部分_第30张图片
 
  
• 某些应用场合，不应该使用 Processing Time
 
  
• Event Time 可以从日志数据的时间戳（timestamp）中提取
 
  
➢ 2017-11-02 18:37:15.624 INFO Fail over to rm
 
  
例如，一条日志进入 Flink 的时间为 2017-11-12 10:00:00.123，到达 Window 的系统时间为 2017-11-12 10:00:01.234，日志的内容如下：
 
  
2017-11-02 18:37:15.624 INFO Fail over to rm2
 
  
对于业务来说，要统计 1min 内的故障日志个数，哪个时间是最有意义的？—— eventTime，因为我们要根据日志的生成时间进行统计。
 
  
 7.2 EventTime 的引入
 
  
在 Flink 的流式处理中，绝大部分的业务都会使用 eventTime，一般只在eventTime 无法使用时，才会被迫使用 ProcessingTime 或者 IngestionTime。如果要使用 EventTime，那么需要引入 EventTime 的时间属性，引入方式如下所示：
 
  
• 我们可以直接在代码中，对执行环境调用 setStreamTimeCharacteristic方法，设置流的时间特性
 
  
• 具体的时间，还需要从数据中提取时间戳（timestamp）
 
  
StreamExecutionEnvironment env = 
StreamExecutionEnvironment.getExecutionEnvironment
// 从调用时刻开始给 env 创建的每一个 stream 追加时间特征
env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)
 
  
7.3 Watermark
 
  
        我们知道，流处理从事件产生，到流经 source，再到 operator，中间是有一个过程和时间的，虽然大部分情况下，流到 operator 的数据都是按照事件产生的时间顺序来的，但是也不排除由于网络、分布式等原因，导致乱序的产生，所谓乱序，就是指 Flink 接收到的事件的先后顺序不是严格按照事件的 Event Time 顺序排列的。
 
  
JavaFlink原理、实战、源码分析（二）原理部分_第31张图片
 
  
 
  
⚫ Watermark 是一种衡量 Event Time 进展的机制。
 
  
⚫ Watermark 是用于处理乱序事件的，而正确的处理乱序事件，通常用Watermark 机制结合 window 来实现。
 
  
⚫ 数据流中的 Watermark 用于表示 timestamp 小于 Watermark 的数据，都已经到达了，因此，window 的执行也是由 Watermark 触发的。
 
  
⚫watermark 用来让程序自己平衡延迟和结果正确性
 
  
⚫ Watermark 可以理解成一个延迟触发机制，我们可以设置 Watermark 的延时时长 t，每次系统会校验已经到达的数据中最大的 maxEventTime，然后认定 eventTime小于 maxEventTime - t 的所有数据都已经到达，如果有窗口的停止时间等于maxEventTime – t，那么这个窗口被触发执行。
 
  
 
  
 
  
有序流的 Watermarker 如下图所示：（Watermark 设置为 0）
 
  
JavaFlink原理、实战、源码分析（二）原理部分_第32张图片
 
  
 
  
乱序流的 Watermarker 如下图所示：（Watermark 设置为 2） 
 
  
JavaFlink原理、实战、源码分析（二）原理部分_第33张图片
 
  
 
  
        当 Flink 接收到数据时，会按照一定的规则去生成 Watermark，这条 Watermark就等于当前所有到达数据中的 maxEventTime - 延迟时长，也就是说，Watermark 是基于数据携带的时间戳生成的，一旦 Watermark 比当前未触发的窗口的停止时间要晚，那么就会触发相应窗口的执行。由于 event time 是由数据携带的，因此，如果运行过程中无法获取新的数据，那么没有被触发的窗口将永远都不被触发。
 
  
       上图中，我们设置的允许最大延迟到达时间为 2s，所以时间戳为 7s 的事件对应的 Watermark 是 5s，时间戳为 12s 的事件的 Watermark 是 10s，如果我们的窗口 1是 1s~5s，窗口 2 是 6s~10s，那么时间戳为 7s 的事件到达时的 Watermarker 恰好触发窗口 1，时间戳为 12s 的事件到达时的 Watermark 恰好触发窗口 2。 Watermark 就是触发前一窗口的“关窗时间”，一旦触发关门那么以当前时刻为准在窗口范围内的所有所有数据都会收入窗中。只要没有达到水位那么不管现实中的时间推进了多久都不会触发关窗。
 
  
watermark 的特点 
 
  
JavaFlink原理、实战、源码分析（二）原理部分_第34张图片
 
  
 
  
• watermark 是一条特殊的数据记录
 
  
• watermark 必须单调递增，以确保任务的事件时间时钟在向前推进，而不是在后退
 
  
• watermark 与数据的时间戳相关
 
  
watermark 的传递
 
  
我们知道水位线是数据流中插入的一个标记，用来表示事件时间的进展，它会随着数据一起在任务间传递。如果只是直通式（forward）的传输，那很简单，数据和水位线都是按照本身的顺序依次传递、依次处理的；一旦水位线到达了算子任务, 那么这个任务就会将它内部的时钟设为这个水位线的时间戳。
 
  
在这里，“任务的时钟”其实仍然是各自为政的，并没有统一的时钟。实际应用中往往上下游都有多个并行子任务，为了统一推进事件时间的进展，我们要求上游任务处理完水位线、时钟改变之后，要把当前的水位线再次发出，广播给所有的下游子任务。这样，后续任务就不需要依赖原始数据中的时间戳（经过转化处理后，数据可能已经改变了），也可以知道当前事件时间了。
 
  
可是还有另外一个问题，那就是在“重分区”（redistributing）的传输模式下，一个任务有可能会收到来自不同分区上游子任务的数据。而不同分区的子任务时钟并不同步，所以同一时刻发给下游任务的水位线可能并不相同。这时下游任务又该听谁的呢？
 
  
这就要回到水位线定义的本质了：它表示的是“当前时间之前的数据，都已经到齐了”。这是一种保证，告诉下游任务“只要你接到这个水位线，就代表之后我不会再给你发更早的数据了，你可以放心做统计计算而不会遗漏数据”。所以如果一个任务收到了来自上游并行任务的不同的水位线，说明上游各个分区处理得有快有慢，进度各不相同比如上游有两个并行子任务都发来了水位线，一个是 5 秒，一个是 7 秒；这代表第一个并行任务已经处理完 5 秒之前的
 
  
所有数据，而第二个并行任务处理到了 7 秒。那这时自己的时钟怎么确定呢？当然也要以“这之前的数据全部到齐”为标准。如果我们以较大的水位线 7 秒作为当前时间，那就表示“7 秒前的数据都已经处理完”，这显然不是事实——第一个上游分区才处理到 5 秒，5~7 秒的数据还会不停地发来；而如果以最小的水位线 5 秒作为当前时钟就不会有这个问题了，因为确实所
 
  
有上游分区都已经处理完，不会再发 5 秒前的数据了。这让我们想到“木桶原理”：所有的上游并行任务就像围成木桶的一块块木板，它们中最短的那一块，决定了我们桶中的水位。
 
  
 
 
  
JavaFlink原理、实战、源码分析（二）原理部分_第35张图片
 
  
JavaFlink原理、实战、源码分析（二）原理部分_第36张图片 
 
  
 
   
我们可以用一个具体的例子，将水位线在任务间传递的过程完整梳理一遍。如上图 所示，当前任务的上游，有四个并行子任务，所以会接收到来自四个分区的水位线；而下游有三个并行子任务，所以会向三个分区发出水位线。具体过程如下：
 
   
     
    
  1. 上游并行子任务发来不同的水位线，当前任务会为每一个分区设置一个“分区水位线”（Partition  Watermark），这是一个分区时钟；而当前任务自己的时钟，就是所有分区时钟里最小的那个。
    2.  
    
  2. 当有一个新的水位线（第一分区的 4）从上游传来时，当前任务会首先更新对应的分区时钟；然后再次判断所有分区时钟中的最小值，如果比之前大，说明事件时间有了进展，当前任务的时钟也就可以更新了。这里要注意，更新后的任务时钟，并不一定是新来的那个分区水位线，比如这里改变的是第一分区的时钟，但最小的分区时钟是第三分区的 3，于是当前任务时钟就推进到了 3。当时钟有进展时，当前任务就会将自己的时钟以水位线的形式，广播给下游所有子任务。
    3.  
    
  3. 再次收到新的水位线（第二分区的 7）后，执行同样的处理流程。首先将第二个分区时钟更新为 7，然后比较所有分区时钟；发现最小值没有变化，那么当前任务的时钟也不变，也不会向下游任务发出水位线。
    4.  
   
 
  
 
  
     
   
  1. 同样道理，当又一次收到新的水位线（第三分区的 6）之后，第三个分区时钟更新为6，同时所有分区时钟最小值变成了第一分区的 4，所以当前任务的时钟推进到 4，并发出时间戳为 4 的水位线，广播到下游各个分区任务。水位线在上下游任务之间的传递，非常巧妙地避免了分布式系统中没有统一时钟的问题， 每个任务都以“处理完之前所有数据”为标准来确定自己的时钟，就可以保证窗口处理的结果总是正确的。对于有多条流合并之后进行处理的场景，水位线传递的规则是类似的。关于 Flink 中的多流转换，我们会在后续章节中介绍。
    2.  
  
 
  
 注：最小的做全局watermark；分区watermark用最大的递增，如果分区在比较的时候发现最小的已广播则当前分区小的不在重复广播（木桶原理）
 
  
 7.3.2 Watermark 的引入 
 
  
 watermark  的引入很简单，对于乱序数据，最常见的引用方式如下：  
  
 
  
 
   
   public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
//        env.setParallelism(1);
        // 从调用时刻开始给 env 创建的每一个 stream 追加时间特征
        env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime);
        env.getConfig().setAutoWatermarkInterval(100);

        // socket文本流
        DataStream inputStream = env.socketTextStream("192.168.32.200", 7777);

        // 转换成SensorReading类型，分配时间戳和watermark
        DataStream dataStream = inputStream.map(line -> {
            String[] fields = line.split(",");
            return new SensorReading(fields[0], new Long(fields[1]), new Double(fields[2]));
        })
                // 升序数据设置事件时间和watermark
//                .assignTimestampsAndWatermarks(new AscendingTimestampExtractor() {
//                    @Override
//                    public long extractAscendingTimestamp(SensorReading element) {
//                        return element.getTimestamp() * 1000L;
//                    }
//                })
                // 乱序数据设置时间戳和watermark
                .assignTimestampsAndWatermarks(new BoundedOutOfOrdernessTimestampExtractor(Time.seconds(2)) {
                    @Override
                    public long extractTimestamp(SensorReading element) {
                        return element.getTimestamp() * 1000L;
                    }
                });

        OutputTag outputTag = new OutputTag("late") {
        };

        // 基于事件时间的开窗聚合，统计15秒内温度的最小值
        SingleOutputStreamOperator minTempStream = dataStream.keyBy("id")
                .timeWindow(Time.seconds(15))
                .allowedLateness(Time.minutes(1))
                .sideOutputLateData(outputTag)
                .minBy("temperature");

        minTempStream.print("minTemp");
        minTempStream.getSideOutput(outputTag).print("late");

        env.execute();
    }
 
   
注意：watermark是固定周期性或者是间断式生成的，（数据稠密用固定周期，数据稀疏用间断式）
 
  
 
  
watermark 的设定
 
  
 •  在 Flink 中，watermark 由应用程序开发人员生成，这通常需要对相应的领域有一定的了解  
  
 
  
 •  如果watermark设置的延迟太久，收到结果的速度可能就会很慢，解决办法是在水位线到达之前输出一个近似结果  
  
 
  
 •  而如果watermark到达得太早，则可能收到错误结果，不过 Flink 处理迟到数据的机制可以解决这个问题 
  
 
  
MyAssigner 有两种类型
 
  
 ⚫  AssignerWithPeriodicWatermarks  
  
 
  
 ⚫  AssignerWithPunctuatedWatermarks  
  
 
  
 以上两个接口都继承自  TimestampAssigner 。  
  
 
  
 
   
 Assigner with periodic watermarks  
   
 
   
         周期性的生成  watermark ：系统会周期性的将  watermark  插入到流中 ( 水位线也是一种特殊的事件!) 。默认周期是  200  毫秒。可以使用ExecutionConfig.setAutoWatermarkInterval()方法进行设置。  
   
 
   
 
    
// 每隔 5 秒产生一个 watermark
env.getConfig.setAutoWatermarkInterval(5000);
 
    
         产生  watermark  的逻辑：每隔  5  秒钟， Flink  会调用AssignerWithPeriodicWatermarks 的  getCurrentWatermark()方法。如果方法返回一个时间戳大于之前水位的时间戳，新的 watermark 会被插入到流中。这个检查保证了水位线是单调递增的。如果方法返回的时间戳小于等于之前水位的时间戳，则不会产生新的 watermark。 
    
 
   
 
   
 例子，自定义一个周期性的时间戳抽取：  
   
 
   
 
    
// 自定义周期性时间戳分配器
public static class MyPeriodicAssigner implements 
AssignerWithPeriodicWatermarks{
 
private Long bound = 60 * 1000L; // 延迟一分钟
 private Long maxTs = Long.MIN_VALUE; // 当前最大时间戳
 @Nullable
 @Override
 public Watermark getCurrentWatermark() {
 return new Watermark(maxTs - bound);
 }
 @Override
 public long extractTimestamp(SensorReading element, long previousElementTimestamp) 
{
 maxTs = Math.max(maxTs, element.getTimestamp());
 return element.getTimestamp();
 } }
 
    
 Assigner with punctuated watermarks 
    
 
    
        间断式地生成  watermark 。和周期性生成的方式不同，这种方式不是固定时间的，而是可以根据需要对每条数据进行筛选和处理。直接上代码来举个例子，我们只给sensor_1 的传感器的数据流插入  watermark ：  
    
 
    
 
     
public static class MyPunctuatedAssigner implements 
AssignerWithPunctuatedWatermarks{
 private Long bound = 60 * 1000L; // 延迟一分钟
 @Nullable
 @Override
 public Watermark checkAndGetNextWatermark(SensorReading lastElement, long 
extractedTimestamp) {
 if(lastElement.getId().equals("sensor_1"))
 return new Watermark(extractedTimestamp - bound);
 else
 return null;
 }
 @Override
 public long extractTimestamp(SensorReading element, long previousElementTimestamp) 
{
 return element.getTimestamp();
 } }
 
     
 窗口起始点与偏移量
 
     
public WindowedStream timeWindow(Time size) {
        return this.environment.getStreamTimeCharacteristic() == TimeCharacteristic.ProcessingTime ? this.window(TumblingProcessingTimeWindows.of(size)) : this.window(TumblingEventTimeWindows.of(size));
    }
 
     
 
     
   public Collection assignWindows(Object element, long timestamp, WindowAssignerContext context) {
        if (timestamp > -9223372036854775808L) {
            long start = TimeWindow.getWindowStartWithOffset(timestamp, this.offset, this.size);
            return Collections.singletonList(new TimeWindow(start, start + this.size));
        } else {
            throw new RuntimeException("Record has Long.MIN_VALUE timestamp (= no timestamp marker). Is the time characteristic set to 'ProcessingTime', or did you forget to call 'DataStream.assignTimestampsAndWatermarks(...)'?");
        }
    }
 
     
对windowSize取余 ，offset最开始没有设置默认为0，
 
     
 public static long getWindowStartWithOffset(long timestamp, long offset, long windowSize) {
        //return timestamp - timestamp% windowSize; 
        return timestamp - (timestamp - offset + windowSize) % windowSize;

    }
 
     
 
    
 
   
 
  
 
  
 
  
 
  
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Flink,大数据,flink,java)

        

            

                
    
                    
  • Long类型前后端数据不一致
                        igotyback
前端
                        
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
    
                    
    • 
                    
  • LocalDateTime 转 String
                        igotyback
java开发语言
                        
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
    
                    
    • 
                    
  • Linux下QT开发的动态库界面弹出操作（SDL2）
                        13jjyao
QT类qt开发语言sdl2linux
                        
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
    
                    
    • 
                    
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
    
                    
    • 
                    
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team
                        若博豆
java算法华为javascript
                        
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
    
                    
    • 
                    
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript
                        二挡起步
web前端期末大作业javascripthtmlcss旅游风景
                        
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
    
                    
    • 
                    
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动
                        二挡起步
web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
                        
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
    
                    
    • 
                    
  • node.js学习
                        小猿L
node.jsnode.js学习vim
                        
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
    
                    
    • 
                    
  • nosql数据库技术与应用知识点
                        皆过客，揽星河
NoSQLnosql数据库大数据数据分析数据结构非关系型数据库
                        
    Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
    
                    
    • 
                    
  • ES聚合分析原理与代码实例讲解
                        光剑书架上的书
大厂Offer收割机面试题简历程序员读书硅基计算碳基计算认知计算生物计算深度学习神经网络大数据AIGCAGILLMJavaPython架构设计Agent程序员实现财富自由
                        
    ES聚合分析原理与代码实例讲解1.背景介绍1.1问题的由来在大规模数据分析场景中，特别是在使用Elasticsearch（ES）进行数据存储和检索时，聚合分析成为了一个至关重要的功能。聚合分析允许用户对数据集进行细分和分组，以便深入探索数据的结构和模式。这在诸如实时监控、日志分析、业务洞察等领域具有广泛的应用。1.2研究现状目前，ES聚合分析已经成为现代大数据平台的核心组件之一。它支持多种类型的聚
    
                    
    • 
                    
  • Java 重写(Override)与重载(Overload)
                        叨唧唧的

                        
    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
    
                    
    • 
                    
  • 简单了解 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
    
                    
    • 
                    
  • Java企业面试题3
                        马龙强_
java
                        
    1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
    
                    
    • 
                    
  • 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
    
                    
    • 
                    
  • Java面试题精选：消息队列(二)
                        芒果不是芒
Java面试题精选javakafka
                        
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
    
                    
    • 
                    
  • 白骑士的Java教学基础篇 2.5 控制流语句
                        白骑士所长
Java教学java开发语言
                        
    欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
    
                    
    • 
                    
  • python语法——三目运算符
                        HappyRocking
pythonpython三目运算符
                        
    在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
    
                    
    • 
                    
  • ArrayList 源码解析
                        程序猿进阶
Java基础ArrayListListjava面试性能优化架构设计idea
                        
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
    
                    
    • 
                    
  • Java爬虫框架（一）--架构设计
                        狼图腾-狼之传说
java框架java任务html解析器存储电子商务
                        
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
    
                    
    • 
                    
  • Java：爬虫框架
                        dingcho
Javajava爬虫
                        
    一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
    
                    
    • 
                    
  • python怎么将png转为tif_png转tif
                        weixin_39977276

                        
    发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
    
                    
    • 
                    
  • JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）
                        跳房子的前端
前端面试javascript开发语言ecmascript
                        
    在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
    
                    
    • 
                    
  • JAVA·一个简单的登录窗口
                        MortalTom
java开发语言学习
                        
    文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
    
                    
    • 
                    
  • WebMagic：强大的Java爬虫框架解析与实战
                        Aaron_945
Javajava爬虫开发语言
                        
    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
    
                    
    • 
                    
  • 博客网站制作教程
                        2401_85194651
javamaven
                        
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
    
                    
    • 
                    
  • 00. 这里整理了最全的爬虫框架（Java + Python）
                        有一只柴犬
爬虫系列爬虫javapython
                        
    目录1、前言2、什么是网络爬虫3、常见的爬虫框架3.1、java框架3.1.1、WebMagic3.1.2、Jsoup3.1.3、HttpClient3.1.4、Crawler4j3.1.5、HtmlUnit3.1.6、Selenium3.2、Python框架3.2.1、Scrapy3.2.2、BeautifulSoup+Requests3.2.3、Selenium3.2.4、PyQuery3.2
    
                    
    • 
                    
  • JAVA学习笔记之23种设计模式学习
                        victorfreedom
Java技术设计模式androidjava常用设计模式
                        
    博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
    
                    
    • 
                    
  • JavaScript `Map` 和 `WeakMap`详细解释
                        跳房子的前端
JavaScript原生方法javascript前端开发语言
                        
    在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
    
                    
    • 
                    
  • 免费的GPT可在线直接使用（一键收藏）
                        kkai人工智能
gpt
                        
    1、LuminAI（https://kk.zlrxjh.top）LuminAI标志着一款融合了星辰大数据模型与文脉深度模型的先进知识增强型语言处理系统，旨在自然语言处理（NLP）的技术开发领域发光发热。此系统展现了卓越的语义把握与内容生成能力，轻松驾驭多样化的自然语言处理任务。VisionAI在NLP界的应用领域广泛，能够胜任从机器翻译、文本概要撰写、情绪分析到问答等众多任务。通过对大量文本数据的
    
                    
    • 
                                
  • Nginx负载均衡
                                    510888780
nginx应用服务器
                                    
    Nginx负载均衡一些基础知识: 
 
nginx 的 upstream目前支持 4 种方式的分配 
1)、轮询（默认） 
      每个请求按时间顺序逐一分配到不同的后端服务器，如果后端服务器down掉，能自动剔除。 
2)、weight 
      指定轮询几率，weight和访问比率成正比
    
                                
    • 
                                
  • RedHat 6.4 安装 rabbitmq
                                    bylijinnan
erlangrabbitmqredhat
                                    
    在 linux 下安装软件就是折腾，首先是测试机不能上外网要找运维开通，开通后发现测试机的 yum 不能使用于是又要配置 yum 源，最后安装 rabbitmq 时也尝试了两种方法最后才安装成功 
 
机器版本： 
 
[root@redhat1 rabbitmq]# lsb_release
LSB Version:    :base-4.0-amd64:base-4.0-noarch:core
    
                                
    • 
                                
  • FilenameUtils工具类
                                    eksliang
FilenameUtilscommon-io
                                    
    转载请出自出处：http://eksliang.iteye.com/blog/2217081 一、概述 
这是一个Java操作文件的常用库，是Apache对java的IO包的封装，这里面有两个非常核心的类FilenameUtils跟FileUtils，其中FilenameUtils是对文件名操作的封装;FileUtils是文件封装，开发中对文件的操作，几乎都可以在这个框架里面找到。 非常的好用。 
    
                                
    • 
                                
  • xml文件解析SAX
                                    不懂事的小屁孩
xml
                                    
    xml文件解析:xml文件解析有四种方式， 
1.DOM生成和解析XML文档(SAX是基于事件流的解析) 
2.SAX生成和解析XML文档(基于XML文档树结构的解析) 
3.DOM4J生成和解析XML文档 
4.JDOM生成和解析XML  
本文章用第一种方法进行解析，使用android常用的DefaultHandler 
 
 
import org.xml.sax.Attributes;

    
                                
    • 
                                
  • 通过定时任务执行mysql的定期删除和新建分区，此处是按日分区
                                    酷的飞上天空
mysql
                                    
    使用python脚本作为命令脚本，linux的定时任务来每天定时执行 
  
#!/usr/bin/python
# -*- coding: utf8 -*-
import pymysql
import datetime
import calendar

#要分区的表
table_name = 'my_table'
#连接数据库的信息
host,user,passwd,db = 
    
                                
    • 
                                
  • 如何搭建数据湖架构？听听专家的意见
                                    蓝儿唯美
架构
                                    
    Edo Interactive在几年前遇到一个大问题：公司使用交易数据来帮助零售商和餐馆进行个性化促销，但其数据仓库没有足够时间去处理所有的信用卡和借记卡交易数据 
 “我们要花费27小时来处理每日的数据量，”Edo主管基础设施和信息系统的高级副总裁Tim Garnto说道：“所以在2013年，我们放弃了现有的基于PostgreSQL的关系型数据库系统，使用了Hadoop集群作为公司的数
    
                                
    • 
                                
  • spring学习——控制反转与依赖注入
                                    a-john
spring
                                    
           控制反转（Inversion of Control，英文缩写为IoC）是一个重要的面向对象编程的法则来削减计算机程序的耦合问题，也是轻量级的Spring框架的核心。 控制反转一般分为两种类型，依赖注入（Dependency Injection，简称DI）和依赖查找（Dependency Lookup）。依赖注入应用比较广泛。 
  

    
                                
    • 
                                
  • 用spool+unixshell生成文本文件的方法
                                    aijuans
xshell
                                    
    例如我们把scott.dept表生成文本文件的语句写成dept.sql,内容如下:  
　　set pages 50000; 
　　set lines 200; 
　　set trims on; 
　　set heading off; 
　　spool /oracle_backup/log/test/dept.lst; 
　　select deptno||','||dname||','||loc 
    
                                
    • 
                                
  • 1、基础--名词解析(OOA/OOD/OOP)
                                    asia007
学习基础知识
                                    
    OOA:Object-Oriented Analysis（面向对象分析方法） 
是在一个系统的开发过程中进行了系统业务调查以后，按照面向对象的思想来分析问题。OOA与结构化分析有较大的区别。OOA所强调的是在系统调查资料的基础上，针对OO方法所需要的素材进行的归类分析和整理，而不是对管理业务现状和方法的分析。 
　　OOA（面向对象的分析）模型由5个层次（主题层、对象类层、结构层、属性层和服务层）
    
                                
    • 
                                
  • 浅谈java转成json编码格式技术
                                    百合不是茶
json编码java转成json编码
                                    
    json编码;是一个轻量级的数据存储和传输的语言 
   
   在java中需要引入json相关的包,引包方式在工程的lib下就可以了 
  
JSON与JAVA数据的转换（JSON 即 JavaScript Object Natation，它是一种轻量级的数据交换格式，非 
  
常适合于服务器与 JavaScript 之间的数据的交
    
                                
    • 
                                
  • web.xml之Spring配置(基于Spring+Struts+Ibatis)
                                    bijian1013
javaweb.xmlSSIspring配置
                                    
    指定Spring配置文件位置 
<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>
			/WEB-INF/spring-dao-bean.xml,/WEB-INF/spring-resources.xml,
			/WEB-INF/
    
                                
    • 
                                
  • Installing SonarQube（Fail to download libraries from server）
                                    sunjing
InstallSonar
                                    
    1.  Download and unzip the SonarQube distribution  
2.  Starting the Web Server 
The default port is "9000" and the context path is "/". These values can be changed in &l
    
                                
    • 
                                
  • 【MongoDB学习笔记十一】Mongo副本集基本的增删查
                                    bit1129
mongodb
                                    
    一、创建复本集 
  
假设mongod,mongo已经配置在系统路径变量上，启动三个命令行窗口，分别执行如下命令： 
  
mongod --port 27017 --dbpath  data1 --replSet rs0

mongod --port 27018 --dbpath  data2 --replSet rs0

mongod --port 27019 -
    
                                
    • 
                                
  • Anychart图表系列二之执行Flash和HTML5渲染
                                    白糖_
Flash
                                    
    今天介绍Anychart的Flash和HTML5渲染功能 
  
 
 HTML5 
 
Anychart从6.0第一个版本起，已经逐渐开始支持各种图的HTML5渲染效果了，也就是说即使你没有安装Flash插件，只要浏览器支持HTML5，也能看到Anychart的图形（不过这些是需要做一些配置的）。 
这里要提醒下大家，Anychart6.0版本对HTML5的支持还不算很成熟，目前还处于
    
                                
    • 
                                
  • Laravel版本更新异常4.2.8-> 4.2.9 Declaration of ... CompilerEngine ... should be compa
                                    bozch
laravel
                                    
    昨天在为了把laravel升级到最新的版本，突然之间就出现了如下错误： 
ErrorException thrown with message "Declaration of Illuminate\View\Engines\CompilerEngine::handleViewException() should be compatible with Illuminate\View\Eng
    
                                
    • 
                                
  • 编程之美-NIM游戏分析-石头总数为奇数时如何保证先动手者必胜
                                    bylijinnan
编程之美
                                    
    


import java.util.Arrays;
import java.util.Random;

public class Nim {

	/**编程之美 NIM游戏分析
问题：
有N块石头和两个玩家A和B，玩家A先将石头随机分成若干堆，然后按照BABA...的顺序不断轮流取石头，
能将剩下的石头一次取光的玩家获胜，每次取石头时，每个玩家只能从若干堆石头中任选一堆，
    
                                
    • 
                                
  • lunce创建索引及简单查询
                                    chengxuyuancsdn
查询创建索引lunce
                                    
    import java.io.File;
import java.io.IOException;

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Docume
    
                                
    • 
                                
  • [IT与投资]坚持独立自主的研究核心技术
                                    comsci
it
                                    
     
 
       和别人合作开发某项产品....如果互相之间的技术水平不同,那么这种合作很难进行,一般都会成为强者控制弱者的方法和手段..... 
 
 
       所以弱者,在遇到技术难题的时候,最好不要一开始就去寻求强者的帮助,因为在我们这颗星球上,生物都有一种控制其
    
                                
    • 
                                
  • flashback transaction闪回事务查询
                                    daizj
oraclesql闪回事务
                                    
       
闪回事务查询有别于闪回查询的特点有以下3个： 
 
（1）其正常工作不但需要利用撤销数据，还需要事先启用最小补充日志。 
 
（2）返回的结果不是以前的“旧”数据，而是能够将当前数据修改为以前的样子的撤销SQL（Undo SQL）语句。 
 
（3）集中地在名为flashback_transaction_query表上查询，而不是在各个表上通过“as of”或“vers
    
                                
    • 
                                
  • Java I/O之FilenameFilter类列举出指定路径下某个扩展名的文件
                                    游其是你
FilenameFilter
                                    
    这是一个FilenameFilter类用法的例子，实现的列举出“c:\\folder“路径下所有以“.jpg”扩展名的文件。        1   2   3   4   5   6   7   8   9   10   11   12   13   14   15   16   17   18   19   20   21   22   23   24   25   26   27   28  
    
                                
    • 
                                
  • C语言学习五函数，函数的前置声明以及如何在软件开发中合理的设计函数来解决实际问题
                                    dcj3sjt126com
c
                                    
    # include <stdio.h>

int f(void)		//括号中的void表示该函数不能接受数据，int表示返回的类型为int类型
{
	return 10;	//向主调函数返回10
}

void g(void)	//函数名前面的void表示该函数没有返回值
{
	//return 10;	//error 与第8行行首的void相矛盾
}

in
    
                                
    • 
                                
  • 今天在测试环境使用yum安装，遇到一个问题： Error: Cannot retrieve metalink for repository: epel. Pl
                                    dcj3sjt126com
centos
                                    
    今天在测试环境使用yum安装，遇到一个问题： 
Error: Cannot retrieve metalink for repository: epel. Please verify its path and try again 
  
处理很简单，修改文件“/etc/yum.repos.d/epel.repo”， 将baseurl的注释取消， mirrorlist注释掉。即可。 
&n
    
                                
    • 
                                
  • 单例模式
                                    shuizhaosi888
单例模式
                                    
    单例模式        懒汉式 
public class RunMain {

	/**
	 * 私有构造
	 */
	private RunMain() {
	}
	
    /**
     * 内部类，用于占位，只有
     */
	private static class SingletonRunMain {
		priv
    
                                
    • 
                                
  • Spring Security（09）——Filter
                                    234390216
Spring Security
                                    
    Filter 
目录 
1.1     Filter顺序 
1.2     添加Filter到FilterChain 
1.3     DelegatingFilterProxy 
1.4     FilterChainProxy 
1.5
    
                                
    • 
                                
  • 公司项目NODEJS实践0.1
                                    逐行分析JS源代码
mongodbnginxubuntunodejs
                                    
      
一、前言 
        前端如何独立用nodeJs实现一个简单的注册、登录功能，是不是只用nodejs+sql就可以了？其实是可以实现，但离实际应用还有距离，那要怎么做才是实际可用的。 
        网上有很多nod
    
                                
    • 
                                
  • java.lang.Math
                                    liuhaibo_ljf
javaMathlang
                                    
    System.out.println(Math.PI); 
System.out.println(Math.abs(1.2)); 
System.out.println(Math.abs(1.2)); 
System.out.println(Math.abs(1)); 
System.out.println(Math.abs(111111111)); 
System.out.println(Mat
    
                                
    • 
                                
  • linux下时间同步
                                    nonobaba
ntp
                                    
    今天在linux下做hbase集群的时候，发现hmaster启动成功了，但是用hbase命令进入shell的时候报了一个错误  PleaseHoldException: Master is initializing，查看了日志，大致意思是说master和slave时间不同步，没办法，只好找一种手动同步一下，后来发现一共部署了10来台机器，手动同步偏差又比较大，所以还是从网上找现成的解决方
    
                                
    • 
                                
  • ZooKeeper3.4.6的集群部署
                                    roadrunners
zookeeper集群部署
                                    
    ZooKeeper是Apache的一个开源项目，在分布式服务中应用比较广泛。它主要用来解决分布式应用中经常遇到的一些数据管理问题，如：统一命名服务、状态同步、集群管理、配置文件管理、同步锁、队列等。这里主要讲集群中ZooKeeper的部署。 
  
1、准备工作 
我们准备3台机器做ZooKeeper集群，分别在3台机器上创建ZooKeeper需要的目录。 
  
数据存储目录
    
                                
    • 
                                
  • Java高效读取大文件
                                    tomcat_oracle
java
                                    
    　　读取文件行的标准方式是在内存中读取，Guava 和Apache Commons IO都提供了如下所示快速读取文件行的方法：   　　Files.readLines(new File(path), Charsets.UTF_8);   　　FileUtils.readLines(new File(path));   　　这种方法带来的问题是文件的所有行都被存放在内存中，当文件足够大时很快就会导致
    
                                
    • 
                                
  • 微信支付api返回的xml转换为Map的方法
                                    xu3508620
xmlmap微信api
                                    
    举例如下： 
<xml> 
   <return_code><![CDATA[SUCCESS]]></return_code> 
   <return_msg><![CDATA[OK]]></return_msg> 
   <appid><
    
                                
    •