Spring cloud微服务与RibbitMQ简单应用

最新推荐文章于 2024-05-31 10:46:10 发布
最新推荐文章于 2024-05-31 10:46:10 发布
阅读量163 收藏
点赞数 1
文章标签： java spring boot 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30414059/article/details/117577649
版权

Spring cloud微服务与RibbitMQ简单应用

一. 系统架构

  • 系统架构图：在这里插入图片描述

  • 完成要求：

    生产者Producer具备Feign客户端，调用dbService微服务;

    增加微服务dbService,通过Spring Data Jpa 访问数据库获取对象user;

    生产者Producer将获取对象user通过RabbitMQ,发送给消费组groupA和groupB;

二. 运行环境

  • window10
  • erlan24.0
  • RabbitMQ3.8.16
  • mysql8.0

三. 编码实现

1. 创建注册中心-eurekaServer

  • 创建springboot项目，导入依赖

      	<dependency>
          <groupId>org.springframework.cloud</groupId>
          <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
      </dependency>

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

  • 配置文件

    server.port=8761
eureka.client.register-with-eureka=false
eureka.client.fetch-registry=false

  • 启动类加入注解@EnableEurekaServer

    @SpringBootApplication
@EnableEurekaServer
public class EurekaServerApplication {

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

2. 创建共有模块-common

  • 用于定义User共有类

  • 需要使用的依赖

    	<dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>RELEASE</version>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>jakarta.persistence</groupId>
      <artifactId>jakarta.persistence-api</artifactId>
      <version>2.2.3</version>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-core</artifactId>
      <version>5.4.31.Final</version>
      <scope>compile</scope>
</dependency>

  • User类,加入@Entity/@Table等，供服务(dbSerivce)进行数据库表映射

    /**
 * @Author: cailong
 * @Date: 2021/6/4 18:59
 * @Description: User实体类
 */
@Data
@ToString
@AllArgsConstructor
@NoArgsConstructor
@Entity
@Table(name = "tb_user")
public class User implements Serializable {

    private static final long serialVersionUID = 1L;
    @Id
    @GenericGenerator(name = "idGenerator", strategy = "uuid")
    @GeneratedValue(generator = "idGenerator")
    String uid;
    @Column(name = "username",length = 20)
    String userName;
    @Column(name = "password",length = 20)
    String passWord;
}

3. 创建数据库访问服务-DBService

  • pox.xml依赖导入

    		<!-- spring data jpa -->
		<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
		<!-- web -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
		<!-- 引入eureka client,服务发现和注册 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
		<!-- mysql驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.25</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
		
		<!-- 引入自主创建的公共模块 -->
        <dependency>
            <groupId>org.hcl</groupId>
            <artifactId>common</artifactId>
            <version>1.0-SNAPSHOT</version>
            <scope>compile</scope>
        </dependency>

  • 配置文件

    server.port=8085

spring.application.name=dbService
eureka.instance.hostname=localhost
eureka.client.service-url.defaultZone=http://localhost:8761/eureka/

spring.datasource.url=jdbc:mysql://localhost:3306/spring-cloud?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull&allowMultiQueries=true&useSSL=false
spring.datasource.username=root
spring.datasource.password=123456

spring.jpa.database=mysql
spring.jpa.database-platform=org.hibernate.dialect.MySQL5InnoDBDialect
spring.jpa.show-sql=false
spring.jpa.hibernate.ddl-auto=update

  • 创建接口UserRepository,继承JpaRepository来实现对User表的操作

    /**
 * @Author: cailong
 * @Date: 2021/6/4 19:13
 * @Description: 
 */
@Repository
public interface UserRepository extends JpaRepository<User,String> {
}

  • 控制器创建

    package com.example.dbservice.controller;

import com.example.dbservice.repository.UserRepository;
import lombok.extern.slf4j.Slf4j;
import org.hcl.common.User;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import java.util.Optional;

/**
 * @Author: cailong
 * @Date: 2021/6/4 19:18
 * @Description:
 */
@RestController
@Slf4j
public class UserController {

    @Resource
    private UserRepository userRepository;

    /**
     * 根据uid,查询对应的User
     * @param uid
     * @return
     */
    @RequestMapping("/send/{uid}")
    public User send(@PathVariable("uid") String uid){
        log.info("finding uid: "+uid);
        Optional<User> opUser = userRepository.findById(uid);
        if (!opUser.isPresent()) //没有找到对应uid,返回null
            return null;
        log.info(String.valueOf(opUser.get()));
        return opUser.get();
    }

    /**
     * 保存新用户
     * @param username
     * @param password
     * @return
     */
    @RequestMapping(value = "/save")
    public User save(String username,String password){
        User user = new User();
        user.setUserName(username);
        user.setPassWord(password);
        user = userRepository.save(user);
        log.info("save user:"+user);

        return user;
    }
}

