2. 程式人生 > >rabbitmq介紹及rabbitmq在java中基礎使用

rabbitmq介紹及rabbitmq在java中基礎使用

阿新 • • 發佈：2018-12-30
RabbitMQ簡介
RabbitMQ是一個在AMQP基礎上完整的，可複用的企業訊息系統。它可以用於大型軟體系統各個模組之間的高效通訊，支援高併發，支援可擴充套件。使用Erlang語言編寫。

RabbitMQ相關術語：
          1.Broker：簡單來說就是訊息佇列伺服器實體。
          2.Exchange：訊息交換機，它指定訊息按什麼規則，路由到哪個佇列。
          3.Queue：訊息佇列載體，每個訊息都會被投入到一個或多個佇列。
          4.Binding：繫結，它的作用就是把exchange和queue按照路由規則繫結起來。
          5.Routing Key：路由關鍵字，exchange根據這個關鍵字進行訊息投遞。
          6.vhost：虛擬主機，一個broker裡可以開設多個vhost，用作不同使用者的許可權分離。
          7.producer：訊息生產者，就是投遞訊息的程式。
          8.consumer：訊息消費者，就是接受訊息的程式。
          9.channel：訊息通道，在客戶端的每個連線裡，可建立多個channel，每個channel代表一個會話任務。


RabbitMQ常用釋出訂閱模式的執行流程：
AMQP模型中，訊息在producer中產生，傳送到MQ的exchange上，exchange根據配置的路由方式發到相應的Queue上，Queue又將訊息傳送給consumer，訊息從queue到consumer有push和pull兩種方式。 訊息佇列的使用過程大概如下：

          1.客戶端連線到訊息佇列伺服器，開啟一個channel。
          2.客戶端宣告一個exchange，並設定相關屬性。
          3.客戶端宣告一個queue，並設定相關屬性。
          4.客戶端使用routing key，在exchange和queue之間建立好繫結關係。
          5.客戶端投遞訊息到exchange。

exchange接收到訊息後，就根據訊息的key和已經設定的binding，進行訊息路由，將訊息投遞到一個或多個佇列裡。 exchange也有幾個型別，下面會有介紹。


RabbitMQ教程：

引入maven依賴:

<dependency>
	<groupId>com.rabbitmq</groupId>
	<artifactId>amqp-client</artifactId>
	<version>3.6.5</version>
</dependency>

1.hello world！

生產者:

package com.rabbitmq.test.T_helloworld;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.test.util.ConnectionUtil;

/**
 * helloworld
 * @author lenovo
 *
 */
public class Producer {

	private final static String QUEUE_NAME = "test_queue";

    public static void main(String[] argv) throws Exception {
        // 獲取到連線以及mq通道
        Connection connection = ConnectionUtil.getConnection();
        // 從連線中建立通道
        Channel channel = connection.createChannel();

        /*
         * 宣告（建立）佇列
         * 引數1：佇列名稱
         * 引數2：為true時server重啟佇列不會消失
         * 引數3：佇列是否是獨佔的，如果為true只能被一個connection使用，其他連線建立時會丟擲異常
         * 引數4：佇列不再使用時是否自動刪除（沒有連線，並且沒有未處理的訊息)
         * 引數5：建立佇列時的其他引數
         */
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        // 訊息內容
        String message = "Hello World!";
        /*
         * 向server釋出一條訊息
         * 引數1：exchange名字，若為空則使用預設的exchange
         * 引數2：routing key
         * 引數3：其他的屬性
         * 引數4：訊息體
         * RabbitMQ預設有一個exchange，叫default exchange，它用一個空字串表示，它是direct exchange型別，
         * 任何發往這個exchange的訊息都會被路由到routing key的名字對應的佇列上，如果沒有對應的佇列，則訊息會被丟棄
         */
        channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
        System.out.println(" [生產者] Sent '" + message + "'");

        //關閉通道和連線
        channel.close();
        connection.close();
    }
}
消費者: 
package com.rabbitmq.test.T_helloworld;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.QueueingConsumer;
import com.rabbitmq.test.util.ConnectionUtil;

