CN115712456A - Dependence management and tool integration method based on springboot - Google Patents
Dependence management and tool integration method based on springboot Download PDFInfo
- Publication number
- CN115712456A CN115712456A CN202211603752.8A CN202211603752A CN115712456A CN 115712456 A CN115712456 A CN 115712456A CN 202211603752 A CN202211603752 A CN 202211603752A CN 115712456 A CN115712456 A CN 115712456A
- Authority
- CN
- China
- Prior art keywords
- class
- annotation
- configuration
- javabean
- dependency
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
Images
Landscapes
- Stored Programmes (AREA)
Abstract
The invention relates to the technical field of computer software, and provides a package dependence management and tool integration method based on Spring Boot. The invention realizes a package dependency management and tool integration method based on Spring Boot in a self-defined starter mode of Spring Boot. The method aims to solve the problems of long shelf package import time, complex code writing, difficult code understanding, multiple repetition methods and the like in the above situation, so that the workload of programmers is reduced, and more time is spent on business logic.
Description
Technical Field
The invention relates to the technical field of computer software, and provides a package dependency management and tool integration method based on Spring Boot.
Background
In the process of Java backend development, the organization name of a project package is not known, the full name of the project package is not known, and the used version of the project package is not known to be stable, so that the time spent on importing a shelf package is increased, useless work is sometimes done, the imported package is not necessarily available, the project package can be used in other projects, and the project package can be copied and pasted quickly, but if the projects are more, the work is also time-consuming. In addition, in the process of writing business codes, sometimes some data need to be processed in a series of processes to obtain correct results, developers are required to write the data processing process, the JDK is used for operations such as time, date, multithreading and the like, and the processing processes are all particularly similar, and different results are caused due to different input parameters. For this situation, some programmers may write codes directly for use, but the complexity of the business layer codes is increased, while other sophisticated programmers may integrate methods, design interfaces, and make the methods highly available, but this may cause other developers to not understand the codes, so that the usability of the methods is reduced.
Disclosure of Invention
Aiming at the two problems, the invention realizes a package dependency management and tool integration method based on the Spring Boot in a self-defined starter mode of the Spring Boot. The method aims to solve the problems of long shelf package import time, complex code writing, difficult code understanding, multiple repeated methods and the like in the above situation, thereby reducing the workload of programmers and spending more time on business logic. In order to realize the purpose, the technical scheme of the invention is as follows:
the invention relates to a packet dependence management and tool integration method based on Spring Boot, which mainly comprises two contents, namely a user-defined starter packet, a development process of packet dependence management and tool integration is described, and a newly-built starter packet is used, wherein the process describes a use step and a research and development effect. Firstly, a Spring Boot project is newly built, a dependency package required in the actual development process is introduced into a pot file, appropriate modification and addition can be made according to the requirement, and the specific description is that in the first S3 step, the version arbitration of the package is managed through dependency management tags. Tool integration is mainly the integration of methods for a series of common methods which may be encountered in the process of a project, such as time, date, character strings, methods which may be applied to the project itself during the development of the project, and the like. The method integration of the time class is realized by adding a new JavaBean, then the parameters are changed by modifying the attributes of the JavaBean, and corresponding data processing methods are designed in the JavaBean, such as conversion between time and character strings, addition and subtraction of the year and month and the date, realization of thread safety and the like, can be used after adding a configuration class, and the user-defined package is deployed on a server for use after the package is constructed. From the method, the shelf packet is considered in aspects of high availability, expansibility, consistency and the like.
The first content of the invention, the steps of customizing the starter packet are as follows:
s1: a spring boot project is newly built, and is named dependent-startup
S2: spring-boot-autoconfigure dependencies are introduced, which have to be introduced for constructing the starter project.
S3: and adding dependencies as required, such as adding dependencies of Web, mySQL, redis, druid, slf4j, myBatis and the like to the front-end and back-end separation items, wherein when adding the dependencies, such as adding Web dependencies, only the organization name and the package name need to be added. Deletion of a dependency only requires deletion of the corresponding dependency
S4: designing a JavaBean of a new method and making related configuration
S5: realize the hot plug function
S6: packaging items
The second aspect of the invention, using the starter package, is an instruction for the use of the invention:
s1: importing the newly-created dependent-starter project
S2: configuring properties required by JavaBean in Properties or YAML
S3: creating a program Main class, using @ Enabledput, determining whether to use a shelf Package
S4: injecting a class instance in the service development type, and completing calling of the operation class instance according to the requirement
The method for dependency management and tool integration based on Spring Boot comprises the following steps:
s1: newly building a spring boot project, naming dependencyluteil-starter in a spring-boot-start-xxx naming mode;
s2: introducing spring-boot-autoconfiguration dependencies, and calling the annotations @ Configuration properties, @ Configuration and @ Configuration in the following custom method;
s3: adding dependencies as required, namely firstly using a dependency label, then labeling the dependency label, finally adding dependency dependencies in the dependency label, after adding the dependencies, adding a properties label at the same level as the dependency label, adding version control of each dependency in the label, and taking a value of a version control value in the dependency in a $ { } manner;
s4: creating a JavaBean, customizing the property and method therein, wherein the property is used through properties or YAML files,
after the JavaBean is written, needing to add @ EnableconfigurationProperties to the class, transmitting the class object of the current class, then adding @ configurationProperties annotation, wherein the parameter of the annotation needs to transmit a prefix when in use;
after the JavaBean is configured, a Configuration class needs to be written, an instance object of the JavaBean is newly built, the object is injected into a container, a @ Configuration annotation needs to be added to the Configuration class and can be identified by the container, then the @ Bean annotation is added in the method, and the @ Conditional annotation is added according to the needs;
s5: adding an intermediate mark class, judging whether the shelf packet is injected into a container or not by judging the existence of the class, then adding an annotation class to realize that an annotation is named as @ Enabledput, adding @ Target to the annotation class and explaining the use area of the annotation class, wherein @ Retention is used for defining how long the annotation annotated by the annotation is reserved, and @ Import introduces a class decorated by @ Configuration, and the class is judged on the Configuration class of JavaBean according to the introduced instance mark class;
s6: creating a META-INF directory under the resources resource directory, creating a spring
Spring frame, boot, autoconfiguration = \ +, how many javabeans are configured, and all configuration needs to be completed, otherwise, the new project cannot discover the type;
s7: the item packing is to pack by using maven, and comprises two steps, firstly, a clear command is used for clearing a compiled file of the item, then an install command is used for packing the item into a shelf package, the item packing step is finished, and the item can be used after being quoted in a new item.
Further comprising performing the use of a starter packet:
s1: newly building a use project, naming and customizing, and selecting spring boot and JDK versions;
s2: clicking the pom file, inputting an organization name, an item name and a version number which are defined in the last content in the pom file, importing the JavaBean and the dependency which are defined in the first content into a new item, and adding the same dependency in the pom file without changing the rest;
s3: adding a properties configuration file, configuring parameters in the file, assigning values by adding the attributes to the parameters of JavaBean annotation @ configuration properties, and configuring other information such as a port of a new project;
s4: newly adding a program main class, adding @ Enabledput annotation prepared by a hot plug technology on the program main class, opening a jar package at any time by the annotation, adding the annotation, using a frame package without adding and solving, and even if dependence is introduced into a pom file, using the frame package by a new project container;
s5: and adding a new service test class, instantiating the JavaBean class annotation in the shelf package through the @ automatic or @ Resource annotation in the class, and using the method of the JavaBean class defined in the previous content through an instantiation object.
The above steps are simple descriptions of two contents of the development and the usage of the present invention, and the detailed steps and explanations will be described in the embodiment. Similar methods for integrating time, date and the like also exist in back-end development, but the method is strong in pertinence, insufficient in universality and high in learning cost, so that a tool method integration package suitable for respective teams is developed.
Drawings
FIG. 1 is a flow chart of the present invention for custom starter packet content;
FIG. 2 is a flow chart of the usage of the custom starter packet provided by the present invention.
Detailed Description
The technical solutions of the present invention will be described clearly and completely with reference to the accompanying drawings, and it is to be understood that the described contents are a part of the contents of the present invention, and not all of the contents. All other matters which can be obtained by a person skilled in the art without making creative efforts based on the contents of the present invention belong to the protection scope of the present invention.
The method for dependency management and tool integration based on Spring Boot comprises the following steps:
s1: newly building a spring boot project, naming dependencyluteil-starter in a spring-boot-start-xxx naming mode;
s2: introducing spring-boot-autoconfiguration dependency, and calling the annotations @ Configuration properties, @ Configuration and @ Configuration when the following self-defining method is used;
s3: adding dependencies as required, namely firstly using a dependency label, then labeling the dependency label, finally adding dependency dependencies in the dependency label, after adding the dependencies, adding a properties label at the same level as the dependency label, adding version control of each dependency in the label, and taking a value of a version control value in the dependency in a $ { } manner;
s4: creating a JavaBean, customizing the property and method therein, wherein the property is used through properties or YAML files,
after the JavaBean is written, needing to add @ EnableconfigurationProperties to the class, transmitting the class object of the current class, then adding @ configurationProperties annotation, wherein the parameter of the annotation needs to transmit a prefix when in use;
after the JavaBean is configured, a Configuration class needs to be written, an instance object of the JavaBean is newly built, the object is injected into a container, a @ Configuration annotation needs to be added to the Configuration class and can be identified by the container, then the @ Bean annotation is added in the method, and the @ Conditional annotation is added according to the needs;
s5: adding an intermediate mark class, judging whether the shelf packet is injected into the container by judging the existence of the class, then adding an annotation class, realizing that an annotation is named as @ Enabledput, adding @ Target to the annotation class, explaining the use area of the annotation class, wherein @ Retention is used for defining how long the annotation annotated by the annotation is reserved, introducing a class decorated by @ Configuration into an @ Import, marking the class according to the introduced example, and judging the class on the Configuration class of JavaBean;
s6: creating a META-INF directory under the resources resource directory, creating a spring
Spring frame, boot, autoconfiguration = \ +, as many javabeans are configured, all configuration needs to be completed, otherwise, the new project cannot find the category;
s7: the item packing is to pack by using maven, and comprises two steps, firstly, a clear command is used for clearing a compiled file of the item, then an install command is used for packing the item into a shelf package, the item packing step is finished, and the item can be used after being quoted in a new item.
Further comprising performing the use of a starter packet:
s1: newly building a use project, naming the project to be self-defined, and selecting spring boot and JDK versions;
s2: clicking the pom file, inputting an organization name, an item name and a version number which are defined in the last content in the pom file, importing the JavaBean and the dependency which are defined in the first content into a new item, and adding the same dependency in the pom file without changing the rest;
s3: newly adding a properties configuration file, configuring parameters in the file, assigning values by adding attributes to the parameters of JavaBean annotation @ configuration properties as prefixes, and configuring other information such as ports of new projects;
s4: newly adding a program main class, adding @ Enabledput annotation prepared by a hot plug technology on the program main class, opening a jar package at any time by the annotation, adding the annotation, using a frame package without adding and solving, and even if dependence is introduced into a pom file, using the frame package by a new project container;
s5: and adding a new service test class, instantiating the JavaBean class annotation in the shelf package through the @ automatic or @ Resource annotation in the class, and using the method of the JavaBean class defined in the previous content through an instantiation object.
Custom starter bag
As shown in fig. 1, for the flow chart related to the self-defined starter packet content provided by the present invention, packet dependency management is mainly performed through dependency management, a pom file is modified when a packet needs to be added, the modified pom file can be used after being packaged and issued, and an unused packet can be dynamically deleted, so that unnecessary packet import is reduced, and thus, the import shelf packets of a newly-built project are reduced. In addition, there is a problem in that version control is not always performed on the package version input in the new project, or some leaky shelf package version is used, so that a bottom version control is required in the design. After the package is dependent on the new item, the JavaBean needs to be written and configured, so that the new item can use a configuration method, a hot plug technology needs to be carried out on the item, the starter package is used in the new item as required, if needed, the starter package is started on a starting class, if not needed, no processing is carried out, and although the package is imported, the container does not load the class.
The method specifically comprises the following steps:
s1: the method is characterized in that a spring boot project is newly built, a dependency-starter is named, the name mode used by an official is spring-boot-start-xxx name, and the xxx-spring-boot-starter is recommended to be used by the custom bag official, but the custom name is also possible and can be made to belong to a team of the official, for example, the bag is named dependency-starter. In addition, with the organization name defined as com.output, the package version may use default, such as 1.0-snap, or 1.1.1 version control.
S2: the method is characterized in that spring-boot-autoconfiguration dependencies are introduced, the dependencies need to be introduced, the dependencies are automatically configured, and in the following customization method, the following annotations need to be used, such as @ Configuration properties, @ Configuration, @ Conditional, and the like.
S3: adding dependency according to needs, firstly using a dependency label, then labeling dependent labels, finally adding dependency in the dependent labels, and after adding dependency, adding a properties label at the same level as the dependent labels, adding version control of each dependency in the label, wherein the version control value is taken in the dependency in a $ { } mode. In addition, in a plurality of projects, all required packages can be imported only by introducing the current shelf package, and proper modification and deletion can be carried out according to the requirements of the projects, so that personalized expansion is carried out, and time is greatly saved.
S4: a JavaBean of the new method is designed and relevant configuration is carried out, and a time format is converted into an example to give a general idea. In the development process, the class which is not thread-safe is often encountered, the thread-safe is needed, and when the class is used, it is not clear whether the class is used by the JDK, so that the class provided by the JDK needs to be packaged so as to be better used in the development process. Firstly, a JavaBean is newly built, the attribute and the method in the JavaBean are customized, and the attribute in the JavaBean is used through properties or YAML files, so that the attribute needs to be designed well during the customization, and the expansibility of the JavaBean is very high. The method in the JavaBean can be written according to the requirement of the JavaBean, for example, when the time is converted, two parameters of the time format and the time required to be converted are required to be transmitted, and the converted time is returned. How to modify in the concrete process can use another parameter value, thus realize a method of time format conversion.
After the JavaBean is written, @ EnableConfigurationProperties needs to be added to the class, a class object of the current class is transmitted, the annotation has the function of finding the class when the class is automatically assembled so as to be assembled into a container, then @ configurationproperties needs to be added, and a prefix when the annotation is used needs to be transmitted, so that the dynamic configuration of the parameters is realized.
After the JavaBean configuration is completed, a configuration class needs to be written, an instance object of the JavaBean is newly created, and the object is injected into a container, so that the JavaBean can be used by the newly created project, and only @ EnableConfigurationProperties is insufficient, which only plays a role of discovery. The method comprises the steps of adding an @ Configuration annotation to a Configuration class, identifying the Configuration class by a container, adding an @ Bean annotation to the Configuration class, adding an @ Conditional annotation according to needs, and determining whether to add an instance of the class or not according to the needs. Meanwhile, the @ conditional bean needs to be added to the class, the function of the @ conditional bean is to realize a hot plug technology, and the specific operation is in the next step.
S5: the hot plug technology is realized, the effect of this technique is that can be along with the use with whole frame package and open, and is very convenient, adds an annotation on the major classification and just can pour into the container with putting up the package, can use, otherwise just can not pour into, just can not use in the middle of the new project. And adding a middle mark class, and judging whether the shelf packet is injected into the container or not by judging the existence of the class. And then adding an annotation class newly, realizing that an annotation is named as @ Enabledeput, adding @ Target into the annotation class, explaining the use area of the annotation class, defining how long the annotation annotated by the annotation is reserved, introducing a class (introduction Configuration class) modified by @ Configuration into an @ Import, marking the class according to the introduced example, and judging the class on the Configuration class of JavaBean simultaneously, thereby realizing the hot plug technology and realizing random use.
S6: creating a META-INF directory under the resources resource directory, creating a spring
Spring frame, boot, autoconfiguration = \ + (full name of JavaBean class), how many javabeans are configured, and all configuration needs to be completed, otherwise, the new project cannot find the class.
S7: the last step is to package the item, by which it can be published to the server so that multiple items can be used. The item packaging is realized by using maven for packaging, and comprises two steps, namely, firstly, a clean command is used for clearing a compiled file of the item, then, an install command is used for packaging the item into a shelf package, the item packaging step is finished, and the item can be used after being quoted in a newly-built item.
As shown in fig. 2, for the flow chart of using the custom starter packet provided by the present invention, after the custom starter step is completed, the use of the starter packet is performed next, and in this process, the convenience and rapidness of using the rack packet can be fully realized.
S1: newly-built use items, naming can be defined by self, and spring boot and JDK versions are selected
S2: clicking the pom file, inputting an organization name, an item name and a version number which are defined in the previous content in the pom file, and after the shelf package is successfully introduced, the JavaBean and the dependency which are defined in the first content are all introduced into a new item without other changes.
S3: and adding a properties configuration file, configuring parameters in the file, assigning values by adding attributes to the parameters with the prefix of JavaBean annotation @ configuration properties, and configuring other information such as a port of a new project to ensure the healthy operation of the project.
S4: newly adding a program main class, adding @ Enabledput annotation prepared by a hot plug technology on the program main class, and through the annotation, opening a jar package at any time, adding the annotation, using a frame package without injection, and even if dependency is introduced into a pom file, using the frame package by a new project container.
S5: and adding a new service test class, instantiating the JavaBean class annotation in the frame package through the @ automatic annotation or the @ Resource annotation in the class, and then using the method of the JavaBean class defined in the previous content through an instantiation object, so that the application is simplified.
In summary, in the two steps of self-defining the shelf package and using the shelf package, the design and implementation of the self-defined shelf package are difficult, the design needs to be performed according to actual needs, the steps in the whole design are probably clearly taught, and the specific code implementation is not shown. When the user-defined shelf package is used, the using steps are approximately similar to the steps of a new project, only the specific using method is different, so that a programmer can have more time to know about the JavaBean method, and the JavaBean can be used better.
The various elements of this description are presented in a progressive manner, each with a detailed description of its design and use. Any modification, equivalent replacement, or improvement made within the spirit and principle of the present invention should be included in the protection scope of the present invention.
Claims (2)
1. The Spring Boot-based dependency management and tool integration method is characterized by comprising the following steps of:
s1: newly building a spring boot project, naming dependencyluteil-starter in a spring-boot-start-xxx naming mode;
s2: introducing spring-boot-autoconfiguration dependencies, and calling the annotations @ Configuration properties, @ Configuration and @ Configuration in the following custom method;
s3: adding dependencies as required, firstly using a dependency label, then labeling dependent labels, finally adding dependency dependencies in the dependent labels, adding a properties label at the same level as the dependent dependencies after adding the dependencies, adding version control of each dependency in the label, and taking values of version control values in the dependency in a $ { } manner;
s4: creating a JavaBean, customizing the property and method therein, wherein the property is used through properties or YAML files,
after the JavaBean is written, needing to add @ EnableconfigurationProperties to the class, transmitting the class object of the current class, then adding @ configurationProperties annotation, wherein the parameter of the annotation needs to transmit a prefix when in use;
after the JavaBean is configured, a Configuration class needs to be written, an instance object of the JavaBean is newly built, the object is injected into a container, a @ Configuration annotation needs to be added to the Configuration class and can be identified by the container, then the @ Bean annotation is added to the method, and the @ Configuration annotation is added according to the needs;
s5: adding an intermediate mark class, judging whether the shelf packet is injected into the container by judging the existence of the class, then adding an annotation class, realizing that an annotation is named as @ Enabledput, adding @ Target to the annotation class, explaining the use area of the annotation class, wherein @ Retention is used for defining how long the annotation annotated by the annotation is reserved, introducing a class decorated by @ Configuration into an @ Import, marking the class according to the introduced example, and judging the class on the Configuration class of JavaBean;
s6: creating a META-INF directory under the resources resource directory, creating a spring
Spring frame, boot, autoconfiguration = \ +, as many javabeans are configured, all configuration needs to be completed, otherwise, the new project cannot find the category;
s7: the item packaging is realized by using maven for packaging, and comprises two steps, namely, firstly, a clean command is used for clearing a compiled file of the item, then, an install command is used for packaging the item into a shelf package, the item packaging step is finished, and the item can be used after being quoted in a newly-built item.
2. The Spring Boot-based dependency management and tool integration method according to claim 1, further comprising performing a startup package using:
s1: newly building a use project, naming the project to be self-defined, and selecting spring boot and JDK versions;
s2: clicking the pom file, inputting an organization name, an item name and a version number which are defined in the last content in the pom file, importing the JavaBean and the dependency which are defined in the first content into a new item, and adding the same dependency in the pom file without changing the rest;
s3: newly adding a properties configuration file, configuring parameters in the file, assigning values by adding attributes to the parameters of JavaBean annotation @ configuration properties as prefixes, and configuring other information such as ports of new projects;
s4: adding a program main class, adding an @ Enabledput annotation prepared by a hot plug technology to the program main class, opening a jar package at any time by the annotation, adding the annotation, using a rack package without injecting, and even if a dependency is introduced in a pom file, using the rack package by a new project container;
s5: and adding a service test class, instantiating the JavaBean class annotation in the frame package through the @ automatic annotation or the @ Resource annotation in the class, and then using the method of the JavaBean class defined in the previous content through an instantiation object.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202211603752.8A CN115712456A (en) | 2022-12-14 | 2022-12-14 | Dependence management and tool integration method based on springboot |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202211603752.8A CN115712456A (en) | 2022-12-14 | 2022-12-14 | Dependence management and tool integration method based on springboot |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN115712456A true CN115712456A (en) | 2023-02-24 |
Family
ID=85236092
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202211603752.8A Pending CN115712456A (en) | 2022-12-14 | 2022-12-14 | Dependence management and tool integration method based on springboot |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN115712456A (en) |
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN116861439A (en) * | 2023-06-21 | 2023-10-10 | 三峡高科信息技术有限责任公司 | Method for realizing SQL injection prevention of service system in modular manner |
-
2022
- 2022-12-14 CN CN202211603752.8A patent/CN115712456A/en active Pending
Cited By (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN116861439A (en) * | 2023-06-21 | 2023-10-10 | 三峡高科信息技术有限责任公司 | Method for realizing SQL injection prevention of service system in modular manner |
| CN116861439B (en) * | 2023-06-21 | 2024-04-12 | 三峡高科信息技术有限责任公司 | Method for realizing SQL injection prevention of service system in modular manner |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| EP3188009B1 (en) | Development, delivery, deployment and operation of an application | |
| CN110912724B (en) | Parameter-driven automatic service arrangement method and device | |
| CN1811702B (en) | System and method for developing portal applications and automatically deploying them into a portal server application | |
| Van der Hoek | Design-time product line architectures for any-time variability | |
| WO2006118872A2 (en) | Application description language | |
| CN104750528B (en) | A kind of assembly management method and apparatus in Android program | |
| US6658644B1 (en) | Services-based architecture for a telecommunications enterprise | |
| US11893367B2 (en) | Source code conversion from application program interface to policy document | |
| CN113553035A (en) | Design and construction method of universal front-end UI component library | |
| CN115712456A (en) | Dependence management and tool integration method based on springboot | |
| CN107133055A (en) | A kind of method that customized development is realized based on ClassLoader | |
| Jaworski et al. | Expert Python Programming: Become a master in Python by learning coding best practices and advanced programming concepts in Python 3.7 | |
| US9183040B2 (en) | Method for manipulating objects in a SOA registry | |
| CN112835584B (en) | Method for realizing component expansion and management based on REACTNATIVE | |
| CN103678687A (en) | Project establishment method and device based on configuration system | |
| Cornelius | Fearless Cross-Platform Development with Delphi: Expand your Delphi skills to build a new generation of Windows, web, mobile, and IoT applications | |
| Samaan et al. | Task models and interaction models in a multiple user interfaces generation process | |
| CN113688141B (en) | Application function design method and software development platform | |
| CN114281539A (en) | Resource allocation method, system and storage medium | |
| Betts et al. | Dependency injection with unity | |
| CN106293680A (en) | A kind of assembly management method and device | |
| Iglesias | Hands-On Microservices with Kotlin: Build reactive and cloud-native microservices with Kotlin using Spring 5 and Spring Boot 2.0 | |
| Yuen | Mastering Windows Presentation Foundation | |
| US20240129402A1 (en) | Customization framework for native mobile applications | |
| Tuominen et al. | Dynamic branding in mobile applications |
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 |