简历技能之网络编程

今日目标

1. 完成Nettu

知识储备

1. 知道网络编程三要素：ip，协议，端口的含义和注意事项
2. 知悉查看本机ip地址的指令或操作
3. 知道字节流和字符流的区别

今日初始代码下载42kb

知识说明

BIO是一个连接一个线程。 NIO是一个请求一个线程。 AIO是一个有效请求一个线程。 先来个例子理解一下概念，以烧水为例： 同步就是普通水壶烧开水，要没事儿自己过来来看开没开； 异步就是响水壶烧开水，水开了水壶响了通知你。 阻塞是烧开水的过程中，你不能干其他事情（即你被阻塞住了）； 非阻塞是烧开水的过程里可以干其他事情。比如出去和老相好聊聊天，去客厅看看电视； 因此： 同步与异步说的是获得水开了的方式不同。 阻塞与非阻塞说的是得到结果之前能不能干其他事情,两组概念描述的是不同的内容。 好的办法:响水壶烧水（异步），烧开提示你之前可以去干别的事儿（非阻塞）

所以异步和非阻塞常常在一起

1.Java BIO入门

前言

Java BIO（Blocking I/O）是一种传统的I/O编程方式，它以阻塞模式进行I/O操作，即当一个线程执行I/O操作时，如果数据没有准备好，线程将会被阻塞，直到数据准备好为止。

• Java BIO 主要用于以下场景：

  • 网络编程：在传统的Socket编程中，使用BIO进行连接和数据传输。
  • 文件操作：对文件的读写操作通常也使用BIO。

• 优点：

  • 简单：BIO编程模型相对简单，容易理解和上手。
  • 兼容性：在一些老旧的系统和应用中，BIO仍然有用。

• 缺点：

  • 阻塞：BIO操作是阻塞的，一个阻塞的I/O操作可能会导致整个程序停滞。
  • 可扩展性：难以应对大量并发连接，每个连接需要一个线程，会消耗大量的系统资源。
  • 性能：由于阻塞导致的线程切换和资源消耗，性能较差。

Java BIO 与 Java NIO 和 Netty 等新一代I/O编程方式有以下区别：

• 阻塞 vs. 非阻塞：BIO是阻塞的，NIO和Netty是非阻塞的，可以处理大量并发连接。
• 单线程 vs. 多路复用：BIO通常使用一个线程处理一个连接，NIO和Netty支持多路复用机制，可以处理多个连接。
• 缓冲区 vs. 通道：NIO和Netty使用缓冲区（Buffer）和通道（Channel）来进行数据读写，BIO使用输入流和输出流。

代码操作

在BIO编程中，首先需要创建一个服务器套接字，以侦听客户端连接。以下是一个简单的BIO服务器示例：

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

public class BIOServer {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(8080);
        System.out.println("Server listening on port 8080...");

        while (true) {
            Socket clientSocket = serverSocket.accept(); // 阻塞等待客户端连接
            System.out.println("Client connected: " + clientSocket);

            // 处理客户端请求
            InputStream inputStream = clientSocket.getInputStream();
            byte[] buffer = new byte[1024];
            int bytesRead;
            while ((bytesRead = inputStream.read(buffer)) != -1) {
                String message = new String(buffer, 0, bytesRead);
                System.out.println("Received: " + message);
            }

            clientSocket.close();
        }
    }
}

客户端通常使用Socket套接字连接到服务器。以下是一个简单的BIO客户端示例：

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

public class BIOClient {
    public static void main(String[] args) throws IOException {
        Socket clientSocket = new Socket("localhost", 8080);
        System.out.println("Connected to server...");

        OutputStream outputStream = clientSocket.getOutputStream();
        String message = "Hello, BIO Server!";
        outputStream.write(message.getBytes());

        clientSocket.close();
    }
}

运行BIO服务器和客户端代码，可以模拟客户端与服务器之间的阻塞式通信。

性能测试和分析：使用工具来模拟多个客户端连接，并观察服务器的响应时间和资源消耗。

总结

Java BIO 是一种传统的I/O编程方式，采用阻塞模型，适用于一些简单的应用场景。然而，由于其阻塞特性和性能限制，在高并发和大规模应用中不适合使用。对于需要更高性能和可扩展性的应用，应考虑使用Java NIO或Netty等现代I/O编程方式。

2. Java NIO

前言

Java NIO（New I/O）是Java的一种新的I/O编程方式，它提供了非阻塞、高性能的I/O操作，适用于构建高并发的网络应用程序。

