黑马程序员—网络编程之TCP

最新推荐文章于 2022-07-22 16:59:35 发布

浪子有情_

最新推荐文章于 2022-07-22 16:59:35 发布

阅读量432

点赞数

分类专栏： java基础文章标签：黑马程序员

本文链接：https://blog.csdn.net/u013648671/article/details/19639097

版权

java基础专栏收录该内容

12 篇文章 0 订阅

订阅专栏

TCP的传输建立主要依靠2个类：Socket和ServerSocket。

TCP协议传输的简单演示：

/*
演示tcp传输

1，tcp分客户端和服务端
2，客户端对应的对象是Socket
	 服务端对应的对象时ServerSocket
	 	 
*/

/*
客户端
通过查阅socket对象，发现在该对象建立时，就可以去连接指定的主机
因为tcp是面向连接的，所以在建立socket服务时，就要有服务端存在并连接成功。
形成通路后，在该通道进行数据的传输。

需求：给服务端发送一个文本数据。

步骤：
1，创建Socket服务并指定要连接的主机和端口。
2，
*/

import java.io.*;
import java.net.*;
class TcpClient
{
	public static void main(String[] args) throws Exception
	{
		//创建客户端的socket服务，指定目的主机和端口
		Socket s = new Socket("192.168.1.107",10005);
		 
		//为了发送数据，应该获取socket流中的输出流 
		OutputStream out = s.getOutputStream();
		
		out.write("tcp ge men lai le !".getBytes());
		s.close(); 
			
	}
	
}


/*
需求：定义端点接收数据并打印在控制台上

服务端：
1，建立服务端的socket服务，通过ServerSocket();
	 并监听一个端口。
2，获取连接过来的客户端对象。
	 通过ServerSocket的accept方法，没有连接就会等待，所以这个方法是阻塞式的。
3，客户端如果发过来数据，那么服务端要使用对应的客户端对象，获取到该客户端对象
	 的读取流，来读取发过来的数据，并打印在控制台
4，关闭服务端。（可选操作）
*/
class TcpServer
{
	public static void main(String[] args) throws Exception
	{
		//建立服务端的socket服务，并监听一个端口
		ServerSocket ss = new ServerSocket(10005);
		
		//通过accept方法获取连接过来的客户端对象
		Socket s = ss.accept();
		
		//获取客户端发送过来的数据，那么要使用客户端对象的读取流来读取数据
		
		InputStream in = s.getInputStream();
		
		byte[] buf = new byte[1024];
		int len = in.read(buf);
		System.out.println(new String(buf,0,len));
		
		String ip = s.getInetAddress().getHostAddress();
		System.out.println("ip::"+ip); 
		
		s.close();//关闭客户端，服务端可能不关闭自己，但要关闭客户端
		ss.close();
	}
	
}

ServerSocket的构造方法ServerSocket(int port,int backlog)，其中backlog指的是能连接到服务器的客户端的最大个数。

用TCP协议演示客户端给服务端上传图片：

/*
需求：上传图片。
*/
/*
客户端。
1、服务端点。
2、读取客户端已有的图片数据。
3、通过socket输出流将数据发给服务端。
4、读取服务端反馈信息。
5、关闭

*/
import java.io.*;
import java.net.*;

class PicClient
{
	 public static void main(String[] args) throws Exception
	 {
	 	 Socket s = new Socket("192.168.1.107",10008);
	 	 
	 	 FileInputStream fis = new FileInputStream("C:\\7ZhICOu.jpg");
	 	 
	 	 OutputStream out = s.getOutputStream();
	 	 
	 	 byte[] buf = new byte[1024];
	 	 
	 	 int len = 0;
	 	 
	 	 while((len=fis.read(buf))!=-1)
	 	 {
	 	 		out.write(buf,0,len);
	 	 	
	 	 }
	 	 //告诉服务端数据已经写完
	 	 s.shutdownOutput();
	 	 
	 	 InputStream in = s.getInputStream();
	 	 
	 	 byte[] bufIn = new byte[1024];
	 	 
	 	 int num = in.read(bufIn);
	 	 System.out.println(new String(bufIn,0,num));
	 	 
	 	 fis.close();
	 	 s.close();
	 }
	
}

/*
服务端。

这个服务端有个局限性，当A客户端连接上以后，被服务端获取到，服务端执行具体流程。
这时B客户端连接，只有等待。
因为服务端还没有处理完A客户端的请求，还没有循环回来执行下次accept方法。
所以暂时获取不到B客户端对象。

那么为了可以让多个客户端同时并发访问服务端。
服务端最好就是将每个客户端封装到一个单独的线程中，这样就可以同时处理多个客户端请求。


如何定义线程呢？

只要明确了每一个客户端要在服务端执行的代码即可，将该代码存入run方法中。
*/


class PicServer
{
	 public static void main(String[] args)throws Exception
	 {
	 	 ServerSocket ss = new ServerSocket(10008);
	 	 
	 	 Socket s = ss.accept();
	 	 
	 	 InputStream in = s.getInputStream();
	 	 
	 	 FileOutputStream fos = new FileOutputStream("server.bmp");
	 	 
	 	 byte[] buf = new byte[1024];
	 	 
	 	 int len = 0;
	 	 while((len= in.read(buf))!=-1)
	 	 {
	 	 		fos.write(buf,0,len);
	 	 }
	 		
	 	s.getOutputStream().write("上传成功".getBytes());
	 	
	 	 fos.close();
	 	 s.close();
	 	 ss.close();
	 		
	 }
	
}

将上面的例子进行改进，可以多个客户端并行连接并且上传图片：

/*
需求：上传图片。
*/
/*
客户端。
1、服务端点。
2、读取客户端已有的图片数据。
3、通过socket输出流将数据发给服务端。
4、读取服务端反馈信息。
5、关闭

*/
import java.io.*;
import java.net.*;

class PicClient
{
	 public static void main(String[] args) throws Exception
	 {
	 	if(args.length!=1)
	 	{
	 		System.out.println("请选择一个jpg格式的图片");
	 		return;
	 	}
	 	
	 	File file = new File(args[0]);
	 	if(!(file.exists()&&file.isFile()))
	 	{
	 		System.out.println("该文件有问题，要么不存在，要么不是文件");
	 	  return;
	 	}
	 	
	 	if(!file.getName().endsWith(".jpg"))
	 	{
	 		System.out.println("图片格式错误，请重新选择");
	 		return;
	 	}
	 	
	 	if(file.length()>1024*1024*5)
	 	{
	 		System.out.println("文件过大");
	 		return;
	 	}
	 	
	 	 Socket s = new Socket("192.168.1.107",10008);
	 	 
	 	 FileInputStream fis = new FileInputStream(file);
	 	 
	 	 OutputStream out = s.getOutputStream();
	 	 
	 	 byte[] buf = new byte[1024];
	 	 
	 	 int len = 0;
	 	 
	 	 while((len=fis.read(buf))!=-1)
	 	 {
	 	 		out.write(buf,0,len);
	 	 	
	 	 }
	 	 //告诉服务端数据已经写完
	 	 s.shutdownOutput();
	 	 
	 	 InputStream in = s.getInputStream();
	 	 
	 	 byte[] bufIn = new byte[1024];
	 	 
	 	 int num = in.read(bufIn);
	 	 System.out.println(new String(bufIn,0,num));
	 	 
	 	 fis.close();
	 	 s.close();
	 }
	
}

/*
服务端。

这个服务端有个局限性，当A客户端连接上以后，被服务端获取到，服务端执行具体流程。
这时B客户端连接，只有等待。
因为服务端还没有处理完A客户端的请求，还没有循环回来执行下次accept方法。
所以暂时获取不到B客户端对象。

那么为了可以让多个客户端同时并发访问服务端。
服务端最好就是将每个客户端封装到一个单独的线程中，这样就可以同时处理多个客户端请求。


如何定义线程呢？

只要明确了每一个客户端要在服务端执行的代码即可，将该代码存入run方法中。
*/
class picThread implements Runnable
{
	private Socket s;
	picThread(Socket s)
	{
		this.s = s;
	}
		
