AlienPaul
AlienPaul

Flink Hudi 源码之HoodieTableSink

Flink源码分析系列文档目录

请点击：Flink 源码分析系列文档目录

源代码分支

release-0.9.0

Hudi 源代码GitHub地址：apache/hudi: Upserts, Deletes And Incremental Processing on Big Data. (github.com)

HoodieTableFactory

Flink通过SPI机制加载org.apache.flink.table.factories.Factory接口的实现类。Hudi的hudi-flink/src/main/resources/META-INF/services/org.apache.flink.table.factories.Factory文件内容如下：

org.apache.hudi.table.HoodieTableFactory

这个类是Flink SQL创建Table Sink和Source的入口类。本篇我们从这个类开始，分析HoodieTableSink的创建过程。创建TableSink的入口方法逻辑如下：

@Override
public DynamicTableSink createDynamicTableSink(Context context) {
    // 获取create table是否with子句附带的参数
    Configuration conf = FlinkOptions.fromMap(context.getCatalogTable().getOptions());
    // 获取表的物理Schema，意思是不包含计算字段和元数据字段
    TableSchema schema = TableSchemaUtils.getPhysicalSchema(context.getCatalogTable().getSchema());
    // 检查参数合理性
    // 检查hoodie.datasource.write.recordkey.field和write.precombine.field配置项是否包含在表字段中，如果不包含则抛出异常
    sanityCheck(conf, schema);
    // 根据table定义和主键等配置，Hudi自动附加一些属性配置
    setupConfOptions(conf, context.getObjectIdentifier().getObjectName(), context.getCatalogTable(), schema);
    // 返回HoodieTableSink
    return new HoodieTableSink(conf, schema);
}

HoodieTableSink

Flink SQL在执行过程中最终被解析转换为Flink的TableSink或者TableSource。本篇我们关注数据写入Hudi的过程。HoodieTableSink写入数据的逻辑位于getSinkRuntimeProvider方法。它的内容和解析如下所示：

@Override
public SinkRuntimeProvider getSinkRuntimeProvider(Context context) {
    return (DataStreamSinkProvider) dataStream -> {

        // setup configuration
        // 获取checkpoint超时配置
        long ckpTimeout = dataStream.getExecutionEnvironment()
            .getCheckpointConfig().getCheckpointTimeout();
        // 设置Hudi的instant commit超时时间为Flink的checkpoint超时时间
        conf.setLong(FlinkOptions.WRITE_COMMIT_ACK_TIMEOUT, ckpTimeout);

        // 获取schema对应每列数据类型
        RowType rowType = (RowType) schema.toRowDataType().notNull().getLogicalType();

        // bulk_insert mode
        // 获取写入操作类型，默认是upsert
        final String writeOperation = this.conf.get(FlinkOptions.OPERATION);
        // 如果写入操作类型配置的为bulk_insert，进入这个if分支
        if (WriteOperationType.fromValue(writeOperation) == WriteOperationType.BULK_INSERT) {
            // 创建出批量插入operator工厂类
            BulkInsertWriteOperator.OperatorFactory operatorFactory = BulkInsertWriteOperator.getFactory(this.conf, rowType);
           // 获取分区字段
            final String[] partitionFields = FilePathUtils.extractPartitionKeys(this.conf);
            if (partitionFields.length > 0) {
                // 创建出key生成器，用于指定数据分组，keyBy算子使用
                RowDataKeyGen rowDataKeyGen = RowDataKeyGen.instance(conf, rowType);
                // 如果启用write.bulk_insert.shuffle_by_partition
                if (conf.getBoolean(FlinkOptions.WRITE_BULK_INSERT_SHUFFLE_BY_PARTITION)) {

                    // shuffle by partition keys
                    // 数据流按照分区字段值进行keyBy操作
                    dataStream = dataStream.keyBy(rowDataKeyGen::getPartitionPath);
                }
                // 如果需要按照分区排序
                if (conf.getBoolean(FlinkOptions.WRITE_BULK_INSERT_SORT_BY_PARTITION)) {
                    // 创建一个排序operator
                    SortOperatorGen sortOperatorGen = new SortOperatorGen(rowType, partitionFields);
                    // sort by partition keys
                    // 为datastream增加一个排序操作符
                    dataStream = dataStream
                        .transform("partition_key_sorter",
                                   TypeInformation.of(RowData.class),
                                   sortOperatorGen.createSortOperator())
                        .setParallelism(conf.getInteger(FlinkOptions.WRITE_TASKS));
                    ExecNode$.MODULE$.setManagedMemoryWeight(dataStream.getTransformation(),
                                                             conf.getInteger(FlinkOptions.WRITE_SORT_MEMORY) * 1024L * 1024L);
                }
            }
            // 为dataStream加入批量写入operator并返回
            return dataStream
                .transform("hoodie_bulk_insert_write",
                           TypeInformation.of(Object.class),
                           operatorFactory)
                // follow the parallelism of upstream operators to avoid shuffle
                .setParallelism(conf.getInteger(FlinkOptions.WRITE_TASKS))
                .addSink(new CleanFunction<>(conf))
                .setParallelism(1)
                .name("clean_commits");
        }
        // 对于非批量写入模式，采用流式写入
        // stream write
        int parallelism = dataStream.getExecutionConfig().getParallelism();
        // 创建流式写入operator
        StreamWriteOperatorFactory operatorFactory = new StreamWriteOperatorFactory<>(conf);

        // 将数据从RowData格式转换为HoodieRecord
        DataStream dataStream1 = dataStream
            .map(RowDataToHoodieFunctions.create(rowType, conf), TypeInformation.of(HoodieRecord.class));

        // bootstrap index
        // TODO: This is a very time-consuming operation, will optimization
        // 是否启动时加载索引
        if (conf.getBoolean(FlinkOptions.INDEX_BOOTSTRAP_ENABLED)) {
            // 如果启用，会在启动时自动加载索引，包装为IndexRecord发往下游
            dataStream1 = dataStream1.rebalance()
                .transform(
                "index_bootstrap",
                TypeInformation.of(HoodieRecord.class),
                new ProcessOperator<>(new BootstrapFunction<>(conf)))
                .setParallelism(conf.getOptional(FlinkOptions.INDEX_BOOTSTRAP_TASKS).orElse(parallelism))
                .uid("uid_index_bootstrap_" + conf.getString(FlinkOptions.TABLE_NAME));
        }

        // 按照record key分区，然后使用ucketAssignFunction分桶
        // 再按照分桶id分区，使用StreamWriteFunction流式写入
        DataStream pipeline = dataStream1
            // Key-by record key, to avoid multiple subtasks write to a bucket at the same time
            .keyBy(HoodieRecord::getRecordKey)
            .transform(
            "bucket_assigner",
            TypeInformation.of(HoodieRecord.class),
            new BucketAssignOperator<>(new BucketAssignFunction<>(conf)))
            .uid("uid_bucket_assigner_" + conf.getString(FlinkOptions.TABLE_NAME))
            .setParallelism(conf.getOptional(FlinkOptions.BUCKET_ASSIGN_TASKS).orElse(parallelism))
            // shuffle by fileId(bucket id)
            .keyBy(record -> record.getCurrentLocation().getFileId())
            .transform("hoodie_stream_write", TypeInformation.of(Object.class), operatorFactory)
            .uid("uid_hoodie_stream_write" + conf.getString(FlinkOptions.TABLE_NAME))
            .setParallelism(conf.getInteger(FlinkOptions.WRITE_TASKS));
        // compaction
        // 如果需要压缩（表类型为MERGE_ON_READ，并且启用了异步压缩）
        if (StreamerUtil.needsAsyncCompaction(conf)) {
            // 首先在coordinator通知checkpoint完毕的时候生成压缩计划
            // 然后使用CompactFunction压缩hudi table数据
            return pipeline.transform("compact_plan_generate",
                                      TypeInformation.of(CompactionPlanEvent.class),
                                      new CompactionPlanOperator(conf))
                .setParallelism(1) // plan generate must be singleton
                .rebalance()
                .transform("compact_task",
                           TypeInformation.of(CompactionCommitEvent.class),
                           new ProcessOperator<>(new CompactFunction(conf)))
                .setParallelism(conf.getInteger(FlinkOptions.COMPACTION_TASKS))
                .addSink(new CompactionCommitSink(conf))
                .name("compact_commit")
                .setParallelism(1); // compaction commit should be singleton
        } else {
            return pipeline.addSink(new CleanFunction<>(conf))
                .setParallelism(1)
                .name("clean_commits");
        }
    };
}


