使用IDEA工具通过Java API 访问HDFS

news2024/11/16 9:54:21

文章目录

  • 一，了解 HDFS Java API
    • （一）HDFS常见类与接口
    • （二）FileSystem的常用方法
  • 二，编写Java程序访问HDFS
    • 01 创建Maven项目
    • 02 添加相关依赖
    • 03 创建日志属性文件
      • （1）在resources目录里创建log4j.properties文件
    • 04 启动集群HDFS服务
    • 05 在HDFS上创建文件
      • （1）创建net.army.hdfs包
      • （2）在net.army.hdfs包里创建CreateFileOnHDFS类
      • （3）编写create1()方法
      • （4）编写create2()方法，事先判断文件是否存在
    • 06 写入HDFS文件
      • （1）在net.hw.hdfs包里创建WriteFileOnHDFS类
      • （2）将数据直接写入HDFS文件
      • （3）将本地文件写入HDFS文件
    • 07 读取HDFS文件
      • （1）在net.hw.hdfs包里创建ReadFileOnHDFS类
      • （2）读取HDFS文件直接在控制台显示
      • （3）读取HDFS文件，保存为本地文件
    • 08 重命名目录或文件
      • （1）在net.hw.hdfs包里创建RenameDirOrFile类
      • （2）重命名目录
      • （3）重命名文件
    • 09 显示文件列表
      • （1）在net.hw.hdfs包里创建ListHDFSFiles类
      • （2）显示指定目录下文件全部信息
      • （3）显示指定目录下文件路径和长度信息
    • 10 获取文件块信息
      • （1）在net.hw.hdfs包里创建GetBlockLocations类
      • （2）用getFileBlockLocations()方法来获取物理切块信息
      • （3）编写代码，获取文件块信息
    • 11 创建目录
      • （1）在net.hw.hdfs包里创建MakeDirOnHDFS类
      • （2）编写代码，创建目录
    • 12 判断目录或文件是否存在
      • （1）在net.hw.hdfs包里创建DirFileExistsOrNot类
      • （2）创建dirExists()方法
      • （3）创建fileExists()方法
    • 13 判断Path指向目录还是文件
      • （1）在net.hw.hdfs包里创建PathToFileOrDir类
      • （2）编写代码，进行判断
    • 14 删除目录或文件
      • （1）在net.hw.hdfs包里创建DeleteFileOrDir类
      • （2）删除文件
      • （3）删除目录
      • （4）删除目录或文件

一，了解 HDFS Java API

Hadoop文件系统API文档：https://hadoop.apache.org/docs/stable/hadoop-project-dist/hadoop-common/filesystem/index.html
在这里插入图片描述

（一）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)来判断

（二）FileSystem的常用方法

FileSystem类API文档：https://hadoop.apache.org/docs/stable/hadoop-project-dist/hadoop-common/filesystem/filesystem.html
在这里插入图片描述

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

01 创建Maven项目

创建名称为HDFSDemo的Maven项目
在这里插入图片描述
创建成功
在这里插入图片描述

02 添加相关依赖

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

1.在pox.xml文件中添加如下内容：

<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>

在这里插入图片描述

2.下载相关依赖到本地仓库
在这里插入图片描述3.查看下载好的依赖
在这里插入图片描述

03 创建日志属性文件

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

1.右击【resources】，选择【New】，单击【Resource Bundle】
在这里插入图片描述2.在弹出的对话框中输入log4j，按【ok】键，成功创建
在这里插入图片描述
3.向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

在这里插入图片描述

04 启动集群HDFS服务

在主节点输入命令：start-dfs.sh
在这里插入图片描述
在Hadoop WebUI界面查看
在这里插入图片描述

05 在HDFS上创建文件

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

（1）创建net.army.hdfs包

1.右击【java】，选择【New】，单击【Package】
在这里插入图片描述2.在弹出的对话框中输入：net.army.hdfs，按下回车键，创建成功
在这里插入图片描述

