hry2015
hry2015

Spring Boot系列十五 spring boot集成RabbitMQ 源码分析

1. 概述

在这篇文章Spring Boot系列十三 Spring Boot集成RabbitMQ中，我们介绍了在Spring Boot如何使用RabbitMQ，本篇文章中，从源码中分析Spring Boot如何集成RabbitMQ。

2. 入口

在spring-boot-autoconfigure.jar中的spring.factories中有如下定义，表示spring启动时，会执行RabbitAutoConfiguration的初始化

… 
# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,\
…

3. RabbitProperties

application_*.yml属性文件

spring:
  # 配置rabbitMQspring:
  rabbitmq:
    host: 10.240.80.134
    username: spring-boot
    password: spring-boot
    virtual-host: spring-boot-vhost

以上的属性文件会被注入到RabbitProperties属性

@ConfigurationProperties(prefix = "spring.rabbitmq")
public class RabbitProperties {
    …
}

4. RabbitAutoConfiguration

4.1. 类上的注解分析：

这是一个配置类，在启动时会初始化上面提到RabbitProperties对象，然后它会引入另一个配置类RabbitAnnotationDrivenConfiguration，这个配置类和消息监听有关我们后面再介绍
这个类有3个内部类，且都是配置类，这此配置类会根据条件初始RabbitMQ所需要的类

@Configuration
@ConditionalOnClass({ RabbitTemplate.class, Channel.class }) 
// 会初始化RabbitProperties.class
@EnableConfigurationProperties(RabbitProperties.class) 
// 引入@Configuration类RabbitAnnotationDrivenConfiguration
@Import(RabbitAnnotationDrivenConfiguration.class)
public class RabbitAutoConfiguration {
…

}

4.2. 内部类RabbitConnectionFactoryCreator

内部类RabbitConnectionFactoryCreator会根据RabbitProperties 配置的参数初始CachingConnectionFactory 实例（它是ConnectionFactory 子类），这个实例是连接RabbitMQ的连接池。
CachingConnectionFactory实例是对RabbitMQ官方提供对com.rabbitmq.client.ConnectionFactory和com.rabbitmq.client.Channel的封装，缓存这两种资源。CachingConnectionFactory有两种缓存模式
1. 如果选择CacheMode#CHANNEL的缓存模式，当我们调用 createConnection()方法时，每次返回相同的Connection。默认情况下，只创建一个Connection，只创建一个Channel（通过配置创建Channel数量参数，可以创建缓存多个Channel）。即可以创建多个Channel，但是所有的Channel共用同一个Connection
2. 如果选择CacheMode#CONNECTION的缓存模式，可以同时配置创建Connection的数量和Channel数据。当调用 createConnection()时，从缓存中获取可用Connection，如果没有且创建的数量没有达到上限，则创建新的Connection。同理Channel

@Configuration
@ConditionalOnMissingBean(ConnectionFactory.class)
protected static class RabbitConnectionFactoryCreator {

    @Bean
    public CachingConnectionFactory rabbitConnectionFactory(RabbitProperties config)
        throws Exception {
        // 根据RabbitProperties 配置RabbitMQ的连接工厂类
        RabbitConnectionFactoryBean factory = new RabbitConnectionFactoryBean();
        if (config.determineHost() != null) {
            factory.setHost(config.determineHost());
        }
        …
        factory.afterPropertiesSet();
        // 连接缓存类
        CachingConnectionFactory connectionFactory = new CachingConnectionFactory(
            factory.getObject());
        connectionFactory.setAddresses(config.determineAddresses());
        connectionFactory.setPublisherConfirms(config.isPublisherConfirms());
        connectionFactory.setPublisherReturns(config.isPublisherReturns());
        …
        return connectionFactory;
    }

}

4.3. 内部类RabbitTemplateConfiguration

内部类RabbitTemplateConfiguration通过类的构造器将RabbitProperties 配置的参数、MessageConverter赋值到类的相应的成员变量上，然后在方法rabbitTemplate()根据RabbitConnectionFactoryCreator创建的CachingConnectionFactory实例 ，创建出RabbitTemplate和RabbitAdmin。

@Configuration
// 引入RabbitConnectionFactoryCreator
@Import(RabbitConnectionFactoryCreator.class)
protected static class RabbitTemplateConfiguration {
    private final ObjectProvider messageConverter;
    private final RabbitProperties properties;

    // 注入MessageConverter和RabbitProperties  
    public RabbitTemplateConfiguration(
        ObjectProvider messageConverter,
        RabbitProperties properties) {
        this.messageConverter = messageConverter;
        this.properties = properties;
    }

    // 初始化RabbitTemplate 
    @Bean
    @ConditionalOnSingleCandidate(ConnectionFactory.class)
    @ConditionalOnMissingBean(RabbitTemplate.class)
    public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory) {
        // 创建RabbitTemplate 
        RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
        MessageConverter messageConverter = this.messageConverter.getIfUnique();
        if (messageConverter != null) {
            // 配置MessageConverter  
            rabbitTemplate.setMessageConverter(messageConverter);
        }
        // 其它参数配置略
        …
        return rabbitTemplate;
    }

    // 初始化AmqpAdmin 
    @Bean
    @ConditionalOnSingleCandidate(ConnectionFactory.class)
    @ConditionalOnProperty(prefix = "spring.rabbitmq", name = "dynamic", matchIfMissing = true)
    @ConditionalOnMissingBean(AmqpAdmin.class)
    public AmqpAdmin amqpAdmin(ConnectionFactory connectionFactory) {
        // 创建RabbitAdmin
        return new RabbitAdmin(connectionFactory);
    }

}

4.4. 内部配置类：MessagingTemplateConfiguration

内部配置类：MessagingTemplateConfiguration
通过rabbitMessagingTemplate()方法将上面创建的RabbitTemplate 实例注入并创建RabbitMessagingTempla

@Configuration
@ConditionalOnClass(RabbitMessagingTemplate.class)
@ConditionalOnMissingBean(RabbitMessagingTemplate.class)
// 引入RabbitTemplateConfiguration配置类 
@Import(RabbitTemplateConfiguration.class)
protected static class MessagingTemplateConfiguration {
    // 生成实例RabbitMessagingTemplate， 其中RabbitTemplate 由RabbitTemplateConfiguration实例化
    @Bean
    @ConditionalOnSingleCandidate(RabbitTemplate.class)
    public RabbitMessagingTemplate rabbitMessagingTemplate(
    RabbitTemplate rabbitTemplate) {
        return new RabbitMessagingTemplate(rabbitTemplate);
    }

}

通过以上配置就完成的RabbitMQ发送者相关的bean初始化，我们可以使用RabbitTemplate和RabbitAdmin发送消息。如果要监听RabbitMQ消息还需要如下配置，这个配置更加更复杂

5. RabbitAnnotationDrivenConfiguration

此类RabbitAutoConfiguration中引入此类，此类会创建监听消息相关的Bean。我们来详细分析这个类。

5.1. 类的构造方法 :

传入监控需要MessageConverter实例、MessageRecoverer实例、RabbitProperties 实例，做为的类的成员变量

@Configuration
@ConditionalOnClass(EnableRabbit.class)
class RabbitAnnotationDrivenConfiguration {

    private final ObjectProvider messageConverter;

    private final ObjectProvider messageRecoverer;

    private final RabbitProperties properties;

    RabbitAnnotationDrivenConfiguration(ObjectProvider messageConverter,
        ObjectProvider messageRecoverer,
        RabbitProperties properties) {
        this.messageConverter = messageConverter;
        this.messageRecoverer = messageRecoverer;
        this.properties = properties;
    }
    …
}

5.2. 类的rabbitListenerContainerFactoryConfigurer()方法

创建SimpleRabbitListenerContainerFactoryConfigurer 对象，此类保存创建RabbitListenerContainer所需要的MessageConverter实例、MessageRecoverer实例、RabbitProperties 实例

// 实例SimpleRabbitListenerContainerFactoryConfigurer 对象，设置MessageConverter、MessageRecovere、RabbitMQ的属性
@Bean
@ConditionalOnMissingBean
public SimpleRabbitListenerContainerFactoryConfigurer rabbitListenerContainerFactoryConfigurer() {
    SimpleRabbitListenerContainerFactoryConfigurer configurer = new SimpleRabbitListenerContainerFactoryConfigurer();
    configurer.setMessageConverter(this.messageConverter.getIfUnique());
    configurer.setMessageRecoverer(this.messageRecoverer.getIfUnique());
    configurer.setRabbitProperties(this.properties);
    return configurer;
}

