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

文章目录

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 {@Overrideprotected 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();}}@Overrideprotected 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 {@GetMappingpublic 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 {@GetMappingpublic 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 {@GetMappingpublic 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;@Overridepublic Class<? extends TemplateModel> getModelClass() {return ApplicationModel.class;}public interface ApplicationModel extends TemplateModel {@ModelDescriptors.AsStringString 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 {@Overridepublic 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 {@Overridepublic 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 {@Overridepublic 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 {@Getpublic 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.RatpackServerRatpackServer.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.RatpackServerimport static ratpack.server.ServerBuilder.ratpack;ratpack { serverSpec ->serverSpec.handlers(chain -> chain.get({ ctx -> ctx.render("Hello, Ratpack!") }))
}.start()

10.3. 示例代码

import ratpack.server.RatpackServerimport static ratpack.server.ServerBuilder.ratpack;ratpack { serverSpec ->serverSpec.handlers(chain -> chain.get({ ctx -> ctx.render("Hello, Ratpack!") }))
}.start()