（2）在net.army.hdfs包里创建CreateFileOnHDFS类

1.右击【net.army.hdfs】包，选择【New】，单击【Java Class】
在这里插入图片描述2.在弹出的对话框中输入：CreateFileOnHDFS，按下回车键，创建成功
在这里插入图片描述

（3）编写create1()方法

create1()源码

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

注：导包不要导错了，请仔细对照

运行程序，查看结果
在这里插入图片描述在Hadoop WebUI查看
在这里插入图片描述

（4）编写create2()方法，事先判断文件是否存在

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

运行程序，查看结果
在这里插入图片描述

06 写入HDFS文件

注：类似于HDFS Shell里的hdfs dfs -put命令

（1）在net.hw.hdfs包里创建WriteFileOnHDFS类

1.右击【net.army.hdfs】包，选择【New】，单击【Java Class】
在这里插入图片描述
2.在弹出的对话框中输入：WriteFileOnHDFS，按下回车键，创建成功
在这里插入图片描述

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

创建write1()方法

write1()源码

@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异常，三个数据节点都在运行，但是无法写入数据
在这里插入图片描述修改代码，设置数据节点主机名属性，如下图所示
在这里插入图片描述运行程序，查看结果
在这里插入图片描述在Hadoop WebUI查看hello.txt文件
在这里插入图片描述

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

在项目根目录创建一个文本文件test.txt

1.右击【HDFSDemo】，选择【New】，单击【File】
在这里插入图片描述2.在弹出的对话框中输入test.txt，按下回车键，创建成功
在这里插入图片描述
3.向test.txt文件添加如下内容：

hello linux world
hello hadoop world
hello zookeeper world
hello hive world
hell hbase world

在这里插入图片描述

创建write2()方法

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 + "]！");                   
}

运行write2()测试方法，查看结果
在这里插入图片描述
查看/ied01/exam.txt内容，输入命令：hdfs dfs -cat /ied01/exam.txt
在这里插入图片描述

注：其实这个方法的功能就是将本地文件复制（上传）到HDFS，有没有更简单的处理方法呢？有的，通过使用一个工具类IOUtils来完成文件的相关操作。

创建write3()方法

write3()源码

@Test                                                                  
public void write3() 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 + "]！");           
}

运行write3()测试方法，查看结果
在这里插入图片描述

在webui界面查看创建的文件，大小为0B，说明没有成功写入，是怎么肥事呢？
在这里插入图片描述原来是因为字节输入流的数据已经输出到到控制台，此时字节输入流里已经没有数据，此时执行IOUtils.copyBytes(in, out, conf);，因此输出流肯定也没有数据可以写入文件，那该怎么办呢？

那当然是再次读取文件，让字节输入流有数据。
在这里插入图片描述运行write3()方法，查看结果
在这里插入图片描述
再到webui界面，查看/ied01/test.txt文件，数据成功写入了
在这里插入图片描述

07 读取HDFS文件

注：相当于Shell里的两个命令：hdfs dfs -cat和hdfs dfs -get

（1）在net.hw.hdfs包里创建ReadFileOnHDFS类

1.右击【net.army.hdfs】包，选择【New】，单击【Java Class】
在这里插入图片描述
2.在弹出的对话框中输入：ReadFileOnHDFS，按下回车键，创建成功
在这里插入图片描述

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

准备读取hdfs://master:9000/ied01/test.txt文件
在这里插入图片描述创建read1()方法

read1()源码

@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()测试方法，查看结果
在这里插入图片描述其实，我们可以使用IOUtils类来简化代码，创建read2()测试方法

read2()源码

@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);                      
    // 读取文件在控制台显示，显示完后关闭流                                      
    IOUtils.copyBytes(in, System.out, 1024, true);             
}

运行read2()测试方法，查看结果
在这里插入图片描述

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

任务：将/ied01/test.txt下载到项目的download目录里