5.3. 类中rabbitListenerContainerFactory()方法

创建实例SimpleRabbitListenerContainerFactory （是RabbitListenerContainerFactory的子类），其中SimpleRabbitListenerContainerFactoryConfigurer 来自下面的方法，ConnectionFactory 来自RabbitAutoConfiguration，上面已经解释过了

@Bean
@ConditionalOnMissingBean(name = "rabbitListenerContainerFactory")
public SimpleRabbitListenerContainerFactory rabbitListenerContainerFactory(
    SimpleRabbitListenerContainerFactoryConfigurer configurer,
    ConnectionFactory connectionFactory) {
    SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
    configurer.configure(factory, connectionFactory);
    return factory;
}

5.4. 启动@EnableRabbit

这个内部类主要看他的@EnableRabbit注解，这个注解会使用RabbitListenerContainer参数，并创建其他相关的Bean实例，并进行监听消息。下节详细介绍@EnableRabbit

@EnableRabbit
@ConditionalOnMissingBean(name = RabbitListenerConfigUtils.RABBIT_LISTENER_ANNOTATION_PROCESSOR_BEAN_NAME)
protected static class EnableRabbitConfiguration {

}

6. @EnableRabbit

引入配置类RabbitBootstrapConfiguration

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
// 引入配置类RabbitBootstrapConfiguration
@Import(RabbitBootstrapConfiguration.class)
public @interface EnableRabbit {
}

7. RabbitBootstrapConfiguration

在这个配置类创建RabbitListenerAnnotationBeanPostProcessor和RabbitListenerEndpointRegistry。

@Configuration
public class RabbitBootstrapConfiguration {

    // 创建RabbitListenerAnnotationBeanPostProcessor ，@RabbitListener+@RabbitHandler注解的方法，当收到监听消息分发到这些方法进行处理
    @Bean(name = RabbitListenerConfigUtils.RABBIT_LISTENER_ANNOTATION_PROCESSOR_BEAN_NAME)
    @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
    public RabbitListenerAnnotationBeanPostProcessor rabbitListenerAnnotationProcessor() {
        return new RabbitListenerAnnotationBeanPostProcessor();
    }

    // 创建RabbitListenerEndpointRegistry，供监听节点的注册 
    @Bean(name = RabbitListenerConfigUtils.RABBIT_LISTENER_ENDPOINT_REGISTRY_BEAN_NAME)
    public RabbitListenerEndpointRegistry defaultRabbitListenerEndpointRegistry() {
        return new RabbitListenerEndpointRegistry();
    }

}

8. RabbitListenerAnnotationBeanPostProcessor

继承BeanPostProcessor，在Spring创建对象后，会拦截所有的被@RabbitListener+@RabbitHandler注解的方法

8.1. 类的afterSingletonsInstantiated()方法

类在实例化时，会执行初始化，重要操作
1. 设置获取RabbitListenerEndpointRegistry实例，并设置实例到RabbitListenerEndpointRegistrar中
2. 在RabbitListenerEndpointRegistrar中设置containerFactoryBeanName名称为rabbitListenerContainerFactory
3. 调用RabbitListenerEndpointRegistrar.afterPropertiesSet()进行初始化，这个方法内容后面再介绍 

// 创建实例
private final RabbitListenerEndpointRegistrar registrar = new RabbitListenerEndpointRegistrar();

@Override
public void afterSingletonsInstantiated() {
    …

    // 设置获取RabbitListenerEndpointRegistry实例，并设置实例到RabbitListenerEndpointRegistrar中
    if (this.registrar.getEndpointRegistry() == null) {
        if (this.endpointRegistry == null) {
            Assert.state(this.beanFactory != null,
                "BeanFactory must be set to find endpoint registry by bean name");
            this.endpointRegistry = this.beanFactory.getBean(
                RabbitListenerConfigUtils.RABBIT_LISTENER_ENDPOINT_REGISTRY_BEAN_NAME,
                RabbitListenerEndpointRegistry.class);
        }
        this.registrar.setEndpointRegistry(this.endpointRegistry);
    }

    // 在RabbitListenerEndpointRegistrar中设置containerFactoryBeanName名称为rabbitListenerContainerFactory
    if (this.containerFactoryBeanName != null) {
        this.registrar.setContainerFactoryBeanName(this.containerFactoryBeanName);
    }

    // Set the custom handler method factory once resolved by the configurer
    MessageHandlerMethodFactory handlerMethodFactory = this.registrar.getMessageHandlerMethodFactory();
    if (handlerMethodFactory != null) {
        this.messageHandlerMethodFactory.setMessageHandlerMethodFactory(handlerMethodFactory);
    }

    // Actually register all listeners，初始化RabbitListenerEndpointRegistrar
    this.registrar.afterPropertiesSet();

}

8.2. postProcessAfterInitialization()方法

postProcessAfterInitialization()方法会在对象初始化完毕后被执行，此方法会拦截所有的被@RabbitListener和@RabbitHandler注解的方法。
1. @RabbitListener如果注解到方法上，则调用方法processAmqpListener()，此时会使用MethodRabbitListenerEndpoint 封装调用方法
2. @RabbitListener如果注解到类上，且类有方法被@RabbitHandler注解，则调用processMultiMethodListeners()，此时会使用MultiMethodRabbitListenerEndpoint 封装调用方法

MethodRabbitListenerEndpoint 和MultiMethodRabbitListenerEndpoint都是MethodRabbitListenerEndpoint 的子类

这里写图片描述

@Override
public Object postProcessAfterInitialization(final Object bean, final String beanName) throws BeansException {
    …
    // 处理所有被@RabbitListener注解的方法 
    for (ListenerMethod lm : metadata.listenerMethods) {
        for (RabbitListener rabbitListener : lm.annotations) {
            processAmqpListener(rabbitListener, lm.method, bean, beanName);
        }
    }

    // 处理所有被@RabbitHandler注解的方法 
    if (metadata.handlerMethods.length > 0) {
        processMultiMethodListeners(metadata.classAnnotations, metadata.handlerMethods, bean, beanName);
    }
    return bean;
}

private void processMultiMethodListeners(RabbitListener[] classLevelListeners, Method[] multiMethods,
    Object bean, String beanName) {
    …
    for (RabbitListener classLevelListener : classLevelListeners) {
        // 创建处理有多个监听方法的类
        MultiMethodRabbitListenerEndpoint endpoint = new MultiMethodRabbitListenerEndpoint(checkedMethods, bean);
        endpoint.setBeanFactory(this.beanFactory);
        processListener(endpoint, classLevelListener, bean, bean.getClass(), beanName);
    }
}

protected void processAmqpListener(RabbitListener rabbitListener, Method method, Object bean, String beanName) {
    Method methodToUse = checkProxy(method, bean);
    // 创建处理单个监听方法的类
    MethodRabbitListenerEndpoint endpoint = new MethodRabbitListenerEndpoint();
    endpoint.setMethod(methodToUse);
    endpoint.setBeanFactory(this.beanFactory);
    processListener(endpoint, rabbitListener, bean, methodToUse, beanName);
}

8.3. 方法processListener()

无论是方法processMultiMethodListeners()和processMultiMethodListeners()都会进入processListener()，这里做如下内容：
1. 第一步这里先根据监听方法上的@RabbitListener的配置参数，设置MethodRabbitListenerEndpoint 要监听的队列、优先级、排他性等待，
2. 第二步获取rabbitAdmin实例，并设置到MethodRabbitListenerEndpoint 中
3. 第三步 根据@RabbitListener的containerFactory()配置的值获取RabbitListenerContainerFactory，默认值为空
4. 第四步将调用工具类RabbitListenerEndpointRegistrar将RabbitListenerEndpoint注册到RabbitListenerEndpointRegistry。后面会解释这个RabbitListenerEndpointRegistrar类

