CN117056240A - Data element development and debugging method and system supporting offline Jar package - Google Patents
Data element development and debugging method and system supporting offline Jar package Download PDFInfo
- Publication number
- CN117056240A CN117056240A CN202311321391.2A CN202311321391A CN117056240A CN 117056240 A CN117056240 A CN 117056240A CN 202311321391 A CN202311321391 A CN 202311321391A CN 117056240 A CN117056240 A CN 117056240A
- Authority
- CN
- China
- Prior art keywords
- offline
- debugging
- jar package
- jar
- debugged
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Granted
Links
- 238000000034 method Methods 0.000 title claims abstract description 51
- 238000011161 development Methods 0.000 title claims abstract description 47
- 238000012545 processing Methods 0.000 claims abstract description 31
- 238000012216 screening Methods 0.000 claims abstract description 15
- 230000006870 function Effects 0.000 claims description 27
- 238000004364 calculation method Methods 0.000 claims description 20
- ZXQYGBMAQZUVMI-GCMPRSNUSA-N gamma-cyhalothrin Chemical compound CC1(C)[C@@H](\C=C(/Cl)C(F)(F)F)[C@H]1C(=O)O[C@H](C#N)C1=CC=CC(OC=2C=CC=CC=2)=C1 ZXQYGBMAQZUVMI-GCMPRSNUSA-N 0.000 claims description 6
- 238000004590 computer program Methods 0.000 claims description 5
- 238000012546 transfer Methods 0.000 claims description 3
- 239000013049 sediment Substances 0.000 abstract description 2
- 238000004891 communication Methods 0.000 description 18
- 230000000007 visual effect Effects 0.000 description 4
- 238000010586 diagram Methods 0.000 description 3
- 230000003287 optical effect Effects 0.000 description 2
- 238000012356 Product development Methods 0.000 description 1
- 238000012986 modification Methods 0.000 description 1
- 230000004048 modification Effects 0.000 description 1
- 230000004044 response Effects 0.000 description 1
- 238000006467 substitution reaction Methods 0.000 description 1
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/362—Software debugging
- G06F11/3644—Software debugging by instrumenting at runtime
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F21/00—Security arrangements for protecting computers, components thereof, programs or data against unauthorised activity
- G06F21/50—Monitoring users, programs or devices to maintain the integrity of platforms, e.g. of processors, firmware or operating systems
- G06F21/55—Detecting local intrusion or implementing counter-measures
- G06F21/56—Computer malware detection or handling, e.g. anti-virus arrangements
- G06F21/562—Static detection
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F21/00—Security arrangements for protecting computers, components thereof, programs or data against unauthorised activity
- G06F21/50—Monitoring users, programs or devices to maintain the integrity of platforms, e.g. of processors, firmware or operating systems
- G06F21/57—Certifying or maintaining trusted computer platforms, e.g. secure boots or power-downs, version controls, system software checks, secure updates or assessing vulnerabilities
- G06F21/577—Assessing vulnerabilities and evaluating computer system security
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/455—Emulation; Interpretation; Software simulation, e.g. virtualisation or emulation of application or operating system execution engines
- G06F9/45533—Hypervisors; Virtual machine monitors
- G06F9/45558—Hypervisor-specific management and integration aspects
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- General Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Computer Security & Cryptography (AREA)
- Computer Hardware Design (AREA)
- General Physics & Mathematics (AREA)
- Physics & Mathematics (AREA)
- Quality & Reliability (AREA)
- Health & Medical Sciences (AREA)
- General Health & Medical Sciences (AREA)
- Virology (AREA)
- Computing Systems (AREA)
- Stored Programmes (AREA)
Abstract
The application relates to the technical field of data element development, and provides a data element development and debugging method and system supporting an offline Jar package, wherein the method comprises the following steps: acquiring an offline Jar package, and screening the secure offline Jar package through secure scanning; generating an element model to be debugged by referring and configuring an offline Jar package; debugging the generated element model to be debugged through a debugging container, and outputting a debugging result; and displaying the debugging result in the modeling platform, and storing the debugged element model. According to the data element development and debugging method and system supporting the offline Jar package, the business sediment accumulated by a developer in the past is rapidly used for the capability of developing and processing the data element product, the developer of the data element product can directly upload the compiled offline Jar package and then quote the offline Jar package in a modeling platform, so that the repeated workload is greatly reduced, and the error probability in the modeling process is also greatly reduced.
Description
Technical Field
The application relates to the technical field of data element development, in particular to a data element development and debugging method and system supporting offline Jar packages.
Background
The existing data element product development platform is mainly used for modeling through dragging of the existing components or modeling through online coding, a new model is needed to be built in the modeling platform, debugging and modification are needed, and an existing business model or an offline program package of a developer cannot be referred to. This current situation results in the developer having to repeatedly develop the existing package before processing the data component product, increasing unnecessary workload and easily causing errors. Especially in the development scene of large development amount and complex data composition, the existing data element debugging method has low efficiency and the data debugging accuracy is not guaranteed.
Therefore, how to provide a more efficient and accurate method for developing and debugging data elements is a technical problem to be solved.
Disclosure of Invention
In view of the above, the present application aims to provide a method and a system for developing and debugging data elements supporting offline Jar packages.
In a first aspect of the present application, a method for supporting development and debugging of a data element of an offline Jar package is provided, including:
acquiring an offline Jar package, and screening the secure offline Jar package through secure scanning;
generating an element model to be debugged by referencing and configuring an offline Jar package, comprising: dragging in an input component, a computing component and an output component in a modeling platform, and associating the output component with the computing component;
selecting a data resource table to be loaded and processed by setting the attribute of the input component;
referencing an offline Jar package passing through security scanning by setting the attribute of the computing component, and configuring a main program path and a main function entry of the referenced offline Jar package;
storing the output assembly, the input assembly and the computing assembly which are subjected to attribute setting, and generating an element model to be debugged;
debugging the generated element model to be debugged through a debugging container, outputting a debugging result, and comprising the following steps: selecting and starting a JVM runtime environment from a mirror warehouse according to the element model to be debugged;
loading the offline Jar package according to the main program path of the offline Jar package, and analyzing the loaded offline Jar package into executable Java codes;
loading sample data of a data resource table selected by the input component, and sending the loaded sample data to the executable Java code as input;
executing the Java code according to the main function entry of the offline Jar packet, loading and processing sample data serving as input, obtaining a calculation result and transmitting the calculation result to an output component in the modeling platform;
and displaying the debugging result in the modeling platform, and storing the debugged element model.
According to some embodiments of the application, the obtaining the offline Jar package, screening the secure offline Jar package through secure scanning includes:
identifying offline Jar packages with risks through security scanning, wherein the risks comprise loopholes and Trojan programs, carrying out risk identification on the offline Jar packages with risks, and obtaining the offline Jar packages without risk identification through screening.
According to some embodiments of the application, the loading and processing of the sample data as input comprises:
and writing processing logic through the business processing function of the offline Jar packet, and processing the loaded sample data according to the written processing logic.
According to some embodiments of the application, the presenting the debug result in the modeling platform and saving the debugged element model includes:
and receiving the debugging result transmitted by the debugging container through the output component, displaying the received debugging result in the modeling platform, and storing an element model corresponding to the debugging result.
In a second aspect of the present application, there is provided a data element development and debugging system supporting offline Jar packages, comprising:
the model management module is used for acquiring an offline Jar package and screening the secure offline Jar package through secure scanning;
the modeling module is used for generating an element model to be debugged by referring and configuring an offline Jar package, and comprises the following steps: dragging in an input component, a computing component and an output component in a modeling platform, and associating the output component with the computing component; selecting a data resource table to be loaded and processed by setting the attribute of the input component; referencing an offline Jar package passing through security scanning by setting the attribute of the computing component, and configuring a main program path and a main function entry of the referenced offline Jar package; storing the output assembly, the input assembly and the computing assembly which are subjected to attribute setting, and generating an element model to be debugged; displaying the debugging result in a modeling platform, and storing a debugged element model;
the debugging module is used for debugging the generated element model to be debugged through the debugging container, outputting a debugging result and comprises the following steps: selecting and starting a JVM runtime environment from a mirror warehouse according to the element model to be debugged; loading the offline Jar package according to the main program path of the offline Jar package, and analyzing the loaded Jar package into executable Java codes; loading sample data of a data resource table selected by the input component, and sending the loaded sample data to the executable Java code as input; and executing the Java code according to the main function entry of the offline Jar packet, loading and processing sample data serving as input, obtaining a calculation result and transmitting the calculation result to an output component in the modeling platform.
According to some embodiments of the present application, the model management module is specifically configured to obtain an offline Jar package, identify the offline Jar package with risk through security scanning, where the risk includes a vulnerability and a Trojan program, perform risk identification on the offline Jar package with risk, and obtain the offline Jar package without risk identification through screening.
According to some embodiments of the present application, the debugging module is specifically configured to write processing logic through the service processing function of the offline Jar packet, and process the loaded sample data according to the written processing logic.
According to some embodiments of the present application, the modeling module is specifically configured to receive, through the output component, a debug result transmitted by the debug container, display the received debug result in the modeling platform, and store an element model corresponding to the debug result.
In a third aspect of the present application, there is provided a computer readable storage medium having stored thereon a program for implementing information transfer, which when executed by a processor, implements the steps of a data element development and debugging method supporting an offline Jar package as described above.
In a fourth aspect of the application, a computer device is provided, the computer device comprising a memory, a processor and a computer program stored on the memory and executable on the processor, the processor implementing the steps of the method of loading and processing sample data as described above when the program is executed.
The data element development and debugging method and system supporting the offline Jar package can be used for rapidly applying the accumulated business sediment of the developer to the development and processing capacity of the data element product, and the developer of the data element product can directly upload the compiled offline Jar package and then quote the offline Jar package in a modeling platform, so that the repeated workload is greatly reduced, and the error probability in the modeling process is also greatly reduced.
Drawings
In order to more clearly illustrate the technical solutions of the embodiments of the present application, the drawings that are needed in the embodiments will be briefly described below, and it is obvious that the drawings in the following description are only some embodiments of the present application, and that other drawings can be obtained according to these drawings without inventive effort for a person skilled in the art.
FIG. 1 is a schematic diagram of a system for supporting an offline Jar package data element development and debugging method, in accordance with an embodiment of the present application;
FIG. 2 is a diagram of a debug server in a data element development and debug system supporting offline Jar packages according to an embodiment of the present application;
FIG. 3 is a flowchart illustrating steps of a method for developing and debugging a data element supporting an offline Jar package according to an embodiment of the present application;
FIG. 4 is a flowchart illustrating an exemplary scenario of a data element development and debugging method supporting offline Jar packages according to an embodiment of the present application;
fig. 5 is a schematic structural diagram of the apparatus provided by the present application.
Detailed Description
Embodiments of the present application will be described in detail below with reference to the accompanying drawings.
It should be noted that, without conflict, the following embodiments and features in the embodiments may be combined with each other; and, based on the embodiments in this disclosure, all other embodiments that may be made by one of ordinary skill in the art without inventive effort are within the scope of the present disclosure.
It is noted that various aspects of the embodiments are described below within the scope of the following claims. It should be apparent that the aspects described herein may be embodied in a wide variety of forms and that any specific structure and/or function described herein is merely illustrative. Based on the present disclosure, one skilled in the art will appreciate that one aspect described herein may be implemented independently of any other aspect, and that two or more of these aspects may be combined in various ways. For example, an apparatus may be implemented and/or a method practiced using any number of the aspects set forth herein. In addition, such apparatus may be implemented and/or such methods practiced using other structure and/or functionality in addition to one or more of the aspects set forth herein.
FIG. 1 illustrates an exemplary system for supporting a data element development and debugging method for offline Jar packages, suitable for use with embodiments of the present application. As shown in fig. 1, the system may include a debug server 101, a communication network 102, and/or one or more debug clients 103, an example of which is a plurality of debug clients 103 in fig. 1.
Debug server 101 may be any suitable server for storing information, data, programs, and/or any other suitable type of content. In some embodiments, debug server 101 may perform appropriate functions. For example, in some embodiments, debug server 101 may be used to support data element development debugging of offline Jar packages. As an alternative example, in some embodiments, debug server 101 may be used to implement data element development debugging that supports offline Jar packages by generating an element model to be debugged. For example, the debug server 101 may be configured to obtain an offline Jar package, and screen the secure offline Jar package through secure scanning; generating an element model to be debugged by referring and configuring an offline Jar package; debugging the generated element model to be debugged through a debugging container, and outputting a debugging result; and displaying the debugging result in the modeling platform, and storing the debugged element model.
As an example, as shown in fig. 2, the present embodiment supports a data element of an offline Jar package to develop a debug server in a debug system, including:
the model management module is used for acquiring an offline Jar package and screening the secure offline Jar package through secure scanning;
the modeling module generates an element model to be debugged by referring and configuring an offline Jar package; displaying the debugging result in a modeling platform, and storing a debugged element model;
the debugging module is used for debugging the generated element model to be debugged through the debugging container and outputting a debugging result.
As another example, the present embodiment supports the data element development of offline Jar packages in a debug server in a debug system:
the model management module is specifically used for acquiring an offline Jar package, identifying the offline Jar package with risk through security scanning, wherein the risk comprises a vulnerability and a Trojan horse program, carrying out risk identification on the offline Jar package with risk, and obtaining the offline Jar package without risk identification through screening;
the debugging module is specifically used for selecting and starting the JVM runtime environment from the mirror image warehouse according to the element model to be debugged; loading an offline Jar package according to a main program path of the offline Jar package, and analyzing the loaded Jar package into executable Java codes; loading sample data of the data resource table selected by the input component, and sending the loaded sample data to the executable Java code as input; and executing Java codes according to the main function entry of the offline Jar package, loading and processing sample data serving as input, obtaining a calculation result and transmitting the calculation result to an output component in the modeling platform.
The modeling module is specifically used for dragging in an input assembly, a calculation assembly and an output assembly in the modeling platform, and associating the output assembly with the calculation assembly; selecting a data resource table to be loaded and processed by setting the attribute of the input component; configuring a main program path and a main function entry of the offline Jar package which are referenced through the security scanning by setting the attribute reference of the computing component; the method comprises the steps of storing an output assembly, an input assembly and a calculation assembly which are set by attributes, and generating an element model to be debugged; and receiving the debugging result transmitted by the debugging container through the output component, displaying the received debugging result in the modeling platform, and storing an element model corresponding to the debugging result.
As another example, in some embodiments, the debug server 101 may send data element development debug methods supporting offline Jar packages to the debug client 103 for use by a user upon request of the debug client 103.
As an optional example, in some embodiments, the debug client 103 is configured to provide a visual debug interface, where the visual debug interface is configured to receive a selection input operation of developing the debug data element by the user, and, in response to the selection input operation, obtain, from the debug server 101, a visual debug interface corresponding to an option selected by the selection input operation, and display the visual debug interface, where at least information of developing the debug data element and an operation option for the information of developing the debug data element are displayed.
In some embodiments, communication network 102 may be any suitable combination of one or more wired and/or wireless networks. For example, the communication network 102 can include any one or more of the following: the internet, an intranet, a Wide Area Network (WAN), a Local Area Network (LAN), a wireless network, a Digital Subscriber Line (DSL) network, a frame relay network, an Asynchronous Transfer Mode (ATM) network, a Virtual Private Network (VPN), and/or any other suitable communication network. Debug client 103 is capable of being connected to communication network 102 via one or more communication links (e.g. communication link 104), which communication network 102 is capable of being linked to debug server 101 via one or more communication links (e.g. communication link 105). The communication link may be any communication link suitable for transferring data between the debug client 103 and the debug server 101, such as a network link, a dial-up link, a wireless link, a hardwired link, any other suitable communication link, or any suitable combination of such links.
Debug client 103 may include any one or more clients that present interfaces related to development of debugging of data elements supporting offline Jar packages in an appropriate form for use and operation by a user. In some embodiments, debug client 103 may comprise any suitable type of device. For example, in some embodiments, debug client 103 may include a mobile device, a tablet computer, a laptop computer, a desktop computer, and/or any other suitable type of client device.
Although debug server 101 is illustrated as one device, in some embodiments any suitable number of devices may be used to perform the functions performed by debug server 101. For example, in some embodiments, multiple devices may be used to implement the functions performed by debug server 101. Alternatively, the functions of the debug server 101 may be implemented using cloud services.
Based on the above system, the embodiment of the application provides a data element development and debugging method supporting offline Jar packages, which is described in the following embodiments.
Referring to FIG. 3, a flowchart of steps for a data element development and debugging method supporting offline Jar packages is shown, according to an embodiment of the present application.
The data element development and debugging method supporting the offline Jar package of the present embodiment may be executed at a debugging server, and the data element development and debugging method supporting the offline Jar package includes the following steps:
step S201: and acquiring an offline Jar package, and screening the secure offline Jar package through secure scanning.
The method of the embodiment identifies offline Jar packages with risks including, but not limited to, vulnerabilities and trojan programs through security scanning. And after identifying the offline Jar package with risk through security scanning, carrying out risk identification on the offline Jar package with risk, and obtaining the offline Jar package without risk identification through screening.
Step S202: and generating an element model to be debugged by referencing and configuring an offline Jar package.
In the method, before generating the element model to be debugged according to the offline Jar package, related input components, output components and computing components are required to be set. As one example, an input component, a computing component, and an output component are dragged in a modeling platform, associating the output component with the computing component; selecting a data resource table to be loaded and processed by setting the attribute of the input component; configuring a main program path and a main function entry of the offline Jar package which are referenced through the security scanning by setting the attribute reference of the computing component; and storing the output component, the input component and the computing component which are subjected to attribute setting, and generating an element model to be debugged. Those skilled in the art may generate the component model to be debugged in an online modeling platform of the data component according to the method of the present embodiment, where the modeling platform includes, but is not limited to, an online modeling platform in the form of a component development canvas, etc., and the present embodiment is not limited thereto.
Step S203: and debugging the generated element model to be debugged through the debugging container, and outputting a debugging result.
As an example, the present embodiment selects and initiates a JVM runtime environment, which is a software layer running on top of a computer operating system, from a mirror repository according to the component model to be debugged, providing additional services specific to Java.
The JVM runtime environment loads an offline Jar package according to a main program path of the offline Jar package, and analyzes the loaded Jar package into executable Java codes; the JVM runtime environment loads sample data of the data resource table selected by the input component, and sends the loaded sample data to the executable Java code as input; the JVM runtime environment executes Java codes according to a main function entry of an offline Jar package, loads and processes sample data as input, specifically, compiles processing logic through a business processing function of the offline Jar package, processes the loaded sample data according to the compiled processing logic, obtains a calculation result and transmits the calculation result to an output component in a modeling platform.
Step S204: and displaying the debugging result in the modeling platform, and storing the debugged element model.
And receiving the debugging result transmitted by the debugging container through the output component, displaying the received debugging result in the modeling platform, and storing an element model corresponding to the debugging result.
The data element development and debugging method supporting offline Jar packages according to the present embodiment is described in detail below in an exemplary scenario. Referring to fig. 4, the data element development and debugging method supporting offline Jar package according to the present embodiment is implemented in the following manner:
1. uploading an offline Jar package by a developer in a model management module, and automatically performing security scanning on the offline Jar package by an element development platform through the model management module to ensure that vulnerabilities and Trojan programs which have risks on a database or a platform server do not exist in the offline Jar package;
2. dragging an input assembly into an element development canvas, and setting a data resource table to be loaded in an attribute panel of the input assembly;
3. continuously dragging a computing component into an element development canvas, taking the computing component as the next node of an input component, selecting an offline Jar package to be referenced in an attribute panel of the computing component, setting a main program path and a main function entry of the Jar package, and loading sample data of a data resource table associated with the input component when the offline Jar package is set to be completed in debugging;
4. continuously dragging an output component into the element development canvas, wherein the output component is used as the next node of the computing component, and the output component receives a debugging result and displays the debugging result on the development canvas;
5. all components and attribute settings on the development canvas are saved, and an element model to be debugged is obtained;
6. the developer firstly locks the components and attributes on the development canvas, then starts the debugging operation, and the debugging container selects and starts the JVM runtime environment from the mirror warehouse;
7. the runtime environment loads the Jar package according to the main program path and analyzes the Jar package into executable Java codes;
8. the runtime environment loads sample data of the data resource table selected by the input component and transmits the sample data as input to the executable Java code;
9. the runtime environment starts to execute Java codes according to the set main function entry, processes the loaded sample data to obtain a calculation result, and transmits the calculation result to the output component, wherein the calculation result is processed content of the sample data by the business processing function of the Jar packet;
10. after the output component obtains the calculation result, the calculation result is displayed in a result display area of the development canvas;
11. the developer views and validates the debugging results on the canvas and saves the element model.
The method of the embodiment aims at solving the problem of how to enable a data element product developer to quickly directly refer an existing offline package to the development of the data element product.
According to the method, an offline program package is embedded into a traditional online modeling platform, through specifying the file path, the main program path and the file name of the offline program package (Jar package), the main function entry in the main program and other related parameter settings, the offline Jar package can be directly loaded into a debugging development container (called a debugging container for short) of an element development platform, the debugging container can select and start a JVM runtime environment from a mirror warehouse, the runtime environment loads Jar package files according to the set paths, the runtime environment converts the Jar package into executable Java codes, the codes start to be executed according to the set main program entry and main function, and then the executed results are output to an output component configured on a canvas.
The method can deposit accumulated business of a developer in the past, can be rapidly used for the capability of developing and processing data element products, can directly upload compiled offline Jar packages by the developer of the data element products, and then refers to the offline Jar packages in a modeling platform, so that the repeated workload is greatly reduced, the error probability in the modeling process is also greatly reduced, and if certain processing logic in the existing offline Jar packages needs to be adjusted, codes can be edited after decompilation by using an online IDE editor, and then the online Jar packages are repackaged, and new Jar packages are directly referred to in a development canvas.
As shown in FIG. 5, the present application also provides an apparatus comprising a processor 310, a communication interface 320, a memory 330 for storing a processor executable computer program, and a communication bus 340. Wherein the processor 310, the communication interface 320 and the memory 330 perform communication with each other through the communication bus 340. Processor 310 develops the debugging method by running an executable computer program to implement the data element supporting the offline Jar package described above.
The computer program in the memory 330 may be implemented in the form of software functional units and may be stored in a computer-readable storage medium when sold or used as a separate product. Based on this understanding, the technical solution of the present application may be embodied essentially or in a part contributing to the prior art or in a part of the technical solution in the form of a software product stored in a storage medium, comprising several instructions for causing a computer device (which may be a personal computer, a server, a network device, etc.) to perform all or part of the steps of the method of the embodiments of the present application. And the aforementioned storage medium includes: a U-disk, a removable hard disk, a Read-Only Memory (ROM), a random access Memory (RAM, random Access Memory), a magnetic disk, or an optical disk, or other various media capable of storing program codes.
The system embodiments described above are merely illustrative, in which elements illustrated as separate elements may or may not be physically separate, and elements shown as elements may or may not be physical elements, may be located in one place, or may be distributed over a plurality of network elements. Some or all of the modules may be selected based on actual needs to achieve the purpose of the embodiment. Those of ordinary skill in the art will understand and implement the present application without undue burden.
From the above description of the embodiments, it will be apparent to those skilled in the art that the embodiments may be implemented by means of software plus necessary general hardware platforms, or of course may be implemented by means of hardware. Based on such understanding, the foregoing technical solutions may be embodied essentially or in part in the form of a software product, which may be stored in a computer-readable storage medium, such as a ROM/RAM, a magnetic disk, an optical disk, etc., including several instructions to cause a computer device (which may be a personal computer, a server, or a network device, etc.) to perform the various embodiments or methods of some parts of the embodiments.
The foregoing is merely illustrative of the present application, and the present application is not limited thereto, and any changes or substitutions easily contemplated by those skilled in the art within the scope of the present application should be included in the present application. Therefore, the protection scope of the application is subject to the protection scope of the claims.
Claims (10)
1. A method for supporting development and debugging of a data element of an offline Jar package, the method comprising:
acquiring an offline Jar package, and screening the secure offline Jar package through secure scanning;
generating an element model to be debugged by referencing and configuring an offline Jar package, comprising: dragging in an input component, a computing component and an output component in a modeling platform, and associating the output component with the computing component;
selecting a data resource table to be loaded and processed by setting the attribute of the input component;
referencing an offline Jar package passing through security scanning by setting the attribute of the computing component, and configuring a main program path and a main function entry of the referenced offline Jar package;
storing the output assembly, the input assembly and the computing assembly which are subjected to attribute setting, and generating an element model to be debugged;
debugging the generated element model to be debugged through a debugging container, outputting a debugging result, and comprising the following steps: selecting and starting a JVM runtime environment from a mirror warehouse according to the element model to be debugged;
loading the offline Jar package according to the main program path of the offline Jar package, and analyzing the loaded offline Jar package into executable Java codes;
loading sample data of a data resource table selected by the input component, and sending the loaded sample data to the executable Java code as input;
executing the Java code according to the main function entry of the offline Jar packet, loading and processing sample data serving as input, obtaining a calculation result and transmitting the calculation result to an output component in the modeling platform;
and displaying the debugging result in the modeling platform, and storing the debugged element model.
2. The method for developing and debugging a data element supporting an offline Jar package according to claim 1, wherein the step of obtaining the offline Jar package and screening the secure offline Jar package by secure scanning comprises:
identifying offline Jar packages with risks through security scanning, wherein the risks comprise loopholes and Trojan programs, carrying out risk identification on the offline Jar packages with risks, and obtaining the offline Jar packages without risk identification through screening.
3. The data element development and debugging method supporting offline Jar package of claim 1, wherein the loading and processing of sample data as input comprises:
and writing processing logic through the business processing function of the offline Jar packet, and processing the loaded sample data according to the written processing logic.
4. The method for developing and debugging a data element supporting an offline Jar package according to claim 1, wherein the step of exposing the debugging result in the modeling platform and saving the debugged element model comprises the steps of:
and receiving the debugging result transmitted by the debugging container through the output component, displaying the received debugging result in the modeling platform, and storing an element model corresponding to the debugging result.
5. A data element development and debugging system supporting offline Jar packages, comprising:
the model management module is used for acquiring an offline Jar package and screening the secure offline Jar package through secure scanning;
the modeling module is used for generating an element model to be debugged by referring and configuring an offline Jar package, and comprises the following steps: dragging in an input component, a computing component and an output component in a modeling platform, and associating the output component with the computing component; selecting a data resource table to be loaded and processed by setting the attribute of the input component; referencing an offline Jar package passing through security scanning by setting the attribute of the computing component, and configuring a main program path and a main function entry of the referenced offline Jar package; storing the output assembly, the input assembly and the computing assembly which are subjected to attribute setting, and generating an element model to be debugged; displaying the debugging result in a modeling platform, and storing a debugged element model;
the debugging module is used for debugging the generated element model to be debugged through the debugging container, outputting a debugging result and comprises the following steps: selecting and starting a JVM runtime environment from a mirror warehouse according to the element model to be debugged; loading the offline Jar package according to the main program path of the offline Jar package, and analyzing the loaded Jar package into executable Java codes; loading sample data of a data resource table selected by the input component, and sending the loaded sample data to the executable Java code as input; and executing the Java code according to the main function entry of the offline Jar packet, loading and processing sample data serving as input, obtaining a calculation result and transmitting the calculation result to an output component in the modeling platform.
6. The system for developing and debugging a data element supporting an offline Jar package according to claim 5, wherein the model management module is specifically configured to obtain the offline Jar package, identify the offline Jar package with risk through security scanning, where the risk includes a vulnerability and a Trojan horse program, perform risk identification on the offline Jar package with risk, and obtain the offline Jar package without risk identification through screening.
7. The system for developing and debugging a data element supporting an offline Jar package according to claim 5, wherein the debugging module is specifically configured to write processing logic through a business processing function of the offline Jar package, and process the loaded sample data according to the written processing logic.
8. The system for developing and debugging data elements supporting offline Jar packages according to claim 5, wherein the modeling module is specifically configured to receive, through the output component, a debug result transmitted by the debug container, display the received debug result in the modeling platform, and store an element model corresponding to the debug result.
9. A computer-readable storage medium, in which a program for implementing information transfer is stored, which program, when executed by a processor, implements the steps of the data element development and debugging method supporting an offline Jar package according to any one of claims 1 to 4.
10. A computer device comprising a memory, a processor and a computer program stored on the memory and executable on the processor, the processor implementing the steps of the data element development and debugging method supporting offline Jar packages as claimed in any of claims 1-4 when the program is executed.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202311321391.2A CN117056240B (en) | 2023-10-13 | 2023-10-13 | Data element development and debugging method and system supporting offline Jar package |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202311321391.2A CN117056240B (en) | 2023-10-13 | 2023-10-13 | Data element development and debugging method and system supporting offline Jar package |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN117056240A true CN117056240A (en) | 2023-11-14 |
| CN117056240B CN117056240B (en) | 2024-02-13 |
Family
ID=88655809
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202311321391.2A Active CN117056240B (en) | 2023-10-13 | 2023-10-13 | Data element development and debugging method and system supporting offline Jar package |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN117056240B (en) |
Cited By (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN117472552A (en) * | 2023-12-28 | 2024-01-30 | 中电数据产业有限公司 | Service scene intelligent arrangement and dynamic scheduling method, device, equipment and medium |
| CN117556453A (en) * | 2024-01-14 | 2024-02-13 | 中电数据产业有限公司 | In-field processing method and system for data elements based on original data without domain |
Citations (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20130125092A1 (en) * | 2011-11-11 | 2013-05-16 | General Electric Company | Generating deployable code from simulation models |
| CN108647142A (en) * | 2018-05-07 | 2018-10-12 | 杭州有赞科技有限公司 | A kind of Gatling pressure surveys script local precompile adjustment method and system |
| CN111026636A (en) * | 2019-09-27 | 2020-04-17 | 珠海随变科技有限公司 | Software project testing method, device, equipment and storage medium |
| CN113986733A (en) * | 2021-10-28 | 2022-01-28 | 中国平安人寿保险股份有限公司 | Jar package based performance test method, device, equipment and storage medium |
-
2023
- 2023-10-13 CN CN202311321391.2A patent/CN117056240B/en active Active
Patent Citations (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20130125092A1 (en) * | 2011-11-11 | 2013-05-16 | General Electric Company | Generating deployable code from simulation models |
| CN108647142A (en) * | 2018-05-07 | 2018-10-12 | 杭州有赞科技有限公司 | A kind of Gatling pressure surveys script local precompile adjustment method and system |
| CN111026636A (en) * | 2019-09-27 | 2020-04-17 | 珠海随变科技有限公司 | Software project testing method, device, equipment and storage medium |
| CN113986733A (en) * | 2021-10-28 | 2022-01-28 | 中国平安人寿保险股份有限公司 | Jar package based performance test method, device, equipment and storage medium |
Cited By (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN117472552A (en) * | 2023-12-28 | 2024-01-30 | 中电数据产业有限公司 | Service scene intelligent arrangement and dynamic scheduling method, device, equipment and medium |
| CN117472552B (en) * | 2023-12-28 | 2024-05-28 | 中电数据产业有限公司 | Service scene intelligent arrangement and dynamic scheduling method, device, equipment and medium |
| CN117556453A (en) * | 2024-01-14 | 2024-02-13 | 中电数据产业有限公司 | In-field processing method and system for data elements based on original data without domain |
| CN117556453B (en) * | 2024-01-14 | 2024-04-30 | 中电数据产业有限公司 | In-field processing method and system for data elements based on original data without domain |
Also Published As
| Publication number | Publication date |
|---|---|
| CN117056240B (en) | 2024-02-13 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN117056240B (en) | Data element development and debugging method and system supporting offline Jar package | |
| US10642725B2 (en) | Automated test generation for multi-interface enterprise virtualization management environment | |
| US9760343B2 (en) | Application builder based on metadata | |
| CN108038051A (en) | Dissemination method, device, computer equipment and the storage medium of micro services | |
| Rahman et al. | Security misconfigurations in open source kubernetes manifests: An empirical study | |
| US11561889B2 (en) | Orchestration for automated performance testing | |
| US20210304027A1 (en) | Message Management Using Machine Learning Techniques | |
| US20110178946A1 (en) | Systems and methods for redundancy using snapshots and check pointing in contact handling systems | |
| US9935849B2 (en) | Assessing a service offering in a networked computing environment | |
| US20110179304A1 (en) | Systems and methods for multi-tenancy in contact handling systems | |
| CN110196809B (en) | Interface testing method and device | |
| CN106874028A (en) | Using dispositions method and device | |
| US20180307574A1 (en) | Automated test generation for multi-interface and multi-platform enterprise virtualization management environment | |
| US20240004966A1 (en) | Onboarding of Monitoring Tools | |
| US20230084685A1 (en) | Constraints-based refactoring of monolith applications through attributed graph embeddings | |
| US20200167172A1 (en) | Declarative technical configuration composer for integration setup | |
| KR20150133902A (en) | System and method for developing of service based on software product line | |
| CN116760682B (en) | Log acquisition and filtration method, device, equipment and medium | |
| US20220030079A1 (en) | Methods and systems for recording user operations on a cloud management platform | |
| CN117519683A (en) | Modeling method and system based on online IDE coding component combined with DAG | |
| US9934019B1 (en) | Application function conversion to a service | |
| CN115134228A (en) | Environment link supply and detection method, device, equipment, medium and program product | |
| US9542171B2 (en) | Managing an application modification process | |
| CN112395194B (en) | Method and device for accessing test platform | |
| CN113360417B (en) | Test method, session modifier, electronic device and medium |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |