Sicherstellung unabhängiger Verbindungen für Threads in der Federintegration TCP ⇐ Java

[Anonymous]

[Problem] < /p>
Wir stehen vor einem Problem, bei dem eine in einem Thread erstellte Verbindung mit einem anderen Thread geteilt wird. Dies geschieht, obwohl jede Anforderung eine eigene unabhängige Verbindung haben sollte. geteilt. 2.1.0
[*] JDK 1.8
Unten ist unser TCPClientConfig-Code:

Code: Select all

@EnableIntegration
@Configuration
@RequiredArgsConstructor
@Slf4j
@ComponentScan
public class TcpClientConfig implements ApplicationEventPublisherAware {

private final Properties properties;
private static final long TIMEOUT = 20000L;
private ApplicationEventPublisher applicationEventPublisher;

@Override
public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
this.applicationEventPublisher = applicationEventPublisher;
}

@Bean
public AbstractClientConnectionFactory clientConnectionFactory() {
TcpNioClientConnectionFactory tcpNioClientConnectionFactory = new TcpNioClientConnectionFactory(properties.getIp(), properties.getPort());
tcpNioClientConnectionFactory.setUsingDirectBuffers(true);
tcpNioClientConnectionFactory.setSingleUse(true);
tcpNioClientConnectionFactory.setSerializer(new ByteArrayCrSerializer());
tcpNioClientConnectionFactory.setDeserializer(new ByteArrayCrSerializer());
tcpNioClientConnectionFactory.setApplicationEventPublisher(applicationEventPublisher);
return tcpNioClientConnectionFactory;
}

public void closeConnection() throws Exception {
try {
TcpConnectionSupport oldConnection = clientConnectionFactory().getConnection();
if (oldConnection != null) {
oldConnection.close();
}
} catch (Exception e){
throw new Exception("error", e);
}
}

@Bean
public MessageChannel outboundChannel() {
return new DirectChannel();
}

@Bean
public QueueChannel inboundChannel() {
return new QueueChannel();
}

@Bean
@ServiceActivator(inputChannel = "outboundChannel")
public MessageHandler outboundGateway(AbstractClientConnectionFactory clientConnectionFactory) {
TcpOutboundGateway tcpOutboundGateway = new TcpOutboundGateway();
tcpOutboundGateway.setConnectionFactory(clientConnectionFactory);
tcpOutboundGateway.setRequestTimeout(TIMEOUT);
tcpOutboundGateway.setRemoteTimeout(TIMEOUT);
tcpOutboundGateway.setReplyChannel(inboundChannel());
return tcpOutboundGateway;
}

@EventListener
public void handleTcpConnectionEvent(TcpConnectionOpenEvent event) {
log.info("============================== TCP Connection Opened : {} ==============================", event.getConnectionId());
}

@EventListener
public void handleTcpConnectionCloseEvent(TcpConnectionCloseEvent event) {
log.info("============================== TCP Connection Closed : {} ==============================", event.getConnectionId());
}
}

Und hier ist der aufrufende Code:
@Service
@Slf4j
@RequiredArgsConstructor
@ComponentScan
public class TcpMessageService {

private final TcpClientConfig tcpClientConfig;

public void sendMessage(byte[] tcpData) {
Message message = MessageBuilder.withPayload(tcpData).build();
tcpClientConfig.outboundChannel().send(message);
}

public void sendAck() {
try (ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream()) {
ByteArrayCrSerializer serializer = new ByteArrayCrSerializer();
serializer.serialize(ACK.getBytes(StandardCharsets.UTF_8), byteArrayOutputStream);
byte[] serializedAck = byteArrayOutputStream.toByteArray();

Message ackMessage = MessageBuilder.withPayload(serializedAck).build();
tcpClientConfig.outboundChannel().send(ackMessage);

} catch (IOException e) {
log.error("error", e);
}
}

public Message receiveMessage() {
return tcpClientConfig.inboundChannel().receive(TIMEOUT);
}
}
< /code>
[gewünschte Lösung] < /p>
Wir benötigen einen Weg, um sicherzustellen, dass jeder Thread seine eigene Verbindung erstellt und verwendet, ohne sie mit anderen Threads zu teilen. Jede neue Anfrage aus einem anderen Thread sollte immer eine neue Verbindung herstellen, die völlig unabhängig von früheren Verbindungen ist. Alle Vorschläge oder alternativen Ansätze wären sehr geschätzt!