Flink Sink JDBC 源码分析【转载】

转载地址：https://blog.51cto.com/u_15064630/4148244

说明：以下所有都基于Flink1.11版本 代码都精简过了

简单栗子

public class MysqlSinkExample {

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

        DataStreamSource<String> source = env.fromElements("a", "b", "c", "d");

        //执行参数 
        JdbcExecutionOptions executionOptions = JdbcExecutionOptions.builder().withBatchIntervalMs(500L).withBatchSize(10000).build();
        //数据库连接参数
        JdbcConnectionOptions connectionOptions = (new JdbcConnectionOptions.JdbcConnectionOptionsBuilder())
       		.withUrl("jdbcurl")
        	.withDriverName("db.driver")
        	.withUsername("db.username")
        	.withPassword("monitor.db.password")
        	.build();
        	
        //sql
        final String sql = "INSERT INTO letter (name) VALUES (?)";
        //输出
        source.addSink(JdbcSink.sink(
                sql,
                (st, r) -> {
                    st.setString(1, r);
                },
                executionOptions,
                connectionOptions
        ));

        env.execute("sink mysql");
    }
}

上面需求就是将元素 “a” “b” “c” “d” 写入 letter 表！可以看到我们有配置：

• JdbcExecutionOptions 执行参数
• batchIntervalMs ：每次批量写入最小间隔时间
• batchSize ：批量写入的数据大小
• maxRetries ： 插入发生异常重试次数 注意：只支持SQL Exception 异常及其子类异常重试
• JdbcConnectionOptions 连接参数配置
• sql 写入的sql语句
• 里面还有一个 labmbda 函数实现它 本身是一个消费labmbda函数
• PreparedStatement ：第一个参数
• 第二参数是元素 如代码中的a b c …

产生思考
当我们写入数据成功时候，会不会想一些其他的问题 ？
如何实现批量写入的？
批量写入是不是会产生数据延迟？

我想转实时写入怎么配置？
数据会丢失吗？

源码
看源码之前看一张核心类关联图，请记住这三个核心类，后面都穿插着他们身影。

工厂类 JdbcSink
我们是通过 JdbcSink.sink(…) 构造一个 SinkFunction 提供给Flink输出数据！
– org.apache.flink.connector.jdbc.JdbcSink

public class JdbcSink {
 public static <T> SinkFunction<T> sink(
  String sql,
  JdbcStatementBuilder<T> statementBuilder,
  JdbcExecutionOptions executionOptions,
  JdbcConnectionOptions connectionOptions) {
  return new GenericJdbcSinkFunction<>(  //  todo GenericJdbcSinkFunction
   new JdbcBatchingOutputFormat<>(    //   todo JdbcBatchingOutputFormat  批量写出处理类
    new SimpleJdbcConnectionProvider(connectionOptions),   //todo Jdbc连接包装类
    executionOptions, //todo 执行参数类 如重试次数 最大等待时间 最大等待条数
    context -> {
     Preconditions.checkState(
      !context.getExecutionConfig().isObjectReuseEnabled(),
      "objects can not be reused with JDBC sink function");
     return JdbcBatchStatementExecutor.simple(   //todo  返回的就是这个 SimpleBatchStatementExecutor 这里封装了 最终写入逻辑
      sql,
      statementBuilder,
      Function.identity());
    },
    JdbcBatchingOutputFormat.RecordExtractor.identity()
   ));
   }

根据此图结合看一下 核心类关系图！
1.
这里我们不用去理解具体每个类作用，但是必须知道通过工厂构造出一个 GenericJdbcSinkFunction ！

数据处理：GenericJdbcSinkFunction
Flink官方提供了 RichSinkFunction 供我们完成数据输出！它有两个接口供下游处理！open 函数初始化方法 在实际处理数据之前仅会调用一次 invoke 每进来一条数据都会调用一次

open(Configuration parameters)
invoke(T value, Context context)

我们再来看看 GenericJdbcSinkFunction 实现 RichSinkFunction 之后具体干了什么？

public class GenericJdbcSinkFunction<T> extends RichSinkFunction<T> {
    private final AbstractJdbcOutputFormat<T > outputFormat;

 public GenericJdbcSinkFunction(@Nonnull AbstractJdbcOutputFormat<T> outputFormat) {
  this.outputFormat = Preconditions.checkNotNull(outputFormat);
 }

 @Override
 public void open(Configuration parameters) throws Exception {
  super.open(parameters);
  RuntimeContext ctx = getRuntimeContext();
  outputFormat.setRuntimeContext(ctx);
  outputFormat.open(ctx.getIndexOfThisSubtask(), ctx.getNumberOfParallelSubtasks());
 }

