1. Basic concept of network

1.1 computer network

Definition: refers to a computer system that connects multiple computers and their external devices with independent functions (no network can exist independently) in different geographical locations through communication lines, and realizes resource sharing and information transmission under the management and coordination of network operating system, network management software and network communication protocol

• Backbone: computer network is a computer system
• Network functions: resource sharing and information transmission
• Network composition
  • Network hardware: computer, external equipment, communication connection
  • Network software: network operating system, network management software, network communication protocol

Classification – by size:

• LAN LAN
• MAN man
• Wide area network WAN

Classification – by transmission medium:

• Coaxial cable network (similar to cable of cable TV network)

• Twisted pair network

• Optical fiber network (transmitting optical signals)

• Satellite network

  

Classification – topology:

• Star network (most commonly used)

• Bus network: signals can be received in the transmission process. If it is identified as its own, it will be received

• Ring network: the same delivery mode

  

1.2 network communication protocol

To realize communication in the network, there must be some conventions (Communication Protocol) to specify standards for rate, transmission code, transmission control steps and so on (such as traffic rules)

Question: network communication involves many contents: source address, target address, encryption and decryption, flow control, routing control, etc. How to realize such a complex network protocol?

===Layering: decompose complex components into some simple components, and then combine them (the same layer can communicate with each other, and the upper layer can call the next layer without any relationship with the next layer)

Network communication protocol layering:

• Nominal standard: ISO -- > OSI reference model
• De facto standard: TCP/IP protocol stack

Data encapsulation and unpacking: in the process of transmission, various data need to be added through each layer, and finally sent to the other end, and then disassembled at the other end

1.3 TCP/IP protocol stack

The most commonly used protocol for network communication

• Main protocol of network layer: IP protocol
• Main protocols of transport layer: TCP and UDP protocols

1.4 TCP protocol

Connection oriented, reliable, byte stream based transport layer communication protocol (telephone case)

• Connection oriented (a piece of information is sent after segmentation, and the sending order is consistent with the receiving order)
• Point to point communication
• High reliability: three handshakes
• Occupy more system resources and low efficiency

Application List: HTTP, FTP, Telnet, SMTP

1.5 UDP protocol

Connectionless transport layer protocol provides simple and unreliable information transmission services for transactions (sending telegrams, sending group SMS)

• Non connection oriented, unreliable transmission and possible loss (a piece of information is sent after segmentation, not necessarily which section arrives first)
• No matter whether the other party is ready or not, the receiver will not reply after receiving it
• Can broadcast and send
• Very simple protocol with less overhead

Application cases: DNS, SNMP

1.6 IP address and port

IP address, used to mark the address of a communication entity (computer, router) in the network

Classification:

• IPV4: 32-bit address, expressed in dotted decimal system, such as 192.168.0.1
• IPV6: 128 bits are written into 8 16 bit unsigned integers. Each integer is identified by 4 hexadecimal bits, and the number is divided by:

Special IP address:

• 127.0.0.1: local address
• 192.168.0.0 – 192.168.255.255 private address for internal use of the organization

port:

• IP address is used to identify a computer, but a computer can provide multiple applications, so you need to use ports to distinguish applications
• Range: 0 – 65535 (16 bit integer)

Port classification:

• 0 – 1023: recognized port (for example, 80 to WWW, 21 to FTP, etc.)
• 1024 – 49151: registered port (assigned to user or application)
• 49152 – 65535: dynamic / private port

IP and port API s:

• InetAddress class: encapsulates the ip address of a computer without a port
• InetSocketAddress: contains the port used for socket communication

1.7 URL uniform resource locator

Uniform Resource Locator: it consists of four parts: protocol, host domain name where resources are stored, port number and resource file name

1.8 Socket

Socket is actually a programming interface provided by the transport layer to the application layer

Similar to sending a letter: the user (application layer) can put the letter (data) into the mailbox (the port of the mailbox is the socket). After entering the socket, how to send the letter is the matter of the post office, highway traffic management (transmission layer, network layer), etc.

2. Common classes of network programming

2.1 encapsulated IP address – InetAddress

// 1. Obtain IP address
InetAddress ia = InetAddress.getLocalHost();  // Native ip

// 2. Operation IP address
System.out.println(ia);  // DESKTOP-F31QQ1H/192.168.0.102
System.out.println(ia.getHostAddress()); // 192.168.0.102
System.out.println(ia.getHostName()); // DESKTOP-F31QQ1H

