欧美bbbwbbbw肥妇,免费乱码人妻系列日韩,一级黄片

RabbitMQ 的七種隊列模式和應(yīng)用場景

 更新時間：2021年05月26日 09:48:08   作者：我思知我在  
最近學(xué)習(xí)RabbitMQ，本文就記錄一下RabbitMQ 的七種隊列模式和應(yīng)用場景，方便以后使用,也方便和大家共享,相互交流

七種模式介紹與應(yīng)用場景

 簡單模式（Hello World）

在這里插入圖片描述

做最簡單的事情，一個生產(chǎn)者對應(yīng)一個消費者，RabbitMQ相當(dāng)于一個消息代理，負責(zé)將A的消息轉(zhuǎn)發(fā)給B
應(yīng)用場景：將發(fā)送的電子郵件放到消息隊列，然后郵件服務(wù)在隊列中獲取郵件并發(fā)送給收件人

工作隊列模式（Work queues）

在這里插入圖片描述

在多個消費者之間分配任務(wù)（競爭的消費者模式），一個生產(chǎn)者對應(yīng)多個消費者，一般適用于執(zhí)行資源密集型任務(wù)，單個消費者處理不過來，需要多個消費者進行處理
應(yīng)用場景：一個訂單的處理需要10s，有多個訂單可以同時放到消息隊列，然后讓多個消費者同時處理，這樣就是并行了，而不是單個消費者的串行情況

訂閱模式（Publish/Subscribe）

在這里插入圖片描述

一次向許多消費者發(fā)送消息，一個生產(chǎn)者發(fā)送的消息會被多個消費者獲取，也就是將消息將廣播到所有的消費者中。
應(yīng)用場景：更新商品庫存后需要通知多個緩存和多個數(shù)據(jù)庫，這里的結(jié)構(gòu)應(yīng)該是：

  • 一個fanout類型交換機扇出兩個個消息隊列，分別為緩存消息隊列、數(shù)據(jù)庫消息隊列
  • 一個緩存消息隊列對應(yīng)著多個緩存消費者
  • 一個數(shù)據(jù)庫消息隊列對應(yīng)著多個數(shù)據(jù)庫消費者

路由模式（Routing）

在這里插入圖片描述

有選擇地（Routing key）接收消息，發(fā)送消息到交換機并且要指定路由key ，消費者將隊列綁定到交換機時需要指定路由key，僅消費指定路由key的消息
應(yīng)用場景：如在商品庫存中增加了1臺iphone12，iphone12促銷活動消費者指定routing key為iphone12，只有此促銷活動會接收到消息，其它促銷活動不關(guān)心也不會消費此routing key的消息

主題模式（Topics）

在這里插入圖片描述

根據(jù)主題（Topics）來接收消息，將路由key和某模式進行匹配，此時隊列需要綁定在一個模式上，#匹配一個詞或多個詞，*只匹配一個詞。
應(yīng)用場景：同上，iphone促銷活動可以接收主題為iphone的消息，如iphone12、iphone13等

遠程過程調(diào)用（RPC）

在這里插入圖片描述

如果我們需要在遠程計算機上運行功能并等待結(jié)果就可以使用RPC，具體流程可以看圖。
應(yīng)用場景：需要等待接口返回數(shù)據(jù)，如訂單支付

發(fā)布者確認（Publisher Confirms）

與發(fā)布者進行可靠的發(fā)布確認，發(fā)布者確認是RabbitMQ擴展，可以實現(xiàn)可靠的發(fā)布。在通道上啟用發(fā)布者確認后，RabbitMQ將異步確認發(fā)送者發(fā)布的消息，這意味著它們已在服務(wù)器端處理
應(yīng)用場景：對于消息可靠性要求較高，比如錢包扣款

代碼演示：

代碼中沒有對后面兩種模式演示，有興趣可以自己研究

簡單模式

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Sender {

    private final static String QUEUE_NAME = "simple_queue";

    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        factory.setPort(5672);
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        // 聲明隊列
        // queue：隊列名
        // durable：是否持久化
        // exclusive：是否排外  即只允許該channel訪問該隊列   一般等于true的話用于一個隊列只能有一個消費者來消費的場景
        // autoDelete：是否自動刪除  消費完刪除
        // arguments：其他屬性
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        //消息內(nèi)容
        String message = "simplest mode message";
        channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
        System.out.println("[x]Sent '" + message + "'");

        //最后關(guān)閉通關(guān)和連接
        channel.close();
        connection.close();

    }
}

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.DeliverCallback;

import java.io.IOException;
import java.util.concurrent.TimeoutException;


