SpringBoot之Kafka官方案例分析

最新推荐文章于 2024-07-26 16:48:44 发布

给我一个自信的表情

最新推荐文章于 2024-07-26 16:48:44 发布

阅读量877

点赞数

分类专栏： Kafka 文章标签： kafka

本文链接：https://blog.csdn.net/ld3205/article/details/103516378

版权

Kafka 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

代码来自Kafka官方网站:https://github.com/spring-projects/spring-kafka/tree/master/samples/sample-03

ConcurrentKafkaListenerContainerFactory工厂

	@Bean
	public ConcurrentKafkaListenerContainerFactory<?, ?> kafkaListenerContainerFactory(
			ConcurrentKafkaListenerContainerFactoryConfigurer configurer,
			ConsumerFactory kafkaConsumerFactory) {
		ConcurrentKafkaListenerContainerFactory<Object, Object> factory =
				new ConcurrentKafkaListenerContainerFactory<>();
		configurer.configure(factory, kafkaConsumerFactory);
		factory.setBatchListener(true);
		factory.setMessageConverter(batchConverter());
		return factory;
	}

源码分析：

ConcurrentKafkaListenerContainerFactory：并发Kafka监听器容器工厂类

public class ConcurrentKafkaListenerContainerFactory<K, V>
		extends AbstractKafkaListenerContainerFactory<ConcurrentMessageListenerContainer<K, V>, K, V>

该工厂类负责容器的创建，初始化容器，其父类有ContainerProperties（容器的属性），ConsumerFactory（消费工厂类），MessageConverter（消息转换），KafkaTemplate（Kafka模板）。

ConcurrentKafkaListenerContainerFactoryConfigurer ：并发Kafka监听器容器工厂的配置类：

public class ConcurrentKafkaListenerContainerFactoryConfigurer

该类的属性有：KafkaProperties，MessageConverter，KafkaTemplate等，用来进行容器配置。

ConsumerFactory ：Kafka消费者类工厂

public interface ConsumerFactory<K, V> 

其实现类：

public class DefaultKafkaConsumerFactory<K, V> implements ConsumerFactory<K, V>

DefaultKafkaConsumerFactory该类有：

private final Map<String, Object> configs;
private Supplier<Deserializer<K>> keyDeserializerSupplier;
private Supplier<Deserializer<V>> valueDeserializerSupplier;
public DefaultKafkaConsumerFactory(Map<String, Object> configs) 	
//一系列创建createConsumer的方法
public Consumer<K, V> createConsumer(...)

主要方法：Application类-configure(...)

configurer.configure(factory, kafkaConsumerFactory);
==》
public void configure(ConcurrentKafkaListenerContainerFactory<Object, Object> listenerFactory,
			ConsumerFactory<Object, Object> consumerFactory) {
		listenerFactory.setConsumerFactory(consumerFactory);
		configureListenerFactory(listenerFactory);
		configureContainer(listenerFactory.getContainerProperties());
}

该方法接受一个ConcurrentKafkaListenerContainerFactory形参和ConsumerFactory形参，configure方法实现ConcurrentKafkaListenerContainerFactory的配置，来绑定ConsumerFactory，并对configureListenerFactory进行配置以及配置容器。

listenerFactory.setConsumerFactory(...)

public void setConsumerFactory(ConsumerFactory<? super K, ? super V> consumerFactory) {
		this.consumerFactory = consumerFactory;
	}

设置ConcurrentKafkaListenerContainerFactory的consumer对象；

configureListenerFactory(...)

private void configureListenerFactory(ConcurrentKafkaListenerContainerFactory<Object, Object> factory) {
		PropertyMapper map = PropertyMapper.get().alwaysApplyingWhenNonNull();
		Listener properties = this.properties.getListener();
		map.from(properties::getConcurrency).to(factory::setConcurrency);
		map.from(this.messageConverter).to(factory::setMessageConverter);
		map.from(this.replyTemplate).to(factory::setReplyTemplate);
	......
	}

该方法：ConcurrentKafkaListenerContainerFactoryConfigurer类先获取自身的KafkaProperties对象。

@ConfigurationProperties(prefix = "spring.kafka")
public class KafkaProperties {
private final Map<String, String> properties = new HashMap<>();
	private final Consumer consumer = new Consumer();
	private final Producer producer = new Producer();
	private final Admin admin = new Admin();
    private final Listener listener = new Listener();
......
}

