你好，未来的Java架构师！

欢迎来到Java的星辰大海。如果你曾感到困惑，面对多如繁星的框架不知何从下手，那么你来对地方了。Java生态之所以强大，正是因为它拥有一个由无数框架构成的、分工明确的“银河系”。

这篇文章不是一份枯燥的清单，而是一张为你绘制的**“Java宇宙航行图”**。我们将驾驶飞船，逐一探访那些最闪亮的“星球”（框架），不仅会了解它们的“地貌特征”（特点），更会亲自“登陆”，搭建一个微型基地（实战项目），让你真正感受每个框架的魅力。

准备好了吗？系好安全带，我们的旅程马上开始！

第一星系：Web框架 —— 构建应用的骨架

Web框架是我们与用户交互的门户，是所有应用的“骨架”。

1. Spring Boot 🌟 —— “五星级酒店的全能管家”

它是谁？ 如果说Spring是一个庞大的工具箱，那Spring Boot就是一位顶级管家，他帮你把所有需要的工具（Spring MVC, AOP, anagement等）都预先组装好，你只需拎包入住，专注于你的核心业务即可。它是当之无愧的王者，是现代Java应用的事实标准。

核心理念： “约定优于配置” (Convention over Configuration)。它假设了你可能需要的一切，并提供了明智的默认配置。

微型实战项目：创建一个用户查询API

目标： 搭建一个HTTP服务，当访问/users/1时，返回一个ID为1的用户信息。

步骤1：环境准备

  • 构建工具： Maven

  • IDE： IntelliJ IDEA / Eclipse

  • 最快搭建方式： 访问 Spring Initializr，这是一个官方的脚手架工具。

    • Project: Maven

    • Language: Java

    • Spring Boot: 选择一个稳定版本 (如 3.x.x)

    • Group: com.example

    • Artifact: springboot-demo

    • Dependencies: 点击"ADD DEPENDENCIES..."，搜索并添加 Spring Web。

    • 点击"GENERATE"，下载zip包并用IDE打开。

步骤2：项目代码

  • pom.xml

        <!-- ... 省略部分 ... -->
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- ... 省略测试依赖 ... -->
</dependencies>
<!-- ... 省略部分 ... -->

  • SpringbootDemoApplication.java (这是启动入口)

        package com.example.springbootdemo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class SpringbootDemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringbootDemoApplication.class, args);
    }
}

  • 创建User.java (数据模型)

        package com.example.springbootdemo;

// 一个简单的POJO (Plain Old Java Object)
public class User {
    private Long id;
    private String name;

    public User(Long id, String name) {
        this.id = id;
        this.name = name;
    }

    // Getters and Setters ...
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
}

  • 创建UserController.java (控制器，处理HTTP请求)

        package com.example.springbootdemo;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

@RestController // 声明这是一个RESTful控制器，返回JSON
public class UserController {
    // 模拟一个数据库
    static Map<Long, User> userDatabase = new ConcurrentHashMap<>();
    static {
        userDatabase.put(1L, new User(1L, "Gitee Master"));
        userDatabase.put(2L, new User(2L, "Dev Coder"));
    }

    @GetMapping("/users/{id}") // 映射HTTP GET请求到 /users/{id}
    public User getUserById(@PathVariable Long id) {
        // @PathVariable 从路径中获取id
        return userDatabase.get(id);
    }
}

步骤3：运行与测试

  • 在IDE中找到SpringbootDemoApplication.java，右键点击，选择"Run"。

  • 等待控制台输出Spring的Logo和"Tomcat started on port(s): 8080"。

  • 打开浏览器或Postman，访问 http://localhost:8080/users/1。

  • 你会看到返回的JSON：{"id":1,"name":"Gitee Master"}。

恭喜！你已经完成了Spring Boot的入门，感受到了它的简洁与强大。

2. Spring MVC —— “Spring Boot的心脏”

它是谁？ 它不是Spring Boot的替代品，而是Spring Boot spring-boot-starter-web依赖的核心。上面我们写的@RestController, @GetMapping, @PathVariable等注解，全部来自于Spring MVC。它是一个经典的、基于模型-视图-控制器（MVC）设计模式的Web框架。

