[网络协议]网络编程的学习

网络编程

1.1、概述

计算机网络：

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

网络编程得目的：

无线电台…传播信息交流，数据交换。通信
.
javaweb：网络编程 B/S（浏览器）
网络编程：TCP/IP C/S（客户端）
.

1.2、网络通信得要素

如何实现网络得通信：
通信双方地址：

• IP
• 端口号
• 192.168.16，124:5900

规则： 网络通信的协议
小结：

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

1.3、IP

ip地址：inetAddress

• 唯一定位一台网络上计算机
• 127.0.0.1：本机localhost
• ip地址的分类

a：ipv4/ipv6
ipv4： 127.0.0.1 ，4个字节组成。
ipv6： 128位。8个为u符号整数！
.
b：公网(互联网)-私网(局域网)
ABCD类地址
192.168.xx.xx，专门给组织内部使用的

• 域名：记忆IP问题！
  IP：www.baidu.com

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.getCanonicalHostName());//规范得名字
            System.out.println(inetAddress2.getHostAddress());//ip
            System.out.println(inetAddress2.getHostName());//域名，或者自己电脑得名称

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

.

1.4、端口

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

• 不同得进程有不同得端口号！用来区分软件！
• 被规定 0-65535
• TCP，UDP ：65535*2 单个协议下，端口号不能冲突
• 端口分类

a. 公有端口 0-1023
HTTP ：80
HTTPS：443
FTP ： 21
Telent ：23
.
b. 程序注册端口： 1024-49151，分配用户或者程序
Tomcat ：8080
MySQL ：3306
Oracle ：1521
.
c. 动态、私有：49152-65535
netstat -ano #查询所有得端口
netstat -ano|findstr “5900” #查询指定得端口
tasklist|findstr “8696” #查询指定端口得进程

.

1.5、通信协议

协议：约定，就好比我们现在说得是普通话
网络通信协议： 速率，传输码率，代码结构，传输控制…
**问题：**非常得复杂？
大事化小：分层！
.
TCP/IP协议簇：实际上是一组协议 （传输层）
重要：

• TCP：用户传输协议
• UDP：用户数据报协议

.
出名的协议：

• TCP：用户传输协议
• IP：网络互连协议
  

TCP udp 对比
TCP：打电话

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

至少需要三次，保证稳定连接！
A: 你瞅啥？
B：瞅你咋地？
A：干一场！
.
A：我要走了！
B：我知道你要走了
B：你真的走了吗？
A：我真的要走了！

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

UDP：发短信

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

1.6、TCP

客户端：

1. 连接服务器Socket
2. 发送消息

