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

Abstract

Disclosed are an event based package module calling method and a system thereof. The event based package module calling system comprises a modularizing unit, an analyzing unit, a structuralizing unit, an information receiving unit, and a massage generating unit. The modularizing unit uses a reflection based programming language to modularize a program package, in which a plurality of functions related to a specific event are implemented, in an event module. The analyzing unit analyzes each program package corresponding to a plurality of event modules by using the reflection. The structuralizing unit structuralizes a class and event function of each analyzed program package for each event. The information receiving unit receives a call of the specific event from a client. The massage generating unit generates a single response massage by collecting a plurality of massages generated based on a class and function related to an event module corresponding to a specific event, to which the call is requested, among the classes and functions of each structuralized program package, and provides the generated single response massage to the client. The present invention can prevent consumption of computing resources.

Description

[0001] METHOD AND SYSTEM FOR INVOKING EVENT BASED PACKAGE MODULE [0002]

Description of the Related Art [0002] 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 a game and an online shopping.

In a variety of server environments such as existing game servers and online shopping malls, one or more variable functions are called starting from specific events. In most systems, a script-based programming language (Script Language) Events (e.g., announcement popups at login, consecutive attendance points / rewards, unidentified mail / message related events, etc.). For example, script-based programming languages include Lua, JavaScript, Python, and so on.

When processing an event using a script-based programming language, at runtime, a single sentence in the script file is read, and the script engine (line) or line (line) Java engine, etc.), there is a performance degradation in which response time to event processing is relatively slow as compared with a compiled language.

When a script-based programming language is used, a script is called through a script engine when debugging, so that only a script engine can be debugged and debugging in a script is difficult. In other words, there is a limit to know what is in the script file.

Also, for a script-based programming language, code sharing between existing and new code is difficult. In other words, if the server is using a library that is already implemented, it is difficult to share the code between the existing code and the new code by embedding an external library into the database and making it compatible with the existing one, or by using a new library .

When an event occurs in the past, the processing logic of the server is modified in such a manner as to reflect the contents of the new plan (i.e., event) or the updated plan (i.e., event) by modifying the already created server code. At this time, there is an inconvenience that the operation of the server is interrupted when the new plan contents are reflected or the updated plan contents are reflected, and the use of the user is restricted. For example, "Your usage will be limited due to server check from 12:00 am to 6:00 pm on July 01, 2017." Are provided to the client terminal, and the client terminal is restricted from using services such as games, shopping, and Internet banking during the period.

Korean Patent Laid-Open Publication No. 10-2009-0000651 relates to an apparatus and method for providing a user interface for an on-line game, in which user interface elements are independently configured to be reusable in a game engine, And a game progress process.

An event-based package module call that calls source code in a plug-in format to process events requested by the client in a server environment that provides services such as games and online shopping using a programming language based on reflection Method and system.

CLAIMS 1. A method for invoking an event-based package module executed by a computer, the method comprising: modulating a program package with a plurality of functions associated with a specific event into an event module using a reflection-based programming language; analyzing a program package corresponding to each of the plurality of event modules using reflection, structuring a class and an event function of each program package analyzed for each event, requesting a call of a specific event from a client Collecting a plurality of messages generated based on event module related classes and functions of the structured program package and corresponding to the specific event for which the call is requested, and generating a single response message; RTI ID = 0.0 > It may comprise providing a client group.

The event-based package module calling system includes: a modulator for modulating a program package into a plurality of event modules related to a specific event by using a reflection-based programming language; An analyzing unit analyzing a program package corresponding to each of the plurality of event modules, a structuring unit structuring a class and an event function of each analyzed program package for each event, an information receiving unit And a plurality of messages generated on the basis of event module related classes and functions corresponding to specific events requested by the call among the classes and functions of each structured program package to generate a single response message, And transmits a response message to the client Generating a message for providing may include a.

A computer program stored on a storage medium for executing an event-based package module invocation method in combination with a computer-implemented server device, the event-based package module invocation method comprising: using a reflection- Comprising the steps of: modulating a program package implemented with a plurality of related functions into an event module; analyzing a program package corresponding to each of the plurality of event modules using the reflection; A class of an event module corresponding to a specific event of the structured program package among the classes and functions of the structured program package; And function Collecting a plurality of messages that are generated by may include the step of providing the step of generating a single response message, and generates the single response message to the client.

In a server environment that provides services such as games and online shopping using a programming language based on reflection, a source code is called in a plug-in format to process an event requested by a client, The response time for the requested event can be accelerated. That is, performance can be improved.

