Java入门(7)--网络编程

news2024/11/4 22:09:47

Java网络编程:构建网络应用的基石 🌐

🎯 掌握Java网络编程,打造强大的网络应用!

在上一篇文章中,我们探讨了Java的I/O操作和反射机制。今天,让我们深入学习Java网络编程,了解如何构建网络应用程序! 💻

1. 网络编程基础 📡

Java提供了强大的网络编程API,支持各种网络协议和通信模式。让我们从基础概念开始学习。

1.1 网络基础概念

  • IP地址:网络设备的唯一标识
  • 端口号:应用程序的通信端点
  • 协议:通信规则(如TCP、UDP)
  • Socket:网络通信的端点
public class NetworkBasics {
    public static void main(String[] args) throws Exception {
        // 获取本机IP地址
        InetAddress localHost = InetAddress.getLocalHost();
        System.out.println("本机IP地址:" + localHost.getHostAddress());
        
        // 解析域名
        InetAddress github = InetAddress.getByName("github.com");
        System.out.println("GitHub IP地址:" + github.getHostAddress());
        
        // 检查主机可达性
        boolean reachable = github.isReachable(5000);
        System.out.println("GitHub是否可达:" + reachable);
    }
}

1.2 URL处理

public class URLExample {
    public static void main(String[] args) {
        try {
            URL url = new URL("https://api.github.com/users/octocat");
            
            // 获取URL信息
            System.out.println("协议:" + url.getProtocol());
            System.out.println("主机:" + url.getHost());
            System.out.println("端口:" + url.getPort());
            System.out.println("路径:" + url.getPath());
            
            // 读取URL内容
            try (BufferedReader reader = new BufferedReader(
                    new InputStreamReader(url.openStream()))) {
                String line;
                while ((line = reader.readLine()) != null) {
                    System.out.println(line);
                }
            }
            
        } catch (IOException e) {
            System.out.println("URL处理错误:" + e.getMessage());
        }
    }
}

2. Socket编程 🔌

Socket是网络编程的核心,让我们通过实例来学习TCP和UDP通信。

2.1 TCP通信示例

服务器端代码:

public class TCPServer {
    public static void main(String[] args) {
        try (ServerSocket serverSocket = new ServerSocket(8888)) {
            System.out.println("服务器启动,等待连接...");
            
            while (true) {
                Socket clientSocket = serverSocket.accept();
                System.out.println("客户端已连接:" + clientSocket.getInetAddress());
                
                // 处理客户端请求
                new Thread(() -> handleClient(clientSocket)).start();
            }
        } catch (IOException e) {
            System.out.println("服务器错误:" + e.getMessage());
        }
    }
    
    private static void handleClient(Socket clientSocket) {
        try (
            BufferedReader reader = new BufferedReader(
                new InputStreamReader(clientSocket.getInputStream()));
            PrintWriter writer = new PrintWriter(
                clientSocket.getOutputStream(), true)
        ) {
            String message;
            while ((message = reader.readLine()) != null) {
                System.out.println("收到消息:" + message);
                writer.println("服务器收到:" + message);
            }
        } catch (IOException e) {
            System.out.println("客户端处理错误:" + e.getMessage());
        }
    }
}

客户端代码:

public class TCPClient {
    public static void main(String[] args) {
        try (
            Socket socket = new Socket("localhost", 8888);
            BufferedReader reader = new BufferedReader(
                new InputStreamReader(socket.getInputStream()));
            PrintWriter writer = new PrintWriter(
                socket.getOutputStream(), true);
            BufferedReader consoleReader = new BufferedReader(
                new InputStreamReader(System.in))
        ) {
            System.out.println("已连接到服务器");
            
            String message;
            while ((message = consoleReader.readLine()) != null) {
                writer.println(message);
                System.out.println("服务器响应:" + reader.readLine());
            }
            
        } catch (IOException e) {
            System.out.println("客户端错误:" + e.getMessage());
        }
    }
}

2.2 UDP通信示例

服务器端代码:

