Java网络编程封装

原创 已于 2025-04-25 11:46:15 修改
· 3.4k 阅读 · 14 ·
版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #网络 #开发语言 #Java网络编程 #java封装

于 2025-02-22 14:10:32 首次发布

系列文章目录

Java知识点

文章目录

👉前言

Java 网络编程封装原理主要围绕着将底层的网络通信细节隐藏起来，提供简洁、易用且安全的高层接口，方便开发者进行网络应用开发。下面从封装的目标、常见的封装层次和具体的封装实现原理等方面详细介绍。

博客将会介绍如何实现Java网络编程封装。希望这篇博客对Unity的开发者有所帮助。
大家好，我是心疼你的一切，不定时更新Unity开发技巧，觉得有用记得一键三连哦。
欢迎点赞评论哦.下面就让我们进入正文吧 !

提示：以下是本篇文章正文内容，下面案例可供参考

👉一、封装的目标

简化开发：底层的网络通信涉及到许多复杂的细节，如套接字的创建、连接的建立、数据的传输和接收等。通过封装，开发者可以使用更简单的接口来完成这些操作，无需关心底层的具体实现。
提高安全性：封装可以对网络通信的关键部分进行安全处理，例如对数据进行加密、验证等，防止数据在传输过程中被窃取或篡改。
增强可维护性和可扩展性：将网络通信的逻辑封装在独立的模块中，使得代码结构更加清晰，便于维护和扩展。当需要更改网络通信的实现方式时，只需修改封装模块的内部代码，而不会影响到使用该封装的其他部分。

👉二、套接字层封装

常见的封装层次
Java 的 java.net 包提供了基本的套接字（Socket）类，包括 Socket 和 ServerSocket，用于实现 TCP 通信，以及 DatagramSocket 用于实现 UDP 通信。这些类已经对底层的网络操作进行了一定程度的封装，但仍然需要开发者手动处理很多细节。例如，创建一个简单的 TCP 服务器：

代码如下：

package cn.ctg.common.util;

import java.io.IOException;
import java.net.HttpURLConnection;
import java.net.InetAddress;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;
import java.net.UnknownHostException;
import java.util.Map;

import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.util.StringUtils;
import org.springframework.web.client.RestTemplate;

import cn.hutool.core.collection.CollectionUtil;
import lombok.extern.slf4j.Slf4j;

/**
 * http请求
 */
@Slf4j
public class HttpUtils {

    public static String doGet(String url) {
        return doGet(url, null);
    }

    public static String doGet(String url, Map<String, String> map) {

        String resultString = "";
        RestTemplate client = new RestTemplate();
        HttpHeaders headers = new HttpHeaders();
        // 参数设置
        MultiValueMap<String, String> params = new LinkedMultiValueMap<String, String>();
        if (CollectionUtil.isNotEmpty(map)) {
            for (String key : map.keySet()) {
                params.add(key, map.get(key));
            }
        }

        try {

            // 设置表单提交
            headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED);
            HttpEntity<MultiValueMap<String, String>> requestEntity = new HttpEntity<MultiValueMap<String, String>>(
                    params, headers);
            // 执行HTTP请求
            ResponseEntity<String> response = client.exchange(url, HttpMethod.GET, requestEntity, String.class);
            resultString = response.getBody();
        } catch (Exception e) {
            log.error(e.getMessage(), e);
        }

