UDP协议&TCP协议

域名：

DN （Domain name）是由一串由点分隔的名字组成的Internet上某一台计算机或计算机组的名称。

域名服务系统：DNS：它可以作为将域名和IP地址相互映射的一个分布式数据库。

协议：

    应用层常见协议：

　　http协议：超文本传输语言。

　　ftp协议：文件传输协议

　　smtp协议：简单邮件传输协议

　传输层的协议：

　　UDP协议：用户数据报协议，面向无连接的，简单不可靠的传输层协议。

1. 　　面向无连接
2.        通过数据报包来进行传输，每个数据报包大小不会超过64k.
3.        不可靠的传输。
4.        传输速度快。

　　TCP协议：传输控制协议，一种面向连接的，可靠的，基于字节流的传输层通信协议。

　　TCP协议传输过程：

　　要经过三次握手，确定通道的连接。

　　建立流的传输通道，进行数据的传输。

　　TCP传输协议的特点：

1. 　　面向连接的
2.        通过流通道进行数据的传输
3.        可靠的连接
4.        速度慢

UDP协议传输

代码示例：

发送端：

/**

1. 发送数据报包
①  创建发送端的套接字对象。
②  打包数据，用的 DatagramPacket
DatagramPacket(byte[] buf, int length, InetAddress address, int port)
③  发送
send(dp)
④  关闭资源
close
*/
public class  发送端 {
public static void main(String[] args) throws IOException, UnknownHostException {
// ①  创建发送端的套接字对象。
DatagramSocket ds=new DatagramSocket();
String s=" 接收端您好 ";
byte[] buf=s.getBytes();
DatagramPacket dp=new DatagramPacket(buf, buf.length, InetAddress.getLocalHost(), 9000);
// 发送
ds.send(dp);
// 等待接收端的响应 --> 接收端
// 空的数据报包接收
byte[] buf1=new byte[1024];
DatagramPacket dp1=new DatagramPacket(buf1, buf1.length);
ds.receive(dp1);
// 显示
System.out.println(new String(dp1.getData()));
ds.close();
}
}

接收端：

/**
. 用来接收数据报包
①  创建一个接收数据的套接字。
②  创建一个空的数据报包来接收数据
③  接收 receive(DatagramPacket p)
④  关闭
*/
public class  接收端 {
public static void main(String[] args) throws IOException {
// ①  创建一个接收数据的套接字。
DatagramSocket ds=new DatagramSocket(9000);
// ②  创建一个空的数据报包来接收数据
// DatagramPacket(byte[] buf, int length)
byte[] buf=new byte[1024];
DatagramPacket dp=new DatagramPacket(buf, buf.length);
// 接收
ds.receive(dp);
// 显示 getLength  返回接收到的数据的字节长度
System.out.println(new String(buf,0,dp.getLength()));
// 发送端响应 -- 》发送端
//getAddress/getPort  获取发送端的 ip 地址与端口号
DatagramPacket p=new DatagramPacket(" 发送端您好 ".getBytes(), " 发送端您好 ".getBytes().length, d
p.getAddress(), dp.getPort());
ds.send(p);
// 关闭
ds.close();
}
}

TCP协议传输

代码示例：

服务器端代码：

package DemoEE;

import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class 服务器端3 {

    public static void main(String[] args) throws IOException {
        System.out.println("正在等待客户端连接");
        ServerSocket ss=new ServerSocket(9004);
        Socket s=ss.accept();
        InputStream is=s.getInputStream();        
        byte[] bt=new byte[1024];
        int count=0;
        while((count=is.read(bt))!=-1) {
            System.out.println(new String(bt,0,count));
        }
    }
}

客户端代码：

package DemoEE;

import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;

public class 客户端3 {

    public static void main(String[] args) throws IOException, IOException {
        Socket s=new Socket(InetAddress.getByName("localhost"),9004);
        OutputStream os=s.getOutputStream();
        os.write(new String("服务器端你好").getBytes());
        os.close();
        s.close();
        
    }
}