KafkaProperties对象包含Kafkabroker的配置信息，其具体的配置信息映射到yml文件中spirng.kafka前缀的属性配置中，如果某些配置没有被配置，则会使用默认的配置，如果在配置文件中进行了配置，则会覆盖默认的配置。利用这些配置信息可以创建生产者，消费者，Stream等。

this.properties.getListener()

public static class Listener {
		public enum Type {
			SINGLE,
			BATCH
		}
		private Type type = Type.SINGLE;
		private AckMode ackMode;
		private String clientId;
    ......
}

Listener类Kafka具体生产者，消费者等具体的配置信息。

map.from(properties::getConcurrency).to(factory::setConcurrency)

private void configureListenerFactory(ConcurrentKafkaListenerContainerFactory<Object, Object> factory) {

		map.from(properties::getConcurrency).to(factory::setConcurrency);
		map.from(this.messageConverter).to(factory::setMessageConverter);
		map.from(this.replyTemplate).to(factory::setReplyTemplate);
	......
	}

该方法是将ConcurrentKafkaListenerContainerFactoryConfigure类的相关配置赋值给ConcurrentKafkaListenerContainerFactory中对应的配置中。

ConfigureContainer(listenerFactory.getContainerProperties())

private void configureContainer(ContainerProperties container) {
		PropertyMapper map = PropertyMapper.get().alwaysApplyingWhenNonNull();
		Listener properties = this.properties.getListener();
		map.from(properties::getAckMode).to(container::setAckMode);
        ......
	
	}

同理，该方法获取配置类的KafkaProperties对象，然后获取Listener类，将对应的配置属性赋值给容器的相关配置。factory.setBatchListener(true)

factory.setMessageConverter(batchConverter())

public void setBatchListener(Boolean batchListener) {
		this.batchListener = batchListener;
	}
public void setMessageConverter(MessageConverter messageConverter) {
		this.messageConverter = messageConverter;
	}

该方法设置是否批量监听，以及消息的转换。Kafka消息传送，必须被序列化。

RecordMessageConverter类

@Bean
	public RecordMessageConverter converter() {
		return new StringJsonMessageConverter();
	}

一路追踪该类：

===》  
public StringJsonMessageConverter() {
		super();
}
===》 进入StringJsonMessageConverter的super()类
public JsonMessageConverter() {
		this(JacksonUtils.enhancedObjectMapper());
}
===》可以看出，JacksonUtils.enhancedObjectMapper()返回了ObjecMapper对象
public JsonMessageConverter(ObjectMapper objectMapper) {
		Assert.notNull(objectMapper, "'objectMapper' must not be null.");
		this.objectMapper = objectMapper;
}
返回上级，并转移到JacksonUtils.enhancedObjectMapper()
===》进入enhancedObjectMapper()
public static ObjectMapper enhancedObjectMapper() {
		return enhancedObjectMapper(ClassUtils.getDefaultClassLoader());
}
===》ClassUtils.getDefaultClassLoader() ：返回一个类加载器
public static ClassLoader getDefaultClassLoader() {
		ClassLoader cl = null;
		try {
			cl = Thread.currentThread().getContextClassLoader();
		}
......
}
返回上上级，并转移到 enhancedObjectMapper(ClassUtils.getDefaultClassLoader())
===》实现ObjectMapper的构建以及注册和classLoader
public static ObjectMapper enhancedObjectMapper(ClassLoader classLoader) {
		ObjectMapper objectMapper = JsonMapper.builder()
			.configure(MapperFeature.DEFAULT_VIEW_INCLUSION, false)
			.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false)
			.build();
		registerWellKnownModulesIfAvailable(objectMapper, classLoader);
		return objectMapper;
}
===》进入JsonMapper.builder()
public static JsonMapper.Builder builder() {
        return new Builder(new JsonMapper());
}
===》进入 new Builder(new JsonMapper())
public Builder(JsonMapper m) {
            super(m);
}
===》进入MapperBuilder(M mapper)
protected MapperBuilder(M mapper)
}
        _mapper = mapper;
}
===》返回上上级，进入new JsonMapper()
 public JsonMapper() {
        this(new JsonFactory());
}
===》进入 JsonFactory() 
public JsonFactory() { 
this((ObjectCodec) null); 
}
===》
 public JsonFactory(ObjectCodec oc) {
        _objectCodec = oc;
        _quoteChar = DEFAULT_QUOTE_CHAR;
}
===》进入ObjectCodec对象
描述信息为：
Abstract class that defines the interface that {@link JsonParser} and use to serialize and deserialize regular
一个接口，实现类将Java对昂进行序列化和反序列化。

