【我的Java笔记】网络编程_TCP协议编程

最新推荐文章于 2021-12-19 12:27:11 发布

Enjoy96

最新推荐文章于 2021-12-19 12:27:11 发布

阅读量302

点赞数

本文链接：https://blog.csdn.net/Enjoy96/article/details/78780828

版权

TCP协议编程（客户端和服务器端）

1.TCP协议原理图解：

2.TCP协议通讯的特点：

（1）需要建立连接通道（通道内的流：使用最基本的字节流）

（2）属于可靠协议

（3）由于是可靠协议，并且需要建立连接通道（服务器端需要等待客户端连接），所以执行效率低

（4）使用TCP编程可以发送大量数据，对于发送文件大小无限制

3.TCP协议编程操作步骤：

（1）客户端：

①创建客户端的Socket对象

Socket s = new Socket(InetAddress,int port)

②获取通道内的流

字节输出流：OutputStream out = s.getOutputStream

③将数据写到通道内的流中发送到服务器端

out.write("hello".getBytes[])

④读取服务器端的反馈

InputStream in = s.getInputStream;

byte [] bys = new byte [1024];

int len = in.read(bys);

String str = new String(bys,0,len);

⑤释放资源

s.close()

（2）服务器端：

①创建服务器端ServerSocket对象

ServerSocket ss = new ServerSocket(int port)

②监听客户端的连接

Socket s = ss.accpet()

③获取通道内的流

InpuetStream in = s.getInputStream()

④解析通道内的流并输出至控制台

byte [] bys = new byte[1024];

len len = in.read(bys);

String str = new String(bys,0,len)

⑤服务器端反馈至客户端

OutputStream out = s.getOutputStream();

out.write("我收到了".getBytes());

⑥释放资源

s.close()

注：应先启动服务器端，再启动客户端，客户端和服务器端是需要建立连接通道的，如果没有启动服务器端先启动客户端，会报异常：Connection refused: connect :连接被拒绝

Socket（连接客户端和服务器端）

1.概述：此类实现客户端的“套接字”。套接字是两台机器间通讯的端点

2.构造方法：

（1）public Socket(InetAddress address,int port)创建一个流套接字并将其连接到指定 IP 地址的指定端口号

3.成员方法：

（1）public InputStream getInputStream() 返回此套接字的输入流
（2）public OutputStream getOutputStream() 返回此套接字的输出流

*（3）public void shutdownOutput() 禁用此套接字的输出流

注：通过shutdownOutput() 这个方法告诉服务器端，客户端没有数据了已经读取完毕，可以反馈了（一般用于有反馈的服务器端复制客户端的文件和图片等）（例4和例5）

ServerSocket

1.概述：此类实现服务器端套接字

2.构造方法：

public ServerSocket(int port) 创建绑定到特定端口的服务器套接字

3.成员方法：

public Socket accept() 侦听并接受到此套接字的连接

注：此方法在连接传入之前一直阻塞

例1：服务器端收取客户端的数据，并给予客户端反馈

// 客户端
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

public class Client {

	public static void main(String[] args) throws IOException {
		// (1)创建客户端Socket对象
		Socket s = new Socket("192.168.1.108",1234);
		
		// (2)获取通道内的输出流
		OutputStream out = s.getOutputStream();
		
		// (3)将数据输入通道内的流发送到服务器端
		out.write("hello".getBytes());
		
		// (4)收取服务器端的反馈
		InputStream in = s.getInputStream();
		byte [] bys = new byte [1024];
		int len = in.read(bys);
		System.out.println(new String(bys,0,len));
		
		// (5)释放资源
		s.close();
	}
}

