网络的相关概念

网络通信

网络

ip地址

1. 概念:用于唯一标识网络中的每台计算和41主机
2. 查看ip地址:ipconfig
3. ip地址的表示形式:点分十进制 xx.xx.xx.xx
4. 每一个十进制数的范围:0~255
5. ip地址的组成=网络地址+主机地址，比如:192.168.16.69
6. IPv6是互联网工程任务组设计的用于替代IPv4的下一代IP协议，其地址数量号称可以为全世界的每 一粒沙子编上一个地址。
7. 由于IPv4最大的问题在于网络地址资源有限，严重制约了互联网的应用和发展。IPv6的使用，不仅能解决网络地址资源数量的问题，而且也解决了多种接入设备连入互联网的障碍

ipv4地址分类

域名

1. www.baidu.cam
2. 好处:为了方便记忆，解决记ip的困难
3. 概念:将!p地址映射成域名，这里怎么映射上，HTTP协议

• 端口号

1. 概念:用于标识计算机上某个特定的网络程序
2. 表示形式:以整数形式，端口范围0-65535 [2个字节表示端口0~2^16-1]
3. 0~1024已经被占用，比如ssh 22,ftp 21,smtp 25,http 80
   4.常见的网络程序端口号:

• tomcat:8080
• mysql:3306
• oracle:1521
• sqlserver:1433

网络通信协议

TCP/IP(Transmission Control Protocol/Internet Protocol)的简写,中文译名为:传输控制协议/因特网互联协议,又叫网络通讯协议,这个协议是Internet最基本的协议,Internet国际互联网络的基础,简单地说,就是由网络层的IP协议和传输层的TCP协议组成的.

TCP和UDP

TCP协议:传输控制协议

1. 使用TCP协议前，须先建立TCP连接，形成传输数据通道
2. 传输前,采用"三次握手"方式，是可靠的
3. TCP协议进行通信的两个应用进程:客户端、服务端
4. 在连接中可进行大数据量的传输
5. 传输完毕，需释放已建立的连接，效率低
   UDP协议:用户数据协议
6. 将数据、源、目的封装成数据包，不需要建立连接
7. 每个数据报的大小限制在64k内，不适合传输大量数据
8. 因无需连接，故是不可靠的
9. 发送数据结束时无需释放资源(因为不是面向连接的),速度快

InetAddress类

相关方法

1. 获取本机InetAddress对象 getLocalHost
2. 根据指定主机名/域名获取ip地址对象 getByName
3. 获取InetAddress对象的主机名 getHostName
4. 获取InetAddress对象的地址 getHostAddress

案例:

/**
 * @ClassName
 * @Description
 * @Author zxk
 * @DateTime 2022-02-05-16:43
 * @Version 演示InetAddress类的使用
 */
//主机名等价域名对应一个ip(地址)
public class API_ {
    public static void main(String[] args) throws UnknownHostException {
        //1. 获取本机的InetAddress 对象
        InetAddress localHost = InetAddress.getLocalHost();
        System.out.println("localHost = " + localHost);//主机名/ip

        //2. 根据指定  主机名 获取 InetAddress对象
        InetAddress host1 = InetAddress.getByName("WIN-I0Q1644D4PA");
        System.out.println("host1 = " + host1);//主机名/ip

        //3. 根据 域名 获取InetAddress对象
        //亦可根据ip获取InetAddress对象
        InetAddress host2 = InetAddress.getByName("www.baidu.com");
        System.out.println("host2 = " + host2);


        //4. 通过 InetAddress 对象，获取对应的地址
        String address = host2.getHostAddress();
        System.out.println("address = " + address);

        //5. 通过 InetAddress 对象，获取对应的主机名/或者的域名
        String name = host2.getHostName();
        System.out.println("name = " + name);


    }
}

Socket

1. 套接字(Socket)开发网络应用程序被广泛采用，以至于成为事实上的标准。
2. 通信的两端都要有Socket，是两台机器间通信的端点
3. 网络通信其实就是Socket间的通信。
4. Socket允许程序把网络连接当成一个流，数据在两个Socket间通过IO传输。
5. 一般主动发起通信的应用程序属客户端，等待通信请求的为服务端

TCP 网络通信编程

