网络编程

InetAddress      获取地址
InetAddress.getCanonicalHostName        规范的名字
InetAddress.getHostAddress      IP
InetAddress.getHostName     域名或自己电脑的名字
InetSocketAddress       实现 IP 地址及端口
InetAddress             实现 IP 地址
ServerSocket                建立服务的端口
.accept                     阻塞监听等待连接
Socket                      创建连接
.getInputStream             获取IO输入流
.getOutputStream            获取IO输出流
ByteArrayOutputStream       byte类型数组管道输出流
FileOutputStream        文件字符输出流
FileInputStream         文件字符输入流
shutdownOutput          停止输出
DatagramSocket          数据包端口
DatagramPacket          数据包
.send           发送
.receive        阻塞接收
BufferedReader          缓存区读取
InputStreamReader       输入流读取
.readLine               读取的一行内容
URL         统一资源定位符
.openConnection             打开连接
HttpURLConnection           指定协议HTTP
?

1.1、概述 计算机网络

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

网络编程的目的：

无限电台…传播交流信息，数据交换，通信

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

如何准确的定位网络上的一台主机 192.168.1.11；端口，定位到一个计算机上的某个资源 找到了这个主机，如何传输数据？ 1.2、网络通信的要素 如何实现网络的通信？

通信双方地址：

ip 端口号 192.168.16，124：5900 规则：网络通信的协议

http, ftp, smtp, tcp,udp…

TCP/IP参考模型：

小结：

• 网络编程中有两个主要的问题

  • 如何准确的定位到网络上的一台或者多台主机

  • 找到主机之后如何进行通信

• 网络编程中的要素

  • IP 和 端口号 IP

  • 网络通信协议 udp,tcp

• 万物皆对象

  • IP和网络通信协议都可以生成对象

1.3、IP ip地址：InetAddress

• 唯一定位一台网络上计算机

• 127.0.0.1：本机Iocalhost

  • ip地址的分类

  • ipv4/ipv6

    • IPV4：127.0.01 ,4个字节组成，0~255，总共42亿；30亿都在北美，亚洲4亿，2011年就已经用尽

    • IPV6：128位。8个无符号整数。2001:acca:0ac1:0002:0ab7:1153:2210:ccc1

• 公网（互联网）-私网（局域网）

  • ABCD类地址

  • 192.168.xxx.xx 专门给组织内部使用

• 域名：记忆IP问题

  • IP：www.xxx.com 方便记录

import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.Arrays;
?
//测试IP
//由于没有构造器，不能new出来。只能利用静态方法
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(Arrays.toString(inetAddress2.getAddress()));      //返回一个数组
ystem.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，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 "8696" #查看指定端口的进程
?

