文章目录

零、学习目标

了解HDFS Java API
掌握使用Java API操作HDFS

一、导入新课

上一节对HDFS的Shell操作进行了详细的讲解，而HDFS Shell本质上就是对Java API的应用。本节课将针对HDFS Java API操作进行详细讲解。

二、新课讲解

由于Hadoop是使用Java语言编写的，因此可以使用Java API操作Hadoop文件系统。HDFS Shell本质上就是对Java API的应用，通过编程的形式操作HDFS，其核心是使用HDFS提供的Java API构造一个访问客户端对象，然后通过客户端对象对HDFS上的文件进行操作（增、删、改、查）。

（一）了解

HDFS

Java API

Hadoop文件系统API文档：

Apache Hadoop 3.3.4 – The Hadoop FileSystem API Definition

1、HDFS常见类与接口

Hadoop整合了众多文件系统，HDFS只是这个文件系统的一个实例。

类或接口	功能描述
org.apache.hadoop.fs.FileSystem	一个通用文件系统的抽象基类，可被分布式文件系统继承。
org.apache.hadoop.fs.FileStatus	文件状态接口，用于向客户端展示系统中文件和目录的元数据。具体包括文件大小、块大小、副本信息、所有者、修改时间等，可通过FileSystem.listStatus()方法获得具体的实例对象。
org.apache.hadoop.fs.FileDataInputStream	文件输入流，用于读取Hadoop文件。
org.apache.hadoop.fs.FileDataOutputStream	文件输出流，用于写Hadoop文件。
org.apache.hadoop.fs.Configuration	访问配置项，所有配置项的值，如果在core-site.xml中有对应的配置，则以core-site.xml为准。
org.apache.hadoop.fs.Path	路径，用于表示Hadoop文件系统中的一个文件或一个目录的路径。
org.apache.hadoop.fs.PathFilter	路径过滤器接口，通过实现方法PathFilter.accept(Path path)来判断是否接收路径path表示的文件或目录。

2、FileSystem的常用方法

FileSystem类

API

文档：

Apache Hadoop 3.3.4 – class
FileSystem对象的一些方法可以对文件进行操作

方法名	功能描述
copyFromLocalFile(Path src, Path dst)	从本地磁盘复制文件到HDFS
copyToLocalFile(Path src, Path dst)	从HDFS复制文件到本地磁盘
mkdirs(Path f)	建立子目录
rename(Path src, Path dst)	重命名文件或文件夹
delete(Path f)	删除指定文件

（二）编写Java程序访问HDFS

1、创建Maven项目

创建Maven项目 – HDFSDemo
单击【Finish】按钮

2、添加相关依赖

在
pom.xml
文件里添加
hadoop
和
junit
依赖

<dependencies>             
    <!--hadoop客户端-->                       
    <dependency>                                  
        <groupId>org.apache.hadoop</groupId>      
        <artifactId>hadoop-client</artifactId>    
        <version>3.3.4</version>                  
    </dependency>     
    <!--单元测试框架-->                            
    <dependency>                                  
        <groupId>junit</groupId>                  
        <artifactId>junit</artifactId>            
        <version>4.13.2</version>                 
    </dependency>                                 
</dependencies>

Maven Repository（Maven仓库）-

https://mvnrepository.com/
搜索
hadoop
单击
hadoop-client
超链接
单击
3.3.4
超链接

3、创建日志属性文件

在
resources
目录里创建
log4j.properties
文件

log4j.rootLogger=stdout, logfile
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d %p [%c] - %m%n
log4j.appender.logfile=org.apache.log4j.FileAppender
log4j.appender.logfile.File=target/hdfs.log
log4j.appender.logfile.layout=org.apache.log4j.PatternLayout
log4j.appender.logfile.layout.ConversionPattern=%d %p [%c] - %m%n

4、启动集群HDFS服务

在主节点上执行命令：
start-dfs.sh
在Hadoop WebUI界面查看

5、在HDFS上创建文件

在HDFS Shell里利用
hdfs dfs -touchz
命令可以创建时间戳文件
任务

