【JavaEE 初阶】⽹络编程套接字

private DatagramSocket socket=null;
public UdpEchoServer(int port)throws SocketException{
    //指定固定端口号，使用服务器
    socket = new DatagramSocket(port);
}

socket 对象代表网卡文件.

读这个文件等于从网卡收数据, 写这个文件等于让网卡发数据 

//1.读取请求并解析

//DatagramPacket表示一个udp数据报，此处传入的字节数组，相当于保存udp的载荷部分
     DatagramPacket requestPacket=new DatagramPacket(new byte[4096],4096);
//输出型参数，事前调用空的对象，receive把它从网卡读入进行处理,填充参数
     socket.receive(requestPacket);
//把读取的二进制数据转换成字符串
     String request=new String(requestPacket.getData(),0, requestPacket.getLength());

a)构造 DatagramPacket 对象.
DatagramPacket 就代表 UDP 数据包.
报头 + 载荷(new 字节数组保存).

b) 调用 receive .
理解输出型参数

c)把 udp 数据包载荷取出来, 构造成一个 String
1)通过requestPacket,getData()拿到 DatagramPacket 中的字节数组 
2)拿到有效数据的长度requestPacket .getLength()
3)根据字节数组,构造出一个 new String

//2.根据请求，计算响应（key）echo服务器，不需要计算响应，直接返回

    String response=process(request);

//后续如果需要进行服务器数据处理，可以采用单独改变此方法
    private String process(String request) {
        return request;
    }

//3.把相应返回给客户端

//不能使用response.length(),这个表示string中字符的个数
//response.getBytes().length,这个表示string中字节的个数
//requestPacket.getSocketAddress()获取报头部分的返回ip和端口号
     DatagramPacket responsePacket=new DatagramPacket(response.getBytes(),response.getBytes().length
,requestPacket.getSocketAddress());
//此处不能直接发送，udp协议自身没有保存对方的信息（不知道发给谁)
//需要指定目的ip和目的端口，收到请求的源ip和源端口即所需
      socket.send(responsePacket);

1)response.getBytes()
拿到字符串中的字节数组
2)response.getBytes().length
拿到字节数组的长度
而不是使用字符串长度(单位 字符)
3)requestPacket.getSocketAddress()
这个方法返回的对象中同时包含 IP 和端口
4) new DatagramPacket 是要干啥??
构造响应数据报,上面的是“请求数据报
5)  socket.send(responsePacket);
把构造好的数据报发送出去前提是报头中包含了目的ip和目的端口

System.out.printf("[%s:%d]req:%s,resp:%s",requestPacket.getAddress().toString(),
requestPacket.getPort(),request,response);

Q:socket不用close吗?
A:文件要关闭,考虑清楚这个文件对象的 生命周期是怎样的 
此处的 socket 对象, 伴随整个 udp 服务器, 自始至终 
如果服务器关闭 (进程结束)，进程结束时就会自动释放 PCB 的文件描述符表中的所有资源,也不需要手动调用 close 了.

Q:此时没有发送请求or没有客户端，那么服务器程序此时应该怎么样呢？

A:应该在receive处阻塞等待

 private DatagramSocket socket=null;
    //和服务端不一样，还需要客户端地址,udp本身不保存对端信息，咱们自己保存一下
private String serverIp;
private int serverPort;

 public UdpEchoClient(String serverIp,int serverPort)throws SocketException  {
        this.serverIp=serverIp;
        this.serverPort=serverPort;
        socket=new DatagramSocket();//一定不能写端口号，如果固定端口号，一旦该端口被用了，那么当被其他程序占用时，这个程序就会运行失效
    }

主循环

//1.从控制台读取用户输入的内容

 System.out.println("请输入要发送的内容");
if(!scanner.hasNext()){
     break;
 }
String request = scanner.next();

//2.把请求发送给服务端，需要构造请求数据包

 //构造时，不光要有载荷，也要有对应的端口和ip
 DatagramPacket requestPacket = new DatagramPacket(request.getBytes(), 
request.getBytes().length,InetAddress.getByName(serverIp), serverPort);

//3.发送数据报

socket.send(requestPacket);

//4.接受服务器的回应

DatagramPacket responsePacket = new DatagramPacket(new byte[4096], 4096);
socket.receive(responsePacket);
//将从服务器读取的数据进行解析，打印出来
String response = new String(responsePacket.getData(), 0, responsePacket.getLength());
System.out.println(response);

整体程序

import java.io.IOException;
import java.net.*;
import java.util.Scanner;

public class UdpEchoClient {
    private DatagramSocket socket=null;
    //和服务端不一样，还需要客户端地址,udp本身不保存对端信息，咱们自己保存一下
    private String serverIp;
    private int serverPort;
    public UdpEchoClient(String serverIp,int serverPort)throws SocketException  {
        this.serverIp=serverIp;
        this.serverPort=serverPort;
        socket=new DatagramSocket();//一定不能写端口号，如果固定端口号，一旦该端口被用了，那么当被其他程序占用时，这个程序就会运行失效
    }
    public void start() throws IOException {
        Scanner scanner = new Scanner(System.in);
        while(true) {
            //1.从控制台读取用户输入的内容
            System.out.println("请输入要发送的内容");
            if(!scanner.hasNext()){
                break;
            }
            String request = scanner.next();
            //2.把请求发送给服务端，需要构造请求数据包
            //构造时，不光要有载荷，也要有对应的端口和ip
            DatagramPacket requestPacket = new DatagramPacket(request.getBytes(), request.getBytes().length,
                    InetAddress.getByName(serverIp), serverPort);
            //3.发送数据报
            socket.send(requestPacket);
            //4.接受服务器的回应
            DatagramPacket responsePacket = new DatagramPacket(new byte[4096], 4096);
            socket.receive(responsePacket);
            //将从服务器读取的数据进行解析，打印出来
            String response = new String(responsePacket.getData(), 0, responsePacket.getLength());
            System.out.println(response);
        }
    }

