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

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

news 2025/11/11 6:35:48

文章目录

  • 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()

相关文章：

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

文章目录 JavaWeb中处理 Web 请求的方式总结1. 原始的 Servlet 方式1.1. 环境搭建**创建 Maven 或 Gradle 项目**&#xff1a;**添加 Servlet 依赖**&#xff1a;**创建 Servlet 类**&#xff1a;**配置项目**&#xff1a;**配置 Tomcat**&#xff1a; 1.2. 路由机制1.3. 示例代…...

编程日记 2024/9/11 7:04:17

React的事件与原生事件的执行顺序？

react自身实现了一套自己的事件机制&#xff0c;包括事件注册、事件的合成、事件冒泡、事件派发等&#xff0c;虽然和原生的是两码事&#xff0c;但也是基于浏览器的事件机制下完成的。 react 的所有事件并没有绑定到具体的dom节点上而是绑定在了document 上&#xff0c;然后由…...

编程日记 2024/9/11 7:03:16

【Java】Runtime与Properties获取系统信息

Java系列文章目录 补充内容 Windows通过SSH连接Linux 第一章 Linux基本命令的学习与Linux历史 文章目录 Java系列文章目录一、前言二、学习内容&#xff1a;三、问题描述四、解决方案&#xff1a;4.1 代码4.2 运行结果 五、总结&#xff1a; 一、前言 这些都被淘汰比较少用了…...

编程日记 2024/9/11 7:02:14

基于SpringBoot的社团管理系统

作者&#xff1a;计算机学姐 开发技术&#xff1a;SpringBoot、SSM、Vue、MySQL、JSP、ElementUI等&#xff0c;“文末源码”。 专栏推荐&#xff1a;前后端分离项目源码、SpringBoot项目源码、SSM项目源码 系统展示 基于JavaSpringBootVueMySQL的社团管理系统【附源码文档】、…...

编程日记 2024/9/11 7:01:12

UE5.3_跟一个插件—Socket.IO Client

网上看到这个插件，挺好！ 项目目前也没有忙到不可开交，索性跟着测一下吧： 商城可见，售价72.61人民币！ 但是，git上有仓库哦，免费！！ 跟着链接先准备起来： Documentation: GitHub - getnamo/SocketIOClient-Unreal: Socket.IO client plugin for the Unreal Engin…...

编程日记 2024/9/11 7:00:11

鸿蒙轻内核A核源码分析系列七 进程管理 (1)

往期知识点记录&#xff1a; 鸿蒙&#xff08;HarmonyOS&#xff09;应用层开发&#xff08;北向&#xff09;知识点汇总 轻内核A核源码分析系列一 数据结构-双向循环链表 轻内核A核源码分析系列二 数据结构-位图操作 轻内核A核源码分析系列三 物理内存&#xff08;1&#xff0…...

编程日记 2024/9/11 6:59:07

qt QGraphicsScene场景坐标和场景内GraphicsItem局部坐标的相互转换

为了更清晰地解释场景坐标与局部坐标之间的转换过程&#xff0c;我们可以通过一个简单的实例来演示如何赋值场景坐标&#xff0c;并将其转换为图形项的局部坐标。 实例步骤 假设我们有一个场景 QGraphicsScene 和一个矩形图形项 QGraphicsRectItem&#xff0c;矩形的大小为 1…...

编程日记 2024/9/11 6:50:54

Windows与linux中docker的安装与使用

windos中安装使用docker 下载Docker_Desktop 安装包进入docker官网下载Docker_Desktop&#xff1a; https://www.docker.com/启用wsl 我们搜索“启用或关闭Windows功能”&#xff0c;打开后勾选适用于Linux的Windows 子系统 Docker_Desktop设置 出现Docker Engine stopp…...

编程日记 2024/9/11 6:46:50

some electronic products

纽扣电池 button cell 运动手环 sports wristband 智能手环 smart bracelet 皮卡丘夜灯 pikachu night lamp 数字显示充电器 Charger with a digital display 磁吸无线充 magnetic wireless charger 直流电机调速器 DC motor speed controller 继电器模块 relay module 锂离子电…...

编程日记 2024/9/11 6:44:45

刘润《关键跃升》读书笔记7

