用Socket实现PC和手机的文件传输

最新推荐文章于 2022-10-16 23:03:58 发布
最新推荐文章于 2022-10-16 23:03:58 发布
阅读量2.7k 收藏 8
点赞数
分类专栏： 杂谈 文章标签： Socket 文件传输

PC服务器端代码:



[java]  view plain copy print ?
  1. /* 
  2.  * PC与Android客户端实现文件的传送 
  3.  * PC服务器端 
  4.  */  
  5. package com.android.test;  
  6. import java.io.BufferedInputStream;  
  7. import java.io.DataInputStream;  
  8. import java.io.DataOutputStream;  
  9. import java.io.File;  
  10. import java.io.FileInputStream;  
  11. import java.io.IOException;  
  12. import java.net.ServerSocket;  
  13. import java.net.Socket;  
  14. public class TransferFileServer {  
  15.     private static final int HOST_PORT = 8821;  
  16.     private void start() {  
  17.         Socket s = null;  
  18.         try {  
  19.             ServerSocket ss = new ServerSocket(HOST_PORT);  
  20.             while (true) {  
  21.                 String filePath = "/home/fan/Pictures/1.jpg";  
  22.                 File file = new File(filePath);  
  23.                 System.out.println("文件长度:" + (int) file.length());  
  24.                 s = ss.accept();  
  25.                 log("建立Socket连接");  
  26.                 DataInputStream dis = new DataInputStream(  
  27.                         new BufferedInputStream(s.getInputStream()));  
  28.                 dis.readByte();  
  29.                 DataInputStream fis = new DataInputStream(  
  30.                         new BufferedInputStream(new FileInputStream(filePath)));  
  31.                 DataOutputStream dos = new DataOutputStream(s.getOutputStream());  
  32.                 dos.writeUTF(file.getName());  
  33.                 dos.flush();  
  34.                 dos.writeLong((long) file.length());  
  35.                 dos.flush();  
  36.                 int bufferSize = 8192;  
  37.                 byte[] buf = new byte[bufferSize];  
  38.                 while (true) {  
  39.                     int read = 0;  
  40.                     if (fis != null) {  
  41.                         read = fis.read(buf);  
  42.                     }  
  43.                     if (read == -1) {  
  44.                         break;  
  45.                     }  
  46.                     dos.write(buf,0,read);  
  47.                 }  
  48.                 dos.flush();  
  49.                  // 注意关闭socket链接哦，不然客户端会等待server的数据过来，  
  50.                 // 直到socket超时，导致数据不完整。  
  51.                 fis.close();  
  52.                 s.close();  
  53.                 log("文件传输完成");  
  54.             }  
  55.         } catch (IOException e) {  
  56.             // TODO Auto-generated catch block  
  57.             e.printStackTrace();  
  58.         }  
  59.     }  
  60.     void log(String msg) {  
  61.         System.out.println(msg);  
  62.     }  
  63.     public static void main(String args[]) {  
  64.         new TransferFileServer().start();  
  65.     }  
  66. }  
[java]  view plain  copy
 print ?
  1. /* 
  2.  * PC与Android客户端实现文件的传送 
  3.  * PC服务器端 
  4.  */  
  5. package com.android.test;  
  6. import java.io.BufferedInputStream;  
  7. import java.io.DataInputStream;  
  8. import java.io.DataOutputStream;  
  9. import java.io.File;  
  10. import java.io.FileInputStream;  
  11. import java.io.IOException;  
  12. import java.net.ServerSocket;  
  13. import java.net.Socket;  
  14. public class TransferFileServer {  
  15.     private static final int HOST_PORT = 8821;  
  16.     private void start() {  
  17.         Socket s = null;  
  18.         try {  
  19.             ServerSocket ss = new ServerSocket(HOST_PORT);  
  20.             while (true) {  
  21.                 String filePath = "/home/fan/Pictures/1.jpg";  
  22.                 File file = new File(filePath);  
  23.                 System.out.println("文件长度:" + (int) file.length());  
  24.                 s = ss.accept();  
  25.                 log("建立Socket连接");  
  26.                 DataInputStream dis = new DataInputStream(  
  27.                         new BufferedInputStream(s.getInputStream()));  
  28.                 dis.readByte();  
  29.                 DataInputStream fis = new DataInputStream(  
  30.                         new BufferedInputStream(new FileInputStream(filePath)));  
  31.                 DataOutputStream dos = new DataOutputStream(s.getOutputStream());  
  32.                 dos.writeUTF(file.getName());  
  33.                 dos.flush();  
  34.                 dos.writeLong((long) file.length());  
  35.                 dos.flush();  
  36.                 int bufferSize = 8192;  
  37.                 byte[] buf = new byte[bufferSize];  
  38.                 while (true) {  
  39.                     int read = 0;  
  40.                     if (fis != null) {  
  41.                         read = fis.read(buf);  
  42.                     }  
  43.                     if (read == -1) {  
  44.                         break;  
  45.                     }  
  46.                     dos.write(buf,0,read);  
  47.                 }  
  48.                 dos.flush();  
  49.                  // 注意关闭socket链接哦，不然客户端会等待server的数据过来，  
  50.                 // 直到socket超时，导致数据不完整。  
  51.                 fis.close();  
  52.                 s.close();  
  53.                 log("文件传输完成");  
  54.             }  
  55.         } catch (IOException e) {  
  56.             // TODO Auto-generated catch block  
  57.             e.printStackTrace();  
  58.         }  
  59.     }  
  60.     void log(String msg) {  
  61.         System.out.println(msg);  
  62.     }  
  63.     public static void main(String args[]) {  
  64.         new TransferFileServer().start();  
  65.     }  
  66. }  
 

ClientSocket:辅助类

