网络编程

1.1 概述

计算机网络

计算机网络是指将地理位置不同的具有独立功能的多台过算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统。

网络编程的目的

传播交流信息数据交换通信

想要达到这个效果需要什么

如何准确的定位网络上的一台主机，
- IP地址，端口，定位到这个计算机上的某个资源
找到了这个主机，如何传播数据？

区分：

javaweb:网页编程 B/S

网络编程：TCP/IP C/S

1.2 网络通信的要素

如何实现网络的通信？

通信双方的地址：

ip
端口号
192.168.16.124：5900

规则：网络通信的协议

TCP/IP参考模型：

小结：

网络编程中有两个主要的问题
- 如何准确的定位到网络上的一台或者多台主机
- 找到主机之后如何进行通信
网络编程中的要素
- IP和端口号
- 网络通信协议 UDP TCP
万物皆对象

1.3 IP

ip地址：InetAddress

唯一定位一台网络计算机
127.0.0.1：本机 localhost
ip地址的分类
- IPV4/IPV6
  - IPV4 127.0.0.1 4个字节组成，每个字节长度0-255，42亿
  - IPV6 128位，8个无符号整数！abcde
```
2001:0bb2:aaaa:0015:0000:0000:1aaa:1312
```
- 公网(互联网)-私网（局域网）
  - ABCD类地址
  - 192.168.xx.xx 专门给组织内部使用的
域名：记忆IP问题
- IP

代码测试：

package com.hao.lesson01;

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

