当前位置：首页 > article >正文

JavaWeb中处理 Web 请求的方式总结

article 2025/1/10 2:20:44

文章目录

JavaWeb中处理 Web 请求的方式总结
1. 原始的 Servlet 方式
- 1.1. 环境搭建
- - **创建 Maven 或 Gradle 项目**：
  - **添加 Servlet 依赖**：
  - **创建 Servlet 类**：
  - **配置项目**：
  - **配置 Tomcat**：
- 1.2. 路由机制
- 1.3. 示例代码
2. Spring MVC
- 2.1. 环境搭建
- - **创建 Spring Boot 项目**：
  - **创建 Controller 类**：
  - **运行 Spring Boot 应用**：
- 2.2. 路由机制
- 2.3. 示例代码
3. Struts2
- 3.1. 环境搭建
- - **创建 Maven 项目**：
  - **配置项目**
  - **添加 Struts2 依赖**：
  - **创建 Struts2 配置文件**：
  - **配置web.xml**：
  - **创建 Action 类**：
  - **创建静态jsp文件**
  - **配置 Tomcat**：
  - **访问项目**：
- 3.2. 路由机制
- 3.3. 示例代码
4. JavaServer Faces (JSF)
- 4.1. 环境搭建
- - **创建 Maven 项目**：
  - **添加 JSF 依赖**：
  - **创建 Managed Bean 类**：
  - **创建 JSP 页面**：
  - **配置 Tomcat**：
- 4.2. 路由机制
- 4.3. 示例代码
5. Vaadin
- 5.1. 环境搭建
- - **创建 Maven 项目**：
  - **添加 Vaadin 依赖**：
  - **创建 Vaadin 应用类**：
  - **配置 Vaadin 应用**：
  - **运行 Vaadin 应用**：
- 5.2. 路由机制
- 5.3. 示例代码
6. Play Framework
- 6.1. 环境搭建
- - **创建 Play 项目**：
  - **修改 Routes 文件：**
  - **编写 Controller 类：**
  - **运行 Play 应用：**
- 6.2. 路由机制
- 6.3. 示例代码
7. Vert.x
- 7.1. 环境搭建
- - **创建 Vert.x 项目：**
  - **添加 Vert.x 依赖：**
  - **编写 Vert.x 应用：**
  - **运行 Vert.x 应用：**
- 7.2. 路由机制
- 7.3. 示例代码
8. Micronaut
- 8.1. 环境搭建
- - **创建 Micronaut 项目：**
  - **编写 Controller 类：**
  - **运行 Micronaut 应用：**
- 8.2. 路由机制
- 8.3. 示例代码
9. Quarkus
- 9.1. 环境搭建
- - **创建 Quarkus 项目：**
  - **修改 RESTful 接口类：**
  - **运行 Quarkus 应用：**
- 9.2. 路由机制
- 9.3. 示例代码
10. Ratpack
- 10.1. 环境搭建
- - **创建 Gradle 项目：**
  - **添加 Ratpack 依赖：**
  - **编写 Groovy 脚本：**
  - **运行 Ratpack 应用：**
- 10.2. 路由机制
- 10.3. 示例代码

JavaWeb中处理 Web 请求的方式总结

在 Java Web 开发中，处理 Web 请求的方式有很多种，涵盖了从原始的 Servlet 到各种现代框架的不同实现。

1. 原始的 Servlet 方式

Servlet 是 Java Web 开发的基础，它定义了处理 HTTP 请求的标准接口。

1.1. 环境搭建

工具: Apache Tomcat、Jetty、Undertow
配置: 在 web.xml 文件中配置 Servlet 映射
IDE: Eclipse、IntelliJ IDEA、NetBeans

创建 Maven 或 Gradle 项目：

打开 IntelliJ IDEA，选择 File > New > Project。
选择 Maven 或 Gradle，然后点击 Next。
填写项目的基本信息，如 Group ID 和 Artifact ID，然后点击 Create。

添加 Servlet 依赖：

在 pom.xml 文件中添加 Servlet API 依赖（如果使用的是 Java 8 及以上版本，Servlet API 已经包含在标准 Java 库中，无需单独添加）：

<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>4.0.1</version>
    <scope>provided</scope>
</dependency>

创建 Servlet 类：

创建一个新的 Java 类，继承 HttpServlet 类，并重写 doGet 和 doPost 方法。

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;