[java]  view plain copy print ?
  1. /* 
  2.  * PC与Android文件传输 
  3.  * Android客户端 
  4.  */  
  5. package com.android.test;  
  6. import java.io.BufferedInputStream;  
  7. import java.io.DataInputStream;  
  8. import java.io.DataOutputStream;  
  9. import java.io.IOException;  
  10. import java.net.Socket;  
  11. import java.net.UnknownHostException;  
  12. public class ClientSocket {  
  13.     private String ip;  
  14.     private int port;  
  15.     private Socket socket = null;  
  16.     DataOutputStream out = null;  
  17.     DataInputStream getMessageStream = null;  
  18.     public ClientSocket(String ip, int port) {  
  19.         this.ip = ip;  
  20.         this.port = port;  
  21.     }  
  22.     public void createConnection() {  
  23.         try {  
  24.             socket = new Socket(ip, port);  
  25.         } catch (UnknownHostException e) {  
  26.             // TODO Auto-generated catch block  
  27.             e.printStackTrace();  
  28.             if (socket != null) {  
  29.                 try {  
  30.                     socket.close();  
  31.                 } catch (IOException e1) {  
  32.                     // TODO Auto-generated catch block  
  33.                     e1.printStackTrace();  
  34.                 }  
  35.             }  
  36.         } catch (IOException e) {  
  37.             // TODO Auto-generated catch block  
  38.             e.printStackTrace();  
  39.             if (socket != null) {  
  40.                 try {  
  41.                     socket.close();  
  42.                 } catch (IOException e1) {  
  43.                     // TODO Auto-generated catch block  
  44.                     e1.printStackTrace();  
  45.                 }  
  46.             }  
  47.         } finally {  
  48.         }  
  49.     }  
  50.     public void sendMessage(String sendMessage) {  
  51.         try {  
  52.             out = new DataOutputStream(socket.getOutputStream());  
  53.             if (sendMessage.equals("Windows")) {  
  54.                 out.writeByte(0x1);  
  55.                 out.flush();  
  56.                 return;  
  57.             }  
  58.             if (sendMessage.equals("Unix")) {  
  59.                 out.writeByte(0x2);  
  60.                 out.flush();  
  61.                 return;  
  62.             }  
  63.             if (sendMessage.equals("Linux")) {  
  64.                 out.writeByte(0x3);  
  65.                 out.flush();  
  66.             } else {  
  67.                 out.writeUTF(sendMessage);  
  68.                 out.flush();  
  69.             }  
  70.         } catch (IOException e) {  
  71.             // TODO Auto-generated catch block  
  72.             e.printStackTrace();  
  73.             if (out != null) {  
  74.                 try {  
  75.                     out.close();  
  76.                 } catch (IOException e1) {  
  77.                     // TODO Auto-generated catch block  
  78.                     e1.printStackTrace();  
  79.                 }  
  80.             }  
  81.         }  
  82.     }  
  83.     public DataInputStream getMessageStream() {  
  84.         try {  
  85.             getMessageStream = new DataInputStream(new BufferedInputStream(  
  86.                     socket.getInputStream()));  
  87.             // return getMessageStream;  
  88.         } catch (IOException e) {  
  89.             // TODO Auto-generated catch block  
  90.             e.printStackTrace();  
  91.             if (getMessageStream != null) {  
  92.                 try {  
  93.                     getMessageStream.close();  
  94.                 } catch (IOException e1) {  
  95.                     // TODO Auto-generated catch block  
  96.                     e1.printStackTrace();  
  97.                 }  
  98.             }  
  99.         }  
  100.         return getMessageStream;  
  101.     }  
  102.     public void shutDownConnection() {  
  103.         try {  
  104.             if (out != null) {  
  105.                 out.close();  
  106.             }  
  107.             if (getMessageStream != null) {  
  108.                 getMessageStream.close();  
  109.             }  
  110.             if (socket != null) {  
  111.                 socket.close();  
  112.             }  
  113.         } catch (IOException e) {  
  114.             // TODO Auto-generated catch block  
  115.             e.printStackTrace();  
  116.         }  
  117.     }  
  118. }  