• Java NIO 主要用于以下场景：

  • 网络编程：Java NIO 可以用于实现高性能的网络服务器，支持大量并发连接。
  • 文件操作：NIO 提供了更灵活的文件读写方式，适用于大文件的处理。
  • 多路复用：NIO 支持多路复用机制，可以同时监控多个通道的事件，提高了I/O操作的效率。
  • 非阻塞操作：NIO 允许非阻塞式的I/O操作，提高了系统的响应性。

• 优点：

  • 高性能：NIO 提供了非阻塞的I/O操作，可以处理大量的并发连接。
  • 可扩展性：NIO 的多路复用机制允许监控多个通道，支持高并发。
  • 灵活性：NIO 提供了更灵活的文件读写方式和缓冲区操作。
  • 高级特性：NIO 支持通道、选择器、缓冲区等高级特性。

• 缺点：

  • 学习曲线：相对于传统的I/O编程，NIO 需要理解更多的概念和使用方式。

  • 复杂性：NIO 编程相对复杂，需要更多的编码工作。

Java NIO 与传统的I/O编程（阻塞I/O）有以下区别：

• 阻塞 vs. 非阻塞：传统I/O是阻塞的，而NIO是非阻塞的，允许多个通道并行操作。
• 通道 vs. 流：NIO 使用通道（Channel）来进行读写操作，而传统I/O 使用流（Stream）。
• 缓冲区 vs. 直接操作：NIO 使用缓冲区（Buffer）来管理数据，允许直接操作数据。
• 选择器 vs. 单线程：NIO 支持选择器（Selector），可以通过单线程监控多个通道的事件。

代码操作

首先，创建一个NIO的通道，可以是文件通道或网络通道。以下是一个创建文件通道的示例：

public class FileChannelExample {
    public static void main(String[] args) throws Exception {
        // 打开一个文件，获取文件通道
        RandomAccessFile file = new RandomAccessFile("example.txt", "rw");
        FileChannel channel = file.getChannel();

        // 创建一个字节缓冲区
        ByteBuffer buffer = ByteBuffer.allocate(1024);

        // 写入数据到缓冲区
        String data = "Hello, Java NIO!";
        buffer.clear(); // 清空缓冲区，准备写入数据
        buffer.put(data.getBytes(StandardCharsets.UTF_8));
        buffer.flip(); // 切换为读模式，准备读取数据

        // 将数据从缓冲区写入文件通道
        while (buffer.hasRemaining()) {
            channel.write(buffer);
        }

        // 从文件通道读取数据到缓冲区
        buffer.clear(); // 清空缓冲区，准备读取数据
        int bytesRead = channel.read(buffer);
        while (bytesRead != -1) {
            buffer.flip(); // 切换为读模式
            while (buffer.hasRemaining()) {
                System.out.print((char) buffer.get()); // 读取数据并输出
            }
            buffer.clear(); // 清空缓冲区，准备读取下一部分数据
            bytesRead = channel.read(buffer);
        }

        // 关闭文件通道
        channel.close();
    }
}

使用缓冲区（Buffer）来进行数据读写操作。以下是一个简单的读取数据的示例：

import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class ByteBufferExample {
    public static void main(String[] args) throws Exception {
        RandomAccessFile file = new RandomAccessFile("example.txt", "rw");
        FileChannel channel = file.getChannel();

        ByteBuffer buffer = ByteBuffer.allocate(1024);
        int bytesRead = channel.read(buffer);
        while (bytesRead != -1) {
            buffer.flip(); // 切换为读模式
            while (buffer.hasRemaining()) {
                System.out.print((char) buffer.get()); // 读取数据并输出
            }
            buffer.clear(); // 清空缓冲区
            bytesRead = channel.read(buffer);
        }

        channel.close();
    }
}

使用选择器（Selector）来实现多路复用。以下是一个使用选择器的示例：

import java.nio.channels.*;
import java.util.Iterator;
import java.util.Set;

public class SelectorExample {
    public static void main(String[] args) throws Exception {
        ServerSocketChannel serverChannel = ServerSocketChannel.open();
        serverChannel.socket().bind(new InetSocketAddress(8080));
        serverChannel.configureBlocking(false); // 设置为非阻塞

        Selector selector = Selector.open();
        serverChannel.register(selector, SelectionKey.OP_ACCEPT);

        while (true) {
            int readyChannels = selector.select();
            if (readyChannels == 0) continue;

            Set<SelectionKey> selectedKeys = selector.selectedKeys();
            Iterator<SelectionKey> keyIterator = selectedKeys.iterator();

            while (keyIterator.hasNext()) {
                SelectionKey key = keyIterator.next();

                if (key.isAcceptable()) {
                    // 处理连接请求
                } else if (key.isReadable()) {
                    // 处理读事件
                }

                keyIterator.remove();
            }
        }
    }
}

