摘要：零前期准备版本版本核心依赖包支持包简介是官方出品的微服务框架，底层基于驱动，大致的使用套路和相差不是很多笔者只是浅浅的了解过，可能存在理解不透的情况。一配置中的配置类有两种，一种是用于读取配置文件的，另一种是用于配置服务器对象的。
零 前期准备 0 版本
JDK 版本 : OpenJDK 11.0.1
IDE : idea 2018.3
Helidon Webserver : helidon-webserver 1.0.0 (核心依赖包)
Helidon Json : helidon-media-jsonp-server 1.0.0 (json 支持包)
1 Helidon 简介Helidon 是 Oracle 官方出品的 java 微服务框架，底层基于 Netty 驱动，大致的使用套路和 Vertx 相差不是很多(笔者只是浅浅的了解过 Vertx，可能存在理解不透的情况)。在 2019 年的年初，Helidon 迎来了 1.0.0 的版本更新，api 开始趋于稳定。
就目前的版本来看，Oracle 应该希望 Helidon 是一个小而美的轻巧型 java 框架，所以对其的封装非常之薄，仅仅是对 Netty 做了一层定制化的处理，同时也深度整合了 jdk 的相关接口(毕竟是自家的东西，驾驭能力不一般)。就连 json 的处理都引用了 javax 中的 joup 去做，而不是使用第三方工具包。
Helidon 目前的网络资料很少，所以本文主要通过其官方文档进行 Demo 的构筑。
一 配置Helidon 中的配置类有两种，一种是用于读取配置文件的 Config，另一种是用于配置服务器对象的 ServerConfiguration。
先来看 Config：
//配置文件
Config conf = Config
//builder
.builder()
//载入配置文件，可以一次载入多张
.sources(
//根据绝对路径去载入配置文件
ConfigSources.file("D://application.yaml"),
//到 resource 文件夹下去寻找
ConfigSources.classpath("application2.yaml")
)
//创建完成
.build();
再来看 ServerConfiguration：
//创建一个配置对象，用于注入一些配置信息
ServerConfiguration config = ServerConfiguration
//生成 builder
.builder()
//address
//getLoopbackAddress() 会获取到 localhost
.bindAddress(InetAddress.getLoopbackAddress())
//getLocalHost() 会获取到本机的 ip
//.bindAddress(InetAddress.getLocalHost())
//端口
.port(8080)
//工作线程的线程数
.workersCount(10)
//增加一个 ServerConfiguration 对象
//.addSocket("serverConfiguration",ServerConfiguration.builder().build())
//载入配置文件
//.config(conf)
//创建完成
.build();
二 路由
网络博文最简单的 Hello World 的路由对象：
//创建最简单的路由逻辑
Routing rt = Routing
//builder
.builder()
//设置路由的请求方法和业务逻辑
//设置多种请求方法
.anyOf(List.of(Http.Method.GET, Http.Method.POST,Http.Method.DELETE),"/hello",(req, res) -> res.send("hello world"))
//单一请求方法
//.post("/hello",(req, res) -> res.send("hello world"))
//.get("/hello",(req, res) -> res.send("hello world"))
//创建完成
.build();
结合业务逻辑的路由对象：
//创建路由对象
Routing routing = Routing
//builder
.builder()
//注册 json 解析器
.register(JsonSupport.create())
//添加 url 路由，一个路由对象可以添加多个
//可以添加业务逻辑的 service 类
.post("/hello", Handler.create(JsonObject.class,new HelloService()))
//hello world
.get("/hello1",(req, res) -> res.send("hello world"))
//创建完成
.build();
HelloService 中处理具体的业务逻辑：
//HelloService 必须实现 Handler.EntityHandler
class HelloService implements Handler.EntityHandler{
//json 的解析门面对象
private static final JsonBuilderFactory jsonFactory = Json.createBuilderFactory(Collections.emptyMap());
//核心业务类，里面可以写具体的业务逻辑，最后 send(...) 进 response 里就可以了
@Override
public void accept(ServerRequest req, ServerResponse res, Object entity) {
//entity 本质上就是 JsonObject
JsonObject reqJson = (JsonObject)entity;
//获取键值对并打印，这个操作和 Fastjson 很类似
String ret = reqJson.getString("hello");
System.out.println(ret);
//创建要返回的 json object
JsonObject msg = jsonFactory
//builder
.createObjectBuilder()
//添加一组 json 的 key - value 键值对
.add("message", "Hello")
//创建 json 对象完成
.build();
//json array 的创建方式
//JsonArray array = jsonFactory.createArrayBuilder().build();
//返回
res.send(msg);
}
}
三 服务器对象
服务器对象：
//启动服务器
WebServer
//创建服务器对象
//具体依赖 ServerConfiguration 和 Routing 对象
.create(config,routing)
//开启服务器
.start()
//获取 future
.toCompletableFuture()
//设置超时时间为 10 秒
.get(10, TimeUnit.SECONDS);
四 服务实现
先来看 WebServer 的 create(...) 方法：
//step 1
//WebServer.class
static WebServer create(ServerConfiguration configuration, Routing routing) {
//有效性验证
Objects.requireNonNull(routing, "Parameter "routing" is null!");
//builder(...) 方法会创建一个 WebServer.Builder 对象，最终在 build() 方法里创建 WebServer
return builder(routing).config(configuration)
.build();
}
//step 2
//WebServer.Builder.class
public WebServer build() {
//routings 是一个 Map 对象，用来储存更多的路由对象
String unpairedRoutings = routings
.keySet()
.stream()
.filter(routingName -> configuration == null || configuration.socket(routingName) == null)
.collect(Collectors.joining(", "));
//有效性验证
if (!unpairedRoutings.isEmpty()) {
throw new IllegalStateException("No server socket configuration found for named routings: " + unpairedRoutings);
}
//NettyWebServer 是 WebServer 接口的实现类
//defaultRouting 是上方 create(...) 方法存入的路由对象
WebServer result = new NettyWebServer(configuration == null
? ServerBasicConfig.DEFAULT_CONFIGURATION
: configuration,
defaultRouting, routings);
//默认的路由对象即为 RequestRouting 类型
//此处给路由对象添加回调方法
if (defaultRouting instanceof RequestRouting) {
((RequestRouting) defaultRouting).fireNewWebServer(result);
}
//返回
return result;
}
//step 3
//NettyWebServer.class
NettyWebServer(ServerConfiguration config,
Routing routing,
Map namedRoutings) {
//获取所有的 SocketConfiguration 对象
//即为之前 addSocket(...) 方法存入的对象，也包括主配置对象自身
Set> sockets = config.sockets().entrySet();
//创建两个线程
this.bossGroup = new NioEventLoopGroup(sockets.size());
this.workerGroup = config.workersCount() <= 0 ? new NioEventLoopGroup() : new NioEventLoopGroup(config.workersCount());
this.configuration = config;
//循环所有的配置对象，然后分别创建 ServerBootstrap 对象并保存
for (Map.Entry entry : sockets) {
String name = entry.getKey();
SocketConfiguration soConfig = entry.getValue();
ServerBootstrap bootstrap = new ServerBootstrap();
JdkSslContext sslContext = null;
if (soConfig.ssl() != null) {
sslContext = new JdkSslContext(soConfig.ssl(), false, ClientAuth.NONE);
}
if (soConfig.backlog() > 0) {
bootstrap.option(ChannelOption.SO_BACKLOG, soConfig.backlog());
}
if (soConfig.timeoutMillis() > 0) {
bootstrap.option(ChannelOption.SO_TIMEOUT, soConfig.timeoutMillis());
}
if (soConfig.receiveBufferSize() > 0) {
bootstrap.option(ChannelOption.SO_RCVBUF, soConfig.receiveBufferSize());
}
//childHandler 是核心的业务 handler，使用者写的业务逻辑也都在里面
HttpInitializer childHandler = new HttpInitializer(sslContext, namedRoutings.getOrDefault(name, routing), this);
//储存 handler
initializers.add(childHandler);
//配置 Netty 的启动器对象
bootstrap.group(bossGroup, workerGroup)
.channel(NioServerSocketChannel.class)
.handler(new LoggingHandler(LogLevel.DEBUG))
.childHandler(childHandler);
//储存启动器
bootstraps.put(name, bootstrap);
}
}
NettyWebServer 中的构造器代码其实本质上就是半段 Netty 的启动模板代码。
主要是为了兼容多配置文件带来的多启动器需求，所以做了一个 for 循环。在多数时候其实就只有一个配置对象，也就只有一个启动器。
而另外半段 Netty 模板代码在 start(...) 方法中：
