使用Java API操作HDFS

素颜马尾好姑娘i 2024-03-30 09:02 49阅读 0赞

> 提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

#### 文章目录 ####

*  学习目标
 *  （一）了解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、删除目录或文件

--------------------

## 学习目标 ##

1.  了解HDFS Java API
2.  掌握使用Java API操作HDFS

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

--------------------

## （一）了解HDFS Java API ##

*  Hadoop文件系统API文档：[https://hadoop.apache.org/docs/stable/hadoop-project-dist/hadoop-common/filesystem/index.html][https_hadoop.apache.org_docs_stable_hadoop-project-dist_hadoop-common_filesystem_index.html]  
    ![在这里插入图片描述][a120e206f3ba4283b0b9d2d3d188e13c.png]

### 1、HDFS常见类与接口 ###

*  Hadoop整合了众多文件系统，HDFS只是这个文件系统的一个实例。  
    ![在这里插入图片描述][e8b0b440fa6744f4abb63ede63cc8648.png]

### 2、FileSystem的常用方法 ###

*  FileSystem类API文档：[https://hadoop.apache.org/docs/stable/hadoop-project-dist/hadoop-common/filesystem/filesystem.html][https_hadoop.apache.org_docs_stable_hadoop-project-dist_hadoop-common_filesystem_filesystem.html]  
    ![在这里插入图片描述][88f43ede552b42d0ab738d8cc7dfbbd7.png]
 *  FileSystem对象的一些方法可以对文件进行操作  
    ![在这里插入图片描述][f0f8390e3e7e474fb37e4f16a7ec9cde.png]

## （二）编写Java程序访问HDFS ##

### 1、创建Maven项目 ###

*  创建Maven项目 - HDFSDemo  
    ![在这里插入图片描述][38b72022383543f591b62eda14bb55ef.png]
 *  单击【Finish】按钮  
    ![在这里插入图片描述][12cd858e076b42a0908e457b6c22dadb.png]

### 2、添加相关依赖 ###

*  在pom.xml文件里添加hadoop和junit依赖  
    ![在这里插入图片描述][9c4d7be192bd45efa4277c6b40d9faac.png]

<dependencies>             
                               
        <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/][https_mvnrepository.com]
 *  ![在这里插入图片描述][b9efe2d59b4a4d31a9431fda89d36edc.png]
 *  搜索hadoop  
    ![在这里插入图片描述][5159e32309944ff286ed46a7681d51e0.png]
 *  单击hadoop-client超链接  
    ![在这里插入图片描述][f3ef07cf6ac1437da0a703e244fec2bb.png]
 *  单击3.3.4超链接  
    ![在这里插入图片描述][7ec7ff20142c4e79a792fab921a1dcea.png]

### 3、创建日志属性文件 ###

*  在resources目录里创建log4j.properties文件  
    ![在这里插入图片描述][9d57481528794438801c779763790152.png]

### 4、启动集群HDFS服务 ###

*  在主节点上执行命令：start-dfs.sh  
    ![在这里插入图片描述][9bbfdc8ee2b64687b242906948291c49.png]
 *  在Hadoop WebUI界面查看  
    ![在这里插入图片描述][8862f1b3fb1541939b4281c9a29e6e7c.png]

### 5、在HDFS上创建文件 ###

*  在HDFS Shell里利用hdfs dfs -touchz命令可以创建时间戳文件
 *  任务：在/ied01目录创建hadoop.txt文件
 *  创建net.hw.hdfs包，在包里创建CreateFileOnHDFS类  
    ![在这里插入图片描述][a757fcfc1fed41d18db1b3c0a4166407.png]
 *  编写create1()方法

package net.at.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;
    /**
     * 功能：在HDFS上创建文件
     * 作者：Argonaut
     * 日期：2022年11月30日
     */
    public class CreateFileOnHDFS {
        
        @Test
        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 + "]创建失败！");
            }
        }
    }

*  注意：别导错包  
    ![在这里插入图片描述][a1101c92f5f94df4801a7348539ff202.png]
 *  运行程序，查看结果  
    ![在这里插入图片描述][d6d18ba18db1417f824a316fa6bbfe23.png]
 *  利用Hadoop WebUI查看  
    ![在这里插入图片描述][f2394119209543d5a729e4b296250a8e.png]
 *  在/ied01目录里确实创建了一个0字节的hadoop.txt文件，有点类似于Hadoop Shell里执行hdfs dfs  
    \-touchz /ied01/hadoop.txt命令的效果，但是有一点不同，hdfs dfs -touchz命令重复执行，不会失败，只是不断改变该文件的时间戳。
 *  再次运行程序，由于hadoop.txt已经存在，此时会提示用户创建失败  
    ![在这里插入图片描述][923e5900826246058a8529f1cb2803bd.png]
 *  能否事先判断文件是否存在呢？我们去查看Hadoop FileSystem API文档  
    [https://hadoop.apache.org/docs/stable/hadoop-project-dist/hadoop-common/filesystem/filesystem.html][https_hadoop.apache.org_docs_stable_hadoop-project-dist_hadoop-common_filesystem_filesystem.html]  
    ![在这里插入图片描述][6304b3a7ae9b48418e39b36ea7a62e68.png]
 *  查看exists(Path path)方法  
    ![在这里插入图片描述][ab30f27d12aa4439b7cd23a945efcaa0.png]
 *  编写create2()方法，事先判断文件是否存在  
    ![在这里插入图片描述][5504ada2341b4774891512882ed173db.png]

@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 + "]创建失败！");                 
            }                                                                
        }                                                                    
    }

*  如果hadoop服务没有启动，运行程序会抛出连接异常  
    ![在这里插入图片描述][48bacad5b9fc42e699eb18697b40131a.png]
 *  故意让HDFS进入安全模式（只能读，不能写），看看会出现什么状况？
 *  删除已经创建的/ied01/hadoop.txt  
    ![在这里插入图片描述][af8b9598b61b46cc9bbef4f32b852930.png]
 *  执行命令：hdfs dfsadmin -safemode enter  
    ![在这里插入图片描述][585b363db5a946bf97db9c51b619ae9b.png]  
    此时，再运行程序，查看结果，抛出SafeModeException异常  
    ![在这里插入图片描述][d11dadd6471e4c5082c75716beed959c.png]
 *  下面，修改程序，来处理这个可能会抛出的安全模式异常

@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 {
                                                                     
            try {
                                                                    
                // 基于路径对象创建文件                                                
                boolean result = fs.createNewFile(path);                     
                // 根据返回值判断文件是否创建成功                                           
                if (result) {
                                                        
                    System.out.println("文件[" + path + "]创建成功！");             
                } else {
                                                             
                    System.out.println("文件[" + path + "]创建失败！");             
                }                                                            
            } catch (Exception e) {
                                                  
                System.err.println("异常信息：" + e.getMessage());                
            }                                                                
        }                                                                    
    }

*  运行程序，查看结果（虽然我们捕获了安全模式异常，但还是有一点系统抛出的异常信息）  
    ![在这里插入图片描述][2c45fb766cf647dab0ffcd5b998c9d16.png]
 *  关闭安全模式，执行命令：hdfs dfsadmin -safemode leave  
    ![在这里插入图片描述][1b5beccef13c4ae48ac79cf872eec3fc.png]
 *  再运行程序，查看效果  
    ![在这里插入图片描述][1fd96baede3f41e983559a4ed24304d0.png]

### 6、写入HDFS文件 ###

*  类似于HDFS Shell里的hdfs dfs -put命令
 *  在net.hw.hdfs包里创建WriteFileOnHDFS类  
    ![在这里插入图片描述][39938762deb849e38d2c9cab34f9ca78.png]  
    （1）将数据直接写入HDFS文件
 *  任务：在/ied01目录里创建hello.txt文件
 *  创建write1()方法

package net.at.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文件
     * 作者：Argonaut
     * 日期：2022年11月30日
     */
    public class WriteFileOnHDFS {
        
        @Test
        public void write1() 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/hello.txt");
            // 创建文件系统数据字节输出流（出水管：数据从程序到文件）
            FSDataOutputStream out = fs.create(path);
            // 通过字节输出流向文件写数据
            out.write("Hello Hadoop World".getBytes());
            // 关闭文件系统数据字节输出流
            out.close();
            // 关闭文件系统对象
            fs.close();
            // 提示用户写文件成功
            System.out.println("文件[" + path + "]写入成功！");
        }
    }

*  运行write1()测试方法，查看结果，抛出RemoteException异常，三个数据节点都在运行，但是无法写入数据  
    ![在这里插入图片描述][bdb3ec48e7114fd49afb2ae7ed1d0f52.png]
 *  修改代码，设置数据节点主机名属性，如下图所示  
    ![在这里插入图片描述][ae4bf4d3e2824207898db28ea6d4de7b.png]
 *  运行程序，查看结果  
    ![在这里插入图片描述][af1dffbfaac748ab95418f3ee4de6e8c.png]
 *  利用Hadoop WebUI查看hello.txt文件  
    ![在这里插入图片描述][a12a7f741de646cb901adb923df7fe51.png]  
    （2）将本地文件写入HDFS文件
 *  在项目根目录创建一个文本文件test.txt  
    ![在这里插入图片描述][e883c2ae2ec344a896fddaf40d36787a.png]
 *  创建write2()方法