创建download目录
右击【HDFSDemo】，选择【New】，单击【Directory】，在弹出的对话框中输入：download，按下回车键，创建成功
在这里插入图片描述在这里插入图片描述
在这里插入图片描述创建read3()方法

read()3源码

@Test                                                                           
public void read3() 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]！");          
}

运行read3()测试方法，查看结果
在这里插入图片描述

08 重命名目录或文件

注：相当于Shell里的hdfs dfs -mv命令

（1）在net.hw.hdfs包里创建RenameDirOrFile类

1.右击【net.army.hdfs】包，选择【New】，单击【Java Class】
在这里插入图片描述2.在弹出的对话框中输入：RenameDirOrFile，按下回车键，创建成功
在这里插入图片描述

（2）重命名目录

任务：将/ied01目录更名为/lzy01

编写renameDir()方法

renameDir()源码

@Test                                                                                               
public void renameDir() 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 sourcePath = new Path(uri + "/ied01");                                                     
    // 创建目标路径对象（指向目录）                                                                               
    Path destinationPath = new Path(uri + "/lzy01");                                                
    // 利用文件系统对象重命名目录                                                                                
    fs.rename(sourcePath, destinationPath);                                                         
    // 关闭文件系统                                                                                       
    fs.close();                                                                                     
    // 提示用户目录更名成功                                                                                   
    System.out.println("目录[" + sourcePath.getName() + "]更名为目录[" + destinationPath.getName() + "]！");
}

运行renameDir()方法，查看结果
在这里插入图片描述在Hadoop WebUI界面查看
在这里插入图片描述

（3）重命名文件

任务：将lzy01目录下的hello.txt重命名为hi.txt

创建renameFile()方法

renameFile()源码

@Test                                                                                                      
public void renameFile() 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 sourcePath = new Path(uri + "/lzy01/hello.txt");                                                  
    // 创建目标路径对象（指向文件）                                                                                      
    Path destinationPath = new Path(uri + "/lzy01/hi.txt");                                                
    // 利用文件系统对象重命名文件                                                                                       
    fs.rename(sourcePath, destinationPath);                                                                
    // 关闭文件系统                                                                                              
    fs.close();                                                                                            
    // 提示用户文件更名成功                                                                                          
    System.out.println("文件[" + sourcePath.getName() + "]更名为文件[" + destinationPath.getName() + "]！");       
}

运行renameFile()测试方法，查看结果
在这里插入图片描述在Hadoop WebUI界面查看
在这里插入图片描述

09 显示文件列表

（1）在net.hw.hdfs包里创建ListHDFSFiles类

1.右击【net.army.hdfs】包，选择【New】，单击【Java Class】
在这里插入图片描述
2.在弹出的对话框中输入：ListHDFSFiles，按下回车键，创建成功
在这里插入图片描述

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

任务：显示/lzy01目录下的文件列表

在这里插入图片描述创建list1()方法
在这里插入图片描述文件系统对象的listFiles()方法第二个参数设置true，这样可以将/lzy01目录的一切文件，包括子目录里的文件，都一网打尽

list1()源码

@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()方法就可以获取文件长度信息……

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

编写list2()方法
在这里插入图片描述

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/apache-hive-3.1.3-bin.tar.gz文件块信息

在这里插入图片描述
hive压缩包会分割成3个文件块
在这里插入图片描述

（1）在net.hw.hdfs包里创建GetBlockLocations类

1.右击【net.army.hdfs】包，选择【New】，单击【Java Class】
在这里插入图片描述
2.在弹出的对话框中输入：GetBlockLocations，按下回车键，创建成功
在这里插入图片描述

（2）用getFileBlockLocations()方法来获取物理切块信息

在这里插入图片描述

注：参数说明

  • Path p：文件路径
  • long start：起点
  • long len：长度

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

在这里插入图片描述

源码：

