DatagramSocket()
DatagramSocket(int port)

1
2
3
4public DatagramPacket(byte[] buf, int length,InetAddress address, int port)
public DatagramPacket(byte[] buf, int length)    
    ....

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58package network;

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

public class UdpEchoServer {
    //创建一个DatagramScocket对象
    //这是后续操作网卡的基础
    private DatagramSocket socket = null;

    public UdpEchoServer(int port) throws SocketException {
        socket = new DatagramSocket(port);
        /*
        我们在服务器和客户端中均需要创建一个Socket对象
        但是服务器的socket一般需要显示的指定一个端口号
        而客户端的socket一般不能显示指定（不显示指定时候系统会自动分配一个随机的端口）
         */
    }

    //通过这个方法开启动服务器
    public void start() throws IOException {
        System.out.println("服务器启动");
        while(true){
            //我们在使用socket.receive来接受数据时，需要先创建一个数据报（DatagramPacket)用来接受从网卡读取到的数据，
            DatagramPacket requestPacket = new DatagramPacket(new byte[4096],4096);
            //1.读取请求并解析
            socket.receive(requestPacket);
            //当前完成recive之后，数据以二进制的形式存储到DatagramPacket中
            //要想能够把数据显示出来，还需要把二进制转成字符串
            String request = new String(requestPacket.getData(),0, requestPacket.getLength());
            //2.由于我们此处是回显服务器，所以请求=响应。
            String reponse = process(request);
            //3.把响应写回客户端
            //  搞一个响应对象，DatagramPacket
            //  往DatagramPacket中填入刚才的数据，在通过sent返回
            //传入数据报,数据报长度，和请求中的地址
            DatagramPacket reponsePacket = new DatagramPacket(reponse.getBytes(),reponse.getBytes().length,requestPacket.getSocketAddress());
            //注意这个长度不可以更改成reponse.length，因为如果这个字符串的内容都是英文字符，此时字节和字符个数是一样的，但是如果包含中文就不一样了。
            socket.send(reponsePacket);
            //4.打印日志
            System.out.printf("[%s:%d] req=%s res=%s\n",reponsePacket.getAddress().toString(),reponsePacket.getPort(),request,reponse);

        }
    }

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

