请选择 进入手机版 | 继续访问电脑版
设为首页收藏本站

houcx

 找回密码
 立即注册
搜索
热搜: 活动 交友 discuz
查看: 987|回复: 0

TCP/IP协议简介及JAVA中的Socket实现

[复制链接]

222

主题

224

帖子

1123

积分

管理员

Rank: 9Rank: 9Rank: 9

积分
1123
发表于 2018-1-12 11:49:58 | 显示全部楼层 |阅读模式
TCP/IP协议简介TCP/IP协议是Internet最基本的协议。TCP/IP协议不是TCP和IP这两个协议的合称,而是指因特网整个TCP/IP协议族。TCP/IP协议模块关系从协议分层模型方面来讲,TCP/IP由四个层次组成:网络接口层、网络层、传输层、应用层。



网络接口层物理层是定义物理介质的各种特性:
1、机械特性;
2、电子特性;
3、功能特性;
4、规程特性。
数据链路层是负责接收IP数据包并通过网络发送,或者从网络上接收物理帧,抽出IP数据包,交给IP层。
ARP是正向地址解析协议,通过已知的IP,寻找对应主机的MAC地址。
RARP是反向地址解析协议,通过MAC地址确定IP地址。比如无盘工作站还有DHCP服务。
常见的接口层协议有:
Ethernet 802.3、Token Ring 802.5、X.25、Frame relay、HDLC、PPP ATM等。

网络层负责相邻计算机之间的通信。其功能包括三方面。
1.处理来自传输层的分组发送请求,收到请求后,将分组装入IP数据报,填充报头,选择去往信宿机的路径,然后将数据报发往适当的网络接口。
2.处理输入数据报:首先检查其合法性,然后进行寻径--假如该数据报已到达信宿机,则去掉报头,将剩下部分交给适当的传输协议;假如该数据报尚未到达信宿,则转发该数据报。
3.处理路径、流控、拥塞等问题。
网络层包括:IP(Internet Protocol)协议、ICMP(Internet Control Message Protocol)、控制报文协议、ARP(Address Resolution Protocol)地址转换协议、RARP(Reverse ARP)反向地址转换协议。
IP是网络层的核心,通过路由选择将下一条IP封装后交给接口层。IP数据报是无连接服务。
ICMP是网络层的补充,可以回送报文。用来检测网络是否通畅。
Ping命令就是发送ICMP的echo包,通过回送的echo relay进行网络测试。

传输层提供应用程序间的通信。其功能包括:一、格式化信息流;二、提供可靠传输。为实现后者,传输层协议规定接收端必须发回确认,并且假如分组丢失,必须重新发送,即耳熟能详的“三次握手”过程,从而提供可靠的数据传输。
传输层协议主要是:传输控制协议TCP(Transmission Control Protocol)和用户数据报协议UDP(User Datagram protocol)。

应用层向用户提供一组常用的应用程序,比如电子邮件、文件传输访问、远程登录等。远程登录TELNET使用TELNET协议提供在网络其它主机上注册的接口。TELNET会话提供了基于字符的虚拟终端。文件传输访问FTP使用FTP协议来提供网络内机器间的文件拷贝功能。
应用层协议主要包括如下几个:FTP、TELNET、DNS、SMTP、NFS、HTTP。
FTP(File TransferProtocol)是文件传输协议,一般上传下载用FTP服务,数据端口是20H,控制端口是21H。
Telnet服务是用户远程登录服务,使用23H端口,使用明码传送,保密性差、简单方便。
DNS(Domain NameService)是域名解析服务,提供域名到IP地址之间的转换,使用端口53。
SMTP(Simple MailTransfer Protocol)是简单邮件传输协议,用来控制信件的发送、中转,使用端口25。
NFS(Network File System)是网络文件系统,用于网络中不同主机间的文件共享。
HTTP(HypertextTransfer Protocol)是超文本传输协议,用于实现互联网中的WWW服务,使用端口80。