package net.army.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;
/**
 * 作者：Army
 * 日期：2022/12/12
 * 功能：获取文件块信息
 */

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/apache-hive-3.1.3-bin.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());                            
}

运行程序，查看结果（切点位置，块大小，块存在位置）
在这里插入图片描述
由此可见，apache-hive-3.1.3-bin.tar.gz被hive物理切分成3块，前2块长度均为134217728字节（128MB），第3块长度为58505211字节（55.80MB）。

11 创建目录

任务：在HDFS上创建/ied01目录

（1）在net.hw.hdfs包里创建MakeDirOnHDFS类

1.右击【net.army.hdfs】包，选择【New】，单击【Java Class】
在这里插入图片描述
2.在弹出的对话框中输入：MakeDirOnHDFS，按下回车键，创建成功
在这里插入图片描述

（2）编写代码，创建目录

源代码

package net.army.hdfs;

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

import java.net.URI;
/**
 * 作者：Army
 * 日期：2022/12/12
 * 功能：在HDFS上创建目录
 */

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文件是否存在

（1）在net.hw.hdfs包里创建DirFileExistsOrNot类

1.右击【net.army.hdfs】包，选择【New】，单击【Java Class】
在这里插入图片描述
2.在弹出的对话框中输入：DirFileExistsOrNot，按下回车键，创建成功
在这里插入图片描述

（2）创建dirExists()方法

在这里插入图片描述dirExists()源码

@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 + "]不存在！");            
    }                                                          
}

运行dirExists()方法，查看结果
在这里插入图片描述
修改代码，再测试
在这里插入图片描述在这里插入图片描述

（3）创建fileExists()方法

在这里插入图片描述fileExists()源码

@Test                                                                  
public void fileExists() 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/music.txt");                          
    // 判断文件是否存在                                                        
    if (fs.exists(path)) {                                             
        System.out.println("文件[" + path + "]存在！");                     
    } else {                                                           
        System.out.println("文件[" + path + "]不存在！");                    
    }                                                                  
}

运行fileExists()方法，查看结果
在这里插入图片描述

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

（1）在net.hw.hdfs包里创建PathToFileOrDir类

1.右击【net.army.hdfs】包，选择【New】，单击【Java Class】
在这里插入图片描述
2.在弹出的对话框中输入：PathToFileOrDir，按下回车键，创建成功
在这里插入图片描述

（2）编写代码，进行判断

PathToFileOrDir源码

package net.army.hdfs;

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

import java.net.URI;

/**
 * 作者：Army
 * 日期：2022/12/12
 * 功能：判断路径指向目录还是文件
 */

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 + "]指向的是目录！");
        }
    }
}

运行程序，查看结果
在这里插入图片描述结果明显不对，说明程序逻辑上有问题，原因在于/ied08目录不存在，/lzy01/howard.txt文件不存在，修改代码，加上目录或文件存在与否的判断
在这里插入图片描述运行程序，查看结果
在这里插入图片描述
修改代码，改成存在的目录和文件
在这里插入图片描述运行程序，查看结果
在这里插入图片描述

最终源码

package net.army.hdfs;

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

import java.net.URI;

/**
 * 作者：Army
 * 日期：2022/12/12
 * 功能：判断路径指向目录还是文件
 */

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.exists(path1)) {
            if (fs.isDirectory(path1)) {
                System.out.println("[" + path1 + "]指向的是目录！");
            } else {
                System.out.println("[" + path1 + "]指向的是文件！");
            }
        } else {
            System.out.println("路径[" + path1 + "]不存在！");
        }


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

14 删除目录或文件

注：类似于HDFS Shell里的hdfs dfs -rmdir和hdfs dfs -rm -r命令

（1）在net.hw.hdfs包里创建DeleteFileOrDir类

1.右击【net.army.hdfs】包，选择【New】，单击【Java Class】
在这里插入图片描述
2.在弹出的对话框中输入：DeleteFileOrDir，按下回车键，创建成功
在这里插入图片描述

