HdfsClient-在本地开发环境使用Java远程连接操作HDFS

最新推荐文章于 2025-05-06 09:20:51 发布
最新推荐文章于 2025-05-06 09:20:51 发布
阅读量1.5k 收藏 1
点赞数
CC 4.0 BY-SA版权
分类专栏： Java 文章标签： hadoop hdfs java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/super_man_1995/article/details/118346649
本文介绍了在本地开发环境中，如何通过Java使用HdfsClient远程连接并操作HDFS，包括pom.xml配置、HdfsClient代码示例以及需要注意的细节，如正确引用Hadoop方法和保持URI与core-site.xml配置一致。此外，还提到了HDFS API接口的使用，展示了创建、删除文件夹和拷贝文件的基本操作。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

一、pom.xml配置

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.lihejia</groupId>
    <artifactId>HDFSClint</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-hdfs</artifactId>
            <version>2.8.1</version>
        </dependency>

        <dependency>
        <groupId>org.apache.hadoop</groupId>
        <artifactId>hadoop-client</artifactId>
        <version>2.8.1</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.30</version>
        </dependency>
    </dependencies>




</project>

二、HdfsClient代码 

package com.lihejia.hdfs;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.conf.Configuration;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;

public class HdfsClient {
    private FileSystem fs;
    @Before
    public void init() throws IOException, URISyntaxException, InterruptedException {
        //连接集群的地址
        URI uri = new URI("hdfs://localhost:9000");

        //创建一个配置文件夹
        Configuration configuration = new Configuration();

        //用户
        String user = "lihejia";

        //获取客户端的对象
        fs = FileSystem.get(uri, configuration, user);

    }

    @After
    public void close() throws IOException {
        //关闭资源
        fs.close();
    }

    @Test
    public void testMkdir() throws IOException {
        //创建文件夹
        fs.mkdirs(new Path("/02jia"));
    }

    @Test
    public void testRemove() throws IOException {
        //删除文件夹
        fs.delete(new Path("/02jia"),true);
    }

    @Test
    public void testCopyFromLocalFile() throws IOException {
        //拷贝本地文件到hdfs
        fs.copyFromLocalFile(new Path("/Users/lihejia/Desktop/Mario0630.txt"),new Path("/"));
    }


}

三、注意点

1、代码中的每个引入的方法记得是hadoop相关的，不要引入错了。

2、URI的地址记得要跟core-site.xml配置文件中保持一致。

譬如配置文件中的hdfs://localhost:9000对应代码中的hdfs的访问地址。

<?xml version="1.0" encoding="UTF-8"?>
<?xml-stylesheet type="text/xsl" href="configuration.xsl"?>


<configuration>
    <property>
        <name>hadoop.tmp.dir</name>
        <value>file:/usr/local/hadoop/tmp</value>
    </property>
    <property>
        <name>fs.defaultFS</name>
        <value>hdfs://localhost:9000</value>
    </property>
</configuration>

四、HDFS的API接口文件

可以参考文件中的方法根据自己需求使用，代码只是设计简单的创建文件夹、删除文件夹、拷贝文件基本操作，其他操作可以具体参考该配置文件API.

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package org.apache.hadoop.fs;

