CN117608623A

CN117608623A - Method, device, equipment and medium for self-updating of Jar program capable of running monomer

Info

Publication number: CN117608623A
Application number: CN202311657716.4A
Authority: CN
Inventors: 施建安; 陈玉明; 林斌; 孙志伟; 林静
Original assignee: Xiamen Yilianzhong Yihui Technology Co ltd
Current assignee: Xiamen Yilianzhong Yihui Technology Co ltd
Priority date: 2023-12-04
Filing date: 2023-12-04
Publication date: 2024-02-27

Abstract

The invention provides a method, a device, equipment and a medium for self-updating of a monomer-operable Jar program, which comprise the following steps: acquiring an input application program prefix name and an operating system command, and retrieving and processing a process progress of the system according to the operating system command to generate a retrieval progress; obtaining a disk file path and a file name of a current execution program, judging whether the file name contains copy, generating a judging result, and executing business operation or copying the file operation according to the judging result; when the judgment result is that the file is not included, copying the source file of the current execution program, generating a copy file, stopping executing the current program, executing the copy file, and upgrading the source file of the current execution program. The method aims to solve the problem that when an existing automatic updating and upgrading method for running the Jar package by a single body updates a version file, the problem that the new version coverage fails due to file locking exists.

Description

Method, device, equipment and medium for self-updating of Jar program capable of running monomer

Technical Field

The invention relates to the technical field, in particular to a method, a device, equipment and a medium for self-updating of a monomer-operable Jar program.

Background

Currently, applications written in the Java language on the market basically use a Jar package that is packaged into a single executable when they need to be run. That is, the executable program is a file with jar as a suffix, and is started by inputting a java-jar command under the operating system. In real services, program upgrades caused by service logic changes are unavoidable. In the past, in order to meet the upgrading requirement, a new version of single program is usually provided at the back end, an operator remotely logs in a system where a service program package is located through remote software, stops the current program, replaces a single Jar package running file, and then restarts a new version command through a command. The whole process needs to be completed manually, and automation is not realized.

The current automatic updating and upgrading method for the single operation Jar package in the market has no matter how the method is achieved, and an intermediate step is necessary to stop the current program in the whole upgrading process. In general, another independent program is adopted to stop the single Jar package, cover the new file and start the new file. In practical use, the steps can be supported simultaneously in a Wi-window environment and a Li nux environment, but the Wi-window environment and the Li nux environment are inconsistent with the file occupation strategy in operation; in short, if the single Jar package is in operation, the file is locked, cannot be deleted, and cannot be covered under the Wi window environment; without any limitation in the Li nux environment. Further, when updating the version file, there is a problem that the new version coverage fails due to the file locking.

In view of this, the present application is presented.

Disclosure of Invention

Therefore, the present invention aims to provide a method, a device, and a medium for self-updating a single-body executable Jar program, which can effectively solve the problem that when a version file is updated, the single-body executable Jar packet in the prior art has a new version coverage failure caused by file locking.

The invention discloses a self-updating method of a monomer-operable Jar program, which comprises the following steps:

acquiring an input application program prefix name and an operating system command, and retrieving and processing a process progress of a system according to the operating system command to generate a retrieval progress;

obtaining a disk file path and a file name of a currently executed program, judging whether the file name contains copy, generating a judging result, and executing business operation or copying the file operation according to the judging result, wherein the judging result comprises containing and not containing;

when the judgment result is that the Jar program is not contained, copying the source file of the current execution program, generating a copy file, stopping executing the current program, executing the copy file, and upgrading the source file of the current execution program to realize self-updating of the Jar program.

Preferably, the method comprises the steps of acquiring an incoming application program prefix name and an operating system command, and searching and processing a process progress of a system according to the operating system command to generate a search progress, wherein the search progress specifically comprises the following steps:

acquiring the prefix name of the currently-transmitted application program and an operating system command;

and according to the operating system command, screening out the process of the non-current process containing the preset prefix in the process name, generating a search process, and terminating the search process, wherein the search process is the process of the non-current process containing the preset prefix in the screened out process name.

Preferably, a disk file path and a file name of a currently executed program are obtained, whether the file name contains copy is judged, a judging result is generated, and service operation or file copying operation is performed according to the judging result, specifically:

obtaining a disk file path and a file name of a currently executed program, and judging whether the file name contains copy;

if yes, continuing to execute the subsequent business logic;

if not, copying the source file of the current executing program to the disk file path to generate a copy file, and modifying the file name of the copy file to a preset name, wherein the preset name is the file name plus copy;

starting the copy file by using a preset command, wherein the preset command is a java-jar command;

and blocking the current process, and stopping executing the subsequent business logic.

