자바 다 중 스 레 드 사진 다운로드 및 압축 실현

최근 에 필요 한 것 이 있 습 니 다.다른 시스템 의 ftp 디 렉 터 리 에서 그림 url 을 저장 하 는 파일 을 다운로드 한 다음 에 파일 의 url 주 소 를 읽 고 주소 에 따라 그림 을 다운로드 한 후 하루 에 한 개의 가방 으로 압축 합 니 다.평균 한 주소 파일 에 4000 개의 주소 가 포함 되 어 있 습 니 다.즉,한 문 서 를 스 캔 한 후에 4000 개의 그림 을 다운로드 한 다음 에 압축 해 야 합 니 다.다음은 제 실현 방식 과 최적화 과정 을 기록 하 겠 습 니 다.여러분 이 더 좋 은 방법 이 있다 면 공유 할 수 있 습 니 다.
사용 프레임 워 크:SpringMVC
정시 퀘 스 트 실현:org.springframework.scheduling.quartz.QuartzJobBean 계승;
ftp 환경 구축 은 물론 이 고 다른 블 로그 에 기록 되 어 있 으 며 가상 컴퓨터 의 CentOS 로 구 축 된 FTP 서 비 스 를 이용 하여 FTP 계 정과 해당 디 렉 터 리 를 만 들 고 다운로드 해 야 할 이미지 주소 파일 을 미리 업로드 합 니 다.파일 내용 형식"그림 ID||그림 주소".
방법 1.가장 간단 한 실현 방법 은 먼저 그림 url 주 소 를 저장 하 는 파일 을 다운로드 한 다음 에 파일 을 읽 고 그림 주 소 를 옮 겨 다 니 며 그림 을 다운로드 하 는 방법 으로 그림 을 로 컬 에 저장 하고 마지막 으로 다운로드 한 그림 을 압축 한 다음 에 다운로드 한 그림 을 삭제 하고 압축 패키지 만 유지 하 는 것 이다.

