第十六天日常更新--网络编程

今天来分享一些网络编程的小知识

IP:定位网络中的不同节点(电子设备:手机,电脑,路由器…)
IPV4 4个字节 32位 IPV6
特殊的IP:
192.168.0.0~192.168.255.255 局域网内部使用
127.0.0.1 本地IP
localhost 本地域名
IP和域名: DNS域名解析服务器
InetAddress 此类表示互联网协议 (IP) 地址。

端口:区分不同软件
0~65535 2个字节
统一协议下端口不能冲突
设置端口号时尽量越大越好
预留端口号:8000
常见端口号:
80: http
8080: tomcat
1521: Oracle
3306: mysql
InetSocketAddress 此类实现 IP 套接字地址（IP 地址 + 端口号）。

URL:统一资源定位符 区分不同的资源
互联网的三大基石: http html url
协议:
域名:
端口:
资源:

传输协议: udp tcp

ocket套接字:传输层为应用层开辟的通道(小口子)
不同的协议针对于Socket的实现是不同的
传输层协议之间的区别:
tcp: 相当于打电话 基于面向连接的 安全 基于io流传输 占用资源多,开销大,效率低 3次握手:1.请求 2.回应 3.传输
udp: 相当于写信 非面向连接的 只管发送 不安全 开销小,效率高 大小有限制 一般不超过60k 基于字节数组
UDP实现Socket编程:
DatagramSocket:定义发送端和接收端
DatagramPacket:数据的包裹

udp实现发送端:基本流程

1.DatagramSocket 指定端口 定义发送端 DatagramSocket(int port)
2.准备数据 ,转为字节数组
3.DatagramPacket 打包
4.发送 void send(DatagramPacket p) 从此套接字发送数据报包。
5.关闭资源

	public class UDPSend {
  		public static void main(String[] args) throws IOException {
			System.out.println("---------发送端----------");
			//1.定义发送端  DatagramSocket(int port)
			DatagramSocket send=new DatagramSocket(8888);
				//2.准备数据  ,转为字节数组
		String msg="你好就好,要过的没我好...";
		byte[] arr=msg.getBytes();
		//3.3.DatagramPacket 打包
		DatagramPacket packet=new DatagramPacket(arr,0,arr.length,new InetSocketAddress("127.0.0.1", 9999));
		//4.发送
		send.send(packet);
		//5.关闭
		send.close();
		}
		}

UDP实现接收端:基本流程
1.DatagramSocket 指定端口号 定义接收端
2.准备字节数组,进行打包(用来接收数据,把数据接收到包裹里面的字节数据中)
3.接收
4.处理数据
5.关闭

		public class UDPReceive {
			public static void main(String[] args) throws IOException {
			System.out.println("---------接收端----------");
			//1.DatagramSocket 指定端口号  定义接收端
			DatagramSocket rec=new DatagramSocket(9999);
			//2.准备字节数组,进行打包(用来接收数据,把数据接收到包裹里面的字节数据中)
			byte[] arr=new byte[1024*60];
			//3.打包
			//DatagramPacket(byte[] buf, int offset, int length) 
			DatagramPacket packet=new DatagramPacket(arr,0,arr.length);
			//4.接收
			rec.receive(packet);  //阻塞式接收
			//5.处理数据
			/*
			 *   byte[] getData() 
				          返回数据缓冲区。 
				 int getLength() 
				          返回将要发送或接收到的数据的长度。 
			 */
			byte[] newArr=packet.getData();
			System.out.println(newArr.length); //字节数组的长度
			System.out.println(packet.getLength());  //接到数据的个数
			
			System.out.println(new String(newArr,0,packet.getLength()));
			
			//6.关闭
			rec.close();
}
}

udp传输文件:发送端
1.定义发送端
2.从文件中读取数据到程序 字节数组
3.打包
4.发送
5.关闭

public class UDPFileSend {
	public static void main(String[] args) throws IOException {
	System.out.println("发送端");
	//1.定义发送端
	DatagramSocket send=new DatagramSocket(7777);
	//2.从文件中读取数据到程序 字节数组
	InputStream is=new BufferedInputStream(new FileInputStream("src/大叔.jpg"));
	//准备字节数组
	byte[] car=new byte[1024*60];
	//读取
	int len=-1;
	while((len=is.read(car))!=-1){
		//3.打包
		DatagramPacket packet=new DatagramPacket(car,0,len,new InetSocketAddress("localhost", 8888));
		//4.发送
		send.send(packet);
	}
	//5.关闭
	is.close();
	send.close();
}
}