InetAddress ia2 = InetAddress.getByName("www.lwclick.com");  // Get ip through domain name
System.out.println(ia2);

2.2 encapsulation IP and Port – InetSocketAddress

// Create an InetSocketAddress object
InetSocketAddress isa = new InetSocketAddress("www.lwclick.com", 8888);

// Get object content
System.out.println(isa);  // www.lwclick.com/104.21.41.202:8888
System.out.println(isa.getAddress());  // www.lwclick.com/104.21.41.202
System.out.println(isa.getPort());  // 8888

2.3 URL class

// Create a URL protocol: https domain name / IP address: lwlick COM port: 80 path: / categories/MySQL/
URL url = new URL("https://lwclick.com:80/categories/MySQL/");

// Get the components of the URL
System.out.println(url.getProtocol());  //  https
System.out.println(url.getHost());  //  lwclick.com
System.out.println(url.getPort());  //  80
System.out.println(url.getDefaultPort());  //  443 default https port
System.out.println(url.getPath());  //  /categories/MySQL/

3. TCP programming

3.1 one way communication

• Server side:

  • Create a ServerSocket and listen on the specified port (accept() method)

    And process the request (if the client request arrives, return the corresponding Socket; otherwise, wait all the time and the thread is blocked)

• client:

  • To create a Socket, you need to specify the ip and port number of the server to send and receive responses to the server

• Send data:

  • You need to use an output stream, which can be wrapped through DataOutputStream and ObjectOutputStream to improve efficiency

• Receive data:

  • Use input stream, wrapped with DataInputStream and ObjectInputStream

Server side:

public class LoginServer {
    public static void main(String[] args) throws IOException {
        // 1. Create a ServerSocket and configure the listening port
        ServerSocket serverSocket = new ServerSocket(8080);

        // 2. Use ServerSocket to listen on the specified port
        Socket socket = serverSocket.accept(); // If the request is not received, it is blocked here; When the request arrives, a socket is returned and execution continues

        // 3. Receive the request data from the client and output the result
        InputStream is = socket.getInputStream(); // Get stream
        DataInputStream dis = new DataInputStream(is); // Data streams are also used for packaging
        String info = dis.readUTF(); // Read the written data of the corresponding type
        System.out.println("Client requests:" + info);

        // 4. Close resources
        dis.close();
        serverSocket.close();
    }
}

client:

public class LoginClient {
    public static void main(String[] args) throws IOException {
        // 1. Create a Socket to indicate the server-side ip and port
        Socket socket = new Socket(InetAddress.getLocalHost(), 8080); // InetAddress.getByName() get ip

        // 2. Send data to the server
        OutputStream os = socket.getOutputStream(); // Information is sent through stream and output stream
        DataOutputStream dos = new DataOutputStream(os); // Data stream packaging
        dos.writeUTF("userName=lwclick&pwd=123");

        // 3. Close resources
        dos.close(); // Close the high-level flow and the low-level flow will be closed automatically
    }
}

Note: during the test, the server needs to be started first, and then the client needs to be started

3.2 primary two-way communication

Server side:

public static void main(String[] args) throws IOException {
    ServerSocket serverSocket = new ServerSocket(8080);
    Socket socket = serverSocket.accept(); 
    InputStream is = socket.getInputStream();
    DataInputStream dis = new DataInputStream(is);
    String info = dis.readUTF(); 
    System.out.println("Client requests:" + info);

    // ==============================Send data to client=====================================
    // 4. Give a response to the client
    OutputStream os = socket.getOutputStream(); // The socket here is the response of the received client
    DataOutputStream dos = new DataOutputStream(os);
    dos.writeUTF("Login succeeded, welcome!");

    // 5. Close resources
    dos.close();
    dis.close();
    serverSocket.close();
}

3.3 transmission object

User class: when the class is transmitted on the network, it must implement the serialization interface

public class User implements Serializable {
    private String userId;
    private String password;
    
    // getter / setter / toString / constructor
}

Server side:

public static void main(String[] args) throws IOException, ClassNotFoundException {
    ServerSocket serverSocket = new ServerSocket(8080);
    Socket socket = serverSocket.accept(); 
    InputStream is = socket.getInputStream(); 
    
    // ===============Here, use [object stream] to receive data===================
    ObjectInputStream ois = new ObjectInputStream(is); 
    User user = (User)ois.readObject(); 
    System.out.println("Client requests:" + user);
    
    OutputStream os = socket.getOutputStream(); 
    DataOutputStream dos = new DataOutputStream(os);
    if (user.getUserId().indexOf("lwclick") >= 0 && user.getPassword().length() > 6) {
        dos.writeUTF("Login succeeded, welcome!");
    } else {
        dos.writeUTF("Login failed, please try again!");
    }

    dos.close();
    ois.close();
    serverSocket.close();
}

client:

public static void main(String[] args) throws IOException {
    Socket socket = new Socket(InetAddress.getLocalHost(), 8080);

    // Get user input
    Scanner sc = new Scanner(System.in);
    System.out.print("userId:  ");
    String userId = sc.next();
    System.out.print("password:  ");
    String password = sc.next();
    User user = new User(userId, password);

    OutputStream os = socket.getOutputStream();
    // [object flow] for packaging
    ObjectOutputStream oos = new ObjectOutputStream(os); 
    oos.writeObject(user);

    InputStream is = socket.getInputStream();
    DataInputStream dis = new DataInputStream(is);
    String info = dis.readUTF();
    System.out.println("Server side response:" + info);

    dis.close();
    oos.close();
}

3.4 introduction of multithreading

Put the processing steps after the server receives the request into the run() method of the thread, and create a thread to execute every request

Thread class:

public class LoginThread extends Thread {
    private Socket socket;

    public LoginThread() {
    }
    
