SpringBoot2整合kafka

这kafka是伪集群，因为虚拟机有限，zookeeper也是集群

上面一篇写了springboot2整合dubbo，原来我以为可以springboot整合dubbo和kafka呢？
之后才发现我想错了

说一下这两个用途的一些区别

• dubbo是微服务，微小的服务，如果并发量不是太高，上千万，上亿级别的或者想要返回结果的可以用dubbo
• kafka是消息队列，如果想提高吞吐量，不要返回结果(返回结果可以放在redis里)就可以用它
• 不过上面的两种一般都有，当进行服务降级或者服务熔断时消息队列就大有用处

添加依赖

		
		    org.springframework.kafka
		    spring-kafka
		
		
		  
         com.alibaba
            fastjson
            1.2.49   
          

生产者

1、application.yml

server:
  port: 8080
spring:
  kafka:      
   #kafka的IP:端口，可以多个，因为kafka集群，连接一个端口就可以，当然为了容错性可以把剩下的端口都写上
    bootstrap-servers: 192.168.137.130:9092  
    template:
      default-topic: my-replicated-topic  #kafka默认主题
    listener:             #指定listen容器中的线程数，用于提高并发量
      concurrency: 5  
    producer:
      batch-size: 1000 # 每次批量发送消息的数量
      retries: 3

2、controller类

@Controller
public class UserController {
	@Autowired
		KafkaService kafkaService;
		
		@RequestMapping("findAll")
		public String findAll(Model model) throws Exception {					
			User user = new User();
			user.setUser_id("111");
			user.setName("搞笑");
			user.setAge(5);							
			kafkaService.sendMessage(user);
												
			return "index";			
		}
}

kafka的接口和实现类

接口类

public interface KafkaService {
	/**
	 * 发送一个消息队列
	 * */
	void sendMessage(User user);
}

实现类

public class KafkaServiceImpl implements KafkaService{
	@Autowired
	private KafkaTemplate kafkaTemplate;
	@Override
	public void sendMessage(User user) {
		kafkaTemplate.send("my-replicated-topic", JSONObject.toJSONString(user));
		
	}

}

消费者

1、application.yml

server:
  port: 8081
spring:
  kafka:      
  #kafka的IP:端口，可以多个，因为kafka集群，连接一个端口就可以，当然为了容错性可以把剩下的端口都写上
    bootstrap-servers: 192.168.137.130:9093   
    template:
      default-topic: my-replicated-topic  #kafka默认主题
    listener:             #指定listen容器中的线程数，用于提高并发量
      concurrency: 5  
    consumer:
      group-id: mygroup      #指定默认消费者group id，这个必须有
      auto-offset-reset: earliest  #最早未被消费的offset 

2、消费者接收的类

下面是三种方式，自己根据需求选择，三个方法同时执行的时候主题不要一样

@Component
public class Consumer {

    /**
     * 有消息就读取,只读取消息value
     */
	
    @KafkaListener(topics = {"test1"})
    public void receiveMessage(String message){
        //收到通道的消息之后执行秒杀操作
        System.out.println(message);
    }

    /**
     * 有消息就读取,批量读取消息value
     */
    @KafkaListener(topics = "test2")
    public void onMessage(List crs) {
        for(String str : crs){
            System.out.println("test12:" + str);
        }
    }

    /**
     * 有消息就读取,读取消息topic，offset，key，value等信息
     */
    @KafkaListener(topics = "my-replicated-topic")
    public void listenT1(ConsumerRecord cr){
        System.out.println("listenT1收到消息,topic:>>>" + cr.topic() + "  offset:>>" + cr.offset()+ "  key:>>" + cr.key() + "  value:>>" + cr.value());
    }
}

测试

成功

如果生产者需要返回到那个分区，主题等

 ListenableFuture> future = kafkaTemplate.send(topic,message);
 RecordMetadata recordMetadata = future.get().getRecordMetadata();
  System.out.println("partition:"+recordMetadata.partition());
        System.out.println("offset:"+recordMetadata.offset());
        System.out.println("topic:"+recordMetadata.topic());