1. 基于客户端一服务端的网络通信
2. 底层使用的是TCP/IP协议
3. 应用场景举例:客户端发送数据，服务端接受并显示控制台
4. 基于Socket的TCP编程

补充

1. 当客户端连接到服务器后,实际上客户端也是通过一个端口和服务端进行通讯的,这个端口是TCP/IP来分配的,是不确定的,是随机的
2. 程序验证+netstat

案例一

1. 编写一个服务器端，和一个客户端
2. 服务器端在9999端口监听
3. 客户端连接到服务器端，发送"hello,server"，然后退出
4. 服务器端接收到客户端发送的信息，输出，并退出

/**
 * @ClassName
 * @Description
 * @Author zxk
 * @DateTime 2022-02-05-17:25
 * @Version
 * 服务端
 */
public class Server {
    public static void main(String[] args) throws IOException {
        //在(默认)本机的指定端口建立服务端插座
        //注意:serverSocket监听9999的前提是没有其他服务在监听9999
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端,在9999端口监听,并等待连接..");

        //等待连接插入-->若没有连接,程序阻塞-->若连接成功,返回Socket对象,程序继续
        //注意:该方法可返回多个Socket对象->多个客户端连接服务器的并发
        Socket socket = serverSocket.accept();

        //net包下Socket类型
        System.out.println("服务端 socket="+socket.getClass());

        //通过网络连接构造输入流:读取
        InputStream inputStream = socket.getInputStream();

        byte[] buf = new byte[1024];
        int length;
        while ((length = inputStream.read(buf)) != -1) {
            System.out.println(new String(buf, 0, length));
        }

        //关闭流,连接,端口插座(插孔有限)以节约资源
        inputStream.close();
        socket.close();
        serverSocket.close();
    }
}

/**
 * @ClassName
 * @Description
 * @Author zxk
 * @DateTime 2022-02-05-17:25
 * @Version
 * 客户端，发送 "hello, server" 给服务端
 */
public class Client {
    public static void main(String[] args) throws IOException {
        //客户端连接到服务端(本机的9999端口)的插座-->若连接成功,返回Socket对象
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);

        //与服务端的连接类型一致
        System.out.println("客户端socket="+socket.getClass());

        //通过网络连接构造输出流:写入
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("hello,sever".getBytes());

        //关闭流,连接
        outputStream.close();
        socket.close();
        System.out.println("客户端退出...");
    }
}

案例二

1.编写一个服务端，和一个客户端
2.服务器端在9999端口监听
3.客户端连接到服务端，发送”hello, serer"，并接收服务器端回发的 “heilo,client”，再退出
4.服务器端接收到客户端发送的信息，输出，并发送”hello, client"，再退出

/**
 * @ClassName
 * @Description
 * @Author zxk
 * @DateTime 2022-02-05-17:57
 * @Version
 * 服务端:接收客户端发送的消息-->并发送"hello,client"
 */
public class Server {
    @SuppressWarnings({"all"})
    public static void main(String[] args) throws IOException {
        //在(默认)本机的指定端口建立服务端插座
        //注意:serverSocket监听9999的前提是没有其他服务在监听9999
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端,在9999端口监听,并等待连接..");

        //等待连接插入-->若没有连接,程序阻塞-->若连接成功,返回Socket对象,程序继续
        //注意:该方法可返回多个Socket对象->多个客户端连接服务器的并发
        Socket socket = serverSocket.accept();

        //net包下Socket类型
        System.out.println("服务端 socket="+socket.getClass()+"已连接");

        //通过网络连接构造输入流:读取
        InputStream inputStream = socket.getInputStream();

        byte[] buf = new byte[1024];
        int length;
        while ((length = inputStream.read(buf)) != -1) {
            System.out.println(new String(buf, 0, length));
        }

        //读取后的 写入到数据通道
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("hello,client".getBytes());

        //设置(输出)结束标记
        socket.shutdownOutput();//若写入后没有再传输可以不设置标记

        //关闭流,连接,端口插座(插孔有限)以节约资源
        outputStream.close();
        inputStream.close();
        socket.close();
        serverSocket.close();

    }
}

/**
 * @ClassName
 * @Description
 * @Author zxk
 * @DateTime 2022-02-05-17:56
 * @Version
 * 客户端:连接服务端-->发送"hello,server"-->接收服务端回发的"hello,client"-->退出
 */
