KR102852202B1 - Service providing method, program and device for generating api with low code - Google Patents

Abstract

A service providing method for generating an API (Application Programming Interface) using low code includes a step of defining a layer including a basic layer, a combination layer that organizes the basic layer, and an API that organizes the combination layer; a step of receiving a step of setting the type and order of layers from an APP provider; a step of generating an API according to the type and order of layers set by the APP provider; and a step of sequentially executing the layers included in the generated API.

Description

Service providing method, program, and device for generating API with low code {SERVICE PROVIDING METHOD, PROGRAM, AND DEVICE FOR GENERATING API WITH LOW CODE}

The present invention relates to a method for generating an API, and more particularly, to a method, program, and device for providing an API generation service using low code.

Recently, interest in coding for software and application development has been increasing. However, developing software or apps through coding is not a simple task, so only a select few developers with specialized knowledge have been able to master the art of coding and develop software or apps.

However, as demand for coding grows, so does the need for tools that facilitate easy coding. Low-code and no-code approaches are gaining attention as new alternatives. Low-code refers to developing software or apps using minimal code, while no-code refers to developing software or apps without using any code at all. These low-code and no-code approaches have made software and app development faster and easier.

Therefore, there is a need for a service that creates APIs in a low-code or no-code manner for companies that do not have professional developers or individuals without specialized coding knowledge.

Patent Registration No. 2483310

The present invention has been proposed to solve the above problems, and aims to provide a method, program, and device for developing APIs more easily and quickly by providing a service for generating APIs with low code.

The technical problem to be solved by the present invention is not limited to the technical problem mentioned above, and may include various technical problems within a scope obvious to a person skilled in the art from the contents described below.

A service providing method for generating an API (Application Programming Interface) with low code according to embodiments of the present invention may include a step of defining a layer including a basic layer, a combination layer that organizes the basic layer, and an API that organizes the combination layer; a step of receiving a step of setting the type and order of the layers from an APP provider; a step of generating an API according to the type and order of the layers set by the APP provider; and a step of sequentially executing the layers included in the generated API.

In one embodiment, the logic of the API may vary depending on the arrangement of the layers.

In one embodiment, the basic layer is the minimum unit of the logic executable on the server, the combination layer is a layer formed by combining a plurality of basic layers, and the API may be a layer formed by combining a plurality of combination layers.

In one embodiment, the data type of the layer may be a reference type.

In one embodiment, if the types and order of the layers included in the logic change, it can be applied to the API without runtime interruption.

In one embodiment, the method may further include the steps of: receiving API request information; creating shared storage corresponding to the API request information; processing the API request information; transmitting response information for the API request information; and discarding the shared storage.

In one embodiment, the shared storage stores values produced by the base layer, and the base layers included in the same API can share the stored values.

In one embodiment, the step of generating the API may further include the step of providing a user interface for assembling the layer.

In one embodiment, the user interface may include a first layer providing area, which is an area providing one of the combination layer and the API; and a second layer providing area, which is an area providing a layer of a lower unit than the layer included in the first layer providing area.

In one embodiment, if the layer provided in the first layer provision area is the combination layer, the layer provided in the second layer provision area may be the base layer, and if the layer provided in the first layer provision area is the API, the layer provided in the second layer provision area may be the combination layer.

In one embodiment, the first layer providing area may include a first layer tab, which is a button that can copy a layer provided in the first layer providing area as a reference type, and the second layer providing area may include a second layer tab, which is a button that can copy a layer provided in the second layer providing area as a reference type.

In one embodiment, the user interface further includes an assembly area, wherein the assembly area may be an area where the server recognizes a click or drag on the first layer tab included in the first layer provision area and the second layer tab included in the second layer provision area to place each layer tab.

In one embodiment, the step of setting the type and order of layers from the APP provider may further include the step of recognizing a click on the first layer tab and placing the first layer tab of the first layer provision area in the assembly area; and the step of recognizing a drag on the second layer tab and placing the second layer tab of the second layer provision area below the first layer tab in the assembly area.

In one embodiment, the user interface may further include an add layer tab, which is a button for additionally registering one of the combination layers and the API; and a layer selection area, which includes buttons for selecting one of the combination layers and the API and displaying it in the first layer provision area.

In one embodiment, the step of generating the API may include: generating the combination layer by combining one or more base layers; and generating the API by combining one or more combination layers.

According to embodiments of the present invention, a computer program stored in a computer-readable storage medium performs steps for providing a service of generating an API in low code by the processor of the device when executed on a processor of the device, the steps including: defining a layer including a basic layer, a combination layer organizing the basic layer, and an API organizing the combination layer; receiving a step of setting the type and order of the layers from an APP provider; generating an API according to the type and order of the layers set by the APP provider; and sequentially executing the layers included in the generated API.

