滔滔逐浪
滔滔逐浪

4,springboot 整合RabbitMq

https://blog.csdn.net/qq_35387940/article/details/100514134
https://github.com/wangjin123456/2020/tree/master/springboot/rabbitmq

在安装完rabbitmq后，输入：http://localhost:15672/，是可以看到rbbitmq界面的；

image.png

在这个界面里面我们乐意做点什么呢？
可以手动创建虚拟机host,创建用户，分配权限，创建队列等，还有查看队列消息，消费效率，推送效率等。
首先先介绍下一个简单的一个消息推送到接收的流程，提供一个简单的图：
image

黄色的圈圈就是我们的消息推送服务，将消息推送到中间方框里面也就是rabbitMq发服务器，然后经过服务器里面的交换机，队列等各种消息将数据处理入列后，最终右边的消费者将获取对应监听的消息。
常用的交换机有以下三种，因为消费者是从队列获取信息的，对列是绑定交换机的（），所以对应的消息推送/接收模式也会有以下三种：
直连型交换机，根据消息携带的路由键将消息投递给对应的队列；

大致流程，有一个队列绑定到一个直连交换机上，同时赋予了一个路由键routing key .然后当一个消息携带着路由值为X,这个消息通过生产者发送给交换机时交换机就根据这个路由值X去寻找绑定值也是X的队列
Fanout Exchange
扇形交换机，这个交换机没有路由键的概念，就算你绑定了路由键也是无视的。这个交换机在接到消息后：会直接转发到绑定到他上面的所有队列。

Topic Exchange
主题交换机，这个交换机其实跟直连交换机流程差不多，但是他的特点是在他的路由键和绑定建之间是有规则的，简单的介绍下规则

  • （星号）用来表示一个单词（必须出现的）

（并号）用来表示任意数量（零个或者多个）单词

统配的绑定建是跟队列进行绑定的，举个小例子：
队列Q1 绑定键为：.TT. 队列Q2绑定键为 TT.#
如果一条消息携带的路由键为 A.TT.B，那么队列Q1将会收到；
如果一条消息携带的路由键为TT.AA.BB，那么队列Q2将会收到；
主题交换机时非常强大的，为什么这么膨胀？

当一个队列绑定键为 # 的时候，这个队列将会无视消息的路由键，接收
所有的消息。
当* 和 # 这2个特殊字符都未在绑定建中出现的时候，此时主题交换机就拥有了直连交换机的功能，
所以主题交换机也就实现了扇形交换机和直连交换机的功能。

另外还有Header Exchange 头交换机，default Exchange 默认交换机， Dead Letter Exchange死信交换机
好了，简单的介绍到此为止，接下来进行编码：
本次实例教程需要创建2个 springboot 项目，一个rabbitmq-provider（生产者），consumber 消费者。

首先创建rabbit-provider,
pom.xml 里用到的jar依赖：



    4.0.0
    
        org.springframework.boot
        spring-boot-starter-parent
        2.2.5.RELEASE
         
    
    com.taotao
    rabbitmq-provider
    0.0.1-SNAPSHOT
    rabbitmq-provider
    Demo project for Spring Boot

    
        1.8
    

    
        
        
            org.springframework.boot
            spring-boot-starter-amqp
        
        
            org.springframework.boot
            spring-boot-starter-web
        

        
            org.springframework.boot
            spring-boot-starter-test
            test
            
                
                    org.junit.vintage
                    junit-vintage-engine
                
            
        
        
            org.springframework.amqp
            spring-rabbit-test
            test
        
    

    
        
            
                org.springframework.boot
                spring-boot-maven-plugin

然后application.yml

server:
  port:  8021
spring:
   application:
      name: rabbitmq-provider
   rabbitmq:
     host: 127.0.0.1
     port:  5672
     username: sy
     password: aaaa1111
     virtual-host:  /yingying_rabbitmq  #这里要去rabbitmq里面创建 /yingying_rabbitmq   并且授权，

接着我们先用下direct exchange(直连型交换机)，创建DirectRabbitConfig.java :


package com.taotao.rabbitmqprovider.config;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/*
* 使用direct exchange(直连型交换机)
* @autor tom
* @date 2020/3/19 0019 10:46
*/@Configuration
public class DirectRabbitConfig {

 //队列 起名：TestDirectQueue
 @Bean
 public Queue TestDirectQueue() {
     return new Queue("TestDirectQueue",true);  //true 是否持久
 }

 //Direct交换机 起名：TestDirectExchange
 @Bean
 DirectExchange TestDirectExchange() {
     return new DirectExchange("TestDirectExchange");
 }

 //绑定  将队列和交换机绑定, 并设置用于匹配键：TestDirectRouting
 @Bean
 Binding bindingDirect() {
     return BindingBuilder.bind(TestDirectQueue()).to(TestDirectExchange()).with("TestDirectRouting");
 }



}

写个简单的接口进行消息推送（根据需求也可以改为定时任务等等，具体看需求），
SendMessageController.java：


package com.taotao.rabbitmqprovider.controller;

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;

/**
 * 接口进行消息推送
 * @autor tom
 * @date 2020/3/19 0019 11:01
 */
@RestController
public class SendMessageController {
    //使用RabbitTemplate 这里提供了接收/发送等方法
    @Autowired
    RabbitTemplate rabbitTemplate;
    @GetMapping("/sendDirectMessage")
    public String sendDirectMessage() {
        String messageId = String.valueOf(UUID.randomUUID());
        String messageData = "test message  hello!";
        String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        Map map = new HashMap<>();
        map.put("messageId", messageId);
        map.put("messageData", messageData);
        map.put("createTime", createTime);
        //将消息携带绑定键值：TestDirectRouting 发送到交换机TestDirectExchange
        rabbitTemplate.convertAndSend("TestDirectExchange", "TestDirectRouting", map);
        return "ok";

    }
}

访问 http://localhost:8021/sendDirectMessage

image.png

因为目前没有弄消费者rabbitmq-consumer，消息没有被消费，我们去rabbitmq
管理页面看，是否推送成功。


image.png

再看看队列

image.png

很好，消息已经推送到rabbitmq服务器了
接下来创建 rabbitmq-consumer项目：
pom.xml依赖：




    4.0.0
    
        org.springframework.boot
        spring-boot-starter-parent
        2.2.5.RELEASE
         
    
    com.taotao
    rabbitmq-consumer
    0.0.1-SNAPSHOT
    rabbitmq-consumer
    Demo project for Spring Boot

    
        1.8
    

    
        
            org.springframework.boot
            spring-boot-starter-amqp
        
        
            org.springframework.boot
            spring-boot-starter-web
        

        
            org.springframework.boot
            spring-boot-starter-test
            test
            
                
                    org.junit.vintage
                    junit-vintage-engine
                
            
        
        
            org.springframework.amqp
            spring-rabbit-test
            test
        
    

    
        
            
                org.springframework.boot
                spring-boot-maven-plugin

然后是 yml

server:
  port: 8022
spring:
   application:
      name: rabbitmq-consumer
   rabbitmq:
      host: 127.0.0.1
      port: 5672
      username:  sy
      password:  aaaa1111
      virtual-host:  /yingying_rabbitmq

然后一样，创建 DirectRabbitConfig.java


package com.taotao.rabbitmqconsumer.config;
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @autor tom
 * @date 2020/3/19 0019 15:18
 */
@Configuration
public class DirectRabbitConfig {
    //队列 起名：TestDirectQueue
    @Bean
    public Queue TestDirectQueue() {
        return new Queue("TestDirectQueue", true);
    }

    //Direct交换机 起名：TestDirectExchange
    @Bean
    DirectExchange TestDirectExchange() {
        return new DirectExchange("TestDirectExchange");
    }

    //绑定  将队列和交换机绑定, 并设置用于匹配键：TestDirectRouting
    @Bean
    Binding bindingDirect() {
        return BindingBuilder.bind(TestDirectQueue()).to(TestDirectExchange()).with("TestDirectRouting");
    }
}