Preferably, when the judging result is not included, upgrading the source file of the currently executed program to realize self-updating of the Jar program, specifically:

acquiring an upgrade file, covering the upgrade file with a source file of the current execution program on a disk according to the disk file path, and generating a new source file;

and starting the new source file by using a preset command, wherein the preset command is a java-Jar command so as to realize self-updating of the Jar program.

The invention also discloses a self-updating device of the Jar program capable of running the monomer, which comprises:

the retrieval unit is used for acquiring the prefix name of the input application program and the command of the operating system, retrieving and processing the progress of the system according to the command of the operating system, and generating a retrieval progress;

the judging and executing unit is used for acquiring a disk file path and a file name of a current executing program, judging whether the file name contains copy, generating a judging result, and executing business operation or copying file operation according to the judging result, wherein the judging result comprises containing and not containing;

and the copying and updating unit is used for copying the source file of the current execution program to generate a copy file, stopping executing the current program, executing the copy file and upgrading the source file of the current execution program to realize self-updating of the Jar program when the judging result is not included.

Preferably, the retrieving unit is specifically configured to:

Preferably, the judging and executing unit is specifically configured to:

if yes, continuing to execute the subsequent business logic;

Preferably, the copy and update unit is specifically configured to:

The invention also discloses a single-body operable Jar program self-updating device which comprises a processor, a memory and a computer program stored in the memory and configured to be executed by the processor, wherein the processor realizes the single-body operable Jar program self-updating method according to any one of the above when executing the computer program.

The invention also discloses a readable storage medium which stores a computer program, wherein the computer program can be executed by a processor of a device where the storage medium is located, so as to realize the self-updating method of the single executable Jar program.

In summary, the method, the device, the equipment and the medium for self-updating of the single executable Jar program provided by the embodiment use the self file and the copy file auxiliary form, and realize that the program package for performing business logic is necessarily the program package of the copy file by inserting a special control flow before the program is started; at the same time, the local coverage of the upgrade file is ensured by using the auxiliary forms of the self file and the copy file. Therefore, the problem that the automatic updating and upgrading method of the single running Jar package in the prior art has the problem of new version coverage failure caused by file locking when updating the version file is solved.

Drawings

Fig. 1 is a flow chart of a method for self-updating a monomer-executable Jar program according to an embodiment of the present invention.

Fig. 2 is a schematic program start-up flow chart of a method for running Jar program self-updating by a monomer according to an embodiment of the present invention.

Fig. 3 is a schematic program upgrade flow chart of a method for running Jar program self-updating by a monomer according to an embodiment of the present invention.

Fig. 4 is a schematic block diagram of a single-body running Jar program self-updating device according to an embodiment of the present invention.

Detailed Description

For the purpose of making the objects, technical solutions and advantages of the embodiments of the present invention more apparent, the technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings in the embodiments of the present invention, and it is apparent that the described embodiments are some embodiments of the present invention, but not all embodiments. All other embodiments, based on the embodiments of the invention, which are apparent to those of ordinary skill in the art without inventive faculty, are intended to be within the scope of the invention. Thus, the following detailed description of the embodiments of the invention, as presented in the figures, is not intended to limit the scope of the invention, as claimed, but is merely representative of selected embodiments of the invention. All other embodiments, based on the embodiments of the invention, which are apparent to those of ordinary skill in the art without inventive faculty, are intended to be within the scope of the invention.

Specific embodiments of the present invention will be described in detail below with reference to the accompanying drawings.

Referring to fig. 1 to 3, a first embodiment of the present invention provides a single-body-executable Jar program self-updating method, which can be executed by a single-body-executable Jar program self-updating device (hereinafter, updating device), and in particular, by one or more processors in the updating device, so as to implement the following steps:

s101, acquiring an input application program prefix name and an operating system command, and searching and processing a process progress of a system according to the operating system command to generate a search progress;

specifically, step S101 includes: acquiring the prefix name of the currently-transmitted application program and an operating system command;

S102, acquiring a disk file path and a file name of a current execution program, judging whether the file name contains copy, generating a judging result, and executing business operation or copying the file operation according to the judging result, wherein the judging result comprises containing and not containing;

specifically, step S102 includes: obtaining a disk file path and a file name of a currently executed program, and judging whether the file name contains copy;

if yes, continuing to execute the subsequent business logic;

And S103, when the judgment result is that the current execution program is not included, copying the source file of the current execution program, generating a copy file, stopping executing the current program, executing the copy file, and upgrading the source file of the current execution program so as to realize self-updating of the Jar program.

Specifically, step S103 includes: acquiring an upgrade file, covering the upgrade file with a source file of the current execution program on a disk according to the disk file path, and generating a new source file;

