2 formas de leer datos de Kafka a la base de datos Hbase usando el modo puente

Database 2023-09-16 17:28:13 views: null

Al leer datos, preste atención al tamaño de la memoria del servidor y use el comando para verificarlo.

Si la memoria es demasiado pequeña, se producirá un error de lectura.

df 

método uno

1. Importar dependencias de pom

<dependencias> 
    <dependencia> 
        <groupId>junit</groupId> 
        <artifactId>junit</artifactId> 
        <versión>4.12</versión> 
        <scope>test</scope> 
    </dependency> 
    <dependency> 
        <groupId>org. apache.kafka</groupId> 
        <artifactId>kafka-clients</artifactId> 
        <versión>2.0.0</version> 
    </dependency> 
    <dependency> 
        <groupId>org.apache.hbase</groupId> 
        <artifactId>hbase -cliente</artifactId> 
        <versión>1.2.0</versión 
    > </dependencia> 
</dependencias>

2. Escribir código

clase pública HbaseReadKafka{ 

    estático int i = 0; 
    conexión de conexión estática; 

    estático { 
        intentar { 
            Configuración cnf = HBaseConfiguration.create(); 
            cnf.set("hbase.zookeeper.quorum", "192.168.64.128:2181"); 
            conexión = ConnectionFactory.createConnection(cnf); 
        } captura (IOException e) { 
            e.printStackTrace(); 
        } 
    } 

    public static void main(String[] args) { 

        Propiedades prop = nuevas Propiedades(); 
        prop.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.64.128:9092"); 
        prop.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "más temprano");
        prop.put(ConsumerConfig.GROUP_ID_CONFIG, "cm"); 
        prop.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName()); 
        prop.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName()); 
        prop.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, falso); 
        KafkaConsumer<String, String> consumidor = new KafkaConsumer<String, String>(prop); 
        consumidor.subscribe(Arrays.asList(new String[]{"user_friends_raw"})); 
        while (verdadero) { 
            ConsumerRecords<String, String> registros = consumer.poll(Duration.ofSeconds(3)); 
            System.out.println("获取数据:" + records.count() + "====>" + (++i));
            Lista<Put> pone = nueva ArrayList<>(); 
            for (ConsumerRecord<String, String> registro: registros) { 
                //对kafka读取的数据处理 塞入集合
                Cadena [] líneas = record.value().split(",", -1); 
                if (lines.length > 1) { 
                    String[] fids = líneas[1].split(" "); 
                    for (String fid : fids) { 
                        Put put = new Put((lines[0] + "-" + fid).getBytes()); 
                        put.addColumn("base".getBytes(), "userid".getBytes(), líneas[0].getBytes()); 
                        put.addColumn("base".getBytes(), "friendid".getBytes(), fid.getBytes()); 
                        pone.
            try {  
                Tabla htable = conn.
                htable.put(puts); 
            } catch (IOException e) { 
                e.printStackTrace(); 
            } 
            //Borrar la colección de listas 
            puts.clear(); 
            //Envío asincrónico 
            consumer.commitAsync(); 
            //Envío sincrónico 
/ / consumidor.commitSync(); 
        } 
} 
    }

Método dos

¡Resumen de tipos!

 

1 pompón importado

   <properties>
        <java.version>1.8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <spring-boot.version>2.3.7.RELEASE</spring-boot.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.kafka</groupId>
            <artifactId>spring-kafka</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.hbase</groupId>
            <artifactId>hbase-shaded-client</artifactId>
            <version>1.2.0</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</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>
    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.3.2.RELEASE</version>
                <configuration>
                    <mainClass>com.kgc.UserinterestApplication</mainClass>
                </configuration>
                <executions>
                    <execution>
                        <id>repackage</id>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

2 Configurar yml

spring: 
  aplicación: 
    nombre: interés del usuario 
  kafka: 
    bootstrap-servers: 192.168.64.128:9092 
    consumidor: 
        #Desactivar el envío manual 
      enable-auto-commit: false 
        #Leer el archivo desde la primera posición 
      auto-offset-reset: primero 
       #Codificación de serialización 
      clave -deserializer: org.apache.kafka.common.serialization.StringDeserializer 
      valor-deserializer: org.apache.kafka.common.serialization.StringDeserializer 
    oyente: 
      modo de reconocimiento: 
servidor manual_immediato: 
  puerto: 8999

3 Configurar el modo puente

#Escribir interfaz 1

interfaz pública FillData<T,E>{ 
    Lista<T> fillData (Lista<E> lst); 
}

#Escribir interfaz 2

/** 
 * Completar datos automáticamente según los resultados de la consulta 
 * @param <T> 
 */ 

public interface FillHbaseData<T> extends FillData<Put,T> { 
    List<Put> fillData(List<T> list); 
} # Escribir interfaz 3



/** 
 * Interfaz de conversión de formato de datos basada en diferentes datos de usuario y modelos de entidades entrantes 
 * @param <T> 
 */ 
public interface StringToEntity<T>{ 
    List<T> change(String line); 
}

#Escribir interfaz 4

/** 
 * Interfaz de conversión de datos Los datos de Kafka se convierten a formatos de datos comunes 
 * @param <T> 
 */ 
public interface DataChange<T> { 
    List<T> change(String line); 
}

#Escribir la clase abstracta 5 e implementar la interfaz 4

/** 
 *桥梁模式中的抽象角色
 */ 
clase abstracta pública AbstracDataChange<E,T> implementa DataChange<T> { 

    protected FillData<E,T> fillData; 
    protegido StringToEntity<T> stringToEntity; 
    Escritor protegido<E> escritor; 

    public AbstracDataChange(FillData<E, T> fillData, StringToEntity<T> stringToEntity, Writer<E> escritor) { 
        this.fillData = fillData; 
        this.stringToEntity = stringToEntity; 
        this.escritor = escritor; 
    } 


    cambio de lista abstracta pública <T> (línea de cadena); 

    relleno de vacío abstracto público (ConsumerRecord<String,String> registro,String tableName); 
}

 

#Escriba la clase de implementación de interfaz 1 para implementar la interfaz 2

1.1

/** 
 * 处理eventAttendees数据
 */ 
public class EventAttendeesFillDataImp implements FillHbaseData<EventAttendees> { 

    @Override 
    public List<Put> fillData(List<EventAttendees> list) { 
        List<Put> puts=new ArrayList<>(); 
        list.stream().forEach(eventAttendees -> { 
            Put put = new Put((eventAttendees.getEventid()+eventAttendees.getUserid()+eventAttendees.getAnswer()).getBytes()); 
            put.addColumn("base" .getBytes(),"eventid".getBytes(),eventAttendees.getEventid().getBytes()); 
            put.addColumn("base".getBytes(),"userid".getBytes(),eventAttendees.getUserid(). getBytes());
            put.addColumn("base".getBytes(),"answer".getBytes(),eventAttendees.getAnswer().getBytes()); 
            pone.add(poner); 

        }); 
        devolución pone;
    } 
}

#Escriba la clase de implementación de interfaz 2 para implementar la interfaz 2

1.2

clase pública EventsFillDataImp implementa FillHbaseData<Events> { 
    @Override 
    public List<Put> fillData(List<Events> lista) { 
        List<Put> puts=new ArrayList<>(); 
        list.stream().forEach(eventos -> { 
            Put put=new Put(events.getEventid().getBytes()); 
            put.addColumn("base".getBytes(),"userid".getBytes(),eventos .getUserid().getBytes()); 
            put.addColumn("base".getBytes(),"starttime".getBytes(),events.getStarttime().getBytes()); 
            put.addColumn("base".getBytes (),"ciudad".getBytes(),events.getCity().getBytes()); 
            put.addColumn("base".getBytes(),"estado".getBytes(),eventos.
            put.addColumn("base".getBytes(),"zip".getBytes(),events.getZip().getBytes()); 
            put.addColumn("base".getBytes(),"país".getBytes(),events.getCountry().getBytes()); 
            put.addColumn("base".getBytes(),"lat".getBytes(),events.getLat().getBytes()); 
            put.addColumn("base".getBytes(),"lng".getBytes(),events.getLng().getBytes()); 
            pone.add(poner); 
        }); 
        devolución pone; 
    } 
}

#Escriba la clase de implementación de interfaz 3 para implementar la interfaz 2

1.3

/** 
 * 针对userfriends消息队列转换的list集合再转为list<Put> 
 */ 
public class UserFriendsFillDataImp implements FillHbaseData<UserFriends> { 
    @Override 
    public List<Put> fillData(List<UserFriends> list) { 
        List<Put> pone=nueva ListaArray<>(); 
        list.stream().forEach(userFriends -> { 
            Put put = new Put((userFriends.getUserid()+"-"+userFriends.getFriendid()).getBytes()); 
            put.addColumn("base".getBytes (),"userid".getBytes(), userFriends.getUserid().getBytes()); 
            put.addColumn("base".getBytes(),"friendid".getBytes(), userFriends.getFriendid().getBytes( )); 
            pone. agregar(poner); 
        }); 
        devolución pone; 
    }
}

#Escriba la clase de implementación de interfaz 1 para implementar la interfaz 3

public class EventAttendeesChangeImp implements StringToEntity<EventAttendees> { 
    /** 
     * Los datos ingresan como eventid sí, tal vez invitados no 
     * ex:123,112233 34343,234234 45454,112233 23232 234234,343343 34343 
     * Convertir el formato de datos a 123 11223 3 si,123 34343 sí, 123 234234 tal vez ...... 
     * @param line 
     * @return 
     */ 
    @Override 
    public List<EventAttendees> change(String line) { 
        String[] infos = line.split(",", -1); 
        List<EventAttendees> eas= new ArrayList<>(); 
        //Primero cuenta todas las personas que respondieron que sí 
        if (!infos[1].trim().equals("")&&infos[1]!=null) { 
            Arrays .asList(infos[1].split(" ")).stream()
                    .forEach(yes->{ 
                        EventAttendees eventAttendees = EventAttendees.builder().eventid(infos[0]).userid(yes).answer("yes").build(); 
                        eas.add(eventAttendees); 
                    }); 
        } 
        //计算所有tal vez的人
        if (!infos[2].trim().equals("")&&infos[2]!=null) { 
            Arrays.asList(infos[2].split(" ")). stream() 
                    .forEach(tal vez->{ 
                        EventAttendees eventAttendees = EventAttendees.builder().eventid(infos[0]).userid(tal vez).answer("tal vez").build(); eas 
                        .
        if (!infos[3].trim().equals("")&&infos[3]!=null) { 
            Arrays.asList(infos[3].split(" ")).stream() 
                    .forEach(invitado- >{ 
                        EventAttendees eventAttendees = EventAttendees.builder().eventid(infos[0]).userid(invited).answer("invited").build(); 
                        eas.add(eventAttendees); 
                    }); 
        } 
        //计算no的人
        if (!infos[4].trim().equals("")&&infos[4]!=null) { 
            Arrays.asList(infos[4].split(" ")).stream () 
                    .forEach(no->{ 
                        EventAttendees eventAttendees = EventAttendees.builder().eventid(infos[0]).userid(no).
                        eas.add(eventoAsistentes); 
                    }); 
        } 
        devolver fácil; 
    } 
}

#Escriba la clase de implementación de interfaz 2 para implementar la interfaz 3

clase pública EventsChangeImp implementa StringToEntity<Eventos> { 
    @Override 
    lista pública<Eventos> cambio(línea de cadena) { 
        Cadena[] infos = line.split(",", -1); 
        Lista<Eventos> eventos=new ArrayList<>(); 
        Eventos evento = Events.builder().eventid(infos[0]).userid(infos[1]).starttime(infos[2]) .city(infos[3]).state(infos[4]). 
                zip (información[5]) 
                .country(información[6]).lat(información[7]).lng(información[8]).build(); 
        eventos.add(evento); 
        eventos de retorno; 
    } 
}

#Escriba la clase de implementación de interfaz 3   para implementar la interfaz 3

/** 
 * 将 123123,123435 435455 345345 => 123123,12335 123123,435455 123123,345345 * 
 / 
public class UserFriendsChangeImp implements StringToEntity<UserFriends> { 
    @Override 
    public List<UserFriends> change(String line) { 
        Cadena [] información = línea.split(",",-1); 
        Lista<UserFriends> ufs=new ArrayList<>(); 
        if(infos.length>=1){ 
            UserFriends userFriends = UserFriends.builder().userid(infos[0]).friendid("").build(); 
            ufs.add(usuariosAmigos); 
        }else { 
            Arrays.asList(infos[1].split(" ")).stream() 
                    .forEach(fid -> {
                        UserFriends uf = UserFriends.builder().userid(infos[0]).friendid(fid).build(); 
                        ufs.add(uf); 
                    }); 
        } 
        devolver ufs; 
    } 
}

3.1 Configuración

La clase de entidad DataChangeFillHbaseDatabase completa la integración de la interfaz

clase pública DataChangeFillHbaseDatabase<T> extiende AbstracDataChange<Put,T> { 
    static int count; 

    public DataChangeFillHbaseDatabase(FillData<Put, T> fillData, StringToEntity<T> stringToEntity, Writer<Put> escritor) { 
        super(fillData, stringToEntity, escritor); 
    } 

    @Override 
    lista pública<T> cambio(línea de cadena) { 
        return stringToEntity.change(line); 
    } 

    @Override 
    public void fill(ConsumerRecord<String,String> record,String tableName) { 
        //读kafka获得的ConsumerRecord 转字符串
        List<Put> puts = fillData.fillData(change(record.value())); 

// pone.forEach( System.out::
        escritor.write(puts,tableName); 
        System.out.println("hu obtuvo datos de Kafka======>"+count++); 

    } 
}

3.2 Configurar clases de entidad

# Entidad clase 1

@Data 
@AllArgsConstructor 
@NoArgsConstructor 
@Builder 
public class EventAttendees { 
    cadena privada eventid; 
    ID de usuario de cadena privada; 
    respuesta de cadena privada; 
}

# Entidad clase 2

@Data 
@AllArgsConstructor 
@NoArgsConstructor 
@Builder 
eventos de clase pública { 
    cadena privada eventid; 
    ID de usuario de cadena privada; 
    hora de inicio de cadena privada; 
    ciudad privada de cuerdas; 
    estado de cadena privada; 
    zip de cadena privada; 
    país de cadena privada; 
    cadena privada lat; 
    longitud de cadena privada; 
} 

# 实体 类 3

@Data 
@AllArgsConstructor 
@NoArgsConstructor 
@Builder 
public class UserFriends { 
    private String ID de usuario; 
    ID de amigo de cadena privada; 
}

 3.3 Configurar la capa de servicio para leer y escribir archivos

# 接口 escritor 
interfaz pública Escritor<T> {
    void write(List<T> puts, String tableName); 
}

#Clase de implementación de interfaz

/** 
 * Acepte el conjunto de datos list<put> convertido y complételo en la base de datos hbase 
 */ 
@Component 
public class HbaseWriter implements Writer<Put> { 
    @Resource 
    conexión privada; 
    escritura nula pública (List<Put> puts,String tableName) { 
        intentar { 
            Tabla tabla = conexión.getTable(TableName.valueOf(tableName)); 
            table.put(puts); 
        } catch (IOException e) { 
            e.printStackTrace(); 
        } 
    } 
}

Clase #KafkaReader

@Component 
public class KafkaReader { 
    @Resource 
    escritor privado<Put> escritor; 

    @KafkaListener(groupId = "cm", temas = {"events_raw"}) 
    public void readEventToHbase(ConsumerRecord<String, String> record, Acknowledgement ack) { 
        AbstracDataChange<Put, Events> eventHandler = new DataChangeFillHbaseDatabase<Events>( 
                new EventsFillDataImp( ), 
                nuevo EventsChangeImp(), 
                escritor 
        ); 
        eventHandler.fill(registro,"eventos"); 
        reconocimiento.reconocimiento(); 
    } 

    @KafkaListener(groupId = "cm", temas = {"event_attendees_raw"})
    public void readEventAttendeesToHbase(ConsumerRecord<String, String> record, Acknowledgement ack) { 
        AbstracDataChange<Put, EventAttendees> eventHandler = new DataChangeFillHbaseDatabase<EventAttendees>( 
                new EventAttendeesFillDataImp(), 
                new EventAttendeesChangeImp(), 
                escritor 
        ); 
        eventHandler.fill(registro,"eventsattends"); 
        reconocimiento.reconocimiento(); 
    } 

// @KafkaListener(groupId = "cm", temas = {"user_friends_raw"}) 
    public void readUserFriendsToHbase(ConsumerRecord<String, String> record, Acknowledgement ack) { 
        AbstracDataChange<Put,
                nuevo UserFriendsFillDataImp(), 
                nuevo UserFriendsChangeImp(), 
                escritor 
        ); 
        eventHandler.fill(registro,"amigos de usuarios"); 
        reconocimiento.reconocimiento(); 
    } 
}

3.4 configuración base 

@Configuration 
clase pública HbaseConfig { 
    @Bean 
    public org.apache.hadoop.conf.Configuration getConfig(){ 
        org.apache.hadoop.conf.Configuration cfg = HBaseConfiguration.create(); 
        cfg.set(HConstants.ZOOKEEPER_QUORUM,"192.168.64.128:2181"); 
        devolver cfg; 
    } 
    @Bean 
    @Scope(valor = "prototipo") 
    Conexión pública getConnection(){ 
        Conexión conexión = nulo; 
        intente { 
            conexión = ConnectionFactory.createConnection(getConfig()); 
        } captura (IOException e) { 
            e.printStackTrace(); 
        } 
        conexión de retorno; 
    }
    @Bean 
    proveedor público<Conexión> hBaseConnection(){ 
        return this::getConnection; 
    } 
}

Supongo que te gusta

Origin blog.csdn.net/just_learing/article/details/126444470
Recomendado
Clasificación
Diario
Más
2024-05-13(7)
2024-05-12(22)
2024-05-11(31)
2024-05-10(32)
2024-05-09(31)
2024-05-08(18)
2024-05-07(35)
2024-05-06(4)
2024-05-05(0)
2024-05-04(17)

Code World

© 2018 codetd.com