如何使用Java API读写HDFS

HDFS是Hadoop生态系统的根基，也是Hadoop生态系统中的重要一员，大部分时候，我们都会使用Linux shell命令来管理HDFS，包括一些文件的创建，删除，修改，上传等等，因为使用shell命令操作HDFS的方式，相对比较简单，方便，但是有时候，我们也需要通过编程的方式来实现对文件系统的管理。 


比如有如下的一个小需求，要求我们实现读取HDFS某个文件夹下所有日志，经过加工处理后在写入到HDFS上，或者存进Hbase里，或者存进其他一些存储系统。这时候使用shell的方式就有点麻烦了，所以这时候我们就可以使用编程的方式来完成这件事了，当然散仙在这里使用的是原生的Java语言的方式，其他的一些语言例如C++,PHP,Python都可以实现，散仙在这里不给出演示了，（其实散仙也不会那些语言，除了刚入门的Python） 。 


下面，散仙给出代码，以供参考：  

Java代码  

1. package com.java.api.hdfs;  
2.   
3. import java.io.BufferedReader;  
4. import java.io.IOException;  
5. import java.io.InputStream;  
6. import java.io.InputStreamReader;  
7.   
8. import org.apache.hadoop.conf.Configuration;  
9. import org.apache.hadoop.fs.FileStatus;  
10. import org.apache.hadoop.fs.FileSystem;  
11. import org.apache.hadoop.fs.Path;  
12.   
13.   
14. /** 
15.  * @author 三劫散仙 
16.  * Java API操作HDFS 
17.  * 工具类 
18.  *  
19.  * **/  
20. public class OperaHDFS {  
21.       
22.       
23.     public static void main(String[] args)throws Exception {  
24.           
25.         //System.out.println("aaa");  
26.     //  uploadFile();  
27.         //createFileOnHDFS();  
28.         //deleteFileOnHDFS();  
29.         //createDirectoryOnHDFS();  
30.         //deleteDirectoryOnHDFS();  
31.     //  renameFileOrDirectoryOnHDFS();  
32.         //downloadFileorDirectoryOnHDFS();  
33.         readHDFSListAll();  
34.     }  
35.       
36.       
37.       
38.       
39.     /*** 
40.      * 加载配置文件 
41.      * **/  
42.      static Configuration conf=new Configuration();  
43.        
44.        
45.        
46.      /** 
47.       * 重名名一个文件夹或者文件 
48.       *  
49.       * **/  
50.      public static void renameFileOrDirectoryOnHDFS()throws Exception{  
51.            
52.             FileSystem fs=FileSystem.get(conf);  
53.             Path p1 =new Path("hdfs://10.2.143.5:9090/root/myfile/my.txt");  
54.             Path p2 =new Path("hdfs://10.2.143.5:9090/root/myfile/my2.txt");  
55.             fs.rename(p1, p2);  
56.               
57.             fs.close();//释放资源  
58.             System.out.println("重命名文件夹或文件成功.....");  
59.            
60.      }  
61.        
62.        
63.      /*** 
64.       *   
65.       * 读取HDFS某个文件夹的所有 
66.       * 文件，并打印 
67.       *  
68.       * **/  
69.         public static void readHDFSListAll() throws Exception{  
70.           
71.      //流读入和写入  
72.             InputStream in=null;  
73.             //获取HDFS的conf  
74.           //读取HDFS上的文件系统  
75.             FileSystem hdfs=FileSystem.get(conf);  
76.           //使用缓冲流，进行按行读取的功能  
77.             BufferedReader buff=null;  
78.           //获取日志文件的根目录  
79.             Path listf =new Path("hdfs://10.2.143.5:9090/root/myfile/");  
80.           //获取根目录下的所有2级子文件目录  
81.             FileStatus stats[]=hdfs.listStatus(listf);  
82.           //自定义j，方便查看插入信息  
83.             int j=0;  
84.              for(int i = 0; i < stats.length; i++){  
85.                 //获取子目录下的文件路径  
86.                 FileStatus   temp[]=hdfs.listStatus(new Path(stats[i].getPath().toString()));  
87.                   for(int k = 0; k < temp.length;k++){  
88.                       System.out.println("文件路径名:"+temp[k].getPath().toString());  
89.                 //获取Path  
90.                 Path p=new Path(temp[k].getPath().toString());  
91.                 //打开文件流  
92.                  in=hdfs.open(p);  
93.                  //BufferedReader包装一个流  
94.                    buff=new BufferedReader(new InputStreamReader(in));             
95.                  String str=null;  
96.                  while((str=buff.readLine())!=null){  
97.                        
98.                      System.out.println(str);  
99.                  }  
100.                     buff.close();  
101.                     in.close();  
102.                    
103.    
104.                  }  
105.                    
106.                   
107.                    
108.    
109.                   }  
110.                    
111.              hdfs.close();  
112.            
113.   
114.         }  
115.      /** 
116.       * 从HDFS上下载文件或文件夹到本地 
117.       *  
118.       * **/  
119.      public static void downloadFileorDirectoryOnHDFS()throws Exception{  
120.            
121.             FileSystem fs=FileSystem.get(conf);  
122.             Path p1 =new Path("hdfs://10.2.143.5:9090/root/myfile//my2.txt");  
123.             Path p2 =new Path("D://7");  
124.             fs.copyToLocalFile(p1, p2);  
125.             fs.close();//释放资源  
126.             System.out.println("下载文件夹或文件成功.....");  
127.            
128.      }  
129.      /** 
130.       * 在HDFS上创建一个文件夹 
131.       *  
132.       * **/  
133.      public static void createDirectoryOnHDFS()throws Exception{  
134.            
135.             FileSystem fs=FileSystem.get(conf);  
136.             Path p =new Path("hdfs://10.2.143.5:9090/root/myfile");  
137.             fs.mkdirs(p);  
138.             fs.close();//释放资源  
139.             System.out.println("创建文件夹成功.....");  
140.            
141.      }  
142.        
143.      /** 
144.       * 在HDFS上删除一个文件夹 
145.       *  
146.       * **/  
147.      public static void deleteDirectoryOnHDFS()throws Exception{  
148.            
149.             FileSystem fs=FileSystem.get(conf);  
150.             Path p =new Path("hdfs://10.2.143.5:9090/root/myfile");  
151.             fs.deleteOnExit(p);  
152.             fs.close();//释放资源  
153.             System.out.println("删除文件夹成功.....");  
154.            
155.      }  
156.      /** 
157.       * 在HDFS上创建一个文件 
158.       *  
159.       * **/  
160.      public static void createFileOnHDFS()throws Exception{  
161.            
162.             FileSystem fs=FileSystem.get(conf);  
163.             Path p =new Path("hdfs://10.2.143.5:9090/root/abc.txt");  
164.             fs.createNewFile(p);  
165.             //fs.create(p);  
166.             fs.close();//释放资源  
167.             System.out.println("创建文件成功.....");  
168.            
169.      }  
170.        
171.      /** 
172.       * 在HDFS上删除一个文件 
173.       *  
174.       * **/  
175.      public static void deleteFileOnHDFS()throws Exception{  
176.            
177.             FileSystem fs=FileSystem.get(conf);  
178.             Path p =new Path("hdfs://10.2.143.5:9090/root/abc.txt");  
179.             fs.deleteOnExit(p);  
180.             fs.close();//释放资源  
181.             System.out.println("删除成功.....");  
182.            
183.      }  
184.        
185.        
186.     /*** 
187.      * 上传本地文件到 
188.      * HDFS上 
189.      *  
190.      * **/  
191.     public static void uploadFile()throws Exception{  
192.         //加载默认配置  
193.         FileSystem fs=FileSystem.get(conf);  
194.           //本地文件  
195.         Path src =new Path("D:\\6");  
196.         //HDFS为止  
197.         Path dst =new Path("hdfs://10.2.143.5:9090/root/");  
198.         try {  
199.             fs.copyFromLocalFile(src, dst);  
200.         } catch (IOException e) {  
201.             // TODO Auto-generated catch block  
202.             e.printStackTrace();  
203.         }  
204.         System.out.println("上传成功........");  
205.      
206.         fs.close();//释放资源  
207.    
208.           
209.     }  
210.   
211. }  

散仙用的是Hadoop1.2的版本，采用hadoop的eclipse插件在eclipse下编写调试的，下面给出截图：  
 
下面给出一个读取某个文件夹下的所有的文件并打印内容的截图：  






其实，java操作HDFS还是比较简单的，只要熟悉java IO的一些操作就可以了。 

  
                        如有不到位的地方，欢迎指正！