xhh199090
xhh199090

Kafka-connect-hdfs源码解析

写数据流程分析

启动task类方法，HdfsSinkTask.java类中start

@Override
public void start(Map props) {
  Set assignment = context.assignment();
  try {
    HdfsSinkConnectorConfig connectorConfig = new HdfsSinkConnectorConfig(props);
    boolean hiveIntegration = connectorConfig.getBoolean(HiveConfig.HIVE_INTEGRATION_CONFIG);
    if (hiveIntegration) {
      StorageSchemaCompatibility compatibility = StorageSchemaCompatibility.getCompatibility(
          connectorConfig.getString(StorageSinkConnectorConfig.SCHEMA_COMPATIBILITY_CONFIG)
      );
      if (compatibility == StorageSchemaCompatibility.NONE) {
        throw new ConfigException(
            "Hive Integration requires schema compatibility to be BACKWARD, FORWARD or FULL"
        );
      }
    }

    //check that timezone it setup correctly in case of scheduled rotation
    if (connectorConfig.getLong(HdfsSinkConnectorConfig.ROTATE_SCHEDULE_INTERVAL_MS_CONFIG) > 0) {
      String timeZoneString = connectorConfig.getString(PartitionerConfig.TIMEZONE_CONFIG);
      if (timeZoneString.equals("")) {
        throw new ConfigException(PartitionerConfig.TIMEZONE_CONFIG,
            timeZoneString, "Timezone cannot be empty when using scheduled file rotation."
        );
      }
      DateTimeZone.forID(timeZoneString);
    }

    int schemaCacheSize = connectorConfig.getInt(
        HdfsSinkConnectorConfig.SCHEMA_CACHE_SIZE_CONFIG
    );
    avroData = new AvroData(schemaCacheSize);
    hdfsWriter = new DataWriter(connectorConfig, context, avroData);   //初始化DataWriter
    recover(assignment);
    if (hiveIntegration) {
      syncWithHive();
    }
  } catch (ConfigException e) {
    throw new ConnectException("Couldn't start HdfsSinkConnector due to configuration error.", e);
  } catch (ConnectException e) {
    // Log at info level to help explain reason, but Connect logs the actual exception at ERROR
    log.info("Couldn't start HdfsSinkConnector:", e);
    log.info("Shutting down HdfsSinkConnector.");
    if (hdfsWriter != null) {
      try {
        try {
          log.debug("Closing data writer due to task start failure.");
          hdfsWriter.close();
        } finally {
          log.debug("Stopping data writer due to task start failure.");
          hdfsWriter.stop();
        }
      } catch (Throwable t) {
        log.debug("Error closing and stopping data writer: {}", t.getMessage(), t);
      }
    }
    // Always throw the original exception that prevent us from starting
    throw e;
  }

  log.info("The connector relies on offsets in HDFS filenames, but does commit these offsets to "
      + "Connect to enable monitoring progress of the HDFS connector. Upon startup, the HDFS "
      + "Connector restores offsets from filenames in HDFS. In the absence of files in HDFS, "
      + "the connector will attempt to find offsets for its consumer group in the "
      + "'__consumer_offsets' topic. If offsets are not found, the consumer will "
      + "rely on the reset policy specified in the 'consumer.auto.offset.reset' property to "
      + "start exporting data to HDFS.");
}

初始化DataWriter，DataWriter.java

