大厂 -doris中间件搭配java idea 使用 streamload上传数据

最新推荐文章于 2024-04-30 17:28:01 发布
最新推荐文章于 2024-04-30 17:28:01 发布
阅读量3k 收藏 3
点赞数
分类专栏： 日常学习 文章标签： java 开发语言 spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39018604/article/details/123742636
版权

doris中间件搭配java idea 使用

目录结构：

在这里插入图片描述
在这里插入图片描述
properties文件内容
在这里插入图片描述
在这里插入图片描述



mysql.datasource.doris.url=jdbc:mysql://doris-ip:端口号/数据库名字?allowMultiQueries=true&useSSL=false&rewriteBatchedStatements=true&multiStatementAllow=true
mysql.datasource.doris.username=root
mysql.datasource.doris.password=
mysql.datasource.doris.driver-class-name=com.mysql.jdbc.Driver
mysql.datasource.doris.minIdle=1
mysql.datasource.doris.maxActive=3
mysql.datasource.doris.initialSize=1
mysql.datasource.doris.maxWait=60000
mysql.datasource.doris.timeBetweenEvictionRunsMillis=60000
mysql.datasource.doris.minEvictableIdleTimeMillis=300000
mysql.datasource.doris.validationQuery=select 'x'
mysql.datasource.doris.testWhileIdle=true
mysql.datasource.doris.testOnBorrow=false
mysql.datasource.doris.testOnReturn=false
mysql.datasource.doris.poolPreparedStatements=true
mysql.datasource.doris.maxPoolPreparedStatementPerConnectionSize=50
mysql.datasource.doris.removeAbandoned=true
mysql.datasource.doris.filters=stat



mybatis.mapper-locations=classpath*:/mapper/*.xml
mysql.datasource.configLocation=classpath:mybatis-config.xml

mybatis-config.xml 内容

<?xml version="1.0" encoding="UTF-8" ?>
<!-- mybatis的配置文件 -->
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <settings>
        <setting name="lazyLoadingEnabled" value="false"/>
        <setting name="defaultStatementTimeout" value="25000"/>
<!--        <setting name="logPrefix" value="jd.wl.mybatis."/>-->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
        <!--		<setting name="logImpl" value="STDOUT_LOGGING"/>-->
    </settings>
</configuration>

@Target({ElementType.FIELD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DorisLoad {
    /**
     * @return 文件中排序，不能重复
     */
    int sort() default 0;

    /**
     * @return 对应列名
     */
    String col() default "";

    /**
     * @return 对应表名
     */
    String table() default "";

    /**
     * @return 对应表名
     */
    String defaultValue() default "";

}

import lombok.Data;
import org.springframework.beans.factory.annotation.Configurable;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;

import java.util.Map;

@Data
@Configuration
@EnableAutoConfiguration
@ConfigurationProperties(prefix = "mysql.datasource")
public class DataSourceProperties {

    private Map<String, String> doris;

}

import cn.hutool.db.ds.druid.DruidDSFactory;
import com.alibaba.druid.pool.DruidDataSource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;

import javax.annotation.Resource;
import java.sql.SQLData;
import java.sql.SQLException;
import java.time.Duration;
import java.util.Map;


@Slf4j
@Configuration
@EnableAutoConfiguration
public class DataSourceConfiguration {

    @Resource
    private DataSourceProperties dataSourceProperties;

