Какие знаешь виды Router в Java?

Виды Router в Java

Router в Java-приложениях — это компонент, который маршрутизирует запросы на соответствующие обработчики (handlers, контроллеры). Рассмотрим основные типы роутеров в разных контекстах.

1. Web Framework Routers

Spring MVC Router (с использованием RequestMapping)

@RestController
@RequestMapping("/api/v1/users")
public class UserController {
    @GetMapping
    public List<User> getAllUsers() { }
    
    @GetMapping("/{id}")
    public User getUser(@PathVariable Long id) { }
    
    @PostMapping
    public User createUser(@RequestBody User user) { }
    
    @PutMapping("/{id}")
    public User updateUser(@PathVariable Long id, @RequestBody User user) { }
    
    @DeleteMapping("/{id}")
    public void deleteUser(@PathVariable Long id) { }
}

Spring WebFlux Router (функциональный подход)

@Configuration
public class UserRoutes {
    @Bean
    public RouterFunction<ServerResponse> route(UserHandler handler) {
        return RouterFunctions
            .route(GET("/users"), handler::getAllUsers)
            .andRoute(GET("/users/{id}"), handler::getUser)
            .andRoute(POST("/users"), handler::createUser)
            .andRoute(PUT("/users/{id}"), handler::updateUser)
            .andRoute(DELETE("/users/{id}"), handler::deleteUser);
    }
}

@Component
public class UserHandler {
    public Mono<ServerResponse> getAllUsers(ServerRequest request) { }
    public Mono<ServerResponse> getUser(ServerRequest request) { }
}

2. HTTP Router (Netty, Undertow)

// Пример с Netty
public class NettyRouter {
    public static void main(String[] args) {
        HttpServer httpServer = HttpServer.create()
            .port(8080)
            .route(routes ->
                routes
                    .get("/users", (request, response) -> 
                        response.sendString(Mono.just("GET users")))
                    .post("/users", (request, response) ->
                        response.sendString(Mono.just("POST users")))
                    .get("/users/{id}", (request, response) ->
                        response.sendString(Mono.just(
                            "GET user " + request.getParameter("id"))))
            )
            .bindNow()
            .onDispose()
            .block();
    }
}

3. WebSocket Router

@Configuration
public class WebSocketConfig {
    @Bean
    public WebSocketHandlerAdapter webSocketHandlerAdapter() {
        return new WebSocketHandlerAdapter();
    }
    
    @Bean
    public HandlerMapping webSocketMapping() {
        Map<String, WebSocketHandler> map = new HashMap<>();
        map.put("/ws/chat", new ChatWebSocketHandler());
        map.put("/ws/notifications", new NotificationWebSocketHandler());
        
        SimpleUrlHandlerMapping mapping = new SimpleUrlHandlerMapping();
        mapping.setUrlMap(map);
        mapping.setOrder(1);
        return mapping;
    }
}

public class ChatWebSocketHandler implements WebSocketHandler {
    @Override
    public Mono<Void> handle(WebSocketSession session) {
        return session.receive()
            .map(WebSocketMessage::getPayloadAsText)
            .subscribe(System.out::println);
    }
}

4. Message Router (для асинхронной обработки)

@Configuration
public class MessageRouterConfig {
    @Bean
    public IntegrationFlow messageRouterFlow() {
        return IntegrationFlows
            .from("inputChannel")
            .route(message -> {
                String type = message.getHeaders().get("type", String.class);
                if ("email".equals(type)) {
                    return "emailChannel";
                } else if ("sms".equals(type)) {
                    return "smsChannel";
                }
                return "defaultChannel";
            })
            .get();
    }
}

@Service
public class MessageRouter {
    public void route(Message message) {
        String destination = determineDestination(message.getType());
        send(message, destination);
    }
    
    private String determineDestination(String type) {
        switch (type) {
            case "EMAIL":
                return "emailService";
            case "SMS":
                return "smsService";
            case "PUSH":
                return "pushService";
            default:
                return "logService";
        }
    }
}

5. RPC Router (для удаленных вызовов)

@Service
public class RpcRouter {
    private final Map<String, RpcHandler> handlers = new ConcurrentHashMap<>();
    
    public RpcRouter() {
        handlers.put("user.create", new UserCreateHandler());
        handlers.put("user.getById", new UserGetHandler());
        handlers.put("order.create", new OrderCreateHandler());
    }
    
    public Object handle(RpcRequest request) throws Exception {
        RpcHandler handler = handlers.get(request.getMethod());
        if (handler == null) {
            throw new RpcMethodNotFoundException(request.getMethod());
        }
        return handler.handle(request.getParams());
    }
}

public interface RpcHandler {
    Object handle(Map<String, Object> params) throws Exception;
}

6. Content-based Router

@Service
public class ContentRouter {
    public void routeByContentType(Message message) {
        String contentType = message.getContentType();
        
        if (contentType.startsWith("application/json")) {
            handleJson(message);
        } else if (contentType.startsWith("application/xml")) {
            handleXml(message);
        } else if (contentType.startsWith("image/")) {
            handleImage(message);
        } else {
            handleDefault(message);
        }
    }
}

7. Topic-based Router (Pub/Sub)

@Configuration
public class TopicRouter {
    @Bean
    public MessageListenerContainer messageListenerContainer(
            ConnectionFactory connectionFactory) {
        MessageListenerAdapter adapter = new MessageListenerAdapter(
            new TopicSubscriber()
        );
        
        SimpleMessageListenerContainer container = 
            new SimpleMessageListenerContainer();
        container.setConnectionFactory(connectionFactory);
        container.setDestination(new Topic("events"));
        container.setMessageListener(adapter);
        return container;
    }
}

public class TopicSubscriber {
    @JmsListener(destination = "user.created")
    public void handleUserCreated(UserCreatedEvent event) { }
    
    @JmsListener(destination = "order.placed")
    public void handleOrderPlaced(OrderPlacedEvent event) { }
}

8. gRPC Router

@Configuration
public class GrpcServerConfig {
    @Bean
    public GrpcServerConfigurer grpcServerConfigurer(
            UserServiceImpl userService) {
        return serverBuilder ->
            serverBuilder.addService(userService);
    }
}

@GrpcService
public class UserServiceImpl extends UserServiceGrpc.UserServiceImplBase {
    @Override
    public void getUser(GetUserRequest request,
            StreamObserver<User> responseObserver) {
        User user = userRepository.findById(request.getId());
        responseObserver.onNext(user);
        responseObserver.onCompleted();
    }
}

9. Сравнение типов Router

Итог

В Java существует множество типов роутеров в зависимости от контекста и архитектуры приложения. Основные это:

• Spring MVC Router для traditionalных REST APIs
• Spring WebFlux Router для реактивных приложений
• Message Router для асинхронных систем
• WebSocket Router для real-time коммуникации
• RPC Router для микросервисной архитектуры

Выбор зависит от требований приложения, типа коммуникации и архитектурных решений.