public class Receiver {

    private final static String QUEUE_NAME = "simplest_queue";

    public static void main(String[] args) throws IOException, InterruptedException, TimeoutException {
        // 獲取連接
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        factory.setPort(5672);
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println(" [x] Received '" +
                    delivery.getEnvelope().getRoutingKey() + "':'" + message + "'");
        };
        channel.basicConsume(QUEUE_NAME, true, deliverCallback, consumerTag -> {
        });
    }
}

工作隊列模式

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.DeliverCallback;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Receiver1 {

    private final static String QUEUE_NAME = "queue_work";

    public static void main(String[] args) throws IOException, InterruptedException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        factory.setPort(5672);
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        // 同一時刻服務(wù)器只會發(fā)送一條消息給消費者
        channel.basicQos(1);

        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println(" [x] Received '" +
                    delivery.getEnvelope().getRoutingKey() + "':'" + message + "'");
        };
        channel.basicConsume(QUEUE_NAME, true, deliverCallback, consumerTag -> {
        });

    }
}

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.DeliverCallback;

import java.io.IOException;
import java.util.concurrent.TimeoutException;


public class Receiver2 {

    private final static String QUEUE_NAME = "queue_work";

    public static void main(String[] args) throws IOException, InterruptedException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        factory.setPort(5672);
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();


        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        // 同一時刻服務(wù)器只會發(fā)送一條消息給消費者
        channel.basicQos(1);

        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println(" [x] Received '" +
                    delivery.getEnvelope().getRoutingKey() + "':'" + message + "'");
        };
        channel.basicConsume(QUEUE_NAME, true, deliverCallback, consumerTag -> {
        });

    }
}

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

import java.io.IOException;
import java.util.concurrent.TimeoutException;


public class Sender {

    private final static String QUEUE_NAME = "queue_work";

    public static void main(String[] args) throws IOException, InterruptedException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        factory.setPort(5672);
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        // 聲明隊列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        for (int i = 0; i < 100; i++) {
            String message = "work mode message" + i;
            channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
            System.out.println("[x] Sent '" + message + "'");
            Thread.sleep(i * 10);
        }

        channel.close();
        connection.close();
    }
}

發(fā)布訂閱模式

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.DeliverCallback;

public class Receive1 {

    private static final String EXCHANGE_NAME = "logs";

    public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();


        channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
        String queueName = channel.queueDeclare().getQueue();
        channel.queueBind(queueName, EXCHANGE_NAME, "");

        System.out.println(" [*] Waiting for messages. To exit press CTRL+C");

        // 訂閱消息的回調(diào)函數(shù)
        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println(" [x] Received '" + message + "'");
        };

        // 消費者，有消息時出發(fā)訂閱回調(diào)函數(shù)
        channel.basicConsume(queueName, true, deliverCallback, consumerTag -> {
        });
    }
}

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.DeliverCallback;

public class Receive2 {

    private static final String EXCHANGE_NAME = "logs";

    public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();


        channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
        String queueName = channel.queueDeclare().getQueue();
        channel.queueBind(queueName, EXCHANGE_NAME, "");

        System.out.println(" [*] Waiting for messages. To exit press CTRL+C");

        // 訂閱消息的回調(diào)函數(shù)
        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println(" [x] Received2 '" + message + "'");
        };

        // 消費者，有消息時出發(fā)訂閱回調(diào)函數(shù)
        channel.basicConsume(queueName, true, deliverCallback, consumerTag -> {
        });
    }
}

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

public class Sender {

    private static final String EXCHANGE_NAME = "logs";

    public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();


        channel.exchangeDeclare(EXCHANGE_NAME, "fanout");

        String message = "publish subscribe message";
        channel.basicPublish(EXCHANGE_NAME, "", null, message.getBytes("UTF-8"));
        System.out.println(" [x] Sent '" + message + "'");

        channel.close();
        connection.close();
    }
}

路由模式

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.DeliverCallback;

import java.io.IOException;
import java.util.concurrent.TimeoutException;


public class Receiver1 {

    private final static String QUEUE_NAME = "queue_routing";
    private final static String EXCHANGE_NAME = "exchange_direct";

    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        factory.setPort(5672);
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();


        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        // 指定路由的key，接收key和key2
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "key");
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "key2");

        channel.basicQos(1);

        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println(" [x] Received '" +
                    delivery.getEnvelope().getRoutingKey() + "':'" + message + "'");
        };
        channel.basicConsume(QUEUE_NAME, true, deliverCallback, consumerTag -> {
        });
    }

}

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.DeliverCallback;

