ftp相关方法，下载没写完

package com.roiland.cms.util;


import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.RandomAccessFile;
import java.io.UnsupportedEncodingException;
import java.net.SocketException;
import java.net.URL;
import java.net.URLConnection;
import java.net.URLEncoder;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;


import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;


import org.apache.commons.net.ftp.FTPClient;
import org.apache.commons.net.ftp.FTPFile;
import org.apache.commons.net.ftp.FTPReply;
import org.springframework.web.multipart.MultipartFile;


public class Ftpclient {


public enum UploadStatus { 
Create_Directory_Fail,   //远程服务器相应目录创建失败 
Create_Directory_Success, //远程服务器闯将目录成功 
Upload_New_File_Success, //上传新文件成功 
Upload_New_File_Failed,   //上传新文件失败 
File_Exits,      //文件已经存在 
Remote_Bigger_Local,   //远程文件大于本地文件 
Upload_From_Break_Success, //断点续传成功 
Upload_From_Break_Failed, //断点续传失败 
Delete_Remote_Faild;   //删除远程文件失败 
} 

/**
* 
* @Title: uploadFile
* @Description: TODO 上传图片文件
* @param targetpath
*            上传文件目标路径
* @param instream
*            上传文件流
* @param fileOldName
*            上传的文件名，包括后缀，需要重命名
* @param directory
*            要删除的文件，包含文件名称（全路径），没有给null
* @return
* @return Map<String,Object> 返回类型
* @throws
*/
@SuppressWarnings("static-access")
public static Map<String, Object> uploadFile(String targetpath, InputStream instream, String fileOldName, String directory, FTPClient ftp) {


boolean flag = true;
Map<String, Object> map = new HashMap<String, Object>();
if (ftp != null) {
try {
// 原文件后缀
String fname = fileOldName.substring(fileOldName.lastIndexOf(".") + 1, fileOldName.length()).toLowerCase();
// 如果不符合，则退出
if (!fname.equalsIgnoreCase("png") && !fname.equalsIgnoreCase("jpg") && !fname.equalsIgnoreCase("bmp") && !fname.equalsIgnoreCase("jpeg")
&& !fname.equalsIgnoreCase("gif")) {
map.put("message", "图片：" + fileOldName + " 上传格式不正确！");
map.put("success", false);
return map;
}
// 新文件名
String fileNewName = UUID.randomUUID().toString() + "." + fname;


if (targetpath != null && !"".equals(targetpath)) {
ftp.changeWorkingDirectory("/");
if (!ftp.changeWorkingDirectory(targetpath)) { // 如果新文件夹不存在


if (!makeDirectory(targetpath, ftp)) {// 创建文件夹
map.put("success", false);
return map;
} else {
ftp.changeWorkingDirectory(targetpath); // 更改ftp目录
}
}
}


ftp.setFileType(ftp.BINARY_FILE_TYPE);
flag = ftp.storeFile(fileNewName, instream); // 上传文件
if (flag) {
map.put("success", true);
map.put("path", targetpath+fileNewName);
map.put("imgname", fileNewName);
map.put("message", "上传成功");


if (directory != null && !"".equals(directory)) {
// 删除文件
if (!deleteFiles(directory, ftp)) {
map.put("success", false);
map.put("message", "删除失败");
}
}
} else {
map.put("success", false);
map.put("message", "上传失败");
return map;
}
} catch (IOException e) {
e.printStackTrace();
return map;
}
return map;
} else {
map.put("success", false);
map.put("message", "ftp is null");
return map;
}
}


/**
* 
* @Title: deletDirectory
* @Description: TODO 删除文件夹
* @param dirpath
*            文件夹路径
* @return
* @return boolean 返回类型
* @throws
*/
public static boolean deletDirectory(String dirpath, FTPClient ftp) {
if (ftp != null) {
try {
ftp.changeWorkingDirectory("/"); // 删除文件夹只需要切换到根目录即可，不要切换到删除文件夹下


FTPFile[] file = ftp.listFiles(dirpath);
for (FTPFile ftpFile : file) {
if (ftpFile.isFile()) {
ftp.deleteFile(dirpath + "/" + ftpFile.getName());
}
if (ftpFile.isDirectory()) {
deletDirectory(dirpath + "/" + ftpFile.getName(), ftp);
ftp.removeDirectory(dirpath + "/" + ftpFile.getName());
}
}


ftp.removeDirectory(dirpath);
FTPFile[] file1 = ftp.listFiles(dirpath);
if (file1.length > 0) {
return false;
} else {
return true;
}
} catch (IOException e) {
e.printStackTrace();
return false;
}
} else {
return false;
}
}


/**
* 
* @Title: deleteFiles
* @Description: TODO 删除文件
* @param filePath
*            删除文件全路径包含文件名及后缀
* @return
* @return boolean 返回类型
* @throws
*/
public static boolean deleteFiles(String filePath, FTPClient ftp) {
boolean flag = true;
if (ftp != null) {
try {
int res = filePath.lastIndexOf("/");
String name = filePath.substring(res + 1);
ftp.changeWorkingDirectory("/");// 回到根目录


if (res != -1) { // 如果等于-1,路径为ftp跟目录


String path = filePath.substring(0, res);
if (ftp.changeWorkingDirectory(path)) {


flag = ftp.deleteFile(name);// 删除文件
} else {
flag = false;// 切换失败，文件夹不存在
}
} else {
flag = ftp.deleteFile(name);// 删除文件
}
} catch (IOException e) {
e.printStackTrace();
flag = false;
}
} else {
flag = false;
}
return flag;
}


/**
* 
* @Title: makeDirectory
* @Description: TODO FTP创建文件夹
* @param dirPathName
*            文件夹路径
* @param ftp
*            FTP
* @return
* @return boolean 返回类型
* @throws
*/
public static boolean makeDirectory(String dirPathName, FTPClient ftp) {


boolean flag = true;
if (ftp != null) {
try {
ftp.changeWorkingDirectory("/");
flag = ftp.makeDirectory(dirPathName);
} catch (IOException e) {
e.printStackTrace();
flag = false;
}
} else {
flag = false;
}
return flag;
}


/**
* 
* @Title: connectService
* @Description: TODO 打开FTP连接
* @return FTPClient
* @return boolean 返回类型
* @throws
*/
public static FTPClient connectService() {


FTPClient ftp = new FTPClient();


String IP = "192.168.1.128"; // IP
int port = 21; // 端口
String username = "audionline"; // 用户名
String userpass = "p@ssWORD"; // 密码


try {
ftp.setControlEncoding("UTF-8");
// ftp.setDataTimeout(120000);//连接超时时间
ftp.setBufferSize(1024 * 10);
ftp.setDefaultPort(port);
ftp.connect(IP);
ftp.login(username, userpass);


int reply = ftp.getReplyCode(); // 230为连接成功
if (!FTPReply.isPositiveCompletion(reply)) {
ftp.logout();
ftp.disconnect();
System.err.println("FTP server refused connection.");
ftp = null;
}
} catch (SocketException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return ftp;
}


/**
* 
* @Title: closeConnect
* @Description: TODO 关闭ftp连接
* @return void 返回类型
* @throws
*/
public static void closeConnect(FTPClient ftp) {
try {
if (ftp != null) {
ftp.logout();
ftp.disconnect();
System.err.println("FTP CLOSE");
}
} catch (Exception e) {
e.printStackTrace();
}
}


/**
* 
* @Title: uploadFile
* @Description: TODO 断点续传方法
* @param remoteFilePath
*            上传到服务器的路径
* @param ftp
* @param file
*            文件流
* @return
* @return boolean 返回类型
* @throws
*/
public static Map<String, Object> pointuploadFile(String remoteFilePath, FTPClient ftp, MultipartFile file) {
Map<String, Object> map = new HashMap<String, Object>();
try {
long localFileSize = file.getSize(); // 获取上传文件大小
String remoteFileName = file.getOriginalFilename();

// 原文件后缀
String fname = remoteFileName.substring(remoteFileName.lastIndexOf(".") + 1, remoteFileName.length()).toLowerCase();
// 如果不符合，则退出
if (!fname.equalsIgnoreCase("mp4") && !fname.equalsIgnoreCase("avi") && !fname.equalsIgnoreCase("bmp") && !fname.equalsIgnoreCase("rmvb")
&& !fname.equalsIgnoreCase("wmv")) {
map.put("message", "视频：" + remoteFileName + " 上传格式不正确！");
map.put("success", false);
return map;
}


ftp.changeWorkingDirectory("/");
if (remoteFilePath != null && !"".equals(remoteFilePath)) { // 上传到服务器的路径不为空
if (!ftp.changeWorkingDirectory(remoteFilePath)) { // 切换失败说明文件夹不存在,
if (makeDirectory(remoteFilePath, ftp)) { // 创建文件夹
if(ftp.changeWorkingDirectory(remoteFilePath)){

return breakpintUpload(ftp, remoteFileName, localFileSize, file);
}else{
map.put("message", "更改服务器路径错误!");
map.put("success", false);
return map;
}


} else {
map.put("message", "创建文件夹失败!");
map.put("success", false);
return map;// 文件夹创建失败
}
} else {
return breakpintUpload(ftp, remoteFileName, localFileSize, file);
}
} else { // 上传到服务器路径为空，则传到服务器根目录下
return breakpintUpload(ftp, remoteFileName, localFileSize, file);
}


} catch (IOException e) {
e.printStackTrace();
map.put("message", "异常错误!");
map.put("success", false);
return map;// 文件夹创建失败
}


}


/**
* 
* @Title: judgeFile
* @Description: TODO 判断文件是否存在并断点上传,执行前提FTP已经切换到指定的工作目录
* @param ftp
* @param remoteFileName  上传到服务器上文件名称
* @return
* @return long 返回类型 ，返回文件字节大小
* @throws
*/
private  static Map<String, Object> breakpintUpload(FTPClient ftp, String remoteFileName, long localFileSize, MultipartFile file) {
long remoteFileSize = 0;
boolean result = true;
Map<String, Object> map = new HashMap<String, Object>();
try {

//remoteFileName = new String(remoteFileName.getBytes("UTF-8"));
ftp.setFileType(ftp.BINARY_FILE_TYPE);
FTPFile[] fi = ftp.listFiles(remoteFileName);
InputStream instream = file.getInputStream();

if (fi.length == 1) { // 有同名文件
remoteFileSize = fi[0].getSize();
if (remoteFileSize == localFileSize) {
map.put("message", "文件存在!");
map.put("success", false);
return map;// 文件已经存在
} else if (remoteFileSize > localFileSize) {
map.put("message", "服务器存在同名文件并大于上传文件!");
map.put("success", false);
return map;// 服务器文件大于上传文件
}


// 断点续传上传文件
if (instream.skip(remoteFileSize) == remoteFileSize) {
ftp.setRestartOffset(remoteFileSize);
if (ftp.storeFile(remoteFileName, instream)) {
map.put("message", "断点上传成功!");
map.put("success", true);
return map;
}
}


// 如果断点续传没有成功，则删除服务器上文件，重新上传
if (!ftp.deleteFile(remoteFileName)) {
map.put("message", "删除失败!");
map.put("success", false);
return map;// 删除失败
}


instream = file.getInputStream(); // 从新获取文件流


if (ftp.storeFile(remoteFileName, instream)) {
map.put("message", "断点上传成功!");
map.put("success", true);

} else {
map.put("message", "断点上传失败!");
map.put("success", false);

}
instream.close();


} else {// 没有同名文件
if (ftp.storeFile(remoteFileName, instream)) {
//ftp.rename(renameFile(remoteFileName), remoteFileName); //文件重命名
map.put("message", "上传成功!");
map.put("success", true);
} else {
map.put("message", "上传失败!");
map.put("success", false);
}
instream.close();
}
} catch (IOException e) {
e.printStackTrace();
map.put("message", "异常错误!");
map.put("success", false);
}
return map;
}


/**
* 
* @Title: renameFile 
* @Description: TODO文件重命名
* @param fileName原文件名
* @return 
* @return String    返回类型 
* @throws
*/
public static String renameFile(String fileName){
String suffix = fileName.substring(fileName.lastIndexOf("."));
String newName = UUID.randomUUID().toString()+"."+suffix;
return newName;
}

/**
* 
* @Title: downloadFile 
* @Description: TODO  文件下载
* @param response
* @param request
* @throws Exception 
* @return void    返回类型 
* @throws
*/
public static void downloadFile(HttpServletResponse response, HttpServletRequest request, String uploadPath) throws Exception {
response.reset();
File file = new File("D:\\image\\ul\\li\\年会第九版.mpg");


InputStream is = new FileInputStream(file);
BufferedOutputStream out = null;
// 文件名
String filename = encodeChineseDownloadFileName(request, file.getName());
try {


response.setHeader("Accept-Ranges", "bytes");
// response.setHeader("ETag", "\"" + eTag + "\"");//续传必须
response.setHeader("Content-Length", file.length() + "");
response.setCharacterEncoding("UTF-8");
response.setContentType("application/octet-stream;charset=UTF-8");
response.addHeader("Content-Disposition", "attachment; filename=" + filename);
byte[] buffer = new byte[1024];
int len;
boolean full = false;
// 读取，输出流
out = new BufferedOutputStream(response.getOutputStream());
while ((len = is.read(buffer)) > 0) {

out.write(buffer, 0, len);
out.flush();
}

} finally {


if (is != null)
is.close();
}
if (out != null) {
out.close();
}


}

/** 
     * 下载服务器已存在的文件 
     *  
     * @param request 
     * @param response 
     * @param proposeFile 
     * @throws IOException 
     * @throws FileNotFoundException 
     */  
    public void downloads(HttpServletRequest request,HttpServletResponse response)  {  
    ServletOutputStream out = null;
    BufferedOutputStream bufferOut = null;
    InputStream inputStream = null;
    try {
File file = new File("D:\\image\\ul\\li\\年会第九版.mpg");
long fSize =file.length();  
// 下载
response.setContentType("application/x-download");  
response.setCharacterEncoding("UFT-8");
String isoFileName = encodeChineseDownloadFileName(request, file.getName());
response.setHeader("Accept-Ranges", "bytes");  
response.setHeader("Content-Length", String.valueOf(fSize));  
response.setHeader("Content-Disposition", "attachment; filename="  
       + isoFileName);  
long pos = 0;  
if (null != request.getHeader("Range")) {  
   // 断点续传  
   response.setStatus(HttpServletResponse.SC_PARTIAL_CONTENT);  
   try {  
       pos = Long.parseLong(request.getHeader("Range").replaceAll(  
               "bytes=", "").replaceAll("-", ""));  
   } catch (NumberFormatException e) {  
       pos = 0;  
   }  
}  
out = response.getOutputStream();  
bufferOut = new BufferedOutputStream(out);  
inputStream = new FileInputStream(file);  
String contentRange = new StringBuffer("bytes ").append(  
       new Long(pos).toString()).append("-").append(  
       new Long(fSize - 1).toString()).append("/").append(  
       new Long(fSize).toString()).toString();  
response.setHeader("Content-Range", contentRange);  
inputStream.skip(pos);  
byte[] buffer = new byte[5 * 1024];  
int length = 0;  
while ((length = inputStream.read(buffer, 0, buffer.length)) != -1) {  
   bufferOut.write(buffer, 0, length);  
   bufferOut.flush(); 
}  

} catch (IOException e) {
System.out.println("下载异常");
e.printStackTrace();
}  finally{
try {
 
bufferOut.close();  
out.close();  
inputStream.close();
} catch (Exception e) {
System.out.println("下载关闭异常");
e.printStackTrace();
}
}
    }
    
    
    public  void domnloadfile(HttpServletRequest request,HttpServletResponse response){
   
    BufferedOutputStream buffer =  null;
    InputStream is = null;
    OutputStream os = null;
    try {

    URL url = new URL("");
    URLConnection con = (URLConnection) url.getContent();
    is =con.getInputStream();
   
} catch (Exception e) {
// TODO: handle exception
}
    }
    
    
    /** 
    * 对文件流输出下载的中文文件名进行编码 屏蔽各种浏览器版本的差异性 
    */ 
private static String encodeChineseDownloadFileName(HttpServletRequest request, String pFileName) {
String agent = request.getHeader("USER-AGENT");
try {
if (null != agent && -1 != agent.indexOf("MSIE")) {
pFileName = URLEncoder.encode(pFileName, "utf-8");
} else {
pFileName = new String(pFileName.getBytes("utf-8"), "iso8859-1");
}
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
return pFileName;
} 
    

}