    public static void main(String[] args) throws IOException {

        UdpEchoServer udpEchoServer = new UdpEchoServer(9090);
        udpEchoServer.start();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44package network;

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

public class UdpEchoClient {
    private DatagramSocket socket = null;
    private String severIp = "";
    private int severPort = 0;
    public UdpEchoClient(String severIp,int severPort) throws SocketException {
        //创建这个对象不能手动指定端口
        socket = new DatagramSocket();
        //由于UDP自身不回持有对端的信息，就需要在应用程序中把对端的情况记录下来。
        this.severIp = severIp;
        this.severPort = severPort;
    }

    public void start() throws IOException {
        System.out.println("客户端启动");
        Scanner sc = new Scanner(System.in);
        while(true){
            //1.从控制台读取一个数据,作为请求
            System.out.print("->");
            String request = sc.next();
            //2.把请求内容构造成一个DatagramPacket对象，发送给服务器
            DatagramPacket requestPacket = new DatagramPacket(request.getBytes(),request.getBytes().length, InetAddress.getByName((severIp)), severPort);
            socket.send(requestPacket);
            //3.尝试读取服务器返回的响应
            DatagramPacket responsePacket = new DatagramPacket(new byte[4096],4096);
            socket.receive(responsePacket);
            //4.把响应转换成字符串，并打印输出
            String response = new String(responsePacket.getData(),0,responsePacket.getLength());
            System.out.println(response);
        }
    }

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28package network;

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("dog", "小狗");
		dict.put("cat", "小猫");
	}

	@Override
	public String process(String request) {
		return dict.get(request);
	}

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90package network;

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 severSocket = null;

	public TcpEchoServer(int port) throws IOException {
		severSocket = new ServerSocket(port);
	}
	public void start() throws IOException {
		System.out.println("服务器启动");
		ExecutorService service = Executors.newCachedThreadPool();
		while(true){
			//通过accetp方法，把内核中已经建立 好的链接拿到应用中
			//建立连接的细节流程是内核自动完成的，应用程序只需要捡现成的即可
			Socket clientSocket = severSocket.accept();
			service.submit(new Runnable(){
				@Override
				public void run(){
					processConnection(clientSocket);
				}
			});
		}
	}

	//通过这个方法来处理当前的连接
	public void processConnection(Socket clientSocket){
		//进入方法，打印出一个日志，表示当前有客户端连接上了
		System.out.printf("[%s:%d] 客户端上线!\n", clientSocket.getInetAddress(), clientSocket.getPort());
		try(InputStream inputStream = clientSocket.getInputStream();
			OutputStream outputStream = clientSocket.getOutputStream()) {
			// 使用 try ( ) 方式, 避免后续用完了流对象, 忘记关闭.
			// 由于客户端发来的数据, 可能是 "多条数据", 针对多条数据, 就循环的处理.
			while(true){
				Scanner sc = new Scanner(inputStream);
				if(!sc.hasNext()){
					// 连接断开了. 此时循环就应该结束
					System.out.printf("[%s:%d] 客户端下线!\n", clientSocket.getInetAddress(), clientSocket.getPort());
					break;
				}
				// 1. 读取请求并解析. 此处就以 next 来作为读取请求的方式. next 的规则是, 读到 "空白符" 就返回.
				String request = sc.next();
				// 2. 根据请求, 计算响应.
				String response = processs(request);
				// 3. 把响应写回到客户端.
				//    可以把 String 转成字节数组, 写入到 OutputStream
				//    也可以使用 PrintWriter 把 OutputStream 包裹一下, 来写入字符串.
				PrintWriter printWriter = new PrintWriter(outputStream);
				//    此处的 println 不是打印到控制台了, 而是写入到 outputStream 对应的流对象中, 也就是写入到 clientSocket 里面.
				//    自然这个数据也就通过网络发送出去了. (发给当前这个连接的另外一端)
				//    此处使用 println 带有 \n 也是为了后续 客户端这边 可以使用 scanner.next 来读取数据.
				printWriter.println(response);
				//    此处还要记得有个操作, 刷新缓冲区. 如果没有刷新操作, 可能数据仍然是在内存中, 没有被写入网卡.
				printWriter.flush();
				// 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{
			try {
				// 在这个地方, 进行 clientSocket 的关闭.
				// processConnection 就是在处理一个连接. 这个方法执行完毕, 这个连接也就处理完了.
				clientSocket.close();
			} catch (IOException e) {
				throw new RuntimeException(e);
			}
		}

	}

	public String processs(String request){
		return request;
	}

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50package network;

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 {
		// 需要在创建 Socket 的同时, 和服务器 "建立连接", 此时就得告诉 Socket 服务器在哪里~~
		// 具体建立连接的细节, 不需要咱们代码手动干预. 是内核自动负责的.
		// 当我们 new 这个对象的时候, 操作系统内核, 就开始进行 三次握手 具体细节, 完成建立连接的过程了.
		socket = new Socket(serverIp,ServerPort);
	}
	public void start(){
		Scanner sc = new Scanner(System.in);
		try(InputStream inputStream = socket.getInputStream();
			OutputStream outputStream = socket.getOutputStream()) {
			PrintWriter writer = new PrintWriter(outputStream);
			Scanner scannerNetWork = new Scanner(inputStream);
			while(true){
				//1.从控制台读取用户输入的内容
				System.out.println("->");
				String request = sc.next();
				// 2. 把字符串作为请求, 发送给服务器
				//    这里使用 println, 是为了让请求后面带上换行.
				//    也就是和服务器读取请求, scanner.next 呼应
				writer.println(request);
				writer.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 tcpEchoClient = new TcpEchoClient("127.0.0.1",9090);
		tcpEchoClient.start();
	}
}

Socket clientSocket