[网络协议]二十六、JavaTCP协议

1.什么是TCP协议？

TCP协议在通讯的时候，要求通讯的双方建立起连接（面向协议）

在建立连接的过程中需要经过三次握手才能完成连接的建立。

TCP三次握手

?解析：

第一次握手：Client将标志位SYN置为1，随机产生一个值seq=J，并将该数据包发送给Server，Client进入SYN_SENT状态，等待Server确认。【Client给Server发送创建连接的请求】

第二次握手：Server收到数据包后由标志位SYN=1知道Client请求建立连接，Server将标志位SYN和ACK都置为1，ack=J+1，随机产生一个值seq=K，并将该数据包发送给Client以确认连接请求，Server进入SYN_RCVD状态。

【Server被Client发送响应信息】

第三次握手：Client收到确认后，检查ack是否为J+1，ACK是否为1，如果正确则将标志位ACK置为1，ack=K+1，并将该数据包发送给Server，Server检查ack是否为K+1，ACK是否为1，如果正确则连接建立成功，Client和Server进入ESTABLISHED状态，完成三次握手，随后Client与Server之间可以开始传输数据了。【Client给Server发送确认信息】

2.建立基于TCP的网络通讯程序需要使用的类和常用方法？

上面建立基于TCP的网络通讯程序需要两套程序。

1）Socket

第一套程序，是建立客户端程序

java.net.Socket[套接字] 创建基于TCP的通讯程序的客户端对象的java类

构造方法

Socket(InetAddress?address, int?port) 创建流套接字并将其连接到指定IP地址的指定端口号。

Socket(String?host, int?port) 创建流套接字并将其连接到指定主机上的指定端口号。

实例方法

OutputStream getOutputStream() 返回客户端的输出流。【与服务器的输入流连接】

InputStream getInputStream() 返回客户端的输入流。 【与服务器的输出流连接】

void close() 关闭客户端。

第二套程序，是建立服务器端程序

java.net.ServerSocket 创建基于TCP的通讯程序的服务器端对象的java类

构造方法

ServerSocket(int?port) 创建绑定到指定端口的服务器套接字。

实例方法

Socket accept() 侦听要连接到此套接字并接受它。 【阻塞主线程运行】

void close() 关闭服务器。

客户端程序的开发步骤:

1.创建客户端对象【Socket】，连接服务器

2.通过客户端对象【Socket】的getInputStream() / getOutputStream(),得到输入输出流

3.通过得到的输入输出流对象调用read()/write()方法完成数据收发。

4.关闭输入输出流和客户端对象【Socket】。

2）ServerSocket

服务器端程序的开发步骤:

1.创建服务器端对象【ServerSocket】，开启服务器

2.通过服务器端对象【ServerSocket】的accept()方法，获得连接进入服务器的客户端对象【Socket】

3.连接进入服务器的客户端对象【Socket】的getInputStream()/getOutputStream(),得到输入输出流.

4.通过得到的输入输出流对象调用read()/write()方法完成数据收发。

5.关闭输入输出流和客户端对象【Socket】以及服务器端对象【ServerSocket】。

例如1:完成客户端向服务器送数据，服务器接收到客户端发送来的数据。

服务类：

import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class ServerTest {
	public static void main(String[] args) throws IOException {
		//定义
		int temp = 0;
		int serverport  = 3000;
		byte defaultvalue[] = new byte[1024];
		ServerSocket server = null;
		Socket atSocket = null;
		InputStream in = null;
		server = new ServerSocket(serverport);
		atSocket = server.accept();
		in = atSocket.getInputStream();
		temp = in.read(defaultvalue);
		String showtext = new String(defaultvalue,0,temp);
		System.out.println("server----" + showtext);
		in.close();
		atSocket.close();
		server.close();
	}
}

客户类

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

public class SocketMain {
	public static void main(String[] args) throws IOException {
		InetAddress inet = InetAddress.getLocalHost();
		BufferedReader buff = null;
		Socket socket = null;
		int exports = 3000;
		buff = new BufferedReader(new InputStreamReader(System.in));
		socket = new Socket(inet, exports);
		System.out.println("请输入需要传输的内容");
		String title =  buff.readLine();
//		System.out.println(title);
		OutputStream outsocket = socket.getOutputStream();
		outsocket.write(title.getBytes());
		socket.close();
	}
}

例如2:完成客户端持续向服务器送数据，服务器持续接收到客户端发送来的数据。

服务类

import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class ServerTest {
	public static void main(String[] args) throws Exception{
		ServerSocket serverSocket = null;
		Socket socket = null;
		InputStream in = null;
		int  temp;
		int export = 3000;
		boolean flag = true;
		byte bytes[] = new byte[1024];
		serverSocket  = new ServerSocket(export);
		socket = serverSocket.accept();
		in = socket.getInputStream();
		while (flag) {
			temp = in.read(bytes);
			String str = new String(bytes,0,temp);
			System.out.println("server------" + str);
		}
		in.close();
		serverSocket.close();
	}
}

客户端类

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;

public class ClickTest {