沟通&#xff1a; 想明⽩&#xff0c;说清楚&#xff0c;能接受 团队沟通的正确⽅式可以⽤9个字来概括&#xff1a;想明⽩&#xff0c;说清楚&#xff0c;能接受 &#xff08;⻅图4-1&#xff09;想明⽩ 有时经理跟⼈沟通&#xff0c;讲完之后却⽆奈地对员⼯说&#xff0c;你怎…...

编程日记 2024/9/11 6:42:43

带参宏定义

#define WM_EVENT_DECLARE_GROUP(group) extern wm_event_group_t const group 宏定义的结构&#xff1a; #define&#xff1a;这是C语言中的预处理指令&#xff0c;用来定义宏。宏的作用是替换代码中的特定部分&#xff0c;类似于全局的文本替换。这里定义的宏名称是 WM_EVE…...

编程日记 2024/9/11 6:40:37

java流

99. ByteArrayOutputStream转化为ByteArrayInputStream ByteArrayOutputStream baos xxx;i new ByteArrayInputStream(baos.toByteArray())100.将inputstream转换为byte[] https://blog.csdn.net/yogima/article/details/128500056 100.1 方式一 直接使用IOUtils byte[] …...

编程日记 2024/9/11 6:37:33

Java ArrayList扩容机制 （源码解读）

结论&#xff1a;初始长度为10&#xff0c;若所需长度小于1.5倍原长度&#xff0c;则按照1.5倍扩容。若不够用则按照所需长度扩容。 一. 明确类内部重要变量含义 1&#xff1a;数组默认长度 2:这是一个共享的空数组实例&#xff0c;用于明确创建长度为0时的ArrayList &#xff…...

编程日记 2024/9/11 6:34:27

『功能项目』管理器基类【38】

我们打开上一篇37单例模式框架的项目&#xff0c; 本章要做的事情是编写管理器基类 首先创建脚本&#xff1a;ManagerBase.cs using UnityEngine; public abstract class ManagerBase : MonoBehaviour{public virtual void Init() { } } public class ManagerBase<T> : …...

编程日记 2024/9/11 6:33:26

Flex布局最后一行元素的对齐的解决方案

问题的产生 使用Flex布局&#xff0c;设置justify-content: space-between;让元素在主轴上两队对齐。 <div class"box"><div class"item">1</div><div class"item">2</div><div class"item">3&l…...

编程日记 2024/9/11 6:29:22

【ShuQiHere】上章：计算与计算机的基础概念

【ShuQiHere】✨ 在当今数字化社会&#xff0c;计算机已无处不在&#xff0c;从智能手机到人工智能应用&#xff0c;影响深远。然而&#xff0c;计算机并非一开始就如此强大。它经历了从手动工具、机械装置到电子计算机的演变。本章将回顾计算与算法的基本概念&#xff0c;探讨…...

编程日记 2024/9/11 6:28:21

前端框架有哪些？全面解析主流前端框架

一、React React 是由 Facebook 开发和维护的一个前端框架&#xff0c;它专注于构建用户界面。React 采用组件化的开发模式&#xff0c;允许开发者将用户界面拆分成多个可复用的组件。 主要特点 组件化: React 的核心是组件&#xff0c;它允许开发者将界面拆分成独立的、可复…...

编程日记 2024/9/11 6:27:20

4G MQTT网关在物联网应用中的优势-天拓四方

随着物联网&#xff08;IoT&#xff09;技术的飞速发展&#xff0c;各种设备和系统之间的互联互通变得日益重要。MQTT&#xff08;Message Queuing Telemetry Transport&#xff09;作为一种轻量级的发布/订阅消息传输协议&#xff0c;因其高效、可靠、简单的特性&#xff0c;在…...

编程日记 2024/9/11 6:25:18

【网上商城项目结构】

文章目录 前言一、网站前台二、运营商后台三、商家管理后台四、系统架构五、数据库设计六、关键技术总结 前言 网上商城项目结构通常包括网站前台、运营商后台和商家管理后台三个子系统&#xff0c;以及多个功能模块&#xff0c;如门户、搜索、购物车、订单、秒杀、个人中心等…...

编程日记 2024/9/11 6:24:16

VMware-Ubuntu Server安装教程

整理了B站和考拉软件上的信息 VMware安装 1.下载完成后&#xff0c;鼠标右击【VMware Workstation Pro 17.5.1】压缩包&#xff0c;选择【解压至此】 2.打开解压后的文件夹&#xff0c;鼠标右击【VMware17.5】选择【以管理员身份运行】 3.点击【下一步】 4.勾选【我接受许可协…...