：在
/ied01
目录创建
hadoop.txt
文件
创建
net.hw.hdfs
包，在包里创建
CreateFileOnHDFS
类
编写
create1()
方法

package net.hw.hdfs;

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

import java.net.URI;

/**
 * 功能：在HDFS上创建文件
 * 作者：华卫
 * 日期：2022年11月25日
 */
public class CreateFileOnHDFS {
    public void create1() throws Exception {
        // 创建配置对象
        Configuration conf = new Configuration();
        // 定义统一资源标识符（uri：uniform resource identifier)
        String uri = "hdfs://master:9000";
        // 创建文件系统对象（基于HDFS的文件系统）
        FileSystem fs = FileSystem.get(new URI(uri), conf);
        // 创建路径对象
        Path path = new Path(uri + "/ied01/hadoop.txt");
        // 基于路径对象创建文件
        boolean result = fs.createNewFile(path);
        // 根据返回值判断文件是否创建成功
        if (result) {
            System.out.println("文件[" + path + "]创建成功！");
        } else {
            System.out.println("文件[" + path + "]创建失败！");
        }
    }
}

注意：导包千万不要导错了
运行程序，查看结果
利用HDFS集群WebUI查看
在
/ied01
目录里确实创建了一个
0
字节的
hadoop.txt
文件，有点类似于Hadoop Shell里执行
hdfs dfs -touchz /ied01/hadoop.txt
命令的效果，但是有一点不同，
hdfs dfs -touchz
命令重复执行，不会失败，只是不断改变该文件的时间戳。
再次运行程序，由于
hadoop.txt
已经存在，此时会提示用户创建失败
能否事先判断文件是否存在呢？我们去查看Hadoop FileSystem API文档

Apache Hadoop 3.3.4 – class
查看
exists(Path path)
方法
编写
create2()
方法，事先判断文件是否存在

@Test                                                                    
public void create2() throws Exception {                                 
    // 创建配置对象                                                            
    Configuration conf = new Configuration();                            
    // 定义统一资源标识符（uri：uniform resource identifier)                        
    String uri = "hdfs://master:9000";                                   
    // 创建文件系统对象（基于HDFS的文件系统）                                             
    FileSystem fs = FileSystem.get(new URI(uri), conf);                  
    // 创建路径对象                                                            
    Path path = new Path(uri + "/ied01/hadoop.txt");                     
    // 判断路径对象指向的文件是否存在                                                   
    if (fs.exists(path)) {                                               
        // 提示用户文件已存在                                                     
        System.out.println("文件[" + path + "]已经存在！");                     
    } else {                                                             
        // 基于路径对象创建文件                                                    
        boolean result = fs.createNewFile(path);                         
        // 根据返回值判断文件是否创建成功                                               
        if (result) {                                                    
            System.out.println("文件[" + path + "]创建成功！");                 
        } else {                                                         
            System.out.println("文件[" + path + "]创建失败！");                 
        }                                                                
    }                                                                    
}

运行程序，查看结果

此时，怎么才能出现文件创建失败的情况呢？我们故意让HDFS进入安全模式（只能读，不能写）
删除已经创建的
/ied01/hadoop.txt
执行命令：
hdfs dfsadmin -safemode enter
此时，再运行程序，查看结果，抛出
SafeModeException
异常
下面，修改程序，来处理这个可能会抛出的安全模式异常
运行程序，查看结果
关闭安全模式，执行命令：
hdfs dfsadmin -safemode leave
再运行程序，查看效果

6、写入HDFS文件

在
net.hw.hdfs
包里创建
WriteFileOnHDFS
类

（1）将数据直接写入HDFS文件

任务

：在
/ied01
目录里创建
hello.txt
文件
创建
write1()方法

package net.hw.hdfs;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FSDataOutputStream;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.junit.Test;

import java.net.URI;

/**
 * 功能：写入HDFS文件
 * 作者：华卫
 * 日期：2022年11月25日
 */