public class Consumer {

	private final static String QUEUE_NAME = "test_queue";

    public static void main(String[] argv) throws Exception {

        // 獲取到連線以及mq通道
        Connection connection = ConnectionUtil.getConnection();
        // 從連線中建立通道
        Channel channel = connection.createChannel();

        // 宣告佇列(如果你已經明確的知道有這個佇列,那麼下面這句程式碼可以註釋掉,如果不註釋掉的話,也可以理解為消費者必須監聽一個佇列,如果沒有就建立一個)
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        // 定義佇列的消費者
        QueueingConsumer consumer = new QueueingConsumer(channel);
       /*
         * 監聽佇列
         * 引數1:佇列名稱
         * 引數2：是否傳送ack包，不傳送ack訊息會持續在服務端儲存，直到收到ack。  可以通過channel.basicAck手動回覆ack
         * 引數3：消費者
         */ 
        channel.basicConsume(QUEUE_NAME, true, consumer);

        // 獲取訊息
        while (true) {
            QueueingConsumer.Delivery delivery = consumer.nextDelivery();
            String message = new String(delivery.getBody());
            System.out.println(" [消費者] Received '" + message + "'");
        }
    }
}
2.Work模式
Work普通模式

生產者:

package com.rabbitmq.test.T_work;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.test.util.ConnectionUtil;

/**
 * work模式
 * @author lenovo
 *
 */
public class Producer {

	private final static String QUEUE_NAME = "test_queue_work";

    public static void main(String[] argv) throws Exception {
        // 獲取到連線以及mq通道
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();

        // 宣告佇列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        for (int i = 0; i < 50; i++) {
            // 訊息內容
            String message = "" + i;
            channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
            System.out.println(" [生產者] Sent '" + message + "'");
            //傳送的訊息間隔越來越長
            Thread.sleep(i * 10);
        }

        channel.close();
        connection.close();
    }
}
消費者1: 
package com.rabbitmq.test.T_work;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.QueueingConsumer;
import com.rabbitmq.test.util.ConnectionUtil;

public class Consumer1 {

	private final static String QUEUE_NAME = "test_queue_work";

    public static void main(String[] argv) throws Exception {

        // 獲取到連線以及mq通道
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();

        // 宣告佇列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        
        // 同一時刻伺服器只會發一條訊息給消費者(能者多勞模式)
        //channel.basicQos(1);

        // 定義佇列的消費者
        QueueingConsumer consumer = new QueueingConsumer(channel);
        /*
         * 監聽佇列，不自動返回ack包,下面手動返回
         * 如果不回覆，訊息不會在伺服器刪除
         */ 
        channel.basicConsume(QUEUE_NAME, false, consumer);

        // 獲取訊息
        while (true) {
            QueueingConsumer.Delivery delivery = consumer.nextDelivery();
            String message = new String(delivery.getBody());
            System.out.println(" [消費者1] Received '" + message + "'");
            //休眠
            Thread.sleep(10);
            // 手動返回ack包確認狀態
            channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
          //channel.basicReject(); channel.basicNack(); //可以通過這兩個函式拒絕訊息，可以指定訊息在伺服器刪除還是繼續投遞給其他消費者
        }
    }
}
消費者2: 
package com.rabbitmq.test.T_work;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.QueueingConsumer;
import com.rabbitmq.test.util.ConnectionUtil;

public class Consumer2 {

	private final static String QUEUE_NAME = "test_queue_work";

