AI 助理
备案控制台
开发者社区 计算巢 文章 正文

java网络编程（详解）

2023-10-18 130
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 网络编程是一种基于计算机网络的应用程序开发技术。它涉及到在不同计算机之间传输数据，允许程序在网络上进行通信和交互。在网络编程中，开发者可以使用不同的编程语言和协议来实现数据的传输和通信
1、什么是网络编程

网络在通信协议下，不同计算机上运行的程序，进行的数据传输

  • 应用场景：即时通信，网游对战，金融证券，国际贸易，邮件等等

    不管什么场景，本质上都是计算机跟计算机之间通过网络进行数据传输

  • java中可以使用java.net包下的技术轻松开发出常见的网络应用程序

2、常见的软件架构

  • C / S ：Client / Server

    在用户本地需要下载安装客户端程序，在远程有一个服务器端程序

    C / S的优缺点：

    ​ 1、画面可以做的非常精美，用户体验好

    ​ 2、需要开发客户端，也需要开发服务端

    ​ 3、用户需要下载更新的时候太麻烦

  • B / S : Browser / Server

    只需要一个浏览器，用户通过不同的地址，客户访问不同的服务器

​ B / S的优缺点：

​ 1、不需要开发客户端

​ 2、用户不需要下载，打开浏览器就能使用

​ 3、如果应用过大，用户体验受到影响

注意：无论什么架构，都有各自的优缺点，具体看实际情况定

3、网络编程三要素
  • ip
    • 设备在网络中的地址
  • 端口号
    • 应用程序在设备中的唯一识别
  • 协议
    • 数据在网络中传输的规则，常见的协议有TCP，http,ftp等
4、InetAddress类

  • ip地址的代表类是谁

    InetAddress

  • 如何获取本机ip对象

    public static InetAddress getLocalHost()

  • 如何判断与该ip地址对象是否互通

    public boolean isReachable(int timeout)

public class myAddress {
   
   
    public static void main(String[] args) throws UnknownHostException {
   
   
        /**
         * static InetAddress getByName(String host)  确定主机名称的ip地址，主机名可以是机器名，也可以是ip地址
         * String getHostName()     获取此ip地址的主机名
         * String getHostAddress    返回文本显示中的ip地址字符串
         */

        // 1.获取InetAddress对象
        InetAddress address = InetAddress.getByName("DESKTOP-1G6DPV3");
        System.out.println(address);

        // 2.获取名称
        String hostName = address.getHostName();
        System.out.println(hostName);

        // 3.获取ip
        String hostAddress = address.getHostAddress();
        System.out.println(hostAddress);

    }
}
5、端口号

标识正在计算机设备上运行的进程，被规定为一个16位的二进制，范围0~65535

端口类型

  • 周知端口：0~1023，被预先定义的知名应用占用（如：http占用80，FTP占用21）
  • 注册端口：1024~49151，分配给用户进程或者某些应用程序（如：tomcat占用8080，MySQL占用3306）
  • 动态端口：49152~65535，之所以称为动态端口，是因为它一般不固定分配某种进程，而是动态分配

注意：我们自己开发的程序选择注册端口，且一个设备中不能出现两个程序的端口号一样，否则出错

6、协议

协议是连接和通信数据的规则

网络通信协议有两套参考模型

  • OSI参考模型 ： 7层
  • TCP/IP参考模型：4层

传输层常见的两个协议

  • TCP：传输控制协议
    • 使用tcp协议必须建立连接，他是一种面向对象的可靠协议
    • 采用三次握手，四次挥手，所以可靠
    • 在连接中可进行大数据量传输
    • 连接、发送数据都需要确认，且传输完毕后，还需要释放自己建立的连接，通信效率低
  • UDP：用户数据报协议
    • udp是无连接不可靠协议
    • 将数据源ip、目的地ip和端口号封装成数据包，不需要建立连接
    • 每个包再64kb内
    • 发送不管对方是否准备好，接收方收到也不确认，故是不可靠的
    • 可以广播发送，发送数据结束时无需释放资源，开销小，速度快