  • 启动类配置

    package com.example.dbservice;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.domain.EntityScan;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

@SpringBootApplication
@EnableEurekaClient//开启服务发现与注册
@EntityScan(basePackageClasses = org.hcl.common.User.class)//扫描指定实体类
public class DbServiceApplication {

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

}

4. 创建生产者服务-producer

  • pox.xml,依赖

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

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

        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>

		<!-- feign -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.hcl</groupId>
            <artifactId>common</artifactId>
            <version>1.0-SNAPSHOT</version>
            <scope>compile</scope>
        </dependency>

  • 配置文件

    server.port=8082

spring.application.name=producer
eureka.instance.hostname=localhost
eureka.client.service-url.defaultZone=http://localhost:8761/eureka/

spring.rabbitmq.host=localhost
spring.rabbitmq.port=5672
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest

  • 创建FeignClient，用于调用dbService服务

    package com.hcl.producer;

import org.hcl.common.User;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;

/**
 * @Author: cailong
 * @Date: 2021/6/4 22:46
 * @Description: FeignClient，用于调用dbService服务
 */
@FeignClient(value = "dbService")
public interface DBServiceClient {

    @RequestMapping("/send/{uid}")
    User getUser(@PathVariable("uid") String uid);


}

  • 创建接口SendService,用于发送消息到对应的RibbitMQ队列

    package com.hcl.producer;

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

/**
 * @Author: cailong
 * @Date: 2021/6/4 20:34
 * @Description:
 */
public interface SendService {
    //建立myUserChannel队列
    @Output("myUserChannel")
    MessageChannel myUser();
}

  • 启动类，加入@EnableEurekaClient，@EnableFeignClients，@EnableBinding

    package com.hcl.producer;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.openfeign.EnableFeignClients;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.cloud.stream.annotation.EnableBinding;

@SpringBootApplication
@EnableEurekaClient
@EnableFeignClients //feign客户端
@EnableBinding(SendService.class) //绑定消息队列
public class ProducerApplication {

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

}

  • 控制器类

    package com.hcl.producer;

import lombok.extern.slf4j.Slf4j;
import org.hcl.common.User;
import org.springframework.messaging.Message;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

/**
 * @Author: cailong
 * @Date: 2021/6/4 22:44
 * @Description:
 */
@RestController
@Slf4j
public class ProducerController {

    @Resource
    private DBServiceClient dbServiceClient;
    @Resource
    SendService sendService;

    /**
     * 查找uid用户，如果找到就发送到消息队列中
     * @param uid
     * @return
     */
    @RequestMapping(value = "/sendUser")
    public String sendUser(String uid){
        User user = dbServiceClient.getUser(uid);
        log.info("user:"+user);
        if (user == null) {
            log.warn("fail ! case by uid=" + uid + " from user is null!");
            return "fail ! case by uid=" + uid + " from user is null!";
        }
        //创建消息
        Message msg = MessageBuilder.withPayload(user).build();
        boolean isSend = sendService.myUser().send(msg);
        log.info(isSend==true?"消息已发送到消息队列":"消息发送失败");
        return "SUCCESS!";
    }
}

5. 创建消费者-consumer

  • pox.xml 依赖导入

    		<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>2.4.5</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-stream-rabbit</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.hcl</groupId>
            <artifactId>common</artifactId>
            <version>1.0-SNAPSHOT</version>
            <scope>compile</scope>
        </dependency>

  • 配置文件

    server.port=8081

spring.application.name=consumer
eureka.instance.hostname=localhost
eureka.client.service-url.defaultZone=http://localhost:8761/eureka/

spring.rabbitmq.port=5672
spring.rabbitmq.host=localhost
spring.cloud.stream.bindings.myUserChannel.group=groupA

  • 接口ReceiveService创建，用于获取消息队列

    package com.hcl.consumer;

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

/**
 * @Author: cailong
 * @Date: 2021/6/4 23:06
 * @Description:
 */
public interface ReceiveService {

    @Input("myUserChannel")
    SubscribableChannel myUser();
}

  • 启动类，以及消息监听

    package com.hcl.consumer;

import lombok.extern.slf4j.Slf4j;
import org.hcl.common.User;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.stream.annotation.EnableBinding;
import org.springframework.cloud.stream.annotation.StreamListener;

@SpringBootApplication
@EnableEurekaClient
@EnableBinding(ReceiveService.class)
@Slf4j
public class ConsumerApplication {

    @Value("${spring.application.name}")
    String applicationName;

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

    /**
     * 接受消息队列中的消息
     * @param user
     */
    @StreamListener("myUserChannel")
    public void receive(User user){
        log.info("I'm "+applicationName);
        log.info("myUserChannel.groupA接收到消息："+user);
    }
}

second Consumer和Third Consumer 同consumer 几乎相同，不同在于配置文件中的

spring.cloud.stream.bindings.myUserChannel.group=groupA

consumer是groupA,而另外两个是groupB

四. 运行结果

