Socket & ServerSocket 使用

示例一

服务器端

// ServerSocket 会等待 客户端发送请求，，一旦接收到请求会创建一个 Socket 与 客户端进行通讯
ServerSocket serverSocket = new ServerSocket(8888);
System.out.println("======   ServerStart    =====");
// 等待客户端发送请求
Socket socket =  serverSocket.accept();
// 客户端发送请求后，返回 socket 进行通讯
// 获取数据输入流，读取数据
InputStream inputStream = socket.getInputStream();

byte [] b = new byte[1024];
int len;
len = inputStream.read(b);
System.out.println(new String(b,0,len));
// 获取数据输出流，发送数据
OutputStream outputStream = socket.getOutputStream();
outputStream.write("你好客户端！".getBytes());

outputStream.close();
inputStream.close();
serverSocket.close();

客户端

try {
    Socket socket = new Socket("127.0.0.1", 8888);
    //使用Socket 的字节输出流
    OutputStream outputStream = socket.getOutputStream();
    //使用字节输出流 向服务器发送数据
    outputStream.write("你好服务器!".getBytes());

    // 获取字节输入流，读取服务器发送的数据
    InputStream inputStream = socket.getInputStream();
    byte[] b = new byte[1024];
    int len = inputStream.read(b);

    System.out.println(new String(b,0,len));
    outputStream.close();

}catch (IOException e){
    System.out.println("Error:"+e.toString());
}

文件上传

先启动服务器，服务器需要获取到网络输入流的内容，并使用本地输出流将获取到的内容保存到服务器

客户端需要使用文件输入流将本地的文件读取出来，使用网络输出流将数据传递到服务器

服务器

package test;

import testPro.Pro;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

public class ServerSocketTest {
    public static void main(String[] args) {
        try{
            //请求 客户端Socket对象
            ServerSocket serverSocket =  new ServerSocket(8888);
            //获取Socket对象
            Socket socket = serverSocket.accept();
            Pro.upLoad(socket,"/Server.txt");
            serverSocket.close();

        } catch (IOException e) {
            System.out.println("ServerSocket Error:"+e.toString());
        }
    }
}

package testPro;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Random;

/**
 * @author LiYang
 * @Project Name: bilibili
 * @Package Name: testPro
 * Created by MacBook Air on 2020/02/29.
 * Copyright © 2020 LiYang. All rights reserved.
 */
