hdfs连接池（通过commons.pool2 对象池管理）

最新推荐文章于 2023-03-12 15:05:57 发布
最新推荐文章于 2023-03-12 15:05:57 发布
阅读量721 收藏 3
点赞数 2
分类专栏： hdfs Java 文章标签： hdfs java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41085114/article/details/114435840
版权
Java 同时被 2 个专栏收录
36 篇文章 1 订阅
订阅专栏
hdfs
1 篇文章 0 订阅
订阅专栏

代码：

1.Hdfs

package com.boot.base.common.util.hdfs;

import com.boot.base.common.util.LogUtil;
import com.google.common.collect.Lists;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.*;
import org.apache.hadoop.io.IOUtils;

import java.io.*;
import java.net.URI;
import java.util.List;

/**
 * @author Admin
 *
 * @date 2020/5/25 9:46
 */
public class Hdfs {

    /** 写hdfs缓冲区大小，单位：byte */
    private final int HDFS_OUT_BUFF_SIZE = 1024*1024*4;

    private FileSystem fs;
    private final String url;
    private final String userName;

    public Hdfs(String url, String userName) {
        this.url = url;
        this.userName = userName;
    }

    public void open() {
        try {
            Configuration conf = new Configuration();
            fs = FileSystem.get(new URI(url), conf, userName);
            LogUtil.info("创建[Hadoop FileSystem]实例成功");
        } catch (Exception e) {
            LogUtil.error("创建[Hadoop FileSystem]实例失败", e);
        }
    }

    public void close() {
        try {
            if (null != fs) {
                fs.close();
                LogUtil.info("关闭[Hadoop FileSystem]实例成功");
            }
        } catch(Exception e) {
            LogUtil.error("关闭[Hadoop FileSystem]实例失败", e);
        }
    }

    public boolean isConnected() throws IOException {
        return fs.exists(new Path("/"));
    }

    public boolean exists(String path) throws IOException {
        return fs.exists(new Path(path));
    }

    public Path getPath(String path) throws IOException {
        return new Path(path);
    }

    public FileStatus getFileStatus(String path) throws IOException {
        return fs.getFileStatus(new Path(path));
    }

    public FileStatus[] listFileStatus(String path) throws IOException {
        return fs.listStatus(new Path(path));
    }

    public ContentSummary getContentSummary(String path) throws IOException {
        ContentSummary contentSummary = null;
        Path hdfsPath = new Path(path);
        if (fs.exists(hdfsPath)) {
            contentSummary = fs.getContentSummary(hdfsPath);
        }
        return contentSummary;
    }

    public List<String> listFileName() throws IOException {
        List<String> res = Lists.newArrayList();
        FileStatus[] fileStatuses = fs.listStatus(new Path("/"));
        for (FileStatus fileStatus : fileStatuses){
            res.add(fileStatus.getPath() +"：类型--"+ (fileStatus.isDirectory()? "文件夹":"文件"));
        }
        return res;
    }

    /**
     * 获取指定目录下的所有文件名
     *
     * @param path
     * @return
     * @throws IOException
     */
    public List<String> listFileName(String path) throws IOException {
        List<String> res = Lists.newArrayList();
        FileStatus[] fileStatuses = fs.listStatus(new Path(path));
        for (FileStatus fileStatus : fileStatuses){
            res.add(fileStatus.getPath().toUri().getPath());
        }
        return res;
    }

    /**
     * 删除文件
     *
     * @param path
     * @return
     * @throws IOException
     */
    public boolean deleteFile(String path) throws IOException {
        return fs.delete(new Path(path), false);
    }

    public String uploadFileByStream(InputStream in, String path) throws Exception {
        OutputStream os = fs.create(new Path(path));
        IOUtils.copyBytes(in, os, HDFS_OUT_BUFF_SIZE, true);
        return path;
    }

    public InputStream downloadFileByStream(String path) throws Exception {
        return fs.open(new Path(path));
    }

