Application architecture representation method and device, equipment, medium and product

Abstract

The invention discloses an application architecture representation method and device, equipment, a medium and a product, relates to the technical field of application architecture.The application architecture representation method, the application architecture representation device, the application architecture representation equipment, the storage medium and the computer program product comprise the steps that a platform tool called by a target application in the execution process is determined, the tool assembly is called by the platform tool, and the assembly module and the operation entity are involved in the tool assembly; constructing an architecture multi-way tree of the target application; wherein the root of the architecture multi-way tree is a target application, the first layer of tree nodes are platform tools, the second layer of tree nodes are tool components, and the third layer of tree nodes are component modules and running entities. Therefore, compared with an application function architecture diagram which only focuses on function points and a component hierarchy architecture diagram which only focuses on component hierarchies in a conventional means, the data logic of application running in the application architecture and the relationship between the running entities of the application running in the application architecture can be comprehensively expressed.

Description

Technical Field

[0001] The present application relates to the field of application architecture technology, and in particular to an application architecture representation method, an application architecture representation apparatus, an application architecture representation device, a storage medium, and a computer program product. Background Art

[0002] Currently, application architecture is often represented by two methods: application functional architecture diagram and component hierarchy architecture diagram. The former focuses on functional points, while the latter focuses on component hierarchy. However, both methods cannot represent the data logic of application operation in the application architecture and the relationship between its running entities. Summary of the invention

[0003] The main purpose of the present application is to provide an application architecture representation method, an application architecture representation apparatus, an application architecture representation device, a storage medium and a computer program product, aiming to solve the technical problem that it is difficult to represent the data logic of the application running in the application architecture and the relationship between its running entities.

[0004] To achieve the above objectives, the present application proposes a method for representing an application architecture, the method comprising:

[0005] Determine the platform tool called by the target application during execution, the tool component called by the platform tool, and the component modules and running entities involved in the tool component;

[0006] Construct an architecture multi-branch tree of the target application; wherein the root of the architecture multi-branch tree is the target application, the first-level tree nodes are the platform tools, the second-level tree nodes are the tool components, and the third-level tree nodes are the component modules and the running entities.

[0007] In one embodiment, the step of constructing the architecture multitree of the target application includes:

[0008] According to the order in which the platform tools are called in sequence, the platform tools are added to the first-level tree nodes of the architecture multi-branch tree;

[0009] According to the order in which the platform tool sequentially calls the tool components, the tool components are added to the tree nodes of the next layer of the node where the platform tool is located on the architecture multi-branch tree;

[0010] The component modules and running entities involved in the tool component are added to the next layer of tree nodes of the node where the tool component is located on the architecture multi-branch tree.

[0011] In one embodiment, the step of adding the platform tools to the first-layer tree nodes of the architecture multitree in the order of calling the platform tools in sequence includes:

[0012] If there is cross-domain transmission processing between the platform tools called in sequence, a target platform tool for implementing the cross-domain transmission processing between the platform tools is determined, and the target platform tool is added to the first-level tree nodes of the platform tools with cross-domain transmission processing.

[0013] In one embodiment, the step of adding the tool components to the tree nodes of the next layer of the node where the platform tool is located on the architecture multi-branch tree in the order in which the platform tool sequentially calls the tool components comprises:

[0014] If there is cross-domain transmission processing between the tool components called in sequence, determining the target platform tool for implementing the cross-domain transmission processing between the platform tools, and the first-layer entity object of the network device called by the target platform tool to implement the cross-domain transmission processing;

[0015] The first-layer entity object of the network device is used as a tool component of the target platform tool and added to the next-layer tree node of the node where the target platform tool is located on the architecture multi-branch tree.

[0016] In one embodiment, the step of adding the component modules and running entities involved in the tool component to the tree nodes of the next layer of the node where the tool component is located on the architecture multi-branch tree includes:

[0017] If there is cross-domain transmission processing between the tool components called in sequence, determine the target platform tool that implements the cross-domain transmission processing between the platform tools, the first-layer entity object of the network device called by the target platform tool to implement the cross-domain transmission processing, and the software carrier of the first-layer entity object of the network device;

[0018] The software carrier is used as a component module of the first-layer entity of the network device and is added to the next-layer tree node of the node where the first-layer entity object of the network device is located on the architecture multi-branch tree.

[0019] In one embodiment, the step of constructing an architecture multitree representing the application architecture of the target application comprises:

[0020] Through the architecture multi-branch tree, the platform tools sequentially called by the target application during execution, the tool components sequentially called by the platform tools, and the component modules and running entities involved in the tool components are accessed point by point.

[0021] In addition, to achieve the above-mentioned purpose, the present application also proposes an application architecture representation device, the device comprising:

[0022] A determination module, used to determine the platform tool called by the target application during execution, the tool component called by the platform tool, and the component modules and running entities involved in the tool component;

[0023] A construction module is used to construct an architecture multi-branch tree of the target application; wherein the root of the architecture multi-branch tree is the target application, the first-level tree nodes are the platform tools, the second-level tree nodes are the tool components, and the third-level tree nodes are the component modules and the running entities.

