TCP/IP协议简介及JAVA中的Socket实现
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实现
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客户端实现代码如下
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协议的服务端与客户端代码没有区别，这里只简单介绍一下客户端代码
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();
}
}
扫一扫
719
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