public class PictureTransferJob extends QuartzJobBean 
{ 
 protected void executeInternal(JobExecutionContext arg0) throws JobExecutionException 
 { 
 //   FTP             
 //FTP   
 String hostName ="192.168.1.112"; 
 //FTP   
 int port = 2001; 
 /FTP   
 String userName = "test1"; 
 //ftp   
 String password = "test1"; 
 //ftp       
 String ftpDowload = "/"; 
 //         
 String path = this.getClass().getResource("/").getPath(); 
 //           
 String addrPath=path.substring(1, path.indexOf("WEB-INF/classes"))+"picAddr"; 
 //            
 String picPath=path.substring(1, path.indexOf("WEB-INF/classes"))+"pic"; 
 addrPath = addrPath.replace("%20"," "); 
 picPath = picPath.replace("%20"," "); 
 try 
 { 
 //            
 creatFile(addrPath); 
 //            
 creatFile(picPath); 
 String oldAddrPath = addrPath; 
 String oldPicPath = picPath; 
 //  FTP   
 FtpUtil2 ftpUtil2 = new FtpUtil2(hostName, port,userName, password, ftpDowload, true); 
 //  FTP       
 String[] files = ftpUtil2.ListAllFiles(); 
 //                  ,         ftp        ,               ,      。 
 //         ,  files  ,        
 for(int i=0;i<files.length;i++){ 
 creatFile(addrPath+File.separator+fileName); 
 //ftpDowload ftp          ,addrPath           
 //                   
 boolean downloadInvestorFlag = ftpUtil2.downloadFile(ftpDowload, addrPath); 
 //               ,               
 boolean entityState = setPictureDetail(addrPath,picPath,fileNameDate); 
 } 
 }  
 catch (Exception e) 
 { 
  e.printStackTrace(); 
  //                         
 } 
} 
  
//          
private boolean setPictureDetail(String addrPath,String picPath,String synDate) 
{ 
 System.out.println("----------  setPictureDetail  -----------"); 
 BufferedReader br = null; 
 try 
 { 
  br=new BufferedReader(new InputStreamReader(new FileInputStream(addrPath),"UTF-8")); 
  String row; 
  int count=0; 
 //map              URL   
  Map<String, String> addrMap=new HashMap<String, String>(); 
  while ((row=br.readLine())!=null) 
  { 
  try 
  { 
   count++; 
   if (count==1) 
   { 
   continue; 
   } 
   String[] column = row.split("\\|\\|", -1); 
   addrMap.put(column[0].trim(), column[1].trim()); 
  } 
  catch (Exception e) 
  { 
   e.printStackTrace(); 
  } 
  } 
  System.out.println(new Date()); 
  //        ,                  
  zipPic(picPath,synDate,addrMap); 
  System.out.println(new Date()); 
  System.out.println("----------  --------------"); 
  return true; 
 } 
 catch (Exception e) 
 { 
  e.printStackTrace(); 
  //             
  return false; 
 }finally { 
  try { 
  if (null != br) 
   br.close(); 
  } catch (IOException e) { 
  e.printStackTrace(); 
  } 
 } 
 } 
 /** 
 *   url       
 * @throws IOException 
 */ 
 private boolean downPic(String picPath,List<Entry<String, String>> addrList,List<File> picList)throws IOException{ 
 InputStream is=null; 
 FileOutputStream fos=null; 
 URL url=null; 
 String fileName=null; 
 String picAddr=null; 
 File pic=null; 
 try 
 { 
  for(Map.Entry<String, String> addrEntry:addrList) 
  { 
  fileName=addrEntry.getKey(); 
  picAddr=addrEntry.getValue(); 
  //  Url   
  url=new URL(picAddr); 
  is=url.openStream(); 
  //URLConnection       InputStream             ,          ,  org.apache.commons.io.IOUtils.toByteArray(urlconnection.openstream())     
  byte[] bytes=IOUtils.toByteArray(is);//new byte[is.available()];      
  //          ,   ,       
  pic=new File(picPath+fileName+".jpg"); 
  fos=new FileOutputStream(pic); 
  fos.write(bytes); 
  //        List,            zip       
  picList.add(pic); 
  fos.flush(); 
  fos.close(); 
  is.close(); 
  } 
  return true; 
 } 
 catch (Exception e) 
 { 
  e.printStackTrace(); 
  return false; 
 } 
 finally{ 
  if (null!=fos) 
  { 
  fos.close(); 
  } 
  if (null!=is) 
  { 
  is.close(); 
  } 
 } 
 } 
 //            
 private void zipPic(picPath,synDate,addrMap);{ 
 //                  
 ZipUtil.zipByStream(picList,new File(picPath+synDate+".zip")); 
 } 
 /** 
 *      
 * @param path 
 */ 
 private void creatFile(String path) 
 { 
 File file = new File(path); 
 if(!file.exists()) 
 { 
  file.mkdirs(); 
 } 
 } 
}
방법 2.다 중 스 레 드 다운로드,직접 압축 흐름
방법 1.기본 적 인 기능 을 실 현 했 지만 다운로드 해 야 할 그림 이 너무 많 고 로 컬 이미지 파일 을 압축 하고 삭제 하 는 데 도 시간 이 걸 리 기 때문에 속 도 를 최적화 할 수 있 는 곳 은 두 가지 가 있다.하 나 는 사진 다운로드 의 효율 을 높이 는 것 이 고,하 나 는 압축 의 효율 을 높이 는 것 이다.
다운로드 효율 을 높이 는 방법 은 다 중 스 레 드 로 다운로드 할 수 있 고 압축 효율 을 높이 는 방법 은 그림 을 로 컬 에 저장 하지 않 고 파일 흐름 을 직접 압축 할 수 있다.
다 중 스 레 드 구현 방식:우선 다운로드 해 야 할 파일 의 주소 목록 을 저 장 했 습 니 다.다 중 스 레 드 로 다운로드 하려 면 서로 다른 스 레 드 로 다운로드 한 그림 이 중복 되 지 않도록 해 야 합 니 다.따라서 하나의 표지 로 구분 해 야 합 니 다.이 때 는 색인 계수 기 를 사용 하여 각 스 레 드 에 따라 일 정량의 그림 을 다운로드 하여 0 부터 시작 할 수 있 습 니 다.예 를 들 어 400 개의 그림 을 하나의 스 레 드 로 다운로드 하면 필요 한 스 레 드 개 수 를 확인 할 수 있 고 모든 스 레 드 에서 다운로드 한 그림 은 중복 되 지 않 습 니 다.
압축 파일 구현 방식:압축 파일 을 만 드 는 본질 도 압축 이 필요 한 파일 흐름 을 읽 고 압축 패 키 지 를 만 들 수 있 기 때문에 다운로드 한 그림 파일 을 만 들 지 않 고 용기 로 모든 스 레 드 에서 다운로드 한 그림 스 트림 데 이 터 를 저장 한 다음 에 스 트림 을 압축 도구 류 에 직접 압축 시 켜 그림 파일 생 성 흐름 을 생략 할 수 있 습 니 다.그리고 압축 패 키 지 를 만 들 고 로 컬 그림 파일 을 삭제 하 는 번 거 로 운 과정 입 니 다.
다음은 개조의 주요 실현 을 보 여 줍 니 다.

