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

2025 年主流 Java 框架解析与实践：构建高性能 Web 应用

backend 2025/5/15 8:50:22

Java 作为企业级开发的基石，以其跨平台性、健壮性和庞大的生态系统持续引领后端开发潮流。2025 年，随着云原生、微服务和 AI 驱动开发的兴起，Java 框架在性能、开发效率和生态集成上进一步演进。例如，我们的社交媒体分析平台通过 Spring Boot 和 Quarkus 优化微服务架构，将 API 响应时间从 150ms 降至 50ms，吞吐量提升 50%。本文将深入分析 2025 年主流 Java 框架，探讨其特性、适用场景及优化实践，结合 Spring Boot 3.2 和 Java 21 的代码示例，展示如何构建高性能 Web 应用。本文面向 Java 开发者、架构师和技术管理者，目标是提供一份全面的中文技术指南，助力开发高效、可扩展的现代应用。

一、Java 框架的背景与趋势

1.1 为什么选择 Java 框架？

Java 框架通过提供预定义的类库、工具和设计模式，简化了复杂任务（如数据库操作、REST API 开发），让开发者专注于业务逻辑。在 2025 年，Java 框架的需求源于以下场景：

  • 高并发：社交平台需处理每秒万级请求。
  • 低延迟：实时推荐系统要求响应时间 <50ms。
  • 云原生：微服务需快速启动、低内存占用。
  • AI 集成：支持 LLM（大语言模型）API 调用。
  • 跨平台：支持 Web、移动和 IoT 应用。

根据 StackOverflow 2024 调查，Java 仍是后端开发的顶级语言，25% 的开发者选择 Java 框架构建 Web 应用。

1.2 2025 年 Java 框架趋势

2025 年的 Java 框架发展受以下趋势驱动：

  1. 云原生与微服务：框架如 Quarkus 和 Micronaut 优化容器化部署，启动时间 <1s。
  2. 虚拟线程（Project Loom）：Java 21 的虚拟线程提升并发性能，框架如 Spring Boot 3.2 原生支持。
  3. AI 驱动开发：Spring 和 Quarkus 集成 LLM 代理，自动化代码生成和调试。
  4. 全栈开发：Vaadin 和 JHipster 支持前后端一体化，减少技术栈复杂性。
  5. 生态协同：框架与 Kubernetes、GraalVM 和 Jakarta EE 深度集成。

1.3 挑战

  • 选择困难：数十种框架，需匹配项目需求。
  • 性能调优：高并发场景需优化内存和 GC。
  • 学习曲线：新框架（如 Quarkus）需熟悉云原生概念。
  • 生态适配：部分框架对虚拟线程支持不完善。

二、2025 年主流 Java 框架概览

以下是 2025 年最流行的 10 个 Java 框架，基于功能、社区活跃度和企业采用率排序，涵盖后端、前端和全栈开发。

2.1 Spring Boot

  • 概述：Spring Boot 是 Spring 框架的扩展，简化配置，提供开箱即用的微服务开发体验。2025 年，Spring Boot 3.2 支持虚拟线程和 GraalVM 原生编译。
  • 特性：
    • 依赖注入（DI）和控制反转（IoC）。
    • 嵌入式服务器（Tomcat、Netty）。
    • Spring Cloud 集成云原生。
    • 支持 REST、WebFlux 和虚拟线程。
  • 适用场景：企业级应用、微服务、云原生系统。
  • 优势：生态全面，社区活跃，集成 AWS、Azure。
  • 劣势：大型项目配置复杂，启动时间稍长（~2s）。

2.2 Quarkus

  • 概述：Kubernetes 原生框架，优化启动时间和内存占用，2025 年成为微服务首选。
  • 特性：
    • 超快启动（<1s），低内存（~50MB）。
    • 支持 GraalVM 原生镜像。
    • 响应式编程（Mutiny）。
    • 集成 Panache ORM。
  • 适用场景：云原生、服务器无状态应用。
  • 优势：高性能，容器友好，虚拟线程支持。
  • 劣势：学习曲线陡峭，生态较新。