@SuppressWarnings("unchecked")
public DataWriter(
    HdfsSinkConnectorConfig connectorConfig,
    SinkTaskContext context,
    AvroData avroData,
    Time time
) {
  this.time = time;
  try {
    String hadoopHome = connectorConfig.getString(HdfsSinkConnectorConfig.HADOOP_HOME_CONFIG);
    System.setProperty("hadoop.home.dir", hadoopHome);

    this.connectorConfig = connectorConfig;
    this.avroData = avroData;
    this.context = context;

    String hadoopConfDir = connectorConfig.getString(
        HdfsSinkConnectorConfig.HADOOP_CONF_DIR_CONFIG
    );
    log.info("Hadoop configuration directory {}", hadoopConfDir);
    Configuration conf = connectorConfig.getHadoopConfiguration();
    if (!hadoopConfDir.equals("")) {
      conf.addResource(new Path(hadoopConfDir + "/core-site.xml"));
      conf.addResource(new Path(hadoopConfDir + "/hdfs-site.xml"));
    }

    boolean secureHadoop = connectorConfig.getBoolean(
        HdfsSinkConnectorConfig.HDFS_AUTHENTICATION_KERBEROS_CONFIG
    );
    if (secureHadoop) {
      SecurityUtil.setAuthenticationMethod(
          UserGroupInformation.AuthenticationMethod.KERBEROS,
          conf
      );
      String principalConfig = connectorConfig.getString(
          HdfsSinkConnectorConfig.CONNECT_HDFS_PRINCIPAL_CONFIG
      );
      String keytab = connectorConfig.getString(
          HdfsSinkConnectorConfig.CONNECT_HDFS_KEYTAB_CONFIG
      );

      if (principalConfig == null || keytab == null) {
        throw new ConfigException(
            "Hadoop is using Kerberos for authentication, you need to provide both a connect "
                + "principal and the path to the keytab of the principal.");
      }

      conf.set("hadoop.security.authentication", "kerberos");
      conf.set("hadoop.security.authorization", "true");
      String hostname = InetAddress.getLocalHost().getCanonicalHostName();
      String namenodePrincipalConfig = connectorConfig.getString(
          HdfsSinkConnectorConfig.HDFS_NAMENODE_PRINCIPAL_CONFIG
      );

      String namenodePrincipal = SecurityUtil.getServerPrincipal(
          namenodePrincipalConfig,
          hostname
      );
      // namenode principal is needed for multi-node hadoop cluster
      if (conf.get("dfs.namenode.kerberos.principal") == null) {
        conf.set("dfs.namenode.kerberos.principal", namenodePrincipal);
      }
      log.info("Hadoop namenode principal: " + conf.get("dfs.namenode.kerberos.principal"));

      UserGroupInformation.setConfiguration(conf);
      // replace the _HOST specified in the principal config to the actual host
      String principal = SecurityUtil.getServerPrincipal(principalConfig, hostname);
      UserGroupInformation.loginUserFromKeytab(principal, keytab);
      final UserGroupInformation ugi = UserGroupInformation.getLoginUser();
      log.info("Login as: " + ugi.getUserName());

      final long renewPeriod = connectorConfig.getLong(
          HdfsSinkConnectorConfig.KERBEROS_TICKET_RENEW_PERIOD_MS_CONFIG
      );

      isRunning = true;
      ticketRenewThread = new Thread(new Runnable() {
        @Override
        public void run() {
          synchronized (DataWriter.this) {
            while (isRunning) {
              try {
                DataWriter.this.wait(renewPeriod);
                if (isRunning) {
                  ugi.reloginFromKeytab();
                }
              } catch (IOException e) {
                // We ignore this exception during relogin as each successful relogin gives
                // additional 24 hours of authentication in the default config. In normal
                // situations, the probability of failing relogin 24 times is low and if
                // that happens, the task will fail eventually.
                log.error("Error renewing the ticket", e);
              } catch (InterruptedException e) {
                // ignored
              }
            }
          }
        }
      });
      log.info("Starting the Kerberos ticket renew thread with period {}ms.", renewPeriod);
      ticketRenewThread.start();
    }

    url = connectorConfig.getUrl();
    topicsDir = connectorConfig.getString(StorageCommonConfig.TOPICS_DIR_CONFIG);

    @SuppressWarnings("unchecked")
    Class storageClass = (Class) connectorConfig
        .getClass(StorageCommonConfig.STORAGE_CLASS_CONFIG);
    storage = io.confluent.connect.storage.StorageFactory.createStorage(
        storageClass,
        HdfsSinkConnectorConfig.class,
        connectorConfig,
        url
    );

    createDir(topicsDir);
    createDir(topicsDir + HdfsSinkConnectorConstants.TEMPFILE_DIRECTORY);
    String logsDir = connectorConfig.getString(HdfsSinkConnectorConfig.LOGS_DIR_CONFIG);
    createDir(logsDir);

    // Try to instantiate as a new-style storage-common type class, then fall back to old-style
    // with no parameters
    try {
      Class formatClass =
          (Class)
              connectorConfig.getClass(HdfsSinkConnectorConfig.FORMAT_CLASS_CONFIG);
      newFormat = formatClass.getConstructor(HdfsStorage.class).newInstance(storage);
      newWriterProvider = newFormat.getRecordWriterProvider();
      schemaFileReader = newFormat.getSchemaFileReader();
    } catch (NoSuchMethodException e) {
      Class formatClass =
          (Class) connectorConfig.getClass(HdfsSinkConnectorConfig.FORMAT_CLASS_CONFIG);
      format = formatClass.getConstructor().newInstance();
      writerProvider = format.getRecordWriterProvider();
      final io.confluent.connect.hdfs.SchemaFileReader oldReader
          = format.getSchemaFileReader(avroData);
      schemaFileReader = new SchemaFileReader() {
        @Override
        public Schema getSchema(HdfsSinkConnectorConfig hdfsSinkConnectorConfig, Path path) {
          try {
            return oldReader.getSchema(hdfsSinkConnectorConfig.getHadoopConfiguration(), path);
          } catch (IOException e) {
            throw new ConnectException("Failed to get schema", e);
          }
        }

        @Override
        public Iterator iterator() {
          throw new UnsupportedOperationException();
        }

        @Override
        public boolean hasNext() {
          throw new UnsupportedOperationException();
        }

        @Override
        public Object next() {
          throw new UnsupportedOperationException();
        }

        @Override
        public void remove() {
          throw new UnsupportedOperationException();
        }

        @Override
        public void close() throws IOException {

        }
      };
    }

    partitioner = newPartitioner(connectorConfig);

    assignment = new HashSet<>(context.assignment());

    hiveIntegration = connectorConfig.getBoolean(HiveConfig.HIVE_INTEGRATION_CONFIG);
    if (hiveIntegration) {
      hiveDatabase = connectorConfig.getString(HiveConfig.HIVE_DATABASE_CONFIG);
      hiveMetaStore = new HiveMetaStore(conf, connectorConfig);
      if (format != null) {
        hive = format.getHiveUtil(connectorConfig, hiveMetaStore);
      } else if (newFormat != null) {
        final io.confluent.connect.storage.hive.HiveUtil newHiveUtil
            = ((HiveFactory) newFormat.getHiveFactory())
            .createHiveUtil(connectorConfig, hiveMetaStore);
        hive = new HiveUtil(connectorConfig, hiveMetaStore) {
          @Override
          public void createTable(
              String database, String tableName, Schema schema,
              Partitioner partitioner
          ) {
            newHiveUtil.createTable(database, tableName, schema, partitioner);
          }

          @Override
          public void alterSchema(String database, String tableName, Schema schema) {
            newHiveUtil.alterSchema(database, tableName, schema);
          }
        };
      } else {
        throw new ConnectException("One of old or new format classes must be provided");
      }
      executorService = Executors.newSingleThreadExecutor();
      hiveUpdateFutures = new LinkedList<>();
    }

    topicPartitionWriters = new HashMap<>();
    for (TopicPartition tp : assignment) {
      TopicPartitionWriter topicPartitionWriter = new TopicPartitionWriter(
          tp,
          storage,
          writerProvider,
          newWriterProvider,
          partitioner,
          connectorConfig,
          context,
          avroData,
          hiveMetaStore,
          hive,
          schemaFileReader,
          executorService,
          hiveUpdateFutures,
          time
      );
      topicPartitionWriters.put(tp, topicPartitionWriter);
    }
  } catch (ClassNotFoundException
          | IllegalAccessException
          | InstantiationException
          | InvocationTargetException
          | NoSuchMethodException e
  ) {
    throw new ConnectException("Reflection exception: ", e);
  } catch (IOException e) {
    throw new ConnectException(e);
  }
}


初始化DataWriter后，下一步执行方法recover方法


private void recover(Set assignment) {
  for (TopicPartition tp : assignment) {
    hdfsWriter.recover(tp);
  }
}



hdfsWriter.recover(tp)方法跳转到DataWriter类中执行
 DataWriter.java


public void recover(TopicPartition tp) {
  topicPartitionWriters.get(tp).recover();
}



TopicPartitionWriter.java中执行recover


@SuppressWarnings("fallthrough")
public boolean recover() {
  try {
    switch (state) {
      case RECOVERY_STARTED:
        log.info("Started recovery for topic partition {}", tp);
        pause();
        nextState();
      case RECOVERY_PARTITION_PAUSED:
        log.debug("Start recovery state: Apply WAL for topic partition {}", tp);
        applyWAL();
        nextState();
      case WAL_APPLIED:
        log.debug("Start recovery state: Truncate WAL for topic partition {}", tp);
        truncateWAL();
        nextState();
      case WAL_TRUNCATED:
        log.debug("Start recovery state: Reset Offsets for topic partition {}", tp);
        resetOffsets();
        nextState();
      case OFFSET_RESET:
        log.debug("Start recovery state: Resume for topic partition {}", tp);
        resume();
        nextState();
        log.info("Finished recovery for topic partition {}", tp);
        break;
      default:
        log.error(
            "{} is not a valid state to perform recovery for topic partition {}.",
            state,
            tp
        );
    }
  } catch (ConnectException e) {
    log.error("Recovery failed at state {}", state, e);
    setRetryTimeout(timeoutMs);
    return false;
  }
  return true;
}



task线程启动后执行执行workersinktask中的iteration()方法
 第二步执行iteration()方法;


protected void iteration() {
    final long offsetCommitIntervalMs = workerConfig.getLong(WorkerConfig.OFFSET_COMMIT_INTERVAL_MS_CONFIG);

    try {
        long now = time.milliseconds();

        // Maybe commit
        if (!committing && (context.isCommitRequested() || now >= nextCommit)) {
            commitOffsets(now, false);
            nextCommit = now + offsetCommitIntervalMs;
            context.clearCommitRequest();
        }

        final long commitTimeoutMs = commitStarted + workerConfig.getLong(WorkerConfig.OFFSET_COMMIT_TIMEOUT_MS_CONFIG);

        // Check for timed out commits
        if (committing && now >= commitTimeoutMs) {
            log.warn("{} Commit of offsets timed out", this);
            commitFailures++;
            committing = false;
        }

        // And process messages
        long timeoutMs = Math.max(nextCommit - now, 0);
        poll(timeoutMs);
    } catch (WakeupException we) {
        log.trace("{} Consumer woken up", this);

        if (isStopping())
            return;

        if (shouldPause()) {
            pauseAll();
            onPause();
            context.requestCommit();
        } else if (!pausedForRedelivery) {
            resumeAll();
            onResume();
        }
    }
}



/**
 * Poll for new messages with the given timeout. Should only be invoked by the worker thread.
 */
protected void poll(long timeoutMs) {
    rewind();
    long retryTimeout = context.timeout();
    if (retryTimeout > 0) {
        timeoutMs = Math.min(timeoutMs, retryTimeout);
        context.timeout(-1L);
    }

    log.trace("{} Polling consumer with timeout {} ms", this, timeoutMs);
    ConsumerRecords msgs = pollConsumer(timeoutMs);
    assert messageBatch.isEmpty() || msgs.isEmpty();
    log.trace("{} Polling returned {} messages", this, msgs.count());

    convertMessages(msgs);
    deliverMessages();
}



private void deliverMessages() {
    // Finally, deliver this batch to the sink
    try {
        // Since we reuse the messageBatch buffer, ensure we give the task its own copy
        log.trace("{} Delivering batch of {} messages to task", this, messageBatch.size());
        long start = time.milliseconds();
        task.put(new ArrayList<>(messageBatch));
        recordBatch(messageBatch.size());
        sinkTaskMetricsGroup.recordPut(time.milliseconds() - start);
        currentOffsets.putAll(origOffsets);
        messageBatch.clear();
        // If we had paused all consumer topic partitions to try to redeliver data, then we should resume any that
        // the task had not explicitly paused
        if (pausedForRedelivery) {
            if (!shouldPause())
                resumeAll();
            pausedForRedelivery = false;
        }
    } catch (RetriableException e) {
        log.error("{} RetriableException from SinkTask:", this, e);
        // If we're retrying a previous batch, make sure we've paused all topic partitions so we don't get new data,
        // but will still be able to poll in order to handle user-requested timeouts, keep group membership, etc.
        pausedForRedelivery = true;
        pauseAll();
        // Let this exit normally, the batch will be reprocessed on the next loop.
    } catch (Throwable t) {
        log.error("{} Task threw an uncaught and unrecoverable exception. Task is being killed and will not "
                + "recover until manually restarted. Error: {}", this, t.getMessage(), t);
        throw new ConnectException("Exiting WorkerSinkTask due to unrecoverable exception.", t);
    }
}



