javaSE-网络

最新推荐文章于 2025-03-27 18:48:15 发布

原创最新推荐文章于 2025-03-27 18:48:15 发布 · 636 阅读

0 ·

CC 4.0 BY-SA版权

javaSE 专栏收录该内容

57 篇文章

订阅专栏

l网络模型

•OSI（OpenSystem Interconnection开放系统互连）参考模型

•TCP/IP参考模型

l网络通讯要素

•IP地址

•端口号

•传输协议

网络参考模型

七层简述

1.层物理层：主要定义物理设备标准，如网线的接口类型、光纤的接口类型、各种传输介质的传输速率等。它的主要作用是传输比特流（就是由1、0转化为电流强弱来进行传输,到达目的地后在转化为1、0，也就是我们常说的数模转换与模数转换）。这一层的数据叫做比特。

2.层数据链路层：主要将从物理层接收的数据进行MAC地址（网卡的地址）的封装与解封装。常把这一层的数据叫做帧。在这一层工作的设备是交换机，数据通过交换机来传输。

3.层网络层：主要将从下层接收到的数据进行IP地址（例192.168.0.1)的封装与解封装。在这一层工作的设备是路由器，常把这一层的数据叫做数据包。

4.层传输层：定义了一些传输数据的协议和端口号（WWW端口80等），如：TCP（传输控制协议，传输效率低，可靠性强，用于传输可靠性要求高，数据量大的数据），UDP（用户数据报协议，与TCP特性恰恰相反，用于传输可靠性要求不高，数据量小的数据，如QQ聊天数据就是通过这种方式传输的）。主要是将从下层接收的数据进行分段和传输，到达目的地址后再进行重组。常常把这一层数据叫做段。

5.会话层：通过传输层（端口号：传输端口与接收端口）建立数据传输的通路。主要在你的系统之间发起会话或者接受会话请求（设备之间需要互相认识可以是IP也可以是MAC或者是主机名）

6.表示层：主要是进行对接收的数据进行解释、加密与解密、压缩与解压缩等（也就是把计算机能够识别的东西转换成人能够能识别的东西（如图片、声音等）。

7.应用层：主要是一些终端的应用，比如说FTP（各种文件下载），WEB（IE浏览），QQ之类的（可以把它理解成我们在电脑屏幕上可以看到的东西．就是终端应用）。

网络通讯要素

lIP地址:InetAddress

•网络中设备的标识

•不易记忆，可用主机名

•本地回环地址：127.0.0.1 主机名：localhost

l端口号

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

•有效端口：0~65535，其中0~1024系统使用或保留端口。

l传输协议

•通讯的规则

•常见协议：TCP，UDP

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

		
//		InetAddress ip = InetAddress.getLocalHost();
		InetAddress ip = InetAddress.getByName("www.baidu.com");
		
		System.out.println("ip:"+ip.getHostAddress());
		System.out.println("name:"+ip.getHostName());
		
	}

TCP和UDP

lUDP

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

•每个数据报的大小在限制在64k内

•因无连接，是不可靠协议

•不需要建立连接，速度快

lTCP

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

•在连接中进行大数据量传输

•通过三次握手完成连接，是可靠协议

•必须建立连接，效率会稍低

Tcp:

面向连接。

安全可靠

效率稍低。

通过三次握手确保连接的建立。

下载。

比喻：打电话。

通过管道传输石油。

Udp:

面向无连接。

不可靠。

速度快。

将数据封包传输，数据包最大64k。

聊天，在线视频，视频会议。

比喻：步话机。邮局包裹。

通过油桶传输石油。

Socket

lSocket就是为网络服务提供的一种机制。

l通信的两端都有Socket。

l网络通信其实就是Socket间的通信。

l数据在两个Socket间通过IO传输。

UDP传输

lDatagramSocket与DatagramPacket

l建立发送端，接收端。

l建立数据包。

l调用Socket的发送接收方法。

l关闭Socket。

发送端与接收端是两个独立的运行程序。

发送端

l在发送端，要在数据包对象中明确目的地IP及端口。

DatagramSocketds = new DatagramSocket();

byte[]by = “hello,udp”.getBytes();

DatagramPacketdp = new DatagramPacket(by,0,by.length,

InetAddress.getByName(“127.0.0.1”),10000);

ds.send(dp);

ds.close();

接收端

l在接收端，要指定监听的端口。

DatagramSocketds = new DatagramSocket(10000);