In one embodiment, the logic of the API may vary depending on the arrangement of the layers.

A device for providing a service for generating an API with low code according to embodiments of the present invention includes: a storage unit storing at least one program command; and a processor for executing the at least one program command; wherein the processor defines a layer including a basic layer, a combination layer organizing the basic layer, and an API organizing the combination layer; receives a type and order of the layers from an APP provider; generates an API according to the type and order of the layers set by the APP provider; and sequentially executes the layers included in the generated API.

In one embodiment, the logic of the API may vary depending on the arrangement of the layers.

In a service providing method for generating an API using low-code according to embodiments of the present invention, since the server provides a service for generating an API using low-code, the APP provider can generate an API more easily and quickly. Specifically, the APP provider's administrator can easily create or modify an API using low-code by clicking or dragging and dropping through the server. Furthermore, since the API is generated through an organized hierarchy, the APP provider's administrator can modify or change each hierarchy unit, eliminating the need for the APP provider's administrator to modify or create individual operators. Furthermore, even if an API is modified, the server can apply the modification to the API without runtime interruption, allowing the server to reflect the modification to the API in real time.

However, the effects of the present invention are not limited to the effects described above, and may be expanded in various ways without departing from the spirit and scope of the present invention.

FIG. 1 is a conceptual diagram illustrating an embodiment of a configuration of a system that provides a service for generating an API with low code according to embodiments of the present invention.
Figure 2 is a block diagram illustrating an embodiment of the configuration of a device that constitutes a service providing system that generates an API with low code.
Figure 3 is a flowchart illustrating an embodiment of a service providing system that generates an API using low code.
Figure 4 is a flowchart illustrating an embodiment of a step of receiving API request information and transmitting response information.
FIGS. 5 to 10 may be drawings showing user interfaces for generating logic of an API.

Hereinafter, various embodiments of the method according to the present invention will be described in detail with reference to the drawings. Regardless of the drawing numbers, identical or similar components are given the same reference numbers and redundant descriptions thereof will be omitted.

The purposes and effects of the present invention, as well as the technical configurations for achieving them, will become clearer with reference to the embodiments described in detail below, along with the accompanying drawings. In describing one or more embodiments of the present invention, if a detailed description of a related known technology is deemed to obscure the gist of at least one embodiment of the present invention, the detailed description will be omitted.

The terms of the present invention are defined in consideration of the functions of the present invention, and may vary depending on the intention or custom of the user or operator. In addition, the attached drawings are only intended to facilitate the understanding of one or more embodiments of the present invention, and the technical spirit of the present invention is not limited by the attached drawings, and should be understood to include all modifications, equivalents, or substitutes included in the spirit and technical scope of the present invention.

The suffix "부" for components used in the following description is given or used interchangeably only for the convenience of writing the present invention, and does not have a distinct meaning or role in itself.

Terms including ordinal numbers, such as "first" and "second," may be used to describe various components, but these components are not limited by these terms. These terms are used solely to distinguish one component from another. Therefore, a "first" component referred to below may also be a "second" component within the technical scope of the present invention.

Singular expressions include plural expressions unless the context clearly indicates otherwise. That is, unless otherwise specified or the context clearly indicates a singular form, the singular should generally be construed as meaning "one or more" in the present invention and claims.

In the present invention, it should be understood that terms such as “comprising,” “including,” or “having” are intended to specify the presence of a feature, number, step, operation, component, part, or combination thereof described in the present invention, but do not exclude in advance the possibility of the presence or addition of one or more other features, numbers, steps, operations, components, parts, or combinations thereof.

The term "or" in the present invention should be understood as an inclusive "or" rather than an exclusive "or." That is, unless otherwise specified or clear from context, "X utilizes A or B" is intended to mean either of the natural inclusive permutations. That is, if X utilizes A; X utilizes B; or X utilizes both A and B, "X utilizes A or B" can apply to any of these cases. Furthermore, the term "and/or" as used herein should be understood to refer to and encompass all possible combinations of one or more of the associated items listed.

The terms “information” and “data” used in the present invention may be used interchangeably.

Unless otherwise defined, all terms (including technical and scientific terms) used in this invention may be used with meanings commonly understood by those of ordinary skill in the art. Furthermore, terms defined in commonly used dictionaries should not be overly interpreted unless specifically defined otherwise.