编程日记 2024/9/11 6:23:12

Python爬虫实战：研究MechanicalSoup库相关技术

一、MechanicalSoup 库概述 1.1 库简介 MechanicalSoup 是一个 Python 库，专为自动化交互网站而设计。它结合了 requests 的 HTTP 请求能力和 BeautifulSoup 的 HTML 解析能力，提供了直观的 API，让我们可以像人类用户一样浏览网页、填写表单和提交请求。 1.2 主要功能特点…...

编程新知 2025/10/10 18:13:55

K8S认证|CKS题库+答案| 11. AppArmor

目录 11. AppArmor 免费获取并激活 CKA_v1.31_模拟系统 题目 开始操作&#xff1a; 1&#xff09;、切换集群 2&#xff09;、切换节点 3&#xff09;、切换到 apparmor 的目录 4&#xff09;、执行 apparmor 策略模块 5&#xff09;、修改 pod 文件 6&#xff09;、…...

编程新知 2025/11/7 20:13:34

mongodb源码分析session执行handleRequest命令find过程

mongo/transport/service_state_machine.cpp已经分析startSession创建ASIOSession过程&#xff0c;并且验证connection是否超过限制ASIOSession和connection是循环接受客户端命令&#xff0c;把数据流转换成Message&#xff0c;状态转变流程是&#xff1a;State::Created 》 St…...

编程新知 2025/8/16 7:00:37

vue3 字体颜色设置的多种方式

在Vue 3中设置字体颜色可以通过多种方式实现&#xff0c;这取决于你是想在组件内部直接设置&#xff0c;还是在CSS/SCSS/LESS等样式文件中定义。以下是几种常见的方法&#xff1a; 1. 内联样式 你可以直接在模板中使用style绑定来设置字体颜色。 <template><div :s…...

编程新知 2025/10/6 20:49:11

大模型多显卡多服务器并行计算方法与实践指南

一、分布式训练概述 大规模语言模型的训练通常需要分布式计算技术，以解决单机资源不足的问题。分布式训练主要分为两种模式： 数据并行：将数据分片到不同设备，每个设备拥有完整的模型副本 模型并行：将模型分割到不同设备，每个设备处理部分模型计算 现代大模型训练通常结合…...

编程新知 2025/11/4 22:16:08

Unit 1 深度强化学习简介

Deep RL Course ——Unit 1 Introduction 从理论和实践层面深入学习深度强化学习。学会使用知名的深度强化学习库&#xff0c;例如 Stable Baselines3、RL Baselines3 Zoo、Sample Factory 和 CleanRL。在独特的环境中训练智能体&#xff0c;比如 SnowballFight、Huggy the Do…...

编程新知 2025/9/18 1:39:03

算法笔记2

1.字符串拼接最好用StringBuilder&#xff0c;不用String 2.创建List<>类型的数组并创建内存 List arr[] new ArrayList[26]; Arrays.setAll(arr, i -> new ArrayList<>()); 3.去掉首尾空格...

编程新知 2025/11/7 20:30:32

rnn判断string中第一次出现a的下标

# coding:utf8 import torch import torch.nn as nn import numpy as np import random import json""" 基于pytorch的网络编写 实现一个RNN网络完成多分类任务 判断字符 a 第一次出现在字符串中的位置 """class TorchModel(nn.Module):def __in…...

编程新知 2025/9/24 16:25:00

VM虚拟机网络配置（ubuntu24桥接模式）：配置静态IP

编辑-虚拟网络编辑器-更改设置 选择桥接模式&#xff0c;然后找到相应的网卡&#xff08;可以查看自己本机的网络连接&#xff09; windows连接的网络点击查看属性 编辑虚拟机设置更改网络配置&#xff0c;选择刚才配置的桥接模式 静态ip设置&#xff1a; 我用的ubuntu24桌…...

编程新知 2025/11/7 6:57:34

【Nginx】使用 Nginx+Lua 实现基于 IP 的访问频率限制

使用 NginxLua 实现基于 IP 的访问频率限制 在高并发场景下&#xff0c;限制某个 IP 的访问频率是非常重要的&#xff0c;可以有效防止恶意攻击或错误配置导致的服务宕机。以下是一个详细的实现方案&#xff0c;使用 Nginx 和 Lua 脚本结合 Redis 来实现基于 IP 的访问频率限制…...

编程新知 2025/10/22 6:06:44