KR102327927B1 - Method and system for invoking event based package module - Google Patents

Abstract

A method and system for invoking an event-based package module are disclosed. A method for calling an event-based package module executed by a computer, comprising: modularizing a program package in which a plurality of functions related to a specific event are implemented into an event module using a reflection-based programming language; Loading the program package for each event, analyzing the loaded program package using the reflection, and structuring classes and functions of the analyzed program package for each event may include.

Description

Method and system for calling event-based package module

The following description relates to a technology for processing an event, and relates to a technology for providing a response by processing an event for providing a specific service in various server environments such as games and online shopping.

In the case of various server environments such as existing game servers and online shopping malls, one or more variable functions are called with a specific event as the starting point. Events (eg, notice pop-up at login, continuous attendance points/rewards, unconfirmed mail/message related events, etc.) are processed. For example, the script-based programming language includes Lua, Java Script, Python, and the like.

When an event is processed using a script-based programming language, the script engine (line by line) reads each sentence included in the script file at runtime. For example, since it is processed by passing it to the Java engine, etc.), there is a performance degradation in that the response time for event processing is relatively slow compared to a compiled language.

In addition, when a script-based programming language is used, since a script is called through the script engine during debugging, debugging is possible only up to the script engine, and debugging within the script is difficult. In other words, there is a limitation that it is difficult to know what is in the script file.

In addition, in the case of a script-based programming language, it is difficult to share code between the existing code and the new code. In other words, when an already implemented library is used in the server, it is difficult to share the code between the existing code and the new code, such as inserting an external library into the database to make it compatible with the existing one, or creating and using a new library. .

When an event occurs in the past, the processing logic of the server is processed in such a way that the previously created server code is modified to reflect the new plan (ie, event) content, or the updated plan (ie, event) content is reflected. In this case, the operation of the server is stopped when reflecting new planning contents or updated planning contents, and there is an inconvenience in that the user's use is limited. For example, "Use is restricted due to server maintenance from 12:00 to 6:00 midnight on July 1, 2017." etc. are provided to the client terminal, and the client terminal is restricted from using services such as games, shopping, and Internet banking during the corresponding period.

Korean Patent Application Laid-Open No. 10-2009-0000651 relates to an apparatus and method for providing a user interface for an online game, and configures user interface components independently of a game engine so that they can be reused, and based on a script Disclosed is a technique for performing game progress-related processing.

In a server environment that provides services such as games and online shopping using a reflection-based programming language, an event-based package module call that processes the event requested by the client by calling the source code in the form of a plug-in Methods and systems are provided.

A method for calling an event-based package module executed by a computer, comprising: modularizing a program package in which a plurality of functions related to a specific event are implemented into an event module using a reflection-based programming language; Loading the program package for each event, analyzing the loaded program package using the reflection, and structuring classes and functions of the analyzed program package for each event may include.

According to one aspect, the method may further include updating the class and function structured for each event to indicate the analyzed class and function for a program package corresponding to the event module loaded for updating.

The event-based package module calling system includes a modularization unit for modularizing a program package implementing a plurality of functions related to a specific event into an event module using a reflection-based programming language, the program package for each event It may include an analysis unit that loads and analyzes the loaded program package using the reflection, and a structuring unit that structures classes and functions of the analyzed program package for each event. .

According to one aspect, when it is desired to update the event module corresponding to the program package, a lock is set for the call of the event module to be updated, and the program package corresponding to the event module to be updated is stored in the module database. It may further include a module update unit for loading.

In the computer program stored in the recording medium in combination with a server device implemented as a computer to execute an event-based package module calling method, the event-based package module calling method includes a specific event using a reflection-based programming language Modularizing a program package in which a plurality of related functions are implemented into an event module, loading the program package for each of a plurality of events, and the program package loaded using the reflection It may include analyzing, and structuring classes and functions of the analyzed program package for each event.

In a server environment that provides services such as games and online shopping using a reflection-based programming language, it processes the event requested by the client by calling the source code in the form of a plug-in, and sends the processing result to the client. By providing this, the response time to the requested event can be quicker. That is, performance may be improved.

In addition, the server is not stopped when adding a new event module or updating an existing event module by modularizing the program package in which event-related functions are implemented and processing the event through the module pool in which the modules are structured. It is possible to add or update the corresponding module without it. That is, it is possible to distribute the binary of the corresponding module while maintaining the operating state of the server without stopping.

In addition, by collecting several response messages generated for each of several modules, generating a single response message in the form of a single response message, and providing it to the client terminal, the response to the event requested by the client can be processed at once. That is, the client waits until all responses are received in relation to the event requested by the client, or after receiving a specific message, waits until a message in the order following the corresponding message is received, or the corresponding event Since it is not necessary to structure the response to provide the user, the response speed (ie, processing speed) can be increased, and unnecessary computing resources for processing can be prevented from being consumed.

In addition, since the same programming language as the actual server code is used, it is possible to increase the debugging convenience of the developer.

In addition, since functions (pre-created functions) already created in the server can be easily reused in each of the event modules, the module code can be simplified.