总结为：converter类就是将对象进行序列化的类。

BatchMessagingMessageConverter类

@Bean
	public BatchMessagingMessageConverter batchConverter() {
		return new BatchMessagingMessageConverter(converter());
	}

同上，与批处理消息侦听器一起使用的Messaging实现；

KafkaTemplate 类

@Autowired
private KafkaTemplate kafkaTemplate;

KafkaTemplate是一个 “A template for executing high-level operations.“，即操作进行封装的一个类，提供了事务，消息转换，主题，生产者工厂类。

@KafkaListener

	@KafkaListener(id = "fooGroup2", topics = "topic2")
	public void listen1(List<Foo2> foos) throws IOException {
		logger.info("Received: " + foos);
		foos.forEach(f -> kafkaTemplate.send("topic3", f.getFoo().toUpperCase()));
		logger.info("Messages sent, hit Enter to commit tx");
		System.in.read();
	}

@KafkaListener注解，用来监听特定主题，当主题有变动时，会被调用，参数foos就是消息

主题创建

@Bean
	public NewTopic dlt() {
		return new NewTopic("topic1.DLT", 1, (short) 1);
	}
===》
 public NewTopic(String name, int numPartitions, short replicationFactor) {
        this.name = name;
        this.numPartitions = numPartitions;
        this.replicationFactor = replicationFactor;
        this.replicasAssignments = null;
    }

该类用来实现主题的创建。

Controller类

@Autowired
	private KafkaTemplate template;

	@PostMapping(path = "/send/foos/{what}")
	public void sendFoo(@PathVariable String what) {
		this.template.executeInTransaction(
				kafkaTemplate -> { StringUtils.commaDelimitedListToSet(what).stream()
				.map(s -> new Foo1(s))
				.forEach(foo -> kafkaTemplate.send("topic2", foo));
				return null;
		});
	}

这个使用KafkaTemplate将消息发送到特定的主题。

资源文件之配置文件application.yml文件

server:
  port: 9999
spring:
  application:
    name: broker
  kafka:
    producer:
      value-serializer: org.springframework.kafka.support.serializer.JsonSerializer
      transaction-id-prefix: tx.
    consumer:
      properties:
        isolation.level: read_committed
    bootstrap-servers: localhost:8989

server:配置springboot本身自带服务器的相关配置，端口port为9999

spring的相关配置，application.name:应用名称

kafka的相关配置：生产者，消费者的配置，Kafka主机的地址和端口。

这里以spirng.kafka开头的配置信息，与KafkaProperties类的属性对应，没有配置的则采用默认配置。

注意：server和spirng.application是我自己增加上去的。官网的没有，这个没什么影响。

消息对象

Foo1

package com.common;

public class Foo1 {
	private String foo;
	public Foo1() {
		super();
	}
	public Foo1(String foo) {
		this.foo = foo;
	}
	public String getFoo() {
		return this.foo;
	}
	public void setFoo(String foo) {
		this.foo = foo;
	}
	@Override
	public String toString() {
		return "Foo1 [foo=" + this.foo + "]";
}}

一般的消息使用字符串，由于Kafka传送时需要序列化，则使用（生产者）

properties.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
properties.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");

如果使用对象，则需要将对象序列化，这里这里我们使用：

value-serializer: org.springframework.kafka.support.serializer.JsonSerializer

为什么没有对Key使用序列化，如果没有，则默认找到一个分区进行存储，而值是序列化Foo对象。

`案例运行结果分析：`

运行时，首先启动Zookeeper和Kafka服务器，需要注意的地方时，对于主题的副本数，小于Kafka的集群数量。

使用PostmanCanary软件进行post请求的发送，该请求会将消息发送到topic2主题中，然后topic2监听器监听到topic2发生变化，会将消息发送到topic3主题中。

控制台日志结果：

如有问题，敬请指出，谢谢观看，与君共勉

给我一个自信的表情

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录