fastdfs java 连接池_简单 fastdfs java client 连接池

package com.xyh.core.fastdfs;

import java.io.BufferedInputStream;

import java.io.BufferedOutputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.util.concurrent.LinkedBlockingQueue;

import java.util.concurrent.TimeUnit;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.csource.common.MyException;

import org.csource.common.NameValuePair;

import org.csource.fastdfs.ClientGlobal;

import org.csource.fastdfs.DownloadCallback;

import org.csource.fastdfs.ProtoCommon;

import org.csource.fastdfs.StorageClient1;

import org.csource.fastdfs.TrackerClient;

import org.csource.fastdfs.TrackerServer;

import org.csource.fastdfs.UploadCallback;

import org.springframework.http.HttpHeaders;

public class FastDfsPool {

//默认连接池大小

public static int connection_size = 20;

private static TrackerClient trackerClient;

private static LinkedBlockingQueue storageClient1s = new LinkedBlockingQueue(

connection_size);

private static int current_index;

static {

try {

String classPath = new File(FileManager.class.getResource("/").getFile()).getCanonicalPath();

String fdfsClientConfigFilePath = classPath + File.separator + FileManagerConfig.CLIENT_CONFIG_FILE;

ClientGlobal.init(fdfsClientConfigFilePath);

trackerClient = new TrackerClient();

} catch (Exception e) {

e.printStackTrace();

}

}

private FastDfsPool() {

}

public static String getFileExt(String local_filename) {

int nPos = local_filename.lastIndexOf('.');

if (nPos > 0 && local_filename.length() - nPos <= ProtoCommon.FDFS_FILE_EXT_NAME_MAX_LEN + 1) {

return local_filename.substring(nPos + 1);

}

return "";

}

private static void createStorageClientInfo() {

synchronized (trackerClient) {

if (current_index < connection_size) {

try {

System.out.println("创建连接");

TrackerServer server = trackerClient.getConnection();

StorageClient1 storageClient1 = new StorageClient1(trackerClient.getConnection(), null);

StorageClientInfo storageClientInfo = new StorageClientInfo(current_index, storageClient1, server);

//System.out.println(storageClientInfo.id+"====================");

if (storageClient1s.offer(storageClientInfo)) {

current_index++;

}

} catch (IOException e) {

e.printStackTrace();

}

}

}

}

private static StorageClientInfo findStorageClient() {

// 尝试获取一个有用的客户端连接信息

StorageClientInfo clientInfo = storageClient1s.poll();

if (clientInfo == null) {

//System.out.println("没有找到可用的空闲连接");

if (current_index < connection_size) {

createStorageClientInfo();

}else{

//System.out.println("等待连接可用");

}

try {

clientInfo=storageClient1s.poll(10,TimeUnit.SECONDS);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

return clientInfo;

}

public static void downloadFile(String path, HttpServletRequest request, HttpServletResponse response) {

StorageClientInfo client1 = findStorageClient();

if(client1!=null){

try {

String type = request.getServletContext().getMimeType(path);

if (type != null) {

response.setContentType(type);

}

if (path.startsWith("/")) {

path = path.substring(1);

}

FileDownLoad fileDownLoad = new FileDownLoad(response);

//System.out.println("down load file "+path+" from "+client1.id+" server");

client1.storageClient1.download_file1(path, fileDownLoad);

if (fileDownLoad.out == null) {

response.setStatus(404);

}

} catch (IOException e) {

e.printStackTrace();

} catch (MyException e) {

e.printStackTrace();

}finally {

storageClient1s.offer(client1);

}

}else{

try {

response.sendError(500, "fastdfs file down server error");

} catch (IOException e) {

e.printStackTrace();

}

}

}

/**

*

* @param in

* 文件输入流

* @param valuePairs

* 元信息

* @param local_filename

* 文件名

* @param size

* 文件大小

* @return 上传后的文件路径

* @throws MyException

* @throws IOException

*/

public static String upload(String local_filename, long size, InputStream in, NameValuePair[] valuePairs){

StorageClientInfo client1 = findStorageClient();

if(client1!=null){

String file_ext_name = null;

if (file_ext_name == null) {

int nPos = local_filename.lastIndexOf('.');

if (nPos > 0 && local_filename.length() - nPos <= ProtoCommon.FDFS_FILE_EXT_NAME_MAX_LEN + 1) {

file_ext_name = local_filename.substring(nPos + 1);

}

}

String path=null;

try {

path=client1.storageClient1.upload_file1(null, size, new FileUpload(in), file_ext_name, valuePairs);

} catch (Exception e1) {

e1.printStackTrace();

}finally {

try {

if(client1.trackerServer.getSocket().isConnected()){

storageClient1s.offer(client1);

}

} catch (IOException e) {

e.printStackTrace();

}

}

return path;

}

return null;

}

private static class StorageClientInfo {

public int id;

public StorageClient1 storageClient1;

public TrackerServer trackerServer;

public StorageClientInfo(int id, StorageClient1 storageClient1, TrackerServer trackerServer) {

this.storageClient1 = storageClient1;

this.trackerServer = trackerServer;

this.id=id;

}

}

private static class FileUpload implements UploadCallback {

private InputStream in;

public FileUpload(InputStream in) {

this.in = in;

}

public int send(OutputStream out) throws IOException {

try {

BufferedOutputStream bufferOut = new BufferedOutputStream(out);

if (in instanceof FileInputStream) {

in = new BufferedInputStream(in);

}

byte[] buff = new byte[4096];

int off = -1;

while ((off = in.read(buff)) != -1) {

bufferOut.write(buff, 0, off);

}

bufferOut.flush();

} catch (Exception e) {

throw e;

} finally {

in.close();

}

return 0;

}

}

private static class FileDownLoad implements DownloadCallback {

private HttpServletResponse response;

private OutputStream out;

public FileDownLoad(HttpServletResponse response) {

this.response = response;

}

@Override

public int recv(long file_size, byte[] data, int bytes) {

if (out == null) {

response.setContentLengthLong(file_size);

response.setHeader(HttpHeaders.CACHE_CONTROL, "max-age=864000");

response.setHeader("Pragma", "Pragma");

response.setDateHeader("Last-Modified", System.currentTimeMillis());

try {

out = response.getOutputStream();

} catch (IOException e) {

e.printStackTrace();

}

}

if (out != null) {

try {

out.write(data, 0, bytes);

} catch (IOException e) {

e.printStackTrace();

return -1;

}

} else {

return -1;

}

return 0;

}

}

public static void deleteFile(String groupName, String remoteFileName) {

StorageClientInfo client = findStorageClient();

try {

client.storageClient1.delete_file(groupName, remoteFileName);

} catch (IOException e) {

e.printStackTrace();

} catch (MyException e) {

e.printStackTrace();

}finally{

storageClient1s.offer(client);

}

}

}