CN117786651B - Method and device for realizing single sign-on based on java class loader - Google Patents
Method and device for realizing single sign-on based on java class loader Download PDFInfo
- Publication number
- CN117786651B CN117786651B CN202410213966.7A CN202410213966A CN117786651B CN 117786651 B CN117786651 B CN 117786651B CN 202410213966 A CN202410213966 A CN 202410213966A CN 117786651 B CN117786651 B CN 117786651B
- Authority
- CN
- China
- Prior art keywords
- interface
- single sign
- maven
- jar packet
- creating
- 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.)
- Active
Links
- 238000000034 method Methods 0.000 title claims abstract description 42
- 238000004806 packaging method and process Methods 0.000 claims abstract description 18
- 238000012856 packing Methods 0.000 claims description 8
- 238000004590 computer program Methods 0.000 claims description 5
- 235000014510 cooky Nutrition 0.000 claims description 4
- 230000007246 mechanism Effects 0.000 claims description 4
- 230000004044 response Effects 0.000 claims description 2
- 238000012546 transfer Methods 0.000 claims description 2
- 238000012423 maintenance Methods 0.000 abstract description 7
- 238000012795 verification Methods 0.000 abstract description 3
- 238000012360 testing method Methods 0.000 description 8
- 230000006870 function Effects 0.000 description 5
- 230000008676 import Effects 0.000 description 3
- 230000003068 static effect Effects 0.000 description 3
- 230000002452 interceptive effect Effects 0.000 description 2
- 241000289581 Macropus sp. Species 0.000 description 1
- 230000009286 beneficial effect Effects 0.000 description 1
- 230000005540 biological transmission Effects 0.000 description 1
- 230000008859 change Effects 0.000 description 1
- 238000010586 diagram Methods 0.000 description 1
- 230000006872 improvement Effects 0.000 description 1
- 230000010354 integration Effects 0.000 description 1
- 210000001503 joint Anatomy 0.000 description 1
- 239000011148 porous material Substances 0.000 description 1
Landscapes
- Stored Programmes (AREA)
Abstract
The application relates to the technical field of information verification, solves the problem of higher maintenance cost required by single sign-on realization in the prior art, and discloses a method and a device for realizing single sign-on based on java ClassLoader, wherein the method comprises the following steps: defining an interface of single sign-on, generating a second maven project based on an implementation class of the interface, packaging the second jar packet, loading the second jar packet through a class loader, calling the second jar packet to realize single sign-on, and enabling different authentication modes to be abutted on the basis of guaranteeing the universality of basic services, wherein the application range is wider.
Description
Technical Field
The application relates to the technical field of information verification, in particular to a method and a device for realizing single sign-on based on java class loader.
Background
Single sign On (SINGLE SIGN On, SSO for short) is a solution for enterprise business integration, which is defined as that among multiple application systems, a user only needs to log in once to access all mutually trusted application systems. The method reduces the time consumption caused by login, the current main stream modes for realizing single sign-on include oauth2, ldap, cas, enterprise WeChat and the like, and the blank is reserved according to the requirement of the frame for logging in advance, so that the blank is filled in during use to realize single sign-on so as to achieve the purpose of universality.
In the prior art, a user changes the login mode based on the user requirement, so that the general logic realized based on the standard framework protocol cannot be used, the change is required according to the actual situation of the user, and the maintenance cost is definitely increased.
Disclosure of Invention
The application aims to solve the problem of high maintenance cost required by single sign-on realization in the prior art, and provides a method and a device for realizing single sign-on based on java ClassLoader.
In a first aspect, a method for implementing single sign-on based on java ClassLoader is provided, including:
defining an interface of single sign-on, wherein the interface is used for acquiring user information and realizing single sign-on;
generating a second maven project based on the implementation class of the interface and packaging the second maven project into a second jar packet;
loading the second jar packet through a class loader;
and calling the second jar packet to realize single sign-on.
Further, defining an interface for single sign-on includes:
Creating a first maven project, wherein the first maven project is used for referencing a defined single sign-on interface;
creating a single sign-on interface in the first maven project, and setting a return value and a parameter entry;
and calling a maven packing command to pack the first maven project into a first jar packet and pushing the first jar packet to a git warehouse.
Further, the return value and the entry are set in the form of key-value, and Object is used as a carrier of the transfer value, wherein key represents the user attribute name, and value represents the user attribute value.
Optionally, generating a second maven project based on the implementation class of the interface and encapsulating the second maven project into a second jar packet includes:
creating a second maven project;
introducing a first jar packet encapsulated in a git warehouse into a configuration file of a second maven project;
creating an implementation class and adding logic of implementation in the implementation class, wherein the implementation class is used for implementing an introduced interface;
creating a first folder and a second folder, and creating a blank file in the second folder, wherein the file name of the blank file is a value corresponding to a first jar packet, and the blank file is internally recorded with a full path of an implementation class of an interface of single sign-on;
And after the personalized code is completed in the implementation class, calling a maven packing command to pack the second maven engineering into a second jar packet.
Optionally, generating a second maven project based on the implementation class of the interface and encapsulating the second maven project into a second jar packet includes:
creating a second maven project;
Creating an interface identical to the single sign-on interface according to the path of the single sign-on interface;
Creating an implementation class and adding logic of implementation in the implementation class, wherein the implementation class is used for implementing a newly built interface;
creating a first folder and a second folder, and creating a blank file in the second folder, wherein the file name of the blank file is a value corresponding to a first jar packet, and the blank file is internally recorded with a full path of an implementation class of an interface of single sign-on;
And after the personalized code is completed in the implementation class, calling a maven packing command to pack the second maven engineering into a second jar packet.
Further, loading the second jar packet by a class loader includes:
uploading the second jar packet to a service and generating an uploading path;
the class loader is customized to break the Java parent delegation mechanism;
and loading the second jar packet through the uploading path by using a custom class loader.
Further, invoking the second jar packet to implement single sign-on includes:
calling an interface defining single sign-on to acquire user information;
comparing the user information with users in service;
Updating existing user information in the service in response to the presence of the user;
And if the user does not exist, adding the user into the service, creating a token according to the user information, filling the token into a cookie, returning to the front end, and calling other interfaces of the service to check the login state after the front end acquires the token.
In a second aspect, a device for implementing single sign-on based on java ClassLoader is provided, including:
The interface definition module is used for defining an interface of single sign-on, wherein the interface is used for acquiring user information and realizing single sign-on;
The packaging module is used for generating a second maven project based on the implementation class of the interface and packaging the second maven project into a second jar packet;
The loading module is used for loading the second jar packet through a class loader;
and the calling module is used for calling the second jar packet to realize single sign-on.
In a third aspect, there is provided a computer program product containing instructions which, when run on a computer, cause the computer to perform the method of the first aspect described above.
In a fourth aspect, a computer readable storage medium is provided, the computer readable medium storing program code for execution by a device, the program code comprising steps for performing the method as in any one of the implementations of the first aspect.
The application has the following beneficial effects: the application can enable a user to realize logic in the jar package by himself based on the related confidentiality principle according to the predefined specification, and secondly, the application can butt joint authentication modes of different modes on the basis of guaranteeing the universality of basic service, has wider application range, can replace the jar package on the basis of not restarting a server along with use and transmission, avoids the influence on the existing service, and effectively reduces the maintenance cost.
Drawings
The accompanying drawings, which are included to provide a further understanding of the application and are incorporated in and constitute a part of this specification, illustrate embodiments of the application and together with the description serve to explain the application.
In order to more clearly illustrate the technical solutions of the embodiments of the present application, the drawings required for the description of the embodiments will be briefly described below, and it is apparent that the drawings in the following description are only some embodiments of the present application, and other drawings may be obtained according to these drawings without inventive effort for a person skilled in the art.
FIG. 1 is a flow chart of a method for implementing single sign-on based on java ClassLoader according to embodiment 1 of the present application;
fig. 2 is a block diagram of a device for implementing single sign-on based on java ClassLoader according to embodiment 2 of the present application.
Reference numerals:
100. An interface definition module; 200. packaging the module; 300. loading a module; 400. and calling a module.
Detailed Description
The following description of the embodiments of the present invention will be made clearly and completely with reference to the accompanying drawings, in which it is apparent that the embodiments described are only some embodiments of the present invention, but not all embodiments. All other embodiments, which can be made by those skilled in the art based on the embodiments of the invention without making any inventive effort, are intended to be within the scope of the invention.
Example 1
The method for realizing single sign-on based on java class loader according to the embodiment 1 of the application comprises the following steps: defining an interface of single sign-on, wherein the interface is used for acquiring user information and realizing single sign-on; generating a second maven project based on the implementation class of the interface and packaging the second maven project into a second jar packet; loading the second jar packet through a class loader; the second jar package is called to realize single sign-on, the method is realized by carrying out interface (i.e. interface) reserved in advance, the second jar package is packaged into the second jar package, the second jar package is uploaded to java web program service needing to use single sign-on, the service loads the second jar package into jvm (i.e. virtual machine) of the current service through a class loader, when the single sign-on method is used, the method in the packaged second jar package is called through the interface (i.e. interface), logic in the second jar package is executed under the condition of entering the interface, and interactive authentication is carried out with a user system, so that the single sign-on method can reduce maintenance cost compared with the single sign-on mode in the prior art, such as oauth2, ldap, cas, enterprise WeChat and the like.
Specifically, fig. 1 shows a flowchart of a method for implementing single sign-on based on java ClassLoader in application embodiment 1, including:
s100, defining an interface of single sign-on, wherein the interface is used for acquiring user information and realizing single sign-on;
Specifically, defining an interface for single sign-on includes:
s101, creating a first maven project, wherein the first maven project is used for referring to a defined single sign-on interface;
S102, creating a single sign-on interface (i.e. interface) in the first maven project created in the step S101, setting a return value and an entry, taking account of different users that the names of the attributes of the users are different, so that the return value and the entry are set in a key-value form, wherein the key represents the name of the attribute of the user, the value represents the value of the attribute of the user, and the key is only a key for finding a value, so that the specific type can be determined to be a String type, and the value of the attribute of the user can be of various types, so that an Object (i.e. a parent class Object. Class of all types in java application) is used as a carrier for transmitting the value, so that the entry uses Map < String, object > (i.e. a data structure of key-value in java is a type that can be adapted to various data structures), and the return value uses Map < String, object >, and a pseudo code is as follows:
1.package com.dtstack.uic.loader;
2.import java.util.Map;
3. interface// defined, IClient is the interface name
4.public interface IClient {
5. Method for obtaining single sign-on user information by// definition, realizing business logic is to realize IClient interface and rewrite getUser () method
6. Map<String,Object> getUser(Map<String,Object> param);
7.}。
S103, calling a maven packaging command to package the first maven project created in the step S101 into a first jar package and pushing the first jar package to a git warehouse so as to facilitate the reference in a user' S pore.
S200, generating a second maven project based on the implementation class of the interface and packaging the second maven project into a second jar packet;
In one possible implementation, generating a second maven project based on the implementation class of the interface and encapsulating into a second jar packet includes:
S2101, creating a second maven project (the maven project is a version management mode in java projects);
S2102, introducing and packaging the first jar packet pushed to the git warehouse in the step S103 into a configuration file (namely a pon.xml file) of a second maven project;
S2103, creating an implementation class [ class format (class format is file format compiled by java code) ] to implement the interface introduced in the step S2102, and adding logic of implementation in the implementation class, wherein the pseudo code is as follows:
1. Interface defined in jar packet pushed to maven repository in step S103 of/(and introduction)
2.import com.dtstack.uic.loader.IClient;
3. Interface IClient for implementing creation of step S102 by using/(and/or creating java implementation class
4.public class LoginTest implements IClient {
5. Method getUser for obtaining user information in creating interface for step S102 is rewritten
6. public Map<String, Object> getUser(Map<String, Object> param) {
7. // --------------------------------------------
8. Code implementation of// user's own acquisition of user information
9. ...
10. // --------------------------------------------
11. Creation of a return object stores acquired user information in the return object
12. Map<String, Object> ret = new HashMap<String, Object>();
13. ret.put("username", "xxxx");
14. return ret;
15.}。
S2104, under the resource directory (i.e. java engineering directory structure, storing information such as static resources, configuration files, etc.) (if a springboot framework (a framework of java engineering) is used, and using a project generation policy provided by a spring official, the directory is automatically created, otherwise, the directory needs to be created by itself and is designated as a resource directory), a first folder and a second folder are created, and it should be noted that the first folder name must be META-INF, otherwise, the spring framework cannot identify, the second folder is a service folder (i.e. a function point of springboot framework, a fixed format is used for configuring an externally exposed interface), and a blank file is created in the second folder, where the file name of the blank file is a value corresponding to the first jar packet in step S, and after the blank file is created successfully, the full path of the interface of the single sign-on created in step S101 is created in the blank file, for example: the value corresponding to the first jar packet (i.e. package) is com.dttstack.ui c.loader, the interface name is IClient, the file name of the created blank file is com.dttstack.ui c.loader.i.ent (relative path of interface), the implementation-like full path of the interface in step S101 is com.dttstack.ui c.test.logic test, and the file content of the blank file is com.dttstack.ui.test.logic test (i.e. relative path of interface implementation, the spring function of spring utilized).
S2105, after the personalized code (namely, the code similar to the code in the step S2103) is completed in the implementation class, calling a maven packaging command to package the second maven project into a second jar package.
In another possible implementation, generating a second maven project based on the implementation class of the interface and encapsulating into a second jar packet includes:
S2201, creating a second maven project (the maven project is a version management mode in java projects);
s2202, creating an interface which is the same as the single sign-on interface according to the path of the single sign-on interface;
S2203, creating an implementation class [ class format (class format is file format compiled by java code) ] to implement the interface newly created in the step S2202, and adding logic of implementation in the implementation class, wherein the pseudo code is as follows:
1. Interface defined in jar packet pushed to maven repository in step S103 of/(and introduction)
2.import com.dtstack.uic.loader.IClient;
3. Interface IClient for implementing creation of step S102 by using/(and/or creating java implementation class
4.public class LoginTest implements IClient {
5. Method getUser for obtaining user information in creating interface for step S102 is rewritten
6. public Map<String, Object> getUser(Map<String, Object> param) {
7. // --------------------------------------------
8. Code implementation of// user's own acquisition of user information
9. ...
10. // --------------------------------------------
11. Creation of a return object stores acquired user information in the return object
12. Map<String, Object> ret = new HashMap<String, Object>();
13. ret.put("username", "xxxx");
14. return ret;
15.}。
S2204, under the resource directory (i.e. java engineering directory structure, storing information such as static resources, configuration files, etc.) (if a springboot framework (a framework of java engineering) is used, and using a project generation policy provided by a spring official, the directory is automatically created, otherwise, the directory needs to be created by itself and is designated as a resource directory), create a first folder and a second folder, note that the first folder name must be META-INF, otherwise, the spring framework cannot identify, the second folder is a service folder (i.e. a function point of springboot framework, a fixed format is used for configuring an externally exposed interface), and create a blank file in the second folder, where the file name of the blank file is a value corresponding to the first jar packet in step S2202, and after the blank file is created successfully, the full path of the interface of the single sign-on created in step S101 is created in the blank file, for example: the value corresponding to the first jar packet (i.e. package) is com.dttstack.ui c.loader, the interface name is IClient, the file name of the created blank file is com.dttstack.ui c.loader.i.ent (relative path of interface), the implementation-like full path of the interface in step S101 is com.dttstack.ui c.test.logic test, and the file content of the blank file is com.dttstack.ui.test.logic test (i.e. relative path of interface implementation, the spring function of spring utilized).
S2205, after the personalized code (i.e. the similar code in the step S2203) is completed in the implementation class, calling a maven packaging command to package the second maven project into a second jar package.
S300, loading the second jar packet through a class loader;
specifically, loading the second jar packet by the class loader includes:
S301, uploading the second jar packet generated in the step S2105 or the step S2205 to a service and generating an uploading path;
S302, in order to break a java parent delegation mechanism, a custom class loader is needed, loadClass (String name) is rewritten (a method name of the java class loading mechanism needs to be rewritten, a fixed name), and a pseudo code is as follows:
1. Method for loading jar into service jvm by using/(class loader)
2.@Override
3.protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
3. try {
4. Direct loading by class name directly using parent class loader if not already loaded and not already in the local library
5. return = Class.forName(name, false, parent);
6. If not found, cast out the exception of the not found class
7. throw new ClassNotFoundException(name);
8.}。
S303, loading a second jar packet through the uploading path by using a custom class loader, wherein the pseudo code is as follows:
1. The second jar file uploaded in step S301 is found by file class
2.File file = new File(path);
3. Determining file path by file
4.URL url = file.toURI().toURL();
5. Load the second jar file uploaded in step S301 using the custom class loader
6.ClassLoader classLoader = new DtUicClassLoader(new URL[]{url}, Thread.currentThread().getContextClassLoader());
7.ServiceLoader<IClient> iClients = ServiceLoader.load(IClient.class, classLoader);
8. The interface of the definition is obtained, which is convenient for the subsequent method getUser for obtaining the user information through the interface
9.IClient client = iClients.iterator().next()。
S400, calling the second jar packet to realize single sign-on.
Specifically, invoking the second jar packet to implement single sign-on includes:
s401, in the standard program, the realization logic in the second jar packet is not concerned, and the return value (namely the user information) is obtained only by calling the interface, and the pseudo code is as follows:
1.Map<String, Object> userInfo = client.getUser(convertMap);
2.String username = String.valueOf(userInfo.get("username"));
S402, after the user information is acquired, comparing the user information with the existing users in the service, if the users exist, updating the existing information used in the service, and if the users do not exist, adding a new user in the service. After the user information falls into the library, a token (token is a proper noun, which is generally used to express a character string encrypted by using a certain encryption rule) is created according to the user information acquired in step S401, and is inserted into a cookie (a cookie is a proper noun, and is used for storing data in a request header in a network request) and returned to the front end, and after the front end receives the token, other interfaces of the service are called, and since the token already exists and is not expired, the service considers that the user has logged in and passes verification when verifying the login state.
It is noted that in the kangaroo cloud stack service component, a single sign-on function of complex situations is realized by uploading a second jar package customized on a page, different authentication services can be better connected, in this embodiment, by implementing a single sign-on mode of interfaces (i.e. interfaces) reserved in advance and packaging the second jar package into the second jar package, the single sign-on method of the application can reduce maintenance cost compared with a single sign-on mode of java web program service needing to use single sign-on, the service loads the second jar package into jvm (i.e. a virtual machine) of the current service through a class loader, when in use, a method in the packaged second jar package is called through the interfaces (i.e. interfaces), the second jar package takes the access as a condition, logic in the second jar package is executed, and the user system performs interactive authentication with the second jar package, and compared with the single sign-on mode of the prior art, such as oauth2, ldcaps, enterprise WeChat, and the like, the single sign-on method of the application can reduce maintenance cost, in addition, based on the related security, the user can realize the same general purpose on the basis of the service package by invoking the interface, the method of the packaged second jar package according to the interface, the security is realized by the interface, the method of the user has the advantages of having different security requirements on the general authentication mode and can not affect the prior service package on the basis.
Example 2
As shown in fig. 2, a device for implementing single sign-on based on java ClassLoader according to embodiment 2 of the present application includes:
An interface definition module 100, configured to define an interface for single sign-on, where the interface is configured to obtain user information and implement single sign-on;
the packaging module 200 is configured to generate a second maven project based on the implementation class of the interface and package the second maven project into a second jar packet;
a loading module 300, configured to load the second jar packet through a class loader;
and the calling module 400 is used for calling the second jar packet to realize single sign-on.
It should be noted that, in the embodiment of the present invention, other specific embodiments of the device for implementing single sign-on based on java class loader may refer to the specific embodiments of the method for implementing single sign-on based on java class loader, and in order to avoid redundancy, details are not repeated here.
Example 3
A computer program product according to embodiment 3 of the present application is a computer program product for storing a computer program, which when run on a computer implements the method according to any one of the implementations of embodiment 1 of the present application.
Example 4
A computer-readable storage medium according to embodiment 4 of the present application stores program code for execution by a device, the program code including steps for performing the method as in any one of the implementations of embodiment 1 of the present application;
wherein the computer readable storage medium may be a Read Only Memory (ROM), a static storage device, a dynamic storage device, or a random access memory (random access memory, RAM); the computer readable storage medium may store a program code which, when executed by a processor, is adapted to perform the steps of the method as in any one of the implementations of embodiment 1 of the application.
The above is only a preferred embodiment of the present application; the scope of the application is not limited in this respect. Any person skilled in the art, within the technical scope of the present disclosure, may apply to the present application, and the technical solution and the improvement thereof are all covered by the protection scope of the present application.
Claims (8)
1. A method for realizing single sign-on based on java class loader is characterized by comprising the following steps:
defining an interface of single sign-on, wherein the interface is used for acquiring user information and realizing single sign-on;
generating a second maven project based on the implementation class of the interface and packaging the second maven project into a second jar packet;
loading the second jar packet through a class loader;
invoking the second jar packet to realize single sign-on;
wherein, define the interface of single sign on, include:
Creating a first maven project, wherein the first maven project is used for referencing a defined single sign-on interface;
creating a single sign-on interface in the first maven project, and setting a return value and a parameter entry;
Calling a maven packing command to pack the first maven project into a first jar packet and pushing the first jar packet to a git warehouse;
generating a second maven project based on the implementation class of the interface and packaging the second maven project into a second jar packet, wherein the method comprises the following steps:
creating a second maven project;
introducing a first jar packet encapsulated in a git warehouse into a configuration file of a second maven project;
creating an implementation class and adding logic of implementation in the implementation class, wherein the implementation class is used for implementing an introduced interface;
creating a first folder and a second folder, and creating a blank file in the second folder, wherein the file name of the blank file is a value corresponding to a first jar packet, and the blank file is internally recorded with a full path of an implementation class of an interface of single sign-on;
And after the personalized code is completed in the implementation class, calling a maven packing command to pack the second maven engineering into a second jar packet.
2. The method for implementing single sign-on based on java ClassLoader according to claim 1, wherein the return value and the entry are set in the form of key-value, and Object is used as a carrier of the transfer value, wherein key represents a user attribute name and value represents a user attribute value.
3. The method for implementing single sign-on based on java ClassLoader according to claim 1, wherein generating a second maven project based on the implementation class of the interface and encapsulating the second maven project into a second jar packet further comprises:
creating a second maven project;
Creating an interface identical to the single sign-on interface according to the path of the single sign-on interface;
Creating an implementation class and adding logic of implementation in the implementation class, wherein the implementation class is used for implementing a newly built interface;
creating a first folder and a second folder, and creating a blank file in the second folder, wherein the file name of the blank file is a value corresponding to a first jar packet, and the blank file is internally recorded with a full path of an implementation class of an interface of single sign-on;
And after the personalized code is completed in the implementation class, calling a maven packing command to pack the second maven engineering into a second jar packet.
4. A method for implementing single sign-on based on java ClassLoader according to claim 1 or 3, wherein loading the second jar packet by a class loader comprises:
uploading the second jar packet to a service and generating an uploading path;
the class loader is customized to break the Java parent delegation mechanism;
and loading the second jar packet through the uploading path by using a custom class loader.
5. The method for implementing single sign-on based on java ClassLoader according to claim 4, wherein invoking the second jar packet to implement single sign-on comprises:
calling an interface defining single sign-on to acquire user information;
comparing the user information with users in service;
Updating existing user information in the service in response to the presence of the user;
And if the user does not exist, adding the user into the service, creating a token according to the user information, filling the token into a cookie, returning to the front end, and calling other interfaces of the service to check the login state after the front end acquires the token.
6. The device for realizing single sign-on based on java ClassLoader is characterized by comprising:
The interface definition module is used for defining an interface of single sign-on, wherein the interface is used for acquiring user information and realizing single sign-on;
The packaging module is used for generating a second maven project based on the implementation class of the interface and packaging the second maven project into a second jar packet;
The loading module is used for loading the second jar packet through a class loader;
The calling module is used for calling the second jar packet to realize single sign-on;
wherein, define the interface of single sign on, include:
Creating a first maven project, wherein the first maven project is used for referencing a defined single sign-on interface;
creating a single sign-on interface in the first maven project, and setting a return value and a parameter entry;
Calling a maven packing command to pack the first maven project into a first jar packet and pushing the first jar packet to a git warehouse;
generating a second maven project based on the implementation class of the interface and packaging the second maven project into a second jar packet, wherein the method comprises the following steps:
creating a second maven project;
introducing a first jar packet encapsulated in a git warehouse into a configuration file of a second maven project;
creating an implementation class and adding logic of implementation in the implementation class, wherein the implementation class is used for implementing an introduced interface;
creating a first folder and a second folder, and creating a blank file in the second folder, wherein the file name of the blank file is a value corresponding to a first jar packet, and the blank file is internally recorded with a full path of an implementation class of an interface of single sign-on;
And after the personalized code is completed in the implementation class, calling a maven packing command to pack the second maven engineering into a second jar packet.
7. A computer program product having stored therein computer instructions which, when executed by a processor, implement the method of any of claims 1-5.
8. A computer readable storage medium storing program code for execution by a device, the program code comprising steps for performing the method of any one of claims 1-5.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202410213966.7A CN117786651B (en) | 2024-02-27 | 2024-02-27 | Method and device for realizing single sign-on based on java class loader |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202410213966.7A CN117786651B (en) | 2024-02-27 | 2024-02-27 | Method and device for realizing single sign-on based on java class loader |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN117786651A CN117786651A (en) | 2024-03-29 |
| CN117786651B true CN117786651B (en) | 2024-06-07 |
Family
ID=90381920
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202410213966.7A Active CN117786651B (en) | 2024-02-27 | 2024-02-27 | Method and device for realizing single sign-on based on java class loader |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN117786651B (en) |
Citations (11)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN101645021A (en) * | 2009-06-18 | 2010-02-10 | 广东金宇恒科技有限公司 | Integrating method for multisystem single-spot logging under Java application server |
| CN104881343A (en) * | 2014-02-27 | 2015-09-02 | 北京京东尚科信息技术有限公司 | Testing method and testing system |
| CN106603556A (en) * | 2016-12-29 | 2017-04-26 | 迈普通信技术股份有限公司 | Single sign-on method, device and system |
| CN109492375A (en) * | 2018-11-01 | 2019-03-19 | 北京京航计算通讯研究所 | SAP ERP single-node login system based on JAVA middleware intergration model |
| CN110083436A (en) * | 2019-05-14 | 2019-08-02 | 上海理想信息产业（集团）有限公司 | A kind of business datum real-time monitoring system and method based on Java bytecode enhancing technology |
| CN111182074A (en) * | 2019-12-31 | 2020-05-19 | 南京创维信息技术研究院有限公司 | Intelligent device terminal with edge computing capability and computer-readable storage medium |
| CN114238895A (en) * | 2021-12-23 | 2022-03-25 | 北京天融信网络安全技术有限公司 | Single sign-on proxy method and device, electronic equipment and storage medium |
| CN114880169A (en) * | 2022-06-09 | 2022-08-09 | 杭州比智科技有限公司 | Method and system for realizing hot update dynamic adaptation based on JavaSPI |
| CN115499162A (en) * | 2022-08-16 | 2022-12-20 | 武汉众邦银行股份有限公司 | Single sign-on method for solving problem of reconstruction-inconvenient application service |
| CN116886428A (en) * | 2023-08-17 | 2023-10-13 | 招银云创信息技术有限公司 | Service authentication method, system and related equipment |
| CN117234529A (en) * | 2023-09-19 | 2023-12-15 | 长春嘉诚信息技术股份有限公司 | Method for generating API (application program interface) based on DSL (digital subscriber line) analytic resources |
Family Cites Families (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| JP4779444B2 (en) * | 2005-05-26 | 2011-09-28 | 株式会社日立製作所 | Single sign-on implementation method |
| US11048527B2 (en) * | 2017-09-21 | 2021-06-29 | Citrix Systems, Inc. | Accessing conflicting frameworks and classes |
-
2024
- 2024-02-27 CN CN202410213966.7A patent/CN117786651B/en active Active
Patent Citations (11)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN101645021A (en) * | 2009-06-18 | 2010-02-10 | 广东金宇恒科技有限公司 | Integrating method for multisystem single-spot logging under Java application server |
| CN104881343A (en) * | 2014-02-27 | 2015-09-02 | 北京京东尚科信息技术有限公司 | Testing method and testing system |
| CN106603556A (en) * | 2016-12-29 | 2017-04-26 | 迈普通信技术股份有限公司 | Single sign-on method, device and system |
| CN109492375A (en) * | 2018-11-01 | 2019-03-19 | 北京京航计算通讯研究所 | SAP ERP single-node login system based on JAVA middleware intergration model |
| CN110083436A (en) * | 2019-05-14 | 2019-08-02 | 上海理想信息产业（集团）有限公司 | A kind of business datum real-time monitoring system and method based on Java bytecode enhancing technology |
| CN111182074A (en) * | 2019-12-31 | 2020-05-19 | 南京创维信息技术研究院有限公司 | Intelligent device terminal with edge computing capability and computer-readable storage medium |
| CN114238895A (en) * | 2021-12-23 | 2022-03-25 | 北京天融信网络安全技术有限公司 | Single sign-on proxy method and device, electronic equipment and storage medium |
| CN114880169A (en) * | 2022-06-09 | 2022-08-09 | 杭州比智科技有限公司 | Method and system for realizing hot update dynamic adaptation based on JavaSPI |
| CN115499162A (en) * | 2022-08-16 | 2022-12-20 | 武汉众邦银行股份有限公司 | Single sign-on method for solving problem of reconstruction-inconvenient application service |
| CN116886428A (en) * | 2023-08-17 | 2023-10-13 | 招银云创信息技术有限公司 | Service authentication method, system and related equipment |
| CN117234529A (en) * | 2023-09-19 | 2023-12-15 | 长春嘉诚信息技术股份有限公司 | Method for generating API (application program interface) based on DSL (digital subscriber line) analytic resources |
Non-Patent Citations (3)
| Title |
|---|
| Asya I Ivanova等.Single sign-on taxonomy.2017 IEEE 21st International Conference on Computer Supported Cooperative Work in Design (CSCWD).2017,全文. * |
| 王超等.面向大型机构的统一身份管理方法.国防科技大学学报.2014,第第36卷卷(第第03期期),全文. * |
| 赵向梅 ; .基于Java EE的单点登录技术研究与实现.电子设计工程.2015,第23卷(第10期),全文. * |
Also Published As
| Publication number | Publication date |
|---|---|
| CN117786651A (en) | 2024-03-29 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| Coward et al. | Java servlet specification version 2.3 | |
| CN110750747B (en) | Page jump method, device, equipment and readable storage medium | |
| US8082508B2 (en) | Method and system for obtaining and modifying portlets via an application programming interface | |
| US8060932B2 (en) | Modular enterprise authorization solution | |
| EP2307977B1 (en) | System and method for dynamic partitioning of applications in client-server environments | |
| US5497463A (en) | Ally mechanism for interconnecting non-distributed computing environment (DCE) and DCE systems to operate in a network system | |
| US6691113B1 (en) | Persistent data storage for client computer software programs | |
| US8051143B2 (en) | Sharing sessions between web-based applications | |
| US9455876B1 (en) | Method and standard for integrating applications into a cloud | |
| US20040216147A1 (en) | Component based application middleware framework | |
| EP3364631A1 (en) | Dynamic orchestration of microservices | |
| US7197530B2 (en) | System and method for pluggable URL pattern matching for servlets and application servers | |
| US8250226B2 (en) | Generating one or more clients for generating one or more synthetic transactions with one or more web service operations | |
| US8949867B2 (en) | System and method for providing transaction monitor integration with service component architecture (SCA) runtime | |
| US20100100894A1 (en) | System and Method for Asynchronously Invoking Dynamic Proxy Interface Using Supplemental Interfaces | |
| CN112350978A (en) | Service processing method, system, device and storage medium | |
| Lamparelli et al. | Smart contract locator (scl) and smart contract description language (scdl) | |
| EP2216962B1 (en) | A method for deploying and managing the sip servlet application and the osgi service platform thereof | |
| CN117786651B (en) | Method and device for realizing single sign-on based on java class loader | |
| Popovici et al. | Spontaneous container services | |
| CN109815202B (en) | Log editing method and related device | |
| US20080144651A1 (en) | Method, system and program product for adapting to protocol changes | |
| US8554878B2 (en) | Method and a system for incorporating reliable messaging in web services client applications via an API | |
| CN114756309B (en) | Service calling method, framework, device and storage medium | |
| US8918451B2 (en) | System and method for providing service component architecture (SCA) data transformation |
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 |