@WebServlet("/hello")
public class HelloServlet extends HttpServlet {
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.setContentType("text/html;charset=UTF-8");
        PrintWriter out = response.getWriter();
        try {
            out.println("<html><head><title>Hello Servlet</title></head>");
            out.println("<body>");
            out.println("<h1>Hello, Servlet!</h1>");
            out.println("</body></html>");
        } finally {
            out.close();
        }
    }
}

配置项目：

1）首先点击“File”-“Project Structure…”

2）点击“Modules”，选择对应Module之后，点击“+”，选择“Web”

3）添加完之后，会出现如下内容，点击右下角“Create Artifact”

4）添加完成之后，如下：

配置 Tomcat：

在 IntelliJ IDEA 中安装 Tomcat 插件或使用内置的 Tomcat 集成。
在 Run/Debug Configurations 中配置 Tomcat，指向项目的 webapp 目录。
运行 Tomcat 服务器。

1）点击项目中的“Edit Configurations…”

2）选择Tomcat Server - Local

3）点击右下角的“Fix”

4）会出现如下内容，也可以将Application context中的内容删掉，这样访问时不需要加项目目录，更简洁。

5）现在就可以运行项目了

1.2. 路由机制

Servlet Mapping: 在 web.xml 中使用 <servlet-mapping> 标签来配置 Servlet 的 URL 映射。
Annotation: 使用 @WebServlet 注解来配置 Servlet 的 URL 映射。

示例：

web.xml配置

<servlet>
    <servlet-name>HelloServlet</servlet-name>
    <servlet-class>com.example.HelloServlet</servlet-class>
</servlet>

<servlet-mapping>
    <servlet-name>HelloServlet</servlet-name>
    <url-pattern>/hello</url-pattern>
</servlet-mapping>

或者是java的Servlet类上添加@WebServlet 注解

@WebServlet("/hello")
public class HelloServlet extends HttpServlet {
    // ...
}

1.3. 示例代码

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;

@WebServlet("/hello")
public class HelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {
        String name = request.getParameter("name");
        response.setContentType("text/html;charset=utf8");
        response.setHeader("Hello",name);
        PrintWriter out = response.getWriter();
        try {
            out.println("<html><head><title>Hello Leyilea</title></head>");
            out.println("<body>");
            out.println("<h1>Hello, Leyilea!</h1>");
            out.println("<p>输入的name参数为："+name+"</p>");
            out.println("</body></html>");
        } finally {
            out.close();
        }
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        super.doPost(req, resp);
    }
}

2. Spring MVC

Spring MVC 是 Spring 框架的一部分，提供了声明式的 MVC 架构支持。

2.1. 环境搭建

工具: Spring Boot、Spring Framework
配置: 使用 @SpringBootApplication 注解启动 Spring Boot 应用，配置 application.properties 或 application.yml 文件。
IDE: Spring Tool Suite (STS)、IntelliJ IDEA

创建 Spring Boot 项目：

在 IntelliJ IDEA 中选择 File > New > Project。
选择 Spring Initializr，然后点击 Next。
填写项目的基本信息，选择 Web Starter 依赖，然后点击 Finish。

创建 Controller 类：

创建一个新的 Java 类，使用 @RestController 注解。

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/hello")
public class HelloController {

    @GetMapping
    public String hello() {
        return "Hello, Spring MVC!";
    }
}

运行 Spring Boot 应用：

在 main 方法所在的类上右键选择 Run ‘Application.main()’。

2.2. 路由机制

Controller: 使用 @Controller 或 @RestController 注解定义控制器类。
RequestMapping: 使用 @RequestMapping、@GetMapping、@PostMapping 等注解来配置路由。

示例：

@RestController
@RequestMapping("/hello")
public class HelloController {

    @GetMapping
    public String hello() {
        return "Hello, Spring MVC!";
    }
}

2.3. 示例代码

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/hello")
public class HelloController {

    @GetMapping
    public String hello() {
        return "Hello, Spring MVC!";
    }
}

3. Struts2

Struts2 是一个基于 Java 的 MVC 框架，使用 XML 或注解来配置路由。

3.1. 环境搭建

和原始的 Servlet 方式配置很相似。

工具: Apache Tomcat
配置: 编写 struts.xml 文件来配置 Struts2 框架。
IDE: IntelliJ IDEA、 Eclipse、NetBeans