	public void run()
	{
		String ip = s.getInetAddress().getHostAddress();
		try
		{
			int count = 1;
			System.out.println(ip+"......connected");
			InputStream in = s.getInputStream();
			
			File file = new File(ip+"("+(count)+")"+".jpg");
			while(file.exists())
			file = new File(ip+"("+(count++)+")"+".jpg");
			
	 	 
	 	 	FileOutputStream fos = new FileOutputStream(file);
	 	 
	 	 	byte[] buf = new byte[1024];
	 	 
	 	 	int len = 0;
	 	 	while((len= in.read(buf))!=-1)
	 	 	{
	 	 		fos.write(buf,0,len);
	 	 	}
	 		
	 		s.getOutputStream().write("上传成功".getBytes());
	 	
	 	 	fos.close();
	 	 	s.close();
	 	 
		}
		
		catch(Exception e)
		{
			throw new RuntimeException(ip+"上传失败");
		}
	}
	
}


class PicServer
{
	 public static void main(String[] args)throws Exception
	 {
	 	 ServerSocket ss = new ServerSocket(10008);
	 	 
	 	 while(true)
	 	 {
	 	 	Socket s = ss.accept();
	 	 	
	 	 	new Thread(new picThread(s)).start();
	   }
	 //	 ss.close();
	 		
	 }
	
}

建立一个文本转换器：

/*
需求：建立一个文本转换服务器。

客户端给服务端发送文本，服务端会将文本转成大写再返回给客户端。
而且客户端可以不断的进行文本转换，当客户端输入over时，转换就结束。

分析：
客户端：
既然是操作设备上的数据，那么就可以使用io技术，并按照io的操作规律来思考。
源：键盘录入。
目的：网络设备，网络输出流。
而且操作的是文本数据。可以选择字符流。

步骤：
1，建立服务。
2，获取键盘录入。
3，将数据发给服务端。
4，获取服务端返回的大写数据。
5，结束，关资源。

都是文本数据，可以使用字符流进行操作，同时提高效率，加入缓冲。




*/
import java.net.*;
import java.io.*;
class TransClient
{
	public static void main(String[] args)throws Exception
	{
		Socket s = new Socket("192.168.1.107",10005);
		
		//定义读取键盘数据的流对象
		BufferedReader bufr = 
				new BufferedReader(new InputStreamReader(System.in));
		
		//定义目的，将数据写入到socket输出流，发给服务端
		BufferedWriter bufwOut =
				new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
	
	  //定义一个socke读取流，读取服务端返回的大写信息
	  BufferedReader bufIn = 
	  		new BufferedReader(new InputStreamReader(s.getInputStream()));
	  
	  PrintWriter out = new PrintWriter(s.getOutputStream(),true);
	  
		String line = null;
		
		while((line=bufr.readLine())!=null)
		{
			if(line.equals("over"))
				break;
	
			out.println(line);			
//			bufwOut.write(line);
//			bufwOut.newLine();
//			bufwOut.flush();
			
			String str = bufIn.readLine();
			System.out.println("server:"+str);
		}
		
		s.close();
		bufr.close();
		
	
	}
}

/*
服务端：
源：socket读取流
目的：socket输出流
都是文本，装饰
*/
class TransServer
{
	public static void main(String[] args) throws Exception
	{
		ServerSocket ss = new ServerSocket(10005);
		Socket s = ss.accept();
		
		String ip = s.getInetAddress().getHostAddress();
		System.out.println(ip+".....connected");
		
		//读取socket读取流中的数据
		BufferedReader bufIn = 
				new BufferedReader(new InputStreamReader(s.getInputStream()));
		
		//目的，socket输出流，将大写数据写入到socket输出流，并发送给客户端
		BufferedWriter  bufOut=
				new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
						
	  PrintWriter out = new PrintWriter(s.getOutputStream(),true);
	  
	  String line = null;
	  while((line = bufIn.readLine())!=null)
	  {
	  	System.out.println(line);
			
			out.println(line.toUpperCase());
//	  	bufOut.write(line.toUpperCase());
//	  	bufOut.newLine();
//	  	bufOut.flush();
	  	
	  }
		
		s.close();
		ss.close();
		
	}
}

