【笔记：Java网络编程】_java

文章目录

一、网络编程
- 1.1概述
- 1.2 网络通信的要素
- 1.3 IP
- 1.4 端口
- 1.5 通信协议
- 1.6 TCP
- - 文件上传
  - Tomcat
- 1.7 UDP
- - 发送消息
  - 咨询
- 1.8 URL
- - URL下载网络资源

一、网络编程 1.1概述

计算机网络

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

1.2 网络通信的要素

通讯双方地址：

ip
端口号

规则：网路通信协议

TCP/IP

1.3 IP

IP地址：InetAddress

唯一定位一台网络上计算机
127.0.0.1 ：本机 localhost
ip地址分类
- IPV4/IPV6
  - IPV4：127.0.0.1，四字节组成，0~255，共42亿；30亿在北美，亚洲4亿，2011年用尽
  - IPV6：fe80::7000:f2bb:1767:eccc%8 , 128位，8个无符号整数
    
    一、冒分十六进制表示法
    
    格式为X:X:X:X:X:X:X:X，其中每个X表示地址中的16b，以十六进制表示，例如：
    
    ABCD:EF01:2345:6789:ABCD:EF01:2345:6789
    
    这种表示法中，每个X的前导0是可以省略的，例如：
    
    2001:0DB8:0000:0023:0008:0800:200C:417A→ 2001:DB8:0:23:8:800:200C:417A
    
    二、0位压缩表示法
    
    在某些情况下，一个IPv6地址中间可能包含很长的一段0，可以把连续的一段0压缩为“::”。但为保证地址解析的唯一性，地址中”::”只能出现一次，例如：
    
    FF01:0:0:0:0:0:0:1101 → FF01::1101
    
    0:0:0:0:0:0:0:1 → ::1
    
    0:0:0:0:0:0:0:0 → ::
    
    三、内嵌IPv4地址表示法
    
    为了实现IPv4-IPv6互通，IPv4地址会嵌入IPv6地址中，此时地址常表示为：X:X:X:X:X:X:d.d.d.d，前96b采用冒分十六进制表示，而最后32b地址则使用IPv4的点分十进制表示，例如::192.168.0.1与::FFFF:192.168.0.1就是两个典型的例子，注意在前96b中，压缩0位的方法依旧适用 [9]