进行性能测试以确保系统的稳定性和性能。可以使用工具来模拟并发请求并监控系统的响应时间和资源使用情况。

总结

Java NIO 是一种非阻塞的I/O编程方式，适用于构建高性能、可扩展的网络应用程序和文件操作。它提供了通道、缓冲区、选择器等高级特性，可以提高系统的响应性和并发性。但需要注意学习曲线和复杂性，需要仔细理解相关概念和使用方式。

2. Netty入门

Netty 入门讲义

前言

Netty 是一个基于 Java 的异步事件驱动的网络应用程序框架，用于快速开发高性能的网络和服务器应用程序。它提供了一组强大的工具和组件，使网络编程变得更加容易和可扩展。

Netty 可以用于构建各种网络应用程序，包括通信协议、服务器、客户端，甚至是分布式系统。它的核心特性包括非阻塞、高性能、可扩展、灵活的事件模型和丰富的协议支持。

Netty 在许多场景下都有广泛的应用，例如：

实时通信服务器，如聊天应用和在线游戏。 高性能的网络代理和反向代理服务器。 分布式系统中的通信组件。 支持多种协议的服务器，如HTTP、WebSocket、TCP和UDP。 优点：

高性能：Netty 提供了异步非阻塞的事件模型，以及内置的高性能编解码器，使其在处理大量连接时表现出色。 可扩展性：Netty 的组件化和模块化架构使得容易扩展和定制。 协议支持：支持多种网络协议，包括 HTTP、WebSocket、TCP 和 UDP。 社区活跃：Netty 拥有一个活跃的社区，提供了丰富的文档和支持。 缺点：

学习曲线：对于初学者来说，可能需要一些时间来理解异步编程和事件驱动的概念。

自定义协议开发可能需要较多的工作。

Netty 与传统的 Java 网络编程和其他类似的框架相比具有以下区别：

异步和事件驱动：Netty 使用异步和事件驱动的编程模型，可以高效地处理大量并发连接。 高性能编解码器：Netty 提供了内置的高性能编解码器，支持多种协议，降低了开发人员的工作量。 可扩展性：Netty 的组件化和模块化架构使得容易扩展和定制。 多协议支持：Netty 支持多种网络协议，包括 HTTP、WebSocket、TCP 和 UDP。

Netty内存池原理

Netty的内存池是一种高效的内存管理机制，它可以减少内存分配和回收的开销，提高应用程序的性能。Netty的内存池采用了两种不同的内存分配策略：堆内存和直接内存。

堆内存是指Java虚拟机中的堆内存，它是由Java虚拟机自动管理的内存空间。Netty的堆内存池使用了一种称为“池化”的技术，它将一定数量的内存块预先分配好，并将它们存放在一个池中，当需要使用内存时，直接从池中取出一个内存块即可。当内存块不再使用时，将其归还给池，而不是立即释放内存。这样可以减少内存分配和回收的开销，提高应用程序的性能。

直接内存是指操作系统中的内存空间，它可以通过Java NIO的ByteBuffer类来访问。Netty的直接内存池使用了一种称为“零拷贝”的技术，它可以将数据直接从网络中读取到直接内存中，而不需要经过中间缓冲区的拷贝。这样可以减少数据拷贝的开销，提高应用程序的性能。

总之，Netty的内存池是一种高效的内存管理机制，它可以提高应用程序的性能，减少内存分配和回收的开销。

代码操作

首先，我们需要在项目中导入 Netty 的相关依赖。你可以使用 Maven 添加以下依赖：

<dependency>
    <groupId>io.netty</groupId>
    <artifactId>netty-all</artifactId>
    <version>4.1.68.Final</version> <!-- 替换为你的版本 -->
</dependency>

接下来，我们创建一个简单的 Netty 服务器。以下是服务器的示例代码：

public class NettyServerDemo {
    public static void main(String[] args) throws Exception {
        NioEventLoopGroup bossGroup = new NioEventLoopGroup();
        NioEventLoopGroup workerGroup = new NioEventLoopGroup();

        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.group(bossGroup, workerGroup)
                .channel(NioServerSocketChannel.class)
                .childHandler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel ch) throws Exception {
                        ChannelPipeline pipeline = ch.pipeline();
                        pipeline.addLast("decoder", new StringDecoder());
                        pipeline.addLast("encoder", new StringEncoder());
                        pipeline.addLast("handler", new NettyServerHandler());
                    }
                });

            ChannelFuture channelFuture = serverBootstrap.bind(8080).sync();
            channelFuture.channel().closeFuture().sync();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

