CN117194837A - Page access method and device, electronic equipment and computer readable medium - Google Patents
Page access method and device, electronic equipment and computer readable medium Download PDFInfo
- Publication number
- CN117194837A CN117194837A CN202311212701.7A CN202311212701A CN117194837A CN 117194837 A CN117194837 A CN 117194837A CN 202311212701 A CN202311212701 A CN 202311212701A CN 117194837 A CN117194837 A CN 117194837A
- Authority
- CN
- China
- Prior art keywords
- page
- function
- compiling
- compiling target
- binding event
- 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 107
- 230000008569 process Effects 0.000 claims abstract description 32
- 230000004044 response Effects 0.000 claims abstract description 28
- 238000012795 verification Methods 0.000 claims abstract description 22
- 238000004590 computer program Methods 0.000 claims description 16
- 230000009191 jumping Effects 0.000 claims description 10
- 238000001514 detection method Methods 0.000 claims description 7
- 230000002452 interceptive effect Effects 0.000 abstract description 5
- 230000006870 function Effects 0.000 description 146
- 238000010586 diagram Methods 0.000 description 15
- 238000011161 development Methods 0.000 description 12
- 230000001960 triggered effect Effects 0.000 description 11
- 238000004891 communication Methods 0.000 description 7
- 238000012545 processing Methods 0.000 description 5
- 235000008694 Humulus lupulus Nutrition 0.000 description 4
- 230000003287 optical effect Effects 0.000 description 4
- 238000005516 engineering process Methods 0.000 description 3
- 230000003993 interaction Effects 0.000 description 3
- 238000012986 modification Methods 0.000 description 3
- 230000004048 modification Effects 0.000 description 3
- 230000008901 benefit Effects 0.000 description 2
- 238000006243 chemical reaction Methods 0.000 description 2
- 239000000835 fiber Substances 0.000 description 2
- 238000003672 processing method Methods 0.000 description 2
- 230000000644 propagated effect Effects 0.000 description 2
- 239000004065 semiconductor Substances 0.000 description 2
- 238000004458 analytical method Methods 0.000 description 1
- 238000013475 authorization Methods 0.000 description 1
- 230000005540 biological transmission Effects 0.000 description 1
- 230000008859 change Effects 0.000 description 1
- 238000010276 construction Methods 0.000 description 1
- 238000013480 data collection Methods 0.000 description 1
- 238000012217 deletion Methods 0.000 description 1
- 230000037430 deletion Effects 0.000 description 1
- 238000013461 design Methods 0.000 description 1
- 230000000694 effects Effects 0.000 description 1
- 239000004973 liquid crystal related substance Substances 0.000 description 1
- 238000012544 monitoring process Methods 0.000 description 1
- 239000013307 optical fiber Substances 0.000 description 1
- 238000004064 recycling Methods 0.000 description 1
- 230000003252 repetitive effect Effects 0.000 description 1
- 230000002441 reversible effect Effects 0.000 description 1
- 238000006467 substitution reaction Methods 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
Abstract
The application discloses a page access method, a device, electronic equipment and a computer readable medium, and relates to the technical field of computers.A specific implementation mode comprises the steps of receiving a page access request, triggering a compiling target binding event, loading a corresponding hook method and executing a page login process; executing an authority verification process in response to successful page login to obtain a compiling target attribute corresponding to the compiling target binding event, and obtaining a compiling target identifier corresponding to the compiling target binding event in response to the compiling target attribute being in an operable range; responding to the consistency of the compiling target identification and the identification stored in the conversation storage container, and acquiring function parameters corresponding to the compiling target identification in the conversation storage container; writing function parameters into a preset function in the objective function component to obtain an objective function, and executing the objective function to jump to an operation corresponding to the compiling objective binding event; operations are performed to continue to access the corresponding page. The interactive experience of the user is improved.
Description
Technical Field
The present application relates to the field of computer technologies, and in particular, to a page access method, a page access device, an electronic device, and a computer readable medium.
Background
At present, in order to show the functions of the system, the traditional system shows all operable page elements, a user triggers a compiling target which can be used only after logging in under the condition of not logging in, the system generally processes a jump to a logging in page, and then jumps to a system home page or a page accessed by the user after logging in the system is completed, so that the user does not always continue to trigger the compiling target event operation, and the user also needs to repeat the previous operation. For users, the method is quite unfriendly, the user interaction experience is poor, the development difficulty and complexity are high, and the enterprise cost is high.
Disclosure of Invention
In view of the above, embodiments of the present application provide a method, an apparatus, an electronic device, and a computer readable medium for accessing a page, which can solve the problems that after a user logs in, the user cannot continue to access the page triggered by the user without logging in, the user interaction experience is poor, the development difficulty and complexity are high, and the enterprise cost is high.
To achieve the above object, according to an aspect of an embodiment of the present application, there is provided a page access method including:
receiving a page access request, triggering a compiling target binding event, loading a corresponding hooking method, and executing a page login process;
executing an authority verification process in response to successful page login to obtain a compiling target attribute corresponding to the compiling target binding event, and obtaining a compiling target identifier corresponding to the compiling target binding event in response to the compiling target attribute being in an operable range;
responding to the consistency of the compiling target identification and the identification stored in the conversation storage container, and acquiring function parameters corresponding to the compiling target identification in the conversation storage container;
writing function parameters into a preset function in the objective function component to obtain an objective function, and executing the objective function to jump to an operation corresponding to the compiling objective binding event;
operations are performed to continue to access the corresponding page.
Optionally, before performing the page login process, the method further comprises:
and binding the operation corresponding to the compiling target binding event and the corresponding compiling target identification.
Optionally, before obtaining the function parameter corresponding to the compiling target identifier in the session storage container, the method further includes:
responding to a page corresponding to a page access request which is not logged in by a user, and acquiring function parameters corresponding to compiling target identifications corresponding to compiling target binding events;
and storing the function parameters and the compiling target identification into a session storage container, and further prompting the user to log in the page.
Optionally, acquiring the compiling target attribute corresponding to the compiling target binding event includes:
responding to the detection of successful page login, and calling a server interface to return the function operable by the current user;
and acquiring operation data of the user on the operable function, and further determining the compiling target attribute according to the operation data.
Optionally, writing the function parameter to a preset function in the objective function component includes:
determining the position of a placeholder in a preset function;
the function parameters are added to the locations of the corresponding placeholders.
Optionally, adding the function parameter to the location of the corresponding placeholder includes:
determining the size of a first space occupied by the function parameters;
determining a second space size occupied by each placeholder;
the function parameter is added to the position of the placeholder corresponding to the second spatial size closest to the first spatial size.
Optionally, performing an operation to continue to access the corresponding page includes:
generating an asynchronous task based on the compiling target binding event and the operation;
the thread pool is called to execute the asynchronous task, and then the page corresponding to the operation is continuously accessed.
In addition, the application also provides a page access device, which comprises:
the receiving unit is configured to receive a page access request, trigger compiling a target binding event, further load a corresponding hook method and execute a page login process;
the authority verification unit is configured to respond to successful page login, execute an authority verification process to acquire a compiling target attribute corresponding to the compiling target binding event, and respond to the compiling target attribute in an operable range to acquire a compiling target identifier corresponding to the compiling target binding event;
the acquisition unit is configured to respond to consistency of the compiling target identification and the identification stored in the conversation storage container, and acquire function parameters corresponding to the compiling target identification in the conversation storage container;
the jump unit is configured to write function parameters into a preset function in the objective function component to obtain an objective function, and execute the objective function to jump to an operation corresponding to the compiling objective binding event;
and a continued access unit configured to perform an operation to continue access to the corresponding page.
Optionally, the apparatus further comprises a binding unit configured to:
and binding the operation corresponding to the compiling target binding event and the corresponding compiling target identification.
Optionally, the apparatus further comprises a login prompt unit configured to:
responding to a page corresponding to a page access request which is not logged in by a user, and acquiring function parameters corresponding to compiling target identifications corresponding to compiling target binding events;
and storing the function parameters and the compiling target identification into a session storage container, and further prompting the user to log in the page.
Optionally, the rights verification unit is further configured to:
responding to the detection of successful page login, and calling a server interface to return the function operable by the current user;
and acquiring operation data of the user on the operable function, and further determining the compiling target attribute according to the operation data.
Optionally, the jumping unit is further configured to:
determining the position of a placeholder in a preset function;
the function parameters are added to the locations of the corresponding placeholders.
Optionally, the jumping unit is further configured to:
determining the size of a first space occupied by the function parameters;
determining a second space size occupied by each placeholder;
the function parameter is added to the position of the placeholder corresponding to the second spatial size closest to the first spatial size.
Optionally, the continued access unit is further configured to:
generating an asynchronous task based on the compiling target binding event and the operation;
the thread pool is called to execute the asynchronous task, and then the page corresponding to the operation is continuously accessed.
In addition, the application also provides page access electronic equipment, which comprises: one or more processors; and a storage device for storing one or more programs which, when executed by the one or more processors, cause the one or more processors to implement the page access method as described above.
In addition, the application also provides a computer readable medium, on which a computer program is stored, which when executed by a processor implements the page access method as described above.
To achieve the above object, according to still another aspect of an embodiment of the present application, there is provided a computer program product.
The computer program product of the embodiment of the application comprises a computer program, and the page access method provided by the embodiment of the application is realized when the program is executed by a processor.
One embodiment of the above application has the following advantages or benefits: according to the method, the target binding event is triggered and compiled by receiving the page access request, so that the corresponding hooking method is loaded, and the page login process is executed; executing an authority verification process in response to successful page login to obtain a compiling target attribute corresponding to the compiling target binding event, and obtaining a compiling target identifier corresponding to the compiling target binding event in response to the compiling target attribute being in an operable range; responding to the consistency of the compiling target identification and the identification stored in the conversation storage container, and acquiring function parameters corresponding to the compiling target identification in the conversation storage container; writing function parameters into a preset function in the objective function component to obtain an objective function, and executing the objective function to jump to an operation corresponding to the compiling objective binding event; operations are performed to continue to access the corresponding page. The method and the device can realize the page access operation triggered under the condition that the user is not logged in after the user is logged in, improve the interactive experience of the user, improve the working efficiency, reduce the development difficulty and complexity of the development stage and reduce the enterprise cost.
Further effects of the above-described non-conventional alternatives are described below in connection with the embodiments.
Drawings
The drawings are included to provide a better understanding of the application and are not to be construed as unduly limiting the application. Wherein:
FIG. 1 is a schematic diagram of the main flow of a page access method according to one embodiment of the application;
FIG. 2 is a schematic diagram of the main flow of a page access method according to one embodiment of the application;
FIG. 3 is a schematic flow diagram of a page access method according to one embodiment of the application;
fig. 4 is a schematic diagram of main units of a page access apparatus according to an embodiment of the present application;
FIG. 5 is an exemplary system architecture diagram in which embodiments of the present application may be applied;
fig. 6 is a schematic diagram of a computer system suitable for use in implementing an embodiment of the application.
Detailed Description
Exemplary embodiments of the present application will now be described with reference to the accompanying drawings, in which various details of the embodiments of the present application are included to facilitate understanding, and are to be considered merely exemplary. Accordingly, those of ordinary skill in the art will recognize that various changes and modifications of the embodiments described herein can be made without departing from the scope and spirit of the application. Also, descriptions of well-known functions and constructions are omitted in the following description for clarity and conciseness. In the technical scheme of the application, the aspects of acquisition, analysis, use, transmission, storage and the like of the related user personal information all meet the requirements of related laws and regulations, are used for legal and reasonable purposes, are not shared, leaked or sold outside the aspects of legal use and the like, and are subjected to supervision and management of a supervision department. Necessary measures should be taken for the personal information of the user to prevent illegal access to such personal information data, ensure that personnel having access to the personal information data comply with the regulations of the relevant laws and regulations, and ensure the personal information of the user. Once these user personal information data are no longer needed, the risk should be minimized by limiting or even prohibiting the data collection and/or deletion.
User privacy is protected by de-identifying data when used, including in some related applications, such as by removing a particular identifier, controlling the amount or specificity of stored data, controlling how data is stored, and/or other methods.
Fig. 1 is a schematic diagram of main flow of a page access method according to an embodiment of the present application, and as shown in fig. 1, the page access method includes:
step S101, receiving a page access request, triggering a compiling target binding event, loading a corresponding hooking method, and executing a page login process.
In this embodiment, the execution body (for example, may be a server) of the page access method may receive the page access request through a wired connection or a wireless connection. After receiving the page access request, the execution body triggers the compiling target binding event. After the compiling Target binding event is triggered, executing a processing method for binding the Target event and binding the unique identification triggering Target. Target refers to a page element that can trigger a javascript event that needs to be used after a system login.
And loading the hook method to support the follow-up operation after the page login is completed, so that the user experience is improved.
Specifically, before executing the page login process, the page access method further includes: and binding the operation corresponding to the compiling target binding event and the corresponding compiling target identification. To support continued operation after login is completed.
Step S102, in response to successful page login, executing an authority verification process to obtain a compiling target attribute corresponding to the compiling target binding event, and in response to the compiling target attribute being in an operable range, obtaining a compiling target identifier corresponding to the compiling target binding event.
Specifically, acquiring the compiling target attribute corresponding to the compiling target binding event includes: responding to the detection of successful page login, and calling a server interface to return the function operable by the current user; and acquiring operation data of the user on the operable function, and further determining the compiling target attribute according to the operation data.
After the user logs in, the service interface returns the current user operable function for the user to select, and the compiling target attribute is generated according to the user selected operable function.
The front end may determine whether the generated compiling target attribute is within the operable range, if not, terminate the subsequent operation, and if so, execute the operation of the subsequent step S103.
Step S103, in response to the consistency of the compiling target identification and the identification stored in the conversation storage container, acquiring the function parameters corresponding to the compiling target identification in the conversation storage container.
In another case, the executing body does not do anything in response to the compiling target identification not conforming to the identification stored in the session storage container.
Step S104, writing the function parameters into the preset functions in the objective function component to obtain the objective function, and executing the objective function to jump to the operation corresponding to the compiling objective binding event.
For example, under the condition that the compiled target identifier is consistent with the identifier stored in the session storage container, obtaining a function parameter cached in the session storage container sessionStorage, transferring the cached function parameter into a function Fun stored in a function component useRef to obtain an objective function, executing the objective function, and further jumping to a corresponding page continuing to follow-up operation for a user to continue to follow-up operation.
Step S105, an operation is performed to continue to access the corresponding page.
The operation corresponding to the compiling target binding event is the subsequent operation of the operation performed by the user before the page login. This subsequent operation is performed to continue to access the corresponding page using the corresponding page element after the login is completed.
According to the embodiment, by receiving the page access request, the compiling target binding event is triggered, so that a corresponding hooking method is loaded, and the page login process is executed; executing an authority verification process in response to successful page login to obtain a compiling target attribute corresponding to the compiling target binding event, and obtaining a compiling target identifier corresponding to the compiling target binding event in response to the compiling target attribute being in an operable range; responding to the consistency of the compiling target identification and the identification stored in the conversation storage container, and acquiring function parameters corresponding to the compiling target identification in the conversation storage container; writing function parameters into a preset function in the objective function component to obtain an objective function, and executing the objective function to jump to an operation corresponding to the compiling objective binding event; operations are performed to continue to access the corresponding page. The method and the device can realize the page access operation triggered under the condition that the user is not logged in after the user is logged in, improve the interactive experience of the user, improve the working efficiency, reduce the development difficulty and complexity of the development stage and reduce the enterprise cost.
Fig. 2 is a main flow diagram of a page access method according to an embodiment of the present application, and as shown in fig. 2, the page access method includes:
step S201, receiving a page access request, triggering a compiling target binding event, loading a corresponding hooking method, and executing a page login process.
The page corresponding to the page access request can be an online shopping page or a cash recycling service handling page, and the page corresponding to the page access request is not particularly limited in the embodiment of the application.
Step S202, in response to successful page login, executing an authority verification process to obtain a compiling target attribute corresponding to the compiling target binding event, and in response to the compiling target attribute being in an operable range, obtaining a compiling target identifier corresponding to the compiling target binding event.
And executing the authority verification process, namely judging whether the compiling target attribute corresponding to the function selected by the user is in the operable range, if so, passing the authority verification, and if not, not passing the authority verification.
Step S203, responding to the page corresponding to the page access request which is not logged in by the user, and acquiring the function parameter corresponding to the compiling target identifier corresponding to the compiling target binding event.
When the user is detected to trigger the compiling target binding event but not log in the page corresponding to the page access request, the execution body can acquire the compiling target identifier corresponding to the compiling target binding event from the session storage container, so as to acquire the corresponding function parameter from the session storage container according to the compiling target identifier.
Step S204, storing the function parameters and the compiling target identification into a session storage container, and prompting the user to log in the page.
By way of example, target: and triggering a page element which can be used only after the system login of the javascript event is required. And triggering a Target binding event by the user, judging whether the current user logs in, if not, storing the parameters of the current function Fun into a session storage container sessionStorage, and storing the identification of the current Target into the session storage container sessionStorage. And then prompting the user to execute login operation, and successfully executing the next operation.
In step S205, in response to the compiling target identifier being consistent with the identifier stored in the session storage container, a function parameter corresponding to the compiling target identifier in the session storage container is obtained.
When the compiling target identification is the same as the identification stored in the conversation storage container or one or more identifications stored in the conversation storage container are contained in the compiling target table, the compiling target identification is determined to be consistent with the identification stored in the conversation storage container. Based on the consistency judging method, whether the identification is consistent with the compiling target identification in the session storage container can be judged rapidly and accurately, so that the speed and the accuracy of judging whether the identification is consistent are improved.
Step S206, writing the function parameters into the preset functions in the objective function component to obtain the objective function, and executing the objective function to jump to the operation corresponding to the compiling objective binding event.
Specifically, writing function parameters into a preset function in an objective function component includes: determining the position of a placeholder in a preset function; the function parameters are added to the locations of the corresponding placeholders.
Placeholders in the preset function, such as XXX, may also be 111, and the form and content of the placeholders are not particularly limited in the embodiment of the present application. The placeholders in the preset function are replaced with the function parameters to add the function parameters to the locations of the placeholders in the preset function.
Specifically, adding the function parameter to the location of the corresponding placeholder includes: determining the size of a first space occupied by the function parameters; determining a second space size occupied by each placeholder; the function parameter is added to the position of the placeholder corresponding to the second spatial size closest to the first spatial size.
In the process of adding the function parameters to the positions of the placeholders in the preset function, the corresponding placeholders can be selected according to the size of the space occupied by the function parameters, so that the function parameters are added to the positions of the placeholders which are the most consistent with each other in type or occupied space, and the practicability of the function parameters is improved.
In step S207, an operation is performed to continue to access the corresponding page.
Specifically, performing operations to continue accessing the corresponding page includes: generating an asynchronous task based on the compiling target binding event and the operation; the thread pool is called to execute the asynchronous task, and then the page corresponding to the operation is continuously accessed.
By executing the asynchronous task, the page access response speed can be improved.
Fig. 3 is a schematic flow diagram of a page access method according to an embodiment of the present application. The page access method provided by the embodiment of the application can be applied to the scene of operation before login after the user logs in. useref is a hook function hook of a function component act that functions to reference DOM elements, components or functions in the act function component for operations of DOM elements in the page, calls to functions, etc. The embodiment of the application relates to the technical field of Internet, and provides useRef implementation Target binding event function Fun storage and hook technology implementation permission judgment based on a reaction frame, function execution logic processing, and session storage container sessionStorage implementation function Fun parameter record and current Target identification record provided by a browser. As shown in fig. 3, first, a user opens and accesses a browser page, page triggers introduce hops, the method of hops is loaded, the processing method of Target event is bound, and unique identification of Target is bound. The target binding event is defined through the hooks, the parameters comprise a follow-up operation function fun actually triggered by the button, and a unique identification is defined. The pending event Fun cache: fun to be executed is recorded through useRef. Fun to be executed is stored in the method object in useRef. useRef is a book that is used to reference DOM elements, components or functions in a reaction component, often used for operations of DOM elements in pages, calls to functions, etc. And returning the function Fun triggered by clicking by the user, recording Fun parameters, and executing login operation. The user clicks to trigger the Target binding event, whether the current user logs in or not is judged through the hooks, if the current user does not log in, parameters of the current function Fun are stored in a session storage container, a button mark (can also be a button mark, and the embodiment of the application is not particularly limited) is stored in the session storage container, namely, the mark of the current Target is stored in the session storage container. And prompting the user to execute login operation, triggering login state monitoring detection in the hops, and executing the next operation when the login success is detected. The next step is to judge whether the current user has authority operation after the user executes the login operation. After logging in, the service interface returns to the current user operable function, the front end judges whether the current Target is in the operable range according to the service interface data, if not, the front end prompts no or insufficient rights, and the subsequent operation is terminated. If the current user has permission to execute the operation, further judging whether the currently executed button mark, namely the target mark, is consistent with the stored in the session storage container sessionStorage, if not, not performing any operation, if so, acquiring the cache parameter in the session storage container sessionStorage, transmitting the parameter into a method stored in a function component useRef, namely a function Fun, executing the function Fun after the parameter is transmitted to realize the operation before continuing login, ensuring that the data is not lost after refreshing the page by the session storage container sessionStorage, and ensuring that the data context state in the function Fun method is not changed by a function component useRef.
By way of example, the page access method of the embodiment of the application is introduced into the page, and the key is bound with the event and the button mark. A page tag binding method, permission binding button. The embodiment of the application provides a method for maintaining operation before button login based on a function component act, which comprises the following steps: after the user clicks the button, a method for binding the page tag, for example, a btnClick method, is executed, and the operation that the system requires to log in is triggered in the btnClick method. After the user completes the login operation, based on the hook binding event, the change of the login state is monitored, and the method btnClickEvent for storing the binding is executed by using the incoming cache parameter params. The method for page access in the embodiment of the application is convenient for multiplexing by using a hops technology; the manner of storing the response method of the javascript (which is a lightweight, interpreted or just-in-time compiling programming language with function priority) event and the response method of the session storage container sessionStorage parameter by adopting the useref method ensures that the unfinished operation can be continuously executed after logging in. The function component React useRef is used for recording the content of the follow-up operation and the custom hooks are used together with the Target, so that the follow-up operation is supported to be continued after the login is completed, and the user experience is improved. The problem that subsequent operation cannot be continued after an event of triggering Target binding by a user is solved, and interaction experience of the user is improved; the public hooks improve the working efficiency, reduce the development difficulty and complexity of the development stage and reduce the enterprise cost.
Fig. 4 is a schematic diagram of main units of a page access apparatus according to an embodiment of the present application. As shown in fig. 4, the page access apparatus 400 includes a receiving unit 401, a right verifying unit 402, an acquiring unit 403, a jumping unit 404, and a continued access unit 405.
The receiving unit 401 is configured to receive a page access request, trigger compiling a target binding event, further load a corresponding hooking method, and execute a page login process.
The permission verification unit 402 is configured to execute a permission verification process in response to successful page login, so as to obtain a compiling target attribute corresponding to the compiling target binding event, and in response to the compiling target attribute being within an operable range, obtain a compiling target identifier corresponding to the compiling target binding event.
And an obtaining unit 403 configured to obtain, in response to the compiling target identifier being consistent with the identifier stored in the session storage container, a function parameter corresponding to the compiling target identifier in the session storage container.
And a jumping unit 404 configured to write function parameters into preset functions in the objective function component to obtain objective functions, and execute the objective functions to jump to operations corresponding to compiling the objective binding events.
A continued access unit 405 configured to perform operations to continue accessing the corresponding page.
In some embodiments, the page access device further comprises a binding unit, not shown in fig. 4, configured to: and binding the operation corresponding to the compiling target binding event and the corresponding compiling target identification.
In some embodiments, the page access device further comprises a login prompt unit, not shown in fig. 4, configured to: responding to a page corresponding to a page access request which is not logged in by a user, and acquiring function parameters corresponding to compiling target identifications corresponding to compiling target binding events; and storing the function parameters and the compiling target identification into a session storage container, and further prompting the user to log in the page.
In some embodiments, the rights verification unit 402 is further configured to: responding to the detection of successful page login, and calling a server interface to return the function operable by the current user; and acquiring operation data of the user on the operable function, and further determining the compiling target attribute according to the operation data.
In some embodiments, the jumping unit 404 is further configured to: determining the position of a placeholder in a preset function; the function parameters are added to the locations of the corresponding placeholders.
In some embodiments, the jumping unit 404 is further configured to: determining the size of a first space occupied by the function parameters; determining a second space size occupied by each placeholder; the function parameter is added to the position of the placeholder corresponding to the second spatial size closest to the first spatial size.
In some embodiments, the continued access unit 405 is further configured to: generating an asynchronous task based on the compiling target binding event and the operation; the thread pool is called to execute the asynchronous task, and then the page corresponding to the operation is continuously accessed.
It should be noted that, the page access method and the page access device of the present application have a corresponding relationship in the implementation content, so the repetitive content will not be described.
Fig. 5 illustrates an exemplary system architecture 500 in which a page access method or page access apparatus of embodiments of the present application may be applied.
As shown in fig. 5, the system architecture 500 may include terminal devices 501, 502, 503, a network 504, and a server 505. The network 504 is used as a medium to provide communication links between the terminal devices 501, 502, 503 and the server 505. The network 504 may include various connection types, such as wired, wireless communication links, or fiber optic cables, among others.
A user may interact with the server 505 via the network 504 using the terminal devices 501, 502, 503 to receive or send messages or the like. Various communication client applications may be installed on the terminal devices 501, 502, 503, such as shopping class applications, web browser applications, search class applications, instant messaging tools, mailbox clients, social platform software, etc. (by way of example only).
The terminal devices 501, 502, 503 may be various electronic devices with a page access processing screen and supporting web browsing, including but not limited to smartphones, tablets, laptop and desktop computers, and the like.
The server 505 may be a server providing various services, such as a background management server (by way of example only) providing support for page access requests submitted by users using the terminal devices 501, 502, 503. The background management server can receive the page access request, trigger the compiling target binding event, further load the corresponding hook method and execute the page login process; executing an authority verification process in response to successful page login to obtain a compiling target attribute corresponding to the compiling target binding event, and obtaining a compiling target identifier corresponding to the compiling target binding event in response to the compiling target attribute being in an operable range; responding to the consistency of the compiling target identification and the identification stored in the conversation storage container, and acquiring function parameters corresponding to the compiling target identification in the conversation storage container; writing function parameters into a preset function in the objective function component to obtain an objective function, and executing the objective function to jump to an operation corresponding to the compiling objective binding event; operations are performed to continue to access the corresponding page. The method and the device can realize the page access operation triggered under the condition that the user is not logged in after the user is logged in, improve the interactive experience of the user, improve the working efficiency, reduce the development difficulty and complexity of the development stage and reduce the enterprise cost.
It should be noted that, the page access method provided in the embodiment of the present application is generally executed by the server 505, and accordingly, the page access device is generally disposed in the server 505.
It should be understood that the number of terminal devices, networks and servers in fig. 5 is merely illustrative. There may be any number of terminal devices, networks, and servers, as desired for implementation.
Referring now to FIG. 6, there is illustrated a schematic diagram of a computer system 600 suitable for use in implementing an embodiment of the present application. The terminal device shown in fig. 6 is only an example, and should not impose any limitation on the functions and the scope of use of the embodiment of the present application.
As shown in fig. 6, the computer system 600 includes a Central Processing Unit (CPU) 601, which can perform various appropriate actions and processes according to a program stored in a Read Only Memory (ROM) 602 or a program loaded from a storage section 608 into a Random Access Memory (RAM) 603. In the RAM603, various programs and data required for the operation of the computer system 600 are also stored. The CPU601, ROM602, and RAM603 are connected to each other through a bus 604. An input/output (I/O) interface 605 is also connected to bus 604.
The following components are connected to the I/O interface 605: an input portion 606 including a keyboard, mouse, etc.; an output portion 607 including a Cathode Ray Tube (CRT), a liquid crystal credit authorization query processor (LCD), and the like, and a speaker, and the like; a storage section 608 including a hard disk and the like; and a communication section 609 including a network interface card such as a LAN card, a modem, or the like. The communication section 609 performs communication processing via a network such as the internet. The drive 610 is also connected to the I/O interface 605 as needed. Removable media 611 such as a magnetic disk, an optical disk, a magneto-optical disk, a semiconductor memory, or the like is installed as needed on drive 610 so that a computer program read therefrom is installed as needed into storage section 608.
In particular, according to embodiments of the present disclosure, the processes described above with reference to flowcharts may be implemented as computer software programs. For example, embodiments of the present disclosure include a computer program product comprising a computer program embodied on a computer readable medium, the computer program comprising program code for performing the method shown in the flow chart. In such an embodiment, the computer program may be downloaded and installed from a network through the communication portion 609, and/or installed from the removable medium 611. The above-described functions defined in the system of the present application are performed when the computer program is executed by a Central Processing Unit (CPU) 601.
The computer readable medium shown in the present application may be a computer readable signal medium or a computer readable storage medium, or any combination of the two. The computer readable storage medium may include, for example, but is not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or a combination of any of the foregoing. More specific examples of the computer-readable storage medium may include, but are not limited to: an electrical connection having one or more wires, a portable computer diskette, a hard disk, a Random Access Memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disc read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing. In the context of this document, a computer readable storage medium may be any tangible medium that can contain, or store a program for use by or in connection with an instruction execution system, apparatus, or device. In the present application, however, the computer-readable signal medium may include a data signal propagated in baseband or as part of a carrier wave, with the computer-readable program code embodied therein. Such a propagated data signal may take any of a variety of forms, including, but not limited to, electro-magnetic, optical, or any suitable combination of the foregoing. A computer readable signal medium may also be any computer readable medium that is not a computer readable storage medium and that can communicate, propagate, or transport a program for use by or in connection with an instruction execution system, apparatus, or device. Program code embodied on a computer readable medium may be transmitted using any appropriate medium, including but not limited to: wireless, wire, fiber optic cable, RF, etc., or any suitable combination of the foregoing.
The flowcharts and block diagrams in the figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods and computer program products according to various embodiments of the present application. In this regard, each block in the flowchart or block diagrams may represent a module, segment, or portion of code, which comprises one or more executable instructions for implementing the specified logical function(s). It should also be noted that, in some alternative implementations, the functions noted in the block may occur out of the order noted in the figures. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, or the blocks may sometimes be executed in the reverse order, depending upon the functionality involved. It will also be noted that each block of the block diagrams or flowchart illustration, and combinations of blocks in the block diagrams or flowchart illustration, can be implemented by special purpose hardware-based systems which perform the specified functions or acts, or combinations of special purpose hardware and computer instructions.
The units involved in the embodiments of the present application may be implemented in software or in hardware. The described units may also be provided in a processor, for example, described as: a processor includes a receiving unit, a rights verification unit, an acquisition unit, a jumping unit, and a continued access unit. Wherein the names of the units do not constitute a limitation of the units themselves in some cases.
As another aspect, the present application also provides a computer-readable medium that may be contained in the apparatus described in the above embodiments; or may be present alone without being fitted into the device. The computer readable medium carries one or more programs, and when the one or more programs are executed by one device, the device receives a page access request, triggers a compiling target binding event, loads a corresponding hook method and executes a page login process; executing an authority verification process in response to successful page login to obtain a compiling target attribute corresponding to the compiling target binding event, and obtaining a compiling target identifier corresponding to the compiling target binding event in response to the compiling target attribute being in an operable range; responding to the consistency of the compiling target identification and the identification stored in the conversation storage container, and acquiring function parameters corresponding to the compiling target identification in the conversation storage container; writing function parameters into a preset function in the objective function component to obtain an objective function, and executing the objective function to jump to an operation corresponding to the compiling objective binding event; operations are performed to continue to access the corresponding page.
The computer program product of the present application comprises a computer program which, when executed by a processor, implements the page access method of the embodiments of the present application.
According to the technical scheme provided by the embodiment of the application, the page access operation triggered under the condition that the user is not logged in can be continuously performed after the user is logged in, the interactive experience of the user is improved, the working efficiency is improved, the development difficulty and complexity of the development stage are reduced, and the enterprise cost is reduced.
The above embodiments do not limit the scope of the present application. It will be apparent to those skilled in the art that various modifications, combinations, sub-combinations and alternatives can occur depending upon design requirements and other factors. Any modifications, equivalent substitutions and improvements made within the spirit and principles of the present application should be included in the scope of the present application.
Claims (16)
1. A method of page access, comprising:
receiving a page access request, triggering a compiling target binding event, loading a corresponding hooking method, and executing a page login process;
executing an authority verification process in response to successful page login so as to acquire a compiling target attribute corresponding to the compiling target binding event, and acquiring a compiling target identifier corresponding to the compiling target binding event in response to the compiling target attribute being in an operable range;
responding to the consistency of the compiling target identification and the identification stored in the conversation storage container, and acquiring function parameters corresponding to the compiling target identification in the conversation storage container;
writing the function parameters into a preset function in an objective function component to obtain an objective function, and executing the objective function to jump to the operation corresponding to the compiling objective binding event;
the operations are performed to continue to access the corresponding page.
2. The method of claim 1, wherein prior to the performing a page log-in process, the method further comprises:
and binding the operation corresponding to the compiling target binding event and the corresponding compiling target identifier.
3. The method of claim 1, wherein prior to the obtaining the function parameters in the session storage container corresponding to the compilation target identification, the method further comprises:
responding to the page corresponding to the page access request which is not logged in by the user, and acquiring function parameters corresponding to the compiling target identification corresponding to the compiling target binding event;
and storing the function parameters and the compiling target identification into a session storage container, and further prompting a user to log in a page.
4. The method according to claim 1, wherein the obtaining the compiling target attribute corresponding to the compiling target binding event includes:
responding to the detection of successful page login, and calling a server interface to return the function operable by the current user;
and acquiring operation data of the user on the operable function, and further determining compiling target attributes according to the operation data.
5. The method of claim 1, wherein writing the function parameters to the preset function in the objective function component comprises:
determining the position of a placeholder in the preset function;
and adding the function parameters to the positions of the corresponding placeholders.
6. The method of claim 5, wherein the adding the function parameter to the location of the corresponding placeholder comprises:
determining the first space size occupied by the function parameters;
determining a second size of space occupied by each placeholder;
and adding the function parameter to the position of a placeholder corresponding to a second space size closest to the first space size.
7. The method of claim 1, wherein the performing the operation to continue accessing the respective page comprises:
generating an asynchronous task based on the compiling target binding event and the operation;
and calling a thread pool to execute the asynchronous task, and further continuously accessing the page corresponding to the operation.
8. A page access apparatus, comprising:
the receiving unit is configured to receive a page access request, trigger compiling a target binding event, further load a corresponding hook method and execute a page login process;
the authority verification unit is configured to respond to successful page login, execute an authority verification process to acquire a compiling target attribute corresponding to the compiling target binding event, and respond to the compiling target attribute in an operable range to acquire a compiling target identifier corresponding to the compiling target binding event;
the obtaining unit is configured to obtain function parameters corresponding to the compiling target identification in the session storage container in response to the compiling target identification being consistent with the identification stored in the session storage container;
the jump unit is configured to write the function parameters into a preset function in the objective function component to obtain an objective function, and execute the objective function to jump to the operation corresponding to the compiling objective binding event;
and a continued access unit configured to perform the operation to continue access to the corresponding page.
9. The apparatus of claim 8, further comprising a binding unit configured to:
and binding the operation corresponding to the compiling target binding event and the corresponding compiling target identifier.
10. The apparatus of claim 8, further comprising a login prompt unit configured to:
responding to the page corresponding to the page access request which is not logged in by the user, and acquiring function parameters corresponding to the compiling target identification corresponding to the compiling target binding event;
and storing the function parameters and the compiling target identification into a session storage container, and further prompting a user to log in a page.
11. The apparatus of claim 8, wherein the rights verification unit is further configured to:
responding to the detection of successful page login, and calling a server interface to return the function operable by the current user;
and acquiring operation data of the user on the operable function, and further determining compiling target attributes according to the operation data.
12. The apparatus of claim 8, wherein the jumping unit is further configured to:
determining the position of a placeholder in the preset function;
and adding the function parameters to the positions of the corresponding placeholders.
13. The apparatus of claim 12, wherein the jumping unit is further configured to:
determining the first space size occupied by the function parameters;
determining a second size of space occupied by each placeholder;
and adding the function parameter to the position of a placeholder corresponding to a second space size closest to the first space size.
14. A page access electronic device, comprising:
one or more processors;
storage means for storing one or more programs,
the one or more programs, when executed by the one or more processors, cause the one or more processors to implement the method of any of claims 1-7.
15. A computer readable medium, on which a computer program is stored, characterized in that the program, when being executed by a processor, implements the method according to any of claims 1-7.
16. A computer program product comprising a computer program which, when executed by a processor, implements the method according to any of claims 1-7.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202311212701.7A CN117194837A (en) | 2023-09-20 | 2023-09-20 | Page access method and device, electronic equipment and computer readable medium |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202311212701.7A CN117194837A (en) | 2023-09-20 | 2023-09-20 | Page access method and device, electronic equipment and computer readable medium |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN117194837A true CN117194837A (en) | 2023-12-08 |
Family
ID=88983214
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202311212701.7A Pending CN117194837A (en) | 2023-09-20 | 2023-09-20 | Page access method and device, electronic equipment and computer readable medium |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN117194837A (en) |
-
2023
- 2023-09-20 CN CN202311212701.7A patent/CN117194837A/en active Pending
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US10079854B1 (en) | Client-side protective script to mitigate server loading | |
| CN111160845B (en) | Service processing method and device | |
| RU2586866C2 (en) | Differentiation of set of features of participant of leased medium and user | |
| CN109542361B (en) | Distributed storage system file reading method, system and related device | |
| CN109981322B (en) | Method and device for cloud resource management based on label | |
| CA2921424A1 (en) | Systems and methodologies for managing document access permissions | |
| CN109787959B (en) | Account information processing method and related device | |
| US10262155B1 (en) | Disabling features using feature toggle | |
| CN109815700A (en) | Processing method and processing device, storage medium, the computer equipment of application program | |
| CN109472127A (en) | Permission processing method, device, using side apparatus and storage medium | |
| CN112100613A (en) | Application login control method and device, electronic equipment and storage medium | |
| CN109542401B (en) | Web development method and device, storage medium and processor | |
| CN117194837A (en) | Page access method and device, electronic equipment and computer readable medium | |
| CN112866265B (en) | CSRF attack protection method and device | |
| CN115203671A (en) | Account login method, device, equipment and storage medium | |
| CN109213815B (en) | Method, device, server terminal and readable medium for controlling execution times | |
| US20140325605A1 (en) | System for storage security of cloud server in cloud computing environment and method thereof | |
| US20230401275A1 (en) | Tenant network for rewriting of code included in a web page | |
| CN117556395B (en) | System application watermark generation method and device | |
| US20230350984A1 (en) | System and method for client-side rewriting of code included in a web page | |
| CN113572763B (en) | Data processing method and device, electronic equipment and storage medium | |
| US20230101198A1 (en) | Computer-implemented systems and methods for application identification and authentication | |
| US20230094066A1 (en) | Computer-implemented systems and methods for application identification and authentication | |
| CN117792704A (en) | Website access method and device, electronic equipment and computer readable medium | |
| CN116305027A (en) | Service processing method, device, electronic equipment and computer readable 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 |