Shulou(Shulou.com)11/24 Report--

Hello everyone, I am here every week to accompany you in the progress of the network manager ~, this time we continue the learning journey of design patterns. What we need to learn this time is the combination pattern, which is not very commonly used when doing business development, but it is necessary to deal with some specific data structures.

At the same time, understanding the principle of the combination pattern is also helpful to improve your data structure and algorithm, and more importantly, it can make you understand some truth in the workplace. You will understand after reading the article, 😉.

What is the combination pattern combination pattern (Composite Pattern), also known as the part-whole (Part-Whole) pattern, its purpose is to make customers consistent in the use of single object and composite object, which is a structural design pattern, by representing a single object (leaf node) and a composite object (branch node) with the same interface.

The use of the application scene composition pattern requires that the entities in the business scene must be able to be represented as a tree structure, and the combination pattern organizes a group of objects into a tree structure. The client (the user of the code) can treat both a single object and the combined object as nodes in the tree to unify the processing logic, and make use of the characteristics of the tree structure to transform the processing of the tree and sub-tree into the recursive processing of leaf nodes. Simplify the code implementation in turn.

From the above description, we can immediately think that the operation of hierarchical things such as file systems and corporate organizational structures will be more suitable for the application of composition patterns.

The structure of combinatorial patterns

The combination pattern consists of the following roles:

Component: a component is an interface that describes the operations to be implemented by both a single object and a composite object in the tree.

Leaf node (Leaf): a single object node, which is the basic structure of the tree, does not contain child nodes, so the work cannot be assigned, and the leaf node will eventually complete most of the actual work.

Composite objects (Composite) are conformant objects that contain subitems such as leaf nodes or other composite objects. A composite object does not know the specific class to which its subproject belongs, it only interacts with its subproject through a common component interface.

Client (Client): interacts with all projects through component interfaces. Therefore, the client can interact with simple or complex objects in the tree structure in the same way.

The code implementation of the combination pattern below uses an example of the organizational structure of a company to demonstrate how to implement the composition pattern with code.

We all know that the organizational structure of large companies can be very complex, often by the group head office-- > branch, each level of the company has different departments, for example, the head office has a finance department, and so will the branch. Branches tend to be more traditional, and large Internet companies may be divided according to BG and BU, but they all have the same meaning in the display hierarchy.

Let's take a look at this example, using code in the Go language to implement the composition pattern. First of all, we define an organization's behavior interface, which can be implemented as large as the head office as small as a department:

/ / represents the interface of the organization type Organization interface {display () duty ()} for simple demonstration here, two methods are provided in the interface, one is the method display () that prints out one's own organizational structure, and the other is the method duty () that shows the responsibilities of the organization. Next, define and implement the behavior of the composite object:

/ / the complete runnable source code used in this article is to go to the official account "bi bi" to send [design pattern] to receive "type CompositeOrganization struct {orgName string depth int list [] Organization} func NewCompositeOrganization (name string, depth int) * CompositeOrganization {return & CompositeOrganization {name, depth). [] Organization {}} func (c * CompositeOrganization) add (org Organization) {if c = = nil {return} c.list = end (c.list, org)} func (c * CompositeOrganization) remove (org Organization) {if c = = nil {return} for I, val: = range c.list {if val = = org {c.list = end (c.list [: I], c.list [I + 1:]...) Return} return} func (c * CompositeOrganization) display () {if c = = nil {return} fmt.Println (strings.Repeat ("-", c.depth * 2), "", c.orgName) for _, val: = range c.list {val.display ()}} func (c * CompositeOrganization) duty () {if c = nil {return} for _ Val: = range c.list {val.duty ()}} combined objects are used to represent organizations with subordinate departments As you can see in the code, it holds a list of [] Organization types, where its subordinate organizations are stored. The implementation of display and duty of composite objects completely entrusts the work to their subordinate organizations, which is also the characteristic of the combination pattern.

Let's take a look at the type implementation of the human resources and finance departments of the two functional departments.

/ / Leaf object-Human Resources Department "the complete runnable source code used in this article goes to the official account" bi Meng "to send [design pattern] and you can get" type HRDOrg struct {orgName string depth int} func (o * HRDOrg) display () {if o = = nil {return} fmt.Println (strings.Repeat ("-", o.depth * 2), "" O.orgName)} func (o * HRDOrg) duty () {if o = = nil {return} fmt.Println (o.orgName, "staff recruitment and training Management")} / / Leaf object-Finance Department type FinanceOrg struct {orgName string depth int} func (f * FinanceOrg) display () {if f = = nil {return} fmt.Println (strings.Repeat ("-", f.depth * 2), "" F.orgName)} func (f * FinanceOrg) duty () {if f = = nil {return} fmt.Println (f.orgName, "staff recruitment and training Management")} as long as we assemble the structure of the organizational structure in the client No matter how many layers of organization there are, the client's call to the entire organization will not change.

Func main () {root: = NewCompositeOrganization ("Beijing head Office", 1) root.add (& HRDOrg {orgName: "head Office Human Resources Department", depth: 2}) root.add (& FinanceOrg {orgName: "head Office Finance Department", depth: 2}) compSh: = NewCompositeOrganization ("Shanghai Branch", 2) compSh.add (& HRDOrg {orgName: "Shanghai Branch Human Resources Department" Depth: 3}) compSh.add (& FinanceOrg {orgName: "Finance Department of Shanghai Branch", depth: 3}) root.add (compSh) compGd: = NewCompositeOrganization ("Guangdong Branch", 2) compGd.add (& HRDOrg {orgName: "Human Resources Department of Guangdong Branch", depth: 3}) compGd.add (& FinanceOrg {orgName: "Finance Department of Nanjing Office" Depth: 3}) root.add (compGd) fmt.Println ("organizational structure:") root.display () fmt.Println ("responsibilities of each organization:") root.duty ()} composition pattern is structurally similar to the decorator pattern we learned in the previous section. Let's talk about the difference between them.

The difference between composition and decorator composition pattern and decorator pattern are similar in structure, with very similar class structure (the class diagram similar to the combination pattern is that I changed the name of the method under the Copy decorator pattern.) But there is a difference in the use intention between the two.

Composition mode: provides a unified interface for leaf objects and composition objects, and leaf objects share the work that composition objects need to do. In fact, the combination object is to assign a job, and after the following work is done, it will be returned (remitted) to the upper caller, similar to those combinations in the company.

Decorator mode: the decorator belongs to the type of eldest brother and younger brother, and the core work is done by the younger brother (the younger brother is the object to be decorated), but the eldest brothers will help you do things other than your work, such as what your Mentor, project manager and leaders in the company do is to enhance you, you can understand them as your decorator 😉.

To put it beside the point, if your Mentor and leaders did not enhance you, then they rated you P7 higher than your interview level. I hope that after you come in, you can fight and grow up quickly. At the P7 level, you can't just get things done. You need to have the ability to think systematically, what is its value, do you make barriers to form core competitiveness, and do you precipitate a set of reusable physical data and methodologies? . (there are too many words, please search the full version by yourself)

To summarize the advantages of the combination model, there are two main points.

To implement a tree-like structure, you can clearly define complex objects at various levels, representing all or part of the object hierarchy.

Simplify the client code, let the client ignore the hierarchical differences, and facilitate the control of the whole hierarchical structure.

In fact, the composition pattern is not so much a design pattern as an abstraction of the data structure and algorithm of the business scenario, the data in the scene can be represented as a tree structure, and the logic of business requirements can be realized through the recursive traversal algorithm of the tree.

This article comes from the official account of Wechat: bi ID:kevin_tech, author: KevinYan11

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.