1 is a diagram illustrating a network environment of an event-based package module call system according to an embodiment of the present invention.
2 is a conceptual diagram illustrating a network environment in which an event is processed using a reflection-based programming language according to an embodiment of the present invention.
3 is a flowchart illustrating a method for calling an event-based package module according to an embodiment of the present invention.
4 is a block diagram illustrating an example of components that a processor of an event-based package module call system may include according to an embodiment of the present invention.
5 is an exemplary diagram of a data structure diagram in which information analyzed for each program package is structured for each event according to an embodiment of the present invention.
6 is a flowchart illustrating an operation of providing a response to an event requested from a client after data is structured according to an embodiment of the present invention.
7 is a conceptual diagram for explaining an operation of updating or adding an event module and module properties according to an embodiment of the present invention.
8 is a flowchart illustrating an operation of providing a single response message based on an event module according to an embodiment of the present invention.
9 is a block diagram illustrating an internal configuration of a processor according to another embodiment of the present invention.
10 is a conceptual diagram provided to explain an operation of generating a single response message according to an embodiment of the present invention.
11 is a diagram illustrating the structure of a single response message according to an embodiment of the present invention.

Hereinafter, embodiments will be described in detail with reference to the accompanying drawings.

The present embodiments relate to a method and system for calling an event-based package module, in particular, using a programming language that provides a script-based programming language (reflection) in various server environments such as game servers and online shopping. It's about processing technology. For example, a programming language that provides reflection may include Java, C#, etc., and modularize each of the compiled files written using Java and C# and load them into memory ( loading), when a call for a specific event is requested from the client, a class or function belonging to the event is executed immediately, and the execution result is provided to the client terminal as a response.

In the present embodiments, "event" refers to a specific plan provided by a game server, online shopping, etc., for example, an attendance event (eg, a reward/point payment event for continuous attendance, etc.), a store event, a roulette event ( For example, an event in which a winning game item/reward/point is paid by spinning roulette when logging in), a Christmas event (e.g., free use of a specific game character/game item during Christmas, a Christmas gift event, etc.), a friend invitation event , a free trial event, and the like may include various types of events.

In the present embodiments, the “event module” is a modularized program package including functions in which a plurality of functions related to a specific event are implemented (that is, a collection of functions), and may be expressed as a package module. have. For example, one or more variable functions may be modularized with a specific event as the starting point, and in the case of a login event, continuous attendance compensation payment, notice pop-up, etc. may belong to the functions related to the event, and the corresponding function It can be configured in package form by collecting the implemented functions to provide them. And, in order to provide the results of the above functions related to a specific event to the client terminal as a response, that is, take a script file from a storage device such as a database, analyze and execute it, then put it back in, and provide the execution result as a response Instead, the program package can be modularized for each event so that the function is directly executed in the system itself through the event module and the execution result is provided as a response.

In the present embodiments, "client" refers to a terminal possessed by a user, and may indicate, for example, a smart phone, a tablet, a notebook computer, or a desktop.

1 is a diagram illustrating a network environment of an event-based package module call system according to an embodiment of the present invention.

The network environment of FIG. 1 shows an example including the electronic device 110 , the server 120 , and the network 130 . The electronic device 110 may represent a client terminal, and the server 120 may represent an event-based package module calling system. In FIG. 1 , a case in which the event-based package module calling system is implemented in the form of a platform in the server 120 is described, but this corresponds to the embodiment, and the event-based package module calling system can be located outside the server 120 separately from the server 120 . have. For example, when there are several servers, the event-based package module calling system may form a network with the corresponding servers, and may process an event called from each of the servers through the event module.

The electronic device 110 is a fixed terminal implemented as a computer device or a mobile terminal. Examples of the electronic device 110 include a smart phone, a mobile phone, a navigation device, a computer, a notebook computer, a digital broadcasting terminal, and a personal digital broadcasting (PDA) terminal. Digital Assistants), Portable Multimedia Player (PMP), and Tablet PC. For example, the electronic device 110 may communicate with the server 120 through the network 130 using a wireless or wired communication method.

The server 120 may be implemented as a computer device or a plurality of computer devices that communicates with the electronic device 110 and the network 130 to provide commands, codes, files, contents, services, and the like.