@Test                                                                          
    public void write2() throws Exception {
                                                
        // 创建配置对象                                                                  
        Configuration conf = new Configuration();                                  
        // 设置数据节点主机名属性                                                             
        conf.set("dfs.client.use.datanode.hostname", "true");                      
        // 定义统一资源标识符（uri: uniform resource identifier）                             
        String uri = "hdfs://master:9000";                                         
        // 创建文件系统对象（基于HDFS的文件系统）                                                   
        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 + "\n").getBytes());                                        
        }                                                                          
        // 关闭缓冲字符输入流                                                               
        br.close();                                                                
        // 关闭文件字符输入流                                                               
        fr.close();                                                                
        // 关闭文件系统数据字节输出流                                                           
        out.close();                                                               
        // 提示用户写入文件成功                                                              
        System.out.println("本地文件[test.txt]成功写入[" + path + "]！");                   
    }

![在这里插入图片描述][bd2b9e8e29b242bbace2158541deacc2.png]

*  查看/ied01/exam.txt内容  
    ![在这里插入图片描述][a13c181dbb43454eb8108d2437903a60.png]
 *  其实这个方法的功能就是将本地文件复制（上传）到HDFS，有没有更简单的处理方法呢？有的，通过使用一个工具类IOUtils来完成文件的相关操作。  
    ![在这里插入图片描述][9499f8b62feb42238877339cce317181.png]
 *  编写write2\_()方法  
    ![在这里插入图片描述][e229a67305b74f5aad97b0fdeb094df0.png]

@Test                                                                  
    public void write2_() throws Exception {
                                       
        // 创建配置对象                                                          
        Configuration conf = new Configuration();                          
        // 设置数据节点主机名属性                                                     
        conf.set("dfs.client.use.datanode.hostname", "true");              
        // 定义统一资源标识符（uri: uniform resource identifier）                     
        String uri = "hdfs://master:9000";                                 
        // 创建文件系统对象（基于HDFS的文件系统）                                           
        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, System.out, 1024, false);                    
        // 利用IOUtils类提供的字节拷贝方法来复制文件                                        
        IOUtils.copyBytes(in, out, conf);                                  
        // 关闭文件字节输入流                                                       
        in.close();                                                        
        // 关闭文件系统数据字节输出流                                                   
        out.close();                                                       
        // 提示用户写入文件成功                                                      
        System.out.println("本地文件[test.txt]成功写入[" + path + "]！");           
    }

*  注意导包问题  
    ![在这里插入图片描述][2073fc1a189a49e18391abbb50890238.png]
 *  运行write2\_()测试方法，查看结果  
    ![在这里插入图片描述][6eb47ca837794c41b6a348ab7235d46e.png]
 *  查看/ied01/test.txt内容，文件是存在的，但是没有内容，怎么回事呢？  
    ![在这里插入图片描述][f7494a2a0852412bb22ce950667f6144.png]
 *  因为字节输入流的数据已经输出到到控制台，此时字节输入流里已经没有数据，此时执行IOUtils.copyBytes(in, out,  
    conf);，因此输出流肯定也没有数据可以写入文件，那该怎么办呢？再次读取文件，让字节输入流有数据。  
    ![在这里插入图片描述][5feb5ce726674f6c89f2f22c2cd052e8.png]
 *  查看/ied01/test.txt文件  
    ![在这里插入图片描述][1bf4cbfb6e064c16a0a65dda4bf58c47.png]

### 7、读取HDFS文件 ###

*  相当于Shell里的两个命令：hdfs dfs -cat和hdfs dfs -get
 *  在net.hw.hdfs包里创建ReadFileOnHDFS类  
    ![在这里插入图片描述][ee9eb2a49ac94bc0949962464bc38469.png]  
    （1）读取HDFS文件直接在控制台显示
 *  准备读取hdfs://master:9000/ied01/test.txt文件  
    ![在这里插入图片描述][8d122f76e9784673ab9a3099d63631d3.png]
 *  编写read1()方法  
    ![在这里插入图片描述][b4ad1dfc81d84ce8a9c79b6b9fa52010.png]

package net.at.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文件
     * 作者：Argonaut
     * 日期：2022年11月30日
     */
    public class ReadFileOnHDFS {
        
        @Test
        public void read1() throws Exception {
        
            // 创建配置对象
            Configuration conf = new Configuration();
            // 设置数据节点主机名属性
            conf.set("dfs.client.use.datanode.hostname", "true");
            // 定义统一资源标识符（uri: uniform resource identifier）
            String uri = "hdfs://master:9000";
            // 创建文件系统对象（基于HDFS的文件系统）
            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()测试方法，查看结果  
    ![在这里插入图片描述][bce75b605db8438692b838a86f7b0aa5.png]  
    （2）读取HDFS文件，保存为本地文件
 *  任务：将/ied01/test.txt下载到项目的download目录里
 *  创建download目录  
    ![在这里插入图片描述][a253d34bf6ea4ad4ac58b641859c0634.png]
 *  创建read2()方法  
    ![在这里插入图片描述][1a0781484a4a4856bdd36e19dad5a6aa.png]

@Test                                                                           
    public void read2() throws Exception {
                                                  
        // 创建配置对象                                                                   
        Configuration conf = new Configuration();                                   
        // 设置数据节点主机名属性                                                              
        conf.set("dfs.client.use.datanode.hostname", "true");                       
        // 定义统一资源标识符（uri: uniform resource identifier）                              
        String uri = "hdfs://master:9000";                                          
        // 创建文件系统对象（基于HDFS的文件系统）                                                    
        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");           
        // 利用IOUtils工具类读取HDFS文件（靠输入流），写入本地文件（靠输出流）                                  
        IOUtils.copyBytes(in, out, conf);                                           
        // 关闭文件字节输出流                                                                
        out.close();                                                                
        // 关闭文件系统数据字节流输入流                                                           
        in.close();                                                                 
        // 关闭文件系统                                                                   
        fs.close();                                                                 
        // 提示用户文件下载成功                                                               
        System.out.println("文件[" + path + "]下载到本地文件[download/exam.txt]！");          
    }

*  运行read2()测试方法，查看结果  
    ![在这里插入图片描述][5ba1061e6ab84c60948481ec3a343a17.png]

### 8、重命名目录或文件 ###

*  相当于Shell里的hdfs dfs -mv命令
 *  在net.hw.hdfs包里创建RenameDirOrFile类  
    ![在这里插入图片描述][886020c4d3f0430ca78079eb91348813.png]  
    （1）重命名目录
 *  任务：将/ied01目录更名为/lzy01
 *  编写renameDir()方法  
    ![在这里插入图片描述][551a9b403b614053b768c948b2363e26.png]
 *  运行renameDir()方法，查看结果

![在这里插入图片描述][29a9ce3bccbd4c56ac29850f46fcdeae.png]

*  利用Hadoop WebUI界面查看  
    ![在这里插入图片描述][86ec638b69c8479b93620d3e349c0cb0.png]  
    （2）重命名文件
 *  任务：将lzy01目录下的hello.txt重命名为hi.txt  
    ![在这里插入图片描述][de75a6defd1641b281fe4cbd6a043a97.png]
 *  编写renameFile()方法  
    ![在这里插入图片描述][e6cb05134b27491095d30159db85e427.png]
 *  运行renameFile()测试方法，查看结果  
    ![在这里插入图片描述][86bda3c2fd7440e6a1021bac9704600d.png]  
    ![在这里插入图片描述][714768c322ff429c87b0f2d2464b4626.png]

### 9、显示文件列表 ###

*  在net.hw.hdfs包里创建ListHDFSFiles类  
    ![在这里插入图片描述][e0687aaa256f4c4b95915e6cef61b94f.png]  
    （1）显示指定目录下文件全部信息
 *  任务：显示/lzy01目录下的文件列表  
    ![在这里插入图片描述][0ecbb7f624ea4b918f15db55ebec4405.png]
 *  编写list1()方法

package net.at.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;
    
    /**
     * 功能：显示文件列表
     * 作者：Argonaut
     * 日期：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());
            }
        }
    }

*  文件系统对象的listFiles()方法第二个参数设置true，这样可以将/lzy01目录的一切文件，包括子目录里的文件，都一网打尽
 *  运行list1()测试方法，查看结果  
    ![在这里插入图片描述][d5ed48a4c2c5415587defc25bf207e94.png]
 *  上述文件状态对象封装的有关信息，可以通过相应的方法来获取，比如getPath()方法就可以获取路径信息，getLen()方法就可以获取文件长度信息……

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

*  编写list2()方法  
    ![在这里插入图片描述][98a5759ef2bc40309b27420e3d1e6e8c.png]  
    ![在这里插入图片描述][08e3132716124308b4da6a3439dea2cf.png]

### 10、获取文件块信息 ###

*  任务：获取/lzy01/hadoop-3.3.4.tar.gz文件块信息  
    ![在这里插入图片描述][1fe1dcf885f7499a8435f7489b1b109f.png]
 *  hadoop压缩包会分割成6个文件块  
    ![在这里插入图片描述][39d10cf20c594c2585812225489e8003.png]
 *  在net.hw.hdfs包里创建GetBlockLocations类  
    ![在这里插入图片描述][0b777af8958844a39579a5a030996cc2.png]
 *  编写代码，获取文件块信息

package net.at.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;
    
    /**
     * 功能：获取文件块信息
     * 作者：Argonaut
     * 日期：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));
        }
    }

*  大家可以尝试用传统for循环、增强for循环或迭代器来遍历块信息

// 利用增强for循环遍历块信息                                                   
    for (BlockLocation blk : blks) {
                                          
        System.out.println(blk);                                      
    }    
                                                                 
    // 利用传统for循环遍历块信息                                                   
    for (int i = 0; i < blks.length; i++) {
                                   
        System.out.println(blks[i]);                                  
    }    
                                                                 
    // 利用迭代器遍历块信息                                                       
    Iterator<BlockLocation> iterator = Arrays.asList(blks).iterator();  
    while (iterator.hasNext()) {
                                                
         System.out.println(iterator.next());                            
    }

*  运行程序，查看结果（切点位置，块大小，块存在位置）  
    ![在这里插入图片描述][b2755c800d694d63aaf0a8283583dbcc.png]

### 11、创建目录 ###

*  任务：在HDFS上创建/ied01目录
 *  在net.hw.hdfs包里创建MakeDirOnHDFS类  
    ![在这里插入图片描述][3e83bca8f270443e97a4830740ba282d.png]

package net.at.hdfs;
    
    import org.apache.hadoop.conf.Configuration;
    import org.apache.hadoop.fs.FileSystem;
    import org.apache.hadoop.fs.Path;
    
    import java.net.URI;
    
    /**
     * 功能：在HDFS上创建目录
     * 作者：Argonaut
     * 日期：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 + "]创建失败！" );
            }
        }
    }

![在这里插入图片描述][aa551d74999a4d208ad9df0614e3602a.png]

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

*  任务：判断HDFS上/ied01目录是否存在，判断/ied01/hadoop.txt文件是否存在
 *  在net.hw.hdfs包里创建DirFileExistsOrNot类

package net.at.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;
    
    /**
     * 功能：判断目录或文件是否存在
     * 作者：Argonaut
     * 日期：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 + "]不存在！");
            }
        }
    }

![在这里插入图片描述][ef1b6620e5cd4b589c4632efedb1cb08.png]

*  编写fileExists()方法  
    ![在这里插入图片描述][63ee26c46f734813a03c69a15b4f3a3e.png]

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

*  在net.hw.hdfs包里创建PathToFileOrDir类  
    ![在这里插入图片描述][21179339a64b49e48b475333bc4cc122.png]

package net.at.hdfs;
    
    import org.apache.hadoop.conf.Configuration;
    import org.apache.hadoop.fs.FileSystem;
    import org.apache.hadoop.fs.Path;
    
    import java.net.URI;
    
    /**
     * 功能：判断路径指向目录还是文件
     * 作者：Argonaut
     * 日期：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("/ied08");
            if (fs.isDirectory(path1)) {
        
                System.out.println("[" + path1 + "]指向的是目录！");
            } else {
        
                System.out.println("[" + path1 + "]指向的是文件！");
            }
    
            // 创建路径对象，指向文件
            Path path2 = new Path("/lzy01/howard.txt");
            if (fs.isFile(path2)) {
        
                System.out.println("[" + path2 + "]指向的是文件！");
            } else {
        
                System.out.println("[" + path2 + "]指向的是目录！");
            }
        }
    }

![在这里插入图片描述][3fd02b264e1f4cc68ff97341a80aa135.png]

*  结果明显不对，说明程序逻辑上有问题，原因在于/ied08目录不存在，/lzy01/howard.txt文件不存在，修改代码，加上目录或文件存在与否的判断  
    ![在这里插入图片描述][cc6af55406134047bf3142d0f6ff1a81.png]  
    ![在这里插入图片描述][2f00a008fc2e4337b5745e3c002c816c.png]

### 14、删除目录或文件 ###

*  类似于HDFS Shell里的hdfs dfs -rmdir和hdfs dfs -rm -r命令
 *  在net.hw.hdfs包里创建DeleteFileOrDir类  
    （1）删除文件  
    任务：删除/lzy01/hi.txt文件  
    ![在这里插入图片描述][0ce87df9a8514e7cb28fbf874c2e2173.png]
 *  编写deleteFile()方法  
    ![在这里插入图片描述][61fef95b018e448381c8eca73b68d60d.png]

package net.at.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;
    
    /**
     * 功能：删除目录或文件
     * 作者：Argonaut
     * 日期：2022年12月02日
     */
    public class DeleteFileOrDir {
        
        @Test
        public void deleteFile() 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 + "/lzy01/hi.txt");
            // 删除路径对象指向的文件（第二个参数表明是否递归，删除文件，不用递归）
            boolean result = fs.delete(path, false);
            // 根据返回结果提示用户
            if (result) {
        
                System.out.println("文件[" + path + "]删除成功！");
            } else {
        
                System.out.println("文件[" + path + "]删除失败！");
            }
        }
    }