For a single executable Jar package program on the market, the updated scene needs to face several steps, including: 1. new and old files are replaced; 2. terminating the operation of the old file program; 3. the program is started with the new file. The steps can be supported simultaneously in a Window environment and a Linux environment. However, the Window environment and the Linux environment are inconsistent with the file occupation strategy in operation. In short, if the single Jar package is running, the file is locked, cannot be deleted, and cannot be covered under the Window environment. And no limitation exists in the Linux environment.

Specifically, in this embodiment, due to the above-mentioned problem, in order to be able to adapt to two different operating systems when updating a version file, it is necessary to avoid operating on a running file in order to avoid a new version coverage failure caused by file locking. Thus, the first point requirement of the monomer-executable Jar program self-update method arises here: copying the body Jar package into one copy, renaming the copy to the original file name + -copy, and executing program by using the copied file. Because the copied program is used for running, when the new and old files are replaced, the source files which are not run can be directly replaced. The replacement of new and old files will not encounter the locking problem of files.

In this embodiment, for the termination of the old program, the commands under the respective systems of Window and Linux may be used. Generally, a command contains two contents: and terminating the process of the current old program, and starting the new file. For example, under Linux, the command used by the monomer to run the Jar program self-update method is similar to kill-9{ pid }; java-jar xx. The two commands are typically executed by saving the commands in a sh file (under the Li nux system), a bat file (under the Wi window system). The old program executing these two commands encounters a problem of: when the first command is executed, the old program is to be terminated by the first command; because the old program has terminated, the command itself loses the executor and the remaining commands cannot execute. In fact, this batch process including two commands is implemented in a manner that relies on the third party to implement upgrades. But now there is only a single monomer Jar package, so this approach cannot be used.

The method of killing and updating the self by self is not feasible, and the method can be changed into a method of executing program termination by means of the source file and executing application by means of copying the file. That is, the monomer can run the Jar program self-updating method, and the source file program is started, the application of the prefix with the same name is killed, and the file copying program is started; the duplicate file program kills the same name prefix application and continues with the subsequent business logic. The main work is to customize the starting flow specifically in order to realize self-upgrading by means of the single Jar package program itself.

In summary, the monomer can run the Jar program self-updating method to enable the monomer Jar package to self-upgrade and start the new version application without a third party application; the method can realize the process that the monomer Jar package can be upgraded and restarted only by self, and avoid the problem that a third party application program is needed in the traditional method. In short, the single-body running Jar program self-updating method uses the self file and the copy file auxiliary form, and a special control flow is inserted before program starting, so that the program package for carrying out business logic is ensured to be the program package of the copy file. Meanwhile, the monomer can run the Jar program self-updating method also uses the self file and the copy file auxiliary form to ensure the local coverage of the upgrade file.

Referring to fig. 4, a second embodiment of the invention provides a single-body executable Jar program self-updating device, comprising:

a retrieving unit 201, configured to obtain an incoming application prefix name and an operating system command, and retrieve a process of a system according to the operating system command, so as to generate a retrieval process;

a judging and executing unit 202, configured to obtain a disk file path and a file name of a currently executing program, judge whether the file name includes copy, generate a judging result, and execute a service operation or copy a file operation according to the judging result, where the judging result includes including and not including;

and the copy and update unit 203 is configured to copy the source file of the currently executing program, generate a copy file, stop executing the current program, execute the copy file, and upgrade the source file of the currently executing program when the determination result is not included, so as to implement self-update of the Jar program.

Preferably, the retrieving unit 201 is specifically configured to:

Preferably, the determining and executing unit 202 is specifically configured to:

if yes, continuing to execute the subsequent business logic;

Preferably, the copy and update unit 203 is specifically configured to:

A third embodiment of the present invention provides a single-body-executable Jar program self-updating device, including a processor, a memory, and a computer program stored in the memory and configured to be executed by the processor, where the processor implements a single-body-executable Jar program self-updating method as described in any one of the above.

A fourth embodiment of the present invention provides a readable storage medium storing a computer program, where the computer program can be executed by a processor of a device in which the storage medium is located, so as to implement a single executable Jar program self-updating method according to any one of the above.

Illustratively, the computer programs described in the third and fourth embodiments of the present invention may be divided into one or more modules, which are stored in the memory and executed by the processor to complete the present invention. The one or more modules may be a series of computer program instruction segments capable of performing a specific function for describing the execution of the computer program in the one-monomer-executable Jar program self-updating device. For example, the device described in the second embodiment of the present invention.

