Java微服务架构入门

什么是微服务

微服务是一种架构风格，将单体应用拆分为一组小型、独立部署的服务，每个服务运行在自己的进程中，通过轻量级机制通信。

微服务架构图

┌─────────────────────────────────────────────────────┐
│                    API Gateway                       │
├─────────────────────────────────────────────────────┤
│  User Service  │ Order Service │ Product Service     │
├─────────────────────────────────────────────────────┤
│           Service Discovery (Nacos/Eureka)           │
├─────────────────────────────────────────────────────┤
│  Config Center │ Message Queue │ Distributed Lock   │
└─────────────────────────────────────────────────────┘

设计原则

// 1. 单一职责
@Service
public class UserService { /* 只处理用户相关 */ }

@Service
public class OrderService { /* 只处理订单相关 */ }

// 2. 服务自治
// 每个服务独立数据库
// UserService → user_db
// OrderService → order_db

// 3. 轻量级通信
// REST / gRPC / 消息队列

// 4. 容错设计
// 熔断、降级、限流

Spring Boot构建微服务

@SpringBootApplication
@RestController
@RequestMapping("/api/users")
public class UserServiceApplication {

    @Autowired
    private UserRepository userRepository;

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

    @GetMapping("/{id}")
    public User getUser(@PathVariable Long id) {
        return userRepository.findById(id)
            .orElseThrow(() -> new RuntimeException("用户不存在"));
    }

    @PostMapping
    public User createUser(@RequestBody User user) {
        return userRepository.save(user);
    }
}

服务间通信

REST调用

@Configuration
public class RestTemplateConfig {
    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

@Service
public class OrderService {
    @Autowired
    private RestTemplate restTemplate;

    public Order createOrder(Long userId, BigDecimal amount) {
        // 调用用户服务
        User user = restTemplate.getForObject(
            "http://user-service/api/users/" + userId, User.class);

        Order order = new Order();
        order.setUserId(userId);
        order.setUserName(user.getName());
        order.setAmount(amount);
        return orderRepository.save(order);
    }
}

Feign声明式调用

@FeignClient(name = "user-service", fallbackFactory = UserClientFallbackFactory.class)
public interface UserClient {
    @GetMapping("/api/users/{id}")
    User getUser(@PathVariable("id") Long id);
}

@Component
public class UserClientFallbackFactory implements FallbackFactory<UserClient> {
    @Override
    public UserClient create(Throwable cause) {
        return new UserClient() {
            @Override
            public User getUser(Long id) {
                User user = new User();
                user.setName("默认用户");
                return user;
            }
        };
    }
}

@Service
public class OrderServiceFeign {
    @Autowired
    private UserClient userClient;

    public Order createOrder(Long userId, BigDecimal amount) {
        User user = userClient.getUser(userId);
        // 创建订单...
    }
}

API Gateway

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

// routes.yml
spring:
  cloud:
    gateway:
      routes:
        - id: user-service
          uri: lb://user-service
          predicates:
            - Path=/api/users/**
        - id: order-service
          uri: lb://order-service
          predicates:
            - Path=/api/orders/**

配置中心

// Nacos配置
@RefreshScope
@RestController
public class ConfigController {
    @Value("${app.feature.enabled:false}")
    private boolean featureEnabled;

    @GetMapping("/config")
    public Map<String, Object> getConfig() {
        return Map.of("featureEnabled", featureEnabled);
    }
}

服务发现

// Nacos服务注册
spring:
  application:
    name: user-service
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848

// 服务调用
RestTemplate restTemplate = new RestTemplate();
User user = restTemplate.getForObject(
    "http://user-service/api/users/1", User.class);

熔断降级

@Component
public class UserClientFallback implements UserClient {
    @Override
    public User getUser(Long id) {
        return new User(id, "降级用户", "降级数据");
    }
}

// Resilience4j熔断
@CircuitBreaker(name = "user-service", fallbackMethod = "getUserFallback")
public User getUser(Long id) {
    return restTemplate.getForObject(
        "http://user-service/api/users/" + id, User.class);
}

public User getUserFallback(Long id, Exception e) {
    return new User(id, "默认用户", "服务暂时不可用");
}

总结

微服务架构需要配套的基础设施：服务发现、配置中心、网关、熔断器等。Spring Cloud提供了完整的解决方案，适合构建企业级微服务系统。