public class WriteFileOnHDFS {
    @Test
    public void write1() throws Exception {
        // 创建配置对象 
        Configuration conf = new Configuration();
        // 定义uri字符串
        String uri = "hdfs://master:9000";
        // 创建文件系统对象
        FileSystem fs = FileSystem.get(new URI(uri), conf);
        // 创建路径对象（指向目录或文件）
        Path path = new Path(uri + "/ied01/hello.txt");
        // 创建文件系统数据字节输出流
        FSDataOutputStream out = fs.create(path);
        // 通过字节输出流向文件写数据
        out.write("Hello Hadoop World".getBytes());
        // 关闭输出流
        out.close();
        // 关闭文件系统对象
        fs.close();
    }
}

正在上传…重新上传取消

运行
write1()
测试方法，查看结果，报错，没有数据节点可以写入数据
修改代码，如下图所示
运行程序，查看结果
利用Hadoop WebUI查看
hello.txt
文件

（2）将本地文件写入HDFS文件

在项目根目录创建一个文本文件
test.txt
创建
write2()
方法

@Test                                                                                  
public void write2() throws Exception {                                                
    // 创建配置对象                                                                          
    Configuration conf = new Configuration();                                          
    // 设置数据节点主机名属性                                                                     
    conf.set("dfs.client.use.datanode.hostname", "true");                              
    // 定义uri字符串                                                                        
    String uri = "hdfs://master:9000";                                                 
    // 创建文件系统对象                                                                        
    FileSystem fs = FileSystem.get(new URI(uri), conf, "root");                        
    // 创建路径对象（指向目录或文件）                                                                 
    Path path = new Path(uri + "/ied01/exam.txt");                                     
    // 创建文件系统数据字节输出流对象                                                                 
    FSDataOutputStream out = fs.create(path);                                          
    // 创建文件字符输入流对象                                                                     
    FileReader fr = new FileReader("test.txt");                                        
    // 创建缓冲字符输入流对象                                                                     
    BufferedReader br = new BufferedReader(fr);                                        
    // 定义行字符串                                                                          
    String nextLine = "";                                                              
    // 通过循环读取缓冲字符输入流                                                                   
    while ((nextLine = br.readLine()) != null) {                                       
        // 在控制台输出读取的行                                                                  
        System.out.println(nextLine);                                                  
        // 通过文件系统数据字节输出流对象写入指定文件                                                       
        out.write(nextLine.getBytes());                                                
    }                                                                                  
    // 关闭文件系统字节输出流                                                                     
    out.close();                                                                       
    // 关闭缓冲字符输入流                                                                       
    br.close();                                                                        
    // 关闭文件字符输入流                                                                       
    fr.close();                                                                        
    // 提示用户写入文件成功                                                                      
    System.out.println("本地文件[test.txt]成功写入[" + path + "]！");                           
}

运行
write2()
测试方法，查看结果
其实这个方法的功能就是将本地文件复制（上传）到HDFS，有没有更简单的处理方法呢？有的，通过使用一个工具类IOUtils来完成文件的相关操作。
编写
write2_()
方法

@Test                                                                   
public void write2_() throws Exception {                                 
    // 创建配置对象                                                           
    Configuration conf = new Configuration();                           
    // 设置数据节点主机名属性                                                      
    conf.set("dfs.client.use.datanode.hostname", "true");               
    // 定义uri字符串                                                         
    String uri = "hdfs://master:9000";                                  
    // 创建文件系统对象                                                         
    FileSystem fs = FileSystem.get(new URI(uri), conf, "root");         
    // 创建路径对象（指向目录或文件）                                                  
    Path path = new Path(uri + "/ied01/test.txt");                      
    // 创建文件系统数据字节输出流对象                                                  
    FSDataOutputStream out = fs.create(path);                           
    // 创建文件字节输入流对象                                                      
    FileInputStream in = new FileInputStream("test.txt");               
    // 利用IOUtils类提供的字节拷贝方法来复制文件                                         
    IOUtils.copyBytes(in, out, conf);                                   
    // 关闭文件字节输入流                                                        
    in.close();                                                         
    // 关闭文件系统数据字节输出流                                                    
    out.close();                                                        
    // 关闭文件系统                                                           
    fs.close();                                                         
    // 提示用户写入文件成功                                                       
    System.out.println("本地文件[test.txt]成功写入[" + path + "]！");            
}