  • 访问Eureka查看服务启动情况

    在这里插入图片描述

  • 查看RibbitMQ界面，myUserChannel.groupA和myUserChannel.groupB队列的消费者状态和绑定信息

    在这里插入图片描述

在这里插入图片描述

producer控制台输出

在这里插入图片描述

dbservice控制台输出

在这里插入图片描述

consumer控制台输出

在这里插入图片描述

consumer second 控制台输出

在这里插入图片描述

consumer third 控制台没有输出消息，原因是被consumer second消费了，这两者通过轮询的方式消费myUserChannel.groupB队列

五. 总结

  • 本次实验中RibbitMQ使用的Work模式

    工作队列(即任务队列)背后的主要思想是避免立即执行资源密集型任务，并且必须等待它完成。相反，我们将任务安排在稍后完成。

    我们将任务封装为消息并将其发送到队列。后台运行的工作进程将获取任务并最终执行任务。当运行多个消费者时，任务将在它们之间分发。

    使用任务队列的一个优点是能够轻松地并行工作。如果我们正在积压工作任务，我们可以添加更多工作进程，这样就可以轻松扩展消费者，但是只能有一个消费者获得消息！竞争消费者模式。

碼上跑
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
SpringCloud项目整合RabbitMQ
weixin_43028393的博客
03-28 4091
在应用程序中，我们可以使用publishMessage()方法来发布消息，并使用handleMessage()方法来处理接收到的消息。在上面的示例中，我们注入了名为“myOutputChannel”的输出通道，并在publishMessage()方法中使用它来发布消息。在我们的示例中，我们已经定义了一个名为“myInputChannel”的输入通道，并在MyMessageChannels接口中定义了它。在需要发送消息的地方，我们可以通过注入MessageChannel并使用send()方法来发送消息。
介绍Spring Cloud Stream与RabbitMQ集成
05-13
介绍Spring Cloud Stream与RabbitMQ集成的代码示例。Spring Cloud Stream是一个建立在Spring Boot和Spring Integration之上的框架，有助于创建事件驱动或消息驱动的微服务。
SpringCloud微服务 Stream集成RabbitMQ(一)
m0_54850825的博客
08-25 479
本小结我们将学习一下如何使用Spring Cloud Stream 来集成Rabbit MQ 并实现常规业务场景中的发布/订阅模式及其确认机制。在学习本小结之前我假设大家已对Spring Cloud Stream 和Rabbit MQ 有实际场景应用的能力，如果暂未掌握请自行学习，这里不赘述。通常而言，对于发布/订阅模式模式而言，消息的发送者一般只注重将消息推送到相应的Exchange 对应的Channel中，并不在意订阅者是否成功接收并消费掉某条消息。
SpringCloud微服务-RabbitMQ快速入门
m0_63144319的博客
03-06 769
中文是消息队列，字面来看就是存放消息的队列。也就是事件驱动架构中的Broker。消息：就是一个个待处理的事件。RabbitMQ是基于Erlang语言开发的开源消息通信中间件RabbitMQ部署指南。
SpringCloud微服务架构
Mr_Jin的博客
01-16 2万+
什么是微服务 微服务架构的基础是将的那个应用程序开发为一组小型独立服务，这些独立服务在自己的进程中运行，独立开发和部署。 SpringCloud Alibaba微服务： Spring Cloud Alibaba 是Spring Cloud的一个子项目，致力于提供微服务开发的一站式解决方案。此项目包含开发分布式应用微服务的必需组件，方便开发者通过 Spring Cloud 编程模型轻松使用这些组件来开发分布式应用服务。依托 Spring Cloud Alibaba，您只需要添加一些注解和少量配置，就可以
SpringCloud+RabbitMQ+Docker+Redis+搜索+分布式，系统详解springcloud微服务技术栈（Eureka、Ribbon）
m0_51448653的博客
04-18 939
SpringCloudAlibaba兼容了前面两种刚才将user-service服务的ip和端口硬编码在代码中的，有一定问题所以不能用硬编码方式搭建EurekaServer需要创建一个独立的微服务starter是springboot中的自动装配，也就是说在这个依赖中已经帮我们把springeureka的所有的配置都做好了，也就是说我们可以零配置直接拿来用了当然，自动装配是需要有开关的，第二步这个注解就是eurekaserver自动装配的开关。
SpringCloud微服务（一）SpringCloud+RabbitMQ+Docker+Redis+搜索+分布式一（RestTemplate、Eureka、Ribbon、Nacos、Feign）
weixin_53669566的博客
06-21 614
目录一、什么是微服务单体架构 分布式架构微服务结构服务拆分注意事项 微服务远程调用 1、步骤一：注册RestTemplate2、步骤2：服务远程调用RestTemplat​编辑提供者和消费者思考：服务A调用了服务B，服务B调用了服务C，那么服务B是什么角色答：一个服务既可以是提供者也可以是消费者，提供者和消费者是相对的，一个服务可以同时服务提供者和服务消费者Eureka注册中心思考：1、消费者如何获取服务提供者具体信息（1）服务者提供者启动时向eureka注册自己的信息（2）eureka保存这些信息（3）消
SpringCloud+RabbitMQ+Docker+Redis+搜索+分布式，系统详解springcloud微服务技术栈（Feign、Gateway）
m0_51448653的博客
04-19 513
创建一个全新的module，做一个独立的服务因为网关本身也是一个微服务，因此也需要把自己注册到nacos，或者从nacos拉取服务，所以要有服务注册发现依赖--nacos服务注册发现依赖--> < dependency > < groupId > com.alibaba.cloud < artifactId > spring-cloud-starter-alibaba-nacos-discovery
【微服务 从0开始 】Spring Cloud 简单搭建一个微服务项目
热门推荐
03-29 5万+
Spring boot 简介 构建一个微服务
springcloud微服务架构搭建过程
拒绝躺平，适当内卷
03-16 1983
springcloud 微服务搭建
SpringCloud微服务架构开发——01微服务架构与SpringCloud
weixin_43624810的博客
04-30 1337
认识架构 1.单体架构 一个典型的单体应用就是将所有业务场景的表示层、业务逻辑层和数据访问层放在一个工程中，最终经过编译、打包，部署在一台服务器上。以一个进存销系统的单体应用为例，架构如下图所示。 单体架构的缺点： 单体应用中，随着业务越来越复杂，应用需要增加的功能越来越多，单体应用的代码量越来越大，代码可读性、可维护性和扩展性会下降。同时，单体应用带来的隐患会比较多，由于系统的庞大以及关联较多，应用中的任何一个Bug都有可能导致整个系统宕机。 2.SOA架构 SOA架构是一个面向服务的架.
springcloud微服务技术栈-个人笔记文档（基础篇）
08-05
SpringCloud+RabbitMQ+Docker+Redis+搜索+分布式-个人笔记文档（基础篇）
基于SpringCloud微服务架构社交系统的设计与实现
04-16
能学到什么：①SpringCloud微服务框架、DL4J智能分类框架、Webmagic爬虫框架、RabbitMQ、Jenkins持续集成、IM、等是怎么在系统中体现的；②数据爬取、数据智能分类、消息通知微服务、即时通讯微服务、问答微服务、...
springcloud微服务项目.rar
08-15
本人年初在上海某马培训的微服务实战项目，使用了Spring-mvc、Spring、Mybatis＋SpringBoot＋SpringCloud＋Redis + MySQL5.7 ＋ JDK8 ＋ Maven ＋ Nginx ＋ RabbitMQ 等最新的框架和技术栈，对于学习微服务有很大的...
SpringCloud微服务框架
12-21
包含mp、feign、gateway、rabbitmq、nacos
operator ＜=＞ (spaceship operator)
janeqi1987的专栏
05-28 1007
= 与!= 操作符为了检查是否相等，现在定义== 操作符就够了。当编译器找不到表达式的匹配声明a!=b 时，编译器会重写表达式并查找!(a==b)。若这不起作用，编译器也会尝试改变操作数的顺序，所以也会尝试!(b==a):a!=b,!(b==a)因此，对于TypeA 的a 和TypeB 的b，编译器将能够识别并编译a!= b若需要的话，可以这样做• 一个独立函数operator!• 一个独立函数operator==(TypeA, TypeB)
Java 异常处理中try-catch块、finally子句以及自定义异常的使用
最新发布
Itmastergo的博客
05-31 804
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
Java手动启动jar包
liangweihao的博客
05-29 296
【代码】Java手动启动jar包。
java调用cmd执行命令
weixin_45210565的博客
05-28 260
3、exec(String command, String[] envp) ，在调用外部程序之前设置系统环境变量，该变量仅供command入参使用，envp每个元素为一个系统环境变量，并且字符串格式为“环境变量名=环境变量值”。2、exec(String[] cmdArray) ，调用外部程序，入参cmdArray的元素将组合成为一条完整的外部可执行程序的启动路径或命令。1、exec(String command) ，调用外部程序，入参command为外部可执行程序的启动路径或命令。
springcloud微服务架构
05-09
Spring Cloud 是基于 Spring Boot 实现的微服务架构开发工具包，它提供了一系列开箱即用的服务治理工具，如服务注册与发现、配置中心、负载均衡、断路器、链路追踪、网关等，可以帮助我们快速构建微服务应用。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值