Android如何实现无网络传输文件

最近的项目需要实现一个 Android 手机之间无网络传输文件的功能，就发现了 Wifi P2P（Wifi点对点）这么一个功能，最后也实现了通过 Wifi 隔空传输文件的功能，这里我也来整理下代码，分享给大家。

Wifi P2P 是在 Android 4.0 以及更高版本系统中加入的功能，通过 Wifi P2P 可以在不连接网络的情况下，直接与配对的设备进行数据交换。相对于蓝牙，Wifi P2P 的搜索速度和传输速度更快，传输距离更远

实现的效果如下所示：

一般而言，开发步骤分为以下几点：

在 AndroidManifest 中声明相关权限（网络和文件读写权限）
获取 WifiP2pManager ，注册相关广播监听Wifi直连的状态变化
指定某一台设备为服务器（用来接收文件），创建群组并作为群主存在，在指定端口监听客户端的连接请求，等待客户端发起连接请求以及文件传输请求
客户端（用来发送文件）主动搜索附近的设备，加入到服务器创建的群组，获取服务器的IP地址，向其发起文件传输请求
校验文件完整性

一、声明权限

Wifi P2P 技术并不会访问网络，但由于会使用到 Java socket，所以需要申请网络权限。此外，由于是要实现文件互传，所以也需要申请SD卡读写权限。

复制

<uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />  <uses-permission android:name="android.permission.CHANGE_WIFI_STATE" />  <uses-permission android:name="android.permission.CHANGE_NETWORK_STATE" />  <uses-permission android:name="android.permission.INTERNET" />  <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />  <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />  <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />

二、注册广播

与 Wifi P2P 相关的广播有以下几个：

WIFI_P2P_STATE_CHANGED_ACTION（用于指示 Wifi P2P 是否可用）
WIFI_P2P_PEERS_CHANGED_ACTION（对等节点列表发生了变化）
WIFI_P2P_CONNECTION_CHANGED_ACTION（ Wifi P2P 的连接状态发生了改变）
WIFI_P2P_THIS_DEVICE_CHANGED_ACTION（本设备的设备信息发生了变化）

当接收到这几个广播时，我们都需要到 WifiP2pManager （对等网络管理器）来进行相应的信息请求，此外还需要用到 Channel 对象作为请求参数

复制

mWifiP2pManager = (WifiP2pManager) getSystemService(Context.WIFI_P2P_SERVICE);  mChannel = mWifiP2pManager.initialize(this, getMainLooper(), this);

当收到 WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION 广播时，可以判断当前 Wifi P2P是否可用

复制

int state = intent.getIntExtra(WifiP2pManager.EXTRA_WIFI_STATE, -1);if (state == WifiP2pManager.WIFI_P2P_STATE_ENABLED) {      mDirectActionListener.wifiP2pEnabled(true);  } else {      mDirectActionListener.wifiP2pEnabled(false);  }

当收到 WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION 广播时，意味设备周围的可用设备列表发生了变化，可以通过 requestPeers 方法得到可用的设备列表，之后就可以选择当中的某一个设备进行连接操作

复制

mWifiP2pManager.requestPeers(mChannel, new WifiP2pManager.PeerListListener() {    @Override      public void onPeersAvailable(WifiP2pDeviceList peers) {          mDirectActionListener.onPeersAvailable(peers.getDeviceList());      }  });

当收到 WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION 广播时，意味着 Wifi P2P 的连接状态发生了变化，可能是连接到了某设备，或者是与某设备断开了连接

复制

NetworkInfo networkInfo = intent.getParcelableExtra(WifiP2pManager.EXTRA_NETWORK_INFO);if (networkInfo.isConnected()) {      mWifiP2pManager.requestConnectionInfo(mChannel, new WifiP2pManager.ConnectionInfoListener() {        @Override          public void onConnectionInfoAvailable(WifiP2pInfo info) {              mDirectActionListener.onConnectionInfoAvailable(info);          }      });      Log.e(TAG, "已连接p2p设备");  } else {      mDirectActionListener.onDisconnection();      Log.e(TAG, "与p2p设备已断开连接");  }

如果是与某设备连接上了，则可以通过 requestConnectionInfo 方法获取到连接信息