先执行服务器端，执行效果：

执行客户端，执行效果：

代码示例二：

服务器端：

/**

1. 创建服务器端的对象： 在指定端口监听是否有客户端进行连接。
2. 通过 accept 方法进行监听，并通过三次握手建立连接流通道。
3. 从客户端读取内容，获取流通道中的输入流
4. 关闭资源
*/
public class  服务器端 {
public static void main(String[] args) throws IOException {
// 1. 创建服务器端的对象： 在指定端口监听是否有客户端进行连接。
ServerSocket ss=new ServerSocket(9000);
//2. 通过 accept 方法进行监听，并通过三次握手建立连接流通道。
// 返回值为当前要连接的客户端对象
System.out.println(" 等待客户端的连接。。。。 ");
Socket s=ss.accept();
//3. 从客户端读取内容，获取流通道中的输入流
InputStream is = s.getInputStream();
// 读取
byte[] b=new byte[1024];
int count=0;
while((count=is.read(b))!=-1) {
System.out.println(new String(b,0,count));
}
// 关闭资源
is.close();
ss.close();
}
}

客户端：

/**

1. 创建客户端的对象： 指定服务器，服务器的端口
2. 向服务器端写入，获取流通道中的输出流
3. 关闭资源
*/
public class  客户端 {
public static void main(String[] args) throws IOException {
// 1. 创建客户端的对象： 指定服务器，服务器的端口
Socket s=new Socket(InetAddress.getByName("localhost"), 9000);
// 2. 向服务器端写入，获取流通道中的输出流
OutputStream os = s.getOutputStream();
os.write(" 服务器端您好 ".getBytes());
// 关闭资源
os.close();
s.close();
}
}

代码示例三：

进阶班客户端：

package com.tcp2;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.InetAddress;
import java.net.Socket;
/**

1. 客户端
*/
public class  客户端 {
public static void main(String[] args) {
// 客户端对象
try(Socket client=new Socket(InetAddress.getByName("localhost"), 9000);
// 用户输入
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
// 向服务器端发送信息，输出流
BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(client.getOutputStream()));
// 读取从服务器写入的内容 输入流
BufferedReader bre=new BufferedReader(new InputStreamReader(client.getInputStream()));
){
System.out.println(" 客户端要发送到服务器端的内容为： ");
// 通过用户输入信息
String msg = br.readLine();
// 将用户输入的信息发送到服务器端
bw.write(msg);
// 换行的标识
bw.newLine();
// 刷新缓冲区
bw.flush();
// 等待接收
String msgServer = bre.readLine();
System.out.println(" 从服务器获取的信息： "+msgServer);
}catch (Exception e) {
e.printStackTrace();
}
}
}

进阶版服务器端：

package com.tcp2;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.ServerSocket;
import java.net.Socket;
/**

1. 服务器端
*/
public class  服务器端 {
public static void main(String[] args) {
// 服务器
try(ServerSocket ss=new ServerSocket(9000);){
System.out.println(" 等待客户端的连接。。。。。 ");
// 连接每一个客户端
try(Socket client=ss.accept();
// 读取客户端发送的信息
BufferedReader br=new BufferedReader(new InputStreamReader(client.getInputStream()));
// 获取服务器端用户输入的信息
BufferedReader bin=new BufferedReader(new InputStreamReader(System.in));
//  向客户端写入信息
BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(client.getOutputStream()));
){
// 读取客户端发来的信息
String clientMsg = br.readLine();
System.out.println(" 从客户端发来的消息为： "+clientMsg);
System.out.println(" 服务器端要发送到客户端的内容为： ");
// 服务器端用户输入信息
String input = bin.readLine();
// 向客户端写入
bw.write(input);
bw.newLine();
bw.flush();
}catch (Exception e) {
e.printStackTrace();
}
}catch (Exception e) {
e.printStackTrace();
}
}
}