![在这里插入图片描述][e3275bf9e38d4677b383669e6195d28a.png]

*  再运行deleteFile()测试方法，查看结果  
    ![在这里插入图片描述][0afcebb2512c4f29b40651085ef693f9.png]
 *  可以在删除文件之前，判断文件是否存在，需要修改代码  
    ![在这里插入图片描述][4553d7b8974b45c396ee41afb0e11f78.png]  
    （2）删除目录
 *  任务：删除/lzy01目录
 *  编写deleteDir()方法

@Test                                                             
    public void deleteDir() 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 + "/lzy01");                         
        // 判断路径对象指向的目录否存在                                             
        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 + "]不存在！");               
        }                                                             
    }

![在这里插入图片描述][dfa1fd0f8b314685b7a3665c7ff0ca05.png]  
![在这里插入图片描述][154f8b803d094f2383e654791f0e5c80.png]  
（3）删除目录或文件

*  进行三个层面的判断：判断是否存在、判断类型（目录或文件）、判断删除是否成功
 *  任务：删除/ied02/exam.txt文件和/lzy01目录  
    ![在这里插入图片描述][f2710b7f9295427f94dfd33080326f59.png]
 *  编写delete()方法

@Test                                                                                                             
    public void delete() 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");                                                   
        // 定义随机对象                                                                                                     
        Random random = new Random();                                                                                 
        // 产生随机整数 - [0, 1]                                                                                            
        int choice = random.nextInt(100) % 2;                                                                         
        // 定义路径字符串                                                                                                    
        String[] strPath = {
        "/ied02/exam.txt", "/lzy01"};                                                             
        // 创建路径对象（指向目录或文件）                                                                                            
        Path path = new Path(uri + strPath[choice]);                                                                  
        // 判断存在性                                                                                                      
        if (fs.exists(path)) {
                                                                                                
            // 判断类型：目录或文件                                                                                             
            String type = "";                                                                                         
            if (fs.isDirectory(path)) {
                                                                                       
                type = "目录";                                                                                          
            } else {
                                                                                                          
                type = "文件";                                                                                          
            }                                                                                                         
            // 删除路径对象指向的目录或文件                                                                                         
            boolean result = fs.delete(path, true);                                                                   
            // 判断删除是否成功                                                                                               
            if (result) {
                                                                                                     
                System.out.println(type + "[" + path + "]删除成功！");                                                     
            } else {
                                                                                                          
                System.out.println(type + "[" + path + "]删除失败！");                                                     
            }                                                                                                         
        } else {
                                                                                                              
            System.out.println("路径[" + path + "]不存在！");                                                               
        }                                                                                                             
    }