[java]  view plain  copy
 print ?
  1. /* 
  2.  * PC与Android文件传输 
  3.  * Android客户端 
  4.  */  
  5. package com.android.test;  
  6. import java.io.BufferedInputStream;  
  7. import java.io.DataInputStream;  
  8. import java.io.DataOutputStream;  
  9. import java.io.IOException;  
  10. import java.net.Socket;  
  11. import java.net.UnknownHostException;  
  12. public class ClientSocket {  
  13.     private String ip;  
  14.     private int port;  
  15.     private Socket socket = null;  
  16.     DataOutputStream out = null;  
  17.     DataInputStream getMessageStream = null;  
  18.     public ClientSocket(String ip, int port) {  
  19.         this.ip = ip;  
  20.         this.port = port;  
  21.     }  
  22.     public void createConnection() {  
  23.         try {  
  24.             socket = new Socket(ip, port);  
  25.         } catch (UnknownHostException e) {  
  26.             // TODO Auto-generated catch block  
  27.             e.printStackTrace();  
  28.             if (socket != null) {  
  29.                 try {  
  30.                     socket.close();  
  31.                 } catch (IOException e1) {  
  32.                     // TODO Auto-generated catch block  
  33.                     e1.printStackTrace();  
  34.                 }  
  35.             }  
  36.         } catch (IOException e) {  
  37.             // TODO Auto-generated catch block  
  38.             e.printStackTrace();  
  39.             if (socket != null) {  
  40.                 try {  
  41.                     socket.close();  
  42.                 } catch (IOException e1) {  
  43.                     // TODO Auto-generated catch block  
  44.                     e1.printStackTrace();  
  45.                 }  
  46.             }  
  47.         } finally {  
  48.         }  
  49.     }  
  50.     public void sendMessage(String sendMessage) {  
  51.         try {  
  52.             out = new DataOutputStream(socket.getOutputStream());  
  53.             if (sendMessage.equals("Windows")) {  
  54.                 out.writeByte(0x1);  
  55.                 out.flush();  
  56.                 return;  
  57.             }  
  58.             if (sendMessage.equals("Unix")) {  
  59.                 out.writeByte(0x2);  
  60.                 out.flush();  
  61.                 return;  
  62.             }  
  63.             if (sendMessage.equals("Linux")) {  
  64.                 out.writeByte(0x3);  
  65.                 out.flush();  
  66.             } else {  
  67.                 out.writeUTF(sendMessage);  
  68.                 out.flush();  
  69.             }  
  70.         } catch (IOException e) {  
  71.             // TODO Auto-generated catch block  
  72.             e.printStackTrace();  
  73.             if (out != null) {  
  74.                 try {  
  75.                     out.close();  
  76.                 } catch (IOException e1) {  
  77.                     // TODO Auto-generated catch block  
  78.                     e1.printStackTrace();  
  79.                 }  
  80.             }  
  81.         }  
  82.     }  
  83.     public DataInputStream getMessageStream() {  
  84.         try {  
  85.             getMessageStream = new DataInputStream(new BufferedInputStream(  
  86.                     socket.getInputStream()));  
  87.             // return getMessageStream;  
  88.         } catch (IOException e) {  
  89.             // TODO Auto-generated catch block  
  90.             e.printStackTrace();  
  91.             if (getMessageStream != null) {  
  92.                 try {  
  93.                     getMessageStream.close();  
  94.                 } catch (IOException e1) {  
  95.                     // TODO Auto-generated catch block  
  96.                     e1.printStackTrace();  
  97.                 }  
  98.             }  
  99.         }  
  100.         return getMessageStream;  
  101.     }  
  102.     public void shutDownConnection() {  
  103.         try {  
  104.             if (out != null) {  
  105.                 out.close();  
  106.             }  
  107.             if (getMessageStream != null) {  
  108.                 getMessageStream.close();  
  109.             }  
  110.             if (socket != null) {  
  111.                 socket.close();  
  112.             }  
  113.         } catch (IOException e) {  
  114.             // TODO Auto-generated catch block  
  115.             e.printStackTrace();  
  116.         }  
  117.     }  
  118. }  
 

Android客户端：Acitiviy实现：

[java]  view plain copy print ?
  1. package com.android.test;  
  2. import java.io.BufferedOutputStream;  
  3. import java.io.DataInputStream;  
  4. import java.io.DataOutputStream;  
  5. import java.io.FileOutputStream;  
  6. import java.io.IOException;  
  7. import android.app.Activity;  
  8. import android.os.Bundle;  
  9. import android.util.Log;  
  10. import android.view.View;  
  11. import android.view.View.OnClickListener;  
  12. import android.widget.Button;  
  13. public class Main extends Activity implements OnClickListener{  
  14.     private ClientSocket cs = null;  
  15.     private static final String FILE_PATH = "/mnt/sdcard/";  
  16.     private String ip = "192.168.1.103";  
  17.     private int port = 8821;  
  18.     private String sendMessage = "Linux";  
  19.     private Button mButton;  
  20.     @Override  
  21.     public void onCreate(Bundle savedInstanceState) {  
  22.         super.onCreate(savedInstanceState);  
  23.         setContentView(R.layout.main);  
  24.         mButton = (Button)findViewById(R.id.start);  
  25.         mButton.setOnClickListener(this);  
  26.     }  
  27.     private void start() {  
  28.         if (createConnection()) {  
  29.             sendMessage();  
  30.             getMessage();  
  31.         }  
  32.     }  
  33.     private void getMessage() {  
  34.         if (cs == null)  
  35.             return;  
  36.         DataInputStream inputStream = null;  
  37.         inputStream = cs.getMessageStream();  
  38.         try {  
  39.             String savePath = FILE_PATH;  
  40.             int bufferSize = 8192;  
  41.             byte[] buf = new byte[bufferSize];  
  42.             int passedlen = 0;  
  43.             long len = 0;  
  44.               
  45.             savePath += inputStream.readUTF();  
  46.             Log.d("AndroidClient","@@@savePath"+savePath);  
  47.             DataOutputStream fileOut = new DataOutputStream(  
  48.                     new BufferedOutputStream(new BufferedOutputStream(  
  49.                             new FileOutputStream(savePath))));  
  50.             len = inputStream.readLong();  
  51.             Log.d("AndoridClient","文件的长度为:"+len);  
  52.             Log.d("AndroidClient","开始接收文件");  
  53.             while(true) {  
  54.                 int read = 0;  
  55.                 if (inputStream != null) {  
  56.                     read = inputStream.read(buf);  
  57.                 }  
  58.                 passedlen += read;  
  59.                 if (read == -1) {  
  60.                     break;  
  61.                 }  
  62.                 Log.d("AndroidClient","文件接收了"+(passedlen*100/len)+"%/n");  
  63.                 fileOut.write(buf,0,read);  
  64.             }  
  65.             Log.d("AndroidClient","@@@文件接收完成"+savePath);  
  66.             fileOut.close();  
  67.         } catch (IOException e) {  
  68.             // TODO Auto-generated catch block  
  69.             e.printStackTrace();  
  70.         }  
  71.     }  
  72.     private void sendMessage() {  
  73.         if (cs == null)  
  74.             return;  
  75.         cs.sendMessage(sendMessage);  
  76.     }  
  77.     private boolean createConnection() {  
  78.         cs = new ClientSocket(ip, port);  
  79.         cs.createConnection();  
  80.         Log.d("Main", "连接服务器成功:");  
  81.         return true;  
  82.     }  
  83.     public void onClick(View v) {  
  84.         start();  
  85.     }  
  86. }  
