Spring cloud微服务结合RibbitMQ消息队列

最新推荐文章于 2022-06-15 14:05:50 发布

佳涛

最新推荐文章于 2022-06-15 14:05:50 发布

阅读量120

点赞数

分类专栏： springcloud 文章标签： java 后端 spring boot 中间件 rabbitmq

本文链接：https://blog.csdn.net/shy_taode/article/details/117693328

版权

springcloud 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

一、系统结构

系统结构完成目标：
1.生产者Producer具备Feign客户端，调用dbService微服务;
2.增加微服务dbService,通过Spring Data Jpa 访问数据库获取对象user;
3.生产者Producer将获取对象user通过RabbitMQ,发送给消费组groupA和groupB;

二、操作环境

Window10
Mysql5.12
erl10.4
rabbitmq 3.7.15
idea2021.1.2

三、实现代码

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

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

@SpringBootApplication
@EnableEurekaServer
public class EurekaServerApplication {

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

2.创建共有模块-common

添加公共使用模块
导入依赖架包

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>5.4.31.Final</version>
        </dependency>

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

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

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;
import org.hibernate.annotations.GenericGenerator;

import javax.persistence.*;
import java.io.Serializable;

/**
 * @author ljt
 * @date 2021/6/6 0006 16:06
 */
@Data
@ToString
@AllArgsConstructor
@NoArgsConstructor
@Entity
@Table(name = "tb_user")
public class User implements Serializable {
    private static final long serialVersionUID = 1L;

    @Id
    @Column(length = 128)
    @GenericGenerator(name = "idGenerator", strategy = "uuid")
    @GeneratedValue(generator = "idGenerator")
    String uid;
    @Column(name = "username", length = 20)
    String userName;
    @Column(name = "password", length = 20)
    String passWord;
}

这里创建完运行一下maven install 操作。

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

架包依赖

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</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>
        <dependency>
            <groupId>com.example</groupId>
            <artifactId>Common</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.12</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</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/student?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull&allowMultiQueries
spring.datasource.username=root
spring.datasource.password=root

spring.datasource.driverClassName=com.mysql.jdbc.Driver
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表的操作

import com.example.common.bean.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface UserRepository extends JpaRepository<User,String> {
}

控制器UserController

import com.example.common.bean.User;
import lombok.extern.slf4j.Slf4j;
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 ljt
 * @date 2021/6/6 0006 19:45
 */
@RestController
@Slf4j
public class UserController {

    @Resource
    private UserRepository userRepository;

    /**
     * 根据uid 查询user对象
     */
    @RequestMapping("/send/{uid}")
    public User send(@PathVariable("uid") String uid){
        log.info("finding uid: "+uid);
        Optional<User> optionalUser = userRepository.findById(uid);
        if (!optionalUser.isPresent())
            return null;

        log.info(String.valueOf(optionalUser.get()));
        return optionalUser.get();
    }

    /***
     * 保存用户信息
     * @param username
     * @param password
     * @return
     */
    @RequestMapping("/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;
    }
}

启动类DbServiceApplication

import com.example.common.bean.User;
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 = User.class) // 扫描指定实体类
public class DbServiceApplication {

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

4.创建生产者服务-producer

架包依赖

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</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-starter-netflix-eureka-client</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>com.example</groupId>
            <artifactId>Common</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.amqp</groupId>
            <artifactId>spring-rabbit-test</artifactId>
            <scope>test</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服务

import com.example.common.bean.User;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;

@FeignClient(value = "dbService")
public interface DBServiceClient {

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

}

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

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

public interface SendService {
    // 建立myUserChannel队列
    @Output("myUserChannel")
    MessageChannel myUser();
    
}

控制器类ProducerController

import com.example.common.bean.User;
import lombok.extern.slf4j.Slf4j;
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 ljt
 * @date 2021/6/6 0006 20:31
 */
@RestController
@Slf4j
public class ProducerController {

    @Resource
    private DBServiceClient dbServiceClient;
    @Resource
    SendService sendService;

    @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!";

    }
}

启动类ProducerApplication

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.stream.annotation.EnableBinding;

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

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

}

5.创建消费者-consumer

依赖架包

        <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>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>com.example</groupId>
            <artifactId>Common</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.amqp</groupId>
            <artifactId>spring-rabbit-test</artifactId>
            <scope>test</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

接收消息服务类

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

public interface ReceiveService {

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

启动类ConsumerApplication

import com.example.common.bean.User;
import lombok.extern.slf4j.Slf4j;
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);
    }

    @StreamListener("myUserChannel")
    public void receive(User user){
        log.info("I'm " + applicationName);
        log.info("myUserChannel.groupA接收到消息：" + user);
    }

}

6.创建消费者-second-consumer

依赖架包

        <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>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>com.example</groupId>
            <artifactId>Common</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>

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

配置文件

server.port=8083

spring.application.name=second-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=groupB

接收消息服务类

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

public interface ReceiveService {

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

启动类SecondConsumerApplication

import com.example.common.bean.User;
import lombok.extern.slf4j.Slf4j;
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 SecondConsumerApplication {


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

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

    @StreamListener("myUserChannel")
    public void receive(User user){
        log.info("I'm " + applicationName);
        log.info("myUserChannel.groupB接收到消息：" + user);
    }
}

7.创建消费者- third-consumer

依赖架包

        <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>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>com.example</groupId>
            <artifactId>Common</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>

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

配置文件

server.port=8084

spring.application.name=third-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=groupB

接收消息服务类

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

public interface ReceiveService {

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

启动类ThirdConsumerApplication

import com.example.common.bean.User;
import lombok.extern.slf4j.Slf4j;
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
@Slf4j
@EnableBinding(ReceiveService.class)
public class ThirdConsumerApplication {

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

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

    @StreamListener("myUserChannel")
    public void receive(User user){
        log.info("I'm " + applicationName);
        log.info("myUserChannel.groupB接收到消息：" + user);
    }
}

四、运行截图

Eureka注册中心已注册的服务
服务提供者运行，使用8082端口
第一个groupA的消费者，使用8081端口
groupB的两个消费者，分别使用8083与8084端口
rabbitMQ里面已经连接的通道，对应上面几个本地端口
首先保存一个用户
查询刚刚插入的用户
DBServer的数据查询

此时的消息传递过程

producer控制台显示：发出消息
groupA中consumer接收到消息
groupB中second消费者接收到消息
此时groupB中third接收不到消息，因为以及被同组的second消费者消费掉了。这两者通过轮询的方式消费myUserChannel.groupB队列

五、总结

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

工作队列(即任务队列)背后的主要思想是避免立即执行资源密集型任务，并且必须等待它完成。相反，我们将任务安排在稍后完成。
我们将任务封装为消息并将其发送到队列。后台运行的工作进程将获取任务并最终执行任务。当运行多个消费者时，任务将在它们之间分发。
使用任务队列的一个优点是能够轻松地并行工作。如果我们正在积压工作任务，我们可以添加更多工作进程，这样就可以轻松扩展消费者，但是只能有一个消费者获得消息！竞争消费者模式。