public class UDPServer {
    public static void main(String[] args) {
        try (DatagramSocket socket = new DatagramSocket(9999)) {
            System.out.println("UDP服务器启动...");
            
            byte[] buffer = new byte[1024];
            while (true) {
                DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
                socket.receive(packet);
                
                String message = new String(
                    packet.getData(), 0, packet.getLength());
                System.out.println("收到消息:" + message);
                
                // 发送响应
                String response = "服务器收到:" + message;
                byte[] responseData = response.getBytes();
                DatagramPacket responsePacket = new DatagramPacket(
                    responseData,
                    responseData.length,
                    packet.getAddress(),
                    packet.getPort()
                );
                socket.send(responsePacket);
            }
        } catch (IOException e) {
            System.out.println("服务器错误:" + e.getMessage());
        }
    }
}

客户端代码:

public class UDPClient {
    public static void main(String[] args) {
        try (DatagramSocket socket = new DatagramSocket()) {
            InetAddress serverAddress = InetAddress.getByName("localhost");
            BufferedReader consoleReader = new BufferedReader(
                new InputStreamReader(System.in));
            
            while (true) {
                System.out.print("请输入消息:");
                String message = consoleReader.readLine();
                
                // 发送数据
                byte[] sendData = message.getBytes();
                DatagramPacket sendPacket = new DatagramPacket(
                    sendData,
                    sendData.length,
                    serverAddress,
                    9999
                );
                socket.send(sendPacket);
                
                // 接收响应
                byte[] receiveData = new byte[1024];
                DatagramPacket receivePacket = new DatagramPacket(
                    receiveData,
                    receiveData.length
                );
                socket.receive(receivePacket);
                
                String response = new String(
                    receivePacket.getData(),
                    0,
                    receivePacket.getLength()
                );
                System.out.println("服务器响应:" + response);
            }
        } catch (IOException e) {
            System.out.println("客户端错误:" + e.getMessage());
        }
    }
}

3. HTTP编程 🌍

3.1 HttpURLConnection示例

public class HttpExample {
    public static void main(String[] args) {
        try {
            URL url = new URL("https://api.github.com/users/octocat");
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            
            // 设置请求方法和头部
            conn.setRequestMethod("GET");
            conn.setRequestProperty("Accept", "application/json");
            
            // 获取响应码
            int responseCode = conn.getResponseCode();
            System.out.println("响应码:" + responseCode);
            
            // 读取响应内容
            try (BufferedReader reader = new BufferedReader(
                    new InputStreamReader(conn.getInputStream()))) {
                StringBuilder response = new StringBuilder();
                String line;
                
                while ((line = reader.readLine()) != null) {
                    response.append(line);
                }
                
                System.out.println("响应内容:" + response.toString());
            }
            
        } catch (IOException e) {
            System.out.println("HTTP请求错误:" + e.getMessage());
        }
    }
}

3.2 实用工具类

public class HttpClient {
    private static final int TIMEOUT = 5000;
    
    public static String get(String url) throws IOException {
        HttpURLConnection conn = null;
        try {
            URL urlObj = new URL(url);
            conn = (HttpURLConnection) urlObj.openConnection();
            conn.setRequestMethod("GET");
            conn.setConnectTimeout(TIMEOUT);
            conn.setReadTimeout(TIMEOUT);
            
            try (BufferedReader reader = new BufferedReader(
                    new InputStreamReader(conn.getInputStream()))) {
                StringBuilder response = new StringBuilder();
                String line;
                
                while ((line = reader.readLine()) != null) {
                    response.append(line);
                }
                
                return response.toString();
            }
        } finally {
            if (conn != null) {
                conn.disconnect();
            }
        }
    }
    