7、UDP通信

DatagramPacket：数据包对象

构造器 说明
public DatagramPacket(byte[] buf,int length,InetAddress address,int port) 创建发送对象
buf：要发送的内容，字节数组
length：要发送内容的字节长度
address：接收端的IP地址对象
port：接受收的端口号
public DatagramPacket(byte[] buf,int length) 创建接收端的数据包对象
buf：用来存储接收的内容
length：能够接收内容的长度

DatagramSocket：发送端和接收端对象

构造器 说明
public DatagramSocket() 创建发送端的Socket对象，系统会随机分配一个端口号
public DatagramSocket(int port) 创建接收端的Socket对象并指定端口号

DatagramSocket类成员方法

方法 说明
public void send(DatagramPacket dp) 发送数据包
public void receive(DatagramPacket p) 接收数据包
7.1、一收一发

需求

  • 客户端实现步骤
    1. 创建DatagramSocket对象（发送端对象）
    2. 创建DatagramPacket对象封装需要发送的数据（数据包对象）
    3. 使用DatagramSocket对象的send方法传入DatagramPack对象
    4. 释放资源
  • 接收端实现步骤
    1. 创建DatagramSocket对象并指定端口（接收端对象）
    2. 创建DatagramPacket对象接收数据（数据包对象）
    3. 使用DatagramSocket对象的receive方法传入DatagramPacket对象
    4. 释放资源

代码案例

  • 发送端

    package com.lwj.address.demo02;

import java.io.IOException;
import java.net.*;

/**
 * 学会udp通信，  需求 1发1收
 * 客户端:发送端
 */
public class ClientDemo01 {
     
     
    public static void main(String[] args) throws IOException {
     
     
       //创建发送端对象
        DatagramSocket socket = new DatagramSocket();

        //创建数据包对象
        byte[] buffer = "我是客户端，请问在吗".getBytes();
        DatagramPacket packet = new DatagramPacket(buffer,buffer.length, InetAddress.getLocalHost(),6666);

        //发送数据包
        socket.send(packet);

        //释放资源
        socket.close();
    }
}

  • 接收端

    package com.lwj.address.demo02;

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

/**
 *
 */
public class ServerDemo01 {
     
     
    public static void main(String[] args) throws IOException {
     
     
        //创建接收端对象,接收端必须注册端口
        DatagramSocket socket = new DatagramSocket(6666);

        // 创建数据包对象
        byte[] buffer = new byte[64 * 1024];
        DatagramPacket packet = new DatagramPacket(buffer,buffer.length);

        //接收数据包
        socket.receive(packet);
        //得到读取的字节数量
        int len = packet.getLength();
        System.out.println("读取的字节数为" + len);

        //把数据转换出来
        String rs = new String(buffer,0, len);
        System.out.println("收到客户端发送的消息" + rs);

        //拿发送端的ip地址和端口
        System.out.println(packet.getSocketAddress());
        System.out.println(packet.getPort());
    }
}
7.2、UDP如何实现广播
  • 使用广播地址：255.255.255.255
  • 具体操作
    1. 发送端发送的数据包的目的地写广播地址且指定端口（255.255.255.255,9999）
    2. 本机所在网段的其他主机和程序只要注册对应端口就可以收到消息了(9999)
7.3、UDP如何实现组播
  • 使用组播地址：224.0.0.0~239.255.255.55
  • 具体操作：
    1. 发送端的数据包的目的是组播IP（例如：224.0.1.1，端口：9999）
    2. 接收端必须绑定该组播IP（224.0.1.1），端口还要注册发送端的目的端口，这样可以即可接收该组播消息
    3. DatagramSocket的子类MulticastSocket可以绑定组播ip

