网络编程套接字(2)

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
 
public class UdpEchoServer {
    /*
    最开始的一步:先创建DdtagramSocket对象
    接下来需要操作网卡,操作网卡是通过socket对象完成的
    socket对象是在内存中的,通过这个来影响网卡(类似遥控)
     */
    private DatagramSocket socket = null;
 
    /*
    一个主机上的一个端口号只能被一个进程绑定,反过来,一个进程可以绑定多个端口
    创建对象时,手动指定一个端口号(在运行服务器程序的时候,主动指定端口)
    程序一启动就需要关联上/绑定上一个操作系统中的端口号
    端口号也是一个整数,用来区分一个主机上进行网络通信的程序.
     */
 
    //参数时服务器要绑定的端口
    public UdpEchoServer(int port) throws SocketException {
        /*
        SocketException是网络编程中的常见异常,通常表示
        socket创建失败,比如端口号被别的进程占用,就会失败
         */
        socket = new DatagramSocket(port);
    }
 
    //使用这个方法启动服务器
    public void start() throws IOException {
        System.out.println("服务器启动");
        while(true) {
            //反复的,长期的执行针对客户端请求处理的逻辑.(不停的收到请求,返回响应)
            //一个服务器,运行的过程中,要做的事情,主要是三个核心环节.
            //1.读取请求,并解析.  (一个服务器单位时间处理的请求返回响应越多,服务器越厉害)
            DatagramPacket requestPacket = new DatagramPacket(new byte[4096], 4096);
            /*
            receive就从网卡中读出了一个数据报,就被放入了requestPacket对象中.
            其中UDP数据报的载荷部分就被放到requestPacket内置的字节数组中了.
            除了UDP报头,还有其它信息,比如收到的数据:源IP
             */
            //如果执行到这个地方,没有客户端请求的话,就会阻塞.
            socket.receive(requestPacket);
            //转成字符串,方便逻辑处理(前提:后续客户端发的就是一个文本字符串)
            String request = new String(requestPacket.getData(), 0, requestPacket.getLength()); //有效长度
            //2.根据请求,计算出响应(对于回显服务器,这一步什么都不用做)
            String response = process(request);
            //3.把响应写回给客户端
            //此时需要告知网卡,要发的内容是啥,要发给谁
            //requestPacket是客户端发来的数据报.
            //通过getSocketAddress()得到InetAddress对象,这个对象就包含了和服务器的通信对端(对应客户端IP)
            //此时就起到了把消息返回给客户端的效果(还可以看到UDP是无连接通信,socket不包含对端IP,端口)
            DatagramPacket responsePacket = new DatagramPacket(response.getBytes(),
                    response.getBytes().length, requestPacket.getSocketAddress());
            socket.send(responsePacket);
            //记录日志,方便观察程序执行效果
            System.out.printf("[%s : %d] req: %s, resq: %s\n", requestPacket.getAddress()
            requestPacket.getPort(), request, response);
        }
    }
    /*
    上述代码中,可以看到UDP是无连接的通信~UDPsocket自身不保存对端的IP和端口
    而是在每个数据报中有一个.另外代码中也"建立连接","接受连接"的擦做
    面向数据报,send和receive都是以DatagramPacket为主
     */
    
    //根据请求计算响应
    public String process(String request) {
        return request;
    }
 
    public static void main(String[] args) throws IOException {
        //指定任何想要的端口,但要确保这个端口在机器上未被其它进程占用
        UdpEchoServer server = new UdpEchoServer(9090);
        server.start();
    }
}

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.util.Scanner;
 
public class UdpEchoClient {
    private DatagramSocket socket = null;
    private String serverIp;
    private int serverPort;
 
    //服务器的ip和服务器的端口 (因为发起请求的前提就是知道服务器在哪).
    public UdpEchoClient(String ip, int port) throws SocketException {
        serverIp = ip;
        serverPort = port;
        //这个new操作,就不再指定端口了.让系统分配一个空闲端口
        socket = new DatagramSocket();
    }
 