    public static String post(String url, String body) throws IOException {
        HttpURLConnection conn = null;
        try {
            URL urlObj = new URL(url);
            conn = (HttpURLConnection) urlObj.openConnection();
            conn.setRequestMethod("POST");
            conn.setConnectTimeout(TIMEOUT);
            conn.setReadTimeout(TIMEOUT);
            conn.setDoOutput(true);
            
            // 写入请求体
            try (OutputStream os = conn.getOutputStream()) {
                byte[] input = body.getBytes(StandardCharsets.UTF_8);
                os.write(input, 0, input.length);
            }
            
            // 读取响应
            try (BufferedReader reader = new BufferedReader(
                    new InputStreamReader(conn.getInputStream()))) {
                StringBuilder response = new StringBuilder();
                String line;
                
                while ((line = reader.readLine()) != null) {
                    response.append(line);
                }
                
                return response.toString();
            }
        } finally {
            if (conn != null) {
                conn.disconnect();
            }
        }
    }
}

4. 网络编程最佳实践 💡

  1. 连接管理:

    • 及时关闭网络连接
    • 使用连接池管理连接
    • 设置合适的超时时间
    • 处理断线重连
  2. 性能优化:

    • 使用NIO提升性能
    • 实现多线程处理
    • 使用缓冲区优化数据传输
    • 压缩传输数据
  3. 安全建议:

    • 使用SSL/TLS加密通信
    • 验证网络连接的合法性
    • 防止拒绝服务攻击
    • 保护敏感数据

5. 高级网络编程特性 🚀

5.1 NIO编程模型

NIO(New I/O)提供了更高效的网络编程模型,特别适合处理大量连接的场景。

public class NIOServer {
    public static void main(String[] args) throws IOException {
        // 创建选择器
        Selector selector = Selector.open();
        
        // 创建ServerSocketChannel
        ServerSocketChannel serverSocket = ServerSocketChannel.open();
        serverSocket.bind(new InetSocketAddress(8889));
        serverSocket.configureBlocking(false);
        
        // 注册到选择器
        serverSocket.register(selector, SelectionKey.OP_ACCEPT);
        
        System.out.println("NIO服务器启动在端口8889...");
        
        while (true) {
            selector.select();
            Set<SelectionKey> selectedKeys = selector.selectedKeys();
            Iterator<SelectionKey> iter = selectedKeys.iterator();
            
            while (iter.hasNext()) {
                SelectionKey key = iter.next();
                
                if (key.isAcceptable()) {
                    handleAccept(serverSocket, selector);
                }
                
                if (key.isReadable()) {
                    handleRead(key);
                }
                
                iter.remove();
            }
        }
    }
    
    private static void handleAccept(ServerSocketChannel serverSocket, 
                                   Selector selector) throws IOException {
        SocketChannel client = serverSocket.accept();
        client.configureBlocking(false);
        client.register(selector, SelectionKey.OP_READ);
        System.out.println("接受新的连接:" + client.getRemoteAddress());
    }
    
    private static void handleRead(SelectionKey key) throws IOException {
        SocketChannel client = (SocketChannel) key.channel();
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        int bytesRead = client.read(buffer);
        
        if (bytesRead == -1) {
            client.close();
            return;
        }
        
        buffer.flip();
        byte[] data = new byte[buffer.limit()];
        buffer.get(data);
        System.out.println("收到消息:" + new String(data));
    }
}

5.2 异步网络编程

Java 7引入的AIO(Asynchronous I/O)提供了真正的异步非阻塞I/O操作。

public class AsyncServer {
    public static void main(String[] args) throws IOException {
        AsynchronousServerSocketChannel server = 
            AsynchronousServerSocketChannel.open();
        server.bind(new InetSocketAddress(8890));
        
        server.accept(null, new CompletionHandler<AsynchronousSocketChannel,
                                                 Void>() {
            @Override
            public void completed(AsynchronousSocketChannel client, Void att) {
                // 继续接受下一个连接
                server.accept(null, this);
                
                ByteBuffer buffer = ByteBuffer.allocate(1024);
                client.read(buffer, buffer, new CompletionHandler<Integer,
                                                                ByteBuffer>() {
                    @Override
                    public void completed(Integer result, ByteBuffer attachment) {
                        attachment.flip();
                        byte[] data = new byte[attachment.limit()];
                        attachment.get(data);
                        System.out.println("异步收到:" + new String(data));
                    }
                    
                    @Override
                    public void failed(Throwable exc, ByteBuffer attachment) {
                        exc.printStackTrace();
                    }
                });
            }
            
            @Override
            public void failed(Throwable exc, Void att) {
                exc.printStackTrace();
            }
        });
        
        System.out.println("异步服务器启动在端口8890...");
        // 保持主线程运行
        System.in.read();
    }
}