代码演示

  • 发送端

    public class ClientDemo04 {
     
     
    public static void main(String[] args) throws IOException {
     
     
        DatagramSocket socket = new DatagramSocket();

        Scanner scanner = new Scanner(System.in);

        while (true){
     
     
            System.out.println("请输入你的信息");
            String s = scanner.nextLine();

            if ("exit".equals(s)){
     
     
                break;
            }

            byte[] buffer = s.getBytes();

            DatagramPacket packet = new DatagramPacket(buffer,buffer.length,InetAddress.getByName("225.1.1.1"),8989);

            socket.send(packet);
        }

        socket.close();
    }
}

  • 服务端

    public class ServerDemo04 {
     
     
    public static void main(String[] args) throws IOException {
     
     

        System.out.println("=====服务端启动=====");

        // 1、创建接收端对象，注册端口
        MulticastSocket socket = new MulticastSocket(8989);

        // 2、注册组播地址
        socket.joinGroup(new InetSocketAddress(InetAddress.getByName("225.1.1.1"),8989),
                NetworkInterface.getByInetAddress(InetAddress.getLocalHost()));

        byte[] buffer = new byte[64*1024];
        DatagramPacket packet = new DatagramPacket(buffer,buffer.length);

        while (true){
     
     

            socket.receive(packet);

            int len = packet.getLength();

            //把数据转换出来
            String rs = new String(buffer,0, len);
            System.out.println("收到客户端发送的消息:" + rs);

        }
    }
}
8、TCP通信

客户端

  1. TCP的通信客户端代代表类是谁？
    • Socker类
    • public Socket(String host,int port)
  2. TCP通信如何使用Socket管道发送、接收数据
    • OutputStream getOutputStream() ：获取字节输出流对象（发）
    • InputStream getInputStream() ：获取字节输入流对象（收）
构造器 说明
public Socket(String host,int port) 创建发送端的Socket对象与服务端连接，参数为服务端程序的ip和端口
方法 说明
OutputStream getOutputStream() 获取字节输入流对象
InputStream getInputStream() 获取字节输入流对象

服务端

  1. TCP通信服务端用的代表类？
    • ServerSocket类，注册端口
    • 调用accept()方法阻塞等待接收客户端连接，得到Socket对象
  2. TCP通信的基本原理
    • 客户端怎么发，服务端怎么收
    • 客户端如果没有发消息，服务端会进入阻塞等待
    • Socket一方关闭或者出现异常、对方Socket也会失效或者出错
构造器 说明
public ServerSocket(int port) 注册服务端端口
方法 说明
public Socket accept() 等待接收客户端的Socket通信连接
连接成功返回Socket对象与客户端建立端到端通信
8.1、客户端编写

需求：客户端实现步骤

  1. 创建客户端Socket对象，请求与服务端的连接
  2. 使用socket对象调用getOutputStream()方法得到字节输入流
  3. 使用字节输出流完成数据的发送
  4. 释放刷新资源

代码示例

public class ClientDemo01 {
   
   
    public static void main(String[] args) throws IOException {
   
   

        //1、创建Socket对象,请求与服务器的连接
        Socket socket = new Socket("127.0.0.1",9999);

        //2、从socket通信管道得到一个字节输出流，负责写数据进去
        OutputStream os = socket.getOutputStream();

        //3、把低级字节输出流交给打印流
        PrintStream ps = new PrintStream(os);

        //4、发送消息
        ps.print("你好");

        //5、刷新
        ps.flush();

    }
}
8.2、服务端编写

需求：服务端实现步骤

  1. 创建ServerSocket对象，注册服务端端口
  2. 调用ServerSocket对象的accept()方法，等待客户端的连接，并得到Socket管道对象

代码示例

