CN117170723A - Java code heat treatment method and device, medium and equipment - Google Patents
Java code heat treatment method and device, medium and equipment Download PDFInfo
- Publication number
- CN117170723A CN117170723A CN202311022046.9A CN202311022046A CN117170723A CN 117170723 A CN117170723 A CN 117170723A CN 202311022046 A CN202311022046 A CN 202311022046A CN 117170723 A CN117170723 A CN 117170723A
- Authority
- CN
- China
- Prior art keywords
- code
- code resource
- resource
- class
- changed
- 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.)
- Pending
Links
- 238000000034 method Methods 0.000 title claims abstract description 69
- 238000010438 heat treatment Methods 0.000 title claims abstract description 13
- 230000006870 function Effects 0.000 claims description 14
- 238000012544 monitoring process Methods 0.000 claims description 7
- 230000008859 change Effects 0.000 claims description 6
- 230000004048 modification Effects 0.000 claims description 5
- 238000012986 modification Methods 0.000 claims description 5
- 238000004590 computer program Methods 0.000 claims description 2
- 230000008569 process Effects 0.000 abstract description 8
- 230000009286 beneficial effect Effects 0.000 description 3
- 230000007246 mechanism Effects 0.000 description 3
- 230000008439 repair process Effects 0.000 description 3
- 238000012217 deletion Methods 0.000 description 2
- 230000037430 deletion Effects 0.000 description 2
- 238000012545 processing Methods 0.000 description 2
- 230000005540 biological transmission Effects 0.000 description 1
- 238000004891 communication Methods 0.000 description 1
- 238000005516 engineering process Methods 0.000 description 1
- 230000003287 optical effect Effects 0.000 description 1
- 230000000750 progressive effect Effects 0.000 description 1
- 230000003068 static effect Effects 0.000 description 1
Classifications
-
- Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y02—TECHNOLOGIES OR APPLICATIONS FOR MITIGATION OR ADAPTATION AGAINST CLIMATE CHANGE
- Y02D—CLIMATE CHANGE MITIGATION TECHNOLOGIES IN INFORMATION AND COMMUNICATION TECHNOLOGIES [ICT], I.E. INFORMATION AND COMMUNICATION TECHNOLOGIES AIMING AT THE REDUCTION OF THEIR OWN ENERGY USE
- Y02D10/00—Energy efficient computing, e.g. low power processors, power management or thermal management
Landscapes
- Stored Programmes (AREA)
Abstract
The invention provides a Java code heat treatment method and device, a medium and equipment. The method comprises the following steps: initializing a code monitor through a code resource manager so that the initialized code monitor can monitor whether code resources stored in a disk are changed or not; wherein each code resource has a unique ID; when the code monitor monitors that the code resource is changed, the changed code resource is utilized to replace the code resource corresponding to the same ID on the disk, an updating interface of a code resource warehouse is called, and the ID of the changed code resource and the changed code resource are transmitted to the updating interface, so that the code resource warehouse replaces the original code resource corresponding to the ID with the changed code resource. When the need of repairing the application loopholes or the quick iteration application exists, the need of updating the Java code can be met through the above process, and the updating of the code is not limited.
Description
Technical Field
The present invention relates to the field of Java technologies, and in particular, to a Java code heat treatment method and apparatus, a medium, and a device.
Background
When the Java application is started, the Java application is transferred to a series of class paths of the Java virtual machine, and in the running process of the Java application, if the class is required, the Java virtual machine searches and loads the class according to the class paths. The Java virtual machine loading of the class is completed through a class loader, and a mechanism called parent delegation is specifically adopted to find the class. When a class loader receives a class loading request, it first delegates the class to the parent class loader to complete, and each layer of class loading is treated as this, so all loading requests should be transferred to the top-level boot class loader, and only when the parent class loader feeds back that it cannot complete the loading request, the child loader will try to do so. The class is generally not changed after being loaded, but in order to repair the application loopholes in time or iterate the application functions quickly, the need for modifying Java codes in operation is unavoidable.
Disclosure of Invention
Aiming at least one technical problem, the embodiment of the invention provides a Java code heat treatment method, a Java code heat treatment device, a Java code heat treatment medium and Java code heat treatment equipment.
According to a first aspect, a Java code heat treatment method provided by an embodiment of the present invention includes:
initializing a code monitor through a code resource manager so that the initialized code monitor can monitor whether code resources stored in a disk are changed or not; wherein each code resource has a unique ID;
when the code monitor monitors that the code resource is changed, the changed code resource is utilized to replace the code resource corresponding to the same ID on the disk, an updating interface of a code resource warehouse is called, and the ID of the changed code resource and the changed code resource are transmitted to the updating interface, so that the code resource warehouse replaces the original code resource corresponding to the ID with the changed code resource.
According to a second aspect, a Java code heat processing apparatus provided by an embodiment of the present invention includes:
the modification monitoring module is used for initializing the code monitor through the code resource manager so that the initialized code monitor can monitor whether the code resource stored in the disk is modified or not; wherein each code resource has a unique ID;
and the resource replacement module is used for replacing the code resource corresponding to the same ID on the disk by utilizing the changed code resource when the code monitor monitors that the code resource is changed, calling an updating interface of a code resource warehouse, and transmitting the ID of the changed code resource and the changed code resource to the updating interface so that the code resource warehouse replaces the original code resource corresponding to the ID with the changed code resource.
According to a third aspect, embodiments of the present invention provide a computer-readable storage medium having stored thereon a computer program which, when executed in a computer, causes the computer to perform the method provided by the first aspect.
According to a fourth aspect, a computing device provided by an embodiment of the present invention includes a memory and a processor, where the memory stores executable code, and the processor implements the method provided by the first aspect when executing the executable code.
According to the Java code heat treatment method, device, medium and equipment provided by the embodiment of the invention, the code monitor is initialized through the code resource manager, so that the initialized code monitor can monitor whether the code resource stored in the disk is changed, when the code monitor monitors that the code resource is changed, the code resource corresponding to the same ID on the disk is replaced by the changed code resource, an update interface of a code resource warehouse is called, the ID of the changed code resource and the changed code resource are transmitted to the update interface, and the original code resource corresponding to the ID is replaced by the changed code resource by the code resource warehouse, so that the code is updated. When the need exists to repair the application vulnerability or the quick iteration application, the need of updating the Java code can be satisfied through the above process. In the above process, the updating of the code is not limited, and the method can be applied to modifying the class field, adding the class method, modifying the parameters of the class method, and the like.
Drawings
FIG. 1 is a flowchart of a Java code heat treatment method according to an embodiment of the invention;
FIG. 2 is a schematic flow chart of Java code hot-updating according to an embodiment of the present invention;
FIG. 3 is a flow chart illustrating hot loading of Java code according to an embodiment of the present invention.
Detailed Description
In a first aspect, an embodiment of the present invention provides a Java code heat treatment method.
Referring to fig. 1 to 3, the method includes the steps S110 to S120 of:
s110, initializing a code monitor through a code resource manager so that the initialized code monitor can monitor whether code resources stored in a disk are changed or not; wherein each code resource has a unique ID;
one of the functions of the code resource manager is to initialize the code monitor, and the initialized code monitor monitors the code resources stored on the disk, and specifically monitors whether the code in the code resources is changed.
Wherein each code resource has an ID for uniquely identifying the code resource.
And S120, when the code monitor monitors that the code resource is changed, replacing the code resource corresponding to the same ID on the disk by utilizing the changed code resource, calling an updating interface of a code resource warehouse, and transmitting the ID of the changed code resource and the changed code resource to the updating interface so that the code resource warehouse replaces the original code resource corresponding to the ID with the changed code resource.
The monitoring mode of the code monitor may include a mode of monitoring file change events or a mode of timing inquiry.
Specifically, according to different code providing modes, the code monitor can monitor in various modes, can monitor file change events for code resources stored on a disk, and can query at regular time for code resources stored in a database.
When the code monitor monitors that the code resource is changed, the code resource corresponding to the same ID on the disk is replaced by the changed code resource, and an updating interface of the code resource warehouse is called, so that the ID of the changed code resource and the changed code resource are transmitted to the updating interface, and the original code resource corresponding to the ID in the code resource warehouse is replaced by the changed code resource by the code resource warehouse, so that the hot updating of the code resource is realized.
In one embodiment, the method provided by the embodiment of the invention can further include:
after the code resource warehouse receives the changed code resource, initializing the changed code resource to obtain a class loader corresponding to the code resource; wherein the class loader has the function of preferentially loading the code resources of the current level; one code resource corresponds to one class loader.
That is, after the code resource warehouse receives the modified code resource, the modified code resource is initialized to obtain a class loader, and the class loader can be used for loading the modified code resource, and the code can be changed into an executable class after being loaded. The class loader is not compliant with the parent delegation mechanism of Java native, and preferentially loads codes of current code resources.
Further, the method provided by the embodiment of the invention can further include:
receiving a class calling request sent by a user through a code unification caller; the class calling request comprises an ID of a code resource, an identification of a target class, a target method in the target class and a parameter of the target method;
the class loading interface of the code resource warehouse is called by the code unified invoker, the ID in the class calling request and the identification of the target class are transmitted into the class loading interface, so that the code resource warehouse loads the target class corresponding to the identification from the code resource corresponding to the ID, and the loaded target class is sent to the code unified invoker;
and executing the target method of the incoming call in the target class by the code unified call device by adopting a reflection call method.
That is, the code unified invoker may receive the class call request sent by the user, and then the code unified invoker obtains the corresponding target class from the code resource library according to the ID in the class call request and the identifier of the target class. Specifically, the code unified invoker calls a class loading interface of the code resource warehouse, and then an ID in a class calling request and an identification of a target class are transmitted into the class loading interface; when the code resource warehouse receives the ID and the identification of the target class, the target class corresponding to the identification is loaded from the code resource corresponding to the ID, and then the target class is fed back to the code unified invoker through the class loading interface, and then the code unified invoker transmits the input parameters in the class calling request to the target method in the target class, and then the target method is executed, so that the hot loading of the codes is realized.
In one embodiment, the code resource repository loads the target class corresponding to the identifier from the code resource corresponding to the ID, which may specifically include: judging whether the code resource warehouse stores the corresponding code resource according to the ID; if not, acquiring the target class corresponding to the identifier in the code resource corresponding to the ID from the java virtual machine.
That is, firstly, the code resource repository will determine whether the code resource repository stores the target class corresponding to the ID, and if not, it is indicated that the code resource repository does not have the corresponding resource, and the target class corresponding to the ID in the code resource corresponding to the ID is directly obtained from the java virtual machine, that is, the target class corresponding to the ID in the code resource corresponding to the ID is obtained from the current environment.
Further, the code resource repository loads the target class corresponding to the identifier from the code resource corresponding to the ID, and may further include: and if the code resource warehouse has the corresponding code resource, acquiring the class loader, and loading the target class corresponding to the identifier from the class loader.
That is, if there is a corresponding code resource in the code resource repository, the previous class loader is acquired, and then the target class to which the identification corresponds is acquired from the class loader.
In an embodiment, in the method provided by the embodiment of the present invention, the transmitting, to the update interface, the ID of the changed code resource and the changed code resource may specifically include:
reading each class in the modified code resource into the memory;
and transmitting the ID of the changed code resource and the byte codes of each class read into the memory to the updating interface.
That is, each class in the modified code resource is read into the memory, and then the ID of the modified code resource and the byte codes of each class in the memory are transmitted to the update interface, so that the fast transmission of the ID and the modified code resource can be realized.
For example, there is a Jar file j.jar, which contains three classes, classA, classB, classC respectively, in which ClassA exists a static method M that receives an entry S of a string type. The Jar file is stored on the disk path P. The Jar file is now used as a code resource, and its resource ID is R.
The hot loading is achieved by performing the steps of:
step one: the code resource manager initializes the code listener.
Specifically, when the application is started, a code monitor L is added to monitor the file change of J.jar located in the disk path P.
Step two: the code listener listens for code changes.
If the code in the J.jar needs to be changed, the user recompiles and packages the changed code into the J.jar and replaces the J.jar file in the disk path P. After replacement, the code listener L will receive notification of the file change. The code monitor L reads the content of j.jar and reads all the classes in the memory. Then the update interface of the code resource repository is called, and the byte codes of the class ClassA, classB, classC in the resource ID R and J.jar are transferred in when the update interface is called.
Step three: replacement of latest code resources by code resource warehouse
After receiving the request for updating the resource R, the code resource repository initializes a class loader L and passes ClassA, classB, classC to the class loader. The class loader is not compliant with the parent delegation mechanism of Java.
Step four: the code unification invoker obtains the latest code class.
If the function of the code resource is required to be called externally, the function must be called through a code unified caller. When the call is made, the resource ID, the target class, the identification of the target method and the parameter of the target method are required to be input. Taking the example of calling the target method M in ClassA, the class loading request needs to include the following parameters: the resource ID is "R", the target class is "ClassA", the target method is identified as "M", and the target method parameter is "s1".
When receiving a class loading request, the code unified invoker invokes a class loading interface of a code resource warehouse, and transmits an ID and an identification of a target class, and the code resource warehouse firstly judges whether corresponding code resources exist in the code resource warehouse or not, and if not, the code unified invoker acquires the target class from the current environment; if so, the target class is obtained from the class loader.
For example, the code unification invoker would call the class loading interface of the code resource repository to load class A of resource R. When loading classes, the code resource repository first determines whether the resource R already exists in the code resource repository. If not, classA is loaded directly from the current environment. If so, classA is loaded from the class loader. After loading is completed, the target class is returned to the code unification caller.
Step five: the code unification invoker invokes specified functions of the code resource.
After the code unified invoker is loaded into ClassA, the method M is invoked by reflection and is transmitted into the parameter s1. After the call is completed, the call result is returned, and the code call process is completed.
In summary, when there is a need to repair an application vulnerability or to iterate an application quickly, the need to update Java code can be satisfied through the above process. In the process, the updating of the code is not limited, and the method can be suitable for adding a deletion field, adding a deletion method, modifying a method signature, modifying method body logic, modifying parameters of a class method and the like, namely, any modification of the Java code is allowed.
In a second aspect, an embodiment of the present invention provides a Java code heat processing apparatus, including:
the modification monitoring module is used for initializing the code monitor through the code resource manager so that the initialized code monitor can monitor whether the code resource stored in the disk is modified or not; wherein each code resource has a unique ID;
and the resource replacement module is used for replacing the code resource corresponding to the same ID on the disk by utilizing the changed code resource when the code monitor monitors that the code resource is changed, calling an updating interface of a code resource warehouse, and transmitting the ID of the changed code resource and the changed code resource to the updating interface so that the code resource warehouse replaces the original code resource corresponding to the ID with the changed code resource.
In one embodiment, the apparatus further comprises:
the initialization module is used for initializing the changed code resource after the code resource warehouse receives the changed code resource, and obtaining a class loader corresponding to the code resource; wherein the class loader has the function of preferentially loading the code resources of the current level; one code resource corresponds to one class loader.
In one embodiment, the apparatus further comprises:
the first receiving module is used for receiving a class calling request sent by a user through the code unification caller; the class calling request comprises an ID of a code resource, an identification of a target class, a target method in the target class and a parameter of the target method;
the first calling module is used for calling a class loading interface of the code resource warehouse through the code unified invoker, transmitting an ID (identity) in the class calling request and an identification of a target class into the class loading interface so that the code resource warehouse loads the target class corresponding to the identification from a code resource corresponding to the ID, and transmitting the loaded target class to the code unified invoker;
and the first execution module is used for executing the target method of the incoming call in the target class by adopting a reflection call method through the code unified call device.
In one embodiment, the process of loading the target class corresponding to the identification from the code resource corresponding to the ID by the code resource warehouse comprises: judging whether the code resource warehouse stores the corresponding code resource according to the ID; if not, acquiring the target class corresponding to the identifier in the code resource corresponding to the ID from the java virtual machine.
In one embodiment, the code resource repository loads the identified corresponding target class from the code resource corresponding to the ID further comprises: and if the code resource warehouse has the corresponding code resource, acquiring the class loader, and loading the target class corresponding to the identifier from the class loader.
In one embodiment, the monitoring mode of the code monitor includes a mode of monitoring file change events or a mode of timing inquiry.
In one embodiment, the resource replacement module is specifically configured to: reading each class in the modified code resource into the memory; and transmitting the ID of the changed code resource and the byte codes of each class read into the memory to the updating interface.
It may be understood that, for explanation, specific implementation, beneficial effects, examples, etc. of the content in the apparatus provided by the embodiment of the present invention, reference may be made to corresponding parts in the method provided in the first aspect, which are not repeated herein.
In a third aspect, embodiments of the present invention provide a computer readable medium having stored thereon computer instructions which, when executed by a processor, cause the processor to perform the method provided in the first aspect.
Specifically, a system or apparatus provided with a storage medium on which a software program code realizing the functions of any of the above embodiments is stored, and a computer (or CPU or MPU) of the system or apparatus may be caused to read out and execute the program code stored in the storage medium.
In this case, the program code itself read from the storage medium may realize the functions of any of the above-described embodiments, and thus the program code and the storage medium storing the program code form part of the present invention.
Examples of the storage medium for providing the program code include a floppy disk, a hard disk, a magneto-optical disk, an optical disk (e.g., CD-ROM, CD-R, CD-RW, DVD-ROM, DVD-RAM, DVD-RW, DVD+RW), a magnetic tape, a nonvolatile memory card, and a ROM. Alternatively, the program code may be downloaded from a server computer by a communication network.
Further, it should be apparent that the functions of any of the above-described embodiments may be implemented not only by executing the program code read out by the computer, but also by causing an operating system or the like operating on the computer to perform part or all of the actual operations based on the instructions of the program code.
Further, it is understood that the program code read out by the storage medium is written into a memory provided in an expansion board inserted into a computer or into a memory provided in an expansion module connected to the computer, and then a CPU or the like mounted on the expansion board or the expansion module is caused to perform part and all of actual operations based on instructions of the program code, thereby realizing the functions of any of the above embodiments.
It may be appreciated that, for explanation, specific implementation, beneficial effects, examples, etc. of the content in the computer readable medium provided by the embodiment of the present invention, reference may be made to corresponding parts in the method provided in the first aspect, and details are not repeated herein.
In a fourth aspect, one embodiment of the present specification provides a computing device comprising a memory having executable code stored therein and a processor that, when executing the executable code, performs the method of any one of the embodiments of the specification.
It may be appreciated that, for explanation, specific implementation, beneficial effects, examples, etc. of the content in the computing device provided by the embodiment of the present invention, reference may be made to corresponding parts in the method provided in the first aspect, which are not repeated herein.
In this specification, each embodiment is described in a progressive manner, and identical and similar parts of each embodiment are all referred to each other, and each embodiment mainly describes differences from other embodiments. In particular, for the device embodiments, since they are substantially similar to the method embodiments, the description is relatively simple, and reference is made to the description of the method embodiments in part.
Those skilled in the art will appreciate that in one or more of the examples described above, the functions described in the present invention may be implemented in hardware, software, a pendant, or any combination thereof. When implemented in software, these functions may be stored on or transmitted over as one or more instructions or code on a computer-readable medium.
The foregoing embodiments have been provided for the purpose of illustrating the general principles of the present invention in further detail, and are not to be construed as limiting the scope of the invention, but are merely intended to cover any modifications, equivalents, improvements, etc. based on the teachings of the invention.
Claims (10)
1. A Java code heat treatment method, comprising:
initializing a code monitor through a code resource manager so that the initialized code monitor can monitor whether code resources stored in a disk are changed or not; wherein each code resource has a unique ID;
when the code monitor monitors that the code resource is changed, the changed code resource is utilized to replace the code resource corresponding to the same ID on the disk, an updating interface of a code resource warehouse is called, and the ID of the changed code resource and the changed code resource are transmitted to the updating interface, so that the code resource warehouse replaces the original code resource corresponding to the ID with the changed code resource.
2. The method as recited in claim 1, further comprising:
after the code resource warehouse receives the changed code resource, initializing the changed code resource to obtain a class loader corresponding to the code resource; wherein the class loader has the function of preferentially loading the code resources of the current level; one code resource corresponds to one class loader.
3. The method as recited in claim 2, further comprising:
receiving a class calling request sent by a user through a code unification caller; the class calling request comprises an ID of a code resource, an identification of a target class, a target method in the target class and a parameter of the target method;
the class loading interface of the code resource warehouse is called by the code unified invoker, the ID in the class calling request and the identification of the target class are transmitted into the class loading interface, so that the code resource warehouse loads the target class corresponding to the identification from the code resource corresponding to the ID, and the loaded target class is sent to the code unified invoker;
and executing the target method of the incoming call in the target class by the code unified call device by adopting a reflection call method.
4. A method according to claim 3, wherein the code resource repository loads the identified corresponding target class from the code resource corresponding to the ID, comprising: judging whether the code resource warehouse stores the corresponding code resource according to the ID; if not, acquiring the target class corresponding to the identifier in the code resource corresponding to the ID from the java virtual machine.
5. The method of claim 4, wherein the code resource repository loads the target class corresponding to the identity from the code resource corresponding to the ID, further comprising: and if the code resource warehouse has the corresponding code resource, acquiring the class loader, and loading the target class corresponding to the identifier from the class loader.
6. The method of claim 1, wherein the listening mode of the code listener comprises a mode of listening for file change events or a mode of timing queries.
7. The method of claim 1, wherein said passing the ID of the changed code resource and the changed code resource to the update interface comprises: reading each class in the modified code resource into the memory; and transmitting the ID of the changed code resource and the byte codes of each class read into the memory to the updating interface.
8. A Java code heat treating apparatus, comprising:
the modification monitoring module is used for initializing the code monitor through the code resource manager so that the initialized code monitor can monitor whether the code resource stored in the disk is modified or not; wherein each code resource has a unique ID;
and the resource replacement module is used for replacing the code resource corresponding to the same ID on the disk by utilizing the changed code resource when the code monitor monitors that the code resource is changed, calling an updating interface of a code resource warehouse, and transmitting the ID of the changed code resource and the changed code resource to the updating interface so that the code resource warehouse replaces the original code resource corresponding to the ID with the changed code resource.
9. A computer readable storage medium, having stored thereon a computer program which, when executed in a computer, causes the computer to perform a method implementing any of claims 1 to 7.
10. A computing device comprising a memory and a processor, the memory having executable code stored therein, the processor, when executing the executable code, implementing the method of any one of claims 1-7.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202311022046.9A CN117170723A (en) | 2023-08-15 | 2023-08-15 | Java code heat treatment method and device, medium and equipment |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202311022046.9A CN117170723A (en) | 2023-08-15 | 2023-08-15 | Java code heat treatment method and device, medium and equipment |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN117170723A true CN117170723A (en) | 2023-12-05 |
Family
ID=88930937
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202311022046.9A Pending CN117170723A (en) | 2023-08-15 | 2023-08-15 | Java code heat treatment method and device, medium and equipment |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN117170723A (en) |
-
2023
- 2023-08-15 CN CN202311022046.9A patent/CN117170723A/en active Pending
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US7165099B2 (en) | Dynamically downloading and executing system services on a wireless device | |
| US6871345B1 (en) | Self managing software agents with introspection | |
| US8799885B2 (en) | Method and system for automated root-cause analysis for class loading failures in java | |
| CN111475227B (en) | Business plug-in loading implementation method and device and terminal equipment | |
| US8099472B2 (en) | System and method for a mobile cross-platform software system | |
| US8332835B2 (en) | Method and system for automated code-source indexing in java virtual machine environment | |
| US7752637B2 (en) | System and method for software component plug-in framework | |
| KR101343148B1 (en) | Automated Device Driver Management | |
| US8176333B2 (en) | Method and apparatus for protecting external call references | |
| JP5026430B2 (en) | Discover, qualify, and launch software add-in components | |
| US7055147B2 (en) | Supporting interactions between different versions of software for accessing remote objects | |
| US7814472B2 (en) | System and method for shared code-sourcing in a Java Virtual Machine environment | |
| CN109614167B (en) | Method and system for managing plug-ins | |
| US6985909B2 (en) | Modified class loaders and methods of use | |
| MXPA03008532A (en) | Dynamically downloading and executing system services on a wireless device. | |
| JPH11272454A (en) | Device for distributing software through computer network | |
| AU2002254289A1 (en) | Dynamically downloading and executing system services on a wireless device | |
| US11726810B2 (en) | Systemic extensible blockchain object model comprising a first-class object model and a distributed ledger technology | |
| KR20010034514A (en) | Method and system for deterministic hashes to identify remote methods | |
| CN117170723A (en) | Java code heat treatment method and device, medium and equipment | |
| AU2002310093B2 (en) | System and method for software component plug-in framework | |
| AU2002310093A1 (en) | System and method for software component plug-in framework |
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 |