Java网络编程基础

最新推荐文章于 2023-05-08 00:00:00 发布

秋鸣之时

最新推荐文章于 2023-05-08 00:00:00 发布

阅读量185

点赞数

文章标签： java

本文链接：https://blog.csdn.net/weixin_45771158/article/details/124111121

版权

文章目录

Java网络编程基础
参考：https://blog.csdn.net/allenfoxxxxx/article/details/90707505
1.什么是网络编程
网络编程是指编写运行在多个设备（计算机）的程序，这些设备都通过网络连接起来。
2.具体在java中来说
在Java中实现网络编程主要使用的是java.net包。
java.net 包中 J2SE 的 API 包含有类和接口，它们提供低层次的通信细节。你可以直接使用这些类和接口，来专注于解决问题，而不用关注通信细节。

3.网络编程在计算机网络中编程使用到的主要是传输层协议：TCP和UDP；网络层的ip协议；
java.net 包中提供了两种常见的网络协议的支持：

TCP：TCP（英语：Transmission Control Protocol，传输控制协议）是一种面向连接的、可靠的、基于字节流的传输层通信协议，TCP 层是位于 IP 层之上，应用层之下的中间层。TCP 保障了两个应用程序之间的可靠通信。通常用于互联网协议，被称 TCP / IP。

UDP：UDP （英语：User Datagram Protocol，用户数据报协议），位于 OSI 模型的传输层。一个无连接的协议。提供了应用程序之间要发送数据的数据报。由于UDP缺乏可靠性且属于无连接协议，所以应用程序通常必须容许一些丢失、错误或重复的数据包。

IP：网络互连协议，它为每个计算机提供了独一无二的ip地址来唯一标识这台计算机。
在这里插入图片描述
ip分类为ip4和ip6：

在这里插入图片描述

IPv4又可以分为五类：
在这里插入图片描述

A类：在IP地址的四段号码中，第一段号码为网络号码，剩下的三段号码为本地计算机的号码；A类IP地址中网络的标识长度为8位，主机标识的长度为24位，A类网络地址数量较少，有126个网络，每个网络可以容纳主机数达1600多万（256的三次方-2）台。

B类：在IP地址的四段号码中，前两段号码为网络号码。B类IP地址中网络的标识长度为16位，主机标识的长度为16位，B类网络地址适用于中等规模的网络，有16384个网络，每个网络所能容纳的计算机数为6万多（256的二次方-2）台

C类：在IP地址的四段号码中，前三段号码为网络号码，剩下的一段号码为本地计算机的号码；此类地址中网络的标识长度为24位，主机标识的长度为8位，C类网络地址数量较多，有209万余个网络。适用于小规模的局域网络，每个网络最多只能包含254（256-2）台计算机

D类：此类IP地址在历史上被叫做多播地址(multicast address)，即组播地址；在以太网中，多播地址命名了一组应该在这个网络中应用接收到一个分组的站点；多播地址的最高位必须是“1110”，范围从224.0.0.0到239.255.255.255

E类：此类地址也不分网络地址和主机地址，它的第1个字节的前五位固定为“11110”，为将来使用保留，地址范围从240.0.0.1到255.255.255.254

java中获取ip地址的封装类为inetAdress，它是一个封装类可以直接调用使用：
在这里插入图片描述
常见方法摘要：

案例：

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

public class TestIP {
    public static void main(String[] args) throws UnknownHostException {
        //InetAdress类表示IP地址

        //获取本机IP
        InetAddress ip = InetAddress.getLocalHost();// ADMINISTRATOR/192.xxx.xxx.xxx
        System.out.println(ip);
        //获得主机名
        System.out.println(ip.getHostName());// ADMINISTRATOR
        //获得IP地址
        System.out.println(ip.getHostAddress());// 192.xxx.xxx.xxx
        //getLocalHost=getHostName+getHostAddress
        System.out.println(InetAddress.getByName("localhost"));
    }
}

4.端口相关概念

IP地址用来标识一台计算机，但是一台计算机上可能提供多种网络应用程序，如何来区分这些不同的程序呢？这就要用到端口。端口号是用来区分一台机器上不同的应用程序的。
我们使用IP地址加端口号，就可以保证数据准确无误地发送到对方计算机的指定软件上了。端口是虚拟的概念，是一个逻辑端口。
当我们使用网络软件一打开，那么操作系统就会为网络软件分配一个随机的端口号，或者打开的时候向系统要指定的端口号。
通过端口，可以在一个主机上运行多个网络应用程序。端口的表示是一个16位的二进制整数，2个字节，对应十进制的0~65535。
端口号在计算机内部是占2个字节。一台机器上最多有65536个端口号。一个应用程序可以占用多个端口号。端口号如果被一个应用程序占用了，那么其他的应用程序就无法再使用这个端口号了。
记住一点，我们编写的程序要占用端口号的话占用1024以上的端口号，1024以下的端口号不要去占用，因为系统有可能会随时征用。端口号本身又分为TCP端口和UDP端口，TCP的8888端口和UDP的8888端口是完全不同的两个端口。TCP端口和UDP端口都有65536个