        return resultString;

    }

    public static String doPost(String url) {
        return doPost(url, null);
    }

    public static String doPost(String url, Map<String, String> map) {

        String resultString = "";
        ResponseEntity<String> response = null;
        RestTemplate client = new RestTemplate();
        HttpHeaders headers = new HttpHeaders();
        // 参数设置
        MultiValueMap<String, String> params = new LinkedMultiValueMap<String, String>();
        if (CollectionUtil.isNotEmpty(map)) {
            for (String key : map.keySet()) {
                params.add(key, map.get(key));
            }
        }

        try {

            // 请勿轻易改变此提交方式，大部分的情况下，提交方式都是表单提交
            headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED);
            HttpEntity<MultiValueMap<String, String>> requestEntity = new HttpEntity<MultiValueMap<String, String>>(
                    params, headers);
            // 执行HTTP请求
            response = client.exchange(url, HttpMethod.POST, requestEntity, String.class);
            resultString = response.getBody();
        } catch (Exception e) {
            log.error(e.getMessage(), e);
        }
        return resultString;

    }

    public static String doPostJson(String url, String json) {

        String resultString = "";
        RestTemplate client = new RestTemplate();
        ResponseEntity<String> response = null;
        // 提交方式设置
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON);
        HttpEntity<String> requestEntity = new HttpEntity<String>(json, headers);
        try {
            // 执行HTTP请求
            response = client.exchange(url, HttpMethod.POST, requestEntity, String.class);
            resultString = response.getBody();

        } catch (Exception e) {
            log.error(e.getMessage(), e);
        } finally {
            try {

            } catch (Exception e) {
                // TODO Auto-generated catch block
                log.error(e.getMessage(), e);
            }
        }
        return resultString;

    }


    /**
     * 创建http请求头
     * @param url
     * @return
     * @throws Exception
     */
    public static URLConnection FactoryCreatURLConnection(String url) throws Exception {
        URL realUrl;
        URLConnection conn = null;
        try {
            // 打开和URL之间的连接
            realUrl = new URL(url);
            conn = realUrl.openConnection();
            conn.setRequestProperty("accept", "text/plain;charset=utf-8");
            conn.setRequestProperty("Content-Type", "application/x-www-form-urlencoded; charset=utf-8");
            conn.setRequestProperty("connection", "Keep-Alive");
            conn.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
        } catch (MalformedURLException e1) {
            e1.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return conn;
    }

    /**
     * 判断连接是否可用
     * 
     * @param url http请求地址
     * @return
     */
    public static boolean isRearchUrl(String url) {
        return isRearchUrl(url, 3000);
    }

    /**
     * 判断连接是否可用
     * 
     * @param url http请求地址
     * @return
     */
    public static boolean isRearchUrl(String url, int timeout) {

        if (StringUtils.isEmpty(url)) {
            return false;
        }
        HttpURLConnection connection = null;
        try {
            connection = (HttpURLConnection) new URL(url).openConnection();
            // 设置超时时间
            connection.setConnectTimeout(timeout);
            connection.setReadTimeout(timeout);
            if (connection.getResponseCode() >= HttpURLConnection.HTTP_OK
                    && connection.getResponseCode() <= HttpURLConnection.HTTP_VERSION) {
                return true;
            }
        } catch (Exception e) {
            log.error(" HttpURLConnection exception happend!");
            return false;
        } finally {
            if (connection != null) {
                connection.disconnect();
            }
        }
        return false;
    }

    /**
     * 判断ip是否能ping通
     */
    public static boolean checkIp(String ipAddr) {
        try {
            boolean status = false;
            if (!StringUtils.isEmpty(ipAddr)) {
                int timeOut = 3000; // 超时 3秒
                status = InetAddress.getByName(ipAddr).isReachable(timeOut);
                return status;
            }
            return status;
        } catch (UnknownHostException e) {
            e.printStackTrace();
            return false;
        } catch (IOException e) {
            e.printStackTrace();
            return false;
        }
    }


}

总结

  1. Java网络编程的封装原理主要体现在以下几个方面：
  2. 对Socket、URL、I/O等核心概念的抽象和封装。
  3. 提供高层次的API，隐藏底层细节。
  4. 支持多种协议（TCP、UDP、HTTP、SSL/TLS等）。
  5. 结合多线程和NIO实现高性能网络通信。
  6. 提供完善的异常处理机制。

通过这些封装，Java使得网络编程变得更加简单、高效和安全。

扩展
实现原理的核心要点：
分层架构
Java网络API基于分层设计，从底层到高级逐步抽象：

  1. 底层Socket API：java.net.Socket和ServerSocket直接操作TCP/IP协议。

  2. NIO（非阻塞IO）：java.nio包通过Channel、Buffer和Selector实现高性能非阻塞通信。

  3. 高级协议封装：如HttpURLConnection、HttpClient处理HTTP协议，隐藏报文解析细节。

  4. 框架级封装：如Netty、OkHttp通过事件驱动、异步回调等模式简化复杂网络编程。

核心设计模式

  1. 工厂模式：URL.openConnection()根据协议返回不同的URLConnection实现（如HTTP/HTTPS）。
  2. 装饰者模式：通过InputStream/OutputStream装饰类（如BufferedInputStream）增强IO功能。
  3. 责任链模式：Netty的ChannelPipeline通过处理器链处理网络事件。
  4. Reactor模式：NIO的Selector实现多路复用，非阻塞处理多个连接。

关键实现机制
(1). 连接管理
连接池：如HttpClient复用TCP连接，减少握手开销。
超时控制：通过setConnectTimeout()等方法设置连接/读取超时，底层依赖Socket的SO_TIMEOUT选项。
SSL/TLS封装：SSLSocketFactory和HttpsURLConnection透明处理加密握手和证书验证。
(2) 协议处理
HTTP报文解析：HttpClient自动处理Header解析、Cookie管理、重定向等。
数据序列化：如将对象转换为JSON/XML通过HTTP传输（需开发者实现或依赖库如Jackson）。
(3) 异步与事件驱动
NIO事件循环：Netty通过EventLoop监听Selector事件，触发回调。
CompletableFuture：Java 8+的异步API封装，简化回调地狱。

性能优化手段

  1. 零拷贝：NIO的FileChannel.transferTo()减少数据拷贝。

  2. 缓冲区复用：Netty的ByteBuf池减少内存分配开销。

  3. 线程模型：如Netty的主从多线程模型，分离连接接受和IO处理。

本次就这么多了，
请添加图片描述

👉壁纸分享

在这里插入图片描述

👉总结

本次总结的就是Java网络编程封装， 有需要会继续增加功能
如能帮助到你，就帮忙点个赞吧，三连更好哦,谢谢
你的点赞就是对博主的支持，有问题记得留言评论哦!
不定时更新Unity开发技巧，觉得有用记得一键三连哦。么么哒！

评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

心疼你的一切

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值