主要协议介绍HTTP协议
超文本传输协议 (HTTP-Hypertext transfer protocol) 是一种详细规定了浏览器和万维网服务器之间互相通信的规则,通过因特网传送万维网文档的数据传送协议。在TCP/IP体系结构中,HTTP属于应用层协议,位于TCP/IP协议的顶层
HTTP协议具有以下特点:
1.支持客户/服务器模式。支持基本认证和安全认证。
2.简单快速:客户向服务器请求服务时,只需传送请求方法和路径。请求方法常用的有GET、HEAD、POST。每种方法规定了客户与服务器联系的类型不同。由于HTTP协议简单,使得HTTP服务器的程序规模小,因而通信速度很快。
3.灵活:HTTP允许传输任意类型的数据对象。正在传输的类型由Content-Type加以标记。
4.HTTP 0.9和1.0使用非持续连接:限制每次连接只处理一个请求,服务器处理完客户的请求,并收到客户的应答后,即断开连接。采用这种方式可以节省传输时间。HTTP 1.1使用持续连接:不必为每个web对象创建一个新的连接,一个连接可以传送多个对象。
5.无状态:HTTP协议是无状态协议。无状态是指协议对于事务处理没有记忆能力。缺少状态意味着如果后续处理需要前面的信息,则它必须重传,这样可能导致每次连接传送的数据量增大。

TCP协议
1.面向连接的传输;
2.端到端的通信;
3.高可靠性,确保传输数据的正确性,不出现丢失或乱序;
4.全双工方式传输;
5.采用字节流方式,即以字节为单位传输字节序列;
6.紧急数据传送功能。

UDP协议
1.UDP是一个无连接协议,传输数据之前源端和终端不建立连接,当它想传送时就简单地去抓取来自应用程序的数据,并尽可能快地把它扔到网络上。在发送端,UDP传送数据的速度仅仅是受应用程序生成数据的速度、计算机的能力和传输带宽的限制;在接收端,UDP把每个消息段放在队列中,应用程序每次从队列中读一个消息段。
2.由于传输数据不建立连接,因此也就不需要维护连接状态,包括收发状态等,因此一台服务机可同时向多个客户机传输相同的消息。
3.UDP信息包的标题很短,只有8个字节,相对于TCP的20个字节信息包的额外开销很小。
4.吞吐量不受拥挤控制算法的调节,只受应用软件生成数据的速率、传输带宽、源端和终端主机性能的限制。
5.UDP使用尽最大努力交付,即不保证可靠交付,因此主机不需要维持复杂的链接状态表(这里面有许多参数)。
6.UDP是面向报文的。发送方的UDP对应用程序交下来的报文,在添加首部后就向下交付给IP层。既不拆分,也不合并,而是保留这些报文的边界,因此,应用程序需要选择合适的报文大小。

TCP协议和UDP协议的区别
1,TCP协议面向连接,UDP协议面向非连接
2,TCP协议传输速度慢,UDP协议传输速度快
3,TCP协议保证数据顺序,UDP协议不保证
4,TCP协议保证数据正确性,UDP协议可能丢包
5,TCP协议对系统资源要求多,UDP协议要求少

