DatagramSocket类简单实现文件下载

转载自：http://www.cnblogs.com/kinghitomi/archive/2012/01/19/2327449.html

1、服务器端代码

1.  
2. import java.io.File;  
3. import java.io.FileInputStream;  
4. import java.io.FileNotFoundException;  
5. import java.io.IOException;  
6. import java.io.InputStream;  
7. import java.net.DatagramPacket;  
8. import java.net.DatagramSocket;  
9. import java.net.SocketException;  
10. import java.util.concurrent.ExecutorService;  
11. import java.util.concurrent.Executors;  
12.   
13. /** 
14.  * 下载服务器,采用UDP协议，传送的过程中可能会丢包，导致下载的文件不完整 
15.  */  
16. public class DownloadServer {  
17.     // 提供服务  
18.     public void service() {  
19.         try {  
20.             // 创建本机指定端口8289的服务器  
21.             DatagramSocket dataSocket = new DatagramSocket(8289);  
22.             // 线程池，固定有十个线程  
23.             ExecutorService ThreadPool = Executors.newFixedThreadPool(10);  
24.   
25.             while (true) {// 不断接收来自客户端的请求  
26.                 byte[] buff = new byte[101];// 文件名长度不超过50  
27.                 DatagramPacket dataPacket = new DatagramPacket(buff, buff.length);  
28.                 dataSocket.receive(dataPacket);// 等待接收来自客户端的数据包  
29.                 // 接收到数据包，开一个线程为该客户服务  
30.                 ThreadPool.execute(new WorkThread(dataPacket));  
31.             }  
32.         } catch (SocketException e) {  
33.             e.printStackTrace();  
34.         } catch (IOException e) {  
35.             e.printStackTrace();  
36.         }  
37.     }  
38.   
39.     // 内部类，为每个客户提供服务  
40.     private class WorkThread implements Runnable {  
41.         private DatagramPacket packet;  
42.         private DatagramSocket dataSocket;  
43.   
44.         public WorkThread(DatagramPacket packet) {  
45.             this.packet = packet;  
46.             try {// 创建本机可以端口的DatagramSocket  
47.                 dataSocket = new DatagramSocket();  
48.             } catch (SocketException e) {  
49.                 e.printStackTrace();  
50.             }  
51.         }  
52.   
53.         // 获取可以下载的文件列表传送给客户端  
54.         private void showFiles() {  
55.             File files = new File("upload_download");  
56.             File[] allFile = files.listFiles();// 获取所有文件  
57.             StringBuffer message = new StringBuffer();  
58.             for (File f : allFile) {  
59.                 if (f.isFile()) {  
60.                     message.append(f.getName());  
61.                     message.append('\n');  
62.                 }  
63.             }  
64.             // 构造响应数据包  
65.             byte[] response = message.toString().getBytes();  
66.             DatagramPacket dataPacket = new DatagramPacket(response, response.length, packet.getAddress(), packet.getPort());  
67.             try {// 发送  
68.                 dataSocket.send(dataPacket);  
69.             } catch (IOException e) {  
70.                 e.printStackTrace();  
71.             }  
72.         }  
73.   
74.         // 下载指定的文件  
75.         private void download(String fileName) {  
76.             try {  
77.                 InputStream in = new FileInputStream("upload_download/" + fileName);  
78.                 DatagramPacket dataPacket;  
79.                 byte[] response = new byte[60000];// 每次发送60000字节  
80.                 while (true) {  
81.                     int len = in.read(response, 0, response.length);  
82.                     dataPacket = new DatagramPacket(response, len, packet.getAddress(), packet.getPort());  
83.                     dataSocket.send(dataPacket);// 发送  
84.                     if (in.available() == 0)// 发送完毕  
85.                         break;  
86.                 }  
87.                 in.close();  
88.             } catch (FileNotFoundException e) {  
89.                 e.printStackTrace();  
90.             } catch (IOException e) {  
91.                 e.printStackTrace();  
92.             }  
93.         }  
94.   
95.         @Override  
96.         public void run() {  
97.             // 获取客户端传送过来的数据  
98.             byte[] data = packet.getData();  
99.             // 表示客户端点击显示文件按钮，该请求是要得到所有可以下载的文件  
100.             if (data[0] == 0)  
101.                 showFiles();  
102.             else if (data[0] == 1)// 表示客户端的请求是下载请求  
103.                 download(new String(data, 1, packet.getLength()).trim());  
104.             else  
105.                 System.out.println("请求错误");  
106.         }  
107.     }  
108.   
109.     public static void main(String[] args) {  
110.         new DownloadServer().service();  
111.     }  
112. }  