    public static void main(String[] argv) throws Exception {

        // 獲取到連線以及mq通道
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();

        // 宣告佇列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        // 同一時刻伺服器只會發一條訊息給消費者(能者多勞模式)
        //channel.basicQos(1);

        // 定義佇列的消費者
        QueueingConsumer consumer = new QueueingConsumer(channel);
        // 監聽佇列，手動返回完成狀態
        channel.basicConsume(QUEUE_NAME, false, consumer);

        // 獲取訊息
        while (true) {
            QueueingConsumer.Delivery delivery = consumer.nextDelivery();
            String message = new String(delivery.getBody());
            System.out.println(" [消費者2] Received '" + message + "'");
            // 休眠1秒
            Thread.sleep(1000);

            //反饋訊息的消費狀態
            channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
        }
    }
}
測試結果：
1、消費者1和消費者2獲取到的訊息內容是不同的，同一個訊息只能被一個消費者獲取。
2、消費者1和消費者2獲取到的訊息的數量是相同的，一個是奇數一個是偶數。

其實，這樣是不合理的，應該是消費者1要比消費者2獲取到的訊息多才對。
Work的能者多勞模式
需要將上面兩個消費者的channel.basicQos(1);這行程式碼的註釋開啟,再次執行會發現,休眠時間短的消費者執行的任務多
訊息的確認
在以上的程式碼中,已經給出了註釋,如何使用自動確認和手動確認,消費者從佇列中獲取訊息，服務端如何知道訊息已經被消費呢？
模式1：自動確認
只要訊息從佇列中獲取，無論消費者獲取到訊息後是否成功訊息，都認為是訊息已經成功消費。
模式2：手動確認
消費者從佇列中獲取訊息後，伺服器會將該訊息標記為不可用狀態，等待消費者的反饋，如果消費者一直沒有反饋，那麼該訊息將一直處於不可用狀態。
如果選用自動確認,在消費者拿走訊息執行過程中出現宕機時,訊息可能就會丟失！！


3.訂閱模式



文章開頭有釋出訂閱的流程介紹

生產者：

package com.rabbitmq.test.T_pubsub;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.test.util.ConnectionUtil;

/**
 * 訂閱模式
 * @author lenovo
 *
 */
public class Producer {

	//交換機的名稱
	private final static String EXCHANGE_NAME = "test_exchange_fanout";

    public static void main(String[] argv) throws Exception {
        // 獲取到連線以及mq通道
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();

        /*
         * 宣告exchange(交換機)
         * 引數1：交換機名稱
         * 引數2：交換機型別
         * 引數3：交換機永續性，如果為true則伺服器重啟時不會丟失
         * 引數4：交換機在不被使用時是否刪除
         * 引數5：交換機的其他屬性
         */
        channel.exchangeDeclare(EXCHANGE_NAME, "fanout",true,true,null);

        // 訊息內容
        String message = "訂閱訊息";
        channel.basicPublish(EXCHANGE_NAME, "", null, message.getBytes());
        System.out.println(" [生產者] Sent '" + message + "'");

        channel.close();
        connection.close();
    }
}
消費者1： 
package com.rabbitmq.test.T_pubsub;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.QueueingConsumer;
import com.rabbitmq.test.util.ConnectionUtil;

public class Consumer1 {

	private final static String QUEUE_NAME = "test_queue_exchange_1";

    private final static String EXCHANGE_NAME = "test_exchange_fanout";

    public static void main(String[] argv) throws Exception {

        // 獲取到連線以及mq通道
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();

        // 宣告佇列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        
        /*
         * 繫結佇列到交換機(這個交換機的名稱一定要和上面的生產者交換機名稱相同)
         * 引數1：佇列的名稱
         * 引數2：交換機的名稱
         * 引數3：Routing Key
         * 
         */
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "");

        // 同一時刻伺服器只會發一條訊息給消費者
        channel.basicQos(1);

        // 定義佇列的消費者
        QueueingConsumer consumer = new QueueingConsumer(channel);
        // 監聽佇列，手動返回完成
        channel.basicConsume(QUEUE_NAME, false, consumer);

