u=3004660631,1745089813&fm=253&fmt=auto&app=138&f=JPEG.webp
参考博客：SpringBoot集成Hadoop系列一 —— 对HDFS的文件操作

1.导入依赖

  1.     <dependencies>
  2.         <dependency>
  3.             <groupId>org.springframework.boot</groupId>
  4.             <artifactId>spring-boot-starter-web</artifactId>
  5.         </dependency>
  6.         <dependency>
  7.             <groupId>org.apache.hadoop</groupId>
  8.             <artifactId>hadoop-common</artifactId>
  9.             <version>3.3.3</version>
  10.         </dependency>
  11.         <dependency>
  12.             <groupId>org.apache.hadoop</groupId>
  13.             <artifactId>hadoop-hdfs</artifactId>
  14.             <version>3.3.3</version>
  15.         </dependency>
  16.         <dependency>
  17.             <groupId>org.apache.hadoop</groupId>
  18.             <artifactId>hadoop-client</artifactId>
  19.             <version>3.3.3</version>
  20.         </dependency>
  21.         <dependency>
  22.             <groupId>org.apache.hadoop</groupId>
  23.             <artifactId>hadoop-mapreduce-client-core</artifactId>
  24.             <version>3.3.3</version>
  25.         </dependency>
  26.         <dependency>
  27.             <groupId>cn.bestwu</groupId>
  28.             <artifactId>ik-analyzers</artifactId>
  29.             <version>5.1.0</version>
  30.         </dependency>
  31.         <dependency>
  32.             <groupId>org.projectlombok</groupId>
  33.             <artifactId>lombok</artifactId>
  34.         </dependency>
  35.         <dependency>
  36.             <groupId>com.alibaba</groupId>
  37.             <artifactId>fastjson</artifactId>
  38.             <version>1.2.46</version>
  39.         </dependency>
  40.         <!-- 此处的导入依赖与mapreduce有关 -->
  41.         <dependency>
  42.             <groupId>jdk.tools</groupId>
  43.             <artifactId>jdk.tools</artifactId>
  44.             <version>1.8</version>
  45.             <scope>system</scope>
  46.             <systemPath>${JAVA_HOME}/lib/tools.jar</systemPath>
  47.         </dependency>
  48.         <dependency>
  49.             <groupId>junit</groupId>
  50.             <artifactId>junit</artifactId>
  51.             <scope>test</scope>
  52.         </dependency>
  54.         <dependency>
  55.             <groupId>org.springframework.boot</groupId>
  56.             <artifactId>spring-boot-starter-test</artifactId>
  57.             <scope>test</scope>
  58.         </dependency>

2.核心代码

application.properties

  1. # tomcat thread = 200
  2. server.tomcat.max-threads=1000
  4. # edit tomcat port
  5. server.port=8900
  6. # session time 30
  7. server.session-timeout=60
  9. spring.application.name=hadoop
  10. spring.servlet.multipart.max-file-size=50MB
  11. spring.servlet.multipart.max-request-size=50MB
  13. hdfs.path=hdfs://hadoop0:9000
  14. hdfs.username=root

HdfsConfig.java

  1. import org.springframework.beans.factory.annotation.Value;
  2. import org.springframework.context.annotation.Configuration;
  4. /**
  5.  * @author HappyDragon1994
  6.  */
  7. @Configuration
  8. public class HdfsConfig {
  9.     @Value("${hdfs.path}")
  10.     private String path;
  12.     public String getPath() {
  13.         return path;
  14.     }
  16.     public void setPath(String path) {
  17.         this.path = path;
  18.     }
  20. }