task.put(new ArrayList<>(messageBatch));具体实现方法为hdfssinktask中的put方法，实现如下


@Override
public void put(Collection records) throws ConnectException {
  if (log.isDebugEnabled()) {
    log.debug("Read {} records from Kafka", records.size());
  }
  try {
    hdfsWriter.write(records);
  } catch (ConnectException e) {
    throw new ConnectException(e);
  }
}

























你可能感兴趣的:(Kafka-connect-hdfs源码解析)






    

  • ArrayList 源码解析
程序猿进阶
Java基础ArrayListListjava面试性能优化架构设计idea

    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
    

    • 

  • Istio pilot-discovery服务发现源码解析（1.13版本）
xidianjiapei001
#Istioistio云原生服务发现

    Istiopilot-discovery服务发现介绍工作机制初始化初始化Config控制器初始化Service控制器controller初始化NamespaceServiceNodePodPilotDiscovery各组件启动流程DiscoveryServer接收Envoy的gRPC连接请求流程Config变化后向Envoy推送更新的流程总结参考介绍IstioPilot的代码分为Pilot-Dis
    

    • 

  • Java集合类框架源码分析 之 RoleList源码解析 【6】
yunzhonghefei
Java集合类源码分析RoleList源码解析

    该类继承于ArrayList，针对Role进行了一些扩展。其他方法和ArrayList中基本相同，源码不做针对性分析：看一下类简介：/***代表了一个roles的列表，作为方法setRoles()的参数，去创建一个关联关系，并且尝试在同一个关系中设置多个角色。*ARoleListrepresentsalistofroles(Roleobjects).Itisusedas*parameterwhen
    

    • 

  • VITS 源码解析2-模型概述
迪三
#NN_Audio音频人工智能

    VITs是文本到语音(Text-to-Speech,TTS)任务中最流行的技术之一，其实现思路是将文本语音信息融合到了HiFiGAN潜空间内,通过文本控制HiFiGAN的生成器，输出含文本语义的声音。VITs主要以GAN的方式训练,其生成器G是SynthesizerTrn，判别器D是MPD。VITS的判别器几乎和HiFiGAN一样，生成器则融合了文本、时序、声音三大类模型1.文件概述模型部分包含三
    

    • 

  • RBtree
努力的小带土
侯捷老师STLc++蓝桥杯

    终结B站没人能讲清楚红黑树的历史，不服等你来踢馆！-【码炫课堂收费课节选之-红黑树源码解析及手写红黑树】_哔哩哔哩_bilibiliB站的听课记录，并写下如下红黑树c++版本代码，该课程真的史诗级推荐！/*RBtreeNode.h*****/#pragmaonceenum{RED=false,BLACK=true};templateclassRBtreeNode{public://红黑树的左右节点
    

    • 

  • 深入理解Kubernetes：kube-scheduler源码解析
mujingluo
kubernetes容器云原生

    Kubernetes的调度器（kube-scheduler）是整个系统中至关重要的组件，它负责将待调度的Pods分配到合适的节点上。本文将深入分析kube-scheduler的源码，揭示其内部工作机制。kube-scheduler的核心功能kube-scheduler的核心功能包括：监听Pod变化：通过KubernetesAPI监听所有未调度的Pods。过滤（Filtering）：根据一系列规则（
    

    • 

  • 【Vesta发号器源码】PropertyMachineIdsProvider
DeanChangDM

    Vesta发号器源码解析——PropertyMachineIdsProvider属性配置文件持有Id的模式,没啥东西，比单个的多了一个获取下一个的方法封装实现上略有一点点区别privatelong[]machineIds;privateintcurrentIndex;publiclonggetNextMachineId(){returngetMachineId();}publiclonggetMa
    

    • 

  • StarRocks分布式元数据源码解析
不甚了然
Iceberg知识集StarRocksIceberg数据湖湖仓一体大数据

    1.支持元数据表https://github.com/StarRocks/starrocks/pull/44276/files核心类：LogicalIcebergMetadataTable，Iceberg元数据表，将元数据的各个字段做成表的列，后期可以通过sql操作从元数据获取字段，这个表的组成字段是DataFile相关的字段public static LogicalIcebergMetadata
    

    • 

  • 【Starrocks】建表篇Fe源码解析
数算七弦
Starrocks大数据

    Starrocks系统架构简述现在市面上主流的OLAP存算一体架构主要有两类进程：Frontend（FE）和Backend（BE）Frontend一般是用Java写的。主要职责有：接收用户连接请求（MySQL协议层）元数据存储与管理查询语句的解析与查询计划的生成集群管控Backend一般是用C++写的，主要职责有：数据存储与管理查询计划的执行建表语句的执行过程与Mysql协议层交互词法解析语法解析
    

    • 

  • 智能农业设备软件工程师如何集成和管理农业物联网（IoT）平台
openwin_top
智能农业设备软件工程师物联网python开发语言深度学习大数据智能农业

    microPythonPython最小内核源码解析NI-motion运动控制c语言示例代码解析python编程示例系列python编程示例系列二python的Web神器Streamlit如何应聘高薪职位集成和管理农业物联网（IoT）平台涉及多个步骤，包括设备连接、数据收集、数据传输、数据存储、数据分析和展示。以下是详细分析和示例代码展示。1.设备连接和数据收集首先，智能农业设备需要能够与传感器和执
    

    • 

  • 智能农业设备软件工程师如何集成和管理农业设备的远程更新系统