6. 网络安全编程 🔒

6.1 SSL/TLS实现

安全套接字层(SSL)和传输层安全(TLS)是网络通信加密的标准。

public class SSLServer {
    public static void main(String[] args) {
        try {
            // 加载密钥库
            String keystorePath = "server.keystore";
            char[] keystorePass = "password".toCharArray();
            
            KeyStore ks = KeyStore.getInstance("JKS");
            ks.load(new FileInputStream(keystorePath), keystorePass);
            
            // 初始化密钥管理器
            KeyManagerFactory kmf = KeyManagerFactory.getInstance("SunX509");
            kmf.init(ks, keystorePass);
            
            // 配置SSL上下文
            SSLContext sslContext = SSLContext.getInstance("TLS");
            sslContext.init(kmf.getKeyManagers(), null, null);
            
            // 创建SSL服务器套接字
            SSLServerSocketFactory ssf = sslContext.getServerSocketFactory();
            SSLServerSocket serverSocket = 
                (SSLServerSocket) ssf.createServerSocket(8891);
            
            System.out.println("SSL服务器启动在端口8891...");
            
            while (true) {
                SSLSocket client = (SSLSocket) serverSocket.accept();
                handleSecureClient(client);
            }
            
        } catch (Exception e) {
            System.out.println("SSL服务器错误:" + e.getMessage());
        }
    }
}

6.2 实用工具类:安全数据传输

public class SecureNetworkUtils {
    // AES加密配置
    private static final String ALGORITHM = "AES";
    private static final int KEY_SIZE = 256;
    private static final String TRANSFORMATION = "AES/CBC/PKCS5Padding";
    
    /**
     * 生成AES密钥
     */
    public static SecretKey generateKey() throws NoSuchAlgorithmException {
        KeyGenerator keyGen = KeyGenerator.getInstance(ALGORITHM);
        keyGen.init(KEY_SIZE);
        return keyGen.generateKey();
    }
    
    /**
     * 加密数据
     */
    public static byte[] encrypt(String data, SecretKey key, IvParameterSpec iv) 
            throws Exception {
        Cipher cipher = Cipher.getInstance(TRANSFORMATION);
        cipher.init(Cipher.ENCRYPT_MODE, key, iv);
        return cipher.doFinal(data.getBytes());
    }
    
    /**
     * 解密数据
     */
    public static String decrypt(byte[] encryptedData, SecretKey key, 
                               IvParameterSpec iv) throws Exception {
        Cipher cipher = Cipher.getInstance(TRANSFORMATION);
        cipher.init(Cipher.DECRYPT_MODE, key, iv);
        byte[] decryptedData = cipher.doFinal(encryptedData);
        return new String(decryptedData);
    }
}

7. 网络编程设计模式 🎨

7.1 Reactor模式

public class Reactor implements Runnable {
    final Selector selector;
    final ServerSocketChannel serverSocket;

    Reactor(int port) throws IOException {
        selector = Selector.open();
        serverSocket = ServerSocketChannel.open();
        serverSocket.socket().bind(new InetSocketAddress(port));
        serverSocket.configureBlocking(false);
        SelectionKey sk = serverSocket.register(selector, SelectionKey.OP_ACCEPT);
        sk.attach(new Acceptor());
    }

    public void run() {
        try {
            while (!Thread.interrupted()) {
                selector.select();
                Set<SelectionKey> selected = selector.selectedKeys();
                Iterator<SelectionKey> it = selected.iterator();
                while (it.hasNext()) {
                    dispatch(it.next());
                    it.remove();
                }
            }
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }

    void dispatch(SelectionKey k) {
        Runnable r = (Runnable) (k.attachment());
        if (r != null) {
            r.run();
        }
    }
}

7.2 观察者模式在网络编程中的应用

public interface NetworkEventListener {
    void onConnected(String clientId);
    void onMessageReceived(String clientId, String message);
    void onDisconnected(String clientId);
}

public class NetworkEventManager {
    private List<NetworkEventListener> listeners = new ArrayList<>();
    