注意导包问题
运行
write2_()
测试方法，查看结果
查看
/ied01/test.txt
内容

7、读取HDFS文件

相当于Shell里的两个命令：
hdfs dfs -cat
和
hdfs dfs -get
在
net.hw.hdfs
包里创建
ReadFileOnHDFS
类

（1）读取HDFS文件直接在控制台显示

准备读取
hdfs://master:9000/ied01/test.txt
文件
编写
read1()
方法

package net.hw.hdfs;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FSDataInputStream;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.junit.Test;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URI;

/**
 * 功能：读取HDFS文件
 * 作者：华卫
 * 日期：2022年11月26日
 */
public class ReadFileOnHDFS {
    @Test
    public void read1() throws Exception {
        // 创建配置对象
        Configuration conf = new Configuration();
        // 设置数据节点主机名属性
        conf.set("dfs.client.use.datanode.hostname", "true");
        // 定义uri字符串
        String uri = "hdfs://master:9000";
        // 创建文件系统对象
        FileSystem fs = FileSystem.get(new URI(uri), conf, "root");
        // 创建路径对象（指向目录或文件）
        Path path = new Path(uri + "/ied01/test.txt");
        // 创建文件系统数据字节输入流对象
        FSDataInputStream in = fs.open(path);
        // 创建缓冲字符输入流对象，提高读取效率（字节流-->字符流-->缓冲流）
        BufferedReader br = new BufferedReader(new InputStreamReader(in));
        // 定义行字符串
        String nextLine = "";
        // 通过循环读取缓冲字符输入流
        while ((nextLine = br.readLine()) != null) {
            // 在控制台输出读取的行内容
            System.out.println(nextLine);
        }
        // 关闭缓冲字符输入流
        br.close();
        // 关闭文件系统数据字节输入流
        in.close();
        // 关闭文件系统
        fs.close();
    }
}

运行
read1()
测试方法，查看结果
其实，我们可以使用
IOUtils
类来简化代码，创建
read1_()
测试方法
再运行
read1_()
测试方法，查看结果

（2）读取HDFS文件，保存为本地文件

任务

：将
/ied01/test.txt
下载到项目下
download
目录里
创建
download
目录
创建
read2()
方法

@Test                                                                    
public void read2() throws Exception {                                   
    // 创建配置对象                                                            
    Configuration conf = new Configuration();                            
    // 设置数据节点主机名属性                                                       
    conf.set("dfs.client.use.datanode.hostname", "true");                
    // 定义uri字符串                                                          
    String uri = "hdfs://master:9000";                                   
    // 创建文件系统对象                                                          
    FileSystem fs = FileSystem.get(new URI(uri), conf, "root");          
    // 创建路径对象（指向目录或文件）                                                   
    Path path = new Path(uri + "/ied01/test.txt");                       
    // 创建文件系统数据字节输入流对象                                                   
    FSDataInputStream in = fs.open(path);                                
    // 创建文件字节输出流                                                         
    FileOutputStream out = new FileOutputStream("download/exam.txt");    
    // 读取HDFS文件（靠输入流），写入本地文件（靠输出流）                                       
    IOUtils.copyBytes(in, out, conf);                                    
    // 关闭文件系统数据字节输入流                                                     
    in.close();                                                          
    // 关闭文件字节输出流                                                         
    out.close();                                                         
    // 关闭文件系统                                                            
    fs.close();       
    // 提示用户文件下载成功
    System.out.println("文件[" + path + "]下载到本地文件[download/exam.txt]！");                                                   
}

运行
read2()
测试方法，查看结果

8、重命名目录或文件

相当于Shell里的
hdfs dfs -mv
命令
在
net.hw.hdfs
包里创建
RenameDirOrFile
类

（1）重命名目录

任务

：将
/ied01
目录更名为
/lzy01
编写
renameDir()
方法