        // 獲取訊息
        while (true) {
            QueueingConsumer.Delivery delivery = consumer.nextDelivery();
            String message = new String(delivery.getBody());
            System.out.println(" [消費者1] Received '" + message + "'");
            Thread.sleep(10);
            
            channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
        }
    }
}
消費者2： 
package com.rabbitmq.test.T_pubsub;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.QueueingConsumer;
import com.rabbitmq.test.util.ConnectionUtil;

public class Consumer2 {

	private final static String QUEUE_NAME = "test_queue_exchange_2";

    private final static String EXCHANGE_NAME = "test_exchange_fanout";

    public static void main(String[] argv) throws Exception {

        // 獲取到連線以及mq通道
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();

        // 宣告佇列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        // 繫結佇列到交換機
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "");

        // 同一時刻伺服器只會發一條訊息給消費者
        channel.basicQos(1);

        // 定義佇列的消費者
        QueueingConsumer consumer = new QueueingConsumer(channel);
        // 監聽佇列，手動返回完成
        channel.basicConsume(QUEUE_NAME, false, consumer);

        // 獲取訊息
        while (true) {
            QueueingConsumer.Delivery delivery = consumer.nextDelivery();
            String message = new String(delivery.getBody());
            System.out.println(" [消費者2] Received '" + message + "'");
            Thread.sleep(10);

            channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
        }
    }
}

注意：訊息傳送到沒有佇列繫結的交換機時，訊息將丟失，因為，交換機沒有儲存訊息的能力，訊息只能存在在佇列中。


Exchange型別
Direct 、Fanout 、Topic  三種類型，RabbitMQ預設有一個exchange，叫default exchange，它用一個空字串表示，它是direct exchange型別。



下面介紹的路由模式和萬用字元模式都是屬於訂閱模式,只不過加入了Routing Key(路由鍵,文章開頭有介紹)。

3.1路由模式



生產者：

package com.rabbitmq.test.T_routing;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.test.util.ConnectionUtil;

/**
 * 路由模式
 * @author lenovo
 *
 */
public class Producer {

	private final static String EXCHANGE_NAME = "test_exchange_direct";

    public static void main(String[] argv) throws Exception {
        // 獲取到連線以及mq通道
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();

        // 宣告exchange
        channel.exchangeDeclare(EXCHANGE_NAME, "direct");

        // 訊息內容
        String message = "這是訊息B";
        channel.basicPublish(EXCHANGE_NAME, "B", null, message.getBytes());
        System.out.println(" [生產者] Sent '" + message + "'");

        channel.close();
        connection.close();
    }
}
消費者1： 
package com.rabbitmq.test.T_routing;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.QueueingConsumer;
import com.rabbitmq.test.util.ConnectionUtil;

public class Consumer1 {

	private final static String QUEUE_NAME = "test_queue_direct_1";

    private final static String EXCHANGE_NAME = "test_exchange_direct";

    public static void main(String[] argv) throws Exception {

        // 獲取到連線以及mq通道
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();

        // 宣告佇列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        /*
         * 繫結佇列到交換機
         * 引數1：佇列的名稱
         * 引數2：交換機的名稱
         * 引數3：routingKey
         */
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "A");

        // 同一時刻伺服器只會發一條訊息給消費者
        channel.basicQos(1);

        // 定義佇列的消費者
        QueueingConsumer consumer = new QueueingConsumer(channel);
        // 監聽佇列，手動返回完成
        channel.basicConsume(QUEUE_NAME, false, consumer);

        // 獲取訊息
        while (true) {
            QueueingConsumer.Delivery delivery = consumer.nextDelivery();
            String message = new String(delivery.getBody());
            System.out.println(" [消費者1] Received '" + message + "'");
            Thread.sleep(10);

            channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
        }
    }
}
消費者2： 
package com.rabbitmq.test.T_routing;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.QueueingConsumer;
import com.rabbitmq.test.util.ConnectionUtil;

