Java KafkaProducer.close方法代码示例

import org.apache.kafka.clients.producer.KafkaProducer; //导入方法依赖的package包/类
public static void main(String[] args) throws InterruptedException, IOException {
    UncaughtExceptionHandling.setup();

    KafkaProducer<ByteBuffer, ByteBuffer> msgProducer = KAFKA_CLIENTS
            .createProducer(ByteBufferSerializer.class, ByteBufferSerializer.class);

    LOG.info("Sending ...");

    for(int i = 0; i < TOTAL_MSGS; i++) {
        ByteBuffer data = ByteBuffer.allocate(4).putInt(i);
        msgProducer.send(new ProducerRecord<>(KMQ_CONFIG.getMsgTopic(), data));
        try { Thread.sleep(100L); } catch (InterruptedException e) { throw new RuntimeException(e); }
        LOG.info(String.format("Sent message %d", i));
    }

    msgProducer.close();

    LOG.info("Sent");
}
 

import org.apache.kafka.clients.producer.KafkaProducer; //导入方法依赖的package包/类
public void createProducer(String bootstrapServer) {
  long numberOfEvents = 5;

  Properties props = new Properties();
  props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServer);
  props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
  props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);

  KafkaProducer<String, String> producer = new KafkaProducer<>(
      props);

  for (int i = 0; i < numberOfEvents; i++) {
    String key = "testContainers";
    String value = "AreAwesome";
    ProducerRecord<String, String> record = new ProducerRecord<>(
        "hello_world_topic", key, value);
    try {
      producer.send(record).get();
    } catch (InterruptedException | ExecutionException e) {
      e.printStackTrace();
    }
    System.out.printf("key = %s, value = %s\n", key, value);
  }

  producer.close();
}
 

import org.apache.kafka.clients.producer.KafkaProducer; //导入方法依赖的package包/类
public static void main(final String[] args) {
    Properties producerProps = new Properties();
    producerProps.put("bootstrap.servers", "localhost:9092");
    producerProps.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
    producerProps.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
    producerProps.put("acks", "all");
    producerProps.put("retries", 1);
    producerProps.put("batch.size", 20000);
    producerProps.put("linger.ms", 1);
    producerProps.put("buffer.memory", 24568545);
    KafkaProducer<String, String> producer = new KafkaProducer<String, String>(producerProps);

    for (int i = 0; i < 2000; i++) {
        ProducerRecord data = new ProducerRecord<String, String>("test1", "Hello this is record " + i);
        Future<RecordMetadata> recordMetadata = producer.send(data);
    }
    producer.close();
}
 

import org.apache.kafka.clients.producer.KafkaProducer; //导入方法依赖的package包/类
public static void main(String[] args) {

		if (args.length < 1) {
			System.out.println("Provide number of vehicle");
			System.exit(1);
		}

		// Number of vehicles for which data needs to be generated.
		int numberOfvehicle = Integer.parseInt(args[0]);

		// Get producer to push data into Kafka
		KafkaProducer<Integer, String> producer = configureKafka();

		// Get vehicle start point.
		Map<String, Location> vehicleStartPoint = getVehicleStartPoints(numberOfvehicle);
		
		// Push data into Kafka
		pushVehicleStartPointToKafka(vehicleStartPoint, producer);

		producer.close();
	}
 

import org.apache.kafka.clients.producer.KafkaProducer; //导入方法依赖的package包/类
public static void main(String[] args) {

		if (args.length < 2) {
			System.out.println("Provide total number of records and range of distance from start point");
			System.exit(1);
		}

		//Total number of records this simulator will generate
		int totalNumberOfRecords = Integer.parseInt(args[0]);
		
		//Distance in meters as Radius
		int distanceFromVehicleStartPoint = Integer.parseInt(args[1]);

		// Get Kafka producer
		KafkaProducer<Integer, String> producer = configureKafka();

		// Get Vehicle Start Points
		Map<String, Location> vehicleStartPoint = getVehicleStartPoints();
		
		// Generate data within distance and push to Kafka
		generateDataAndPushToKafka(producer, vehicleStartPoint.size(), totalNumberOfRecords,
				distanceFromVehicleStartPoint, vehicleStartPoint);
		
		producer.close();
	}
 

import org.apache.kafka.clients.producer.KafkaProducer; //导入方法依赖的package包/类
/**
	 * @param args
	 */
	public static void main(String[] args) {
		
		Properties props=new Properties();
		props.put("bootstrap.servers", "localhost:9092,localhost:9093");
		props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
		props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
		
		KafkaProducer<String,String> sampleProducer= new KafkaProducer<String,String>(props);
		
//		ProducerRecord<String, String> record = new ProducerRecord<String, String>(topicName, value);		
//		sampleProducer.send(record);
		for (int i = 0; i < 10; i++)
			sampleProducer.send(new ProducerRecord<String, String>("demo-topic1","Data:"+ Integer.toString(i)));
		sampleProducer.close();
	}
 

import org.apache.kafka.clients.producer.KafkaProducer; //导入方法依赖的package包/类
public void publishDummyDataNumbers() {
    final String topic = "NumbersTopic";

    // Create publisher
    final Map<String, Object> config = new HashMap<>();
    config.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, IntegerSerializer.class);
    config.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, IntegerSerializer.class);
    config.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");

    final KafkaProducer<Integer, Integer> producer = new KafkaProducer<>(config);
    for (int value = 0; value < 10000; value++) {
        producer.send(new ProducerRecord<>(topic, value, value));
    }
    producer.flush();
    producer.close();
}
 

import org.apache.kafka.clients.producer.KafkaProducer; //导入方法依赖的package包/类
public static void main(String[] args) {
    Properties props = new Properties();
    props.put("bootstrap.servers", "localhost:9092");
    props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
    props.put("value.serializer", "org.apache.kafka.common.serialization.LongSerializer");
    props.put("linger.ms", 0);

    KafkaProducer<String, Long> producer = new KafkaProducer<>(props);

    for(int i=0; i < 10000; i++){
        String ip = "127.0.0." + i % 10;
        System.out.println(ip);
        producer.send(new ProducerRecord<>("visits", ip, System.currentTimeMillis() + i));
    }

    producer.close();

}
 

import org.apache.kafka.clients.producer.KafkaProducer; //导入方法依赖的package包/类
private static void sendMessages(KafkaClients clients, KmqConfig kmqConfig) {
    KafkaProducer<ByteBuffer, ByteBuffer> msgProducer = clients.createProducer(ByteBufferSerializer.class, ByteBufferSerializer.class);

    LOG.info("Sending ...");

    for(int i = 0; i < TOTAL_MSGS; i++) {
        ByteBuffer data = ByteBuffer.allocate(4).putInt(i);
        msgProducer.send(new ProducerRecord<>(kmqConfig.getMsgTopic(), data));
        try { Thread.sleep(100L); } catch (InterruptedException e) { throw new RuntimeException(e); }
    }

    msgProducer.close();

    LOG.info("Sent");
}
 

import org.apache.kafka.clients.producer.KafkaProducer; //导入方法依赖的package包/类
public static void main(String args[]) {
	Properties properties = new Properties();
	 
	properties.put("bootstrap.servers", "localhost:9092");
	properties.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
	properties.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
	properties.put("acks", "1");
	 
	KafkaProducer<Integer, String> producer = new KafkaProducer<Integer, String>(properties);
	int counter =0;
	int nbrOfEventsRequired = Integer.parseInt(args[0]);
	while (counter<nbrOfEventsRequired) {
		StringBuffer stream = new StringBuffer();
		
		long phoneNumber = ThreadLocalRandom.current().nextLong(9999999950l,
				9999999999l);
		int bin = ThreadLocalRandom.current().nextInt(100000, 9999999);
		int bout = ThreadLocalRandom.current().nextInt(100000, 9999999);
		
		stream.append(phoneNumber);
		stream.append(",");
		stream.append(bin);
		stream.append(",");
		stream.append(bout);
		stream.append(",");
		stream.append(System.currentTimeMillis());

		System.out.println(stream.toString());
		ProducerRecord<Integer, String> data = new ProducerRecord<Integer, String>(
				"device-data", stream.toString());
		producer.send(data);
		counter++;
	}
	
	producer.close();
}
 

import org.apache.kafka.clients.producer.KafkaProducer; //导入方法依赖的package包/类
public static void main(String args[]) {
	Properties properties = new Properties();
	 
	properties.put("bootstrap.servers", "localhost:9092");
	properties.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
	properties.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
	properties.put("acks", "1");
	 
	KafkaProducer<Integer, String> producer = new KafkaProducer<Integer, String>(properties);
	int counter =0;
	int nbrOfEventsRequired = Integer.parseInt(args[0]);
	while (counter<nbrOfEventsRequired) {
		StringBuffer stream = new StringBuffer();
		
		long phoneNumber = ThreadLocalRandom.current().nextLong(9999999950l,
				9999999960l);
		int bin = ThreadLocalRandom.current().nextInt(1000, 9999);
		int bout = ThreadLocalRandom.current().nextInt(1000, 9999);
		
		stream.append(phoneNumber);
		stream.append(",");
		stream.append(bin);
		stream.append(",");
		stream.append(bout);
		stream.append(",");
		stream.append(new Date(ThreadLocalRandom.current().nextLong()));

		System.out.println(stream.toString());
		ProducerRecord<Integer, String> data = new ProducerRecord<Integer, String>(
				"storm-trident-diy", stream.toString());
		producer.send(data);
		counter++;
	}
	
	producer.close();
}
 

