Kafka——SpringBoot整合（生产者）

目录

• pom
• 生产者配置文件
  • application.properties
  • javaConfig
  • 事务性javaConfig配置
• Controller
  • 异步不回调发送方式
  • 异步带回调信息
  • 同步发送
  • 事务式发送

生产者根据不同的业户需求和性能需求，选择合适的发送方式，可以达到最大效率。
具体选择哪一种发送方式，要考虑实际的业务场景。
简单来说：
1、保存用户点击情况、不重要的日志分析等大频率储存，但不担心丢失的情况下使用异步发送
2、订单、支付信息，信息量不一定很多，但是非常重要，就需要采取同步发送或者异步带回调发送，对发送结果进行必要处理。

pom

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.kafka</groupId>
            <artifactId>kafka-streams</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.kafka</groupId>
            <artifactId>spring-kafka</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.springframework.kafka</groupId>
            <artifactId>spring-kafka-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
            <version>2.8.2</version>
        </dependency>

生产者配置文件

这里也可以在application.xxx进行参数配置，不过使用java配置文件的方式使配置更加直观，建议使用java配置
具体的参数配置可以查看以前的博客文章kafka生产者参数配置。https://www.cnblogs.com/luckyhui28/p/12001798.html

application.properties

# 指定kafka 代理地址，可以多个
kafka.bootstrap-servers=192.168.32.11:9092

javaConfig

@Configuration
public class KafkaProducerConfig {
    @Value("${kafka.bootstrap-servers}")
    private String bootstrapServers;

    /**
     * 生产者配置
     * @return
     */
    private Map<String, Object> configs() {
        Map<String, Object> props = new HashMap<>();
        // 连接地址
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServers);
        // 键的序列化方式
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        // 值的序列化方式
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        // 重试，0为不启用重试机制
        props.put(ProducerConfig.RETRIES_CONFIG, 1);
        // 控制批处理大小，单位为字节
        props.put(ProducerConfig.BATCH_SIZE_CONFIG, 16384);
        // 批量发送，延迟为1毫秒，启用该功能能有效减少生产者发送消息次数，从而提高并发量
        props.put(ProducerConfig.LINGER_MS_CONFIG, 1);
        // 生产者可以使用的总内存字节来缓冲等待发送到服务器的记录
        props.put(ProducerConfig.BUFFER_MEMORY_CONFIG, 1024000);
        return props;
    }


    @Bean
    public ProducerFactory<String, String> producerFactory() {
        DefaultKafkaProducerFactory factory = new DefaultKafkaProducerFactory<>(configs());
        return factory;
    }
    @Primary
    @Bean("producertemplate")
    public KafkaTemplate<String, String> producertemplate() {
        KafkaTemplate template = new KafkaTemplate<String, String>(producerFactory());
        return template;
    }

}

事务性javaConfig配置

@Configuration
public class KafkaTransactionalProducerConfig {

    @Value("${kafka.bootstrap-servers}")
    private String bootstrapServers;


    /**
     * 生产者配置
     * @return
     */
    private Map<String, Object> configs() {
        Map<String, Object> props = new HashMap<>();
        // 连接地址
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServers);
        // 键的序列化方式
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        // 值的序列化方式
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        // 重试，0为不启用重试机制
        props.put(ProducerConfig.RETRIES_CONFIG, 1);
        // 控制批处理大小，单位为字节
        props.put(ProducerConfig.BATCH_SIZE_CONFIG, 16384);
        // 批量发送，延迟为1毫秒，启用该功能能有效减少生产者发送消息次数，从而提高并发量
        props.put(ProducerConfig.LINGER_MS_CONFIG, 1);
        // 生产者可以使用的总内存字节来缓冲等待发送到服务器的记录
        props.put(ProducerConfig.BUFFER_MEMORY_CONFIG, 1024000);
        return props;
    }



    @Bean
    public ProducerFactory<String, String> transactionalProducerFactory() {
        DefaultKafkaProducerFactory factory = new DefaultKafkaProducerFactory<>(configs());
        // 开启事务
        factory.transactionCapable();
        // 用来生成Transactional.id的前缀
        factory.setTransactionIdPrefix("tran-");
        return factory;
    }


    /**
     * 事务管理器
     * @param transactionalProducerFactory
     * @return
     */
    @Bean
    public KafkaTransactionManager transactionManager(ProducerFactory transactionalProducerFactory) {
        KafkaTransactionManager manager = new KafkaTransactionManager(transactionalProducerFactory);
        return manager;
    }

    @Bean("transactionalTemplate")
    public KafkaTemplate<String, String> transactionalTemplate() {
        KafkaTemplate template = new KafkaTemplate<String, String>(transactionalProducerFactory());
        return template;
    }
}

Controller

@Controller
public class KafkaTestController {

	private static Logger logger = LoggerFactory.getLogger(KafkaTestController.class);

	@Autowired
	@Qualifier("producertemplate")
	private KafkaTemplate<String, String> producertemplate;

	@Autowired
	@Qualifier("transactionalTemplate")
	private KafkaTemplate<String, String> transactionalTemplate;

	private Gson gson = new GsonBuilder().create();
}

异步不回调发送方式

发送既忘，只管消息发送，不论结果。多使用不重要的业务信息

	@RequestMapping("/testSendMsg1")
	@ResponseBody
	public String testSendMsg1(){ //发送既忘方式发送消息，在发送消息后并不关心消息是否正确到达。这种方法方式的性能最高，可靠性最差。
		Message message = new Message();
		message.setId(1);
		message.setMsg("testSendMsg1");
		message.setSendTime(new Date());
		logger.info("发送消息(发送既忘) ----->>>>>  message = {}", gson.toJson(message));
		producertemplate.send("hello", gson.toJson(message));
		return "testSendMsg1";
	}