    public static DruidDataSource getDataSource(Map<String, String> params) throws SQLException{
        DruidDataSource datasource = new DruidDataSource();
        datasource.setUrl(params.get("url"));
        datasource.setUsername(params.get("username"));
        datasource.setPassword(params.get("password"));
        if (params.containsKey("initialSize")) {
            datasource.setInitialSize(Integer.parseInt(params.get("initialSize")));
        }
        if (params.containsKey("minIdle")) {
            datasource.setMinIdle(Integer.parseInt(params.get("minIdle")));
        }
        if (params.containsKey("maxActive")) {
            datasource.setMaxActive(Integer.parseInt(params.get("maxActive")));
        }
        if (params.containsKey("maxWait")) {
            datasource.setMaxWait(Long.parseLong(params.get("maxWait")));
        }
        if (params.containsKey("timeBetweenEvictionRunsMillis")) {
            datasource.setTimeBetweenEvictionRunsMillis(Long.parseLong(params.get("timeBetweenEvictionRunsMillis")));
        }
        if (params.containsKey("minEvictableIdleTimeMillis")) {
            datasource.setMinEvictableIdleTimeMillis(Long.parseLong(params.get("minEvictableIdleTimeMillis")));
        }
        if (params.containsKey("validationQuery")) {
            datasource.setValidationQuery(params.get("validationQuery"));
        }
        if (params.containsKey("testWhileIdle")) {
            datasource.setTestWhileIdle(Boolean.parseBoolean(params.get("testWhileIdle")));
        }
        if (params.containsKey("testOnBorrow")) {
            datasource.setTestOnBorrow(Boolean.parseBoolean(params.get("testOnBorrow")));
        }
        if (params.containsKey("testOnReturn")) {
            datasource.setTestOnBorrow(Boolean.parseBoolean(params.get("testOnReturn")));
        }
        if (params.containsKey("poolPreparedStatements")) {
            datasource.setPoolPreparedStatements(Boolean.parseBoolean(params.get("poolPreparedStatements")));
        }
        if (params.containsKey("maxPoolPreparedStatementPerConnectionSize")) {
            datasource.setMaxPoolPreparedStatementPerConnectionSize(
                    Integer.parseInt(params.get("maxPoolPreparedStatementPerConnectionSize")));
        }
        if (params.containsKey("filters")) {
            datasource.setFilters(params.get("filters"));
        }
        if (params.containsKey("connectionProperties")) {
            datasource.setConnectionProperties(params.get("connectionProperties"));
        }
        return datasource;

    }

  

    @Bean( name = "dorisDataSource", initMethod = "init")
    public DruidDataSource dorisDataSource(){
        log.info("-------------------dorisDataSource init-----------------------");

        try {
           return getDataSource(dataSourceProperties.getDoris());
        } catch (SQLException e) {
            log.error("初始化 doris 数据库源失败", e);
        }
        return  null;
    }
}

下面这个是核心文件




import com.alibaba.druid.pool.DruidDataSource;
import io.swagger.annotations.Authorization;
import lombok.Data;

import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.session.SqlSessionFactory;
import org.example.doman.DataSourceType;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.DefaultResourceLoader;
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
import org.springframework.transaction.PlatformTransactionManager;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

@Slf4j
@Configuration
@AutoConfigureAfter(DataSourceConfiguration.class)
public class MybatisConfiguration {

    @Value("${mybatis.mapper-locations}")
    private String mapperLocations;
    @Value("${mysql.datasource.configLocation}")
    private String configLocation;

    @javax.annotation.Resource
    @Qualifier("predictDataSource")
    private DruidDataSource predictDataSource;

    @javax.annotation.Resource
    @Qualifier("dorisDataSource")
    private DruidDataSource dorisDataSource;