public class ServerDemo01 {
   
   
    public static void main(String[] args) throws IOException {
   
   
        System.out.println("服务端启动....");

        //1、注册端口
        ServerSocket serverSocket = new ServerSocket(9999);

        //2、开始等待接收客户端的连接请求
        Socket accept = serverSocket.accept();

        //3、从socket通信管道中得到字节输入流
        InputStream inputStream = accept.getInputStream();

        //4、读取消息
        BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));
        String line;
        if ((line = br.readLine()) != null) {
   
   
            System.out.println(accept.getRemoteSocketAddress() + "说了" + line);
        }
    }
}
8.3、TCP多发多收通信

需求：使用TCP通信方式：多发多收

  1. 可以使用循环控制服务端收完消息继续等待接收下一个消息
  2. 客户端也可以使用死循环等待用户不断输入消息
  3. 客户端一但输入exit，则关闭客户端程序，并释放资源

客户端编写

public class ClientDemo02 {
   
   
    public static void main(String[] args) throws IOException {
   
   

        //1、创建Socket对象,请求与服务器的连接
        Socket socket = new Socket("127.0.0.1",9999);

        Scanner scanner = new Scanner(System.in);

        //2、从socket通信管道得到一个字节输出流，负责写数据进去
        OutputStream os = socket.getOutputStream();

        //3、把低级字节输出流交给打印流
        PrintStream ps = new PrintStream(os);

        while (true){
   
   
            String mess = scanner.nextLine();

            if (mess.equals("exit")){
   
   
                socket.close();
                break;
            }
            //4、发送消息
            ps.println(mess);

            //5、刷新
            ps.flush();
        }

    }
}

服务端

public class ServerDemo02 {
   
   
    public static void main(String[] args) throws IOException {
   
   
        System.out.println("服务端启动....");

        //1、注册端口
        ServerSocket serverSocket = new ServerSocket(9999);

        //2、开始等待接收客户端的连接请求
        Socket accept = serverSocket.accept();

        //3、从socket通信管道中得到字节输入流
        InputStream inputStream = accept.getInputStream();

        //4、读取消息
        BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));
        String line;
        while ((line = br.readLine()) != null) {
   
   
            System.out.println(accept.getRemoteSocketAddress() + "说了" + line);
        }
    }
}
8.4、同时接收多个客户端消息

之前我们的通信是否可以同时与多个客户端通信，为什么

  • 不可以
  • 单线程每次只能处理一个客户端的Socket通信

如何才可以让服务i端处理多个客户端的通信需求

  • 引入多线程

image-20231018183533830

客户端编写

public class ClientDemo03 {
   
   
    public static void main(String[] args) throws IOException {
   
   

        //1、创建Socket对象,请求与服务器的连接
        Socket socket = new Socket("127.0.0.1",9999);

        Scanner scanner = new Scanner(System.in);

        //2、从socket通信管道得到一个字节输出流，负责写数据进去
        OutputStream os = socket.getOutputStream();

        //3、把低级字节输出流交给打印流
        PrintStream ps = new PrintStream(os);

        while (true){
   
   
            String mess = scanner.nextLine();

            if (mess.equals("exit")){
   
   
                socket.close();
                break;
            }
            //4、发送消息
            ps.println(mess);

            //5、刷新
            ps.flush();
        }
    }
}

线程类编写

public class ServerReaderThread extends Thread{
   
   

    private Socket socket;

    public ServerReaderThread(Socket socket){
   
   
        this.socket = socket;
    }

    @Override
    public void run() {
   
   
        try {
   
   
            //从socker管道获取字节输入流读取数据
            InputStream inputStream = socket.getInputStream();

            //读取消息
            BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));
            String line;
            while ((line = br.readLine()) != null){
   
   
                System.out.println(socket.getRemoteSocketAddress() + " 说了：" + line);
            }
            System.out.println("有人下线了" + socket.getRemoteSocketAddress());
        } catch (IOException e) {
   
   
            System.out.println("有人非正常下线了" + socket.getRemoteSocketAddress());
        }
    }
}

服务端编写