 @Override
 public void invoke(T value, Context context) throws IOException {
  outputFormat.writeRecord(value);
 }
}

简化代码发现：open执行时候会去调用outputFormat.open(…) invoke 也只是调用了 outputFormat.writeRecord(value)
那么outputFormat是具体那个类实现? 回到构造工厂可以看到 里面构造了 JdbcBatchingOutputFormat

这个时候可以理解: AbstractJdbcOutputFormat outputFormat = JdbcBatchingOutputFormat outputFormat

初始化：JdbcBatchingOutputFormat#Open

public class JdbcBatchingOutputFormat extend AbstractJdbcOutputFormat{
 private transient JdbcExec jdbcStatementExecutor;

 @Override
 public void open(int taskNumber, int numTasks) throws IOException {
        //初始化jdbc连接
  super.open(taskNumber, numTasks);

  // todo 创建执行器 SimpleBatchStatementExecutor
  jdbcStatementExecutor = createAndOpenStatementExecutor(statementExecutorFactory);

        // todo 如果 配置输出到jdbc最小间隔不等于0 且最小条数不是1 就创建一个固定定时线程池
  if (executionOptions.getBatchIntervalMs() != 0 && executionOptions.getBatchSize() != 1) {
   this.scheduler = Executors.newScheduledThreadPool(
    1,
    new ExecutorThreadFactory("jdbc-upsert-output-format"));
   this.scheduledFuture = this.scheduler.scheduleWithFixedDelay(
    () -> {
     synchronized (JdbcBatchingOutputFormat.this) {
      if (!closed) {
       try {
                                // todo 批量缓存的数据都写到jdbc
        flush(); 
       } catch (Exception e) {
        flushException = e;
       }
      }
     }
    },
    executionOptions.getBatchIntervalMs(),
    executionOptions.getBatchIntervalMs(),
    TimeUnit.MILLISECONDS);
  }
 }
}

其实这里就干了三件事情: 
第一件事：super.open(taskNumber, numTasks)就是调用了抽象父类中 AbstractJdbcOutputFormat的open方法

public abstract class AbstractJdbcOutputFormat{
    protected transient Connection connection;
 protected final JdbcConnectionProvider connectionProvider;

 @Override
 public void open(int taskNumber, int numTasks) throws IOException {
  try {
   establishConnection();
  } catch (Exception e) {
   throw new IOException("unable to open JDBC writer", e);
  }
 }
  protected void establishConnection() throws Exception {
        //创建jdbc连接
  connection = connectionProvider.getConnection();
 }
}

而这个JdbcConnectionProvider这个类就是在在构造JdbcBatchingOutputFormat构造方法传入的SimpleJdbcConnectionProvider

SimpleJdbcConnectionProvider#getConnection 可以看到就是创建了Connection

public class SimpleJdbcConnectionProvider{
 private final JdbcConnectionOptions jdbcOptions;
 private transient volatile Connection connection;

    @Override
 public Connection  getConnection() throws SQLException, ClassNotFoundException {
  if (connection == null) {
   synchronized (this) {
    if (connection == null) {
     Class.forName(jdbcOptions.getDriverName());
     if (jdbcOptions.getUsername().isPresent()) {
      connection = DriverManager.getConnection(jdbcOptions.getDbURL(), jdbcOptions.getUsername().get(), jdbcOptions.getPassword().orElse(null));
     } else {
      connection = DriverManager.getConnection(jdbcOptions.getDbURL());
     }
    }
   }
  }
  return connection;
 }
}

第二件事：createAndOpenStatementExecutor(statementExecutorFactory) 创建执行器SimpleBatchStatementExecutor

然后调用 SimpleBatchStatementExecutor#prepareStatements(connection) 初始化了PreparedStatement st

第二件事：根据条件判断是否创建固定定时启动线程池！这个线程池会根据你配置的时间定时启动去执行 flush 方法！这个 flush 方法主要作用定时将缓存的数据触发jdbc写入！

扩展一下：为什么还要判断 executionOptions.getBatchSize() != 1 呢？你想如果最大推送大小只有一条那就是来一条写入jdbc一条那么定时去触发写入就没啥意义了！如果想要实时写入那么也就是来一条我立马写入到jdbc。这个时候在flink内部不会有延迟的！

处理数据：JdbcBatchingOutputFormat#writeRecord
每条数据进来每次都会进入一下逻辑 我们宏观先看一遍 有个印象再来看细节

• GenericJdbcSinkFunction#invoke
• SimpleBatchStatementExecutor#addToBatch
• JdbcBatchingOutputFormat#flush
• SimpleBatchStatementExecutor#executeBatch
• JdbcBatchingOutputFormat#writeRecord

设计思路：
我们想要实现批量写入，那就必须要有批量数据，可是我们数据一条条进来是不是先得有个容器容纳这些批量数据？当容器到达一定的数据量我们就得批量写出去，然后清空容器，再重新装数据。

flink的实现：
JdbcBatchingOutputFormat#writeRecord

@Override
 public final synchronized void writeRecord(In record) throws IOException {
  //写入数据之前发现有之前存在异常 就抛出异常 结束写入！否则则继续写入。
  checkFlushException();

  try {
   //将数据添加到容器
   addToBatch(record, jdbcRecordExtractor.apply(record));
   //计数器 统计容器已经有多少数据了
   batchCount++;
   //判断计数器是不是达到 指定容量
   if (executionOptions.getBatchSize() > 0
    && batchCount >= executionOptions.getBatchSize()) {
    flush(); //达到就执行批量输出jdbc
   }
  } catch (Exception e) {
   throw new IOException("Writing records to JDBC failed.", e);
  }
 }

JdbcBatchingOutputFormat#addToBatch 如何批量写入容器

protected void addToBatch(In original, JdbcIn extracted) throws SQLException {
     //这个jdbcStatementExecutor 前面说了就等于  SimpleBatchStatementExecutor
  jdbcStatementExecutor.addToBatch(extracted);
  }

SimpleBatchStatementExecutor#addToBatch

class SimpleBatchStatementExecutor<T, V>{
    private final List<V> batch;