    @Bean(name = "sqlSessionFactory")
    public SqlSessionFactory sqlSessionFactory(){
        log.info("--------------------  sqlSessionFactory init ---------------------");
        try {
        SqlSessionFactoryBean sessionFactoryBean = new SqlSessionFactoryBean();
        



        //设置mapper.xml文件所在位置
        Resource[] resources = new PathMatchingResourcePatternResolver().getResources(mapperLocations);
        sessionFactoryBean.setMapperLocations(resources);
        //设置mybatis-config.xml配置文件位置
        sessionFactoryBean.setConfigLocation(new DefaultResourceLoader().getResource(configLocation));
        return sessionFactoryBean.getObject();

        } catch (IOException e) {
            log.error("mybatis resolver mapper*xml is error", e);
            return null;
        } catch (Exception e) {
            log.error("mybatis sqlSessionFactoryBean create error", e);
            return null;
        }
    }

//这个是用于多源数据的方法可以把这部分去掉
    @Bean(name = "roundRobinDataSourceProxy")
    public AbstractRoutingDataSource roundRobinDataSourceProxy() {
        Map<Object, Object> targetDataSources = new HashMap<Object, Object>();
        //把所有数据库都放在targetDataSources中,注意key值要和determineCurrentLookupKey()中代码写的一至，
        //否则切换数据源时找不到正确的数据源
        targetDataSources.put(DataSourceType.PREDICT.getType(), predictDataSource);
        targetDataSources.put(DataSourceType.DORIS.getType(), dorisDataSource);

        //路由类，寻找对应的数据源
        AbstractRoutingDataSource proxy = new RoundRobinRoutingDataSource(2);
        //默认库
        proxy.setDefaultTargetDataSource(predictDataSource);
        proxy.setTargetDataSources(targetDataSources);
        return proxy;
    }

    @Bean
    public SqlSessionTemplate sqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
        return new SqlSessionTemplate(sqlSessionFactory);
    }

    /**
     * 事务管理
     * @param roundRobinDataSourceProxy
     * @return
     */
    @Bean
    public PlatformTransactionManager transactionManager(AbstractRoutingDataSource roundRobinDataSourceProxy) {
        return new DataSourceTransactionManager(roundRobinDataSourceProxy);
    }
}

也是核心配置文化

package org.example.config;

import com.alibaba.cola.exception.BizException;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.codec.binary.Base64;
import org.apache.commons.io.FileUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.http.HttpHeaders;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpPut;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.FileEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.DefaultRedirectStrategy;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.example.util.DateUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.PropertySource;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
import org.springframework.util.ReflectionUtils;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.lang.reflect.Field;
import java.nio.charset.StandardCharsets;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * DorisStreamLoader
 *
 */
@Component
@Slf4j
@PropertySource("classpath:application.properties")
@ConfigurationProperties(prefix = "doris.stream")
public class DorisStreamLoader {

    /**
     * doris状态
     */
    private static final String DORIS_STATUS = "Status";
    /**
     * doris错误信息
     */
    private static final String DORIS_MESSAGE = "Message";
    /**
     * doris总数量
     */
    private static final String DORIS_TOTAL_ROWS = "NumberTotalRows";
    /**
     * doris成功数量
     */
    private static final String DORIS_LOADED_ROWS = "NumberLoadedRows";


    /**
     *
     */
    @Value("${doris.stream.domain}")
    private String domain;
    /**
     * 数据库
     */
    @Value("${doris.stream.db}")
    private String db;
    /**
     * 用户
     */
    @Value("${doris.stream.user}")
    private String user;
    /**
     * 密码
     */
    @Value("${doris.stream.password}")
    private String password;

    /**
     * 最多重试5次,100次会jsf超时
     */
    private final static int MAX_RETRY = 5;
    private final static int RETRY_SLEEPMS = 5000;