//测试ip
public class TestInetAddress {
    public static void main(String[] args) {
        try {
            //查询本机地址
            InetAddress inetAddresses1 = InetAddress.getByName("127.0.0.1");
            System.out.println(inetAddresses1);
            InetAddress inetAddresses3 = InetAddress.getByName("localhost");
            System.out.println(inetAddresses3);
            InetAddress inetAddresses4 = InetAddress.getLocalHost();
            System.out.println(inetAddresses4);
            //查询网站ip地址
            InetAddress inetAddresses2 = InetAddress.getByName("www.baidu.com");
            System.out.println(inetAddresses2);
            //查用方法
            System.out.println(inetAddresses2.getAddress());//没啥用
            System.out.println(inetAddresses2.getCanonicalHostName());//获得他规范的名字 也没啥用
            System.out.println(inetAddresses2.getHostAddress());//ip
            System.out.println(inetAddresses2.getHostName());//域名，或者自己电脑的名字

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

1.4 端口

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

不同的进程有不同的端口号，用来区分软件
被规定0-65535
TCP,UDP：
- 每个端口可以有65535*2 个线程
- 单个协议下，端口号不能冲突

端口分类

公有端口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 "端口号" # |管道符过滤的意思，先执行后面的话 然后在里面找 查看指定的端口
tasklist|findstr "24892" #查看某个端口号下面的的进程是哪个

代码测试：

package com.hao.lesson01;

import java.net.InetSocketAddress;

public class TestInetSocketAddress {
    public static void main(String[] args) {
        InetSocketAddress address = new InetSocketAddress("127.0.0.1", 8080);
        InetSocketAddress address2 = new InetSocketAddress("localhost", 8080);
        System.out.println(address);
        System.out.println(address2);

        System.out.println(address.getAddress());//返回InetAddress
        System.out.println(address.getHostName());//地址
        System.out.println(address.getPort());//端口
    }
}

两台电脑进行通信时，要访问正确的端口号！！

1.5 通信协议

协议：约定，就好比我们现在说的是普通话。

网络通信协议：速率，传输码率，代码结构，传输控制......

问题：非常的复杂？

大事化小：分层！

TCP/IP 协议簇：实际上是一组协议

重要：

TCP：用户传输协议
UDP：用户传输报协议

出名的协议：

TCP：
IP:网络互联协议

TCP UDP对比

TCP：打电话

连接，稳定
三次握手，四次挥手

最少需要三次，保证稳定连接！
A：你瞅啥？
B：瞅你咋地？
A：干一场

分手，需要四次挥手
A：我要走了！
B：你真的要走了吗？
B：你真的真的要走了吗？
A：我真的要走了！

客服端、服务端
传输完成，释放连接，效率低

UDP：发短信

不连接，不稳定
客户端、服务端：没有明确的界限
不管有没有准备好，都可以发给你
导弹
DDOS：洪水攻击

1.6 TCP

TCP聊天

客户端

连接服务器 socket
发送消息

服务器

建立服务的端口ServerSocket
等待用户的连接 accept

socket = serverSocket.accept();

接受用户的消息

客户端代码

package com.hao.lesson02;

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

// 客户端
public class TcpClientDemo01 {
    public static void main(String[] args) {
        Socket socket=null;
        OutputStream os=null;
        try {
            //1.要知道服务器的地址ip,端口号
            InetAddress serverIP = InetAddress.getByName("127.0.0.1");
            int port=9999;
            //2.创建一个socket连接
            socket = new Socket(serverIP,port);//扩大异常作用域Exception e
            //3.发送消息，IO流
            os = socket.getOutputStream();//创建一个输出流

            os.write("你好，欢迎学习小豪学Java".getBytes());//写什么了,然后把他变成二进制

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

服务器端代码

package com.hao.lesson02;

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

//服务端
public class TcpServerDemo01 {
    public static void main(String[] args) {
        //提升作用域
        ServerSocket serverSocket=null;
        Socket socket=null;
        InputStream is=null;
        ByteArrayOutputStream baos = null;
        try {
            //1.我得有一个地址
            serverSocket = new ServerSocket(9999);//Socket插座 参数是端口号
            //2.等待客户端连接过来
            socket = serverSocket.accept();
            //3.读取客户端的消息
            is = socket.getInputStream();
            /*
            byte[] buffer = new byte[1024];
            int len;
            while((len=is.read(buffer))!=-1){
                String msg = new String(buffer,0,len);
                System.out.println(msg);
            }
             */
            //管道流
            baos = new ByteArrayOutputStream();//作为正常的管道连接
            byte[] buffer = new byte[1024];
            int len;
            while((len=is.read(buffer))!=-1){
                baos.write(buffer,0,len);//将读取的信息写入baos
            }
            System.out.println(baos.toString());


        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭资源
            if (baos!=null){
                try {
                    baos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (is!=null){
                try {
                    is.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();
                }
            }


        }
    }
}

TCP文件上传实现

客户端代码

package com.hao.lesson02;


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

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("1.png"));
        //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();

        ByteArrayOutputStream baos = new ByteArrayOutputStream();//服务器输出的是一个Byte类型数据，通过一个管道流
        byte[] buffer2 = new byte[1024];
        int len2;
        while((len2=inputStream.read(buffer2))!=-1){//inputStream.read(buffer2 读取buffer2中的数据
            baos.write(buffer2,0,len2);//写入baos中
        }
        System.out.println(baos.toString());
        //5.关闭资源
        baos.close();
        inputStream.close();
        fis.close();
        os.close();
        socket.close();
    }

}

服务器端代码

package com.hao.lesson02;

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

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("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());
        //关闭资源
        fos.close();
        is.close();
        socket.close();
        serverSocket.close();




    }
}

Tomcat

后面会重点进行学习！

服务端

自定义S
Tomcat服务器 S:java后台开发

客户端

自定义C
浏览器 B

1.7 UDP

发短信：不用连接，需要知道对方的地址！

DatagramPacket

DatagramSocket

发送消息

发送端

package com.hao.lesson03;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;

// 不需要连接服务器
public class UdpClientDemo01 {
    public static void main(String[] args) throws Exception {
        //1.建立一个Socket
        DatagramSocket socket = new DatagramSocket();
        //2.建个包
        String msg = "你好啊，服务器！";
        //发送给谁
        InetAddress localhost = InetAddress.getByName("localhost");
        int port = 9090;
        //msg.getBytes变成字节数组
        // 参数含义：数据 数据长度起，始 要发送给谁 端口号
        DatagramPacket packet = new DatagramPacket(msg.getBytes(),0,msg.getBytes().length,localhost,port);
        //3.发送包
        socket.send(packet);
        //4.关闭流
        socket.close();
    }
}

接收端

package com.hao.lesson03;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
//还是要等待客户端的连接
public class UdpServerDemo01 {
    public static void main(String[] args) throws Exception {
        //开放端口
        DatagramSocket socket = new DatagramSocket(9090);
        //接收数据
        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()));
        //packet.getData()是Byte类型，通过new String(packet.getData())转换为字符串

        //关闭连接
        socket.close();
    }
}

循环发消息

package com.hao.chat;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;


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",8066));//发给谁，发给那个端口

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

package com.hao.chat;

import java.net.DatagramPacket;
import java.net.DatagramSocket;

public class UdpReceiveDemo01 {
    public static void main(String[] args) throws Exception {
        DatagramSocket socket = new DatagramSocket(8066);
        while(true){

            //准备接受包裹
            byte[] container = new byte[1024];
            DatagramPacket packet = new DatagramPacket(container,0,container.length);
            socket.receive(packet);//阻塞式接受包裹
            //断开连接 bye
            byte[] data = packet.getData();//接受包裹内的数据
            String receiveData = new String(data, 0, data.length);
            System.out.println(receiveData);
            if(receiveData.equals("bye")){
                break;
            }
        }
        socket.close();
    }
}

多线程在线聊天

TalkSend

package com.hao.chat;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.net.SocketException;

public class TalkSend implements  Runnable{
    DatagramSocket socket = null;
    BufferedReader reader = null;
    private int fromPort;
    private String toIP;
    private int toPort;

    public TalkSend(int fromPort, String toIP, int toPort) {
        this.fromPort = fromPort;
        this.toIP = toIP;
        this.toPort = toPort;
        try {
            socket = new DatagramSocket(fromPort);
            reader = new BufferedReader(new InputStreamReader(System.in));
        } catch (SocketException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        while(true){
            String data = null; //我们的数据
            try {
                data = reader.readLine();
                byte[] datas = data.getBytes(); //转换成具体的数据
                DatagramPacket packet = new DatagramPacket(datas,0,datas.length,new InetSocketAddress(this.toIP,this.toPort));//发给谁，发给那个端口

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

TalkReceive

package com.hao.chat;

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

public class TalkReceive implements Runnable{
    DatagramSocket socket=null;
    private int port;
    private String msgFrom;
    public TalkReceive(int port,String msgFrom) {
        this.port = port;
        this.msgFrom=msgFrom;
        try {
            socket = new DatagramSocket(port);
        } catch (SocketException e) {
            e.printStackTrace();
        }
    }
    @Override
    public void run() {
        while(true){
            try {
                //准备接受包裹
                byte[] container = new byte[1024];
                DatagramPacket packet = new DatagramPacket(container,0,container.length);
                socket.receive(packet);//阻塞式接受包裹
                //断开连接 bye
                byte[] data = packet.getData();//接受包裹内的数据
                String receiveData = new String(data, 0, data.length);
                System.out.println(msgFrom+"："+receiveData);
                if(receiveData.equals("bye")){
                    break;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        socket.close();
    }
}

TalkStudent

package com.hao.chat;

public class TalkStudent {
    public static void main(String[] args) {
        //开启两个线程
        new Thread(new TalkSend(777,"localhost",9999)).start();
        new Thread(new TalkReceive(8888,"老师")).start();
    }
}

TalkTeacher

package com.hao.chat;

public class TalkTeacher {
    public static void main(String[] args) {
        new Thread(new TalkSend(5555,"localhost",8888)).start();
        new Thread(new TalkReceive(9999,"学生")).start();
    }
}

1.8 URL

https://www.baidu.com/

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

DNS 域名解析 :把www.baidu.com变成一个Ip

协议：//ip地址：端口号/项目名/资源

package com.hao.lesson04;

import java.net.MalformedURLException;
import java.net.URL;

public class URLDemo01 {
    public static void main(String[] args) throws MalformedURLException {
        URL url = new URL("http://localhost:8080/helloworld/index.jsp?username=xiaohao&password=123");
        System.out.println(url.getProtocol());//协议名
        System.out.println(url.getHost());//主机Ip
        System.out.println(url.getPort());//端口号
        System.out.println(url.getPath());//文件
        System.out.println(url.getFile());//文件全路径
        System.out.println(url.getQuery());//得到url查询的名字，带的参数
    }
}

通过Tomcat与URL下载资源

package com.hao.lesson04;

import java.io.FileOutputStream;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;

public class UrlDown {
    public static void main(String[] args) throws Exception {
        //1.下载地址
        URL url = new URL("http://localhost:8080/xiaohao/securityfile.txt");
        //2.连接到这个资源
        HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();

        InputStream inputStream = urlConnection.getInputStream();
        FileOutputStream fos = new FileOutputStream("securityfile.txt");//新创建一个文件夹接受文件

        byte[] buffer = new byte[1024];//缓冲区
        int len;
        while((len=inputStream.read(buffer))!=-1){
            fos.write(buffer,0,len);//将读取到的buffer内容写入fos,写出这个数据
        }
        fos.close();
        inputStream.close();
        urlConnection.disconnect();//断开连接


    }
}

JavaSE java

网络编程

网络编程

1.1 概述

1.2 网络通信的要素

1.3 IP

1.4 端口

1.5 通信协议

1.6 TCP

TCP聊天

TCP文件上传实现

Tomcat

1.7 UDP

发送消息

循环发消息

多线程在线聊天

1.8 URL

相关

JavaWeb的三大作用域

java中常用数组copy方法

6.Java方法

Java web开发：从零到 Run 一个现有的 Spring Boot 前后端分离项目（前端Vue）

javascript基础知识(29) 实现继承的方式

java 正则表达式

JAVA List<Object[]>取值问题

初次接触Java感受

99乘法表 java for循环

基于java.net.socket包的对象传递

Idea Java项目文件夹后面提示百分数怎么去掉

Java8新特性

标签