微服务框架SpringcloudAlibaba+Nacos集成RabbitMQ
  D49yXDf6ruYT 2023年12月02日 16 0


目前公司使用jeepluscloud版本，这个版本没有集成消息队列，这里记录一下，集成的过程；这个框架跟ruoyi的那个微服务版本结构一模一样，所以也可以快速上手。

1.项目结构图：

配置类的东西做成一个公共的模块

微服务框架SpringcloudAlibaba+Nacos集成RabbitMQ_spring

rabbitmq模块:

微服务框架SpringcloudAlibaba+Nacos集成RabbitMQ_微服务_02

2.核心配置

1.pom类

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>jeeplus-common</artifactId>
        <groupId>org.jeeplus</groupId>
        <version>${revision}</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>jeeplus-common-rabbitmq</artifactId>
    <packaging>jar</packaging>

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

        <dependency>
            <groupId>org.jeeplus</groupId>
            <artifactId>jeeplus-common-core</artifactId>
            <version>${project.parent.version}</version>
        </dependency>

    </dependencies>
</project>

2.ConditionalOnRabbit

package com.jeeplus.common.rabbit.conditional;

import org.springframework.context.annotation.Conditional;

import java.lang.annotation.*;

/**
 * 判断系统是否在启用了Rabbit, 未启用的情况下不将Bean注册到系统中
 *
 * 使用场景: 在不使用Rabbit中间件但未去除Rabbit依赖的情况下, 通过配置文件中关闭Rabbit选项，
 * 同时将这个注解到有`@RabbitListener`标志的类上，让这个对象不注册到Spring容器中,
 * 从而避免`RabbitMQ`进行无限尝试重连服务器，导致项目一直抛出异常，影响开发和使用。
 *
 * @author xxm
 * @since 2022/12/12
 */
@Target({ ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional(OnRabbitEnable.class)
public @interface ConditionalOnRabbit {

}

3.OnRabbitEnable

package com.jeeplus.common.rabbit.conditional;

import com.jeeplus.common.rabbit.configuration.RabbitMqProperties;
import org.springframework.boot.context.properties.bind.Binder;
import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.type.AnnotatedTypeMetadata;

/**
 * 判断是否在启用了Rabbit, 用来控制在没启用Rabbit情况下. 不将 @RabbitListener 修饰的监听器注册为Bean, 不然会导致无限尝试重连
 *
 * @author xxm
 * @since 2022/12/12
 */
public class OnRabbitEnable implements Condition {

    private final String rabbitPropertiesPrefix = "com.jeeplus.common.rabbit";

    /**
     * @param context
     * @param metadata
     * @return
     */
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        RabbitMqProperties rabbitMqProperties = Binder.get(context.getEnvironment())
            .bind(rabbitPropertiesPrefix, RabbitMqProperties.class)
            .orElse(new RabbitMqProperties());
        return rabbitMqProperties.isEnable();
    }

}

4.BootxRabbitListenerConfigurer

package com.jeeplus.common.rabbit.configuration;

import lombok.RequiredArgsConstructor;
import org.springframework.amqp.rabbit.annotation.RabbitListenerConfigurer;
import org.springframework.amqp.rabbit.listener.RabbitListenerEndpointRegistrar;
import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.handler.annotation.support.DefaultMessageHandlerMethodFactory;

/**
 * Rabbit 侦听器配置器
 *
 * @author xxm
 * @since 2021/6/25
 */
@Configuration
@RequiredArgsConstructor
public class BootxRabbitListenerConfigurer implements RabbitListenerConfigurer {

    private final DefaultMessageHandlerMethodFactory jsonHandlerMethodFactory;

    @Override
    public void configureRabbitListeners(RabbitListenerEndpointRegistrar registrar) {
        registrar.setMessageHandlerMethodFactory(jsonHandlerMethodFactory);
    }

}

5.BootxRabbitListenerConfigurer

package com.jeeplus.common.rabbit.configuration;

import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.amqp.rabbit.annotation.EnableRabbit;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.converter.MappingJackson2MessageConverter;
import org.springframework.messaging.handler.annotation.support.DefaultMessageHandlerMethodFactory;

/**
 * 消息队列配置
 *
 * @author xxm
 * @since 2021/6/25
 */
@EnableRabbit
@Configuration
public class RabbitMqConfigurer {

    /**
     * 注册 RabbitTemplate 对象, 使用默认序列化方式
     */
    @Bean
    public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory, ObjectMapper objectMapper) {
        RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
        // 使用系统同版jackson 序列化配置
        rabbitTemplate.setMessageConverter(new Jackson2JsonMessageConverter(objectMapper));
        return rabbitTemplate;
    }

    /**
     * 添加默认消息序列化方式, 使用默认序列化方式
     */
    @Bean
    public DefaultMessageHandlerMethodFactory jsonHandlerMethodFactory(ObjectMapper objectMapper) {
        DefaultMessageHandlerMethodFactory factory = new DefaultMessageHandlerMethodFactory();
        // 这里的转换器设置实现了 通过 @Payload 注解 自动反序列化message body
        MappingJackson2MessageConverter converter = new MappingJackson2MessageConverter();
        converter.setObjectMapper(objectMapper);
        factory.setMessageConverter(converter);
        return factory;
    }

}

