2 maneiras de ler dados do banco de dados Kafka para Hbase usando o modo bridge

Ao ler os dados, preste atenção ao tamanho da memória do servidor e use o comando para verificar!

Se a memória for muito pequena, ocorrerá um erro de leitura.

df 

método um

1. Importe dependências pom

<dependencies> 
    <dependency> 
        <groupId>junit</groupId> 
        <artifactId>junit</artifactId> 
        <version>4.12</version> 
        <scope>test</scope> 
    </dependency> 
    <dependency> 
        <groupId>org. apache.kafka</groupId> 
        <artifactId>kafka-clients</artifactId> 
        <version>2.0.0</version> 
    </dependency> 
    <dependency> 
        <groupId>org.apache.hbase</groupId> 
        <artifactId>hbase -client</artifactId> 
        <versão>1.2.0</versão 
    > </dependency> 
</dependencies>

2. Escreva o código

classe pública HbaseReadKafka{ 

    static int i = 0; 
    conexão de conexão estática; 

    static { 
        try { 
            Configuração cnf = HBaseConfiguration.create(); 
            cnf.set("hbase.zookeeper.quorum", "192.168.64.128:2181"); 
            conexão = ConnectionFactory.createConnection(cnf); 
        } catch (IOException e) { 
            e.printStackTrace(); 
        } 
    } 

    public static void main(String[] args) { 

        Propriedades prop = new Propriedades(); 
        prop.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.64.128:9092"); 
        prop.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "mais antigo");
        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 (true) { 
            ConsumerRecords<String, String> registros = consumer.poll(Duration.ofSeconds(3)); 
            System.out.println("获取数据:" + records.count() + "====>" + (++i));
            List<Put> puts = new ArrayList<>(); 
            for (ConsumerRecord<String, String> record : records) { 
                //对kafka读取的数据处理 塞入集合
                String[] linhas = record.value().split(",", -1); 
                if (lines.length > 1) { 
                    String[] fids = linhas[1].split(" "); 
                    for (String fid: fids) { 
                        Put put = new Put((linhas[0] + "-" + fid).getBytes()); 
                        put.addColumn("base".getBytes(), "userid".getBytes(), linhas[0].getBytes()); 
                        put.addColumn("base".getBytes(), "friendid".getBytes(), fid.getBytes()); 
                        coloca.add(colocar); 
                    } 
                } 
            } 
            try { 
                Tabela htable = conn. 
                htable.put(puts); 
            } catch (IOException e) { 
                e.printStackTrace(); 
            } 
            //Limpa a coleção de lista 
            puts.clear(); 
            //Envio assíncrono 
            consumer.commitAsync(); 
            //Envio síncrono 
/ /consumidor.commitSync(); 
        } 
} 
    }

Método dois

Visão geral do tipo!

 

1 Importar pom

   <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 o yml

spring: 
  application: 
    name: userinterest 
  kafka: 
    bootstrap-servers: 192.168.64.128:9092 
    consumer: 
        #Desativar envio manual 
      enable-auto-commit: false 
        #Leia o arquivo da primeira posição 
      auto-offset-reset: mais antigo 
       #Codificação de serialização 
      key -deserializer: org.apache.kafka.common.serialization.StringDeserializer 
      value-deserializer: org.apache.kafka.common.serialization.StringDeserializer 
    ouvinte: 
      ack-mode: manual_immediate 
servidor: 
  porta: 8999

3 Configurar o modo bridge

#Escrever interface 1

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

#Escrever interface 2

/** 
 * Preencher dados automaticamente com base nos resultados da consulta 
 * @param <T> 
 */ 

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

/** 
 * Interface de conversão de formato de dados baseada em diferentes dados de usuário e modelos de entidade de entrada 
 * @param <T> 
 */ 
public interface StringToEntity<T>{ 
    List<T> change(String line); 
}

#Escrever interface 4