- 公网(互联网)/私网(局域网）
  - 192.168.xx.xx：专门给组织内部使用
  - ABCD类地址
域名：记忆IP问题
- IP：www.bilibili.com

//测试IP
public class TestInetAdress {
    public static void main(String[] args) {
        try {
            //查询本机地址
            InetAddress byName = InetAddress.getByName("127.0.0.1");
            System.out.println(byName);//127.0.0.1
            InetAddress byName2 = InetAddress.getByName("localhost");
            System.out.println(byName2);//localhost/127.0.0.1
            InetAddress byName3 = InetAddress.getLocalHost();
            System.out.println(byName3);//DESKTOP-7OMFADN/192.168.1.107
            //查询网站ip地址
            InetAddress byName1 = InetAddress.getByName("www.baidu.com");
            System.out.println(byName1);//www.baidu.com/14.215.177.38

            //常用方法
            System.out.println(byName1.getCanonicalHostName());
            //14.215.177.39(规范的名字）
            System.out.println(byName1.getHostAddress());
            //14.215.177.39（ip）
            System.out.println(byName1.getHostName());
            //www.baidu.com（域名，或自己电脑的名字）

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

1.4 端口

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

不同的进程有不同的端口号，用来区分软件
被规定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 "8096"	#查看指定端口的进程
```

1.5 通信协议

**网络通信协议：**速率、传输码率、代码结构、传输控制…

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

TCP：用户传输协议
UDP：用户数据报协议
IP：网络互连协议

TCP、UDP对比：

TCP：

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

三次挥手（最少需要三次，保证稳定连接）

A：你愁啥（发送）

B：瞅你咋地（回复）

A：干一架！（连接）

四次挥手

A：我要断开了

B：好的，稍等一下

B：你断吧

A：好的，我断了
客户端、服务端
传输完成，释放连接，效率低

UDP：

不连接、不稳定
客户端、服务端：没有明确的界限
无论是否准备好，都可以发送
DDOS：洪水攻击（饱和攻击）

1.6 TCP

客户端：C

连接服务器Socket
发送消息

package TCPtest;

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

//客户端
public class TcpClientDemo1 {
    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.发送消息
            os = socket.getOutputStream();
            os.write("你好".getBytes());
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (os != null){
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

服务端：S

建立服务端口 SeverSocket
等待用户的连接 accept
接受消息

public class TcpServerDemo1 {
    public static void main(String[] args){
        ServerSocket serverSocket = null;
        Socket socket = null;
        InputStream is = null;
        ByteArrayOutputStream baos = null;

        try {
            //1.需要一个地址
            serverSocket = new ServerSocket(9999);
            //2.等待客户端连接进来
            while (true) {
                socket = serverSocket.accept();
                //3.读取客户端的消息
                is = socket.getInputStream();
                //管道流
                baos = new ByteArrayOutputStream();
                byte[] buffer =new byte[1024];
                int len;
                while((len = is.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 (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();
                }
            }
        }
    }
}

文件上传

服务器端

package TCPtest;

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

//服务端
public class TcpServerDemo1 {
    public static void main(String[] args){
        ServerSocket serverSocket = null;
        Socket socket = null;
        InputStream is = null;
        ByteArrayOutputStream baos = null;

        try {
            //1.需要一个地址
            serverSocket = new ServerSocket(9999);
            //2.等待客户端连接进来
            while (true) {
                socket = serverSocket.accept();
                //3.读取客户端的消息
                is = socket.getInputStream();
                //管道流
                baos = new ByteArrayOutputStream();
                byte[] buffer =new byte[1024];
                int len;
                while((len = is.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 (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();
                }
            }
        }
    }
}

客户端

package demo2;

import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Locale;

public class TcpClientDemo2 {
    public static void main(String[] args) throws  Exception {
        //创建一个socket连接
        int port = 9000;
        Socket socket = new Socket(InetAddress.getByName("127.0.0.1"),9000);
        //创建一个输出流
        OutputStream os = socket.getOutputStream();
        //文件流
        FileInputStream fis = new FileInputStream(new File("猫猫.jpg"));
        //写出文件
        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[] buffer2 = new byte[1024];
        int len2;
        while ((len2 = inputStream.read(buffer2))!= -1){
            baos.write(buffer2,0,len2);
        }
        System.out.println(baos.toString());

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

Tomcat

服务端

Tomcat服务器 S

客户端

浏览器 B

1.7 UDP

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

发送消息

发送端

package demo3;

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

//不需要连接服务器
public class UdpClientDemo1 {

    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;
        //数据、数据的起始长度、发送给谁
        DatagramPacket packet = new DatagramPacket(msg.getBytes(), 0, msg.getBytes().length, localhost, port);

        //3.发送包
        socket.send(packet);

        //4.关闭流
        socket.close();
    }
}

接收端

package demo3;

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

//还是要等待客户端的连接
public class UdpServerDemo1 {
    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());
        //127.0.0.1

        System.out.println(new String(packet.getData(), 0, packet.getLength()));
        //你好，服务器。

        socket.close();
    }
}

咨询

循环发送消息

发送方

package 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", 6666));
            socket.send(packet);
            if (data.equals("bye")) break;
        }
        socket.close();
    }
}

接收方

package chat;

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

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 datas = new String(data, 0, data.length);
            System.out.println(datas);
            if (datas.equals("bye")) break;
        }
        socket.close();
    }
}

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

发送线程

package 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;

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 (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {

        while (true) {
            try {
                String 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 (Exception e) {
                e.printStackTrace();
            }
        }
        socket.close();
    }
}

接收线程

package 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 datas = new String(data, 0, data.length);
                System.out.println(msgFrom + "发送：" + datas);
                if (datas.equals("bye")) break;
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        socket.close();
    }
}

用户1

package chat;

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

用户2

package 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域名解析：https://www.baidu.com/ -> xxx.x…x…x

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

url常用方法

package demo4;

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

public class URLDemo01 {
    public static void main(String[] args) throws MalformedURLException {
        URL url = new URL("https://localhost:8080/helloworld/index.jsp?username=name&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());//参数
        /*
        https
        localhost
        8080
        /helloworld/index.jsp
        /helloworld/index.jsp?username=name&password=123
        username=name&password=123
         */
    }
}

URL下载网络资源

package demo4;

import java.io.FileOutputStream;
import java.io.IOException;
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 IOException {
        //1.下载地址
        URL url = new URL("http://www.kaotop.com/file/tupian/20220429/34b48fd47a9141c3ac2964d1ef2166aa_editplusplusplus.jpg!1");

        //2.连接到这个资源
        HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();

        InputStream inputStream = urlConnection.getInputStream();

        FileOutputStream fos = new FileOutputStream("34b48fd47a9141c3ac2964d1ef2166aa_editplusplusplus.jpg");

        byte[] buffer = new byte[1024];
        int len;
        while((len=inputStream.read(buffer))!=-1){
            fos.write(buffer,0,len);
        }
        fos.close();
        inputStream.close();
        urlConnection.disconnect();
    }
}

欢迎分享，转载请注明来源：内存溢出

原文地址: http://outofmemory.cn/langs/788273.html

【笔记：Java网络编程】

发表评论

评论列表（0条）