HdfsController.java

  1. package com.zym.controller;
  3. import com.zym.entity.User;
  4. import com.zym.result.Result;
  5. import com.zym.service.HdfsService;
  6. import lombok.extern.slf4j.Slf4j;
  7. import org.apache.commons.lang3.StringUtils;
  8. import org.apache.hadoop.fs.BlockLocation;
  9. import org.springframework.web.bind.annotation.*;
  10. import org.springframework.web.multipart.MultipartFile;
  12. import java.util.List;
  13. import java.util.Map;
  15. @RestController
  16. @RequestMapping("/hadoop/hdfs")
  17. @Slf4j
  18. public class HdfsController {
  19.     /**
  20.      * 创建文件夹
  21.      * @param path
  22.      * @return
  23.      * @throws Exception
  24.      */
  25.     @RequestMapping(value = "mkdir", method = RequestMethod.POST)
  26.     @ResponseBody
  27.     public Result mkdir(@RequestParam("path") String path) throws Exception {
  28.         if (StringUtils.isEmpty(path)) {
  29.             System.out.println("请求参数为空");
  30.             return new Result(Result.FAILURE, "请求参数为空");
  31.         }
  32.         // 创建空文件夹
  33.         boolean isOk = HdfsService.mkdir(path);
  34.         if (isOk) {
  35.             log.debug("文件夹创建成功");
  36.             return new Result(Result.SUCCESS, "文件夹创建成功");
  37.         } else {
  38.             log.debug("文件夹创建失败");
  39.             return new Result(Result.FAILURE, "文件夹创建失败");
  40.         }
  41.     }
  43.     /**
  44.      * 读取HDFS目录信息
  45.      * @param path
  46.      * @return
  47.      * @throws Exception
  48.      */
  49.     @PostMapping("/readPathInfo")
  50.     public Result readPathInfo(@RequestParam("path") String path) throws Exception {
  51.         List<Map<String, Object>> list = HdfsService.readPathInfo(path);
  52.         return new Result(Result.SUCCESS, "读取HDFS目录信息成功", list);
  53.     }
  55.     /**
  56.      * 获取HDFS文件在集群中的位置
  57.      * @param path
  58.      * @return
  59.      * @throws Exception
  60.      */
  61.     @PostMapping("/getFileBlockLocations")
  62.     public Result getFileBlockLocations(@RequestParam("path") String path) throws Exception {
  63.         BlockLocation[] blockLocations = HdfsService.getFileBlockLocations(path);
  64.         return new Result(Result.SUCCESS, "获取HDFS文件在集群中的位置", blockLocations);
  65.     }
  67.     /**
  68.      * 创建文件
  69.      * @param path
  70.      * @return
  71.      * @throws Exception
  72.      */
  73.     @PostMapping("/createFile")
  74.     public Result createFile(@RequestParam("path") String path, @RequestParam("file") MultipartFile file)
  75.             throws Exception {
  76.         if (StringUtils.isEmpty(path) || null == file.getBytes()) {
  77.             return new Result(Result.FAILURE, "请求参数为空");
  78.         }
  79.         HdfsService.createFile(path, file);
  80.         return new Result(Result.SUCCESS, "创建文件成功");
  81.     }
  83.     /**
  84.      * 读取HDFS文件内容
  85.      * @param path
  86.      * @return
  87.      * @throws Exception
  88.      */
  89.     @PostMapping("/readFile")
  90.     public Result readFile(@RequestParam("path") String path) throws Exception {
  91.         String targetPath = HdfsService.readFile(path);
  92.         return new Result(Result.SUCCESS, "读取HDFS文件内容", targetPath);
  93.     }
  95.     /**
  96.      * 读取HDFS文件转换成Byte类型
  97.      * @param path
  98.      * @return
  99.      * @throws Exception
  100.      */
  101.     @PostMapping("/openFileToBytes")
  102.     public Result openFileToBytes(@RequestParam("path") String path) throws Exception {
  103.         byte[] files = HdfsService.openFileToBytes(path);
  104.         return new Result(Result.SUCCESS, "读取HDFS文件转换成Byte类型", files);
  105.     }
  107.     /**
  108.      * 读取HDFS文件装换成User对象
  109.      * @param path
  110.      * @return
  111.      * @throws Exception
  112.      */
  113.     @PostMapping("/openFileToUser")
  114.     public Result openFileToUser(@RequestParam("path") String path) throws Exception {
  115.         User user = HdfsService.openFileToObject(path, User.class);
  116.         return new Result(Result.SUCCESS, "读取HDFS文件装换成User对象", user);
  117.     }
  119.     /**
  120.      * 读取文件列表
  121.      * @param path
  122.      * @return
  123.      * @throws Exception
  124.      */
  125.     @PostMapping("/listFile")
  126.     public Result listFile(@RequestParam("path") String path) throws Exception {
  127.         if (StringUtils.isEmpty(path)) {
  128.             return new Result(Result.FAILURE, "请求参数为空");
  129.         }
  130.         List<Map<String, String>> returnList = HdfsService.listFile(path);
  131.         return new Result(Result.SUCCESS, "读取文件列表成功", returnList);
  132.     }
  134.     /**
  135.      * 重命名文件
  136.      * @param oldName
  137.      * @param newName
  138.      * @return
  139.      * @throws Exception
  140.      */
  141.     @PostMapping("/renameFile")
  142.     public Result renameFile(@RequestParam("oldName") String oldName, @RequestParam("newName") String newName)
  143.             throws Exception {
  144.         if (StringUtils.isEmpty(oldName) || StringUtils.isEmpty(newName)) {
  145.             return new Result(Result.FAILURE, "请求参数为空");
  146.         }
  147.         boolean isOk = HdfsService.renameFile(oldName, newName);
  148.         if (isOk) {
  149.             return new Result(Result.SUCCESS, "文件重命名成功");
  150.         } else {
  151.             return new Result(Result.FAILURE, "文件重命名失败");
  152.         }
  153.     }
  155.     /**
  156.      * 删除文件
  157.      * @param path
  158.      * @return
  159.      * @throws Exception
  160.      */
  161.     @PostMapping("/deleteFile")
  162.     public Result deleteFile(@RequestParam("path") String path) throws Exception {
  163.         boolean isOk = HdfsService.deleteFile(path);
  164.         if (isOk) {
  165.             return new Result(Result.SUCCESS, "delete file success");
  166.         } else {
  167.             return new Result(Result.FAILURE, "delete file fail");
  168.         }
  169.     }
  171.     /**
  172.      * 上传文件
  173.      * @param path
  174.      * @param uploadPath
  175.      * @return
  176.      * @throws Exception
  177.      */
  178.     @PostMapping("/uploadFile")
  179.     public Result uploadFile(@RequestParam("path") String path, @RequestParam("uploadPath") String uploadPath)
  180.             throws Exception {
  181.         HdfsService.uploadFile(path, uploadPath);
  182.         return new Result(Result.SUCCESS, "upload file success");
  183.     }
  185.     /**
  186.      * 下载文件
  187.      * @param path
  188.      * @param downloadPath
  189.      * @return
  190.      * @throws Exception
  191.      */
  192.     @PostMapping("/downloadFile")
  193.     public Result downloadFile(@RequestParam("path") String path, @RequestParam("downloadPath") String downloadPath)
  194.             throws Exception {
  195.         HdfsService.downloadFile(path, downloadPath);
  196.         return new Result(Result.SUCCESS, "download file success");
  197.     }
  199.     /**
  200.      * HDFS文件复制
  201.      * @param sourcePath
  202.      * @param targetPath
  203.      * @return
  204.      * @throws Exception
  205.      */
  206.     @PostMapping("/copyFile")
  207.     public Result copyFile(@RequestParam("sourcePath") String sourcePath, @RequestParam("targetPath") String targetPath)
  208.             throws Exception {
  209.         HdfsService.copyFile(sourcePath, targetPath);
  210.         return new Result(Result.SUCCESS, "copy file success");
  211.     }
  213.     /**
  214.      * 查看文件是否已存在
  215.      * @param path
  216.      * @return
  217.      * @throws Exception
  218.      */
  219.     @PostMapping("/existFile")
  220.     public Result existFile(@RequestParam("path") String path) throws Exception {
  221.         boolean isExist = HdfsService.existFile(path);
  222.         return new Result(Result.SUCCESS, "file isExist: " + isExist);
  223.     }
  224. }