package net.hw.hdfs;

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

import java.net.URI;

/**
 * 功能：重命名目录或文件
 * 作者：华卫
 * 日期：2022年11月26日
 */
public class RenameDirOrFile {
    @Test
    public void renameDir() throws Exception {
        // 创建配置对象
        Configuration conf = new Configuration();
        // 设置数据节点主机名属性
        conf.set("dfs.client.use.datanode.hostname", "true");
        // 定义uri字符串
        String uri = "hdfs://master:9000";
        // 创建文件系统对象
        FileSystem fs = FileSystem.get(new URI(uri), conf, "root");
        // 创建源路径对象
        Path sourcePath = new Path("/ied01");
        // 创建目标路径对象
        Path targetPath = new Path("/lzy01");
        // 利用文件系统对象重命名目录
        fs.rename(sourcePath, targetPath);
        // 关闭文件系统
        fs.close();
        // 提示用户目录更名成功
        System.out.println("目录[" + sourcePath.getName() + "]更名为目录[" + targetPath.getName() + "]！");
    }
}

运行
renameDir()
方法，查看结果
利用Hadoop WebUI界面查看

（2）重命名文件

任务：将
lzy01
目录下的
hello.txt
重命名为
hi.txt
编写
renameFile()
方法

@Test                                                                                               
public void renameFile() throws Exception {                                                         
    // 创建配置对象                                                                                       
    Configuration conf = new Configuration();                                                       
    // 设置数据节点主机名属性                                                                                  
    conf.set("dfs.client.use.datanode.hostname", "true");                                           
    // 定义uri字符串                                                                                     
    String uri = "hdfs://master:9000";                                                              
    // 创建文件系统对象                                                                                     
    FileSystem fs = FileSystem.get(new URI(uri), conf, "root");                                     
    // 创建源路径对象（指向文件）                                                                                
    Path sourcePath = new Path("/lzy01/hello.txt");                                                 
    // 创建目标路径对象（指向文件）                                                                               
    Path targetPath = new Path("/lzy01/hi.txt");                                                    
    // 利用文件系统对象重命名文件                                                                                
    fs.rename(sourcePath, targetPath);                                                              
    // 关闭文件系统                                                                                       
    fs.close();                                                                                     
    // 提示用户文件更名成功                                                                                   
    System.out.println("文件[" + sourcePath.getName() + "]更名为文件[" + targetPath.getName() + "]！");     
}

运行
renameFile()
测试方法，查看结果
利用Hadoop WebUI界面查看

9、显示文件列表

在
net.hw.hdfs
包里创建
ListHDFSFiles
类

（1）显示指定目录下文件全部信息

任务

：显示
/lzy01
目录下的文件列表
编写
list1()
方法

package net.hw.hdfs;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.LocatedFileStatus;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.fs.RemoteIterator;
import org.junit.Test;

import java.net.URI;

/**
 * 功能：显示文件列表
 * 作者：华卫
 * 日期：2022年11月26日
 */
public class ListHDFSFiles {
    @Test
    public void list1() throws Exception {
        // 创建配置对象
        Configuration conf = new Configuration();
        // 设置数据节点主机名属性
        conf.set("dfs.client.use.datanode.hostname", "true");
        // 定义uri字符串
        String uri = "hdfs://master:9000";
        // 创建文件系统对象
        FileSystem fs = FileSystem.get(new URI(uri), conf, "root");
        // 创建远程迭代器对象，泛型是位置文件状态类（相当于`hdfs dfs -ls -R /lzy01`）
        RemoteIterator<LocatedFileStatus> ri = fs.listFiles(new Path("/lzy01"), true);
        // 遍历远程迭代器
        while (ri.hasNext()) {
            System.out.println(ri.next());
        }
    }
}

运行
list1()
测试方法，查看结果
上述文件状态对象封装的有关信息，可以通过相应的方法来获取，比如
getPath()
方法就可以获取路径信息，
getLen()
方法就可以获取文件长度信息……

（2）显示指定目录下文件路径和长度信息

