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

使用Spring Cloud Stream的事件驱动架构(利用kafka和redis,学习笔记) 源码:Chapter 8 Event-driven architecture with Spring Cloud Stream 要实现的功能是:现有两个微服务,组织服务A,和许可证服务B,B用redis保存A的缓存,B产生变化的时候,用消息队列通知A数据已经变化,请刷新缓存。 一、编写简单的消息生产者和消费者 1.在组织服务里编写消息生产者 组织服务pom依赖: <dependency&gt... 阅读详情

主项目链接: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中24个很重要的Starter Netflix SpringCloud中几个很重要的组件写在前面一、Eureka二、Turbine三、Ribbon四、Hystrix 写在前面 其实在这些个Starter之上,是一个团队的努力结果,从下图可以看出,每个Starter都是基于相应的Starter-Netflix-XX,开发,团队会根据需要,在Starter-Netflix-XXX中封装SDK,最后整合使用在Starter中,需要注意... 阅读详情

相关推荐

SpringBoot连接Hive实现自助取数的示例

公司运营免不了让我们数据做一些临时取数,这些取数有时候是重复的,或者可以做成可配置的。需要开发成界面,供他们选择,自然想到SpringBoot连接Hive,可以把取数做成一键生成,或者让他们自己写sql,通常大多人是不会sql的。 1. 需要的依赖配置 为了节省篇幅,这里给出hiveserver2方式连接hive主要的maven依赖,父工程springboot依赖省略。 <!-- 版本信息 --> <properties> <hadoop.version>2.6.5&l

weixin_51495453的博客 652

SpringCloud集成Stream

SpringCloud集成StreamStream为什么被引入Stream是什么及Binder介绍Stream的设计思想Stream编码常用注解简介案例Stream消息驱动之生产者Stream消息驱动之消费者Stream之消息重复消费生产实际案例Stream之group解决消息重复消费Stream之消息持久化 Stream为什么被引入 常见MQ(消息中间件): ActiveMQ RabbitMQ RocketMQ Kafka 有没有一种新的技术诞生,让我们不再关注具体MQ的细节,我们只需要用一

m0_53157173的博客 756

SpringBoot整合hive-jdbc示例

本项目对如何在Springboot项目中整合hive-jdbc进行简单示例和介绍,亲测可用,请放心下载。

实战指南:使用 Spring Cloud Stream 集成 Kafka 构建高效消息驱动微服务

SCS 是一个用于构建消息驱动微服务的框架,它基于 Spring Boot,提供了一种简化的方式来处理消息和事件的传递。它旨在为不同消息代理(如 Kafka、RabbitMQ、Apache Kafka 等)提供统一的编程模型,使开发者能够更轻松地在微服务架构中使用消息通信。Binder(绑定器):Binder 是 Spring Cloud Stream 的核心概念之一,它提供了与底层消息代理之间的连接和交互。

沉梦听雨的博客 4777

KMS服务器一键部署与激活实战指南

本文详细介绍了KMS服务器的一键部署与激活实战指南,包括快速入门、安装步骤、服务管理技巧及常见问题排查。特别针对Windows和Mac用户提供了Office激活的具体操作步骤,并分享了高级配置与优化方案,帮助IT管理员高效管理批量授权激活。

weixin_29305313的博客 463

高效打卡系统设计:从行为心理学到实践工具

打卡系统作为现代时间管理的重要工具,其核心原理植根于行为心理学中的即时反馈机制和习惯养成理论。通过科学设计的打卡周期和可视化反馈,能有效提升个人自律性和目标达成率。在技术实现上,从纸质记录到数字化工具(如Notion、Excel自动化模板)的演进,为不同场景提供了灵活解决方案。特别在习惯追踪和进度管理领域,结合热力图生成、数据统计等技巧,打卡系统能转化为强大的自我监督工具。本文通过实践案例,详解如何构建兼顾弹性和约束力的个性化打卡方案,帮助读者突破'三天打鱼两天晒网'的常见困境。

weixin_30047059的博客 341

springboot 集成hive

springboot 集成hive

胡八一的博客 3851

AUTOSAR实战:手把手教你配置EthTsync模块,搞定车载以太网时间同步

