fastdfs分布式文件系统之JAVA client工具类封装

工具类当中进行连接池的初始化及上传、下载、删除功能的实现并在spring配置文件中配置，生成对应的java bean 方便其它类访问。

FastDfsUtil工具类

实现对连接池初始化、上传、删除功能的实现。

import java.net.SocketTimeoutException;
import java.util.UUID;

import org.csource.common.NameValuePair;
import org.csource.fastdfs.StorageClient1;
import org.csource.fastdfs.StorageServer;
import org.csource.fastdfs.TrackerServer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.xxxx.common.AppException;
import com.xxxx.fastdfs.dto.ResultDto;
import com.xxxx.fastdfs.exception.ERRORS;

/**
 * 
 * @ClassName: FastDfsUtil
 * @Description: fastdfs文件操作工具类 1).初始化连接池； 2).实现文件的上传与下载;
 * @author mr_smile2014 [email protected]
 * @date 2015年11月25日 上午10:21:46
 * 
 */
public class FastDfsUtil {
	private static final Logger LOGGER = LoggerFactory
			.getLogger(FastDfsUtil.class);
	/** 连接池 */
	private ConnectionPool connectionPool = null;
	/** 连接池默认最小连接数 */
	private long minPoolSize = 10;
	/** 连接池默认最大连接数 */
	private long maxPoolSize = 30;
	/** 当前创建的连接数 */
	private volatile long nowPoolSize = 0;
	/** 默认等待时间（单位：秒） */
	private long waitTimes = 200;

	/**
	 * 初始化线程池
	 * 
	 * @Description:
	 * 
	 */
	public void init() {
		String logId = UUID.randomUUID().toString();
		LOGGER.info("[初始化线程池(Init)][" + logId + "][默认参数：minPoolSize="
				+ minPoolSize + ",maxPoolSize=" + maxPoolSize + ",waitTimes="
				+ waitTimes + "]");
		connectionPool = new ConnectionPool(minPoolSize, maxPoolSize, waitTimes);
	}

	/**
	 * 
	 * @Description: TODO(这里用一句话描述这个方法的作用)
	 * @param groupName
	 *            组名如group0
	 * @param fileBytes
	 *            文件字节数组
	 * @param extName
	 *            文件扩展名：如png
	 * @param linkUrl
	 *            访问地址：http://image.xxx.com
	 * @return 图片上传成功后地址
	 * @throws AppException
	 * 
	 */
	public String upload(String groupName, byte[] fileBytes, String extName,
			String linkUrl) throws AppException {
		String logId = UUID.randomUUID().toString();
		/** 封装文件信息参数 */
		NameValuePair[] metaList = new NameValuePair[] { new NameValuePair(
				"fileName", "") };
		TrackerServer trackerServer = null;
		try {

			/** 获取fastdfs服务器连接 */
			trackerServer = connectionPool.checkout(logId);
			StorageServer storageServer = null;
			StorageClient1 client1 = new StorageClient1(trackerServer,
					storageServer);

			/** 以文件字节的方式上传 */
			String[] results = client1.upload_file(groupName, fileBytes,
					extName, metaList);

			/** 上传完毕及时释放连接 */
			connectionPool.checkin(trackerServer, logId);

			LOGGER.info("[上传文件（upload）-fastdfs服务器相应结果][" + logId
					+ "][result：results=" + results + "]");

			ResultDto result = null;

			/** results[0]:组名，results[1]:远程文件名 */
			if (results != null && results.length == 2) {

				return linkUrl + "/" + results[0] + "/" + results[1];
			} else {
				/** 文件系统上传返回结果错误 */
				throw ERRORS.UPLOAD_RESULT_ERROR.ERROR();
			}
		} catch (AppException e) {

			LOGGER.error("[上传文件（upload)][" + logId + "][异常：" + e + "]");
			throw e;

		} catch (SocketTimeoutException e) {
			LOGGER.error("[上传文件（upload)][" + logId + "][异常：" + e + "]");
			throw ERRORS.WAIT_IDLECONNECTION_TIMEOUT.ERROR();
		} catch (Exception e) {

			LOGGER.error("[上传文件（upload)][" + logId + "][异常：" + e + "]");
			connectionPool.drop(trackerServer, logId);
			throw ERRORS.SYS_ERROR.ERROR();

		}

	}

	/**
	 * 
	 * @Description: 删除fastdfs服务器中文件
	 * @param group_name
	 *            组名
	 * @param remote_filename
	 *            远程文件名称
	 * @throws AppException
	 * 
	 */
	public void deleteFile(String group_name, String remote_filename)
			throws AppException {

		String logId = UUID.randomUUID().toString();
		LOGGER.info("[ 删除文件（deleteFile）][" + logId + "][parms：group_name="
				+ group_name + ",remote_filename=" + remote_filename + "]");
		TrackerServer trackerServer = null;

		try {
			/** 获取可用的tracker,并创建存储server */
			trackerServer = connectionPool.checkout(logId);
			StorageServer storageServer = null;
			StorageClient1 client1 = new StorageClient1(trackerServer,
					storageServer);
			/** 删除文件,并释放 trackerServer */
			int result = client1.delete_file(group_name, remote_filename);

			/** 上传完毕及时释放连接 */
			connectionPool.checkin(trackerServer, logId);

			LOGGER.info("[ 删除文件（deleteFile）--调用fastdfs客户端返回结果][" + logId
					+ "][results：result=" + result + "]");

			/** 0:文件删除成功，2：文件不存在 ，其它：文件删除出错 */
			if (result == 2) {

				throw ERRORS.NOT_EXIST_FILE.ERROR();

			} else if (result != 0) {

				throw ERRORS.DELETE_RESULT_ERROR.ERROR();

			}

		} catch (AppException e) {

			LOGGER.error("[ 删除文件（deleteFile）][" + logId + "][异常：" + e + "]");
			throw e;

		} catch (SocketTimeoutException e) {
			LOGGER.error("[ 删除文件（deleteFile）][" + logId + "][异常：" + e + "]");
			throw ERRORS.WAIT_IDLECONNECTION_TIMEOUT.ERROR();
		} catch (Exception e) {

			LOGGER.error("[ 删除文件（deleteFile）][" + logId + "][异常：" + e + "]");
			connectionPool.drop(trackerServer, logId);
			throw ERRORS.SYS_ERROR.ERROR();

		}
	}