6.RabbitMqConfigurer

package com.jeeplus.common.rabbit.configuration;

import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.amqp.rabbit.annotation.EnableRabbit;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.converter.MappingJackson2MessageConverter;
import org.springframework.messaging.handler.annotation.support.DefaultMessageHandlerMethodFactory;

/**
 * 消息队列配置
 *
 * @author xxm
 * @since 2021/6/25
 */
@EnableRabbit
@Configuration
public class RabbitMqConfigurer {

    /**
     * 注册 RabbitTemplate 对象, 使用默认序列化方式
     */
    @Bean
    public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory, ObjectMapper objectMapper) {
        RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
        // 使用系统同版jackson 序列化配置
        rabbitTemplate.setMessageConverter(new Jackson2JsonMessageConverter(objectMapper));
        return rabbitTemplate;
    }

    /**
     * 添加默认消息序列化方式, 使用默认序列化方式
     */
    @Bean
    public DefaultMessageHandlerMethodFactory jsonHandlerMethodFactory(ObjectMapper objectMapper) {
        DefaultMessageHandlerMethodFactory factory = new DefaultMessageHandlerMethodFactory();
        // 这里的转换器设置实现了 通过 @Payload 注解 自动反序列化message body
        MappingJackson2MessageConverter converter = new MappingJackson2MessageConverter();
        converter.setObjectMapper(objectMapper);
        factory.setMessageConverter(converter);
        return factory;
    }

}

7.RabbitMqProperties

package com.jeeplus.common.rabbit.configuration;

import com.jeeplus.common.rabbit.conditional.ConditionalOnRabbit;
import lombok.Getter;
import lombok.Setter;
import org.springframework.boot.context.properties.ConfigurationProperties;

/**
 * MQTT配置
 *
 * @author xxm
 * @since 2022/12/12
 */
@Getter
@Setter
@ConfigurationProperties("com.jeeplus.common.rabbit")
public class RabbitMqProperties {

    /**
     * 是否开启 RabbitMQ功能,
     * @see ConditionalOnRabbit 配合此注解使用
     */
    private boolean enable = false;

}

8.RabbitMqCommonAutoConfiguration

package com.jeeplus.common.rabbit;

import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * RabbitMQ配置
 *
 * @author xxm
 * @since 2022/5/3
 */
@SpringBootApplication
public class RabbitMqCommonAutoConfiguration {

}

微服务框架SpringcloudAlibaba+Nacos集成RabbitMQ_序列化_03

9.org.springframework.boot.autoconfigure.AutoConfiguration.imports

RabbitMqCommonAutoConfiguration

10.spring.factories

## 配置自定义 starter 的自动化配置
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  com.jeeplus.common.rabbit.RabbitMqCommonAutoConfiguration

3. nacos配置

哪一个服务模块需要消息队列，就在对应的yml文件中配置 rabbit链接

微服务框架SpringcloudAlibaba+Nacos集成RabbitMQ_架构_04

#rabbitmq
  rabbitmq:
    host: localhost
    port: 5627
    username: root
    password: root123
    virtual-host: /
    publisher-confirm-type: correlated
    listener:
      simple:
        acknowledge-mode: manual

4.服务中调用rabbitmq

建立两个包，配置类和监听类

微服务框架SpringcloudAlibaba+Nacos集成RabbitMQ_微服务_05