[java]  view plain  copy
 print ?
  1. package com.android.test;  
  2. import java.io.BufferedOutputStream;  
  3. import java.io.DataInputStream;  
  4. import java.io.DataOutputStream;  
  5. import java.io.FileOutputStream;  
  6. import java.io.IOException;  
  7. import android.app.Activity;  
  8. import android.os.Bundle;  
  9. import android.util.Log;  
  10. import android.view.View;  
  11. import android.view.View.OnClickListener;  
  12. import android.widget.Button;  
  13. public class Main extends Activity implements OnClickListener{  
  14.     private ClientSocket cs = null;  
  15.     private static final String FILE_PATH = "/mnt/sdcard/";  
  16.     private String ip = "192.168.1.103";  
  17.     private int port = 8821;  
  18.     private String sendMessage = "Linux";  
  19.     private Button mButton;  
  20.     @Override  
  21.     public void onCreate(Bundle savedInstanceState) {  
  22.         super.onCreate(savedInstanceState);  
  23.         setContentView(R.layout.main);  
  24.         mButton = (Button)findViewById(R.id.start);  
  25.         mButton.setOnClickListener(this);  
  26.     }  
  27.     private void start() {  
  28.         if (createConnection()) {  
  29.             sendMessage();  
  30.             getMessage();  
  31.         }  
  32.     }  
  33.     private void getMessage() {  
  34.         if (cs == null)  
  35.             return;  
  36.         DataInputStream inputStream = null;  
  37.         inputStream = cs.getMessageStream();  
  38.         try {  
  39.             String savePath = FILE_PATH;  
  40.             int bufferSize = 8192;  
  41.             byte[] buf = new byte[bufferSize];  
  42.             int passedlen = 0;  
  43.             long len = 0;  
  44.               
  45.             savePath += inputStream.readUTF();  
  46.             Log.d("AndroidClient","@@@savePath"+savePath);  
  47.             DataOutputStream fileOut = new DataOutputStream(  
  48.                     new BufferedOutputStream(new BufferedOutputStream(  
  49.                             new FileOutputStream(savePath))));  
  50.             len = inputStream.readLong();  
  51.             Log.d("AndoridClient","文件的长度为:"+len);  
  52.             Log.d("AndroidClient","开始接收文件");  
  53.             while(true) {  
  54.                 int read = 0;  
  55.                 if (inputStream != null) {  
  56.                     read = inputStream.read(buf);  
  57.                 }  
  58.                 passedlen += read;  
  59.                 if (read == -1) {  
  60.                     break;  
  61.                 }  
  62.                 Log.d("AndroidClient","文件接收了"+(passedlen*100/len)+"%/n");  
  63.                 fileOut.write(buf,0,read);  
  64.             }  
  65.             Log.d("AndroidClient","@@@文件接收完成"+savePath);  
  66.             fileOut.close();  
  67.         } catch (IOException e) {  
  68.             // TODO Auto-generated catch block  
  69.             e.printStackTrace();  
  70.         }  
  71.     }  
  72.     private void sendMessage() {  
  73.         if (cs == null)  
  74.             return;  
  75.         cs.sendMessage(sendMessage);  
  76.     }  
  77.     private boolean createConnection() {  
  78.         cs = new ClientSocket(ip, port);  
  79.         cs.createConnection();  
  80.         Log.d("Main", "连接服务器成功:");  
  81.         return true;  
  82.     }  
  83.     public void onClick(View v) {  
  84.         start();  
  85.     }  
  86. } 

[java]  view plain copy print ?
  1. /* 
  2.  * PC与Android客户端实现文件的传送 
  3.  * PC服务器端 
  4.  */  
  5. package com.android.test;  
  6. import java.io.BufferedInputStream;  
  7. import java.io.DataInputStream;  
  8. import java.io.DataOutputStream;  
  9. import java.io.File;  
  10. import java.io.FileInputStream;  
  11. import java.io.IOException;  
  12. import java.net.ServerSocket;  
  13. import java.net.Socket;  
  14. public class TransferFileServer {  
  15.     private static final int HOST_PORT = 8821;  
  16.     private void start() {  
  17.         Socket s = null;  
  18.         try {  
  19.             ServerSocket ss = new ServerSocket(HOST_PORT);  
  20.             while (true) {  
  21.                 String filePath = "/home/fan/Pictures/1.jpg";  
  22.                 File file = new File(filePath);  
  23.                 System.out.println("文件长度:" + (int) file.length());  
  24.                 s = ss.accept();  
  25.                 log("建立Socket连接");  
  26.                 DataInputStream dis = new DataInputStream(  
  27.                         new BufferedInputStream(s.getInputStream()));  
  28.                 dis.readByte();  
  29.                 DataInputStream fis = new DataInputStream(  
  30.                         new BufferedInputStream(new FileInputStream(filePath)));  
  31.                 DataOutputStream dos = new DataOutputStream(s.getOutputStream());  
  32.                 dos.writeUTF(file.getName());  
  33.                 dos.flush();  
  34.                 dos.writeLong((long) file.length());  
  35.                 dos.flush();  
  36.                 int bufferSize = 8192;  
  37.                 byte[] buf = new byte[bufferSize];  
  38.                 while (true) {  
  39.                     int read = 0;  
  40.                     if (fis != null) {  
  41.                         read = fis.read(buf);  
  42.                     }  
  43.                     if (read == -1) {  
  44.                         break;  
  45.                     }  
  46.                     dos.write(buf,0,read);  
  47.                 }  
  48.                 dos.flush();  
  49.                  // 注意关闭socket链接哦，不然客户端会等待server的数据过来，  
  50.                 // 直到socket超时，导致数据不完整。  
  51.                 fis.close();  
  52.                 s.close();  
  53.                 log("文件传输完成");  
  54.             }  
  55.         } catch (IOException e) {  
  56.             // TODO Auto-generated catch block  
  57.             e.printStackTrace();  
  58.         }  
  59.     }  
  60.     void log(String msg) {  
  61.         System.out.println(msg);  
  62.     }  
  63.     public static void main(String args[]) {  
  64.         new TransferFileServer().start();  
  65.     }  
  66. }  
