StreamExecutionEnvironment (flink 1.5-SNAPSHOT API)

java.lang.Object
- org.apache.flink.streaming.api.environment.StreamExecutionEnvironment

Direct Known Subclasses:

LocalStreamEnvironment, RemoteStreamEnvironment, StreamContextEnvironment, StreamPlanEnvironment, TestStreamEnvironment
```
@Public
public abstract class StreamExecutionEnvironment
extends Object
```
The StreamExecutionEnvironment is the context in which a streaming program is executed. A LocalStreamEnvironment will cause execution in the current JVM, a RemoteStreamEnvironment will cause execution on a remote setup.
The environment provides methods to control the job execution (such as setting the parallelism or the fault tolerance/checkpointing parameters) and to interact with the outside world (data access).

See Also:

LocalStreamEnvironment, RemoteStreamEnvironment

Field Summary

Fields
Modifier and Type	Field and Description
`protected List<Tuple2<String,DistributedCache.DistributedCacheEntry>>`	`cacheFile`
`static String`	`DEFAULT_JOB_NAME` The default name to use for a streaming job if no other name has been specified.
`protected boolean`	`isChainingEnabled`
`protected List<StreamTransformation<?>>`	`transformations`

Constructor Summary

Constructors
Constructor and Description

StreamExecutionEnvironment()

