JAVA网络编程

网络编程 基本知识 计算机网络：

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

网络通信的要素： 通信双方地址 ip 端口号 协议 TCP/IP 参考模型

IP

ip地址：InetAddress

作用：唯一定位一台计算机 本机localhost：127.0.0.1

ip地址分类：

1. IPV4/IPV6

IPV4由四个字节组成，0~255，有42亿个；30亿都在北美，亚洲都有4亿

IPV6， fe80::70a1:70d1:591d:6309%7；128位，8个无符号整数

1. 公网/私网 公网是互联网 私网是局域网 192.168.xx.xx

域名

域名： www.baidu

查询ip地址： InetAddress i = InetAddress.getByName("127.0.0.1");

获得本机地址： InetAddress i2 = InetAddress.getLocalHost();

常用方法：

i.getHostAddress(); 获得ip

i.getHostName(); 获得域名

端口

定义：端口表示计算机上一个程序的进程 特性：

1. 不同的进程有不同的端口号 用来区分软件

2. 按规定有0~65535*2个端口 TCP/UDP ，单个协议下端口号不能冲突

分类： 公有端口0~1023 HTTP:80 HTTPS:443 FTP:21 TELENT:23

程序注册端口 1024~49151 分配用户或者程序

Tomcat：8080

MySQL：3306

Oracle：1521 动态、私有：49152~65535

常用cmd命令

netstat -ano 查看所有的端口

netstat -ano|findstr"5900" 查看指定端口

tasklist|findstr"8696" 查看指定端口的进程

ctrl+shift+ESC 打开任务管理器

解析地址

InetSocketAddress s = new InetSocketAddress("127.0.0.1",8080);

s.getAddress();

s.getHostName(); 地址

s.getPort(); 端口

通信协议

网络通信协议：速率、传输码率、代码结构、传输控制。。。 TCP/IP协议簇：

1. TCP：用户传输协议

2. UDP：用户数据报协议

3. IP：网络互连协议

TCP与UDP对比

TCP是打电话 UDP是发短信

TCP：连接、稳定、三次握手、四次挥手；客户端与服务端界限明确；传输完成、释放连接、效率低

UDP：不连接、不稳定；客户端与服务端没有明确的界限；不管有没有准备好都可以发给你

三次握手： A: 你瞅啥 B: 瞅你咋地 A：干一场 最少需要三次、保证稳定连接

四次挥手： A: 我要走了 B: 你真的要走了吗 B: 你真的要走了吗 A: 我真的要走了

TCP

客户端：

1. 连接服务器 创建一个socket连接

2. 发送消息 用连接获得一个输出流，在流上写内容

