kafka333

MessageListener
import kafka.message.MessageAndMetadata;


public interface MessageListener {
    void onMessage(MessageAndMetadata<String, String> messageAndMetadata);
}

 

 

MessageConsumer

public class MessageConsumer implements Runnable {

    private static final Logger log = LoggerFactory.getLogger(MessageConsumer.class);


    @Value("${kafka.consumer.zookeeper.connect}")
    private String zookeeperConnect;

    @Value("${kafka.consumer.group.id}")
    private String groupId;

    @Value("${kafka.consumer.session.timeout.ms}")
    private String sessionMs;

    @Value("${kafka.consumer.auto.commit.interval.ms}")
    private String autoCommitMs;

    @Value("${kafka.consumer.zookeeper.sync.time.ms}")
    private String syncMs;

    @Value("${kafka.consumer.auto.offset.reset}")
    private String autoOffsetReset;

    @Value("${kafka.consumer.serializer.class}")
    private String serializerClass;

    @Value("${kafka.consumer.topic}")
    private String topic;

    @Value("${kafka.consumer.reconnect.num}")
    private int reconnectNum;// 重连次数

    @Value("${kafka.consumer.reconnect.time}")
    private long reconnectTime;// 多长时间重连一次单位是ms

    private ExecutorService executorService;

    public void setExecutorService(ExecutorService executorService) {
        this.executorService = executorService;
    }

    private ConsumerConnector consumerConnector;

    private Map<String, List<KafkaStream<String, String>>> streamsListMap;

    private MessageListener messageListener;


    public void setMessageListener(MessageListener messageListener) {
        this.messageListener = messageListener;
    }

    @Override
    public void run() {
        if (init()) {
            ArrayList<Runnable> taskList = new ArrayList<>();
            Collection<List<KafkaStream<String, String>>> streamsList = streamsListMap.values();
            Iterator<List<KafkaStream<String, String>>> slIterator = streamsList.iterator();
            while (slIterator.hasNext()) {
                List<KafkaStream<String, String>> streamList = slIterator.next();
                for (KafkaStream<String, String> stream : streamList) {
                    final ConsumerIterator<String, String> it = stream.iterator();
                    Runnable task = new Runnable() {
                        @Override
                        public void run() {
                            while (it.hasNext()) {
                                MessageAndMetadata<String, String> message = it.next();
                                messageListener.onMessage(message);
                            }
                        }
                    };
                    taskList.add(task);
                }
            }
            Iterator<Runnable> tasksIt = taskList.iterator();
            while (tasksIt.hasNext()) {
                executorService.execute(tasksIt.next());
            }
        }
    }

    private boolean init() {
        try {
            Properties props = new Properties();
            props.put("zookeeper.connect", zookeeperConnect);
            // group 代表一个消费组
            props.put("group.id", groupId);
            // zk连接超时
            props.put("zookeeper.session.timeout.ms", sessionMs);
            props.put("zookeeper.sync.time.ms", syncMs);
            props.put("auto.commit.interval.ms", autoCommitMs);
            props.put("auto.offset.reset", autoOffsetReset);
            // 序列化类
            props.put("serializer.class", serializerClass);
            props.put("kafka.reconnect.num", reconnectNum);
            props.put("kafka.reconnect.time", reconnectTime);
            ConsumerConfig consumerConfig = new ConsumerConfig(props);
            this.consumerConnector = Consumer.createJavaConsumerConnector(consumerConfig);
            StringDecoder keyDecoder = new StringDecoder(new VerifiableProperties());
            StringDecoder valueDecoder = new StringDecoder(new VerifiableProperties());
            HashMap<String, Integer> map = new HashMap<String, Integer>();
            map.put(topic, 1);
            this.streamsListMap = consumerConnector.createMessageStreams(map, keyDecoder, valueDecoder);
        } catch (Exception e) {
            log.error("kafka连接创建失败",e);
            Assert.notNull(streamsListMap,"kafka连接创建失败");
            return false;
        }
        return true;
    }

    public void close() {
        if (this.consumerConnector != null) {
            this.consumerConnector.shutdown();
        }

        if (this.executorService != null) {
            this.executorService.shutdown();
        }
    }
}

 

 

MessageConsumerContainer

public class MessageConsumerContainer extends AbstractMessageListenerContainer {

    private MessageConsumer messageConsumer;

    /*public MessageConsumerContainer(ContainerProperties containerProperties, MessageConsumer messageConsumer) {
        super(containerProperties);
        this.messageConsumer = messageConsumer;
    }*/

    public MessageConsumerContainer(MessageConsumer messageConsumer) {
        this.messageConsumer = messageConsumer;
    }

    @Override
    protected void doStart() {
        if(isRunning()){return;}
        AsyncTaskExecutor executor = getTaskExecutor();
        if(executor == null){
            setTaskExecutor(new SimpleAsyncTaskExecutor());
        }
        setisRunning(true);
        getTaskExecutor().execute(this.messageConsumer);
    }

    @Override
    protected void doStop(Runnable callback) {
        if(isRunning()){
            messageConsumer.close();
            setisRunning(false);
        }
    }


}

 

 

 

AbstractMessageListenerContainer

public abstract class AbstractMessageListenerContainer implements SmartLifecycle {

    private final Object lifecycleMonitor = new Object();

    private boolean autoStartup = true;

    private volatile boolean isRunning = false;

    private int phase = 0;

    private AsyncTaskExecutor taskExecutor;

    //private final ContainerProperties containerProperties;

    /*public AbstractMessageListenerContainer(ContainerProperties containerProperties) {
        this.containerProperties = containerProperties;
    }*/

    public AsyncTaskExecutor getTaskExecutor() {
        return taskExecutor;
    }

    public void setTaskExecutor(AsyncTaskExecutor taskExecutor) {
        this.taskExecutor = taskExecutor;
    }

    @Override
    public boolean isAutoStartup() {
        return this.autoStartup;
    }

    @Override
    public final void start() {
        //LOGGER.info("start AbstractMessageListenerContainer", "Begin to start the AbstractMessageListenerContainer");
        synchronized (this.lifecycleMonitor) {
            doStart();
        }
    }

    @Override
    public void stop() {
        System.out.println("Begin to stop the AbstractMessageListenerContainer");
    }

    @Override
    public void stop(Runnable callback) {
        synchronized (this.lifecycleMonitor) {
            doStop(callback);
        }
    }

    protected abstract void doStart();

    protected abstract void doStop(Runnable callback);

    public void setAutoStartup(boolean autoStartup) {
        this.autoStartup = autoStartup;
    }

    @Override
    public boolean isRunning() {
        return isRunning;
    }

    public void setisRunning(boolean isRunning) {
        this.isRunning = isRunning;
    }

    @Override
    public int getPhase() {
        return phase;
    }

    public void setPhase(int phase) {
        this.phase = phase;
    }

    /*public ContainerProperties getContainerProperties() {
        return containerProperties;
    }*/
}