黑马程序员java之网络通讯

最新推荐文章于 2024-06-19 11:00:59 发布

Zero_120_1

最新推荐文章于 2024-06-19 11:00:59 发布

阅读量409

点赞数

分类专栏： java基础

本文链接：https://blog.csdn.net/Zero_120_1/article/details/48224757

版权

java基础专栏收录该内容

12 篇文章 0 订阅

订阅专栏

　------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------

网络通讯要素。

IP地址：网络号码+主机地址

网络中设备的标识。

不易记忆，可用主机名。

本地回环地址：127.0.0.1.主机名:localhost

端口号：

计算机为了标识应用程序，把这些应用程序都用数字记性标识。这些数字我们成为端口逻辑端口。

用于标识进程的逻辑地址，不同进程的标识。

有效的端口号为0-65535，其中，0-1024为系统使用或称为保留端口。

传输协议：

通讯的规则。

常见的通讯协议为 TCP,UDP.

UDP:

将数据，源和目的封装成数据包，不需要建立连接。

每个数据包的大小限制在64K内。

因为无连接，所以是不可靠协议，会丢失数据包。

因为不需要建立连接，所以速度快。

TCP:

需要建立连接，形成传输数据的通道。

在连接中可以进行大量数据传送。

通过三次握手的动作完成连接，所以是可靠协议。

因为必须建立连接，所以它的效率会稍微低。

Socket：套接字，通信的端点。

就是为网络服务提供的一种机制，通信的两端都有Socket，网络通信其实就是Socket间的通信，数据在两个Socket间通过IO传输。

UDP传输：

1，只要是网络传输，必须有socket。

2，数据一定要封装到数据包中，数据包中包括目的地址、端口、数据等信息。

直接操作udp不可能，对于java语言应该将udp封装成对象，易于我们的使用，这个对象就是DatagramSocket.封装了udp传输协议的socket对象。

因为数据包中包含的信息较多，为了操作这些信息方便，也一样会将其封装成对象。这个数据包对象就是：DatagramPacket.通过这个对象中的方法，就可以获取到数据包中的各种信息。

DatagramSocket具备发送和接受功能，在进行udp传输时，需要明确一个是发送端，一个是接收端。

udp的发送端：

1，建立udp的socket服务，创建对象时如果没有明确端口，系统会自动分配一个未被使用的端口。

2，明确要发送的具体数据。

3，将数据封装成了数据包。64k内

4，用socket服务的send方法将数据包发送出去。

5，关闭资源。

import java.net.*;
class  UdpSend
{
	public static void main(String[] args) throws Exception
	{
		//1，创建udp服务。通过DatagramSocket对象。
		DatagramSocket ds = new DatagramSocket(8888);

		//2，确定数据，并封装成数据包。DatagramPacket(byte[] buf, int length, InetAddress address, int port) 

		byte[] buf = "udp ge men lai le ".getBytes();
		DatagramPacket dp = 
			new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.254"),10000);

		//3，通过socket服务，将已有的数据包发送出去。通过send方法。
		ds.send(dp);

		//4，关闭资源。

		ds.close();

	}
}

udp的接收端：

1，创建udp的socket服务，必须要明确一个端口，作用在于，只有发送到这个端口的数据才是这个接收端可以处理的数据。

2，定义数据包，用于存储接收到数据。

3，通过socket服务的接收方法将收到的数据存储到数据包中。

4，通过数据包的方法获取数据包中的具体数据内容，比如ip、端口、数据等等。

5，关闭资源。

import java.net.DatagramPacket;
import java.net.DatagramSocket;

class  UdpRece
{
	public static void main(String[] args) throws Exception
	{
		//1,创建udp socket，建立端点。
		DatagramSocket ds = new DatagramSocket(10000);
		while(true)
		{
		//2,定义数据包。用于存储数据。
		byte[] buf = new byte[1024];
		DatagramPacket dp = new DatagramPacket(buf,buf.length);

		//3，通过服务的receive方法将收到数据存入数据包中。
		ds.receive(dp);//阻塞式方法。
		

		//4，通过数据包的方法获取其中的数据。
		String ip = dp.getAddress().getHostAddress();

		String data = new String(dp.getData(),0,dp.getLength());

		int port = dp.getPort();

		System.out.println(ip+"::"+data+"::"+port);

		}
		//5，关闭资源
		//ds.close();

	}
}

编写一个聊天工具

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

/*
编写一个聊天程序。
有收数据的部分，和发数据的部分。
这两部分需要同时执行。
那就需要用到多线程技术。
一个线程控制收，一个线程控制发。

因为收和发动作是不一致的，所以要定义两个run方法。
而且这两个方法要封装到不同的类中。

*/
class Send implements Runnable
{
	private DatagramSocket ds;
	public Send(DatagramSocket ds)
	{
		this.ds = ds;
	}


	public void run()//开启线程
	{
		try
		{	//键盘录入
			BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));

			String line = null;

			while((line=bufr.readLine())!=null)
			{
				

				byte[] buf = line.getBytes();
				//
				DatagramPacket dp = 
					new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.255"),10002);
				//通过socket服务，将已有的数据包发送出去。通过send方法
				ds.send(dp);
				//当输入886 结束
				if("886".equals(line))
					break;
			}
		}
		catch (Exception e)
		{
			throw new RuntimeException("发送端失败");
		}
	}
}

class Rece implements Runnable
{