    public InputStream downloadFileByStream(Path path) throws Exception {
        return fs.open(path);
    }

}

2.HdfsFactory

package com.boot.base.common.util.hdfs;

import org.apache.commons.pool2.PooledObject;
import org.apache.commons.pool2.PooledObjectFactory;
import org.apache.commons.pool2.impl.DefaultPooledObject;
import java.io.IOException;

/**
 * @author admin
 * @date 2020/5/25 9:45
 */
public class HdfsFactory implements PooledObjectFactory<Hdfs> {

    private final String url;
    private final String userName;

    public HdfsFactory(String url, String userName){
        this.url = url;
        this.userName = userName;
    }

    @Override
    public PooledObject<Hdfs> makeObject() throws Exception {
        Hdfs hdfs = new Hdfs(url, userName);
        hdfs.open();
        return new DefaultPooledObject<Hdfs>(hdfs);
    }

    @Override
    public void destroyObject(PooledObject<Hdfs> pooledObject) throws Exception {
        Hdfs hdfs = pooledObject.getObject();
        hdfs.close();
    }

    @Override
    public boolean validateObject(PooledObject<Hdfs> pooledObject) {
        Hdfs hdfs = pooledObject.getObject();
        try {
            return  hdfs.isConnected();
        } catch (IOException e) {
            e.printStackTrace();
            return false;
        }
    }

    @Override
    public void activateObject(PooledObject<Hdfs> pooledObject) throws Exception {

    }

    @Override
    public void passivateObject(PooledObject<Hdfs> pooledObject) throws Exception {

    }
}

3.HdfsPoolConfig

package com.boot.base.config.hdfs;

import com.boot.base.common.util.hdfs.HdfsClient;
import com.boot.base.common.util.hdfs.HdfsFactory;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @author admin
 * @date 2020/5/25 9:42
 */
@Configuration
public class HdfsPoolConfig extends GenericObjectPoolConfig {

    @Value("${hdfs.url}")
    private String url;

    @Value("${hdfs.userName}")
    private String userName;

    @Value("${hdfs.pool.maxTotal}")
    private String maxTotal;

    @Value("${hdfs.pool.maxIdle}")
    private String maxIdle;

    @Value("${hdfs.pool.minIdle}")
    private String minIdle;

    @Value("${hdfs.pool.maxWaitMillis}")
    private String maxWaitMillis;

    @Value("${hdfs.pool.minEvictableIdleTimeMillis}")
    private String minEvictableIdleTimeMillis;

    @Value("${hdfs.pool.timeBetweenEvictionRunsMillis}")
    private String timeBetweenEvictionRunsMillis;

    @Bean(initMethod = "init", destroyMethod = "stop")
    public HdfsClient HdfsClient(){
        HdfsClient client = new HdfsClient();
        return client;
    }

    @Bean
    public HdfsPoolConfig HdfsPoolConfig(){
        HdfsPoolConfig hdfsPoolConfig = new HdfsPoolConfig();
        hdfsPoolConfig.setMaxTotal(Integer.valueOf(maxTotal));
        hdfsPoolConfig.setMaxIdle(Integer.valueOf(maxIdle));
        hdfsPoolConfig.setMinIdle(Integer.valueOf(minIdle));
        hdfsPoolConfig.setMaxWaitMillis(Long.parseLong(maxWaitMillis));
        hdfsPoolConfig.setMinEvictableIdleTimeMillis(Long.parseLong(minEvictableIdleTimeMillis));
        hdfsPoolConfig.setTimeBetweenEvictionRunsMillis(Long.parseLong(timeBetweenEvictionRunsMillis));
        return hdfsPoolConfig;
    }

    @Bean
    public HdfsFactory HdfsFactory(){
        return new HdfsFactory(url, userName);
    }

}

4.HdfsPool

package com.boot.base.common.util.hdfs;

import org.apache.commons.pool2.PooledObjectFactory;
import org.apache.commons.pool2.impl.AbandonedConfig;
import org.apache.commons.pool2.impl.GenericObjectPool;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;