byte[]by = new byte[1024];

DatagramPacketdp = new DatagramPacket(by,by.length);

ds.receive(dp);

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

System.out.println(str+"--"+dp.getAddress());

ds.close();

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

		/*
		 * 需求：建立udp的接收端。
		 * 思路
		 * 1，必须有udp的端点。
		 * 2，接收数据，
		 * 3，并解析数据。
		 * 4，将数据打印出来看到，并结束接收动作。
		 */
		
		System.out.println("udp接收端开启.....");
		//1，创建一个udp的端点。注意：接收端一定要明确具体的端口。否则收不到数据。
		DatagramSocket ds = new DatagramSocket(10000);
		
		//2，接收数据。 一般使用socket服务的动作完成。将数据存储到数据包对象中。
		byte[] buf = new byte[1024];
		DatagramPacket dp = new DatagramPacket(buf,buf.length);
		ds.receive(dp);
		
		//3,通过数据包对象的方法对数据进行解析。
		String ip = dp.getAddress().getHostAddress();
		int port = dp.getPort();
		
		String text = new String(dp.getData(),0,dp.getLength());
		
		System.out.println(ip+":"+port+"--"+text);
		
		//4,关闭资源。
		ds.close();
		System.out.println("udp接收端关闭.....");
		
	}

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

		
		/*
		 * 需求：创建一个udp的发送端。
		 * 思路：
		 * 1，要先创建udp端点。也就是udp的socket。
		 * 2，将数据封装成数据包。
		 * 3，通过udp的端点将数据发送出去。就哦了。
		 * 
		 */
		System.out.println("udp发送开始......");
		//1,创建udp的端点。
		DatagramSocket ds = new DatagramSocket(9527);
		
		//2,将数据封装成数据包。
		String str = "udp发送数据演示！";
		byte[] buf = str.getBytes();
		
		//2.1创建数据包对象。
		DatagramPacket dp = 
				new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.200"),10000);
		
		
		//3,使用udp的socket服务将数据包发出去。
		ds.send(dp);
		
		
		//4,关闭资源。
		ds.close();
		
		System.out.println("udp发送结束.....");
	}

例从键盘录入数据

public class UDPReceiver2 {

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

		/*
		 * 接收发送端的数据，并打印到屏幕上。
		 */
		//1，建立接收端的udpsocket服务，必须明确端口号。
		DatagramSocket ds = new DatagramSocket(10001);
		while(true){
		
		//2,创建数据包。
		byte[] buf  = new byte[1024];
		DatagramPacket dp = new DatagramPacket(buf,buf.length);
		
		//3,使用接收方法将接收到的数据存储到数据包中。
		ds.receive(dp);
		
		//4,对数据进行解析。
		String ip = dp.getAddress().getHostAddress();
		String text = new String(dp.getData(),0,dp.getLength());
		System.out.println(ip+":"+text);
		}
//		ds.close();
		
		
	}

}

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

		/*
		 * 频繁获取键盘录入的数据。并发送给接收端。
		 */

		// 1,建立udpsocket服务端点。
		DatagramSocket ds = new DatagramSocket(8888);

		// 2,明确数据，将数据封装成数据包。
		BufferedReader bufr = new BufferedReader(new InputStreamReader(
				System.in));

		String line = null;
		while ((line = bufr.readLine()) != null) {
			if ("over".equals(line))
				break;
			byte[] buf = line.getBytes();
			DatagramPacket dp = new DatagramPacket(buf, buf.length,
					InetAddress.getByName("127.0.0.1"), 10001);
			ds.send(dp);
		}
		ds.close();
	}

}

群聊程序

public class ChatDemo {

	/**
	 * @param args
	 * @throws IOException
	 */
	public static void main(String[] args) throws IOException {

		DatagramSocket send = new DatagramSocket(9999);
		DatagramSocket rece = new DatagramSocket(10002);

		new Thread(new Send(send)).start();
		new Thread(new Rece(rece)).start();
	}
}

/*
 * 群聊程序，一边发一边收。 使用两个内容：1，使用广播 192.168.1.255，使用多线程。
 */

// 建立发送的任务。
class Send implements Runnable {

	private DatagramSocket ds;

	public Send(DatagramSocket ds) {
		super();
		this.ds = ds;
	}

	@Override
	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("10.212.169.255"), 10002);

				ds.send(dp);

				if ("88".equals(line)) {
					break;
				}
			}

			ds.close();
		} catch (Exception e) {

			e.printStackTrace();
		}
	}

}

