Mensaje middleware -kafka (II)

Investigación de noticias Middleware

Mensaje middleware -kafka (II)

Medio Ambiente para construir

Paso 1: Descargar Kafka, haga clic en Descargar y descomprimir la versión más reciente.

 tar -xzf kafka_2.9.2-0.8.1.1.tgz
 cd kafka_2.9.2-0.8.1.1

Paso 2: Iniciar servicios
Kafka utiliza Zookeeper, en primer lugar Zookper inicio, sólo tiene que activar Zookkeeper una única instancia del servicio a continuación. Puede dejar después del final de la consola de comandos add y símbolo, para que pueda comenzar.

bin/zookeeper-server-start.sh config/zookeeper.properties &

Inicio Kafka:

bin/kafka-server-start.sh config/server.properties

Paso 3: Crear tema

bin/kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic test

Ver por orden de lista para crear el tema:

bin/kafka-topics.sh --list --zookeeper localhost:2181 test

Paso 4: transmitir un mensaje.
Kafka mediante un sencillo productor de línea de comandos, o leer desde el archivo de los mensajes de entrada y enviar al servidor estándar. Por defecto cada comando para enviar un mensaje.
Algunos productor de carreras y dar salida a los mensajes de consola, estos mensajes se envían al servidor

 bin/kafka-console-producer.sh --broker-list localhost:9092 --topic test 

Paso 5: Comienzo del consumidor
línea de consumo puede leer el mensaje y la salida estándar

bin/kafka-console-consumer.sh --zookeeper localhost:2181 --topic test --from-beginning

Lograr resultados:
Ejecutar los consumidores en un terminal de línea de comandos, otra línea de comandos productor de carreras terminal, el mensaje de entrada puede ser un terminal, otro terminal lee el mensaje.
Paso 6: Crear más de un clúster de agente
ahora se inicia con tres corredor compuesta de racimos, éstos son también los nodos de corredores en esta máquina:
En primer lugar, el archivo de configuración de escritura para cada nodo:

cp config/server.properties config/server-1.properties
cp config/server.properties config/server-2.properties

Añadir una nueva copia del archivo en los siguientes parámetros:

config/server-1.properties:
    broker.id=1
    port=9093
    log.dir=/tmp/kafka-logs-1

config/server-2.properties:
    broker.id=2
    port=9094
    log.dir=/tmp/kafka-logs-2

broker.id solamente marcar un nodo del clúster, ya que en la misma máquina, es necesario desarrollar diferentes puertos y los archivos para evitar que se sobrescriban los datos de registro.
Zookeeper puede ya haber comenzado y un nodo, los otros dos nodos empezar ahora

 bin/kafka-server-start.sh config/server-1.properties &
 
 bin/kafka-server-start.sh config/server-2.properties &

Crear un tema tiene tres copias:

bin/kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 3 --partitions 1 --topic my-replicated-topic

Ahora hemos creado un clúster, cómo conocer la información sobre cada nodo es? Ejecutar "" describen los temas de "comando en él.

 bin/kafka-topics.sh --describe --zookeeper localhost:2181 --topic my-replicated-topic
 //效果
 Topic:my-replicated-topic       PartitionCount:1        ReplicationFactor:3     Configs:
        Topic: my-replicated-topic      Partition: 0    Leader: 1       Replicas: 1,2,0 Isr: 1,2,0
        下面解释一下这些输出。第一行是对所有分区的一个描述，然后每个分区都会对应一行，因为我们只有一个分区所以下面就只加了一行。
        eader：负责处理消息的读和写，leader是从所有节点中随机选择的.
replicas：列出了所有的副本节点，不管节点是否在服务中.
isr：是正在服务中的节点.

mecanismos Kafka de tolerancia a fallos de prueba (omitido)

Kafka entorno de desarrollo para construir

En proyecto experto, añadiendo una dependencia en pom.xml