创建 Maven 项目：

在 IntelliJ IDEA 中选择 File > New > Project。
选择 Maven，然后点击 Next。
填写项目的基本信息，然后点击 Finish。

配置项目

1）首先点击“File”-“Project Structure…”

2）点击“Modules”，选择对应Module之后，点击“+”，选择“Web”

3）添加完之后，会出现如下内容，点击右下角“Create Artifact”

4）添加完成之后，如下：

接下来创建的项目目录结构如下：

添加 Struts2 依赖：

在 pom.xml 文件中添加 Struts2 依赖：

注意版本兼容，否则报错很多…

    <dependencies>
        <dependency>
            <groupId>org.apache.struts</groupId>
            <artifactId>struts2-core</artifactId>
            <version>2.5.10</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>1.1.2</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.3</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>

创建 Struts2 配置文件：

在 src/main/resources 目录下创建 struts.xml 文件。

<!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
    "http://struts.apache.org/dtds/struts-2.3.dtd">

<struts>
    <package name="default" namespace="/" extends="struts-default">
        <action name="helloWorld" class="com.leyilea.HelloWorldAction">
            <result>/helloworld.jsp</result>
        </action>
    </package>
</struts>

配置web.xml：

在web/WEB-INF/web.xml文件中配置 Struts DispatcherServlet，拦截所有请求，转发给struts2。

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
         version="3.1">


    <!-- 配置 Struts DispatcherServlet -->
    <!--  拦截所有请求，转发给struts2-->
    <filter>
        <filter-name>struts2</filter-name>
        <filter-class>org.apache.struts2.dispatcher.filter.StrutsPrepareAndExecuteFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>struts2</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
</web-app>

创建 Action 类：

创建一个新的 Java 类HelloWorldAction，实现 Action 接口。

package com.leyilea;
import com.opensymphony.xwork2.Action;

public class HelloWorldAction implements Action {
    private String message;
    public String getMessage() {
        return message;
    }
    public void setMessage(String message) {
        this.message = message;
    }

    public String execute(){
        message = "Hello World!";
        return SUCCESS;
    }
}

创建静态jsp文件

index.jsp：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>首页</title>
</head>
<body>

<h3>首页</h3>
</body>
</html>

helloworld.jsp:

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>HelloWorld</title>
</head>
<body>

<h3>HelloWorld</h3>
<p><%= ((String)request.getAttribute("message")) %></p>

</body>
</html>

配置 Tomcat：

在 IntelliJ IDEA 中安装 Tomcat 插件或使用内置的 Tomcat 集成。
在 Run/Debug Configurations 中配置 Tomcat，指向项目的 webapp 目录。
运行 Tomcat 服务器。

1）点击项目中的“Edit Configurations…”

2）选择Tomcat Server - Local

3）点击右下角的“Fix”

4）会出现如下内容，也可以将Application context中的内容删掉，这样访问时不需要加项目目录，更简洁。

访问项目：

3.2. 路由机制

Action: 使用 XML 配置文件 struts.xml 来定义 <action> 标签。
Result: 使用 <result> 标签来配置 Action 的结果。

示例：

struts.xml

<package name="default" namespace="/">
    <action name="helloWorld" class="com.leyilea.HelloWorldAction">
        <result>/helloworld.jsp</result>
    </action>
</package>

java

package com.example;

import com.opensymphony.xwork2.ActionSupport;

public class HelloWorldAction extends ActionSupport {
    // ...
}

3.3. 示例代码

<package name="default" namespace="/">
    <action name="helloWorld" class="com.example.HelloWorldAction">
        <result>/index.jsp</result>
    </action>
</package>

package com.example;

import com.opensymphony.xwork2.ActionSupport;

public class HelloWorldAction extends ActionSupport {
    private String message;