Referring to FIG. 1 , an event-based package module call and electronic device 110 that is a server 120 includes memories 111 and 121 , processors 112 and 122 , communication modules 113 and 123 , and input/output interfaces 114 and 124 . The memories 111 and 121 are computer-readable recording media, and are non-volatile mass storage devices such as random access memory (RAM), read only memory (ROM), and disk drives. In addition, in the memories 111 and 121 , an operating system and at least one program code (eg, a code for a browser installed and driven in the electronic device 110 or an application for calling a package module) These software components may be loaded from a computer-readable recording medium separate from the memories 111 and 121 using a drive mechanism. Such a separate computer-readable recording medium may include a computer-readable recording medium such as a floppy drive, a disk, a tape, a DVD/CD-ROM drive, a memory card, etc. In another embodiment, the software components include a communication module ( It may be loaded into the memories 111 and 121 through 113 and 123. For example, at least one program is a file distribution system that distributes installation files of developers or applications (eg, the server 120 described above). It may be loaded into the memories 111 and 121 based on a program (eg, the above-described application) installed by files provided through the network 130 .

The processors 112 and 122 may be configured to process instructions of a computer program by performing basic arithmetic, logic, and input/output operations. Commands may be provided to the processors 112 and 122 by the memories 111 and 121 or the communication modules 113 and 123 . For example, the processors 112 and 122 may be configured to execute received instructions according to program codes stored in a recording device such as the memories 111 and 121 .

The communication modules 113 and 123 may provide a function for communication between the electronic device 110 as a client terminal and the server 120 as an event-based package module calling system through the network 130 . As an example, a request generated by the processor 112 of the client terminal 110 according to a program code stored in a recording device such as the memory 111 (eg, a request for calling a login event according to an event such as login occurs) is It may be transmitted to the event-based package module call system 120 that is a server through the network 130 under the control of the communication module 113 . Conversely, a control signal, command, content, file, etc. provided under the control of the processor 122 of the event-based package module calling system 120 that is a server passes through the communication module 123 and the network 130 to the electronic device ( It may be received by the electronic device 110 through the communication module 113 of the 110 . For example, a control signal or command of the server 120 received through the communication module 113 may be transmitted to the processor 112 or the memory 111 , and the electronic device 110 may further transmit content or files. It may be stored in a storage medium that may include.

The input/output interfaces 114 and 124 may be means for interfacing with the input/output device 115 . For example, the input device may include a device such as a keyboard or mouse, and the output device may include a device such as a display for displaying a communication session of an application. As another example, the input/output interface 114 may be a means for an interface with a device in which functions for input and output are integrated into one, such as a touch screen. As a more specific example, when the processor 112 of the electronic device 110 processes a command of a computer program loaded in the memory 111 , a service screen or content configured using data provided by the server 120 is an input/output interface It may be displayed on the display through 114 .

In addition, in other embodiments, the electronic device 110 as a client terminal and the server 120 as an event-based package module calling system may include more components than those of FIG. 1 . However, there is no need to clearly show most of the prior art components. For example, the electronic device 110 is implemented to include at least a portion of the above-described input/output device 115 or other components such as a transceiver, a global positioning system (GPS) module, a camera, various sensors, and a database. may include more. As a more specific example, when the electronic device 110 is a smartphone, an acceleration sensor or a gyro sensor, a camera, various physical buttons, a button using a touch panel, an input/output port, a vibrator for vibration, etc. generally included in the smartphone It can be seen that various components of can be implemented to be further included in the electronic device 110 .

In addition, a database may be included in the server 120 , which is an event-based package module calling system, or a database may exist externally separately from the server 120 , and the database may be accessed from the server 120 to a website such as a game or a shopping mall, or , It is possible to store and manage various information for providing a call to an event that occurred in various electronic devices (ie, client terminals) in which a communication session for receiving a corresponding service is established through an application and a response to the called event. have. For example, the database includes a module database for storing and managing program packages corresponding to each of a plurality of event modules and a property database for storing and managing program packages related to a plurality of event properties (configuration Items, for example, config file) of each of the plurality of events. may include

The event-based package module calling system according to embodiments of the present invention may be implemented in the form of a platform in the server 120 . Hereinafter, for convenience of explanation, a package file for installing and driving an application or a browser for setting a communication session with the server 120 in the electronic device 110 to receive a service provided by the server 120 is stored, An embodiment of processing an event called through an event-based package module calling system implemented in the server 120 according to the request of the electronic device 110 (that is, as an event occurs in the electronic device and the event is called to the server) explain

2 is a conceptual diagram illustrating a network environment in which an event is processed using a reflection-based programming language according to an embodiment of the present invention.

Referring to FIG. 2 , the client 201 may represent a mobile app or a web browser installed in the electronic device 110 , and as a specific event (event 1 such as login) occurs in the client 201, the server ( 200 ) may receive a request from the client 201 to call the generated event through an application installed and driven in the client 201 or a web browser.

The server 200 checks the event (eg, event 1) requested by the client 201, searches for the corresponding event in the module pool 210 and executes it, and uses the execution result as a response to the called event. Alternatively, it may be transmitted to the client 201 through a web browser. That is, a function in which functions related to the called event are implemented can be executed. At this time, the event-based package module call system 200 that is a server in order to process an event using a reflection-based programming language may include a module pool 210 and a module loader 220, and a plurality of events Program packages that collect a plurality of functions corresponding to each may be modularized into the event module 230 and stored and maintained in a database (ie, a module database and an attribute database). In FIG. 2, a case in which the server includes the module pool 210 and the module loader 220 is described as an example, but this corresponds to the embodiment, and the module pool 210 is a memory and may be located outside the server separately from the server. , the module loader 220 may be implemented in a structure included in a server or a processor such as an electronic device separate from the server in order to control the operation of the module pool 210 .

In FIG. 2 , each of the event modules 230 is a modularized program package (eg, a JAR file in the case of Java, a DLL file in the case of C#, etc.) written/generated using a reflection-based programming language, the JAR , DLL, etc., may be implemented using a predefined notation (eg, Annotation in the case of JAVA, Attribute in the case of C#, etc.). Here, the program package may include at least one function in which functions related to a specific event are implemented, and the corresponding function may be defined in the program package in association with a predefined notation (that is, notation information). For example, functions related to the attendance event (eg, entry to a web page or virtual space that provide an attendance event, check attendance, payment of compensation according to continuous attendance, a web page or virtual space that provides an attendance event to a user Functions for providing a result according to an action such as exit of the user) may be associated with a predefined notation for each function corresponding to a specific function. Here, the notation may indicate notation information for identifying that the corresponding function is related to a specific event. As an example of the notation, @ModuleInterface may be used, various symbols such as # and % may be used in addition to @, and other characters may be used in addition to ModuleInterface.

The module loader 220 uses reflection to load program packages, and for the loaded program package, based on the notation defined in advance in the program package, related to the event. to analyze defined functions, variables, and class information. At this time, as the program package is modularized into one event module, the module loader 220 determines which class, which member variable, and which member function (eg, event function) the loaded program package (ie, event module) is composed of. can be analyzed whether

The module pool 210 may structure class information for each event module corresponding to the program package analyzed by the module loader 220 , a function, and a parameter of the function using a hash function. For example, the module pool 210 is a memory corresponding to the class, event function, and function parameter of each program package loaded through the module loader by using a hash function to classify and structure it. can In other words, when a call of a specific event is requested, in order to provide a response to the specific event requested to be called directly to the client terminal, data structuring is performed to link the class, event function, etc. of each program package with the identifier information of the event. can be And, after the pre-processing process up to data structure is completed, when a call request for a specific event is received from the client, the call to the event module related to the received specific event is requested for the module pool, and the corresponding function can be executed. . In this case, the call to the event module may be performed synchronously or asynchronously. For example, it is possible to provide flexibility in server development by allowing the execution code of the server to be blocked or non-blocking depending on the situation.

3 is a flowchart illustrating an event-based package module calling method according to an embodiment of the present invention, and FIG. 4 is a configuration that the processor of the event-based package module calling system may include in an embodiment of the present invention. It is a block diagram showing an example of an element.

As shown in FIG. 4 , the processor 122 included in the event-based package module calling system 120 and 200 is a component, and includes a modularization unit 410 , an analysis unit 420 , a structuring unit 430 , and a module. An update unit 440 may be included. In FIG. 4 , the analysis unit 420 performs or controls an operation corresponding to the module loader 220 of FIG. 2 , and the structuring unit 430 performs or controls an operation corresponding to the module pool 210 of FIG. 2 . can be used to That is, the analysis unit 420 performs some operations performed by the processor 122 during the operation of the module loader 220 (eg, controlling program packages to be loaded into a memory, an operation of analyzing the program packages, etc.) , the structuring unit 430 is an operation excluding some operations performed by the processor 122 during the operation of the module pool 210 (eg, operations performed in the memory, functions corresponding to the event requested in the module pool, etc.) operation to search for and execute, etc.).

In addition, the modularizing unit 410 , the analyzing unit 420 , the structuring unit 430 , and the module updating unit 440 may be used to perform each of the steps 310 to 350 of FIG. 3 .

In operation 310, the modularization unit 410 may modularize a program package in which a plurality of functions related to a specific event are implemented into an event module using a reflection-based programming language. Here, the process of modularizing each of the plurality of events into an event module is a DLL file, a JAR file, and a program implementing functions to be realized in order to provide a specific service (eg, game service, online shopping mall service, etc.) provided by the server. It may correspond to a pre-processing process for immediately executing when a corresponding event occurs by modularizing it into a module. That is, when a corresponding event occurs, it can correspond to a preprocessing process that provides a response result by directly executing the corresponding event-related DLL file and JAR file without fetching and executing the corresponding script file from the DB and putting it back in again.

For example, when the server provides the game service to the client terminal, according to actions related to a plurality of events (eg, login event, logout event, store event, attendance event, etc.) generated when the game service is provided At least one function for providing a result (ie, an event function) may be defined in the program package. That is, a program for realizing a specific event may be defined in the function, and functions for realizing the corresponding event for each of a plurality of events provided in the game service may be implemented as a program package. For example, in the case of a store event, functions for realizing a store event may be implemented to be included in the store event package, and in the case of an attendance event, functions for realizing a departure event may be implemented to be included in the attendance event package.

In this case, in order to modularize the program package into an event module, the program package may be implemented by associating each of a plurality of functions related to a specific event with a predefined notation. For example, the attendance event package may include a function of function 1 and a function of function 2 corresponding to function 1 and function 2 related to the attendance event, and each of the function 1 function and the function 2 function is in the program package. It may be defined in association with the notation. For example, by using Annotation in Java and Attribute in C#, the annotation can be associated with the corresponding function and defined in the program package.

In operation 320 , the analyzer 420 may load a program package corresponding to each of the plurality of events into the memory. Here, the operation of the loading analysis unit 420 may correspond to the module loader 220 of FIG. 2 . That is, when program packages corresponding to each of the plurality of events are modularized into an event module based on the notation, the program packages may be loaded into the memory for analysis of the program package.

In operation 330, the analyzer 420 may analyze each of the plurality of loaded program packages using reflection supported by a programming language implementing the program package.

For example, the analysis unit 420 reads a plurality of program packages using reflection supported by a programming language such as Java or C#, and targets the plurality of program packages, defined in advance in the program package. Based on the notation, a function defined in association with the corresponding notation (ie, an event function), a class of the corresponding function, and a parameter of the function may be analyzed.

In operation 340 , the structuring unit 430 may structure classes and functions (ie, event functions) of the analyzed program package for each event.

For example, the structuring unit 430 uses a hash function for the class and function of each analyzed program package so that a class or function corresponding to a specific event can be easily and quickly searched for in the module pool. You can structure (ie, structure your data). In this case, the structuring unit 430 may structure (ie, structure data) the classes and event functions of each analyzed program package for each event. In this case, in addition to the class and event function, parameters of the analyzed function (eg, member variables, etc.) may also be structured together with the class and event function using a hash function. Here, a detailed operation of structuring data based on the analyzed information (class, event function, etc.) will be described later with reference to FIG. 5 below.

In step 350, if an event module to be updated or added exists, the module update unit 440 may set a lock for calling the corresponding event module, and may update or add the corresponding module. .

For example, when a call request of an event to be updated or added is received from the client, the module updater 440 may wait for processing of the called event after receiving the call request. For example, the process may wait until the update or addition of the event module corresponding to the event requested to be called is completed. In addition, the module update unit 440 may store a program package corresponding to an event module to be updated or added in the module database. Then, the corresponding program package may be loaded into the memory for updating or adding an event module corresponding to the program package stored in the module database for addition or update, and based on the class, function, etc. obtained by analyzing the loaded program package As a result, structured information related to the corresponding program package (ie, event module) can be updated. For example, classes and functions of a program package corresponding to an existing structured specific event may be updated to indicate the obtained classes and functions.

As such, when the update is completed, the lock set in the call may be released. Here, a detailed operation of updating or adding the event module will be described later with reference to FIG. 7 below.

5 is an exemplary diagram of a data structure diagram in which information analyzed for each program package is structured for each event according to an embodiment of the present invention.

In FIG. 5, when a program package (shop event package, 510) related to a store event and a program package (attendance event package, 520) related to an attendance event are modularized into event modules, respectively, in the case of providing a game service, the corresponding program package A case in which data structuring is performed by analyzing . The data structure diagram of FIG. 5 corresponds to an embodiment, and data structuring may be performed in various forms. In FIG. 5 , the module loader 530 may correspond to the analysis unit 420 of FIG. 4 , and the module pool 540 may correspond to the structuring unit 430 of FIG. 4 .

Referring to the attendance event package 520 of FIG. 5, the functions (OnJoinRoom, OnLeaveRoom) for realizing the functions related to the attendance event may be defined in the program package in association with a pre-defined notation (@ModuleInterface). . In this way, the DLL or JAR file corresponding to the attendance event package in which the notation is defined may be modularized into an event module corresponding to the attendance event.

The module loader 530 may load a function (eg, an event function) defined by the notation (eg, @ModuleInterface) in the package for each program package. When loading a function, the module loader 530 may read a class, a function, and a parameter of the function using reflection.

Then, the module pool 540 may structure the loaded information (ie, a class for each program package, a function, a parameter of a function, etc.) for quick search using a hash function. In this case, structuring may be performed for each event based on an event function for realizing the corresponding event. For example, in the case of the event function (OnJoinRoom), since it can be commonly used to realize a store event, an attendance event, and a locker event, it can be defined as the notation in a program package for each event. Accordingly, structuring may be performed so that the corresponding events, such as a store event, an exit event, and a locker event, are connected with a virtual link based on OnJoinRoom. That is, the action of entering the virtual space that provides the corresponding event for a specific event is common to the store event, the attendance event, and the locker event, and the action of exiting the virtual space after performing the action suggested by the corresponding event is the store event, Since it is common to the attendance event and the locker event, it can be structured so that the corresponding events based on OnLeaveRoom, the store event, the exit event, and the locker event, are linked with a virtual link.

6 is a flowchart illustrating an operation of providing a response to an event requested from a client after data is structured according to an embodiment of the present invention.

Each of the steps 610 and 620 of FIG. 6 may be performed by the structuring unit 430 of FIG. 4 .

In order to realize a plurality of events, a program package corresponding to each of the plurality of events is modularized into an event module, and after event module (ie, program package) classes, functions, and parameters of functions are structured, the client A call request for a specific event may occur. For example, in order to receive a reward for continuous attendance provided by the attendance event, an action to enter the virtual space (eg, click the attendance event pop-up window, click the attendance event item on the lobby screen, etc.) in which the client provides the attendance event occurs Accordingly, the event-based package module call system 200, which is a server, may receive a call request for an attendance event through an application or web browser driven by the client.

In step 610, the structuring unit 430 may check the called event (that is, check the called event based on the identifier information of the event), and search the class and function corresponding to the checked event from the module pool. have. In addition, the structuring unit 430 may instantiate the found class (eg, a class of a program package related to an attendance event) and execute a corresponding function (ie, a function of the found class). In this case, the class instantiated once may not be deleted immediately, but may be maintained to be reused in the next call.

As an example, when a call request for an attendance event occurs from client 1, the structuring unit 430 may search for and instantiate a class corresponding to the attendance event found in the module pool. In this case, the identifier information of the instance created in relation to the client 1 may be stored by matching the identifier information of the client 1. In addition, when the client 1 receives a reward for continuous attendance in relation to the attendance event and leaves the virtual space corresponding to the attendance event, the instance created in relation to the client 1 may be reused without being deleted. For example, when a call request for an attendance event occurs at client 2, the instance created at client 1 may be reused. In this way, when reused, the identifier information of the instance may be modified from the identifier information of the client 1 to the identifier information of the client 2. Here, the instance may be reused without being removed until the server requests deletion of the instance. That is, it can be removed when an instance deletion request is made.

As another example, when a call to an attendance event occurs and the execution of the OnJoinRoom function is requested, the structuring unit 430 performs a store event, attendance event, and storage event corresponding to OnJoinRoom found in the module pool. Class (class) can be instantiated and the OnJoinRoom function can be executed. That is, when a call is requested for a store event or a store event in addition to the attendance event from the client, the generated instance of the class may be reused to provide a response to the call-requested store event and store event.

In operation 620 , the structuring unit 430 may transmit the execution result of the class and function to the corresponding client as a response to the specific event requested to be called. In this case, when a plurality of responses exist as a result of executing the event function of the program package (ie, event module), a single response message may be transmitted to the client by collecting the plurality of responses.

7 is a conceptual diagram for explaining an operation of updating or adding an event module and module properties according to an embodiment of the present invention.

In FIG. 7 , a module repository 740 may correspond to a module database, and a module property repository 750 may correspond to a property database. The operation of FIG. 7 may be performed by the processor 122 of FIG. 1 . For example, it may be performed by the module update unit 440 of the processor 122 .

The server (ie, the event-based package module calling system) may receive the module update request 710 through the module management tool 730 . For example, the display information (button, icon, etc.) for the module update request 710 may be selected from the administrator of the server, and the module update request 710 may be received.

As such, when the module update request is received, the processor 122 may store a program package corresponding to the module requested to be updated or added in the module repository 740 which is the module database. In addition, the processor 122 may request the update or addition of the event module requested to be updated or added to the module pool 760 . At this time, before updating or adding the event module corresponding to the stored program package in the module pool 760 , the processor 122 performs the event and the event until the update or addition is completed for the module pool 760 . You can set a lock for the call of the related event module.

For example, when a program package related to an attendance event is modified and a corresponding event module is to be updated, the modified program package may be stored in the module repository 740 serving as a module database. At this time, if a call request for the attendance event occurs from the client before the module pool is updated, the processor 122 waits for the processing of the event for a certain time after receiving the call request of the event until the update is completed. can That is, it does not block the access of the service related to the attendance event itself, but because the update is made in a very short time, it is possible to wait for a response while allowing the client access to the virtual space for the attendance event. To this end, the processor 122 may receive a call request from the client, but may set a lock on the call of the event module related to the corresponding event. And, when the update related to the attendance event in the module pool is completed, the processor 122 may unlock the lock for the call of the event module in which the lock is set.

For example, after the lock is set, the processor 122 may load a program package corresponding to an update-requested attendance event stored in the module repository 740 into the memory. In addition, the loaded program package can be analyzed using reflection, and the existing attendance event-related class already structured in the module pool 750 based on the class, function, and function parameters obtained through analysis. , functions, and function parameters can be updated. Accordingly, the update of the event module related to the attendance event requested to be updated may be completed, and as the update is completed, the processor 122 unlocks the lock on the call of the event module related to the attendance event. can As such, when it is desired to add or update an event module, the module distribution may proceed in a non-stop state without shutting down the server.

Like the update of the event module, the properties (Configuration Items) of the event module may be updated, and even when the properties of the event module are updated, the updated property file may be distributed without shutting down the server without shutting down the server.

For example, the processor 122 may receive a request to update the properties of the module through the module management tool 730 ( 720 ). Then, the corresponding program package may be stored in the module property repository 750 which is the property database, and the processor 122 locks the call to the event module in order to update the event module for the module pool 760 . (Lock) can be set. And, when the attribute update of the requested event module is completed, the lock may be released.

In this way, as event processing is performed based on the module pool and module loader, unlike the existing script-based event processing method, the script file is stored in the DB (that is, repository) and then a signal is sent to the server to reload ( reload), the server can retrieve the event from the module pool and immediately execute the function.

8 is a flowchart illustrating an operation of providing a single response message based on an event module according to an embodiment of the present invention, and FIG. 9 is a block diagram illustrating an internal configuration of a processor according to another embodiment of the present invention. It is also

In FIG. 9 , the processor 900 may correspond to the processor 122 of FIG. 2 , and instead of the module updater 440 included in the processor 400 of FIG. 4 , the information receiver 940 and the message generator 950 . may include.

Referring to FIG. 9 , the processors 900 and 122 may include a modularizing unit 910 , an analyzing unit 920 , a structuring unit 930 , an information receiving unit 940 , and a message generating unit 950 , and the modularizing unit Operations of the 910 , the analyzer 920 , and the structuring unit 930 are the same as the above-described modularizing unit 910 , the analyzing unit 920 , and the structuring unit 930 of FIG. 4 , and thus overlapping descriptions will be omitted. do. That is, in FIG. 9, the preprocessing process (modularization, structuring through reflection-based analysis) of processing an event based on a module is the same as the preprocessing process already described in FIGS. 3 and 4, and in FIG. 9, after the preprocessing process, in the client In the event that an event call request occurs, the processing of providing a response to the event to the client will be described. Accordingly, each step of FIG. 3 for preprocessing may be performed before step 810 of FIG. 8 , and each step (steps 810 to 830 ) of FIG. 8 may be performed by the processors 122 and 400 .

In operation 810, the information receiver 940 may receive a call request of a specific event from the client. For example, the information receiving unit 940 may receive a call request of an attendance event through an application installed and driven in the client.

In step 820, the message generator 950 collects a plurality of messages generated based on the class and function related to the event module corresponding to the specific event for which the call is requested among the classes and functions of each structured program package to form one single message. You can create a response message.

In operation 830, the generated single response message may be provided to the client.

As an example, classes and functions corresponding to the attendance event may be searched for in the module pool, and the message generator 950 collects response messages obtained as an execution result as the searched classes and functions are executed to form one single You can create a response message. Here, as a result of executing the function, a plurality of response messages may be obtained not at the same time, but may be obtained at the same time, or messages obtained with a time difference may exist. Accordingly, the message generating unit 950 may provide a response message to the client after structuring the response message as a response to the call-requested attendance event from the client, rather than providing the response messages from time to time. Here, the operation of generating a single response message will be described in detail with reference to FIG. 9 below.

10 is a conceptual diagram provided to explain an operation of generating a single response message according to an embodiment of the present invention, and FIG. 11 is a diagram showing the structure of a single response message according to an embodiment of the present invention .

In FIG. 10, a case in which a plurality of responses are collected and processed as one response in order to obtain a performance effect by minimizing a roundtrip trip of messaging between the server and the client is described as an example, but this corresponds to the embodiment, and the event module It is also possible to send messages directly to the client from each of them.

Referring to 1000 of FIG. 10 , when a call for event 1 is requested from a client, the processors 122 and 900 call an event module related to the corresponding event, and a plurality of generated classes and functions are executed in the module pool. A single response message 1030 may be generated by collecting the messages 1010 and 1020 to be transmitted. In addition, the generated single response message 1030 may be provided to the client. That is, each of the plurality of messages to be transmitted (eg, the 8 response messages of FIG. 10 ) is not transmitted to the client immediately whenever each occurrence, but the 8 response messages are temporarily stored in a buffer, etc. , a single response message) can be generated and provided to the client. In this case, a plurality of messages to be transmitted to the client may be aggregated to generate the single response message after all event modules are called.

For example, the processor (eg, the message generator) executes the corresponding class and function by calling the event modules (event modules A and B) related to a specific event (eg, event 1), and provides a plurality of execution results. One single response message may be generated by collecting the response messages 1010 and 1020 . In this case, the messages may include an ordered message in some cases (ie, a sequenced message), and may include a message out of order (ie, a message regardless of the sequence (Unified Message)). You may. Then, the processor (eg, the message generator) may generate a single response message 1100 by distinguishing the message 1120 related to the order and the message 1110 irrelevant to the order as shown in FIG. 11 . Here, the order-related message 1120 may indicate a message (ie, a response message) designated as having a provision order when the client provides a response corresponding to a specific event for which a call is requested.

For example, in relation to a specific event, a welcome message, a reward message, a mail confirmation message, etc. may be gathered as a result of execution to generate a single response message. At this time, in relation to the authenticated client (that is, after the user logs in), if it is pre-specified that the welcome message, the reward message, and the mail confirmation message are sequentially displayed on the client's display, the ordered messages each have priority information may be associated with the corresponding message and constructed within a single response message. For example, information indicating priority 1 in association with a welcome message, information indicating priority 2 in association with a reward message, and information indicating priority 3 in association with a mail confirmation message may be included in a single response message together. In this case, when there is a message irrelevant to the order, the message irrelevant to the order may be included in the single response message.

As such, as the server provides a single response message in relation to the event requested from the client, the client receives a single response message in a structured form without waiting for all messages for structuring to arrive, so that at the client end A response to the event can be processed at once.

Referring to 1050 of FIG. 10 , while a function of an event module (ie, a program package) processed in relation to a specific event is executed, another event module (ie, another program package) that commonly uses the corresponding function may exist. Then, the processors 122 and 900 reuse the functions of other event modules through internal circulation events while processing the event modules, thereby preventing duplicate code between modules.

For example, when there are a plurality of event modules (eg, event modules A, B, and C) related to a specific event, the processors 122 and 900 call each of the plurality of event modules through the internal circulation event 1051 to function can run And, when the execution of all event modules (eg, event modules A, B, and C) related functions is completed, a plurality of response messages may be generated as a result of execution. In this case, the processors 122 and 900 may collect a plurality of response messages to generate a single response message, and may provide the generated single response message to the client. In this case, when other event modules are called through the internal cycle event 1051, other event modules are called synchronously or asynchronously, and a corresponding event-related function may be executed. For example, in the case of synchronous processing, the execution code of the server may be blocked. That is, it can wait without executing the next code until a response to the execution result occurs. And, when a response occurs, the following code can be executed. In the case of asynchronous processing, the server's executable code may be non-blocking. For example, even if there is no response, the next code is immediately executed, and if a response occurs during the execution of the next code, processing such as providing the generated response to the client may be performed.

The system or device described above may be implemented as a hardware component, a software component, or a combination of a hardware component and a software component. For example, devices and components described in the embodiments may include, for example, a processor, a controller, an arithmetic logic unit (ALU), a digital signal processor, a microcomputer, a field programmable gate array (FPGA). , a programmable logic unit (PLU), a microprocessor, or any other device capable of executing and responding to instructions, may be implemented using one or more general purpose or special purpose computers. The processing device may execute an operating system (OS) and one or more software applications running on the operating system. The processing device may also access, store, manipulate, process, and generate data in response to execution of the software. For convenience of understanding, although one processing device is sometimes described as being used, one of ordinary skill in the art will recognize that the processing device includes a plurality of processing elements and/or a plurality of types of processing elements. It can be seen that can include For example, the processing device may include a plurality of processors or one processor and one controller. Other processing configurations are also possible, such as parallel processors.

The software may be distributed over networked computer systems, and stored or executed in a distributed manner. Software and data may be stored in one or more computer-readable recording media.

The method according to the embodiment may be implemented in the form of program instructions that can be executed through various computer means and recorded in a computer-readable medium. The computer-readable medium may include program instructions, data files, data structures, etc. alone or in combination. The program instructions recorded on the medium may be specially designed and configured for the embodiment, or may be known and available to those skilled in the art of computer software. Examples of the computer-readable recording medium include magnetic media such as hard disks, floppy disks and magnetic tapes, optical media such as CD-ROMs and DVDs, and magnetic such as floppy disks. - includes magneto-optical media, and hardware devices specially configured to store and execute program instructions, such as ROM, RAM, flash memory, and the like. Examples of program instructions include not only machine language codes such as those generated by a compiler, but also high-level language codes that can be executed by a computer using an interpreter or the like.

As described above, although the embodiments have been described with reference to the limited embodiments and drawings, various modifications and variations are possible from the above description by those skilled in the art. For example, the described techniques are performed in a different order than the described method, and/or the described components of the system, structure, apparatus, circuit, etc. are combined or combined in a different form than the described method, or other components Or substituted or substituted by equivalents may achieve an appropriate result.

Therefore, other implementations, other embodiments, and equivalents to the claims are also within the scope of the following claims.

Claims (20)

A method for calling an event-based package module executed by a computer, the method comprising:
modularizing a program package in which a plurality of functions related to a specific event are implemented into an event module using a reflection-based programming language;
loading the program package for each of a plurality of events;
parsing the loaded program package using the reflection; and
Structuring classes and functions of the analyzed program package for each event
including,
The step of modularizing into the event module,
Modularizing each of a plurality of functions related to the specific event by associating it with a predetermined notation
including,
The loading step is
loading an event function related to the specific event using the predetermined notation in the program package;
including,
The analyzing step is
Analyzing function, variable, and class information defined in relation to the specific event when loading the event function
including,
The step of structuring for each event is
The class and function of the program package are structured for each event based on a hash function, and a class corresponding to a specific event requested by the client based on the structured class and function for each event. or executing a function, and transmitting an execution result of executing the class or function to the client in response to the called specific event
How to call an event-based package module containing delete According to claim 1,
An event module for executing a class or function related to the specific event is called synchronously or asynchronously
An event-based package module invocation method, characterized by delete delete According to claim 1,
When the event module corresponding to the program package is to be updated, a lock is set for the call of the event module to be updated.
An event-based package module invocation method, characterized by 7. The method of claim 6,
updating the class and function structured for each event to indicate the analyzed class and function for the program package corresponding to the event module loaded for update;
An event-based package module invocation method further comprising a. 7. The method of claim 6,
The lock set for the invocation of the event related to the program package is released as the update is completed.
An event-based package module invocation method, characterized by 7. The method of claim 6,
When it is desired to update the properties (configuration items) of the event module corresponding to the program package, a lock is set for the call of the event module related to the property to be updated until the update of the properties is completed
An event-based package module invocation method, characterized by According to claim 1,
The above program package would represent a JAR file or a DLL file
An event-based package module invocation method, characterized by a module module for modularizing a program package in which a plurality of functions related to a specific event are implemented into an event module using a reflection-based programming language;
an analysis unit that loads the program package for each of a plurality of events and analyzes the loaded program package using the reflection; and
A structuring unit for structuring classes and functions of the analyzed program package for each event
including,
The modularization unit,
Including modularizing each of a plurality of functions related to the specific event by associating it with a predetermined notation,
The analysis unit,
Loading an event function related to the specific event by using the predetermined notation in the program package, and analyzing function, variable, and class information defined in relation to the specific event when the event function is loaded,
The structuring unit,
Structured for each event based on the class and function hash function of the program package, and based on the structured event-specific class and function, a class corresponding to a specific event requested by the client or Executes a function and delivers the execution result of executing the class or function to the client in response to the called specific event
Event-based package module invocation system. delete 12. The method of claim 11,
An event module for executing a class or function related to the specific event is called synchronously or asynchronously
An event-based package module invocation system, characterized by delete delete 12. The method of claim 11,
When an event module corresponding to the program package is to be updated, a module update unit that sets a lock for the call of the event module to be updated and loads the program package corresponding to the event module to be updated from the module database
An event-based package module invocation system further comprising a. 17. The method of claim 16,
The module update unit,
Updating the structured class and function for each event to indicate the analyzed class and function
An event-based package module invocation system, characterized by 17. The method of claim 16,
A lock set for invocation of an event related to the program package is released as the update is completed.
An event-based package module invocation system, characterized by In the computer program stored in the recording medium to execute the event-based package module calling method in combination with a server device implemented as a computer,
The event-based package module calling method is
modularizing a program package in which a plurality of functions related to a specific event are implemented into an event module using a reflection-based programming language;
loading the program package for each of a plurality of events;
parsing the loaded program package using the reflection; and
Structuring classes and functions of the analyzed program package for each event
including,
The step of modularizing into the event module,
Modularizing each of a plurality of functions related to the specific event by associating it with a predetermined notation
including,
The loading step is
loading an event function related to the specific event using the predetermined notation in the program package;
including,
The analyzing step is
Analyzing function, variable, and class information defined in relation to the specific event when the event function is loaded
including,
The step of structuring for each event is
The class and function of the program package are structured for each event based on a hash function, and a class corresponding to a specific event requested by the client based on the structured class and function for each event. or executing a function, and transmitting an execution result of executing the class or function to the client in response to the called specific event
A computer program comprising a. delete

Images