从上面源代码我们可大致梳理出数据入Hudi表的流程：


    

  1. 如果配置了批量插入，采用BulkInsertWriteOperator批量写入数据。根据是否需要排序的要求，决定是否采用SortOperator。
    2. 

  2. 将RowData格式的数据转换为Hudi专用的HoodieRecord格式。
    3. 

  3. 根据配置需要，确定是否使用BootstrapFunction加载索引，此步骤耗时较长。
    4. 

  4. 根据数据的partition分配数据的存储位置（BucketAssignFunction）。
    5. 

  5. 将数据通过流的方式落地StreamWriteFunction。
    6. 

  6. 如果是MOR类型表，且开启了异步压缩，schedule一个压缩操作（CompactionPlanOperator和CompactFunction）。
    7. 



批量插入相关


BulkInsertWriteOperator


BulkInsertWriteOperator使用BulkInsertWriteFunction进行批量数据插入操作。


BulkInsertWriteFunction的初始化逻辑位于open方法中，代码如下所示：


@Override
public void open(Configuration parameters) throws IOException {
    // 获取批量插入数据作业的taskID
    this.taskID = getRuntimeContext().getIndexOfThisSubtask();
    // 创建writeClient，它负责创建index，提交数据和回滚，以及数据增删改查操作
    this.writeClient = StreamerUtil.createWriteClient(this.config, getRuntimeContext());
    // 根据table类型和写入操作类型推断操作类型
    this.actionType = CommitUtils.getCommitActionType(
        WriteOperationType.fromValue(config.getString(FlinkOptions.OPERATION)),
        HoodieTableType.valueOf(config.getString(FlinkOptions.TABLE_TYPE)));

    // 获取上一个进行中的instant时间戳
    this.initInstant = this.writeClient.getLastPendingInstant(this.actionType);
    // 发送一个WriteMetadataEvent到coordinator，结束上一批数据写入过程
    sendBootstrapEvent();
    // 初始化writerHelper，用于辅助进行数据批量插入
    initWriterHelper();
}



该function遇到每一个元素，通过writerHelper将这个元素写入到Parquet文件中。


@Override
public void processElement(I value, Context ctx, Collector out) throws IOException {
    this.writerHelper.write((RowData) value);
}



每一批数据结束后，会调用endInput方法。执行writeHelper关闭和通知coordinator批量插入完毕。


public void endInput() {
    final List writeStatus;
    try {
        // 关闭writeHelper
        this.writerHelper.close();
        // 获取所有HoodieRowDataCreateHandle对应的writeStatus，每个数据写入的partitionPath对应一个handle
        writeStatus = this.writerHelper.getWriteStatuses().stream()
            .map(BulkInsertWriteFunction::toWriteStatus).collect(Collectors.toList());
    } catch (IOException e) {
        throw new HoodieException("Error collect the write status for task [" + this.taskID + "]");
    }
    // 发送本批数据已完全写入的event给coordinator
    final WriteMetadataEvent event = WriteMetadataEvent.builder()
        .taskID(taskID)
        .instantTime(this.writerHelper.getInstantTime())
        .writeStatus(writeStatus)
        .lastBatch(true)
        .endInput(true)
        .build();
    this.eventGateway.sendEventToCoordinator(event);
}



SortOperator


SortOperator用于将一批插入的数据排序后再写入。开启write.bulk_insert.sort_by_partition配置项会启用此特性。


它的初始化逻辑位于open方法，内容和分析如下：


@Override
public void open() throws Exception {
    super.open();
    LOG.info("Opening SortOperator");

    // 获取用户代码classloader
    ClassLoader cl = getContainingTask().getUserCodeClassLoader();

    // 获取RowData序列化器
    AbstractRowDataSerializer inputSerializer =
        (AbstractRowDataSerializer)
        getOperatorConfig().getTypeSerializerIn1(getUserCodeClassloader());
    // 创建Hudi专用的序列化器，传入参数为RowData字段数
    this.binarySerializer = new BinaryRowDataSerializer(inputSerializer.getArity());

    NormalizedKeyComputer computer = gComputer.newInstance(cl);
    RecordComparator comparator = gComparator.newInstance(cl);
    gComputer = null;
    gComparator = null;

    // 获取作业的内存管理器
    MemoryManager memManager = getContainingTask().getEnvironment().getMemoryManager();
    // 使用Flink提供的二进制MergeSort工具对RowData排序
    this.sorter =
        new BinaryExternalSorter(
        this.getContainingTask(),
        memManager,
        computeMemorySize(),
        this.getContainingTask().getEnvironment().getIOManager(),
        inputSerializer,
        binarySerializer,
        computer,
        comparator,
        getContainingTask().getJobConfiguration());
    // 排序工具包含了排序线程，合并线程以及溢写Thread，该方法启动这些线程
    this.sorter.startThreads();

    // 创建结果收集器，用于发送结果到下游
    collector = new StreamRecordCollector<>(output);

    // register the the metrics.
    // 创建监控仪表，包含内存已用字节数，溢写文件数和溢写字节数
    getMetricGroup().gauge("memoryUsedSizeInBytes", (Gauge) sorter::getUsedMemoryInBytes);
    getMetricGroup().gauge("numSpillFiles", (Gauge) sorter::getNumSpillFiles);
    getMetricGroup().gauge("spillInBytes", (Gauge) sorter::getSpillInBytes);
}



SortOperator每次接收到一个RowData类型数据，都把它放入BinaryExternalSorter的缓存中。


@Override
public void processElement(StreamRecord element) throws Exception {
    this.sorter.write(element.getValue());
}



当一批数据插入过程结束时，SortOperator将sorter中以排序的二进制RowData数据顺序取出，发往下游。


@Override
public void endInput() throws Exception {
    BinaryRowData row = binarySerializer.createInstance();
    MutableObjectIterator iterator = sorter.getIterator();
    while ((row = iterator.next(row)) != null) {
        collector.collect(row);
    }
}



RowDataToHoodieFunction


负责将RowData映射为HoodieRecord，转换的逻辑位于toHoodieRecord方法中。


private HoodieRecord toHoodieRecord(I record) throws Exception {
    // 根据AvroSchema，将RowData数据转换为Avro格式
    GenericRecord gr = (GenericRecord) this.converter.convert(this.avroSchema, record);
    // 获取HoodieKey，它由record key字段值和partitionPath（分区路径）共同确定
    final HoodieKey hoodieKey = keyGenerator.getKey(gr);

    // 创建数据载体，该对象包含RowData数据
    HoodieRecordPayload payload = payloadCreation.createPayload(gr);
    // 获取操作类型，增删改查
    HoodieOperation operation = HoodieOperation.fromValue(record.getRowKind().toByteValue());
    // 构造出HoodieRecord
    return new HoodieRecord<>(hoodieKey, payload, operation);
}



BootstrapFunction