[0024] In addition, to achieve the above-mentioned purpose, the present application also proposes an application architecture representation device, which includes: a memory, a processor, and a computer program stored in the memory and executable on the processor, and the computer program is configured to implement the steps of the application architecture representation method as described above.

[0025] In addition, to achieve the above-mentioned purpose, the present application also proposes a storage medium, which is a computer-readable storage medium, and a computer program is stored on the storage medium. When the computer program is executed by a processor, the steps of the application architecture representation method described above are implemented.

[0026] In addition, to achieve the above-mentioned purpose, the present application also provides a computer program product, which includes a computer program, and when the computer program is executed by a processor, it implements the steps of the application architecture representation method described above.

[0027] One or more technical solutions proposed in this application have at least the following technical effects:

[0028] Through the platform tools called by the target application during execution, the tool components called by the platform tools, and the component modules and running entities involved in the tool components, an architecture multi-branch tree representing the application architecture of the target application is constructed, and the root and nodes of the architecture multi-branch tree are used to represent the platform tools, tool components, component modules, running entities and their respective relationships. In this way, compared with the application function architecture diagram that only focuses on function points and the component hierarchy architecture diagram that only focuses on component hierarchy in conventional means, the data logic of application operation in the application architecture and the relationship between its running entities can be fully represented. BRIEF DESCRIPTION OF THE DRAWINGS

[0029] The accompanying drawings, which are incorporated in and constitute a part of this specification, illustrate embodiments consistent with the present application and, together with the description, serve to explain the principles of the present application.

[0030] In order to more clearly illustrate the embodiments of the present application or the technical solutions in the prior art, the drawings required for use in the embodiments or the description of the prior art will be briefly introduced below. Obviously, for ordinary technicians in this field, other drawings can be obtained based on these drawings without paying any creative labor.

[0031] Figure 1A flowchart of the first embodiment of the application architecture representation method of the present application is provided;

[0032] Figure 2 This is a schematic diagram of the first layer of a multi-branch tree of an application architecture representation method embodiment of the present application;

[0033] Figure 3 This is a schematic diagram of the second layer of a multi-branch tree of an embodiment of the application architecture representation method of the present application;

[0034] Figure 4 This is a schematic diagram of the third layer of a multi-branch tree of an embodiment of the application architecture representation method of the present application;

[0035] Figure 5 This is a schematic diagram of the module structure of the application architecture representation device of the embodiment of the present application;

[0036] Figure 6 A schematic diagram of the device structure of the hardware operating environment involved in the application architecture representation method in the embodiment of the present application.

[0037] The purpose, features and advantages of this application will be further described in conjunction with the embodiments and with reference to the accompanying drawings. DETAILED DESCRIPTION

[0038] It should be understood that the specific embodiments described herein are only used to explain the technical solutions of the present application and are not used to limit the present application.

[0039] In order to better understand the technical solution of the present application, a detailed description will be given below in conjunction with the accompanying drawings and specific implementation methods.

[0040] The present application embodiment provides a method for representing an application architecture. Figure 1 , Figure 1 This is a flowchart of the first embodiment of the application architecture representation method of the present application.

[0041] In this embodiment, the method described includes steps S10 to S20:

[0042] Step S10, determining the platform tool called by the target application during execution, the tool component called by the platform tool, and the component modules and running entities involved in the tool component;

[0043] It should be noted that the execution subject of this embodiment can be a computing service device with data processing, network communication and program running functions, such as a tablet computer, a personal computer, a mobile phone, etc., or an electronic device that can realize the above functions.

[0044] In addition, it should be noted that application architecture is the content that describes the functions and technical implementation of the application system, and is used to explain and guide application implementation. In other words, application architecture usually refers to the design and organization of the entire application, including the relationship between its various components, communication methods, and data flow paths.

[0045] For example, in a typical application architecture example: the front-end application layer includes UI (User Interface), user interaction logic and front-end routing, etc., which is responsible for direct interaction with users, displaying interfaces to users and receiving user input; the back-end application layer includes business logic processing, identity authentication and authorization, API (Application Programming Interface), logging and monitoring and other functions. This layer is responsible for processing requests sent by the front-end, executing corresponding business logic, interacting with the data storage layer, and returning results to the front-end; the data storage layer is responsible for data storage and management, including databases, caches, file storage and external service integration, etc. The back-end application layer reads and modifies data through the data storage layer; the infrastructure layer includes servers, network equipment, data storage equipment and security equipment, etc., which provides the infrastructure and environment to support the entire application.

