昨晚睡不着拿着吃灰的书《手写Java虚拟机》看了两张，以前自己学cpp和go的时候都写过一些轮子（抄），Go写的类Gin的web框架，cpp当然是WebServer（烂大街），正好我有Go语言基础，这本书也是用的Go,现在又来写JVM了，这本书实现了一个基本的Java虚拟机，按照Java虚拟机8标准，可以运行Java字节码，依赖JDK类库。

记录一下第一节很简单，实现了一个命令行工具，类似Java -jar xxx.jar差不多的东西

以前写Web框架的时候用的是cobra这个库写的命令行工具，对于复杂的命令行工具很省事，这里直接用flag

下面是第一章的demo
```go
package main

import (
	"flag"
	"fmt"
	"os"
)

// Cmd 结构体用于存储命令行参数解析后的结果
type Cmd struct {
	helpFlag    bool
	versionFlag bool
	cpOption    string
	class       string
	args        []string
}

// parserCmd 解析命令行参数并返回 Cmd 结构体
func parserCmd() *Cmd {
	cmd := &Cmd{}

	// 设置自定义的 Usage 函数
	flag.Usage = printUsage

	// 定义命令行参数
	flag.BoolVar(&cmd.helpFlag, "help", false, "print help message")
	flag.BoolVar(&cmd.helpFlag, "?", false, "print help message")
	flag.BoolVar(&cmd.versionFlag, "version", false, "print version and exit")
	flag.StringVar(&cmd.cpOption, "classpath", "", "classpath")
	flag.StringVar(&cmd.cpOption, "cp", "", "classpath")

	// 解析命令行参数
	flag.Parse()

	// 获取解析后的参数
	args := flag.Args()

	if len(args) > 0 {
		cmd.class = args[0]
		cmd.args = args[1:]
	}
	return cmd
}

// printUsage 打印使用说明
func printUsage() {
	fmt.Printf("Usage: %s [-options] class [args...]\n", os.Args[0])
}

func main() {
	// 解析命令行参数
	cmd := parserCmd()

	// 根据解析结果执行相应的操作
	if cmd.versionFlag {
		fmt.Println("version 0.0.1")
	} else if cmd.helpFlag || cmd.class == "" {
		printUsage()
	} else {
		startJVM(cmd)
	}
}

// startJVM 模拟启动JVM的函数
func startJVM(cmd *Cmd) {
	fmt.Printf("classpath:%s class:%s args:%v\n", cmd.cpOption, cmd.class, cmd.args)
}
```


![image.png](/static/img/6946fa2f68b038cbb0bf2befa756ecf3.image.webp)


第一张就这样

手写JVM

有的时候很想找几本书看，还有以前在群里找的pdf书籍但是可能遗落在Ipad或者电脑各种各样的设备上，很久就像写个简单的能存储文件的网站并在线浏览，只我一个人用，这样就没时间就上传一下就好了，前段时间研究了一下，文件预览方案整合挺麻烦而且用不上，所以整了个简单的，但是我很喜欢


![image.png](/static/img/2d2704c141ab2d17509d65edf79ca396.image.webp)

界面有点丑，到时候改一下

![image.png](/static/img/b17c90c2101b37c0466d11145cd41c6f.image.webp)

![image.png](/static/img/da763797b56990591c2a3bedb5a4d38e.image.webp)



自己写了个存资源的网站

netty

SPDY（读作"speedy"）是一个由谷歌开发的开放网络传输协议，旨在通过减少网页加载时间来加速网络通信。它最初在2009年被提出，并在2012年首次公开发布。SPDY设计用于减少网页内容加载的延迟，通过多路复用流、优先级排序、服务器推送等技术手段，提高网络传输效率。

SPDY并不是http的替代协议，而是对http1.1的补充升级，现已被http2替代。

在netty中依然提供了对SPDY协议的支持

如下：