说明：DatagramSocket 类是基于UDP协议，服务器端默认提供下载的文件存放在当前目录下的upload_download文件夹中。服务器采用线程池能同时为多个用户服务

2、客户端代码

1. import java.awt.BorderLayout;  
2. import java.awt.GridLayout;  
3. import java.awt.event.ActionEvent;  
4. import java.awt.event.ActionListener;  
5. import java.io.File;  
6. import java.io.FileOutputStream;  
7. import java.io.IOException;  
8. import java.io.OutputStream;  
9. import java.net.DatagramPacket;  
10. import java.net.DatagramSocket;  
11. import java.net.InetAddress;  
12.   
13. import javax.swing.*;  
14.   
15. /** 
16.  * 下载客户端 
17.  */  
18. public class DownloadClient extends JFrame {  
19.     // 显示可下载的文件  
20.     private JTextArea textArea = new JTextArea();  
21.   
22.     private JPanel panel = new JPanel();  
23.     // 下载时保存文件  
24.     private JFileChooser saveFile = new JFileChooser(".");  
25.   
26.     private JButton showButton = new JButton("显示文件");  
27.     private JButton downloadButton = new JButton("下载...");  
28.     // 下载时填入要下载的文件名，注意文件名必须是textArea显示的文件名  
29.     private JTextField downloadFile = new JTextField("");  
30.   
31.     private DatagramSocket dataSocket=null;  
32.   
33.     public DownloadClient() {  
34.         // frame 的基本设置  
35.         this.setTitle("下载客户端");  
36.         this.setVisible(true);  
37.         this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  
38.         this.setSize(400, 500);  
39.         this.setLayout(new BorderLayout());  
40.         this.setResizable(false);  
41.   
42.         // 设置不可编辑  
43.         textArea.setEditable(false);  
44.   
45.         panel.setLayout(new GridLayout(3, 2, 5, 5));  
46.         panel.add(new JLabel("点击按钮显示可下载的文件"));  
47.         panel.add(showButton);  
48.         panel.add(downloadFile);  
49.         panel.add(downloadButton);  
50.   
51.         // 组件加入frame中  
52.         add(new JScrollPane(textArea));  
53.         add(panel, BorderLayout.SOUTH);  
54.   
55.         // saveFile只能打开目录  
56.         saveFile.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);  
57.   
58.         // 显示文件按钮注册事件  
59.         showButton.addActionListener(new ActionListener() {  
60.             @Override  
61.             public void actionPerformed(ActionEvent e) {  
62.                 showButton.setEnabled(false);  
63.                 downloadButton.setEnabled(false);  
64.                 showFiles();  
65.                 showButton.setEnabled(true);  
66.                 downloadButton.setEnabled(true);  
67.             }  
68.         });  
69.   
70.         // 下载按钮注册事件  
71.         downloadButton.addActionListener(new ActionListener() {  
72.             @Override  
73.             public void actionPerformed(ActionEvent e) {  
74.                 showButton.setEnabled(false);  
75.                 downloadButton.setEnabled(false);  
76.                 downloadFile();  
77.                 showButton.setEnabled(true);  
78.                 downloadButton.setEnabled(true);  
79.             }  
80.         });  
81.     }  
82.   
83.     // 显示文件  
84.     private void showFiles() {  
85.         try {  
86.             if (dataSocket == null)  
87.                 dataSocket = new DatagramSocket();  
88.             // 创建发送数据包并发送给服务器  
89.             byte[] request = { 0 };  
90.             DatagramPacket requestPacket = new DatagramPacket(request, request.length, InetAddress.getLocalHost(), 8289);  
91.             dataSocket.send(requestPacket);  
92.   
93.             // 接收服务器的数据包，显示在textArea中  
94.             byte[] receive = new byte[1024 * 1024];  
95.             DatagramPacket receivePacket = new DatagramPacket(receive, receive.length);  
96.             dataSocket.receive(receivePacket);  
97.             String str = new String(receivePacket.getData(), 0, receivePacket.getLength());  
98.             textArea.setText(str);  
99.         } catch (IOException e) {  
100.             e.printStackTrace();  
101.         }  
102.     }  
103.   
104.     // 下载文件  
105.     private void downloadFile() {  
106.         // 获取要下载的文件名  
107.         String fileName = downloadFile.getText().trim();  
108.         // 所有可以下载的文件  
109.         String allFiles = textArea.getText();  
110.         // 文件名为空  
111.         if (fileName == null || "".equals(fileName))  
112.             JOptionPane.showMessageDialog(null, "请选中正确的文件名", "文件名错误", JOptionPane.WARNING_MESSAGE);  
113.         // 文件名是在可以下载的文件中  
114.         else if (allFiles.contains((fileName + '\n'))) {  
115.             saveFile.showSaveDialog(null);  
116.             File f = saveFile.getSelectedFile();// 获取选中的文件夹  
117.             if (f.exists()) {  
118.                 // 检测该文件是否已经存在于目录中  
119.                 String[] fileNames = f.list();  
120.                 boolean exit = false;  
121.                 for (String name : fileNames)  
122.                     if (name.equals(fileName)) {  
123.                         exit = true;  
124.                         break;  
125.                     }  
126.   
127.                 if (exit)// 如果要下载的文件已经存在  
128.                     JOptionPane.showMessageDialog(null, "此文件已经存在", "请选择另外的文件下载", JOptionPane.WARNING_MESSAGE);  
129.                 else {  
130.                     // 发送的请求  
131.                     byte[] request = (new String(new byte[] { 1 }) + fileName).getBytes();  
132.                     try {  
133.                         if (dataSocket == null)  
134.                             dataSocket = new DatagramSocket();  
135.                         // 创建发送数据包并发送给服务器  
136.                         DatagramPacket requestPacket = new DatagramPacket(request, request.length, InetAddress.getLocalHost(), 8289);  
137.                         dataSocket.send(requestPacket);  
138.   
139.                         // 接收服务器的数据包,把文件保存在选中的文件夹中  
140.                         OutputStream out = new FileOutputStream(f.getAbsolutePath() + "/" + fileName, true);  
141.                         byte[] receive = new byte[60000];// 每次接收60000字节  
142.                         DatagramPacket receivePacket;  
143.                         // 不断接收来自服务器的数据包  
144.                         while (true) {  
145.                             receivePacket = new DatagramPacket(receive, receive.length);  
146.                             dataSocket.receive(receivePacket);  
147.                             out.write(receivePacket.getData(), 0, receivePacket.getLength());// 输出流把文件内容输出到文件中  
148.                             out.flush();  
149.                             if (receivePacket.getLength() != receive.length)  
150.                                 break;  
151.                         }  
152.                         out.close();  
153.                     } catch (IOException e) {  
154.                         e.printStackTrace();  
155.                     }  
156.                 }  
157.   
158.             } else  
159.                 // 选择的文件夹不存在  
160.                 JOptionPane.showMessageDialog(null, "请选择正确的存储路径", "存储路径错误", JOptionPane.WARNING_MESSAGE);  
161.   
162.         } else {// 文件名错误  
163.             JOptionPane.showMessageDialog(null, "请选择正确的文件名", "文件名错误", JOptionPane.WARNING_MESSAGE);  
164.         }  
165.     }  
166.   
167.     public static void main(String[] args) {  
168.         new DownloadClient();  
169.     }  
170. }  

说明：客户端下载时先点击显示文件，然后输入要下载的文件名，最后点击下载按钮、选择保存路径

3、运行时先开服务器，然后再开客户端。运行结果：

点击显示文件按钮、输入01.jpg后：

 

 

点击下载按钮后、选择保存路径

 

 

点击保存按钮后,文件下载到指定目录下