常见端口：
在这里插入图片描述
查看端口的DOS命令：

查看所有端口：netstat -ano
查看指定端口：netstat -ano|findstr "端口号"
查看指定端口的进程：tasklist|findstr "端口号"

在java中使用端口的类为InetSocketAddress，并且借此来实现ip套接字的实现（ip+端口号）

InetSocketAddress常见的方法：

在这里插入图片描述
例子：

import java.net.InetAddress;
import java.net.InetSocketAddress;

public class TestPort {
    public static void main(String[] args) {
        InetSocketAddress inetSocketAddress = new InetSocketAddress("127.0.0.1",8082);
        System.out.println(inetSocketAddress);
        //返回主机名
        System.out.println(inetSocketAddress.getHostName());
        //获得InetSocketAddress的端口
        System.out.println(inetSocketAddress.getPort());
        //返回一个InetAddress对象（IP对象）
        InetAddress address = inetSocketAddress.getAddress();
        System.out.println(address);
    }
}

5.具体的TCP和UDP网络编程
网络编程实现的主要方式是Socket编程，也就是我们常说的套接字编程。
在这里插入图片描述
TCP网络编程

Java中的实现类为客户端的Socket类
Socket 类：该类实现客户端套接字，套接字指的是两台设备之间通讯的端点。

主要方法：

public Socket(String host, int port)
:创建套接字对象并将其连接到指定主机上的指定端口号。如果指定的host是null ，则相当于指定地址为回送地址。
回送地址(127.x.x.x) 是本机回送地址（Loopback
Address），主要用于网络软件测试以及本地机进程间通信，无论什么程序，一旦使用回送地址发送数据，立即返回，不进行任何网络传输。

Socket client = new Socket("127.0.0.1", 6666);

服务端的套接字类为ServerSocke：

ServerSocket类：这个类实现了服务器套接字，该对象等待通过网络的请求。
主要方法：

public ServerSocket(int port)
：使用该构造方法在创建ServerSocket对象时，就可以将其绑定到一个指定的端口号上，参数port就是端口号。
public Socket accept()
：侦听并接受连接，返回一个新的Socket对象，用于和客户端实现通信。该方法会一直阻塞直到建立连接

套接字编程的基本步骤（socket一边传输数据完后会关闭连接）:

1：加载套接字库，创建套接字(WSAStartup()/socket())；

2：绑定套接字到一个IP地址和一个端口上(bind())；

3：将套接字设置为监听模式等待连接请求(listen())；

4：请求到来后，接受连接请求，返回一个新的对应于此次连接的套接字(accept())；

5：用返回的套接字和客户端进行通信(send()/recv())；

6：返回，等待另一连接请求；

7：关闭套接字，关闭加载的套接字库(closesocket()/WSACleanup())。

客户端向服务端传输数据实例：
注意：启动时要先启动服务端。

//客户端
import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;