import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
import java.nio.charset.StandardCharsets;
​
public class TestClient {
​
    public static void main(String[] args) {
        Socket socket =null;
        OutputStream os =null;
        //指导服务器的端口号 地址
        try {
            InetAddress serverip = InetAddress.getByName("127.0.0.1");
            int port = 9999;
            //创建一个socket连接
            socket = new Socket(serverip,port);
            //发送消息
            os = socket.getOutputStream();
            os.write("hello".getBytes());
​
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException 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. 接受用户的消息

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
​
public class TestServer {
    public static void main(String[] args) {
        Socket socket = null;
        InputStream is = null;
        ByteArrayOutputStream baos = null;
        //获得连接端口
        try {
            ServerSocket serverSocket = new ServerSocket(9999);
            //连接
            while (true){
                //客户端连接
                socket = serverSocket.accept();
                //读取消息
                is = socket.getInputStream();
                //建立管道流
                baos = new ByteArrayOutputStream();
                //写入内容
                byte[] b = new byte[1024];
                int len = 0;
                while ((len=is.read(b))!=-1){
                    baos.write(b,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();
                }
            }
        }
    }
}

模拟文件上传：

服务器端：

import jdk.internal.util.xml.impl.Input;
​
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.charset.StandardCharsets;
​
public class TestFileServer {
    public static void main(String[] args) throws Exception {
        //set connection
        ServerSocket serverSocket = new ServerSocket(9000);
        //accecpt client
        Socket socket = serverSocket.accept();
        //get inputstream
        InputStream is = socket.getInputStream();
        //output file
        FileOutputStream fos = new FileOutputStream(new File("receive.jpg"));
        byte[] buffer = new byte[1024];
        int len = 0;
        while ((len=is.read(buffer))!=-1){
            fos.write(buffer,0,len);
        }
​
        //通知客户端 我已经接收完毕
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("我已经接收完毕!".getBytes());
​
        //关闭资源
        outputStream.close();
        fos.close();
        is.close();
        socket.close();
        serverSocket.close();
    }
}

客户端

import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
​
public class TestFileClient {
    public static void main(String[] args) throws Exception{
        //获取地址 端口 创建socket连接
        Socket socket = new Socket(InetAddress.getByName("127.0.0.1"),9000);
        //创建输出流
        OutputStream os = socket.getOutputStream();
        //read file
        FileInputStream fis = new FileInputStream(new File("liujing.jpg"));
​
        //write file to os
        byte[] buffer = new byte[1024];
        int len = 0;
        while ((len=fis.read(buffer))!=-1){
            os.write(buffer,0,len);
        }
        //通知服务器 已经发送结束
        socket.shutdownOutput();
​
        //确定服务器接收完毕 断开连接
        InputStream inputStream = socket.getInputStream();
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        byte[] buffer1 = new byte[1024];
        int len1 = 0;
        while ((len1=inputStream.read(buffer1))!=-1){
            byteArrayOutputStream.write(buffer1);
        }
        System.out.println(byteArrayOutputStream.toString());
​
​
        //close resource
        byteArrayOutputStream.close();
        inputStream.close();
        fis.close();
        os.close();
        socket.close();
    }
}

Tomcat

服务端：自定义服务器/Tomcat服务器

客户端：自定义客户端/浏览器客户端

UDP

不需要连接 但需要知道对方的地址

建立连接：DatagramSocket socket = new DatagramSocket();

创建包：DatagramPacket packet = new DatagramPacket(数据，数据长度起始，发送端地址，发送端端口)

服务端

import java.net.DatagramPacket;
import java.net.DatagramSocket;
​
public class UDPServer {
    public static void main(String[] args) throws Exception{
        //开放端口
        DatagramSocket socket = new DatagramSocket(8088);
        //接受包
        byte[] b = new byte[1024];
        DatagramPacket packet = new DatagramPacket(b,0,b.length);
        socket.receive(packet); //阻塞接受
​
        System.out.println(packet.getAddress().getHostAddress());
        System.out.println(new String(packet.getData(),0,packet.getLength()));
​
        //关闭连接
        socket.close();
    }
}

客户端

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.nio.charset.StandardCharsets;
​
public class UDPClient {
    public static void main(String[] args) throws Exception {
        //建立连接
        DatagramSocket datagramSocket = new DatagramSocket();
        //数据
        String msg = "hello";
        InetAddress address = InetAddress.getByName("localhost");
        int port = 8088;
        //创建包
        DatagramPacket datagramPacket = new DatagramPacket(msg.getBytes(),0,msg.getBytes().length,address,port);
        //发送包
        datagramSocket.send(datagramPacket);
        //关闭流
        datagramSocket.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;
import java.net.SocketException;
import java.nio.Buffer;
import java.nio.charset.StandardCharsets;
​
public class UDPSend implements Runnable {
    DatagramSocket socket = null;
    BufferedReader reader = null;
​
    private int fromport;
    private final String toIP;
    private final int toPort;
​
    public UDPSend(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() throws  IllegalArgumentException{
        while (true){
​
            try {
                String data = reader.readLine();
                byte[] d = data.getBytes();
​
                //装在包裹
                DatagramPacket packet = new DatagramPacket(d,0,d.length,new InetSocketAddress(this.toIP,this.toPort));
                //发送包裹
                socket.send(packet);
                //如果发送内容为bye则断开连接
                if (data.equals("bye")){
                    break;
                }
            } catch (IOException 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 UDPReceive implements Runnable {
    DatagramSocket socket = null;
    private int port;
    private final String msgFrom;
​
    public UDPReceive(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);
​
                //断开连接
                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();
        }
}

老师

package chat;

public class Teacher {
    public static void main(String[] args) throws  Exception{
        new Thread(new UDPSend(3556,"学生",6755)).start();
        new Thread(new UDPReceive(5467,"学生")).start();
    }
}

学生

package chat;

public class Student {
    public static void main(String[] args) throws  Exception{
        new Thread(new UDPSend(45756,"老师",5467)).start();
        new Thread(new UDPReceive(6755,"老师")).start();
    }
}

URL

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

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

创建： URL url = new URL("https://localhost:8080/helloword/index.jsp");

方法：

url.getProtocol(); 协议

url.getHost(); 主机

ip url.getPort(); 端口

url.getPath(); 文件

url.getFile(); 全路径

url.getQuery(); 参数