使用Java网络编程实现用户上传文件

  1. 客户端Client:
    用户上传本地文件到服务器端,服务器返回文件上传成功。

    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
    package xnj.fileupload;

    import java.io.*;
    import java.net.InetAddress;
    import java.net.Socket;
    import java.util.concurrent.*;

    // 客户端;上传文件
    public class Client {
    public static void main(String[] args) throws IOException {
    // 创建socket对象连接服务器,服务器ip地址和端口
    Socket socket = new Socket("127.0.0.1",10086);

    // 读取本地文件并写入服务器
    FileInputStream fis = new FileInputStream("C:\\Users\\xnj\\Pictures\\保存的图片\\1594086267611.jpg");
    BufferedInputStream bis = new BufferedInputStream(fis);
    BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
    byte[] bytes = new byte[1024];
    int len;
    while( ( len = bis.read(bytes)) != -1){
    bos.write(bytes,0,len);
    }

    // 往服务器发送结束标记
    socket.shutdownOutput();

    // 接收服务器的响应信息
    BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
    String msg = br.readLine();
    System.out.println(msg);

    // 关闭资源
    socket.close();
    }
    }
  2. 服务端Server:
    服务器端接收客户端上传的文件,并保存到服务器本地。

    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
    package xnj.fileupload;

    import java.io.*;
    import java.net.ServerSocket;
    import java.net.Socket;
    import java.util.UUID;
    import java.util.concurrent.ArrayBlockingQueue;
    import java.util.concurrent.Executors;
    import java.util.concurrent.ThreadPoolExecutor;
    import java.util.concurrent.TimeUnit;

    // 服务端,保存客户端上传的文件
    public class Server {

    public static void main(String[] args) throws IOException {
    // 下面频繁创建线程会消耗服务器的性能,所以这里使用线程池
    ThreadPoolExecutor pool = new ThreadPoolExecutor(
    3,// 核心线程数
    16,// 最大线程数
    60,// 线程空闲时间
    TimeUnit.SECONDS,// 线程空闲时间单位
    new ArrayBlockingQueue<Runnable>(2),// 阻塞队列
    Executors.defaultThreadFactory(),// 线程工厂,让工厂如何创建线程对象
    new ThreadPoolExecutor.AbortPolicy()// 拒绝策略
    );


    // 创建对象,监听10000端口
    ServerSocket serverSocket = new ServerSocket(10086);

    // 循环监听,即可多次上传
    while (true) {
    // 等待客户端连接
    Socket socket = serverSocket.accept();

    // 开启一条线程
    // 一个用户对应一条线程
    // new MyRunnable(socket).start();
    // 使用线程池
    pool.submit(new MyRunnable(socket));
    }

    }
    }
  3. 线程类MyRunnable:

    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
    package xnj.fileupload;

    import java.io.*;
    import java.net.Socket;
    import java.util.UUID;

    public class MyRunnable implements Runnable{

    Socket socket ;

    public MyRunnable(Socket socket) {
    this.socket = socket;
    }
    @Override
    public void run() {
    try {
    // 读取数据并保存到本地文件中
    BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
    String name = UUID.randomUUID().toString().replace("-", "");
    BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("fileimage\\"+name+".jpg"));
    byte[] bytes = new byte[1024];
    int len;
    while( ( len = bis.read(bytes)) != -1){
    bos.write(bytes,0,len);
    }

    // 发送反馈信息
    socket.shutdownInput();
    BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
    bw.write("上传成功");
    bw.newLine();
    bw.flush();

    } catch (IOException e) {
    throw new RuntimeException(e);
    }finally {
    // 释放资源
    if(socket != null){
    try {
    socket.close();
    } catch (IOException e) {
    throw new RuntimeException(e);
    }
    }
    }
    }
    }