（2）删除文件

任务：删除/lzy01/hi.txt文件

在这里插入图片描述创建deleteFile()方法
在这里插入图片描述deleteFile()源码

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

运行deleteFile()测试方法，查看结果
在这里插入图片描述在Hadoop WebUI界面查看，已经没有hi.txt文件了
在这里插入图片描述再运行deleteFile()测试方法，查看结果
在这里插入图片描述
我们可以设计在删除文件之前，判断文件是否存在，需要修改代码
在这里插入图片描述
源码

@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");               
    // 判断路径对象指向的文件是否存在                                         
    if (fs.exists(path)) {                                     
        // 删除路径对象指向的文件（第二个参数表明是否递归，删除文件，不用递归）                  
        boolean result = fs.delete(path, false);               
        // 根据返回结果提示用户                                          
        if (result) {                                          
            System.out.println("文件[" + path + "]删除成功！");       
        } else {                                               
            System.out.println("文件[" + path + "]删除失败！");       
        }                                                      
    } else {                                                   
        System.out.println("文件[" + path + "]不存在！");            
    }                                                          
}

再运行deleteFile()测试方法，查看结果
在这里插入图片描述

（3）删除目录

任务：删除/lzy01目录

编写deleteDir()方法
在这里插入图片描述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 + "]不存在！");               
    }                                                             
}

运行deleteDir()方法，查看结果
在这里插入图片描述再运行deleteDir()方法，查看结果
在这里插入图片描述

（4）删除目录或文件

注：进行三个层面的判断：判断是否存在、判断类型（目录或文件）、判断删除是否成功

任务：删除/ied02/read.txt文件和/lzy01目录

在这里插入图片描述编写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/read.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 + "]不存在！");             
    }                                                           
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/98404.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

变电站火灾检测项目（tf2）

变电站火灾检测项目（tf2）

目录 1. 项目背景 2. 项目研究数据集介绍&#xff08;变电站火灾检测图像数据集&#xff09; 3. 目标检测模型介绍&#xff08;SE改进的YOLOv4-tiny模型&#xff09; 4. 模型训练及测试 1. 项目背景 我们的日常生活与电力息息相关&#xff0c;变电站作为输配电系统的关键环…
阅读更多...
【设计模式】责任链模式

【设计模式】责任链模式

【设计模式】责任链模式 文章目录【设计模式】责任链模式一&#xff1a;责任链模式概述二&#xff1a;责任链模式结构三&#xff1a;责任链模式案例实现四&#xff1a;优缺点五&#xff1a;责任链模式实战一&#xff1a;责任链模式概述 在现实生活中&#xff0c;常常会出现这样…
阅读更多...
Jmeter(二十一)：jmeter导入和导出接口的处理

Jmeter(二十一)：jmeter导入和导出接口的处理

JMeter测试导入接口 利用Jmeter测试上传文件&#xff0c;首先可根据接口文档或者fiddler抓包分析文件上传的接口&#xff1b;如下图&#xff1a; 以下是我通过fiddler所截取的文件上传的接口 1、填写导入接口的信息 查看文件上传栏下的填写信息&#xff1a; 文件名称&#xf…
阅读更多...
【图像分割】多种阈值图像分割（带面板）【含GUI Matlab源码 733期】

【图像分割】多种阈值图像分割（带面板）【含GUI Matlab源码 733期】

⛄一、图像分割简介 理论知识参考&#xff1a;【基础教程】基于matlab图像处理图像分割【含Matlab源码 191期】 ⛄二、部分源代码 function varargout yuzhifenge(varargin) % YUZHIFENGE MATLAB code for yuzhifenge.fig % YUZHIFENGE, by itself, creates a new YUZHIFEN…
阅读更多...
【Redis】缓存问题

【Redis】缓存问题

