Java基础_网络编程基础相关_字节跳动杨成-优快云博客

本文链接：https://blog.youkuaiyun.com/yangcheng91/article/details/7905988

一、网络编程(概述)

二、网络编程(网络模型)

OSI/RM：

Open System Interconnection Reference Model开放系统互连基本参考模型。开放，是指非垄断的。系统是指现实的系统中与互联有关的各部分。

世界上第一个网络体系结构由IBM公司提出（74年，SNA），以后其他公司也相继提出自己的网络体系结构如：Digital公司的DNA，美国国防部的TCP/IP等，多种网络体系结构并存，其结果是若采用IBM的结构，只能选用IBM的产品，只能与同种结构的网络互联。

为了促进计算机网络的发展，国际标准化组织ISO于1977年成立了一个委员会，在现有网络的基础上，提出了不基于具体机型、操作系统或公司的网络体系结构，称为开放系统互联模型（OSI参考，open system interconnection）

三、网络编程(IP地址)

/*
获取IP:
*/
import java.net.*;
class IPDemo 
{
	public static void main(String[] args)throws Exception
	{
		InetAddress i=InetAddress.getLocalHost();//获取本地
		System.out.println(i.toString());
		System.out.println("address:"+i.getHostAddress());
		System.out.println("name:"+i.getHostName());

		InetAddress[] ia=InetAddress.getAllByName("www.baidu.com");//获取www.baidu.com
		for(InetAddress info:ia)
		{
			System.out.println(info);
		}
		
	}
}

四、网络编程(TCP和UDP)

网络通讯要素：

IP地址：

网络中设备的标识。

不易记忆，可用主机名。

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

端口号：

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

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

传输协议：

通讯的规则。

常见的协议：TCP，UDP

UDP:

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

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

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

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

TCP:

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

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

通过3次握手完成连接，是可靠协议。

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

五、网络编程(Socket)

Socket：

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

通信的两端都有Socket。

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

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

六、网络编程(Udp-发送端)

UDP传输：

DatagramSocket和DatagramPacket

建立发送端和接收端。

建立数据包。

调用Socket的发送接收方法。

关闭Socket。

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

/*
通过UDP传输方式，将一段文字数据发送出去。

思路：
1.建立udpsocket服务。
2.将要提供的数据封装到数据包中。
3.通过socket服务的发送功能将数据包发送出去。
4.关闭资源。

*/
import java.net.*;
class UDPSend//发送
{
	public static void main(String[] args)throws Exception
	{
		//创建UDP服务。通过DatagramSocket对象。
		DatagramSocket ds=new DatagramSocket(1001);//绑定1001端口

		//确定数据，并将其封装成数据包。
		byte[] buf="你好！".getBytes();
		DatagramPacket dp=new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.101"),1000);//将数据发送到192.168.1.101的1000端口

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

		//关闭资源
		ds.close();

	}
}

七、网络编程(Udp-接收端)

/*
定义一个应用程序，用于接收UDP协议传输的数据并处理。

定义UDP的接收端。
思路：
1.定义udpsocket服务。通常会监听一个端口。其实就是给这个接收网络应用程序定义数字标识。
方便明确哪些数据过来该应用程序可以处理。
2.定义一个数据包，要存储接收到的字节数据。因为数据包对象中有更多功能可以提取字节数据
中的不同数据信息。
3.通过socket服务的receive方法将收到的数据存入已定义好的数据包中。
4.通过数据包对象的特有功能，将这些不同的数据取出，打印在控制台上。
5.关闭资源。
*/
import java.net.*;
class UDPRece//接收 
{
	public static void main(String[] args)throws Exception
	{
		//创建udp soket建立端点
		DatagramSocket ds=new DatagramSocket(1000);//监听1000端口

		//定义数据包。用于存储数据。
		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());
		int port=dp.getPort();
		System.out.println("IP:"+ip+":"+port+"\t:"+data);
		//关闭资源
		ds.close();


	}
}

测试：

八、网络编程(UDP-键盘录入方式数据)