然后创建消息接收监听类, DirectReceiver.java


package com.taotao.rabbitmqconsumer.config;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.util.Map;

/**
 * 创建消息接收监听类
 * @autor tom
 * @date 2020/3/19 0019 15:29
 */
@Component
@RabbitListener(queues = "TestDirectQueue")//监听的队列消息
public class DirectReceiver {
    @RabbitHandler
    public  void process(Map testMessage){
        System.out.println("DirectReceiver消费者收到消息："+ testMessage.toString() );
    }
}

然后将rabbitmq-consumer项目运行起来，可以看到把之前推送的那条消息消费下来了：
然后可以再继续调用rabbitmq-provider项目的推送消息接口，可以看到消费者即时消费消息：


image.png

接着，我们使用Topic Exchange 主题交换机

在rabbitmq-provider 项目里创建TopicRabbitConfig.java

package com.taotao.rabbitmqprovider.config;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
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 javax.management.MXBean;


/**
 * 主题交换机
 * @autor tom
 * @date 2020/3/19 0019 16:25
 */
@Configuration
public class TopicRabbitConfig {
    //绑定建
    public  final static String man="topic.man";
    public final static  String woman="topic.woman";
    @Bean
    public Queue firstQueue(){
        return  new Queue(TopicRabbitConfig.man);
    }

    @Bean
    public  Queue secondQueue(){
        return  new Queue(TopicRabbitConfig.woman);
    }

    @Bean
    TopicExchange exchange(){
        return  new TopicExchange("topicExchange");
    }
    /**
     * 将firstQueue 和 topicExchange绑定，而且绑定的键值为 topic.man
     *z这样只要是消息携带的路由键是topic.man，才会分发到该队列
     */
    @Bean
    Binding bindingExchangeMessage(){
        return  BindingBuilder.bind(firstQueue()).to(exchange()).with(man);
    }
    /**
     * 将SecondQueue 和 topicExchange绑定，而且绑定的键值为 topic.#
     *z这样只要是消息携带的路由键是topic.#，才会分发到该队列
     */
    @Bean
    Binding bindingExchangeMessage2(){
        return  BindingBuilder.bind(secondQueue()).to(exchange()).with("topic.#");
    }
}

2，然后再加多2个接口，同于推送消息到主题交换机：

package com.taotao.rabbitmqprovider.controller;

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;

/**
 * 接口进行消息推送
 * @autor tom
 * @date 2020/3/19 0019 11:01
 */
@RestController
public class SendMessageController {
    //使用RabbitTemplate 这里提供了接收/发送等方法
    @Autowired
    RabbitTemplate rabbitTemplate;
    @GetMapping("/sendDirectMessage")
    public String sendDirectMessage() {
        String messageId = String.valueOf(UUID.randomUUID());
        String messageData = "test message, hello!";
        String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        Map map = new HashMap<>();
        map.put("messageId", messageId);
        map.put("messageData", messageData);
        map.put("createTime", createTime);
        //将消息携带绑定键值：TestDirectRouting 发送到交换机TestDirectExchange
        rabbitTemplate.convertAndSend("TestDirectExchange", "TestDirectRouting", map);
        return "ok";

    }


    @GetMapping("/sendTopicMessage1")
    public String sendTopicMessage1(){
        String messageId=String.valueOf(UUID.randomUUID());
        String messageData ="message: M A N";
        String createTime=LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        Map manMap=new HashMap<>();
        manMap.put("messageId",messageId);
        manMap.put("messageData",messageData);
        manMap.put("createTime",createTime);//topic.man
        rabbitTemplate.convertAndSend("topicExchange","topic.man",manMap);
      return  "ok";
    }


    @GetMapping("/sendTopicMessage2")
    public String sendTopicMessage2(){
        String messageId=String.valueOf(UUID.randomUUID());
        String messageData ="message:  woman is all";
        String createTime=LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        Map manMap=new HashMap<>();
        manMap.put("messageId",messageId);
        manMap.put("messageData",messageData);
        manMap.put("createTime",createTime);
        rabbitTemplate.convertAndSend("topicExchange","topic.woman",manMap);
        return  "ok";
    }

}

生产者这边已经完事，先不着急运行，在rabbit-consumer项目上，创建TopicManReceiver.java

package com.taotao.rabbitmqconsumer.config;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.util.Map;

/**
 * @autor tom
 * @date 2020/3/19 0019 18:29
 */

@Component
@RabbitListener(queues = "topic.man")
public class TopicManReceiver {
    @RabbitHandler
    public void process(Map testMessage){
        System.out.println("TopicManReceiver消费者收到消息："+testMessage.toString());
    }
}

在创建一个TopicTotalReceiver.java

package com.taotao.rabbitmqconsumer.config;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.util.Map;

/**
 * @autor tom
 * @date 2020/3/19 0019 18:32
 */

@Component
@RabbitListener(queues = "topic.woman")
public class TopicTotalReceiver {

    @RabbitHandler
    public void process(Map testMessage){
        System.out.println("TopicTotalReceiver消费者收到的消息:"+ testMessage.toString());
    }
}

同样加上主题交换机的相关配置， TopicRabbitConfig.java


package com.taotao.rabbitmqconsumer.config;

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


/**
 * 主题交换机
 * @autor tom
 * @date 2020/3/19 0019 16:25
 */
@Configuration
public class TopicRabbitConfig {
    //绑定建
    public  final static String man="topic.man";
    public final static  String woman="topic.woman";
    @Bean
    public Queue firstQueue(){
        return  new Queue(TopicRabbitConfig.man);
    }

    @Bean
    public  Queue secondQueue(){
        return  new Queue(TopicRabbitConfig.woman);
    }

    @Bean
    TopicExchange exchange(){
        return  new TopicExchange("topicExchange");
    }
    /**
     * 将firstQueue 和 topicExchange绑定，而且绑定的键值为 topic.man
     *z这样只要是消息携带的路由键是topic.man，才会分发到该队列
     */
    @Bean
    Binding bindingExchangeMessage(){
        return  BindingBuilder.bind(firstQueue()).to(exchange()).with(man);
    }
    /**
     * 将SecondQueue 和 topicExchange绑定，而且绑定的键值为 topic.#
     *z这样只要是消息携带的路由键是topic.#，才会分发到该队列
     */
    @Bean
    Binding bindingExchangeMessage2(){
        return  BindingBuilder.bind(secondQueue()).to(exchange()).with("topic.#");
    }
}

然后将rabbitmq-provider, rabbit-cosumer2个项目跑起来，先调用/sendTopicMessage1接口：


image

然后看消费者rabbitmq-consumer的控制台输出情况：
TopicManReceiver 监听队列1，绑定建为 topic.man
TopicTotallReceiver 监听队列2，绑定键为： topic.#
而当前推送的消息，携带的路由键为: topic.man
所以可以看到两个监听消费者receiver都成功消费到了消息，因为这两个recevier监听的队列的绑定键都能与这条消息携带的路由键匹配上。


image.png

接下来调用接口/sendTopicMessage2:
image

然后看消费者rabbitmq-consumer的控制台输出情况：
TopicManReceiver监听队列1，绑定键为：topic.man
TopicTotalReceiver监听队列2，绑定键为：topic.#
而当前推送的消息，携带的路由键为：topic.woman

所以可以看到两个监听消费者只有TopicTotalReceiver成功消费到了消息。


image.png

接下来是使用Fanout Exchang 扇形交换机。
同样地，先在rabbitmq-provider项目上创建FanoutRabbitConfig.java:



package com.taotao.rabbitmqprovider.config;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.FanoutExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;



/**
 * Famout Exchange 扇形交换机
 * @autor tom
 * @date 2020/3/19 0019 19:13
 */
@Configuration
public class FanoutRabbitConfig {