1.mq模板配置

package com.jeeplus.duxin.config;

import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
import org.springframework.amqp.support.converter.MessageConverter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;

/**
 * mq模板
 * @author lgn
 * @date 2023/10/28 10:15
 */
@Configuration
public class MyRabbitConfig {

    private RabbitTemplate rabbitTemplate;

    @Primary
    @Bean
    public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory) {
        RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
        this.rabbitTemplate = rabbitTemplate;
        rabbitTemplate.setMessageConverter(messageConverter());
        initRabbitTemplate();
        return rabbitTemplate;
    }

    @Bean
    public MessageConverter messageConverter() {
        return new Jackson2JsonMessageConverter();
    }

    /**
     * 定制RabbitTemplate
     * 1、服务收到消息就会回调
     *      1、spring.rabbitmq.publisher-confirms: true
     *      2、设置确认回调
     * 2、消息正确抵达队列就会进行回调
     *      1、spring.rabbitmq.publisher-returns: true
     *         spring.rabbitmq.template.mandatory: true
     *      2、设置确认回调ReturnCallback
     *
     * 3、消费端确认(保证每个消息都被正确消费，此时才可以broker删除这个消息)
     *
     */
    // @PostConstruct  //MyRabbitConfig对象创建完成以后，执行这个方法
    public void initRabbitTemplate() {

        /**
         * 1、只要消息抵达Broker就ack=true
         * correlationData：当前消息的唯一关联数据(这个是消息的唯一id)
         * ack：消息是否成功收到
         * cause：失败的原因
         */
        //设置确认回调
        rabbitTemplate.setConfirmCallback((correlationData,ack,cause) -> {
            System.out.println("confirm...correlationData["+correlationData+"]==>ack:["+ack+"]==>cause:["+cause+"]");
        });


        /**
         * 只要消息没有投递给指定的队列，就触发这个失败回调
         * message：投递失败的消息详细信息
         * replyCode：回复的状态码
         * replyText：回复的文本内容
         * exchange：当时这个消息发给哪个交换机
         * routingKey：当时这个消息用哪个路邮键
         */
        rabbitTemplate.setReturnCallback((message,replyCode,replyText,exchange,routingKey) -> {
            System.out.println("Fail Message["+message+"]==>replyCode["+replyCode+"]" +
                    "==>replyText["+replyText+"]==>exchange["+exchange+"]==>routingKey["+routingKey+"]");
        });
    }
}

2.服务交换机 队列设置

初始化交换机，队列，建立绑定。

package com.jeeplus.duxin.config;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.Exchange;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.HashMap;

/**
 * 服务交换机 队列设置
 * @author lgn
 * @date 2023/10/28 10:16
 */
@Configuration
public class MyRabbitMQConfig {

