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

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

news 文章来源：https://blog.csdn.net/qq_45305211/article/details/142109915 2025/5/4 21:00:05

文章目录

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

从hadoop平台下载文件到本地Windows

一、只能上传文件，不能下载 1、原因：如果在Windows中没有配置hadoop的环境变量，用idea远程连接上hadoop平台之后，只能往hadoop上推送数据文件，并不能下载文件，因为下载时hadoop会检测本地有无hadoop环境配置，所以我们需要安装winutils，在windows本地模拟一个hadoop环…...

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

MySQL-CRUD入门2

文章目录数据的查询(补充)条件查询关于SQL语句的执行顺序分页查询(LIMIT) 数据的修改数据修改基础知识数据的查询(补充) 这一节接着写, 包括数据的查询(补充), 数据的更新, 数据的删除条件查询其实就是根据给定的一些条件, 然后过滤掉不符合实际情况的记录, 把符合条件的…...

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

高级java每日一道面试题-2024年9月06日-基础篇-Java中的PO、VO、BO、DO、DAO、DTO、POJO是什么意思?

如果有遗漏,评论区告诉我进行补充面试官: Java中的PO、VO、BO、DO、DAO、DTO、POJO是什么意思? 我回答: PO持久化对象（Persistent Object） PO是持久化对象，用于表示数据库中的实体或表的映射通常与数据库表的结构和字段对应 PO的属性对…...

编程日记 2024/9/11 6:17:05

MFC读取PC6408板卡输入信号实例

本程序基于前期我的博客文章《MFC用信号灯模拟工控机数字量输入信号实时采集实例（源码下载》 1、在TheradDlg.h中相关代码 ... private:unsigned short nAddr; ... TheradDlg.cpp中相关代码 #include "pc60002k.h"BOOL CTheradDlg::OnInitDialog() { ..…...

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

@Async的使用说明

在 Spring Boot 中，Async 注解用于实现异步方法调用，允许方法在单独的线程中执行，从而避免阻塞主线程，提升应用的并发处理能力。 1. 基本用法在 Spring Boot 中使用 Async 很简单，主要步骤如下： 步骤 1…...

编程日记 2024/9/11 6:14:01

经验笔记：SQL调优

SQL调优经验笔记引言 SQL调优是确保数据库系统高效运行的重要环节。通过对查询语句、数据库配置、硬件资源等方面进行优化，可以显著提升数据库性能，进而增强应用程序的整体表现。以下是基于常见调优手段和实践经验整理的一份经验笔记。 1. 查询语句优…...

编程日记 2024/9/11 6:13:00

Selenium使用浏览器用户配置进行测试

本文主要介绍了如何在使用Selenium WebDriver进行自动化测试时，创建和使用自定义的Firefox配置文件。什么是Firefox配置文件？ Firefox会将用户的个人信息，如书签、密码和用户偏好设置存储在一个称为配置文件的文件集合中，这些文…...

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

virsh命令的使用

virsh 是一个用于管理虚拟机的命令行工具，它与 libvirt 服务配合使用，支持对虚拟机的创建、配置、启动、停止等操作。 1、列出虚拟机列出正在运行的虚拟机： virsh list列出所有虚拟机（包括未启动的）： …...

编程日记 2024/9/11 6:10:57

【来学Vue吧】创建一个Vue项目

🌟 嗨，我是命运之光！ 🌍 2024，每日百字，记录时光，感谢有你一路同行。 🚀 携手启航，探索未知，激发潜能，每一步都意义非凡。首先需要配置Vue环境…...

编程日记 2024/9/11 6:09:56

C#迭代器方法和yield用法

一.迭代器方法介绍可使用foreach循环进行遍历的方法，称为迭代器方法。迭代器方法使用yield return语句返回元素。到达yield return语句时，会记住当前在代码中的位置。下次调用迭代器函数时，将从该位置开始执行。换言之，如果…...

编程日记 2024/9/11 6:08:55