openwin_top
智能农业设备软件工程师深度学习大数据物联网人工智能网络智能农业

    microPythonPython最小内核源码解析NI-motion运动控制c语言示例代码解析python编程示例系列python编程示例系列二python的Web神器Streamlit如何应聘高薪职位集成和管理农业设备的远程更新系统涉及多个技术层面，包括设备固件的安全更新、版本控制、网络通信，以及设备管理平台的开发。下面我们详细分析这些步骤，并提供一个基本的示例代码来展示如何实现这个系统。1.系
    

    • 

  • 智能农业设备软件工程师如何处理设备的远程诊断和修复
openwin_top
智能农业设备软件工程师网络智能农业物联网人工智能大数据深度学习

    microPythonPython最小内核源码解析NI-motion运动控制c语言示例代码解析python编程示例系列python编程示例系列二python的Web神器Streamlit如何应聘高薪职位处理智能农业设备的远程诊断和修复涉及几个关键步骤，包括设备的数据采集、数据传输、远程诊断、远程控制和修复。以下是详细分析和示例代码：1.数据采集智能农业设备通常配备传感器和控制器，这些设备不断采集环
    

    • 

  • android10 按键音量调节源码解析
@OuYang
android

    /frameworks/base/services/core/java/com/android/server/policy/PhoneWindowManager.javastaticIAudioServicegetAudioService(){IAudioServiceaudioService=IAudioService.Stub.asInterface(ServiceManager.checkS
    

    • 

  • android10 Settings源码解析
@OuYang
android

    /packages/apps/Settings/AndroidManifest.xml.................................................................................activity-alias是Android里为了重复使用Activity而设计的。对于activity-alias标签，它有一个属性叫android:
    

    • 

  • MyBatis 源码解析：XMLScriptBuilder 工作机制
捕风捉你
MyBatis源码解读mybatisjava

    摘要MyBatis提供了强大的动态SQL功能，它通过解析XML配置文件中的动态SQL标签（如、、等），来实现灵活的SQL生成。而XMLScriptBuilder类则负责解析这些XML配置并生成最终的SQL语句。本文将详细解析XMLScriptBuilder的工作机制，并通过自定义实现来帮助您深入理解该类的功能。前言MyBatis中的动态SQL功能是通过解析XML配置文件实现的。XML文件中包含了动
    

    • 

  • c#视觉应用开发中如何使用Emgu CV在C#中进行图像处理？
openwin_top
C#视觉应用开发问题系列c#图像处理开发语言

    microPythonPython最小内核源码解析NI-motion运动控制c语言示例代码解析python编程示例系列python编程示例系列二python的Web神器Streamlit如何应聘高薪职位EmguCV是OpenCV的.NET包装器，可以让开发者在.NET语言（如C#）中使用OpenCV的功能进行图像处理。在进行图像处理时，EmguCV提供了丰富的API可以使用。以下是使用EmguCV
    

    • 

  • Elasticsearch——配置详解
smart哥
elasticsearch专题elasticsearch搜索引擎

    作者简介：大家好，我是smart哥，前中兴通讯、美团架构师，现某互联网公司CTO联系qq：184480602，加我进群，大家一起学习，一起进步，一起对抗互联网寒冬学习必须往深处挖，挖的越深，基础越扎实！阶段1、深入多线程阶段2、深入多线程设计模式阶段3、深入juc源码解析阶段4、深入jdk其余源码解析阶段5、深入jvm源码解析码哥源码部分码哥讲源码-原理源码篇【2024年最新大厂关于线程池使用的场
    

    • 

  • Eventbus3.0源码解析
超威蓝猫l

    根据官方demo首先你需要先在activity中注册EventBus.getDefault().register(this);register所以我们先从getDefault方法开始看起/**Conveniencesingletonforappsusingaprocess-wideEventBusinstance.*/publicstaticEventBusgetDefault(){EventBu
    

    • 

  • 前端宝典之三：React源码解析之Fiber架构
桃子叔叔
大厂进阶前端深度解析系列react.js架构javascript

    本文主要内容：1、ReactConcurrent2、React15架构3、React16架构4、Fiber架构5、任务调度循环和fiber构造循环区别一、ReactConcurrentReact在解决CPU卡顿是会用到ReactConcurrent的概念，它是React中的一个重要特性和模块，主要的特点和原理如下一、主要特点和优势1、时间切片（TimeSlicing）允许将长时间运行的任务分割成小
    

    • 

  • Java集合之HashSet源码解析
气宇轩昂固执狂
JAVA面试笔试通关指南java开发语言HashSetHashSet源码

    一、HashSet概述：1、HashSet底层实现实际上就是利用HashMap的键（Key）来存储对象，原HashMap的键key的位置存放对象，值value的位置存放空的Object对象作为虚拟值；2、增加和删除都是直接调用HashMap的方法来实现的，没有修改和具体的查询方法，获取值只能通过iterator方法来迭代，迭代方法也是建立在HashMap的键的迭代方法上的。相关HashSet的操作
    

    • 

  • Spring之AOP底层源码解析（上）
阿立聊代码
spring代理模式

    动态代理代理模式的解释：为其他对象提供一种代理以控制对这个对象的访问，增强一个类中的某个方法，对程序进行扩展。比如，现在存在一个UserService类：public class UserService  { public void test() {  System.out.println("test..."); }}此时，我们new一个UserService对象，然后执行test()方法，结果是
    

    • 

  • Spring Boot自动配置源码解析
一休哥助手
springbootjava数据库

    一、自动配置概述1.1什么是自动配置SpringBoot的自动配置是一种能够根据类路径中的依赖、配置文件中的属性以及其他条件，自动配置Spring应用上下文的功能。它通过扫描项目中的类和配置文件，判断哪些组件需要自动装配，从而减少了手动编写配置代码的繁琐过程。1.2自动配置的优点减少配置工作量：自动配置能够帮助开发者快速启动一个Spring应用，而不必担心各种复杂的XML或Java配置。智能化配置
    

    • 

  • Spring扩展点系列-InstantiationAwareBeanPostProcessor
码至终章
Spring生命周期扩展接口springsqljava扩展接口mavenspringboot

    文章目录简介测试一1、配置文件Bean注册2、单元测试方法3、测试类4、输出结果结论测试二1、测试类2、输出结果结论源码解析postProcessPropertiesCommonAnnotationBeanPostProcessorAnnotationInjectedBeanPostProcessor总结简介spring容器中Bean的生命周期内所有可扩展的点的调用顺序扩展接口实现接口Applic
    

    • 

  • MyBatis 源码解析：DefaultSqlSessionFactory 的创建与管理
捕风捉你
MyBatis源码解读mybatis

    摘要在MyBatis中，SqlSessionFactory是执行数据库操作的核心对象，它负责创建和管理SqlSession的生命周期。你是否想了解SqlSessionFactory的创建和管理过程？本文将通过自定义实现一个简化版的DefaultSqlSessionFactory，带你深入探讨MyBatis中DefaultSqlSessionFactory的创建与管理机制，并帮助你更好地掌握SqlS
    

    • 

  • FFmpeg源码解析系列（一）目录和编译
头快撑不住了
FFmpeg源码解析ffmpeg音视频视频编解码实时音视频图像处理

    引言当我们欣赏一部电影、观看一段视频或者享受一首音乐时，很少有人会停下来思考这一切是如何呈现在我们眼前的。然而，在每一帧的画面、每一秒的声音背后，有着一个不可思议的技术世界这个充满音视频的世界的核心之一，就是FFmpeg。FFmpeg是一个强大而复杂的多媒体处理工具，它为视频和音频编解码、流媒体传输、格式转换等提供了优秀的解决方案。在这个系列博客中，我们将深入探讨FFmpeg源码，解析它的工作原理
    

    • 

  • Spark MLlib LinearRegression线性回归算法源码解析
SmileySure
Spark人工智能算法SparkMLlib

    线性回归一元线性回归hθ(x)=θ0+θ1xhθ(x)=θ0+θ1x——————–1多元线性回归hθ(x)=∑mi=1θixi=θTXhθ(x)=∑i=1mθixi=θTX—————–2损失函数J(θ)=1/2∑mi=1(hθ(xi)−yi)2J(θ)=1/2∑i=1m(hθ(xi)−yi)2—————31/2是为了求导时系数为1，平方里是真实值减去估计值我们的目的就是求其最小值最小二乘法要求较为
    

    • 

  • HashMap源码解析
dlwlrma ⥳
兴趣类哈希算法散列表算法

    目录一:put方法流程二：get方法三：扩容机制一：put方法流程publicVput(Kkey,Vvalue){returnputVal(hash(key),key,value,false,true);}finalVputVal(inthash,Kkey,Vvalue,booleanonlyIfAbsent,booleanevict){Node[]tab;Nodep;intn,i;//判断数组是
    

    • 

  • Spring之启动过程源码解析
阿立聊代码
springspring数据库oracle

    前言分析通常，我们说的Spring启动，就是构造ApplicationContext对象以及调用refresh()方法的过程。首先，Spring启动过程主要做了这么几件事情：构造一个BeanFactory对象解析配置类，得到BeanDefinition，并注册到BeanFactory中解析@ComponentScan，此时就会完成扫描解析@Import解析@Bean...因为Application
    

    • 

  • 【HuggingFace Transformers】BertIntermediate 和 BertPooler源码解析
CS_木成河
HuggingFace深度学习人工智能bertpython大模型Transformer

    BertIntermediate和BertPooler源码解析1.介绍1.1位置与功能1.2相似点与不同点2.源码解析2.1BertIntermediate源码解析2.2BertPooler源码解析1.介绍1.1位置与功能(1)BertIntermediate位置：位于BertLayer的注意力层（BertSelfAttention）和输出层（BertOutput）之间。功能：它执行一个线性变换（
    

    • 

  • vue.js项目实战案例详细源码讲解
程序员小羊！
Javavue.js前端javascript

    大家好，我是程序员小羊！前言：为帮助大家更好地掌握Vue.js项目的开发流程，我将为你讲解一个完整的Vue.js实战案例，并提供详细的源码解析。这个案例将涵盖从项目创建到实现各种功能模块的全过程，适合用于构建一个具有基本CRUD功能的简单任务管理应用。案例介绍我们将开发一个任务管理应用（TaskManager），它允许用户添加、查看、编辑和删除任务。这个应用将包括以下主要功能模块：任务列表显示：展
    

    • 

  • Enum 枚举
120153216
enum枚举

    原文地址：http://www.cnblogs.com/Kavlez/p/4268601.html Enumeration
于Java 1.5增加的enum type...enum type是由一组固定的常量组成的类型，比如四个季节、扑克花色。在出现enum type之前，通常用一组int常量表示枚举类型。比如这样：
public static final int APPLE_FUJI = 0
    

    • 

  • Java8简明教程
bijian1013
javajdk1.8

            Java 8已于2014年3月18日正式发布了，新版本带来了诸多改进，包括Lambda表达式、Streams、日期时间API等等。本文就带你领略Java 8的全新特性。 
一.允许在接口中有默认方法实现
        Java 8 允许我们使用default关键字，为接口声明添
    

    • 

  • Oracle表维护 快速备份删除数据
cuisuqiang
oracle索引快速备份删除

    我知道oracle表分区，不过那是数据库设计阶段的事情，目前是远水解不了近渴。
当前的数据库表，要求保留一个月数据，且表存在大量录入更新，不存在程序删除。
为了解决频繁查询和更新的瓶颈，我在oracle内根据需要创建了索引。但是随着数据量的增加，一个半月数据就要超千万，此时就算有索引，对高并发的查询和更新来说，让然有所拖累。
为了解决这个问题，我一般一个月会进行一次数据库维护，主要工作就是备
    

    • 

  • java多态内存分析
麦田的设计者
java内存分析多态原理接口和抽象类

          “  时针如果可以回头，熟悉那张脸，重温嬉戏这乐园，墙壁的松脱涂鸦已经褪色才明白存在的价值归于记忆。街角小店尚存在吗？这大时代会不会牵挂，过去现在花开怎么会等待。
      但有种意外不管痛不痛都有伤害，光阴远远离开，那笑声徘徊与脑海。但这一秒可笑不再可爱，当天心
    

    • 

  • Xshell实现Windows上传文件到Linux主机
被触发
windows

    经常有这样的需求，我们在Windows下载的软件包，如何上传到远程Linux主机上？还有如何从Linux主机下载软件包到Windows下；之前我的做法现在看来好笨好繁琐，不过也达到了目的，笨人有本方法嘛；
我是怎么操作的：
1、打开一台本地Linux虚拟机，使用mount 挂载Windows的共享文件夹到Linux上，然后拷贝数据到Linux虚拟机里面；（经常第一步都不顺利，无法挂载Windo
    

    • 

  • 类的加载ClassLoader
肆无忌惮_
ClassLoader

    类加载器ClassLoader是用来将java的类加载到虚拟机中，类加载器负责读取class字节文件到内存中，并将它转为Class的对象（类对象），通过此实例的 newInstance()方法就可以创建出该类的一个对象。
 
其中重要的方法为findClass(String name)。
 
如何写一个自己的类加载器呢？
首先写一个便于测试的类Student
    

    • 

  • html5写的玫瑰花
知了ing
html5

    <html>
<head>
<title>I Love You!</title>
<meta charset="utf-8" />
</head>
<body>
<canvas id="c"></canvas> 
    

    • 

  • google的ConcurrentLinkedHashmap源代码解析
矮蛋蛋
LRU

    原文地址：
http://janeky.iteye.com/blog/1534352
简述
ConcurrentLinkedHashMap 是google团队提供的一个容器。它有什么用呢？其实它本身是对
ConcurrentHashMap的封装，可以用来实现一个基于LRU策略的缓存。详细介绍可以参见
http://code.google.com/p/concurrentlinke
    

    • 

  • webservice获取访问服务的ip地址
alleni123
webservice

    1. 首先注入javax.xml.ws.WebServiceContext,
@Resource
private WebServiceContext context;
2. 在方法中获取交换请求的对象。
javax.xml.ws.handler.MessageContext mc=context.getMessageContext();
com.sun.net.http
    

    • 

  • 菜鸟的java基础提升之道——————>是否值得拥有
百合不是茶

    1，c++，java是面向对象编程的语言，将万事万物都看成是对象；java做一件事情关注的是人物，java是c++继承过来的，java没有直接更改地址的权限但是可以通过引用来传值操作地址，java也没有c++中繁琐的操作，java以其优越的可移植型，平台的安全型，高效性赢得了广泛的认同，全世界越来越多的人去学习java，我也是其中的一员
 
 
 java组成：
    

    • 

  • 通过修改Linux服务自动启动指定应用程序
bijian1013
linux

    Linux中修改系统服务的命令是chkconfig (check config)，命令的详细解释如下: chkconfig
功能说明：检查，设置系统的各种服务。
语　　法：chkconfig [ -- add][ -- del][ -- list][系统服务] 或 chkconfig [ -- level  <</SPAN>
    

    • 

  • spring拦截器的一个简单实例
bijian1013
javaspring拦截器Interceptor

    Purview接口
package aop;
public interface Purview {
void checkLogin();
}
Purview接口的实现类PurviesImpl.java
package aop;
public class PurviewImpl implements Purview {
public void check
    

    • 

  • [Velocity二]自定义Velocity指令
bit1129
velocity

    什么是Velocity指令
在Velocity中，#set,#if, #foreach, #elseif, #parse等，以#开头的称之为指令，Velocity内置的这些指令可以用来做赋值，条件判断，循环控制等脚本语言必备的逻辑控制等语句，Velocity的指令是可扩展的，即用户可以根据实际的需要自定义Velocity指令
  自定义指令(Directive)的一般步骤
&nbs
    

    • 

  • 【Hive十】Programming Hive学习笔记
bit1129
programming

     第二章 Getting Started
1.Hive最大的局限性是什么？一是不支持行级别的增删改(insert, delete, update)二是查询性能非常差(基于Hadoop MapReduce）,不适合延迟小的交互式任务三是不支持事务2. Hive MetaStore是干什么的？Hive persists table schemas and other system metadata.
    

    • 

  • nginx有选择性进行限制
ronin47
nginx 动静　限制

    http {
limit_conn_zone $binary_remote_addr zone=addr:10m;
limit_req_zone $binary_remote_addr zone=one:10m rate=5r/s;...
server {...
location ~.*\.(gif|png|css|js|icon)$ {

    

    • 

  • java-4.-在二元树中找出和为某一值的所有路径 .
bylijinnan
java

    
/*
* 0.use a TwoWayLinkedList to store the path.when the node can't be path,you should/can delete it.
* 1.curSum==exceptedSum:if the lastNode is TreeNode,printPath();delete the node otherwise 
    

    • 

  • Netty学习笔记
bylijinnan
javanetty

    本文是阅读以下两篇文章时：
http://seeallhearall.blogspot.com/2012/05/netty-tutorial-part-1-introduction-to.html
http://seeallhearall.blogspot.com/2012/06/netty-tutorial-part-15-on-channel.html
我的一些笔记
===
    

    • 

  • js获取项目路径
cngolon
js

    //js获取项目根路径，如： http://localhost:8083/uimcardprj
function getRootPath(){
    //获取当前网址，如： http://localhost:8083/uimcardprj/share/meun.jsp
    var curWwwPath=window.document.locati
    

    • 

  • oracle 的性能优化
cuishikuan
oracleSQL Server

       在网上搜索了一些Oracle性能优化的文章，为了更加深层次的巩固[边写边记]，也为了可以随时查看，所以发表这篇文章。
    1.ORACLE采用自下而上的顺序解析WHERE子句，根据这个原理，表之间的连接必须写在其他WHERE条件之前，那些可以过滤掉最大数量记录的条件必须写在WHERE子句的末尾。（这点本人曾经做过实例验证过，的确如此哦！
    

    • 

  • Shell变量和数组使用详解
daizj
linuxshell变量数组

    Shell 变量
定义变量时，变量名不加美元符号（$，PHP语言中变量需要），如：
your_name="w3cschool.cc"
注意，变量名和等号之间不能有空格，这可能和你熟悉的所有编程语言都不一样。同时，变量名的命名须遵循如下规则：
首个字符必须为字母（a-z，A-Z）。
中间不能有空格，可以使用下划线（_）。
不能使用标点符号。
不能使用ba
    

    • 

  • 编程中的一些概念，KISS、DRY、MVC、OOP、REST
dcj3sjt126com
REST

    KISS、DRY、MVC、OOP、REST （1）KISS是指Keep It Simple,Stupid（摘自wikipedia），指设计时要坚持简约原则，避免不必要的复杂化。 （2）DRY是指Don't Repeat Yourself（摘自wikipedia），特指在程序设计以及计算中避免重复代码，因为这样会降低灵活性、简洁性，并且可能导致代码之间的矛盾。 （3）OOP 即Object-Orie
    

    • 

  • [Android]设置Activity为全屏显示的两种方法
dcj3sjt126com
Activity

    1. 方法1：AndroidManifest.xml 里，Activity的 android:theme  指定为" @android:style/Theme.NoTitleBar.Fullscreen" 示例:   <application      
    

    • 

  • solrcloud 部署方式比较
eksliang
solrCloud

    solrcloud 的部署其实有两种方式可选，那么我们在实践开发中应该怎样选择呢？ 第一种：当启动solr服务器时，内嵌的启动一个Zookeeper服务器，然后将这些内嵌的Zookeeper服务器组成一个集群。  第二种：将Zookeeper服务器独立的配置一个集群，然后将solr交给Zookeeper进行管理
 
谈谈第一种：每启动一个solr服务器就内嵌的启动一个Zoo
    

    • 

  • Java synchronized关键字详解
gqdy365
synchronized

    转载自：http://www.cnblogs.com/mengdd/archive/2013/02/16/2913806.html
多线程的同步机制对资源进行加锁，使得在同一个时间，只有一个线程可以进行操作，同步用以解决多个线程同时访问时可能出现的问题。
同步机制可以使用synchronized关键字实现。
当synchronized关键字修饰一个方法的时候，该方法叫做同步方法。
当s
    

    • 

  • js实现登录时记住用户名
hw1287789687
记住我记住密码cookie记住用户名记住账号

    在页面中如何获取cookie值呢?
如果是JSP的话,可以通过servlet的对象request 获取cookie,可以
参考:http://hw1287789687.iteye.com/blog/2050040
如果要求登录页面是html呢?html页面中如何获取cookie呢?
直接上代码了
页面:loginInput.html
代码:
<!DOCTYPE html PUB
    

    • 

  • 开发者必备的 Chrome 扩展
justjavac
chrome

    Firebug：不用多介绍了吧https://chrome.google.com/webstore/detail/bmagokdooijbeehmkpknfglimnifench
ChromeSnifferPlus：Chrome 探测器，可以探测正在使用的开源软件或者 js 类库https://chrome.google.com/webstore/detail/chrome-sniffer-pl
    

    • 

  • 算法机试题
李亚飞
java算法机试题

           在面试机试时，遇到一个算法题，当时没能写出来，最后是同学帮忙解决的。
       这道题大致意思是：输入一个数，比如4,。这时会输出：
          &n
    

    • 

  • 正确配置Linux系统ulimit值
字符串
ulimit

    在Linux下面部 署应用的时候，有时候会遇上Socket/File: Can’t open so many files的问题；这个值也会影响服务器的最大并发数，其实Linux是有文件句柄限制的，而且Linux默认不是很高，一般都是1024，生产服务器用 其实很容易就达到这个数量。下面说的是，如何通过正解配置来改正这个系统默认值。因为这个问题是我配置Nginx+php5时遇到了，所以我将这篇归纳进
    

    • 

  • hibernate调用返回游标的存储过程
Supanccy2013
javaDAOoracleHibernatejdbc

    注：原创作品，转载请注明出处。
    上篇博文介绍的是hibernate调用返回单值的存储过程，本片博文说的是hibernate调用返回游标的存储过程。
    此此扁博文的存储过程的功能相当于是jdbc调用select 的作用。
1，创建oracle中的包，并在该包中创建的游标类型。
---创建oracle的程
    

    • 

  • Spring 4.2新特性-更简单的Application Event
wiselyman
application

    1.1 Application Event
Spring 4.1的写法请参考10点睛Spring4.1-Application Event
请对比10点睛Spring4.1-Application Event
使用一个@EventListener取代了实现ApplicationListener接口,使耦合度降低;
1.2 示例
包依赖
<p
    

    •