// 建立接收任务。
class Rece implements Runnable {

	private DatagramSocket ds;

	public Rece(DatagramSocket ds) {
		super();
		this.ds = ds;
	}

	@Override
	public void run() {

		while (true) {

			byte[] buf = new byte[1024];
			DatagramPacket dp = new DatagramPacket(buf, buf.length);

			try {
				ds.receive(dp);

				String ip = dp.getAddress().getHostAddress();
				String text = new String(dp.getData(), 0, dp.getLength());

				System.out.println(ip + "::" + text);
				if ("88".equals(text)) {
					System.out.println(ip + ".....离开聊天室!!!");
				}
			} catch (IOException e) {

				e.printStackTrace();
			}

		}

	}

}

TCP传输

lSocket和ServerSocket

l建立客户端和服务器端

l建立连接后，通过Socket中的IO流进行数据的传输

l关闭socket

同样，客户端与服务器端是两个独立的应用程序。

基本思路（客户端）

l客户端需要明确服务器的ip地址以及端口，这样才可以去试着建立连接，如果连接失败，会出现异常。

l连接成功，说明客户端与服务端建立了通道，那么通过IO流就可以进行数据的传输，而Socket对象已经提供了输入

流和输出流对象，通过getInputStream(),getOutputStream()获取即可。

l与服务端通讯结束后，关闭Socket。

基本思路（服务端）

l服务端需要明确它要处理的数据是从哪个端口进入的。

l当有客户端访问时，要明确是哪个客户端，可通过accept()获取已连接的客户端对象，并通过该对象与客户端通过IO流进行数据传输。

l当该客户端访问结束，关闭该客户端。

客户端

l通过Socket建立对象并指定要连接的服务端主机以及端口。

Sockets = new Socket(“192.168.1.1”,9999);

OutputStreamout = s.getOutputStream();

out.write(“hello”.getBytes());

s.close();

服务端

l建立服务端需要监听一个端口

ServerSocketss = new ServerSocket(9999);

Sockets = ss.accept ();

InputStreamin = s.getInputStream();

byte[]buf = new byte[1024];

intnum = in.read(buf);

Stringstr = new String(buf,0,num);

System.out.println(s.getInetAddress().toString()+”:”+str);

s.close();

ss.close();

public class TCPClient {

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

		/*
		 * 需求：基于tcp，创建一个客户端。
		 * 并将数据发送给服务端。
		 */
		System.out.println("客户端开启......");
		//1,必须先建立tcp的客户端socket服务。
		Socket s = new Socket("192.168.1.200",10003);
		
		//2,通过socket获取socket流中的输出流对象。
		OutputStream out = s.getOutputStream();
		
		out.write("hi，server，哥们来了！".getBytes());
		
		
		s.close();
		
		System.out.println("客户端关闭......");
		
	}

}

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

		
		/*
		 * 创建服务端，接收客户端的数据。并打印在控制台上。
		 */
		System.out.println("服务端启动......");
		//1,创建tcp的服务端socket服务。服务端必须指定端口。
		ServerSocket ss = new ServerSocket(10003);
		
		//2,获取连接过来的客户端的对象。
		Socket s = ss.accept();
		System.out.println(s.getInetAddress().getHostAddress()+"....connected");
		
		//3,通过客户端对象的读取流，读取客户端发来的数据。
		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();
		System.out.println("服务端关闭......");
		
		
		
	}

}

public class TCPServer2 {

	/**
	 * @param args
	 */
	public static void main(String[] args)throws IOException {

		
		//1,创建tcp服务端的socket服务，并监听一个端口。
		ServerSocket ss = new ServerSocket(10004);
		
		//2,获取客户端对象。
		Socket s = ss.accept();
		System.out.println(s.getInetAddress().getHostAddress()+"......connected");
		
		//3,通过客户端对象获取socket流中的输入流。
		InputStream in = s.getInputStream();
		
		//4,定义缓冲区，读取数据。
		byte[] buf = new byte[1024];
		int len = in.read(buf);
		System.out.println(new String(buf,0,len));
		
		//5,通过客户端对象获取socket流中的输出流。
		OutputStream out = s.getOutputStream();
		
		out.write("哈哈，我已收到！哦也！".getBytes());
		
		s.close();
		
		ss.close();
		
	}

}

public class TCPClient2 {