/**
 * @author admin
 * @date 2020/5/25 9:45
 */
public class HdfsPool extends GenericObjectPool<Hdfs> {

    public HdfsPool(PooledObjectFactory<Hdfs> factory) {
        super(factory);
    }

    public HdfsPool(PooledObjectFactory<Hdfs> factory, GenericObjectPoolConfig<Hdfs> config) {
        super(factory, config);
    }

    public HdfsPool(PooledObjectFactory<Hdfs> factory, GenericObjectPoolConfig<Hdfs> config, AbandonedConfig abandonedConfig) {
        super(factory, config, abandonedConfig);
    }
}

5.HdfsClient

package com.boot.base.common.util.hdfs;

import com.boot.base.common.exception.WorkException;
import com.boot.base.common.util.FileUtil;
import com.boot.base.common.util.LogUtil;
import com.boot.base.config.hdfs.HdfsPoolConfig;
import com.boot.dto.salesLeads.DeptSignForecastExportModel;
import org.apache.hadoop.fs.ContentSummary;
import org.apache.hadoop.fs.FileStatus;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.net.URL;
import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

/**
 * 封装了从hdfs上传、下载文件等操作的工具类
 *
 * @author admin
 * @date 2020/5/25 9:44
 */
public class HdfsClient {

    private HdfsPool hdfsPool;

    @Autowired
    private HdfsPoolConfig hdfsPoolConfig;

    @Autowired
    private HdfsFactory hdfsFactory;

    public void init() {
        hdfsPool = new HdfsPool(hdfsFactory, hdfsPoolConfig);
    }

    public long getPathSize(String path) throws Exception {
        Hdfs hdfs = null;
        try {
            hdfs = hdfsPool.borrowObject();
            return hdfs.getContentSummary(path).getLength();
        } catch (Exception e) {
            LogUtil.error("[HDFS]获取路径大小失败", e);
            throw e;
        } finally {
            if (null != hdfs) {
                hdfsPool.returnObject(hdfs);
            }
        }
    }

    public List<String> getBasePath() {
        Hdfs hdfs = null;
        try {
            hdfs = hdfsPool.borrowObject();
            return hdfs.listFileName();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        } finally {
            if (null != hdfs) {
                hdfsPool.returnObject(hdfs);
            }
        }
    }

    /**
     * 获取指定目录下的所有文件名
     *
     * @param path
     * @return
     */
    public List<String> getFileNameList(String path) {
        Hdfs hdfs = null;
        try {
            hdfs = hdfsPool.borrowObject();
            return hdfs.listFileName(path);
        } catch (Exception e) {
            LogUtil.error("获取hdfs指定目录下的所有文件名异常：", e);
            return new ArrayList<>();
        } finally {
            if (null != hdfs) {
                hdfsPool.returnObject(hdfs);
            }
        }
    }

    /**
     * 删除文件
     *
     * @param path 文件或文件夹绝对路径
     * @return
     * @throws WorkException
     */
    public boolean deleteFile(String path) throws WorkException {
        Hdfs hdfs = null;
        try {
            hdfs = hdfsPool.borrowObject();
            return hdfs.deleteFile(path);
        } catch (Exception e) {
            LogUtil.error("删除hdfs文件异常：", e);
            throw new WorkException("删除文件异常！");
        } finally {
            if (null != hdfs) {
                hdfsPool.returnObject(hdfs);
            }
        }
    }

    /**
     * 通过流的方式上传文件
     *
     * @param in   文件流
     * @param path 被上传的hdfs路径
     * @return path 被上传的hdfs路径
     * @throws Exception
     */
    public String uploadFileByStream(InputStream in, String path) throws Exception {
        Hdfs hdfs = null;
        try {
            hdfs = hdfsPool.borrowObject();
            return hdfs.uploadFileByStream(in, path);
        } finally {
            if (null != hdfs) {
                hdfsPool.returnObject(hdfs);
            }
        }
    }