异步带回调信息

带有回调结果，根据发送结果进行后期处理

	@RequestMapping("/testSendMsg3")
	@ResponseBody
	public String testSendMsg3(){ //异步发送，异步发送一般是在sned（）方法里指定一个CallBack的回调函数，Kafka在返回响应时调用该函数来实现异步的发送确认。
		Message message = new Message();
		message.setId(1);
		message.setMsg("testSendMsg1");
		message.setSendTime(new Date());
		logger.info("发送消息(异步发送) ----->>>>>  message = {}", gson.toJson(message));
		producertemplate.send("hello", gson.toJson(message)).addCallback(new ListenableFutureCallback<SendResult<String, String>>() {
			@Override
			public void onFailure(Throwable throwable) {
				logger.error("发送发生错误：" + throwable.getMessage());
			}

			@Override
			public void onSuccess(SendResult<String, String> stringStringSendResult) {
				logger.info("消息发送成功");
				//生产者发送的元数据信息
				ProducerRecord<String, String> producerRecord = stringStringSendResult.getProducerRecord();
				logger.info("生产者发送元信息 ：" );
				String topic = producerRecord.topic();
				logger.info("主题 ：" + topic );
				String value = producerRecord.value();
				logger.info("信息 ：" + value );
				Integer partition = producerRecord.partition();
				logger.info("分区 ：" + partition );
				String key = producerRecord.key();
				logger.info("键 ：" + key );
				Long timestamp = producerRecord.timestamp();
				logger.info("时间戳 ：" + timestamp );
				//返回结果元信息
				RecordMetadata recordMetadata = stringStringSendResult.getRecordMetadata();
				logger.info("生产者返回结果元信息 ：" );
				String topic1 = recordMetadata.topic();
				logger.info("主题 ：" + topic1 );
				int partition1 = recordMetadata.partition();
				logger.info("分区 ：" + partition1 );
				long offset = recordMetadata.offset();
				logger.info("位移 ：" + offset );
				boolean b = recordMetadata.hasOffset();
				logger.info("是否返回位移信息 ：" + b );
				long timestamp1 = recordMetadata.timestamp();
				logger.info("时间戳 ：" + timestamp1 );
				boolean b1 = recordMetadata.hasTimestamp();
				logger.info("是否返回时间戳 ：" + b1 );
				int i = recordMetadata.serializedKeySize();
				logger.info("序列化后键大小 ：" + i );
				int i1 = recordMetadata.serializedValueSize();
				logger.info("序列化后值大小 ：" + i1 );
			}
		});
		return "testSendMsg3";
	}

同步发送

阻塞式，同步发送方式发送消息，利用返回的Fature对象实现。

	@RequestMapping("/testSendMsg2")
	@ResponseBody
	public String testSendMsg2(){ //同步发送方式发送消息，利用返回的Fature对象实现。。
		Message message = new Message();
		message.setId(1);
		message.setMsg("testSendMsg2");
		message.setSendTime(new Date());
		logger.info("发送消息(同步发送) ----->>>>>  message = {}", gson.toJson(message));

		SendResult<String, String> sendResult = null;
		try {
			sendResult = producertemplate.send("hello", gson.toJson(message)).get();
		} catch (InterruptedException e) {
			e.printStackTrace();
		} catch (ExecutionException e) {
			e.printStackTrace();
		}


		//生产者发送的元数据信息
		ProducerRecord<String, String> producerRecord = sendResult.getProducerRecord();
		logger.info("生产者发送元信息 ：" );
		String topic = producerRecord.topic();
		logger.info("主题 ：" + topic );
		String value = producerRecord.value();
		logger.info("信息 ：" + value );
		Integer partition = producerRecord.partition();
		logger.info("分区 ：" + partition );
		String key = producerRecord.key();
		logger.info("键 ：" + key );
		Long timestamp = producerRecord.timestamp();
		logger.info("时间戳 ：" + timestamp );



		//返回结果元信息
		RecordMetadata recordMetadata = sendResult.getRecordMetadata();
		logger.info("生产者返回结果元信息 ：" );
		String topic1 = recordMetadata.topic();
		logger.info("主题 ：" + topic1 );
		int partition1 = recordMetadata.partition();
		logger.info("分区 ：" + partition1 );
		long offset = recordMetadata.offset();
		logger.info("位移 ：" + offset );
		boolean b = recordMetadata.hasOffset();
		logger.info("是否返回位移信息 ：" + b );
		long timestamp1 = recordMetadata.timestamp();
		logger.info("时间戳 ：" + timestamp1 );
		boolean b1 = recordMetadata.hasTimestamp();
		logger.info("是否返回时间戳 ：" + b1 );
		int i = recordMetadata.serializedKeySize();
		logger.info("序列化后键大小 ：" + i );
		int i1 = recordMetadata.serializedValueSize();
		logger.info("序列化后值大小 ：" + i1 );


		return "testSendMsg2";
	}

事务式发送

多用于发送多条信息，若有异常全部失败

	@RequestMapping("/testSendMsg4")
	@ResponseBody
	@Transactional
	public String testSendMsg5(){ //事务发送
		Message message = new Message();
		message.setId(1);
		message.setMsg("testSendMsg4");
		message.setSendTime(new Date());
		logger.info("发送消息(事务发送) ----->>>>>  message = {}", gson.toJson(message));
		
		transactionalTemplate.send("hello", gson.toJson(message));

		int i = 1/0;


		return "testSendMsg4";
	}