HDFS---客户端入门 API

  封装工具类

public class DoitUtils {
    /**
     * 返回操作hdfs://linux01:8020/ 文件系统的客户端对象
     * @return
     * @throws Exception
     */
    public static  FileSystem getFs() throws Exception {
        return FileSystem.newInstance(new URI("hdfs://linux01:8020/"), new Configuration(),"root") ;

    }

}

上传  

public class UploadDemo {
    public static void main(String[] args) throws Exception {
        //创建文件系统对象
        Configuration conf = new Configuration();
        FileSystem fs = FileSystem.newInstance(new URI("hdfs://linux01:8020"), conf, "root");

        //本地路径 待上传内容
        Path path = new Path("D:\\hadoop-2.8.1.zip");
        //HDFS系统路径
        Path path2 = new Path("/doit17/hdp/");
        fs.copyFromLocalFile(path,path2);//没有返回值
        /**
         * 参数一 是否删除上传文件  默认 是false  不删除  true 删除(剪切)
         * 参数二 是否覆盖HDFS中已存在的内容  默认 true
         * 参数三  本地路径 待上传内容
         * 参数四  HDFS系统路径
         */

        fs.copyFromLocalFile(true,true,path,path2);

        //关闭对象 释放资源
        fs.close();
    }
}

 下载

public class DownDemo {
    public static void main(String[] args) throws Exception {
        //使用工具类调用  获取客户端对象
        FileSystem fs = DoitUtils.getFs();

        //HDFS系统路径
        Path path = new Path("/doit17/hdp/hadoop-2.8.1.zip");
        //本地路径
        Path path2 = new Path("d://");

        /**
         * 参数一  HDFS系统路径
         * 参数二  本地路径
         */

        fs.copyToLocalFile(path,path2);
        /**
         * 参数一 是否删除HDFS中下载的文件  默认 false
         * 参数二  HDFS 系统路径
         * 参数三  本地路径
         * 参数四  是否不生成校验文件  默认 false
         */

        //是否生成校验文件的选择
        //fs.copyToLocalFile(false,path,path2,true);

        //关闭对象 释放资源
        fs.close();
    }
}

移动 + 重命名

public class rename {
    public static void main(String[] args) throws Exception {
        //获取客户端对象
        FileSystem fs = DoitUtils.getFs();


      /**  //要改名的文件
        Path path = new Path("/a.txt");
        //重命名后的文件
        Path path2 = new Path("/b.txt");
        boolean b = fs.rename(path, path2);
        if (b){  //判断是否修改成功
            System.out.println("重命名成功");
        }else{
            System.out.println("重命名失败");
        }*/
      /*
        //改名后的文件
        Path path = new Path("/b.txt");
        //将文件移动到指定文件夹下
        Path path2 = new Path("/data/");
        boolean b = fs.rename(path, path2);
        if (b){  //判断是否移动成功
            System.out.println("移动成功");
        }else{
            System.out.println("移动失败");
        }
        */

        //移动 + 重命名
        Path path = new Path("/data/b.txt");
        Path path2 = new Path("/b.doc");
        boolean b = fs.rename(path, path2);
        if (b){  //判断是否移动 + 重命名 成功
            System.out.println("移动 - 重命名 成功");
        }else{
            System.out.println("移动 - 重命名 失败");
        }



        //释放资源
        fs.close();
    }
}

删除

public class DeleteDemo {
    public static void main(String[] args) throws Exception {
        FileSystem fs = DoitUtils.getFs();
        /**
         * 参数一  要删除的内容文件 或文件夹
         * 参数二  是否递归式删除(强制删除) 默认false
         * 返回值  删除成功返回true
         *
         */
        Path path = new Path("/doit17");
        if (fs.exists(path)) { //判断文件是否存在
            boolean b = fs.delete(path, true);
            if (b) {
                System.out.println("删除内容成功");
            } else {
                System.out.println("删除内容失败");
            }
        }else{
            System.out.println("删除内容不存在");
        }
            //关闭对象  释放资源
            fs.close();
        }
    }

 创建文件夹