[0046] In addition, it should be noted that during the execution of the application, various platform tools may be called to implement different functions or handle specific tasks. The platform tools that may be called during the execution of the application include: 1. Operating system API: Applications usually use the API provided by the operating system to perform low-level tasks such as file operations, process management, network communication, etc., such as WinAPI on Windows, POSIX API on Linux, etc.; 2. Network library: A library or framework for handling network communications, such as Express.js in Node.js, Flask or Django in Python, Spring in Java, etc. These network library tools provide interfaces that simplify network programming, including HTTP (Hypertext Transfer Protocol). Protocol, Hypertext Transfer Protocol) request processing, WebSocket (a protocol for full-duplex communication on a single TCP connection) communication, etc.; 3. Database access library: a library or framework for interacting with the database, such as JDBC in Java, SQLAlchemy in Python, Sequelize in Node.js, etc. These database access library tools enable applications to easily perform database queries, inserts, updates, and deletes; 4. Log library: a library for recording application runtime status and events, such as Log4j in Java, the logging module in Python, winston in Node.js, etc. These log library tools help developers debug and monitor applications, as well as analyze application behavior; 5. Security library: a library for implementing security features and defense measures, such as encryption libraries, authentication libraries, Authorization library, etc. These security library tools help protect applications from various security threats, such as SQL injection, cross-site scripting attacks, etc.; 6. Testing framework: frameworks for writing and executing unit tests, integration tests, and end-to-end tests, such as JUnit, pytest, Mocha, Jest, etc. These testing framework tools help ensure the quality and stability of applications; 7. Container and orchestration tools: tools for building, deploying, and managing application containers, such as Docker, Kubernetes, etc. These containers and orchestration tools enable applications to be quickly deployed and expanded in different environments; 8. Message queues and event buses: tools for implementing asynchronous messaging and event-driven architectures, such as RabbitMQ, Kafka, Redis, etc. These message queues and event bus tools help decouple different parts of an application and achieve high reliability and scalability.

[0047] In addition, it should be noted that the tool components called by platform tools may include the following aspects: 1. Libraries and frameworks: Platform tools usually implement specific functions by calling libraries or frameworks. These libraries and frameworks provide a series of functions and interfaces. For example, if the application needs to communicate over the network, a network library or framework may be used, such as Express.js in Node.js, Flask in Python, or Spring in Java; 2. Middleware: During the operation of the application, some middleware may be used to process requests, responses, or perform other tasks. Middleware is a software component located between the application and the server to enhance the functionality or performance of the application. For example, In Web applications, middleware can be used to implement functions such as logging, authentication, and authorization; 3. Plug-ins: Some platform tools may support a plug-in system, allowing custom plug-ins to be written to extend their functionality. By using plug-ins, additional or customized functions can be added according to the needs of the application. For example, a text editor may support plug-ins to implement code auto-completion, syntax highlighting, and other functions; 4. Configuration files: Some platform tools may need to be configured through configuration files to specify their behavior or parameters. Configuration files usually contain various settings, such as server address, database connection information, log level, etc. By modifying the configuration file, the behavior of the platform tool can be customized to adapt to specific application scenarios or requirements.

[0048] In addition, it should be noted that the component modules involved in the tool component include: 1. Core function module: The core function module of the platform tool is usually its most important component, responsible for realizing the main functions of the tool. For example, the core function module of a network framework may include routers, request processors, response generators, etc.; 2. Additional function module: In addition to the core functions, the platform tool may also provide some additional function modules to expand the functions of the tool or provide additional features. These function modules are usually optional and can be used selectively as needed. For example, a Web framework may provide additional modules for form validation, session management, caching and other functions; 3. Interface and adapter module: Platform tools usually define a series of interfaces and adapters for interacting or extending with other components. Through these interfaces and adapters, customized functions can be implemented or third-party components can be integrated. For example, a database access library may define a series of database connection interfaces and various database adapters to support different types of databases.

[0049] In addition, it should be noted that the running entities involved in the tool components include: 1. Application entity: Application entity refers to a specific application or service that uses the platform tool. In the application, the required business logic or specific tasks can be implemented by calling the functions provided by the platform tool. For example, a Web application can serve as an application entity to process HTTP requests and generate responses by calling the API provided by the Web framework; 2. Service entity: Service entity refers to a service or microservice running in a distributed system. These services are usually deployed and run independently, communicate with other services through network interfaces, and develop, deploy and manage these services, as well as realize communication and collaboration between services. For example, a microservice architecture based on container technology can use Docker and Kubernetes to manage the deployment and operation of services.

[0050] In the process of platform tool invocation, component modules and running entities work together to realize the functions of applications or services. Further, the running entities of applications usually include the following aspects: 1. Client device: This is the device used by the end user of the application, which can be a desktop computer, laptop, smart phone, tablet or other type of device. The front-end application layer runs on the client device, which is responsible for displaying the interface to the user and receiving the user's input; 2. Server: The server is where the back-end part of the application runs, which can be a physical server or a cloud server. The back-end application layer, data storage layer and infrastructure layer are usually deployed on the server. The server is responsible for receiving requests from client devices, executing corresponding business logic, interacting with the data storage layer, and returning results to the client device; 3. Database: The database is where application data is stored, which can be a relational database, a NoSQL non-relational database or other types of databases. The data storage layer is responsible for interacting with the database, reading and modifying data; 4. Network equipment: Network equipment includes routers, switches, etc., which are responsible for connecting client devices and servers to ensure that data can be transmitted between them; 5. External services: External services are other services or systems that applications may rely on, such as third-party APIs, message queues, mail services, etc. The service integration component is responsible for integrating and interacting with external services. These running entities together constitute the entire running environment of the application, ensuring that the application can run normally and provide the required functions.

[0051] Step S20, constructing an architecture multi-branch tree of the target application; wherein the root of the architecture multi-branch tree is the target application, the first-level tree nodes are the platform tools, the second-level tree nodes are the tool components, and the third-level tree nodes are the component modules and the running entities.