```java
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.spdy.SpdyFrameCodec;
import io.netty.handler.codec.spdy.SpdyHttpDecoder;
import io.netty.handler.codec.spdy.SpdyHttpEncoder;
import io.netty.handler.codec.spdy.SpdySessionHandler;
import io.netty.handler.ssl.ApplicationProtocolConfig;
import io.netty.handler.ssl.ApplicationProtocolNames;
import io.netty.handler.ssl.SslContext;
import io.netty.handler.ssl.SslContextBuilder;
import io.netty.handler.ssl.util.SelfSignedCertificate;

import javax.net.ssl.SSLException;
import java.security.cert.CertificateException;

public class SpdyServer {
    static final int PORT = Integer.parseInt(System.getProperty("port", "8443"));

    public static void main(String[] args) throws CertificateException, SSLException, InterruptedException {
        // 使用自签名证书
        SelfSignedCertificate ssc = new SelfSignedCertificate();
        SslContext sslCtx = SslContextBuilder.forServer(ssc.certificate(), ssc.privateKey())
                .applicationProtocolConfig(new ApplicationProtocolConfig(
                        ApplicationProtocolConfig.Protocol.NPN,
                        ApplicationProtocolConfig.SelectorFailureBehavior.NO_ADVERTISE,
                        ApplicationProtocolConfig.SelectedListenerFailureBehavior.ACCEPT,
                        ApplicationProtocolNames.SPDY_3_1))
                .build();

        NioEventLoopGroup bossGroup = new NioEventLoopGroup();
        NioEventLoopGroup workerGroup = new NioEventLoopGroup();

        try {
            ServerBootstrap b = new ServerBootstrap();
            b.group(bossGroup, workerGroup)
             .channel(NioServerSocketChannel.class)
             .childHandler(new ChannelInitializer<SocketChannel>() {
                 @Override
                 protected void initChannel(SocketChannel ch) {
                     ChannelPipeline pipeline = ch.pipeline();
                     pipeline.addLast(sslCtx.newHandler(ch.alloc()));
                     pipeline.addLast(new SpdyFrameCodec(SpdyVersion.SPDY_3_1));
                     pipeline.addLast(new SpdySessionHandler(SpdyVersion.SPDY_3_1, true));
                     pipeline.addLast(new SpdyHttpDecoder(SpdyVersion.SPDY_3_1, 8192));
                     pipeline.addLast(new SpdyHttpEncoder(SpdyVersion.SPDY_3_1));
                     pipeline.addLast(new SpdyServerHandler());
                 }
             });

            b.bind(PORT).sync().channel().closeFuture().sync();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.handler.codec.spdy.SpdyHttpResponseStreamIdHandler;
import io.netty.handler.codec.spdy.SpdySessionHandler;
import io.netty.handler.codec.spdy.SpdyStreamFrame;

public class SpdyServerHandler extends SimpleChannelInboundHandler<SpdyStreamFrame> {
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, SpdyStreamFrame msg) throws Exception {
        System.out.println("Received SPDY frame: " + msg);
        ctx.writeAndFlush("Hello, SPDY");
    }

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

```

spdy协议

BotServer
```java
package org.example.demo2.server;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
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.NioServerSocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;

public class BotServer {

    private final int port;

    public BotServer(int port) {
        this.port = port;
    }

    public void start() throws InterruptedException {
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap b = new ServerBootstrap();
            b.group(bossGroup, workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        public void initChannel(SocketChannel ch) throws Exception {
                            ChannelPipeline p = ch.pipeline();
                            p.addLast(new StringDecoder());
                            p.addLast(new StringEncoder());
                            p.addLast(new BotServerHandler());
                        }
                    });

            ChannelFuture f = b.bind(port).sync();
            System.out.println("BotServer started on port " + port);

            f.channel().closeFuture().sync();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        int port = 8080;
        new BotServer(port).start();
    }
}




package org.example.demo2.server;

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

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

public class BotServerHandler extends SimpleChannelInboundHandler<String> {

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
        String response;
        switch (msg.trim()) {
            case "现在几点了？":
                response = "现在是：" + LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
                break;
            case "你叫什么名字？":
                response = "我叫 BotServer";
                break;
            case "今天过的开心吗？":
                response = "我是一个机器人，没有情感，所以无所谓开心不开心";
                break;
            default:
                response = "我不明白你的问题";
                break;
        }
        ctx.writeAndFlush(response);
    }

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

```
BotClinet

```java
package org.example.demo2.client;

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
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;

import java.util.Scanner;

public class BotClient {

    private final String host;
    private final int port;

    public BotClient(String host, int port) {
        this.host = host;
        this.port = port;
    }

    public void start() throws InterruptedException {
        EventLoopGroup group = new NioEventLoopGroup();
        try {
            Bootstrap b = new Bootstrap();
            b.group(group)
                    .channel(NioSocketChannel.class)
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        public void initChannel(SocketChannel ch) throws Exception {
                            ChannelPipeline p = ch.pipeline();
                            p.addLast(new StringDecoder());
                            p.addLast(new StringEncoder());
                            p.addLast(new BotClientHandler());
                        }
                    });

            ChannelFuture f = b.connect(host, port).sync();
            System.out.println("BotClient connected to " + host + ":" + port);

            Channel channel = f.channel();
            Scanner scanner = new Scanner(System.in);
            while (true) {
                System.out.print("Enter message: ");
                String message = scanner.nextLine();
                if ("exit".equalsIgnoreCase(message)) {
                    break;
                }
                channel.writeAndFlush(message);
            }

            channel.closeFuture().sync();
        } finally {
            group.shutdownGracefully();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        String host = "localhost";
        int port = 8080;
        new BotClient(host, port).start();
    }
}


package org.example.demo2.client;

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

public class BotClientHandler extends SimpleChannelInboundHandler<String> {


    @Override
    protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
        System.out.println("Server response: " + msg);
    }

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

```