However, the present invention is not limited to the embodiments disclosed below and can be implemented in various other forms. These specific embodiments are provided solely to fully inform those skilled in the art of the scope of the present invention, and the present invention is defined solely by the scope of the claims. Therefore, such definitions should be based on the overall content of the present invention.

The processor of the device of the present invention can provide a service for generating APIs using low-code, thereby enabling easier and faster API generation. A method for providing a service for generating APIs using low-code will be described below with reference to FIGS. 1 to 10.

FIG. 1 is a conceptual diagram illustrating an embodiment of a configuration of a system that provides a service for generating an API with low code according to embodiments of the present invention.

Referring to FIG. 1, a service providing system for generating an API with low code may include a server (110), a user terminal (120) connected to the server (110) via a network, and an APP provider (130) that provides an API to the user terminal (120) via the server (110).

A network may refer to a connection structure for exchanging information between a server (110), a user terminal (120), and an APP provider (130). The network may include the Internet, a Local Area Network (LAN), a Wireless Local Area Network (Wireless LAN), a Wide Area Network (WAN), a Personal Area Network (PAN), 3G, 4G, LTE (long term evolution), VoLTE (voice over LTE), 5G NR (new radio), Wi-Fi (wireless-fidelity), Bluetooth, NFC, RFID (radio frequency identification), a home network, and the Internet of Things (IoT).

The server (110) may provide a service for generating APIs using a low-code method. For example, the server (110) may be an API gateway.

The APP provider (130) can be connected to the server (110) via a network. The APP provider (130) can create an API via the server (110) and provide the created API to the user terminal (120) via the server (110). In addition, the APP provider (130) or the administrator of the APP provider (130) can connect to the server (110) to create or modify the API only when creating or modifying a new API.

Specifically, an application of an APP provider (130) and a server (110) may be connected. At this time, the application of the APP provider (130) may request an API from the server (110) and receive the API. Through this, the user terminal (120) may receive the API generated by the server (110).

Accordingly, the APP provider (130) can easily and quickly create or modify an API through the server (110) and provide the created or modified API to the user terminal (120).

A user terminal (120) may be connected to a server (110) via a network. The user terminal (120) may include user equipment such as a computer, tablet, or smartphone. The user terminal (120) may access an application of an APP provider (130) and utilize an API provided by the server (110).

The server (110), user terminal (120), and APP provider (130) of FIG. 1 may be referred to as a device, and the configuration of the device may be as described below.

Figure 2 is a block diagram illustrating an embodiment of the configuration of a device that constitutes a service providing system that generates an API with low code.

A device (200) included in the system may include at least one processor (210) and a database (220) that stores instructions for directing at least one processor (210) to perform at least one step.

The processor (210) can execute at least one program command stored in the database (220). In addition to operations related to the application program, the processor (210) can typically control the overall operation of the device (200). The processor (210) can provide or process appropriate information or functions by processing signals, data, information, etc. input or output through components of the device (200) or by operating an application program stored in the database (220).

The processor (210) can control at least some of the components of the device (200) to drive an application program stored in the database (220). Furthermore, the processor (210) can operate at least two or more of the components included in the device (200) in combination to drive the application program.

The processor (210) may be configured with one or more cores and may be any of various commercially available processors. For example, the processor (210) may include a central processing unit (CPU), a general purpose graphics processing unit (GPGPU), a tensor processing unit (TPU), etc. of the device. However, the present disclosure is not limited thereto.

The database (220) can store data that supports various functions of the device (200). The database (220) can store a plurality of application programs (or applications) running on the device (200), data for the operation of the device (200), commands, and at least one program command. Meanwhile, the application programs can be stored in the database (220), installed on the device (200), and driven by the processor (210) to perform the operation (or function) of the device (200).

The cache memory (230) can store some data of the database (220) in advance for faster transmission between the database (220) and the processor (210). The cache memory (230) can reduce bottlenecks caused by speed differences between the processor (210) and the database (220) by transmitting data between the processor (210) and the database (220) at high speed. That is, the device (200) can store information for creating and modifying APIs in the cache memory (230). Through this, the processor (210) can access the cache memory (230) when creating or modifying APIs, thereby retrieving data from the cache memory (230) more quickly.

The communication unit (240) may include one or more modules that enable wired/wireless communication between the device (200) and a wired/wireless communication system, between the device (200) and another device, or between the device (200) and an external server. In addition, the communication unit (240) may include one or more modules that connect the device (200) to one or more networks.

In the present disclosure, each component included in the device (200) can communicate with each other through the communication unit (240), and the device (200) can be connected to a user terminal and other devices through the communication unit (240). Here, the user terminal may refer to a terminal that transmits API request information, and the other device may refer to a customer server that wishes to provide an API service.

