java网络通信编程

网络的相关概念

1.概念：两台设备之间通过网络实现数据传输

2.网络通信：将数据从网络从一台设备传输到另一台设备

3.java.net包下提供一系列的类或接口，供开发者使用，完成网络通信

4.根据网络覆盖范围不同，对网络进行分类：

​ 局域网：覆盖范围最小，仅仅覆盖一个教室或一个机房

​ 城域网：覆盖范围较大，可以覆盖一个城市

​ 广域网：覆盖范围最大，可以覆盖全国，甚至全球，万维网是广域网的代表

IP地址

1.概念：用于唯一标识网络中的每台计算机

2.查看IP地址：ipconfig

3.ip地址的表现形式：点分十进制 xx.xx.xx.xx

4.每一个十进制数的范围：0-255

5.IP地址的组成=网络地址+主机地址，比如：192.168.16.69

6.ilPv6是互联网工程任务组织设计的用于替代Ipv4的下一代协议，其地址数量号称为全世界的

每一粒沙子编上一个地址，同时也解决了网络地址资源有限，也解决多种接入设备连入互联网的障碍

域名

1.www.baidu.com

2.概念：将IP地址映射成域名

3.好处就是方便记忆ip的困难

端口号

1.概念：用于标识计算机上某个特定的网络程序

2.表示形式：以整数形式，范围0-65535

3.0-1024已经被占用，比如 ssh 22，ftp21，stmp 25 http 80

4.常见的网络程序端口号：

​ tomcat：8080

​ mysql：3306

​ oracle：1521

​ sqlserver：1433

网络通信协议

TCP/IP(Transmission Control Protocol/Internet Protocol)的简写

中文译名为传输控制协议/因特网互联协议，又叫网络通讯协议，这个协议是Internet最基本的协议，

Internet国际互联网络的基础，简单的说，就是由网络层的IP协议和传输层的Tcp协议组成的

OSI模型	TCP/IP模型	TCP/IP模型各层对应的协议
应用层	应用层	HTTP . ftp , telnet , DNS…
表示层	应用层	HTTP . ftp , telnet , DNS…
会话层	应用层	HTTP . ftp , telnet , DNS…
传输层	传输层	TCP, UDP,…
网络层	网络层	IP, ICMP, ARP
数据链路层	物理+数据链路层	Link
物理层	物理+数据链路层	Link

准确来说人和人交流(通讯):依靠语言[中文，英语，法语]

语言本身就是一种协议

数据在网络编程中数据的组织形式就是协议 ，回复数据也需要按照规定的协议形式

TCP协议

1.使用TCP协议前，须先建立TCP连接，形成传输数据通道

2.传输前，采用三次握手方式，是可靠的

3.TCP协议进行通信的两个应用程序：客户端，服务端

4.在连接中可以进行大数据量的传输

5.传输完毕，须释放已建立的连接，效率低

UDP协议

1.将数据，源，目的封装成数据包，不需要建立连接

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

3.因无需连接，故是不可靠的

4.发送数据结束时无需释放资源（因为不是面向连接的），速度快

5.举例：厕所通知：发短信

InetAddress类相关方法

import java.net.InetAddress;
import java.net.UnknownHostException;