    /***
     * 创建三个队列： famout.A  famout.B famout.c
     * 将三个队列都绑定在交换机 famoutExchange 上
     * 因为是扇形交换机，路由键无需配置，配置也不起作用
     */

    @Bean
    public Queue queueA(){
        return  new Queue("fanout.A");
    }
    @Bean
    public Queue queueB(){
        return  new Queue("fanout.B");
    }
    @Bean
    public Queue queueC(){
        return  new Queue("fanout.C");
    }

    @Bean
    FanoutExchange fanoutExchange(){
        return  new FanoutExchange("fanoutExchange");
    }

    @Bean
    Binding bindingExchangeA(){
        return BindingBuilder.bind(queueA()).to(fanoutExchange());
    }
    @Bean
    Binding bindingExchangeB(){
        return BindingBuilder.bind(queueB()).to(fanoutExchange());
    }
    @Bean
    Binding bindingExchangeC(){
        return BindingBuilder.bind(queueC()).to(fanoutExchange());
    }
}

然后填写一个接口用于推送消息;

package com.taotao.rabbitmqprovider.controller;

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;

/**
 * 接口进行消息推送
 * @autor tom
 * @date 2020/3/19 0019 11:01
 */
@RestController
public class SendMessageController {
    //使用RabbitTemplate 这里提供了接收/发送等方法
    @Autowired
    RabbitTemplate rabbitTemplate;
    @GetMapping("/sendDirectMessage")
    public String sendDirectMessage() {
        String messageId = String.valueOf(UUID.randomUUID());
        String messageData = "test message, hello!";
        String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        Map map = new HashMap<>();
        map.put("messageId", messageId);
        map.put("messageData", messageData);
        map.put("createTime", createTime);
        //将消息携带绑定键值：TestDirectRouting 发送到交换机TestDirectExchange
        rabbitTemplate.convertAndSend("TestDirectExchange", "TestDirectRouting", map);
        return "ok";

    }


    @GetMapping("/sendTopicMessage1")
    public String sendTopicMessage1(){
        String messageId=String.valueOf(UUID.randomUUID());
        String messageData ="message: M A N";
        String createTime=LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        Map manMap=new HashMap<>();
        manMap.put("messageId",messageId);
        manMap.put("messageData",messageData);
        manMap.put("createTime",createTime);//topic.man
        rabbitTemplate.convertAndSend("topicExchange","topic.man",manMap);
      return  "ok";
    }


    @GetMapping("/sendTopicMessage2")
    public String sendTopicMessage2(){
        String messageId=String.valueOf(UUID.randomUUID());
        String messageData ="message:  woman is all";
        String createTime=LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        Map manMap=new HashMap<>();
        manMap.put("messageId",messageId);
        manMap.put("messageData",messageData);
        manMap.put("createTime",createTime);
        rabbitTemplate.convertAndSend("topicExchange","topic.woman",manMap);
        return  "ok";
    }

    @GetMapping("/sendTopicMessage3")
    public String sendTopicMessage3(){
        String messageId=String.valueOf(UUID.randomUUID());
        String messageData ="message:  woman is all";
        String createTime=LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        Map manMap=new HashMap<>();
        manMap.put("messageId",messageId);
        manMap.put("messageData",messageData);
        manMap.put("createTime",createTime);
        rabbitTemplate.convertAndSend("fanoutExchange",null,manMap);
        return  "ok";
    }
}

接着在 rabbitmq-consumer项目里加上消息消费类

FanoutReceiverA.java


package com.taotao.rabbitmqconsumer.config;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.util.Map;

/**
 * 加上消息消费类
 * @autor tom
 * @date 2020/3/19 0019 19:23
 */
@Component
@RabbitListener(queues = "fanout.A")
public class FanoutReceiverA {

    @RabbitHandler
    public  void process(Map testMessage){
        System.out.println("FamoutReceiverA消费者收到消息："+ testMessage.toString());
    }
}

FanoutReceiverB.java

package com.taotao.rabbitmqconsumer.config;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.util.Map;

/**
 * 加上消息消费类
 * @autor tom
 * @date 2020/3/19 0019 19:23
 */
@Component
@RabbitListener(queues = "fanout.B")
public class FanoutReceiverB {

    @RabbitHandler
    public  void process(Map testMessage){
        System.out.println("FamoutReceiverB消费者收到消息："+ testMessage.toString());
    }
}

FanoutReceiverC.java

package com.taotao.rabbitmqconsumer.config;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.util.Map;

/**
 * 加上消息消费类
 * @autor tom
 * @date 2020/3/19 0019 19:23
 */
@Component
@RabbitListener(queues = "fanout.C")
public class FanoutReceiverC {

    @RabbitHandler
    public  void process(Map testMessage){
        System.out.println("FamoutReceiverC消费者收到消息："+ testMessage.toString());
    }
}

然后加上扇形交换机的配置类， FanoutRabbitConfig.java

package com.taotao.rabbitmqconsumer.config;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.FanoutExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;


/**
 * Famout Exchange 扇形交换机
 * @autor tom
 * @date 2020/3/19 0019 19:13
 */
@Configuration
public class FanoutRabbitConfig {

    /***
     * 创建三个队列： famout.A  famout.B famout.c
     * 将三个队列都绑定在交换机 famoutExchange 上
     * 因为是扇形交换机，路由键无需配置，配置也不起作用
     */

    @Bean
    public Queue queueA(){
        return  new Queue("fanout.A");
    }
    @Bean
    public Queue queueB(){
        return  new Queue("fanout.B");
    }
    @Bean
    public Queue queueC(){
        return  new Queue("fanout.C");
    }

    @Bean
    FanoutExchange fanoutExchange(){
        return  new FanoutExchange("fanoutExchange");
    }

    @Bean
    Binding bindingExchangeA(){
        return BindingBuilder.bind(queueA()).to(fanoutExchange());
    }
    @Bean
    Binding bindingExchangeB(){
        return BindingBuilder.bind(queueB()).to(fanoutExchange());
    }
    @Bean
    Binding bindingExchangeC(){
        return BindingBuilder.bind(queueC()).to(fanoutExchange());
    }
}

最后将rabbitmq-provider和rabbitmq-consumer项目都跑起来，调用下接口/sendFanoutMessage ：

image

然后看看rabbitmq-consumer项目的控制台情况：

可以看到只要发送到 fanoutExchange 这个扇型交换机的消息， 三个队列都绑定这个交换机，所以三个消息接收类都监听到了这条消息。
到了这里其实三个常用交换机的使用我们已经使用完毕了，那么接下来我们继续讲讲 消息的回调，其实就是消息确认（生产者推送消息成功，消费这边接收消息成功）。

在rabbitmq-provider项目的application.yml文件上，加上消息确认的配置项后：

···
server:
port: 8021
spring:
application:
name: rabbitmq-provider
rabbitmq:
host: 127.0.0.1
port: 5672
username: sy
password: aaaa1111
virtual-host: /yingying_rabbitmq #这里要去rabbitmq里面创建 /yingying_rabbitmq 并且授权，
#消息确认配置项

 #确认消息已发送到交换机（Exchange)

 publisher-confirms: true
 publisher-returns: true #确认消息已发送到队列（）Queue

···
然后配置相关的信息确认回调函数，RabbitConfig.java

package com.taotao.rabbitmqprovider.config;


import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * 配置相关的消息确认回调函数
 *
 * @autor tom
 * @date 2020/3/19 0019 21:19
 */