<dependency>
        <groupId> org.apache.kafka</groupId >
        <artifactId> kafka_2.10</artifactId >
        <version> 0.8.0</ version>
</dependency>

El programa de configuración
primer acto como un papel de un archivo de configuración de la interfaz, configurada con una variedad de parámetros de conexión Kafka:

kage com.sohu.kafkademon;
public interface KafkaProperties
{
    final static String zkConnect = "10.22.10.139:2181";
    final static String groupId = "group1";
    final static String topic = "topic1";
    final static String kafkaServerURL = "10.22.10.139";
    final static int kafkaServerPort = 9092;
    final static int kafkaProducerBufferSize = 64 * 1024;
    final static int connectionTimeOut = 20000;
    final static int reconnectInterval = 10000;
    final static String topic2 = "topic2";
    final static String topic3 = "topic3";
    final static String clientId = "SimpleConsumerDemoClient";
}

productor

import java.util.Properties;
import kafka.producer.KeyedMessage;
import kafka.producer.ProducerConfig;
/**
* @author leicui [email protected]
*/
public class KafkaProducer extends Thread
{
    private final kafka.javaapi.producer.Producer<Integer, String> producer;
    private final String topic;
    private final Properties props = new Properties();
    public KafkaProducer(String topic)
    {
        props.put("serializer.class", "kafka.serializer.StringEncoder");
        props.put("metadata.broker.list", "10.22.10.139:9092");
        producer = new kafka.javaapi.producer.Producer<Integer, String>(new ProducerConfig(props));
        this.topic = topic;
    }
    @Override
    public void run() {
        int messageNo = 1;
        while (true)
        {
            String messageStr = new String("Message_" + messageNo);
            System.out.println("Send:" + messageStr);
            producer.send(new KeyedMessage<Integer, String>(topic, messageStr));
            messageNo++;
            try {
                sleep(3000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}

consumidor

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import kafka.consumer.ConsumerConfig;
import kafka.consumer.ConsumerIterator;
import kafka.consumer.KafkaStream;
import kafka.javaapi.consumer.ConsumerConnector;
/**
* @author leicui [email protected]
*/
public class KafkaConsumer extends Thread
{
    private final ConsumerConnector consumer;
    private final String topic;
    public KafkaConsumer(String topic)
    {
        consumer = kafka.consumer.Consumer.createJavaConsumerConnector(
                createConsumerConfig());
        this.topic = topic;
    }
    private static ConsumerConfig createConsumerConfig()
    {
        Properties props = new Properties();
        props.put("zookeeper.connect", KafkaProperties.zkConnect);
        props.put("group.id", KafkaProperties.groupId);
        props.put("zookeeper.session.timeout.ms", "40000");
        props.put("zookeeper.sync.time.ms", "200");
        props.put("auto.commit.interval.ms", "1000");
        return new ConsumerConfig(props);
    }
    @Override
    public void run() {
        Map<String, Integer> topicCountMap = new HashMap<String, Integer>();
        topicCountMap.put(topic, new Integer(1));
        Map<String, List<KafkaStream<byte[], byte[]>>> consumerMap = consumer.createMessageStreams(topicCountMap);
        KafkaStream<byte[], byte[]> stream = consumerMap.get(topic).get(0);
        ConsumerIterator<byte[], byte[]> it = stream.iterator();
        while (it.hasNext()) {
            System.out.println("receive：" + new String(it.next().message()));
            try {
                sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

simple transmisión y recepción
corren el siguiente programa, sólo tiene que enviar un mensaje recibido:

public class KafkaConsumerProducerDemo
{
    public static void main(String[] args)
    {
        KafkaProducer producerThread = new KafkaProducer(KafkaProperties.topic);
        producerThread.start();
        KafkaConsumer consumerThread = new KafkaConsumer(KafkaProperties.topic);
        consumerThread.start();
    }
}

Fuente: https: //blog.csdn.net/wangzhanzheng/article/details/79720029