    /**
     * 采用 stream load方式，将 doris数据对象 装入到 doris表中
     *
     * @param clazz 数据对象
     * @param list  列表对象
     */
    public <T> int load(Class<T> clazz, Collection<T> list) {
        if (CollectionUtils.isEmpty(list)) {
            return 0;
        }

        DorisLoad dorisLoad = clazz.getAnnotation(DorisLoad.class);
        if (dorisLoad == null || StringUtils.isEmpty(dorisLoad.table())) {
            throw new BizException("未设置对应doris表");
        }

        Field[] fields = clazz.getDeclaredFields();
        List<Field> fieldList = Stream.of(fields)
                .filter(field -> field.getAnnotation(DorisLoad.class) != null)
                .sorted(
                        Comparator.comparing(
                                field -> field.getAnnotation(DorisLoad.class).sort()
                        )).collect(Collectors.toList());

        StringBuilder colSb = new StringBuilder();

        for (Field field : fieldList) {
            colSb.append(field.getAnnotation(DorisLoad.class).col()).append(",");
            field.setAccessible(true);
        }

        String cols = colSb.substring(0, colSb.length() - 1);

        File file = null;
        // 重试循环
        boolean succeed = false;
        int retry = 0;
        int resultCount = 0;
        while (!succeed && retry < MAX_RETRY) {
            try {
                file = buildContent(list, fieldList);
                String rt = sendData(dorisLoad.table(), file, UUID.randomUUID().toString(), cols);
                JSONObject jsonObject = JSON.parseObject(rt);
                if (jsonObject != null) {
                    log.info("sendData dorisLoad.table():{}，结果:{}", dorisLoad.table(), rt);
                    DorisLoadResultCo resultCo = getResult(jsonObject.getString(DORIS_STATUS),
                            jsonObject.getString(DORIS_MESSAGE),
                            jsonObject.getInteger(DORIS_TOTAL_ROWS),
                            jsonObject.getInteger(DORIS_LOADED_ROWS));
                    log.info("resultCo: {}", resultCo);

                    // 收到结果不验证，直接成功
                    succeed = true;
                    resultCount = resultCo.getLoadedQty();
                }
            } catch (Exception e) {
                log.warn(String.format("数据上传异常, 重试次数 %s", retry), e);
                try {
                    Thread.sleep(RETRY_SLEEPMS);
                } catch (Exception e2) {
                    log.warn("", e2);
                }
            } finally {
                retry++;
                if (file != null) {
                    file.delete();
                }
            }
        }
        if (!succeed) {
            throw new BizException(String.format("数据上传异常, 重试次数 %s", retry));
        }
        return resultCount;
    }


    public <T> File loadBuildContent(Class<T> clazz, Collection<T> list,File tempFile) {
        if (CollectionUtils.isEmpty(list)) {
            return null;
        }

        DorisLoad dorisLoad = clazz.getAnnotation(DorisLoad.class);
        if (dorisLoad == null || StringUtils.isEmpty(dorisLoad.table())) {
            throw new BizException("未设置对应doris表");
        }

        Field[] fields = clazz.getDeclaredFields();
        List<Field> fieldList = Stream.of(fields)
                .filter(field -> field.getAnnotation(DorisLoad.class) != null)
                .sorted(
                        Comparator.comparing(
                                field -> field.getAnnotation(DorisLoad.class).sort()
                        )).collect(Collectors.toList());

        StringBuilder colSb = new StringBuilder();

        for (Field field : fieldList) {
            colSb.append(field.getAnnotation(DorisLoad.class).col()).append(",");
            field.setAccessible(true);
        }
        File file = null;
        try {
            file = buildContent(list, fieldList,tempFile);
        } catch (Exception e) {
            log.error("doris组装数据出现错误",e);
        }
        return file;
    }


    public <T> int batchload(Class<T> clazz, File file) {
        if(Objects.isNull(file)){
            return 0;
        }

        DorisLoad dorisLoad = clazz.getAnnotation(DorisLoad.class);
        if (dorisLoad == null || StringUtils.isEmpty(dorisLoad.table())) {
            throw new BizException("未设置对应doris表");
        }

        Field[] fields = clazz.getDeclaredFields();
        List<Field> fieldList = Stream.of(fields)
                .filter(field -> field.getAnnotation(DorisLoad.class) != null)
                .sorted(
                        Comparator.comparing(
                                field -> field.getAnnotation(DorisLoad.class).sort()
                        )).collect(Collectors.toList());

        StringBuilder colSb = new StringBuilder();

        for (Field field : fieldList) {
            colSb.append(field.getAnnotation(DorisLoad.class).col()).append(",");
            field.setAccessible(true);
        }

        String cols = colSb.substring(0, colSb.length() - 1);

        // 重试循环
        boolean succeed = false;
        int retry = 0;
        int resultCount = 0;
        while (!succeed && retry < MAX_RETRY) {
            try {

                String rt = sendData(dorisLoad.table(), file, UUID.randomUUID().toString(), cols);
                JSONObject jsonObject = JSON.parseObject(rt);
                if (jsonObject != null) {
                    log.info("sendData dorisLoad.table():{}，结果:{}", dorisLoad.table(), rt);
                    DorisLoadResultCo resultCo = getResult(jsonObject.getString(DORIS_STATUS),
                            jsonObject.getString(DORIS_MESSAGE),
                            jsonObject.getInteger(DORIS_TOTAL_ROWS),
                            jsonObject.getInteger(DORIS_LOADED_ROWS));
                    log.info("resultCo: {}", resultCo);

                    // 收到结果不验证，直接成功
                    succeed = true;
                    resultCount = resultCo.getLoadedQty();
                }
            } catch (Exception e) {
                log.warn(String.format("数据上传异常, 重试次数 %s", retry), e);
                try {
                    Thread.sleep(RETRY_SLEEPMS);
                } catch (Exception e2) {
                    log.warn("", e2);
                }
            } finally {
                retry++;
                if (file != null) {
                    file.delete();
                }
            }
        }
        if (!succeed) {
            throw new BizException(String.format("数据上传异常, 重试次数 %s", retry));
        }
        return resultCount;
    }