public class Consumer2 {

	private final static String QUEUE_NAME = "test_queue_direct_2";

    private final static String EXCHANGE_NAME = "test_exchange_direct";

    public static void main(String[] argv) throws Exception {

        // 獲取到連線以及mq通道
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();

        // 宣告佇列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        // 繫結佇列到交換機
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "B");
        //如果想讓消費者2同時接受routingKey為A 和為B的訊息,只要在下面在此新增一個Bing就可以了
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "A");

        // 同一時刻伺服器只會發一條訊息給消費者
        channel.basicQos(1);

        // 定義佇列的消費者
        QueueingConsumer consumer = new QueueingConsumer(channel);
        // 監聽佇列，手動返回完成
        channel.basicConsume(QUEUE_NAME, false, consumer);

        // 獲取訊息
        while (true) {
            QueueingConsumer.Delivery delivery = consumer.nextDelivery();
            String message = new String(delivery.getBody());
            System.out.println(" [消費者2] Received '" + message + "'");
            Thread.sleep(10);

            channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
        }
    }
}

3.2萬用字元模式
將路由鍵和某模式進行匹配。此時佇列需要繫結要一個模式上。符號“#”匹配一個或多個詞，符號“*”只能匹配一個詞。因此“audit.#”能夠匹配到“audit.irs”和“audit.irs.corporate”，但是“audit.*” 只會匹配到“audit.irs”。


生產者：

package com.rabbitmq.test.T_topic;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.test.util.ConnectionUtil;

/**
 * 通配模式
 * @author lenovo
 *
 */
public class Producer {

	private final static String EXCHANGE_NAME = "test_exchange_topic";

    public static void main(String[] argv) throws Exception {
        // 獲取到連線以及mq通道
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();

        // 宣告exchange
        channel.exchangeDeclare(EXCHANGE_NAME, "topic");

        // 訊息內容  模擬 有人購物下訂單
        String message = "新增訂單:id=101";
        channel.basicPublish(EXCHANGE_NAME, "order.insert", null, message.getBytes());
        System.out.println(" [生產者] Sent '" + message + "'");

        channel.close();
        connection.close();
    }
	
}
消費者1： 
package com.rabbitmq.test.T_topic;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.QueueingConsumer;
import com.rabbitmq.test.util.ConnectionUtil;

public class Consumer1 {

	private final static String QUEUE_NAME = "test_queue_topic_1";

    private final static String EXCHANGE_NAME = "test_exchange_topic";

    public static void main(String[] argv) throws Exception {

        // 獲取到連線以及mq通道
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();

        // 宣告佇列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        // 繫結佇列到交換機
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "order.#");

        // 同一時刻伺服器只會發一條訊息給消費者
        channel.basicQos(1);

        // 定義佇列的消費者
        QueueingConsumer consumer = new QueueingConsumer(channel);
        // 監聽佇列，手動返回完成
        channel.basicConsume(QUEUE_NAME, false, consumer);

        // 獲取訊息
        while (true) {
            QueueingConsumer.Delivery delivery = consumer.nextDelivery();
            String message = new String(delivery.getBody());
            System.out.println(" [財務系統] Received '" + message + "'");
            Thread.sleep(10);

            channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
        }
    }
}
消費者2： 
package com.rabbitmq.test.T_topic;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.QueueingConsumer;
import com.rabbitmq.test.util.ConnectionUtil;

public class Consumer2 {

	private final static String QUEUE_NAME = "test_queue_topic_2";

    private final static String EXCHANGE_NAME = "test_exchange_topic";

    public static void main(String[] argv) throws Exception {

        // 獲取到連線以及mq通道
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();

        // 宣告佇列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        // 繫結佇列到交換機
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "order.insert");

        // 同一時刻伺服器只會發一條訊息給消費者
        channel.basicQos(1);