    /*
    在服务器中,在代码中需要手动指定端口号,才能保证端口始终固定
    如果不手动指定,依赖系统自动分配导致服务器重启之后,端口号就
    变了,客户端可能找不到服务器在哪了
    服务器这个机器,是在程序员手里的,是可控的.
    程序员能知道服务器有哪些端口被使用,客户端是在普通用户的机器上
     */
 
    //让这个客户端反复的从控制台读取用户输入的内容,把这个内容构成UDP请求,发送给服务器
    //最终显示在客户端的屏幕上
    public void start() throws IOException {
        Scanner sc = new Scanner(System.in);
        System.out.println("客户端启动!");
        while(true) {
            //1.从控制台读取用户输入内容
            System.out.println("->"); //命令提示符,提示用户要输入的字符串
            String request = sc.next(); //从控制台读取,最好使用next而不是nextLine
            //2.构造请求对象,并发给服务器
            DatagramPacket requestPacket = new DatagramPacket(request.getBytes(),
                    request.getBytes().length, InetAddress.getByName(serverIp), serverPort);
            socket.send(requestPacket);
            //3.读取服务器的响应,解析出响应内容.
            DatagramPacket responsePacket = new DatagramPacket(new byte[4096], 4096);
            socket.receive(responsePacket);
            String response = new String(responsePacket.getData(), 0, responsePacket.getLength());
            //4.显示到屏幕上
            System.out.println(response);
        }
    }
 
    public static void main(String[] args) throws IOException {
        UdpEchoClient client = new UdpEchoClient("127.0.0.1", 9090);
        client.start();
    }
}

import java.io.IOException;
import java.net.SocketException;
import java.util.HashMap;
import java.util.Map;
 
public class UdpDictServer extends UdpEchoServer{
    private Map<String, String> dict = new HashMap<>();
 
    public UdpDictServer(int port) throws SocketException {
        super(port);
 
        dict.put("cat", "小猫");
        dict.put("dog", "小狗");
        dict.put("fuck", "我爱你");
        //可以在这里添加千千万万个单词.使每一个单词都有对应的翻译
    }
 
    @Override
    public String process(String request) {
        //把请求对应单词的翻译,给返回回去
        return dict.getOrDefault(request, "该单词没有查询到!");
    }
 
    public static void main(String[] args) throws IOException {
        UdpDictServer server = new UdpDictServer(9090);
        server.start(); //在此处会除法多态
    }
}

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;
 
public class TcpEchoServer {
     private ServerSocket serverSocket = null;
 
    //这个操作就会绑定端口号
    public TcpEchoServer(int port) throws IOException {
        serverSocket = new ServerSocket(port);
    }
 
    //启动服务器
    public void start() throws IOException {
        System.out.println("服务器启动!");
        while(true) {
            //这是个建立链接的过程,就相当于接地阿努好的时候这边拨完号打过去,另一边在响铃
            //通过accept()操作接听电话,然后进行通信
            //clientSocket负责后续通信交互
            Socket clientSocket = serverSocket.accept();
            /*accept可能会产生阻塞.没有客户端,就会阻塞.有客户端的时候再处理
            有一个客户端来了, accept一次就能返回一次.
            有多个客户端连过来了,accept就会执行多次
            */
            processConnection(clientSocket);
        }
    }
 