udp传输文件:接收端
1.定义接收端
2.准备字节数组
3.打包准备接收
4.接收(阻塞式)
5.字节输出流写出到本地
6.关闭

public class UDPFileReceive {
	public static void main(String[] args) throws IOException {
	System.out.println("接收端");
	//1.定义接收端
	DatagramSocket receive=new DatagramSocket(8888);
	//2.准备字节数组
	byte[] car=new byte[1024*60];
	//3.打包准备接收
	DatagramPacket packet=new DatagramPacket(car,0,car.length);
	OutputStream out=new BufferedOutputStream(new FileOutputStream("D:/timg.jpg"));
	//4.接收(阻塞式)
	while(true){
		receive.receive(packet);
		byte[] arr=packet.getData();
		int len=packet.getLength();
		//5.字节输出流写出到本地
		out.write(arr, 0, len);
		if(len<car.length){
			break;
		}
	}
	out.flush();
	//6.关闭
	out.close();
	receive.close();
}
}

tcp实现客户端:基本流程
1.定义客户端 Socket 指定服务端的ip 端口
2.准备数据
3.通过io读写
4.关闭

public class Client {
	public static void main(String[] args) throws UnknownHostException, IOException {
	System.out.println("---------Client------------");
	//1.定义客户端  Socket 指定服务端的ip 端口
	Socket client=new Socket("localhost", 8888);
	String str="哈哈";
	//2.获取输出流  OutputStream getOutputStream() 返回此套接字的输出流。 
	OutputStream out=new BufferedOutputStream(client.getOutputStream());
	//写出
	out.write(str.getBytes());
	//3.关闭
	out.flush();
	out.close();
	client.close();
}
}

tcp实现服务端:基本流程
1.定义服务端 ServerSocket
2.阻塞式监听
3.通过io读写
4.关闭

public class Server {
	public static void main(String[] args) throws IOException {
	System.out.println("---------Server------------");
	//1.定义服务端  ServerSocket
	ServerSocket server=new ServerSocket(8888);
	//2.Socket accept() 侦听并接受到此套接字的连接。 
	Socket client=server.accept();
	System.out.println("--------一个客户端连接成功---------");
	InputStream is=new BufferedInputStream(client.getInputStream());
	byte[] car=new byte[1024];
	int len=is.read(car);
	System.out.println(new String(car,0,len));
	//3.关闭
	is.close();
	client.close();
	server.close();
}
}

tcp实现单向用户登录:客户端
1.键盘接收用户输入的用户名和密码
2.写出到服务端

public class LoginClient {
	public static void main(String[] args) throws IOException {
	//1.获取键盘输入流
	BufferedReader read=new BufferedReader(new InputStreamReader(System.in));
	//2.接收数据
	System.out.println("请输入用户名:");
	String uname=read.readLine();
	System.out.println("请输入密码:");
	String upwd=read.readLine();
	
	//3.定义客户端
	Socket client=new Socket("127.0.0.1",8989);
	//4.通过socket获取 输出流
	DataOutputStream out=new DataOutputStream(client.getOutputStream());
	//5.写出  uname=zhangsan&pwd=123
	out.writeUTF("uname="+uname+"&upwd="+upwd);
	out.flush();
	//6.关闭
	out.close();
	read.close();
	client.close();
}
}
tcp实现用户单向登录:服务端
1.定义服务端  ServerSocket
2.阻塞式监听
3.通过io读数据
4.进行判断
5.关闭
public class LoginServer {
	public static void main(String[] args) throws IOException {
		System.out.println("---------Server------------");
		//1.定义服务端  ServerSocket
		ServerSocket server=new ServerSocket(8989);
		//2.Socket accept() 侦听并接受到此套接字的连接。 
		Socket client=server.accept();
		System.out.println("--------一个客户端连接成功---------");
		DataInputStream is=new DataInputStream(client.getInputStream());
		String str=is.readUTF();
		System.out.println(str);
		
		//如果用户名为 laopei,密码为0523 
		//3.关闭
		is.close();
		client.close();
		server.close();
}

}