    public LoginThread(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        DataOutputStream dos = null;
        ObjectInputStream ois = null;
        try {
            InputStream is = socket.getInputStream();
            ois = new ObjectInputStream(is);
            User user = (User)ois.readObject();
            System.out.println("Client requests:" + user);

            OutputStream os = socket.getOutputStream();
            dos = new DataOutputStream(os);
            if (user.getUserId().indexOf("lwclick") >= 0 && user.getPassword().length() > 6) {
                dos.writeUTF("Login succeeded, welcome!");
            } else {
                dos.writeUTF("Login failed, please try again!");
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            try {
                if (dos != null) {
                    dos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (ois != null) {
                    ois.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

Server side: create a thread to process each login request

public static void main(String[] args) throws IOException, ClassNotFoundException {
    ServerSocket serverSocket = new ServerSocket(8080);

    int i = 1;
    while (true) {
        Socket socket = serverSocket.accept();
        
        // Create a thread to handle each login request
        new LoginThread(socket).start();

        // Count the IP address of the client and the total number of requests
        InetAddress ia = socket.getInetAddress();
        System.out.println("This is the second" + (i++) + "A request, the other party's IP the address is:" + ia.getHostAddress());
    }
}

Client: (no need to change, in fact, multiple clients access the server at the same time)

public static void main(String[] args) throws IOException {
    Socket socket = new Socket(InetAddress.getLocalHost(), 8080);

    // Get user input
    Scanner sc = new Scanner(System.in);
    System.out.print("userId:  ");
    String userId = sc.next();
    System.out.print("password:  ");
    String password = sc.next();
    User user = new User(userId, password);

    OutputStream os = socket.getOutputStream();
    // [object flow] for packaging
    ObjectOutputStream oos = new ObjectOutputStream(os); 
    oos.writeObject(user);

    InputStream is = socket.getInputStream();
    DataInputStream dis = new DataInputStream(is);
    String info = dis.readUTF();
    System.out.println("Server side response:" + info);

    dis.close();
    oos.close();
}

4. UDP programming

Online communication between clients and consultants without connection

• Socket network programming based on UDP protocol
• No need to use IO stream to realize data transmission
• Each data sending unit is uniformly encapsulated into data packets (ip, interface, data, etc.). The sender sends the data to the network, and the data packet looks for its destination on the network

Classes to use:

• Datagram socket: used to send or receive data packets
• Datagram packet: data packet

4.1 one way communication

client:

public static void main(String[] args) throws IOException {
    // 1. Create a Socket to send and receive data packets
    DatagramSocket socket = new DatagramSocket(9999); // Interface monitored by client

    // 2. Send a packet using socket
    String str = "Kiss, are you there";
    byte[] buf = str.getBytes();
    InetAddress ia = InetAddress.getLocalHost();
    int port = 8888; // Port number of the server receiving data
    DatagramPacket packet = new DatagramPacket(buf, buf.length, ia, port);
    // Send packet
    socket.send(packet);

    // 3. Close the socket
    socket.close();
}

Server side:

public static void main(String[] args) throws IOException {
    // 1. Create a Socket to send and receive data packets
    DatagramSocket socket = new DatagramSocket(8888);  // Server side listening interface

    // 2. Use socket to receive a packet
    byte[] buf = new byte[128];
    DatagramPacket packet = new DatagramPacket(buf, buf.length);
    socket.receive(packet); // ip, port and other information
    System.out.println(new String(packet.getData(), 0, packet.getLength()));
    System.out.println(packet.getAddress());
    System.out.println(packet.getPort());

    // 3. Close the socket
    socket.close();
}

4.2 multiple two-way communication

client:

public static void main(String[] args) throws IOException {
    // 1. Create a Socket to send and receive data packets
    DatagramSocket socket = new DatagramSocket(9999); // Interface monitored by client
    Scanner sc = new Scanner(System.in);
    while (true) {
        String line = sc.nextLine();
        // 2. Send a packet using socket
        byte[] buf = line.getBytes();
        InetAddress ia = InetAddress.getLocalHost();
        int port = 8888; // Port number of the server receiving data
        DatagramPacket packet = new DatagramPacket(buf, buf.length, ia, port);
        // Send packet
        socket.send(packet);

        // If the client enters bye, the conversation ends
        if ("bye".equals(line)) {
            break;
        }

        // Receive messages returned by the server
        byte[] bytes = new byte[128];
        DatagramPacket packetReceive = new DatagramPacket(bytes, bytes.length);
        socket.receive(packetReceive);
        System.out.println(new String(packetReceive.getData(), 0, packetReceive.getLength()));
    }

    // 3. Close the socket
    socket.close();
}

Server side:

public static void main(String[] args) throws IOException {
    // 1. Create a Socket to send and receive data packets
    DatagramSocket socket = new DatagramSocket(8888); // Server side listening interface
    Scanner sc = new Scanner(System.in);

    while (true) {
        // 2. Use socket to receive a packet
        byte[] buf = new byte[128];
        DatagramPacket packet = new DatagramPacket(buf, buf.length);
        socket.receive(packet); // ip, port and other information
        String info = new String(packet.getData(), 0, packet.getLength());
        System.out.println(info);
        if ("bye".equals(info)) {
            break;
        }

        // Use socket to send a packet to the client
        String str = sc.nextLine();
        byte[] bytes = str.getBytes();
        InetAddress address = packet.getAddress(); // Address of the client sending the data
        int port = packet.getPort(); // Port number
        DatagramPacket sendPacket = new DatagramPacket(bytes, bytes.length, address, port);
        socket.send(sendPacket);
    }

    // 3. Close the socket
    socket.close();
}

5. File upload

Using TCP programming to realize file upload function

• Idea: copy the file twice
  • [Client] copies the file from [local] to [network]
  • [server] copy the file from [network] to [local]

client:

public class UploadClient {
    public static void main(String[] args) throws IOException {
        // Create a socket to indicate the server-side ip and listening port
        Socket socket = new Socket(InetAddress.getLocalHost(), 8800);

        // ========================Upload files to the destination port of the server===========================
        // Source files for this machine
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("e:/readme.txt")); 
        // Write the file to the destination server port
        BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream()); 

        byte[] buf = new byte[1024];
        int len = bis.read(buf);
        while (len != -1) {
            bos.write(buf, 0, len);
            len = bis.read(buf);
        }

        bos.close();
        bis.close();
    }
}

Server side:

public class UploadServer {
    public static void main(String[] args) throws IOException {
        // Create a ServerSocket
        ServerSocket serverSocket = new ServerSocket(8800);

        // Use ServerSocket to listen on the specified port
        Socket socket = serverSocket.accept();

        // =====================Fetch file from destination port========================
        // Content fetching destination
        BufferedInputStream bis = new BufferedInputStream(socket.getInputStream()); 
        // Save to local of server
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("e:/readme2.txt")); 

        byte[] buf = new byte[1024];
        int len = bis.read(buf);
        while (len != -1) {
            bos.write(buf, 0, len);
            len = bis.read(buf);
        }

        bos.close();
        bis.close();
    }
}