所以，你刚刚写的Spring Boot项目，其实就是一个Spring MVC项目！ Spring Boot只是让配置和运行它变得无比简单。

3. Quarkus ⚡ —— “为云而生的闪电侠”

它是谁？ 一个专为云原生、容器化和Serverless时代打造的Java框架。它的目标是：极速启动、超低内存。

核心武器： 它在编译时就完成了大量的依赖注入和框架初始化工作，并能与GraalVM（一种高性能JDK）配合，将Java应用编译成本地可执行文件，实现毫秒级启动。

微型实战项目：一个Quarkus版的Hello API

步骤1：环境准备

  • 最快搭建方式： 访问 Quarkus代码生成器。

    • Group: org.example

    • Artifact: quarkus-demo

    • 添加扩展 (Extensions): RESTEasy Reactive (Quarkus的Web层)

    • 点击"Generate your application"，下载并解压。

步骤2：项目代码

  • pom.xml (注意依赖)

        <!-- ... -->
<dependencies>
  <dependency>
    <groupId>io.quarkus</groupId>
    <artifactId>quarkus-resteasy-reactive</artifactId>
  </dependency>
  <!-- ... -->
</dependencies>
<!-- ... -->

  • GreetingResource.java (类似Spring MVC的Controller)

        package org.example;

import jakarta.ws.rs.GET;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.Produces;
import jakarta.ws.rs.core.MediaType;

@Path("/hello") // 类似@RequestMapping，定义根路径
public class GreetingResource {

    @GET // 类似@GetMapping
    @Produces(MediaType.TEXT_PLAIN) // 定义返回类型为纯文本
    public String hello() {
        return "Hello from Quarkus!";
    }
}

步骤3：运行与测试

  • 打开终端，进入项目根目录。

  • 执行Quarkus的开发模式命令：

        ./mvnw quarkus:dev

  • 你会惊讶地发现，它几乎是瞬间启动！

  • 访问 http://localhost:8080/hello，你会看到 "Hello from Quarkus!"。

Quarkus的魅力在于其极致的性能，是未来云原生Java的重要方向。

(注：Micronaut与Quarkus类似，也是编译时依赖注入，在此不重复展示。Vert.x则专注于响应式编程，我们将在第三星系中深入探讨。)

第二星系：ORM框架 —— 与数据库对话的艺术

ORM（对象关系映射）框架是应用与数据库之间的“翻译官”，它让你能用操作Java对象的方式来操作数据库表。

1. MyBatis-Plus 🌟 (基于MyBatis) —— “SQL掌控者的瑞士军刀”

它是谁？ MyBatis本身是一个半自动的ORM框架，它让你在XML或注解中编写原生SQL，灵活性极高。而MyBatis-Plus是MyBatis的“超级增强版”，它在MyBatis的基础上，提供了大量开箱即用的功能（如通用的CRUD、分页），让你在享受SQL灵活性的同时，大大提升了开发效率。对于国内开发者，它几乎是必选项。

微型实战项目：将Spring Boot项目接入数据库

目标： 改造我们之前的springboot-demo项目，使其能从真实的数据库中查询用户。

步骤1：修改pom.xml
在pom.xml中添加MyBatis-Plus和数据库驱动的依赖。为了简单，我们使用H2内存数据库。

    <!-- ... 在 <dependencies> 标签内添加 ... -->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.5.3.1</version> <!-- 使用一个较新版本 -->
</dependency>
<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <scope>runtime</scope>
</dependency>

步骤2：配置数据库连接

  • 在 src/main/resources/application.properties 文件中添加配置：

        # H2 数据库配置
spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=