[java]  view plain  copy
 print ?
  1. /* 
  2.  * PC与Android客户端实现文件的传送 
  3.  * PC服务器端 
  4.  */  
  5. package com.android.test;  
  6. import java.io.BufferedInputStream;  
  7. import java.io.DataInputStream;  
  8. import java.io.DataOutputStream;  
  9. import java.io.File;  
  10. import java.io.FileInputStream;  
  11. import java.io.IOException;  
  12. import java.net.ServerSocket;  
  13. import java.net.Socket;  
  14. public class TransferFileServer {  
  15.     private static final int HOST_PORT = 8821;  
  16.     private void start() {  
  17.         Socket s = null;  
  18.         try {  
  19.             ServerSocket ss = new ServerSocket(HOST_PORT);  
  20.             while (true) {  
  21.                 String filePath = "/home/fan/Pictures/1.jpg";  
  22.                 File file = new File(filePath);  
  23.                 System.out.println("文件长度:" + (int) file.length());  
  24.                 s = ss.accept();  
  25.                 log("建立Socket连接");  
  26.                 DataInputStream dis = new DataInputStream(  
  27.                         new BufferedInputStream(s.getInputStream()));  
  28.                 dis.readByte();  
  29.                 DataInputStream fis = new DataInputStream(  
  30.                         new BufferedInputStream(new FileInputStream(filePath)));  
  31.                 DataOutputStream dos = new DataOutputStream(s.getOutputStream());  
  32.                 dos.writeUTF(file.getName());  
  33.                 dos.flush();  
  34.                 dos.writeLong((long) file.length());  
  35.                 dos.flush();  
  36.                 int bufferSize = 8192;  
  37.                 byte[] buf = new byte[bufferSize];  
  38.                 while (true) {  
  39.                     int read = 0;  
  40.                     if (fis != null) {  
  41.                         read = fis.read(buf);  
  42.                     }  
  43.                     if (read == -1) {  
  44.                         break;  
  45.                     }  
  46.                     dos.write(buf,0,read);  
  47.                 }  
  48.                 dos.flush();  
  49.                  // 注意关闭socket链接哦，不然客户端会等待server的数据过来，  
  50.                 // 直到socket超时，导致数据不完整。  
  51.                 fis.close();  
  52.                 s.close();  
  53.                 log("文件传输完成");  
  54.             }  
  55.         } catch (IOException e) {  
  56.             // TODO Auto-generated catch block  
  57.             e.printStackTrace();  
  58.         }  
  59.     }  
  60.     void log(String msg) {  
  61.         System.out.println(msg);  
  62.     }  
  63.     public static void main(String args[]) {  
  64.         new TransferFileServer().start();  
  65.     }  
  66. }  
 

ClientSocket:辅助类

[java]  view plain copy print ?
  1. /* 
  2.  * PC与Android文件传输 
  3.  * Android客户端 
  4.  */  
  5. package com.android.test;  
  6. import java.io.BufferedInputStream;  
  7. import java.io.DataInputStream;  
  8. import java.io.DataOutputStream;  
  9. import java.io.IOException;  
  10. import java.net.Socket;  
  11. import java.net.UnknownHostException;  
  12. public class ClientSocket {  
  13.     private String ip;  
  14.     private int port;  
  15.     private Socket socket = null;  
  16.     DataOutputStream out = null;  
  17.     DataInputStream getMessageStream = null;  
  18.     public ClientSocket(String ip, int port) {  
  19.         this.ip = ip;  
  20.         this.port = port;  
  21.     }  
  22.     public void createConnection() {  
  23.         try {  
  24.             socket = new Socket(ip, port);  
  25.         } catch (UnknownHostException e) {  
  26.             // TODO Auto-generated catch block  
  27.             e.printStackTrace();  
  28.             if (socket != null) {  
  29.                 try {  
  30.                     socket.close();  
  31.                 } catch (IOException e1) {  
  32.                     // TODO Auto-generated catch block  
  33.                     e1.printStackTrace();  
  34.                 }  
  35.             }  
  36.         } catch (IOException e) {  
  37.             // TODO Auto-generated catch block  
  38.             e.printStackTrace();  
  39.             if (socket != null) {  
  40.                 try {  
  41.                     socket.close();  
  42.                 } catch (IOException e1) {  
  43.                     // TODO Auto-generated catch block  
  44.                     e1.printStackTrace();  
  45.                 }  
  46.             }  
  47.         } finally {  
  48.         }  
  49.     }  
  50.     public void sendMessage(String sendMessage) {  
  51.         try {  
  52.             out = new DataOutputStream(socket.getOutputStream());  
  53.             if (sendMessage.equals("Windows")) {  
  54.                 out.writeByte(0x1);  
  55.                 out.flush();  
  56.                 return;  
  57.             }  
  58.             if (sendMessage.equals("Unix")) {  
  59.                 out.writeByte(0x2);  
  60.                 out.flush();  
  61.                 return;  
  62.             }  
  63.             if (sendMessage.equals("Linux")) {  
  64.                 out.writeByte(0x3);  
  65.                 out.flush();  
  66.             } else {  
  67.                 out.writeUTF(sendMessage);  
  68.                 out.flush();  
  69.             }  
  70.         } catch (IOException e) {  
  71.             // TODO Auto-generated catch block  
  72.             e.printStackTrace();  
  73.             if (out != null) {  
  74.                 try {  
  75.                     out.close();  
  76.                 } catch (IOException e1) {  
  77.                     // TODO Auto-generated catch block  
  78.                     e1.printStackTrace();  
  79.                 }  
  80.             }  
  81.         }  
  82.     }  
  83.     public DataInputStream getMessageStream() {  
  84.         try {  
  85.             getMessageStream = new DataInputStream(new BufferedInputStream(  
  86.                     socket.getInputStream()));  
  87.             // return getMessageStream;  
  88.         } catch (IOException e) {  
  89.             // TODO Auto-generated catch block  
  90.             e.printStackTrace();  
  91.             if (getMessageStream != null) {  
  92.                 try {  
  93.                     getMessageStream.close();  
  94.                 } catch (IOException e1) {  
  95.                     // TODO Auto-generated catch block  
  96.                     e1.printStackTrace();  
  97.                 }  
  98.             }  
  99.         }  
  100.         return getMessageStream;  
  101.     }  
  102.     public void shutDownConnection() {  
  103.         try {  
  104.             if (out != null) {  
  105.                 out.close();  
  106.             }  
  107.             if (getMessageStream != null) {  
  108.                 getMessageStream.close();  
  109.             }  
  110.             if (socket != null) {  
  111.                 socket.close();  
  112.             }  
  113.         } catch (IOException e) {  
  114.             // TODO Auto-generated catch block  
  115.             e.printStackTrace();  
  116.         }  
  117.     }  
  118. }  