The algorithms and operations executed by the server included in the service provision system that generates APIs with low code may be as described below.

Figure 3 is a flowchart illustrating an embodiment of a service providing system that generates an API using low code.

Referring to FIG. 3, in step S301, the server (310) can define a base layer, a combination layer, an API, and an APP.

The base layer may be the smallest unit of logic executable on the server (310). The base layer may be an operator representing variable declaration, assignment, condition, repetition, and unit operation.

The combination layer may include a first combination layer and a second combination layer. The first combination layer is a layer that organizes the basic layers. That is, the first combination layer may refer to a function, which is the minimum unit of logic created by combining the basic layers, which are basic operators. In addition, the first combination layer may be a minimum layer that can be reused in the logic of the API. That is, it can be reused within the API logic as a unit of the first combination layer and a layer higher than the first combination layer. In other words, the server (310) or the APP provider (320) organizes the basic layers that are reused within the API logic to create the first combination layer, and can then retrieve and use the stored first combination layer whenever necessary. For example, the first combination layer may include a variable initialization module, a header conversion module, and a response module.

The second composition layer may be a layer that organizes the first composition layer. That is, the second composition layer may be a template containing sequential functions. Furthermore, the second composition layer may include a general layer for generating the API's logic and an error layer for handling errors. The error layer is not essential to the API's logic, but if present, it can handle errors that occur during the execution of the API's logic. For example, the second composition layer may include an EAI (Enterprise Application Integration) call API template.

APIs can be a layer that organizes the second layer of integration. For example, APIs include account list query APIs, account balance query APIs, and interbank transfer APIs. Finally, APPs can be a layer that organizes APIs. For example, APPs include Android and iOS apps.

That is, the first combination layer may be a layer formed by combining multiple base layers, the second combination layer may be a layer formed by combining multiple first combination layers, and the API may be a layer formed by combining multiple second combination layers. The server (310) may define layers as described above and generate an API based on the defined layers.

Additionally, the data types of the layers including the base layer, the composite layer, and the API can be reference types. Accordingly, the server (310) can efficiently share and manage data even when changes occur, such as when some layers included in the API are changed.

The server (310) can store information about the first combination layer, the second combination layer, the API, and the APP in a JSON (JavaScript Object Notation) format in a database (e.g., the database (220) of FIG. 2). The server (310) can initially load information about the first combination layer, the second combination layer, the API, and the APP from the database into a cache memory (e.g., the cache memory (230) of FIG. 2). Accordingly, when the server (310) later receives API request information from a user terminal, the server (310) can retrieve data related to the API request information from the cache memory.

In step S303, the APP provider (320) can generate the API logic through the user interface provided by the server (310). That is, the APP provider (320) can generate the API logic by arranging layers through the user interface. In other words, the server (310) can receive the type and order of layers from the APP provider (320). At this time, the API logic may vary depending on the type and order of layers, i.e., the arrangement of the layers.

In step S305, the server (310) can generate an API according to the type and order of layers set by the APP provider (320). Specifically, the server (310) can generate a first combination layer by combining one or more base layers as set by the APP provider (320), and can generate a second combination layer by combining one or more first combination layers. In addition, the server (310) can generate an API by combining one or more second combination layers. In other words, the server (310) can repeatedly generate an upper layer by combining lower layers to finally generate an API.

When an API is created, the server (310) can update both the data stored in the database and cache memory. Furthermore, the server (310) can periodically check for data inconsistencies between the database and cache memory. This allows the server (310) to correct any data inconsistencies between the database and cache memory.

In step S307, the server (310) can distribute the generated API. Accordingly, the APP provider (320) can provide the distributed API to the user terminal through the server (310).

In step S309, if the server (310) recognizes a specific stimulus transmitted from the user terminal, it may sequentially execute the layers included in the generated API. For example, the specific stimulus may mean that the server (310) receives API request information from the user terminal. Accordingly, the server (310) processes the API request information and sequentially executes the layers included in the API. The server (310) may transmit response information regarding the API request information to the user terminal.

At step S311, the APP provider (320) can modify the API logic through the user interface provided by the server (310). That is, the APP provider (320) can modify the API logic by changing the arrangement of layers through the user interface. Accordingly, the API logic may vary depending on the changed arrangement of layers.

At step S313, the server (310) can generate an API based on the type and order of layers modified by the APP provider (320). Specifically, the server (310) can modify at least one layer as modified by the APP provider. If the API is modified, the server (310) can update all data stored in the database and cache memory.