    public static void main(String[] args) throws IOException {
        UdpEchoClient client=new UdpEchoClient("127.0.0.1",9090);
                                                      // 环回ip，表示当前主机，无论真实ip是什么，都可以用它替代，相当于this
        client.start();
    }

}

import java.io.IOException;
import java.net.SocketException;
import java.util.HashMap;

public class UdpDictServer extends UdpEchoServer {

    private HashMap<String,String>dict=new HashMap<>();
    public UdpDictServer(int port) throws SocketException {
        super(port);

        //初始化词典
        dict.put("小狗","dog");
        dict.put("小猫","cat");
        dict.put("小鸭子","duck");
        dict.put("小兔子","rabbit");
    }
    @Override
    public String process(String request){
        return dict.getOrDefault(request,"未找到该词条");
    }

    public static void main(String[] args) throws IOException {
        UdpDictServer dictServer=new UdpDictServer(9090);
        dictServer.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;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

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("启动服务器");
        //这种情况一般不会是用fixedThreadPool，意味着同时处理的客户端数目固定了

        ExecutorService  executorService= Executors.newCachedThreadPool();

        while (true){
            //tcp要先处理客户端发来的连接
            //通过读写clientsocket和客户端进行通信
            //如果客户端没有发送消息，accept会阻塞
            //主线程负责accept，每次accept一个客户端，就创建一个线程，由新线程负责处理客户的请求
           Socket clientSocket= serversocket.accept();
           //使用多线程的方式来调整
//           Thread thread=new Thread(()->{
//               try {
//                   processConnect(clientSocket);
//               } catch (IOException e) {
//                   throw new RuntimeException(e);
//               }
//           });
//           thread.start();
            //使用线程池来调整
            executorService.submit(()->{
                try {
                    processConnect(clientSocket);
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            });

        }
    }
//处理一个客户端的连接，可能会涉及多个客户端的连接和响应
    private void processConnect(Socket clientSocket) throws IOException {
        System.out.printf("[%s,%d]客户端上线!\n",clientSocket.getInetAddress(),clientSocket.getPort());
        try(InputStream inputStream=clientSocket.getInputStream();
            OutputStream outputStream=clientSocket.getOutputStream()){
            Scanner scanner=new Scanner(inputStream);
            PrintWriter printWriter=new PrintWriter(outputStream);
            while(true){
                //1.读取请求并解析，可以借助read，也可以借助scanner来辅助完成
                if(!scanner.hasNext()){
                    System.out.printf("[%s,%d]客户端下线\n",clientSocket.getInetAddress(),clientSocket.getPort());
                    break;
                }
                String request=scanner.next();
                //2.根据请求计算响应
                String response=process(request);
                //3.返回响应
                printWriter.println(response);
                printWriter.flush();
                //等价于 outputStream.write(response.getBytes());

                //4.写日志
                System.out.printf("[%s,%d]req:%s.resp:%s\n",clientSocket.getInetAddress(),clientSocket.getPort(),request,response);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally {
            clientSocket.close();
        }

    }

    private String process(String request) {
        return request;
    }

    public static void main(String[] args) throws IOException {
        TcpEchoServer tcpEchoServer=new TcpEchoServer(9090);
        tcpEchoServer.start();
    }
}

import javax.imageio.IIOException;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.SocketException;
import java.util.Scanner;

public class TcpEchoClient {
    private Socket clientsocket=null;
    public TcpEchoClient(String SeverIp, int ServerPort)throws IOException {
        //直接把字符串的ip设置进来
        clientsocket=new Socket(SeverIp,ServerPort);
    }

    public void start(){
        Scanner scanner=new Scanner(System.in);
        try(InputStream inputStream=clientsocket.getInputStream();
            OutputStream outputStream=clientsocket.getOutputStream()) {
            //为了方便操作，套壳操作
            Scanner scannerNet=new Scanner(inputStream);
            PrintWriter printWriter=new PrintWriter(outputStream);
            while(true){
                //1.从控制台读取用户输入
                String request=scanner.next();
                //2.直接送给服务器
                printWriter.println(request);//这一步只是写到缓冲区里面，还要刷新一下才能发送
                printWriter.flush();
                //3.读取响应
                String response=scannerNet.next();
                //4.打印至控制台
                System.out.println(response);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }

    }

    public static void main(String[] args) throws IOException {
        TcpEchoClient tcpEchoClient=new TcpEchoClient("127.0.0.1",9090);
        tcpEchoClient.start();
    }

}

//使用多线程的方式来调整
Thread thread=new Thread(()->{
 try {
        processConnect(clientSocket);
     } catch (IOException e) {
         throw new RuntimeException(e);
      }
});
thread.start();

  //使用线程池来调整
executorService.submit(()->{
   try {
        processConnect(clientSocket);
} catch (IOException e) {
       throw new RuntimeException(e);
}
    });