In addition, a program package implemented with functions related to an event is modularized and an event is processed through a module pool in which modules are structured, thereby stopping the server upon adding a new event module or updating an existing event module It is possible to add or update the corresponding module without having to do so. That is, the binary of the module can be distributed while the operation state of the server is maintained without stopping.

In addition, a plurality of response messages generated for each of the plurality of modules are collected and generated in the form of a single response message, and provided to the client terminal, so that a response to an event requested by the client can be processed at one time. That is, the client waits until all the responses are received in association with the event requested by the client, or waits until a message of the next order is received after receiving the specific message, (I.e., processing speed) increases, and it is possible to prevent unnecessary computing resources from being consumed for processing.

In addition, since the same programming language as the actual server code is used, debugging convenience of the developer can be improved.

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

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

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

The present invention relates to a method and system for invoking an event-based package module, and more particularly, to a method and system for invoking an event using a programming language that provides a non-script-based programming language in various server environments such as a game server, ≪ / RTI > For example, a programming language that provides reflection can include Java, C #, etc., and each of the files compiled and created using Java and C # are modularized and loaded into memory loading a class or a function belonging to the event when a call for a specific event is requested by the client and providing the execution result to the client terminal in response to the class or function.

In the present embodiment, the term "event" represents a specific plan provided by a game server, online shopping, etc., and may include, for example, attendance events (e.g., reward / (For example, freeing of a specific game character / game item during a Christmas period, a Christmas gift event, etc.), a friend invitation event (for example, , Free trial events, and the like.

In the present embodiment, an "event module" is a module package of a program package including functions in which a plurality of functions related to a specific event are implemented (i.e., a collection of functions) have. For example, one or more functions that are variable with a specific event as a starting point may be modularized. In the case of a login event, continuous attendance compensation payment, announcement pop-up, etc. may belong to functions related to the event. The functions can be assembled in a package form. In order to provide a result of the functions related to a specific event to the client terminal in response to the request, that is, a script file is fetched from a storage device such as a database, analyzed, executed, 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, the term "client" refers to a terminal carried by a user, and may represent, for example, a smart phone, a tablet, a notebook, a desktop,

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

1 shows an example in which the network environment includes 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. 1 illustrates a case where the event-based package module calling system is implemented in the form of a platform in the server 120, which corresponds to the embodiment, and the event-based package module calling system may be located outside the server 120 have. For example, when there are a plurality of servers, the event-based package module calling system can form a network with corresponding servers, and can perform processing for an event called in each of the servers through an event module.

The electronic device 110 may be a fixed type mobile terminal implemented as a computer device or a portable type mobile terminal such as a smart phone, a mobile phone, a navigation device, a computer, a notebook, Digital Assistants), Portable Multimedia Player (PMP), and Tablet PC. For example, the electronic device 110 may communicate with the server 120 via the network 130 using a wireless or wired communication scheme.

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

1, an event-based package module call, which is a server 120, and an electronic device 110 include memories 111 and 121, processors 112 and 122, communication modules 113 and 123, and input / output interfaces 114 and 124, The memory 111 and 121 may be a computer-readable recording medium and may be a permanent mass storage device such as a random access memory (RAM), a read only memory (ROM), and a disk drive, The memory 111 and 121 may be provided with an operating system and at least one program code (for example, a code for an application for calling a browser or a losing module installed in and operated on the electronic device 110) Etc. These software components may be loaded from a computer readable recording medium separate from the memories 111 and 121 using a drive mechanism. Readable recording medium of the computer 100 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, May be loaded into the memories 111 and 121 via the communication modules 113 and 123 instead of the recording medium 100. For example, at least one program may be a file distribution system for distributing installation files of developers or applications (Such as the server 120 described above) may be loaded into the memory 111, 121 based on a program (for example, the application described above) installed by the files provided through the network 130. [

Processors 112 and 122 may be configured to process instructions of a computer program by performing basic arithmetic, logic, and I / O operations. An instruction may be provided to the processors 112, 122 by the memory 111, 121 or the communication module 113, 123. For example, the processor 112, 122 may be configured to execute a command received in accordance with a program code stored in a recording device, such as the memory 111, 121.

The communication modules 113 and 123 may provide a function for the electronic appliance 110 serving as a client terminal and the server 120 serving as an event-based package module calling system to communicate with each other through the network 130. For example, when the processor 112 of the client terminal 110 receives a request generated based on the program code stored in the recording device such as the memory 111 (for example, a request for a login event call when an event such as login occurs) Based package module calling system 120 that is a server through the network 130 under the control of the communication module 113. [ Conversely, control signals, commands, contents, files, and the like provided under the control of the processor 122 of the event-based package module calling system 120 as a server are transmitted to the electronic device 110 may be received by the electronic device 110 via the communication module 113 of the mobile terminal 110. [ For example, control signals and commands of the server 120 received through the communication module 113 may be transmitted to the processor 112 or the memory 111, And may be stored as a storage medium that can contain it.

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 a mouse, and the output device may include a device such as a display for displaying a communication session of the application. As another example, the input / output interface 114 may be a means for interfacing with a device having integrated functions for input and output, such as a touch screen. The processor 112 of the electronic device 110 may process a command of a computer program loaded in the memory 111 and may include a service screen or contents configured using data provided by the server 120, May be displayed on the display via the display 114.

Also, in other embodiments, the electronic device 110, which is a client terminal, and the server 120, which is an event-based package module calling system, may include more components than the components of FIG. However, there is no need to clearly illustrate most prior art components. For example, the electronic device 110 may be implemented to include at least some of the input / output devices 115 described above, or may include other components such as a transceiver, a Global Positioning System (GPS) module, a camera, As shown in FIG. More specifically, when the electronic device 110 is a smart phone, an acceleration sensor, a gyro sensor, a camera, various physical buttons, a button using a touch panel, an input / output port, a vibrator for vibrating It will be appreciated that various components of the electronic device 110 may 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 separately from the server 120. The database may be accessed by a server 120 from a web site such as a game or a shopping mall , Various information for providing a call for an event and a response to a called event occurring in various electronic devices (i.e., client terminals) having a communication session established for receiving a corresponding service through an application can be stored and managed have. For example, the database may include a module database for storing and managing program packages corresponding to each of a plurality of event modules, and an attribute database for storing and managing program packages related to attributes (configuration Items (e.g., config files) .

The event-based package module calling system according to the embodiments of the present invention may be implemented in a form of a platform in the server 120. Hereinafter, for convenience of explanation, a package file for installing and running an application or a browser for receiving a service provided by the server 120 by establishing a communication session with the server 120 is stored in the electronic device 110, An embodiment that processes an event called through an event-based package module calling system implemented on the server 120 upon request of the electronic device 110 (i.e., an event occurs at the electronic device and an event is called to the server) .

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

2, the client 201 may represent a mobile application installed on the electronic device 110 or a web browser. When a specific event (event 1 such as login) occurs in the client 201, the server 201 200 may be requested by the client 201 to invoke the generated event through an application installed in the client 201 or a web browser or a web browser.

The server 200 checks the event (for example, event 1) requested by the client 201 and searches for and executes the corresponding event in the module pool 210 and outputs the execution result to the application 200 Or may be delivered to the client 201 via a web browser. That is, you can execute a function that implements the functions associated with the called event. At this time, the event-based package module calling system 200, which is a server for processing events using a reflection-based programming language, may include a module pool 210, a module loader 220, The program packages including a plurality of functions corresponding to the respective functions may be modularized into an event module 230 and stored and maintained in a database (i.e., a module database and an attribute database). 2, the module pool 210 and the module loader 220 are included in the server. However, the module pool 210 corresponds to the embodiment, and the module pool 210 may be located outside the server as a memory The module loader 220 may be implemented in a structure including a processor such as an electronic device separate from the server or the server in order to control the operation of the module pool 210. [

In FIG. 2, each of the event modules 230 is a module of a program package (for example, JAR file for Java, DLL file for C #) created / generated using a reflection-based programming language, , Notation (for example, annotation in the case of JAVA, attribute in the case of C #), which are predefined in advance by a program package such as a DLL. Here, the program package may include at least one function in which functions related to a specific event are implemented, and the function may be defined in the program package in association with a notation (pre-defined notation). For example, it may be desirable to provide a user with access to information related to an attendance event (e.g., a web page or virtual space that provides a user with access to a web page or virtual space providing an attendance event, attendance confirmation, reimbursement due to continuous attendance, And a function for providing a result according to an action such as an exit of the program) may be associated with a notation previously defined for each function corresponding to a specific function. Here, the notation may indicate notation information for identifying that the function is related to a specific event. As an example of notation, @ModuleInterface can be used, and various symbols such as # and% can be used in addition to @, and other characters besides ModuleInterface can be used.

The module loader 220 loads the program packages using Reflection and loads the loaded program package into the program package based on the notation previously defined in the program package And analyze the defined functions, variables, and class information. At this time, as the program package is modulated into one event module, the module loader 220 determines whether the loaded program package (i.e., event module) is composed of a certain class, a certain member variable, a certain member function Can be analyzed.

The module pool 210 can classify class information, function, and function parameters of each event module corresponding to the analyzed program package in the module loader 220, using a hash function. For example, the module pool 210 corresponds to a memory, and is structured by classifying each program package class, event function, and function parameter loaded through the module loader by a hash function using an event . That is, when a call for a specific event is requested, data structuring for linking the class, event function, and the like of each program package with the identifier information of the event is performed in order to provide a response to the specific event immediately requested to the client terminal . When a call request for a specific event is received from the client after the preprocessing process to the data structure is completed, a call to the event module related to the specific event received for the module pool is requested, and the corresponding function can be executed . At this time, the call to the event module can be performed synchronously or asynchronously. For example, the execution code of the server may be blocked or non-blocked depending on the situation, thereby providing the flexibility of server development.

FIG. 3 is a flowchart illustrating a method of calling an event-based package module according to an embodiment of the present invention. FIG. 4 is a flow chart illustrating a configuration Is a block diagram showing an example of an element.

4, the processor 122 included in the event-based package module calling system 120, 200 includes the modular unit 410, the analysis unit 420, the structured unit 430, And an update unit 440. 4, the analyzer 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. . ≪ / RTI > That is, the analyzing unit 420 performs some operations performed by the processor 122 during the operation of the module loader 220 (e.g., controlling the program packages to be loaded into the memory, analyzing the program package, etc.) , The structuring unit 430 may perform a part of operations performed by the processor 122 during the operation of the module pool 210 (for example, operations excluding operations performed in the memory, And performing an operation to search for and execute it).

The modulating unit 410, the analyzing unit 420, the structuring unit 430, and the module updating unit 440 may be used to perform the respective steps (steps 310 to 350) of FIG.

In step 310, the modulator 410 may modularize a program package into which the plurality of functions related to a specific event are implemented, as an event module, using a reflection-based programming language. Here, the process of modularizing each of the plurality of events into an event module may be performed by a DLL file, a JAR file (e.g., a JAR file), a program having functions implemented to provide a specific service (e.g., a game service, Or the like, and corresponds to a preprocessing process for executing the event immediately upon occurrence of the event. That is, it can correspond to a preprocessing process of immediately executing a corresponding DLL file or JAR file and providing a response result, without importing, executing, and re-importing the corresponding script file from the DB when the event occurs.

For example, when a server provides a game service to a client terminal, the game service may be associated with a plurality of events (e.g., a login event, a logout event, a store event, a attendance event, etc.) At least one function (i.e., event function) for providing a result can be defined in the program package. That is, a program for realizing a specific event in the function can be defined, and functions for realizing the event for each of a plurality of events provided in the game service can be implemented as a program package. For example, in the case of a store event, functions for realizing the store event may be implemented so as to be included in the store event package, and in the case of the attendance event, functions for realizing the exit event may be included in the attendance event package.

At this time, in order to modularize the program package into an event module, the program package can 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, function 2, corresponding to function 1 and function 2, associated with an attendance event, and each function of function 1 and function 2, May be defined in association with the notation. For example, Annotation for Java and Attribute for C # can be defined in the program package by associating the notation with the corresponding function.

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

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

For example, the analysis unit 420 may read a plurality of program packages using reflection supported by a programming language such as Java or C #, and may use a plurality of program packages, A function defined in association with the notation (i.e., an event function), a class of the corresponding function, and a parameter of the function can be analyzed based on the notation.

In operation 340, the structuring unit 430 may classify classes and functions (i.e., event functions) of the analyzed program package on an event-by-event basis.

For example, the structuring unit 430 may use a hash function to classify and classify each analyzed program package so that a class or function corresponding to a specific event can be easily and quickly retrieved from the module pool. Can be structured (i.e., data structured). At this time, the structuring unit 430 can structure (i.e., data structure) classes and event functions of each analyzed program package for each event. At this time, parameters (for example, member variables, etc.) of the analyzed function in addition to the class and event function can be structured together with the class and event function using a hash function. Here, the detailed operation of data structure based on the analyzed information (class, event function, etc.) will be described later with reference to FIG. 5 below.

If there is an event module to be updated or added in step 350, the module update unit 440 sets a lock for the call of the corresponding event module, and performs update or addition to the corresponding module .

For example, when a call request for an event to be updated or added is received from the client, the module update unit 440 may once receive the call request and wait for processing of the called event. For example, the process can wait until the update or addition of the event module corresponding to the event requested to be called is completed. The module update unit 440 may store the program package corresponding to the event module to be updated or added in the module database. Then, the 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 the loaded program package may be analyzed and the obtained class, The structured information associated with the program package (i.e., event module) may be updated. For example, a class and a function of a program package corresponding to an existing structured specific event may be updated to indicate the obtained class, function.

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

FIG. 5 is an exemplary diagram illustrating a data structure diagram structured by information analyzed for each program package according to an exemplary embodiment of the present invention. FIG.

5, when providing a game service, when a program package (store event package 510) related to a store event and a program package (attendance event package 520) associated with an attendance event are modularized into an event module, A description will be given of an example in which the data structure is analyzed. The data structure diagram of FIG. 5 corresponds to the embodiment, and data structuring can be performed in various forms. In FIG. 5, the module loader 530 corresponds to the analyzing unit 420 in FIG. 4, and the module pool 540 corresponds to the structuring unit 430 in FIG.

5, the functions (OnJoinRoom, OnLeaveRoom) for realizing the functions related to the attendance event can be defined in the program package in association with the predefined notation (@ModuleInterface) . As described above, a DLL or JAR file corresponding to the attendance event package in which the notation is defined can be modularized into an event module corresponding to an attendance event.

The module loader 530 can load a function (e.g., an event function) defined in the package as the notation (e.g., @ ModuleInterface) for each program package. When loading a function, the module loader 530 can read the parameters of the class, function, and function using reflection.

The module pool 540 may then structure the loaded information (i.e., class, function, function parameters, etc.) for the quick search using a hash function. At this time, structuring may be performed for each event on the basis of an event function for realizing the event. For example, in the case of the event function (OnJoinRoom), it can be commonly used for realizing the store event, the attendance event, and the archive event, and thus can be defined as the notation in the program package for each event. Accordingly, a structuring can be performed so that a corresponding event such as a store event, an emergence event, and a repository event is linked to a virtual link based on OnJoinRoom. That is, an operation for entering a virtual space providing a corresponding event for a specific event is common to store events, attendance events, and archive events, and an action to exit from the virtual space after performing an action presented by the corresponding event, Attendance event, and archive event, it can be structured so that corresponding events based on OnLeaveRoom, such as store event, emergence event, and archive event, are virtually linked.

Figure 6 is a flow diagram illustrating an operation for providing a response to a requested event from a client after data structure, in an embodiment of the present invention.

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

In order to realize a plurality of events, a program package corresponding to each of a plurality of events is modularized into an event module, and after a class, a function, and a parameter of a function are structured according to each event module (i.e., program package) A call request for a specific event may occur. For example, an action to enter a virtual space (for example, clicking on a attendance event pop-up window, clicking on an attendance event item on the lobby screen, etc.) occurs in the client to receive an attendance event at the client in order to receive compensation for continuous attendance provided in the attendance event The event-based package module calling system 200, which is a server, can receive a call request for an attendance event through an application or a web browser operated by the client.

In step 610, the structuring unit 430 can check the event requested to be called (i.e., check the event requested to be called based on the identifier information of the event), and search the module pool for the class and function corresponding to the checked event have. The structuring unit 430 may instantiate the retrieved class (e.g., the class of the program package associated with the attendance event) and execute the corresponding function (i.e., the function of the retrieved class). At this time, the once instantiated class is not deleted immediately but can be maintained to be reused in the next call.

For example, if a call request for an attendance event occurs in the client 1, the structuring unit 430 can search for and instantiate a class corresponding to the attendance event retrieved from the module pool. At this time, the identifier information of the instance created with respect to the client 1 can be stored by matching with the identifier information of the client 1. And, if the client 1 receives compensation for continuous attendance in connection with the attendance event and leaves the virtual space corresponding to the attendance event, the instance generated in association with the client 1 can be reused without being deleted. For example, when a call request for an attendance event occurs in the client 2, the instance generated in the client 1 can be reused. In this way, when reused, the identifier information of the instance can be modified from the identifier information of the client 1 to the identifier information of the client 2. Here, the instance can 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 the invocation of the attendance event occurs and the execution of the OnJoinRoom function is requested, the structuring unit 430 may classify the store event, attendance event, and archive event corresponding to OnJoinRoom retrieved from the module pool, , And execute the OnJoinRoom function. That is, if a call to a store event or a library event is requested at a client other than an attendance event, an instance of the generated class can be reused to provide a response to a store event, a store event, which is requested to be invoked.

In operation 620, the structuring unit 430 may transmit the execution result of the class and the function to the client as a response to the specific event requested to be called. At this time, if there are a plurality of responses as a result of executing the event function of the program package (i.e., event module), a plurality of responses may be collected and a single response message may be transmitted to the client.

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

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

The server (i.e., the event-based package module calling system) may receive the module update request 710 via the module management tool 730. For example, display information (button, icon, etc.) for the module update request 710 may be selected from a manager of the server or the like and a module update request 710 may be received.

As such, when the module update request is received, the processor 122 may store the program package corresponding to the module requested to be updated or added to the module repository 740, which is a module database. The processor 122 may then request the update or addition of the event module that is requested to update or add to the module pool 760. In this case, before the event module corresponding to the stored program package is updated or added in the module pool 760, the processor 122 updates the module pool 760 with the corresponding event You can set a lock on a call to a related event module.

For example, if a program package associated with an attendance event is modified to update the corresponding event module, the modified program package may be stored in the module repository 740, which is 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 processing of the event for a predetermined time until the update is completed after receiving the call request of the event . That is, rather than blocking the access of the service related to the attendance event, since the update is performed in a very short time, the response can be paused 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 a client, but may lock a call to an event module associated with the event. When the attendance event related update is completed in the module pool, the processor 122 can unlock the call for the event module in which the lock is set.

For example, after the lock is set, the processor 122 may load the program package corresponding to the 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 acquired class, function, , Function, and function parameters. Accordingly, the update of the attendance event related event module requested to be updated may be completed, and upon completion of the update, the processor 122 may unlock the invitation of the event module in association with the attendance event . In this way, when an event module is to be added or updated, the module distribution can be performed in an uninterrupted state without shutting down the server.

The configuration items of the event module can be updated in the same manner as the update of the event module and the updated attribute file can be distributed without shutting down the server even when the attribute of the event module is updated.

For example, the processor 122 may be requested 720 to update the attributes of the module via the module management tool 730. Then, the corresponding program package may be stored in the module property repository 750, which is an attribute database, and the processor 122 may lock the call to the event module to update the event module to the module pool 760 (Lock) can be set. When the attribute update of the requested event module is completed, the lock can be unlocked.

In this way, unlike the existing script-based event handling method, event processing is performed based on the module pool and module loader, the script file is stored in the DB (that is, the repository) Without reloading, the server can retrieve the event from the module pool and execute the function immediately.

FIG. 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. FIG. 9 is a block diagram illustrating an internal structure of a processor according to another embodiment of the present invention. .

9, the processor 900 may correspond to the processor 122 of FIG. 2 and may include an information receiving unit 940 and a message generating unit 950 instead of the module updating unit 440 included in the processor 400 of FIG. . ≪ / RTI >

9, the processors 900 and 122 may include a modulating unit 910, an analyzing unit 920, a structuring unit 930, an information receiving unit 940, and a message generating unit 950, The analyzing unit 910, the analyzing unit 920 and the structuring unit 930 are the same as those of the modulating unit 910, the analyzing unit 920 and the structuring unit 930 shown in FIG. 4 described above, do. 9, a preprocessing process (modularization, structuring through reflection-based analysis) for processing an event based on a module is the same as the preprocessing process already described with reference to FIGS. 3 and 4. In FIG. 9, A case where a response to the event is provided to the client when an event call request is generated will be described. 3 may be performed prior to step 810 of FIG. 8, and steps 810 through 830 of FIG. 8 may be performed by the processors 122 and 400.

In step 810, the information receiving unit 940 may receive a call request for a specific event from the client. For example, the information receiving unit 940 can receive a request for invitation 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 on the basis of the classes and functions of the structured program packages and the event modules related to the specific events requested to be called, A response message can be generated.

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

For example, the class and function corresponding to the attendance event can be searched for the module pool, and the message generating unit 950 can collect the response messages obtained as the execution result by executing the searched class and function, A response message can be generated. Here, a plurality of response messages may be acquired at the same time, not simultaneously, as a result of executing the function, and there may be messages obtained with a time difference. Accordingly, the message generation unit 950 can collect the response messages as a response to the attendance event requested by the client, and provide the response messages to the client after structuring them. Here, the operation of generating a single response message will be described in detail with reference to FIG. 9 below.

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

In FIG. 10, a roundtrip trip of messaging between a server and a client is minimized, and a plurality of responses are collected and processed as a response to obtain a performance effect. Each of which may send a message directly to the client.

Referring to FIG. 10, when a call is requested from the client to the event 1, the processor 122, 900 calls an event module associated with the event, and a plurality Messages 1010 and 1020 to be transmitted may be aggregated to generate a single response message 1030. [ The generated single response message 1030 can be provided to the client. That is, each time a plurality of messages to be transmitted (e.g., eight response messages in FIG. 10) are generated, the eight response messages are temporarily stored in a buffer or the like, , A single response message) and provide it to the client. At this time, a plurality of messages to be transmitted to the client may be collected after the call of all the event modules is completed, so that the single response message may be generated.

For example, a processor (e.g., a message generator) may invoke event modules A and B associated with a particular event (e.g., Event 1) to execute the corresponding class and function, The response messages 1010 and 1020 may be collected to generate a single response message. At this time, the messages may include an ordered message (i.e., a Sequenced Message), and may include a sequence unrelated message (i.e., a message unrelated to the order (Unified Message)). You may. Then, the processor (e.g., message generating unit) can generate a single response message 1100 by separating the message 1120 related to the order and the message 1110 related to the order, as shown in FIG. Here, the message 1120 related to the order may indicate a message (i.e., a response message) designated as having a providing order when a response corresponding to a specific event requested by the client is requested.

For example, in connection with a particular event, a welcome message, a reward message, a mail confirmation message, etc., as a result of execution may be collected to generate a single response message. At this time, if the welcome message, the reward message, and the mail confirmation message are sequentially designated to be displayed on the display of the client with respect to the authenticated client (i.e., after the user logs in) May be associated with the message and configured in 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 together in a single response message. In this case, if there is a message irrelevant to the order, a message irrelevant to the order may be included in the single response message.

Thus, since the server provides a single response message with respect to the event requested to be called from the client, the client receives a single response message in a structured form without having to wait for all the messages for the structuring to arrive, A response to the event can be processed at one time.

Referring to 1050 of FIG. 10, there may be another event module (that is, another program package) that commonly uses a function of an event module (i.e., program package) to be processed in association with a specific event. Then, the processors 122 and 900 can reuse the functions of the other event modules through the internal circulation event while processing the event modules, thereby preventing overlapping codes between the modules.

For example, if there are a plurality of event modules (e.g., event modules A, B, and C) associated with a particular event, the processors 122 and 900 call each of the plurality of event modules through an internal circular event 1051, . When execution of all the event modules (e.g., event modules A, B, and C) is completed, a plurality of response messages may be generated as the execution result. At this time, the processors 122 and 900 can collect a plurality of response messages to generate a single response message, and provide the generated single response message to the client. At this time, when calling other event modules through the internal circulation event 1051, another event module may be called synchronously or asynchronously so that the event related function can be executed. For example, when processed synchronously, 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. Then, when a response occurs, the following code can be executed. When processed asynchronously, the executable code of the server may be non-blocking. For example, even if no response has come, the next code is immediately executed, and if a response occurs during execution of the next code, processing such as providing the generated response to the client can be performed.

The system or apparatus described above may be implemented as a hardware component, a software component or a combination of hardware components and software components. For example, the apparatus and components described in the embodiments may be implemented within a computer system, such as, 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. 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 ease of understanding, the processing apparatus may be described as being used singly, but those skilled in the art will recognize that the processing apparatus may have a plurality of processing elements and / As shown in FIG. For example, the processing unit may comprise a plurality of processors or one processor and one controller. Other processing configurations are also possible, such as a parallel processor.

The software may be distributed over a networked computer system and stored or executed in a distributed manner. The software and data may be stored on one or more computer readable recording media.

The method according to an embodiment may be implemented in the form of a program command 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, and the like, alone or in combination. The program instructions to be recorded on the medium may be those specially designed and configured for the embodiments or may be available to those skilled in the art of computer software. Examples of computer-readable media include magnetic media such as hard disks, floppy disks and magnetic tape; optical media such as CD-ROMs and DVDs; magnetic media such as floppy disks; Magneto-optical media, and hardware devices specifically configured to store and execute program instructions such as ROM, RAM, flash memory, and the like. Examples of program instructions include machine language code such as those produced by a compiler, as well as high-level language code that can be executed by a computer using an interpreter or the like.

While the present invention has been particularly shown and described with reference to exemplary embodiments thereof, it is to be understood that the invention is not limited to the disclosed exemplary embodiments. For example, it is to be understood that the techniques described may be performed in a different order than the described methods, and / or that components of the described systems, structures, devices, circuits, Lt; / RTI > or equivalents, even if it is replaced or replaced.

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

Claims (20)

CLAIMS 1. A method for invoking an event based package module executed by a computer,
Modularizing a program package having a plurality of functions related to a specific event into an event module using a reflection-based programming language;
Analyzing a program package corresponding to each of the plurality of event modules using the reflection;
Structuring classes and functions of each analyzed program package by event;
Receiving a request for a specific event from a client;
Collecting a plurality of messages generated based on an event module related class and a corresponding function corresponding to a specific event among the classes and functions of each structured program package to generate a single response message; And
Providing the generated single response message to the client
Based package module. The method according to claim 1,
Wherein the generating the single response message comprises:
Generating the single response message by distinguishing a unified message and a sequenced message from the plurality of messages,
Lt; RTI ID = 0.0 > of: < / RTI > 3. The method of claim 2,
The message related to the above sequence indicates a message designated as having a providing order when a client provides a response corresponding to a specific event for which the call is requested
Lt; RTI ID = 0.0 > of: < / RTI > 3. The method of claim 2,
Wherein the generating the single response message comprises:
And generating a single response message by associating a priority corresponding to each sequence with a corresponding message when there are a plurality of sequenced messages in the sequence
Lt; RTI ID = 0.0 > of: < / RTI > The method according to claim 1,
Wherein the generating the single response message comprises:
And generating the single response message by collecting the generated messages according to the execution of the function of at least one event module corresponding to the specific event requested based on the structured event modules
Lt; RTI ID = 0.0 > of: < / RTI > 6. The method of claim 5,
Wherein the step of performing the function comprises:
When a plurality of event modules are associated with the specific event, calling each of the plurality of event modules through an internal circulation event and executing the corresponding function
Based package module. 6. The method of claim 5,
At least one event module corresponding to the specific event requested to be called is called as synchronous or asynchronous
Lt; RTI ID = 0.0 > of: < / RTI > The method according to claim 1,
Wherein modularizing the event module comprises:
Modularizing each of a plurality of functions associated with the specific event in association with a predetermined notation
Lt; RTI ID = 0.0 > of: < / RTI > The method according to claim 1,
Wherein the structuring for each event comprises:
Structuring a class and a function of each program package based on a hash function
Lt; RTI ID = 0.0 > of: < / RTI > The method according to claim 1,
The program package includes a JAR file or a DLL file
Lt; RTI ID = 0.0 > of: < / RTI > A modulator for modulating a program package implemented with a plurality of functions related to a specific event into an event module using a reflection based programming language;
An analysis unit for analyzing a program package corresponding to each of the plurality of event modules using the reflection;
A structuring unit structuring a class and a function of each analyzed program package for each event;
An information receiving unit for receiving a request for a specific event from a client; And
A plurality of messages generated based on an event module related class and function corresponding to a specific event requested by the call among the classes and functions of each structured program package to generate a single response message, To the client,
The event-based package module calling system comprising: 12. The method of claim 11,
Wherein the message generator comprises:
Generating the single response message by distinguishing a unified message and a sequenced message from the plurality of messages,
The event-based package module calling system. 13. The method of claim 12,
The message related to the above sequence indicates a message designated as having a providing order when a client provides a response corresponding to a specific event for which the call is requested
The event-based package module calling system. 13. The method of claim 12,
Wherein the message generator comprises:
And generating a single response message by associating a priority corresponding to each sequence with a corresponding message when there are a plurality of sequenced messages in the sequence
The event-based package module calling system. 12. The method of claim 11,
The structuring unit includes:
Executing a function of at least one event module corresponding to the specific event requested to be called based on the structured event modules,
Wherein the message generator comprises:
Generating the single response message by collecting messages for each execution result that executed the event function
The event-based package module calling system. 16. The method of claim 15,
The structuring unit includes:
When a plurality of event modules related to the specific event are present, each of the plurality of event modules is called through an internal circulation event to execute the corresponding function
The event-based package module calling system. 16. The method of claim 15,
At least one event module corresponding to the specific event requested to be called is called as synchronous or asynchronous
The event-based package module calling system. 12. The method of claim 11,
Wherein the modulating unit comprises:
Modularizing each of a plurality of functions associated with the specific event in association with a predetermined notation
The event-based package module calling system. 12. The method of claim 11,
The structuring unit includes:
Structuring a class and a function of each program package based on a hash function
The event-based package module calling system. A computer program stored on a recording medium for executing an event-based package module calling method in combination with a computer-implemented server device,
The event-based package module calling method includes:
Modularizing a program package having a plurality of functions related to a specific event into an event module using a reflection-based programming language;
Analyzing a program package corresponding to each of the plurality of event modules using the reflection;
Structuring classes and functions of each analyzed program package by event;
Receiving a request for a specific event from a client;
Collecting a plurality of messages generated based on an event module related class and a corresponding function corresponding to a specific event among the classes and functions of each structured program package to generate a single response message; And
Providing the generated single response message to the client
And a computer program product.

Images