public class Client {
    @SuppressWarnings({"all"})
    public static void main(String[] args) throws IOException {
        //客户端连接到服务端(本机的9999端口)的插座-->若连接成功,返回Socket对象
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);

        //与服务端的连接类型一致
        System.out.println("客户端socket="+socket.getClass()+"已连接");

        //通过网络连接构造输出流:写入
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("hello,sever".getBytes());

        //设置(输出)结束标记(先写后读不可省略,否则两端都阻塞在数据的传输上)
//        socket.shutdownOutput();

        //写入后的 读取数据
        InputStream inputStream = socket.getInputStream();
        byte[] buf = new byte[1024];
        int length;
        while ((length = inputStream.read(buf)) != -1) {
            System.out.println(new String(buf, 0, length));
        }

        //关闭流,连接
        inputStream.close();
        outputStream.close();
        socket.close();
        System.out.println("客户端退出...");
    }
}

案例三

1. 编写一个服务端,和一个客户端
2. 服务端在9999端口监听
3. 客户端连接到服务端,发送"hello,server",并接收服务端回发的"hello,client",在退出
4. 服务端接收到客户端发送的信息,输出,并发送"hello,client",再退出

/**
 * @ClassName
 * @Description
 * @Author zxk
 * @DateTime 2022-02-05-17:57
 * @Version 字符流方式
 * 服务端:接收客户端发送的消息-->并发送"hello,client"
 */
public class Server {
    @SuppressWarnings({"all"})
    public static void main(String[] args) throws IOException {
        //在(默认)本机的指定端口建立服务端插座
        //注意:serverSocket监听9999的前提是没有其他服务在监听9999
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端,在9999端口监听,并等待连接..");

        //等待连接插入-->若没有连接,程序阻塞-->若连接成功,返回Socket对象,程序继续
        //注意:该方法可返回多个Socket对象->多个客户端连接服务器的并发
        Socket socket = serverSocket.accept();

        //net包下Socket类型
        System.out.println("服务端 socket="+socket.getClass()+"已连接");

        //通过网络连接构造输入流:读取
        InputStream inputStream = socket.getInputStream();
        BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));

        System.out.println(br.readLine());

        //读取后的 写入到数据通道
        OutputStream outputStream = socket.getOutputStream();
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(outputStream));
        bw.write("hello,client 字符流");


        //设置(输出)结束标记
//      bw.newLine();//若写入后没有再传输可以不设置标记


        //关闭流,连接,端口插座(插孔有限)以节约资源
        bw.close();//写入
        br.close();
        socket.close();
        serverSocket.close();

    }
}

/**
 * @ClassName
 * @Description
 * @Author zxk
 * @DateTime 2022-02-05-17:56
 * @Version 字符流方式
 * 客户端:连接服务端-->发送"hello,server"-->接收服务端回发的"hello,client"-->退出
 */
public class Client {
    @SuppressWarnings({"all"})
    public static void main(String[] args) throws IOException {
        //客户端连接到服务端(本机的9999端口)的插座-->若连接成功,返回Socket对象
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);

        //与服务端的连接类型一致
        System.out.println("客户端socket="+socket.getClass()+"已连接");

        //通过网络连接构造输出流:写入
        OutputStream outputStream = socket.getOutputStream();
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(outputStream));
        bw.write("hello,server 字符流");


        //设置(输出)结束标记(先写后读不可省略,否则两端都阻塞在数据的传输上)
        bw.newLine();//对应的另一端必须使用readLine!!!
        bw.flush();//刷新以写入

        //写入后的 读取数据
        InputStream inputStream = socket.getInputStream();
        BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));

        System.out.println(br.readLine());

        //关闭流,连接
        br.close();
        bw.close();
        socket.close();
        System.out.println("客户端退出...");
    }
}

案例四(上传文件)

1. 编写一个服务端，和一个客户端
2. 服务器端在8 888端口监听
3. 客户端连接到服务端，发送一张图片e://q i e. p n g
4. 服务器端接收到客户端发送的图片，保存到src下，发送”收到图片”
5. 客户端接收到服务端发送的”收到图片”，再退出
6. 该程序要求使用StreamUtils.java,我们直接使用

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();
		
	}

}