然后，我们创建一个简单的服务器处理程序 NettyServerHandler。这个处理程序将处理从客户端接收到的消息，并回复响应。

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;

public class NettyServerHandler extends SimpleChannelInboundHandler<String> {
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
        System.out.println("Received message: " + msg);
        // 在服务器上回复客户端
        ctx.writeAndFlush("Server received: " + msg);
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}

最后，我们可以创建一个简单的 Netty 客户端。以下是客户端的示例代码：

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.Channel;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;

public class NettyClientDemo {
    public static void main(String[] args) throws Exception {
        EventLoopGroup group = new NioEventLoopGroup();

        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(group)
                .channel(NioSocketChannel.class)
                .handler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel ch) throws Exception {
                        ChannelPipeline pipeline = ch.pipeline();
                        pipeline.addLast("decoder", new StringDecoder());
                        pipeline.addLast("encoder", new StringEncoder());
                    }
                });

            Channel channel = bootstrap.connect("localhost", 8080).sync().channel();
            channel.writeAndFlush("Hello, Netty Server!");
        } finally {
            group.shutdownGracefully();
        }
    }
}

至此，你已经学会了如何使用 Netty 创建一个简单的服务器和客户端，实现消息传递。

总结

Java NIO（New I/O）和 Netty 都与网络编程有关，但它们之间存在一些重要的区别。以下是 Java NIO 和 Netty 的主要区别：

编程模型：

Java NIO：Java NIO 是 Java 标准库的一部分，提供了一种非阻塞、事件驱动的I/O编程模型。NIO 提供了通道（Channel）和缓冲区（Buffer）等抽象，程序员需要编写较低级的代码来处理I/O操作和事件。 Netty：Netty 是一个基于 Java 的高性能网络应用程序框架，构建在 Java NIO 之上。Netty 封装了复杂的NIO细节，提供了更高级别的抽象，使得网络编程更加简单和可扩展。 复杂性：

Java NIO：NIO编程相对较复杂，需要编写大量的低级代码，处理缓冲区的管理、事件监听和多路复用等细节。 Netty：Netty 简化了网络编程，提供了高级的组件和易于使用的API，使得编写网络应用程序更加容易。 性能：

Java NIO：NIO提供了非阻塞的I/O操作，相对于传统的阻塞I/O，可以更好地处理大量并发连接，但需要开发人员自行处理复杂性。 Netty：Netty 构建在Java NIO之上，进一步提高了性能和并发处理能力。它使用了高效的事件循环和线程池等技术，使得性能更加出色。 协议支持：

Java NIO：NIO本身是通用的，可以用于实现多种协议，但需要自行处理协议解析和编码。 Netty：Netty 提供了丰富的协议支持，包括 HTTP、WebSocket、TCP 和 UDP 等，内置了高性能的编解码器，使得开发者可以更容易地构建基于这些协议的应用程序。 社区和生态系统：

Java NIO：NIO是Java标准库的一部分，拥有庞大的用户群体，但没有像Netty那样活跃的社区和生态系统。 Netty：Netty 拥有一个活跃的社区和丰富的生态系统，提供了大量的文档、示例和插件，开发者可以更容易地找到支持和解决方案。 总之，Java NIO 是一种底层的、原生的非阻塞I/O编程模型，需要程序员编写较多的代码来处理I/O操作。而 Netty 是构建在Java NIO之上的高性能网络应用程序框架，提供了高级的抽象和易于使用的API，使得网络编程更加简单和高效。选择使用Java NIO还是Netty取决于项目需求、开发人员的经验以及性能要求。在大多数情况下，Netty是一个更好的选择，特别是在构建高性能的网络应用程序时。

当观察服务器的响应时间和资源消耗时，通常可以使用以下方法：

日志记录：输出日志是一种常见的观察手段。你可以在服务器代码中添加日志记录，记录请求到达时间、请求处理时间以及资源消耗等信息。使用一些常见的日志框架如Log4j、Slf4j、Logback等，将日志输出到文件或控制台。

性能分析工具：性能分析工具可以帮助你监控服务器的性能，包括响应时间、CPU和内存使用情况等。一些常见的性能分析工具包括VisualVM、JProfiler、YourKit等。这些工具可以提供详细的性能统计信息，并允许你进行性能分析和优化。

负载测试工具：负载测试工具如Apache JMeter、Gatling等可以模拟多个并发用户对服务器进行压力测试。通过观察服务器在不同负载下的响应时间和资源消耗，可以评估其性能。

操作系统工具：操作系统提供了一些工具来监控进程的资源消耗。例如，Linux下的top命令可以实时查看进程的CPU和内存使用情况。使用这些工具可以观察服务器的资源消耗情况。