package com.lwj.address.demo07;

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

public class ServerDemo03 {
   
   
    public static void main(String[] args) throws IOException {
   
   
        System.out.println("服务端启动....");

        ServerSocket serverSocket = new ServerSocket(9999);

        while (true){
   
   
            //开始等待接收客户端socket连接请求
            Socket socket = serverSocket.accept();

            System.out.println("有人上线了" + socket.getRemoteSocketAddress());


            //创建线程负责处理socket信息
            new ServerReaderThread(socket).start();
        }
    }
}
8.5、使用线程池优化

8.4的通信架构存在什么问题？

  1. 客户端与服务端的线程模型是：N-N的关系
  2. 客户端并发越多，系统瘫痪的越快

优化

  • 客户端编写
public class ClientDemo {
   
   
    public static void main(String[] args) throws IOException {
   
   

        //1、创建Socket对象,请求与服务器的连接
        Socket socket = new Socket("127.0.0.1",7777);

        Scanner scanner = new Scanner(System.in);

        //2、从socket通信管道得到一个字节输出流，负责写数据进去
        OutputStream os = socket.getOutputStream();

        //3、把低级字节输出流交给打印流
        PrintStream ps = new PrintStream(os);

        while (true){
   
   
            String mess = scanner.nextLine();

            if (mess.equals("exit")){
   
   
                socket.close();
                break;
            }
            //4、发送消息
            ps.println(mess);

            //5、刷新
            ps.flush();
        }
    }
}
  • 服务端
public class ServerDemo {
   
   

    //定义静态的线程池对象
    public static ExecutorService pool = new ThreadPoolExecutor(2,3,5,
            TimeUnit.SECONDS,new ArrayBlockingQueue<>(3), Executors.defaultThreadFactory(),
            new ThreadPoolExecutor.AbortPolicy());

    public static void main(String[] args) throws IOException {
   
   
        System.out.println("服务端启动...");

        //1、注册端口
        ServerSocket serverSocket = new ServerSocket(7777);

        while (true){
   
   
            // 2、开始等待接收客户端的socket连接请求
            Socket socket = serverSocket.accept();

            System.out.println("有人上线了" + socket.getRemoteSocketAddress());

            //3、把当前客户端的socket做出任务对象交给线程池处理
            pool.execute(new ServerReaderRunnable(socket));

        }
    }
}
  • 线程实现类
/**
 * 读取负责socket的消息
 */
public class ServerReaderRunnable implements Runnable {
   
   
    private Socket socket;

    public ServerReaderRunnable(Socket socket){
   
   
        this.socket = socket;
    }
    @Override
    public void run() {
   
   
        try {
   
   
            //从socket管道获取字节输入流读取数据
            InputStream inputStream = socket.getInputStream();

            //读取消息
            BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));
            String line;
            while ((line = br.readLine()) != null){
   
   
                System.out.println(socket.getRemoteSocketAddress() + " 说了：" + line);
            }
            System.out.println("有人下线了" + socket.getRemoteSocketAddress());
        } catch (IOException e) {
   
   
            System.out.println("有人非正常下线了" + socket.getRemoteSocketAddress());
        }
    }
}
9、TCP实战案例----即时通信

即时通信是什么含义，要实现怎么样的设计？

  • 即时通信，是指一个客户端的消息发出去，其他客户端可以接收到
  • 之前我们的消息都是发给服务端的
  • 即时通信需要我们进行端口转发的设计思想

即时通信-端口转发

image-20231018223533863

9.1、实现群聊

客户端编写