/**
 * @ClassName
 * @Description
 * @Author zxk
 * @DateTime 2022-02-05-19:58
 * @Version 服务端
 * 接收客户端发送的文件-->保存到系统文件目录下-->发送"收到图片"后退出
 */
public class Server {
    public static void main(String[] args) throws Exception {
        //创建字节输出流-->上传到本地
        String filePath = "chapter21\\src\\Copy.wmv";
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(filePath));

        //服务端监听本机端口
        ServerSocket serverSocket = new ServerSocket(8888);
        System.out.println("服务端,监听8888端口,等待连接...");

        //等待连接
        Socket socket = serverSocket.accept();

        //连接后创建数据通道的输入流/输出流
        InputStream inputStream = socket.getInputStream();
        OutputStream outputStream = socket.getOutputStream();

        /*byte[] buf = new byte[1024];
        int length;
        //从数据通道的输入流读取到图片数据
        while ((length = inputStream.read(buf)) != -1) {
            //通过字节输出流将数据写入到指定目录下的文件
            bos.write(buf,0,length);
        }*/

        //不使用缓冲数组的先读后写(简化了循环读写)
        byte[] bytes = StreamUtils.streamToByteArray(inputStream);
        bos.write(bytes);

        //从数据通道的输出流写入文本数据
        outputStream.write("收到图片".getBytes());

        //关闭资源
        outputStream.close();
        inputStream.close();
        bos.close();
        socket.close();
        serverSocket.close();
    }
}

/**
 * @ClassName
 * @Description
 * @Author zxk
 * @DateTime 2022-02-05-19:58
 * @Version 客户端
 * 连接到服务端-->发送磁盘里的文件-->接收到"收到图片"后退出
 */
public class Client {
    public static void main(String[] args) throws Exception {
        //创建字节输入流-->从磁盘读取到内存
        String filePath = "f:\\io\\bufferedCopy.wmv";
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(filePath));

        //连接到服务端
        Socket socket = new Socket(InetAddress.getLocalHost(), 8888);

        //创建数据通道的输出流/输入流
        OutputStream outputStream = socket.getOutputStream();
        InputStream inputStream = socket.getInputStream();


        /*byte[] buf = new byte[1024];
        int length;
        //通过字节输入流从磁盘读取到图片数据
        while ((length = bis.read(buf)) != -1) {
            //通过数据通道的输出流写入图片数据
            outputStream.write(buf,0,length);
        }*/

        //简化版先读后写
        byte[] bytes = StreamUtils.streamToByteArray(bis);
        outputStream.write(bytes);

        //设置传输结束标记
        socket.shutdownOutput();

        /*byte[] bytes = new byte[1024];
        int len;
        //通过数据通道的输入流读取文本数据
        while ((len = inputStream.read(bytes))!=-1) {
            System.out.println(new String(bytes,0,len));
        }*/

        //简化版循环读取打印
        String string = StreamUtils.streamToString(inputStream);
        System.out.println(string);

        //关闭资源
        inputStream.close();
        outputStream.close();
        bis.close();
        socket.close();
    }
}

案例五(下载文件)

1. 编写客户端程序和服务器端程序
2. 客户端可以输入一个音乐文件名，比如高山流水，服务端收到音乐名后，可以给客户端返回这个音乐文件，如果服务器没有这个文件，返回一个默认的音乐即可.
3. 客户端收到文件后，保存到本地e:\
4. 提示:该程序可以使用StreamUtils.java
   本质:其实就是指定下载文件的应用

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();
		
	}

}

public class Server {
    public static void main(String[] args) throws Exception {
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端,监听9999端口,等待连接...");
        Socket socket = serverSocket.accept();

        //接收文件名
        BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        String musicName = br.readLine();
        System.out.println("客户端点歌:"+musicName);

        String srcPath = "";
        if (musicName.equals("高山流水")) {
            srcPath = "chapter21\\src\\高山流水.mp3";
        } else {
            srcPath="chapter21\\src\\无名.mp3";
        }

        //提取文件数据到数组
        FileInputStream fileInputStream = new FileInputStream(srcPath);
        byte[] data = StreamUtils.streamToByteArray(fileInputStream);

        BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
        bos.write(data);

        bos.close();
        fileInputStream.close();
        br.close();
        socket.close();
        serverSocket.close();

    }
}

