Java Socket实现文件传输示例代码

最近学socket学上瘾了，就写了一个简单的文件传输程序。

客户端设计思路：客户端与服务端建立连接，选择客户端本地文件，先将文件名及大小等属性发送给服务端，再将文件通过流的方式传输给服务端。传输的进度打印到控制台中，直到传输完成。

服务端设计思路：服务端接收客户端的请求（阻塞式），每接收到一个客户端请求连接后，就新开一个处理文件的线程，开始写入流，将文件到服务器的指定目录下，并与传输过来的文件同名。
下面是客户端和服务端的代码实现：

客户端代码：

import java.io.dataoutputstream; 
import java.io.file; 
import java.io.fileinputstream; 
import java.net.socket; 
 
/** 
 * 文件传输client端<br> 
 * 功能说明： 
 * 
 * @author 大智若愚的小懂 
 * @date 2016年09月01日 
 * @version 1.0 
 */ 
public class filetransferclient extends socket { 
 
  private static final string server_ip = "127.0.0.1"; // 服务端ip 
  private static final int server_port = 8899; // 服务端端口 
 
  private socket client; 
 
  private fileinputstream fis; 
 
  private dataoutputstream dos; 
 
  /** 
   * 构造函数<br/> 
   * 与服务器建立连接 
   * @throws exception 
   */ 
  public filetransferclient() throws exception { 
    super(server_ip, server_port); 
    this.client = this; 
    system.out.println("cliect[port:" + client.getlocalport() + "] 成功连接服务端"); 
  } 
 
  /** 
   * 向服务端传输文件 
   * @throws exception 
   */ 
  public void sendfile() throws exception { 
    try { 
      file file = new file("e:\\jdk1.6中文参考手册(jdk_api_1_6_zh_cn).chm"); 
      if(file.exists()) { 
        fis = new fileinputstream(file); 
        dos = new dataoutputstream(client.getoutputstream()); 
 
        // 文件名和长度 
        dos.writeutf(file.getname()); 
        dos.flush(); 
        dos.writelong(file.length()); 
        dos.flush(); 
 
        // 开始传输文件 
        system.out.println("======== 开始传输文件 ========"); 
        byte[] bytes = new byte[1024]; 
        int length = 0; 
        long progress = 0; 
        while((length = fis.read(bytes, 0, bytes.length)) != -1) { 
          dos.write(bytes, 0, length); 
          dos.flush(); 
          progress += length; 
          system.out.print("| " + (100*progress/file.length()) + "% |"); 
        } 
        system.out.println(); 
        system.out.println("======== 文件传输成功 ========"); 
      } 
    } catch (exception e) { 
      e.printstacktrace(); 
    } finally { 
      if(fis != null) 
        fis.close(); 
      if(dos != null) 
        dos.close(); 
      client.close(); 
    } 
  } 
 
  /** 
   * 入口 
   * @param args 
   */ 
  public static void main(string[] args) { 
    try { 
      filetransferclient client = new filetransferclient(); // 启动客户端连接 
      client.sendfile(); // 传输文件 
    } catch (exception e) { 
      e.printstacktrace(); 
    } 
  } 
 
} 

服务端代码：

import java.io.datainputstream; 
import java.io.file; 
import java.io.fileoutputstream; 
import java.math.roundingmode; 
import java.net.serversocket; 
import java.net.socket; 
import java.text.decimalformat; 
 
/** 
 * 文件传输server端<br> 
 * 功能说明： 
 * 
 * @author 大智若愚的小懂 
 * @date 2016年09月01日 
 * @version 1.0 
 */ 
public class filetransferserver extends serversocket { 
 
  private static final int server_port = 8899; // 服务端端口 
 
  private static decimalformat df = null; 
 
  static { 
    // 设置数字格式，保留一位有效小数 
    df = new decimalformat("#0.0"); 
    df.setroundingmode(roundingmode.half_up); 
    df.setminimumfractiondigits(1); 
    df.setmaximumfractiondigits(1); 
  } 
 
  public filetransferserver() throws exception { 
    super(server_port); 
  } 
 
  /** 
   * 使用线程处理每个客户端传输的文件 
   * @throws exception 
   */ 
  public void load() throws exception { 
    while (true) { 
      // server尝试接收其他socket的连接请求，server的accept方法是阻塞式的 
      socket socket = this.accept(); 
      /** 
       * 我们的服务端处理客户端的连接请求是同步进行的， 每次接收到来自客户端的连接请求后， 
       * 都要先跟当前的客户端通信完之后才能再处理下一个连接请求。 这在并发比较多的情况下会严重影响程序的性能， 
       * 为此，我们可以把它改为如下这种异步处理与客户端通信的方式 
       */ 
      // 每接收到一个socket就建立一个新的线程来处理它 
      new thread(new task(socket)).start(); 
    } 
  } 
 
  /** 
   * 处理客户端传输过来的文件线程类 
   */ 
  class task implements runnable { 
 
    private socket socket; 
 
    private datainputstream dis; 
 
    private fileoutputstream fos; 
 
    public task(socket socket) { 
      this.socket = socket; 
    } 
 
    @override 
    public void run() { 
      try { 
        dis = new datainputstream(socket.getinputstream()); 
 
        // 文件名和长度 
        string filename = dis.readutf(); 
        long filelength = dis.readlong(); 
        file directory = new file("d:\\ftcache"); 
        if(!directory.exists()) { 
          directory.mkdir(); 
        } 
        file file = new file(directory.getabsolutepath() + file.separatorchar + filename); 
        fos = new fileoutputstream(file); 
 
        // 开始接收文件 
        byte[] bytes = new byte[1024]; 
        int length = 0; 
        while((length = dis.read(bytes, 0, bytes.length)) != -1) { 
          fos.write(bytes, 0, length); 
          fos.flush(); 
        } 
        system.out.println("======== 文件接收成功 [file name：" + filename + "] [size：" + getformatfilesize(filelength) + "] ========"); 
      } catch (exception e) { 
        e.printstacktrace(); 
      } finally { 
        try { 
          if(fos != null) 
            fos.close(); 
          if(dis != null) 
            dis.close(); 
          socket.close(); 
        } catch (exception e) {} 
      } 
    } 
  } 
 
  /** 
   * 格式化文件大小 
   * @param length 
   * @return 
   */ 
  private string getformatfilesize(long length) { 
    double size = ((double) length) / (1 << 30); 
    if(size >= 1) { 
      return df.format(size) + "gb"; 
    } 
    size = ((double) length) / (1 << 20); 
    if(size >= 1) { 
      return df.format(size) + "mb"; 
    } 
    size = ((double) length) / (1 << 10); 
    if(size >= 1) { 
      return df.format(size) + "kb"; 
    } 
    return length + "b"; 
  } 
 
  /** 
   * 入口 
   * @param args 
   */ 
  public static void main(string[] args) { 
    try { 
      filetransferserver server = new filetransferserver(); // 启动服务端 
      server.load(); 
    } catch (exception e) { 
      e.printstacktrace(); 
    } 
  } 
} 

测试的结果（客户端）：

测试的结果（服务端）：

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。