public class Pro {
    public static void main(String[] args) {

        while (true){
        /*
            自定义一个文件的命名规则，防止文件被覆盖掉
            规则：域名+毫秒值 + 随机数
        */
        String fileName = "/Server"+System.currentTimeMillis() + new Random().nextInt(9999)+".txt";

        /*
            让服务器一直处于监听状态 （死循环方法）
            上传文件 -> 创建一个线程
         */

            try{
                //请求 客户端Socket对象
                ServerSocket serverSocket =  new ServerSocket(8888);
                //获取Socket对象
                Socket socket = serverSocket.accept();

                new Thread(() -> {
                    try {
                        upLoad(socket,fileName);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }).start();
                serverSocket.close();
            } catch (
                    IOException e) {
                System.out.println("ServerSocket Error:"+e.toString());
            }
        }
    }

    // 完成数据的保存
    public static void upLoad(Socket socket,String filename) throws IOException {
        InputStream inputStream = socket.getInputStream();
        File file = new File("网络/src/test/");

        if(!file.exists()){
            file.mkdir();
        }
        //创建本地输出流对象
        FileOutputStream fileOutputStream = new FileOutputStream(file + filename);

        byte [] b = new byte[1024];
        int len =0;
        while ((len = inputStream.read(b)) != -1){
            //保存到服务器的磁盘上
            fileOutputStream.write(b,0,len);
        }

        //获取网络输出流
        OutputStream outputStream = socket.getOutputStream();
        //给客户端回写
        outputStream.write("文件接收成功！".getBytes());

        fileOutputStream.close();
        socket.close();
    }
}

客户端

package test;


import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

public class SocketTest {
    public static void main(String[] args) {
        try{
            //创建本地输入流
            FileInputStream fileInputStream = new FileInputStream("网络/src/test/Socket.txt");
            //创建客户端对象
            Socket socket = new Socket("127.0.0.1",8888);
            //获取网络字节输出流对象
            OutputStream outputStream = socket.getOutputStream();
            int len;
            byte [] b = new byte[1024];
            //读取本地文件
            while ((len = fileInputStream.read(b))!= -1){
                //上传到服务器
                outputStream.write(b,0,len);
            }

            
            // 只关闭输出流
            socket.shutdownOutput();
            
            //获取网络字节输入流
            InputStream inputStream = socket.getInputStream();
            //读取服务器回写数据
            len = inputStream.read(b);
            System.out.println(new String(b,0,len));

            //释放资源
            fileInputStream.close();
            socket.close();

        }catch (IOException e){
            System.out.println("Socket Error:"+e.toString());
        }
    }
}

B/S 模式模拟

访问路径 http://localhost:8080/Server.txt

package Net;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * @author LiYang
 * @Project Name: bilibili
 * @Package Name: Net
 * Created by MacBook Air on 2020/02/29.
 * Copyright © 2020 LiYang. All rights reserved.
 * B/S 版本的Server服务器
 * http://localhost:8080/Server.txt
 */
public class NetTest {
    public static void main(String[] args) {
        try{
            // 创建服务器对象，并且设置端口号为 8080
            ServerSocket serverSocket = new ServerSocket(8080);
            while(true){

                // 监听客户端发送请求
                Socket socket = serverSocket.accept();
                InputStream  inputStream = socket.getInputStream();
                OutputStream outputStream =  socket.getOutputStream();

                // 设置响应的相关数据
                outputStream.write("HTTP/1.1 200 OK\r\n".getBytes());
                // 设置编码格式
                outputStream.write("Content-Type:text/html;charset=utf-8\r\n".getBytes());
                outputStream.write("\r\n".getBytes());

                try{
                    
                    // 获取请求的URL
                    BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
                    String url = bufferedReader.readLine();
                    System.out.println(url);
                    String [] arr = url.split(" ");

                    // 裁剪出 需要获取的文件信息
                    String file = arr[1].substring(1);
                    System.out.println(file);

                    FileInputStream fileInputStream = new FileInputStream("./网络/src/Net/" + file);

                    int len ;
                    byte[] bytes = new byte[1024];

                    while ((len = fileInputStream.read(bytes))!= -1){
                        outputStream.write(bytes,0,len);
                    }


                }catch (Exception e) {
                    e.printStackTrace();
                    // 如果发生错误，将错误信息返回到浏览器
                    outputStream.write(e.getMessage().getBytes());
                }finally {
                    outputStream.close();
                    socket.close();
                }
            }
        }catch (IOException e){
            System.out.println(e.toString());
        }
    }
}

总结

主要内容是 Socket & ServerSocket 类的使用，配合数据流完成数据内容的传输。

Socket

1. 构造方法

• public Socket(String host, int port) throws UnknownHostException, IOException

• @Deprecated public Socket(String host, int port, boolean stream) throws IOException

  Deprecated.

  Use DatagramSocket instead for UDP transport.

2. 方法

• public InputStream getInputStream() throws IOException
• public OutputStream getOutputStream() throws IOException
• public void shutdownInput() throws IOException
• public void shutdownOutput() throws IOException
• public boolean isInputShutdown()
• public boolean isOutputShutdown()

ServerSocket

1. 构造方法

• public ServerSocket(int port, int backlog) throws IOException
• public ServerSocket(int port) throws IOException

2. 方法

• public Socket accept() throws IOException
  Listens for a connection to be made to this socket and accepts it. The method blocks until a connection is made.

• public void close() throws IOException

• public boolean isClosed()