编写
list2()
方法

@Test                                                                                                 
public void list2() throws Exception {                                                                
    // 创建配置对象                                                                                         
    Configuration conf = new Configuration();                                                         
    // 设置数据节点主机名属性                                                                                    
    conf.set("dfs.client.use.datanode.hostname", "true");                                             
    // 定义uri字符串                                                                                       
    String uri = "hdfs://master:9000";                                                                
    // 创建文件系统对象                                                                                       
    FileSystem fs = FileSystem.get(new URI(uri), conf, "root");                                       
    // 创建远程迭代器对象，泛型是位置文件状态类（相当于`hdfs dfs -ls -R /lzy01`）                                              
    RemoteIterator<LocatedFileStatus> ri = fs.listFiles(new Path("/lzy01"), true);                    
    // 遍历远程迭代器                                                                                        
    while (ri.hasNext()) {                                                                            
        LocatedFileStatus lfs = ri.next();                                                            
        System.out.println(lfs.getPath() + " " + lfs.getLen() + "字节");                                
    }                                                                                                 
}

运行
list2()
测试方法，查看结果
对照Hadoop WebUI上给出的文件长度信息

10、获取文件块信息

任务

：获取
/lzy01/hadoop-3.3.4.tar.gz
文件块信息
hadoop压缩包会分割成6个文件块
在
net.hw.hdfs
包里创建
GetBlockLocations
类
用到
getFileBlockLocations()
方法来获取物理切块信息

参数1：文件路径

参数2：起点

参数3：长度

编写代码，获取文件块信息

package net.hw.hdfs;

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

import java.net.URI;
import java.util.Arrays;

/**
 * 功能：获取文件块信息
 * 作者：华卫
 * 日期：2022年11月26日
 */
public class GetBlockLocations {
    public static void main(String[] args) throws Exception {
        // 创建配置对象
        Configuration conf = new Configuration();
        // 设置数据节点主机名属性
        conf.set("dfs.client.use.datanode.hostname", "true");
        // 定义uri字符串
        String uri = "hdfs://master:9000";
        // 创建文件系统对象
        FileSystem fs = FileSystem.get(new URI(uri), conf, "root");
        // 创建路径对象，指向文件
        Path path = new Path("/lzy01/hadoop-3.3.4.tar.gz");
        // 获取文件块信息
        BlockLocation[] blks = fs.getFileBlockLocations(path, 0, Integer.MAX_VALUE);
        // 利用Lambda表达式遍历块信息
        Arrays.asList(blks).forEach(blk -> System.out.println(blk));
    }
}

运行程序，查看结果（切点位置，块大小，块存在位置）
由此可见，
hadoop-3.3.4.tar.gz
被hadoop物理切分成
6
块，前
5
块长度均为
134217728
字节（
128
MB），第
6
块长度为
24369142
字节（
23.24
MB）。

11、创建目录

任务

：在HDFS上创建
/ied01
目录
在
net.hw.hdfs
包里创建
MakeDirOnHDFS
类

package net.hw.hdfs;

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

import java.net.URI;

/**
 * 功能：在HDFS上创建目录
 * 作者：华卫
 * 日期：2022年11月26日
 */
public class MakeDirOnHDFS {
    public static void main(String[] args) throws Exception {
        // 创建配置对象
        Configuration conf = new Configuration();
        // 设置数据节点主机名属性
        conf.set("dfs.client.use.datanode.hostname", "true");
        // 定义uri字符串
        String uri = "hdfs://master:9000";
        // 创建文件系统对象
        FileSystem fs = FileSystem.get(new URI(uri), conf, "root");
        // 创建路径对象，指向目录
        Path path = new Path("/ied01");
        // 利用文件系统创建指定目录
        boolean result = fs.mkdirs(path);
        // 判断目录是否创建成功
        if (result) {
            System.out.println("目录[" + path + "]创建成功！" );
        } else {
            System.out.println("目录[" + path + "]创建失败！" );
        }
    }
}

运行程序，查看结果
利用Hadoop WebUI界面查看