public class ClientDemography {
   
   
    public static void main(String[] args) throws IOException {
   
   
        //创建Socket对象，请求与服务器的连接
        Socket socket = new Socket("127.0.0.1",7777);

        Scanner scanner = new Scanner(System.in);

        //为当前这个客户端socket分配一个独立的读线程，负责读取服务器转发过来的其他客户端的信息
        new ClientReaderThreadDemo(socket).start();


        //从socket通信管道得到一个字节输入流，负责写数据进去
        OutputStream outputStream = socket.getOutputStream();

        //把低级字节输出流给打印流，负责写数据进去
        PrintStream ps = new PrintStream(outputStream);

        while (true){
   
   
            String mess = scanner.nextLine();

            if (mess.equals("exit")){
   
   
                socket.close();
                break;
            }

            //4、发送消息
            ps.println(mess);
            //5、刷新
            ps.flush();
        }
    }
}

客户端接收线程类

public class ClientReaderThreadDemo extends Thread{
   
   
    private Socket socket;

    public ClientReaderThreadDemo(Socket socket){
   
   
        this.socket = socket;
    }

    @Override
    public void run() {
   
   

        try {
   
   
            //从socket管道获取字节输入流读取数据
            InputStream inputStream = socket.getInputStream();

            //读取数据
            BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));
            String line;
            while ((line = br.readLine()) != null){
   
   
                System.out.println(socket.getRemoteSocketAddress() + "说了" + line);

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

    }
}

服务端编写

public class ServerDemography {
   
   

    //定义一个静态集合，存储所有在线的socket管道
    public static List<Socket> socketList = new ArrayList<>();

    public static void main(String[] args) throws IOException {
   
   
        System.out.println("服务端启动....");

        ServerSocket serverSocket = new ServerSocket(7777);

        while (true){
   
   
            //开始等待接收客户端socket连接请求
            Socket socket = serverSocket.accept();

            System.out.println("有人上线了" + socket.getRemoteSocketAddress());

            //存进集合
            socketList.add(socket);

            //创建线程负责处理socket信息
            new ServerReaderThreadDemo(socket).start();

        }
    }
}

服务端线程类编写

public class ServerReaderThreadDemo extends Thread{
   
   
    private Socket socket;

    public ServerReaderThreadDemo(Socket socket){
   
   
        this.socket = socket;
    }

    @Override
    public void run() {
   
   

        try {
   
   
            //从socket管道获取字节输入流读取数据
            InputStream inputStream = socket.getInputStream();

            //读取数据
            BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));
            String line;
            while ((line = br.readLine()) != null){
   
   

                System.out.println(socket.getRemoteSocketAddress() + "说了" + line);

                //将消息推送给当前所有在线socket，排除自己
                senMsgToAll(line);

            }
            System.out.println("有人下线了" + socket.getRemoteSocketAddress());
        } catch (IOException e) {
   
   
            System.out.println("有人下线了" + socket.getRemoteSocketAddress());
        }

    }

    private void senMsgToAll(String msg) throws IOException {
   
   
        /**
         * 1、遍历全部在线socket
         * 2、排除自己的Socket，不应该发给自己
         * 3、从这个socket得到一个字节输入流，包装成打印流写消息
         */
        for (Socket newSocket : ServerDemography.socketList) {
   
   
            if (newSocket != socket){
   
   
                PrintStream ps = new PrintStream(newSocket.getOutputStream());
                ps.println(msg);
                ps.flush();
            }
        }
    }
}
9.2、模拟BS系统

BS结构是什么样的，需要开发客户端嘛

  • 浏览器访问服务端，不需要开发客户端，是由服务端直接响应网页数据的
  • 所以我们只需要开发服务端，然后用本地浏览器测试

服务端编写

package com.lwj.address.demo10;


import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.*;

public class BSServer {
   
   
    //定义静态的线程池对象
    public static ExecutorService pool = new ThreadPoolExecutor(2,3,5,
            TimeUnit.SECONDS,new ArrayBlockingQueue<>(3), Executors.defaultThreadFactory(),
            new ThreadPoolExecutor.AbortPolicy());