通途为加载时候生成索引。该特性通过index.bootstrap.enabled配置项开启。索引在接收到数据的时候开始加载，只加载index.partition.regex配置项正则表达式匹配的partition path对应的索引。加载完毕之后，该算子将不再进行任何其他操作，直接将数据发往下游。


public void processElement(I value, Context ctx, Collector out) throws Exception {
    // 标记是否已启动，初始值为false
    if (!alreadyBootstrap) {
        // 获取hoodie表元数据所在路径
        String basePath = hoodieTable.getMetaClient().getBasePath();
        int taskID = getRuntimeContext().getIndexOfThisSubtask();
        LOG.info("Start loading records in table {} into the index state, taskId = {}", basePath, taskID);
        // 遍历表包含的所有partitionPath
        for (String partitionPath : FSUtils.getAllFoldersWithPartitionMetaFile(FSUtils.getFs(basePath, hadoopConf), basePath)) {
            // pattern为index.partition.regex配置项的值，决定加载哪些partition的index，默认全加载
            if (pattern.matcher(partitionPath).matches()) {
                // 加载分区索引
                loadRecords(partitionPath, out);
            }
        }

        // wait for others bootstrap task send bootstrap complete.
        // 等待其他task启动完毕
        waitForBootstrapReady(taskID);

        // 标记已启动完毕
        alreadyBootstrap = true;
        LOG.info("Finish sending index records, taskId = {}.", getRuntimeContext().getIndexOfThisSubtask());
    }

    // send the trigger record
    // 把数据原封不动发往下游
    // 该算子不操作数据，仅仅是通过数据触发加载索引的操作
    out.collect((O) value);
}



loadRecords方法加载partition的索引。索引是Indexrecord格式，保存了record key，partition path（两者合起来为HoodieKey）和所在fileSlice的对应关系。


