CN112905272A - Account-opening checking method suitable for multi-scene prototype combination - Google Patents
Account-opening checking method suitable for multi-scene prototype combination Download PDFInfo
- Publication number
- CN112905272A CN112905272A CN202110310942.XA CN202110310942A CN112905272A CN 112905272 A CN112905272 A CN 112905272A CN 202110310942 A CN202110310942 A CN 202110310942A CN 112905272 A CN112905272 A CN 112905272A
- Authority
- CN
- China
- Prior art keywords
- account
- java
- opening
- verification
- class
- 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.)
- Withdrawn
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/448—Execution paradigms, e.g. implementations of programming paradigms
- G06F9/4488—Object-oriented
- G06F9/449—Object-oriented method invocation or resolution
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/20—Software design
- G06F8/24—Object-oriented
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/30—Creation or generation of source code
- G06F8/36—Software reuse
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/445—Program loading or initiating
- G06F9/44521—Dynamic linking or loading; Link editing at or after load time, e.g. Java class loading
Abstract
The invention discloses an account opening verification method suitable for multi-scene prototype combination, belongs to the field of multi-scene verification, and solves the problems of high complexity of programs and poor loose coupling of codes in the prior art; the logic judgment is more, and the code readability is poor; poor flexibility, large development workload, low efficiency and the like. The invention creates a simulation account opening calling program OpenAccountTest. The invention is used for account opening verification of multi-scene prototype combination.
Description
Technical Field
An account opening verification method suitable for multi-scene prototype combination is used for account opening verification of the multi-scene prototype combination and belongs to the field of multiple scene verification.
Background
In the age of the rapid development of the internet, the internet technology is applied to various industries, and the technology is more and more diversified, along with the scene also more and more diversified. When a certain function is realized, more consideration is needed to adapt to various scenes, each scene has respective verification, the program development is more and more complicated, and the following technical problems are specifically existed:
1. the complexity of the program is high, and the loose coupling of the code is poor;
2. the logic judgment is more, the code readability is poor, the logic responsibility is realized, and the execution performance is influenced;
3. the flexibility is poor, the development workload is large, and the efficiency is low.
Disclosure of Invention
Aiming at the research problems, the invention aims to provide an account opening verification method suitable for multi-scene prototype combination, which solves the problems of high complexity of programs and poor loose coupling of codes in the prior art; the logic judgment is more, and the code readability is poor; poor flexibility, large development workload, low efficiency and the like.
In order to achieve the purpose, the invention adopts the following technical scheme:
an account opening verification method suitable for multi-scene prototype combination comprises the following steps:
s1, defining an abstract type OpenAccount.java of a simulated opening scene as a top-level parent type OpenAccount, and defining an abstract opening method open in the top-level parent type OpenAccount to simulate opening to obtain an account;
defining an account opening verification component prototype public interface type IOpenAccountComponent, java, as a top level parent type IOpenAccountComponent, and defining a verification abstract method verification at the top level parent type IOpenAccountComponent for obtaining a verification result of whether account opening is possible or not;
java, which is used as an attribute and is injected into a parent node OpenAccoun;
s2, defining an account opening verification component prototype realization class BaseCheckcomponent, java, as a subclass node BaseCheckcomponent inheriting a parent node IOpenAccountcomponent, realizing the account opening verification component prototype public interface class IOpenAccountcomponent, java, and obtaining a verification result of whether an account can be opened or not by realizing verification abstract method verification;
s3, defining an account opening checking component prototype realization class OnlineCheck component, java, as a subclass node OnlineCheck component inheriting a father class node IOpenAccountcomponent, realizing the account opening checking component prototype public interface class IOpenAccountcomponent, java, and obtaining a checking result of whether an account can be opened or not by realizing checking abstract method verification;
s4, defining a simulation counter open Account.java as a subclass node CounterOpenAccount inheriting a father node OpenAccount, inheriting a simulation open scene abstract OpenAccount.java, accessing an open verification component prototype public interface class IOpenAccount _ java into a simulation counter open Account.java to obtain verification component injection, simultaneously simulating a counter open scene implementation class CounterOpenAccount.java to further realize an abstract open method open, and simulating an open to obtain an account number;
s5, defining an online open scene realization class ONLineOpenAccount.java of a simulation, as a subclass node ONLineOpenAccount inheriting a parent class node OpenAccount, inheriting an open scene abstraction class OpenAccount.java of the simulation, accessing an open verification component prototype public interface class IOpenAccount Comment.java into an online open scene realization class ONLineOpenAccount.java of the simulation, obtaining check component injection, simultaneously realizing an online open scene realization class ONLineOpenAccount.java of the simulation, further realizing an abstract open method open, and simulating an open to obtain an account number;
and S6, creating a simulation account opening calling program OpenAccountTest.
Further, the step S1 includes the steps of:
step 1: creating an abstract type OpenAccount.java of a simulated opening scene, constructing the abstract type OpenAccount.java of the simulated opening scene through an abstrat class keyword, wherein the abstract type OpenAccount.java is a top-level parent type OpenAccount, defining an abstract opening method open in the abstract type OpenAccount.java of the simulated opening scene, wherein the abstract opening method open is an abstract method which is only defined but not realized, the concrete realization needs to be realized under an inherited subclass node, the abstract opening method open can realize the realization of each opening scene, is an abstract method of public operation, namely the simulated opening operation, and simultaneously returns an account number which is successfully opened;
step 2: creating an account opening verification component prototype public interface type IOpenAccountComponent. Constructing an account opening checking component prototype public interface type IOpenAccountComponent.java through interface keywords, wherein the type is a top-level parent type IOpenAccountComponent, and defining a checking abstract method verification by the account opening checking component prototype public interface type IOpenAccountComponent.java, wherein the checking abstract method verification is used for judging whether account opening can be performed or not, the checking abstract method verification is a public operation method of each account opening checking prototype realization type, each realization type needs to realize the checking abstract method verification, and whether an account opening can be performed or not is finally obtained: the tube is account-opening-possible, the false is account-non-opening-possible;
and step 3: and injecting java, which is an account opening verification component prototype public interface class IOpenAccountcomponent, into the parent class node OpenAccoun as an attribute.
Further, the step S2 includes the steps of:
step 1: defining a simulation account opening verification component prototype to realize a class BaseCheckcomponent, java, as a subclass node BaseCheckcomponent inheriting a parent node IOpenAccountcomponent;
step 2: the method comprises the steps that an account opening verification component prototype implementation class is BaseCheckcomponent java, an account opening verification component prototype public interface class IOpenAccountcomponent java is implemented, whether account opening verification method verification can be achieved or not is achieved, the verification abstraction method verification judges whether identity card, business license and legal information are normal or not, if the identity card, the business license and the legal information are returned normally, account opening can be achieved, and if the identity card, the business license and the legal information are abnormal, false account opening cannot be achieved.
Further, the step S3 includes the steps of:
step 1: defining a simulation account opening verification component prototype to realize class OnlineCheck component, java, as a subclass node OnlineCeck component inheriting parent class node IOpenAccountcomponent;
step 2: the method comprises the steps of enabling an account opening verification component prototype to realize an open account verification component prototype public interface type IOpenAccountcomponent.
Further, the step S4 includes the steps of:
step 1: defining a simulation counter account opening scene realization class CounterOpenAccount.java as a subclass node CounterOpenAccount inheriting a parent node OpenAccount;
step 2: simulating a counter open account implementation class CounterOpenAccount.java to inherit OpenAccount.java, and accessing an open account verification component prototype public interface class IOpenAccount Comment.java into the open account implementation class CounterOpenAccount.java to obtain verification component injection so as to call a verification abstract method verification under a sub-class node IOpenAccount Comment;
and step 3: meanwhile, simulating a counter account opening scene to realize a counter open account.java and also realizing that an abstract account opening method open simulates an account to obtain an account, wherein the concrete operation is to call a verification abstract method versification of a verification component in the abstract account opening method open realized by the counter open account.java in the account opening scene, if the return is true, the account can be opened, the simulated counter account opening operation is executed, the account with an account opening success is returned, if the return is false, the account cannot be opened, and the account opening failure is directly returned;
further, the step S5 includes the steps of:
step 1: defining an account opening scene on a simulation line to realize class OnlineOpAccount.java as a subclass node OnlineOpAccount inheriting a parent class node OpenAccount;
step 2: simulating an online opening scene realization class OnlineOpenAccount.java to inherit OpenAccount.java, and accessing an opening verification component prototype public interface class IOpenAccount Comment.java to the online opening scene realization class OnlineOpenAccount.java to obtain verification component injection so as to transfer a verification abstract method verification under a parent class node IOpenAccount Comment;
and step 3: and simultaneously simulating an online account opening scene to realize the online open account.java and also realizing that an abstract account opening method open simulates account opening to obtain an account, wherein the specific operation is to call a verification abstract method verification of a verification component in the method, if the return is true, the account can be opened, the online account opening operation is executed, the account with successful account opening is returned, and if the return is false, the account cannot be opened, and the account opening failure is directly returned.
Further, the step S6 includes the steps of:
step 1: creating a simulation account opening call class OpenAccountTest.java;
step 2: after the simulation account opening calling program openaccount test is built, the simulation call cabinet is opened, an instance of a simulation cabinet opening scene implementation class countopenaccount java is created, and a verification prototype component implementation class is combined as an attribute when the instance is created, namely the freely selected combination simulation cabinet opening scene implementation class countopenaccount java + simulation account opening verification component prototype implementation class basecard component java, or the combination simulation cabinet opening scene implementation class countopenaccount java + simulation account opening verification component prototype implementation class onlinecard component java, an opening scene implementation class onlineAccou java on a homological simulation line and an opening verification component prototype implementation class onlineAccou component are freely combined, namely the combination simulation line opening scene implementation class onlineAccou java + simulation opening verification component prototype implementation class onlinecard component implementation class is created by combining the openopen scene implementation class onlineAccou component implementation class java + simulation open scene open component implementation class basecard component, the open scene implementation class onlinecard component implementation class is combined with the openlinecard component implementation class onlinecard component implementation class. And a corresponding checking method of the checking component prototype is automatically called, and finally, an account number with successful account opening can be obtained successfully.
Compared with the prior art, the invention has the beneficial effects that:
the invention is suitable for the service scenes with multiple scenes, channels and inlets, the verification of each scene is modularized and abstracted into a verification prototype component implementation class, and the scene combination is realized by simulating an account opening scene implementation class and the verification prototype component implementation class, thereby achieving the effects of code multiplexing and clear logic.
And secondly, the method can be expanded to other non-account opening verification scenes, such as:
logging in: the modular prototype can be realized by means of fingerprint login, short message login, password login and the like, and various channels only need to call corresponding verification prototype components for login to realize the type;
transferring accounts: the verification prototype component implementation class can be realized by transaction password verification, short message verification, fingerprint verification and the like, the verification diversity, flexibility and the loose coupling of codes are improved, the corresponding verification prototype component implementation class can be called according to personal selection and then the transfer operation is carried out after the verification, and the following effects can be achieved through componentization recombination:
1. aiming at complex scenes, each scene is modularized and is extracted into each modularized unit, so that the complexity of a program is reduced, and the loose coupling of codes is improved;
2. by means of the combination of the components, multiple if judgment of the code is reduced, the logic is clearer, the readability of the code is improved, and the execution performance of hardware is improved.
3. The flexibility is improved, more customers can select through the combination and collocation of the scene and the verification method, and the realization is more flexible.
Drawings
FIG. 1 is an architectural diagram of the present invention;
FIG. 2 is a diagram illustrating substitution of account opening data into program code blocks;
fig. 3 is a diagram showing the result of substituting account opening data into a program code block.
Detailed Description
The invention will be further described with reference to the accompanying drawings and specific embodiments.
An account opening verification method suitable for multi-scene prototype combination comprises the following steps:
s1, defining an abstract type OpenAccount.java of a simulated account opening scene as a top-level parent type OpenAccoun, and defining an abstract account opening method open in the top-level parent type OpenAccoun for simulating account opening to obtain an account;
defining an account opening verification component prototype public interface type IOpenAccountComponent, java, as a top level parent type IOpenAccountComponent, and defining a verification abstract method verification at the top level parent type IOpenAccountComponent for obtaining a verification result of whether account opening is possible or not;
java, which is used as an attribute and is injected into a parent node OpenAccoun;
the method comprises the following steps:
step 1: creating an abstract type OpenAccount.java of a simulated opening scene, constructing the abstract type OpenAccount.java of the simulated opening scene through an abstrat class keyword (the abstract type OpenAccount.java is an existing construction mode), wherein the abstract type OpenAccount is a top-level parent type OpenAccount, defining an abstract opening method open under the abstract type OpenAccount.java of the simulated opening scene, wherein the abstract opening method open is only defined but not realized, and is realized under inherited subclass nodes (for example, a simulated counter open Account.java of the simulated cabinet opening scene and an online opening scene realization class of the simulated line opening scene defined below), wherein the abstract opening method open can realize various opening scene realization classes, is a public operation abstract method, namely, is used for simulating opening operation, and returns to open a successful account number at the same time;
step 2: creating an account opening verification component prototype public interface type IOpenAccountComponent. Constructing an account opening checking component prototype public interface class IOpenAccountComponent.java (in the existing construction mode) through an interface keyword, wherein the class is a top-level parent class IOpenAccountComponent, and defining a checking abstract method verification by the account opening checking component prototype public interface class IOpenAccountComponent.java, wherein the checking abstract method verification is used for judging whether account opening can be performed or not, the checking abstract method verification is a public operation method for realizing each account opening checking prototype, each realization class needs to realize the checking abstract method verification, and finally whether an account opening can be performed or not is obtained: the tube is account-opening-possible, the false is account-non-opening-possible;
and step 3: and injecting java, which is an account opening verification component prototype public interface class IOpenAccountcomponent, into the parent class node OpenAccoun as an attribute.
S2, defining an account opening verification component prototype realization class BaseCheckcomponent, java, as a subclass node BaseCheckcomponent inheriting a parent node IOpenAccountcomponent, realizing the account opening verification component prototype public interface class IOpenAccountcomponent, java, and obtaining a verification result of whether an account can be opened or not by realizing verification abstract method verification;
the method comprises the following steps:
step 1: defining a simulation account opening verification component prototype to realize a class BaseCheckcomponent, java, as a subclass node BaseCheckcomponent inheriting a parent node IOpenAccountcomponent;
step 2: the method comprises the following steps of realizing the base echeckcomponent java implementation type of an account opening verification component prototype, realizing the IOpenAccountcomponent java implementation type of a public interface of the account opening verification component prototype, and realizing whether account opening verification method verification can be realized, wherein the specific implementation mode is as follows: the existing checking method is called to check whether the information of business license, legal person, manager of financial affairs and the like is consistent with the information of the business bureau and the records of the people bank, and whether the operation information is normal, if the information is consistent with the information of the business bureau and the records of the people bank, and the operation information is abnormal, if the information is not abnormal, the operation is abnormal, if the operation is normal, the account can be opened, and if the operation is abnormal, the false operation is returned, the account cannot be opened.
S3, defining an account opening checking component prototype realization class OnlineCheck component, java, as a subclass node OnlineCheck component inheriting a father class node IOpenAccountcomponent, realizing the account opening checking component prototype public interface class IOpenAccountcomponent, java, and obtaining a checking result of whether an account can be opened or not by realizing checking abstract method verification;
the method comprises the following steps:
step 1: defining a simulation account opening verification component prototype to realize class OnlineCheck component, java, as a subclass node OnlineCeck component inheriting parent class node IOpenAccountcomponent;
step 2: the method comprises the following steps of realizing an account opening verification component prototype implementation type ONLINECHECKcomponent. And calling a third party service to judge whether the abnormal operation condition of the enterprise is abnormal or not, and whether the abnormal operation condition of the enterprise exists in a blacklist or not, if no abnormal operation condition exists and the abnormal operation condition does not exist in the blacklist, the operation is normal, otherwise, the operation is abnormal, the operation is returned normally, the account can be opened, and if the abnormal operation condition exists, the failure is returned, the account cannot be opened.
S4, defining a simulation counter open Account.java as a subclass node CounterOpenAccount inheriting a parent node OpenAccount, inheriting a simulation open scene abstract OpenAccount.java, and accessing an open verification component prototype public interface class IOpenAccount Comment.java into a simulation counter open Account.java to obtain verification component injection, wherein the open scene implementation class also realizes an abstract open method open and simulates opening to obtain an account number;
the method comprises the following steps:
step 1: defining a simulation counter account opening scene realization class CounterOpenAccount.java as a subclass node CounterOpenAccount inheriting a parent node OpenAccount;
step 2: simulating a counter open account implementation class CounterOpenAccount.java to inherit OpenAccount.java, and accessing an open account verification component prototype public interface class IOpenAccount Comment.java into the open account implementation class CounterOpenAccount.java to obtain verification component injection so as to call a verification abstract method verification under a sub-class node IOpenAccount Comment;
and step 3: and simultaneously, simulating a counter account opening scene to realize the counter open account.java and also realizing that an abstract account opening method open simulates an account to open an account, specifically calling a verification abstract method versification of a verification component in the counter open account.java realization abstract account opening method open in the account opening scene, if the return is true, opening the account, executing the simulated counter account opening operation, returning the account with an account opening success, if the return is false, not opening the account, and directly returning the account opening failure.
S5, defining an online account opening scene realization class OnlineOpAccount.java as a subclass node OnlineOpAccount inheriting a parent class node OpenAccount, inheriting an account opening scene abstraction class OpenAccount.java, and accessing an account opening verification component prototype public interface class IOpenAccount Comment.java into an online account opening scene realization class OnlineOpenAccount.java to obtain verification component injection, wherein the online account opening scene realization class also realizes an abstract account opening method open, and an account is obtained by simulating opening;
the method comprises the following steps:
step 1: defining an account opening scene on a simulation line to realize class OnlineOpAccount.java as a subclass node OnlineOpAccount inheriting a parent class node OpenAccount;
step 2: simulating an online opening scene realization class OnlineOpenAccount.java to inherit OpenAccount.java, and accessing an opening verification component prototype public interface class IOpenAccount Comment.java to the online opening scene realization class OnlineOpenAccount.java to obtain verification component injection so as to transfer a verification abstract method verification under a parent class node IOpenAccount Comment;
and step 3: and simultaneously simulating an online account opening scene to realize the online open account.java and also realizing that an abstract account opening method open simulates account opening to obtain an account, wherein the specific operation is to call a verification abstract method verification of a verification component in the method, if the return is true, the account can be opened, the online account opening operation is executed, the account with successful account opening is returned, and if the return is false, the account cannot be opened, and the account opening failure is directly returned.
And S6, creating a simulation account opening calling program OpenAccountTest.
The method comprises the following steps:
step 1: creating a simulation account opening call class OpenAccountTest.java;
step 2: after the simulation account opening calling program openaccount test is built, the simulation call cabinet is opened, an instance of a simulation cabinet opening scene implementation class countopenaccount java is created, and a verification prototype component implementation class is combined as an attribute when the instance is created, namely the freely selected combination simulation cabinet opening scene implementation class countopenaccount java + simulation account opening verification component prototype implementation class basecard component java, or the combination simulation cabinet opening scene implementation class countopenaccount java + simulation account opening verification component prototype implementation class onlinecard component java, an opening scene implementation class onlineAccou. And a corresponding checking method of the checking component prototype is automatically called, and finally, an account number with successful account opening is obtained successfully, as shown in fig. 2 and 3.
The above are merely representative examples of the many specific applications of the present invention, and do not limit the scope of the invention in any way. All the technical solutions formed by the transformation or the equivalent substitution fall within the protection scope of the present invention.
Claims (7)
1. An account opening verification method suitable for multi-scene prototype combination is characterized by comprising the following steps:
s1, defining an abstract type OpenAccount.java of a simulated opening scene as a top-level parent type OpenAccount, and defining an abstract opening method open in the top-level parent type OpenAccount to simulate opening to obtain an account;
defining an account opening verification component prototype public interface type IOpenAccountComponent, java, as a top level parent type IOpenAccountComponent, and defining a verification abstract method verification at the top level parent type IOpenAccountComponent for obtaining a verification result of whether account opening is possible or not;
java, which is used as an attribute and is injected into a parent node OpenAccoun;
s2, defining an account opening verification component prototype realization class BaseCheckcomponent, java, as a subclass node BaseCheckcomponent inheriting a parent node IOpenAccountcomponent, realizing the account opening verification component prototype public interface class IOpenAccountcomponent, java, and obtaining a verification result of whether an account can be opened or not by realizing verification abstract method verification;
s3, defining an account opening checking component prototype realization class OnlineCheck component, java, as a subclass node OnlineCheck component inheriting a father class node IOpenAccountcomponent, realizing the account opening checking component prototype public interface class IOpenAccountcomponent, java, and obtaining a checking result of whether an account can be opened or not by realizing checking abstract method verification;
s4, defining a simulation counter opening scene realization class CounterOpenAccount.java as a subclass node CounterOpenAccount inheriting a father class node OpenAccount, inheriting a simulation opening scene abstract class OpenAccount.java, and accessing an opening verification component prototype public interface class IOpenAccountCommonjava into a simulation counter opening scene realization class CounterOpenAccount.java to obtain verification component injection, meanwhile, simulating a counter opening scene realization class CounterAccount.java also realizes an abstract opening method open, and simulating an opening to obtain an account number;
s5, defining an online open scene realization class ONLineOpenAccount.java of a simulation, as a subclass node ONLineOpenAccount inheriting a parent class node OpenAccount, inheriting an open scene abstraction class OpenAccount.java of the simulation, accessing an open verification component prototype public interface class IOpenAccount Comment.java into an online open scene realization class ONLineOpenAccount.java of the simulation, obtaining check component injection, simultaneously realizing an online open scene realization class ONLineOpenAccount.java of the simulation, further realizing an abstract open method open, and simulating an open to obtain an account number;
and S6, creating a simulation account opening calling program OpenAccountTest.
2. The account opening verification method for multi-scenario prototype combination according to claim 1, wherein the step S1 comprises the following steps:
step 1: creating an abstract type OpenAccount.java of a simulated opening scene, constructing the abstract type OpenAccount.java of the simulated opening scene through an abstrat class keyword, wherein the abstract type OpenAccount.java is a top-level parent type OpenAccount, defining an abstract opening method open in the abstract type OpenAccount.java of the simulated opening scene, wherein the abstract opening method open is an abstract method which is only defined but not realized, the concrete realization needs to be realized under an inherited subclass node, the abstract opening method open can realize the realization of each opening scene, is an abstract method of public operation, namely the simulated opening operation, and simultaneously returns an account number which is successfully opened;
step 2: creating an account opening verification component prototype public interface type IOpenAccountComponent. Constructing an account opening checking component prototype public interface type IOpenAccountComponent.java through an interface keyword, wherein the type is a top-level parent type IOpenAccoumtComponent, and defining a checking abstract method verification by the account opening checking component prototype public interface type IOpenAccountComponent.java, wherein the checking abstract method verification is used for judging whether the account can be opened or not, and is a public operation method of each account opening checking prototype realization type, each realization type needs to realize the checking abstract method verification, and finally whether the account can be opened or not is obtained: the tube is account-opening-possible, the false is account-non-opening-possible;
and step 3: and injecting java, which is an account opening verification component prototype public interface class IOpenAccountcomponent, into the parent class node OpenAccoun as an attribute.
3. The account opening verification method for multi-scenario prototype combination according to claim 2, wherein the step S2 comprises the following steps:
step 1: defining a simulation account opening verification component prototype to realize a class BaseCheckcomponent, java, as a subclass node BaseCheckcomponent inheriting a parent node IOpenAccountcomponent;
step 2: the method comprises the steps that an account opening verification component prototype implementation class is BaseCheckcomponent java, an account opening verification component prototype public interface class IOpenAccountcomponent java is implemented, whether account opening verification method verification can be achieved or not is achieved, the verification abstraction method verification judges whether identity card, business license and legal information are normal or not, if the identity card, the business license and the legal information are returned normally, account opening can be achieved, and if the identity card, the business license and the legal information are abnormal, false account opening cannot be achieved.
4. The account opening verification method for multi-scenario prototype combination according to claim 3, wherein the step S3 comprises the following steps:
step 1: defining a simulation account opening verification component prototype to realize class OnlineCheck component, java, as a subclass node OnlineCeck component inheriting parent class node IOpenAccountcomponent;
step 2: the method comprises the steps of enabling an account opening verification component prototype to realize an open account verification component prototype public interface type IOpenAccountcomponent.
5. The account opening verification method for multi-scenario prototype combination according to claim 4, wherein the step S4 comprises the steps of:
step 1: defining a simulation counter account opening scene realization class CounterOpenAccount.java as a subclass node CounterOpenAccount inheriting a parent node OpenAccount;
step 2: simulating a counter open account implementation class CounterOpenAccount.java to inherit OpenAccount.java, and accessing an open account verification component prototype public interface class IOpenAccount Comment.java into the open account implementation class CounterOpenAccount.java to obtain verification component injection so as to call a verification abstract method verification under a sub-class node IOpenAccount Comment;
and step 3: meanwhile, simulating counter open account.java in the counter open account scene to realize the counter open account.java also realizes that the abstract account opening method open simulates the account to obtain the account, and the concrete operation is calling the verification abstract method versification of the verification component in the abstract account opening method open in the counter open account.java in the account opening scene to realize the verification abstract method versification, if the return is true, the account can be opened, the simulated counter open account operation is executed, the account with successful account opening is returned, if the return is false, the account cannot be opened, and the account opening failure is directly returned.
6. The account opening verification method for multi-scenario prototype combination according to claim 5, wherein the step S5 comprises the following steps:
step 1: defining an account opening scene on a simulation line to realize class OnlineOpAccount.java as a subclass node OnlineOpAccount inheriting a parent class node OpenAccount;
step 2: simulating an online opening scene realization class OnlineOpenAccount.java to inherit OpenAccount.java, and accessing an opening verification component prototype public interface class IOpenAccount Comment.java to the online opening scene realization class OnlineOpenAccount.java to obtain verification component injection so as to transfer a verification abstract method verification under a parent class node IOpenAccount Comment;
and step 3: and simultaneously simulating an online account opening scene to realize the online open account.java and also realizing that an abstract account opening method open simulates account opening to obtain an account, wherein the specific operation is to call a verification abstract method verification of a verification component in the method, if the return is true, the account can be opened, the online account opening operation is executed, the account with successful account opening is returned, and if the return is false, the account cannot be opened, and the account opening failure is directly returned.
7. The account opening verification method for multi-scenario prototype combination according to claim 6, wherein the step S6 comprises the following steps:
step 1: creating a simulation account opening call class OpenAccountTest.java;
step 2: after the simulation account opening calling program openaccount test is built, the simulation call cabinet is opened, an instance of a simulation cabinet opening scene implementation class countopenaccount java is created, and a verification prototype component implementation class is combined as an attribute when the instance is created, namely the freely selected combination simulation cabinet opening scene implementation class countopenaccount java + simulation account opening verification component prototype implementation class basecard component java, or the combination simulation cabinet opening scene implementation class countopenaccount java + simulation account opening verification component prototype implementation class onlinecard component java, an opening scene implementation class onlineAccou. And a corresponding checking method of the checking component prototype is automatically called, and finally, an account number with successful account opening can be obtained successfully.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202110310942.XA CN112905272A (en) | 2021-03-23 | 2021-03-23 | Account-opening checking method suitable for multi-scene prototype combination |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202110310942.XA CN112905272A (en) | 2021-03-23 | 2021-03-23 | Account-opening checking method suitable for multi-scene prototype combination |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN112905272A true CN112905272A (en) | 2021-06-04 |
Family
ID=76106177
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202110310942.XA Withdrawn CN112905272A (en) | 2021-03-23 | 2021-03-23 | Account-opening checking method suitable for multi-scene prototype combination |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN112905272A (en) |
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN113554753A (en) * | 2021-07-30 | 2021-10-26 | 福建天晴数码有限公司 | Method and system for dynamically constructing 3D scene |
-
2021
- 2021-03-23 CN CN202110310942.XA patent/CN112905272A/en not_active Withdrawn
Cited By (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN113554753A (en) * | 2021-07-30 | 2021-10-26 | 福建天晴数码有限公司 | Method and system for dynamically constructing 3D scene |
| CN113554753B (en) * | 2021-07-30 | 2023-11-10 | 福建天晴数码有限公司 | Method and system for dynamically constructing 3D scene |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US7647645B2 (en) | System and method for securing computer system against unauthorized access | |
| Bolignano | Towards the formal verification of electronic commerce protocols | |
| CN104375836B (en) | A kind of method and device of displaying screen locking window | |
| CN109948345A (en) | A kind of method, the system of intelligence contract Hole Detection | |
| KR20060076184A (en) | Method and apparatus for metadata driven business logic processing | |
| CN112150266A (en) | Design principle of intelligent contract prediction machine | |
| CN108111364A (en) | The test method and device of a kind of operation system | |
| CN112905272A (en) | Account-opening checking method suitable for multi-scene prototype combination | |
| CN110908880B (en) | Buried point code injection method, event reporting method and related equipment thereof | |
| CN112329273B (en) | Method and device for improving chip verification efficiency, storage medium and terminal | |
| Ben Jaballah et al. | A grey-box approach for detecting malicious user interactions in web applications | |
| Miller et al. | Using reliability and simulation models in business continuity planning | |
| CN111124883B (en) | Test case library introduction method, system and equipment based on tree form | |
| CN115017512A (en) | Unauthorized access vulnerability testing method and device based on block chain | |
| CN109828929A (en) | The anti-tamper method for testing security of hard disk firmware, system, terminal and storage medium | |
| CN114895879A (en) | Management system design scheme determining method, device, equipment and storage medium | |
| CN112256595B (en) | Heterogeneous system testing method and device and electronic equipment | |
| CN110738384B (en) | Event sequence checking method and system | |
| Shehata et al. | A taxonomy for identifying requirement interactions in software systems | |
| CN111459793A (en) | Full-life-cycle software automatic testing method and device | |
| Martin et al. | Automatic test generation for Java Card applets | |
| CN108449367A (en) | Manage method, apparatus, electronic equipment and the readable medium of user's login security | |
| Boroday et al. | Techniques for Abstracting SDL Specifications | |
| George et al. | Specification for testing | |
| Guo et al. | Verifying Erlang telecommunication systems with the process algebra μ CRL |
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 | ||
| WW01 | Invention patent application withdrawn after publication |
Application publication date: 20210604 |
|
| WW01 | Invention patent application withdrawn after publication |