devbox
IT小白
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

FastDFS连接池实现文件上传并监控TrackerServer心跳_fastdfs 监控

作者：IT小白 | 2024-03-01 01:11:52

赞

踩

fastdfs 监控

前言：

        在使用fastDFS文件存储的时候，使用过程中会时不时出现 connect timed out，一部分原因是因为配置。

        因此为应对此场景，创建连接池进行心跳监控保证长链接。

1.创建fastdfs连接池：

  1. /**
  2.  * @Description: fastdfs连接池
  3.  * @version 1.0
  4.  * @Description
  5.  */
  6. public class ConnectionPool {
  7.     private static final Logger LOGGER = LoggerFactory
  8.             .getLogger(ConnectionPool.class);
  9.     /**
  10.      * 空闲的连接池
  11.      */
  12.     private LinkedBlockingQueue<TrackerServer> idleConnectionPool = null;
  13.     /**
  14.      * 连接池默认最小连接数
  15.      */
  16.     private long minPoolSize = 10;
  17.     /**
  18.      * 连接池默认最大连接数
  19.      */
  20.     private long maxPoolSize = 30;
  21.     /**
  22.      * 当前创建的连接数
  23.      */
  24.     private volatile long nowPoolSize = 0;
  25.     /**
  26.      * 默认等待时间（单位：秒）
  27.      */
  28.     private long waitTimes = 1200;
  29.     /**
  30.      * fastdfs客户端创建连接默认1次
  31.      */
  32.     private static final int COUNT = 2;
  33.  
  34.     /**
  35.      * 默认构造方法
  36.      */
  37.     public ConnectionPool(long minPoolSize, long maxPoolSize, long waitTimes) {
  38.         String logId = UUID.randomUUID().toString();
  39.         LOGGER.info("[线程池构造方法(ConnectionPool)][" + logId
  40.                 + "][默认参数：minPoolSize=" + minPoolSize + ",maxPoolSize="
  41.                 + maxPoolSize + ",waitTimes=" + waitTimes + "]");
  42.         this.minPoolSize = minPoolSize;
  43.         this.maxPoolSize = maxPoolSize;
  44.         this.waitTimes = waitTimes;
  45.         /** 初始化连接池 */
  46.         poolInit(logId);
  47.         /** 注册心跳 */
  48.         HeartBeat beat = new HeartBeat(this);
  49.         beat.beat();
  50.     }
  51.  
  52.     /**
  53.      * @Description: 连接池初始化 (在加载当前ConnectionPool时执行) 1).加载配置文件 2).空闲连接池初始化；
  54.      * 3).创建最小连接数的连接，并放入到空闲连接池；
  55.      */
  56.     private void poolInit(String logId) {
  57.         try {
  58.             /** 加载配置文件 */
  59.             initClientGlobal();
  60.             /** 初始化空闲连接池 */
  61.             idleConnectionPool = new LinkedBlockingQueue<TrackerServer>();
  62.             /** 往线程池中添加默认大小的线程 */
  63.             for (int i = 0; i < minPoolSize; i++) {
  64.                 createTrackerServer(logId, COUNT);
  65.             }
  66.         } catch (Exception e) {
  67.             LOGGER.error("[FASTDFS初始化(init)--异常][" + logId + "][异常：{}]", e);
  68.         }
  69.     }
  70.  
  71.     /**
  72.      * @Description: 创建TrackerServer, 并放入空闲连接池
  73.      */
  74.     public void createTrackerServer(String logId, int flag) {
  75.  
  76. //        LOGGER.info("[创建TrackerServer(createTrackerServer)][" + logId + "]");
  77.         TrackerServer trackerServer = null;
  78.  
  79.         try {
  80.  
  81.             TrackerClient trackerClient = new TrackerClient();
  82.             trackerServer = trackerClient.getConnection();
  83.             while (trackerServer == null && flag < 5) {
  84.                 LOGGER.info("[创建TrackerServer(createTrackerServer)][" + logId
  85.                         + "][第" + flag + "次重建]");
  86.                 flag++;
  87.                 initClientGlobal();
  88.                 trackerServer = trackerClient.getConnection();
  89.             }
  90.             org.csource.fastdfs.ProtoCommon.activeTest(trackerServer
  91.                     .getSocket());
  92.             idleConnectionPool.add(trackerServer);
  93.             /** 同一时间只允许一个线程对nowPoolSize操作 **/
  94.             synchronized (this) {
  95.                 nowPoolSize++;
  96.             }
  97.  
  98.         } catch (Exception e) {
  99.  
  100.             LOGGER.error("[创建TrackerServer(createTrackerServer)][" + logId
  101.                     + "][异常：{}]", e);
  102.  
  103.         } finally {
  104.  
  105.             if (trackerServer != null) {
  106.                 try {
  107.                     trackerServer.close();
  108.                 } catch (Exception e) {
  109.                     LOGGER.error("[创建TrackerServer(createTrackerServer)--关闭trackerServer异常]["
  110.                             + logId + "][异常：{}]", e);
  111.                 }
  112.             }
  113.  
  114.         }
  115.     }
  116.  
  117.     /**
  118.      * @throws AppException
  119.      * @Description: 获取空闲连接 1).在空闲池（idleConnectionPool)中弹出一个连接；
  120.      * 2).把该连接放入忙碌池（busyConnectionPool）中; 3).返回 connection
  121.      * 4).如果没有idle connection, 等待 wait_time秒, and check again
  122.      */
  123.     public TrackerServer checkout(String logId) throws AppException {
  124.  
  125.         LOGGER.info("[获取空闲连接(checkout)][" + logId + "]");
  126.         TrackerServer trackerServer = idleConnectionPool.poll();
  127.  
  128.         if (trackerServer == null) {
  129.  
  130.             if (nowPoolSize < maxPoolSize) {
  131.                 createTrackerServer(logId, COUNT);
  132.                 try {
  133.                     trackerServer = idleConnectionPool.poll(waitTimes,
  134.                             TimeUnit.SECONDS);
  135.                 } catch (Exception e) {
  136.                     LOGGER.error("[获取空闲连接(checkout)-error][" + logId
  137.                             + "][error:获取连接超时:{}]", e);
  138.                     throw ERRORS.WAIT_IDLECONNECTION_TIMEOUT.ERROR();
  139.                 }
  140.             }
  141.             if (trackerServer == null) {
  142.                 LOGGER.error("[获取空闲连接(checkout)-error][" + logId
  143.                         + "][error:获取连接超时（" + waitTimes + "s）]");
  144.                 throw ERRORS.WAIT_IDLECONNECTION_TIMEOUT.ERROR();
  145.             }
  146.  
  147.         }
  148.         LOGGER.info("[获取空闲连接(checkout)][" + logId + "][获取空闲连接成功]");
  149.         return trackerServer;
  150.  
  151.     }
  152.  
  153.     /**
  154.      * @param trackerServer 需释放的连接对象
  155.      * @Description: 释放繁忙连接 1.如果空闲池的连接小于最小连接值，就把当前连接放入idleConnectionPool；
  156.      * 2.如果空闲池的连接等于或大于最小连接值，就把当前释放连接丢弃；
  157.      */
  158.  
  159.     public void checkin(TrackerServer trackerServer, String logId) {
  160.  
  161.         LOGGER.info("[释放当前连接(checkin)][" + logId + "][prams:" + trackerServer
  162.                 + "] ");
  163.         if (trackerServer != null) {
  164.             if (idleConnectionPool.size() < minPoolSize) {
  165.                 idleConnectionPool.add(trackerServer);
  166.             } else {
  167.                 synchronized (this) {
  168.                     if (nowPoolSize != 0) {
  169.                         nowPoolSize--;
  170.                     }
  171.                 }
  172.             }
  173.         }
  174.  
  175.     }
  176.  
  177.     /**
  178.      * @param trackerServer
  179.      * @Description: 删除不可用的连接，并把当前连接数减一（调用过程中trackerServer报异常，调用一般在finally中）
  180.      */
  181.     public void drop(TrackerServer trackerServer, String logId) {
  182.         LOGGER.info("[删除不可用连接方法(drop)][" + logId + "][parms:" + trackerServer
  183.                 + "] ");
  184.         if (trackerServer != null) {
  185.             try {
  186.                 synchronized (this) {
  187.                     if (nowPoolSize != 0) {
  188.                         nowPoolSize--;
  189.                     }
  190.                 }
  191.                 trackerServer.close();
  192.             } catch (IOException e) {
  193.                 LOGGER.info("[删除不可用连接方法(drop)--关闭trackerServer异常][" + logId
  194.                         + "][异常：{}]", e);
  195.             }
  196.         }
  197.     }
  198.  
  199.     private void initClientGlobal() throws Exception {
  200.         ClientGlobal.init(this.getClass().getResource("/").getPath()+"deploy/fastdfs_client.conf");
  201.     }
  202.  
  203.     public LinkedBlockingQueue<TrackerServer> getIdleConnectionPool() {
  204.         return idleConnectionPool;
  205.     }
  206.  
  207.     public long getMinPoolSize() {
  208.         return minPoolSize;
  209.     }
  210.  
  211.     public void setMinPoolSize(long minPoolSize) {
  212.         if (minPoolSize != 0) {
  213.             this.minPoolSize = minPoolSize;
  214.         }
  215.     }
  216.  
  217.     public long getMaxPoolSize() {
  218.         return maxPoolSize;
  219.     }
  220.  
  221.     public void setMaxPoolSize(long maxPoolSize) {
  222.         if (maxPoolSize != 0) {
  223.             this.maxPoolSize = maxPoolSize;
  224.         }
  225.     }
  226.  
  227.     public long getWaitTimes() {
  228.         return waitTimes;
  229.     }
  230.  
  231.     public void setWaitTimes(int waitTimes) {
  232.         if (waitTimes != 0) {
  233.             this.waitTimes = waitTimes;
  234.         }
  235.     }
  236. }