12、判断目录或文件是否存在

任务

：判断HDFS上
/ied01
目录是否存在，判断
/ied01/hadoop.txt
文件是否存在
在
net.hw.hdfs
包里创建
DirFileExistsOrNot
类
编写
dirExists()
方法

package net.hw.hdfs;

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

import java.net.URI;

/**
 * 功能：判断目录或文件是否存在
 * 作者：华卫
 * 日期：2022年11月26日
 */
public class DirFileExistsOrNot {
    @Test
    public void dirExists() throws Exception {
        // 创建配置对象
        Configuration conf = new Configuration();
        // 设置数据节点主机名属性
        conf.set("dfs.client.use.datanode.hostname", "true");
        // 定义uri字符串
        String uri = "hdfs://master:9000";
        // 创建文件系统对象
        FileSystem fs = FileSystem.get(new URI(uri), conf, "root");
        // 创建路径对象，指向目录
        Path path = new Path("/ied01");
        // 判断目录是否存在
        if (fs.exists(path)) {
            System.out.println("目录[" + path + "]存在！");
        } else {
            System.out.println("目录[" + path + "]不存在！");
        }
    }
}

运行程序，查看结果
修改代码，再测试

13、判断Path指向目录还是文件

在
net.hw.hdfs
包里创建
PathToFileOrDir
类

package net.hw.hdfs;

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

import java.net.URI;

/**
 * 功能：判断路径指向目录还是文件
 * 作者：华卫
 * 日期：2022年11月26日
 */
public class PathToFileOrDir {
    public static void main(String[] args) throws Exception {
        // 创建配置对象
        Configuration conf = new Configuration();
        // 设置数据节点主机名属性
        conf.set("dfs.client.use.datanode.hostname", "true");
        // 定义uri字符串
        String uri = "hdfs://master:9000";
        // 创建文件系统对象
        FileSystem fs = FileSystem.get(new URI(uri), conf, "root");

        // 创建路径对象，指向目录
        Path path1 = new Path("/ied01");
        if (fs.isDirectory(path1)) {
            System.out.println("[" + path1 + "]指向的是目录！");
        } else {
            System.out.println("[" + path1 + "]指向的是文件！");
        }

        // 创建路径对象，指向文件
        Path path2 = new Path("/lzy01/test.txt");
        if (fs.isFile(path2)) {
            System.out.println("[" + path2 + "]指向的是文件！");
        } else {
            System.out.println("[" + path2 + "]指向的是目录！");
        }
    }
}

运行程序，查看结果

14、删除目录或文件

在
net.hw.hdfs
包里创建
DeleteFileOrDir
类

（1）删除文件

任务：删除
/lzy01/test2.txt
文件
编写
deleteFile()
方法

package net.hw.hdfs;

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

import java.net.URI;

/**
 * 功能：删除文件或目录
 * 作者：华卫
 * 日期：2022年10月08日
 */
public class DeleteFileOrDir {
    @Test
    public void deleteFile() throws Exception {
        Configuration conf = new Configuration();
        String uri = "hdfs://master:9000";
        FileSystem fs = FileSystem.get(new URI(uri), conf);
        Path path = new Path("/lzy01/test2.txt");
        boolean result = fs.delete(path, true);
        if (result) {
            System.out.println("文件[" + path + "]删除成功！");
        } else {
            System.out.println("文件[" + path + "]删除失败！");
        }
    }
}

运行
deleteFile()
测试方法，查看结果
利用HDFS集群WebUI界面查看
再运行
deleteFile()
测试方法，查看结果
可以在删除文件之前，判断文件是否存在，需要修改代码

@Test                                                               
public void deleteFile() throws Exception {                         
    Configuration conf = new Configuration();                       
    String uri = "hdfs://master:9000";                              
    FileSystem fs = FileSystem.get(new URI(uri), conf);             
    Path path = new Path("/lzy01/test2.txt");                       
    if (fs.exists(path)) {                                          
        boolean result = fs.delete(path, true);                     
        if (result) {                                               
            System.out.println("文件[" + path + "]删除成功！");            
        } else {                                                    
            System.out.println("文件[" + path + "]删除失败！");            
        }                                                           
    } else {                                                        
        System.out.println("文件[" + path + "]不存在！");                 
    }                                                               
}