import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Preconditions;
import java.io.Closeable;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.WeakReference;
import java.net.URI;
import java.net.URISyntaxException;
import java.security.PrivilegedExceptionAction;
import java.util.ArrayList;
import java.util.Collection;
import java.util.EnumSet;
import java.util.HashMap;
import java.util.HashSet;
import java.util.IdentityHashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.ServiceConfigurationError;
import java.util.ServiceLoader;
import java.util.Set;
import java.util.Stack;
import java.util.TreeSet;
import java.util.Map.Entry;
import java.util.concurrent.atomic.AtomicLong;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.hadoop.classification.InterfaceAudience.LimitedPrivate;
import org.apache.hadoop.classification.InterfaceAudience.Private;
import org.apache.hadoop.classification.InterfaceAudience.Public;
import org.apache.hadoop.classification.InterfaceStability.Evolving;
import org.apache.hadoop.classification.InterfaceStability.Stable;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.conf.Configured;
import org.apache.hadoop.fs.ContentSummary.Builder;
import org.apache.hadoop.fs.GlobalStorageStatistics.StorageStatisticsProvider;
import org.apache.hadoop.fs.Options.ChecksumOpt;
import org.apache.hadoop.fs.Options.Rename;
import org.apache.hadoop.fs.permission.AclEntry;
import org.apache.hadoop.fs.permission.AclStatus;
import org.apache.hadoop.fs.permission.FsAction;
import org.apache.hadoop.fs.permission.FsPermission;
import org.apache.hadoop.io.MultipleIOException;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.security.AccessControlException;
import org.apache.hadoop.security.Credentials;
import org.apache.hadoop.security.SecurityUtil;
import org.apache.hadoop.security.UserGroupInformation;
import org.apache.hadoop.security.token.Token;
import org.apache.hadoop.util.ClassUtil;
import org.apache.hadoop.util.Progressable;
import org.apache.hadoop.util.ReflectionUtils;
import org.apache.hadoop.util.ShutdownHookManager;
import org.apache.hadoop.util.StringUtils;
import org.apache.hadoop.util.DataChecksum.Type;
import org.apache.htrace.core.TraceScope;
import org.apache.htrace.core.Tracer;

@Public
@Stable
public abstract class FileSystem extends Configured implements Closeable {
    public static final String FS_DEFAULT_NAME_KEY = "fs.defaultFS";
    public static final String DEFAULT_FS = "file:///";
    public static final Log LOG = LogFactory.getLog(FileSystem.class);
    public static final int SHUTDOWN_HOOK_PRIORITY = 10;
    public static final String TRASH_PREFIX = ".Trash";
    static final FileSystem.Cache CACHE = new FileSystem.Cache();
    private FileSystem.Cache.Key key;
    private static final Map<Class<? extends FileSystem>, FileSystem.Statistics> statisticsTable = new IdentityHashMap();
    protected FileSystem.Statistics statistics;
    private Set<Path> deleteOnExit = new TreeSet();
    boolean resolveSymlinks;
    private static final PathFilter DEFAULT_FILTER = new PathFilter() {
        public boolean accept(Path file) {
            return true;
        }
    };
    private static volatile boolean FILE_SYSTEMS_LOADED = false;
    private static final Map<String, Class<? extends FileSystem>> SERVICE_FILE_SYSTEMS = new HashMap();
    private static boolean symlinksEnabled = false;
    private static Configuration conf = null;

    static void addFileSystemForTesting(URI uri, Configuration conf, FileSystem fs) throws IOException {
        CACHE.map.put(new FileSystem.Cache.Key(uri, conf), fs);
    }

    public static FileSystem get(final URI uri, final Configuration conf, String user) throws IOException, InterruptedException {
        String ticketCachePath = conf.get("hadoop.security.kerberos.ticket.cache.path");
        UserGroupInformation ugi = UserGroupInformation.getBestUGI(ticketCachePath, user);
        return (FileSystem)ugi.doAs(new PrivilegedExceptionAction<FileSystem>() {
            public FileSystem run() throws IOException {
                return FileSystem.get(uri, conf);
            }
        });
    }

    public static FileSystem get(Configuration conf) throws IOException {
        return get(getDefaultUri(conf), conf);
    }

    public static URI getDefaultUri(Configuration conf) {
        return URI.create(fixName(conf.get("fs.defaultFS", "file:///")));
    }

    public static void setDefaultUri(Configuration conf, URI uri) {
        conf.set("fs.defaultFS", uri.toString());
    }

    public static void setDefaultUri(Configuration conf, String uri) {
        setDefaultUri(conf, URI.create(fixName(uri)));
    }