    public static void main(String[] args) throws IOException {
   
   
        System.out.println("服务端启动...");

        //1、注册端口
        ServerSocket serverSocket = new ServerSocket(8080);

        while (true){
   
   
            // 2、开始等待接收客户端的socket连接请求
            Socket socket = serverSocket.accept();

            System.out.println("有人上线了" + socket.getRemoteSocketAddress());

            //3、把当前客户端的socket做出任务对象交给线程池处理
            pool.execute(new ServerReaderRunnable(socket));

        }
    }
}

服务端线程

package com.lwj.address.demo10;

import java.io.*;
import java.net.Socket;

/**
 * 读取负责socket的消息
 */
public class ServerReaderRunnable implements Runnable {
   
   
    private Socket socket;

    public ServerReaderRunnable(Socket socket){
   
   
        this.socket = socket;
    }
    @Override
    public void run() {
   
   
        try {
   
   
            //响应一个网页数据
            PrintStream ps = new PrintStream(socket.getOutputStream());
            ps.println("HTTP/1.1 200 0k");
            ps.println("Content-Type:text/html;charset=UTF-8");
            ps.println(); //换行
            ps.println("<div style='color:green'>你好</div>");
            ps.flush();
            socket.close();

        } catch (Exception e) {
   
   
            System.out.println("有人非正常下线了" + socket.getRemoteSocketAddress());
        }
    }
}

运行结果

image-20231018234819094

文章标签：
网络协议
Java
UED
关系型数据库
存储
关键词：
Java网络
Java网络编程
网络编程java
小小小林
目录
相关文章
陌陌谣
|
13天前
|
存储 监控 安全
单位网络监控软件：Java 技术驱动的高效网络监管体系构建
在数字化办公时代，构建基于Java技术的单位网络监控软件至关重要。该软件能精准监管单位网络活动，保障信息安全，提升工作效率。通过网络流量监测、访问控制及连接状态监控等模块，实现高效网络监管，确保网络稳定、安全、高效运行。
陌陌谣
43 11
东方睿赢
|
1月前
|
Java 程序员
JAVA程序员的进阶之路：掌握URL与URLConnection，轻松玩转网络资源！
在Java编程中，网络资源的获取与处理至关重要。本文介绍了如何使用URL与URLConnection高效、准确地获取网络资源。首先，通过`java.net.URL`类定位网络资源；其次，利用`URLConnection`类实现资源的读取与写入。文章还提供了最佳实践，包括异常处理、连接池、超时设置和请求头与响应头的合理配置，帮助Java程序员提升技能，应对复杂网络编程场景。
东方睿赢
66 9
东方睿赢
|
1月前
|
人工智能 Java 物联网
JAVA网络编程的未来：URL与URLConnection的无限可能，你准备好了吗？
随着技术的发展和互联网的普及，JAVA网络编程迎来新的机遇。本文通过案例分析，探讨URL与URLConnection在智能API调用和实时数据流处理中的关键作用，展望其未来趋势和潜力。
东方睿赢
47 7
兴化
|
1月前
|
网络协议 Java 物联网
Java网络编程知识点
Java网络编程知识点
兴化
50 13
龙大吉
|
1月前
|
Java 开发者
JAVA高手必备：URL与URLConnection，解锁网络资源的终极秘籍！
在Java网络编程中，URL和URLConnection是两大关键技术，能够帮助开发者轻松处理网络资源。本文通过两个案例，深入解析了如何使用URL和URLConnection从网站抓取数据和发送POST请求上传数据，助力你成为真正的JAVA高手。
龙大吉
67 11
喵帕斯先生
|
1月前
|
安全 Java API
深入探索Java网络编程中的HttpURLConnection：从基础到进阶
本文介绍了Java网络编程中HttpURLConnection的高级特性，包括灵活使用不同HTTP方法、处理重定向、管理Cookie、优化安全性以及处理大文件上传和下载。通过解答五个常见问题，帮助开发者提升网络编程的效率和安全性。
喵帕斯先生
116 9
东方睿赢
|
1月前
|
JSON 安全 算法
JAVA网络编程中的URL与URLConnection：那些你不知道的秘密！
在Java网络编程中，URL与URLConnection是连接网络资源的两大基石。本文通过问题解答形式，揭示了它们的深层秘密，包括特殊字符处理、请求头设置、响应体读取、支持的HTTP方法及性能优化技巧，帮助你掌握高效、安全的网络编程技能。
东方睿赢
69 9
龙大吉
|
1月前
|
JSON Java API
JAVA网络编程新纪元：URL与URLConnection的神级运用，你真的会了吗？
本文深入探讨了Java网络编程中URL和URLConnection的高级应用，通过示例代码展示了如何解析URL、发送GET请求并读取响应内容。文章挑战了传统认知，帮助读者更好地理解和运用这两个基础组件，提升网络编程能力。
龙大吉
56 5
进步`于辰
|
2月前
|
Java
[Java]Socket套接字（网络编程入门）
本文介绍了基于Java Socket实现的一对一和多对多聊天模式。一对一模式通过Server和Client类实现简单的消息收发；多对多模式则通过Server类维护客户端集合，并使用多线程实现实时消息广播。文章旨在帮助读者理解Socket的基本原理和应用。
进步`于辰
34 1
互联网课堂
|
1月前
|
数据采集 Java API
java怎么设置代理ip：简单步骤，实现高效网络请求
本文介绍了在Java中设置代理IP的方法，包括使用系统属性设置HTTP和HTTPS代理、在URL连接中设置代理、设置身份验证代理，以及使用第三方库如Apache HttpClient进行更复杂的代理配置。这些方法有助于提高网络请求的安全性和灵活性。
互联网课堂
59 0