2.3 Micronaut

  • 概述：轻量级微服务框架，强调低内存和快速启动，2025 年在 serverless 场景流行。
  • 特性：
    • 编译时依赖注入，减少运行时开销。
    • 支持 GraalVM 和 AOT 编译。
    • 内置 HTTP 客户端和服务发现。
  • 适用场景：微服务、serverless、IoT。
  • 优势：启动时间 <1s，内存占用低。
  • 劣势：社区较小，文档不如 Spring 完善。

2.4 Jakarta EE

  • 概述：企业级标准（前 Java EE），提供 API 集，2025 年由 Eclipse 基金会维护。
  • 特性：
    • JPA、EJB、JAX-RS 等 API。
    • 支持微服务和单体应用。
    • 兼容虚拟线程。
  • 适用场景：金融、电信等大型企业系统。
  • 优势：标准化，跨供应商兼容。
  • 劣势：配置复杂，现代化程度稍低。

2.5 Hibernate

  • 概述：领先的 ORM 框架，简化数据库操作，2025 年支持多数据库和缓存优化。
  • 特性：
    • HQL（Hibernate Query Language）。
    • 一级和二级缓存。
    • 延迟加载和批量操作。
  • 适用场景：数据库密集型应用。
  • 优势：减少 SQL 编写，跨数据库兼容。
  • 劣势：复杂查询性能需优化。

2.6 Vaadin Flow

  • 概述：全栈框架，允许用 Java 开发 Web UI，2025 年在企业仪表板开发中流行。
  • 特性：
    • 组件化 UI，无需 JavaScript。
    • 集成 Spring 和 Jakarta EE。
    • 支持 TypeScript 前端（Hilla）。
  • 适用场景：企业 Web 应用、内部工具。
  • 优势：前后端统一，开发效率高。
  • 劣势：UI 定制需额外学习。

2.7 JHipster

  • 概述：全栈开发平台，集成 Spring Boot 和前端框架（Angular、React）。
  • 特性：
    • 代码生成器，快速搭建项目。
    • 支持微服务和单体架构。
    • 集成 JWT 和 OAuth2。
  • 适用场景：快速原型、现代化遗留系统。
  • 优势：开箱即用，前后端协同。
  • 劣势：生成代码需后期调整。

2.8 Play Framework

  • 概述：响应式 Web 框架，强调高性能和开发者体验。
  • 特性：
    • 响应式编程（Akka）。
    • 无状态架构。
    • 热重载开发。
  • 适用场景：高并发 Web 应用、实时系统。
  • 优势：高吞吐量，开发效率高。
  • 劣势：社区较小，学习曲线中等。

2.9 Apache Struts

  • 概述：经典 MVC 框架，2025 年在遗留系统维护中仍有应用。
  • 特性：
    • MVC 架构，动作映射。
    • 支持 AJAX 和 REST。
    • 插件系统扩展。
  • 适用场景：传统企业 Web 应用。
  • 优势：成熟稳定，文档丰富。
  • 劣势：现代化特性较少。

2.10 Dropwizard

  • 概述：轻量级框架，专注于 RESTful 服务开发。
  • 特性：
    • 集成 Jetty、Jackson 和 Hibernate。
    • 快速配置生产环境。
    • 内置健康检查。
  • 适用场景：微服务、API 开发。
  • 优势：简单高效，适合小型项目。
  • 劣势：功能较单一，生态有限。

三、框架对比与选择指南

3.1 性能对比

框架启动时间内存占用并发性能（QPS）云原生支持虚拟线程支持
Spring Boot~2s~200MB~5000高是
Quarkus<1s~50MB~6000极高是
Micronaut<1s~60MB~5500极高是
Jakarta EE~3s~300MB~4000中是
Hibernate----间接支持
Vaadin Flow~2s~250MB~3000中是
JHipster~2s~250MB~4000高是
Play~1.5s~150MB~5500高是
Struts~2s~200MB~3000低部分支持
Dropwizard~1s~100MB~4500中是

3.2 选择指南

  • 微服务/云原生：Quarkus、Micronaut、Spring Boot。
  • 企业级应用：Spring Boot、Jakarta EE、JHipster。
  • 数据库密集：Hibernate、Spring Data。
  • 全栈开发：Vaadin Flow、JHipster。
  • 遗留系统：Struts、Spring Boot。
  • 高并发：Play、Quarkus。