// 服务器端
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {

	public static void main(String[] args) throws IOException {
		// (1)创建服务器端ServerSocket对象
		ServerSocket ss = new ServerSocket(1234);
		
		// (2)创建服务器端Socket对象
		Socket s = ss.accept();		// 此方法在接收到数居前一直处于阻塞状态
		
		// (3)获取通道内的输入流
		InputStream in = s.getInputStream();
		
		// (4)读取流内的数据
		byte [] bys = new byte [1024];
		int len = in.read(bys);
		String str = new String(bys,0,len);
		
		InetAddress address = s.getInetAddress();	// 获取IP地址
		String ip = address.getHostAddress();
		
		System.out.println(ip+"传递的数据是："+str);
		
		// (5)反馈信息给客户端
		OutputStream out = s.getOutputStream();
		out.write("信息已收到".getBytes());
		
		// (5)释放资源
		s.close();
	}
}

结果：

服务器端：

客户端：

例2：客户端键盘录入数据，服务器端将数据读出

// 客户端
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.Socket;

public class Client {

	public static void main(String[] args) throws IOException {
		// 创建客户端socket对象
		Socket s = new Socket("192.168.1.108", 1234);

		// 使用IO流的方式获取键盘录入的数据
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		// 使用字符缓冲流封装通道内的流
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));

		// 读取键盘录入的数据，并写入通道内的流中
		String line = null;
		while ((line = br.readLine()) != null) {
			// 自定义结束录入的条件
			if ("over".equals(line)) {
				break;
			}

			bw.write(line);
			bw.newLine();
			bw.flush();
		}

		// 释放资源
		br.close();
		s.close();
	}
}

// 服务器端
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {

	public static void main(String[] args) throws IOException {
		// 创建服务器端ServerSocket对象
		ServerSocket ss = new ServerSocket(1234);

		System.out.println("等待客户端连接...");
		
		// 获取服务器端Socket对象
		Socket s = ss.accept();
		System.out.println("客户端已连接！");

		// 使用BufferedReader封裝通道內的输入流
		BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
		
		// 读取通道内的流中的数据，并打印在控制台
		String line = null;
		while ((line = br.readLine()) != null) {
			System.out.println(line);
		}

		// 释放资源
		s.close();
	}
}

例3：客户端键盘录入数据，服务器端将录入的数据输出到文本文件

//客户端
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.Socket;

public class Client {

	public static void main(String[] args) throws IOException {
		// 创建客户端socket对象
		Socket s = new Socket("192.168.1.108", 1234);

		// 使用IO流的方式获取键盘录入的数据
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		// 使用字符缓冲流封装通道内的流
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));

		// 读取键盘录入的数据，并写入通道内的流中
		String line = null;
		while ((line = br.readLine()) != null) {
			// 自定义结束录入的条件
			if ("over".equals(line)) {
				break;
			}

			bw.write(line);
			bw.newLine();
			bw.flush();
		}

		// 释放资源
		br.close();
		s.close();
	}
}

//服务器端
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {

	public static void main(String[] args) throws IOException {
		// 创建服务器端ServerSocket对象
		ServerSocket ss = new ServerSocket(1234);

		System.out.println("等待客户端连接...");
		
		// 获取服务器端Socket对象
		Socket s = ss.accept();
		System.out.println("客户端已连接！");

		// 使用BufferedReader封裝通道內的输入流
		BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
		
		// 服务器端输出数据到文本文件
		BufferedWriter bw = new BufferedWriter(new FileWriter("a.txt"));
		
		// 读取通道内的流中的数据，并输出到文本文件中
		String line = null;
		while ((line = br.readLine()) != null) {
			bw.write(line);
			bw.newLine();
			bw.flush();
		}
		
		// 释放资源
		bw.close();
		s.close();
	}
}

客户端给服务器端上传文件或者图片

例4：客户端文本文件，服务器端将此文本文件复制到一个新的文本文件中，完成后并给客户端反馈

此中方式需在客户端读取完成时加上shutdownOutput() 判定读取完毕

// 客户端
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStreamWriter;
import java.net.Socket;

public class UploadClient {

