Kafka - 3 客户端工作机制2

//1.记录累加器
int batchSize = Math.max(1, config.getInt(ProducerConfig.BATCH_SIZE_CONFIG));
this.accumulator = new RecordAccumulator(logContext,batchSize,this.compressionType,lingerMs(config),retryBackoffMs,deliveryTimeoutMs, partitionerConfig,metrics,PRODUCER_METRIC_GROUP_NAME,time,apiVersions,transactionManager,new BufferPool(this.totalMemorySize, batchSize, metrics, time, PRODUCER_METRIC_GROUP_NAME));
//2. 数据发送线程
this.sender = newSender(logContext, kafkaClient, this.metadata);

RecordAccumulator.RecordAppendResult result = this.accumulator.append(record.topic(), partition, timestamp, serializedKey, serializedValue, headers, appendCallbacks, remainingWaitMs, abortOnNewBatch, nowMs, cluster);

//RecordAccumulator缓冲区大小
public static final String BUFFER_MEMORY_CONFIG = "buffer.memory";
private static final String BUFFER_MEMORY_DOC = "The total bytes of memory the producer can use to buffer records waiting to be sent to the server." + 
"If records are sent faster than they can be delivered to the server the producer will block for <code>max.block.ms</code> after which it will throw an exception." + 
"<p>This setting should correspond roughly to the total memory the producer will use, but is not a hard bound since not all memory the producer uses is used for buffering." + 
"Some additional memory will be used for compression (if compression is enabled) as well as for maintaining in-flight requests.";


//缓冲区每一个batch的大小
public static final String BATCH_SIZE_CONFIG = "batch.size";
private static final String BATCH_SIZE_DOC = "The producer will attempt to batch records together into fewer requests whenever multiple records are being sent to the same partition."+
"This helps performance on both the client and the server. This configuration controls the default batch size in bytes." + 
"<p>No attempt will be made to batch records larger than this size."+
"<p>Requests sent to brokers will contain multiple batches, one for each partition with data available to be sent.<p>"+
"A small batch size will make batching less common and may reduce throughput (a batch size of zero will disable batching entirely)."+
"A very large batch size may use memory a bit more wastefully as we will always allocate a buffer of the specified batch size in anticipation of additional records."+
"<p>Note: This setting gives the upper bound of the batch size to be sent."+
"If we have fewer than this many bytes accumulated for this partition, we will 'linger' for the <code>linger.ms</code> time waiting for more records to show up."+
"This <code>linger.ms</code> setting defaults to 0, which means we'll immediately send out a record even the accumulated batch size is under this <code>batch.size</code> setting.";

//org.apache.kafka.clients.producer.KafkaProducer#doSend
if (result.batchIsFull || result.newBatchCreated) {
  log.trace("Waking up the sender since topic {} partition {} is either full or getting a new batch", record.topic(), appendCallbacks.getPartition());
  this.sender.wakeup();
}

public static final String LINGER_MS_CONFIG = "linger.ms";
private static final String LINGER_MS_DOC = "The producer groups together any records that arrive in between request transmissions into a single batched request. Normally this occurs only under load when records arrive faster than they can be sent out. However in some circumstances the client may want to reduce the number of requests even under moderate load. This setting accomplishes this by adding a small amount of artificial delay&mdash;that is, rather than immediately sending out a record, the producer will wait for up to the given delay to allow other records to be sent so that the sends can be batched together. This can be thought of as analogous to Nagle's algorithm in TCP. This setting gives the upper bound on the delay for batching: once we get <code>batch.size</code> worth of records for a partition it will be sent immediately regardless of this setting, however if we have fewer than this many bytes accumulated for this partition we will 'linger' for the specified time waiting for more records to show up. This setting defaults to 0 (i.e. no delay). Setting <code>linger.ms=5</code>, for example, would have the effect of reducing the number of requests sent but would add up to 5ms of latency to records sent in the absence of load.";

private static final int MAX_IN_FLIGHT_REQUESTS_PER_CONNECTION_FOR_IDEMPOTENCE = 5;
public static final String MAX_IN_FLIGHT_REQUESTS_PER_CONNECTION = "max.in.flight.requests.per.connection";
private static final String MAX_IN_FLIGHT_REQUESTS_PER_CONNECTION_DOC = "The maximum number of unacknowledged requests the client will send on a single connection before blocking."+
"Note that if this configuration is set to be greater than 1 and <code>enable.idempotence</code> is set to false, there is a risk of message reordering after a failed send due to retries (i.e., if retries are enabled);"+
"if retries are disabled or if <code>enable.idempotence</code> is set to true, ordering will be preserved."+
"Additionally, enabling idempotence requires the value of this configuration to be less than or equal to 5."+
"If conflicting configurations are set and idempotence is not explicitly enabled, idempotence is disabled. ";

