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

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

news 2025/7/12 15:25:20

文章目录

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 项目**：**添加 Servlet 依赖**：**创建 Servlet 类**：**配置项目**：**配置 Tomcat**： 1.2. 路由机制1.3. 示例代…...

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

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

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

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

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

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

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

基于SpringBoot的社团管理系统

作者：计算机学姐开发技术：SpringBoot、SSM、Vue、MySQL、JSP、ElementUI等，“文末源码”。专栏推荐：前后端分离项目源码、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)

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

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

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

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

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

Windows与linux中docker的安装与使用

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

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

纽扣电池 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

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

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

带参宏定义

#define WM_EVENT_DECLARE_GROUP(group) extern wm_event_group_t const group 宏定义的结构： #define：这是C语言中的预处理指令，用来定义宏。宏的作用是替换代码中的特定部分，类似于全局的文本替换。这里定义的宏名称是 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扩容机制（源码解读）

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

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

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

我们打开上一篇37单例模式框架的项目， 本章要做的事情是编写管理器基类首先创建脚本：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布局，设置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】✨ 在当今数字化社会，计算机已无处不在，从智能手机到人工智能应用，影响深远。然而，计算机并非一开始就如此强大。它经历了从手动工具、机械装置到电子计算机的演变。本章将回顾计算与算法的基本概念，探讨…...

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

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

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

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

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

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

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

【网上商城项目结构】

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

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

VMware-Ubuntu Server安装教程

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

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

生成xcframework

打包 XCFramework 的方法 XCFramework 是苹果推出的一种多平台二进制分发格式，可以包含多个架构和平台的代码。打包 XCFramework 通常用于分发库或框架。使用 Xcode 命令行工具打包通过 xcodebuild 命令可以打包 XCFramework。确保项目已经配置好需要支持的平台…...

编程新知 2025/7/8 18:20:22

day52 ResNet18 CBAM

在深度学习的旅程中，我们不断探索如何提升模型的性能。今天，我将分享我在 ResNet18 模型中插入 CBAM（Convolutional Block Attention Module）模块，并采用分阶段微调策略的实践过程。通过这个过程，我不仅提升…...

编程新知 2025/7/11 20:41:37

中南大学无人机智能体的全面评估！BEDI：用于评估无人机上具身智能体的综合性基准测试

作者：Mingning Guo, Mengwei Wu, Jiarun He, Shaoxian Li, Haifeng Li, Chao Tao单位：中南大学地球科学与信息物理学院论文标题：BEDI: A Comprehensive Benchmark for Evaluating Embodied Agents on UAVs论文链接：https://arxiv.…...

编程新知 2025/7/11 8:40:45

相机Camera日志实例分析之二：相机Camx【专业模式开启直方图拍照】单帧流程日志详解

【关注我，后续持续新增专题博文，谢谢！！！】上一篇我们讲了： 这一篇我们开始讲： 目录一、场景操作步骤二、日志基础关键字分级如下三、场景日志如下： 一、场景操作步骤操作步…...

编程新知 2025/7/10 22:40:01

土地利用/土地覆盖遥感解译与基于CLUE模型未来变化情景预测；从基础到高级，涵盖ArcGIS数据处理、ENVI遥感解译与CLUE模型情景模拟等

🔍 土地利用/土地覆盖数据是生态、环境和气象等诸多领域模型的关键输入参数。通过遥感影像解译技术，可以精准获取历史或当前任何一个区域的土地利用/土地覆盖情况。这些数据不仅能够用于评估区域生态环境的变化趋势，还能有效评价重大生态工程…...

编程新知 2025/7/6 4:52:27

第 86 场周赛：矩阵中的幻方、钥匙和房间、将数组拆分成斐波那契序列、猜猜这个单词

Q1、[中等] 矩阵中的幻方 1、题目描述 3 x 3 的幻方是一个填充有从 1 到 9 的不同数字的 3 x 3 矩阵，其中每行，每列以及两条对角线上的各数之和都相等。给定一个由整数组成的row x col 的 grid，其中有多少个 3 3 的 “幻方” 子矩阵&am…...

编程新知 2025/7/11 14:36:43

【碎碎念】宝可梦 Mesh GO : 基于MESH网络的口袋妖怪宝可梦GO游戏自组网系统

目录游戏说明《宝可梦 Mesh GO》 —— 局域宝可梦探索Pokmon GO 类游戏核心理念应用场景Mesh 特性宝可梦玩法融合设计游戏构想要素1. 地图探索（基于物理空间广播范围）2. 野生宝可梦生成与广播3. 对战系统4. 道具与通信5. 延伸玩法安全性设计技术选…...

编程新知 2025/6/26 5:08:48

Spring Cloud Gateway 中自定义验证码接口返回 404 的排查与解决

Spring Cloud Gateway 中自定义验证码接口返回 404 的排查与解决问题背景在一个基于 Spring Cloud Gateway WebFlux 构建的微服务项目中，新增了一个本地验证码接口 /code，使用函数式路由（RouterFunction）和 Hutool 的 Circle…...

编程新知 2025/7/11 18:15:58

排序算法总结（C++）

目录一、稳定性二、排序算法选择、冒泡、插入排序归并排序随机快速排序堆排序基数排序计数排序三、总结一、稳定性排序算法的稳定性是指：同样大小的样本 **（同样大小的数据）**在排序之后不会改变原始的相对次序。稳定性对基础类型对象…...

编程新知 2025/7/10 16:45:26

MySQL JOIN 表过多的优化思路

当 MySQL 查询涉及大量表 JOIN 时，性能会显著下降。以下是优化思路和简易实现方法： 一、核心优化思路减少 JOIN 数量数据冗余：添加必要的冗余字段（如订单表直接存储用户名）合并表：将频繁关联的小表合并成…...

编程新知 2025/7/6 1:12:52