protected void processListener(MethodRabbitListenerEndpoint endpoint, RabbitListener rabbitListener, Object bean,
    Object adminTarget, String beanName) {

    // 这里有设置MethodRabbitListenerEndpoint endpoint的要监听的队列、优先级、排他性等待
    …

    // 获取rabbitAdmin实例，并设置到MethodRabbitListenerEndpoint 中 
    String rabbitAdmin = resolve(rabbitListener.admin());
    if (StringUtils.hasText(rabbitAdmin)) {
        Assert.state(this.beanFactory != null, "BeanFactory must be set to resolve RabbitAdmin by bean name");
        try {
            endpoint.setAdmin(this.beanFactory.getBean(rabbitAdmin, RabbitAdmin.class));
        }
        catch (NoSuchBeanDefinitionException ex) {
            throw new BeanInitializationException("Could not register rabbit listener endpoint on [" +
                adminTarget + "], no " + RabbitAdmin.class.getSimpleName() + " with id '" +
                rabbitAdmin + "' was found in the application context", ex);
        }
    }

    //  根据@RabbitListener的containerFactory()配置的值获取RabbitListenerContainerFactory
    RabbitListenerContainerFactory factory = null;
    String containerFactoryBeanName = resolve(rabbitListener.containerFactory());
    if (StringUtils.hasText(containerFactoryBeanName)) {
        Assert.state(this.beanFactory != null, "BeanFactory must be set to obtain container factory by bean name");
        try {
            factory = this.beanFactory.getBean(containerFactoryBeanName, RabbitListenerContainerFactory.class);
        }
        catch (NoSuchBeanDefinitionException ex) {
            throw new BeanInitializationException("Could not register rabbit listener endpoint on [" +
                adminTarget + "] for bean " + beanName + ", no " +
                RabbitListenerContainerFactory.class.getSimpleName() + " with id '" +
                containerFactoryBeanName + "' was found in the application context", ex);
        }
    }

    // 调用工具类RabbitListenerEndpointRegistrar将RabbitListenerEndpoint注册到RabbitListenerEndpointRegistry。RabbitListenerEndpointRegistra下面会解释这个类
    this.registrar.registerEndpoint(endpoint, factory);
}

9. RabbitListenerEndpointRegistrar

将上文的RabbitListenerEndpoint注册到RabbitListenerEndpointRegistry上的工作类

9.1. 初始化操作afterPropertiesSet()

初始化操作，此方法被RabbitListenerAnnotationBeanPostProcessor的afterSingletonsInstantiated()方法调用，触发初始化 。主要内容如下：

  1. 第一步：循环AmqpListenerEndpointDescriptor，将MethodRabbitListenerEndpoint 和 RabbitListenerContainerFactory实例调用RabbitListenerEndpointRegistry的方法注册到此类上
  2. 第二步：设置startImmediately 为true，表示后面将
private RabbitListenerEndpointRegistry endpointRegistry;...

// 初始化操作
@Override
public void afterPropertiesSet() {
    registerAllEndpoints();
}

protected void registerAllEndpoints() {
    synchronized (this.endpointDescriptors) {、
        # AmqpListenerEndpointDescriptor是保存RabbitListenerEndpoint和RabbitListenerContainerFactory实例
        for (AmqpListenerEndpointDescriptor descriptor : this.endpointDescriptors) {
            # 将MethodRabbitListenerEndpoint endpoint + RabbitListenerContainerFactory注册到endpointRegistry上
            this.endpointRegistry.registerListenerContainer(
                descriptor.endpoint, resolveContainerFactory(descriptor));
        }
        # 设置值为true
        this.startImmediately = true;  // trigger immediate startup
    }
}

# 获取RabbitListenerContainerFactory实例
/**
    如果endpoint 结点注册是有RabbitListenerContainerFactory，则使用这个值（实际来自@RabbitListener的containerFactory()值）。
    如果没有则使用默认的RabbitListenerContainerFactory，如果没有，则从spring容器中获取名称为containerFactoryBeanName值的RabbitListenerContainerFactory对象并设置为默认值
    在之前我们已经知道这个值被RabbitListenerAnnotationBeanPostProcessor在afterSingletonsInstantiated()中设置为rabbitListenerContainerFactory
**/
private RabbitListenerContainerFactory resolveContainerFactory(AmqpListenerEndpointDescriptor descriptor) {
    if (descriptor.containerFactory != null) {
        return descriptor.containerFactory;
    }
    else if (this.containerFactory != null) {
        return this.containerFactory;
    }
    else if (this.containerFactoryBeanName != null) {
        Assert.state(this.beanFactory != null, "BeanFactory must be set to obtain container factory by bean name");
        this.containerFactory = this.beanFactory.getBean(
            this.containerFactoryBeanName, RabbitListenerContainerFactory.class);
        return this.containerFactory;  // Consider changing this if live change of the factory is required
    }
    else {
        throw new IllegalStateException("Could not resolve the " +
            RabbitListenerContainerFactory.class.getSimpleName() + " to use for [" +
            descriptor.endpoint + "] no factory was given and no default is set.");
    }
}

9.2. registerEndpoint()方法

此方法被RabbitListenerAnnotationBeanPostProcessor的processListener()方法调用。主要内容如下：
在之前的分析中我们初始化设置startImmediately=true，现在只分析true情况。此时调用 RabbitListenerEndpointRegistry的registerListenerContainer()方法将且传递参数startImmediately=true

// 在 RabbitListenerAnnotationBeanPostProcessor调用此方法进行注册

private RabbitListenerEndpointRegistry endpointRegistry;

public void registerEndpoint(RabbitListenerEndpoint endpoint, RabbitListenerContainerFactory factory) {
    …
    // Factory may be null, we defer the resolution right before actually creating the container
    AmqpListenerEndpointDescriptor descriptor = new AmqpListenerEndpointDescriptor(endpoint, factory);
    synchronized (this.endpointDescriptors) {
        if (this.startImmediately) { // Register and start immediately
            # 在之前的分析中我们发现startImmediately=true，现在只分析true情况
            # 调用endpointRegistry的方法注册到上面this.endpointRegistry.registerListenerContainer(descriptor.endpoint,
                resolveContainerFactory(descriptor), true);
        }
        else {
            this.endpointDescriptors.add(descriptor);
        }
    }
}

10. RabbitListenerEndpointRegistry

功能： 为已经注册的RabbitListenerEndpoint创建MessageListenerContainer实例，并执行MessageListenerContainer的初始化操作，最后执行此对象的start()方法。此类还管理监听容器的生命周期

10.1. registerListenerContainer()方法：

  1. 第一步：为RabbitListenerEndpoint 根据RabbitListenerContainerFactory创建一个MessageListenerContainer监听器
  2. 第二步：从上文知道我们startImmediately值为true，会执行startIfNecessary()启动MessageListenerContainer
 // 设置RabbitListenerEndpoint 创建一个监听容器
public void registerListenerContainer(RabbitListenerEndpoint endpoint, RabbitListenerContainerFactory factory,
                                          boolean startImmediately) {
        Assert.notNull(endpoint, "Endpoint must not be null");
        Assert.notNull(factory, "Factory must not be null");

    String id = endpoint.getId();
    Assert.hasText(id, "Endpoint id must not be empty");
    synchronized (this.listenerContainers) {
        Assert.state(!this.listenerContainers.containsKey(id),
            "Another endpoint is already registered with id '" + id + "'");
        # 为endpoint根据factory创建一个监听器，方法详细见下边
        MessageListenerContainer container = createListenerContainer(endpoint, factory);
        this.listenerContainers.put(id, container);
        # Group？？
        if (StringUtils.hasText(endpoint.getGroup()) && this.applicationContext != null) {
            List containerGroup;
            if (this.applicationContext.containsBean(endpoint.getGroup())) {
                containerGroup = this.applicationContext.getBean(endpoint.getGroup(), List.class);
            }
            else {
                containerGroup = new ArrayList();
                this.applicationContext.getBeanFactory().registerSingleton(endpoint.getGroup(), containerGroup);
            }
            containerGroup.add(container);
        }
        if (startImmediately) {
            # 启动容器MessageListenerContainer，已知传入的值为true
            startIfNecessary(container);
        }
    }
}

