flink常用基本算子

flink中常用的基本转换算子有：map，flatmap，filter等算子。其用法为：

1.map算子

        map算子是一一对应的映射关系算子，将一条数据转化为另一条数据。

        1.1数据准备

               首先定义一个实体类Event。

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.sql.Timestamp;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Event {
    public String user;
    public String url;
    public Long timestamp;

    @Override
    public String toString() {
        return "Event{" +
                "user='" + user + '\'' +
                ", url='" + url + '\'' +
                ", timestamp='" + new Timestamp(timestamp) + '\'' +
                '}';
    }
}

1.2.map算子基本用法

import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;

public class TransformMapTest {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
        DataStreamSource<Event> stream = env.fromElements(new Event("zhangsan", "./home", 1000L),
                new Event("lisi", ".fav", 2000L));
        SingleOutputStreamOperator<String> result = stream.map(new myMap());
        SingleOutputStreamOperator<String> result2 = stream.map(new MapFunction<Event, String>() {
            @Override
            public String map(Event event) throws Exception {
                return event.user;
            }
        });
        result.print("1");
        result2.print("2");
        env.execute();
    }
    public static class myMap implements MapFunction<Event,String>{

        @Override
        public String map(Event event) throws Exception {
            return event.user;
        }
    }
}


// 结果为：

1> zhangsan
2> zhangsan
1> lisi
2> lisi

2.flatmap算子

flatmap算子就是将数据进行一个拆散的扁平化处理

import org.apache.flink.api.common.functions.FlatMapFunction;
import org.apache.flink.api.common.typeinfo.TypeHint;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.util.Collector;

public class TransformFlatMapTest {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
        DataStreamSource<Event> stream = env.fromElements(new Event("zhangsan", "./home", 1000L),
                new Event("lisi", ".fav", 2000L));

        stream.flatMap(new myFlatMap()).print("1");
        stream.flatMap(new FlatMapFunction<Event, String>() {
            @Override
            public void flatMap(Event event, Collector<String> collector) throws Exception {
                collector.collect(event.user);
                collector.collect(event.timestamp.toString());
            }
        }).print("2");
        stream.flatMap( (Event event,Collector<String> out)->out.collect(event.user) ).
                returns(new TypeHint<String>() {}).print("3");
        env.execute();
    }
    public static class myFlatMap implements FlatMapFunction<Event,String>{
        @Override
        public void flatMap(Event event, Collector<String> clt) throws Exception {
            clt.collect(event.user);
            clt.collect(event.url);
            clt.collect(event.timestamp.toString());
        }
    }
}

//结果为
1> zhangsan
1> ./home
1> 1000
2> zhangsan
2> 1000
3> zhangsan
1> lisi
1> .fav
1> 2000
2> lisi
2> 2000
3> lisi

3.filter算子

filter算子是过滤数据，将符合条件的数据进行输出

import org.apache.flink.api.common.functions.FilterFunction;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;

public class TransformFilterTest {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
        DataStreamSource<Event> stream = env.fromElements(new Event("zhangsan", "./home", 1000L),
                new Event("lisi", ".fav", 2000L));
        SingleOutputStreamOperator<Event> result = stream.filter(new FilterFunction<Event>() {
            @Override
            public boolean filter(Event event) throws Exception {
                return event.user.equals("zhangsan");
            }
        });
        result.print("1");
        SingleOutputStreamOperator<Event> stream2 = stream.filter(new myFilter());
        stream2.print("2");
        stream.filter(data-> data.user.equals("zhangsan")).print();
        env.execute();
    }

    public static class myFilter implements FilterFunction<Event>{

        @Override
        public boolean filter(Event event) throws Exception {
            return event.user.equals("zhangsan");
        }
    }
}
//结果为
1> Event{user='zhangsan', url='./home', timestamp='1970-01-01 08:00:01.0'}
2> Event{user='zhangsan', url='./home', timestamp='1970-01-01 08:00:01.0'}
Event{user='zhangsan', url='./home', timestamp='1970-01-01 08:00:01.0'}