网络通信

javaweb：网页编程 B/S
网络编程：TCP/IP C/S

1、网络通信的要素

如何实现网络的通信？
通信双方地址

• IP
• 端口号
• 192.168.16.124:5900

规则：网络通信的协议
TCP/IP参考模型：

小结：
1、网络编程中有两个主要的问题：

• 如何准确地定位到网络上的一台或者多台主机
• 找到主机后如何进行通信

2、网络编程中的要素

• IP和端口号 IP
• 网络通信协议 UDP、TCP

3、万物皆对象

2、IP

ip地址：InetAddress

• 唯一定位一台网络上的计算机
• 127.0.0.1：本机 localhost
• ip地址的分类
  • IPv4 / IPv6
    • IPv4 127.0.0.1 四个字节组成 0~255
    • IPv6 128位。 8个无符号整数 例：2001:0bb2:aaaa:0015:0000;0000;1aaa;1312
  • 公网（互联网）-私网（局域网）
    • ABCD类地址
    • 192.168.xx.xx专门给组织内部使用
• 域名：记忆IP问题
  • IP：

//测试IP
public class TestInetAddress {
    public static void main(String[] args) {
        try {
            //查询本机地址
            InetAddress inetAddress1 = InetAddress.getByName("127.0.0.1");
            System.out.println(inetAddress1);
            InetAddress inetAddress3 = InetAddress.getByName("localhost");
            System.out.println(inetAddress3);
            InetAddress inetAddress4 = InetAddress.getLocalHost();
            System.out.println(inetAddress4);

            //查询网站ip地址
            InetAddress inetAddress2 = InetAddress.getByName("www.baidu.com");
            System.out.println(inetAddress2);

            //常用方法
//            System.out.println(inetAddress2.getAddress());
            System.out.println(inetAddress2.getCanonicalHostName());//规范的名字
            System.out.println(inetAddress2.getHostAddress());//ip
            System.out.println(inetAddress2.getHostName());//域名，或者自己电脑的名字

        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
    }
}

3、端口

端口表示计算机上一个程序的进程

• 不同的进程有不同的端口号，用来区分软件
• 被规定：0 - 65535
• TCP,UDP：65535 * 2 tcp：80 udp：80，单个协议下，端口号不能冲突
• 端口号分类：
  • 公有端口：0 - 1023
    • HTTP：80
    • HTTPS：443
    • FTP：21
    • Telent：23
  • 程序注册端口：1024 - 49151，分配给用户或程序
    • Tomcat：8080
    • MySQL：3306
    • Oracle：1521
  • 动态端口（私有端口）：49152 - 65535

netstat -ano #查看所有端口
netstat -ano | findstr "5900" #查看指定的端口
tasklist|findstr "17664" #查看指定端口的进程

4、通信协议

TCP/IP协议簇
重要：

• TCP：用户传输协议
• UDP：用户数据包协议
  出名的协议：
• TCP：
• IP：网络互连协议

TCP UDP对比：

• TCP：打电话
  • 连接，稳定
  • 三次握手、四次挥手
  • 客户端，服务端
  • 传输完成，释放连接，效率低
• UDP：发短信
  • 不连接，不稳定
  • 客户端，服务端，没有明确的界限
  • 不管有没有连接好，都可以发送
  • DDOS：洪水攻击（饱和攻击）

5、TCP

客户端
1、通过Socket连接服务器
2、发送消息

//客户端
public class TcpClientDemo01 {
    public static void main(String[] args) {

        Socket socket = null;
        OutputStream os = null;

        try {
            //1.要知道服务器的地址、端口号
            InetAddress serverIp = InetAddress.getByName("127.0.0.1");
            int port = 9999;
            //2.创建一个socket连接
            socket = new Socket(serverIp, port);
            //3.发送消息 IO流
            os = socket.getOutputStream();

            os.write("你好".getBytes());

        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if (os != null){
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(socket != null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

服务器
1、建立服务端口 ServerSocket
2、accept等待用户连接
3、接收用户的消息

//服务端
public class TcpServerDemo01 {
    public static void main(String[] args) {

        ServerSocket serverSocket = null;
        Socket socket = null;
        InputStream inputStream = null;
        ByteArrayOutputStream baos = null;

        try {
            //1.需要有一个地址
            serverSocket = new ServerSocket(9999);
            //2.等待客户端连接
            socket = serverSocket.accept();
            //3.读取客户端的消息
            inputStream = socket.getInputStream();

            /*
                byte[] buffer = new byte[1024];
                int len;
                while((len = inputStream.read()) != -1){
                    String s = new String(buffer, 0, len);
                    System.out.println(s);
                }
             */
            //管道流
            baos = new ByteArrayOutputStream();
            byte[] buffer = new byte[1024];
            int len;
            while((len = inputStream.read(buffer)) != -1){
                baos.write(buffer, 0,len);

            }
            System.out.println(baos.toString());
            
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //关闭资源
            if(baos != null){
                try {
                    baos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(inputStream != null){
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(socket != null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(serverSocket != null){
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

文件上传

服务器端

public class TcpServerDemo02 {
    public static void main(String[] args) throws Exception {
        //1.创建服务
        ServerSocket serverSocket = new ServerSocket(9000);
        //2.监听客户端的连接
        Socket socket = serverSocket.accept();  //阻塞式监听，会一直等待客户端连接
        //3.获取输入流
        InputStream is = socket.getInputStream();
        //4.文件输出
        FileOutputStream fos = new FileOutputStream(new File("C:/Users/82784/Desktop/receive.jpg"));
        byte[] buffer = new byte[1024];
        int len;
        while((len = is.read(buffer)) != -1){
            fos.write(buffer, 0, len);
        }

        //通知客户端接收完毕
        OutputStream os = socket.getOutputStream();
        os.write("我接收完毕".getBytes());

        //关闭资源
        os.close();
        fos.close();
        is.close();
        socket.close();
        serverSocket.close();
    }
}

客户端

public class TcpClientDemo02 {
    public static void main(String[] args) throws Exception {
        //1.建立Socket连接
        Socket socket = new Socket(InetAddress.getByName("127.0.0.1"),9000);
        //2.创建一个输出流
        OutputStream os = socket.getOutputStream();

        //3.读取文件
        FileInputStream fis = new FileInputStream(new File("C:/Users/82784/Desktop/1.jpg"));
        //4.输出文件
        byte[] buffer = new byte[1024];
        int len;
        while((len = fis.read(buffer)) != -1){
            os.write(buffer, 0, len);
        }

        //通知服务器，我已经结束了
        socket.shutdownOutput();    //我已经传输完了

        //确定服务器接收完毕，断开连接
        InputStream inputStream = socket.getInputStream();
        //String byte[]
        ByteArrayOutputStream baos = new ByteArrayOutputStream();

        byte[] buffer2 = new byte[1024];
        int len2;
        while ((len2 = inputStream.read(buffer2)) != -1){
            baos.write(buffer2, 0, len2);
        }

        System.out.println(baos.toString());

        //关闭资源
        baos.close();
        inputStream.close();
        fis.close();
        os.close();
        socket.close();
    }
}

6、UDP

发送消息

public class UdpClientDemo01 {
    public static void main(String[] args) throws Exception {
        //1.建立一个Socket
        DatagramSocket socket = new DatagramSocket();
        //2.建立一个包
        String msg = "你好，服务器";
        //发送对象
        InetAddress address = InetAddress.getByName("localhost");
        int port = 9090;
        //数据，数据的起始，发送的对象，端口
        DatagramPacket packet = new DatagramPacket(msg.getBytes(), 0, msg.getBytes().length, address, port);
        //3.发送一个包
        socket.send(packet);
        //4.关闭流
        socket.close();
    }
}

接收端

//等待客户端的连接
public class UdpServerDemo01 {
    public static void main(String[] args) throws Exception {
        //1.开放端口
        DatagramSocket socket = new DatagramSocket(9090);
        //2.接收数据包
        byte[] buffer = new byte[1024];
        DatagramPacket packet = new DatagramPacket(buffer, 0, buffer.length);

        socket.receive(packet); //阻塞接收

        System.out.println(packet.getAddress().getHostAddress());
        System.out.println(new String(packet.getData(), 0, packet.getLength()));
        //3.关闭连接
        socket.close();
    }
}

单方面循环发送消息

public class UdpSenderDemo01 {
    public static void main(String[] args) throws Exception {

        DatagramSocket socket = new DatagramSocket(8888);

        //准备数据：控制台读取：System.in
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

        while (true){
            String data = reader.readLine();
            byte[] datas = data.getBytes();
            DatagramPacket packet = new DatagramPacket(datas, 0, datas.length, new InetSocketAddress("localhost", 6666));

            socket.send(packet);
            if(data.equals("bye")){
                break;
            }
        }
        socket.close();

    }
}

public class UdpReceiveDemo01 {
    public static void main(String[] args) throws Exception {

        DatagramSocket socket = new DatagramSocket(6666);

        while(true){
            //准备接收包裹
            byte[] container = new byte[1024];

            DatagramPacket packet = new DatagramPacket(container, 0, container.length);
            socket.receive(packet); //阻塞式接收包裹

            // 断开连接
            byte[] data = packet.getData();
            String receiveData = new String(data, 0, data.length);

            System.out.println(receiveData);

            if (receiveData.equals("bye")){
                break;
            }
        }
        socket.close();
    }
}

在线咨询：两个人都可以是发送方，都可以是接收方

8、URL

统一资源定位符：定位互联网上某一个资源的位置

DNS域名解析：将域名解析为IP地址

协议:// 域名或IP地址 :端口号/项目名/资源