import java.io.IOException;
import java.util.concurrent.TimeoutException;


public class Receiver2 {

    private final static String QUEUE_NAME = "queue_routing2";
    private final static String EXCHANGE_NAME = "exchange_direct";

    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        factory.setPort(5672);
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();


        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        // 僅接收key2
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "key2");

        channel.basicQos(1);

        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println(" [x] Received '" +
                    delivery.getEnvelope().getRoutingKey() + "':'" + message + "'");
        };
        channel.basicConsume(QUEUE_NAME, true, deliverCallback, consumerTag -> {
        });


    }
}

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

import java.io.IOException;
import java.util.concurrent.TimeoutException;


public class Sender {

    private final static String EXCHANGE_NAME = "exchange_direct";
    private final static String EXCHANGE_TYPE = "direct";

    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        factory.setPort(5672);
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        // 交換機聲明
        channel.exchangeDeclare(EXCHANGE_NAME, EXCHANGE_TYPE);

        // 只有routingKey相同的才會消費
        String message = "routing mode message";
        channel.basicPublish(EXCHANGE_NAME, "key2", null, message.getBytes());
        System.out.println("[x] Sent '" + message + "'");
//        channel.basicPublish(EXCHANGE_NAME, "key", null, message.getBytes());
//        System.out.println("[x] Sent '" + message + "'");

        channel.close();
        connection.close();
    }
}

主題模式

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.DeliverCallback;

import java.io.IOException;
import java.util.concurrent.TimeoutException;


public class Receiver1 {

    private final static String QUEUE_NAME = "queue_topic";
    private final static String EXCHANGE_NAME = "exchange_topic";

    public static void main(String[] args) throws IOException, InterruptedException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        factory.setPort(5672);
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        // 可以接收key.1
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "key.*");

        channel.basicQos(1);

        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println(" [x] Received '" +
                    delivery.getEnvelope().getRoutingKey() + "':'" + message + "'");
        };
        channel.basicConsume(QUEUE_NAME, true, deliverCallback, consumerTag -> {
        });
    }
}

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.DeliverCallback;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Receiver2 {

    private final static String QUEUE_NAME = "queue_topic2";
    private final static String EXCHANGE_NAME = "exchange_topic";
    private final static String EXCHANGE_TYPE = "topic";

    public static void main(String[] args) throws IOException, InterruptedException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        factory.setPort(5672);
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        // *號代表單個單詞，可以接收key.1
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "*.*");
        // #號代表多個單詞，可以接收key.1.2
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "*.#");

        channel.basicQos(1);

        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println(" [x] Received '" +
                    delivery.getEnvelope().getRoutingKey() + "':'" + message + "'");
        };
        channel.basicConsume(QUEUE_NAME, true, deliverCallback, consumerTag -> {
        });
    }
}

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

import java.io.IOException;
import java.util.concurrent.TimeoutException;


public class Sender {

    private final static String EXCHANGE_NAME = "exchange_topic";
    private final static String EXCHANGE_TYPE = "topic";

    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        factory.setPort(5672);
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        channel.exchangeDeclare(EXCHANGE_NAME, EXCHANGE_TYPE);

        String message = "topics model message with key.1";
        channel.basicPublish(EXCHANGE_NAME, "key.1", null, message.getBytes());
        System.out.println("[x] Sent '" + message + "'");
        String message2 = "topics model message with key.1.2";
        channel.basicPublish(EXCHANGE_NAME, "key.1.2", null, message2.getBytes());
        System.out.println("[x] Sent '" + message2 + "'");

        channel.close();
        connection.close();
    }
}

四種交換機介紹

直連交換機（Direct exchange）：具有路由功能的交換機，綁定到此交換機的時候需要指定一個routing_key，交換機發(fā)送消息的時候需要routing_key，會將消息發(fā)送道對應(yīng)的隊列
扇形交換機（Fanout exchange）：廣播消息到所有隊列，沒有任何處理，速度最快
主題交換機（Topic exchange）：在直連交換機基礎(chǔ)上增加模式匹配，也就是對routing_key進行模式匹配，*代表一個單詞，#代表多個單詞
首部交換機（Headers exchange）：忽略routing_key，使用Headers信息（一個Hash的數(shù)據(jù)結(jié)構(gòu)）進行匹配，優(yōu)勢在于可以有更多更靈活的匹配規(guī)則

總結(jié)

這么多種隊列模式中都有其應(yīng)用場景，大家可以根據(jù)應(yīng)用場景示例中進行選擇

參考

 RabbitMQ官方教程

官方教程源碼

