微服务架构设计实践指南

微服务架构设计详解

本文将深入介绍微服务架构的设计原则和最佳实践，帮助你构建可靠的微服务系统。

服务拆分

领域驱动设计

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


// 用户领域服务
@Service
public class UserDomainService {
    @Autowired
    private UserRepository userRepository;
    
    public User createUser(UserCommand command) {
        // 领域逻辑
        User user = new User(command);
        return userRepository.save(user);
    }
}

// 订单领域服务
@Service
public class OrderDomainService {
    @Autowired
    private OrderRepository orderRepository;
    
    public Order createOrder(OrderCommand command) {
        // 领域逻辑
        Order order = new Order(command);
        return orderRepository.save(order);
    }
}

服务边界定义

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


// 用户服务API
@RestController
@RequestMapping("/api/users")
public class UserController {
    @PostMapping
    public UserDTO createUser(@RequestBody UserCommand command) {
        // API实现
    }
}

// 订单服务API
@RestController
@RequestMapping("/api/orders")
public class OrderController {
    @PostMapping
    public OrderDTO createOrder(@RequestBody OrderCommand command) {
        // API实现
    }
}

服务通信

同步通信

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


// Feign客户端
@FeignClient(name = "user-service")
public interface UserServiceClient {
    @GetMapping("/api/users/{id}")
    UserDTO getUser(@PathVariable("id") String id);
}

// 使用示例
@Service
public class OrderService {
    @Autowired
    private UserServiceClient userServiceClient;
    
    public OrderDTO createOrder(String userId) {
        UserDTO user = userServiceClient.getUser(userId);
        // 处理订单创建
    }
}

异步通信

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


// 消息发布
@Service
public class OrderEventPublisher {
    @Autowired
    private KafkaTemplate<String, OrderEvent> kafkaTemplate;
    
    public void publishOrderCreated(Order order) {
        OrderEvent event = new OrderEvent(order);
        kafkaTemplate.send("order-events", event);
    }
}

// 消息消费
@Service
public class OrderEventConsumer {
    @KafkaListener(topics = "order-events")
    public void handleOrderEvent(OrderEvent event) {
        // 处理订单事件
    }
}

服务发现

Eureka配置

1
2
3
4
5
6
7


# application.yml
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/
  instance:
    preferIpAddress: true

服务注册

1
2
3
4
5
6
7


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

配置管理

Spring Cloud Config

1
2
3
4
5
6
7


# bootstrap.yml
spring:
  cloud:
    config:
      uri: http://config-server:8888
      name: user-service
      profile: prod

配置刷新

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


@RestController
@RefreshScope
public class ConfigController {
    @Value("${app.feature.enabled}")
    private boolean featureEnabled;
    
    @GetMapping("/feature")
    public boolean isFeatureEnabled() {
        return featureEnabled;
    }
}

服务容错

Circuit Breaker模式

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


@Service
public class UserService {
    @HystrixCommand(fallbackMethod = "getDefaultUser")
    public UserDTO getUser(String id) {
        // 调用用户服务
    }
    
    public UserDTO getDefaultUser(String id) {
        return new UserDTO("default");
    }
}

Bulkhead模式

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


@Service
public class OrderService {
    @HystrixCommand(
        threadPoolKey = "orderServicePool",
        threadPoolProperties = {
            @HystrixProperty(name = "coreSize", value = "30"),
            @HystrixProperty(name = "maxQueueSize", value = "10")
        }
    )
    public OrderDTO processOrder(String orderId) {
        // 处理订单
    }
}

API网关

Spring Cloud Gateway配置

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


spring:
  cloud:
    gateway:
      routes:
      - id: user-service
        uri: lb://user-service
        predicates:
        - Path=/api/users/**
        filters:
        - StripPrefix=1

过滤器实现

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


@Component
public class AuthenticationFilter implements GlobalFilter {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // 验证请求
        String token = exchange.getRequest().getHeaders().getFirst("Authorization");
        if (isValidToken(token)) {
            return chain.filter(exchange);
        }
        throw new UnauthorizedException();
    }
}

监控与追踪

Spring Cloud Sleuth

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


@RestController
public class OrderController {
    private static final Logger log = LoggerFactory.getLogger(OrderController.class);
    
    @GetMapping("/orders/{id}")
    public OrderDTO getOrder(@PathVariable String id) {
        log.info("Retrieving order {}", id);
        // 处理请求
    }
}

Prometheus监控

1
2
3
4
5
6
7
8


management:
  endpoints:
    web:
      exposure:
        include: prometheus,health,info
  metrics:
    tags:
      application: ${spring.application.name}

最佳实践

设计原则
- 单一职责
- 服务自治
- 数据隔离
- 接口幂等
开发建议
- 使用API版本控制
- 实现健康检查
- 合理使用缓存
- 做好日志记录

掌握这些微服务架构设计原则，将帮助你构建可扩展、可维护的微服务系统。