2.连接池定时器设置：

  1. /**
  2.  * 连接池定时器设置
  3.  * @version 1.0
  4.  * @Description
  5.  */
  6. public class HeartBeat {
  7.     private static final Logger LOGGER = LoggerFactory
  8.             .getLogger(HeartBeat.class);
  9.     /**
  10.      * fastdfs连接池
  11.      */
  12.     private ConnectionPool pool = null;
  13.     /**
  14.      * 小时毫秒数
  15.      */
  16.     public static int ahour = 1000 * 60 * 60 * 1;
  17.     /**
  18.      * 等待时间
  19.      */
  20.     public static int waitTimes = 1200;
  21.  
  22.     public HeartBeat(ConnectionPool pool) {
  23.         this.pool = pool;
  24.     }
  25.  
  26.     /**
  27.      * @Description: 定时执行任务，检测当前的空闲连接是否可用，如果不可用将从连接池中移除
  28.      */
  29.     public void beat() {
  30.         LOGGER.info("[心跳任务方法（beat）]");
  31.         TimerTask task = new TimerTask() {
  32.             @Override
  33.             public void run() {
  34.                 String logId = UUID.randomUUID().toString();
  35.                 LOGGER.info("[心跳任务方法（beat）]["
  36.                         + logId
  37.                         + "][Description:对idleConnectionPool中的TrackerServer进行监测]");
  38.                 LinkedBlockingQueue<TrackerServer> idleConnectionPool = pool
  39.                         .getIdleConnectionPool();
  40.                 TrackerServer ts = null;
  41.                 for (int i = 0; i < idleConnectionPool.size(); i++) {
  42.                     try {
  43.                         ts = idleConnectionPool.poll(waitTimes,
  44.                                 TimeUnit.SECONDS);
  45.                         if (ts != null) {
  46.                             org.csource.fastdfs.ProtoCommon.activeTest(ts
  47.                                     .getSocket());
  48.                             idleConnectionPool.add(ts);
  49.                         } else {
  50.                             /** 代表已经没有空闲长连接 */
  51.                             break;
  52.                         }
  53.                     } catch (Exception e) {
  54.                         /** 发生异常,要删除，进行重建 */
  55.                         LOGGER.error("[心跳任务方法（beat）][" + logId
  56.                                 + "][异常：当前连接已不可用将进行重新获取连接]");
  57.                         pool.drop(ts, logId);
  58.                     }
  59.                 }
  60.             }
  61.         };
  62.         Timer timer = new Timer();
  63.         timer.schedule(task, ahour, ahour);
  64.     }
  65. }