计算巢

热门文章

最新文章

  • 1
    幻兽帕鲁服务器存档拷贝教程
  • 2
    幻兽帕鲁服务器参数配置指南&参数解读&参数推荐
  • 3
    Docker Hub 镜像拉取超时：1Panel面板中应用安装失败的临时解决方案
  • 4
    Java“Could Not Create Java Virtual Machine”解决
  • 5
    2024阿里云幻兽帕鲁/Palworld服务器价格表(CPU/内存/带宽/磁盘收费标准)
  • 6
    Java“Broken Pipe”解决
  • 7
    Java“非静态变量 ... 不能在静态上下文中被引用”解决
  • 8
    Java 包(package)的作用详解
  • 9
    Nextcloud一键部署：快速搭建如企业钉钉或飞书的团队协作平台
  • 10
    3分钟部署 我的世界（Minecraft） 联机服务
  • 1
    前端基础之HTML
    17
  • 2
    NetApp数据恢复—NetApp误删除的数据恢复案例
    19
  • 3
    Java的基础概念一
    24
  • 4
    服务器数据恢复—V7000存储上多块Mdisk成员盘出现故障的数据恢复案例
    18
  • 5
    硬盘数据恢复—硬盘电路板损坏的数据恢复方案
    46
  • 6
    硬盘数据恢复—硬盘出现物理坏道如何妙手回春？
    24
  • 7
    硬盘数据恢复——硬盘固件区损坏的数据恢复方案
    36
  • 8
    UNIX数据恢复—UNIX系统常见故障问题的数据恢复方案
    30
  • 9
    服务器数据恢复—RAID5阵列中两块硬盘离线导致阵列崩溃的数据恢复案例
    34
  • 10
    在云上轻松部署达梦数据库
    80

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0

    • 相关实验场景

    更多
  • 阿里云平台上进行Java程序的编译与运行
  • 使用Java面向对象编写网络通信程序应用
  • 手动部署Java Web环境（Alibaba Cloud Linux 2）
  • 容器的网络入门
  • 容器的自定义网络
  • 容器的共享网络模型
    • 下一篇
    手把手教你白嫖阿里云服务器(免费领服务器)