Je vois pas mal d'articles sur Spring Framework, mais je ne trouve aucun article sur Spring Integration, probablement parce que ce n'est pas un article majeur au Japon, donc j'aimerais le publier de manière irrégulière. (Je ne dis pas que je posterai: lunettes de soleil :)
TcpOutBoundGateway.Le «handleRequestMessage» du «TcpOutboundGateway». Dans cette méthode, le message est envoyé au serveur en utilisant le "TcpConnection" obtenu à partir de "ClientConnectionFactory".
↓ Émetteur de message TcpOutboundGateway (partiellement omis)
TcpOutboundGateway.java
protected Object handleRequestMessage(Message<?> requestMessage) {
TcpConnection connection = null;
String connectionId = null;
try {
connection = this.connectionFactory.getConnection();
AsyncReply reply = new AsyncReply(this.remoteTimeoutExpression.getValue(this.evaluationContext,
requestMessage, Long.class));
connectionId = connection.getConnectionId();
this.pendingReplies.put(connectionId, reply);
if (logger.isDebugEnabled()) {
logger.debug("Added pending reply " + connectionId);
}
connection.send(requestMessage);
Normalement, il n'est pas nécessaire de vérifier lors de l'envoi, mais selon le cas, il peut y avoir une exigence telle que «surveiller l'état d'un composant et ne pas envoyer de message en fonction de l'état». C'est l'accord sur lequel je travaille en ce moment: v:
Pour le moment, il y a deux méthodes que j'ai proposées.
Eh bien, c'est une idée simple ...
Étendez TcpOutboundGateway pour remplacer handleRequestMessage.
Le traitement d'envoi est effectué uniquement lorsque la valeur de retour de getStatus est true.
CustomizedTcpOutboundGateway.java
public class CustomizedTcpOutboundGateway extends TcpOutboundGateway {
@Override
public Object handleRequestMessage(Message<?> message) {
if (getStatus()) {
return super.handleRequestMessage(message);
} else {
return new GenericMessage<String>("can not send");
}
}
La valeur de retour de l'original handleRequestMessage est de type ʻObject, mais dans le cas d'un système normal, le message reçu est retourné, donc un objet Message` approprié est renvoyé. Cela dépend de vos besoins.
Vous pouvez utiliser la méthode ci-dessus, mais si vous ne voulez pas trop étendre les classes du framework, il existe un moyen d'utiliser ʻInterceptor`. La procédure est la suivante.
Tout d'abord, étendez TcpConnectionInterceptor et insérez un processus de vérification lors de l'envoi d'un message.
TcpConnectionInterceptor.java
public class TcpConnectionInterceptor extends TcpConnectionInterceptorSupport {
@Override
public void send(Message<?> message) throws Exception {
if (getStatus()) {
super.send(message);
}
}
//Abréviation
Envoyez un message avec la valeur de getStatus (). Puisque TcpConnectionInterceptorSupport a plusieurs méthodes autour de la connexion, il est possible d'insérer le traitement à des moments autres qu'avant l'envoi comme cette fois: hugging:.
Ensuite, créez une classe qui implémente le TcpConnectionInterceptorFactory qui renvoie le TcpConnectionInterceptor que vous venez de créer. La mise en œuvre est appropriée.
CustomizedTcpConnectionInterceptorFactory.java
public class CustomizedTcpConnectionInterceptorFactory implements TcpConnectionInterceptorFactory {
private final TcpConnectionInterceptorSupport interceptor;
public CustomizedTcpConnectionInterceptorFactory(TcpConnectionInterceptorSupport interceptor) {
this.interceptor = interceptor;
}
@Override
public TcpConnectionInterceptorSupport getInterceptor() {
return interceptor;
}
}
Après cela, transmettez-le à TcpConnectionInterceptorFactoryChain et définissez-le sur ClientConnectionFactory.
<int-ip:tcp-connection-factory type="client" host="localhost" port="56789"
deserializer="deserializer" serializer="serializer" interceptor-factory-chain="interceptorFactoryChain" />
<bean id="interceptorFactoryChain"
class="org.springframework.integration.ip.tcp.connection.TcpConnectionInterceptorFactoryChain">
<property name="interceptors">
<array>
<bean
class="com.neriudon.sample.interceptor.CustomizedTcpConnectionInterceptorFactory"
c:interceptor-ref="tcpConnectionInterceptor" />
</array>
</property>
</bean>
<bean id="tcpConnectionInterceptor"
class="com.neriudon.sample.interceptor.TcpConnectionInterceptor" />
Les paramètres ClientConnectionFactory sont appropriés. : froncer les sourcils2:
Cette méthode est un peu compliquée, mais est-ce un avantage de ne pas jouer avec la passerelle d'origine?
En mémoire car cette fonction était nécessaire pour le projet dans lequel je suis actuellement impliqué.
Même si vous recherchez sur Google avec le nom de classe Spring Integration, il existe de nombreux cas où les sites japonais ne sont pas accessibles, alors essayez également Spring Integration. : kissing_heart: