java实现socket文件传输

事实上网络编程简单的理解就是两台计算机相互通讯数据而已.对于程序员而言,去掌握一种编程接口并使用一种编程模型相对就会显得简单的多了.Java SDK提供一些相对简单的Api来完成这些工作.Socket就是其中之一.对于Java而言.这些Api存在与java.net 这个包里面.因此只要导入这个包就可以准备网络编程了. 
网络编程的基本模型就是客户机到服务器模型.简单的说就是两个进程之间相互通讯,然后其中一个必须提供一个固定的位置,而另一个则只需要知道这个固定的位置.并去建立两者之间的联系..然后完成数据的通讯就可以了.这里提供固定位置的通常称为服务器,而建立联系的通常叫做客户端.基于这个简单的模型,就可以进入网络编程啦. 

Java对这个模型的支持有很多种Api.而这里我只想介绍有关Socket的编程接口.对于Java而言已经简化了Socket的编程接口.首先我们来讨论有关提供固定位置的服务方是如何建立的.Java提供了ServerSocket来对其进行支持.事实上当你创建该类的一个实力对象并提供一个端口资源你就建立了一个固定位置可以让其他计算机来访问你. 

ServerSocket server=new ServerSocket(6789); 

这里稍微要注意的是端口的分配必须是唯一的.因为端口是为了唯一标识每台计算机唯一服务的.另外端口号是从0~65535之间的,前1024个端口已经被Tcp/Ip 作为保留端口,因此你所分配的端口只能是1024个之后的.好了.我们有了固定位置.现在所需要的就是一根连接线了.该连接线由客户方首先提出要求.因此Java同样提供了一个Socket对象来对其进行支持.只要客户方创建一个Socket的实例对象进行支持就可以了. 

Socket client=new Socket(InetAddress.getLocalHost(),5678);

客户机必须知道有关服务器的IP地址.对于这一点Java也提供了一个相关的类InetAddress 该对象的实例必须通过它的静态方法来提供.它的静态方法主要提供了得到本机IP 和通过名字或IP直接得到InetAddress的方法. 
上面的方法基本可以建立一条连线让两台计算机相互交流了.

下面是socket传文件的一个简单例子。

发送端代码：

[java] view plain copy

1. package fileTransmission;  
2.   
3. import java.io.BufferedInputStream;  
4. import java.io.DataInputStream;  
5. import java.io.DataOutputStream;  
6. import java.io.File;  
7. import java.io.FileInputStream;  
8. import java.io.FileNotFoundException;  
9. import java.io.IOException;  
10. import java.net.ServerSocket;  
11. import java.net.Socket;  
12.   
13. public class FileSender {  
14.     private ServerSocket ss=null;  
15.     public FileSender(){  
16.           
17.     }  
18.     public void sendFile(String filePath,int port){  
19.         DataOutputStream dos=null;  
20.         DataInputStream dis=null;  
21.           
22.         Socket socket=null;  
23.         try {  
24.             File file=new File(filePath);  
25.             ss=new ServerSocket(port);  
26.             socket=ss.accept();  
27.             dos=new DataOutputStream(socket.getOutputStream());  
28.             dis=new DataInputStream(new BufferedInputStream(new FileInputStream(filePath)));  
29.               
30.             int buffferSize=1024;  
31.             byte[]bufArray=new byte[buffferSize];  
32.             dos.writeUTF(file.getName());   
33.             dos.flush();   
34.             dos.writeLong((long) file.length());   
35.             dos.flush();   
36.             while (true) {   
37.                 int read = 0;   
38.                 if (dis!= null) {   
39.                   read = dis.read(bufArray);   
40.                 }   
41.   
42.                 if (read == -1) {   
43.                   break;   
44.                 }   
45.                 dos.write(bufArray, 0, read);   
46.               }   
47.               dos.flush();  
48.         } catch (FileNotFoundException e) {  
49.             // TODO Auto-generated catch block  
50.             e.printStackTrace();  
51.         } catch (IOException e) {  
52.             // TODO Auto-generated catch block  
53.             e.printStackTrace();  
54.         } finally {   
55.               // 关闭所有连接   
56.               try {   
57.                 if (dos != null)   
58.                   dos.close();   
59.               } catch (IOException e) {   
60.               }   
61.               try {   
62.                 if (dis != null)   
63.                   dis.close();   
64.               } catch (IOException e) {   
65.               }   
66.               try {   
67.                 if (socket != null)   
68.                   socket.close();   
69.               } catch (IOException e) {   
70.               }   
71.               try {   
72.                 if (ss != null)   
73.                   ss.close();   
74.               } catch (IOException e) {   
75.               }   
76.             }   
77.   
78.   
79.     }  
80.     public static void main(String []args){  
81.         new FileSender().sendFile("E:/VITA文档记录.doc", 8821);  
82.     }  
83. }  

接收端代码：

[java] view plain copy

1. package fileTransmission;  
2.   
3. import java.io.BufferedInputStream;  
4. import java.io.BufferedOutputStream;  
5. import java.io.DataInputStream;  
6. import java.io.DataOutputStream;  
7. import java.io.FileOutputStream;  
8. import java.io.IOException;  
9. import java.net.Socket;  
10. import java.net.UnknownHostException;  
11.   
12. public class FileIncepter {  
13.     public FileIncepter(){  
14.           
15.     }  
16.     public void receiveFile(String savePath,String ip,int port){  
17.         Socket socket=null;  
18.         try {   
19.             socket = new Socket(ip,port);   
20.           } catch (UnknownHostException e1) {   
21.             e1.printStackTrace();   
22.           } catch (IOException e1) {   
23.             e1.printStackTrace();   
24.           }   
25.         DataInputStream dis=null;  
26.         try {   
27.             dis = new DataInputStream(new BufferedInputStream(socket   
28.                 .getInputStream()));   
29.           } catch (IOException e1) {   
30.             e1.printStackTrace();   
31.           }   
32.         int bufferSize = 1024;   
33.         // 缓冲区   
34.         byte[] buf = new byte[bufferSize];   
35.         int passedlen = 0;   
36.         long len = 0;   
37.         // 获取文件名称   
38.        try{  
39.         savePath += dis.readUTF();   
40.         DataOutputStream fileOut = new DataOutputStream(   
41.             new BufferedOutputStream(new BufferedOutputStream(   
42.                 new FileOutputStream(savePath))));   
43.         len = dis.readLong();   
44.         System.out.println("文件的长度为:" + len + "    KB");   
45.         System.out.println("开始接收文件!");   
46.         while (true) {   
47.             int read = 0;   
48.             if (dis!= null) {   
49.               read = dis.read(buf);   
50.             }   
51.             passedlen += read;   
52.             if (read == -1) {   
53.               break;   
54.             }   
55.             System.out.println("文件接收了" + (passedlen * 100 / len) + "%");   
56.             fileOut.write(buf, 0, read);   
57.           }   
58.           System.out.println("接收完成，文件存为" + savePath);   
59.           fileOut.close();   
60.         } catch (Exception e) {   
61.           e.printStackTrace();   
62.           return;   
63.         }   
64.     }  
65.     public static void main(String[] args) {   
66.         new FileIncepter().receiveFile("F:\\", "localhost", 8821);   
67.       }    
68. }