此时运行
deleteFile()
测试方法，查看结果

（2）删除目录

任务：删除
/ied01
目录
编写
deleteDir()
方法

@Test                                                               
public void deleteDir() throws Exception {                          
    Configuration conf = new Configuration();                       
    String uri = "hdfs://master:9000";                               
    FileSystem fs = FileSystem.get(new URI(uri), conf);             
    Path path = new Path("/ied01");                                
    if (fs.exists(path)) {                                          
        boolean result = fs.delete(path, true);                     
        if (result) {                                               
            System.out.println("目录[" + path + "]删除成功！");            
        } else {                                                    
            System.out.println("目录[" + path + "]删除失败！");            
        }                                                           
    } else {                                                        
        System.out.println("目录[" + path + "]不存在！");                 
    }                                                               
}

运行
deleteDir()
方法，查看结果
再运行
deleteDir()
方法，查看结果

（3）删除目录或文件

进行三个层面的判断：判断类型（目录或文件）、判断是否存在、判断删除是否成功。
任务：删除
/lzy01
目录下的
test1.txt
编写
delete()
方法

@Test                                                                               
public void delete() throws Exception {                                             
    Configuration conf = new Configuration();                                       
    String uri = "hdfs://master:9000";                                               
    FileSystem fs = FileSystem.get(new URI(uri), conf);                             
    Path path1 = new Path("/lzy01/test1.txt");                                       
    String type = "";                                                               
    if (fs.isFile(path1)) {                                                         
        type = "文件";                                                                
    } else {                                                                        
        type = "目录";                                                                
    }                                                                               
    if (fs.exists(path1)) {                                                         
        boolean result = fs.delete(path1, true);                                    
        if (result) {                                                               
            System.out.println(type + "[" + path1 + "]删除成功！");                      
        } else {                                                                    
            System.out.println(type + "[" + path1 + "]删除失败！");                      
        }                                                                           
    } else {                                                                        
        System.out.println(type + "[" + path1 + "]不存在！");                           
    }                                                                               
                                                                                    
    Path path2 = new Path("/lzy01");                                               
    if (fs.isFile(path1)) {                                                         
        type = "文件";                                                                
    } else {                                                                        
        type = "目录";                                                                
    }                                                                               
    if (fs.exists(path2)) {                                                         
        boolean result = fs.delete(path1, true);                                    
        if (result) {                                                               
            System.out.println(type + "[" + path2 + "]删除成功！");                      
        } else {                                                                    
            System.out.println(type + "[" + path2 + "]删除失败！");                      
        }                                                                           
    } else {                                                                        
        System.out.println(type + "[" + path2 + "]不存在！");                           
    }                                                                               
}

运行
delete()
测试方法，查看结果

三、归纳总结

回顾本节课所讲的内容，并通过提问的方式引导学生解答问题并给予指导。

四、上机操作

形式：单独完成
题目：使用Java API操作HDFS
要求：让学生自己按照步骤使用Java API操作HDFS，以此来巩固本节的学习内容。写一篇CSDN博客，记录操作过程。

原文链接：https://blog.csdn.net/m0_63560941/article/details/128085653

文章目录

零、学习目标

一、导入新课

二、新课讲解

（一）了解 HDFS Java API

1、HDFS常见类与接口

2、FileSystem的常用方法

（二）编写Java程序访问HDFS

1、创建Maven项目

2、添加相关依赖

3、创建日志属性文件

4、启动集群HDFS服务

5、在HDFS上创建文件

6、写入HDFS文件

7、读取HDFS文件

8、重命名目录或文件

9、显示文件列表

10、获取文件块信息

11、创建目录

12、判断目录或文件是否存在

13、判断Path指向目录还是文件

14、删除目录或文件

三、归纳总结

四、上机操作

你可能也喜欢

（一）了解

HDFS

Java API