【java_wxid项目】【第十四章】【Spring Cloud Stream集成】

原创 已于 2022-12-05 21:24:14 修改 · 1.5k 阅读 · 4 ·
CC 4.0 BY-SA版权
##############阁下如果是抄袭，爬取文章作恶或误导他人的开发者,请阅读中国现行法律的相关处罚条例再动手，转载之前最好先验证#############
文章标签：

#java #spring cloud #微服务

于 2022-10-02 20:20:16 首次发布

主项目链接：https://gitee.com/java_wxid/java_wxid
项目架构及博文总结：

项目模块：
前期规划，实现部分

java_wxid   
├── demo                                                            // 演示模块
│     └── 模块名称：apache-mybatis-demo模块                            //Apache Mybatis集成（已实现并有博文总结）
│     └── 模块名称：apache-shardingsphere-demo模块                     //Apache ShardingSphere集成（已实现并有博文总结）
│     └── 模块名称：design-demo模块                                    //设计模式实战落地（已实现并有博文总结）
│     └── 模块名称：elasticsearch-demo模块                             //ElasticSearch集成（已实现并有博文总结）
│     └── 模块名称：mongodb-demo模块                                   //MongoDB集成（已实现并有博文总结）
│     └── 模块名称：redis-demo模块                                     //Redis集成（已实现并有博文总结）
│     └── 模块名称：spring-boot-demo模块                               //Spring Boot快速构建应用（已实现并有博文总结）
│     └── 模块名称：spring-cloud-alibaba-nacos-demo模块                //Spring Cloud Alibaba Nacos集成（已实现并有博文总结）
│     └── 模块名称：spring-cloud-alibaba-seata-demo模块                //Spring Cloud Alibaba Seata集成（已实现并有博文总结）
│     └── 模块名称：spring-cloud-alibaba-sentinel-demo模块             //Spring Cloud Alibaba Sentinel集成（已实现并有博文总结）
│     └── 模块名称：spring-cloud-gateway-demo模块                      //Spring Cloud Gateway集成（已实现并有博文总结）
│     └── 模块名称：spring-cloud-hystrix-demo模块                      //Spring Cloud Hystrix集成（已实现并有博文总结）
│     └── 模块名称：spring-cloud-open-feign-demo模块                   //Spring Cloud Open Feign集成（已实现并有博文总结）
│     └── 模块名称：spring-cloud-ribbon-demo模块                       //Spring Cloud Ribbon集成（已实现并有博文总结）
│     └── 模块名称：spring-cloud-security-oauth2-demo模块              //Spring Cloud Security Oauth2集成（已实现并有博文总结）
│     └── 模块名称：spring-cloud-security-oauth2-sso-client-demo模块   //Spring Cloud Security Oauth2集成（已实现并有博文总结）
│     └── 模块名称：spring-cloud-skywalking-demo模块                   //Spring Cloud Skywalking集成（已实现并有博文总结）
│     └── 模块名称：spring-cloud-stream-demo模块                       //Spring Cloud Stream集成（已实现并有博文总结）
│     └── 模块名称：swagger-demo模块                                   //springfox-swagger2集成（已实现并有博文总结）
│     └── 模块名称：xxl-job模块                                        //xxl-job集成（已实现并有博文总结）
│     └── 模块名称：apache-spark-demo模块                              //Apache Spark集成
│     └── 模块名称：etl-hdfs-hive-hbase-demo模块                       //ETL、HDFS、Hive、Hbase集成
│     └── 模块名称：ddd-mode-demo模块                                  //DDD领域设计
│     └── 模块名称：netty-demo模块                                     //Netty集成
│     └── 模块名称：vue-demo模块                                       //前端vue集成
├── document                                                        // 文档
│     └── JavaKnowledgeDocument                                     //java知识点
│           └── java基础知识点.md                     
│           └── mq知识点.md
│           └── mysql知识点.md
│           └── redis知识点.md
│           └── springcould知识点.md
│           └── spring知识点.md
│     └── FounderDocument                                           //创始人
│           └── 创始人.md

系列文章：快速集成各种微服务相关的技术，帮助大家可以快速集成到自己的项目中，节约开发时间。
提示：系列文章还未全部完成，后续的文章，会慢慢补充进去的。

文章目录

创建elasticsearch-demo项目

项目代码：https://gitee.com/java_wxid/java_wxid/tree/master/demo/spring-cloud-stream-demo
项目结构如下（示例）：
在这里插入图片描述