	/**
	 * @param args
	 * @throws IOException 
	 * @throws UnknownHostException 
	 */
	public static void main(String[] args) throws UnknownHostException, IOException {

		/*
		 * 需求：客户端将数据发送到服务端，服务端收到后，将应答的数据反馈给客户端。
		 */
		
		//1,创建tcp客户端socket服务。
		Socket s = new Socket("127.0.0.2",10004);
		
		//2,获取socket流的输出流对象。
		OutputStream out = s.getOutputStream();
		
		//3,将数据写入到的socket流。
		out.write("hi,server,哥们又来了！".getBytes());
		
		//4,获取服务端发挥的数据，需要用到socket流中的输入流。
		InputStream in = s.getInputStream();
		
		//5,创建缓冲区，读取数据。
		byte[] buf = new byte[1024];		
		int len = in.read(buf);
		System.out.println(new String(buf,0,len));
		
		s.close();
		
	}

}

public class TransServer {

	/**
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {

		//1,创建服务端socket服务。
		ServerSocket ss = new ServerSocket(10005);
		
		//2,获取socket对象。
		Socket s = ss.accept();
		System.out.println(s.getInetAddress().getHostAddress()+"....connected");
		
		//3，明确源，网络。Socket输入流。
		BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));
		
		//4,明确目的，网络，socket输出流。
		PrintWriter out = new PrintWriter(s.getOutputStream(),true);
		
		//5,就是熟悉的读写过程。
		String line = null;
		while((line=bufIn.readLine())!=null){
			out.println(line.toUpperCase());
		}
		
		
		s.close();
		ss.close();
	}

}

public class TransClient {

	/**
	 * @param args
	 * @throws IOException 
	 * @throws UnknownHostException 
	 */
	public static void main(String[] args) throws UnknownHostException, IOException {

		/*
		 * 需求：通过客户端给服务器端发送单词数据，服务端将单词转成大写返回客户端。
		 * 如果客户端发送over，则客户端结束发送。其实就是创建了一个大写服务器。
		 */
		
		//1，创建客户端socket服务。
		Socket s = new Socket("127.0.0.1",10005);
		
		//2,客户端读取键盘录入的单词。
		BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
		
		//3,明确目的，网络流。
//		BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
		PrintWriter out = new PrintWriter(s.getOutputStream(),true);
		
		
		//4,明确源。来自于网络。
		BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));
		
		
		String line = null;
		while((line=bufr.readLine())!=null){
			
			if("over".equals(line)){
				break;
			}
			
			out.println(line);
			
			String str = bufIn.readLine();
			System.out.println("trans : "+str);
		}
		
		s.close();
		
		
	}

}

Tcp传输最容易出现的问题

l客户端连接上服务端，两端都在等待，没有任何数据传输。

l通过例程分析：

•因为read方法或者readLine方法是阻塞式。

l解决办法：

•自定义结束标记

•使用shutdownInput，shutdownOutput方法。

public class UploadPic implements Runnable {

	private Socket s;

	public UploadPic(Socket s) {
		this.s = s;

	}

	@Override
	public void run() {

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

		try {
			InputStream in = s.getInputStream();

			File dir = new File("e:\\pic");
			if (!dir.exists()) {
				dir.mkdirs();
			}
			int count = 1;

			File file = new File(dir, ip + "("+count+").jpg");
			while(file.exists()){
				file = new File(dir, 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);
			}

			OutputStream out = s.getOutputStream();
			out.write("上传成功".getBytes());

			fos.close();
			s.close();
		} catch (IOException e) {

		}
	}

}

public class UploadPicClient {

	/**
	 * @param args
	 * @throws IOException 
	 * @throws UnknownHostException 
	 */
	public static void main(String[] args) throws UnknownHostException, IOException {

		Socket s = new Socket("192.168.1.200",10007);
		
		
		//客户端要读取图片。
		FileInputStream fis = new FileInputStream("temp\\1.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 lenIn = in.read(bufIn);
		System.out.println(new String(bufIn,0,lenIn));
		
		fis.close();
		s.close();
		
	}

}

public class UploadPicServer {

	/**
	 * @param args
	 * @throws IOException
	 */
	public static void main(String[] args) throws IOException {

		ServerSocket ss = new ServerSocket(10007);
		while (true) {
			Socket s = ss.accept();

			new Thread(new UploadPic(s)).start();
		}

		// ss.close();

	}

}