ساخت میکروسرویس های واکنشی: راهنمای گام به گام

public class MonolithicApp {
    public static void main(String[] args) {
        UserService userService = new UserService();
        OrderService orderService = new OrderService(userService);

        Order order = orderService.createOrder("user123", "product456");
        System.out.println(order);
    }
}

// User.java
public class User {
    private String id;
    private String name;
    // getters and setters
}

// UserService.java
@Service
public class UserService {
    private final Map<String, User> users = new ConcurrentHashMap<>();

    public Mono<User> getUserById(String id) {
        return Mono.justOrEmpty(users.get(id));
    }

    public Mono<User> createUser(User user) {
        users.put(user.getId(), user);
        return Mono.just(user);
    }
}

// UserController.java
@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public Mono<ResponseEntity<User>> getUser(@PathVariable String id) {
        return userService.getUserById(id)
                .map(ResponseEntity::ok)
                .defaultIfEmpty(ResponseEntity.notFound().build());
    }

    @PostMapping
    public Mono<User> createUser(@RequestBody User user) {
        return userService.createUser(user);
    }
}

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

// Order.java
public class Order {
    private String orderId;
    private String userId;
    private String productId;
    // getters and setters
}

// OrderService.java
@Service
public class OrderService {
    private final WebClient webClient;

    public OrderService(WebClient.Builder webClientBuilder) {
        this.webClient = webClientBuilder.baseUrl("http://localhost:8080").build();
    }

    public Mono<Order> createOrder(String userId, String productId) {
        return webClient.get()
                .uri("/users/{id}", userId)
                .retrieve()
                .bodyToMono(User.class)
                .map(user -> {
                    Order order = new Order();
                    order.setUserId(user.getId());
                    order.setProductId(productId);
                    order.setOrderId(UUID.randomUUID().toString());
                    return order;
                });
    }
}

// OrderController.java
@RestController
@RequestMapping("/orders")
public class OrderController {
    private final OrderService orderService;

    public OrderController(OrderService orderService) {
        this.orderService = orderService;
    }

    @PostMapping
    public Mono<Order> createOrder(@RequestParam String userId, @RequestParam String productId) {
        return orderService.createOrder(userId, productId);
    }
}

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

@Bean
public WebClient.Builder webClientBuilder() {
    return WebClient.builder();
}

// OrderService.java
@Service
public class OrderService {
    private final WebClient webClient;
    private final CircuitBreaker circuitBreaker;

    public OrderService(WebClient.Builder webClientBuilder, CircuitBreakerRegistry circuitBreakerRegistry) {
        this.webClient = webClientBuilder.baseUrl("http://localhost:8080").build();
        this.circuitBreaker = circuitBreakerRegistry.circuitBreaker("userService");
    }

    public Mono<Order> createOrder(String userId, String productId) {
        return Mono.fromCallable(() -> circuitBreaker.executeSupplier(() ->
                webClient.get()
                        .uri("/users/{id}", userId)
                        .retrieve()
                        .bodyToMono(User.class)
                        .block()))
                .map(user -> {
                    Order order = new Order();
                    order.setUserId(user.getId());
                    order.setProductId(productId);
                    order.setOrderId(UUID.randomUUID().toString());
                    return order;
                });
    }
}

// Add dependencies for micrometer and prometheus
dependencies {
    implementation 'io.micrometer:micrometer-core'
    implementation 'io.micrometer:micrometer-registry-prometheus'
}

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

// KafkaProducerConfig.java
@Configuration
public class KafkaProducerConfig {

    @Bean
    public ProducerFactory<String, Order> producerFactory() {
        Map<String, Object> configProps = new HashMap<>();
        configProps.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
        configProps.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        configProps.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, JsonSerializer.class);
        return new DefaultKafkaProducerFactory<>(configProps);
    }

    @Bean
    public KafkaTemplate<String, Order> kafkaTemplate() {
        return new KafkaTemplate<>(producerFactory());
    }
}

// KafkaConsumerConfig.java
@Configuration
public class KafkaConsumerConfig {

    @Bean
    public ConsumerFactory<String, Order> consumerFactory() {
        Map<String, Object> configProps = new HashMap<>();
        configProps.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
        configProps.put(ConsumerConfig.GROUP_ID_CONFIG, "group_id");
        configProps.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        configProps.put(ConsumerConfig.VALUE_DES

ERIALIZER_CLASS_CONFIG, JsonDeserializer.class);
        configProps.put(JsonDeserializer.TRUSTED_PACKAGES, "*");
        return new DefaultKafkaConsumerFactory<>(configProps);
    }

    @Bean
    public ConcurrentKafkaListenerContainerFactory<String, Order> kafkaListenerContainerFactory() {
        ConcurrentKafkaListenerContainerFactory<String, Order> factory = new ConcurrentKafkaListenerContainerFactory<>();
        factory.setConsumerFactory(consumerFactory());
        return factory;
    }
}

// OrderProducer.java
@Service
public class OrderProducer {

    private final KafkaTemplate<String, Order> kafkaTemplate;

    public OrderProducer(KafkaTemplate<String, Order> kafkaTemplate) {
        this.kafkaTemplate = kafkaTemplate;
    }

    public void sendOrder(Order order) {
        kafkaTemplate.send("orders", order);
    }
}

// OrderConsumer.java
@Service
public class OrderConsumer {

    @KafkaListener(topics = "orders", groupId = "group_id")
    public void consume(Order order) {
        System.out.println("Consumed order: " + order);
    }
}

// OrderService.java
@Service
public class OrderService {
    private final WebClient webClient;
    private final CircuitBreaker circuitBreaker;

    public OrderService(WebClient.Builder webClientBuilder, CircuitBreakerRegistry circuitBreakerRegistry) {
        this.webClient = webClientBuilder.baseUrl("http://localhost:8080").build();
        this.circuitBreaker = circuitBreakerRegistry.circuitBreaker("userService");
    }

    public Mono<Order> createOrder(String userId, String productId) {
        return Mono.fromCallable(() -> circuitBreaker.executeSupplier(() ->
                webClient.get()
                        .uri("/users/{id}", userId)
                        .retrieve()
                        .bodyToMono(User.class)
                        .block()))
                .map(user -> {
                    Order order = new Order();
                    order.setUserId(user.getId());
                    order.setProductId(productId);
                    order.setOrderId(UUID.randomUUID().toString());
                    return order;
                });
    }
}

// EventStore.java
public class EventStore {
    private final List<Event> events = new ArrayList<>();

    public void save(Event event) {
        events.add(event);
    }

    public List<Event> getEvents() {
        return new ArrayList<>(events);
    }
}

// C# example using CQRS
public class Command {
    public string Data { get; set; }
}

public class Query {
    public string Criteria { get; set; }
}

public interface ICommandHandler<T> {
    void Handle(T command);
}

public interface IQueryHandler<T, R> {
    R Handle(T query);
}

public class CommandHandler : ICommandHandler<Command> {
    public void Handle(Command command) {
        // Handle the command
    }
}

public class QueryHandler : IQueryHandler<Query, string> {
    public string Handle(Query query) {
        // Handle the query and return result
        return "Result";
    }
}