public class Client {
    public static void main(String[] args) throws Exception {
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);

        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入下载的音乐名");
        String music = sc.next();
        bw.write(music);
        bw.newLine();
        bw.flush();

        InputStream inputStream = socket.getInputStream();
        byte[] data = StreamUtils.streamToByteArray(inputStream);

        String destPath = "";
        if (music.equals("高山流水")) {
            destPath = "f:\\io\\高山流水.mp3";
        } else {
            destPath = "f:\\io\\zxk.mp3";
        }
        FileOutputStream fos = new FileOutputStream(destPath);
        fos.write(data);

        fos.close();
        inputStream.close();
        bw.close();
        socket.close();
        System.out.println("客户端退出");
    }
}

netstat指令

补充:

netstat -anb指令:

查看监听端口的应用:

必须在管理员身份下运行控制台输入指令

UDP 网络通信编程

介绍

1. 类DatagramSocket和DatagramPacket[数据报/数据包]实现了基于UDP协议网络程序。
2. UDP数据报通过数据报套接字DatagramSacket发送和接收,系统不保证UDP数据报一定能够安全送到目的地，也不能确定什么时候可以抵达。
3. DatagramPacket对象封装了UDP数据报，在数据报中包含了发送端的IP地址端口号以及接收端的IP地址和端口号。
4. UDP协议中每个数据报都给出了完整的地址信息，因此无须建立发送方和接收方的连接

基本流程

1. 核心的两个类/对象DatagrarnSocket与DatagramPacket
2. 建立发送端，接收端(没有服务端和客户端概念)
3. 发送数据前，建立数据报 DatagramPacket对象
4. 调用DatagramSocket的发送、接收方法
5. 关闭DatagramSocket

案例

1. 编写一个接收端A，和一个发送端B
2. 接收端A在9999端口等待接收数据(receive)
3. 发送端B向接收端A发送数据”hello，明天吃火锅~”
4. 接收端A接收到发送端B发送的数据，回复"好的，明天见"，再退出
5. 发送端接收回复的数据，再退出

/**
 * @ClassName
 * @Description
 * @Author zxk
 * @DateTime 2022-02-06-0:53
 * @Version 接收端A
 */
public class UDPReceiverA {
    public static void main(String[] args) throws IOException {
        //创建DatagramSocket对象-->在指定端口接收
        DatagramSocket socket = new DatagramSocket(9999);

        //创建DatagramPacket对象-->准备接收数据报
        byte[] bytes = new byte[1024];//接收数组
        DatagramPacket packet = new DatagramPacket(bytes, bytes.length);
        System.out.println("端口A,监听9999端口,等待接收...");
        //调用 接收方法, 将通过网络传输的 DatagramPacket 对象,填充到 packet对象
        socket.receive(packet);
        //拆包显示
        int length = packet.getLength();
        byte[] data = packet.getData();
        String s = new String(data, 0, length);
        System.out.println(s);

        //创建待发送数据报,并指明接收端的地址和端口
        byte[] buf = "好的明天见".getBytes();
        packet = new DatagramPacket(buf, buf.length,
                InetAddress.getByName("192.168.200.1"), 9998);
        socket.send(packet);

        socket.close();
        System.out.println("A端退出");
    }
}

/**
 * @ClassName
 * @Description
 * @Author zxk
 * @DateTime 2022-02-06-0:53
 * @Version 发送端B
 */
public class UDPSenderB {
    public static void main(String[] args) throws IOException {
        //创建DatagramSocket对象-->在指定端口接收
        DatagramSocket socket = new DatagramSocket(9998);

        //待发送数据封装到数据报
        byte[] data = "hello,明天吃火锅~".getBytes();
        //待发报中指明接收地址和端口
        DatagramPacket packet = new DatagramPacket(data, data.length,
                InetAddress.getByName("192.168.200.1"), 9999);
        socket.send(packet);

        //创建数据报准备接收
        byte[] bytes = new byte[1024];
        packet = new DatagramPacket(bytes, bytes.length);
        System.out.println("端口B,监听9998端口,等待接收...");
        //调用接收方法填充数据报
        socket.receive(packet);
        //拆包显示
        int length = packet.getLength();//实际接收的数据字节长度
        byte[] buf = packet.getData();//接收到的数据
        String s = new String(buf, 0, length);
        System.out.println(s);


        socket.close();
        System.out.println("B端退出");
    }
}