域名：
DN （Domain name）是由一串由点分隔的名字组成的Internet上某一台计算机或计算机组的名称。
域名服务系统：DNS：它可以作为将域名和IP地址相互映射的一个分布式数据库。
协议：
应用层常见协议：
http协议：超文本传输语言。
ftp协议：文件传输协议
smtp协议：简单邮件传输协议
传输层的协议：
UDP协议：用户数据报协议，面向无连接的，简单不可靠的传输层协议。
- 面向无连接
- 通过数据报包来进行传输，每个数据报包大小不会超过64k.
- 不可靠的传输。
- 传输速度快。
TCP协议：传输控制协议，一种面向连接的，可靠的，基于字节流的传输层通信协议。
TCP协议传输过程：
要经过三次握手，确定通道的连接。
建立流的传输通道，进行数据的传输。
TCP传输协议的特点：
- 面向连接的
- 通过流通道进行数据的传输
- 可靠的连接
- 速度慢
UDP协议传输
代码示例：
发送端：
1 /**
2
3 1. 发送数据报包
4 ① 创建发送端的套接字对象。
5 ② 打包数据，用的 DatagramPacket
6 DatagramPacket(byte[] buf, int length, InetAddress address, int port)
7 ③ 发送
8 send(dp)
9 ④ 关闭资源
10 close
11 */
12 public class 发送端 {
13 public static void main(String[] args) throws IOException, UnknownHostException {
14 // ① 创建发送端的套接字对象。
15 DatagramSocket ds=new DatagramSocket();
16 String s=" 接收端您好 ";
17 byte[] buf=s.getBytes();
18 DatagramPacket dp=new DatagramPacket(buf, buf.length, InetAddress.getLocalHost(), 9000);
19 // 发送
20 ds.send(dp);
21 // 等待接收端的响应 --> 接收端
22 // 空的数据报包接收
23 byte[] buf1=new byte[1024];
24 DatagramPacket dp1=new DatagramPacket(buf1, buf1.length);
25 ds.receive(dp1);
26 // 显示
27 System.out.println(new String(dp1.getData()));
28 ds.close();
29 }
30 }
接收端：
1 /**
2 . 用来接收数据报包
3 ① 创建一个接收数据的套接字。
4 ② 创建一个空的数据报包来接收数据
5 ③ 接收 receive(DatagramPacket p)
6 ④ 关闭
7 */
8 public class 接收端 {
9 public static void main(String[] args) throws IOException {
10 // ① 创建一个接收数据的套接字。
11 DatagramSocket ds=new DatagramSocket(9000);
12 // ② 创建一个空的数据报包来接收数据
13 // DatagramPacket(byte[] buf, int length)
14 byte[] buf=new byte[1024];
15 DatagramPacket dp=new DatagramPacket(buf, buf.length);
16 // 接收
17 ds.receive(dp);
18 // 显示 getLength 返回接收到的数据的字节长度
19 System.out.println(new String(buf,0,dp.getLength()));
20 // 发送端响应 -- 》发送端
21 //getAddress/getPort 获取发送端的 ip 地址与端口号
22 DatagramPacket p=new DatagramPacket(" 发送端您好 ".getBytes(), " 发送端您好 ".getBytes().length, d
23 p.getAddress(), dp.getPort());
24 ds.send(p);
25 // 关闭
26 ds.close();
27 }
28 }
TCP协议传输
代码示例：
服务器端代码：
1 package DemoEE;
2
3 import java.io.IOException;
4 import java.io.InputStream;
5 import java.net.ServerSocket;
6 import java.net.Socket;
7
8 public class 服务器端3 {
9
10 public static void main(String[] args) throws IOException {
11 System.out.println("正在等待客户端连接");
12 ServerSocket ss=new ServerSocket(9004);
13 Socket s=ss.accept();
14 InputStream is=s.getInputStream();
15 byte[] bt=new byte[1024];
16 int count=0;
17 while((count=is.read(bt))!=-1) {
18 System.out.println(new String(bt,0,count));
19 }
20 }
21 }
客户端代码：
1 package DemoEE;
2
3 import java.io.IOException;
4 import java.io.OutputStream;
5 import java.net.InetAddress;
6 import java.net.Socket;
7
8 public class 客户端3 {
9
10 public static void main(String[] args) throws IOException, IOException {
11 Socket s=new Socket(InetAddress.getByName("localhost"),9004);
12 OutputStream os=s.getOutputStream();
13 os.write(new String("服务器端你好").getBytes());
14 os.close();
15 s.close();
16
17 }
18 }
先执行服务器端，执行效果：
执行客户端，执行效果：
代码示例二：
服务器端：
1 /**
2
3 1. 创建服务器端的对象： 在指定端口监听是否有客户端进行连接。
4 2. 通过 accept 方法进行监听，并通过三次握手建立连接流通道。
5 3. 从客户端读取内容，获取流通道中的输入流
6 4. 关闭资源
7 */
8 public class 服务器端 {
9 public static void main(String[] args) throws IOException {
10 // 1. 创建服务器端的对象： 在指定端口监听是否有客户端进行连接。
11 ServerSocket ss=new ServerSocket(9000);
12 //2. 通过 accept 方法进行监听，并通过三次握手建立连接流通道。
13 // 返回值为当前要连接的客户端对象
14 System.out.println(" 等待客户端的连接。。。。 ");
15 Socket s=ss.accept();
16 //3. 从客户端读取内容，获取流通道中的输入流
17 InputStream is = s.getInputStream();
18 // 读取
19 byte[] b=new byte[1024];
20 int count=0;
21 while((count=is.read(b))!=-1) {
22 System.out.println(new String(b,0,count));
23 }
24 // 关闭资源
25 is.close();
26 ss.close();
27 }
28 }
客户端：
1 /**
2
3 1. 创建客户端的对象： 指定服务器，服务器的端口
4 2. 向服务器端写入，获取流通道中的输出流
5 3. 关闭资源
6 */
7 public class 客户端 {
8 public static void main(String[] args) throws IOException {
9 // 1. 创建客户端的对象： 指定服务器，服务器的端口
10 Socket s=new Socket(InetAddress.getByName("localhost"), 9000);
11 // 2. 向服务器端写入，获取流通道中的输出流
12 OutputStream os = s.getOutputStream();
13 os.write(" 服务器端您好 ".getBytes());
14 // 关闭资源
15 os.close();
16 s.close();
17 }
18 }
代码示例三：
进阶班客户端：
1 package com.tcp2;
2 import java.io.BufferedReader;
3 import java.io.BufferedWriter;
4 import java.io.InputStreamReader;
5 import java.io.OutputStream;
6 import java.io.OutputStreamWriter;
7 import java.net.InetAddress;
8 import java.net.Socket;
9 /**
10
11 1. 客户端
12 */
13 public class 客户端 {
14 public static void main(String[] args) {
15 // 客户端对象
16 try(Socket client=new Socket(InetAddress.getByName("localhost"), 9000);
17 // 用户输入
18 BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
19 // 向服务器端发送信息，输出流
20 BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(client.getOutputStream()));
21 // 读取从服务器写入的内容 输入流
22 BufferedReader bre=new BufferedReader(new InputStreamReader(client.getInputStream()));
23 ){
24 System.out.println(" 客户端要发送到服务器端的内容为： ");
25 // 通过用户输入信息
26 String msg = br.readLine();
27 // 将用户输入的信息发送到服务器端
28 bw.write(msg);
29 // 换行的标识
30 bw.newLine();
31 // 刷新缓冲区
32 bw.flush();
33 // 等待接收
34 String msgServer = bre.readLine();
35 System.out.println(" 从服务器获取的信息： "+msgServer);
36 }catch (Exception e) {
37 e.printStackTrace();
38 }
39 }
40 }
进阶版服务器端：
1 package com.tcp2;
2 import java.io.BufferedReader;
3 import java.io.BufferedWriter;
4 import java.io.InputStreamReader;
5 import java.io.OutputStreamWriter;
6 import java.net.ServerSocket;
7 import java.net.Socket;
8 /**
9
10 1. 服务器端
11 */
12 public class 服务器端 {
13 public static void main(String[] args) {
14 // 服务器
15 try(ServerSocket ss=new ServerSocket(9000);){
16 System.out.println(" 等待客户端的连接。。。。。 ");
17 // 连接每一个客户端
18 try(Socket client=ss.accept();
19 // 读取客户端发送的信息
20 BufferedReader br=new BufferedReader(new InputStreamReader(client.getInputStream()));
21 // 获取服务器端用户输入的信息
22 BufferedReader bin=new BufferedReader(new InputStreamReader(System.in));
23 // 向客户端写入信息
24 BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(client.getOutputStream()));
25 ){
26 // 读取客户端发来的信息
27 String clientMsg = br.readLine();
28 System.out.println(" 从客户端发来的消息为： "+clientMsg);
29 System.out.println(" 服务器端要发送到客户端的内容为： ");
30 // 服务器端用户输入信息
31 String input = bin.readLine();
32 // 向客户端写入
33 bw.write(input);
34 bw.newLine();
35 bw.flush();
36 }catch (Exception e) {
37 e.printStackTrace();
38 }
39 }catch (Exception e) {
40 e.printStackTrace();
41 }
42 }
43 }
原文地址：https://www.cnblogs.com/ywzbky/p/10731808.html
时间： 2024-11-08 12:23:10