[0052] In the constructed architecture multi-branch tree representing the application architecture of the target application, the root is the target application, the first-level tree nodes are platform tools, the second-level tree nodes are tool components, and the third-level tree nodes are component modules and the running entities.

[0053] Exemplarily, the depth of the multi-branch tree T is denoted as S, the maximum width is denoted as K, the depth starts from 0, the s-th layer and the k-th tree node is denoted as Tsk, then s is greater than or equal to 0 and less than S, and k is greater than or equal to 1 and less than or equal to K.

[0054] In a feasible implementation, step S20 may include steps A11 to A13:

[0055] Step A11: Add the platform tools to the first-level tree nodes of the architecture multitree in the order in which the platform tools are called.

[0056] Exemplarily, the target application code is used as the root of the multitree, with a depth of 0. Then, the platform tools involved in the execution of the target application are exhaustively listed, and in the execution order from left to right, as a multitree with a depth of 1 node and a width increasing from 1 from left to right.

[0057] For example, for target application a, its code is A, and its execution platform tools involve ETL (extract, transform, load) tool 1, Hadoop platform (distributed system infrastructure developed by Apache Foundation), GP database (greenplum relational database) and WEB server 1. The execution order of platform tools in the target application implementation process is ETL tool 1, Hadoop platform, ETL tool 1, GP database, ETL tool 1, WEB server 1. If the above objects are all in the same domain and each host is interconnected by default, then the multi-branch tree of the target application is A in T01, ETL tool 1 in T11, Hadoop platform in T12, ETL tool 1 in T13, GP database in T14, ETL tool 1 in T15, and WEB server 1 in T16.

[0058] In the above, a multi-branch tree relationship between the application and the platform tool is constructed through step A11, and the correlation relationship between the execution order of the application and the execution order of the platform tool is interpreted.

[0059] In a feasible implementation manner, step A11 includes:

[0060] If there is cross-domain transmission processing between the platform tools called in sequence, a target platform tool for implementing the cross-domain transmission processing between the platform tools is determined, and the target platform tool is added to the first-level tree nodes of the platform tools with cross-domain transmission processing.

[0061] It should be noted that for ultra-large-scale systems such as cloud computing, big data and edge computing systems, the network, as a core requirement affecting the system architecture, needs to be one of the objects of architecture analysis. In this embodiment, different network domains (network connections that require customized network policies) are abstracted as execution platform tool objects and participate in the numbering in the multi-branch tree.

[0062] For example, ETL tool 1, Hadoop platform, and GP database are located in different domains, which is cross-domain transmission processing. ETL tool 1 and WEB server 1 are located in the same domain, which is intra-domain transmission. Define the cross-network transmission object between ETL tool 1 and Hadoop platform as NW1, and the cross-network transmission object between ETL tool 1 and GP database as NW2. Figure 2 , taking NW1 and NW2 as target platform tools, the multitree node definition of the application is changed as follows: T01 is A, T11 is ETL tool 1, T12 is NW1, T13 is Hadoop platform, T14 is ETL tool 1, T15 is NW2, T16 is GP database, T17 is ETL tool 1, and T18 is WEB server 1.

[0063] Step A12: according to the order in which the platform tool calls the tool components in sequence, the tool components are added to the tree nodes of the next layer of the node where the platform tool is located on the architecture multi-branch tree.

[0064] Exemplarily, the tool components involved in the actual running entity of the target application are recorded as tree nodes with a depth of 2. The specific marking method is to traverse the running tool component objects one by one in the tree nodes with a depth of 1, and then number the nodes at the same layer.

[0065] The tool components of each platform are determined by their own properties, and their properties are clear after the platform is launched. For example, on the Hadoop platform, the tool components used by batch tasks are LDAP, Kerberos, Ranger, Yarn, HDFS, and MapReduce. For batch task applications, when the node with a depth of 1 generated in step A11 is the Hadoop platform, the corresponding node with a depth of 2 generated in step A12 is LDAP, Kerberos, Ranger, Yarn, HDFS, and MapReduce, which are recorded as H1, H2, H3, H4, H5, and H6.

[0066] For example, referring to the application A in the above example, ETL tool 1, Hadoop platform, and GP database are located in different domains, which belongs to cross-domain transmission processing. When ETL tool 1 and WEB server 1 are located in the same domain, T01 is A, T11 is ETL tool 1, T12 is NW1, T13 is Hadoop platform, T14 is ETL tool 1, T15 is NW2, T16 is GP database, T17 is ETL tool 1, and T18 is WEB server 1. Assuming that ETL tool 1 to Hadoop platform involves components M11 and M12, ETL tool 1 to GP database involves components M11 and M13, GP database involves components GP1 and GP2, ETL tool 1 to WEB server involves component M14, and WEB server operation involves component WEB1, then refer to Figure 3 , the tree nodes with a depth of 2 are sorted as {T21, T22, T23, T24, T25, T26, T27, T28, T29, T210, T211, T212} = {M11, M12, H1, H2, H3, H4, H5, H6, M11, M13, GP1, GP2, M14, WEB1}.