import org.apache.kafka.clients.producer.KafkaProducer; //导入方法依赖的package包/类
public void run(String brokers, long amount, long delay) throws IOException {
    // set up the producer
    KafkaProducer<String, String> producer;
    try (InputStream props = Resources.getResource("producer.props").openStream()) {
        Properties properties = new Properties();
        properties.load(props);

        if (brokers != null && !brokers.isEmpty()) {
            properties.put("bootstrap.servers", brokers);
        }

        producer = new KafkaProducer<>(properties);
    }

    try {
        for (int i = 0; i < amount; i++) {
            // send lots of messages
            Date t = new Date();
            producer.send(new ProducerRecord<String, String>(
                    "fast-messages", String.valueOf(i),
                    String.format("{\"type\":\"test\", \"t\":%d, \"k\":%d}", t.getTime(), i)));
            System.out.println("Sent msg number " + i);
            if (delay > 0) {
                Thread.sleep(delay);
            }
        }
    } catch (Throwable throwable) {
        System.out.printf("%s", throwable.getStackTrace());
    } finally {
        producer.close();
    }
}
 

import org.apache.kafka.clients.producer.KafkaProducer; //导入方法依赖的package包/类
static void generate(final String kafka) throws Exception {

        Runtime.getRuntime().addShutdownHook(new Thread() {
            @Override
            public void run() {
                isRunning = false;
            }
        });

        final Properties producerProps = new Properties();
        producerProps.put(ProducerConfig.CLIENT_ID_CONFIG, "SmokeTest");
        producerProps.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, kafka);
        producerProps.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        producerProps.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, IntegerSerializer.class);
        producerProps.put(ProducerConfig.ENABLE_IDEMPOTENCE_CONFIG, true);

        final KafkaProducer<String, Integer> producer = new KafkaProducer<>(producerProps);

        final Random rand = new Random(System.currentTimeMillis());

        int numRecordsProduced = 0;
        while (isRunning) {
            final String key = "" + rand.nextInt(MAX_NUMBER_OF_KEYS);
            final int value = rand.nextInt(10000);

            final ProducerRecord<String, Integer> record = new ProducerRecord<>("data", key, value);

            producer.send(record, new Callback() {
                @Override
                public void onCompletion(final RecordMetadata metadata, final Exception exception) {
                    if (exception != null) {
                        exception.printStackTrace();
                        Exit.exit(1);
                    }
                }
            });

            numRecordsProduced++;
            if (numRecordsProduced % 1000 == 0) {
                System.out.println(numRecordsProduced + " records produced");
            }
            Utils.sleep(rand.nextInt(50));
        }
        producer.close();
        System.out.println(numRecordsProduced + " records produced");
    }
 

import org.apache.kafka.clients.producer.KafkaProducer; //导入方法依赖的package包/类
public void sendMessage(String msg) {
    KafkaProducer<String,String> producer = new KafkaProducer<String, String>(properties);
    ProducerRecord<String,String> record = new ProducerRecord<String, String>(properties.getProperty("topic"),msg);
    producer.send(record);
    producer.close();
}
 

import org.apache.kafka.clients.producer.KafkaProducer; //导入方法依赖的package包/类
public static void step( int start
                       , int end
                       , DemoConfig config
                       , KafkaProducer<String, String> producer
                       , Long timeOffset
                       , Integer stepTimeMs
                       , Set<String> hostnameFilter
                       ) throws IOException, InterruptedException {
  List<SourceState> states = new ArrayList<>();
  for(DemoConfig.DataSource ds : config.getSources()) {
    BufferedReader reader = null;
    if(ds.getInputFile().endsWith(".gz")) {
      reader = new BufferedReader(new InputStreamReader(new GZIPInputStream(new FileInputStream(ds.getInputFile())), Charset.defaultCharset()));
    }
    else {
      reader = Files.newBufferedReader(new File(ds.getInputFile()).toPath(), Charset.defaultCharset());
    }
    states.add(new SourceState(ds, reader));
  }
  LocalImporter.Progress progress = new LocalImporter.Progress();
  try {
    for (int index = start; index <= end; ++index) {
      progress.update();
      boolean allDone = true;
      long sTime = System.currentTimeMillis();
      int numMessagesWritten = 0;
      for (SourceState s : states) {
        String fileName = toFileName(s.getSource().getInputFile());
        List<Map<String, Object>> messages = s.read(index);
        for (Map<String, Object> message : messages) {
          int timestamp = Integer.parseInt("" + message.get("timestamp"));
          message.put("time_offset", timestamp);
          message.put("source_file", fileName);
          message.put("timestamp", 1000L*timestamp + timeOffset);
          if(matchesFilter(s.getSource(), hostnameFilter, message)) {
            String jsonMap = JSONUtils.INSTANCE.toJSON(message, false);
            if(producer != null) {
              numMessagesWritten++;
              producer.send(new ProducerRecord<String, String>(s.getSource().getOutputTopic(), jsonMap));
            }
            else {
              System.out.println(jsonMap);
            }
          }
        }
        allDone &= s.allDone;
      }
      if(allDone) {
        break;
      }
      else if(numMessagesWritten > 0 && producer != null){
        long eTime = System.currentTimeMillis();
        long durationMs = eTime - sTime;
        if(durationMs < stepTimeMs) {
          long msSleeping = stepTimeMs - durationMs;
          Thread.sleep(msSleeping);
        }
      }
    }
  }
  finally {
    if(producer != null) {
      producer.close();
    }
  }
}