    /* 容器中的Queue、Exchange、Binding 会自动创建（在RabbitMQ）不存在的情况下 */

/*    *//**
     * 初始化队列
     * 死信队列
     *
     * @return
     *//*@Bean
    public Queue orderDelayQueue() {
        *//*
            Queue(String name,  队列名字
            boolean durable,  是否持久化
            boolean exclusive,  是否排他
            boolean autoDelete, 是否自动删除
            Map<String, Object> arguments) 属性
         *//*
        HashMap<String, Object> arguments = new HashMap<>();
        arguments.put("x-dead-letter-exchange", "order-event-exchange");
        arguments.put("x-dead-letter-routing-key", "order.release.order");
        arguments.put("x-message-ttl", 60000); // 消息过期时间 1分钟
        Queue queue = new Queue("order.delay.queue", true, false, false, arguments);

        return queue;
    }*/

/*    *//**
     * 初始化队列
     * 普通队列
     *
     * @return
     *//*
    @Bean
    public Queue orderReleaseQueue() {

        Queue queue = new Queue("order.release.order.queue", true, false, false);

        return queue;
    }*/

/*    *//**
     *
     * TopicExchange
     * 创建topic类型的交换机
     * @return
     *//*
    @Bean
    public Exchange orderEventExchange() {
        *//*
         *   String name,
         *   boolean durable,
         *   boolean autoDelete,
         *   Map<String, Object> arguments
         * *//*
        return new TopicExchange("order-event-exchange", true, false);

    }*/


/*    *//**
     * 路由和交换机进行绑定 设置路由key
     * @author lgn
     * @date 2023/10/28 10:33
     * @return Binding
     *//*
    @Bean
    public Binding orderCreateBinding() {
        *//*
         * String destination, 目的地（队列名或者交换机名字）
         * DestinationType destinationType, 目的地类型（Queue、Exhcange）
         * String exchange,
         * String routingKey,
         * Map<String, Object> arguments
         * *//*
        return new Binding("order.delay.queue",
                Binding.DestinationType.QUEUE,
                "order-event-exchange",
                "order.create.order",
                null);
    }*/

/*    @Bean
    public Binding orderReleaseBinding() {

        return new Binding("order.release.order.queue",
                Binding.DestinationType.QUEUE,
                "order-event-exchange",
                "order.release.order",
                null);
    }

    *//**
     * 订单释放直接和库存释放进行绑定
     * @return
     *//*
    @Bean
    public Binding orderReleaseOtherBinding() {

        return new Binding("stock.release.stock.queue",
                Binding.DestinationType.QUEUE,
                "order-event-exchange",
                "order.release.other.#",
                null);
    }*/


/*    *//**
     * 初始化队列
     * 商品秒杀队列
     * @return
     *//*
    @Bean
    public Queue orderSecKillOrrderQueue() {
        Queue queue = new Queue("order.seckill.order.queue", true, false, false);
        return queue;
    }

    @Bean
    public Binding orderSecKillOrrderQueueBinding() {
        //String destination, DestinationType destinationType, String exchange, String routingKey,
        // 			Map<String, Object> arguments
        Binding binding = new Binding(
                "order.seckill.order.queue",
                Binding.DestinationType.QUEUE,
                "order-event-exchange",
                "order.seckill.order",
                null);

        return binding;
    }*/

    /**
     * BOM模块的交换机
     * TopicExchange
     * 创建topic类型的交换机
     * @return
     */
    @Bean
    public Exchange orderEventExchange() {
        /*
         *   String name,
         *   boolean durable,
         *   boolean autoDelete,
         *   Map<String, Object> arguments
         * */
        return new TopicExchange("bom-event-exchange", true, false);

    }

    /**
     * 初始化BOM队列
     * @return
     */
    @Bean
    public Queue bomMaintenanceQueue() {
        Queue queue = new Queue("bom.maintenance.queue", true, false, false);
        return queue;
    }

    /**
     * bom
     * 路由和交换机进行绑定 设置路由key
     * @author lgn
     * @date 2023/10/28 10:33
     * @return Binding
     */
    @Bean
    public Binding bomCreateBinding() {
        /*
         * String destination, 目的地（队列名或者交换机名字）
         * DestinationType destinationType, 目的地类型（Queue、Exhcange）
         * String exchange,
         * String routingKey,
         * Map<String, Object> arguments
         * */
        return new Binding("bom.maintenance.queue",
                Binding.DestinationType.QUEUE,
                "bom-event-exchange",
                "bom.maintenance.create",
                null);
    }

    /**
     * 初始化产品存货档案队列
     * @return
     */
    @Bean
    public Queue stockDocQueue() {
        Queue queue = new Queue("stock.doc.queue", true, false, false);
        return queue;
    }

    /**
     * 存货档案StockDoc
     * 路由和交换机进行绑定 设置路由key
     * @author lgn
     * @date 2023/10/28 10:33
     * @return Binding
     */
    @Bean
    public Binding docCreateBinding() {
        /*
         * String destination, 目的地（队列名或者交换机名字）
         * DestinationType destinationType, 目的地类型（Queue、Exhcange）
         * String exchange,
         * String routingKey,
         * Map<String, Object> arguments
         * */
        return new Binding("stock.doc.queue",
                Binding.DestinationType.QUEUE,
                "bom-event-exchange",
                "stock.doc.create",
                null);
    }


    /**
     * 调用C++模块的交换机
     * TopicExchange
     * 创建topic类型的交换机
     * @return
     */
    @Bean
    public Exchange cEventExchange() {
        /*
         *   String name,
         *   boolean durable,
         *   boolean autoDelete,
         *   Map<String, Object> arguments
         * */
        return new TopicExchange("c-event-exchange", true, false);

    }