Constructors
Constructor and Description
`StreamExecutionEnvironment()`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`void`	`addDefaultKryoSerializer(Class<?> type, Class<? extends com.esotericsoftware.kryo.Serializer<?>> serializerClass)` Adds a new Kryo default serializer to the Runtime.
`<T extends com.esotericsoftware.kryo.Serializer<?> & Serializable> void`	`addDefaultKryoSerializer(Class<?> type, T serializer)` Adds a new Kryo default serializer to the Runtime.
`void`	`addOperator(StreamTransformation<?> transformation)` Adds an operator to the list of operators that should be executed when calling `execute()`.
`<OUT> DataStreamSource<OUT>`	`addSource(SourceFunction<OUT> function)` Adds a Data Source to the streaming topology.
`<OUT> DataStreamSource<OUT>`	`addSource(SourceFunction<OUT> function, String sourceName)` Ads a data source with a custom type information thus opening a `DataStream`.
`<OUT> DataStreamSource<OUT>`	`addSource(SourceFunction<OUT> function, String sourceName, TypeInformation<OUT> typeInfo)` Ads a data source with a custom type information thus opening a `DataStream`.
`<OUT> DataStreamSource<OUT>`	`addSource(SourceFunction<OUT> function, TypeInformation<OUT> typeInfo)` Ads a data source with a custom type information thus opening a `DataStream`.
`<F> F`	`clean(F f)` Returns a "closure-cleaned" version of the given function.
`<OUT> DataStreamSource<OUT>`	`createInput(InputFormat<OUT,?> inputFormat)` Generic method to create an input data stream with `InputFormat`.
`<OUT> DataStreamSource<OUT>`	`createInput(InputFormat<OUT,?> inputFormat, TypeInformation<OUT> typeInfo)` Generic method to create an input data stream with `InputFormat`.
`static LocalStreamEnvironment`	`createLocalEnvironment()` Creates a `LocalStreamEnvironment`.
`static LocalStreamEnvironment`	`createLocalEnvironment(int parallelism)` Creates a `LocalStreamEnvironment`.
`static LocalStreamEnvironment`	`createLocalEnvironment(int parallelism, Configuration configuration)` Creates a `LocalStreamEnvironment`.
`static StreamExecutionEnvironment`	`createLocalEnvironmentWithWebUI(Configuration conf)` Creates a `LocalStreamEnvironment` for local program execution that also starts the web monitoring UI.
`static StreamExecutionEnvironment`	`createRemoteEnvironment(String host, int port, Configuration clientConfig, String... jarFiles)` Creates a `RemoteStreamEnvironment`.
`static StreamExecutionEnvironment`	`createRemoteEnvironment(String host, int port, int parallelism, String... jarFiles)` Creates a `RemoteStreamEnvironment`.
`static StreamExecutionEnvironment`	`createRemoteEnvironment(String host, int port, String... jarFiles)` Creates a `RemoteStreamEnvironment`.
`StreamExecutionEnvironment`	`disableOperatorChaining()` Disables operator chaining for streaming operators.
`StreamExecutionEnvironment`	`enableCheckpointing()` Deprecated. Use `enableCheckpointing(long)` instead.
`StreamExecutionEnvironment`	`enableCheckpointing(long interval)` Enables checkpointing for the streaming job.
`StreamExecutionEnvironment`	`enableCheckpointing(long interval, CheckpointingMode mode)` Enables checkpointing for the streaming job.
`StreamExecutionEnvironment`	`enableCheckpointing(long interval, CheckpointingMode mode, boolean force)` Deprecated. Use `enableCheckpointing(long, CheckpointingMode)` instead. Forcing checkpoints will be removed in the future.
`JobExecutionResult`	`execute()` Triggers the program execution.
`abstract JobExecutionResult`	`execute(String jobName)` Triggers the program execution.
`<OUT> DataStreamSource<OUT>`	`fromCollection(Collection<OUT> data)` Creates a data stream from the given non-empty collection.
`<OUT> DataStreamSource<OUT>`	`fromCollection(Collection<OUT> data, TypeInformation<OUT> typeInfo)` Creates a data stream from the given non-empty collection.
`<OUT> DataStreamSource<OUT>`	`fromCollection(Iterator<OUT> data, Class<OUT> type)` Creates a data stream from the given iterator.
`<OUT> DataStreamSource<OUT>`	`fromCollection(Iterator<OUT> data, TypeInformation<OUT> typeInfo)` Creates a data stream from the given iterator.
`<OUT> DataStreamSource<OUT>`	`fromElements(Class<OUT> type, OUT... data)` Creates a new data set that contains the given elements.
`<OUT> DataStreamSource<OUT>`	`fromElements(OUT... data)` Creates a new data stream that contains the given elements.
`<OUT> DataStreamSource<OUT>`	`fromParallelCollection(SplittableIterator<OUT> iterator, Class<OUT> type)` Creates a new data stream that contains elements in the iterator.
`<OUT> DataStreamSource<OUT>`	`fromParallelCollection(SplittableIterator<OUT> iterator, TypeInformation<OUT> typeInfo)` Creates a new data stream that contains elements in the iterator.
`DataStreamSource<Long>`	`generateSequence(long from, long to)` Creates a new data stream that contains a sequence of numbers.
`long`	`getBufferTimeout()` Gets the maximum time frequency (milliseconds) for the flushing of the output buffers.
`List<Tuple2<String,DistributedCache.DistributedCacheEntry>>`	`getCachedFiles()` Get the list of cached files that were registered for distribution among the task managers.
`CheckpointConfig`	`getCheckpointConfig()` Gets the checkpoint config, which defines values like checkpoint interval, delay between checkpoints, etc.
`CheckpointingMode`	`getCheckpointingMode()` Returns the checkpointing mode (exactly-once vs.
`long`	`getCheckpointInterval()` Returns the checkpointing interval or -1 if checkpointing is disabled.
`ExecutionConfig`	`getConfig()` Gets the config object.
`static int`	`getDefaultLocalParallelism()` Gets the default parallelism that will be used for the local execution environment created by `createLocalEnvironment()`.
`static StreamExecutionEnvironment`	`getExecutionEnvironment()` Creates an execution environment that represents the context in which the program is currently executed.
`String`	`getExecutionPlan()` Creates the plan with which the system will execute the program, and returns it as a String using a JSON representation of the execution data flow graph.
`int`	`getMaxParallelism()` Gets the maximum degree of parallelism defined for the program.
`int`	`getNumberOfExecutionRetries()` Deprecated. This method will be replaced by `getRestartStrategy()`.
`int`	`getParallelism()` Gets the parallelism with which operation are executed by default.
`RestartStrategies.RestartStrategyConfiguration`	`getRestartStrategy()` Returns the specified restart strategy configuration.
`StateBackend`	`getStateBackend()` Gets the state backend that defines how to store and checkpoint state.
`StreamGraph`	`getStreamGraph()` Getter of the `StreamGraph` of the streaming job.
`TimeCharacteristic`	`getStreamTimeCharacteristic()` Gets the time characteristic.
`protected static void`	`initializeContextEnvironment(StreamExecutionEnvironmentFactory ctx)`
`boolean`	`isChainingEnabled()` Returns whether operator chaining is enabled.
`boolean`	`isForceCheckpointing()` Deprecated. Forcing checkpoints will be removed in future version.
`<OUT> DataStreamSource<OUT>`	`readFile(FileInputFormat<OUT> inputFormat, String filePath)` Reads the contents of the user-specified `filePath` based on the given `FileInputFormat`.
`<OUT> DataStreamSource<OUT>`	`readFile(FileInputFormat<OUT> inputFormat, String filePath, FileProcessingMode watchType, long interval)` Reads the contents of the user-specified `filePath` based on the given `FileInputFormat`.
`<OUT> DataStreamSource<OUT>`	`readFile(FileInputFormat<OUT> inputFormat, String filePath, FileProcessingMode watchType, long interval, FilePathFilter filter)` Deprecated. Use `FileInputFormat.setFilesFilter(FilePathFilter)` to set a filter and `readFile(FileInputFormat, String, FileProcessingMode, long)`
`<OUT> DataStreamSource<OUT>`	`readFile(FileInputFormat<OUT> inputFormat, String filePath, FileProcessingMode watchType, long interval, TypeInformation<OUT> typeInformation)` Reads the contents of the user-specified `filePath` based on the given `FileInputFormat`.
`DataStream<String>`	`readFileStream(String filePath, long intervalMillis, FileMonitoringFunction.WatchType watchType)` Deprecated. Use `readFile(FileInputFormat, String, FileProcessingMode, long)` instead.
`DataStreamSource<String>`	`readTextFile(String filePath)` Reads the given file line-by-line and creates a data stream that contains a string with the contents of each such line.
`DataStreamSource<String>`	`readTextFile(String filePath, String charsetName)` Reads the given file line-by-line and creates a data stream that contains a string with the contents of each such line.
`void`	`registerCachedFile(String filePath, String name)` Registers a file at the distributed cache under the given name.
`void`	`registerCachedFile(String filePath, String name, boolean executable)` Registers a file at the distributed cache under the given name.
`void`	`registerType(Class<?> type)` Registers the given type with the serialization stack.
`void`	`registerTypeWithKryoSerializer(Class<?> type, Class<? extends com.esotericsoftware.kryo.Serializer> serializerClass)` Registers the given Serializer via its class as a serializer for the given type at the KryoSerializer.
`<T extends com.esotericsoftware.kryo.Serializer<?> & Serializable> void`	`registerTypeWithKryoSerializer(Class<?> type, T serializer)` Registers the given type with a Kryo Serializer.
`protected static void`	`resetContextEnvironment()`
`StreamExecutionEnvironment`	`setBufferTimeout(long timeoutMillis)` Sets the maximum time frequency (milliseconds) for the flushing of the output buffers.
`static void`	`setDefaultLocalParallelism(int parallelism)` Sets the default parallelism that will be used for the local execution environment created by `createLocalEnvironment()`.
`StreamExecutionEnvironment`	`setMaxParallelism(int maxParallelism)` Sets the maximum degree of parallelism defined for the program.
`void`	`setNumberOfExecutionRetries(int numberOfExecutionRetries)` Deprecated. This method will be replaced by `setRestartStrategy(org.apache.flink.api.common.restartstrategy.RestartStrategies.RestartStrategyConfiguration)`. The `RestartStrategies.fixedDelayRestart(int, Time)` contains the number of execution retries.
`StreamExecutionEnvironment`	`setParallelism(int parallelism)` Sets the parallelism for operations executed through this environment.
`void`	`setRestartStrategy(RestartStrategies.RestartStrategyConfiguration restartStrategyConfiguration)` Sets the restart strategy configuration.
`StreamExecutionEnvironment`	`setStateBackend(AbstractStateBackend backend)` Deprecated. Use `setStateBackend(StateBackend)` instead.
`StreamExecutionEnvironment`	`setStateBackend(StateBackend backend)` Sets the state backend that describes how to store and checkpoint operator state.
`void`	`setStreamTimeCharacteristic(TimeCharacteristic characteristic)` Sets the time characteristic for all streams create from this environment, e.g., processing time, event time, or ingestion time.
`DataStreamSource<String>`	`socketTextStream(String hostname, int port)` Creates a new data stream that contains the strings received infinitely from a socket.
`DataStreamSource<String>`	`socketTextStream(String hostname, int port, char delimiter)` Deprecated. Use `socketTextStream(String, int, String)` instead.
`DataStreamSource<String>`	`socketTextStream(String hostname, int port, char delimiter, long maxRetry)` Deprecated. Use `socketTextStream(String, int, String, long)` instead.
`DataStreamSource<String>`	`socketTextStream(String hostname, int port, String delimiter)` Creates a new data stream that contains the strings received infinitely from a socket.
`DataStreamSource<String>`	`socketTextStream(String hostname, int port, String delimiter, long maxRetry)` Creates a new data stream that contains the strings received infinitely from a socket.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - DEFAULT_JOB_NAME
```
public static final String DEFAULT_JOB_NAME
```
    The default name to use for a streaming job if no other name has been specified.
    
    See Also:
    
    Constant Field Values
  - transformations
```
protected final List<StreamTransformation<?>> transformations
```
  - isChainingEnabled
```
protected boolean isChainingEnabled
```
  - cacheFile
```
protected final List<Tuple2<String,DistributedCache.DistributedCacheEntry>> cacheFile
```
- Constructor Detail
  - StreamExecutionEnvironment
```
public StreamExecutionEnvironment()
```
- Method Detail
  - getConfig
```
public ExecutionConfig getConfig()
```
    Gets the config object.
  - getCachedFiles
```
public List<Tuple2<String,DistributedCache.DistributedCacheEntry>> getCachedFiles()
```
    Get the list of cached files that were registered for distribution among the task managers.
  - setParallelism
```
public StreamExecutionEnvironment setParallelism(int parallelism)
```
    Sets the parallelism for operations executed through this environment. Setting a parallelism of x here will cause all operators (such as map, batchReduce) to run with x parallel instances. This method overrides the default parallelism for this environment. The LocalStreamEnvironment uses by default a value equal to the number of hardware contexts (CPU cores / threads). When executing the program via the command line client from a JAR file, the default degree of parallelism is the one configured for that setup.
    
    Parameters:
    
    parallelism - The parallelism
  - setMaxParallelism
```
public StreamExecutionEnvironment setMaxParallelism(int maxParallelism)
```
    Sets the maximum degree of parallelism defined for the program. The upper limit (inclusive) is Short.MAX_VALUE.
    The maximum degree of parallelism specifies the upper limit for dynamic scaling. It also defines the number of key groups used for partitioned state.
    
    Parameters:
    
    maxParallelism - Maximum degree of parallelism to be used for the program., with 0 < maxParallelism <= 2^15 - 1
  - getParallelism
```
public int getParallelism()
```
    Gets the parallelism with which operation are executed by default. Operations can individually override this value to use a specific parallelism.
    
    Returns:
    
    The parallelism used by operations, unless they override that value.
  - getMaxParallelism
```
public int getMaxParallelism()
```
    Gets the maximum degree of parallelism defined for the program.
    The maximum degree of parallelism specifies the upper limit for dynamic scaling. It also defines the number of key groups used for partitioned state.
    
    Returns:
    
    Maximum degree of parallelism
  - setBufferTimeout
```
public StreamExecutionEnvironment setBufferTimeout(long timeoutMillis)
```
    Sets the maximum time frequency (milliseconds) for the flushing of the output buffers. By default the output buffers flush frequently to provide low latency and to aid smooth developer experience. Setting the parameter can result in three logical modes:
    - A positive integer triggers flushing periodically by that integer
    - 0 triggers flushing after every record thus minimizing latency
    - -1 triggers flushing only when the output buffer is full thus maximizing throughput
    Parameters:
    
    timeoutMillis - The maximum time between two output flushes.
  - getBufferTimeout
```
public long getBufferTimeout()
```
    Gets the maximum time frequency (milliseconds) for the flushing of the output buffers. For clarification on the extremal values see setBufferTimeout(long).
    
    Returns:
    
    The timeout of the buffer.
  - disableOperatorChaining
```
@PublicEvolving
public StreamExecutionEnvironment disableOperatorChaining()
```
    Disables operator chaining for streaming operators. Operator chaining allows non-shuffle operations to be co-located in the same thread fully avoiding serialization and de-serialization.
    
    Returns:
    
    StreamExecutionEnvironment with chaining disabled.
  - isChainingEnabled
```
@PublicEvolving
public boolean isChainingEnabled()
```
    Returns whether operator chaining is enabled.
    
    Returns:
    
    true if chaining is enabled, false otherwise.
  - getCheckpointConfig
```
public CheckpointConfig getCheckpointConfig()
```
    Gets the checkpoint config, which defines values like checkpoint interval, delay between checkpoints, etc.
    
    Returns:
    
    The checkpoint config.
  - enableCheckpointing
```
public StreamExecutionEnvironment enableCheckpointing(long interval)
```
    Enables checkpointing for the streaming job. The distributed state of the streaming dataflow will be periodically snapshotted. In case of a failure, the streaming dataflow will be restarted from the latest completed checkpoint. This method selects CheckpointingMode.EXACTLY_ONCE guarantees.
    The job draws checkpoints periodically, in the given interval. The state will be stored in the configured state backend.
    NOTE: Checkpointing iterative streaming dataflows in not properly supported at the moment. For that reason, iterative jobs will not be started if used with enabled checkpointing. To override this mechanism, use the enableCheckpointing(long, CheckpointingMode, boolean) method.
    
    Parameters:
    
    interval - Time interval between state checkpoints in milliseconds.
  - enableCheckpointing
```
public StreamExecutionEnvironment enableCheckpointing(long interval,
                                                      CheckpointingMode mode)
```
    Enables checkpointing for the streaming job. The distributed state of the streaming dataflow will be periodically snapshotted. In case of a failure, the streaming dataflow will be restarted from the latest completed checkpoint.
    The job draws checkpoints periodically, in the given interval. The system uses the given CheckpointingMode for the checkpointing ("exactly once" vs "at least once"). The state will be stored in the configured state backend.
    NOTE: Checkpointing iterative streaming dataflows in not properly supported at the moment. For that reason, iterative jobs will not be started if used with enabled checkpointing. To override this mechanism, use the enableCheckpointing(long, CheckpointingMode, boolean) method.
    
    Parameters:
    
    interval - Time interval between state checkpoints in milliseconds.
    
    mode - The checkpointing mode, selecting between "exactly once" and "at least once" guaranteed.
  - enableCheckpointing
```
@Deprecated
 @PublicEvolving
public StreamExecutionEnvironment enableCheckpointing(long interval,
                                                                                   CheckpointingMode mode,
                                                                                   boolean force)
```
    Deprecated. Use enableCheckpointing(long, CheckpointingMode) instead. Forcing checkpoints will be removed in the future.
    
    Enables checkpointing for the streaming job. The distributed state of the streaming dataflow will be periodically snapshotted. In case of a failure, the streaming dataflow will be restarted from the latest completed checkpoint.
    The job draws checkpoints periodically, in the given interval. The state will be stored in the configured state backend.
    NOTE: Checkpointing iterative streaming dataflows in not properly supported at the moment. If the "force" parameter is set to true, the system will execute the job nonetheless.
    
    Parameters:
    
    interval - Time interval between state checkpoints in millis.
    
    mode - The checkpointing mode, selecting between "exactly once" and "at least once" guaranteed.
    
    force - If true checkpointing will be enabled for iterative jobs as well.
  - enableCheckpointing
```
@Deprecated
 @PublicEvolving
public StreamExecutionEnvironment enableCheckpointing()
```
    Deprecated. Use enableCheckpointing(long) instead.
    
    Enables checkpointing for the streaming job. The distributed state of the streaming dataflow will be periodically snapshotted. In case of a failure, the streaming dataflow will be restarted from the latest completed checkpoint. This method selects CheckpointingMode.EXACTLY_ONCE guarantees.
    The job draws checkpoints periodically, in the default interval. The state will be stored in the configured state backend.
    NOTE: Checkpointing iterative streaming dataflows in not properly supported at the moment. For that reason, iterative jobs will not be started if used with enabled checkpointing. To override this mechanism, use the enableCheckpointing(long, CheckpointingMode, boolean) method.
  - getCheckpointInterval
```
public long getCheckpointInterval()
```
    Returns the checkpointing interval or -1 if checkpointing is disabled.
    Shorthand for getCheckpointConfig().getCheckpointInterval().
    
    Returns:
    
    The checkpointing interval or -1
  - isForceCheckpointing
```
@Deprecated
 @PublicEvolving
public boolean isForceCheckpointing()
```
    Deprecated. Forcing checkpoints will be removed in future version.
    
    Returns whether checkpointing is force-enabled.
  - getCheckpointingMode
```
public CheckpointingMode getCheckpointingMode()
```
    Returns the checkpointing mode (exactly-once vs. at-least-once).
    Shorthand for getCheckpointConfig().getCheckpointingMode().
    
    Returns:
    
    The checkpoint mode
  - setStateBackend
```
@PublicEvolving
public StreamExecutionEnvironment setStateBackend(StateBackend backend)
```
    Sets the state backend that describes how to store and checkpoint operator state. It defines both which data structures hold state during execution (for example hash tables, RockDB, or other data stores) as well as where checkpointed data will be persisted.
    State managed by the state backend includes both keyed state that is accessible on keyed streams, as well as state maintained directly by the user code that implements CheckpointedFunction.
    The MemoryStateBackend for example maintains the state in heap memory, as objects. It is lightweight without extra dependencies, but can checkpoint only small states (some counters).
    In contrast, the FsStateBackend stores checkpoints of the state (also maintained as heap objects) in files. When using a replicated file system (like HDFS, S3, MapR FS, Tachyon, etc) this will guarantee that state is not lost upon failures of individual nodes and that streaming program can be executed highly available and strongly consistent (assuming that Flink is run in high-availability mode).
    
    Returns:
    
    This StreamExecutionEnvironment itself, to allow chaining of function calls.
    
    See Also:
    
    getStateBackend()
  - setStateBackend
```
@Deprecated
 @PublicEvolving
public StreamExecutionEnvironment setStateBackend(AbstractStateBackend backend)
```
    Deprecated. Use setStateBackend(StateBackend) instead.
  - getStateBackend
```
@PublicEvolving
public StateBackend getStateBackend()
```
    Gets the state backend that defines how to store and checkpoint state.
    
    See Also:
    
    setStateBackend(StateBackend)
  - setRestartStrategy
```
@PublicEvolving
public void setRestartStrategy(RestartStrategies.RestartStrategyConfiguration restartStrategyConfiguration)
```
    Sets the restart strategy configuration. The configuration specifies which restart strategy will be used for the execution graph in case of a restart.
    
    Parameters:
    
    restartStrategyConfiguration - Restart strategy configuration to be set
  - getRestartStrategy
```
@PublicEvolving
public RestartStrategies.RestartStrategyConfiguration getRestartStrategy()
```
    Returns the specified restart strategy configuration.
    
    Returns:
    
    The restart strategy configuration to be used
  - setNumberOfExecutionRetries
```
@Deprecated
 @PublicEvolving
public void setNumberOfExecutionRetries(int numberOfExecutionRetries)
```
    Deprecated. This method will be replaced by setRestartStrategy(org.apache.flink.api.common.restartstrategy.RestartStrategies.RestartStrategyConfiguration). The RestartStrategies.fixedDelayRestart(int, Time) contains the number of execution retries.
    
    Sets the number of times that failed tasks are re-executed. A value of zero effectively disables fault tolerance. A value of -1 indicates that the system default value (as defined in the configuration) should be used.
    
    Parameters:
    
    numberOfExecutionRetries - The number of times the system will try to re-execute failed tasks.
  - getNumberOfExecutionRetries
```
@Deprecated
 @PublicEvolving
public int getNumberOfExecutionRetries()
```
    Deprecated. This method will be replaced by getRestartStrategy().
    
    Gets the number of times the system will try to re-execute failed tasks. A value of -1 indicates that the system default value (as defined in the configuration) should be used.
    
    Returns:
    
    The number of times the system will try to re-execute failed tasks.
  - addDefaultKryoSerializer
```
public <T extends com.esotericsoftware.kryo.Serializer<?> & Serializable> void addDefaultKryoSerializer(Class<?> type,
                                                                                                        T serializer)
```
    Adds a new Kryo default serializer to the Runtime.
    Note that the serializer instance must be serializable (as defined by java.io.Serializable), because it may be distributed to the worker nodes by java serialization.
    
    Parameters:
    
    type - The class of the types serialized with the given serializer.
    
    serializer - The serializer to use.
  - addDefaultKryoSerializer
```
public void addDefaultKryoSerializer(Class<?> type,
                                     Class<? extends com.esotericsoftware.kryo.Serializer<?>> serializerClass)
```
    Adds a new Kryo default serializer to the Runtime.
    
    Parameters:
    
    type - The class of the types serialized with the given serializer.
    
    serializerClass - The class of the serializer to use.
  - registerTypeWithKryoSerializer
```
public <T extends com.esotericsoftware.kryo.Serializer<?> & Serializable> void registerTypeWithKryoSerializer(Class<?> type,
                                                                                                              T serializer)
```
    Registers the given type with a Kryo Serializer.
    Note that the serializer instance must be serializable (as defined by java.io.Serializable), because it may be distributed to the worker nodes by java serialization.
    
    Parameters:
    
    type - The class of the types serialized with the given serializer.
    
    serializer - The serializer to use.
  - registerTypeWithKryoSerializer
```
public void registerTypeWithKryoSerializer(Class<?> type,
                                           Class<? extends com.esotericsoftware.kryo.Serializer> serializerClass)
```
    Registers the given Serializer via its class as a serializer for the given type at the KryoSerializer.
    
    Parameters:
    
    type - The class of the types serialized with the given serializer.
    
    serializerClass - The class of the serializer to use.
  - registerType
```
public void registerType(Class<?> type)
```
    Registers the given type with the serialization stack. If the type is eventually serialized as a POJO, then the type is registered with the POJO serializer. If the type ends up being serialized with Kryo, then it will be registered at Kryo to make sure that only tags are written.
    
    Parameters:
    
    type - The class of the type to register.
  - setStreamTimeCharacteristic
```
@PublicEvolving
public void setStreamTimeCharacteristic(TimeCharacteristic characteristic)
```
    Sets the time characteristic for all streams create from this environment, e.g., processing time, event time, or ingestion time.
    If you set the characteristic to IngestionTime of EventTime this will set a default watermark update interval of 200 ms. If this is not applicable for your application you should change it using ExecutionConfig.setAutoWatermarkInterval(long).
    
    Parameters:
    
    characteristic - The time characteristic.
  - getStreamTimeCharacteristic
```
@PublicEvolving
public TimeCharacteristic getStreamTimeCharacteristic()
```
    Gets the time characteristic.
    
    Returns:
    
    The time characteristic.
    
    See Also:
    
    setStreamTimeCharacteristic(org.apache.flink.streaming.api.TimeCharacteristic)
  - generateSequence
```
public DataStreamSource<Long> generateSequence(long from,
                                               long to)
```
    Creates a new data stream that contains a sequence of numbers. This is a parallel source, if you manually set the parallelism to 1 (using SingleOutputStreamOperator.setParallelism(int)) the generated sequence of elements is in order.
    
    Parameters:
    
    from - The number to start at (inclusive)
    
    to - The number to stop at (inclusive)
    
    Returns:
    
    A data stream, containing all number in the [from, to] interval
  - fromElements
```
@SafeVarargs
public final <OUT> DataStreamSource<OUT> fromElements(OUT... data)
```
    Creates a new data stream that contains the given elements. The elements must all be of the same type, for example, all of the String or Integer.
    The framework will try and determine the exact type from the elements. In case of generic elements, it may be necessary to manually supply the type information via fromCollection(java.util.Collection, org.apache.flink.api.common.typeinfo.TypeInformation).
    Note that this operation will result in a non-parallel data stream source, i.e. a data stream source with a degree of parallelism one.
    
    Type Parameters:
    
    OUT - The type of the returned data stream
    
    Parameters:
    
    data - The array of elements to create the data stream from.
    
    Returns:
    
    The data stream representing the given array of elements
  - fromElements
```
@SafeVarargs
public final <OUT> DataStreamSource<OUT> fromElements(Class<OUT> type,
                                                                   OUT... data)
```
    Creates a new data set that contains the given elements. The framework will determine the type according to the based type user supplied. The elements should be the same or be the subclass to the based type. The sequence of elements must not be empty. Note that this operation will result in a non-parallel data stream source, i.e. a data stream source with a degree of parallelism one.
    
    Type Parameters:
    
    OUT - The type of the returned data stream
    
    Parameters:
    
    type - The based class type in the collection.
    
    data - The array of elements to create the data stream from.
    
    Returns:
    
    The data stream representing the given array of elements
  - fromCollection
```
public <OUT> DataStreamSource<OUT> fromCollection(Collection<OUT> data)
```
    Creates a data stream from the given non-empty collection. The type of the data stream is that of the elements in the collection.
    The framework will try and determine the exact type from the collection elements. In case of generic elements, it may be necessary to manually supply the type information via fromCollection(java.util.Collection, org.apache.flink.api.common.typeinfo.TypeInformation).
    Note that this operation will result in a non-parallel data stream source, i.e. a data stream source with parallelism one.
    
    Type Parameters:
    
    OUT - The generic type of the returned data stream.
    
    Parameters:
    
    data - The collection of elements to create the data stream from.
    
    Returns:
    
    The data stream representing the given collection
  - fromCollection
```
public <OUT> DataStreamSource<OUT> fromCollection(Collection<OUT> data,
                                                  TypeInformation<OUT> typeInfo)
```
    Creates a data stream from the given non-empty collection.
    Note that this operation will result in a non-parallel data stream source, i.e., a data stream source with parallelism one.
    
    Type Parameters:
    
    OUT - The type of the returned data stream
    
    Parameters:
    
    data - The collection of elements to create the data stream from
    
    typeInfo - The TypeInformation for the produced data stream
    
    Returns:
    
    The data stream representing the given collection
  - fromCollection
```
public <OUT> DataStreamSource<OUT> fromCollection(Iterator<OUT> data,
                                                  Class<OUT> type)
```
    Creates a data stream from the given iterator.
    Because the iterator will remain unmodified until the actual execution happens, the type of data returned by the iterator must be given explicitly in the form of the type class (this is due to the fact that the Java compiler erases the generic type information).
    Note that this operation will result in a non-parallel data stream source, i.e., a data stream source with a parallelism of one.
    
    Type Parameters:
    
    OUT - The type of the returned data stream
    
    Parameters:
    
    data - The iterator of elements to create the data stream from
    
    type - The class of the data produced by the iterator. Must not be a generic class.
    
    Returns:
    
    The data stream representing the elements in the iterator
    
    See Also:
    
    fromCollection(java.util.Iterator, org.apache.flink.api.common.typeinfo.TypeInformation)
  - fromCollection
```
public <OUT> DataStreamSource<OUT> fromCollection(Iterator<OUT> data,
                                                  TypeInformation<OUT> typeInfo)
```
    Creates a data stream from the given iterator.
    Because the iterator will remain unmodified until the actual execution happens, the type of data returned by the iterator must be given explicitly in the form of the type information. This method is useful for cases where the type is generic. In that case, the type class (as given in fromCollection(java.util.Iterator, Class) does not supply all type information.
    Note that this operation will result in a non-parallel data stream source, i.e., a data stream source with parallelism one.
    
    Type Parameters:
    
    OUT - The type of the returned data stream
    
    Parameters:
    
    data - The iterator of elements to create the data stream from
    
    typeInfo - The TypeInformation for the produced data stream
    
    Returns:
    
    The data stream representing the elements in the iterator
  - fromParallelCollection
```
public <OUT> DataStreamSource<OUT> fromParallelCollection(SplittableIterator<OUT> iterator,
                                                          Class<OUT> type)
```
    Creates a new data stream that contains elements in the iterator. The iterator is splittable, allowing the framework to create a parallel data stream source that returns the elements in the iterator.
    Because the iterator will remain unmodified until the actual execution happens, the type of data returned by the iterator must be given explicitly in the form of the type class (this is due to the fact that the Java compiler erases the generic type information).
    
    Type Parameters:
    
    OUT - The type of the returned data stream
    
    Parameters:
    
    iterator - The iterator that produces the elements of the data stream
    
    type - The class of the data produced by the iterator. Must not be a generic class.
    
    Returns:
    
    A data stream representing the elements in the iterator
  - fromParallelCollection
```
public <OUT> DataStreamSource<OUT> fromParallelCollection(SplittableIterator<OUT> iterator,
                                                          TypeInformation<OUT> typeInfo)
```
    Creates a new data stream that contains elements in the iterator. The iterator is splittable, allowing the framework to create a parallel data stream source that returns the elements in the iterator.
    Because the iterator will remain unmodified until the actual execution happens, the type of data returned by the iterator must be given explicitly in the form of the type information. This method is useful for cases where the type is generic. In that case, the type class (as given in fromParallelCollection(org.apache.flink.util.SplittableIterator, Class) does not supply all type information.
    
    Type Parameters:
    
    OUT - The type of the returned data stream
    
    Parameters:
    
    iterator - The iterator that produces the elements of the data stream
    
    typeInfo - The TypeInformation for the produced data stream.
    
    Returns:
    
    A data stream representing the elements in the iterator
  - readTextFile
```
public DataStreamSource<String> readTextFile(String filePath)
```
    Reads the given file line-by-line and creates a data stream that contains a string with the contents of each such line. The file will be read with the system's default character set.
    NOTES ON CHECKPOINTING: The source monitors the path, creates the FileInputSplits to be processed, forwards them to the downstream readers to read the actual data, and exits, without waiting for the readers to finish reading. This implies that no more checkpoint barriers are going to be forwarded after the source exits, thus having no checkpoints after that point.
    
    Parameters:
    
    filePath - The path of the file, as a URI (e.g., "file:///some/local/file" or "hdfs://host:port/file/path").
    
    Returns:
    
    The data stream that represents the data read from the given file as text lines
  - readTextFile
```
public DataStreamSource<String> readTextFile(String filePath,
                                             String charsetName)
```
    Reads the given file line-by-line and creates a data stream that contains a string with the contents of each such line. The Charset with the given name will be used to read the files.
    NOTES ON CHECKPOINTING: The source monitors the path, creates the FileInputSplits to be processed, forwards them to the downstream readers to read the actual data, and exits, without waiting for the readers to finish reading. This implies that no more checkpoint barriers are going to be forwarded after the source exits, thus having no checkpoints after that point.
    
    Parameters:
    
    filePath - The path of the file, as a URI (e.g., "file:///some/local/file" or "hdfs://host:port/file/path")
    
    charsetName - The name of the character set used to read the file
    
    Returns:
    
    The data stream that represents the data read from the given file as text lines
  - readFile
```
public <OUT> DataStreamSource<OUT> readFile(FileInputFormat<OUT> inputFormat,
                                            String filePath)
```
    Reads the contents of the user-specified filePath based on the given FileInputFormat.
    Since all data streams need specific information about their types, this method needs to determine the type of the data produced by the input format. It will attempt to determine the data type by reflection, unless the input format implements the ResultTypeQueryable interface. In the latter case, this method will invoke the ResultTypeQueryable.getProducedType() method to determine data type produced by the input format.
    NOTES ON CHECKPOINTING: The source monitors the path, creates the FileInputSplits to be processed, forwards them to the downstream readers to read the actual data, and exits, without waiting for the readers to finish reading. This implies that no more checkpoint barriers are going to be forwarded after the source exits, thus having no checkpoints after that point.
    
    Type Parameters:
    
    OUT - The type of the returned data stream
    
    Parameters:
    
    filePath - The path of the file, as a URI (e.g., "file:///some/local/file" or "hdfs://host:port/file/path")
    
    inputFormat - The input format used to create the data stream
    
    Returns:
    
    The data stream that represents the data read from the given file
  - readFile
```
@PublicEvolving
 @Deprecated
public <OUT> DataStreamSource<OUT> readFile(FileInputFormat<OUT> inputFormat,
                                                                         String filePath,
                                                                         FileProcessingMode watchType,
                                                                         long interval,
                                                                         FilePathFilter filter)
```
    Deprecated. Use FileInputFormat.setFilesFilter(FilePathFilter) to set a filter and readFile(FileInputFormat, String, FileProcessingMode, long)
    
    Reads the contents of the user-specified filePath based on the given FileInputFormat. Depending on the provided FileProcessingMode.
    See readFile(FileInputFormat, String, FileProcessingMode, long)
    
    Type Parameters:
    
    OUT - The type of the returned data stream
    
    Parameters:
    
    inputFormat - The input format used to create the data stream
    
    filePath - The path of the file, as a URI (e.g., "file:///some/local/file" or "hdfs://host:port/file/path")
    
    watchType - The mode in which the source should operate, i.e. monitor path and react to new data, or process once and exit
    
    interval - In the case of periodic path monitoring, this specifies the interval (in millis) between consecutive path scans
    
    filter - The files to be excluded from the processing
    
    Returns:
    
    The data stream that represents the data read from the given file
  - readFile
```
@PublicEvolving
public <OUT> DataStreamSource<OUT> readFile(FileInputFormat<OUT> inputFormat,
                                                            String filePath,
                                                            FileProcessingMode watchType,
                                                            long interval)
```
    Reads the contents of the user-specified filePath based on the given FileInputFormat. Depending on the provided FileProcessingMode, the source may periodically monitor (every interval ms) the path for new data (FileProcessingMode.PROCESS_CONTINUOUSLY), or process once the data currently in the path and exit (FileProcessingMode.PROCESS_ONCE). In addition, if the path contains files not to be processed, the user can specify a custom FilePathFilter. As a default implementation you can use FilePathFilter.createDefaultFilter().
    Since all data streams need specific information about their types, this method needs to determine the type of the data produced by the input format. It will attempt to determine the data type by reflection, unless the input format implements the ResultTypeQueryable interface. In the latter case, this method will invoke the ResultTypeQueryable.getProducedType() method to determine data type produced by the input format.
    NOTES ON CHECKPOINTING: If the watchType is set to FileProcessingMode.PROCESS_ONCE, the source monitors the path once, creates the FileInputSplits to be processed, forwards them to the downstream readers to read the actual data, and exits, without waiting for the readers to finish reading. This implies that no more checkpoint barriers are going to be forwarded after the source exits, thus having no checkpoints after that point.
    
    Type Parameters:
    
    OUT - The type of the returned data stream
    
    Parameters:
    
    inputFormat - The input format used to create the data stream
    
    filePath - The path of the file, as a URI (e.g., "file:///some/local/file" or "hdfs://host:port/file/path")
    
    watchType - The mode in which the source should operate, i.e. monitor path and react to new data, or process once and exit
    
    interval - In the case of periodic path monitoring, this specifies the interval (in millis) between consecutive path scans
    
    Returns:
    
    The data stream that represents the data read from the given file
  - readFileStream
```
@Deprecated
public DataStream<String> readFileStream(String filePath,
                                                     long intervalMillis,
                                                     FileMonitoringFunction.WatchType watchType)
```
    Deprecated. Use readFile(FileInputFormat, String, FileProcessingMode, long) instead.
    
    Creates a data stream that contains the contents of file created while system watches the given path. The file will be read with the system's default character set.
    
    Parameters:
    
    filePath - The path of the file, as a URI (e.g., "file:///some/local/file" or "hdfs://host:port/file/path/")
    
    intervalMillis - The interval of file watching in milliseconds
    
    watchType - The watch type of file stream. When watchType is FileMonitoringFunction.WatchType.ONLY_NEW_FILES, the system processes only new files. FileMonitoringFunction.WatchType.REPROCESS_WITH_APPENDED means that the system re-processes all contents of appended file. FileMonitoringFunction.WatchType.PROCESS_ONLY_APPENDED means that the system processes only appended contents of files.
    
    Returns:
    
    The DataStream containing the given directory.
  - readFile
```
@PublicEvolving
public <OUT> DataStreamSource<OUT> readFile(FileInputFormat<OUT> inputFormat,
                                                            String filePath,
                                                            FileProcessingMode watchType,
                                                            long interval,
                                                            TypeInformation<OUT> typeInformation)
```
    Reads the contents of the user-specified filePath based on the given FileInputFormat. Depending on the provided FileProcessingMode, the source may periodically monitor (every interval ms) the path for new data (FileProcessingMode.PROCESS_CONTINUOUSLY), or process once the data currently in the path and exit (FileProcessingMode.PROCESS_ONCE). In addition, if the path contains files not to be processed, the user can specify a custom FilePathFilter. As a default implementation you can use FilePathFilter.createDefaultFilter().
    NOTES ON CHECKPOINTING: If the watchType is set to FileProcessingMode.PROCESS_ONCE, the source monitors the path once, creates the FileInputSplits to be processed, forwards them to the downstream readers to read the actual data, and exits, without waiting for the readers to finish reading. This implies that no more checkpoint barriers are going to be forwarded after the source exits, thus having no checkpoints after that point.
    
    Type Parameters:
    
    OUT - The type of the returned data stream
    
    Parameters:
    
    inputFormat - The input format used to create the data stream
    
    filePath - The path of the file, as a URI (e.g., "file:///some/local/file" or "hdfs://host:port/file/path")
    
    watchType - The mode in which the source should operate, i.e. monitor path and react to new data, or process once and exit
    
    typeInformation - Information on the type of the elements in the output stream
    
    interval - In the case of periodic path monitoring, this specifies the interval (in millis) between consecutive path scans
    
    Returns:
    
    The data stream that represents the data read from the given file
  - socketTextStream
```
@Deprecated
public DataStreamSource<String> socketTextStream(String hostname,
                                                             int port,
                                                             char delimiter,
                                                             long maxRetry)
```
    Deprecated. Use socketTextStream(String, int, String, long) instead.
    
    Creates a new data stream that contains the strings received infinitely from a socket. Received strings are decoded by the system's default character set. On the termination of the socket server connection retries can be initiated.
    Let us note that the socket itself does not report on abort and as a consequence retries are only initiated when the socket was gracefully terminated.
    
    Parameters:
    
    hostname - The host name which a server socket binds
    
    port - The port number which a server socket binds. A port number of 0 means that the port number is automatically allocated.
    
    delimiter - A character which splits received strings into records
    
    maxRetry - The maximal retry interval in seconds while the program waits for a socket that is temporarily down. Reconnection is initiated every second. A number of 0 means that the reader is immediately terminated, while a negative value ensures retrying forever.
    
    Returns:
    
    A data stream containing the strings received from the socket
  - socketTextStream
```
@PublicEvolving
public DataStreamSource<String> socketTextStream(String hostname,
                                                                 int port,
                                                                 String delimiter,
                                                                 long maxRetry)
```
    Creates a new data stream that contains the strings received infinitely from a socket. Received strings are decoded by the system's default character set. On the termination of the socket server connection retries can be initiated.
    Let us note that the socket itself does not report on abort and as a consequence retries are only initiated when the socket was gracefully terminated.
    
    Parameters:
    
    hostname - The host name which a server socket binds
    
    port - The port number which a server socket binds. A port number of 0 means that the port number is automatically allocated.
    
    delimiter - A string which splits received strings into records
    
    maxRetry - The maximal retry interval in seconds while the program waits for a socket that is temporarily down. Reconnection is initiated every second. A number of 0 means that the reader is immediately terminated, while a negative value ensures retrying forever.
    
    Returns:
    
    A data stream containing the strings received from the socket
  - socketTextStream
```
@Deprecated
public DataStreamSource<String> socketTextStream(String hostname,
                                                             int port,
                                                             char delimiter)
```
    Deprecated. Use socketTextStream(String, int, String) instead.
    
    Creates a new data stream that contains the strings received infinitely from a socket. Received strings are decoded by the system's default character set. The reader is terminated immediately when the socket is down.
    
    Parameters:
    
    hostname - The host name which a server socket binds
    
    port - The port number which a server socket binds. A port number of 0 means that the port number is automatically allocated.
    
    delimiter - A character which splits received strings into records
    
    Returns:
    
    A data stream containing the strings received from the socket
  - socketTextStream
```
@PublicEvolving
public DataStreamSource<String> socketTextStream(String hostname,
                                                                 int port,
                                                                 String delimiter)
```
    Creates a new data stream that contains the strings received infinitely from a socket. Received strings are decoded by the system's default character set. The reader is terminated immediately when the socket is down.
    
    Parameters:
    
    hostname - The host name which a server socket binds
    
    port - The port number which a server socket binds. A port number of 0 means that the port number is automatically allocated.
    
    delimiter - A string which splits received strings into records
    
    Returns:
    
    A data stream containing the strings received from the socket
  - socketTextStream
```
@PublicEvolving
public DataStreamSource<String> socketTextStream(String hostname,
                                                                 int port)
```
    Creates a new data stream that contains the strings received infinitely from a socket. Received strings are decoded by the system's default character set, using"\n" as delimiter. The reader is terminated immediately when the socket is down.
    
    Parameters:
    
    hostname - The host name which a server socket binds
    
    port - The port number which a server socket binds. A port number of 0 means that the port number is automatically allocated.
    
    Returns:
    
    A data stream containing the strings received from the socket
  - createInput
```
@PublicEvolving
public <OUT> DataStreamSource<OUT> createInput(InputFormat<OUT,?> inputFormat)
```
    Generic method to create an input data stream with InputFormat.
    Since all data streams need specific information about their types, this method needs to determine the type of the data produced by the input format. It will attempt to determine the data type by reflection, unless the input format implements the ResultTypeQueryable interface. In the latter case, this method will invoke the ResultTypeQueryable.getProducedType() method to determine data type produced by the input format.
    NOTES ON CHECKPOINTING: In the case of a FileInputFormat, the source (which executes the ContinuousFileMonitoringFunction) monitors the path, creates the FileInputSplits to be processed, forwards them to the downstream ContinuousFileReaderOperator to read the actual data, and exits, without waiting for the readers to finish reading. This implies that no more checkpoint barriers are going to be forwarded after the source exits, thus having no checkpoints.
    
    Type Parameters:
    
    OUT - The type of the returned data stream
    
    Parameters:
    
    inputFormat - The input format used to create the data stream
    
    Returns:
    
    The data stream that represents the data created by the input format
  - createInput
```
@PublicEvolving
public <OUT> DataStreamSource<OUT> createInput(InputFormat<OUT,?> inputFormat,
                                                               TypeInformation<OUT> typeInfo)
```
    Generic method to create an input data stream with InputFormat.
    The data stream is typed to the given TypeInformation. This method is intended for input formats where the return type cannot be determined by reflection analysis, and that do not implement the ResultTypeQueryable interface.
    NOTES ON CHECKPOINTING: In the case of a FileInputFormat, the source (which executes the ContinuousFileMonitoringFunction) monitors the path, creates the FileInputSplits to be processed, forwards them to the downstream ContinuousFileReaderOperator to read the actual data, and exits, without waiting for the readers to finish reading. This implies that no more checkpoint barriers are going to be forwarded after the source exits, thus having no checkpoints.
    
    Type Parameters:
    
    OUT - The type of the returned data stream
    
    Parameters:
    
    inputFormat - The input format used to create the data stream
    
    typeInfo - The information about the type of the output type
    
    Returns:
    
    The data stream that represents the data created by the input format
  - addSource
```
public <OUT> DataStreamSource<OUT> addSource(SourceFunction<OUT> function)
```
    Adds a Data Source to the streaming topology.
    By default sources have a parallelism of 1. To enable parallel execution, the user defined source should implement ParallelSourceFunction or extend RichParallelSourceFunction. In these cases the resulting source will have the parallelism of the environment. To change this afterwards call DataStreamSource.setParallelism(int)
    
    Type Parameters:
    
    OUT - type of the returned stream
    
    Parameters:
    
    function - the user defined function
    
    Returns:
    
    the data stream constructed
  - addSource
```
public <OUT> DataStreamSource<OUT> addSource(SourceFunction<OUT> function,
                                             String sourceName)
```
    Ads a data source with a custom type information thus opening a DataStream. Only in very special cases does the user need to support type information. Otherwise use addSource(org.apache.flink.streaming.api.functions.source.SourceFunction)
    
    Type Parameters:
    
    OUT - type of the returned stream
    
    Parameters:
    
    function - the user defined function
    
    sourceName - Name of the data source
    
    Returns:
    
    the data stream constructed
  - addSource
```
public <OUT> DataStreamSource<OUT> addSource(SourceFunction<OUT> function,
                                             TypeInformation<OUT> typeInfo)
```
    Ads a data source with a custom type information thus opening a DataStream. Only in very special cases does the user need to support type information. Otherwise use addSource(org.apache.flink.streaming.api.functions.source.SourceFunction)
    
    Type Parameters:
    
    OUT - type of the returned stream
    
    Parameters:
    
    function - the user defined function
    
    typeInfo - the user defined type information for the stream
    
    Returns:
    
    the data stream constructed
  - addSource
```
public <OUT> DataStreamSource<OUT> addSource(SourceFunction<OUT> function,
                                             String sourceName,
                                             TypeInformation<OUT> typeInfo)
```
    Ads a data source with a custom type information thus opening a DataStream. Only in very special cases does the user need to support type information. Otherwise use addSource(org.apache.flink.streaming.api.functions.source.SourceFunction)
    
    Type Parameters:
    
    OUT - type of the returned stream
    
    Parameters:
    
    function - the user defined function
    
    sourceName - Name of the data source
    
    typeInfo - the user defined type information for the stream
    
    Returns:
    
    the data stream constructed
  - execute
```
public JobExecutionResult execute()
                           throws Exception
```
    Triggers the program execution. The environment will execute all parts of the program that have resulted in a "sink" operation. Sink operations are for example printing results or forwarding them to a message queue.
    The program execution will be logged and displayed with a generated default name.
    
    Returns:
    
    The result of the job execution, containing elapsed time and accumulators.
    
    Throws:
    
    Exception - which occurs during job execution.
  - execute
```
public abstract JobExecutionResult execute(String jobName)
                                    throws Exception
```
    Triggers the program execution. The environment will execute all parts of the program that have resulted in a "sink" operation. Sink operations are for example printing results or forwarding them to a message queue.
    The program execution will be logged and displayed with the provided name
    
    Parameters:
    
    jobName - Desired name of the job
    
    Returns:
    
    The result of the job execution, containing elapsed time and accumulators.
    
    Throws:
    
    Exception - which occurs during job execution.
  - getStreamGraph
```
@Internal
public StreamGraph getStreamGraph()
```
    Getter of the StreamGraph of the streaming job.
    
    Returns:
    
    The streamgraph representing the transformations
  - getExecutionPlan
```
public String getExecutionPlan()
```
    Creates the plan with which the system will execute the program, and returns it as a String using a JSON representation of the execution data flow graph. Note that this needs to be called, before the plan is executed.
    
    Returns:
    
    The execution plan of the program, as a JSON String.
  - clean
```
@Internal
public <F> F clean(F f)
```
    Returns a "closure-cleaned" version of the given function. Cleans only if closure cleaning is not disabled in the ExecutionConfig
  - addOperator
```
@Internal
public void addOperator(StreamTransformation<?> transformation)
```
    Adds an operator to the list of operators that should be executed when calling execute().
    When calling execute() only the operators that where previously added to the list are executed.
    This is not meant to be used by users. The API methods that create operators must call this method.
  - getExecutionEnvironment
```
public static StreamExecutionEnvironment getExecutionEnvironment()
```
    Creates an execution environment that represents the context in which the program is currently executed. If the program is invoked standalone, this method returns a local execution environment, as returned by createLocalEnvironment().
    
    Returns:
    
    The execution environment of the context in which the program is executed.
  - createLocalEnvironment
```
public static LocalStreamEnvironment createLocalEnvironment()
```
    Creates a LocalStreamEnvironment. The local execution environment will run the program in a multi-threaded fashion in the same JVM as the environment was created in. The default parallelism of the local environment is the number of hardware contexts (CPU cores / threads), unless it was specified differently by setParallelism(int).
    
    Returns:
    
    A local execution environment.
  - createLocalEnvironment
```
public static LocalStreamEnvironment createLocalEnvironment(int parallelism)
```
    Creates a LocalStreamEnvironment. The local execution environment will run the program in a multi-threaded fashion in the same JVM as the environment was created in. It will use the parallelism specified in the parameter.
    
    Parameters:
    
    parallelism - The parallelism for the local environment.
    
    Returns:
    
    A local execution environment with the specified parallelism.
  - createLocalEnvironment
```
public static LocalStreamEnvironment createLocalEnvironment(int parallelism,
                                                            Configuration configuration)
```
    Creates a LocalStreamEnvironment. The local execution environment will run the program in a multi-threaded fashion in the same JVM as the environment was created in. It will use the parallelism specified in the parameter.
    
    Parameters:
    
    parallelism - The parallelism for the local environment.
    
    configuration - Pass a custom configuration into the cluster
    
    Returns:
    
    A local execution environment with the specified parallelism.
  - createLocalEnvironmentWithWebUI
```
@PublicEvolving
public static StreamExecutionEnvironment createLocalEnvironmentWithWebUI(Configuration conf)
```
    Creates a LocalStreamEnvironment for local program execution that also starts the web monitoring UI.
    The local execution environment will run the program in a multi-threaded fashion in the same JVM as the environment was created in. It will use the parallelism specified in the parameter.
    If the configuration key 'rest.port' was set in the configuration, that particular port will be used for the web UI. Otherwise, the default port (8081) will be used.
  - createRemoteEnvironment
```
public static StreamExecutionEnvironment createRemoteEnvironment(String host,
                                                                 int port,
                                                                 String... jarFiles)
```
    Creates a RemoteStreamEnvironment. The remote environment sends (parts of) the program to a cluster for execution. Note that all file paths used in the program must be accessible from the cluster. The execution will use no parallelism, unless the parallelism is set explicitly via setParallelism(int).
    
    Parameters:
    
    host - The host name or address of the master (JobManager), where the program should be executed.
    
    port - The port of the master (JobManager), where the program should be executed.
    
    jarFiles - The JAR files with code that needs to be shipped to the cluster. If the program uses user-defined functions, user-defined input formats, or any libraries, those must be provided in the JAR files.
    
    Returns:
    
    A remote environment that executes the program on a cluster.
  - createRemoteEnvironment
```
public static StreamExecutionEnvironment createRemoteEnvironment(String host,
                                                                 int port,
                                                                 int parallelism,
                                                                 String... jarFiles)
```
    Creates a RemoteStreamEnvironment. The remote environment sends (parts of) the program to a cluster for execution. Note that all file paths used in the program must be accessible from the cluster. The execution will use the specified parallelism.
    
    Parameters:
    
    host - The host name or address of the master (JobManager), where the program should be executed.
    
    port - The port of the master (JobManager), where the program should be executed.
    
    parallelism - The parallelism to use during the execution.
    
    jarFiles - The JAR files with code that needs to be shipped to the cluster. If the program uses user-defined functions, user-defined input formats, or any libraries, those must be provided in the JAR files.
    
    Returns:
    
    A remote environment that executes the program on a cluster.
  - createRemoteEnvironment
```
public static StreamExecutionEnvironment createRemoteEnvironment(String host,
                                                                 int port,
                                                                 Configuration clientConfig,
                                                                 String... jarFiles)
```
    Creates a RemoteStreamEnvironment. The remote environment sends (parts of) the program to a cluster for execution. Note that all file paths used in the program must be accessible from the cluster. The execution will use the specified parallelism.
    
    Parameters:
    
    host - The host name or address of the master (JobManager), where the program should be executed.
    
    port - The port of the master (JobManager), where the program should be executed.
    
    clientConfig - The configuration used by the client that connects to the remote cluster.
    
    jarFiles - The JAR files with code that needs to be shipped to the cluster. If the program uses user-defined functions, user-defined input formats, or any libraries, those must be provided in the JAR files.
    
    Returns:
    
    A remote environment that executes the program on a cluster.
  - getDefaultLocalParallelism
```
@PublicEvolving
public static int getDefaultLocalParallelism()
```
    Gets the default parallelism that will be used for the local execution environment created by createLocalEnvironment().
    
    Returns:
    
    The default local parallelism
  - setDefaultLocalParallelism
```
@PublicEvolving
public static void setDefaultLocalParallelism(int parallelism)
```
    Sets the default parallelism that will be used for the local execution environment created by createLocalEnvironment().
    
    Parameters:
    
    parallelism - The parallelism to use as the default local parallelism.
  - initializeContextEnvironment
```
protected static void initializeContextEnvironment(StreamExecutionEnvironmentFactory ctx)
```
  - resetContextEnvironment
```
protected static void resetContextEnvironment()
```
  - registerCachedFile
```
public void registerCachedFile(String filePath,
                               String name)
```
    Registers a file at the distributed cache under the given name. The file will be accessible from any user-defined function in the (distributed) runtime under a local path. Files may be local files (as long as all relevant workers have access to it), or files in a distributed file system. The runtime will copy the files temporarily to a local cache, if needed.
    The RuntimeContext can be obtained inside UDFs via RichFunction.getRuntimeContext() and provides access DistributedCache via RuntimeContext.getDistributedCache().
    
    Parameters:
    
    filePath - The path of the file, as a URI (e.g. "file:///some/path" or "hdfs://host:port/and/path")
    
    name - The name under which the file is registered.
  - registerCachedFile
```
public void registerCachedFile(String filePath,
                               String name,
                               boolean executable)
```
    Registers a file at the distributed cache under the given name. The file will be accessible from any user-defined function in the (distributed) runtime under a local path. Files may be local files (as long as all relevant workers have access to it), or files in a distributed file system. The runtime will copy the files temporarily to a local cache, if needed.
    The RuntimeContext can be obtained inside UDFs via RichFunction.getRuntimeContext() and provides access DistributedCache via RuntimeContext.getDistributedCache().
    
    Parameters:
    
    filePath - The path of the file, as a URI (e.g. "file:///some/path" or "hdfs://host:port/and/path")
    
    name - The name under which the file is registered.
    
    executable - flag indicating whether the file should be executable

Back to Flink Website

Class StreamExecutionEnvironment

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

DEFAULT_JOB_NAME

transformations

isChainingEnabled

cacheFile

Constructor Detail

StreamExecutionEnvironment

Method Detail

getConfig

getCachedFiles

setParallelism

setMaxParallelism

getParallelism

getMaxParallelism

setBufferTimeout

getBufferTimeout

disableOperatorChaining

isChainingEnabled

getCheckpointConfig

enableCheckpointing

enableCheckpointing

enableCheckpointing

enableCheckpointing

getCheckpointInterval

isForceCheckpointing

getCheckpointingMode

setStateBackend

setStateBackend

getStateBackend

setRestartStrategy

getRestartStrategy

setNumberOfExecutionRetries

getNumberOfExecutionRetries

addDefaultKryoSerializer

addDefaultKryoSerializer

registerTypeWithKryoSerializer

registerTypeWithKryoSerializer

registerType

setStreamTimeCharacteristic

getStreamTimeCharacteristic

generateSequence

fromElements

fromElements

fromCollection

fromCollection

fromCollection

fromCollection

fromParallelCollection

fromParallelCollection

readTextFile

readTextFile

readFile

readFile

readFile

readFileStream

readFile

socketTextStream

socketTextStream

socketTextStream

socketTextStream

socketTextStream

createInput

createInput

addSource

addSource

addSource

addSource

execute

execute

getStreamGraph

getExecutionPlan

clean

addOperator

getExecutionEnvironment