private void loadRecords(String partitionPath, Collector out) throws Exception {
    long start = System.currentTimeMillis();

    // 根据存储格式，创建对应的格式处理工具，目前支持Parquet和Orc
    BaseFileUtils fileUtils = BaseFileUtils.getInstance(this.hoodieTable.getBaseFileFormat());
    // 获取table对应的avro schema
    Schema schema = new TableSchemaResolver(this.hoodieTable.getMetaClient()).getTableAvroSchema();

    // 获取并行度，最大并行度和taskID
    final int parallelism = getRuntimeContext().getNumberOfParallelSubtasks();
    final int maxParallelism = getRuntimeContext().getMaxNumberOfParallelSubtasks();
    final int taskID = getRuntimeContext().getIndexOfThisSubtask();

    // 获取时间线上最后一个已提交的instant
    Option latestCommitTime = this.hoodieTable.getMetaClient().getCommitsTimeline()
        .filterCompletedInstants().lastInstant();

    // 如果这个instant存在
    if (latestCommitTime.isPresent()) {
        // 获取这个commit时间之前的所有FileSlice
        List fileSlices = this.hoodieTable.getSliceView()
            .getLatestFileSlicesBeforeOrOn(partitionPath, latestCommitTime.get().getTimestamp(), true)
            .collect(toList());

        for (FileSlice fileSlice : fileSlices) {
            // 判断这个fileSlice是否归本task加载
            // 如果不是则跳过
            if (!shouldLoadFile(fileSlice.getFileId(), maxParallelism, parallelism, taskID)) {
                continue;
            }
            LOG.info("Load records from {}.", fileSlice);

            // load parquet records
            // 加载FlieSlice中的数据文件
            fileSlice.getBaseFile().ifPresent(baseFile -> {
                // filter out crushed files
                // 根据文件类型，校验文件是否正常
                if (!isValidFile(baseFile.getFileStatus())) {
                    return;
                }

                final List hoodieKeys;
                try {
                    // 获取Partition对应的HoodieKey
                    hoodieKeys =
                        fileUtils.fetchRecordKeyPartitionPath(this.hadoopConf, new Path(baseFile.getPath()));
                } catch (Exception e) {
                    throw new HoodieException(String.format("Error when loading record keys from file: %s", baseFile), e);
                }

                // 发送indexRecord（各个HoodieKey和fileSlice的对应关系）到下游，这里是列存储文件的index
                for (HoodieKey hoodieKey : hoodieKeys) {
                    out.collect((O) new IndexRecord(generateHoodieRecord(hoodieKey, fileSlice)));
                }
            });

            // load avro log records
            // 加载所有avro格式log文件的路径
            List logPaths = fileSlice.getLogFiles()
                // filter out crushed files
                .filter(logFile -> isValidFile(logFile.getFileStatus()))
                .map(logFile -> logFile.getPath().toString())
                .collect(toList());
            // 扫描log文件，合并record key相同的数据
            HoodieMergedLogRecordScanner scanner = FormatUtils.logScanner(logPaths, schema, latestCommitTime.get().getTimestamp(),
                                                                          writeConfig, hadoopConf);

            try {
                // 遍历合并后的数据，遍历他们的record key
                // 发送IndexRecord到下游，这里处理的是log文件中数据的index
                for (String recordKey : scanner.getRecords().keySet()) {
                    out.collect((O) new IndexRecord(generateHoodieRecord(new HoodieKey(recordKey, partitionPath), fileSlice)));
                }
            } catch (Exception e) {
                throw new HoodieException(String.format("Error when loading record keys from files: %s", logPaths), e);
            } finally {
                scanner.close();
            }
        }
    }



BucketAssignFunction


执行数据分桶操作。为每一条数据分配它的存储位置。如果开启了索引加载（BootstrapFunction），BucketAssignFunction会把索引数据（IndexRecord）加载入operator状态缓存中。


@Override
public void processElement(I value, Context ctx, Collector out) throws Exception {
    // 如果接收到的是索引数据
    // 如果启用的加载索引，上一节的BootstrapFunction会产生IndexRecord
    // 这里需要根据索引，更新recordKey和储存位置的对应关系
    if (value instanceof IndexRecord) {
        IndexRecord indexRecord = (IndexRecord) value;
        // 设置operator StateHandler当前处理的key为record key
        this.context.setCurrentKey(indexRecord.getRecordKey());
        // 更新indexState为索引数据对应的位置
        // 将IndexRecord携带的recordKey和location信息对应存入indexState中
        this.indexState.update((HoodieRecordGlobalLocation) indexRecord.getCurrentLocation());
    } else {
        // 进入此分支伤命接收到的事HoodieRecord，开始处理数据过程
        processRecord((HoodieRecord) value, out);
    }
}



数据处理过程位于processRecord方法，逻辑如下所示：


private void processRecord(HoodieRecord record, Collector out) throws Exception {
    // 1. put the record into the BucketAssigner;
    // 2. look up the state for location, if the record has a location, just send it out;
    // 3. if it is an INSERT, decide the location using the BucketAssigner then send it out.
    
    // 获取HoodieKey，分别拿出recordKey和partitionPath
    final HoodieKey hoodieKey = record.getKey();
    final String recordKey = hoodieKey.getRecordKey();
    final String partitionPath = hoodieKey.getPartitionPath();
    // 封装了HoodieRecord的存储位置，即这条HoodieRecord对应哪个文件
    final HoodieRecordLocation location;

    // Only changing records need looking up the index for the location,
    // append only records are always recognized as INSERT.
    // 获取index中保存的location信息
    HoodieRecordGlobalLocation oldLoc = indexState.value();
    // 如果操作类型为UPSERT，DELETE或者UPSERT_PREPPED，isChangingRecords为true
    if (isChangingRecords && oldLoc != null) {
        // Set up the instant time as "U" to mark the bucket as an update bucket.
        // 如果index的partitionPath和当前HoodieRecord的不同
        if (!Objects.equals(oldLoc.getPartitionPath(), partitionPath)) {
            // 由index.global.enabled配置项控制
            // 表示一个相同key的record到来但是partitionPath不同，是否需要更新旧的partitionPath
            if (globalIndex) {
                // if partition path changes, emit a delete record for old partition path,
                // then update the index state using location with new partition path.
                // 创建一个删除元素发给下游，删除老的partitionPath信息
                HoodieRecord deleteRecord = new HoodieRecord<>(new HoodieKey(recordKey, oldLoc.getPartitionPath()),
                                                                  payloadCreation.createDeletePayload((BaseAvroPayload) record.getData()));
                deleteRecord.setCurrentLocation(oldLoc.toLocal("U"));
                deleteRecord.seal();
                out.collect((O) deleteRecord);
            }
            // 通过BucketAssigner获取新的存储位置
            location = getNewRecordLocation(partitionPath);
            // 更新IndexState为新的partitionPath和location
            updateIndexState(partitionPath, location);
        } else {
            location = oldLoc.toLocal("U");
            // 加入更新数据的位置信息到bucketAssigner
            this.bucketAssigner.addUpdate(partitionPath, location.getFileId());
        }
    } else {
        // 如果不是数据更新操作
        location = getNewRecordLocation(partitionPath);
        this.context.setCurrentKey(recordKey);
    }
    // always refresh the index
    // 确保数据更新操作刷新索引（indexState）
    if (isChangingRecords) {
        updateIndexState(partitionPath, location);
    }
    // 设置record的存放位置，发送给下游
    record.setCurrentLocation(location);
    out.collect((O) record);
}



StreamWriteFunction


用于写入HoodieRecord到文件系统中。


@Override
public void processElement(I value, KeyedProcessFunction.Context ctx, Collector out) {
    bufferRecord((HoodieRecord) value);
}



processElement又调用了bufferRecord方法。在存入数据到buffer之前，先检查是否需要flush bucket和buffer。先提前判断如果某条数据加入bucket后将超过了bucket大小限制，会flush这个bucket。buffer为多个bucket的最大占用内存数量总和，如果buffer空闲容量耗尽，Hudi挑一个当前数据写入最多的bucket执行flush。代码如下所示：


private void bufferRecord(HoodieRecord value) {
    // 根据HoodieRecord的partitionPath和fileId构建出bucketID
    final String bucketID = getBucketID(value);

    // 根据bucketID缓存了一组DataBucket，保存在buckets变量
    // 如果bucketID对应的DataBucket不存在，这里创建一个新的并放入buckets中
    // bucket batch大小设置为write.batch.size
    // partitionPath和fileID与HoodieRecord一致
    DataBucket bucket = this.buckets.computeIfAbsent(bucketID,
                                                     k -> new DataBucket(this.config.getDouble(FlinkOptions.WRITE_BATCH_SIZE), value));
    // 将HoodieRecord转换为DataItem
    // DataItem为数据保存在buffer中的格式，在flush之前DataItem会再转换回HoodieRecord
    final DataItem item = DataItem.fromHoodieRecord(value);

    // buffer中已存元素大小加上当前dataitem是否大于batch size，如果大于需要flush
    boolean flushBucket = bucket.detector.detect(item);
    // 检查buffer size是否超过最大缓存容量
    // 最大缓存容量为write.task.max.size - 100MB - write.merge.max_memory
    boolean flushBuffer = this.tracer.trace(bucket.detector.lastRecordSize);
    // 如果需要flushBucket
    if (flushBucket) {
        // 如果bucket数据被writeClient成功写入
        if (flushBucket(bucket)) {
            // tracer持有的缓存使用量减掉bucket容量
            this.tracer.countDown(bucket.detector.totalSize);
            // 清空bucket
            bucket.reset();
        }
    } else if (flushBuffer) {
        // 如果需要清空buffer，找到大小最大的bucket然后flush它
        // find the max size bucket and flush it out
        // 找到所有的bucket，按照totalSize从大到小排序
        List sortedBuckets = this.buckets.values().stream()
            .sorted((b1, b2) -> Long.compare(b2.detector.totalSize, b1.detector.totalSize))
            .collect(Collectors.toList());
        // 取出第一个bucket，即totalSize最大的bucket
        final DataBucket bucketToFlush = sortedBuckets.get(0);
        // flush这个bucket
        if (flushBucket(bucketToFlush)) {
            this.tracer.countDown(bucketToFlush.detector.totalSize);
            bucketToFlush.reset();
        } else {
            LOG.warn("The buffer size hits the threshold {}, but still flush the max size data bucket failed!", this.tracer.maxBufferSize);
        }
    }
    // 将record加入bucket中
    bucket.records.add(item);
}



CompactionPlanOperator


如果符合数据压缩的条件（Merge on Read表，并且启用异步压缩），CompactionPlanOperator将会生成数据压缩计划。CompactionPlanOperator不处理数据，只在checkpoint完成之后，schedule一个compact操作。


@Override
public void notifyCheckpointComplete(long checkpointId) {
    try {
        // 获取Hoodie表
        HoodieFlinkTable hoodieTable = writeClient.getHoodieTable();
        // 回滚之前没进行完的压缩操作
        CompactionUtil.rollbackCompaction(hoodieTable, writeClient, conf);
        // schedule一个新的压缩操作
        scheduleCompaction(hoodieTable, checkpointId);
    } catch (Throwable throwable) {
        // make it fail safe
        LOG.error("Error while scheduling compaction at instant: " + compactionInstantTime, throwable);
    }
}



scheduleCompaction方法：


private void scheduleCompaction(HoodieFlinkTable table, long checkpointId) throws IOException {
    // the last instant takes the highest priority.
    // 获取最近一个活跃的可被压缩的instant
    Option lastRequested = table.getActiveTimeline().filterPendingCompactionTimeline()
        .filter(instant -> instant.getState() == HoodieInstant.State.REQUESTED).lastInstant();
    if (!lastRequested.isPresent()) {
        // do nothing.
        LOG.info("No compaction plan for checkpoint " + checkpointId);
        return;
    }

    // 获取这个instant的时间
    String compactionInstantTime = lastRequested.get().getTimestamp();
    // 如果当前正在压缩的instant时间和最近一个活跃的可被压缩的instant时间相同
    // 说明schedule的compact操作重复了
    if (this.compactionInstantTime != null
        && Objects.equals(this.compactionInstantTime, compactionInstantTime)) {
        // do nothing
        LOG.info("Duplicate scheduling for compaction instant: " + compactionInstantTime + ", ignore");
        return;
    }

    // generate compaction plan
    // should support configurable commit metadata
    // 创建HoodieCompactionPlan
    HoodieCompactionPlan compactionPlan = CompactionUtils.getCompactionPlan(
        table.getMetaClient(), compactionInstantTime);

    if (compactionPlan == null || (compactionPlan.getOperations() == null)
        || (compactionPlan.getOperations().isEmpty())) {
        // do nothing.
        LOG.info("No compaction plan for checkpoint " + checkpointId + " and instant " + compactionInstantTime);
    } else {
        this.compactionInstantTime = compactionInstantTime;
        // 获取要压缩的instant
        HoodieInstant instant = HoodieTimeline.getCompactionRequestedInstant(compactionInstantTime);
        // Mark instant as compaction inflight
        // 标记该instant状态为inflight（正在处理）
        table.getActiveTimeline().transitionCompactionRequestedToInflight(instant);
        table.getMetaClient().reloadActiveTimeline();

        // 创建压缩操作
        List operations = compactionPlan.getOperations().stream()
            .map(CompactionOperation::convertFromAvroRecordInstance).collect(toList());
        LOG.info("CompactionPlanOperator compacting " + operations + " files");
        // 逐个发送压缩操作到下游
        for (CompactionOperation operation : operations) {
            output.collect(new StreamRecord<>(new CompactionPlanEvent(compactionInstantTime, operation)));
        }
    }
}



CompactFunction


接前一步生成的压缩计划，执行数据压缩过程。


@Override
public void processElement(CompactionPlanEvent event, Context context, Collector collector) throws Exception {
    // 获取要压缩的instant
    final String instantTime = event.getCompactionInstantTime();
    // 获取压缩操作
    final CompactionOperation compactionOperation = event.getOperation();
    // 如果是异步压缩，通过线程池执行doCompaction方法
    if (asyncCompaction) {
        // executes the compaction task asynchronously to not block the checkpoint barrier propagate.
        executor.execute(
            () -> doCompaction(instantTime, compactionOperation, collector),
            "Execute compaction for instant %s from task %d", instantTime, taskID);
    } else {
        // executes the compaction task synchronously for batch mode.
        LOG.info("Execute compaction for instant {} from task {}", instantTime, taskID);
        doCompaction(instantTime, compactionOperation, collector);
    }
}



doCompaction方法：


private void doCompaction(String instantTime, CompactionOperation compactionOperation, Collector collector) throws IOException {
    // 通过FlinkCompactHelpers执行数据压缩操作
    List writeStatuses = FlinkCompactHelpers.compact(writeClient, instantTime, compactionOperation);
    // 收集数据压缩结果到下游
    collector.collect(new CompactionCommitEvent(instantTime, writeStatuses, taskID));
}



到此为止，Flink写入Hudi表的流程已分析完毕。


本博客为作者原创，欢迎大家参与讨论和批评指正。如需转载请注明出处。
























你可能感兴趣的:(Flink Hudi 源码之HoodieTableSink)






    

  • 《昼颜》里的日本女人：相遇要万种风情，分手要残忍绝情
迷影咖啡

    作者：迷之菌子神奇菇迷影咖啡：一本正经做烘焙，胡说八道聊电影漫天萤火虫消散之时良宵就将过去，人们也说含苞待放的花蕾总会开了又谢，因紧紧相拥而面红耳赤的躯体，便是我们经历过这热爱的证明。夫妻关系介绍《昼颜》是2014年电视剧《昼颜：工作日下午三点的恋人们》的续集，故事发在电视剧情节结束的三年后，讲述了已经恢复独身的纱和偶然与曾经的出轨对象北野重逢后再次陷入感情漩涡的故事。《昼颜》制作灵感源自利佳子在
    

    • 

  • 迎接2019
唯有杜康1994

    告别2018这一年是机遇与挑战，痛苦与喜悦，失去与收获的一年一月:收获了第一份爱情，开始真正想去了解一个人三月:对工作有了更深入的认识，靠自己的力量完成晋升五月:搬家，住进了自己理想的公寓，一间属于自己的屋子。满地的书六月:外调广州，升经理，有了自己的第一个团队。七月:怀着自我否定，第一次完成了部门任务八月:第一个员工流失，痛哭不已明白无不散之筵席九月:员工陆续离开，经济是一切的根本。十月:陪员工
    

    • 

  • 亲子日记之祝姑姥姥生日快乐（282）
冰心雨露_d504

    2021年7月18日，周日，晴周日上班的不上班，上学的不上学，全家都属于休息状态，洗衣做饭是上午的主要任务，中午休息一会儿，下午比较晚了出去给梦怡买了二年级上册的口算题卡，然后去参加姑姑的生日聚餐，本来姑姑应该是周一生日，因为周一都要上班，就提前到周日过了，说是过生日其实就是想借此机会一家人聚聚，毕竟平常都忙，没有时间聚在一起，梦怡还给姑姥姥做了生日贺卡，虽然长相一般，重在心意。生日快乐
    

    • 

  • android 自定义曲线图,Android自定义View——贝赛尔曲线
weixin_39767513
android自定义曲线图

    个人博客：haichenyi.com。感谢关注本文针对有一定自定义View的童鞋，最好对贝赛尔曲线有辣么一丢丢了解，不了解也没关系。花5分钟看一下GcsSloop的安卓自定义View进阶-Path之贝塞尔曲线。本文的最终效果图：最终效果图.gif思路首先他是一个只有上半部分的正弦形状的水波纹，很规则。其次，他这个正弦图左右在移动。然后，就是它这个自定义View，上下也在移动，是慢慢增加的最后，优化
    

    • 

  • Flink中的SQL Client和SQL Gateway
BigDataMLApplication
flinkflinksqlgateway

    Flink中的SQLClient和SQLGateway对比目录定义基本原理适用场景主要区别常用运维命令示例官方链接正文1.定义SQLClient：FlinkSQLClient是一种用于提交和执行FlinkSQL语句的命令行界面或图形界面工具。SQLGateway：FlinkSQLGateway是一个独立的服务，它允许客户端通过RESTfulAPI将SQL查询提交到Flink集群。2.基本原理SQL
    

    • 

  • 下载Android源码
赛非斯

    repoinit-uhttps://mirrors.tuna.tsinghua.edu.cn/git/AOSP/platform/manifest-bandroid-10.0.0_r411.首先下载repo：a）终端运行gitclonegit://codeaurora.org/tools/repo.gitb）mkdir~/binc）拷贝repo到~/bin下面，修改repo权限，chmoda+x~
    

    • 

  • 信任
饮冰伊乔

    随着社会的发展，微信和支付宝交易给人们带来了极大的方便，越来越多的人出门都只选择拿一部手机即可，方便安全，可昨天我就遇到了一件比较尴尬的事。昨天傍晚，我从公司出来，感觉有点饿，决定索性吃了饭再回去，来到去过几次的一个店里，如往常一样叫了餐，当时店里吃饭的不多，老板麻利的先去做了，正要扫微信付账的时候发现手机没电了，迷之尴尬，我只好跟老板说不用做了，手机没电了，我身上又没现金，付不了帐了。老板娘很热
    

    • 

  • Django之Debug篇
菜鸟之编程
Djangodjangopython后端

    一、DebugToolBar基本使用1.1、概述Django框架的调试工具栏使用django-debug-toolbar库，是一组可配置的面板，显示有关当前请求/响应的各种调试信息，点击时，显示有关面板内容的更多详细信息。官方文档：DjangoDebugToolbar—DjangoDebugToolbar4.3.0documentation1.2、安装pipinstalldjango-debug-
    

    • 

  • 以高质量调查研究助力组织工作提质增效
木同木同

    近日，中共中央办公厅印发了《关于在全党大兴调查研究的工作方案》(后简称《方案》），要求各地区各部门结合实际认真贯彻落实。调查研究是我们党的传家宝，是谋事之基、成事之道。组织部门作为党管干部的核心部门，肩负着管党员、管干部、管人才的重要职责，调查研究更是把握组织工作规律、破解组织工作难题的重要办法。要用好调查研究这一法宝，把准政治方向，贯穿问题导向，坚持实事求是，以高质量调查研究助力组织工作提质增效
    

    • 

  • 地低为海人低为王
缘梦草

    地低为海，人低为王。低，高之基，高，低之顶。谦虚才能收益，咄咄逼人会招损。高粱熟了，头会低下。受益反而会深藏不露。捧人之术，把人捧高，然后控制。受控之人，大都是虚荣心作祟。活成别人想象中的样子，像别人想象中那么有面子的活着是悲哀的。穷不可怕，怕的是虚荣心。当你好面子，你就会被控制。一旦受虚荣心控制，你不得不谨小慎微的维护面子，付出多余的能量，希望得到别人的一句赞。面子就是金子打造的牢笼，让你在赞美
    

    • 

  • 计划比盲目做重要
一祉微笑

    坚持分享第99天。一次次会议提醒着老师们假期余额不足，马上面临停机状态。50多天掐指而过，想想放假时的计划，对照如今的完成情况，感觉差太远。想着好好看书，如今50多天过去了第6本还处在未完待续状态；想着假期好好陪陪孩子，在玩中学一些知识，如今想想，孩子学的真不多；想着暑假坚持跑步，有时还是容易给自己找借口，休息三两天。给这个假期一个综合评价，只能说只完成了计划的百分之五六十。想想为什么临近开学没达
    

    • 

  • 081天 约柜失而复得
宁宁2018

    撒迦利亚书4:6他对我说：“这是耶和华指示所罗巴伯的。万军之耶和华说：‘不是倚靠势力，不是倚靠才能，乃是倚靠我的灵方能成事。’
    

    • 

  • 《金文成〈正蒙〉日记124。2020-11-9》
金吾生

    《金文成〈正蒙〉日记124。2020-11-9》今天是庚子丁亥丙子，九月廿四，2020年11月9日星期一。作者篇7【舜之孝，汤、武之武，虽顺逆不同，其为不幸均矣。】船山讲解说，顺，指的是舜的父亲最终受到感化，转变了态度，结局圆满之事；逆，指的是＂桀放、纣诛＂，即，商汤放桀，周武诛纣，都是采用暴力，不是感化方式，所以是逆。顺与逆，都是为了解决弊政，然其差异之大如此，然而，无论圆满还是遗憾，其实他们都
    

    • 

  • 如何把大象装进冰箱的思考 210624
大丁_初心生活

    央视春晚曾有个小品，宋丹丹问赵本山，如何把大象装进冰箱。赵本山说不知道。宋丹丹得意地说，第一步，把冰箱门打开。第二步，把大象装进去。第三步，把冰箱门关上。我相信很多人看了都是一笑了之，我们也从潜意识上给出了否定的答案。樊登老师给出了不一样的解读，他认为这其实是解决问题的经典方法。“把大象装冰箱”，目标十分明确，宋丹丹给出的执行步骤也十分清晰。可赵本山却不会？难道赵本山不知道这三个步骤吗？肯定知道。
    

    • 

  • 道德经第三十四章
套马地汉纸

    道德经第三十四章原文：大道泛兮，其可左右！万物恃之而生，而不辞，功成不名有。爱养万物而不为主，常无欲，可名于小；万物归焉而不为主，可名为大。是以圣人终不为大，故能成其大。译文：大道广泛流行，无所不到。万物依赖它生长而不推辞，有所成就而不自以为有功。养育万物而不自以为主，永远没有私欲，可以说是渺小得很，所以可称它为“小”；物归附于它而它不自以为主宰，可以说极其伟大，所以可称它为“大”。由于它不自以为
    

    • 

  • Linux学习系列之vim编辑器（一）
llibertyll
linux学习

    vi编辑器的操作模式输入模式—aio等—>命令模式<—：键—末行模式从输入/末行模式切换到命令模式都是需要按ESC键注:a光标后输入，i光标前输入，o直接向下加一行输入，O向上加一行输入在vi编辑器中光标的移动（命令行模式下）键组合（命令）光标的移动$光标移动到当前行的结尾0（零）光标移动到当前行的开始GG光标移动到最后一行gg光标移动到第一行在命令行模式下删除与复制的操作键组合（命令）含义dd删
    

    • 

  • 6/21 最后的编织之观后感
ChereAlicia

    今天看了7分钟震撼人心之短篇有种当局者迷旁观者清的感觉在外人眼里看来已经足够但自有人深陷其中无法自拔而那个人很有可能是自己超脱物质寻求自己真正想要的方能得到内心的平息和安宁图片发自App
    

    • 

  • 每天学点成语
余子烨

    1、口诀：功败垂成未成功，不以为然不赞同；火中取栗被利用，罚不当罪处罚重；2、解释：功败垂成：事情接近成功的时候却遭到了失败。出自：《三国志·杨阜传》：“弃垂成之功，陷不义之名，阜以死守之。”不以为然：不认为是对的。表示不同意或否定。出自：宋·苏轼《再乞罢详定役法状》：“右臣先曾奏论前衙一役，只当招募，不当定差，执政不以为然。”火中取栗：一只猴子和一只猫看见炉火中烤着栗子，猴子叫猫去偷，猫用爪子从
    

    • 

  • 2023-11-07
碎碎念念的每一天

    忽然开始自卑了，感觉自己无论各个方面都太平平，读书不多，家务做不好，体重控制的不好，早起也困难，起来又不知道该做什么，没有一个可以为之奋斗的目标，也没有很好的交际圈，感觉自己就像一只在笼子里的鸟，想飞也飞不高……我想改变这样的现状，可该如何呢？其实都是我不够努力，没有争分夺秒，没有自律，这些都是我未来跟人拉开差距的原因，所以，我不应该只是自卑，自卑过头会变成焦虑，我应该努力去改变，哪怕改变一小点，
    

    • 

  • stm32之GPIO寄存器
luofengmacheng
嵌入式stm32嵌入式硬件单片机

    文章目录1背景2GPIO寄存器的类型2.1端口配置寄存器2.2设置/清除寄存器和位清除寄存器3总结1背景C51单片机在进行数据的输入输出时，是直接操作与外部引脚关联的内部寄存器，例如，当设置P2_1为0时，就是将外部引脚的P21引脚设置为低电平，当读取P2_1时，就是读取P21的电平。与之类似，stm32芯片内部也有很多用于输入输出的寄存器，这些寄存器也是用于操作外部引脚，但是比C51单片机复杂很
    

    • 

  • Java回溯知识点（含面试大厂题和源码）
一成码农
java面试开发语言

    回溯算法是一种通过遍历所有可能的候选解来寻找所有解的算法，如果候选解被确认不是一个解（或至少不是最后一个解），回溯算法会通过在上一步进行一些变化来丢弃这个解，即“回溯”并尝试另一个候选解。回溯法通常用递归方法来实现，在解决排列、组合、选择问题时非常有效。回溯算法的核心要点：路径：也就是已经做出的选择。选择列表：也就是你当前可以做的选择。结束条件：也就是到达决策树底层，无法再做出选择的条件。回溯算法
    

    • 

  • 《老子》笔记19 2018-10-28
海上明月共

    第二十二章[原文]曲则全，枉则直，洼则盈，敝则新，少则得，多则惑。是以圣人抱一为天下式。不自见，故明；不自是，故彰，不自伐，故有功；不自矜，故长。夫唯不争，故天下莫能与之争。古之所谓"曲则全"者，岂虚言哉？诚全而归之。[译文]委曲便会保全，屈枉便会直伸；低洼便会充盈，陈旧便会更新；少取便会获得，贪多便会迷惑。所以有道的人坚守这一原则作为天下事理的范式，不自我表扬，反能显明；不自以为是，反能是非彰明
    

    • 

  • 爱心账户之存钱日记11.20
静_d595

    新沙发终于到了，满心欢喜，可旧沙发的处理又是个头疼的问题，免费送都没有人要。临时想起来公司那个收垃圾的，看看付费能不能拉走。对方说随便给点都行，我又拿不准，于是就想说88把。对方说给两包烟就行了，我说还是给钱吧，也不想欠人情。如果请专门搬东西的估计得200加了，还算是比较顺利，刚好想到他。选了12元存进我的爱心账户！
    

    • 

  • 大话设计模式之工厂模式
码农客栈
设计模式开发语言

    工厂模式（FactoryPattern）是一种创建型设计模式，它提供了一种创建对象的最佳方式，而无需指定将要创建的对象的确切类。通过使用工厂模式，我们可以将对象的创建和使用分离，从而使代码更具灵活性和可维护性。在工厂模式中，通常会有三种角色：工厂接口（FactoryInterface）：声明了一个用于创建对象的接口，这样所有具体工厂类都必须实现该接口。具体工厂（ConcreteFactory）：实
    

    • 

  • 优化选址问题 | 基于和声搜索算法求解基站选址问题含Matlab源码
天天酷科研
优化选址问题（LP）matlab和声搜索算法基站选址问题

    目录问题代码问题和声搜索算法（HarmonySearch,HS）是一种模拟音乐创作过程中乐师们凭借自己的记忆，通过反复调整各乐器的音调，直至达到最美和声状态为启发，通过反复调整解向量的各分量来寻求全局最优解的智能优化算法。下面是一个基于和声搜索算法求解基站选址问题的Matlab伪代码框架。请注意，这个框架是一个基本的实现，你可能需要根据你的具体问题和约束条件进行调整和优化。代码%和声搜索算法求解基
    

    • 

  • 大话设计模式之代理模式
码农客栈
设计模式代理模式

    代理模式（ProxyPattern）是一种结构型设计模式，它允许通过代理对象控制对另一个对象的访问。代理对象充当客户端和实际对象之间的中介，客户端通过代理对象间接访问实际对象，从而可以在访问控制、缓存、延迟加载等方面提供额外的功能。在代理模式中，通常会有三种角色：Subject（抽象主题）：声明了真实对象和代理对象的共同接口，这样在任何使用真实对象的地方都可以使用代理对象。RealSubject（
    

    • 

  • 【1.1 编程基础之输入输出】09. 字符菱形
青少年编程小助手_Python
Openjudge题目解析算法青少年编程电子学会等级考试gesp

    09:字符菱形总时间限制:1000ms内存限制:65536kB描述给定一个字符，用它构造一个对角线长5个字符，倾斜放置的菱形。输入输入只有一行，包含一个字符。输出该字符构成的菱形。样例输入*样例输出*************参考程序（1）C语言#includeintmain(){charc;scanf("%c",&c);printf("%c\n",c);printf("%c%c%c\n",c,c,
    

    • 

  • 剩28天19年12月3日星期二 晴朗
岁月流转足迹可循

    图片发自App图片发自App图片发自App图片发自App昨天升完旗，去操场上走走，才发现霜是如此之重，脚踩上去，都有凝粒！天是越来越冷了！不过晴空净爽，空气清冽，一呼一吸之间很是舒服！中午写了几个大字，童爸说笔画还有些软，一语中的。需用心提升，贵在坚持坚持吧！下午做了张丽华的顺车，捎我到陈仓元，再坐了3路到西关，费时50分钟！晚上吃完饭送童去学校，到八点半下楼运动半小时，跳了500个绳，弯弯腰！感
    

    • 

  • 很久以前的故事 138
余间上古

    偶遇机械人大公子镇静下来继续说：“你可知所谓的拍卖会是要杀掉一些人，某些人斗不过一个映山城，天下虽大，从此后恐无容身之地。”他语气一缓：“如果你肯联手，我不但不计较你今日之举，杀手阁随时恭候大驾光临，从此多了一个方便之门。”“我只是寻找路彦而已......”薛莹笑道直呼其名：“剑二，用尽心思糊弄别人，独行者经常内斗再正常不过！你不过是一个道修，踏入神明之境而已，理解不到独行者的真谛……”薛莹言尽意
    

    • 

  • Flink算子通用状态应用测试样例
公子乂
flinkjavaservlet

    Flink算子通用状态应用测试样例1.获取Flink执行环境finalStreamExecutionEnvironmentenv=StreamExecutionEnvironment.getExecutionEnvironment();env.setParallelism(1);2.创建数据源，生成随机数据DataStream>source=env.addSource(newSourceFunct
    

    • 

  • ASM系列四 利用Method 组件动态注入方法逻辑
lijingyao8206
字节码技术jvmAOP动态代理ASM

            这篇继续结合例子来深入了解下Method组件动态变更方法字节码的实现。通过前面一篇，知道ClassVisitor 的visitMethod()方法可以返回一个MethodVisitor的实例。那么我们也基本可以知道，同ClassVisitor改变类成员一样，MethodVIsistor如果需要改变方法成员，注入逻辑，也可以
    

    • 

  • java编程思想 --内部类
百合不是茶
java内部类匿名内部类

    内部类;了解外部类 并能与之通信 内部类写出来的代码更加整洁与优雅
 
1,内部类的创建  内部类是创建在类中的
package com.wj.InsideClass;
/*
* 内部类的创建
*/
public class CreateInsideClass {
public CreateInsideClass(
    

    • 

  • web.xml报错
crabdave
web.xml

    web.xml报错
 
The content of element type "web-app" must match "(icon?,display-
 name?,description?,distributable?,context-param*,filter*,filter-mapping*,listener*,servlet*,s
    

    • 

  • 泛型类的自定义
麦田的设计者
javaandroid泛型

       为什么要定义泛型类，当类中要操作的引用数据类型不确定的时候。
采用泛型类，完成扩展。
  例如有一个学生类
   
Student{
Student(){
System.out.println("I'm a student.....");
}
}
 有一个老师类
 

    

    • 

  • CSS清除浮动的4中方法
IT独行者
JavaScriptUIcss

    清除浮动这个问题，做前端的应该再熟悉不过了，咱是个新人，所以还是记个笔记，做个积累，努力学习向大神靠近。CSS清除浮动的方法网上一搜，大概有N多种，用过几种，说下个人感受。
1、结尾处加空div标签 clear:both 1 2 3 4
.div
1
{
background
:
#000080
;
border
:
1px  
s
    

    • 

  • Cygwin使用windows的jdk 配置方法
_wy_
jdkwindowscygwin

    1.[vim /etc/profile]
   JAVA_HOME="/cgydrive/d/Java/jdk1.6.0_43"  (windows下jdk路径为D:\Java\jdk1.6.0_43)
   PATH="$JAVA_HOME/bin:${PATH}"
   CLAS
    

    • 

  • linux下安装maven
无量
mavenlinux安装

    Linux下安装maven(转) 1.首先到Maven官网
下载安装文件，目前最新版本为3.0.3，下载文件为
apache-maven-3.0.3-bin.tar.gz，下载可以使用wget命令；
2.进入下载文件夹，找到下载的文件，运行如下命令解压
tar -xvf  apache-maven-2.2.1-bin.tar.gz
解压后的文件夹
    

    • 

  • tomcat的https 配置,syslog-ng配置
aichenglong
tomcathttp跳转到httpssyslong-ng配置syslog配置

    1) tomcat配置https,以及http自动跳转到https的配置
    1)TOMCAT_HOME目录下生成密钥(keytool是jdk中的命令)
     keytool -genkey -alias tomcat -keyalg RSA -keypass changeit -storepass changeit
    

    • 

  • 关于领号活动总结
alafqq
活动

    关于某彩票活动的总结
具体需求，每个用户进活动页面，领取一个号码，1000中的一个；
活动要求
1，随机性，一定要有随机性；
2，最少中奖概率，如果注数为3200注，则最多中4注
3，效率问题，（不能每个人来都产生一个随机数，这样效率不高）；
4，支持断电（仍然从下一个开始），重启服务；（存数据库有点大材小用，因此不能存放在数据库）
解决方案
1，事先产生随机数1000个，并打
    

    • 

  • java数据结构 冒泡排序的遍历与排序
百合不是茶
java

    java的冒泡排序是一种简单的排序规则
 
冒泡排序的原理： 
         比较两个相邻的数，首先将最大的排在第一个，第二次比较第二个 ，此后一样；
        针对所有的元素重复以上的步骤，除了最后一个
 
 
例题；将int array[] 
    

    • 

  • JS检查输入框输入的是否是数字的一种校验方法
bijian1013
js

    如下是JS检查输入框输入的是否是数字的一种校验方法：
<form method=post target="_blank">
数字：<input type="text" name=num onkeypress="checkNum(this.form)"><br>
</form>

    

    • 

  • Test注解的两个属性：expected和timeout
bijian1013
javaJUnitexpectedtimeout

    JUnit4：Test文档中的解释：
　　The Test annotation supports two optional parameters.
　　The first, expected, declares that a test method should throw an exception.
　　If it doesn't throw an exception or if it 
    

    • 

  • [Gson二]继承关系的POJO的反序列化
bit1129
POJO

    父类
 
 
package inheritance.test2;
import java.util.Map;
public class Model {
private String field1;
private String field2;
private Map<String, String> infoMap
    

    • 

  • 【Spark八十四】Spark零碎知识点记录
bit1129
spark

    1. ShuffleMapTask的shuffle数据在什么地方记录到MapOutputTracker中的
ShuffleMapTask的runTask方法负责写数据到shuffle map文件中。当任务执行完成成功，DAGScheduler会收到通知，在DAGScheduler的handleTaskCompletion方法中完成记录到MapOutputTracker中
 

    

    • 

  • WAS各种脚本作用大全
ronin47
WAS 脚本

    　　　http://www.ibm.com/developerworks/cn/websphere/library/samples/SampleScripts.html
　　　无意中，在WAS官网上发现的各种脚本作用，感觉很有作用，先与各位分享一下
　　　
获取下载
这些示例 jacl 和 Jython 脚本可用于在 WebSphere Application Server 的不同版本中自
    

    • 

  • java-12.求 1+2+3+..n不能使用乘除法、 for 、 while 、 if 、 else 、 switch 、 case 等关键字以及条件判断语句
bylijinnan
switch

    借鉴网上的思路，用java实现：
public class NoIfWhile {
/**
* @param args
*
* find x=1+2+3+....n
*/
public static void main(String[] args) {
int n=10;
int re=find(n);
System.o
    

    • 

  • Netty源码学习-ObjectEncoder和ObjectDecoder
bylijinnan
javanetty

    Netty中传递对象的思路很直观：
Netty中数据的传递是基于ChannelBuffer（也就是byte[]）；
那把对象序列化为字节流，就可以在Netty中传递对象了
相应的从ChannelBuffer恢复对象，就是反序列化的过程
Netty已经封装好ObjectEncoder和ObjectDecoder
先看ObjectEncoder
ObjectEncoder是往外发送
    

    • 

  • spring 定时任务中cronExpression表达式含义
chicony
cronExpression

    一个cron表达式有6个必选的元素和一个可选的元素，各个元素之间是以空格分隔的，从左至右，这些元素的含义如下表所示：
代表含义            是否必须 允许的取值范围         &nb
    

    • 

  • Nutz配置Jndi
ctrain
JNDI

    1、使用JNDI获取指定资源：
var ioc = {
dao : {
type :"org.nutz.dao.impl.NutDao",
args : [ {jndi :"jdbc/dataSource"} ]
}
}
以上方法,仅需要在容器中配置好数据源,注入到NutDao即可. 
    

    • 

  • 解决 /bin/sh^M: bad interpreter: No such file or directory
daizj
shell

    在Linux中执行.sh脚本，异常/bin/sh^M: bad interpreter: No such file or directory。
 
分析：这是不同系统编码格式引起的：在windows系统中编辑的.sh文件可能有不可见字符，所以在Linux系统下执行会报以上异常信息。
解决：
1）在windows下转换：
利用一些编辑器如UltraEdit或EditPlus等工具
    

    • 

  • [转]for 循环为何可恨？
dcj3sjt126com
程序员读书

     
Java的闭包(Closure)特征最近成为了一个热门话题。 一些精英正在起草一份议案，要在Java将来的版本中加入闭包特征。 然而，提议中的闭包语法以及语言上的这种扩充受到了众多Java程序员的猛烈抨击。
不久前，出版过数十本编程书籍的大作家Elliotte Rusty Harold发表了对Java中闭包的价值的质疑。 尤其是他问道“for 循环为何可恨？”[http://ju
    

    • 

  • Android实用小技巧
dcj3sjt126com
android

    1、去掉所有Activity界面的标题栏
　　修改AndroidManifest.xml 　　在application 标签中添加android:theme="@android:style/Theme.NoTitleBar"
 
2、去掉所有Activity界面的TitleBar 和StatusBar 
　　修改AndroidManifes
    

    • 

  • Oracle 复习笔记之序列
eksliang
Oracle 序列sequenceOracle sequence

    转载请出自出处：http://eksliang.iteye.com/blog/2098859
1.序列的作用
序列是用于生成唯一、连续序号的对象
一般用序列来充当数据库表的主键值
2.创建序列语法如下：
 
create sequence s_emp
start with 1 --开始值
increment by 1 --増长值
maxval
    

    • 

  • 有“品”的程序员
gongmeitao
工作

    完美程序员的10种品质　　
 
完美程序员的每种品质都有一个范围，这个范围取决于具体的问题和背景。没有能解决所有问题的
 
完美程序员（至少在我们这个星球上），并且对于特定问题，完美程序员应该具有以下品质：
　　1. 才智非凡- 能够理解问题、能够用清晰可读的代码翻译并表达想法、善于分析并且逻辑思维能力强
 
（范围：用简单方式解决复杂问题）　　

    

    • 

  • 使用KeleyiSQLHelper类进行分页查询
hvt
sql.netC#asp.nethovertree

    本文适用于sql server单主键表或者视图进行分页查询，支持多字段排序。KeleyiSQLHelper类的最新代码请到http://hovertree.codeplex.com/SourceControl/latest下载整个解决方案源代码查看。或者直接在线查看类的代码：http://hovertree.codeplex.com/SourceControl/latest#HoverTree.D
    

    • 

  • SVG 教程 （三）圆形，椭圆，直线
天梯梦
svg

    SVG <circle> SVG 圆形 - <circle>
<circle> 标签可用来创建一个圆：
下面是SVG代码：
<svg xmlns="http://www.w3.org/2000/svg" version="1.1">
<circle cx="100" c
    

    • 

  • 链表栈
luyulong
java数据结构

    
public class Node {
private Object object;
private Node next;
public Node() {
this.next = null;
this.object = null;
}
public Object getObject() {
return object;
}
public
    

    • 

  • 基础数据结构和算法十：2-3 search tree
sunwinner
Algorithm2-3 search tree

     
Binary search tree works well for a wide variety of applications, but they have poor worst-case performance. Now we introduce a type of binary search tree where costs are guaranteed to be loga
    

    • 

  • spring配置定时任务
stunizhengjia
springtimer

    最近因工作的需要，用到了spring的定时任务的功能,觉得spring还是很智能化的,只需要配置一下配置文件就可以了,在此记录一下，以便以后用到：
 
 
//------------------------定时任务调用的方法------------------------------
/**
* 存储过程定时器
*/
publi
    

    • 

  • ITeye 8月技术图书有奖试读获奖名单公布
ITeye管理员
活动

    ITeye携手博文视点举办的8月技术图书有奖试读活动已圆满结束，非常感谢广大用户对本次活动的关注与参与。
8月试读活动回顾：
http://webmaster.iteye.com/blog/2102830
本次技术图书试读活动的优秀奖获奖名单及相应作品如下（优秀文章有很多，但名额有限，没获奖并不代表不优秀）：
《跨终端Web》
gleams：http
    

    •