Is it somehow possible to use Spring's RSocket integration in a "traditional" servlet-based Spring application without having to sacrifice functionality that Spring offers according to the documentation if you do not mix the two variants?

如果您不混合这两种变体，有没有可能在“传统的”基于Servlet的Spring应用程序中使用Spring的RSocket集成，而不必根据文档牺牲Spring提供的功能？

If so, how? Are there any pitfalls to be aware of?

如果是这样的话，是如何做到的呢？有什么陷阱需要注意吗？

The objective would be to allow an existing Servlet-based Spring application to talk to various clients over RSocket. A fully reactive experience with backpressure is neither expected nor necessary on the server side. Having to start a separate Netty-based server that runs alongside the servlet container is okay and expected.

其目标是允许现有的基于Servlet的Spring应用程序通过RSocket与各种客户端进行对话。服务器端既不需要也不需要完全应对背压的体验。必须启动一个单独的基于Netty的服务器并与Servlet容器一起运行，这是可以接受的，也是意料之中的。

To address questions raised in the comments, there is some functionality I am especially concerned about:

为了解决评论中提出的问题，我特别关注一些功能：

• Does declarative transaction support work for requests that come in via RSocket without having to use R2DBC? According to Reactive Transactions with Spring imperative and reactive transaction management differ significantly.


• Does Spring Security "just" work? Or is special configuration necessary, for example, to use @PreAuthorize on methods that are invoked by the servlet-based parts and the RSocket-based parts of the application?

Yes, it is possible to use Spring's RSocket integration in a traditional Servlet-based Spring application without sacrificing declarative transaction support or Spring Security integration. Spring provides flexibility and modularity, allowing you to mix different technologies and features based on your requirements. You can run a separate Netty-based RSocket server alongside your existing servlet-based Spring application. Here's how you can achieve this:

是的，可以在传统的基于Servlet的Spring应用程序中使用Spring的RSocket集成，而不牺牲声明性事务支持或Spring Security集成。Spring提供了灵活性和模块化，允许您根据需求混合不同的技术和功能。您可以在现有的基于Servlet的Spring应用程序旁边运行单独的基于Netty的RSocket服务器。以下是如何实现这一点的方法：

Create an RSocket Server Configuration:

创建RSocket服务器配置：

Start by creating an RSocket server configuration class. This class will define your RSocket server and how it handles incoming requests.

首先创建一个RSocket服务器配置类。这个类将定义RSocket服务器以及它如何处理传入的请求。

@Configuration
public class RSocketServerConfig {

    @Bean
    public RSocketServer rSocketServer() {
        return RSocketServer.create();
    }

    @Bean
    public RSocketMessageHandler messageHandler() {
        RSocketMessageHandler handler = new RSocketMessageHandler();
        handler.setRSocketStrategies(rSocketStrategies());
        return handler;
    }

    @Bean
    public RSocketStrategies rSocketStrategies() {
        return RSocketStrategies.builder().build();
    }
}

Define Your RSocket Controllers:

定义您的RSocket控制器：

Create RSocket controllers similar to how you create Spring MVC controllers. These controllers will handle incoming RSocket requests. For example:

创建RSocket控制器的方法与创建Spring MVC控制器的方式类似。这些控制器将处理传入的RSocket请求。例如：

@Controller
public class RSocketController {

    @MessageMapping("your.rsocket.route")
    public Mono<String> handleRSocketRequest(String request) {
        // Handle the request here
        return Mono.just("Response");
    }
}

Enable RSocket in Your Application:

在您的应用程序中启用RSocket：

You need to enable RSocket in your Spring application. To do this, add the @EnableRSocket annotation to one of your configuration classes:

您需要在您的Spring应用程序中启用RSocket。为此，将@EnableRSocket注释添加到您的一个配置类中：

@SpringBootApplication
@EnableRSocket
public class YourServletBasedApplication {

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

Configure Spring Security:

配置Spring安全：

If you have Spring Security configured in your application, ensure that you also secure your RSocket endpoints appropriately. You can use Spring Security's features to secure your RSocket controllers.

如果您在应用程序中配置了Spring Security，请确保您还适当地保护RSocket端点。您可以使用Spring Security的功能来保护您的RSocket控制器。

Transaction Management:

交易管理：

Spring's transaction management should work as expected in your servlet-based Spring application. Ensure that your RSocket controllers are within the transaction boundaries when necessary, and configure your transaction manager accordingly.

在基于Servlet的Spring应用程序中，Spring的事务管理应该按预期工作。确保您的RSocket控制器在必要时位于事务边界内，并相应地配置您的事务管理器。

Pitfalls to Be Aware Of:

要注意的陷阱：

Concurrency: Be mindful of the concurrency model of your servlet-based Spring application and ensure that RSocket interactions don't cause contention or concurrency issues.

并发性：注意基于Servlet的Spring应用程序的并发模型，并确保RSocket交互不会导致争用或并发问题。

Resource Management: Managing resources (e.g., database connections, thread pools) between the servlet-based application and the RSocket server should be done carefully to avoid resource exhaustion or contention.

资源管理：应仔细管理基于Servlet的应用程序和RSocket服务器之间的资源(例如，数据库连接、线程池)，以避免资源耗尽或争用。

Cross-Origin Resource Sharing (CORS): If your RSocket clients are web-based, you may need to handle CORS settings appropriately to allow RSocket connections from different origins.

跨域资源共享(CORS)：如果您的RSocket客户端是基于Web的，您可能需要适当处理CORS设置以允许来自不同来源的RSocket连接。

Error Handling: Implement robust error handling for your RSocket controllers to handle failures gracefully.

错误处理：为RSocket控制器实现健壮的错误处理，以优雅地处理故障。

Remember that while you're integrating RSocket into your servlet-based Spring application, the level of reactivity and backpressure handling is up to you. You can keep your servlet-based code as is and provide a more traditional request-response experience over RSocket if that fits your requirements.

请记住，当您将RSocket集成到基于Servlet的Spring应用程序中时，反应性和反压力处理的级别取决于您。您可以保持基于Servlet的代码不变，并通过RSocket提供更传统的请求-响应体验(如果这符合您的需求)。