/*
UDP-键盘录入方式数据:
将发送端和接收端写在了一个*.java文件中。
*/
import java.net.*;
import java.io.*;
class  UDPSend2
{
	public static void main(String[] args)throws Exception
	{
		DatagramSocket ds=new DatagramSocket();
	
		BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));
		String line=null;
		while((line=bufr.readLine())!=null)//阻塞式
		{
			if("886".equals(line))
				break;

			byte[] buf=line.getBytes();
			DatagramPacket dp=new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.101"),1003);//最后一位，255广播地址。
			ds.send(dp);
		}

		ds.close();
	}
}


class  UDPRece2
{
	public static void main(String[] args)throws Exception
	{
		DatagramSocket ds=new DatagramSocket(1003);
		while(true)
		{
			byte[] buf=new byte[1024];
			DatagramPacket dp=new DatagramPacket(buf,buf.length);

			ds.receive(dp);//阻塞式

			String ip=dp.getAddress().getHostAddress();
			String data=new String(dp.getData(),0,dp.getLength());
			int port=dp.getPort();

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

九、网络编程(UDP-聊天)

/*
编写一个聊天程序。
有接收数据的部分和发送数据的部分。
需要同时执行，所以用到多线程技术。一个负责发送，另一个负责接收。

因为收和发的动作是不一致的，所以要定义两个run方法，且这两个方法要
封装到不同的类中。
*/
import java.io.*;
import java.net.*;
class Send implements Runnable
{
	private DatagramSocket ds;
	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)
			{
				if("886".equals(line))
					break;

				byte[] buf=line.getBytes();
				DatagramPacket dp=new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.101"),1003);
			
				ds.send(dp);
			}
		}
		catch (Exception e)
		{
			throw new RuntimeException("发送端失败！");
		}
	}
}

class Rece implements Runnable
{
	private DatagramSocket ds;
	Rece(DatagramSocket ds)
	{
		this.ds=ds;
	}
	public void run()
	{
		try
		{
			while(true)
			{
				byte[] buf=new byte[1024];
				DatagramPacket dp=new DatagramPacket(buf,buf.length);

				ds.receive(dp);

				String ip=dp.getAddress().getHostAddress();
				String data=new String(dp.getData(),0,dp.getLength());
				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(1003);
		
		new Thread(new Send(sendSocket)).start();
		new Thread(new Rece(receSocket)).start();

	}
}

十、网络编程(TCP传输)

TCP传输：

Socket和ServerSocket

建立客户端和服务器端

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

关闭Socket

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

/*
演示TCP传输：

1.TCP分客户端和服务端
2.客户端对应的对象是Socket。服务端对应的对象是ServerSocket。


*/


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

需求：
给服务端发送一个文本数据。
步骤：
1.创建Socket服务，并指定要连接的主机和端口。

*/
import java.io.*;
import java.net.*;
class TCPClient
{
	public static void main(String[] args)throws Exception 
	{
		//创建客户端的socket服务，指定目的主机和端口
		Socket s=new Socket("192.168.1.101",1005);

		//为了发送数据，应该获取socket流中的输出流
		OutputStream out=s.getOutputStream();
		out.write("TCP .............".getBytes());

		s.close();
	}
}

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

服务端：
1.建立服务端的socket服务。ServerSocket();并监听一个端口。
2.获取连接过来的客户端对象。通过ServerSocket的accept方法。所以这个方法是阻塞式的。
3。客户端如果发过来数据，那么服务端要使用对应的客户端对象，并获取到该客户端对象的读取流
来读取发过来的数据，并打印在控制台上。
4.关闭服务端。（可选）


*/
import java.io.*;
import java.net.*;
class TCPServer
{
	public static void main(String[] args)throws Exception
	{
		//建立服务端的socket服务，并监听一个端口
		ServerSocket ss=new ServerSocket(1005);

		//通过accept方法获取连接过来的客户端对象
		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();//关闭服务端


	}
}

十一、网络编程(TCP传输2)

/*
演示：TCP传出的客户端和服务端互访。

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


/*
客户端：

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


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

class TCPClient2
{
	public static void main(String[] args)throws Exception 
	{
		Socket s=new Socket("192.168.1.101",1005);
		OutputStream os=s.getOutputStream();
		os.write("你好，服务端。".getBytes());

		InputStream is=s.getInputStream();
		byte[] buf=new byte[1024];
		int len=is.read(buf);
		System.out.println(new String(buf,0,len));

		s.close();

	}
}

/*
服务端：
*/
import java.io.*;
import java.net.*;

class TCPServer2
{
	public static void main(String[] args)throws Exception 
	{
		ServerSocket ss=new ServerSocket(1005);
		Socket s=ss.accept();
		
		String ip=s.getInetAddress().getHostAddress();
		System.out.println(ip+"...connected");
		InputStream is=s.getInputStream();
		byte[] buf=new byte[1024];
		int len=is.read(buf);
		System.out.println(new String(buf,0,len));

		OutputStream os=s.getOutputStream();
		os.write("接收到你的请求了。".getBytes());

		s.close();
		ss.close();
	}
}

十二、网络编程(TCP练习)

/*
需求：建立一个文本转换服务器。客户端给服务端发送文本，服务端会将文本转成大写然后返回给
客户端。而且客户端可以不断地进行文本转换，当客户端输入over时，转换结束。


分析：

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

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

都是字符流，可选择字符流操作。提高效率，加入缓冲技术。

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

class TransClient
{
	public static void main(String[] args)throws Exception
	{
		Socket s=new Socket("192.168.1.101",1005);
		
		//定义读取键盘数据的流对象
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		//定义目的，将数据写入到socket输出流，发给服务端。

		//BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
		PrintWriter pw=new PrintWriter(s.getOutputStream(),true);
		
		//定义一个socket读取流，读取服务端返回的大写信息。
		BufferedReader bufr=new BufferedReader(new InputStreamReader(s.getInputStream()));

		String line=null;
		while((line=br.readLine())!=null)
		{
			if("over".equals(line))
				break;

			pw.println(line);
			/*
			bw.write(line);
			bw.newLine();
			bw.flush();
			*/

			System.out.println(bufr.readLine());
		}
		
		br.close();
		s.close();
	}
}

/*
服务端：
	源：socket读取流
	目的：socket输出流
	都是文本，装饰一下。
*/

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

class TransServer 
{
	public static void main(String[] args)throws Exception 
	{
		ServerSocket ss=new ServerSocket(1005);
		Socket s=ss.accept();

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

		//读取socket流中的数据
		BufferedReader br=new BufferedReader(new InputStreamReader(s.getInputStream()));

		//目的。socket输出流，将大写数据写入到socket输出流，并发送给客户端。
		//BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
		PrintWriter pw=new PrintWriter(s.getOutputStream(),true);

		String line=null;
		while((line=br.readLine())!=null)
		{
			pw.println("Server:"+line.toUpperCase());
			/*
			bw.write("Server:"+line.toUpperCase());
			bw.newLine();
			bw.flush();
			*/
		}

		s.close();
		ss.close();
	}
}


/*

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

*/

十三、网络编程(TCP复制文件)

/*
TCP复制文件:

客户端：
*/
import java.io.*;
import java.net.*;
class TextClient 
{
	public static void main(String[] args)throws Exception
	{
		Socket s=new Socket("192.168.1.101",1005);
		BufferedReader bufr=new BufferedReader(new FileReader("IPDemo.java"));

		PrintWriter out=new PrintWriter(s.getOutputStream(),true);
		

		String line=null;
		while((line=bufr.readLine())!=null)
		{
			out.println(line);
		}
		s.shutdownOutput();//关闭客户端的输出流，相当于给流中加入一个结束标记。

		BufferedReader bufIn=new BufferedReader(new InputStreamReader(s.getInputStream()));
		System.out.println(bufIn.readLine());

		bufr.close();
		s.close();
	}
}

/*
服务端：
*/
import java.io.*;
import java.net.*;
class TextServer
{
	public static void main(String[] args)throws Exception 
	{
		ServerSocket ss=new ServerSocket(1005);
		Socket s=ss.accept();

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

		BufferedReader bufIn=new BufferedReader(new InputStreamReader(s.getInputStream()));

		PrintWriter out=new PrintWriter(new FileWriter("server.txt"),true);

		String line=null;
		while((line=bufIn.readLine())!=null)
		{
			out.println(line);
		}
		PrintWriter pw=new PrintWriter(s.getOutputStream(),true);
		pw.println("上传成功！");

		out.close();
		s.close();
		ss.close();
	}
}