[java]  view plain  copy
 print ?
  1. /* 
  2.  * PC与Android文件传输 
  3.  * Android客户端 
  4.  */  
  5. package com.android.test;  
  6. import java.io.BufferedInputStream;  
  7. import java.io.DataInputStream;  
  8. import java.io.DataOutputStream;  
  9. import java.io.IOException;  
  10. import java.net.Socket;  
  11. import java.net.UnknownHostException;  
  12. public class ClientSocket {  
  13.     private String ip;  
  14.     private int port;  
  15.     private Socket socket = null;  
  16.     DataOutputStream out = null;  
  17.     DataInputStream getMessageStream = null;  
  18.     public ClientSocket(String ip, int port) {  
  19.         this.ip = ip;  
  20.         this.port = port;  
  21.     }  
  22.     public void createConnection() {  
  23.         try {  
  24.             socket = new Socket(ip, port);  
  25.         } catch (UnknownHostException e) {  
  26.             // TODO Auto-generated catch block  
  27.             e.printStackTrace();  
  28.             if (socket != null) {  
  29.                 try {  
  30.                     socket.close();  
  31.                 } catch (IOException e1) {  
  32.                     // TODO Auto-generated catch block  
  33.                     e1.printStackTrace();  
  34.                 }  
  35.             }  
  36.         } catch (IOException e) {  
  37.             // TODO Auto-generated catch block  
  38.             e.printStackTrace();  
  39.             if (socket != null) {  
  40.                 try {  
  41.                     socket.close();  
  42.                 } catch (IOException e1) {  
  43.                     // TODO Auto-generated catch block  
  44.                     e1.printStackTrace();  
  45.                 }  
  46.             }  
  47.         } finally {  
  48.         }  
  49.     }  
  50.     public void sendMessage(String sendMessage) {  
  51.         try {  
  52.             out = new DataOutputStream(socket.getOutputStream());  
  53.             if (sendMessage.equals("Windows")) {  
  54.                 out.writeByte(0x1);  
  55.                 out.flush();  
  56.                 return;  
  57.             }  
  58.             if (sendMessage.equals("Unix")) {  
  59.                 out.writeByte(0x2);  
  60.                 out.flush();  
  61.                 return;  
  62.             }  
  63.             if (sendMessage.equals("Linux")) {  
  64.                 out.writeByte(0x3);  
  65.                 out.flush();  
  66.             } else {  
  67.                 out.writeUTF(sendMessage);  
  68.                 out.flush();  
  69.             }  
  70.         } catch (IOException e) {  
  71.             // TODO Auto-generated catch block  
  72.             e.printStackTrace();  
  73.             if (out != null) {  
  74.                 try {  
  75.                     out.close();  
  76.                 } catch (IOException e1) {  
  77.                     // TODO Auto-generated catch block  
  78.                     e1.printStackTrace();  
  79.                 }  
  80.             }  
  81.         }  
  82.     }  
  83.     public DataInputStream getMessageStream() {  
  84.         try {  
  85.             getMessageStream = new DataInputStream(new BufferedInputStream(  
  86.                     socket.getInputStream()));  
  87.             // return getMessageStream;  
  88.         } catch (IOException e) {  
  89.             // TODO Auto-generated catch block  
  90.             e.printStackTrace();  
  91.             if (getMessageStream != null) {  
  92.                 try {  
  93.                     getMessageStream.close();  
  94.                 } catch (IOException e1) {  
  95.                     // TODO Auto-generated catch block  
  96.                     e1.printStackTrace();  
  97.                 }  
  98.             }  
  99.         }  
  100.         return getMessageStream;  
  101.     }  
  102.     public void shutDownConnection() {  
  103.         try {  
  104.             if (out != null) {  
  105.                 out.close();  
  106.             }  
  107.             if (getMessageStream != null) {  
  108.                 getMessageStream.close();  
  109.             }  
  110.             if (socket != null) {  
  111.                 socket.close();  
  112.             }  
  113.         } catch (IOException e) {  
  114.             // TODO Auto-generated catch block  
  115.             e.printStackTrace();  
  116.         }  
  117.     }  
  118. }  
 

Android客户端：Acitivyt实现：

