CN116233217A - Page jump method and device based on route, electronic equipment and storage medium - Google Patents
Page jump method and device based on route, electronic equipment and storage medium Download PDFInfo
- Publication number
- CN116233217A CN116233217A CN202310510442.XA CN202310510442A CN116233217A CN 116233217 A CN116233217 A CN 116233217A CN 202310510442 A CN202310510442 A CN 202310510442A CN 116233217 A CN116233217 A CN 116233217A
- Authority
- CN
- China
- Prior art keywords
- message
- message channel
- page
- jump
- route
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Granted
Links
- 238000000034 method Methods 0.000 title claims abstract description 216
- 230000009471 action Effects 0.000 claims abstract description 72
- 238000013507 mapping Methods 0.000 claims abstract description 28
- 230000009191 jumping Effects 0.000 claims abstract description 12
- 230000008569 process Effects 0.000 claims description 37
- 238000004590 computer program Methods 0.000 claims description 18
- 238000012546 transfer Methods 0.000 claims description 12
- 230000005540 biological transmission Effects 0.000 claims description 9
- 238000011161 development Methods 0.000 abstract description 6
- 230000001419 dependent effect Effects 0.000 abstract description 5
- 230000005856 abnormality Effects 0.000 abstract description 2
- 230000000694 effects Effects 0.000 description 20
- 230000006870 function Effects 0.000 description 14
- 238000012545 processing Methods 0.000 description 13
- 238000013459 approach Methods 0.000 description 7
- 238000010586 diagram Methods 0.000 description 6
- 238000004891 communication Methods 0.000 description 5
- 238000010276 construction Methods 0.000 description 5
- 238000006731 degradation reaction Methods 0.000 description 4
- 238000013461 design Methods 0.000 description 4
- 235000008694 Humulus lupulus Nutrition 0.000 description 3
- 230000008878 coupling Effects 0.000 description 3
- 238000010168 coupling process Methods 0.000 description 3
- 238000005859 coupling reaction Methods 0.000 description 3
- 239000000969 carrier Substances 0.000 description 2
- 230000015556 catabolic process Effects 0.000 description 2
- 230000009286 beneficial effect Effects 0.000 description 1
- 230000008901 benefit Effects 0.000 description 1
- 230000008859 change Effects 0.000 description 1
- 230000003247 decreasing effect Effects 0.000 description 1
- 238000005516 engineering process Methods 0.000 description 1
- 230000003993 interaction Effects 0.000 description 1
- 230000002452 interceptive effect Effects 0.000 description 1
- 238000012986 modification Methods 0.000 description 1
- 230000004048 modification Effects 0.000 description 1
- 230000003287 optical effect Effects 0.000 description 1
- 230000004044 response Effects 0.000 description 1
- 238000006467 substitution reaction Methods 0.000 description 1
Images
Classifications
-
- H—ELECTRICITY
- H04—ELECTRIC COMMUNICATION TECHNIQUE
- H04L—TRANSMISSION OF DIGITAL INFORMATION, e.g. TELEGRAPHIC COMMUNICATION
- H04L67/00—Network arrangements or protocols for supporting network services or applications
- H04L67/14—Session management
- H04L67/148—Migration or transfer of sessions
-
- H—ELECTRICITY
- H04—ELECTRIC COMMUNICATION TECHNIQUE
- H04L—TRANSMISSION OF DIGITAL INFORMATION, e.g. TELEGRAPHIC COMMUNICATION
- H04L67/00—Network arrangements or protocols for supporting network services or applications
- H04L67/14—Session management
- H04L67/141—Setup of application sessions
-
- H—ELECTRICITY
- H04—ELECTRIC COMMUNICATION TECHNIQUE
- H04L—TRANSMISSION OF DIGITAL INFORMATION, e.g. TELEGRAPHIC COMMUNICATION
- H04L67/00—Network arrangements or protocols for supporting network services or applications
- H04L67/14—Session management
- H04L67/146—Markers for unambiguous identification of a particular session, e.g. session cookie or URL-encoding
-
- 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 provides a page jumping method and device based on routing, electronic equipment and a storage medium. The method comprises the following steps: the method comprises the steps of inputting a pre-constructed message carrier into a route, and creating a message channel in a page module of an application program class; creating a target jump intention object in an execution action method of a message channel; traversing the parameters in the executing action method, and adding key value pairs in the parameters into the target jump intention objects one by one; according to a message channel mapping table preset in the route, obtaining a message channel identifier from a message carrier, and inquiring the message channel mapping table by using the message channel identifier to obtain a message channel corresponding to the message channel identifier; the execution action method of the message channel is invoked to execute the jump logic to jump from the original page to the target page. The method and the device realize class-dependent decoupling, can split the modules, improve development efficiency and avoid throwing out abnormality.
Description
Technical Field
The present disclosure relates to the field of application program development technologies, and in particular, to a method and apparatus for page skip based on routing, an electronic device, and a storage medium.
Background
Page hopping in mobile applications is critical to implementing application functions and user interactions. Currently, there are two main page-skipping methods in the native routing system, which are respectively Explicit intention (Explicit Intent) and Implicit intention (Explicit Intent). However, each of these two approaches has some drawbacks and disadvantages.
The display intent is a jump that needs to be dependent on the specific class of the target page. However, this approach has a problem of large dependency between classes, and especially in the project of module splitting, the target class may not be found, resulting in jump failure. In contrast to the display intent, implicit intent enables jumping by defining rules in the manifest configuration file of the application. Nevertheless, this approach is less scalable. Implicit intent is to ensure uniqueness of the page jump rules, otherwise multiple jump targets may occur, resulting in security risks. Meanwhile, if the target component (e.g., activity) is deleted, the jump target cannot be found, resulting in an application crash. In addition, the jump procedure of the native routing mode cannot be controlled by a developer and can only be managed by a system. This means that when the jump fails, the developer cannot perform the degradation process, and can only directly throw the exception.
It can be seen that the display intention and the implicit intention in the existing native routing system have a plurality of problems such as large dependency, poor scalability, security risk and the like when page skip in the mobile application is realized.
Disclosure of Invention
In view of this, the embodiments of the present application provide a method, an apparatus, an electronic device, and a storage medium for page skipping based on routing, so as to solve the problems of large dependency, poor scalability, and security risk existing in the prior art.
In a first aspect of an embodiment of the present application, a method for page skipping based on routing is provided, including: the method comprises the steps of inputting a pre-constructed message carrier into a route, and creating a message channel in a page module of an application program class; creating a target jump intention object in an execution action method of the message channel, wherein the target jump intention object is used for representing a jump intention relationship between an original page and a target page; traversing the parameters in the executing action method, and adding key value pairs in the parameters into the target jump intention objects one by one; according to a message channel mapping table preset in the route, obtaining a message channel identifier from a message carrier, and inquiring the message channel mapping table by using the message channel identifier to obtain a message channel corresponding to the message channel identifier; the execution action method of the message channel is invoked to execute the jump logic to jump from the original page to the target page.
In a second aspect of the embodiments of the present application, a route-based page jumping apparatus is provided, including: an incoming module configured to incoming a pre-structured message carrier into a route and create a message channel in a page module of an application class; the creation module is configured to create a target jump intention object in the execution action method of the message channel, wherein the target jump intention object is used for representing the jump intention relationship between the original page and the target page; the traversing module is configured to traverse parameters in the executing action method and add key value pairs in the parameters into the target jump intention objects one by one; the query module is configured to acquire a message channel identifier from the message carrier according to a message channel mapping table preset in the route, and query the message channel mapping table by utilizing the message channel identifier to acquire a message channel corresponding to the message channel identifier; and the calling module is configured to call an execution action method of the message channel to execute the jump logic so as to jump from the original page to the target page.
In a third aspect of the embodiments of the present application, there is provided an electronic device including a memory, a processor and a computer program stored on the memory and executable on the processor, the processor implementing the steps of the above method when executing the program.
In a fourth aspect of the embodiments of the present application, there is provided a computer readable storage medium storing a computer program which, when executed by a processor, implements the steps of the above method.
The above-mentioned at least one technical scheme that this application embodiment adopted can reach following beneficial effect:
by introducing a pre-constructed message carrier into the route and creating a message channel in a page module of an application program class; creating a target jump intention object in an execution action method of the message channel, wherein the target jump intention object is used for representing a jump intention relationship between an original page and a target page; traversing the parameters in the executing action method, and adding key value pairs in the parameters into the target jump intention objects one by one; according to a message channel mapping table preset in the route, obtaining a message channel identifier from a message carrier, and inquiring the message channel mapping table by using the message channel identifier to obtain a message channel corresponding to the message channel identifier; the execution action method of the message channel is invoked to execute the jump logic to jump from the original page to the target page. The page jump method based on the route realizes class-dependent decoupling, can split modules, improves development efficiency, and avoids throwing out abnormality by modifying the route.
Drawings
In order to more clearly illustrate the technical solutions of the embodiments of the present application, the following description will briefly introduce the drawings that are needed in the embodiments or the description of the prior art, it is obvious that the drawings in the following description are only some embodiments of the present application, and that other drawings may be obtained according to these drawings without inventive effort for a person skilled in the art.
FIG. 1 is a schematic flow chart of a route-based page skip method according to an embodiment of the present application;
fig. 2 is a schematic diagram of basic components and structures of a routing transfer station according to an embodiment of the present application;
fig. 3 is a schematic structural diagram of a route-based page skip device according to an embodiment of the present application;
fig. 4 is a schematic structural diagram of an electronic device according to an embodiment of the present application.
Detailed Description
In the following description, for purposes of explanation and not limitation, specific details are set forth, such as particular system configurations, techniques, etc. in order to provide a thorough understanding of the embodiments of the present application. It will be apparent, however, to one skilled in the art that the present application may be practiced in other embodiments that depart from these specific details. In other instances, detailed descriptions of well-known systems, devices, circuits, and methods are omitted so as not to obscure the description of the present application with unnecessary detail.
In the prior art, two page skipping methods in a native routing system are as follows: the intent and implicit intent are displayed. The native routing system is a method for implementing hops between pages in a mobile application.
Display intention: this manner of hopping depends on the specific class of target pages. However, this approach has several drawbacks, such as: the dependency between classes is large, and for those items that are split by the module, the target class may not be found.
Implicit intent: this jump approach requires defining some rules in the Manifest configuration file (Manifest) of the application, but it is less scalable. This approach needs to ensure that schema (a rule that identifies pages to jump) is unique, otherwise multiple jump targets may occur, resulting in security risks. In addition, if the target component (e.g., activity) is deleted, the jump target is not found, resulting in a crash (crash) of the application. The jump procedure using the native routing method cannot be controlled by the developer, but can only be managed by the system. This means that when the jump fails, the developer cannot perform the degradation process, and can only directly throw the exception.
In summary, two page skip modes in the mobile application program at present, namely, display intention and implicit intention, have a plurality of problems such as large dependency relationship, poor expandability, security risk and the like when the page skip in the mobile application program is realized.
In view of this, in order to solve the above-mentioned problems, an embodiment of the present application provides a route-based page jumping method. According to the method and the device, the pre-constructed message carrier is transmitted into the route, and the message channel is created in the page module of the application program class, so that the jump intention relation between the original page and the target page is realized. Message data attributes are defined in classes of message carriers, and new message carriers are created by using a new method, a parameter setting method and an action setting method to realize data required when transferring page jumps. By realizing the registration method and setting the single case mode, the application registers the message channel in the route, and processes the message processing and forwarding between the page modules in different processes. The method and the device also use feedback types sent by the message to return the page skip result, so that a developer can carry out degradation processing when the skip fails, and avoid direct throwing of the exception.
The following describes the technical scheme of the present application in detail with reference to the accompanying drawings and specific embodiments.
Fig. 1 is a schematic flow chart of a route-based page skip method according to an embodiment of the present application. The route-based page skip method of fig. 1 may be performed by an application program. As shown in fig. 1, the route-based page skip method may specifically include:
s101, a pre-constructed message carrier is transmitted into a route, and a message channel is created in a page module of an application program class;
s102, creating a target jump intention object in an execution action method of a message channel, wherein the target jump intention object is used for representing a jump intention relationship between an original page and a target page;
s103, traversing parameters in the execution action method, and adding key value pairs in the parameters into target jump intention objects one by one;
s104, according to a preset message channel mapping table in the route, obtaining a message channel identifier from the message carrier, and inquiring the message channel mapping table by using the message channel identifier to obtain a message channel corresponding to the message channel identifier;
s105, calling an execution action method of the message channel to execute the jump logic so as to jump from the original page to the target page.
Firstly, explaining some technical terms involved in the practical application scene in the embodiment of the present application, the specific terms may include the following:
application: in the Android framework, application is a system component that represents the entire Application. When an Android Application is started, the system will first create an Application instance. Briefly, an Application component is automatically created at Application start-up that serves as an entry and basis for the entire Application, providing global context and Application-level resources. In program development, a developer can manage the global state of an Application and handle some operations related to the whole Application by inheriting and customizing Application classes.
Activity: the user interface component (Activity) is one of the Android four-megacomponents (Activity, service, broadcast Receiver and Content Provider), which is mainly responsible for interacting with users. Activity may be understood as a screen page in an application where various interfaces and interactive elements (such as buttons, text boxes, etc.) that a user sees are presented when they open the application. During development, a developer may create one or more activities for an application to implement different functions and interfaces. Each Activity has its own life cycle, and the activities can be switched between different states according to the user's operation and the state change of the application.
Context: a Context object is an abstract class provided by the Android system that provides the ability to access resources and classes associated with an application. Context is a carrier of Context information related to an application. It can help developers access various resources (e.g., pictures, strings, etc.) and components (e.g., services, broadcast receivers, etc.) in applications, as well as many system-level functions (e.g., launching other activities, sending broadcasts, etc.). During development, developers often use contexts to implement different functions and operations. For example, a resource file of an application may be acquired by Context, or another Activity may be started with Context, or the like.
HashMap: hashMap is a hash table-based Map interface implementation. HashMap is understood to be a data structure that stores and manages data in the form of key-value pairs (key-value). This means that each value has a unique key corresponding to it in HashMap. Through this key, the corresponding value can be conveniently queried and accessed.
String: a character string is a type of data used to store text data. It is a sequence of characters including Chinese characters, english letters, numerals, punctuation marks, etc. In computer programming, character strings are typically used to represent text information such as file names, web addresses, mail content, and the like. The string is inflexible, i.e. its content cannot be modified once created, so when a string needs to be modified, a new string variable needs to be used to store the modified result.
Any: superclass objects in the kotlen language, whose parameter types are designed herein with "|" meaning that the type can be null, the syntax structure of kotlen.
Androidmanifast. An Android management file is an information description file of the whole Android application program, and provides basic information and configuration of the application program, including components, rights, functional requirements and the like of the application program. Briefly, an Android management. Xml file can provide basic information about an application program by the Android system, and this file is located under the root directory of the project. In the development process, a developer needs to configure various information in an Android management file so as to ensure that an application program runs normally on an Android device.
It should be noted that, in this application, english class names and method names may be customized to other names, in order to eliminate inter-dependent call between modules, the present application designs a route as a message transfer station (or a route transfer station), and all modules depend on the message transfer station, and then the communication between each module is implemented through the route transfer station. The following describes the basic components and structures of the routing transfer station in detail with reference to the accompanying drawings, and fig. 2 is a schematic diagram of the basic components and structures of the routing transfer station according to the embodiment of the present application. As shown in fig. 2, the basic components of the routing transfer station include an App entry, a Module, libs, and Route, where:
App inlet: this is the starting point for the whole program, responsible for starting the application, in which entry module the registration of the message channel will take place so that the individual components in the program can communicate.
Module1, module2, module3, module4: this is four different independent modules (also called page modules) which may be components of the same process as the portal module or may run in different processes. These modules may be functional modules in an application program that are responsible for handling various business logic.
Libs: this directory is used to store some common class libraries, where the present application will have routing functions independent and manage the names of the individual message channels in a unified way.
Route: this is a routing framework responsible for registering and managing the message channels of each module, which controls the messaging, ensuring that messages can be properly transferred between the various components.
It can be seen that the application program structure comprises an App portal, an independent module, a public class library and a routing framework. The registration of the message channel is performed in the App entry module, and the routing framework is responsible for managing the message channel and controlling the sending of the message.
The following details of the usage and principles of the routing transfer station are described in conjunction with the basic components and structures of the routing transfer station shown in fig. 2, which may specifically include the following:
First, at program initialization, a message channel is established in an Application class (Application class), which has the advantage that the route can be made to support multiple processes. In an Android Application program, multiple processes mean that an Application class will execute once in each process, and the initialization of a channel is placed in the Application class, so that it can be ensured that the channel is created in each process.
Secondly, realizing a specific message channel, firstly creating a specific channel class (for example, mainAction, name can be customized), allowing the class to inherit an IAaction class (message channel class), and then realizing an abstract method in the IAaction class. According to specific service requirements, the page skip function is realized in the channel class.
In addition, when a message needs to be sent, the IRouter class (the previously created message processing core class) is used to call a message sending method in the IRouter class, and a message carrier and a designated channel are input, so that the message can be sent to a target receiver.
In some embodiments, prior to introducing the pre-structured message carrier into the route, the method of embodiments of the present application further comprises:
the method comprises the steps of creating a new message carrier by using a new method through pre-defined message data attribute storage page data transferred when jumping, storing key value pairs by using a parameter setting method, and setting the name attribute of a jumping action by using an action setting method so as to construct the message carrier.
Specifically, before the message carrier is introduced into the route, the embodiment of the application needs to construct a carrier for sending the message (i.e. the message carrier), and the message carrier is called routereq class, which is used for transferring data related to page hops. The construction process and principle of the message carrier will be described in detail with reference to specific embodiments.
In some embodiments, storing data transferred when a page jumps with a predefined message data attribute, creating a new message carrier with a new method, saving key value pairs with a parameter setting method, setting a name attribute of a jump action with an action setting method, comprising:
defining message data attributes in a class of a preset message carrier, wherein the type of the message data attributes is a hash table;
creating a new method in the class of the message carrier, wherein the new method is used for creating a new message carrier;
creating a parameter setting method in the class of the message carrier, wherein the parameter setting method is used for storing keys and values as parameters into a message data hash table;
an action setting method is created in the class of the message carrier for assigning action parameters to action name attributes in the class of the message carrier.
Specifically, when constructing the message carrier, firstly, an attribute named actData (i.e. message data attribute) is defined in routereq class (i.e. class of message carrier), and the type of the attribute is HashMap < String, any | >, which is used for storing data to be transferred when the page jumps. Then, an attribute name of String type is defined as actionName, which is used to represent the name of jump action.
Next, a method named build () is created in the routereq class (i.e., a new method). In this method, a routereq object is created and directly returned, so that a new routereq instance can be obtained by calling the build () method.
Then, a method named setData (mKey: string, mValue: any|) is newly built in the RouterReq class (i.e., a parameter setting method). In this method, two parameters, mKey and mValue, are stored in the actData hash table of the actData attribute. Thus, different key-value pairs can be stored in actData by this method for use in page jumps.
Finally, a method named setAction (action: string) (i.e., action setup method) is newly created. In this method, the action parameter (i.e., action parameter) is directly assigned to the actionName attribute (i.e., action name attribute) in the routereq class. Thus, the name of the jump action can be specified by calling the setAction () method.
It can be seen that the embodiments of the present application provide a complete implementation process for creating a routereq class that encapsulates page jump related data and action names. Through setData () and setAction () methods, embodiments of the present application can set data and hops to be transferred as names, and create a new routereq instance using build () methods.
Further, before the pre-constructed message carrier is transferred into the route, the embodiment of the application needs to create an IRouter class (i.e. route) as a core part of message processing for processing the forwarding message. The main function of IRouter is to process and forward incoming messages of different message channels so that they can arrive correctly at the target. The route IRouter created by the embodiment of the application has the following characteristics:
maintaining a queue: within the IRouter class, messages received from different message channels are received and stored using a queue.
The design is a single case mode: to ensure that only one instance of IRouter exists throughout the application, embodiments of the present application design it as a single instance mode. Thus, whenever the IRouter function is required, the same instance is used, ensuring data consistency.
Support multithreading: through the single-instance mode, the IRouter class can support multithreading, namely, the message is processed and forwarded in a plurality of threads at the same time, and the efficiency is improved.
Realizing channel establishment and message sending logic: within the IRouter class, code needs to be written to implement the function of establishing a message channel and sending the message to the correct destination.
Thus, the IRouter class is a core class responsible for handling and forwarding messages, which receives messages using queues and supports multithreading through single instance mode. Embodiments of the present application require logic to implement the establishment of message channels and sending messages in this class.
In some embodiments, after the created message carrier is passed into the routing IRouter, the embodiments of the present application will create a message channel (iaaction) in the page module of the application class, where the iaaction is controlled by the routing IRouter, and send the message to the designated message channel, where the channel is implemented using an abstract method, and may send different types of messages.
In practice, an IAaction is a class of message channels that is used to send and process messages on different message channels. The IAaction class operates under the control of the IRouter class. IRouter is responsible for handling and forwarding messages, while IAaction class is responsible for actually sending messages on the message channel. The function of the IAaction class is to send a message on a designated message channel so that the message can be properly delivered to the target. The channels in the IAaction class are implemented using an abstract method, which can provide flexible extensibility for different types of messages. A developer can implement a specific message channel according to needs, so that different types of messages can be flexibly sent.
In some embodiments, before obtaining the message channel identifier from the message carrier according to the message channel mapping table preset in the route, the method according to the embodiment of the present application further includes:
the method is used for judging whether the message channel mapping table contains the preset message channel identification or not, and when the preset message channel identification is not contained, the preset message channel identification and the message channel corresponding to the message channel identification are stored in the message channel mapping table so as to register the message channel in the route.
Specifically, the embodiment of the application defines an attribute named actions in the IRouter class, and the actions attribute can be understood as a message channel map, which represents a mapping table storing all message channels and is used for quickly querying and managing different message channels. The types of actions attributes are HashMap < String, IAaction > for storing all message channels (IAactions).
After that, the embodiment of the application realizes a registration method registAction (actionName: string, action: IAaction). In this registration method, it is first determined whether a given message channel identifier (actionName) is already contained in a message channel map (actions). If the actionName is not contained, the message channel identification actionName and the message channel action are stored in a message channel mapping table actions. The embodiment of the application registers each message channel in the IRouter class by using a registration method.
Further, routereq represents a carrier class (i.e. a message carrier) for sending a message, two parameters are defined inside the message carrier, namely a channel name and a message body, the channel name is used to identify which channel is to be used, the message body is a specific message to be sent, and the type of the message body is defined as a hash table, so that the hash table supports different message types.
When the embodiment of the application calls IRouter to send a message, a queryReq (req: routerReq) method is realized. The method obtains the actionName attribute of the RouterReq through the RouterReq object, and searches for and returns corresponding IActions from the acts according to the actionName. That is, a method called queryReq (req: routereq) is implemented, which obtains the actionName attribute of routereq through routereq object, and then searches and returns the corresponding IAction from the actions mapping table according to actionName. Briefly, this method queries and retrieves the message channel corresponding to the request by providing a routereq request object.
In some embodiments, invoking the execution action method of the message channel to execute the jump logic includes:
creating a feedback class of message transmission, acquiring a requested message channel by using a preset query request method, calling an execution action method of the message channel to execute page jump logic, and returning a page jump result by using the feedback class of message transmission.
Specifically, when the embodiment of the application calls IRouter to send a message, a method named sendMsg (cxt: context, req: routerReq) is also implemented. This method first creates a routeres object for returning the jump result. Then, the queryReq method in the foregoing embodiment is called to obtain the corresponding IAaction channel, and then the actionTo method of the IAaction (i.e. executing the action method) is called to execute the specific jump logic. Finally, the routeres object is returned.
That is, embodiments of the present application also implement a method called "sendMsg" that receives two parameters: one is "cxt" representing a context object and the other is "req" representing a route request object. In this method, a "routeres" object is first created for returning the results of the page hop. The "queryReq" method is then invoked to obtain the "IAaction" channel corresponding to the request. The "actionTo" method of "IAaction" is then invoked to execute the specific page jump logic. Finally, the "routeres" object is returned directly. In short, this approach is to process incoming route requests and perform page jumps, and then return the result of the jumps.
Further, routeres represents a feedback class of message transmission, and is used to notify a sender of a result of message transmission, and may be flexibly defined, such as a status code (code), a message content (msg), and the like. The above embodiments of the present application describe how to use the IRouter class to send a message, where the present application registers a message channel first, then queries a corresponding channel according to a request, and finally actually sends the message and performs a skip operation by using the sendMsg method.
The foregoing embodiments respectively describe the construction of the message carrier, the construction of the message channel, and the specific implementation process and principle of calling the IRouter to send the message in detail. The following describes in detail a specific implementation procedure of the route-based page hopping scheme of the present application with reference to specific embodiments.
Taking a jump between two page modules as an example, how to construct the message channel IAction in two different page modules (Module 1 and Module 2) respectively, and the process running in different processes is described specifically, the following may be included:
step 1: creating a new Activity named as Activity1 in Module1, and creating a class named as Activity1, so that the class realizes an IAaction interface. Then, an actionTo (Context, data: hashMap < String, any | >) method (i.e., an execution action method) is rewritten, and this method is used to store in HashMap in the form of key value pairs according to the Context (Context) and data (data) entered, and to execute specific actions such as page jumps, etc.
Step 2: the Action1 class represents an Action to jump to Action 1. In the actionTo method, an Intint object (i.e., a target jump intention object) named mIntnt is created, which is used to represent the intention of an application to perform an action, such as jumping to another page.
Step 3: and traversing the data parameters transferred to the actionTo method by utilizing the characteristics of the Kotlen language, and adding the key value pairs in the data into the mIntent object one by calling the mIntent. PutExtra () method.
Step 4: calling a context.startActivity () method, starting Activity1 by using an mIntent object, and realizing page skip.
In addition, the embodiment of the application creates a new Activity named as Activity2 in Module2, and creates a class named as Action2, so that the class realizes an IAaction interface. Next, the contents of the steps 2 to 4 completed above are repeated.
In order to enable the first page Module1 and the second page Module2 to run in different processes, an android process= ": module2" attribute is added for Activity2 in an android management.xml configuration file under a Module2 directory.
It is emphasized that the attribute android: process= ": module2" in: "module 2" may be named arbitrarily here, but in practical applications it is necessary to start with, based on security considerations, representing a private process, indicating that only the current app is accessible and that no other app is accessible.
According to the technical scheme provided by the embodiment of the application, the embodiment of the application can realize data transmission between two activities and page skip by respectively constructing the message channel IAaction in two independent modules and realizing running the two modules in different processes, traversing the data parameters and adding the key value pairs into the Intent object.
In some embodiments, the method of embodiments of the present application further comprises:
and calling a registration method to register the message channel as a parameter in a file of the application program class, and setting the route to a single-instance mode so as to process and forward the messages among page modules in different processes.
Specifically, in the Application file (i.e., the file of the Application class) of the whole project, the registAction method is called twice, and the Action1 (i.e., the first page Module) and the Action2 (i.e., the second page Module) are respectively taken as parameters to be input and registered, where the acquisition of the IRouter object needs to be set to a single instance mode (sington), because Module1 and Module2 are in different processes.
In some embodiments, the method of embodiments of the present application further comprises:
creating a user interface component in an entry module of an application program, setting a button component corresponding to a page module in the user interface component, and responding to clicking operation of a user on the button component, and jumping to the user interface component of the page module corresponding to the button component.
Specifically, in the App entry Module, an Activity (i.e., a user interface component) is newly created, named as an enhanced Activity, and two buttons, button1 and Button2, are newly added in the Activity, wherein clicking Button1 jumps to the Activity in Module1, clicking Button2 jumps to the Activity in Module2, and when clicking the Button, an IRouter object is acquired first, and then a sendMsg method is called to transfer the context object and routereq parameter.
In practical applications, the value of setAction of the RouterReq object in Button1 corresponds to Action1, and the value of setAction of the RouterReq object in Button2 corresponds to Action2.
In the step of the foregoing embodiment, if the IAaction channel is not registered, a situation that the jump failure throws out an exception may occur, when a returned IAaction is acquired, whether the IAaction is empty or not is judged, if yes, a next step of processing is performed, for example, a direct Toast prompts a user or a RouterRes object may be directly constructed, an error status code (code= -1) is set, and the error status code is returned to a caller, so that the caller performs unified error processing in the following manner: 1. newly building a common error page (error); 2. judging the code in the RouterRes object, if the code is equal to-1, then re-jumping to the error in step 1, and displaying a text in the page for prompting the user.
According to the technical scheme provided by the embodiment of the application, when the page skip method based on the route is used for realizing the page skip in the mobile application program, compared with the display intention and the implicit intention in the existing native routing system, the page skip method based on the route has the following remarkable technical effects:
class dependent decoupling is achieved: by using message bearers and message channels to handle page jump logic, specific classes that directly depend on the target page are avoided. This makes module splitting easier, thereby improving development efficiency.
Supporting communication among modules under multiple processes: the method and the device adopt the routing to process and forward the information among the page modules in different processes, thereby realizing the communication among the modules under multiple processes.
Routing logic may be modified: the method and the device allow the developer to modify the routing logic, such as performing degradation processing, when the jump fails, so as to avoid direct throwing of the exception. This helps to improve the stability of the application and the user experience.
The following are device embodiments of the present application, which may be used to perform method embodiments of the present application. For details not disclosed in the device embodiments of the present application, please refer to the method embodiments of the present application.
Fig. 3 is a schematic structural diagram of a route-based page skip device according to an embodiment of the present application. As shown in fig. 3, the route-based page jumping apparatus includes:
an incoming module 301 configured to incoming a pre-structured message carrier into a route and create a message channel in a page module of an application class;
a creation module 302 configured to create a target skip intention object in the execution action method of the message channel, the target skip intention object being used to represent a skip intention relationship between the original page and the target page;
a traversing module 303 configured to traverse parameters in the execution action method and add key value pairs in the parameters to the target jump intention object one by one;
the query module 304 is configured to obtain a message channel identifier from the message carrier according to a message channel mapping table preset in the route, and query the message channel mapping table by using the message channel identifier to obtain a message channel corresponding to the message channel identifier;
a calling module 305 configured to call the execution action method of the message channel to execute the jump logic to jump from the original page to the target page.
In some embodiments, the construction module 306 of fig. 3 stores the data transferred at page jumps by predefined message data attributes before passing the pre-constructed message carrier into the route, creates a new message carrier using the new method, saves the key value pairs using the parameter setting method, and sets the name attribute of the jump action using the action setting method to construct the message carrier.
In some embodiments, the construction module 306 of fig. 3 defines the message data attributes in a class of preset message bearers, the type of message data attributes being a hash table; creating a new method in the class of the message carrier, wherein the new method is used for creating a new message carrier; creating a parameter setting method in the class of the message carrier, wherein the parameter setting method is used for storing keys and values as parameters into a message data hash table; an action setting method is created in the class of the message carrier for assigning action parameters to action name attributes in the class of the message carrier.
In some embodiments, the query module 304 of fig. 3 implements a registration method in the route before obtaining the message channel identifier from the message carrier according to a message channel mapping table preset in the route, where the registration method is used to determine whether the message channel mapping table contains a predetermined message channel identifier, and when the message channel identifier does not contain the predetermined message channel identifier, the predetermined message channel identifier and a message channel corresponding to the message channel identifier are stored in the message channel mapping table, so as to register the message channel in the route.
In some embodiments, the calling module 305 of fig. 3 creates a feedback class of the message transmission, obtains the requested message channel using a preset query request method, calls an execution action method of the message channel to execute the page jump logic, and returns the result of the page jump using the feedback class of the message transmission.
In some embodiments, the setup module 307 of fig. 3 invokes a registration method to register a message channel as a parameter into a file of an application class and sets the route to a single instance mode to enable the route to handle message processing and forwarding between page modules in different processes.
In some embodiments, the setting module 307 of fig. 3 creates a user interface component in the entry module of the application program, sets a button component corresponding to the page module in the user interface component, and jumps to the user interface component of the page module corresponding to the button component in response to a click operation of the button component by the user.
It should be understood that the sequence number of each step in the foregoing embodiment does not mean that the execution sequence of each process should be determined by the function and the internal logic of each process, and should not limit the implementation process of the embodiment of the present application in any way.
Fig. 4 is a schematic structural diagram of the electronic device 4 provided in the embodiment of the present application. As shown in fig. 4, the electronic apparatus 4 of this embodiment includes: a processor 401, a memory 402 and a computer program 403 stored in the memory 402 and executable on the processor 401. The steps of the various method embodiments described above are implemented by processor 401 when executing computer program 403. Alternatively, the processor 401, when executing the computer program 403, performs the functions of the modules/units in the above-described apparatus embodiments.
Illustratively, the computer program 403 may be partitioned into one or more modules/units, which are stored in the memory 402 and executed by the processor 401 to complete the present application. One or more of the modules/units may be a series of computer program instruction segments capable of performing a specific function for describing the execution of the computer program 403 in the electronic device 4.
The electronic device 4 may be a desktop computer, a notebook computer, a palm computer, a cloud server, or the like. The electronic device 4 may include, but is not limited to, a processor 401 and a memory 402. It will be appreciated by those skilled in the art that fig. 4 is merely an example of the electronic device 4 and is not meant to be limiting of the electronic device 4, and may include more or fewer components than shown, or may combine certain components, or different components, e.g., the electronic device may also include an input-output device, a network access device, a bus, etc.
The processor 401 may be a central processing unit (Central Processing Unit, CPU) or other general purpose processor, digital signal processor (Digital Signal Processor, DSP), application specific integrated circuit (Application SpecificIntegrated Circuit, ASIC), field programmable gate array (Field-Programmable Gate Array, FPGA) or other programmable logic device, discrete gate or transistor logic device, discrete hardware components, or the like. A general purpose processor may be a microprocessor or the processor may be any conventional processor or the like.
The memory 402 may be an internal storage unit of the electronic device 4, for example, a hard disk or a memory of the electronic device 4. The memory 402 may also be an external storage device of the electronic device 4, for example, a plug-in hard disk, a Smart Media Card (SMC), a Secure Digital (SD) Card, a Flash Card (Flash Card) or the like, which are provided on the electronic device 4. Further, the memory 402 may also include both internal storage units and external storage devices of the electronic device 4. The memory 402 is used to store computer programs and other programs and data required by the electronic device. The memory 402 may also be used to temporarily store data that has been output or is to be output.
It will be apparent to those skilled in the art that, for convenience and brevity of description, only the above-described division of the functional units and modules is illustrated, and in practical application, the above-described functional distribution may be performed by different functional units and modules according to needs, i.e. the internal structure of the apparatus is divided into different functional units or modules to perform all or part of the above-described functions. The functional units and modules in the embodiment may be integrated in one processing unit, or each unit may exist alone physically, or two or more units may be integrated in one unit, where the integrated units may be implemented in a form of hardware or a form of a software functional unit. In addition, specific names of the functional units and modules are only for convenience of distinguishing from each other, and are not used for limiting the protection scope of the present application. The specific working process of the units and modules in the above system may refer to the corresponding process in the foregoing method embodiment, which is not described herein again.
In the foregoing embodiments, the descriptions of the embodiments are emphasized, and in part, not described or illustrated in any particular embodiment, reference is made to the related descriptions of other embodiments.
Those of ordinary skill in the art will appreciate that the various illustrative elements and algorithm steps described in connection with the embodiments disclosed herein may be implemented as electronic hardware, or combinations of computer software and electronic hardware. Whether such functionality is implemented as hardware or software depends upon the particular application and design constraints imposed on the solution. Skilled artisans may implement the described functionality in varying ways for each particular application, but such implementation decisions should not be interpreted as causing a departure from the scope of the present application.
In the embodiments provided in this application, it should be understood that the disclosed apparatus/computer device and method may be implemented in other ways. For example, the apparatus/computer device embodiments described above are merely illustrative, e.g., the division of modules or elements is merely a logical functional division, and there may be additional divisions of actual implementations, multiple elements or components may be combined or integrated into another system, or some features may be omitted, or not performed. Alternatively, the coupling or direct coupling or communication connection shown or discussed may be an indirect coupling or communication connection via interfaces, devices or units, which may be in electrical, mechanical or other forms.
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 units may be selected according to actual needs to achieve the purpose of the solution of this embodiment.
In addition, each functional unit in each embodiment of the present application may be integrated in one processing unit, or each unit may exist alone physically, or two or more units may be integrated in one unit. The integrated units may be implemented in hardware or in software functional units.
The integrated modules/units, if implemented in the form of software functional units and sold or used as stand-alone products, may be stored in a computer readable storage medium. Based on such understanding, the present application implements all or part of the flow in the methods of the above embodiments, or may be implemented by a computer program to instruct related hardware, and the computer program may be stored in a computer readable storage medium, where the computer program may implement the steps of the respective method embodiments described above when executed by a processor. The computer program may comprise computer program code, which may be in source code form, object code form, executable file or in some intermediate form, etc. The computer readable medium may include: any entity or device capable of carrying 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 (Random Access Memory, RAM), an electrical carrier signal, a telecommunications signal, a software distribution medium, and so forth. It should be noted that the content of the computer readable medium can be appropriately increased or decreased according to the requirements of the jurisdiction's jurisdiction and the patent practice, for example, in some jurisdictions, the computer readable medium does not include electrical carrier signals and telecommunication signals according to the jurisdiction and the patent practice.
The above embodiments are only for illustrating the technical solution of the present application, and are not limiting thereof; although the present application has been described in detail with reference to the foregoing embodiments, it should be understood by those of ordinary skill in the art that: the technical scheme described in the foregoing embodiments can be modified or some technical features thereof can be replaced by equivalents; such modifications and substitutions do not depart from the spirit and scope of the technical solutions of the embodiments of the present application, and are intended to be included in the scope of the present application.
Claims (10)
1. A route-based page skip method, comprising:
the method comprises the steps of inputting a pre-constructed message carrier into a route, and creating a message channel in a page module of an application program class;
creating a target jump intention object in an execution action method of the message channel, wherein the target jump intention object is used for representing a jump intention relationship between an original page and a target page;
traversing the parameters in the executing action method, and adding key value pairs in the parameters into the target jump intention object one by one;
acquiring a message channel identifier from the message carrier according to a message channel mapping table preset in the route, and inquiring the message channel mapping table by using the message channel identifier to acquire a message channel corresponding to the message channel identifier;
And calling an execution action method of the message channel to execute jump logic so as to jump from the original page to the target page.
2. The method of claim 1, wherein prior to said entering the pre-constructed message carrier into the route, the method further comprises:
and storing data transferred when the page jumps through a predefined message data attribute, creating a new message carrier by using a new method, storing a key value pair by using a parameter setting method, and setting the name attribute of the jump action by using an action setting method so as to construct the message carrier.
3. The method of claim 2, wherein the storing data transferred when a page jumps by a predefined message data attribute, creating a new message carrier by a new method, saving a key value pair by a parameter setting method, setting a name attribute of a jumping action by an action setting method, comprises:
defining message data attributes in a class of a preset message carrier, wherein the type of the message data attributes is a hash table;
creating a new method in the class of the message carrier, wherein the new method is used for creating a new message carrier;
Creating a parameter setting method in the class of the message carrier, wherein the parameter setting method is used for storing keys and values as parameters into a message data hash table;
an action setting method is created in the class of the message carrier, and the action setting method is used for assigning action parameters to action name attributes in the class of the message carrier.
4. The method according to claim 1, wherein before said obtaining a message channel identifier from said message carrier according to a message channel mapping table preset in said route, said method further comprises:
and implementing a registration method in the route, wherein the registration method is used for judging whether the message channel mapping table contains a preset message channel identifier, and storing the preset message channel identifier and a message channel corresponding to the message channel identifier into the message channel mapping table when the preset message channel identifier is not contained, so as to register the message channel in the route.
5. The method of claim 1, wherein the invoking the method of performing actions of the message channel to perform jump logic comprises:
Creating a feedback class of message transmission, acquiring a requested message channel by using a preset query request method, calling an execution action method of the message channel to execute page jump logic, and returning a page jump result by using the feedback class of message transmission.
6. The method according to claim 4, wherein the method further comprises:
and calling the registration method to transfer the message channel as a parameter into the file of the application program class for registration, and setting the route to a single-instance mode so as to enable the route to process and forward the messages among the page modules in different processes.
7. The method of claim 6, wherein the method further comprises:
creating a user interface component in an entry module of an application program, setting a button component corresponding to the page module in the user interface component, and responding to clicking operation of a user on the button component, and jumping to the user interface component of the page module corresponding to the button component.
8. A route-based page jumping apparatus, comprising:
an incoming module configured to incoming a pre-structured message carrier into a route and create a message channel in a page module of an application class;
A creating module configured to create a target jump intention object in an execution action method of the message channel, wherein the target jump intention object is used for representing a jump intention relationship between an original page and a target page;
the traversing module is configured to traverse parameters in the executing action method and add key value pairs in the parameters into the target jump intention object one by one;
the query module is configured to acquire a message channel identifier from the message carrier according to a message channel mapping table preset in the route, and query the message channel mapping table by utilizing the message channel identifier to acquire a message channel corresponding to the message channel identifier;
and the calling module is configured to call an execution action method of the message channel to execute jump logic so as to jump from the original page to the target page.
9. An electronic device comprising a memory, a processor and a computer program stored on the memory and executable on the processor, wherein the processor implements the method of any one of claims 1 to 7 when the program is executed by the processor.
10. A computer readable storage medium storing a computer program, characterized in that the computer program when executed by a processor implements the method according to any one of claims 1 to 7.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202310510442.XA CN116233217B (en) | 2023-05-08 | 2023-05-08 | Page jump method and device based on route, electronic equipment and storage medium |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202310510442.XA CN116233217B (en) | 2023-05-08 | 2023-05-08 | Page jump method and device based on route, electronic equipment and storage medium |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN116233217A true CN116233217A (en) | 2023-06-06 |
| CN116233217B CN116233217B (en) | 2023-07-21 |
Family
ID=86584715
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202310510442.XA Active CN116233217B (en) | 2023-05-08 | 2023-05-08 | Page jump method and device based on route, electronic equipment and storage medium |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN116233217B (en) |
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN117130692A (en) * | 2023-10-23 | 2023-11-28 | 成都赛力斯科技有限公司 | Application management method, device, electronic equipment and storage medium |
Citations (12)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN107707614A (en) * | 2017-08-16 | 2018-02-16 | 深圳市丰巢科技有限公司 | App route implementation methods, equipment and the storage medium of agreement are jumped based on system |
| US20180198915A1 (en) * | 2015-06-30 | 2018-07-12 | Zte Corporation | Interactive processing method and device |
| US20180278671A1 (en) * | 2015-11-27 | 2018-09-27 | Alibaba Group Holding Limited | Page jump method and apparatus |
| CN109669716A (en) * | 2018-09-25 | 2019-04-23 | 深圳壹账通智能科技有限公司 | Page control method, device, equipment and readable storage medium storing program for executing |
| CN109857386A (en) * | 2018-12-30 | 2019-06-07 | 贝壳技术有限公司 | A kind of method for page jump and device |
| CN110221872A (en) * | 2019-04-22 | 2019-09-10 | 五八有限公司 | Method for page jump, device, electronic equipment and storage medium |
| CN110347942A (en) * | 2019-05-31 | 2019-10-18 | 深圳壹账通智能科技有限公司 | Method for page jump, device, storage medium and computer equipment |
| CN111143723A (en) * | 2019-12-26 | 2020-05-12 | 五八同城信息技术有限公司 | Page jump method and device, electronic equipment and storage medium |
| CN112040013A (en) * | 2020-11-05 | 2020-12-04 | 南京研利科技有限公司 | Method, computing device and computer storage medium for page routing |
| CN112307374A (en) * | 2020-10-30 | 2021-02-02 | 康键信息技术（深圳）有限公司 | Jumping method, device and equipment based on backlog and storage medium |
| CN114817803A (en) * | 2022-03-22 | 2022-07-29 | 上海淇玥信息技术有限公司 | Page skipping method and device and electronic equipment |
| CN115827115A (en) * | 2022-11-16 | 2023-03-21 | 康键信息技术（深圳）有限公司 | H5 page jump method, device, equipment and storage medium of WeChat applet |
-
2023
- 2023-05-08 CN CN202310510442.XA patent/CN116233217B/en active Active
Patent Citations (12)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20180198915A1 (en) * | 2015-06-30 | 2018-07-12 | Zte Corporation | Interactive processing method and device |
| US20180278671A1 (en) * | 2015-11-27 | 2018-09-27 | Alibaba Group Holding Limited | Page jump method and apparatus |
| CN107707614A (en) * | 2017-08-16 | 2018-02-16 | 深圳市丰巢科技有限公司 | App route implementation methods, equipment and the storage medium of agreement are jumped based on system |
| CN109669716A (en) * | 2018-09-25 | 2019-04-23 | 深圳壹账通智能科技有限公司 | Page control method, device, equipment and readable storage medium storing program for executing |
| CN109857386A (en) * | 2018-12-30 | 2019-06-07 | 贝壳技术有限公司 | A kind of method for page jump and device |
| CN110221872A (en) * | 2019-04-22 | 2019-09-10 | 五八有限公司 | Method for page jump, device, electronic equipment and storage medium |
| CN110347942A (en) * | 2019-05-31 | 2019-10-18 | 深圳壹账通智能科技有限公司 | Method for page jump, device, storage medium and computer equipment |
| CN111143723A (en) * | 2019-12-26 | 2020-05-12 | 五八同城信息技术有限公司 | Page jump method and device, electronic equipment and storage medium |
| CN112307374A (en) * | 2020-10-30 | 2021-02-02 | 康键信息技术（深圳）有限公司 | Jumping method, device and equipment based on backlog and storage medium |
| CN112040013A (en) * | 2020-11-05 | 2020-12-04 | 南京研利科技有限公司 | Method, computing device and computer storage medium for page routing |
| CN114817803A (en) * | 2022-03-22 | 2022-07-29 | 上海淇玥信息技术有限公司 | Page skipping method and device and electronic equipment |
| CN115827115A (en) * | 2022-11-16 | 2023-03-21 | 康键信息技术（深圳）有限公司 | H5 page jump method, device, equipment and storage medium of WeChat applet |
Non-Patent Citations (2)
| Title |
|---|
| ZAYZY: "路由跳转的3种方式", Retrieved from the Internet <URL:https://blog.csdn.net/weixin_45630345/article/details/119714591> * |
| 陈辰;王萌;程旭;: "基于路由模式的前端框架设计与改进", 电脑知识与技术, no. 12, pages 59 - 60 * |
Cited By (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN117130692A (en) * | 2023-10-23 | 2023-11-28 | 成都赛力斯科技有限公司 | Application management method, device, electronic equipment and storage medium |
| CN117130692B (en) * | 2023-10-23 | 2024-01-23 | 成都赛力斯科技有限公司 | Application management method, device, electronic equipment and storage medium |
Also Published As
| Publication number | Publication date |
|---|---|
| CN116233217B (en) | 2023-07-21 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US10558435B2 (en) | System and method for a development environment for building services for a platform instance | |
| US8788580B2 (en) | Event broker for an improved application server platform for telecom-based applications | |
| US10073707B2 (en) | System and method for configuring a platform instance at runtime | |
| CN116018788A (en) | Configuring service grid networking resources for dynamically discovered peers or network functions | |
| CN111345008B (en) | Mobile edge host service notification method and device | |
| US8688835B2 (en) | Service enablement/disablement based on service relationships | |
| US20120166646A1 (en) | Method and apparatus for providing multi-level distributed computations | |
| CN116233217B (en) | Page jump method and device based on route, electronic equipment and storage medium | |
| CN112799825A (en) | Task processing method and network equipment | |
| WO2019223099A1 (en) | Application program calling method and system | |
| US11915034B2 (en) | Sidecar-based integration capabilities for containerized applications | |
| CN110505318B (en) | Uniform resource locator addressing method and device, and network system | |
| CN112235378B (en) | Data updating method and device, storage medium and electronic equipment | |
| CN114710549A (en) | Dynamic management method, system and service node of network card in container platform | |
| CN114222003A (en) | Service calling method, system, device, equipment and storage medium | |
| CN110798504B (en) | Method, device, management equipment and storage medium for cross-region sharing service | |
| CN108370329B (en) | Management method and device for management function object | |
| CN110324722B (en) | Method, device, equipment and storage medium for acquiring data in live broadcast room | |
| JP2021010164A (en) | Method and apparatus for processing notification using notification preset | |
| CN109144520B (en) | Information interaction method, device, equipment and storage medium among different objects in Android | |
| CN116668520A (en) | Gateway-based service arrangement method, system, equipment and storage medium | |
| EP4340436A1 (en) | Operation and maintenance method, apparatus, and system, server, electronic device, and medium | |
| CN106559454B (en) | Resource access method, device and system | |
| CN113918215A (en) | Micro-service configuration system, equipment and medium | |
| CN113760481A (en) | Distributed timed task scheduling system and method |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant | ||
| TR01 | Transfer of patent right | ||
| TR01 | Transfer of patent right |
Effective date of registration: 20240116 Address after: No. 13 Xingxiang Road, Zengjia Town, High tech Zone, Shapingba District, Chongqing, 400039 Patentee after: Chongqing Selis Phoenix Intelligent Innovation Technology Co.,Ltd. Address before: 610095 No. 2901, floor 29, unit 1, building 1, No. 151, Tianfu Second Street, high tech Zone, China (Sichuan) pilot Free Trade Zone, Chengdu, Sichuan Province Patentee before: Chengdu Thalys Technology Co.,Ltd. |