10.2. createListenerContainer()方法

  1. 第一步： 使用RabbitListenerEndpoint 配置的RabbitListenerContainerFactory的方法createListenerContainer()创建MessageListenerContainer 。默认是使用SimpleRabbitListenerContainerFactory创建的实例为SimpleMessageListenerContainer
  2. 第二步：因为MessageListenerContainer 继承InitializingBean，所有会执行SimpleMessageListenerContainer的初始化操作。后面会介绍这个类的初始化
 # 为endpoint根据factory创建一个监听器
protected MessageListenerContainer createListenerContainer(RabbitListenerEndpoint endpoint,
    RabbitListenerContainerFactory> factory) {
    # 使用endpoint配置的RabbitListenerContainerFactory创建MessageListenerContainer 。默认是使用SimpleRabbitListenerContainerFactory创建的实例为SimpleMessageListenerContainer
    MessageListenerContainer listenerContainer = factory.createListenerContainer(endpoint);
    # 初始化容器
    if (listenerContainer instanceof InitializingBean) {
        try {
            ((InitializingBean) listenerContainer).afterPropertiesSet();
        }
        catch (Exception ex) {
            throw new BeanInitializationException("Failed to initialize message listener container", ex);
        }
    }
    …
    return listenerContainer;
}

10.3. 启动容器

调用MessageListenerContainer 的start()方法启动容器

// 启动容器 
private void startIfNecessary(MessageListenerContainer listenerContainer) {
    if (this.contextRefreshed || listenerContainer.isAutoStartup()) {
        // 容器默认值为自动启动，所有会执行一下操作
        listenerContainer.start();
    }
}

11. 类SimpleRabbitListenerContainerFactory

此类是RabbitListenerContainerFactory的子类

11.1. createContainerInstance() 方法

创建SimpleMessageListenerContainer实例

// 创建SimpleMessageListenerContainer实例 
@Override
protected SimpleMessageListenerContainer createContainerInstance() {
    return new SimpleMessageListenerContainer();
}

11.2. 方法createContainerInstance()

此方法：调用createContainerInstance()创建SimpleMessageListenerContainer实例，并使用RabbitListenerEndpoint包含的参数设置到创建的实例中，最后调用initializeContainer()初始化SimpleMessageListenerContainer实例

@Override
public C createListenerContainer(RabbitListenerEndpoint endpoint) {
    // 创建实例
    C instance = createContainerInstance();

    // 以下设置容器的初始值
    if (this.connectionFactory != null) {
        instance.setConnectionFactory(this.connectionFactory);
    }
    // 其他根据本对象的成员变量配置RabbitListenerEndpoint 代码略
    …
    instance.setListenerId(endpoint.getId());

    endpoint.setupListenerContainer(instance);

    // 初始化容器
    initializeContainer(instance);

    return instance;
}

11.3. initializeContainer()方法

初始化刚刚创建的SimpleMessageListenerContainer实例，将本对象中的成员变量配置到SimpleMessageListenerContainer实例中

// 根据容器工厂初始化容器值 
@Override
protected void initializeContainer(SimpleMessageListenerContainer instance) {
    super.initializeContainer(instance);

    if (this.applicationContext != null) {
        instance.setApplicationContext(this.applicationContext);
    }
    if (this.taskExecutor != null) {
        instance.setTaskExecutor(this.taskExecutor);
    }
    if (this.transactionManager != null) {
        instance.setTransactionManager(this.transactionManager);
    }
    if (this.txSize != null) {
        instance.setTxSize(this.txSize);
    }
    // 其他根据本对象的成员变量配置SimpleMessageListenerContainer 代码略
    …
}

12. SimpleMessageListenerContainer

在RabbitListenerEndpointRegistry中会调用SimpleMessageListenerContainer的start()方法

12.1. start()方法

如果没有初始化，则执行此类的初始化操作

// 初始操作，主要操作见doStart() 
@Override
public void start() {
    if (!this.initialized) {
        synchronized (this.lifecycleMonitor) {
            if (!this.initialized) {
                afterPropertiesSet();
                this.initialized = true;
            }
        }
    }
    try {
        if (logger.isDebugEnabled()) {
            logger.debug("Starting Rabbit listener container.");
        }
        # 调用子类方法
        doStart();
    }
    catch (Exception ex) {
        throw convertRabbitAccessException(ex);
    }
}

12.2. doStart()方法：

主要操作如下：
第一步：获取RabbitAdmin实例
第二步：rabbitAdmin初始化：对新增的队列、交换机、绑定在RabbitMQ上进行声明
第三步：调用父类doStart()方法
第四步：在线程池中启动这个消息者，进行消息消费
第五步：监控消息者是否启动成功，如果失败则抛出异常

protected void doStart() throws Exception {
    if (getMessageListener() instanceof ListenerContainerAware) {
        // 验证当前监听的队列是否和容器相同 
        ….
        Collection expectedQueueNames = ((ListenerContainerAware) getMessageListener()).expectedQueueNames();
        if (expectedQueueNames != null) {
            String[] queueNames = getQueueNames();
            Assert.state(expectedQueueNames.size() == queueNames.length,
                "Listener expects us to be listening on '" + expectedQueueNames + "'; our queues: "
                    + Arrays.asList(queueNames));
            boolean found = false;
            for (String queueName : queueNames) {
                if (expectedQueueNames.contains(queueName)) {
                    found = true;
                }
                else {
                    found = false;
                    break;
                }
            }
            Assert.state(found, "Listener expects us to be listening on '" + expectedQueueNames + "'; our queues: "
                + Arrays.asList(queueNames));
        }
    }
    // 获取rabbitAdmin值
    if (this.rabbitAdmin == null && this.getApplicationContext() != null) {
        Map admins = this.getApplicationContext().getBeansOfType(RabbitAdmin.class);
        if (admins.size() == 1) {
            this.rabbitAdmin = admins.values().iterator().next();
        }
        else {
            ….
        }
    }
    // rabbitAdmin初始化：对新增的队列、交换机、绑定在RabbitMQ上进行声明 
    checkMismatchedQueues();
    // 调用父类方法
    super.doStart();
    synchronized (this.consumersMonitor) {
        // 初始化消息者，此方法会创建消息者BlockingQueueConsumer
        int newConsumers = initializeConsumers();
        ….
        Set processors = new HashSet();
        // 在线程池中启动这个消息者，进行消息消费：AsyncMessageProcessingConsumer 是个线程类，它调用BlockingQueueConsumer的start()方法接收消息并进行处理。
        for (BlockingQueueConsumer consumer : this.consumers) {
            AsyncMessageProcessingConsumer processor = new AsyncMessageProcessingConsumer(consumer);
            processors.add(processor);
            // 在线程池中执行 AsyncMessageProcessingConsumer 
            this.taskExecutor.execute(processor);
            if (this.applicationEventPublisher != null) {
                this.applicationEventPublisher.publishEvent(new AsyncConsumerStartedEvent(this, consumer));
            }
        }
        // 监控消息者是否启动成功，如果失败则抛出异常
        for (AsyncMessageProcessingConsumer processor : processors) {
            FatalListenerStartupException startupException = processor.getStartupException();
            if (startupException != null) {
                throw new AmqpIllegalStateException("Fatal exception on listener startup", startupException);
            }
        }
    }
}

13. RabbitAdmin：

rabbitAdmin初始化：对新增的队列、交换机、绑定在RabbitMQ上进行声明

public void initialize() {

    …
    // 获取所有的队列、交换机、绑定
    Collection contextExchanges = new LinkedList(
        this.applicationContext.getBeansOfType(Exchange.class).values());
    Collection contextQueues = new LinkedList(
        this.applicationContext.getBeansOfType(Queue.class).values());
    Collection contextBindings = new LinkedList(
        this.applicationContext.getBeansOfType(Binding.class).values());

    … 
    // 在RabbitMQ上进行声明，创建对应的队列、交换机、绑定
    this.rabbitTemplate.execute(new ChannelCallback() {
        @Override
        public Object doInRabbit(Channel channel) throws Exception {
            declareExchanges(channel, exchanges.toArray(new Exchange[exchanges.size()]));
            declareQueues(channel, queues.toArray(new Queue[queues.size()]));
            declareBindings(channel, bindings.toArray(new Binding[bindings.size()]));
            return null;
        }
    });


    }
 
  
14. AsyncMessageProcessingConsumer
 
  
继承Runnable，的run()方法中调用BlockingQueueConsumer 的start()方法
 
  
private final class AsyncMessageProcessingConsumer implements Runnable {

    private final BlockingQueueConsumer consumer;

    private volatile FatalListenerStartupException startupException;

    private AsyncMessageProcessingConsumer(BlockingQueueConsumer consumer) {
        this.consumer = consumer;
        this.start = new CountDownLatch(1);
    }

    @Override
    public void run() {

    ….
    try {
        if (SimpleMessageListenerContainer.this.autoDeclare) {
        SimpleMessageListenerContainer.this.redeclareElementsIfNecessary();
        }
        // 启动BlockingQueueConsumer 的start()方法
        this.consumer.start();
        ..
    }
    …
...
 
  
15. BlockingQueueConsumer
 
  
BlockingQueueConsumer：在start中调用basicConsume方法定阅消息。在这里我们可以看到spring开始调用RabbitMQ提供的Jar包里的类(.channel.basicConsume)，说明我们已经跟到底层，所有源码分析到此为止
 
  
15.1. 线程start()方法
 
  
        void start() throws AmqpException {

        try {
                for (String queueName : this.queues) {
                        // 循环订阅所有的消息
                        if (!this.missingQueues.contains(queupublic eName)) {
                                consumeFromQueue(queueName);
                        }
                }
                }
                catch (IOException e) {
                        throw RabbitExceptionTranslator.convertRabbitAccessException(e);
                }
                }

                private void consumeFromQueue(String queue) throws IOException {
                        // 调用basicConsume方法定阅消息。在这里我们可以看到spring开始调用RabbitMQ提供的Jar包里的类(.channel.basicConsume)，
                        String consumerTag = this.channel.basicConsume(queue, this.acknowledgeMode.isAutoAck(),
                                (this.tagStrategy != null ? this.tagStrategy.createConsumerTag(queue) : ""), false, this.exclusive,
                                this.consumerArgs, this.consumer);
                        if (consumerTag != null) {
                                this.consumerTags.put(consumerTag, queue);
                        }
                        ...
                }

        }

 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(rabbitmq,spring,boot,源码阅读,Spring,boot,消息中间件)

        

            

                
    
                    
  • Spring Boot实战：MySQL与Redis数据一致性深度解析与代码实战
                        黑猫Teng
springbootmysqlredis
                        
    SpringBoot实战：MySQL与Redis数据一致性深度解析与代码实战一、数据一致性问题概述二、常见解决方案三、选择合适的解决方案四、总结在SpringBoot开发中，MySQL作为关系型数据库，提供了强大的数据存储和查询能力；而Redis作为内存数据库，以其高速读写性能成为缓存层的首选。然而，当这两者共同服务于一个系统时，如何确保它们之间的数据一致性，成为了一个不可忽视的问题。本文将深入探
    
                    
    • 
                    
  • [Java实战]性能优化qps从1万到3万
                        曼岛_
国密实战java性能优化开发语言
                        
    一、问题背景事情起因是项目上springboot项目提供的tps达不到客户要求，除了增加服务器提高tps之外，作为团队的技术总监，架构师，技术扛把子，本着我不入地狱谁入地狱的原则，决心从代码上优化，让客户享受到飞一般的感觉。虽然大多数编程工作在写下第一行代码时已经完成，但本着谦虚使人进步，骄傲使人落后的原则还是一步一个脚印的把问题慢慢展开，慢慢分析。以下内容是抽丝剥茧的心路历程，请君欣赏。二、TP
    
                    
    • 
                    
  • Java面试精选：Kafka+Zookeeper+redis+JVM+RabbitMQ，最全总结
                        我叫小迁W：bjmsb2019
Java架构面试数据库javaredismysql分布式
                        
    大家开始准备金九银十了吗？不知是跳槽还是找工作的朋友，趁现在增进一下自己的技术何尝不是一件好事呢？一、RabbitMQ1.rabbitmq的使用场景有哪些？2.rabbitmq有哪些重要的角色？3.rabbitmq有哪些重要的组件？4.rabbitmq中vhost的作用是什么？5.rabbitmq的消息是怎么发送的？6.rabbitmq怎么保证消息的稳定性？7.rabbitmq怎么避免消息丢失？8
    
                    
    • 
                    
  • vue使用el-upload实现文件上传功能
                        小来码呀码
vue.jselementuijavascript
                        
    因为是vue+springboot前后分离，要跨域，就不能用默认的action写请求地址，我用axios时最困扰的就是怎么拿到那个真实的文件，然后给传给后台。其实可以通过自带的onchanne触发方法获得文件列表，文件信息中那个raw就是真实的文件。写的时候，刚开始我是直接把el-upload里面的button中加了点击事件，但是每次文件还没选，就已经向后台发出请求了，当然传不过去，于是外面套了个
    
                    
    • 
                    
  • 【经验分享】SpringBoot集成Websocket开发 之 使用由 Jakarta EE 规范提供的 API开发
                        Xcong_Zhu
学习笔记经验分享springbootwebsocket
                        
    在SpringBoot中整合、使用WebSocketWebSocket是一种基于TCP协议的全双工通信协议，它允许客户端和服务器之间建立持久的、双向的通信连接。相比传统的HTTP请求-响应模式，WebSocket提供了实时、低延迟的数据传输能力。通过WebSocket，客户端和服务器可以在任意时间点互相发送消息，实现实时更新和即时通信的功能。WebSocket协议经过了多个浏览器和服务器的支持，成
    
                    
    • 
                    
  • Caddy2使用阿里云DNS申请https证书，利用阿里云DNS境内外不同解析给Gone文档做一个同域名的国内镜像站点
                        dapeng-大鹏
大鹏运维记录caddyhttpsdockerdocker-compose
                        
    我从头到尾实现了一个Golang的依赖注入框架，并且集成了gin、xorm、redis、cron、消息中间件等功能；自己觉得还挺好用的，并且打算长期维护！github地址：https://github.com/gone-io/gone文档原地址：https://goner.fun/zh/guide/auto-gen-priest.html请帮忙在github上点个⭐️吧，这对我很重要；万分感谢！！
    
                    
    • 
                    
  • SpringBoot设置过滤器（Filter）或拦截器（Interceptor）的执行顺序：@Order注解、setOrder()方法
                        pan_junbiao
SpringSpringBoot我の原创springbootjava后端
                        
    JavaWeb过滤器、拦截器、监听器，系列文章：（1）过滤器（Filter）的使用：《Servlet过滤器（Filter）的使用：Filter接口、@WebFilter注释》《SpringMVC使用过滤器（Filter）解决中文乱码》《SpringBoot过滤器（Filter）的使用：Filter接口、FilterRegistrationBean类配置、@WebFilter注释》《SpringBo
    
                    
    • 
                    
  • SpringBoot使用AspectJ实现AOP记录接口：请求日志、响应日志、异常日志
                        pan_junbiao
SpringSpringBoot我の原创springboot后端java
                        
    Spring面向切面编程（AOP），系列文章：《Spring面向切面编程（AOP）的简单实例》《Spring使用AspectJ的注解式实现AOP面向切面编程》《SpringBoot使用AspectJ实现AOP记录接口：请求日志、响应日志、异常日志》《SpringBoot使用AspectJ的@Around注解实现AOP全局记录接口：请求日志、响应日志、异常日志》1、AspectJ框架的简介Aspec
    
                    
    • 
                    
  • Elasticsearch Java High Level Client [7.17] 使用
                        DavidSoCool
javaelasticsearch开发语言
                        
    es的HighLevelClient存在es源代码的引用，结合springboot使用时，会存在es版本的冲突，这里记录下解决冲突和使用方式（es已经不建议使用这个了）。注意es服务端的版本需要与client的版本对齐，否则返回数据可能会解析失败！！！文档地址：JavaHighLevelRESTClient|JavaRESTClient[7.17]|Elastic1、首先创建个javaspring
    
                    
    • 
                    
  • IDEA项目maven project没有出现plugins和Dependencies
                        冬瓜生鲜
IDEAMaven
                        
    背景：今天学习Springboot，但是用的apache-maven3.0，导入springboot1.5.19，Maven项目老是爆红线，还没有plugins和Dependencies方案一：方案二：jdk+SpringBoot+maven版本不对《我把maven版本换高，就成功解决了》Springboot版本SpringFrameworkjdk版本maven版本1.2.0版本之前63.01.2
    
                    
    • 
                    