    //通过这个方法来处理一个连接的逻辑
    private void processConnection(Socket clientSocket) {
        System.out.printf("[%s:%d] 客户端上线!\n", clientSocket.getInetAddress(), clientSocket.getPort());
        //接下来就可以读取请求,根据请求计算响应,返回响应这三步走了.
        //Socket对象包含两个字节流对象,可以把这两字节流对象获取到,完成后续的读写
        /*
        inputStream是从网卡中读,OutputStream是向网卡中写
        TCP是面向字节流的.和文件操作以一样的类和方法来完成tcp socket的读写
         */
        try(InputStream inputStream = clientSocket.getInputStream();
            OutputStream outputStream = clientSocket.getOutputStream()) {
            //一次连接中,可能会涉及到多次请求/响应
            while(true) {
                //1.读取请求并解析..为了读取方便,直接使用Scanner
                Scanner sc = new Scanner(inputStream);
                //客户端退出的时候就会触发Tcp的"断开连接"流程.
                //服务器这边的代码也会感知到,对应Scanner就在hasNext()处返回false.
                if(!sc.hasNext()) {
                    //读取完毕,客户端下线.
                    System.out.printf("[%s:%d] 客户端下线!\n", clientSocket.getInetAddress(), clientSocket.getPort());
                    break;
                }
                //这个代码暗含一个约定,客户端发过来的请求,得是文本数据. next读的时候要督导空白符才会结束.
                // 因此就要客户端发来的请求必须带有空白符结尾.比如\n或者空格.
                String request = sc.next();
                //2.根据请求计算相应
                String response = process(request);
                //3.把响应写回客户端
                // 通过这种方式可以写回,但是这种方式不方便给返回的响应中添加\n
                //outputStream.write(response.getBytes(), 0, response.getBytes().length);
                // 也可以给outputStream套上一层,完成更方便的写入.
                PrintWriter printWriter = new PrintWriter(outputStream);
                printWriter.println(response);
                //这里还需要加一个"刷新缓冲区"的操作
                printWriter.flush();
                
                //日志,打印当前的请求详细.
                System.out.printf("[%s:%d] req: %s, resq: %s\n", clientSocket.getInetAddress(),
                        clientSocket.getPort(), request, response);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //在finally中加上close操作,确保当前socket被正确关闭
            /*
            tcp的clientSocket是每个客户端都有一个.随着客户端
            越来越多.这里消耗的socket也会越来越多(如果不释放,就可能把文件操作符表占满)
             */
            try {
                clientSocket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
 
    private String process(String request) {
        return request;
    }
 
    public static void main(String[] args) throws IOException {
        TcpEchoServer server = new TcpEchoServer(9090);
        server.start();
    }
}

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Scanner;
 
public class TcpEchoClient {
    private Socket socket = null;
 
    //要和服务器通信, 就需要先知道,服务器所在的位置
    public TcpEchoClient(String serverIp, int serverPort) throws IOException {
        //这个new操作完成之后,就完成了tcp连接的建立
        socket = new Socket(serverIp, serverPort);
    }
 
    public void start() {
        System.out.println("客户端启动!");
        try (InputStream inputStream = socket.getInputStream();
             OutputStream outputStream = socket.getOutputStream()) {
            Scanner scannerConsole = new Scanner(System.in);
            Scanner scannerNetwork = new Scanner(inputStream);
            PrintWriter printWriter = new PrintWriter(outputStream);
            while(true) {
                //1.从控制台中读取字符串
                System.out.println("->");
                if(!scannerConsole.hasNext()) {
                    break;
                }
                String request = scannerConsole.next();
                //2.把请求发给服务器
                //使用println带上换行, 后续服务器读取请求,就使用scanner.next()读取
                printWriter.println(request);
                printWriter.flush();
                // 不要忘记flush, 确保数据是真的发出去了
                //3.从服务器中读取响应
                String response = scannerNetwork.next();
                //4.把响应打印出来
                System.out.println(response);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
 
    public static void main(String[] args) throws IOException {
        TcpEchoClient client = new TcpEchoClient("127.0.0.1", 9090);
        client.start();
    }
}

//启动服务器
public void start() throws IOException {
    System.out.println("服务器启动!");
    while(true) {
        Socket clientSocket = serverSocket.accpet();
        //每次来一个客户端,就创建一个新线程.每次走一个,就销毁一个线程
        Thread t = new Thread(() -> {
            //此时,就把processConnection交给新线程负责了.
            //主循环就会快速执行完一次后,回到accept这里阻塞等待新的客户端来
            processConnection(clientSocket);
        });
        t.start();
    }
}

//启动服务器
public void start() throws IOException {
    System.out.println("服务器启动!");
    ExecutorService service = Executors.newCachedThreadPool();
    while(true) {
        Socket clientSocket = serverSocket.accept();
        //使用线程池来解决上述问题
        service.submit(new Runnable() {
            @Override
            public void run() {
                processConnection(clientSocket);
            }
        });
    }
}