    /**
     * 初始化c++生成记录文件队列
     * @return
     */
    @Bean
    public Queue cCreatFileQueue() {
        Queue queue = new Queue("c.creatfile.queue", true, false, false);
        return queue;
    }

    /**
     * 初始化c++签名队列
     * @return
     */
    @Bean
    public Queue cDealQueue() {
        Queue queue = new Queue("c.deal.queue", true, false, false);
        return queue;
    }

    /** 
     * 创建绑定关系
     * @author lgn
     * @date 2023/10/30 9:34
     * @return Binding
     */
    @Bean
    public Binding cCreatFileCreateBinding() {
        /*
         * String destination, 目的地（队列名或者交换机名字）
         * DestinationType destinationType, 目的地类型（Queue、Exhcange）
         * String exchange,
         * String routingKey,
         * Map<String, Object> arguments
         * */
        return new Binding("c.creatfile.queue",
                Binding.DestinationType.QUEUE,
                "c-event-exchange",
                "c.creatFile.create",
                null);
    }


    /**
     * 创建绑定关系
     * @author lgn
     * @date 2023/10/30 9:34
     * @return Binding
     */
    @Bean
    public Binding cDealBinding() {
        /*
         * String destination, 目的地（队列名或者交换机名字）
         * DestinationType destinationType, 目的地类型（Queue、Exhcange）
         * String exchange,
         * String routingKey,
         * Map<String, Object> arguments
         * */
        return new Binding("c.deal.queue",
                Binding.DestinationType.QUEUE,
                "c-event-exchange",
                "c.deal.create",
                null);
    }


}

3.监听队列 接收消息

消费方消费消息

package com.jeeplus.duxin.listener;

import com.rabbitmq.client.Channel;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.io.IOException;

/**
 * 监听路由信息
 * @author lgn
 * @date 2023/10/28 10:33
 */
@Slf4j
@Component
//@RabbitListener标注在方法上，直接监听指定的队列，此时接收的参数需要与发送时类型一致
//@RabbitListener 注解是指定某方法作为消息消费的方法，例如监听某 Queue 里面的消息。
@RabbitListener(queues = "bom.maintenance.queue")
public class MQTestListener {

    //@RabbitListener 可以标注在类上面，需配合 @RabbitHandler 注解一起使用
    //@RabbitListener 标注在类上面表示当有收到消息的时候，就交给 @RabbitHandler 的方法处理，根据接受的参数类型进入具体的方法中。
    @RabbitHandler
    public void listener(String info,Channel channel, Message message) throws IOException {

        System.out.println("=============接收消息开始执行："+info);

        try {
            channel.basicAck(message.getMessageProperties().getDeliveryTag(),false);
        } catch (Exception e) {
            channel.basicReject(message.getMessageProperties().getDeliveryTag(),true);
        }

    }
}

5.使用

使用起来也非常方便：
在业务service中直接调用，生产者消息发送。

/**
	 * mqTest
	 * @author lgn
	 * @date 2023/10/28 10:03
	 * @return Object
	 */
    public String mqTest() {
		//TODO 订单创建成功，发送消息给MQ
		rabbitTemplate.convertAndSend("bom-event-exchange","bom.maintenance.create","1234");
		return null;
    }

希望对你有用！


【版权声明】本文内容来自摩杜云社区用户原创、第三方投稿、转载，内容版权归原作者所有。本网站的目的在于传递更多信息，不拥有版权，亦不承担相应法律责任。如果您发现本社区中有涉嫌抄袭的内容，欢迎发送邮件进行举报，并提供相关证据，一经查实，本社区将立刻删除涉嫌侵权内容，举报邮箱： cloudbbs@moduyun.com
  1. 分享：
最后一次编辑于 2023年12月02日 0

暂无评论