JAVA中的Socket实现TCP服务端实现代码如下:
[java] view plain copy

  • import java.io.BufferedReader;  
  • import java.io.IOException;  
  • import java.io.InputStreamReader;  
  • import java.io.OutputStreamWriter;  
  • import java.io.PrintWriter;  
  • import java.net.ServerSocket;  
  • import java.net.Socket;  
  • import java.util.ArrayList;  
  • import java.util.List;  
  •   
  • public class JavaTCPServer {  
  •   
  •     private static final int PORT = 10010;  
  •     private ServerSocket serverSocket;  
  •     private final List<ServerThread> socketList = new ArrayList<ServerThread>();  
  •     private boolean isStartServer = false;  
  •   
  •     public void startServer() throws IOException {  
  •         if (isStartServer) {  
  •             System.err.println("already>>>>startServer>>>>>>>>>");  
  •             return;  
  •         }  
  •         System.err.println("startServer>>>>>>>>>");  
  •         serverSocket = new ServerSocket(PORT);  
  •         isStartServer = true;  
  •         new Thread(new Runnable() {  
  •   
  •             @Override  
  •             public void run() {  
  •                 // TODO Auto-generated method stub  
  •                 while (isStartServer) {  
  •                     try {  
  •                         Socket client = serverSocket.accept();  
  •   
  •                         ServerThread serverThread = new ServerThread(client);  
  •                         new Thread(serverThread).start();  
  •                         socketList.add(serverThread);  
  •                         System.err.println("当前连接数为:" + socketList.size());  
  •   
  •                     } catch (IOException e) {  
  •                         // TODO Auto-generated catch block  
  •                         e.printStackTrace();  
  •                     }  
  •   
  •                 }  
  •             }  
  •         }).start();  
  •     }  
  •   
  •     public void stopServer() {  
  •         System.err.println("stopServer>>>>>>>>>");  
  •         isStartServer = false;  
  •         for (ServerThread serverThread : socketList) {  
  •             serverThread.stop();  
  •         }  
  •         socketList.clear();  
  •     }  
  •   
  •     public void sendMessage(String str) {  
  •         socketList.get(0).sendMessage(str);  
  •     }  
  •   
  •     private class ServerThread implements Runnable {  
  •         private boolean isRunning = false;  
  •         private final Socket socket;  
  •         private final BufferedReader reader;  
  •         private final PrintWriter writer;  
  •   
  •         public ServerThread(Socket socket) throws IOException {  
  •             this.socket = socket;  
  •             reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));  
  •             writer = new PrintWriter(new OutputStreamWriter(socket.getOutputStream()));  
  •             isRunning = true;  
  •         }  
  •   
  •         public void stop() {  
  •             isRunning = false;  
  •             try {  
  •                 reader.close();  
  •                 writer.close();  
  •                 socket.close();  
  •   
  •             } catch (IOException e) {  
  •                 // TODO Auto-generated catch block  
  •                 e.printStackTrace();  
  •             }  
  •         }  
  •   
  •         public void sendMessage(String str) {  
  •             writer.print(str + "\n");  
  •             writer.flush();  
  •         }  
  •   
  •         @Override  
  •         public void run() {  
  •             // TODO Auto-generated method stub  
  •             String msg = null;  
  •             while (isRunning) {  
  •                 try {  
  •                     msg = reader.readLine();  
  •                     System.out.println(ServerThread.this.toString() + ":"  
  •                             + msg);  
  •                 } catch (IOException e) {  
  •                     // TODO Auto-generated catch block  
  •                     e.printStackTrace();  
  •                 }  
  •             }  
  •         }  
  •   
  •     }  
  •   
  •     public static void main(String[] args) {  
  •         // TODO Auto-generated method stub  
  •         JavaTCPServer tcpServer = new JavaTCPServer();  
  •         BufferedReader in = new BufferedReader(new InputStreamReader(System.in));  
  •         String msg = null;  
  •         while (true) {  
  •             try {  
  •                 msg = in.readLine();  
  •                 if ("-start".equalsIgnoreCase(msg)) {  
  •                     tcpServer.startServer();  
  •                 } else if ("-stop".equalsIgnoreCase(msg)) {  
  •                     tcpServer.stopServer();  
  •                 } else {  
  •                     tcpServer.sendMessage(msg);  
  •                     // System.out.println(msg);  
  •                 }  
  •             } catch (IOException e) {  
  •                 // TODO Auto-generated catch block  
  •                 e.printStackTrace();  
  •             }  
  •         }  
  •     }  
  •   
  • }  


TCP客户端实现代码如下