用户数据一般都是存储在数据库中&#xff0c;数据库则落在磁盘上。而磁盘的I/O速度是计算机中最慢的硬件。 当用户的访问量在某一个时间段突然上升&#xff0c;数据库就很容易崩溃。为了避免用户直接访问数据库&#xff0c;所以会使用缓存数据库(Redis)作为缓冲层。 Redis 是内…
阅读更多...
DIY NAS服务器之OMV 5.6入坑指南（二）- 安装omv-extras插件

DIY NAS服务器之OMV 5.6入坑指南（二）- 安装omv-extras插件

DIY NAS服务器之OMV 5.6入坑指南&#xff08;一&#xff09;-openmediavalut 5.6安装 前面我们已经安装好了OMV5.6了。 接下来就是建设我们的OMV系统了。 首先第一步&#xff0c;我们开启社区插件omv-extras&#xff1a; 通过如下url把插件安装文件 下载到电脑本地&#xff0c…
阅读更多...
Mysql分布式锁（二）直接用一条sql语句来实现原子性

Mysql分布式锁（二）直接用一条sql语句来实现原子性

文章目录一、直接用更新的sql实现1. 场景描述2. 修改sqlStockMapperStockService3. 重新测试二、问题1. 锁范围问题&#xff1a;行级锁 表级锁2. 若逻辑太复杂&#xff0c;一个sql无法实现4. 无法监控库存变化前后的状态一、直接用更新的sql实现 1. 场景描述 之前的deduct()方…
阅读更多...
DevOps实战系列【第十三章】：流水线应用工具Blue Ocean使用

DevOps实战系列【第十三章】：流水线应用工具Blue Ocean使用

个人亲自录制全套DevOps系列实战教程 &#xff1a;手把手教你玩转DevOps全栈技术 BlueOcean图形化工具 可以通过插件的方式安装到jenkins&#xff0c;搜索“Blue Ocean”&#xff0c;安装后重启即可。 由于兼容问题&#xff0c;BlueOcean依赖的插件有些是失败的&#xff0c;我…
阅读更多...
实际生产中使用Oracle的小问题及解决方法记录：ORA-00911，ORA-12514，ORA-28547

实际生产中使用Oracle的小问题及解决方法记录：ORA-00911，ORA-12514，ORA-28547

背景 在上次安装并初步测试 Oracle 后Oracle 11g安装使用、备份恢复并与SpringBoot集成&#xff0c;在实际生产中使用 Oracle 时又遇到几个小问题&#xff1a; ORA-00911 &#xff0c; ORA-12514 &#xff0c; ORA-28547 。下面分别列出这几个问题的解决方法。 Note&#xff…
阅读更多...
DCBC路由模式配置端口映射

DCBC路由模式配置端口映射

DCBC路由模式配置端口映射 拓扑搭建 前提&#xff1a;使用DCBC、CS6200、两台PC机&#xff1a;一台用户配置IP另一台用于测试端口映射&#xff0c;外网环境使用192.168.19.0/24网段 网段划分 全网互通 1.DCBC对应工作模式配置 对应接口配置 配置静态路由两条&#xff0c;一条…
阅读更多...
ArcGIS And ENVI：如何进行植被指数的提取并制作成专题地图？

ArcGIS And ENVI：如何进行植被指数的提取并制作成专题地图？

目录 01 目的 02 操作步骤 2.1 在ENVI加载tm_860516.img文件 2.2 进行NDVI指数的计算 2.3 使用ArcGIS对NDVI植被指数提取图进行专题制作 2.3.1 加载NDVI植被指数提取图 2.3.2 对NDVI植被指数提取图进行重分类 2.3.3 布局视图下的NDVI植被指数的相关编辑 03 实验结果 01 目的 对…
阅读更多...
Iterated function

Iterated function

In mathematics, an iterated function is a function X → X (that is, a function from some set X to itself) which is obtained by composing another function f : X → X with itself a certain number of times. The process of repeatedly applying the same function…
阅读更多...
【数据结构与算法 - 数据结构基础】什么是数据结构？

