@TOC
The basic concepts of MQ
1. Summary of MQ
MQ, short for Message Queue, is a container that holds messages during their transmission. It is used for communication between distributed systems. Common service communications:
Second, the advantages of MQ
1. Apply decoupling
Services are no longer connected by protocol, but decoupled (more extensible) by using the producer/consumer mode to allow the middleware MQ to connect to the data communication on both sides. Common service communications:
2. Speed up asynchronously
Common service communication: the need to block successfully to obtain the response status before writing data to the database, blocking synchronization is performed down.
3. Cut peaks and fill valleys
Common service communication: when 5000 requests are sent to the server at a moment, the server can handle the maximum 1000 requests and dies instantly.
After joining MQ: Put the request into the queue waiting to be processed, the system from mq pull 1000 requests per second for processing (just can be processed by the card in 1000, the real press cases), thus become the handle 5000 requests from 1 second peak, split into five seconds, handle 1000 requests per second gentle treatment period, oh no, is loaded with processing period.
As you can see from the graph below, the peak has indeed been clipped
3. Disadvantages of MQ
The system availability decreases
The more external dependencies a system introduces, the worse its stability will be. Once MQ is down, services are affected. How can MQ be highly available?
System complexity enhancement
The addition of MQ has greatly increased the complexity of systems where synchronous remote calls between systems are now asynchronous calls through MQ. How to ensure that the message is not lost and so on.
Common MQ products
MQ is an abstract concept that has spawned various implementations based on its ideas, such as the common ones: RabbitMQ, RocketMQ, Kafka.
5. RabbitMQ introduction
It is suggested to directly read the summary, the following knowledge can be slowly tasted (the following quotes Guide brother)
1. The introduction of the RabbitMQ
RabbitMQ is a messaging middleware that uses Erlang to implement AMQP(Advanced Message Queuing Protocol). It originated in financial systems and is used to store and forward messages in distributed systems.
RabbitMQ has grown in popularity due to its excellence in ease of use, scalability, reliability and high availability. The specific features of RabbitMQ can be summarized as follows:
- Reliability: RabbitMQ uses mechanisms to ensure the reliability of messages such as persistence, transport confirmation, and release confirmation.
- Flexible routing: Messages are routed through the exchange before they are queued. For typical routing, RabbitMQ already provides some built-in switches. For more complex routing functions, multiple switches can be bound together, or you can implement your own switch through a plug-in mechanism. This will be covered later when we cover the core concepts of RabbitMQ.
- Scalability: Multiple RabbitMQ nodes can form a cluster or dynamically expand the cluster based on service requirements.
- High availability: Queues can be mirrored on machines in a cluster, making them available even if some nodes fail.
- Supports multiple protocols: RabbitMQ supports multiple messaging middleware protocols, such as STOMP and MQTT, in addition to AMQP.
- Multi-language clients: RabbitMQ supports almost all common languages, such as Java, Python, Ruby, PHP, C#, JavaScript, etc.
- Easy-to-use management interface: RabbitMQ provides an easy-to-use user interface that allows users to monitor and manage messages, nodes in a cluster, etc. Install RabbitMQ and the admin interface will come with RabbitMQ.
- Plugin mechanisms: RabbitMQ provides many plug-ins to extend in many ways, but you can also write your own. This feels a bit like Dubbo’s SPI mechanism.
RabbitMQ is essentially a producer and consumer model, responsible for receiving, storing, and forwarding messages. Think of it as sending a package to the post office, which stores it and eventually sends it to the postman. RabbitMQ is like a system of post office, mailbox and postman. In computer terms, the RabbitMQ model is more like a switch model.
Take a look at the picture – the overall model architecture of RabbitMQ.
1.1 Producers and consumers
- Producer: the party that produces messages
- Consumer: the party that consumes the message (the person to whom the message is sent)
A message typically consists of two parts: a header (or Label) and a body. The body of the message, also called payLoad, is opaque, and the header is made up of a set of optional attributes. These attributes include routing-key, priority (priority over other messages), delivery-mode (indicating that the message may require persistent storage), and so on. After the producer sends the message to RabbitMQ, RabbitMQ sends the message to the interested Consumer based on the message header.
1.2 Exchange
In RabbitMQ, messages are not sent directly to a Queue, they have to pass through the Exchange layer, which allocates our messages to the corresponding Queue.
Exchanges are used to receive messages sent by producers and route them to queues on the server. If they are not routed, they may be returned to the Producer or discarded. Here you can think of the switch in RabbitMQ as a simple entity.
RabbitMQ has four types of exchanges, each of which has a different routing policy: Direct (default), Fanout, Topic, and headers. This will be covered when we introduce Exchange Types.
An Exchange is shown as follows:
RabbitMQ uses Binding to associate exchanges with queues, A BindingKey is usually specified during binding so RabbitMQ knows how to route messages to queues correctly, as shown below. A binding is a routing rule that connects a switch to a message queue based on a routing key, so a switch can be thought of as a routing table made up of bindings. Exchange and Queue bindings can be many-to-many.
Binding schematic diagram:
1.3 Queue
A Queue is used to hold messages until they are sent to consumers. It is the container and destination of the message. A message can be put into one or more queues. The message remains in the queue, waiting for the consumer to connect to the queue to pick it up.
RabbitMQ messages can only be stored in queues, as opposed to messaging middleware such as Kafka. Kafka stores messages at the logical level of the topic (topic), and the corresponding queue logic is just a displacement identifier in the actual storage file of the topic. The RabbitMQ producer produces the message and ultimately delivers it to the queue, from which the consumer can retrieve and consume the message.
Multiple consumers can subscribe to the same queue, and messages in the queue are round-robin for processing among multiple consumers, rather than each consumer receiving all messages and processing them, thus avoiding repeated consumption of messages.
RabbitMQ does not support queue-level broadcast consumption, so secondary development on top of broadcast consumption is cumbersome and not recommended.
1.4 Broker (Service node of message-oriented middleware)
For RabbitMQ, a RabbitMQ Broker can simply be regarded as a RabbitMQ service node, or RabbitMQ service instance. In most cases a RabbitMQ Broker can also be thought of as a RabbitMQ server.
The following figure shows the process by which a producer stores a message into a RabbitMQ Broker and a consumer consumes data from the Broker.
1.5 Exchange Types
The main Exchange types for RabbitMQ are FANout, Direct, Topic, and headers. The AMQP specification also mentions system and custom Exchange types.
(1) the fanout
The Exchange routing rule of the FANout type is very simple. It routes all messages sent to the Exchange to all queues bound to it without any judgment, so the Fanout type is the fastest of all switch types. The fanout type is often used to broadcast messages.
(2) direct
Exchange routing rules of type Direct are also simple, routing messages to queues where bindingKeys match routingkeys exactly.
(3) the topic
As mentioned above, the routing rules of the direct type switch match BindingKey and RoutingKey exactly. However, such strict matching method cannot meet the requirements of actual business in many cases. Topic exchanges extend the matching rules. Similar to direct exchanges, they route messages to queues that match BindingKey and RoutingKey, but the matching rules are a little different:
- The RoutingKey is a dot “. Delimited string (dot ‘. Each separate string is called a word), such as “com.rabbitmq.client”, “java.util.concurrent”, “com.hidden. Client”;
- BindingKey is also a dot like RoutingKey. Delimited strings;
- There can be two special strings “*” and “#” in BindingKey for fuzzy matching, where “*” is used to match one word and “#” is used to match multiple words (possibly zero).
- The messages whose routing key is com.rabbitmq.client are routed to both Queuel and Queue2.
- Messages with a routing key of “com.hidden.client” are routed to Queue2 only.
- The messages whose routing key is com.hidden.demo will only be routed to Queue2.
- The messages whose routing key is java.rabbitmq.demo are routed to Queuel only.
- Messages with a routing key of “java.util.concurrent” will be discarded or returned to the producer (the mandatory parameter is required) because it does not match any routing key.
④ Headers (not recommended)
A HEADERS exchange does not rely on the matching rules of the routing key to route a message, but matches it based on the HEADERS attribute in the content of the sent message. When sending a message to the exchange, RabbitMQ will fetch the headers of the message and compare the matching keys to the queue and the exchange binding. If they match, the message will be routed to the queue. Otherwise, the queue will not be routed to. Headers switches tend to be poor in performance and impractical, and you’ll almost never see them.
2. To summarize
To put it more broadly, the RabbitMQ architecture is client, switch and queue. These three roles make up the various modes used by RabbitMQ with different modes of switch (direct, sector, principal and header) and different configurations: Simple mode (), work queue mode, publish/subscribe mode, routing mode, wildcard mode, its most core is queue, provider and corresponding queuing, consumption corresponding queuing.
3. Install RabbitMQ in the Windows local environment
3.1 download the Erlang
RabbitMQ is based on the Erlang environment, download Erlang (24), erlang.org/download/ot…
3.2 Installing RabbitMQ (3.9.5)
Github.com/rabbitmq/ra…
3.3 start
I don’t think I need to tell you what to press for this
Successful startup, as follows
3.4 Installing management Plug-ins
Right-click the shortcut to open the folder directory
5. Access the background
Background management website:http://localhost:15672/The default initial account after installation: guest password: guset
Learn about RabbitMQ from a simple example
Example 1.
Rely on:
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
<version>2.41.</version>
</dependency>
Copy the codeProducers:
package boot.spring.test;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/ * * *@description:
* @author: lx *@date: 2021/09/04 3:12 p.m. *@Copyright: lx * /
public class Provider {
/** * The declared queue name */
private final static String QUEUE_NAME = "test_queue";
public static void main(String[] args) throws IOException, TimeoutException {
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("127.0.0.1");
// The default port number
connectionFactory.setPort(5672);
connectionFactory.setUsername("guest");
connectionFactory.setPassword("guest");
connectionFactory.setVirtualHost("/");
// Obtain the TCP long connection
Connection conn = connectionFactory.newConnection();
// Create a communication "channel", equivalent to a virtual connection in TCP
Channel channel = conn.createChannel();
// Start a RabbitMQ transaction, throw an exception and roll back if no MQ feedback is received
channel.txSelect();
// Create a queue, declare and create a queue, if the queue already exists, use this queue
// First argument: queue name
// The second parameter: persistent or not, false for non-persistent data, data will be lost when MQ stops
False means that all consumers can access the queue. True means that consumers who own it only once can use it forever. Other consumers are not allowed to access the queue
False indicates that the queue is not automatically deleted after the connection is down
// Other extra arguments: null
channel.queueDeclare(QUEUE_NAME, true.false.false.null);
String message = "hello world!";
try {
// The first parameter: switch, this is the simple demo version, no switch
// Second argument: queue name
// Third argument: additional setting properties
// The fourth argument: an array of message bytes to pass
channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
} catch (Exception e) {
// An abnormal rollback occurred
channel.txRollback();
}
// The normal process commits the transaction
channel.txCommit();
channel.close();
conn.close();
System.out.println("Sent successfully!"); }}Copy the codeConsumer:
package boot.spring.test;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/ * * *@description:
* @author: lx *@date: 2021/09/04 下午 3:33
* @Copyright: lx * /
public class Consumer {
private final static String QUEUE_NAME = "test_queue";
public static void main(String[] args) throws IOException, TimeoutException {
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("127.0.0.1");
connectionFactory.setPort(5672);
connectionFactory.setUsername("guest");
connectionFactory.setPassword("guest");
connectionFactory.setVirtualHost("/");
// Obtain the TCP long connection
Connection conn = connectionFactory.newConnection();
// Create a communication "channel", equivalent to a virtual connection in TCP
Channel channel = conn.createChannel();
// Create a queue, declare and create a queue, if the queue already exists, use this queue
// First argument: queue name
// The second parameter: persistent or not, false for non-persistent data, data will be lost when MQ stops
False means that all consumers can access the queue. True means that consumers who own it only once can use it forever. Other consumers are not allowed to access the queue
False indicates that the queue is not automatically deleted after the connection is down
// Other extra arguments: null
channel.queueDeclare(QUEUE_NAME, true.false.false.null);
// Create a message consumer
// First argument: queue name
// Second argument: The second argument indicates whether the message is automatically acknowledged. False indicates that the message is manually programmed
// Third argument: pass in the implementation class of DefaultConsumer
channel.basicConsume(QUEUE_NAME, false.newReceiver(channel)); }}/ * * *@description:
* @author: lx *@date: 2021/09/04 下午 3:37
* @Copyright: lx * /
class Receiver extends DefaultConsumer {
private Channel channel;
/** * overrides the constructor, the channel object needs to be passed in from the outer layer, which is used in handleDelivery@param channel
*/
public Receiver(Channel channel) {
super(channel);
this.channel = channel;
}
@Override
public void handleDelivery(String consumerTag,
Envelope envelope,
AMQP.BasicProperties properties,
byte[] body)
throws IOException {
String message = new String(body);
System.out.println("Messages received by consumers:" + message);
System.out.println("Message TagID:" + envelope.getDeliveryTag());
// int i = 1 / 0;
// False indicates that only current messages are signed. If set to true, all unsigned messages for the consumer are signed
channel.basicAck(envelope.getDeliveryTag(), false); }}Copy the code2. Repeat spending
Start the producer, go to the admin page, and you can see that the message has been queued and is ready to be consumed.
The solution
Since repeated consumption is unavoidable, how do we deal with it? The business logic for processing messages on the consumer side remains idempotent. Idempotence, in plain English, is just one piece of data, or one request, given to you over and over again, and you have to make sure that the corresponding data doesn’t change, you can’t go wrong.
1. You get the message and do the database insert. That would be easy. Give the message a unique primary key, so that even if repeated consumption occurs, primary key collisions will occur, avoiding dirty data in the database. 2. If you get this message and do the redis set operation, then it is easy to solve, because you will get the same result no matter how many times you set the set operation, which is supposed to be idempotent. 3. Prepare a third-party medium to keep track of your spending. In the case of Redis, a message is assigned a global ID, and as long as the message has been consumed, < ID,message> is written to Redis in k-V form. Before the consumer begins to consume, go to Redis to check whether there is any consumption record.
3. Message loss
The message is lost during network transmission. MQ is down and the message is lost
4. Message backlog
A program exception can cause the consumer program to crash, and MQ can remain blocked waiting for a response, causing messages to pile up
5. High availability of MQ
Blog.csdn.net/yygEwing/ar…
Six, source code analysis
Learn more about RabbitMQ from a simple source code analysis
RabbitMQ Server is a Message Broker Virtual Host designed for multi-tenancy and security purposes to divide the basic components of an AMQP into Virtual groups, similar to the namespace concept of a network. RabbitMQserver can be partitioned into multiple vhosts when different users use the same RabbitMQserver service, and each user can create an exchange/queue Connection on their own Vhost: Publisher/Consumer/broker TCP Channel: How to establish a Connection every time you access RabbitMQ. Establishing a TCP Connection on a high volume of messages can be expensive and inefficient. A channel is a logical connection established within a connection. If the application supports multiple threads, it is common for each thread to create a separate channel for communication. AMQPmethod contains a channelId to help the client and Message Broker identify a channel. So channels are completely isolated from each other. As a lightweight Connection, Channel greatly reduces the overhead of establishing TCP Connection in the operating system.
1. Review design patterns
1.1 Factory method pattern
1.2 Abstract factory pattern
Abstract factory is an abstract class of other factory classes, that is, AbstractXXX abstract factory class is extracted from the common behavior of other factory classes. In abstract factory mode, another implementation of abstract factory is used, including agents, adapters and abstract factories. The two cache-mode implementations of CacheService are added with adapters that correspond to the methods of the CacheService interface, and then dynamic proxies are used, where the method calls are encoded to the invoke method of the invocation handler when the proxy instance calls the method. You can think of the adapter classes for different caching patterns as building classes for factories that have common getters and setters. These common behaviors are abstracted into CacheService, where methods called in service actually call methods in the adapter class through dynamic proxies.
CacheService proxy_EGM = JDKProxy.getProxy(CacheServiceImpl.class, new EGMCacheAdapter());
proxy_EGM.set("user_name_01".Little Fuge.);
String val01 = proxy_EGM.get("user_name_01");
System.out.println("Test Results:" + val01);
CacheService proxy_IIR = JDKProxy.getProxy(CacheServiceImpl.class, new IIRCacheAdapter());
proxy_IIR.set("user_name_01".Little Fuge.);
String val02 = proxy_IIR.get("user_name_01");
System.out.println("Test Results:" + val02);
Copy the code1.3 Builder mode
In daily life, decorating house would be based on different scenarios, brand, model, price and so on combination formed A variety of decorate A style, set A: contemporary and contracted, plan B: light luxury pastoral, package C: european-style luxury) will not change some basic material, and the combination of often change over time, you can choose the builder pattern to build the code. Builder
1.4 Prototype Mode
In the exam, each examinee gets roughly the same exam paper topic, are from the same exam question pool random combination of a set of questions out and distributed to all examinees for the exam, but the questions, the same topic order, easy to cause cheating, and still constantly create initialization unified object. Use prototype patterns: Create complex objects by cloning, avoid repeated initialization operations, and do not need to be coupled to other classes that belong to the class. However, there are some disadvantages that can make this pattern extremely cumbersome if the objects include clones of circular references, as well as clones of deeply used objects in the class. Cloneable is implemented (out of order in overridden clone methods)
1.5 Singleton Mode
Get the same instance each time you get or create. For example: Spring’s @autowird automatic injection of objects is also a representation of the singleton pattern. The underlying singleton pattern is determined by the Bean injection pattern. The singleton pattern is to put the instance created by new into the container, and get the instance object every time. NewInstance proposes to use the enumerated singleton pattern to solve the most important problem; Thread-safe, free serialization, single instance. enum
1.6 Adapter Mode
Create an adapter interface for classes that have common behavior but call different methods. The implementation class of the adapter actually calls the corresponding methods of the original object. The interface has been uniformly wrapped so that external use does not need to care about the internal logic. And in the call only need to pass unified parameters, so that meet the role of adaptation. Adapter
1.7 Bridge Mode
The main role of the bridge pattern is to combine multiple matching uses by separating the abstract from the implementation. To put it bluntly, the core implementation is A class A with A class B interface, passing the implementation of class B through constructors, and that class B is the bridge of the design. Through the simulation of wechat and Alipay in different payment modes, the combination of face brush, fingerprint and password reflects the reasonable application of bridge mode in such scenarios. ZfbPay = new zfbPay (new PayFingerprintMode()); Bridge/ passes in other objects at initialization as a judgment of the class’s execution method
1.8 Combination mode (no fine products)
The main solution of the composite pattern is a series of simple logical nodes or extended complex logical nodes under different structure organization, for external calls can still be very simple.
1.9 Decorative mode (no fine items)
new BufferedReader(new FileReader(“”)); , this code you are familiar with, I believe that learning Java development to byte stream, character stream, file stream content have seen such code, a layer nested a layer, a layer nested a layer, byte flow character stream and so on, and the use of this way is a manifestation of the decorator mode.
1.10 Appearance mode (no fine products)
The facade pattern, also known as the facade pattern, is designed to reduce the complexity of the logical combination of interfaces used by callers. This provides an intermediate layer between the caller and the actual interface provider, which provides the API interface for the wrapping logic. Sometimes the facade pattern is also used in the middleware layer to wrap the generic complex logic in the service so that the consumer can only care about business development.
1.11 Free Yuan mode
The share mode is used to share common objects, reducing memory usage and improving system access efficiency. These shared objects usually consume memory or need to query a large number of interfaces or use database resources, so they are all removed and used as shared objects. Through a variety of ways to reuse the data cache the entire object, reduce memory footprint and the number of queries Seconds kill under the scenario of the activity, activity information is not the same, only the goods inventory in the event of a transformation, every time information from a database access to the activities of the object in addition to the inventory information is consistent with the other, this time can use the flyweight pattern, The repeated parts are cached for repeated use. Here, the element factory is used, the active information is cached from the database with map during initialization, and the inventory information is later fetched from redis and spliced into the active information.
1.12 Agent Mode (no details)
The agency model is a bit like the boss and the little brother, and a bit like the distributor. The main solution is to provide convenient proxy services for access to some resources and easy operation of object classes. This pattern of design thinking is often found in our systems, or in the components you use, which give you a very simple and easy way to control the service classes that you would otherwise have to write a lot of code to use. Basically: a series of encapsulation designs after the implementation of the proxy. We adopt the development of a part of the core functions of Mybatis – Spring middleware to reflect the power of the proxy mode, so it involves some knowledge points about the creation of proxy classes and the registration of beans in Spring, which may be rarely used in ordinary business development. But it is a very common operation in middleware development. In addition to developing middleware, proxy mode can also be the packaging of services, Internet of Things components and so on, making complex services into lightweight invocation and cache use. You can understand it as the light switch in your home. We cannot operate the human flesh connection of 220V wire, but we can use the switch to avoid electric shock. The design of proxy mode can make the code more clean, clean and easy to maintain. Although many additional classes are added in this part of the development, including the registration of their own processing beans, etc., such middleware is highly reusable and more intelligent, which can be easily extended to various service applications.
1.13 chain of responsibility
I am familiar with this, more commonly used and relatively simple one, the core of the responsibility chain model is to solve a group of services in the execution of the processing relationship, a bit like you have no money to spend, the need for family financial expenditure approval, less than 10 yuan to find daughter approval, 100 yuan first daughter approval in daughter-in-law approval. You can imagine that when you want to change jobs you are arranged to be signed off on by the various leaders.
Chain of Responsibility model1.The core idea is chain execution, and the execution of each node depends on the execution result of the node at the next level.2.Abstract parent class: Action Property: Action Action is used to store the object pointing to the next node reference abstract method: start() The implementation of the subclass to define the current node specific logic implementation method: Action () node to execute the decision branch, success-enter the next nodedoReturn subclass: openDeviceAction (multiple subclass nodes, etc.) Override the start () method to implement the concrete logical assembly execution class: Call (encapsulate the sequence of execution actions, logic, and where needed) creates the required node, uses setNext to specify the next node (execution order), and calls the action () of the first node to start3.Key words linked list data structure, the essence of responsibility chain is a linked list data structure, through the Node points to the Next Node to ensure the execution order of the Node, (Next, Node)Copy the code1.14 Command Mode
1.15 Iterator mode (no details)
1.16 Intermediary Mode (no details)
1.17 Memo Mode (no details)
1.18 Observer mode
For example; Sniper, Li Yunlong. And many frameworks will have listeners, through annotations, when the listening mode is executed, it will also execute the corresponding listening method (listening database inventory changes, front-end statistics inventory changes, etc.). There is also the consumer pattern in MQ, again by listening for messages in queues and then consuming them, which is also the idea of the observer pattern, listening for actions, subscriptions
1.19 Status Mode
1.20 Policy Mode
1.21 Template mode (no fineness)
The core design idea of the template pattern is to define the order of execution of abstract methods in an abstract class, and to make the abstract methods subclass only, but not to design independently accessible methods. Simply put, make your schedule very clear. The template pattern is very convenient in defining the uniform structure, namely the implementation standard, which is a good control of the subsequent implementers do not care about the call logic, according to the uniform way of execution. Then the inheritors of the class need only care about the concrete implementation of the business logic.
1.22 Visitor Mode (no details)
The core issue for visitors is to add volatile business access logic to a stable data structure, such as user information, employee information, and so on. A design pattern that decouples these two parts of the business to enhance scalability.
1.23 Interpreter mode
The Interpreter Pattern, which provides a way to evaluate the syntax or expressions of a language, is a behavioral Pattern. This pattern implements an expression interface that interprets a particular context. This pattern is used in SQL parsing, symbol processing engines, and so on. A bit like in a code generator, the {name} expression is replaced with a “three” interpretation of the actual queried data.
2. Understand the data interaction between RabbitMQ and the client
3. Look at the code with questions
3.1 How did the message get into the team?
3.2 How are messages consumed?
3.3 How does the Client Establish a Connection?
3.4 What is a channel?
3.5 How can RabbitMQ be Asynchronous?
3.6 How do RabbitMQ ensure that messages are not lost? Ack
3.7 Why do consumers automatically consume messages in the queue after startup?
3.8 Will consumers continue to consume after they stop running consumers after receiving consumption information?
4. Core ideas
What is the core idea of RabbitMQ? What are its characteristics? What design patterns are used? What impressed you most?
Idea to download the source code, read.
Vii. Reference:
The elder brother of the Guide: github.com/Snailclimb/… Little Fu Ge: bugstack.cn/itstack/its… B station Baidu welcome to reprint, please indicate the source.
Update log
- 9-7
- Fixed some typos
- Added a supplement
- Added the overall learning framework diagram and the second node (Design pattern) content
I’m Lin Xi, thank you so much for your support! Learn together and make progress together!