    public String execute() throws Exception {
        message = "Hello World!";
        return SUCCESS;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
}

4. JavaServer Faces (JSF)

JSF 是一种基于组件的 MVC 框架，主要用于构建富客户端 Web 应用程序。

4.1. 环境搭建

工具: Apache Tomcat、GlassFish
配置: 使用 faces-config.xml 文件来配置 JSF 组件。
IDE: NetBeans、Eclipse

创建 Maven 项目：

在 IntelliJ IDEA 中选择 File > New > Project。
选择 Maven，然后点击 Next。
填写项目的基本信息，然后点击 Finish。

添加 JSF 依赖：

在 pom.xml 文件中添加 JSF 依赖：

<dependency>
    <groupId>javax.faces</groupId>
    <artifactId>javax.faces-api</artifactId>
    <version>2.2.13</version>
    <scope>provided</scope>
</dependency>
<dependency>
    <groupId>com.sun.faces</groupId>
    <artifactId>mojarra</artifactId>
    <version>2.2.13</version>
    <scope>runtime</scope>
</dependency>

创建 Managed Bean 类：

创建一个新的 Java 类，使用 @ManagedBean 注解。

import javax.faces.bean.ManagedBean;
import javax.faces.bean.SessionScoped;

@ManagedBean
@SessionScoped
public class HelloBean {
    private String message;

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public String sayHello() {
        message = "Hello, JSF!";
        return null;
    }
}

创建 JSP 页面：

在 src/main/webapp 目录下创建 index.xhtml 文件。

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:h="http://xmlns.jcp.org/jsf/html">
<h:head>
    <title>Hello JSF</title>
</h:head>
<h:body>
    <h:form>
        <h:commandButton value="Say Hello" action="#{helloBean.sayHello}" />
        <h:outputText value="#{helloBean.message}" />
    </h:form>
</h:body>
</html>

配置 Tomcat：

在 IntelliJ IDEA 中安装 Tomcat 插件或使用内置的 Tomcat 集成。
在 Run/Debug Configurations 中配置 Tomcat，指向项目的 webapp 目录。
运行 Tomcat 服务器。

4.2. 路由机制

Managed Bean: 使用 @ManagedBean 注解定义 Managed Beans。
Navigation Rule: 在 faces-config.xml 文件中定义导航规则。

示例：

xml

<navigation-rule>
    <from-view-id>/login.xhtml</from-view-id>
    <navigation-case>
        <from-outcome>success</from-outcome>
        <to-view-id>/welcome.xhtml</to-view-id>
    </navigation-case>
</navigation-rule>

java

@ManagedBean
@SessionScoped
public class LoginBean {
    // ...
}

4.3. 示例代码

import javax.faces.bean.ManagedBean;
import javax.faces.bean.SessionScoped;

@ManagedBean
@SessionScoped
public class HelloBean {
    private String message;

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public String sayHello() {
        message = "Hello, JSF!";
        return null;
    }
}

5. Vaadin

Vaadin 是一种用于构建 Web 应用程序的框架，支持构建富客户端应用。

5.1. 环境搭建

工具: Apache Tomcat
配置: 使用 Vaadin 库和 Maven 或 Gradle 构建工具。
IDE: IntelliJ IDEA、Eclipse

创建 Maven 项目：

在 IntelliJ IDEA 中选择 File > New > Project。
选择 Maven，然后点击 Next。
填写项目的基本信息，然后点击 Finish。

添加 Vaadin 依赖：

在 pom.xml 文件中添加 Vaadin 依赖：

<dependency>
    <groupId>com.vaadin</groupId>
    <artifactId>vaadin-bom</artifactId>
    <version>14.7.14</version>
    <type>pom</type>
    <scope>import</scope>
</dependency>

创建 Vaadin 应用类：

创建一个新的 Java 类，使用 @Route 注解。

import com.vaadin.flow.component.button.Button;
import com.vaadin.flow.component.notification.Notification;
import com.vaadin.flow.component.orderedlayout.VerticalLayout;
import com.vaadin.flow.router.Route;
import com.vaadin.flow.server.PWA;

@Route("")
@PWA(name = "Project Base", shortName = "Project Base PWA", offlineResources = { "images/app-icon.png" })
public class MainView extends VerticalLayout {

    public MainView() {
        Button button = new Button("Click me!", event -> Notification.show("Clicked!"));
        add(button);
    }
}

配置 Vaadin 应用：

在 src/main/java 目录下创建 Application.java 类。

import com.vaadin.flow.component.Component;
import com.vaadin.flow.component.Tag;
import com.vaadin.flow.component.dependency.JsModule;
import com.vaadin.flow.component.littemplate.LitTemplate;
import com.vaadin.flow.component.template.Id;
import com.vaadin.flow.component.uri.UriTemplate;
import com.vaadin.flow.di.HasModels;
import com.vaadin.flow.internal.nodefeature.ModelDescriptors;
import com.vaadin.flow.router.Route;
import com.vaadin.flow.templatemodel.TemplateModel;

@Tag("my-view")
@JsModule("./views/my-view.ts")
public class Application extends LitTemplate implements HasModels {