	private DatagramSocket ds;
	public Rece(DatagramSocket ds)
	{
		this.ds = ds;
	}
	public void run()
	{
		try
		{
			while(true)
			{
				byte[] buf = new byte[1024];
				DatagramPacket dp = new DatagramPacket(buf,buf.length);
				//通过服务的receive方法将收到数据存入数据包中。
				ds.receive(dp);

				//通过数据包的方法获取其中的数据。
				String ip = dp.getAddress().getHostAddress();

				String data = new String(dp.getData(),0,dp.getLength());

				if("886".equals(data))
				{
					System.out.println(ip+"....离开聊天室");
					break;
				}


				System.out.println(ip+":"+data);
			}
		}
		catch (Exception e)
		{
			throw new RuntimeException("接收端失败");
		}
	}
}


class  ChatDemo
{
	public static void main(String[] args) throws Exception
	{
		DatagramSocket sendSocket = new DatagramSocket();
		DatagramSocket receSocket = new DatagramSocket(10002);

		new Thread(new Send(sendSocket)).start();
		new Thread(new Rece(receSocket)).start();

	}
}

TCP传输：两个端点的建立连接后会有一个传输数据的通道，这通道称为流，而且是建立在网络基础上的流，称之为socket流。该流中既有读取，也有写入。

tcp的两个端点：一个是客户端，一个是服务端。

客户端：对应的对象，Socket

服务端：对应的对象，ServerSocket

TCP客户端：

1，建立tcp的socket服务，最好明确具体的地址和端口。这个对象在创建时，就已经可以对指定ip和端口进行连接(三次握手)。

2，如果连接成功，就意味着通道建立了，socket流就已经产生了。只要获取到socket流中的读取流和写入流即可，只要通过getInputStream和getOutputStream就可以获取两个流对象。

3，关闭资源。

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


class  TcpClient
{
	public static void main(String[] args) throws Exception 
	{
		//创建客户端的socket服务。指定目的主机和端口
		Socket s = new Socket("192.168.1.254",10003);
		
		//为了发送数据，应该获取socket流中的输出流。
		OutputStream out = s.getOutputStream();

		out.write("tcp ge men lai le ".getBytes());


		s.close();
	}
}

TCP服务端：

1，创建服务端socket服务，并监听一个端口。

2，服务端为了给客户端提供服务，获取客户端的内容，可以通过accept方法获取连接过来的客户端对象。

3，可以通过获取到的socket对象中的socket流和具体的客户端进行通讯。

4，如果通讯结束，关闭资源。注意：要先关客户端，再关服务端。

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

class  TcpServer
{
	public static void main(String[] args) throws Exception
	{
		//建立服务端socket服务。并监听一个端口。
		ServerSocket ss = new ServerSocket(10003);

		//通过accept方法获取连接过来的客户端对象。
		while(true)
		{
		Socket s = ss.accept();

		String ip = s.getInetAddress().getHostAddress();
		System.out.println(ip+".....connected");

		//获取客户端发送过来的数据，那么要使用客户端对象的读取流来读取数据。
		InputStream in = s.getInputStream();
		
		byte[] buf = new byte[1024];
		int len = in.read(buf);

		System.out.println(new String(buf,0,len));

		s.close();//关闭客户端.
		}
		//ss.close();
	}
}

客户端给服务端发送数据，服务端收到后，给客户端反馈信息。

import java.io.*;
import java.net.*;
/*
演示tcp的传输的客户端和服务端的互访。

需求：客户端给服务端发送数据，服务端收到后，给客户端反馈信息。

*/

/*
客户端：
1，建立socket服务。指定要连接主机和端口。
2，获取socket流中的输出流。将数据写到该流中。通过网络发送给服务端。
3，获取socket流中的输入流，将服务端反馈的数据获取到，并打印。
4，关闭客户端资源。

*/
class TcpClient2 
{
	public static void main(String[] args)throws Exception 
	{	//创建客户端的socket服务。指定目的主机和端口
		Socket s = new Socket("192.168.1.254",10004);
		//为了发送数据，应该获取socket流中的输出流
		OutputStream out = s.getOutputStream();

		out.write("服务端，你好".getBytes());

		//接收数据
		InputStream in = s.getInputStream();

		byte[] buf = new byte[1024];

		int len = in.read(buf);

		System.out.println(new String(buf,0,len));

		s.close();//关闭
	}
}


class TcpServer2
{
	public static void main(String[] args) throws Exception
	{	//建立服务端socket服务。并监听一个端口。
		ServerSocket ss = new ServerSocket(10004);

		Socket s = ss.accept();

		String ip = s.getInetAddress().getHostAddress();
		System.out.println(ip+"....connected");
		//获取客户端发送过来的数据，
		InputStream in = s.getInputStream();

		byte[] buf = new byte[1024];

		int len = in.read(buf);

		System.out.println(new String(buf,0,len));

		//回馈客户端发出的信息
		OutputStream out = s.getOutputStream();

		out.write("哥们收到,你也好".getBytes());

		s.close();

		ss.close();
	}
}

Zero_120_1

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员java之网络通讯

------- android培训、java培训、期待与您交流！ ----------网络通讯要素。 IP地址：网络号码+主机地址网络中设备的标识。不易记忆，可用主机名。本地回环地址：127.0.0.1.主机名:localhost 端口号：计算机为了标识应用程序，把这些应用程序都用数字记性标识。这些数字我们成为端口
复制链接

扫一扫