到此這篇關(guān)于RabbitMQ 的七種隊列模式和應(yīng)用場景的文章就介紹到這了,更多相關(guān)RabbitMQ 模式和應(yīng)用場景內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

相關(guān)文章

  • java簡易小游戲制作代碼

    java簡易小游戲制作代碼

    這篇文章主要介紹了java簡易小游戲制作代碼,代碼簡單易懂，對大家的學(xué)習(xí)或工作具有一定的參考借鑒價值，需要的朋友可以參考下
    2021-04-04
  • SpringBoot自定義內(nèi)容協(xié)商的實現(xiàn)

    SpringBoot自定義內(nèi)容協(xié)商的實現(xiàn)

    在Spring Boot中,內(nèi)容協(xié)商是一種機制,它允許服務(wù)器根據(jù)客戶端的請求選擇返回不同的表示形式,本文就來詳細的介紹一下SpringBoot自定義內(nèi)容協(xié)商的實現(xiàn),感興趣的可以了解一下
    2024-09-09
  • Java replaceAll()方法報錯Illegal group reference的解決辦法

    Java replaceAll()方法報錯Illegal group reference的解決辦法

    這篇文章主要給大家介紹了關(guān)于Java replaceAll()方法報錯Illegal group reference的解決辦法，文中通過示例代碼介紹的非常詳細，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧
    2020-09-09
  • Nacos啟動出現(xiàn)failed to req API:/nacos/v1/ns/instance after all servers問題

    Nacos啟動出現(xiàn)failed to req API:/nacos/v1/ns/insta

    這篇文章主要介紹了Nacos啟動出現(xiàn)failed to req API:/nacos/v1/ns/instance after all servers問題,具有很好的參考價值,希望對大家有所幫助,如有錯誤或未考慮完全的地方,望不吝賜教
    2024-08-08
  • Mybatis-Plus可能導(dǎo)致死鎖的問題分析及解決辦法

    Mybatis-Plus可能導(dǎo)致死鎖的問題分析及解決辦法

    這篇文章給大家主要介紹了Mybatis-Plus可能導(dǎo)致死鎖的問題分析及解決辦法,文中通過代碼示例給大家介紹的非常詳細,具有一定的參考價值,需要的朋友可以參考下
    2023-12-12
  • 淺析SpringBoot多數(shù)據(jù)源實現(xiàn)方案

    淺析SpringBoot多數(shù)據(jù)源實現(xiàn)方案

    現(xiàn)在很多項目的開發(fā)過程中,可能涉及到多個數(shù)據(jù)源,像讀寫分離的場景,或者因為業(yè)務(wù)復(fù)雜,導(dǎo)致不同的業(yè)務(wù)部署在不同的數(shù)據(jù)庫上,那么這樣的場景,我們應(yīng)該如何在代碼中簡潔方便的切換數(shù)據(jù)源呢,本文介紹SpringBoot多數(shù)據(jù)源實現(xiàn)方案,感興趣的朋友跟隨小編一起看看吧
    2024-02-02
  • 淺談Spring6中的反射機制

    淺談Spring6中的反射機制

    Java反射機制是Java語言中一種動態(tài)（運行時）訪問、檢測、修改它本身的能力，主要作用是動態(tài)（運行時）獲取類的完整結(jié)構(gòu)信息、調(diào)用對象的方法,需要的朋友可以參考下
    2023-05-05
  • 一文搞懂Java創(chuàng)建線程的五種方法

    一文搞懂Java創(chuàng)建線程的五種方法

    本文主要為大家詳細介紹一下Java實現(xiàn)線程創(chuàng)建的五種常見方式，文中的示例代碼講解詳細，對我們學(xué)習(xí)有一定的幫助，感興趣的可以跟隨小編學(xué)習(xí)一下
    2022-06-06
  • IDEA關(guān)閉git管理,文件變成紅色解決方案

    IDEA關(guān)閉git管理,文件變成紅色解決方案

    在軟件開發(fā)中,當(dāng)一個文件夾內(nèi)的Java項目啟用Git版本控制,通常會導(dǎo)致該文件夾下所有項目同步開啟Git,這種做法有助于保持項目的一致性和可追溯性,但也可能帶來管理上的復(fù)雜性,如果需要解除某個項目的Git管理,可以通過IDE的設(shè)置選項進行調(diào)整
    2024-10-10
  • Spring Boot集成Java DSL的實現(xiàn)代碼

    Spring Boot集成Java DSL的實現(xiàn)代碼

    這篇文章主要介紹了Spring Boot集成Java DSL的實現(xiàn)代碼，文中通過示例代碼介紹的非常詳細，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧
    2019-01-01

最新評論