3.工具类实现文件的上传下载：

  1. /**
  2.  *         fastdfs文件操作工具类 1).初始化连接池； 2).实现文件的上传与下载;
  3.  * @version 1.0
  4.  * @Description
  5.  */
  6. public class FastDfsUtil {
  7.     private static final Logger LOGGER = LoggerFactory
  8.             .getLogger(FastDfsUtil.class);
  9.     /**
  10.      * 连接池
  11.      */
  12.     private static ConnectionPool connectionPool = null;
  13.     /**
  14.      * 连接池默认最小连接数
  15.      */
  16.     private long minPoolSize = 10;
  17.     /**
  18.      * 连接池默认最大连接数
  19.      */
  20.     private long maxPoolSize = 30;
  21.     /**
  22.      * 当前创建的连接数
  23.      */
  24.     private volatile long nowPoolSize = 0;
  25.     /**
  26.      * 默认等待时间（单位：秒）
  27.      */
  28.     private long waitTimes = 1200;
  29.  
  30.     /**
  31.      * 初始化线程池
  32.      *
  33.      * @Description:
  34.      */
  35.     public void init() {
  36.         String logId = UUID.randomUUID().toString();
  37.         LOGGER.info("[初始化线程池(Init)][" + logId + "][默认参数：minPoolSize="
  38.                 + minPoolSize + ",maxPoolSize=" + maxPoolSize + ",waitTimes="
  39.                 + waitTimes + "]");
  40.         connectionPool = new ConnectionPool(minPoolSize, maxPoolSize, waitTimes);
  41.     }
  42.  
  43.     /**
  44.      * @param groupName 组名如group0
  45.      * @param fileBytes 文件字节数组
  46.      * @param extName   文件扩展名：如png
  47.      * @param linkUrl   访问地址：http://image.xxx.com
  48.      * @return 图片上传成功后地址
  49.      * @throws AppException
  50.      * @Description: TODO(这里用一句话描述这个方法的作用)
  51.      */
  52.     public String upload(String groupName, byte[] fileBytes, String extName,
  53.                          String linkUrl) throws AppException {
  54.         String logId = UUID.randomUUID().toString();
  55.         /** 封装文件信息参数 */
  56.         NameValuePair[] metaList = new NameValuePair[]{new NameValuePair(
  57.                 "fileName", "")};
  58.         TrackerServer trackerServer = null;
  59.         try {
  60.  
  61.             /** 获取fastdfs服务器连接 */
  62.             trackerServer = connectionPool.checkout(logId);
  63.             StorageServer storageServer = null;
  64.             StorageClient1 client1 = new StorageClient1(trackerServer,
  65.                     storageServer);
  66.  
  67.             /** 以文件字节的方式上传 */
  68.             String[] results = client1.upload_file(groupName, fileBytes, extName, metaList);
  69.  
  70.             /** 上传完毕及时释放连接 */
  71.             connectionPool.checkin(trackerServer, logId);
  72.  
  73.             /** results[0]:组名，results[1]:远程文件名 */
  74.             if (results != null && results.length == 2) {
  75.                 String result = results[0] + "/" + results[1];
  76.  
  77.                 LOGGER.info("[上传文件（upload）-fastdfs服务器相应结果][" + logId
  78.                         + "][result：" + result + "]");
  79.  
  80.                 if (!StringUtils.isEmpty(linkUrl))
  81.                     return linkUrl + "/" + result;
  82.                 else {
  83.                     return result;
  84.                 }
  85.             } else {
  86.                 /** 文件系统上传返回结果错误 */
  87.                 throw ERRORS.UPLOAD_RESULT_ERROR.ERROR();
  88.             }
  89.         } catch (AppException e) {
  90.  
  91.             LOGGER.error("[上传文件（upload)][" + logId + "][异常：" + e + "]");
  92.             throw e;
  93.  
  94.         } catch (SocketTimeoutException e) {
  95.             LOGGER.error("[上传文件（upload)][" + logId + "][异常：" + e + "]");
  96.             throw ERRORS.WAIT_IDLECONNECTION_TIMEOUT.ERROR();
  97.         } catch (Exception e) {
  98.  
  99.             LOGGER.error("[上传文件（upload)][" + logId + "][异常：" + e + "]");
  100.             connectionPool.drop(trackerServer, logId);
  101.             throw ERRORS.SYS_ERROR.ERROR();
  102.  
  103.         }
  104.  
  105.     }
  106.  
  107.     /**
  108.      * @param groupName 组名如group0
  109.      * @param fileBytes 文件字节数组
  110.      * @param extName   文件扩展名：如png
  111.      * @param linkUrl   访问地址：http://image.xxx.com
  112.      * @return 图片上传成功后地址
  113.      * @throws AppException
  114.      * @Description: TODO(这里用一句话描述这个方法的作用)
  115.      */
  116.     public  static  String upload(byte[] fileBytes, String extName,
  117.                          String linkUrl) throws AppException {
  118.         String logId = UUID.randomUUID().toString();
  119.         /** 封装文件信息参数 */
  120.         NameValuePair[] metaList = new NameValuePair[]{new NameValuePair(
  121.                 "fileName", "")};
  122.         TrackerServer trackerServer = null;
  123.         try {
  124.  
  125.             /** 获取fastdfs服务器连接 */
  126.             trackerServer = connectionPool.checkout(logId);
  127.             StorageServer storageServer = null;
  128.             StorageClient1 client1 = new StorageClient1(trackerServer,
  129.                     storageServer);
  130.  
  131.             /** 以文件字节的方式上传 */
  132.             String[] results = client1.upload_file(fileBytes,extName, metaList);
  133.  
  134.             /** 上传完毕及时释放连接 */
  135.             connectionPool.checkin(trackerServer, logId);
  136.  
  137.             /** results[0]:组名，results[1]:远程文件名 */
  138.             if (results != null && results.length == 2) {
  139.                 String result= results[0] + "/" + results[1];
  140.  
  141.                 LOGGER.info("[上传文件（upload）-fastdfs服务器相应结果][" + logId
  142.                         + "][result：" + result + "]");
  143.  
  144.                 if (!StringUtils.isEmpty(linkUrl))
  145.                     return linkUrl + "/" + result;
  146.                 else {
  147.                     return result;
  148.                 }
  149.             } else {
  150.                 /** 文件系统上传返回结果错误 */
  151.                 throw ERRORS.UPLOAD_RESULT_ERROR.ERROR();
  152.             }
  153.         } catch (AppException e) {
  154.  
  155.             LOGGER.error("[上传文件（upload)][" + logId + "][异常：" + e + "]");
  156.             throw e;
  157.  
  158.         } catch (SocketTimeoutException e) {
  159.             LOGGER.error("[上传文件（upload)][" + logId + "][异常：" + e + "]");
  160.             throw ERRORS.WAIT_IDLECONNECTION_TIMEOUT.ERROR();
  161.         } catch (Exception e) {
  162.  
  163.             LOGGER.error("[上传文件（upload)][" + logId + "][异常：" + e + "]");
  164.             connectionPool.drop(trackerServer, logId);
  165.             throw ERRORS.SYS_ERROR.ERROR();
  166.  
  167.         }
  168.  
  169.     }
  170.     
  171.     /**
  172.      * @param group_name      组名
  173.      * @param remote_filename 远程文件名称
  174.      * @throws AppException
  175.      * @Description: 删除fastdfs服务器中文件
  176.      */
  177.     public void deleteFile(String group_name, String remote_filename)
  178.             throws AppException {
  179.  
  180.         String logId = UUID.randomUUID().toString();
  181.         LOGGER.info("[ 删除文件（deleteFile）][" + logId + "][parms：group_name="
  182.                 + group_name + ",remote_filename=" + remote_filename + "]");
  183.         TrackerServer trackerServer = null;
  184.  
  185.         try {
  186.             /** 获取可用的tracker,并创建存储server */
  187.             trackerServer = connectionPool.checkout(logId);
  188.             StorageServer storageServer = null;
  189.             StorageClient1 client1 = new StorageClient1(trackerServer,
  190.                     storageServer);
  191.             /** 删除文件,并释放 trackerServer */
  192.             //int result = client1.delete_file(group_name, remote_filename);
  193.             int result = client1.delete_file1(remote_filename);
  194.  
  195.             /** 上传完毕及时释放连接 */
  196.             connectionPool.checkin(trackerServer, logId);
  197.  
  198.             LOGGER.info("[ 删除文件（deleteFile）--调用fastdfs客户端返回结果][" + logId
  199.                     + "][results：result=" + result + "]");
  200.  
  201.             //** 0:文件删除成功，2：文件不存在 ，其它：文件删除出错 *//*
  202.             if (result == 2) {
  203.  
  204.                 throw ERRORS.NOT_EXIST_FILE.ERROR();
  205.              
  206.             } else if (result != 0) {
  207.  
  208.                 throw ERRORS.DELETE_RESULT_ERROR.ERROR();
  209.  
  210.             } 
  211.  
  212.         } catch (AppException e) {
  213.  
  214.             LOGGER.error("[ 删除文件（deleteFile）][" + logId + "][异常：" + e + "]");
  215.             throw e;
  216.  
  217.         } catch (SocketTimeoutException e) {
  218.             LOGGER.error("[ 删除文件（deleteFile）][" + logId + "][异常：" + e + "]");
  219.             throw ERRORS.WAIT_IDLECONNECTION_TIMEOUT.ERROR();
  220.         } catch (Exception e) {
  221.  
  222.             LOGGER.error("[ 删除文件（deleteFile）][" + logId + "][异常：" + e + "]");
  223.             connectionPool.drop(trackerServer, logId);
  224.             throw ERRORS.SYS_ERROR.ERROR();
  225.  
  226.         }
  227.     }
  228.  
  229.     /**
  230.      * @param fileld 远程文件名称
  231.      * @throws AppException
  232.      * @Description: 删除fastdfs服务器中文件
  233.      */
  234.     public boolean delFile(String fileld)
  235.             throws AppException {
  236.         int count = 0;
  237.         String logId = UUID.randomUUID().toString();
  238.         LOGGER.info("[ 删除文件（deleteFile）][" + logId + "],remote_filename=" + fileld + "]");
  239.         TrackerServer trackerServer = null;
  240.  
  241.         try {
  242.             /** 获取可用的tracker,并创建存储server */
  243.             trackerServer = connectionPool.checkout(logId);
  244.             StorageServer storageServer = null;
  245.             StorageClient1 client1 = new StorageClient1(trackerServer,
  246.                     storageServer);
  247.             /** 删除文件,并释放 trackerServer */
  248.             count = client1.delete_file1(fileld);
  249.  
  250.             /** 上传完毕及时释放连接 */
  251.             connectionPool.checkin(trackerServer, logId);
  252.  
  253.             LOGGER.info("[ 删除文件（deleteFile）--调用fastdfs客户端返回结果][" + logId
  254.                     + "][results：result=" + count + "]");
  255.  
  256.         } catch (AppException e) {
  257.  
  258.             LOGGER.error("[ 删除文件（deleteFile）][" + logId + "][异常：" + e + "]");
  259.             throw e;
  260.  
  261.         } catch (SocketTimeoutException e) {
  262.             LOGGER.error("[ 删除文件（deleteFile）][" + logId + "][异常：" + e + "]");
  263.             throw ERRORS.WAIT_IDLECONNECTION_TIMEOUT.ERROR();
  264.         } catch (Exception e) {
  265.  
  266.             LOGGER.error("[ 删除文件（deleteFile）][" + logId + "][异常：" + e + "]");
  267.             connectionPool.drop(trackerServer, logId);
  268.             throw ERRORS.SYS_ERROR.ERROR();
  269.  
  270.         }
  271.         return count == 0 ? true : false;
  272.     }
  273.  
  274.     public ConnectionPool getConnectionPool() {
  275.         return connectionPool;
  276.     }
  277.  
  278.     public void setConnectionPool(ConnectionPool connectionPool) {
  279.         this.connectionPool = connectionPool;
  280.     }
  281.  
  282.     public long getMinPoolSize() {
  283.         return minPoolSize;
  284.     }
  285.  
  286.     public void setMinPoolSize(long minPoolSize) {
  287.         this.minPoolSize = minPoolSize;
  288.     }
  289.  
  290.     public long getMaxPoolSize() {
  291.         return maxPoolSize;
  292.     }
  293.  
  294.     public void setMaxPoolSize(long maxPoolSize) {
  295.         this.maxPoolSize = maxPoolSize;
  296.     }
  297.  
  298.     public long getNowPoolSize() {
  299.         return nowPoolSize;
  300.     }
  301.  
  302.     public void setNowPoolSize(long nowPoolSize) {
  303.         this.nowPoolSize = nowPoolSize;
  304.     }
  305.  
  306.     public long getWaitTimes() {
  307.         return waitTimes;
  308.     }
  309.  
  310.     public void setWaitTimes(long waitTimes) {
  311.         this.waitTimes = waitTimes;
  312.     }
  313. }

以上就是fastdfs连接池配置。查看日志：

对于fastDFS安装请参考：https://blog.csdn.net/u011663149/article/details/85321181

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/IT小白/article/detail/169880
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号