【网络编程】狂神说笔记

TCP模型

初识TCP

服务端代码

import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

class ClientThread extends Thread{
    Socket socket;

    public ClientThread(Socket socket) {
        this.socket = socket;
    }
    @Override
    public void run() {
        InputStream in = null;
        try {
            in = socket.getInputStream();
            BufferedReader reader = new BufferedReader(new InputStreamReader(in));
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println("read:" +line);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (in != null) {
                    in.close();
                }
                socket.close();
                System.out.println("close socket: " + socket);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        
    }
    
}
public class TCPServer {
    ServerSocket server;
    int serverPort = 8848;

    public TCPServer() {
        try {
            server = new ServerSocket(serverPort);
            System.out.println("create a server socket and the port is " + serverPort);

        } catch (IOException e) {

            e.printStackTrace();
        }
    }

    private void listen() {
        while (true) {
            try {
                Socket socket = server.accept();
                System.out.println("socket:" + socket);
                new ClientThread(socket).start();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        new TCPServer().listen();
    }
}

客户端代码

import java.net.InetAddress;
import java.net.Socket;

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;


import java.io.OutputStream;
import java.io.PrintWriter;

public class TCPClient extends JFrame implements ActionListener {
    Socket client = null;
    String serverAddr = "localhost";
    int serverPort = 8848;
    PrintWriter out;
    JTextField tf;

    public TCPClient() {
        try {
            client = new Socket(serverAddr, serverPort);
            System.out.println("client:" + client);
            out = new PrintWriter(client.getOutputStream());
            out.println("hello");
            out.flush();
        } catch (Exception e) {
            e.printStackTrace();
        }
        Container cp = getContentPane();
        cp.setLayout(new FlowLayout(FlowLayout.LEFT, 15, 15));
        cp.add(new JLabel("enter your message or \"quit\""));
        tf = new JTextField(40);
        tf.addActionListener(this);
        cp.add(tf);
        setDefaultCloseOperation(EXIT_ON_CLOSE);
        pack();
        setTitle("TCP client");
        setVisible(true);
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        String message = tf.getText();
        if (message.equals("quit")) {
            try {
                if (out != null) {
                    out.close();
                }
                if (client != null) {
                    client.close();
                }
                System.exit(0);
            } catch (Exception exception) {
                exception.printStackTrace();
            }
        } else {
            out.println(message);
            out.flush();
            tf.setText("");
        }
    }
    public static void main(String[] args) {
        new TCPClient();
    }
}

TCP握手

服务器端

package note.JAVA.NET.UploadFile;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {
    public static void main(String[] args) throws IOException{
        ServerSocket server = new ServerSocket(8848);
        Socket socket = server.accept(); //阻塞式监听
        OutputStream out = socket.getOutputStream();

        FileInputStream fileInputStream = new FileInputStream(new File("note/res/receive.txt"));
        int len;
        byte[] buffer = new byte[1024];
        while ((len = fileInputStream.read(buffer)) != -1) {
            out.write(buffer, 0, len);
        }
        server.close();
        fileInputStream.close();
        out.close();
        socket.close();
    }
}

客户端

package note.JAVA.NET.TCPShakeHand;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;

public class Client {
    public static void main(String[] args) throws UnknownHostException, IOException{
        Socket socket = new Socket(InetAddress.getByName("127.0.0.1"), 8848);

        OutputStream socketOut = socket.getOutputStream();
        InputStream socketIn = socket.getInputStream();
        
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        byte[] buffer = new byte[1024];
        int len;
        while ((len = socketIn.read(buffer)) != -1) {
            byteArrayOutputStream.write(buffer,0,len);
            System.out.println("receive: " + byteArrayOutputStream.toString());
        }

        socket.close();
        socketIn.close();
        socketOut.close();


    }
}

Tomcat

初识Tomcat

UDP

receiver

package note.JAVA.NET.UDP;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;

public class Server {
    public static void main(String[] args) throws IOException {
        DatagramSocket socket = new DatagramSocket(8848);
        byte[] buffer = new byte[1024];
        DatagramPacket packet = new DatagramPacket(buffer, 0, buffer.length);

        socket.receive(packet);
        System.out.println("receive:" + new String(packet.getData(), 0, packet.getData().length));
        socket.close();
    }
}

sender

package note.JAVA.NET.UDP;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

public class Client {
    public static void main(String[] args) throws IOException {
        DatagramSocket socket = new DatagramSocket();

        String message = "hello server";
        InetAddress localhost = InetAddress.getByName("localhost");
        int port = 8848;

        DatagramPacket packet = new DatagramPacket(message.getBytes(), 0, message.getBytes().length,localhost,port);

        socket.send(packet);

        socket.close();
    }
}

聊天实现

循环发送接收消息

发送方

package note.JAVA.NET.UDPChat;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;


public class UDPSender {

    public static void main(String[] args) throws IOException {
        DatagramSocket socket = new DatagramSocket(6666);
        while (true) {
            BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
            String data = reader.readLine();
            byte[] buffer = data.getBytes();
            DatagramPacket packet = new DatagramPacket(buffer, 0, buffer.length,
                    new InetSocketAddress("localhost", 8848));
            socket.send(packet);
            if (data.equals("quit")) {
                System.out.println("sender closed");
                socket.close();
                break;
            } else {
                System.out.println("send:" + data);
            }
        }
        
    }

}

接收方

package note.JAVA.NET.UDPChat;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;

public class UDPReceiver {
    public static void main(String[] args) throws IOException {
        DatagramSocket socket = new DatagramSocket(8848);

        while (true) {
            byte[] buffer = new byte[1024];
            DatagramPacket packet = new DatagramPacket(buffer, 0, buffer.length);

            socket.receive(packet);

            String data = new String(packet.getData(), 0, packet.getData().length);

            if (data.equals("quit")) {
                System.out.println("receiver closed");
                socket.close();
                break;
            } else {
                System.out.println("receive:" + data);
            }

        }
    }
}

双人聊天

线程1

package NET.UDPChat;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;


public class SenderThread implements Runnable{
    DatagramSocket socket;
    BufferedReader reader;

    private String receiverIP = "localhost";
    private int receiverPort = 8848;

    private String senderIP = "localhost";
    private int senderPort = 8080;

    SenderThread(String receiverIP, int receiverPort, String senderIP, int senderPort){
        try {
            this.receiverIP = receiverIP;
            this.receiverPort = receiverPort;
            this.senderIP = senderIP;
            this.senderPort = senderPort;
            socket = new DatagramSocket(senderPort);
            reader = new BufferedReader(new InputStreamReader(System.in));
        } catch (Exception exception) {
            exception.printStackTrace();
        }

    }

    @Override
    public void run() {
        while (true) {
            try {
                String data = reader.readLine();
                byte[] buffer = data.getBytes();
                DatagramPacket packet = new DatagramPacket(buffer, 0, buffer.length,
                        new InetSocketAddress(receiverIP, receiverPort));
                socket.send(packet);
                if (data.equals("quit")) {
                    break;
                } else {
                    System.out.println(socket.getLocalPort() + " send:" + data);
                }
            } catch (Exception exception) {
                exception.printStackTrace();
            }
        }
        try {
            System.out.println("sender closed");
            socket.close();
        } catch (Exception exception) {
            exception.printStackTrace();
        }
    }
    
}

线程2

package NET.UDPChat;

import java.io.BufferedReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;



public class ReceiverThread implements Runnable{
    DatagramSocket socket;
    BufferedReader reader;

    private String receiverIP;
    private int receiverPort;

    private String senderIP;
    private int senderPort;

    ReceiverThread(String receiverIP, int receiverPort) {
        try {
            this.receiverIP = receiverIP;
            this.receiverPort = receiverPort;
            socket = new DatagramSocket(receiverPort);
        } catch (Exception exception) {
            exception.printStackTrace();
        }

    }

    @Override
    public void run() {
        while (true) {
            try {
                byte[] buffer = new byte[1024];
                DatagramPacket packet = new DatagramPacket(buffer, 0, buffer.length);
                socket.receive(packet);
                String data = new String(packet.getData(), 0, packet.getData().length);
                if (data.equals("quit")) {
                    break;
                } else {
                    System.out.println(socket.getLocalPort() + " receive:" + data);
                }
            } catch (Exception exception) {
                exception.printStackTrace();
            }
        }
        try {
            System.out.println("receiver closed");
            socket.close();
        } catch (Exception exception) {
            exception.printStackTrace();
        }
    }

}

主线程

package NET.UDPChat;


public class Chat1 {

    public static void main(String[] args) {
        new Thread(new SenderThread("localhost", 4444, "localhost", 2222)).start();
        new Thread(new ReceiverThread("localhost", 1111)).start();
    }

}



package NET.UDPChat;

public class Chat2 {
    public static void main(String[] args) {
        new Thread(new SenderThread("localhost", 1111, "localhost", 3333)).start();
        new Thread(new ReceiverThread("localhost", 4444)).start();
    }
}