[0067] In the above, through step A12, on the basis of building the relationship between the application and the platform tool, a multi-tree relationship between the platform tool and the tool component is built, and the building process depends on the internal execution order of the application calling the tool component.

[0068] In a feasible implementation manner, step A12 includes:

[0069] If there is cross-domain transmission processing between the tool components called in sequence, determining the target platform tool for implementing the cross-domain transmission processing between the platform tools, and the first-layer entity object of the network device called by the target platform tool to implement the cross-domain transmission processing;

[0070] The first-layer entity object of the network device is used as a tool component of the target platform tool and added to the next-layer tree node of the node where the target platform tool is located on the architecture multi-branch tree.

[0071] That is to say, the first-layer entity object of the network device called by the target platform tool to implement cross-domain transmission processing is added as a new tool component to the second-layer tree nodes of the architecture multi-branch tree between the second-layer tree nodes of the existing tool components in the order of calling.

[0072] It should be noted that for virtualized platform objects transmitted across network domains, the tool component objects are the first-layer entity objects of network devices actually involved in network transmission. For example, if two switches are required to go from network domain 1 to network domain 2, the first-layer entity objects of network devices mentioned in step A12 are switch 1 and switch 2.

[0073] Step A13: Add the component modules and running entities involved in the tool component to the next layer of tree nodes of the node where the tool component is located on the architecture multi-branch tree.

[0074] For example, refer to Figure 4 , the component modules actually called by the tool component with a depth of 2 are listed to form a tree node with a depth of 3, and the running entities of the above nodes are used as tree nodes with a depth of 4, where the component modules refer to the processes actually running at the OS (Operating System) layer.

[0075] For example, HDFS in the Hadoop platform component has two components with a depth of 3, namely {T31, T32} = {NameNode, DataNode}. For a single namespace, the core component modules are NameNode and DataNode. NameNode has only two IPs, and the encodings of these two IPs will be used as the tree nodes with a depth of 4 corresponding to the NameNode module, namely T41 and T42, and the node with a depth of 4 corresponding to DataNode is the set of its IPs, T43, T44, ... T4K, where K is the number of DataNode nodes; for multiple namespaces, the core component modules include Router, NameNode, and DataNode. The tree node with a depth of 4 corresponding to Router is the encoding of the IP where its process is located, and the tree nodes with a depth of 4 corresponding to NameNode and DataNode are the encodings of the IPs where multiple NameNode and multiple DataNode processes are located. Other tool component modules refer to the Hadoop platform.

[0076] In the above, through step A13, a multi-branch tree relationship between components and modules is constructed to identify the association relationship between the running carrier and the running entity.

[0077] In a feasible implementation manner, step A13 includes:

[0078] If there is cross-domain transmission processing between the tool components called in sequence, determine the target platform tool that implements the cross-domain transmission processing between the platform tools, the first-layer entity object of the network device called by the target platform tool to implement the cross-domain transmission processing, and the software carrier of the first-layer entity object of the network device;

[0079] The software carrier is used as a component module of the first-layer entity of the network device and is added to the next-layer tree node of the node where the first-layer entity object of the network device is located on the architecture multi-branch tree.

[0080] For virtualized platform objects that are transmitted across network domains, their component module objects are software carriers of the first-layer entity objects that are actually involved in network transmission. For example, if switch 1 only involves two switching routers and a network card module, its component modules are divided into switching router 1, switching router 2, and module. The corresponding tree node with a depth of 3 is switch 1, and the corresponding tree nodes with a depth of 4 are the codes corresponding to switching router 1, switching router 2, and the codes corresponding to the module in the network card.

[0081] In a feasible implementation manner, step S20 includes:

[0082] Through the architecture multi-branch tree, the platform tools sequentially called by the target application during execution, the tool components sequentially called by the platform tools, and the component modules and running entities involved in the tool components are accessed point by point.

[0083] Through the above steps S10 to S20, the multi-branch tree relationship construction of applications, platforms, tool components and modules is realized.

[0084] In this embodiment, a general association method is proposed, which uses a traversable data structure multi-branch tree to represent platform component tools and the applications running on them, as well as the networking logic of their operation and maintenance objects, thereby converting large-scale software systems in reality into data sets that can be accessed point by point through the structural characteristics of the multi-branch tree.

[0085] As described above, this application proposes a method for representing an application architecture based on a multi-branch tree. By horizontally traversing the platform tools called by the application, and then vertically traversing and associating tool components, component modules and their running entity objects based on the characteristics of the platform tools, a multi-branch tree for displaying the application architecture is formed. The purpose is to solve the technical problem that it is difficult to accurately represent the relationship between application running modules and entities in, for example, ultra-large-scale cloud SAAS (Software as a Service) application systems. Compared with the conventional technical scheme, the description process of the execution relationship of the running program code unit is formed based on the program's interface calling sequence. Although the data relationship is described based on the object calling sequence, in the conventional technical scheme, the API is only valid for programs using the specified protocol, but the method described in the present application does not rely on the automatic acquisition of task ID attributes and their mutual relationships, and is more versatile and has a wider range of applications. Moreover, the present application can realize the association between soft and hard entities, and its versatility is wider, especially suitable for the construction of multi-branch trees of architecture relationships in ultra-large-scale systems and highly integrated systems; further, because the present application uses the execution sequence of the application architecture platform tool and the running logic of the tool components, it is more suitable for large-scale distributed clusters, especially big data tools and their business operation scenarios. Application architecture acquisition and display; finally, the method described in the present application has the characteristics of simple construction unit method, support for customization, and reproducibility, and is suitable for automatic representation of module running entities in different systems and applications.

