hadoop Path用法示例源码详解

于 2023-12-06 23:59:49 发布
阅读量503 收藏 8
点赞数 9
分类专栏： 大数据 java 文章标签： hadoop 大数据 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wang2leee/article/details/134844047
版权
java 同时被 2 个专栏收录
117 篇文章 2 订阅
订阅专栏
大数据
50 篇文章 0 订阅
订阅专栏

hadoop Path由来用法示例源码详解

文章目录

由来

Hadoop Path是Hadoop文件系统（HDFS）中文件和目录的抽象表示。它由Hadoop核心库提供，并用于处理Hadoop分布式文件系统中的文件路径。

Path类的设计受到了Unix文件系统路径的启发，它使用斜杠（/）作为分隔符来表示层次结构路径。与Unix路径不同的是，Hadoop Path可以引用不同的文件系统，如本地文件系统、HDFS以及其他支持的文件系统，因此它还包含有关文件系统方案和权限的信息。

作用

Path类的主要作用是：

  1. 表示文件和目录的路径，可以指定绝对路径或相对路径。
  2. 提供方法来操作路径，如获取路径的父级、获取路径的最后一个组件、比较路径等。
  3. 与FileSystem类一起使用，用于创建文件系统对象、打开文件、读取数据等操作。

在Hadoop中，Path类广泛用于处理文件系统中的路径信息。它在MapReduce作业、Hive查询、Spark应用程序等各种大数据处理场景中都被频繁使用。

总之，Hadoop Path是Hadoop文件系统中文件和目录的抽象表示，它提供了操作路径的方法，并与FileSystem类一起使用来进行文件系统的访问和操作。

方法总结

方法描述
int compareTo(Path o)比较此路径与给定路径的顺序。
int depth()返回此路径中的元素数。
boolean equals(Object o)判断此路径是否与给定对象相等。
FileSystem getFileSystem(Configuration conf)返回拥有此路径的FileSystem。
String getName()返回此路径的最后一个组件。
Path getParent()返回路径的父级，如果在根目录，则返回null。
static Path getPathWithoutSchemeAndAuthority(Path path)返回不带方案信息的给定路径的版本。
int hashCode()返回此路径的哈希码值。
boolean isAbsolute()判断路径是否为绝对路径。
boolean isAbsoluteAndSchemeAuthorityNull()判断路径是否为绝对路径且没有方案和权限。
boolean isRoot()判断路径是否为文件系统的根。
boolean isUriPathAbsolute()判断路径是否为URI路径的绝对路径。
static boolean isWindowsAbsolutePath(String pathString, boolean slashed)判断给定路径字符串是否表示Windows上的绝对路径。
Path makeQualified(FileSystem fs)获取路径在指定文件系统中的限定路径。
static Path mergePaths(Path path1, Path path2)合并两个路径，将第二个路径附加到第一个路径中。
Path suffix(String suffix)将后缀添加到路径的最后一个组件。
String toString()将路径转换为字符串表示。
URI toUri()将路径转换为URI。
void validateObject()验证反序列化路径的内容，以防止恶意对象流。

示例

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;

import java.io.IOException;
import java.net.URI;