public static final String ACKS_CONFIG = "acks";
private static final String ACKS_DOC = "The number of acknowledgments the producer requires the leader to have received before considering a request complete."+
"This controls the  durability of records that are sent. The following settings are allowed:"+
"<ul>"+
"<li><code>acks=0</code> If set to zero then the producer will not wait for any acknowledgment from the server at all."+
"The record will be immediately added to the socket buffer and considered sent."+
"No guarantee can be made that the server has received the record in this case,"+
"and the <code>retries</code> configuration will not take effect (as the client won't generally know of any failures)."+
"The offset given back for each record will always be set to <code>-1</code>."+
"<li><code>acks=1</code> This will mean the leader will write the record to its local log but will respond without awaiting full acknowledgement from all followers."+
"In this case should the leader fail immediately after acknowledging the record but before the followers have replicated it then the record will be lost."+
"<li><code>acks=all</code> This means the leader will wait for the full set of in-sync replicas to acknowledge the record."+
"This guarantees that the record will not be lost as long as at least one in-sync replica remains alive."+
"This is the strongest available guarantee. This is equivalent to the acks=-1 setting.</ul>"+
"<p>Note that enabling idempotence requires this config value to be 'all'."+
"If conflicting configurations are set and idempotence is not explicitly enabled, idempotence is disabled.";

RecordMetadata recordMetadata = producer.send(record).get();

public static final String ENABLE_IDEMPOTENCE_CONFIG = "enable.idempotence";
public static final String ENABLE_IDEMPOTENCE_DOC = "When set to 'true', the producer will ensure that exactly one copy of each message is written in the stream."+ 
"If 'false', producer retries due to broker failures, etc., may write duplicates of the retried message in the stream."+
"Note that enabling idempotence"+
"requires <code>max.in.flight.requests.per.connection</code> to be less than or equal to 5 (with message ordering preserved for any allowable value),"+
"<code>retries</code> to be greater than 0, and <code>acks</code> must be 'all'. <p>"+
"Idempotence is enabled by default if no conflicting configurations are set."+
"If conflicting configurations are set and idempotence is not explicitly enabled, idempotence is disabled."+
"If idempotence is explicitly enabled and conflicting configurations are set, a <code>ConfigException</code> is thrown.";

public static final String COMPRESSION_TYPE_CONFIG = "compression.type";
private static final String COMPRESSION_TYPE_DOC = "The compression type for all data generated by the producer. The default is none (i.e. no compression). Valid  values are <code>none</code>, <code>gzip</code>, <code>snappy</code>, <code>lz4</code>, or <code>zstd</code>. Compression is of full batches of data, so the efficacy of batching will also impact the compression ratio (more batching means better compression).";

// 1 初始化事务
void initTransactions();
// 2 开启事务
void beginTransaction() throws ProducerFencedException;
// 3 提交事务
void commitTransaction() throws ProducerFencedException;
// 4 放弃事务（类似于回滚事务的操作）
void abortTransaction() throws ProducerFencedException;

public class TransactionErrorDemo {
  private static final String BOOTSTRAP_SERVERS = "worker1:9092,worker2:9092,worker3:9092";
  private static final String TOPIC = "disTopic";

  public static void main(String[] args) throws ExecutionException, InterruptedException {
      Properties props = new Properties();
      // 此处配置的是kafka的端口
      props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, BOOTSTRAP_SERVERS);
      // 事务ID
      props.put(ProducerConfig.TRANSACTIONAL_ID_CONFIG,"111");
      // 配置key的序列化类
      props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG,"org.apache.kafka.common.serialization.StringSerializer");
      // 配置value的序列化类
      props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,"org.apache.kafka.common.serialization.StringSerializer");

      Producer<String,String> producer = new KafkaProducer<>(props);
      producer.initTransactions();
      producer.beginTransaction();
      for(int i = 0; i < 5; i++) {
          ProducerRecord<String, String> record = new ProducerRecord<>(TOPIC, Integer.toString(i), "MyProducer" + i);
          //异步发送。
          producer.send(record);
          if(i == 3){
              //第三条消息放弃事务之后，整个这一批消息都回退了。
              System.out.println("error");
              producer.abortTransaction();
          }
      }
      System.out.println("message sended");
      try {
          Thread.sleep(10000);
      } catch (Exception e) {
          e.printStackTrace();
      }
    //producer.commitTransaction();
      producer.close();
  }
}

public class TransactionProducer {
  private static final String BOOTSTRAP_SERVERS = "worker1:9092,worker2:9092,worker3:9092";
  private static final String TOPIC = "disTopic";
  public static void main(String[] args) throws ExecutionException, InterruptedException {
      Properties props = new Properties();
      // 此处配置的是kafka的端口
      props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, BOOTSTRAP_SERVERS);
      // 事务ID。
      props.put(ProducerConfig.TRANSACTIONAL_ID_CONFIG,"111");
      // 配置key的序列化类
      props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG,"org.apache.kafka.common.serialization.StringSerializer");
      // 配置value的序列化类
      props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,"org.apache.kafka.common.serialization.StringSerializer");

      Producer<String,String> producer = new KafkaProducer<>(props);
      producer.initTransactions();
      producer.beginTransaction();
      try{
          for(int i = 0; i < 5; i++) {
              ProducerRecord<String, String> record = new ProducerRecord<>(TOPIC, Integer.toString(i), "MyProducer" + i);
              //异步发送。
              producer.send(record);
          }
          producer.commitTransaction();
      }catch (ProducerFencedException e){
          producer.abortTransaction();
      }finally {
          producer.close();
      }
  }
}