    public void initialize(URI name, Configuration conf) throws IOException {
        String scheme;
        if (name.getScheme() != null && !name.getScheme().isEmpty()) {
            scheme = name.getScheme();
        } else {
            scheme = getDefaultUri(conf).getScheme();
        }

        this.statistics = getStatistics(scheme, this.getClass());
        this.resolveSymlinks = conf.getBoolean("fs.client.resolve.remote.symlinks", true);
    }

    public String getScheme() {
        throw new UnsupportedOperationException("Not implemented by the " + this.getClass().getSimpleName() + " FileSystem implementation");
    }

    public abstract URI getUri();

    protected URI getCanonicalUri() {
        return this.canonicalizeUri(this.getUri());
    }

    protected URI canonicalizeUri(URI uri) {
        if (uri.getPort() == -1 && this.getDefaultPort() > 0) {
            try {
                uri = new URI(uri.getScheme(), uri.getUserInfo(), uri.getHost(), this.getDefaultPort(), uri.getPath(), uri.getQuery(), uri.getFragment());
            } catch (URISyntaxException var3) {
                throw new AssertionError("Valid URI became unparseable: " + uri);
            }
        }

        return uri;
    }

    protected int getDefaultPort() {
        return 0;
    }

    protected static FileSystem getFSofPath(Path absOrFqPath, Configuration conf) throws UnsupportedFileSystemException, IOException {
        absOrFqPath.checkNotSchemeWithRelative();
        absOrFqPath.checkNotRelative();
        return get(absOrFqPath.toUri(), conf);
    }

    @Public
    @Evolving
    public String getCanonicalServiceName() {
        return this.getChildFileSystems() == null ? SecurityUtil.buildDTServiceName(this.getUri(), this.getDefaultPort()) : null;
    }

    /** @deprecated */
    @Deprecated
    public String getName() {
        return this.getUri().toString();
    }

    /** @deprecated */
    @Deprecated
    public static FileSystem getNamed(String name, Configuration conf) throws IOException {
        return get(URI.create(fixName(name)), conf);
    }

    private static String fixName(String name) {
        if (name.equals("local")) {
            LOG.warn("\"local\" is a deprecated filesystem name. Use \"file:///\" instead.");
            name = "file:///";
        } else if (name.indexOf(47) == -1) {
            LOG.warn("\"" + name + "\" is a deprecated filesystem name." + " Use \"hdfs://" + name + "/\" instead.");
            name = "hdfs://" + name;
        }

        return name;
    }

    public static LocalFileSystem getLocal(Configuration conf) throws IOException {
        return (LocalFileSystem)get(LocalFileSystem.NAME, conf);
    }

    public static FileSystem get(URI uri, Configuration conf) throws IOException {
        String scheme = uri.getScheme();
        String authority = uri.getAuthority();
        if (scheme == null && authority == null) {
            return get(conf);
        } else {
            if (scheme != null && authority == null) {
                URI defaultUri = getDefaultUri(conf);
                if (scheme.equals(defaultUri.getScheme()) && defaultUri.getAuthority() != null) {
                    return get(defaultUri, conf);
                }
            }

            String disableCacheName = String.format("fs.%s.impl.disable.cache", scheme);
            return conf.getBoolean(disableCacheName, false) ? createFileSystem(uri, conf) : CACHE.get(uri, conf);
        }
    }

    public static FileSystem newInstance(final URI uri, final Configuration conf, String user) throws IOException, InterruptedException {
        String ticketCachePath = conf.get("hadoop.security.kerberos.ticket.cache.path");
        UserGroupInformation ugi = UserGroupInformation.getBestUGI(ticketCachePath, user);
        return (FileSystem)ugi.doAs(new PrivilegedExceptionAction<FileSystem>() {
            public FileSystem run() throws IOException {
                return FileSystem.newInstance(uri, conf);
            }
        });
    }