当收到 WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION 广播时，则可以获取到本设备变化后的设备信息

复制

(WifiP2pDevice) intent.getParcelableExtra(WifiP2pManager.EXTRA_WIFI_P2P_DEVICE)

可以看出 Wifi P2P 的接口高度异步化，到现在已经用到了三个系统的回调函数，一个用于 WifiP2pManager 的初始化，两个用于在广播中异步请求数据，为了简化操作，此处统一使用一个自定义的回调函数，方法含义与系统的回调函数一致

复制

public interface DirectActionListener extends WifiP2pManager.ChannelListener {      void wifiP2pEnabled(boolean enabled);          void onConnectionInfoAvailable(WifiP2pInfo wifiP2pInfo);      void onDisconnection();          void onSelfDeviceAvailable(WifiP2pDevice wifiP2pDevice);         void onPeersAvailable(Collection<WifiP2pDevice> wifiP2pDeviceList); }

所以，整个广播接收器使用到的所有代码是：

复制

/**   * 作者：chenZY   * 时间：2018/2/9 17:53   * 描述：   */  public class DirectBroadcastReceiver extends BroadcastReceiver {      private static final String TAG = "DirectBroadcastReceiver";         private WifiP2pManager mWifiP2pManager;         private WifiP2pManager.Channel mChannel;        private DirectActionListener mDirectActionListener;           public DirectBroadcastReceiver(WifiP2pManager wifiP2pManager, WifiP2pManager.Channel channel, DirectActionListener directActionListener) {          mWifiP2pManager = wifiP2pManager;          mChannel = channel;          mDirectActionListener = directActionListener;      }         public static IntentFilter getIntentFilter() {          IntentFilter intentFilter = new IntentFilter();          intentFilter.addAction(WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION);          intentFilter.addAction(WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION);          intentFilter.addAction(WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION);          intentFilter.addAction(WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION);           return intentFilter;      }        @Override      public void onReceive(Context context, Intent intent) {          Log.e(TAG, "接收到广播： " + intent.getAction());         if (!TextUtils.isEmpty(intent.getAction())) {              switch (intent.getAction()) {                      // 用于指示 Wifi P2P 是否可用                 case WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION: {                         int state = intent.getIntExtra(WifiP2pManager.EXTRA_WIFI_STATE, -1);                       if (state == WifiP2pManager.WIFI_P2P_STATE_ENABLED) {                         mDirectActionListener.wifiP2pEnabled(true);                     } else {                         mDirectActionListener.wifiP2pEnabled(false);                         List<WifiP2pDevice> wifiP2pDeviceList = new ArrayList<>();                         mDirectActionListener.onPeersAvailable(wifiP2pDeviceList);                     }                                         break;                  }                                  // 对等节点列表发生了变化                  case WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION: {                      mWifiP2pManager.requestPeers(mChannel, new WifiP2pManager.PeerListListener() {                          @Override                          public void onPeersAvailable(WifiP2pDeviceList peers) {                             mDirectActionListener.onPeersAvailable(peers.getDeviceList());                         }                     });                              break;                 }                                  // Wifi P2P 的连接状态发生了改变                  case WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION: {                     NetworkInfo networkInfo = intent.getParcelableExtra(WifiP2pManager.EXTRA_NETWORK_INFO);                       if (networkInfo.isConnected()) {                         mWifiP2pManager.requestConnectionInfo(mChannel, new WifiP2pManager.ConnectionInfoListener() {                               @Override                             public void onConnectionInfoAvailable(WifiP2pInfo info) {                                 mDirectActionListener.onConnectionInfoAvailable(info);                             }                         });                          Log.e(TAG, "已连接p2p设备");                      } else {                          mDirectActionListener.onDisconnection();                          Log.e(TAG, "与p2p设备已断开连接");                      }                                         break;                  }                                  //本设备的设备信息发生了变化                  case WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION: {                     mDirectActionListener.onSelfDeviceAvailable((WifiP2pDevice) intent.getParcelableExtra(WifiP2pManager.EXTRA_WIFI_P2P_DEVICE));                       break;                 }             }         }     } }

三、服务器端创建群组

假设当设备A搜索到了设备B，并与设备B连接到了一起，此时系统会自动创建一个群组（Group）并随机指定一台设备为群主（GroupOwner）。此时，对于两台设备来说，群主的IP地址是可知的（系统回调函数中有提供），但客户端的IP地址需要再来通过其他方法来主动获取。例如，可以在设备连接成功后，客户端主动发起对服务器端的Socket连接请求，服务器端在指定端口监听客户端的连接请求，当连接成功后，服务器端就可以获取到客户端的IP地址了

此处为了简化操作，直接指定某台设备作为服务器端（群主），即直接指定某台设备用来接收文件

因此，服务器端要主动创建群组，并等待客户端的连接

复制

wifiP2pManager.createGroup(channel, new WifiP2pManager.ActionListener() {      @Override     public void onSuccess() {         Log.e(TAG, "createGroup onSuccess");         dismissLoadingDialog();         showToast("onSuccess");     }          @Override      public void onFailure(int reason) {         Log.e(TAG, "createGroup onFailure: " + reason);         dismissLoadingDialog();         showToast("onFailure");     } });

此处，使用 IntentService 在后台监听客户端的Socket连接请求，并通过输入输出流来传输文件。此处的代码比较简单，就只是在指定端口一直堵塞监听客户端的连接请求，获取待传输的文件信息模型 FileTransfer ，之后就进行实际的数据传输

复制

@Override   protected void onHandleIntent(Intent intent) {      clean();      File file = null;           try {           serverSocket = new ServerSocket();           serverSocket.setReuseAddress(true);           serverSocket.bind(new InetSocketAddress(PORT));           Socket client = serverSocket.accept();           Log.e(TAG, "客户端IP地址 : " + client.getInetAddress().getHostAddress());           inputStream = client.getInputStream();           objectInputStream = new ObjectInputStream(inputStream);           FileTransfer fileTransfer = (FileTransfer) objectInputStream.readObject();          Log.e(TAG, "待接收的文件: " + fileTransfer);           String name = new File(fileTransfer.getFilePath()).getName();                   //将文件存储至指定位置           file = new File(Environment.getExternalStorageDirectory() + "/" + name);           fileOutputStream = new FileOutputStream(file);             byte buf[] = new byte[512];                int len;                      long total = 0;                     int progress;                     while ((len = inputStream.read(buf)) != -1) {              fileOutputStream.write(buf, 0, len);              total += len;              progress = (int) ((total * 100) / fileTransfer.getFileLength());              Log.e(TAG, "文件接收进度: " + progress);                  if (progressChangListener != null) {                  progressChangListener.onProgressChanged(fileTransfer, progress);              }           }          serverSocket.close();          inputStream.close();          objectInputStream.close();           fileOutputStream.close();           serverSocket = null;           inputStream = null;           objectInputStream = null;           fileOutputStream = null;           Log.e(TAG, "文件接收成功，文件的MD5码是：" + Md5Util.getMd5(file));       } catch (Exception e) {           Log.e(TAG, "文件接收 Exception: " + e.getMessage());       } finally {           clean();                      if (progressChangListener != null) {               progressChangListener.onTransferFinished(file);           }              //再次启动服务，等待客户端下次连接          startService(new Intent(this, WifiServerService.class));      }   }

因为客户端可能会多次发起连接请求，所以当此处文件传输完成后（不管成功或失败），都需要重新 startService ，让服务再次堵塞等待客户端的连接请求

FileTransfer 包含三个字段，MD5码值用于校验文件的完整性，fileLength 是为了用于计算文件的传输进度

复制

public class FileTransfer implements Serializable {     //文件路径     private String filePath;          //文件大小     private long fileLength;       //MD5码      private String md5;      ··· }

为了将文件传输进度发布到外部界面，所以除了需要启动Service外，界面还需要绑定Service，此处就需要用到一个更新文件传输状态的接口

复制

public interface OnProgressChangListener {      //当传输进度发生变化时      void onProgressChanged(FileTransfer fileTransfer, int progress);      //当传输结束时     void onTransferFinished(File file); }

因此，需要将 progressChangListener 作为参数传给 WifiServerService ，并在进度变化时更新进度对话框

复制

private WifiServerService.OnProgressChangListener progressChangListener = new WifiServerService.OnProgressChangListener() {           @Override        public void onProgressChanged(final FileTransfer fileTransfer, final int progress) {            runOnUiThread(new Runnable() {                @Override                public void run() {                   progressDialog.setMessage("文件名： " + new File(fileTransfer.getFilePath()).getName());                    progressDialog.setProgress(progress);                    progressDialog.show();                }            });         }              @Override         public void onTransferFinished(final File file) {             runOnUiThread(new Runnable() {                  @Override                public void run() {                    progressDialog.cancel();                     if (file != null &amp;&amp; file.exists()) {                        openFile(file.getPath());                    }                }            });        }    };

四、客户端加入群组并发起文件传输请求

文件发送界面 SendFileActivity 需要实现 DirectActionListener 接口

首先，需要先注册P2P广播，以便获取周边设备信息以及连接状态

复制

@Override  protected void onCreate(Bundle savedInstanceState) {     super.onCreate(savedInstanceState);      setContentView(R.layout.activity_send_file);      initView();      mWifiP2pManager = (WifiP2pManager) getSystemService(Context.WIFI_P2P_SERVICE);      mChannel = mWifiP2pManager.initialize(this, getMainLooper(), this);      broadcastReceiver = new DirectBroadcastReceiver(mWifiP2pManager, mChannel, this);      registerReceiver(broadcastReceiver, DirectBroadcastReceiver.getIntentFilter());  }

通过 discoverPeers 方法搜索周边设备，回调函数用于通知方法是否调用成功

复制

mWifiP2pManager.discoverPeers(mChannel, new WifiP2pManager.ActionListener() {    @Override      public void onSuccess() {          showToast("Success");      }          @Override      public void onFailure(int reasonCode) {          showToast("Failure");          loadingDialog.cancel();      }  });

当搜索结束后，系统就会触发 WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION 广播，此时就可以调用 requestPeers 方法获取设备列表信息，此处用 RecyclerView 展示列表，在 onPeersAvailable 方法刷新列表

复制

mWifiP2pManager.requestPeers(mChannel, new WifiP2pManager.PeerListListener() {      @Override      public void onPeersAvailable(WifiP2pDeviceList peers) {          mDirectActionListener.onPeersAvailable(peers.getDeviceList());      } });      @Override      public void onPeersAvailable(Collection<WifiP2pDevice> wifiP2pDeviceList) {          Log.e(TAG, "onPeersAvailable :" + wifiP2pDeviceList.size());          this.wifiP2pDeviceList.clear();                 this.wifiP2pDeviceList.addAll(wifiP2pDeviceList);          deviceAdapter.notifyDataSetChanged();         loadingDialog.cancel();     }

之后，通过点击事件选中群主（服务器端）设备，通过 connect 方法请求与之进行连接

复制

private void connect() {      WifiP2pConfig config = new WifiP2pConfig();      if (config.deviceAddress != null &amp;&amp; mWifiP2pDevice != null) {          config.deviceAddress = mWifiP2pDevice.deviceAddress;          config.wps.setup = WpsInfo.PBC;          showLoadingDialog("正在连接 " + mWifiP2pDevice.deviceName);          mWifiP2pManager.connect(mChannel, config, new WifiP2pManager.ActionListener() {                        @Override              public void onSuccess() {                  Log.e(TAG, "connect onSuccess");              }                      @Override              public void onFailure(int reason) {                 showToast("连接失败 " + reason);                  dismissLoadingDialog();             }          });      }  }

此处依然无法通过函数函数来判断连接结果，需要依靠系统发出的 WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION 方法来获取到连接结果，在此处可以通过 requestConnectionInfo 获取到组连接信息，信息最后通过 onConnectionInfoAvailable 方法传递出来，在此可以判断当前设备是否为群主，获取群组IP地址

复制

@Override  public void onConnectionInfoAvailable(WifiP2pInfo wifiP2pInfo) {      dismissLoadingDialog();      wifiP2pDeviceList.clear();      deviceAdapter.notifyDataSetChanged();      btn_disconnect.setEnabled(true);      btn_chooseFile.setEnabled(true);      Log.e(TAG, "onConnectionInfoAvailable");      Log.e(TAG, "onConnectionInfoAvailable groupFormed: " + wifiP2pInfo.groupFormed);      Log.e(TAG, "onConnectionInfoAvailable isGroupOwner: " + wifiP2pInfo.isGroupOwner);      Log.e(TAG, "onConnectionInfoAvailable getHostAddress: " + wifiP2pInfo.groupOwnerAddress.getHostAddress());      StringBuilder stringBuilder = new StringBuilder();        if (mWifiP2pDevice != null) {          stringBuilder.append("连接的设备名：");          stringBuilder.append(mWifiP2pDevice.deviceName);          stringBuilder.append("\n");          stringBuilder.append("连接的设备的地址：");          stringBuilder.append(mWifiP2pDevice.deviceAddress);      }      stringBuilder.append("\n");      stringBuilder.append("是否群主：");      stringBuilder.append(wifiP2pInfo.isGroupOwner ? "是群主" : "非群主");      stringBuilder.append("\n");      stringBuilder.append("群主IP地址：");      stringBuilder.append(wifiP2pInfo.groupOwnerAddress.getHostAddress());      tv_status.setText(stringBuilder);         if (wifiP2pInfo.groupFormed &amp;&amp; !wifiP2pInfo.isGroupOwner) {          this.wifiP2pInfo = wifiP2pInfo;      }  }

至此服务器端和客户端已经通过 Wifi P2P 连接在了一起，客户端也获取到了服务器端的IP地址，在选取好待发送的文件后就可以主动发起对服务器端的连接请求了

发起选取文件的方法

复制

Intent intent = new Intent(Intent.ACTION_GET_CONTENT);  intent.setType("*/*"); intent.addCategory(Intent.CATEGORY_OPENABLE);  startActivityForResult(intent, 1);

获取选取的文件的实际路径

复制

@Override  protected void onActivityResult(int requestCode, int resultCode, Intent data) {         super.onActivityResult(requestCode, resultCode, data);          if (requestCode == 1) {        if (resultCode == RESULT_OK) {             Uri uri = data.getData();              if (uri != null) {                  String path = getPath(this, uri);                  if (path != null) {                     File file = new File(path);                      if (file.exists() &amp;&amp; wifiP2pInfo != null) {                         FileTransfer fileTransfer = new FileTransfer(file.getPath(), file.length());                        Log.e(TAG, "待发送的文件：" + fileTransfer);                              new WifiClientTask(this, fileTransfer).execute(wifiP2pInfo.groupOwnerAddress.getHostAddress());                     }                 }              }          }      }  }                           private String getPath(Context context, Uri uri) {         if ("content".equalsIgnoreCase(uri.getScheme())) {          Cursor cursor = context.getContentResolver().query(uri, new String[]{"_data"}, null, null, null);           if (cursor != null) {                       if (cursor.moveToFirst()) {                 String data = cursor.getString(cursor.getColumnIndex("_data"));                 cursor.close();                             return data;              }          }      } else if ("file".equalsIgnoreCase(uri.getScheme())) {                return uri.getPath();     }         return null;  }

文件的发送操作放到 AsyncTask 中处理，将服务器端的IP地址作为参数传进来，在正式发送文件前，先发送包含文件信息（文件名，文件大小，文件MD5码）的信息模型 FileTransfer ，并在发送文件的过程中同时更新进度

复制

/**   * 作者：叶应是叶   * 时间：2018/2/15 8:51   * 描述：客户端发送文件   */  public class WifiClientTask extends AsyncTask<String, Integer, Boolean> {       private ProgressDialog progressDialog;      private FileTransfer fileTransfer;        private static final int PORT = 4786;         private static final String TAG = "WifiClientTask";            public WifiClientTask(Context context, FileTransfer fileTransfer) {           this.fileTransfer = fileTransfer;          progressDialog = new ProgressDialog(context);          progressDialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);          progressDialog.setCancelable(false);          progressDialog.setCanceledOnTouchOutside(false);          progressDialog.setTitle("正在发送文件");          progressDialog.setMax(100);      }          @Override      protected void onPreExecute() {         progressDialog.show();      }         @Override      protected Boolean doInBackground(String... strings) {          fileTransfer.setMd5(Md5Util.getMd5(new File(fileTransfer.getFilePath())));          Log.e(TAG, "文件的MD5码值是：" + fileTransfer.getMd5());          Socket socket = null;          OutputStream outputStream = null;          ObjectOutputStream objectOutputStream = null;          InputStream inputStream = null;            try {             socket = new Socket();              socket.bind(null);              socket.connect((new InetSocketAddress(strings[0], PORT)), 10000);              outputStream = socket.getOutputStream();              objectOutputStream = new ObjectOutputStream(outputStream);              objectOutputStream.writeObject(fileTransfer);              inputStream = new FileInputStream(new File(fileTransfer.getFilePath()));               long fileSize = fileTransfer.getFileLength();                         long total = 0;                          byte buf[] = new byte[512];                          int len;                          while ((len = inputStream.read(buf)) != -1) {                  outputStream.write(buf, 0, len);                  total += len;                                int progress = (int) ((total * 100) / fileSize);                 publishProgress(progress);                  Log.e(TAG, "文件发送进度：" + progress);              }              outputStream.close();              objectOutputStream.close();              inputStream.close();              socket.close();              outputStream = null;              objectOutputStream = null;              inputStream = null;              socket = null;              Log.e(TAG, "文件发送成功");                        return true;          } catch (Exception e) {              Log.e(TAG, "文件发送异常 Exception: " + e.getMessage());          } finally {               if (outputStream != null) {                  try {                     outputStream.close();                  } catch (IOException e) {                     e.printStackTrace();                 }             }                          if (objectOutputStream != null) {                 try {                      objectOutputStream.close();                  } catch (IOException e) {                      e.printStackTrace();                  }              }                          if (inputStream != null) {                    try {                      inputStream.close();                  } catch (IOException e) {                      e.printStackTrace();                  }             }                          if (socket != null) {                   try {                     socket.close();                 } catch (Exception e) {                     e.printStackTrace();                 }              }          }                  return false;      }           @Override      protected void onProgressUpdate(Integer... values) {          progressDialog.setProgress(values[0]);      }         @Override      protected void onPostExecute(Boolean aBoolean) {          progressDialog.cancel();          Log.e(TAG, "onPostExecute: " + aBoolean);      }  }

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.
78.
79.
80.
81.
82.
83.
84.
85.
86.
87.
88.
89.
90.
91.
92.
93.
94.
95.
96.
97.
98.
99.
100.
101.
102.
103.
104.
105.
106.
107.
108.
109.
110.
111.
112.
113.
114.
115.

五、校验文件完整性

传输文件的完整性主要是通过计算文件的MD5码值来保证了，在发送文件前，即在 WifiClientTask 的 doInBackground 方法中进行计算，将MD5码值赋给 FileTransfer 模型，通过如下方法计算得到

复制

/**   * 作者：叶应是叶   * 时间：2018/2/14 21:16   * 描述：   */  public class Md5Util {      public static String getMd5(File file) {          InputStream inputStream = null;          byte[] buffer = new byte[2048];          int numRead;         MessageDigest md5;                 try {              inputStream = new FileInputStream(file);              md5 = MessageDigest.getInstance("MD5");             while ((numRead = inputStream.read(buffer)) > 0) {                 md5.update(buffer, 0, numRead);             }             inputStream.close();              inputStream = null;              return md5ToString(md5.digest());         } catch (Exception e) {                     return null;         } finally {                         if (inputStream != null) {                   try {                     inputStream.close();                 } catch (IOException e) {                     e.printStackTrace();                 }             }         }     }                   private static String md5ToString(byte[] md5Bytes) {          StringBuilder hexValue = new StringBuilder();          for (byte b : md5Bytes) {                    int val = ((int) b) &amp; 0xff;               if (val < 16) {                 hexValue.append("0");             }              hexValue.append(Integer.toHexString(val));          }                  return hexValue.toString();      }  }

因为客户端会将 FileTransfer 传给服务器端，所以服务器端在文件传输结束后，可以重新计算文件的MD5码值，进行对比以判断文件是否完整。

代码地址：https://github.com/leavesC/WifiP2P

喜欢已喜欢

27 2018-03-16 15:14:08 Android 传输文件

如何创建多云传输网络系统

Java编码及网络传输中的编码问题

您正在使用低版本浏览器，为了获得更良好的体验，建议您升级浏览器，为您推荐：