devbox
很楠不爱3
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

大数据编程实验二：熟悉常用的HDFS操作_熟悉常用的hdfs操作。

作者：很楠不爱3 | 2024-04-20 15:14:18

赞

踩

熟悉常用的hdfs操作。

实验目的
1、理解HDFS在Hadoop体系结构中的角色
2、熟悉使用HDFS操作常用的Shell命令
3、熟悉HDFS操作常用的Java API

实验平台
1、操作系统：Windows
2、Hadoop版本：3.1.3
3、JDK版本：1.8
4、Java IDE：IDEA

实验步骤

前期：一定要先启动hadoop

  1.  cd /usr/local/hadoop
  2. ./sbin/start-dfs.sh

 1、编程实现以下功能，并利用Hadoop提供的Shell命令完成相同任务
1）向 HDFS 中上传任意文本文件，如果指定的文件在 HDFS 中已经存在，则由用户来指定是追加到原有文件末尾还是覆盖原有的文件；
Shell 命令
检查文件是否存在，可以使用如下命令:

  1. cd /usr/local/hadoop
  2. ./bin/hdfs dfs -test -e text.txt

 执行完上述命令不会输出结果，需要继续输入命令查看结果：

echo $?

 如果结果显示文件已经存在，则用户可以选择追加到原来文件末尾或者覆盖原来文件，
具体命令如下：

  1. cd /usr/local/hadoop
  2. ./bin/hdfs dfs -appendToFile local.txt text.txt #追加到原文件末尾
  3. ./bin/hdfs dfs -copyFromLocal -f local.txt text.txt #覆盖原来文件，第一种命令形式
  4. ./bin/hdfs dfs -cp -f file:///home/hadoop/local.txt text.txt#覆盖原来文件，第二种命令形式

 实际上，也可以不用上述方法，而是采用如下命令来实现：(注意要加上./bin/)

  1. if $(./bin/hdfs dfs -test -e text.txt);
  2. then $(./bin/hdfs dfs -appendToFile local.txt text.txt);
  3. else $(./bin/hdfs dfs -copyFromLocal -f local.txt text.txt);
  4. fi

上述代码可视为一行代码，在终端中输入第一行代码后，代码不会立即被执行，可以继续输入第 2 行代码和第 3 行代码，直到输入 fi 以后，上述代码才会真正执行。另外，上述代码中，直接使用了 hdfs 命令，而没有给出命令的路径，因为，这里假设已经配置了 PATH环境变量，把 hdfs 命令的路径“/usr/local/hadoop/bin”写入了 PATH 环境变量中。

采用idea来进行java代码编写

前期：先导JAR包


点击Project Structure......

 

 选择Libraries，以及中间的 +

 选择Java，开始跟据下方图片进行4个导包

(1)/usr/local/hadoop/share/hadoop/common

 

shift + ↓ 可以选中多个。

(2)/usr/local/hadoop/share/hadoop/common/lib

 lib下所有的JVR包

 （3)/usr/local/hadoop/share/hadoop/hdfs

 

 （4)/usr/local/hadoop/share/hadoop/hdfs/lib

lib下面的所有JVR包

 

 最终导入后： 

 