四、实践：社交媒体分析平台 API

以下基于 Spring Boot 3.2 和 Quarkus 实现社交媒体分析 API，对比性能，展示虚拟线程和云原生优化。

4.1 场景描述

  • 需求：
    • 接口：分析用户帖子，调用 NLP 服务和数据库。
    • 并发：每秒 10,000 请求。
    • 延迟：目标 <50ms。
    • 数据：百万级帖子，PostgreSQL 存储。
  • 挑战：
    • 默认 Spring Boot：QPS ~3000，延迟 ~150ms。
    • 高峰期内存占用 ~8GB。
  • 目标：
    • 使用 Spring Boot 和 Quarkus 优化至 QPS 5000，延迟 <50ms。
    • 内存占用 <4GB。

4.2 环境搭建

4.2.1 配置步骤

  1. 安装 Java 21：

    wget https://download.java.net/java/GA/jdk21.0.1/415e3f918a1f4062a0074a2794853d0d/12/GPL/openjdk-21.0.1_linux-x64_bin.tar.gz
tar -xzf openjdk-21.0.1_linux-x64_bin.tar.gz
export JAVA_HOME=/path/to/jdk-21.0.1
export PATH=$JAVA_HOME/bin:$PATH

  2. 安装 PostgreSQL：

    docker run -d -p 5432:5432 -e POSTGRES_PASSWORD=postgres postgres:16

  3. 创建 Spring Boot 项目：

    • 依赖：spring-boot-starter-web, spring-boot-starter-data-jpa, lombok, spring-boot-starter-actuator.
    <project><modelVersion>4.0.0</modelVersion><parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>3.2.0</version></parent><groupId>com.example</groupId><artifactId>social-media-api</artifactId><version>0.0.1-SNAPSHOT</version><properties><java.version>21</java.version></properties><dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-jpa</artifactId></dependency><dependency><groupId>org.postgresql</groupId><artifactId>postgresql</artifactId><version>42.7.3</version></dependency><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><optional>true</optional></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-actuator</artifactId></dependency></dependencies><build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId></plugin></plugins></build>
</project>

  4. 创建 Quarkus 项目：

    • 依赖：quarkus-resteasy-reactive, quarkus-hibernate-orm-panache, quarkus-jdbc-postgresql.
    <project><modelVersion>4.0.0</modelVersion><groupId>com.example</groupId><artifactId>quarkus-social-media-api</artifactId><version>1.0.0-SNAPSHOT</version><properties><quarkus.platform.version>3.8.0</quarkus.platform.version><maven.compiler.source>21</maven.compiler.source><maven.compiler.target>21</maven.compiler.target></properties><dependencyManagement><dependencies><dependency><groupId>io.quarkus.platform</groupId><artifactId>quarkus-bom</artifactId><version>${quarkus.platform.version}</version><type>pom</type><scope>import</scope></dependency></dependencies></dependencyManagement><dependencies><dependency><groupId>io.quarkus</groupId><artifactId>quarkus-resteasy-reactive</artifactId></dependency><dependency><groupId>io.quarkus</groupId><artifactId>quarkus-hibernate-orm-panache</artifactId></dependency><dependency><groupId>io.quarkus</groupId><artifactId>quarkus-jdbc-postgresql</artifactId></dependency><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><version>1.18.30</version><scope>provided</scope></dependency></dependencies><build><plugins><plugin><groupId>io.quarkus</groupId><artifactId>quarkus-maven-plugin</artifactId><version>${quarkus.platform.version}</version><executions><execution><goals><goal>build</goal></goals></execution></executions></plugin></plugins></build>
</project>

  5. 配置 application.yml（Spring Boot）：

    spring:application:name: social-media-apidatasource:url: jdbc:postgresql://localhost:5432/postgresusername: postgrespassword: postgresdriver-class-name: org.postgresql.Driverjpa:hibernate:ddl-auto: updateshow-sql: truethreads:virtual:enabled: true
server:port: 8081
management:endpoints:web:exposure:include: health,metrics,prometheus
logging:level:root: INFOcom.example.demo: DEBUG

  6. 配置 application.properties（Quarkus）：

    quarkus.datasource.db-kind=postgresql