    /**
     * 获取文件内容
     *
     * @param dataList 传入数组
     * @return 字符串
     */
    private <T> File buildContent(Collection<T> dataList, List<Field> fieldList) throws Exception {
        StringBuilder content = new StringBuilder();
        dataList.forEach(
                data -> {
                    StringBuilder sb = new StringBuilder();
                    fieldList.forEach(
                            field -> {
                                try {
                                    sb.append(getFormatData(field, data)).append("\t");
                                } catch (Exception e) {
                                    log.error("buildContent异常", e);
                                    throw new RuntimeException("生成文档出错");
                                }
                            }
                    );
                    sb.replace(sb.length() - 1, sb.length(), "\n");
                    content.append(sb);

                }
        );

        File file = File.createTempFile("doris_", "txt");

        try (FileOutputStream fos = new FileOutputStream(file)) {
            fos.write(content.toString().getBytes());
            log.info("buildContent 生成文件 {} ", file.getAbsolutePath());
        } catch (Exception e) {
            log.error("buildContent生成文件异常  {}", file.getAbsolutePath());
            file.delete();
        }
        return file;
    }

    private <T> File buildContent(Collection<T> dataList, List<Field> fieldList,File tempFile) throws Exception {
        StringBuilder content = new StringBuilder();
        dataList.forEach(
                data -> {
                    StringBuilder sb = new StringBuilder();
                    fieldList.forEach(
                            field -> {
                                try {
                                    sb.append(getFormatData(field, data)).append("\t");
                                } catch (Exception e) {
                                    log.error("buildContent异常", e);
                                    throw new RuntimeException("生成文档出错");
                                }
                            }
                    );
                    sb.replace(sb.length() - 1, sb.length(), "\n");
                    content.append(sb);

                }
        );
        File file;
        if(tempFile == null){
            file= File.createTempFile("doris_", "txt");
            try (FileOutputStream fos = new FileOutputStream(file)) {
                fos.write(content.toString().getBytes());
                log.info("buildContent 生成文件 {} ", file.getAbsolutePath());
            } catch (Exception e) {
                log.error("buildContent生成文件异常  {}", file.getAbsolutePath());
                file.delete();
            }
        }else{
            file=tempFile;
            byte[] bytes = content.toString().getBytes();
            FileUtils.writeByteArrayToFile(file,bytes,true);
            log.info("buildContent 追加 {} ", file.getAbsolutePath());
        }
        return file;
    }

    /**
     * 返回格式化后的值
     *
     * @param field 变量
     * @param data  数据
     * @param <T>   类型
     * @return 结果
     */
    private <T> Object getFormatData(Field field, T data) {
        Object obj = ReflectionUtils.getField(field, data);
        if (obj == null) {
            return field.getAnnotation(DorisLoad.class).defaultValue();
        }
        if (obj instanceof String) {
            return ((String) obj)
                    .replaceAll("\t", StringUtils.EMPTY)
                    .replaceAll("\n", StringUtils.EMPTY);
        }
        if (obj instanceof Date) {
            return DateUtils.format((Date) obj, DateUtils.FORMAT_TIME);
        }

        return obj;
    }