推荐阅读
  ejdQbmcNduLw   2023年12月23日   64   0   0 分布式系统springCloudspring cloud架构Cloud架构spring cloudspring分布式系统
  WuI4stbRPSwJ   2023年12月23日   27   0   0 GraviteGraviteCockpitCockpit数据数据API管理平台API管理平台微服务微服务
  ejdQbmcNduLw   2023年12月23日   51   0   0 Java序列化javaspring bootspringspringspring bootredisRedis序列化
  CcFwX2bC0dgf   2023年12月19日   12   0   0 springspringboot监听器listener事件event事件监听机制springboot事件监听机制spring事件event监听器listener
  ejdQbmcNduLw   2023年12月23日   17   0   0 分布式系统springhystrix断路器spring cloudspring cloud断路器springhystrix分布式系统
  NrKhGdPqPgIO   2023年12月23日   43   0   0 Javaredisjavaidespringspringrediside
  WuI4stbRPSwJ   2023年12月19日   48   0   0 状态模式前端干净架构架构架构前端架构前端架构前端状态模式干净架构
  ejdQbmcNduLw   2023年12月23日   29   0   0 CloudCloudspring cloudspring cloudspringspring配置文件配置文件eurekaeureka
  IdAbMGfNl7YD   2023年12月23日   44   0   0 kubernetes云原生容器2d2d容器rancherrancher云原生kubernetes
  gxJ4jYVTC9IN   2023年12月23日   18   0   0 springrocketmqrocketmq推送负载均衡spring推送负载均衡
  IdAbMGfNl7YD   2023年12月23日   54   0   0 容器kubernetes云原生容器kubernetes云原生
  GlkGUhBxsw3T   2023年12月19日   15   0   0 Javamavenmavenjavaspringspring
  NrKhGdPqPgIO   2023年12月19日   15   0   0 Java业务逻辑javaidespring bootspringspring bootspring业务逻辑ide
  WuI4stbRPSwJ   2023年12月23日   35   0   0 数据DaprITCNCF云原生IT数据CNCFDapr云原生
  PaOhvuHAwZ1R   2023年12月23日   42   0   0 数据微服务企业培训数据微服务企业培训
  NrKhGdPqPgIO   2023年12月19日   13   0   0 Java缓存redisjava数据库数据库springspring缓存redis
  NrKhGdPqPgIO   2023年12月23日   46   0   0 redis线程安全数据库数据库安全安全springspring线程安全redis
D49yXDf6ruYT
D49yXDf6ruYT
作者其他文章 更多
在win10环境下安装python，配置python环境，执行python脚本

2023-12-08

微服务框架SpringcloudAlibaba+Nacos集成RabbitMQ

2023-12-02

rabbitmq消费端限流:一次只能消费一条消息

2023-12-01

window系统修改rabbitmq 默认端口

2023-12-01

swagger3.0设置分组和配置多个扫描路径和过滤URL

2023-11-13

Windows环境设置mysql自动备份

2023-11-02

SpringCloudGateway网关整合swagger3+Knife4j3，basePath丢失请求404问题

2023-11-02

Windows系统编写bat脚本启动，停止，重启Java服务jar包

2023-11-02

Neo4j---性能优化

2023-11-02

neo4j常用语法

2023-11-02

最新推荐 更多
vue3早已具备抛弃虚拟DOM的能力了

2024-05-08

Vue3 除了 keep-alive，还有哪些页面缓存的实现方案

2024-05-08

十分钟，带你了解 Vue3 的新写法

2024-05-08

如何判断一个js对象是否存在循环引用

2024-05-08

页面嵌套，界面套娃，除了用iframe，还有其他方式吗？

2024-05-08

【动画进阶】巧用 CSS/SVG 实现复杂线条光效动画

2024-05-08

说说你对盒子模型的理解?

2024-05-08

HTML页面关于高分屏的设置

2024-05-04

Vue列表过滤与排序

2024-05-02

Vue3+Ts i18n实现国际化

2024-04-30

一款极简的聊天应用

2024-04-30

你是怎么理解ES6中 Promise的？使用场景？

2024-04-30

微信读书助手迎来史诗级增强

2024-04-30

Radash库使用说明——数组方法篇（全）

2024-04-30

uniapp+vue3聊天室|uni-app+vite4+uv-ui跨端仿微信app聊天语音/朋友圈

2024-04-29

在vue2中，什么是双向绑定，为什么vue3要进行优化？

2024-04-29

为什么vue打印的对象在浏览器中显示...

2024-04-28

浏览器开发者工具DevTools中提升效率的小技巧

2024-04-28

google浏览器插件开发

2024-04-28

厉害了！这个工具帮助你生成朋友圈转发截图

2024-04-28

常用标签
数据数据数据数据javalinuxlinuxpythonCentOSredisJava区块链技术python区块链信息系统字符串MySQL资讯项目管理mysql教程MySQL