网络编程IP/UDP
1.网络通信
概念：两台设备通过网络实现数据传输
网络通信：将数据通过网络从一台设备传输到另一台设备
java.net包下提供了一系列的类或接口，供程序员使用，完成网络通信
2.网络
概念：两台或多台设备通过一定物理设备连接起来构成了网络
根据网络的覆盖范围不同，对网络进行分类：
1）局域网：覆盖范围最小，仅仅一个教室或一个机房
2）城域网：覆盖范围很大，可以覆盖一个城市
3）广域网：覆盖范围最大，可以覆盖全国，甚至全球，万维网是广域网的代表
3.ip地址
1）概念：用于唯一表示网络中的每台计算机/主机
2）查看ip地址：ipconfig
3）ip地址的表示形式：点分十进制 xx.xx.xx.xx
4) 每个十进制数的范围 0-255
5) ip地址的组成=网络地址+主机地址，比如：192.183.32.42
6) iIPv6是互联网工程任务组设计的用于代替IPV4的下一代Ip协议，其地址数量号称可以为 全世界的每一粒啥子编上一个地址
7）由于Ipv3最大的问题在于网络地址资源有限，严重制约了互联网的应用和发展。IPv6的 使用，不仅能解决网络地址资源数量问题，而且也解决了多种接入设备连接互联网的障碍
ipv4地址分类
域名：
举例：百度主机ip：110.242.68.3
百度域名：www.baidu.com
好处：为了方便记忆，解决了记Ip的困难
概念：将ip地址映射成域名，这里怎么映射上，HTTP协议
端口号：
1.概念：用于标识计算机上的某个特定的网络程序
2.表示形式：以整数形式，端口范围0-65535
3. 0-1024已经被占用 ，比如ssh12,ftp21,smtp25，不能在继续使用这些端口号
4.常见的 网络端口号：sqlserver:1433 tomcat:8080 mysql:3306
网络通信协议：
网络通信协议包含（TCP传输控制协议 和 IP/因特网互联协议），又称为协议，这个协议是Internet最基本的协议，Internet国际互联网的基础，简单来说，网络通信协议就是由互联网的Ip协议和传输层的TCP
TCP和UDP
1.TCP协议：传输控制协议
1）使用TCP协议前，须先建立TCP连接，形成传输数据通道
2）传输前，采用“三次握手”方式，是可靠的
3）TCP协议进行通信的两个应用程序：客户端，服务端
4）在连接中可进行大数据量大传输
5）传输完毕，需释放已经建立的连接，效率较低
2.UDP协议：用户数据协议
1）将数据，源，目的封装成数据包，不需要建立连接
2）每个数据报的大小限制在64K内，不适合传输大量数据
3）因无需连接，故是不可靠的
4）发送数据结束时无需释放资源，速度快
InetAddress类相关方法
1.获取本机InetAddress对象getLocalHost
2.根据指定主机名/域名获取ip地址对象getByName
3.获取InetAddress对象的主机名 getHostName
4.获取InetAddtress对象的地址 getHostAddress
package com_xx;
import java.net.InetAddress;
import java.net.UnknownHostException;
/**
* 演示InetAddress的使用
*/
public class api {
public static void main(String[] args) throws UnknownHostException {
//获取本机的InetAdress对象
InetAddress localHost =InetAddress.getLocalHost();
System.out.println(localHost);
//2.根据指定的主机名获取InetAdress对象
InetAddress host1=InetAddress.getByName("LAPTOP-K1LTB3RJ");
System.out.println("host1="+host1);
//3.根据域名返回InetAddress对象 比如www.baidu.com对象
InetAddress host2=InetAddress.getByName("www.baidu.com");
System.out.println("host2="+host2);
//4.通过InetAddress对象 获取对应的地址
String hostAddress =host2.getHostAddress();
System.out.print("host2对应的IP="+hostAddress);
//5.通过InetAddress对象，获取对应的主机名/或者的域名
String hostName =host2.getHostName();
System.out.println("host2对应的主机名="+hostName );
}
}
Socket
1）套接字Socket开发网络应用程序被广泛采用，以至于成为事实上的标准，通信的两端都要有Socket，是两台机器间通信的端点，网络通信其实就是Socket间的端点
2）Socket允许程序把网络连接成一个流，数据在两个Socket间通过IO传输，一般主动发起通讯的应用属于客户端，等待通信请求的为服务端
TCP网络通信编程
1.基于客户端-服务端 的网络通信
2.底层使用的是TCP/IP协议
3.应用场景举例：客户端发送数据，服务端接收并显示
4.基于Socket的TCP编程
例题一（使用字节流 客户端发送信息到客户端）
服务端
package Socket入门.socket;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
/**
*
* 服务端
* 1.在本机的9999端口监听，等待连接
* 细节：要求在本机没有其他服务在监听9999
* 2.当没有客户端连接9999端口时，程序会阻塞，等待连接
* 3，通过socket.getInputStream()读取客户端写到数据通道的数据
*
* 客户端
* 1.连接服务端
* 2.连接上后 生成Socket通过socket.getOutputStream
* 3.通过输出流，写入数据到数据通道 显示
*/
public class SocketTPC01Server {
public static void main(String[] args) throws IOException {
//serverSocket 可以通过accept()返回多个Socket[多并发]
ServerSocket serverSocket = new ServerSocket(9999);
System.out.println("服务器，在9999端口监听 等待连接");
//如果有客户端连接9999端口 程序继续执行
Socket socket = serverSocket.accept();
System.out.println("服务器端socket="+socket.getClass());
//3，通过socket.getInputStream()读取客户端写到数据通道的数据
InputStream inputStream = socket.getInputStream();
//4.io读取
byte[] buf =new byte[1024];
int readlen =0;
while ((readlen =inputStream.read(buf))!=-1){
System.out.println(new String(buf,0,readlen));
}
inputStream.close();
socket.close();
serverSocket.close();
}
}
客户端
package Socket入门.socket;
import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
/**
*
* * 客户端
* * 1.连接服务端
* * 2.连接上后 生成Socket通过socket.getOutputStream
* * 3.通过输出流，写入数据到数据通道 显示
*/
public class SocketTCP01Client {
public static void main(String[] args) throws IOException {
//连接本机的9999端口 如果连接成功 换回Socket对象
Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
System.out.println("客户端 Socket"+socket.getClass());
//连接上后，生成Socket,通过socket.getOutPutStream()
//得到和socket对象关联的输出流对象
OutputStream outputStream = socket.getOutputStream();
//3.通过输出流，写入数据到数据通道 显示
outputStream.write("hello,server".getBytes());
//4.关闭流对象 和socket 必须关闭
outputStream.close();
socket.close();
System.out.println("客户端退出");
}
}
例题二（字节流 客户端发送文字并接收文字）
服务端
package Socket入门.socket.socket1;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
/**
* 服务端
* 1.在本机的9999端口监听，等待连接
* 细节 要求在本机没有其他服务在监听9999
* 2.当没有客户端连接9999端口时，程序会阻塞，等待连接
* 3，通过socket.getInputStream()读取客户端写到数据通道的数据
*
* 客户端
* 1.连接服务端
* 2.连接上后 生成Socket通过socket.getOutputStream
* 3.通过输出流，写入数据到数据通道 显示
*/
@SuppressWarnings({"all"})
public class SocketTPC02Server {
public static void main(String[] args) throws IOException {
//serverSocket 可以通过accept()返回多个Socket[多并发]
ServerSocket serverSocket = new ServerSocket(9999);
System.out.println("服务器，在9999端口监听 等待连接");
//如果有客户端连接9999端口 程序继续执行
Socket socket = serverSocket.accept();
System.out.println("服务器端socket="+socket.getClass());
//3，通过socket.getInputStream()读取客户端写到数据通道的数据
InputStream inputStream = socket.getInputStream();
//4.io读取
byte[] buf =new byte[1024];
int readlen =0;
while ((readlen =inputStream.read(buf))!=-1){
System.out.println(new String(buf,0,readlen));
}
OutputStream outputStream = socket.getOutputStream();
//3.通过输出流，写入数据到数据通道 显示
outputStream.write("hello,server".getBytes());
socket.shutdownOutput();
inputStream.close();
socket.close();
serverSocket.close();
}
}
客户端
package Socket入门.socket.socket1;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
/**
* * 客户端
* * 1.连接服务端
* * 2.连接上后 生成Socket通过socket.getOutputStream
* * 3.通过输出流，写入数据到数据通道 显示
*/
@SuppressWarnings({"all"})
public class SocketTCP02Client {
public static void main(String[] args) throws IOException {
//连接本机的9999端口 如果连接成功 换回Socket对象
Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
System.out.println("客户端 Socket"+socket.getClass());
//连接上后，生成Socket,通过socket.getOutPutStream()
//得到和socket对象关联的输出流对象
OutputStream outputStream = socket.getOutputStream();
//3.通过输出流，写入数据到数据通道 显示
outputStream.write("hello,server".getBytes());
socket.shutdownOutput();
InputStream inputStream = socket.getInputStream();
//4.io读取
byte[] buf =new byte[1024];
int readlen =0;
while ((readlen =inputStream.read(buf))!=-1){
System.out.println(new String(buf,0,readlen));
}
//4.关闭流对象 和socket 必须关闭
outputStream.close();
socket.close();
System.out.println("客户端退出");
}
}
例题三（使用字符流 客户端发送文字信息，并接收到文字信息）
服务端
package Socket入门.socket.socket2;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
/**
*使用字符流
* 服务端
* 1.在本机的9999端口监听，等待连接
* 细节 要求在本机没有其他服务在监听9999
* 2.当没有客户端连接9999端口时，程序会阻塞，等待连接
* 3，通过socket.getInputStream()读取客户端写到数据通道的数据
*
* 客户端
* 1.连接服务端
* 2.连接上后 生成Socket通过socket.getOutputStream
* 3.通过输出流，写入数据到数据通道 显示
*/
@SuppressWarnings({"all"})
public class SocketTPC03Server {
public static void main(String[] args) throws IOException {
//serverSocket 可以通过accept()返回多个Socket[多并发]
ServerSocket serverSocket = new ServerSocket(9999);
System.out.println("服务器，在9999端口监听 等待连接");
//如果有客户端连接9999端口 程序继续执行
Socket socket = serverSocket.accept();
System.out.println("服务器端socket="+socket.getClass());
//3，通过socket.getInputStream()读取客户端写到数据通道的数据
InputStream inputStream = socket.getInputStream();
//4.io读取 使用字符流 使用转换流将inputStream转换成bufferedreader
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
String s=bufferedReader.readLine();
System.out.println(s);
OutputStream outputStream = socket.getOutputStream();
//3.通过输出流，写入数据到数据通道 显示
BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
bufferedWriter.write("hello , client 字符流");
bufferedWriter.newLine();
bufferedWriter.flush();//需要手动刷新
socket.shutdownOutput();
bufferedReader.close();
bufferedWriter.close();
socket.close();
serverSocket.close();
}
}
客户端
package Socket入门.socket.socket2;
import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
/**
* * 客户端 使用字符流
* * 1.连接服务端
* * 2.连接上后 生成Socket通过socket.getOutputStream
* * 3.通过输出流，写入数据到数据通道 显示
*/
@SuppressWarnings({"all"})
public class SocketTPC03Client {
public static void main(String[] args) throws IOException {
//连接本机的9999端口 如果连接成功 换回Socket对象
Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
System.out.println("客户端 Socket"+socket.getClass());
//连接上后，生成Socket,通过socket.getOutPutStream()
//得到和socket对象关联的输出流对象
OutputStream outputStream = socket.getOutputStream();
//3.通过输出流，写入数据到数据通道 显示
BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
bufferedWriter.write("hello,server 字符流");
bufferedWriter.newLine();//插入一个换行符 表示写入内容的结束 注意要求对方使用readline()来读
bufferedWriter.flush();//如果使用的字符流 需要手动刷新否则数据不会写入数据通道
socket.shutdownOutput();
InputStream inputStream = socket.getInputStream();
//4.io读取 字符流
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
String s =bufferedReader.readLine();
System.out.println(s);
System.out.println("客户端退出");
//4.关闭流对象 和socket 必须关闭
bufferedWriter.close();
bufferedReader.close();
socket.close();
}
}
例题四（服务端接收到一张照片，返回文字信息）
文件上传的客户端
package Socket入门.socket.socket2;
import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
/**
* * 客户端 使用字符流
* * 1.连接服务端
* * 2.连接上后 生成Socket通过socket.getOutputStream
* * 3.通过输出流，写入数据到数据通道 显示
*/
@SuppressWarnings({"all"})
public class SocketTPC03Client {
public static void main(String[] args) throws IOException {
//连接本机的9999端口 如果连接成功 换回Socket对象
Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
System.out.println("客户端 Socket"+socket.getClass());
//连接上后，生成Socket,通过socket.getOutPutStream()
//得到和socket对象关联的输出流对象
OutputStream outputStream = socket.getOutputStream();
//3.通过输出流，写入数据到数据通道 显示
BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
bufferedWriter.write("hello,server 字符流");
bufferedWriter.newLine();//插入一个换行符 表示写入内容的结束 注意要求对方使用readline()来读
bufferedWriter.flush();//如果使用的字符流 需要手动刷新否则数据不会写入数据通道
socket.shutdownOutput();
InputStream inputStream = socket.getInputStream();
//4.io读取 字符流
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
String s =bufferedReader.readLine();
System.out.println(s);
System.out.println("客户端退出");
//4.关闭流对象 和socket 必须关闭
bufferedWriter.close();
bufferedReader.close();
socket.close();
}
}
文字上传的服务端
package upload;
import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
public class TCPFileUploadClient {
public static void main(String[] args) throws Exception {
//1.连接到服务端 得到Socket对象
Socket socket = new Socket(InetAddress.getLocalHost(), 6666);
//2.创建读取磁盘文件的输入流
String FilePath ="e:\\hello\\美女.jpg";
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(FilePath));
//3.把文件读到字节数组中 使用方法 Stream.Utils 可以将文件的内容传入到byte[]中
//这里的bytes就是filePath返回的字节数组
byte[] bytes = StreamUtils.streamToByteArray(bis);
//4.通过socket获取到输出流，将bytes数据发送给服务端
BufferedOutputStream bos= new BufferedOutputStream(socket.getOutputStream());
bos.write(bytes);//将文件转换成数组 并写到数据通道里面
bis.close();
socket.shutdownOutput();//设置写入数据到结束标记
//======接受从服务端返回来的信息
InputStream inputStream = socket.getInputStream();
//使用StreamUtils 的方法，直接将inputStream读取到的内容转成字符串
String s = StreamUtils.streamToString(inputStream);
System.out.println(s);
//关闭相应的流
bos.close();
socket.close();
}
}
StreamUtils流
package upload;
import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
/**
* 此类用于演示关于流的读写方法
*/
public class StreamUtils {
/**
* 功能：将输入流转换成byte[]
* @param is
* @return
* @throws Exception
*/
public static byte[] streamToByteArray(InputStream is) throws Exception{
ByteArrayOutputStream bos = new ByteArrayOutputStream();//创建输出流对象
byte[] b = new byte[1024];
int len;
while((len=is.read(b))!=-1){
bos.write(b, 0, len);
}
byte[] array = bos.toByteArray();
bos.close();
return array;
}
/**
* 功能：将InputStream转换成String
* @param is
* @return
* @throws Exception
*/
public static String streamToString(InputStream is) throws Exception{
BufferedReader reader = new BufferedReader(new InputStreamReader(is));
StringBuilder builder= new StringBuilder();
String line;
while((line=reader.readLine())!=null){ //当读取到 null时，就表示结束
builder.append(line+"\r\n");
}
return builder.toString();
}
}
netstat指令
1. netstat -an 可以查看当前主机网络情况，包括端口监听情况和网络连接情况
2. netstat -an|more可以分页显示
3.要求在dos控制台下执行win+r
说明：
1）Listening 表示某个端口在监听
2）如果有一个外币程序连接到该接口，就会显示一条连接信息
3）可以输入ctrl + c 退出指定
当客户端连接到服务断后，实际上客户端也是通过一个端口和服务端进行通讯的，这个端口时TCP/IP来分配的，是不确定的，是随机的
UDP网络通信编程
1.类DatagramSocket和DatagramPacket[数据报|数据报]实现了基于UDP协议网络程序、
2.UDP数据报通过数据报嵌套字DatagramSocket发送和接收，系统不保证UDP数据报一定
能够安全送到目的地，也不能确定什么时候抵达
3.DatagramPacket对象封装了UDP数据报，在数据报中包含了发送端的IP地址和端口号以
及接收端的IP地址和端口号
4.UDP协议中的每个数据报都给出了完整的地址信息，因此无需建立发送方和接收方的连接
UDP编程流程
1.核心的两个类/对象 DatagramSocket与DatagramPacket
2.建立发送端，接收端（没有客户端和服务端）
3.发送数据前，建立数据包/报 DatagramPacket对象
4调用DatagramSocket的发送，接收方法
5.关闭DatagramSocket
接收端
package com.udp;
import java.io.IOException;
import java.net.*;
/**
* UDP接收端
*/
public class UDPReceiverA {
public static void main(String[] args) throws IOException {
//1.创建一个DatagramSocket 准备在9999端口接收数据
DatagramSocket socket = new DatagramSocket(9999);
//2.构建一个DatagramPacket对象，准备接收数据
//在前面讲解UDP协议时 一个数据包最大是64k
byte[] bytes = new byte[1024];
DatagramPacket packet = new DatagramPacket(bytes, bytes.length);
//3.调用接收方法 将通过网络传输的DatagramPacket对象 填充到packet对象
//当有数据报发送到本机的9999端口时 方法便会生效 接收到数据
//如果没有数据报发送到本机9999端口时， 方法就会阻塞
System.out.println("接收端A等待接收数据");
socket.receive(packet);
//4.可以把packet进行拆包 取出数据 并显示
byte[] data = packet.getData();
int length = packet.getLength();
String s = new String(data,0,length);
System.out.println(s);
//发送数据包
byte []a ="ok".getBytes();
DatagramPacket packet1 = new DatagramPacket(a, a.length, InetAddress.getByName("192.168.164.211"), 9998);
socket.send(packet1);
//关闭资源
socket.close();
System.out.println("A端退出");
}
}
发送端
package com.udp;
import java.io.IOException;
import java.net.*;
/**
* 发送端B
*/
public class UDPSenterB {
public static void main(String[] args) throws IOException {
//首先我们要创建 DatagramSocket 对象 准备在9998端口发送数据
//这里的发送端口不能和接收端口的端口号相同
DatagramSocket socket = new DatagramSocket(9998);
//2.降需要发送的数据 封装到DatagramPacket数据报中
//本机可以使用InetAddress.getHostAddress
byte[] data= "hello 明天吃火锅".getBytes();
//封装到DatagramPacket对象 data 内容 字节数组，data.length,主机Ip ,端口号
DatagramPacket packet = new DatagramPacket(data, data.length, InetAddress.getByName("192.168.164.211"), 9999);
socket.send(packet);
//接收数据包
byte []data1=new byte[1024];
DatagramPacket packet1 = new DatagramPacket(data1, data1.length);
System.out.println("B在等待A的回信");
socket.receive(packet1);
//拆包
byte[] data2 = packet1.getData();
int length = packet1.getLength();
String s1 =new String(data2,0,length);
System.out.println(s1);
//关闭资源
socket.close();
System.out.println("B端退出");
}
}