User.java

  1. package com.zym.entity;
  3. import org.apache.hadoop.io.Writable;
  5. import java.io.DataInput;
  6. import java.io.DataOutput;
  7. import java.io.IOException;
  9. /**
  10.  * @author HappyDragon1994
  11.  */
  12. public class User implements Writable {
  13.     private String username;
  14.     private Integer age;
  15.     private String address;
  17.     public User() {
  18.         super();
  19.         // TODO Auto-generated constructor stub
  20.     }
  22.     public User(String username, Integer age, String address) {
  23.         super();
  24.         this.username = username;
  25.         this.age = age;
  26.         this.address = address;
  27.     }
  29.     @Override
  30.     public void write(DataOutput output) throws IOException {
  31.         // 把对象序列化
  32.         output.writeChars(username);
  33.         output.writeInt(age);
  34.         output.writeChars(address);
  35.     }
  38.     @Override
  39.     public void readFields(DataInput input) throws IOException {
  40.         // 把序列化的对象读取到内存中
  41.         username = input.readUTF();
  42.         age = input.readInt();
  43.         address = input.readUTF();
  44.     }
  46.     public String getUsername() {
  47.         return username;
  48.     }
  50.     public void setUsername(String username) {
  51.         this.username = username;
  52.     }
  54.     public Integer getAge() {
  55.         return age;
  56.     }
  58.     public void setAge(Integer age) {
  59.         this.age = age;
  60.     }
  62.     public String getAddress() {
  63.         return address;
  64.     }
  66.     public void setAddress(String address) {
  67.         this.address = address;
  68.     }
  70.     @Override
  71.     public String toString() {
  72.         return "User [username=" + username + ", age=" + age + ", address=" + address + "]";
  73.     }
  74. }