    /**
     * 通过流的方式下载文件到浏览器
     *
     * @param path HDFS中文件的路径
     * @throws Exception
     */
    public void downloadFileByStream(String path) throws Exception {
        Hdfs hdfs = null;
        OutputStream os = null;
        InputStream in = null;
        try {
            hdfs = hdfsPool.borrowObject();
            in = hdfs.downloadFileByStream(path);
            String fileName = new Path(path).getName();
            int index;
            HttpServletResponse response = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getResponse();
            response.setCharacterEncoding("UTF-8");
            response.setContentType("application/octet-stream; charset=utf-8");
            response.setHeader("Content-disposition", "attachment;filename=" + URLEncoder.encode(fileName, "UTF-8"));
            os = response.getOutputStream();
            byte[] buffer = new byte[in.available()];
            while ((index = in.read(buffer)) != -1) {
                os.write(buffer, 0, index);
                os.flush();
            }
        } finally {
            if (null != hdfs) {
                hdfsPool.returnObject(hdfs);
            }
            if (os != null) {
                os.close();
            }
            if (in != null) {
                in.close();
            }
        }
    }

    /**
     * 下载单个文件到浏览器
     *
     * @param filePath
     * @param request
     * @param response
     * @return
     * @throws Exception
     */
    public String downloadSingleFile(String filePath, HttpServletRequest request, HttpServletResponse response) throws Exception {
        Hdfs hdfs = null;
        InputStream in = null;
        BufferedInputStream br = null;
        OutputStream os = null;
        try {
            hdfs = hdfsPool.borrowObject();
            if (!hdfs.exists(filePath)) {
                throw new WorkException("hdfs上的文件：" + filePath + "不存在！");
            }
            Path hdfsPath = hdfs.getPath(filePath);
            ContentSummary hdfsContentSummary = hdfs.getContentSummary(filePath);
            in = new BufferedInputStream(hdfs.downloadFileByStream(filePath));
            byte[] buffer = new byte[in.available()];
            in.read(buffer);
            // 解决文件名乱码问题，获取浏览器类型，转换对应文件名编码格式，IE要求文件名必须是utf-8, FireFox要求是iso-8859-1编码
            String agent = request.getHeader("user-agent");
            String fileName = hdfsPath.getName();
            if (agent.contains("FireFox")) {
                fileName = new String(fileName.getBytes("UTF-8"), "iso-8859-1");
            } else {
                fileName = URLEncoder.encode(fileName, "UTF-8");
            }
            // 清空response
            response.reset();
            response.setCharacterEncoding("UTF-8");
            // 设置下载文件的mineType，告诉浏览器下载文件类型
            String mineType = request.getServletContext().getMimeType(fileName);
            response.setContentType(mineType);
            response.addHeader("Content-Disposition", "attachment;filename=" + fileName);
            response.addHeader("Content-Length", "" + hdfsContentSummary.getLength());
            os = new BufferedOutputStream(response.getOutputStream());
            os.write(buffer);
            os.flush();
        } finally {
            if (null != hdfs) {
                hdfsPool.returnObject(hdfs);
            }
            if (os != null) {
                os.close();
            }
            if (br != null) {
                br.close();
            }
            if (in != null) {
                in.close();
            }
        }
        return filePath;
    }