    public void addListener(NetworkEventListener listener) {
        listeners.add(listener);
    }
    
    public void removeListener(NetworkEventListener listener) {
        listeners.remove(listener);
    }
    
    protected void fireOnConnected(String clientId) {
        for (NetworkEventListener listener : listeners) {
            listener.onConnected(clientId);
        }
    }
    
    // ... 其他事件触发方法
}

8. 性能优化技巧 🚀

8.1 网络性能调优

  1. 缓冲区优化
// 使用直接缓冲区
ByteBuffer buffer = ByteBuffer.allocateDirect(65536);

// 使用合适的缓冲区大小
int bufferSize = socket.getReceiveBufferSize();
  1. 连接池管理
public class ConnectionPool {
    private static final int MAX_POOL_SIZE = 20;
    private Queue<Socket> pool = new ConcurrentLinkedQueue<>();
    
    public Socket acquire() {
        Socket socket = pool.poll();
        if (socket == null || socket.isClosed()) {
            socket = createNewConnection();
        }
        return socket;
    }
    
    public void release(Socket socket) {
        if (pool.size() < MAX_POOL_SIZE) {
            pool.offer(socket);
        } else {
            try {
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

9. 实战示例:高性能聊天服务器 💬

public class ChatServer {
    private static final int PORT = 8892;
    private final Map<String, SocketChannel> clients = new ConcurrentHashMap<>();
    private final Selector selector;
    
    public ChatServer() throws IOException {
        this.selector = Selector.open();
        ServerSocketChannel serverSocket = ServerSocketChannel.open();
        serverSocket.bind(new InetSocketAddress(PORT));
        serverSocket.configureBlocking(false);
        serverSocket.register(selector, SelectionKey.OP_ACCEPT);
    }
    
    public void start() {
        try {
            System.out.println("聊天服务器启动在端口 " + PORT);
            while (true) {
                selector.select();
                Set<SelectionKey> selectedKeys = selector.selectedKeys();
                Iterator<SelectionKey> iter = selectedKeys.iterator();
                
                while (iter.hasNext()) {
                    SelectionKey key = iter.next();
                    
                    if (key.isAcceptable()) {
                        handleNewConnection();
                    }
                    
                    if (key.isReadable()) {
                        handleMessage(key);
                    }
                    
                    iter.remove();
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    // ... 实现详细的处理方法
}

10. 写在最后 📝

咱们深入探讨了Java网络编程的高级特性和最佳实践,从基础的Socket编程到高级的NIO和安全编程,为构建强大的网络应用提供了全面的指导。

在未来的网络编程发展中,我们可以期待:

  1. 更高效的异步编程模型
  2. 更简单的响应式编程API
  3. 更强大的安全机制
  4. 更完善的云原生支持

学习资源推荐

  1. Java Network Programming, 4th Edition (O’Reilly)
  2. Netty in Action
  3. Java NIO (Ron Hitchens)

练习项目建议

  1. 实现一个支持多人的聊天室
  2. 开发一个简单的HTTP服务器
  3. 构建一个文件传输系统
  4. 设计一个基于WebSocket的实时通讯应用

记住:优秀的网络程序不仅要能正常工作,还要考虑性能、安全性和可维护性。持续学习和实践是提升网络编程能力的关键!

如果你觉得这篇文章有帮助,欢迎点赞转发,也期待在评论区看到你的想法和建议!👇

咱们下期见 !

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/2232117.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

最新PHP校园源码系统开发(多客社区校园系统源码全套APP源码附搭建教程)

最新PHP校园源码系统开发、多客社区校园系统源码以及全套APP源码附搭建教程的需求 一、最新PHP校园源码系统开发 技术栈选择&#xff1a; 后端&#xff1a;PHP&#xff08;建议使用PHP 7.2或更高版本&#xff09;数据库&#xff1a;MySQL&#xff08;建议使用MySQL 5.6或更高版…

Netty 组件介绍 - ByteBuf

直接内存&堆内存 ByteBuf buffer ByteBufAllocator.DEFAULT.heapBuffer(10);ByteBuf byteBuf ByteBufAllocator.DEFAULT.directBuffer(10); 组成 ByteBuf维护了两个不同的索引&#xff0c;一个用于读取&#xff0c;一个用于写入。 写入 内存回收 堆内存使用的是JVM内…

Java项目实战II基于Java+Spring Boot+MySQL的高校办公室行政事务管理系统(源码+数据库+文档)

目录 一、前言 二、技术介绍 三、系统实现 四、文档参考 五、核心代码 六、源码获取 全栈码农以及毕业设计实战开发&#xff0c;CSDN平台Java领域新星创作者&#xff0c;专注于大学生项目实战开发、讲解和毕业答疑辅导。获取源码联系方式请查看文末 一、前言 在高等教育…

word mathml 创建粗体字母快捷键

在 mathml 中达到latex中 \mathbf{A} 的效果 由于word本身不支持这个命令&#xff0c;所以打算用快捷键实现 快捷键的功能是加粗光标前一个字目 1. Alt F8 打开宏&#xff0c;如果打不开可以尝试 Alt Fn F8 2. 输入 BoldPreviousCharacter 新建宏&#xff1a; Sub Bold…

redis实现分布式锁,go实现完整code

Redis分布式锁 Redis 分布式锁是一种使用 Redis 数据库实现分布式锁的方式&#xff0c;可以保证在分布式环境中同一时间只有一个实例可以访问共享资源。 实现机制 以下是实现其加锁步骤&#xff1a; 获取锁 在 Redis 中&#xff0c;一个相同的key代表一把锁。是否拥有这把锁&…

flink 自定义kudu connector中使用Metrics计数平均吞吐量,并推送到自定义kafkaReporter

文章目录 前言1. Registering metrics2. Metrics 的类型2.1 counter2.2 Gauge2.3 Histogram2.4 meter 3. 指标划分3.1 指标所属的范围3.2 默认所属 4. 自定义kudu connector中使用Metrics4.1 sink算子继承RichFunction4.2 注册指标4.3 计数逻辑4.4 自定义Reporter&#xff0c;推…

柯桥日语培训|N1常考语法:~(よ)うが/(よ)うと——“无论……都……”

&#xff5e;&#xff08;よ&#xff09;うが&#xff0f;&#xff08;よ&#xff09;うと 接续&#xff1a;動意向形&#xff0f;イ形→かろう&#xff0f;名、ナ形→だろう・であろう&#xff0b;が&#xff0f;と 说明&#xff1a;表示假定条件的逆接&#xff0c;无论前项如…

一个基于Zookeeper+Dubbo3+SpringBoot3的完整微服务调用程序示例代码

一、关于 Dubbo3 的一些优化改进介绍 Dubbo3 的官方文档地址&#xff1a; https://cn.dubbo.apache.org/zh-cn/overview/what/overview/ 其针对一些问题进行了优化和改变。个人整理3个小的方面&#xff1a; 1. 在服务注册方面使用 DubboService 注解&#xff0c;不再使用 Servi…

电能表预付费系统-标准传输规范(STS)(33)

6.5.4.4 Key rotation process 按键旋转过程 The entire key is rotated one bit position to the left as illustrated in Figure 15.整个密钥向左旋转一个位&#xff0c;如图15所示。 6.5.4.5 Worked example to generate TokenData for a TransferCredit token using the S…

时序数据库是什么:概念、特点与分类简析

时序数据与时序数据库的“保姆级”科普&#xff01; 作为将数据价值转化为产能能效的“核心大脑”&#xff0c;数据库的发展依然处于加速期&#xff0c;面向不同数据类型的数据库类型也在不断增加。 在众多细分领域数据库类型中&#xff0c;伴随制造业数字化转型的行业趋势和多…

【创建型】单例模式

单例模式使用的场景&#xff1a;需要频繁的进行创建和销毁的对象、创建对象时耗时过多或耗费资源过多(即&#xff1a;重量级对象)&#xff0c;但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象(比如数据源、session工厂等) 1. 饿汉式&#xff08;静态常量&#xf…

6.0、静态路由

路由器最主要的功能就是转发数据包。路由器转发数据包时需要查找路由表&#xff08;你可以理解为地图&#xff09;&#xff0c;管理员可以直接手动配置路由表&#xff0c;这就是静态路由。 1.什么是路由&#xff1f; 在网络世界中&#xff0c;路由是指数据包在网络中的传输路…

工业通信网关的各项功能解析-天拓四方

在工业自动化和智能制造的浪潮中&#xff0c;工业通信网关作为连接工业现场与互联网的重要桥梁&#xff0c;发挥着至关重要的作用。它不仅实现了不同网络协议之间的转换&#xff0c;还在数据采集、设备控制、网络管理等方面展现出强大的功能。 一、协议转换功能 工业通信网关…

数据结构与算法——Java实现 53.力扣938题——二叉搜索树的范围和

生命的意义 在于活出自我 而不是成为别人眼中的你 —— 24.11.3 938. 二叉搜索树的范围和 给定二叉搜索树的根结点 root&#xff0c;返回值位于范围 [low, high] 之间的所有结点的值的和。 示例 1&#xff1a; 输入&#xff1a;root [10,5,15,3,7,null,18], low 7, high 15 …

TensorRT-LLM的k8s弹性伸缩部署方案

Scaling LLMs with NVIDIA Triton and NVIDIA TensorRT-LLM Using Kubernetes | NVIDIA Technical Blog 一共涉及4个k8s组件&#xff1a; 1. Deployment&#xff1a;跑起来N个pod&#xff1b;指定NVIDIA官方的triton&trt-llm的docker image&#xff0c;指定好model放在哪个…

高亮无惧烈日,强力巨彩租赁屏点亮户外“视”界

在户外显示领域&#xff0c;一款性能出色、适应性强、维护便捷的租赁屏无疑是众多主办方和广告商的首选。强力巨彩旗下的幻云系列租赁屏具备画面清晰、无水波纹、性能稳定、高亮度等诸多优势&#xff0c;可应用于各大户外显示场所&#xff0c;是户外租赁屏市场的明星产品。   …

批量删除redis数据【亲测可用】

文章目录 引言I redis客户端基础操作key的命名规则批量查询keyII 批量删除key使用连接工具进行分组shell脚本示例其他方法III 知识扩展:控制短信验证码获取频率引言 批量删除redis数据的应用: 例如缓存数据使用了新的key存储,需要删除废弃的key。RedisTemplate的key序列化采…

Mysql开发规范

开发规范 对象命名 命名规范的对象&#xff0c;是指数据库SCHEMA、表TABLE、字段COLUMN、索引INDEX、约束CONSTRAINTS等 【强制】凡是需要命名的对象&#xff0c;其标识符不能超过30个字符【强制】名称必须以英文字母开头&#xff0c;不得以 _(下划线) 作为起始和终止字母【…

Web应用性能测试工具 - httpstat

在数字化时代&#xff0c;网站的性能直接影响用户体验和业务成功。你是否曾经在浏览网页时&#xff0c;遇到加载缓慢的困扰&#xff1f;在这个快速变化的互联网环境中&#xff0c;如何快速诊断和优化Web应用的性能呢&#xff1f;今天&#xff0c;我们将探讨一个强大的工具——h…

(57)MATLAB使用迫零均衡器和MMSE均衡器的BPSK调制系统仿真

文章目录 前言一、仿真测试模型二、仿真代码三、仿真结果四、迫零均衡器和MMSE均衡器的实现1.均衡器的MATLAB实现2.均衡器的性能测试 总结 前言 本文给出仿真模型与MATLAB代码&#xff0c;分别使用具有ISI的三个不同传输特性的信道&#xff0c;仿真测试了使用迫零均衡器和MMSE…