        // 定義佇列的消費者
        QueueingConsumer consumer = new QueueingConsumer(channel);
        // 監聽佇列，手動返回完成
        channel.basicConsume(QUEUE_NAME, false, consumer);

        // 獲取訊息
        while (true) {
            QueueingConsumer.Delivery delivery = consumer.nextDelivery();
            String message = new String(delivery.getBody());
            System.out.println(" [物流系統] Received '" + message + "'");
            Thread.sleep(10);

            channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
        }
    }
}



相關推薦

rabbitmq介紹及rabbitmq在java中基礎使用

RabbitMQ簡介 RabbitMQ是一個在AMQP基礎上完整的，可複用的企業訊息系統。它可以用於大型軟體系統各個模組之間的高效通訊，支援高併發，支援可擴充套件。使用Erlang語言編寫。RabbitMQ相關術語：          1.Broker：簡單來說就是訊息佇

RabbitMQ介紹及安裝部署

lan 行數 安裝部署 原理圖 tro 快的 它的 主題 通配符 本節內容： RabbitMQ介紹 RabbitMQ運行原理 RabbitMQ重要術語 三種ExchangeType RabbitMQ集群種類 集群基本概念 鏡像模式部署集群 一、RabbitMQ介紹

Spring.net介紹及MVC中應用

text name default 轉變 業務層 核心 解耦 inf star Spring.net兩大核心內容： IOC（控制反轉） 傳統的面相對象思維模式是對象A依賴對象B，對象B的實例化和調用都在對象A中發生，一旦對象B中發生變化，對象A也要隨之變化，這樣使得

ES6 介紹 及 變量基礎知識

函數表達式 status 執行函數 java 5.1 ber 聲明 設置 模式匹配 一、ES6 簡介 ECMAScript 6.0（以下簡稱 ES6）是 JavaScript 語言的下一代標準，已經在 2015 年 6 月正式發布了。它的目標，是使得 JavaScript

Arm處理器寄存器介紹及匯編基礎

狀態 defined bubuko arm處理器 TP TE nsf 匯編 arm尋址 1. ARM處理器支持7種工作模式 · User (usr): 　　　　 The normal ARM program execution state· FIQ (fiq):　　　 　　

斐波那契數列介紹及Python中五種方法斐波那契數列

Q：斐波那契數列為什麼那麼重要，所有關於數學的書幾乎都會提到？ A：因為斐波那契數列在數學和生活以及自然界中都非常有用。 1.　斐波那契數列 概念引入 斐波那契數列（Fibonacci sequence），又稱黃金分割數列，因數學家列昂納多·斐波那契（Leonar

java中URI,URL,URL介紹及Android中Uri解析

一、URI 1.1 定義 在電腦術語中，統一資源識別符號（Uniform Resource Identifier，即URI)是一個用於標識某一網際網路資源名稱的字串。 該種標識允許使用者對任何（包括本地和網際網路）的資源通過特定的協議進行互動操作。 1.2 組成 一般格式為：

MySQL · 捉蟲動態 · MySQL字符集相關變數介紹及binlog中字符集相關缺陷分析

MySQL字符集相關變數介紹及binlog中字符集相關缺陷分析 MySQL支援多種字符集（character set）提供使用者儲存資料，同時允許用不同排序規則（collation）做比較。 本文基於MySQL5.7介紹了字符集相關變數的使用，通過例子描述了

linq介紹及工作中應用兩例——左聯與內聯，linq迴圈方法

[toc] #1 linq介紹 ##1.1 linq產生背景 一個應用服務後臺程式，肯定會需要格式各樣的資料檢索跟操作，而這些資料在過去的這些年裡一般都會包含在關係型資料庫或者xml檔案中。 .Net3.5版本發行之前，傳統的資料來源訪問方式就是直接對資料庫或者xml檔案進行檢索操作。在.Net3.5 V

