Review the directory
- The business scenario | synchronous implementation: kill Redis in seconds kill function of practice
- Design patterns | a word understand design patterns
- Apache SkyWalking | SkyWalking advanced play
- Apache SkyWalking | SkyWalking Java plug-in contribution to practice
- A distributed job scheduling | HOME LINK distributed operation platform (recommended)
Singleton:
Ensure that there is only one instance of a class and that you instantiate it yourself and make it available to the entire system.
Factory method Pattern (Factory):
Define an interface for creating objects and let subclasses decide which class to instantiate. The factory method delays the instantiation of a class to its subclasses.
Abstract Factory Model:
Provides an interface for creating a set of related or interdependent objects without specifying their concrete classes.
Template method pattern (Template):
A framework that defines an algorithm in an operation, deferring some steps to subclasses. Allows subclasses to redefine specific steps of an algorithm without changing its structure.
Builder mode:
Separating the construction of a complex object from its representation allows the same construction process to create different representations.
Proxy mode:
Provide a proxy for other objects to control access to that object.
Prototype:
Specify what kind of objects to create with prototype instances, and create new objects by copying these prototypes.
Mediator mode:
By encapsulating a set of object interactions with a mediation object, the mediator loosens the coupling by allowing objects to interact without explicitly, and can change their interactions independently.
Command mode:
Encapsulating a request as an object allows you to parameterize clients with different requests, queue requests, or log requests, and provides command undo and recovery capabilities.
Chain of Responsibility mode:
This avoids coupling between the sender and receiver of the request by giving multiple objects the opportunity to process the request. Connect the objects into a chain and pass the request along the chain until an object handles it.
Decorator:
Add some extra responsibilities to an object dynamically. Decorator patterns are more flexible in terms of adding functionality than subclassing.
Strategy Mode:
Define a set of algorithms, encapsulate each algorithm, and make them interchangeable.
Adapter mode:
Transform the interface of one class into another that the client expects, so that two classes that would otherwise not work together because of interface mismatches can work together.
Iterator pattern:
It provides a way to access individual elements of a container object without exposing the inner details of the object.
Composite mode:
Objects are grouped into a tree structure to represent a partial-whole hierarchy, allowing consistency in the use of individual objects and composite objects.
Observer mode:
Define a one-to-many dependency between objects so that whenever an object changes state, all dependent objects are notified and automatically updated.
Facade pattern:
It is required that communication between the outside and the inside of a subsystem must be carried out through a unified object. Facade mode provides a high-level interface that makes subsystems easier to use.
Memento mode:
Capture the internal state of an object and store the state outside of the object without breaking encapsulation. You can then restore the object to its original saved state.
Visitor Pattern:
Encapsulates operations that operate on elements of a data structure and defines new operations that operate on those elements without changing the data structure.
State mode:
Allowing an object to change its behavior when its internal state changes, the object appears to have changed its class.
Interpreter mode:
Given a language, define a representation of its grammar, and define an interpreter that uses representation to interpret sentences in the language.
Flyweight mode:
Using shared objects effectively supports a large number of fine-grained objects.
Bridge mode:
Decouple the abstraction from the implementation so that the two can vary independently.