    /**
     * load公用方法
     *
     * @param table 表
     * @param file  内容
     * @param label 流水
     * @throws Exception 异常
     */
    private String sendData(String table, File file, String label, String column) throws Exception {
        log.info("sendData start  table:{},column:{}", table, column);

        try {
            return doSendData(table, file, label, column);
        } catch (IOException e) {
            try {
                return doSendData(table, file, label, column);
            } catch (Exception ex) {
                log.error("doSendData Exception table:{},label:{}，{}", table, label, ex);
                throw ex;
            }
        } catch (Exception ex) {
            log.error("doSendData Exception table:{},label:{}，{}", table, label, ex);
            throw ex;
        }
    }

    /**
     * load公用方法
     *
     * @param table 表
     * @param file  内容
     * @param label 流水
     * @throws Exception 异常
     */
    private String doSendData(String table, File file, String label, String column) throws Exception {
        final HttpClientBuilder httpClientBuilder = HttpClients
                .custom()
                .setRedirectStrategy(new DefaultRedirectStrategy() {
                    @Override
                    protected boolean isRedirectable(String method) {
                        return true;
                    }
                });

        try (CloseableHttpClient client = httpClientBuilder.build()) {
            try (CloseableHttpResponse response = client.execute(buildPut(table, file, label, column))) {
                String loadResult = "";
                if (response.getEntity() != null) {
                    loadResult = EntityUtils.toString(response.getEntity());
                }
                final int statusCode = response.getStatusLine().getStatusCode();
                if (statusCode != 200) {
                    throw new IOException(
                            String.format("Stream load failed, statusCode=%s load result=%s", statusCode, loadResult));
                }

                log.info("sendData end table:{}", table);
                return loadResult;
            }
        }
    }

    /**
     * 获取http客户端
     *
     * @param table 表名
     * @param file  内容
     * @param label 流水
     * @return 客户端
     */
    private HttpPut buildPut(String table, File file, String label, String cols) {
        HttpPut put = new HttpPut(getUrl(table));
        FileEntity entity = new FileEntity(file, ContentType.APPLICATION_OCTET_STREAM);
        put.setHeader(HttpHeaders.EXPECT, "100-continue");
        put.setHeader(HttpHeaders.AUTHORIZATION, basicAuthHeader());
        put.setHeader("label", label);
        // 导入容错率设置为100%，即不会失败
        put.setHeader("max_filter_ratio", "1");
        if (StringUtils.isNotEmpty(cols)) {
            put.setHeader("columns", cols);
        }
        put.setEntity(entity);
        return put;
    }

    /**
     * 加密账号
     *
     * @return 密文
     */
    private String basicAuthHeader() {
        final String tobeEncode = user + ":" + password;
        byte[] encoded = Base64.encodeBase64(tobeEncode.getBytes(StandardCharsets.UTF_8));
        return "Basic " + new String(encoded);
    }

    /**
     * load的url
     *
     * @param table 表
     * @return url
     */
    private String getUrl(String table) {
        return String.format("%s/api/%s/%s/_stream_load", domain, db, table);
    }