	public static void main(String[] args) throws Exception {
		Socket socket = null;
		BufferedReader buff = null;
		InetAddress localhost = null;
		int export = 3000;
		boolean flag = true;
		OutputStream outserver= null;
		buff = new BufferedReader(new InputStreamReader(System.in));
		localhost = InetAddress.getLocalHost();
		socket = new Socket(localhost,export);
		outserver = socket.getOutputStream();
		while (flag) {
			System.out.println("请输入需要传入的数据：");
			String instr = buff.readLine();
			outserver.write(instr.getBytes());
			if (instr.equals("exit")) {
				flag = false;
			}
		}
		outserver.close();
		socket.close();
		buff.close();
	}
}

例如3:完成客户端持续向服务器送数据，还能接收服务器返回的信息，服务器持续接收到客户端发送来的数据，还可以向客户端返回信息。

服务端类

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

public class ServerTest {

	public static void main(String[] args)throws Exception {
		ServerSocket serverSocket = null;
		Socket socket  = null;
		InputStream in = null;
		OutputStream out = null;
		int prot = 3000;
		boolean flag = true;
		int temp = 0;
		byte databytes[] =new byte[1024];
		
		serverSocket = new ServerSocket(prot);
		socket = serverSocket.accept();
		in = socket.getInputStream();
		out = socket.getOutputStream();
		
		while (flag) {
		 temp =	in.read(databytes);
		 String str = new String(databytes,0,temp);
		 if (!str.equals("exit")) {
			 str  = "Server : " + str;
		  }else{
			 flag = false;
		  }
		 System.out.println(str);
		 out.write(str.getBytes());
		}
		out.close();
		in.close();
		socket.close();
		serverSocket.close();
	}

}

客户端类

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;

public class ClickTest {
	public static void main(String[] args) throws Exception{
		Socket socket = null;
		InetAddress localhost = null;
		int port = 3000;
		BufferedReader buff = null;
		OutputStream out = null;
		InputStream in = null;
		byte data[] = new byte[1024];
		boolean flag = true;
		String serverstr = null;
		localhost = InetAddress.getLocalHost();
		
		socket = new Socket(localhost, port);
		buff = new BufferedReader(new InputStreamReader(System.in));
		out = socket.getOutputStream();
		in = socket.getInputStream();
		while(flag){
			System.out.println("请输入需要传输的文字");
			String str = buff.readLine();
			out.write(str.getBytes());
			int temp = in.read(data);
			if (temp != -1) {
				serverstr = new String(data,0,temp);
				System.out.println("接受服务端返回的值为：" + serverstr);
			}
			if (serverstr.equals("exit")) {
				flag = false;
			}
		}
		
		in.close();
		out.close();
		buff.close();
		socket.close();
		
	}
}

例如4:多客户端，配置一台服务器，独立运行

服务端类

import java.net.ServerSocket;
import java.net.Socket;

public class ServerTest {
	public static void main(String[] args) throws Exception{
		ServerSocket serverSocket = null;
		Socket socket = null;
		int port = 3000;
		serverSocket  = new ServerSocket(port);
		boolean flag = true;
		ThreadTest thread = null;
		while (flag) {
			socket = serverSocket.accept();
			thread = new ThreadTest(socket);
			thread.start();
		}
		serverSocket.close();
	}
}

服务端线程类

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

public class ThreadTest extends Thread {
	private Socket socket;
	private InputStream in;
	private OutputStream out;
	byte data[];

	public ThreadTest(Socket socket) {
		this.socket = socket;
	}

	@Override
	public void run() {
		boolean flag = true;
		String str = null;
		data = new byte[1024];
		//不间断的发送数据
		while (flag) {
			try {
				in = socket.getInputStream();
				int temp = in.read(data);
				if (temp != -1) {
					str = new String(data, 0, temp);
				}
				if (str.equals("exit")) {
					flag = false;
					System.out.println(Thread.currentThread().getName() + "服务已经关闭");
				} else {
					str = Thread.currentThread().getName() + "服务数据为：" + str;
					System.out.println(str);
				}
				out = socket.getOutputStream();
				out.write(str.getBytes());
			} catch (IOException e) {
				System.out.println("服务器异常:"+e.getMessage());
			}
		}
		
		//停止发送数据
		try {
			out.close();
			in.close();
			socket.close();
		} catch (IOException e) {
			System.out.println("关闭");
			e.printStackTrace();
		}
	}
}

客户类：

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;


public class ClickTest {
	public static void main(String[] args) throws Exception {
		Socket socket = null;
		OutputStream out = null;
		InputStream in = null;
		BufferedReader buff = null;
		InetAddress localhost = null;
		int prot = 3000;
		int temp = 0;
		byte bytedata[] = new byte[1024];
		boolean flag = true;
		String  str = null;
		
		localhost = InetAddress.getLocalHost();
		socket = new Socket(localhost,prot);
		buff = new BufferedReader(new InputStreamReader(System.in));
		in = socket.getInputStream();
		out = socket.getOutputStream();
		while(flag){
			System.out.println("请输入传递的数据：");
			str =  buff.readLine();
			out.write(str.getBytes());
			temp = in.read(bytedata);
			if (temp != -1) {
				str = new String(bytedata,0,temp);
			}
			if (str.equals("exit")) {
				System.out.println("连接断开~~~bye");
				flag = false;
			}
			System.out.println("服务器响应的数据："  + str);
		}
		out.close();
		in.close();
		buff.close();
		socket.close();
	}
}

无奈源于不够强大

?