    @Id("foo")
    private Component foo;

    @Override
    public Class<? extends TemplateModel> getModelClass() {
        return ApplicationModel.class;
    }

    public interface ApplicationModel extends TemplateModel {
        @ModelDescriptors.AsString
        String getFoo();
    }

    public void setFoo(String foo) {
        ((ApplicationModel) getModel()).setFoo(foo);
    }
}

运行 Vaadin 应用：

在 main 方法所在的类上右键选择 Run 'Application.main()'。

5.2. 路由机制

Router: 使用 @Route 注解定义路由。
Component: 使用 Vaadin 组件来构建 UI。

示例：

@Route("")
public class MainView extends VerticalLayout {
    // ...
}

5.3. 示例代码

import com.vaadin.flow.component.button.Button;
import com.vaadin.flow.component.notification.Notification;
import com.vaadin.flow.component.orderedlayout.VerticalLayout;
import com.vaadin.flow.router.Route;
import com.vaadin.flow.server.PWA;

@Route("")
@PWA(name = "Project Base", shortName = "Project Base PWA", offlineResources = { "images/app-icon.png" })
public class MainView extends VerticalLayout {

    public MainView() {
        Button button = new Button("Click me!", event -> Notification.show("Clicked!"));
        add(button);
    }
}

6. Play Framework

Play 是一个轻量级的框架，支持 Java 和 Scala。

6.1. 环境搭建

工具: sbt（Scala Build Tool）
配置: 使用 Play 应用模板和 sbt 构建工具。
IDE: IntelliJ IDEA、Eclipse

创建 Play 项目：

打开终端，使用 Play CLI 创建新项目：
```
play new myproject
```
进入项目目录：
```
cd myproject
```
将项目导入到 IntelliJ IDEA 中：
- 在 IntelliJ IDEA 中选择 File > Import Project。
- 选择项目根目录并选择相应的 build.sbt 文件。
- 点击 OK 并等待项目加载完毕。

修改 Routes 文件：

在 conf/routes 文件中添加路由映射：

GET     /hello         controllers.HelloController.hello

编写 Controller 类：

创建一个新的 Java 类，继承 AbstractController 类。

例如，创建一个名为 HelloController 的类：

package controllers;

import play.mvc.Controller;
import play.mvc.Result;

public class HelloController extends Controller {

    public static Result hello() {
        return ok("Hello, Play Framework!");
    }
}

运行 Play 应用：

在 IntelliJ IDEA 中右键点击 Application 类并选择 Run 'Application'。
访问 http://localhost:9000/hello 来查看结果。

6.2. 路由机制

Routes File: 在 conf/routes 文件中定义路由。
Controller: 使用 Java 或 Scala 编写控制器类。

示例：

conf

GET     /hello      controllers.HelloController.index()

java

public class HelloController extends Controller {
    public Result index() {
        return ok("Hello, Play Framework!");
    }
}

6.3. 示例代码

import play.mvc.Controller;
import play.mvc.Result;

public class HelloController extends Controller {
    public Result index() {
        return ok("Hello, Play Framework!");
    }
}

7. Vert.x

Vert.x 是一个高性能的异步框架，支持多种语言，包括 Java。

7.1. 环境搭建

工具: Vert.x 库
配置: 使用 Vert.x 库和 Maven 或 Gradle 构建工具。
IDE: IntelliJ IDEA、Eclipse

创建 Vert.x 项目：

打开 IntelliJ IDEA，选择 File > New > Project。
选择 Gradle 或 Maven，然后点击 Next。
填写项目的基本信息，如 Group ID 和 Artifact ID，然后点击 Finish。

添加 Vert.x 依赖：

在 pom.xml 文件中添加 Vert.x 核心依赖：

<dependency>
    <groupId>io.vertx</groupId>
    <artifactId>vertx-core</artifactId>
    <version>4.3.1</version>
</dependency>

如果使用 Gradle，在 build.gradle 文件中添加：
```
implementation 'io.vertx:vertx-core:4.3.1'
```

编写 Vert.x 应用：

创建一个新的 Java 类，编写 Vert.x 应用代码。

例如，创建一个名为 HelloVerticle 的类：

import io.vertx.core.AbstractVerticle;
import io.vertx.core.DeploymentOptions;
import io.vertx.core.Vertx;
import io.vertx.core.http.HttpServer;
import io.vertx.core.http.HttpServerResponse;

public class HelloVerticle extends AbstractVerticle {