/** 
 *            
 * @throws IOException 
 */ 
private boolean zipPic(String picPath,String synDate,Map<String, String> addrMap) throws IOException{ 
 //             ,           map,    ConcurrentHashMap 
 Map<String,InputStream> pictureList=new ConcurrentHashMap<String,InputStream>(); 
 //                
 int count=400; 
 //            
 List<Entry<String, String>> addrList=new ArrayList<Entry<String, String>>(addrMap.entrySet()); 
 //   ,                  400     
 int nThreads=(addrList.size()/count)+1; 
 //CountDownLatch countDownLatch = new CountDownLatch(nThreads); 
 try 
 { 
 boolean downPic=false; 
 //          
 downPic=downPic(picPath,addrList,picList,pictureList,nThreads,count); 
 if (downPic) 
 { 
  ZipUtil.zipByArray(picList,new File(picPath+synDate+".zip")); 
 } 
 return true; 
 } 
 catch (Exception e) 
 { 
 e.printStackTrace(); 
 return false; 
 } 
} 
다음은 스 레 드 풀 만 들 기

/** 
 *   url       
 * @throws InterruptedException 
 */ 
private boolean downPic(String picPath,List<Entry<String, String>> addrList,Map<String, byte[]> picList,Map<String, InputStream> pictureList,int nThreads,int count)throws IOException, InterruptedException{ 
 ExecutorService threadPool=Executors.newFixedThreadPool(nThreads); 
 //          
 CountDownLatch begin=new CountDownLatch(0); 
 CountDownLatch end=new CountDownLatch(nThreads); 
 //        
 for (int i = 0; i < nThreads; i++) { 
 List<Entry<String, String>>subAddrList=null; 
 //             
 if ((i + 1) == nThreads) { 
  int startIndex = (i * count); 
  int endIndex = addrList.size(); 
  subAddrList = addrList.subList(startIndex, endIndex); 
 } else { 
  int startIndex = (i * count); 
  int endIndex = (i + 1) * count; 
  subAddrList = addrList.subList(startIndex, endIndex); 
 } 
 //     
 PicDownload mythead = new PicDownload(picPath,subAddrList,picList,pictureList); 
 //                  threadPool.execute(mythead)  。 
 try 
 { 
  threadPool.execute(mythead); 
 } 
 catch (Exception e) 
 { 
  //       
  return false; 
 } 
 } 
 begin.countDown(); 
 end.await(); 
 //          
 threadPool.shutdown(); 
 //                         ,                       ,          ,           
 //     CountDownLatch   
 /*while (true) 
 { 
 if (threadPool.isTerminated()) 
 { 
  System.out.println("        !"); 
  break; 
 } 
 }*/ 
 return true; 
} 
다음은 스 레 드 구현 입 니 다.

class PicDownload implements Runnable{ 
 //          
 List<Entry<String, String>> addrList; 
 //            
 Map<String, byte[]> picList; 
 Map<String, InputStream> pictureList; 
 //         
 String picPath; 
 
 CountDownLatch begin,end; 
 public PicDownload(String picPath,List<Entry<String, String>> addrList,Map<String, InputStream> picList,CountDownLatch begin,CountDownLatch end){ 
 this.addrList=addrList; 
 this.picList=picList; 
 this.picPath=picPath; 
 this.begin=begin; 
 this.end=end; 
 } 
 @Override 
 public void run() 
 { 
 try 
 { 
  System.out.println(Thread.currentThread().getName()+"------"+Thread.currentThread().getId()); 
  downPicture(addrList); 
  //System.out.println(countDownLatch.getCount()); 
  begin.await(); 
 } 
 catch (Exception e) 
 { 
  e.printStackTrace(); 
 }finally{ 
  end.countDown(); 
  //countDownLatch.countDown(); 
 } 
 } 
 public boolean downPicture(List<Entry<String, String>> addrList) throws Exception{ 
 InputStream is=null; 
 FileOutputStream fos=null; 
 URL url=null; 
 String fileName=null; 
 String picAddr=null; 
 File pic=null; 
 try 
 { 
  for(Map.Entry<String, String> addrEntry:addrList) 
  { 
  fileName=addrEntry.getKey(); 
  picAddr=addrEntry.getValue(); 
  //  Url   
  url=new URL(picAddr); 
  is=url.openStream(); 
  //URLConnection       InputStream             ,          ,  org.apache.commons.io.IOUtils.toByteArray(urlconnection.openstream())     
  //byte[] bytes=IOUtils.toByteArray(is);//new byte[is.available()];      
  //          ,   ,       
  picList.put(fileName+".jpg", is); 
  //             ,       ,            
  //is.close(); 
  } 
  return true; 
 } 
 catch (Exception e) 
 { 
  e.printStackTrace(); 
  return false; 
 } 
 finally{ 
  //      
  /*if (null!=is) 
  { 
  is.close(); 
  }*/ 
 } 
 } 
} 
위 에서 스 트림 을 사용 하여 압축 하 는 데 또 다른 문제 가 발생 했 습 니 다.파일 을 압축 할 때 자바.net.SocketException:Connection reset 가 나타 납 니 다.
원인 을 분석 해 보 니 스 트림 InputStream 과 UrlConnection 이 연결 상태 이기 때문에 UrlConnection 이 시간 을 초과 하여 리 셋 되 어 입력 스 트림 을 가 져 오 는 데 실 패 했 습 니 다.
URLConnection 의 시간 초과 설정 을 시도 하 였 으 나 테스트 할 때 그림 다운로드 가 네트워크 속도 에 큰 영향 을 받 는 것 을 발견 하 였 습 니 다.이러한 방식 은 매우 불안정 하고 바람 직 하지 않 습 니 다.마지막 으로 스 트림 사용 을 포기 하고 바이트 배열 로 압축 도구 류 에 전송 한 다음 에 바이트 배열 을 스 트림 압축 으로 바 꾸 었 습 니 다.