    /**
     * 下载同一个目录下的多个文件到浏览器
     *
     * @param filePath 被下载的多个文件所在的目录
     * @param fileNameList 需要下载的文件名
     * @param response
     * @return
     * @throws Exception
     */
    public String downloadMultipleFile(String filePath, List<String> fileNameList, String zipFileName, HttpServletResponse response) throws Exception {
        InputStream in = null;
        Hdfs hdfs = hdfsPool.borrowObject();
        if (!hdfs.exists(filePath)) {
            LogUtil.getLogger().error("hdfs上的文件目录：" + filePath + "不存在！");
            throw new WorkException("所下载文件在文件服务器中不存在，请检查文件是否被误删！");
        }
        // 打包为压缩文件写入浏览器
        response.setContentType("application/*");
        response.setHeader("content-disposition", "attachment;filename=" + URLEncoder.encode( zipFileName + ".zip", "utf-8"));
        response.setCharacterEncoding("UTF-8");
        OutputStream os = new BufferedOutputStream(response.getOutputStream());
        ZipOutputStream zos = null;
        ByteArrayOutputStream bos;
        try {
            zos = new ZipOutputStream(os);
            FileStatus[] fsts = hdfs.listFileStatus(filePath);
            for (FileStatus fileStatus : fsts) {
                String fileName = fileStatus.getPath().getName();
                if (fileStatus.isFile() && fileNameList.contains(fileName)) {
                    in = new BufferedInputStream(hdfs.downloadFileByStream(fileStatus.getPath()));
                    byte[] buffer = new byte[in.available()];
                    in.read(buffer);
                    zos.putNextEntry(new ZipEntry(fileName));
                    bos = new ByteArrayOutputStream();
                    bos.write(buffer);
                    bos.writeTo(zos);
                    zos.closeEntry();
                }
            }
        } finally {
            try {
                if (null != hdfs) {
                    hdfsPool.returnObject(hdfs);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            try {
                if (zos != null) {
                    zos.flush();
                    zos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (in != null) {
                    in.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return filePath;
    }

    /**
     * 下载单个文件并返回其文件流
     *
     * @param filePath
     * @return
     * @throws Exception
     */
    public InputStream downloadSingleFileByStream(String filePath) throws Exception {
        Hdfs hdfs = null;
        try {
            hdfs = hdfsPool.borrowObject();
            if (!hdfs.exists(filePath)) {
                LogUtil.getLogger().error("文件：" + filePath + "不存在！");
                throw new WorkException("文件不存在！");
            }
            return hdfs.downloadFileByStream(filePath);
        } finally {
            if (null != hdfs) {
                hdfsPool.returnObject(hdfs);
            }
        }
    }

    public void stop() {
        hdfsPool.close();
    }

}

配置：

hdfs.url=hdfs://10.10.101.40:8020
hdfs.userName=admin
hdfs.size=50
#池化hdfs配置:
#连接池中最大连接数,默认为8
hdfs.pool.maxTotal=15
#连接池中最大空闲的连接数，默认也为8
hdfs.pool.maxIdle=8
#连接池中最少空闲的连接数，默认为0
hdfs.pool.minIdle=0
#当连接池资源耗尽时，等待时间，超出则抛异常，默认为-1即永不超时
hdfs.pool.maxWaitMillis=1800000
#连接空闲的最小时间，达到此值后空闲连接将可能会被移除。默认为1000L*60L*30L
hdfs.pool.minEvictableIdleTimeMillis=60000
#空闲连接检测线程检测的周期，毫秒数。如果为负值，表示不运行检测线程。默认为-1
hdfs.pool.timeBetweenEvictionRunsMillis=300000

参考：

commons.pool2 对象池的使用

BaseObjectPoolConfig

king-hero
关注
专栏目录
JAVA怎么连接华为的HDFS系统_Java使用连接池管理Hdfs连接
weixin_32009121的博客
02-23 327
记录一下Java API 连接hadoop操作hdfs的实现流程(使用连接池管理)。以前做过这方面的开发，本来以为不会有什么问题，但是做的还是坑坑巴巴，内心有些懊恼，记录下这烦人的过程，警示自己切莫眼高手低！一：引入相关jar包如下org.apache.hadoophadoop-common2.8.2org.apache.hadoophadoop-hdfs2.8.2org.apache.commo...
Java hdfs连接池_ZooKeeper实现HA HDFS(示例代码)
weixin_39595931的博客
03-02 236
单节点NameNode存在问题：NameNode宕机，metadata数据消失；单节点出现故障，如何进行故障转移？如果增加一个NameNode节点，会出现脑裂问题(一个集群有多个管理者)，如何解决？ZK搭建高可用(HA High Aliavble)HDFS集群原理QJM(Quorum Jouranl Manager)是Hadoop转为为NameNode共享存储开发的组件。其集群运行一组Journa...
连接池的实现
weixin_34199405的博客
09-15 151
1. 背景 工程架构中有很多访问下游的需求，下游包括但不限于服务/数据库/缓存，其通讯步骤为： （1）与下游建立一个连接 （2）通过这个连接，收发请求 （3）交互结束，关闭连接，释放资源 2. 为什么需要连接池？ 当并发量很低的时候，建立连接和关闭连接的过程是没问题的，但当服务单机QPS达到几百、几千的时候，建立连接和销毁连接就会成为瓶颈，此时如何优化？ 结论很简单，服务启动的时候，...
HDFS 连接缓存
weixin_30528371的博客
08-16 98
HDFS 连接缓存 HDFS 连接获取时注意事项： 使用FileSystem.get(Configuration conf) 方式来获取FileSystem，得到的将是一个单利对象。 该方式默认从缓存中取出一个连接。在多线程环境下可能造成FileSystem...
困惑了多少个中午，终于解决了：通过java连接hdfs的问题
Greahow的博客
09-21 2116
困惑了多少个中午，终于解决了：通过java连接hdfs的问题 ♠ ♥ ♦ ♣ 该文章仅为平时的笔记，非商用，如有侵权请联系博主删除 ♣ ♦ ♥ ♠ 之前用java连接hdfs时（提交到集群上跑），总会报错：Call From xxxxx to xxxxx failed on connection exception: java.net.ConnectException: Connection re...
commons.pool2 对象池的使用
04stone37
01-06 1084
maven依赖 &lt;dependency&gt; &lt;groupId&gt;org.apache.commons&lt;/groupId&gt; &lt;artifactId&gt;commons-pool2&lt;/artifactId&gt; &lt;version&gt;2.3&lt;/version&gt; &lt;/dependency&g
Hadoop-HDFS详解与HA，完全分布式集群搭建(细到令人发指的教程)
wudidahuanggua的博客
09-17 3385
对HDFS细致到腋毛的讲解，包括HA，完全分布式集群搭建，以及让你打瞌睡的理论知识！
java连接oracle数据库jar包_jdbc连接oracle数据库jar包
weixin_33258874的博客
02-13 3540
java学习：jdbc连接示例java中最常用的数据库连接技术就是JDBC。目前几乎所有的主流数据库都提供了相应的jdbc驱动，可以简单理解为.net中的数据库客户端dll，.net中如果对于netframework默认不支持的数据库(比如sqllite,mysql之类)，就必须要下载专门的数据库客户端dll文件，在vs.n...文章杨俊明2012-11-03820浏览量weblogic配置sql...
达梦数据源配置_达梦数据库的连接配置
weixin_39902107的博客
12-19 4438
1.建立基本的JDBC连接JDBC(Java Database Connectivity)是Java应用程序与数据库的接口规范，旨在让各数据库开发商为Java程序员提供标准的数据库应用程序编程接口(API)。JDBC定义了一个跨数据库、跨平台的通用SQL数据库API。DM JDBC 3.0驱动程序符合SUN JDBC3.0标准，兼容DM JDBC 2.0。DM JDBC驱动程序是DM数据库的JDB...
调用java api 访问HDFS
zhangt85的专栏
12-17 1022
依赖 org.apache.hadoop hadoop-client 2.6.0 上传文件 /** * 上传文件到hdfs系统 * 伪分布方式启动下的实现 * @param s 源文件 * @param d 目标路径 * @throws IOException * @see [类、类#方法、类#成员]
使用JAVA中的动态代理实现数据库连接池
01-20
数据库连接池在编写应用服务是经常需要用到的模块，太过频繁的连接数据库对服务性能来讲是一个瓶颈，使用缓冲池技术可以来消除这个瓶颈。我们可以在互联网上找到很多关于数据库连接池的源程序，但是都发现这样一个共同的问题：这些连接池的实现方法都不同程度地增加了与使用者之间的耦合度。很多的连接池都要求用户通过其规定的方法获取数据库的连接，这一点我们可以理解，毕竟目前所有的应用服务器取数据库连接的方式都是这种方式实现的。但是另外一个共同的问题是，它们同时不允许使用者显式的调用Connection.close()方法，而需要用其规定的一个方法来关闭连接。这种做法有两个缺点： 　　第一：改变了用户使用习惯，增
BigData-06：HDFS底层原理：代理对象和RPC
feiyan的博客
02-28 318
一、HDFS底层的原理 1、RPC：remote proceduer call 远程过程调用（协议） 2、Java的动态代理对象 （*）如果一个类的名字前面有$，表示这是一个代理对象 （*）是一种包装设计模式 （*）可以增强类的功能 （*）举例：Java的动态代理对象应用场景（典型：数据库连接池） 二、分析WordCount数据处理过程 WordCount实例： package d...
java操作hdfs
赶路人儿
04-14 1039
在eclipse中创建一个java工程，然后导入hadoop中的7个jar包(如图)；如果为了方便调试hadoop源码，可以关联到hadoop的源码。 引入hadoop安装包中的7个jar 关联hadoop源码： 1、使用URL的方式读取hdfs中的数据，这种方式和使用浏览器查看hdfs中的数据一样；缺点是只能读取，不能上传、删除等： public st
大数据笔记（六）——HDFS的底层原理：JAVA动态代理和RPC
weixin_30271335的博客
02-28 137
一、Java的动态代理对象 实现代码如下： 　　1.接口类MyService package hdfs.proxy; public interface MyService { public void method1(); public void method2(); } 　　2.接口实现类MyServiceImpl ...
多线程环境下HDFS的FileSystem使用踩坑
打酱油的葫芦娃
04-02 8263
最近用户反映项目现场某些Spark服务会莫名宕掉，作为组内的救火小王子，急速远程到现场服务器排查相关问题。 打开宕掉服务的日志，发现该服务"遗言"如下: 23:46:02.441 [Thread-3] INFO o.a.spark.storage.DiskBlockManager - Shutdown hook called 23:46:02.441 [dispatcher-event-loop...
Java使用连接池管理Hdfs连接
weixin_30687811的博客
05-20 2688
记录一下Java API 连接hadoop操作hdfs的实现流程（使用连接池管理）。 以前做过这方面的开发，本来以为不会有什么问题，但是做的还是坑坑巴巴，内心有些懊恼，记录下这烦人的过程，警示自己切莫眼高手低！ 一：引入相关jar包如下 <dependency> <groupId>org.apache.hadoop<...
commons-pool与commons-pool2连接池(Hadoop连接池)
weixin_30478757的博客
10-15 317
commons-pool和commons-pool2是用来建立对象池的框架，提供了一些将对象池化必须要实现的接口和一些默认动作。对象池化之后可以通过pool的概念去管理其生命周期，例如对象的创建，使用，销毁等。例如我们通常使用的连接池，连接池可以有效管理连接的数量和状态，保证连接资源的情况而且避免并发场景下连接的频繁建立和释放。 我们这里来讲述如何使用commons-pool2来池化对象。我们以...
hadoop表连接
cp1002327672的博客
02-08 481
hadoop表连接
FastDFS 介绍
最新发布
踩踩踩从踩的博客
03-12 1094
本篇文章会介绍FastDFS是什么，具有什么功能；FastDFS服务端有的角色，来实现这些功能；当然也涉及到集群，以及 负载均衡；使用FastDFS很容易搭建一套高性能的文件服务器集群提供文件上传、下载等服务。作为文件存储的中间件 ，我们怎么去使用它。FastDFS是一个开源的轻量级分布式文件系统，它对文件进行管理，功能包括：文件存储、文件同步、文件访问（文件上传、文件下载）等，解决了大容量存储和负载均衡的问题。特别适合以文件为载体的在线服务，如相册网站、视频网站等等。
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值