    /**
     * 获取结果
     *
     * @param status    状态
     * @param message   错误信息
     * @param totalQty  总数量
     * @param loadedQty 成功数量
     * @return 结果
     */
    private DorisLoadResultCo getResult(String status, String message, Integer totalQty, Integer loadedQty) {
        return new DorisLoadResultCo(status, message, totalQty, loadedQty);
    }
}
813654432
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
jdbc连接数据库
10-15
java连接数据库，从连接驱动到数据库用户到连接最后的datebase，sql语句对数据库的操作。
apache-doris-flink-connector-1.14_2.12-1.0.3
05-05
Flink Doris Connector（apache-doris-flink-connector-1.14_2.12-1.0.3-incubating-src.tar.gz） Flink Doris Connector Version：1.0.3 Flink Version：1.14 Scala Version：2.12 Apache Doris是一个现代MPP分析数据库产品。它可以提供亚秒级查询和高效的实时数据分析。通过它的分布式架构，高达10PB级的数据集将得到很好的支持，易于操作。 Apache Doris可以满足各种数据分析需求，包括历史数据报告、实时数据分析、交互式数据分析和探索性数据分析。让您的数据分析更容易!
Doris数据库--导入数据之 stream load Java调FE接口上传文件导入数据
qq_1391237686的博客
03-26 545
Doris数据库--导入数据之 stream load Java调FE接口上传文件导入数据
DorisDB系列文档(九) 数据导入简介
HANG.NIAN
04-25 1675
1 简介 为了更好地满足各种不同的业务场景，DorisDB支持多种数据模型，DorisDB中存储的数据需要按照特定的模型进行组织。数据导入功能是将原始数据按照相应的模型进行清洗转换并加载到DorisDB中，方便查询使用。 DorisDB提供了多种导入方式，用户可以根据数据量大小、导入频率等要求选择最适合自己业务需求的导入方式。本节介绍数据导入的基本概念、基本原理、系统配置、不同导入方式的适用场景，以及一些最佳实践案例和常见问题。 导入作业：导入作业读取用户提交的源数据并进行清洗转换后，将数据导入到Do
什么是IDE
斜阳雨陌
05-18 1811
集成开发环境（IDE，Integrated Development Environment ）是用于提供程序开发环境的应用程序，一般包括代码编辑器、编译器、调试器和图形用户界面等工具。集成了代码编写功能、分析功能、编译功能、调试功能等一体化的开发软件服务套。所有具备这一特性的软件或者软件套（组）都可以叫集成开发环境。如微软的Visual Studio系列，Borland的C++ Build
Ubuntu14.04 LTS 安装Doris、StaMPS、ROI_PAC
IvanLJF的专栏
04-17 7727
1、软件下载网址：1）Doris下载网址：http://doris.tudelft.nl/ 2）Doris软件最新的信息总可以在这个网址上查到：http://enterprise.tudelft.nl/doris/3）StaMPS官方网址：http://homepages.see.leeds.ac.uk/~earahoo/stamps/4）SNAPHU:（Statistical-Cost, Net
Doris应用指南
03-09
简介Doris软件安装，应用，环境变量的配置等等
海量数据分析引擎Apache Doris入门及实战
01-25
本门课程主要讲解百度开源海量数据分析引擎Apache Doris的从概念、编译、安装到编程实战。第一部分我会讲解Doris的基本概念，告诉大家Doris的使用场景，明白我们为什么使用Doris，另外有哪些公司在使用Doris；第二部分会学习Doris的手动编译、单机部署和集群部署以及可视化的工具；第三部分我们介绍Doris的基本操作；第四部分会介绍Doris的账号和权限；最后会带着大家进行SpringBoot操作Doris的实战开发。
【doris的安装部署】
weixin_56425963的博客
03-31 1660
1.下载百度Palo预编译版本，不需要编译源码，直接安装就行。2.下载Apache Doris源码用docker进行编译。
Apache Doris 系列： 基础篇-JAVA执行Stream Load
修破立生
09-16 1773
Stream Load 的本质是调用 Doris BE 节点的 HTTP API 来实现数据的导入，因为我们可以用JAVA HTTP CLIENT 来实现数据的导入。
Doris入门到精通-阶段一（简介&安装&使用）
S1124654的博客
09-11 8037
Doris入门到精通-阶段一（简介&安装&使用）
apache-doris-spark-connector-2.3_2.11-1.0.1
05-05
Spark Doris Connector（apache-doris-spark-connector-2.3_2.11-1.0.1-incubating...Apache Doris可以满足各种数据分析需求，包括历史数据报告、实时数据分析、交互式数据分析和探索性数据分析。让您的数据分析更容易!
apache-doris-flink-connector-1.13_2.12-1.0.3
05-05
Flink Doris Connector 源码（apache-doris-flink-connector-1.13_2.12-1.0.3-...Apache Doris可以满足各种数据分析需求，包括历史数据报告、实时数据分析、交互式数据分析和探索性数据分析。让您的数据分析更容易!
apache-doris-flink-connector-1.11_2.12-1.0.3
05-05
Flink Doris Connector（apache-doris-flink-connector-1.11_2.12-1.0.3-...Apache Doris可以满足各种数据分析需求，包括历史数据报告、实时数据分析、交互式数据分析和探索性数据分析。让您的数据分析更容易!
apache-doris-spark-connector-3.1_2.12-1.0.1
05-05
Spark Doris Connector（apache-doris-spark-connector-3.1_2.12-1.0.1-incubating...Apache Doris可以满足各种数据分析需求，包括历史数据报告、实时数据分析、交互式数据分析和探索性数据分析。让您的数据分析更容易!
Day25-Java基础之常用类1
m0_46053885的博客
04-27 1124
同时我们发现Math类中的方法都是静态的，因此在使用的时候我们可以直接通过类名去调用。对于计算机而言，其实是没有数据类型的概念的，都是0101010101，数据类型是编程语言自己规定的，所以在实际存储的时候，先把具体的数字变成二进制，每32个bit为一组，存储在数组中。比较内存地址值一般情况下是没有意义的，我们希望比较的是对象的属性，如果两个对象的属性相同，我们认为就是同一个对象；如果我们的数据是一个浮点类型的数据，有的时候计算机并不会将这个数据完全转换成一个二进制数据，而是将这个将其转换成一个无限的。
链表刷题集
最新发布
yajunjiao的专栏
04-30 503
本文主要列举了一些刷的题，不多，有那么几道，也建议各位去建立自己的刷题集。积少成多。
d15(136-148)-勇敢开始Java，咖啡拯救人生
m0_73459387的博客
04-28 1100
对象哈希值的特点：同一个对象调用hashCode()返回的哈希值相同；HashMap的键依赖hashCode方法和equals方法保证键的唯一，存储自定义类型的对象时，重写这两个方法。实际上，Set系列集合的底层就是基于Map实现的，只是Set集合中的元素要键数据，不要值数据。当12个位置都占满时就会扩容，大约扩容为原来的二倍，再把原数组数据转移到新数组。使用迭代器遍历集合时，又同时在删除集合中的数据，程序就会出现并发修改异常的错误。基于哈希表实现，每个键值对额外多了一个双链表的机制，记录元素顺序（保证。
Java解决最长公共前缀
无人罪的博客
04-28 396
编写一个函数来查找字符串数组中的最长公共前缀。如果不存在公共前缀，返回空字符串""。
flink-cdc-doris jar下载
01-18
要下载flink-cdc-doris jar，您可以按照以下步骤进行操作： 首先，您需要打开Flink的官方网站（https://flink.apache.org/）并导航到Flink的下载页面。 在Flink的下载页面上，您将找到一系列可用的Flink版本。找到与您当前使用的Flink版本兼容的版本。 一旦您选择了正确的Flink版本，您需要找到与Flink CDC Doris集成的jar文件。您可以使用浏览器的查找功能或直接搜索“Flink CDC Doris jar”以快速定位该文件。 一旦您找到了该文件，点击下载按钮将开始下载该jar文件。请根据您的网络速度耐心等待下载完成。 下载完成后，请确认jar文件是否位于您计算机的指定位置。您可以使用文件管理器或命令行工具进行确认。 最后，您已经成功下载了flink-cdc-doris jar文件。您可以将该文件用于您的Flink项目中，以实现与Doris数据库的CDC（变更数据捕获）集成。 请注意，以上步骤仅适用于一般的jar文件下载。如果您有特定的网站或资源需要用于下载flink-cdc-doris jar文件，请参考该资源的具体指导。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值