At step S315, the server (310) can distribute the modified API in real time. Accordingly, the APP provider (320) can provide the modified API to the user terminal through the server (310).

In step S317, if the server (310) recognizes a specific stimulus from the user terminal, it may sequentially execute the layers included in the modified API. For example, the specific stimulus may mean that the server (310) receives new API request information from the user terminal. Accordingly, the server (310) processes the API request information and sequentially executes the layers included in the modified API in real time. By sequentially executing the layers included in the modified API, the server (310) may transmit response information regarding the API request information to the user terminal.

That is, since the data type of the layer is a reference type, even if the type and order of the layers included in the API logic are changed, the server (310) can reflect such changes in real time. In addition, the server (310) can immediately apply the changes to the API logic without runtime interruption. In other words, the changed API logic can be synchronized and distributed in real time without stopping the server (310). Accordingly, even if the server (310) receives API request information from a user terminal immediately after a change, it can sequentially execute the layers included in the modified API.

Additionally, for example, even if the server (310) is a dual server rather than a single server, changes can be synchronized between the dual servers through communication.

As described above, the specific algorithms and operations for receiving API request information from a user terminal and transmitting response information corresponding to the API request information may be as described below.

Figure 4 is a flowchart illustrating an embodiment of a step of receiving API request information and transmitting response information.

Referring to FIG. 4, in step S401, the server (410) may receive API request information from the user terminal (420). That is, the server (410) may receive a specific stimulus called API request information from the user terminal (420). For example, the API request information may be HTTP API request information. However, the present invention is not limited thereto.

In step S403, the server (410) may create shared storage corresponding to the API request information. The server (410) may create one shared storage for one API corresponding to the API request information.

Shared storage can store values produced by the basic layer included in the API's logic. Furthermore, basic layers included in the same API logic can share the values stored in the shared storage. In other words, basic layers included in the same API can store and retrieve the produced values in the shared storage. Accordingly, the server (410) can sequentially perform operations based on the basic layer included in the API's logic through the shared storage, without having to store the values in the basic layer itself.

At step S405, the server (410) can process API request information. At this time, the server (410) can sequentially execute the layers included in the API.

Specifically, the server (410) may perform a lookup for the API in the cache memory. Thereafter, the server (410) may perform a lookup for the second combination layer included in the API in the cache memory. Thereafter, the server (410) may perform a lookup for the first combination layer included in the second combination layer in the cache memory. Finally, the server (410) may perform a lookup for the base layer included in the first combination layer in the cache memory.

That is, the server (410) can retrieve or call an API from the cache memory, then retrieve or call a second combination layer included in the API, then retrieve or call a first combination layer included in the second combination layer, and finally retrieve or call a base layer included in the first combination layer.

In other words, the server (410) sequentially looks up from the API to the base layer, can look up from the upper layer to the lower layer, and can sequentially execute the base layer, which is the lowest layer.

In step S407, the server (410) can transmit response information for API request information to the user terminal (420). The user terminal (420) can display the response information through an output unit.

At step S409, the server (410) may discard shared storage. Shared storage is created to share data (values) between basic layers included in the API's logic when generating response information for the API. The server (410) may discard shared storage when the response to the API request information is terminated.

As described above, the user interfaces for creating the logic of the API may be as described below.

FIGS. 5 to 10 may be drawings showing user interfaces for generating logic of an API.

Referring to FIG. 5, the server may provide the APP provider with a user interface (500) for layer assembly. When creating or modifying API logic, the APP provider may access the server and create or modify the API logic through the user interface (500) provided by the server.

The user interface (500) may include a first layer providing area (510), a second layer providing area (520), and an assembly area (530).

The first layer provision area (510) may be an area that provides one of a combination layer and an API. The second layer provision area (520) may be an area that provides a layer of a lower unit than the layer included in the first layer provision area (510). Specifically, if the layer provided in the first layer provision area (510) is a combination layer, the layer provided in the second layer provision area (520) may be a base layer. If the layer provided in the first layer provision area (510) is an API, the layer provided in the second layer provision area (520) may be a combination layer or a base layer.

For example, if the layer provided in the first layer provision area (510) is the first combination layer, the layer provided in the second layer provision area (520) may be the base layer. If the layer provided in the first layer provision area (510) is the second combination layer, the layer provided in the second layer provision area (520) may be the first combination layer. If the layer provided in the first layer provision area (510) is an API, the layer provided in the second layer provision area (520) may be the second combination layer. If the layer provided in the first layer provision area (510) is an APP, the layer provided in the second layer provision area (520) may be an API.

