Monitoring method of service system, electronic equipment and storage medium
By obtaining the instrument object in the business system and inserting monitoring code into the class bytecode file, the problem of high monitoring costs of business systems in different technology stacks is solved, and unified monitoring and cost reduction is achieved.
Patent Information
- Application Number
- CN202411182084.5
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2024-08-27
- Publication Date
- 2024-12-03
AI Technical Summary
Because multiple business systems deployed on the enterprise server side are based on different technology stacks, the monitoring cost is high, and the compatibility problem between the technology stacks is difficult to solve.
By obtaining the instrument object in the premain method of the target business system, using the bytebuddy bytecode operation library to insert monitoring code into the class bytecode file, the monitoring of the target business system is achieved without being restricted by the technical stack, and the monitoring cost is reduced.
It realizes unified monitoring of business systems of different technology stacks, reduces monitoring costs, avoids the problem of technology stack compatibility adaptation, and improves monitoring efficiency.
Smart Images

Figure CN119065927A_ABST
Abstract
Description
Technical Field
[0001] The present application relates to the field of Internet technology, and in particular to a monitoring method, electronic device and storage medium for a business system. Background Art
[0002] The enterprise's server side usually deploys multiple business systems, which may include customer service systems, sales systems, procurement systems, etc., so that different businesses can be processed through the business systems.
[0003] In actual applications, in order to ensure the smooth operation of the overall business of the enterprise, it is usually necessary to monitor these business systems. However, these business systems may be built based on different technology stacks (Tech Stack), resulting in high monitoring costs when monitoring these business systems due to the need to adapt to compatibility issues between technology stacks. Summary of the invention
[0004] The embodiments of the present application provide a monitoring method, electronic device and storage medium for a business system, which can be used to solve technical problems in the prior art.
[0005] A first aspect of an embodiment of the present application provides a method for monitoring a business system, including:
[0006] Get the instrument object in the premain method of the target business system;
[0007] Get the class bytecode file of the target business system through the instrument object;
[0008] Based on the instrument object and the bytebuddy bytecode operation library, monitoring code is inserted into the class bytecode file.
[0009] Preferably, the method further comprises:
[0010] Monitoring the target business system through the monitoring code to obtain original monitoring data;
[0011] The original monitoring data is converted into metric monitoring indicators.
[0012] Preferably, the raw monitoring data is converted into metric monitoring indicators, specifically including:
[0013] The raw monitoring data is converted into metric monitoring indicators through the simpleclient_common* component of prometheus.
[0014] Preferably, based on the instrument object and the bytebuddy bytecode operation library, the monitoring code is inserted into the class bytecode file, specifically including:
[0015] Based on the instrument object and the bytebuddy bytecode operation library, monitoring code is inserted into the target java method of the class bytecode file through AOP transformation.
[0016] Preferably, the monitoring code specifically includes any one or more of the following: monitoring code for callback before method entry, monitoring code for method exception callback, and monitoring code for method end callback.
[0017] Preferably, the monitoring code specifically includes a monitoring code for callback before method entry, a monitoring code for method exception callback and a monitoring code for method end callback; and the method further includes:
[0018] When executing the target Java method, the name and execution time of the target Java method are monitored and obtained through the monitoring code called back before the method is entered;
[0019] When the target Java method is executed abnormally, the monitoring code of the method exception callback is used to monitor and obtain the exception type and the exception time;
[0020] When the target Java method is executed, the time consumed in executing the target Java method is monitored and acquired through the monitoring code of the method end callback.
[0021] Preferably, the method further comprises:
[0022] The target java method is determined according to the correspondence between the technology stack and the java method to be monitored, as well as the technology stack of the target business system.
[0023] Preferably, the method further comprises:
[0024] Determine the key Java methods of each technology stack based on the core technical principles of each technology stack;
[0025] The key Java methods of each technology stack are used as the Java methods to be monitored to establish a corresponding relationship between the technology stack and the Java methods to be monitored.
[0026] A third aspect of the embodiments of the present application provides an electronic device, including:
[0027] Memory for storing computer programs;
[0028] A processor is used to execute the method described in any one of the first aspects of the embodiments of the present application.
[0029] A fourth aspect of the embodiments of the present application provides a computer-readable storage medium having a computer program stored thereon. When the computer program is executed by a processor, the method described in any one of the first aspects of the embodiments of the present application is implemented.
[0030] The monitoring method of the business system provided by the embodiment of the present application includes obtaining the instrument object in the premain method of the target business system, then obtaining the class bytecode file of the target business system through the instrument object, and then inserting the monitoring code into the class bytecode file based on the instrument object and the bytebuddy bytecode operation library. Since the method is not limited to the technology stack adopted by the target business system, the monitoring of the target business system can be achieved by inserting the monitoring code into the class bytecode file. Therefore, even if the multiple business systems deployed by the enterprise's server adopt different technology stacks, the method does not need to adapt the compatibility between technology stacks and other issues, thereby reducing the monitoring cost. BRIEF DESCRIPTION OF THE DRAWINGS
[0031] In order to more clearly illustrate the technical solutions of the embodiments of the present application, the drawings required for use in the embodiments of the present application will be briefly introduced below. It should be understood that the following drawings only show certain embodiments of the present application and therefore should not be regarded as limiting the scope. For ordinary technicians in this field, other related drawings can be obtained based on these drawings without paying creative work.
[0032] Figure 1 A schematic diagram of the structure of an electronic device provided in one embodiment of the present application;
[0033] Figure 2 A schematic diagram of a specific process of a monitoring method for a business system provided in one embodiment of the present application;
[0034] Figure 3 A schematic diagram of the correspondence between the technology stack and the metric monitoring indicators provided in an embodiment of the present application;
[0035] Figure 4 A schematic diagram of a specific flow chart of a method for monitoring a business system provided in another embodiment of the present application;
[0036] Figure 5 A schematic diagram of the specific structure of a monitoring device for a business system provided in another embodiment of the present application. DETAILED DESCRIPTION
[0037] The technical solutions in the embodiments of the present application will be described below in conjunction with the accompanying drawings in the embodiments of the present application. In the description of the present application, terms such as "first", "second", "third", etc. are only used to distinguish the description and cannot be understood as indicating or implying relative importance or sequence.
[0038] As mentioned earlier, an enterprise's server usually has multiple business systems deployed. In order to ensure the smooth operation of the enterprise's overall business, these business systems usually need to be monitored. However, these business systems may be built based on different technology stacks (Tech Stack). As a result, when monitoring these business systems, the monitoring cost is high due to the need to adapt to compatibility issues between technology stacks.
[0039] The technology stack refers to the collection of various technologies and tools used in the software development process, including programming languages, development frameworks, databases, operating systems, cloud services, etc. Different application scenarios and project requirements will have different impacts on the choice of technology stack, so choosing a suitable technology stack is one of the important factors to ensure the smooth progress of project development.
[0040] Based on this, the embodiments of the present application provide a monitoring method, device, electronic device and storage medium for a business system. Figure 1 The electronic device 1 is a schematic diagram of a specific structure. The electronic device 1 includes: at least one processor 11 and a memory 12, Figure 1 A processor is used as an example. The processor 11 and the memory 12 may be connected via a bus 10, and the memory 12 stores instructions executable by the processor 11, and the instructions are executed by the processor 11, so that the electronic device 1 can execute all or part of the process of the method in the following embodiment.
[0041] In practical applications, the electronic device 1 can be a user-side electronic device, such as a user's mobile phone, computer, etc.; of course, the electronic device 1 can also be a server-side electronic device, such as a server or server cluster, etc.
[0042] like Figure 2 The figure is a specific flow chart of the monitoring method of the business system provided by an embodiment of the present application. Some or all steps of the method can be performed by Figure 1 The method is performed by the electronic device 1 shown in the figure. Here, the electronic device 1 is specifically a server at the service end as an example to illustrate the method. The method includes the following steps:
[0043] Step S21: Obtain the instrument object in the premain method of the target business system.
[0044] Step S22: Obtain the class bytecode file of the target business system through the instrument object.
[0045] Here, step S21 and step S22 may be described uniformly.
[0046] The target business system may be any one of the multiple business systems deployed by the enterprise's server, such as a customer service system, a sales system, or a purchasing system. In practical applications, when a business system needs to be monitored, the business system may be used as the target business system in step S21.
[0047] The premain method is a special entry method provided by the Java language, which is used to perform some preprocessing operations before the application written in the Java language (called a Java application) is started. Among them, the premain method is part of the Agent mechanism of the Java language, through which the bytecode can be dynamically modified during the running of the Java application.
[0048] The underlying implementation of the instrument object relies on JVMTI (JVM Tool Interface), which is a set of interfaces exposed by the JVM for user extension. JVMTI is event-driven. Every time the JVM executes a certain logic, it will call some event callback interfaces (if any). These interfaces can be used by developers to extend their own logic.
[0049] For the specific implementation of step S21, before the application of the target business system is started, the instrument object in the premain method of the application of the target business system can be obtained, for example, the premain method can be obtained, and then the instrument object therein can be extracted. After the instrument object is obtained through the above step S21, the class bytecode file of the target business system can be obtained through the instrument object. For example, during the running of the application, the class bytecode can be read and executed in sequence, and then the file of the class bytecode, that is, the class bytecode file, can be associated with the instrument object.
[0050] Step S23: Based on the instrument object and the bytebuddy bytecode operation library, insert monitoring code into the class bytecode file.
[0051] Among them, the bytebuddy bytecode manipulation library is a code generation and modification library used to create Java proxy classes. Through these proxy classes, developers can modify or enhance existing classes at runtime.
[0052] In an embodiment of the present application, after the class bytecode file is obtained through the above-mentioned step S22, the monitoring code is inserted into the class bytecode file to implement the monitoring. Of course, the monitoring code is inserted into the class bytecode file based on the instrument object and the bytebuddy bytecode operation library.
[0053] Specifically, based on the instrument object and the bytebuddy bytecode operation library, the monitoring code can be inserted into the target Java method of the Class bytecode file through AOP transformation. Among them, AOP refers to aspect-oriented programming, which is a technical method for implementing program functions through pre-compilation and dynamic proxy during runtime. In the embodiment of the present application, the monitoring code is inserted into the Class bytecode file through AOP transformation.
[0054] In actual applications, the specific location for inserting the monitoring code in the Class bytecode file is to insert the monitoring code into the target java method in the Class bytecode file, and then monitor the startup, operation and other processes of the target java method. In other words, the target java method is taken as a specific monitoring object to insert the monitoring code and monitor it.
[0055] For example, each java method in the application of the target business system can be used as the target java method, so that during the running of the application, each java method can be identified, and then the monitoring code can be inserted into the java method of the class bytecode file; of course, only some key java methods in the application of the target business system can be used as the target java method, and then the monitoring code can be inserted into them. Therefore, the specific implementation method of step S23 can be based on the instrument object and the bytebuddy bytecode operation library to insert the monitoring code into the target java method of the class bytecode file.
[0056] In order to flexibly configure the target java methods to be monitored, in actual applications, the corresponding relationship between the technology stack and the java methods to be monitored can be established in advance. For example, according to the core technical principles of technology stack 1, its key java methods are java method a and java method b, so the java methods to be monitored are java method a and java method b. According to the core technical principles of technology stack 2, the java methods to be monitored are java method c and java method d, so that the corresponding relationship between the technology stack and the java methods to be monitored can be established. In this example, the java methods to be monitored by technology stack 1 are java method a and java method b, and the java methods to be monitored by technology stack 2 are java method c and java method d. In other words, the key java methods of each technology stack can be determined according to the core technical principles of each technology stack, and the key java methods of each technology stack can be used as the java methods to be monitored to establish the corresponding relationship.
[0057] After establishing the corresponding relationship, the technology stack of the target business system can be determined, and then the Java method that needs to be monitored by the technology stack of the target business system, that is, the target Java method, can be determined based on the corresponding relationship and the technology stack of the target business system. In this way, during the operation of the application of the target business system, the monitoring code is inserted into the target Java method through the method provided in the embodiment of the present application.
[0058] According to the actual monitoring needs, the monitoring code can specifically include any one or more of the following: monitoring code for callback before method entry, monitoring code for method exception callback, and monitoring code for method end callback. The monitoring code for callback before method entry can be used to monitor the target Java method before callback, so as to obtain the original monitoring data; the monitoring code for method exception callback can be used to monitor the target Java method when an exception occurs, so as to obtain the original monitoring data; the monitoring code for method end callback can be used to monitor the target Java method after it runs, so as to obtain the original monitoring data.
[0059] For example, for the target Java method, the monitoring code inserted at this time specifically includes the monitoring code of the callback before the method enters, the monitoring code of the method exception callback and the monitoring code of the method end callback. At this time, the method provided by the embodiment of the present application may also include: when executing the target Java method, through the monitoring code of the callback before the method enters, monitor and obtain the name and execution time of the target Java method; when the target Java method executes abnormally, through the monitoring code of the method exception callback, monitor and obtain the exception type and exception time; when the target Java method ends execution, through the monitoring code of the method end callback, monitor and obtain the time consumed to execute the target Java method.
[0060] The monitoring method of the business system provided by the embodiment of the present application includes obtaining the instrument object in the premain method of the target business system, then obtaining the class bytecode file of the target business system through the instrument object, and then inserting the monitoring code into the class bytecode file based on the instrument object and the bytebuddy bytecode operation library. Since the method is not limited to the technology stack adopted by the target business system, the monitoring of the target business system can be achieved by inserting the monitoring code into the class bytecode file. Therefore, even if the multiple business systems deployed by the enterprise's server adopt different technology stacks, the method does not need to adapt the compatibility between technology stacks and other issues, thereby reducing the monitoring cost.
[0061] In addition, in the method provided in the embodiment of the present application, since it is necessary to obtain the instrument object in the premain method of the target business system, the application of the target business system usually needs to be written in Java, or some modules in the application are written in Java, that is, the application of the target business system includes code written in Java. For example, the code of the target Java method can be code written in Java.
[0062] The above is a specific description of the method provided in the embodiment of the present application. For ease of understanding, the method can be further described here in conjunction with specific examples. For example, in actual applications, the enterprise's server is deployed with multiple business systems, and these business systems use different technology stacks, so that these business systems can be used as target business systems respectively, and then monitored in the following manner. The technology stack of the target business system can be determined first, and then the java method to be monitored by the technology stack of the target business system, that is, the target java method, can be determined based on the correspondence between the technology stack and the java method to be monitored, as well as the technology stack of the target business system; then the instrument object in the premain method of the target business system is obtained, and then the class bytecode file of the target business system is obtained through the instrument object, and then based on the instrument object and the bytebuddy bytecode operation library, the monitoring code is inserted into the target java method of the Class bytecode file through AOP transformation, so that monitoring can be achieved through the monitoring code.
[0063] It should be further explained that in the actual monitoring process, the original monitoring data can be obtained. For example, as mentioned above, the monitoring code of the method entry callback can be used to monitor the target Java method before the callback, so as to obtain the original monitoring data; the monitoring code of the method exception callback can be used to monitor the target Java method when an exception occurs, so as to obtain the original monitoring data; the monitoring code of the method end callback can be used to monitor after the target Java method ends, so as to obtain the original monitoring data.
[0064] The format of these original monitoring data is usually not intuitive and not convenient for users to view because it needs to be in accordance with the requirements of the relevant rules of the Java application. Therefore, the method can further include monitoring the target business system through the monitoring code to obtain the original monitoring data, such as the monitoring code of the method entry callback can be used to monitor the target Java method before the callback to obtain the original monitoring data; the monitoring code of the method exception callback can be used to monitor the target Java method when an exception occurs, so as to obtain the original monitoring data; the monitoring code of the method end callback can be used to monitor after the target Java method runs to obtain the original monitoring data.
[0065] After obtaining the original monitoring data, the original monitoring data can also be converted into metric monitoring indicators. In OpsMind, each type of object that needs to be observed and monitored is represented by a metric monitoring indicator. The metric monitoring indicator includes the basis for functions such as data viewing, alarm configuration, and configuration of the monitoring large screen. Therefore, converting the original monitoring data into metric monitoring indicators can facilitate display through the large screen function, thereby facilitating user viewing. For example, Table 1 shows the metric monitoring indicators in actual applications.
[0066] Table 1
[0067]
[0068]
[0069] In actual applications, the original monitoring data can be converted into metric monitoring indicators through the simpleclient_common* component of prometheus. Among them, prometheus is an open source service monitoring system and time series database. The simpleclient_common* component is a component in prometheus, which can convert the original monitoring data into metric monitoring indicators.
[0070] Therefore, in the method provided in the embodiment of the present application, after inserting the monitoring code into the target java method of the Class bytecode file, monitoring can be implemented through the monitoring code, and the original monitoring data can be obtained; of course, after obtaining the original monitoring data, the simpleclient_common* component of prometheus can be further used to convert the original monitoring data into metric monitoring indicators, which is convenient for large-screen display and user viewing.
[0071] It should be noted that different technology stacks usually correspond to different metric monitoring indicators. Therefore, before converting the original monitoring data into metric monitoring indicators through the simpleclient_common* component of prometheus, you can also obtain the technology stack of the target business system, and then determine the metric monitoring indicators corresponding to the technology stack of the target business system, and then convert the original monitoring data into the metric monitoring indicators through the simpleclient_common* component of prometheus.
[0072] When determining the metric monitoring indicator corresponding to the technology stack of the target business system, it can usually be determined based on the corresponding relationship between the technology stack and the metric monitoring indicator (called the second corresponding relationship). Figure 3 The following figure shows the correspondence between various technology stacks and metric monitoring indicators.
[0073] The above is a specific description of the method provided in the embodiment of the present application. For ease of understanding, the method can be further described here with reference to a specific example. In this example, the enterprise's server has multiple business systems deployed, and these business systems use different technology stacks. At this time, any business system can be used as the target business system. In this example, Figure 4 As shown, the method comprises the following steps:
[0074] Step S41: Determine the technology stack of the target business system.
[0075] Step S42: Determine the target Java method in the target business system according to the correspondence between the technology stack and the Java method to be monitored, and the technology stack of the target business system.
[0076] Step S43: Obtain the instrument object in the premain method of the target business system.
[0077] Step S44: Obtain the class bytecode file of the target business system through the instrument object.
[0078] Step S45: Based on the instrument object and the bytebuddy bytecode operation library, the monitoring code is inserted into the target Java method of the Class bytecode file through AOP transformation.
[0079] Step S46: Monitor the target business system through the monitoring code to obtain original monitoring data.
[0080] For example, the monitoring code of the method entry callback can be used to monitor the target Java method before the callback, so as to obtain the original monitoring data; the monitoring code of the method exception callback can be used to monitor the target Java method when an exception occurs, so as to obtain the original monitoring data; the monitoring code of the method end callback can be used to monitor after the target Java method ends, so as to obtain the original monitoring data.
[0081] Step S47: The original monitoring data is converted into metric monitoring indicators through the simpleclient_common* component of prometheus.
[0082] Based on the same inventive concept as the monitoring method of the business system provided in the embodiment of the present application, the embodiment of the present application also provides a monitoring device for the business system. For any part not specifically described in the embodiment of the device, reference may be made to the corresponding content of the method embodiment. Figure 3 FIG. 5 is a schematic diagram of a specific structure of the device 50, which includes: a first acquisition unit 501, a second acquisition unit 502 and a code insertion unit 503, wherein:
[0083] The first acquisition unit 501 is used to acquire the instrument object in the premain method of the target business system;
[0084] The second acquisition unit 502 is used to acquire the class bytecode file of the target business system through the instrument object;
[0085] The code insertion unit 503 is used to insert monitoring code into the class bytecode file based on the instrument object and the bytebuddy bytecode operation library.
[0086] The device 50 provided in the embodiment of the present application is adopted. Since the device 50 adopts the same inventive concept as the method provided in the embodiment of the present application, on the premise that the method can solve the technical problem, the device 50 can also solve the technical problem, which will not be repeated here.
[0087] In addition, in actual applications, the technical effects achieved by combining the device 50 with specific hardware equipment, cloud technology, etc. are also within the scope of protection of the present application. For example, different units in the device 50 are deployed in different nodes in the distributed cluster in a distributed cluster manner, or some units are deployed in a cloud server, etc., to improve efficiency and reduce costs.
[0088] The device 50 may further include an indicator conversion unit, which is used to monitor the target business system through the monitoring code to obtain original monitoring data; and convert the original monitoring data into a metric monitoring indicator.
[0089] The process of converting the raw monitoring data into metric monitoring indicators may specifically include:
[0090] The raw monitoring data is converted into metric monitoring indicators through the simpleclient_common* component of prometheus.
[0091] Among them, based on the instrument object and the bytebuddy bytecode operation library, inserting the monitoring code into the class bytecode file can specifically include: based on the instrument object and the bytebuddy bytecode operation library, inserting the monitoring code into the target Java method of the class bytecode file through AOP transformation.
[0092] The monitoring code specifically includes any one or more of the following: monitoring code for callback before method entry, monitoring code for method exception callback, and monitoring code for method end callback.
[0093] The monitoring code specifically includes a monitoring code for callback before method entry, a monitoring code for method exception callback, and a monitoring code for method end callback; and the method further includes:
[0094] When executing the target Java method, the name and execution time of the target Java method are monitored and obtained through the monitoring code called back before the method is entered;
[0095] When the target Java method is executed abnormally, the monitoring code of the method exception callback is used to monitor and obtain the exception type and the exception time;
[0096] When the target Java method is executed, the time consumed in executing the target Java method is monitored and acquired through the monitoring code of the method end callback.
[0097] The device 50 may also include a monitoring method determination unit, which is used to determine the target Java method according to the correspondence between the technology stack and the Java method to be monitored, and the technology stack of the target business system.
[0098] The device 50 may also include a correspondence establishing unit for determining the key Java methods of each technology stack according to the core technical principles of each technology stack; using the key Java methods of each technology stack as the Java methods to be monitored to establish a correspondence between the technology stack and the Java methods to be monitored.
[0099] The embodiment of the present invention further provides a computer-readable storage medium having a computer program stored thereon, characterized in that the computer program implements all or part of the process of the method in the above embodiment when executed by a processor. The storage medium may be a disk, an optical disk, a read-only memory (ROM), a random access memory (RAM), a flash memory, a hard disk drive (HDD) or a solid-state drive (SSD). The storage medium may also include a combination of the above-mentioned types of memory.
[0100] Although the embodiments of the present invention have been described in conjunction with the accompanying drawings, those skilled in the art may make various modifications and variations without departing from the spirit and scope of the present invention, and such modifications and variations are all within the scope defined by the appended claims.
Claims
1. A monitoring method for a business system, characterized in that: include: Get the instrument object in the premain method of the target business system; Get the class bytecode file of the target business system through the instrument object; Based on the instrument object and the bytebuddy bytecode operation library, monitoring code is inserted into the class bytecode file.
2. The method according to claim 1, characterized in that The method further comprises: Monitoring the target business system through the monitoring code to obtain original monitoring data; The original monitoring data is converted into metric monitoring indicators.
3. The method according to claim 2, characterized in that The original monitoring data is converted into metric monitoring indicators, specifically including: The raw monitoring data is converted into metric monitoring indicators through the simpleclient_common* component of prometheus.
4. The method according to claim 1, characterized in that: Based on the instrument object and the bytebuddy bytecode operation library, the monitoring code is inserted into the class bytecode file, specifically including: Based on the instrument object and the bytebuddy bytecode operation library, monitoring code is inserted into the target java method of the class bytecode file through AOP transformation.
5. The method according to claim 4, characterized in that The monitoring code specifically includes any one or more of the following: monitoring code for callback before method entry, monitoring code for method exception callback, and monitoring code for method end callback.
6. The method according to claim 5, characterized in that The monitoring code specifically includes the monitoring code for callback before method entry, the monitoring code for method exception callback and the monitoring code for method end callback; And, the method further comprises: When executing the target Java method, the name and execution time of the target Java method are monitored and obtained through the monitoring code called back before the method is entered; When the target Java method is executed abnormally, the monitoring code of the method exception callback is used to monitor and obtain the exception type and the exception time; When the target Java method is executed, the time consumed in executing the target Java method is monitored and acquired through the monitoring code of the method end callback.
7. The method according to claim 4, characterized in that The method further comprises: The target java method is determined according to the correspondence between the technology stack and the java method to be monitored, as well as the technology stack of the target business system.
8. The method according to claim 7, characterized in that The method further comprises: Determine the key Java methods of each technology stack based on the core technical principles of each technology stack; The key Java methods of each technology stack are used as the Java methods to be monitored to establish a corresponding relationship between the technology stack and the Java methods to be monitored.
9. An electronic device, characterized in that: include: Memory for storing computer programs; A processor, for executing the insurance claim material image processing method as claimed in any one of claims 1 to 8.
10. A computer-readable storage medium having a computer program stored thereon, characterized in that: When the computer program is executed by a processor, the insurance claim material image processing method according to any one of claims 1 to 8 is implemented.