//端口
public class TestInetSocketAddress {
    public static void main(String[] args) {
        InetSocketAddress socketAddress = new InetSocketAddress("127.0.0.1",8080);
        InetSocketAddress socketAddress2 = new InetSocketAddress("localhost",8080);
?
        System.out.println(socketAddress);
        System.out.println(socketAddress2);
?
        System.out.println(socketAddress.getAddress());
        System.out.println(socketAddress.getHostName());    //地址
        System.out.println(socketAddress.getPort());        //端口
?
    }

InetSocketAddress        IP 地址及端口
InetAddress              IP 地址

1.5、通信协议 协议：约定，双方使用相同可识别的语言

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

主要使用：TCP/IP协议簇：实际上是一组协议

主要：

• TCP：用户传输协议 {类似于打电话，需要两边进行连接} UDP：用户数据报协议 {类似于发短信，不需要两边连接也可以发出，但不一定能送到}

出名的协议：

• TCP：

• IP：网络互连协议

TCP UDP 对比

TCP：打电话

• 连接、稳定

• 三次握手 四次挥手

最少需要三次，保证稳定连接
A—— 我要连接 ——>B
B—— 你可以连接 ——>A
A—— 那我连接了 ——>B
连接成功！
?
四次挥手
A——我要断开——>B
B——你可以断开——>A
?
B——你确定断开？——>A
A——我确定断开！——>B
连接断开

• 客户端、服务端：主动和被动的过程

• 传输完成，释放连接，效率低

UDP：发短信

• 不连接、不稳定

• 客户端、服务端：没有明确的界限

• 不管有没有准备好，都可以发给你

• DDOS：洪水攻击！（饱和攻击

1.6、TCP

服务器

1. 建立服务的端口 ServerSocket

2. 等待用户的连接 accept

3. 接收用户的信息

服务端

package com.dong.lesson;
?
import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
?
public class TcpClientDemo1 {
    private static InetAddress byName = null;
    private static Socket socket = null;
    private static OutputStream outputStream = null;
    public static void main(String[] args) {
        try {
            //要知道服务器的地址
           byName = InetAddress.getByName("127.0.0.1");
           int port = 9999;
           //创建一个socket连接
            try {
                socket = new Socket(byName,port);
                outputStream = socket.getOutputStream();
                outputStream.write("欢迎学习Java".getBytes());
            } catch (IOException e) {
                e.printStackTrace();
            }
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }finally {
            if (outputStream!=null){
                try {
                    outputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (socket!=null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
?

客户端

1. 连接服务器 Socket

2. 发送消息

package com.dong.lesson;
?
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
?
public class TcpServerDemo1 {
    private static ServerSocket serverSocket = null;
    private static Socket accept =  null;
    private static InputStream inputStream = null;
    private static ByteArrayOutputStream bis = null;
?
    public static void main(String[] args) {
        try {
            //创建一个地址
            serverSocket = new ServerSocket(9999);
?
            while (true) {
                //接收
                accept = serverSocket.accept();
                //读取客户端消息
                inputStream = accept.getInputStream();
                TcpServerDemo1.inputStream = inputStream;
                bis = new ByteArrayOutputStream();
                byte[] bytes = new byte[1024];
                int len;
                while ((len = TcpServerDemo1.inputStream.read(bytes)) != -1) {
                    bis.write(bytes, 0, len);
                }
                System.out.println(bis.toString());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                bis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                accept.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                inputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
?
        }
?
    }
?
}

文件上传

客户端

接收完毕package com.dong.lesson;
?
import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
?
public class TcpClientDemo2 {
    public static void main(String[] args) throws Exception{
        //创建一个Socket 连接
        Socket socket = new Socket(InetAddress.getByName("127.0.0.1"),9000);
        //创建一个输出流
        OutputStream os = socket.getOutputStream();
        //读取文件
        FileInputStream fis = new FileInputStream(new File("PM02_20210111153107.jpg"));
        //写出文件
        byte[] bytes = new byte[1024];
        int len = 0;
        while ((len = fis.read(bytes))!=-1){
            os.write(bytes,0,len);
        }
        //通知服务器，我已经结束了
        socket.shutdownOutput();
        InputStream is = socket.getInputStream();
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        byte[] bytes1 = new byte[1024];
        int len1 = 0;
        while ((len1= is.read(bytes1))!=-1){
            baos.write(bytes1,0,len1);
        }
        System.out.println(baos.toString());
        //关闭资源
        is.close();
        baos.close();
        fis.close();
        os.close();
        socket.close();
    }
}

服务器

package com.dong.lesson;
?
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
?
public class TcpServerDemo2 {
    public static void main(String[] args) throws Exception{
        //创建一个地址
        ServerSocket serverSocket = new ServerSocket(9000);
        //接受
        Socket accept = serverSocket.accept();
        //读取客户端的消息
        InputStream is = accept.getInputStream();
        FileOutputStream fos = new FileOutputStream(new File("receive.jpg"));
        byte[] bytes = new byte[1024];
        int len = 0;
        while ((len = is.read(bytes))!=-1){
         fos.write(bytes,0,len);
        }
        //通知服务器接收完毕
        OutputStream os = accept.getOutputStream();
        os.write("接收完毕".getBytes());
?
        //关闭资源
        os.close();
        fos.close();
        is.close();
        accept.close();
        serverSocket.close();
    }
}
?

UDP消息发送

发送

package com.dong.lesson2;
?
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.Socket;
?
public class UdpClientDemo1 {
    public static void main(String[] args) throws Exception{
        //建立一个socket
        DatagramSocket socket = new DatagramSocket();
        //建立一个包
        String msg = "你好！服务器！";
        InetAddress inetAddress = InetAddress.getByName("localhost");
        int port = 9090;
        DatagramPacket packet = new DatagramPacket(msg.getBytes(),0,msg.getBytes().length,inetAddress,port);
        //发送
        socket.send(packet);
        socket.close();
    }
}
?

接受

package com.dong.lesson2;
?
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[] bytes = new byte[1024];
        DatagramPacket packet = new DatagramPacket(bytes,0,bytes.length);
        socket.receive(packet);
        System.out.println(packet.getAddress().getHostAddress());
        System.out.println(new String(packet.getData(),0,packet.getLength()));
        socket.close();
    }
}
?

实时聊天(多线程)

package com.dong.chat;
?
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
?
public class TalkReceice implements Runnable{
    DatagramSocket socket = null;
?
    private int port;
    private String msg;
    public TalkReceice(int port,String msg) {
        this.port = port;
        this.msg = msg;
        try {
            socket = new DatagramSocket(port);
        } catch (SocketException e) {
            e.printStackTrace();
        }
?
    }
?
    @Override
    public void run() {
?
        while (true) {
?
            try {
                byte[] bytes = new byte[1024];
                DatagramPacket packet = new DatagramPacket(bytes,0,bytes.length);
                socket.receive(packet);
                byte[] data = packet.getData();
                String data2 = new String(data,0, data.length);
                System.out.println(msg + ": " + data2);
                if(data2.trim().equals("bye")){
                    break;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
?
        }
?
        socket.close();
    }
}
?

package com.dong.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 TaliSend implements Runnable {
    DatagramSocket socket = null;
    BufferedReader reader = null;
?
    private  int fromport;
    private int toport;
    private String toIp;
?
    public TaliSend(int fromport, int toport, String toIp) {
        this.fromport = fromport;
        this.toport = toport;
        this.toIp = toIp;
        try {
            socket = new DatagramSocket(fromport);
            reader = new BufferedReader(new InputStreamReader(System.in));
        } catch (SocketException e) {
            e.printStackTrace();
        }
    }
?
    @Override
    public void run() {
        while (true) {
            String s = null;
            try {
                s = reader.readLine();
                byte[] bytes = s.getBytes();
                DatagramPacket packet = new DatagramPacket(bytes, 0, bytes.length, new InetSocketAddress(this.toIp, this.toport));
                socket.send(packet);
                if (s.equals("bye")){
                    break;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
?
        }
        socket.close();
    }
}
?

package com.dong.chat;
?
public class TalkMy {
    public static void main(String[] args) {
        new Thread(new TaliSend(9872,9999,"localhost")).start();
        new Thread(new TalkReceice(8888,"you")).start();
    }
}
?

package com.dong.chat;
?
public class TalkYou {
    public static void main(String[] args) {
        new Thread(new TaliSend(9874,8888,"localhost")).start();
        new Thread(new TalkReceice(9999,"my")).start();
    }
}
?

文件下载

package com.dong.lesson4;
?
import java.io.FileOutputStream;
import java.io.InputStream;
import java.net.URL;
import java.net.URLConnection;
import java.net.HttpURLConnection;
?
public class UIL {
    public static void main(String[] args) throws Exception{
        URL url = new URL("https://m701.music.126.net/20210404171137/bce648e379a682f120a69b5f0786e9cc/jdyyaac/obj/w5rDlsOJwrLDjj7CmsOj/7937683494/31e2/2771/3eef/e1a6f0f79db893a61118d620b204384f.m4a");
        HttpURLConnection urlConnection = (HttpURLConnection)url.openConnection();
        InputStream inputStream = urlConnection.getInputStream();
        FileOutputStream fileOutputStream = new FileOutputStream("f.m4a");
        byte[] bytes = new byte[1024];
        int len = 0;
        while ((len = inputStream.read(bytes))!=-1){
            fileOutputStream.write(bytes,0,len);
        }
    }
}
?

网络编程

原文：https://www.cnblogs.com/sikaha/p/14616459.html