[0086] It should be noted that the above examples are only used to understand the present application and do not constitute a limitation on the method of representing the application architecture of the present application. More simple transformations based on this technical concept are all within the scope of protection of the present application.

[0087] This application also provides an application architecture representation device, please refer to Figure 5 , the device comprises:

[0088] A determination module 10 is used to determine the platform tool called by the target application during execution, the tool component called by the platform tool, and the component modules and running entities involved in the tool component;

[0089] Construction module 20 is used to construct an architecture multi-branch tree of the target application; wherein the root of the architecture multi-branch tree is the target application, the first-level tree nodes are the platform tools, the second-level tree nodes are the tool components, and the third-level tree nodes are the component modules and the running entities.

[0090] In one embodiment, the building block 10 is further used to:

[0091] According to the order in which the platform tools are called in sequence, the platform tools are added to the first-level tree nodes of the architecture multi-branch tree;

[0092] According to the order in which the platform tool sequentially calls the tool components, the tool components are added to the tree nodes of the next layer of the node where the platform tool is located on the architecture multi-branch tree;

[0093] The component modules and running entities involved in the tool component are added to the next layer of tree nodes of the node where the tool component is located on the architecture multi-branch tree.

[0094] In one embodiment, the building block 10 is further used to:

[0095] If there is cross-domain transmission processing between the platform tools called in sequence, a target platform tool for implementing the cross-domain transmission processing between the platform tools is determined, and the target platform tool is added to the first-level tree nodes of the platform tools with cross-domain transmission processing.

[0096] In one embodiment, the building block 10 is further used to:

[0097] If there is cross-domain transmission processing between the tool components called in sequence, determining the target platform tool for implementing the cross-domain transmission processing between the platform tools, and the first-layer entity object of the network device called by the target platform tool to implement the cross-domain transmission processing;

[0098] The first-layer entity object of the network device is used as a tool component of the target platform tool and added to the next-layer tree node of the node where the target platform tool is located on the architecture multi-branch tree.

[0099] In one embodiment, the building block 10 is further used to:

[0100] If there is cross-domain transmission processing between the tool components called in sequence, determine the target platform tool that implements the cross-domain transmission processing between the platform tools, the first-layer entity object of the network device called by the target platform tool to implement the cross-domain transmission processing, and the software carrier of the first-layer entity object of the network device;

[0101] The software carrier is used as a component module of the first-layer entity of the network device and is added to the next-layer tree node of the node where the first-layer entity object of the network device is located on the architecture multi-branch tree.

[0102] In one embodiment, the application architecture representation device further includes an access module 30, which is used to:

[0103] Through the architecture multi-branch tree, the platform tools sequentially called by the target application during execution, the tool components sequentially called by the platform tools, and the component modules and running entities involved in the tool components are accessed point by point.

[0104] The application architecture representation device provided by the present application adopts the application architecture representation method in the above embodiment, which can solve the technical problem of difficulty in representing the data logic of application operation in the application architecture and the relationship between its operation entities. Compared with the prior art, the beneficial effects of the application architecture representation device provided by the present application are the same as the beneficial effects of the application architecture representation method provided by the above embodiment, and other technical features in the application architecture representation device are the same as the features disclosed in the above embodiment method, which will not be repeated here.

[0105] The present application provides an application architecture representation device, which includes: at least one processor; and a memory communicatively connected to the at least one processor; wherein the memory stores instructions executable by the at least one processor, and the instructions are executed by the at least one processor so that the at least one processor can execute the application architecture representation method in the above-mentioned embodiment 1.

[0106] Reference below Figure 6 , which shows a schematic diagram of the structure of an application architecture representation device suitable for implementing an embodiment of the present application. The application architecture representation device in the embodiment of the present application may include but is not limited to mobile terminals such as mobile phones, laptop computers, digital broadcast receivers, PDAs (Personal Digital Assistants), PADs (Portable Application Descriptions), PMPs (Portable Media Players), vehicle-mounted terminals (such as vehicle-mounted navigation terminals), etc., and fixed terminals such as digital TVs, desktop computers, etc. Figure 6 The application architecture representation device shown is only an example and should not bring any limitation to the functions and scope of use of the embodiments of the present application.

[0107] like Figure 6As shown, the application architecture representation device may include a processing device 1001 (e.g., a central processing unit, a graphics processor, etc.), which can perform various appropriate actions and processes according to a program stored in a read-only memory (ROM: Read Only Memory) 1002 or a program loaded from a storage device 1003 to a random access memory (RAM: Random Access Memory) 1004. In RAM1004, various programs and data required for the operation of the application architecture representation device are also stored. The processing device 1001, ROM1002, and RAM1004 are connected to each other through a bus 1005. An input / output (I / O) interface 1006 is also connected to the bus. Generally, the following systems can be connected to the I / O interface 1006: an input device 1007 including, for example, a touch screen, a touch pad, a keyboard, a mouse, an image sensor, a microphone, an accelerometer, a gyroscope, etc.; an output device 1008 including, for example, a liquid crystal display (LCD: Liquid Crystal Display), a speaker, a vibrator, etc.; a storage device 1003 including, for example, a magnetic tape, a hard disk, etc.; and a communication device 1009. The communication device 1009 can allow the application architecture representation device to communicate with other devices wirelessly or by wire to exchange data. Although the figure shows an application architecture representation device with various systems, it should be understood that it is not required to implement or have all the systems shown. More or fewer systems can be implemented or have alternatively.