    SimpleBatchStatementExecutor(...) {
  ...
  this.batch = new ArrayList<>();
 }

 @Override
 public void addToBatch(T record) {
  batch.add(valueTransformer.apply(record));
 }
}

可以看到内部使用一个ArrayList容器容纳待写入的元素， valueTransformer 这里的就是record数据进去record数据出来，没有做什么处理！系统留下的扩展！

系统批量写入jdbc时机？
有三个他们都调用了 JdbcBatchingOutputFormat#flush

• JdbcBatchingOutputFormat#writeRecord 写入元素时候判断批量条数达到阈值调用
• JdbcBatchingOutputFormat#open 上面讲了open里面启动一个定时调度器会调用
• GenericJdbcSinkFunction#snapshotState 还有一个发生checkPoint时候会调用

JdbcBatchingOutputFormat#flush 方法解析

@Override
 public synchronized void flush() throws IOException {
  checkFlushException();
  //循环判断是否小于最大重试次数
  for (int i = 1; i <= executionOptions.getMaxRetries(); i++) {
   try {
    //执行jdbc批量写入 然后将统计数据条数值重置为0  跳出循环结束
    attemptFlush();
    batchCount = 0;
    break;
   } catch (SQLException e) {
    LOG.error("JDBC executeBatch error, retry times = {}", i, e);
    if (i >= executionOptions.getMaxRetries()) {
     throw new IOException(e);  //如果循环次数达到最大重试次数 就抛出异常
    }
    try {
     //验证 连接是否有效 无效会重新生成connection和PreparedStatement
     if (!connection.isValid(CONNECTION_CHECK_TIMEOUT_SECONDS)) {
      connection = connectionProvider.reestablishConnection();
      jdbcStatementExecutor.closeStatements();
      jdbcStatementExecutor.prepareStatements(connection);
     }
    } catch (Exception excpetion) {
     LOG.error(
      "JDBC connection is not valid, and reestablish connection failed.",
      excpetion);
     throw new IOException("Reestablish JDBC connection failed", excpetion);
    }
    try {
     Thread.sleep(1000 * i);
    } catch (InterruptedException ex) {
     Thread.currentThread().interrupt();
     throw new IOException(
      "unable to flush; interrupted while doing another attempt",
      e);
    }
   }
  }
 }

 protected void attemptFlush() throws SQLException {
        //这个jdbcStatementExecutor 前面说了就等于  SimpleBatchStatementExecutor
  jdbcStatementExecutor.executeBatch();
 }

SimpleBatchStatementExecutor#executeBatch

@Override
 public void executeBatch() throws SQLException {
  if (!batch.isEmpty()) {
   for (V r : batch) {
    parameterSetter.accept(st, r);
    st.addBatch();
   }
   st.executeBatch();
   batch.clear();
  }
 }

这个parameterSetter.accept(st, r) 方法就是调用我例子里面的st = PreparedStatement r = 每一个元素
这里执行批量写入，然后清空ArrayList容器！

总结

• JdbcExecutionOptions 可以配置 批量写入间隔时间 最大写入数量 和 异常容错次数（只支持sql异常）
• JdbcConnectionOptions 可以配置数据库的连接参数
• 关闭定时写入可以把 BatchIntervalMs设置为0
• 实时写入可以把 BatchSize 设置为1
• 间隔时间 或者 最大写入数 或者 触发检查点的时候 这三个地方 会触发写入批量写入jdbc
• 未开启检查点可能会丢失数据的，开启了检查点需要保证数据库幂等性插入因为可能会重复插入！