public class TCPClient {
    public static void main(String[] args){
        Socket socket = null;
        OutputStream os = null;
        try {
            //1、创建Socket对象，它的第一个参数需要的是服务端的IP，第二个参数是服务端的端口
            InetAddress inet = InetAddress.getByName("127.0.0.1");
            socket = new Socket(inet,8090);
            //2、获取一个输出流，用于写出要发送的数据
            os = socket.getOutputStream();
            //3、写出数据
            os.write("你好，我是客户端！".getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {//4、释放资源
            if(socket!=null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(os!=null){
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

//服务端
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class TCPServer {
    public static void main(String[] args) {
        ServerSocket serverSocket = null;
        Socket socket = null;
        InputStream is = null;
        ByteArrayOutputStream baos = null;
        try {
            //1、创建服务端的ServerSocket，指明自己的端口号
            serverSocket = new ServerSocket(8090);
            //2、调用accept接收到来自于客户端的socket
            socket = serverSocket.accept();//阻塞式监听，会一直等待客户端的接入
            //3、获取socket的输入流
            is = socket.getInputStream();

//        不建议这样写：因为如果我们发送的数据有汉字，用String的方式输出可能会截取汉字，产生乱码
//        int len=0;
//        byte[] buffer = new byte[1024];
//        while ((len=is.read(buffer))!=-1){
//            String str = new String(buffer, 0, len);
//            System.out.println(str);
//        }
            
            //4、读取输入流中的数据
            //ByteArrayOutputStream的好处是它可以根据数据的大小自动扩充
            baos = new ByteArrayOutputStream();
            int len=0;
            byte[] buffer = new byte[1024];
            while ((len=is.read(buffer))!=-1){
                baos.write(buffer,0,len);
            }
            System.out.println("收到了来自于客户端"+socket.getInetAddress().getHostName()
                    +"的消息："+baos.toString());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {//5、关闭资源
            if(serverSocket!=null){
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(socket!=null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(is!=null){
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(baos!=null){
                try {
                    baos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

服务端向客户端传输数据实例：
客户端

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;

public class TCPClient {
    public static void main(String[] args){
        Socket socket = null;
        OutputStream os = null;
        ByteArrayOutputStream baos=null;
        InputStream is=null;
        try {
            //1、创建Socket对象，它的第一个参数需要的是服务端的IP，第二个参数是服务端的端口
            InetAddress inet = InetAddress.getByName("127.0.0.1");
            socket = new Socket(inet,8888);
            //2、获取一个输出流，用于写出要发送的数据
            os = socket.getOutputStream();
            //3、写出数据
            os.write("你好，我是客户端！".getBytes());
            //==========================解析回复==================================
            //4、首先必须通知服务器，我已经输出完毕了，不然服务端不知道什么时候输出完毕
            //服务端的while循环会一直执行，会阻塞
            socket.shutdownOutput();
            ///5、获取输入流，用于读取服务端回复的数据
            is = socket.getInputStream();
            baos = new ByteArrayOutputStream();
            int len=0;
            byte[] buffer = new byte[1024];
            while ((len=is.read(buffer))!=-1){
                baos.write(buffer,0,len);
            }
            System.out.println("收到了来自服务端的消息："+baos.toString());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {//6、释放资源
            if(socket!=null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(os!=null){
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(is!=null){
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (baos!=null){
                try {
                    baos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

服务端：

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

public class TCPServer {
    public static void main(String[] args) {
        ServerSocket serverSocket = null;
        Socket socket = null;
        InputStream is = null;
        ByteArrayOutputStream baos = null;
        OutputStream os=null;
        try {
            //1、创建服务端的ServerSocket，指明自己的端口号
            serverSocket = new ServerSocket(8888);
            //2、调用accept接收到来自于客户端的socket
            socket = serverSocket.accept();//阻塞式监听，会一直等待客户端接入
            //3、获取socket的输入流
            is = socket.getInputStream();

//        不建议这样写：因为如果我们发送的数据有汉字，用String的方式输出可能会截取汉字，产生乱码
//        int len=0;
//        byte[] buffer = new byte[1024];
//        while ((len=is.read(buffer))!=-1){
//            String str = new String(buffer, 0, len);
//            System.out.println(str);
//        }

            //4、读取输入流中的数据
            //ByteArrayOutputStream的好处是它可以根据数据的大小自动扩充
            baos = new ByteArrayOutputStream();
            int len=0;
            byte[] buffer = new byte[1024];
            while ((len=is.read(buffer))!=-1){
                baos.write(buffer,0,len);
            }
            System.out.println("收到了来自于客户端"+socket.getInetAddress().getHostName()
                    +"的消息："+baos.toString());
            //===========================回复==========================================
            //5、获取一个输出流，写出回复给客户端
            os = socket.getOutputStream();
            //6、写出数据
            os.write("你好，我是服务端".getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {//7、关闭资源
            if(serverSocket!=null){
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(socket!=null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(is!=null){
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(baos!=null){
                try {
                    baos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(os!=null){
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

文件上传实现：
具体流程：
在这里插入图片描述
客户端：

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

public class TCPClient {
    public static void main(String[] args) {
        Socket socket = null;
        FileInputStream fis = null;
        OutputStream os = null;
        try {
            //1、创建Socket对象，它的第一个参数需要的是服务端的IP，第二个参数是服务端的端口
            InetAddress inet = InetAddress.getByName("127.0.0.1");
            socket = new Socket(inet, 8888);
            //2、创建一个文件输入流，读取要上传的文件
            fis = new FileInputStream("D:/test/touxiang.jpg");
            //3、获取一个输出流，用于写出要发送的数据
            os = socket.getOutputStream();
            byte[] buffer = new byte[1024];
            int len=0;
            while((len=fis.read(buffer))!=-1){
                //4、写出数据
                os.write(buffer,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {//5、释放资源
            if(socket!=null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(fis!=null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(os!=null){
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

服务端：

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

public class TCPServer {
    public static void main(String[] args) {
        ServerSocket serverSocket = null;
        Socket socket = null;
        FileOutputStream fos = null;
        InputStream is = null;
        try {
            //1、创建服务端的ServerSocket，指明自己的端口号
            serverSocket = new ServerSocket(8888);
            //2、调用accept接收到来自于客户端的socket
            socket = serverSocket.accept();//阻塞式监听，会一直等待客户端的接入
            //3、创建一个文件输出流，用于将读取到的客户端上传的文件输出
            fos = new FileOutputStream("touxiang.jpg");
            //4、获取socket的输入流
            is = socket.getInputStream();
            byte[] buffer = new byte[1024];
            int len=0;
            while((len=is.read(buffer))!=-1){
                fos.write(buffer,0,len);//5、写出文件
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {//6、释放资源
            if(serverSocket!=null){
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(socket!=null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(fos!=null){
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(is!=null){
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

UDP网络编程
UDP网络编程主要使用的时DatagramSocket类，因为UDP严格意义上来说部分client和是server。
java.net包给我们提供了两个类DatagramSocket（此类表示用于发送和接收数据报的套接字）和DatagramPacket（该类表示数据报的数据包。）

DatagramSocket
（1）构造方法摘要
protected DatagramSocket()构造数据报套接字并将其绑定到本地主机上的任何可用端口。
protected DatagramSocket(int port)构造数据报套接字并将其绑定到本地主机上的指定端口。
protected DatagramSocket(int port, InetAddress laddr)创建一个数据报套接字，绑定到指定的本地地址。

DatagramPacket
（1）构造方法摘要

DatagramPacket(byte[] buf, int offset, int length)构造一个 DatagramPacket用于接收指定长度的数据报包到缓冲区中。
DatagramPacket(byte[] buf, int offset, int length, InetAddress address, int port)构造用于发送指定长度的数据报包到指定主机的指定端口号上。

（2）常用方法摘要

byte[] getData() 返回数据报包中的数据。
InetAddress getAddress() 返回该数据报发送或接收数据报的计算机的IP地址。
int getLength() 返回要发送的数据的长度或接收到的数据的长度。

单对单案例：
发送方：

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

public class UDPSender {
    public static void main(String[] args) throws IOException {
        //1、创建一个socket
        DatagramSocket socket = new DatagramSocket();
        InetAddress inet = InetAddress.getLocalHost();
        String msg="你好，很高兴认识你！";
        byte[] buffer = msg.getBytes();
        //2、创建一个包（要发送给谁）
        DatagramPacket packet = new DatagramPacket(buffer,0,buffer.length,inet,9090);
        //3、发送包
        socket.send(packet);
        //4、释放资源
        socket.close();
    }
}

接收方：

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

public class UDPReceiver {
    public static void main(String[] args) throws IOException {
        //1、创建一个socket，开放端口
        DatagramSocket socket = new DatagramSocket(9090);
        byte[] buffer = new byte[1024];
        //2、创建一个包接收数据
        DatagramPacket packet = new DatagramPacket(buffer, 0, buffer.length);
        //3、接收数据
        socket.receive(packet);//阻塞式接收
        //将数据包转换为字符串输出
        String msg = new String(packet.getData(), 0, packet.getLength());
        System.out.println(msg);
        //4、释放资源
        socket.close();
    }
}

学生老师在线交流实例，相当于创建两个udp连接，一方学生当发送者，老师是当接收者；一方老师当发送者，学生当接收者，所以要实例化两个线程；
发送方：

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

public class UDPSender implements Runnable{
    //创建一个socket
    DatagramSocket socket=null;
    //创建一个流 用于录入键盘的数据
    BufferedReader bfr=null;
    //发送数据目的地的IP
    private String toIP;
    //发送数据目的地的端口
    private int toPort;

    public UDPSender(String toIP, int toPort) {
        this.toIP = toIP;
        this.toPort = toPort;
        try {
            socket=new DatagramSocket();//创建一个socket
        } catch (SocketException e) {
            e.printStackTrace();
        }
        bfr=new BufferedReader(new InputStreamReader(System.in));//从键盘录入数据到流中
    }

    @Override
    public void run() {
        while (true){//循环发送数据
            try {
                String msg = bfr.readLine();//从流中读取数据
                byte[] buffer = msg.getBytes();
                InetAddress inet = InetAddress.getByName(toIP);
                DatagramPacket packet = new DatagramPacket(buffer, 0, buffer.length, inet, toPort);
                socket.send(packet);
                //如果发送了拜拜，则退出发送
                if(msg.equals("拜拜")){
                    break;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        //释放资源
        if(socket!=null){
            socket.close();
        }
        if (bfr!=null){
            try {
                bfr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

接收方：

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

public class UDPReceiver implements Runnable{
    //创建一个socket
    DatagramSocket socket=null;
    //接收方自己所在的端口
    private int fromPort;
    //数据发送者的姓名
    private String msgFrom;

    public UDPReceiver(int fromPort,String msgFrom) {
        this.fromPort = fromPort;
        this.msgFrom=msgFrom;
        try {
            socket=new DatagramSocket(fromPort);//创建一个socket
        } catch (SocketException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        while(true){//循环接收
            try {
                byte[] buffer = new byte[1024 * 8];
                DatagramPacket packet = new DatagramPacket(buffer, 0, buffer.length);
                socket.receive(packet);
                String msg = new String(packet.getData(), 0, packet.getLength());
                System.out.println(msgFrom+":"+msg);
                if (msg.equals("拜拜")){//如果接收到的数据为拜拜，则退出接收
                    break;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        //释放资源
        socket.close();
    }
}

学生线程：

public class Student {
    public static void main(String[] args) {
        new Thread(new UDPSender("127.0.0.1",8888)).start();
        new Thread(new UDPReceiver(7777,"老师")).start();
    }
}

教师线程：

public class Student {
    public static void main(String[] args) {
        new Thread(new UDPSender("127.0.0.1",8888)).start();
        new Thread(new UDPReceiver(7777,"老师")).start();
    }
}

在这里插入图片描述
6.URL
java.net包下

1.构造方法摘要

URL(String spec)根据 String 表示形式创建 URL 对象。
URL(String protocol, String host, int port, String file) 根据指定协议名、主机名、端口号和文件名创建 URL 对象。
URL(String protocol, String host, String file) 根据指定的协议名、主机名和文件名创建 URL。

2.常用方法摘要

String getProtocol()获取此 URL的协议名称。
String getHost() 获取此 URL 的主机名。
int getPort() 获取此 URL 的端口号。
String getPath() 获取此 URL 的文件路径。
String getFile()获取此 URL 的文件名。
String getQuery()获取此 URL的查询部分。
URLConnection openConnection() 返回一个URLConnection实例，表示与URL引用的远程对象的URL 。

URLConnection类中又有一个方法：

InputStream getInputStream() 返回从此打开的连接读取的输入流。

案例演示1

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

public class Test {
    public static void main(String[] args) throws MalformedURLException {
        URL url = new URL("http://localhost:8080/index.jsp?username=Tom&password=123456");
        System.out.println(url.getProtocol());//获取协议名
        System.out.println(url.getHost());//获取主机名
        System.out.println(url.getPort());//获取端口号
        System.out.println(url.getPath());//获取文件路径
        System.out.println(url.getFile());//获取文件名
        System.out.println(url.getQuery());//获取查询名
    }
}

案例演示2
URL下载网络资源

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;

public class Test {
    public static void main(String[] args) throws IOException {
        //下载地址
        URL url = new URL("https://img.t.sinajs.cn/t6/style/images/global_nav/WB_logo.png?id=1404211047727");
        //连接到这个资源 HTTP
        HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();
        InputStream is = urlConnection.getInputStream();
        FileOutputStream fos = new FileOutputStream("weibo.jpg");
        byte[] buffer = new byte[1024];
        int len=0;
        while ((len=is.read(buffer))!=-1){
            fos.write(buffer,0,len);
        }
        //释放资源
        urlConnection.disconnect();//断开连接
        is.close();
        fos.close();
    }
}
`总结：
![在这里插入图片描述](https://img-blog.csdnimg.cn/c51d06278a9f468eb19dbf788131bd7f.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAd2VpeGluXzQ1NzcxMTU4,size_20,color_FFFFFF,t_70,g_se,x_16)

秋鸣之时

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Java网络编程基础

Java网络编程基础参考：https://blog.csdn.net/allenfoxxxxx/article/details/907075051.什么是网络编程网络编程是指编写运行在多个设备（计算机）的程序，这些设备都通过网络连接起来。2.具体在java中来说在Java中实现网络编程主要使用的是java.net包。java.net 包中 J2SE 的 API 包含有类和接口，它们提供低层次的通信细节。你可以直接使用这些类和接口，来专注于解决问题，而不用关注通信细节。3....
复制链接

扫一扫