# 让MyBatis-Plus知道Mapper XML文件的位置
mybatis-plus.mapper-locations=classpath:/mapper/*.xml

步骤3：修改代码

  • User.java (添加MyBatis-Plus注解)

        package com.example.springbootdemo;

import com.baomidou.mybatisplus.annotation.TableName;

@TableName("user") // 告诉MyBatis-Plus这个类对应数据库中的'user'表
public class User {
    // ... id 和 name 字段不变 ...
}

  • 创建UserMapper.java (数据访问接口)

        package com.example.springbootdemo;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;

@Mapper // 告诉Spring Boot这是一个MyBatis的Mapper接口
public interface UserMapper extends BaseMapper<User> {
    // 继承了BaseMapper后，就自动拥有了增删改查等大量方法！
    // 无需写任何SQL！
}

  • 创建schema.sql (初始化数据库表和数据)
    在 src/main/resources 目录下创建 schema.sql 文件，Spring Boot启动时会自动执行它。

        CREATE TABLE user (
    id BIGINT PRIMARY KEY,
    name VARCHAR(255)
);

INSERT INTO user (id, name) VALUES (1, 'Gitee Master From DB');
INSERT INTO user (id, name) VALUES (2, 'Dev Coder From DB');

  • 修改UserController.java (注入Mapper并调用)

        package com.example.springbootdemo;

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
public class UserController {
    
    @Autowired // Spring自动注入UserMapper实例
    private UserMapper userMapper;

    @GetMapping("/users/{id}")
    public User getUserById(@PathVariable Long id) {
        // 调用MyBatis-Plus提供的selectById方法
        return userMapper.selectById(id);
    }
}

步骤4：运行与测试

  • 重新运行SpringbootDemoApplication。

  • 再次访问 http://localhost:8080/users/1。

  • 你会看到从数据库中查询出的数据：{"id":1,"name":"Gitee Master From DB"}。

看到了吗？MyBatis-Plus让你几乎不用写SQL就完成了数据库操作，同时保留了需要时手写复杂SQL的能力。

2. Spring Data JPA —— “面向对象的极致体验”

它是谁？ 如果说MyBatis是让你成为“SQL大师”，那么Spring Data JPA就是让你“忘记SQL”。它基于JPA（Java Persistence API）规范，让你完全通过操作对象的方式来持久化数据。

核心武器： Repository接口。你只需定义一个接口，继承JpaRepository，它就能自动为你生成常用的CRUD方法。你甚至可以通过方法名来自动生成查询！

微型实战项目：用JPA方式重写数据访问层

步骤1：修改pom.xml
将MyBatis-Plus的依赖替换为Spring Data JPA。

    <!-- 移除 mybatis-plus-boot-starter -->
<!-- 添加 jpa 和 h2 (h2已存在) -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

步骤2：修改代码

  • User.java (修改为JPA实体)

        package com.example.springbootdemo;

import jakarta.persistence.Entity;
import jakarta.persistence.Id;

@Entity // 告诉JPA这是一个实体类
public class User {
    
    @Id // 声明这是主键
    private Long id;
    private String name;
    
    // JPA需要一个无参构造函数
    public User() {}

    public User(Long id, String name) {
        this.id = id;
        this.name = name;
    }

    // Getters and Setters ...
}

  • 创建UserRepository.java (替代UserMapper)

        package com.example.springbootdemo;

import org.springframework.data.jpa.repository.JpaRepository;

// 继承JpaRepository，泛型参数为 <实体类, 主键类型>
public interface UserRepository extends JpaRepository<User, Long> {
    // 这就是魔法！Spring Data JPA会根据方法名自动生成SQL查询
    // 比如，你想通过名字查找用户：
    User findByName(String name); 
}

  • 修改UserController.java (注入UserRepository)

        // ...
@RestController
public class UserController {
    @Autowired
    private UserRepository userRepository;

    @GetMapping("/users/{id}")
    public User getUserById(@PathVariable Long id) {
        // JpaRepository提供了findById方法，返回一个Optional
        return userRepository.findById(id).orElse(null);
    }
}

    (注：schema.sql仍然有效，JPA会自动检测并使用它)

步骤3：运行与测试

  • 运行并访问，你会得到同样的结果。但实现方式已经天差地别。

JPA适合快速开发、CRUD密集型的应用。MyBatis-Plus则在需要精细控制SQL的复杂场景中更具优势。

第三星系：微服务框架 —— 构建庞大系统的乐高

当应用变得巨大，我们就需要将其拆分成一个个小而美的“微服务”。微服务框架就是管理这些服务的“交通警察”和“通信基站”。

1. Spring Cloud 🌟 —— “微服务领域的全家桶”

它是谁？ 它不是一个单一的框架，而是一套基于Spring Boot的、用于构建微服务的完整解决方案。它就像一个工具箱，里面有：

  • 注册中心 (Nacos/Eureka): 服务“户籍管理处”，记录每个服务在哪里。

  • 服务调用 (OpenFeign): 让你像调用本地方法一样调用远程服务。

  • 网关 (Gateway): 所有外部请求的统一入口，负责路由、安全和限流。

  • 配置中心 (Nacos/Config): 集中管理所有服务的配置。

微型实战项目：用户服务与订单服务的简单调用

目标： 我们有一个user-service（就是我们上面的项目）和一个新的order-service。order-service需要查询某个订单属于哪个用户，它将通过OpenFeign来调用user-service。

步骤1：搭建user-service

  • 我们之前的springboot-demo项目就可以作为user-service。

  • 我们需要将它注册到服务中心。这里我们选用阿里巴巴的Nacos（集注册中心和配置中心于一体）。

  • 修改user-service的pom.xml：

        <!-- 添加Spring Cloud和Nacos的依赖 -->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
    <version>2022.0.0.0</version> <!-- 版本需要与Spring Boot匹配 -->
</dependency>

    (你可能需要在dependencyManagement中添加Spring Cloud的版本)

  • 修改user-service的application.properties：

        # 定义服务名
spring.application.name=user-service
# Nacos服务器地址
spring.cloud.nacos.server-addr=127.0.0.1:8848

  • 修改user-service的启动类：

        @SpringBootApplication
@EnableDiscoveryClient // 开启服务发现功能
public class SpringbootDemoApplication {
    // ...
}

步骤2：搭建order-service

  • 按照Spring Initializr的方式，创建一个新的Spring Boot项目order-service。

  • 添加Spring Web, Nacos Discovery, 和 OpenFeign 依赖。

  • 配置order-service的application.properties：

        spring.application.name=order-service
server.port=8081 # 避免端口冲突
spring.cloud.nacos.server-addr=127.0.0.1:8848

  • 在order-service中创建UserClient.java (Feign客户端)

        package com.example.orderservice;

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;

// "user-service" 是我们要调用的服务名
@FeignClient("user-service") 
public interface UserClient {
    // 这个方法签名，必须与user-service中的Controller方法完全一致！
    @GetMapping("/users/{id}")
    User getUserById(@PathVariable("id") Long id);
}
// (需要自己创建一个与user-service中一样的User.java类)

  • 在order-service的启动类上开启Feign功能：

        @SpringBootApplication
@EnableDiscoveryClient
@EnableFeignClients // 开启Feign
public class OrderServiceApplication { // ...

  • 在order-service中创建一个OrderController来测试调用：

        @RestController
public class OrderController {
    @Autowired
    private UserClient userClient;
    
    @GetMapping("/orders/{orderId}/user")
    public User getOrderUser(@PathVariable String orderId) {
        // 假设所有订单都属于用户1
        Long userId = 1L;
        // 像调用本地接口一样调用远程服务！
        return userClient.getUserById(userId);
    }
}

步骤3：运行与测试

  1. 先下载并启动Nacos服务器。 (具体步骤可搜索“Nacos快速开始”)

  2. 启动user-service。

  3. 启动order-service。

  4. 访问order-service的接口：http://localhost:8081/orders/any-id/user。

  5. 你会看到，order-service成功地从user-service获取到了用户信息！

这就是微服务的魅力：服务解耦，通过轻量级通信协同工作。Spring Cloud让这一切变得标准化、工程化。

(注：Dubbo和gRPC是高性能的RPC框架，专注于服务间的高效调用，与Spring Cloud的HTTP+JSON方式不同，它们更底层，性能更高。)

第四星系：响应式编程 —— 迎接高并发的未来

传统编程是“一问一答”的同步阻塞模式。响应式编程则是“订阅-推送”的异步非阻塞模式，它能用更少的线程处理更高的并发。

1. Spring WebFlux & Project Reactor —— “Spring的响应式化身”

它是谁？ WebFlux是Spring 5推出的、与Spring MVC并行的响应式Web框架。它的底层不再是传统的Servlet容器，而是像Netty这样的异步事件驱动框架。Project Reactor是WebFlux默认使用的响应式库，它提供了两种核心类型：Mono (代表0或1个元素) 和 Flux (代表0到N个元素)。

微型实战项目：一个响应式的用户API

目标： 用WebFlux重写我们的用户查询API。

步骤1：创建项目

  • 使用Spring Initializr，但这次的依赖要选择 Spring Reactive Web。

步骤2：项目代码

  • UserHandler.java (处理业务逻辑，类似Service)

        @Component
public class UserHandler {
    public Mono<ServerResponse> getUserById(ServerRequest request) {
        Long id = Long.valueOf(request.pathVariable("id"));
        // 返回一个Mono<User>，表示未来可能会有一个User
        Mono<User> userMono = Mono.just(new User(id, "Reactive User"));
        
        return ServerResponse.ok()
            .contentType(MediaType.APPLICATION_JSON)
            .body(userMono, User.class);
    }
}

  • RouterConfig.java (配置路由，替代@GetMapping)

        @Configuration
public class RouterConfig {
    @Bean
    public RouterFunction<ServerResponse> routes(UserHandler userHandler) {
        // 函数式地定义路由
        return RouterFunctions.route()
            .GET("/users/{id}", userHandler::getUserById)
            .build();
    }
}

    (注：WebFlux也支持@RestController风格的注解编程，但函数式路由更能体现其思想。)

步骤3：运行与测试

  • 运行应用，访问 http://localhost:8080/users/1。

  • 你会得到和之前一样的JSON结果，但其底层的执行模型已经完全不同了。它以极低的资源消耗，为应对C10K（万级并发）甚至更高的负载做好了准备。

航行总结：你的Java学习路线图

我们已经完成了这次壮丽的宇宙航行。你可能有些眼花缭乱，这是正常的。作为新手，你应该如何规划你的学习路径？

  1. 第一站：Spring Boot + MyBatis-Plus。这是当前国内Java后端开发最主流、最实用的技术栈。牢牢掌握它，你就能应对80%以上的工作需求。

  2. 第二站：Spring Cloud。当你需要构建更复杂的分布式系统时，深入学习Spring Cloud的微服务治理能力。

  3. 探索新大陆：Spring Data JPA, Quarkus, Spring WebFlux。根据你的项目需求和个人兴趣，去探索这些不同风格、面向未来的框架。

记住，框架是工具，解决业务问题才是根本。这篇指南为你打开了无数扇门，但真正的旅程，需要你自己一步一个脚印去探索。

祝你在Java的宇宙中，航行愉快，发现属于你的新世界！

# java # spring boot # 云原生
Logo
亚马逊云科技技术品牌专区

更多推荐

open-code-review Codex 插件教程：对话式调用评审技能指南

本文是一份面向新手的 **open-code-review Codex 插件教程**，教你在 Codex 中通过对话式方式调用 open-code-review 的 AI 代码评审技能。open-code-review 是阿里巴巴开源的 AI 代码评审工具，采用"确定性流水线 + LLM Agent"混合架构，内置多语言评审规则（NPE、线程安全、XSS、SQL 注入等），可在 Codex 里用一

avatar 亚马逊云科技技术品牌专区

OBS Studio 完整指南：免费开源录屏与直播软件从零上手

想做一场像模像样的直播，或者把屏幕内容录成教程视频，但一想到商用软件的订阅费就有些犹豫？其实你不需要花一分钱。OBS Studio 是一款免费开源的直播与录屏软件，支持 Windows、macOS 和 Linux，采集、混音、编码、推流、录制，一条流水线全包了。## 先搞清楚 OBS Studio 是什么OBS Studio 是一个"场景化"的采集合成工具：你把摄像头、窗口、浏览器、图片、

avatar 亚马逊云科技技术品牌专区

如何用MediaCrawler爬取小红书抖音数据？7大平台爬虫从安装到实战完整指南

MediaCrawler 是一个支持小红书、抖音、快手、B站、微博、百度贴吧、知乎的开源自媒体数据采集工具。它能按关键词、按帖子、按创作者主页三种方式抓取笔记/视频内容、评论甚至二级评论，并把结果存成 JSON、CSV、Excel 或数据库。适合做市场调研、竞品监控、内容选题的运营人员，以及想要现成爬虫框架而不想从零写 JS 逆向的开发者。## 从一次"手动抄数据"说起想象这个场景：你负责

avatar 亚马逊云科技技术品牌专区