    public static FileSystem newInstance(URI uri, Configuration conf) throws IOException {
        String scheme = uri.getScheme();
        String authority = uri.getAuthority();
        if (scheme == null) {
            return newInstance(conf);
        } else {
            if (authority == null) {
                URI defaultUri = getDefaultUri(conf);
                if (scheme.equals(defaultUri.getScheme()) && defaultUri.getAuthority() != null) {
                    return newInstance(defaultUri, conf);
                }
            }

            return CACHE.getUnique(uri, conf);
        }
    }

    public static FileSystem newInstance(Configuration conf) throws IOException {
        return newInstance(getDefaultUri(conf), conf);
    }

    public static LocalFileSystem newInstanceLocal(Configuration conf) throws IOException {
        return (LocalFileSystem)newInstance(LocalFileSystem.NAME, conf);
    }

    public static void closeAll() throws IOException {
        CACHE.closeAll();
    }

    public static void closeAllForUGI(UserGroupInformation ugi) throws IOException {
        CACHE.closeAll(ugi);
    }

    public Path makeQualified(Path path) {
        this.checkPath(path);
        return path.makeQualified(this.getUri(), this.getWorkingDirectory());
    }

    @Private
    public Token<?> getDelegationToken(String renewer) throws IOException {
        return null;
    }