/** 
*                
*/ 
public boolean downPicture(List<Entry<String, String>> addrList) throws Exception{ 
 InputStream is=null; 
 FileOutputStream fos=null; 
 URL url=null; 
 String fileName=null; 
 String picAddr=null; 
 File pic=null; 
 try 
 { 
 for(Map.Entry<String, String> addrEntry:addrList) 
 { 
  fileName=addrEntry.getKey(); 
  picAddr=addrEntry.getValue(); 
  //  Url   
  url=new URL(picAddr); 
  //    ,  java.net.URLConnection  ,            ,        HttpURLConnection  disconnect      。 
  //java.net.URLConnection java.net.HttpURLConnection                
  //HttpURLConnection uc=(HttpURLConnection)url.openConnection(); 
  is=uc.getInputStream(); 
  //URLConnection       InputStream             ,          ,  org.apache.commons.io.IOUtils.toByteArray(urlconnection.openstream())     
  byte[] bytes=IOUtils.toByteArray(is);//new byte[is.available()];      
  //          ,   ,       
  //is.read(bytes); 
  picList.put(fileName+".jpg",bytes); 
  is.close(); 
 } 
 return true; 
 } 
 catch (Exception e) 
 { 
 e.printStackTrace(); 
 return false; 
 } 
 finally{ 
 if (null!=is) 
 { 
  is.close(); 
 } 
 } 
}
요약:
실현 과정 에서 발생 하 는 문제:
1.스 레 드 풀 을 사용 할 때 공유 상태,예 를 들 어 여기 서 다운로드 한 이미지 바이트 데이터 용 기 는 모든 스 레 드 가 공유 되 기 때문에 동기 화 용 기 를 사용 해 야 합 니 다.그렇지 않 으 면 저 장 된 데이터 에 문제 가 생 길 수 있 기 때문에 ConcurrentHashMap를 사 용 했 습 니 다.
2.여기 메 인 스 레 드 와 하위 스 레 드 의 실행 순서 문제 가 존재 합 니 다.메 인 스 레 드 는 스 레 드 탱크 의 모든 스 레 드 다운로드 그림 이 끝 난 후에 야 아래로 내 려 가서 그림 을 압축 할 수 있 기 때 문 입 니 다.만약 에 메 인 스 레 드 가 하위 스 레 드 가 끝 날 때 까지 기다 리 지 않 고 아래로 압축 방법 을 실행 하면 압축 그림 이 부족 하거나 압축 되 지 않 습 니 다.따라서 Count Downlatch 를 사용 하여 구현 하거나 스 레 드 풀 문 구 를 닫 는 데 사 순환 검사 threadPool.isTerminated()를 사용 해 야 메 인 스 레 드 를 계속 실행 하여 그림 을 압축 할 수 있 습 니 다.
3.UrlConnection 에서 가 져 온 입력 흐름 을 압축 클래스 에 직접 전송 하여 압축 하기 때문에 연결 시간 이 초과 되 어 리 셋 되 는 경우 가 있 으 므 로 다운로드 한 흐름 을 바이트 배열 에 저장 하고 압축 클래스 에 전송 하여 압축 하여 사용 흐름 에 의외 의 상황 이 발생 하지 않도록 합 니 다.
4.urlconnection.openStream()을 사용 하여 입력 흐름 을 가 져 온 후 바이트 배열 로 전환 하여 다운로드 한 그림 은 완전 하지 않 습 니 다.org.apache.comons.io.IOUtils.toByteArray(urlconnection.openstream()를 사용 하면 해결 할 수 있 으 며,구체 적 으로 소스 코드 를 읽 어 볼 수 있 습 니 다.
다음은 FTP 도구 류 의 실현 입 니 다.

import java.io.BufferedInputStream; 
import java.io.BufferedOutputStream; 
import java.io.FileInputStream; 
import java.io.FileOutputStream; 
import java.io.IOException; 
 
import org.apache.commons.net.ftp.FTPClient; 
import org.apache.commons.net.ftp.FTPClientConfig; 
import org.apache.commons.net.ftp.FTPConnectionClosedException; 
import org.apache.commons.net.ftp.FTPReply; 
 
public class FtpUtil2 { 
 private FTPClient ftpClient = null; 
 
 // ftp      
 private String hostName; 
 
 // ftp        
 public static int defaultport = 21; 
 
 //     
 private String userName; 
 
 //      
 private String password; 
 
 //           
 private String remoteDir; 
 
 
 /** 
 * @param hostName 
 *       
 * @param port 
 *      
 * @param userName 
 *      
 * @param password 
 *     
 * @param remoteDir 
 *         
 * @param is_zhTimeZone 
 *       FTP Server  
 * @return 
 * @return 
 */ 
 
 /** 
 *      
 */ 
 public FtpUtil2() 
 { 
 PropConfig config = PropConfig.loadConfig("system.properties"); 
 String hostName = config.getConfig("ftpAddress"); 
 String port = config.getConfig("ftpPort"); 
 String userName = config.getConfig("ftpUserName"); 
 String password = config.getConfig("ftpPassword"); 
 String remoteDir = config.getConfig("remoteFilePath"); 
 boolean is_zhTimeZone= true; 
 this.hostName = hostName; 
 this.userName = userName; 
 this.password = password; 
 this.remoteDir = remoteDir == null ? "" : remoteDir; 
 this.ftpClient = new FTPClient(); 
 if (is_zhTimeZone) { 
  this.ftpClient.configure(FtpUtil2.Config()); 
  this.ftpClient.setControlEncoding("GBK"); 
 } 
 //    
 this.login(); 
 //      
 this.changeDir(this.remoteDir); 
 this.setFileType(FTPClient.BINARY_FILE_TYPE); 
 ftpClient.setDefaultPort(Integer.parseInt(port));  
 } 
 public FtpUtil2(String hostName, int port, String userName, 
  String password, String remoteDir, boolean is_zhTimeZone) { 
 this.hostName = hostName; 
 this.userName = userName; 
 this.password = password; 
 defaultport=port; 
 this.remoteDir = remoteDir == null ? "" : remoteDir; 
 this.ftpClient = new FTPClient(); 
 if (is_zhTimeZone) { 
  this.ftpClient.configure(FtpUtil2.Config()); 
  this.ftpClient.setControlEncoding("GBK"); 
 
 } 
 //    
 this.login(); 
 //      
 this.changeDir(this.remoteDir); 
 this.setFileType(FTPClient.ASCII_FILE_TYPE); 
 ftpClient.setDefaultPort(port); 
 
 } 
 
 /** 
 *   FTP    
 */ 
 public boolean login() { 
 boolean success = false; 
 try { 
  ftpClient.connect(this.hostName,defaultport); 
  ftpClient.login(this.userName, this.password); 
  int reply; 
  reply = ftpClient.getReplyCode(); 
  if (!FTPReply.isPositiveCompletion(reply)) { 
  ftpClient.disconnect(); 
  return success; 
  } 
 } catch (FTPConnectionClosedException e) { 
  // TODO Auto-generated catch block 
  e.printStackTrace(); 
 } catch (IOException e) { 
  // TODO Auto-generated catch block 
  e.printStackTrace(); 
 } 
 success = true; 
 System.out.println("   ftp   :" + this.hostName + "   ..    "); 
 return success; 
 } 
 
 private static FTPClientConfig Config() { 
 FTPClientConfig conf = new FTPClientConfig(FTPClientConfig.SYST_UNIX); 
 conf.setRecentDateFormatStr("MM dd  HH:mm"); 
 // conf.setRecentDateFormatStr("(YYYY )?MM dd ( HH:mm)?"); 
 return conf; 
 } 
 
 /** 
 *        
 * 
 * @param remoteDir 
 * 
 */ 
 public void changeDir(String remoteDir) { 
 try { 
  this.remoteDir = remoteDir; 
  ftpClient.changeWorkingDirectory(remoteDir); 
 } catch (IOException e) { 
  // TODO Auto-generated catch block 
  e.printStackTrace(); 
 } 
 System.out.println("       :" + remoteDir); 
 } 
 
 /** 
 *        (   ) 
 */ 
 public void toParentDir() { 
 try { 
  ftpClient.changeToParentDirectory(); 
 } catch (IOException e) { 
  // TODO Auto-generated catch block 
  e.printStackTrace(); 
 } 
 } 
 
 /** 
 *               
 */ 
 public String[] ListAllFiles() { 
 String[] names = this.ListFiles("*"); 
 return this.sort(names); 
 } 
 
 /** 
 *                
 * 
 * @param dir 
 *  exp: /cim/ 
 * @param file_regEx 
 *      * 
 */ 
 public String[] ListAllFiles(String dir, String file_regEx) { 
 String[] names = this.ListFiles(dir + file_regEx); 
 return this.sort(names); 
 } 
 
 /** 
 *        
 * 
 * @param file_regEx 
 *      ,    * 
 */ 
 public String[] ListFiles(String file_regEx) { 
 try { 
  /** 
   * FTPFile[] remoteFiles = ftpClient.listFiles(file_regEx); 
   * //System.out.println(remoteFiles.length); String[] name = new 
   * String[remoteFiles.length]; if(remoteFiles != null) { for(int 
   * i=0;i<remoteFiles.length;i++) { if(remoteFiles[i] == null) 
   * name[i] = ""; else 
   * if(remoteFiles[i].getName()==null||remoteFiles 
   * [i].getName().equals 
   * (".")||remoteFiles[i].getName().equals("..")) { name[i] = ""; 
   * } else name[i] = remoteFiles[i].getName(); 
   * System.out.println(name[i]); } } 
   */ 
  ftpClient.enterLocalPassiveMode(); 
  String[] name = ftpClient.listNames(file_regEx);; 
  if (name == null) 
  return new String[0]; 
 
  return this.sort(name); 
 
 } catch (Exception e) { 
  // TODO Auto-generated catch block 
  e.printStackTrace(); 
 } 
 return new String[0]; 
 } 
 
 public void Lists(String reg) { 
 try { 
  String[] a = ftpClient.listNames(reg); 
  if (a != null) { 
  for (String b : a) { 
   System.out.println(b); 
  } 
  } 
 } catch (IOException e) { 
  // TODO Auto-generated catch block 
  e.printStackTrace(); 
 } 
 } 
 
 /** 
 *          [           ] 
 * 
 * @param fileType 
 *  --BINARY_FILE_TYPE,ASCII_FILE_TYPE 
 */ 
 public void setFileType(int fileType) { 
 try { 
  ftpClient.setFileType(fileType); 
 } catch (IOException e) { 
  e.printStackTrace(); 
 } 
 } 
 
 /** 
 *      
 * 
 * @param localFilePath 
 *  --      +    
 * @param newFileName 
 *  --      
 */ 
 public void uploadFile(String localFilePath, String newFileName) { 
 //      
 this.ftpClient.enterLocalPassiveMode();//        
 BufferedInputStream buffIn = null; 
 try { 
  buffIn = new BufferedInputStream(new FileInputStream(localFilePath)); 
  boolean ifUpload = ftpClient.storeFile(newFileName, buffIn); 
  if (!ifUpload) { 
  System.out.println("      。。。"); 
  } else { 
  System.out.println("      。。。"); 
  } 
 } catch (Exception e) { 
  e.printStackTrace(); 
 } finally { 
  try { 
  if (buffIn != null) 
   buffIn.close(); 
  } catch (Exception e) { 
  e.printStackTrace(); 
  } 
 } 
 } 
 
 /** 
 *     2 
 * 
 * @param file 
 *  --FileInputStream    
 * @param newFileName 
 *  --      
 */ 
 public void newUploadFile(FileInputStream file, String newFileName) { 
 //      
 this.ftpClient.enterLocalPassiveMode();//        
 BufferedInputStream buffIn = null; 
 try { 
  buffIn = new BufferedInputStream(file); 
  boolean ifUpload = ftpClient.storeFile(newFileName, buffIn); 
  if (!ifUpload) { 
  System.out.println("      。。。"); 
  } else { 
  System.out.println("      。。。"); 
  } 
 } catch (Exception e) { 
  e.printStackTrace(); 
 } finally { 
  try { 
  if (buffIn != null) 
   buffIn.close(); 
  } catch (Exception e) { 
  e.printStackTrace(); 
  } 
 } 
 } 
 
 /** 
 *     (  ) 
 * 
 * @param remoteFileName 
 *  --         
 * @param localFileName 
 *  --      
 */ 
 public boolean downloadFile(String remoteFileName, String localFileName) { 
 this.ftpClient.enterLocalPassiveMode();//        
 BufferedOutputStream buffOut = null; 
 try { 
  buffOut = new BufferedOutputStream(new FileOutputStream( 
   localFileName)); 
  boolean ifDownload = ftpClient 
   .retrieveFile(remoteFileName, buffOut); 
  if (!ifDownload) { 
  System.out.println("      。。。"); 
  return false; 
  } else { 
  System.out.println("      。。。"); 
  } 
 } catch (Exception e) { 
  e.printStackTrace(); 
  return false; 
 } finally { 
  try { 
  if (buffOut != null) 
   buffOut.close(); 
  } catch (Exception e) { 
  e.printStackTrace(); 
  } 
 } 
 return true; 
 } 
 
 /** 
 *   FTP   
 */ 
 public void close() { 
 try { 
  if (ftpClient != null) { 
  ftpClient.logout(); 
  ftpClient.disconnect(); 
  } 
 } catch (Exception e) { 
  e.printStackTrace(); 
 } 
 } 
 
 /** 
 *        (    ) 
 */ 
 public String[] sort(String[] str_Array) { 
 if (str_Array == null) { 
  throw new NullPointerException("The str_Array can not be null!"); 
 } 
 String tmp = ""; 
 for (int i = 0; i < str_Array.length; i++) { 
  for (int j = 0; j < str_Array.length - i - 1; j++) { 
  if (str_Array[j].compareTo(str_Array[j + 1]) < 0) { 
   tmp = str_Array[j]; 
   str_Array[j] = str_Array[j + 1]; 
   str_Array[j + 1] = tmp; 
  } 
  } 
 } 
 return str_Array; 
 } 
 
 public static void main(String[] strs) { 
 FtpUtil2 FtpUtil2 = new FtpUtil2("192.168.1.112", 20011, "test1", 
  "test1", "/", true); 
 FtpUtil2.downloadFile("test.txt", "d:\\test.txt"); 
 } 
 
} 
다음은 ZIP 도구 클래스 입 니 다.

import java.io.File; 
import java.io.FileInputStream; 
import java.io.FileOutputStream; 
import java.io.IOException; 
import java.io.InputStream; 
import java.io.OutputStream; 
import java.util.ArrayList; 
import java.util.Enumeration; 
import java.util.List; 
import java.util.Map; 
import java.util.zip.ZipEntry; 
import java.util.zip.ZipFile; 
import java.util.zip.ZipOutputStream; 
 
import org.apache.commons.io.IOUtils; 
 
import com.ibatis.common.logging.Log; 
import com.ibatis.common.logging.LogFactory; 
 
public class ZipUtil { 
 private static final Log log = LogFactory.getLog(ZipUtil.class); 
 
 
 /** 
 *      
 * 
 * @param srcfile File[]           
 * @param zipfile File        
 */ 
 public static OutputStream zipFiles(List<File> srcfile, OutputStream outputStream) { 
 byte[] buf = new byte[1024]; 
 try {    
  // Create the ZIP file 
  ZipOutputStream out = new ZipOutputStream(outputStream); 
  // Compress the files 
  for (int i = 0; i < srcfile.size(); i++) { 
  File file = srcfile.get(i); 
  FileInputStream in = new FileInputStream(file); 
  // Add ZIP entry to output stream. 
  out.putNextEntry(new ZipEntry(file.getName())); 
   
  // Transfer bytes from the file to the ZIP file 
  int len; 
  while ((len = in.read(buf)) > 0) { 
   //System.out.println(len+"=============="); 
   
   out.write(buf, 0, len); 
  } 
  // Complete the entry 
  out.closeEntry(); 
  in.close(); 
  } 
  // Complete the ZIP file 
  out.close(); 
 } catch (IOException e) { 
  log.error("ZipUtil zipFiles exception:"+e); 
 } 
 return outputStream; 
 } 
 
 
 /** 
 *      
 * 
 * @param srcfile File[]           
 * @param zipfile File        
 */ 
 public static void zipFiles(List<File> srcfile, File zipfile) { 
 byte[] buf = new byte[1024]; 
 try { 
  // Create the ZIP file 
  ZipOutputStream out = new ZipOutputStream(new FileOutputStream(zipfile)); 
  // Compress the files 
  for (int i = 0; i < srcfile.size(); i++) { 
  File file = srcfile.get(i); 
  FileInputStream in = new FileInputStream(file); 
  // Add ZIP entry to output stream. 
  out.putNextEntry(new ZipEntry(file.getName())); 
  // Transfer bytes from the file to the ZIP file 
  int len; 
  while ((len = in.read(buf)) > 0) { 
   out.write(buf, 0, len); 
  } 
  // Complete the entry 
  out.closeEntry(); 
  in.close(); 
  } 
  // Complete the ZIP file 
  out.close(); 
 } catch (IOException e) { 
  log.error("ZipUtil zipFiles exception:"+e); 
 } 
 } 
 
 
 /** 
 *      
 * srcfile:key:   ,value:         
 * @param srcfile 
 * @param zipfile 
 * @see 
 */ 
 public static void zipByStream(Map<String,InputStream> srcfile, File zipfile) { 
 try { 
  // Create the ZIP file 
  ZipOutputStream out = new ZipOutputStream(new FileOutputStream(zipfile)); 
  // Compress the files 
  System.out.println(srcfile.entrySet().size()); 
  for (Map.Entry<String, InputStream> fileEntry:srcfile.entrySet()) { 
  InputStream in = fileEntry.getValue(); 
  // Add ZIP entry to output stream. 
  System.out.println(in.available()); 
  out.putNextEntry(new ZipEntry(fileEntry.getKey())); 
  // Transfer bytes from the file to the ZIP file 
  byte[] bytes=IOUtils.toByteArray(in); 
  out.write(bytes); 
  out.closeEntry(); 
  in.close(); 
  } 
  // Complete the ZIP file 
  out.close(); 
 } catch (IOException e) { 
  log.error("ZipUtil zipFiles exception:"+e); 
  System.out.println(e.getMessage()); 
 } 
 } 
 
 
 /** 
 *      
 * srcfile:key:   ,value:          
 * @param srcfile 
 * @param zipfile 
 * @see 
 */ 
 public static void zipByArray(Map<String,byte[]> srcfile, File zipfile) { 
 byte[] buf = new byte[1024]; 
 try { 
  // Create the ZIP file 
  ZipOutputStream out = new ZipOutputStream(new FileOutputStream(zipfile)); 
  // Compress the files 
  System.out.println(srcfile.entrySet().size()); 
  for (Map.Entry<String, byte[]> fileEntry:srcfile.entrySet()) { 
  //InputStream in = fileEntry.getValue(); 
  // Add ZIP entry to output stream. 
  out.putNextEntry(new ZipEntry(fileEntry.getKey())); 
  // Transfer bytes from the file to the ZIP file 
  byte[] bytes=fileEntry.getValue();//IOUtils.toByteArray(in); 
  out.write(bytes); 
  out.closeEntry(); 
  //in.close(); 
  } 
  // Complete the ZIP file 
  out.close(); 
 } catch (IOException e) { 
  log.error("ZipUtil zipFiles exception:"+e); 
  System.out.println(e.getMessage()); 
 } 
 } 
 
 /** 
 *     
 * 
 * @param zipfile File          
 * @param descDir String          
 */ 
 public static void unZipFiles(File zipfile, String descDir) { 
 try { 
  // Open the ZIP file 
  ZipFile zf = new ZipFile(zipfile); 
  for (Enumeration entries = zf.entries(); entries.hasMoreElements();) { 
  // Get the entry name 
  ZipEntry entry = ((ZipEntry) entries.nextElement()); 
  String zipEntryName = entry.getName(); 
  InputStream in = zf.getInputStream(entry); 
  // System.out.println(zipEntryName); 
  OutputStream out = new FileOutputStream(descDir + zipEntryName); 
  byte[] buf1 = new byte[1024]; 
  int len; 
  while ((len = in.read(buf1)) > 0) { 
   out.write(buf1, 0, len); 
  } 
  // Close the file and stream 
  in.close(); 
  out.close(); 
  } 
 } catch (IOException e) { 
  log.error("ZipUtil unZipFiles exception:"+e); 
 } 
 } 
 
 /** 
 * Main 
 * 
 * @param args 
 */ 
 public static void main(String[] args) { 
 List<File> srcfile=new ArrayList<File>(); 
 srcfile.add(new File("d:\\1.jpg")); 
 srcfile.add(new File("d:\\2.jpg")); 
 srcfile.add(new File("d:\\3.jpg")); 
 srcfile.add(new File("d:\\4.jpg")); 
 File zipfile = new File("d:\\pic.zip"); 
 ZipUtil.zipFiles(srcfile, zipfile); 
 } 
} 

이상 이 바로 본 고의 모든 내용 입 니 다.여러분 의 학습 에 도움 이 되 고 저 희 를 많이 응원 해 주 셨 으 면 좋 겠 습 니 다.

좋은 웹페이지 즐겨찾기