public class MkdirDemo {
    public static void main(String[] args) throws Exception {
        /**
         * 参数一 URI  指定HDFS系统位置对象
         * 参数二  配置对象  用户自定义设置   文件上传副本个数
         * 参数三  用户名
         */
        //1.指定HDFS指定文置
        URI uri = new URI("hdfs://linux01:8020");

        //2.获取配置对象  自定义设置
        Configuration conf = new Configuration();

        //3.获取用户

        String username = "root";

        //4.将参数放入文件中
        FileSystem fs = FileSystem.newInstance(uri, conf, username);

        //5.创建文件夹 new File("")  new Path("") Path对象是hdfs对路径的抽象
        Path path = new Path("/doit17/hdp");

        //6.创建层级文件夹
        boolean b = fs.mkdirs(path);

        //7.进行判断
        if (b){
            System.out.println("创建成功");
        }else{
            System.out.println("创建失败");
        }

        //8.关闭对象  释放资源

        fs.close();
    }
}

遍历文件夹 

public class ListDemo {
    public static void main(String[] args) throws Exception {
        //1.工具的调用 获取客户端对象
        FileSystem fs = DoitUtils.getFs();

        //2.路径的获取
        Path path = new Path("/");

        //3.文件夹的路径获取
        FileStatus fileStatus = fs.getFileStatus(path);

        //4.判断路径是否是文件夹
        boolean b = fileStatus.isDirectory();

        if (b) {
            //5.进行遍历目录下及子目录下的所有的文件
            RemoteIterator<LocatedFileStatus> iterator = fs.listFiles(path, true);
            //6.遍历每个文件
            while (iterator.hasNext()) {
                //7.获取每个文件
                LocatedFileStatus file = iterator.next();

                //获取文件路径
                Path p = file.getPath();
                //获取文件名
                String name = p.getName();
                //获取实际文件大小
                long len = file.getLen();
                //获取副本数量
                short replication = file.getReplication();
                //获取物理块大小
                long blockSize = file.getBlockSize();
                System.out.println(name);
                // 8.获取数据文件的元数据信息
                // 9.每个文件的多个物理块
                BlockLocation[] blockLocations = file.getBlockLocations();
                // 文件的一个物理切块
                for (BlockLocation blockLocation : blockLocations) {
                    // 起始位置
                    blockLocation.getOffset();
                    // 数据物理块的大小
                    blockLocation.getLength();
                    //blockLocation  获取多个副本的主机名
                    String[] hosts = blockLocation.getHosts();
                    for (String host : hosts) {
                        // 多个副本所在的主机名
                        System.out.println(host);
                    }
                }

            }
        }


        fs.close();
    }


}

判断是否存在 

public class exitsDemo {
    public static void main(String[] args) throws Exception {

        //获取客户端对象
        FileSystem fs = DoitUtils.getFs();
       /* boolean b = fs.exists(new Path("/w"));
        //System.out.println(b?"存在":"不存在");
        if (b){ //判断文件夹是否存在
            System.out.println("文件夹存在");
        }else{
            System.out.println("文件夹不存在");
        }
        */


        //释放资源
        fs.close();

    }
}

读取数据 

public class ReadDataDemo {
    public static void main(String[] args) throws Exception {
        //获取输入流
        //获取客户端对象
        FileSystem fs = DoitUtils.getFs();
        Path path = new Path("/b.doc");
        //字节读取
       /* if (fs.exists(path)){
            FSDataInputStream fis = fs.open(path);
            // 跳跃字节 随机读取
            fis.seek(2);
            //从头读取
            int i = fis.read();
            System.out.println(i);
            fis.close();
        }*/

        if (fs.exists(path)){
            //获取文件输入流
            FSDataInputStream fis = fs.open(path);
            //得到一个缓冲字符流
            BufferedReader br = new BufferedReader(new InputStreamReader(fis));
            String line = null;
            while ((line=br.readLine())!=null){
                System.out.println(line);
            }
            br.close();
            fis.close();
        }


        fs.close();
    }
}

写数据 

/**
 * 向HDFS文件中写内容  不能随机写
 * HDFS设计目的是为了存储海量数据文件
 * 文件一旦存储在集群中元数据是固定的
 * 里面的数据不支持随机写  允许在文件末尾追加  一般不修改内容
 * 场景试一次存入 多次读取  一般不会追加数据(单用户) 更不能随机修改
 *
 */
public class WriteDataDemo {
    public static void main(String[] args) throws Exception {
        //获取客户端对象
        FileSystem fs = DoitUtils.getFs();
        Path path = new Path("/b.doc");

        //创建新文件写内容
        //fs.create(); //覆盖写

        //追加内容
        FSDataOutputStream fout = fs.append(path);

        //将内容写进去
        fout.writeUTF("hello");
        fout.flush();

        fout.close();

        // 关闭对象 释放资源
        fs.close();
    }
}