[0108] In particular, according to the embodiments disclosed in the present application, the process described above with reference to the flowchart can be implemented as a computer software program. For example, the embodiments disclosed in the present application include a computer program product, which includes a computer program carried on a computer-readable medium, and the computer program includes a program code for executing the method shown in the flowchart. In such an embodiment, the computer program can be downloaded and installed from a network through a communication device, or installed from a storage device 1003, or installed from a ROM 1002. When the computer program is executed by the processing device 1001, the above-mentioned functions defined in the method of the embodiment disclosed in the present application are executed.

[0109] The application architecture representation device provided by the present application adopts the application architecture representation method in the above embodiment, which can solve the technical problem of difficulty in representing the data logic of application operation in the application architecture and the relationship between its operation entities. Compared with the prior art, the beneficial effects of the application architecture representation device provided by the present application are the same as the beneficial effects of the application architecture representation method provided by the above embodiment, and other technical features in the application architecture representation device are the same as the features disclosed in the method of the previous embodiment, which will not be repeated here.

[0110] It should be understood that the various parts disclosed in this application can be implemented by hardware, software, firmware or a combination thereof. In the description of the above embodiments, specific features, structures, materials or characteristics can be combined in any one or more embodiments or examples in a suitable manner.

[0111] The above is only a specific implementation of the present application, but the protection scope of the present application is not limited thereto. Any person skilled in the art who is familiar with the present technical field can easily think of changes or substitutions within the technical scope disclosed in the present application, which should be included in the protection scope of the present application. Therefore, the protection scope of the present application should be based on the protection scope of the claims.

[0112] The present application provides a computer-readable storage medium having computer-readable program instructions (ie, computer programs) stored thereon, wherein the computer-readable program instructions are used to execute the application architecture representation method in the above-mentioned embodiment.

[0113] The computer-readable storage medium provided in the present application may be, for example, a USB flash drive, but is not limited to electrical, magnetic, optical, electromagnetic, infrared, or semiconductor systems, systems or devices, or any combination of the above. More specific examples of computer-readable storage media may include, but are not limited to: an electrical connection with one or more wires, a portable computer disk, a hard disk, a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disk read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the above. In this embodiment, the computer-readable storage medium may be any tangible medium containing or storing a program that can be used by or in combination with an instruction execution system, system or device. The program code contained on the computer-readable storage medium may be transmitted using any appropriate medium, including but not limited to: wires, optical cables, RF (Radio Frequency), etc., or any suitable combination of the above.

[0114] The computer-readable storage medium may be included in the application architecture representation device; or may exist independently without being assembled into the application architecture representation device.

[0115] The above-mentioned computer-readable storage medium carries one or more programs. When the above-mentioned one or more programs are executed by the application architecture representation device, the application architecture representation device: determines the platform tools that are sequentially called by the target application during execution, the tool components that are sequentially called by the platform tools, and the component modules and running entities involved in the tool components; constructs an architecture multi-branch tree representing the application architecture of the target application; wherein the root of the architecture multi-branch tree is the target application, the first-level tree nodes are the platform tools, the second-level tree nodes are the tool components, and the third-level tree nodes are the component modules and the running entities.

[0116] Computer program code for performing the operations of the present application may be written in one or more programming languages ​​or a combination thereof, including object-oriented programming languages ​​such as Java, Smalltalk, C++, and conventional procedural programming languages ​​such as "C" or similar programming languages. The program code may be executed entirely on the user's computer, partially on the user's computer, as a separate software package, partially on the user's computer and partially on a remote computer, or entirely on a remote computer or server. In the case of a remote computer, the remote computer may be connected to the user's computer through any type of network, including a local area network (LAN) or a wide area network (WAN), or may be connected to an external computer (e.g., via the Internet using an Internet service provider).

[0117] The flow chart and block diagram in the accompanying drawings illustrate the possible architecture, function and operation of the system, method and computer program product according to various embodiments of the present application. In this regard, each square box in the flow chart or block diagram can represent a module, a program segment or a part of a code, and the module, the program segment or a part of the code contains one or more executable instructions for realizing the specified logical function. It should also be noted that in some alternative implementations, the functions marked in the square box can also occur in a sequence different from that marked in the accompanying drawings. For example, two square boxes represented in succession can actually be executed substantially in parallel, and they can sometimes be executed in the opposite order, depending on the functions involved. It should also be noted that each square box in the block diagram and / or flow chart, and the combination of the square boxes in the block diagram and / or flow chart can be implemented with a dedicated hardware-based system that performs a specified function or operation, or can be implemented with a combination of dedicated hardware and computer instructions.

