入门案例

准备工作#

案例中通过rabbitMQ作为消息中间件，完成SpringCloud Stream的案例。需要自行安装

消息生产者#

/**
 * 入门案例:
 *      1.引入依赖
 *      2.配置application.yml文件
 *      3.发送消息的话,定义一个通道接口,通过接口中内置的messagechannel
 *              springcloudstream中内置接口  Source
 *      4.@EnableBinding : 绑定对应通道
 *      5.发送消息的话,通过MessageChannel发送消息
 *          * 如果需要MessageChannel --> 通过绑定的内置接口获取
 */

（1）创建工程引入依赖#

        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-stream</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-stream-rabbit</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-stream-binder-rabbit</artifactId>
        </dependency>

（2）定义bingding#

发送消息时需要定义一个接口，不同的是接口方法的返回对象是 MessageChannel，下面是 SpringCloud Stream 内置的接口：

public interface Source {
  String OUTPUT = "output";

  @Output("output")
  MessageChannel output();
}

这个接口声明了一个 binding 命名为 “output”。这个binding 声明了一个消息输出流，也就是消息的生产者。

（3）配置application.yml#

server:
  port: 7001 #服务端口
spring:
  application:
    name: stream_producer #指定服务名
  rabbitmq:
    addresses: 127.0.0.1
    username: guest
    password: guest
  cloud:
    stream:
      bindings:
        output:
          destination: itcast-default  #指定消息发送的目的地,在rabbitmq中,发送到一个itcast-default的exchange中
      binders:  #配置绑定器
        defaultRabbit:
          type: rabbit

destination：指定了消息发送的目的地，对应 RabbitMQ，会发送到 exchange 是 itcast-default 的所有消息队列中。

（4）定义一个stream的消息发送类#

/**
 * 负责向中间件发送数据
 */
@Component
@EnableBinding(MyProcessor.class)
public class MessageSender {

    @Autowired
　　 private MessageChannel output;

    //发送消息
    public void send(Object obj) {
        myoutput.send(MessageBuilder.withPayload(obj).build());
    }
}

（5）cn.itcast.stream中定义一个测试类ProducerTest#

package cn.itcast.stream;

import cn.itcast.stream.producer.MessageSender;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest
public class ProducerTest {

    @Autowired
    private MessageSender messageSender;

    @Test
    public void testSend() {
        for (int i = 0; i <5 ; i++) {
            messageSender.send("1");
        }
    }
}

整体流程#

消息消费者#

（1）创建工程引入依赖#

        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-stream</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-stream-rabbit</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-stream-binder-rabbit</artifactId>
        </dependency>

（2）定义bingding#

同发送消息一致，在Spring Cloud Stream中接受消息，需要定义一个接口，如下是内置的一个接口。

public interface Sink {
    String INPUT = "input";
    @Input("input")
    SubscribableChannel input();
}

注释 @Input 对应的方法，需要返回 SubscribableChannel ，并且传入一个参数值。

这个接口声明了一个 binding 命名为 “input” 。

（3）配置application.yml#

server:
  port: 7002 #服务端口
spring:
  application:
    name: rabbitmq-consumer #指定服务名
  rabbitmq:
    addresses: 127.0.0.1
    username: guest
    password: guest
  cloud:
    stream:
      bindings:
        input: #内置的获取消息的通道 , 从itcast-default中获取消息
          destination: itcast-default
      binders:
        defaultRabbit:
          type: rabbit

destination：指定了消息获取的目的地，对应于MQ就是 exchange，这里的exchange就是 itcast-default

（4） 定义一个消息监听类MessageListener#

package cn.itcast.stream.consumer;
import org.springframework.cloud.stream.annotation.EnableBinding;
import org.springframework.cloud.stream.annotation.StreamListener;
import org.springframework.cloud.stream.messaging.Sink;
import org.springframework.stereotype.Component;

@Component
@EnableBinding(MyProcessor.class)
public class MessageListener {
　　//监听binding中的消息
    @StreamListener(Sink.INPUT)
 public void input(String message) { System.out.println("获取到消息: "+message); }
 }

定义一个 class （这里直接在启动类），并且添加注解@EnableBinding(Sink.class) ，其中Sink 就是上述的接口。同时定义一个方法（此处是 input）标明注解为@StreamListener(Processor.INPUT)，方法参数为 Message 。

所有发送 exchange 为“itcast-default ” 的MQ消息都会被投递到这个临时队列，并且触发上述的方法。

（5）定义一个启动类运行#