@Configuration
public class RabbitConfig {
    @Bean
    public RabbitTemplate createRabbitTemplate(ConnectionFactory connectionFactory) {
        RabbitTemplate rabbitTemplate = new RabbitTemplate();
        rabbitTemplate.setConnectionFactory(connectionFactory);
        //设置开启Mandatory, 才能触发回调函数，无论消息推送结果怎么样都强制调用回调函数，
        rabbitTemplate.setMandatory(true);
        rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
            @Override
            public void confirm(CorrelationData correlationData, boolean b, String s) {
                System.out.println("ConfirmCallback:  " + " 相关数据:" + correlationData);
                System.out.println("ConfirmCallback:  " + "确认情况： " + b);
                System.out.println("ConfirmCallback:  " + " 原因：" + s);
            }
        });

        rabbitTemplate.setReturnCallback(new RabbitTemplate.ReturnCallback() {
            @Override
            public void returnedMessage(Message message, int i, String s, String s1, String s2) {
                System.out.println("ReturnCallback:  " + "消息：" + message);

                System.out.println("ReturnCallback:  " + "回应码：" + i);
                System.out.println("ReturnCallback:  " + "回应消息：" + s);
                System.out.println("ReturnCallback:  " + "交换机：" + s1);
                System.out.println("ReturnCallback:  " + "路由键：" + s2);

            }
        });
        return rabbitTemplate;
    }


}

到这里 ，生产者推送消息的消息确认调用回调函数已完毕

可以看到上面写 了2个回调函数，一个叫ConfirmCallback，一个叫做Retrunallback;
那么以上这2种回调函数都是什么情况会触发呢？
先从总体的情况分析，推送消息存在四种情况：
1，消息推送到server,但是在server里找不到交换机
2，消息推送到server,找到交换机了，但是没找到队列
3，消息推送到server,交换机和队列啥都没找到
4，消息推送成功
那么我先写几个接口来分别测试和认证下4种情况，消息确认触发回调函数情况：
1，消息推送到server，但是在server里找不到交换机
写个测试接口，把消息推送到名为 'non-existent-exchange' 的交换机上（这里没有配置的）：

  /**
     *
     * 消息推送到server ,但是在server里找不到交换机
     */

    @GetMapping("/TestMessageAck")
    public  String TestMessageAck(){
        String messageId =String.valueOf(UUID.randomUUID());
        String messageData ="message: non-existent-exchange  test message";
        String createTime=LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH-mm-ss"));
        Mapmap =new HashMap<>();
        map.put("messageId",messageId);
        map.put("messageData",messageData);
        map.put("createTime",createTime);
        rabbitTemplate.convertAndSend("non-existent-exchange","TestDirectRouting",map);

        return  "ok";

    }

调用接口，查看rabbitmq-provider项目控制台输出情况（原因里又说，existent-exchange）:

2020-03-19 22:28:08.820 ERROR 10768 --- [ 127.0.0.1:5672] o.s.a.r.c.CachingConnectionFactory       : Channel shutdown: channel error; protocol method: #method(reply-code=404, reply-text=NOT_FOUND - no exchange 'non-existent-exchange' in vhost '/yingying_rabbitmq', class-id=60, method-id=40)
ConfirmCallback:   相关数据:null
ConfirmCallback:  确认情况： false
ConfirmCallback:   原因：channel error; protocol method: #method(reply-code=404, reply-text=NOT_FOUND - no exchange 'non-existent-exchange' in vhost '/yingying_rabbitmq', class-id=60, method-id=40)

结论： 1 这种情况触发的是ConfirmCallback回调函数

2，消息推送到server, 找到交换机了，但是没有找到队列
这种情况就是需要新增一个交换机，但是不给这个交换机绑定队列，我来简单在
DirectRabbitConfig 里面新增一个交换机，名叫"lonelyDirectExchange",但是没给他做任何绑定配置操作：

  @Bean
    DirectExchange lonelyDirectExchange() {
        return new DirectExchange("lonelyDirectExchange");
    }

然后写个测试接口，把消息推送到名为 'lonelyDirectExchange'的交换机（这个交换机时没有任何队列配置的）：

  @GetMapping("/TestMessageAck2")
    public String TestMessageAck2() {
        String messageId = String.valueOf(UUID.randomUUID());
        String messageData = "message: lonelyDirectExchange test message ";
        String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        Map map = new HashMap<>();
        map.put("messageId", messageId);
        map.put("messageData", messageData);
        map.put("createTime", createTime);
        rabbitTemplate.convertAndSend("lonelyDirectExchange", "TestDirectRouting", map);
        return "ok";
    }

调用接口，查看rabbitmq-provider项目的控制台输出情况：

ReturnCallback:  消息：(Body:'{createTime=2020-03-20 04:01:26, messageId=80341f93-fff8-4cf2-bd03-cea65ab9b589, messageData=message: lonelyDirectExchange test message }' MessageProperties [headers={}, contentType=application/x-java-serialized-object, contentLength=0, receivedDeliveryMode=PERSISTENT, priority=0, deliveryTag=0])
ReturnCallback:  回应码：312
ReturnCallback:  回应消息：NO_ROUTE
ReturnCallback:  交换机：lonelyDirectExchange
ReturnCallback:  路由键：TestDirectRouting



ConfirmCallback:   相关数据:null
ConfirmCallback:  确认情况： true
ConfirmCallback:   原因：null

可以看到这种情况，2个函数都被调用了；
这种情况下，消息是推送成功到服务器了的，所以ConfirmCallback对 消息确认情况是true;而在ReturnCalllback回调函数的打印参数里面可以看到，消息是推送到了交换机成功了，但是在路由分发给队列的时候，找不到队列，所以报了错误 No_Route
结论 2 这种情况触发的是 Confirm和 ReturnCallback 2个回调函数。
3，消息推送到server，交换机和队列啥都没找到，
这种情况其实一看觉得跟1 好像，没错，3和1的回调是一致的，所以不做结果说明了
结论： 3 这种情况触发的是ConfirmCallback 回调函数。
4 消息推送成功
那么测试下，按照正常调用之前消息推送到的接口就行，就调用下/sendFanoutMessage接口，可以看到控制台输出：

ConfirmCallback:   相关数据:null
ConfirmCallback:  确认情况： true
ConfirmCallback:   原因：null

以上是生产者推送消息的消息确认，回调函数的使用介绍（可以在回调函数根据雪球做对应的扩展或者业务数据处理）。
接下来我们继续，消费者接受到消息的消息确认机制。
和生产者的消息确认不同，因为消息接收本来就是在监听消息，符合条件的消息就会消费下来。所以，消息接收的确认机制主要存在三种模式
1，自动确认，这也是默认的消息确认情况， AcknowledgeMode.NONE
RabbitMQ成功将消息发出（即将消息成功写入 Tcp Socket）中立即认为本次投递已经被正确处理。不管消费者端是否成功处理本次投递；
所以这种情况如果消费端消费逻辑抛出异常，也就是消费端没有处理成功这条消息，那么相当于丢失了消息。
一般这种情况我们都是使用try catch 捕捉异常后， 打印日志用于追踪数据，这样找出对应数据在做后续处理。

2，根据情况确认，这个不做介绍
3，手动确认，这个比较关键，也是我们配置接收消息确认机制时，多数选择的模式。消费者接收到消息后，手动调用用 basic.ack/basic.nack/basic.reject后，RabbitMQ收到消息后，才认为本次投递成功。
basic.ack 用于肯定确认，
basic.nack 用于否定确认，
basic.reject 用于否定确认，但与basic.nack相比有一个限制，一次只能拒绝单条消息，消费者端以上的3个方法都表示消息已经被正确投递，但是basic.ack表示消息已经被正确处理，但是basic.nack,basic.reject 表示没有被正确处理，但是RabbitMQ中仍然需要删除这条消息。

看了上面那么多介绍，接下来我们一起配置下，看看一般的消息接收，手动确认是怎样的。
之前介绍用了很多个交换，现在我们就先给直连型交换机添加信息接收确认机制。
新建 MessageListenerConfig.java 上添加代码相关的配置代码（可以看到注释掉的代码，就是给扇型交换机配置消息确认，只用在这个里面继续添加对应的队列和对应的接收类即可，当然对应的接收类也需要跟后面介绍一个加上对应方法）：

package com.taotao.rabbitmqconsumer.config;

import org.springframework.amqp.core.AcknowledgeMode;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @autor tom
 * @date 2020/3/20 0020 7:35
 */
@Configuration
public class MessageListenerConfig {
    @Autowired
    private CachingConnectionFactory cachingConnectionFactory;
    @Autowired
    private DirectReceiver directReceiver;//Direct消息接收处理类
    //@Autowired
    //FanoutReceiverA fanoutReceiverA;//消息接收处理类A

    @Autowired
    DirectRabbitConfig directRabbitConfig;

    //@Autowired
    //   FanoutRabbitConfig fanoutRabbitConfig;
    @Bean
    public SimpleMessageListenerContainer simpleMessageListenerContainer() {
        SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(cachingConnectionFactory);
        container.setConcurrentConsumers(1);
        container.setMaxConcurrentConsumers(1);
        container.setAcknowledgeMode(AcknowledgeMode.MANUAL); // RabbitMQ默认是自动确认，这里改为手动确认消息
        container.setQueues(directRabbitConfig.TestDirectQueue());
        container.setMessageListener(directReceiver);
//        container.addQueues(fanoutRabbitConfig.queueA());
//        container.setMessageListener(fanoutReceiverA);
        return container;
    }
}

然后在直连型交换机的消息接收处理类上需要添加相关的消息手动确认代码
DirectReceiver.java

package com.taotao.rabbitmqconsumer.config;

import com.rabbitmq.client.Channel;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.rabbit.listener.api.ChannelAwareMessageListener;
import org.springframework.stereotype.Component;

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

/**
 * 创建消息接收监听类
 * @autor tom
 * @date 2020/3/19 0019 15:29
 */
@Component
@RabbitListener(queues = "TestDirectQueue")//监听的队列名称 TestDirectQueue
public class DirectReceiver implements ChannelAwareMessageListener {

    @Override
    public void onMessage(Message message, Channel channel) throws Exception {
        long deliveryTag = message.getMessageProperties().getDeliveryTag();
        try {
            //因为传递消息的时候用的map传递,所以将Map从Message内取出需要做些处理
            String msg = message.toString();
            String[] msgArray = msg.split("'");//可以点进Message里面看源码,单引号直接的数据就是我们的map消息数据
            Map msgMap = mapStringToMap(msgArray[1].trim());
            String messageId=msgMap.get("messageId");
            String messageData=msgMap.get("messageData");
            String createTime=msgMap.get("createTime");
            System.out.println("messageId:"+messageId+"  messageData:"+messageData+"  createTime:"+createTime);
            channel.basicAck(deliveryTag, true);
//          channel.basicReject(deliveryTag, true);//为true会重新放回队列
        } catch (Exception e) {
            channel.basicReject(deliveryTag, false);
            e.printStackTrace();
        }
    }

    //{key=value,key=value,key=value} 格式转换成map
   private  MapmapStringToMap(String str){
       str = str.substring(1, str.length() - 1);
       String[] strs = str.split(",");
       Map map = new HashMap();
       for (String string : strs) {
           String key = string.split("=")[0].trim();
           String value = string.split("=")[1];
           System.out.println(key+"*****");
           map.put(key, value);
       }
       return map;
   }
}

然后在将rabbitmq-provider, rabbitmq-consumer俩个项目跑起来，访问下/sendDirectMessage接口往直连型交换机推送一条消息，看看监听到的消息结果：

createTime*****
messageId*****
messageData*****
messageId:81469828-9008-4218-ba6a-29f6d2c0c8c8  messageData:test message. hello!  createTime:2020-03-20 10:00:28

手动的确认模式的投递消息略低于 自动，但是可以弥补自动确认模式的不足，更加准确的去记录消费情况，
那么如果需要有些消息接收类设置自动确认，有些消息接收类设置需要手动确认的话，那么只需要将需要设置手动确认的相关对垒加到之前的MessageListenerConfig的SimpleMessageListenerContainer里就行，
PS: 我这个就是扇形交换机A,B,C里面仅仅对于FanoutReceiverA设置了 手动确认，推送一条消息，情况如下：

createTime*****
messageId*****
messageData*****
messageId:92fd2837-8ebb-43cc-83cf-b84ef78b2451  messageData:message:  woman is all  createTime:2020-03-20 10:19:50
FamoutReceiverB消费者收到消息：{createTime=2020-03-20 10:19:50, messageId=92fd2837-8ebb-43cc-83cf-b84ef78b2451, messageData=message:  woman is all}
FamoutReceiverC消费者收到消息：{createTime=2020-03-20 10:19:50, messageId=92fd2837-8ebb-43cc-83cf-b84ef78b2451, messageData=message:  woman is all}

ok, nice.

你可能感兴趣的:(4,springboot 整合RabbitMq)

  • 底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说 造命者说
    底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说我叫吴起，生于公元前440年的战国初期，正是群雄并起、天下纷争不断的时候。后人说我是军事家、政治家、改革家，是兵家代表人物。评价我一生历仕鲁、魏、楚三国，通晓兵家、法家、儒家三家思想，在内政军事上都有极高的成就。周安王二十一年（公元前381年），因变法得罪守旧贵族，被人乱箭射死。我出生在卫国一个“家累万金”的富有家庭，从年轻时候起就不甘平凡
  • 2020-01-25 晴岚85
    郑海燕坚持分享590天2020.1.24在生活中只存在两个问题。一个问题是：你知道想要达成的目标是什么，但却不知道如何才能达成；另一个问题是：你不知道你的目标是什么。前一个是行动的问题，后一个是结果的问题。通过制定具体的下一步行动，可以解决不知道如何开始行动的问题。而通过去想象结果，对结果做预估，可以解决找不着目标的问题。对于所有吸引我们注意力，想要完成的任务，你可以先想象一下，预期的结果究竟是什
  • 谢谢你们，爱你们！ 鹿游儿
    昨天家人去泡温泉，二个孩子也带着去，出发前一晚，匆匆下班，赶回家和孩子一起收拾。饭后，我拿出笔和本子（上次去澳门时做手帐的本子）写下了1\2\3\4\5\6\7\8\9,让后让小壹去思考，带什么出发去旅游呢？她在对应的数字旁边画上了，泳衣、泳圈、肖恩、内衣内裤、tapuy、拖鞋……画完后，就让她自己对着这个本子，将要带的，一一带上，没想到这次带的书还是这本《便便工厂》(晚上姑婆发照片过来，妹妹累得
  • 《投行人生》读书笔记 小蘑菇的树洞
    《投行人生》----作者詹姆斯-A-朗德摩根斯坦利副主席40年的职业洞见-很短小精悍的篇幅，比较适合初入职场的新人。第一部分成功的职业生涯需要规划1.情商归为适应能力分享与协作同理心适应能力，更多的是自我意识，你有能力识别自己的情并分辨这些情绪如何影响你的思想和行为。2.对于初入职场的人的建议，细节，截止日期和数据很重要截止日期，一种有效的方法是请老板为你所有的任务进行优先级排序。和老板喝咖啡的好
  • Long类型前后端数据不一致 igotyback 前端
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
  • 绘本讲师训练营【24期】8/21阅读原创《独生小孩》 1784e22615e0
    24016-孟娟《独生小孩》图片发自App今天我想分享一个蛮特别的绘本，讲的是一个特殊的群体，我也是属于这个群体，80后的独生小孩。这是一本中国绘本，作者郭婧，也是一个80厚。全书一百多页，均为铅笔绘制，虽然为黑白色调，但并不显得沉闷。全书没有文字，犹如“默片”，但并不影响读者对该作品的理解，反而显得神秘，梦幻，給读者留下想象的空间。作者在前蝴蝶页这样写到：“我更希望父母和孩子一起分享这本书，使他
  • 消息中间件有哪些常见类型 xmh-sxh-1314 java
    消息中间件根据其设计理念和用途，可以大致分为以下几种常见类型：点对点消息队列（Point-to-PointMessagingQueues）：在这种模型中，消息被发送到特定的队列中，消费者从队列中取出并处理消息。队列中的消息只能被一个消费者消费，消费后即被删除。常见的实现包括IBM的MQSeries、RabbitMQ的部分使用场景等。适用于任务分发、负载均衡等场景。发布/订阅消息模型（Pub/Sub
  • 高级编程--XML+socket练习题 masa010 java开发语言
    1.北京华北2114.8万人上海华东2,500万人广州华南1292.68万人成都华西1417万人（1）使用dom4j将信息存入xml中（2）读取信息，并打印控制台（3）添加一个city节点与子节点（4）使用socketTCP协议编写服务端与客户端，客户端输入城市ID，服务器响应相应城市信息（5）使用socketTCP协议编写服务端与客户端，客户端要求用户输入city对象，服务端接收并使用dom4j
  • 本周第二次约练 2cfbdfe28a51
    中原焦点团队中24初26刘霞2021.12.3约练161次，分享第368天当事人虽然是带着问题来的，但是咨询过程中发现，她是经过自己不断地调整和努力才走到现在的，看到当事人的不容易，找到例外，发现资源，力量感也就随之而来。增强画面感，或者说重温，会给当事人带来更深刻的感受。
  • 今日联对0306 诗图佳得
    自对联：烟销皓月临江浒，水漫金山荡塔裙。一一肖士平2020.3.6.1、试对肖老师联：烟销皓月临江浒，夜笼寒沙梦晚舟。耀哥求正2、试对萧老师联:烟销浩月临江浒，雾散乾坤解汉城。秀霞习作请各位老师校正3、自对联：烟销皓月临江浒，水漫金山荡塔裙。一一肖士平2020.3.6.4、试对肖老师垫场联：烟销皓月临江浒，雾锁寒林缈葉丛。小智求正[抱拳]5、试对肖老师联：烟销皓月临江浒；风卷乱云入峰巅。一一五品6
  • 2022-07-08 保利学府里李楚怡1307022
    ——保利碧桂园学府里——童梦奇趣【科学实验室】「7.9-7.10」✏玩出大智慧约99-144㎡二期全新升级力作
  • 2022-04-18 Apbenz
    语重心长的和我说，不要老是说不行，人至而立之年危机四伏，内在的，外在的，感觉就是心力憔悴，让人无所适从。面对职场的无情，突然好羡慕干体力劳动的外卖小哥。难道命运是想让我去送外卖了吗？干体力活才能让我活下去？fastadmin打卡成功,淘宝金币任务完成。ㅏㅓㅗㅜㅡㅣㅐㅔㅑㅕㅛㅠㅢㅒㅖY行。야자여자요리우유의사얘기예
  • 每日一题——第八十二题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：将一个控制台输入的字符串中的所有元音字母复制到另一字符串中#include#include#include#include#defineMAX_INPUT1024boolisVowel(charp);intmain(){charinput[MAX_INPUT];charoutput[MAX_INPUT];printf("请输入一串字符串：\n");fgets(input,sizeof(inp
  • 每日一题——第八十三题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：将输入的整形数字输出,输出1990，输出"1990"#include#defineMAX_INPUT1024intmain(){intarrr_num[MAX_INPUT];intnum,i=0;printf("请输入一个数字：");scanf_s("%d",&num);while(num!=0){arrr_num[i++]=num%10;num/=10;}printf("\"");for(
  • Python中os.environ基本介绍及使用方法 鹤冲天Pro #Pythonpython服务器开发语言
    文章目录python中os.environos.environ简介os.environ进行环境变量的增删改查python中os.environ的使用详解1.简介2.key字段详解2.1常见key字段3.os.environ.get()用法4.环境变量的增删改查和判断是否存在4.1新增环境变量4.2更新环境变量4.3获取环境变量4.4删除环境变量4.5判断环境变量是否存在python中os.envi
  • 第四天旅游线路预览——从换乘中心到喀纳斯湖 陟彼高冈yu 基于Googleearthstudio的旅游规划和预览旅游
    第四天：从贾登峪到喀纳斯风景区入口，晚上住宿贾登峪；换乘中心有4路车，喀纳斯①号车，去喀纳斯湖，路程时长约5分钟；将上面的的行程安排进行动态展示，具体步骤见”Googleearthstudio进行动态轨迹显示制作过程“、“Googleearthstudio入门教程”和“Googleearthstudio进阶教程“相关内容，得到行程如下所示：Day4-2-480p
  • linux sdl windows.h,Windows下的SDL安装 奔跑吧linux内核 linuxsdlwindows.h
    首先你要下载并安装SDL开发包。如果装在C盘下，路径为C:\SDL1.2.5如果在WINDOWS下。你可以按以下步骤：1.打开VC++，点击"Tools",Options2,点击directories选项3.选择"Includefiles"增加一个新的路径。"C:\SDL1.2.5\include"4，现在选择"Libaryfiles“增加"C:\SDL1.2.5\lib"现在你可以开始编写你的第
  • Goolge earth studio 进阶4——路径修改与平滑 陟彼高冈yu Googleearthstudio进阶教程旅游
    如果我们希望在大约中途时获得更多的城市鸟瞰视角。可以将相机拖动到这里并创建一个新的关键帧。camera_target_clip_7EarthStudio会自动平滑我们的路径，所以当我们通过这个关键帧时，不是一个生硬的角度，而是一个平滑的曲线。camera_target_clip_8路径上有贝塞尔控制手柄，允许我们调整路径的形状。右键单击，我们可以选择“平滑路径”，这是默认的自动平滑算法，或者我们可
  • Python教程：一文了解使用Python处理XPath 旦莫 Python进阶python开发语言
    目录1.环境准备1.1安装lxml1.2验证安装2.XPath基础2.1什么是XPath？2.2XPath语法2.3示例XML文档3.使用lxml解析XML3.1解析XML文档3.2查看解析结果4.XPath查询4.1基本路径查询4.2使用属性查询4.3查询多个节点5.XPath的高级用法5.1使用逻辑运算符5.2使用函数6.实战案例6.1从网页抓取数据6.1.1安装Requests库6.1.2代
  • 相信相信的力量 孙丽_cdb3
    孙丽中级十期坚持分享第345天有一个特别有哲理的故事：有一只老鹰下了蛋，这个蛋，不知怎的就滚到了鸡窝里去了，鸡也下了一窝蛋，然后鸡妈妈把这些蛋全都浮出来了，孵出来之后等小鸡长大一点了，就觉得鹰蛋孵出来的那只小鹰怪模怪样，这些小鸡都嘲笑它，真难看，真笨，丑死了，那只小鹰觉得自己真是谁也不像，真是不好看，后来鸡妈妈也不喜欢他，我怎么生出你这样的孩子来了？真烦人，后来这群小鸡和小鹰一起生活，有一天，老鹰
  • 基于社交网络算法优化的二维最大熵图像分割 智能算法研学社（Jack旭） 智能优化算法应用图像分割算法php开发语言
    智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码文章目录智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码1.前言2.二维最大熵阈值分割原理3.基于社交网络优化的多阈值分割4.算法结果：5.参考文献：6.Matlab代码摘要：本文介绍基于最大熵的图像分割，并且应用社交网络算法进行阈值寻优。1.前言阅读此文章前，请阅读《图像分割：直方图区域划分及信息统计介绍》htt
  • 509. 斐波那契数(每日一题) lzyprime
    lzyprime博客(github)创建时间：2021.01.04qq及邮箱：2383518170leetcode笔记题目描述斐波那契数，通常用F(n)表示，形成的序列称为斐波那契数列。该数列由0和1开始，后面的每一项数字都是前面两项数字的和。也就是：F(0)=0，F(1)=1F(n)=F(n-1)+F(n-2)，其中n>1给你n，请计算F(n)。示例1：输入：2输出：1解释：F(2)=F(1)+
  • 郎朗大婚娶公主：所有光环的背后，都是十年如一日的自律 简小尘
    近日，关于郎朗大婚的新闻上了热搜，看了新娘的照片，既有天使般的面容，更有魔鬼般的身材，关键是人家还身世好，又有才华，这真的是让所有男人羡慕嫉妒恨哪。有些人不禁会想，“凭什么郎朗的人生就象开挂了一样，可我却每天都活得这么狼狈！”其实，每个开挂的人生背后，都是苦行僧般的自律。01欲戴王冠，必承其重。练琴不能只靠兴趣，更需要自律！我们先来看一下朗朗在小时候的作息时间表：早晨5:45起床，练琴1小时。中午
  • 《中华小厨师》单行VS爱藏：姜是老的辣，书是新的好 cicoky
    《汉书·郦食其传》有曰：“王者以民为天，而民以食为天。”自古以来，吃饱饭是每一个人的基本要求，而吃好饭却是每一个人的最终追求。于是，厨师这一职业孕育而生，其渊源之久，甚至可追溯到4000年前的奴隶时代。职业本身无贵贱，但职业能力却有高低之分。所以一家餐馆生意好不好，厨师的水平决定一切，而站在所有厨师顶端的就被称之为“特级厨师”。今天要说的就是一个关于“特级厨师刘昴星”的故事。连载历程1995年第4
  • 2023-04-17|篮球女孩 长一木
    1小学抑或初中阶段，在课外书了解到她的故事。“篮球女孩”。当时佩服她的顽强，也对生命多了一丝敬畏。今天刚好在公众号看到，长大后的“篮球女孩”。佩服之余又满是心疼。网络侵删祝那素未蒙面的女孩，未来一切顺遂。
  • 2020-04-12每天三百字之连接与替代 冷眼看潮
    不知道是不是好为人师，有时候还真想和别人分享一下我对某些现象的看法或者解释。人类社会不断发展进步的过程，就是不断连接与替代的过程。人类发现了火并应用火以后，告别了茹毛饮血的野兽般的原始生活（火烧、烹饪替代了生食）人类用石器代替了完全手工，工具的使用使人类进步一大步。类似这样的替代还有很多，随着科技的发展，有更多的原始的事物被替代，代之以更高效、更先进的技术。在近现代，汽车替代了马车，高速公路和铁路
  • 数组去重 好奇的猫猫猫
    整理自js中基础数据结构数组去重问题思考？如何去除数组中重复的项例如数组：[1,3,4,3,5]我们在做去重的时候，一开始想到的肯定是，逐个比较，外面一层循环，内层后一个与前一个一比较，如果是久不将当前这一项放进新的数组，挨个比较完之后返回一个新的去过重复的数组不好的实践方式上述方法效率极低，代码量还多，思考？有没有更好的方法这时候不禁一想当然有了！！！hashtable啊，通过对象的hash办法
  • 春季养肝正当时 dxn悟
    重温快乐2023年2月4日立春。春天来了，春暖花开，小鸟欢唱，那在这样的季节我们如何养肝呢？自然界的春季对应中医五行的木，人体五脏肝属木，“木曰曲直”，是以树干曲曲直直地向上、向外伸长舒展的生发姿态，来形容具有生长、升发、条达、舒畅等特征的食物及现象。根据中医天人相应的理念，肝五行属木，喜条达，主疏泄，与春天相应，所以春天最适合养肝。养肝首先要少生气，因为肝喜条达恶抑郁。人体五志肝为怒，生气发怒最
  • log4j配置 yy爱yy
    #log4j.rootLogger配置的是大于等于当前级别的日志信息的输出#log4j.rootLogger用法:（注意appenderName可以是一个或多个）#log4j.rootLogger=日志级别,appenderName1,appenderName2,....#log4j.appender.appenderName2定义的是日志的输出方式，有两种：一种是命令行输出或者叫控制台输出，另一
  • 121. 买卖股票的最佳时机 薄荷糖的味道_fb40
    给定一个数组，它的第i个元素是一支给定股票第i天的价格。如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。注意你不能在买入股票前卖出股票。示例1:输入:[7,1,5,3,6,4]输出:5解释:在第2天（股票价格=1）的时候买入，在第5天（股票价格=6）的时候卖出，最大利润=6-1=5。注意利润不能是7-1=6,因为卖出价格需要大于买入价格。示例2:输入:
  • 312个免费高速HTTP代理IP（能隐藏自己真实IP地址） yangshangchuan 高速免费superwordHTTP代理
        124.88.67.20:843 190.36.223.93:8080 117.147.221.38:8123 122.228.92.103:3128 183.247.211.159:8123 124.88.67.35:81 112.18.51.167:8123 218.28.96.39:3128 49.94.160.198:3128 183.20
  • pull解析和json编码 百合不是茶 androidpull解析json
    n.json文件: [{name:java,lan:c++,age:17},{name:android,lan:java,age:8}]   pull.xml文件 <?xml version="1.0" encoding="utf-8"?> <stu>     <name>java
  • [能源与矿产]石油与地球生态系统 comsci 能源
          按照苏联的科学界的说法,石油并非是远古的生物残骸的演变产物,而是一种可以由某些特殊地质结构和物理条件生产出来的东西,也就是说,石油是可以自增长的....       那么我们做一个猜想: 石油好像是地球的体液,我们地球具有自动产生石油的某种机制,只要我们不过量开采石油,并保护好
  • 类与对象浅谈 沐刃青蛟 java基础
           类，字面理解，便是同一种事物的总称，比如人类，是对世界上所有人的一个总称。而对象，便是类的具体化，实例化，是一个具体事物，比如张飞这个人，就是人类的一个对象。但要注意的是：张飞这个人是对象，而不是张飞，张飞只是他这个人的名字，是他的属性而已。而一个类中包含了属性和方法这两兄弟，他们分别用来描述对象的行为和性质（感觉应该是
  • 新站开始被收录后，我们应该做什么？ IT独行者 PHPseo
    新站开始被收录后，我们应该做什么？         百度终于开始收录自己的网站了，作为站长，你是不是觉得那一刻很有成就感呢，同时，你是不是又很茫然，不知道下一步该做什么了？至少我当初就是这样，在这里和大家一份分享一下新站收录后，我们要做哪些工作。       至于如何让百度快速收录自己的网站，可以参考我之前的帖子《新站让百
  • oracle 连接碰到的问题 文强chu oracle
    Unable to find a java Virtual Machine－－安装64位版Oracle11gR2后无法启动SQLDeveloper的解决方案 作者：草根IT网 来源：未知 人气：813标签： 导读：安装64位版Oracle11gR2后发现启动SQLDeveloper时弹出配置java.exe的路径，找到Oracle自带java.exe后产生的路径“C:\app\用户名\prod
  • Swing中按ctrl键同时移动鼠标拖动组件（类中多借口共享同一数据） 小桔子 java继承swing接口监听
            都知道java中类只能单继承，但可以实现多个接口，但我发现实现多个接口之后，多个接口却不能共享同一个数据，应用开发中想实现：当用户按着ctrl键时，可以用鼠标点击拖动组件，比如说文本框。 编写一个监听实现KeyListener,NouseListener,MouseMotionListener三个接口，重写方法。定义一个全局变量boolea
  • linux常用的命令 aichenglong linux常用命令
    1 startx切换到图形化界面 2 man命令:查看帮助信息 man 需要查看的命令,man命令提供了大量的帮助信息,一般可以分成4个部分 name:对命令的简单说明 synopsis:命令的使用格式说明 description:命令的详细说明信息 options:命令的各项说明 3 date:显示时间 语法：date [OPTION]... [+FORMAT]
  • eclipse内存优化 AILIKES javaeclipsejvmjdk
    一 基本说明      在JVM中，总体上分2块内存区,默认空余堆内存小于 40%时，JVM就会增大堆直到-Xmx的最大限制；空余堆内存大于70%时，JVM会减少堆直到-Xms的最小限制。     1)堆内存(Heap memory):堆是运行时数据区域，所有类实例和数组的内存均从此处分配,是Java代码可及的内存，是留给开发人
  • 关键字的使用探讨 百合不是茶 关键字
    //关键字的使用探讨/*访问关键词private 只能在本类中访问public 只能在本工程中访问protected 只能在包中和子类中访问默认的 只能在包中访问*//*final   类 方法 变量 final 类 不能被继承 final 方法 不能被子类覆盖，但可以继承 final 变量 只能有一次赋值，赋值后不能改变 final 不能用来修饰构造方法*///this()
  • JS中定义对象的几种方式 bijian1013 js
        1. 基于已有对象扩充其对象和方法(只适合于临时的生成一个对象)： <html> <head> <title>基于已有对象扩充其对象和方法(只适合于临时的生成一个对象)</title> </head> <script> var obj = new Object();
  • 表驱动法实例 bijian1013 java表驱动法TDD
    获得月的天数是典型的直接访问驱动表方式的实例，下面我们来展示一下： MonthDaysTest.java package com.study.test; import org.junit.Assert; import org.junit.Test; import com.study.MonthDays; public class MonthDaysTest { @T
  • LInux启停重启常用服务器的脚本 bit1129 linux
    启动，停止和重启常用服务器的Bash脚本，对于每个服务器，需要根据实际的安装路径做相应的修改   #! /bin/bash Servers=(Apache2, Nginx, Resin, Tomcat, Couchbase, SVN, ActiveMQ, Mongo); Ops=(Start, Stop, Restart); currentDir=$(pwd); echo
  • 【HBase六】REST操作HBase bit1129 hbase
    HBase提供了REST风格的服务方便查看HBase集群的信息，以及执行增删改查操作   1. 启动和停止HBase REST 服务 1.1 启动REST服务 前台启动（默认端口号8080） [hadoop@hadoop bin]$ ./hbase rest start   后台启动 hbase-daemon.sh start rest   启动时指定
  • 大话zabbix 3.0设计假设 ronin47
    What’s new in Zabbix 2.0? 去年开始使用Zabbix的时候，是1.8.X的版本，今年Zabbix已经跨入了2.0的时代。看了2.0的release notes，和performance相关的有下面几个：          :: Performance improvements::Trigger related da
  • http错误码大全 byalias http协议javaweb
    响应码由三位十进制数字组成，它们出现在由HTTP服务器发送的响应的第一行。 响应码分五种类型，由它们的第一位数字表示： 1）1xx：信息，请求收到，继续处理 2）2xx：成功，行为被成功地接受、理解和采纳 3）3xx：重定向，为了完成请求，必须进一步执行的动作 4）4xx：客户端错误，请求包含语法错误或者请求无法实现 5）5xx：服务器错误，服务器不能实现一种明显无效的请求
  • J2EE设计模式-Intercepting Filter bylijinnan java设计模式数据结构
    Intercepting Filter类似于职责链模式 有两种实现 其中一种是Filter之间没有联系，全部Filter都存放在FilterChain中，由FilterChain来有序或无序地把把所有Filter调用一遍。没有用到链表这种数据结构。示例如下： package com.ljn.filter.custom; import java.util.ArrayList;
  • 修改jboss端口 chicony jboss
    修改jboss端口   %JBOSS_HOME%\server\{服务实例名}\conf\bindingservice.beans\META-INF\bindings-jboss-beans.xml   中找到 <!-- The ports-default bindings are obtained by taking the base bindin
  • c++ 用类模版实现数组类 CrazyMizzz C++
    最近c++学到数组类，写了代码将他实现，基本具有vector类的功能 #include<iostream> #include<string> #include<cassert> using namespace std; template<class T> class Array { public: //构造函数
  • hadoop dfs.datanode.du.reserved 预留空间配置方法 daizj hadoop预留空间
    对于datanode配置预留空间的方法 为：在hdfs-site.xml添加如下配置  <property>     <name>dfs.datanode.du.reserved</name>     <value>10737418240</value>    
  • mysql远程访问的设置 dcj3sjt126com mysql防火墙
    第一步: 激活网络设置 你需要编辑mysql配置文件my.cnf. 通常状况，my.cnf放置于在以下目录： /etc/mysql/my.cnf (Debian linux) /etc/my.cnf （Red Hat Linux/Fedora Linux) /var/db/mysql/my.cnf (FreeBSD) 然后用vi编辑my.cnf，修改内容从以下行： [mysqld] 你所需要: 1
  • ios 使用特定的popToViewController返回到相应的Controller dcj3sjt126com controller
    1、取navigationCtroller中的Controllers NSArray * ctrlArray = self.navigationController.viewControllers; 2、取出后，执行， [self.navigationController popToViewController:[ctrlArray objectAtIndex:0] animated:YES
  • Linux正则表达式和通配符的区别 eksliang 正则表达式通配符和正则表达式的区别通配符
    转载请出自出处：http://eksliang.iteye.com/blog/1976579 首先得明白二者是截然不同的 通配符只能用在shell命令中,用来处理字符串的的匹配。 判断一个命令是否为bash shell(linux 默认的shell)的内置命令 type -t commad 返回结果含义 file  表示为外部命令 alias  表示该
  • Ubuntu Mysql Install and CONF gengzg Install
    http://www.navicat.com.cn/download/navicat-for-mysql Step1: 下载Navicat ，网址：http://www.navicat.com/en/download/download.html Step2：进入下载目录，解压压缩包：tar -zxvf navicat11_mysql_en.tar.gz
  • 批处理，删除文件bat huqiji windowsdos
    @echo off ::演示：删除指定路径下指定天数之前（以文件名中包含的日期字符串为准）的文件。 ::如果演示结果无误，把del前面的echo去掉，即可实现真正删除。 ::本例假设文件名中包含的日期字符串（比如：bak-2009-12-25.log） rem 指定待删除文件的存放路径 set SrcDir=C:/Test/BatHome rem 指定天数 set DaysAgo=1
  • 跨浏览器兼容的HTML5视频音频播放器 天梯梦 html5
    HTML5的video和audio标签是用来在网页中加入视频和音频的标签，在支持html5的浏览器中不需要预先加载Adobe Flash浏览器插件就能轻松快速的播放视频和音频文件。而html5media.js可以在不支持html5的浏览器上使video和audio标签生效。   How to enable <video> and <audio> tags in
  • Bundle自定义数据传递 hm4123660 androidSerializable自定义数据传递BundleParcelable
          我们都知道Bundle可能过put****()方法添加各种基本类型的数据，Intent也可以通过putExtras(Bundle)将数据添加进去，然后通过startActivity()跳到下一下Activity的时候就把数据也传到下一个Activity了。如传递一个字符串到下一个Activity   把数据放到Intent
  • C＃：异步编程和线程的使用（.NET 4.5 ） powertoolsteam .net线程C#异步编程
    异步编程和线程处理是并发或并行编程非常重要的功能特征。为了实现异步编程，可使用线程也可以不用。将异步与线程同时讲，将有助于我们更好的理解它们的特征。 本文中涉及关键知识点 1. 异步编程 2. 线程的使用 3. 基于任务的异步模式 4. 并行编程 5. 总结 异步编程 什么是异步操作？异步操作是指某些操作能够独立运行，不依赖主流程或主其他处理流程。通常情况下，C＃程序
  • spark 查看 job history 日志 Stark_Summer 日志sparkhistoryjob
    SPARK_HOME/conf 下: spark-defaults.conf 增加如下内容 spark.eventLog.enabled true spark.eventLog.dir hdfs://master:8020/var/log/spark spark.eventLog.compress true spark-env.sh 增加如下内容 export SP
  • SSH框架搭建 wangxiukai2015eye springHibernatestruts
    MyEclipse搭建SSH框架 Struts Spring Hibernate 1、new一个web project。 2、右键项目，为项目添加Struts支持。    选择Struts2 Core Libraries -<MyEclipes-Library>      点击Finish。src目录下多了struts
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他