    @Override
    public void start() {
        HttpServer server = vertx.createHttpServer();
        server.requestHandler(req -> {
            if ("/hello".equals(req.uri())) {
                req.response()
                    .putHeader("content-type", "text/plain")
                    .end("Hello, Vert.x!");
            } else {
                req.response().setStatusCode(404).end();
            }
        }).listen(8080, result -> {
            if (result.succeeded()) {
                System.out.println("HTTP server started on port 8080");
            } else {
                System.err.println("Failed to start server: " + result.cause());
            }
        });
    }

    public static void main(String[] args) {
        Vertx vertx = Vertx.vertx();
        vertx.deployVerticle(new HelloVerticle());
    }
}

运行 Vert.x 应用：

在 IntelliJ IDEA 中右键点击 HelloVerticle 类并选择 Run 'HelloVerticle.main()'。
访问 http://localhost:8080/hello 来查看结果。

7.2. 路由机制

Router: 使用 Router 类来定义路由。
Handler: 使用 Handler 函数来处理请求。

示例：

import io.vertx.core.AbstractVerticle;
import io.vertx.ext.web.Router;
import io.vertx.ext.web.handler.StaticHandler;

public class MainVerticle extends AbstractVerticle {
    @Override
    public void start() {
        Router router = Router.router(vertx);

        router.get("/").handler(rc -> rc.response().end("Hello, Vert.x!"));

        vertx.createHttpServer().requestHandler(router::accept).listen(8080);
    }
}

7.3. 示例代码

import io.vertx.core.AbstractVerticle;
import io.vertx.ext.web.Router;
import io.vertx.ext.web.handler.StaticHandler;

public class MainVerticle extends AbstractVerticle {
    @Override
    public void start() {
        Router router = Router.router(vertx);

        router.get("/").handler(rc -> rc.response().end("Hello, Vert.x!"));

        vertx.createHttpServer().requestHandler(router::accept).listen(8080);
    }
}

8. Micronaut

Micronaut 是一个现代的微服务框架，支持 Java 和 Groovy。

8.1. 环境搭建

工具: Micronaut 库
配置: 使用 Micronaut 应用模板和 Gradle 构建工具。
IDE: IntelliJ IDEA、Eclipse

创建 Micronaut 项目：

打开终端，使用 Micronaut CLI 创建新项目：
```
mn create-app myproject
```
进入项目目录：
```
cd myproject
```
将项目导入到 IntelliJ IDEA 中：
- 在 IntelliJ IDEA 中选择 File > Import Project。
- 选择项目根目录并选择相应的 build.gradle 文件。
- 点击 OK 并等待项目加载完毕。

编写 Controller 类：

创建一个新的 Java 类，使用 Micronaut 注解。

例如，创建一个名为 HelloController 的类：

import io.micronaut.http.HttpResponse;
import io.micronaut.http.HttpStatus;
import io.micronaut.http.annotation.Controller;
import io.micronaut.http.annotation.Get;

@Controller("/hello")
public class HelloController {

    @Get
    public HttpResponse<String> hello() {
        return HttpResponse.ok("Hello, Micronaut!");
    }
}

运行 Micronaut 应用：

在 IntelliJ IDEA 中右键点击 Application 类并选择 Run 'Application'。
访问 http://localhost:8080/hello 来查看结果。

8.2. 路由机制

Controller: 使用 @Controller 注解定义控制器类。
RequestMapping: 使用 @GetMapping、@PostMapping 等注解来配置路由。

示例：

import io.micronaut.http.HttpResponse;
import io.micronaut.http.MediaType;
import io.micronaut.http.annotation.Controller;
import io.micronaut.http.annotation.Get;

@Controller("/hello")
public class HelloController {

    @Get(produces = MediaType.TEXT_PLAIN)
    public HttpResponse<String> index() {
        return HttpResponse.ok("Hello, Micronaut!");
    }
}

8.3. 示例代码

import io.micronaut.http.HttpResponse;
import io.micronaut.http.HttpStatus;
import io.micronaut.http.MediaType;
import io.micronaut.http.annotation.Controller;
import io.micronaut.http.annotation.Get;

@Controller("/hello")
public class HelloController {