//客户端
public class TcpClientDemo01 {
    public static void main(String[] args) {
        try {
            //1.我要知道服务器的地址,端口号
            InetAddress serverIP = InetAddress.getByName("127.0.0.1");
            int port = 9999;
            //2.创建一个socket连接
            Socket socket = new Socket(serverIP, port);
            //3.发送消息，IO流（输出流）
            OutputStream os = socket.getOutputStream();
            os.write("你好，欢迎学习java".getBytes());
            os.close();
            socket.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

.
服务器：

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

//服务端
public class TcpServerDemo01 {
    public static void main(String[] args) {
        try {
            //1.我要有一个地址
            ServerSocket serverSocket = new ServerSocket(9999);
            //2.等待客户端连接
            Socket socket = serverSocket.accept();
            //3.读取客户端消息
            InputStream is = socket.getInputStream();
            //管道流，用来输出客户端传来的东西
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            byte[] buffer = new byte[1024];
            int len;
            if ((len = is.read(buffer)) != -1) {
                baos.write(buffer, 0, len);
            }
            System.out.println(baos.toString());
            baos.close();
            is.close();
            socket.close();
            serverSocket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

.

文件上传

先启动服务端，再启动客户端

服务端：

public class TcpServerDemo02 {
    public static void main(String[] args) throws IOException {
        //1.创建服务
        ServerSocket serverSocket = new ServerSocket(9000);
        //2.监听客户端连接
        Socket socket = serverSocket.accept();//阻塞式监听，会一直等待客户端的连接
        //3.获取输入流
        InputStream is=socket.getInputStream();
        //4.文件输出
        FileOutputStream fos=new FileOutputStream(new File("receive.png"));
        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();
    }
}

.
客户端：

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("微信截图_20210811222010.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();
        //接收到String类型的字节数组
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        byte[] in=new byte[1024];
        int len2;
        while ((len2=inputStream.read(buffer))!=-1){
            baos.write(buffer,0,len2);
        }
        System.out.println(baos.toString());
        //5.关闭资源
        baos.close();
        inputStream.close();
        fis.close();
        os.close();
        socket.close();
    }
}

.

TomCat

服务端：

• 自定义
• Tomcat服务器：JAVA后台开发

客户端：

• 自定义C
• 浏览器B
  .

1.7、UDP

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

//不需要连接服务器
public class UdpSendDemo01 {
    public static void main(String[] args) throws Exception {
        //1.建立一个数据socket
        DatagramSocket socket=new DatagramSocket();
        //2.要发给谁
        InetAddress localhost=InetAddress.getByName("localhost");
        int port=9090;
        //3.建一个包
        String str="你好啊，服务器~";
        //数据，数据的开始，结束，要发给谁
        DatagramPacket packet=new DatagramPacket(str.getBytes(),0,str.getBytes().length,localhost,port);
        
        //4.发送
        socket.send(packet);
        
        //5.关闭流
        socket.close();
    }
}

.
接收端

//还是要等待客户端的连接
public class UdpReceiverDemo01 {
    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.getData().length));你好啊，服务器~   
        //关闭
        socket.close();
    }
}

.
UDP聊天实现
循环发送消息：

public class UdpSenderDemo01 {
    public static void main(String[] args) throws Exception {
        DatagramSocket socket = new DatagramSocket(8080);

        //准备数据：控制台读取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);//阻塞式接受包裹

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

            System.out.println(receiveData);

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

        socket.close();
    }
}

.
UDP多线程 在线咨询： 两个人都可以是发送方或者接收方！

• 先创建两个工具类，一个用来发送消息，一个用来接收消息，并且都是单独的线程(实现线程接口)
• 创建两个聊天的人，这两个人都有发送和接收功能
• 发送线程

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) {
            try {
                String data = reader.readLine();
                byte[] bts = data.getBytes();
                DatagramPacket packet = new DatagramPacket(bts, 0, bts.length, new InetSocketAddress(this.toIP, this.toPort));
                socket.send(packet);
                if (data.equals("bye")) {
                    break;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        socket.close();
    }
}

.

• 接收线程

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[] bts = new byte[1024];
                DatagramPacket packet = new DatagramPacket(bts, 0, bts.length);
                socket.receive(packet);
                //断开连接
                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();
    }
}

.

• 学生端

public class TalkStudent {
    public static void main(String[] args) {//两个线程：既负责发送也负责接受
        //开启两个线程
        //发送
        new Thread(new TalkSend(7777,"localhost",9999)).start();
        //接收
        new Thread(new TalkReceive(8888,"老师")).start();
    }
}

.

• 老师端

public class TalkTeacher {
    public static void main(String[] args) {//两个线程：既负责发送也负责接受
        //开启两个线程
        new Thread(new TalkSend(5555,"local",8888)).start();
        new Thread(new TalkReceive(9999,"学生")).start();
    }
}

.

1.8、URL

https://www.baidu.com/
统一资源定位符：定位资源的，定位互联网上的某一个资源
DNS域名解析器 可以解析域名为URL

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

public class URLDown {
    public static void main(String[] args) throws IOException {
        //1.下载地址
        URL url = new URL("https://m701.music.126.net/20210815203025/8961e5e0796919db5e20ba1b4d841e5f/jdyyaac/obj/w5rDlsOJwrLDjj7CmsOj/10313272238/bf67/a160/c117/401e7788b41adcc68319f084e25089f2.m4a");
        
        //2.连接这个地址的资源 HTTP
        HttpURLConnection connection= (HttpURLConnection) url.openConnection();
        
        //3.把资源写入程序
        InputStream inputStream = urlConnection.getInputStream();
        
        //新建想要输出的路径
        FileOutputStream fos= new FileOutputStream("401e7788b42.m4a");
        
        byte[] buffer=new byte[1024];
        int len;
        //4.把资源用字节流读入bts数组中
        while ((len=inputStream.read(buffer))!=-1){
            //把读到的写入输出流
            fileOutputStream.write(buffer,0,len);//写出这个数据
        }
        
        //关闭流
        fileOutputStream.close();
        inputStream.close();
        connection.disconnect();//断开连接
    }
}