选择Apply，再OK

 项目结构目录：

 HDFSApi.java

  1. package HDFSApi;
  2. import org.apache.hadoop.conf.Configuration;
  3. import org.apache.hadoop.fs.*;
  4. import java.io.*;
  5. public class HDFSApi {
  6.     /**
  7.      * 判断路径是否存在
  8.      */
  9.     public static boolean test(Configuration conf, String path) throws IOException {
  10.         FileSystem fs = FileSystem.get(conf);
  11.         return fs.exists(new Path(path));
  12.     }
  13.     /**
  14.      * 复制文件到指定路径
  15.      * 若路径已存在，则进行覆盖
  16.      */
  17.     public static void copyFromLocalFile(Configuration conf, String localFilePath, String
  18.             remoteFilePath) throws IOException {
  19.         FileSystem fs = FileSystem.get(conf);
  20.         Path localPath = new Path(localFilePath);
  21.         Path remotePath = new Path(remoteFilePath);
  22.  /* fs.copyFromLocalFile 第一个参数表示是否删除源文件，第二个参数表示是否覆
  23. 盖 */
  24.         fs.copyFromLocalFile(false, true, localPath, remotePath);
  25.         fs.close();
  26.     }
  27.     /**
  28.      * 追加文件内容
  29.      */
  30.     public static void appendToFile(Configuration conf, String localFilePath, String
  31.             remoteFilePath) throws IOException {
  32.         FileSystem fs = FileSystem.get(conf);
  33.         Path remotePath = new Path(remoteFilePath);
  34.         /* 创建一个文件读入流 */
  35.         FileInputStream in = new FileInputStream(localFilePath);
  36.         /* 创建一个文件输出流，输出的内容将追加到文件末尾 */
  37.         FSDataOutputStream out = fs.append(remotePath);
  38.         /* 读写文件内容 */
  39.         byte[] data = new byte[1024];
  40.         int read = -1;
  41.         while ( (read = in.read(data)) > 0 ) {
  42.             out.write(data, 0, read);
  43.         }
  44.         out.close();
  45.         in.close();
  46.         fs.close();
  47.     }
  48.  
  49.     /**
  50.      * 主函数
  51.      */
  52.     public static void main(String[] args) {
  53.         Configuration conf = new Configuration();
  54.         conf.set("fs.default.name","hdfs://localhost:9000");
  55.         String localFilePath = "/home/hadoop/text.txt"; // 本地路径
  56.         String remoteFilePath = "/user/hadoop/text.txt"; // HDFS 路径
  57.         String choice = "append"; // 若文件存在则追加到文件末尾
  58. // String choice = "overwrite"; // 若文件存在则覆盖
  59.         try {
  60.             /* 判断文件是否存在 */
  61.             Boolean fileExists = false;
  62.             if (HDFSApi.test(conf, remoteFilePath)) {
  63.                 fileExists = true;
  64.                 System.out.println(remoteFilePath + " 已存在.");
  65.             } else {
  66.                 System.out.println(remoteFilePath + " 不存在.");
  67.             }
  68.             /* 进行处理 */
  69.             if ( !fileExists) { // 文件不存在，则上传
  70.                 HDFSApi.copyFromLocalFile(conf, localFilePath, remoteFilePath);
  71.                 System.out.println(localFilePath + " 已上传至 " + remoteFilePath);
  72.             } else if ( choice.equals("overwrite") ) { // 选择覆盖
  73.                 HDFSApi.copyFromLocalFile(conf, localFilePath, remoteFilePath);
  74.                 System.out.println(localFilePath + " 已覆盖 " + remoteFilePath);
  75.             } else if ( choice.equals("append") ) { // 选择追加
  76.                 HDFSApi.appendToFile(conf, localFilePath, remoteFilePath);
  77.                 System.out.println(localFilePath + " 已追加至 " + remoteFilePath);
  78.             }
  79.         } catch (Exception e) {
  80.             e.printStackTrace();
  81.         }
  82.     }
  83. }

log4j.properties

  1. log4j.rootLogger=info,consolePrint,errorFile,logFile
  2.  
  3. log4j.appender.consolePrint.Encoding = UTF-8
  4. log4j.appender.consolePrint = org.apache.log4j.ConsoleAppender
  5. log4j.appender.consolePrint.Target = System.out
  6. log4j.appender.consolePrint.layout = org.apache.log4j.PatternLayout
  7. log4j.appender.consolePrint.layout.ConversionPattern=%d %p [%c] - %m%n
  8.  
  9. log4j.appender.logFile.Encoding = UTF-8
  10. log4j.appender.logFile = org.apache.log4j.DailyRollingFileAppender
  11. log4j.appender.logFile.File = D:/eclipse/log4j_properties_runlog/WorldCount_demo_run.log
  12. log4j.appender.logFile.Append = true
  13. log4j.appender.logFile.Threshold = info
  14. log4j.appender.logFile.layout = org.apache.log4j.PatternLayout
  15. log4j.appender.logFile.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss}  [ %t:%r ] - [ %p ]  %m%n
  16.  
  17. log4j.appender.errorFile.Encoding = UTF-8
  18. log4j.appender.errorFile = org.apache.log4j.DailyRollingFileAppender
  19. log4j.appender.errorFile.File = D:/eclipse/log4j_properties_runlog/WorldCount_demo_error.log
  20. log4j.appender.errorFile.Append = true
  21. log4j.appender.errorFile.Threshold = ERROR
  22. log4j.appender.errorFile.layout = org.apache.log4j.PatternLayout
  23. log4j.appender.errorFile.layout.ConversionPattern =%-d{yyyy-MM-dd HH:mm:ss}  [ %t:%r ] - [ %p ]  %m%n