The processor may be a central processing unit (Central Processing Unit, CPU), other general purpose processors, digital signal processors (Digital Signal Processor, DSP), application specific integrated circuits (Application Specific Integrated Circuit, ASIC), off-the-shelf programmable gate arrays (Field-Programmable Gate Array, FPGA) or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components, or the like. The general-purpose processor may be a microprocessor or the processor may be any conventional processor, etc., and the processor is a control center of the single-body executable Jar program self-updating method, and various interfaces and lines are used to connect various parts of the entire single-body executable Jar program self-updating method.

The memory may be used to store the computer program and/or the module, and the processor may implement various functions of the single executable Jar program self-updating method by running or executing the computer program and/or the module stored in the memory and invoking data stored in the memory. The memory may mainly include a storage program area and a storage data area, wherein the storage program area may store an operating system, an application program (such as a sound playing function, a text conversion function, etc.) required for at least one function, and the like; the storage data area may store data (such as audio data, text message data, etc.) created according to the use of the cellular phone, etc. In addition, the memory may include high-speed random access memory, and may also include non-volatile memory, such as a hard disk, memory, plug-in hard disk, smart Media Card (SMC), secure Digital (SD) Card, flash Card (Flash Card), at least one disk storage device, flash memory device, or other volatile solid-state storage device.

Wherein the modules may be stored in a computer readable storage medium if implemented in the form of software functional units and sold or used as a stand alone product. Based on this understanding, the present invention may implement all or part of the flow of the method of the above embodiment, or may be implemented by a computer program to instruct related hardware, where the computer program may be stored in a computer readable storage medium, and the computer program may implement the steps of each method embodiment described above when executed by a processor. Wherein the computer program comprises computer program code which may be in source code form, object code form, executable file or some intermediate form etc. The computer readable medium may include: any entity or device capable of carrying the computer program code, a recording medium, a U disk, a removable hard disk, a magnetic disk, an optical disk, a computer Memory, a Read-Only Memory (ROM), a random access Memory (RAM, random Access Memory), an electrical carrier signal, a telecommunications signal, a software distribution medium, and so forth. It should be noted that the computer readable medium contains content that can be appropriately scaled according to the requirements of jurisdictions in which such content is subject to legislation and patent practice, such as in certain jurisdictions in which such content is subject to legislation and patent practice, the computer readable medium does not include electrical carrier signals and telecommunication signals.

It should be noted that the above-described apparatus embodiments are merely illustrative, and the units described as separate units may or may not be physically separate, and units shown as units may or may not be physical units, may be located in one place, or may be distributed over a plurality of network units. Some or all of the modules may be selected according to actual needs to achieve the purpose of the solution of this embodiment. In addition, in the drawings of the embodiment of the device provided by the invention, the connection relation between the modules represents that the modules have communication connection, and can be specifically implemented as one or more communication buses or signal lines. Those of ordinary skill in the art will understand and implement the present invention without undue burden.

The above is only a preferred embodiment of the present invention, and the protection scope of the present invention is not limited to the above examples, and all technical solutions belonging to the concept of the present invention belong to the protection scope of the present invention.

Claims

1. A method for self-updating a monomer-executable Jar program, comprising:

2. The method for self-updating a single-body executable Jar program according to claim 1, wherein the method is characterized in that the method comprises the steps of obtaining the prefix name of the incoming application program and the command of the operating system, and searching the progress of the system according to the command of the operating system to generate a searching progress, and the specific steps are as follows:

3. The method for self-updating a single-body executable Jar program according to claim 1, wherein the method is characterized in that a disk file path and a file name of a currently executed program are obtained, whether the file name contains copy is judged, a judging result is generated, and business operation or file copying operation is executed according to the judging result, specifically:

if yes, continuing to execute the subsequent business logic;

4. The method for self-updating a single executable Jar program according to claim 3, wherein when the judging result is not included, upgrading the source file of the currently executed program to realize self-updating of the Jar program, specifically:

5. A single-body, executable Jar program self-updating device, comprising:

6. The single-body-executable Jar program self-updating device of claim 5, wherein the retrieval unit is specifically configured to:

7. The device of claim 5, wherein the determining and executing unit is configured to:

if yes, continuing to execute the subsequent business logic;

8. The single-body-executable Jar program self-updating device of claim 5, wherein the replication and updating unit is configured to:

9. A single-body-executable Jar program self-updating device comprising a processor, a memory, and a computer program stored in the memory and configured to be executed by the processor, the processor implementing a single-body-executable Jar program self-updating method as claimed in any one of claims 1 to 4 when the computer program is executed by the processor.

10. A readable storage medium storing a computer program executable by a processor of a device in which the storage medium is located to implement a single executable Jar program self-updating method as claimed in any one of claims 1 to 4.