/** 
 * Os dados kafka da interface de conversão de dados são convertidos em formatos de dados comuns 
 * @param <T> 
 */ 
public interface DataChange<T> { 
    List<T> change(String line); 
}

#Escreva a classe abstrata 5 e implemente a interface 4

/** 
 *桥梁模式中的抽象角色
 */ 
public abstract class AbstracDataChange<E,T> implements DataChange<T> { 

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

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


    public abstract List<T> change(String line); 

    preenchimento de void abstrato público (ConsumerRecord<String,String> record,String tableName); 
}

 

#Escreva a classe de implementação da interface 1 para implementar a interface 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(),"resposta".getBytes(),eventAttendees.getAnswer().getBytes()); 
            coloca.add(colocar); 

        }); 
        opções de venda de retorno;
    } 
}

#Escreva a classe de implementação da interface 2 para implementar a interface 2

1.2

public class EventsFillDataImp implements FillHbaseData<Events> { 
    @Override 
    public List<Put> fillData(List<Events> list) { 
        List<Put> puts=new ArrayList<>(); 
        list.stream().forEach(events -> { 
            Put put=new Put(events.getEventid().getBytes()); 
            put.addColumn("base".getBytes(),"userid".getBytes(),events .getUserid().getBytes()); 
            put.addColumn("base".getBytes(),"starttime".getBytes(),events.getStarttime().getBytes()); 
            put.addColumn("base".getBytes (),"cidade".getBytes(),events.getCity().getBytes()); 
            put.addColumn("base".getBytes(),"estado".getBytes(),events.
            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()); 
            coloca.add(colocar); 
        }); 
        opções de venda de retorno; 
    } 
}

#Escreva a classe de implementação da interface 3 para implementar a interface 2

1.3

/** 
 * 针对userfriends消息队列转换的list集合再转为list<Put> 
 */ 
public class UserFriendsFillDataImp implements FillHbaseData<UserFriends> { 
    @Override 
    public List<Put> fillData(List<UserFriends> list) { 
        List<Put> puts=new ArrayList<>(); 
        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( )); 
            coloca. adicionar(colocar); 
        }); 
        opções de venda de retorno; 
    }
}

#Escreva a classe de implementação da interface 1 para implementar a interface 3