修改pom.xml

代码如下（示例）：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>spring-cloud-stream-demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>spring-cloud-stream-demo</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <!--引入 Spring Boot、Spring Cloud、Spring Cloud Alibaba 三者 BOM 文件，进行依赖版本的管理，防止不兼容。
        在 https://dwz.cn/mcLIfNKt 文章中，Spring Cloud Alibaba 开发团队推荐了三者的依赖关系-->
        <spring.boot.version>2.3.12.RELEASE</spring.boot.version>
        <spring.cloud.version>Hoxton.SR12</spring.cloud.version>
        <spring.cloud.alibaba.version>2.2.7.RELEASE</spring.cloud.alibaba.version>
    </properties>
    <!--
        引入 Spring Boot、Spring Cloud、Spring Cloud Alibaba 三者 BOM 文件，进行依赖版本的管理，防止不兼容。
        在 https://dwz.cn/mcLIfNKt 文章中，Spring Cloud Alibaba 开发团队推荐了三者的依赖关系
     -->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-parent</artifactId>
                <version>${spring.boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring.cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-alibaba-dependencies</artifactId>
                <version>${spring.cloud.alibaba.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

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

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

        <!-- 集成spring-cloud-starter-stream-rocketmq -->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-stream-rocketmq</artifactId>
            <version>2.0.1.RELEASE</version>
        </dependency>
        <!-- 集成spring-cloud-starter-stream-kafka -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-stream-kafka</artifactId>
            <version>2.0.1.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.apache.kafka</groupId>
            <artifactId>kafka-streams</artifactId>
        </dependency>


        <!-- 集成spring-cloud-starter-stream-rabbitmq -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-stream-rabbit</artifactId>
            <version>2.0.1.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>2.3.3.RELEASE</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

修改SpringCloudStreamDemoApplication

代码如下（示例）：

package com.example.springcloudstreamdemo;

import com.example.springcloudstreamdemo.passage.*;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.stream.annotation.EnableBinding;

@EnableBinding(value = {StreamSource.class, StreamSink.class})
@SpringBootApplication
//Spring boot的CommandLineRunner接口主要用于实现在应用初始化后，去执行一段代码块逻辑，这段初始化代码在整个应用生命周期内只会执行一次
public class SpringCloudStreamDemoApplication {

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

}

创建application.yml

代码如下（示例）：

server:
  port: 8097
spring:
  rabbitmq:
#    host: 106.14.132.94
#    port: 5672
#    username: admin
#    password: java@2022
#    virtual-host: /
    host: 192.168.160.128
    port: 5672
    username: admin
    password: admin
    virtual-host: /
  application:
    name: spring-cloud-stream-demo
  autoconfigure:
    # 使用multiple RabbitMQ binders 时需要排除RabbitAutoConfiguration
    exclude:
      - org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration
  cloud:
    stream:
      default-binder: rocketmq #选择默认绑定器
      rocketmq:
        binder:
          name-server: 192.168.160.128:9876
      kafka:
        binder:
          brokers: 106.14.132.94:9092
          # 自动创建Topic
          auto-create-topics: true
      binders: #可以绑定多个消息中间件
        rabbit: #表示定义的名称，用于binding整合 名字可以自定义  在此处配置要绑定的rabbitmq的服务信息
          type: rabbit # 消息组件类型
        rocketmq: #表示定义的名称，用于binding整合 名字可以自定义 在此处配置要绑定的rocket的服务信息
          type: rocketmq
        kafka:
          type: kafka
      bindings: # 服务的整合处理
        rabbitmqOutput:  # 这个名字是一个binding的名称（自定义）
          destination: rabbitmq-destination # 通道，如果用的是RabbitMQ就是交换机名称
          content-type: application/json # 设置消息类型，本次为json，文本则设置“text/plain”
          default-binder: rabbit # 如果没设定，就使用default-binder默认的
          producer:
            routing-key-expression: headers.routingKey   # 发送端路由key
            delayed-exchange: true    # 开启延时队列
          # 指定了消息分区的数量。
          partitionCount: 2
          # 指定分区键的表达式规则，我们可以根据实际的输出消息规则来配置SpEL来生成合适的分区键；
          partition-key-expression: headers.id1
        rabbitmqInput:  # 这个名字是一个binding的名称（自定义）
          destination: rabbitmq-destination # 通道，如果用的是RabbitMQ就是交换机名称
          content-type: application/json # 设置消息类型，本次为对象json，如果是文本则设置“text/plain”
          default-binder: rabbit # 设置要绑定的消息服务的具体设置
          group: my-rabbitmq-group  # 分组名称，在rabbit当中其实就是交换机绑定的队列名称
          consumer:
            concurrency: 2 # 初始/最少/空闲时 消费者数量,默认1
            max-attempts: 3 #重试次数
            partitioned: true #通过该参数开启消费者分区功能；
        kafkaOutput: # 通道名称
          destination: kafka-destination # 消息的主题名 消息发往的目的地，对应topic 在发送消息的配置里面，group是不用配置的
          content-type: application/json # 设置消息类型，本次为json，文本则设置“text/plain” 如果我们需要传输json的信息，那么在发送消息端需要设置content-type为json（其实可以不写，默认content-type就是json）
          default-binder: kafka # 如果没设定，就使用default-binder默认的
          # 指定了消息分区的数量。
          partitionCount: 2
          # 指定分区键的表达式规则，我们可以根据实际的输出消息规则来配置SpEL来生成合适的分区键；
          partition-key-expression: headers.id2
        kafkaInput:
          destination: kafka-destination # 消息的主题名 消息发往的目的地，对应topic
          content-type: application/json # 设置消息类型，本次为对象json，如果是文本则设置“text/plain”
          default-binder: kafka # 设置要绑定的消息服务的具体设置
          group: my-kafka-group  # 分组名称，在kafka当中其实就是交换机绑定的队列名称
          consumer:
            concurrency: 2 # 初始/最少/空闲时 消费者数量,默认1
            max-attempts: 3 #重试次数
            partitioned: true #通过该参数开启消费者分区功能；
        rocketmqOutput: # 通道名称
          destination: rocket-destination # 消息发往的目的地，对应topic 在发送消息的配置里面，group是不用配置的
          content-type: application/json # 设置消息类型，本次为json，文本则设置“text/plain” 如果我们需要传输json的信息，那么在发送消息端需要设置content-type为json（其实可以不写，默认content-type就是json）
          default-binder: rocketmq # 如果没设定，就使用default-binder默认的
          # 指定了消息分区的数量。
          partitionCount: 2
          # 指定分区键的表达式规则，我们可以根据实际的输出消息规则来配置SpEL来生成合适的分区键；
          partition-key-expression: headers.id3
        rocketmqInput:
          destination: rocket-destination # 消息发往的目的地，对应topic
          content-type: application/json # 设置消息类型，本次为对象json，如果是文本则设置“text/plain”
          default-binder: rocketmq # 设置要绑定的消息服务的具体设置
          group: my-rocketmq-group  # 分组名称，在rocket当中其实就是交换机绑定的队列名称
          consumer:
            concurrency: 2 # 初始/最少/空闲时 消费者数量,默认1
            max-attempts: 3 #重试次数
            partitioned: true #通过该参数开启消费者分区功能；

创建KafkaConsumer

代码如下（示例）：

package com.example.springcloudstreamdemo.consumer;

import com.example.springcloudstreamdemo.passage.StreamSink;
import org.springframework.cloud.stream.annotation.EnableBinding;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.cloud.stream.annotation.StreamListener;
import org.springframework.stereotype.Component;

/**
 * @author zhiwei Liao
 * @Description
 * @Date create in 2022/9/12 0012 21:03
 */
@Component
@EnableBinding(StreamSink.class)
public class KafkaConsumer {

    private static final Logger logger = LoggerFactory.getLogger(KafkaConsumer.class);

    @StreamListener(target = StreamSink.KAFKAINPUT)
    public void consume(String message) {
        logger.info("Kafka recieved a string message : " + message);
    }

    @StreamListener(target = StreamSink.KAFKAINPUT, condition = "headers['type']=='kafka'")
    public void handle(String message) {
        logger.info("Kafka recieved a complex message: {}",  message);
    }
}

创建RabbitmqConsumer

代码如下（示例）：

package com.example.springcloudstreamdemo.consumer;

import com.example.springcloudstreamdemo.passage.StreamSink;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.cloud.stream.annotation.EnableBinding;
import org.springframework.cloud.stream.annotation.StreamListener;
import org.springframework.stereotype.Component;

/**
 * @author zhiwei Liao
 * @Description
 * @Date create in 2022/9/12 0012 21:03
 */
@Component
@EnableBinding(StreamSink.class)
public class RabbitmqConsumer {

    private static final Logger logger = LoggerFactory.getLogger(RabbitmqConsumer.class);

    @StreamListener(target = StreamSink.RABBITMQINPUT)
    public void consume(String message) {
        logger.info("rabbitmq recieved a string message : " + message);
    }

    @StreamListener(target = StreamSink.RABBITMQINPUT, condition = "headers['type']=='rabbitmq'")
    public void handle(String message) {
        logger.info("rabbitmq recieved a complex message : {}",  message);
    }
}

创建RocketmqConsumer

代码如下（示例）：

package com.example.springcloudstreamdemo.consumer;

import com.example.springcloudstreamdemo.passage.StreamSink;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.cloud.stream.annotation.EnableBinding;
import org.springframework.cloud.stream.annotation.StreamListener;
import org.springframework.stereotype.Component;

/**
 * @author zhiwei Liao
 * @Description
 * @Date create in 2022/9/12 0012 21:03
 */
@Component
@EnableBinding(StreamSink.class)
public class RocketmqConsumer {

    private static final Logger logger = LoggerFactory.getLogger(RocketmqConsumer.class);

    @StreamListener(target = StreamSink.ROCKETMQINPUT)
    public void consume(String message) {
        logger.info("Rocketmq recieved a string message : " + message);
    }

    @StreamListener(target = StreamSink.ROCKETMQINPUT, condition = "headers['type']=='rocketmq'")
    public void handle(String message) {
        logger.info("Rocketmq recieved a complex message : {}", message);
    }
}

创建KafkaController

代码如下（示例）：

package com.example.springcloudstreamdemo.controller;

import com.example.springcloudstreamdemo.producer.StraamProducer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author zhiwei Liao
 * @Description
 * @Date create in 2022/9/12 0012 21:03
 */
@RestController
@RequestMapping("/kafka")
public class KafkaController {

    @Autowired
    private StraamProducer straamProducer;

    /**
     * 发送消息
     * @param payload
     */
    @GetMapping("/sendSucceed")
    public void sendSucceed(String payload) {
        straamProducer.kafkaSendMessage(payload);
    }

}

创建RabbitmqController

代码如下（示例）：

package com.example.springcloudstreamdemo.controller;

import com.example.springcloudstreamdemo.producer.StraamProducer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author zhiwei Liao
 * @Description
 * @Date create in 2022/9/12 0012 21:03
 */
@RestController
@RequestMapping("/rabbitmq")
public class RabbitmqController {

    @Autowired
    private StraamProducer straamProducer;

    /**
     * 发送消息
     * @param payload
     */
    @GetMapping("/sendSucceed")
    public boolean sendSucceed(String payload) {
        return straamProducer.rabbitmqSendMessage(payload);
    }


}

创建RocketmqController

代码如下（示例）：

package com.example.springcloudstreamdemo.controller;

import com.example.springcloudstreamdemo.passage.StreamSink;
import com.example.springcloudstreamdemo.producer.StraamProducer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.stream.annotation.EnableBinding;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

/**
 * @author zhiwei Liao
 * @Description
 * @Date create in 2022/9/12 0012 21:03
 */
@EnableBinding(StreamSink.class)
@RestController
@RequestMapping("/rocketmq")
public class RocketmqController {

    @Resource
    private StraamProducer straamProducer;

    @GetMapping("/sendSucceed")
    public boolean sendSucceed(@RequestParam(value="payload") String payload) {
        return straamProducer.rocketmqSendMessage(payload);
    }
}

创建StreamSink

代码如下（示例）：

package com.example.springcloudstreamdemo.passage;

import org.springframework.cloud.stream.annotation.Input;
import org.springframework.messaging.SubscribableChannel;

/**
 * @author zhiwei Liao
 * @Description
 * @Date create in 2022/9/12 0012 21:03
 */
public interface StreamSink {


    String KAFKAINPUT = "kafkaInput";

    @Input(KAFKAINPUT)
    SubscribableChannel kafkaInput();

    String ROCKETMQINPUT = "rocketmqInput";

    @Input(ROCKETMQINPUT)
    SubscribableChannel rocketmqInput();

    String RABBITMQINPUT = "rabbitmqInput";

    @Input(RABBITMQINPUT)
    SubscribableChannel rabbitmqInput();
}

创建StreamSource

代码如下（示例）：

package com.example.springcloudstreamdemo.passage;

import org.springframework.cloud.stream.annotation.Output;
import org.springframework.messaging.MessageChannel;

/**
 * @author zhiwei Liao
 * @Description
 * @Date create in 2022/9/12 0012 21:03
 */
public interface StreamSource {

    String ROCKETMQOUTPUT = "rocketmqOutput";

    @Output(ROCKETMQOUTPUT)
    MessageChannel rocketmqOutput();

    String RABBITMQOUTPUT = "rabbitmqOutput";

    @Output(RABBITMQOUTPUT)
    MessageChannel rabbitmqOutput();

    String KAFKAOUTPUT = "kafkaOutput";

    @Output(KAFKAOUTPUT)
    MessageChannel kafkaOutput();

}

创建StreamProducer

代码如下（示例）：

package com.example.springcloudstreamdemo.producer;

import com.example.springcloudstreamdemo.passage.StreamSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.stream.annotation.EnableBinding;
import org.springframework.cloud.stream.function.StreamBridge;
import org.springframework.messaging.Message;
import org.springframework.messaging.support.MessageBuilder;

/**
 * @author zhiweiLiao
 * @Description kafka的生产者
 * @Date create in 2022/9/13 0013 14:39
 */
@EnableBinding({StreamSource.class})
public class StreamProducer {

    @Autowired
    private StreamSource streamSource;

    @Autowired
    private StreamBridge streamBridge;

    public boolean rocketmqSendMessage(Object payload) {
        Message<Object> message = MessageBuilder.withPayload(payload)
                .setHeader("type", "rocketmq")
                .setHeader("x-delay", 5000)
                .build();
//        return streamBridge.send("rocketmqOutput",message);
        return streamSource.rocketmqOutput().send(message);
    }

    public boolean rabbitmqSendMessage(Object payload) {
        Message<Object> message = MessageBuilder.withPayload(payload)
                .setHeader("type", "rabbitmq")
                .setHeader("x-delay", 5000)
                .build();
        return streamSource.rabbitmqOutput().send(message);
    }

    public boolean kafkaSendMessage(Object payload) {
        Message<Object> message = MessageBuilder.withPayload(payload)
                .setHeader("type", "kafka")
                .setHeader("x-delay", 5000)
                .build();
        return streamSource.kafkaOutput().send(message);
    }

}

创建RabbitMQUtil

代码如下（示例）：

package com.example.springcloudstreamdemo.util;

import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class RabbitMQUtil {
    private static ConnectionFactory factory;
    //程序一加载就会启动
    static {
        //1.创建连接工厂对象
        factory=new ConnectionFactory();
        //设置连接对象的参数
        factory.setHost("106.14.132.94");
        factory.setPort(5672);
        factory.setUsername("admin");
        factory.setPassword("java@2022");
        factory.setVirtualHost("/");
    }
    public static Connection getconnection(){
        Connection connection=null;
        try{
            connection=factory.newConnection();
        } catch (TimeoutException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return connection;
    }
    public static void main(String[] args) {
        System.out.println(getconnection());
    }
}

校验是否正常工作

使用rocketmq发消息

如下图（示例）：

在这里插入图片描述调用接口发消息，如下图（示例）：
在这里插入图片描述控制台打印，如下图（示例）：
在这里插入图片描述

SpringCloud集成Stream
m0_53157173的博客
10-21 624
SpringCloud集成StreamStream为什么被引入Stream是什么及Binder介绍Stream的设计思想Stream编码常用注解简介案例Stream消息驱动之生产者Stream消息驱动之消费者Stream之消息重复消费生产实际案例Stream之group解决消息重复消费Stream之消息持久化 Stream为什么被引入 常见MQ(消息中间件)： ActiveMQ RabbitMQ RocketMQ Kafka 有没有一种新的技术诞生，让我们不再关注具体MQ的细节，我们只需要用一
Spring Boot 集成 Hive
格物致知，知行合一。
06-28 3621
本文介绍了在 Spring Boot 工程中通过 MyBatis-Plus 集成 Hive，从而实现对 Hive 中数据的操作，欢迎阅读斧正。
hive整合springcloud框架
my java博客园
06-10 775
hive插入表数据非常慢 1.maven解决 日志冲突和Tomcat冲突 <dependency> <groupId>org.apache.hive</groupId> <artifactId>hive-jdbc</artifactId> <version>2.3.2</version> <exclusions> <exclusion>
实战指南：使用 Spring Cloud Stream 集成 Kafka 构建高效消息驱动微服务
沉梦听雨的博客
12-26 4513
SCS 是一个用于构建消息驱动微服务的框架，它基于 Spring Boot，提供了一种简化的方式来处理消息和事件的传递。它旨在为不同消息代理（如 Kafka、RabbitMQ、Apache Kafka 等）提供统一的编程模型，使开发者能够更轻松地在微服务架构中使用消息通信。Binder（绑定器）：Binder 是 Spring Cloud Stream 的核心概念之一，它提供了与底层消息代理之间的连接和交互。
spring cloud篇-(基于redis实现spring-cloud-stream功能)
qq_42413011的博客
09-07 2559
基于redis实现spring-cloud-stream的抽象api,实现input,output功能写在前面开发spring-cloud-stream-redis模块项目结构如下自定义Consumer和Producer配置类定义redis客户端配置类定义StreamBindingProperties配置类定义ExtendBindingProperties自定义消息发送器自定义消息处理器创建StreamBinder创建配置类，将相关bean注册到spring容器创建测试项目，使用自定义的spring-clo
SpringCloud AdminServer 深入解析
MoneyHacksPro的博客
08-14 832
SpringCloud AdminServer 是 Spring Cloud 生态系统中的一个核心组件，旨在为开发者提供一种高效的方式来监控和管理 Spring Cloud 应用程序。通过 AdminServer，开发者能够实时监控服务的状态、查看实时日志、执行健康检查、追踪事件以及集成仪表盘等功能，从而实现对应用程序的全面监控和管理。通过自定义仪表盘，用户可以自定义监控数据的展示方式。
java 怎么接入AI 实现自动图片答题
最新发布
11-22
我们参考用户提供的站内引用，特别是引用[2]和引用[5]中提到的Java技术栈和AI集成方法，结合引用[3]中的API调用示例和引用[4]的AI智能识别，设计一个Java接入AI实现自动图片答题的方案。 ### 一、整体架构 ```...
spring cloud stream操作kafka和redis，以及kafka与redis队列性能比较（未完）
山间明月江上清风的专栏
05-26 872
上次用redis队列做了性能测试，不过redis毕竟不是专门用来做队列的，这次用kafka试试。这次我用spring cloud stream来操作kafka。Spring Cloud Stream是构建消息驱动的微服务应用程序的框架。Spring Cloud Stream基于Spring Boot构建独立的生产级Spring应用程序，并使用Spring Integration为消息代理提供连接。...
SpringBoot整合hive-jdbc示例
08-19
本项目对如何在Springboot项目中整合hive-jdbc进行简单示例和介绍，亲测可用，请放心下载。
SpringCloudStream 构建消息驱动的微服务框架 集成kafka_http://blog.spring-cloud.io/blog/sc-stream.html
热门推荐
a363722188的专栏
07-17 1万+
SpringCloudStream 构建消息驱动的微服务框架 2016-09-02 /  Wang Sihan 前言 Spring Cloud Stream，用精简的语言概括，他本质上其实就是让开发人员使用消息中间件变得简单。 他基于Spring Integration并利用Spring Boot提供了自动配置，提供了极为方便的消息中间件使用体验。看到这里会有人认
spring-cloud-starter-stream-rabbit MQ使用规范
03-12
各个微服务统一使用spring-cloud-starter-stream-rabbit 为规范各个微服务之间消息队列的交换机、通道、队列、消息投递更加便于识别、扩展和维护特进行以下要求
SpringCloud中24个很重要的Starter
诗和远方，任重道远
11-12 3455
Netflix SpringCloud中几个很重要的组件写在前面一、Eureka二、Turbine三、Ribbon四、Hystrix 写在前面 其实在这些个Starter之上，是一个团队的努力结果，从下图可以看出，每个Starter都是基于相应的Starter-Netflix-XX，开发，团队会根据需要，在Starter-Netflix-XXX中封装SDK，最后整合使用在Starter中，需要注意...
springboot 集成hive
胡八一的博客
07-08 3798
springboot 集成hive
springCloud 之 spring-cloud-stream 集成消息中间件rabbitmq
Mynah886的博客
09-23 3366
1、POM中引入spring-cloud-starter-stream-rabbit <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-stream-binder-rabbit</artifactId> &...
使用Spring Cloud Stream的事件驱动架构（利用kafka和redis，学习笔记）
qq_28799479的博客
08-25 927
源码：Chapter 8 Event-driven architecture with Spring Cloud Stream 要实现的功能是：现有两个微服务，组织服务A，和许可证服务B，B用redis保存A的缓存，B产生变化的时候，用消息队列通知A数据已经变化，请刷新缓存。 一、编写简单的消息生产者和消费者 1.在组织服务里编写消息生产者 组织服务pom依赖： <dependency&gt...
SpringCloud Stream 使用
小凯的博客
06-28 1027
SpringCloud Stream 介绍及使用
spring cloud 分布式Hadoop三部曲之Hive
lvhao2813的博客
06-03 1026
下载apache-hive-2.3.7-bin.tar.gz 放在目录/myfiles/hive 解压tar -zxvf apache-hive-2.3.7-bin.tar.gz http://mirror.bit.edu.cn/apache/hive/ 修改环境变量 vim /etc/profile export HIVE_HOME=/myfiles/hive/apache-hive-2.3.7-bin export PATH=$PATH:$HIVE_HOME/bin //执行 sourc..
SpringBoot连接Hive实现自助取数的示例
weixin_51495453的博客
01-07 611
公司运营免不了让我们数据做一些临时取数，这些取数有时候是重复的，或者可以做成可配置的。需要开发成界面，供他们选择，自然想到SpringBoot连接Hive，可以把取数做成一键生成，或者让他们自己写sql，通常大多人是不会sql的。 1. 需要的依赖配置 为了节省篇幅，这里给出hiveserver2方式连接hive主要的maven依赖，父工程springboot依赖省略。 <!-- 版本信息 --> <properties> <hadoop.version>2.6.5&l
springboot集成hivejdbc报错处理
胡八一的博客
08-05 785
springboot集成hivejdbc报错处理
.版本 2 .程序集 千寻微信框架_SDK, , , QxWeChat_SDK .全局变量 规则名称, 文本型, , "0" ' 规则名称数组 .全局变量 规则群组, 文本型, , "0" ' 对应的群ID数组 .全局变量 用户等待, 文本型, , "0" ' 存储等待回复的用户信息 .子程序 _启动子程序, 整数型 返回 (0) .子程序结束 .子程序 Qx_EventEnable, 整数型, 公开 加载规则 () 返回 (#事件处理_同意) .子程序结束 .子程序 加载规则 .局部变量 配置路径, 文本型 .局部变量 内容数组, 文本型, , "0" .局部变量 i, 整数型 配置路径 = 取运行目录() + "\data\plugin\群发规则.txt" ' 自动创建示例文件 .如果真 (文件是否存在(配置路径) = 假) 创建目录(取运行目录() + "\data\plugin\") 写文本文件(配置路径, "规则1:群ID1,群ID2" + #换行符 + "规则2:群ID3") .如果真结束 内容数组 = 读入文本文件(配置路径) 重定义数组(规则名称, 取数组成员数(内容数组)) 重定义数组(规则群组, 取数组成员数(内容数组)) .计次循环首(取数组成员数(规则名称), i) .如果真 (寻找文本(内容数组[i], ":", , 假) ≠ -1) 规则名称[i] = 取文本左边(内容数组[i], 寻找文本(内容数组[i], ":", , 假)) 规则群组[i] = 取文本右边(内容数组[i], 内容数组[i].长度 - 寻找文本(内容数组[i], ":", , 假) - 1) .否则 规则名称[i] = "规则" + 到文本(i + 1) 规则群组[i] = "" .如果真结束 .计次循环尾() ' 刷新设置窗口显示 .如果真 (是否已创建(窗口_设置)) 窗口_设置.规则列表.列表项 = 到文本(规则名称) .如果真结束 .子程序结束 .子程序 Qx_EventPrivateMsg, 整数型, 公开 .参数 robot_wxid, 文本型 .参数 jsonStr, 文本型 .局部变量 消息数据, 事件_数据_消息 .局部变量 用户索引, 整数型 .局部变量 选择序号, 整数型 消息数据 = 事件_解析消息(jsonStr) ' 只处理自己发送的消息 .如果真 (消息数据.fromWxid ≠ robot_wxid) 返回 (#消息处理_继续) .如果真结束 ' 检测触发关键词 .如果真 (消息数据.消息内容.右边(4) = "群发消息") .如果真 (取数组成员数(规则名称) = 0) Api.发送文本消息(robot_wxid, robot_wxid, "请先配置群发规则", , ) 返回 (#消息处理_结束) .如果真结束 用户索引 = 查找用户(robot_wxid) .如果真 (用户索引 = -1) 用户索引 = 加入成员(user等待, ) .如果真结束 user等待[user索引] = 消息数据.消息内容.左边(消息数据.消息内容.长度 - 4) Api.发送文本消息(robot_wxid, robot_wxid, 生成规则菜单(), , ) 返回 (#消息处理_结束) .如果真结束 ' 处理规则选择 .如果真 (是否为数值(消息数据.消息内容)) 选择序号 = 到整数(消息数据.消息内容) - 1 .如果真 (选择序号 ≥ 0 且 选择序号 < 取数组成员数(规则名称)) 执行群发(robot_wxid, 取用户消息(robot_wxid), 选择序号) 清除用户(robot_wxid) Api.发送文本消息(robot_wxid, robot_wxid, "已执行群发", , ) 返回 (#消息处理_结束) .如果真结束 .如果真结束 返回 (#消息处理_继续) .子程序结束 .子程序 生成规则菜单, 文本型 .局部变量 菜单, 文本型 .局部变量 i, 整数型 菜单 = "请选择群发规则（回复序号）：" .计次循环首(取数组成员数(规则名称), i) 菜单 = 菜单 + #换行符 + 到文本(i + 1) + ". " + 规则名称[i] .计次循环尾() 返回 (菜单) .子程序结束 .子程序 执行群发 .参数 robot_wxid, 文本型 .参数 消息内容, 文本型 .参数 规则索引, 整数型 .局部变量 群数组, 文本型, , "0" .局部变量 i, 整数型 群数组 = 分割文本(规则群组[规则索引], ",", ) .计次循环首(取数组成员数(群数组), i) Api.发送文本消息(robot_wxid, 群数组[i], 消息内容, , ) .计次循环尾() .子程序结束 .子程序 查找用户, 整数型 .参数 robot_wxid, 文本型 .计次循环首(取数组成员数(user等待), ) .如果真 (user等待[] = robot_wxid) 返回 (循环变量 - 1) .如果真结束 .计次循环尾() 返回 (-1) .子程序结束 .子程序 取用户消息, 文本型 .参数 robot_wxid, 文本型 .局部变量 用户索引, 整数型 用户索引 = 查找用户(robot_wxid) .如果真 (用户索引 ≠ -1) 返回 (user等待[user索引]) .否则 返回 ("") .如果真结束 .子程序结束 .子程序 清除用户 .参数 robot_wxid, 文本型 .局部变量 用户索引, 整数型 用户索引 = 查找用户(robot_wxid) .如果真 (用户索引 ≠ -1) 删除成员(user等待, 用户索引) .如果真结束 .子程序结束 ' --------------- 设置窗口相关代码 --------------- .子程序 Qx_Set, , 公开 载入(窗口_设置, , 假) .子程序结束 .窗口程序集 窗口_设置 .程序集变量 规则列表, 列表框, , "规则列表" .程序集变量 重新加载按钮, 按钮, , "重新加载" .子程序 __启动窗口_创建完毕 规则列表.加入项目 (, 0) 规则列表.列表项 = 到文本(规则名称) .子程序结束 .子程序 重新加载按钮_被单击 加载规则 () Api.发送文本消息 (Api.获取当前机器人ID(), Api.获取当前机器人ID(), "规则已重新加载", , ) .子程序结束 .窗口程序集结束 ' 其他事件处理保持默认实现 .子程序 Qx_EventPluginIns, 整数型, 公开 返回 (#事件处理_同意) .子程序结束 .子程序 Qx_EventInject, 整数型, 公开 Api.输出日志 (“有微信注入成功”, , ) 返回 (#消息处理_继续) .子程序结束 帮我看看以上代码有没有错误
03-27
$$错误四：配置文件解析缺陷$$ 建议增加容错处理： ```easyment .计次循环首(取数组成员数(内容数组), i) ' 修正循环次数 .如果真 (内容数组[i] ≠ "" 且 寻找文本(内容数组[i], ":", , 假) ≠ -1) ... .否则 ...
评论 2
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Java程序员廖志伟

赏我包辣条呗

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值