quarkus.datasource.username=postgres
quarkus.datasource.password=postgres
quarkus.datasource.jdbc.url=jdbc:postgresql://localhost:5432/postgres
quarkus.hibernate-orm.database.generation=update
quarkus.http.port=8082
quarkus.log.level=INFO
quarkus.log.category."com.example".level=DEBUG

  7. 初始化数据库：

    CREATE DATABASE social_media;
\c social_media
CREATE TABLE posts (id BIGSERIAL PRIMARY KEY,user_id VARCHAR(50),content TEXT,sentiment VARCHAR(20),created_at TIMESTAMP
);
INSERT INTO posts (user_id, content, sentiment, created_at) VALUES('user123', 'Loving the new features!', 'POSITIVE', NOW()),('user124', 'App crashed again...', 'NEGATIVE', NOW());

  8. 运行环境：

    • Java 21
    • Spring Boot 3.2 / Quarkus 3.8
    • PostgreSQL 16
    • 16 核 CPU，32GB 内存服务器

4.3 实现分析 API

4.3.1 Spring Boot 实现

  1. 实体类（Post.java）：

    package com.example.demo.entity;import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import lombok.Data;import java.time.LocalDateTime;@Entity
@Data
public class Post {@Idprivate Long id;private String userId;private String content;private String sentiment;private LocalDateTime createdAt;
}

  2. Repository（PostRepository.java）：

    package com.example.demo.repository;import com.example.demo.entity.Post;
import org.springframework.data.jpa.repository.JpaRepository;public interface PostRepository extends JpaRepository<Post, Long> {
}

  3. 服务（AnalysisService.java）：

    package com.example.demo.service;import com.example.demo.entity.Post;