	public static void main(String[] args) throws IOException{
		// (1)创建套接字对象
		Socket s = new Socket("192.168.1.108",1234);
		
		// (2)封装通道内的流
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
		
		// (3)读取文件并写入通道内的流中
		BufferedReader br = new BufferedReader(new FileReader("a.txt"));
		
		String line = null;
		while((line = br.readLine())!=null){
			bw.write(line);
			bw.newLine();
			bw.flush();
		}
		
		
		// (4)判断数据读取完毕
		s.shutdownOutput();
		/*
		 * // 另一种方式：写入结束标记
		 *	bw.write("over");
		 *	bw.newLine();
		 *	bw.flush();
		 *
		 *	此种方式存在弊端，如果文件中也存在over这个关键字则会没有读完文件提前结束
		 * */
		
		// (5)获取服务器端的反馈
		InputStream in = s.getInputStream();
		byte [] bys = new byte [1024];
		int len = in.read(bys);
		System.out.println(new String(bys,0,len));
		
		// (6)释放资源
		br.close();
		s.close();
		
	}
}

// 服务器端
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class UploadServer {

	public static void main(String[] args) throws IOException {

		// (1)创建服务器端套接字对象
		ServerSocket ss = new ServerSocket(1234);
		
		// (2)获取Socket对象
		Socket s = ss.accept();

		// (3)封装通道内的流
		BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));

		// (4)读取通道内的流中的数据，并写入copy.txt文件中
		BufferedWriter bw = new BufferedWriter(new FileWriter("copy.txt"));

		String line = null;
		while ((line = br.readLine()) != null) {
			/*
			 * // 另一种方式：判断自定义结束标记 
			 * if("over".equals(line)){ 
			 * 		break; 
			 * }
			 * 
			 */

			bw.write(line);
			bw.newLine();
			bw.flush();
		}

		// (5)读取完毕后，反馈信息给客户端
		OutputStream out = s.getOutputStream();
		out.write("数据已复制完成".getBytes());

		// (6)释放资源
		bw.close();
		s.close();
	}
}

例5：客户端的图片文件，服务器端复制此图片，完成后并给客户端反馈（shundownOutput() 方法的应用）

// 客户端
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.Socket;

public class UploadClient {

	public static void main(String[] args) throws IOException{
		
		// (1)创建客户端套接字对象
		Socket s = new Socket("192.168.1.108",1234);
		
		// (2)封装通道内的流
		BufferedOutputStream bos = new BufferedOutputStream(s.getOutputStream());
		
		// (3)创建BufferedInputStream对象读取图片
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream("Reus.jpg"));
		
		byte [] bys = new byte [1024];
		int len = 0;
		while((len = bis.read(bys))!=-1){
			bos.write(bys, 0, len);
			bos.flush();
		}
		
		// (4)判断文件读取完毕
		s.shutdownOutput();
		
		// (5)封装通道内的输入流读取服务器的反馈
		InputStream in = s.getInputStream();
		byte [] bys2 = new byte [1024];
		int len2 = in.read(bys2);
		System.out.println(new String(bys2,0,len2));
		
		// (6)释放资源
		bis.close();
		s.close();
	}
}

// 服务器端
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class UploadServer {

	public static void main(String[] args) throws IOException{
		// (1)创建服务器端ServerSocket对象
		ServerSocket ss = new ServerSocket(1234);
		
		// (2)获取服务器端Socket对象
		Socket s = ss.accept();
		
		// (3)封装通道内的流
		BufferedInputStream bis = new BufferedInputStream(s.getInputStream());
		
		// (4)创建BufferedOutputStream 读取数据并写入
		BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.jpg"));
		
		byte [] bys = new byte [1024];
		int len = 0;
		while((len = bis.read(bys))!=-1){
			bos.write(bys, 0, len);
			bos.flush();
		}
		
		
		// (5)反馈数据
		OutputStream out = s.getOutputStream();
		out.write("图片上传成功".getBytes());
		out.flush();
		
		// 释放资源
		bos.close();
		s.close();
	}
}