[java]  view plain copy print ?
  1. package com.android.test;  
  2. import java.io.BufferedOutputStream;  
  3. import java.io.DataInputStream;  
  4. import java.io.DataOutputStream;  
  5. import java.io.FileOutputStream;  
  6. import java.io.IOException;  
  7. import android.app.Activity;  
  8. import android.os.Bundle;  
  9. import android.util.Log;  
  10. import android.view.View;  
  11. import android.view.View.OnClickListener;  
  12. import android.widget.Button;  
  13. public class Main extends Activity implements OnClickListener{  
  14.     private ClientSocket cs = null;  
  15.     private static final String FILE_PATH = "/mnt/sdcard/";  
  16.     private String ip = "192.168.1.103";  
  17.     private int port = 8821;  
  18.     private String sendMessage = "Linux";  
  19.     private Button mButton;  
  20.     @Override  
  21.     public void onCreate(Bundle savedInstanceState) {  
  22.         super.onCreate(savedInstanceState);  
  23.         setContentView(R.layout.main);  
  24.         mButton = (Button)findViewById(R.id.start);  
  25.         mButton.setOnClickListener(this);  
  26.     }  
  27.     private void start() {  
  28.         if (createConnection()) {  
  29.             sendMessage();  
  30.             getMessage();  
  31.         }  
  32.     }  
  33.     private void getMessage() {  
  34.         if (cs == null)  
  35.             return;  
  36.         DataInputStream inputStream = null;  
  37.         inputStream = cs.getMessageStream();  
  38.         try {  
  39.             String savePath = FILE_PATH;  
  40.             int bufferSize = 8192;  
  41.             byte[] buf = new byte[bufferSize];  
  42.             int passedlen = 0;  
  43.             long len = 0;  
  44.               
  45.             savePath += inputStream.readUTF();  
  46.             Log.d("AndroidClient","@@@savePath"+savePath);  
  47.             DataOutputStream fileOut = new DataOutputStream(  
  48.                     new BufferedOutputStream(new BufferedOutputStream(  
  49.                             new FileOutputStream(savePath))));  
  50.             len = inputStream.readLong();  
  51.             Log.d("AndoridClient","文件的长度为:"+len);  
  52.             Log.d("AndroidClient","开始接收文件");  
  53.             while(true) {  
  54.                 int read = 0;  
  55.                 if (inputStream != null) {  
  56.                     read = inputStream.read(buf);  
  57.                 }  
  58.                 passedlen += read;  
  59.                 if (read == -1) {  
  60.                     break;  
  61.                 }  
  62.                 Log.d("AndroidClient","文件接收了"+(passedlen*100/len)+"%/n");  
  63.                 fileOut.write(buf,0,read);  
  64.             }  
  65.             Log.d("AndroidClient","@@@文件接收完成"+savePath);  
  66.             fileOut.close();  
  67.         } catch (IOException e) {  
  68.             // TODO Auto-generated catch block  
  69.             e.printStackTrace();  
  70.         }  
  71.     }  
  72.     private void sendMessage() {  
  73.         if (cs == null)  
  74.             return;  
  75.         cs.sendMessage(sendMessage);  
  76.     }  
  77.     private boolean createConnection() {  
  78.         cs = new ClientSocket(ip, port);  
  79.         cs.createConnection();  
  80.         Log.d("Main", "连接服务器成功:");  
  81.         return true;  
  82.     }  
  83.     public void onClick(View v) {  
  84.         start();  
  85.     }  
  86. }  
[java]  view plain  copy
 print ?
  1. package com.android.test;  
  2. import java.io.BufferedOutputStream;  
  3. import java.io.DataInputStream;  
  4. import java.io.DataOutputStream;  
  5. import java.io.FileOutputStream;  
  6. import java.io.IOException;  
  7. import android.app.Activity;  
  8. import android.os.Bundle;  
  9. import android.util.Log;  
  10. import android.view.View;  
  11. import android.view.View.OnClickListener;  
  12. import android.widget.Button;  
  13. public class Main extends Activity implements OnClickListener{  
  14.     private ClientSocket cs = null;  
  15.     private static final String FILE_PATH = "/mnt/sdcard/";  
  16.     private String ip = "192.168.1.103";  
  17.     private int port = 8821;  
  18.     private String sendMessage = "Linux";  
  19.     private Button mButton;  
  20.     @Override  
  21.     public void onCreate(Bundle savedInstanceState) {  
  22.         super.onCreate(savedInstanceState);  
  23.         setContentView(R.layout.main);  
  24.         mButton = (Button)findViewById(R.id.start);  
  25.         mButton.setOnClickListener(this);  
  26.     }  
  27.     private void start() {  
  28.         if (createConnection()) {  
  29.             sendMessage();  
  30.             getMessage();  
  31.         }  
  32.     }  
  33.     private void getMessage() {  
  34.         if (cs == null)  
  35.             return;  
  36.         DataInputStream inputStream = null;  
  37.         inputStream = cs.getMessageStream();  
  38.         try {  
  39.             String savePath = FILE_PATH;  
  40.             int bufferSize = 8192;  
  41.             byte[] buf = new byte[bufferSize];  
  42.             int passedlen = 0;  
  43.             long len = 0;  
  44.               
  45.             savePath += inputStream.readUTF();  
  46.             Log.d("AndroidClient","@@@savePath"+savePath);  
  47.             DataOutputStream fileOut = new DataOutputStream(  
  48.                     new BufferedOutputStream(new BufferedOutputStream(  
  49.                             new FileOutputStream(savePath))));  
  50.             len = inputStream.readLong();  
  51.             Log.d("AndoridClient","文件的长度为:"+len);  
  52.             Log.d("AndroidClient","开始接收文件");  
  53.             while(true) {  
  54.                 int read = 0;  
  55.                 if (inputStream != null) {  
  56.                     read = inputStream.read(buf);  
  57.                 }  
  58.                 passedlen += read;  
  59.                 if (read == -1) {  
  60.                     break;  
  61.                 }  
  62.                 Log.d("AndroidClient","文件接收了"+(passedlen*100/len)+"%/n");  
  63.                 fileOut.write(buf,0,read);  
  64.             }  
  65.             Log.d("AndroidClient","@@@文件接收完成"+savePath);  
  66.             fileOut.close();  
  67.         } catch (IOException e) {  
  68.             // TODO Auto-generated catch block  
  69.             e.printStackTrace();  
  70.         }  
  71.     }  
  72.     private void sendMessage() {  
  73.         if (cs == null)  
  74.             return;  
  75.         cs.sendMessage(sendMessage);  
  76.     }  
  77.     private boolean createConnection() {  
  78.         cs = new ClientSocket(ip, port);  
  79.         cs.createConnection();  
  80.         Log.d("Main", "连接服务器成功:");  
  81.         return true;  
  82.     }  
  83.     public void onClick(View v) {  
  84.         start();  
  85.     }  
  86. } 
