基于TCP协议的通信程序
1.什么是TCP协议？
? ? ? ? TCP---传输控制协议[有链接的协议]
? ? ? ? 优点：保证数据安全可靠
? ? ? ? 缺点：消耗大，效率低
2.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发送响应信息】
3.建立基于TCP的网络通讯程序需要使用的类和常用方法？
? ? ? ? 上面建立基于TCP网络通讯程序需要两套程序。
? ? ? ? 第一套程序，是建立客户端程序
? ? ? ? java.bet.Socket[套接字]创建基于TCP的通讯程序的客户段对象的java类
? ? ? ? 构造方法
? ? ? ? Socket(InetAddress address,int prot)创建流套接字并将其连接到指定IP地址的指定端口号。
? ? ? ? Socket(String host,int prot)创建流套接字并将其连接到指定主机上的指定端口号
? ? ? ? 实例方法
? ? ? ? OutputStream? ? ? ? getOutputStream()返回客户端的输出流。【与服务器的输入流连接】
? ? ? ? InputStream? ? ? ? ? ?getInputStream()返回客户端的输入流【与服务器的输出流连接】
? ? ? ? void? ? ? ? ? close()关闭客户端。
? ? ? ? 第二套程序，是建立服务器端程序
? ? ? ? java.net.ServerSocke创建基于TCP的通讯程序的服务器端对象的java可u
? ? ? ? 构造方法
? ? ? ? ServerSocket(int? ?prot)创建绑定到指定端口的服务器套接字
? ? ? ? 实例方法
? ? ? ? Socket? ? ? ? ?accept()侦听要连接到此套接字并接受它。【阻塞主线程运行】
? ? ? ? void? ? ? ? close()关闭服务器
? ? ? ? 客户端程序的开发步骤：
? ? ? ?1. 创建客户端对象【Socket】，连接服务器??
? ? ? ?2.通过客户端对象【Socket】的getInputStream()/getOutputStream(),得到输入输出流
? ? ? ? 3.通过得到输入输出流对象调用read()/write()方法完成数据收发
? ? ? ? 4.关闭输入输出流和客户端对象【Socket】
? ? ? ? 服务端程序的开发步骤：
? ? ? ? 1.创建服务器端对象【ServerSocket】，开启服务器
? ? ? ? 2.通过服务器端对象【ServerSocket】的accept()方法，获得连接进入服务器的客户端对象【Socket】
? ? ? ? 3.连接进入服务器的客户端对象【Socket】的个getInputStream()/getOutputStream(),得到输入输出流
? ? ? ? 4.通过得到的输入输出流对象嗲用read()/write()方法完成数据收发
? ? ? ? 5.关闭输入输出流和客户端都西昂【Socket】以及服务器端对象【ServerSocket】。
例如1：完成客户端向服务器发送数据，服务器接收到客户端发送来的数据。
package com.test1;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
/**
* 客户端向服务器发送数据
* @author zxc
*
*/
public class ClientMain {
public static void main(String[] args) throws Exception {
//接收控制台数据的输入流对象
BufferedReader buff=null;
//定义保存服务器地址的对象【String】
InetAddress serverip=null;
//定义连接服务器的端口号
int serverprot=3001;
//定义创建客户端对象的Socket
Socket client=null;
//定义发送信息的输出流对象
OutputStream sendStream=null;
//定义保存被发送的数据
String info=null;
serverip=InetAddress.getLocalHost();
client=new Socket(serverip,serverprot);
sendStream=client.getOutputStream();
System.out.println("请输入需要发送的数据：");
buff=new BufferedReader(new InputStreamReader(System.in));
info=buff.readLine();
sendStream.write(info.getBytes());
sendStream.close();
buff.close();
client.close();
}
}
package com.test1;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class ServerMain {
public static void main(String[] args) throws Exception{
//定义服务器开发的端口号
int serverprot=3001;
//定义服务器对象
ServerSocket server=null;
//定义保存连接到服务器的客户端对象
Socket client=null;
//定义服务器接收客户端信息的输入流对象
InputStream in=null;
//定义保存客户端发送来的数据的字节数组
byte data[]=new byte[1024];
server=new ServerSocket(serverprot);
System.out.println("服务器已经启动，等待客户端连接......");
client=server.accept();
in=client.getInputStream();
int len=in.read(data);
//将读取来的保存在字节数组中的数据转换成字符串
String msg=new String(data,0,len);
System.out.println("服务器接收的信息是---"+msg);
in.close();
client.close();
server.close();
}
}
例如2：完成客户端持续向服务器发送数据，服务器持续接收到客户端发送来的数据
package com.test2;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
public class ClientMain {
public static void main(String[] args) throws Exception{
//接收控制台数据的输入流对象
BufferedReader buff=null;
//定义保存服务器地址的对象
InetAddress address=null;
//定义连接服务器端口号
int port=3002;
//定义创建客户端对象的Scoket
Socket client=null;
//定义发送信息的输出流对象
OutputStream out=null;
//定义保存被发送的数据
String info=null;
//定义控制持续输出的变量
boolean flag=true;
//得到本机服务器地址
address=InetAddress.getLocalHost();
//创建客户端对象
client=new Socket(address, port);
//发送信息
out=client.getOutputStream();
//从键盘输入
buff=new BufferedReader(new InputStreamReader(System.in));
while(flag){
System.out.println("请输入需要发送的数据");
info=buff.readLine();
out.write(info.getBytes());
if(info.equals("exit")){
flag=false;
}
}
client.close();
out.close();
buff.close();
}
}
package com.test2;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class ServerMain {
public static void main(String[] args) throws Exception{
int port=3002;
ServerSocket server=new ServerSocket(port);
System.out.println("服务器已经启动，等待客户端连接........");
Socket client=server.accept();
InputStream in=client.getInputStream();
byte data[]=new byte[1024];
boolean flag=true;
while(flag){
int len=in.read(data);
String info=new String(data,0,len);
System.out.println("服务器接收的信息是---"+info);
if(info.equals("exit")){
flag=false;
}
}
server.close();
client.close();
in.close();
}
}
例如3：完成客户端持续向服务器发送数据，还能接收服务器返回的信息，服务器持续接收到客户端发来的数据，还可以向客户端返回信息。
package com.test3;
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 ClientMain {
public static void main(String[] args) throws Exception{
InetAddress address=InetAddress.getLocalHost();
int port=3003;
//创建客户端对象
Socket client=new Socket(address, port);
OutputStream out=client.getOutputStream();
InputStream in=client.getInputStream();
//得到键盘输入
BufferedReader buff=new BufferedReader(new InputStreamReader(System.in));
boolean flag=true;
while(flag){
System.out.println("请输入需要发送的数据");
String info=buff.readLine();
out.write(info.getBytes());
byte data[]=new byte[1024];
int len=in.read(data);
String msg=new String(data,0,len);
System.out.println("数据库返回的结果是---"+msg);
if(msg.equals("exit")){
flag=false;
}
}
client.close();
out.close();
in.close();
buff.close();
}
}
package com.test3;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class ServerMain {
public static void main(String[] args) throws Exception{
int port=3003;
//创建服务器对象
ServerSocket server=new ServerSocket(port);
System.out.println("数据库已经启动，等待客户端连接.......");
Socket client=server.accept();
InputStream in=client.getInputStream();
OutputStream out=client.getOutputStream();
boolean flag=true;
byte data[]=new byte[1024];
while(flag){
int len=in.read(data);
String info=new String(data,0,len);
System.out.println("服务器接收到的信息是---"+info);
if(info.equals("exit")){
flag=false;
}else{
info="server--"+info;
}
out.write(info.getBytes());
}
server.close();
client.close();
in.close();
out.close();
}
}
例如4：多客户端，配置一台服务器，独立运行
package com.test4;
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 ClientMain {
public static void main(String[] args) throws Exception{
InetAddress address=InetAddress.getLocalHost();
int port=3004;
byte data[]=new byte[1024];
//创建客户端对象
Socket client=new Socket(address,port);
OutputStream out=client.getOutputStream();
InputStream in=client.getInputStream();
BufferedReader buff=new BufferedReader(new InputStreamReader(System.in));
boolean flag=true;
while(flag){
System.out.println("请输入需要发送的数据");
String info=buff.readLine();
out.write(info.getBytes());
int len=in.read(data);
String msg=new String(data,0,len);
System.out.println("服务器返回的结果是---"+msg);
if(msg.equals("exit")){
flag=false;
}
}
client.close();
out.close();
in.close();
buff.close();
}
}
package com.test4;
import java.net.ServerSocket;
import java.net.Socket;
public class ServerMain {
public static void main(String[] args) throws Exception{
int port=3004;
ServerSocket server=new ServerSocket(port);
System.out.println("服务器已经启动，等待客户端连接.....");
boolean flag=true;
while(flag){
Socket client=server.accept();
ThreadTest threads=new ThreadTest(client);
Thread thread=new Thread(threads);
thread.start();
}
server.close();
}
}
package com.test4;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
public class ThreadTest implements Runnable{
InputStream in=null;
OutputStream out=null;
Socket client=null;
boolean flag=true;
public ThreadTest(Socket client){
this.client=client;
}
@Override
public void run() {
try{
in=client.getInputStream();
out=client.getOutputStream();
byte data[]=new byte[1024];
while(flag){
int len=in.read(data);
String info=new String(data, 0, len);
System.out.println("服务器接收的信息是---"+info);
if(info.equals("exit")){
flag=false;
}else{
info="server"+info;
}
out.write(info.getBytes());
}
}catch(Exception e){
e.printStackTrace();
}finally{
try {
client.close();
in.close();
out.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}