Spring Boot微服务架构详解

原创 已于 2025-10-13 20:36:27 修改 · 668 阅读 · 16 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#架构 #spring boot #微服务

于 2025-10-13 20:29:49 首次发布

文章目录

1. 微服务架构概述

微服务架构是一种将单一应用程序开发为一组小型服务的方法，每个服务运行在自己的进程中，并通过轻量级机制（通常是HTTP API）进行通信。Spring Boot为微服务架构提供了完整的解决方案。

1.1 微服务架构特点

  • 服务拆分：按业务功能拆分服务
  • 独立部署：每个服务独立部署和扩展
  • 技术多样性：不同服务可以使用不同技术栈
  • 容错性：单个服务故障不影响整体系统
  • 可扩展性：可以独立扩展高负载服务

1.2 微服务技术栈

  • Spring Cloud：微服务开发框架
  • 服务注册与发现：Eureka、Consul、Nacos
  • 配置中心：Spring Cloud Config、Nacos
  • 服务网关：Spring Cloud Gateway、Zuul
  • 负载均衡：Ribbon、LoadBalancer
  • 熔断器：Hystrix、Resilience4j
  • 消息队列：RabbitMQ、Kafka

1.3 核心依赖

<dependencies>
    <!-- Spring Boot Web -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    <!-- Spring Cloud Starter -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter</artifactId>
    </dependency>
    
    <!-- Eureka Client -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>
    
    <!-- Spring Cloud Config Client -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-config</artifactId>
    </dependency>
    
    <!-- Spring Cloud Gateway -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-gateway</artifactId>
    </dependency>
    
    <!-- OpenFeign -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-openfeign</artifactId>
    </dependency>
    
    <!-- Resilience4j -->
    <dependency>
        <groupId>io.github.resilience4j</groupId>
        <artifactId>resilience4j-spring-boot2</artifactId>
    </dependency>
</dependencies>

2. 服务注册与发现

2.1 Eureka服务端

package com.example.eureka;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

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

application.yml

server:
  port: 8761

eureka:
  instance:
    hostname: localhost
  client:
    register-with-eureka: false
    fetch-registry: false
    service-url:
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/

2.2 Eureka客户端

package com.example.userservice;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

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

application.yml

server:
  port: 8081

spring:
  application:
    name: user-service

eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/
  instance:
    prefer-ip-address: true

3. 服务间通信

3.1 OpenFeign客户端

package com.example.userservice.client;

import com.example.userservice.dto.OrderDto;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import java.util.List;

@FeignClient(name = "order-service")
public interface OrderServiceClient {
    
    @GetMapping("/orders/user/{userId}")
    List<OrderDto> getUserOrders(@PathVariable Long userId);
    
    @GetMapping("/orders/{orderId}")
    OrderDto getOrderById(@PathVariable Long orderId);
}

3.2 服务调用

package com.example.userservice.service;

import com.example.userservice.client.OrderServiceClient;
import com.example.userservice.dto.OrderDto;
import com.example.userservice.dto.UserDto;
import com.example.userservice.entity.User;
import com.example.userservice.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Optional;

@Service
public class UserService {
    
    @Autowired
    private UserRepository userRepository;
    
    @Autowired
    private OrderServiceClient orderServiceClient;
    
    public UserDto getUserWithOrders(Long userId) {
        User user = userRepository.findById(userId)
                .orElseThrow(() -> new RuntimeException("用户不存在"));
        
        List<OrderDto> orders = orderServiceClient.getUserOrders(userId);
        
        UserDto userDto = new UserDto();
        userDto.setId(user.getId());
        userDto.setUsername(user.getUsername());
        userDto.setEmail(user.getEmail());
        userDto.setOrders(orders);
        
        return userDto;
    }
}

4. 服务网关

4.1 Gateway配置

package com.example.gateway;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

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

application.yml

server:
  port: 8080

