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();
}
}
}