投稿
  1. 极客之音首页
  2. 后端开发
  3. Java

Helidon微服务框架，轻装上阵，效率翻倍

服务端技术精选 • • Java • 阅读 54

今天换点别的框架聊聊吧，整天都是SpringBoot，太腻了。作为开发人员，多知道点东西，不会坏，就当扩展一下自己的技术视野吧！

请出今天的主角：Helidon

Helidon SE（Server Essential）是一个轻量级、高效的微服务框架，特别适用于需要高性能和低资源消耗的场景。

与Spingboot对比

那么，Helidon 跟 SpringBoot有什么不同呢？

特征
Helidon
Spring Boot
设计理念
轻量级、高性能、响应式编程、云原生友好、模块化
全面功能集、约定优于配置、企业级支持、广泛的生态系统
架构
微内核架构、响应式流、模块化设计、无头模式
分层架构、自动配置、Spring 生态系统、嵌入式服务器
特性
响应式编程、轻量级、模块化、云原生支持、无头模式、简化配置
自动配置、全面功能集、广泛集成、热部署、企业级支持、社区支持

总的来说，Helidon SE 更注重轻量级和高性能，而 Spring Boot 提供了全面的功能集和强大的生态系统。

应用场景

1. 微服务架构

  • 容器化部署: Helidon SE 适合在 Docker 容器中部署，支持 Kubernetes 等编排工具。
  • 服务网格集成: 可以与 Istio 等服务网格集成，提供流量管理、安全性和服务发现等功能。

2. 响应式编程

  • 高并发处理: 使用响应式编程模型（Reactive Streams），能够高效地处理大量并发请求。
  • 非阻塞 I/O: 提供非阻塞的 I/O 操作，减少线程开销，提高吞吐量。

3. 云原生应用

  • 无头模式: 支持无头模式（headless mode），适用于不需要传统 UI 的微服务。
  • 弹性伸缩: 由于其轻量级特性，更容易实现水平扩展。

4. API 网关

  • 路由和代理: 可以用作 API 网关，处理客户端请求并将它们路由到不同的后端服务。
  • 负载均衡: 内置负载均衡功能，可以分配流量到多个实例。

5. 边缘计算

  • 轻量级部署: 在资源受限的环境中（如边缘设备）部署微服务。
  • 实时数据处理: 处理和分析靠近数据源的数据，减少延迟。

6. 物联网 (IoT) 应用

  • 低功耗: 适用于需要长时间运行且电池供电的 IoT 设备。
  • 实时监控: 实时收集和处理传感器数据。

7. 移动后端服务

  • 快速开发: 快速构建 RESTful API 和 GraphQL 端点，支持移动应用的需求。
  • 跨平台兼容: 提供一致的服务接口，支持不同平台的移动应用。

8. 事件驱动架构

  • 消息传递: 使用消息队列（如 Kafka、RabbitMQ）与其他系统进行通信。
  • 事件处理: 处理异步事件，提高系统的响应性和可扩展性。

9. 嵌入式系统

  • 小型服务器: 适用于需要嵌入式服务器的应用程序。
  • 有限资源: 在内存和 CPU 资源有限的环境中运行。

10. DevOps 工具

  • 自动化任务: 构建 DevOps 工具和服务，如 CI/CD 流水线。
  • 监控和日志: 提供监控和日志记录功能，帮助运维团队管理和维护系统。

关注我，送Java福利

/**
 * 这段代码只有Java开发者才能看得懂！
 * 关注我微信公众号之后，
 * 发送:"666"，
 * 即可获得一本由Java大神一手面试经验诚意出品
 * 《Java开发者面试百宝书》Pdf电子书
 * 福利截止日期为2025年01月22日止
 * 手快有手慢没！！！
*/
System.out.println("请关注我的微信公众号：");
System.out.println("Java知识日历");

代码实操

现在我们搞一个 Helidon SE 通过注解驱动的方式快速构建微服务的简单例子感受一下。

项目结构

helidon-example/
├── pom.xml
└── src/
    └── main/
        ├── java/
        │   └── com/
        │       └── example/
        │           ├── Application.java          // 应用程序启动类
        │           ├── service/
        │           │   └── ItemService.java      // 业务逻辑服务
        │           └── resource/
        │               └── ItemResource.java     // RESTful 资源类
        └── resources/
            └── application.yaml                  // 配置文件

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>helidon-example</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
        <helidon.version>2.5.0</helidon.version>
    </properties>

    <dependencies>
        <!-- Helidon SE Dependencies -->
        <dependency>
            <groupId>io.helidon.webserver</groupId>
            <artifactId>helidon-webserver</artifactId>
            <version>${helidon.version}</version>
        </dependency>
        <dependency>
            <groupId>io.helidon.media</groupId>
            <artifactId>helidon-media-json-jackson</artifactId>
            <version>${helidon.version}</version>
        </dependency>
        <dependency>
            <groupId>io.helidon.common</groupId>
            <artifactId>helidon-common-config-yaml</artifactId>
            <version>${helidon.version}</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>3.2.4</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <transformers>
                                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                    <mainClass>com.example.Application</mainClass>
                                </transformer>
                            </transformers>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