    @Get(produces = MediaType.TEXT_PLAIN)
    public HttpResponse<String> index() {
        return HttpResponse.ok("Hello, Micronaut!");
    }
}

9. Quarkus

Quarkus 是一个现代的、高性能的 Java 框架，专为 Kubernetes 设计。

9.1. 环境搭建

工具: Quarkus 库
配置: 使用 Quarkus 应用模板和 Maven 构建工具。
IDE: IntelliJ IDEA、Eclipse

创建 Quarkus 项目：

打开终端，使用 Quarkus CLI 创建新项目：

mvn io.quarkus:quarkus-maven-plugin:1.13.7.Final:create \
  -DprojectName=myproject \
  -DclassName=com.example.HelloResource \
  -DresourceName=hello

进入项目目录：
```
cd myproject
```
将项目导入到 IntelliJ IDEA 中：
- 在 IntelliJ IDEA 中选择 File > Import Project。
- 选择项目根目录并选择相应的 pom.xml 文件。
- 点击 OK 并等待项目加载完毕。

修改 RESTful 接口类：

修改 src/main/java/com/example/HelloResource.java 文件

package com.example;

import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;

@Path("/hello")
public class HelloResource {

    @GET
    @Produces(MediaType.TEXT_PLAIN)
    public String hello() {
        return "Hello, Quarkus!";
    }
}

运行 Quarkus 应用：

在 IntelliJ IDEA 中右键点击 Application 类并选择 Run 'Application'。
访问 http://localhost:8081/hello 来查看结果。

9.2. 路由机制

RESTful Service: 使用 @Path 注解定义 RESTful 服务。
Method Mapping: 使用 @GET、@POST 等注解来配置路由。

示例：

import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;

@Path("/hello")
public class HelloResource {

    @GET
    @Produces(MediaType.TEXT_PLAIN)
    public String hello() {
        return "Hello, Quarkus!";
    }
}

9.3. 示例代码

import io.quarkus.runtime.QuarkusApplication;
import io.quarkus.runtime.annotations.QuarkusMain;

import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;

@Path("/hello")
public class HelloResource {

    @GET
    @Produces(MediaType.TEXT_PLAIN)
    public String hello() {
        return "Hello, Quarkus!";
    }
}

10. Ratpack

Ratpack 是一个高性能的异步 Java 框架。

10.1. 环境搭建

工具: Gradle 构建工具
配置: 使用 Ratpack 库和 Gradle 构建工具。
IDE: IntelliJ IDEA、Eclipse

创建 Gradle 项目：

打开 IntelliJ IDEA，选择 File > New > Project。
选择 Gradle，然后点击 Next。
填写项目的基本信息，如 Group ID 和 Artifact ID，然后点击 Finish。

添加 Ratpack 依赖：

在 build.gradle 文件中添加 Ratpack 核心依赖：

dependencies {
    compile 'io.ratpack:ratpack-groovy:1.6.0'
}

编写 Groovy 脚本：

创建一个新的 Groovy 类，使用 Ratpack 提供的方法。

例如，创建一个名为 Build.gradle 的类：

import ratpack.groovy.Groovy
import ratpack.groovy.handler.GroovyTemplate
import ratpack.server.RatpackServer

RatpackServer.start { serverSpec ->
    serverSpec.handlers(chain -> {
        chain.get("hello") { ctx ->
            ctx.render("Hello, Ratpack!")
        }
    })
}

运行 Ratpack 应用：

在 IntelliJ IDEA 中右键点击 Build.gradle 文件并选择 Run 'Build.gradle'。
访问 http://localhost:5050/hello 来查看结果。

10.2. 路由机制

Handler: 使用 get, post 等方法来定义路由。
Chain: 使用 chain 方法来处理请求。

示例：

import ratpack.server.RatpackServer

import static ratpack.server.ServerBuilder.ratpack;

ratpack { serverSpec ->
    serverSpec.handlers(chain -> chain.get({ ctx -> ctx.render("Hello, Ratpack!") }))
}.start()

10.3. 示例代码

import ratpack.server.RatpackServer

import static ratpack.server.ServerBuilder.ratpack;

ratpack { serverSpec ->
    serverSpec.handlers(chain -> chain.get({ ctx -> ctx.render("Hello, Ratpack!") }))
}.start()