  • SpringBoot 自动装配
                        SilvertipSage
springboot后端java
                        
    SpringBoot自动装配：自动装配是Springboot框架的一个核心特性之一。SpringBoot的自动装配通过条件注解和自动配置类，根据应用需求自动配置组件，简化配置过程，提高开发效率不需要手动配置许多繁琐的细节，而是通过自动装配来简化配置过程好处：简化配置，减少了出错的可能性，提高了开发效率，提升了应用程序的可维护性和可扩展性。自动把第三方组件的bean加到IOC容器里，在SpringB
    
                    
    • 
                    
  • Spring Cloud 与微服务学习总结（14）—— 云原生时代，如何从 Java 开发者转型微服务？
                        一杯甜酒
SpringCloud与微服务java云原生springcloud微服务微服务架构
                        
    前言根据维基百科定义，微服务不是整体应用程序中的一个层。相反，微服务是一个独立的业务功能，具有清晰的接口，并且可以通过内部组件实现分层架构。从战略角度来看，微服务架构基本上遵循“做一件事，就要做得好”的Unix哲学。为了应对传统单体架构的缺陷，微服务架构被企业广泛应用。然而，实践之前有很多问题都需要提前考虑清楚，比如Java背景的开发者是否更有优势？微服务、容器化、DevOps和CI/CD之间的关
    
                    
    • 
                    
  • 【Rust基础】Rust后端开发常用库
                        勇敢牛牛_
rust开发语言后端
                        
    使用Rust有一段时间了，期间尝试过使用Rust做后端开发、命令行工具开发，以及做端侧模型部署，也尝试过交叉编译、FFI调用等，也算是基本入门了。在用Rust做后端接口开发时，常常会找不到一些合适库，而这些库在Java中却很常见，于是在此汇总一下后Rust后端开发中常用的一些库。基础框架首先是基础web开发框架，在Java中，最常用的就是Spring了，而Spring其实不单单是一个开发框架，而是
    
                    
    • 
                    
  • SpringBoot整合RabbitMQ
                        z小天才b
RabbitMQruby开发语言后端
                        
    1、添加依赖org.springframework.bootspring-boot-starter-weborg.springframework.bootspring-boot-starter-amqporg.projectlomboklomboktrue2.配置文件(application.yml)spring:rabbitmq:host:localhostport:5672username:g
    
                    
    • 
                    
  • Spring MVC 面试题
                        A逍遥人世欢
面试springmvcjava
                        
    概述什么是SpringMVC？简单介绍下你对SpringMVC的理解？SpringMVC是一个基于Java的实现了MVC设计模式的请求驱动类型的轻量级Web框架，通过把模型-视图-控制器分离，将web层进行职责解耦，把复杂的web应用分成逻辑清晰的几部分，简化开发，减少出错，方便组内开发人员之间的配合。SpringMVC的优点可以支持各种视图技术,而不仅仅局限于JSP；与Spring框架集成（如I
    
                    
    • 
                    
  • 从零实现OSS阿里云图片上传：前端采用的vue3+element-plus，后端采用javaspingboot，实现上传图片到云，然后存储数据库链接能够回显的效果
                        绝顶少年
阿里云前端数据库
                        
    后端（JavaSpringBoot）1.添加依赖在pom.xml中添加必要的依赖，包括阿里云OSSSDK、SpringBootWeb、MyBatis-Plus等：org.springframework.bootspring-boot-starter-webcom.baomidoumybatis-plus-boot-starter3.4.3.4com.aliyun.ossaliyun-sdk-oss
    
                    
    • 
                    
  • linux操作系统实战
                        沅沅真真
linux服务器运维
                        
    第一题创建根目录结构中的所有的普通文件 [root@localhost~]#cd/ [root@localhost/]#mkdir/text [root@localhost/]#cd/text [root@localhosttext]#mkdir/text/boot/text/root/text/home/text/bin/text/sbin/text/lib/text/lib64/text/us
    
                    
    • 
                    
  • Spring MVC面试题（一）
                        码农 小王
springmvcjava
                        
    1.什么是SpringMVC？全称为ModelViewController，SpringMVC是Spring的一个模块，基于MVC架构模式的一个框架2.SpringMVC优点？1.可用各种视图技术，不仅限于JSP2.支持各种请求资源映射策略3.SpringMVC工作原理？1.客户端发送请求到DispatcherServlet2.DispatcherServlet查询handlerMapping找到
    
                    
    • 
                    
  • SpringBoot项目集成分布式任务调度平台XXL-JOB
                        樱花语
分布式开发SpringBootXXL-JOB
                        
    一、概述XXL-JOB是一个轻量级分布式任务调度平台，其核心设计目标是开发迅速、学习简单、轻量级、易扩展。现已开放源代码并接入多家公司线上产品线，开箱即用。二、特性1、简单：支持通过Web页面对任务进行CRUD操作，操作简单，一分钟上手；2、动态：支持动态修改任务状态、启动/停止任务，以及终止运行中任务，即时生效；3、调度中心HA（中心式）：调度采用中心式设计，“调度中心”自研调度组件并支持集群部
    
                    
    • 
                    
  • spring event发布及监听实例
                        weixin_33924220
java测试
                        
