microservices design principles

There is an important concept in the replica set in MongoDB: mostBecause the replica set has only one node that is readable and writable, the other nodes are readable only, and the selection of the master node is determined by the majority, and can continue as the primary node only if support is obtained.(1) Most of the confirmation formula for this number: M=int ((N/2) +1)* Most of the numbers are equal to greater than m, but less than or equal to n;n as the total number of servers in the repli

use an index with a small amount of dataIf the value of the index is long, the speed of the query is affected. For example, full-text retrieval of a field of type char (100) would take more time than a field of type char (10). 6. use prefixes as far as possible to indexIf the value of an indexed field is long, it is best to index it with the prefix of the value. For example, text and blog type fields, full-text retrieval can be a waste of time. If you retrieve only the first few characters of a

Principles of design patterns1. "Open-Close" principle-the module should be open for extension, but should be closed for modification.2. Rys replacement principle-if the parent class is called, the replacement of the Child class can be completely run. The Li's replacement principle is a basis for inheritance and reuse.3. Merging Reuse Principle-less inheritance and more synthesis relationships are required.

Adaptive XAML layout experience summary (I) Principles and page structure design, and xaml Experience SummaryXAML layout Review Grid and StackPanel are the core layout, especially Grid. Grid is a Grid layout. The XAML designer may have designed a Grid layout based on the Table in Html, but made improvements. Tables in Html are tr sets of td, which is very troublesome to change the columns. The Grid in XAML

Principle (OCP), open-close principle, the design to the extension has good support, and the changes are strictly limited. This is the most important and most abstract principle, and basically what we call reusable software is developed based on this principle. Other principles also provide a path to its implementation.2) Liskov substituition Principle (LSP), the Richter substitution principle, very strict

Document directory Basic Principles SRP: The single responsibility principle single responsibility DRY: Don't repeat yourself Principle OCP: Open-Close Principle LSP: The Liskov substitution principle DIP: Dependency inversion principle ISP: interface isolation principle 1. SRP-single Responsibility Principle 2. OCP-open and closed Principle 3. LSP ---- Liskov replacement principle 4. DIP ---- Dependency inversion principle 5. ISP-interface

frameworks rather than reusable components when creating an inheritance hierarchy. (55) If you use multiple inheritance in the design, first assume that you have made a mistake. If you do not make a mistake, try to prove it. (56) as long as inheritance is used in object-oriented design, I have two questions: (1) is the derived class a special type of the thing it inherits? (2) is the base class part of

Three basic elements of object-oriented architecture: encapsulation, inheritance, and Polymorphism Five basic object-oriented design principles: Single-Resposibility Principle) Its core idea is: A class. It is best to do only one thing and only one change that causes it. The single responsibility principle can be seen as the extension of low coupling and high cohesion in the object-oriented principle. The r

【Abstract]The principle of the design pattern is that the module should be open to expansion, but the modification should be closed. The module should try not to modify the original ("original", which refers to the originalCode) Code. So how can we expand? Let's look at the factory model "factory pattern": Suppose Zhongguancun has a hacker who sells pirated disk and wool film. We designed a "CD sales management software" for him ". Why should we

Programming is military study words, design mode is a set of internal strength heart, a set of sword.A simple understanding of the design pattern: In the course of programming, we have a way of solving a problem in some situation. The design pattern is a well-known and universally optimized scheme that has been summed up and tested to avoid recurring problems, th

ArticleDirectory Problem cause Differences from the single Responsibility Principle Notes Design Pattern Series Six principles of design model (1): single Responsibility Principle Six principles of design patterns (2) Six

3 basic elements of object-oriented: encapsulation, inheritance, polymorphism Object-oriented 5 basic design principles: single Duty principle (Single-resposibility Principle) Its core idea is: A class, it is best to do only one thing, only a change that caused it. The principle of single responsibility can be regarded as the extension of low coupling, cohesion in object-oriented principle, defining respons

The first three component design principles focus on the cohesion of components. Starting from this article, the three principles to be introduced will focus more on the coupling between components, which is more difficult than the first three principles, I will explain it with some examples. The main reference is stil

With the rapid development of enterprise intranets and the international Internet, more and more workflows, business transactions, education, training, conferences, and lectures are available, and personal consumption and entertainment have been transferred to the so-called world wide web (Web. Correspondingly, interactive operations are becoming increasingly complex. As the Browser/Server mode becomes increasingly popular, many operations are performed on webpages in the browser environment, no

in public interfaces. A large number of access methods mean that related data and behaviors are not stored in a centralized manner. (15) Be careful with classes that contain too many non-communication behaviors. Another manifestation of this problem is that many get and set functions are created in the public interfaces of classes in your application. (16) In an application composed of an object-oriented model that interacts with the user interface, the model should not depend on the interface,

application lifecycle consistent with the system to ensure that your users can return to your application as effectively as possible. Do not provide users with methods to terminate your application. Make full use of Metro Style Design Principles Use these principles to help guide your design. For more information, see

to more reasons for its changes. This will lead to dependency between duties and affect each other, greatly damaging their cohesion and coupling. A single responsibility usually means a single function. Therefore, do not implement too many function points for the class to ensure that the entity has only one reason for its change. Therefore, the core of the SRP principle is to require only one change to the class. classes that violate this principle should be reconstructed, for example, separa

structure, while the abstract factory faces multiple levels. Similarly, we have done an excellent job of decoupling applications from specific implementations. The factory method uses inheritance, while the abstract factory uses a combination of objects. The abstract factory provides an abstract type of a product family. This subclass completes product creation.The expressions of ocp dip lsp and other principles mentioned in the factory method mode a

The general rule of design not only describes how to design a class, but also goes up to the design of the entire component and down to the design of a single method in the class. Single Responsibility Principle-SRP For a class, there should be only one reason for its changes. Pr