Flink 1.11.x WatermarkStrategy 不兼容问题

Error:Error:line (31)Static methods in interface require -target:jvm-1.8
                .assignTimestampsAndWatermarks(WatermarkStrategy.forBoundedOutOfOrderness[String](Duration.ofSeconds(5)))

env.addSource(new FlinkKafkaConsumer[String](topic_, new SimpleStringSchema(), properties).setStartFromLatest())
              .assignTimestampsAndWatermarks(WatermarkStrategy.forBoundedOutOfOrderness[String](Duration.ofSeconds(5)))

/**
  * Creates a watermark strategy for situations where records are out of order, but you can place
  * an upper bound on how far the events are out of order. An out-of-order bound B means that
  * once the an event with timestamp T was encountered, no events older than {@code T - B} will
  * follow any more.
  *
  * <p>The watermarks are generated periodically. The delay introduced by this watermark
  * strategy is the periodic interval length, plus the out of orderness bound.
  *
  * @see BoundedOutOfOrdernessWatermarks
  */
 static <T> WatermarkStrategy<T> forBoundedOutOfOrderness(Duration maxOutOfOrderness) {
  return (ctx) -> new BoundedOutOfOrdernessWatermarks<>(maxOutOfOrderness);
 }

public interface WatermarkStrategy<T> extends
  TimestampAssignerSupplier<T>, WatermarkGeneratorSupplier<T> {
 // ------------------------------------------------------------------------
 //  Methods that implementors need to implement.
 // ------------------------------------------------------------------------
 /**
  * Instantiates a WatermarkGenerator that generates watermarks according to this strategy.
  */
 @Override
 WatermarkGenerator<T> createWatermarkGenerator(WatermarkGeneratorSupplier.Context context);
 /**
  * Instantiates a {@link TimestampAssigner} for assigning timestamps according to this
  * strategy.
  */
 @Override
 default TimestampAssigner<T> createTimestampAssigner(TimestampAssignerSupplier.Context context) {
  // By default, this is {@link RecordTimestampAssigner},
  // for cases where records come out of a source with valid timestamps, for example from Kafka.
  return new RecordTimestampAssigner<>();
 }
 // ------------------------------------------------------------------------
 //  Builder methods for enriching a base WatermarkStrategy
 // ------------------------------------------------------------------------
 /**
  * Creates a new {@code WatermarkStrategy} that wraps this strategy but instead uses the given
  * {@link TimestampAssigner} (via a {@link TimestampAssignerSupplier}).
  *
  * <p>You can use this when a {@link TimestampAssigner} needs additional context, for example
  * access to the metrics system.
  *
  * <pre>
  * {@code WatermarkStrategy<Object> wmStrategy = WatermarkStrategy
  *   .forMonotonousTimestamps()
  *   .withTimestampAssigner((ctx) -> new MetricsReportingAssigner(ctx));
  * }</pre>
  */
 default WatermarkStrategy<T> withTimestampAssigner(TimestampAssignerSupplier<T> timestampAssigner) {
  checkNotNull(timestampAssigner, "timestampAssigner");
  return new WatermarkStrategyWithTimestampAssigner<>(this, timestampAssigner);
 }
 /**
  * Creates a new {@code WatermarkStrategy} that wraps this strategy but instead uses the given
  * {@link SerializableTimestampAssigner}.
  *
  * <p>You can use this in case you want to specify a {@link TimestampAssigner} via a lambda
  * function.
  *
  * <pre>
  * {@code WatermarkStrategy<CustomObject> wmStrategy = WatermarkStrategy
  *   .<CustomObject>forMonotonousTimestamps()
  *   .withTimestampAssigner((event, timestamp) -> event.getTimestamp());
  * }</pre>
  */
 default WatermarkStrategy<T> withTimestampAssigner(SerializableTimestampAssigner<T> timestampAssigner) {
  checkNotNull(timestampAssigner, "timestampAssigner");
  return new WatermarkStrategyWithTimestampAssigner<>(this,
    TimestampAssignerSupplier.of(timestampAssigner));
 }
 /**
  * Creates a new enriched {@link WatermarkStrategy} that also does idleness detection in the
  * created {@link WatermarkGenerator}.
  *
  * <p>Add an idle timeout to the watermark strategy. If no records flow in a partition of a
  * stream for that amount of time, then that partition is considered "idle" and will not hold
  * back the progress of watermarks in downstream operators.
  *
  * <p>Idleness can be important if some partitions have little data and might not have events
  * during some periods. Without idleness, these streams can stall the overall event time
  * progress of the application.
  */
 default WatermarkStrategy<T> withIdleness(Duration idleTimeout) {
  checkNotNull(idleTimeout, "idleTimeout");
  checkArgument(!(idleTimeout.isZero() || idleTimeout.isNegative()),
    "idleTimeout must be greater than zero");
  return new WatermarkStrategyWithIdleness<>(this, idleTimeout);
 }
 // ------------------------------------------------------------------------
 //  Convenience methods for common watermark strategies
 // ------------------------------------------------------------------------
 /**
  * Creates a watermark strategy for situations with monotonously ascending timestamps.
  *
  * <p>The watermarks are generated periodically and tightly follow the latest
  * timestamp in the data. The delay introduced by this strategy is mainly the periodic interval
  * in which the watermarks are generated.
  *
  * @see AscendingTimestampsWatermarks
  */
 static <T> WatermarkStrategy<T> forMonotonousTimestamps() {
  return (ctx) -> new AscendingTimestampsWatermarks<>();
 }
 /**
  * Creates a watermark strategy for situations where records are out of order, but you can place
  * an upper bound on how far the events are out of order. An out-of-order bound B means that
  * once the an event with timestamp T was encountered, no events older than {@code T - B} will
  * follow any more.
  *
  * <p>The watermarks are generated periodically. The delay introduced by this watermark
  * strategy is the periodic interval length, plus the out of orderness bound.
  *
  * @see BoundedOutOfOrdernessWatermarks
  */
 static <T> WatermarkStrategy<T> forBoundedOutOfOrderness(Duration maxOutOfOrderness) {
  return (ctx) -> new BoundedOutOfOrdernessWatermarks<>(maxOutOfOrderness);
 }
 /**
  * Creates a watermark strategy based on an existing {@link WatermarkGeneratorSupplier}.
  */
 static <T> WatermarkStrategy<T> forGenerator(WatermarkGeneratorSupplier<T> generatorSupplier) {
  return generatorSupplier::createWatermarkGenerator;
 }
 /**
  * Creates a watermark strategy that generates no watermarks at all. This may be useful in
  * scenarios that do pure processing-time based stream processing.
  */
 static <T> WatermarkStrategy<T> noWatermarks() {
  return (ctx) -> new NoWatermarksGenerator<>();
 }
}

mvn clean package -DaddScalacArgs=-target:jvm-1.8

<plugin>
                <groupId>net.alchim31.maven</groupId>
                <artifactId>scala-maven-plugin</artifactId>
                <version>3.4.6</version>
                <configuration>
                    <recompileMode>incremental</recompileMode>
                    <addScalacArgs>-target:jvm-1.8</addScalacArgs>
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <goal>compile</goal>
                            <goal>testCompile</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>