	public ConnectionPool getConnectionPool() {
		return connectionPool;
	}

	public void setConnectionPool(ConnectionPool connectionPool) {
		this.connectionPool = connectionPool;
	}

	public long getMinPoolSize() {
		return minPoolSize;
	}

	public void setMinPoolSize(long minPoolSize) {
		this.minPoolSize = minPoolSize;
	}

	public long getMaxPoolSize() {
		return maxPoolSize;
	}

	public void setMaxPoolSize(long maxPoolSize) {
		this.maxPoolSize = maxPoolSize;
	}

	public long getNowPoolSize() {
		return nowPoolSize;
	}

	public void setNowPoolSize(long nowPoolSize) {
		this.nowPoolSize = nowPoolSize;
	}

	public long getWaitTimes() {
		return waitTimes;
	}

	public void setWaitTimes(long waitTimes) {
		this.waitTimes = waitTimes;
	}
}

property.properties文件配置

#fastdfs连接池最大连接数
maxPoolSize=30
#fastdfs等待时间（单位：秒）
waitTimes=400
#fastdfs连接池最小连接数
minPoolSize=20

spring文件配置

<bean id="propertyConfigurer"
		class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
		<property name="locations">
			<list>
				<value>classpath:property.properties</value>
			</list>
		</property>
	</bean>
	<bean name="connectionPool" class="com.xxxx.fastdfs.pool.FastDfsUtil"
		init-method="init">
		<property name="minPoolSize" value="${minPoolSize}" />
		<property name="maxPoolSize" value="${maxPoolSize}" />
		<property name="waitTimes" value="${waitTimes}" />
	</bean>

代码中用到的其它类代码如下：

error枚举类

package com.xxxx.fastdfs.exception;

import com.xxxx.common.AppException;
import com.xxxx.common.Module;

/**
 * 
 * @ClassName: ERRORS
 * @Description: 应用异常枚举类
 * @author mr_smile2014 [email protected]
 * @date 2015年21月17日 上午10:22:39
 * 
 */
public enum ERRORS {

	PARAMETER_IS_NULL("21001", "必填参数为空", "必填参数为空"),

	FASTDFS_CONNECTION_FAIL("21002", "连接fastdfs服务器失败", "文件上传异常，请重试"),

	WAIT_IDLECONNECTION_TIMEOUT("21003", "等待空闲连接超时", "连接超时，请重试"),

	NOT_EXIST_GROUP("21004", "文件组不存在", "文件组不存在"),

	UPLOAD_RESULT_ERROR("21005", "fastdfs文件系统上传返回结果错误", "文件上传异常，请重试"),

	NOT_EXIST_PORTURL("21006", "未找到对应的端口和访问地址", "文件上传异常，请重试"),

	SYS_ERROR("21007", "系统错误", "系统错误"),

	FILE_PATH_ERROR("21008", "文件访问地址格式不对","文件访问地址格式不对"),

	DELETE_RESULT_ERROR("21009", "fastdfs文件系统删除文件返回结果错误", "文件删除异常，请重试"),

	NOT_EXIST_FILE("21010", "文件不存在", "文件不存在");

	/** 错误码 */
	String code;

	/** 错误信息，用于日志输出，便于问题定位 */
	String message;

	/** 错误提示，用于客户端提示 */
	String descreption;

	ERRORS(String code, String message) {
		this.message = message;
		this.code = code;
	}

	ERRORS(String code, String message, String descreption) {
		this.message = message;
		this.code = code;
		this.descreption = descreption;
	}

	public AppException ERROR() {
		return new AppException(Module.FASTDFS, this.code, this.message,
				this.descreption);
	}

	public AppException ERROR(String descreption) {
		return new AppException(Module.FASTDFS, this.code, this.message,
				descreption);
	}
}

异常类

package com.xxxx.common;

/**
 * 系统通用异常
 * @author mr_smile2014 [email protected]
 *
 */
public class AppException extends Exception {
	private static final long serialVersionUID = -1848618491499044704L;

	private Module module;
	private String code;
	private String description;


	public AppException(Module module, String code, String message) {
		super(message);
		this.module = module;
		this.code = code;
	}

	public AppException(Module module, String code, String message, String description) {
		super(message);
		this.module = module;
		this.code = code;
		this.description = description;
	}

	/**
	 * 产生异常的模块
	 * 
	 * @return
	 */
	public Module getModule() {
		return module;
	}

	/**
	 * 错误码
	 * 
	 * @return
	 */
	public String getCode() {
		return code;
	}

	/**
	 * 用户可读描述信息
	 * 
	 * @return
	 */
	public String getDescription() {
		return description;
	}

	@Override
	public String toString() {
		StringBuilder sb = new StringBuilder();
		sb.append(getClass().getName());
		sb.append(": [");
		sb.append(module);
		sb.append("] - ");
		sb.append(code);
		sb.append(" - ");
		sb.append(getMessage());
		if (getDescription() != null) {
			sb.append(" - ");
			sb.append(getDescription());
		}
		return sb.toString();
	}
}

注:连接池ConnectionPool类使用的是上一篇文章的类，如果要使用直接去拷贝。