本文详细解析AUTOSAR架构中EthTsync模块的配置方法,实现车载以太网时间同步。通过对比gPTP与PTP协议差异,提供从开发环境准备到参数配置、模块集成的全流程指南,并分享性能优化与调试技巧,帮助开发者实现微秒级同步精度,满足自动驾驶等高精度时间同步需求。

weixin_28736335的博客 376

springCloud 之 spring-cloud-stream 集成消息中间件rabbitmq

1、POM中引入spring-cloud-starter-stream-rabbit <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-stream-binder-rabbit</artifactId> &...

Mynah886的博客 3454

接上篇,记录一下【Unity 3D对博途PLCSIM的通讯】文章有点长~仔细看,很基础

本文参考链接:西门子PLC丨PROFINET通讯仿真(虚拟通讯)做了一些更详细的优化,本文使用的类库并非原作者使用的类库。 首先,昨天项目已经创建好了,这边也加了一个InputField和一个Button,可以实现简单的读取,ok开始。 放入准备好的通讯类库; 新建一个博途的项目,本次测试使用博途V15,测试环境为虚拟机,Unity运行在本地计算机,建立博途项目流程如下: 新建项目,右键项目-属性-保护-对勾,如图: 不得不说的是,仿真中加密的FB块是无法下载的哦~ 添加CPU...

NS_Speak(IVAV) 8069

AI智能体项目管理框架agent-pm:从原理到实战的多智能体协作指南

在人工智能和自动化技术快速发展的今天,多智能体系统已成为实现复杂任务自动化的重要技术路径。其核心原理在于通过任务分解、角色分配和状态管理,让多个AI智能体像人类团队一样协同工作,从而突破单个模型的性能边界。这种架构的技术价值在于将软件工程中成熟的项目管理方法论引入AI领域,显著提升了自动化流程的可预测性、可观测性和可复用性。在实际应用场景中,多智能体协作框架能够高效处理从代码开发、文档撰写到数据分析等一系列任务,尤其适合需要多步骤、多专业协同的复杂项目。本文聚焦的agent-pm框架,正是这一领域的典型实践

weixin_42533910的博客 717

SpringCloudStream 构建消息驱动的微服务框架 集成kafka_http://blog.spring-cloud.io/blog/sc-stream.html

SpringCloudStream 构建消息驱动的微服务框架 2016-09-02 /  Wang Sihan 前言 Spring Cloud Stream,用精简的语言概括,他本质上其实就是让开发人员使用消息中间件变得简单。 他基于Spring Integration并利用Spring Boot提供了自动配置,提供了极为方便的消息中间件使用体验。看到这里会有人认

a363722188的专栏 1万+