[0118] The modules involved in the embodiments described in this application may be implemented by software or hardware, wherein the name of the module does not constitute a limitation on the unit itself in some cases.

[0119] The readable storage medium provided by the present application is a computer-readable storage medium, which stores computer-readable program instructions (i.e., computer programs) for executing the above-mentioned application architecture representation method, and can solve the technical problem of difficulty in representing the data logic of application operation in the application architecture and the relationship between its operation entities. Compared with the prior art, the beneficial effects of the computer-readable storage medium provided by the present application are the same as the beneficial effects of the application architecture representation method provided by the above-mentioned embodiment, and will not be repeated here.

[0120] The present application also provides a computer program product, including a computer program, which implements the steps of the above-mentioned application architecture representation method when executed by a processor.

[0121] The computer program product provided by the present application can solve the technical problem of difficulty in representing the data logic of application operation and the relationship between its operation entities in the application architecture. Compared with the prior art, the beneficial effects of the computer program product provided by the present application are the same as the beneficial effects of the application architecture representation method provided by the above embodiment, and will not be repeated here.

[0122] The above descriptions are only some embodiments of the present application, and are not intended to limit the patent scope of the present application. All equivalent structural changes made using the contents of the present application specification and drawings under the technical concept of the present application, or direct / indirect applications in other related technical fields are included in the patent protection scope of the present application.

Claims

1. A method for representing an application architecture, characterized in that: The method includes: Determine the platform tool called by the target application during execution, the tool component called by the platform tool, and the component modules and running entities involved in the tool component; Construct an architecture multi-branch tree of the target application; wherein the root of the architecture multi-branch tree is the target application, the first-level tree nodes are the platform tools, the second-level tree nodes are the tool components, and the third-level tree nodes are the component modules and the running entities.

2. The method according to claim 1, characterized in that The step of constructing the architecture multitree of the target application comprises: According to the order in which the platform tools are called in sequence, the platform tools are added to the first-level tree nodes of the architecture multi-branch tree; According to the order in which the platform tool sequentially calls the tool components, the tool components are added to the tree nodes of the next layer of the node where the platform tool is located on the architecture multi-branch tree; The component modules and running entities involved in the tool component are added to the next layer of tree nodes of the node where the tool component is located on the architecture multi-branch tree.

3. The method according to claim 2, characterized in that The step of adding the platform tools to the first-layer tree nodes of the architecture multitree in the order of calling the platform tools in sequence comprises: If there is cross-domain transmission processing between the platform tools called in sequence, a target platform tool for implementing the cross-domain transmission processing between the platform tools is determined, and the target platform tool is added to the first-level tree nodes of the platform tools with cross-domain transmission processing.

4. The method according to claim 2, characterized in that The step of adding the tool components to the tree nodes of the next layer of the node where the platform tool is located on the architecture multi-branch tree in the order in which the platform tool sequentially calls the tool components comprises: If there is cross-domain transmission processing between the tool components called in sequence, determining the target platform tool for implementing the cross-domain transmission processing between the platform tools, and the first-layer entity object of the network device called by the target platform tool to implement the cross-domain transmission processing; The first-layer entity object of the network device is used as a tool component of the target platform tool and added to the next-layer tree node of the node where the target platform tool is located on the architecture multi-branch tree.

5. The method according to claim 2, characterized in that The step of adding the component modules and running entities involved in the tool component to the tree node of the next layer of the node where the tool component is located on the architecture multi-branch tree includes: If there is cross-domain transmission processing between the tool components called in sequence, determine the target platform tool that implements the cross-domain transmission processing between the platform tools, the first-layer entity object of the network device called by the target platform tool to implement the cross-domain transmission processing, and the software carrier of the first-layer entity object of the network device; The software carrier is used as a component module of the first-layer entity of the network device and is added to the next-layer tree node of the node where the first-layer entity object of the network device is located on the architecture multi-branch tree.

6. The method according to claim 1, characterized in that The step of constructing an architecture multitree representing the application architecture of the target application comprises: Through the architecture multi-branch tree, the platform tools sequentially called by the target application during execution, the tool components sequentially called by the platform tools, and the component modules and running entities involved in the tool components are accessed point by point.

7. An application architecture representation device, characterized in that: The device comprises: A determination module, used to determine the platform tool called by the target application during execution, the tool component called by the platform tool, and the component modules and running entities involved in the tool component; A construction module is used to construct an architecture multi-branch tree of the target application; wherein the root of the architecture multi-branch tree is the target application, the first-level tree nodes are the platform tools, the second-level tree nodes are the tool components, and the third-level tree nodes are the component modules and the running entities.

8. An application architecture representation device, characterized in that: The device comprises: a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the computer program is configured to implement the steps of the application architecture representation method according to any one of claims 1 to 6.

9. A storage medium, characterized in that: The storage medium is a computer-readable storage medium, and a computer program is stored on the storage medium. When the computer program is executed by a processor, the steps of the application architecture representation method according to any one of claims 1 to 6 are implemented.

10. A computer program product, characterized in that The computer program product comprises a computer program, and when the computer program is executed by a processor, the steps of the application architecture representation method according to any one of claims 1 to 6 are implemented.

Images