public class EventAttendeesChangeImp implements StringToEntity<EventAttendees> { 
    /** 
     * Os dados entram como eventid sim, talvez convidados não 
     * ex:123,112233 34343,234234 45454,112233 23232 234234,343343 34343 
     * Converta o formato de dados para 123 11223 3 sim, 123 34343 sim,123 234234 talvez ...... 
     * @param line 
     * @return 
     */ 
    @Override 
    public List<EventAttendees> change(String line) { 
        String[] infos = line.split(",", -1); 
        List<EventAttendees> eas= new ArrayList<>(); 
        //Primeiro conta todas as pessoas que responderam sim 
        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); 
                    }); 
        } 
        //计算所有talvez的人
        if (!infos[2].trim().equals("")&&infos[2]!=null) { 
            Arrays.asList(infos[2].split(" ")). stream() 
                    .forEach(talvez->{ 
                        EventAttendees eventAttendees = EventAttendees.builder().eventid(infos[0]).userid(talvez).answer("talvez").build(); eas 
                        .
        if (!infos[3].trim().equals("")&&infos[3]!=null) { 
            Arrays.asList(infos[3].split(" ")).stream() 
                    .forEach(convidado- >{ 
                        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(eventoAtendentes); 
                    }); 
        } 
        retornar eas; 
    } 
}

#Escreva a classe de implementação da interface 2 para implementar a interface 3

public class EventsChangeImp implements StringToEntity<Events> { 
    @Override 
    public List<Events> change(String line) { 
        String[] infos = line.split(",", -1); 
        List<Eventos> events=new ArrayList<>(); 
        Eventos evento = Events.builder().eventid(infos[0]).userid(infos[1]).starttime(infos[2]) .city(infos[3]).state(infos[4]). 
                zip (infos[5]) 
                .país(infos[6]).lat(infos[7]).lng(infos[8]).build(); 
        eventos.add(evento); 
        eventos de retorno; 
    } 
}

#Escreva a classe de implementação da interface 3   para implementar a interface 3

/** 
 * 将 123123,123435 435455 345345 => 123123,12335 123123,435455 123123,345345 
 */ 
public class UserFriendsChangeImp implements StringToEntity<UserFriends> { 
    @Override 
    public List<UserFriends> change(String line) { 
        String[] informações = linha.split(",",-1); 
        List<UserFriends> ufs=new ArrayList<>(); 
        if(infos.length>=1){ 
            UserFriends userFriends = UserFriends.builder().userid(infos[0]).friendid("").build(); 
            ufs.add(userFriends); 
        }else { 
            Arrays.asList(infos[1].split(" ")).stream() 
                    .forEach(fid -> {
                        UserFriends uf = UserFriends.builder().userid(infos[0]).friendid(fid).build(); 
                        ufs.add(uf); 
                    }); 
        } 
        retornar ufs; 
    } 
}

3.1 Configuração

A classe de entidade DataChangeFillHbaseDatabase conclui a integração da interface

classe pública DataChangeFillHbaseDatabase<T> estende AbstracDataChange<Put,T> { 
    contagem int estática; 

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

    @Override 
    public List<T> change(String line) { 
        return stringToEntity.change(line); 
    } 

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

// puts.forEach( System.out::
        escritor.write(puts,tableName); 
        System.out.println("hu obteve dados kafka======>"+count++); 

    } 
}

3.2 Configurar classes de entidade

# Entidade classe 1

@Data 
@AllArgsConstructor 
@NoArgsConstructor 
@Builder 
public class EventAttendees { 
    private String eventid; 
    string privada ID do usuário; 
    resposta de string privada; 
}

# Entidade classe 2

@Data 
@AllArgsConstructor 
@NoArgsConstructor 
@Builder 
public class Eventos { 
    private String eventid; 
    string privada ID do usuário; 
    horário de início da string privada; 
    cidade privada de String; 
    estado de String privado; 
    zip de string privada; 
    país String privado; 
    string privada lat; 
    string privada lng; 
} 

# 实体类 3

@Data 
@AllArgsConstructor 
@NoArgsConstructor 
@Builder 
public class UserFriends { 
    private String userid; 
    private String amigo; 
}

 3.3 Configure a camada de serviço para leitura e gravação de arquivos

# 接口 escritor 
public interface Writer<T> {
    void write(List<T> puts, String tableName); 
}

#Classe de implementação de interface

/** 
 * Aceita o conjunto de dados list<put> convertido e preenche-o no banco de dados hbase 
 */ 
@Component 
public class HbaseWriter implements Writer<Put> { 
    @Resource 
    private Connection connection; 
    public void write(List<Put> puts,String tableName) { 
        try { 
            Table table = connection.getTable(TableName.valueOf(tableName)); 
            table.put(puts); 
        } catch (IOException e) { 
            e.printStackTrace(); 
        } 
    } 
}

Aula #KafkaReader

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

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

    @KafkaListener(groupId = "cm", tópicos = {"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,"eventsattend"); 
        ack.acknowledge(); 
    } 

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

3.4 configuração hbase 

@Configuration 
public class 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"); 
        retornar cfg; 
    } 
    @Bean 
    @Scope(value = "prototype") 
    public Connection getConnection(){ 
        Connection connection = null; 
        tente { 
            conexão = ConnectionFactory.createConnection(getConfig()); 
        } catch (IOException e) { 
            e.printStackTrace(); 
        } 
        retornar conexão; 
    }
    @Bean 
    public Supplier<Connection> hBaseConnection(){ 
        return this::getConnection; 
    } 
}