hdfs设计原则
1.非常大的文件：
这里的非常大是指几百MB,GB,TB.雅虎的hadoop集群已经可以存储PB级别的数据
2.流式数据访问：
基于一次写，多次读。
3.商用硬件：
hdfs的高可用是用软件来解决，因此不需要昂贵的硬件来保障高可用性，各个生产商售卖的pc或者虚拟机即可。
hdfs不适用的场景
1.低延迟的数据访问
hdfs的强项在于大量的数据传输，递延迟不适合他，10毫秒以下的访问可以无视hdfs，不过hbase可以弥补这个缺陷。
2.太多小文件
namenode节点在内存中hold住了整个文件系统的元数据，因此文件的数量就会受到限制，每个文件的元数据大约150字节
1百万个文件，每个文件只占一个block，那么就需要300MB内存。你的服务器可以hold住多少呢，你可以自己算算
3.多处写和随机修改
目前还不支持多处写入以及通过偏移量随机修改
hdfs block
1 为了最小化查找时间比例，hdfs的块要比磁盘的块大很多。hdfs块的大小默认为64MB，和文件系统的块不同，默认大小可以修改
2 hdfs的文件可以小于块大小，并且不会占满整个块大小
3 做个统数据统计：
查找时间在10ms左右，数据传输几率在100MB/s,为了使查找时间是传输时间的1%，块的大小必须在100MB左右，一般都会设置为128MB
在有了块概念后，hdfs增加如下优点：（这三个没看出来是多大的优点，或许是对hdfs理解不深入吧）
1.可以存储比单个磁盘更大的文件
2.存储块比存储文件更加简单，每个块的大小都基本相同
3.使用块比文件更适合做容错性和高可用
namenodes和datanodes
hdfs集群有两种类型的节点，一种为master及namenode，另一种为worker及datanodes。
namenode节点管理文件 系统的命名空间。 它包含一个文件系统的树，所有文件和目录 的原数据都在这个树上，这些 信息被存储在本地 磁盘的两个文件中，image文件和edit log文件。
文件相关的块存在哪个块中，块在哪个地方，这些 信息都是在 系统启动的时 候加载到namenode的内存中
datanode节点在文件系统中充当的角色就是苦力，按照namenode和client的指令进行存储或者检索block，并且周期性 的向namenode节点报告它存了哪些文件的block
namenode节点如果不能使用了，那么整个hdfs就玩完了,为了防止这种情况,有两种方式可供选择
1.namenode通过配置元数据可以写到多个磁盘中，最好是独立的磁盘，或者NFS.
2 使用第二namenode节点(secondnamenode),第二namenode节点平时并不作为namenode节点工作，
它的主要工作内容就是定期将编辑日志（edit log）合并到namespace image中，并清空 edit log,
合并后的image它自己也保留一份，等着 namenode节点挂掉，然后它可以转正，由于不是实时的，
有数据上的损失是很可能发生的。
hdfs Federation
namenode节点保持所有的文件和块的引用在内存中，这就意味着在一个拥有很多很多文件的很大的集群中，内存就成为了一个
限制的条件，hdfs federation在hadoop 2.x的被实现了，允许hdfs有多个namenode节点，每个管hdfs的一部分，比如一个管/usr，
另一个管/home，每个namenode节点是相互隔离的，一个挂掉不会影响另外一个。
hdfs的高可用
不管namenode节点的备份还是第二namenode节点都只能保证数据的恢复，并不能保证hdfs的高可用性,
一旦namenode节点挂掉 就会产生单点故障，这时候要手动去数据恢复，并且启用第二name节点
新的namenode节点在对外服务器要做三件事：
1.把命名空间的镜像加载到内存中
2.重新运行编辑日志
3.接受各个datanode节点的block报告
在一个大型一点的hdfs系统中，等这些做完需要30分钟左右。
hadoop2.x已经支持了高可用性(HA)，通过一对namenode热备来实现，一台挂掉，备机马上提供无中断服务
要实现HA,要做三点微调：
1.namenode节点必须使用高可用的共享存储。
2.datanode节点必须象两个namenode节点发送block报告
3.客户端做改动可以在故障时切换到可用的namenode节点上，而且要对用户是无感知的
failover和fencing
将备份namenode激活的过程就叫failover，管理激活备份namenode的系统叫做failover controller，
zookeeper就可以担当这样的角色，可以保证只有一个节点处于激活状态。
必须确认原来的namenode已经真的挂掉了，很多时候只是网络延迟，如果备份节点已经激活了，
原来的节点又可以提供服务了，这样是不行的，防止原来namenode活过来的过程就叫fencing。
可以用STONITH实现， STONITH可以做到直接断电把原namenode节点fencing掉
FileSystem， 可以通过如下代码创建此对象:
static FileSystem getFileSystem() {
try {
return FileSystem.get(new URI(PATH), new Configuration());
} catch (IOException e) {
e.printStackTrace();
} catch (URISyntaxException e) {
e.printStackTrace();
}
return null;
}
new Configuration(), 查看源代码发现有如下写法
addDefaultResource("core-default.xml");
addDefaultResource("core-site.xml");
会自动加载hdfs的这两个核心文件
写数据
FileSystem类有很多种创建文件的方法，最简单的一种是
public FSDataOutputStream create(Path f) throws IOException
它还有很多重载方法，可以指定是否强制覆盖已存在的文件，文件的重复因子，写缓存的大小，文件的块大小，文件的权限等。
还可以指定一个回调接口：
public interface Progressable {
void progress();
}
和普通文件系统一样，也支持apend操作，写日志时最常用
public FSDataOutputStream append(Path f) throws IOException
以下是个拷贝本地文件到hdfs的例子
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IOUtils;
import org.apache.hadoop.util.Progressable;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.URI;
public class FileCopyWithProgress {
public static void main(String[] args) throws Exception {
String localSrc = args[0];
String dst = args[1];
InputStream in = new BufferedInputStream(new FileInputStream(localSrc));
Configuration conf = new Configuration();
FileSystem fs = FileSystem.get(URI.create(dst), conf);
OutputStream out = fs.create(new Path(dst), new Progressable() {
@Override
public void progress() {
System.out.print(".");
}
});
IOUtils.copyBytes(in, out, 4096, true);
FileStatus
封装了hdfs文件和目录的元数据，包括文件的长度，块大小，重复数，修改时间，所有者，权限等信息，FileSystem的getFileStatus可以获得这些信息
Listing files
有时候你可能会需要找一组符合要求的文件，那么下面的示例就可以帮到你，通过FileSystem的listStatus方法可以获得符合条件的一组FileStatus对象，listStatus有几个重载的方法，可以传入多个路径，还可以使用PathFilter做过滤
PathFilter
接着上面我们来讲PathFilter接口，该接口只需实现其中的一个方法即可，即accpet方法，方法返回true时表示被过滤掉,我们来实现一个正则过滤，并在下面的例子里起作用
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.fs.PathFilter;
public class RegexExludePathFilter implements PathFilter {
private final String regex;
public RegexExludePathFilter(String regex) {
this.regex = regex;
}
@Override
public boolean accept(Path path) {
return !path.toString().matches(regex);
}
}
File patterns
当需要很多文件时，一个个列出路径是很不便捷的，hdfs提供了一个通配符列出文件的方法，通过FileSystem的globStatus方法提供了这个便捷，globStatus也有重载的方法，使用PathFilter过滤，那么我们结合两个来实现一下
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileStatus;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.FileUtil;
import org.apache.hadoop.fs.Path;
import java.io.IOException;
import java.net.URI;
public class GlobStatus {
public static void main(String[] args) throws IOException {
String uri = args[0];
Configuration conf = new Configuration();
FileSystem fs = FileSystem.get(URI.create(uri), conf);
FileStatus[] status = fs.globStatus(new Path(uri),new RegexExludePathFilter("^.*/1901"));
Path[] listedPaths = FileUtil.stat2Paths(status);
for (Path p : listedPaths) {
System.out.println(p);
}
}
}
删除数据
删除数据比较简单
public abstract boolean delete(Path f, boolean recursive) throws IOException
第一个参数很明确，第二个参数表示是否递归删除子目录或目录下的文件，在Path为目录但目录是空的或者Path为文件时可以忽略，但如果Path为目录且不为空的情况下，如果recursive为false,那么删除就会抛出io异常。
下面贴上java操作hdfs的一些简单代码：
package hdfs;
import java.io.FileInputStream;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FSDataInputStream;
import org.apache.hadoop.fs.FSDataOutputStream;
import org.apache.hadoop.fs.FileStatus;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IOUtils;
// 使用 hadoop的FileSystem API进行文件操作
public class FileSystemHdfs {
static final String PATH = "hdfs://master:9000/"; // 本机host中已经配置 192.168.1.105 master
static final String DIR = "/d1";
static final String FILE = "/d1/file";
public static void main(String[] args) {
// 获取hadoop文件系统
FileSystem fileSystem = getFileSystem();
// 创建文件夹
//mkdir(fileSystem);
// 上传文件
//putData(fileSystem);
// 下载文件
//getData(fileSystem);
// 浏览文件夹
list(fileSystem);
// 删除文件
//remove(fileSystem);
}
private static void list(FileSystem fileSystem) {
try {
FileStatus[] filesStatus = fileSystem.listStatus(new Path("/"));
for (FileStatus fileStatus : filesStatus) {
String isDir = fileStatus.isDir()?"文件夹":"文件";
String permission = fileStatus.getPermission().toString();
short replication = (short) fileStatus.getBlockSize();
long len = fileStatus.getLen();
String path = fileStatus.getPath().toString();
System.out.println(isDir+"\t"+permission+"\t"+replication+"\t"+len+"\t"+path);
}
} catch (IOException e) {
e.printStackTrace();
}
}
private static void getData(FileSystem fileSystem) {
try {
FSDataInputStream in = fileSystem.open(new Path(FILE));
IOUtils.copyBytes(in, System.out, 1024,true);
} catch (IOException e) {
e.printStackTrace();
}
}
private static void putData(FileSystem fileSystem) {
try {
/**
* * @param in InputStrem to read from
* @param out OutputStream to write to
* 虽然下面定义 hdfs上的FILE文件为输出流感觉和真正JAVA上学的IO 输出流概念正好相反，但是看到IOUtils.copyBytes(in, out, 1024, true)
* 方法中对 in,out的英文解释，你就按照Java世界IO概念的反方向理解吧。
*/
FSDataOutputStream out = fileSystem.create(new Path(FILE));
FileInputStream in = new FileInputStream("E:/yy.txt");
IOUtils.copyBytes(in, out, 1024, true);
} catch (Exception e) {
e.printStackTrace();
}
//fileSystem.geto
}
private static void remove(FileSystem fileSystem) {
try {// true表示递归删除
fileSystem.delete(new Path(DIR), true);
} catch (IOException e) {
e.printStackTrace();
}
}
private static void mkdir(FileSystem fileSystem) {
try {
fileSystem.mkdirs(new Path(DIR));
} catch (IOException e) {
e.printStackTrace();
}
}
// 创建hadoop的文件操作系统 filesystem实例
private static FileSystem getFileSystem() {
try {
return FileSystem.get(new URI(PATH), new Configuration());
} catch (IOException e) {
e.printStackTrace();
} catch (URISyntaxException e) {
e.printStackTrace();
}
return null;
}
/**
* new Configuration()会自动加载hdfs的
* addDefaultResource("core-default.xml");
addDefaultResource("core-site.xml");
*/
}