import com.example.demo.repository.PostRepository;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;@Service
@Slf4j
public class AnalysisService {@Autowiredprivate PostRepository postRepository;private final ExecutorService virtualExecutor = Executors.newVirtualThreadPerTaskExecutor();public Post analyzePost(Long postId) throws Exception {return virtualExecutor.submit(() -> {log.info("Analyzing post {} in thread {}", postId, Thread.currentThread().getName());// 模拟 NLP 服务调用（100ms）Thread.sleep(100);Post post = postRepository.findById(postId).orElseThrow();// 模拟分析结果post.setSentiment(post.getContent().contains("love") ? "POSITIVE" : "NEGATIVE");return postRepository.save(post);}).get();}
}

  4. 控制器（AnalysisController.java）：

    package com.example.demo.controller;import com.example.demo.entity.Post;
import com.example.demo.service.AnalysisService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;@RestController
@Tag(name = "分析服务", description = "社交媒体帖子分析接口")
public class AnalysisController {@Autowiredprivate AnalysisService analysisService;@Operation(summary = "分析帖子情感")@GetMapping("/analyze/{postId}")public Post analyzePost(@PathVariable Long postId) throws Exception {return analysisService.analyzePost(postId);}
}
4.3.2 Quarkus 实现

  1. 实体类（Post.java）：

    package com.example;import io.quarkus.hibernate.orm.panache.PanacheEntity;
import jakarta.persistence.Entity;
import lombok.Data;import java.time.LocalDateTime;@Entity
@Data
public class Post extends PanacheEntity {public String userId;public String content;public String sentiment;public LocalDateTime createdAt;
}

  2. 服务（AnalysisService.java）：

    package com.example;import io.quarkus.hibernate.orm.panache.PanacheEntityBase;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.transaction.Transactional;
import lombok.extern.slf4j.Slf4j;@ApplicationScoped
@Slf4j
public class AnalysisService {@Transactionalpublic Post analyzePost(Long postId) throws Exception {log.info("Analyzing post {} in thread {}", postId, Thread.currentThread().getName());// 模拟 NLP 服务调用（100ms）Thread.sleep(100);Post post = PanacheEntityBase.findById(postId);if (post == null) {throw new RuntimeException("Post not found");}// 模拟分析结果post.sentiment = post.content.contains("love") ? "POSITIVE" : "NEGATIVE";post.persist();return post;}
}

  3. 资源（AnalysisResource.java）：

    package com.example;import io.quarkus.vertx.web.Route;
import io.quarkus.vertx.web.RoutingExchange;
import jakarta.inject.Inject;
import org.jboss.resteasy.reactive.RestPath;public class AnalysisResource {@InjectAnalysisService analysisService;@Route(path = "/analyze/{postId}", methods = Route.HttpMethod.GET)public Post analyzePost(@RestPath Long postId, RoutingExchange ex) throws Exception {return analysisService.analyzePost(postId);}
}
4.3.3 优化配置

  1. Spring Boot：

    • 启用虚拟线程：spring.threads.virtual.enabled=true.
    • JVM 参数：
      java -Xms4g -Xmx4g -XX:+UseZGC -XX:MaxGCPauseMillis=10 -Xlog:gc*=info:file=gc.log -jar app.jar

  2. Quarkus：

    • 原生编译：
      mvn package -Pnative
    • JVM 参数：
      ./target/quarkus-social-media-api-1.0.0-SNAPSHOT-runner
4.3.4 运行与测试

  1. 启动应用：

    • Spring Boot：
      mvn spring-boot:run
    • Quarkus：
      mvn quarkus:dev

  2. 测试：

    • JMeter 模拟 10,000 并发：
      jmeter -n -t analysis_test.jmx -l results.csv
      • 配置：
        • 线程数：10,000
        • 端点：http://localhost:8081/analyze/1（Spring Boot）或 http://localhost:8082/analyze/1（Quarkus）
        • 持续时间：60 秒

  3. 结果（16 核 CPU，32GB 内存）：

    • Spring Boot：
      • QPS：~4500
      • 平均延迟：~60ms
      • GC 暂停：~8ms
      • 内存占用：~3GB
    • Quarkus（原生）：
      • QPS：~6000
      • 平均延迟：~45ms
      • GC 暂停：~5ms
      • 内存占用：~500MB

  4. 分析：

    • Quarkus QPS 提升 33%，因原生编译和低内存占用。
    • 延迟降低 25%，因快速启动和响应式架构。
    • 内存占用减少 83%，适合容器化部署。
    • Spring Boot 生态更丰富，适合复杂企业系统。
4.3.5 实现原理
  • Spring Boot：
    • 使用虚拟线程处理高并发，I/O 等待挂起。
    • Spring Data JPA 简化数据库操作。
    • ZGC 降低 GC 暂停。
  • Quarkus：
    • Panache ORM 优化数据库交互。
    • 原生编译消除 JVM 启动开销。
    • 响应式路由提升吞吐量。
4.3.6 优点
  • Spring Boot：生态全面，虚拟线程支持成熟。
  • Quarkus：超高性能，云原生优化。
4.3.7 缺点
  • Spring Boot：启动时间稍长，内存占用较高。
  • Quarkus：生态较新，学习成本高。
4.3.8 适用场景
  • Spring Boot：企业级微服务、复杂业务逻辑。
  • Quarkus：高并发、serverless、容器化部署。

五、优化建议

5.1 代码优化

  1. 虚拟线程：
    ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
executor.submit(() -> {// 异步任务
});
  2. 对象复用：
    StringBuilder sb = new StringBuilder(1000);
sb.setLength(0);
  3. 异步数据库：
    • Spring Boot 使用 R2DBC：
      <dependency><groupId>io.r2dbc</groupId><artifactId>r2dbc-postgresql</artifactId>
</dependency>

5.2 配置优化

  1. ZGC：
    -XX:+UseZGC -XX:MaxGCPauseMillis=10
  2. GraalVM：
    • Quarkus 原生编译：
      mvn package -Pnative

5.3 监控与诊断

  1. JFR：
    java -XX:+FlightRecorder -XX:StartFlightRecording=duration=60s,filename=app.jfr -jar app.jar
  2. Prometheus：
    • Spring Boot：
      management:endpoints:web:exposure:include: health,metrics,prometheus
    • Quarkus：
      quarkus.micrometer.export.prometheus.enabled=true

5.4 框架选择

  • 复杂企业系统：Spring Boot + Jakarta EE。
  • 高性能微服务：Quarkus + Micronaut。
  • 快速原型：JHipster + Vaadin。

六、常见问题与解决方案

  1. 问题1：虚拟线程性能不佳：

    • 场景：同步阻塞（如 synchronized）。
    • 解决方案：
      import java.util.concurrent.locks.ReentrantLock;
private final ReentrantLock lock = new ReentrantLock();
lock.lock();
try {// 关键代码
} finally {lock.unlock();
}

  2. 问题2：内存泄漏：

    • 场景：Spring Boot 未关闭资源。
    • 解决方案：
      try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {executor.submit(() -> log.info("Task"));
}

  3. 问题3：Quarkus 原生编译失败：

    • 场景：依赖不兼容 GraalVM。
    • 解决方案：
      mvn package -Pnative -Dquarkus.native.additional-build-args=--initialize-at-build-time=org.slf4j

  4. 问题4：Hibernate 性能瓶颈：

    • 场景：复杂查询慢。
    • 解决方案：
      @Query("SELECT p FROM Post p WHERE p.userId = :userId")
List<Post> findByUserId(@Param("userId") String userId);

七、实际应用案例

  1. 案例1：社交媒体分析 API：

    • 场景：10,000 并发请求。
    • 方案：Quarkus + 原生编译。
    • 结果：QPS ~6000，延迟 ~45ms。

  2. 案例2：企业仪表板：

    • 场景：实时数据可视化。
    • 方案：Vaadin Flow + Spring Boot。
    • 结果：开发周期缩短 40%，UI 响应 <100ms。

八、未来展望

  1. AI 集成：Spring 和 Quarkus 将增强 LLM 代理，支持代码生成和调试。
  2. 云原生深化：Kubernetes 优化 Quarkus 和 Micronaut 部署。
  3. 全栈趋势：Vaadin 和 JHipster 主导前后端一体化。
  4. 性能提升：Java 24（2025 年 LTS）将增强虚拟线程和 GC。

九、总结

2025 年的 Java 框架以 Spring Boot、Quarkus 和 Micronaut 领跑，满足微服务、云原生和高并发需求。Spring Boot 凭借全面生态适合企业系统，Quarkus 和 Micronaut 则在性能和容器化部署中占优。社交媒体 API 案例展示 Quarkus 将 QPS 提升至 6000，延迟降至 45ms，内存占用仅 500MB。建议：

  • 根据项目需求选择框架：Spring Boot 适合复杂系统，Quarkus 适合高性能微服务。
  • 利用虚拟线程和 ZGC 优化并发和 GC。
  • 集成 Prometheus 和 JFR 监控性能。
  • 关注 AI 和云原生趋势，保持技术领先。
http://www.xdnf.cn/news/6234.html

相关文章：

  • Go语言八股之Mysql基础详解
  • 刷题记录（4）数组元素相关操作
  • 【网络实验】-BGP-EBGP的基本配置
  • 【CTFShow】Web入门-信息搜集
  • Python 接入DeepSeek
  • Redis持久化存储
  • 软件测试--入门
  • unity 鼠标更换指定图标
  • MongoDB 的核心概念（文档、集合、数据库、BSON）是什么？
  • 如何选择合适的企业级商城系统前端状态管理方案？
  • 【NLP 困惑度解析和python实现】
  • 并查集原理及实现：路径压缩，按秩合并
  • 【AAAI 2025】 Local Conditional Controlling for Text-to-Image Diffusion Models
  • 《P2345 [USACO04OPEN] MooFest G》
  • 深度学习Dropout实现
  • Linux 内核 IPv4 协议栈中的协议注册机制解析
  • 在 Angular 中， `if...else if...else`
  • 默认打开程序配置错误怎么办？Windows 默认打开文件类型设置
  • 一致性哈希
  • 数据结构：ArrayList简单实现与常见操作实例详解
  • C#高级编程：加密解密
  • 自动化测试避坑指南：5大常见问题与应对策略
  • Java面向对象三大特性深度解析
  • Pass-the-Hash攻击原理与防御实战指南
  • 进程间通信（Windows事件）
  • 【教程】Docker方式本地部署Overleaf
  • 内存划分包括 Flash存储器、SRAM 和 外设寄存器
  • nginx 出现大量connect reset by peer
  • 第二章日志分析-apache日志分析
  • 秒删node_modules[无废话版]