/*
该例子出现的问题。
现象：客户端和服务端都在莫名的等待，这时为什么呢？
因为客户端和服务端都是阻塞式的方法，这些方法没有读到结束标记，就会一直等，
而导致两端都在等待。

*/

客户并发登陆：

/*
客户端通过键盘录入用户名。
服务端对这个用户名进行校验。

如果用户名存在，在服务端显示xxx，已登录。
并在客户端显示xxx，欢迎光临。

如果该用户不存在，在用户端显示xxx，尝试登陆。
并在客户端显示xxx，该用户不存在。

最多就登陆三次
*/

import java.io.*;
import java.net.*;

class LoginClient
{
	public static void main(String[] args) throws Exception
	{
		Socket s = new Socket("192.168.1.107",10008);
		
		BufferedReader bufr = 
				new BufferedReader(new InputStreamReader(System.in));
		
		PrintWriter out = 
				new PrintWriter(s.getOutputStream(),true);
		
		BufferedReader bufIn = 
				new BufferedReader(new InputStreamReader(s.getInputStream()));
		
		for(int x=0;x<3;x++)
		{
			String line = bufr.readLine();
			if(line==null)
				break;
			out.println(line);
			
			String info = bufIn.readLine();
			System.out.println("info:"+info);
			if(info.contains("欢迎"))
				break;
		}
			
		bufr.close();
		s.close();
	}
}

class LoginServer
{
	public static void main(String[] args) throws Exception
	{
		ServerSocket ss = new ServerSocket(10008);
		while(true)
		{
			Socket s = ss.accept();
			new Thread(new UserThread(s)).start();
		}
		
	}
}

class UserThread implements Runnable
{
	private Socket s;
	UserThread(Socket s)
	{
		this.s = s;
	}
	
	
	public void run()
	{
		String ip = s.getInetAddress().getHostAddress();
		System.out.println(ip+"......connected");
		try
		{
			for(int x=0;x<3;x++)
			{
				BufferedReader bufIn = 
						new BufferedReader(new InputStreamReader(s.getInputStream()));
				
				PrintWriter out = new PrintWriter(s.getOutputStream(),true);
				
				String name = bufIn.readLine();
				if(name == null)
					break;
//				if(name.equals("\r\n"))
//				{
//					out.println("请输入用户名");
//					continue;
//				}
				
				BufferedReader bufr = new BufferedReader(new FileReader("user.txt"));
				
				String line = null;
				
				boolean flag = false;
				while((line = bufr.readLine())!=null)
				{
					if(line.equals(name))
					{
						flag = true;
						break;
					}
				}
				
					if(flag)
					{
						System.out.println(name+",已登录");
						out.println(name+",欢迎光临");
						break;
					}
					else
					{
						System.out.println(name+",尝试登陆");
						out.println(name+",用户名不存在");
						
					}
			}
			s.close();
		}
		catch(Exception e)
		{
			throw new RuntimeException(ip+"校验失败");
		}
	}
	
}

要注意的问题：

通路建立了之后，其内部已经封装好了输入输出流，只需用方法获取到这两个流对象就可以使用了。

因为是面向连接的，所以必须先启动服务端。

InetAddress封装的是ip地址，SocketAddress的子类InetSocketAddress封装的是IP地址和端口号。

URL的使用

URL url = new URL("http://192.168.1.107:8080/myweb/demo.html");

URLConnection conn = url.openConnection();

上述操作后就已经连接到主机，无需再使用socket，该对象将应用层的请求头和应用头都封装好了。

浪子有情_

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员—网络编程之TCP

TCP的传输建立主要依靠2个类：Socket和ServerSocket。TCP协议传输的简单演示：/*演示tcp传输1，tcp分客户端和服务端2，客户端对应的对象是Socket 服务端对应的对象时ServerSocket *//*客户端通过查阅socket对象，发现在该对象建立时，就可以去连接指定的主机因为tcp是面向连接的，所以在建立socket服务时，就
复制链接

扫一扫