uniapp [全端兼容] - 实现大文件上传分片/切片+本地选择文件上传超大文件,大文件切片上传+断点续传+上传进度条+失败自动重传,支持单个/批量上传图片、视频、文档各种文件(App、小程序、H5

uniapp 分片 断点续传 大文件上传。uniapp大文件切片上传,uniapp实现大文件上传 分片上传 进度条,分片上传附件,实现大文件上传,实现分片大文件上传,Uniapp实现大文件上传 分片上传 进度条,uniapp文件分片上传,uniapp如何上传很大的文件,在选择文件后,按指定大小将文件切割成独立的文件片,并逐片上传,uniapp 微信小程序上传大文件如何切片,uniapp APP实现大文件分片上传、断点续传、秒传,解决大文件上传问题,大文件上传如何做断点续传,uniapp上传视频,Uniapp

🏆 前端领域优质创作者 1万+

spring cloud stream操作kafka和redis,以及kafka与redis队列性能比较(未完)

上次用redis队列做了性能测试,不过redis毕竟不是专门用来做队列的,这次用kafka试试。这次我用spring cloud stream来操作kafka。Spring Cloud Stream是构建消息驱动的微服务应用程序的框架。Spring Cloud Stream基于Spring Boot构建独立的生产级Spring应用程序,并使用Spring Integration为消息代理提供连接。...

山间明月江上清风的专栏 934

Excel 汉字首字母提取:四种方案对比与选型

本文对比了 Excel 中提取汉字首字母的四种方案:手动转换、VBA 脚本、映射表与 AI 工具。手动方式低效易错;VBA 适合无网环境但识别范围有限;映射表精度提升却无法解决多音字;AI 工具通过语义理解可一句话完成提取,是多数场景下的首选。

u011186532的专栏 400

MAX30102心率血氧传感器原理图设计,已量产(e-Health传感器)

在最近的便携健康监测设备项目中,我们采用了集成算法的 MAX30102 心率血氧模块 —— 这类带内置 MCU 算法的传感器能直接输出心率 / 血氧数值,大幅降低了主控资源占用。但硬件电路的稳定性直接决定了 PPG 信号的采集精度,下面结合实际项目里的原理图,拆解下这个模块的设计细节。

不脱发的程序猿 1283

spring cloud篇-(基于redis实现spring-cloud-stream功能)

基于redis实现spring-cloud-stream的抽象api,实现input,output功能写在前面开发spring-cloud-stream-redis模块项目结构如下自定义Consumer和Producer配置类定义redis客户端配置类定义StreamBindingProperties配置类定义ExtendBindingProperties自定义消息发送器自定义消息处理器创建StreamBinder创建配置类,将相关bean注册到spring容器创建测试项目,使用自定义的spring-clo

qq_42413011的博客 2654

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

SpringCloud Stream 使用

SpringCloud Stream 介绍及使用

小凯的博客 1227

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

Camera2Demo

在Camera2 的基础上进行封装,使得Camera2一堆初始化逻辑与Activity分离,降低耦合度,完成预览拍照并保存的操作

【Java】SpringBoot中实现Redis Stream队列

在SpringBoot中实现Redis Stream队列

Syals的博客 4395

锂电池充电器电路设计 里面有电路

锂电池充电器电路设计 里面有电路 3.7V升压到5V电路设计。

SpringColud结合Redis(简单版)

首先环境 SpringBoot版本2.1.8 Redis安装在Linux上面。测试类 运行成功之后 打开Redis可视化工具 查看是否添加数据成功!SpringBoot版本依赖、Redis版本依赖。

X_H_W_426的博客 472

hive整合springcloud框架

hive插入表数据非常慢 1.maven解决 日志冲突和Tomcat冲突 <dependency> <groupId>org.apache.hive</groupId> <artifactId>hive-jdbc</artifactId> <version>2.3.2</version> <exclusions> <exclusion>

my java博客园 806

spring cloud 分布式Hadoop三部曲之Hive

下载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..

lvhao2813的博客 1060

Spring Boot 集成 Hive

本文介绍了在 Spring Boot 工程中通过 MyBatis-Plus 集成 Hive,从而实现对 Hive 中数据的操作,欢迎阅读斧正。

格物致知,知行合一。 3781

springboot集成hivejdbc报错处理

springboot集成hivejdbc报错处理

胡八一的博客 828

Java8新特性 —— Stream流整合

1.串行stream操作 Lambda为java8带来了闭包,支持对集合对象的stream进行函数式操作, stream api被集成进了collection api ,允许对集合对象进行批量操作。 Stream表示数据流,它没有数据结构,本身也不存储元素,其操作也不会改变源Stream,而是生成新Stream.作为一种操作数据的接口,它提供了过滤、排序、映射、规约等多种操作方法, 这些方法按照返回类型被分为两类:凡是返回Stream类型的方法,称之为中间方法(中间操作),其余的都是完结方法(完结操作)。完

风华流沙君莫笑的博客 897

InnoDB 内存结构总览:Change Buffer、AHI 与 Log Buffer

本文系统梳理InnoDB内存结构中的ChangeBuffer、Adaptive Hash Index(AHI)与LogBuffer。ChangeBuffer缓存二级索引页不在内存时的变更,减少随机IO,仅在页加载时合并;聚簇索引修改立即执行,因数据本身不可延后。AHI基于高频等值查询自动构建哈希索引,加速定位,仅支持等值操作。LogBuffer为redo log内存缓冲,配合磁盘日志实现崩溃恢复。三者均服务于性能优化,其中ChangeBuffer与AHI共享BufferPool空间,而LogBuffer独立

bksczm的博客 307
上一篇: 【java_wxid项目】【第十三章】【Elasticsearch集成】
下一篇: 【安装配置RabbitMQ】
Java程序员廖志伟
Java程序员廖志伟 优质创作者: Java技术领域 优质创作者: Java技术领域 领域专家: 后端开发技术领域 领域专家: 后端开发技术领域
博客等级 码龄8年 2万+粉丝 1902原创
评论 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、付费专栏及课程。

余额充值