Python零基礎學習系列之二--Python介紹及環境搭建

url 軟件包 三方庫 簡單的 lin 文件的 span 高級程序設計 擴展 1-1、Python簡介： 　Python是一種解釋型、面向對象、動態數據類型的高級程序設計語言。Python由Guido van Rossum於1989年底發明，第一個公開發行版發行於1991年

簡單介紹下python中函數的基礎語法

想要 再次 要求 傳參 ima glob 語法 none 聲明 python 函數 定義 函數是指將一組語句的集合通過一個名字(函數名)封裝起來，要想執行這個函數，只需調用其函數名即可。 特性 減少代碼重復 使程序變得可擴展 使程序變得易於維護 函數的創建 python

Numpy中Meshgrid函數介紹及2種應用場景

我們 wdk fbx images 文章 () dcb markdown grid 近期在好幾個地方都看到meshgrid的使用，雖然之前也註意到meshgrid的用法。但總覺得印象不深刻，不是太了解meshgrid的應用場景。所以，本文將進一步介紹Numpy中mesh

Java中BigDecimal類介紹及用法

exceptio decimal body ue4 mage oat 比較運算符 mod 乘法 　　Java中提供了大數字(超過16位有效位)的操作類,即 java.math.BinInteger 類和 java.math.BigDecimal 類,用於高精度計算. 　　其

CSS基礎-介紹及語法

工作 png ont violet inf 語法 class 圖片 alt 一、CSS概述： 1、 CSS指層疊樣式表 CSS樣式表極大地提高了工作效率 2、①選擇器分組：

MYSQL基礎加固——SQL的介紹及MySQL的安裝

語句格式 查看表 產生 進行 ble mysql lin perf 需求 2.1 數據庫和 SQL 概念 數據庫（Database）是按照數據結構來組織、存儲和管理數據的倉庫，它的產生距今已有六十多年。隨著信息技術和市場的發展，數據庫變得無處不在：它在電子商務、銀行系統等眾

memcached簡單介紹及在django中的使用

item 讀取 用戶 維護 數字 emc 當前 性能 djang 什麽是memcached？ 　　Memcached是一個高性能的分布式的內存對象緩存系統，全世界有不少公司采用這個緩存項目來構建大負載的網站，來分擔數據庫的壓力。Memcached是通過在內存裏維護一個統一的

RabbitMQ簡單介紹及安裝使用

簡單 text web bin Opens 端口 密碼 curses usr 一.RabbitMQ簡單介紹 二.安裝配置1.安裝環境 CentOS7 server1 190.168.3.250安裝包依賴[root@server1 ~]# yum -y install gcc

RabbitMQ使用介紹及實例

mvc 環境變量 ade ring 路由規則 自己 編寫 使用 消息 消息列隊不做過多解釋了，直接講講rabbitmq的基本概念和路由模式。 一、安裝及基本概念 rabbitmq是基於erlang編寫的，所以安裝rabbitmq之前需要安裝erlang的環境，配置環境變量，

kubernetes 環境搭建 及 基礎架構介紹 及 一個進銷存管理系統 簡單搭建

kubernetes是一個全新的基於容器技術的分散式架構領先方案。它是谷歌十幾年來大規模應用容器技術的經驗積累和昇華的一個重要成果 kubernetes是一個完備的分散式系統支撐平臺。kubernetes具有完備的叢集管理能力，包括多層次的安全防護和准入機制，多租戶應用支撐能力，透明的服務註冊和

Hanlp 在Python環境中安裝、介紹及使用

Hanlp HanLP是由一系列模型與演算法組成的Java工具包，目標是普及自然語言處理在生產環境中的應用。HanLP具備功能完善、效能高效、架構清晰、語料時新、可自定義的特點。 功能：中文分詞 詞性標註 命名實體識別 依存句法分析 關鍵詞提取新詞發現 短語提取 自動摘要 文字分類 拼音簡繁