spring:
  application:
    name: api-gateway
  cloud:
    gateway:
      routes:
        - id: user-service
          uri: lb://user-service
          predicates:
            - Path=/api/users/**
          filters:
            - StripPrefix=2
        - id: order-service
          uri: lb://order-service
          predicates:
            - Path=/api/orders/**
          filters:
            - StripPrefix=2
      globalcors:
        cors-configurations:
          '[/**]':
            allowedOrigins: "*"
            allowedMethods: "*"
            allowedHeaders: "*"

eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/

4.2 自定义过滤器

package com.example.gateway.filter;

import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalGatewayFilter;
import org.springframework.core.Ordered;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

@Component
public class AuthFilter implements GlobalGatewayFilter, Ordered {
    
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        String token = exchange.getRequest().getHeaders().getFirst("Authorization");
        
        if (token == null || !token.startsWith("Bearer ")) {
            exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
            return exchange.getResponse().setComplete();
        }
        
        // 验证token逻辑
        if (!isValidToken(token)) {
            exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
            return exchange.getResponse().setComplete();
        }
        
        return chain.filter(exchange);
    }
    
    private boolean isValidToken(String token) {
        // 实现token验证逻辑
        return true;
    }
    
    @Override
    public int getOrder() {
        return -1;
    }
}

5. 配置中心

5.1 Config Server

package com.example.configserver;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.config.server.EnableConfigServer;

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

application.yml

server:
  port: 8888

spring:
  cloud:
    config:
      server:
        git:
          uri: https://github.com/your-repo/config-repo
          search-paths: config

5.2 Config Client

# bootstrap.yml
spring:
  application:
    name: user-service
  cloud:
    config:
      uri: http://localhost:8888
      fail-fast: true

6. 熔断器

6.1 Resilience4j配置

resilience4j:
  circuitbreaker:
    instances:
      orderService:
        failure-rate-threshold: 50
        wait-duration-in-open-state: 30s
        sliding-window-size: 10
        minimum-number-of-calls: 5
  retry:
    instances:
      orderService:
        max-attempts: 3
        wait-duration: 1s
  timelimiter:
    instances:
      orderService:
        timeout-duration: 3s

6.2 熔断器使用

package com.example.userservice.service;

import com.example.userservice.client.OrderServiceClient;
import io.github.resilience4j.circuitbreaker.annotation.CircuitBreaker;
import io.github.resilience4j.retry.annotation.Retry;
import io.github.resilience4j.timelimiter.annotation.TimeLimiter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.concurrent.CompletableFuture;

@Service
public class ResilientUserService {
    
    @Autowired
    private OrderServiceClient orderServiceClient;
    
    @CircuitBreaker(name = "orderService", fallbackMethod = "getUserOrdersFallback")
    @Retry(name = "orderService")
    @TimeLimiter(name = "orderService")
    public CompletableFuture<List<OrderDto>> getUserOrders(Long userId) {
        return CompletableFuture.supplyAsync(() -> 
            orderServiceClient.getUserOrders(userId));
    }
    
    public CompletableFuture<List<OrderDto>> getUserOrdersFallback(Long userId, Exception ex) {
        // 返回默认订单或缓存数据
        return CompletableFuture.completedFuture(List.of());
    }
}

7. 消息队列

7.1 RabbitMQ配置

spring:
  rabbitmq:
    host: localhost
    port: 5672
    username: guest
    password: guest
    virtual-host: /

7.2 消息生产者

package com.example.userservice.messaging;

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class UserEventPublisher {
    
    @Autowired
    private RabbitTemplate rabbitTemplate;
    
    public void publishUserCreatedEvent(UserCreatedEvent event) {
        rabbitTemplate.convertAndSend("user.exchange", "user.created", event);
    }
    
    public void publishUserUpdatedEvent(UserUpdatedEvent event) {
        rabbitTemplate.convertAndSend("user.exchange", "user.updated", event);
    }
}

7.3 消息消费者

package com.example.orderservice.messaging;

import com.example.orderservice.service.OrderService;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class UserEventConsumer {
    
    @Autowired
    private OrderService orderService;
    
    @RabbitListener(queues = "user.created.queue")
    public void handleUserCreated(UserCreatedEvent event) {
        // 处理用户创建事件
        orderService.createUserProfile(event.getUserId());
    }
    
    @RabbitListener(queues = "user.updated.queue")
    public void handleUserUpdated(UserUpdatedEvent event) {
        // 处理用户更新事件
        orderService.updateUserProfile(event.getUserId(), event.getUserData());
    }
}

8. 分布式追踪

8.1 Sleuth配置

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-sleuth</artifactId>
</dependency>

8.2 追踪配置

spring:
  sleuth:
    sampler:
      probability: 1.0
    zipkin:
      base-url: http://localhost:9411

9. 服务监控

9.1 Actuator配置

management:
  endpoints:
    web:
      exposure:
        include: "*"
  endpoint:
    health:
      show-details: always
  metrics:
    export:
      prometheus:
        enabled: true

9.2 健康检查

package com.example.userservice.health;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.actuate.health.Health;
import org.springframework.boot.actuate.health.HealthIndicator;
import org.springframework.stereotype.Component;

@Component
public class DatabaseHealthIndicator implements HealthIndicator {
    
    @Autowired
    private UserRepository userRepository;
    
    @Override
    public Health health() {
        try {
            userRepository.count();
            return Health.up()
                    .withDetail("database", "Available")
                    .build();
        } catch (Exception e) {
            return Health.down()
                    .withDetail("database", "Unavailable")
                    .withDetail("error", e.getMessage())
                    .build();
        }
    }
}

10. 容器化部署

10.1 Dockerfile

FROM openjdk:17-jdk-slim

WORKDIR /app

COPY target/user-service-1.0.0.jar app.jar

EXPOSE 8081

ENTRYPOINT ["java", "-jar", "app.jar"]

10.2 Docker Compose

version: '3.8'

services:
  eureka-server:
    image: eureka-server:latest
    ports:
      - "8761:8761"
    environment:
      - SPRING_PROFILES_ACTIVE=docker

  user-service:
    image: user-service:latest
    ports:
      - "8081:8081"
    environment:
      - SPRING_PROFILES_ACTIVE=docker
      - EUREKA_CLIENT_SERVICE_URL_DEFAULTZONE=http://eureka-server:8761/eureka/
    depends_on:
      - eureka-server

  order-service:
    image: order-service:latest
    ports:
      - "8082:8082"
    environment:
      - SPRING_PROFILES_ACTIVE=docker
      - EUREKA_CLIENT_SERVICE_URL_DEFAULTZONE=http://eureka-server:8761/eureka/
    depends_on:
      - eureka-server

  api-gateway:
    image: api-gateway:latest
    ports:
      - "8080:8080"
    environment:
      - SPRING_PROFILES_ACTIVE=docker
      - EUREKA_CLIENT_SERVICE_URL_DEFAULTZONE=http://eureka-server:8761/eureka/
    depends_on:
      - eureka-server

11. 总结

Spring Boot微服务架构提供了完整的微服务开发解决方案：

  1. 服务注册与发现：Eureka、Consul等服务注册中心
  2. 服务间通信：OpenFeign、RestTemplate等通信方式
  3. 服务网关：Spring Cloud Gateway统一入口
  4. 配置中心：Spring Cloud Config集中配置管理
  5. 熔断器：Resilience4j、Hystrix容错处理
  6. 消息队列：RabbitMQ、Kafka异步通信
  7. 分布式追踪：Sleuth、Zipkin链路追踪
  8. 服务监控：Actuator、Micrometer监控
  9. 容器化部署：Docker、Kubernetes部署

通过合理使用这些技术，可以构建出高可用、可扩展的微服务系统。

SpringBoot入门实战：SpringBoot与微服务
AI天才研究院
12-21 305
在本文中，我们详细介绍了 Spring Boot 的核心功能和原理，以及如何使用 Spring Boot 开。
微服务springboot详细解析（一）
mzz715的博客
12-03 1354
Spring是一个开源框架，2003 年兴起的一个轻量级的Java 开发框架目的：Spring是为了解决企业级应用开发的复杂性而创建的，简化开发那么Spring是如何简化Java开发的？基于POJO的轻量级和最小侵入性编程通过IOC、DI和面向接口实现松耦合基于切面(AOP)和惯例进行声明式编程通过切面和模版减少样式代码学过javaweb的就知道，开发一个web应用，从最初开始接触Servlet结合Tomcat，在前端跑出一个Hello Wolrld程序，是要经历特别多的步骤；
Spring Boot 与微服务详细总结
m0_61261153的博客
07-19 1323
快速创建独立运行的 Spring 项目，轻松集成主流框架内置 Servlet 容器（如 Tomcat），无需打包为 war 包即可部署提供 starters 机制，实现自动依赖管理与版本控制，减少版本冲突问题大量自动装配功能简化开发流程，同时支持自定义默认配置零 XML 配置、无代码生成，真正实现开箱即用内置准生产环境的运行时监控功能，便于项目运维与云计算天然适配，满足现代部署需求。
Spring Boot 中的微服务架构：原理和使用
徐师兄的博客
07-02 5282
首先，需要定义每个服务的接口。接口应该定义清楚服务提供的功能和输入输出参数。接口可以使用 Java 接口或者 RESTful API 来实现。Spring Boot 中的微服务架构是一种非常灵活、可靠、可扩展的架构模式。它可以带来更高的开发效率、更好的系统可靠性和容错性。在 Spring Boot 中，可以使用各种技术栈来实现微服务架构，例如 Spring Cloud、Feign、Ribbon、Hystrix、Eureka、Zuul 等。
SpringBoot微服务架构学习
yjh_________的博客
06-12 2056
YAML是一种直观的能够被电脑识别的数据序列化格式，并且能够被人阅读，容易和脚本语言交互的，可以被支持YAML库的不同的编程语言程序导入；profile功能就是用来进行动态配置切换的。· 我们的工程继承spring-boot-starter-parent，引入starter之后，通过依赖传递，可以简单方便获得需要的jar包，并且不会存在版本冲突等问题。@ResponseBody 的作用是指该类中所有的API接口返回的数据，对应的方法返回Map或是其他Object，都会以Json字符串的形式返回给客户端。
springboot搭建微服务
qq_41720578的博客
08-19 5124
修改application.properties。
【SpringBoot】SpringBoot：打造现代化微服务架构
Easonmax的博客
06-15 2929
微服务架构是一种设计风格，它将应用程序划分为一组小型、独立部署的服务。这些服务可以独立开发、测试、部署和扩展。每个微服务通常负责特定的业务功能，并通过轻量级的通信协议（通常是HTTP/REST或消息队列）进行交互。
从零到英雄：Spring Boot 微服务架构全攻略
最新发布
一个被知识诅咒的人
11-11 1788
在数字化转型的时代，微服务架构已成为构建可扩展、高可用系统的首选方案。本文以“从零到英雄”为主题，详细指导读者使用Spring Boot快速构建微服务帝国。从基础环境搭建入手，逐步深入到服务发现、配置管理、负载均衡、断路器、API网关、安全认证、监控与部署等核心模块。通过大量代码示例和详细解释，包括中文注释，帮助初学者和中级开发者掌握Spring Boot的核心概念和技术实践。文章强调实际操作，涵盖RESTful API开发、数据库集成、容器化部署等内容，并讨论常见问题与优化策略。无论你是Java开发者还是
【Spring Boot 微服务架构详解】：优雅拆分与部署的必学技巧
![Spring Boot 快速开发实战：从零到上线只需一杯咖啡的时间！...# 1. Spring Boot微服务架构概览 ...## 1.1 Spring Boot微服务架构的出现 随着现代企业应用的复杂性日益增加，传统的单体架构逐渐暴露出难以适应快速迭
spring boot微服务自定义starter原理详解
08-25
Spring Boot 微服务自定义 Starter 是指在 Spring Boot 应用程序中，通过自定义 Starter 来实现微服务架构的自动配置和 Bean 的依赖注入。在本文中，我们将详细介绍 Spring Boot 微服务自定义 Starter 的原理，并...
Spring Boot微服务架构详解：配置、认证、监控
资源摘要信息: "本文件提供了关于使用Spring Boot进行微服务架构设计与开发的详细知识指南。内容覆盖了微服务环境下的多个关键组件，包括认证服务器、Oauth2服务器、配置管理、服务注册与发现、以及服务网关等概念和...
Spring Boot 与 Spring Cloud：微服务架构必备
一名热衷于技术的全栈开发者，专注于前端与后端的全面技术探索。在这里，我将分享我在技术领域的学习与成长，助力更多开发者的进步。
11-08 1756
提供了简化的 Java 应用开发体验，使得创建独立、生产级应用变得简单。Spring Boot 可以快速创建 RESTful 服务，适合用于微服务架构的单个服务。：基于 Spring Boot 之上，提供了微服务体系的分布式基础设施解决方案，如服务注册发现、负载均衡、熔断处理等，解决了分布式架构中的通用问题。两者结合，使得构建、部署和管理微服务变得更加高效。微服务划分：根据业务功能划分微服务，保证服务粒度合适。无状态服务：微服务之间尽量保持无状态性，以便水平扩展。集中配置管理。
微服务基础技能 SpringBoot详解！
SYJ的博客
07-31 4373
微服务基础技能 SpringBoot详解！一片大文章从入门到实战不来看看吗？
Spring Boot框架让你的工程更简便
beautiful_huang的博客
11-17 635
文章目录spring Boot简介Spring Boot 为什么简便Maven工程构建idea 中使用Spring Boot构建项目项目结构介绍引入 web 模块1、pom.xml中添加支持web的模块：2、编写 Controller 内容：3、启动主程序，打开浏览器访问 http://localhost:8080/hello，就可以看到效果了，有木有很简单！如何做单元测试开发环境的调试 spri...
SpringBoot之微服务架构
qq_42338744的博客
03-06 2207
微服务是一种架构风格，它要求我们在开发一个应用的时候，这个应用必须构建成一系列小服务的组合；可以通过http的方式进行互通。
微服务入门：SpringBoot
qq_59463944的博客
10-29 4881
微服务入门：SpringBoot
终于有人用7000字一次性把SpringBoot与微服务给讲明白了！
java_beautiful的博客
06-04 645
微服务架构是一种架构模式，区别于其他系统架构的构建方式和技术方案，微服务架构具有其固有特点。微服务架构的提出者Martin Fowler在其文章“Microservices”中定义了服务组件化、去中心化、基础设施自动化等多个微服务架构特点，正是这些特点为我们使用微服务架构进行系统设计提供了主要的切入点。从实施角度来讲，我们可以基于这些微服务架构的特点提炼出构建微服务架构三大要素，即服务建模、技术体系和研发过程。
在Spring Boot中实现微服务架构最佳实践
聚娃科技开发者博客
07-18 1300
微服务架构是一种将应用程序拆分为多个小型、独立部署的服务的方法，每个服务都负责特定的业务功能。在Java开发中，Spring Boot提供了强大的支持，使得构建和管理微服务变得更加简便。本文介绍了在Spring Boot中实现微服务架构的最佳实践，包括服务注册与发现、配置管理、微服务间通信、容错处理和服务监控与日志。在微服务架构中，服务注册与发现是一个重要的组件。在微服务架构中，配置管理是一个重要的部分。大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

程序员小凯

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值