application.yaml

server:
  port: 8080
  host: 0.0.0.0

logging:
  level:
    io.helidon: INFO

ItemService.java

package com.example.service;

import java.util.HashMap;
import java.util.Map;
import java.util.Optional;

publicclass ItemService {
    privatefinal Map<Long, String> items = new HashMap<>();
    privatelong currentId = 1L;

    public Optional<String> getItem(long id) {
        return Optional.ofNullable(items.get(id));
    }

    public Long addItem(String item) {
        items.put(currentId, item);
        return currentId++;
    }

    public boolean updateItem(long id, String item) {
        if (items.containsKey(id)) {
            items.put(id, item);
            returntrue;
        }
        returnfalse;
    }

    public boolean deleteItem(long id) {
        return items.remove(id) != null;
    }
}

ItemResource.java

package com.example.resource;

import com.example.service.ItemService;
import io.helidon.webserver.json.JsonSupport;

import javax.inject.Inject;
import javax.json.Json;
import javax.json.JsonArrayBuilder;
import javax.json.JsonObject;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;

@Path("/items")
@Produces(MediaType.APPLICATION_JSON)
publicclass ItemResource {

    privatefinal ItemService itemService;

    @Inject
    public ItemResource(ItemService itemService) {
        this.itemService = itemService;
    }

    @GET
    public JsonObject getAllItems() {
        JsonArrayBuilder arrayBuilder = Json.createArrayBuilder();
        itemService.getItems().forEach((id, item) -> 
            arrayBuilder.add(Json.createObjectBuilder()
                .add("id", id)
                .add("name", item))
        );
        return Json.createObjectBuilder()
                .add("items", arrayBuilder.build())
                .build();
    }

    @GET
    @Path("/{id}")
    public Response getItemById(@PathParam("id") long id) {
        return itemService.getItem(id)
                .map(item -> Response.ok(Json.createObjectBuilder()
                    .add("id", id)
                    .add("name", item)
                    .build()).build())
                .orElse(Response.status(Response.Status.NOT_FOUND).build());
    }

    @POST
    public Response addItem(String itemName) {
        long newItemId = itemService.addItem(itemName);
        return Response.created(UriBuilder.fromUri("/items/{id}").build(newItemId)).build();
    }

    @PUT
    @Path("/{id}")
    public Response updateItem(@PathParam("id") long id, String itemName) {
        if (itemService.updateItem(id, itemName)) {
            return Response.noContent().build();
        }
        return Response.status(Response.Status.NOT_FOUND).build();
    }

    @DELETE
    @Path("/{id}")
    public Response deleteItem(@PathParam("id") long id) {
        if (itemService.deleteItem(id)) {
            return Response.noContent().build();
        }
        return Response.status(Response.Status.NOT_FOUND).build();
    }
}

Application.java

package com.example;

import io.helidon.config.Config;
import io.helidon.webserver.Routing;
import io.helidon.webserver.Server;
import io.helidon.webserver.json.JsonSupport;

publicclass Application {

    public static void main(String[] args) {
        startServer();
    }

    public static Server startServer() {
        Config config = Config.create();

        ItemService itemService = new ItemService();
        ItemResource itemResource = new ItemResource(itemService);

        Routing routing = Routing.builder()
                .register(JsonSupport.create())
                .register(itemResource)
                .build();

        return Server.create(config.get("server"))
                .routing(routing)
                .start();
    }
}

运行项目

你可以通过 Maven 构建并运行该项目：

mvn clean package
java -jar target/helidon-example-1.0-SNAPSHOT.jar

访问接口

  • 获取所有物品: http://localhost:8080/items
  • 获取特定物品: http://localhost:8080/items/1
  • 添加新物品: POST /items 请求体: "New Item"
  • 更新物品: PUT /items/1 请求体: "Updated Item"
  • 删除物品: DELETE /items/1

注释说明

  1. ItemService.java:

    • 提供了基本的 CRUD 操作方法。
    • 使用 HashMap 来存储物品数据。

  2. ItemResource.java:

    • 使用 JAX-RS 注解 (@Path, @GET, @POST, @PUT, @DELETE) 来定义 RESTful 端点。
    • 使用 @Inject 注解注入 ItemService 实例。
    • 方法返回 Response 对象以处理不同的 HTTP 状态码和响应内容。

  3. Application.java:

    • 创建并启动 Helidon Web 服务器。
    • 使用 Routing 类注册 JSON 支持和资源类。
    • 从配置文件中读取服务器配置。

原文始发于微信公众号（Java知识日历）：Helidon微服务框架，轻装上阵，效率翻倍

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。

文章由极客之音整理，本文链接：https://www.bmabk.com/index.php/post/310628.html

赞 (0)
服务端技术精选的头像服务端技术精选
0 0

相关推荐

发表回复

登录后才能评论
极客之音——专业性很强的中文编程技术网站，欢迎收藏到浏览器，订阅我们！