Result.java

  1. package com.zym.result;
  3. import lombok.Data;
  5. @Data
  6. public class Result {
  7.     private String resCode;
  8.     private String resDes;
  9.     private Object data;
  11.     public static final String FAILURE="sys-00-01";
  12.     public static final String SUCCESS = "SUCCESS";
  14.     public Result(String resCode,String resDes,Object data){
  15.         this.resCode = resCode;
  16.         this.resDes = resDes;
  17.         this.data=data;
  18.     }
  20.     public Result(String resCode,String resDes){
  21.         this.resCode = resCode;
  22.         this.resDes = resDes;
  23.     }
  24. }

HdfsService.java

  1. package com.zym.service;
  3. import com.alibaba.fastjson.JSONObject;
  4. import org.apache.commons.lang3.StringUtils;
  5. import org.apache.hadoop.conf.Configuration;
  6. import org.apache.hadoop.fs.*;
  7. import org.apache.hadoop.hdfs.web.JsonUtil;
  8. import org.apache.hadoop.io.IOUtils;
  9. import org.springframework.beans.factory.annotation.Value;
  10. import org.springframework.stereotype.Component;
  11. import org.springframework.web.multipart.MultipartFile;
  13. import javax.annotation.PostConstruct;
  14. import java.io.BufferedReader;
  15. import java.io.InputStreamReader;
  16. import java.net.URI;
  17. import java.util.ArrayList;
  18. import java.util.HashMap;
  19. import java.util.List;
  20. import java.util.Map;
  22. @Component
  23. public class HdfsService {
  24.     @Value("${hdfs.path}")
  25.     private String path;
  26.     @Value("${hdfs.username}")
  27.     private String username;
  29.     private static String hdfsPath;
  30.     private static String hdfsName;
  31.     private static final int bufferSize = 1024 * 1024 * 64;
  33.     @PostConstruct
  34.     public void getPath() {
  35.         hdfsPath = this.path;
  36.     }
  38.     @PostConstruct
  39.     public void getName() {
  40.         hdfsName = this.username;
  41.     }
  43.     public static String getHdfsPath() {
  44.         return hdfsPath;
  45.     }
  47.     public String getUsername() {
  48.         return username;
  49.     }
  51.     /**
  52.      * 获取HDFS配置信息
  53.      * @return
  54.      */
  55.     private static Configuration getConfiguration() {
  56.         Configuration configuration = new Configuration();
  57.         configuration.set("fs.defaultFS", hdfsPath);
  58.         return configuration;
  59.     }
  61.     /**
  62.      * 获取HDFS文件系统对象
  63.      * @return
  64.      * @throws Exception
  65.      */
  66.     public static FileSystem getFileSystem() throws Exception {
  67.         // 客户端去操作hdfs时是有一个用户身份的，默认情况下hdfs客户端api会从jvm中获取一个参数作为自己的用户身份
  68.         // DHADOOP_USER_NAME=hadoop
  69.         // 也可以在构造客户端fs对象时，通过参数传递进去
  70.         FileSystem fileSystem = FileSystem.get(new URI(hdfsPath), getConfiguration(), hdfsName);
  71.         return fileSystem;
  72.     }
  74.     /**
  75.      * 在HDFS创建文件夹
  76.      * @param path
  77.      * @return
  78.      * @throws Exception
  79.      */
  80.     public static boolean mkdir(String path) throws Exception {
  81.         if (StringUtils.isEmpty(path)) {
  82.             return false;
  83.         }
  84.         if (existFile(path)) {
  85.             return true;
  86.         }
  87.         FileSystem fs = getFileSystem();
  88.         // 目标路径
  89.         Path srcPath = new Path(path);
  90.         boolean isOk = fs.mkdirs(srcPath);
  91.         fs.close();
  92.         return isOk;
  93.     }
  95.     /**
  96.      * 判断HDFS文件是否存在
  97.      * @param path
  98.      * @return
  99.      * @throws Exception
  100.      */
  101.     public static boolean existFile(String path) throws Exception {
  102.         if (StringUtils.isEmpty(path)) {
  103.             return false;
  104.         }
  105.         FileSystem fs = getFileSystem();
  106.         Path srcPath = new Path(path);
  107.         boolean isExists = fs.exists(srcPath);
  108.         return isExists;
  109.     }
  111.     /**
  112.      * 读取HDFS目录信息
  113.      * @param path
  114.      * @return
  115.      * @throws Exception
  116.      */
  117.     public static List<Map<String, Object>> readPathInfo(String path) throws Exception {
  118.         if (StringUtils.isEmpty(path)) {
  119.             return null;
  120.         }
  121.         if (!existFile(path)) {
  122.             return null;
  123.         }
  124.         FileSystem fs = getFileSystem();
  125.         // 目标路径
  126.         Path newPath = new Path(path);
  127.         FileStatus[] statusList = fs.listStatus(newPath);
  128.         List<Map<String, Object>> list = new ArrayList<>();
  129.         if (null != statusList && statusList.length > 0) {
  130.             for (FileStatus fileStatus : statusList) {
  131.                 Map<String, Object> map = new HashMap<>();
  132.                 map.put("filePath", fileStatus.getPath());
  133.                 map.put("fileStatus", fileStatus.toString());
  134.                 list.add(map);
  135.             }
  136.             return list;
  137.         } else {
  138.             return null;
  139.         }
  140.     }
  142.     /**
  143.      * HDFS创建文件
  144.      * @param path
  145.      * @param file
  146.      * @throws Exception
  147.      */
  148.     public static void createFile(String path, MultipartFile file) throws Exception {
  149.         if (StringUtils.isEmpty(path) || null == file.getBytes()) {
  150.             return;
  151.         }
  152.         String fileName = file.getOriginalFilename();
  153.         FileSystem fs = getFileSystem();
  154.         // 上传时默认当前目录，后面自动拼接文件的目录
  155.         Path newPath = new Path(path + "/" + fileName);
  156.         // 打开一个输出流
  157.         FSDataOutputStream outputStream = fs.create(newPath);
  158.         outputStream.write(file.getBytes());
  159.         outputStream.close();
  160.         fs.close();
  161.     }
  163.     /**
  164.      * 读取HDFS文件内容
  165.      * @param path
  166.      * @return
  167.      * @throws Exception
  168.      */
  169.     public static String readFile(String path) throws Exception {
  170.         if (StringUtils.isEmpty(path)) {
  171.             return null;
  172.         }
  173.         if (!existFile(path)) {
  174.             return null;
  175.         }
  176.         FileSystem fs = getFileSystem();
  177.         // 目标路径
  178.         Path srcPath = new Path(path);
  179.         FSDataInputStream inputStream = null;
  180.         try {
  181.             inputStream = fs.open(srcPath);
  182.             // 防止中文乱码
  183.             BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
  184.             String lineTxt = "";
  185.             StringBuffer sb = new StringBuffer();
  186.             while ((lineTxt = reader.readLine()) != null) {
  187.                 sb.append(lineTxt);
  188.             }
  189.             return sb.toString();
  190.         } finally {
  191.             inputStream.close();
  192.             fs.close();
  193.         }
  194.     }
  196.     /**
  197.      * 读取HDFS文件列表
  198.      * @param path
  199.      * @return
  200.      * @throws Exception
  201.      */
  202.     public static List<Map<String, String>> listFile(String path) throws Exception {
  203.         if (StringUtils.isEmpty(path)) {
  204.             return null;
  205.         }
  206.         if (!existFile(path)) {
  207.             return null;
  208.         }
  210.         FileSystem fs = getFileSystem();
  211.         // 目标路径
  212.         Path srcPath = new Path(path);
  213.         // 递归找到所有文件
  214.         RemoteIterator<LocatedFileStatus> filesList = fs.listFiles(srcPath, true);
  215.         List<Map<String, String>> returnList = new ArrayList<>();
  216.         while (filesList.hasNext()) {
  217.             LocatedFileStatus next = filesList.next();
  218.             String fileName = next.getPath().getName();
  219.             Path filePath = next.getPath();
  220.             Map<String, String> map = new HashMap<>();
  221.             map.put("fileName", fileName);
  222.             map.put("filePath", filePath.toString());
  223.             returnList.add(map);
  224.         }
  225.         fs.close();
  226.         return returnList;
  227.     }
  229.     /**
  230.      * HDFS重命名文件
  231.      * @param oldName
  232.      * @param newName
  233.      * @return
  234.      * @throws Exception
  235.      */
  236.     public static boolean renameFile(String oldName, String newName) throws Exception {
  237.         if (StringUtils.isEmpty(oldName) || StringUtils.isEmpty(newName)) {
  238.             return false;
  239.         }
  240.         FileSystem fs = getFileSystem();
  241.         // 原文件目标路径
  242.         Path oldPath = new Path(oldName);
  243.         // 重命名目标路径
  244.         Path newPath = new Path(newName);
  245.         boolean isOk = fs.rename(oldPath, newPath);
  246.         fs.close();
  247.         return isOk;
  248.     }
  250.     /**
  251.      * 删除HDFS文件
  252.      * @param path
  253.      * @return
  254.      * @throws Exception
  255.      */
  256.     public static boolean deleteFile(String path) throws Exception {
  257.         if (StringUtils.isEmpty(path)) {
  258.             return false;
  259.         }
  260.         if (!existFile(path)) {
  261.             return false;
  262.         }
  263.         FileSystem fs = getFileSystem();
  264.         Path srcPath = new Path(path);
  265.         boolean isOk = fs.deleteOnExit(srcPath);
  266.         fs.close();
  267.         return isOk;
  268.     }
  270.     /**
  271.      * 上传HDFS文件
  272.      * @param path
  273.      * @param uploadPath
  274.      * @throws Exception
  275.      */
  276.     public static void uploadFile(String path, String uploadPath) throws Exception {
  277.         if (StringUtils.isEmpty(path) || StringUtils.isEmpty(uploadPath)) {
  278.             return;
  279.         }
  280.         FileSystem fs = getFileSystem();
  281.         // 上传路径
  282.         Path clientPath = new Path(path);
  283.         // 目标路径
  284.         Path serverPath = new Path(uploadPath);
  286.         // 调用文件系统的文件复制方法，第一个参数是否删除原文件true为删除，默认为false
  287.         fs.copyFromLocalFile(false, clientPath, serverPath);
  288.         fs.close();
  289.     }
  291.     /**
  292.      * 下载HDFS文件
  293.      * @param path
  294.      * @param downloadPath
  295.      * @throws Exception
  296.      */
  297.     public static void downloadFile(String path, String downloadPath) throws Exception {
  298.         if (StringUtils.isEmpty(path) || StringUtils.isEmpty(downloadPath)) {
  299.             return;
  300.         }
  301.         FileSystem fs = getFileSystem();
  302.         // 上传路径
  303.         Path clientPath = new Path(path);
  304.         // 目标路径
  305.         Path serverPath = new Path(downloadPath);
  307.         // 调用文件系统的文件复制方法，第一个参数是否删除原文件true为删除，默认为false
  308.         fs.copyToLocalFile(false, clientPath, serverPath);
  309.         fs.close();
  310.     }
  312.     /**
  313.      * HDFS文件复制
  314.      * @param sourcePath
  315.      * @param targetPath
  316.      * @throws Exception
  317.      */
  318.     public static void copyFile(String sourcePath, String targetPath) throws Exception {
  319.         if (StringUtils.isEmpty(sourcePath) || StringUtils.isEmpty(targetPath)) {
  320.             return;
  321.         }
  322.         FileSystem fs = getFileSystem();
  323.         // 原始文件路径
  324.         Path oldPath = new Path(sourcePath);
  325.         // 目标路径
  326.         Path newPath = new Path(targetPath);
  328.         FSDataInputStream inputStream = null;
  329.         FSDataOutputStream outputStream = null;
  330.         try {
  331.             inputStream = fs.open(oldPath);
  332.             outputStream = fs.create(newPath);
  334.             IOUtils.copyBytes(inputStream, outputStream, bufferSize, false);
  335.         } finally {
  336.             inputStream.close();
  337.             outputStream.close();
  338.             fs.close();
  339.         }
  340.     }
  342.     /**
  343.      * 打开HDFS上的文件并返回byte数组
  344.      * @param path
  345.      * @return
  346.      * @throws Exception
  347.      */
  348.     public static byte[] openFileToBytes(String path) throws Exception {
  349.         if (StringUtils.isEmpty(path)) {
  350.             return null;
  351.         }
  352.         if (!existFile(path)) {
  353.             return null;
  354.         }
  355.         FileSystem fs = getFileSystem();
  356.         // 目标路径
  357.         Path srcPath = new Path(path);
  358.         try {
  359.             FSDataInputStream inputStream = fs.open(srcPath);
  360.             return IOUtils.readFullyToByteArray(inputStream);
  361.         } finally {
  362.             fs.close();
  363.         }
  364.     }
  366.     /**
  367.      * 打开HDFS上的文件并返回java对象
  368.      * @param path
  369.      * @return
  370.      * @throws Exception
  371.      */
  372.     public static <T extends Object> T openFileToObject(String path, Class<T> clazz) throws Exception {
  373.         if (StringUtils.isEmpty(path)) {
  374.             return null;
  375.         }
  376.         if (!existFile(path)) {
  377.             return null;
  378.         }
  379.         String jsonStr = readFile(path);
  380.         return JSONObject.parseObject(jsonStr,clazz);
  381.     }
  383.     /**
  384.      * 获取某个文件在HDFS的集群位置
  385.      * @param path
  386.      * @return
  387.      * @throws Exception
  388.      */
  389.     public static BlockLocation[] getFileBlockLocations(String path) throws Exception {
  390.         if (StringUtils.isEmpty(path)) {
  391.             return null;
  392.         }
  393.         if (!existFile(path)) {
  394.             return null;
  395.         }
  396.         FileSystem fs = getFileSystem();
  397.         // 目标路径
  398.         Path srcPath = new Path(path);
  399.         FileStatus fileStatus = fs.getFileStatus(srcPath);
  400.         return fs.getFileBlockLocations(fileStatus, 0, fileStatus.getLen());
  401.     }
  402. }

代码地址：？？？

……哎，开源路漫漫，Gitee现在仓库公开还要审核……下次改用GitHub吧，这次的代码上面都贴出来了，复制粘贴即可~

部分Postman测试截图：
image.png
image.png
image.png
image.png
image.png
image.png
image.png