public class API_ {
    public static void main(String[] args) throws UnknownHostException {
        //1.获取本机的InetAddress对象
        InetAddress localHost = InetAddress.getLocalHost();
        System.out.println(localHost);

        //2.根据主机名获取InetAddress
        InetAddress byName = InetAddress.getByName("LAPTOP-AK488A5P");
        System.out.println(byName);

        //3.根据域名返回InetAddress对象，比如www.baidu.com
        InetAddress byName1 = InetAddress.getByName("www.baidu.com");
        System.out.println(byName1);

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

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

Socket(电源插口)

1.套接字(Socket)开发网络应用程序被广泛采用，以至于称为事实上的标准

2.通信的两端都要有Socket，是两台机器通信间的端点

3.网络通信其实就是Socket之间的通信

4.Socket允许程序把网络连接当成一个流，数据在两个Socket通过IO传输

5.一般主动发起通信的应用程序是客户端，等待通信请求的为服务端

TCP网络通信编程

TCP字节流编程

客户端向服务端发起通信

import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class SocketTCPServer {
    public static void main(String[] args) throws IOException {
        /**
          *编写一个服务端
          **/
        //思路
        //1.在本机的9999端口监听，等待连接
        //  细节：要求在本机没有其他服务器在监听9999端口
        // 细节：这个ServerSocket 可以通过accept（）返回多个Socket[多个客户端连接服务器的并发]
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端，在9999端口监听，等待连接");
        //2.当没有客户端连接9999端口时，程序会阻塞，等待连接
        //如果有程序会连接则返回Socket对象
        Socket socket = serverSocket.accept();
        System.out.println("服务端 socket = "+socket.getClass());
        //3.通过socket.getInputStream()读取客户端写入到数据通道的数据，显示
        InputStream inputStream = socket.getInputStream();
        //读取客户端的数据
        byte[] bytes = new byte[1024];
        int readLen= 0;
        while((readLen= inputStream.read(bytes)) != -1){
            System.out.println(new String(bytes,0,readLen));//根据读取到的实际长度，显示内容
        }
        //关闭流和socket
        inputStream.close();
        socket.close();
        serverSocket.close();
        System.out.println("服务器已经接收到客户端的通信");
    }
}

import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;

public class SocketTCPClient {
    //编写一个客户端
    public static void main(String[] args) throws IOException {
//      1.连接服务端(IP,端口)
        //连接本机的9999端口
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
        System.out.println("客户端 socket返回="+socket.getClass());
//        2.连接上后，生成Socket通过socket.getOutputStream()
        OutputStream outputStream = socket.getOutputStream();
//        3.通过输出流，写入数据到数据通道
        outputStream.write("hello,server".getBytes());
        //4.关闭流对象和socket
        outputStream.close();
        socket.close();
        System.out.println("客户端退出.....");
    }
}

服务端向客户端发起通信

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class SocketTCPServer {
    public static void main(String[] args) throws IOException {
        /**
          *编写一个服务端
          **/
        //思路
        //1.在本机的9999端口监听，等待连接
        //  细节：要求在本机没有其他服务器在监听9999端口
        // 细节：这个ServerSocket 可以通过accept（）返回多个Socket[多个客户端连接服务器的并发]
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端，在9999端口监听，等待连接");
        //2.当没有客户端连接9999端口时，程序会阻塞，等待连接
        //如果有程序会连接则返回Socket对象
        Socket socket = serverSocket.accept();
        System.out.println("服务端 socket = "+socket.getClass());
        //3.通过socket.getOutputStream写入到数据通道发送到客户端
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("hello,Client".getBytes());
        //关闭流和socket
        outputStream.close();
        socket.close();
        serverSocket.close();
        System.out.println("服务器向客户端发起通信");
    }
}

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;

public class SocketTCPClient {
    //编写一个客户端
    public static void main(String[] args) throws IOException {
//      1.连接服务端(IP,端口)
        //连接本机的9999端口
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
        System.out.println("客户端 socket返回="+socket.getClass());
        
        //读取服务端的数据
        InputStream inputStream = socket.getInputStream();
        byte[] bytes = new byte[1024];
        int readLen= 0;
        while((readLen= inputStream.read(bytes)) != -1){
            System.out.println(new String(bytes,0,readLen));//根据读取到的实际长度，显示内容
        }

        //4.关闭流对象和socket
        inputStream.close();
        socket.close();
        System.out.println("客户端接收到服务端的信息");

TCP字符流编程

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

public class SocketTCPServer {
    public static void main(String[] args) throws IOException {
        /**
          *编写一个服务端
          **/
        //思路
        //1.在本机的9999端口监听，等待连接
        //  细节：要求在本机没有其他服务器在监听9999端口
        // 细节：这个ServerSocket 可以通过accept（）返回多个Socket[多个客户端连接服务器的并发]
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端，在9999端口监听，等待连接");
        //2.当没有客户端连接9999端口时，程序会阻塞，等待连接
        //如果有程序会连接则返回Socket对象
        Socket socket = serverSocket.accept();
        System.out.println("服务端 socket = "+socket.getClass());
        //3.通过socket.getOutputStream写入到数据通道发送到客户端
        OutputStream outputStream = socket.getOutputStream();
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
        bufferedWriter.write("hello,Client,字符流");
        bufferedWriter.newLine();//插入一个换行符，表示写入的内容结束
        bufferedWriter.flush();//如果使用字符流，需要手动刷新，否则数据不会写入到数据通道
        //关闭流和socket
        outputStream.close();
        socket.close();
        serverSocket.close();
        System.out.println("服务器向客户端发起通信");
    }
}

import java.io.*;
import java.net.InetAddress;
import java.net.Socket;

public class SocketTCPClient {
    //编写一个客户端
    public static void main(String[] args) throws IOException {
//      1.连接服务端(IP,端口)
        //连接本机的9999端口
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
        System.out.println("客户端 socket返回="+socket.getClass());
        2.连接上后，生成Socket通过socket.getOutputStream()
//        OutputStream outputStream = socket.getOutputStream();
        3.通过输出流，写入数据到数据通道
//        outputStream.write("hello,server".getBytes());
        //        InputStream inputStream = socket.getInputStream();
        //读取服务端的数据
        InputStream inputStream = socket.getInputStream();
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
        String s = bufferedReader.readLine();
        System.out.println(s);


        //4.关闭流对象和socket
        bufferedReader.close();
        inputStream.close();
        socket.close();
        System.out.println("客户端接收到服务端的信息");
    }
}

传送文件

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;

public class TCPClient {
    //文件上传的客户端
    public static void main(String[] args) throws IOException {
        //客户端连接服务端8888，得到Socket
        Socket socket = new Socket(InetAddress.getLocalHost(), 8888);
        //创建读取磁盘文件的输入流
        String filePath = "D:\\Google\\1.png";
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(filePath));

        //bytes就是filePath对应的字节数组
        byte[] bytes = StreamUtils.streamToByteArray(bis);

        //通过socket获取到输出流，将bytes数据发送给服务端
        BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
        bos.write(bytes);
        bis.close();
        socket.shutdownOutput();//设置写入数据的结束标记

        //关闭相关流
        bos.close();
        socket.close();

    }
}

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

public class TcpServer {
    public static void main(String[] args) throws IOException {
        //1.服务端在本机监听8888端口
        ServerSocket serverSocket = new ServerSocket(8888);
        System.out.println("服务端在8888端口监听");
        //2.等待连接
        Socket socket = serverSocket.accept();
        //3.读取客户端发送的数据
        BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
        byte[] bytes = StreamUtils.streamToByteArray(bis);
        //将得到bytes数组，写入到指定的路径，就得到一个文件了
        String destFilePath = "D:\\java开发\\网络通信\\src\\11.png";
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFilePath));
        bos.write(bytes);
        bos.close();

        //关闭其他资源
        bis.close();
        socket.close();
        serverSocket.close();


    }
}

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;

public class StreamUtils {
    public static byte[] streamToByteArray(InputStream is) throws IOException {
        /**
         *封装的一个方法 
         *将输入流转换成byte[]*/
        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;
    }
}

netstat指令

1.netstat -an可以查看主机网络情况，包括端口监听情况和网络连接情况

2.netstat -an |more可以分页显示

3.是在dos控制台下执行win+r

​ 说明：(1).Listening表示某个端口在监听

​ (2).如果有一个外部程序(客户端连接)连接到该端口，就会显示一条连接信息

​ (3).可以输入ctrl+c退出指令

UDP网络通信编程[了解]

基本介绍

1.类DataagramSocket和DatagramPacket实现了基于UDP协议网络程序

2.UDP数据报通过数据报套接字DatagramSocket发送和接收，系统不保证UDP数据报

​ 一定能够安全送到目的地，也不确定什么时候可以抵达

3.DatagramPacket对象封装了UDP数据报，在数据报中包含了发送端的IP地址和

​ 端口号以及接收端的IP地址和端口号

4.UDP协议中每个数据报都给出了完整的地址信息，因此无需建立发送方和接收方的连接

基本流程

1.核心的两个类/对象 DatagramSocket与DatagramPacket

2.建立发送端，接收端

3.建立数据包/报DatagramPacket

4.调用DatagramSocket的发送，接收方法

5.关闭DatagramSocket

应用案例

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;

public class UdpReceive {
    public static void main(String[] args) throws IOException {
        //1.创建一个DatagramSocket对象，准备在9999端口接收数据
        DatagramSocket socket = new DatagramSocket(9999);
        //2.构建一个DatagramPacket，准备接收数据，一个数据包最大64k
        byte[] buf = new byte[1024];
        DatagramPacket datagramPacket = new DatagramPacket(buf, buf.length);
        //3.调用接收方法  将通过网络传输的DatagramPacket对象
        //填充到packet对象
        //当有数据包发送到本机的9999端口时，就会接收到数据
        //如果数据包没有发送到本机的9999端口，就会阻塞等待
        System.out.println("接收端等待接收数据......");
        socket.receive(datagramPacket);

        //4.可以把packet进行拆包，取出数据，并显示
        int length = datagramPacket.getLength();//实际接收到的数据字节长度
        byte[] data = datagramPacket.getData();//接收数据
        String s = new String(data,0,length);
        System.out.println(s);

        //关闭资源
        socket.close();
        System.out.println("接口端退出");
    }
}

import java.io.IOException;
import java.net.*;
import java.nio.charset.StandardCharsets;

public class UdpSendOut {
    public static void main(String[] args) throws IOException {
        //发送端
        //创建DatagramSocket对象，准备在9998端口发送数据和接收数据
        DatagramSocket socket = new DatagramSocket(9998);
        byte[] data  = "hello 明天吃火锅-".getBytes();
        //说明：封装的DatagramPacket对象data内容字节数组，data.length,主机ip，端口
        DatagramPacket packet =
                new DatagramPacket(data, data.length, InetAddress.getLocalHost(), 9999);
        socket.send(packet);

        //关闭资源
        socket.close();
        System.out.println("发送端退出");
    }
}
SendOut {
    public static void main(String[] args) throws IOException {
        //发送端
        //创建DatagramSocket对象，准备在9998端口发送数据和接收数据
        DatagramSocket socket = new DatagramSocket(9998);
        byte[] data  = "hello 明天吃火锅-".getBytes();
        //说明：封装的DatagramPacket对象data内容字节数组，data.length,主机ip，端口
        DatagramPacket packet =
                new DatagramPacket(data, data.length, InetAddress.getLocalHost(), 9999);
        socket.send(packet);

        //关闭资源
        socket.close();
        System.out.println("发送端退出");
    }
}