![在这里插入图片描述][44e65ef02c374770a8a848b2a8a436f2.png]

[https_hadoop.apache.org_docs_stable_hadoop-project-dist_hadoop-common_filesystem_index.html]: https://hadoop.apache.org/docs/stable/hadoop-project-dist/hadoop-common/filesystem/index.html
[a120e206f3ba4283b0b9d2d3d188e13c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/c75f003f28f2441792254b69a43f484a.png
[e8b0b440fa6744f4abb63ede63cc8648.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/6cdb26d522784c50a6f61af755f499bb.png
[https_hadoop.apache.org_docs_stable_hadoop-project-dist_hadoop-common_filesystem_filesystem.html]: https://hadoop.apache.org/docs/stable/hadoop-project-dist/hadoop-common/filesystem/filesystem.html
[88f43ede552b42d0ab738d8cc7dfbbd7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/ecacc61743174e038c8889c770ec1144.png
[f0f8390e3e7e474fb37e4f16a7ec9cde.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/45bfa6f61b6e425cb8acd673c4bebac6.png
[38b72022383543f591b62eda14bb55ef.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/0da762fceee0440883a4afd7cb144e74.png
[12cd858e076b42a0908e457b6c22dadb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/edfe3a9c68f04af898ac82f0c043e13a.png
[9c4d7be192bd45efa4277c6b40d9faac.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/739aa734e6ab43cfa2264d39f6b31a9c.png
[https_mvnrepository.com]: https://mvnrepository.com/
[b9efe2d59b4a4d31a9431fda89d36edc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/7965b3de5e7a4cb2bf11df5d0d6863e7.png
[5159e32309944ff286ed46a7681d51e0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/f918845adfed44ea849442a35d84b77b.png
[f3ef07cf6ac1437da0a703e244fec2bb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/6f68d2d466e048269295f61eebd2af01.png
[7ec7ff20142c4e79a792fab921a1dcea.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/e2ba35b59ea34b26a8865c008270fe1f.png
[9d57481528794438801c779763790152.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/7e572616427443b68d37b997adb964a4.png
[9bbfdc8ee2b64687b242906948291c49.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/7c4c265ef69f48f98d8e45b87e3fdc5c.png
[8862f1b3fb1541939b4281c9a29e6e7c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/50b8b19c54b24953b47c6515c771ba16.png
[a757fcfc1fed41d18db1b3c0a4166407.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/2bafd2deb64342d39bb5712e36eee6e7.png
[a1101c92f5f94df4801a7348539ff202.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/b1a1eba14013485c98e550c0ac152d8c.png
[d6d18ba18db1417f824a316fa6bbfe23.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/17679ba4b78a4c97bfacbfbe0a4d90ff.png
[f2394119209543d5a729e4b296250a8e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/58790a1d4c5140b082575d3027c88424.png
[923e5900826246058a8529f1cb2803bd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/d5114f40574048fd94eb19c0598133b8.png
[6304b3a7ae9b48418e39b36ea7a62e68.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/61ce09384a914444becc9ba8e01ac7cd.png
[ab30f27d12aa4439b7cd23a945efcaa0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/1a16f9cbf8dc46b69f9abd236aa62e8a.png
[5504ada2341b4774891512882ed173db.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/0af02696745c473490131f7c484d569f.png
[48bacad5b9fc42e699eb18697b40131a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/2cd550b29e1847b2a266ed8228be19ef.png
[af8b9598b61b46cc9bbef4f32b852930.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/a0dfae48e1f245b18a48d082f2f9132b.png
[585b363db5a946bf97db9c51b619ae9b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/653c0ea5ad0f4a82be2c068f0e7ec76b.png
[d11dadd6471e4c5082c75716beed959c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/523c1663136f4909b734f9c7d1b08a48.png
[2c45fb766cf647dab0ffcd5b998c9d16.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/f3c819d92ccb4f1eb3695cb9bddf0218.png
[1b5beccef13c4ae48ac79cf872eec3fc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/ca865d0e9bbe4f89a79a30430660cdc2.png
[1fd96baede3f41e983559a4ed24304d0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/c0b7b16173d54655a59002e8dc0814c3.png
[39938762deb849e38d2c9cab34f9ca78.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/77ff3261965a43c48901be6f268b2cc4.png
[bdb3ec48e7114fd49afb2ae7ed1d0f52.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/272f6937d27d42f6a4f5fbe6dedde384.png
[ae4bf4d3e2824207898db28ea6d4de7b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/87f314900247468aaaa9222ca745c33b.png
[af1dffbfaac748ab95418f3ee4de6e8c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/09fe9f32ec2442eab58a17c481c348b0.png
[a12a7f741de646cb901adb923df7fe51.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/ec195124b81140709f95bcff575b5a10.png
[e883c2ae2ec344a896fddaf40d36787a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/67b8b3ae91ae4f8da963b9bbd68fcb3d.png
[bd2b9e8e29b242bbace2158541deacc2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/3da64f9ffc5c42d897d0369839389668.png
[a13c181dbb43454eb8108d2437903a60.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/d68f790ccd9d4469b2a8477b691d4aae.png
[9499f8b62feb42238877339cce317181.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/822abe1f9fcd4fd99e513e1a99117b5c.png
[e229a67305b74f5aad97b0fdeb094df0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/9e23aa2fa558470b99aa8fe2a40b7015.png
[2073fc1a189a49e18391abbb50890238.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/d68b599f023c4d40b7b88a074230a2f4.png
[6eb47ca837794c41b6a348ab7235d46e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/baace0f4021b4b5d847043f3366a5989.png
[f7494a2a0852412bb22ce950667f6144.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/3eb5cf357b1346e5ba1884d5e162a95f.png
[5feb5ce726674f6c89f2f22c2cd052e8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/b16bc78f1c7643ba93617e3a7bb1e781.png
[1bf4cbfb6e064c16a0a65dda4bf58c47.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/3c63cc82f63c42d08322906c55f10efb.png
[ee9eb2a49ac94bc0949962464bc38469.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/a6db641e6d014c289c99fc14e432db55.png
[8d122f76e9784673ab9a3099d63631d3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/dbc698b4ef6b4bccb61bc7c95abc8977.png
[b4ad1dfc81d84ce8a9c79b6b9fa52010.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/829d5d13c6894aa68605660099d09e9a.png
[bce75b605db8438692b838a86f7b0aa5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/fc830ed12be04883a7aa161eb241fc9a.png
[a253d34bf6ea4ad4ac58b641859c0634.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/022a6b438c244b81a5b08df17104fe8b.png
[1a0781484a4a4856bdd36e19dad5a6aa.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/8fa00a3f756f4edabf1e2d534c7f103d.png
[5ba1061e6ab84c60948481ec3a343a17.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/1a41d0abe5214482814aabc5ed97710e.png
[886020c4d3f0430ca78079eb91348813.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/1f44a2cae01741528441a1095d07e3cc.png
[551a9b403b614053b768c948b2363e26.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/067bfda987064332892601ae779cc04a.png
[29a9ce3bccbd4c56ac29850f46fcdeae.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/fbe7a9cae01948e191f06109b2fd1f04.png
[86ec638b69c8479b93620d3e349c0cb0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/ed52d764525a48f1841e35df2bafa42c.png
[de75a6defd1641b281fe4cbd6a043a97.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/a8bee3d16810410b99a09c6cf2147c7f.png
[e6cb05134b27491095d30159db85e427.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/4e31bd4378484fde941caec9f7776e1b.png
[86bda3c2fd7440e6a1021bac9704600d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/636a344bb17746dfb1a8c79f33a94f1a.png
[714768c322ff429c87b0f2d2464b4626.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/e99125af67634930a1b8b8286f2f2bb8.png
[e0687aaa256f4c4b95915e6cef61b94f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/9b26dc75231243b8ac9180d0aa7e4046.png
[0ecbb7f624ea4b918f15db55ebec4405.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/b8ee71bae8d84514b37bd075990f5efd.png
[d5ed48a4c2c5415587defc25bf207e94.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/425c0603d65447d6a4a2b6fe47625e0e.png
[98a5759ef2bc40309b27420e3d1e6e8c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/a32f94ed1f4f4a708538d5efe633030a.png
[08e3132716124308b4da6a3439dea2cf.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/e83057ece81b47fba2b85b97520e3ce9.png
[1fe1dcf885f7499a8435f7489b1b109f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/2f6b37e299d848e39eed28991a126cb5.png
[39d10cf20c594c2585812225489e8003.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/118bd5ba876341ffa45fceb92bb25a28.png
[0b777af8958844a39579a5a030996cc2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/4b5e55b533c44ed6bd0a79e2b46e7b12.png
[b2755c800d694d63aaf0a8283583dbcc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/4ad5fbcbfd32474e929902af854cb406.png
[3e83bca8f270443e97a4830740ba282d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/1b7bb0219f204557831b74b2652fb6f2.png
[aa551d74999a4d208ad9df0614e3602a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/059a04b1af2948568ab96d59f920a684.png
[ef1b6620e5cd4b589c4632efedb1cb08.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/a7751c9552434c039a940e9b3d5fdcad.png
[63ee26c46f734813a03c69a15b4f3a3e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/eef116e9860a45d5bb21dd51b6b28258.png
[21179339a64b49e48b475333bc4cc122.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/546149caa6424ac2898368fb2fb3b955.png
[3fd02b264e1f4cc68ff97341a80aa135.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/9a74bec7708e4063b554cb73037cdca2.png
[cc6af55406134047bf3142d0f6ff1a81.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/a1818576103441c28e036da7aae13483.png
[2f00a008fc2e4337b5745e3c002c816c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/3d156d9511604540be240813a75caaad.png
[0ce87df9a8514e7cb28fbf874c2e2173.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/071bdb72795d4a059697a42eb4d22b16.png
[61fef95b018e448381c8eca73b68d60d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/f818043bd1b54563b8d2bd4e3605856c.png
[e3275bf9e38d4677b383669e6195d28a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/243e4894117c4c4b96f59f2c11e0f0cd.png
[0afcebb2512c4f29b40651085ef693f9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/132cdc2d04214edab9b4ad7b6e63010c.png
[4553d7b8974b45c396ee41afb0e11f78.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/1b159fdd78644a7b84d84528e2010c10.png
[dfa1fd0f8b314685b7a3665c7ff0ca05.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/b92dc55b96a944699dabfc04601b4e37.png
[154f8b803d094f2383e654791f0e5c80.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/1277d37a84714db4b204666685ccf4fa.png
[f2710b7f9295427f94dfd33080326f59.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/25615f2da1ba42b898778adccf62f3ae.png
[44e65ef02c374770a8a848b2a8a436f2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/aabc722411a44a948eb387a54747e975.png