    序本文主要介绍下如何在spring中进行发布时间以及接收事件定义事件publicclassDemoEventextendsApplicationEvent{privateStringmessage;publicDemoEvent(Objectsource,Stringmessage){super(source);this.message=message;}publicStringgetMessag
    
                    
    • 
                    
  • Spring Plugin与策略模式：打造动态可扩展的应用
                        超越不平凡
Spring策略模式SpringSpringPlugin
                        
    目录一、策略模式二、SpringPlugin2.1SpringPlugin实现策略模式开发2.2策略模式优缺点三、SpringPlugin原理一、策略模式策略模式是一种设计模式，它允许程序在运行中动态的选择不同的行为方式进行动态执行。策略模式的核心思想是将行为封装在一个个独立的类中，这些类实现了相同的接口或抽象类，客户端可以通过接口来调用不同的实现，而不知道具体的实现细节。下面来看一个具体的案例。
    
                    
    • 
                    
  • Spring中的Events
                        Leon_Jinhai_Sun

                        
    事件通过org.springframework.context.ApplicationEvent实例来表示。这个抽象类继承扩展了java.util.EventObject，可以使用EventObject中的getSource方法，我们可以很容易地获得所发生的给定事件的对象。这里，事件存在两种类型与应用程序上下文相关联所有这种类型的事件都继承自org.springframework.context.
    
                    
    • 
                    
  • SpringBoot整合RabbitMq
                        qq_45923849
java-rabbitmqspringbootrabbitmq
                        
    1.引入依赖org.springframework.bootspring-boot-starter-amqp2.application.yml文件配置spring:rabbitmq:host:192.168.101.129port:5672username:adminpassword:adminvirtual-host:/3.编写配置类主要是声明RabbitTemplate，创建交换机和队列并进行
    
                    
    • 
                    
  • nacos集成网关
                        hubertbb3
gatewayspringcloud
                        
    前言，之前写的微服务中，并没有网关来进行控制，任何请求都可以访问到服务，所以，我们通过集成网关的方式，来对发送到我们服务的路由进行管理和控制。第一步，创建一个springboot应用第二步，引入相关依赖org.springframework.cloudspring-cloud-starter-gateway
    
                    
    • 
                    
  • nginx源码阅读(八).ngx_events_module模块
                        UKey_
NginxNginx源码阅读nginx源码moduleevents配置项结构体
                        
    前言在上一小节中我们对模块的整体有了一定的把握,本小节将进入到事件模块的分析中,了解nginx是如何收集、管理、分发事件的。nginx将网络事件以及定时事件集成到一起进行管理,由于各平台的I/O多路复用机制不同,但是nginx支持多个操作系统,因此在事件模块中也实现了多种针对不同平台下封装I/O多路复用机制的模块。由于我所用的环境主要关注的是linux,因此后面主要分析ngx_epoll_modu
    
                    
    • 
                    
  • MongoDB在Spring商城用户行为记录中的应用
                        小小初霁
mongodbspring数据库
                        
    一、MongoDB的优势灵活Schema用户行为数据结构多变（如点击、搜索、下单），MongoDB的文档模型无需固定字段，适应快速迭代。高吞吐写入支持批量插入，适合高并发场景（如秒杀活动的用户操作记录）。复杂查询优化支持聚合管道、地理空间查询、全文索引，便于多维分析。水平扩展通过分片（Sharding）应对海量数据存储。二、用户行为数据建模1.基础行为记录集合（如user_actions）{"us
    
                    
    • 
                    
  • spring 的model repository service controller的功能
                        LCY133
web开发springjava后端
                        
    1.Controller层（控制层）•功能：负责接收和处理HTTP请求，协调客户端与业务逻辑之间的交互。•核心职责：•请求处理：解析HTTP请求参数（如URL参数、Body数据、Headers）。•路由分发：根据请求路径（@RequestMapping）调用对应的Service方法。•响应生成：返回格式化数据（如JSON、XML）或视图（如HTML页面）。•输入校验：验证请求参数的合法性（如使用@
    
                    
    • 
                    
  • SpringBoot调用deepseek
                        想买CT5的小曹
springboot后端java
                        
    1、效果截图：2、代码部分：application.propertiesserver.port=8080deepseek.api.token=sk-d34e929e887b4881813395241df2f745deepseek.api.url=https://api.deepseek.com/chat/completionscontroller部分请求参数可以缩短，写成实体类形式packagec
    
                    
    • 
                    
  • RabbitMQ实战（二）-消息持久化策略、事务以及Confirm消息确认方式
                        Java思享汇
RabbitMQ学习RabbitMQ消息持久化事务confirmack
                        
    「扫码关注我，面试、各种技术（mysql、zookeeper、微服务、redis、jvm）持续更新中～」RabbitMQ学习列表：RabbitMQ实战（一）-消息通信基本概念·在上一篇学习完RabbitMQ通信的基本概念后，我们来继续学习消息的持久化以及代码实现RabbitMQ通信。在正常生产环境运维过程中无法避免RabbitMQ服务器重启，那么，如果RabbitMQ重启之后，那些队列和交换器就会
    
                    
    • 
                    
  • java版电子招投标采购|投标|评标|竞标|邀标|评审招投标系统源码
                        微服务技术分享
java企业电子招投标系统源代码企业招投标系统源码招采系统源码
                        
    功能模块：待办消息，招标公告，中标公告，信息发布描述：全过程数字化采购管理，打造从供应商管理到采购招投标、采购合同、采购执行的全过程数字化管理。通供应商门户具备内外协同的能力，为外部供应商集中推送展示与其相关的所有采购业务信息（历史合作、考察整改，绩效评价等），支持供应商信息的自助维护，实时风险自动提服务框架：SpringCloud、SpringBoot2、Mybatis、OAuth2、Secur
    
                    
    • 
                                
  • Java常用排序算法/程序员必须掌握的8大排序算法
                                    cugfy
java
                                    
    分类： 
 
1）插入排序（直接插入排序、希尔排序） 
2）交换排序（冒泡排序、快速排序） 
3）选择排序（直接选择排序、堆排序） 
4）归并排序 
5）分配排序（基数排序） 
 
所需辅助空间最多：归并排序 
所需辅助空间最少：堆排序 
平均速度最快：快速排序 
 
不稳定：快速排序，希尔排序，堆排序。 
 
先来看看8种排序之间的关系： 
 
  
 
 1.直接插入排序 
 
（1
    
                                
    • 
                                
  • 【Spark102】Spark存储模块BlockManager剖析
                                    bit1129
manager
                                    
    Spark围绕着BlockManager构建了存储模块，包括RDD，Shuffle，Broadcast的存储都使用了BlockManager。而BlockManager在实现上是一个针对每个应用的Master/Executor结构，即Driver上BlockManager充当了Master角色，而各个Slave上(具体到应用范围，就是Executor)的BlockManager充当了Slave角色
    
                                
    • 
                                
  • linux 查看端口被占用情况详解
                                    daizj
linux端口占用netstatlsof
                                    
    经常在启动一个程序会碰到端口被占用，这里讲一下怎么查看端口是否被占用，及哪个程序占用，怎么Kill掉已占用端口的程序 
  
1、lsof -i:port 
port为端口号 
  
[root@slave /data/spark-1.4.0-bin-cdh4]# lsof -i:8080 
COMMAND   PID USER   FD   TY
    
                                
    • 
                                
  • Hosts文件使用
                                    周凡杨
hostslocahost
                                    
         一切都要从localhost说起，经常在tomcat容器起动后，访问页面时输入http://localhost:8088/index.jsp，大家都知道localhost代表本机地址，如果本机IP是10.10.134.21，那就相当于http://10.10.134.21:8088/index.jsp，有时候也会看到http: 127.0.0.1:
    
                                
    • 
                                
  • java excel工具
                                    g21121
Java excel
                                    
    直接上代码，一看就懂，利用的是jxl： 
import java.io.File;
import java.io.IOException;
import jxl.Cell;
import jxl.Sheet;
import jxl.Workbook;
import jxl.read.biff.BiffException;
import jxl.write.Label;
import 
    
                                
    • 
                                
  • web报表工具finereport常用函数的用法总结（数组函数）
                                    老A不折腾
finereportweb报表函数总结
                                    
    ADD2ARRAY 
ADDARRAY(array,insertArray, start):在数组第start个位置插入insertArray中的所有元素，再返回该数组。 
示例： 
ADDARRAY([3,4, 1, 5, 7], [23, 43, 22], 3)返回[3, 4, 23, 43, 22, 1, 5, 7]. 
ADDARRAY([3,4, 1, 5, 7], "测试&q
    
                                
    • 
                                
  • 游戏服务器网络带宽负载计算
                                    墙头上一根草
服务器
                                    
    家庭所安装的4M，8M宽带。其中M是指，Mbits/S 
其中要提前说明的是： 
8bits = 1Byte 
即8位等于1字节。我们硬盘大小50G。意思是50*1024M字节，约为 50000多字节。但是网宽是以“位”为单位的，所以，8Mbits就是1M字节。是容积体积的单位。 
8Mbits/s后面的S是秒。8Mbits/s意思是 每秒8M位，即每秒1M字节。 
我是在计算我们网络流量时想到的
    
                                
    • 
                                
  • 我的spring学习笔记2-IoC（反向控制 依赖注入）
                                    aijuans
Spring 3 系列
                                    
    IoC（反向控制 依赖注入）这是Spring提出来了，这也是Spring一大特色。这里我不用多说，我们看Spring教程就可以了解。当然我们不用Spring也可以用IoC，下面我将介绍不用Spring的IoC。 
IoC不是框架，她是java的技术，如今大多数轻量级的容器都会用到IoC技术。这里我就用一个例子来说明： 
如：程序中有 Mysql.calss 、Oracle.class 、SqlSe
    
                                
    • 
                                
  • 高性能mysql 之 选择存储引擎(一)
                                    annan211
mysqlInnoDBMySQL引擎存储引擎
                                    
      1 没有特殊情况，应尽可能使用InnoDB存储引擎。   原因：InnoDB 和 MYIsAM 是mysql 最常用、使用最普遍的存储引擎。其中InnoDB是最重要、最广泛的存储引擎。她   被设计用来处理大量的短期事务。短期事务大部分情况下是正常提交的，很少有回滚的情况。InnoDB的性能和自动崩溃   恢复特性使得她在非事务型存储的需求中也非常流行，除非有非常
    
                                
    • 
                                
  • UDP网络编程
                                    百合不是茶
UDP编程局域网组播
                                    
      
UDP是基于无连接的,不可靠的传输   与TCP/IP相反 
  
  
  
UDP实现私聊,发送方式客户端,接受方式服务器 
package netUDP_sc;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.Ine
    
                                
    • 
                                
  • JQuery对象的val()方法执行结果分析
                                    bijian1013
JavaScriptjsjquery
                                    
            JavaScript中，如果id对应的标签不存在（同理JAVA中，如果对象不存在），则调用它的方法会报错或抛异常。在实际开发中，发现JQuery在id对应的标签不存在时，调其val()方法不会报错，结果是undefined。 
        
    
                                
    • 
                                
  • http请求测试实例（采用json-lib解析）
                                    bijian1013
jsonhttp
                                    
            由于fastjson只支持JDK1.5版本，因些对于JDK1.4的项目，可以采用json-lib来解析JSON数据。如下是http请求的另外一种写法，仅供参考。 
package com;

import java.util.HashMap;
import java.util.Map;

import 
    
                                
    • 
                                
  • 【RPC框架Hessian四】Hessian与Spring集成
                                    bit1129
hessian
                                    
    在【RPC框架Hessian二】Hessian 对象序列化和反序列化一文中介绍了基于Hessian的RPC服务的实现步骤，在那里使用Hessian提供的API完成基于Hessian的RPC服务开发和客户端调用，本文使用Spring对Hessian的集成来实现Hessian的RPC调用。 
  定义模型、接口和服务器端代码 
|---Model 
   &nb
    
                                
    • 
                                
  • 【Mahout三】基于Mahout CBayes算法的20newsgroup流程分析
                                    bit1129
Mahout
                                    
    1.Mahout环境搭建 
 1.下载Mahout 
http://mirror.bit.edu.cn/apache/mahout/0.10.0/mahout-distribution-0.10.0.tar.gz 
  
 2.解压Mahout 
 3. 配置环境变量 
vim /etc/profile

export HADOOP_HOME=/home
    
                                
    • 
                                
  • nginx负载tomcat遇非80时的转发问题
                                    ronin47

                                    
    　　nginx负载后端容器是tomcat（其它容器如WAS,JBOSS暂没发现这个问题）非８０端口，遇到跳转异常问题。解决的思路是：$host:port 
       详细如下： 
　　  
该问题是最先发现的，由于之前对nginx不是特别的熟悉所以该问题是个入门级别的：    
?       1   2   3   4   5   
    
                                
    • 
                                
  • java-17-在一个字符串中找到第一个只出现一次的字符
                                    bylijinnan
java
                                    
    

public class FirstShowOnlyOnceElement {

	/**Q17.在一个字符串中找到第一个只出现一次的字符。如输入abaccdeff，则输出b
	 * 1.int[] count:count[i]表示i对应字符出现的次数
	 * 2.将26个英文字母映射：a-z <--> 0-25
	 * 3.假设全部字母都是小写
	 */
	pu
    
                                
    • 
                                
  • mongoDB 复制集
                                    开窍的石头
mongodb
                                    
    mongo的复制集就像mysql的主从数据库，当你往其中的主复制集(primary)写数据的时候，副复制集(secondary)会自动同步主复制集(Primary)的数据,当主复制集挂掉以后其中的一个副复制集会自动成为主复制集。提供服务器的可用性。和防止当机问题 
       
 
     mo
    
                                
    • 
                                
  • [宇宙与天文]宇宙时代的经济学
                                    comsci
经济
                                    
     
    宇宙尺度的交通工具一般都体型巨大，造价高昂。。。。。 
 
     在宇宙中进行航行，近程采用反作用力类型的发动机，需要消耗少量矿石燃料，中远程航行要采用量子或者聚变反应堆发动机，进行超空间跳跃，要消耗大量高纯度水晶体能源 
 
     以目前地球上国家的经济发展水平来讲，
    
                                
    • 
                                
  • Git忽略文件
                                    Cwind
git
                                    
         有很多文件不必使用git管理。例如Eclipse或其他IDE生成的项目文件，编译生成的各种目标或临时文件等。使用git status时，会在Untracked files里面看到这些文件列表，在一次需要添加的文件比较多时（使用git add . / git add -u），会把这些所有的未跟踪文件添加进索引。  
   ==== ==== ==== 一些牢骚
    
                                
    • 
                                
  • MySQL连接数据库的必须配置
                                    dashuaifu
mysql连接数据库配置
                                    
    MySQL连接数据库的必须配置 
  
1.driverClass：com.mysql.jdbc.Driver 
  
2.jdbcUrl：jdbc:mysql://localhost:3306/dbname 
  
3.user：username 
  
4.password：password 
  
其中1是驱动名；2是url，这里的‘dbna
    
                                
    • 
                                
  • 一生要养成的60个习惯
                                    dcj3sjt126com
习惯
                                    
    一生要养成的60个习惯 
第1篇 让你更受大家欢迎的习惯 
1 守时，不准时赴约,让别人等,会失去很多机会。 
如何做到： 
①该起床时就起床， 
②养成任何事情都提前15分钟的习惯。 
③带本可以随时阅读的书，如果早了就拿出来读读。 
④有条理，生活没条理最容易耽误时间。 
⑤提前计划：将重要和不重要的事情岔开。 
⑥今天就准备好明天要穿的衣服。 
⑦按时睡觉，这会让按时起床更容易。 
2 注重
    
                                
    • 
                                
  • [介绍]Yii 是什么
                                    dcj3sjt126com
PHPyii2
                                    
    Yii 是一个高性能，基于组件的 PHP 框架，用于快速开发现代 Web 应用程序。名字 Yii （读作 易）在中文里有“极致简单与不断演变”两重含义，也可看作 Yes It Is! 的缩写。  
Yii 最适合做什么？ 
Yii 是一个通用的 Web 编程框架，即可以用于开发各种用 PHP 构建的 Web 应用。因为基于组件的框架结构和设计精巧的缓存支持，它特别适合开发大型应
    
                                
    • 
                                
  • Linux SSH常用总结
                                    eksliang
linux sshSSHD
                                    
    转载请出自出处：http://eksliang.iteye.com/blog/2186931 一、连接到远程主机 
  
格式：
ssh name@remoteserver
例如：
ssh [email protected] 
  二、连接到远程主机指定的端口 
  
格式：
ssh name@remoteserver -p 22
例如：
ssh i
    
                                
    • 
                                
  • 快速上传头像到服务端工具类FaceUtil
                                    gundumw100
android
                                    
    快速迭代用 
 
 

import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOExceptio
    
                                
    • 
                                
  • jQuery入门之怎么使用
                                    ini
JavaScripthtmljqueryWebcss
                                    
    jQuery的强大我何问起（个人主页：hovertree.com）就不用多说了，那么怎么使用jQuery呢？ 
  
首先，下载jquery。下载地址：http://hovertree.com/hvtart/bjae/b8627323101a4994.htm，一个是压缩版本，一个是未压缩版本，如果在开发测试阶段，可以使用未压缩版本，实际应用一般使用压缩版本(min)。然后就在页面上引用。
    
                                
    • 
                                
  • 带filter的hbase查询优化
                                    kane_xie
查询优化hbaseRandomRowFilter
                                    
     
 问题描述 
 
hbase scan数据缓慢，server端出现LeaseException。hbase写入缓慢。     
 
 问题原因 
 
直接原因是：  hbase client端每次和regionserver交互的时候，都会在服务器端生成一个Lease,Lease的有效期由参数hbase.regionserver.lease.period确定。如果hbase scan需
    
                                
    • 
                                
  • java设计模式-单例模式
                                    men4661273
java单例枚举反射IOC
                                    
             单例模式1，饿汉模式 
//饿汉式单例类.在类初始化时，已经自行实例化
public class Singleton1 {
    //私有的默认构造函数
    private Singleton1() {}
    //已经自行实例化
    private static final Singleton1 singl
    
                                
    • 
                                
  • mongodb 查询某一天所有信息的3种方法，根据日期查询
                                    qiaolevip
每天进步一点点学习永无止境mongodb纵观千象
                                    
    // mongodb的查询真让人难以琢磨，就查询单天信息，都需要花费一番功夫才行。

// 第一种方式：
coll.aggregate([
          {$project:{sendDate: {$substr: ['$sendTime', 0, 10]}, sendTime: 1, content:1}},
          {$match:{sendDate: '2015-
    
                                
    • 
                                
  • 二维数组转换成JSON
                                    tangqi609567707
java二维数组json
                                    
    原文出处：http://blog.csdn.net/springsen/article/details/7833596 
public class Demo { 
    public static void main(String[] args) {        String[][] blogL
    
                                
    • 
                                
  • erlang supervisor
                                    wudixiaotie
erlang
                                    
    定义supervisor时，如果是监控celuesimple_one_for_one则删除children的时候就用supervisor:terminate_child (SupModuleName, ChildPid)，如果shutdown策略选择的是brutal_kill，那么supervisor会调用exit(ChildPid, kill)，这样的话如果Child的behavior是gen_
    
                                
    •