spring-integration Tutorial
Comenzando con la integración de primavera

Observaciones

Versiones

Instalación o configuración

La mejor manera de comenzar a utilizar Spring-Integration en su proyecto es con un sistema de administración de dependencias, como gradle.

dependencies {
    compile 'org.springframework.integration:spring-integration-core:4.3.5.RELEASE'
}

A continuación se muestra un ejemplo muy simple que utiliza los puntos finales de mensaje de activador de servicio , puerta de enlace .

//these annotations will enable Spring integration and scan for components
@Configuration
@EnableIntegration
@IntegrationComponentScan
public class Application {
    //a channel has two ends, this Messaging Gateway is acting as input from one side of inChannel
    @MessagingGateway
    interface Greeting {
        @Gateway(requestChannel = "inChannel")
        String greet(String name);
    }

    @Component
    static class HelloMessageProvider {
        //a service activator act as a handler when message is received from inChannel, in this example, it is acting as the handler on the output side of inChannel
        @ServiceActivator(inputChannel = "inChannel")
        public String sayHello(String name) {
            return "Hi, " + name;
        }
    }

    @Bean
    MessageChannel inChannel() {
        return new DirectChannel();
    }

    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(Application.class);
        Greeting greeting = context.getBean(Greeting.class);
        //greeting.greet() send a message to the channel, which trigger service activitor to process the incoming message
        System.out.println(greeting.greet("Spring Integration!"));
    }
}

Se mostrará la cadena Hi, Spring Integration! en la consola

Por supuesto, Spring Integration también proporciona una configuración de estilo xml. Para el ejemplo anterior, puede escribir el siguiente archivo de configuración XML.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:int="http://www.springframework.org/schema/integration"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/integration
        http://www.springframework.org/schema/integration/spring-integration.xsd">
    <int:gateway default-request-channel="inChannel"
                 service-interface="spring.integration.stackoverflow.getstarted.Application$Greeting"/>
    <int:channel id="inChannel"/>
    <int:service-activator input-channel="inChannel" method="sayHello">
        <bean class="spring.integration.stackoverflow.getstarted.Application$HelloMessageProvider"/>
    </int:service-activator>
</beans>

Para ejecutar la aplicación utilizando el archivo de configuración xml, debe cambiar el código new AnnotationConfigApplicationContext(Application.class) en la clase de Application a new ClassPathXmlApplicationContext("classpath:getstarted.xml") . Y ejecuta esta aplicación otra vez, puedes ver el mismo resultado.

Adaptador de canal entrante y saliente genérico

El adaptador de canal es uno de los puntos finales del mensaje en Spring Integration. Se utiliza para el flujo de mensajes unidireccionales. Hay dos tipos de adaptador de canal:

Adaptador de entrada: lado de entrada del canal. Escucha o lee activamente el mensaje.

Adaptador de salida: lado de salida del canal. Enviar mensaje a la clase Java o al sistema o protocolo externo.

• Código fuente.

  public class Application {
      static class MessageProducer {
          public String produce() {
              String[] array = {"first line!", "second line!", "third line!"};
              return array[new Random().nextInt(3)];
          }
      }
  
      static class MessageConsumer {
          public void consume(String message) {
              System.out.println(message);
          }
      }
  
      public static void main(String[] args) {
          new ClassPathXmlApplicationContext("classpath:spring/integration/stackoverflow/ioadapter/ioadapter.xml");
      }
  }
  

• Archivo de configuración de estilo XML:

  <?xml version="1.0" encoding="UTF-8"?>
  <beans xmlns="http://www.springframework.org/schema/beans"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns:int="http://www.springframework.org/schema/integration"
         xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
         http://www.springframework.org/schema/integration http://www.springframework.org/schema/integration/spring-integration.xsd">
      <int:channel id="channel"/>
      <int:inbound-channel-adapter id="inAdapter" channel="channel" method="produce">
          <bean class="spring.integration.stackoverflow.ioadapter.Application$MessageProducer"/>
          <int:poller fixed-rate="1000"/>
      </int:inbound-channel-adapter>
      <int:outbound-channel-adapter id="outAdapter" channel="channel" method="consume">
          <bean class="spring.integration.stackoverflow.ioadapter.Application$MessageConsumer"/>
      </int:outbound-channel-adapter>
  </beans>
  

• Flujo de mensajes

  • inAdapter : un adaptador de canal entrante. Invoque el método de la Application$MessageProducer.produce cada 1 segundo ( <int:poller fixed-rate="1000"/> ) y envíe la cadena devuelta como mensaje al canal del channel .
  • channel : canal para transferir mensaje.
  • outAdapter : un adaptador de canal de salida. Una vez que se haya recibido el mensaje en el canal del channel , este adaptador recibirá el mensaje y luego lo enviará al método Application$MessageConsumer.consume que imprime el mensaje en la consola.
  • Por lo tanto, puede observar que estas cadenas de selección aleatoria se mostrarán en la consola cada 1 segundo.

Ejemplo simple de eco con Spring-Integration-Stream

Código de Java:

public class StdioApplication {
    public static void main(String[] args) {
        new ClassPathXmlApplicationContext("classpath:spring/integration/stackoverflow/stdio/stdio.xml");
    }
}

Archivo de configuración xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:int="http://www.springframework.org/schema/integration"
       xmlns:int-stream="http://www.springframework.org/schema/integration/stream"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/integration/stream
       http://www.springframework.org/schema/integration/stream/spring-integration-stream.xsd
       http://www.springframework.org/schema/integration
       http://www.springframework.org/schema/integration/spring-integration.xsd">
    <int:channel id="channel"/>
    <int-stream:stdin-channel-adapter id="stdin" channel="channel">
        <int:poller fixed-rate="1000"/>
    </int-stream:stdin-channel-adapter>
    <int-stream:stdout-channel-adapter id="stdout" channel="channel"/>
</beans>

Este es un ejemplo de eco. Cuando ejecute esta aplicación Java, puede ingresar alguna cadena y luego se mostrará en la consola.