SOCKET 文件传输

要求将服务端文件夹A下的文件拷贝到客户端文件A下 删除服务端文件夹A下的文件；
客户端文件夹B下的文件拷贝到服务端文件B下  然后删除客户端文件夹B下的文件；

技巧：实现过程中将要传输的文件打包后传输



服务端：

package com.socket.filetrans.exe;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;

import com.socket.filetrans.LoadParamConfig;
import com.socket.zip.util.ZipUtil;


public class ServerTest   {
    
	int port = 0;
    static String SERVER_SENDPATH = "";
    String SERVER_SAVEPATH="";
    ServerSocket ss = null;
    Socket s = null;
    DataInputStream dis=null;
    DataOutputStream dos=null;
    static List fileList=new ArrayList();
    static ZipUtil zipUtilObj=new ZipUtil();
    public ServerTest() throws IOException{
    	Properties properties=LoadParamConfig.getProperties();
    	SERVER_SENDPATH=properties.getProperty("SERVER_SENDPATH");
    	SERVER_SAVEPATH=properties.getProperty("SERVER_SAVEPATH");
    	port=Integer.parseInt(properties.getProperty("SOCKET_PORT"));
    	ss=new ServerSocket(port);
    	 
    	File file=new File(SERVER_SENDPATH);
        if(!file.exists()){
       	 file.mkdir();
       	 System.out.println("创建目录:"+SERVER_SENDPATH);
        }  
        File file2=new File(SERVER_SAVEPATH);
        if(!file2.exists()){
       	 file2.mkdir();
       	 System.out.println("创建目录:"+SERVER_SAVEPATH);
       	 
       	
        }  
    }
   
    public static void main(String arg[]) {
        try {
        	
        	ServerTest server=new ServerTest();
        	while(true){
        		fileList=new ArrayList();
        		server.serverStart();
        		server.deleteDirectory(new File(SERVER_SENDPATH));
        		fileList=null;
        		//短时间内new socket操作很多,而socket.close()操作并不能立即释放绑定的端口,
        		//而是把端口设置为TIME_WAIT状态,过段时间(默认240s)才释放
        	    Thread.sleep(240000);
        	}
        	
		} catch (Exception e) {
			e.printStackTrace();
		}
    }
    
    public void serverStart() throws Exception {
    	
    
    	//===============================服务端批量写文件==========================================//
    	     File ZipFilePath=null;
    	     getAllFiles(SERVER_SENDPATH);
    	     
    	   while(true){ 
    	    if(new File(SERVER_SENDPATH).renameTo(new File(SERVER_SENDPATH))){
    	      if(fileList.size()>0){
    	    	 //压缩文件
    	    	 zipUtilObj.zip(SERVER_SENDPATH+".zip", SERVER_SENDPATH);
    	         //压缩文件绝对路径
    	    	  ZipFilePath=new File(SERVER_SENDPATH+".zip");
	    	
	    		  //写文件名
	    	      s = ss.accept();
	 		      dos = new DataOutputStream(s.getOutputStream());  
	 		      dos.writeUTF(ZipFilePath.getName());
	 		      System.out.println("服务端写文件名");
			      dos.close();
    			     
    			     
    			  //读确认信息
  	               s = ss.accept();
  	               dis= new DataInputStream(new BufferedInputStream(s.getInputStream()));   
  	  		      System.out.println(dis.readUTF());     
    			     
  	  		      
    	    	 //写数据
	    		   s = ss.accept();
	    		   DataInputStream fis = new DataInputStream(new BufferedInputStream(new FileInputStream(ZipFilePath)));
	    		   int bufferSize = 8192;
	               byte[] buf = new byte[bufferSize];
	               int read = 0;
	               while ((read = fis.read(buf))!=-1) {
	            	   dos = new DataOutputStream(s.getOutputStream());  
	                   dos.write(buf, 0, read);
	               }
	               dos.flush();
	               fis.close();
	               s.close();
	               System.out.println("服务端 写数据完成...");
	               
	               
	             //读信号
	               s = ss.accept();
	               dis= new DataInputStream(new BufferedInputStream(s.getInputStream()));   
	  		      System.out.println("服务端 读信号:"+dis.readUTF()+"\n");   
    	       }
    	      
    	       break;
    	     } 
         }
             // 服务端文件结束标志
    	     System.out.println("服务端没有数据发送或发送完成！");
    	     s = ss.accept();
 		     dos = new DataOutputStream(s.getOutputStream());  
 		     dos.writeUTF("serverFileSendOver");
		     dos.close();
    	   
		     //删除发送完的zip文件
			 boolean deleted2=false;
				if(ZipFilePath!=null){
					while(!deleted2){
						deleted2=ZipFilePath.delete();
					}
				}
		   //===============================服务端批量写文件 结束==========================================//
		   
    	
    	
    
    	
		 //===============================服务端批接收 文件==============================================//
				
			String	fileABSPath="";
			File tempFile=null;
	     while(true){
	    	 
	    	 //读文件名  或者结束标志
    	 	 s = ss.accept();
			 dis= new DataInputStream(new BufferedInputStream(s.getInputStream())); 
			 String fileName="";
			
			 if("clientFileSendOver".endsWith(fileName=dis.readUTF())){
				 System.out.println("服务端 收到客户端文件结束标志:"+fileName);   
				 break;
			 }
			 System.out.println("服务端 收到文件名:"+fileName);   
	    	 
			//写确认信息
			  s = ss.accept();
              dos = new DataOutputStream(new BufferedOutputStream(s.getOutputStream()));
              dos.writeUTF("服务端 确认收到文件名:"+fileName);
			   // dos.flush();
			  dos.close();
	    	 
			//读文件
		    fileABSPath=SERVER_SAVEPATH+File.separator+fileName;
            File tempdir=new File(fileABSPath.substring(0, fileABSPath.lastIndexOf("\\")));
            tempFile=new File(fileABSPath);
            if(!tempdir.exists()){
         	   tempdir.mkdirs();
	               
            }
            if(!tempFile.exists()){
         	   tempFile.createNewFile();
            }
            s = ss.accept();
			DataOutputStream fos = new DataOutputStream(new BufferedOutputStream(new BufferedOutputStream(new FileOutputStream(tempFile))));
			dis= new DataInputStream(new BufferedInputStream(s.getInputStream()));   
			 int bufferSize = 8192;
	         byte[] buf = new byte[bufferSize];
	         int read = 0;
	         while ((read = dis.read(buf))!=-1) {
	                fos.write(buf, 0, read);
	            }
	         fos.close();
	         System.out.println("服务端 读取数据完成...");
	         
	         
	         //写信号
	          s = ss.accept();
                dos = new DataOutputStream(new BufferedOutputStream(s.getOutputStream()));
                dos.writeUTF("ServerRecieved");
			   // dos.flush();
			  dos.close();
			  
			   System.out.println("......服务端 接收数据结束...开始解压文件...");
				
	     }
	     
		 
	       //解压数据
			if(!"".equals(fileABSPath) && ".zip".equals(fileABSPath.substring(fileABSPath.lastIndexOf(".")))){
				zipUtilObj.unzip(fileABSPath, SERVER_SAVEPATH);	
			}
			//删除压缩文件
			boolean deleted=false;
			if(tempFile!=null){
				while(!deleted){
					deleted=tempFile.delete();
				}
			}
    }
    //===============================服务端批接收 文件  结束==============================================//  
 	      
    
    
    
    
    /*
	 * 递归删除一个目录以及下面的文件
	 */
	public  boolean deleteDirectory(File path) {   
	    if( path.exists() ) {   
	      File[] files = path.listFiles();   
	      for(int i=0; i<files.length; i++) {   
	         if(files[i].isDirectory()) {   
	           deleteDirectory(files[i]);  
	         }   
	         else {   
	        	 //删除文件
	           files[i].delete();   
	         }   
	      }   
	    }   
	   //删除目录
	    boolean hasdelete=false;
	    if(!SERVER_SENDPATH.equals(path.getAbsolutePath())){
	     hasdelete=path.delete();
	    if(hasdelete){
	    	System.out.println("删除目录:"+path);
	    	
	    }
	    }
		return hasdelete;
	    
	    
	  }   
    /**
     * 得到服务端要发送的文件列表
     * @param dir
     * @return
     * @throws Exception
     */
    public void  getAllFiles(String dir) throws Exception{
    	File file=new File(dir);
    	 
    	if(!file.exists()){
    		file.mkdir();
    	}
    	File[] fs = file.listFiles();
		 if(fs!=null){
			 for(int i=0; i<fs.length; i++){
				   if(fs[i].isFile()){
					   fileList.add(fs[i].getAbsolutePath().substring(SERVER_SENDPATH.length()));
				   }
				   if(fs[i].isDirectory()){
				    try{
				    	getAllFiles(fs[i].getPath());
				    }catch(Exception e){}
				   }
				  } 
		 }
		
		 
		
		  
		 
  }

   

	
}

客户端：

package com.socket.filetrans.exe;


import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;

import com.socket.filetrans.LoadParamConfig;
import com.socket.zip.util.ZipUtil;


public class ClientTest {
    private Socket socket = null;

    private String ip = "";// 设置成服务器IP

    private int port = 0;
    
    static List fileList=null;;
    static String CLIENT_SENDPATH ="";
    String CLIENT_SAVEPATH="";
    DataInputStream dis=null;
    DataOutputStream dos=null;
    static ZipUtil zipUtilObj=new ZipUtil();
    
public ClientTest() {
        try {
        	Properties properties=LoadParamConfig.getProperties();
        	CLIENT_SENDPATH=properties.getProperty("CLIENT_SENDPATH");
        	CLIENT_SAVEPATH=properties.getProperty("CLIENT_SAVEPATH");
        	port=Integer.parseInt(properties.getProperty("SOCKET_PORT"));
        	ip=properties.getProperty("IP_ADDRESS");
        	File file=new File(CLIENT_SENDPATH);
            if(!file.exists()){
           	 file.mkdir();
           	 System.out.println("创建目录:"+CLIENT_SENDPATH);
            }  
            File file2=new File(CLIENT_SAVEPATH);
            if(!file2.exists()){
           	 file2.mkdir();
           	 System.out.println("创建目录:"+CLIENT_SAVEPATH);
            }  
        	
        
        	
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

	public static void main(String arg[]) {
	    try {
	    	
	    	ClientTest client=new ClientTest();
	    	while(true){
	    	fileList=new ArrayList();
	    	 client.clientStart();
	    	 client.deleteDirectory(new File(CLIENT_SENDPATH));
	    	 fileList=null;
	    	//短时间内new socket操作很多,而socket.close()操作并不能立即释放绑定的端口,
     		//而是把端口设置为TIME_WAIT状态,过段时间(默认240s)才释放
	    	 Thread.sleep(240000);
	    	}
	    	 
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	
    public void clientStart() throws Exception {
		
    	    String fileABSPath="";
    	    File tempFile=null;
			//=======================客户端批量 读取文件==================================//
			while(true){
				
				//读文件名 或者结束标志
				 socket = new Socket(ip, port);
				 dis= new DataInputStream(new BufferedInputStream(socket.getInputStream())); 
				 String fileName="";
				
				 if("serverFileSendOver".endsWith(fileName=dis.readUTF())){
					 System.out.println("客户端 收到服务端文件结束标志:"+fileName);   
					 break;
				 }
				 System.out.println("收到文件名:"+fileName);   
				 
				 
				 //写确认信息
				  socket = new Socket(ip, port);
	              dos = new DataOutputStream(new BufferedOutputStream(socket.getOutputStream()));
	              dos.writeUTF("客户端 确认收到文件名:"+fileName);
				   // dos.flush();
				  dos.close();
				    
				    
				//读 
			    fileABSPath=CLIENT_SAVEPATH+File.separator+fileName;
	            File tempdir=new File(fileABSPath.substring(0, fileABSPath.lastIndexOf("\\")));
	            tempFile=new File(fileABSPath);
	            if(!tempdir.exists()){
	         	   tempdir.mkdirs();
		               
	            }
	            if(!tempFile.exists()){
	         	   tempFile.createNewFile();
	            }
				socket = new Socket(ip, port);
				DataOutputStream fos = new DataOutputStream(new BufferedOutputStream(new BufferedOutputStream(new FileOutputStream(tempFile))));
				dis= new DataInputStream(new BufferedInputStream(socket.getInputStream()));   
				 int bufferSize = 8192;
		         byte[] buf = new byte[bufferSize];
		         int read = 0;
		         while ((read = dis.read(buf))!=-1) {
		                fos.write(buf, 0, read);
		            }
		         fos.close();
		         System.out.println("客户端 读取数据完成...");
		         
		         
		         //写信号
                socket = new Socket(ip, port);
                dos = new DataOutputStream(new BufferedOutputStream(socket.getOutputStream()));
                dos.writeUTF("ClientRecieved");
                System.out.println("客户端 发送 收到信号:ClientRecieved"+"\n");
			   // dos.flush();
			    dos.close();
			    
			    System.out.println("......客户端 接收数据结束...开始解压文件...");
				
			   
			}
			
			//解压数据
			if(!"".equals(fileABSPath) && ".zip".equals(fileABSPath.substring(fileABSPath.lastIndexOf(".")))){
				zipUtilObj.unzip(fileABSPath, CLIENT_SAVEPATH);	
			}
			//删除压缩文件
			boolean deleted=false;
			if(tempFile!=null){
				while(!deleted){
					deleted=tempFile.delete();
				}
			}
			
			//=======================客户端批量 读取文件 结束==================================//    
			 
			
			
			
		  //=======================客户端批量  发送文件    ==================================//   	
		
			File ZipFilePath=null;
		   
			getAllFiles(CLIENT_SENDPATH);
			
		   while(true){ 
		
			 if(new File(CLIENT_SENDPATH).renameTo(new File(CLIENT_SENDPATH))){
			
		     if(fileList.size()>0){
				 //压缩文件
    	     zipUtilObj.zip(CLIENT_SENDPATH+".zip", CLIENT_SENDPATH);
    	         //压缩文件绝对路径
    	     ZipFilePath=new File(CLIENT_SENDPATH+".zip");
    	    
    	     
    	    
    	    	 //写文件名
                socket = new Socket(ip, port);
                dos = new DataOutputStream(new BufferedOutputStream(socket.getOutputStream()));
                dos.writeUTF(ZipFilePath.getName());
                System.out.println("客户端写文件名");
			   // dos.flush();
			    dos.close();
    	    	 
			  //读确认信息
			    socket = new Socket(ip, port);
	               dis= new DataInputStream(new BufferedInputStream(socket.getInputStream()));   
	  		      System.out.println(dis.readUTF());     
    	    
			
    	     //写数据
  	       
             
             socket = new Socket(ip, port);
  		   DataInputStream fis = new DataInputStream(new BufferedInputStream(new FileInputStream(ZipFilePath)));
  		   int bufferSize = 8192;
             byte[] buf = new byte[bufferSize];
             int read = 0;
             while ((read = fis.read(buf))!=-1) {
          	   dos = new DataOutputStream(socket.getOutputStream());  
                 dos.write(buf, 0, read);
             }
             dos.flush();
             fis.close();
             socket.close();
             System.out.println("客户端 写数据完成...");
             
             
            //读信号
             socket = new Socket(ip, port);
             dis= new DataInputStream(new BufferedInputStream(socket.getInputStream()));   
		     System.out.println("客户端 读信号:"+dis.readUTF()+"/n");    
			 
    	     }
		   break;
		     }
		 }
	   
				
			//客户端文件结束标志
			 System.out.println("客户端 没有数据发送或发送完成！");
    	     socket = new Socket(ip, port);
 		     dos = new DataOutputStream(socket.getOutputStream());  
 		     dos.writeUTF("clientFileSendOver");
		     dos.close(); 
    	  
	     
	  
		 
	    
		//删除发送完的zip文件
		 boolean deleted2=false;
			if(ZipFilePath!=null){
				while(!deleted2){
					deleted2=ZipFilePath.delete();
				}
			}
		  //=======================客户端批量 发送文件 结束    ==================================//    	
			
			
			
			
 }
		
		
	
     
     
     
     /*
 	 * 递归删除一个目录以及下面的文件
 	 */
 	public  boolean deleteDirectory(File path) {   
 	    if( path.exists() ) {   
 	      File[] files = path.listFiles();   
 	      for(int i=0; i<files.length; i++) {   
 	         if(files[i].isDirectory()) {   
 	           deleteDirectory(files[i]);  
 	         }   
 	         else {   
 	        	 //删除文件
 	           files[i].delete();   
 	         }   
 	      }   
 	    }   
 	   //删除目录
 	   boolean hasdelete=false;
	    if(!CLIENT_SENDPATH.equals(path.getAbsolutePath())){
 	     hasdelete=path.delete();
 	    if(hasdelete){
 	    	System.out.println("删除目录:"+path);
 	    	
 	    }
	    }
 		return hasdelete;
 	    
 	    
 	  }   
     
    

    
    /**
     * 得到服务端要发送的文件列表
     * @param dir
     * @return
     * @throws Exception
     */
 	 public void  getAllFiles(String dir) throws Exception{
     	File file=new File(dir);
     	 
     	if(!file.exists()){
     		file.mkdir();
     	}
     	File[] fs = file.listFiles();
 		 if(fs!=null){
 			 for(int i=0; i<fs.length; i++){
 				   if(fs[i].isFile()){
 					   fileList.add(fs[i].getAbsolutePath().substring(CLIENT_SENDPATH.length()));
 				   }
 				   if(fs[i].isDirectory()){
 				    try{
 				    	getAllFiles(fs[i].getPath());
 				    }catch(Exception e){}
 				   }
 				  } 
 		 }
 		  
 		 
   }

   
}

配置文件：

######### CLIENT_CONFIG #########
CLIENT_SENDPATH=D:\\SOCKET\\client_fa
CLIENT_SAVEPATH=D:\\SOCKET\\client_shou
SOCKET_PORT=8873
IP_ADDRESS=localhost

######### SERVER_CONFIG #########
SERVER_SENDPATH=D:\\SOCKET\\server_fa
SERVER_SAVEPATH=D:\\SOCKET\\server_shou

参数加载器：

package com.socket.filetrans;

import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.util.Properties;

public class LoadParamConfig {

	public static Properties  getProperties(){
		Properties	properties=new Properties();
		   URL url= Thread.currentThread().getContextClassLoader().getResource("config.properties");
		       InputStream in = null; 
		       if(url != null){
		        try {
					in = url.openStream();
					properties.load(in);
					//String path=properties.getProperty("importFilePath");
				} catch (IOException e) {
					e.printStackTrace();
				}
		       }
			return properties;
	}
	  

}

ZIP压缩和解压缩工具包：

package com.socket.zip.util;

import java.util.*;
import java.util.zip.*;
import java.io.*;

public class ZipUtil 
{
	public void zip(String zipFileName,String inputFile)throws Exception{
		zip(zipFileName,new File(inputFile));
	}
	public void zip(String zipFileName,File inputFile)throws Exception{
		ZipOutputStream out=new ZipOutputStream(new FileOutputStream(zipFileName));
		zip(out,inputFile,"");
		System.out.println("zip done");
		out.close();
	}

	public void unzip(String zipFileName,String outputDirectory)throws Exception{
		ZipInputStream in=new ZipInputStream(new FileInputStream(zipFileName));
		ZipEntry z;
		while ((z=in.getNextEntry() )!= null)
		{
			System.out.println("unziping "+z.getName());
			if (z.isDirectory())
			{
				String name=z.getName();
				name=name.substring(0,name.length()-1);
				File f=new File(outputDirectory+File.separator+name);
				f.mkdir();
				System.out.println("mkdir "+outputDirectory+File.separator+name);
			}
			else{
				File f=new File(outputDirectory+File.separator+z.getName());
				f.createNewFile();
				FileOutputStream out=new FileOutputStream(f);
				int b;
				while ((b=in.read()) != -1)
					out.write(b);
				out.close();
			}
		}

		in.close();
	}

	public void zip(ZipOutputStream out,File f,String base)throws Exception{
		System.out.println("Zipping  "+f.getName());
		if (f.isDirectory())
		{
			File[] fl=f.listFiles();
			out.putNextEntry(new ZipEntry(base+"/"));
			base=base.length()==0?"":base+"/";
			for (int i=0;i<fl.length ;i++ )
			{
				zip(out,fl[i],base+fl[i].getName());
			}
		}
		else
		{
			out.putNextEntry(new ZipEntry(base));
			FileInputStream in=new FileInputStream(f);
			int b;
			while ((b=in.read()) != -1)
				out.write(b);
			in.close();
		}

	}
	
	
	public static void main(String[] args) 
	{
		try{
		ZipUtil t=new ZipUtil();
		t.zip("D:\\wulihai\\SocketTrans.zip","D:\\wulihai\\SocketTrans");
		t.unzip("D:\\wulihai\\SocketTrans.zip","D:\\wulihai\\开发手册");
		}
		catch(Exception e){e.printStackTrace(System.out);}
	}
}

评论

1 楼 wujianjun12315 2011-07-19