然后运行，

（可能出错）

 解决方法，弄一个text.txt文件，应该是在前面没有弄成功

 运行成功

（2） 从 HDFS 中下载指定文件，如果本地文件与要下载的文件名称相同，则自动对下
载的文件重命名； 
  1. if $(./bin/hdfs dfs -test -e file:///home/hadoop/text.txt);
  2. then $(./bin/hdfs dfs -copyToLocal text.txt ./text2.txt);
  3. else $(./bin/hdfs dfs -copyToLocal text.txt ./text.txt);
  4. fi

 Java代码（记得新建项目、再重新导包）

shiyan2.2

  1. package HDFSApi;
  2. import org.apache.hadoop.conf.Configuration;
  3. import org.apache.hadoop.fs.*;
  4. import java.io.*;
  5. public class HDFSApi {
  6.     /**
  7.      * 下载文件到本地
  8.      * 判断本地路径是否已存在，若已存在，则自动进行重命名
  9.      */
  10.     public static void copyToLocal(Configuration conf, String remoteFilePath, String
  11.             localFilePath) throws IOException {
  12.         FileSystem fs = FileSystem.get(conf);
  13.         Path remotePath = new Path(remoteFilePath);
  14.         File f = new File(localFilePath);
  15.         /* 如果文件名存在，自动重命名(在文件名后面加上 _0, _1 ...) */
  16.         if (f.exists()) {
  17.             System.out.println(localFilePath + " 已存在.");
  18.             Integer i = 0;
  19.             while (true) {
  20.                 f = new File(localFilePath + "_" + i.toString());
  21.                 if (!f.exists()) {
  22.                     localFilePath = localFilePath + "_" + i.toString();
  23.                     break;
  24.                 }
  25.             }
  26.             System.out.println("将重新命名为: " + localFilePath);
  27.         }
  28.  
  29.         // 下载文件到本地
  30.         Path localPath = new Path(localFilePath);
  31.         fs.copyToLocalFile(remotePath, localPath);
  32.         fs.close();
  33.     }
  34.  
  35.     /**
  36.      * 主函数
  37.      */
  38.     public static void main(String[] args) {
  39.         Configuration conf = new Configuration();
  40.         conf.set("fs.default.name","hdfs://localhost:9000");
  41.         String localFilePath = "/home/hadoop/text.txt"; // 本地路径
  42.         String remoteFilePath = "/user/hadoop/text.txt"; // HDFS 路径
  43.         try {
  44.             HDFSApi.copyToLocal(conf, remoteFilePath, localFilePath);
  45.             System.out.println("下载完成");
  46.         } catch (Exception e) {
  47.             e.printStackTrace();
  48.         }
  49.     }
  50. }

记得把之前的 log4j.properties弄进项目里（在上方有）

 

 运行成功

 （3） 将 HDFS 中指定文件的内容输出到终端中
shell命令

./bin/hdfs dfs -cat text.txt

shiyan2.3

  java命令

  1. package HDFSApi;
  2. import org.apache.hadoop.conf.Configuration;
  3. import org.apache.hadoop.fs.*;
  4. import java.io.*;
  5. public class HDFSApi {
  6.     /**
  7.      * 读取文件内容
  8.      */
  9.     public static void cat(Configuration conf, String remoteFilePath) throws IOException {
  10.         FileSystem fs = FileSystem.get(conf);
  11.         Path remotePath = new Path(remoteFilePath);
  12.         FSDataInputStream in = fs.open(remotePath);
  13.         BufferedReader d = new BufferedReader(new InputStreamReader(in));
  14.         String line = null;
  15.         while ( (line = d.readLine()) != null ) {
  16.             System.out.println(line);
  17.         }
  18.         d.close();
  19.         in.close();
  20.         fs.close();
  21.     }
  22.  
  23.     /**
  24.      * 主函数
  25.      */
  26.     public static void main(String[] args) {
  27.         Configuration conf = new Configuration();
  28.         conf.set("fs.default.name","hdfs://localhost:9000");
  29.         String remoteFilePath = "/user/hadoop/text.txt"; // HDFS 路径
  30.         try {
  31.             System.out.println("读取文件: " + remoteFilePath);
  32.             HDFSApi.cat(conf, remoteFilePath);
  33.             System.out.println("\n 读取完成");
  34.         } catch (Exception e) {
  35.             e.printStackTrace();
  36.         }
  37.     }
  38. }

 （4） 显示 HDFS 中指定的文件的读写权限、大小、创建时间、路径等信息；
shell命令

 ./bin/hdfs dfs -ls -h text.txt

（5） 给定 HDFS 中某一个目录，输出该目录下的所有文件的读写权限、大小、创建时
间、路径等信息，如果该文件是目录，则递归输出该目录下所有文件相关信息；
shell命令

  1. cd /usr/local/hadoop
  2. ./bin/hdfs dfs -ls -R -h /user/hadoop

（6） 提供一个 HDFS 内的文件的路径，对该文件进行创建和删除操作。如果文件所在
目录不存在，则自动创建目录；
shell命令

  1. if $(./bin/hdfs dfs -test -d dir1/dir2);
  2. then $(./bin/hdfs dfs -touchz dir1/dir2/filename);
  3. else $(./bin/hdfs dfs -mkdir -p dir1/dir2 && ./bin/hdfs dfs -touchz dir1/dir2/filename);
  4. fi
  5. ./bin/hdfs dfs -rm dir1/dir2/filename #删除文件

 shiyan2.6

 Java代码

  1. package HDFSApi;
  2.  
  3. import org.apache.hadoop.conf.Configuration;
  4. import org.apache.hadoop.fs.*;
  5. import java.io.*;
  6. public class HDFSApi {
  7.     /**
  8.      * 判断路径是否存在
  9.      */
  10.     public static boolean test(Configuration conf, String path) throws IOException {
  11.         FileSystem fs = FileSystem.get(conf);
  12.         return fs.exists(new Path(path));
  13.     }
  14.     /**
  15.      * 创建目录
  16.      */
  17.     public static boolean mkdir(Configuration conf, String remoteDir) throws IOException {
  18.         FileSystem fs = FileSystem.get(conf);
  19.         Path dirPath = new Path(remoteDir);
  20.         boolean result = fs.mkdirs(dirPath);
  21.         fs.close();
  22.         return result;
  23.     }
  24.     /**
  25.      * 创建文件
  26.      */
  27.     public static void touchz(Configuration conf, String remoteFilePath) throws IOException {
  28.         FileSystem fs = FileSystem.get(conf);
  29.         Path remotePath = new Path(remoteFilePath);
  30.         FSDataOutputStream outputStream = fs.create(remotePath);
  31.         outputStream.close();
  32.         fs.close();
  33.     }
  34.  
  35.     /**
  36.      * 删除文件
  37.      */
  38.     public static boolean rm(Configuration conf, String remoteFilePath) throws IOException {
  39.         FileSystem fs = FileSystem.get(conf);
  40.         Path remotePath = new Path(remoteFilePath);
  41.         boolean result = fs.delete(remotePath, false);
  42.         fs.close();
  43.         return result;
  44.     }
  45.     /**
  46.      * 主函数
  47.      */
  48.     public static void main(String[] args) {
  49.         Configuration conf = new Configuration();
  50.         conf.set("fs.default.name","hdfs://localhost:9000");
  51.         String remoteFilePath = "/user/hadoop/input/text.txt"; // HDFS 路径
  52.         String remoteDir = "/user/hadoop/input"; // HDFS 路径对应的目录
  53.         try {
  54.             /* 判断路径是否存在，存在则删除，否则进行创建 */
  55.             if ( HDFSApi.test(conf, remoteFilePath) ) {
  56.                 HDFSApi.rm(conf, remoteFilePath); // 删除
  57.                 System.out.println("删除路径: " + remoteFilePath);
  58.             } else {
  59.                 if ( !HDFSApi.test(conf, remoteDir) ) { // 若目录不存在，则进行创建
  60.                     HDFSApi.mkdir(conf, remoteDir);
  61.                     System.out.println("创建文件夹: " + remoteDir);
  62.                 }
  63.                 HDFSApi.touchz(conf, remoteFilePath);
  64.                 System.out.println("创建路径: " + remoteFilePath);
  65.             }
  66.         } catch (Exception e) {
  67.             e.printStackTrace();
  68.         }
  69.     }
  70. }

 （7） 提供一个 HDFS 的目录的路径，对该目录进行创建和删除操作。创建目录时，如
果目录文件所在目录不存在，则自动创建相应目录；删除目录时，由用户指定
当该目录不为空时是否还删除该目录；
shell命令
创建目录的命令如下：

 ./bin/hdfs dfs -mkdir -p dir1/dir2

删除目录的命令如下：

./bin/hdfs dfs -rmdir dir1/dir2

上述命令执行以后，如果目录非空，则会提示 not empty，删除操作不会执行。如果要
强制删除目录，可以使用如下命令：

./bin/hdfs dfs -rm -R dir1/dir2

 shiyan2.7

java代码

  1. package HDFSApi;
  2.  
  3. import org.apache.hadoop.conf.Configuration;
  4. import org.apache.hadoop.fs.*;
  5. import java.io.*;
  6. public class HDFSApi {
  7.     /**
  8.      * 判断路径是否存在
  9.      */
  10.     public static boolean test(Configuration conf, String path) throws IOException {
  11.         FileSystem fs = FileSystem.get(conf);
  12.         return fs.exists(new Path(path));
  13.     }
  14.     /**
  15.      * 判断目录是否为空
  16.      * true: 空，false: 非空
  17.      */
  18.     public static boolean isDirEmpty(Configuration conf, String remoteDir) throws IOException {
  19.         FileSystem fs = FileSystem.get(conf);
  20.         Path dirPath = new Path(remoteDir);
  21.         RemoteIterator<LocatedFileStatus> remoteIterator = fs.listFiles(dirPath, true);
  22.         return !remoteIterator.hasNext();
  23.     }
  24.     /**
  25.      * 创建目录
  26.      */
  27.     public static boolean mkdir(Configuration conf, String remoteDir) throws IOException {
  28.         FileSystem fs = FileSystem.get(conf);
  29.         Path dirPath = new Path(remoteDir);
  30.         boolean result = fs.mkdirs(dirPath);
  31.         fs.close();
  32.         return result;
  33.     }
  34.  
  35.     /**
  36.      * 删除目录
  37.      */
  38.     public static boolean rmDir(Configuration conf, String remoteDir) throws IOException {
  39.         FileSystem fs = FileSystem.get(conf);
  40.         Path dirPath = new Path(remoteDir);
  41.         /* 第二个参数表示是否递归删除所有文件 */
  42.         boolean result = fs.delete(dirPath, true);
  43.         fs.close();
  44.         return result;
  45.     }
  46.     /**
  47.      * 主函数
  48.      */
  49.     public static void main(String[] args) {
  50.         Configuration conf = new Configuration();
  51.         conf.set("fs.default.name","hdfs://localhost:9000");
  52.         String remoteDir = "/user/hadoop/input"; // HDFS 目录
  53.         Boolean forceDelete = false; // 是否强制删除
  54.         try {
  55.             /* 判断目录是否存在，不存在则创建，存在则删除 */
  56.             if ( !HDFSApi.test(conf, remoteDir) ) {
  57.                 HDFSApi.mkdir(conf, remoteDir); // 创建目录
  58.                 System.out.println("创建目录: " + remoteDir);
  59.             } else {
  60.                 if ( HDFSApi.isDirEmpty(conf, remoteDir) || forceDelete ) { // 目录为空或强制删除
  61.                     HDFSApi.rmDir(conf, remoteDir);
  62.                     System.out.println("删除目录: " + remoteDir);
  63.                 } else { // 目录不为空
  64.                     System.out.println("目录不为空，不删除: " + remoteDir);
  65.                 }
  66.             }
  67.         } catch (Exception e) {
  68.             e.printStackTrace();
  69.         }
  70.     }
  71. }

 8） 向HDFS中指定的文件追加内容，由用户指定内容追加到原有文件的开头或结尾；
shell命令
追加到原文件末尾的命令如下

 ./bin/hdfs dfs -appendToFile local.txt text.txt

追加到原文件的开头，在 HDFS 中不存在与这种操作对应的命令，因此，无法使用一条
命令来完成。可以先移动到本地进行操作，再进行上传覆盖，具体命令如下： 

无此文件，则新建此文件

 

  1. ./bin/hdfs dfs -get text.txt
  2. cat text.txt >> local.txt
  3. ./bin/hdfs dfs -copyFromLocal -f local.txt text.txt

 

 继续·

 ./bin/hdfs dfs -appendToFile local.txt text.txt

 

 shiyan2.8

 java代码

  1. package HDFSApi;
  2.  
  3. import org.apache.hadoop.conf.Configuration;
  4. import org.apache.hadoop.fs.*;
  5. import java.io.*;
  6. public class HDFSApi {
  7.     /**
  8.      * 判断路径是否存在
  9.      */
  10.     public static boolean test(Configuration conf, String path) throws IOException {
  11.         FileSystem fs = FileSystem.get(conf);
  12.         return fs.exists(new Path(path));
  13.     }
  14.     /**
  15.      * 追加文本内容
  16.      */
  17.     public static void appendContentToFile(Configuration conf, String content, String
  18.             remoteFilePath) throws IOException {
  19.         FileSystem fs = FileSystem.get(conf);
  20.         Path remotePath = new Path(remoteFilePath);
  21.         /* 创建一个文件输出流，输出的内容将追加到文件末尾 */
  22.         FSDataOutputStream out = fs.append(remotePath);
  23.         out.write(content.getBytes());
  24.         out.close();
  25.         fs.close();
  26.     }
  27.     /**
  28.      * 追加文件内容
  29.      */
  30.     public static void appendToFile(Configuration conf, String localFilePath, String
  31.             remoteFilePath) throws IOException {
  32.         FileSystem fs = FileSystem.get(conf);
  33.         Path remotePath = new Path(remoteFilePath);
  34.         /* 创建一个文件读入流 */
  35.         FileInputStream in = new FileInputStream(localFilePath);
  36.         /* 创建一个文件输出流，输出的内容将追加到文件末尾 */
  37.         FSDataOutputStream out = fs.append(remotePath);
  38.         /* 读写文件内容 */
  39.         byte[] data = new byte[1024];
  40.         int read = -1;
  41.         while ( (read = in.read(data)) > 0 ) {
  42.             out.write(data, 0, read);
  43.         }
  44.         out.close();
  45.         in.close();
  46.         fs.close();
  47.     }
  48.     /**
  49.      * 移动文件到本地
  50.      * 移动后，删除源文件
  51.      */
  52.     public static void moveToLocalFile(Configuration conf, String remoteFilePath, String
  53.             localFilePath) throws IOException {
  54.         FileSystem fs = FileSystem.get(conf);
  55.         Path remotePath = new Path(remoteFilePath);
  56.         Path localPath = new Path(localFilePath);
  57.         fs.moveToLocalFile(remotePath, localPath);
  58.     }
  59.  
  60.     /**
  61.      * 创建文件
  62.      */
  63.     public static void touchz(Configuration conf, String remoteFilePath) throws IOException {
  64.  
  65.         FileSystem fs = FileSystem.get(conf);
  66.         Path remotePath = new Path(remoteFilePath);
  67.         FSDataOutputStream outputStream = fs.create(remotePath);
  68.         outputStream.close();
  69.         fs.close();
  70.     }
  71.  
  72.     /**
  73.      * 主函数
  74.      */
  75.     public static void main(String[] args) {
  76.         Configuration conf = new Configuration();
  77.         conf.set("fs.default.name","hdfs://localhost:9000");
  78.         String remoteFilePath = "/user/hadoop/text.txt"; // HDFS 文件
  79.         String content = "新追加的内容\n";
  80.         String choice = "after"; //追加到文件末尾
  81. // String choice = "before"; // 追加到文件开头
  82.         try {
  83.             /* 判断文件是否存在 */
  84.             if ( !HDFSApi.test(conf, remoteFilePath) ) {
  85.                 System.out.println("文件不存在: " + remoteFilePath);
  86.             } else {
  87.                 if ( choice.equals("after") ) { // 追加在文件末尾
  88.                     HDFSApi.appendContentToFile(conf, content, remoteFilePath);
  89.                     System.out.println("已追加内容到文件末尾" + remoteFilePath);
  90.                 } else if ( choice.equals("before") ) { // 追加到文件开头
  91.                     /* 没有相应的 api 可以直接操作，因此先把文件移动到本地*/
  92.                     /*创建一个新的 HDFS，再按顺序追加内容 */
  93.                     String localTmpPath = "/user/hadoop/tmp.txt";
  94. // 移动到本地
  95.                     HDFSApi.moveToLocalFile(conf, remoteFilePath, localTmpPath);
  96.                     // 创建一个新文件
  97.                     HDFSApi.touchz(conf, remoteFilePath);
  98.                     // 先写入新内容
  99.                     HDFSApi.appendContentToFile(conf, content, remoteFilePath);
  100.                     // 再写入原来内容
  101.                     HDFSApi.appendToFile(conf, localTmpPath, remoteFilePath);
  102.                     System.out.println("已追加内容到文件开头: " + remoteFilePath);
  103.                 }
  104.             }
  105.         } catch (Exception e) {
  106.             e.printStackTrace();
  107.         }
  108.     }
  109. }

 

 （9） 删除 HDFS 中指定的文件
shell命令

./bin/hdfs dfs -rm text.txt

 

  1. package HDFSApi;
  2.  
  3. import org.apache.hadoop.conf.Configuration;
  4. import org.apache.hadoop.fs.*;
  5. import java.io.*;
  6. public class HDFSApi {
  7.     /**
  8.      * 删除文件
  9.      */
  10.     public static boolean rm(Configuration conf, String remoteFilePath) throws IOException {
  11.  
  12.  
  13.  
  14.  
  15.  
  16.  
  17.  
  18.         FileSystem fs = FileSystem.get(conf);
  19.         Path remotePath = new Path(remoteFilePath);
  20.         boolean result = fs.delete(remotePath, false);
  21.         fs.close();
  22.         return result;
  23.     }
  24.     /**
  25.      * 主函数
  26.      */
  27.     public static void main(String[] args) {
  28.         Configuration conf = new Configuration();
  29.         conf.set("fs.default.name","hdfs://localhost:9000");
  30.         String remoteFilePath = "/user/hadoop/text.txt"; // HDFS 文件
  31.         try {
  32.             if ( HDFSApi.rm(conf, remoteFilePath) ) {
  33.                 System.out.println("文件删除: " + remoteFilePath);
  34.             } else {
  35.                 System.out.println("操作失败（文件不存在或删除失败）");
  36.             }
  37.         } catch (Exception e) {
  38.             e.printStackTrace();
  39.         }
  40.     }
  41. }

 （10） 在 HDFS 中，将文件从源路径移动到目的路径
shell命令

./bin/hdfs dfs -mv text.txt text2.txt

 

  1. package HDFSApi;
  2.  
  3. import org.apache.hadoop.conf.Configuration;
  4. import org.apache.hadoop.fs.*;
  5. import java.io.*;
  6. public class HDFSApi {
  7.     /**
  8.      * 移动文件
  9.      */
  10.     public static boolean mv(Configuration conf, String remoteFilePath, String
  11.             remoteToFilePath) throws IOException {
  12.         FileSystem fs = FileSystem.get(conf);
  13.         Path srcPath = new Path(remoteFilePath);
  14.         Path dstPath = new Path(remoteToFilePath);
  15.         boolean result = fs.rename(srcPath, dstPath);
  16.         fs.close();
  17.         return result;
  18.     }
  19.  
  20.     /**
  21.      * 主函数
  22.      */
  23.     public static void main(String[] args) {
  24.         Configuration conf = new Configuration();
  25.         conf.set("fs.default.name","hdfs://localhost:9000");
  26.         String remoteFilePath = "hdfs:///user/hadoop/text.txt"; // 源文件 HDFS 路径
  27.         String remoteToFilePath = "hdfs:///user/hadoop/new.txt"; // 目的 HDFS 路径
  28.         try {
  29.             if ( HDFSApi.mv(conf, remoteFilePath, remoteToFilePath) ) {
  30.                 System.out.println(" 将文件 " + remoteFilePath + " 移动到 " +
  31.                         remoteToFilePath);
  32.             } else {
  33.                 System.out.println("操作失败(源文件不存在或移动失败)");
  34.             }
  35.         } catch (Exception e) {
  36.             e.printStackTrace();
  37.         }
  38.     }
  39. }

 （二）编程实现一个类“MyFSDataInputStream”
该类继承“org.apache.hadoop.fs.FSDataInputStream”，要求如下：实现按行读取 HDFS 中指定文件的方法“readLine()”，如果读到文件末尾，则返回空，否则返回文件一行的文本。

在终端中先进入hadoop中，然后输入命令bin/hadoop dfsadmin -safemode leave使其离开安全模式
运行过程如图：

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/很楠不爱3/article/detail/457931
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号