Android手机与PC机的Socket通信：实现信息传输与通信
TlScratch的博客
09-16 405
本文将介绍如何通过Socket实现Android手机客户端与PC机之间的通信，并提供相应的源代码示例。此外，还需要确定一个可用的端口号，用于建立连接和数据传输。该程序通过监听指定的IP地址和端口号，接受来自Android手机客户端的连接，并打印接收到的消息。在Android项目中，创建一个按钮或其他触发事件，调用SocketClient类的相关方法来进行连接和消息发送。在PC机上，需要编写一个Socket服务端程序用于接收Android手机客户端发送的消息。方法用于建立与服务器的Socket连接，
非阻塞socket实现android手机与PC的文件传输
10-17
android手机端发送一个“filename”字符串到PC，PC验证字符后返回要传输文件的文件名，然后手机端再把接收到的文件名发送给PC端，进行校验，如果PC端校验成功，那么PC端就开始传输这个文件给手机端，手机端就接收这个文件。
Android手机间使用socket进行文件互传
08-01
Android socket 文件互传 Android系统间使用socket进行文件互传
Android 手机间的文件传送（socket手机做服务端和客户端进行）
luoyy的专栏
06-04 2459
Android 手机间的文件传送（socket手机做服务端和客户端进行）前几天需要写个android局域网通讯，首先就是想到的就是socket通讯了，不说了开始吧。 在这里，由于我们需要的是在局域网的通讯，所以我们先得写一个socket客户端吧。所以我就以一个app作为服务端一个作为客户端。 服务端 我们在以手机建立服务端，但是为了让其他手机可以连入该服务端进行通讯，我们必须获得该手机的WiFi
PC_Socket_Demo
01-05
Android demo\C#_TCP&UDP;_Demo\Dephi_RS232&TCP;-UDP\VB_soket_TCPIP\VB_TCP-Server-Client等例子源代码。
pc与开发板通过socket通信
10-29
pc与开发板通过socket通信，pc端有图形界面
java传输手机文件到电脑_Android 用Socket实现PC和手机的文件传输
weixin_32541907的博客
02-26 641
package com.android.test;import java.io.BufferedOutputStream;import java.io.DataInputStream;import java.io.DataOutputStream;import java.io.FileOutputStream;import java.io.IOException;import android.ap...
有错误本例通过socket通信实现安卓客户端控制PC。从PC上下载文件从手机本地上传文件到PC控制PC鼠标控制PC关机相当于是电脑遥控器。运行时保证PC和手机客户端在同一个网段.rar
07-30
有错误本例通过socket通信实现安卓客户端控制PC。从PC上下载文件从手机本地上传文件到PC控制PC鼠标控制PC关机相当于是电脑遥控器。运行时保证PC和手机客户端在同一个网段.rar,太多无法一一验证是否可用，程序如果跑...
基于socket实现Android端和PC端服务器多文件传输
szu_Vegetable_Bird的博客
08-30 3589
基于socket实现Android端和PC端服务器多文件传输
基于Socket的Android手机视频实时传输
02-26
主要是在手机客户端（Android）通过实现Camera.PreviewCallback接口，在其onPreviewFrame重载函数里面获取摄像头当前图像数据，然后通过Socket将图像数据和相关的用户名、命令等数据传输到服务器程序中。服务器端...
Java Socket PC端传输文件简易服务器客户端
06-17
通过上述知识点的学习和实践，我们可以构建一个简单的文件传输系统，实现PC端的文件发送和接收功能。在实际应用中，这只是一个基础的框架，还需要根据具体需求进行扩展，例如增加用户身份验证、传输速度控制、错误重...
开发板与PC端虚拟机的Socket基础通信
qq_32089315的博客
10-16 1126
开发板与PC端虚拟机的Socket基础通信
电脑-Android手机之间TCP协议局域网文件传送
08-29
一个还好的Android手机无线（WIFI）连接无线路由实现局域网 连接电脑后，进行文件传送的Socket/TCP实例。 需要手机WIFI连接局域网，并设定IP地址，地址可在程序文件找到，或者自行对应修改，需要统一。
局域网，手机与电脑文件共享
qq_50942611的博客
10-05 3782
安卓手机与电脑互传文件工具，使用java语言，电脑端运行需要有java环境（最好是1.8），功能主要是使用Socket实现。：接收方必须先开启服务，然后发送方再发送数据，比如电脑端先接收手机的数据，需先点击电脑端。2.手机上接到某群里发的链接想在电脑上操作，但是又不想登微信或QQ。2.利用校园网，可做到只连接Wifi不使用账号登录，也可传输。1.不想登录微信或者QQ，只是想发个文件到电脑或者手机。3.需要传输较大文件的时候，又不想使用数据线。5.有文字共享功能，可互相发送文字信息。，然后电脑发送数据即可。
android socket通信_安卓和PC端TCP通信
weixin_39673742的博客
11-02 750
最近去了一趟上海，外滩的景色还是很nice的，非常喜欢这种具有历史感的建筑。很久没写文章，小姐姐最近打代码比较少，搞项管去。。。。。。程序媛才是小姐姐的最爱，记录文档写起来，哈哈哈。在一些工具类开发中，经常涉及不同设备之间的通信，今天我就针对安卓手机和PC端的通信，做一些文档说明。在安卓手机和PC端的TCP通信中，PC做为接收端（服务器Server端），以Android设备做为发送端（客户Clie...
socket文件传输手机客户端代码，文件选择上传到电脑。
08-22
socket传输文件，手机客户端，选择文件后，即可传输到电脑，用的是局域网，或者固定IP的公网。
android-pc socket传输
06-21
android-pc socket传输，手动连网，选择文件即可传输，不能重复文件名，亲试好用
用Python实现电脑与手机之间的文件快速传输
热门推荐
qq_45703548的博客
12-09 1万+
几行Python代码实现Linux和手机间文件互传 亲测有效
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值