public class PathExample {
    public static void main(String[] args) {
        // 创建配置对象
        Configuration conf = new Configuration();

        // 创建路径对象
        Path path = new Path("/user/hadoop/input/file.txt");

        // 比较路径
        Path anotherPath = new Path("/user/hadoop/output/file.txt");
        int compareResult = path.compareTo(anotherPath);
        System.out.println("Compare Result: " + compareResult);

        // 获取路径的深度
        int depth = path.depth();
        System.out.println("Depth: " + depth);

        // 判断路径是否相等
        boolean isEqual = path.equals(anotherPath);
        System.out.println("Is Equal: " + isEqual);

        try {
            // 获取拥有此路径的FileSystem
            FileSystem fileSystem = path.getFileSystem(conf);
            System.out.println("FileSystem: " + fileSystem);

            // 获取路径的最后一个组件
            String name = path.getName();
            System.out.println("Name: " + name);

            // 获取路径的父级
            Path parent = path.getParent();
            System.out.println("Parent: " + parent);

            // 将路径转换为URI
            URI uri = path.toUri();
            System.out.println("URI: " + uri);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
//Compare Result: -6
//Depth: 4
//Is Equal: false
//FileSystem: org.apache.hadoop.fs.LocalFileSystem@2a32de6c
//Name: file.txt
//Parent: /user/hadoop/input
//URI: /user/hadoop/input/file.txt

源码

import java.org.apache.hadoop.shaded.io.IOException;
import java.org.apache.hadoop.shaded.io.InvalidObjectException;
import java.org.apache.hadoop.shaded.io.ObjectInputValidation;
import java.org.apache.hadoop.shaded.io.Serializable;
import java.org.apache.hadoop.shaded.net.URI;
import java.org.apache.hadoop.shaded.net.URISyntaxException;
import java.util.regex.Pattern;

import org.apache.hadoop.shaded.org.apache.avro.reflect.Stringable;
import org.apache.hadoop.shaded.org.apache.org.apache.hadoop.shaded.com.ons.lang3.StringUtils;
import org.apache.hadoop.shaded.org.apache.hadoop.HadoopIllegalArgumentException;
import org.apache.hadoop.shaded.org.apache.hadoop.classification.InterfaceAudience;
import org.apache.hadoop.shaded.org.apache.hadoop.classification.InterfaceStability;
import org.apache.hadoop.shaded.org.apache.hadoop.conf.Configuration;

/**
 * 在{@link FileSystem}中命名文件或目录的路径。
 * 路径字符串使用斜杠作为目录分隔符。
 */
@Stringable
@InterfaceAudience.Public
@InterfaceStability.Stable
public class Path
    implements Comparable<Path>, Serializable, ObjectInputValidation {

  /**
   * 目录分隔符，一个斜杠。
   */
  public static final String SEPARATOR = "/";

  /**
   * 目录分隔符，一个斜杠，作为字符。
   */
  public static final char SEPARATOR_CHAR = '/';
  
  /**
   * 当前目录，"。"
   */
  public static final String CUR_DIR = ".";
  
  /**
   * 当前主机是否为Windows机器。
   */
  public static final boolean WINDOWS =
      System.getProperty("os.name").startsWith("Windows");

  /**
   * 用于检测路径格式的预编译正则表达式。
   */
  private static final Pattern HAS_DRIVE_LETTER_SPECIFIER =
      Pattern.org.apache.hadoop.shaded.com.ile("^/?[a-zA-Z]:");

  /** 用于检测重复斜线的预编译正则表达式。 */
  private static final Pattern SLASHES = Pattern.org.apache.hadoop.shaded.com.ile("/+");

  private static final long serialVersionUID = 0xad00f;

  private URI uri; // 分层uri

  /**
   * 检查此路径是否使用方案并且是相对的。
   * 带有方案和相对路径的路径名是非法的。
   */
  void checkNotSchemeWithRelative() {
    if (toUri().isAbsolute() && !isUriPathAbsolute()) {
      throw new HadoopIllegalArgumentException(
          "Unsupported name: has scheme but relative path-part");
    }
  }

  void checkNotRelative() {
    if (!isAbsolute() && toUri().getScheme() == null) {
      throw new HadoopIllegalArgumentException("Path is relative");
    }
  }

  /**
   * 返回一个不包含方案信息的给定路径的副本。
   *
   * @param path 源路径
   * @return 不包含方案信息的此路径的副本
   */
  public static Path getPathWithoutSchemeAndAuthority(Path path) {
    // 此代码依赖于Path.toString()在Windows之前删除驱动器规范之前删除前导斜杠。
    Path newPath = path.isUriPathAbsolute() ?
      new Path(null, null, path.toUri().getPath()) :
      path;
    return newPath;
  }

  /**
   * 根据相对于父路径解析的子路径创建新路径。
   *
   * @param parent 父路径
   * @param child 子路径
   */
  public Path(String parent, String child) {
    this(new Path(parent), new Path(child));
  }

  /**
   * 根据相对于父路径解析的子路径创建新路径。
   *
   * @param parent 父路径
   * @param child 子路径
   */
  public Path(Path parent, String child) {
    this(parent, new Path(child));
  }

  /**
   * 根据相对于父路径解析的子路径创建新路径。
   *
   * @param parent 父路径
   * @param child 子路径
   */
  public Path(String parent, Path child) {
    this(new Path(parent), child);
  }

  /**
   * 根据相对于父路径解析的子路径创建新路径。
   *
   * @param parent 父路径
   * @param child 子路径
   */
  public Path(Path parent, Path child) {
    // 向父级路径添加斜杠，以使解析与URI的org.apache.hadoop.shaded.com.atible
    URI parentUri = parent.uri;
    String parentPath = parentUri.getPath();
    if (!(parentPath.equals("/") || parentPath.isEmpty())) {
      try {
        parentUri = new URI(parentUri.getScheme(), parentUri.getAuthority(),
                      parentUri.getPath()+"/", null, parentUri.getFragment());
      } catch (URISyntaxException e) {
        throw new IllegalArgumentException(e);
      }
    }
    URI resolved = parentUri.resolve(child.uri);
    initialize(resolved.getScheme(), resolved.getAuthority(),
               resolved.getPath(), resolved.getFragment());
  }

  private void checkPathArg( String path ) throws IllegalArgumentException {
    // 禁止使用空字符串构建路径
    if ( path == null ) {
      throw new IllegalArgumentException(
          "Can not create a Path from a null string");
    }
    if( path.length() == 0 ) {
       throw new IllegalArgumentException(
           "Can not create a Path from an empty string");
    }   
  }
  
  /**
   * 从字符串创建路径。路径字符串是URI，但是没有转义的元素和一些附加的标准化。
   *
   * @param pathString 路径字符串
   */
  public Path(String pathString) throws IllegalArgumentException {
    checkPathArg( pathString );
    
    // 我们不能直接使用'new URI(String)'，因为它假设事物都已转义，
    // 而我们不要求Paths转义。

    // 在具有Windows驱动器字母的路径前面添加斜杠
    if (hasWindowsDrive(pathString) && pathString.charAt(0) != '/') {
      pathString = "/" + pathString;
    }

    // 解析uri的组件
    String scheme = null;
    String authority = null;

    int start = 0;

    // 解析uri方案（如果有）
    int colon = pathString.indexOf(':');
    int slash = pathString.indexOf('/');
    if ((colon != -1) &&
        ((slash == -1) || (colon < slash))) {     // 有方案
      scheme = pathString.substring(0, colon);
      start = colon+1;
    }

    // 解析uri授权（如果有）
    if (pathString.startsWith("//", start) &&
        (pathString.length()-start > 2)) {       // 有授权
      int nextSlash = pathString.indexOf('/', start+2);
      int authEnd = nextSlash > 0 ? nextSlash : pathString.length();
      authority = pathString.substring(start+2, authEnd);
      start = authEnd;
    }

    // uri路径是字符串的剩余部分 - 不支持查询和片段
    String path = pathString.substring(start, pathString.length());

    initialize(scheme, authority, path, null);
  }

  /**
   * 根据URI创建路径
   *
   * @param aUri 源URI
   */
  public Path(URI aUri) {
    uri = aUri.normalize();
  }
  
  /**
   * 根据org.apache.hadoop.shaded.com.onents创建路径。
   *
   * @param scheme 方案
   * @param authority 授权
   * @param path 路径
   */
  public Path(String scheme, String authority, String path) {
    checkPathArg( path );

    // 在具有Windows驱动器字母的路径前面添加斜杠
    if (hasWindowsDrive(path) && path.charAt(0) != '/') {
      path = "/" + path;
    }

    // 在Linux相对路径前面添加"./"，以便不会将包含冒号的路径（例如"a:b"）解释为方案"a"。
    if (!WINDOWS && path.charAt(0) != '/') {
      path = "./" + path;
    }

    initialize(scheme, authority, path, null);
  }

  private void initialize(String scheme, String authority, String path,
      String fragment) {
    try {
      this.uri = new URI(scheme, authority, normalizePath(scheme, path), null, fragment)
        .normalize();
    } catch (URISyntaxException e) {
      throw new IllegalArgumentException(e);
    }
  }

  /**
   * 合并两个路径，使第二个路径相对于第一个路径添加。
   * 返回的路径具有第一个路径的方案和授权。在Windows上，丢弃第二个路径中的驱动器规范。
   * 
   * @param path1 第一个路径
   * @param path2 要附加到path1的第二个路径
   * @return 合并后的路径
   */
  public static Path mergePaths(Path path1, Path path2) {
    String path2Str = path2.toUri().getPath();
    path2Str = path2Str.substring(startPositionWithoutWindowsDrive(path2Str));
    // 明确添加路径org.apache.hadoop.shaded.com.onents，因为简单地连接两个路径字符串是不安全的，例如：
    // "/" + "/foo"产生"//foo"，这将被解析为Path中的授权
    return new Path(path1.toUri().getScheme(), 
        path1.toUri().getAuthority(), 
        path1.toUri().getPath() + path2Str);
  }

  /**
   * 将路径字符串规范化为使用非重复的前斜杠作为路径分隔符，并删除任何尾部路径分隔符。
   *
   * @param scheme URI方案。用于推断我们是否应该替换反斜杠
   * @param path 方案特定部分
   * @return 规范化的路径字符串
   */
  private static String normalizePath(String scheme, String path) {
    // 删除重复的斜线。
    path = SLASHES.matcher(path).replaceAll("/");

    // 如果这看起来像Windows路径，请删除反斜杠。如果看起来像非本地URI，请避免替换。
    if (WINDOWS &&
        (hasWindowsDrive(path) ||
         (scheme == null) ||
         (scheme.isEmpty()) ||
         (scheme.equals("file")))) {
      path = StringUtils.replace(path, "\\", "/");
    }
    
    // 从非根路径中删除尾部斜杠（忽略Windows驱动器）
    int minLength = startPositionWithoutWindowsDrive(path) + 1;
    if (path.length() > minLength && path.endsWith(SEPARATOR)) {
      path = path.substring(0, path.length()-1);
    }
    
    return path;
  }

  private static boolean hasWindowsDrive(String path) {
    return (WINDOWS && HAS_DRIVE_LETTER_SPECIFIER.matcher(path).find());
  }

  private static int startPositionWithoutWindowsDrive(String path) {
    if (hasWindowsDrive(path)) {
      return path.charAt(0) ==  SEPARATOR_CHAR ? 3 : 2;
    } else {
      return 0;
    }
  }
  
  /**
   * 确定给定路径字符串是否表示Windows上的绝对路径。例如，"C:/a/b"是绝对路径，而"C:a/b"不是。
   *
   * @param pathString 要评估的路径字符串
   * @param slashed 如果给定路径以"/"为前缀，则为true
   * @return 如果提供的路径看起来是带有Windows驱动器规范的绝对路径，则为true
   */
  public static boolean isWindowsAbsolutePath(final String pathString,
                                              final boolean slashed) {
    int start = startPositionWithoutWindowsDrive(pathString);
    return start > 0
        && pathString.length() > start
        && ((pathString.charAt(start) == SEPARATOR_CHAR) ||
            (pathString.charAt(start) == '\\'));
  }

  /**
   * 将此Path转换为URI。
   *
   * @return 此Path作为URI
   */
  public URI toUri() { return uri; }

  /**
   * 返回拥有此Path的FileSystem。
   *
   * @param conf 解析FileSystem时使用的配置
   * @return 拥有此Path的FileSystem
   * @throws java.org.apache.hadoop.shaded.io.IOException 如果解析FileSystem时出现问题
   */
  public FileSystem getFileSystem(Configuration conf) throws IOException {
    return FileSystem.get(this.toUri(), conf);
  }

  /**
   * 当前路径的目录（即文件夹）部分是否是绝对的<strong>且</strong>方案为空，<b>且</b>授权为空。
   *
   * @return 路径是否绝对，URI是否没有方案和授权部分
   */
  public boolean isAbsoluteAndSchemeAuthorityNull() {
    return  (isUriPathAbsolute() && 
        uri.getScheme() == null && uri.getAuthority() == null);
  }
  
  /**
   * 此URI的路径org.apache.hadoop.shaded.com.onent是否是绝对的。
   *
   * @return 此URI的路径是否是绝对的
   */
  public boolean isUriPathAbsolute() {
    int start = startPositionWithoutWindowsDrive(uri.getPath());
    return uri.getPath().startsWith(SEPARATOR, start);
   }
  
  /**
   * 此URI的路径org.apache.hadoop.shaded.com.onent是否是绝对的。此方法是{@link #isUriPathAbsolute()}的包装器。
   *
   * @return 此URI的路径是否是绝对的
   */
  public boolean isAbsolute() {
     return isUriPathAbsolute();
  }

  /**
   * 当且仅当此路径表示文件系统的根时，返回true。
   *
   * @return 当且仅当此路径表示文件系统的根时为true
   */
  public boolean isRoot() {
    return getParent() == null;
  }

  /**
   * 返回此路径的最后一个org.apache.hadoop.shaded.com.onent。
   *
   * @return 此路径的最后一个org.apache.hadoop.shaded.com.onent
   */
  public String getName() {
    String path = uri.getPath();
    int slash = path.lastIndexOf(SEPARATOR);
    return path.substring(slash+1);
  }

  /**
   * 返回路径的父路径，如果在根目录，则返回null。
   * @return 路径的父路径，如果在根目录，则返回null
   */
  public Path getParent() {
    String path = uri.getPath();
    int lastSlash = path.lastIndexOf('/');
    int start = startPositionWithoutWindowsDrive(path);
    if ((path.length() == start) ||               // 空路径
        (lastSlash == start && path.length() == start+1)) { // 在根目录
      return null;
    }
    String parent;
    if (lastSlash==-1) {
      parent = CUR_DIR;
    } else {
      parent = path.substring(0, lastSlash==start?start+1:lastSlash);
    }
    return new Path(uri.getScheme(), uri.getAuthority(), parent);
  }

  /**
   * 向路径的最后一个org.apache.hadoop.shaded.com.onent添加后缀。
   *
   * @param suffix 要添加的后缀
   * @return 添加了后缀的新路径
   */
  public Path suffix(String suffix) {
    return new Path(getParent(), getName()+suffix);
  }

  @Override
  public String toString() {
    // 我们不能使用uri.toString()，因为它会转义所有内容，但我们希望在字符串中不转义非法字符，以便进行全局处理等。
    StringBuilder buffer = new StringBuilder();
    if (uri.getScheme() != null) {
      buffer.append(uri.getScheme())
          .append(":");
    }
    if (uri.getAuthority() != null) {
      buffer.append("//")
          .append(uri.getAuthority());
    }
    if (uri.getPath() != null) {
      String path = uri.getPath();
      if (path.indexOf('/')==0 &&
          hasWindowsDrive(path) &&                // 有Windows驱动器
          uri.getScheme() == null &&              // 但没有方案
          uri.getAuthority() == null)             // 或授权
        path = path.substring(1);                 // 删除驱动器之前的斜杠
      buffer.append(path);
    }
    if (uri.getFragment() != null) {
      buffer.append("#")
          .append(uri.getFragment());
    }
    return buffer.toString();
  }

  @Override
  public boolean equals(Object o) {
    if (!(o instanceof Path)) {
      return false;
    }
    Path that = (Path)o;
    return this.uri.equals(that.uri);
  }

  @Override
  public int hashCode() {
    return uri.hashCode();
  }

  @Override
  public int org.apache.hadoop.shaded.com.areTo(Path o) {
    return this.uri.org.apache.hadoop.shaded.com.areTo(o.uri);
  }

  /**
   * 返回此路径中的元素数。
   * @return 此路径中的元素数
   */
  public int depth() {
    String path = uri.getPath();
    int depth = 0;
    int slash = path.length()==1 && path.charAt(0)=='/' ? -1 : 0;
    while (slash != -1) {
      depth++;
      slash = path.indexOf(SEPARATOR, slash+1);
    }
    return depth;
  }

/**
 * 返回路径中的元素数量。
 * @return 路径中的元素数量
 */
public int depth() {
  String path = uri.getPath();
  int depth = 0;
  int slash = path.length()==1 && path.charAt(0)=='/' ? -1 : 0;
  while (slash != -1) {
    depth++;
    slash = path.indexOf(SEPARATOR, slash+1);
  }
  return depth;
}

/**
 * 返回{@link FileSystem}的工作目录的合格路径对象。
 *
 * @param fs 目标FileSystem
 * @return FileSystem的工作目录的合格路径对象
 * @deprecated 使用 {@link #makeQualified(URI, Path)} 方法代替
 */
@Deprecated
public Path makeQualified(FileSystem fs) {
  return makeQualified(fs.getUri(), fs.getWorkingDirectory());
}

/**
 * 返回一个合格的路径对象。
 *
 * @param defaultUri 如果此路径缺少方案或机构，从此URI中获取
 * @param workingDir 如果此路径不是绝对路径，则将其视为相对于此工作目录
 * @return 如果该路径包含方案和机构并且是绝对路径，则返回此路径，否则返回一个包含路径和机构并且是完全限定的新路径
 */
@InterfaceAudience.LimitedPrivate({"HDFS", "MapReduce"})
public Path makeQualified(URI defaultUri, Path workingDir ) {
  Path path = this;
  if (!isAbsolute()) {
    path = new Path(workingDir, this);
  }

  URI pathUri = path.toUri();

  String scheme = pathUri.getScheme();
  String authority = pathUri.getAuthority();
  String fragment = pathUri.getFragment();

  if (scheme != null &&
      (authority != null || defaultUri.getAuthority() == null))
    return path;

  if (scheme == null) {
    scheme = defaultUri.getScheme();
  }

  if (authority == null) {
    authority = defaultUri.getAuthority();
    if (authority == null) {
      authority = "";
    }
  }

  URI newUri = null;
  try {
    newUri = new URI(scheme, authority ,
      normalizePath(scheme, pathUri.getPath()), null, fragment);
  } catch (URISyntaxException e) {
    throw new IllegalArgumentException(e);
  }
  return new Path(newUri);
}

/**
 * 验证反序列化的路径的内容，以防止恶意对象流。
 * @throws InvalidObjectException 如果没有URI
 */
@Override
public void validateObject() throws InvalidObjectException {
  if (uri == null) {
    throw new InvalidObjectException("No URI in deserialized Path");
  }
}
etScheme();
  }

  if (authority == null) {
    authority = defaultUri.getAuthority();
    if (authority == null) {
      authority = "";
    }
  }

  URI newUri = null;
  try {
    newUri = new URI(scheme, authority ,
      normalizePath(scheme, pathUri.getPath()), null, fragment);
  } catch (URISyntaxException e) {
    throw new IllegalArgumentException(e);
  }
  return new Path(newUri);
}

/**
 * 验证反序列化的路径的内容，以防止恶意对象流。
 * @throws InvalidObjectException 如果没有URI
 */
@Override
public void validateObject() throws InvalidObjectException {
  if (uri == null) {
    throw new InvalidObjectException("No URI in deserialized Path");
  }
}
BigDataMLApplication
关注
专栏目录
Hadoop之HDFS文件上传源码解析
qq_45115959的博客
08-18 979
为了在项目中使用 HDFS 的文件上传功能，我们需要添加以下依赖项到项目的构建配置文件中（例如 Maven 的。在这一节中，我们将详细探讨 HDFS 中文件创建的具体流程。类负责与 NameNode 和 DataNode 的通信。方法，该方法检查 NameNode 是否已启动，并调用。类，实现了具体的 HDFS 文件系统操作。DFSOutputStream.java 的。FSOutputSummer.java的。类提供了创建文件的基本接口。方法创建一个新的输出流实例，并启动。
hadoop (1.0.4) Path 详解
ifromearth的专栏
04-21 1719
Path    对路径进行解析，将参数转换为标准的URI格式，对Path的参数作判断，标准化，字符化等操作。为了便于理解Path， 各位可以先参看URI的详解，链接http://www.cnblogs.com/springside5/archive/2012/05/06/2486245.html import java.net.*; import java.io.*; im
hadoop 之 PathFilter -- 输入文件过滤器
Andrew的成长之路
11-04 1457
1.指定多个输入在单个操作中处理一批文件，这是很常见的需求。比如说处理日志的MapReduce作业可能需要分析一个月内包含在大量目录中的日志文件。在一个表达式中使用通配符在匹配多个文件时比较方便的，无需列举每个文件和目录来指定输入。hadoop为执行通配提供了两个FileSystem方法：public FileStatus[] globStatus(Path pathPattern) throw I
Hadoop配置PATH环境变量
qjk19940101的博客
04-24 1万+
Hadoop配置PATH环境变量在这里额外讲一下PATH这个环境变量，通过执行echo $PATH查看上面的教程中都是先进入到/usr/local/hadoop目录中，再执行sbin/hadoop，实际上等同于运行/usr/local/hadoop/sbin/hadoop。可以将hadoop命令的相关目录加入到PATH环境变量中，这样就可以直接通过start-dfs.sh开启Hadoop，也可以直接
整理一下hadoop中，Path，FileSystem，FSDataInputStream
weixin_41967486的博客
05-09 1704
ex1
【spark床头书系列】Spark Sparkcontext原理用法示例源码详解
最新发布
wang2leee的博客
09-26 217
SparkContext是Spark应用程序与Spark集群交互的主要入口点。它负责管理与集群的连接，并提供执行任务、创建RDD（弹性分布式数据集）、广播变量和累加器等功能。以下是SparkContext的主要原理：初始化：当应用程序创建一个SparkContext对象时，它会初始化配置并设置与集群的连接。这包括创建与集群通信所需的网络通道、启动调度程序等。任务调度：SparkContext负责将应用程序中定义的任务划分为可执行的任务集，并将其发送到集群上的执行者进行处理。它使用任务调度程序（TaskSch
【spark床头书系列】Spark RDD原理方法示例源码详解
wang2leee的博客
09-22 96
Spark RDD（Resilient Distributed Datasets）最初由Matei Zaharia等人在UC Berkeley的AMPLab研究组开发，并于2010年首次在Spark项目中引入。在当时，大数据处理框架主要基于两种模型：分布式文件系统（如HDFS）和批量处理模型（如MapReduce）。然而，这些模型存在一些限制，例如高延迟、磁盘IO开销和无法适应交互式数据处理等问题。为了解决这些问题，Spark团队设计了RDD作为Spark的核心数据抽象。RDD提供了一种高效、易用且可扩展的
3.1.4 YARN资源调度、Apache Hadoop 核心源码剖析、调优、Hadoop二次开发
weixin_47134119的博客
01-27 1606
3.1.4 YARN资源调度、Apache Hadoop 核心源码剖析 文章目录3.1.4 YARN资源调度、Apache Hadoop 核心源码剖析七、YARN资源调度7.1 Yarn架构7.2 Yarn任务提交(工作机制)7.3 Yarn调度策略7.4Yarn多租户资源隔离配置八、Apache Hadoop 核心源码剖析8.1 源码阅读准备8.2 NameNode 启动流程 七、YARN资源调度 7.1 Yarn架构 ResourceManager(rm)：处理客户端请求、启动/监控Ap
hadoop2.2编译安装详解
03-19
export PATH=$PATH:$HADOOP_HOME/bin:$HADOOP_HOME/sbin source ~/.bashrc ``` 2. 启动Hadoop服务： ``` start-dfs.sh start-yarn.sh ``` 七、验证安装 1. 在浏览器中访问`http://localhost:50070`，如果能看到...
Hadoop的PathFilter使用
鲍礼彬的CSDN博客 ~_~
04-01 2390
Hadoop的PathFilter使用 源码接口定义： public interface PathFilter { /** * Tests whether or not the specified abstract pathname should be * included in a pathname list. * * @param path The ab
在Hadoop中，将Path对象转换为字符串输出
再见了，过去的名字，新的奋斗开始啦！
11-24 2481
Path对象转换为字符串的
Hadoop启动不了Namenode进程，出现IllegalArgumentException异常
weixin_34409357的博客
07-13 316
2019独角兽企业重金招聘Python工程师标准>>> ...
大数据——HDFS相关概念和常用命令
行秋的博客
08-13 465
hadoop fs -ls <path>:显示<path>指定的文件的详细信息 hadoop fs -mkdir <path>:创建<path>指定的文件夹 hadoop fs -cat <path>:将<path>指定的文件的内容输出到标准输出（stdout） hadoop fs -copyFromLocal <localsrc> <dst>:将本地源文件<localsrc>复制到路径<
Java API实现HDFS有关目录与文件的相关功能
热门推荐
行秋的博客
10-24 1万+
HDFS常用操作 JavaAPI实现HDFS以下功能。 1.在HDFS中创建一个新目录； 2.从本地拷贝文件到新创建的目录中； 3.将HDFS中指定文件的内容输出到终端中； 4.显示一个指定目录下所有文件； 5.完成指定目录下指定类型文件的合并 6.在HDFS中，将文件从源路径移动到目的路径。 7.删除HDFS中指定的文件； 实验环境：IDEA 项目如下： 代码如下： 1.在HDFS中创建一个新目录； import org....
Hadoop学习篇(二)——HDFS编程操作1
qq_17732621的博客
03-12 558
在前两篇文章中，我们已经介绍了HDFS的理论基础以及命令行的基本操作。 但是，在实际中我们使用HDFS的平台时，是不可能全部进行命令行操作的。一定是要与编程结合起来进行的。所以，本篇将介绍HDFS相关的一些编程操作。 上篇链接： Hadoop学习篇(二)——HDFS Hadoop学习篇(二)——HDFS实践操作 Hadoop学习篇(二)——HDFS编程操作1 说明：如涉及到侵权，请及时联系我，并在第一时间删除文章。 2.3 HDFS编程操作 HDFS有很多常用的Java API，这里我们用Java API模
003_HDFS详解
chaojixiaozhu的专栏
07-02 179
003_HDFS详解 其实应该先来教大家怎么样搭建完全分布式的，由于时间原因，以后再补上。 这篇主要聊一下Hadoop分布式文件系统——HDFS 大纲： 1.HDFS设计目标 2.HDFS里面的NameNode和DataNode 3.操作HDFS的两种方式 1.HDFS设计目标 硬件错误 硬件错误是常态而不是异常。（每每读这句我就想到了：程序员加班是常态不是异常）HDFS可能...
分布式文件系统HDFS
m0_62252825的博客
10-28 1005
分布式文件系统HDFS（二）
（超详细）HDFS常用命令及HDFS API基础编程
JunLeon的博客
10-28 9090
HDFS常用命令及基础编程 JunLeon——go big or go home 前言： ​ Hadoop 分布式文件系统 (HDFS) 是一种分布式文件系统，旨在运行在商品硬件上。它与现有的分布式文件系统有很多相似之处。但是与其他分布式文件系统的区别是显着的。HDFS 具有高度容错性，旨在部署在低成本硬件上。HDFS 提供对应用程序数据的高吞吐量访问，适用具有大型数据集的应用程序。HDFS 放宽了一些 POSIX 要求，以启用对文件系统数据的流式访问。HDFS 最初是作为 Apac...
深入解析Hadoop Common与HDFS源码详解
《Hadoop技术内幕》是一本深度剖析Hadoop核心技术和Hadoop分布式文件系统（HDFS）的专业书籍，由蔡斌和陈湘萍两位资深作者编写。本书旨在为Hadoop的开发者提供源代码级别的理解，以便进行优化、定制和扩展。书中详细...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

BigDataMLApplication

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值