【数据结构与算法 - 数据结构基础】什么是数据结构？

【数据结构与算法 - 数据结构基础】什么是数据结构&#xff1f; 文章目录【数据结构与算法 - 数据结构基础】什么是数据结构&#xff1f;1 数据结构包含的三个方面1.1 数据的逻辑结构1.1.1 线性结构数组【Array】链表【LinkedList】栈【Stack】队列【Queue】1.1.2 树结构【Tree…
阅读更多...
【生信】初探基因定位和全基因组关联分析

【生信】初探基因定位和全基因组关联分析

初探QTL和GWAS 文章目录初探QTL和GWAS实验目的实验内容实验题目第一题&#xff1a;玉米MAGIC群体的QTL分析第二题&#xff1a;TASSEL自带数据集的关联分析实验过程玉米MAGIC群体的QTL分析① 包含的数据② 绘制LOD曲线株高对应的QTLTASSEL自带数据集的关联分析TASSEL简介实际操作…
阅读更多...
Docker ( 一 ) 基本概念及安装

Docker ( 一 ) 基本概念及安装

1.Docker是什么&#xff1f; Docker 是一个开源的应用容器引擎, 可以简化理解实现应用与运行环境分离. Docker 其中包括&#xff0c;镜像、容器、仓库等概念&#xff0c;目的就是通过对应用组件的封装、分发、部署、运行等生命周期的管理&#xff0c;使用户的产品&#xff08…
阅读更多...
Android 进阶——性能优化之电量优化全攻略及实战小结（一）

Android 进阶——性能优化之电量优化全攻略及实战小结（一）

文章大纲引言一、偷懒至上的原则二、低电耗模式1、低电耗模式概述2、低电耗模式限制3、适配适应低电耗模式三、应用待机模式对其他用例的支持引言 电池续航时间是移动用户体验中最重要的一个方面。没电的设备完全无法使用。因此&#xff0c;对于应用来说&#xff0c;尽可能地考…
阅读更多...
数据库拆分4--sharding-jdbc-spring-boot-starter自动装配启动过程

数据库拆分4--sharding-jdbc-spring-boot-starter自动装配启动过程

学习一下springboot是如何整合sharding-jdbc的。 添加依赖以后 <dependency><groupId>org.apache.shardingsphere</groupId><artifactId>sharding-jdbc-spring-boot-starter</artifactId><version>4.1.1</version> </dependency…
阅读更多...
Java8之JMX与MBean

Java8之JMX与MBean

参考文章&#xff1a; 《JMX超详细解读》 《JMX》 写在开头&#xff1a;本文为学习后的总结&#xff0c;可能有不到位的地方&#xff0c;错误的地方&#xff0c;欢迎各位指正。 在学习tomcat源码架构的时候了解到其中使用了JMX来实现一些管理工作&#xff0c;于是便整理了这篇…
阅读更多...
Linux systemd-run unit封装CGroup资源进行任务运行

Linux systemd-run unit封装CGroup资源进行任务运行

Linux systemd-run 封装资源使用 序 之前我们讲了关于 systemctl 对各种服务或者说是 unit 进行了讲解&#xff0c;也讲了怎么创建一个 unit&#xff0c;进行相关配置或者依赖设置等等。在使用 systemctl status xxx 时&#xff0c;我们可以发现对应的资源使用情况&#xff0…
阅读更多...
JSTL标签库 | 深入解析JSTL标签库

JSTL标签库 | 深入解析JSTL标签库

目录 一&#xff1a;深入解析JSTL标签库 1、什么是JSTL标签库 2、使用JSTL标签库的步骤 3、JSTL标签的原理 4、jstl中的核心标签库core当中常用的标签 一&#xff1a;深入解析JSTL标签库 1、什么是JSTL标签库 ①Java Standard Tag Lib&#xff08;Java标准的标签库&am…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023