[java] view plain copy

  • import java.io.BufferedReader;  
  • import java.io.IOException;  
  • import java.io.InputStreamReader;  
  • import java.io.OutputStreamWriter;  
  • import java.io.PrintWriter;  
  • import java.net.Socket;  
  •   
  • public class JavaTCPClient {  
  •   
  •     private static final String HOST = "localhost";  
  •     private static final int PORT = 10010;  
  •     private Socket socket;  
  •     private ClientThread clientThread;  
  •     private boolean isBind = false;  
  •   
  •     public void bindServer() throws IOException {  
  •         if (isBind) {  
  •             System.err.println("already>>>>bindServer>>>>>>>>>");  
  •             return;  
  •         }  
  •         System.err.println("bindServer>>>>>>>>>");  
  •         socket = new Socket(HOST, PORT);  
  •         clientThread = new ClientThread(socket);  
  •         new Thread(clientThread).start();  
  •         isBind = true;  
  •     }  
  •   
  •     public void unBindServer() {  
  •         System.err.println("unBindServer>>>>>>>>>");  
  •         isBind = false;  
  •         clientThread.stop();  
  •     }  
  •   
  •     public void sendMessage(String str) {  
  •         if (isBind) {  
  •             clientThread.sendMessage(str);  
  •         }  
  •     }  
  •   
  •     private class ClientThread implements Runnable {  
  •         private boolean isRunning = false;  
  •         private final Socket socket;  
  •         private final BufferedReader reader;  
  •         private final PrintWriter writer;  
  •   
  •         public ClientThread(Socket socket) throws IOException {  
  •             this.socket = socket;  
  •             reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));  
  •             writer = new PrintWriter(new OutputStreamWriter(socket.getOutputStream()));  
  •             isRunning = true;  
  •         }  
  •   
  •         public void stop() {  
  •             isRunning = false;  
  •             try {  
  •                 reader.close();  
  •                 writer.close();  
  •                 socket.close();  
  •   
  •             } catch (IOException e) {  
  •                 // TODO Auto-generated catch block  
  •                 e.printStackTrace();  
  •             }  
  •         }  
  •   
  •         public void sendMessage(String str) {  
  •             writer.print(str + "\n");  
  •             writer.flush();  
  •         }  
  •   
  •         @Override  
  •         public void run() {  
  •             // TODO Auto-generated method stub  
  •             String msg = null;  
  •             while (isRunning) {  
  •                 try {  
  •                     msg = reader.readLine();  
  •                     System.out.println(HOST + ":"  
  •                             + msg);  
  •                 } catch (IOException e) {  
  •                     // TODO Auto-generated catch block  
  •                     e.printStackTrace();  
  •                 }  
  •             }  
  •         }  
  •   
  •     }  
  •   
  •     public boolean isBind() {  
  •         return isBind;  
  •     }  
  •   
  •     public static void main(String[] args) {  
  •         // TODO Auto-generated method stub  
  •         JavaTCPClient tcpClient = new JavaTCPClient();  
  •         BufferedReader in = new BufferedReader(new InputStreamReader(System.in));  
  •         String msg = null;  
  •         while (true) {  
  •             try {  
  •                 msg = in.readLine();  
  •                 if ("-bind".equalsIgnoreCase(msg)) {  
  •                     tcpClient.bindServer();  
  •                 } else if ("-unbind".equalsIgnoreCase(msg)) {  
  •                     tcpClient.unBindServer();  
  •                 } else {  
  •                     if (tcpClient.isBind()) {  
  •                         tcpClient.sendMessage(msg);  
  •                     } else {  
  •                         System.out.println(msg);  
  •                     }  
  •                 }  
  •             } catch (IOException e) {  
  •                 // TODO Auto-generated catch block  
  •                 e.printStackTrace();  
  •             }  
  •         }  
  •     }  
  • }  


UDP协议的服务端与客户端代码没有区别,这里只简单介绍一下客户端代码
[java] view plain copy

  • import java.io.BufferedReader;  
  • import java.io.InputStreamReader;  
  • import java.net.DatagramPacket;  
  • import java.net.DatagramSocket;  
  • import java.net.InetAddress;  
  •   
  • public class JavaUDPClient {  
  •   
  •     private static final String HOST = "localhost";  
  •     private static final int PORT = 10010;  
  •   
  •     public static void main(String args[]) throws Exception  
  •     {  
  •         BufferedReader inFromUser =  
  •                 new BufferedReader(new InputStreamReader(System.in));  
  •   
  •         DatagramSocket clientSocket = new DatagramSocket();  
  •         InetAddress IPAddress = InetAddress.getByName(HOST);  
  •         byte[] sendData = new byte[1024];  
  •         byte[] receiveData = new byte[1024];  
  •         String sentence = inFromUser.readLine();  
  •         sendData = sentence.getBytes();  
  •         DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length, IPAddress, PORT);  
  •         clientSocket.send(sendPacket);  
  •         DatagramPacket receivePacket = new DatagramPacket(receiveData, receiveData.length);  
  •         clientSocket.receive(receivePacket);  
  •         String modifiedSentence = new String(receivePacket.getData());  
  •         System.out.println("FROM SERVER:" + modifiedSentence);  
  •         clientSocket.close();  
  •     }  
  •   
  • }  



来自:http://blog.csdn.net/u013290890/article/details/19766099



回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

QQ|Archiver|手机版|小黑屋|houcx ( 京ICP备15004793号  

GMT+8, 2019-6-25 13:41 , Processed in 0.060351 second(s), 24 queries .

Powered by houcx! X3.2

© 2001-2013 Comsenz Inc.

快速回复 返回顶部 返回列表