    @Public
    @Evolving
    public Token<?>[] addDelegationTokens(String renewer, Credentials credentials) throws IOException {
        if (credentials == null) {
            credentials = new Credentials();
        }

        List<Token<?>> tokens = new ArrayList();
        this.collectDelegationTokens(renewer, credentials, tokens);
        return (Token[])tokens.toArray(new Token[tokens.size()])
最低0.47元/天 解锁文章

200万优质内容无限畅学
hdfs-client 客户端连接
qq_36012085的博客
04-04 870
在pom.xml中导入相关依赖包：hadoop_hdfs,hadoop_common,hadoop_client。在resources中创建log4j.properties文件控制日志数量。在maven resporitry官网。切记：本地目录不能带中文名字会出错。4.在idle创建maven项目。在web_url中验证是否创建。给hdfs目录所有权限可读可写。也可以导入相关日志管理。在项目中创建Java。
JAVA怎么连接华为的HDFS系统_Java使用连接池管理Hdfs连接
weixin_32009121的博客
02-23 378
记录一下Java API 连接hadoop操作hdfs的实现流程(使用连接池管理)。以前做过这方面的开发，本来以为不会有什么问题，但是做的还是坑坑巴巴，内心有些懊恼，记录下这烦人的过程，警示自己切莫眼高手低！一：引入相关jar包如下org.apache.hadoophadoop-common2.8.2org.apache.hadoophadoop-hdfs2.8.2org.apache.commo...
HdfsClient.java
07-23
一个hdfsclient的操作类，如果有报错，在idea开发工具中File -> Project Struct... -> Libraies -> 点击绿色的加号 -> Java -> 找到 IDEA 安装路径下的 Lib 中的junit-4.12 -> 确定完就行了，点击OK就出去了
java 远程 hdfs_java远程操作HDFS
weixin_39934063的博客
03-07 437
java远程操作hadoop的分布式文件系统hdfs需要导入的hadoop的jar包hadoop解压包中有所需的jar包hadoop-2.5.2/share/hadoop/common/hadoop-common-2.5.2.jarhadoop-2.5.2/share/hadoop/common/lib/*.jar(lib下的全部jar包)hadoop-2.5.2/share/hadoop/hdf...
HDFS 客户端操作教程
最新发布
xiaoyu070321的博客
05-06 560
类代码，详细说明 HDFS 文件系统常见操作。代码通过 Hadoop 的。API 实现文件上传、下载、元数据查看等功能。路径权限不足或本地目录不存在时会抛出。释放连接资源，推荐使用。
client 操作hdfs
张斌斌的博客
07-18 3593
1.构建环境 去除编译文件share目录下所有xxxsources.jar和xxxtests.jar，将剩下的jar copy到eclispe中 2.配置hadoop环境变量 注：测试hadoop-version报错，jdk为默认路径下，需修改hadoop-env.cmd下 set JAVA_HOME=C:\PROGRA~1\Java\jdk1.8...
分布式存储系统-HDFS.docx
10-01
在Eclipse中开发HDFS应用程序，需要安装Hadoop的Eclipse插件，并配置好Hadoop的相关环境变量，以便在IDE中编写、调试和运行Java程序，利用HDFS API进行数据操作。 ### Java接口及常用API HDFS提供了丰富的Java API...
intellij idea本地配置连接远程hadoop集群开发
热门推荐
孤城长烟
11-07 1万+
自己研究大数据一年多了，虽然技术上有很多提高，但是有个问题就是一直没法使用本地联调集群，每次都是写完打包放到集群执行。最近发现可以本地直接连接远程联调，大大提高了开发效率，分享一下。 1、下载hadoop，配置到本地环境变量中，路径中最好不要有空格或下划线 环境变量： 2、修改项目的pom.xml &amp;lt;dependency&amp;gt; &amp;lt;groupId&amp;gt;org.apache....
深入理解WebHDFS Java客户端使用与API
从给定的信息来看，这个文件夹名为“webhdfs-java-client-master”，而标题和描述都相同，没有提供额外的说明。根据标签，我们可以推断出这个项目与“WebHDFS”，“Java”，和“Hadoop API”相关。由于文件名列表仅...
使用Java API访问Hdfs服务器
我玩的很开心的博客
06-30 5718
使用Java API访问Hdfs服务器
hdfsclient
09-18
hadoop的hdfs的工具类，基于hadoop的2.6.4的开发的工具类，hadoop的namenode的ha模式过几天上传
HDFS之Java客户端操作
优快云2022博客之星Top39；华为云博主7&，优快云、稀土掘金、微信公众号、阿里云开发者社区、腾讯云社区、博客园、知乎、51CTO同名博主WHYBIGDATA；
06-27 2343
HDFS之Java客户端操作
hdfs client api
qq_38250124的博客
03-23 369
public class HdfsClient { FileSystem fs = null; @Before public void init() throws Exception { Configuration conf = new Configuration(); // conf.set("fs.defaultFS","hdfs://m
JavaClient With HDFS
难得糊涂
04-17 306
在使用Java创建连接HDFS的客户端时,可以设置很多参数,具体有哪些参数呢,只要是在部署HDFS服务中可以设置的参数,都是可以在连接的时候设置. 我没有去验证所有的配置是否都可以验证,只是推测cuiyaonan2000@163.com。
Java远程操作HDFS文件系统
一直在努力的小渣渣
05-30 4349
目标：通过Java编程实现远程HDFS文件系统的增、删、改、查，并且解释原理。 一、准备工作 集群：搭建Hadoop集群，并且启动HDFS。详细过程可以参考：Hadoop-2.5.1安装步骤及异常处理 二、创建Maven工程 选择创建工程： 选择JDK版本，并勾选"create from archetype"选项，千万不要手贱选择“quick start”，选快速开启的话，创建的maven工程中...
Hadoop之HDFS客户端------java实现
Star-Technology
05-12 1189
1.HDFS—-java代码加载配置public void setup() throws Exception{ config = new Configuration(); fs = FileSystem.get(config); }2.HDFS——java实现在HDFS上创建文件夹public void mkdir() throws Exception{
window本机远程连接虚拟机的hdfs
e5bb96的博客
12-20 2624
服务器ip：192.168.66.128 测试主机能否连接虚拟机 ping 192.168.66.128 修改虚拟机hadoop中core-site.xml vim ./etc/hadoop/core-site.xml <property> <name>fs.defaultFS</name> <value>hdfs://192.168.66.128:9000</value> </property> 启动hadoop
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值