In addition, the first layer provision area (510) may include a first layer tab (512), and the second layer provision area (520) may include a second layer tab (522). The first layer tab (512) may be a button that can copy a layer provided in the first layer provision area (510) as a reference type, and the second layer tab (522) may be a button that can copy a layer provided in the second layer provision area (520) as a reference type. That is, the first layer tab (512) may be a button that can bring a layer provided in the first layer provision area (510) as a shallow copy, and the layer tab (522) may be a button that can bring a layer provided in the second layer provision area (520) as a shallow copy.

The first layer tabs (512) may be grouped according to common functions and displayed in the first layer provision area (510), and the second layer tabs (522) may also be grouped according to common functions and displayed in the second layer provision area (520). This allows the administrator of the APP provider to more quickly find the required first layer tabs (512) and second layer tabs (522).

An administrator of an APP provider can retrieve code by clicking on one of the first layer tabs (512) of the first layer provision area (510) without having to code directly. Similarly, an administrator of an APP provider can retrieve code by dragging one of the second layer tabs (522) of the second layer provision area (520) without having to code directly in the lower layers of the first layer tab (512).

The assembly area (530) may be an area where the server recognizes a click or drag on the layer tabs (512, 522) included in the layer provision area (510, 520) and places each layer tab (512, 522). That is, the assembly area (530) may be an area where the server recognizes a click or drag on the first layer tab (512) included in the first layer provision area (510) and the second layer tab (522) included in the second layer provision area (520) and places the first layer tab (512') and the second layer tab (522').

The server can receive the type and order of layers from the administrator of the APP provider through the user interface (500). Specifically, when the administrator of the APP provider clicks the first layer tab (512), the server can recognize the click on the first layer tab (512) and place the first layer tab (512) of the first layer provision area (510) in the assembly area (530).

At this time, the first layer tab (512') placed in the assembly area (530) may be displayed in various layers. For example, the first layer tab (512') placed in the assembly area (530) may be displayed as a layer provided in the first layer provision area (510). For another example, since the layers provided in the first layer provision area (510) are a sequential combination of the layers provided in the second layer provision area (520), the first layer tab (512') placed in the assembly area (530) may be displayed as a layer provided in the second layer provision area (520).

Thereafter, when the administrator of the APP provider drags the second layer tab (522) to the assembly area (530), the server can recognize the drag for the second layer tab (522) and place the second layer tab (522') of the second layer provision area (520) below the first layer tab (512') in the assembly area (530).

At this time, the first layer tab (512') corresponding to the upper layer may be preferentially placed in the assembly area (530). Thereafter, the second layer tab (522') corresponding to the lower layer may be placed below the first layer tab (512') in the assembly area (530).

Referring to FIG. 5, the layer provided by the first layer provision area (510) may be the first combination layer, and the layer provided by the second layer provision area (520) may be the basic layer. In this case, the administrator of the APP provider may click the first layer tab (512) of the first layer provision area (510) required for the API logic and place it in the assembly area (530).

The administrator of the APP provider can drag the second layer tab (522') required for the logic of the API and place it under the first layer tab (512') of the assembly area (530). That is, the administrator of the APP provider can additionally place the second layer tab (522) required for the logic of the API to be created in addition to the second layer tab (522) placed under the existing first layer tab (512). Alternatively, the administrator of the APP provider can delete the second layer tab (522') placed under the existing first layer tab (512') to suit the logic of the API to be created.

Referring further to FIG. 6, when the server recognizes that a second layer tab (522') is placed in the assembly area (530), it may display a first information input tab (610) as a pop-up for entering additional information required to place the second layer tab (522') under the first layer tab (512'). The administrator of the APP provider must fill in the required fields in the first information input tab (610) to add the second layer tab (522') under the first layer tab (512').

At this time, the additional information required may include operand values required for the base layer to operate, space for storing values produced by the base layer to operate, etc. However, the present invention is not limited thereto.

Referring again to FIG. 5, the user interface (500) may include a Save tab (560), which is a button for saving changes. When an administrator of the APP provider changes or creates logic and then clicks the Save tab (560), the server may store the changes and creations in the logic in cache memory.

Additionally, the user interface (500) may further include an add layer tab (540) and a layer selection area (550).

Referring further to FIG. 7, the Add Layer tab (540) may be a button that allows for additional registration of one of a combination layer, an API, and an APP. When the server recognizes a click on the Add Layer tab (540), it may display a pop-up second information input tab (710) for entering additional information required to add a first layer tab (512'). The administrator of the APP provider must fill in the required fields in the second information input tab (710) to add the first layer tab (512') to the first layer provision area (510).

At this time, the required additional information may vary for each layer. For example, if the server adds a layer tab for the first combination layer as input by the APP provider, the required additional information may include the name of the layer tab that identifies the first combination layer, a unique number for the first combination layer, etc.

When the server adds a layer tab for a second combination layer as input by the APP provider, the additional information required may include a name of the layer tab that can identify the second combination layer, a unique number for the second combination layer, and whether the second combination layer is a normal layer or an error layer.

When the server adds a layer tab to an API as entered by the APP provider, the additional information required may include the name of the layer tab that identifies the API, a unique number for the API, a URL for accessing it externally, and parameters associated with the API.

When the server adds a layer tab for an APP as entered by the APP provider, the additional information required may include the name of the layer tab that can identify that APP, a unique number for that APP, and parameters related to that APP.

Referring back to FIG. 5, the layer selection area (550) may include buttons that can select one of the combination layers, API, and APP to be displayed in the first layer provision area (510).

That is, the layer selection area (550) may include a first layer selection tab (552) that displays a layer tab corresponding to the first combination layer in the first layer provision area (510), a second layer selection tab (554) that displays a layer tab corresponding to the second combination layer in the first layer provision area (510), a third layer selection tab (556) that displays a layer tab corresponding to the API in the first layer provision area (510), and a fourth layer selection tab (558) that displays a layer tab corresponding to the APP in the first layer provision area (510).

When the server recognizes a click on the first layer selection tab (552), it can display a first layer tab (512) corresponding to the first combination layer in the first layer provision area (510) and a second layer tab (522) corresponding to the base layer in the second layer provision area (520).

Referring to FIG. 8, when the server recognizes a click on the second layer selection tab (854) in the layer selection area (850), the server can display a first layer tab (812) corresponding to the second combination layer in the first layer provision area (810) of the user interface (800), and can display a second layer tab (822) corresponding to the first combination layer in the second layer provision area (820).

Referring to FIG. 9, when the server recognizes a click on the third layer selection tab (956) in the layer selection area (950), the server can display a first layer tab (912) corresponding to the API in the first layer provision area (910) of the user interface (900), and can display a second layer tab (922) corresponding to the second combination layer in the second layer provision area (920).

Referring to FIG. 10, when the server recognizes a click on the fourth layer selection tab (1058) in the layer selection area (1050), the server can display a first layer tab (1012) corresponding to the APP in the first layer provision area (1010) of the user interface (1000), and can display a second layer tab (1022) corresponding to the API in the second layer provision area (1020).

Additionally, referring to FIGS. 8 to 10, each user interface (800, 900, 1000) may further include an Add Layer tab (840, 940, 1040) and a Save tab (860, 960, 1060). Accordingly, the APP provider may add a layer tab corresponding to a selected layer through the Add Layer tab (840, 940, 1040), and may save creations and changes through the Save tab (860, 960, 1060).

In embodiments of the present invention, by providing a service that allows the server to generate APIs using low-code, APP providers can more easily and quickly create APIs. Specifically, the APP provider's administrator can easily create or modify APIs using low-code methods, such as clicks or drag-and-drop, via the server. Furthermore, since APIs are created through organized hierarchies, the APP provider's administrator can modify or change each layer individually, eliminating the need to modify or create individual operators. Furthermore, even when APIs are modified, the server can apply them without runtime interruption, allowing the server to reflect API modifications in real time.

However, the above-described examples are merely examples and the present invention is not limited to the above-described examples.

In the present invention, the system and device are not limited to the configuration and method of the several embodiments described above, but the several embodiments may be configured by selectively combining all or some of the embodiments so that various modifications can be made.

The various embodiments described in the present invention may be implemented in a recording medium readable by a computer or similar device, for example, using software, hardware, or a combination thereof.

In terms of hardware implementation, some embodiments described herein may be implemented using at least one of application specific integrated circuits (ASICs), digital signal processors (DSPs), digital signal processing devices (DSPDs), programmable logic devices (PLDs), field programmable gate arrays (FPGAs), processors, controllers, micro-controllers, microprocessors, and other electrical units for performing functions. In some cases, some embodiments described herein may be implemented using a processor.

In a software implementation, some embodiments, such as the procedures and functions described in the present invention, may be implemented as separate software modules. Each software module may perform one or more functions, tasks, and operations described in the present invention. The software code may be implemented as a software application written in a suitable programming language. Here, the software code may be stored in a storage unit and executed by a processor. That is, at least one program instruction is stored in the storage unit, and at least one program instruction may be executed by the processor.

The methods according to the present invention may be implemented in the form of program instructions that can be executed by various computer means and recorded on a computer-readable medium. The computer-readable medium may include program instructions, data files, and data structures, either singly or in combination. The program instructions recorded on the computer-readable medium may be those specifically designed and constructed for the present invention, or may be known and usable by those skilled in the art of computer software.

Examples of computer-readable media include hardware devices specifically configured to store and execute program instructions, such as ROM, RAM, and flash memory. Examples of program instructions include not only machine language codes generated by a compiler, but also high-level language codes that can be executed by a computer using an interpreter, etc. The hardware devices described above may be configured to operate with at least one software module to perform the operations of the present invention, and vice versa.

Although the present invention has been described with reference to the above embodiments, it will be understood by those skilled in the art that various modifications and changes can be made to the present invention without departing from the spirit and scope of the present invention as set forth in the claims below.

Claims (19)

In a service providing method for generating an API (Application Programming Interface) with low code executed by a server processor,
A step of defining a layer including a basic layer, which is the minimum unit of logic executable on a server, a combination layer formed by a combination of a plurality of the basic layers, and an API formed by a combination of a plurality of the combination layers;
A step of receiving the type and order of the above layers from the APP provider;
A step of generating an API according to the type and order of the layers set by the APP provider; and
A step of sequentially executing the layers included in the generated API;
The above combination layer includes a first combination layer that means a function generated by combining the above basic layers,
The data types of the layer including the above basic layer, the above combination layer, and the above API are reference types.
method. delete In the first paragraph,
A step of storing information about the first combination layer and the API in a database; and
Further comprising a step of loading information about the first combination layer and the API from a database into a cache memory;
The step of sequentially executing the layers included in the above generated API is:
A step of sequentially looking up from the upper layer to the lower layer from the API to the basic layer in the cache memory;
method. In the third paragraph,
Further comprising a step of periodically checking for data inconsistency between the database and the cache memory;
method. delete In the first paragraph,
Step of receiving API request information;
A step of creating shared storage corresponding to the above API request information;
A step of processing the above API request information;
A step of transmitting response information for the above API request information; and
further comprising a step of discarding the shared storage;
The above shared storage is shared between the basic layers included in the same API.
method. delete In the first paragraph,
The steps to create the above API are:
Further comprising the step of providing a user interface for assembling the hierarchy;
The above user interface,
A first-tier provision area that displays the first-tier tab;
A second layer provision area that displays a second layer tab corresponding to a lower layer of a layer corresponding to a first layer tab; and
Including an assembly area that recognizes a click or drag on the first layer tab and the second layer tab and places the first layer tab and the second layer tab.
method. In paragraph 8,
Further comprising a step of displaying a first information input tab for inputting additional information required to place the second layer tab under the first layer tab when recognizing that the second layer tab is placed in the assembly area;
method. delete delete delete delete delete delete A computer program stored in a computer-readable storage medium, wherein when the computer program is executed on a processor of a device, the computer program performs steps for providing a service of generating an API in low code by the processor of the device, the steps comprising:
A step of defining a layer including a basic layer, which is the minimum unit of logic executable on a server, a combination layer formed by a combination of a plurality of the basic layers, and an API formed by a combination of a plurality of the combination layers;
A step of receiving the type and order of the above layers from the APP provider;
A step of generating an API according to the type and order of the layers set by the APP provider; and
A step of sequentially executing the layers included in the generated API;
The above combination layer includes a first combination layer that means a function generated by combining the above basic layers,
The data types of the layer including the above basic layer, the above combination layer, and the above API are reference types.
A computer program stored on a computer-readable storage medium. delete In a device that provides a service for generating an API with low code, the device:
database; and
a processor for performing at least one program command stored in the database;
At least one program command above,
Define a layer including a basic layer, which is the minimum unit of logic executable on a server, a combination layer formed by a combination of a plurality of the basic layers, and an API formed by a combination of a plurality of the combination layers;
Obtain the type and order of the above layers from the APP provider;
Generate an API in the type and order of the above layers set by the above APP provider; and
It is executed by the processor to sequentially execute the layers included in the generated API,
The above combination layer includes a first combination layer that means a function generated by combining the above basic layers,
The data types of the layer including the above basic layer, the above combination layer, and the above API are reference types.
device. In Article 18,
Further comprising a cache memory for high-speed data transfer between the processor and the database;
At least one program command above,
Store information about the first combination layer and the API in a database,
Further executed by the processor to load information about the first combination layer and the API from the database into the cache memory,
When executed by the processor to sequentially execute the layers included in the generated API,
Executed by the processor to sequentially lookup from the upper layer to the lower layer from the API to the basic layer in the cache memory,
device.